// Code generated for linux/s390x by 'generator -hide TclGetCStackPtr -hide TclWinCPUID -hide TclpCreateProcess -hide __darwin_check_fd_set --prefix-external=X --prefix-field=F --prefix-static-internal=_ --prefix-static-none=_ --prefix-tagged-struct=T --prefix-tagged-union=T --prefix-typename=T --prefix-undefined=_ -I /home/jnml/src/modernc.org/builder/.exclude/modernc.org/libz/include/linux/s390x -eval-all-macros -extended-errors -ignore-link-errors -ignore-unsupported-alignment -o libtcl.a.go --package-name libtcl9_0 libtcl9.0.a -lz', DO NOT EDIT.

//go:build linux && s390x

package libtcl9_0

import (
	"reflect"
	"unsafe"

	"modernc.org/libc"
	"modernc.org/libz"
)

var _ reflect.Type
var _ unsafe.Pointer

const ABSIZE = 10
const AF_ALG = 38
const AF_APPLETALK = 5
const AF_ASH = 18
const AF_ATMPVC = 8
const AF_ATMSVC = 20
const AF_AX25 = 3
const AF_BLUETOOTH = 31
const AF_BRIDGE = 7
const AF_CAIF = 37
const AF_CAN = 29
const AF_DECnet = 12
const AF_ECONET = 19
const AF_FILE = 1
const AF_IB = 27
const AF_IEEE802154 = 36
const AF_INET = 2
const AF_INET6 = 10
const AF_IPX = 4
const AF_IRDA = 23
const AF_ISDN = 34
const AF_IUCV = 32
const AF_KCM = 41
const AF_KEY = 15
const AF_LLC = 26
const AF_LOCAL = 1
const AF_MAX = 45
const AF_MPLS = 28
const AF_NETBEUI = 13
const AF_NETLINK = 16
const AF_NETROM = 6
const AF_NFC = 39
const AF_PACKET = 17
const AF_PHONET = 35
const AF_PPPOX = 24
const AF_QIPCRTR = 42
const AF_RDS = 21
const AF_ROSE = 11
const AF_ROUTE = 16
const AF_RXRPC = 33
const AF_SECURITY = 14
const AF_SMC = 43
const AF_SNA = 22
const AF_TIPC = 30
const AF_UNIX = 1
const AF_UNSPEC = 0
const AF_VSOCK = 40
const AF_WANPIPE = 25
const AF_X25 = 9
const AF_XDP = 44
const AHEAD = 97
const AI_ADDRCONFIG = 32
const AI_ALL = 16
const AI_CANONNAME = 2
const AI_NUMERICHOST = 4
const AI_NUMERICSERV = 1024
const AI_PASSIVE = 1
const AI_V4MAPPED = 8
const ALLOC_NOBJHIGH = 1200
const ARG_MAX = 131072
const AT_EACCESS = 512
const AT_EMPTY_PATH = 4096
const AT_FDCWD = -100
const AT_NO_AUTOMOUNT = 2048
const AT_RECURSIVE = 32768
const AT_REMOVEDIR = 512
const AT_STATX_DONT_SYNC = 16384
const AT_STATX_FORCE_SYNC = 8192
const AT_STATX_SYNC_AS_STAT = 0
const AT_STATX_SYNC_TYPE = 24576
const AT_SYMLINK_FOLLOW = 1024
const AT_SYMLINK_NOFOLLOW = 256
const BACKR = 16
const BACKREF = 98
const BC_BASE_MAX = 99
const BC_DIM_MAX = 2048
const BC_SCALE_MAX = 99
const BC_STRING_MAX = 1000
const BEHIND = 114
const BIG_ENDIAN = 4321
const BUFSIZ = 1024
const BUILD_tcl = 1
const BUS_ADRALN = 1
const BUS_ADRERR = 2
const BUS_MCEERR_AO = 5
const BUS_MCEERR_AR = 4
const BUS_OBJERR = 3
const BYTBITS = 8
const BYTE_ORDER = 4321
const BYTMASK = 255
const BYTTAB = 256
const CANBSIZ = 255
const CANCELED = 4096
const CAP = 8
const CCLASS = 67
const CHARCLASS_NAME_MAX = 14
const CHAR_BIT = 8
const CHAR_MAX = 255
const CHAR_MIN = 0
const CHRBITS = 32
const CHR_MAX = 1114111
const CHR_MIN = 0
const CLD_CONTINUED = 6
const CLD_DUMPED = 3
const CLD_EXITED = 1
const CLD_KILLED = 2
const CLD_STOPPED = 5
const CLD_TRAPPED = 4
const CLL_END = -1
const CLOCKS_PER_SEC = 1000000
const CLOCK_BOOTTIME = 7
const CLOCK_BOOTTIME_ALARM = 9
const CLOCK_MONOTONIC = 1
const CLOCK_MONOTONIC_COARSE = 6
const CLOCK_MONOTONIC_RAW = 4
const CLOCK_PROCESS_CPUTIME_ID = 2
const CLOCK_REALTIME = 0
const CLOCK_REALTIME_ALARM = 8
const CLOCK_REALTIME_COARSE = 5
const CLOCK_SGI_CYCLE = 10
const CLOCK_TAI = 11
const CLOCK_THREAD_CPUTIME_ID = 3
const CLONE_CHILD_CLEARTID = 2097152
const CLONE_CHILD_SETTID = 16777216
const CLONE_DETACHED = 4194304
const CLONE_FILES = 1024
const CLONE_FS = 512
const CLONE_IO = 2147483648
const CLONE_NEWCGROUP = 33554432
const CLONE_NEWIPC = 134217728
const CLONE_NEWNET = 1073741824
const CLONE_NEWNS = 131072
const CLONE_NEWPID = 536870912
const CLONE_NEWTIME = 128
const CLONE_NEWUSER = 268435456
const CLONE_NEWUTS = 67108864
const CLONE_PARENT = 32768
const CLONE_PARENT_SETTID = 1048576
const CLONE_PIDFD = 4096
const CLONE_PTRACE = 8192
const CLONE_SETTLS = 524288
const CLONE_SIGHAND = 2048
const CLONE_SYSVSEM = 262144
const CLONE_THREAD = 65536
const CLONE_UNTRACED = 8388608
const CLONE_VFORK = 16384
const CLONE_VM = 256
const CMD_COMPILES_EXPANDED = 8
const CMD_DEAD = 64
const CMD_DYING = 1
const CMD_HAS_EXEC_TRACES = 4
const CMD_REDEF_IN_PROGRESS = 16
const CMD_TRACE_ACTIVE = 2
const CMD_VIA_RESOLVER = 32
const CMMAGIC = 2166
const CNFA_NOPROGRESS = 1
const COLLEL = 73
const COLL_WEIGHTS_MAX = 2
const COLORLESS = -1
const COMPATIBLE = 3
const CONST86 = 0
const CPU_SETSIZE = 1024
const CSIGNAL = 255
const DBL_DECIMAL_DIG = 17
const DBL_DIG = 15
const DBL_EPSILON = 0
const DBL_HAS_SUBNORM = 1
const DBL_MANT_DIG = 53
const DBL_MAX = 0
const DBL_MAX_10_EXP = 308
const DBL_MAX_EXP = 1024
const DBL_MIN = 0
const DBL_MIN_10_EXP = -307
const DBL_MIN_EXP = -1021
const DBL_TRUE_MIN = 0
const DECIMAL_DIG = 17
const DELAYTIMER_MAX = 2147483647
const DELETED = 1
const DEV_BSIZE = 512
const DICT_PATH_CREATE = 5
const DICT_PATH_EXISTS = 2
const DICT_PATH_READ = 0
const DICT_PATH_UPDATE = 1
const DN_ACCESS = 1
const DN_ATTRIB = 32
const DN_CREATE = 4
const DN_DELETE = 8
const DN_MODIFY = 2
const DN_MULTISHOT = 2147483648
const DN_RENAME = 16
const DONT_COMPILE_CMDS_INLINE = 32
const DT_BLK = 6
const DT_CHR = 2
const DT_DIR = 4
const DT_FIFO = 1
const DT_LNK = 10
const DT_REG = 8
const DT_SOCK = 12
const DT_UNKNOWN = 0
const DT_WHT = 14
const DUPINF = 256
const DUPMAX = 255
const DUPTRAVERSE_MAX_DEPTH = 15000
const E2BIG = 7
const EACCES = 13
const EADDRINUSE = 98
const EADDRNOTAVAIL = 99
const EADV = 68
const EAFNOSUPPORT = 97
const EAGAIN = 11
const EAI_ADDRFAMILY = -9
const EAI_AGAIN = -3
const EAI_ALLDONE = -103
const EAI_BADFLAGS = -1
const EAI_CANCELED = -101
const EAI_FAIL = -4
const EAI_FAMILY = -6
const EAI_IDN_ENCODE = -105
const EAI_INPROGRESS = -100
const EAI_INTR = -104
const EAI_MEMORY = -10
const EAI_NODATA = -5
const EAI_NONAME = -2
const EAI_NOTCANCELED = -102
const EAI_OVERFLOW = -12
const EAI_SERVICE = -8
const EAI_SOCKTYPE = -7
const EAI_SYSTEM = -11
const EALREADY = 114
const EBADE = 52
const EBADF = 9
const EBADFD = 77
const EBADMSG = 74
const EBADR = 53
const EBADRQC = 56
const EBADSLT = 57
const EBFONT = 59
const EBUSY = 16
const ECANCELED = 125
const ECHILD = 10
const ECHRNG = 44
const ECLASS = 69
const ECOMM = 70
const ECONNABORTED = 103
const ECONNREFUSED = 111
const ECONNRESET = 104
const EDEADLK = 35
const EDEADLOCK = 35
const EDESTADDRREQ = 89
const EDOM = 33
const EDOTDOT = 73
const EDQUOT = 122
const EEXIST = 17
const EFAULT = 14
const EFBIG = 27
const EHOSTDOWN = 112
const EHOSTUNREACH = 113
const EHWPOISON = 133
const EIDRM = 43
const EILSEQ = 84
const EINPROGRESS = 115
const EINTR = 4
const EINVAL = 22
const EIO = 5
const EISCONN = 106
const EISDIR = 21
const EISNAM = 120
const EKEYEXPIRED = 127
const EKEYREJECTED = 129
const EKEYREVOKED = 128
const EL2HLT = 51
const EL2NSYNC = 45
const EL3HLT = 46
const EL3RST = 47
const ELIBACC = 79
const ELIBBAD = 80
const ELIBEXEC = 83
const ELIBMAX = 82
const ELIBSCN = 81
const ELNRNG = 48
const ELOOP = 40
const EMEDIUMTYPE = 124
const EMFILE = 24
const EMLINK = 31
const EMPTY = 110
const EMSGSIZE = 90
const EMULTIHOP = 72
const ENAMETOOLONG = 36
const ENAVAIL = 119
const ENCODING_PROFILE_MASK = 4278190080
const END = 88
const ENETDOWN = 100
const ENETRESET = 102
const ENETUNREACH = 101
const ENFILE = 23
const ENOANO = 55
const ENOBUFS = 105
const ENOCSI = 50
const ENODATA = 61
const ENODEV = 19
const ENOENT = 2
const ENOEXEC = 8
const ENOKEY = 126
const ENOLCK = 37
const ENOLINK = 67
const ENOMEDIUM = 123
const ENOMEM = 12
const ENOMSG = 42
const ENONET = 64
const ENOPKG = 65
const ENOPROTOOPT = 92
const ENOSPC = 28
const ENOSR = 63
const ENOSTR = 60
const ENOSYS = 38
const ENOTBLK = 15
const ENOTCONN = 107
const ENOTDIR = 20
const ENOTEMPTY = 39
const ENOTNAM = 118
const ENOTRECOVERABLE = 131
const ENOTSOCK = 88
const ENOTSUP = 95
const ENOTTY = 25
const ENOTUNIQ = 76
const ENSEMBLE_COMPILE = 4
const ENSEMBLE_DEAD = 1
const ENXIO = 6
const EOPNOTSUPP = 95
const EOS = 101
const EOVERFLOW = 75
const EOWNERDEAD = 130
const EPERM = 1
const EPFNOSUPPORT = 96
const EPIPE = 32
const EPROTO = 71
const EPROTONOSUPPORT = 93
const EPROTOTYPE = 91
const ERANGE = 34
const EREMCHG = 78
const EREMOTE = 66
const EREMOTEIO = 121
const ERESTART = 85
const ERFKILL = 132
const EROFS = 30
const ERR_ALREADY_LOGGED = 4
const ERR_LEGACY_COPY = 2048
const ESHUTDOWN = 108
const ESOCKTNOSUPPORT = 94
const ESPIPE = 29
const ESRCH = 3
const ESRMNT = 69
const ESTALE = 116
const ESTRPIPE = 86
const ETIME = 62
const ETIMEDOUT = 110
const ETOOMANYREFS = 109
const ETXTBSY = 26
const EUCLEAN = 117
const EUNATCH = 49
const EUSERS = 87
const EWOULDBLOCK = 11
const EXDEV = 18
const EXFULL = 54
const EXIT_FAILURE = 1
const EXIT_SUCCESS = 0
const EXPR_NEST_MAX = 32
const EXTERN = 0
const FALLOC_FL_KEEP_SIZE = 1
const FALLOC_FL_PUNCH_HOLE = 2
const FAPPEND = 1024
const FASYNC = 8192
const FD_CLOEXEC = 1
const FD_SETSIZE = 1024
const FFSYNC = 1052672
const FILENAME_MAX = 4096
const FILESIZEBITS = 64
const FLT_DECIMAL_DIG = 9
const FLT_DIG = 6
const FLT_EPSILON = 0
const FLT_EVAL_METHOD = 0
const FLT_HAS_SUBNORM = 1
const FLT_MANT_DIG = 24
const FLT_MAX = 0
const FLT_MAX_10_EXP = 38
const FLT_MAX_EXP = 128
const FLT_MIN = 0
const FLT_MIN_10_EXP = -37
const FLT_MIN_EXP = -125
const FLT_RADIX = 2
const FLT_ROUNDS = 0
const FLT_TRUE_MIN = 0
const FNDELAY = 2048
const FNONBLOCK = 2048
const FOPEN_MAX = 1000
const FPE_FLTDIV = 3
const FPE_FLTINV = 7
const FPE_FLTOVF = 4
const FPE_FLTRES = 6
const FPE_FLTSUB = 8
const FPE_FLTUND = 5
const FPE_INTDIV = 1
const FPE_INTOVF = 2
const FRAME_IS_LAMBDA = 2
const FRAME_IS_METHOD = 4
const FRAME_IS_OO_DEFINE = 8
const FRAME_IS_PRIVATE_DEFINE = 16
const FRAME_IS_PROC = 1
const FREECOL = 1
const FREESTATE = -1
const F_ADD_SEALS = 1033
const F_CANCELLK = 1029
const F_DUPFD = 0
const F_DUPFD_CLOEXEC = 1030
const F_GETFD = 1
const F_GETFL = 3
const F_GETLEASE = 1025
const F_GETLK = 5
const F_GETLK64 = 5
const F_GETOWN = 9
const F_GETOWNER_UIDS = 17
const F_GETOWN_EX = 16
const F_GETPIPE_SZ = 1032
const F_GETSIG = 11
const F_GET_FILE_RW_HINT = 1037
const F_GET_RW_HINT = 1035
const F_GET_SEALS = 1034
const F_LOCK = 1
const F_NOTIFY = 1026
const F_OFD_GETLK = 36
const F_OFD_SETLK = 37
const F_OFD_SETLKW = 38
const F_OK = 0
const F_OWNER_GID = 2
const F_OWNER_PGRP = 2
const F_OWNER_PID = 1
const F_OWNER_TID = 0
const F_RDLCK = 0
const F_SEAL_FUTURE_WRITE = 16
const F_SEAL_GROW = 4
const F_SEAL_SEAL = 1
const F_SEAL_SHRINK = 2
const F_SEAL_WRITE = 8
const F_SETFD = 2
const F_SETFL = 4
const F_SETLEASE = 1024
const F_SETLK = 6
const F_SETLK64 = 6
const F_SETLKW = 7
const F_SETLKW64 = 7
const F_SETOWN = 8
const F_SETOWN_EX = 15
const F_SETPIPE_SZ = 1031
const F_SETSIG = 10
const F_SET_FILE_RW_HINT = 1038
const F_SET_RW_HINT = 1036
const F_TEST = 3
const F_TLOCK = 2
const F_ULOCK = 0
const F_UNLCK = 2
const F_WRLCK = 1
const GUTSMAGIC = 65241
const HASLACONS = 1
const HAVE_BLKCNT_T = 1
const HAVE_CAST_TO_UNION = 1
const HAVE_CFMAKERAW = 1
const HAVE_DECL_GETHOSTBYADDR_R = 1
const HAVE_DECL_GETHOSTBYNAME_R = 1
const HAVE_DECL_PTHREAD_MUTEX_RECURSIVE = 1
const HAVE_FREEADDRINFO = 1
const HAVE_GAI_STRERROR = 1
const HAVE_GETADDRINFO = 1
const HAVE_GETCWD = 1
const HAVE_GETGRGID_R = 1
const HAVE_GETGRGID_R_5 = 1
const HAVE_GETGRNAM_R = 1
const HAVE_GETGRNAM_R_5 = 1
const HAVE_GETHOSTBYADDR_R = 1
const HAVE_GETHOSTBYADDR_R_8 = 1
const HAVE_GETHOSTBYNAME_R = 1
const HAVE_GETHOSTBYNAME_R_6 = 1
const HAVE_GETNAMEINFO = 1
const HAVE_GETPWNAM_R = 1
const HAVE_GETPWNAM_R_5 = 1
const HAVE_GETPWUID_R = 1
const HAVE_GETPWUID_R_5 = 1
const HAVE_GMTIME_R = 1
const HAVE_HIDDEN = 1
const HAVE_INTPTR_T = 1
const HAVE_INTTYPES_H = 1
const HAVE_LANGINFO = 1
const HAVE_LOCALTIME_R = 1
const HAVE_MKSTEMP = 1
const HAVE_MKSTEMPS = 1
const HAVE_POSIX_SPAWNATTR_SETFLAGS = 1
const HAVE_POSIX_SPAWNP = 1
const HAVE_POSIX_SPAWN_FILE_ACTIONS_ADDDUP2 = 1
const HAVE_PSELECT = 1
const HAVE_PTHREAD_ATFORK = 1
const HAVE_PTHREAD_ATTR_SETSTACKSIZE = 1
const HAVE_SIGNED_CHAR = 1
const HAVE_STDBOOL_H = 1
const HAVE_STDINT_H = 1
const HAVE_STDIO_H = 1
const HAVE_STDLIB_H = 1
const HAVE_STRINGS_H = 1
const HAVE_STRING_H = 1
const HAVE_STRUCT_ADDRINFO = 1
const HAVE_STRUCT_IN6_ADDR = 1
const HAVE_STRUCT_SOCKADDR_IN6 = 1
const HAVE_STRUCT_SOCKADDR_STORAGE = 1
const HAVE_STRUCT_STAT_ST_BLKSIZE = 1
const HAVE_STRUCT_STAT_ST_BLOCKS = 1
const HAVE_STRUCT_STAT_ST_RDEV = 1
const HAVE_SYS_IOCTL_H = 1
const HAVE_SYS_PARAM_H = 1
const HAVE_SYS_STAT_H = 1
const HAVE_SYS_TIME_H = 1
const HAVE_SYS_TYPES_H = 1
const HAVE_TIMEZONE_VAR = 1
const HAVE_TM_GMTOFF = 1
const HAVE_UINTPTR_T = 1
const HAVE_UNISTD_H = 1
const HAVE_VFORK = 1
const HAVE_WAITPID = 1
const HOST_NAME_MAX = 255
const HOST_NOT_FOUND = 1
const ILL_BADSTK = 8
const ILL_COPROC = 7
const ILL_ILLADR = 3
const ILL_ILLOPC = 1
const ILL_ILLOPN = 2
const ILL_ILLTRP = 4
const ILL_PRVOPC = 5
const ILL_PRVREG = 6
const INCOMPATIBLE = 1
const INET6_ADDRSTRLEN = 46
const INET_ADDRSTRLEN = 16
const INF = 3
const INT16_MAX = 32767
const INT16_MIN = -32768
const INT32_MAX = 2147483647
const INT32_MIN = -2147483648
const INT64_MAX = 9223372036854775807
const INT64_MIN = -9223372036854775808
const INT8_MAX = 127
const INT8_MIN = -128
const INTERP_ALTERNATE_WRONG_ARGS = 1024
const INTERP_DEBUG_FRAME = 16
const INTERP_TRACE_IN_PROGRESS = 512
const INTMAX_MAX = 9223372036854775807
const INTMAX_MIN = -9223372036854775808
const INTPTR_MAX = 9223372036854775807
const INTPTR_MIN = -9223372036854775808
const INT_FAST16_MAX = 2147483647
const INT_FAST16_MIN = -2147483648
const INT_FAST32_MAX = 2147483647
const INT_FAST32_MIN = -2147483648
const INT_FAST64_MAX = 9223372036854775807
const INT_FAST64_MIN = -9223372036854775808
const INT_FAST8_MAX = 127
const INT_FAST8_MIN = -128
const INT_LEAST16_MAX = 32767
const INT_LEAST16_MIN = -32768
const INT_LEAST32_MAX = 2147483647
const INT_LEAST32_MIN = -2147483648
const INT_LEAST64_MAX = 9223372036854775807
const INT_LEAST64_MIN = -9223372036854775808
const INT_LEAST8_MAX = 127
const INT_LEAST8_MIN = -128
const INT_MAX = 2147483647
const INT_MIN = -2147483648
const INUSE = 64
const IN_CLASSA_HOST = 16777215
const IN_CLASSA_MAX = 128
const IN_CLASSA_NET = 4278190080
const IN_CLASSA_NSHIFT = 24
const IN_CLASSB_HOST = 65535
const IN_CLASSB_MAX = 65536
const IN_CLASSB_NET = 4294901760
const IN_CLASSB_NSHIFT = 16
const IN_CLASSC_HOST = 255
const IN_CLASSC_NET = 4294967040
const IN_CLASSC_NSHIFT = 8
const IN_LOOPBACKNET = 127
const IOV_MAX = 1024
const IPPORT_RESERVED = 1024
const IPPROTO_AH = 51
const IPPROTO_BEETPH = 94
const IPPROTO_COMP = 108
const IPPROTO_DCCP = 33
const IPPROTO_DSTOPTS = 60
const IPPROTO_EGP = 8
const IPPROTO_ENCAP = 98
const IPPROTO_ESP = 50
const IPPROTO_ETHERNET = 143
const IPPROTO_FRAGMENT = 44
const IPPROTO_GRE = 47
const IPPROTO_HOPOPTS = 0
const IPPROTO_ICMP = 1
const IPPROTO_ICMPV6 = 58
const IPPROTO_IDP = 22
const IPPROTO_IGMP = 2
const IPPROTO_IP = 0
const IPPROTO_IPIP = 4
const IPPROTO_IPV6 = 41
const IPPROTO_MAX = 263
const IPPROTO_MH = 135
const IPPROTO_MPLS = 137
const IPPROTO_MPTCP = 262
const IPPROTO_MTP = 92
const IPPROTO_NONE = 59
const IPPROTO_PIM = 103
const IPPROTO_PUP = 12
const IPPROTO_RAW = 255
const IPPROTO_ROUTING = 43
const IPPROTO_RSVP = 46
const IPPROTO_SCTP = 132
const IPPROTO_TCP = 6
const IPPROTO_TP = 29
const IPPROTO_UDP = 17
const IPPROTO_UDPLITE = 136
const IPV6_2292DSTOPTS = 4
const IPV6_2292HOPLIMIT = 8
const IPV6_2292HOPOPTS = 3
const IPV6_2292PKTINFO = 2
const IPV6_2292PKTOPTIONS = 6
const IPV6_2292RTHDR = 5
const IPV6_ADDRFORM = 1
const IPV6_ADDR_PREFERENCES = 72
const IPV6_ADD_MEMBERSHIP = 20
const IPV6_AUTHHDR = 10
const IPV6_AUTOFLOWLABEL = 70
const IPV6_CHECKSUM = 7
const IPV6_DONTFRAG = 62
const IPV6_DROP_MEMBERSHIP = 21
const IPV6_DSTOPTS = 59
const IPV6_FREEBIND = 78
const IPV6_HDRINCL = 36
const IPV6_HOPLIMIT = 52
const IPV6_HOPOPTS = 54
const IPV6_IPSEC_POLICY = 34
const IPV6_JOIN_ANYCAST = 27
const IPV6_JOIN_GROUP = 20
const IPV6_LEAVE_ANYCAST = 28
const IPV6_LEAVE_GROUP = 21
const IPV6_MINHOPCOUNT = 73
const IPV6_MTU = 24
const IPV6_MTU_DISCOVER = 23
const IPV6_MULTICAST_ALL = 29
const IPV6_MULTICAST_HOPS = 18
const IPV6_MULTICAST_IF = 17
const IPV6_MULTICAST_LOOP = 19
const IPV6_NEXTHOP = 9
const IPV6_ORIGDSTADDR = 74
const IPV6_PATHMTU = 61
const IPV6_PKTINFO = 50
const IPV6_PMTUDISC_DO = 2
const IPV6_PMTUDISC_DONT = 0
const IPV6_PMTUDISC_INTERFACE = 4
const IPV6_PMTUDISC_OMIT = 5
const IPV6_PMTUDISC_PROBE = 3
const IPV6_PMTUDISC_WANT = 1
const IPV6_PREFER_SRC_CGA = 8
const IPV6_PREFER_SRC_COA = 4
const IPV6_PREFER_SRC_HOME = 1024
const IPV6_PREFER_SRC_NONCGA = 2048
const IPV6_PREFER_SRC_PUBLIC = 2
const IPV6_PREFER_SRC_PUBTMP_DEFAULT = 256
const IPV6_PREFER_SRC_TMP = 1
const IPV6_RECVDSTOPTS = 58
const IPV6_RECVERR = 25
const IPV6_RECVFRAGSIZE = 77
const IPV6_RECVHOPLIMIT = 51
const IPV6_RECVHOPOPTS = 53
const IPV6_RECVORIGDSTADDR = 74
const IPV6_RECVPATHMTU = 60
const IPV6_RECVPKTINFO = 49
const IPV6_RECVRTHDR = 56
const IPV6_RECVTCLASS = 66
const IPV6_ROUTER_ALERT = 22
const IPV6_ROUTER_ALERT_ISOLATE = 30
const IPV6_RTHDR = 57
const IPV6_RTHDRDSTOPTS = 55
const IPV6_RTHDR_LOOSE = 0
const IPV6_RTHDR_STRICT = 1
const IPV6_RTHDR_TYPE_0 = 0
const IPV6_RXDSTOPTS = 59
const IPV6_RXHOPOPTS = 54
const IPV6_TCLASS = 67
const IPV6_TRANSPARENT = 75
const IPV6_UNICAST_HOPS = 16
const IPV6_UNICAST_IF = 76
const IPV6_V6ONLY = 26
const IPV6_XFRM_POLICY = 35
const IP_ADD_MEMBERSHIP = 35
const IP_ADD_SOURCE_MEMBERSHIP = 39
const IP_BIND_ADDRESS_NO_PORT = 24
const IP_BLOCK_SOURCE = 38
const IP_CHECKSUM = 23
const IP_DEFAULT_MULTICAST_LOOP = 1
const IP_DEFAULT_MULTICAST_TTL = 1
const IP_DROP_MEMBERSHIP = 36
const IP_DROP_SOURCE_MEMBERSHIP = 40
const IP_FREEBIND = 15
const IP_HDRINCL = 3
const IP_IPSEC_POLICY = 16
const IP_MAX_MEMBERSHIPS = 20
const IP_MINTTL = 21
const IP_MSFILTER = 41
const IP_MTU = 14
const IP_MTU_DISCOVER = 10
const IP_MULTICAST_ALL = 49
const IP_MULTICAST_IF = 32
const IP_MULTICAST_LOOP = 34
const IP_MULTICAST_TTL = 33
const IP_NODEFRAG = 22
const IP_OPTIONS = 4
const IP_ORIGDSTADDR = 20
const IP_PASSSEC = 18
const IP_PKTINFO = 8
const IP_PKTOPTIONS = 9
const IP_PMTUDISC = 10
const IP_PMTUDISC_DO = 2
const IP_PMTUDISC_DONT = 0
const IP_PMTUDISC_INTERFACE = 4
const IP_PMTUDISC_OMIT = 5
const IP_PMTUDISC_PROBE = 3
const IP_PMTUDISC_WANT = 1
const IP_RECVERR = 11
const IP_RECVERR_RFC4884 = 26
const IP_RECVFRAGSIZE = 25
const IP_RECVOPTS = 6
const IP_RECVORIGDSTADDR = 20
const IP_RECVRETOPTS = 7
const IP_RECVTOS = 13
const IP_RECVTTL = 12
const IP_RETOPTS = 7
const IP_ROUTER_ALERT = 5
const IP_TOS = 1
const IP_TRANSPARENT = 19
const IP_TTL = 2
const IP_UNBLOCK_SOURCE = 37
const IP_UNICAST_IF = 50
const IP_XFRM_POLICY = 17
const ITIMER_PROF = 2
const ITIMER_REAL = 0
const ITIMER_VIRTUAL = 1
const LACON = 76
const LC_ALL = 6
const LC_ALL_MASK = 2147483647
const LC_COLLATE = 3
const LC_COLLATE_MASK = 8
const LC_CTYPE = 0
const LC_CTYPE_MASK = 1
const LC_GLOBAL_LOCALE = -1
const LC_MESSAGES = 5
const LC_MESSAGES_MASK = 32
const LC_MONETARY = 4
const LC_MONETARY_MASK = 16
const LC_NUMERIC = 1
const LC_NUMERIC_MASK = 2
const LC_TIME = 2
const LC_TIME_MASK = 4
const LDBL_DECIMAL_DIG = 17
const LDBL_DIG = 15
const LDBL_EPSILON = 0
const LDBL_HAS_SUBNORM = 1
const LDBL_MANT_DIG = 53
const LDBL_MAX = 0
const LDBL_MAX_10_EXP = 308
const LDBL_MAX_EXP = 1024
const LDBL_MIN = 0
const LDBL_MIN_10_EXP = -307
const LDBL_MIN_EXP = -1021
const LDBL_TRUE_MIN = 0
const LINE_MAX = 4096
const LISTSTORE_CANONICAL = 1
const LIST_SPAN_THRESHOLD = 101
const LITTLE_ENDIAN = 1234
const LLONG_MAX = 9223372036854775807
const LLONG_MIN = -9223372036854775808
const LOCK_EX = 2
const LOCK_NB = 4
const LOCK_SH = 1
const LOCK_UN = 8
const LOGIN_NAME_MAX = 256
const LONGER = 1
const LONG_BIT = 64
const LONG_MAX = 9223372036854775807
const LONG_MIN = -9223372036854775808
const L_BBND = 5
const L_BRACK = 6
const L_BRE = 2
const L_CCL = 9
const L_CEL = 7
const L_EBND = 4
const L_ECL = 8
const L_ERE = 1
const L_INCR = 1
const L_Q = 3
const L_SET = 0
const L_XTND = 2
const L_ctermid = 20
const L_cuserid = 20
const L_tmpnam = 20
const MAXHOSTNAMELEN = 64
const MAXNAMLEN = 255
const MAXPATHLEN = 4096
const MAXSYMLINKS = 20
const MAX_COLOR = 32767
const MAX_HANDLE_SZ = 128
const MAX_NESTING_DEPTH = 1000
const MB_CUR_MAX = 0
const MB_LEN_MAX = 4
const MCAST_BLOCK_SOURCE = 43
const MCAST_EXCLUDE = 0
const MCAST_INCLUDE = 1
const MCAST_JOIN_GROUP = 42
const MCAST_JOIN_SOURCE_GROUP = 46
const MCAST_LEAVE_GROUP = 45
const MCAST_LEAVE_SOURCE_GROUP = 47
const MCAST_MSFILTER = 48
const MCAST_UNBLOCK_SOURCE = 44
const MINSIGSTKSZ = 4096
const MIXED = 4
const MP_FIXED_CUTOFFS = 1
const MP_PREC = 4
const MQ_PRIO_MAX = 32768
const MSG_BATCH = 262144
const MSG_CMSG_CLOEXEC = 1073741824
const MSG_CONFIRM = 2048
const MSG_CTRUNC = 8
const MSG_DONTROUTE = 4
const MSG_DONTWAIT = 64
const MSG_EOR = 128
const MSG_ERRQUEUE = 8192
const MSG_FASTOPEN = 536870912
const MSG_FIN = 512
const MSG_MORE = 32768
const MSG_NOSIGNAL = 16384
const MSG_OOB = 1
const MSG_PEEK = 2
const MSG_PROXY = 16
const MSG_RST = 4096
const MSG_SYN = 1024
const MSG_TRUNC = 32
const MSG_WAITALL = 256
const MSG_WAITFORONE = 65536
const MSG_ZEROCOPY = 67108864
const NAME_MAX = 255
const NBBY = 8
const NBYTS = 4
const NCARGS = 131072
const NDEBUG = 1
const NGROUPS = 32
const NGROUPS_MAX = 32
const NI_DGRAM = 16
const NI_MAXHOST = 255
const NI_MAXSERV = 32
const NI_NAMEREQD = 8
const NI_NOFQDN = 4
const NI_NUMERICHOST = 1
const NI_NUMERICSCOPE = 256
const NI_NUMERICSERV = 2
const NL_ARGMAX = 9
const NL_LANGMAX = 32
const NL_MSGMAX = 32767
const NL_NMAX = 16
const NL_SETMAX = 255
const NL_TEXTMAX = 2048
const NOCELT = -1
const NOFILE = 256
const NOGROUP = -1
const NOPROP = 3
const NOSUB = -1
const NOTREACHED = 0
const NO_ADDRESS = 4
const NO_DATA = 4
const NO_RECOVERY = 3
const NO_UNION_WAIT = 1
const NRE_ENABLE_ASSERTS = 0
const NRE_USE_SMALL_ALLOC = 1
const NSIG = 65
const NS_DEAD = 2
const NS_DYING = 1
const NS_KILLED = 4
const NS_SUPPRESS_COMPILATION = 8
const NS_TEARDOWN = 4
const NUM_STATIC_TOKENS = 20
const NWBDRY = 87
const NZERO = 20
const O_ACCMODE = 2097155
const O_APPEND = 1024
const O_ASYNC = 8192
const O_CLOEXEC = 524288
const O_CREAT = 64
const O_DIRECT = 16384
const O_DIRECTORY = 65536
const O_DSYNC = 4096
const O_EXCL = 128
const O_EXEC = 2097152
const O_LARGEFILE = 32768
const O_NDELAY = 2048
const O_NOATIME = 262144
const O_NOCTTY = 256
const O_NOFOLLOW = 131072
const O_NONBLOCK = 2048
const O_PATH = 2097152
const O_RDONLY = 0
const O_RDWR = 2
const O_RSYNC = 1052672
const O_SEARCH = 2097152
const O_SYNC = 1052672
const O_TMPFILE = 4259840
const O_TRUNC = 512
const O_TTY_INIT = 0
const O_WRONLY = 1
const PACKAGE_BUGREPORT = ""
const PACKAGE_NAME = "tcl"
const PACKAGE_STRING = "tcl 9.0"
const PACKAGE_TARNAME = "tcl"
const PACKAGE_URL = ""
const PACKAGE_VERSION = "9.0"
const PAGESIZE = 4096
const PAGE_SIZE = 4096
const PATH_MAX = 4096
const PDP_ENDIAN = 3412
const PF_ALG = 38
const PF_APPLETALK = 5
const PF_ASH = 18
const PF_ATMPVC = 8
const PF_ATMSVC = 20
const PF_AX25 = 3
const PF_BLUETOOTH = 31
const PF_BRIDGE = 7
const PF_CAIF = 37
const PF_CAN = 29
const PF_DECnet = 12
const PF_ECONET = 19
const PF_FILE = 1
const PF_IB = 27
const PF_IEEE802154 = 36
const PF_INET = 2
const PF_INET6 = 10
const PF_IPX = 4
const PF_IRDA = 23
const PF_ISDN = 34
const PF_IUCV = 32
const PF_KCM = 41
const PF_KEY = 15
const PF_LLC = 26
const PF_LOCAL = 1
const PF_MAX = 45
const PF_MPLS = 28
const PF_NETBEUI = 13
const PF_NETLINK = 16
const PF_NETROM = 6
const PF_NFC = 39
const PF_PACKET = 17
const PF_PHONET = 35
const PF_PPPOX = 24
const PF_QIPCRTR = 42
const PF_RDS = 21
const PF_ROSE = 11
const PF_ROUTE = 16
const PF_RXRPC = 33
const PF_SECURITY = 14
const PF_SMC = 43
const PF_SNA = 22
const PF_TIPC = 30
const PF_UNIX = 1
const PF_UNSPEC = 0
const PF_VSOCK = 40
const PF_WANPIPE = 25
const PF_X25 = 9
const PF_XDP = 44
const PIPE_BUF = 4096
const PLAIN = 112
const POLL_ERR = 4
const POLL_HUP = 6
const POLL_IN = 1
const POLL_MSG = 3
const POLL_OUT = 2
const POLL_PRI = 5
const POSIX_CLOSE_RESTART = 0
const POSIX_FADV_DONTNEED = 6
const POSIX_FADV_NOREUSE = 7
const POSIX_FADV_NORMAL = 0
const POSIX_FADV_RANDOM = 1
const POSIX_FADV_SEQUENTIAL = 2
const POSIX_FADV_WILLNEED = 3
const PREFER = 80
const PRIO_MAX = 20
const PRIO_MIN = -20
const PRIO_PGRP = 1
const PRIO_PROCESS = 0
const PRIO_USER = 2
const PRIX16 = "X"
const PRIX32 = "X"
const PRIX8 = "X"
const PRIXFAST16 = "X"
const PRIXFAST32 = "X"
const PRIXFAST8 = "X"
const PRIXLEAST16 = "X"
const PRIXLEAST32 = "X"
const PRIXLEAST8 = "X"
const PRId16 = "d"
const PRId32 = "d"
const PRId8 = "d"
const PRIdFAST16 = "d"
const PRIdFAST32 = "d"
const PRIdFAST8 = "d"
const PRIdLEAST16 = "d"
const PRIdLEAST32 = "d"
const PRIdLEAST8 = "d"
const PRIi16 = "i"
const PRIi32 = "i"
const PRIi8 = "i"
const PRIiFAST16 = "i"
const PRIiFAST32 = "i"
const PRIiFAST8 = "i"
const PRIiLEAST16 = "i"
const PRIiLEAST32 = "i"
const PRIiLEAST8 = "i"
const PRIo16 = "o"
const PRIo32 = "o"
const PRIo8 = "o"
const PRIoFAST16 = "o"
const PRIoFAST32 = "o"
const PRIoFAST8 = "o"
const PRIoLEAST16 = "o"
const PRIoLEAST32 = "o"
const PRIoLEAST8 = "o"
const PRIu16 = "u"
const PRIu32 = "u"
const PRIu8 = "u"
const PRIuFAST16 = "u"
const PRIuFAST32 = "u"
const PRIuFAST8 = "u"
const PRIuLEAST16 = "u"
const PRIuLEAST32 = "u"
const PRIuLEAST8 = "u"
const PRIx16 = "x"
const PRIx32 = "x"
const PRIx8 = "x"
const PRIxFAST16 = "x"
const PRIxFAST32 = "x"
const PRIxFAST8 = "x"
const PRIxLEAST16 = "x"
const PRIxLEAST32 = "x"
const PRIxLEAST8 = "x"
const PSEUDO = 2
const PTHREAD_BARRIER_SERIAL_THREAD = -1
const PTHREAD_CANCELED = -1
const PTHREAD_CANCEL_ASYNCHRONOUS = 1
const PTHREAD_CANCEL_DEFERRED = 0
const PTHREAD_CANCEL_DISABLE = 1
const PTHREAD_CANCEL_ENABLE = 0
const PTHREAD_CANCEL_MASKED = 2
const PTHREAD_CREATE_DETACHED = 1
const PTHREAD_CREATE_JOINABLE = 0
const PTHREAD_DESTRUCTOR_ITERATIONS = 4
const PTHREAD_EXPLICIT_SCHED = 1
const PTHREAD_INHERIT_SCHED = 0
const PTHREAD_KEYS_MAX = 128
const PTHREAD_MUTEX_DEFAULT = 0
const PTHREAD_MUTEX_ERRORCHECK = 2
const PTHREAD_MUTEX_NORMAL = 0
const PTHREAD_MUTEX_RECURSIVE = 1
const PTHREAD_MUTEX_ROBUST = 1
const PTHREAD_MUTEX_STALLED = 0
const PTHREAD_ONCE_INIT = 0
const PTHREAD_PRIO_INHERIT = 1
const PTHREAD_PRIO_NONE = 0
const PTHREAD_PRIO_PROTECT = 2
const PTHREAD_PROCESS_PRIVATE = 0
const PTHREAD_PROCESS_SHARED = 1
const PTHREAD_SCOPE_PROCESS = 1
const PTHREAD_SCOPE_SYSTEM = 0
const PTHREAD_STACK_MIN = 2048
const PTRDIFF_MAX = 9223372036854775807
const PTRDIFF_MIN = -9223372036854775808
const P_tmpdir = "/tmp"
const RAND_MAX = 2147483647
const RAND_SEED_INITIALIZED = 64
const RANGE = 82
const REG_ADVANCED = 3
const REG_ADVF = 2
const REG_ASSERT = 15
const REG_ATOI = 101
const REG_BADBR = 10
const REG_BADOPT = 18
const REG_BADPAT = 2
const REG_BADRPT = 13
const REG_BASIC = 0
const REG_BOSONLY = 1024
const REG_CANCEL = 777
const REG_DUMP = 2048
const REG_EBRACE = 9
const REG_EBRACK = 7
const REG_ECOLLATE = 3
const REG_ECOLORS = 20
const REG_ECTYPE = 4
const REG_EESCAPE = 5
const REG_EPAREN = 8
const REG_ERANGE = 11
const REG_ESPACE = 12
const REG_ESUBREG = 6
const REG_ETOOBIG = 19
const REG_EXPANDED = 32
const REG_EXPECT = 512
const REG_EXTENDED = 1
const REG_FAKE = 4096
const REG_FTRACE = 8
const REG_ICASE = 8
const REG_INVARG = 16
const REG_ITOA = 102
const REG_MAX_COMPILE_SPACE = 0
const REG_MIXED = 17
const REG_MTRACE = 16
const REG_NEWLINE = 192
const REG_NLANCH = 128
const REG_NLSTOP = 64
const REG_NOMATCH = 1
const REG_NOSPEC = 4
const REG_NOSUB = 16
const REG_NOTBOL = 1
const REG_NOTEOL = 2
const REG_OKAY = 0
const REG_PEND = 256
const REG_PROGRESS = 8192
const REG_QUOTE = 4
const REG_SMALL = 32
const REG_STARTEND = 4
const REG_UBACKREF = 1
const REG_UBBS = 64
const REG_UBOUNDS = 4
const REG_UBRACES = 8
const REG_UBSALNUM = 16
const REG_UEMPTYMATCH = 2048
const REG_UIMPOSSIBLE = 4096
const REG_ULOCALE = 1024
const REG_ULOOKAHEAD = 2
const REG_UNONPOSIX = 128
const REG_UPBOTCH = 32
const REG_USHORTEST = 8192
const REG_UUNPORT = 512
const REG_UUNSPEC = 256
const REMAGIC = 65239
const RE_DUP_MAX = 255
const RLIM64_INFINITY = 18446744073709551615
const RLIM64_SAVED_CUR = 18446744073709551615
const RLIM64_SAVED_MAX = 18446744073709551615
const RLIMIT_AS = 9
const RLIMIT_CORE = 4
const RLIMIT_CPU = 0
const RLIMIT_DATA = 2
const RLIMIT_FSIZE = 1
const RLIMIT_LOCKS = 10
const RLIMIT_MEMLOCK = 8
const RLIMIT_MSGQUEUE = 12
const RLIMIT_NICE = 13
const RLIMIT_NLIMITS = 16
const RLIMIT_NOFILE = 7
const RLIMIT_NPROC = 6
const RLIMIT_RSS = 5
const RLIMIT_RTPRIO = 14
const RLIMIT_RTTIME = 15
const RLIMIT_SIGPENDING = 11
const RLIMIT_STACK = 3
const RLIM_INFINITY = 18446744073709551615
const RLIM_NLIMITS = 16
const RLIM_SAVED_CUR = 18446744073709551615
const RLIM_SAVED_MAX = 18446744073709551615
const RUSAGE_CHILDREN = -1
const RUSAGE_SELF = 0
const RUSAGE_THREAD = 1
const RWF_WRITE_LIFE_NOT_SET = 0
const RWH_WRITE_LIFE_EXTREME = 5
const RWH_WRITE_LIFE_LONG = 4
const RWH_WRITE_LIFE_MEDIUM = 3
const RWH_WRITE_LIFE_NONE = 1
const RWH_WRITE_LIFE_SHORT = 2
const R_OK = 4
const SAFE_INTERP = 128
const SATISFIED = 2
const SA_EXPOSE_TAGBITS = 2048
const SA_NOCLDSTOP = 1
const SA_NOCLDWAIT = 2
const SA_NODEFER = 1073741824
const SA_NOMASK = 1073741824
const SA_ONESHOT = 2147483648
const SA_ONSTACK = 134217728
const SA_RESETHAND = 2147483648
const SA_RESTART = 268435456
const SA_RESTORER = 67108864
const SA_SIGINFO = 4
const SA_UNSUPPORTED = 1024
const SBEGIN = 65
const SCHAR_MAX = 127
const SCHAR_MIN = -128
const SCHED_BATCH = 3
const SCHED_DEADLINE = 6
const SCHED_FIFO = 1
const SCHED_IDLE = 5
const SCHED_OTHER = 0
const SCHED_RESET_ON_FORK = 1073741824
const SCHED_RR = 2
const SCM_CREDENTIALS = 2
const SCM_RIGHTS = 1
const SCM_TIMESTAMP = 29
const SCM_TIMESTAMPING = 37
const SCM_TIMESTAMPING_OPT_STATS = 54
const SCM_TIMESTAMPING_PKTINFO = 58
const SCM_TIMESTAMPNS = 35
const SCM_TXTIME = 61
const SCM_WIFI_STATUS = 41
const SCNd16 = "hd"
const SCNd32 = "d"
const SCNd8 = "hhd"
const SCNdFAST16 = "d"
const SCNdFAST32 = "d"
const SCNdFAST8 = "hhd"
const SCNdLEAST16 = "hd"
const SCNdLEAST32 = "d"
const SCNdLEAST8 = "hhd"
const SCNi16 = "hi"
const SCNi32 = "i"
const SCNi8 = "hhi"
const SCNiFAST16 = "i"
const SCNiFAST32 = "i"
const SCNiFAST8 = "hhi"
const SCNiLEAST16 = "hi"
const SCNiLEAST32 = "i"
const SCNiLEAST8 = "hhi"
const SCNo16 = "ho"
const SCNo32 = "o"
const SCNo8 = "hho"
const SCNoFAST16 = "o"
const SCNoFAST32 = "o"
const SCNoFAST8 = "hho"
const SCNoLEAST16 = "ho"
const SCNoLEAST32 = "o"
const SCNoLEAST8 = "hho"
const SCNu16 = "hu"
const SCNu32 = "u"
const SCNu8 = "hhu"
const SCNuFAST16 = "u"
const SCNuFAST32 = "u"
const SCNuFAST8 = "hhu"
const SCNuLEAST16 = "hu"
const SCNuLEAST32 = "u"
const SCNuLEAST8 = "hhu"
const SCNx16 = "hx"
const SCNx32 = "x"
const SCNx8 = "hhx"
const SCNxFAST16 = "x"
const SCNxFAST32 = "x"
const SCNxFAST8 = "hhx"
const SCNxLEAST16 = "hx"
const SCNxLEAST32 = "x"
const SCNxLEAST8 = "hhx"
const SEEK_DATA = 3
const SEEK_HOLE = 4
const SEGV_ACCERR = 2
const SEGV_BNDERR = 3
const SEGV_MAPERR = 1
const SEGV_MTEAERR = 8
const SEGV_MTESERR = 9
const SEGV_PKUERR = 4
const SELECT_MASK = 0
const SEM_NSEMS_MAX = 256
const SEM_VALUE_MAX = 2147483647
const SEND = 90
const SHORTER = 2
const SHRT_MAX = 32767
const SHRT_MIN = -32768
const SHUT_RD = 0
const SHUT_RDWR = 2
const SHUT_WR = 1
const SIGABRT = 6
const SIGALRM = 14
const SIGBUS = 7
const SIGCHLD = 17
const SIGCONT = 18
const SIGEV_NONE = 1
const SIGEV_SIGNAL = 0
const SIGEV_THREAD = 2
const SIGEV_THREAD_ID = 4
const SIGFPE = 8
const SIGHUP = 1
const SIGILL = 4
const SIGINT = 2
const SIGIO = 29
const SIGIOT = 6
const SIGKILL = 9
const SIGPIPE = 13
const SIGPOLL = 29
const SIGPROF = 27
const SIGPWR = 30
const SIGQUIT = 3
const SIGRTMAX = 0
const SIGRTMIN = 0
const SIGSEGV = 11
const SIGSTKFLT = 16
const SIGSTKSZ = 10240
const SIGSTOP = 19
const SIGSYS = 31
const SIGTERM = 15
const SIGTRAP = 5
const SIGTSTP = 20
const SIGTTIN = 21
const SIGTTOU = 22
const SIGUNUSED = 31
const SIGURG = 23
const SIGUSR1 = 10
const SIGUSR2 = 12
const SIGVTALRM = 26
const SIGWINCH = 28
const SIGXCPU = 24
const SIGXFSZ = 25
const SIG_ATOMIC_MAX = 2147483647
const SIG_ATOMIC_MIN = -2147483648
const SIG_BLOCK = 0
const SIG_SETMASK = 2
const SIG_UNBLOCK = 1
const SIZE_MAX = 18446744073709551615
const SI_ASYNCIO = -4
const SI_ASYNCNL = -60
const SI_KERNEL = 128
const SI_MESGQ = -3
const SI_QUEUE = -1
const SI_SIGIO = -5
const SI_TIMER = -2
const SI_TKILL = -6
const SI_USER = 0
const SOCK_CLOEXEC = 524288
const SOCK_DCCP = 6
const SOCK_DGRAM = 2
const SOCK_NONBLOCK = 2048
const SOCK_PACKET = 10
const SOCK_RAW = 3
const SOCK_RDM = 4
const SOCK_SEQPACKET = 5
const SOCK_STREAM = 1
const SOL_AAL = 265
const SOL_ALG = 279
const SOL_ATM = 264
const SOL_BLUETOOTH = 274
const SOL_CAIF = 278
const SOL_DCCP = 269
const SOL_DECNET = 261
const SOL_ICMPV6 = 58
const SOL_IP = 0
const SOL_IPV6 = 41
const SOL_IRDA = 266
const SOL_IUCV = 277
const SOL_KCM = 281
const SOL_LLC = 268
const SOL_NETBEUI = 267
const SOL_NETLINK = 270
const SOL_NFC = 280
const SOL_PACKET = 263
const SOL_PNPIPE = 275
const SOL_PPPOL2TP = 273
const SOL_RAW = 255
const SOL_RDS = 276
const SOL_RXRPC = 272
const SOL_SOCKET = 1
const SOL_TIPC = 271
const SOL_TLS = 282
const SOL_X25 = 262
const SOL_XDP = 283
const SOMAXCONN = 128
const SOME = 2
const SO_ACCEPTCONN = 30
const SO_ATTACH_BPF = 50
const SO_ATTACH_FILTER = 26
const SO_ATTACH_REUSEPORT_CBPF = 51
const SO_ATTACH_REUSEPORT_EBPF = 52
const SO_BINDTODEVICE = 25
const SO_BINDTOIFINDEX = 62
const SO_BPF_EXTENSIONS = 48
const SO_BROADCAST = 6
const SO_BSDCOMPAT = 14
const SO_BUSY_POLL = 46
const SO_BUSY_POLL_BUDGET = 70
const SO_CNX_ADVICE = 53
const SO_COOKIE = 57
const SO_DEBUG = 1
const SO_DETACH_BPF = 27
const SO_DETACH_FILTER = 27
const SO_DETACH_REUSEPORT_BPF = 68
const SO_DOMAIN = 39
const SO_DONTROUTE = 5
const SO_ERROR = 4
const SO_GET_FILTER = 26
const SO_INCOMING_CPU = 49
const SO_INCOMING_NAPI_ID = 56
const SO_KEEPALIVE = 9
const SO_LINGER = 13
const SO_LOCK_FILTER = 44
const SO_MARK = 36
const SO_MAX_PACING_RATE = 47
const SO_MEMINFO = 55
const SO_NOFCS = 43
const SO_NO_CHECK = 11
const SO_OOBINLINE = 10
const SO_PASSCRED = 16
const SO_PASSSEC = 34
const SO_PEEK_OFF = 42
const SO_PEERCRED = 17
const SO_PEERGROUPS = 59
const SO_PEERNAME = 28
const SO_PEERSEC = 31
const SO_PREFER_BUSY_POLL = 69
const SO_PRIORITY = 12
const SO_PROTOCOL = 38
const SO_RCVBUF = 8
const SO_RCVBUFFORCE = 33
const SO_RCVLOWAT = 18
const SO_RCVTIMEO = 20
const SO_REUSEADDR = 2
const SO_REUSEPORT = 15
const SO_RXQ_OVFL = 40
const SO_SECURITY_AUTHENTICATION = 22
const SO_SECURITY_ENCRYPTION_NETWORK = 24
const SO_SECURITY_ENCRYPTION_TRANSPORT = 23
const SO_SELECT_ERR_QUEUE = 45
const SO_SNDBUF = 7
const SO_SNDBUFFORCE = 32
const SO_SNDLOWAT = 19
const SO_SNDTIMEO = 21
const SO_TIMESTAMP = 29
const SO_TIMESTAMPING = 37
const SO_TIMESTAMPNS = 35
const SO_TXTIME = 61
const SO_TYPE = 3
const SO_WIFI_STATUS = 41
const SO_ZEROCOPY = 60
const SPLICE_F_GIFT = 8
const SPLICE_F_MORE = 4
const SPLICE_F_MOVE = 1
const SPLICE_F_NONBLOCK = 2
const SSIZE_MAX = 9223372036854775807
const SS_AUTODISARM = 2147483648
const SS_DISABLE = 2
const SS_FLAG_BITS = 2147483648
const SS_ONSTACK = 1
const STATIC_BUILD = 1
const STATX_ALL = 4095
const STATX_ATIME = 32
const STATX_BASIC_STATS = 2047
const STATX_BLOCKS = 1024
const STATX_BTIME = 2048
const STATX_CTIME = 128
const STATX_GID = 16
const STATX_INO = 256
const STATX_MODE = 2
const STATX_MTIME = 64
const STATX_NLINK = 4
const STATX_SIZE = 512
const STATX_TYPE = 1
const STATX_UID = 8
const STDC_HEADERS = 1
const STDERR_FILENO = 2
const STDIN_FILENO = 0
const STDOUT_FILENO = 1
const SYMLOOP_MAX = 40
const SYNC_FILE_RANGE_WAIT_AFTER = 4
const SYNC_FILE_RANGE_WAIT_BEFORE = 1
const SYNC_FILE_RANGE_WRITE = 2
const SYS_SECCOMP = 1
const SYS_USER_DISPATCH = 2
const S_IEXEC = 64
const S_IFBLK = 24576
const S_IFCHR = 8192
const S_IFDIR = 16384
const S_IFIFO = 4096
const S_IFLNK = 40960
const S_IFMT = 61440
const S_IFREG = 32768
const S_IFSOCK = 49152
const S_IREAD = 256
const S_IRGRP = 32
const S_IROTH = 4
const S_IRUSR = 256
const S_IRWXG = 56
const S_IRWXO = 7
const S_IRWXU = 448
const S_ISGID = 1024
const S_ISUID = 2048
const S_ISVTX = 512
const S_IWGRP = 16
const S_IWOTH = 2
const S_IWRITE = 128
const S_IWUSR = 128
const S_IXGRP = 8
const S_IXOTH = 1
const S_IXUSR = 64
const TCLFSENCODING = "NULL"
const TCL_ALLOCALIGN = 0
const TCL_ALLOW_EXCEPTIONS = 4
const TCL_ALLOW_INLINE_COMPILATION = 131072
const TCL_ALL_EVENTS = -3
const TCL_ALPHA_RELEASE = 0
const TCL_APPEND_VALUE = 4
const TCL_ARGV_CONSTANT = 15
const TCL_ARGV_END = 23
const TCL_ARGV_FLOAT = 19
const TCL_ARGV_FUNC = 20
const TCL_ARGV_GENFUNC = 21
const TCL_ARGV_HELP = 22
const TCL_ARGV_INT = 16
const TCL_ARGV_REST = 18
const TCL_ARGV_STRING = 17
const TCL_AUTO_LENGTH = -1
const TCL_AVOID_RESOLVERS = 262144
const TCL_BETA_RELEASE = 1
const TCL_BREAK = 3
const TCL_CANCEL_UNWIND = 1048576
const TCL_CFGVAL_ENCODING = "utf-8"
const TCL_CFG_DO64BIT = 1
const TCL_CFG_OPTIMIZED = 1
const TCL_CHANNEL_THREAD_INSERT = 0
const TCL_CHANNEL_THREAD_REMOVE = 1
const TCL_CLOSE2PROC = "NULL"
const TCL_CLOSE_READ = 2
const TCL_CLOSE_WRITE = 4
const TCL_CODE_USER_MAX = 1073741823
const TCL_CODE_USER_MIN = 5
const TCL_COMBINE = 16777216
const TCL_CONTINUE = 4
const TCL_CONVERT_MULTIBYTE = -1
const TCL_CONVERT_NOSPACE = -4
const TCL_CONVERT_SYNTAX = -2
const TCL_CONVERT_UNKNOWN = -3
const TCL_CREATE_HARD_LINK = 2
const TCL_CREATE_NS_IF_UNKNOWN = 2048
const TCL_CREATE_SYMBOLIC_LINK = 1
const TCL_CUSTOM_PTR_KEYS = -1
const TCL_CUSTOM_TYPE_KEYS = -2
const TCL_DD_CONVERSION_TYPE_MASK = 3
const TCL_DD_E_FORMAT = 2
const TCL_DD_F_FORMAT = 3
const TCL_DD_NO_QUICK = 8
const TCL_DD_SHORTEST = 4
const TCL_DONT_QUOTE_HASH = 8
const TCL_DONT_USE_BRACES = 1
const TCL_DONT_WAIT = 2
const TCL_DOUBLE_SPACE = 27
const TCL_DSTRING_STATIC_SIZE = 200
const TCL_EACH_COLLECT = 1
const TCL_EACH_KEEP_NONE = 0
const TCL_ENCODING_CHAR_LIMIT = 16
const TCL_ENCODING_END = 2
const TCL_ENCODING_INTERNAL_USE_MASK = 65280
const TCL_ENCODING_NO_TERMINATE = 8
const TCL_ENCODING_PROFILE_REPLACE = 33554432
const TCL_ENCODING_PROFILE_STRICT = 0
const TCL_ENCODING_PROFILE_TCL8 = 16777216
const TCL_ENCODING_START = 1
const TCL_ENCODING_STOPONERROR = 0
const TCL_ENFORCE_MODE = 16
const TCL_ENSEMBLE_PREFIX = 2
const TCL_ERROR = 1
const TCL_EVAL_DIRECT = 262144
const TCL_EVAL_DISCARD_RESULT = 64
const TCL_EVAL_FILE = 2
const TCL_EVAL_GLOBAL = 131072
const TCL_EVAL_INVOKE = 524288
const TCL_EVAL_NOERR = 2097152
const TCL_EVAL_NORESOLVE = 32
const TCL_EVAL_SOURCE_IN_FRAME = 16
const TCL_EXACT = 1
const TCL_EXCEPTION = 8
const TCL_FILE_EVENTS = 8
const TCL_FINAL_RELEASE = 2
const TCL_FIND_IF_NOT_SIMPLE = 8192
const TCL_FIND_ONLY_NS = 4096
const TCL_GLOBAL_ONLY = 1
const TCL_GLOB_PERM_HIDDEN = 2
const TCL_GLOB_PERM_R = 4
const TCL_GLOB_PERM_RONLY = 1
const TCL_GLOB_PERM_W = 8
const TCL_GLOB_PERM_X = 16
const TCL_GLOB_TYPE_BLOCK = 1
const TCL_GLOB_TYPE_CHAR = 2
const TCL_GLOB_TYPE_DIR = 4
const TCL_GLOB_TYPE_FILE = 16
const TCL_GLOB_TYPE_LINK = 32
const TCL_GLOB_TYPE_MOUNT = 128
const TCL_GLOB_TYPE_PIPE = 8
const TCL_GLOB_TYPE_SOCK = 64
const TCL_HASH_KEY_DIRECT_COMPARE = 4
const TCL_HASH_KEY_RANDOMIZE_HASH = 1
const TCL_HASH_KEY_SYSTEM_HASH = 2
const TCL_HASH_KEY_TYPE_VERSION = 1
const TCL_HASH_TYPE = 0
const TCL_IDLE_EVENTS = 32
const TCL_INDEX_END = -2
const TCL_INDEX_NONE = -1
const TCL_INDEX_TEMP_TABLE = 64
const TCL_INVOKE_HIDDEN = 1
const TCL_INVOKE_NO_TRACEBACK = 4
const TCL_INVOKE_NO_UNKNOWN = 2
const TCL_IO_FAILURE = -1
const TCL_LEAVE_ERR_MSG = 512
const TCL_LIMIT_COMMANDS = 1
const TCL_LIMIT_TIME = 2
const TCL_LINK_BINARY = 16
const TCL_LINK_BOOLEAN = 3
const TCL_LINK_CHAR = 6
const TCL_LINK_CHARS = 15
const TCL_LINK_DOUBLE = 2
const TCL_LINK_FLOAT = 13
const TCL_LINK_INT = 1
const TCL_LINK_LONG = 1
const TCL_LINK_READ_ONLY = 128
const TCL_LINK_SHORT = 8
const TCL_LINK_STRING = 4
const TCL_LINK_UCHAR = 7
const TCL_LINK_UINT = 10
const TCL_LINK_ULONG = 10
const TCL_LINK_USHORT = 9
const TCL_LINK_WIDE_INT = 5
const TCL_LINK_WIDE_UINT = 14
const TCL_LIST_ELEMENT = 8
const TCL_LL_MODIFIER = "ll"
const TCL_LOAD_GLOBAL = 1
const TCL_LOAD_LAZY = 2
const TCL_LOCATION_BC = 2
const TCL_LOCATION_EVAL = 0
const TCL_LOCATION_LAST = 6
const TCL_LOCATION_PREBC = 3
const TCL_LOCATION_PROC = 5
const TCL_LOCATION_SOURCE = 4
const TCL_MAJOR_VERSION = 9
const TCL_MATCH_NOCASE = 1
const TCL_MAX_PREC = 17
const TCL_MINOR_VERSION = 0
const TCL_MIN_GROWTH = 1024
const TCL_MIN_TOKEN_GROWTH = 1024
const TCL_MODE_BLOCKING = 0
const TCL_MODE_NONBLOCKING = 1
const TCL_NAMESPACE_ONLY = 2
const TCL_NO_EVAL = 65536
const TCL_NULL_OK = 32
const TCL_NUMBER_BIG = 3
const TCL_NUMBER_DOUBLE = 4
const TCL_NUMBER_INT = 2
const TCL_NUMBER_NAN = 5
const TCL_OBJTYPE_V0 = 0
const TCL_OK = 0
const TCL_ONE_WORD_KEYS = 1
const TCL_PARSE_BAD_NUMBER = 9
const TCL_PARSE_BINARY_ONLY = 64
const TCL_PARSE_BRACE_EXTRA = 2
const TCL_PARSE_DECIMAL_ONLY = 1
const TCL_PARSE_HEXADECIMAL_ONLY = 4
const TCL_PARSE_INTEGER_ONLY = 8
const TCL_PARSE_MISSING_BRACE = 3
const TCL_PARSE_MISSING_BRACKET = 4
const TCL_PARSE_MISSING_PAREN = 5
const TCL_PARSE_MISSING_QUOTE = 6
const TCL_PARSE_MISSING_VAR_BRACE = 7
const TCL_PARSE_NO_UNDERSCORE = 128
const TCL_PARSE_NO_WHITESPACE = 32
const TCL_PARSE_OCTAL_ONLY = 2
const TCL_PARSE_QUOTE_EXTRA = 1
const TCL_PARSE_SCAN_PREFIXES = 16
const TCL_PARSE_SUCCESS = 0
const TCL_PARSE_SYNTAX = 8
const TCL_PATCH_LEVEL = "9.0.1"
const TCL_PLATFORM_TRANSLATION = 0
const TCL_READABLE = 2
const TCL_REG_ADVANCED = 3
const TCL_REG_ADVF = 2
const TCL_REG_BASIC = 0
const TCL_REG_BOSONLY = 1024
const TCL_REG_CANMATCH = 512
const TCL_REG_EXPANDED = 32
const TCL_REG_EXTENDED = 1
const TCL_REG_NEWLINE = 192
const TCL_REG_NLANCH = 128
const TCL_REG_NLSTOP = 64
const TCL_REG_NOCASE = 8
const TCL_REG_NOSUB = 16
const TCL_REG_NOTBOL = 1
const TCL_REG_NOTEOL = 2
const TCL_REG_QUOTE = 4
const TCL_RELEASE_LEVEL = 2
const TCL_RELEASE_SERIAL = 1
const TCL_RETURN = 2
const TCL_SERVICE_ALL = 1
const TCL_SERVICE_NONE = 0
const TCL_SHLIB_EXT = ""
const TCL_SIZE_MODIFIER = "TCL_T_MODIFIER"
const TCL_SMALL_HASH_TABLE = 4
const TCL_STDERR = 8
const TCL_STDIN = 2
const TCL_STDOUT = 4
const TCL_STRING_IN_PLACE = 2
const TCL_STRING_KEYS = 0
const TCL_STRING_MATCH_NOCASE = 1
const TCL_SUBST_ALL = 7
const TCL_SUBST_BACKSLASHES = 4
const TCL_SUBST_COMMANDS = 1
const TCL_SUBST_VARIABLES = 2
const TCL_TCPSERVER_REUSEADDR = 1
const TCL_TCPSERVER_REUSEPORT = 2
const TCL_THREADS = 1
const TCL_THREAD_JOINABLE = 1
const TCL_THREAD_NOFLAGS = 0
const TCL_THREAD_STACK_DEFAULT = 0
const TCL_TIMER_EVENTS = 16
const TCL_TOKEN_BS = 8
const TCL_TOKEN_COMMAND = 16
const TCL_TOKEN_EXPAND_WORD = 256
const TCL_TOKEN_OPERATOR = 128
const TCL_TOKEN_SIMPLE_WORD = 2
const TCL_TOKEN_SUB_EXPR = 64
const TCL_TOKEN_TEXT = 4
const TCL_TOKEN_VARIABLE = 32
const TCL_TOKEN_WORD = 1
const TCL_TRACE_ARRAY = 2048
const TCL_TRACE_DELETE = 16384
const TCL_TRACE_DESTROYED = 128
const TCL_TRACE_ENTER_EXEC = 1
const TCL_TRACE_LEAVE_EXEC = 2
const TCL_TRACE_READS = 16
const TCL_TRACE_RENAME = 8192
const TCL_TRACE_RESULT_DYNAMIC = 32768
const TCL_TRACE_RESULT_OBJECT = 65536
const TCL_TRACE_UNSETS = 64
const TCL_TRACE_WRITES = 32
const TCL_T_MODIFIER = "t"
const TCL_UNLOAD_DETACH_FROM_INTERPRETER = 1
const TCL_UNLOAD_DETACH_FROM_PROCESS = 2
const TCL_UTF_MAX = 4
const TCL_VERSION = "9.0"
const TCL_WIDE_INT_IS_LONG = 1
const TCL_WINDOW_EVENTS = 4
const TCL_WRITABLE = 4
const TCL_ZLIB_COMPRESS_BEST = 9
const TCL_ZLIB_COMPRESS_DEFAULT = -1
const TCL_ZLIB_COMPRESS_FAST = 1
const TCL_ZLIB_COMPRESS_NONE = 0
const TCL_ZLIB_FINALIZE = 4
const TCL_ZLIB_FLUSH = 2
const TCL_ZLIB_FORMAT_AUTO = 8
const TCL_ZLIB_FORMAT_GZIP = 4
const TCL_ZLIB_FORMAT_RAW = 1
const TCL_ZLIB_FORMAT_ZLIB = 2
const TCL_ZLIB_FULLFLUSH = 3
const TCL_ZLIB_NO_FLUSH = 0
const TCL_ZLIB_STREAM_DEFLATE = 16
const TCL_ZLIB_STREAM_INFLATE = 32
const TCL_Z_MODIFIER = "z"
const TIMER_ABSTIME = 1
const TIME_UTC = 1
const TMP_MAX = 10000
const TRAP_BRANCH = 3
const TRAP_BRKPT = 1
const TRAP_HWBKPT = 4
const TRAP_TRACE = 2
const TRAP_UNK = 5
const TRY_AGAIN = 2
const TTY_NAME_MAX = 32
const TZNAME_MAX = 6
const TclOSclosedir = 0
const TclOSopen = 0
const TclOSopendir = 0
const TclOSreaddir = 0
const TclOSrewinddir = 0
const TclOSseek = 0
const TclObjInterpProc = 0
const TclObjInterpProc2 = 0
const Tcl_AttemptAlloc = 0
const Tcl_AttemptRealloc = 0
const Tcl_CreateSlave = 0
const Tcl_EncodingFreeProc = 0
const Tcl_ExitProc = 0
const Tcl_FSFreeInternalRepProc = 0
const Tcl_FileFreeProc = 0
const Tcl_Free = 0
const Tcl_GetMaster = 0
const Tcl_GetSlave = 0
const Tcl_LimitHandlerDeleteProc = 0
const Tcl_PackageInitProc = 0
const Tcl_PackageUnloadProc = 0
const Tcl_StaticPackage = 0
const Tcl_ThreadCreateType = 0
const UBITS = 0
const UCHAR_MAX = 255
const UINT16_MAX = 65535
const UINT32_MAX = 4294967295
const UINT64_MAX = 18446744073709551615
const UINT8_MAX = 255
const UINTMAX_MAX = 18446744073709551615
const UINTPTR_MAX = 18446744073709551615
const UINT_FAST16_MAX = 4294967295
const UINT_FAST32_MAX = 4294967295
const UINT_FAST64_MAX = 18446744073709551615
const UINT_FAST8_MAX = 255
const UINT_LEAST16_MAX = 65535
const UINT_LEAST32_MAX = 4294967295
const UINT_LEAST64_MAX = 18446744073709551615
const UINT_LEAST8_MAX = 255
const UINT_MAX = 4294967295
const ULLONG_MAX = 18446744073709551615
const ULONG_MAX = 18446744073709551615
const USE_THREAD_ALLOC = 1
const USHRT_MAX = 65535
const UTIME_NOW = 1073741823
const UTIME_OMIT = 1073741822
const UWIDE_MAX = -1
const VAR_ALL_HASH = 4236
const VAR_ALL_TRACES = 2160
const VAR_ARGUMENT = 256
const VAR_ARRAY = 1
const VAR_ARRAY_ELEMENT = 4096
const VAR_CONSTANT = 65536
const VAR_DEAD_HASH = 8
const VAR_IN_HASHTABLE = 4
const VAR_IS_ARGS = 1024
const VAR_LINK = 2
const VAR_NAMESPACE_VAR = 128
const VAR_RESOLVED = 32768
const VAR_SEARCH_ACTIVE = 16384
const VAR_TEMPORARY = 512
const VAR_TRACED_ARRAY = 2048
const VAR_TRACED_READ = 16
const VAR_TRACED_UNSET = 64
const VAR_TRACED_WRITE = 32
const VAR_TRACE_ACTIVE = 8192
const WAIT_STATUS_TYPE = 0
const WBDRY = 119
const WCHAR_MAX = 2147483647
const WCHAR_MIN = -2147483648
const WCONTINUED = 8
const WEXITED = 4
const WHITE = 0
const WINT_MAX = 4294967295
const WINT_MIN = 0
const WNOHANG = 1
const WNOWAIT = 16777216
const WORD_BIT = 32
const WSTOPPED = 2
const WUNTRACED = 2
const W_OK = 2
const X_OK = 1
const ZIPFS_BUILD = 2
const _CS_GNU_LIBC_VERSION = 2
const _CS_GNU_LIBPTHREAD_VERSION = 3
const _CS_PATH = 0
const _CS_POSIX_V5_WIDTH_RESTRICTED_ENVS = 4
const _CS_POSIX_V6_ILP32_OFF32_CFLAGS = 1116
const _CS_POSIX_V6_ILP32_OFF32_LDFLAGS = 1117
const _CS_POSIX_V6_ILP32_OFF32_LIBS = 1118
const _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS = 1119
const _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS = 1120
const _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS = 1121
const _CS_POSIX_V6_ILP32_OFFBIG_LIBS = 1122
const _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS = 1123
const _CS_POSIX_V6_LP64_OFF64_CFLAGS = 1124
const _CS_POSIX_V6_LP64_OFF64_LDFLAGS = 1125
const _CS_POSIX_V6_LP64_OFF64_LIBS = 1126
const _CS_POSIX_V6_LP64_OFF64_LINTFLAGS = 1127
const _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS = 1128
const _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS = 1129
const _CS_POSIX_V6_LPBIG_OFFBIG_LIBS = 1130
const _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS = 1131
const _CS_POSIX_V6_WIDTH_RESTRICTED_ENVS = 1
const _CS_POSIX_V7_ILP32_OFF32_CFLAGS = 1132
const _CS_POSIX_V7_ILP32_OFF32_LDFLAGS = 1133
const _CS_POSIX_V7_ILP32_OFF32_LIBS = 1134
const _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS = 1135
const _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS = 1136
const _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS = 1137
const _CS_POSIX_V7_ILP32_OFFBIG_LIBS = 1138
const _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS = 1139
const _CS_POSIX_V7_LP64_OFF64_CFLAGS = 1140
const _CS_POSIX_V7_LP64_OFF64_LDFLAGS = 1141
const _CS_POSIX_V7_LP64_OFF64_LIBS = 1142
const _CS_POSIX_V7_LP64_OFF64_LINTFLAGS = 1143
const _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS = 1144
const _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS = 1145
const _CS_POSIX_V7_LPBIG_OFFBIG_LIBS = 1146
const _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS = 1147
const _CS_POSIX_V7_THREADS_CFLAGS = 1150
const _CS_POSIX_V7_THREADS_LDFLAGS = 1151
const _CS_POSIX_V7_WIDTH_RESTRICTED_ENVS = 5
const _CS_V6_ENV = 1148
const _CS_V7_ENV = 1149
const _GNU_SOURCE = 1
const _IOFBF = 0
const _IOLBF = 1
const _IONBF = 2
const _LARGEFILE64_SOURCE = 1
const _LP64 = 1
const _NSIG = 65
const _PC_2_SYMLINKS = 20
const _PC_ALLOC_SIZE_MIN = 18
const _PC_ASYNC_IO = 10
const _PC_CHOWN_RESTRICTED = 6
const _PC_FILESIZEBITS = 13
const _PC_LINK_MAX = 0
const _PC_MAX_CANON = 1
const _PC_MAX_INPUT = 2
const _PC_NAME_MAX = 3
const _PC_NO_TRUNC = 7
const _PC_PATH_MAX = 4
const _PC_PIPE_BUF = 5
const _PC_PRIO_IO = 11
const _PC_REC_INCR_XFER_SIZE = 14
const _PC_REC_MAX_XFER_SIZE = 15
const _PC_REC_MIN_XFER_SIZE = 16
const _PC_REC_XFER_ALIGN = 17
const _PC_SOCK_MAXBUF = 12
const _PC_SYMLINK_MAX = 19
const _PC_SYNC_IO = 9
const _PC_VDISABLE = 8
const _POSIX2_BC_BASE_MAX = 99
const _POSIX2_BC_DIM_MAX = 2048
const _POSIX2_BC_SCALE_MAX = 99
const _POSIX2_BC_STRING_MAX = 1000
const _POSIX2_CHARCLASS_NAME_MAX = 14
const _POSIX2_COLL_WEIGHTS_MAX = 2
const _POSIX2_C_BIND = 200809
const _POSIX2_EXPR_NEST_MAX = 32
const _POSIX2_LINE_MAX = 2048
const _POSIX2_RE_DUP_MAX = 255
const _POSIX2_VERSION = 200809
const _POSIX_ADVISORY_INFO = 200809
const _POSIX_AIO_LISTIO_MAX = 2
const _POSIX_AIO_MAX = 1
const _POSIX_ARG_MAX = 4096
const _POSIX_ASYNCHRONOUS_IO = 200809
const _POSIX_BARRIERS = 200809
const _POSIX_CHILD_MAX = 25
const _POSIX_CHOWN_RESTRICTED = 1
const _POSIX_CLOCKRES_MIN = 20000000
const _POSIX_CLOCK_SELECTION = 200809
const _POSIX_CPUTIME = 200809
const _POSIX_DELAYTIMER_MAX = 32
const _POSIX_FSYNC = 200809
const _POSIX_HOST_NAME_MAX = 255
const _POSIX_IPV6 = 200809
const _POSIX_JOB_CONTROL = 1
const _POSIX_LINK_MAX = 8
const _POSIX_LOGIN_NAME_MAX = 9
const _POSIX_MAPPED_FILES = 200809
const _POSIX_MAX_CANON = 255
const _POSIX_MAX_INPUT = 255
const _POSIX_MEMLOCK = 200809
const _POSIX_MEMLOCK_RANGE = 200809
const _POSIX_MEMORY_PROTECTION = 200809
const _POSIX_MESSAGE_PASSING = 200809
const _POSIX_MONOTONIC_CLOCK = 200809
const _POSIX_MQ_OPEN_MAX = 8
const _POSIX_MQ_PRIO_MAX = 32
const _POSIX_NAME_MAX = 14
const _POSIX_NGROUPS_MAX = 8
const _POSIX_NO_TRUNC = 1
const _POSIX_OPEN_MAX = 20
const _POSIX_PATH_MAX = 256
const _POSIX_PIPE_BUF = 512
const _POSIX_RAW_SOCKETS = 200809
const _POSIX_READER_WRITER_LOCKS = 200809
const _POSIX_REALTIME_SIGNALS = 200809
const _POSIX_REGEXP = 1
const _POSIX_RE_DUP_MAX = 255
const _POSIX_RTSIG_MAX = 8
const _POSIX_SAVED_IDS = 1
const _POSIX_SEMAPHORES = 200809
const _POSIX_SEM_NSEMS_MAX = 256
const _POSIX_SEM_VALUE_MAX = 32767
const _POSIX_SHARED_MEMORY_OBJECTS = 200809
const _POSIX_SHELL = 1
const _POSIX_SIGQUEUE_MAX = 32
const _POSIX_SPAWN = 200809
const _POSIX_SPIN_LOCKS = 200809
const _POSIX_SSIZE_MAX = 32767
const _POSIX_SS_REPL_MAX = 4
const _POSIX_STREAM_MAX = 8
const _POSIX_SYMLINK_MAX = 255
const _POSIX_SYMLOOP_MAX = 8
const _POSIX_THREADS = 200809
const _POSIX_THREAD_ATTR_STACKADDR = 200809
const _POSIX_THREAD_ATTR_STACKSIZE = 200809
const _POSIX_THREAD_CPUTIME = 200809
const _POSIX_THREAD_DESTRUCTOR_ITERATIONS = 4
const _POSIX_THREAD_KEYS_MAX = 128
const _POSIX_THREAD_PRIORITY_SCHEDULING = 200809
const _POSIX_THREAD_PROCESS_SHARED = 200809
const _POSIX_THREAD_SAFE_FUNCTIONS = 200809
const _POSIX_THREAD_THREADS_MAX = 64
const _POSIX_TIMEOUTS = 200809
const _POSIX_TIMERS = 200809
const _POSIX_TIMER_MAX = 32
const _POSIX_TRACE_EVENT_NAME_MAX = 30
const _POSIX_TRACE_NAME_MAX = 8
const _POSIX_TRACE_SYS_MAX = 8
const _POSIX_TRACE_USER_EVENT_MAX = 32
const _POSIX_TTY_NAME_MAX = 9
const _POSIX_TZNAME_MAX = 6
const _POSIX_V6_LP64_OFF64 = 1
const _POSIX_V7_LP64_OFF64 = 1
const _POSIX_VDISABLE = 0
const _POSIX_VERSION = 200809
const _REENTRANT = 1
const _SC_2_CHAR_TERM = 95
const _SC_2_C_BIND = 47
const _SC_2_C_DEV = 48
const _SC_2_FORT_DEV = 49
const _SC_2_FORT_RUN = 50
const _SC_2_LOCALEDEF = 52
const _SC_2_PBS = 168
const _SC_2_PBS_ACCOUNTING = 169
const _SC_2_PBS_CHECKPOINT = 175
const _SC_2_PBS_LOCATE = 170
const _SC_2_PBS_MESSAGE = 171
const _SC_2_PBS_TRACK = 172
const _SC_2_SW_DEV = 51
const _SC_2_UPE = 97
const _SC_2_VERSION = 46
const _SC_ADVISORY_INFO = 132
const _SC_AIO_LISTIO_MAX = 23
const _SC_AIO_MAX = 24
const _SC_AIO_PRIO_DELTA_MAX = 25
const _SC_ARG_MAX = 0
const _SC_ASYNCHRONOUS_IO = 12
const _SC_ATEXIT_MAX = 87
const _SC_AVPHYS_PAGES = 86
const _SC_BARRIERS = 133
const _SC_BC_BASE_MAX = 36
const _SC_BC_DIM_MAX = 37
const _SC_BC_SCALE_MAX = 38
const _SC_BC_STRING_MAX = 39
const _SC_CHILD_MAX = 1
const _SC_CLK_TCK = 2
const _SC_CLOCK_SELECTION = 137
const _SC_COLL_WEIGHTS_MAX = 40
const _SC_CPUTIME = 138
const _SC_DELAYTIMER_MAX = 26
const _SC_EXPR_NEST_MAX = 42
const _SC_FSYNC = 15
const _SC_GETGR_R_SIZE_MAX = 69
const _SC_GETPW_R_SIZE_MAX = 70
const _SC_HOST_NAME_MAX = 180
const _SC_IOV_MAX = 60
const _SC_IPV6 = 235
const _SC_JOB_CONTROL = 7
const _SC_LINE_MAX = 43
const _SC_LOGIN_NAME_MAX = 71
const _SC_MAPPED_FILES = 16
const _SC_MEMLOCK = 17
const _SC_MEMLOCK_RANGE = 18
const _SC_MEMORY_PROTECTION = 19
const _SC_MESSAGE_PASSING = 20
const _SC_MINSIGSTKSZ = 249
const _SC_MONOTONIC_CLOCK = 149
const _SC_MQ_OPEN_MAX = 27
const _SC_MQ_PRIO_MAX = 28
const _SC_NGROUPS_MAX = 3
const _SC_NPROCESSORS_CONF = 83
const _SC_NPROCESSORS_ONLN = 84
const _SC_NZERO = 109
const _SC_OPEN_MAX = 4
const _SC_PAGESIZE = 30
const _SC_PAGE_SIZE = 30
const _SC_PASS_MAX = 88
const _SC_PHYS_PAGES = 85
const _SC_PRIORITIZED_IO = 13
const _SC_PRIORITY_SCHEDULING = 10
const _SC_RAW_SOCKETS = 236
const _SC_READER_WRITER_LOCKS = 153
const _SC_REALTIME_SIGNALS = 9
const _SC_REGEXP = 155
const _SC_RE_DUP_MAX = 44
const _SC_RTSIG_MAX = 31
const _SC_SAVED_IDS = 8
const _SC_SEMAPHORES = 21
const _SC_SEM_NSEMS_MAX = 32
const _SC_SEM_VALUE_MAX = 33
const _SC_SHARED_MEMORY_OBJECTS = 22
const _SC_SHELL = 157
const _SC_SIGQUEUE_MAX = 34
const _SC_SIGSTKSZ = 250
const _SC_SPAWN = 159
const _SC_SPIN_LOCKS = 154
const _SC_SPORADIC_SERVER = 160
const _SC_SS_REPL_MAX = 241
const _SC_STREAMS = 174
const _SC_STREAM_MAX = 5
const _SC_SYMLOOP_MAX = 173
const _SC_SYNCHRONIZED_IO = 14
const _SC_THREADS = 67
const _SC_THREAD_ATTR_STACKADDR = 77
const _SC_THREAD_ATTR_STACKSIZE = 78
const _SC_THREAD_CPUTIME = 139
const _SC_THREAD_DESTRUCTOR_ITERATIONS = 73
const _SC_THREAD_KEYS_MAX = 74
const _SC_THREAD_PRIORITY_SCHEDULING = 79
const _SC_THREAD_PRIO_INHERIT = 80
const _SC_THREAD_PRIO_PROTECT = 81
const _SC_THREAD_PROCESS_SHARED = 82
const _SC_THREAD_ROBUST_PRIO_INHERIT = 247
const _SC_THREAD_ROBUST_PRIO_PROTECT = 248
const _SC_THREAD_SAFE_FUNCTIONS = 68
const _SC_THREAD_SPORADIC_SERVER = 161
const _SC_THREAD_STACK_MIN = 75
const _SC_THREAD_THREADS_MAX = 76
const _SC_TIMEOUTS = 164
const _SC_TIMERS = 11
const _SC_TIMER_MAX = 35
const _SC_TRACE = 181
const _SC_TRACE_EVENT_FILTER = 182
const _SC_TRACE_EVENT_NAME_MAX = 242
const _SC_TRACE_INHERIT = 183
const _SC_TRACE_LOG = 184
const _SC_TRACE_NAME_MAX = 243
const _SC_TRACE_SYS_MAX = 244
const _SC_TRACE_USER_EVENT_MAX = 245
const _SC_TTY_NAME_MAX = 72
const _SC_TYPED_MEMORY_OBJECTS = 165
const _SC_TZNAME_MAX = 6
const _SC_UIO_MAXIOV = 60
const _SC_V6_ILP32_OFF32 = 176
const _SC_V6_ILP32_OFFBIG = 177
const _SC_V6_LP64_OFF64 = 178
const _SC_V6_LPBIG_OFFBIG = 179
const _SC_V7_ILP32_OFF32 = 237
const _SC_V7_ILP32_OFFBIG = 238
const _SC_V7_LP64_OFF64 = 239
const _SC_V7_LPBIG_OFFBIG = 240
const _SC_VERSION = 29
const _SC_XBS5_ILP32_OFF32 = 125
const _SC_XBS5_ILP32_OFFBIG = 126
const _SC_XBS5_LP64_OFF64 = 127
const _SC_XBS5_LPBIG_OFFBIG = 128
const _SC_XOPEN_CRYPT = 92
const _SC_XOPEN_ENH_I18N = 93
const _SC_XOPEN_LEGACY = 129
const _SC_XOPEN_REALTIME = 130
const _SC_XOPEN_REALTIME_THREADS = 131
const _SC_XOPEN_SHM = 94
const _SC_XOPEN_STREAMS = 246
const _SC_XOPEN_UNIX = 91
const _SC_XOPEN_VERSION = 89
const _SC_XOPEN_XCU_VERSION = 90
const _SC_XOPEN_XPG2 = 98
const _SC_XOPEN_XPG3 = 99
const _SC_XOPEN_XPG4 = 100
const _STDC_PREDEF_H = 1
const _THREAD_SAFE = 1
const _XOPEN_ENH_I18N = 1
const _XOPEN_IOV_MAX = 16
const _XOPEN_NAME_MAX = 255
const _XOPEN_PATH_MAX = 1024
const _XOPEN_UNIX = 1
const _XOPEN_VERSION = 700
const __ARCH__ = 9
const __ATOMIC_ACQUIRE = 2
const __ATOMIC_ACQ_REL = 4
const __ATOMIC_CONSUME = 1
const __ATOMIC_RELAXED = 0
const __ATOMIC_RELEASE = 3
const __ATOMIC_SEQ_CST = 5
const __BIGGEST_ALIGNMENT__ = 8
const __BIG_ENDIAN = 4321
const __BYTE_ORDER = 4321
const __BYTE_ORDER__ = 4321
const __CCGO__ = 1
const __CHAR_BIT__ = 8
const __CHAR_UNSIGNED__ = 1
const __DBL_DECIMAL_DIG__ = 17
const __DBL_DIG__ = 15
const __DBL_HAS_DENORM__ = 1
const __DBL_HAS_INFINITY__ = 1
const __DBL_HAS_QUIET_NAN__ = 1
const __DBL_MANT_DIG__ = 53
const __DBL_MAX_10_EXP__ = 308
const __DBL_MAX_EXP__ = 1024
const __DBL_MIN_10_EXP__ = -307
const __DBL_MIN_EXP__ = -1021
const __DEC128_EPSILON__ = 0
const __DEC128_MANT_DIG__ = 34
const __DEC128_MAX_EXP__ = 6145
const __DEC128_MAX__ = 0
const __DEC128_MIN_EXP__ = -6142
const __DEC128_MIN__ = 0
const __DEC128_SUBNORMAL_MIN__ = 0
const __DEC32_EPSILON__ = 0
const __DEC32_MANT_DIG__ = 7
const __DEC32_MAX_EXP__ = 97
const __DEC32_MAX__ = 0
const __DEC32_MIN_EXP__ = -94
const __DEC32_MIN__ = 0
const __DEC32_SUBNORMAL_MIN__ = 0
const __DEC64_EPSILON__ = 0
const __DEC64_MANT_DIG__ = 16
const __DEC64_MAX_EXP__ = 385
const __DEC64_MAX__ = 0
const __DEC64_MIN_EXP__ = -382
const __DEC64_MIN__ = 0
const __DEC64_SUBNORMAL_MIN__ = 0
const __DECIMAL_DIG__ = 17
const __DEC_EVAL_METHOD__ = 2
const __ELF__ = 1
const __FINITE_MATH_ONLY__ = 0
const __FLOAT_WORD_ORDER__ = 4321
const __FLT32X_DECIMAL_DIG__ = 17
const __FLT32X_DENORM_MIN__ = 0
const __FLT32X_DIG__ = 15
const __FLT32X_EPSILON__ = 0
const __FLT32X_HAS_DENORM__ = 1
const __FLT32X_HAS_INFINITY__ = 1
const __FLT32X_HAS_QUIET_NAN__ = 1
const __FLT32X_MANT_DIG__ = 53
const __FLT32X_MAX_10_EXP__ = 308
const __FLT32X_MAX_EXP__ = 1024
const __FLT32X_MAX__ = 0
const __FLT32X_MIN_10_EXP__ = -307
const __FLT32X_MIN_EXP__ = -1021
const __FLT32X_MIN__ = 0
const __FLT32X_NORM_MAX__ = 0
const __FLT32_DECIMAL_DIG__ = 9
const __FLT32_DENORM_MIN__ = 0
const __FLT32_DIG__ = 6
const __FLT32_EPSILON__ = 0
const __FLT32_HAS_DENORM__ = 1
const __FLT32_HAS_INFINITY__ = 1
const __FLT32_HAS_QUIET_NAN__ = 1
const __FLT32_MANT_DIG__ = 24
const __FLT32_MAX_10_EXP__ = 38
const __FLT32_MAX_EXP__ = 128
const __FLT32_MAX__ = 0
const __FLT32_MIN_10_EXP__ = -37
const __FLT32_MIN_EXP__ = -125
const __FLT32_MIN__ = 0
const __FLT32_NORM_MAX__ = 0
const __FLT64_DECIMAL_DIG__ = 17
const __FLT64_DENORM_MIN__ = 0
const __FLT64_DIG__ = 15
const __FLT64_EPSILON__ = 0
const __FLT64_HAS_DENORM__ = 1
const __FLT64_HAS_INFINITY__ = 1
const __FLT64_HAS_QUIET_NAN__ = 1
const __FLT64_MANT_DIG__ = 53
const __FLT64_MAX_10_EXP__ = 308
const __FLT64_MAX_EXP__ = 1024
const __FLT64_MAX__ = 0
const __FLT64_MIN_10_EXP__ = -307
const __FLT64_MIN_EXP__ = -1021
const __FLT64_MIN__ = 0
const __FLT64_NORM_MAX__ = 0
const __FLT_DECIMAL_DIG__ = 9
const __FLT_DENORM_MIN__ = 0
const __FLT_DIG__ = 6
const __FLT_EPSILON__ = 0
const __FLT_EVAL_METHOD_TS_18661_3__ = 0
const __FLT_EVAL_METHOD__ = 0
const __FLT_HAS_DENORM__ = 1
const __FLT_HAS_INFINITY__ = 1
const __FLT_HAS_QUIET_NAN__ = 1
const __FLT_MANT_DIG__ = 24
const __FLT_MAX_10_EXP__ = 38
const __FLT_MAX_EXP__ = 128
const __FLT_MAX__ = 0
const __FLT_MIN_10_EXP__ = -37
const __FLT_MIN_EXP__ = -125
const __FLT_MIN__ = 0
const __FLT_NORM_MAX__ = 0
const __FLT_RADIX__ = 2
const __FP_FAST_FMA = 1
const __FP_FAST_FMAF = 1
const __FP_FAST_FMAF32 = 1
const __FP_FAST_FMAF32x = 1
const __FP_FAST_FMAF64 = 1
const __FP_FAST_FMAL = 1
const __FUNCTION__ = 0
const __GCC_ATOMIC_BOOL_LOCK_FREE = 2
const __GCC_ATOMIC_CHAR16_T_LOCK_FREE = 2
const __GCC_ATOMIC_CHAR32_T_LOCK_FREE = 2
const __GCC_ATOMIC_CHAR_LOCK_FREE = 2
const __GCC_ATOMIC_INT_LOCK_FREE = 2
const __GCC_ATOMIC_LLONG_LOCK_FREE = 2
const __GCC_ATOMIC_LONG_LOCK_FREE = 2
const __GCC_ATOMIC_POINTER_LOCK_FREE = 2
const __GCC_ATOMIC_SHORT_LOCK_FREE = 2
const __GCC_ATOMIC_TEST_AND_SET_TRUEVAL = 1
const __GCC_ATOMIC_WCHAR_T_LOCK_FREE = 2
const __GCC_HAVE_DWARF2_CFI_ASM = 1
const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1 = 1
const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_16 = 1
const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2 = 1
const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 = 1
const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 = 1
const __GCC_IEC_559 = 2
const __GCC_IEC_559_COMPLEX = 2
const __GNUC_MINOR__ = 2
const __GNUC_PATCHLEVEL__ = 1
const __GNUC_STDC_INLINE__ = 1
const __GNUC__ = 10
const __GXX_ABI_VERSION = 1014
const __HAVE_SPECULATION_SAFE_VALUE = 1
const __INT16_MAX__ = 32767
const __INT32_MAX__ = 2147483647
const __INT32_TYPE__ = 0
const __INT64_MAX__ = 9223372036854775807
const __INT8_MAX__ = 127
const __INTMAX_MAX__ = 9223372036854775807
const __INTMAX_WIDTH__ = 64
const __INTPTR_MAX__ = 9223372036854775807
const __INTPTR_WIDTH__ = 64
const __INT_FAST16_MAX__ = 9223372036854775807
const __INT_FAST16_WIDTH__ = 64
const __INT_FAST32_MAX__ = 9223372036854775807
const __INT_FAST32_WIDTH__ = 64
const __INT_FAST64_MAX__ = 9223372036854775807
const __INT_FAST64_WIDTH__ = 64
const __INT_FAST8_MAX__ = 127
const __INT_FAST8_WIDTH__ = 8
const __INT_LEAST16_MAX__ = 32767
const __INT_LEAST16_WIDTH__ = 16
const __INT_LEAST32_MAX__ = 2147483647
const __INT_LEAST32_TYPE__ = 0
const __INT_LEAST32_WIDTH__ = 32
const __INT_LEAST64_MAX__ = 9223372036854775807
const __INT_LEAST64_WIDTH__ = 64
const __INT_LEAST8_MAX__ = 127
const __INT_LEAST8_WIDTH__ = 8
const __INT_MAX__ = 2147483647
const __INT_WIDTH__ = 32
const __LDBL_DECIMAL_DIG__ = 17
const __LDBL_DENORM_MIN__ = 0
const __LDBL_DIG__ = 15
const __LDBL_EPSILON__ = 0
const __LDBL_HAS_DENORM__ = 1
const __LDBL_HAS_INFINITY__ = 1
const __LDBL_HAS_QUIET_NAN__ = 1
const __LDBL_MANT_DIG__ = 53
const __LDBL_MAX_10_EXP__ = 308
const __LDBL_MAX_EXP__ = 1024
const __LDBL_MAX__ = 0
const __LDBL_MIN_10_EXP__ = -307
const __LDBL_MIN_EXP__ = -1021
const __LDBL_MIN__ = 0
const __LDBL_NORM_MAX__ = 0
const __LITTLE_ENDIAN = 1234
const __LONG_LONG_MAX__ = 9223372036854775807
const __LONG_LONG_WIDTH__ = 64
const __LONG_MAX = 9223372036854775807
const __LONG_MAX__ = 9223372036854775807
const __LONG_WIDTH__ = 64
const __LP64__ = 1
const __OPTIMIZE__ = 1
const __ORDER_BIG_ENDIAN__ = 4321
const __ORDER_LITTLE_ENDIAN__ = 1234
const __ORDER_PDP_ENDIAN__ = 3412
const __PDP_ENDIAN = 3412
const __PIC__ = 2
const __PIE__ = 2
const __PRAGMA_REDEFINE_EXTNAME = 1
const __PRETTY_FUNCTION__ = 0
const __PRI64 = "l"
const __PRIPTR = "l"
const __PTRDIFF_MAX__ = 9223372036854775807
const __PTRDIFF_WIDTH__ = 64
const __SCHAR_MAX__ = 127
const __SCHAR_WIDTH__ = 8
const __SHRT_MAX__ = 32767
const __SHRT_WIDTH__ = 16
const __SIG_ATOMIC_MAX__ = 2147483647
const __SIG_ATOMIC_MIN__ = -2147483648
const __SIG_ATOMIC_TYPE__ = 0
const __SIG_ATOMIC_WIDTH__ = 32
const __SIZEOF_DOUBLE__ = 8
const __SIZEOF_FLOAT__ = 4
const __SIZEOF_INT__ = 4
const __SIZEOF_LONG_DOUBLE__ = 8
const __SIZEOF_LONG_LONG__ = 8
const __SIZEOF_LONG__ = 8
const __SIZEOF_POINTER__ = 8
const __SIZEOF_PTRDIFF_T__ = 8
const __SIZEOF_SHORT__ = 2
const __SIZEOF_SIZE_T__ = 8
const __SIZEOF_WCHAR_T__ = 4
const __SIZEOF_WINT_T__ = 4
const __SIZE_MAX__ = 18446744073709551615
const __SIZE_WIDTH__ = 64
const __STDC_HOSTED__ = 1
const __STDC_IEC_559_COMPLEX__ = 1
const __STDC_IEC_559__ = 1
const __STDC_ISO_10646__ = 201706
const __STDC_UTF_16__ = 1
const __STDC_UTF_32__ = 1
const __STDC_VERSION__ = 201710
const __STDC__ = 1
const __UAPI_DEF_IN6_ADDR = 0
const __UAPI_DEF_IN6_ADDR_ALT = 0
const __UAPI_DEF_IN6_PKTINFO = 0
const __UAPI_DEF_IN_ADDR = 0
const __UAPI_DEF_IN_CLASS = 0
const __UAPI_DEF_IN_IPPROTO = 0
const __UAPI_DEF_IN_PKTINFO = 0
const __UAPI_DEF_IP6_MTUINFO = 0
const __UAPI_DEF_IPPROTO_V6 = 0
const __UAPI_DEF_IPV6_MREQ = 0
const __UAPI_DEF_IPV6_OPTIONS = 0
const __UAPI_DEF_IP_MREQ = 0
const __UAPI_DEF_SOCKADDR_IN = 0
const __UAPI_DEF_SOCKADDR_IN6 = 0
const __UINT16_MAX__ = 65535
const __UINT32_MAX__ = 4294967295
const __UINT64_MAX__ = 18446744073709551615
const __UINT8_MAX__ = 255
const __UINTMAX_MAX__ = 18446744073709551615
const __UINTPTR_MAX__ = 18446744073709551615
const __UINT_FAST16_MAX__ = 18446744073709551615
const __UINT_FAST32_MAX__ = 18446744073709551615
const __UINT_FAST64_MAX__ = 18446744073709551615
const __UINT_FAST8_MAX__ = 255
const __UINT_LEAST16_MAX__ = 65535
const __UINT_LEAST32_MAX__ = 4294967295
const __UINT_LEAST64_MAX__ = 18446744073709551615
const __UINT_LEAST8_MAX__ = 255
const __USE_TIME_BITS64 = 1
const __VERSION__ = "10.2.1 20210110"
const __WALL = 1073741824
const __WCHAR_MAX__ = 2147483647
const __WCHAR_MIN__ = -2147483648
const __WCHAR_TYPE__ = 0
const __WCHAR_WIDTH__ = 32
const __WCLONE = 2147483648
const __WINT_MAX__ = 4294967295
const __WINT_MIN__ = 0
const __WINT_WIDTH__ = 32
const __WNOTHREAD = 536870912
const __gnu_linux__ = 1
const __inline = 0
const __linux = 1
const __linux__ = 1
const __pic__ = 2
const __pie__ = 2
const __restrict = 0
const __restrict_arr = 0
const __s390__ = 1
const __s390x__ = 1
const __tm_gmtoff = 0
const __tm_zone = 0
const __ucontext = 0
const __unix = 1
const __unix__ = 1
const __zarch__ = 1
const alloca = 0
const alphasort64 = 0
const blkcnt64_t = 0
const compile = 0
const creat64 = 0
const d_fileno = 0
const dirent64 = 0
const errno = 0
const exec = 0
const fallocate64 = 0
const fgetpos64 = 0
const flock64 = 0
const fopen64 = 0
const fpos64_t = 0
const freechain = 0
const freopen64 = 0
const fsblkcnt64_t = 0
const fseeko64 = 0
const fsetpos64 = 0
const fsfilcnt64_t = 0
const fstat64 = 0
const fstatat64 = 0
const ftello64 = 0
const ftruncate64 = 0
const getdents64 = 0
const getrlimit64 = 0
const h_errno = 0
const ino64_t = 0
const linux = 1
const lockf64 = 0
const loff_t = 0
const lseek64 = 0
const lstat64 = 0
const mkostemp64 = 0
const mkostemps64 = 0
const mkstemp64 = 0
const mkstemps64 = 0
const off64_t = 0
const open64 = 0
const openat64 = 0
const posix_fadvise64 = 0
const posix_fallocate64 = 0
const pread64 = 0
const prlimit64 = 0
const pwrite64 = 0
const readdir64 = 0
const readdir64_r = 0
const regerror = 0
const regfree = 0
const rlim64_t = 0
const rlimit64 = 0
const scandir64 = 0
const setrlimit64 = 0
const stat64 = 0
const static_assert = 0
const tmpfile64 = 0
const truncate64 = 0
const unix = 1
const versionsort64 = 0

type T__builtin_va_list = uintptr

type T__predefined_size_t = uint64

type T__predefined_wchar_t = int32

type T__predefined_ptrdiff_t = int64

type Tsize_t = uint64

type Tssize_t = int64

type Tmode_t = uint32

type Toff_t = int64

type Tpid_t = int32

type Tiovec = struct {
	Fiov_base uintptr
	Fiov_len  Tsize_t
}

type Tflock = struct {
	Fl_type   int16
	Fl_whence int16
	Fl_start  Toff_t
	Fl_len    Toff_t
	Fl_pid    Tpid_t
}

type Tfile_handle = struct {
	Fhandle_bytes uint32
	Fhandle_type  int32
}

type Tf_owner_ex = struct {
	Ftype1 int32
	Fpid   Tpid_t
}

type Tuid_t = uint32

type Tgid_t = uint32

type Tpasswd = struct {
	Fpw_name   uintptr
	Fpw_passwd uintptr
	Fpw_uid    Tuid_t
	Fpw_gid    Tgid_t
	Fpw_gecos  uintptr
	Fpw_dir    uintptr
	Fpw_shell  uintptr
}

type Ttime_t = int64

type Tclock_t = int64

type Ttimespec = struct {
	Ftv_sec  Ttime_t
	Ftv_nsec int64
}

type Tpthread_t = uintptr

type Tsigset_t = struct {
	F__bits [16]uint64
}

type T__sigset_t = Tsigset_t

type Tpthread_attr_t = struct {
	F__u struct {
		F__vi [0][14]int32
		F__s  [0][7]uint64
		F__i  [14]int32
	}
}

type Tstack_t = struct {
	Fss_sp    uintptr
	Fss_flags int32
	Fss_size  Tsize_t
}

type Tsigaltstack = Tstack_t

type Tgreg_t = uint64

type Tgregset_t = [27]uint64

type T__psw_t = struct {
	Fmask uint64
	Faddr uint64
}

type Tfpreg_t = struct {
	Ff [0]float32
	Fd float64
}

type Tfpregset_t = struct {
	Ffpc  uint32
	Ffprs [16]Tfpreg_t
}

type Tmcontext_t = struct {
	Fpsw    T__psw_t
	Fgregs  [16]uint64
	Faregs  [16]uint32
	Ffpregs Tfpregset_t
}

type Tsigcontext = struct {
	Foldmask [1]uint64
	Fsregs   uintptr
}

type Tucontext_t = struct {
	Fuc_flags    uint64
	Fuc_link     uintptr
	Fuc_stack    Tstack_t
	Fuc_mcontext Tmcontext_t
	Fuc_sigmask  Tsigset_t
}

type Tucontext = Tucontext_t

type Tsigval = struct {
	Fsival_ptr   [0]uintptr
	Fsival_int   int32
	F__ccgo_pad2 [4]byte
}

type Tsiginfo_t = struct {
	Fsi_signo    int32
	Fsi_errno    int32
	Fsi_code     int32
	F__si_fields struct {
		F__si_common [0]struct {
			F__first struct {
				F__timer [0]struct {
					Fsi_timerid int32
					Fsi_overrun int32
				}
				F__piduid struct {
					Fsi_pid Tpid_t
					Fsi_uid Tuid_t
				}
			}
			F__second struct {
				F__sigchld [0]struct {
					Fsi_status int32
					Fsi_utime  Tclock_t
					Fsi_stime  Tclock_t
				}
				Fsi_value    Tsigval
				F__ccgo_pad2 [16]byte
			}
		}
		F__sigfault [0]struct {
			Fsi_addr     uintptr
			Fsi_addr_lsb int16
			F__first     struct {
				Fsi_pkey    [0]uint32
				F__addr_bnd struct {
					Fsi_lower uintptr
					Fsi_upper uintptr
				}
			}
		}
		F__sigpoll [0]struct {
			Fsi_band int64
			Fsi_fd   int32
		}
		F__sigsys [0]struct {
			Fsi_call_addr uintptr
			Fsi_syscall   int32
			Fsi_arch      uint32
		}
		F__pad [112]uint8
	}
}

type Tsigaction = struct {
	F__sa_handler struct {
		Fsa_sigaction [0]uintptr
		Fsa_handler   uintptr
	}
	Fsa_mask     Tsigset_t
	Fsa_flags    int32
	Fsa_restorer uintptr
}

type Tsigevent = struct {
	Fsigev_value  Tsigval
	Fsigev_signo  int32
	Fsigev_notify int32
	F__sev_fields struct {
		Fsigev_notify_thread_id [0]Tpid_t
		F__sev_thread           [0]struct {
			Fsigev_notify_function   uintptr
			Fsigev_notify_attributes uintptr
		}
		F__pad [48]uint8
	}
}

type Tsig_t = uintptr

type Tsighandler_t = uintptr

type Tsig_atomic_t = int32

type Tsuseconds_t = int64

type Ttimeval = struct {
	Ftv_sec  Ttime_t
	Ftv_usec Tsuseconds_t
}

type Tfd_mask = uint64

type Tfd_set = struct {
	Ffds_bits [16]uint64
}

type Titimerval = struct {
	Fit_interval Ttimeval
	Fit_value    Ttimeval
}

type Ttimezone = struct {
	Ftz_minuteswest int32
	Ftz_dsttime     int32
}

type Tid_t = uint32

type Trlim_t = uint64

type Trlimit = struct {
	Frlim_cur Trlim_t
	Frlim_max Trlim_t
}

type Trusage = struct {
	Fru_utime    Ttimeval
	Fru_stime    Ttimeval
	Fru_maxrss   int64
	Fru_ixrss    int64
	Fru_idrss    int64
	Fru_isrss    int64
	Fru_minflt   int64
	Fru_majflt   int64
	Fru_nswap    int64
	Fru_inblock  int64
	Fru_oublock  int64
	Fru_msgsnd   int64
	Fru_msgrcv   int64
	Fru_nsignals int64
	Fru_nvcsw    int64
	Fru_nivcsw   int64
	F__reserved  [16]int64
}

type Tuint16_t = uint16

type Tuint32_t = uint32

type Tuint64_t = uint64

type Tregister_t = int64

type Tint8_t = int8

type Tint16_t = int16

type Tint32_t = int32

type Tint64_t = int64

type Tu_int64_t = uint64

type Tnlink_t = uint64

type Tino_t = uint64

type Tdev_t = uint64

type Tblksize_t = int64

type Tblkcnt_t = int64

type Tfsblkcnt_t = uint64

type Tfsfilcnt_t = uint64

type Ttimer_t = uintptr

type Tclockid_t = int32

type Tkey_t = int32

type Tuseconds_t = uint32

type Tpthread_once_t = int32

type Tpthread_key_t = uint32

type Tpthread_spinlock_t = int32

type Tpthread_mutexattr_t = struct {
	F__attr uint32
}

type Tpthread_condattr_t = struct {
	F__attr uint32
}

type Tpthread_barrierattr_t = struct {
	F__attr uint32
}

type Tpthread_rwlockattr_t = struct {
	F__attr [2]uint32
}

type Tpthread_mutex_t = struct {
	F__u struct {
		F__vi [0][10]int32
		F__p  [0][5]uintptr
		F__i  [10]int32
	}
}

type Tpthread_cond_t = struct {
	F__u struct {
		F__vi [0][12]int32
		F__p  [0][6]uintptr
		F__i  [12]int32
	}
}

type Tpthread_rwlock_t = struct {
	F__u struct {
		F__vi [0][14]int32
		F__p  [0][7]uintptr
		F__i  [14]int32
	}
}

type Tpthread_barrier_t = struct {
	F__u struct {
		F__vi [0][8]int32
		F__p  [0][4]uintptr
		F__i  [8]int32
	}
}

type Tu_int8_t = uint8

type Tu_int16_t = uint16

type Tu_int32_t = uint32

type Tcaddr_t = uintptr

type Tu_char = uint8

type Tu_short = uint16

type Tushort = uint16

type Tu_int = uint32

type Tuint = uint32

type Tu_long = uint64

type Tulong = uint64

type Tquad_t = int64

type Tu_quad_t = uint64

type Tdirent = struct {
	Fd_ino    Tino_t
	Fd_off    Toff_t
	Fd_reclen uint16
	Fd_type   uint8
	Fd_name   [256]uint8
}

type TTcl_DirEntry = struct {
	Fd_ino    Tino_t
	Fd_off    Toff_t
	Fd_reclen uint16
	Fd_type   uint8
	Fd_name   [256]uint8
}

type TTcl_SeekOffset = int64

type Tstat = struct {
	Fst_dev     Tdev_t
	Fst_ino     Tino_t
	Fst_nlink   Tnlink_t
	Fst_mode    Tmode_t
	Fst_uid     Tuid_t
	Fst_gid     Tgid_t
	Fst_rdev    Tdev_t
	Fst_size    Toff_t
	Fst_atim    Ttimespec
	Fst_mtim    Ttimespec
	Fst_ctim    Ttimespec
	Fst_blksize Tblksize_t
	Fst_blocks  Tblkcnt_t
	F__unused   [3]uint64
}

type Tstatx_timestamp = struct {
	Ftv_sec  Tint64_t
	Ftv_nsec Tuint32_t
	F__pad   Tuint32_t
}

type Tstatx = struct {
	Fstx_mask            Tuint32_t
	Fstx_blksize         Tuint32_t
	Fstx_attributes      Tuint64_t
	Fstx_nlink           Tuint32_t
	Fstx_uid             Tuint32_t
	Fstx_gid             Tuint32_t
	Fstx_mode            Tuint16_t
	F__pad0              [1]Tuint16_t
	Fstx_ino             Tuint64_t
	Fstx_size            Tuint64_t
	Fstx_blocks          Tuint64_t
	Fstx_attributes_mask Tuint64_t
	Fstx_atime           Tstatx_timestamp
	Fstx_btime           Tstatx_timestamp
	Fstx_ctime           Tstatx_timestamp
	Fstx_mtime           Tstatx_timestamp
	Fstx_rdev_major      Tuint32_t
	Fstx_rdev_minor      Tuint32_t
	Fstx_dev_major       Tuint32_t
	Fstx_dev_minor       Tuint32_t
	F__pad1              [14]Tuint64_t
}

type Tlocale_t = uintptr

type Ttm = struct {
	Ftm_sec    int32
	Ftm_min    int32
	Ftm_hour   int32
	Ftm_mday   int32
	Ftm_mon    int32
	Ftm_year   int32
	Ftm_wday   int32
	Ftm_yday   int32
	Ftm_isdst  int32
	Ftm_gmtoff int64
	Ftm_zone   uintptr
}

type Titimerspec = struct {
	Fit_interval Ttimespec
	Fit_value    Ttimespec
}

type Tidtype_t = int32

const P_ALL = 0
const P_PID = 1
const P_PGID = 2
const P_PIDFD = 3

type Tuintptr_t = uint64

type Tintptr_t = int64

type Tintmax_t = int64

type Tuint8_t = uint8

type Tuintmax_t = uint64

type Tint_fast8_t = int8

type Tint_fast64_t = int64

type Tint_least8_t = int8

type Tint_least16_t = int16

type Tint_least32_t = int32

type Tint_least64_t = int64

type Tuint_fast8_t = uint8

type Tuint_fast64_t = uint64

type Tuint_least8_t = uint8

type Tuint_least16_t = uint16

type Tuint_least32_t = uint32

type Tuint_least64_t = uint64

type Tint_fast16_t = int32

type Tint_fast32_t = int32

type Tuint_fast16_t = uint32

type Tuint_fast32_t = uint32

type Twchar_t = int32

type Timaxdiv_t = struct {
	Fquot Tintmax_t
	Frem  Tintmax_t
}

type Tutimbuf = struct {
	Factime  Ttime_t
	Fmodtime Ttime_t
}

type Tsocklen_t = uint32

type Tsa_family_t = uint16

type Tmsghdr = struct {
	Fmsg_name       uintptr
	Fmsg_namelen    Tsocklen_t
	Fmsg_iov        uintptr
	F__pad1         int32
	Fmsg_iovlen     int32
	Fmsg_control    uintptr
	F__pad2         int32
	Fmsg_controllen Tsocklen_t
	Fmsg_flags      int32
}

type Tcmsghdr = struct {
	F__pad1     int32
	Fcmsg_len   Tsocklen_t
	Fcmsg_level int32
	Fcmsg_type  int32
}

type Tucred = struct {
	Fpid Tpid_t
	Fuid Tuid_t
	Fgid Tgid_t
}

type Tmmsghdr = struct {
	Fmsg_hdr Tmsghdr
	Fmsg_len uint32
}

type Tlinger = struct {
	Fl_onoff  int32
	Fl_linger int32
}

type Tsockaddr = struct {
	Fsa_family Tsa_family_t
	Fsa_data   [14]uint8
}

type Tsockaddr_storage = struct {
	Fss_family    Tsa_family_t
	F__ss_padding [118]uint8
	F__ss_align   uint64
}

type Tutsname = struct {
	Fsysname    [65]uint8
	Fnodename   [65]uint8
	Frelease    [65]uint8
	Fversion    [65]uint8
	Fmachine    [65]uint8
	Fdomainname [65]uint8
}

type Tin_port_t = uint16

type Tin_addr_t = uint32

type Tin_addr = struct {
	Fs_addr Tin_addr_t
}

type Tsockaddr_in = struct {
	Fsin_family Tsa_family_t
	Fsin_port   Tin_port_t
	Fsin_addr   Tin_addr
	Fsin_zero   [8]Tuint8_t
}

type Tin6_addr = struct {
	F__in6_union struct {
		F__s6_addr16 [0][8]Tuint16_t
		F__s6_addr32 [0][4]Tuint32_t
		F__s6_addr   [16]Tuint8_t
	}
}

type Tsockaddr_in6 = struct {
	Fsin6_family   Tsa_family_t
	Fsin6_port     Tin_port_t
	Fsin6_flowinfo Tuint32_t
	Fsin6_addr     Tin6_addr
	Fsin6_scope_id Tuint32_t
}

type Tipv6_mreq = struct {
	Fipv6mr_multiaddr Tin6_addr
	Fipv6mr_interface uint32
}

type Tip_opts = struct {
	Fip_dst  Tin_addr
	Fip_opts [40]uint8
}

type Tip_mreq = struct {
	Fimr_multiaddr Tin_addr
	Fimr_interface Tin_addr
}

type Tip_mreqn = struct {
	Fimr_multiaddr Tin_addr
	Fimr_address   Tin_addr
	Fimr_ifindex   int32
}

type Tip_mreq_source = struct {
	Fimr_multiaddr  Tin_addr
	Fimr_interface  Tin_addr
	Fimr_sourceaddr Tin_addr
}

type Tip_msfilter = struct {
	Fimsf_multiaddr Tin_addr
	Fimsf_interface Tin_addr
	Fimsf_fmode     Tuint32_t
	Fimsf_numsrc    Tuint32_t
	Fimsf_slist     [1]Tin_addr
}

type Tgroup_req = struct {
	Fgr_interface Tuint32_t
	Fgr_group     Tsockaddr_storage
}

type Tgroup_source_req = struct {
	Fgsr_interface Tuint32_t
	Fgsr_group     Tsockaddr_storage
	Fgsr_source    Tsockaddr_storage
}

type Tgroup_filter = struct {
	Fgf_interface Tuint32_t
	Fgf_group     Tsockaddr_storage
	Fgf_fmode     Tuint32_t
	Fgf_numsrc    Tuint32_t
	Fgf_slist     [1]Tsockaddr_storage
}

type Tin_pktinfo = struct {
	Fipi_ifindex  int32
	Fipi_spec_dst Tin_addr
	Fipi_addr     Tin_addr
}

type Tin6_pktinfo = struct {
	Fipi6_addr    Tin6_addr
	Fipi6_ifindex uint32
}

type Tip6_mtuinfo = struct {
	Fip6m_addr Tsockaddr_in6
	Fip6m_mtu  Tuint32_t
}

type Taddrinfo = struct {
	Fai_flags     int32
	Fai_family    int32
	Fai_socktype  int32
	Fai_protocol  int32
	Fai_addrlen   Tsocklen_t
	Fai_addr      uintptr
	Fai_canonname uintptr
	Fai_next      uintptr
}

type Tnetent = struct {
	Fn_name     uintptr
	Fn_aliases  uintptr
	Fn_addrtype int32
	Fn_net      Tuint32_t
}

type Thostent = struct {
	Fh_name      uintptr
	Fh_aliases   uintptr
	Fh_addrtype  int32
	Fh_length    int32
	Fh_addr_list uintptr
}

type Tservent = struct {
	Fs_name    uintptr
	Fs_aliases uintptr
	Fs_port    int32
	Fs_proto   uintptr
}

type Tprotoent = struct {
	Fp_name    uintptr
	Fp_aliases uintptr
	Fp_proto   int32
}

type Tsched_param = struct {
	Fsched_priority int32
	F__reserved1    int32
	F__reserved2    [2]struct {
		F__reserved1 Ttime_t
		F__reserved2 int64
	}
	F__reserved3 int32
}

type Tcpu_set_t = struct {
	F__bits [16]uint64
}

type T__ptcb = struct {
	F__f    uintptr
	F__x    uintptr
	F__next uintptr
}

type Tcpu_set_t1 = struct {
	F__bits [16]uint64
}

type Tgroup = struct {
	Fgr_name   uintptr
	Fgr_passwd uintptr
	Fgr_gid    Tgid_t
	Fgr_mem    uintptr
}

type Tva_list = uintptr

type T__isoc_va_list = uintptr

type Tfpos_t = struct {
	F__lldata [0]int64
	F__align  [0]float64
	F__opaque [16]uint8
}

type T_G_fpos64_t = Tfpos_t

type Tcookie_io_functions_t = struct {
	Fread   uintptr
	Fwrite  uintptr
	Fseek   uintptr
	Fclose1 uintptr
}

type T_IO_cookie_io_functions_t = Tcookie_io_functions_t

type Tmax_align_t = struct {
	F__ll int64
	F__ld float64
}

type Tptrdiff_t = int64

type TClientData = uintptr

type TTcl_WideInt = int64

type TTcl_WideUInt = uint64

type TTcl_Size = int64

type TTcl_StatBuf = struct {
	Fst_dev     Tdev_t
	Fst_ino     Tino_t
	Fst_nlink   Tnlink_t
	Fst_mode    Tmode_t
	Fst_uid     Tuid_t
	Fst_gid     Tgid_t
	Fst_rdev    Tdev_t
	Fst_size    Toff_t
	Fst_atim    Ttimespec
	Fst_mtim    Ttimespec
	Fst_ctim    Ttimespec
	Fst_blksize Tblksize_t
	Fst_blocks  Tblkcnt_t
	F__unused   [3]uint64
}

type TTcl_AsyncHandler = uintptr

type TTcl_Channel = uintptr

type TTcl_ChannelTypeVersion = uintptr

type TTcl_Command = uintptr

type TTcl_Condition = uintptr

type TTcl_Dict = uintptr

type TTcl_EncodingState = uintptr

type TTcl_Encoding = uintptr

type TTcl_Event = struct {
	Fproc    uintptr
	FnextPtr uintptr
}

type TTcl_InterpState = uintptr

type TTcl_LoadHandle = uintptr

type TTcl_LoadHandle_ = struct {
	FclientData        uintptr
	FfindSymbolProcPtr uintptr
	FunloadFileProcPtr uintptr
}

type TTcl_Mutex = uintptr

type TTcl_Pid = uintptr

type TTcl_RegExp = uintptr

type TTcl_ThreadDataKey = uintptr

type TTcl_ThreadId = uintptr

type TTcl_TimerToken = uintptr

type TTcl_Trace = uintptr

type TTcl_Var = uintptr

type TTcl_ZlibStream = uintptr

type TTcl_RegExpIndices = struct {
	Fstart TTcl_Size
	Fend   TTcl_Size
}

type TTcl_RegExpInfo = struct {
	Fnsubs       TTcl_Size
	Fmatches     uintptr
	FextendStart TTcl_Size
}

type TTcl_Stat_ = uintptr

type TTcl_OldStat_ = uintptr

type TTcl_Obj1 = struct {
	FrefCount    TTcl_Size
	Fbytes       uintptr
	Flength      TTcl_Size
	FtypePtr     uintptr
	FinternalRep TTcl_ObjInternalRep
}

type TTcl_ObjType = struct {
	Fname             uintptr
	FfreeIntRepProc   uintptr
	FdupIntRepProc    uintptr
	FupdateStringProc uintptr
	FsetFromAnyProc   uintptr
	Fversion          Tsize_t
	FlengthProc       uintptr
	FindexProc        uintptr
	FsliceProc        uintptr
	FreverseProc      uintptr
	FgetElementsProc  uintptr
	FsetElementProc   uintptr
	FreplaceProc      uintptr
	FinOperProc       uintptr
}

type TTcl_ObjInternalRep = struct {
	FdoubleValue   [0]float64
	FotherValuePtr [0]uintptr
	FwideValue     [0]TTcl_WideInt
	FtwoPtrValue   [0]struct {
		Fptr1 uintptr
		Fptr2 uintptr
	}
	FptrAndLongRep [0]struct {
		Fptr   uintptr
		Fvalue uint64
	}
	FptrAndSize [0]struct {
		Fptr  uintptr
		Fsize TTcl_Size
	}
	FlongValue   int64
	F__ccgo_pad7 [8]byte
}

type TTcl_Obj = struct {
	FrefCount    TTcl_Size
	Fbytes       uintptr
	Flength      TTcl_Size
	FtypePtr     uintptr
	FinternalRep TTcl_ObjInternalRep
}

type TTcl_Namespace = struct {
	Fname       uintptr
	FfullName   uintptr
	FclientData uintptr
	FdeleteProc uintptr
	FparentPtr  uintptr
}

type TTcl_CallFrame = struct {
	FnsPtr   uintptr
	Fdummy1  int32
	Fdummy2  TTcl_Size
	Fdummy3  uintptr
	Fdummy4  uintptr
	Fdummy5  uintptr
	Fdummy6  TTcl_Size
	Fdummy7  uintptr
	Fdummy8  uintptr
	Fdummy9  TTcl_Size
	Fdummy10 uintptr
	Fdummy11 uintptr
	Fdummy12 uintptr
	Fdummy13 uintptr
}

type TTcl_CmdInfo = struct {
	FisNativeObjectProc int32
	FobjProc            uintptr
	FobjClientData      uintptr
	Fproc               uintptr
	FclientData         uintptr
	FdeleteProc         uintptr
	FdeleteData         uintptr
	FnamespacePtr       uintptr
	FobjProc2           uintptr
	FobjClientData2     uintptr
}

type TTcl_DString = struct {
	Fstring1     uintptr
	Flength      TTcl_Size
	FspaceAvl    TTcl_Size
	FstaticSpace [200]uint8
}

type TTcl_HashKeyType = struct {
	Fversion         int32
	Fflags           int32
	FhashKeyProc     uintptr
	FcompareKeysProc uintptr
	FallocEntryProc  uintptr
	FfreeEntryProc   uintptr
}

type TTcl_HashTable = struct {
	Fbuckets       uintptr
	FstaticBuckets [4]uintptr
	FnumBuckets    TTcl_Size
	FnumEntries    TTcl_Size
	FrebuildSize   TTcl_Size
	Fmask          Tsize_t
	FdownShift     int32
	FkeyType       int32
	FfindProc      uintptr
	FcreateProc    uintptr
	FtypePtr       uintptr
}

type TTcl_HashEntry = struct {
	FnextPtr    uintptr
	FtablePtr   uintptr
	Fhash       Tsize_t
	FclientData uintptr
	Fkey        struct {
		FobjPtr       [0]uintptr
		Fwords        [0][1]int32
		Fstring1      [0][1]uint8
		FoneWordValue uintptr
	}
}

type TTcl_HashEntry1 = struct {
	FnextPtr    uintptr
	FtablePtr   uintptr
	Fhash       Tsize_t
	FclientData uintptr
	Fkey        struct {
		FobjPtr       [0]uintptr
		Fwords        [0][1]int32
		Fstring1      [0][1]uint8
		FoneWordValue uintptr
	}
}

type TTcl_HashKeyType1 = struct {
	Fversion         int32
	Fflags           int32
	FhashKeyProc     uintptr
	FcompareKeysProc uintptr
	FallocEntryProc  uintptr
	FfreeEntryProc   uintptr
}

type TTcl_HashTable1 = struct {
	Fbuckets       uintptr
	FstaticBuckets [4]uintptr
	FnumBuckets    TTcl_Size
	FnumEntries    TTcl_Size
	FrebuildSize   TTcl_Size
	Fmask          Tsize_t
	FdownShift     int32
	FkeyType       int32
	FfindProc      uintptr
	FcreateProc    uintptr
	FtypePtr       uintptr
}

type TTcl_HashSearch = struct {
	FtablePtr     uintptr
	FnextIndex    TTcl_Size
	FnextEntryPtr uintptr
}

type TTcl_DictSearch = struct {
	Fnext          uintptr
	Fepoch         Tsize_t
	FdictionaryPtr TTcl_Dict
}

type TTcl_Event1 = struct {
	Fproc    uintptr
	FnextPtr uintptr
}

type TTcl_QueuePosition = int32

const TCL_QUEUE_TAIL = 0
const TCL_QUEUE_HEAD = 1
const TCL_QUEUE_MARK = 2
const TCL_QUEUE_ALERT_IF_EMPTY = 4

type TTcl_Time = struct {
	Fsec  int64
	Fusec int64
}

type TTcl_DriverCloseProc = struct{}

type TTcl_DriverSeekProc = struct{}

type TTcl_ChannelType = struct {
	FtypeName         uintptr
	Fversion          TTcl_ChannelTypeVersion
	FcloseProc        uintptr
	FinputProc        uintptr
	FoutputProc       uintptr
	FseekProc         uintptr
	FsetOptionProc    uintptr
	FgetOptionProc    uintptr
	FwatchProc        uintptr
	FgetHandleProc    uintptr
	Fclose2Proc       uintptr
	FblockModeProc    uintptr
	FflushProc        uintptr
	FhandlerProc      uintptr
	FwideSeekProc     uintptr
	FthreadActionProc uintptr
	FtruncateProc     uintptr
}

type TTcl_PathType = int32

type Tcl_PathType = int32

const TCL_PATH_ABSOLUTE = 0
const TCL_PATH_RELATIVE = 1
const TCL_PATH_VOLUME_RELATIVE = 2

type TTcl_GlobTypeData = struct {
	Ftype1      int32
	Fperm       int32
	FmacType    uintptr
	FmacCreator uintptr
}

type TTcl_FSVersion = uintptr

type TTcl_Filesystem = struct {
	FtypeName                 uintptr
	FstructureLength          TTcl_Size
	Fversion                  TTcl_FSVersion
	FpathInFilesystemProc     uintptr
	FdupInternalRepProc       uintptr
	FfreeInternalRepProc      uintptr
	FinternalToNormalizedProc uintptr
	FcreateInternalRepProc    uintptr
	FnormalizePathProc        uintptr
	FfilesystemPathTypeProc   uintptr
	FfilesystemSeparatorProc  uintptr
	FstatProc                 uintptr
	FaccessProc               uintptr
	FopenFileChannelProc      uintptr
	FmatchInDirectoryProc     uintptr
	FutimeProc                uintptr
	FlinkProc                 uintptr
	FlistVolumesProc          uintptr
	FfileAttrStringsProc      uintptr
	FfileAttrsGetProc         uintptr
	FfileAttrsSetProc         uintptr
	FcreateDirectoryProc      uintptr
	FremoveDirectoryProc      uintptr
	FdeleteFileProc           uintptr
	FcopyFileProc             uintptr
	FrenameFileProc           uintptr
	FcopyDirectoryProc        uintptr
	FlstatProc                uintptr
	FloadFileProc             uintptr
	FgetCwdProc               uintptr
	FchdirProc                uintptr
}

type TTcl_NotifierProcs = struct {
	FsetTimerProc          uintptr
	FwaitForEventProc      uintptr
	FcreateFileHandlerProc uintptr
	FdeleteFileHandlerProc uintptr
	FinitNotifierProc      uintptr
	FfinalizeNotifierProc  uintptr
	FalertNotifierProc     uintptr
	FserviceModeHookProc   uintptr
}

type TTcl_Token = struct {
	Ftype1         int32
	Fstart         uintptr
	Fsize          TTcl_Size
	FnumComponents TTcl_Size
}

type TTcl_Parse = struct {
	FcommentStart    uintptr
	FcommentSize     TTcl_Size
	FcommandStart    uintptr
	FcommandSize     TTcl_Size
	FnumWords        TTcl_Size
	FtokenPtr        uintptr
	FnumTokens       TTcl_Size
	FtokensAvailable TTcl_Size
	FerrorType       int32
	Fincomplete      int32
	Fstring1         uintptr
	Fend             uintptr
	Finterp          uintptr
	Fterm            uintptr
	FstaticTokens    [20]TTcl_Token
}

type TTcl_EncodingType = struct {
	FencodingName uintptr
	FtoUtfProc    uintptr
	FfromUtfProc  uintptr
	FfreeProc     uintptr
	FclientData   uintptr
	FnullSize     TTcl_Size
}

type TTcl_UniChar = int32

type TTcl_Config = struct {
	Fkey   uintptr
	Fvalue uintptr
}

type TTcl_ArgvInfo = struct {
	Ftype1      int32
	FkeyStr     uintptr
	FsrcPtr     uintptr
	FdstPtr     uintptr
	FhelpStr    uintptr
	FclientData uintptr
}

type TTclStubHooks = struct {
	FtclPlatStubs    uintptr
	FtclIntStubs     uintptr
	FtclIntPlatStubs uintptr
}

type TTclStubs = struct {
	Fmagic                                  int32
	Fhooks                                  uintptr
	Ftcl_PkgProvideEx                       uintptr
	Ftcl_PkgRequireEx                       uintptr
	Ftcl_Panic                              uintptr
	Ftcl_Alloc                              uintptr
	Ftcl_Free                               uintptr
	Ftcl_Realloc                            uintptr
	Ftcl_DbCkalloc                          uintptr
	Ftcl_DbCkfree                           uintptr
	Ftcl_DbCkrealloc                        uintptr
	Ftcl_CreateFileHandler                  uintptr
	Ftcl_DeleteFileHandler                  uintptr
	Ftcl_SetTimer                           uintptr
	Ftcl_Sleep                              uintptr
	Ftcl_WaitForEvent                       uintptr
	Ftcl_AppendAllObjTypes                  uintptr
	Ftcl_AppendStringsToObj                 uintptr
	Ftcl_AppendToObj                        uintptr
	Ftcl_ConcatObj                          uintptr
	Ftcl_ConvertToType                      uintptr
	Ftcl_DbDecrRefCount                     uintptr
	Ftcl_DbIncrRefCount                     uintptr
	Ftcl_DbIsShared                         uintptr
	Freserved22                             uintptr
	Ftcl_DbNewByteArrayObj                  uintptr
	Ftcl_DbNewDoubleObj                     uintptr
	Ftcl_DbNewListObj                       uintptr
	Freserved26                             uintptr
	Ftcl_DbNewObj                           uintptr
	Ftcl_DbNewStringObj                     uintptr
	Ftcl_DuplicateObj                       uintptr
	FtclFreeObj                             uintptr
	Ftcl_GetBoolean                         uintptr
	Ftcl_GetBooleanFromObj                  uintptr
	Ftcl_GetByteArrayFromObj                uintptr
	Ftcl_GetDouble                          uintptr
	Ftcl_GetDoubleFromObj                   uintptr
	Freserved36                             uintptr
	Ftcl_GetInt                             uintptr
	Ftcl_GetIntFromObj                      uintptr
	Ftcl_GetLongFromObj                     uintptr
	Ftcl_GetObjType                         uintptr
	FtclGetStringFromObj                    uintptr
	Ftcl_InvalidateStringRep                uintptr
	Ftcl_ListObjAppendList                  uintptr
	Ftcl_ListObjAppendElement               uintptr
	FtclListObjGetElements                  uintptr
	Ftcl_ListObjIndex                       uintptr
	FtclListObjLength                       uintptr
	Ftcl_ListObjReplace                     uintptr
	Freserved49                             uintptr
	Ftcl_NewByteArrayObj                    uintptr
	Ftcl_NewDoubleObj                       uintptr
	Freserved52                             uintptr
	Ftcl_NewListObj                         uintptr
	Freserved54                             uintptr
	Ftcl_NewObj                             uintptr
	Ftcl_NewStringObj                       uintptr
	Freserved57                             uintptr
	Ftcl_SetByteArrayLength                 uintptr
	Ftcl_SetByteArrayObj                    uintptr
	Ftcl_SetDoubleObj                       uintptr
	Freserved61                             uintptr
	Ftcl_SetListObj                         uintptr
	Freserved63                             uintptr
	Ftcl_SetObjLength                       uintptr
	Ftcl_SetStringObj                       uintptr
	Freserved66                             uintptr
	Freserved67                             uintptr
	Ftcl_AllowExceptions                    uintptr
	Ftcl_AppendElement                      uintptr
	Ftcl_AppendResult                       uintptr
	Ftcl_AsyncCreate                        uintptr
	Ftcl_AsyncDelete                        uintptr
	Ftcl_AsyncInvoke                        uintptr
	Ftcl_AsyncMark                          uintptr
	Ftcl_AsyncReady                         uintptr
	Freserved76                             uintptr
	Freserved77                             uintptr
	Ftcl_BadChannelOption                   uintptr
	Ftcl_CallWhenDeleted                    uintptr
	Ftcl_CancelIdleCall                     uintptr
	Ftcl_Close                              uintptr
	Ftcl_CommandComplete                    uintptr
	Ftcl_Concat                             uintptr
	Ftcl_ConvertElement                     uintptr
	Ftcl_ConvertCountedElement              uintptr
	Ftcl_CreateAlias                        uintptr
	Ftcl_CreateAliasObj                     uintptr
	Ftcl_CreateChannel                      uintptr
	Ftcl_CreateChannelHandler               uintptr
	Ftcl_CreateCloseHandler                 uintptr
	Ftcl_CreateCommand                      uintptr
	Ftcl_CreateEventSource                  uintptr
	Ftcl_CreateExitHandler                  uintptr
	Ftcl_CreateInterp                       uintptr
	Freserved95                             uintptr
	Ftcl_CreateObjCommand                   uintptr
	Ftcl_CreateChild                        uintptr
	Ftcl_CreateTimerHandler                 uintptr
	Ftcl_CreateTrace                        uintptr
	Ftcl_DeleteAssocData                    uintptr
	Ftcl_DeleteChannelHandler               uintptr
	Ftcl_DeleteCloseHandler                 uintptr
	Ftcl_DeleteCommand                      uintptr
	Ftcl_DeleteCommandFromToken             uintptr
	Ftcl_DeleteEvents                       uintptr
	Ftcl_DeleteEventSource                  uintptr
	Ftcl_DeleteExitHandler                  uintptr
	Ftcl_DeleteHashEntry                    uintptr
	Ftcl_DeleteHashTable                    uintptr
	Ftcl_DeleteInterp                       uintptr
	Ftcl_DetachPids                         uintptr
	Ftcl_DeleteTimerHandler                 uintptr
	Ftcl_DeleteTrace                        uintptr
	Ftcl_DontCallWhenDeleted                uintptr
	Ftcl_DoOneEvent                         uintptr
	Ftcl_DoWhenIdle                         uintptr
	Ftcl_DStringAppend                      uintptr
	Ftcl_DStringAppendElement               uintptr
	Ftcl_DStringEndSublist                  uintptr
	Ftcl_DStringFree                        uintptr
	Ftcl_DStringGetResult                   uintptr
	Ftcl_DStringInit                        uintptr
	Ftcl_DStringResult                      uintptr
	Ftcl_DStringSetLength                   uintptr
	Ftcl_DStringStartSublist                uintptr
	Ftcl_Eof                                uintptr
	Ftcl_ErrnoId                            uintptr
	Ftcl_ErrnoMsg                           uintptr
	Freserved129                            uintptr
	Ftcl_EvalFile                           uintptr
	Freserved131                            uintptr
	Ftcl_EventuallyFree                     uintptr
	Ftcl_Exit                               uintptr
	Ftcl_ExposeCommand                      uintptr
	Ftcl_ExprBoolean                        uintptr
	Ftcl_ExprBooleanObj                     uintptr
	Ftcl_ExprDouble                         uintptr
	Ftcl_ExprDoubleObj                      uintptr
	Ftcl_ExprLong                           uintptr
	Ftcl_ExprLongObj                        uintptr
	Ftcl_ExprObj                            uintptr
	Ftcl_ExprString                         uintptr
	Ftcl_Finalize                           uintptr
	Freserved144                            uintptr
	Ftcl_FirstHashEntry                     uintptr
	Ftcl_Flush                              uintptr
	Freserved147                            uintptr
	Freserved148                            uintptr
	FtclGetAliasObj                         uintptr
	Ftcl_GetAssocData                       uintptr
	Ftcl_GetChannel                         uintptr
	Ftcl_GetChannelBufferSize               uintptr
	Ftcl_GetChannelHandle                   uintptr
	Ftcl_GetChannelInstanceData             uintptr
	Ftcl_GetChannelMode                     uintptr
	Ftcl_GetChannelName                     uintptr
	Ftcl_GetChannelOption                   uintptr
	Ftcl_GetChannelType                     uintptr
	Ftcl_GetCommandInfo                     uintptr
	Ftcl_GetCommandName                     uintptr
	Ftcl_GetErrno                           uintptr
	Ftcl_GetHostName                        uintptr
	Ftcl_GetInterpPath                      uintptr
	Ftcl_GetParent                          uintptr
	Ftcl_GetNameOfExecutable                uintptr
	Ftcl_GetObjResult                       uintptr
	Ftcl_GetOpenFile                        uintptr
	Ftcl_GetPathType                        uintptr
	Ftcl_Gets                               uintptr
	Ftcl_GetsObj                            uintptr
	Ftcl_GetServiceMode                     uintptr
	Ftcl_GetChild                           uintptr
	Ftcl_GetStdChannel                      uintptr
	Freserved174                            uintptr
	Freserved175                            uintptr
	Ftcl_GetVar2                            uintptr
	Freserved177                            uintptr
	Freserved178                            uintptr
	Ftcl_HideCommand                        uintptr
	Ftcl_Init                               uintptr
	Ftcl_InitHashTable                      uintptr
	Ftcl_InputBlocked                       uintptr
	Ftcl_InputBuffered                      uintptr
	Ftcl_InterpDeleted                      uintptr
	Ftcl_IsSafe                             uintptr
	Ftcl_JoinPath                           uintptr
	Ftcl_LinkVar                            uintptr
	Freserved188                            uintptr
	Ftcl_MakeFileChannel                    uintptr
	Freserved190                            uintptr
	Ftcl_MakeTcpClientChannel               uintptr
	Ftcl_Merge                              uintptr
	Ftcl_NextHashEntry                      uintptr
	Ftcl_NotifyChannel                      uintptr
	Ftcl_ObjGetVar2                         uintptr
	Ftcl_ObjSetVar2                         uintptr
	Ftcl_OpenCommandChannel                 uintptr
	Ftcl_OpenFileChannel                    uintptr
	Ftcl_OpenTcpClient                      uintptr
	Ftcl_OpenTcpServer                      uintptr
	Ftcl_Preserve                           uintptr
	Ftcl_PrintDouble                        uintptr
	Ftcl_PutEnv                             uintptr
	Ftcl_PosixError                         uintptr
	Ftcl_QueueEvent                         uintptr
	Ftcl_Read                               uintptr
	Ftcl_ReapDetachedProcs                  uintptr
	Ftcl_RecordAndEval                      uintptr
	Ftcl_RecordAndEvalObj                   uintptr
	Ftcl_RegisterChannel                    uintptr
	Ftcl_RegisterObjType                    uintptr
	Ftcl_RegExpCompile                      uintptr
	Ftcl_RegExpExec                         uintptr
	Ftcl_RegExpMatch                        uintptr
	Ftcl_RegExpRange                        uintptr
	Ftcl_Release                            uintptr
	Ftcl_ResetResult                        uintptr
	Ftcl_ScanElement                        uintptr
	Ftcl_ScanCountedElement                 uintptr
	Freserved220                            uintptr
	Ftcl_ServiceAll                         uintptr
	Ftcl_ServiceEvent                       uintptr
	Ftcl_SetAssocData                       uintptr
	Ftcl_SetChannelBufferSize               uintptr
	Ftcl_SetChannelOption                   uintptr
	Ftcl_SetCommandInfo                     uintptr
	Ftcl_SetErrno                           uintptr
	Ftcl_SetErrorCode                       uintptr
	Ftcl_SetMaxBlockTime                    uintptr
	Freserved230                            uintptr
	Ftcl_SetRecursionLimit                  uintptr
	Freserved232                            uintptr
	Ftcl_SetServiceMode                     uintptr
	Ftcl_SetObjErrorCode                    uintptr
	Ftcl_SetObjResult                       uintptr
	Ftcl_SetStdChannel                      uintptr
	Freserved237                            uintptr
	Ftcl_SetVar2                            uintptr
	Ftcl_SignalId                           uintptr
	Ftcl_SignalMsg                          uintptr
	Ftcl_SourceRCFile                       uintptr
	FtclSplitList                           uintptr
	FtclSplitPath                           uintptr
	Freserved244                            uintptr
	Freserved245                            uintptr
	Freserved246                            uintptr
	Freserved247                            uintptr
	Ftcl_TraceVar2                          uintptr
	Ftcl_TranslateFileName                  uintptr
	Ftcl_Ungets                             uintptr
	Ftcl_UnlinkVar                          uintptr
	Ftcl_UnregisterChannel                  uintptr
	Freserved253                            uintptr
	Ftcl_UnsetVar2                          uintptr
	Freserved255                            uintptr
	Ftcl_UntraceVar2                        uintptr
	Ftcl_UpdateLinkedVar                    uintptr
	Freserved258                            uintptr
	Ftcl_UpVar2                             uintptr
	Ftcl_VarEval                            uintptr
	Freserved261                            uintptr
	Ftcl_VarTraceInfo2                      uintptr
	Ftcl_Write                              uintptr
	Ftcl_WrongNumArgs                       uintptr
	Ftcl_DumpActiveMemory                   uintptr
	Ftcl_ValidateAllMemory                  uintptr
	Freserved267                            uintptr
	Freserved268                            uintptr
	Ftcl_HashStats                          uintptr
	Ftcl_ParseVar                           uintptr
	Freserved271                            uintptr
	Ftcl_PkgPresentEx                       uintptr
	Freserved273                            uintptr
	Freserved274                            uintptr
	Freserved275                            uintptr
	Freserved276                            uintptr
	Ftcl_WaitPid                            uintptr
	Freserved278                            uintptr
	Ftcl_GetVersion                         uintptr
	Ftcl_InitMemory                         uintptr
	Ftcl_StackChannel                       uintptr
	Ftcl_UnstackChannel                     uintptr
	Ftcl_GetStackedChannel                  uintptr
	Ftcl_SetMainLoop                        uintptr
	Ftcl_GetAliasObj                        uintptr
	Ftcl_AppendObjToObj                     uintptr
	Ftcl_CreateEncoding                     uintptr
	Ftcl_CreateThreadExitHandler            uintptr
	Ftcl_DeleteThreadExitHandler            uintptr
	Freserved290                            uintptr
	Ftcl_EvalEx                             uintptr
	Ftcl_EvalObjv                           uintptr
	Ftcl_EvalObjEx                          uintptr
	Ftcl_ExitThread                         uintptr
	Ftcl_ExternalToUtf                      uintptr
	Ftcl_ExternalToUtfDString               uintptr
	Ftcl_FinalizeThread                     uintptr
	Ftcl_FinalizeNotifier                   uintptr
	Ftcl_FreeEncoding                       uintptr
	Ftcl_GetCurrentThread                   uintptr
	Ftcl_GetEncoding                        uintptr
	Ftcl_GetEncodingName                    uintptr
	Ftcl_GetEncodingNames                   uintptr
	Ftcl_GetIndexFromObjStruct              uintptr
	Ftcl_GetThreadData                      uintptr
	Ftcl_GetVar2Ex                          uintptr
	Ftcl_InitNotifier                       uintptr
	Ftcl_MutexLock                          uintptr
	Ftcl_MutexUnlock                        uintptr
	Ftcl_ConditionNotify                    uintptr
	Ftcl_ConditionWait                      uintptr
	FtclNumUtfChars                         uintptr
	Ftcl_ReadChars                          uintptr
	Freserved314                            uintptr
	Freserved315                            uintptr
	Ftcl_SetSystemEncoding                  uintptr
	Ftcl_SetVar2Ex                          uintptr
	Ftcl_ThreadAlert                        uintptr
	Ftcl_ThreadQueueEvent                   uintptr
	Ftcl_UniCharAtIndex                     uintptr
	Ftcl_UniCharToLower                     uintptr
	Ftcl_UniCharToTitle                     uintptr
	Ftcl_UniCharToUpper                     uintptr
	Ftcl_UniCharToUtf                       uintptr
	FtclUtfAtIndex                          uintptr
	FtclUtfCharComplete                     uintptr
	Ftcl_UtfBackslash                       uintptr
	Ftcl_UtfFindFirst                       uintptr
	Ftcl_UtfFindLast                        uintptr
	FtclUtfNext                             uintptr
	FtclUtfPrev                             uintptr
	Ftcl_UtfToExternal                      uintptr
	Ftcl_UtfToExternalDString               uintptr
	Ftcl_UtfToLower                         uintptr
	Ftcl_UtfToTitle                         uintptr
	Ftcl_UtfToChar16                        uintptr
	Ftcl_UtfToUpper                         uintptr
	Ftcl_WriteChars                         uintptr
	Ftcl_WriteObj                           uintptr
	Ftcl_GetString                          uintptr
	Freserved341                            uintptr
	Freserved342                            uintptr
	Ftcl_AlertNotifier                      uintptr
	Ftcl_ServiceModeHook                    uintptr
	Ftcl_UniCharIsAlnum                     uintptr
	Ftcl_UniCharIsAlpha                     uintptr
	Ftcl_UniCharIsDigit                     uintptr
	Ftcl_UniCharIsLower                     uintptr
	Ftcl_UniCharIsSpace                     uintptr
	Ftcl_UniCharIsUpper                     uintptr
	Ftcl_UniCharIsWordChar                  uintptr
	Ftcl_Char16Len                          uintptr
	Freserved353                            uintptr
	Ftcl_Char16ToUtfDString                 uintptr
	Ftcl_UtfToChar16DString                 uintptr
	Ftcl_GetRegExpFromObj                   uintptr
	Freserved357                            uintptr
	Ftcl_FreeParse                          uintptr
	Ftcl_LogCommandInfo                     uintptr
	Ftcl_ParseBraces                        uintptr
	Ftcl_ParseCommand                       uintptr
	Ftcl_ParseExpr                          uintptr
	Ftcl_ParseQuotedString                  uintptr
	Ftcl_ParseVarName                       uintptr
	Ftcl_GetCwd                             uintptr
	Ftcl_Chdir                              uintptr
	Ftcl_Access                             uintptr
	Ftcl_Stat                               uintptr
	FtclUtfNcmp                             uintptr
	FtclUtfNcasecmp                         uintptr
	Ftcl_StringCaseMatch                    uintptr
	Ftcl_UniCharIsControl                   uintptr
	Ftcl_UniCharIsGraph                     uintptr
	Ftcl_UniCharIsPrint                     uintptr
	Ftcl_UniCharIsPunct                     uintptr
	Ftcl_RegExpExecObj                      uintptr
	Ftcl_RegExpGetInfo                      uintptr
	Ftcl_NewUnicodeObj                      uintptr
	Ftcl_SetUnicodeObj                      uintptr
	FtclGetCharLength                       uintptr
	FtclGetUniChar                          uintptr
	Freserved382                            uintptr
	FtclGetRange                            uintptr
	Ftcl_AppendUnicodeToObj                 uintptr
	Ftcl_RegExpMatchObj                     uintptr
	Ftcl_SetNotifier                        uintptr
	Ftcl_GetAllocMutex                      uintptr
	Ftcl_GetChannelNames                    uintptr
	Ftcl_GetChannelNamesEx                  uintptr
	Ftcl_ProcObjCmd                         uintptr
	Ftcl_ConditionFinalize                  uintptr
	Ftcl_MutexFinalize                      uintptr
	Ftcl_CreateThread                       uintptr
	Ftcl_ReadRaw                            uintptr
	Ftcl_WriteRaw                           uintptr
	Ftcl_GetTopChannel                      uintptr
	Ftcl_ChannelBuffered                    uintptr
	Ftcl_ChannelName                        uintptr
	Ftcl_ChannelVersion                     uintptr
	Ftcl_ChannelBlockModeProc               uintptr
	Freserved401                            uintptr
	Ftcl_ChannelClose2Proc                  uintptr
	Ftcl_ChannelInputProc                   uintptr
	Ftcl_ChannelOutputProc                  uintptr
	Freserved405                            uintptr
	Ftcl_ChannelSetOptionProc               uintptr
	Ftcl_ChannelGetOptionProc               uintptr
	Ftcl_ChannelWatchProc                   uintptr
	Ftcl_ChannelGetHandleProc               uintptr
	Ftcl_ChannelFlushProc                   uintptr
	Ftcl_ChannelHandlerProc                 uintptr
	Ftcl_JoinThread                         uintptr
	Ftcl_IsChannelShared                    uintptr
	Ftcl_IsChannelRegistered                uintptr
	Ftcl_CutChannel                         uintptr
	Ftcl_SpliceChannel                      uintptr
	Ftcl_ClearChannelHandlers               uintptr
	Ftcl_IsChannelExisting                  uintptr
	Freserved419                            uintptr
	Freserved420                            uintptr
	Freserved421                            uintptr
	Freserved422                            uintptr
	Ftcl_InitCustomHashTable                uintptr
	Ftcl_InitObjHashTable                   uintptr
	Ftcl_CommandTraceInfo                   uintptr
	Ftcl_TraceCommand                       uintptr
	Ftcl_UntraceCommand                     uintptr
	Ftcl_AttemptAlloc                       uintptr
	Ftcl_AttemptDbCkalloc                   uintptr
	Ftcl_AttemptRealloc                     uintptr
	Ftcl_AttemptDbCkrealloc                 uintptr
	Ftcl_AttemptSetObjLength                uintptr
	Ftcl_GetChannelThread                   uintptr
	FtclGetUnicodeFromObj                   uintptr
	Freserved435                            uintptr
	Freserved436                            uintptr
	Ftcl_SubstObj                           uintptr
	Ftcl_DetachChannel                      uintptr
	Ftcl_IsStandardChannel                  uintptr
	Ftcl_FSCopyFile                         uintptr
	Ftcl_FSCopyDirectory                    uintptr
	Ftcl_FSCreateDirectory                  uintptr
	Ftcl_FSDeleteFile                       uintptr
	Ftcl_FSLoadFile                         uintptr
	Ftcl_FSMatchInDirectory                 uintptr
	Ftcl_FSLink                             uintptr
	Ftcl_FSRemoveDirectory                  uintptr
	Ftcl_FSRenameFile                       uintptr
	Ftcl_FSLstat                            uintptr
	Ftcl_FSUtime                            uintptr
	Ftcl_FSFileAttrsGet                     uintptr
	Ftcl_FSFileAttrsSet                     uintptr
	Ftcl_FSFileAttrStrings                  uintptr
	Ftcl_FSStat                             uintptr
	Ftcl_FSAccess                           uintptr
	Ftcl_FSOpenFileChannel                  uintptr
	Ftcl_FSGetCwd                           uintptr
	Ftcl_FSChdir                            uintptr
	Ftcl_FSConvertToPathType                uintptr
	Ftcl_FSJoinPath                         uintptr
	FtclFSSplitPath                         uintptr
	Ftcl_FSEqualPaths                       uintptr
	Ftcl_FSGetNormalizedPath                uintptr
	Ftcl_FSJoinToPath                       uintptr
	Ftcl_FSGetInternalRep                   uintptr
	Ftcl_FSGetTranslatedPath                uintptr
	Ftcl_FSEvalFile                         uintptr
	Ftcl_FSNewNativePath                    uintptr
	Ftcl_FSGetNativePath                    uintptr
	Ftcl_FSFileSystemInfo                   uintptr
	Ftcl_FSPathSeparator                    uintptr
	Ftcl_FSListVolumes                      uintptr
	Ftcl_FSRegister                         uintptr
	Ftcl_FSUnregister                       uintptr
	Ftcl_FSData                             uintptr
	Ftcl_FSGetTranslatedStringPath          uintptr
	Ftcl_FSGetFileSystemForPath             uintptr
	Ftcl_FSGetPathType                      uintptr
	Ftcl_OutputBuffered                     uintptr
	Ftcl_FSMountsChanged                    uintptr
	Ftcl_EvalTokensStandard                 uintptr
	Ftcl_GetTime                            uintptr
	Ftcl_CreateObjTrace                     uintptr
	Ftcl_GetCommandInfoFromToken            uintptr
	Ftcl_SetCommandInfoFromToken            uintptr
	Ftcl_DbNewWideIntObj                    uintptr
	Ftcl_GetWideIntFromObj                  uintptr
	Ftcl_NewWideIntObj                      uintptr
	Ftcl_SetWideIntObj                      uintptr
	Ftcl_AllocStatBuf                       uintptr
	Ftcl_Seek                               uintptr
	Ftcl_Tell                               uintptr
	Ftcl_ChannelWideSeekProc                uintptr
	Ftcl_DictObjPut                         uintptr
	Ftcl_DictObjGet                         uintptr
	Ftcl_DictObjRemove                      uintptr
	FtclDictObjSize                         uintptr
	Ftcl_DictObjFirst                       uintptr
	Ftcl_DictObjNext                        uintptr
	Ftcl_DictObjDone                        uintptr
	Ftcl_DictObjPutKeyList                  uintptr
	Ftcl_DictObjRemoveKeyList               uintptr
	Ftcl_NewDictObj                         uintptr
	Ftcl_DbNewDictObj                       uintptr
	Ftcl_RegisterConfig                     uintptr
	Ftcl_CreateNamespace                    uintptr
	Ftcl_DeleteNamespace                    uintptr
	Ftcl_AppendExportList                   uintptr
	Ftcl_Export                             uintptr
	Ftcl_Import                             uintptr
	Ftcl_ForgetImport                       uintptr
	Ftcl_GetCurrentNamespace                uintptr
	Ftcl_GetGlobalNamespace                 uintptr
	Ftcl_FindNamespace                      uintptr
	Ftcl_FindCommand                        uintptr
	Ftcl_GetCommandFromObj                  uintptr
	Ftcl_GetCommandFullName                 uintptr
	Ftcl_FSEvalFileEx                       uintptr
	Freserved519                            uintptr
	Ftcl_LimitAddHandler                    uintptr
	Ftcl_LimitRemoveHandler                 uintptr
	Ftcl_LimitReady                         uintptr
	Ftcl_LimitCheck                         uintptr
	Ftcl_LimitExceeded                      uintptr
	Ftcl_LimitSetCommands                   uintptr
	Ftcl_LimitSetTime                       uintptr
	Ftcl_LimitSetGranularity                uintptr
	Ftcl_LimitTypeEnabled                   uintptr
	Ftcl_LimitTypeExceeded                  uintptr
	Ftcl_LimitTypeSet                       uintptr
	Ftcl_LimitTypeReset                     uintptr
	Ftcl_LimitGetCommands                   uintptr
	Ftcl_LimitGetTime                       uintptr
	Ftcl_LimitGetGranularity                uintptr
	Ftcl_SaveInterpState                    uintptr
	Ftcl_RestoreInterpState                 uintptr
	Ftcl_DiscardInterpState                 uintptr
	Ftcl_SetReturnOptions                   uintptr
	Ftcl_GetReturnOptions                   uintptr
	Ftcl_IsEnsemble                         uintptr
	Ftcl_CreateEnsemble                     uintptr
	Ftcl_FindEnsemble                       uintptr
	Ftcl_SetEnsembleSubcommandList          uintptr
	Ftcl_SetEnsembleMappingDict             uintptr
	Ftcl_SetEnsembleUnknownHandler          uintptr
	Ftcl_SetEnsembleFlags                   uintptr
	Ftcl_GetEnsembleSubcommandList          uintptr
	Ftcl_GetEnsembleMappingDict             uintptr
	Ftcl_GetEnsembleUnknownHandler          uintptr
	Ftcl_GetEnsembleFlags                   uintptr
	Ftcl_GetEnsembleNamespace               uintptr
	Ftcl_SetTimeProc                        uintptr
	Ftcl_QueryTimeProc                      uintptr
	Ftcl_ChannelThreadActionProc            uintptr
	Ftcl_NewBignumObj                       uintptr
	Ftcl_DbNewBignumObj                     uintptr
	Ftcl_SetBignumObj                       uintptr
	Ftcl_GetBignumFromObj                   uintptr
	Ftcl_TakeBignumFromObj                  uintptr
	Ftcl_TruncateChannel                    uintptr
	Ftcl_ChannelTruncateProc                uintptr
	Ftcl_SetChannelErrorInterp              uintptr
	Ftcl_GetChannelErrorInterp              uintptr
	Ftcl_SetChannelError                    uintptr
	Ftcl_GetChannelError                    uintptr
	Ftcl_InitBignumFromDouble               uintptr
	Ftcl_GetNamespaceUnknownHandler         uintptr
	Ftcl_SetNamespaceUnknownHandler         uintptr
	Ftcl_GetEncodingFromObj                 uintptr
	Ftcl_GetEncodingSearchPath              uintptr
	Ftcl_SetEncodingSearchPath              uintptr
	Ftcl_GetEncodingNameFromEnvironment     uintptr
	Ftcl_PkgRequireProc                     uintptr
	Ftcl_AppendObjToErrorInfo               uintptr
	Ftcl_AppendLimitedToObj                 uintptr
	Ftcl_Format                             uintptr
	Ftcl_AppendFormatToObj                  uintptr
	Ftcl_ObjPrintf                          uintptr
	Ftcl_AppendPrintfToObj                  uintptr
	Ftcl_CancelEval                         uintptr
	Ftcl_Canceled                           uintptr
	Ftcl_CreatePipe                         uintptr
	Ftcl_NRCreateCommand                    uintptr
	Ftcl_NREvalObj                          uintptr
	Ftcl_NREvalObjv                         uintptr
	Ftcl_NRCmdSwap                          uintptr
	Ftcl_NRAddCallback                      uintptr
	Ftcl_NRCallObjProc                      uintptr
	Ftcl_GetFSDeviceFromStat                uintptr
	Ftcl_GetFSInodeFromStat                 uintptr
	Ftcl_GetModeFromStat                    uintptr
	Ftcl_GetLinkCountFromStat               uintptr
	Ftcl_GetUserIdFromStat                  uintptr
	Ftcl_GetGroupIdFromStat                 uintptr
	Ftcl_GetDeviceTypeFromStat              uintptr
	Ftcl_GetAccessTimeFromStat              uintptr
	Ftcl_GetModificationTimeFromStat        uintptr
	Ftcl_GetChangeTimeFromStat              uintptr
	Ftcl_GetSizeFromStat                    uintptr
	Ftcl_GetBlocksFromStat                  uintptr
	Ftcl_GetBlockSizeFromStat               uintptr
	Ftcl_SetEnsembleParameterList           uintptr
	Ftcl_GetEnsembleParameterList           uintptr
	FtclParseArgsObjv                       uintptr
	Ftcl_GetErrorLine                       uintptr
	Ftcl_SetErrorLine                       uintptr
	Ftcl_TransferResult                     uintptr
	Ftcl_InterpActive                       uintptr
	Ftcl_BackgroundException                uintptr
	Ftcl_ZlibDeflate                        uintptr
	Ftcl_ZlibInflate                        uintptr
	Ftcl_ZlibCRC32                          uintptr
	Ftcl_ZlibAdler32                        uintptr
	Ftcl_ZlibStreamInit                     uintptr
	Ftcl_ZlibStreamGetCommandName           uintptr
	Ftcl_ZlibStreamEof                      uintptr
	Ftcl_ZlibStreamChecksum                 uintptr
	Ftcl_ZlibStreamPut                      uintptr
	Ftcl_ZlibStreamGet                      uintptr
	Ftcl_ZlibStreamClose                    uintptr
	Ftcl_ZlibStreamReset                    uintptr
	Ftcl_SetStartupScript                   uintptr
	Ftcl_GetStartupScript                   uintptr
	Ftcl_CloseEx                            uintptr
	Ftcl_NRExprObj                          uintptr
	Ftcl_NRSubstObj                         uintptr
	Ftcl_LoadFile                           uintptr
	Ftcl_FindSymbol                         uintptr
	Ftcl_FSUnloadFile                       uintptr
	Ftcl_ZlibStreamSetCompressionDictionary uintptr
	Ftcl_OpenTcpServerEx                    uintptr
	FtclZipfs_Mount                         uintptr
	FtclZipfs_Unmount                       uintptr
	FtclZipfs_TclLibrary                    uintptr
	FtclZipfs_MountBuffer                   uintptr
	Ftcl_FreeInternalRep                    uintptr
	Ftcl_InitStringRep                      uintptr
	Ftcl_FetchInternalRep                   uintptr
	Ftcl_StoreInternalRep                   uintptr
	Ftcl_HasStringRep                       uintptr
	Ftcl_IncrRefCount                       uintptr
	Ftcl_DecrRefCount                       uintptr
	Ftcl_IsShared                           uintptr
	Ftcl_LinkArray                          uintptr
	Ftcl_GetIntForIndex                     uintptr
	Ftcl_UtfToUniChar                       uintptr
	Ftcl_UniCharToUtfDString                uintptr
	Ftcl_UtfToUniCharDString                uintptr
	FtclGetBytesFromObj                     uintptr
	Ftcl_GetBytesFromObj                    uintptr
	Ftcl_GetStringFromObj                   uintptr
	Ftcl_GetUnicodeFromObj                  uintptr
	Ftcl_GetSizeIntFromObj                  uintptr
	Ftcl_UtfCharComplete                    uintptr
	Ftcl_UtfNext                            uintptr
	Ftcl_UtfPrev                            uintptr
	Ftcl_FSTildeExpand                      uintptr
	Ftcl_ExternalToUtfDStringEx             uintptr
	Ftcl_UtfToExternalDStringEx             uintptr
	Ftcl_AsyncMarkFromSignal                uintptr
	Ftcl_ListObjGetElements                 uintptr
	Ftcl_ListObjLength                      uintptr
	Ftcl_DictObjSize                        uintptr
	Ftcl_SplitList                          uintptr
	Ftcl_SplitPath                          uintptr
	Ftcl_FSSplitPath                        uintptr
	Ftcl_ParseArgsObjv                      uintptr
	Ftcl_UniCharLen                         uintptr
	Ftcl_NumUtfChars                        uintptr
	Ftcl_GetCharLength                      uintptr
	Ftcl_UtfAtIndex                         uintptr
	Ftcl_GetRange                           uintptr
	Ftcl_GetUniChar                         uintptr
	Ftcl_GetBool                            uintptr
	Ftcl_GetBoolFromObj                     uintptr
	Ftcl_CreateObjCommand2                  uintptr
	Ftcl_CreateObjTrace2                    uintptr
	Ftcl_NRCreateCommand2                   uintptr
	Ftcl_NRCallObjProc2                     uintptr
	Ftcl_GetNumberFromObj                   uintptr
	Ftcl_GetNumber                          uintptr
	Ftcl_RemoveChannelMode                  uintptr
	Ftcl_GetEncodingNulLength               uintptr
	Ftcl_GetWideUIntFromObj                 uintptr
	Ftcl_DStringToObj                       uintptr
	Ftcl_UtfNcmp                            uintptr
	Ftcl_UtfNcasecmp                        uintptr
	Ftcl_NewWideUIntObj                     uintptr
	Ftcl_SetWideUIntObj                     uintptr
	FtclUnusedStubEntry                     uintptr
}

type TTclPlatStubs = struct {
	Fmagic                                  int32
	Fhooks                                  uintptr
	Freserved0                              uintptr
	Ftcl_MacOSXOpenVersionedBundleResources uintptr
	Ftcl_MacOSXNotifierAddRunLoopMode       uintptr
	Ftcl_WinConvertError                    uintptr
}

type Tdiv_t = struct {
	Fquot int32
	Frem  int32
}

type Tldiv_t = struct {
	Fquot int64
	Frem  int64
}

type Tlldiv_t = struct {
	Fquot int64
	Frem  int64
}

type Tlconv = struct {
	Fdecimal_point      uintptr
	Fthousands_sep      uintptr
	Fgrouping           uintptr
	Fint_curr_symbol    uintptr
	Fcurrency_symbol    uintptr
	Fmon_decimal_point  uintptr
	Fmon_thousands_sep  uintptr
	Fmon_grouping       uintptr
	Fpositive_sign      uintptr
	Fnegative_sign      uintptr
	Fint_frac_digits    uint8
	Ffrac_digits        uint8
	Fp_cs_precedes      uint8
	Fp_sep_by_space     uint8
	Fn_cs_precedes      uint8
	Fn_sep_by_space     uint8
	Fp_sign_posn        uint8
	Fn_sign_posn        uint8
	Fint_p_cs_precedes  uint8
	Fint_p_sep_by_space uint8
	Fint_n_cs_precedes  uint8
	Fint_n_sep_by_space uint8
	Fint_p_sign_posn    uint8
	Fint_n_sign_posn    uint8
}

type TTcl_ResolvedVarInfo1 = struct {
	FfetchProc  uintptr
	FdeleteProc uintptr
}

type TTcl_ResolvedVarInfo = struct {
	FfetchProc  uintptr
	FdeleteProc uintptr
}

type TTcl_ResolverInfo = struct {
	FcmdResProc         uintptr
	FvarResProc         uintptr
	FcompiledVarResProc uintptr
}

type TNamespacePathEntry = struct {
	FnsPtr        uintptr
	FcreatorNsPtr uintptr
	FprevPtr      uintptr
	FnextPtr      uintptr
}

type TTclVarHashTable = struct {
	Ftable    TTcl_HashTable
	FnsPtr    uintptr
	FarrayPtr uintptr
}

type TNamespace = struct {
	Fname                  uintptr
	FfullName              uintptr
	FclientData            uintptr
	FdeleteProc            uintptr
	FparentPtr             uintptr
	FchildTable            TTcl_HashTable
	FnsId                  Tsize_t
	Finterp                uintptr
	Fflags                 int32
	FactivationCount       TTcl_Size
	FrefCount              TTcl_Size
	FcmdTable              TTcl_HashTable
	FvarTable              TTclVarHashTable
	FexportArrayPtr        uintptr
	FnumExportPatterns     TTcl_Size
	FmaxExportPatterns     TTcl_Size
	FcmdRefEpoch           TTcl_Size
	FresolverEpoch         TTcl_Size
	FcmdResProc            uintptr
	FvarResProc            uintptr
	FcompiledVarResProc    uintptr
	FexportLookupEpoch     TTcl_Size
	Fensembles             uintptr
	FunknownHandlerPtr     uintptr
	FcommandPathLength     TTcl_Size
	FcommandPathArray      uintptr
	FcommandPathSourceList uintptr
	FearlyDeleteProc       uintptr
}

type TNamespacePathEntry1 = struct {
	FnsPtr        uintptr
	FcreatorNsPtr uintptr
	FprevPtr      uintptr
	FnextPtr      uintptr
}

type TEnsembleConfig = struct {
	FnsPtr              uintptr
	Ftoken              TTcl_Command
	Fepoch              TTcl_Size
	FsubcommandArrayPtr uintptr
	FsubcommandTable    TTcl_HashTable
	Fnext               uintptr
	Fflags              int32
	FsubcommandDict     uintptr
	FsubcmdList         uintptr
	FunknownHandler     uintptr
	FparameterList      uintptr
	FnumParameters      TTcl_Size
}

type TVarTrace = struct {
	FtraceProc  uintptr
	FclientData uintptr
	Fflags      int32
	FnextPtr    uintptr
}

type TCommandTrace = struct {
	FtraceProc  uintptr
	FclientData uintptr
	Fflags      int32
	FnextPtr    uintptr
	FrefCount   TTcl_Size
}

type TActiveCommandTrace = struct {
	FcmdPtr       uintptr
	FnextPtr      uintptr
	FnextTracePtr uintptr
	FreverseScan  int32
}

type TActiveVarTrace = struct {
	FvarPtr       uintptr
	FnextPtr      uintptr
	FnextTracePtr uintptr
}

type TVar = struct {
	Fflags int32
	Fvalue struct {
		FtablePtr [0]uintptr
		FlinkPtr  [0]uintptr
		FobjPtr   uintptr
	}
}

type TVarInHash = struct {
	Fvar1     TVar
	FrefCount TTcl_Size
	Fentry    TTcl_HashEntry
}

type TCommand1 = struct {
	FhPtr          uintptr
	FnsPtr         uintptr
	FrefCount      TTcl_Size
	FcmdEpoch      TTcl_Size
	FcompileProc   uintptr
	FobjProc       uintptr
	FobjClientData uintptr
	Fproc          uintptr
	FclientData    uintptr
	FdeleteProc    uintptr
	FdeleteData    uintptr
	Fflags         int32
	FimportRefPtr  uintptr
	FtracePtr      uintptr
	FnreProc       uintptr
}

type TCompiledLocal = struct {
	FnextPtr     uintptr
	FnameLength  TTcl_Size
	FframeIndex  TTcl_Size
	FdefValuePtr uintptr
	FresolveInfo uintptr
	Fflags       int32
}

type TProc = struct {
	FiPtr              uintptr
	FrefCount          TTcl_Size
	FcmdPtr            uintptr
	FbodyPtr           uintptr
	FnumArgs           TTcl_Size
	FnumCompiledLocals TTcl_Size
	FfirstLocalPtr     uintptr
	FlastLocalPtr      uintptr
}

type TTrace = struct {
	Flevel      TTcl_Size
	Fproc       uintptr
	FclientData uintptr
	FnextPtr    uintptr
	Fflags      int32
	FdelProc    uintptr
}

type TActiveInterpTrace = struct {
	FnextPtr      uintptr
	FnextTracePtr uintptr
	FreverseScan  int32
}

type TAssocData = struct {
	Fproc       uintptr
	FclientData uintptr
}

type TLocalCache = struct {
	FrefCount TTcl_Size
	FnumVars  TTcl_Size
	FvarName0 uintptr
}

type TCallFrame = struct {
	FnsPtr             uintptr
	FisProcCallFrame   int32
	Fobjc              TTcl_Size
	Fobjv              uintptr
	FcallerPtr         uintptr
	FcallerVarPtr      uintptr
	Flevel             TTcl_Size
	FprocPtr           uintptr
	FvarTablePtr       uintptr
	FnumCompiledLocals TTcl_Size
	FcompiledLocals    uintptr
	FclientData        uintptr
	FlocalCachePtr     uintptr
	FtailcallPtr       uintptr
}

type TCmdFrame = struct {
	Ftype1    int32
	Flevel    int32
	Fline     uintptr
	Fnline    TTcl_Size
	FframePtr uintptr
	FnextPtr  uintptr
	Fdata     struct {
		Ftebc [0]struct {
			FcodePtr uintptr
			Fpc      uintptr
		}
		Feval struct {
			Fpath uintptr
		}
		F__ccgo_pad2 [8]byte
	}
	FcmdObj uintptr
	Fcmd    uintptr
	Flen1   TTcl_Size
	Flitarg uintptr
}

type TCFWord = struct {
	FframePtr uintptr
	Fword     TTcl_Size
	FrefCount TTcl_Size
}

type TCFWordBC = struct {
	FframePtr uintptr
	Fpc       TTcl_Size
	Fword     TTcl_Size
	FprevPtr  uintptr
	FnextPtr  uintptr
	Fobj      uintptr
}

type TContLineLoc = struct {
	Fnum TTcl_Size
}

type TExtraFrameInfoField = struct {
	Fname       uintptr
	Fproc       uintptr
	FclientData uintptr
}

type TExtraFrameInfo = struct {
	Flength TTcl_Size
	Ffields [2]TExtraFrameInfoField
}

type TTclHandle = uintptr

type TExecStack = struct {
	FprevPtr   uintptr
	FnextPtr   uintptr
	FmarkerPtr uintptr
	FendPtr    uintptr
	FtosPtr    uintptr
}

type TCorContext = struct {
	FframePtr    uintptr
	FvarFramePtr uintptr
	FcmdFramePtr uintptr
	FlineLABCPtr uintptr
}

type TCoroutineData = struct {
	FcmdPtr       uintptr
	FeePtr        uintptr
	FcallerEEPtr  uintptr
	Fcaller       TCorContext
	Frunning      TCorContext
	FlineLABCPtr  uintptr
	FstackLevel   uintptr
	FauxNumLevels TTcl_Size
	Fnargs        TTcl_Size
	FyieldPtr     uintptr
}

type TExecEnv = struct {
	FexecStackPtr uintptr
	Fconstants    [2]uintptr
	Finterp       uintptr
	FcallbackPtr  uintptr
	FcorPtr       uintptr
	Frewind       int32
}

type TLiteralEntry = struct {
	FnextPtr  uintptr
	FobjPtr   uintptr
	FrefCount TTcl_Size
	FnsPtr    uintptr
}

type TLiteralTable = struct {
	Fbuckets       uintptr
	FstaticBuckets [4]uintptr
	FnumBuckets    Tsize_t
	FnumEntries    Tsize_t
	FrebuildSize   Tsize_t
	Fmask          Tsize_t
}

type TEnsembleImplMap = struct {
	Fname        uintptr
	Fproc        uintptr
	FcompileProc uintptr
	FnreProc     uintptr
	FclientData  uintptr
	Funsafe      int32
}

type TImportRef = struct {
	FimportedCmdPtr uintptr
	FnextPtr        uintptr
}

type TImportedCmdData = struct {
	FrealCmdPtr uintptr
	FselfPtr    uintptr
}

type TCommand = struct {
	FhPtr          uintptr
	FnsPtr         uintptr
	FrefCount      TTcl_Size
	FcmdEpoch      TTcl_Size
	FcompileProc   uintptr
	FobjProc       uintptr
	FobjClientData uintptr
	Fproc          uintptr
	FclientData    uintptr
	FdeleteProc    uintptr
	FdeleteData    uintptr
	Fflags         int32
	FimportRefPtr  uintptr
	FtracePtr      uintptr
	FnreProc       uintptr
}

type TResolverScheme = struct {
	Fname               uintptr
	FcmdResProc         uintptr
	FvarResProc         uintptr
	FcompiledVarResProc uintptr
	FnextPtr            uintptr
}

type PkgPreferOptions = int32

const PKG_PREFER_LATEST = 0
const PKG_PREFER_STABLE = 1

type TAllocCache = struct {
	FnextPtr     uintptr
	Fowner       TTcl_ThreadId
	FfirstObjPtr uintptr
	FnumObjects  Tsize_t
}

type TInterp = struct {
	FlegacyResult           uintptr
	FlegacyFreeProc         uintptr
	FerrorLine              int32
	FstubTable              uintptr
	Fhandle                 TTclHandle
	FglobalNsPtr            uintptr
	FhiddenCmdTablePtr      uintptr
	FinterpInfo             uintptr
	Foptimizer              uintptr
	FnumLevels              TTcl_Size
	FmaxNestingDepth        TTcl_Size
	FframePtr               uintptr
	FvarFramePtr            uintptr
	FactiveVarTracePtr      uintptr
	FreturnCode             int32
	FrootFramePtr           uintptr
	FlookupNsPtr            uintptr
	FpackageTable           TTcl_HashTable
	FpackageUnknown         uintptr
	FcmdCount               TTcl_Size
	FevalFlags              int32
	FliteralTable           TLiteralTable
	FcompileEpoch           TTcl_Size
	FcompiledProcPtr        uintptr
	FresolverPtr            uintptr
	FscriptFile             uintptr
	Fflags                  int32
	FrandSeed               int64
	FtracePtr               uintptr
	FassocData              uintptr
	FexecEnvPtr             uintptr
	FemptyObjPtr            uintptr
	FobjResultPtr           uintptr
	FthreadId               TTcl_ThreadId
	FactiveCmdTracePtr      uintptr
	FactiveInterpTracePtr   uintptr
	FtracesForbiddingInline TTcl_Size
	FreturnOpts             uintptr
	FerrorInfo              uintptr
	FeiVar                  uintptr
	FerrorCode              uintptr
	FecVar                  uintptr
	FreturnLevel            int32
	Flimit                  struct {
		Factive            int32
		FgranularityTicker int32
		Fexceeded          int32
		FcmdCount          TTcl_Size
		FcmdHandlers       uintptr
		FcmdGranularity    int32
		Ftime              TTcl_Time
		FtimeHandlers      uintptr
		FtimeGranularity   int32
		FtimeEvent         TTcl_TimerToken
		Fcallbacks         TTcl_HashTable
	}
	FensembleRewrite struct {
		FsourceObjs      uintptr
		FnumRemovedObjs  TTcl_Size
		FnumInsertedObjs TTcl_Size
	}
	FchanMsg           uintptr
	FcmdFramePtr       uintptr
	FinvokeCmdFramePtr uintptr
	FinvokeWord        int32
	FlinePBodyPtr      uintptr
	FlineBCPtr         uintptr
	FlineLABCPtr       uintptr
	FlineLAPtr         uintptr
	FscriptCLLocPtr    uintptr
	FpackagePrefer     int32
	FvarTraces         TTcl_HashTable
	FvarSearches       TTcl_HashTable
	FallocCache        uintptr
	FpendingObjDataPtr uintptr
	FasyncReadyPtr     uintptr
	FobjectFoundation  uintptr
	FdeferredCallbacks uintptr
	FasyncCancel       TTcl_AsyncHandler
	FasyncCancelMsg    uintptr
	FerrorStack        uintptr
	FupLiteral         uintptr
	FcallLiteral       uintptr
	FinnerLiteral      uintptr
	FinnerContext      uintptr
	FresetErrorStack   int32
}

type TTclMaxAlignment = struct {
	Funalign [8]uint8
	Faligned struct {
		FmaxAlignDouble   [0]float64
		FmaxAlignPointer  [0]uintptr
		FmaxAlignLongLong int64
	}
}

type TTclPlatformType = int32

const TCL_PLATFORM_UNIX = 0
const TCL_PLATFORM_WINDOWS = 2

type TTclEolTranslation = int32

type TclEolTranslation = int32

const TCL_TRANSLATE_AUTO = 0
const TCL_TRANSLATE_CR = 1
const TCL_TRANSLATE_LF = 2
const TCL_TRANSLATE_CRLF = 3

type TListStore = struct {
	FfirstUsed    TTcl_Size
	FnumUsed      TTcl_Size
	FnumAllocated TTcl_Size
	FrefCount     Tsize_t
	Fflags        int32
}

type TListSpan = struct {
	FspanStart  TTcl_Size
	FspanLength TTcl_Size
	FrefCount   Tsize_t
}

type TListRep = struct {
	FstorePtr uintptr
	FspanPtr  uintptr
}

type TTclFileAttrProcs = struct {
	FgetProc uintptr
	FsetProc uintptr
}

type TTclFile = uintptr

type TTcl_PathPart = int32

type Tcl_PathPart = int32

const TCL_PATH_DIRNAME = 0
const TCL_PATH_TAIL = 1
const TCL_PATH_EXTENSION = 2
const TCL_PATH_ROOT = 3

type TProcessGlobalValue = struct {
	Fepoch    TTcl_Size
	FnumBytes Tsize_t
	Fvalue    uintptr
	Fencoding TTcl_Encoding
	Fproc     uintptr
	Fmutex    TTcl_Mutex
	Fkey      TTcl_ThreadDataKey
}

type CheckEmptyStringResult = int32

const TCL_EMPTYSTRING_UNKNOWN = -1
const TCL_EMPTYSTRING_NO = 0
const TCL_EMPTYSTRING_YES = 1

type TForIterData = struct {
	Fcond uintptr
	Fbody uintptr
	Fnext uintptr
	Fmsg  uintptr
	Fword TTcl_Size
}

type TmemCmpFn_t = uintptr

type TTclProcessWaitStatus = int32

type TclProcessWaitStatus = int32

const TCL_PROCESS_ERROR = -1
const TCL_PROCESS_UNCHANGED = 0
const TCL_PROCESS_EXITED = 1
const TCL_PROCESS_SIGNALED = 2
const TCL_PROCESS_STOPPED = 3
const TCL_PROCESS_UNKNOWN_STATUS = 4

type TNRE_callback = struct {
	FprocPtr uintptr
	Fdata    [4]uintptr
	FnextPtr uintptr
}

type TTclIntStubs = struct {
	Fmagic                        int32
	Fhooks                        uintptr
	Freserved0                    uintptr
	Freserved1                    uintptr
	Freserved2                    uintptr
	FtclAllocateFreeObjects       uintptr
	Freserved4                    uintptr
	FtclCleanupChildren           uintptr
	FtclCleanupCommand            uintptr
	FtclCopyAndCollapse           uintptr
	Freserved8                    uintptr
	FtclCreatePipeline            uintptr
	FtclCreateProc                uintptr
	FtclDeleteCompiledLocalVars   uintptr
	FtclDeleteVars                uintptr
	Freserved13                   uintptr
	FtclDumpMemoryInfo            uintptr
	Freserved15                   uintptr
	FtclExprFloatError            uintptr
	Freserved17                   uintptr
	Freserved18                   uintptr
	Freserved19                   uintptr
	Freserved20                   uintptr
	Freserved21                   uintptr
	FtclFindElement               uintptr
	FtclFindProc                  uintptr
	FtclFormatInt                 uintptr
	FtclFreePackageInfo           uintptr
	Freserved26                   uintptr
	Freserved27                   uintptr
	FtclpGetDefaultStdChannel     uintptr
	Freserved29                   uintptr
	Freserved30                   uintptr
	FtclGetExtension              uintptr
	FtclGetFrame                  uintptr
	Freserved33                   uintptr
	Freserved34                   uintptr
	Freserved35                   uintptr
	Freserved36                   uintptr
	Freserved37                   uintptr
	FtclGetNamespaceForQualName   uintptr
	FtclGetObjInterpProc          uintptr
	FtclGetOpenMode               uintptr
	FtclGetOriginalCommand        uintptr
	FtclpGetUserHome              uintptr
	FtclGetObjInterpProc2         uintptr
	Freserved44                   uintptr
	FtclHideUnsafeCommands        uintptr
	FtclInExit                    uintptr
	Freserved47                   uintptr
	Freserved48                   uintptr
	Freserved49                   uintptr
	Freserved50                   uintptr
	FtclInterpInit                uintptr
	Freserved52                   uintptr
	Freserved53                   uintptr
	Freserved54                   uintptr
	FtclIsProc                    uintptr
	Freserved56                   uintptr
	Freserved57                   uintptr
	FtclLookupVar                 uintptr
	Freserved59                   uintptr
	FtclNeedSpace                 uintptr
	FtclNewProcBodyObj            uintptr
	FtclObjCommandComplete        uintptr
	Freserved63                   uintptr
	FtclObjInvoke                 uintptr
	Freserved65                   uintptr
	Freserved66                   uintptr
	Freserved67                   uintptr
	Freserved68                   uintptr
	FtclpAlloc                    uintptr
	Freserved70                   uintptr
	Freserved71                   uintptr
	Freserved72                   uintptr
	Freserved73                   uintptr
	FtclpFree                     uintptr
	FtclpGetClicks                uintptr
	FtclpGetSeconds               uintptr
	Freserved77                   uintptr
	Freserved78                   uintptr
	Freserved79                   uintptr
	Freserved80                   uintptr
	FtclpRealloc                  uintptr
	Freserved82                   uintptr
	Freserved83                   uintptr
	Freserved84                   uintptr
	Freserved85                   uintptr
	Freserved86                   uintptr
	Freserved87                   uintptr
	Freserved88                   uintptr
	FtclPreventAliasLoop          uintptr
	Freserved90                   uintptr
	FtclProcCleanupProc           uintptr
	FtclProcCompileProc           uintptr
	FtclProcDeleteProc            uintptr
	Freserved94                   uintptr
	Freserved95                   uintptr
	FtclRenameCommand             uintptr
	FtclResetShadowedCmdRefs      uintptr
	FtclServiceIdle               uintptr
	Freserved99                   uintptr
	Freserved100                  uintptr
	Freserved101                  uintptr
	FtclSetupEnv                  uintptr
	FtclSockGetPort               uintptr
	Freserved104                  uintptr
	Freserved105                  uintptr
	Freserved106                  uintptr
	Freserved107                  uintptr
	FtclTeardownNamespace         uintptr
	FtclUpdateReturnInfo          uintptr
	FtclSockMinimumBuffers        uintptr
	Ftcl_AddInterpResolvers       uintptr
	Freserved112                  uintptr
	Freserved113                  uintptr
	Freserved114                  uintptr
	Freserved115                  uintptr
	Freserved116                  uintptr
	Freserved117                  uintptr
	Ftcl_GetInterpResolvers       uintptr
	Ftcl_GetNamespaceResolvers    uintptr
	Ftcl_FindNamespaceVar         uintptr
	Freserved121                  uintptr
	Freserved122                  uintptr
	Freserved123                  uintptr
	Freserved124                  uintptr
	Freserved125                  uintptr
	Ftcl_GetVariableFullName      uintptr
	Freserved127                  uintptr
	Ftcl_PopCallFrame             uintptr
	Ftcl_PushCallFrame            uintptr
	Ftcl_RemoveInterpResolvers    uintptr
	Ftcl_SetNamespaceResolvers    uintptr
	Freserved132                  uintptr
	Freserved133                  uintptr
	Freserved134                  uintptr
	Freserved135                  uintptr
	Freserved136                  uintptr
	Freserved137                  uintptr
	FtclGetEnv                    uintptr
	Freserved139                  uintptr
	Freserved140                  uintptr
	FtclpGetCwd                   uintptr
	FtclSetByteCodeFromAny        uintptr
	FtclAddLiteralObj             uintptr
	FtclHideLiteral               uintptr
	FtclGetAuxDataType            uintptr
	FtclHandleCreate              uintptr
	FtclHandleFree                uintptr
	FtclHandlePreserve            uintptr
	FtclHandleRelease             uintptr
	FtclRegAbout                  uintptr
	FtclRegExpRangeUniChar        uintptr
	Freserved152                  uintptr
	Freserved153                  uintptr
	Freserved154                  uintptr
	Freserved155                  uintptr
	FtclRegError                  uintptr
	FtclVarTraceExists            uintptr
	Freserved158                  uintptr
	Freserved159                  uintptr
	Freserved160                  uintptr
	FtclChannelTransform          uintptr
	FtclChannelEventScriptInvoker uintptr
	FtclGetInstructionTable       uintptr
	FtclExpandCodeArray           uintptr
	FtclpSetInitialEncodings      uintptr
	FtclListObjSetElement         uintptr
	Freserved167                  uintptr
	Freserved168                  uintptr
	FtclpUtfNcmp2                 uintptr
	FtclCheckInterpTraces         uintptr
	FtclCheckExecutionTraces      uintptr
	FtclInThreadExit              uintptr
	FtclUniCharMatch              uintptr
	Freserved174                  uintptr
	FtclCallVarTraces             uintptr
	FtclCleanupVar                uintptr
	FtclVarErrMsg                 uintptr
	Freserved178                  uintptr
	Freserved179                  uintptr
	Freserved180                  uintptr
	Freserved181                  uintptr
	Freserved182                  uintptr
	Freserved183                  uintptr
	Freserved184                  uintptr
	Freserved185                  uintptr
	Freserved186                  uintptr
	Freserved187                  uintptr
	Freserved188                  uintptr
	Freserved189                  uintptr
	Freserved190                  uintptr
	Freserved191                  uintptr
	Freserved192                  uintptr
	Freserved193                  uintptr
	Freserved194                  uintptr
	Freserved195                  uintptr
	Freserved196                  uintptr
	Freserved197                  uintptr
	FtclObjGetFrame               uintptr
	Freserved199                  uintptr
	FtclpObjRemoveDirectory       uintptr
	FtclpObjCopyDirectory         uintptr
	FtclpObjCreateDirectory       uintptr
	FtclpObjDeleteFile            uintptr
	FtclpObjCopyFile              uintptr
	FtclpObjRenameFile            uintptr
	FtclpObjStat                  uintptr
	FtclpObjAccess                uintptr
	FtclpOpenFileChannel          uintptr
	Freserved209                  uintptr
	Freserved210                  uintptr
	Freserved211                  uintptr
	FtclpFindExecutable           uintptr
	FtclGetObjNameOfExecutable    uintptr
	FtclSetObjNameOfExecutable    uintptr
	FtclStackAlloc                uintptr
	FtclStackFree                 uintptr
	FtclPushStackFrame            uintptr
	FtclPopStackFrame             uintptr
	FtclpCreateTemporaryDirectory uintptr
	Freserved220                  uintptr
	FtclListTestObj               uintptr
	FtclListObjValidate           uintptr
	FtclGetCStackPtr              uintptr
	FtclGetPlatform               uintptr
	FtclTraceDictPath             uintptr
	FtclObjBeingDeleted           uintptr
	FtclSetNsPath                 uintptr
	Freserved228                  uintptr
	FtclPtrMakeUpvar              uintptr
	FtclObjLookupVar              uintptr
	FtclGetNamespaceFromObj       uintptr
	FtclEvalObjEx                 uintptr
	FtclGetSrcInfoForPc           uintptr
	FtclVarHashCreateVar          uintptr
	FtclInitVarHashTable          uintptr
	Freserved236                  uintptr
	FtclResetCancellation         uintptr
	FtclNRInterpProc              uintptr
	FtclNRInterpProcCore          uintptr
	FtclNRRunCallbacks            uintptr
	FtclNREvalObjEx               uintptr
	FtclNREvalObjv                uintptr
	FtclDbDumpActiveObjects       uintptr
	FtclGetNamespaceChildTable    uintptr
	FtclGetNamespaceCommandTable  uintptr
	FtclInitRewriteEnsemble       uintptr
	FtclResetRewriteEnsemble      uintptr
	FtclCopyChannel               uintptr
	FtclDoubleDigits              uintptr
	FtclSetChildCancelFlags       uintptr
	FtclRegisterLiteral           uintptr
	FtclPtrGetVar                 uintptr
	FtclPtrSetVar                 uintptr
	FtclPtrIncrObjVar             uintptr
	FtclPtrObjMakeUpvar           uintptr
	FtclPtrUnsetVar               uintptr
	FtclStaticLibrary             uintptr
	Freserved258                  uintptr
	Freserved259                  uintptr
	Freserved260                  uintptr
	FtclUnusedStubEntry           uintptr
}

type TTclIntPlatStubs = struct {
	Fmagic                    int32
	Fhooks                    uintptr
	Freserved0                uintptr
	FtclpCloseFile            uintptr
	FtclpCreateCommandChannel uintptr
	FtclpCreatePipe           uintptr
	FtclWinGetTclInstance     uintptr
	FtclUnixWaitForFile       uintptr
	FtclpMakeFile             uintptr
	FtclpOpenFile             uintptr
	FtclpGetPid               uintptr
	FtclpCreateTempFile       uintptr
	Freserved10               uintptr
	FtclGetAndDetachPids      uintptr
	Freserved12               uintptr
	Freserved13               uintptr
	Freserved14               uintptr
	FtclpCreateProcess        uintptr
	FtclpIsAtty               uintptr
	FtclUnixCopyFile          uintptr
	Freserved18               uintptr
	Freserved19               uintptr
	FtclWinAddProcess         uintptr
	Freserved21               uintptr
	Freserved22               uintptr
	Freserved23               uintptr
	FtclWinNoBackslash        uintptr
	Freserved25               uintptr
	Freserved26               uintptr
	FtclWinFlushDirtyChannels uintptr
	Freserved28               uintptr
	FtclWinCPUID              uintptr
	FtclUnixOpenTemporaryFile uintptr
}

type Tregex_t = struct {
	Fre_magic int32
	Fre_info  int64
	Fre_nsub  Tsize_t
	Fre_endp  uintptr
	Fre_guts  uintptr
	Fre_fns   uintptr
}

type Tregmatch_t = struct {
	Frm_so Tsize_t
	Frm_eo Tsize_t
}

type Trm_detail_t = struct {
	Frm_extend Tregmatch_t
}

type Tchr = int32

type Tpchr = int32

type Tuchr = uint32

type Tcelt = int32

type Tcolor = int16

type Tpcolor = int32

type Tcolors = struct {
	Fccolor [256]Tcolor
}

type Tptrs = struct {
	Fpptr [256]uintptr
}

type Ttree = struct {
	Fptrs        [0]Tptrs
	Fcolors      Tcolors
	F__ccgo_pad2 [1536]byte
}

type Tcolordesc = struct {
	Fnchrs Tuchr
	Fsub   Tcolor
	Farcs  uintptr
	Fflags int32
	Fblock uintptr
}

type Tcolormap = struct {
	Fmagic   int32
	Fv       uintptr
	Fncds    Tsize_t
	Fmax     Tsize_t
	Ffree    Tcolor
	Fcd      uintptr
	Fcdspace [10]Tcolordesc
	Ftree    [4]Ttree
}

type Tcvec = struct {
	Fnchrs      Tsize_t
	Fchrspace   Tsize_t
	Fchrs       uintptr
	Fnranges    Tsize_t
	Frangespace Tsize_t
	Franges     uintptr
}

type Tstate = struct {
	Fno    Tsize_t
	Fflag  uint8
	Fnins  Tsize_t
	Fins   uintptr
	Fnouts Tsize_t
	Fouts  uintptr
	Ffree  uintptr
	Ftmp   uintptr
	Fnext  uintptr
	Fprev  uintptr
	Foas   Tarcbatch
	Fnoas  Tsize_t
}

type Tarc = struct {
	Ftype1         int32
	Fco            Tcolor
	Ffrom          uintptr
	Fto            uintptr
	Foutchain      uintptr
	FoutchainRev   uintptr
	Finchain       uintptr
	FinchainRev    uintptr
	Fcolorchain    uintptr
	FcolorchainRev uintptr
}

type Tarcbatch = struct {
	Fnext uintptr
	Fa    [10]Tarc
}

type Tnfa = struct {
	Fpre     uintptr
	Finit1   uintptr
	Ffinal   uintptr
	Fpost    uintptr
	Fnstates Tsize_t
	Fstates  uintptr
	Fslast   uintptr
	Ffree    uintptr
	Fcm      uintptr
	Fbos     [2]Tcolor
	Feos     [2]Tcolor
	Fv       uintptr
	Fparent  uintptr
}

type Tcarc = struct {
	Fco Tcolor
	Fto Tsize_t
}

type Tcnfa = struct {
	Fnstates Tsize_t
	Fncolors int32
	Fflags   int32
	Fpre     Tsize_t
	Fpost    Tsize_t
	Fbos     [2]Tcolor
	Feos     [2]Tcolor
	Fstflags uintptr
	Fstates  uintptr
	Farcs    uintptr
}

type Tsubre = struct {
	Fop    uint8
	Fflags uint8
	Fid    int16
	Fsubno int32
	Fmin   int16
	Fmax   int16
	Fleft  uintptr
	Fright uintptr
	Fbegin uintptr
	Fend   uintptr
	Fcnfa  Tcnfa
	Fchain uintptr
}

type Tfns = struct {
	Ffree uintptr
}

type Tguts = struct {
	Fmagic   int32
	Fcflags  int32
	Finfo    int64
	Fnsub    Tsize_t
	Ftree    uintptr
	Fsearch  Tcnfa
	Fntree   Tsize_t
	Fcmap    Tcolormap
	Fcompare uintptr
	Flacons  uintptr
	Fnlacons Tsize_t
}

/* automatically gathered by fwd; do not hand-edit */
/* =====^!^===== end forwards =====^!^===== */

/* internal variables, bundled for easy passing around */
type Tvars = struct {
	Fre        uintptr
	Fnow       uintptr
	Fstop      uintptr
	Fsavenow   uintptr
	Fsavestop  uintptr
	Ferr       int32
	Fcflags    int32
	Flasttype  int32
	Fnexttype  int32
	Fnextvalue Tsize_t
	Flexcon    int32
	Fnsubexp   Tsize_t
	Fsubs      uintptr
	Fnsubs     Tsize_t
	Fsub10     [10]uintptr
	Fnfa       uintptr
	Fcm        uintptr
	Fnlcolor   Tcolor
	Fwordchrs  uintptr
	Ftree      uintptr
	Ftreechain uintptr
	Ftreefree  uintptr
	Fntree     int32
	Fcv        uintptr
	Fcv2       uintptr
	Flacons    uintptr
	Fnlacons   Tsize_t
	Fspaceused Tsize_t
}

/* parsing macros; most know that `v' is the struct vars pointer */

/* token type codes, some also used as NFA arc types */

/* is an arc colored, and hence on a color chain? */

// C documentation
//
//	/* static function list */
var _functions = Tfns{}

func init() {
	p := unsafe.Pointer(&_functions)
	*(*uintptr)(unsafe.Add(p, 0)) = __ccgo_fp(_rfree)
}

// C documentation
//
//	/*
//	 - compile - compile regular expression
//	 * Note: on failure, no resources remain allocated, so regfree()
//	 * need not be applied to re.
//	 ^ int compile(regex_t *, const chr *, size_t, int);
//	 */
func XTclReComp(tls *libc.TLS, re uintptr, string1 uintptr, len1 Tsize_t, flags int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var debug, g, v, v1, v2, v5 uintptr
	var i, j Tsize_t
	_, _, _, _, _, _, _, _ = debug, g, i, j, v, v1, v2, v5
	v = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_varsKey)), int64(280))
	if flags&int32(REG_PROGRESS) != 0 {
		v1 = libc.Xstdout
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	debug = v1
	/*
	 * Sanity checks.
	 */
	if re == libc.UintptrFromInt32(0) || string1 == libc.UintptrFromInt32(0) {
		return int32(REG_INVARG)
	}
	if flags&int32(REG_QUOTE) != 0 && flags&(libc.Int32FromInt32(REG_ADVANCED)|libc.Int32FromInt32(REG_EXPANDED)|libc.Int32FromInt32(REG_NEWLINE)) != 0 {
		return int32(REG_INVARG)
	}
	if !(flags&libc.Int32FromInt32(REG_EXTENDED) != 0) && flags&int32(REG_ADVF) != 0 {
		return int32(REG_INVARG)
	}
	/*
	 * Initial setup (after which freev() is callable).
	 */
	(*Tvars)(unsafe.Pointer(v)).Fre = re
	(*Tvars)(unsafe.Pointer(v)).Fnow = string1
	(*Tvars)(unsafe.Pointer(v)).Fstop = (*Tvars)(unsafe.Pointer(v)).Fnow + uintptr(len1)*4
	v2 = libc.UintptrFromInt32(0)
	(*Tvars)(unsafe.Pointer(v)).Fsavestop = v2
	(*Tvars)(unsafe.Pointer(v)).Fsavenow = v2
	(*Tvars)(unsafe.Pointer(v)).Ferr = 0
	(*Tvars)(unsafe.Pointer(v)).Fcflags = flags
	(*Tvars)(unsafe.Pointer(v)).Fnsubexp = uint64(0)
	(*Tvars)(unsafe.Pointer(v)).Fsubs = v + 96
	(*Tvars)(unsafe.Pointer(v)).Fnsubs = uint64(10)
	j = uint64(0)
	for {
		if !(j < (*Tvars)(unsafe.Pointer(v)).Fnsubs) {
			break
		}
		*(*uintptr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fsubs + uintptr(j)*8)) = libc.UintptrFromInt32(0)
		goto _3
	_3:
		;
		j++
	}
	(*Tvars)(unsafe.Pointer(v)).Fnfa = libc.UintptrFromInt32(0)
	(*Tvars)(unsafe.Pointer(v)).Fcm = libc.UintptrFromInt32(0)
	(*Tvars)(unsafe.Pointer(v)).Fnlcolor = int16(-libc.Int32FromInt32(1))
	(*Tvars)(unsafe.Pointer(v)).Fwordchrs = libc.UintptrFromInt32(0)
	(*Tvars)(unsafe.Pointer(v)).Ftree = libc.UintptrFromInt32(0)
	(*Tvars)(unsafe.Pointer(v)).Ftreechain = libc.UintptrFromInt32(0)
	(*Tvars)(unsafe.Pointer(v)).Ftreefree = libc.UintptrFromInt32(0)
	(*Tvars)(unsafe.Pointer(v)).Fcv = libc.UintptrFromInt32(0)
	(*Tvars)(unsafe.Pointer(v)).Fcv2 = libc.UintptrFromInt32(0)
	(*Tvars)(unsafe.Pointer(v)).Flacons = libc.UintptrFromInt32(0)
	(*Tvars)(unsafe.Pointer(v)).Fnlacons = uint64(0)
	(*Tvars)(unsafe.Pointer(v)).Fspaceused = uint64(0)
	(*Tregex_t)(unsafe.Pointer(re)).Fre_magic = int32(REMAGIC)
	(*Tregex_t)(unsafe.Pointer(re)).Fre_info = 0 /* bits get set during parse */
	(*Tregex_t)(unsafe.Pointer(re)).Fre_guts = libc.UintptrFromInt32(0)
	(*Tregex_t)(unsafe.Pointer(re)).Fre_fns = uintptr(unsafe.Pointer(&_functions))
	/*
	 * More complex setup, malloced things.
	 */
	(*Tregex_t)(unsafe.Pointer(re)).Fre_guts = XTclpAlloc(tls, uint64(8688))
	if (*Tregex_t)(unsafe.Pointer(re)).Fre_guts == libc.UintptrFromInt32(0) {
		return _freev(tls, v, int32(REG_ESPACE))
	}
	g = (*Tregex_t)(unsafe.Pointer(re)).Fre_guts
	(*Tguts)(unsafe.Pointer(g)).Ftree = libc.UintptrFromInt32(0)
	_initcm(tls, v, g+104)
	(*Tvars)(unsafe.Pointer(v)).Fcm = g + 104
	(*Tguts)(unsafe.Pointer(g)).Flacons = libc.UintptrFromInt32(0)
	(*Tguts)(unsafe.Pointer(g)).Fnlacons = uint64(0)
	(*Tguts)(unsafe.Pointer(g)).Fsearch.Fnstates = uint64(0)
	(*Tvars)(unsafe.Pointer(v)).Fnfa = _newnfa(tls, v, (*Tvars)(unsafe.Pointer(v)).Fcm, libc.UintptrFromInt32(0))
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return _freev(tls, v, (*Tvars)(unsafe.Pointer(v)).Ferr)
	}
	(*Tvars)(unsafe.Pointer(v)).Fcv = _newcvec(tls, uint64(100), uint64(20))
	if (*Tvars)(unsafe.Pointer(v)).Fcv == libc.UintptrFromInt32(0) {
		return _freev(tls, v, int32(REG_ESPACE))
	}
	/*
	 * Parsing.
	 */
	_lexstart(tls, v) /* also handles prefixes */
	if (*Tvars)(unsafe.Pointer(v)).Fcflags&int32(REG_NLSTOP) != 0 || (*Tvars)(unsafe.Pointer(v)).Fcflags&int32(REG_NLANCH) != 0 {
		/*
		 * Assign newline a unique color.
		 */
		(*Tvars)(unsafe.Pointer(v)).Fnlcolor = _subcolor(tls, (*Tvars)(unsafe.Pointer(v)).Fcm, _newline(tls))
		_okcolors(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, (*Tvars)(unsafe.Pointer(v)).Fcm)
	}
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return _freev(tls, v, (*Tvars)(unsafe.Pointer(v)).Ferr)
	}
	(*Tvars)(unsafe.Pointer(v)).Ftree = _parse(tls, v, int32('e'), int32('p'), (*Tnfa)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnfa)).Finit1, (*Tnfa)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnfa)).Ffinal)
	/* even if error; ISERR() => SEE(EOS) */
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return _freev(tls, v, (*Tvars)(unsafe.Pointer(v)).Ferr)
	}
	/*
	 * Finish setup of nfa and its subre tree.
	 */
	_specialcolors(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return _freev(tls, v, (*Tvars)(unsafe.Pointer(v)).Ferr)
	}
	if debug != libc.UintptrFromInt32(0) {
		libc.Xfprintf(tls, debug, __ccgo_ts, 0)
		_dumpnfa(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, debug)
		_dumpst(tls, (*Tvars)(unsafe.Pointer(v)).Ftree, debug, int32(1))
	}
	(*Tvars)(unsafe.Pointer(v)).Fntree = _numst(tls, (*Tvars)(unsafe.Pointer(v)).Ftree, int32(1))
	_markst(tls, (*Tvars)(unsafe.Pointer(v)).Ftree)
	_cleanst(tls, v)
	if debug != libc.UintptrFromInt32(0) {
		libc.Xfprintf(tls, debug, __ccgo_ts+29, 0)
		_dumpst(tls, (*Tvars)(unsafe.Pointer(v)).Ftree, debug, int32(1))
	}
	/*
	 * Build compacted NFAs for tree and lacons.
	 */
	*(*int64)(unsafe.Pointer(re + 8)) |= _nfatree(tls, v, (*Tvars)(unsafe.Pointer(v)).Ftree, debug)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return _freev(tls, v, (*Tvars)(unsafe.Pointer(v)).Ferr)
	}
	i = uint64(1)
	for {
		if !(i < (*Tvars)(unsafe.Pointer(v)).Fnlacons) {
			break
		}
		if debug != libc.UintptrFromInt32(0) {
			libc.Xfprintf(tls, debug, __ccgo_ts+65, libc.VaList(bp+8, i))
		}
		_nfanode(tls, v, (*Tvars)(unsafe.Pointer(v)).Flacons+uintptr(i)*120, debug)
		goto _4
	_4:
		;
		i++
	}
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return _freev(tls, v, (*Tvars)(unsafe.Pointer(v)).Ferr)
	}
	if libc.Int32FromUint8((*Tsubre)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Ftree)).Fflags)&int32(SHORTER) != 0 {
		*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_USHORTEST))
	}
	/*
	 * Build compacted NFAs for tree, lacons, fast search.
	 */
	if debug != libc.UintptrFromInt32(0) {
		libc.Xfprintf(tls, debug, __ccgo_ts+96, 0)
	}
	/*
	 * Can sacrifice main NFA now, so use it as work area.
	 */
	_optimize(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, debug)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return _freev(tls, v, (*Tvars)(unsafe.Pointer(v)).Ferr)
	}
	_makesearch(tls, v, (*Tvars)(unsafe.Pointer(v)).Fnfa)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return _freev(tls, v, (*Tvars)(unsafe.Pointer(v)).Ferr)
	}
	_compact(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, g+32)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return _freev(tls, v, (*Tvars)(unsafe.Pointer(v)).Ferr)
	}
	/*
	 * Looks okay, package it up.
	 */
	(*Tregex_t)(unsafe.Pointer(re)).Fre_nsub = (*Tvars)(unsafe.Pointer(v)).Fnsubexp
	(*Tvars)(unsafe.Pointer(v)).Fre = libc.UintptrFromInt32(0) /* freev no longer frees re */
	(*Tguts)(unsafe.Pointer(g)).Fmagic = int32(GUTSMAGIC)
	(*Tguts)(unsafe.Pointer(g)).Fcflags = (*Tvars)(unsafe.Pointer(v)).Fcflags
	(*Tguts)(unsafe.Pointer(g)).Finfo = (*Tregex_t)(unsafe.Pointer(re)).Fre_info
	(*Tguts)(unsafe.Pointer(g)).Fnsub = (*Tregex_t)(unsafe.Pointer(re)).Fre_nsub
	(*Tguts)(unsafe.Pointer(g)).Ftree = (*Tvars)(unsafe.Pointer(v)).Ftree
	(*Tvars)(unsafe.Pointer(v)).Ftree = libc.UintptrFromInt32(0)
	(*Tguts)(unsafe.Pointer(g)).Fntree = libc.Uint64FromInt32((*Tvars)(unsafe.Pointer(v)).Fntree)
	if (*Tvars)(unsafe.Pointer(v)).Fcflags&int32(REG_ICASE) != 0 {
		v5 = __ccgo_fp(_casecmp)
	} else {
		v5 = __ccgo_fp(_cmp)
	}
	(*Tguts)(unsafe.Pointer(g)).Fcompare = v5
	(*Tguts)(unsafe.Pointer(g)).Flacons = (*Tvars)(unsafe.Pointer(v)).Flacons
	(*Tvars)(unsafe.Pointer(v)).Flacons = libc.UintptrFromInt32(0)
	(*Tguts)(unsafe.Pointer(g)).Fnlacons = (*Tvars)(unsafe.Pointer(v)).Fnlacons
	if flags&int32(REG_DUMP) != 0 {
		_dump(tls, re, libc.Xstdout)
	}
	return _freev(tls, v, 0)
}

var _varsKey TTcl_ThreadDataKey

// C documentation
//
//	/*
//	 - moresubs - enlarge subRE vector
//	 ^ static void moresubs(struct vars *, size_t);
//	 */
func _moresubs(tls *libc.TLS, v uintptr, wanted Tsize_t) {
	/* want enough room for this one */
	var n Tsize_t
	var p uintptr
	var v1 int32
	_, _, _ = n, p, v1
	n = wanted*uint64(3)/uint64(2) + uint64(1)
	if (*Tvars)(unsafe.Pointer(v)).Fsubs == v+96 {
		p = XTclpAlloc(tls, n*uint64(8))
		if p != libc.UintptrFromInt32(0) {
			libc.Xmemcpy(tls, p, (*Tvars)(unsafe.Pointer(v)).Fsubs, (*Tvars)(unsafe.Pointer(v)).Fnsubs*uint64(8))
		}
	} else {
		p = XTclpRealloc(tls, (*Tvars)(unsafe.Pointer(v)).Fsubs, n*uint64(8))
	}
	if p == libc.UintptrFromInt32(0) {
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			v1 = (*Tvars)(unsafe.Pointer(v)).Ferr
		} else {
			v1 = int32(REG_ESPACE)
		}
		(*Tvars)(unsafe.Pointer(v)).Ferr = v1
		return
	}
	(*Tvars)(unsafe.Pointer(v)).Fsubs = p
	p = (*Tvars)(unsafe.Pointer(v)).Fsubs + uintptr((*Tvars)(unsafe.Pointer(v)).Fnsubs)*8
	for {
		if !((*Tvars)(unsafe.Pointer(v)).Fnsubs < n) {
			break
		}
		*(*uintptr)(unsafe.Pointer(p)) = libc.UintptrFromInt32(0)
		goto _2
	_2:
		;
		p += 8
		(*Tvars)(unsafe.Pointer(v)).Fnsubs++
	}
}

// C documentation
//
//	/*
//	 - freev - free vars struct's substructures where necessary
//	 * Optionally does error-number setting, and always returns error code (if
//	 * any), to make error-handling code terser.
//	 ^ static int freev(struct vars *, int);
//	 */
func _freev(tls *libc.TLS, v uintptr, err int32) (r int32) {
	var ret, v1 int32
	_, _ = ret, v1
	if (*Tvars)(unsafe.Pointer(v)).Fre != libc.UintptrFromInt32(0) {
		_rfree(tls, (*Tvars)(unsafe.Pointer(v)).Fre)
	}
	if (*Tvars)(unsafe.Pointer(v)).Fsubs != v+96 {
		XTclpFree(tls, (*Tvars)(unsafe.Pointer(v)).Fsubs)
	}
	if (*Tvars)(unsafe.Pointer(v)).Fnfa != libc.UintptrFromInt32(0) {
		_freenfa(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa)
	}
	if (*Tvars)(unsafe.Pointer(v)).Ftree != libc.UintptrFromInt32(0) {
		_freesubre(tls, v, (*Tvars)(unsafe.Pointer(v)).Ftree)
	}
	if (*Tvars)(unsafe.Pointer(v)).Ftreechain != libc.UintptrFromInt32(0) {
		_cleanst(tls, v)
	}
	if (*Tvars)(unsafe.Pointer(v)).Fcv != libc.UintptrFromInt32(0) {
		_freecvec(tls, (*Tvars)(unsafe.Pointer(v)).Fcv)
	}
	if (*Tvars)(unsafe.Pointer(v)).Fcv2 != libc.UintptrFromInt32(0) {
		_freecvec(tls, (*Tvars)(unsafe.Pointer(v)).Fcv2)
	}
	if (*Tvars)(unsafe.Pointer(v)).Flacons != libc.UintptrFromInt32(0) {
		_freelacons(tls, (*Tvars)(unsafe.Pointer(v)).Flacons, libc.Int32FromUint64((*Tvars)(unsafe.Pointer(v)).Fnlacons))
	}
	(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		v1 = (*Tvars)(unsafe.Pointer(v)).Ferr
	} else {
		v1 = err
	}
	(*Tvars)(unsafe.Pointer(v)).Ferr = v1 /* nop if err==0 */
	ret = (*Tvars)(unsafe.Pointer(v)).Ferr
	return ret
}

// C documentation
//
//	/*
//	 - makesearch - turn an NFA into a search NFA (implicit prepend of .*?)
//	 * NFA must have been optimize()d already.
//	 ^ static void makesearch(struct vars *, struct nfa *);
//	 */
func _makesearch(tls *libc.TLS, v uintptr, nfa uintptr) {
	var a, b, pre, s, s2, slist, v4, v7 uintptr
	_, _, _, _, _, _, _, _ = a, b, pre, s, s2, slist, v4, v7
	pre = (*Tnfa)(unsafe.Pointer(nfa)).Fpre
	/*
	 * No loops are needed if it's anchored.
	 */
	a = (*Tstate)(unsafe.Pointer(pre)).Fouts
	for {
		if !(a != libc.UintptrFromInt32(0)) {
			break
		}
		if int32((*Tarc)(unsafe.Pointer(a)).Fco) != int32(*(*Tcolor)(unsafe.Pointer(nfa + 72))) && int32((*Tarc)(unsafe.Pointer(a)).Fco) != int32(*(*Tcolor)(unsafe.Pointer(nfa + 72 + 1*2))) {
			break
		}
		goto _1
	_1:
		;
		a = (*Tarc)(unsafe.Pointer(a)).Foutchain
	}
	if a != libc.UintptrFromInt32(0) {
		/*
		 * Add implicit .* in front.
		 */
		_rainbow(tls, nfa, (*Tvars)(unsafe.Pointer(v)).Fcm, int32('p'), -libc.Int32FromInt32(1), pre, pre)
		/*
		 * And ^* and \A* too -- not always necessary, but harmless.
		 */
		_newarc(tls, nfa, int32('p'), int32(*(*Tcolor)(unsafe.Pointer(nfa + 72))), pre, pre)
		_newarc(tls, nfa, int32('p'), int32(*(*Tcolor)(unsafe.Pointer(nfa + 72 + 1*2))), pre, pre)
	}
	/*
	 * Now here's the subtle part. Because many REs have no lookback
	 * constraints, often knowing when you were in the pre state tells you
	 * little; it's the next state(s) that are informative. But some of them
	 * may have other inarcs, i.e. it may be possible to make actual progress
	 * and then return to one of them. We must de-optimize such cases,
	 * splitting each such state into progress and no-progress states.
	 */
	/*
	 * First, make a list of the states.
	 */
	slist = libc.UintptrFromInt32(0)
	a = (*Tstate)(unsafe.Pointer(pre)).Fouts
	for {
		if !(a != libc.UintptrFromInt32(0)) {
			break
		}
		s = (*Tarc)(unsafe.Pointer(a)).Fto
		b = (*Tstate)(unsafe.Pointer(s)).Fins
		for {
			if !(b != libc.UintptrFromInt32(0)) {
				break
			}
			if (*Tarc)(unsafe.Pointer(b)).Ffrom != pre {
				break
			}
			goto _3
		_3:
			;
			b = (*Tarc)(unsafe.Pointer(b)).Finchain
		}
		/*
		 * We want to mark states as being in the list already by having non
		 * NULL tmp fields, but we can't just store the old slist value in tmp
		 * because that doesn't work for the first such state.  Instead, the
		 * first list entry gets its own address in tmp.
		 */
		if b != libc.UintptrFromInt32(0) && (*Tstate)(unsafe.Pointer(s)).Ftmp == libc.UintptrFromInt32(0) {
			if slist != libc.UintptrFromInt32(0) {
				v4 = slist
			} else {
				v4 = s
			}
			(*Tstate)(unsafe.Pointer(s)).Ftmp = v4
			slist = s
		}
		goto _2
	_2:
		;
		a = (*Tarc)(unsafe.Pointer(a)).Foutchain
	}
	/*
	 * Do the splits.
	 */
	s = slist
	for {
		if !(s != libc.UintptrFromInt32(0)) {
			break
		}
		s2 = _newstate(tls, nfa)
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			return
		}
		_copyouts(tls, nfa, s, s2)
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			return
		}
		a = (*Tstate)(unsafe.Pointer(s)).Fins
		for {
			if !(a != libc.UintptrFromInt32(0)) {
				break
			}
			b = (*Tarc)(unsafe.Pointer(a)).Finchain
			if (*Tarc)(unsafe.Pointer(a)).Ffrom != pre {
				_cparc(tls, nfa, a, (*Tarc)(unsafe.Pointer(a)).Ffrom, s2)
				_freearc(tls, nfa, a)
			}
			goto _6
		_6:
			;
			a = b
		}
		if (*Tstate)(unsafe.Pointer(s)).Ftmp != s {
			v7 = (*Tstate)(unsafe.Pointer(s)).Ftmp
		} else {
			v7 = libc.UintptrFromInt32(0)
		}
		s2 = v7
		(*Tstate)(unsafe.Pointer(s)).Ftmp = libc.UintptrFromInt32(0) /* clean up while we're at it */
		goto _5
	_5:
		;
		s = s2
	}
}

// C documentation
//
//	/*
//	 - parse - parse an RE
//	 * This is actually just the top level, which parses a bunch of branches tied
//	 * together with '|'. They appear in the tree as the left children of a chain
//	 * of '|' subres.
//	 ^ static struct subre *parse(struct vars *, int, int, struct state *,
//	 ^	struct state *);
//	 */
func _parse(tls *libc.TLS, v uintptr, stopper int32, type1 int32, init1 uintptr, final uintptr) (r uintptr) {
	/* final state */
	var branch, branches, left, right, t, p1, p3 uintptr
	var firstbranch, v4 int32
	_, _, _, _, _, _, _, _, _ = branch, branches, firstbranch, left, right, t, v4, p1, p3 /* is this the first branch? */
	branches = _sub_re(tls, v, int32('|'), int32(LONGER), init1, final)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return libc.UintptrFromInt32(0)
	}
	branch = branches
	firstbranch = int32(1)
	for cond := true; cond; cond = (*Tvars)(unsafe.Pointer(v)).Fnexttype == int32('|') && _next(tls, v) != 0 { /* a branch */
		if !(firstbranch != 0) {
			/*
			 * Need a place to hang the branch.
			 */
			(*Tsubre)(unsafe.Pointer(branch)).Fright = _sub_re(tls, v, int32('|'), int32(LONGER), init1, final)
			if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
				return libc.UintptrFromInt32(0)
			}
			branch = (*Tsubre)(unsafe.Pointer(branch)).Fright
		}
		firstbranch = 0
		left = _newstate(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa)
		right = _newstate(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa)
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			return libc.UintptrFromInt32(0)
		}
		_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('n'), 0, init1, left)
		_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('n'), 0, right, final)
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			return libc.UintptrFromInt32(0)
		}
		(*Tsubre)(unsafe.Pointer(branch)).Fleft = _parsebranch(tls, v, stopper, type1, left, right, 0)
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			return libc.UintptrFromInt32(0)
		}
		p1 = branch + 1
		*(*uint8)(unsafe.Pointer(p1)) = uint8(int32(*(*uint8)(unsafe.Pointer(p1))) | ((libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(branch)).Fflags)|libc.Int32FromUint8((*Tsubre)(unsafe.Pointer((*Tsubre)(unsafe.Pointer(branch)).Fleft)).Fflags)) & ^libc.Int32FromInt32(NOPROP) | (libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(branch)).Fflags)|libc.Int32FromUint8((*Tsubre)(unsafe.Pointer((*Tsubre)(unsafe.Pointer(branch)).Fleft)).Fflags))<<libc.Int32FromInt32(2)&((libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(branch)).Fflags)|libc.Int32FromUint8((*Tsubre)(unsafe.Pointer((*Tsubre)(unsafe.Pointer(branch)).Fleft)).Fflags))<<libc.Int32FromInt32(1))&libc.Int32FromInt32(MIXED)))
		if libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(branch)).Fflags) & ^libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(branches)).Fflags) != 0 { /* new flags */
			t = branches
			for {
				if !(t != branch) {
					break
				}
				p3 = t + 1
				*(*uint8)(unsafe.Pointer(p3)) = uint8(int32(*(*uint8)(unsafe.Pointer(p3))) | libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(branch)).Fflags))
				goto _2
			_2:
				;
				t = (*Tsubre)(unsafe.Pointer(t)).Fright
			}
		}
	}
	if !((*Tvars)(unsafe.Pointer(v)).Fnexttype == stopper) {
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			v4 = (*Tvars)(unsafe.Pointer(v)).Ferr
		} else {
			v4 = int32(REG_EPAREN)
		}
		(*Tvars)(unsafe.Pointer(v)).Ferr = v4
	}
	/*
	 * Optimize out simple cases.
	 */
	if branch == branches { /* only one branch */
		t = (*Tsubre)(unsafe.Pointer(branch)).Fleft
		(*Tsubre)(unsafe.Pointer(branch)).Fleft = libc.UintptrFromInt32(0)
		_freesubre(tls, v, branches)
		branches = t
	} else {
		if !(libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(branches)).Fflags)&(libc.Int32FromInt32(MIXED)|libc.Int32FromInt32(CAP)|libc.Int32FromInt32(BACKR)) != 0) { /* no interesting innards */
			_freesubre(tls, v, (*Tsubre)(unsafe.Pointer(branches)).Fleft)
			(*Tsubre)(unsafe.Pointer(branches)).Fleft = libc.UintptrFromInt32(0)
			_freesubre(tls, v, (*Tsubre)(unsafe.Pointer(branches)).Fright)
			(*Tsubre)(unsafe.Pointer(branches)).Fright = libc.UintptrFromInt32(0)
			(*Tsubre)(unsafe.Pointer(branches)).Fop = uint8('=')
		}
	}
	return branches
}

// C documentation
//
//	/*
//	 - parsebranch - parse one branch of an RE
//	 * This mostly manages concatenation, working closely with parseqatom().
//	 * Concatenated things are bundled up as much as possible, with separate
//	 * ',' nodes introduced only when necessary due to substructure.
//	 ^ static struct subre *parsebranch(struct vars *, int, int, struct state *,
//	 ^	struct state *, int);
//	 */
func _parsebranch(tls *libc.TLS, v uintptr, stopper int32, type1 int32, left uintptr, right uintptr, partial int32) (r uintptr) {
	/* is this only part of a branch? */
	var lp, t uintptr
	var seencontent int32
	_, _, _ = lp, seencontent, t
	lp = left
	seencontent = 0
	t = _sub_re(tls, v, int32('='), 0, left, right) /* op '=' is tentative */
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return libc.UintptrFromInt32(0)
	}
	for !((*Tvars)(unsafe.Pointer(v)).Fnexttype == libc.Int32FromUint8('|')) && !((*Tvars)(unsafe.Pointer(v)).Fnexttype == stopper) && !((*Tvars)(unsafe.Pointer(v)).Fnexttype == libc.Int32FromUint8('e')) {
		if seencontent != 0 { /* implicit concat operator */
			lp = _newstate(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa)
			if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
				return libc.UintptrFromInt32(0)
			}
			_moveins(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, right, lp)
		}
		seencontent = int32(1)
		/* NB, recursion in parseqatom() may swallow rest of branch */
		_parseqatom(tls, v, stopper, type1, lp, right, t)
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			return libc.UintptrFromInt32(0)
		}
	}
	if !(seencontent != 0) { /* empty branch */
		if !(partial != 0) {
			*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UUNSPEC))
		}
		_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('n'), 0, left, right)
	}
	return t
}

// C documentation
//
//	/*
//	 - parseqatom - parse one quantified atom or constraint of an RE
//	 * The bookkeeping near the end cooperates very closely with parsebranch(); in
//	 * particular, it contains a recursion that can involve parsing the rest of
//	 * the branch, making this function's name somewhat inaccurate.
//	 ^ static void parseqatom(struct vars *, int, int, struct state *,
//	 ^	struct state *, struct subre *);
//	 */
func _parseqatom(tls *libc.TLS, v uintptr, stopper int32, type1 int32, lp uintptr, rp uintptr, top uintptr) {
	/* subtree top */
	var atom, atomp, s, s2, t, p42, p47, p49 uintptr
	var atomtype, cap1, f, m, n, pos, qprefer, v22, v23, v24, v25, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v43, v44, v45, v46, v48, v50 int32
	var subno Tsize_t
	var v26 uint64
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = atom, atomp, atomtype, cap1, f, m, n, pos, qprefer, s, s2, subno, t, v22, v23, v24, v25, v26, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v43, v44, v45, v46, v48, v50, p42, p47, p49 /* where the pointer to atom is */
	/*
	 * Initial bookkeeping.
	 */
	atom = libc.UintptrFromInt32(0)
	/* must string new code */
	/* between lp and rp */
	subno = uint64(0)
	/*
	 * An atom or constraint...
	 */
	atomtype = (*Tvars)(unsafe.Pointer(v)).Fnexttype
	switch atomtype {
	case int32('^'):
		goto _1
	case int32('$'):
		goto _2
	case int32('A'):
		goto _3
	case int32('Z'):
		goto _4
	case int32('<'):
		goto _5
	case int32('>'):
		goto _6
	case int32('w'):
		goto _7
	case int32('W'):
		goto _8
	case int32('L'):
		goto _9
	case int32('{'):
		goto _10
	case int32('?'):
		goto _11
	case int32('+'):
		goto _12
	case int32('*'):
		goto _13
	default:
		goto _14
	case int32(')'):
		goto _15
	case int32('p'):
		goto _16
	case int32('['):
		goto _17
	case int32('.'):
		goto _18
	case int32('('):
		goto _19
	case int32('b'):
		goto _20
	}
	goto _21
	/* first, constraints, which end by returning */
_1:
	;
	_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('^'), int32(1), lp, rp)
	if (*Tvars)(unsafe.Pointer(v)).Fcflags&int32(REG_NLANCH) != 0 {
		_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('r'), int32((*Tvars)(unsafe.Pointer(v)).Fnlcolor), lp, rp)
	}
	_next(tls, v)
	return
_2:
	;
	_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('$'), int32(1), lp, rp)
	if (*Tvars)(unsafe.Pointer(v)).Fcflags&int32(REG_NLANCH) != 0 {
		_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('a'), int32((*Tvars)(unsafe.Pointer(v)).Fnlcolor), lp, rp)
	}
	_next(tls, v)
	return
_3:
	;
	_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('^'), int32(1), lp, rp) /* BOL */
	_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('^'), 0, lp, rp)        /* or BOS */
	_next(tls, v)
	return
_4:
	;
	_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('$'), int32(1), lp, rp) /* EOL */
	_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('$'), 0, lp, rp)        /* or EOS */
	_next(tls, v)
	return
_5:
	;
	_wordchrs(tls, v) /* does NEXT() */
	s = _newstate(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return
	}
	_nonword(tls, v, int32('r'), lp, s)
	_word(tls, v, int32('a'), s, rp)
	return
_6:
	;
	_wordchrs(tls, v) /* does NEXT() */
	s = _newstate(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return
	}
	_word(tls, v, int32('r'), lp, s)
	_nonword(tls, v, int32('a'), s, rp)
	return
_7:
	;
	_wordchrs(tls, v) /* does NEXT() */
	s = _newstate(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return
	}
	_nonword(tls, v, int32('r'), lp, s)
	_word(tls, v, int32('a'), s, rp)
	s = _newstate(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return
	}
	_word(tls, v, int32('r'), lp, s)
	_nonword(tls, v, int32('a'), s, rp)
	return
_8:
	;
	_wordchrs(tls, v) /* does NEXT() */
	s = _newstate(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return
	}
	_word(tls, v, int32('r'), lp, s)
	_word(tls, v, int32('a'), s, rp)
	s = _newstate(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return
	}
	_nonword(tls, v, int32('r'), lp, s)
	_nonword(tls, v, int32('a'), s, rp)
	return
_9:
	; /* lookahead constraint */
	pos = libc.Int32FromUint64((*Tvars)(unsafe.Pointer(v)).Fnextvalue)
	_next(tls, v)
	s = _newstate(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa)
	s2 = _newstate(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return
	}
	t = _parse(tls, v, int32(')'), int32('L'), s, s2)
	_freesubre(tls, v, t) /* internal structure irrelevant */
	_next(tls, v)
	n = _newlacon(tls, v, s, s2, pos)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return
	}
	_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('L'), n, lp, rp)
	return
	/*
	 * Then errors, to get them out of the way.
	 */
_13:
	;
_12:
	;
_11:
	;
_10:
	;
	(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		v22 = (*Tvars)(unsafe.Pointer(v)).Ferr
	} else {
		v22 = int32(REG_BADRPT)
	}
	(*Tvars)(unsafe.Pointer(v)).Ferr = v22
	return
_14:
	;
	(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		v23 = (*Tvars)(unsafe.Pointer(v)).Ferr
	} else {
		v23 = int32(REG_ASSERT)
	}
	(*Tvars)(unsafe.Pointer(v)).Ferr = v23
	return
	/*
	 * Then plain characters, and minor variants on that theme.
	 */
_15:
	; /* unbalanced paren */
	if (*Tvars)(unsafe.Pointer(v)).Fcflags&int32(REG_ADVANCED) != int32(REG_EXTENDED) {
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			v24 = (*Tvars)(unsafe.Pointer(v)).Ferr
		} else {
			v24 = int32(REG_EPAREN)
		}
		(*Tvars)(unsafe.Pointer(v)).Ferr = v24
		return
	}
	/*
	 * Legal in EREs due to specification botch.
	 */
	*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UPBOTCH))
	/* FALLTHRU */
_16:
	;
	_onechr(tls, v, libc.Int32FromUint64((*Tvars)(unsafe.Pointer(v)).Fnextvalue), lp, rp)
	_okcolors(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, (*Tvars)(unsafe.Pointer(v)).Fcm)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return
	}
	_next(tls, v)
	goto _21
_17:
	;
	if (*Tvars)(unsafe.Pointer(v)).Fnextvalue == uint64(1) {
		_bracket(tls, v, lp, rp)
	} else {
		_cbracket(tls, v, lp, rp)
	}
	_next(tls, v)
	goto _21
_18:
	;
	if (*Tvars)(unsafe.Pointer(v)).Fcflags&int32(REG_NLSTOP) != 0 {
		v25 = int32((*Tvars)(unsafe.Pointer(v)).Fnlcolor)
	} else {
		v25 = -int32(1)
	}
	_rainbow(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, (*Tvars)(unsafe.Pointer(v)).Fcm, int32('p'), v25, lp, rp)
	_next(tls, v)
	goto _21
	/*
	 * And finally the ugly stuff.
	 */
_19:
	; /* value flags as capturing or non */
	if type1 == int32('L') {
		v26 = uint64(0)
	} else {
		v26 = (*Tvars)(unsafe.Pointer(v)).Fnextvalue
	}
	cap1 = libc.Int32FromUint64(v26)
	if cap1 != 0 {
		(*Tvars)(unsafe.Pointer(v)).Fnsubexp++
		subno = (*Tvars)(unsafe.Pointer(v)).Fnsubexp
		if subno >= (*Tvars)(unsafe.Pointer(v)).Fnsubs {
			_moresubs(tls, v, subno)
		}
	} else {
		atomtype = int32('p') /* something that's not '(' */
	}
	_next(tls, v)
	/*
	 * Need new endpoints because tree will contain pointers.
	 */
	s = _newstate(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa)
	s2 = _newstate(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return
	}
	_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('n'), 0, lp, s)
	_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('n'), 0, s2, rp)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return
	}
	atom = _parse(tls, v, int32(')'), int32('p'), s, s2)
	_next(tls, v)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return
	}
	if cap1 != 0 {
		*(*uintptr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fsubs + uintptr(subno)*8)) = atom
		t = _sub_re(tls, v, int32('('), libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(atom)).Fflags)|int32(CAP), lp, rp)
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			return
		}
		(*Tsubre)(unsafe.Pointer(t)).Fsubno = libc.Int32FromUint64(subno)
		(*Tsubre)(unsafe.Pointer(t)).Fleft = atom
		atom = t
	}
	/*
	 * Postpone everything else pending possible {0}.
	 */
	goto _21
_20:
	; /* the Feature From The Black Lagoon */
_29:
	;
	if !(type1 != libc.Int32FromUint8('L')) {
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			v30 = (*Tvars)(unsafe.Pointer(v)).Ferr
		} else {
			v30 = int32(REG_ESUBREG)
		}
		(*Tvars)(unsafe.Pointer(v)).Ferr = v30
	}
	goto _28
_28:
	;
	if 0 != 0 {
		goto _29
	}
	goto _27
_27:
	;
	if !((*Tvars)(unsafe.Pointer(v)).Fnextvalue < (*Tvars)(unsafe.Pointer(v)).Fnsubs) {
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			v31 = (*Tvars)(unsafe.Pointer(v)).Ferr
		} else {
			v31 = int32(REG_ESUBREG)
		}
		(*Tvars)(unsafe.Pointer(v)).Ferr = v31
	}
	if !(*(*uintptr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fsubs + uintptr((*Tvars)(unsafe.Pointer(v)).Fnextvalue)*8)) != libc.UintptrFromInt32(0)) {
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			v32 = (*Tvars)(unsafe.Pointer(v)).Ferr
		} else {
			v32 = int32(REG_ESUBREG)
		}
		(*Tvars)(unsafe.Pointer(v)).Ferr = v32
	}
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return
	}
	atom = _sub_re(tls, v, int32('b'), int32(BACKR), lp, rp)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return
	}
	subno = (*Tvars)(unsafe.Pointer(v)).Fnextvalue
	(*Tsubre)(unsafe.Pointer(atom)).Fsubno = libc.Int32FromUint64(subno)
	_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('n'), 0, lp, rp) /* temporarily, so there's something */
	_next(tls, v)
	goto _21
_21:
	;
	/*
	 * ...and an atom may be followed by a quantifier.
	 */
	switch (*Tvars)(unsafe.Pointer(v)).Fnexttype {
	case int32('*'):
		m = 0
		n = libc.Int32FromInt32(_POSIX2_RE_DUP_MAX) + libc.Int32FromInt32(1)
		if (*Tvars)(unsafe.Pointer(v)).Fnextvalue != 0 {
			v33 = int32(LONGER)
		} else {
			v33 = int32(SHORTER)
		}
		qprefer = v33
		_next(tls, v)
	case int32('+'):
		m = int32(1)
		n = libc.Int32FromInt32(_POSIX2_RE_DUP_MAX) + libc.Int32FromInt32(1)
		if (*Tvars)(unsafe.Pointer(v)).Fnextvalue != 0 {
			v34 = int32(LONGER)
		} else {
			v34 = int32(SHORTER)
		}
		qprefer = v34
		_next(tls, v)
	case int32('?'):
		m = 0
		n = int32(1)
		if (*Tvars)(unsafe.Pointer(v)).Fnextvalue != 0 {
			v35 = int32(LONGER)
		} else {
			v35 = int32(SHORTER)
		}
		qprefer = v35
		_next(tls, v)
	case int32('{'):
		_next(tls, v)
		m = _scannum(tls, v)
		if (*Tvars)(unsafe.Pointer(v)).Fnexttype == int32(',') && _next(tls, v) != 0 {
			if (*Tvars)(unsafe.Pointer(v)).Fnexttype == int32('d') {
				n = _scannum(tls, v)
			} else {
				n = libc.Int32FromInt32(_POSIX2_RE_DUP_MAX) + libc.Int32FromInt32(1)
			}
			if m > n {
				(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
				if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
					v36 = (*Tvars)(unsafe.Pointer(v)).Ferr
				} else {
					v36 = int32(REG_BADBR)
				}
				(*Tvars)(unsafe.Pointer(v)).Ferr = v36
				return
			}
			/*
			 * {m,n} exercises preference, even if it's {m,m}
			 */
			if (*Tvars)(unsafe.Pointer(v)).Fnextvalue != 0 {
				v37 = int32(LONGER)
			} else {
				v37 = int32(SHORTER)
			}
			qprefer = v37
		} else {
			n = m
			/*
			 * {m} passes operand's preference through.
			 */
			qprefer = 0
		}
		if !((*Tvars)(unsafe.Pointer(v)).Fnexttype == libc.Int32FromUint8('}')) { /* catches errors too */
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
				v38 = (*Tvars)(unsafe.Pointer(v)).Ferr
			} else {
				v38 = int32(REG_BADBR)
			}
			(*Tvars)(unsafe.Pointer(v)).Ferr = v38
			return
		}
		_next(tls, v)
	default: /* no quantifier */
		v39 = libc.Int32FromInt32(1)
		n = v39
		m = v39
		qprefer = 0
		break
	}
	/*
	 * Annoying special case: {0} or {0,0} cancels everything.
	 */
	if m == 0 && n == 0 {
		if atom != libc.UintptrFromInt32(0) {
			_freesubre(tls, v, atom)
		}
		if atomtype == int32('(') {
			*(*uintptr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fsubs + uintptr(subno)*8)) = libc.UintptrFromInt32(0)
		}
		_delsub(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, lp, rp)
		_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('n'), 0, lp, rp)
		return
	}
	/*
	 * If not a messy case, avoid hard part.
	 */
	if atom != libc.UintptrFromInt32(0) {
		v40 = libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(atom)).Fflags)
	} else {
		v40 = 0
	}
	f = libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(top)).Fflags) | qprefer | v40
	if atomtype != int32('(') && atomtype != int32('b') && !((f & ^libc.Int32FromInt32(NOPROP) | f<<libc.Int32FromInt32(2)&(f<<libc.Int32FromInt32(1))&libc.Int32FromInt32(MIXED))&(libc.Int32FromInt32(MIXED)|libc.Int32FromInt32(CAP)|libc.Int32FromInt32(BACKR)) != 0) {
		if !(m == int32(1) && n == int32(1)) {
			_repeat(tls, v, lp, rp, m, n)
		}
		if atom != libc.UintptrFromInt32(0) {
			_freesubre(tls, v, atom)
		}
		(*Tsubre)(unsafe.Pointer(top)).Fflags = libc.Uint8FromInt32(f)
		return
	}
	/*
	 * hard part: something messy
	 * That is, capturing parens, back reference, short/long clash, or an atom
	 * with substructure containing one of those.
	 */
	/*
	 * Now we'll need a subre for the contents even if they're boring.
	 */
	if atom == libc.UintptrFromInt32(0) {
		atom = _sub_re(tls, v, int32('='), 0, lp, rp)
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			return
		}
	}
	/*
	 * Prepare a general-purpose state skeleton.
	 *
	 * In the no-backrefs case, we want this:
	 *
	 * [lp] ---> [s] ---prefix---> [begin] ---atom---> [end] ---rest---> [rp]
	 *
	 * where prefix is some repetitions of atom.  In the general case we need
	 *
	 * [lp] ---> [s] ---iterator---> [s2] ---rest---> [rp]
	 *
	 * where the iterator wraps around [begin] ---atom---> [end]
	 *
	 * We make the s state here for both cases; s2 is made below if needed
	 */
	s = _newstate(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa) /* first, new endpoints for the atom */
	s2 = _newstate(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return
	}
	_moveouts(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, lp, s)
	_moveins(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, rp, s2)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return
	}
	(*Tsubre)(unsafe.Pointer(atom)).Fbegin = s
	(*Tsubre)(unsafe.Pointer(atom)).Fend = s2
	s = _newstate(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa) /* set up starting state */
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return
	}
	_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('n'), 0, lp, s)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return
	}
	/*
	 * Break remaining subRE into x{...} and what follows.
	 */
	if qprefer&int32(NOPROP) != 0 {
		v41 = qprefer & int32(NOPROP)
	} else {
		v41 = libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(atom)).Fflags) & int32(NOPROP)
	}
	t = _sub_re(tls, v, int32('.'), (qprefer|libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(atom)).Fflags)) & ^libc.Int32FromInt32(NOPROP) | (qprefer|libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(atom)).Fflags))<<int32(2)&((qprefer|libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(atom)).Fflags))<<int32(1))&int32(MIXED) | v41, lp, rp)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return
	}
	(*Tsubre)(unsafe.Pointer(t)).Fleft = atom
	atomp = t + 16
	/*
	 * Here we should recurse... but we must postpone that to the end.
	 */
	/*
	 * Split top into prefix and remaining.
	 */
	(*Tsubre)(unsafe.Pointer(top)).Fleft = _sub_re(tls, v, int32('='), libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(top)).Fflags), (*Tsubre)(unsafe.Pointer(top)).Fbegin, lp)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return
	}
	(*Tsubre)(unsafe.Pointer(top)).Fop = uint8('.')
	(*Tsubre)(unsafe.Pointer(top)).Fright = t
	/*
	 * If it's a backref, now is the time to replicate the subNFA.
	 */
	if atomtype == int32('b') {
		/* just the EMPTY */
		_delsub(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, (*Tsubre)(unsafe.Pointer(atom)).Fbegin, (*Tsubre)(unsafe.Pointer(atom)).Fend)
		/*
		 * And here's why the recursion got postponed: it must wait until the
		 * skeleton is filled in, because it may hit a backref that wants to
		 * copy the filled-in skeleton.
		 */
		_dupnfa(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, (*Tsubre)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fsubs + uintptr(subno)*8)))).Fbegin, (*Tsubre)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fsubs + uintptr(subno)*8)))).Fend, (*Tsubre)(unsafe.Pointer(atom)).Fbegin, (*Tsubre)(unsafe.Pointer(atom)).Fend)
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			return
		}
	}
	/*
	 * It's quantifier time.  If the atom is just a backref, we'll let it deal
	 * with quantifiers internally.
	 */
	if atomtype == int32('b') {
		/*
		 * Special case: backrefs have internal quantifiers.
		 */
		_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('n'), 0, s, (*Tsubre)(unsafe.Pointer(atom)).Fbegin) /* empty prefix */
		/*
		 * Just stuff everything into atom.
		 */
		_repeat(tls, v, (*Tsubre)(unsafe.Pointer(atom)).Fbegin, (*Tsubre)(unsafe.Pointer(atom)).Fend, m, n)
		(*Tsubre)(unsafe.Pointer(atom)).Fmin = int16(m)
		(*Tsubre)(unsafe.Pointer(atom)).Fmax = int16(n)
		p42 = atom + 1
		if qprefer&int32(NOPROP) != 0 {
			v43 = qprefer & int32(NOPROP)
		} else {
			v43 = libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(atom)).Fflags) & int32(NOPROP)
		}
		*(*uint8)(unsafe.Pointer(p42)) = uint8(int32(*(*uint8)(unsafe.Pointer(p42))) | ((qprefer|libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(atom)).Fflags)) & ^libc.Int32FromInt32(NOPROP) | (qprefer|libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(atom)).Fflags))<<libc.Int32FromInt32(2)&((qprefer|libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(atom)).Fflags))<<libc.Int32FromInt32(1))&libc.Int32FromInt32(MIXED) | v43))
		/* rest of branch can be strung starting from atom->end */
		s2 = (*Tsubre)(unsafe.Pointer(atom)).Fend
	} else {
		if m == int32(1) && n == int32(1) {
			/*
			 * No/vacuous quantifier: done.
			 */
			_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('n'), 0, s, (*Tsubre)(unsafe.Pointer(atom)).Fbegin) /* empty prefix */
			/* rest of branch can be strung starting from atom->end */
			s2 = (*Tsubre)(unsafe.Pointer(atom)).Fend
		} else {
			if m > 0 && !(libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(atom)).Fflags)&libc.Int32FromInt32(BACKR) != 0) {
				/*
				 * If there's no backrefs involved, we can turn x{m,n} into
				 * x{m-1,n-1}x, with capturing parens in only the second x.  This
				 * is valid because we only care about capturing matches from the
				 * final iteration of the quantifier.  It's a win because we can
				 * implement the backref-free left side as a plain DFA node, since
				 * we don't really care where its submatches are.
				 */
				_dupnfa(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, (*Tsubre)(unsafe.Pointer(atom)).Fbegin, (*Tsubre)(unsafe.Pointer(atom)).Fend, s, (*Tsubre)(unsafe.Pointer(atom)).Fbegin)
				if n == libc.Int32FromInt32(_POSIX2_RE_DUP_MAX)+libc.Int32FromInt32(1) {
					v44 = n
				} else {
					v44 = n - int32(1)
				}
				_repeat(tls, v, s, (*Tsubre)(unsafe.Pointer(atom)).Fbegin, m-int32(1), v44)
				if qprefer&int32(NOPROP) != 0 {
					v45 = qprefer & int32(NOPROP)
				} else {
					v45 = libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(atom)).Fflags) & int32(NOPROP)
				}
				f = (qprefer|libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(atom)).Fflags)) & ^libc.Int32FromInt32(NOPROP) | (qprefer|libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(atom)).Fflags))<<int32(2)&((qprefer|libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(atom)).Fflags))<<int32(1))&int32(MIXED) | v45
				t = _sub_re(tls, v, int32('.'), f, s, (*Tsubre)(unsafe.Pointer(atom)).Fend) /* prefix and atom */
				if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
					return
				}
				(*Tsubre)(unsafe.Pointer(t)).Fleft = _sub_re(tls, v, int32('='), f&int32(NOPROP), s, (*Tsubre)(unsafe.Pointer(atom)).Fbegin)
				if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
					return
				}
				(*Tsubre)(unsafe.Pointer(t)).Fright = atom
				*(*uintptr)(unsafe.Pointer(atomp)) = t
				/* rest of branch can be strung starting from atom->end */
				s2 = (*Tsubre)(unsafe.Pointer(atom)).Fend
			} else {
				/* general case: need an iteration node */
				s2 = _newstate(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa)
				if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
					return
				}
				_moveouts(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, (*Tsubre)(unsafe.Pointer(atom)).Fend, s2)
				if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
					return
				}
				_dupnfa(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, (*Tsubre)(unsafe.Pointer(atom)).Fbegin, (*Tsubre)(unsafe.Pointer(atom)).Fend, s, s2)
				_repeat(tls, v, s, s2, m, n)
				if qprefer&int32(NOPROP) != 0 {
					v46 = qprefer & int32(NOPROP)
				} else {
					v46 = libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(atom)).Fflags) & int32(NOPROP)
				}
				f = (qprefer|libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(atom)).Fflags)) & ^libc.Int32FromInt32(NOPROP) | (qprefer|libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(atom)).Fflags))<<int32(2)&((qprefer|libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(atom)).Fflags))<<int32(1))&int32(MIXED) | v46
				t = _sub_re(tls, v, int32('*'), f, s, s2)
				if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
					return
				}
				(*Tsubre)(unsafe.Pointer(t)).Fmin = int16(m)
				(*Tsubre)(unsafe.Pointer(t)).Fmax = int16(n)
				(*Tsubre)(unsafe.Pointer(t)).Fleft = atom
				*(*uintptr)(unsafe.Pointer(atomp)) = t
				/* rest of branch is to be strung from iteration's end state */
			}
		}
	}
	/*
	 * And finally, look after that postponed recursion.
	 */
	t = (*Tsubre)(unsafe.Pointer(top)).Fright
	if !((*Tvars)(unsafe.Pointer(v)).Fnexttype == int32('|') || (*Tvars)(unsafe.Pointer(v)).Fnexttype == stopper || (*Tvars)(unsafe.Pointer(v)).Fnexttype == int32('e')) {
		(*Tsubre)(unsafe.Pointer(t)).Fright = _parsebranch(tls, v, stopper, type1, s2, rp, int32(1))
	} else {
		_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('n'), 0, s2, rp)
		(*Tsubre)(unsafe.Pointer(t)).Fright = _sub_re(tls, v, int32('='), 0, s2, rp)
	}
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return
	}
	p47 = t + 1
	if libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(t)).Fflags)&int32(NOPROP) != 0 {
		v48 = libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(t)).Fflags) & int32(NOPROP)
	} else {
		v48 = libc.Int32FromUint8((*Tsubre)(unsafe.Pointer((*Tsubre)(unsafe.Pointer(t)).Fright)).Fflags) & int32(NOPROP)
	}
	*(*uint8)(unsafe.Pointer(p47)) = uint8(int32(*(*uint8)(unsafe.Pointer(p47))) | ((libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(t)).Fflags)|libc.Int32FromUint8((*Tsubre)(unsafe.Pointer((*Tsubre)(unsafe.Pointer(t)).Fright)).Fflags)) & ^libc.Int32FromInt32(NOPROP) | (libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(t)).Fflags)|libc.Int32FromUint8((*Tsubre)(unsafe.Pointer((*Tsubre)(unsafe.Pointer(t)).Fright)).Fflags))<<libc.Int32FromInt32(2)&((libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(t)).Fflags)|libc.Int32FromUint8((*Tsubre)(unsafe.Pointer((*Tsubre)(unsafe.Pointer(t)).Fright)).Fflags))<<libc.Int32FromInt32(1))&libc.Int32FromInt32(MIXED) | v48))
	p49 = top + 1
	if libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(top)).Fflags)&int32(NOPROP) != 0 {
		v50 = libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(top)).Fflags) & int32(NOPROP)
	} else {
		v50 = libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(t)).Fflags) & int32(NOPROP)
	}
	*(*uint8)(unsafe.Pointer(p49)) = uint8(int32(*(*uint8)(unsafe.Pointer(p49))) | ((libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(top)).Fflags)|libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(t)).Fflags)) & ^libc.Int32FromInt32(NOPROP) | (libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(top)).Fflags)|libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(t)).Fflags))<<libc.Int32FromInt32(2)&((libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(top)).Fflags)|libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(t)).Fflags))<<libc.Int32FromInt32(1))&libc.Int32FromInt32(MIXED) | v50))
}

// C documentation
//
//	/*
//	 - nonword - generate arcs for non-word-character ahead or behind
//	 ^ static void nonword(struct vars *, int, struct state *, struct state *);
//	 */
func _nonword(tls *libc.TLS, v uintptr, dir int32, lp uintptr, rp uintptr) {
	var anchor, v1 int32
	_, _ = anchor, v1
	if dir == int32('a') {
		v1 = int32('$')
	} else {
		v1 = int32('^')
	}
	anchor = v1
	_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, anchor, int32(1), lp, rp)
	_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, anchor, 0, lp, rp)
	_colorcomplement(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, (*Tvars)(unsafe.Pointer(v)).Fcm, dir, (*Tvars)(unsafe.Pointer(v)).Fwordchrs, lp, rp)
	/* (no need for special attention to \n) */
}

// C documentation
//
//	/*
//	 - word - generate arcs for word character ahead or behind
//	 ^ static void word(struct vars *, int, struct state *, struct state *);
//	 */
func _word(tls *libc.TLS, v uintptr, dir int32, lp uintptr, rp uintptr) {
	_cloneouts(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, (*Tvars)(unsafe.Pointer(v)).Fwordchrs, lp, rp, dir)
	/* (no need for special attention to \n) */
}

// C documentation
//
//	/*
//	 - scannum - scan a number
//	 ^ static int scannum(struct vars *);
//	 */
func _scannum(tls *libc.TLS, v uintptr) (r int32) {
	var n, v1 int32
	_, _ = n, v1
	n = 0
	for (*Tvars)(unsafe.Pointer(v)).Fnexttype == int32('d') && n < int32(_POSIX2_RE_DUP_MAX) {
		n = libc.Int32FromUint64(libc.Uint64FromInt32(n*int32(10)) + (*Tvars)(unsafe.Pointer(v)).Fnextvalue)
		_next(tls, v)
	}
	if (*Tvars)(unsafe.Pointer(v)).Fnexttype == int32('d') || n > int32(_POSIX2_RE_DUP_MAX) {
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			v1 = (*Tvars)(unsafe.Pointer(v)).Ferr
		} else {
			v1 = int32(REG_BADBR)
		}
		(*Tvars)(unsafe.Pointer(v)).Ferr = v1
		return 0
	}
	return n
}

// C documentation
//
//	/*
//	 - repeat - replicate subNFA for quantifiers
//	 * The sub-NFA strung from lp to rp is modified to represent m to n
//	 * repetitions of its initial contents.
//	 * The duplication sequences used here are chosen carefully so that any
//	 * pointers starting out pointing into the subexpression end up pointing into
//	 * the last occurrence. (Note that it may not be strung between the same left
//	 * and right end states, however!) This used to be important for the subRE
//	 * tree, although the important bits are now handled by the in-line code in
//	 * parse(), and when this is called, it doesn't matter any more.
//	 ^ static void repeat(struct vars *, struct state *, struct state *, int, int);
//	 */
func _repeat(tls *libc.TLS, v uintptr, lp uintptr, rp uintptr, m int32, n int32) {
	var rm, rn, v1, v2, v3, v4, v5 int32
	var s, s2 uintptr
	_, _, _, _, _, _, _, _, _ = rm, rn, s, s2, v1, v2, v3, v4, v5
	if m == libc.Int32FromInt32(_POSIX2_RE_DUP_MAX)+libc.Int32FromInt32(1) {
		v1 = int32(INF)
	} else {
		if m > int32(1) {
			v2 = int32(SOME)
		} else {
			v2 = m
		}
		v1 = v2
	}
	rm = v1
	if n == libc.Int32FromInt32(_POSIX2_RE_DUP_MAX)+libc.Int32FromInt32(1) {
		v3 = int32(INF)
	} else {
		if n > int32(1) {
			v4 = int32(SOME)
		} else {
			v4 = n
		}
		v3 = v4
	}
	rn = v3
	switch rm*libc.Int32FromInt32(4) + rn {
	case libc.Int32FromInt32(0)*libc.Int32FromInt32(4) + libc.Int32FromInt32(0): /* empty string */
		_delsub(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, lp, rp)
		_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('n'), 0, lp, rp)
	case libc.Int32FromInt32(0)*libc.Int32FromInt32(4) + libc.Int32FromInt32(1): /* do as x| */
		_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('n'), 0, lp, rp)
	case libc.Int32FromInt32(0)*libc.Int32FromInt32(4) + libc.Int32FromInt32(SOME): /* do as x{1,n}| */
		_repeat(tls, v, lp, rp, int32(1), n)
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			return
		}
		_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('n'), 0, lp, rp)
	case libc.Int32FromInt32(0)*libc.Int32FromInt32(4) + libc.Int32FromInt32(INF): /* loop x around */
		s = _newstate(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa)
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			return
		}
		_moveouts(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, lp, s)
		_moveins(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, rp, s)
		_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('n'), 0, lp, s)
		_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('n'), 0, s, rp)
	case libc.Int32FromInt32(1)*libc.Int32FromInt32(4) + libc.Int32FromInt32(1): /* no action required */
	case libc.Int32FromInt32(1)*libc.Int32FromInt32(4) + libc.Int32FromInt32(SOME): /* do as x{0,n-1}x = (x{1,n-1}|)x */
		s = _newstate(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa)
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			return
		}
		_moveouts(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, lp, s)
		_dupnfa(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, s, rp, lp, s)
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			return
		}
		_repeat(tls, v, lp, s, int32(1), n-int32(1))
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			return
		}
		_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('n'), 0, lp, s)
	case libc.Int32FromInt32(1)*libc.Int32FromInt32(4) + libc.Int32FromInt32(INF): /* add loopback arc */
		s = _newstate(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa)
		s2 = _newstate(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa)
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			return
		}
		_moveouts(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, lp, s)
		_moveins(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, rp, s2)
		_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('n'), 0, lp, s)
		_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('n'), 0, s2, rp)
		_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('n'), 0, s2, s)
	case libc.Int32FromInt32(SOME)*libc.Int32FromInt32(4) + libc.Int32FromInt32(SOME): /* do as x{m-1,n-1}x */
		s = _newstate(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa)
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			return
		}
		_moveouts(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, lp, s)
		_dupnfa(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, s, rp, lp, s)
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			return
		}
		_repeat(tls, v, lp, s, m-int32(1), n-int32(1))
	case libc.Int32FromInt32(SOME)*libc.Int32FromInt32(4) + libc.Int32FromInt32(INF): /* do as x{m-1,}x */
		s = _newstate(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa)
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			return
		}
		_moveouts(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, lp, s)
		_dupnfa(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, s, rp, lp, s)
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			return
		}
		_repeat(tls, v, lp, s, m-int32(1), n)
	default:
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			v5 = (*Tvars)(unsafe.Pointer(v)).Ferr
		} else {
			v5 = int32(REG_ASSERT)
		}
		(*Tvars)(unsafe.Pointer(v)).Ferr = v5
		break
	}
}

// C documentation
//
//	/*
//	 - bracket - handle non-complemented bracket expression
//	 * Also called from cbracket for complemented bracket expressions.
//	 ^ static void bracket(struct vars *, struct state *, struct state *);
//	 */
func _bracket(tls *libc.TLS, v uintptr, lp uintptr, rp uintptr) {
	_next(tls, v)
	for !((*Tvars)(unsafe.Pointer(v)).Fnexttype == libc.Int32FromUint8(']')) && !((*Tvars)(unsafe.Pointer(v)).Fnexttype == libc.Int32FromUint8('e')) {
		_brackpart(tls, v, lp, rp)
	}
	_okcolors(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, (*Tvars)(unsafe.Pointer(v)).Fcm)
}

// C documentation
//
//	/*
//	 - cbracket - handle complemented bracket expression
//	 * We do it by calling bracket() with dummy endpoints, and then complementing
//	 * the result. The alternative would be to invoke rainbow(), and then delete
//	 * arcs as the b.e. is seen... but that gets messy.
//	 ^ static void cbracket(struct vars *, struct state *, struct state *);
//	 */
func _cbracket(tls *libc.TLS, v uintptr, lp uintptr, rp uintptr) {
	var left, right uintptr
	_, _ = left, right
	left = _newstate(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa)
	right = _newstate(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return
	}
	_bracket(tls, v, left, right)
	if (*Tvars)(unsafe.Pointer(v)).Fcflags&int32(REG_NLSTOP) != 0 {
		_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('p'), int32((*Tvars)(unsafe.Pointer(v)).Fnlcolor), left, right)
	}
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return
	}
	/* all outarcs will be ours */
	/*
	 * Easy part of complementing, and all there is to do since the MCCE code
	 * was removed.
	 */
	_colorcomplement(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, (*Tvars)(unsafe.Pointer(v)).Fcm, int32('p'), left, lp, rp)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return
	}
	_dropstate(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, left)
	_freestate(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, right)
	return
}

// C documentation
//
//	/*
//	 - brackpart - handle one item (or range) within a bracket expression
//	 ^ static void brackpart(struct vars *, struct state *, struct state *);
//	 */
func _brackpart(tls *libc.TLS, v uintptr, lp uintptr, rp uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var cv, endp, startp uintptr
	var endc, startc Tcelt
	var v1, v2, v3, v4, v5, v6, v7 int32
	var _ /* c at bp+0 */ Tchr
	_, _, _, _, _, _, _, _, _, _, _, _ = cv, endc, endp, startc, startp, v1, v2, v3, v4, v5, v6, v7
	/*
	 * Parse something, get rid of special cases, take shortcuts.
	 */
	switch (*Tvars)(unsafe.Pointer(v)).Fnexttype {
	case int32('R'): /* a-b-c or other botch */
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			v1 = (*Tvars)(unsafe.Pointer(v)).Ferr
		} else {
			v1 = int32(REG_ERANGE)
		}
		(*Tvars)(unsafe.Pointer(v)).Ferr = v1
		return
	case int32('p'):
		*(*Tchr)(unsafe.Pointer(bp)) = libc.Int32FromUint64((*Tvars)(unsafe.Pointer(v)).Fnextvalue)
		_next(tls, v)
		/*
		 * Shortcut for ordinary chr (not range).
		 */
		if !((*Tvars)(unsafe.Pointer(v)).Fnexttype == libc.Int32FromUint8('R')) {
			_onechr(tls, v, *(*Tchr)(unsafe.Pointer(bp)), lp, rp)
			return
		}
		startc = _element(tls, v, bp, bp+uintptr(1)*4)
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			return
		}
	case int32('I'):
		startp = (*Tvars)(unsafe.Pointer(v)).Fnow
		endp = _scanplain(tls, v)
		if !(startp < endp) {
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
				v2 = (*Tvars)(unsafe.Pointer(v)).Ferr
			} else {
				v2 = int32(REG_ECOLLATE)
			}
			(*Tvars)(unsafe.Pointer(v)).Ferr = v2
		}
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			return
		}
		startc = _element(tls, v, startp, endp)
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			return
		}
	case int32('E'):
		startp = (*Tvars)(unsafe.Pointer(v)).Fnow
		endp = _scanplain(tls, v)
		if !(startp < endp) {
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
				v3 = (*Tvars)(unsafe.Pointer(v)).Ferr
			} else {
				v3 = int32(REG_ECOLLATE)
			}
			(*Tvars)(unsafe.Pointer(v)).Ferr = v3
		}
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			return
		}
		startc = _element(tls, v, startp, endp)
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			return
		}
		cv = _eclass(tls, v, startc, (*Tvars)(unsafe.Pointer(v)).Fcflags&int32(REG_ICASE))
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			return
		}
		_dovec(tls, v, cv, lp, rp)
		return
	case int32('C'):
		startp = (*Tvars)(unsafe.Pointer(v)).Fnow
		endp = _scanplain(tls, v)
		if !(startp < endp) {
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
				v4 = (*Tvars)(unsafe.Pointer(v)).Ferr
			} else {
				v4 = int32(REG_ECTYPE)
			}
			(*Tvars)(unsafe.Pointer(v)).Ferr = v4
		}
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			return
		}
		cv = _cclass(tls, v, startp, endp, (*Tvars)(unsafe.Pointer(v)).Fcflags&int32(REG_ICASE))
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			return
		}
		_dovec(tls, v, cv, lp, rp)
		return
	default:
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			v5 = (*Tvars)(unsafe.Pointer(v)).Ferr
		} else {
			v5 = int32(REG_ASSERT)
		}
		(*Tvars)(unsafe.Pointer(v)).Ferr = v5
		return
		break
	}
	if (*Tvars)(unsafe.Pointer(v)).Fnexttype == int32('R') {
		_next(tls, v)
		switch (*Tvars)(unsafe.Pointer(v)).Fnexttype {
		case int32('p'):
			fallthrough
		case int32('R'):
			*(*Tchr)(unsafe.Pointer(bp)) = libc.Int32FromUint64((*Tvars)(unsafe.Pointer(v)).Fnextvalue)
			_next(tls, v)
			endc = _element(tls, v, bp, bp+uintptr(1)*4)
			if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
				return
			}
		case int32('I'):
			startp = (*Tvars)(unsafe.Pointer(v)).Fnow
			endp = _scanplain(tls, v)
			if !(startp < endp) {
				(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
				if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
					v6 = (*Tvars)(unsafe.Pointer(v)).Ferr
				} else {
					v6 = int32(REG_ECOLLATE)
				}
				(*Tvars)(unsafe.Pointer(v)).Ferr = v6
			}
			if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
				return
			}
			endc = _element(tls, v, startp, endp)
			if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
				return
			}
		default:
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
				v7 = (*Tvars)(unsafe.Pointer(v)).Ferr
			} else {
				v7 = int32(REG_ERANGE)
			}
			(*Tvars)(unsafe.Pointer(v)).Ferr = v7
			return
			break
		}
	} else {
		endc = startc
	}
	/*
	 * Ranges are unportable. Actually, standard C does guarantee that digits
	 * are contiguous, but making that an exception is just too complicated.
	 */
	if startc != endc {
		*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UUNPORT))
	}
	cv = _range(tls, v, startc, endc, (*Tvars)(unsafe.Pointer(v)).Fcflags&int32(REG_ICASE))
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return
	}
	_dovec(tls, v, cv, lp, rp)
}

// C documentation
//
//	/*
//	 - scanplain - scan PLAIN contents of [. etc.
//	 * Certain bits of trickery in lex.c know that this code does not try to look
//	 * past the final bracket of the [. etc.
//	 ^ static const chr *scanplain(struct vars *);
//	 */
func _scanplain(tls *libc.TLS, v uintptr) (r uintptr) {
	var endp uintptr
	_ = endp
	_next(tls, v)
	endp = (*Tvars)(unsafe.Pointer(v)).Fnow
	for (*Tvars)(unsafe.Pointer(v)).Fnexttype == int32('p') {
		endp = (*Tvars)(unsafe.Pointer(v)).Fnow
		_next(tls, v)
	}
	_next(tls, v)
	return endp
}

// C documentation
//
//	/*
//	 - onechr - fill in arcs for a plain character, and possible case complements
//	 * This is mostly a shortcut for efficient handling of the common case.
//	 ^ static void onechr(struct vars *, pchr, struct state *, struct state *);
//	 */
func _onechr(tls *libc.TLS, v uintptr, c Tpchr, lp uintptr, rp uintptr) {
	if !((*Tvars)(unsafe.Pointer(v)).Fcflags&libc.Int32FromInt32(REG_ICASE) != 0) {
		_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('p'), int32(_subcolor(tls, (*Tvars)(unsafe.Pointer(v)).Fcm, c)), lp, rp)
		return
	}
	/*
	 * Rats, need general case anyway...
	 */
	_dovec(tls, v, _allcases(tls, v, c), lp, rp)
}

// C documentation
//
//	/*
//	 - dovec - fill in arcs for each element of a cvec
//	 ^ static void dovec(struct vars *, struct cvec *, struct state *,
//	 ^	struct state *);
//	 */
func _dovec(tls *libc.TLS, v uintptr, cv uintptr, lp uintptr, rp uintptr) {
	var ch, from, to Tchr
	var i int32
	var p uintptr
	_, _, _, _, _ = ch, from, i, p, to
	p = (*Tcvec)(unsafe.Pointer(cv)).Fchrs
	i = libc.Int32FromUint64((*Tcvec)(unsafe.Pointer(cv)).Fnchrs)
	for {
		if !(i > 0) {
			break
		}
		ch = *(*Tchr)(unsafe.Pointer(p))
		_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('p'), int32(_subcolor(tls, (*Tvars)(unsafe.Pointer(v)).Fcm, ch)), lp, rp)
		goto _1
	_1:
		;
		p += 4
		i--
	}
	p = (*Tcvec)(unsafe.Pointer(cv)).Franges
	i = libc.Int32FromUint64((*Tcvec)(unsafe.Pointer(cv)).Fnranges)
	for {
		if !(i > 0) {
			break
		}
		from = *(*Tchr)(unsafe.Pointer(p))
		to = *(*Tchr)(unsafe.Pointer(p + libc.UintptrFromInt32(1)*4))
		if from <= to {
			_subrange(tls, v, from, to, lp, rp)
		}
		goto _2
	_2:
		;
		p += uintptr(2) * 4
		i--
	}
}

// C documentation
//
//	/*
//	 - wordchrs - set up word-chr list for word-boundary stuff, if needed
//	 * The list is kept as a bunch of arcs between two dummy states; it's disposed
//	 * of by the unreachable-states sweep in NFA optimization. Does NEXT(). Must
//	 * not be called from any unusual lexical context. This should be reconciled
//	 * with the \w etc. handling in lex.c, and should be cleaned up to reduce
//	 * dependencies on input scanning.
//	 ^ static void wordchrs(struct vars *);
//	 */
func _wordchrs(tls *libc.TLS, v uintptr) {
	var left, right uintptr
	_, _ = left, right
	if (*Tvars)(unsafe.Pointer(v)).Fwordchrs != libc.UintptrFromInt32(0) {
		_next(tls, v) /* for consistency */
		return
	}
	left = _newstate(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa)
	right = _newstate(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return
	}
	/*
	 * Fine point: implemented with [::], and lexer will set REG_ULOCALE.
	 */
	_lexword(tls, v)
	_next(tls, v)
	_bracket(tls, v, left, right)
	_next(tls, v)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return
	}
	(*Tvars)(unsafe.Pointer(v)).Fwordchrs = left
}

// C documentation
//
//	/*
//	 - sub_re - allocate a subre
//	 ^ static struct subre *sub_re(struct vars *, int, int, struct state *,
//	 ^	struct state *);
//	 */
func _sub_re(tls *libc.TLS, v uintptr, op int32, flags int32, begin uintptr, end uintptr) (r uintptr) {
	var ret uintptr
	var v1 int32
	var v2 int16
	_, _, _ = ret, v1, v2
	ret = (*Tvars)(unsafe.Pointer(v)).Ftreefree
	if ret != libc.UintptrFromInt32(0) {
		(*Tvars)(unsafe.Pointer(v)).Ftreefree = (*Tsubre)(unsafe.Pointer(ret)).Fleft
	} else {
		ret = XTclpAlloc(tls, uint64(120))
		if ret == libc.UintptrFromInt32(0) {
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
				v1 = (*Tvars)(unsafe.Pointer(v)).Ferr
			} else {
				v1 = int32(REG_ESPACE)
			}
			(*Tvars)(unsafe.Pointer(v)).Ferr = v1
			return libc.UintptrFromInt32(0)
		}
		(*Tsubre)(unsafe.Pointer(ret)).Fchain = (*Tvars)(unsafe.Pointer(v)).Ftreechain
		(*Tvars)(unsafe.Pointer(v)).Ftreechain = ret
	}
	(*Tsubre)(unsafe.Pointer(ret)).Fop = libc.Uint8FromInt32(op)
	(*Tsubre)(unsafe.Pointer(ret)).Fflags = libc.Uint8FromInt32(flags)
	(*Tsubre)(unsafe.Pointer(ret)).Fid = 0 /* will be assigned later */
	(*Tsubre)(unsafe.Pointer(ret)).Fsubno = 0
	v2 = libc.Int16FromInt32(1)
	(*Tsubre)(unsafe.Pointer(ret)).Fmax = v2
	(*Tsubre)(unsafe.Pointer(ret)).Fmin = v2
	(*Tsubre)(unsafe.Pointer(ret)).Fleft = libc.UintptrFromInt32(0)
	(*Tsubre)(unsafe.Pointer(ret)).Fright = libc.UintptrFromInt32(0)
	(*Tsubre)(unsafe.Pointer(ret)).Fbegin = begin
	(*Tsubre)(unsafe.Pointer(ret)).Fend = end
	(*Tsubre)(unsafe.Pointer(ret)).Fcnfa.Fnstates = uint64(0)
	return ret
}

// C documentation
//
//	/*
//	 - freesubre - free a subRE subtree
//	 ^ static void freesubre(struct vars *, struct subre *);
//	 */
func _freesubre(tls *libc.TLS, v uintptr, sr uintptr) {
	if sr == libc.UintptrFromInt32(0) {
		return
	}
	if (*Tsubre)(unsafe.Pointer(sr)).Fleft != libc.UintptrFromInt32(0) {
		_freesubre(tls, v, (*Tsubre)(unsafe.Pointer(sr)).Fleft)
	}
	if (*Tsubre)(unsafe.Pointer(sr)).Fright != libc.UintptrFromInt32(0) {
		_freesubre(tls, v, (*Tsubre)(unsafe.Pointer(sr)).Fright)
	}
	_freesrnode(tls, v, sr)
}

// C documentation
//
//	/*
//	 - freesrnode - free one node in a subRE subtree
//	 ^ static void freesrnode(struct vars *, struct subre *);
//	 */
func _freesrnode(tls *libc.TLS, v uintptr, sr uintptr) {
	if sr == libc.UintptrFromInt32(0) {
		return
	}
	if !((*Tsubre)(unsafe.Pointer(sr)).Fcnfa.Fnstates == libc.Uint64FromInt32(0)) {
		_freecnfa(tls, sr+48)
	}
	(*Tsubre)(unsafe.Pointer(sr)).Fflags = uint8(0)
	if v != libc.UintptrFromInt32(0) && (*Tvars)(unsafe.Pointer(v)).Ftreechain != libc.UintptrFromInt32(0) {
		/* we're still parsing, maybe we can reuse the subre */
		(*Tsubre)(unsafe.Pointer(sr)).Fleft = (*Tvars)(unsafe.Pointer(v)).Ftreefree
		(*Tvars)(unsafe.Pointer(v)).Ftreefree = sr
	} else {
		XTclpFree(tls, sr)
	}
}

// C documentation
//
//	/*
//	 - numst - number tree nodes (assigning "id" indexes)
//	 ^ static int numst(struct subre *, int);
//	 */
func _numst(tls *libc.TLS, t uintptr, start int32) (r int32) {
	/* starting point for subtree numbers */
	var i, v1 int32
	_, _ = i, v1
	i = start
	v1 = i
	i++
	(*Tsubre)(unsafe.Pointer(t)).Fid = int16(v1)
	if (*Tsubre)(unsafe.Pointer(t)).Fleft != libc.UintptrFromInt32(0) {
		i = _numst(tls, (*Tsubre)(unsafe.Pointer(t)).Fleft, i)
	}
	if (*Tsubre)(unsafe.Pointer(t)).Fright != libc.UintptrFromInt32(0) {
		i = _numst(tls, (*Tsubre)(unsafe.Pointer(t)).Fright, i)
	}
	return i
}

// C documentation
//
//	/*
//	 - markst - mark tree nodes as INUSE
//	 * Note: this is a great deal more subtle than it looks.  During initial
//	 * parsing of a regex, all subres are linked into the treechain list;
//	 * discarded ones are also linked into the treefree list for possible reuse.
//	 * After we are done creating all subres required for a regex, we run markst()
//	 * then cleanst(), which results in discarding all subres not reachable from
//	 * v->tree.  We then clear v->treechain, indicating that subres must be found
//	 * by descending from v->tree.  This changes the behavior of freesubre(): it
//	 * will henceforth FREE() unwanted subres rather than sticking them into the
//	 * treefree list.  (Doing that any earlier would result in dangling links in
//	 * the treechain list.)  This all means that freev() will clean up correctly
//	 * if invoked before or after markst()+cleanst(); but it would not work if
//	 * called partway through this state conversion, so we mustn't error out
//	 * in or between these two functions.
//	 ^ static void markst(struct subre *);
//	 */
func _markst(tls *libc.TLS, t uintptr) {
	var p1 uintptr
	_ = p1
	p1 = t + 1
	*(*uint8)(unsafe.Pointer(p1)) = uint8(int32(*(*uint8)(unsafe.Pointer(p1))) | libc.Int32FromInt32(INUSE))
	if (*Tsubre)(unsafe.Pointer(t)).Fleft != libc.UintptrFromInt32(0) {
		_markst(tls, (*Tsubre)(unsafe.Pointer(t)).Fleft)
	}
	if (*Tsubre)(unsafe.Pointer(t)).Fright != libc.UintptrFromInt32(0) {
		_markst(tls, (*Tsubre)(unsafe.Pointer(t)).Fright)
	}
}

// C documentation
//
//	/*
//	 - cleanst - free any tree nodes not marked INUSE
//	 ^ static void cleanst(struct vars *);
//	 */
func _cleanst(tls *libc.TLS, v uintptr) {
	var next, t uintptr
	_, _ = next, t
	t = (*Tvars)(unsafe.Pointer(v)).Ftreechain
	for {
		if !(t != libc.UintptrFromInt32(0)) {
			break
		}
		next = (*Tsubre)(unsafe.Pointer(t)).Fchain
		if !(libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(t)).Fflags)&libc.Int32FromInt32(INUSE) != 0) {
			XTclpFree(tls, t)
		}
		goto _1
	_1:
		;
		t = next
	}
	(*Tvars)(unsafe.Pointer(v)).Ftreechain = libc.UintptrFromInt32(0)
	(*Tvars)(unsafe.Pointer(v)).Ftreefree = libc.UintptrFromInt32(0) /* just on general principles */
}

// C documentation
//
//	/*
//	 - nfatree - turn a subRE subtree into a tree of compacted NFAs
//	 ^ static long nfatree(struct vars *, struct subre *, FILE *);
//	 */
func _nfatree(tls *libc.TLS, v uintptr, t uintptr, f uintptr) (r int64) {
	/* for debug output */
	if (*Tsubre)(unsafe.Pointer(t)).Fleft != libc.UintptrFromInt32(0) {
		_nfatree(tls, v, (*Tsubre)(unsafe.Pointer(t)).Fleft, f)
	}
	if (*Tsubre)(unsafe.Pointer(t)).Fright != libc.UintptrFromInt32(0) {
		_nfatree(tls, v, (*Tsubre)(unsafe.Pointer(t)).Fright, f)
	}
	return _nfanode(tls, v, t, f)
}

// C documentation
//
//	/*
//	 - nfanode - do one NFA for nfatree
//	 ^ static long nfanode(struct vars *, struct subre *, FILE *);
//	 */
func _nfanode(tls *libc.TLS, v uintptr, t uintptr, f uintptr) (r int64) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* for debug output */
	var nfa uintptr
	var ret int64
	var _ /* idbuf at bp+0 */ [50]uint8
	_, _ = nfa, ret
	ret = 0
	if f != libc.UintptrFromInt32(0) {
		libc.Xfprintf(tls, f, __ccgo_ts+128, libc.VaList(bp+64, _stid(tls, t, bp, uint64(50))))
	}
	nfa = _newnfa(tls, v, (*Tvars)(unsafe.Pointer(v)).Fcm, (*Tvars)(unsafe.Pointer(v)).Fnfa)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return 0
	}
	_dupnfa(tls, nfa, (*Tsubre)(unsafe.Pointer(t)).Fbegin, (*Tsubre)(unsafe.Pointer(t)).Fend, (*Tnfa)(unsafe.Pointer(nfa)).Finit1, (*Tnfa)(unsafe.Pointer(nfa)).Ffinal)
	if !((*Tvars)(unsafe.Pointer(v)).Ferr != libc.Int32FromInt32(0)) {
		_specialcolors(tls, nfa)
		ret = _optimize(tls, nfa, f)
	}
	if !((*Tvars)(unsafe.Pointer(v)).Ferr != libc.Int32FromInt32(0)) {
		_compact(tls, nfa, t+48)
	}
	_freenfa(tls, nfa)
	return ret
}

// C documentation
//
//	/*
//	 - newlacon - allocate a lookahead-constraint subRE
//	 ^ static int newlacon(struct vars *, struct state *, struct state *, int);
//	 */
func _newlacon(tls *libc.TLS, v uintptr, begin uintptr, end uintptr, pos int32) (r int32) {
	var n, v1 int32
	var newlacons, sub uintptr
	_, _, _, _ = n, newlacons, sub, v1
	if (*Tvars)(unsafe.Pointer(v)).Fnlacons == uint64(0) {
		n = int32(1) /* skip 0th */
		newlacons = XTclpAlloc(tls, libc.Uint64FromInt32(2)*libc.Uint64FromInt64(120))
	} else {
		n = libc.Int32FromUint64((*Tvars)(unsafe.Pointer(v)).Fnlacons)
		newlacons = XTclpRealloc(tls, (*Tvars)(unsafe.Pointer(v)).Flacons, libc.Uint64FromInt32(n+libc.Int32FromInt32(1))*uint64(120))
	}
	if newlacons == libc.UintptrFromInt32(0) {
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			v1 = (*Tvars)(unsafe.Pointer(v)).Ferr
		} else {
			v1 = int32(REG_ESPACE)
		}
		(*Tvars)(unsafe.Pointer(v)).Ferr = v1
		return 0
	}
	(*Tvars)(unsafe.Pointer(v)).Flacons = newlacons
	(*Tvars)(unsafe.Pointer(v)).Fnlacons = libc.Uint64FromInt32(n + int32(1))
	sub = (*Tvars)(unsafe.Pointer(v)).Flacons + uintptr(n)*120
	(*Tsubre)(unsafe.Pointer(sub)).Fbegin = begin
	(*Tsubre)(unsafe.Pointer(sub)).Fend = end
	(*Tsubre)(unsafe.Pointer(sub)).Fsubno = pos
	(*Tsubre)(unsafe.Pointer(sub)).Fcnfa.Fnstates = uint64(0)
	return n
}

// C documentation
//
//	/*
//	 - freelacons - free lookahead-constraint subRE vector
//	 ^ static void freelacons(struct subre *, int);
//	 */
func _freelacons(tls *libc.TLS, subs uintptr, n int32) {
	var i int32
	var sub uintptr
	_, _ = i, sub
	sub = subs + uintptr(1)*120
	i = n - libc.Int32FromInt32(1)
	for {
		if !(i > 0) {
			break
		} /* no 0th */
		if !((*Tsubre)(unsafe.Pointer(sub)).Fcnfa.Fnstates == libc.Uint64FromInt32(0)) {
			_freecnfa(tls, sub+48)
		}
		goto _1
	_1:
		;
		sub += 120
		i--
	}
	XTclpFree(tls, subs)
}

// C documentation
//
//	/*
//	 - rfree - free a whole RE (insides of regfree)
//	 ^ static void rfree(regex_t *);
//	 */
func _rfree(tls *libc.TLS, re uintptr) {
	var g uintptr
	_ = g
	if re == libc.UintptrFromInt32(0) || (*Tregex_t)(unsafe.Pointer(re)).Fre_magic != int32(REMAGIC) {
		return
	}
	(*Tregex_t)(unsafe.Pointer(re)).Fre_magic = 0 /* invalidate RE */
	g = (*Tregex_t)(unsafe.Pointer(re)).Fre_guts
	(*Tregex_t)(unsafe.Pointer(re)).Fre_guts = libc.UintptrFromInt32(0)
	(*Tregex_t)(unsafe.Pointer(re)).Fre_fns = libc.UintptrFromInt32(0)
	if g != libc.UintptrFromInt32(0) {
		(*Tguts)(unsafe.Pointer(g)).Fmagic = 0
		_freecm(tls, g+104)
		if (*Tguts)(unsafe.Pointer(g)).Ftree != libc.UintptrFromInt32(0) {
			_freesubre(tls, libc.UintptrFromInt32(0), (*Tguts)(unsafe.Pointer(g)).Ftree)
		}
		if (*Tguts)(unsafe.Pointer(g)).Flacons != libc.UintptrFromInt32(0) {
			_freelacons(tls, (*Tguts)(unsafe.Pointer(g)).Flacons, libc.Int32FromUint64((*Tguts)(unsafe.Pointer(g)).Fnlacons))
		}
		if !((*Tguts)(unsafe.Pointer(g)).Fsearch.Fnstates == libc.Uint64FromInt32(0)) {
			_freecnfa(tls, g+32)
		}
		XTclpFree(tls, g)
	}
}

// C documentation
//
//	/*
//	 - dump - dump an RE in human-readable form
//	 ^ static void dump(regex_t *, FILE *);
//	 */
func _dump(tls *libc.TLS, re uintptr, f uintptr) {
	_ = re
	_ = f
}

// C documentation
//
//	/*
//	 - dumpst - dump a subRE tree
//	 ^ static void dumpst(struct subre *, FILE *, int);
//	 */
func _dumpst(tls *libc.TLS, t uintptr, f uintptr, nfapresent int32) {
	/* is the original NFA still around? */
	if t == libc.UintptrFromInt32(0) {
		libc.Xfprintf(tls, f, __ccgo_ts+166, 0)
	} else {
		_stdump(tls, t, f, nfapresent)
	}
	libc.Xfflush(tls, f)
}

// C documentation
//
//	/*
//	 - stdump - recursive guts of dumpst
//	 ^ static void stdump(struct subre *, FILE *, int);
//	 */
func _stdump(tls *libc.TLS, t uintptr, f uintptr, nfapresent int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* is the original NFA still around? */
	var _ /* idbuf at bp+0 */ [50]uint8
	libc.Xfprintf(tls, f, __ccgo_ts+177, libc.VaList(bp+64, _stid(tls, t, bp, uint64(50)), libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(t)).Fop)))
	if libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(t)).Fflags)&int32(LONGER) != 0 {
		libc.Xfprintf(tls, f, __ccgo_ts+186, 0)
	}
	if libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(t)).Fflags)&int32(SHORTER) != 0 {
		libc.Xfprintf(tls, f, __ccgo_ts+195, 0)
	}
	if libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(t)).Fflags)&int32(MIXED) != 0 {
		libc.Xfprintf(tls, f, __ccgo_ts+205, 0)
	}
	if libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(t)).Fflags)&int32(CAP) != 0 {
		libc.Xfprintf(tls, f, __ccgo_ts+215, 0)
	}
	if libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(t)).Fflags)&int32(BACKR) != 0 {
		libc.Xfprintf(tls, f, __ccgo_ts+227, 0)
	}
	if !(libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(t)).Fflags)&libc.Int32FromInt32(INUSE) != 0) {
		libc.Xfprintf(tls, f, __ccgo_ts+239, 0)
	}
	if (*Tsubre)(unsafe.Pointer(t)).Fsubno != 0 {
		libc.Xfprintf(tls, f, __ccgo_ts+247, libc.VaList(bp+64, (*Tsubre)(unsafe.Pointer(t)).Fsubno))
	}
	if int32((*Tsubre)(unsafe.Pointer(t)).Fmin) != int32(1) || int32((*Tsubre)(unsafe.Pointer(t)).Fmax) != int32(1) {
		libc.Xfprintf(tls, f, __ccgo_ts+254, libc.VaList(bp+64, int32((*Tsubre)(unsafe.Pointer(t)).Fmin)))
		if int32((*Tsubre)(unsafe.Pointer(t)).Fmax) != libc.Int32FromInt32(_POSIX2_RE_DUP_MAX)+libc.Int32FromInt32(1) {
			libc.Xfprintf(tls, f, __ccgo_ts+260, libc.VaList(bp+64, int32((*Tsubre)(unsafe.Pointer(t)).Fmax)))
		}
		libc.Xfprintf(tls, f, __ccgo_ts+263, 0)
	}
	if nfapresent != 0 {
		libc.Xfprintf(tls, f, __ccgo_ts+265, libc.VaList(bp+64, (*Tstate)(unsafe.Pointer((*Tsubre)(unsafe.Pointer(t)).Fbegin)).Fno, (*Tstate)(unsafe.Pointer((*Tsubre)(unsafe.Pointer(t)).Fend)).Fno))
	}
	if (*Tsubre)(unsafe.Pointer(t)).Fleft != libc.UintptrFromInt32(0) {
		libc.Xfprintf(tls, f, __ccgo_ts+274, libc.VaList(bp+64, _stid(tls, (*Tsubre)(unsafe.Pointer(t)).Fleft, bp, uint64(50))))
	}
	if (*Tsubre)(unsafe.Pointer(t)).Fright != libc.UintptrFromInt32(0) {
		libc.Xfprintf(tls, f, __ccgo_ts+280, libc.VaList(bp+64, _stid(tls, (*Tsubre)(unsafe.Pointer(t)).Fright, bp, uint64(50))))
	}
	if !((*Tsubre)(unsafe.Pointer(t)).Fcnfa.Fnstates == libc.Uint64FromInt32(0)) {
		libc.Xfprintf(tls, f, __ccgo_ts+286, 0)
		_dumpcnfa(tls, t+48, f)
	}
	libc.Xfprintf(tls, f, __ccgo_ts+286, 0)
	if (*Tsubre)(unsafe.Pointer(t)).Fleft != libc.UintptrFromInt32(0) {
		_stdump(tls, (*Tsubre)(unsafe.Pointer(t)).Fleft, f, nfapresent)
	}
	if (*Tsubre)(unsafe.Pointer(t)).Fright != libc.UintptrFromInt32(0) {
		_stdump(tls, (*Tsubre)(unsafe.Pointer(t)).Fright, f, nfapresent)
	}
}

// C documentation
//
//	/*
//	 - stid - identify a subtree node for dumping
//	 ^ static const char *stid(struct subre *, char *, size_t);
//	 */
func _stid(tls *libc.TLS, t uintptr, buf uintptr, bufsize Tsize_t) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	/*
	 * Big enough for hex int or decimal t->id?
	 */
	if bufsize < libc.Uint64FromInt64(8)*libc.Uint64FromInt32(2)+libc.Uint64FromInt32(3) || bufsize < libc.Uint64FromInt64(2)*libc.Uint64FromInt32(3)+libc.Uint64FromInt32(1) {
		return __ccgo_ts + 288
	}
	if int32((*Tsubre)(unsafe.Pointer(t)).Fid) != 0 {
		libc.X__builtin_snprintf(tls, buf, bufsize, __ccgo_ts+260, libc.VaList(bp+8, int32((*Tsubre)(unsafe.Pointer(t)).Fid)))
	} else {
		libc.X__builtin_snprintf(tls, buf, bufsize, __ccgo_ts+295, libc.VaList(bp+8, t))
	}
	return buf
}

/*
 * lexical analyzer
 * This file is #included by regcomp.c.
 *
 * Copyright © 1998, 1999 Henry Spencer.  All rights reserved.
 *
 * Development of this software was funded, in part, by Cray Research Inc.,
 * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
 * Corporation, none of whom are responsible for the results.  The author
 * thanks all of them.
 *
 * Redistribution and use in source and binary forms -- with or without
 * modification -- are permitted for any purpose, provided that
 * redistributions in source form retain this entire copyright notice and
 * indicate the origin and nature of any modifications.
 *
 * I'd appreciate being given credit for this package in the documentation of
 * software which uses it, but that is not a requirement.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
 * HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/* scanning macros (know about v) */

/* lexical contexts */

/* construct pointer past end of chr array */

// C documentation
//
//	/*
//	 - lexstart - set up lexical stuff, scan leading options
//	 ^ static void lexstart(struct vars *);
//	 */
func _lexstart(tls *libc.TLS, v uintptr) {
	_prefixes(tls, v) /* may turn on new type bits etc. */
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return
	}
	if (*Tvars)(unsafe.Pointer(v)).Fcflags&int32(REG_QUOTE) != 0 {
		(*Tvars)(unsafe.Pointer(v)).Flexcon = int32(L_Q)
	} else {
		if (*Tvars)(unsafe.Pointer(v)).Fcflags&int32(REG_EXTENDED) != 0 {
			(*Tvars)(unsafe.Pointer(v)).Flexcon = int32(L_ERE)
		} else {
			(*Tvars)(unsafe.Pointer(v)).Flexcon = int32(L_BRE)
		}
	}
	(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('n') /* remember we were at the start */
	_next(tls, v)                                      /* set up the first token */
}

// C documentation
//
//	/*
//	 - prefixes - implement various special prefixes
//	 ^ static void prefixes(struct vars *);
//	 */
func _prefixes(tls *libc.TLS, v uintptr) {
	var v1, v2, v4, v5 int32
	_, _, _, _ = v1, v2, v4, v5
	/*
	 * Literal string doesn't get any of this stuff.
	 */
	if (*Tvars)(unsafe.Pointer(v)).Fcflags&int32(REG_QUOTE) != 0 {
		return
	}
	/*
	 * Initial "***" gets special things.
	 */
	if (int64((*Tvars)(unsafe.Pointer(v)).Fstop)-int64((*Tvars)(unsafe.Pointer(v)).Fnow))/4 >= int64(libc.Int32FromInt32(4)) && ((int64((*Tvars)(unsafe.Pointer(v)).Fstop)-int64((*Tvars)(unsafe.Pointer(v)).Fnow))/4 >= int64(libc.Int32FromInt32(3)) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('*'))) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow + libc.UintptrFromInt32(1)*4)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('*'))) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow + libc.UintptrFromInt32(2)*4)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('*')))) {
		switch *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow + libc.UintptrFromInt32(3)*4)) {
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('?'))): /* "***?" error, msg shows version */
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
				v1 = (*Tvars)(unsafe.Pointer(v)).Ferr
			} else {
				v1 = int32(REG_BADPAT)
			}
			(*Tvars)(unsafe.Pointer(v)).Ferr = v1
			return /* proceed no further */
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('='))): /* "***=" shifts to literal string */
			*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UNONPOSIX))
			*(*int32)(unsafe.Pointer(v + 44)) |= int32(REG_QUOTE)
			*(*int32)(unsafe.Pointer(v + 44)) &= ^(libc.Int32FromInt32(REG_ADVANCED) | libc.Int32FromInt32(REG_EXPANDED) | libc.Int32FromInt32(REG_NEWLINE))
			*(*uintptr)(unsafe.Pointer(v + 8)) += uintptr(4) * 4
			return /* and there can be no more prefixes */
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(':'))): /* "***:" shifts to AREs */
			*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UNONPOSIX))
			*(*int32)(unsafe.Pointer(v + 44)) |= int32(REG_ADVANCED)
			*(*uintptr)(unsafe.Pointer(v + 8)) += uintptr(4) * 4
		default: /* otherwise *** is just an error */
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
				v2 = (*Tvars)(unsafe.Pointer(v)).Ferr
			} else {
				v2 = int32(REG_BADRPT)
			}
			(*Tvars)(unsafe.Pointer(v)).Ferr = v2
			return
			break
		}
	}
	/*
	 * BREs and EREs don't get embedded options.
	 */
	if (*Tvars)(unsafe.Pointer(v)).Fcflags&int32(REG_ADVANCED) != int32(REG_ADVANCED) {
		return
	}
	/*
	 * Embedded options (AREs only).
	 */
	if (int64((*Tvars)(unsafe.Pointer(v)).Fstop)-int64((*Tvars)(unsafe.Pointer(v)).Fnow))/4 >= int64(libc.Int32FromInt32(3)) && ((int64((*Tvars)(unsafe.Pointer(v)).Fstop)-int64((*Tvars)(unsafe.Pointer(v)).Fnow))/4 >= int64(libc.Int32FromInt32(2)) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('('))) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow + libc.UintptrFromInt32(1)*4)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('?')))) && XTcl_UniCharIsAlpha(tls, *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow + libc.UintptrFromInt32(2)*4))) != 0 {
		*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UNONPOSIX))
		*(*uintptr)(unsafe.Pointer(v + 8)) += uintptr(2) * 4
		for {
			if !(!((*Tvars)(unsafe.Pointer(v)).Fnow >= (*Tvars)(unsafe.Pointer(v)).Fstop) && XTcl_UniCharIsAlpha(tls, *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow))) != 0) {
				break
			}
			switch *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow)) {
			case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('b'))): /* BREs (but why???) */
				*(*int32)(unsafe.Pointer(v + 44)) &= ^(libc.Int32FromInt32(REG_ADVANCED) | libc.Int32FromInt32(REG_QUOTE))
			case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('c'))): /* case sensitive */
				*(*int32)(unsafe.Pointer(v + 44)) &= ^libc.Int32FromInt32(REG_ICASE)
			case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('e'))): /* plain EREs */
				*(*int32)(unsafe.Pointer(v + 44)) |= int32(REG_EXTENDED)
				*(*int32)(unsafe.Pointer(v + 44)) &= ^(libc.Int32FromInt32(REG_ADVF) | libc.Int32FromInt32(REG_QUOTE))
			case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('i'))): /* case insensitive */
				*(*int32)(unsafe.Pointer(v + 44)) |= int32(REG_ICASE)
			case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('m'))): /* Perloid synonym for n */
				fallthrough
			case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('n'))): /* \n affects ^ $ . [^ */
				*(*int32)(unsafe.Pointer(v + 44)) |= int32(REG_NEWLINE)
			case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('p'))): /* ~Perl, \n affects . [^ */
				*(*int32)(unsafe.Pointer(v + 44)) |= int32(REG_NLSTOP)
				*(*int32)(unsafe.Pointer(v + 44)) &= ^libc.Int32FromInt32(REG_NLANCH)
			case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('q'))): /* literal string */
				*(*int32)(unsafe.Pointer(v + 44)) |= int32(REG_QUOTE)
				*(*int32)(unsafe.Pointer(v + 44)) &= ^libc.Int32FromInt32(REG_ADVANCED)
			case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('s'))): /* single line, \n ordinary */
				*(*int32)(unsafe.Pointer(v + 44)) &= ^libc.Int32FromInt32(REG_NEWLINE)
			case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('t'))): /* tight syntax */
				*(*int32)(unsafe.Pointer(v + 44)) &= ^libc.Int32FromInt32(REG_EXPANDED)
			case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('w'))): /* weird, \n affects ^ $ only */
				*(*int32)(unsafe.Pointer(v + 44)) &= ^libc.Int32FromInt32(REG_NLSTOP)
				*(*int32)(unsafe.Pointer(v + 44)) |= int32(REG_NLANCH)
			case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('x'))): /* expanded syntax */
				*(*int32)(unsafe.Pointer(v + 44)) |= int32(REG_EXPANDED)
			default:
				(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
				if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
					v4 = (*Tvars)(unsafe.Pointer(v)).Ferr
				} else {
					v4 = int32(REG_BADOPT)
				}
				(*Tvars)(unsafe.Pointer(v)).Ferr = v4
				return
			}
			goto _3
		_3:
			;
			(*Tvars)(unsafe.Pointer(v)).Fnow += 4
		}
		if !(!((*Tvars)(unsafe.Pointer(v)).Fnow >= (*Tvars)(unsafe.Pointer(v)).Fstop) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(')')))) {
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
				v5 = (*Tvars)(unsafe.Pointer(v)).Ferr
			} else {
				v5 = int32(REG_BADOPT)
			}
			(*Tvars)(unsafe.Pointer(v)).Ferr = v5
			return
		}
		(*Tvars)(unsafe.Pointer(v)).Fnow += 4
		if (*Tvars)(unsafe.Pointer(v)).Fcflags&int32(REG_QUOTE) != 0 {
			*(*int32)(unsafe.Pointer(v + 44)) &= ^(libc.Int32FromInt32(REG_EXPANDED) | libc.Int32FromInt32(REG_NEWLINE))
		}
	}
}

// C documentation
//
//	/*
//	 - lexnest - "call a subroutine", interpolating string at the lexical level
//	 * Note, this is not a very general facility.  There are a number of
//	 * implicit assumptions about what sorts of strings can be subroutines.
//	 ^ static void lexnest(struct vars *, const chr *, const chr *);
//	 */
func _lexnest(tls *libc.TLS, v uintptr, beginp uintptr, endp uintptr) {
	/* one past end of interpolation */
	/* only one level of nesting */
	(*Tvars)(unsafe.Pointer(v)).Fsavenow = (*Tvars)(unsafe.Pointer(v)).Fnow
	(*Tvars)(unsafe.Pointer(v)).Fsavestop = (*Tvars)(unsafe.Pointer(v)).Fstop
	(*Tvars)(unsafe.Pointer(v)).Fnow = beginp
	(*Tvars)(unsafe.Pointer(v)).Fstop = endp
}

/*
 * string constants to interpolate as expansions of things like \d
 */

var _backd = [11]Tchr{
	0:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('['))),
	1:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('['))),
	2:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(':'))),
	3:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('d'))),
	4:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('i'))),
	5:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('g'))),
	6:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('i'))),
	7:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('t'))),
	8:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(':'))),
	9:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(']'))),
	10: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(']'))),
}
var _backD = [12]Tchr{
	0:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('['))),
	1:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('^'))),
	2:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('['))),
	3:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(':'))),
	4:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('d'))),
	5:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('i'))),
	6:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('g'))),
	7:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('i'))),
	8:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('t'))),
	9:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(':'))),
	10: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(']'))),
	11: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(']'))),
}
var _brbackd = [9]Tchr{
	0: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('['))),
	1: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(':'))),
	2: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('d'))),
	3: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('i'))),
	4: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('g'))),
	5: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('i'))),
	6: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('t'))),
	7: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(':'))),
	8: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(']'))),
}
var _backs = [11]Tchr{
	0:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('['))),
	1:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('['))),
	2:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(':'))),
	3:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('s'))),
	4:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('p'))),
	5:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('a'))),
	6:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('c'))),
	7:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('e'))),
	8:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(':'))),
	9:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(']'))),
	10: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(']'))),
}
var _backS = [12]Tchr{
	0:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('['))),
	1:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('^'))),
	2:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('['))),
	3:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(':'))),
	4:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('s'))),
	5:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('p'))),
	6:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('a'))),
	7:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('c'))),
	8:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('e'))),
	9:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(':'))),
	10: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(']'))),
	11: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(']'))),
}
var _brbacks = [9]Tchr{
	0: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('['))),
	1: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(':'))),
	2: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('s'))),
	3: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('p'))),
	4: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('a'))),
	5: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('c'))),
	6: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('e'))),
	7: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(':'))),
	8: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(']'))),
}

var _backw = [21]Tchr{
	0:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('['))),
	1:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('['))),
	2:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(':'))),
	3:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('a'))),
	4:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('l'))),
	5:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('n'))),
	6:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('u'))),
	7:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('m'))),
	8:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(':'))),
	9:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(']'))),
	10: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('_'))),
	11: int32(0x203F),
	12: int32(0x2040),
	13: int32(0x2054),
	14: int32(0xFE33),
	15: int32(0xFE34),
	16: int32(0xFE4D),
	17: int32(0xFE4E),
	18: int32(0xFE4F),
	19: int32(0xFF3F),
	20: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(']'))),
}
var _backW = [22]Tchr{
	0:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('['))),
	1:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('^'))),
	2:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('['))),
	3:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(':'))),
	4:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('a'))),
	5:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('l'))),
	6:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('n'))),
	7:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('u'))),
	8:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('m'))),
	9:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(':'))),
	10: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(']'))),
	11: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('_'))),
	12: int32(0x203F),
	13: int32(0x2040),
	14: int32(0x2054),
	15: int32(0xFE33),
	16: int32(0xFE34),
	17: int32(0xFE4D),
	18: int32(0xFE4E),
	19: int32(0xFE4F),
	20: int32(0xFF3F),
	21: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(']'))),
}
var _brbackw = [19]Tchr{
	0:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('['))),
	1:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(':'))),
	2:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('a'))),
	3:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('l'))),
	4:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('n'))),
	5:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('u'))),
	6:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('m'))),
	7:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(':'))),
	8:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(']'))),
	9:  libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('_'))),
	10: int32(0x203F),
	11: int32(0x2040),
	12: int32(0x2054),
	13: int32(0xFE33),
	14: int32(0xFE34),
	15: int32(0xFE4D),
	16: int32(0xFE4E),
	17: int32(0xFE4F),
	18: int32(0xFF3F),
}

// C documentation
//
//	/*
//	 - lexword - interpolate a bracket expression for word characters
//	 * Possibly ought to inquire whether there is a "word" character class.
//	 ^ static void lexword(struct vars *);
//	 */
func _lexword(tls *libc.TLS, v uintptr) {
	_lexnest(tls, v, uintptr(unsafe.Pointer(&_backw)), uintptr(unsafe.Pointer(&_backw))+uintptr(libc.Uint64FromInt64(84)/libc.Uint64FromInt64(4))*4)
}

// C documentation
//
//	/*
//	 - next - get next token
//	 ^ static int next(struct vars *);
//	 */
func _next(tls *libc.TLS, v uintptr) (r int32) {
	var c Tchr
	var v1, v14, v15, v16, v17, v29, v30, v4, v5 uintptr
	var v10, v11, v12, v13, v2, v26, v27, v28, v3, v31, v32, v6, v7, v8, v9 int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, v1, v10, v11, v12, v13, v14, v15, v16, v17, v2, v26, v27, v28, v29, v3, v30, v31, v32, v4, v5, v6, v7, v8, v9
	/*
	 * Errors yield an infinite sequence of failures.
	 */
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return 0 /* the error has set nexttype to EOS */
	}
	/*
	 * Remember flavor of last token.
	 */
	(*Tvars)(unsafe.Pointer(v)).Flasttype = (*Tvars)(unsafe.Pointer(v)).Fnexttype
	/*
	 * REG_BOSONLY
	 */
	if (*Tvars)(unsafe.Pointer(v)).Fnexttype == int32('n') && (*Tvars)(unsafe.Pointer(v)).Fcflags&int32(REG_BOSONLY) != 0 {
		/* at start of a REG_BOSONLY RE */
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('A')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromInt32(0))
		return libc.Int32FromInt32(1) /* same as \A */
	}
	/*
	 * If we're nested and we've hit end, return to outer level.
	 */
	if (*Tvars)(unsafe.Pointer(v)).Fsavenow != libc.UintptrFromInt32(0) && (*Tvars)(unsafe.Pointer(v)).Fnow >= (*Tvars)(unsafe.Pointer(v)).Fstop {
		(*Tvars)(unsafe.Pointer(v)).Fnow = (*Tvars)(unsafe.Pointer(v)).Fsavenow
		(*Tvars)(unsafe.Pointer(v)).Fstop = (*Tvars)(unsafe.Pointer(v)).Fsavestop
		v1 = libc.UintptrFromInt32(0)
		(*Tvars)(unsafe.Pointer(v)).Fsavestop = v1
		(*Tvars)(unsafe.Pointer(v)).Fsavenow = v1
	}
	/*
	 * Skip white space etc. if appropriate (not in literal or [])
	 */
	if (*Tvars)(unsafe.Pointer(v)).Fcflags&int32(REG_EXPANDED) != 0 {
		switch (*Tvars)(unsafe.Pointer(v)).Flexcon {
		case int32(L_ERE):
			fallthrough
		case int32(L_BRE):
			fallthrough
		case int32(L_EBND):
			fallthrough
		case int32(L_BBND):
			_skip(tls, v)
			break
		}
	}
	/*
	 * Handle EOS, depending on context.
	 */
	if (*Tvars)(unsafe.Pointer(v)).Fnow >= (*Tvars)(unsafe.Pointer(v)).Fstop {
		switch (*Tvars)(unsafe.Pointer(v)).Flexcon {
		case int32(L_ERE):
			fallthrough
		case int32(L_BRE):
			fallthrough
		case int32(L_Q):
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
			return libc.Int32FromInt32(1)
		case int32(L_EBND):
			fallthrough
		case int32(L_BBND):
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
				v2 = (*Tvars)(unsafe.Pointer(v)).Ferr
			} else {
				v2 = int32(REG_EBRACE)
			}
			(*Tvars)(unsafe.Pointer(v)).Ferr = v2
			return libc.Int32FromInt32(0)
		case int32(L_BRACK):
			fallthrough
		case int32(L_CEL):
			fallthrough
		case int32(L_ECL):
			fallthrough
		case int32(L_CCL):
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
				v3 = (*Tvars)(unsafe.Pointer(v)).Ferr
			} else {
				v3 = int32(REG_EBRACK)
			}
			(*Tvars)(unsafe.Pointer(v)).Ferr = v3
			return libc.Int32FromInt32(0)
			break
		}
	}
	/*
	 * Okay, time to actually get a character.
	 */
	v5 = v + 8
	v4 = *(*uintptr)(unsafe.Pointer(v5))
	*(*uintptr)(unsafe.Pointer(v5)) += 4
	c = *(*Tchr)(unsafe.Pointer(v4))
	/*
	 * Deal with the easy contexts, punt EREs to code below.
	 */
	switch (*Tvars)(unsafe.Pointer(v)).Flexcon {
	case int32(L_BRE): /* punt BREs to separate function */
		return _brenext(tls, v, c)
	case int32(L_ERE): /* see below */
	case int32(L_Q): /* literal strings are easy */
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(c)
		return libc.Int32FromInt32(1)
	case int32(L_BBND): /* bounds are fairly simple */
		fallthrough
	case int32(L_EBND):
		switch c {
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('0'))):
			fallthrough
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('1'))):
			fallthrough
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('2'))):
			fallthrough
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('3'))):
			fallthrough
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('4'))):
			fallthrough
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('5'))):
			fallthrough
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('6'))):
			fallthrough
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('7'))):
			fallthrough
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('8'))):
			fallthrough
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('9'))):
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('d')
			(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(c - libc.Int32FromUint8('0'))
			return libc.Int32FromInt32(1)
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(','))):
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32(',')
			return libc.Int32FromInt32(1)
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('}'))): /* ERE bound ends with } */
			if (*Tvars)(unsafe.Pointer(v)).Flexcon == int32(L_EBND) {
				(*Tvars)(unsafe.Pointer(v)).Flexcon = int32(L_ERE)
				if (*Tvars)(unsafe.Pointer(v)).Fcflags&int32(REG_ADVF) != 0 && (!((*Tvars)(unsafe.Pointer(v)).Fnow >= (*Tvars)(unsafe.Pointer(v)).Fstop) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('?')))) {
					(*Tvars)(unsafe.Pointer(v)).Fnow += 4
					*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UNONPOSIX))
					(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('}')
					(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromInt32(0))
					return libc.Int32FromInt32(1)
				}
				(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('}')
				(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromInt32(1))
				return libc.Int32FromInt32(1)
			} else {
				(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
				if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
					v6 = (*Tvars)(unsafe.Pointer(v)).Ferr
				} else {
					v6 = int32(REG_BADBR)
				}
				(*Tvars)(unsafe.Pointer(v)).Ferr = v6
				return libc.Int32FromInt32(0)
			}
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('\\'))): /* BRE bound ends with \} */
			if (*Tvars)(unsafe.Pointer(v)).Flexcon == int32(L_BBND) && (!((*Tvars)(unsafe.Pointer(v)).Fnow >= (*Tvars)(unsafe.Pointer(v)).Fstop) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('}')))) {
				(*Tvars)(unsafe.Pointer(v)).Fnow += 4
				(*Tvars)(unsafe.Pointer(v)).Flexcon = int32(L_BRE)
				(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('}')
				(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromInt32(1))
				return libc.Int32FromInt32(1)
			} else {
				(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
				if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
					v7 = (*Tvars)(unsafe.Pointer(v)).Ferr
				} else {
					v7 = int32(REG_BADBR)
				}
				(*Tvars)(unsafe.Pointer(v)).Ferr = v7
				return libc.Int32FromInt32(0)
			}
		default:
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
				v8 = (*Tvars)(unsafe.Pointer(v)).Ferr
			} else {
				v8 = int32(REG_BADBR)
			}
			(*Tvars)(unsafe.Pointer(v)).Ferr = v8
			return libc.Int32FromInt32(0)
			break
		}
	case int32(L_BRACK): /* brackets are not too hard */
		switch c {
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(']'))):
			if (*Tvars)(unsafe.Pointer(v)).Flasttype == int32('[') {
				(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
				(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(c)
				return libc.Int32FromInt32(1)
			} else {
				if (*Tvars)(unsafe.Pointer(v)).Fcflags&int32(REG_EXTENDED) != 0 {
					v9 = int32(L_ERE)
				} else {
					v9 = int32(L_BRE)
				}
				(*Tvars)(unsafe.Pointer(v)).Flexcon = v9
				(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32(']')
				return libc.Int32FromInt32(1)
			}
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('\\'))):
			*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UBBS))
			if !((*Tvars)(unsafe.Pointer(v)).Fcflags&libc.Int32FromInt32(REG_ADVF) != 0) {
				(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
				(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(c)
				return libc.Int32FromInt32(1)
			}
			*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UNONPOSIX))
			if (*Tvars)(unsafe.Pointer(v)).Fnow >= (*Tvars)(unsafe.Pointer(v)).Fstop {
				(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
				if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
					v10 = (*Tvars)(unsafe.Pointer(v)).Ferr
				} else {
					v10 = int32(REG_EESCAPE)
				}
				(*Tvars)(unsafe.Pointer(v)).Ferr = v10
				return libc.Int32FromInt32(0)
			}
			_lexescape(tls, v)
			switch (*Tvars)(unsafe.Pointer(v)).Fnexttype { /* not all escapes okay here */
			case int32('p'):
				return int32(1)
			case int32('C'):
				switch (*Tvars)(unsafe.Pointer(v)).Fnextvalue {
				case uint64('d'):
					_lexnest(tls, v, uintptr(unsafe.Pointer(&_brbackd)), uintptr(unsafe.Pointer(&_brbackd))+uintptr(libc.Uint64FromInt64(36)/libc.Uint64FromInt64(4))*4)
				case uint64('s'):
					_lexnest(tls, v, uintptr(unsafe.Pointer(&_brbacks)), uintptr(unsafe.Pointer(&_brbacks))+uintptr(libc.Uint64FromInt64(36)/libc.Uint64FromInt64(4))*4)
				case uint64('w'):
					_lexnest(tls, v, uintptr(unsafe.Pointer(&_brbackw)), uintptr(unsafe.Pointer(&_brbackw))+uintptr(libc.Uint64FromInt64(76)/libc.Uint64FromInt64(4))*4)
				default:
					(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
					if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
						v11 = (*Tvars)(unsafe.Pointer(v)).Ferr
					} else {
						v11 = int32(REG_EESCAPE)
					}
					(*Tvars)(unsafe.Pointer(v)).Ferr = v11
					return libc.Int32FromInt32(0)
					break
				}
				/*
				 * lexnest() done, back up and try again.
				 */
				(*Tvars)(unsafe.Pointer(v)).Fnexttype = (*Tvars)(unsafe.Pointer(v)).Flasttype
				return _next(tls, v)
				break
			}
			/*
			 * Not one of the acceptable escapes.
			 */
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
				v12 = (*Tvars)(unsafe.Pointer(v)).Ferr
			} else {
				v12 = int32(REG_EESCAPE)
			}
			(*Tvars)(unsafe.Pointer(v)).Ferr = v12
			return libc.Int32FromInt32(0)
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('-'))):
			if (*Tvars)(unsafe.Pointer(v)).Flasttype == int32('[') || !((*Tvars)(unsafe.Pointer(v)).Fnow >= (*Tvars)(unsafe.Pointer(v)).Fstop) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(']'))) {
				(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
				(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(c)
				return libc.Int32FromInt32(1)
			} else {
				(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('R')
				(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(c)
				return libc.Int32FromInt32(1)
			}
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('['))):
			if (*Tvars)(unsafe.Pointer(v)).Fnow >= (*Tvars)(unsafe.Pointer(v)).Fstop {
				(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
				if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
					v13 = (*Tvars)(unsafe.Pointer(v)).Ferr
				} else {
					v13 = int32(REG_EBRACK)
				}
				(*Tvars)(unsafe.Pointer(v)).Ferr = v13
				return libc.Int32FromInt32(0)
			}
			v15 = v + 8
			v14 = *(*uintptr)(unsafe.Pointer(v15))
			*(*uintptr)(unsafe.Pointer(v15)) += 4
			switch *(*Tchr)(unsafe.Pointer(v14)) {
			case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('.'))):
				(*Tvars)(unsafe.Pointer(v)).Flexcon = int32(L_CEL)
				/*
				 * Might or might not be locale-specific.
				 */
				(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('I')
				return libc.Int32FromInt32(1)
			case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('='))):
				(*Tvars)(unsafe.Pointer(v)).Flexcon = int32(L_ECL)
				*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_ULOCALE))
				(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('E')
				return libc.Int32FromInt32(1)
			case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(':'))):
				(*Tvars)(unsafe.Pointer(v)).Flexcon = int32(L_CCL)
				*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_ULOCALE))
				(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('C')
				return libc.Int32FromInt32(1)
			default: /* oops */
				(*Tvars)(unsafe.Pointer(v)).Fnow -= 4
				(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
				(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(c)
				return libc.Int32FromInt32(1)
				break
			}
		default:
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
			(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(c)
			return libc.Int32FromInt32(1)
			break
		}
	case int32(L_CEL): /* collating elements are easy */
		if c == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('.'))) && (!((*Tvars)(unsafe.Pointer(v)).Fnow >= (*Tvars)(unsafe.Pointer(v)).Fstop) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(']')))) {
			(*Tvars)(unsafe.Pointer(v)).Fnow += 4
			(*Tvars)(unsafe.Pointer(v)).Flexcon = int32(L_BRACK)
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('X')
			(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromUint8('.'))
			return libc.Int32FromInt32(1)
		} else {
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
			(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(c)
			return libc.Int32FromInt32(1)
		}
	case int32(L_ECL): /* ditto equivalence classes */
		if c == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('='))) && (!((*Tvars)(unsafe.Pointer(v)).Fnow >= (*Tvars)(unsafe.Pointer(v)).Fstop) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(']')))) {
			(*Tvars)(unsafe.Pointer(v)).Fnow += 4
			(*Tvars)(unsafe.Pointer(v)).Flexcon = int32(L_BRACK)
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('X')
			(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromUint8('='))
			return libc.Int32FromInt32(1)
		} else {
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
			(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(c)
			return libc.Int32FromInt32(1)
		}
	case int32(L_CCL): /* ditto character classes */
		if c == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(':'))) && (!((*Tvars)(unsafe.Pointer(v)).Fnow >= (*Tvars)(unsafe.Pointer(v)).Fstop) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(']')))) {
			(*Tvars)(unsafe.Pointer(v)).Fnow += 4
			(*Tvars)(unsafe.Pointer(v)).Flexcon = int32(L_BRACK)
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('X')
			(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromUint8(':'))
			return libc.Int32FromInt32(1)
		} else {
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
			(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(c)
			return libc.Int32FromInt32(1)
		}
	default:
		break
	}
	/*
	 * That got rid of everything except EREs and AREs.
	 */
	/*
	 * Deal with EREs and AREs, except for backslashes.
	 */
	switch c {
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('|'))):
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('|')
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('*'))):
		if (*Tvars)(unsafe.Pointer(v)).Fcflags&int32(REG_ADVF) != 0 && (!((*Tvars)(unsafe.Pointer(v)).Fnow >= (*Tvars)(unsafe.Pointer(v)).Fstop) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('?')))) {
			(*Tvars)(unsafe.Pointer(v)).Fnow += 4
			*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UNONPOSIX))
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('*')
			(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromInt32(0))
			return libc.Int32FromInt32(1)
		}
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('*')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromInt32(1))
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('+'))):
		if (*Tvars)(unsafe.Pointer(v)).Fcflags&int32(REG_ADVF) != 0 && (!((*Tvars)(unsafe.Pointer(v)).Fnow >= (*Tvars)(unsafe.Pointer(v)).Fstop) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('?')))) {
			(*Tvars)(unsafe.Pointer(v)).Fnow += 4
			*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UNONPOSIX))
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('+')
			(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromInt32(0))
			return libc.Int32FromInt32(1)
		}
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('+')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromInt32(1))
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('?'))):
		if (*Tvars)(unsafe.Pointer(v)).Fcflags&int32(REG_ADVF) != 0 && (!((*Tvars)(unsafe.Pointer(v)).Fnow >= (*Tvars)(unsafe.Pointer(v)).Fstop) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('?')))) {
			(*Tvars)(unsafe.Pointer(v)).Fnow += 4
			*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UNONPOSIX))
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('?')
			(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromInt32(0))
			return libc.Int32FromInt32(1)
		}
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('?')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromInt32(1))
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('{'))): /* bounds start or plain character */
		if (*Tvars)(unsafe.Pointer(v)).Fcflags&int32(REG_EXPANDED) != 0 {
			_skip(tls, v)
		}
		if (*Tvars)(unsafe.Pointer(v)).Fnow >= (*Tvars)(unsafe.Pointer(v)).Fstop || !(XTcl_UniCharIsDigit(tls, *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow))) != 0) {
			*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UBRACES))
			*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UUNSPEC))
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
			(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(c)
			return libc.Int32FromInt32(1)
		} else {
			*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UBOUNDS))
			(*Tvars)(unsafe.Pointer(v)).Flexcon = int32(L_EBND)
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('{')
			return libc.Int32FromInt32(1)
		}
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('('))): /* parenthesis, or advanced extension */
		if (*Tvars)(unsafe.Pointer(v)).Fcflags&int32(REG_ADVF) != 0 && (!((*Tvars)(unsafe.Pointer(v)).Fnow >= (*Tvars)(unsafe.Pointer(v)).Fstop) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('?')))) {
			*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UNONPOSIX))
			(*Tvars)(unsafe.Pointer(v)).Fnow += 4
			v17 = v + 8
			v16 = *(*uintptr)(unsafe.Pointer(v17))
			*(*uintptr)(unsafe.Pointer(v17)) += 4
			switch *(*Tchr)(unsafe.Pointer(v16)) {
			case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(':'))):
				goto _18
			case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('#'))):
				goto _19
			case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('='))):
				goto _20
			case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('!'))):
				goto _21
			default:
				goto _22
			}
			goto _23
		_18:
			; /* non-capturing paren */
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('(')
			(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromInt32(0))
			return libc.Int32FromInt32(1)
			goto _23
		_19:
			; /* comment */
		_25:
			;
			if !(!((*Tvars)(unsafe.Pointer(v)).Fnow >= (*Tvars)(unsafe.Pointer(v)).Fstop) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow)) != libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(')')))) {
				goto _24
			}
			(*Tvars)(unsafe.Pointer(v)).Fnow += 4
			goto _25
		_24:
			;
			if !((*Tvars)(unsafe.Pointer(v)).Fnow >= (*Tvars)(unsafe.Pointer(v)).Fstop) {
				(*Tvars)(unsafe.Pointer(v)).Fnow += 4
			}
			return _next(tls, v)
			goto _23
		_20:
			; /* positive lookahead */
			*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_ULOOKAHEAD))
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('L')
			(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromInt32(1))
			return libc.Int32FromInt32(1)
			goto _23
		_21:
			; /* negative lookahead */
			*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_ULOOKAHEAD))
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('L')
			(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromInt32(0))
			return libc.Int32FromInt32(1)
			goto _23
		_22:
			;
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
				v26 = (*Tvars)(unsafe.Pointer(v)).Ferr
			} else {
				v26 = int32(REG_BADRPT)
			}
			(*Tvars)(unsafe.Pointer(v)).Ferr = v26
			return libc.Int32FromInt32(0)
			goto _23
		_23:
		}
		if (*Tvars)(unsafe.Pointer(v)).Fcflags&int32(REG_NOSUB) != 0 {
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('(')
			(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromInt32(0))
			return libc.Int32FromInt32(1) /* all parens non-capturing */
		} else {
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('(')
			(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromInt32(1))
			return libc.Int32FromInt32(1)
		}
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(')'))):
		if (*Tvars)(unsafe.Pointer(v)).Flasttype == int32('(') {
			*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UUNSPEC))
		}
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32(')')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(c)
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('['))): /* easy except for [[:<:]] and [[:>:]] */
		if (int64((*Tvars)(unsafe.Pointer(v)).Fstop)-int64((*Tvars)(unsafe.Pointer(v)).Fnow))/4 >= int64(libc.Int32FromInt32(6)) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow + libc.UintptrFromInt32(0)*4)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('['))) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow + libc.UintptrFromInt32(1)*4)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(':'))) && (*(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow + libc.UintptrFromInt32(2)*4)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('<'))) || *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow + libc.UintptrFromInt32(2)*4)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('>')))) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow + libc.UintptrFromInt32(3)*4)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(':'))) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow + libc.UintptrFromInt32(4)*4)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(']'))) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow + libc.UintptrFromInt32(5)*4)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(']'))) {
			c = *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow + libc.UintptrFromInt32(2)*4))
			*(*uintptr)(unsafe.Pointer(v + 8)) += uintptr(6) * 4
			*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UNONPOSIX))
			if c == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('<'))) {
				v27 = int32('<')
			} else {
				v27 = int32('>')
			}
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = v27
			return libc.Int32FromInt32(1)
		}
		(*Tvars)(unsafe.Pointer(v)).Flexcon = int32(L_BRACK)
		if !((*Tvars)(unsafe.Pointer(v)).Fnow >= (*Tvars)(unsafe.Pointer(v)).Fstop) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('^'))) {
			(*Tvars)(unsafe.Pointer(v)).Fnow += 4
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('[')
			(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromInt32(0))
			return libc.Int32FromInt32(1)
		}
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('[')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromInt32(1))
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('.'))):
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('.')
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('^'))):
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('^')
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('$'))):
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('$')
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('\\'))): /* mostly punt backslashes to code below */
		if (*Tvars)(unsafe.Pointer(v)).Fnow >= (*Tvars)(unsafe.Pointer(v)).Fstop {
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
				v28 = (*Tvars)(unsafe.Pointer(v)).Ferr
			} else {
				v28 = int32(REG_EESCAPE)
			}
			(*Tvars)(unsafe.Pointer(v)).Ferr = v28
			return libc.Int32FromInt32(0)
		}
	default: /* ordinary character */
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(c)
		return libc.Int32FromInt32(1)
		break
	}
	/*
	 * ERE/ARE backslash handling; backslash already eaten.
	 */
	if !((*Tvars)(unsafe.Pointer(v)).Fcflags&libc.Int32FromInt32(REG_ADVF) != 0) { /* only AREs have non-trivial escapes */
		if XTcl_UniCharIsAlnum(tls, *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow))) != 0 {
			*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UBSALNUM))
			*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UUNSPEC))
		}
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
		v30 = v + 8
		v29 = *(*uintptr)(unsafe.Pointer(v30))
		*(*uintptr)(unsafe.Pointer(v30)) += 4
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(*(*Tchr)(unsafe.Pointer(v29)))
		return libc.Int32FromInt32(1)
	}
	_lexescape(tls, v)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			v31 = (*Tvars)(unsafe.Pointer(v)).Ferr
		} else {
			v31 = int32(REG_EESCAPE)
		}
		(*Tvars)(unsafe.Pointer(v)).Ferr = v31
		return libc.Int32FromInt32(0)
	}
	if (*Tvars)(unsafe.Pointer(v)).Fnexttype == int32('C') { /* fudge at lexical level */
		switch (*Tvars)(unsafe.Pointer(v)).Fnextvalue {
		case uint64('d'):
			_lexnest(tls, v, uintptr(unsafe.Pointer(&_backd)), uintptr(unsafe.Pointer(&_backd))+uintptr(libc.Uint64FromInt64(44)/libc.Uint64FromInt64(4))*4)
		case uint64('D'):
			_lexnest(tls, v, uintptr(unsafe.Pointer(&_backD)), uintptr(unsafe.Pointer(&_backD))+uintptr(libc.Uint64FromInt64(48)/libc.Uint64FromInt64(4))*4)
		case uint64('s'):
			_lexnest(tls, v, uintptr(unsafe.Pointer(&_backs)), uintptr(unsafe.Pointer(&_backs))+uintptr(libc.Uint64FromInt64(44)/libc.Uint64FromInt64(4))*4)
		case uint64('S'):
			_lexnest(tls, v, uintptr(unsafe.Pointer(&_backS)), uintptr(unsafe.Pointer(&_backS))+uintptr(libc.Uint64FromInt64(48)/libc.Uint64FromInt64(4))*4)
		case uint64('w'):
			_lexnest(tls, v, uintptr(unsafe.Pointer(&_backw)), uintptr(unsafe.Pointer(&_backw))+uintptr(libc.Uint64FromInt64(84)/libc.Uint64FromInt64(4))*4)
		case uint64('W'):
			_lexnest(tls, v, uintptr(unsafe.Pointer(&_backW)), uintptr(unsafe.Pointer(&_backW))+uintptr(libc.Uint64FromInt64(88)/libc.Uint64FromInt64(4))*4)
		default:
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
				v32 = (*Tvars)(unsafe.Pointer(v)).Ferr
			} else {
				v32 = int32(REG_ASSERT)
			}
			(*Tvars)(unsafe.Pointer(v)).Ferr = v32
			return libc.Int32FromInt32(0)
			break
		}
		/* lexnest done, back up and try again */
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = (*Tvars)(unsafe.Pointer(v)).Flasttype
		return _next(tls, v)
	}
	/*
	 * Otherwise, lexescape has already done the work.
	 */
	return libc.BoolInt32(!((*Tvars)(unsafe.Pointer(v)).Ferr != libc.Int32FromInt32(0)))
}

// C documentation
//
//	/*
//	 - lexescape - parse an ARE backslash escape (backslash already eaten)
//	 * Note slightly nonstandard use of the CCLASS type code.
//	 ^ static int lexescape(struct vars *);
//	 */
func _lexescape(tls *libc.TLS, v uintptr) (r int32) {
	var c Tchr
	var i, v10, v11, v3, v6, v7, v8, v9 int32
	var save, v1, v2, v4, v5 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, i, save, v1, v10, v11, v2, v3, v4, v5, v6, v7, v8, v9
	v2 = v + 8
	v1 = *(*uintptr)(unsafe.Pointer(v2))
	*(*uintptr)(unsafe.Pointer(v2)) += 4
	c = *(*Tchr)(unsafe.Pointer(v1))
	if !(XTcl_UniCharIsAlnum(tls, c) != 0) {
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(c)
		return libc.Int32FromInt32(1)
	}
	*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UNONPOSIX))
	switch c {
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('a'))):
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(_chrnamed(tls, v, uintptr(unsafe.Pointer(&_alert)), uintptr(unsafe.Pointer(&_alert))+uintptr(libc.Uint64FromInt64(20)/libc.Uint64FromInt64(4))*4, libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('\x07')))))
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('A'))):
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('A')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromInt32(0))
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('b'))):
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = uint64(libc.Uint8FromInt32(libc.Int32FromUint8('\b')))
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('B'))):
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = uint64(libc.Uint8FromInt32(libc.Int32FromUint8('\\')))
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('c'))):
		*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UUNPORT))
		if (*Tvars)(unsafe.Pointer(v)).Fnow >= (*Tvars)(unsafe.Pointer(v)).Fstop {
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
				v3 = (*Tvars)(unsafe.Pointer(v)).Ferr
			} else {
				v3 = int32(REG_EESCAPE)
			}
			(*Tvars)(unsafe.Pointer(v)).Ferr = v3
			return libc.Int32FromInt32(0)
		}
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
		v5 = v + 8
		v4 = *(*uintptr)(unsafe.Pointer(v5))
		*(*uintptr)(unsafe.Pointer(v5)) += 4
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(*(*Tchr)(unsafe.Pointer(v4)) & libc.Int32FromInt32(037))
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('d'))):
		*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_ULOCALE))
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('C')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromUint8('d'))
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('D'))):
		*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_ULOCALE))
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('C')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromUint8('D'))
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('e'))):
		*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UUNPORT))
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(_chrnamed(tls, v, uintptr(unsafe.Pointer(&_esc)), uintptr(unsafe.Pointer(&_esc))+uintptr(libc.Uint64FromInt64(12)/libc.Uint64FromInt64(4))*4, libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('\x1B')))))
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('f'))):
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = uint64(libc.Uint8FromInt32(libc.Int32FromUint8('\f')))
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('m'))):
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('<')
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('M'))):
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('>')
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('n'))):
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = uint64(libc.Uint8FromInt32(libc.Int32FromUint8('\n')))
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('r'))):
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = uint64(libc.Uint8FromInt32(libc.Int32FromUint8('\r')))
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('s'))):
		*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_ULOCALE))
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('C')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromUint8('s'))
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('S'))):
		*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_ULOCALE))
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('C')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromUint8('S'))
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('t'))):
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = uint64(libc.Uint8FromInt32(libc.Int32FromUint8('\t')))
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('u'))):
		c = libc.Int32FromUint32(libc.Uint32FromInt32(_lexdigits(tls, v, int32(16), int32(1), int32(4))))
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
				v6 = (*Tvars)(unsafe.Pointer(v)).Ferr
			} else {
				v6 = int32(REG_EESCAPE)
			}
			(*Tvars)(unsafe.Pointer(v)).Ferr = v6
			return libc.Int32FromInt32(0)
		}
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(c)
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('U'))):
		i = _lexdigits(tls, v, int32(16), int32(1), int32(8))
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
				v7 = (*Tvars)(unsafe.Pointer(v)).Ferr
			} else {
				v7 = int32(REG_EESCAPE)
			}
			(*Tvars)(unsafe.Pointer(v)).Ferr = v7
			return libc.Int32FromInt32(0)
		}
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = uint64(libc.Uint32FromInt32(i))
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('v'))):
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = uint64(libc.Uint8FromInt32(libc.Int32FromUint8('\v')))
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('w'))):
		*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_ULOCALE))
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('C')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromUint8('w'))
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('W'))):
		*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_ULOCALE))
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('C')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromUint8('W'))
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('x'))):
		*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UUNPORT))
		c = libc.Int32FromUint32(libc.Uint32FromInt32(_lexdigits(tls, v, int32(16), int32(1), int32(2))))
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
				v8 = (*Tvars)(unsafe.Pointer(v)).Ferr
			} else {
				v8 = int32(REG_EESCAPE)
			}
			(*Tvars)(unsafe.Pointer(v)).Ferr = v8
			return libc.Int32FromInt32(0)
		}
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(c)
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('y'))):
		*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_ULOCALE))
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('w')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromInt32(0))
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('Y'))):
		*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_ULOCALE))
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('W')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromInt32(0))
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('Z'))):
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('Z')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromInt32(0))
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('1'))):
		fallthrough
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('2'))):
		fallthrough
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('3'))):
		fallthrough
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('4'))):
		fallthrough
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('5'))):
		fallthrough
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('6'))):
		fallthrough
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('7'))):
		fallthrough
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('8'))):
		fallthrough
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('9'))):
		save = (*Tvars)(unsafe.Pointer(v)).Fnow
		(*Tvars)(unsafe.Pointer(v)).Fnow -= 4                                                               /* put first digit back */
		c = libc.Int32FromUint32(libc.Uint32FromInt32(_lexdigits(tls, v, int32(10), int32(1), int32(255)))) /* REs >255 long outside spec */
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
				v9 = (*Tvars)(unsafe.Pointer(v)).Ferr
			} else {
				v9 = int32(REG_EESCAPE)
			}
			(*Tvars)(unsafe.Pointer(v)).Ferr = v9
			return libc.Int32FromInt32(0)
		}
		/*
		 * Ugly heuristic (first test is "exactly 1 digit?")
		 */
		if (int64((*Tvars)(unsafe.Pointer(v)).Fnow)-int64(save))/4 == 0 || c > 0 && libc.Uint64FromInt32(c) <= (*Tvars)(unsafe.Pointer(v)).Fnsubexp {
			*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UBACKREF))
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('b')
			(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(c)
			return libc.Int32FromInt32(1)
		}
		/*
		 * Oops, doesn't look like it's a backref after all...
		 */
		(*Tvars)(unsafe.Pointer(v)).Fnow = save
		/* FALLTHRU */
		fallthrough
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('0'))):
		*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UUNPORT))
		(*Tvars)(unsafe.Pointer(v)).Fnow -= 4 /* put first digit back */
		c = libc.Int32FromUint32(libc.Uint32FromInt32(_lexdigits(tls, v, int32(8), int32(1), int32(3))))
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
				v10 = (*Tvars)(unsafe.Pointer(v)).Ferr
			} else {
				v10 = int32(REG_EESCAPE)
			}
			(*Tvars)(unsafe.Pointer(v)).Ferr = v10
			return libc.Int32FromInt32(0)
		}
		if c > int32(0xFF) {
			/* out of range, so we handled one digit too much */
			(*Tvars)(unsafe.Pointer(v)).Fnow -= 4
			c >>= int32(3)
		}
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(c)
		return libc.Int32FromInt32(1)
	default:
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			v11 = (*Tvars)(unsafe.Pointer(v)).Ferr
		} else {
			v11 = int32(REG_EESCAPE)
		}
		(*Tvars)(unsafe.Pointer(v)).Ferr = v11
		return libc.Int32FromInt32(0) /* unknown alphabetic escape */
		break
	}
	return r
}

var _alert = [5]Tchr{
	0: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('a'))),
	1: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('l'))),
	2: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('e'))),
	3: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('r'))),
	4: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('t'))),
}

var _esc = [3]Tchr{
	0: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('E'))),
	1: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('S'))),
	2: libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('C'))),
}

// C documentation
//
//	/*
//	 - lexdigits - slurp up digits and return chr value
//	 ^ static int lexdigits(struct vars *, int, int, int);
//	 */
func _lexdigits(tls *libc.TLS, v uintptr, base int32, minlen int32, maxlen int32) (r int32) {
	var c Tchr
	var d, len1, n, v4 int32
	var ub Tuchr
	var v2, v3 uintptr
	_, _, _, _, _, _, _, _ = c, d, len1, n, ub, v2, v3, v4
	ub = libc.Uint32FromInt32(base)
	n = 0
	len1 = 0
	for {
		if !(len1 < maxlen && !((*Tvars)(unsafe.Pointer(v)).Fnow >= (*Tvars)(unsafe.Pointer(v)).Fstop)) {
			break
		}
		if n > int32(0x10FFF) {
			/* Stop when continuing would otherwise overflow */
			break
		}
		v3 = v + 8
		v2 = *(*uintptr)(unsafe.Pointer(v3))
		*(*uintptr)(unsafe.Pointer(v3)) += 4
		c = *(*Tchr)(unsafe.Pointer(v2))
		switch c {
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('0'))):
			fallthrough
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('1'))):
			fallthrough
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('2'))):
			fallthrough
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('3'))):
			fallthrough
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('4'))):
			fallthrough
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('5'))):
			fallthrough
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('6'))):
			fallthrough
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('7'))):
			fallthrough
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('8'))):
			fallthrough
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('9'))):
			d = c - int32('0')
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('a'))):
			fallthrough
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('A'))):
			d = int32(10)
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('b'))):
			fallthrough
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('B'))):
			d = int32(11)
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('c'))):
			fallthrough
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('C'))):
			d = int32(12)
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('d'))):
			fallthrough
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('D'))):
			d = int32(13)
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('e'))):
			fallthrough
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('E'))):
			d = int32(14)
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('f'))):
			fallthrough
		case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('F'))):
			d = int32(15)
		default:
			(*Tvars)(unsafe.Pointer(v)).Fnow -= 4 /* oops, not a digit at all */
			d = -int32(1)
			break
		}
		if d >= base { /* not a plausible digit */
			(*Tvars)(unsafe.Pointer(v)).Fnow -= 4
			d = -int32(1)
		}
		if d < 0 {
			break /* NOTE BREAK OUT */
		}
		n = libc.Int32FromUint32(libc.Uint32FromInt32(n)*ub + libc.Uint32FromInt32(d))
		goto _1
	_1:
		;
		len1++
	}
	if len1 < minlen {
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			v4 = (*Tvars)(unsafe.Pointer(v)).Ferr
		} else {
			v4 = int32(REG_EESCAPE)
		}
		(*Tvars)(unsafe.Pointer(v)).Ferr = v4
	}
	return n
}

// C documentation
//
//	/*
//	 - brenext - get next BRE token
//	 * This is much like EREs except for all the stupid backslashes and the
//	 * context-dependency of some things.
//	 ^ static int brenext(struct vars *, pchr);
//	 */
func _brenext(tls *libc.TLS, v uintptr, pc Tpchr) (r int32) {
	var c Tchr
	var v1, v2 int32
	var v3, v4 uintptr
	_, _, _, _, _ = c, v1, v2, v3, v4
	c = pc
	switch c {
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('*'))):
		if (*Tvars)(unsafe.Pointer(v)).Flasttype == int32('n') || (*Tvars)(unsafe.Pointer(v)).Flasttype == int32('(') || (*Tvars)(unsafe.Pointer(v)).Flasttype == int32('^') {
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
			(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(c)
			return libc.Int32FromInt32(1)
		}
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('*')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromInt32(1))
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('['))):
		if (int64((*Tvars)(unsafe.Pointer(v)).Fstop)-int64((*Tvars)(unsafe.Pointer(v)).Fnow))/4 >= int64(libc.Int32FromInt32(6)) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow + libc.UintptrFromInt32(0)*4)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('['))) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow + libc.UintptrFromInt32(1)*4)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(':'))) && (*(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow + libc.UintptrFromInt32(2)*4)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('<'))) || *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow + libc.UintptrFromInt32(2)*4)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('>')))) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow + libc.UintptrFromInt32(3)*4)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(':'))) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow + libc.UintptrFromInt32(4)*4)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(']'))) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow + libc.UintptrFromInt32(5)*4)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(']'))) {
			c = *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow + libc.UintptrFromInt32(2)*4))
			*(*uintptr)(unsafe.Pointer(v + 8)) += uintptr(6) * 4
			*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UNONPOSIX))
			if c == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('<'))) {
				v1 = int32('<')
			} else {
				v1 = int32('>')
			}
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = v1
			return libc.Int32FromInt32(1)
		}
		(*Tvars)(unsafe.Pointer(v)).Flexcon = int32(L_BRACK)
		if !((*Tvars)(unsafe.Pointer(v)).Fnow >= (*Tvars)(unsafe.Pointer(v)).Fstop) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('^'))) {
			(*Tvars)(unsafe.Pointer(v)).Fnow += 4
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('[')
			(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromInt32(0))
			return libc.Int32FromInt32(1)
		}
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('[')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromInt32(1))
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('.'))):
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('.')
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('^'))):
		if (*Tvars)(unsafe.Pointer(v)).Flasttype == int32('n') {
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('^')
			return libc.Int32FromInt32(1)
		}
		if (*Tvars)(unsafe.Pointer(v)).Flasttype == int32('(') {
			*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UUNSPEC))
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('^')
			return libc.Int32FromInt32(1)
		}
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(c)
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('$'))):
		if (*Tvars)(unsafe.Pointer(v)).Fcflags&int32(REG_EXPANDED) != 0 {
			_skip(tls, v)
		}
		if (*Tvars)(unsafe.Pointer(v)).Fnow >= (*Tvars)(unsafe.Pointer(v)).Fstop {
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('$')
			return libc.Int32FromInt32(1)
		}
		if (int64((*Tvars)(unsafe.Pointer(v)).Fstop)-int64((*Tvars)(unsafe.Pointer(v)).Fnow))/4 >= int64(libc.Int32FromInt32(2)) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('\\'))) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow + libc.UintptrFromInt32(1)*4)) == libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(')'))) {
			*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UUNSPEC))
			(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('$')
			return libc.Int32FromInt32(1)
		}
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(c)
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('\\'))):
	default:
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(c)
		return libc.Int32FromInt32(1)
		break
	}
	if (*Tvars)(unsafe.Pointer(v)).Fnow >= (*Tvars)(unsafe.Pointer(v)).Fstop {
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			v2 = (*Tvars)(unsafe.Pointer(v)).Ferr
		} else {
			v2 = int32(REG_EESCAPE)
		}
		(*Tvars)(unsafe.Pointer(v)).Ferr = v2
		return libc.Int32FromInt32(0)
	}
	v4 = v + 8
	v3 = *(*uintptr)(unsafe.Pointer(v4))
	*(*uintptr)(unsafe.Pointer(v4)) += 4
	c = *(*Tchr)(unsafe.Pointer(v3))
	switch c {
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('{'))):
		(*Tvars)(unsafe.Pointer(v)).Flexcon = int32(L_BBND)
		*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UBOUNDS))
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('{')
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('('))):
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('(')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(libc.Int32FromInt32(1))
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8(')'))):
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32(')')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(c)
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('<'))):
		*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UNONPOSIX))
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('<')
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('>'))):
		*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UNONPOSIX))
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('>')
		return libc.Int32FromInt32(1)
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('1'))):
		fallthrough
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('2'))):
		fallthrough
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('3'))):
		fallthrough
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('4'))):
		fallthrough
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('5'))):
		fallthrough
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('6'))):
		fallthrough
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('7'))):
		fallthrough
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('8'))):
		fallthrough
	case libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('9'))):
		*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UBACKREF))
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('b')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(c - libc.Int32FromUint8('0'))
		return libc.Int32FromInt32(1)
	default:
		if XTcl_UniCharIsAlnum(tls, c) != 0 {
			*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UBSALNUM))
			*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UUNSPEC))
		}
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('p')
		(*Tvars)(unsafe.Pointer(v)).Fnextvalue = libc.Uint64FromInt32(c)
		return libc.Int32FromInt32(1)
		break
	}
	return r
}

// C documentation
//
//	/*
//	 - skip - skip white space and comments in expanded form
//	 ^ static void skip(struct vars *);
//	 */
func _skip(tls *libc.TLS, v uintptr) {
	var start uintptr
	_ = start
	start = (*Tvars)(unsafe.Pointer(v)).Fnow
	for {
		for !((*Tvars)(unsafe.Pointer(v)).Fnow >= (*Tvars)(unsafe.Pointer(v)).Fstop) && XTcl_UniCharIsSpace(tls, *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow))) != 0 {
			(*Tvars)(unsafe.Pointer(v)).Fnow += 4
		}
		if (*Tvars)(unsafe.Pointer(v)).Fnow >= (*Tvars)(unsafe.Pointer(v)).Fstop || *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow)) != libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('#'))) {
			break /* NOTE BREAK OUT */
		}
		for !((*Tvars)(unsafe.Pointer(v)).Fnow >= (*Tvars)(unsafe.Pointer(v)).Fstop) && *(*Tchr)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fnow)) != libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('\n'))) {
			(*Tvars)(unsafe.Pointer(v)).Fnow += 4
		}
		/*
		 * Leave the newline to be picked up by the iscspace loop.
		 */
		goto _1
	_1:
	}
	if (*Tvars)(unsafe.Pointer(v)).Fnow != start {
		*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_UNONPOSIX))
	}
}

// C documentation
//
//	/*
//	 - newline - return the chr for a newline
//	 * This helps confine use of CHR to this source file.
//	 ^ static chr newline(void);
//	 */
func _newline(tls *libc.TLS) (r Tchr) {
	return libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('\n')))
}

// C documentation
//
//	/*
//	 - chrnamed - return the chr known by a given (chr string) name
//	 * The code is a bit clumsy, but this routine gets only such specialized
//	 * use that it hardly matters.
//	 ^ static chr chrnamed(struct vars *, const chr *, const chr *, pchr);
//	 */
func _chrnamed(tls *libc.TLS, v uintptr, startp uintptr, endp uintptr, lastresort Tpchr) (r Tchr) {
	/* what to return if name lookup fails */
	var c Tcelt
	var cv uintptr
	var e, errsave int32
	_, _, _, _ = c, cv, e, errsave
	errsave = (*Tvars)(unsafe.Pointer(v)).Ferr
	(*Tvars)(unsafe.Pointer(v)).Ferr = 0
	c = _element(tls, v, startp, endp)
	e = (*Tvars)(unsafe.Pointer(v)).Ferr
	(*Tvars)(unsafe.Pointer(v)).Ferr = errsave
	if e != 0 {
		return lastresort
	}
	cv = _range(tls, v, c, c, 0)
	if (*Tcvec)(unsafe.Pointer(cv)).Fnchrs == uint64(0) {
		return lastresort
	}
	return *(*Tchr)(unsafe.Pointer((*Tcvec)(unsafe.Pointer(cv)).Fchrs))
}

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */
/*
 * colorings of characters
 * This file is #included by regcomp.c.
 *
 * Copyright © 1998, 1999 Henry Spencer. All rights reserved.
 *
 * Development of this software was funded, in part, by Cray Research Inc.,
 * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
 * Corporation, none of whom are responsible for the results. The author
 * thanks all of them.
 *
 * Redistribution and use in source and binary forms -- with or without
 * modification -- are permitted for any purpose, provided that
 * redistributions in source form retain this entire copyright notice and
 * indicate the origin and nature of any modifications.
 *
 * I'd appreciate being given credit for this package in the documentation of
 * software which uses it, but that is not a requirement.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
 * HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * Note that there are some incestuous relationships between this code and NFA
 * arc maintenance, which perhaps ought to be cleaned up sometime.
 */

// C documentation
//
//	/*
//	 - initcm - set up new colormap
//	 ^ static void initcm(struct vars *, struct colormap *);
//	 */
func _initcm(tls *libc.TLS, v uintptr, cm uintptr) {
	var cd, nextt, t uintptr
	var i, j int32
	_, _, _, _, _ = cd, i, j, nextt, t
	(*Tcolormap)(unsafe.Pointer(cm)).Fmagic = int32(CMMAGIC)
	(*Tcolormap)(unsafe.Pointer(cm)).Fv = v
	(*Tcolormap)(unsafe.Pointer(cm)).Fncds = libc.Uint64FromInt32(10)
	(*Tcolormap)(unsafe.Pointer(cm)).Fcd = cm + 48
	(*Tcolormap)(unsafe.Pointer(cm)).Fmax = uint64(0)
	(*Tcolormap)(unsafe.Pointer(cm)).Ffree = 0
	cd = (*Tcolormap)(unsafe.Pointer(cm)).Fcd /* cm->cd[WHITE] */
	(*Tcolordesc)(unsafe.Pointer(cd)).Fsub = int16(-libc.Int32FromInt32(1))
	(*Tcolordesc)(unsafe.Pointer(cd)).Farcs = libc.UintptrFromInt32(0)
	(*Tcolordesc)(unsafe.Pointer(cd)).Fflags = 0
	(*Tcolordesc)(unsafe.Pointer(cd)).Fnchrs = libc.Uint32FromInt32(libc.Int32FromInt32(CHR_MAX) - libc.Int32FromInt32(CHR_MIN) + libc.Int32FromInt32(1))
	/*
	 * Upper levels of tree.
	 */
	t = cm + 368
	j = (libc.Int32FromInt32(CHRBITS)+libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1))/libc.Int32FromInt32(BYTBITS) - libc.Int32FromInt32(1)
	for {
		if !(j > 0) {
			break
		}
		nextt = t + uintptr(1)*2048
		i = libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS) - libc.Int32FromInt32(1)
		for {
			if !(i >= 0) {
				break
			}
			*(*uintptr)(unsafe.Pointer(t + uintptr(i)*8)) = nextt
			goto _2
		_2:
			;
			i--
		}
		goto _1
	_1:
		;
		t = nextt
		j--
	}
	/*
	 * Bottom level is solid white.
	 */
	t = cm + 368 + uintptr((libc.Int32FromInt32(CHRBITS)+libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1))/libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1))*2048
	i = libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS) - libc.Int32FromInt32(1)
	for {
		if !(i >= 0) {
			break
		}
		*(*Tcolor)(unsafe.Pointer(t + uintptr(i)*2)) = WHITE
		goto _3
	_3:
		;
		i--
	}
	(*Tcolordesc)(unsafe.Pointer(cd)).Fblock = t
}

// C documentation
//
//	/*
//	 - freecm - free dynamically-allocated things in a colormap
//	 ^ static void freecm(struct colormap *);
//	 */
func _freecm(tls *libc.TLS, cm uintptr) {
	var cb uintptr
	var i Tsize_t
	_, _ = cb, i
	(*Tcolormap)(unsafe.Pointer(cm)).Fmagic = 0
	if (libc.Int32FromInt32(CHRBITS)+libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1))/libc.Int32FromInt32(BYTBITS) > int32(1) {
		_cmtreefree(tls, cm, cm+368, 0)
	}
	i = uint64(1)
	for {
		if !(i <= (*Tcolormap)(unsafe.Pointer(cm)).Fmax) {
			break
		} /* skip WHITE */
		if !((*Tcolordesc)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fcd+uintptr(i)*32)).Fflags&libc.Int32FromInt32(FREECOL) != 0) {
			cb = (*(*Tcolordesc)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr(i)*32))).Fblock
			if cb != libc.UintptrFromInt32(0) {
				XTclpFree(tls, cb)
			}
		}
		goto _1
	_1:
		;
		i++
	}
	if (*Tcolormap)(unsafe.Pointer(cm)).Fcd != cm+48 {
		XTclpFree(tls, (*Tcolormap)(unsafe.Pointer(cm)).Fcd)
	}
}

// C documentation
//
//	/*
//	 - cmtreefree - free a non-terminal part of a colormap tree
//	 ^ static void cmtreefree(struct colormap *, union tree *, int);
//	 */
func _cmtreefree(tls *libc.TLS, cm uintptr, tree uintptr, level int32) {
	/* level number (top == 0) of this block */
	var cb, fillt, t uintptr
	var i int32
	_, _, _, _ = cb, fillt, i, t
	fillt = cm + 368 + uintptr(level+int32(1))*2048
	/* this level has pointers */
	i = libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS) - libc.Int32FromInt32(1)
	for {
		if !(i >= 0) {
			break
		}
		t = *(*uintptr)(unsafe.Pointer(tree + uintptr(i)*8))
		if t != fillt {
			if level < (libc.Int32FromInt32(CHRBITS)+libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1))/libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(2) { /* more pointer blocks below */
				_cmtreefree(tls, cm, t, level+int32(1))
				XTclpFree(tls, t)
			} else { /* color block below */
				cb = (*(*Tcolordesc)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr(*(*Tcolor)(unsafe.Pointer(t)))*32))).Fblock
				if t != cb { /* not a solid block */
					XTclpFree(tls, t)
				}
			}
		}
		goto _1
	_1:
		;
		i--
	}
}

// C documentation
//
//	/*
//	 - setcolor - set the color of a character in a colormap
//	 ^ static color setcolor(struct colormap *, pchr, pcolor);
//	 */
func _setcolor(tls *libc.TLS, cm uintptr, c Tpchr, co Tpcolor) (r Tcolor) {
	var b, bottom, level, shift, v2, v5 int32
	var cb, fillt, lastt, newt, t, v3 uintptr
	var prev Tcolor
	var uc Tuchr
	var v4 uint64
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = b, bottom, cb, fillt, lastt, level, newt, prev, shift, t, uc, v2, v3, v4, v5
	uc = libc.Uint32FromInt32(c)
	if (*Tvars)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fv)).Ferr != 0 || co == -int32(1) {
		return int16(-libc.Int32FromInt32(1))
	}
	t = cm + 368
	level = 0
	shift = libc.Int32FromInt32(BYTBITS) * ((libc.Int32FromInt32(CHRBITS)+libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1))/libc.Int32FromInt32(BYTBITS) - libc.Int32FromInt32(1))
	for {
		if !(shift > 0) {
			break
		}
		b = libc.Int32FromUint32(uc >> shift & libc.Uint32FromInt32(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))
		lastt = t
		t = *(*uintptr)(unsafe.Pointer(lastt + uintptr(b)*8))
		fillt = cm + 368 + uintptr(level+int32(1))*2048
		if shift <= int32(BYTBITS) {
			v2 = int32(1)
		} else {
			v2 = 0
		}
		bottom = v2
		if bottom != 0 {
			v3 = (*(*Tcolordesc)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr(*(*Tcolor)(unsafe.Pointer(t)))*32))).Fblock
		} else {
			v3 = fillt
		}
		cb = v3
		if t == fillt || t == cb { /* must allocate a new block */
			if bottom != 0 {
				v4 = uint64(512)
			} else {
				v4 = uint64(2048)
			}
			newt = XTclpAlloc(tls, v4)
			if newt == libc.UintptrFromInt32(0) {
				(*Tvars)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fv)).Fnexttype = int32('e')
				if (*Tvars)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fv)).Ferr != 0 {
					v5 = (*Tvars)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fv)).Ferr
				} else {
					v5 = int32(REG_ESPACE)
				}
				(*Tvars)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fv)).Ferr = v5
				return int16(-libc.Int32FromInt32(1))
			}
			if bottom != 0 {
				libc.Xmemcpy(tls, newt, t, libc.Uint64FromInt32(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS))*libc.Uint64FromInt64(2))
			} else {
				libc.Xmemcpy(tls, newt, t, libc.Uint64FromInt32(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS))*libc.Uint64FromInt64(8))
			}
			t = newt
			*(*uintptr)(unsafe.Pointer(lastt + uintptr(b)*8)) = t
		}
		goto _1
	_1:
		;
		level++
		shift -= int32(BYTBITS)
	}
	b = libc.Int32FromUint32(uc & libc.Uint32FromInt32(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))
	prev = *(*Tcolor)(unsafe.Pointer(t + uintptr(b)*2))
	*(*Tcolor)(unsafe.Pointer(t + uintptr(b)*2)) = int16(co)
	return prev
}

// C documentation
//
//	/*
//	 - maxcolor - report largest color number in use
//	 ^ static color maxcolor(struct colormap *);
//	 */
func _maxcolor(tls *libc.TLS, cm uintptr) (r Tcolor) {
	if (*Tvars)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fv)).Ferr != 0 {
		return int16(-libc.Int32FromInt32(1))
	}
	return libc.Int16FromUint64((*Tcolormap)(unsafe.Pointer(cm)).Fmax)
}

// C documentation
//
//	/*
//	 - newcolor - find a new color (must be subject of setcolor at once)
//	 * Beware: may relocate the colordescs.
//	 ^ static color newcolor(struct colormap *);
//	 */
func _newcolor(tls *libc.TLS, cm uintptr) (r Tcolor) {
	var cd, newCd uintptr
	var n Tsize_t
	var v1, v2 int32
	_, _, _, _, _ = cd, n, newCd, v1, v2
	if (*Tvars)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fv)).Ferr != 0 {
		return int16(-libc.Int32FromInt32(1))
	}
	if int32((*Tcolormap)(unsafe.Pointer(cm)).Ffree) != 0 {
		cd = (*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr((*Tcolormap)(unsafe.Pointer(cm)).Ffree)*32
		(*Tcolormap)(unsafe.Pointer(cm)).Ffree = (*Tcolordesc)(unsafe.Pointer(cd)).Fsub
	} else {
		if (*Tcolormap)(unsafe.Pointer(cm)).Fmax < (*Tcolormap)(unsafe.Pointer(cm)).Fncds-uint64(1) {
			(*Tcolormap)(unsafe.Pointer(cm)).Fmax++
			cd = (*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr((*Tcolormap)(unsafe.Pointer(cm)).Fmax)*32
		} else {
			/*
			 * Oops, must allocate more.
			 */
			if (*Tcolormap)(unsafe.Pointer(cm)).Fmax == uint64(SHRT_MAX) {
				(*Tvars)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fv)).Fnexttype = int32('e')
				if (*Tvars)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fv)).Ferr != 0 {
					v1 = (*Tvars)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fv)).Ferr
				} else {
					v1 = int32(REG_ECOLORS)
				}
				(*Tvars)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fv)).Ferr = v1
				return int16(-libc.Int32FromInt32(1)) /* too many colors */
			}
			n = (*Tcolormap)(unsafe.Pointer(cm)).Fncds * uint64(2)
			if n > libc.Uint64FromInt32(libc.Int32FromInt32(SHRT_MAX)+libc.Int32FromInt32(1)) {
				n = libc.Uint64FromInt32(libc.Int32FromInt32(SHRT_MAX) + libc.Int32FromInt32(1))
			}
			if (*Tcolormap)(unsafe.Pointer(cm)).Fcd == cm+48 {
				newCd = XTclpAlloc(tls, n*uint64(32))
				if newCd != libc.UintptrFromInt32(0) {
					libc.Xmemcpy(tls, newCd, cm+48, (*Tcolormap)(unsafe.Pointer(cm)).Fncds*uint64(32))
				}
			} else {
				newCd = XTclpRealloc(tls, (*Tcolormap)(unsafe.Pointer(cm)).Fcd, n*uint64(32))
			}
			if newCd == libc.UintptrFromInt32(0) {
				(*Tvars)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fv)).Fnexttype = int32('e')
				if (*Tvars)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fv)).Ferr != 0 {
					v2 = (*Tvars)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fv)).Ferr
				} else {
					v2 = int32(REG_ESPACE)
				}
				(*Tvars)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fv)).Ferr = v2
				return int16(-libc.Int32FromInt32(1))
			}
			(*Tcolormap)(unsafe.Pointer(cm)).Fcd = newCd
			(*Tcolormap)(unsafe.Pointer(cm)).Fncds = n
			(*Tcolormap)(unsafe.Pointer(cm)).Fmax++
			cd = (*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr((*Tcolormap)(unsafe.Pointer(cm)).Fmax)*32
		}
	}
	(*Tcolordesc)(unsafe.Pointer(cd)).Fnchrs = uint32(0)
	(*Tcolordesc)(unsafe.Pointer(cd)).Fsub = int16(-libc.Int32FromInt32(1))
	(*Tcolordesc)(unsafe.Pointer(cd)).Farcs = libc.UintptrFromInt32(0)
	(*Tcolordesc)(unsafe.Pointer(cd)).Fflags = 0
	(*Tcolordesc)(unsafe.Pointer(cd)).Fblock = libc.UintptrFromInt32(0)
	return int16((int64(cd) - int64((*Tcolormap)(unsafe.Pointer(cm)).Fcd)) / 32)
}

// C documentation
//
//	/*
//	 - freecolor - free a color (must have no arcs or subcolor)
//	 ^ static void freecolor(struct colormap *, pcolor);
//	 */
func _freecolor(tls *libc.TLS, cm uintptr, co Tpcolor) {
	var cd uintptr
	var nco, pco Tcolor
	_, _, _ = cd, nco, pco
	cd = (*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr(co)*32 /* for freelist scan */
	if co == WHITE {
		return
	}
	(*Tcolordesc)(unsafe.Pointer(cd)).Fflags = int32(FREECOL)
	if (*Tcolordesc)(unsafe.Pointer(cd)).Fblock != libc.UintptrFromInt32(0) {
		XTclpFree(tls, (*Tcolordesc)(unsafe.Pointer(cd)).Fblock)
		(*Tcolordesc)(unsafe.Pointer(cd)).Fblock = libc.UintptrFromInt32(0) /* just paranoia */
	}
	if libc.Uint64FromInt32(co) == (*Tcolormap)(unsafe.Pointer(cm)).Fmax {
		for (*Tcolormap)(unsafe.Pointer(cm)).Fmax > uint64(WHITE) && (*Tcolordesc)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fcd+uintptr((*Tcolormap)(unsafe.Pointer(cm)).Fmax)*32)).Fflags&int32(FREECOL) != 0 {
			(*Tcolormap)(unsafe.Pointer(cm)).Fmax--
		}
		for libc.Uint64FromInt16((*Tcolormap)(unsafe.Pointer(cm)).Ffree) > (*Tcolormap)(unsafe.Pointer(cm)).Fmax {
			(*Tcolormap)(unsafe.Pointer(cm)).Ffree = (*(*Tcolordesc)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr((*Tcolormap)(unsafe.Pointer(cm)).Ffree)*32))).Fsub
		}
		if int32((*Tcolormap)(unsafe.Pointer(cm)).Ffree) > 0 {
			pco = (*Tcolormap)(unsafe.Pointer(cm)).Ffree
			nco = (*(*Tcolordesc)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr(pco)*32))).Fsub
			for int32(nco) > 0 {
				if libc.Uint64FromInt16(nco) > (*Tcolormap)(unsafe.Pointer(cm)).Fmax {
					/*
					 * Take this one out of freelist.
					 */
					nco = (*(*Tcolordesc)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr(nco)*32))).Fsub
					(*(*Tcolordesc)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr(pco)*32))).Fsub = nco
				} else {
					pco = nco
					nco = (*(*Tcolordesc)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr(pco)*32))).Fsub
				}
			}
		}
	} else {
		(*Tcolordesc)(unsafe.Pointer(cd)).Fsub = (*Tcolormap)(unsafe.Pointer(cm)).Ffree
		(*Tcolormap)(unsafe.Pointer(cm)).Ffree = int16((int64(cd) - int64((*Tcolormap)(unsafe.Pointer(cm)).Fcd)) / 32)
	}
}

// C documentation
//
//	/*
//	 - pseudocolor - allocate a false color, to be managed by other means
//	 ^ static color pseudocolor(struct colormap *);
//	 */
func _pseudocolor(tls *libc.TLS, cm uintptr) (r Tcolor) {
	var co Tcolor
	_ = co
	co = _newcolor(tls, cm)
	if (*Tvars)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fv)).Ferr != 0 {
		return int16(-libc.Int32FromInt32(1))
	}
	(*(*Tcolordesc)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr(co)*32))).Fnchrs = uint32(1)
	(*(*Tcolordesc)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr(co)*32))).Fflags = int32(PSEUDO)
	return co
}

// C documentation
//
//	/*
//	 - subcolor - allocate a new subcolor (if necessary) to this chr
//	 ^ static color subcolor(struct colormap *, pchr c);
//	 */
func _subcolor(tls *libc.TLS, cm uintptr, c Tpchr) (r Tcolor) {
	var co, sco Tcolor
	_, _ = co, sco /* new subcolor */
	co = *(*Tcolor)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(cm + 368 + uintptr(c>>(libc.Int32FromInt32(3)*libc.Int32FromInt32(BYTBITS))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))*8)) + uintptr(c>>(libc.Int32FromInt32(2)*libc.Int32FromInt32(BYTBITS))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))*8)) + uintptr(c>>libc.Int32FromInt32(BYTBITS)&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))*8)) + uintptr(c&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))*2))
	sco = _newsub(tls, cm, int32(co))
	if (*Tvars)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fv)).Ferr != 0 {
		return int16(-libc.Int32FromInt32(1))
	}
	if int32(co) == int32(sco) { /* already in an open subcolor */
		return co /* rest is redundant */
	}
	(*(*Tcolordesc)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr(co)*32))).Fnchrs--
	(*(*Tcolordesc)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr(sco)*32))).Fnchrs++
	_setcolor(tls, cm, c, int32(sco))
	return sco
}

// C documentation
//
//	/*
//	 - newsub - allocate a new subcolor (if necessary) for a color
//	 ^ static color newsub(struct colormap *, pcolor);
//	 */
func _newsub(tls *libc.TLS, cm uintptr, co Tpcolor) (r Tcolor) {
	var sco Tcolor
	_ = sco /* new subcolor */
	sco = (*(*Tcolordesc)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr(co)*32))).Fsub
	if int32(sco) == -int32(1) { /* color has no open subcolor */
		if (*(*Tcolordesc)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr(co)*32))).Fnchrs == uint32(1) { /* optimization */
			return int16(co)
		}
		sco = _newcolor(tls, cm) /* must create subcolor */
		if int32(sco) == -int32(1) {
			return int16(-libc.Int32FromInt32(1))
		}
		(*(*Tcolordesc)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr(co)*32))).Fsub = sco
		(*(*Tcolordesc)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr(sco)*32))).Fsub = sco /* open subcolor points to self */
	}
	return sco
}

// C documentation
//
//	/*
//	 - subrange - allocate new subcolors to this range of chrs, fill in arcs
//	 ^ static void subrange(struct vars *, pchr, pchr, struct state *,
//	 ^	struct state *);
//	 */
func _subrange(tls *libc.TLS, v uintptr, from Tpchr, to Tpchr, lp uintptr, rp uintptr) {
	var i int32
	var uf Tuchr
	_, _ = i, uf
	/*
	 * First, align "from" on a tree-block boundary
	 */
	uf = libc.Uint32FromInt32(from)
	i = libc.Int32FromUint32((uf+libc.Uint32FromInt32(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS))-libc.Uint32FromInt32(1))&libc.Uint32FromInt32(^(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1))) - uf)
	for {
		if !(from <= to && i > 0) {
			break
		}
		_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('p'), int32(_subcolor(tls, (*Tvars)(unsafe.Pointer(v)).Fcm, from)), lp, rp)
		goto _1
	_1:
		;
		i--
		from++
	}
	if from > to { /* didn't reach a boundary */
		return
	}
	/*
	 * Deal with whole blocks.
	 */
	for {
		if !(to-from >= libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)) {
			break
		}
		_subblock(tls, v, from, lp, rp)
		goto _2
	_2:
		;
		from += libc.Int32FromInt32(1) << libc.Int32FromInt32(BYTBITS)
	}
	/*
	 * Clean up any remaining partial table.
	 */
	for {
		if !(from <= to) {
			break
		}
		_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('p'), int32(_subcolor(tls, (*Tvars)(unsafe.Pointer(v)).Fcm, from)), lp, rp)
		goto _3
	_3:
		;
		from++
	}
}

// C documentation
//
//	/*
//	 - subblock - allocate new subcolors for one tree block of chrs, fill in arcs
//	 ^ static void subblock(struct vars *, pchr, struct state *, struct state *);
//	 */
func _subblock(tls *libc.TLS, v uintptr, start Tpchr, lp uintptr, rp uintptr) {
	var b, i, level, ndone, previ, shift, v2, v3, v5 int32
	var cb, cm, fillt, lastt, t uintptr
	var co, sco Tcolor
	var uc Tuchr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = b, cb, cm, co, fillt, i, lastt, level, ndone, previ, sco, shift, t, uc, v2, v3, v5
	uc = libc.Uint32FromInt32(start)
	cm = (*Tvars)(unsafe.Pointer(v)).Fcm
	/*
	 * Find its color block, making new pointer blocks as needed.
	 */
	t = cm + 368
	fillt = libc.UintptrFromInt32(0)
	level = 0
	shift = libc.Int32FromInt32(BYTBITS) * ((libc.Int32FromInt32(CHRBITS)+libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1))/libc.Int32FromInt32(BYTBITS) - libc.Int32FromInt32(1))
	for {
		if !(shift > 0) {
			break
		}
		b = libc.Int32FromUint32(uc >> shift & libc.Uint32FromInt32(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))
		lastt = t
		t = *(*uintptr)(unsafe.Pointer(lastt + uintptr(b)*8))
		fillt = cm + 368 + uintptr(level+int32(1))*2048
		if t == fillt && shift > int32(BYTBITS) { /* need new ptr block */
			t = XTclpAlloc(tls, uint64(2048))
			if t == libc.UintptrFromInt32(0) {
				(*Tvars)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fv)).Fnexttype = int32('e')
				if (*Tvars)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fv)).Ferr != 0 {
					v2 = (*Tvars)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fv)).Ferr
				} else {
					v2 = int32(REG_ESPACE)
				}
				(*Tvars)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fv)).Ferr = v2
				return
			}
			libc.Xmemcpy(tls, t, fillt, libc.Uint64FromInt32(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS))*libc.Uint64FromInt64(8))
			*(*uintptr)(unsafe.Pointer(lastt + uintptr(b)*8)) = t
		}
		goto _1
	_1:
		;
		level++
		shift -= int32(BYTBITS)
	}
	/*
	 * Special cases: fill block or solid block.
	 */
	co = *(*Tcolor)(unsafe.Pointer(t))
	cb = (*(*Tcolordesc)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr(co)*32))).Fblock
	if t == fillt || t == cb {
		/*
		 * Either way, we want a subcolor solid block.
		 */
		sco = _newsub(tls, cm, int32(co))
		t = (*(*Tcolordesc)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr(sco)*32))).Fblock
		if t == libc.UintptrFromInt32(0) { /* must set it up */
			t = XTclpAlloc(tls, uint64(512))
			if t == libc.UintptrFromInt32(0) {
				(*Tvars)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fv)).Fnexttype = int32('e')
				if (*Tvars)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fv)).Ferr != 0 {
					v3 = (*Tvars)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fv)).Ferr
				} else {
					v3 = int32(REG_ESPACE)
				}
				(*Tvars)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fv)).Ferr = v3
				return
			}
			i = 0
			for {
				if !(i < libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)) {
					break
				}
				*(*Tcolor)(unsafe.Pointer(t + uintptr(i)*2)) = sco
				goto _4
			_4:
				;
				i++
			}
			(*(*Tcolordesc)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr(sco)*32))).Fblock = t
		}
		/*
		 * Find loop must have run at least once.
		 */
		*(*uintptr)(unsafe.Pointer(lastt + uintptr(b)*8)) = t
		_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('p'), int32(sco), lp, rp)
		(*(*Tcolordesc)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr(co)*32))).Fnchrs -= libc.Uint32FromInt32(libc.Int32FromInt32(1) << libc.Int32FromInt32(BYTBITS))
		(*(*Tcolordesc)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr(sco)*32))).Fnchrs += libc.Uint32FromInt32(libc.Int32FromInt32(1) << libc.Int32FromInt32(BYTBITS))
		return
	}
	/*
	 * General case, a mixed block to be altered.
	 */
	i = 0
	for i < libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS) {
		co = *(*Tcolor)(unsafe.Pointer(t + uintptr(i)*2))
		sco = _newsub(tls, cm, int32(co))
		_newarc(tls, (*Tvars)(unsafe.Pointer(v)).Fnfa, int32('p'), int32(sco), lp, rp)
		previ = i
		for cond := true; cond; cond = i < libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS) && int32(*(*Tcolor)(unsafe.Pointer(t + uintptr(i)*2))) == int32(co) {
			v5 = i
			i++
			*(*Tcolor)(unsafe.Pointer(t + uintptr(v5)*2)) = sco
		}
		ndone = i - previ
		(*(*Tcolordesc)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr(co)*32))).Fnchrs -= libc.Uint32FromInt32(ndone)
		(*(*Tcolordesc)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr(sco)*32))).Fnchrs += libc.Uint32FromInt32(ndone)
	}
}

// C documentation
//
//	/*
//	 - okcolors - promote subcolors to full colors
//	 ^ static void okcolors(struct nfa *, struct colormap *);
//	 */
func _okcolors(tls *libc.TLS, nfa uintptr, cm uintptr) {
	var a, cd, end, scd, v2 uintptr
	var co, sco Tcolor
	_, _, _, _, _, _, _ = a, cd, co, end, scd, sco, v2
	end = (*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr((*Tcolormap)(unsafe.Pointer(cm)).Fmax+uint64(1))*32
	cd = (*Tcolormap)(unsafe.Pointer(cm)).Fcd
	co = libc.Int16FromInt32(0)
	for {
		if !(cd < end) {
			break
		}
		sco = (*Tcolordesc)(unsafe.Pointer(cd)).Fsub
		if (*Tcolordesc)(unsafe.Pointer(cd)).Fflags&int32(FREECOL) != 0 || int32(sco) == -int32(1) {
			/*
			 * Has no subcolor, no further action.
			 */
		} else {
			if int32(sco) == int32(co) {
				/*
				 * Is subcolor, let parent deal with it.
				 */
			} else {
				if (*Tcolordesc)(unsafe.Pointer(cd)).Fnchrs == uint32(0) {
					/*
					 * Parent empty, its arcs change color to subcolor.
					 */
					(*Tcolordesc)(unsafe.Pointer(cd)).Fsub = int16(-libc.Int32FromInt32(1))
					scd = (*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr(sco)*32
					(*Tcolordesc)(unsafe.Pointer(scd)).Fsub = int16(-libc.Int32FromInt32(1))
					for {
						v2 = (*Tcolordesc)(unsafe.Pointer(cd)).Farcs
						a = v2
						if !(v2 != libc.UintptrFromInt32(0)) {
							break
						}
						_uncolorchain(tls, cm, a)
						(*Tarc)(unsafe.Pointer(a)).Fco = sco
						_colorchain(tls, cm, a)
					}
					_freecolor(tls, cm, int32(co))
				} else {
					/*
					 * Parent's arcs must gain parallel subcolor arcs.
					 */
					(*Tcolordesc)(unsafe.Pointer(cd)).Fsub = int16(-libc.Int32FromInt32(1))
					scd = (*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr(sco)*32
					(*Tcolordesc)(unsafe.Pointer(scd)).Fsub = int16(-libc.Int32FromInt32(1))
					a = (*Tcolordesc)(unsafe.Pointer(cd)).Farcs
					for {
						if !(a != libc.UintptrFromInt32(0)) {
							break
						}
						_newarc(tls, nfa, (*Tarc)(unsafe.Pointer(a)).Ftype1, int32(sco), (*Tarc)(unsafe.Pointer(a)).Ffrom, (*Tarc)(unsafe.Pointer(a)).Fto)
						goto _3
					_3:
						;
						a = (*Tarc)(unsafe.Pointer(a)).Fcolorchain
					}
				}
			}
		}
		goto _1
	_1:
		;
		cd += 32
		co++
	}
}

// C documentation
//
//	/*
//	 - colorchain - add this arc to the color chain of its color
//	 ^ static void colorchain(struct colormap *, struct arc *);
//	 */
func _colorchain(tls *libc.TLS, cm uintptr, a uintptr) {
	var cd uintptr
	_ = cd
	cd = (*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr((*Tarc)(unsafe.Pointer(a)).Fco)*32
	if (*Tcolordesc)(unsafe.Pointer(cd)).Farcs != libc.UintptrFromInt32(0) {
		(*Tarc)(unsafe.Pointer((*Tcolordesc)(unsafe.Pointer(cd)).Farcs)).FcolorchainRev = a
	}
	(*Tarc)(unsafe.Pointer(a)).Fcolorchain = (*Tcolordesc)(unsafe.Pointer(cd)).Farcs
	(*Tarc)(unsafe.Pointer(a)).FcolorchainRev = libc.UintptrFromInt32(0)
	(*Tcolordesc)(unsafe.Pointer(cd)).Farcs = a
}

// C documentation
//
//	/*
//	 - uncolorchain - delete this arc from the color chain of its color
//	 ^ static void uncolorchain(struct colormap *, struct arc *);
//	 */
func _uncolorchain(tls *libc.TLS, cm uintptr, a uintptr) {
	var aa, cd uintptr
	_, _ = aa, cd
	cd = (*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr((*Tarc)(unsafe.Pointer(a)).Fco)*32
	aa = (*Tarc)(unsafe.Pointer(a)).FcolorchainRev
	if aa == libc.UintptrFromInt32(0) {
		(*Tcolordesc)(unsafe.Pointer(cd)).Farcs = (*Tarc)(unsafe.Pointer(a)).Fcolorchain
	} else {
		(*Tarc)(unsafe.Pointer(aa)).Fcolorchain = (*Tarc)(unsafe.Pointer(a)).Fcolorchain
	}
	if (*Tarc)(unsafe.Pointer(a)).Fcolorchain != libc.UintptrFromInt32(0) {
		(*Tarc)(unsafe.Pointer((*Tarc)(unsafe.Pointer(a)).Fcolorchain)).FcolorchainRev = aa
	}
	(*Tarc)(unsafe.Pointer(a)).Fcolorchain = libc.UintptrFromInt32(0) /* paranoia */
	(*Tarc)(unsafe.Pointer(a)).FcolorchainRev = libc.UintptrFromInt32(0)
}

// C documentation
//
//	/*
//	 - rainbow - add arcs of all full colors (but one) between specified states
//	 ^ static void rainbow(struct nfa *, struct colormap *, int, pcolor,
//	 ^	struct state *, struct state *);
//	 */
func _rainbow(tls *libc.TLS, nfa uintptr, cm uintptr, type1 int32, but Tpcolor, from uintptr, to uintptr) {
	var cd, end uintptr
	var co Tcolor
	_, _, _ = cd, co, end
	end = (*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr((*Tcolormap)(unsafe.Pointer(cm)).Fmax+uint64(1))*32
	cd = (*Tcolormap)(unsafe.Pointer(cm)).Fcd
	co = libc.Int16FromInt32(0)
	for {
		if !(cd < end && !((*Tvars)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fv)).Ferr != libc.Int32FromInt32(0))) {
			break
		}
		if !((*Tcolordesc)(unsafe.Pointer(cd)).Fflags&libc.Int32FromInt32(FREECOL) != 0) && int32((*Tcolordesc)(unsafe.Pointer(cd)).Fsub) != int32(co) && int32(co) != but && !((*Tcolordesc)(unsafe.Pointer(cd)).Fflags&libc.Int32FromInt32(PSEUDO) != 0) {
			_newarc(tls, nfa, type1, int32(co), from, to)
		}
		goto _1
	_1:
		;
		cd += 32
		co++
	}
}

// C documentation
//
//	/*
//	 - colorcomplement - add arcs of complementary colors
//	 * The calling sequence ought to be reconciled with cloneouts().
//	 ^ static void colorcomplement(struct nfa *, struct colormap *, int,
//	 ^	struct state *, struct state *, struct state *);
//	 */
func _colorcomplement(tls *libc.TLS, nfa uintptr, cm uintptr, type1 int32, of uintptr, from uintptr, to uintptr) {
	var cd, end uintptr
	var co Tcolor
	_, _, _ = cd, co, end
	end = (*Tcolormap)(unsafe.Pointer(cm)).Fcd + uintptr((*Tcolormap)(unsafe.Pointer(cm)).Fmax+uint64(1))*32
	cd = (*Tcolormap)(unsafe.Pointer(cm)).Fcd
	co = libc.Int16FromInt32(0)
	for {
		if !(cd < end && !((*Tvars)(unsafe.Pointer((*Tcolormap)(unsafe.Pointer(cm)).Fv)).Ferr != libc.Int32FromInt32(0))) {
			break
		}
		if !((*Tcolordesc)(unsafe.Pointer(cd)).Fflags&libc.Int32FromInt32(FREECOL) != 0) && !((*Tcolordesc)(unsafe.Pointer(cd)).Fflags&libc.Int32FromInt32(PSEUDO) != 0) {
			if _findarc(tls, of, int32('p'), int32(co)) == libc.UintptrFromInt32(0) {
				_newarc(tls, nfa, type1, int32(co), from, to)
			}
		}
		goto _1
	_1:
		;
		cd += 32
		co++
	}
}

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */
/*
 * NFA utilities.
 * This file is #included by regcomp.c.
 *
 * Copyright © 1998, 1999 Henry Spencer. All rights reserved.
 *
 * Development of this software was funded, in part, by Cray Research Inc.,
 * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
 * Corporation, none of whom are responsible for the results. The author
 * thanks all of them.
 *
 * Redistribution and use in source and binary forms -- with or without
 * modification -- are permitted for any purpose, provided that
 * redistributions in source form retain this entire copyright notice and
 * indicate the origin and nature of any modifications.
 *
 * I'd appreciate being given credit for this package in the documentation of
 * software which uses it, but that is not a requirement.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
 * HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * One or two things that technically ought to be in here are actually in
 * color.c, thanks to some incestuous relationships in the color chains.
 */

// C documentation
//
//	/*
//	 - newnfa - set up an NFA
//	 ^ static struct nfa *newnfa(struct vars *, struct colormap *, struct nfa *);
//	 */
func _newnfa(tls *libc.TLS, v uintptr, cm uintptr, parent uintptr) (r uintptr) {
	/* NULL if primary NFA */
	var nfa uintptr
	var v1 int32
	var v2, v3 Tcolor
	_, _, _, _ = nfa, v1, v2, v3
	nfa = XTclpAlloc(tls, uint64(96))
	if nfa == libc.UintptrFromInt32(0) {
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			v1 = (*Tvars)(unsafe.Pointer(v)).Ferr
		} else {
			v1 = int32(REG_ESPACE)
		}
		(*Tvars)(unsafe.Pointer(v)).Ferr = v1
		return libc.UintptrFromInt32(0)
	}
	(*Tnfa)(unsafe.Pointer(nfa)).Fstates = libc.UintptrFromInt32(0)
	(*Tnfa)(unsafe.Pointer(nfa)).Fslast = libc.UintptrFromInt32(0)
	(*Tnfa)(unsafe.Pointer(nfa)).Ffree = libc.UintptrFromInt32(0)
	(*Tnfa)(unsafe.Pointer(nfa)).Fnstates = uint64(0)
	(*Tnfa)(unsafe.Pointer(nfa)).Fcm = cm
	(*Tnfa)(unsafe.Pointer(nfa)).Fv = v
	v2 = int16(-libc.Int32FromInt32(1))
	*(*Tcolor)(unsafe.Pointer(nfa + 72 + 1*2)) = v2
	*(*Tcolor)(unsafe.Pointer(nfa + 72)) = v2
	v3 = int16(-libc.Int32FromInt32(1))
	*(*Tcolor)(unsafe.Pointer(nfa + 76 + 1*2)) = v3
	*(*Tcolor)(unsafe.Pointer(nfa + 76)) = v3
	(*Tnfa)(unsafe.Pointer(nfa)).Fparent = parent                         /* Precedes newfstate so parent is valid. */
	(*Tnfa)(unsafe.Pointer(nfa)).Fpost = _newfstate(tls, nfa, int32('@')) /* number 0 */
	(*Tnfa)(unsafe.Pointer(nfa)).Fpre = _newfstate(tls, nfa, int32('>'))  /* number 1 */
	(*Tnfa)(unsafe.Pointer(nfa)).Finit1 = _newstate(tls, nfa)             /* May become invalid later. */
	(*Tnfa)(unsafe.Pointer(nfa)).Ffinal = _newstate(tls, nfa)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		_freenfa(tls, nfa)
		return libc.UintptrFromInt32(0)
	}
	_rainbow(tls, nfa, (*Tnfa)(unsafe.Pointer(nfa)).Fcm, int32('p'), -libc.Int32FromInt32(1), (*Tnfa)(unsafe.Pointer(nfa)).Fpre, (*Tnfa)(unsafe.Pointer(nfa)).Finit1)
	_newarc(tls, nfa, int32('^'), int32(1), (*Tnfa)(unsafe.Pointer(nfa)).Fpre, (*Tnfa)(unsafe.Pointer(nfa)).Finit1)
	_newarc(tls, nfa, int32('^'), 0, (*Tnfa)(unsafe.Pointer(nfa)).Fpre, (*Tnfa)(unsafe.Pointer(nfa)).Finit1)
	_rainbow(tls, nfa, (*Tnfa)(unsafe.Pointer(nfa)).Fcm, int32('p'), -libc.Int32FromInt32(1), (*Tnfa)(unsafe.Pointer(nfa)).Ffinal, (*Tnfa)(unsafe.Pointer(nfa)).Fpost)
	_newarc(tls, nfa, int32('$'), int32(1), (*Tnfa)(unsafe.Pointer(nfa)).Ffinal, (*Tnfa)(unsafe.Pointer(nfa)).Fpost)
	_newarc(tls, nfa, int32('$'), 0, (*Tnfa)(unsafe.Pointer(nfa)).Ffinal, (*Tnfa)(unsafe.Pointer(nfa)).Fpost)
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		_freenfa(tls, nfa)
		return libc.UintptrFromInt32(0)
	}
	return nfa
}

// C documentation
//
//	/*
//	 - freenfa - free an entire NFA
//	 ^ static void freenfa(struct nfa *);
//	 */
func _freenfa(tls *libc.TLS, nfa uintptr) {
	var s, v1, v3 uintptr
	var v2 Tsize_t
	_, _, _, _ = s, v1, v2, v3
	for {
		v1 = (*Tnfa)(unsafe.Pointer(nfa)).Fstates
		s = v1
		if !(v1 != libc.UintptrFromInt32(0)) {
			break
		}
		v2 = libc.Uint64FromInt32(0)
		(*Tstate)(unsafe.Pointer(s)).Fnouts = v2
		(*Tstate)(unsafe.Pointer(s)).Fnins = v2 /* don't worry about arcs */
		_freestate(tls, nfa, s)
	}
	for {
		v3 = (*Tnfa)(unsafe.Pointer(nfa)).Ffree
		s = v3
		if !(v3 != libc.UintptrFromInt32(0)) {
			break
		}
		(*Tnfa)(unsafe.Pointer(nfa)).Ffree = (*Tstate)(unsafe.Pointer(s)).Fnext
		_destroystate(tls, nfa, s)
	}
	(*Tnfa)(unsafe.Pointer(nfa)).Fslast = libc.UintptrFromInt32(0)
	(*Tnfa)(unsafe.Pointer(nfa)).Fnstates = libc.Uint64FromInt32(-libc.Int32FromInt32(1))
	(*Tnfa)(unsafe.Pointer(nfa)).Fpre = libc.UintptrFromInt32(0)
	(*Tnfa)(unsafe.Pointer(nfa)).Fpost = libc.UintptrFromInt32(0)
	XTclpFree(tls, nfa)
}

// C documentation
//
//	/*
//	 - newstate - allocate an NFA state, with zero flag value
//	 ^ static struct state *newstate(struct nfa *);
//	 */
func _newstate(tls *libc.TLS, nfa uintptr) (r uintptr) {
	var s, v4 uintptr
	var v1, v2 int32
	var v3 Tsize_t
	_, _, _, _, _ = s, v1, v2, v3, v4
	if (*Tnfa)(unsafe.Pointer(nfa)).Ffree != libc.UintptrFromInt32(0) {
		s = (*Tnfa)(unsafe.Pointer(nfa)).Ffree
		(*Tnfa)(unsafe.Pointer(nfa)).Ffree = (*Tstate)(unsafe.Pointer(s)).Fnext
	} else {
		if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Fspaceused >= libc.Uint64FromInt32(100000)*libc.Uint64FromInt64(816)+libc.Uint64FromInt32(100000)*libc.Uint64FromInt64(728) {
			(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
				v1 = (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr
			} else {
				v1 = int32(REG_ETOOBIG)
			}
			(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr = v1
			return libc.UintptrFromInt32(0)
		}
		s = XTclpAlloc(tls, uint64(816))
		if s == libc.UintptrFromInt32(0) {
			(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
				v2 = (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr
			} else {
				v2 = int32(REG_ESPACE)
			}
			(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr = v2
			return libc.UintptrFromInt32(0)
		}
		*(*Tsize_t)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv + 272)) += uint64(816)
		(*Tstate)(unsafe.Pointer(s)).Foas.Fnext = libc.UintptrFromInt32(0)
		(*Tstate)(unsafe.Pointer(s)).Ffree = libc.UintptrFromInt32(0)
		(*Tstate)(unsafe.Pointer(s)).Fnoas = uint64(0)
	}
	v4 = nfa + 32
	v3 = *(*Tsize_t)(unsafe.Pointer(v4))
	*(*Tsize_t)(unsafe.Pointer(v4))++
	(*Tstate)(unsafe.Pointer(s)).Fno = v3
	(*Tstate)(unsafe.Pointer(s)).Fflag = uint8(0)
	if (*Tnfa)(unsafe.Pointer(nfa)).Fstates == libc.UintptrFromInt32(0) {
		(*Tnfa)(unsafe.Pointer(nfa)).Fstates = s
	}
	(*Tstate)(unsafe.Pointer(s)).Fnins = uint64(0)
	(*Tstate)(unsafe.Pointer(s)).Fins = libc.UintptrFromInt32(0)
	(*Tstate)(unsafe.Pointer(s)).Fnouts = uint64(0)
	(*Tstate)(unsafe.Pointer(s)).Fouts = libc.UintptrFromInt32(0)
	(*Tstate)(unsafe.Pointer(s)).Ftmp = libc.UintptrFromInt32(0)
	(*Tstate)(unsafe.Pointer(s)).Fnext = libc.UintptrFromInt32(0)
	if (*Tnfa)(unsafe.Pointer(nfa)).Fslast != libc.UintptrFromInt32(0) {
		(*Tstate)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fslast)).Fnext = s
	}
	(*Tstate)(unsafe.Pointer(s)).Fprev = (*Tnfa)(unsafe.Pointer(nfa)).Fslast
	(*Tnfa)(unsafe.Pointer(nfa)).Fslast = s
	return s
}

// C documentation
//
//	/*
//	 - newfstate - allocate an NFA state with a specified flag value
//	 ^ static struct state *newfstate(struct nfa *, int flag);
//	 */
func _newfstate(tls *libc.TLS, nfa uintptr, flag int32) (r uintptr) {
	var s uintptr
	_ = s
	s = _newstate(tls, nfa)
	if s != libc.UintptrFromInt32(0) {
		(*Tstate)(unsafe.Pointer(s)).Fflag = libc.Uint8FromInt32(flag)
	}
	return s
}

// C documentation
//
//	/*
//	 - dropstate - delete a state's inarcs and outarcs and free it
//	 ^ static void dropstate(struct nfa *, struct state *);
//	 */
func _dropstate(tls *libc.TLS, nfa uintptr, s uintptr) {
	var a, v1, v2 uintptr
	_, _, _ = a, v1, v2
	for {
		v1 = (*Tstate)(unsafe.Pointer(s)).Fins
		a = v1
		if !(v1 != libc.UintptrFromInt32(0)) {
			break
		}
		_freearc(tls, nfa, a)
	}
	for {
		v2 = (*Tstate)(unsafe.Pointer(s)).Fouts
		a = v2
		if !(v2 != libc.UintptrFromInt32(0)) {
			break
		}
		_freearc(tls, nfa, a)
	}
	_freestate(tls, nfa, s)
}

// C documentation
//
//	/*
//	 - freestate - free a state, which has no in-arcs or out-arcs
//	 ^ static void freestate(struct nfa *, struct state *);
//	 */
func _freestate(tls *libc.TLS, nfa uintptr, s uintptr) {
	(*Tstate)(unsafe.Pointer(s)).Fno = libc.Uint64FromInt32(-libc.Int32FromInt32(1))
	(*Tstate)(unsafe.Pointer(s)).Fflag = uint8(0)
	if (*Tstate)(unsafe.Pointer(s)).Fnext != libc.UintptrFromInt32(0) {
		(*Tstate)(unsafe.Pointer((*Tstate)(unsafe.Pointer(s)).Fnext)).Fprev = (*Tstate)(unsafe.Pointer(s)).Fprev
	} else {
		(*Tnfa)(unsafe.Pointer(nfa)).Fslast = (*Tstate)(unsafe.Pointer(s)).Fprev
	}
	if (*Tstate)(unsafe.Pointer(s)).Fprev != libc.UintptrFromInt32(0) {
		(*Tstate)(unsafe.Pointer((*Tstate)(unsafe.Pointer(s)).Fprev)).Fnext = (*Tstate)(unsafe.Pointer(s)).Fnext
	} else {
		(*Tnfa)(unsafe.Pointer(nfa)).Fstates = (*Tstate)(unsafe.Pointer(s)).Fnext
	}
	(*Tstate)(unsafe.Pointer(s)).Fprev = libc.UintptrFromInt32(0)
	(*Tstate)(unsafe.Pointer(s)).Fnext = (*Tnfa)(unsafe.Pointer(nfa)).Ffree /* don't delete it, put it on the free list */
	(*Tnfa)(unsafe.Pointer(nfa)).Ffree = s
}

// C documentation
//
//	/*
//	 - destroystate - really get rid of an already-freed state
//	 ^ static void destroystate(struct nfa *, struct state *);
//	 */
func _destroystate(tls *libc.TLS, nfa uintptr, s uintptr) {
	var ab, abnext uintptr
	_, _ = ab, abnext
	ab = (*Tstate)(unsafe.Pointer(s)).Foas.Fnext
	for {
		if !(ab != libc.UintptrFromInt32(0)) {
			break
		}
		abnext = (*Tarcbatch)(unsafe.Pointer(ab)).Fnext
		XTclpFree(tls, ab)
		*(*Tsize_t)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv + 272)) -= uint64(728)
		goto _1
	_1:
		;
		ab = abnext
	}
	(*Tstate)(unsafe.Pointer(s)).Fins = libc.UintptrFromInt32(0)
	(*Tstate)(unsafe.Pointer(s)).Fouts = libc.UintptrFromInt32(0)
	(*Tstate)(unsafe.Pointer(s)).Fnext = libc.UintptrFromInt32(0)
	XTclpFree(tls, s)
	*(*Tsize_t)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv + 272)) -= uint64(816)
}

// C documentation
//
//	/*
//	 - newarc - set up a new arc within an NFA
//	 ^ static void newarc(struct nfa *, int, pcolor, struct state *,
//	 ^	struct state *);
//	 */
//	/*
//	 * This function checks to make sure that no duplicate arcs are created.
//	 * In general we never want duplicates.
//	 */
func _newarc(tls *libc.TLS, nfa uintptr, t int32, co Tpcolor, from uintptr, to uintptr) {
	var a uintptr
	_ = a
	/* check for duplicate arc, using whichever chain is shorter */
	if (*Tstate)(unsafe.Pointer(from)).Fnouts <= (*Tstate)(unsafe.Pointer(to)).Fnins {
		a = (*Tstate)(unsafe.Pointer(from)).Fouts
		for {
			if !(a != libc.UintptrFromInt32(0)) {
				break
			}
			if (*Tarc)(unsafe.Pointer(a)).Fto == to && int32((*Tarc)(unsafe.Pointer(a)).Fco) == co && (*Tarc)(unsafe.Pointer(a)).Ftype1 == t {
				return
			}
			goto _1
		_1:
			;
			a = (*Tarc)(unsafe.Pointer(a)).Foutchain
		}
	} else {
		a = (*Tstate)(unsafe.Pointer(to)).Fins
		for {
			if !(a != libc.UintptrFromInt32(0)) {
				break
			}
			if (*Tarc)(unsafe.Pointer(a)).Ffrom == from && int32((*Tarc)(unsafe.Pointer(a)).Fco) == co && (*Tarc)(unsafe.Pointer(a)).Ftype1 == t {
				return
			}
			goto _2
		_2:
			;
			a = (*Tarc)(unsafe.Pointer(a)).Finchain
		}
	}
	/* no dup, so create the arc */
	_createarc(tls, nfa, t, co, from, to)
}

// C documentation
//
//	/*
//	 * createarc - create a new arc within an NFA
//	 *
//	 * This function must *only* be used after verifying that there is no existing
//	 * identical arc (same type/color/from/to).
//	 */
func _createarc(tls *libc.TLS, nfa uintptr, t int32, co Tpcolor, from uintptr, to uintptr) {
	var a uintptr
	_ = a
	/* the arc is physically allocated within its from-state */
	a = _allocarc(tls, nfa, from)
	if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
		return
	}
	(*Tarc)(unsafe.Pointer(a)).Ftype1 = t
	(*Tarc)(unsafe.Pointer(a)).Fco = int16(co)
	(*Tarc)(unsafe.Pointer(a)).Fto = to
	(*Tarc)(unsafe.Pointer(a)).Ffrom = from
	/*
	 * Put the new arc on the beginning, not the end, of the chains; it's
	 * simpler here, and freearc() is the same cost either way.  See also the
	 * logic in moveins() and its cohorts, as well as fixempties().
	 */
	(*Tarc)(unsafe.Pointer(a)).Finchain = (*Tstate)(unsafe.Pointer(to)).Fins
	(*Tarc)(unsafe.Pointer(a)).FinchainRev = libc.UintptrFromInt32(0)
	if (*Tstate)(unsafe.Pointer(to)).Fins != 0 {
		(*Tarc)(unsafe.Pointer((*Tstate)(unsafe.Pointer(to)).Fins)).FinchainRev = a
	}
	(*Tstate)(unsafe.Pointer(to)).Fins = a
	(*Tarc)(unsafe.Pointer(a)).Foutchain = (*Tstate)(unsafe.Pointer(from)).Fouts
	(*Tarc)(unsafe.Pointer(a)).FoutchainRev = libc.UintptrFromInt32(0)
	if (*Tstate)(unsafe.Pointer(from)).Fouts != 0 {
		(*Tarc)(unsafe.Pointer((*Tstate)(unsafe.Pointer(from)).Fouts)).FoutchainRev = a
	}
	(*Tstate)(unsafe.Pointer(from)).Fouts = a
	(*Tstate)(unsafe.Pointer(from)).Fnouts++
	(*Tstate)(unsafe.Pointer(to)).Fnins++
	if ((*Tarc)(unsafe.Pointer(a)).Ftype1 == int32('p') || (*Tarc)(unsafe.Pointer(a)).Ftype1 == int32('a') || (*Tarc)(unsafe.Pointer(a)).Ftype1 == int32('r')) && (*Tnfa)(unsafe.Pointer(nfa)).Fparent == libc.UintptrFromInt32(0) {
		_colorchain(tls, (*Tnfa)(unsafe.Pointer(nfa)).Fcm, a)
	}
}

// C documentation
//
//	/*
//	 - allocarc - allocate a new out-arc within a state
//	 ^ static struct arc *allocarc(struct nfa *, struct state *);
//	 */
func _allocarc(tls *libc.TLS, nfa uintptr, s uintptr) (r uintptr) {
	var a, newAb uintptr
	var i, v1, v2 int32
	_, _, _, _, _ = a, i, newAb, v1, v2
	/*
	 * Shortcut
	 */
	if (*Tstate)(unsafe.Pointer(s)).Ffree == libc.UintptrFromInt32(0) && (*Tstate)(unsafe.Pointer(s)).Fnoas < uint64(ABSIZE) {
		a = s + 80 + 8 + uintptr((*Tstate)(unsafe.Pointer(s)).Fnoas)*72
		(*Tstate)(unsafe.Pointer(s)).Fnoas++
		return a
	}
	/*
	 * if none at hand, get more
	 */
	if (*Tstate)(unsafe.Pointer(s)).Ffree == libc.UintptrFromInt32(0) {
		if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Fspaceused >= libc.Uint64FromInt32(100000)*libc.Uint64FromInt64(816)+libc.Uint64FromInt32(100000)*libc.Uint64FromInt64(728) {
			(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
				v1 = (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr
			} else {
				v1 = int32(REG_ETOOBIG)
			}
			(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr = v1
			return libc.UintptrFromInt32(0)
		}
		newAb = XTclpAlloc(tls, uint64(728))
		if newAb == libc.UintptrFromInt32(0) {
			(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
				v2 = (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr
			} else {
				v2 = int32(REG_ESPACE)
			}
			(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr = v2
			return libc.UintptrFromInt32(0)
		}
		*(*Tsize_t)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv + 272)) += uint64(728)
		(*Tarcbatch)(unsafe.Pointer(newAb)).Fnext = (*Tstate)(unsafe.Pointer(s)).Foas.Fnext
		(*Tstate)(unsafe.Pointer(s)).Foas.Fnext = newAb
		i = 0
		for {
			if !(i < int32(ABSIZE)) {
				break
			}
			(*(*Tarc)(unsafe.Pointer(newAb + 8 + uintptr(i)*72))).Ftype1 = 0
			(*(*Tarc)(unsafe.Pointer(newAb + 8 + uintptr(i)*72))).Foutchain = newAb + 8 + uintptr(i+int32(1))*72
			goto _3
		_3:
			;
			i++
		}
		(*(*Tarc)(unsafe.Pointer(newAb + 8 + uintptr(libc.Int32FromInt32(ABSIZE)-libc.Int32FromInt32(1))*72))).Foutchain = libc.UintptrFromInt32(0)
		(*Tstate)(unsafe.Pointer(s)).Ffree = newAb + 8
	}
	a = (*Tstate)(unsafe.Pointer(s)).Ffree
	(*Tstate)(unsafe.Pointer(s)).Ffree = (*Tarc)(unsafe.Pointer(a)).Foutchain
	return a
}

// C documentation
//
//	/*
//	 - freearc - free an arc
//	 ^ static void freearc(struct nfa *, struct arc *);
//	 */
func _freearc(tls *libc.TLS, nfa uintptr, victim uintptr) {
	var from, predecessor, to uintptr
	_, _, _ = from, predecessor, to
	from = (*Tarc)(unsafe.Pointer(victim)).Ffrom
	to = (*Tarc)(unsafe.Pointer(victim)).Fto
	/*
	 * Take it off color chain if necessary.
	 */
	if ((*Tarc)(unsafe.Pointer(victim)).Ftype1 == int32('p') || (*Tarc)(unsafe.Pointer(victim)).Ftype1 == int32('a') || (*Tarc)(unsafe.Pointer(victim)).Ftype1 == int32('r')) && (*Tnfa)(unsafe.Pointer(nfa)).Fparent == libc.UintptrFromInt32(0) {
		_uncolorchain(tls, (*Tnfa)(unsafe.Pointer(nfa)).Fcm, victim)
	}
	/*
	 * Take it off source's out-chain.
	 */
	predecessor = (*Tarc)(unsafe.Pointer(victim)).FoutchainRev
	if predecessor == libc.UintptrFromInt32(0) {
		(*Tstate)(unsafe.Pointer(from)).Fouts = (*Tarc)(unsafe.Pointer(victim)).Foutchain
	} else {
		(*Tarc)(unsafe.Pointer(predecessor)).Foutchain = (*Tarc)(unsafe.Pointer(victim)).Foutchain
	}
	if (*Tarc)(unsafe.Pointer(victim)).Foutchain != libc.UintptrFromInt32(0) {
		(*Tarc)(unsafe.Pointer((*Tarc)(unsafe.Pointer(victim)).Foutchain)).FoutchainRev = predecessor
	}
	(*Tstate)(unsafe.Pointer(from)).Fnouts--
	/*
	 * Take it off target's in-chain.
	 */
	predecessor = (*Tarc)(unsafe.Pointer(victim)).FinchainRev
	if predecessor == libc.UintptrFromInt32(0) {
		(*Tstate)(unsafe.Pointer(to)).Fins = (*Tarc)(unsafe.Pointer(victim)).Finchain
	} else {
		(*Tarc)(unsafe.Pointer(predecessor)).Finchain = (*Tarc)(unsafe.Pointer(victim)).Finchain
	}
	if (*Tarc)(unsafe.Pointer(victim)).Finchain != libc.UintptrFromInt32(0) {
		(*Tarc)(unsafe.Pointer((*Tarc)(unsafe.Pointer(victim)).Finchain)).FinchainRev = predecessor
	}
	(*Tstate)(unsafe.Pointer(to)).Fnins--
	/*
	 * Clean up and place on from-state's free list.
	 */
	(*Tarc)(unsafe.Pointer(victim)).Ftype1 = 0
	(*Tarc)(unsafe.Pointer(victim)).Ffrom = libc.UintptrFromInt32(0) /* precautions... */
	(*Tarc)(unsafe.Pointer(victim)).Fto = libc.UintptrFromInt32(0)
	(*Tarc)(unsafe.Pointer(victim)).Finchain = libc.UintptrFromInt32(0)
	(*Tarc)(unsafe.Pointer(victim)).FinchainRev = libc.UintptrFromInt32(0)
	(*Tarc)(unsafe.Pointer(victim)).Foutchain = libc.UintptrFromInt32(0)
	(*Tarc)(unsafe.Pointer(victim)).FoutchainRev = libc.UintptrFromInt32(0)
	(*Tarc)(unsafe.Pointer(victim)).Foutchain = (*Tstate)(unsafe.Pointer(from)).Ffree
	(*Tstate)(unsafe.Pointer(from)).Ffree = victim
}

// C documentation
//
//	/*
//	 * changearctarget - flip an arc to have a different to state
//	 *
//	 * Caller must have verified that there is no preexisting duplicate arc.
//	 *
//	 * Note that because we store arcs in their from state, we can't easily have
//	 * a similar changearcsource function.
//	 */
func _changearctarget(tls *libc.TLS, a uintptr, newto uintptr) {
	var oldto, predecessor uintptr
	_, _ = oldto, predecessor
	oldto = (*Tarc)(unsafe.Pointer(a)).Fto
	/* take it off old target's in-chain */
	predecessor = (*Tarc)(unsafe.Pointer(a)).FinchainRev
	if predecessor == libc.UintptrFromInt32(0) {
		(*Tstate)(unsafe.Pointer(oldto)).Fins = (*Tarc)(unsafe.Pointer(a)).Finchain
	} else {
		(*Tarc)(unsafe.Pointer(predecessor)).Finchain = (*Tarc)(unsafe.Pointer(a)).Finchain
	}
	if (*Tarc)(unsafe.Pointer(a)).Finchain != libc.UintptrFromInt32(0) {
		(*Tarc)(unsafe.Pointer((*Tarc)(unsafe.Pointer(a)).Finchain)).FinchainRev = predecessor
	}
	(*Tstate)(unsafe.Pointer(oldto)).Fnins--
	(*Tarc)(unsafe.Pointer(a)).Fto = newto
	/* prepend it to new target's in-chain */
	(*Tarc)(unsafe.Pointer(a)).Finchain = (*Tstate)(unsafe.Pointer(newto)).Fins
	(*Tarc)(unsafe.Pointer(a)).FinchainRev = libc.UintptrFromInt32(0)
	if (*Tstate)(unsafe.Pointer(newto)).Fins != 0 {
		(*Tarc)(unsafe.Pointer((*Tstate)(unsafe.Pointer(newto)).Fins)).FinchainRev = a
	}
	(*Tstate)(unsafe.Pointer(newto)).Fins = a
	(*Tstate)(unsafe.Pointer(newto)).Fnins++
}

// C documentation
//
//	/*
//	 - hasnonemptyout - Does state have a non-EMPTY out arc?
//	 ^ static int hasnonemptyout(struct state *);
//	 */
func _hasnonemptyout(tls *libc.TLS, s uintptr) (r int32) {
	var a uintptr
	_ = a
	a = (*Tstate)(unsafe.Pointer(s)).Fouts
	for {
		if !(a != libc.UintptrFromInt32(0)) {
			break
		}
		if (*Tarc)(unsafe.Pointer(a)).Ftype1 != int32('n') {
			return int32(1)
		}
		goto _1
	_1:
		;
		a = (*Tarc)(unsafe.Pointer(a)).Foutchain
	}
	return 0
}

// C documentation
//
//	/*
//	 - findarc - find arc, if any, from given source with given type and color
//	 * If there is more than one such arc, the result is random.
//	 ^ static struct arc *findarc(struct state *, int, pcolor);
//	 */
func _findarc(tls *libc.TLS, s uintptr, type1 int32, co Tpcolor) (r uintptr) {
	var a uintptr
	_ = a
	a = (*Tstate)(unsafe.Pointer(s)).Fouts
	for {
		if !(a != libc.UintptrFromInt32(0)) {
			break
		}
		if (*Tarc)(unsafe.Pointer(a)).Ftype1 == type1 && int32((*Tarc)(unsafe.Pointer(a)).Fco) == co {
			return a
		}
		goto _1
	_1:
		;
		a = (*Tarc)(unsafe.Pointer(a)).Foutchain
	}
	return libc.UintptrFromInt32(0)
}

// C documentation
//
//	/*
//	 - cparc - allocate a new arc within an NFA, copying details from old one
//	 ^ static void cparc(struct nfa *, struct arc *, struct state *,
//	 ^	struct state *);
//	 */
func _cparc(tls *libc.TLS, nfa uintptr, oa uintptr, from uintptr, to uintptr) {
	_newarc(tls, nfa, (*Tarc)(unsafe.Pointer(oa)).Ftype1, int32((*Tarc)(unsafe.Pointer(oa)).Fco), from, to)
}

// C documentation
//
//	/*
//	 * sortins - sort the in arcs of a state by from/color/type
//	 */
func _sortins(tls *libc.TLS, nfa uintptr, s uintptr) {
	var a, sortarray uintptr
	var i, n, v1, v3 int32
	_, _, _, _, _, _ = a, i, n, sortarray, v1, v3
	n = libc.Int32FromUint64((*Tstate)(unsafe.Pointer(s)).Fnins)
	if n <= int32(1) {
		return /* nothing to do */
	}
	/* make an array of arc pointers ... */
	sortarray = XTclpAlloc(tls, libc.Uint64FromInt32(n)*uint64(8))
	if sortarray == libc.UintptrFromInt32(0) {
		(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Fnexttype = int32('e')
		if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
			v1 = (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr
		} else {
			v1 = int32(REG_ESPACE)
		}
		(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr = v1
		return
	}
	i = 0
	a = (*Tstate)(unsafe.Pointer(s)).Fins
	for {
		if !(a != libc.UintptrFromInt32(0)) {
			break
		}
		v3 = i
		i++
		*(*uintptr)(unsafe.Pointer(sortarray + uintptr(v3)*8)) = a
		goto _2
	_2:
		;
		a = (*Tarc)(unsafe.Pointer(a)).Finchain
	}
	/* ... sort the array */
	libc.Xqsort(tls, sortarray, libc.Uint64FromInt32(n), uint64(8), __ccgo_fp(_sortins_cmp))
	/* ... and rebuild arc list in order */
	/* it seems worth special-casing first and last items to simplify loop */
	a = *(*uintptr)(unsafe.Pointer(sortarray))
	(*Tstate)(unsafe.Pointer(s)).Fins = a
	(*Tarc)(unsafe.Pointer(a)).Finchain = *(*uintptr)(unsafe.Pointer(sortarray + 1*8))
	(*Tarc)(unsafe.Pointer(a)).FinchainRev = libc.UintptrFromInt32(0)
	i = int32(1)
	for {
		if !(i < n-int32(1)) {
			break
		}
		a = *(*uintptr)(unsafe.Pointer(sortarray + uintptr(i)*8))
		(*Tarc)(unsafe.Pointer(a)).Finchain = *(*uintptr)(unsafe.Pointer(sortarray + uintptr(i+int32(1))*8))
		(*Tarc)(unsafe.Pointer(a)).FinchainRev = *(*uintptr)(unsafe.Pointer(sortarray + uintptr(i-int32(1))*8))
		goto _4
	_4:
		;
		i++
	}
	a = *(*uintptr)(unsafe.Pointer(sortarray + uintptr(i)*8))
	(*Tarc)(unsafe.Pointer(a)).Finchain = libc.UintptrFromInt32(0)
	(*Tarc)(unsafe.Pointer(a)).FinchainRev = *(*uintptr)(unsafe.Pointer(sortarray + uintptr(i-int32(1))*8))
	XTclpFree(tls, sortarray)
}

func _sortins_cmp(tls *libc.TLS, a uintptr, b uintptr) (r int32) {
	var aa, bb uintptr
	_, _ = aa, bb
	aa = *(*uintptr)(unsafe.Pointer(a))
	bb = *(*uintptr)(unsafe.Pointer(b))
	/* we check the fields in the order they are most likely to be different */
	if (*Tstate)(unsafe.Pointer((*Tarc)(unsafe.Pointer(aa)).Ffrom)).Fno < (*Tstate)(unsafe.Pointer((*Tarc)(unsafe.Pointer(bb)).Ffrom)).Fno {
		return -int32(1)
	}
	if (*Tstate)(unsafe.Pointer((*Tarc)(unsafe.Pointer(aa)).Ffrom)).Fno > (*Tstate)(unsafe.Pointer((*Tarc)(unsafe.Pointer(bb)).Ffrom)).Fno {
		return int32(1)
	}
	if int32((*Tarc)(unsafe.Pointer(aa)).Fco) < int32((*Tarc)(unsafe.Pointer(bb)).Fco) {
		return -int32(1)
	}
	if int32((*Tarc)(unsafe.Pointer(aa)).Fco) > int32((*Tarc)(unsafe.Pointer(bb)).Fco) {
		return int32(1)
	}
	if (*Tarc)(unsafe.Pointer(aa)).Ftype1 < (*Tarc)(unsafe.Pointer(bb)).Ftype1 {
		return -int32(1)
	}
	if (*Tarc)(unsafe.Pointer(aa)).Ftype1 > (*Tarc)(unsafe.Pointer(bb)).Ftype1 {
		return int32(1)
	}
	return 0
}

// C documentation
//
//	/*
//	 * sortouts - sort the out arcs of a state by to/color/type
//	 */
func _sortouts(tls *libc.TLS, nfa uintptr, s uintptr) {
	var a, sortarray uintptr
	var i, n, v1, v3 int32
	_, _, _, _, _, _ = a, i, n, sortarray, v1, v3
	n = libc.Int32FromUint64((*Tstate)(unsafe.Pointer(s)).Fnouts)
	if n <= int32(1) {
		return /* nothing to do */
	}
	/* make an array of arc pointers ... */
	sortarray = XTclpAlloc(tls, libc.Uint64FromInt32(n)*uint64(8))
	if sortarray == libc.UintptrFromInt32(0) {
		(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Fnexttype = int32('e')
		if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
			v1 = (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr
		} else {
			v1 = int32(REG_ESPACE)
		}
		(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr = v1
		return
	}
	i = 0
	a = (*Tstate)(unsafe.Pointer(s)).Fouts
	for {
		if !(a != libc.UintptrFromInt32(0)) {
			break
		}
		v3 = i
		i++
		*(*uintptr)(unsafe.Pointer(sortarray + uintptr(v3)*8)) = a
		goto _2
	_2:
		;
		a = (*Tarc)(unsafe.Pointer(a)).Foutchain
	}
	/* ... sort the array */
	libc.Xqsort(tls, sortarray, libc.Uint64FromInt32(n), uint64(8), __ccgo_fp(_sortouts_cmp))
	/* ... and rebuild arc list in order */
	/* it seems worth special-casing first and last items to simplify loop */
	a = *(*uintptr)(unsafe.Pointer(sortarray))
	(*Tstate)(unsafe.Pointer(s)).Fouts = a
	(*Tarc)(unsafe.Pointer(a)).Foutchain = *(*uintptr)(unsafe.Pointer(sortarray + 1*8))
	(*Tarc)(unsafe.Pointer(a)).FoutchainRev = libc.UintptrFromInt32(0)
	i = int32(1)
	for {
		if !(i < n-int32(1)) {
			break
		}
		a = *(*uintptr)(unsafe.Pointer(sortarray + uintptr(i)*8))
		(*Tarc)(unsafe.Pointer(a)).Foutchain = *(*uintptr)(unsafe.Pointer(sortarray + uintptr(i+int32(1))*8))
		(*Tarc)(unsafe.Pointer(a)).FoutchainRev = *(*uintptr)(unsafe.Pointer(sortarray + uintptr(i-int32(1))*8))
		goto _4
	_4:
		;
		i++
	}
	a = *(*uintptr)(unsafe.Pointer(sortarray + uintptr(i)*8))
	(*Tarc)(unsafe.Pointer(a)).Foutchain = libc.UintptrFromInt32(0)
	(*Tarc)(unsafe.Pointer(a)).FoutchainRev = *(*uintptr)(unsafe.Pointer(sortarray + uintptr(i-int32(1))*8))
	XTclpFree(tls, sortarray)
}

func _sortouts_cmp(tls *libc.TLS, a uintptr, b uintptr) (r int32) {
	var aa, bb uintptr
	_, _ = aa, bb
	aa = *(*uintptr)(unsafe.Pointer(a))
	bb = *(*uintptr)(unsafe.Pointer(b))
	/* we check the fields in the order they are most likely to be different */
	if (*Tstate)(unsafe.Pointer((*Tarc)(unsafe.Pointer(aa)).Fto)).Fno < (*Tstate)(unsafe.Pointer((*Tarc)(unsafe.Pointer(bb)).Fto)).Fno {
		return -int32(1)
	}
	if (*Tstate)(unsafe.Pointer((*Tarc)(unsafe.Pointer(aa)).Fto)).Fno > (*Tstate)(unsafe.Pointer((*Tarc)(unsafe.Pointer(bb)).Fto)).Fno {
		return int32(1)
	}
	if int32((*Tarc)(unsafe.Pointer(aa)).Fco) < int32((*Tarc)(unsafe.Pointer(bb)).Fco) {
		return -int32(1)
	}
	if int32((*Tarc)(unsafe.Pointer(aa)).Fco) > int32((*Tarc)(unsafe.Pointer(bb)).Fco) {
		return int32(1)
	}
	if (*Tarc)(unsafe.Pointer(aa)).Ftype1 < (*Tarc)(unsafe.Pointer(bb)).Ftype1 {
		return -int32(1)
	}
	if (*Tarc)(unsafe.Pointer(aa)).Ftype1 > (*Tarc)(unsafe.Pointer(bb)).Ftype1 {
		return int32(1)
	}
	return 0
}

/*
 * Common decision logic about whether to use arc-by-arc operations or
 * sort/merge.  If there's just a few source arcs we cannot recoup the
 * cost of sorting the destination arc list, no matter how large it is.
 * Otherwise, limit the number of arc-by-arc comparisons to about 1000
 * (a somewhat arbitrary choice, but the breakeven point would probably
 * be machine dependent anyway).
 */

// C documentation
//
//	/*
//	 - moveins - move all in arcs of a state to another state
//	 * You might think this could be done better by just updating the
//	 * existing arcs, and you would be right if it weren't for the need
//	 * for duplicate suppression, which makes it easier to just make new
//	 * ones to exploit the suppression built into newarc.
//	 *
//	 * However, if we have a whole lot of arcs to deal with, retail duplicate
//	 * checks become too slow.  In that case we proceed by sorting and merging
//	 * the arc lists, and then we can indeed just update the arcs in-place.
//	 *
//	 ^ static void moveins(struct nfa *, struct state *, struct state *);
//	 */
func _moveins(tls *libc.TLS, nfa uintptr, oldState uintptr, newState uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var a, a1, a2, v2 uintptr
	var v1, v3 int32
	var _ /* na at bp+8 */ uintptr
	var _ /* oa at bp+0 */ uintptr
	_, _, _, _, _, _ = a, a1, a2, v1, v2, v3
	if (*Tstate)(unsafe.Pointer(oldState)).Fnins < uint64(4) {
		v1 = 0
	} else {
		v1 = libc.BoolInt32((*Tstate)(unsafe.Pointer(oldState)).Fnins > uint64(32) || (*Tstate)(unsafe.Pointer(newState)).Fnins > uint64(32))
	}
	if !(v1 != 0) {
		for {
			v2 = (*Tstate)(unsafe.Pointer(oldState)).Fins
			a = v2
			if !(v2 != libc.UintptrFromInt32(0)) {
				break
			}
			_cparc(tls, nfa, a, (*Tarc)(unsafe.Pointer(a)).Ffrom, newState)
			_freearc(tls, nfa, a)
		}
	} else {
		/*
		 * Because we bypass newarc() in this code path, we'd better include a
		 * cancel check.
		 */
		if 0 != 0 {
			(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
				v3 = (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr
			} else {
				v3 = int32(REG_CANCEL)
			}
			(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr = v3
			return
		}
		_sortins(tls, nfa, oldState)
		_sortins(tls, nfa, newState)
		if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
			return /* might have failed to sort */
		}
		*(*uintptr)(unsafe.Pointer(bp)) = (*Tstate)(unsafe.Pointer(oldState)).Fins
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tstate)(unsafe.Pointer(newState)).Fins
		for *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) && *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) {
			a1 = *(*uintptr)(unsafe.Pointer(bp))
			switch _sortins_cmp(tls, bp, bp+8) {
			case -int32(1):
				/* newState does not have anything matching oa */
				*(*uintptr)(unsafe.Pointer(bp)) = (*Tarc)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Finchain
				/*
				 * Rather than doing createarc+freearc, we can just unlink
				 * and relink the existing arc struct.
				 */
				_changearctarget(tls, a1, newState)
			case 0:
				/* match, advance in both lists */
				*(*uintptr)(unsafe.Pointer(bp)) = (*Tarc)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Finchain
				*(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tarc)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Finchain
				/* ... and drop duplicate arc from oldState */
				_freearc(tls, nfa, a1)
			case +libc.Int32FromInt32(1):
				/* advance only na; oa might have a match later */
				*(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tarc)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Finchain
			default:
			}
		}
		for *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
			/* newState does not have anything matching oa */
			a2 = *(*uintptr)(unsafe.Pointer(bp))
			*(*uintptr)(unsafe.Pointer(bp)) = (*Tarc)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Finchain
			_changearctarget(tls, a2, newState)
		}
	}
}

// C documentation
//
//	/*
//	 - copyins - copy in arcs of a state to another state
//	 ^ static void copyins(struct nfa *, struct state *, struct state *, int);
//	 */
func _copyins(tls *libc.TLS, nfa uintptr, oldState uintptr, newState uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var a, a1, a2 uintptr
	var v1, v3 int32
	var _ /* na at bp+8 */ uintptr
	var _ /* oa at bp+0 */ uintptr
	_, _, _, _, _ = a, a1, a2, v1, v3
	if (*Tstate)(unsafe.Pointer(oldState)).Fnins < uint64(4) {
		v1 = 0
	} else {
		v1 = libc.BoolInt32((*Tstate)(unsafe.Pointer(oldState)).Fnins > uint64(32) || (*Tstate)(unsafe.Pointer(newState)).Fnins > uint64(32))
	}
	if !(v1 != 0) {
		a = (*Tstate)(unsafe.Pointer(oldState)).Fins
		for {
			if !(a != libc.UintptrFromInt32(0)) {
				break
			}
			_cparc(tls, nfa, a, (*Tarc)(unsafe.Pointer(a)).Ffrom, newState)
			goto _2
		_2:
			;
			a = (*Tarc)(unsafe.Pointer(a)).Finchain
		}
	} else {
		/*
		 * Because we bypass newarc() in this code path, we'd better include a
		 * cancel check.
		 */
		if 0 != 0 {
			(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
				v3 = (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr
			} else {
				v3 = int32(REG_CANCEL)
			}
			(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr = v3
			return
		}
		_sortins(tls, nfa, oldState)
		_sortins(tls, nfa, newState)
		if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
			return /* might have failed to sort */
		}
		*(*uintptr)(unsafe.Pointer(bp)) = (*Tstate)(unsafe.Pointer(oldState)).Fins
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tstate)(unsafe.Pointer(newState)).Fins
		for *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) && *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) {
			a1 = *(*uintptr)(unsafe.Pointer(bp))
			switch _sortins_cmp(tls, bp, bp+8) {
			case -int32(1):
				/* newState does not have anything matching oa */
				*(*uintptr)(unsafe.Pointer(bp)) = (*Tarc)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Finchain
				_createarc(tls, nfa, (*Tarc)(unsafe.Pointer(a1)).Ftype1, int32((*Tarc)(unsafe.Pointer(a1)).Fco), (*Tarc)(unsafe.Pointer(a1)).Ffrom, newState)
			case 0:
				/* match, advance in both lists */
				*(*uintptr)(unsafe.Pointer(bp)) = (*Tarc)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Finchain
				*(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tarc)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Finchain
			case +libc.Int32FromInt32(1):
				/* advance only na; oa might have a match later */
				*(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tarc)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Finchain
			default:
			}
		}
		for *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
			/* newState does not have anything matching oa */
			a2 = *(*uintptr)(unsafe.Pointer(bp))
			*(*uintptr)(unsafe.Pointer(bp)) = (*Tarc)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Finchain
			_createarc(tls, nfa, (*Tarc)(unsafe.Pointer(a2)).Ftype1, int32((*Tarc)(unsafe.Pointer(a2)).Fco), (*Tarc)(unsafe.Pointer(a2)).Ffrom, newState)
		}
	}
}

// C documentation
//
//	/*
//	 * mergeins - merge a list of inarcs into a state
//	 *
//	 * This is much like copyins, but the source arcs are listed in an array,
//	 * and are not guaranteed unique.  It's okay to clobber the array contents.
//	 */
func _mergeins(tls *libc.TLS, nfa uintptr, s uintptr, arcarray uintptr, arccount int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var a1 uintptr
	var i, j, v1, v3 int32
	var _ /* a at bp+8 */ uintptr
	var _ /* na at bp+0 */ uintptr
	_, _, _, _, _ = a1, i, j, v1, v3
	if arccount <= 0 {
		return
	}
	/*
	 * Because we bypass newarc() in this code path, we'd better include a
	 * cancel check.
	 */
	if 0 != 0 {
		(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Fnexttype = int32('e')
		if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
			v1 = (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr
		} else {
			v1 = int32(REG_CANCEL)
		}
		(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr = v1
		return
	}
	/* Sort existing inarcs as well as proposed new ones */
	_sortins(tls, nfa, s)
	if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
		return /* might have failed to sort */
	}
	libc.Xqsort(tls, arcarray, libc.Uint64FromInt32(arccount), uint64(8), __ccgo_fp(_sortins_cmp))
	/*
	 * arcarray very likely includes dups, so we must eliminate them.  (This
	 * could be folded into the next loop, but it's not worth the trouble.)
	 */
	j = 0
	i = int32(1)
	for {
		if !(i < arccount) {
			break
		}
		switch _sortins_cmp(tls, arcarray+uintptr(j)*8, arcarray+uintptr(i)*8) {
		case -int32(1):
			/* non-dup */
			j++
			v3 = j
			*(*uintptr)(unsafe.Pointer(arcarray + uintptr(v3)*8)) = *(*uintptr)(unsafe.Pointer(arcarray + uintptr(i)*8))
		case 0:
			/* dup */
		default:
			/* trouble */
		}
		goto _2
	_2:
		;
		i++
	}
	arccount = j + int32(1)
	/*
	 * Now merge into s' inchain.  Note that createarc() will put new arcs
	 * onto the front of s's chain, so it does not break our walk through the
	 * sorted part of the chain.
	 */
	i = 0
	*(*uintptr)(unsafe.Pointer(bp)) = (*Tstate)(unsafe.Pointer(s)).Fins
	for i < arccount && *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(arcarray + uintptr(i)*8))
		switch _sortins_cmp(tls, bp+8, bp) {
		case -int32(1):
			/* s does not have anything matching a */
			_createarc(tls, nfa, (*Tarc)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Ftype1, int32((*Tarc)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fco), (*Tarc)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Ffrom, s)
			i++
		case 0:
			/* match, advance in both lists */
			i++
			*(*uintptr)(unsafe.Pointer(bp)) = (*Tarc)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Finchain
		case +libc.Int32FromInt32(1):
			/* advance only na; array might have a match later */
			*(*uintptr)(unsafe.Pointer(bp)) = (*Tarc)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Finchain
		default:
		}
	}
	for i < arccount {
		/* s does not have anything matching a */
		a1 = *(*uintptr)(unsafe.Pointer(arcarray + uintptr(i)*8))
		_createarc(tls, nfa, (*Tarc)(unsafe.Pointer(a1)).Ftype1, int32((*Tarc)(unsafe.Pointer(a1)).Fco), (*Tarc)(unsafe.Pointer(a1)).Ffrom, s)
		i++
	}
}

// C documentation
//
//	/*
//	 - moveouts - move all out arcs of a state to another state
//	 ^ static void moveouts(struct nfa *, struct state *, struct state *);
//	 */
func _moveouts(tls *libc.TLS, nfa uintptr, oldState uintptr, newState uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var a, a1, a2, v2 uintptr
	var v1, v3 int32
	var _ /* na at bp+8 */ uintptr
	var _ /* oa at bp+0 */ uintptr
	_, _, _, _, _, _ = a, a1, a2, v1, v2, v3
	if (*Tstate)(unsafe.Pointer(oldState)).Fnouts < uint64(4) {
		v1 = 0
	} else {
		v1 = libc.BoolInt32((*Tstate)(unsafe.Pointer(oldState)).Fnouts > uint64(32) || (*Tstate)(unsafe.Pointer(newState)).Fnouts > uint64(32))
	}
	if !(v1 != 0) {
		for {
			v2 = (*Tstate)(unsafe.Pointer(oldState)).Fouts
			a = v2
			if !(v2 != libc.UintptrFromInt32(0)) {
				break
			}
			_cparc(tls, nfa, a, newState, (*Tarc)(unsafe.Pointer(a)).Fto)
			_freearc(tls, nfa, a)
		}
	} else {
		/*
		 * Because we bypass newarc() in this code path, we'd better include a
		 * cancel check.
		 */
		if 0 != 0 {
			(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
				v3 = (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr
			} else {
				v3 = int32(REG_CANCEL)
			}
			(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr = v3
			return
		}
		_sortouts(tls, nfa, oldState)
		_sortouts(tls, nfa, newState)
		if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
			return /* might have failed to sort */
		}
		*(*uintptr)(unsafe.Pointer(bp)) = (*Tstate)(unsafe.Pointer(oldState)).Fouts
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tstate)(unsafe.Pointer(newState)).Fouts
		for *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) && *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) {
			a1 = *(*uintptr)(unsafe.Pointer(bp))
			switch _sortouts_cmp(tls, bp, bp+8) {
			case -int32(1):
				/* newState does not have anything matching oa */
				*(*uintptr)(unsafe.Pointer(bp)) = (*Tarc)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Foutchain
				_createarc(tls, nfa, (*Tarc)(unsafe.Pointer(a1)).Ftype1, int32((*Tarc)(unsafe.Pointer(a1)).Fco), newState, (*Tarc)(unsafe.Pointer(a1)).Fto)
				_freearc(tls, nfa, a1)
			case 0:
				/* match, advance in both lists */
				*(*uintptr)(unsafe.Pointer(bp)) = (*Tarc)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Foutchain
				*(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tarc)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Foutchain
				/* ... and drop duplicate arc from oldState */
				_freearc(tls, nfa, a1)
			case +libc.Int32FromInt32(1):
				/* advance only na; oa might have a match later */
				*(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tarc)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Foutchain
			default:
			}
		}
		for *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
			/* newState does not have anything matching oa */
			a2 = *(*uintptr)(unsafe.Pointer(bp))
			*(*uintptr)(unsafe.Pointer(bp)) = (*Tarc)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Foutchain
			_createarc(tls, nfa, (*Tarc)(unsafe.Pointer(a2)).Ftype1, int32((*Tarc)(unsafe.Pointer(a2)).Fco), newState, (*Tarc)(unsafe.Pointer(a2)).Fto)
			_freearc(tls, nfa, a2)
		}
	}
}

// C documentation
//
//	/*
//	 - copyouts - copy out arcs of a state to another state
//	 ^ static void copyouts(struct nfa *, struct state *, struct state *, int);
//	 */
func _copyouts(tls *libc.TLS, nfa uintptr, oldState uintptr, newState uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var a, a1, a2 uintptr
	var v1, v3 int32
	var _ /* na at bp+8 */ uintptr
	var _ /* oa at bp+0 */ uintptr
	_, _, _, _, _ = a, a1, a2, v1, v3
	if (*Tstate)(unsafe.Pointer(oldState)).Fnouts < uint64(4) {
		v1 = 0
	} else {
		v1 = libc.BoolInt32((*Tstate)(unsafe.Pointer(oldState)).Fnouts > uint64(32) || (*Tstate)(unsafe.Pointer(newState)).Fnouts > uint64(32))
	}
	if !(v1 != 0) {
		a = (*Tstate)(unsafe.Pointer(oldState)).Fouts
		for {
			if !(a != libc.UintptrFromInt32(0)) {
				break
			}
			_cparc(tls, nfa, a, newState, (*Tarc)(unsafe.Pointer(a)).Fto)
			goto _2
		_2:
			;
			a = (*Tarc)(unsafe.Pointer(a)).Foutchain
		}
	} else {
		/*
		 * Because we bypass newarc() in this code path, we'd better include a
		 * cancel check.
		 */
		if 0 != 0 {
			(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
				v3 = (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr
			} else {
				v3 = int32(REG_CANCEL)
			}
			(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr = v3
			return
		}
		_sortouts(tls, nfa, oldState)
		_sortouts(tls, nfa, newState)
		if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
			return /* might have failed to sort */
		}
		*(*uintptr)(unsafe.Pointer(bp)) = (*Tstate)(unsafe.Pointer(oldState)).Fouts
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tstate)(unsafe.Pointer(newState)).Fouts
		for *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) && *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) {
			a1 = *(*uintptr)(unsafe.Pointer(bp))
			switch _sortouts_cmp(tls, bp, bp+8) {
			case -int32(1):
				/* newState does not have anything matching oa */
				*(*uintptr)(unsafe.Pointer(bp)) = (*Tarc)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Foutchain
				_createarc(tls, nfa, (*Tarc)(unsafe.Pointer(a1)).Ftype1, int32((*Tarc)(unsafe.Pointer(a1)).Fco), newState, (*Tarc)(unsafe.Pointer(a1)).Fto)
			case 0:
				/* match, advance in both lists */
				*(*uintptr)(unsafe.Pointer(bp)) = (*Tarc)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Foutchain
				*(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tarc)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Foutchain
			case +libc.Int32FromInt32(1):
				/* advance only na; oa might have a match later */
				*(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tarc)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Foutchain
			default:
			}
		}
		for *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
			/* newState does not have anything matching oa */
			a2 = *(*uintptr)(unsafe.Pointer(bp))
			*(*uintptr)(unsafe.Pointer(bp)) = (*Tarc)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Foutchain
			_createarc(tls, nfa, (*Tarc)(unsafe.Pointer(a2)).Ftype1, int32((*Tarc)(unsafe.Pointer(a2)).Fco), newState, (*Tarc)(unsafe.Pointer(a2)).Fto)
		}
	}
}

// C documentation
//
//	/*
//	 - cloneouts - copy out arcs of a state to another state pair, modifying type
//	 ^ static void cloneouts(struct nfa *, struct state *, struct state *,
//	 ^	struct state *, int);
//	 */
func _cloneouts(tls *libc.TLS, nfa uintptr, old uintptr, from uintptr, to uintptr, type1 int32) {
	var a uintptr
	_ = a
	a = (*Tstate)(unsafe.Pointer(old)).Fouts
	for {
		if !(a != libc.UintptrFromInt32(0)) {
			break
		}
		_newarc(tls, nfa, type1, int32((*Tarc)(unsafe.Pointer(a)).Fco), from, to)
		goto _1
	_1:
		;
		a = (*Tarc)(unsafe.Pointer(a)).Foutchain
	}
}

// C documentation
//
//	/*
//	 - delsub - delete a sub-NFA, updating subre pointers if necessary
//	 * This uses a recursive traversal of the sub-NFA, marking already-seen
//	 * states using their tmp pointer.
//	 ^ static void delsub(struct nfa *, struct state *, struct state *);
//	 */
func _delsub(tls *libc.TLS, nfa uintptr, lp uintptr, rp uintptr) {
	/* ...to here, *not* inclusive */
	(*Tstate)(unsafe.Pointer(rp)).Ftmp = rp /* mark end */
	_deltraverse(tls, nfa, lp, lp)
	/* did the job */
	/* no more */
	(*Tstate)(unsafe.Pointer(rp)).Ftmp = libc.UintptrFromInt32(0) /* unmark end */
	(*Tstate)(unsafe.Pointer(lp)).Ftmp = libc.UintptrFromInt32(0) /* and begin, marked by deltraverse */
}

// C documentation
//
//	/*
//	 - deltraverse - the recursive heart of delsub
//	 * This routine's basic job is to destroy all out-arcs of the state.
//	 ^ static void deltraverse(struct nfa *, struct state *, struct state *);
//	 */
func _deltraverse(tls *libc.TLS, nfa uintptr, leftend uintptr, s uintptr) {
	var a, to, v1 uintptr
	_, _, _ = a, to, v1
	if (*Tstate)(unsafe.Pointer(s)).Fnouts == uint64(0) {
		return /* nothing to do */
	}
	if (*Tstate)(unsafe.Pointer(s)).Ftmp != libc.UintptrFromInt32(0) {
		return /* already in progress */
	}
	(*Tstate)(unsafe.Pointer(s)).Ftmp = s /* mark as in progress */
	for {
		v1 = (*Tstate)(unsafe.Pointer(s)).Fouts
		a = v1
		if !(v1 != libc.UintptrFromInt32(0)) {
			break
		}
		to = (*Tarc)(unsafe.Pointer(a)).Fto
		_deltraverse(tls, nfa, leftend, to)
		_freearc(tls, nfa, a)
		if (*Tstate)(unsafe.Pointer(to)).Fnins == uint64(0) && (*Tstate)(unsafe.Pointer(to)).Ftmp == libc.UintptrFromInt32(0) {
			_freestate(tls, nfa, to)
		}
	}
	/* we're still here */
	/* and still reachable */
	/* but have no outarcs */
	(*Tstate)(unsafe.Pointer(s)).Ftmp = libc.UintptrFromInt32(0) /* we're done here */
}

// C documentation
//
//	/*
//	 - dupnfa - duplicate sub-NFA
//	 * Another recursive traversal, this time using tmp to point to duplicates as
//	 * well as mark already-seen states. (You knew there was a reason why it's a
//	 * state pointer, didn't you? :-))
//	 ^ static void dupnfa(struct nfa *, struct state *, struct state *,
//	 ^	struct state *, struct state *);
//	 */
func _dupnfa(tls *libc.TLS, nfa uintptr, start uintptr, stop uintptr, from uintptr, to uintptr) {
	/* to here */
	if start == stop {
		_newarc(tls, nfa, int32('n'), 0, from, to)
		return
	}
	(*Tstate)(unsafe.Pointer(stop)).Ftmp = to
	_duptraverse(tls, nfa, start, from, 0)
	/* done, except for clearing out the tmp pointers */
	(*Tstate)(unsafe.Pointer(stop)).Ftmp = libc.UintptrFromInt32(0)
	_cleartraverse(tls, nfa, start)
}

// C documentation
//
//	/*
//	 - duptraverse - recursive heart of dupnfa
//	 ^ static void duptraverse(struct nfa *, struct state *, struct state *);
//	 */
func _duptraverse(tls *libc.TLS, nfa uintptr, s uintptr, stmp uintptr, depth int32) {
	var a, v1 uintptr
	var v2, v3 int32
	_, _, _, _ = a, v1, v2, v3
	if (*Tstate)(unsafe.Pointer(s)).Ftmp != libc.UintptrFromInt32(0) {
		return /* already done */
	}
	if stmp == libc.UintptrFromInt32(0) {
		v1 = _newstate(tls, nfa)
	} else {
		v1 = stmp
	}
	(*Tstate)(unsafe.Pointer(s)).Ftmp = v1
	if (*Tstate)(unsafe.Pointer(s)).Ftmp == libc.UintptrFromInt32(0) {
		return
	}
	/*
	 * Arbitrary depth limit. Needs tuning, but this value is sufficient to
	 * make all normal tests (not reg-33.14) pass.
	 */
	v2 = depth
	depth++
	if v2 > int32(DUPTRAVERSE_MAX_DEPTH) {
		(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Fnexttype = int32('e')
		if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
			v3 = (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr
		} else {
			v3 = int32(REG_ESPACE)
		}
		(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr = v3
	}
	a = (*Tstate)(unsafe.Pointer(s)).Fouts
	for {
		if !(a != libc.UintptrFromInt32(0) && !((*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != libc.Int32FromInt32(0))) {
			break
		}
		_duptraverse(tls, nfa, (*Tarc)(unsafe.Pointer(a)).Fto, libc.UintptrFromInt32(0), depth)
		if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
			break
		}
		_cparc(tls, nfa, a, (*Tstate)(unsafe.Pointer(s)).Ftmp, (*Tstate)(unsafe.Pointer((*Tarc)(unsafe.Pointer(a)).Fto)).Ftmp)
		goto _4
	_4:
		;
		a = (*Tarc)(unsafe.Pointer(a)).Foutchain
	}
}

// C documentation
//
//	/*
//	 - cleartraverse - recursive cleanup for algorithms that leave tmp ptrs set
//	 ^ static void cleartraverse(struct nfa *, struct state *);
//	 */
func _cleartraverse(tls *libc.TLS, nfa uintptr, s uintptr) {
	var a uintptr
	_ = a
	if (*Tstate)(unsafe.Pointer(s)).Ftmp == libc.UintptrFromInt32(0) {
		return
	}
	(*Tstate)(unsafe.Pointer(s)).Ftmp = libc.UintptrFromInt32(0)
	a = (*Tstate)(unsafe.Pointer(s)).Fouts
	for {
		if !(a != libc.UintptrFromInt32(0)) {
			break
		}
		_cleartraverse(tls, nfa, (*Tarc)(unsafe.Pointer(a)).Fto)
		goto _1
	_1:
		;
		a = (*Tarc)(unsafe.Pointer(a)).Foutchain
	}
}

// C documentation
//
//	/*
//	 - specialcolors - fill in special colors for an NFA
//	 ^ static void specialcolors(struct nfa *);
//	 */
func _specialcolors(tls *libc.TLS, nfa uintptr) {
	/*
	 * False colors for BOS, BOL, EOS, EOL
	 */
	if (*Tnfa)(unsafe.Pointer(nfa)).Fparent == libc.UintptrFromInt32(0) {
		*(*Tcolor)(unsafe.Pointer(nfa + 72)) = _pseudocolor(tls, (*Tnfa)(unsafe.Pointer(nfa)).Fcm)
		*(*Tcolor)(unsafe.Pointer(nfa + 72 + 1*2)) = _pseudocolor(tls, (*Tnfa)(unsafe.Pointer(nfa)).Fcm)
		*(*Tcolor)(unsafe.Pointer(nfa + 76)) = _pseudocolor(tls, (*Tnfa)(unsafe.Pointer(nfa)).Fcm)
		*(*Tcolor)(unsafe.Pointer(nfa + 76 + 1*2)) = _pseudocolor(tls, (*Tnfa)(unsafe.Pointer(nfa)).Fcm)
	} else {
		*(*Tcolor)(unsafe.Pointer(nfa + 72)) = *(*Tcolor)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fparent + 72))
		*(*Tcolor)(unsafe.Pointer(nfa + 72 + 1*2)) = *(*Tcolor)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fparent + 72 + 1*2))
		*(*Tcolor)(unsafe.Pointer(nfa + 76)) = *(*Tcolor)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fparent + 76))
		*(*Tcolor)(unsafe.Pointer(nfa + 76 + 1*2)) = *(*Tcolor)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fparent + 76 + 1*2))
	}
}

/*
 - optimize - optimize an NFA
 ^ static long optimize(struct nfa *, FILE *);
*/

// C documentation
//
//	/*
//	  * The main goal of this function is not so much "optimization" (though it
//	  * does try to get rid of useless NFA states) as reducing the NFA to a form
//	  * the regex executor can handle.  The executor, and indeed the cNFA format
//	  * that is its input, can only handle PLAIN and LACON arcs.  The output of
//	  * the regex parser also includes EMPTY (do-nothing) arcs, as well as
//	  * ^, $, AHEAD, and BEHIND constraint arcs, which we must get rid of here.
//	  * We first get rid of EMPTY arcs and then deal with the constraint arcs.
//	  * The hardest part of either job is to get rid of circular loops of the
//	  * target arc type.  We would have to do that in any case, though, as such a
//	  * loop would otherwise allow the executor to cycle through the loop endlessly
//	  * without making any progress in the input string.
//	  */
func _optimize(tls *libc.TLS, nfa uintptr, f uintptr) (r int64) {
	/* for debug output; NULL none */
	var verbose, v1 int32
	_, _ = verbose, v1
	if f != libc.UintptrFromInt32(0) {
		v1 = int32(1)
	} else {
		v1 = 0
	}
	verbose = v1
	if verbose != 0 {
		libc.Xfprintf(tls, f, __ccgo_ts+298, 0)
	}
	_cleanup(tls, nfa) /* may simplify situation */
	if verbose != 0 {
		_dumpnfa(tls, nfa, f)
	}
	if verbose != 0 {
		libc.Xfprintf(tls, f, __ccgo_ts+317, 0)
	}
	_fixempties(tls, nfa, f) /* get rid of EMPTY arcs */
	if verbose != 0 {
		libc.Xfprintf(tls, f, __ccgo_ts+328, 0)
	}
	_fixconstraintloops(tls, nfa, f) /* get rid of constraint loops */
	_pullback(tls, nfa, f)           /* pull back constraints backward */
	_pushfwd(tls, nfa, f)            /* push fwd constraints forward */
	if verbose != 0 {
		libc.Xfprintf(tls, f, __ccgo_ts+343, 0)
	}
	_cleanup(tls, nfa)        /* final tidying */
	return _analyze(tls, nfa) /* and analysis */
}

// C documentation
//
//	/*
//	 - pullback - pull back constraints backward to eliminate them
//	 ^ static void pullback(struct nfa *, FILE *);
//	 */
func _pullback(tls *libc.TLS, nfa uintptr, f uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* for debug output; NULL none */
	var a, nexta, nexts, ns, s uintptr
	var progress int32
	var _ /* intermediates at bp+0 */ uintptr
	_, _, _, _, _, _ = a, nexta, nexts, ns, progress, s
	/*
	 * Find and pull until there are no more.
	 */
	for cond := true; cond; cond = progress != 0 && !((*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != libc.Int32FromInt32(0)) {
		progress = 0
		s = (*Tnfa)(unsafe.Pointer(nfa)).Fstates
		for {
			if !(s != libc.UintptrFromInt32(0) && !((*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != libc.Int32FromInt32(0))) {
				break
			}
			nexts = (*Tstate)(unsafe.Pointer(s)).Fnext
			*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
			a = (*Tstate)(unsafe.Pointer(s)).Fouts
			for {
				if !(a != libc.UintptrFromInt32(0) && !((*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != libc.Int32FromInt32(0))) {
					break
				}
				nexta = (*Tarc)(unsafe.Pointer(a)).Foutchain
				if (*Tarc)(unsafe.Pointer(a)).Ftype1 == int32('^') || (*Tarc)(unsafe.Pointer(a)).Ftype1 == int32('r') {
					if _pull(tls, nfa, a, bp) != 0 {
						progress = int32(1)
					}
				}
				goto _2
			_2:
				;
				a = nexta
			}
			/* clear tmp fields of intermediate states created here */
			for *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
				ns = (*Tstate)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Ftmp
				(*Tstate)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Ftmp = libc.UintptrFromInt32(0)
				*(*uintptr)(unsafe.Pointer(bp)) = ns
			}
			/* if s is now useless, get rid of it */
			if ((*Tstate)(unsafe.Pointer(s)).Fnins == uint64(0) || (*Tstate)(unsafe.Pointer(s)).Fnouts == uint64(0)) && !((*Tstate)(unsafe.Pointer(s)).Fflag != 0) {
				_dropstate(tls, nfa, s)
			}
			goto _1
		_1:
			;
			s = nexts
		}
		if progress != 0 && f != libc.UintptrFromInt32(0) {
			_dumpnfa(tls, nfa, f)
		}
	}
	if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
		return
	}
	/*
	 * Any ^ constraints we were able to pull to the start state can now be
	 * replaced by PLAIN arcs referencing the BOS or BOL colors.  There should
	 * be no other ^ or BEHIND arcs left in the NFA, though we do not check
	 * that here (compact() will fail if so).
	 */
	a = (*Tstate)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fpre)).Fouts
	for {
		if !(a != libc.UintptrFromInt32(0)) {
			break
		}
		nexta = (*Tarc)(unsafe.Pointer(a)).Foutchain
		if (*Tarc)(unsafe.Pointer(a)).Ftype1 == int32('^') {
			_newarc(tls, nfa, int32('p'), int32(*(*Tcolor)(unsafe.Pointer(nfa + 72 + uintptr((*Tarc)(unsafe.Pointer(a)).Fco)*2))), (*Tarc)(unsafe.Pointer(a)).Ffrom, (*Tarc)(unsafe.Pointer(a)).Fto)
			_freearc(tls, nfa, a)
		}
		goto _3
	_3:
		;
		a = nexta
	}
}

// C documentation
//
//	/*
//	 - pull - pull a back constraint backward past its source state
//	 *
//	 * Returns 1 if successful (which it always is unless the source is the
//	 * start state or we have an internal error), 0 if nothing happened.
//	 *
//	 * A significant property of this function is that it deletes no preexisting
//	 * states, and no outarcs of the constraint's from state other than the given
//	 * constraint arc.  This makes the loops in pullback() safe, at the cost that
//	 * we may leave useless states behind.  Therefore, we leave it to pullback()
//	 * to delete such states.
//	 *
//	 * If the from state has multiple back-constraint outarcs, and/or multiple
//	 * compatible constraint inarcs, we only need to create one new intermediate
//	 * state per combination of predecessor and successor states.  *intermediates
//	 * points to a list of such intermediate states for this from state (chained
//	 * through their tmp fields).
//	 ^ static int pull(struct nfa *, struct arc *);
//	 */
func _pull(tls *libc.TLS, nfa uintptr, con uintptr, intermediates uintptr) (r int32) {
	var a, from, nexta, s, to uintptr
	_, _, _, _, _ = a, from, nexta, s, to
	from = (*Tarc)(unsafe.Pointer(con)).Ffrom
	to = (*Tarc)(unsafe.Pointer(con)).Fto
	/* should have gotten rid of this earlier */
	if (*Tstate)(unsafe.Pointer(from)).Fflag != 0 { /* can't pull back beyond start */
		return 0
	}
	if (*Tstate)(unsafe.Pointer(from)).Fnins == uint64(0) { /* unreachable */
		_freearc(tls, nfa, con)
		return int32(1)
	}
	/*
	 * First, clone from state if necessary to avoid other outarcs.  This may
	 * seem wasteful, but it simplifies the logic, and we'll get rid of the
	 * clone state again at the bottom.
	 */
	if (*Tstate)(unsafe.Pointer(from)).Fnouts > uint64(1) {
		s = _newstate(tls, nfa)
		if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
			return 0
		}
		_copyins(tls, nfa, from, s)  /* duplicate inarcs */
		_cparc(tls, nfa, con, s, to) /* move constraint arc */
		_freearc(tls, nfa, con)
		if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
			return 0
		}
		from = s
		con = (*Tstate)(unsafe.Pointer(from)).Fouts
	}
	/*
	 * Propagate the constraint into the from state's inarcs.
	 */
	a = (*Tstate)(unsafe.Pointer(from)).Fins
	for {
		if !(a != libc.UintptrFromInt32(0) && !((*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != libc.Int32FromInt32(0))) {
			break
		}
		nexta = (*Tarc)(unsafe.Pointer(a)).Finchain
		switch _combine(tls, con, a) {
		case int32(INCOMPATIBLE):
			goto _2
		case int32(SATISFIED):
			goto _3
		case int32(COMPATIBLE):
			goto _4
		default:
			goto _5
		}
		goto _6
	_2:
		; /* destroy the arc */
		_freearc(tls, nfa, a)
		goto _6
	_3:
		; /* no action needed */
		goto _6
	_4:
		; /* swap the two arcs, more or less */
		/* need an intermediate state, but might have one already */
		s = *(*uintptr)(unsafe.Pointer(intermediates))
	_9:
		;
		if !(s != libc.UintptrFromInt32(0)) {
			goto _7
		}
		if (*Tarc)(unsafe.Pointer((*Tstate)(unsafe.Pointer(s)).Fins)).Ffrom == (*Tarc)(unsafe.Pointer(a)).Ffrom && (*Tarc)(unsafe.Pointer((*Tstate)(unsafe.Pointer(s)).Fouts)).Fto == to {
			goto _7
		}
		goto _8
	_8:
		;
		s = (*Tstate)(unsafe.Pointer(s)).Ftmp
		goto _9
		goto _7
	_7:
		;
		if s == libc.UintptrFromInt32(0) {
			s = _newstate(tls, nfa)
			if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
				return 0
			}
			(*Tstate)(unsafe.Pointer(s)).Ftmp = *(*uintptr)(unsafe.Pointer(intermediates))
			*(*uintptr)(unsafe.Pointer(intermediates)) = s
		}
		_cparc(tls, nfa, con, (*Tarc)(unsafe.Pointer(a)).Ffrom, s)
		_cparc(tls, nfa, a, s, to)
		_freearc(tls, nfa, a)
		goto _6
	_5:
		;
		goto _6
	_6:
		;
		goto _1
	_1:
		;
		a = nexta
	}
	/*
	 * Remaining inarcs, if any, incorporate the constraint.
	 */
	_moveins(tls, nfa, from, to)
	_freearc(tls, nfa, con)
	/* from state is now useless, but we leave it to pullback() to clean up */
	return int32(1)
}

// C documentation
//
//	/*
//	 - pushfwd - push forward constraints forward to eliminate them
//	 ^ static void pushfwd(struct nfa *, FILE *);
//	 */
func _pushfwd(tls *libc.TLS, nfa uintptr, f uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* for debug output; NULL none */
	var a, nexta, nexts, ns, s uintptr
	var progress int32
	var _ /* intermediates at bp+0 */ uintptr
	_, _, _, _, _, _ = a, nexta, nexts, ns, progress, s
	/*
	 * Find and push until there are no more.
	 */
	for cond := true; cond; cond = progress != 0 && !((*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != libc.Int32FromInt32(0)) {
		progress = 0
		s = (*Tnfa)(unsafe.Pointer(nfa)).Fstates
		for {
			if !(s != libc.UintptrFromInt32(0) && !((*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != libc.Int32FromInt32(0))) {
				break
			}
			nexts = (*Tstate)(unsafe.Pointer(s)).Fnext
			*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
			a = (*Tstate)(unsafe.Pointer(s)).Fins
			for {
				if !(a != libc.UintptrFromInt32(0) && !((*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != libc.Int32FromInt32(0))) {
					break
				}
				nexta = (*Tarc)(unsafe.Pointer(a)).Finchain
				if (*Tarc)(unsafe.Pointer(a)).Ftype1 == int32('$') || (*Tarc)(unsafe.Pointer(a)).Ftype1 == int32('a') {
					if _push(tls, nfa, a, bp) != 0 {
						progress = int32(1)
					}
				}
				goto _2
			_2:
				;
				a = nexta
			}
			/* clear tmp fields of intermediate states created here */
			for *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
				ns = (*Tstate)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Ftmp
				(*Tstate)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Ftmp = libc.UintptrFromInt32(0)
				*(*uintptr)(unsafe.Pointer(bp)) = ns
			}
			/* if s is now useless, get rid of it */
			if ((*Tstate)(unsafe.Pointer(s)).Fnins == uint64(0) || (*Tstate)(unsafe.Pointer(s)).Fnouts == uint64(0)) && !((*Tstate)(unsafe.Pointer(s)).Fflag != 0) {
				_dropstate(tls, nfa, s)
			}
			goto _1
		_1:
			;
			s = nexts
		}
		if progress != 0 && f != libc.UintptrFromInt32(0) {
			_dumpnfa(tls, nfa, f)
		}
	}
	if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
		return
	}
	/*
	 * Any $ constraints we were able to push to the post state can now be
	 * replaced by PLAIN arcs referencing the EOS or EOL colors.  There should
	 * be no other $ or AHEAD arcs left in the NFA, though we do not check
	 * that here (compact() will fail if so).
	 */
	a = (*Tstate)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fpost)).Fins
	for {
		if !(a != libc.UintptrFromInt32(0)) {
			break
		}
		nexta = (*Tarc)(unsafe.Pointer(a)).Finchain
		if (*Tarc)(unsafe.Pointer(a)).Ftype1 == int32('$') {
			_newarc(tls, nfa, int32('p'), int32(*(*Tcolor)(unsafe.Pointer(nfa + 76 + uintptr((*Tarc)(unsafe.Pointer(a)).Fco)*2))), (*Tarc)(unsafe.Pointer(a)).Ffrom, (*Tarc)(unsafe.Pointer(a)).Fto)
			_freearc(tls, nfa, a)
		}
		goto _3
	_3:
		;
		a = nexta
	}
}

// C documentation
//
//	/*
//	 - push - push a forward constraint forward past its destination state
//	 *
//	 * Returns 1 if successful (which it always is unless the destination is the
//	 * post state or we have an internal error), 0 if nothing happened.
//	 *
//	 * A significant property of this function is that it deletes no preexisting
//	 * states, and no inarcs of the constraint's to state other than the given
//	 * constraint arc.  This makes the loops in pushfwd() safe, at the cost that
//	 * we may leave useless states behind.  Therefore, we leave it to pushfwd()
//	 * to delete such states.
//	 *
//	 * If the to state has multiple forward-constraint inarcs, and/or multiple
//	 * compatible constraint outarcs, we only need to create one new intermediate
//	 * state per combination of predecessor and successor states.  *intermediates
//	 * points to a list of such intermediate states for this to state (chained
//	 * through their tmp fields).
//	 ^ static int push(struct nfa *, struct arc *);
//	 */
func _push(tls *libc.TLS, nfa uintptr, con uintptr, intermediates uintptr) (r int32) {
	var a, from, nexta, s, to uintptr
	_, _, _, _, _ = a, from, nexta, s, to
	from = (*Tarc)(unsafe.Pointer(con)).Ffrom
	to = (*Tarc)(unsafe.Pointer(con)).Fto
	/* should have gotten rid of this earlier */
	if (*Tstate)(unsafe.Pointer(to)).Fflag != 0 { /* can't push forward beyond end */
		return 0
	}
	if (*Tstate)(unsafe.Pointer(to)).Fnouts == uint64(0) { /* dead end */
		_freearc(tls, nfa, con)
		return int32(1)
	}
	/*
	 * First, clone to state if necessary to avoid other inarcs.  This may
	 * seem wasteful, but it simplifies the logic, and we'll get rid of the
	 * clone state again at the bottom.
	 */
	if (*Tstate)(unsafe.Pointer(to)).Fnins > uint64(1) {
		s = _newstate(tls, nfa)
		if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
			return 0
		}
		_copyouts(tls, nfa, to, s)     /* duplicate outarcs */
		_cparc(tls, nfa, con, from, s) /* move constraint arc */
		_freearc(tls, nfa, con)
		if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
			return 0
		}
		to = s
		con = (*Tstate)(unsafe.Pointer(to)).Fins
	}
	/*
	 * Propagate the constraint into the to state's outarcs.
	 */
	a = (*Tstate)(unsafe.Pointer(to)).Fouts
	for {
		if !(a != libc.UintptrFromInt32(0) && !((*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != libc.Int32FromInt32(0))) {
			break
		}
		nexta = (*Tarc)(unsafe.Pointer(a)).Foutchain
		switch _combine(tls, con, a) {
		case int32(INCOMPATIBLE):
			goto _2
		case int32(SATISFIED):
			goto _3
		case int32(COMPATIBLE):
			goto _4
		default:
			goto _5
		}
		goto _6
	_2:
		; /* destroy the arc */
		_freearc(tls, nfa, a)
		goto _6
	_3:
		; /* no action needed */
		goto _6
	_4:
		; /* swap the two arcs, more or less */
		/* need an intermediate state, but might have one already */
		s = *(*uintptr)(unsafe.Pointer(intermediates))
	_9:
		;
		if !(s != libc.UintptrFromInt32(0)) {
			goto _7
		}
		if (*Tarc)(unsafe.Pointer((*Tstate)(unsafe.Pointer(s)).Fins)).Ffrom == from && (*Tarc)(unsafe.Pointer((*Tstate)(unsafe.Pointer(s)).Fouts)).Fto == (*Tarc)(unsafe.Pointer(a)).Fto {
			goto _7
		}
		goto _8
	_8:
		;
		s = (*Tstate)(unsafe.Pointer(s)).Ftmp
		goto _9
		goto _7
	_7:
		;
		if s == libc.UintptrFromInt32(0) {
			s = _newstate(tls, nfa)
			if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
				return 0
			}
			(*Tstate)(unsafe.Pointer(s)).Ftmp = *(*uintptr)(unsafe.Pointer(intermediates))
			*(*uintptr)(unsafe.Pointer(intermediates)) = s
		}
		_cparc(tls, nfa, con, s, (*Tarc)(unsafe.Pointer(a)).Fto)
		_cparc(tls, nfa, a, from, s)
		_freearc(tls, nfa, a)
		goto _6
	_5:
		;
		goto _6
	_6:
		;
		goto _1
	_1:
		;
		a = nexta
	}
	/*
	 * Remaining outarcs, if any, incorporate the constraint.
	 */
	_moveouts(tls, nfa, to, from)
	_freearc(tls, nfa, con)
	/* to state is now useless, but we leave it to pushfwd() to clean up */
	return int32(1)
}

// C documentation
//
//	/*
//	 - combine - constraint lands on an arc, what happens?
//	 ^ #def	INCOMPATIBLE	1	// destroys arc
//	 ^ #def	SATISFIED	2	// constraint satisfied
//	 ^ #def	COMPATIBLE	3	// compatible but not satisfied yet
//	 ^ static int combine(struct arc *, struct arc *);
//	 */
func _combine(tls *libc.TLS, con uintptr, a uintptr) (r int32) {
	switch (*Tarc)(unsafe.Pointer(con)).Ftype1<<libc.Int32FromInt32(CHAR_BIT) | (*Tarc)(unsafe.Pointer(a)).Ftype1 {
	case libc.Int32FromUint8('^')<<libc.Int32FromInt32(CHAR_BIT) | libc.Int32FromUint8('p'): /* newlines are handled separately */
		fallthrough
	case libc.Int32FromUint8('$')<<libc.Int32FromInt32(CHAR_BIT) | libc.Int32FromUint8('p'):
		return int32(INCOMPATIBLE)
	case libc.Int32FromUint8('a')<<libc.Int32FromInt32(CHAR_BIT) | libc.Int32FromUint8('p'): /* color constraints meet colors */
		fallthrough
	case libc.Int32FromUint8('r')<<libc.Int32FromInt32(CHAR_BIT) | libc.Int32FromUint8('p'):
		if int32((*Tarc)(unsafe.Pointer(con)).Fco) == int32((*Tarc)(unsafe.Pointer(a)).Fco) {
			return int32(SATISFIED)
		}
		return int32(INCOMPATIBLE)
	case libc.Int32FromUint8('^')<<libc.Int32FromInt32(CHAR_BIT) | libc.Int32FromUint8('^'): /* collision, similar constraints */
		fallthrough
	case libc.Int32FromUint8('$')<<libc.Int32FromInt32(CHAR_BIT) | libc.Int32FromUint8('$'):
		fallthrough
	case libc.Int32FromUint8('a')<<libc.Int32FromInt32(CHAR_BIT) | libc.Int32FromUint8('a'):
		fallthrough
	case libc.Int32FromUint8('r')<<libc.Int32FromInt32(CHAR_BIT) | libc.Int32FromUint8('r'):
		if int32((*Tarc)(unsafe.Pointer(con)).Fco) == int32((*Tarc)(unsafe.Pointer(a)).Fco) { /* true duplication */
			return int32(SATISFIED)
		}
		return int32(INCOMPATIBLE)
	case libc.Int32FromUint8('^')<<libc.Int32FromInt32(CHAR_BIT) | libc.Int32FromUint8('r'): /* collision, dissimilar constraints */
		fallthrough
	case libc.Int32FromUint8('r')<<libc.Int32FromInt32(CHAR_BIT) | libc.Int32FromUint8('^'):
		fallthrough
	case libc.Int32FromUint8('$')<<libc.Int32FromInt32(CHAR_BIT) | libc.Int32FromUint8('a'):
		fallthrough
	case libc.Int32FromUint8('a')<<libc.Int32FromInt32(CHAR_BIT) | libc.Int32FromUint8('$'):
		return int32(INCOMPATIBLE)
	case libc.Int32FromUint8('^')<<libc.Int32FromInt32(CHAR_BIT) | libc.Int32FromUint8('$'): /* constraints passing each other */
		fallthrough
	case libc.Int32FromUint8('^')<<libc.Int32FromInt32(CHAR_BIT) | libc.Int32FromUint8('a'):
		fallthrough
	case libc.Int32FromUint8('r')<<libc.Int32FromInt32(CHAR_BIT) | libc.Int32FromUint8('$'):
		fallthrough
	case libc.Int32FromUint8('r')<<libc.Int32FromInt32(CHAR_BIT) | libc.Int32FromUint8('a'):
		fallthrough
	case libc.Int32FromUint8('$')<<libc.Int32FromInt32(CHAR_BIT) | libc.Int32FromUint8('^'):
		fallthrough
	case libc.Int32FromUint8('$')<<libc.Int32FromInt32(CHAR_BIT) | libc.Int32FromUint8('r'):
		fallthrough
	case libc.Int32FromUint8('a')<<libc.Int32FromInt32(CHAR_BIT) | libc.Int32FromUint8('^'):
		fallthrough
	case libc.Int32FromUint8('a')<<libc.Int32FromInt32(CHAR_BIT) | libc.Int32FromUint8('r'):
		fallthrough
	case libc.Int32FromUint8('^')<<libc.Int32FromInt32(CHAR_BIT) | libc.Int32FromUint8('L'):
		fallthrough
	case libc.Int32FromUint8('r')<<libc.Int32FromInt32(CHAR_BIT) | libc.Int32FromUint8('L'):
		fallthrough
	case libc.Int32FromUint8('$')<<libc.Int32FromInt32(CHAR_BIT) | libc.Int32FromUint8('L'):
		fallthrough
	case libc.Int32FromUint8('a')<<libc.Int32FromInt32(CHAR_BIT) | libc.Int32FromUint8('L'):
		return int32(COMPATIBLE)
		break
	}
	return int32(INCOMPATIBLE) /* for benefit of blind compilers */
}

// C documentation
//
//	/*
//	 - fixempties - get rid of EMPTY arcs
//	 ^ static void fixempties(struct nfa *, FILE *);
//	 */
func _fixempties(tls *libc.TLS, nfa uintptr, f uintptr) {
	/* for debug output; NULL none */
	var a, arcarray, inarcsorig, nexta, nexts, s, s2 uintptr
	var arccount, nskip, prevnins, totalinarcs, v10, v3, v5, v9 int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, arcarray, arccount, inarcsorig, nexta, nexts, nskip, prevnins, s, s2, totalinarcs, v10, v3, v5, v9
	/*
	 * First, get rid of any states whose sole out-arc is an EMPTY,
	 * since they're basically just aliases for their successor.  The
	 * parsing algorithm creates enough of these that it's worth
	 * special-casing this.
	 */
	s = (*Tnfa)(unsafe.Pointer(nfa)).Fstates
	for {
		if !(s != libc.UintptrFromInt32(0) && !((*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != libc.Int32FromInt32(0))) {
			break
		}
		nexts = (*Tstate)(unsafe.Pointer(s)).Fnext
		if (*Tstate)(unsafe.Pointer(s)).Fflag != 0 || (*Tstate)(unsafe.Pointer(s)).Fnouts != uint64(1) {
			goto _1
		}
		a = (*Tstate)(unsafe.Pointer(s)).Fouts
		if (*Tarc)(unsafe.Pointer(a)).Ftype1 != int32('n') {
			goto _1
		}
		if s != (*Tarc)(unsafe.Pointer(a)).Fto {
			_moveins(tls, nfa, s, (*Tarc)(unsafe.Pointer(a)).Fto)
		}
		_dropstate(tls, nfa, s)
		goto _1
	_1:
		;
		s = nexts
	}
	/*
	 * Similarly, get rid of any state with a single EMPTY in-arc, by
	 * folding it into its predecessor.
	 */
	s = (*Tnfa)(unsafe.Pointer(nfa)).Fstates
	for {
		if !(s != libc.UintptrFromInt32(0) && !((*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != libc.Int32FromInt32(0))) {
			break
		}
		nexts = (*Tstate)(unsafe.Pointer(s)).Fnext
		/* Ensure tmp fields are clear for next step */
		if (*Tstate)(unsafe.Pointer(s)).Fflag != 0 || (*Tstate)(unsafe.Pointer(s)).Fnins != uint64(1) {
			goto _2
		}
		a = (*Tstate)(unsafe.Pointer(s)).Fins
		if (*Tarc)(unsafe.Pointer(a)).Ftype1 != int32('n') {
			goto _2
		}
		if s != (*Tarc)(unsafe.Pointer(a)).Ffrom {
			_moveouts(tls, nfa, s, (*Tarc)(unsafe.Pointer(a)).Ffrom)
		}
		_dropstate(tls, nfa, s)
		goto _2
	_2:
		;
		s = nexts
	}
	if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
		return
	}
	/*
	 * For each remaining NFA state, find all other states from which it is
	 * reachable by a chain of one or more EMPTY arcs.  Then generate new arcs
	 * that eliminate the need for each such chain.
	 *
	 * We could replace a chain of EMPTY arcs that leads from a "from" state
	 * to a "to" state either by pushing non-EMPTY arcs forward (linking
	 * directly from "from"'s predecessors to "to") or by pulling them back
	 * (linking directly from "from" to "to"'s successors).  We choose to
	 * always do the former; this choice is somewhat arbitrary, but the
	 * approach below requires that we uniformly do one or the other.
	 *
	 * Suppose we have a chain of N successive EMPTY arcs (where N can easily
	 * approach the size of the NFA).  All of the intermediate states must
	 * have additional inarcs and outarcs, else they'd have been removed by
	 * the steps above.  Assuming their inarcs are mostly not empties, we will
	 * add O(N^2) arcs to the NFA, since a non-EMPTY inarc leading to any one
	 * state in the chain must be duplicated to lead to all its successor
	 * states as well.  So there is no hope of doing less than O(N^2) work;
	 * however, we should endeavor to keep the big-O cost from being even
	 * worse than that, which it can easily become without care.  In
	 * particular, suppose we were to copy all S1's inarcs forward to S2, and
	 * then also to S3, and then later we consider pushing S2's inarcs forward
	 * to S3.  If we include the arcs already copied from S1 in that, we'd be
	 * doing O(N^3) work.  (The duplicate-arc elimination built into newarc()
	 * and its cohorts would get rid of the extra arcs, but not without cost.)
	 *
	 * We can avoid this cost by treating only arcs that existed at the start
	 * of this phase as candidates to be pushed forward.  To identify those,
	 * we remember the first inarc each state had to start with.  We rely on
	 * the fact that newarc() and friends put new arcs on the front of their
	 * to-states' inchains, and that this phase never deletes arcs, so that
	 * the original arcs must be the last arcs in their to-states' inchains.
	 *
	 * So the process here is that, for each state in the NFA, we gather up
	 * all non-EMPTY inarcs of states that can reach the target state via
	 * EMPTY arcs.  We then sort, de-duplicate, and merge these arcs into the
	 * target state's inchain.  (We can safely use sort-merge for this as long
	 * as we update each state's original-arcs pointer after we add arcs to
	 * it; the sort step of mergeins probably changed the order of the old
	 * arcs.)
	 *
	 * Another refinement worth making is that, because we only add non-EMPTY
	 * arcs during this phase, and all added arcs have the same from-state as
	 * the non-EMPTY arc they were cloned from, we know ahead of time that any
	 * states having only EMPTY outarcs will be useless for lack of outarcs
	 * after we drop the EMPTY arcs.  (They cannot gain non-EMPTY outarcs if
	 * they had none to start with.)  So we need not bother to update the
	 * inchains of such states at all.
	 */
	/* Remember the states' first original inarcs */
	/* ... and while at it, count how many old inarcs there are altogether */
	inarcsorig = XTclpAlloc(tls, (*Tnfa)(unsafe.Pointer(nfa)).Fnstates*uint64(8))
	if inarcsorig == libc.UintptrFromInt32(0) {
		(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Fnexttype = int32('e')
		if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
			v3 = (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr
		} else {
			v3 = int32(REG_ESPACE)
		}
		(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr = v3
		return
	}
	totalinarcs = 0
	s = (*Tnfa)(unsafe.Pointer(nfa)).Fstates
	for {
		if !(s != libc.UintptrFromInt32(0)) {
			break
		}
		*(*uintptr)(unsafe.Pointer(inarcsorig + uintptr((*Tstate)(unsafe.Pointer(s)).Fno)*8)) = (*Tstate)(unsafe.Pointer(s)).Fins
		totalinarcs = int32(uint64(totalinarcs) + (*Tstate)(unsafe.Pointer(s)).Fnins)
		goto _4
	_4:
		;
		s = (*Tstate)(unsafe.Pointer(s)).Fnext
	}
	/*
	 * Create a workspace for accumulating the inarcs to be added to the
	 * current target state.  totalinarcs is probably a considerable
	 * overestimate of the space needed, but the NFA is unlikely to be large
	 * enough at this point to make it worth being smarter.
	 */
	arcarray = XTclpAlloc(tls, libc.Uint64FromInt32(totalinarcs)*uint64(8))
	if arcarray == libc.UintptrFromInt32(0) {
		(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Fnexttype = int32('e')
		if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
			v5 = (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr
		} else {
			v5 = int32(REG_ESPACE)
		}
		(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr = v5
		XTclpFree(tls, inarcsorig)
		return
	}
	/* And iterate over the target states */
	s = (*Tnfa)(unsafe.Pointer(nfa)).Fstates
	for {
		if !(s != libc.UintptrFromInt32(0) && !((*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != libc.Int32FromInt32(0))) {
			break
		}
		/* Ignore target states without non-EMPTY outarcs, per note above */
		if !((*Tstate)(unsafe.Pointer(s)).Fflag != 0) && !(_hasnonemptyout(tls, s) != 0) {
			goto _6
		}
		/* Find predecessor states and accumulate their original inarcs */
		arccount = 0
		s2 = _emptyreachable(tls, nfa, s, s, inarcsorig)
		for {
			if !(s2 != s) {
				break
			}
			/* Add s2's original inarcs to arcarray[], but ignore empties */
			a = *(*uintptr)(unsafe.Pointer(inarcsorig + uintptr((*Tstate)(unsafe.Pointer(s2)).Fno)*8))
			for {
				if !(a != libc.UintptrFromInt32(0)) {
					break
				}
				if (*Tarc)(unsafe.Pointer(a)).Ftype1 != int32('n') {
					v9 = arccount
					arccount++
					*(*uintptr)(unsafe.Pointer(arcarray + uintptr(v9)*8)) = a
				}
				goto _8
			_8:
				;
				a = (*Tarc)(unsafe.Pointer(a)).Finchain
			}
			/* Reset the tmp fields as we walk back */
			nexts = (*Tstate)(unsafe.Pointer(s2)).Ftmp
			(*Tstate)(unsafe.Pointer(s2)).Ftmp = libc.UintptrFromInt32(0)
			goto _7
		_7:
			;
			s2 = nexts
		}
		(*Tstate)(unsafe.Pointer(s)).Ftmp = libc.UintptrFromInt32(0)
		/* Remember how many original inarcs this state has */
		prevnins = libc.Int32FromUint64((*Tstate)(unsafe.Pointer(s)).Fnins)
		/* Add non-duplicate inarcs to target state */
		_mergeins(tls, nfa, s, arcarray, arccount)
		/* Now we must update the state's inarcsorig pointer */
		nskip = libc.Int32FromUint64((*Tstate)(unsafe.Pointer(s)).Fnins - libc.Uint64FromInt32(prevnins))
		a = (*Tstate)(unsafe.Pointer(s)).Fins
		for {
			v10 = nskip
			nskip--
			if !(v10 > 0) {
				break
			}
			a = (*Tarc)(unsafe.Pointer(a)).Finchain
		}
		*(*uintptr)(unsafe.Pointer(inarcsorig + uintptr((*Tstate)(unsafe.Pointer(s)).Fno)*8)) = a
		goto _6
	_6:
		;
		s = (*Tstate)(unsafe.Pointer(s)).Fnext
	}
	XTclpFree(tls, arcarray)
	XTclpFree(tls, inarcsorig)
	if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
		return
	}
	/*
	 * Remove all the EMPTY arcs, since we don't need them anymore.
	 */
	s = (*Tnfa)(unsafe.Pointer(nfa)).Fstates
	for {
		if !(s != libc.UintptrFromInt32(0)) {
			break
		}
		a = (*Tstate)(unsafe.Pointer(s)).Fouts
		for {
			if !(a != libc.UintptrFromInt32(0)) {
				break
			}
			nexta = (*Tarc)(unsafe.Pointer(a)).Foutchain
			if (*Tarc)(unsafe.Pointer(a)).Ftype1 == int32('n') {
				_freearc(tls, nfa, a)
			}
			goto _12
		_12:
			;
			a = nexta
		}
		goto _11
	_11:
		;
		s = (*Tstate)(unsafe.Pointer(s)).Fnext
	}
	/*
	 * And remove any states that have become useless.  (This cleanup is
	 * not very thorough, and would be even less so if we tried to
	 * combine it with the previous step; but cleanup() will take care
	 * of anything we miss.)
	 */
	s = (*Tnfa)(unsafe.Pointer(nfa)).Fstates
	for {
		if !(s != libc.UintptrFromInt32(0)) {
			break
		}
		nexts = (*Tstate)(unsafe.Pointer(s)).Fnext
		if ((*Tstate)(unsafe.Pointer(s)).Fnins == uint64(0) || (*Tstate)(unsafe.Pointer(s)).Fnouts == uint64(0)) && !((*Tstate)(unsafe.Pointer(s)).Fflag != 0) {
			_dropstate(tls, nfa, s)
		}
		goto _13
	_13:
		;
		s = nexts
	}
	if f != libc.UintptrFromInt32(0) {
		_dumpnfa(tls, nfa, f)
	}
}

// C documentation
//
//	/*
//	 - emptyreachable - recursively find all states that can reach s by EMPTY arcs
//	 * The return value is the last such state found.  Its tmp field links back
//	 * to the next-to-last such state, and so on back to s, so that all these
//	 * states can be located without searching the whole NFA.
//	 *
//	 * Since this is only used in fixempties(), we pass in the inarcsorig[] array
//	 * maintained by that function.  This lets us skip over all new inarcs, which
//	 * are certainly not EMPTY arcs.
//	 *
//	 * The maximum recursion depth here is equal to the length of the longest
//	 * loop-free chain of EMPTY arcs, which is surely no more than the size of
//	 * the NFA, and in practice will be less than that.
//	 ^ static struct state *emptyreachable(struct state *, struct state *);
//	 */
func _emptyreachable(tls *libc.TLS, nfa uintptr, s uintptr, lastfound uintptr, inarcsorig uintptr) (r uintptr) {
	var a uintptr
	_ = a
	(*Tstate)(unsafe.Pointer(s)).Ftmp = lastfound
	lastfound = s
	a = *(*uintptr)(unsafe.Pointer(inarcsorig + uintptr((*Tstate)(unsafe.Pointer(s)).Fno)*8))
	for {
		if !(a != libc.UintptrFromInt32(0)) {
			break
		}
		if (*Tarc)(unsafe.Pointer(a)).Ftype1 == int32('n') && (*Tstate)(unsafe.Pointer((*Tarc)(unsafe.Pointer(a)).Ffrom)).Ftmp == libc.UintptrFromInt32(0) {
			lastfound = _emptyreachable(tls, nfa, (*Tarc)(unsafe.Pointer(a)).Ffrom, lastfound, inarcsorig)
		}
		goto _1
	_1:
		;
		a = (*Tarc)(unsafe.Pointer(a)).Finchain
	}
	return lastfound
}

// C documentation
//
//	/*
//	 * isconstraintarc - detect whether an arc is of a constraint type
//	 */
func _isconstraintarc(tls *libc.TLS, a uintptr) (r int32) {
	switch (*Tarc)(unsafe.Pointer(a)).Ftype1 {
	case int32('^'):
		fallthrough
	case int32('$'):
		fallthrough
	case int32('r'):
		fallthrough
	case int32('a'):
		fallthrough
	case int32('L'):
		return int32(1)
	}
	return 0
}

// C documentation
//
//	/*
//	 * hasconstraintout - does state have a constraint out arc?
//	 */
func _hasconstraintout(tls *libc.TLS, s uintptr) (r int32) {
	var a uintptr
	_ = a
	a = (*Tstate)(unsafe.Pointer(s)).Fouts
	for {
		if !(a != libc.UintptrFromInt32(0)) {
			break
		}
		if _isconstraintarc(tls, a) != 0 {
			return int32(1)
		}
		goto _1
	_1:
		;
		a = (*Tarc)(unsafe.Pointer(a)).Foutchain
	}
	return 0
}

// C documentation
//
//	/*
//	 * fixconstraintloops - get rid of loops containing only constraint arcs
//	 *
//	 * A loop of states that contains only constraint arcs is useless, since
//	 * passing around the loop represents no forward progress.  Moreover, it
//	 * would cause infinite looping in pullback/pushfwd, so we need to get rid
//	 * of such loops before doing that.
//	 */
func _fixconstraintloops(tls *libc.TLS, nfa uintptr, f uintptr) {
	/* for debug output; NULL none */
	var a, nexta, nexts, s uintptr
	var hasconstraints int32
	_, _, _, _, _ = a, hasconstraints, nexta, nexts, s
	/*
	 * In the trivial case of a state that loops to itself, we can just drop
	 * the constraint arc altogether.  This is worth special-casing because
	 * such loops are far more common than loops containing multiple states.
	 * While we're at it, note whether any constraint arcs survive.
	 */
	hasconstraints = 0
	s = (*Tnfa)(unsafe.Pointer(nfa)).Fstates
	for {
		if !(s != libc.UintptrFromInt32(0) && !((*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != libc.Int32FromInt32(0))) {
			break
		}
		nexts = (*Tstate)(unsafe.Pointer(s)).Fnext
		/* while we're at it, ensure tmp fields are clear for next step */
		a = (*Tstate)(unsafe.Pointer(s)).Fouts
		for {
			if !(a != libc.UintptrFromInt32(0) && !((*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != libc.Int32FromInt32(0))) {
				break
			}
			nexta = (*Tarc)(unsafe.Pointer(a)).Foutchain
			if _isconstraintarc(tls, a) != 0 {
				if (*Tarc)(unsafe.Pointer(a)).Fto == s {
					_freearc(tls, nfa, a)
				} else {
					hasconstraints = int32(1)
				}
			}
			goto _2
		_2:
			;
			a = nexta
		}
		/* If we removed all the outarcs, the state is useless. */
		if (*Tstate)(unsafe.Pointer(s)).Fnouts == uint64(0) && !((*Tstate)(unsafe.Pointer(s)).Fflag != 0) {
			_dropstate(tls, nfa, s)
		}
		goto _1
	_1:
		;
		s = nexts
	}
	/* Nothing to do if no remaining constraint arcs */
	if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 || !(hasconstraints != 0) {
		return
	}
	/*
	 * Starting from each remaining NFA state, search outwards for a
	 * constraint loop.  If we find a loop, break the loop, then start the
	 * search over.  (We could possibly retain some state from the first scan,
	 * but it would complicate things greatly, and multi-state constraint
	 * loops are rare enough that it's not worth optimizing the case.)
	 */
	goto restart
restart:
	;
	s = (*Tnfa)(unsafe.Pointer(nfa)).Fstates
	for {
		if !(s != libc.UintptrFromInt32(0) && !((*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != libc.Int32FromInt32(0))) {
			break
		}
		if _findconstraintloop(tls, nfa, s) != 0 {
			goto restart
		}
		goto _3
	_3:
		;
		s = (*Tstate)(unsafe.Pointer(s)).Fnext
	}
	if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
		return
	}
	/*
	 * Now remove any states that have become useless.  (This cleanup is not
	 * very thorough, and would be even less so if we tried to combine it with
	 * the previous step; but cleanup() will take care of anything we miss.)
	 *
	 * Because findconstraintloop intentionally doesn't reset all tmp fields,
	 * we have to clear them after it's done.  This is a convenient place to
	 * do that, too.
	 */
	s = (*Tnfa)(unsafe.Pointer(nfa)).Fstates
	for {
		if !(s != libc.UintptrFromInt32(0)) {
			break
		}
		nexts = (*Tstate)(unsafe.Pointer(s)).Fnext
		(*Tstate)(unsafe.Pointer(s)).Ftmp = libc.UintptrFromInt32(0)
		if ((*Tstate)(unsafe.Pointer(s)).Fnins == uint64(0) || (*Tstate)(unsafe.Pointer(s)).Fnouts == uint64(0)) && !((*Tstate)(unsafe.Pointer(s)).Fflag != 0) {
			_dropstate(tls, nfa, s)
		}
		goto _4
	_4:
		;
		s = nexts
	}
	if f != libc.UintptrFromInt32(0) {
		_dumpnfa(tls, nfa, f)
	}
}

// C documentation
//
//	/*
//	 * findconstraintloop - recursively find a loop of constraint arcs
//	 *
//	 * If we find a loop, break it by calling breakconstraintloop(), then
//	 * return 1; otherwise return 0.
//	 *
//	 * State tmp fields are guaranteed all NULL on a success return, because
//	 * breakconstraintloop does that.  After a failure return, any state that
//	 * is known not to be part of a loop is marked with s->tmp == s; this allows
//	 * us not to have to re-prove that fact on later calls.  (This convention is
//	 * workable because we already eliminated single-state loops.)
//	 *
//	 * Note that the found loop doesn't necessarily include the first state we
//	 * are called on.  Any loop reachable from that state will do.
//	 *
//	 * The maximum recursion depth here is one more than the length of the longest
//	 * loop-free chain of constraint arcs, which is surely no more than the size
//	 * of the NFA, and in practice will be a lot less than that.
//	 */
func _findconstraintloop(tls *libc.TLS, nfa uintptr, s uintptr) (r int32) {
	var a, sto uintptr
	var v1 int32
	_, _, _ = a, sto, v1
	/* Since this is recursive, it could be driven to stack overflow */
	if 0 != 0 {
		(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Fnexttype = int32('e')
		if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
			v1 = (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr
		} else {
			v1 = int32(REG_ETOOBIG)
		}
		(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr = v1
		return int32(1) /* to exit as quickly as possible */
	}
	if (*Tstate)(unsafe.Pointer(s)).Ftmp != libc.UintptrFromInt32(0) {
		/* Already proven uninteresting? */
		if (*Tstate)(unsafe.Pointer(s)).Ftmp == s {
			return 0
		}
		/* Found a loop involving s */
		_breakconstraintloop(tls, nfa, s)
		/* The tmp fields have been cleaned up by breakconstraintloop */
		return int32(1)
	}
	a = (*Tstate)(unsafe.Pointer(s)).Fouts
	for {
		if !(a != libc.UintptrFromInt32(0)) {
			break
		}
		if _isconstraintarc(tls, a) != 0 {
			sto = (*Tarc)(unsafe.Pointer(a)).Fto
			(*Tstate)(unsafe.Pointer(s)).Ftmp = sto
			if _findconstraintloop(tls, nfa, sto) != 0 {
				return int32(1)
			}
		}
		goto _2
	_2:
		;
		a = (*Tarc)(unsafe.Pointer(a)).Foutchain
	}
	/*
	 * If we get here, no constraint loop exists leading out from s.  Mark it
	 * with s->tmp == s so we need not rediscover that fact again later.
	 */
	(*Tstate)(unsafe.Pointer(s)).Ftmp = s
	return 0
}

// C documentation
//
//	/*
//	 * breakconstraintloop - break a loop of constraint arcs
//	 *
//	 * sinitial is any one member state of the loop.  Each loop member's tmp
//	 * field links to its successor within the loop.  (Note that this function
//	 * will reset all the tmp fields to NULL.)
//	 *
//	 * We can break the loop by, for any one state S1 in the loop, cloning its
//	 * loop successor state S2 (and possibly following states), and then moving
//	 * all S1->S2 constraint arcs to point to the cloned S2.  The cloned S2 should
//	 * copy any non-constraint outarcs of S2.  Constraint outarcs should be
//	 * dropped if they point back to S1, else they need to be copied as arcs to
//	 * similarly cloned states S3, S4, etc.  In general, each cloned state copies
//	 * non-constraint outarcs, drops constraint outarcs that would lead to itself
//	 * or any earlier cloned state, and sends other constraint outarcs to newly
//	 * cloned states.  No cloned state will have any inarcs that aren't constraint
//	 * arcs or do not lead from S1 or earlier-cloned states.  It's okay to drop
//	 * constraint back-arcs since they would not take us to any state we've not
//	 * already been in; therefore, no new constraint loop is created.  In this way
//	 * we generate a modified NFA that can still represent every useful state
//	 * sequence, but not sequences that represent state loops with no consumption
//	 * of input data.  Note that the set of cloned states will certainly include
//	 * all of the loop member states other than S1, and it may also include
//	 * non-loop states that are reachable from S2 via constraint arcs.  This is
//	 * important because there is no guarantee that findconstraintloop found a
//	 * maximal loop (and searching for one would be NP-hard, so don't try).
//	 * Frequently the "non-loop states" are actually part of a larger loop that
//	 * we didn't notice, and indeed there may be several overlapping loops.
//	 * This technique ensures convergence in such cases, while considering only
//	 * the originally-found loop does not.
//	 *
//	 * If there is only one S1->S2 constraint arc, then that constraint is
//	 * certainly satisfied when we enter any of the clone states.  This means that
//	 * in the common case where many of the constraint arcs are identically
//	 * labeled, we can merge together clone states linked by a similarly-labeled
//	 * constraint: if we can get to the first one we can certainly get to the
//	 * second, so there's no need to distinguish.  This greatly reduces the number
//	 * of new states needed, so we preferentially break the given loop at a state
//	 * pair where this is true.
//	 *
//	 * Furthermore, it's fairly common to find that a cloned successor state has
//	 * no outarcs, especially if we're a bit aggressive about removing unnecessary
//	 * outarcs.  If that happens, then there is simply not any interesting state
//	 * that can be reached through the predecessor's loop arcs, which means we can
//	 * break the loop just by removing those loop arcs, with no new states added.
//	 */
func _breakconstraintloop(tls *libc.TLS, nfa uintptr, sinitial uintptr) {
	var a, nexta, nexts, refarc, s, sclone, shead, stail uintptr
	var narcs int32
	_, _, _, _, _, _, _, _, _ = a, narcs, nexta, nexts, refarc, s, sclone, shead, stail
	/*
	 * Start by identifying which loop step we want to break at.
	 * Preferentially this is one with only one constraint arc.  (XXX are
	 * there any other secondary heuristics we want to use here?)  Set refarc
	 * to point to the selected lone constraint arc, if there is one.
	 */
	refarc = libc.UintptrFromInt32(0)
	s = sinitial
	for cond := true; cond; cond = s != sinitial {
		nexts = (*Tstate)(unsafe.Pointer(s)).Ftmp
		/* should not see any one-element loops */
		if refarc == libc.UintptrFromInt32(0) {
			narcs = 0
			a = (*Tstate)(unsafe.Pointer(s)).Fouts
			for {
				if !(a != libc.UintptrFromInt32(0)) {
					break
				}
				if (*Tarc)(unsafe.Pointer(a)).Fto == nexts && _isconstraintarc(tls, a) != 0 {
					refarc = a
					narcs++
				}
				goto _1
			_1:
				;
				a = (*Tarc)(unsafe.Pointer(a)).Foutchain
			}
			if narcs > int32(1) {
				refarc = libc.UintptrFromInt32(0) /* multiple constraint arcs here, no good */
			}
		}
		s = nexts
	}
	if refarc != 0 {
		/* break at the refarc */
		shead = (*Tarc)(unsafe.Pointer(refarc)).Ffrom
		stail = (*Tarc)(unsafe.Pointer(refarc)).Fto
	} else {
		/* for lack of a better idea, break after sinitial */
		shead = sinitial
		stail = (*Tstate)(unsafe.Pointer(sinitial)).Ftmp
	}
	/*
	 * Reset the tmp fields so that we can use them for local storage in
	 * clonesuccessorstates.  (findconstraintloop won't mind, since it's just
	 * going to abandon its search anyway.)
	 */
	s = (*Tnfa)(unsafe.Pointer(nfa)).Fstates
	for {
		if !(s != libc.UintptrFromInt32(0)) {
			break
		}
		(*Tstate)(unsafe.Pointer(s)).Ftmp = libc.UintptrFromInt32(0)
		goto _2
	_2:
		;
		s = (*Tstate)(unsafe.Pointer(s)).Fnext
	}
	/*
	 * Recursively build clone state(s) as needed.
	 */
	sclone = _newstate(tls, nfa)
	if sclone == libc.UintptrFromInt32(0) {
		return
	}
	_clonesuccessorstates(tls, nfa, stail, sclone, shead, refarc, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), (*Tnfa)(unsafe.Pointer(nfa)).Fnstates)
	if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
		return
	}
	/*
	 * It's possible that sclone has no outarcs at all, in which case it's
	 * useless.  (We don't try extremely hard to get rid of useless states
	 * here, but this is an easy and fairly common case.)
	 */
	if (*Tstate)(unsafe.Pointer(sclone)).Fnouts == uint64(0) {
		_freestate(tls, nfa, sclone)
		sclone = libc.UintptrFromInt32(0)
	}
	/*
	 * Move shead's constraint-loop arcs to point to sclone, or just drop them
	 * if we discovered we don't need sclone.
	 */
	a = (*Tstate)(unsafe.Pointer(shead)).Fouts
	for {
		if !(a != libc.UintptrFromInt32(0)) {
			break
		}
		nexta = (*Tarc)(unsafe.Pointer(a)).Foutchain
		if (*Tarc)(unsafe.Pointer(a)).Fto == stail && _isconstraintarc(tls, a) != 0 {
			if sclone != 0 {
				_cparc(tls, nfa, a, shead, sclone)
			}
			_freearc(tls, nfa, a)
			if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
				break
			}
		}
		goto _3
	_3:
		;
		a = nexta
	}
}

// C documentation
//
//	/*
//	 * clonesuccessorstates - create a tree of constraint-arc successor states
//	 *
//	 * ssource is the state to be cloned, and sclone is the state to copy its
//	 * outarcs into.  sclone's inarcs, if any, should already be set up.
//	 *
//	 * spredecessor is the original predecessor state that we are trying to build
//	 * successors for (it may not be the immediate predecessor of ssource).
//	 * refarc, if not NULL, is the original constraint arc that is known to have
//	 * been traversed out of spredecessor to reach the successor(s).
//	 *
//	 * For each cloned successor state, we transiently create a "donemap" that is
//	 * a boolean array showing which source states we've already visited for this
//	 * clone state.  This prevents infinite recursion as well as useless repeat
//	 * visits to the same state subtree (which can add up fast, since typical NFAs
//	 * have multiple redundant arc pathways).  Each donemap is a char array
//	 * indexed by state number.  The donemaps are all of the same size "nstates",
//	 * which is nfa->nstates as of the start of the recursion.  This is enough to
//	 * have entries for all preexisting states, but *not* entries for clone
//	 * states created during the recursion.  That's okay since we have no need to
//	 * mark those.
//	 *
//	 * curdonemap is NULL when recursing to a new sclone state, or sclone's
//	 * donemap when we are recursing without having created a new state (which we
//	 * do when we decide we can merge a successor state into the current clone
//	 * state).  outerdonemap is NULL at the top level and otherwise the parent
//	 * clone state's donemap.
//	 *
//	 * The successor states we create and fill here form a strict tree structure,
//	 * with each state having exactly one predecessor, except that the toplevel
//	 * state has no inarcs as yet (breakconstraintloop will add its inarcs from
//	 * spredecessor after we're done).  Thus, we can examine sclone's inarcs back
//	 * to the root, plus refarc if any, to identify the set of constraints already
//	 * known valid at the current point.  This allows us to avoid generating extra
//	 * successor states.
//	 */
func _clonesuccessorstates(tls *libc.TLS, nfa uintptr, ssource uintptr, sclone uintptr, spredecessor uintptr, refarc uintptr, curdonemap uintptr, outerdonemap uintptr, nstates Tsize_t) {
	var a, a2, donemap, prevclone, s, sto, sto1, stoclone, stoclone1 uintptr
	var canmerge, v1, v2 int32
	_, _, _, _, _, _, _, _, _, _, _, _ = a, a2, canmerge, donemap, prevclone, s, sto, sto1, stoclone, stoclone1, v1, v2
	/* Since this is recursive, it could be driven to stack overflow */
	if 0 != 0 {
		(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Fnexttype = int32('e')
		if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
			v1 = (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr
		} else {
			v1 = int32(REG_ETOOBIG)
		}
		(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr = v1
		return
	}
	/* If this state hasn't already got a donemap, create one */
	donemap = curdonemap
	if donemap == libc.UintptrFromInt32(0) {
		donemap = XTclpAlloc(tls, nstates*uint64(1))
		if donemap == libc.UintptrFromInt32(0) {
			(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Fnexttype = int32('e')
			if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
				v2 = (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr
			} else {
				v2 = int32(REG_ESPACE)
			}
			(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr = v2
			return
		}
		if outerdonemap != libc.UintptrFromInt32(0) {
			/*
			 * Not at outermost recursion level, so copy the outer level's
			 * donemap; this ensures that we see states in process of being
			 * visited at outer levels, or already merged into predecessor
			 * states, as ones we shouldn't traverse back to.
			 */
			libc.Xmemcpy(tls, donemap, outerdonemap, nstates*uint64(1))
		} else {
			/* At outermost level, only spredecessor is off-limits */
			libc.Xmemset(tls, donemap, 0, nstates*uint64(1))
			*(*uint8)(unsafe.Pointer(donemap + uintptr((*Tstate)(unsafe.Pointer(spredecessor)).Fno))) = uint8(1)
		}
	}
	/* Mark ssource as visited in the donemap */
	*(*uint8)(unsafe.Pointer(donemap + uintptr((*Tstate)(unsafe.Pointer(ssource)).Fno))) = uint8(1)
	/*
	 * We proceed by first cloning all of ssource's outarcs, creating new
	 * clone states as needed but not doing more with them than that.  Then in
	 * a second pass, recurse to process the child clone states.  This allows
	 * us to have only one child clone state per reachable source state, even
	 * when there are multiple outarcs leading to the same state.  Also, when
	 * we do visit a child state, its set of inarcs is known exactly, which
	 * makes it safe to apply the constraint-is-already-checked optimization.
	 * Also, this ensures that we've merged all the states we can into the
	 * current clone before we recurse to any children, thus possibly saving
	 * them from making extra images of those states.
	 *
	 * While this function runs, child clone states of the current state are
	 * marked by setting their tmp fields to point to the original state they
	 * were cloned from.  This makes it possible to detect multiple outarcs
	 * leading to the same state, and also makes it easy to distinguish clone
	 * states from original states (which will have tmp == NULL).
	 */
	a = (*Tstate)(unsafe.Pointer(ssource)).Fouts
	for {
		if !(a != libc.UintptrFromInt32(0) && !((*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != libc.Int32FromInt32(0))) {
			break
		}
		sto = (*Tarc)(unsafe.Pointer(a)).Fto
		/*
		 * We do not consider cloning successor states that have no constraint
		 * outarcs; just link to them as-is.  They cannot be part of a
		 * constraint loop so there is no need to make copies.  In particular,
		 * this rule keeps us from trying to clone the post state, which would
		 * be a bad idea.
		 */
		if _isconstraintarc(tls, a) != 0 && _hasconstraintout(tls, sto) != 0 {
			/*
			 * Back-link constraint arcs must not be followed.  Nor is there a
			 * need to revisit states previously merged into this clone.
			 */
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(donemap + uintptr((*Tstate)(unsafe.Pointer(sto)).Fno)))) != 0 {
				goto _3
			}
			/*
			 * Check whether we already have a child clone state for this
			 * source state.
			 */
			prevclone = libc.UintptrFromInt32(0)
			a2 = (*Tstate)(unsafe.Pointer(sclone)).Fouts
			for {
				if !(a2 != libc.UintptrFromInt32(0)) {
					break
				}
				if (*Tstate)(unsafe.Pointer((*Tarc)(unsafe.Pointer(a2)).Fto)).Ftmp == sto {
					prevclone = (*Tarc)(unsafe.Pointer(a2)).Fto
					break
				}
				goto _4
			_4:
				;
				a2 = (*Tarc)(unsafe.Pointer(a2)).Foutchain
			}
			/*
			 * If this arc is labeled the same as refarc, or the same as any
			 * arc we must have traversed to get to sclone, then no additional
			 * constraints need to be met to get to sto, so we should just
			 * merge its outarcs into sclone.
			 */
			if refarc != 0 && (*Tarc)(unsafe.Pointer(a)).Ftype1 == (*Tarc)(unsafe.Pointer(refarc)).Ftype1 && int32((*Tarc)(unsafe.Pointer(a)).Fco) == int32((*Tarc)(unsafe.Pointer(refarc)).Fco) {
				canmerge = int32(1)
			} else {
				canmerge = 0
				s = sclone
				for {
					if !((*Tstate)(unsafe.Pointer(s)).Fins != 0) {
						break
					}
					if (*Tstate)(unsafe.Pointer(s)).Fnins == uint64(1) && (*Tarc)(unsafe.Pointer(a)).Ftype1 == (*Tarc)(unsafe.Pointer((*Tstate)(unsafe.Pointer(s)).Fins)).Ftype1 && int32((*Tarc)(unsafe.Pointer(a)).Fco) == int32((*Tarc)(unsafe.Pointer((*Tstate)(unsafe.Pointer(s)).Fins)).Fco) {
						canmerge = int32(1)
						break
					}
					goto _5
				_5:
					;
					s = (*Tarc)(unsafe.Pointer((*Tstate)(unsafe.Pointer(s)).Fins)).Ffrom
				}
			}
			if canmerge != 0 {
				/*
				 * We can merge into sclone.  If we previously made a child
				 * clone state, drop it; there's no need to visit it.  (This
				 * can happen if ssource has multiple pathways to sto, and we
				 * only just now found one that is provably a no-op.)
				 */
				if prevclone != 0 {
					_dropstate(tls, nfa, prevclone) /* kills our outarc, too */
				}
				/* Recurse to merge sto's outarcs into sclone */
				_clonesuccessorstates(tls, nfa, sto, sclone, spredecessor, refarc, donemap, outerdonemap, nstates)
				/* sto should now be marked as previously visited */
			} else {
				if prevclone != 0 {
					/*
					 * We already have a clone state for this successor, so just
					 * make another arc to it.
					 */
					_cparc(tls, nfa, a, sclone, prevclone)
				} else {
					stoclone = _newstate(tls, nfa)
					if stoclone == libc.UintptrFromInt32(0) {
						break
					}
					/* Mark it as to what it's a clone of */
					(*Tstate)(unsafe.Pointer(stoclone)).Ftmp = sto
					/* ... and add the outarc leading to it */
					_cparc(tls, nfa, a, sclone, stoclone)
				}
			}
		} else {
			/*
			 * Non-constraint outarcs just get copied to sclone, as do outarcs
			 * leading to states with no constraint outarc.
			 */
			_cparc(tls, nfa, a, sclone, sto)
		}
		goto _3
	_3:
		;
		a = (*Tarc)(unsafe.Pointer(a)).Foutchain
	}
	/*
	 * If we are at outer level for this clone state, recurse to all its child
	 * clone states, clearing their tmp fields as we go.  (If we're not
	 * outermost for sclone, leave this to be done by the outer call level.)
	 * Note that if we have multiple outarcs leading to the same clone state,
	 * it will only be recursed-to once.
	 */
	if curdonemap == libc.UintptrFromInt32(0) {
		a = (*Tstate)(unsafe.Pointer(sclone)).Fouts
		for {
			if !(a != libc.UintptrFromInt32(0) && !((*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != libc.Int32FromInt32(0))) {
				break
			}
			stoclone1 = (*Tarc)(unsafe.Pointer(a)).Fto
			sto1 = (*Tstate)(unsafe.Pointer(stoclone1)).Ftmp
			if sto1 != libc.UintptrFromInt32(0) {
				(*Tstate)(unsafe.Pointer(stoclone1)).Ftmp = libc.UintptrFromInt32(0)
				_clonesuccessorstates(tls, nfa, sto1, stoclone1, spredecessor, refarc, libc.UintptrFromInt32(0), donemap, nstates)
			}
			goto _6
		_6:
			;
			a = (*Tarc)(unsafe.Pointer(a)).Foutchain
		}
		/* Don't forget to free sclone's donemap when done with it */
		XTclpFree(tls, donemap)
	}
}

// C documentation
//
//	/*
//	 - cleanup - clean up NFA after optimizations
//	 ^ static void cleanup(struct nfa *);
//	 */
func _cleanup(tls *libc.TLS, nfa uintptr) {
	var n, v3 Tsize_t
	var nexts, s uintptr
	_, _, _, _ = n, nexts, s, v3
	/*
	 * Clear out unreachable or dead-end states. Use pre to mark reachable,
	 * then post to mark can-reach-post.
	 */
	_markreachable(tls, nfa, (*Tnfa)(unsafe.Pointer(nfa)).Fpre, libc.UintptrFromInt32(0), (*Tnfa)(unsafe.Pointer(nfa)).Fpre)
	_markcanreach(tls, nfa, (*Tnfa)(unsafe.Pointer(nfa)).Fpost, (*Tnfa)(unsafe.Pointer(nfa)).Fpre, (*Tnfa)(unsafe.Pointer(nfa)).Fpost)
	s = (*Tnfa)(unsafe.Pointer(nfa)).Fstates
	for {
		if !(s != libc.UintptrFromInt32(0)) {
			break
		}
		nexts = (*Tstate)(unsafe.Pointer(s)).Fnext
		if (*Tstate)(unsafe.Pointer(s)).Ftmp != (*Tnfa)(unsafe.Pointer(nfa)).Fpost && !((*Tstate)(unsafe.Pointer(s)).Fflag != 0) {
			_dropstate(tls, nfa, s)
		}
		goto _1
	_1:
		;
		s = nexts
	}
	_cleartraverse(tls, nfa, (*Tnfa)(unsafe.Pointer(nfa)).Fpre)
	/* the nins==0 (final unreachable) case will be caught later */
	/*
	 * Renumber surviving states.
	 */
	n = uint64(0)
	s = (*Tnfa)(unsafe.Pointer(nfa)).Fstates
	for {
		if !(s != libc.UintptrFromInt32(0)) {
			break
		}
		v3 = n
		n++
		(*Tstate)(unsafe.Pointer(s)).Fno = v3
		goto _2
	_2:
		;
		s = (*Tstate)(unsafe.Pointer(s)).Fnext
	}
	(*Tnfa)(unsafe.Pointer(nfa)).Fnstates = n
}

// C documentation
//
//	/*
//	 - markreachable - recursive marking of reachable states
//	 ^ static void markreachable(struct nfa *, struct state *, struct state *,
//	 ^	struct state *);
//	 */
func _markreachable(tls *libc.TLS, nfa uintptr, s uintptr, okay uintptr, mark uintptr) {
	/* the value to mark with */
	var a uintptr
	_ = a
	if (*Tstate)(unsafe.Pointer(s)).Ftmp != okay {
		return
	}
	(*Tstate)(unsafe.Pointer(s)).Ftmp = mark
	a = (*Tstate)(unsafe.Pointer(s)).Fouts
	for {
		if !(a != libc.UintptrFromInt32(0)) {
			break
		}
		_markreachable(tls, nfa, (*Tarc)(unsafe.Pointer(a)).Fto, okay, mark)
		goto _1
	_1:
		;
		a = (*Tarc)(unsafe.Pointer(a)).Foutchain
	}
}

// C documentation
//
//	/*
//	 - markcanreach - recursive marking of states which can reach here
//	 ^ static void markcanreach(struct nfa *, struct state *, struct state *,
//	 ^	struct state *);
//	 */
func _markcanreach(tls *libc.TLS, nfa uintptr, s uintptr, okay uintptr, mark uintptr) {
	/* the value to mark with */
	var a uintptr
	_ = a
	if (*Tstate)(unsafe.Pointer(s)).Ftmp != okay {
		return
	}
	(*Tstate)(unsafe.Pointer(s)).Ftmp = mark
	a = (*Tstate)(unsafe.Pointer(s)).Fins
	for {
		if !(a != libc.UintptrFromInt32(0)) {
			break
		}
		_markcanreach(tls, nfa, (*Tarc)(unsafe.Pointer(a)).Ffrom, okay, mark)
		goto _1
	_1:
		;
		a = (*Tarc)(unsafe.Pointer(a)).Finchain
	}
}

// C documentation
//
//	/*
//	 - analyze - ascertain potentially-useful facts about an optimized NFA
//	 ^ static long analyze(struct nfa *);
//	 */
func _analyze(tls *libc.TLS, nfa uintptr) (r int64) {
	var a, aa uintptr
	_, _ = a, aa
	if (*Tstate)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fpre)).Fouts == libc.UintptrFromInt32(0) {
		return int64(REG_UIMPOSSIBLE)
	}
	a = (*Tstate)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fpre)).Fouts
	for {
		if !(a != libc.UintptrFromInt32(0)) {
			break
		}
		aa = (*Tstate)(unsafe.Pointer((*Tarc)(unsafe.Pointer(a)).Fto)).Fouts
		for {
			if !(aa != libc.UintptrFromInt32(0)) {
				break
			}
			if (*Tarc)(unsafe.Pointer(aa)).Fto == (*Tnfa)(unsafe.Pointer(nfa)).Fpost {
				return int64(REG_UEMPTYMATCH)
			}
			goto _2
		_2:
			;
			aa = (*Tarc)(unsafe.Pointer(aa)).Foutchain
		}
		goto _1
	_1:
		;
		a = (*Tarc)(unsafe.Pointer(a)).Foutchain
	}
	return 0
}

// C documentation
//
//	/*
//	 - compact - construct the compact representation of an NFA
//	 ^ static void compact(struct nfa *, struct cnfa *);
//	 */
func _compact(tls *libc.TLS, nfa uintptr, cnfa uintptr) {
	var a, ca, first, s uintptr
	var narcs, nstates Tsize_t
	var v2, v5 int32
	_, _, _, _, _, _, _, _ = a, ca, first, narcs, nstates, s, v2, v5
	nstates = uint64(0)
	narcs = uint64(0)
	s = (*Tnfa)(unsafe.Pointer(nfa)).Fstates
	for {
		if !(s != libc.UintptrFromInt32(0)) {
			break
		}
		nstates++
		narcs += (*Tstate)(unsafe.Pointer(s)).Fnouts + uint64(1) /* need one extra for endmarker */
		goto _1
	_1:
		;
		s = (*Tstate)(unsafe.Pointer(s)).Fnext
	}
	(*Tcnfa)(unsafe.Pointer(cnfa)).Fstflags = XTclpAlloc(tls, nstates*uint64(1))
	(*Tcnfa)(unsafe.Pointer(cnfa)).Fstates = XTclpAlloc(tls, nstates*uint64(8))
	(*Tcnfa)(unsafe.Pointer(cnfa)).Farcs = XTclpAlloc(tls, narcs*uint64(16))
	if (*Tcnfa)(unsafe.Pointer(cnfa)).Fstflags == libc.UintptrFromInt32(0) || (*Tcnfa)(unsafe.Pointer(cnfa)).Fstates == libc.UintptrFromInt32(0) || (*Tcnfa)(unsafe.Pointer(cnfa)).Farcs == libc.UintptrFromInt32(0) {
		if (*Tcnfa)(unsafe.Pointer(cnfa)).Fstflags != libc.UintptrFromInt32(0) {
			XTclpFree(tls, (*Tcnfa)(unsafe.Pointer(cnfa)).Fstflags)
		}
		if (*Tcnfa)(unsafe.Pointer(cnfa)).Fstates != libc.UintptrFromInt32(0) {
			XTclpFree(tls, (*Tcnfa)(unsafe.Pointer(cnfa)).Fstates)
		}
		if (*Tcnfa)(unsafe.Pointer(cnfa)).Farcs != libc.UintptrFromInt32(0) {
			XTclpFree(tls, (*Tcnfa)(unsafe.Pointer(cnfa)).Farcs)
		}
		(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Fnexttype = int32('e')
		if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
			v2 = (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr
		} else {
			v2 = int32(REG_ESPACE)
		}
		(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr = v2
		return
	}
	(*Tcnfa)(unsafe.Pointer(cnfa)).Fnstates = nstates
	(*Tcnfa)(unsafe.Pointer(cnfa)).Fpre = (*Tstate)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fpre)).Fno
	(*Tcnfa)(unsafe.Pointer(cnfa)).Fpost = (*Tstate)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fpost)).Fno
	*(*Tcolor)(unsafe.Pointer(cnfa + 32)) = *(*Tcolor)(unsafe.Pointer(nfa + 72))
	*(*Tcolor)(unsafe.Pointer(cnfa + 32 + 1*2)) = *(*Tcolor)(unsafe.Pointer(nfa + 72 + 1*2))
	*(*Tcolor)(unsafe.Pointer(cnfa + 36)) = *(*Tcolor)(unsafe.Pointer(nfa + 76))
	*(*Tcolor)(unsafe.Pointer(cnfa + 36 + 1*2)) = *(*Tcolor)(unsafe.Pointer(nfa + 76 + 1*2))
	(*Tcnfa)(unsafe.Pointer(cnfa)).Fncolors = int32(_maxcolor(tls, (*Tnfa)(unsafe.Pointer(nfa)).Fcm)) + int32(1)
	(*Tcnfa)(unsafe.Pointer(cnfa)).Fflags = 0
	ca = (*Tcnfa)(unsafe.Pointer(cnfa)).Farcs
	s = (*Tnfa)(unsafe.Pointer(nfa)).Fstates
	for {
		if !(s != libc.UintptrFromInt32(0)) {
			break
		}
		*(*uint8)(unsafe.Pointer((*Tcnfa)(unsafe.Pointer(cnfa)).Fstflags + uintptr((*Tstate)(unsafe.Pointer(s)).Fno))) = uint8(0)
		*(*uintptr)(unsafe.Pointer((*Tcnfa)(unsafe.Pointer(cnfa)).Fstates + uintptr((*Tstate)(unsafe.Pointer(s)).Fno)*8)) = ca
		first = ca
		a = (*Tstate)(unsafe.Pointer(s)).Fouts
		for {
			if !(a != libc.UintptrFromInt32(0)) {
				break
			}
			switch (*Tarc)(unsafe.Pointer(a)).Ftype1 {
			case int32('p'):
				(*Tcarc)(unsafe.Pointer(ca)).Fco = (*Tarc)(unsafe.Pointer(a)).Fco
				(*Tcarc)(unsafe.Pointer(ca)).Fto = (*Tstate)(unsafe.Pointer((*Tarc)(unsafe.Pointer(a)).Fto)).Fno
				ca += 16
			case int32('L'):
				(*Tcarc)(unsafe.Pointer(ca)).Fco = int16((*Tcnfa)(unsafe.Pointer(cnfa)).Fncolors + int32((*Tarc)(unsafe.Pointer(a)).Fco))
				(*Tcarc)(unsafe.Pointer(ca)).Fto = (*Tstate)(unsafe.Pointer((*Tarc)(unsafe.Pointer(a)).Fto)).Fno
				ca += 16
				*(*int32)(unsafe.Pointer(cnfa + 12)) |= int32(HASLACONS)
			default:
				(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Fnexttype = int32('e')
				if (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr != 0 {
					v5 = (*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr
				} else {
					v5 = int32(REG_ASSERT)
				}
				(*Tvars)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fv)).Ferr = v5
				break
			}
			goto _4
		_4:
			;
			a = (*Tarc)(unsafe.Pointer(a)).Foutchain
		}
		_carcsort(tls, first, libc.Uint64FromInt64((int64(ca)-int64(first))/16))
		(*Tcarc)(unsafe.Pointer(ca)).Fco = int16(-libc.Int32FromInt32(1))
		(*Tcarc)(unsafe.Pointer(ca)).Fto = uint64(0)
		ca += 16
		goto _3
	_3:
		;
		s = (*Tstate)(unsafe.Pointer(s)).Fnext
	}
	/*
	 * Mark no-progress states.
	 */
	a = (*Tstate)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fpre)).Fouts
	for {
		if !(a != libc.UintptrFromInt32(0)) {
			break
		}
		*(*uint8)(unsafe.Pointer((*Tcnfa)(unsafe.Pointer(cnfa)).Fstflags + uintptr((*Tstate)(unsafe.Pointer((*Tarc)(unsafe.Pointer(a)).Fto)).Fno))) = uint8(CNFA_NOPROGRESS)
		goto _6
	_6:
		;
		a = (*Tarc)(unsafe.Pointer(a)).Foutchain
	}
	*(*uint8)(unsafe.Pointer((*Tcnfa)(unsafe.Pointer(cnfa)).Fstflags + uintptr((*Tstate)(unsafe.Pointer((*Tnfa)(unsafe.Pointer(nfa)).Fpre)).Fno))) = uint8(CNFA_NOPROGRESS)
}

// C documentation
//
//	/*
//	 - carcsort - sort compacted-NFA arcs by color
//	 ^ static void carcsort(struct carc *, struct carc *);
//	 */
func _carcsort(tls *libc.TLS, first uintptr, n Tsize_t) {
	if n > uint64(1) {
		libc.Xqsort(tls, first, n, uint64(16), __ccgo_fp(_carc_cmp))
	}
}

func _carc_cmp(tls *libc.TLS, a uintptr, b uintptr) (r int32) {
	var aa, bb uintptr
	_, _ = aa, bb
	aa = a
	bb = b
	if int32((*Tcarc)(unsafe.Pointer(aa)).Fco) < int32((*Tcarc)(unsafe.Pointer(bb)).Fco) {
		return -int32(1)
	}
	if int32((*Tcarc)(unsafe.Pointer(aa)).Fco) > int32((*Tcarc)(unsafe.Pointer(bb)).Fco) {
		return +libc.Int32FromInt32(1)
	}
	if (*Tcarc)(unsafe.Pointer(aa)).Fto < (*Tcarc)(unsafe.Pointer(bb)).Fto {
		return -int32(1)
	}
	if (*Tcarc)(unsafe.Pointer(aa)).Fto > (*Tcarc)(unsafe.Pointer(bb)).Fto {
		return +libc.Int32FromInt32(1)
	}
	return 0
}

// C documentation
//
//	/*
//	 - freecnfa - free a compacted NFA
//	 ^ static void freecnfa(struct cnfa *);
//	 */
func _freecnfa(tls *libc.TLS, cnfa uintptr) {
	/* not empty already */
	(*Tcnfa)(unsafe.Pointer(cnfa)).Fnstates = uint64(0)
	XTclpFree(tls, (*Tcnfa)(unsafe.Pointer(cnfa)).Fstflags)
	XTclpFree(tls, (*Tcnfa)(unsafe.Pointer(cnfa)).Fstates)
	XTclpFree(tls, (*Tcnfa)(unsafe.Pointer(cnfa)).Farcs)
}

// C documentation
//
//	/*
//	 - dumpnfa - dump an NFA in human-readable form
//	 ^ static void dumpnfa(struct nfa *, FILE *);
//	 */
func _dumpnfa(tls *libc.TLS, nfa uintptr, f uintptr) {
	_ = nfa
	_ = f
}

// C documentation
//
//	/*
//	 - dumpcnfa - dump a compacted NFA in human-readable form
//	 ^ static void dumpcnfa(struct cnfa *, FILE *);
//	 */
func _dumpcnfa(tls *libc.TLS, cnfa uintptr, f uintptr) {
	_ = cnfa
	_ = f
}

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */
/*
 * Utility functions for handling cvecs
 * This file is #included by regcomp.c.
 *
 * Copyright © 1998, 1999 Henry Spencer.  All rights reserved.
 *
 * Development of this software was funded, in part, by Cray Research Inc.,
 * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
 * Corporation, none of whom are responsible for the results. The author
 * thanks all of them.
 *
 * Redistribution and use in source and binary forms -- with or without
 * modification -- are permitted for any purpose, provided that
 * redistributions in source form retain this entire copyright notice and
 * indicate the origin and nature of any modifications.
 *
 * I'd appreciate being given credit for this package in the documentation of
 * software which uses it, but that is not a requirement.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
 * HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * Notes:
 * Only (selected) functions in _this_ file should treat chr* as non-constant.
 */

// C documentation
//
//	/*
//	 - newcvec - allocate a new cvec
//	 ^ static struct cvec *newcvec(size_t, size_t);
//	 */
func _newcvec(tls *libc.TLS, nchrs Tsize_t, nranges Tsize_t) (r uintptr) {
	/* ... and this many ranges... */
	var cv uintptr
	var n, nc Tsize_t
	_, _, _ = cv, n, nc
	nc = nchrs + nranges*uint64(2)
	n = uint64(48) + nc*uint64(4)
	cv = XTclpAlloc(tls, n)
	if cv == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	(*Tcvec)(unsafe.Pointer(cv)).Fchrspace = nchrs
	(*Tcvec)(unsafe.Pointer(cv)).Fchrs = cv + libc.UintptrFromInt64(48)
	(*Tcvec)(unsafe.Pointer(cv)).Franges = (*Tcvec)(unsafe.Pointer(cv)).Fchrs + uintptr(nchrs)*4
	(*Tcvec)(unsafe.Pointer(cv)).Frangespace = nranges
	return _clearcvec(tls, cv)
}

// C documentation
//
//	/*
//	 - clearcvec - clear a possibly-new cvec
//	 * Returns pointer as convenience.
//	 ^ static struct cvec *clearcvec(struct cvec *);
//	 */
func _clearcvec(tls *libc.TLS, cv uintptr) (r uintptr) {
	/* character vector */
	(*Tcvec)(unsafe.Pointer(cv)).Fnchrs = uint64(0)
	(*Tcvec)(unsafe.Pointer(cv)).Fnranges = uint64(0)
	return cv
}

// C documentation
//
//	/*
//	 - addchr - add a chr to a cvec
//	 ^ static void addchr(struct cvec *, pchr);
//	 */
func _addchr(tls *libc.TLS, cv uintptr, c Tpchr) {
	/* character to add */
	var v1 Tsize_t
	var v2 uintptr
	_, _ = v1, v2
	v2 = cv
	v1 = *(*Tsize_t)(unsafe.Pointer(v2))
	*(*Tsize_t)(unsafe.Pointer(v2))++
	*(*Tchr)(unsafe.Pointer((*Tcvec)(unsafe.Pointer(cv)).Fchrs + uintptr(v1)*4)) = c
}

// C documentation
//
//	/*
//	 - addrange - add a range to a cvec
//	 ^ static void addrange(struct cvec *, pchr, pchr);
//	 */
func _addrange(tls *libc.TLS, cv uintptr, from Tpchr, to Tpchr) {
	/* last character of range */
	*(*Tchr)(unsafe.Pointer((*Tcvec)(unsafe.Pointer(cv)).Franges + uintptr((*Tcvec)(unsafe.Pointer(cv)).Fnranges*uint64(2))*4)) = from
	*(*Tchr)(unsafe.Pointer((*Tcvec)(unsafe.Pointer(cv)).Franges + uintptr((*Tcvec)(unsafe.Pointer(cv)).Fnranges*uint64(2)+uint64(1))*4)) = to
	(*Tcvec)(unsafe.Pointer(cv)).Fnranges++
}

// C documentation
//
//	/*
//	 - getcvec - get a cvec, remembering it as v->cv
//	 ^ static struct cvec *getcvec(struct vars *, int, int);
//	 */
func _getcvec(tls *libc.TLS, v uintptr, nchrs Tsize_t, nranges Tsize_t) (r uintptr) {
	/* ... and this many ranges... */
	var v1 int32
	_ = v1
	if (*Tvars)(unsafe.Pointer(v)).Fcv != libc.UintptrFromInt32(0) && nchrs <= (*Tcvec)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fcv)).Fchrspace && nranges <= (*Tcvec)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fcv)).Frangespace {
		return _clearcvec(tls, (*Tvars)(unsafe.Pointer(v)).Fcv)
	}
	if (*Tvars)(unsafe.Pointer(v)).Fcv != libc.UintptrFromInt32(0) {
		_freecvec(tls, (*Tvars)(unsafe.Pointer(v)).Fcv)
	}
	(*Tvars)(unsafe.Pointer(v)).Fcv = _newcvec(tls, nchrs, nranges)
	if (*Tvars)(unsafe.Pointer(v)).Fcv == libc.UintptrFromInt32(0) {
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			v1 = (*Tvars)(unsafe.Pointer(v)).Ferr
		} else {
			v1 = int32(REG_ESPACE)
		}
		(*Tvars)(unsafe.Pointer(v)).Ferr = v1
	}
	return (*Tvars)(unsafe.Pointer(v)).Fcv
}

// C documentation
//
//	/*
//	 - freecvec - free a cvec
//	 ^ static void freecvec(struct cvec *);
//	 */
func _freecvec(tls *libc.TLS, cv uintptr) {
	/* character vector */
	XTclpFree(tls, cv)
}

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */
/*
 * regc_locale.c --
 *
 *	This file contains the Unicode locale specific regexp routines.
 *	This file is #included by regcomp.c.
 *
 * Copyright © 1998 Scriptics Corporation.
 *
 * See the file "license.terms" for information on usage and redistribution of
 * this file, and for a DISCLAIMER OF ALL WARRANTIES.
 */

/* ASCII character-name table */

type Tcname = struct {
	Fname uintptr
	Fcode uint8
}

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */
/*
 * regc_locale.c --
 *
 *	This file contains the Unicode locale specific regexp routines.
 *	This file is #included by regcomp.c.
 *
 * Copyright © 1998 Scriptics Corporation.
 *
 * See the file "license.terms" for information on usage and redistribution of
 * this file, and for a DISCLAIMER OF ALL WARRANTIES.
 */

/* ASCII character-name table */

var _cnames = [96]Tcname{
	0: {
		Fname: __ccgo_ts + 360,
	},
	1: {
		Fname: __ccgo_ts + 364,
		Fcode: uint8('\x01'),
	},
	2: {
		Fname: __ccgo_ts + 368,
		Fcode: uint8('\x02'),
	},
	3: {
		Fname: __ccgo_ts + 372,
		Fcode: uint8('\x03'),
	},
	4: {
		Fname: __ccgo_ts + 376,
		Fcode: uint8('\x04'),
	},
	5: {
		Fname: __ccgo_ts + 380,
		Fcode: uint8('\x05'),
	},
	6: {
		Fname: __ccgo_ts + 384,
		Fcode: uint8('\x06'),
	},
	7: {
		Fname: __ccgo_ts + 388,
		Fcode: uint8('\x07'),
	},
	8: {
		Fname: __ccgo_ts + 392,
		Fcode: uint8('\x07'),
	},
	9: {
		Fname: __ccgo_ts + 398,
		Fcode: uint8('\x08'),
	},
	10: {
		Fname: __ccgo_ts + 401,
		Fcode: uint8('\x08'),
	},
	11: {
		Fname: __ccgo_ts + 411,
		Fcode: uint8('\x09'),
	},
	12: {
		Fname: __ccgo_ts + 414,
		Fcode: uint8('\x09'),
	},
	13: {
		Fname: __ccgo_ts + 418,
		Fcode: uint8('\x0A'),
	},
	14: {
		Fname: __ccgo_ts + 421,
		Fcode: uint8('\x0A'),
	},
	15: {
		Fname: __ccgo_ts + 429,
		Fcode: uint8('\x0B'),
	},
	16: {
		Fname: __ccgo_ts + 432,
		Fcode: uint8('\x0B'),
	},
	17: {
		Fname: __ccgo_ts + 445,
		Fcode: uint8('\x0C'),
	},
	18: {
		Fname: __ccgo_ts + 448,
		Fcode: uint8('\x0C'),
	},
	19: {
		Fname: __ccgo_ts + 458,
		Fcode: uint8('\x0D'),
	},
	20: {
		Fname: __ccgo_ts + 461,
		Fcode: uint8('\x0D'),
	},
	21: {
		Fname: __ccgo_ts + 477,
		Fcode: uint8('\x0E'),
	},
	22: {
		Fname: __ccgo_ts + 480,
		Fcode: uint8('\x0F'),
	},
	23: {
		Fname: __ccgo_ts + 483,
		Fcode: uint8('\x10'),
	},
	24: {
		Fname: __ccgo_ts + 487,
		Fcode: uint8('\x11'),
	},
	25: {
		Fname: __ccgo_ts + 491,
		Fcode: uint8('\x12'),
	},
	26: {
		Fname: __ccgo_ts + 495,
		Fcode: uint8('\x13'),
	},
	27: {
		Fname: __ccgo_ts + 499,
		Fcode: uint8('\x14'),
	},
	28: {
		Fname: __ccgo_ts + 503,
		Fcode: uint8('\x15'),
	},
	29: {
		Fname: __ccgo_ts + 507,
		Fcode: uint8('\x16'),
	},
	30: {
		Fname: __ccgo_ts + 511,
		Fcode: uint8('\x17'),
	},
	31: {
		Fname: __ccgo_ts + 515,
		Fcode: uint8('\x18'),
	},
	32: {
		Fname: __ccgo_ts + 519,
		Fcode: uint8('\x19'),
	},
	33: {
		Fname: __ccgo_ts + 522,
		Fcode: uint8('\x1A'),
	},
	34: {
		Fname: __ccgo_ts + 526,
		Fcode: uint8('\x1B'),
	},
	35: {
		Fname: __ccgo_ts + 530,
		Fcode: uint8('\x1C'),
	},
	36: {
		Fname: __ccgo_ts + 534,
		Fcode: uint8('\x1C'),
	},
	37: {
		Fname: __ccgo_ts + 537,
		Fcode: uint8('\x1D'),
	},
	38: {
		Fname: __ccgo_ts + 541,
		Fcode: uint8('\x1D'),
	},
	39: {
		Fname: __ccgo_ts + 544,
		Fcode: uint8('\x1E'),
	},
	40: {
		Fname: __ccgo_ts + 548,
		Fcode: uint8('\x1E'),
	},
	41: {
		Fname: __ccgo_ts + 551,
		Fcode: uint8('\x1F'),
	},
	42: {
		Fname: __ccgo_ts + 555,
		Fcode: uint8('\x1F'),
	},
	43: {
		Fname: __ccgo_ts + 558,
		Fcode: uint8(' '),
	},
	44: {
		Fname: __ccgo_ts + 564,
		Fcode: uint8('!'),
	},
	45: {
		Fname: __ccgo_ts + 581,
		Fcode: uint8('"'),
	},
	46: {
		Fname: __ccgo_ts + 596,
		Fcode: uint8('#'),
	},
	47: {
		Fname: __ccgo_ts + 608,
		Fcode: uint8('$'),
	},
	48: {
		Fname: __ccgo_ts + 620,
		Fcode: uint8('%'),
	},
	49: {
		Fname: __ccgo_ts + 633,
		Fcode: uint8('&'),
	},
	50: {
		Fname: __ccgo_ts + 643,
		Fcode: uint8('\''),
	},
	51: {
		Fname: __ccgo_ts + 654,
		Fcode: uint8('('),
	},
	52: {
		Fname: __ccgo_ts + 671,
		Fcode: uint8(')'),
	},
	53: {
		Fname: __ccgo_ts + 689,
		Fcode: uint8('*'),
	},
	54: {
		Fname: __ccgo_ts + 698,
		Fcode: uint8('+'),
	},
	55: {
		Fname: __ccgo_ts + 708,
		Fcode: uint8(','),
	},
	56: {
		Fname: __ccgo_ts + 714,
		Fcode: uint8('-'),
	},
	57: {
		Fname: __ccgo_ts + 721,
		Fcode: uint8('-'),
	},
	58: {
		Fname: __ccgo_ts + 734,
		Fcode: uint8('.'),
	},
	59: {
		Fname: __ccgo_ts + 741,
		Fcode: uint8('.'),
	},
	60: {
		Fname: __ccgo_ts + 751,
		Fcode: uint8('/'),
	},
	61: {
		Fname: __ccgo_ts + 757,
		Fcode: uint8('/'),
	},
	62: {
		Fname: __ccgo_ts + 765,
		Fcode: uint8('0'),
	},
	63: {
		Fname: __ccgo_ts + 770,
		Fcode: uint8('1'),
	},
	64: {
		Fname: __ccgo_ts + 774,
		Fcode: uint8('2'),
	},
	65: {
		Fname: __ccgo_ts + 778,
		Fcode: uint8('3'),
	},
	66: {
		Fname: __ccgo_ts + 784,
		Fcode: uint8('4'),
	},
	67: {
		Fname: __ccgo_ts + 789,
		Fcode: uint8('5'),
	},
	68: {
		Fname: __ccgo_ts + 794,
		Fcode: uint8('6'),
	},
	69: {
		Fname: __ccgo_ts + 798,
		Fcode: uint8('7'),
	},
	70: {
		Fname: __ccgo_ts + 804,
		Fcode: uint8('8'),
	},
	71: {
		Fname: __ccgo_ts + 810,
		Fcode: uint8('9'),
	},
	72: {
		Fname: __ccgo_ts + 815,
		Fcode: uint8(':'),
	},
	73: {
		Fname: __ccgo_ts + 821,
		Fcode: uint8(';'),
	},
	74: {
		Fname: __ccgo_ts + 831,
		Fcode: uint8('<'),
	},
	75: {
		Fname: __ccgo_ts + 846,
		Fcode: uint8('='),
	},
	76: {
		Fname: __ccgo_ts + 858,
		Fcode: uint8('>'),
	},
	77: {
		Fname: __ccgo_ts + 876,
		Fcode: uint8('?'),
	},
	78: {
		Fname: __ccgo_ts + 890,
		Fcode: uint8('@'),
	},
	79: {
		Fname: __ccgo_ts + 904,
		Fcode: uint8('['),
	},
	80: {
		Fname: __ccgo_ts + 924,
		Fcode: uint8('\\'),
	},
	81: {
		Fname: __ccgo_ts + 934,
		Fcode: uint8('\\'),
	},
	82: {
		Fname: __ccgo_ts + 950,
		Fcode: uint8(']'),
	},
	83: {
		Fname: __ccgo_ts + 971,
		Fcode: uint8('^'),
	},
	84: {
		Fname: __ccgo_ts + 982,
		Fcode: uint8('^'),
	},
	85: {
		Fname: __ccgo_ts + 1000,
		Fcode: uint8('_'),
	},
	86: {
		Fname: __ccgo_ts + 1011,
		Fcode: uint8('_'),
	},
	87: {
		Fname: __ccgo_ts + 1020,
		Fcode: uint8('`'),
	},
	88: {
		Fname: __ccgo_ts + 1033,
		Fcode: uint8('{'),
	},
	89: {
		Fname: __ccgo_ts + 1044,
		Fcode: uint8('{'),
	},
	90: {
		Fname: __ccgo_ts + 1063,
		Fcode: uint8('|'),
	},
	91: {
		Fname: __ccgo_ts + 1077,
		Fcode: uint8('}'),
	},
	92: {
		Fname: __ccgo_ts + 1089,
		Fcode: uint8('}'),
	},
	93: {
		Fname: __ccgo_ts + 1109,
		Fcode: uint8('~'),
	},
	94: {
		Fname: __ccgo_ts + 1115,
		Fcode: uint8('\x7F'),
	},
	95: {},
}

/*
 * Unicode character-class tables.
 */

type Tcrange = struct {
	Fstart Tchr
	Fend   Tchr
}

/*
 *	Declarations of Unicode character ranges.  This code
 *	is automatically generated by the tools/uniClass.tcl script
 *	and used in generic/regc_locale.c.  Do not modify by hand.
 */

/*
 * Unicode: alphabetic characters.
 */

var _alphaRangeTable = [471]Tcrange{
	0: {
		Fstart: int32(0x41),
		Fend:   int32(0x5A),
	},
	1: {
		Fstart: int32(0x61),
		Fend:   int32(0x7A),
	},
	2: {
		Fstart: int32(0xC0),
		Fend:   int32(0xD6),
	},
	3: {
		Fstart: int32(0xD8),
		Fend:   int32(0xF6),
	},
	4: {
		Fstart: int32(0xF8),
		Fend:   int32(0x2C1),
	},
	5: {
		Fstart: int32(0x2C6),
		Fend:   int32(0x2D1),
	},
	6: {
		Fstart: int32(0x2E0),
		Fend:   int32(0x2E4),
	},
	7: {
		Fstart: int32(0x370),
		Fend:   int32(0x374),
	},
	8: {
		Fstart: int32(0x37A),
		Fend:   int32(0x37D),
	},
	9: {
		Fstart: int32(0x388),
		Fend:   int32(0x38A),
	},
	10: {
		Fstart: int32(0x38E),
		Fend:   int32(0x3A1),
	},
	11: {
		Fstart: int32(0x3A3),
		Fend:   int32(0x3F5),
	},
	12: {
		Fstart: int32(0x3F7),
		Fend:   int32(0x481),
	},
	13: {
		Fstart: int32(0x48A),
		Fend:   int32(0x52F),
	},
	14: {
		Fstart: int32(0x531),
		Fend:   int32(0x556),
	},
	15: {
		Fstart: int32(0x560),
		Fend:   int32(0x588),
	},
	16: {
		Fstart: int32(0x5D0),
		Fend:   int32(0x5EA),
	},
	17: {
		Fstart: int32(0x5EF),
		Fend:   int32(0x5F2),
	},
	18: {
		Fstart: int32(0x620),
		Fend:   int32(0x64A),
	},
	19: {
		Fstart: int32(0x671),
		Fend:   int32(0x6D3),
	},
	20: {
		Fstart: int32(0x6FA),
		Fend:   int32(0x6FC),
	},
	21: {
		Fstart: int32(0x712),
		Fend:   int32(0x72F),
	},
	22: {
		Fstart: int32(0x74D),
		Fend:   int32(0x7A5),
	},
	23: {
		Fstart: int32(0x7CA),
		Fend:   int32(0x7EA),
	},
	24: {
		Fstart: int32(0x800),
		Fend:   int32(0x815),
	},
	25: {
		Fstart: int32(0x840),
		Fend:   int32(0x858),
	},
	26: {
		Fstart: int32(0x860),
		Fend:   int32(0x86A),
	},
	27: {
		Fstart: int32(0x870),
		Fend:   int32(0x887),
	},
	28: {
		Fstart: int32(0x889),
		Fend:   int32(0x88E),
	},
	29: {
		Fstart: int32(0x8A0),
		Fend:   int32(0x8C9),
	},
	30: {
		Fstart: int32(0x904),
		Fend:   int32(0x939),
	},
	31: {
		Fstart: int32(0x958),
		Fend:   int32(0x961),
	},
	32: {
		Fstart: int32(0x971),
		Fend:   int32(0x980),
	},
	33: {
		Fstart: int32(0x985),
		Fend:   int32(0x98C),
	},
	34: {
		Fstart: int32(0x993),
		Fend:   int32(0x9A8),
	},
	35: {
		Fstart: int32(0x9AA),
		Fend:   int32(0x9B0),
	},
	36: {
		Fstart: int32(0x9B6),
		Fend:   int32(0x9B9),
	},
	37: {
		Fstart: int32(0x9DF),
		Fend:   int32(0x9E1),
	},
	38: {
		Fstart: int32(0xA05),
		Fend:   int32(0xA0A),
	},
	39: {
		Fstart: int32(0xA13),
		Fend:   int32(0xA28),
	},
	40: {
		Fstart: int32(0xA2A),
		Fend:   int32(0xA30),
	},
	41: {
		Fstart: int32(0xA59),
		Fend:   int32(0xA5C),
	},
	42: {
		Fstart: int32(0xA72),
		Fend:   int32(0xA74),
	},
	43: {
		Fstart: int32(0xA85),
		Fend:   int32(0xA8D),
	},
	44: {
		Fstart: int32(0xA8F),
		Fend:   int32(0xA91),
	},
	45: {
		Fstart: int32(0xA93),
		Fend:   int32(0xAA8),
	},
	46: {
		Fstart: int32(0xAAA),
		Fend:   int32(0xAB0),
	},
	47: {
		Fstart: int32(0xAB5),
		Fend:   int32(0xAB9),
	},
	48: {
		Fstart: int32(0xB05),
		Fend:   int32(0xB0C),
	},
	49: {
		Fstart: int32(0xB13),
		Fend:   int32(0xB28),
	},
	50: {
		Fstart: int32(0xB2A),
		Fend:   int32(0xB30),
	},
	51: {
		Fstart: int32(0xB35),
		Fend:   int32(0xB39),
	},
	52: {
		Fstart: int32(0xB5F),
		Fend:   int32(0xB61),
	},
	53: {
		Fstart: int32(0xB85),
		Fend:   int32(0xB8A),
	},
	54: {
		Fstart: int32(0xB8E),
		Fend:   int32(0xB90),
	},
	55: {
		Fstart: int32(0xB92),
		Fend:   int32(0xB95),
	},
	56: {
		Fstart: int32(0xBA8),
		Fend:   int32(0xBAA),
	},
	57: {
		Fstart: int32(0xBAE),
		Fend:   int32(0xBB9),
	},
	58: {
		Fstart: int32(0xC05),
		Fend:   int32(0xC0C),
	},
	59: {
		Fstart: int32(0xC0E),
		Fend:   int32(0xC10),
	},
	60: {
		Fstart: int32(0xC12),
		Fend:   int32(0xC28),
	},
	61: {
		Fstart: int32(0xC2A),
		Fend:   int32(0xC39),
	},
	62: {
		Fstart: int32(0xC58),
		Fend:   int32(0xC5A),
	},
	63: {
		Fstart: int32(0xC85),
		Fend:   int32(0xC8C),
	},
	64: {
		Fstart: int32(0xC8E),
		Fend:   int32(0xC90),
	},
	65: {
		Fstart: int32(0xC92),
		Fend:   int32(0xCA8),
	},
	66: {
		Fstart: int32(0xCAA),
		Fend:   int32(0xCB3),
	},
	67: {
		Fstart: int32(0xCB5),
		Fend:   int32(0xCB9),
	},
	68: {
		Fstart: int32(0xD04),
		Fend:   int32(0xD0C),
	},
	69: {
		Fstart: int32(0xD0E),
		Fend:   int32(0xD10),
	},
	70: {
		Fstart: int32(0xD12),
		Fend:   int32(0xD3A),
	},
	71: {
		Fstart: int32(0xD54),
		Fend:   int32(0xD56),
	},
	72: {
		Fstart: int32(0xD5F),
		Fend:   int32(0xD61),
	},
	73: {
		Fstart: int32(0xD7A),
		Fend:   int32(0xD7F),
	},
	74: {
		Fstart: int32(0xD85),
		Fend:   int32(0xD96),
	},
	75: {
		Fstart: int32(0xD9A),
		Fend:   int32(0xDB1),
	},
	76: {
		Fstart: int32(0xDB3),
		Fend:   int32(0xDBB),
	},
	77: {
		Fstart: int32(0xDC0),
		Fend:   int32(0xDC6),
	},
	78: {
		Fstart: int32(0xE01),
		Fend:   int32(0xE30),
	},
	79: {
		Fstart: int32(0xE40),
		Fend:   int32(0xE46),
	},
	80: {
		Fstart: int32(0xE86),
		Fend:   int32(0xE8A),
	},
	81: {
		Fstart: int32(0xE8C),
		Fend:   int32(0xEA3),
	},
	82: {
		Fstart: int32(0xEA7),
		Fend:   int32(0xEB0),
	},
	83: {
		Fstart: int32(0xEC0),
		Fend:   int32(0xEC4),
	},
	84: {
		Fstart: int32(0xEDC),
		Fend:   int32(0xEDF),
	},
	85: {
		Fstart: int32(0xF40),
		Fend:   int32(0xF47),
	},
	86: {
		Fstart: int32(0xF49),
		Fend:   int32(0xF6C),
	},
	87: {
		Fstart: int32(0xF88),
		Fend:   int32(0xF8C),
	},
	88: {
		Fstart: int32(0x1000),
		Fend:   int32(0x102A),
	},
	89: {
		Fstart: int32(0x1050),
		Fend:   int32(0x1055),
	},
	90: {
		Fstart: int32(0x105A),
		Fend:   int32(0x105D),
	},
	91: {
		Fstart: int32(0x106E),
		Fend:   int32(0x1070),
	},
	92: {
		Fstart: int32(0x1075),
		Fend:   int32(0x1081),
	},
	93: {
		Fstart: int32(0x10A0),
		Fend:   int32(0x10C5),
	},
	94: {
		Fstart: int32(0x10D0),
		Fend:   int32(0x10FA),
	},
	95: {
		Fstart: int32(0x10FC),
		Fend:   int32(0x1248),
	},
	96: {
		Fstart: int32(0x124A),
		Fend:   int32(0x124D),
	},
	97: {
		Fstart: int32(0x1250),
		Fend:   int32(0x1256),
	},
	98: {
		Fstart: int32(0x125A),
		Fend:   int32(0x125D),
	},
	99: {
		Fstart: int32(0x1260),
		Fend:   int32(0x1288),
	},
	100: {
		Fstart: int32(0x128A),
		Fend:   int32(0x128D),
	},
	101: {
		Fstart: int32(0x1290),
		Fend:   int32(0x12B0),
	},
	102: {
		Fstart: int32(0x12B2),
		Fend:   int32(0x12B5),
	},
	103: {
		Fstart: int32(0x12B8),
		Fend:   int32(0x12BE),
	},
	104: {
		Fstart: int32(0x12C2),
		Fend:   int32(0x12C5),
	},
	105: {
		Fstart: int32(0x12C8),
		Fend:   int32(0x12D6),
	},
	106: {
		Fstart: int32(0x12D8),
		Fend:   int32(0x1310),
	},
	107: {
		Fstart: int32(0x1312),
		Fend:   int32(0x1315),
	},
	108: {
		Fstart: int32(0x1318),
		Fend:   int32(0x135A),
	},
	109: {
		Fstart: int32(0x1380),
		Fend:   int32(0x138F),
	},
	110: {
		Fstart: int32(0x13A0),
		Fend:   int32(0x13F5),
	},
	111: {
		Fstart: int32(0x13F8),
		Fend:   int32(0x13FD),
	},
	112: {
		Fstart: int32(0x1401),
		Fend:   int32(0x166C),
	},
	113: {
		Fstart: int32(0x166F),
		Fend:   int32(0x167F),
	},
	114: {
		Fstart: int32(0x1681),
		Fend:   int32(0x169A),
	},
	115: {
		Fstart: int32(0x16A0),
		Fend:   int32(0x16EA),
	},
	116: {
		Fstart: int32(0x16F1),
		Fend:   int32(0x16F8),
	},
	117: {
		Fstart: int32(0x1700),
		Fend:   int32(0x1711),
	},
	118: {
		Fstart: int32(0x171F),
		Fend:   int32(0x1731),
	},
	119: {
		Fstart: int32(0x1740),
		Fend:   int32(0x1751),
	},
	120: {
		Fstart: int32(0x1760),
		Fend:   int32(0x176C),
	},
	121: {
		Fstart: int32(0x176E),
		Fend:   int32(0x1770),
	},
	122: {
		Fstart: int32(0x1780),
		Fend:   int32(0x17B3),
	},
	123: {
		Fstart: int32(0x1820),
		Fend:   int32(0x1878),
	},
	124: {
		Fstart: int32(0x1880),
		Fend:   int32(0x1884),
	},
	125: {
		Fstart: int32(0x1887),
		Fend:   int32(0x18A8),
	},
	126: {
		Fstart: int32(0x18B0),
		Fend:   int32(0x18F5),
	},
	127: {
		Fstart: int32(0x1900),
		Fend:   int32(0x191E),
	},
	128: {
		Fstart: int32(0x1950),
		Fend:   int32(0x196D),
	},
	129: {
		Fstart: int32(0x1970),
		Fend:   int32(0x1974),
	},
	130: {
		Fstart: int32(0x1980),
		Fend:   int32(0x19AB),
	},
	131: {
		Fstart: int32(0x19B0),
		Fend:   int32(0x19C9),
	},
	132: {
		Fstart: int32(0x1A00),
		Fend:   int32(0x1A16),
	},
	133: {
		Fstart: int32(0x1A20),
		Fend:   int32(0x1A54),
	},
	134: {
		Fstart: int32(0x1B05),
		Fend:   int32(0x1B33),
	},
	135: {
		Fstart: int32(0x1B45),
		Fend:   int32(0x1B4C),
	},
	136: {
		Fstart: int32(0x1B83),
		Fend:   int32(0x1BA0),
	},
	137: {
		Fstart: int32(0x1BBA),
		Fend:   int32(0x1BE5),
	},
	138: {
		Fstart: int32(0x1C00),
		Fend:   int32(0x1C23),
	},
	139: {
		Fstart: int32(0x1C4D),
		Fend:   int32(0x1C4F),
	},
	140: {
		Fstart: int32(0x1C5A),
		Fend:   int32(0x1C7D),
	},
	141: {
		Fstart: int32(0x1C80),
		Fend:   int32(0x1C8A),
	},
	142: {
		Fstart: int32(0x1C90),
		Fend:   int32(0x1CBA),
	},
	143: {
		Fstart: int32(0x1CBD),
		Fend:   int32(0x1CBF),
	},
	144: {
		Fstart: int32(0x1CE9),
		Fend:   int32(0x1CEC),
	},
	145: {
		Fstart: int32(0x1CEE),
		Fend:   int32(0x1CF3),
	},
	146: {
		Fstart: int32(0x1D00),
		Fend:   int32(0x1DBF),
	},
	147: {
		Fstart: int32(0x1E00),
		Fend:   int32(0x1F15),
	},
	148: {
		Fstart: int32(0x1F18),
		Fend:   int32(0x1F1D),
	},
	149: {
		Fstart: int32(0x1F20),
		Fend:   int32(0x1F45),
	},
	150: {
		Fstart: int32(0x1F48),
		Fend:   int32(0x1F4D),
	},
	151: {
		Fstart: int32(0x1F50),
		Fend:   int32(0x1F57),
	},
	152: {
		Fstart: int32(0x1F5F),
		Fend:   int32(0x1F7D),
	},
	153: {
		Fstart: int32(0x1F80),
		Fend:   int32(0x1FB4),
	},
	154: {
		Fstart: int32(0x1FB6),
		Fend:   int32(0x1FBC),
	},
	155: {
		Fstart: int32(0x1FC2),
		Fend:   int32(0x1FC4),
	},
	156: {
		Fstart: int32(0x1FC6),
		Fend:   int32(0x1FCC),
	},
	157: {
		Fstart: int32(0x1FD0),
		Fend:   int32(0x1FD3),
	},
	158: {
		Fstart: int32(0x1FD6),
		Fend:   int32(0x1FDB),
	},
	159: {
		Fstart: int32(0x1FE0),
		Fend:   int32(0x1FEC),
	},
	160: {
		Fstart: int32(0x1FF2),
		Fend:   int32(0x1FF4),
	},
	161: {
		Fstart: int32(0x1FF6),
		Fend:   int32(0x1FFC),
	},
	162: {
		Fstart: int32(0x2090),
		Fend:   int32(0x209C),
	},
	163: {
		Fstart: int32(0x210A),
		Fend:   int32(0x2113),
	},
	164: {
		Fstart: int32(0x2119),
		Fend:   int32(0x211D),
	},
	165: {
		Fstart: int32(0x212A),
		Fend:   int32(0x212D),
	},
	166: {
		Fstart: int32(0x212F),
		Fend:   int32(0x2139),
	},
	167: {
		Fstart: int32(0x213C),
		Fend:   int32(0x213F),
	},
	168: {
		Fstart: int32(0x2145),
		Fend:   int32(0x2149),
	},
	169: {
		Fstart: int32(0x2C00),
		Fend:   int32(0x2CE4),
	},
	170: {
		Fstart: int32(0x2CEB),
		Fend:   int32(0x2CEE),
	},
	171: {
		Fstart: int32(0x2D00),
		Fend:   int32(0x2D25),
	},
	172: {
		Fstart: int32(0x2D30),
		Fend:   int32(0x2D67),
	},
	173: {
		Fstart: int32(0x2D80),
		Fend:   int32(0x2D96),
	},
	174: {
		Fstart: int32(0x2DA0),
		Fend:   int32(0x2DA6),
	},
	175: {
		Fstart: int32(0x2DA8),
		Fend:   int32(0x2DAE),
	},
	176: {
		Fstart: int32(0x2DB0),
		Fend:   int32(0x2DB6),
	},
	177: {
		Fstart: int32(0x2DB8),
		Fend:   int32(0x2DBE),
	},
	178: {
		Fstart: int32(0x2DC0),
		Fend:   int32(0x2DC6),
	},
	179: {
		Fstart: int32(0x2DC8),
		Fend:   int32(0x2DCE),
	},
	180: {
		Fstart: int32(0x2DD0),
		Fend:   int32(0x2DD6),
	},
	181: {
		Fstart: int32(0x2DD8),
		Fend:   int32(0x2DDE),
	},
	182: {
		Fstart: int32(0x3031),
		Fend:   int32(0x3035),
	},
	183: {
		Fstart: int32(0x3041),
		Fend:   int32(0x3096),
	},
	184: {
		Fstart: int32(0x309D),
		Fend:   int32(0x309F),
	},
	185: {
		Fstart: int32(0x30A1),
		Fend:   int32(0x30FA),
	},
	186: {
		Fstart: int32(0x30FC),
		Fend:   int32(0x30FF),
	},
	187: {
		Fstart: int32(0x3105),
		Fend:   int32(0x312F),
	},
	188: {
		Fstart: int32(0x3131),
		Fend:   int32(0x318E),
	},
	189: {
		Fstart: int32(0x31A0),
		Fend:   int32(0x31BF),
	},
	190: {
		Fstart: int32(0x31F0),
		Fend:   int32(0x31FF),
	},
	191: {
		Fstart: int32(0x3400),
		Fend:   int32(0x4DBF),
	},
	192: {
		Fstart: int32(0x4E00),
		Fend:   int32(0xA48C),
	},
	193: {
		Fstart: int32(0xA4D0),
		Fend:   int32(0xA4FD),
	},
	194: {
		Fstart: int32(0xA500),
		Fend:   int32(0xA60C),
	},
	195: {
		Fstart: int32(0xA610),
		Fend:   int32(0xA61F),
	},
	196: {
		Fstart: int32(0xA640),
		Fend:   int32(0xA66E),
	},
	197: {
		Fstart: int32(0xA67F),
		Fend:   int32(0xA69D),
	},
	198: {
		Fstart: int32(0xA6A0),
		Fend:   int32(0xA6E5),
	},
	199: {
		Fstart: int32(0xA717),
		Fend:   int32(0xA71F),
	},
	200: {
		Fstart: int32(0xA722),
		Fend:   int32(0xA788),
	},
	201: {
		Fstart: int32(0xA78B),
		Fend:   int32(0xA7CD),
	},
	202: {
		Fstart: int32(0xA7D5),
		Fend:   int32(0xA7DC),
	},
	203: {
		Fstart: int32(0xA7F2),
		Fend:   int32(0xA801),
	},
	204: {
		Fstart: int32(0xA803),
		Fend:   int32(0xA805),
	},
	205: {
		Fstart: int32(0xA807),
		Fend:   int32(0xA80A),
	},
	206: {
		Fstart: int32(0xA80C),
		Fend:   int32(0xA822),
	},
	207: {
		Fstart: int32(0xA840),
		Fend:   int32(0xA873),
	},
	208: {
		Fstart: int32(0xA882),
		Fend:   int32(0xA8B3),
	},
	209: {
		Fstart: int32(0xA8F2),
		Fend:   int32(0xA8F7),
	},
	210: {
		Fstart: int32(0xA90A),
		Fend:   int32(0xA925),
	},
	211: {
		Fstart: int32(0xA930),
		Fend:   int32(0xA946),
	},
	212: {
		Fstart: int32(0xA960),
		Fend:   int32(0xA97C),
	},
	213: {
		Fstart: int32(0xA984),
		Fend:   int32(0xA9B2),
	},
	214: {
		Fstart: int32(0xA9E0),
		Fend:   int32(0xA9E4),
	},
	215: {
		Fstart: int32(0xA9E6),
		Fend:   int32(0xA9EF),
	},
	216: {
		Fstart: int32(0xA9FA),
		Fend:   int32(0xA9FE),
	},
	217: {
		Fstart: int32(0xAA00),
		Fend:   int32(0xAA28),
	},
	218: {
		Fstart: int32(0xAA40),
		Fend:   int32(0xAA42),
	},
	219: {
		Fstart: int32(0xAA44),
		Fend:   int32(0xAA4B),
	},
	220: {
		Fstart: int32(0xAA60),
		Fend:   int32(0xAA76),
	},
	221: {
		Fstart: int32(0xAA7E),
		Fend:   int32(0xAAAF),
	},
	222: {
		Fstart: int32(0xAAB9),
		Fend:   int32(0xAABD),
	},
	223: {
		Fstart: int32(0xAADB),
		Fend:   int32(0xAADD),
	},
	224: {
		Fstart: int32(0xAAE0),
		Fend:   int32(0xAAEA),
	},
	225: {
		Fstart: int32(0xAAF2),
		Fend:   int32(0xAAF4),
	},
	226: {
		Fstart: int32(0xAB01),
		Fend:   int32(0xAB06),
	},
	227: {
		Fstart: int32(0xAB09),
		Fend:   int32(0xAB0E),
	},
	228: {
		Fstart: int32(0xAB11),
		Fend:   int32(0xAB16),
	},
	229: {
		Fstart: int32(0xAB20),
		Fend:   int32(0xAB26),
	},
	230: {
		Fstart: int32(0xAB28),
		Fend:   int32(0xAB2E),
	},
	231: {
		Fstart: int32(0xAB30),
		Fend:   int32(0xAB5A),
	},
	232: {
		Fstart: int32(0xAB5C),
		Fend:   int32(0xAB69),
	},
	233: {
		Fstart: int32(0xAB70),
		Fend:   int32(0xABE2),
	},
	234: {
		Fstart: int32(0xAC00),
		Fend:   int32(0xD7A3),
	},
	235: {
		Fstart: int32(0xD7B0),
		Fend:   int32(0xD7C6),
	},
	236: {
		Fstart: int32(0xD7CB),
		Fend:   int32(0xD7FB),
	},
	237: {
		Fstart: int32(0xF900),
		Fend:   int32(0xFA6D),
	},
	238: {
		Fstart: int32(0xFA70),
		Fend:   int32(0xFAD9),
	},
	239: {
		Fstart: int32(0xFB00),
		Fend:   int32(0xFB06),
	},
	240: {
		Fstart: int32(0xFB13),
		Fend:   int32(0xFB17),
	},
	241: {
		Fstart: int32(0xFB1F),
		Fend:   int32(0xFB28),
	},
	242: {
		Fstart: int32(0xFB2A),
		Fend:   int32(0xFB36),
	},
	243: {
		Fstart: int32(0xFB38),
		Fend:   int32(0xFB3C),
	},
	244: {
		Fstart: int32(0xFB46),
		Fend:   int32(0xFBB1),
	},
	245: {
		Fstart: int32(0xFBD3),
		Fend:   int32(0xFD3D),
	},
	246: {
		Fstart: int32(0xFD50),
		Fend:   int32(0xFD8F),
	},
	247: {
		Fstart: int32(0xFD92),
		Fend:   int32(0xFDC7),
	},
	248: {
		Fstart: int32(0xFDF0),
		Fend:   int32(0xFDFB),
	},
	249: {
		Fstart: int32(0xFE70),
		Fend:   int32(0xFE74),
	},
	250: {
		Fstart: int32(0xFE76),
		Fend:   int32(0xFEFC),
	},
	251: {
		Fstart: int32(0xFF21),
		Fend:   int32(0xFF3A),
	},
	252: {
		Fstart: int32(0xFF41),
		Fend:   int32(0xFF5A),
	},
	253: {
		Fstart: int32(0xFF66),
		Fend:   int32(0xFFBE),
	},
	254: {
		Fstart: int32(0xFFC2),
		Fend:   int32(0xFFC7),
	},
	255: {
		Fstart: int32(0xFFCA),
		Fend:   int32(0xFFCF),
	},
	256: {
		Fstart: int32(0xFFD2),
		Fend:   int32(0xFFD7),
	},
	257: {
		Fstart: int32(0xFFDA),
		Fend:   int32(0xFFDC),
	},
	258: {
		Fstart: int32(0x10000),
		Fend:   int32(0x1000B),
	},
	259: {
		Fstart: int32(0x1000D),
		Fend:   int32(0x10026),
	},
	260: {
		Fstart: int32(0x10028),
		Fend:   int32(0x1003A),
	},
	261: {
		Fstart: int32(0x1003F),
		Fend:   int32(0x1004D),
	},
	262: {
		Fstart: int32(0x10050),
		Fend:   int32(0x1005D),
	},
	263: {
		Fstart: int32(0x10080),
		Fend:   int32(0x100FA),
	},
	264: {
		Fstart: int32(0x10280),
		Fend:   int32(0x1029C),
	},
	265: {
		Fstart: int32(0x102A0),
		Fend:   int32(0x102D0),
	},
	266: {
		Fstart: int32(0x10300),
		Fend:   int32(0x1031F),
	},
	267: {
		Fstart: int32(0x1032D),
		Fend:   int32(0x10340),
	},
	268: {
		Fstart: int32(0x10342),
		Fend:   int32(0x10349),
	},
	269: {
		Fstart: int32(0x10350),
		Fend:   int32(0x10375),
	},
	270: {
		Fstart: int32(0x10380),
		Fend:   int32(0x1039D),
	},
	271: {
		Fstart: int32(0x103A0),
		Fend:   int32(0x103C3),
	},
	272: {
		Fstart: int32(0x103C8),
		Fend:   int32(0x103CF),
	},
	273: {
		Fstart: int32(0x10400),
		Fend:   int32(0x1049D),
	},
	274: {
		Fstart: int32(0x104B0),
		Fend:   int32(0x104D3),
	},
	275: {
		Fstart: int32(0x104D8),
		Fend:   int32(0x104FB),
	},
	276: {
		Fstart: int32(0x10500),
		Fend:   int32(0x10527),
	},
	277: {
		Fstart: int32(0x10530),
		Fend:   int32(0x10563),
	},
	278: {
		Fstart: int32(0x10570),
		Fend:   int32(0x1057A),
	},
	279: {
		Fstart: int32(0x1057C),
		Fend:   int32(0x1058A),
	},
	280: {
		Fstart: int32(0x1058C),
		Fend:   int32(0x10592),
	},
	281: {
		Fstart: int32(0x10597),
		Fend:   int32(0x105A1),
	},
	282: {
		Fstart: int32(0x105A3),
		Fend:   int32(0x105B1),
	},
	283: {
		Fstart: int32(0x105B3),
		Fend:   int32(0x105B9),
	},
	284: {
		Fstart: int32(0x105C0),
		Fend:   int32(0x105F3),
	},
	285: {
		Fstart: int32(0x10600),
		Fend:   int32(0x10736),
	},
	286: {
		Fstart: int32(0x10740),
		Fend:   int32(0x10755),
	},
	287: {
		Fstart: int32(0x10760),
		Fend:   int32(0x10767),
	},
	288: {
		Fstart: int32(0x10780),
		Fend:   int32(0x10785),
	},
	289: {
		Fstart: int32(0x10787),
		Fend:   int32(0x107B0),
	},
	290: {
		Fstart: int32(0x107B2),
		Fend:   int32(0x107BA),
	},
	291: {
		Fstart: int32(0x10800),
		Fend:   int32(0x10805),
	},
	292: {
		Fstart: int32(0x1080A),
		Fend:   int32(0x10835),
	},
	293: {
		Fstart: int32(0x1083F),
		Fend:   int32(0x10855),
	},
	294: {
		Fstart: int32(0x10860),
		Fend:   int32(0x10876),
	},
	295: {
		Fstart: int32(0x10880),
		Fend:   int32(0x1089E),
	},
	296: {
		Fstart: int32(0x108E0),
		Fend:   int32(0x108F2),
	},
	297: {
		Fstart: int32(0x10900),
		Fend:   int32(0x10915),
	},
	298: {
		Fstart: int32(0x10920),
		Fend:   int32(0x10939),
	},
	299: {
		Fstart: int32(0x10980),
		Fend:   int32(0x109B7),
	},
	300: {
		Fstart: int32(0x10A10),
		Fend:   int32(0x10A13),
	},
	301: {
		Fstart: int32(0x10A15),
		Fend:   int32(0x10A17),
	},
	302: {
		Fstart: int32(0x10A19),
		Fend:   int32(0x10A35),
	},
	303: {
		Fstart: int32(0x10A60),
		Fend:   int32(0x10A7C),
	},
	304: {
		Fstart: int32(0x10A80),
		Fend:   int32(0x10A9C),
	},
	305: {
		Fstart: int32(0x10AC0),
		Fend:   int32(0x10AC7),
	},
	306: {
		Fstart: int32(0x10AC9),
		Fend:   int32(0x10AE4),
	},
	307: {
		Fstart: int32(0x10B00),
		Fend:   int32(0x10B35),
	},
	308: {
		Fstart: int32(0x10B40),
		Fend:   int32(0x10B55),
	},
	309: {
		Fstart: int32(0x10B60),
		Fend:   int32(0x10B72),
	},
	310: {
		Fstart: int32(0x10B80),
		Fend:   int32(0x10B91),
	},
	311: {
		Fstart: int32(0x10C00),
		Fend:   int32(0x10C48),
	},
	312: {
		Fstart: int32(0x10C80),
		Fend:   int32(0x10CB2),
	},
	313: {
		Fstart: int32(0x10CC0),
		Fend:   int32(0x10CF2),
	},
	314: {
		Fstart: int32(0x10D00),
		Fend:   int32(0x10D23),
	},
	315: {
		Fstart: int32(0x10D4A),
		Fend:   int32(0x10D65),
	},
	316: {
		Fstart: int32(0x10D6F),
		Fend:   int32(0x10D85),
	},
	317: {
		Fstart: int32(0x10E80),
		Fend:   int32(0x10EA9),
	},
	318: {
		Fstart: int32(0x10EC2),
		Fend:   int32(0x10EC4),
	},
	319: {
		Fstart: int32(0x10F00),
		Fend:   int32(0x10F1C),
	},
	320: {
		Fstart: int32(0x10F30),
		Fend:   int32(0x10F45),
	},
	321: {
		Fstart: int32(0x10F70),
		Fend:   int32(0x10F81),
	},
	322: {
		Fstart: int32(0x10FB0),
		Fend:   int32(0x10FC4),
	},
	323: {
		Fstart: int32(0x10FE0),
		Fend:   int32(0x10FF6),
	},
	324: {
		Fstart: int32(0x11003),
		Fend:   int32(0x11037),
	},
	325: {
		Fstart: int32(0x11083),
		Fend:   int32(0x110AF),
	},
	326: {
		Fstart: int32(0x110D0),
		Fend:   int32(0x110E8),
	},
	327: {
		Fstart: int32(0x11103),
		Fend:   int32(0x11126),
	},
	328: {
		Fstart: int32(0x11150),
		Fend:   int32(0x11172),
	},
	329: {
		Fstart: int32(0x11183),
		Fend:   int32(0x111B2),
	},
	330: {
		Fstart: int32(0x111C1),
		Fend:   int32(0x111C4),
	},
	331: {
		Fstart: int32(0x11200),
		Fend:   int32(0x11211),
	},
	332: {
		Fstart: int32(0x11213),
		Fend:   int32(0x1122B),
	},
	333: {
		Fstart: int32(0x11280),
		Fend:   int32(0x11286),
	},
	334: {
		Fstart: int32(0x1128A),
		Fend:   int32(0x1128D),
	},
	335: {
		Fstart: int32(0x1128F),
		Fend:   int32(0x1129D),
	},
	336: {
		Fstart: int32(0x1129F),
		Fend:   int32(0x112A8),
	},
	337: {
		Fstart: int32(0x112B0),
		Fend:   int32(0x112DE),
	},
	338: {
		Fstart: int32(0x11305),
		Fend:   int32(0x1130C),
	},
	339: {
		Fstart: int32(0x11313),
		Fend:   int32(0x11328),
	},
	340: {
		Fstart: int32(0x1132A),
		Fend:   int32(0x11330),
	},
	341: {
		Fstart: int32(0x11335),
		Fend:   int32(0x11339),
	},
	342: {
		Fstart: int32(0x1135D),
		Fend:   int32(0x11361),
	},
	343: {
		Fstart: int32(0x11380),
		Fend:   int32(0x11389),
	},
	344: {
		Fstart: int32(0x11390),
		Fend:   int32(0x113B5),
	},
	345: {
		Fstart: int32(0x11400),
		Fend:   int32(0x11434),
	},
	346: {
		Fstart: int32(0x11447),
		Fend:   int32(0x1144A),
	},
	347: {
		Fstart: int32(0x1145F),
		Fend:   int32(0x11461),
	},
	348: {
		Fstart: int32(0x11480),
		Fend:   int32(0x114AF),
	},
	349: {
		Fstart: int32(0x11580),
		Fend:   int32(0x115AE),
	},
	350: {
		Fstart: int32(0x115D8),
		Fend:   int32(0x115DB),
	},
	351: {
		Fstart: int32(0x11600),
		Fend:   int32(0x1162F),
	},
	352: {
		Fstart: int32(0x11680),
		Fend:   int32(0x116AA),
	},
	353: {
		Fstart: int32(0x11700),
		Fend:   int32(0x1171A),
	},
	354: {
		Fstart: int32(0x11740),
		Fend:   int32(0x11746),
	},
	355: {
		Fstart: int32(0x11800),
		Fend:   int32(0x1182B),
	},
	356: {
		Fstart: int32(0x118A0),
		Fend:   int32(0x118DF),
	},
	357: {
		Fstart: int32(0x118FF),
		Fend:   int32(0x11906),
	},
	358: {
		Fstart: int32(0x1190C),
		Fend:   int32(0x11913),
	},
	359: {
		Fstart: int32(0x11918),
		Fend:   int32(0x1192F),
	},
	360: {
		Fstart: int32(0x119A0),
		Fend:   int32(0x119A7),
	},
	361: {
		Fstart: int32(0x119AA),
		Fend:   int32(0x119D0),
	},
	362: {
		Fstart: int32(0x11A0B),
		Fend:   int32(0x11A32),
	},
	363: {
		Fstart: int32(0x11A5C),
		Fend:   int32(0x11A89),
	},
	364: {
		Fstart: int32(0x11AB0),
		Fend:   int32(0x11AF8),
	},
	365: {
		Fstart: int32(0x11BC0),
		Fend:   int32(0x11BE0),
	},
	366: {
		Fstart: int32(0x11C00),
		Fend:   int32(0x11C08),
	},
	367: {
		Fstart: int32(0x11C0A),
		Fend:   int32(0x11C2E),
	},
	368: {
		Fstart: int32(0x11C72),
		Fend:   int32(0x11C8F),
	},
	369: {
		Fstart: int32(0x11D00),
		Fend:   int32(0x11D06),
	},
	370: {
		Fstart: int32(0x11D0B),
		Fend:   int32(0x11D30),
	},
	371: {
		Fstart: int32(0x11D60),
		Fend:   int32(0x11D65),
	},
	372: {
		Fstart: int32(0x11D6A),
		Fend:   int32(0x11D89),
	},
	373: {
		Fstart: int32(0x11EE0),
		Fend:   int32(0x11EF2),
	},
	374: {
		Fstart: int32(0x11F04),
		Fend:   int32(0x11F10),
	},
	375: {
		Fstart: int32(0x11F12),
		Fend:   int32(0x11F33),
	},
	376: {
		Fstart: int32(0x12000),
		Fend:   int32(0x12399),
	},
	377: {
		Fstart: int32(0x12480),
		Fend:   int32(0x12543),
	},
	378: {
		Fstart: int32(0x12F90),
		Fend:   int32(0x12FF0),
	},
	379: {
		Fstart: int32(0x13000),
		Fend:   int32(0x1342F),
	},
	380: {
		Fstart: int32(0x13441),
		Fend:   int32(0x13446),
	},
	381: {
		Fstart: int32(0x13460),
		Fend:   int32(0x143FA),
	},
	382: {
		Fstart: int32(0x14400),
		Fend:   int32(0x14646),
	},
	383: {
		Fstart: int32(0x16100),
		Fend:   int32(0x1611D),
	},
	384: {
		Fstart: int32(0x16800),
		Fend:   int32(0x16A38),
	},
	385: {
		Fstart: int32(0x16A40),
		Fend:   int32(0x16A5E),
	},
	386: {
		Fstart: int32(0x16A70),
		Fend:   int32(0x16ABE),
	},
	387: {
		Fstart: int32(0x16AD0),
		Fend:   int32(0x16AED),
	},
	388: {
		Fstart: int32(0x16B00),
		Fend:   int32(0x16B2F),
	},
	389: {
		Fstart: int32(0x16B40),
		Fend:   int32(0x16B43),
	},
	390: {
		Fstart: int32(0x16B63),
		Fend:   int32(0x16B77),
	},
	391: {
		Fstart: int32(0x16B7D),
		Fend:   int32(0x16B8F),
	},
	392: {
		Fstart: int32(0x16D40),
		Fend:   int32(0x16D6C),
	},
	393: {
		Fstart: int32(0x16E40),
		Fend:   int32(0x16E7F),
	},
	394: {
		Fstart: int32(0x16F00),
		Fend:   int32(0x16F4A),
	},
	395: {
		Fstart: int32(0x16F93),
		Fend:   int32(0x16F9F),
	},
	396: {
		Fstart: int32(0x17000),
		Fend:   int32(0x187F7),
	},
	397: {
		Fstart: int32(0x18800),
		Fend:   int32(0x18CD5),
	},
	398: {
		Fstart: int32(0x18CFF),
		Fend:   int32(0x18D08),
	},
	399: {
		Fstart: int32(0x1AFF0),
		Fend:   int32(0x1AFF3),
	},
	400: {
		Fstart: int32(0x1AFF5),
		Fend:   int32(0x1AFFB),
	},
	401: {
		Fstart: int32(0x1B000),
		Fend:   int32(0x1B122),
	},
	402: {
		Fstart: int32(0x1B150),
		Fend:   int32(0x1B152),
	},
	403: {
		Fstart: int32(0x1B164),
		Fend:   int32(0x1B167),
	},
	404: {
		Fstart: int32(0x1B170),
		Fend:   int32(0x1B2FB),
	},
	405: {
		Fstart: int32(0x1BC00),
		Fend:   int32(0x1BC6A),
	},
	406: {
		Fstart: int32(0x1BC70),
		Fend:   int32(0x1BC7C),
	},
	407: {
		Fstart: int32(0x1BC80),
		Fend:   int32(0x1BC88),
	},
	408: {
		Fstart: int32(0x1BC90),
		Fend:   int32(0x1BC99),
	},
	409: {
		Fstart: int32(0x1D400),
		Fend:   int32(0x1D454),
	},
	410: {
		Fstart: int32(0x1D456),
		Fend:   int32(0x1D49C),
	},
	411: {
		Fstart: int32(0x1D4A9),
		Fend:   int32(0x1D4AC),
	},
	412: {
		Fstart: int32(0x1D4AE),
		Fend:   int32(0x1D4B9),
	},
	413: {
		Fstart: int32(0x1D4BD),
		Fend:   int32(0x1D4C3),
	},
	414: {
		Fstart: int32(0x1D4C5),
		Fend:   int32(0x1D505),
	},
	415: {
		Fstart: int32(0x1D507),
		Fend:   int32(0x1D50A),
	},
	416: {
		Fstart: int32(0x1D50D),
		Fend:   int32(0x1D514),
	},
	417: {
		Fstart: int32(0x1D516),
		Fend:   int32(0x1D51C),
	},
	418: {
		Fstart: int32(0x1D51E),
		Fend:   int32(0x1D539),
	},
	419: {
		Fstart: int32(0x1D53B),
		Fend:   int32(0x1D53E),
	},
	420: {
		Fstart: int32(0x1D540),
		Fend:   int32(0x1D544),
	},
	421: {
		Fstart: int32(0x1D54A),
		Fend:   int32(0x1D550),
	},
	422: {
		Fstart: int32(0x1D552),
		Fend:   int32(0x1D6A5),
	},
	423: {
		Fstart: int32(0x1D6A8),
		Fend:   int32(0x1D6C0),
	},
	424: {
		Fstart: int32(0x1D6C2),
		Fend:   int32(0x1D6DA),
	},
	425: {
		Fstart: int32(0x1D6DC),
		Fend:   int32(0x1D6FA),
	},
	426: {
		Fstart: int32(0x1D6FC),
		Fend:   int32(0x1D714),
	},
	427: {
		Fstart: int32(0x1D716),
		Fend:   int32(0x1D734),
	},
	428: {
		Fstart: int32(0x1D736),
		Fend:   int32(0x1D74E),
	},
	429: {
		Fstart: int32(0x1D750),
		Fend:   int32(0x1D76E),
	},
	430: {
		Fstart: int32(0x1D770),
		Fend:   int32(0x1D788),
	},
	431: {
		Fstart: int32(0x1D78A),
		Fend:   int32(0x1D7A8),
	},
	432: {
		Fstart: int32(0x1D7AA),
		Fend:   int32(0x1D7C2),
	},
	433: {
		Fstart: int32(0x1D7C4),
		Fend:   int32(0x1D7CB),
	},
	434: {
		Fstart: int32(0x1DF00),
		Fend:   int32(0x1DF1E),
	},
	435: {
		Fstart: int32(0x1DF25),
		Fend:   int32(0x1DF2A),
	},
	436: {
		Fstart: int32(0x1E030),
		Fend:   int32(0x1E06D),
	},
	437: {
		Fstart: int32(0x1E100),
		Fend:   int32(0x1E12C),
	},
	438: {
		Fstart: int32(0x1E137),
		Fend:   int32(0x1E13D),
	},
	439: {
		Fstart: int32(0x1E290),
		Fend:   int32(0x1E2AD),
	},
	440: {
		Fstart: int32(0x1E2C0),
		Fend:   int32(0x1E2EB),
	},
	441: {
		Fstart: int32(0x1E4D0),
		Fend:   int32(0x1E4EB),
	},
	442: {
		Fstart: int32(0x1E5D0),
		Fend:   int32(0x1E5ED),
	},
	443: {
		Fstart: int32(0x1E7E0),
		Fend:   int32(0x1E7E6),
	},
	444: {
		Fstart: int32(0x1E7E8),
		Fend:   int32(0x1E7EB),
	},
	445: {
		Fstart: int32(0x1E7F0),
		Fend:   int32(0x1E7FE),
	},
	446: {
		Fstart: int32(0x1E800),
		Fend:   int32(0x1E8C4),
	},
	447: {
		Fstart: int32(0x1E900),
		Fend:   int32(0x1E943),
	},
	448: {
		Fstart: int32(0x1EE00),
		Fend:   int32(0x1EE03),
	},
	449: {
		Fstart: int32(0x1EE05),
		Fend:   int32(0x1EE1F),
	},
	450: {
		Fstart: int32(0x1EE29),
		Fend:   int32(0x1EE32),
	},
	451: {
		Fstart: int32(0x1EE34),
		Fend:   int32(0x1EE37),
	},
	452: {
		Fstart: int32(0x1EE4D),
		Fend:   int32(0x1EE4F),
	},
	453: {
		Fstart: int32(0x1EE67),
		Fend:   int32(0x1EE6A),
	},
	454: {
		Fstart: int32(0x1EE6C),
		Fend:   int32(0x1EE72),
	},
	455: {
		Fstart: int32(0x1EE74),
		Fend:   int32(0x1EE77),
	},
	456: {
		Fstart: int32(0x1EE79),
		Fend:   int32(0x1EE7C),
	},
	457: {
		Fstart: int32(0x1EE80),
		Fend:   int32(0x1EE89),
	},
	458: {
		Fstart: int32(0x1EE8B),
		Fend:   int32(0x1EE9B),
	},
	459: {
		Fstart: int32(0x1EEA1),
		Fend:   int32(0x1EEA3),
	},
	460: {
		Fstart: int32(0x1EEA5),
		Fend:   int32(0x1EEA9),
	},
	461: {
		Fstart: int32(0x1EEAB),
		Fend:   int32(0x1EEBB),
	},
	462: {
		Fstart: int32(0x20000),
		Fend:   int32(0x2A6DF),
	},
	463: {
		Fstart: int32(0x2A700),
		Fend:   int32(0x2B739),
	},
	464: {
		Fstart: int32(0x2B740),
		Fend:   int32(0x2B81D),
	},
	465: {
		Fstart: int32(0x2B820),
		Fend:   int32(0x2CEA1),
	},
	466: {
		Fstart: int32(0x2CEB0),
		Fend:   int32(0x2EBE0),
	},
	467: {
		Fstart: int32(0x2EBF0),
		Fend:   int32(0x2EE5D),
	},
	468: {
		Fstart: int32(0x2F800),
		Fend:   int32(0x2FA1D),
	},
	469: {
		Fstart: int32(0x30000),
		Fend:   int32(0x3134A),
	},
	470: {
		Fstart: int32(0x31350),
		Fend:   int32(0x323AF),
	},
}

var _alphaCharTable = [269]Tchr{
	0:   int32(0xAA),
	1:   int32(0xB5),
	2:   int32(0xBA),
	3:   int32(0x2EC),
	4:   int32(0x2EE),
	5:   int32(0x376),
	6:   int32(0x377),
	7:   int32(0x37F),
	8:   int32(0x386),
	9:   int32(0x38C),
	10:  int32(0x559),
	11:  int32(0x66E),
	12:  int32(0x66F),
	13:  int32(0x6D5),
	14:  int32(0x6E5),
	15:  int32(0x6E6),
	16:  int32(0x6EE),
	17:  int32(0x6EF),
	18:  int32(0x6FF),
	19:  int32(0x710),
	20:  int32(0x7B1),
	21:  int32(0x7F4),
	22:  int32(0x7F5),
	23:  int32(0x7FA),
	24:  int32(0x81A),
	25:  int32(0x824),
	26:  int32(0x828),
	27:  int32(0x93D),
	28:  int32(0x950),
	29:  int32(0x98F),
	30:  int32(0x990),
	31:  int32(0x9B2),
	32:  int32(0x9BD),
	33:  int32(0x9CE),
	34:  int32(0x9DC),
	35:  int32(0x9DD),
	36:  int32(0x9F0),
	37:  int32(0x9F1),
	38:  int32(0x9FC),
	39:  int32(0xA0F),
	40:  int32(0xA10),
	41:  int32(0xA32),
	42:  int32(0xA33),
	43:  int32(0xA35),
	44:  int32(0xA36),
	45:  int32(0xA38),
	46:  int32(0xA39),
	47:  int32(0xA5E),
	48:  int32(0xAB2),
	49:  int32(0xAB3),
	50:  int32(0xABD),
	51:  int32(0xAD0),
	52:  int32(0xAE0),
	53:  int32(0xAE1),
	54:  int32(0xAF9),
	55:  int32(0xB0F),
	56:  int32(0xB10),
	57:  int32(0xB32),
	58:  int32(0xB33),
	59:  int32(0xB3D),
	60:  int32(0xB5C),
	61:  int32(0xB5D),
	62:  int32(0xB71),
	63:  int32(0xB83),
	64:  int32(0xB99),
	65:  int32(0xB9A),
	66:  int32(0xB9C),
	67:  int32(0xB9E),
	68:  int32(0xB9F),
	69:  int32(0xBA3),
	70:  int32(0xBA4),
	71:  int32(0xBD0),
	72:  int32(0xC3D),
	73:  int32(0xC5D),
	74:  int32(0xC60),
	75:  int32(0xC61),
	76:  int32(0xC80),
	77:  int32(0xCBD),
	78:  int32(0xCDD),
	79:  int32(0xCDE),
	80:  int32(0xCE0),
	81:  int32(0xCE1),
	82:  int32(0xCF1),
	83:  int32(0xCF2),
	84:  int32(0xD3D),
	85:  int32(0xD4E),
	86:  int32(0xDBD),
	87:  int32(0xE32),
	88:  int32(0xE33),
	89:  int32(0xE81),
	90:  int32(0xE82),
	91:  int32(0xE84),
	92:  int32(0xEA5),
	93:  int32(0xEB2),
	94:  int32(0xEB3),
	95:  int32(0xEBD),
	96:  int32(0xEC6),
	97:  int32(0xF00),
	98:  int32(0x103F),
	99:  int32(0x1061),
	100: int32(0x1065),
	101: int32(0x1066),
	102: int32(0x108E),
	103: int32(0x10C7),
	104: int32(0x10CD),
	105: int32(0x1258),
	106: int32(0x12C0),
	107: int32(0x17D7),
	108: int32(0x17DC),
	109: int32(0x18AA),
	110: int32(0x1AA7),
	111: int32(0x1BAE),
	112: int32(0x1BAF),
	113: int32(0x1CF5),
	114: int32(0x1CF6),
	115: int32(0x1CFA),
	116: int32(0x1F59),
	117: int32(0x1F5B),
	118: int32(0x1F5D),
	119: int32(0x1FBE),
	120: int32(0x2071),
	121: int32(0x207F),
	122: int32(0x2102),
	123: int32(0x2107),
	124: int32(0x2115),
	125: int32(0x2124),
	126: int32(0x2126),
	127: int32(0x2128),
	128: int32(0x214E),
	129: int32(0x2183),
	130: int32(0x2184),
	131: int32(0x2CF2),
	132: int32(0x2CF3),
	133: int32(0x2D27),
	134: int32(0x2D2D),
	135: int32(0x2D6F),
	136: int32(0x2E2F),
	137: int32(0x3005),
	138: int32(0x3006),
	139: int32(0x303B),
	140: int32(0x303C),
	141: int32(0xA62A),
	142: int32(0xA62B),
	143: int32(0xA7D0),
	144: int32(0xA7D1),
	145: int32(0xA7D3),
	146: int32(0xA8FB),
	147: int32(0xA8FD),
	148: int32(0xA8FE),
	149: int32(0xA9CF),
	150: int32(0xAA7A),
	151: int32(0xAAB1),
	152: int32(0xAAB5),
	153: int32(0xAAB6),
	154: int32(0xAAC0),
	155: int32(0xAAC2),
	156: int32(0xFB1D),
	157: int32(0xFB3E),
	158: int32(0xFB40),
	159: int32(0xFB41),
	160: int32(0xFB43),
	161: int32(0xFB44),
	162: int32(0x1003C),
	163: int32(0x1003D),
	164: int32(0x10594),
	165: int32(0x10595),
	166: int32(0x105BB),
	167: int32(0x105BC),
	168: int32(0x10808),
	169: int32(0x10837),
	170: int32(0x10838),
	171: int32(0x1083C),
	172: int32(0x108F4),
	173: int32(0x108F5),
	174: int32(0x109BE),
	175: int32(0x109BF),
	176: int32(0x10A00),
	177: int32(0x10EB0),
	178: int32(0x10EB1),
	179: int32(0x10F27),
	180: int32(0x11071),
	181: int32(0x11072),
	182: int32(0x11075),
	183: int32(0x11144),
	184: int32(0x11147),
	185: int32(0x11176),
	186: int32(0x111DA),
	187: int32(0x111DC),
	188: int32(0x1123F),
	189: int32(0x11240),
	190: int32(0x11288),
	191: int32(0x1130F),
	192: int32(0x11310),
	193: int32(0x11332),
	194: int32(0x11333),
	195: int32(0x1133D),
	196: int32(0x11350),
	197: int32(0x1138B),
	198: int32(0x1138E),
	199: int32(0x113B7),
	200: int32(0x113D1),
	201: int32(0x113D3),
	202: int32(0x114C4),
	203: int32(0x114C5),
	204: int32(0x114C7),
	205: int32(0x11644),
	206: int32(0x116B8),
	207: int32(0x11909),
	208: int32(0x11915),
	209: int32(0x11916),
	210: int32(0x1193F),
	211: int32(0x11941),
	212: int32(0x119E1),
	213: int32(0x119E3),
	214: int32(0x11A00),
	215: int32(0x11A3A),
	216: int32(0x11A50),
	217: int32(0x11A9D),
	218: int32(0x11C40),
	219: int32(0x11D08),
	220: int32(0x11D09),
	221: int32(0x11D46),
	222: int32(0x11D67),
	223: int32(0x11D68),
	224: int32(0x11D98),
	225: int32(0x11F02),
	226: int32(0x11FB0),
	227: int32(0x16F50),
	228: int32(0x16FE0),
	229: int32(0x16FE1),
	230: int32(0x16FE3),
	231: int32(0x1AFFD),
	232: int32(0x1AFFE),
	233: int32(0x1B132),
	234: int32(0x1B155),
	235: int32(0x1D49E),
	236: int32(0x1D49F),
	237: int32(0x1D4A2),
	238: int32(0x1D4A5),
	239: int32(0x1D4A6),
	240: int32(0x1D4BB),
	241: int32(0x1D546),
	242: int32(0x1E14E),
	243: int32(0x1E5F0),
	244: int32(0x1E7ED),
	245: int32(0x1E7EE),
	246: int32(0x1E94B),
	247: int32(0x1EE21),
	248: int32(0x1EE22),
	249: int32(0x1EE24),
	250: int32(0x1EE27),
	251: int32(0x1EE39),
	252: int32(0x1EE3B),
	253: int32(0x1EE42),
	254: int32(0x1EE47),
	255: int32(0x1EE49),
	256: int32(0x1EE4B),
	257: int32(0x1EE51),
	258: int32(0x1EE52),
	259: int32(0x1EE54),
	260: int32(0x1EE57),
	261: int32(0x1EE59),
	262: int32(0x1EE5B),
	263: int32(0x1EE5D),
	264: int32(0x1EE5F),
	265: int32(0x1EE61),
	266: int32(0x1EE62),
	267: int32(0x1EE64),
	268: int32(0x1EE7E),
}

/*
 * Unicode: control characters.
 */

var _controlRangeTable = [12]Tcrange{
	0: {
		Fend: int32(0x1F),
	},
	1: {
		Fstart: int32(0x7F),
		Fend:   int32(0x9F),
	},
	2: {
		Fstart: int32(0x600),
		Fend:   int32(0x605),
	},
	3: {
		Fstart: int32(0x200B),
		Fend:   int32(0x200F),
	},
	4: {
		Fstart: int32(0x202A),
		Fend:   int32(0x202E),
	},
	5: {
		Fstart: int32(0x2060),
		Fend:   int32(0x2064),
	},
	6: {
		Fstart: int32(0x2066),
		Fend:   int32(0x206F),
	},
	7: {
		Fstart: int32(0xFFF9),
		Fend:   int32(0xFFFB),
	},
	8: {
		Fstart: int32(0x13430),
		Fend:   int32(0x1343F),
	},
	9: {
		Fstart: int32(0x1BCA0),
		Fend:   int32(0x1BCA3),
	},
	10: {
		Fstart: int32(0x1D173),
		Fend:   int32(0x1D17A),
	},
	11: {
		Fstart: int32(0xE0020),
		Fend:   int32(0xE007F),
	},
}

var _controlCharTable = [12]Tchr{
	0:  int32(0xAD),
	1:  int32(0x61C),
	2:  int32(0x6DD),
	3:  int32(0x70F),
	4:  int32(0x890),
	5:  int32(0x891),
	6:  int32(0x8E2),
	7:  int32(0x180E),
	8:  int32(0xFEFF),
	9:  int32(0x110BD),
	10: int32(0x110CD),
	11: int32(0xE0001),
}

/*
 * Unicode: decimal digit characters.
 */

var _digitRangeTable = [71]Tcrange{
	0: {
		Fstart: int32(0x30),
		Fend:   int32(0x39),
	},
	1: {
		Fstart: int32(0x660),
		Fend:   int32(0x669),
	},
	2: {
		Fstart: int32(0x6F0),
		Fend:   int32(0x6F9),
	},
	3: {
		Fstart: int32(0x7C0),
		Fend:   int32(0x7C9),
	},
	4: {
		Fstart: int32(0x966),
		Fend:   int32(0x96F),
	},
	5: {
		Fstart: int32(0x9E6),
		Fend:   int32(0x9EF),
	},
	6: {
		Fstart: int32(0xA66),
		Fend:   int32(0xA6F),
	},
	7: {
		Fstart: int32(0xAE6),
		Fend:   int32(0xAEF),
	},
	8: {
		Fstart: int32(0xB66),
		Fend:   int32(0xB6F),
	},
	9: {
		Fstart: int32(0xBE6),
		Fend:   int32(0xBEF),
	},
	10: {
		Fstart: int32(0xC66),
		Fend:   int32(0xC6F),
	},
	11: {
		Fstart: int32(0xCE6),
		Fend:   int32(0xCEF),
	},
	12: {
		Fstart: int32(0xD66),
		Fend:   int32(0xD6F),
	},
	13: {
		Fstart: int32(0xDE6),
		Fend:   int32(0xDEF),
	},
	14: {
		Fstart: int32(0xE50),
		Fend:   int32(0xE59),
	},
	15: {
		Fstart: int32(0xED0),
		Fend:   int32(0xED9),
	},
	16: {
		Fstart: int32(0xF20),
		Fend:   int32(0xF29),
	},
	17: {
		Fstart: int32(0x1040),
		Fend:   int32(0x1049),
	},
	18: {
		Fstart: int32(0x1090),
		Fend:   int32(0x1099),
	},
	19: {
		Fstart: int32(0x17E0),
		Fend:   int32(0x17E9),
	},
	20: {
		Fstart: int32(0x1810),
		Fend:   int32(0x1819),
	},
	21: {
		Fstart: int32(0x1946),
		Fend:   int32(0x194F),
	},
	22: {
		Fstart: int32(0x19D0),
		Fend:   int32(0x19D9),
	},
	23: {
		Fstart: int32(0x1A80),
		Fend:   int32(0x1A89),
	},
	24: {
		Fstart: int32(0x1A90),
		Fend:   int32(0x1A99),
	},
	25: {
		Fstart: int32(0x1B50),
		Fend:   int32(0x1B59),
	},
	26: {
		Fstart: int32(0x1BB0),
		Fend:   int32(0x1BB9),
	},
	27: {
		Fstart: int32(0x1C40),
		Fend:   int32(0x1C49),
	},
	28: {
		Fstart: int32(0x1C50),
		Fend:   int32(0x1C59),
	},
	29: {
		Fstart: int32(0xA620),
		Fend:   int32(0xA629),
	},
	30: {
		Fstart: int32(0xA8D0),
		Fend:   int32(0xA8D9),
	},
	31: {
		Fstart: int32(0xA900),
		Fend:   int32(0xA909),
	},
	32: {
		Fstart: int32(0xA9D0),
		Fend:   int32(0xA9D9),
	},
	33: {
		Fstart: int32(0xA9F0),
		Fend:   int32(0xA9F9),
	},
	34: {
		Fstart: int32(0xAA50),
		Fend:   int32(0xAA59),
	},
	35: {
		Fstart: int32(0xABF0),
		Fend:   int32(0xABF9),
	},
	36: {
		Fstart: int32(0xFF10),
		Fend:   int32(0xFF19),
	},
	37: {
		Fstart: int32(0x104A0),
		Fend:   int32(0x104A9),
	},
	38: {
		Fstart: int32(0x10D30),
		Fend:   int32(0x10D39),
	},
	39: {
		Fstart: int32(0x10D40),
		Fend:   int32(0x10D49),
	},
	40: {
		Fstart: int32(0x11066),
		Fend:   int32(0x1106F),
	},
	41: {
		Fstart: int32(0x110F0),
		Fend:   int32(0x110F9),
	},
	42: {
		Fstart: int32(0x11136),
		Fend:   int32(0x1113F),
	},
	43: {
		Fstart: int32(0x111D0),
		Fend:   int32(0x111D9),
	},
	44: {
		Fstart: int32(0x112F0),
		Fend:   int32(0x112F9),
	},
	45: {
		Fstart: int32(0x11450),
		Fend:   int32(0x11459),
	},
	46: {
		Fstart: int32(0x114D0),
		Fend:   int32(0x114D9),
	},
	47: {
		Fstart: int32(0x11650),
		Fend:   int32(0x11659),
	},
	48: {
		Fstart: int32(0x116C0),
		Fend:   int32(0x116C9),
	},
	49: {
		Fstart: int32(0x116D0),
		Fend:   int32(0x116E3),
	},
	50: {
		Fstart: int32(0x11730),
		Fend:   int32(0x11739),
	},
	51: {
		Fstart: int32(0x118E0),
		Fend:   int32(0x118E9),
	},
	52: {
		Fstart: int32(0x11950),
		Fend:   int32(0x11959),
	},
	53: {
		Fstart: int32(0x11BF0),
		Fend:   int32(0x11BF9),
	},
	54: {
		Fstart: int32(0x11C50),
		Fend:   int32(0x11C59),
	},
	55: {
		Fstart: int32(0x11D50),
		Fend:   int32(0x11D59),
	},
	56: {
		Fstart: int32(0x11DA0),
		Fend:   int32(0x11DA9),
	},
	57: {
		Fstart: int32(0x11F50),
		Fend:   int32(0x11F59),
	},
	58: {
		Fstart: int32(0x16130),
		Fend:   int32(0x16139),
	},
	59: {
		Fstart: int32(0x16A60),
		Fend:   int32(0x16A69),
	},
	60: {
		Fstart: int32(0x16AC0),
		Fend:   int32(0x16AC9),
	},
	61: {
		Fstart: int32(0x16B50),
		Fend:   int32(0x16B59),
	},
	62: {
		Fstart: int32(0x16D70),
		Fend:   int32(0x16D79),
	},
	63: {
		Fstart: int32(0x1CCF0),
		Fend:   int32(0x1CCF9),
	},
	64: {
		Fstart: int32(0x1D7CE),
		Fend:   int32(0x1D7FF),
	},
	65: {
		Fstart: int32(0x1E140),
		Fend:   int32(0x1E149),
	},
	66: {
		Fstart: int32(0x1E2F0),
		Fend:   int32(0x1E2F9),
	},
	67: {
		Fstart: int32(0x1E4F0),
		Fend:   int32(0x1E4F9),
	},
	68: {
		Fstart: int32(0x1E5F1),
		Fend:   int32(0x1E5FA),
	},
	69: {
		Fstart: int32(0x1E950),
		Fend:   int32(0x1E959),
	},
	70: {
		Fstart: int32(0x1FBF0),
		Fend:   int32(0x1FBF9),
	},
}

/*
 * no singletons of digit characters.
 */

/*
 * Unicode: punctuation characters.
 */

var _punctRangeTable = [86]Tcrange{
	0: {
		Fstart: int32(0x21),
		Fend:   int32(0x23),
	},
	1: {
		Fstart: int32(0x25),
		Fend:   int32(0x2A),
	},
	2: {
		Fstart: int32(0x2C),
		Fend:   int32(0x2F),
	},
	3: {
		Fstart: int32(0x5B),
		Fend:   int32(0x5D),
	},
	4: {
		Fstart: int32(0x55A),
		Fend:   int32(0x55F),
	},
	5: {
		Fstart: int32(0x61D),
		Fend:   int32(0x61F),
	},
	6: {
		Fstart: int32(0x66A),
		Fend:   int32(0x66D),
	},
	7: {
		Fstart: int32(0x700),
		Fend:   int32(0x70D),
	},
	8: {
		Fstart: int32(0x7F7),
		Fend:   int32(0x7F9),
	},
	9: {
		Fstart: int32(0x830),
		Fend:   int32(0x83E),
	},
	10: {
		Fstart: int32(0xF04),
		Fend:   int32(0xF12),
	},
	11: {
		Fstart: int32(0xF3A),
		Fend:   int32(0xF3D),
	},
	12: {
		Fstart: int32(0xFD0),
		Fend:   int32(0xFD4),
	},
	13: {
		Fstart: int32(0x104A),
		Fend:   int32(0x104F),
	},
	14: {
		Fstart: int32(0x1360),
		Fend:   int32(0x1368),
	},
	15: {
		Fstart: int32(0x16EB),
		Fend:   int32(0x16ED),
	},
	16: {
		Fstart: int32(0x17D4),
		Fend:   int32(0x17D6),
	},
	17: {
		Fstart: int32(0x17D8),
		Fend:   int32(0x17DA),
	},
	18: {
		Fstart: int32(0x1800),
		Fend:   int32(0x180A),
	},
	19: {
		Fstart: int32(0x1AA0),
		Fend:   int32(0x1AA6),
	},
	20: {
		Fstart: int32(0x1AA8),
		Fend:   int32(0x1AAD),
	},
	21: {
		Fstart: int32(0x1B5A),
		Fend:   int32(0x1B60),
	},
	22: {
		Fstart: int32(0x1B7D),
		Fend:   int32(0x1B7F),
	},
	23: {
		Fstart: int32(0x1BFC),
		Fend:   int32(0x1BFF),
	},
	24: {
		Fstart: int32(0x1C3B),
		Fend:   int32(0x1C3F),
	},
	25: {
		Fstart: int32(0x1CC0),
		Fend:   int32(0x1CC7),
	},
	26: {
		Fstart: int32(0x2010),
		Fend:   int32(0x2027),
	},
	27: {
		Fstart: int32(0x2030),
		Fend:   int32(0x2043),
	},
	28: {
		Fstart: int32(0x2045),
		Fend:   int32(0x2051),
	},
	29: {
		Fstart: int32(0x2053),
		Fend:   int32(0x205E),
	},
	30: {
		Fstart: int32(0x2308),
		Fend:   int32(0x230B),
	},
	31: {
		Fstart: int32(0x2768),
		Fend:   int32(0x2775),
	},
	32: {
		Fstart: int32(0x27E6),
		Fend:   int32(0x27EF),
	},
	33: {
		Fstart: int32(0x2983),
		Fend:   int32(0x2998),
	},
	34: {
		Fstart: int32(0x29D8),
		Fend:   int32(0x29DB),
	},
	35: {
		Fstart: int32(0x2CF9),
		Fend:   int32(0x2CFC),
	},
	36: {
		Fstart: int32(0x2E00),
		Fend:   int32(0x2E2E),
	},
	37: {
		Fstart: int32(0x2E30),
		Fend:   int32(0x2E4F),
	},
	38: {
		Fstart: int32(0x2E52),
		Fend:   int32(0x2E5D),
	},
	39: {
		Fstart: int32(0x3001),
		Fend:   int32(0x3003),
	},
	40: {
		Fstart: int32(0x3008),
		Fend:   int32(0x3011),
	},
	41: {
		Fstart: int32(0x3014),
		Fend:   int32(0x301F),
	},
	42: {
		Fstart: int32(0xA60D),
		Fend:   int32(0xA60F),
	},
	43: {
		Fstart: int32(0xA6F2),
		Fend:   int32(0xA6F7),
	},
	44: {
		Fstart: int32(0xA874),
		Fend:   int32(0xA877),
	},
	45: {
		Fstart: int32(0xA8F8),
		Fend:   int32(0xA8FA),
	},
	46: {
		Fstart: int32(0xA9C1),
		Fend:   int32(0xA9CD),
	},
	47: {
		Fstart: int32(0xAA5C),
		Fend:   int32(0xAA5F),
	},
	48: {
		Fstart: int32(0xFE10),
		Fend:   int32(0xFE19),
	},
	49: {
		Fstart: int32(0xFE30),
		Fend:   int32(0xFE52),
	},
	50: {
		Fstart: int32(0xFE54),
		Fend:   int32(0xFE61),
	},
	51: {
		Fstart: int32(0xFF01),
		Fend:   int32(0xFF03),
	},
	52: {
		Fstart: int32(0xFF05),
		Fend:   int32(0xFF0A),
	},
	53: {
		Fstart: int32(0xFF0C),
		Fend:   int32(0xFF0F),
	},
	54: {
		Fstart: int32(0xFF3B),
		Fend:   int32(0xFF3D),
	},
	55: {
		Fstart: int32(0xFF5F),
		Fend:   int32(0xFF65),
	},
	56: {
		Fstart: int32(0x10100),
		Fend:   int32(0x10102),
	},
	57: {
		Fstart: int32(0x10A50),
		Fend:   int32(0x10A58),
	},
	58: {
		Fstart: int32(0x10AF0),
		Fend:   int32(0x10AF6),
	},
	59: {
		Fstart: int32(0x10B39),
		Fend:   int32(0x10B3F),
	},
	60: {
		Fstart: int32(0x10B99),
		Fend:   int32(0x10B9C),
	},
	61: {
		Fstart: int32(0x10F55),
		Fend:   int32(0x10F59),
	},
	62: {
		Fstart: int32(0x10F86),
		Fend:   int32(0x10F89),
	},
	63: {
		Fstart: int32(0x11047),
		Fend:   int32(0x1104D),
	},
	64: {
		Fstart: int32(0x110BE),
		Fend:   int32(0x110C1),
	},
	65: {
		Fstart: int32(0x11140),
		Fend:   int32(0x11143),
	},
	66: {
		Fstart: int32(0x111C5),
		Fend:   int32(0x111C8),
	},
	67: {
		Fstart: int32(0x111DD),
		Fend:   int32(0x111DF),
	},
	68: {
		Fstart: int32(0x11238),
		Fend:   int32(0x1123D),
	},
	69: {
		Fstart: int32(0x1144B),
		Fend:   int32(0x1144F),
	},
	70: {
		Fstart: int32(0x115C1),
		Fend:   int32(0x115D7),
	},
	71: {
		Fstart: int32(0x11641),
		Fend:   int32(0x11643),
	},
	72: {
		Fstart: int32(0x11660),
		Fend:   int32(0x1166C),
	},
	73: {
		Fstart: int32(0x1173C),
		Fend:   int32(0x1173E),
	},
	74: {
		Fstart: int32(0x11944),
		Fend:   int32(0x11946),
	},
	75: {
		Fstart: int32(0x11A3F),
		Fend:   int32(0x11A46),
	},
	76: {
		Fstart: int32(0x11A9A),
		Fend:   int32(0x11A9C),
	},
	77: {
		Fstart: int32(0x11A9E),
		Fend:   int32(0x11AA2),
	},
	78: {
		Fstart: int32(0x11B00),
		Fend:   int32(0x11B09),
	},
	79: {
		Fstart: int32(0x11C41),
		Fend:   int32(0x11C45),
	},
	80: {
		Fstart: int32(0x11F43),
		Fend:   int32(0x11F4F),
	},
	81: {
		Fstart: int32(0x12470),
		Fend:   int32(0x12474),
	},
	82: {
		Fstart: int32(0x16B37),
		Fend:   int32(0x16B3B),
	},
	83: {
		Fstart: int32(0x16D6D),
		Fend:   int32(0x16D6F),
	},
	84: {
		Fstart: int32(0x16E97),
		Fend:   int32(0x16E9A),
	},
	85: {
		Fstart: int32(0x1DA87),
		Fend:   int32(0x1DA8B),
	},
}

var _punctCharTable = [154]Tchr{
	0:   int32(0x3A),
	1:   int32(0x3B),
	2:   int32(0x3F),
	3:   int32(0x40),
	4:   int32(0x5F),
	5:   int32(0x7B),
	6:   int32(0x7D),
	7:   int32(0xA1),
	8:   int32(0xA7),
	9:   int32(0xAB),
	10:  int32(0xB6),
	11:  int32(0xB7),
	12:  int32(0xBB),
	13:  int32(0xBF),
	14:  int32(0x37E),
	15:  int32(0x387),
	16:  int32(0x589),
	17:  int32(0x58A),
	18:  int32(0x5BE),
	19:  int32(0x5C0),
	20:  int32(0x5C3),
	21:  int32(0x5C6),
	22:  int32(0x5F3),
	23:  int32(0x5F4),
	24:  int32(0x609),
	25:  int32(0x60A),
	26:  int32(0x60C),
	27:  int32(0x60D),
	28:  int32(0x61B),
	29:  int32(0x6D4),
	30:  int32(0x85E),
	31:  int32(0x964),
	32:  int32(0x965),
	33:  int32(0x970),
	34:  int32(0x9FD),
	35:  int32(0xA76),
	36:  int32(0xAF0),
	37:  int32(0xC77),
	38:  int32(0xC84),
	39:  int32(0xDF4),
	40:  int32(0xE4F),
	41:  int32(0xE5A),
	42:  int32(0xE5B),
	43:  int32(0xF14),
	44:  int32(0xF85),
	45:  int32(0xFD9),
	46:  int32(0xFDA),
	47:  int32(0x10FB),
	48:  int32(0x1400),
	49:  int32(0x166E),
	50:  int32(0x169B),
	51:  int32(0x169C),
	52:  int32(0x1735),
	53:  int32(0x1736),
	54:  int32(0x1944),
	55:  int32(0x1945),
	56:  int32(0x1A1E),
	57:  int32(0x1A1F),
	58:  int32(0x1B4E),
	59:  int32(0x1B4F),
	60:  int32(0x1C7E),
	61:  int32(0x1C7F),
	62:  int32(0x1CD3),
	63:  int32(0x207D),
	64:  int32(0x207E),
	65:  int32(0x208D),
	66:  int32(0x208E),
	67:  int32(0x2329),
	68:  int32(0x232A),
	69:  int32(0x27C5),
	70:  int32(0x27C6),
	71:  int32(0x29FC),
	72:  int32(0x29FD),
	73:  int32(0x2CFE),
	74:  int32(0x2CFF),
	75:  int32(0x2D70),
	76:  int32(0x3030),
	77:  int32(0x303D),
	78:  int32(0x30A0),
	79:  int32(0x30FB),
	80:  int32(0xA4FE),
	81:  int32(0xA4FF),
	82:  int32(0xA673),
	83:  int32(0xA67E),
	84:  int32(0xA8CE),
	85:  int32(0xA8CF),
	86:  int32(0xA8FC),
	87:  int32(0xA92E),
	88:  int32(0xA92F),
	89:  int32(0xA95F),
	90:  int32(0xA9DE),
	91:  int32(0xA9DF),
	92:  int32(0xAADE),
	93:  int32(0xAADF),
	94:  int32(0xAAF0),
	95:  int32(0xAAF1),
	96:  int32(0xABEB),
	97:  int32(0xFD3E),
	98:  int32(0xFD3F),
	99:  int32(0xFE63),
	100: int32(0xFE68),
	101: int32(0xFE6A),
	102: int32(0xFE6B),
	103: int32(0xFF1A),
	104: int32(0xFF1B),
	105: int32(0xFF1F),
	106: int32(0xFF20),
	107: int32(0xFF3F),
	108: int32(0xFF5B),
	109: int32(0xFF5D),
	110: int32(0x1039F),
	111: int32(0x103D0),
	112: int32(0x1056F),
	113: int32(0x10857),
	114: int32(0x1091F),
	115: int32(0x1093F),
	116: int32(0x10A7F),
	117: int32(0x10D6E),
	118: int32(0x10EAD),
	119: int32(0x110BB),
	120: int32(0x110BC),
	121: int32(0x11174),
	122: int32(0x11175),
	123: int32(0x111CD),
	124: int32(0x111DB),
	125: int32(0x112A9),
	126: int32(0x113D4),
	127: int32(0x113D5),
	128: int32(0x113D7),
	129: int32(0x113D8),
	130: int32(0x1145A),
	131: int32(0x1145B),
	132: int32(0x1145D),
	133: int32(0x114C6),
	134: int32(0x116B9),
	135: int32(0x1183B),
	136: int32(0x119E2),
	137: int32(0x11BE1),
	138: int32(0x11C70),
	139: int32(0x11C71),
	140: int32(0x11EF7),
	141: int32(0x11EF8),
	142: int32(0x11FFF),
	143: int32(0x12FF1),
	144: int32(0x12FF2),
	145: int32(0x16A6E),
	146: int32(0x16A6F),
	147: int32(0x16AF5),
	148: int32(0x16B44),
	149: int32(0x16FE2),
	150: int32(0x1BC9F),
	151: int32(0x1E5FF),
	152: int32(0x1E95E),
	153: int32(0x1E95F),
}

/*
 * Unicode: white space characters.
 */

var _spaceRangeTable = [2]Tcrange{
	0: {
		Fstart: int32(0x9),
		Fend:   int32(0xD),
	},
	1: {
		Fstart: int32(0x2000),
		Fend:   int32(0x200B),
	},
}

var _spaceCharTable = [12]Tchr{
	0:  int32(0x20),
	1:  int32(0x85),
	2:  int32(0xA0),
	3:  int32(0x1680),
	4:  int32(0x180E),
	5:  int32(0x2028),
	6:  int32(0x2029),
	7:  int32(0x202F),
	8:  int32(0x205F),
	9:  int32(0x2060),
	10: int32(0x3000),
	11: int32(0xFEFF),
}

/*
 * Unicode: lowercase characters.
 */

var _lowerRangeTable = [91]Tcrange{
	0: {
		Fstart: int32(0x61),
		Fend:   int32(0x7A),
	},
	1: {
		Fstart: int32(0xDF),
		Fend:   int32(0xF6),
	},
	2: {
		Fstart: int32(0xF8),
		Fend:   int32(0xFF),
	},
	3: {
		Fstart: int32(0x17E),
		Fend:   int32(0x180),
	},
	4: {
		Fstart: int32(0x199),
		Fend:   int32(0x19B),
	},
	5: {
		Fstart: int32(0x1BD),
		Fend:   int32(0x1BF),
	},
	6: {
		Fstart: int32(0x233),
		Fend:   int32(0x239),
	},
	7: {
		Fstart: int32(0x24F),
		Fend:   int32(0x293),
	},
	8: {
		Fstart: int32(0x295),
		Fend:   int32(0x2AF),
	},
	9: {
		Fstart: int32(0x37B),
		Fend:   int32(0x37D),
	},
	10: {
		Fstart: int32(0x3AC),
		Fend:   int32(0x3CE),
	},
	11: {
		Fstart: int32(0x3D5),
		Fend:   int32(0x3D7),
	},
	12: {
		Fstart: int32(0x3EF),
		Fend:   int32(0x3F3),
	},
	13: {
		Fstart: int32(0x430),
		Fend:   int32(0x45F),
	},
	14: {
		Fstart: int32(0x560),
		Fend:   int32(0x588),
	},
	15: {
		Fstart: int32(0x10D0),
		Fend:   int32(0x10FA),
	},
	16: {
		Fstart: int32(0x10FD),
		Fend:   int32(0x10FF),
	},
	17: {
		Fstart: int32(0x13F8),
		Fend:   int32(0x13FD),
	},
	18: {
		Fstart: int32(0x1C80),
		Fend:   int32(0x1C88),
	},
	19: {
		Fstart: int32(0x1D00),
		Fend:   int32(0x1D2B),
	},
	20: {
		Fstart: int32(0x1D6B),
		Fend:   int32(0x1D77),
	},
	21: {
		Fstart: int32(0x1D79),
		Fend:   int32(0x1D9A),
	},
	22: {
		Fstart: int32(0x1E95),
		Fend:   int32(0x1E9D),
	},
	23: {
		Fstart: int32(0x1EFF),
		Fend:   int32(0x1F07),
	},
	24: {
		Fstart: int32(0x1F10),
		Fend:   int32(0x1F15),
	},
	25: {
		Fstart: int32(0x1F20),
		Fend:   int32(0x1F27),
	},
	26: {
		Fstart: int32(0x1F30),
		Fend:   int32(0x1F37),
	},
	27: {
		Fstart: int32(0x1F40),
		Fend:   int32(0x1F45),
	},
	28: {
		Fstart: int32(0x1F50),
		Fend:   int32(0x1F57),
	},
	29: {
		Fstart: int32(0x1F60),
		Fend:   int32(0x1F67),
	},
	30: {
		Fstart: int32(0x1F70),
		Fend:   int32(0x1F7D),
	},
	31: {
		Fstart: int32(0x1F80),
		Fend:   int32(0x1F87),
	},
	32: {
		Fstart: int32(0x1F90),
		Fend:   int32(0x1F97),
	},
	33: {
		Fstart: int32(0x1FA0),
		Fend:   int32(0x1FA7),
	},
	34: {
		Fstart: int32(0x1FB0),
		Fend:   int32(0x1FB4),
	},
	35: {
		Fstart: int32(0x1FC2),
		Fend:   int32(0x1FC4),
	},
	36: {
		Fstart: int32(0x1FD0),
		Fend:   int32(0x1FD3),
	},
	37: {
		Fstart: int32(0x1FE0),
		Fend:   int32(0x1FE7),
	},
	38: {
		Fstart: int32(0x1FF2),
		Fend:   int32(0x1FF4),
	},
	39: {
		Fstart: int32(0x2146),
		Fend:   int32(0x2149),
	},
	40: {
		Fstart: int32(0x2C30),
		Fend:   int32(0x2C5F),
	},
	41: {
		Fstart: int32(0x2C76),
		Fend:   int32(0x2C7B),
	},
	42: {
		Fstart: int32(0x2D00),
		Fend:   int32(0x2D25),
	},
	43: {
		Fstart: int32(0xA72F),
		Fend:   int32(0xA731),
	},
	44: {
		Fstart: int32(0xA771),
		Fend:   int32(0xA778),
	},
	45: {
		Fstart: int32(0xA793),
		Fend:   int32(0xA795),
	},
	46: {
		Fstart: int32(0xAB30),
		Fend:   int32(0xAB5A),
	},
	47: {
		Fstart: int32(0xAB60),
		Fend:   int32(0xAB68),
	},
	48: {
		Fstart: int32(0xAB70),
		Fend:   int32(0xABBF),
	},
	49: {
		Fstart: int32(0xFB00),
		Fend:   int32(0xFB06),
	},
	50: {
		Fstart: int32(0xFB13),
		Fend:   int32(0xFB17),
	},
	51: {
		Fstart: int32(0xFF41),
		Fend:   int32(0xFF5A),
	},
	52: {
		Fstart: int32(0x10428),
		Fend:   int32(0x1044F),
	},
	53: {
		Fstart: int32(0x104D8),
		Fend:   int32(0x104FB),
	},
	54: {
		Fstart: int32(0x10597),
		Fend:   int32(0x105A1),
	},
	55: {
		Fstart: int32(0x105A3),
		Fend:   int32(0x105B1),
	},
	56: {
		Fstart: int32(0x105B3),
		Fend:   int32(0x105B9),
	},
	57: {
		Fstart: int32(0x10CC0),
		Fend:   int32(0x10CF2),
	},
	58: {
		Fstart: int32(0x10D70),
		Fend:   int32(0x10D85),
	},
	59: {
		Fstart: int32(0x118C0),
		Fend:   int32(0x118DF),
	},
	60: {
		Fstart: int32(0x16E60),
		Fend:   int32(0x16E7F),
	},
	61: {
		Fstart: int32(0x1D41A),
		Fend:   int32(0x1D433),
	},
	62: {
		Fstart: int32(0x1D44E),
		Fend:   int32(0x1D454),
	},
	63: {
		Fstart: int32(0x1D456),
		Fend:   int32(0x1D467),
	},
	64: {
		Fstart: int32(0x1D482),
		Fend:   int32(0x1D49B),
	},
	65: {
		Fstart: int32(0x1D4B6),
		Fend:   int32(0x1D4B9),
	},
	66: {
		Fstart: int32(0x1D4BD),
		Fend:   int32(0x1D4C3),
	},
	67: {
		Fstart: int32(0x1D4C5),
		Fend:   int32(0x1D4CF),
	},
	68: {
		Fstart: int32(0x1D4EA),
		Fend:   int32(0x1D503),
	},
	69: {
		Fstart: int32(0x1D51E),
		Fend:   int32(0x1D537),
	},
	70: {
		Fstart: int32(0x1D552),
		Fend:   int32(0x1D56B),
	},
	71: {
		Fstart: int32(0x1D586),
		Fend:   int32(0x1D59F),
	},
	72: {
		Fstart: int32(0x1D5BA),
		Fend:   int32(0x1D5D3),
	},
	73: {
		Fstart: int32(0x1D5EE),
		Fend:   int32(0x1D607),
	},
	74: {
		Fstart: int32(0x1D622),
		Fend:   int32(0x1D63B),
	},
	75: {
		Fstart: int32(0x1D656),
		Fend:   int32(0x1D66F),
	},
	76: {
		Fstart: int32(0x1D68A),
		Fend:   int32(0x1D6A5),
	},
	77: {
		Fstart: int32(0x1D6C2),
		Fend:   int32(0x1D6DA),
	},
	78: {
		Fstart: int32(0x1D6DC),
		Fend:   int32(0x1D6E1),
	},
	79: {
		Fstart: int32(0x1D6FC),
		Fend:   int32(0x1D714),
	},
	80: {
		Fstart: int32(0x1D716),
		Fend:   int32(0x1D71B),
	},
	81: {
		Fstart: int32(0x1D736),
		Fend:   int32(0x1D74E),
	},
	82: {
		Fstart: int32(0x1D750),
		Fend:   int32(0x1D755),
	},
	83: {
		Fstart: int32(0x1D770),
		Fend:   int32(0x1D788),
	},
	84: {
		Fstart: int32(0x1D78A),
		Fend:   int32(0x1D78F),
	},
	85: {
		Fstart: int32(0x1D7AA),
		Fend:   int32(0x1D7C2),
	},
	86: {
		Fstart: int32(0x1D7C4),
		Fend:   int32(0x1D7C9),
	},
	87: {
		Fstart: int32(0x1DF00),
		Fend:   int32(0x1DF09),
	},
	88: {
		Fstart: int32(0x1DF0B),
		Fend:   int32(0x1DF1E),
	},
	89: {
		Fstart: int32(0x1DF25),
		Fend:   int32(0x1DF2A),
	},
	90: {
		Fstart: int32(0x1E922),
		Fend:   int32(0x1E943),
	},
}

var _lowerCharTable = [592]Tchr{
	0:   int32(0xB5),
	1:   int32(0x101),
	2:   int32(0x103),
	3:   int32(0x105),
	4:   int32(0x107),
	5:   int32(0x109),
	6:   int32(0x10B),
	7:   int32(0x10D),
	8:   int32(0x10F),
	9:   int32(0x111),
	10:  int32(0x113),
	11:  int32(0x115),
	12:  int32(0x117),
	13:  int32(0x119),
	14:  int32(0x11B),
	15:  int32(0x11D),
	16:  int32(0x11F),
	17:  int32(0x121),
	18:  int32(0x123),
	19:  int32(0x125),
	20:  int32(0x127),
	21:  int32(0x129),
	22:  int32(0x12B),
	23:  int32(0x12D),
	24:  int32(0x12F),
	25:  int32(0x131),
	26:  int32(0x133),
	27:  int32(0x135),
	28:  int32(0x137),
	29:  int32(0x138),
	30:  int32(0x13A),
	31:  int32(0x13C),
	32:  int32(0x13E),
	33:  int32(0x140),
	34:  int32(0x142),
	35:  int32(0x144),
	36:  int32(0x146),
	37:  int32(0x148),
	38:  int32(0x149),
	39:  int32(0x14B),
	40:  int32(0x14D),
	41:  int32(0x14F),
	42:  int32(0x151),
	43:  int32(0x153),
	44:  int32(0x155),
	45:  int32(0x157),
	46:  int32(0x159),
	47:  int32(0x15B),
	48:  int32(0x15D),
	49:  int32(0x15F),
	50:  int32(0x161),
	51:  int32(0x163),
	52:  int32(0x165),
	53:  int32(0x167),
	54:  int32(0x169),
	55:  int32(0x16B),
	56:  int32(0x16D),
	57:  int32(0x16F),
	58:  int32(0x171),
	59:  int32(0x173),
	60:  int32(0x175),
	61:  int32(0x177),
	62:  int32(0x17A),
	63:  int32(0x17C),
	64:  int32(0x183),
	65:  int32(0x185),
	66:  int32(0x188),
	67:  int32(0x18C),
	68:  int32(0x18D),
	69:  int32(0x192),
	70:  int32(0x195),
	71:  int32(0x19E),
	72:  int32(0x1A1),
	73:  int32(0x1A3),
	74:  int32(0x1A5),
	75:  int32(0x1A8),
	76:  int32(0x1AA),
	77:  int32(0x1AB),
	78:  int32(0x1AD),
	79:  int32(0x1B0),
	80:  int32(0x1B4),
	81:  int32(0x1B6),
	82:  int32(0x1B9),
	83:  int32(0x1BA),
	84:  int32(0x1C6),
	85:  int32(0x1C9),
	86:  int32(0x1CC),
	87:  int32(0x1CE),
	88:  int32(0x1D0),
	89:  int32(0x1D2),
	90:  int32(0x1D4),
	91:  int32(0x1D6),
	92:  int32(0x1D8),
	93:  int32(0x1DA),
	94:  int32(0x1DC),
	95:  int32(0x1DD),
	96:  int32(0x1DF),
	97:  int32(0x1E1),
	98:  int32(0x1E3),
	99:  int32(0x1E5),
	100: int32(0x1E7),
	101: int32(0x1E9),
	102: int32(0x1EB),
	103: int32(0x1ED),
	104: int32(0x1EF),
	105: int32(0x1F0),
	106: int32(0x1F3),
	107: int32(0x1F5),
	108: int32(0x1F9),
	109: int32(0x1FB),
	110: int32(0x1FD),
	111: int32(0x1FF),
	112: int32(0x201),
	113: int32(0x203),
	114: int32(0x205),
	115: int32(0x207),
	116: int32(0x209),
	117: int32(0x20B),
	118: int32(0x20D),
	119: int32(0x20F),
	120: int32(0x211),
	121: int32(0x213),
	122: int32(0x215),
	123: int32(0x217),
	124: int32(0x219),
	125: int32(0x21B),
	126: int32(0x21D),
	127: int32(0x21F),
	128: int32(0x221),
	129: int32(0x223),
	130: int32(0x225),
	131: int32(0x227),
	132: int32(0x229),
	133: int32(0x22B),
	134: int32(0x22D),
	135: int32(0x22F),
	136: int32(0x231),
	137: int32(0x23C),
	138: int32(0x23F),
	139: int32(0x240),
	140: int32(0x242),
	141: int32(0x247),
	142: int32(0x249),
	143: int32(0x24B),
	144: int32(0x24D),
	145: int32(0x371),
	146: int32(0x373),
	147: int32(0x377),
	148: int32(0x390),
	149: int32(0x3D0),
	150: int32(0x3D1),
	151: int32(0x3D9),
	152: int32(0x3DB),
	153: int32(0x3DD),
	154: int32(0x3DF),
	155: int32(0x3E1),
	156: int32(0x3E3),
	157: int32(0x3E5),
	158: int32(0x3E7),
	159: int32(0x3E9),
	160: int32(0x3EB),
	161: int32(0x3ED),
	162: int32(0x3F5),
	163: int32(0x3F8),
	164: int32(0x3FB),
	165: int32(0x3FC),
	166: int32(0x461),
	167: int32(0x463),
	168: int32(0x465),
	169: int32(0x467),
	170: int32(0x469),
	171: int32(0x46B),
	172: int32(0x46D),
	173: int32(0x46F),
	174: int32(0x471),
	175: int32(0x473),
	176: int32(0x475),
	177: int32(0x477),
	178: int32(0x479),
	179: int32(0x47B),
	180: int32(0x47D),
	181: int32(0x47F),
	182: int32(0x481),
	183: int32(0x48B),
	184: int32(0x48D),
	185: int32(0x48F),
	186: int32(0x491),
	187: int32(0x493),
	188: int32(0x495),
	189: int32(0x497),
	190: int32(0x499),
	191: int32(0x49B),
	192: int32(0x49D),
	193: int32(0x49F),
	194: int32(0x4A1),
	195: int32(0x4A3),
	196: int32(0x4A5),
	197: int32(0x4A7),
	198: int32(0x4A9),
	199: int32(0x4AB),
	200: int32(0x4AD),
	201: int32(0x4AF),
	202: int32(0x4B1),
	203: int32(0x4B3),
	204: int32(0x4B5),
	205: int32(0x4B7),
	206: int32(0x4B9),
	207: int32(0x4BB),
	208: int32(0x4BD),
	209: int32(0x4BF),
	210: int32(0x4C2),
	211: int32(0x4C4),
	212: int32(0x4C6),
	213: int32(0x4C8),
	214: int32(0x4CA),
	215: int32(0x4CC),
	216: int32(0x4CE),
	217: int32(0x4CF),
	218: int32(0x4D1),
	219: int32(0x4D3),
	220: int32(0x4D5),
	221: int32(0x4D7),
	222: int32(0x4D9),
	223: int32(0x4DB),
	224: int32(0x4DD),
	225: int32(0x4DF),
	226: int32(0x4E1),
	227: int32(0x4E3),
	228: int32(0x4E5),
	229: int32(0x4E7),
	230: int32(0x4E9),
	231: int32(0x4EB),
	232: int32(0x4ED),
	233: int32(0x4EF),
	234: int32(0x4F1),
	235: int32(0x4F3),
	236: int32(0x4F5),
	237: int32(0x4F7),
	238: int32(0x4F9),
	239: int32(0x4FB),
	240: int32(0x4FD),
	241: int32(0x4FF),
	242: int32(0x501),
	243: int32(0x503),
	244: int32(0x505),
	245: int32(0x507),
	246: int32(0x509),
	247: int32(0x50B),
	248: int32(0x50D),
	249: int32(0x50F),
	250: int32(0x511),
	251: int32(0x513),
	252: int32(0x515),
	253: int32(0x517),
	254: int32(0x519),
	255: int32(0x51B),
	256: int32(0x51D),
	257: int32(0x51F),
	258: int32(0x521),
	259: int32(0x523),
	260: int32(0x525),
	261: int32(0x527),
	262: int32(0x529),
	263: int32(0x52B),
	264: int32(0x52D),
	265: int32(0x52F),
	266: int32(0x1C8A),
	267: int32(0x1E01),
	268: int32(0x1E03),
	269: int32(0x1E05),
	270: int32(0x1E07),
	271: int32(0x1E09),
	272: int32(0x1E0B),
	273: int32(0x1E0D),
	274: int32(0x1E0F),
	275: int32(0x1E11),
	276: int32(0x1E13),
	277: int32(0x1E15),
	278: int32(0x1E17),
	279: int32(0x1E19),
	280: int32(0x1E1B),
	281: int32(0x1E1D),
	282: int32(0x1E1F),
	283: int32(0x1E21),
	284: int32(0x1E23),
	285: int32(0x1E25),
	286: int32(0x1E27),
	287: int32(0x1E29),
	288: int32(0x1E2B),
	289: int32(0x1E2D),
	290: int32(0x1E2F),
	291: int32(0x1E31),
	292: int32(0x1E33),
	293: int32(0x1E35),
	294: int32(0x1E37),
	295: int32(0x1E39),
	296: int32(0x1E3B),
	297: int32(0x1E3D),
	298: int32(0x1E3F),
	299: int32(0x1E41),
	300: int32(0x1E43),
	301: int32(0x1E45),
	302: int32(0x1E47),
	303: int32(0x1E49),
	304: int32(0x1E4B),
	305: int32(0x1E4D),
	306: int32(0x1E4F),
	307: int32(0x1E51),
	308: int32(0x1E53),
	309: int32(0x1E55),
	310: int32(0x1E57),
	311: int32(0x1E59),
	312: int32(0x1E5B),
	313: int32(0x1E5D),
	314: int32(0x1E5F),
	315: int32(0x1E61),
	316: int32(0x1E63),
	317: int32(0x1E65),
	318: int32(0x1E67),
	319: int32(0x1E69),
	320: int32(0x1E6B),
	321: int32(0x1E6D),
	322: int32(0x1E6F),
	323: int32(0x1E71),
	324: int32(0x1E73),
	325: int32(0x1E75),
	326: int32(0x1E77),
	327: int32(0x1E79),
	328: int32(0x1E7B),
	329: int32(0x1E7D),
	330: int32(0x1E7F),
	331: int32(0x1E81),
	332: int32(0x1E83),
	333: int32(0x1E85),
	334: int32(0x1E87),
	335: int32(0x1E89),
	336: int32(0x1E8B),
	337: int32(0x1E8D),
	338: int32(0x1E8F),
	339: int32(0x1E91),
	340: int32(0x1E93),
	341: int32(0x1E9F),
	342: int32(0x1EA1),
	343: int32(0x1EA3),
	344: int32(0x1EA5),
	345: int32(0x1EA7),
	346: int32(0x1EA9),
	347: int32(0x1EAB),
	348: int32(0x1EAD),
	349: int32(0x1EAF),
	350: int32(0x1EB1),
	351: int32(0x1EB3),
	352: int32(0x1EB5),
	353: int32(0x1EB7),
	354: int32(0x1EB9),
	355: int32(0x1EBB),
	356: int32(0x1EBD),
	357: int32(0x1EBF),
	358: int32(0x1EC1),
	359: int32(0x1EC3),
	360: int32(0x1EC5),
	361: int32(0x1EC7),
	362: int32(0x1EC9),
	363: int32(0x1ECB),
	364: int32(0x1ECD),
	365: int32(0x1ECF),
	366: int32(0x1ED1),
	367: int32(0x1ED3),
	368: int32(0x1ED5),
	369: int32(0x1ED7),
	370: int32(0x1ED9),
	371: int32(0x1EDB),
	372: int32(0x1EDD),
	373: int32(0x1EDF),
	374: int32(0x1EE1),
	375: int32(0x1EE3),
	376: int32(0x1EE5),
	377: int32(0x1EE7),
	378: int32(0x1EE9),
	379: int32(0x1EEB),
	380: int32(0x1EED),
	381: int32(0x1EEF),
	382: int32(0x1EF1),
	383: int32(0x1EF3),
	384: int32(0x1EF5),
	385: int32(0x1EF7),
	386: int32(0x1EF9),
	387: int32(0x1EFB),
	388: int32(0x1EFD),
	389: int32(0x1FB6),
	390: int32(0x1FB7),
	391: int32(0x1FBE),
	392: int32(0x1FC6),
	393: int32(0x1FC7),
	394: int32(0x1FD6),
	395: int32(0x1FD7),
	396: int32(0x1FF6),
	397: int32(0x1FF7),
	398: int32(0x210A),
	399: int32(0x210E),
	400: int32(0x210F),
	401: int32(0x2113),
	402: int32(0x212F),
	403: int32(0x2134),
	404: int32(0x2139),
	405: int32(0x213C),
	406: int32(0x213D),
	407: int32(0x214E),
	408: int32(0x2184),
	409: int32(0x2C61),
	410: int32(0x2C65),
	411: int32(0x2C66),
	412: int32(0x2C68),
	413: int32(0x2C6A),
	414: int32(0x2C6C),
	415: int32(0x2C71),
	416: int32(0x2C73),
	417: int32(0x2C74),
	418: int32(0x2C81),
	419: int32(0x2C83),
	420: int32(0x2C85),
	421: int32(0x2C87),
	422: int32(0x2C89),
	423: int32(0x2C8B),
	424: int32(0x2C8D),
	425: int32(0x2C8F),
	426: int32(0x2C91),
	427: int32(0x2C93),
	428: int32(0x2C95),
	429: int32(0x2C97),
	430: int32(0x2C99),
	431: int32(0x2C9B),
	432: int32(0x2C9D),
	433: int32(0x2C9F),
	434: int32(0x2CA1),
	435: int32(0x2CA3),
	436: int32(0x2CA5),
	437: int32(0x2CA7),
	438: int32(0x2CA9),
	439: int32(0x2CAB),
	440: int32(0x2CAD),
	441: int32(0x2CAF),
	442: int32(0x2CB1),
	443: int32(0x2CB3),
	444: int32(0x2CB5),
	445: int32(0x2CB7),
	446: int32(0x2CB9),
	447: int32(0x2CBB),
	448: int32(0x2CBD),
	449: int32(0x2CBF),
	450: int32(0x2CC1),
	451: int32(0x2CC3),
	452: int32(0x2CC5),
	453: int32(0x2CC7),
	454: int32(0x2CC9),
	455: int32(0x2CCB),
	456: int32(0x2CCD),
	457: int32(0x2CCF),
	458: int32(0x2CD1),
	459: int32(0x2CD3),
	460: int32(0x2CD5),
	461: int32(0x2CD7),
	462: int32(0x2CD9),
	463: int32(0x2CDB),
	464: int32(0x2CDD),
	465: int32(0x2CDF),
	466: int32(0x2CE1),
	467: int32(0x2CE3),
	468: int32(0x2CE4),
	469: int32(0x2CEC),
	470: int32(0x2CEE),
	471: int32(0x2CF3),
	472: int32(0x2D27),
	473: int32(0x2D2D),
	474: int32(0xA641),
	475: int32(0xA643),
	476: int32(0xA645),
	477: int32(0xA647),
	478: int32(0xA649),
	479: int32(0xA64B),
	480: int32(0xA64D),
	481: int32(0xA64F),
	482: int32(0xA651),
	483: int32(0xA653),
	484: int32(0xA655),
	485: int32(0xA657),
	486: int32(0xA659),
	487: int32(0xA65B),
	488: int32(0xA65D),
	489: int32(0xA65F),
	490: int32(0xA661),
	491: int32(0xA663),
	492: int32(0xA665),
	493: int32(0xA667),
	494: int32(0xA669),
	495: int32(0xA66B),
	496: int32(0xA66D),
	497: int32(0xA681),
	498: int32(0xA683),
	499: int32(0xA685),
	500: int32(0xA687),
	501: int32(0xA689),
	502: int32(0xA68B),
	503: int32(0xA68D),
	504: int32(0xA68F),
	505: int32(0xA691),
	506: int32(0xA693),
	507: int32(0xA695),
	508: int32(0xA697),
	509: int32(0xA699),
	510: int32(0xA69B),
	511: int32(0xA723),
	512: int32(0xA725),
	513: int32(0xA727),
	514: int32(0xA729),
	515: int32(0xA72B),
	516: int32(0xA72D),
	517: int32(0xA733),
	518: int32(0xA735),
	519: int32(0xA737),
	520: int32(0xA739),
	521: int32(0xA73B),
	522: int32(0xA73D),
	523: int32(0xA73F),
	524: int32(0xA741),
	525: int32(0xA743),
	526: int32(0xA745),
	527: int32(0xA747),
	528: int32(0xA749),
	529: int32(0xA74B),
	530: int32(0xA74D),
	531: int32(0xA74F),
	532: int32(0xA751),
	533: int32(0xA753),
	534: int32(0xA755),
	535: int32(0xA757),
	536: int32(0xA759),
	537: int32(0xA75B),
	538: int32(0xA75D),
	539: int32(0xA75F),
	540: int32(0xA761),
	541: int32(0xA763),
	542: int32(0xA765),
	543: int32(0xA767),
	544: int32(0xA769),
	545: int32(0xA76B),
	546: int32(0xA76D),
	547: int32(0xA76F),
	548: int32(0xA77A),
	549: int32(0xA77C),
	550: int32(0xA77F),
	551: int32(0xA781),
	552: int32(0xA783),
	553: int32(0xA785),
	554: int32(0xA787),
	555: int32(0xA78C),
	556: int32(0xA78E),
	557: int32(0xA791),
	558: int32(0xA797),
	559: int32(0xA799),
	560: int32(0xA79B),
	561: int32(0xA79D),
	562: int32(0xA79F),
	563: int32(0xA7A1),
	564: int32(0xA7A3),
	565: int32(0xA7A5),
	566: int32(0xA7A7),
	567: int32(0xA7A9),
	568: int32(0xA7AF),
	569: int32(0xA7B5),
	570: int32(0xA7B7),
	571: int32(0xA7B9),
	572: int32(0xA7BB),
	573: int32(0xA7BD),
	574: int32(0xA7BF),
	575: int32(0xA7C1),
	576: int32(0xA7C3),
	577: int32(0xA7C8),
	578: int32(0xA7CA),
	579: int32(0xA7CD),
	580: int32(0xA7D1),
	581: int32(0xA7D3),
	582: int32(0xA7D5),
	583: int32(0xA7D7),
	584: int32(0xA7D9),
	585: int32(0xA7DB),
	586: int32(0xA7F6),
	587: int32(0xA7FA),
	588: int32(0x105BB),
	589: int32(0x105BC),
	590: int32(0x1D4BB),
	591: int32(0x1D7CB),
}

/*
 * Unicode: uppercase characters.
 */

var _upperRangeTable = [76]Tcrange{
	0: {
		Fstart: int32(0x41),
		Fend:   int32(0x5A),
	},
	1: {
		Fstart: int32(0xC0),
		Fend:   int32(0xD6),
	},
	2: {
		Fstart: int32(0xD8),
		Fend:   int32(0xDE),
	},
	3: {
		Fstart: int32(0x189),
		Fend:   int32(0x18B),
	},
	4: {
		Fstart: int32(0x18E),
		Fend:   int32(0x191),
	},
	5: {
		Fstart: int32(0x196),
		Fend:   int32(0x198),
	},
	6: {
		Fstart: int32(0x1B1),
		Fend:   int32(0x1B3),
	},
	7: {
		Fstart: int32(0x1F6),
		Fend:   int32(0x1F8),
	},
	8: {
		Fstart: int32(0x243),
		Fend:   int32(0x246),
	},
	9: {
		Fstart: int32(0x388),
		Fend:   int32(0x38A),
	},
	10: {
		Fstart: int32(0x391),
		Fend:   int32(0x3A1),
	},
	11: {
		Fstart: int32(0x3A3),
		Fend:   int32(0x3AB),
	},
	12: {
		Fstart: int32(0x3D2),
		Fend:   int32(0x3D4),
	},
	13: {
		Fstart: int32(0x3FD),
		Fend:   int32(0x42F),
	},
	14: {
		Fstart: int32(0x531),
		Fend:   int32(0x556),
	},
	15: {
		Fstart: int32(0x10A0),
		Fend:   int32(0x10C5),
	},
	16: {
		Fstart: int32(0x13A0),
		Fend:   int32(0x13F5),
	},
	17: {
		Fstart: int32(0x1C90),
		Fend:   int32(0x1CBA),
	},
	18: {
		Fstart: int32(0x1CBD),
		Fend:   int32(0x1CBF),
	},
	19: {
		Fstart: int32(0x1F08),
		Fend:   int32(0x1F0F),
	},
	20: {
		Fstart: int32(0x1F18),
		Fend:   int32(0x1F1D),
	},
	21: {
		Fstart: int32(0x1F28),
		Fend:   int32(0x1F2F),
	},
	22: {
		Fstart: int32(0x1F38),
		Fend:   int32(0x1F3F),
	},
	23: {
		Fstart: int32(0x1F48),
		Fend:   int32(0x1F4D),
	},
	24: {
		Fstart: int32(0x1F68),
		Fend:   int32(0x1F6F),
	},
	25: {
		Fstart: int32(0x1FB8),
		Fend:   int32(0x1FBB),
	},
	26: {
		Fstart: int32(0x1FC8),
		Fend:   int32(0x1FCB),
	},
	27: {
		Fstart: int32(0x1FD8),
		Fend:   int32(0x1FDB),
	},
	28: {
		Fstart: int32(0x1FE8),
		Fend:   int32(0x1FEC),
	},
	29: {
		Fstart: int32(0x1FF8),
		Fend:   int32(0x1FFB),
	},
	30: {
		Fstart: int32(0x210B),
		Fend:   int32(0x210D),
	},
	31: {
		Fstart: int32(0x2110),
		Fend:   int32(0x2112),
	},
	32: {
		Fstart: int32(0x2119),
		Fend:   int32(0x211D),
	},
	33: {
		Fstart: int32(0x212A),
		Fend:   int32(0x212D),
	},
	34: {
		Fstart: int32(0x2130),
		Fend:   int32(0x2133),
	},
	35: {
		Fstart: int32(0x2C00),
		Fend:   int32(0x2C2F),
	},
	36: {
		Fstart: int32(0x2C62),
		Fend:   int32(0x2C64),
	},
	37: {
		Fstart: int32(0x2C6D),
		Fend:   int32(0x2C70),
	},
	38: {
		Fstart: int32(0x2C7E),
		Fend:   int32(0x2C80),
	},
	39: {
		Fstart: int32(0xA7AA),
		Fend:   int32(0xA7AE),
	},
	40: {
		Fstart: int32(0xA7B0),
		Fend:   int32(0xA7B4),
	},
	41: {
		Fstart: int32(0xA7C4),
		Fend:   int32(0xA7C7),
	},
	42: {
		Fstart: int32(0xFF21),
		Fend:   int32(0xFF3A),
	},
	43: {
		Fstart: int32(0x10400),
		Fend:   int32(0x10427),
	},
	44: {
		Fstart: int32(0x104B0),
		Fend:   int32(0x104D3),
	},
	45: {
		Fstart: int32(0x10570),
		Fend:   int32(0x1057A),
	},
	46: {
		Fstart: int32(0x1057C),
		Fend:   int32(0x1058A),
	},
	47: {
		Fstart: int32(0x1058C),
		Fend:   int32(0x10592),
	},
	48: {
		Fstart: int32(0x10C80),
		Fend:   int32(0x10CB2),
	},
	49: {
		Fstart: int32(0x10D50),
		Fend:   int32(0x10D65),
	},
	50: {
		Fstart: int32(0x118A0),
		Fend:   int32(0x118BF),
	},
	51: {
		Fstart: int32(0x16E40),
		Fend:   int32(0x16E5F),
	},
	52: {
		Fstart: int32(0x1D400),
		Fend:   int32(0x1D419),
	},
	53: {
		Fstart: int32(0x1D434),
		Fend:   int32(0x1D44D),
	},
	54: {
		Fstart: int32(0x1D468),
		Fend:   int32(0x1D481),
	},
	55: {
		Fstart: int32(0x1D4A9),
		Fend:   int32(0x1D4AC),
	},
	56: {
		Fstart: int32(0x1D4AE),
		Fend:   int32(0x1D4B5),
	},
	57: {
		Fstart: int32(0x1D4D0),
		Fend:   int32(0x1D4E9),
	},
	58: {
		Fstart: int32(0x1D507),
		Fend:   int32(0x1D50A),
	},
	59: {
		Fstart: int32(0x1D50D),
		Fend:   int32(0x1D514),
	},
	60: {
		Fstart: int32(0x1D516),
		Fend:   int32(0x1D51C),
	},
	61: {
		Fstart: int32(0x1D53B),
		Fend:   int32(0x1D53E),
	},
	62: {
		Fstart: int32(0x1D540),
		Fend:   int32(0x1D544),
	},
	63: {
		Fstart: int32(0x1D54A),
		Fend:   int32(0x1D550),
	},
	64: {
		Fstart: int32(0x1D56C),
		Fend:   int32(0x1D585),
	},
	65: {
		Fstart: int32(0x1D5A0),
		Fend:   int32(0x1D5B9),
	},
	66: {
		Fstart: int32(0x1D5D4),
		Fend:   int32(0x1D5ED),
	},
	67: {
		Fstart: int32(0x1D608),
		Fend:   int32(0x1D621),
	},
	68: {
		Fstart: int32(0x1D63C),
		Fend:   int32(0x1D655),
	},
	69: {
		Fstart: int32(0x1D670),
		Fend:   int32(0x1D689),
	},
	70: {
		Fstart: int32(0x1D6A8),
		Fend:   int32(0x1D6C0),
	},
	71: {
		Fstart: int32(0x1D6E2),
		Fend:   int32(0x1D6FA),
	},
	72: {
		Fstart: int32(0x1D71C),
		Fend:   int32(0x1D734),
	},
	73: {
		Fstart: int32(0x1D756),
		Fend:   int32(0x1D76E),
	},
	74: {
		Fstart: int32(0x1D790),
		Fend:   int32(0x1D7A8),
	},
	75: {
		Fstart: int32(0x1E900),
		Fend:   int32(0x1E921),
	},
}

var _upperCharTable = [597]Tchr{
	0:   int32(0x100),
	1:   int32(0x102),
	2:   int32(0x104),
	3:   int32(0x106),
	4:   int32(0x108),
	5:   int32(0x10A),
	6:   int32(0x10C),
	7:   int32(0x10E),
	8:   int32(0x110),
	9:   int32(0x112),
	10:  int32(0x114),
	11:  int32(0x116),
	12:  int32(0x118),
	13:  int32(0x11A),
	14:  int32(0x11C),
	15:  int32(0x11E),
	16:  int32(0x120),
	17:  int32(0x122),
	18:  int32(0x124),
	19:  int32(0x126),
	20:  int32(0x128),
	21:  int32(0x12A),
	22:  int32(0x12C),
	23:  int32(0x12E),
	24:  int32(0x130),
	25:  int32(0x132),
	26:  int32(0x134),
	27:  int32(0x136),
	28:  int32(0x139),
	29:  int32(0x13B),
	30:  int32(0x13D),
	31:  int32(0x13F),
	32:  int32(0x141),
	33:  int32(0x143),
	34:  int32(0x145),
	35:  int32(0x147),
	36:  int32(0x14A),
	37:  int32(0x14C),
	38:  int32(0x14E),
	39:  int32(0x150),
	40:  int32(0x152),
	41:  int32(0x154),
	42:  int32(0x156),
	43:  int32(0x158),
	44:  int32(0x15A),
	45:  int32(0x15C),
	46:  int32(0x15E),
	47:  int32(0x160),
	48:  int32(0x162),
	49:  int32(0x164),
	50:  int32(0x166),
	51:  int32(0x168),
	52:  int32(0x16A),
	53:  int32(0x16C),
	54:  int32(0x16E),
	55:  int32(0x170),
	56:  int32(0x172),
	57:  int32(0x174),
	58:  int32(0x176),
	59:  int32(0x178),
	60:  int32(0x179),
	61:  int32(0x17B),
	62:  int32(0x17D),
	63:  int32(0x181),
	64:  int32(0x182),
	65:  int32(0x184),
	66:  int32(0x186),
	67:  int32(0x187),
	68:  int32(0x193),
	69:  int32(0x194),
	70:  int32(0x19C),
	71:  int32(0x19D),
	72:  int32(0x19F),
	73:  int32(0x1A0),
	74:  int32(0x1A2),
	75:  int32(0x1A4),
	76:  int32(0x1A6),
	77:  int32(0x1A7),
	78:  int32(0x1A9),
	79:  int32(0x1AC),
	80:  int32(0x1AE),
	81:  int32(0x1AF),
	82:  int32(0x1B5),
	83:  int32(0x1B7),
	84:  int32(0x1B8),
	85:  int32(0x1BC),
	86:  int32(0x1C4),
	87:  int32(0x1C7),
	88:  int32(0x1CA),
	89:  int32(0x1CD),
	90:  int32(0x1CF),
	91:  int32(0x1D1),
	92:  int32(0x1D3),
	93:  int32(0x1D5),
	94:  int32(0x1D7),
	95:  int32(0x1D9),
	96:  int32(0x1DB),
	97:  int32(0x1DE),
	98:  int32(0x1E0),
	99:  int32(0x1E2),
	100: int32(0x1E4),
	101: int32(0x1E6),
	102: int32(0x1E8),
	103: int32(0x1EA),
	104: int32(0x1EC),
	105: int32(0x1EE),
	106: int32(0x1F1),
	107: int32(0x1F4),
	108: int32(0x1FA),
	109: int32(0x1FC),
	110: int32(0x1FE),
	111: int32(0x200),
	112: int32(0x202),
	113: int32(0x204),
	114: int32(0x206),
	115: int32(0x208),
	116: int32(0x20A),
	117: int32(0x20C),
	118: int32(0x20E),
	119: int32(0x210),
	120: int32(0x212),
	121: int32(0x214),
	122: int32(0x216),
	123: int32(0x218),
	124: int32(0x21A),
	125: int32(0x21C),
	126: int32(0x21E),
	127: int32(0x220),
	128: int32(0x222),
	129: int32(0x224),
	130: int32(0x226),
	131: int32(0x228),
	132: int32(0x22A),
	133: int32(0x22C),
	134: int32(0x22E),
	135: int32(0x230),
	136: int32(0x232),
	137: int32(0x23A),
	138: int32(0x23B),
	139: int32(0x23D),
	140: int32(0x23E),
	141: int32(0x241),
	142: int32(0x248),
	143: int32(0x24A),
	144: int32(0x24C),
	145: int32(0x24E),
	146: int32(0x370),
	147: int32(0x372),
	148: int32(0x376),
	149: int32(0x37F),
	150: int32(0x386),
	151: int32(0x38C),
	152: int32(0x38E),
	153: int32(0x38F),
	154: int32(0x3CF),
	155: int32(0x3D8),
	156: int32(0x3DA),
	157: int32(0x3DC),
	158: int32(0x3DE),
	159: int32(0x3E0),
	160: int32(0x3E2),
	161: int32(0x3E4),
	162: int32(0x3E6),
	163: int32(0x3E8),
	164: int32(0x3EA),
	165: int32(0x3EC),
	166: int32(0x3EE),
	167: int32(0x3F4),
	168: int32(0x3F7),
	169: int32(0x3F9),
	170: int32(0x3FA),
	171: int32(0x460),
	172: int32(0x462),
	173: int32(0x464),
	174: int32(0x466),
	175: int32(0x468),
	176: int32(0x46A),
	177: int32(0x46C),
	178: int32(0x46E),
	179: int32(0x470),
	180: int32(0x472),
	181: int32(0x474),
	182: int32(0x476),
	183: int32(0x478),
	184: int32(0x47A),
	185: int32(0x47C),
	186: int32(0x47E),
	187: int32(0x480),
	188: int32(0x48A),
	189: int32(0x48C),
	190: int32(0x48E),
	191: int32(0x490),
	192: int32(0x492),
	193: int32(0x494),
	194: int32(0x496),
	195: int32(0x498),
	196: int32(0x49A),
	197: int32(0x49C),
	198: int32(0x49E),
	199: int32(0x4A0),
	200: int32(0x4A2),
	201: int32(0x4A4),
	202: int32(0x4A6),
	203: int32(0x4A8),
	204: int32(0x4AA),
	205: int32(0x4AC),
	206: int32(0x4AE),
	207: int32(0x4B0),
	208: int32(0x4B2),
	209: int32(0x4B4),
	210: int32(0x4B6),
	211: int32(0x4B8),
	212: int32(0x4BA),
	213: int32(0x4BC),
	214: int32(0x4BE),
	215: int32(0x4C0),
	216: int32(0x4C1),
	217: int32(0x4C3),
	218: int32(0x4C5),
	219: int32(0x4C7),
	220: int32(0x4C9),
	221: int32(0x4CB),
	222: int32(0x4CD),
	223: int32(0x4D0),
	224: int32(0x4D2),
	225: int32(0x4D4),
	226: int32(0x4D6),
	227: int32(0x4D8),
	228: int32(0x4DA),
	229: int32(0x4DC),
	230: int32(0x4DE),
	231: int32(0x4E0),
	232: int32(0x4E2),
	233: int32(0x4E4),
	234: int32(0x4E6),
	235: int32(0x4E8),
	236: int32(0x4EA),
	237: int32(0x4EC),
	238: int32(0x4EE),
	239: int32(0x4F0),
	240: int32(0x4F2),
	241: int32(0x4F4),
	242: int32(0x4F6),
	243: int32(0x4F8),
	244: int32(0x4FA),
	245: int32(0x4FC),
	246: int32(0x4FE),
	247: int32(0x500),
	248: int32(0x502),
	249: int32(0x504),
	250: int32(0x506),
	251: int32(0x508),
	252: int32(0x50A),
	253: int32(0x50C),
	254: int32(0x50E),
	255: int32(0x510),
	256: int32(0x512),
	257: int32(0x514),
	258: int32(0x516),
	259: int32(0x518),
	260: int32(0x51A),
	261: int32(0x51C),
	262: int32(0x51E),
	263: int32(0x520),
	264: int32(0x522),
	265: int32(0x524),
	266: int32(0x526),
	267: int32(0x528),
	268: int32(0x52A),
	269: int32(0x52C),
	270: int32(0x52E),
	271: int32(0x10C7),
	272: int32(0x10CD),
	273: int32(0x1C89),
	274: int32(0x1E00),
	275: int32(0x1E02),
	276: int32(0x1E04),
	277: int32(0x1E06),
	278: int32(0x1E08),
	279: int32(0x1E0A),
	280: int32(0x1E0C),
	281: int32(0x1E0E),
	282: int32(0x1E10),
	283: int32(0x1E12),
	284: int32(0x1E14),
	285: int32(0x1E16),
	286: int32(0x1E18),
	287: int32(0x1E1A),
	288: int32(0x1E1C),
	289: int32(0x1E1E),
	290: int32(0x1E20),
	291: int32(0x1E22),
	292: int32(0x1E24),
	293: int32(0x1E26),
	294: int32(0x1E28),
	295: int32(0x1E2A),
	296: int32(0x1E2C),
	297: int32(0x1E2E),
	298: int32(0x1E30),
	299: int32(0x1E32),
	300: int32(0x1E34),
	301: int32(0x1E36),
	302: int32(0x1E38),
	303: int32(0x1E3A),
	304: int32(0x1E3C),
	305: int32(0x1E3E),
	306: int32(0x1E40),
	307: int32(0x1E42),
	308: int32(0x1E44),
	309: int32(0x1E46),
	310: int32(0x1E48),
	311: int32(0x1E4A),
	312: int32(0x1E4C),
	313: int32(0x1E4E),
	314: int32(0x1E50),
	315: int32(0x1E52),
	316: int32(0x1E54),
	317: int32(0x1E56),
	318: int32(0x1E58),
	319: int32(0x1E5A),
	320: int32(0x1E5C),
	321: int32(0x1E5E),
	322: int32(0x1E60),
	323: int32(0x1E62),
	324: int32(0x1E64),
	325: int32(0x1E66),
	326: int32(0x1E68),
	327: int32(0x1E6A),
	328: int32(0x1E6C),
	329: int32(0x1E6E),
	330: int32(0x1E70),
	331: int32(0x1E72),
	332: int32(0x1E74),
	333: int32(0x1E76),
	334: int32(0x1E78),
	335: int32(0x1E7A),
	336: int32(0x1E7C),
	337: int32(0x1E7E),
	338: int32(0x1E80),
	339: int32(0x1E82),
	340: int32(0x1E84),
	341: int32(0x1E86),
	342: int32(0x1E88),
	343: int32(0x1E8A),
	344: int32(0x1E8C),
	345: int32(0x1E8E),
	346: int32(0x1E90),
	347: int32(0x1E92),
	348: int32(0x1E94),
	349: int32(0x1E9E),
	350: int32(0x1EA0),
	351: int32(0x1EA2),
	352: int32(0x1EA4),
	353: int32(0x1EA6),
	354: int32(0x1EA8),
	355: int32(0x1EAA),
	356: int32(0x1EAC),
	357: int32(0x1EAE),
	358: int32(0x1EB0),
	359: int32(0x1EB2),
	360: int32(0x1EB4),
	361: int32(0x1EB6),
	362: int32(0x1EB8),
	363: int32(0x1EBA),
	364: int32(0x1EBC),
	365: int32(0x1EBE),
	366: int32(0x1EC0),
	367: int32(0x1EC2),
	368: int32(0x1EC4),
	369: int32(0x1EC6),
	370: int32(0x1EC8),
	371: int32(0x1ECA),
	372: int32(0x1ECC),
	373: int32(0x1ECE),
	374: int32(0x1ED0),
	375: int32(0x1ED2),
	376: int32(0x1ED4),
	377: int32(0x1ED6),
	378: int32(0x1ED8),
	379: int32(0x1EDA),
	380: int32(0x1EDC),
	381: int32(0x1EDE),
	382: int32(0x1EE0),
	383: int32(0x1EE2),
	384: int32(0x1EE4),
	385: int32(0x1EE6),
	386: int32(0x1EE8),
	387: int32(0x1EEA),
	388: int32(0x1EEC),
	389: int32(0x1EEE),
	390: int32(0x1EF0),
	391: int32(0x1EF2),
	392: int32(0x1EF4),
	393: int32(0x1EF6),
	394: int32(0x1EF8),
	395: int32(0x1EFA),
	396: int32(0x1EFC),
	397: int32(0x1EFE),
	398: int32(0x1F59),
	399: int32(0x1F5B),
	400: int32(0x1F5D),
	401: int32(0x1F5F),
	402: int32(0x2102),
	403: int32(0x2107),
	404: int32(0x2115),
	405: int32(0x2124),
	406: int32(0x2126),
	407: int32(0x2128),
	408: int32(0x213E),
	409: int32(0x213F),
	410: int32(0x2145),
	411: int32(0x2183),
	412: int32(0x2C60),
	413: int32(0x2C67),
	414: int32(0x2C69),
	415: int32(0x2C6B),
	416: int32(0x2C72),
	417: int32(0x2C75),
	418: int32(0x2C82),
	419: int32(0x2C84),
	420: int32(0x2C86),
	421: int32(0x2C88),
	422: int32(0x2C8A),
	423: int32(0x2C8C),
	424: int32(0x2C8E),
	425: int32(0x2C90),
	426: int32(0x2C92),
	427: int32(0x2C94),
	428: int32(0x2C96),
	429: int32(0x2C98),
	430: int32(0x2C9A),
	431: int32(0x2C9C),
	432: int32(0x2C9E),
	433: int32(0x2CA0),
	434: int32(0x2CA2),
	435: int32(0x2CA4),
	436: int32(0x2CA6),
	437: int32(0x2CA8),
	438: int32(0x2CAA),
	439: int32(0x2CAC),
	440: int32(0x2CAE),
	441: int32(0x2CB0),
	442: int32(0x2CB2),
	443: int32(0x2CB4),
	444: int32(0x2CB6),
	445: int32(0x2CB8),
	446: int32(0x2CBA),
	447: int32(0x2CBC),
	448: int32(0x2CBE),
	449: int32(0x2CC0),
	450: int32(0x2CC2),
	451: int32(0x2CC4),
	452: int32(0x2CC6),
	453: int32(0x2CC8),
	454: int32(0x2CCA),
	455: int32(0x2CCC),
	456: int32(0x2CCE),
	457: int32(0x2CD0),
	458: int32(0x2CD2),
	459: int32(0x2CD4),
	460: int32(0x2CD6),
	461: int32(0x2CD8),
	462: int32(0x2CDA),
	463: int32(0x2CDC),
	464: int32(0x2CDE),
	465: int32(0x2CE0),
	466: int32(0x2CE2),
	467: int32(0x2CEB),
	468: int32(0x2CED),
	469: int32(0x2CF2),
	470: int32(0xA640),
	471: int32(0xA642),
	472: int32(0xA644),
	473: int32(0xA646),
	474: int32(0xA648),
	475: int32(0xA64A),
	476: int32(0xA64C),
	477: int32(0xA64E),
	478: int32(0xA650),
	479: int32(0xA652),
	480: int32(0xA654),
	481: int32(0xA656),
	482: int32(0xA658),
	483: int32(0xA65A),
	484: int32(0xA65C),
	485: int32(0xA65E),
	486: int32(0xA660),
	487: int32(0xA662),
	488: int32(0xA664),
	489: int32(0xA666),
	490: int32(0xA668),
	491: int32(0xA66A),
	492: int32(0xA66C),
	493: int32(0xA680),
	494: int32(0xA682),
	495: int32(0xA684),
	496: int32(0xA686),
	497: int32(0xA688),
	498: int32(0xA68A),
	499: int32(0xA68C),
	500: int32(0xA68E),
	501: int32(0xA690),
	502: int32(0xA692),
	503: int32(0xA694),
	504: int32(0xA696),
	505: int32(0xA698),
	506: int32(0xA69A),
	507: int32(0xA722),
	508: int32(0xA724),
	509: int32(0xA726),
	510: int32(0xA728),
	511: int32(0xA72A),
	512: int32(0xA72C),
	513: int32(0xA72E),
	514: int32(0xA732),
	515: int32(0xA734),
	516: int32(0xA736),
	517: int32(0xA738),
	518: int32(0xA73A),
	519: int32(0xA73C),
	520: int32(0xA73E),
	521: int32(0xA740),
	522: int32(0xA742),
	523: int32(0xA744),
	524: int32(0xA746),
	525: int32(0xA748),
	526: int32(0xA74A),
	527: int32(0xA74C),
	528: int32(0xA74E),
	529: int32(0xA750),
	530: int32(0xA752),
	531: int32(0xA754),
	532: int32(0xA756),
	533: int32(0xA758),
	534: int32(0xA75A),
	535: int32(0xA75C),
	536: int32(0xA75E),
	537: int32(0xA760),
	538: int32(0xA762),
	539: int32(0xA764),
	540: int32(0xA766),
	541: int32(0xA768),
	542: int32(0xA76A),
	543: int32(0xA76C),
	544: int32(0xA76E),
	545: int32(0xA779),
	546: int32(0xA77B),
	547: int32(0xA77D),
	548: int32(0xA77E),
	549: int32(0xA780),
	550: int32(0xA782),
	551: int32(0xA784),
	552: int32(0xA786),
	553: int32(0xA78B),
	554: int32(0xA78D),
	555: int32(0xA790),
	556: int32(0xA792),
	557: int32(0xA796),
	558: int32(0xA798),
	559: int32(0xA79A),
	560: int32(0xA79C),
	561: int32(0xA79E),
	562: int32(0xA7A0),
	563: int32(0xA7A2),
	564: int32(0xA7A4),
	565: int32(0xA7A6),
	566: int32(0xA7A8),
	567: int32(0xA7B6),
	568: int32(0xA7B8),
	569: int32(0xA7BA),
	570: int32(0xA7BC),
	571: int32(0xA7BE),
	572: int32(0xA7C0),
	573: int32(0xA7C2),
	574: int32(0xA7C9),
	575: int32(0xA7CB),
	576: int32(0xA7CC),
	577: int32(0xA7D0),
	578: int32(0xA7D6),
	579: int32(0xA7D8),
	580: int32(0xA7DA),
	581: int32(0xA7DC),
	582: int32(0xA7F5),
	583: int32(0x10594),
	584: int32(0x10595),
	585: int32(0x1D49C),
	586: int32(0x1D49E),
	587: int32(0x1D49F),
	588: int32(0x1D4A2),
	589: int32(0x1D4A5),
	590: int32(0x1D4A6),
	591: int32(0x1D504),
	592: int32(0x1D505),
	593: int32(0x1D538),
	594: int32(0x1D539),
	595: int32(0x1D546),
	596: int32(0x1D7CA),
}

/*
 * Unicode: unicode print characters excluding space.
 */

var _graphRangeTable = [605]Tcrange{
	0: {
		Fstart: int32(0x21),
		Fend:   int32(0x7E),
	},
	1: {
		Fstart: int32(0xA1),
		Fend:   int32(0xAC),
	},
	2: {
		Fstart: int32(0xAE),
		Fend:   int32(0x377),
	},
	3: {
		Fstart: int32(0x37A),
		Fend:   int32(0x37F),
	},
	4: {
		Fstart: int32(0x384),
		Fend:   int32(0x38A),
	},
	5: {
		Fstart: int32(0x38E),
		Fend:   int32(0x3A1),
	},
	6: {
		Fstart: int32(0x3A3),
		Fend:   int32(0x52F),
	},
	7: {
		Fstart: int32(0x531),
		Fend:   int32(0x556),
	},
	8: {
		Fstart: int32(0x559),
		Fend:   int32(0x58A),
	},
	9: {
		Fstart: int32(0x58D),
		Fend:   int32(0x58F),
	},
	10: {
		Fstart: int32(0x591),
		Fend:   int32(0x5C7),
	},
	11: {
		Fstart: int32(0x5D0),
		Fend:   int32(0x5EA),
	},
	12: {
		Fstart: int32(0x5EF),
		Fend:   int32(0x5F4),
	},
	13: {
		Fstart: int32(0x606),
		Fend:   int32(0x61B),
	},
	14: {
		Fstart: int32(0x61D),
		Fend:   int32(0x6DC),
	},
	15: {
		Fstart: int32(0x6DE),
		Fend:   int32(0x70D),
	},
	16: {
		Fstart: int32(0x710),
		Fend:   int32(0x74A),
	},
	17: {
		Fstart: int32(0x74D),
		Fend:   int32(0x7B1),
	},
	18: {
		Fstart: int32(0x7C0),
		Fend:   int32(0x7FA),
	},
	19: {
		Fstart: int32(0x7FD),
		Fend:   int32(0x82D),
	},
	20: {
		Fstart: int32(0x830),
		Fend:   int32(0x83E),
	},
	21: {
		Fstart: int32(0x840),
		Fend:   int32(0x85B),
	},
	22: {
		Fstart: int32(0x860),
		Fend:   int32(0x86A),
	},
	23: {
		Fstart: int32(0x870),
		Fend:   int32(0x88E),
	},
	24: {
		Fstart: int32(0x897),
		Fend:   int32(0x8E1),
	},
	25: {
		Fstart: int32(0x8E3),
		Fend:   int32(0x983),
	},
	26: {
		Fstart: int32(0x985),
		Fend:   int32(0x98C),
	},
	27: {
		Fstart: int32(0x993),
		Fend:   int32(0x9A8),
	},
	28: {
		Fstart: int32(0x9AA),
		Fend:   int32(0x9B0),
	},
	29: {
		Fstart: int32(0x9B6),
		Fend:   int32(0x9B9),
	},
	30: {
		Fstart: int32(0x9BC),
		Fend:   int32(0x9C4),
	},
	31: {
		Fstart: int32(0x9CB),
		Fend:   int32(0x9CE),
	},
	32: {
		Fstart: int32(0x9DF),
		Fend:   int32(0x9E3),
	},
	33: {
		Fstart: int32(0x9E6),
		Fend:   int32(0x9FE),
	},
	34: {
		Fstart: int32(0xA01),
		Fend:   int32(0xA03),
	},
	35: {
		Fstart: int32(0xA05),
		Fend:   int32(0xA0A),
	},
	36: {
		Fstart: int32(0xA13),
		Fend:   int32(0xA28),
	},
	37: {
		Fstart: int32(0xA2A),
		Fend:   int32(0xA30),
	},
	38: {
		Fstart: int32(0xA3E),
		Fend:   int32(0xA42),
	},
	39: {
		Fstart: int32(0xA4B),
		Fend:   int32(0xA4D),
	},
	40: {
		Fstart: int32(0xA59),
		Fend:   int32(0xA5C),
	},
	41: {
		Fstart: int32(0xA66),
		Fend:   int32(0xA76),
	},
	42: {
		Fstart: int32(0xA81),
		Fend:   int32(0xA83),
	},
	43: {
		Fstart: int32(0xA85),
		Fend:   int32(0xA8D),
	},
	44: {
		Fstart: int32(0xA8F),
		Fend:   int32(0xA91),
	},
	45: {
		Fstart: int32(0xA93),
		Fend:   int32(0xAA8),
	},
	46: {
		Fstart: int32(0xAAA),
		Fend:   int32(0xAB0),
	},
	47: {
		Fstart: int32(0xAB5),
		Fend:   int32(0xAB9),
	},
	48: {
		Fstart: int32(0xABC),
		Fend:   int32(0xAC5),
	},
	49: {
		Fstart: int32(0xAC7),
		Fend:   int32(0xAC9),
	},
	50: {
		Fstart: int32(0xACB),
		Fend:   int32(0xACD),
	},
	51: {
		Fstart: int32(0xAE0),
		Fend:   int32(0xAE3),
	},
	52: {
		Fstart: int32(0xAE6),
		Fend:   int32(0xAF1),
	},
	53: {
		Fstart: int32(0xAF9),
		Fend:   int32(0xAFF),
	},
	54: {
		Fstart: int32(0xB01),
		Fend:   int32(0xB03),
	},
	55: {
		Fstart: int32(0xB05),
		Fend:   int32(0xB0C),
	},
	56: {
		Fstart: int32(0xB13),
		Fend:   int32(0xB28),
	},
	57: {
		Fstart: int32(0xB2A),
		Fend:   int32(0xB30),
	},
	58: {
		Fstart: int32(0xB35),
		Fend:   int32(0xB39),
	},
	59: {
		Fstart: int32(0xB3C),
		Fend:   int32(0xB44),
	},
	60: {
		Fstart: int32(0xB4B),
		Fend:   int32(0xB4D),
	},
	61: {
		Fstart: int32(0xB55),
		Fend:   int32(0xB57),
	},
	62: {
		Fstart: int32(0xB5F),
		Fend:   int32(0xB63),
	},
	63: {
		Fstart: int32(0xB66),
		Fend:   int32(0xB77),
	},
	64: {
		Fstart: int32(0xB85),
		Fend:   int32(0xB8A),
	},
	65: {
		Fstart: int32(0xB8E),
		Fend:   int32(0xB90),
	},
	66: {
		Fstart: int32(0xB92),
		Fend:   int32(0xB95),
	},
	67: {
		Fstart: int32(0xBA8),
		Fend:   int32(0xBAA),
	},
	68: {
		Fstart: int32(0xBAE),
		Fend:   int32(0xBB9),
	},
	69: {
		Fstart: int32(0xBBE),
		Fend:   int32(0xBC2),
	},
	70: {
		Fstart: int32(0xBC6),
		Fend:   int32(0xBC8),
	},
	71: {
		Fstart: int32(0xBCA),
		Fend:   int32(0xBCD),
	},
	72: {
		Fstart: int32(0xBE6),
		Fend:   int32(0xBFA),
	},
	73: {
		Fstart: int32(0xC00),
		Fend:   int32(0xC0C),
	},
	74: {
		Fstart: int32(0xC0E),
		Fend:   int32(0xC10),
	},
	75: {
		Fstart: int32(0xC12),
		Fend:   int32(0xC28),
	},
	76: {
		Fstart: int32(0xC2A),
		Fend:   int32(0xC39),
	},
	77: {
		Fstart: int32(0xC3C),
		Fend:   int32(0xC44),
	},
	78: {
		Fstart: int32(0xC46),
		Fend:   int32(0xC48),
	},
	79: {
		Fstart: int32(0xC4A),
		Fend:   int32(0xC4D),
	},
	80: {
		Fstart: int32(0xC58),
		Fend:   int32(0xC5A),
	},
	81: {
		Fstart: int32(0xC60),
		Fend:   int32(0xC63),
	},
	82: {
		Fstart: int32(0xC66),
		Fend:   int32(0xC6F),
	},
	83: {
		Fstart: int32(0xC77),
		Fend:   int32(0xC8C),
	},
	84: {
		Fstart: int32(0xC8E),
		Fend:   int32(0xC90),
	},
	85: {
		Fstart: int32(0xC92),
		Fend:   int32(0xCA8),
	},
	86: {
		Fstart: int32(0xCAA),
		Fend:   int32(0xCB3),
	},
	87: {
		Fstart: int32(0xCB5),
		Fend:   int32(0xCB9),
	},
	88: {
		Fstart: int32(0xCBC),
		Fend:   int32(0xCC4),
	},
	89: {
		Fstart: int32(0xCC6),
		Fend:   int32(0xCC8),
	},
	90: {
		Fstart: int32(0xCCA),
		Fend:   int32(0xCCD),
	},
	91: {
		Fstart: int32(0xCE0),
		Fend:   int32(0xCE3),
	},
	92: {
		Fstart: int32(0xCE6),
		Fend:   int32(0xCEF),
	},
	93: {
		Fstart: int32(0xCF1),
		Fend:   int32(0xCF3),
	},
	94: {
		Fstart: int32(0xD00),
		Fend:   int32(0xD0C),
	},
	95: {
		Fstart: int32(0xD0E),
		Fend:   int32(0xD10),
	},
	96: {
		Fstart: int32(0xD12),
		Fend:   int32(0xD44),
	},
	97: {
		Fstart: int32(0xD46),
		Fend:   int32(0xD48),
	},
	98: {
		Fstart: int32(0xD4A),
		Fend:   int32(0xD4F),
	},
	99: {
		Fstart: int32(0xD54),
		Fend:   int32(0xD63),
	},
	100: {
		Fstart: int32(0xD66),
		Fend:   int32(0xD7F),
	},
	101: {
		Fstart: int32(0xD81),
		Fend:   int32(0xD83),
	},
	102: {
		Fstart: int32(0xD85),
		Fend:   int32(0xD96),
	},
	103: {
		Fstart: int32(0xD9A),
		Fend:   int32(0xDB1),
	},
	104: {
		Fstart: int32(0xDB3),
		Fend:   int32(0xDBB),
	},
	105: {
		Fstart: int32(0xDC0),
		Fend:   int32(0xDC6),
	},
	106: {
		Fstart: int32(0xDCF),
		Fend:   int32(0xDD4),
	},
	107: {
		Fstart: int32(0xDD8),
		Fend:   int32(0xDDF),
	},
	108: {
		Fstart: int32(0xDE6),
		Fend:   int32(0xDEF),
	},
	109: {
		Fstart: int32(0xDF2),
		Fend:   int32(0xDF4),
	},
	110: {
		Fstart: int32(0xE01),
		Fend:   int32(0xE3A),
	},
	111: {
		Fstart: int32(0xE3F),
		Fend:   int32(0xE5B),
	},
	112: {
		Fstart: int32(0xE86),
		Fend:   int32(0xE8A),
	},
	113: {
		Fstart: int32(0xE8C),
		Fend:   int32(0xEA3),
	},
	114: {
		Fstart: int32(0xEA7),
		Fend:   int32(0xEBD),
	},
	115: {
		Fstart: int32(0xEC0),
		Fend:   int32(0xEC4),
	},
	116: {
		Fstart: int32(0xEC8),
		Fend:   int32(0xECE),
	},
	117: {
		Fstart: int32(0xED0),
		Fend:   int32(0xED9),
	},
	118: {
		Fstart: int32(0xEDC),
		Fend:   int32(0xEDF),
	},
	119: {
		Fstart: int32(0xF00),
		Fend:   int32(0xF47),
	},
	120: {
		Fstart: int32(0xF49),
		Fend:   int32(0xF6C),
	},
	121: {
		Fstart: int32(0xF71),
		Fend:   int32(0xF97),
	},
	122: {
		Fstart: int32(0xF99),
		Fend:   int32(0xFBC),
	},
	123: {
		Fstart: int32(0xFBE),
		Fend:   int32(0xFCC),
	},
	124: {
		Fstart: int32(0xFCE),
		Fend:   int32(0xFDA),
	},
	125: {
		Fstart: int32(0x1000),
		Fend:   int32(0x10C5),
	},
	126: {
		Fstart: int32(0x10D0),
		Fend:   int32(0x1248),
	},
	127: {
		Fstart: int32(0x124A),
		Fend:   int32(0x124D),
	},
	128: {
		Fstart: int32(0x1250),
		Fend:   int32(0x1256),
	},
	129: {
		Fstart: int32(0x125A),
		Fend:   int32(0x125D),
	},
	130: {
		Fstart: int32(0x1260),
		Fend:   int32(0x1288),
	},
	131: {
		Fstart: int32(0x128A),
		Fend:   int32(0x128D),
	},
	132: {
		Fstart: int32(0x1290),
		Fend:   int32(0x12B0),
	},
	133: {
		Fstart: int32(0x12B2),
		Fend:   int32(0x12B5),
	},
	134: {
		Fstart: int32(0x12B8),
		Fend:   int32(0x12BE),
	},
	135: {
		Fstart: int32(0x12C2),
		Fend:   int32(0x12C5),
	},
	136: {
		Fstart: int32(0x12C8),
		Fend:   int32(0x12D6),
	},
	137: {
		Fstart: int32(0x12D8),
		Fend:   int32(0x1310),
	},
	138: {
		Fstart: int32(0x1312),
		Fend:   int32(0x1315),
	},
	139: {
		Fstart: int32(0x1318),
		Fend:   int32(0x135A),
	},
	140: {
		Fstart: int32(0x135D),
		Fend:   int32(0x137C),
	},
	141: {
		Fstart: int32(0x1380),
		Fend:   int32(0x1399),
	},
	142: {
		Fstart: int32(0x13A0),
		Fend:   int32(0x13F5),
	},
	143: {
		Fstart: int32(0x13F8),
		Fend:   int32(0x13FD),
	},
	144: {
		Fstart: int32(0x1400),
		Fend:   int32(0x167F),
	},
	145: {
		Fstart: int32(0x1681),
		Fend:   int32(0x169C),
	},
	146: {
		Fstart: int32(0x16A0),
		Fend:   int32(0x16F8),
	},
	147: {
		Fstart: int32(0x1700),
		Fend:   int32(0x1715),
	},
	148: {
		Fstart: int32(0x171F),
		Fend:   int32(0x1736),
	},
	149: {
		Fstart: int32(0x1740),
		Fend:   int32(0x1753),
	},
	150: {
		Fstart: int32(0x1760),
		Fend:   int32(0x176C),
	},
	151: {
		Fstart: int32(0x176E),
		Fend:   int32(0x1770),
	},
	152: {
		Fstart: int32(0x1780),
		Fend:   int32(0x17DD),
	},
	153: {
		Fstart: int32(0x17E0),
		Fend:   int32(0x17E9),
	},
	154: {
		Fstart: int32(0x17F0),
		Fend:   int32(0x17F9),
	},
	155: {
		Fstart: int32(0x1800),
		Fend:   int32(0x180D),
	},
	156: {
		Fstart: int32(0x180F),
		Fend:   int32(0x1819),
	},
	157: {
		Fstart: int32(0x1820),
		Fend:   int32(0x1878),
	},
	158: {
		Fstart: int32(0x1880),
		Fend:   int32(0x18AA),
	},
	159: {
		Fstart: int32(0x18B0),
		Fend:   int32(0x18F5),
	},
	160: {
		Fstart: int32(0x1900),
		Fend:   int32(0x191E),
	},
	161: {
		Fstart: int32(0x1920),
		Fend:   int32(0x192B),
	},
	162: {
		Fstart: int32(0x1930),
		Fend:   int32(0x193B),
	},
	163: {
		Fstart: int32(0x1944),
		Fend:   int32(0x196D),
	},
	164: {
		Fstart: int32(0x1970),
		Fend:   int32(0x1974),
	},
	165: {
		Fstart: int32(0x1980),
		Fend:   int32(0x19AB),
	},
	166: {
		Fstart: int32(0x19B0),
		Fend:   int32(0x19C9),
	},
	167: {
		Fstart: int32(0x19D0),
		Fend:   int32(0x19DA),
	},
	168: {
		Fstart: int32(0x19DE),
		Fend:   int32(0x1A1B),
	},
	169: {
		Fstart: int32(0x1A1E),
		Fend:   int32(0x1A5E),
	},
	170: {
		Fstart: int32(0x1A60),
		Fend:   int32(0x1A7C),
	},
	171: {
		Fstart: int32(0x1A7F),
		Fend:   int32(0x1A89),
	},
	172: {
		Fstart: int32(0x1A90),
		Fend:   int32(0x1A99),
	},
	173: {
		Fstart: int32(0x1AA0),
		Fend:   int32(0x1AAD),
	},
	174: {
		Fstart: int32(0x1AB0),
		Fend:   int32(0x1ACE),
	},
	175: {
		Fstart: int32(0x1B00),
		Fend:   int32(0x1B4C),
	},
	176: {
		Fstart: int32(0x1B4E),
		Fend:   int32(0x1BF3),
	},
	177: {
		Fstart: int32(0x1BFC),
		Fend:   int32(0x1C37),
	},
	178: {
		Fstart: int32(0x1C3B),
		Fend:   int32(0x1C49),
	},
	179: {
		Fstart: int32(0x1C4D),
		Fend:   int32(0x1C8A),
	},
	180: {
		Fstart: int32(0x1C90),
		Fend:   int32(0x1CBA),
	},
	181: {
		Fstart: int32(0x1CBD),
		Fend:   int32(0x1CC7),
	},
	182: {
		Fstart: int32(0x1CD0),
		Fend:   int32(0x1CFA),
	},
	183: {
		Fstart: int32(0x1D00),
		Fend:   int32(0x1F15),
	},
	184: {
		Fstart: int32(0x1F18),
		Fend:   int32(0x1F1D),
	},
	185: {
		Fstart: int32(0x1F20),
		Fend:   int32(0x1F45),
	},
	186: {
		Fstart: int32(0x1F48),
		Fend:   int32(0x1F4D),
	},
	187: {
		Fstart: int32(0x1F50),
		Fend:   int32(0x1F57),
	},
	188: {
		Fstart: int32(0x1F5F),
		Fend:   int32(0x1F7D),
	},
	189: {
		Fstart: int32(0x1F80),
		Fend:   int32(0x1FB4),
	},
	190: {
		Fstart: int32(0x1FB6),
		Fend:   int32(0x1FC4),
	},
	191: {
		Fstart: int32(0x1FC6),
		Fend:   int32(0x1FD3),
	},
	192: {
		Fstart: int32(0x1FD6),
		Fend:   int32(0x1FDB),
	},
	193: {
		Fstart: int32(0x1FDD),
		Fend:   int32(0x1FEF),
	},
	194: {
		Fstart: int32(0x1FF2),
		Fend:   int32(0x1FF4),
	},
	195: {
		Fstart: int32(0x1FF6),
		Fend:   int32(0x1FFE),
	},
	196: {
		Fstart: int32(0x2010),
		Fend:   int32(0x2027),
	},
	197: {
		Fstart: int32(0x2030),
		Fend:   int32(0x205E),
	},
	198: {
		Fstart: int32(0x2074),
		Fend:   int32(0x208E),
	},
	199: {
		Fstart: int32(0x2090),
		Fend:   int32(0x209C),
	},
	200: {
		Fstart: int32(0x20A0),
		Fend:   int32(0x20C0),
	},
	201: {
		Fstart: int32(0x20D0),
		Fend:   int32(0x20F0),
	},
	202: {
		Fstart: int32(0x2100),
		Fend:   int32(0x218B),
	},
	203: {
		Fstart: int32(0x2190),
		Fend:   int32(0x2429),
	},
	204: {
		Fstart: int32(0x2440),
		Fend:   int32(0x244A),
	},
	205: {
		Fstart: int32(0x2460),
		Fend:   int32(0x2B73),
	},
	206: {
		Fstart: int32(0x2B76),
		Fend:   int32(0x2B95),
	},
	207: {
		Fstart: int32(0x2B97),
		Fend:   int32(0x2CF3),
	},
	208: {
		Fstart: int32(0x2CF9),
		Fend:   int32(0x2D25),
	},
	209: {
		Fstart: int32(0x2D30),
		Fend:   int32(0x2D67),
	},
	210: {
		Fstart: int32(0x2D7F),
		Fend:   int32(0x2D96),
	},
	211: {
		Fstart: int32(0x2DA0),
		Fend:   int32(0x2DA6),
	},
	212: {
		Fstart: int32(0x2DA8),
		Fend:   int32(0x2DAE),
	},
	213: {
		Fstart: int32(0x2DB0),
		Fend:   int32(0x2DB6),
	},
	214: {
		Fstart: int32(0x2DB8),
		Fend:   int32(0x2DBE),
	},
	215: {
		Fstart: int32(0x2DC0),
		Fend:   int32(0x2DC6),
	},
	216: {
		Fstart: int32(0x2DC8),
		Fend:   int32(0x2DCE),
	},
	217: {
		Fstart: int32(0x2DD0),
		Fend:   int32(0x2DD6),
	},
	218: {
		Fstart: int32(0x2DD8),
		Fend:   int32(0x2DDE),
	},
	219: {
		Fstart: int32(0x2DE0),
		Fend:   int32(0x2E5D),
	},
	220: {
		Fstart: int32(0x2E80),
		Fend:   int32(0x2E99),
	},
	221: {
		Fstart: int32(0x2E9B),
		Fend:   int32(0x2EF3),
	},
	222: {
		Fstart: int32(0x2F00),
		Fend:   int32(0x2FD5),
	},
	223: {
		Fstart: int32(0x2FF0),
		Fend:   int32(0x2FFF),
	},
	224: {
		Fstart: int32(0x3001),
		Fend:   int32(0x303F),
	},
	225: {
		Fstart: int32(0x3041),
		Fend:   int32(0x3096),
	},
	226: {
		Fstart: int32(0x3099),
		Fend:   int32(0x30FF),
	},
	227: {
		Fstart: int32(0x3105),
		Fend:   int32(0x312F),
	},
	228: {
		Fstart: int32(0x3131),
		Fend:   int32(0x318E),
	},
	229: {
		Fstart: int32(0x3190),
		Fend:   int32(0x31E5),
	},
	230: {
		Fstart: int32(0x31EF),
		Fend:   int32(0x321E),
	},
	231: {
		Fstart: int32(0x3220),
		Fend:   int32(0xA48C),
	},
	232: {
		Fstart: int32(0xA490),
		Fend:   int32(0xA4C6),
	},
	233: {
		Fstart: int32(0xA4D0),
		Fend:   int32(0xA62B),
	},
	234: {
		Fstart: int32(0xA640),
		Fend:   int32(0xA6F7),
	},
	235: {
		Fstart: int32(0xA700),
		Fend:   int32(0xA7CD),
	},
	236: {
		Fstart: int32(0xA7D5),
		Fend:   int32(0xA7DC),
	},
	237: {
		Fstart: int32(0xA7F2),
		Fend:   int32(0xA82C),
	},
	238: {
		Fstart: int32(0xA830),
		Fend:   int32(0xA839),
	},
	239: {
		Fstart: int32(0xA840),
		Fend:   int32(0xA877),
	},
	240: {
		Fstart: int32(0xA880),
		Fend:   int32(0xA8C5),
	},
	241: {
		Fstart: int32(0xA8CE),
		Fend:   int32(0xA8D9),
	},
	242: {
		Fstart: int32(0xA8E0),
		Fend:   int32(0xA953),
	},
	243: {
		Fstart: int32(0xA95F),
		Fend:   int32(0xA97C),
	},
	244: {
		Fstart: int32(0xA980),
		Fend:   int32(0xA9CD),
	},
	245: {
		Fstart: int32(0xA9CF),
		Fend:   int32(0xA9D9),
	},
	246: {
		Fstart: int32(0xA9DE),
		Fend:   int32(0xA9FE),
	},
	247: {
		Fstart: int32(0xAA00),
		Fend:   int32(0xAA36),
	},
	248: {
		Fstart: int32(0xAA40),
		Fend:   int32(0xAA4D),
	},
	249: {
		Fstart: int32(0xAA50),
		Fend:   int32(0xAA59),
	},
	250: {
		Fstart: int32(0xAA5C),
		Fend:   int32(0xAAC2),
	},
	251: {
		Fstart: int32(0xAADB),
		Fend:   int32(0xAAF6),
	},
	252: {
		Fstart: int32(0xAB01),
		Fend:   int32(0xAB06),
	},
	253: {
		Fstart: int32(0xAB09),
		Fend:   int32(0xAB0E),
	},
	254: {
		Fstart: int32(0xAB11),
		Fend:   int32(0xAB16),
	},
	255: {
		Fstart: int32(0xAB20),
		Fend:   int32(0xAB26),
	},
	256: {
		Fstart: int32(0xAB28),
		Fend:   int32(0xAB2E),
	},
	257: {
		Fstart: int32(0xAB30),
		Fend:   int32(0xAB6B),
	},
	258: {
		Fstart: int32(0xAB70),
		Fend:   int32(0xABED),
	},
	259: {
		Fstart: int32(0xABF0),
		Fend:   int32(0xABF9),
	},
	260: {
		Fstart: int32(0xAC00),
		Fend:   int32(0xD7A3),
	},
	261: {
		Fstart: int32(0xD7B0),
		Fend:   int32(0xD7C6),
	},
	262: {
		Fstart: int32(0xD7CB),
		Fend:   int32(0xD7FB),
	},
	263: {
		Fstart: int32(0xF900),
		Fend:   int32(0xFA6D),
	},
	264: {
		Fstart: int32(0xFA70),
		Fend:   int32(0xFAD9),
	},
	265: {
		Fstart: int32(0xFB00),
		Fend:   int32(0xFB06),
	},
	266: {
		Fstart: int32(0xFB13),
		Fend:   int32(0xFB17),
	},
	267: {
		Fstart: int32(0xFB1D),
		Fend:   int32(0xFB36),
	},
	268: {
		Fstart: int32(0xFB38),
		Fend:   int32(0xFB3C),
	},
	269: {
		Fstart: int32(0xFB46),
		Fend:   int32(0xFBC2),
	},
	270: {
		Fstart: int32(0xFBD3),
		Fend:   int32(0xFD8F),
	},
	271: {
		Fstart: int32(0xFD92),
		Fend:   int32(0xFDC7),
	},
	272: {
		Fstart: int32(0xFDF0),
		Fend:   int32(0xFE19),
	},
	273: {
		Fstart: int32(0xFE20),
		Fend:   int32(0xFE52),
	},
	274: {
		Fstart: int32(0xFE54),
		Fend:   int32(0xFE66),
	},
	275: {
		Fstart: int32(0xFE68),
		Fend:   int32(0xFE6B),
	},
	276: {
		Fstart: int32(0xFE70),
		Fend:   int32(0xFE74),
	},
	277: {
		Fstart: int32(0xFE76),
		Fend:   int32(0xFEFC),
	},
	278: {
		Fstart: int32(0xFF01),
		Fend:   int32(0xFFBE),
	},
	279: {
		Fstart: int32(0xFFC2),
		Fend:   int32(0xFFC7),
	},
	280: {
		Fstart: int32(0xFFCA),
		Fend:   int32(0xFFCF),
	},
	281: {
		Fstart: int32(0xFFD2),
		Fend:   int32(0xFFD7),
	},
	282: {
		Fstart: int32(0xFFDA),
		Fend:   int32(0xFFDC),
	},
	283: {
		Fstart: int32(0xFFE0),
		Fend:   int32(0xFFE6),
	},
	284: {
		Fstart: int32(0xFFE8),
		Fend:   int32(0xFFEE),
	},
	285: {
		Fstart: int32(0x10000),
		Fend:   int32(0x1000B),
	},
	286: {
		Fstart: int32(0x1000D),
		Fend:   int32(0x10026),
	},
	287: {
		Fstart: int32(0x10028),
		Fend:   int32(0x1003A),
	},
	288: {
		Fstart: int32(0x1003F),
		Fend:   int32(0x1004D),
	},
	289: {
		Fstart: int32(0x10050),
		Fend:   int32(0x1005D),
	},
	290: {
		Fstart: int32(0x10080),
		Fend:   int32(0x100FA),
	},
	291: {
		Fstart: int32(0x10100),
		Fend:   int32(0x10102),
	},
	292: {
		Fstart: int32(0x10107),
		Fend:   int32(0x10133),
	},
	293: {
		Fstart: int32(0x10137),
		Fend:   int32(0x1018E),
	},
	294: {
		Fstart: int32(0x10190),
		Fend:   int32(0x1019C),
	},
	295: {
		Fstart: int32(0x101D0),
		Fend:   int32(0x101FD),
	},
	296: {
		Fstart: int32(0x10280),
		Fend:   int32(0x1029C),
	},
	297: {
		Fstart: int32(0x102A0),
		Fend:   int32(0x102D0),
	},
	298: {
		Fstart: int32(0x102E0),
		Fend:   int32(0x102FB),
	},
	299: {
		Fstart: int32(0x10300),
		Fend:   int32(0x10323),
	},
	300: {
		Fstart: int32(0x1032D),
		Fend:   int32(0x1034A),
	},
	301: {
		Fstart: int32(0x10350),
		Fend:   int32(0x1037A),
	},
	302: {
		Fstart: int32(0x10380),
		Fend:   int32(0x1039D),
	},
	303: {
		Fstart: int32(0x1039F),
		Fend:   int32(0x103C3),
	},
	304: {
		Fstart: int32(0x103C8),
		Fend:   int32(0x103D5),
	},
	305: {
		Fstart: int32(0x10400),
		Fend:   int32(0x1049D),
	},
	306: {
		Fstart: int32(0x104A0),
		Fend:   int32(0x104A9),
	},
	307: {
		Fstart: int32(0x104B0),
		Fend:   int32(0x104D3),
	},
	308: {
		Fstart: int32(0x104D8),
		Fend:   int32(0x104FB),
	},
	309: {
		Fstart: int32(0x10500),
		Fend:   int32(0x10527),
	},
	310: {
		Fstart: int32(0x10530),
		Fend:   int32(0x10563),
	},
	311: {
		Fstart: int32(0x1056F),
		Fend:   int32(0x1057A),
	},
	312: {
		Fstart: int32(0x1057C),
		Fend:   int32(0x1058A),
	},
	313: {
		Fstart: int32(0x1058C),
		Fend:   int32(0x10592),
	},
	314: {
		Fstart: int32(0x10597),
		Fend:   int32(0x105A1),
	},
	315: {
		Fstart: int32(0x105A3),
		Fend:   int32(0x105B1),
	},
	316: {
		Fstart: int32(0x105B3),
		Fend:   int32(0x105B9),
	},
	317: {
		Fstart: int32(0x105C0),
		Fend:   int32(0x105F3),
	},
	318: {
		Fstart: int32(0x10600),
		Fend:   int32(0x10736),
	},
	319: {
		Fstart: int32(0x10740),
		Fend:   int32(0x10755),
	},
	320: {
		Fstart: int32(0x10760),
		Fend:   int32(0x10767),
	},
	321: {
		Fstart: int32(0x10780),
		Fend:   int32(0x10785),
	},
	322: {
		Fstart: int32(0x10787),
		Fend:   int32(0x107B0),
	},
	323: {
		Fstart: int32(0x107B2),
		Fend:   int32(0x107BA),
	},
	324: {
		Fstart: int32(0x10800),
		Fend:   int32(0x10805),
	},
	325: {
		Fstart: int32(0x1080A),
		Fend:   int32(0x10835),
	},
	326: {
		Fstart: int32(0x1083F),
		Fend:   int32(0x10855),
	},
	327: {
		Fstart: int32(0x10857),
		Fend:   int32(0x1089E),
	},
	328: {
		Fstart: int32(0x108A7),
		Fend:   int32(0x108AF),
	},
	329: {
		Fstart: int32(0x108E0),
		Fend:   int32(0x108F2),
	},
	330: {
		Fstart: int32(0x108FB),
		Fend:   int32(0x1091B),
	},
	331: {
		Fstart: int32(0x1091F),
		Fend:   int32(0x10939),
	},
	332: {
		Fstart: int32(0x10980),
		Fend:   int32(0x109B7),
	},
	333: {
		Fstart: int32(0x109BC),
		Fend:   int32(0x109CF),
	},
	334: {
		Fstart: int32(0x109D2),
		Fend:   int32(0x10A03),
	},
	335: {
		Fstart: int32(0x10A0C),
		Fend:   int32(0x10A13),
	},
	336: {
		Fstart: int32(0x10A15),
		Fend:   int32(0x10A17),
	},
	337: {
		Fstart: int32(0x10A19),
		Fend:   int32(0x10A35),
	},
	338: {
		Fstart: int32(0x10A38),
		Fend:   int32(0x10A3A),
	},
	339: {
		Fstart: int32(0x10A3F),
		Fend:   int32(0x10A48),
	},
	340: {
		Fstart: int32(0x10A50),
		Fend:   int32(0x10A58),
	},
	341: {
		Fstart: int32(0x10A60),
		Fend:   int32(0x10A9F),
	},
	342: {
		Fstart: int32(0x10AC0),
		Fend:   int32(0x10AE6),
	},
	343: {
		Fstart: int32(0x10AEB),
		Fend:   int32(0x10AF6),
	},
	344: {
		Fstart: int32(0x10B00),
		Fend:   int32(0x10B35),
	},
	345: {
		Fstart: int32(0x10B39),
		Fend:   int32(0x10B55),
	},
	346: {
		Fstart: int32(0x10B58),
		Fend:   int32(0x10B72),
	},
	347: {
		Fstart: int32(0x10B78),
		Fend:   int32(0x10B91),
	},
	348: {
		Fstart: int32(0x10B99),
		Fend:   int32(0x10B9C),
	},
	349: {
		Fstart: int32(0x10BA9),
		Fend:   int32(0x10BAF),
	},
	350: {
		Fstart: int32(0x10C00),
		Fend:   int32(0x10C48),
	},
	351: {
		Fstart: int32(0x10C80),
		Fend:   int32(0x10CB2),
	},
	352: {
		Fstart: int32(0x10CC0),
		Fend:   int32(0x10CF2),
	},
	353: {
		Fstart: int32(0x10CFA),
		Fend:   int32(0x10D27),
	},
	354: {
		Fstart: int32(0x10D30),
		Fend:   int32(0x10D39),
	},
	355: {
		Fstart: int32(0x10D40),
		Fend:   int32(0x10D65),
	},
	356: {
		Fstart: int32(0x10D69),
		Fend:   int32(0x10D85),
	},
	357: {
		Fstart: int32(0x10E60),
		Fend:   int32(0x10E7E),
	},
	358: {
		Fstart: int32(0x10E80),
		Fend:   int32(0x10EA9),
	},
	359: {
		Fstart: int32(0x10EAB),
		Fend:   int32(0x10EAD),
	},
	360: {
		Fstart: int32(0x10EC2),
		Fend:   int32(0x10EC4),
	},
	361: {
		Fstart: int32(0x10EFC),
		Fend:   int32(0x10F27),
	},
	362: {
		Fstart: int32(0x10F30),
		Fend:   int32(0x10F59),
	},
	363: {
		Fstart: int32(0x10F70),
		Fend:   int32(0x10F89),
	},
	364: {
		Fstart: int32(0x10FB0),
		Fend:   int32(0x10FCB),
	},
	365: {
		Fstart: int32(0x10FE0),
		Fend:   int32(0x10FF6),
	},
	366: {
		Fstart: int32(0x11000),
		Fend:   int32(0x1104D),
	},
	367: {
		Fstart: int32(0x11052),
		Fend:   int32(0x11075),
	},
	368: {
		Fstart: int32(0x1107F),
		Fend:   int32(0x110BC),
	},
	369: {
		Fstart: int32(0x110BE),
		Fend:   int32(0x110C2),
	},
	370: {
		Fstart: int32(0x110D0),
		Fend:   int32(0x110E8),
	},
	371: {
		Fstart: int32(0x110F0),
		Fend:   int32(0x110F9),
	},
	372: {
		Fstart: int32(0x11100),
		Fend:   int32(0x11134),
	},
	373: {
		Fstart: int32(0x11136),
		Fend:   int32(0x11147),
	},
	374: {
		Fstart: int32(0x11150),
		Fend:   int32(0x11176),
	},
	375: {
		Fstart: int32(0x11180),
		Fend:   int32(0x111DF),
	},
	376: {
		Fstart: int32(0x111E1),
		Fend:   int32(0x111F4),
	},
	377: {
		Fstart: int32(0x11200),
		Fend:   int32(0x11211),
	},
	378: {
		Fstart: int32(0x11213),
		Fend:   int32(0x11241),
	},
	379: {
		Fstart: int32(0x11280),
		Fend:   int32(0x11286),
	},
	380: {
		Fstart: int32(0x1128A),
		Fend:   int32(0x1128D),
	},
	381: {
		Fstart: int32(0x1128F),
		Fend:   int32(0x1129D),
	},
	382: {
		Fstart: int32(0x1129F),
		Fend:   int32(0x112A9),
	},
	383: {
		Fstart: int32(0x112B0),
		Fend:   int32(0x112EA),
	},
	384: {
		Fstart: int32(0x112F0),
		Fend:   int32(0x112F9),
	},
	385: {
		Fstart: int32(0x11300),
		Fend:   int32(0x11303),
	},
	386: {
		Fstart: int32(0x11305),
		Fend:   int32(0x1130C),
	},
	387: {
		Fstart: int32(0x11313),
		Fend:   int32(0x11328),
	},
	388: {
		Fstart: int32(0x1132A),
		Fend:   int32(0x11330),
	},
	389: {
		Fstart: int32(0x11335),
		Fend:   int32(0x11339),
	},
	390: {
		Fstart: int32(0x1133B),
		Fend:   int32(0x11344),
	},
	391: {
		Fstart: int32(0x1134B),
		Fend:   int32(0x1134D),
	},
	392: {
		Fstart: int32(0x1135D),
		Fend:   int32(0x11363),
	},
	393: {
		Fstart: int32(0x11366),
		Fend:   int32(0x1136C),
	},
	394: {
		Fstart: int32(0x11370),
		Fend:   int32(0x11374),
	},
	395: {
		Fstart: int32(0x11380),
		Fend:   int32(0x11389),
	},
	396: {
		Fstart: int32(0x11390),
		Fend:   int32(0x113B5),
	},
	397: {
		Fstart: int32(0x113B7),
		Fend:   int32(0x113C0),
	},
	398: {
		Fstart: int32(0x113C7),
		Fend:   int32(0x113CA),
	},
	399: {
		Fstart: int32(0x113CC),
		Fend:   int32(0x113D5),
	},
	400: {
		Fstart: int32(0x11400),
		Fend:   int32(0x1145B),
	},
	401: {
		Fstart: int32(0x1145D),
		Fend:   int32(0x11461),
	},
	402: {
		Fstart: int32(0x11480),
		Fend:   int32(0x114C7),
	},
	403: {
		Fstart: int32(0x114D0),
		Fend:   int32(0x114D9),
	},
	404: {
		Fstart: int32(0x11580),
		Fend:   int32(0x115B5),
	},
	405: {
		Fstart: int32(0x115B8),
		Fend:   int32(0x115DD),
	},
	406: {
		Fstart: int32(0x11600),
		Fend:   int32(0x11644),
	},
	407: {
		Fstart: int32(0x11650),
		Fend:   int32(0x11659),
	},
	408: {
		Fstart: int32(0x11660),
		Fend:   int32(0x1166C),
	},
	409: {
		Fstart: int32(0x11680),
		Fend:   int32(0x116B9),
	},
	410: {
		Fstart: int32(0x116C0),
		Fend:   int32(0x116C9),
	},
	411: {
		Fstart: int32(0x116D0),
		Fend:   int32(0x116E3),
	},
	412: {
		Fstart: int32(0x11700),
		Fend:   int32(0x1171A),
	},
	413: {
		Fstart: int32(0x1171D),
		Fend:   int32(0x1172B),
	},
	414: {
		Fstart: int32(0x11730),
		Fend:   int32(0x11746),
	},
	415: {
		Fstart: int32(0x11800),
		Fend:   int32(0x1183B),
	},
	416: {
		Fstart: int32(0x118A0),
		Fend:   int32(0x118F2),
	},
	417: {
		Fstart: int32(0x118FF),
		Fend:   int32(0x11906),
	},
	418: {
		Fstart: int32(0x1190C),
		Fend:   int32(0x11913),
	},
	419: {
		Fstart: int32(0x11918),
		Fend:   int32(0x11935),
	},
	420: {
		Fstart: int32(0x1193B),
		Fend:   int32(0x11946),
	},
	421: {
		Fstart: int32(0x11950),
		Fend:   int32(0x11959),
	},
	422: {
		Fstart: int32(0x119A0),
		Fend:   int32(0x119A7),
	},
	423: {
		Fstart: int32(0x119AA),
		Fend:   int32(0x119D7),
	},
	424: {
		Fstart: int32(0x119DA),
		Fend:   int32(0x119E4),
	},
	425: {
		Fstart: int32(0x11A00),
		Fend:   int32(0x11A47),
	},
	426: {
		Fstart: int32(0x11A50),
		Fend:   int32(0x11AA2),
	},
	427: {
		Fstart: int32(0x11AB0),
		Fend:   int32(0x11AF8),
	},
	428: {
		Fstart: int32(0x11B00),
		Fend:   int32(0x11B09),
	},
	429: {
		Fstart: int32(0x11BC0),
		Fend:   int32(0x11BE1),
	},
	430: {
		Fstart: int32(0x11BF0),
		Fend:   int32(0x11BF9),
	},
	431: {
		Fstart: int32(0x11C00),
		Fend:   int32(0x11C08),
	},
	432: {
		Fstart: int32(0x11C0A),
		Fend:   int32(0x11C36),
	},
	433: {
		Fstart: int32(0x11C38),
		Fend:   int32(0x11C45),
	},
	434: {
		Fstart: int32(0x11C50),
		Fend:   int32(0x11C6C),
	},
	435: {
		Fstart: int32(0x11C70),
		Fend:   int32(0x11C8F),
	},
	436: {
		Fstart: int32(0x11C92),
		Fend:   int32(0x11CA7),
	},
	437: {
		Fstart: int32(0x11CA9),
		Fend:   int32(0x11CB6),
	},
	438: {
		Fstart: int32(0x11D00),
		Fend:   int32(0x11D06),
	},
	439: {
		Fstart: int32(0x11D0B),
		Fend:   int32(0x11D36),
	},
	440: {
		Fstart: int32(0x11D3F),
		Fend:   int32(0x11D47),
	},
	441: {
		Fstart: int32(0x11D50),
		Fend:   int32(0x11D59),
	},
	442: {
		Fstart: int32(0x11D60),
		Fend:   int32(0x11D65),
	},
	443: {
		Fstart: int32(0x11D6A),
		Fend:   int32(0x11D8E),
	},
	444: {
		Fstart: int32(0x11D93),
		Fend:   int32(0x11D98),
	},
	445: {
		Fstart: int32(0x11DA0),
		Fend:   int32(0x11DA9),
	},
	446: {
		Fstart: int32(0x11EE0),
		Fend:   int32(0x11EF8),
	},
	447: {
		Fstart: int32(0x11F00),
		Fend:   int32(0x11F10),
	},
	448: {
		Fstart: int32(0x11F12),
		Fend:   int32(0x11F3A),
	},
	449: {
		Fstart: int32(0x11F3E),
		Fend:   int32(0x11F5A),
	},
	450: {
		Fstart: int32(0x11FC0),
		Fend:   int32(0x11FF1),
	},
	451: {
		Fstart: int32(0x11FFF),
		Fend:   int32(0x12399),
	},
	452: {
		Fstart: int32(0x12400),
		Fend:   int32(0x1246E),
	},
	453: {
		Fstart: int32(0x12470),
		Fend:   int32(0x12474),
	},
	454: {
		Fstart: int32(0x12480),
		Fend:   int32(0x12543),
	},
	455: {
		Fstart: int32(0x12F90),
		Fend:   int32(0x12FF2),
	},
	456: {
		Fstart: int32(0x13000),
		Fend:   int32(0x1342F),
	},
	457: {
		Fstart: int32(0x13440),
		Fend:   int32(0x13455),
	},
	458: {
		Fstart: int32(0x13460),
		Fend:   int32(0x143FA),
	},
	459: {
		Fstart: int32(0x14400),
		Fend:   int32(0x14646),
	},
	460: {
		Fstart: int32(0x16100),
		Fend:   int32(0x16139),
	},
	461: {
		Fstart: int32(0x16800),
		Fend:   int32(0x16A38),
	},
	462: {
		Fstart: int32(0x16A40),
		Fend:   int32(0x16A5E),
	},
	463: {
		Fstart: int32(0x16A60),
		Fend:   int32(0x16A69),
	},
	464: {
		Fstart: int32(0x16A6E),
		Fend:   int32(0x16ABE),
	},
	465: {
		Fstart: int32(0x16AC0),
		Fend:   int32(0x16AC9),
	},
	466: {
		Fstart: int32(0x16AD0),
		Fend:   int32(0x16AED),
	},
	467: {
		Fstart: int32(0x16AF0),
		Fend:   int32(0x16AF5),
	},
	468: {
		Fstart: int32(0x16B00),
		Fend:   int32(0x16B45),
	},
	469: {
		Fstart: int32(0x16B50),
		Fend:   int32(0x16B59),
	},
	470: {
		Fstart: int32(0x16B5B),
		Fend:   int32(0x16B61),
	},
	471: {
		Fstart: int32(0x16B63),
		Fend:   int32(0x16B77),
	},
	472: {
		Fstart: int32(0x16B7D),
		Fend:   int32(0x16B8F),
	},
	473: {
		Fstart: int32(0x16D40),
		Fend:   int32(0x16D79),
	},
	474: {
		Fstart: int32(0x16E40),
		Fend:   int32(0x16E9A),
	},
	475: {
		Fstart: int32(0x16F00),
		Fend:   int32(0x16F4A),
	},
	476: {
		Fstart: int32(0x16F4F),
		Fend:   int32(0x16F87),
	},
	477: {
		Fstart: int32(0x16F8F),
		Fend:   int32(0x16F9F),
	},
	478: {
		Fstart: int32(0x16FE0),
		Fend:   int32(0x16FE4),
	},
	479: {
		Fstart: int32(0x17000),
		Fend:   int32(0x187F7),
	},
	480: {
		Fstart: int32(0x18800),
		Fend:   int32(0x18CD5),
	},
	481: {
		Fstart: int32(0x18CFF),
		Fend:   int32(0x18D08),
	},
	482: {
		Fstart: int32(0x1AFF0),
		Fend:   int32(0x1AFF3),
	},
	483: {
		Fstart: int32(0x1AFF5),
		Fend:   int32(0x1AFFB),
	},
	484: {
		Fstart: int32(0x1B000),
		Fend:   int32(0x1B122),
	},
	485: {
		Fstart: int32(0x1B150),
		Fend:   int32(0x1B152),
	},
	486: {
		Fstart: int32(0x1B164),
		Fend:   int32(0x1B167),
	},
	487: {
		Fstart: int32(0x1B170),
		Fend:   int32(0x1B2FB),
	},
	488: {
		Fstart: int32(0x1BC00),
		Fend:   int32(0x1BC6A),
	},
	489: {
		Fstart: int32(0x1BC70),
		Fend:   int32(0x1BC7C),
	},
	490: {
		Fstart: int32(0x1BC80),
		Fend:   int32(0x1BC88),
	},
	491: {
		Fstart: int32(0x1BC90),
		Fend:   int32(0x1BC99),
	},
	492: {
		Fstart: int32(0x1BC9C),
		Fend:   int32(0x1BC9F),
	},
	493: {
		Fstart: int32(0x1CC00),
		Fend:   int32(0x1CCF9),
	},
	494: {
		Fstart: int32(0x1CD00),
		Fend:   int32(0x1CEB3),
	},
	495: {
		Fstart: int32(0x1CF00),
		Fend:   int32(0x1CF2D),
	},
	496: {
		Fstart: int32(0x1CF30),
		Fend:   int32(0x1CF46),
	},
	497: {
		Fstart: int32(0x1CF50),
		Fend:   int32(0x1CFC3),
	},
	498: {
		Fstart: int32(0x1D000),
		Fend:   int32(0x1D0F5),
	},
	499: {
		Fstart: int32(0x1D100),
		Fend:   int32(0x1D126),
	},
	500: {
		Fstart: int32(0x1D129),
		Fend:   int32(0x1D172),
	},
	501: {
		Fstart: int32(0x1D17B),
		Fend:   int32(0x1D1EA),
	},
	502: {
		Fstart: int32(0x1D200),
		Fend:   int32(0x1D245),
	},
	503: {
		Fstart: int32(0x1D2C0),
		Fend:   int32(0x1D2D3),
	},
	504: {
		Fstart: int32(0x1D2E0),
		Fend:   int32(0x1D2F3),
	},
	505: {
		Fstart: int32(0x1D300),
		Fend:   int32(0x1D356),
	},
	506: {
		Fstart: int32(0x1D360),
		Fend:   int32(0x1D378),
	},
	507: {
		Fstart: int32(0x1D400),
		Fend:   int32(0x1D454),
	},
	508: {
		Fstart: int32(0x1D456),
		Fend:   int32(0x1D49C),
	},
	509: {
		Fstart: int32(0x1D4A9),
		Fend:   int32(0x1D4AC),
	},
	510: {
		Fstart: int32(0x1D4AE),
		Fend:   int32(0x1D4B9),
	},
	511: {
		Fstart: int32(0x1D4BD),
		Fend:   int32(0x1D4C3),
	},
	512: {
		Fstart: int32(0x1D4C5),
		Fend:   int32(0x1D505),
	},
	513: {
		Fstart: int32(0x1D507),
		Fend:   int32(0x1D50A),
	},
	514: {
		Fstart: int32(0x1D50D),
		Fend:   int32(0x1D514),
	},
	515: {
		Fstart: int32(0x1D516),
		Fend:   int32(0x1D51C),
	},
	516: {
		Fstart: int32(0x1D51E),
		Fend:   int32(0x1D539),
	},
	517: {
		Fstart: int32(0x1D53B),
		Fend:   int32(0x1D53E),
	},
	518: {
		Fstart: int32(0x1D540),
		Fend:   int32(0x1D544),
	},
	519: {
		Fstart: int32(0x1D54A),
		Fend:   int32(0x1D550),
	},
	520: {
		Fstart: int32(0x1D552),
		Fend:   int32(0x1D6A5),
	},
	521: {
		Fstart: int32(0x1D6A8),
		Fend:   int32(0x1D7CB),
	},
	522: {
		Fstart: int32(0x1D7CE),
		Fend:   int32(0x1DA8B),
	},
	523: {
		Fstart: int32(0x1DA9B),
		Fend:   int32(0x1DA9F),
	},
	524: {
		Fstart: int32(0x1DAA1),
		Fend:   int32(0x1DAAF),
	},
	525: {
		Fstart: int32(0x1DF00),
		Fend:   int32(0x1DF1E),
	},
	526: {
		Fstart: int32(0x1DF25),
		Fend:   int32(0x1DF2A),
	},
	527: {
		Fstart: int32(0x1E000),
		Fend:   int32(0x1E006),
	},
	528: {
		Fstart: int32(0x1E008),
		Fend:   int32(0x1E018),
	},
	529: {
		Fstart: int32(0x1E01B),
		Fend:   int32(0x1E021),
	},
	530: {
		Fstart: int32(0x1E026),
		Fend:   int32(0x1E02A),
	},
	531: {
		Fstart: int32(0x1E030),
		Fend:   int32(0x1E06D),
	},
	532: {
		Fstart: int32(0x1E100),
		Fend:   int32(0x1E12C),
	},
	533: {
		Fstart: int32(0x1E130),
		Fend:   int32(0x1E13D),
	},
	534: {
		Fstart: int32(0x1E140),
		Fend:   int32(0x1E149),
	},
	535: {
		Fstart: int32(0x1E290),
		Fend:   int32(0x1E2AE),
	},
	536: {
		Fstart: int32(0x1E2C0),
		Fend:   int32(0x1E2F9),
	},
	537: {
		Fstart: int32(0x1E4D0),
		Fend:   int32(0x1E4F9),
	},
	538: {
		Fstart: int32(0x1E5D0),
		Fend:   int32(0x1E5FA),
	},
	539: {
		Fstart: int32(0x1E7E0),
		Fend:   int32(0x1E7E6),
	},
	540: {
		Fstart: int32(0x1E7E8),
		Fend:   int32(0x1E7EB),
	},
	541: {
		Fstart: int32(0x1E7F0),
		Fend:   int32(0x1E7FE),
	},
	542: {
		Fstart: int32(0x1E800),
		Fend:   int32(0x1E8C4),
	},
	543: {
		Fstart: int32(0x1E8C7),
		Fend:   int32(0x1E8D6),
	},
	544: {
		Fstart: int32(0x1E900),
		Fend:   int32(0x1E94B),
	},
	545: {
		Fstart: int32(0x1E950),
		Fend:   int32(0x1E959),
	},
	546: {
		Fstart: int32(0x1EC71),
		Fend:   int32(0x1ECB4),
	},
	547: {
		Fstart: int32(0x1ED01),
		Fend:   int32(0x1ED3D),
	},
	548: {
		Fstart: int32(0x1EE00),
		Fend:   int32(0x1EE03),
	},
	549: {
		Fstart: int32(0x1EE05),
		Fend:   int32(0x1EE1F),
	},
	550: {
		Fstart: int32(0x1EE29),
		Fend:   int32(0x1EE32),
	},
	551: {
		Fstart: int32(0x1EE34),
		Fend:   int32(0x1EE37),
	},
	552: {
		Fstart: int32(0x1EE4D),
		Fend:   int32(0x1EE4F),
	},
	553: {
		Fstart: int32(0x1EE67),
		Fend:   int32(0x1EE6A),
	},
	554: {
		Fstart: int32(0x1EE6C),
		Fend:   int32(0x1EE72),
	},
	555: {
		Fstart: int32(0x1EE74),
		Fend:   int32(0x1EE77),
	},
	556: {
		Fstart: int32(0x1EE79),
		Fend:   int32(0x1EE7C),
	},
	557: {
		Fstart: int32(0x1EE80),
		Fend:   int32(0x1EE89),
	},
	558: {
		Fstart: int32(0x1EE8B),
		Fend:   int32(0x1EE9B),
	},
	559: {
		Fstart: int32(0x1EEA1),
		Fend:   int32(0x1EEA3),
	},
	560: {
		Fstart: int32(0x1EEA5),
		Fend:   int32(0x1EEA9),
	},
	561: {
		Fstart: int32(0x1EEAB),
		Fend:   int32(0x1EEBB),
	},
	562: {
		Fstart: int32(0x1F000),
		Fend:   int32(0x1F02B),
	},
	563: {
		Fstart: int32(0x1F030),
		Fend:   int32(0x1F093),
	},
	564: {
		Fstart: int32(0x1F0A0),
		Fend:   int32(0x1F0AE),
	},
	565: {
		Fstart: int32(0x1F0B1),
		Fend:   int32(0x1F0BF),
	},
	566: {
		Fstart: int32(0x1F0C1),
		Fend:   int32(0x1F0CF),
	},
	567: {
		Fstart: int32(0x1F0D1),
		Fend:   int32(0x1F0F5),
	},
	568: {
		Fstart: int32(0x1F100),
		Fend:   int32(0x1F1AD),
	},
	569: {
		Fstart: int32(0x1F1E6),
		Fend:   int32(0x1F202),
	},
	570: {
		Fstart: int32(0x1F210),
		Fend:   int32(0x1F23B),
	},
	571: {
		Fstart: int32(0x1F240),
		Fend:   int32(0x1F248),
	},
	572: {
		Fstart: int32(0x1F260),
		Fend:   int32(0x1F265),
	},
	573: {
		Fstart: int32(0x1F300),
		Fend:   int32(0x1F6D7),
	},
	574: {
		Fstart: int32(0x1F6DC),
		Fend:   int32(0x1F6EC),
	},
	575: {
		Fstart: int32(0x1F6F0),
		Fend:   int32(0x1F6FC),
	},
	576: {
		Fstart: int32(0x1F700),
		Fend:   int32(0x1F776),
	},
	577: {
		Fstart: int32(0x1F77B),
		Fend:   int32(0x1F7D9),
	},
	578: {
		Fstart: int32(0x1F7E0),
		Fend:   int32(0x1F7EB),
	},
	579: {
		Fstart: int32(0x1F800),
		Fend:   int32(0x1F80B),
	},
	580: {
		Fstart: int32(0x1F810),
		Fend:   int32(0x1F847),
	},
	581: {
		Fstart: int32(0x1F850),
		Fend:   int32(0x1F859),
	},
	582: {
		Fstart: int32(0x1F860),
		Fend:   int32(0x1F887),
	},
	583: {
		Fstart: int32(0x1F890),
		Fend:   int32(0x1F8AD),
	},
	584: {
		Fstart: int32(0x1F8B0),
		Fend:   int32(0x1F8BB),
	},
	585: {
		Fstart: int32(0x1F900),
		Fend:   int32(0x1FA53),
	},
	586: {
		Fstart: int32(0x1FA60),
		Fend:   int32(0x1FA6D),
	},
	587: {
		Fstart: int32(0x1FA70),
		Fend:   int32(0x1FA7C),
	},
	588: {
		Fstart: int32(0x1FA80),
		Fend:   int32(0x1FA89),
	},
	589: {
		Fstart: int32(0x1FA8F),
		Fend:   int32(0x1FAC6),
	},
	590: {
		Fstart: int32(0x1FACE),
		Fend:   int32(0x1FADC),
	},
	591: {
		Fstart: int32(0x1FADF),
		Fend:   int32(0x1FAE9),
	},
	592: {
		Fstart: int32(0x1FAF0),
		Fend:   int32(0x1FAF8),
	},
	593: {
		Fstart: int32(0x1FB00),
		Fend:   int32(0x1FB92),
	},
	594: {
		Fstart: int32(0x1FB94),
		Fend:   int32(0x1FBF9),
	},
	595: {
		Fstart: int32(0x20000),
		Fend:   int32(0x2A6DF),
	},
	596: {
		Fstart: int32(0x2A700),
		Fend:   int32(0x2B739),
	},
	597: {
		Fstart: int32(0x2B740),
		Fend:   int32(0x2B81D),
	},
	598: {
		Fstart: int32(0x2B820),
		Fend:   int32(0x2CEA1),
	},
	599: {
		Fstart: int32(0x2CEB0),
		Fend:   int32(0x2EBE0),
	},
	600: {
		Fstart: int32(0x2EBF0),
		Fend:   int32(0x2EE5D),
	},
	601: {
		Fstart: int32(0x2F800),
		Fend:   int32(0x2FA1D),
	},
	602: {
		Fstart: int32(0x30000),
		Fend:   int32(0x3134A),
	},
	603: {
		Fstart: int32(0x31350),
		Fend:   int32(0x323AF),
	},
	604: {
		Fstart: int32(0xE0100),
		Fend:   int32(0xE01EF),
	},
}

var _graphCharTable = [192]Tchr{
	0:   int32(0x38C),
	1:   int32(0x85E),
	2:   int32(0x98F),
	3:   int32(0x990),
	4:   int32(0x9B2),
	5:   int32(0x9C7),
	6:   int32(0x9C8),
	7:   int32(0x9D7),
	8:   int32(0x9DC),
	9:   int32(0x9DD),
	10:  int32(0xA0F),
	11:  int32(0xA10),
	12:  int32(0xA32),
	13:  int32(0xA33),
	14:  int32(0xA35),
	15:  int32(0xA36),
	16:  int32(0xA38),
	17:  int32(0xA39),
	18:  int32(0xA3C),
	19:  int32(0xA47),
	20:  int32(0xA48),
	21:  int32(0xA51),
	22:  int32(0xA5E),
	23:  int32(0xAB2),
	24:  int32(0xAB3),
	25:  int32(0xAD0),
	26:  int32(0xB0F),
	27:  int32(0xB10),
	28:  int32(0xB32),
	29:  int32(0xB33),
	30:  int32(0xB47),
	31:  int32(0xB48),
	32:  int32(0xB5C),
	33:  int32(0xB5D),
	34:  int32(0xB82),
	35:  int32(0xB83),
	36:  int32(0xB99),
	37:  int32(0xB9A),
	38:  int32(0xB9C),
	39:  int32(0xB9E),
	40:  int32(0xB9F),
	41:  int32(0xBA3),
	42:  int32(0xBA4),
	43:  int32(0xBD0),
	44:  int32(0xBD7),
	45:  int32(0xC55),
	46:  int32(0xC56),
	47:  int32(0xC5D),
	48:  int32(0xCD5),
	49:  int32(0xCD6),
	50:  int32(0xCDD),
	51:  int32(0xCDE),
	52:  int32(0xDBD),
	53:  int32(0xDCA),
	54:  int32(0xDD6),
	55:  int32(0xE81),
	56:  int32(0xE82),
	57:  int32(0xE84),
	58:  int32(0xEA5),
	59:  int32(0xEC6),
	60:  int32(0x10C7),
	61:  int32(0x10CD),
	62:  int32(0x1258),
	63:  int32(0x12C0),
	64:  int32(0x1772),
	65:  int32(0x1773),
	66:  int32(0x1940),
	67:  int32(0x1F59),
	68:  int32(0x1F5B),
	69:  int32(0x1F5D),
	70:  int32(0x2070),
	71:  int32(0x2071),
	72:  int32(0x2D27),
	73:  int32(0x2D2D),
	74:  int32(0x2D6F),
	75:  int32(0x2D70),
	76:  int32(0xA7D0),
	77:  int32(0xA7D1),
	78:  int32(0xA7D3),
	79:  int32(0xFB3E),
	80:  int32(0xFB40),
	81:  int32(0xFB41),
	82:  int32(0xFB43),
	83:  int32(0xFB44),
	84:  int32(0xFDCF),
	85:  int32(0xFFFC),
	86:  int32(0xFFFD),
	87:  int32(0x1003C),
	88:  int32(0x1003D),
	89:  int32(0x101A0),
	90:  int32(0x10594),
	91:  int32(0x10595),
	92:  int32(0x105BB),
	93:  int32(0x105BC),
	94:  int32(0x10808),
	95:  int32(0x10837),
	96:  int32(0x10838),
	97:  int32(0x1083C),
	98:  int32(0x108F4),
	99:  int32(0x108F5),
	100: int32(0x1093F),
	101: int32(0x10A05),
	102: int32(0x10A06),
	103: int32(0x10D8E),
	104: int32(0x10D8F),
	105: int32(0x10EB0),
	106: int32(0x10EB1),
	107: int32(0x11288),
	108: int32(0x1130F),
	109: int32(0x11310),
	110: int32(0x11332),
	111: int32(0x11333),
	112: int32(0x11347),
	113: int32(0x11348),
	114: int32(0x11350),
	115: int32(0x11357),
	116: int32(0x1138B),
	117: int32(0x1138E),
	118: int32(0x113C2),
	119: int32(0x113C5),
	120: int32(0x113D7),
	121: int32(0x113D8),
	122: int32(0x113E1),
	123: int32(0x113E2),
	124: int32(0x11909),
	125: int32(0x11915),
	126: int32(0x11916),
	127: int32(0x11937),
	128: int32(0x11938),
	129: int32(0x11D08),
	130: int32(0x11D09),
	131: int32(0x11D3A),
	132: int32(0x11D3C),
	133: int32(0x11D3D),
	134: int32(0x11D67),
	135: int32(0x11D68),
	136: int32(0x11D90),
	137: int32(0x11D91),
	138: int32(0x11FB0),
	139: int32(0x16FF0),
	140: int32(0x16FF1),
	141: int32(0x1AFFD),
	142: int32(0x1AFFE),
	143: int32(0x1B132),
	144: int32(0x1B155),
	145: int32(0x1D49E),
	146: int32(0x1D49F),
	147: int32(0x1D4A2),
	148: int32(0x1D4A5),
	149: int32(0x1D4A6),
	150: int32(0x1D4BB),
	151: int32(0x1D546),
	152: int32(0x1E023),
	153: int32(0x1E024),
	154: int32(0x1E08F),
	155: int32(0x1E14E),
	156: int32(0x1E14F),
	157: int32(0x1E2FF),
	158: int32(0x1E5FF),
	159: int32(0x1E7ED),
	160: int32(0x1E7EE),
	161: int32(0x1E95E),
	162: int32(0x1E95F),
	163: int32(0x1EE21),
	164: int32(0x1EE22),
	165: int32(0x1EE24),
	166: int32(0x1EE27),
	167: int32(0x1EE39),
	168: int32(0x1EE3B),
	169: int32(0x1EE42),
	170: int32(0x1EE47),
	171: int32(0x1EE49),
	172: int32(0x1EE4B),
	173: int32(0x1EE51),
	174: int32(0x1EE52),
	175: int32(0x1EE54),
	176: int32(0x1EE57),
	177: int32(0x1EE59),
	178: int32(0x1EE5B),
	179: int32(0x1EE5D),
	180: int32(0x1EE5F),
	181: int32(0x1EE61),
	182: int32(0x1EE62),
	183: int32(0x1EE64),
	184: int32(0x1EE7E),
	185: int32(0x1EEF0),
	186: int32(0x1EEF1),
	187: int32(0x1F250),
	188: int32(0x1F251),
	189: int32(0x1F7F0),
	190: int32(0x1F8C0),
	191: int32(0x1F8C1),
}

/*
 *	End of auto-generated Unicode character ranges declarations.
 */

// C documentation
//
//	/*
//	 - element - map collating-element name to celt
//	 ^ static celt element(struct vars *, const chr *, const chr *);
//	 */
func _element(tls *libc.TLS, v uintptr, startp uintptr, endp uintptr) (r Tcelt) {
	bp := tls.Alloc(224)
	defer tls.Free(224) /* points just past end of name */
	var cn, np uintptr
	var len1 Tsize_t
	var v2 int32
	var _ /* ds at bp+0 */ TTcl_DString
	_, _, _, _ = cn, len1, np, v2
	/*
	 * Generic: one-chr names stand for themselves.
	 */
	len1 = libc.Uint64FromInt64((int64(endp) - int64(startp)) / 4)
	if len1 == uint64(1) {
		return *(*Tchr)(unsafe.Pointer(startp))
	}
	*(*int64)(unsafe.Pointer((*Tvars)(unsafe.Pointer(v)).Fre + 8)) |= int64(libc.Int32FromInt32(REG_ULOCALE))
	/*
	 * Search table.
	 */
	XTcl_DStringInit(tls, bp)
	np = XTcl_UniCharToUtfDString(tls, startp, libc.Int64FromUint64(len1), bp)
	cn = uintptr(unsafe.Pointer(&_cnames))
	for {
		if !((*Tcname)(unsafe.Pointer(cn)).Fname != libc.UintptrFromInt32(0)) {
			break
		}
		if libc.Xstrlen(tls, (*Tcname)(unsafe.Pointer(cn)).Fname) == len1 && libc.Xstrncmp(tls, (*Tcname)(unsafe.Pointer(cn)).Fname, np, len1) == 0 {
			break /* NOTE BREAK OUT */
		}
		goto _1
	_1:
		;
		cn += 16
	}
	XTcl_DStringFree(tls, bp)
	if (*Tcname)(unsafe.Pointer(cn)).Fname != libc.UintptrFromInt32(0) {
		return libc.Int32FromUint8((*Tcname)(unsafe.Pointer(cn)).Fcode)
	}
	/*
	 * Couldn't find it.
	 */
	(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		v2 = (*Tvars)(unsafe.Pointer(v)).Ferr
	} else {
		v2 = int32(REG_ECOLLATE)
	}
	(*Tvars)(unsafe.Pointer(v)).Ferr = v2
	return 0
}

// C documentation
//
//	/*
//	 - range - supply cvec for a range, including legality check
//	 ^ static struct cvec *range(struct vars *, celt, celt, int);
//	 */
func _range(tls *libc.TLS, v uintptr, a Tcelt, b Tcelt, cases int32) (r uintptr) {
	/* case-independent? */
	var c, lc, tc, uc Tcelt
	var cv uintptr
	var nchrs, v1 int32
	_, _, _, _, _, _, _ = c, cv, lc, nchrs, tc, uc, v1
	if a != b && !(_before(tls, a, b) != 0) {
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			v1 = (*Tvars)(unsafe.Pointer(v)).Ferr
		} else {
			v1 = int32(REG_ERANGE)
		}
		(*Tvars)(unsafe.Pointer(v)).Ferr = v1
		return libc.UintptrFromInt32(0)
	}
	if !(cases != 0) { /* easy version */
		cv = _getcvec(tls, v, uint64(0), uint64(1))
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			return libc.UintptrFromInt32(0)
		}
		_addrange(tls, cv, a, b)
		return cv
	}
	/*
	 * When case-independent, it's hard to decide when cvec ranges are usable,
	 * so for now at least, we won't try. We allocate enough space for two
	 * case variants plus a little extra for the two title case variants.
	 */
	nchrs = (b-a+int32(1))*int32(2) + int32(4)
	cv = _getcvec(tls, v, libc.Uint64FromInt32(nchrs), uint64(0))
	if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
		return libc.UintptrFromInt32(0)
	}
	c = a
	for {
		if !(c <= b) {
			break
		}
		_addchr(tls, cv, c)
		lc = XTcl_UniCharToLower(tls, c)
		uc = XTcl_UniCharToUpper(tls, c)
		tc = XTcl_UniCharToTitle(tls, c)
		if c != lc {
			_addchr(tls, cv, lc)
		}
		if c != uc {
			_addchr(tls, cv, uc)
		}
		if c != tc && tc != uc {
			_addchr(tls, cv, tc)
		}
		goto _2
	_2:
		;
		c++
	}
	return cv
}

// C documentation
//
//	/*
//	 - before - is celt x before celt y, for purposes of range legality?
//	 ^ static int before(celt, celt);
//	 */
func _before(tls *libc.TLS, x Tcelt, y Tcelt) (r int32) {
	/* collating elements */
	if x < y {
		return int32(1)
	}
	return 0
}

// C documentation
//
//	/*
//	 - eclass - supply cvec for an equivalence class
//	 * Must include case counterparts on request.
//	 ^ static struct cvec *eclass(struct vars *, celt, int);
//	 */
func _eclass(tls *libc.TLS, v uintptr, c Tcelt, cases int32) (r uintptr) {
	/* all cases? */
	var cv uintptr
	_ = cv
	/*
	 * Crude fake equivalence class for testing.
	 */
	if (*Tvars)(unsafe.Pointer(v)).Fcflags&int32(REG_FAKE) != 0 && c == int32('x') {
		cv = _getcvec(tls, v, uint64(4), uint64(0))
		_addchr(tls, cv, int32('x'))
		_addchr(tls, cv, int32('y'))
		if cases != 0 {
			_addchr(tls, cv, int32('X'))
			_addchr(tls, cv, int32('Y'))
		}
		return cv
	}
	/*
	 * Otherwise, none.
	 */
	if cases != 0 {
		return _allcases(tls, v, c)
	}
	cv = _getcvec(tls, v, uint64(1), uint64(0))
	_addchr(tls, cv, c)
	return cv
}

// C documentation
//
//	/*
//	 - cclass - supply cvec for a character class
//	 * Must include case counterparts on request.
//	 ^ static struct cvec *cclass(struct vars *, const chr *, const chr *, int);
//	 */
func _cclass(tls *libc.TLS, v uintptr, startp uintptr, endp uintptr, cases int32) (r uintptr) {
	bp := tls.Alloc(224)
	defer tls.Free(224) /* case-independent? */
	var cv, namePtr, np uintptr
	var i, index, v2, v25 int32
	var len1 Tsize_t
	var _ /* ds at bp+0 */ TTcl_DString
	_, _, _, _, _, _, _, _ = cv, i, index, len1, namePtr, np, v2, v25
	cv = libc.UintptrFromInt32(0)
	/*
	 * Extract the class name
	 */
	len1 = libc.Uint64FromInt64((int64(endp) - int64(startp)) / 4)
	XTcl_DStringInit(tls, bp)
	np = XTcl_UniCharToUtfDString(tls, startp, libc.Int64FromUint64(len1), bp)
	/*
	 * Map the name to the corresponding enumerated value.
	 */
	index = -1
	namePtr = uintptr(unsafe.Pointer(&_classNames))
	i = libc.Int32FromInt32(0)
	for {
		if !(*(*uintptr)(unsafe.Pointer(namePtr)) != libc.UintptrFromInt32(0)) {
			break
		}
		if libc.Xstrlen(tls, *(*uintptr)(unsafe.Pointer(namePtr))) == len1 && libc.Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(namePtr)), np, len1) == 0 {
			index = i
			break
		}
		goto _1
	_1:
		;
		namePtr += 8
		i++
	}
	XTcl_DStringFree(tls, bp)
	/*
	 * Remap lower and upper to alpha if the match is case insensitive.
	 */
	if cases != 0 && (index == 7 || index == 11) {
		index = 0
	}
	/*
	 * Now compute the character class contents.
	 */
	switch index {
	case -1:
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			v2 = (*Tvars)(unsafe.Pointer(v)).Ferr
		} else {
			v2 = int32(REG_ECTYPE)
		}
		(*Tvars)(unsafe.Pointer(v)).Ferr = v2
		return libc.UintptrFromInt32(0)
	case 0:
		cv = _getcvec(tls, v, libc.Uint64FromInt32(libc.Int32FromUint64(libc.Uint64FromInt64(1076)/libc.Uint64FromInt64(4))), libc.Uint64FromInt32(libc.Int32FromUint64(libc.Uint64FromInt64(568)/libc.Uint64FromInt64(8))+libc.Int32FromUint64(libc.Uint64FromInt64(3768)/libc.Uint64FromInt64(8))))
		if cv != 0 {
			i = 0
			for {
				if !(i < libc.Int32FromUint64(libc.Uint64FromInt64(1076)/libc.Uint64FromInt64(4))) {
					break
				}
				_addchr(tls, cv, _alphaCharTable[i])
				goto _3
			_3:
				;
				i++
			}
			i = 0
			for {
				if !(i < libc.Int32FromUint64(libc.Uint64FromInt64(3768)/libc.Uint64FromInt64(8))) {
					break
				}
				_addrange(tls, cv, _alphaRangeTable[i].Fstart, _alphaRangeTable[i].Fend)
				goto _4
			_4:
				;
				i++
			}
			i = 0
			for {
				if !(i < libc.Int32FromUint64(libc.Uint64FromInt64(568)/libc.Uint64FromInt64(8))) {
					break
				}
				_addrange(tls, cv, _digitRangeTable[i].Fstart, _digitRangeTable[i].Fend)
				goto _5
			_5:
				;
				i++
			}
		}
	case 1:
		cv = _getcvec(tls, v, libc.Uint64FromInt32(libc.Int32FromUint64(libc.Uint64FromInt64(1076)/libc.Uint64FromInt64(4))), libc.Uint64FromInt32(libc.Int32FromUint64(libc.Uint64FromInt64(3768)/libc.Uint64FromInt64(8))))
		if cv != 0 {
			i = 0
			for {
				if !(i < libc.Int32FromUint64(libc.Uint64FromInt64(3768)/libc.Uint64FromInt64(8))) {
					break
				}
				_addrange(tls, cv, _alphaRangeTable[i].Fstart, _alphaRangeTable[i].Fend)
				goto _6
			_6:
				;
				i++
			}
			i = 0
			for {
				if !(i < libc.Int32FromUint64(libc.Uint64FromInt64(1076)/libc.Uint64FromInt64(4))) {
					break
				}
				_addchr(tls, cv, _alphaCharTable[i])
				goto _7
			_7:
				;
				i++
			}
		}
	case 2:
		cv = _getcvec(tls, v, uint64(0), uint64(1))
		if cv != 0 {
			_addrange(tls, cv, 0, int32(0x7F))
		}
	case 3:
		cv = _getcvec(tls, v, uint64(2), uint64(0))
		_addchr(tls, cv, int32('\t'))
		_addchr(tls, cv, int32(' '))
	case 4:
		cv = _getcvec(tls, v, libc.Uint64FromInt32(libc.Int32FromUint64(libc.Uint64FromInt64(48)/libc.Uint64FromInt64(4))), libc.Uint64FromInt32(libc.Int32FromUint64(libc.Uint64FromInt64(96)/libc.Uint64FromInt64(8))))
		if cv != 0 {
			i = 0
			for {
				if !(i < libc.Int32FromUint64(libc.Uint64FromInt64(96)/libc.Uint64FromInt64(8))) {
					break
				}
				_addrange(tls, cv, _controlRangeTable[i].Fstart, _controlRangeTable[i].Fend)
				goto _8
			_8:
				;
				i++
			}
			i = 0
			for {
				if !(i < libc.Int32FromUint64(libc.Uint64FromInt64(48)/libc.Uint64FromInt64(4))) {
					break
				}
				_addchr(tls, cv, _controlCharTable[i])
				goto _9
			_9:
				;
				i++
			}
		}
	case 5:
		cv = _getcvec(tls, v, uint64(0), libc.Uint64FromInt32(libc.Int32FromUint64(libc.Uint64FromInt64(568)/libc.Uint64FromInt64(8))))
		if cv != 0 {
			i = 0
			for {
				if !(i < libc.Int32FromUint64(libc.Uint64FromInt64(568)/libc.Uint64FromInt64(8))) {
					break
				}
				_addrange(tls, cv, _digitRangeTable[i].Fstart, _digitRangeTable[i].Fend)
				goto _10
			_10:
				;
				i++
			}
		}
	case 9:
		cv = _getcvec(tls, v, libc.Uint64FromInt32(libc.Int32FromUint64(libc.Uint64FromInt64(616)/libc.Uint64FromInt64(4))), libc.Uint64FromInt32(libc.Int32FromUint64(libc.Uint64FromInt64(688)/libc.Uint64FromInt64(8))))
		if cv != 0 {
			i = 0
			for {
				if !(i < libc.Int32FromUint64(libc.Uint64FromInt64(688)/libc.Uint64FromInt64(8))) {
					break
				}
				_addrange(tls, cv, _punctRangeTable[i].Fstart, _punctRangeTable[i].Fend)
				goto _11
			_11:
				;
				i++
			}
			i = 0
			for {
				if !(i < libc.Int32FromUint64(libc.Uint64FromInt64(616)/libc.Uint64FromInt64(4))) {
					break
				}
				_addchr(tls, cv, _punctCharTable[i])
				goto _12
			_12:
				;
				i++
			}
		}
	case 12:
		/*
		 * This is a 3 instead of (NUM_DIGIT_RANGE+2) because I've no idea how
		 * to define the digits 'a' through 'f' in non-western locales. The
		 * concept is quite possibly non portable, or only used in contextx
		 * where the characters used would be the western ones anyway!
		 * Whatever is actually the case, the number of ranges is fixed (until
		 * someone comes up with a better arrangement!)
		 */
		cv = _getcvec(tls, v, uint64(0), uint64(3))
		if cv != 0 {
			_addrange(tls, cv, int32('0'), int32('9'))
			_addrange(tls, cv, int32('a'), int32('f'))
			_addrange(tls, cv, int32('A'), int32('F'))
		}
	case 10:
		cv = _getcvec(tls, v, libc.Uint64FromInt32(libc.Int32FromUint64(libc.Uint64FromInt64(48)/libc.Uint64FromInt64(4))), libc.Uint64FromInt32(libc.Int32FromUint64(libc.Uint64FromInt64(16)/libc.Uint64FromInt64(8))))
		if cv != 0 {
			i = 0
			for {
				if !(i < libc.Int32FromUint64(libc.Uint64FromInt64(16)/libc.Uint64FromInt64(8))) {
					break
				}
				_addrange(tls, cv, _spaceRangeTable[i].Fstart, _spaceRangeTable[i].Fend)
				goto _13
			_13:
				;
				i++
			}
			i = 0
			for {
				if !(i < libc.Int32FromUint64(libc.Uint64FromInt64(48)/libc.Uint64FromInt64(4))) {
					break
				}
				_addchr(tls, cv, _spaceCharTable[i])
				goto _14
			_14:
				;
				i++
			}
		}
	case 7:
		cv = _getcvec(tls, v, libc.Uint64FromInt32(libc.Int32FromUint64(libc.Uint64FromInt64(2368)/libc.Uint64FromInt64(4))), libc.Uint64FromInt32(libc.Int32FromUint64(libc.Uint64FromInt64(728)/libc.Uint64FromInt64(8))))
		if cv != 0 {
			i = 0
			for {
				if !(i < libc.Int32FromUint64(libc.Uint64FromInt64(728)/libc.Uint64FromInt64(8))) {
					break
				}
				_addrange(tls, cv, _lowerRangeTable[i].Fstart, _lowerRangeTable[i].Fend)
				goto _15
			_15:
				;
				i++
			}
			i = 0
			for {
				if !(i < libc.Int32FromUint64(libc.Uint64FromInt64(2368)/libc.Uint64FromInt64(4))) {
					break
				}
				_addchr(tls, cv, _lowerCharTable[i])
				goto _16
			_16:
				;
				i++
			}
		}
	case 11:
		cv = _getcvec(tls, v, libc.Uint64FromInt32(libc.Int32FromUint64(libc.Uint64FromInt64(2388)/libc.Uint64FromInt64(4))), libc.Uint64FromInt32(libc.Int32FromUint64(libc.Uint64FromInt64(608)/libc.Uint64FromInt64(8))))
		if cv != 0 {
			i = 0
			for {
				if !(i < libc.Int32FromUint64(libc.Uint64FromInt64(608)/libc.Uint64FromInt64(8))) {
					break
				}
				_addrange(tls, cv, _upperRangeTable[i].Fstart, _upperRangeTable[i].Fend)
				goto _17
			_17:
				;
				i++
			}
			i = 0
			for {
				if !(i < libc.Int32FromUint64(libc.Uint64FromInt64(2388)/libc.Uint64FromInt64(4))) {
					break
				}
				_addchr(tls, cv, _upperCharTable[i])
				goto _18
			_18:
				;
				i++
			}
		}
	case 8:
		cv = _getcvec(tls, v, libc.Uint64FromInt32(libc.Int32FromUint64(libc.Uint64FromInt64(48)/libc.Uint64FromInt64(4))+libc.Int32FromUint64(libc.Uint64FromInt64(768)/libc.Uint64FromInt64(4))), libc.Uint64FromInt32(libc.Int32FromUint64(libc.Uint64FromInt64(16)/libc.Uint64FromInt64(8))+libc.Int32FromUint64(libc.Uint64FromInt64(4840)/libc.Uint64FromInt64(8))-libc.Int32FromInt32(1)))
		if cv != 0 {
			i = int32(1)
			for {
				if !(i < libc.Int32FromUint64(libc.Uint64FromInt64(16)/libc.Uint64FromInt64(8))) {
					break
				}
				_addrange(tls, cv, _spaceRangeTable[i].Fstart, _spaceRangeTable[i].Fend)
				goto _19
			_19:
				;
				i++
			}
			i = 0
			for {
				if !(i < libc.Int32FromUint64(libc.Uint64FromInt64(48)/libc.Uint64FromInt64(4))) {
					break
				}
				_addchr(tls, cv, _spaceCharTable[i])
				goto _20
			_20:
				;
				i++
			}
			i = 0
			for {
				if !(i < libc.Int32FromUint64(libc.Uint64FromInt64(4840)/libc.Uint64FromInt64(8))) {
					break
				}
				_addrange(tls, cv, _graphRangeTable[i].Fstart, _graphRangeTable[i].Fend)
				goto _21
			_21:
				;
				i++
			}
			i = 0
			for {
				if !(i < libc.Int32FromUint64(libc.Uint64FromInt64(768)/libc.Uint64FromInt64(4))) {
					break
				}
				_addchr(tls, cv, _graphCharTable[i])
				goto _22
			_22:
				;
				i++
			}
		}
	case 6:
		cv = _getcvec(tls, v, libc.Uint64FromInt32(libc.Int32FromUint64(libc.Uint64FromInt64(768)/libc.Uint64FromInt64(4))), libc.Uint64FromInt32(libc.Int32FromUint64(libc.Uint64FromInt64(4840)/libc.Uint64FromInt64(8))))
		if cv != 0 {
			i = 0
			for {
				if !(i < libc.Int32FromUint64(libc.Uint64FromInt64(4840)/libc.Uint64FromInt64(8))) {
					break
				}
				_addrange(tls, cv, _graphRangeTable[i].Fstart, _graphRangeTable[i].Fend)
				goto _23
			_23:
				;
				i++
			}
			i = 0
			for {
				if !(i < libc.Int32FromUint64(libc.Uint64FromInt64(768)/libc.Uint64FromInt64(4))) {
					break
				}
				_addchr(tls, cv, _graphCharTable[i])
				goto _24
			_24:
				;
				i++
			}
		}
		break
	}
	if cv == libc.UintptrFromInt32(0) {
		(*Tvars)(unsafe.Pointer(v)).Fnexttype = int32('e')
		if (*Tvars)(unsafe.Pointer(v)).Ferr != 0 {
			v25 = (*Tvars)(unsafe.Pointer(v)).Ferr
		} else {
			v25 = int32(REG_ESPACE)
		}
		(*Tvars)(unsafe.Pointer(v)).Ferr = v25
	}
	return cv
}

/*
 * The following arrays define the valid character class names.
 */

var _classNames = [14]uintptr{
	0:  __ccgo_ts + 1119,
	1:  __ccgo_ts + 1125,
	2:  __ccgo_ts + 1131,
	3:  __ccgo_ts + 1137,
	4:  __ccgo_ts + 1143,
	5:  __ccgo_ts + 1149,
	6:  __ccgo_ts + 1155,
	7:  __ccgo_ts + 1161,
	8:  __ccgo_ts + 1167,
	9:  __ccgo_ts + 1173,
	10: __ccgo_ts + 558,
	11: __ccgo_ts + 1179,
	12: __ccgo_ts + 1185,
	13: libc.UintptrFromInt32(0),
}

// C documentation
//
//	/*
//	 - allcases - supply cvec for all case counterparts of a chr (including itself)
//	 * This is a shortcut, preferably an efficient one, for simple characters;
//	 * messy cases are done via range().
//	 ^ static struct cvec *allcases(struct vars *, pchr);
//	 */
func _allcases(tls *libc.TLS, v uintptr, pc Tpchr) (r uintptr) {
	/* character to get case equivs of */
	var c, lc, tc, uc Tchr
	var cv uintptr
	_, _, _, _, _ = c, cv, lc, tc, uc
	c = pc
	lc = XTcl_UniCharToLower(tls, c)
	uc = XTcl_UniCharToUpper(tls, c)
	tc = XTcl_UniCharToTitle(tls, c)
	if tc != uc {
		cv = _getcvec(tls, v, uint64(3), uint64(0))
		_addchr(tls, cv, tc)
	} else {
		cv = _getcvec(tls, v, uint64(2), uint64(0))
	}
	_addchr(tls, cv, lc)
	if lc != uc {
		_addchr(tls, cv, uc)
	}
	return cv
}

// C documentation
//
//	/*
//	 - cmp - chr-substring compare
//	 * Backrefs need this.  It should preferably be efficient.
//	 * Note that it does not need to report anything except equal/unequal.
//	 * Note also that the length is exact, and the comparison should not
//	 * stop at embedded NULs!
//	 ^ static int cmp(const chr *, const chr *, size_t);
//	 */
func _cmp(tls *libc.TLS, x uintptr, y uintptr, len1 Tsize_t) (r int32) {
	/* exact length of comparison */
	return libc.Xmemcmp(tls, x, y, len1*uint64(4))
}

// C documentation
//
//	/*
//	 - casecmp - case-independent chr-substring compare
//	 * REG_ICASE backrefs need this.  It should preferably be efficient.
//	 * Note that it does not need to report anything except equal/unequal.
//	 * Note also that the length is exact, and the comparison should not
//	 * stop at embedded NULs!
//	 ^ static int casecmp(const chr *, const chr *, size_t);
//	 */
func _casecmp(tls *libc.TLS, x uintptr, y uintptr, len1 Tsize_t) (r int32) {
	/* exact length of comparison */
	for {
		if !(len1 > uint64(0)) {
			break
		}
		if *(*Tchr)(unsafe.Pointer(x)) != *(*Tchr)(unsafe.Pointer(y)) && XTcl_UniCharToLower(tls, *(*Tchr)(unsafe.Pointer(x))) != XTcl_UniCharToLower(tls, *(*Tchr)(unsafe.Pointer(y))) {
			return int32(1)
		}
		goto _1
	_1:
		;
		len1--
		x += 4
		y += 4
	}
	return 0
}

const FEWCOLORS = 15
const FEWSTATES = 20
const LOCALDFAS = 40
const LOCALMAT = 20
const LOCKED = 4
const NOPROGRESS = 8
const POSTSTATE = 2
const STARTER = 1
const WORK = 1

/*
 * Magic for allocating a variable workspace. This default version is
 * stack-hungry.
 */

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * Lazy-DFA representation.
 */

type Tarcp = struct {
	Fss uintptr
	Fco Tcolor
}

type Tsset = struct {
	Fstates   uintptr
	Fhash     uint32
	Fflags    int32
	Fins      Tarcp
	Flastseen uintptr
	Fouts     uintptr
	Finchain  uintptr
}

type Tdfa = struct {
	Fnssets       Tsize_t
	Fnssused      Tsize_t
	Fnstates      Tsize_t
	Fwordsper     Tsize_t
	Fncolors      int32
	Fcptsmalloced int32
	Fssets        uintptr
	Fstatesarea   uintptr
	Fwork         uintptr
	Foutsarea     uintptr
	Fincarea      uintptr
	Fcnfa         uintptr
	Fcm           uintptr
	Flastpost     uintptr
	Flastnopr     uintptr
	Fsearch       uintptr
	Fmallocarea   uintptr
}

/*
 * Setup for non-malloc allocation for small cases.
 */

type Tsmalldfa = struct {
	Fdfa        Tdfa
	Fssets      [40]Tsset
	Fstatesarea [41]uint32
	Foutsarea   [600]uintptr
	Fincarea    [600]Tarcp
}

/*
 * Internal variables, bundled for easy passing around.
 */

type Tvars1 = struct {
	Fre      uintptr
	Fg       uintptr
	Feflags  int32
	Fnmatch  Tsize_t
	Fpmatch  uintptr
	Fdetails uintptr
	Fstart   uintptr
	Fstop    uintptr
	Ferr     int32
	Fsubdfas uintptr
	Fdfa1    Tsmalldfa
	Fdfa2    Tsmalldfa
}

/* automatically gathered by fwd; do not hand-edit */
/* =====^!^===== end forwards =====^!^===== */

// C documentation
//
//	/*
//	 - exec - match regular expression
//	 ^ int exec(regex_t *, const chr *, size_t, rm_detail_t *,
//	 ^					size_t, regmatch_t [], int);
//	 */
func XTclReExec(tls *libc.TLS, re uintptr, string1 uintptr, len1 Tsize_t, details uintptr, nmatch Tsize_t, pmatch uintptr, flags int32) (r int32) {
	bp := tls.Alloc(640)
	defer tls.Free(640)
	var backref, i, n, st, v1 int32
	var v uintptr
	var v3 uint64
	var _ /* mat at bp+0 */ [20]Tregmatch_t
	var _ /* subdfas at bp+320 */ [40]uintptr
	_, _, _, _, _, _, _ = backref, i, n, st, v, v1, v3
	v = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_varsKey1)), int64(33952))
	/*
	 * Sanity checks.
	 */
	if re == libc.UintptrFromInt32(0) || string1 == libc.UintptrFromInt32(0) || (*Tregex_t)(unsafe.Pointer(re)).Fre_magic != int32(REMAGIC) {
		return int32(REG_INVARG)
	}
	/*
	 * Setup.
	 */
	(*Tvars1)(unsafe.Pointer(v)).Fre = re
	(*Tvars1)(unsafe.Pointer(v)).Fg = (*Tregex_t)(unsafe.Pointer(re)).Fre_guts
	if (*Tguts)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fg)).Fcflags&int32(REG_EXPECT) != 0 && details == libc.UintptrFromInt32(0) {
		return int32(REG_INVARG)
	}
	if (*Tguts)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fg)).Finfo&int64(REG_UIMPOSSIBLE) != 0 {
		return int32(REG_NOMATCH)
	}
	if (*Tguts)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fg)).Finfo&int64(REG_UBACKREF) != 0 {
		v1 = int32(1)
	} else {
		v1 = 0
	}
	backref = v1
	(*Tvars1)(unsafe.Pointer(v)).Feflags = flags
	if (*Tguts)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fg)).Fcflags&int32(REG_NOSUB) != 0 {
		nmatch = uint64(0) /* override client */
	}
	(*Tvars1)(unsafe.Pointer(v)).Fnmatch = nmatch
	if backref != 0 {
		/*
		 * Need work area.
		 */
		if (*Tguts)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fg)).Fnsub+uint64(1) <= uint64(LOCALMAT) {
			(*Tvars1)(unsafe.Pointer(v)).Fpmatch = bp
		} else {
			(*Tvars1)(unsafe.Pointer(v)).Fpmatch = XTclpAlloc(tls, ((*Tguts)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fg)).Fnsub+uint64(1))*uint64(16))
		}
		if (*Tvars1)(unsafe.Pointer(v)).Fpmatch == libc.UintptrFromInt32(0) {
			return int32(REG_ESPACE)
		}
		(*Tvars1)(unsafe.Pointer(v)).Fnmatch = (*Tguts)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fg)).Fnsub + uint64(1)
	} else {
		(*Tvars1)(unsafe.Pointer(v)).Fpmatch = pmatch
	}
	(*Tvars1)(unsafe.Pointer(v)).Fdetails = details
	(*Tvars1)(unsafe.Pointer(v)).Fstart = string1
	(*Tvars1)(unsafe.Pointer(v)).Fstop = string1 + uintptr(len1)*4
	(*Tvars1)(unsafe.Pointer(v)).Ferr = 0
	n = libc.Int32FromUint64((*Tguts)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fg)).Fntree)
	if n <= int32(LOCALDFAS) {
		(*Tvars1)(unsafe.Pointer(v)).Fsubdfas = bp + 320
	} else {
		(*Tvars1)(unsafe.Pointer(v)).Fsubdfas = XTclpAlloc(tls, libc.Uint64FromInt32(n)*uint64(8))
	}
	if (*Tvars1)(unsafe.Pointer(v)).Fsubdfas == libc.UintptrFromInt32(0) {
		if (*Tvars1)(unsafe.Pointer(v)).Fpmatch != pmatch && (*Tvars1)(unsafe.Pointer(v)).Fpmatch != bp {
			XTclpFree(tls, (*Tvars1)(unsafe.Pointer(v)).Fpmatch)
		}
		return int32(REG_ESPACE)
	}
	i = 0
	for {
		if !(i < n) {
			break
		}
		*(*uintptr)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fsubdfas + uintptr(i)*8)) = libc.UintptrFromInt32(0)
		goto _2
	_2:
		;
		i++
	}
	/*
	 * Do it.
	 */
	if backref != 0 {
		st = _complicatedFind(tls, v, (*Tguts)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fg)).Ftree+48, (*Tvars1)(unsafe.Pointer(v)).Fg+104)
	} else {
		st = _simpleFind(tls, v, (*Tguts)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fg)).Ftree+48, (*Tvars1)(unsafe.Pointer(v)).Fg+104)
	}
	/*
	 * Copy (portion of) match vector over if necessary.
	 */
	if st == REG_OKAY && (*Tvars1)(unsafe.Pointer(v)).Fpmatch != pmatch && nmatch > uint64(0) {
		_zapallsubs(tls, pmatch, nmatch)
		if nmatch < (*Tvars1)(unsafe.Pointer(v)).Fnmatch {
			v3 = nmatch
		} else {
			v3 = (*Tvars1)(unsafe.Pointer(v)).Fnmatch
		}
		n = libc.Int32FromUint64(v3)
		libc.Xmemcpy(tls, pmatch, (*Tvars1)(unsafe.Pointer(v)).Fpmatch, libc.Uint64FromInt32(n)*uint64(16))
	}
	/*
	 * Clean up.
	 */
	if (*Tvars1)(unsafe.Pointer(v)).Fpmatch != pmatch && (*Tvars1)(unsafe.Pointer(v)).Fpmatch != bp {
		XTclpFree(tls, (*Tvars1)(unsafe.Pointer(v)).Fpmatch)
	}
	n = libc.Int32FromUint64((*Tguts)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fg)).Fntree)
	i = 0
	for {
		if !(i < n) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fsubdfas + uintptr(i)*8)) != libc.UintptrFromInt32(0) {
			_freeDFA(tls, *(*uintptr)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fsubdfas + uintptr(i)*8)))
		}
		goto _4
	_4:
		;
		i++
	}
	if (*Tvars1)(unsafe.Pointer(v)).Fsubdfas != bp+320 {
		XTclpFree(tls, (*Tvars1)(unsafe.Pointer(v)).Fsubdfas)
	}
	return st
}

var _varsKey1 TTcl_ThreadDataKey

// C documentation
//
//	/*
//	 - getsubdfa - create or re-fetch the DFA for a subre node
//	 * We only need to create the DFA once per overall regex execution.
//	 * The DFA will be freed by the cleanup step in exec().
//	 */
func _getsubdfa(tls *libc.TLS, v uintptr, t uintptr) (r uintptr) {
	if *(*uintptr)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fsubdfas + uintptr((*Tsubre)(unsafe.Pointer(t)).Fid)*8)) == libc.UintptrFromInt32(0) {
		*(*uintptr)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fsubdfas + uintptr((*Tsubre)(unsafe.Pointer(t)).Fid)*8)) = _newDFA(tls, v, t+48, (*Tvars1)(unsafe.Pointer(v)).Fg+104, libc.UintptrFromInt32(0))
		if (*Tvars1)(unsafe.Pointer(v)).Ferr != 0 {
			return libc.UintptrFromInt32(0)
		}
	}
	return *(*uintptr)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fsubdfas + uintptr((*Tsubre)(unsafe.Pointer(t)).Fid)*8))
}

// C documentation
//
//	/*
//	 - simpleFind - find a match for the main NFA (no-complications case)
//	 ^ static int simpleFind(struct vars *, struct cnfa *, struct colormap *);
//	 */
func _simpleFind(tls *libc.TLS, v uintptr, cnfa uintptr, cm uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var begin, close1, d, end, open, s uintptr
	var shorter, v1 int32
	var _ /* cold at bp+0 */ uintptr
	var _ /* hitend at bp+8 */ int32
	_, _, _, _, _, _, _, _ = begin, close1, d, end, open, s, shorter, v1
	end = libc.UintptrFromInt32(0)
	if libc.Int32FromUint8((*Tsubre)(unsafe.Pointer((*Tguts)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fg)).Ftree)).Fflags)&int32(SHORTER) != 0 {
		v1 = int32(1)
	} else {
		v1 = 0
	}
	shorter = v1
	/*
	 * First, a shot with the search RE.
	 */
	s = _newDFA(tls, v, (*Tvars1)(unsafe.Pointer(v)).Fg+32, cm, v+80)
	if (*Tvars1)(unsafe.Pointer(v)).Ferr != 0 {
		return (*Tvars1)(unsafe.Pointer(v)).Ferr
	}
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	close1 = _shortest(tls, v, s, (*Tvars1)(unsafe.Pointer(v)).Fstart, (*Tvars1)(unsafe.Pointer(v)).Fstart, (*Tvars1)(unsafe.Pointer(v)).Fstop, bp, libc.UintptrFromInt32(0))
	_freeDFA(tls, s)
	if (*Tvars1)(unsafe.Pointer(v)).Ferr != 0 {
		return (*Tvars1)(unsafe.Pointer(v)).Ferr
	}
	if (*Tguts)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fg)).Fcflags&int32(REG_EXPECT) != 0 {
		if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
			(*Trm_detail_t)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fdetails)).Frm_extend.Frm_so = libc.Uint64FromInt64((int64(*(*uintptr)(unsafe.Pointer(bp))) - int64((*Tvars1)(unsafe.Pointer(v)).Fstart)) / 4)
		} else {
			(*Trm_detail_t)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fdetails)).Frm_extend.Frm_so = libc.Uint64FromInt64((int64((*Tvars1)(unsafe.Pointer(v)).Fstop) - int64((*Tvars1)(unsafe.Pointer(v)).Fstart)) / 4)
		}
		(*Trm_detail_t)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fdetails)).Frm_extend.Frm_eo = libc.Uint64FromInt64((int64((*Tvars1)(unsafe.Pointer(v)).Fstop) - int64((*Tvars1)(unsafe.Pointer(v)).Fstart)) / 4) /* unknown */
	}
	if close1 == libc.UintptrFromInt32(0) { /* not found */
		return int32(REG_NOMATCH)
	}
	if (*Tvars1)(unsafe.Pointer(v)).Fnmatch == uint64(0) { /* found, don't need exact location */
		return REG_OKAY
	}
	/*
	 * Find starting point and match.
	 */
	open = *(*uintptr)(unsafe.Pointer(bp))
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	d = _newDFA(tls, v, cnfa, cm, v+80)
	if (*Tvars1)(unsafe.Pointer(v)).Ferr != 0 {
		return (*Tvars1)(unsafe.Pointer(v)).Ferr
	}
	begin = open
	for {
		if !(begin <= close1) {
			break
		}
		if shorter != 0 {
			end = _shortest(tls, v, d, begin, begin, (*Tvars1)(unsafe.Pointer(v)).Fstop, libc.UintptrFromInt32(0), bp+8)
		} else {
			end = _longest(tls, v, d, begin, (*Tvars1)(unsafe.Pointer(v)).Fstop, bp+8)
		}
		if (*Tvars1)(unsafe.Pointer(v)).Ferr != 0 {
			_freeDFA(tls, d)
			return (*Tvars1)(unsafe.Pointer(v)).Ferr
		}
		if *(*int32)(unsafe.Pointer(bp + 8)) != 0 && *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
			*(*uintptr)(unsafe.Pointer(bp)) = begin
		}
		if end != libc.UintptrFromInt32(0) {
			break /* NOTE BREAK OUT */
		}
		goto _2
	_2:
		;
		begin += 4
	}
	/* search RE succeeded so loop should */
	_freeDFA(tls, d)
	/*
	 * And pin down details.
	 */
	(*(*Tregmatch_t)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fpmatch))).Frm_so = libc.Uint64FromInt64((int64(begin) - int64((*Tvars1)(unsafe.Pointer(v)).Fstart)) / 4)
	(*(*Tregmatch_t)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fpmatch))).Frm_eo = libc.Uint64FromInt64((int64(end) - int64((*Tvars1)(unsafe.Pointer(v)).Fstart)) / 4)
	if (*Tguts)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fg)).Fcflags&int32(REG_EXPECT) != 0 {
		if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
			(*Trm_detail_t)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fdetails)).Frm_extend.Frm_so = libc.Uint64FromInt64((int64(*(*uintptr)(unsafe.Pointer(bp))) - int64((*Tvars1)(unsafe.Pointer(v)).Fstart)) / 4)
		} else {
			(*Trm_detail_t)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fdetails)).Frm_extend.Frm_so = libc.Uint64FromInt64((int64((*Tvars1)(unsafe.Pointer(v)).Fstop) - int64((*Tvars1)(unsafe.Pointer(v)).Fstart)) / 4)
		}
		(*Trm_detail_t)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fdetails)).Frm_extend.Frm_eo = libc.Uint64FromInt64((int64((*Tvars1)(unsafe.Pointer(v)).Fstop) - int64((*Tvars1)(unsafe.Pointer(v)).Fstart)) / 4) /* unknown */
	}
	if (*Tvars1)(unsafe.Pointer(v)).Fnmatch == uint64(1) { /* no need for submatches */
		return REG_OKAY
	}
	/*
	 * Find submatches.
	 */
	_zapallsubs(tls, (*Tvars1)(unsafe.Pointer(v)).Fpmatch, (*Tvars1)(unsafe.Pointer(v)).Fnmatch)
	return _cdissect(tls, v, (*Tguts)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fg)).Ftree, begin, end)
}

// C documentation
//
//	/*
//	 - complicatedFind - find a match for the main NFA (with complications)
//	 ^ static int complicatedFind(struct vars *, struct cnfa *, struct colormap *);
//	 */
func _complicatedFind(tls *libc.TLS, v uintptr, cnfa uintptr, cm uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var d, s uintptr
	var ret int32
	var _ /* cold at bp+0 */ uintptr
	_, _, _ = d, ret, s
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	s = _newDFA(tls, v, (*Tvars1)(unsafe.Pointer(v)).Fg+32, cm, v+80)
	if (*Tvars1)(unsafe.Pointer(v)).Ferr != 0 {
		return (*Tvars1)(unsafe.Pointer(v)).Ferr
	}
	d = _newDFA(tls, v, cnfa, cm, v+17016)
	if (*Tvars1)(unsafe.Pointer(v)).Ferr != 0 {
		_freeDFA(tls, s)
		return (*Tvars1)(unsafe.Pointer(v)).Ferr
	}
	ret = _complicatedFindLoop(tls, v, d, s, bp)
	_freeDFA(tls, d)
	_freeDFA(tls, s)
	if (*Tvars1)(unsafe.Pointer(v)).Ferr != 0 {
		return (*Tvars1)(unsafe.Pointer(v)).Ferr
	}
	if (*Tguts)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fg)).Fcflags&int32(REG_EXPECT) != 0 {
		if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
			(*Trm_detail_t)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fdetails)).Frm_extend.Frm_so = libc.Uint64FromInt64((int64(*(*uintptr)(unsafe.Pointer(bp))) - int64((*Tvars1)(unsafe.Pointer(v)).Fstart)) / 4)
		} else {
			(*Trm_detail_t)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fdetails)).Frm_extend.Frm_so = libc.Uint64FromInt64((int64((*Tvars1)(unsafe.Pointer(v)).Fstop) - int64((*Tvars1)(unsafe.Pointer(v)).Fstart)) / 4)
		}
		(*Trm_detail_t)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fdetails)).Frm_extend.Frm_eo = libc.Uint64FromInt64((int64((*Tvars1)(unsafe.Pointer(v)).Fstop) - int64((*Tvars1)(unsafe.Pointer(v)).Fstart)) / 4) /* unknown */
	}
	return ret
}

// C documentation
//
//	/*
//	 - complicatedFindLoop - the heart of complicatedFind
//	 ^ static int complicatedFindLoop(struct vars *,
//	 ^	struct dfa *, struct dfa *, chr **);
//	 */
func _complicatedFindLoop(tls *libc.TLS, v uintptr, d uintptr, s uintptr, coldp uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* where to put coldstart pointer */
	var begin, close1, end, estart, estop, open uintptr
	var er, shorter, v3, v4 int32
	var _ /* cold at bp+0 */ uintptr
	var _ /* hitend at bp+8 */ int32
	_, _, _, _, _, _, _, _, _, _ = begin, close1, end, er, estart, estop, open, shorter, v3, v4
	shorter = libc.Int32FromUint8((*Tsubre)(unsafe.Pointer((*Tguts)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fg)).Ftree)).Fflags) & int32(SHORTER)
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	close1 = (*Tvars1)(unsafe.Pointer(v)).Fstart
	for cond := true; cond; cond = close1 < (*Tvars1)(unsafe.Pointer(v)).Fstop {
		close1 = _shortest(tls, v, s, close1, close1, (*Tvars1)(unsafe.Pointer(v)).Fstop, bp, libc.UintptrFromInt32(0))
		if close1 == libc.UintptrFromInt32(0) {
			break /* NOTE BREAK */
		}
		open = *(*uintptr)(unsafe.Pointer(bp))
		*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
		begin = open
		for {
			if !(begin <= close1) {
				break
			}
			estart = begin
			estop = (*Tvars1)(unsafe.Pointer(v)).Fstop
			for {
				if shorter != 0 {
					end = _shortest(tls, v, d, begin, estart, estop, libc.UintptrFromInt32(0), bp+8)
				} else {
					end = _longest(tls, v, d, begin, estop, bp+8)
				}
				if *(*int32)(unsafe.Pointer(bp + 8)) != 0 && *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
					*(*uintptr)(unsafe.Pointer(bp)) = begin
				}
				if end == libc.UintptrFromInt32(0) {
					break /* NOTE BREAK OUT */
				}
				_zapallsubs(tls, (*Tvars1)(unsafe.Pointer(v)).Fpmatch, (*Tvars1)(unsafe.Pointer(v)).Fnmatch)
				er = _cdissect(tls, v, (*Tguts)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fg)).Ftree, begin, end)
				if er == REG_OKAY {
					if (*Tvars1)(unsafe.Pointer(v)).Fnmatch > uint64(0) {
						(*(*Tregmatch_t)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fpmatch))).Frm_so = libc.Uint64FromInt64((int64(begin) - int64((*Tvars1)(unsafe.Pointer(v)).Fstart)) / 4)
						(*(*Tregmatch_t)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fpmatch))).Frm_eo = libc.Uint64FromInt64((int64(end) - int64((*Tvars1)(unsafe.Pointer(v)).Fstart)) / 4)
					}
					*(*uintptr)(unsafe.Pointer(coldp)) = *(*uintptr)(unsafe.Pointer(bp))
					return REG_OKAY
				}
				if er != int32(REG_NOMATCH) {
					if (*Tvars1)(unsafe.Pointer(v)).Ferr != 0 {
						v3 = (*Tvars1)(unsafe.Pointer(v)).Ferr
					} else {
						v3 = er
					}
					(*Tvars1)(unsafe.Pointer(v)).Ferr = v3
					*(*uintptr)(unsafe.Pointer(coldp)) = *(*uintptr)(unsafe.Pointer(bp))
					return er
				}
				if shorter != 0 {
					v4 = libc.BoolInt32(end == estop)
				} else {
					v4 = libc.BoolInt32(end == begin)
				}
				if v4 != 0 {
					break
				}
				/*
				 * Go around and try again
				 */
				if shorter != 0 {
					estart = end + uintptr(1)*4
				} else {
					estop = end - uintptr(1)*4
				}
				goto _2
			_2:
			}
			goto _1
		_1:
			;
			begin += 4
		}
	}
	*(*uintptr)(unsafe.Pointer(coldp)) = *(*uintptr)(unsafe.Pointer(bp))
	return int32(REG_NOMATCH)
}

// C documentation
//
//	/*
//	 - zapallsubs - initialize all subexpression matches to "no match"
//	 ^ static void zapallsubs(regmatch_t *, size_t);
//	 */
func _zapallsubs(tls *libc.TLS, p uintptr, n Tsize_t) {
	var i Tsize_t
	_ = i
	i = n - uint64(1)
	for {
		if !(i > uint64(0)) {
			break
		}
		(*(*Tregmatch_t)(unsafe.Pointer(p + uintptr(i)*16))).Frm_so = libc.Uint64FromInt32(-libc.Int32FromInt32(1))
		(*(*Tregmatch_t)(unsafe.Pointer(p + uintptr(i)*16))).Frm_eo = libc.Uint64FromInt32(-libc.Int32FromInt32(1))
		goto _1
	_1:
		;
		i--
	}
}

// C documentation
//
//	/*
//	 - zaptreesubs - initialize subexpressions within subtree to "no match"
//	 ^ static void zaptreesubs(struct vars *, struct subre *);
//	 */
func _zaptreesubs(tls *libc.TLS, v uintptr, t uintptr) {
	var n Tsize_t
	_ = n
	if libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(t)).Fop) == int32('(') {
		n = libc.Uint64FromInt32((*Tsubre)(unsafe.Pointer(t)).Fsubno)
		if n < (*Tvars1)(unsafe.Pointer(v)).Fnmatch {
			(*(*Tregmatch_t)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fpmatch + uintptr(n)*16))).Frm_so = libc.Uint64FromInt32(-libc.Int32FromInt32(1))
			(*(*Tregmatch_t)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fpmatch + uintptr(n)*16))).Frm_eo = libc.Uint64FromInt32(-libc.Int32FromInt32(1))
		}
	}
	if (*Tsubre)(unsafe.Pointer(t)).Fleft != libc.UintptrFromInt32(0) {
		_zaptreesubs(tls, v, (*Tsubre)(unsafe.Pointer(t)).Fleft)
	}
	if (*Tsubre)(unsafe.Pointer(t)).Fright != libc.UintptrFromInt32(0) {
		_zaptreesubs(tls, v, (*Tsubre)(unsafe.Pointer(t)).Fright)
	}
}

// C documentation
//
//	/*
//	 - subset - set subexpression match data for a successful subre
//	 ^ static void subset(struct vars *, struct subre *, chr *, chr *);
//	 */
func _subset(tls *libc.TLS, v uintptr, sub uintptr, begin uintptr, end uintptr) {
	var n int32
	_ = n
	n = (*Tsubre)(unsafe.Pointer(sub)).Fsubno
	if libc.Uint64FromInt32(n) >= (*Tvars1)(unsafe.Pointer(v)).Fnmatch {
		return
	}
	(*(*Tregmatch_t)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fpmatch + uintptr(n)*16))).Frm_so = libc.Uint64FromInt64((int64(begin) - int64((*Tvars1)(unsafe.Pointer(v)).Fstart)) / 4)
	(*(*Tregmatch_t)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fpmatch + uintptr(n)*16))).Frm_eo = libc.Uint64FromInt64((int64(end) - int64((*Tvars1)(unsafe.Pointer(v)).Fstart)) / 4)
}

// C documentation
//
//	/*
//	 - cdissect - check backrefs and determine subexpression matches
//	 * cdissect recursively processes a subre tree to check matching of backrefs
//	 * and/or identify submatch boundaries for capture nodes.  The proposed match
//	 * runs from "begin" to "end" (not including "end"), and we are basically
//	 * "dissecting" it to see where the submatches are.
//	 * Before calling any level of cdissect, the caller must have run the node's
//	 * DFA and found that the proposed substring satisfies the DFA.  (We make
//	 * the caller do that because in concatenation and iteration nodes, it's
//	 * much faster to check all the substrings against the child DFAs before we
//	 * recurse.)  Also, caller must have cleared subexpression match data via
//	 * zaptreesubs (or zapallsubs at the top level).
//	 ^ static int cdissect(struct vars *, struct subre *, chr *, chr *);
//	 */
func _cdissect(tls *libc.TLS, v uintptr, t uintptr, begin uintptr, end uintptr) (r int32) {
	/* end of same */
	var er int32
	_ = er
	switch libc.Int32FromUint8((*Tsubre)(unsafe.Pointer(t)).Fop) {
	case int32('='): /* terminal node */
		er = REG_OKAY /* no action, parent did the work */
	case int32('b'): /* back reference */
		er = _cbrdissect(tls, v, t, begin, end)
	case int32('.'): /* concatenation */
		if libc.Int32FromUint8((*Tsubre)(unsafe.Pointer((*Tsubre)(unsafe.Pointer(t)).Fleft)).Fflags)&int32(SHORTER) != 0 { /* reverse scan */
			er = _crevcondissect(tls, v, t, begin, end)
		} else {
			er = _ccondissect(tls, v, t, begin, end)
		}
	case int32('|'): /* alternation */
		er = _caltdissect(tls, v, t, begin, end)
	case int32('*'): /* iteration */
		if libc.Int32FromUint8((*Tsubre)(unsafe.Pointer((*Tsubre)(unsafe.Pointer(t)).Fleft)).Fflags)&int32(SHORTER) != 0 { /* reverse scan */
			er = _creviterdissect(tls, v, t, begin, end)
		} else {
			er = _citerdissect(tls, v, t, begin, end)
		}
	case int32('('): /* capturing */
		er = _cdissect(tls, v, (*Tsubre)(unsafe.Pointer(t)).Fleft, begin, end)
		if er == REG_OKAY {
			_subset(tls, v, t, begin, end)
		}
	default:
		er = int32(REG_ASSERT)
		break
	}
	/*
	 * We should never have a match failure unless backrefs lurk below;
	 * otherwise, either caller failed to check the DFA, or there's some
	 * inconsistency between the DFA and the node's innards.
	 */
	return er
}

// C documentation
//
//	/*
//	 - ccondissect - dissect match for concatenation node
//	 ^ static int ccondissect(struct vars *, struct subre *, chr *, chr *);
//	 */
func _ccondissect(tls *libc.TLS, v uintptr, t uintptr, begin uintptr, end uintptr) (r int32) {
	/* end of same */
	var d, d2, mid uintptr
	var er int32
	_, _, _, _ = d, d2, er, mid
	d = _getsubdfa(tls, v, (*Tsubre)(unsafe.Pointer(t)).Fleft)
	if (*Tvars1)(unsafe.Pointer(v)).Ferr != 0 {
		return (*Tvars1)(unsafe.Pointer(v)).Ferr
	}
	d2 = _getsubdfa(tls, v, (*Tsubre)(unsafe.Pointer(t)).Fright)
	if (*Tvars1)(unsafe.Pointer(v)).Ferr != 0 {
		return (*Tvars1)(unsafe.Pointer(v)).Ferr
	}
	/*
	 * Pick a tentative midpoint.
	 */
	mid = _longest(tls, v, d, begin, end, libc.UintptrFromInt32(0))
	if mid == libc.UintptrFromInt32(0) {
		return int32(REG_NOMATCH)
	}
	/*
	 * Iterate until satisfaction or failure.
	 */
	for {
		/*
		 * Try this midpoint on for size.
		 */
		if _longest(tls, v, d2, mid, end, libc.UintptrFromInt32(0)) == end {
			er = _cdissect(tls, v, (*Tsubre)(unsafe.Pointer(t)).Fleft, begin, mid)
			if er == REG_OKAY {
				er = _cdissect(tls, v, (*Tsubre)(unsafe.Pointer(t)).Fright, mid, end)
				if er == REG_OKAY {
					/*
					 * Satisfaction.
					 */
					return REG_OKAY
				}
			}
			if er != int32(REG_NOMATCH) {
				return er
			}
		}
		/*
		 * That midpoint didn't work, find a new one.
		 */
		if mid == begin {
			/*
			 * All possibilities exhausted.
			 */
			return int32(REG_NOMATCH)
		}
		mid = _longest(tls, v, d, begin, mid-uintptr(1)*4, libc.UintptrFromInt32(0))
		if mid == libc.UintptrFromInt32(0) {
			/*
			 * Failed to find a new one.
			 */
			return int32(REG_NOMATCH)
		}
		_zaptreesubs(tls, v, (*Tsubre)(unsafe.Pointer(t)).Fleft)
		_zaptreesubs(tls, v, (*Tsubre)(unsafe.Pointer(t)).Fright)
		goto _1
	_1:
	}
	return r
}

// C documentation
//
//	/*
//	 - crevcondissect - dissect match for concatenation node, shortest-first
//	 ^ static int crevcondissect(struct vars *, struct subre *, chr *, chr *);
//	 */
func _crevcondissect(tls *libc.TLS, v uintptr, t uintptr, begin uintptr, end uintptr) (r int32) {
	/* end of same */
	var d, d2, mid uintptr
	var er int32
	_, _, _, _ = d, d2, er, mid
	d = _getsubdfa(tls, v, (*Tsubre)(unsafe.Pointer(t)).Fleft)
	if (*Tvars1)(unsafe.Pointer(v)).Ferr != 0 {
		return (*Tvars1)(unsafe.Pointer(v)).Ferr
	}
	d2 = _getsubdfa(tls, v, (*Tsubre)(unsafe.Pointer(t)).Fright)
	if (*Tvars1)(unsafe.Pointer(v)).Ferr != 0 {
		return (*Tvars1)(unsafe.Pointer(v)).Ferr
	}
	/*
	 * Pick a tentative midpoint.
	 */
	mid = _shortest(tls, v, d, begin, begin, end, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	if mid == libc.UintptrFromInt32(0) {
		return int32(REG_NOMATCH)
	}
	/*
	 * Iterate until satisfaction or failure.
	 */
	for {
		/*
		 * Try this midpoint on for size.
		 */
		if _longest(tls, v, d2, mid, end, libc.UintptrFromInt32(0)) == end {
			er = _cdissect(tls, v, (*Tsubre)(unsafe.Pointer(t)).Fleft, begin, mid)
			if er == REG_OKAY {
				er = _cdissect(tls, v, (*Tsubre)(unsafe.Pointer(t)).Fright, mid, end)
				if er == REG_OKAY {
					/*
					 * Satisfaction.
					 */
					return REG_OKAY
				}
			}
			if er != int32(REG_NOMATCH) {
				return er
			}
		}
		/*
		 * That midpoint didn't work, find a new one.
		 */
		if mid == end {
			/*
			 * All possibilities exhausted.
			 */
			return int32(REG_NOMATCH)
		}
		mid = _shortest(tls, v, d, begin, mid+uintptr(1)*4, end, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
		if mid == libc.UintptrFromInt32(0) {
			/*
			 * Failed to find a new one.
			 */
			return int32(REG_NOMATCH)
		}
		_zaptreesubs(tls, v, (*Tsubre)(unsafe.Pointer(t)).Fleft)
		_zaptreesubs(tls, v, (*Tsubre)(unsafe.Pointer(t)).Fright)
		goto _1
	_1:
	}
	return r
}

// C documentation
//
//	/*
//	 - cbrdissect - dissect match for backref node
//	 ^ static int cbrdissect(struct vars *, struct subre *, chr *, chr *);
//	 */
func _cbrdissect(tls *libc.TLS, v uintptr, t uintptr, begin uintptr, end uintptr) (r int32) {
	/* end of same */
	var brlen, numreps, tlen, v1 Tsize_t
	var brstring, p uintptr
	var max, min, n int32
	_, _, _, _, _, _, _, _, _ = brlen, brstring, max, min, n, numreps, p, tlen, v1
	n = (*Tsubre)(unsafe.Pointer(t)).Fsubno
	min = int32((*Tsubre)(unsafe.Pointer(t)).Fmin)
	max = int32((*Tsubre)(unsafe.Pointer(t)).Fmax)
	/* get the backreferenced string */
	if (*(*Tregmatch_t)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fpmatch + uintptr(n)*16))).Frm_so == libc.Uint64FromInt32(-libc.Int32FromInt32(1)) {
		return int32(REG_NOMATCH)
	}
	brstring = (*Tvars1)(unsafe.Pointer(v)).Fstart + uintptr((*(*Tregmatch_t)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fpmatch + uintptr(n)*16))).Frm_so)*4
	brlen = (*(*Tregmatch_t)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fpmatch + uintptr(n)*16))).Frm_eo - (*(*Tregmatch_t)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fpmatch + uintptr(n)*16))).Frm_so
	/* special cases for zero-length strings */
	if brlen == uint64(0) {
		/*
		 * matches only if target is zero length, but any number of
		 * repetitions can be considered to be present
		 */
		if begin == end && min <= max {
			return REG_OKAY
		}
		return int32(REG_NOMATCH)
	}
	if begin == end {
		/* matches only if zero repetitions are okay */
		if min == 0 {
			return REG_OKAY
		}
		return int32(REG_NOMATCH)
	}
	/*
	 * check target length to see if it could possibly be an allowed number of
	 * repetitions of brstring
	 */
	tlen = libc.Uint64FromInt64((int64(end) - int64(begin)) / 4)
	if tlen%brlen != uint64(0) {
		return int32(REG_NOMATCH)
	}
	numreps = tlen / brlen
	if numreps < libc.Uint64FromInt32(min) || numreps > libc.Uint64FromInt32(max) && max != libc.Int32FromInt32(_POSIX2_RE_DUP_MAX)+libc.Int32FromInt32(1) {
		return int32(REG_NOMATCH)
	}
	/* okay, compare the actual string contents */
	p = begin
	for {
		v1 = numreps
		numreps--
		if !(v1 > uint64(0)) {
			break
		}
		if (*(*func(*libc.TLS, uintptr, uintptr, Tsize_t) int32)(unsafe.Pointer(&struct{ uintptr }{(*Tguts)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fg)).Fcompare})))(tls, brstring, p, brlen) != 0 {
			return int32(REG_NOMATCH)
		}
		p += uintptr(brlen) * 4
	}
	return REG_OKAY
}

// C documentation
//
//	/*
//	 - caltdissect - dissect match for alternation node
//	 ^ static int caltdissect(struct vars *, struct subre *, chr *, chr *);
//	 */
func _caltdissect(tls *libc.TLS, v uintptr, t uintptr, begin uintptr, end uintptr) (r int32) {
	/* end of same */
	var d uintptr
	var er int32
	_, _ = d, er
	/* We loop, rather than tail-recurse, to handle a chain of alternatives */
	for t != libc.UintptrFromInt32(0) {
		d = _getsubdfa(tls, v, (*Tsubre)(unsafe.Pointer(t)).Fleft)
		if (*Tvars1)(unsafe.Pointer(v)).Ferr != 0 {
			return (*Tvars1)(unsafe.Pointer(v)).Ferr
		}
		if _longest(tls, v, d, begin, end, libc.UintptrFromInt32(0)) == end {
			er = _cdissect(tls, v, (*Tsubre)(unsafe.Pointer(t)).Fleft, begin, end)
			if er != int32(REG_NOMATCH) {
				return er
			}
		}
		t = (*Tsubre)(unsafe.Pointer(t)).Fright
	}
	return int32(REG_NOMATCH)
}

// C documentation
//
//	/*
//	 - citerdissect - dissect match for iteration node
//	 ^ static int citerdissect(struct vars *, struct subre *, chr *, chr *);
//	 */
func _citerdissect(tls *libc.TLS, v uintptr, t uintptr, begin uintptr, end uintptr) (r int32) {
	/* end of same */
	var d, endpts, limit, prev_end uintptr
	var er, i, k, min_matches, nverified int32
	var max_matches Tsize_t
	_, _, _, _, _, _, _, _, _, _ = d, endpts, er, i, k, limit, max_matches, min_matches, nverified, prev_end
	/*
	 * If zero matches are allowed, and target string is empty, just declare
	 * victory.  OTOH, if target string isn't empty, zero matches can't work
	 * so we pretend the min is 1.
	 */
	min_matches = int32((*Tsubre)(unsafe.Pointer(t)).Fmin)
	if min_matches <= 0 {
		if begin == end {
			return REG_OKAY
		}
		min_matches = int32(1)
	}
	/*
	 * We need workspace to track the endpoints of each sub-match.  Normally
	 * we consider only nonzero-length sub-matches, so there can be at most
	 * end-begin of them.  However, if min is larger than that, we will also
	 * consider zero-length sub-matches in order to find enough matches.
	 *
	 * For convenience, endpts[0] contains the "begin" pointer and we store
	 * sub-match endpoints in endpts[1..max_matches].
	 */
	max_matches = libc.Uint64FromInt64((int64(end) - int64(begin)) / 4)
	if max_matches > libc.Uint64FromInt16((*Tsubre)(unsafe.Pointer(t)).Fmax) && int32((*Tsubre)(unsafe.Pointer(t)).Fmax) != libc.Int32FromInt32(_POSIX2_RE_DUP_MAX)+libc.Int32FromInt32(1) {
		max_matches = libc.Uint64FromInt16((*Tsubre)(unsafe.Pointer(t)).Fmax)
	}
	if max_matches < libc.Uint64FromInt32(min_matches) {
		max_matches = libc.Uint64FromInt32(min_matches)
	}
	endpts = XTclpAlloc(tls, (max_matches+uint64(1))*uint64(8))
	if endpts == libc.UintptrFromInt32(0) {
		return int32(REG_ESPACE)
	}
	*(*uintptr)(unsafe.Pointer(endpts)) = begin
	d = _getsubdfa(tls, v, (*Tsubre)(unsafe.Pointer(t)).Fleft)
	if (*Tvars1)(unsafe.Pointer(v)).Ferr != 0 {
		XTclpFree(tls, endpts)
		return (*Tvars1)(unsafe.Pointer(v)).Ferr
	}
	/*
	 * Our strategy is to first find a set of sub-match endpoints that are
	 * valid according to the child node's DFA, and then recursively dissect
	 * each sub-match to confirm validity.  If any validity check fails,
	 * backtrack the last sub-match and try again.  And, when we next try for
	 * a validity check, we need not recheck any successfully verified
	 * sub-matches that we didn't move the endpoints of.  nverified remembers
	 * how many sub-matches are currently known okay.
	 */
	/* initialize to consider first sub-match */
	nverified = 0
	k = int32(1)
	limit = end
	/* iterate until satisfaction or failure */
	for k > 0 {
		/* try to find an endpoint for the k'th sub-match */
		*(*uintptr)(unsafe.Pointer(endpts + uintptr(k)*8)) = _longest(tls, v, d, *(*uintptr)(unsafe.Pointer(endpts + uintptr(k-int32(1))*8)), limit, libc.UintptrFromInt32(0))
		if *(*uintptr)(unsafe.Pointer(endpts + uintptr(k)*8)) == libc.UintptrFromInt32(0) {
			/* no match possible, so see if we can shorten previous one */
			k--
			goto backtrack
		}
		/* k'th sub-match can no longer be considered verified */
		if nverified >= k {
			nverified = k - int32(1)
		}
		if *(*uintptr)(unsafe.Pointer(endpts + uintptr(k)*8)) != end {
			/* haven't reached end yet, try another iteration if allowed */
			if libc.Uint64FromInt32(k) >= max_matches {
				/* must try to shorten some previous match */
				k--
				goto backtrack
			}
			/* reject zero-length match unless necessary to achieve min */
			if *(*uintptr)(unsafe.Pointer(endpts + uintptr(k)*8)) == *(*uintptr)(unsafe.Pointer(endpts + uintptr(k-int32(1))*8)) && (k >= min_matches || int64(min_matches-k) < (int64(end)-int64(*(*uintptr)(unsafe.Pointer(endpts + uintptr(k)*8))))/4) {
				goto backtrack
			}
			k++
			limit = end
			continue
		}
		/*
		 * We've identified a way to divide the string into k sub-matches
		 * that works so far as the child DFA can tell.  If k is an allowed
		 * number of matches, start the slow part: recurse to verify each
		 * sub-match.  We always have k <= max_matches, needn't check that.
		 */
		if k < min_matches {
			goto backtrack
		}
		i = nverified + int32(1)
		for {
			if !(i <= k) {
				break
			}
			_zaptreesubs(tls, v, (*Tsubre)(unsafe.Pointer(t)).Fleft)
			er = _cdissect(tls, v, (*Tsubre)(unsafe.Pointer(t)).Fleft, *(*uintptr)(unsafe.Pointer(endpts + uintptr(i-int32(1))*8)), *(*uintptr)(unsafe.Pointer(endpts + uintptr(i)*8)))
			if er == REG_OKAY {
				nverified = i
				goto _1
			}
			if er == int32(REG_NOMATCH) {
				break
			}
			/* oops, something failed */
			XTclpFree(tls, endpts)
			return er
			goto _1
		_1:
			;
			i++
		}
		if i > k {
			/* satisfaction */
			XTclpFree(tls, endpts)
			return REG_OKAY
		}
		/* match failed to verify, so backtrack */
		goto backtrack
	backtrack:
		;
		/*
		 * Must consider shorter versions of the current sub-match.  However,
		 * we'll only ask for a zero-length match if necessary.
		 */
		for k > 0 {
			prev_end = *(*uintptr)(unsafe.Pointer(endpts + uintptr(k-int32(1))*8))
			if *(*uintptr)(unsafe.Pointer(endpts + uintptr(k)*8)) > prev_end {
				limit = *(*uintptr)(unsafe.Pointer(endpts + uintptr(k)*8)) - uintptr(1)*4
				if limit > prev_end || k < min_matches && int64(min_matches-k) >= (int64(end)-int64(prev_end))/4 {
					/* break out of backtrack loop, continue the outer one */
					break
				}
			}
			/* can't shorten k'th sub-match any more, consider previous one */
			k--
		}
	}
	/* all possibilities exhausted */
	XTclpFree(tls, endpts)
	return int32(REG_NOMATCH)
}

// C documentation
//
//	/*
//	 - creviterdissect - dissect match for iteration node, shortest-first
//	 ^ static int creviterdissect(struct vars *, struct subre *, chr *, chr *);
//	 */
func _creviterdissect(tls *libc.TLS, v uintptr, t uintptr, begin uintptr, end uintptr) (r int32) {
	/* end of same */
	var d, endpts, limit uintptr
	var er, i, k, min_matches, nverified int32
	var max_matches Tsize_t
	_, _, _, _, _, _, _, _, _ = d, endpts, er, i, k, limit, max_matches, min_matches, nverified
	/*
	 * If zero matches are allowed, and target string is empty, just declare
	 * victory.  OTOH, if target string isn't empty, zero matches can't work
	 * so we pretend the min is 1.
	 */
	min_matches = int32((*Tsubre)(unsafe.Pointer(t)).Fmin)
	if min_matches <= 0 {
		if begin == end {
			return REG_OKAY
		}
		min_matches = int32(1)
	}
	/*
	 * We need workspace to track the endpoints of each sub-match.  Normally
	 * we consider only nonzero-length sub-matches, so there can be at most
	 * end-begin of them.  However, if min is larger than that, we will also
	 * consider zero-length sub-matches in order to find enough matches.
	 *
	 * For convenience, endpts[0] contains the "begin" pointer and we store
	 * sub-match endpoints in endpts[1..max_matches].
	 */
	max_matches = libc.Uint64FromInt64((int64(end) - int64(begin)) / 4)
	if max_matches > libc.Uint64FromInt16((*Tsubre)(unsafe.Pointer(t)).Fmax) && int32((*Tsubre)(unsafe.Pointer(t)).Fmax) != libc.Int32FromInt32(_POSIX2_RE_DUP_MAX)+libc.Int32FromInt32(1) {
		max_matches = libc.Uint64FromInt16((*Tsubre)(unsafe.Pointer(t)).Fmax)
	}
	if max_matches < libc.Uint64FromInt32(min_matches) {
		max_matches = libc.Uint64FromInt32(min_matches)
	}
	endpts = XTclpAlloc(tls, (max_matches+uint64(1))*uint64(8))
	if endpts == libc.UintptrFromInt32(0) {
		return int32(REG_ESPACE)
	}
	*(*uintptr)(unsafe.Pointer(endpts)) = begin
	d = _getsubdfa(tls, v, (*Tsubre)(unsafe.Pointer(t)).Fleft)
	if (*Tvars1)(unsafe.Pointer(v)).Ferr != 0 {
		XTclpFree(tls, endpts)
		return (*Tvars1)(unsafe.Pointer(v)).Ferr
	}
	/*
	 * Our strategy is to first find a set of sub-match endpoints that are
	 * valid according to the child node's DFA, and then recursively dissect
	 * each sub-match to confirm validity.  If any validity check fails,
	 * backtrack the last sub-match and try again.  And, when we next try for
	 * a validity check, we need not recheck any successfully verified
	 * sub-matches that we didn't move the endpoints of.  nverified remembers
	 * how many sub-matches are currently known okay.
	 */
	/* initialize to consider first sub-match */
	nverified = 0
	k = int32(1)
	limit = begin
	/* iterate until satisfaction or failure */
	for k > 0 {
		/* disallow zero-length match unless necessary to achieve min */
		if limit == *(*uintptr)(unsafe.Pointer(endpts + uintptr(k-int32(1))*8)) && limit != end && (k >= min_matches || int64(min_matches-k) < (int64(end)-int64(limit))/4) {
			limit += 4
		}
		/* if this is the last allowed sub-match, it must reach to the end */
		if libc.Uint64FromInt32(k) >= max_matches {
			limit = end
		}
		/* try to find an endpoint for the k'th sub-match */
		*(*uintptr)(unsafe.Pointer(endpts + uintptr(k)*8)) = _shortest(tls, v, d, *(*uintptr)(unsafe.Pointer(endpts + uintptr(k-int32(1))*8)), limit, end, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
		if *(*uintptr)(unsafe.Pointer(endpts + uintptr(k)*8)) == libc.UintptrFromInt32(0) {
			/* no match possible, so see if we can lengthen previous one */
			k--
			goto backtrack
		}
		/* k'th sub-match can no longer be considered verified */
		if nverified >= k {
			nverified = k - int32(1)
		}
		if *(*uintptr)(unsafe.Pointer(endpts + uintptr(k)*8)) != end {
			/* haven't reached end yet, try another iteration if allowed */
			if libc.Uint64FromInt32(k) >= max_matches {
				/* must try to lengthen some previous match */
				k--
				goto backtrack
			}
			k++
			limit = *(*uintptr)(unsafe.Pointer(endpts + uintptr(k-int32(1))*8))
			continue
		}
		/*
		 * We've identified a way to divide the string into k sub-matches
		 * that works so far as the child DFA can tell.  If k is an allowed
		 * number of matches, start the slow part: recurse to verify each
		 * sub-match.  We always have k <= max_matches, needn't check that.
		 */
		if k < min_matches {
			goto backtrack
		}
		i = nverified + int32(1)
		for {
			if !(i <= k) {
				break
			}
			_zaptreesubs(tls, v, (*Tsubre)(unsafe.Pointer(t)).Fleft)
			er = _cdissect(tls, v, (*Tsubre)(unsafe.Pointer(t)).Fleft, *(*uintptr)(unsafe.Pointer(endpts + uintptr(i-int32(1))*8)), *(*uintptr)(unsafe.Pointer(endpts + uintptr(i)*8)))
			if er == REG_OKAY {
				nverified = i
				goto _1
			}
			if er == int32(REG_NOMATCH) {
				break
			}
			/* oops, something failed */
			XTclpFree(tls, endpts)
			return er
			goto _1
		_1:
			;
			i++
		}
		if i > k {
			/* satisfaction */
			XTclpFree(tls, endpts)
			return REG_OKAY
		}
		/* match failed to verify, so backtrack */
		goto backtrack
	backtrack:
		;
		/*
		 * Must consider longer versions of the current sub-match.
		 */
		for k > 0 {
			if *(*uintptr)(unsafe.Pointer(endpts + uintptr(k)*8)) < end {
				limit = *(*uintptr)(unsafe.Pointer(endpts + uintptr(k)*8)) + uintptr(1)*4
				/* break out of backtrack loop, continue the outer one */
				break
			}
			/* can't lengthen k'th sub-match any more, consider previous one */
			k--
		}
	}
	/* all possibilities exhausted */
	XTclpFree(tls, endpts)
	return int32(REG_NOMATCH)
}

/*
 * DFA routines
 * This file is #included by regexec.c.
 *
 * Copyright © 1998, 1999 Henry Spencer.  All rights reserved.
 *
 * Development of this software was funded, in part, by Cray Research Inc.,
 * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
 * Corporation, none of whom are responsible for the results.  The author
 * thanks all of them.
 *
 * Redistribution and use in source and binary forms -- with or without
 * modification -- are permitted for any purpose, provided that
 * redistributions in source form retain this entire copyright notice and
 * indicate the origin and nature of any modifications.
 *
 * I'd appreciate being given credit for this package in the documentation
 * of software which uses it, but that is not a requirement.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
 * HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

// C documentation
//
//	/*
//	 - longest - longest-preferred matching engine
//	 ^ static chr *longest(struct vars *, struct dfa *, chr *, chr *, int *);
//	 */
func _longest(tls *libc.TLS, v uintptr, d uintptr, start uintptr, stop uintptr, hitstopp uintptr) (r uintptr) {
	/* record whether hit v->stop, if non-NULL */
	var cm, cp, css, post, realstop, ss, v1 uintptr
	var co Tcolor
	var i Tsize_t
	var v2, v3 int32
	_, _, _, _, _, _, _, _, _, _, _ = cm, co, cp, css, i, post, realstop, ss, v1, v2, v3
	if stop == (*Tvars1)(unsafe.Pointer(v)).Fstop {
		v1 = stop
	} else {
		v1 = stop + uintptr(1)*4
	}
	realstop = v1
	cm = (*Tdfa)(unsafe.Pointer(d)).Fcm
	/*
	 * Initialize.
	 */
	css = _initialize(tls, v, d, start)
	cp = start
	if hitstopp != libc.UintptrFromInt32(0) {
		*(*int32)(unsafe.Pointer(hitstopp)) = 0
	}
	/*
	 * Startup.
	 */
	if cp == (*Tvars1)(unsafe.Pointer(v)).Fstart {
		if (*Tvars1)(unsafe.Pointer(v)).Feflags&int32(REG_NOTBOL) != 0 {
			v2 = 0
		} else {
			v2 = int32(1)
		}
		co = *(*Tcolor)(unsafe.Pointer((*Tdfa)(unsafe.Pointer(d)).Fcnfa + 32 + uintptr(v2)*2))
	} else {
		co = *(*Tcolor)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(cm + 368 + uintptr(*(*Tchr)(unsafe.Pointer(cp - libc.UintptrFromInt32(1)*4))>>(libc.Int32FromInt32(3)*libc.Int32FromInt32(BYTBITS))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))*8)) + uintptr(*(*Tchr)(unsafe.Pointer(cp - libc.UintptrFromInt32(1)*4))>>(libc.Int32FromInt32(2)*libc.Int32FromInt32(BYTBITS))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))*8)) + uintptr(*(*Tchr)(unsafe.Pointer(cp - libc.UintptrFromInt32(1)*4))>>libc.Int32FromInt32(BYTBITS)&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))*8)) + uintptr(*(*Tchr)(unsafe.Pointer(cp - libc.UintptrFromInt32(1)*4))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))*2))
	}
	css = _miss(tls, v, d, css, int32(co), cp, start)
	if css == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	(*Tsset)(unsafe.Pointer(css)).Flastseen = cp
	/*
	 * Main loop.
	 */
	if (*Tvars1)(unsafe.Pointer(v)).Feflags&int32(REG_FTRACE) != 0 {
		for cp < realstop {
			co = *(*Tcolor)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(cm + 368 + uintptr(*(*Tchr)(unsafe.Pointer(cp))>>(libc.Int32FromInt32(3)*libc.Int32FromInt32(BYTBITS))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))*8)) + uintptr(*(*Tchr)(unsafe.Pointer(cp))>>(libc.Int32FromInt32(2)*libc.Int32FromInt32(BYTBITS))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))*8)) + uintptr(*(*Tchr)(unsafe.Pointer(cp))>>libc.Int32FromInt32(BYTBITS)&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))*8)) + uintptr(*(*Tchr)(unsafe.Pointer(cp))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))*2))
			ss = *(*uintptr)(unsafe.Pointer((*Tsset)(unsafe.Pointer(css)).Fouts + uintptr(co)*8))
			if ss == libc.UintptrFromInt32(0) {
				ss = _miss(tls, v, d, css, int32(co), cp+uintptr(1)*4, start)
				if ss == libc.UintptrFromInt32(0) {
					break /* NOTE BREAK OUT */
				}
			}
			cp += 4
			(*Tsset)(unsafe.Pointer(ss)).Flastseen = cp
			css = ss
		}
	} else {
		for cp < realstop {
			co = *(*Tcolor)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(cm + 368 + uintptr(*(*Tchr)(unsafe.Pointer(cp))>>(libc.Int32FromInt32(3)*libc.Int32FromInt32(BYTBITS))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))*8)) + uintptr(*(*Tchr)(unsafe.Pointer(cp))>>(libc.Int32FromInt32(2)*libc.Int32FromInt32(BYTBITS))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))*8)) + uintptr(*(*Tchr)(unsafe.Pointer(cp))>>libc.Int32FromInt32(BYTBITS)&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))*8)) + uintptr(*(*Tchr)(unsafe.Pointer(cp))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))*2))
			ss = *(*uintptr)(unsafe.Pointer((*Tsset)(unsafe.Pointer(css)).Fouts + uintptr(co)*8))
			if ss == libc.UintptrFromInt32(0) {
				ss = _miss(tls, v, d, css, int32(co), cp+uintptr(1)*4, start)
				if ss == libc.UintptrFromInt32(0) {
					break /* NOTE BREAK OUT */
				}
			}
			cp += 4
			(*Tsset)(unsafe.Pointer(ss)).Flastseen = cp
			css = ss
		}
	}
	/*
	 * Shutdown.
	 */
	if cp == (*Tvars1)(unsafe.Pointer(v)).Fstop && stop == (*Tvars1)(unsafe.Pointer(v)).Fstop {
		if hitstopp != libc.UintptrFromInt32(0) {
			*(*int32)(unsafe.Pointer(hitstopp)) = int32(1)
		}
		if (*Tvars1)(unsafe.Pointer(v)).Feflags&int32(REG_NOTEOL) != 0 {
			v3 = 0
		} else {
			v3 = int32(1)
		}
		co = *(*Tcolor)(unsafe.Pointer((*Tdfa)(unsafe.Pointer(d)).Fcnfa + 36 + uintptr(v3)*2))
		ss = _miss(tls, v, d, css, int32(co), cp, start)
		/*
		 * Special case: match ended at eol?
		 */
		if ss != libc.UintptrFromInt32(0) && (*Tsset)(unsafe.Pointer(ss)).Fflags&int32(POSTSTATE) != 0 {
			return cp
		} else {
			if ss != libc.UintptrFromInt32(0) {
				(*Tsset)(unsafe.Pointer(ss)).Flastseen = cp /* to be tidy */
			}
		}
	}
	/*
	 * Find last match, if any.
	 */
	post = (*Tdfa)(unsafe.Pointer(d)).Flastpost
	ss = (*Tdfa)(unsafe.Pointer(d)).Fssets
	i = (*Tdfa)(unsafe.Pointer(d)).Fnssused
	for {
		if !(i > uint64(0)) {
			break
		}
		if (*Tsset)(unsafe.Pointer(ss)).Fflags&int32(POSTSTATE) != 0 && post != (*Tsset)(unsafe.Pointer(ss)).Flastseen && (post == libc.UintptrFromInt32(0) || post < (*Tsset)(unsafe.Pointer(ss)).Flastseen) {
			post = (*Tsset)(unsafe.Pointer(ss)).Flastseen
		}
		goto _4
	_4:
		;
		ss += 56
		i--
	}
	if post != libc.UintptrFromInt32(0) { /* found one */
		return post - uintptr(1)*4
	}
	return libc.UintptrFromInt32(0)
}

// C documentation
//
//	/*
//	 - shortest - shortest-preferred matching engine
//	 ^ static chr *shortest(struct vars *, struct dfa *, chr *, chr *, chr *,
//	 ^	chr **, int *);
//	 */
func _shortest(tls *libc.TLS, v uintptr, d uintptr, start uintptr, min uintptr, max uintptr, coldp uintptr, hitstopp uintptr) (r uintptr) {
	/* record whether hit v->stop, if non-NULL */
	var cm, cp, css, realmax, realmin, ss, v1, v2 uintptr
	var co Tcolor
	var v3, v4 int32
	_, _, _, _, _, _, _, _, _, _, _ = cm, co, cp, css, realmax, realmin, ss, v1, v2, v3, v4
	if min == (*Tvars1)(unsafe.Pointer(v)).Fstop {
		v1 = min
	} else {
		v1 = min + uintptr(1)*4
	}
	realmin = v1
	if max == (*Tvars1)(unsafe.Pointer(v)).Fstop {
		v2 = max
	} else {
		v2 = max + uintptr(1)*4
	}
	realmax = v2
	cm = (*Tdfa)(unsafe.Pointer(d)).Fcm
	/*
	 * Initialize.
	 */
	css = _initialize(tls, v, d, start)
	cp = start
	if hitstopp != libc.UintptrFromInt32(0) {
		*(*int32)(unsafe.Pointer(hitstopp)) = 0
	}
	/*
	 * Startup.
	 */
	if cp == (*Tvars1)(unsafe.Pointer(v)).Fstart {
		if (*Tvars1)(unsafe.Pointer(v)).Feflags&int32(REG_NOTBOL) != 0 {
			v3 = 0
		} else {
			v3 = int32(1)
		}
		co = *(*Tcolor)(unsafe.Pointer((*Tdfa)(unsafe.Pointer(d)).Fcnfa + 32 + uintptr(v3)*2))
	} else {
		co = *(*Tcolor)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(cm + 368 + uintptr(*(*Tchr)(unsafe.Pointer(cp - libc.UintptrFromInt32(1)*4))>>(libc.Int32FromInt32(3)*libc.Int32FromInt32(BYTBITS))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))*8)) + uintptr(*(*Tchr)(unsafe.Pointer(cp - libc.UintptrFromInt32(1)*4))>>(libc.Int32FromInt32(2)*libc.Int32FromInt32(BYTBITS))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))*8)) + uintptr(*(*Tchr)(unsafe.Pointer(cp - libc.UintptrFromInt32(1)*4))>>libc.Int32FromInt32(BYTBITS)&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))*8)) + uintptr(*(*Tchr)(unsafe.Pointer(cp - libc.UintptrFromInt32(1)*4))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))*2))
	}
	css = _miss(tls, v, d, css, int32(co), cp, start)
	if css == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	(*Tsset)(unsafe.Pointer(css)).Flastseen = cp
	ss = css
	/*
	 * Main loop.
	 */
	if (*Tvars1)(unsafe.Pointer(v)).Feflags&int32(REG_FTRACE) != 0 {
		for cp < realmax {
			co = *(*Tcolor)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(cm + 368 + uintptr(*(*Tchr)(unsafe.Pointer(cp))>>(libc.Int32FromInt32(3)*libc.Int32FromInt32(BYTBITS))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))*8)) + uintptr(*(*Tchr)(unsafe.Pointer(cp))>>(libc.Int32FromInt32(2)*libc.Int32FromInt32(BYTBITS))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))*8)) + uintptr(*(*Tchr)(unsafe.Pointer(cp))>>libc.Int32FromInt32(BYTBITS)&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))*8)) + uintptr(*(*Tchr)(unsafe.Pointer(cp))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))*2))
			ss = *(*uintptr)(unsafe.Pointer((*Tsset)(unsafe.Pointer(css)).Fouts + uintptr(co)*8))
			if ss == libc.UintptrFromInt32(0) {
				ss = _miss(tls, v, d, css, int32(co), cp+uintptr(1)*4, start)
				if ss == libc.UintptrFromInt32(0) {
					break /* NOTE BREAK OUT */
				}
			}
			cp += 4
			(*Tsset)(unsafe.Pointer(ss)).Flastseen = cp
			css = ss
			if (*Tsset)(unsafe.Pointer(ss)).Fflags&int32(POSTSTATE) != 0 && cp >= realmin {
				break /* NOTE BREAK OUT */
			}
		}
	} else {
		for cp < realmax {
			co = *(*Tcolor)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(cm + 368 + uintptr(*(*Tchr)(unsafe.Pointer(cp))>>(libc.Int32FromInt32(3)*libc.Int32FromInt32(BYTBITS))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))*8)) + uintptr(*(*Tchr)(unsafe.Pointer(cp))>>(libc.Int32FromInt32(2)*libc.Int32FromInt32(BYTBITS))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))*8)) + uintptr(*(*Tchr)(unsafe.Pointer(cp))>>libc.Int32FromInt32(BYTBITS)&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))*8)) + uintptr(*(*Tchr)(unsafe.Pointer(cp))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(BYTBITS)-libc.Int32FromInt32(1)))*2))
			ss = *(*uintptr)(unsafe.Pointer((*Tsset)(unsafe.Pointer(css)).Fouts + uintptr(co)*8))
			if ss == libc.UintptrFromInt32(0) {
				ss = _miss(tls, v, d, css, int32(co), cp+uintptr(1)*4, start)
				if ss == libc.UintptrFromInt32(0) {
					break /* NOTE BREAK OUT */
				}
			}
			cp += 4
			(*Tsset)(unsafe.Pointer(ss)).Flastseen = cp
			css = ss
			if (*Tsset)(unsafe.Pointer(ss)).Fflags&int32(POSTSTATE) != 0 && cp >= realmin {
				break /* NOTE BREAK OUT */
			}
		}
	}
	if ss == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	if coldp != libc.UintptrFromInt32(0) { /* report last no-progress state set, if any */
		*(*uintptr)(unsafe.Pointer(coldp)) = _lastCold(tls, v, d)
	}
	if (*Tsset)(unsafe.Pointer(ss)).Fflags&int32(POSTSTATE) != 0 && cp > min {
		cp -= 4
	} else {
		if cp == (*Tvars1)(unsafe.Pointer(v)).Fstop && max == (*Tvars1)(unsafe.Pointer(v)).Fstop {
			if (*Tvars1)(unsafe.Pointer(v)).Feflags&int32(REG_NOTEOL) != 0 {
				v4 = 0
			} else {
				v4 = int32(1)
			}
			co = *(*Tcolor)(unsafe.Pointer((*Tdfa)(unsafe.Pointer(d)).Fcnfa + 36 + uintptr(v4)*2))
			ss = _miss(tls, v, d, css, int32(co), cp, start)
			/*
			 * Match might have ended at eol.
			 */
			if (ss == libc.UintptrFromInt32(0) || !((*Tsset)(unsafe.Pointer(ss)).Fflags&libc.Int32FromInt32(POSTSTATE) != 0)) && hitstopp != libc.UintptrFromInt32(0) {
				*(*int32)(unsafe.Pointer(hitstopp)) = int32(1)
			}
		}
	}
	if ss == libc.UintptrFromInt32(0) || !((*Tsset)(unsafe.Pointer(ss)).Fflags&libc.Int32FromInt32(POSTSTATE) != 0) {
		return libc.UintptrFromInt32(0)
	}
	return cp
}

// C documentation
//
//	/*
//	 - lastCold - determine last point at which no progress had been made
//	 ^ static chr *lastCold(struct vars *, struct dfa *);
//	 */
func _lastCold(tls *libc.TLS, v uintptr, d uintptr) (r uintptr) {
	var i Tsize_t
	var nopr, ss uintptr
	_, _, _ = i, nopr, ss
	nopr = (*Tdfa)(unsafe.Pointer(d)).Flastnopr
	if nopr == libc.UintptrFromInt32(0) {
		nopr = (*Tvars1)(unsafe.Pointer(v)).Fstart
	}
	ss = (*Tdfa)(unsafe.Pointer(d)).Fssets
	i = (*Tdfa)(unsafe.Pointer(d)).Fnssused
	for {
		if !(i > uint64(0)) {
			break
		}
		if (*Tsset)(unsafe.Pointer(ss)).Fflags&int32(NOPROGRESS) != 0 && nopr < (*Tsset)(unsafe.Pointer(ss)).Flastseen {
			nopr = (*Tsset)(unsafe.Pointer(ss)).Flastseen
		}
		goto _1
	_1:
		;
		ss += 56
		i--
	}
	return nopr
}

// C documentation
//
//	/*
//	 - newDFA - set up a fresh DFA
//	 ^ static struct dfa *newDFA(struct vars *, struct cnfa *,
//	 ^	struct colormap *, struct smalldfa *);
//	 */
func _newDFA(tls *libc.TLS, v uintptr, cnfa uintptr, cm uintptr, sml uintptr) (r uintptr) {
	/* preallocated space, may be NULL */
	var d, smallwas, v2 uintptr
	var nss, wordsper Tsize_t
	var v1, v3, v4 int32
	var v5 uint64
	_, _, _, _, _, _, _, _, _ = d, nss, smallwas, wordsper, v1, v2, v3, v4, v5
	nss = (*Tcnfa)(unsafe.Pointer(cnfa)).Fnstates * uint64(2)
	wordsper = ((*Tcnfa)(unsafe.Pointer(cnfa)).Fnstates + libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(4) - uint64(1)) / (libc.Uint64FromInt32(CHAR_BIT) * libc.Uint64FromInt64(4))
	smallwas = sml
	if nss <= uint64(FEWSTATES) && (*Tcnfa)(unsafe.Pointer(cnfa)).Fncolors <= int32(FEWCOLORS) {
		if sml == libc.UintptrFromInt32(0) {
			sml = XTclpAlloc(tls, uint64(16936))
			if sml == libc.UintptrFromInt32(0) {
				if (*Tvars1)(unsafe.Pointer(v)).Ferr != 0 {
					v1 = (*Tvars1)(unsafe.Pointer(v)).Ferr
				} else {
					v1 = int32(REG_ESPACE)
				}
				(*Tvars1)(unsafe.Pointer(v)).Ferr = v1
				return libc.UintptrFromInt32(0)
			}
		}
		d = sml
		(*Tdfa)(unsafe.Pointer(d)).Fssets = sml + 128
		(*Tdfa)(unsafe.Pointer(d)).Fstatesarea = sml + 2368
		(*Tdfa)(unsafe.Pointer(d)).Fwork = (*Tdfa)(unsafe.Pointer(d)).Fstatesarea + uintptr(nss)*4
		(*Tdfa)(unsafe.Pointer(d)).Foutsarea = sml + 2536
		(*Tdfa)(unsafe.Pointer(d)).Fincarea = sml + 7336
		(*Tdfa)(unsafe.Pointer(d)).Fcptsmalloced = 0
		if smallwas == libc.UintptrFromInt32(0) {
			v2 = sml
		} else {
			v2 = libc.UintptrFromInt32(0)
		}
		(*Tdfa)(unsafe.Pointer(d)).Fmallocarea = v2
	} else {
		d = XTclpAlloc(tls, uint64(128))
		if d == libc.UintptrFromInt32(0) {
			if (*Tvars1)(unsafe.Pointer(v)).Ferr != 0 {
				v3 = (*Tvars1)(unsafe.Pointer(v)).Ferr
			} else {
				v3 = int32(REG_ESPACE)
			}
			(*Tvars1)(unsafe.Pointer(v)).Ferr = v3
			return libc.UintptrFromInt32(0)
		}
		(*Tdfa)(unsafe.Pointer(d)).Fssets = XTclpAlloc(tls, nss*uint64(56))
		(*Tdfa)(unsafe.Pointer(d)).Fstatesarea = XTclpAlloc(tls, (nss+uint64(WORK))*wordsper*uint64(4))
		(*Tdfa)(unsafe.Pointer(d)).Fwork = (*Tdfa)(unsafe.Pointer(d)).Fstatesarea + uintptr(nss*wordsper)*4
		(*Tdfa)(unsafe.Pointer(d)).Foutsarea = XTclpAlloc(tls, nss*libc.Uint64FromInt32((*Tcnfa)(unsafe.Pointer(cnfa)).Fncolors)*uint64(8))
		(*Tdfa)(unsafe.Pointer(d)).Fincarea = XTclpAlloc(tls, nss*libc.Uint64FromInt32((*Tcnfa)(unsafe.Pointer(cnfa)).Fncolors)*uint64(16))
		(*Tdfa)(unsafe.Pointer(d)).Fcptsmalloced = int32(1)
		(*Tdfa)(unsafe.Pointer(d)).Fmallocarea = d
		if (*Tdfa)(unsafe.Pointer(d)).Fssets == libc.UintptrFromInt32(0) || (*Tdfa)(unsafe.Pointer(d)).Fstatesarea == libc.UintptrFromInt32(0) || (*Tdfa)(unsafe.Pointer(d)).Foutsarea == libc.UintptrFromInt32(0) || (*Tdfa)(unsafe.Pointer(d)).Fincarea == libc.UintptrFromInt32(0) {
			_freeDFA(tls, d)
			if (*Tvars1)(unsafe.Pointer(v)).Ferr != 0 {
				v4 = (*Tvars1)(unsafe.Pointer(v)).Ferr
			} else {
				v4 = int32(REG_ESPACE)
			}
			(*Tvars1)(unsafe.Pointer(v)).Ferr = v4
			return libc.UintptrFromInt32(0)
		}
	}
	if (*Tvars1)(unsafe.Pointer(v)).Feflags&int32(REG_SMALL) != 0 {
		v5 = uint64(7)
	} else {
		v5 = nss
	}
	(*Tdfa)(unsafe.Pointer(d)).Fnssets = v5
	(*Tdfa)(unsafe.Pointer(d)).Fnssused = uint64(0)
	(*Tdfa)(unsafe.Pointer(d)).Fnstates = (*Tcnfa)(unsafe.Pointer(cnfa)).Fnstates
	(*Tdfa)(unsafe.Pointer(d)).Fncolors = (*Tcnfa)(unsafe.Pointer(cnfa)).Fncolors
	(*Tdfa)(unsafe.Pointer(d)).Fwordsper = wordsper
	(*Tdfa)(unsafe.Pointer(d)).Fcnfa = cnfa
	(*Tdfa)(unsafe.Pointer(d)).Fcm = cm
	(*Tdfa)(unsafe.Pointer(d)).Flastpost = libc.UintptrFromInt32(0)
	(*Tdfa)(unsafe.Pointer(d)).Flastnopr = libc.UintptrFromInt32(0)
	(*Tdfa)(unsafe.Pointer(d)).Fsearch = (*Tdfa)(unsafe.Pointer(d)).Fssets
	/*
	 * Initialization of sset fields is done as needed.
	 */
	return d
}

// C documentation
//
//	/*
//	 - freeDFA - free a DFA
//	 ^ static void freeDFA(struct dfa *);
//	 */
func _freeDFA(tls *libc.TLS, d uintptr) {
	if (*Tdfa)(unsafe.Pointer(d)).Fcptsmalloced != 0 {
		if (*Tdfa)(unsafe.Pointer(d)).Fssets != libc.UintptrFromInt32(0) {
			XTclpFree(tls, (*Tdfa)(unsafe.Pointer(d)).Fssets)
		}
		if (*Tdfa)(unsafe.Pointer(d)).Fstatesarea != libc.UintptrFromInt32(0) {
			XTclpFree(tls, (*Tdfa)(unsafe.Pointer(d)).Fstatesarea)
		}
		if (*Tdfa)(unsafe.Pointer(d)).Foutsarea != libc.UintptrFromInt32(0) {
			XTclpFree(tls, (*Tdfa)(unsafe.Pointer(d)).Foutsarea)
		}
		if (*Tdfa)(unsafe.Pointer(d)).Fincarea != libc.UintptrFromInt32(0) {
			XTclpFree(tls, (*Tdfa)(unsafe.Pointer(d)).Fincarea)
		}
	}
	if (*Tdfa)(unsafe.Pointer(d)).Fmallocarea != libc.UintptrFromInt32(0) {
		XTclpFree(tls, (*Tdfa)(unsafe.Pointer(d)).Fmallocarea)
	}
}

// C documentation
//
//	/*
//	 - hash - construct a hash code for a bitvector
//	 * There are probably better ways, but they're more expensive.
//	 ^ static unsigned hash(unsigned *, int);
//	 */
func _hash(tls *libc.TLS, uv uintptr, n int32) (r uint32) {
	var h uint32
	var i int32
	_, _ = h, i
	h = uint32(0)
	i = 0
	for {
		if !(i < n) {
			break
		}
		h ^= *(*uint32)(unsafe.Pointer(uv + uintptr(i)*4))
		goto _1
	_1:
		;
		i++
	}
	return h
}

// C documentation
//
//	/*
//	 - initialize - hand-craft a cache entry for startup, otherwise get ready
//	 ^ static struct sset *initialize(struct vars *, struct dfa *, chr *);
//	 */
func _initialize(tls *libc.TLS, v uintptr, d uintptr, start uintptr) (r uintptr) {
	var i Tsize_t
	var ss uintptr
	var v2 uint32
	_, _, _ = i, ss, v2
	/*
	 * Is previous one still there?
	 */
	if (*Tdfa)(unsafe.Pointer(d)).Fnssused > uint64(0) && (*(*Tsset)(unsafe.Pointer((*Tdfa)(unsafe.Pointer(d)).Fssets))).Fflags&int32(STARTER) != 0 {
		ss = (*Tdfa)(unsafe.Pointer(d)).Fssets
	} else { /* no, must (re)build it */
		ss = _getVacantSS(tls, v, d, start, start)
		i = uint64(0)
		for {
			if !(i < (*Tdfa)(unsafe.Pointer(d)).Fwordsper) {
				break
			}
			*(*uint32)(unsafe.Pointer((*Tsset)(unsafe.Pointer(ss)).Fstates + uintptr(i)*4)) = uint32(0)
			goto _1
		_1:
			;
			i++
		}
		*(*uint32)(unsafe.Pointer((*Tsset)(unsafe.Pointer(ss)).Fstates + uintptr((*Tcnfa)(unsafe.Pointer((*Tdfa)(unsafe.Pointer(d)).Fcnfa)).Fpre/(libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(4)))*4)) |= libc.Uint32FromInt32(1) << ((*Tcnfa)(unsafe.Pointer((*Tdfa)(unsafe.Pointer(d)).Fcnfa)).Fpre % (libc.Uint64FromInt32(CHAR_BIT) * libc.Uint64FromInt64(4)))
		if (*Tdfa)(unsafe.Pointer(d)).Fwordsper == uint64(1) {
			v2 = *(*uint32)(unsafe.Pointer((*Tsset)(unsafe.Pointer(ss)).Fstates))
		} else {
			v2 = _hash(tls, (*Tsset)(unsafe.Pointer(ss)).Fstates, libc.Int32FromUint64((*Tdfa)(unsafe.Pointer(d)).Fwordsper))
		}
		(*Tsset)(unsafe.Pointer(ss)).Fhash = v2
		(*Tsset)(unsafe.Pointer(ss)).Fflags = libc.Int32FromInt32(STARTER) | libc.Int32FromInt32(LOCKED) | libc.Int32FromInt32(NOPROGRESS)
		/*
		 * lastseen dealt with below
		 */
	}
	i = uint64(0)
	for {
		if !(i < (*Tdfa)(unsafe.Pointer(d)).Fnssused) {
			break
		}
		(*(*Tsset)(unsafe.Pointer((*Tdfa)(unsafe.Pointer(d)).Fssets + uintptr(i)*56))).Flastseen = libc.UintptrFromInt32(0)
		goto _3
	_3:
		;
		i++
	}
	(*Tsset)(unsafe.Pointer(ss)).Flastseen = start /* maybe untrue, but harmless */
	(*Tdfa)(unsafe.Pointer(d)).Flastpost = libc.UintptrFromInt32(0)
	(*Tdfa)(unsafe.Pointer(d)).Flastnopr = libc.UintptrFromInt32(0)
	return ss
}

// C documentation
//
//	/*
//	 - miss - handle a cache miss
//	 ^ static struct sset *miss(struct vars *, struct dfa *, struct sset *,
//	 ^	pcolor, chr *, chr *);
//	 */
func _miss(tls *libc.TLS, v uintptr, d uintptr, css uintptr, co Tpcolor, cp uintptr, start uintptr) (r uintptr) {
	/* where the attempt got started */
	var ca, cnfa, p uintptr
	var doLAConstraints, gotState, isPost, noProgress, sawLAConstraints, v10, v4 int32
	var h, v7 uint32
	var i Tsize_t
	_, _, _, _, _, _, _, _, _, _, _, _, _ = ca, cnfa, doLAConstraints, gotState, h, i, isPost, noProgress, p, sawLAConstraints, v10, v4, v7
	cnfa = (*Tdfa)(unsafe.Pointer(d)).Fcnfa
	/*
	 * For convenience, we can be called even if it might not be a miss.
	 */
	if *(*uintptr)(unsafe.Pointer((*Tsset)(unsafe.Pointer(css)).Fouts + uintptr(co)*8)) != libc.UintptrFromInt32(0) {
		return *(*uintptr)(unsafe.Pointer((*Tsset)(unsafe.Pointer(css)).Fouts + uintptr(co)*8))
	}
	/*
	 * First, what set of states would we end up in?
	 */
	i = uint64(0)
	for {
		if !(i < (*Tdfa)(unsafe.Pointer(d)).Fwordsper) {
			break
		}
		*(*uint32)(unsafe.Pointer((*Tdfa)(unsafe.Pointer(d)).Fwork + uintptr(i)*4)) = uint32(0)
		goto _1
	_1:
		;
		i++
	}
	isPost = 0
	noProgress = int32(1)
	gotState = 0
	i = uint64(0)
	for {
		if !(i < (*Tdfa)(unsafe.Pointer(d)).Fnstates) {
			break
		}
		if *(*uint32)(unsafe.Pointer((*Tsset)(unsafe.Pointer(css)).Fstates + uintptr(i/(libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(4)))*4))&(libc.Uint32FromInt32(1)<<(i%(libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(4)))) != 0 {
			ca = *(*uintptr)(unsafe.Pointer((*Tcnfa)(unsafe.Pointer(cnfa)).Fstates + uintptr(i)*8))
			for {
				if !(int32((*Tcarc)(unsafe.Pointer(ca)).Fco) != -int32(1)) {
					break
				}
				if int32((*Tcarc)(unsafe.Pointer(ca)).Fco) == co {
					*(*uint32)(unsafe.Pointer((*Tdfa)(unsafe.Pointer(d)).Fwork + uintptr((*Tcarc)(unsafe.Pointer(ca)).Fto/(libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(4)))*4)) |= libc.Uint32FromInt32(1) << ((*Tcarc)(unsafe.Pointer(ca)).Fto % (libc.Uint64FromInt32(CHAR_BIT) * libc.Uint64FromInt64(4)))
					gotState = int32(1)
					if (*Tcarc)(unsafe.Pointer(ca)).Fto == (*Tcnfa)(unsafe.Pointer(cnfa)).Fpost {
						isPost = int32(1)
					}
					if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*Tcnfa)(unsafe.Pointer(cnfa)).Fstflags + uintptr((*Tcarc)(unsafe.Pointer(ca)).Fto))))&libc.Int32FromInt32(CNFA_NOPROGRESS) != 0) {
						noProgress = 0
					}
				}
				goto _3
			_3:
				;
				ca += 16
			}
		}
		goto _2
	_2:
		;
		i++
	}
	if gotState != 0 {
		v4 = (*Tcnfa)(unsafe.Pointer(cnfa)).Fflags & int32(HASLACONS)
	} else {
		v4 = 0
	}
	doLAConstraints = v4
	sawLAConstraints = 0
	for doLAConstraints != 0 { /* transitive closure */
		doLAConstraints = 0
		i = uint64(0)
		for {
			if !(i < (*Tdfa)(unsafe.Pointer(d)).Fnstates) {
				break
			}
			if *(*uint32)(unsafe.Pointer((*Tdfa)(unsafe.Pointer(d)).Fwork + uintptr(i/(libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(4)))*4))&(libc.Uint32FromInt32(1)<<(i%(libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(4)))) != 0 {
				ca = *(*uintptr)(unsafe.Pointer((*Tcnfa)(unsafe.Pointer(cnfa)).Fstates + uintptr(i)*8))
				for {
					if !(int32((*Tcarc)(unsafe.Pointer(ca)).Fco) != -int32(1)) {
						break
					}
					if int32((*Tcarc)(unsafe.Pointer(ca)).Fco) < (*Tcnfa)(unsafe.Pointer(cnfa)).Fncolors {
						goto _6 /* NOTE CONTINUE */
					}
					sawLAConstraints = int32(1)
					if *(*uint32)(unsafe.Pointer((*Tdfa)(unsafe.Pointer(d)).Fwork + uintptr((*Tcarc)(unsafe.Pointer(ca)).Fto/(libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(4)))*4))&(libc.Uint32FromInt32(1)<<((*Tcarc)(unsafe.Pointer(ca)).Fto%(libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(4)))) != 0 {
						goto _6 /* NOTE CONTINUE */
					}
					if !(_checkLAConstraint(tls, v, cnfa, cp, int32((*Tcarc)(unsafe.Pointer(ca)).Fco)) != 0) {
						goto _6 /* NOTE CONTINUE */
					}
					*(*uint32)(unsafe.Pointer((*Tdfa)(unsafe.Pointer(d)).Fwork + uintptr((*Tcarc)(unsafe.Pointer(ca)).Fto/(libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(4)))*4)) |= libc.Uint32FromInt32(1) << ((*Tcarc)(unsafe.Pointer(ca)).Fto % (libc.Uint64FromInt32(CHAR_BIT) * libc.Uint64FromInt64(4)))
					doLAConstraints = int32(1)
					if (*Tcarc)(unsafe.Pointer(ca)).Fto == (*Tcnfa)(unsafe.Pointer(cnfa)).Fpost {
						isPost = int32(1)
					}
					if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*Tcnfa)(unsafe.Pointer(cnfa)).Fstflags + uintptr((*Tcarc)(unsafe.Pointer(ca)).Fto))))&libc.Int32FromInt32(CNFA_NOPROGRESS) != 0) {
						noProgress = 0
					}
					goto _6
				_6:
					;
					ca += 16
				}
			}
			goto _5
		_5:
			;
			i++
		}
	}
	if !(gotState != 0) {
		return libc.UintptrFromInt32(0)
	}
	if (*Tdfa)(unsafe.Pointer(d)).Fwordsper == uint64(1) {
		v7 = *(*uint32)(unsafe.Pointer((*Tdfa)(unsafe.Pointer(d)).Fwork))
	} else {
		v7 = _hash(tls, (*Tdfa)(unsafe.Pointer(d)).Fwork, libc.Int32FromUint64((*Tdfa)(unsafe.Pointer(d)).Fwordsper))
	}
	h = v7
	/*
	 * Next, is that in the cache?
	 */
	p = (*Tdfa)(unsafe.Pointer(d)).Fssets
	i = (*Tdfa)(unsafe.Pointer(d)).Fnssused
	for {
		if !(i > uint64(0)) {
			break
		}
		if (*Tsset)(unsafe.Pointer(p)).Fhash == h && ((*Tdfa)(unsafe.Pointer(d)).Fwordsper == uint64(1) || libc.Xmemcmp(tls, (*Tdfa)(unsafe.Pointer(d)).Fwork, (*Tsset)(unsafe.Pointer(p)).Fstates, (*Tdfa)(unsafe.Pointer(d)).Fwordsper*uint64(4)) == 0) {
			break /* NOTE BREAK OUT */
		}
		goto _8
	_8:
		;
		p += 56
		i--
	}
	if i == uint64(0) { /* nope, need a new cache entry */
		p = _getVacantSS(tls, v, d, cp, start)
		i = uint64(0)
		for {
			if !(i < (*Tdfa)(unsafe.Pointer(d)).Fwordsper) {
				break
			}
			*(*uint32)(unsafe.Pointer((*Tsset)(unsafe.Pointer(p)).Fstates + uintptr(i)*4)) = *(*uint32)(unsafe.Pointer((*Tdfa)(unsafe.Pointer(d)).Fwork + uintptr(i)*4))
			goto _9
		_9:
			;
			i++
		}
		(*Tsset)(unsafe.Pointer(p)).Fhash = h
		if isPost != 0 {
			v10 = int32(POSTSTATE)
		} else {
			v10 = 0
		}
		(*Tsset)(unsafe.Pointer(p)).Fflags = v10
		if noProgress != 0 {
			*(*int32)(unsafe.Pointer(p + 12)) |= int32(NOPROGRESS)
		}
		/*
		 * lastseen to be dealt with by caller
		 */
	}
	if !(sawLAConstraints != 0) { /* lookahead conds. always cache miss */
		*(*uintptr)(unsafe.Pointer((*Tsset)(unsafe.Pointer(css)).Fouts + uintptr(co)*8)) = p
		*(*Tarcp)(unsafe.Pointer((*Tsset)(unsafe.Pointer(css)).Finchain + uintptr(co)*16)) = (*Tsset)(unsafe.Pointer(p)).Fins
		(*Tsset)(unsafe.Pointer(p)).Fins.Fss = css
		(*Tsset)(unsafe.Pointer(p)).Fins.Fco = int16(co)
	}
	return p
}

// C documentation
//
//	/*
//	 - checkLAConstraint - lookahead-constraint checker for miss()
//	 ^ static int checkLAConstraint(struct vars *, struct cnfa *, chr *, pcolor);
//	 */
func _checkLAConstraint(tls *libc.TLS, v uintptr, pcnfa uintptr, cp uintptr, co Tpcolor) (r int32) {
	bp := tls.Alloc(16944)
	defer tls.Free(16944) /* "color" of the lookahead constraint */
	var d, end, sub uintptr
	var n Tsize_t
	var v1, v2 int32
	var _ /* sd at bp+0 */ Tsmalldfa
	_, _, _, _, _, _ = d, end, n, sub, v1, v2
	n = libc.Uint64FromInt32(co - (*Tcnfa)(unsafe.Pointer(pcnfa)).Fncolors)
	sub = (*Tguts)(unsafe.Pointer((*Tvars1)(unsafe.Pointer(v)).Fg)).Flacons + uintptr(n)*120
	d = _newDFA(tls, v, sub+48, (*Tvars1)(unsafe.Pointer(v)).Fg+104, bp)
	if d == libc.UintptrFromInt32(0) {
		if (*Tvars1)(unsafe.Pointer(v)).Ferr != 0 {
			v1 = (*Tvars1)(unsafe.Pointer(v)).Ferr
		} else {
			v1 = int32(REG_ESPACE)
		}
		(*Tvars1)(unsafe.Pointer(v)).Ferr = v1
		return 0
	}
	end = _longest(tls, v, d, cp, (*Tvars1)(unsafe.Pointer(v)).Fstop, libc.UintptrFromInt32(0))
	_freeDFA(tls, d)
	if (*Tsubre)(unsafe.Pointer(sub)).Fsubno != 0 {
		v2 = libc.BoolInt32(end != libc.UintptrFromInt32(0))
	} else {
		v2 = libc.BoolInt32(end == libc.UintptrFromInt32(0))
	}
	return v2
}

// C documentation
//
//	/*
//	 - getVacantSS - get a vacant state set
//	 * This routine clears out the inarcs and outarcs, but does not otherwise
//	 * clear the innards of the state set -- that's up to the caller.
//	 ^ static struct sset *getVacantSS(struct vars *, struct dfa *, chr *, chr *);
//	 */
func _getVacantSS(tls *libc.TLS, v uintptr, d uintptr, cp uintptr, start uintptr) (r uintptr) {
	var ap, lastap Tarcp
	var co Tcolor
	var i int32
	var p, ss, v1 uintptr
	_, _, _, _, _, _, _ = ap, co, i, lastap, p, ss, v1
	lastap = Tarcp{}
	ss = _pickNextSS(tls, v, d, cp, start)
	/*
	 * Clear out its inarcs, including self-referential ones.
	 */
	ap = (*Tsset)(unsafe.Pointer(ss)).Fins
	for {
		v1 = ap.Fss
		p = v1
		if !(v1 != libc.UintptrFromInt32(0)) {
			break
		}
		co = ap.Fco
		*(*uintptr)(unsafe.Pointer((*Tsset)(unsafe.Pointer(p)).Fouts + uintptr(co)*8)) = libc.UintptrFromInt32(0)
		ap = *(*Tarcp)(unsafe.Pointer((*Tsset)(unsafe.Pointer(p)).Finchain + uintptr(co)*16))
		(*(*Tarcp)(unsafe.Pointer((*Tsset)(unsafe.Pointer(p)).Finchain + uintptr(co)*16))).Fss = libc.UintptrFromInt32(0) /* paranoia */
	}
	(*Tsset)(unsafe.Pointer(ss)).Fins.Fss = libc.UintptrFromInt32(0)
	/*
	 * Take it off the inarc chains of the ssets reached by its outarcs.
	 */
	i = 0
	for {
		if !(i < (*Tdfa)(unsafe.Pointer(d)).Fncolors) {
			break
		}
		p = *(*uintptr)(unsafe.Pointer((*Tsset)(unsafe.Pointer(ss)).Fouts + uintptr(i)*8))
		/* not self-referential */
		if p == libc.UintptrFromInt32(0) {
			goto _2 /* NOTE CONTINUE */
		}
		if (*Tsset)(unsafe.Pointer(p)).Fins.Fss == ss && int32((*Tsset)(unsafe.Pointer(p)).Fins.Fco) == i {
			(*Tsset)(unsafe.Pointer(p)).Fins = *(*Tarcp)(unsafe.Pointer((*Tsset)(unsafe.Pointer(ss)).Finchain + uintptr(i)*16))
		} else {
			ap = (*Tsset)(unsafe.Pointer(p)).Fins
			for {
				if !(ap.Fss != libc.UintptrFromInt32(0) && !(ap.Fss == ss && int32(ap.Fco) == i)) {
					break
				}
				lastap = ap
				goto _3
			_3:
				;
				ap = *(*Tarcp)(unsafe.Pointer((*Tsset)(unsafe.Pointer(ap.Fss)).Finchain + uintptr(ap.Fco)*16))
			}
			*(*Tarcp)(unsafe.Pointer((*Tsset)(unsafe.Pointer(lastap.Fss)).Finchain + uintptr(lastap.Fco)*16)) = *(*Tarcp)(unsafe.Pointer((*Tsset)(unsafe.Pointer(ss)).Finchain + uintptr(i)*16))
		}
		*(*uintptr)(unsafe.Pointer((*Tsset)(unsafe.Pointer(ss)).Fouts + uintptr(i)*8)) = libc.UintptrFromInt32(0)
		(*(*Tarcp)(unsafe.Pointer((*Tsset)(unsafe.Pointer(ss)).Finchain + uintptr(i)*16))).Fss = libc.UintptrFromInt32(0)
		goto _2
	_2:
		;
		i++
	}
	/*
	 * If ss was a success state, may need to remember location.
	 */
	if (*Tsset)(unsafe.Pointer(ss)).Fflags&int32(POSTSTATE) != 0 && (*Tsset)(unsafe.Pointer(ss)).Flastseen != (*Tdfa)(unsafe.Pointer(d)).Flastpost && ((*Tdfa)(unsafe.Pointer(d)).Flastpost == libc.UintptrFromInt32(0) || (*Tdfa)(unsafe.Pointer(d)).Flastpost < (*Tsset)(unsafe.Pointer(ss)).Flastseen) {
		(*Tdfa)(unsafe.Pointer(d)).Flastpost = (*Tsset)(unsafe.Pointer(ss)).Flastseen
	}
	/*
	 * Likewise for a no-progress state.
	 */
	if (*Tsset)(unsafe.Pointer(ss)).Fflags&int32(NOPROGRESS) != 0 && (*Tsset)(unsafe.Pointer(ss)).Flastseen != (*Tdfa)(unsafe.Pointer(d)).Flastnopr && ((*Tdfa)(unsafe.Pointer(d)).Flastnopr == libc.UintptrFromInt32(0) || (*Tdfa)(unsafe.Pointer(d)).Flastnopr < (*Tsset)(unsafe.Pointer(ss)).Flastseen) {
		(*Tdfa)(unsafe.Pointer(d)).Flastnopr = (*Tsset)(unsafe.Pointer(ss)).Flastseen
	}
	return ss
}

// C documentation
//
//	/*
//	 - pickNextSS - pick the next stateset to be used
//	 ^ static struct sset *pickNextSS(struct vars *, struct dfa *, chr *, chr *);
//	 */
func _pickNextSS(tls *libc.TLS, v uintptr, d uintptr, cp uintptr, start uintptr) (r uintptr) {
	var ancient, end, ss uintptr
	var i, v4 int32
	var j Tsize_t
	_, _, _, _, _, _ = ancient, end, i, j, ss, v4
	/*
	 * Shortcut for cases where cache isn't full.
	 */
	if (*Tdfa)(unsafe.Pointer(d)).Fnssused < (*Tdfa)(unsafe.Pointer(d)).Fnssets {
		j = (*Tdfa)(unsafe.Pointer(d)).Fnssused
		(*Tdfa)(unsafe.Pointer(d)).Fnssused++
		ss = (*Tdfa)(unsafe.Pointer(d)).Fssets + uintptr(j)*56
		/*
		 * Set up innards.
		 */
		(*Tsset)(unsafe.Pointer(ss)).Fstates = (*Tdfa)(unsafe.Pointer(d)).Fstatesarea + uintptr(j*(*Tdfa)(unsafe.Pointer(d)).Fwordsper)*4
		(*Tsset)(unsafe.Pointer(ss)).Fflags = 0
		(*Tsset)(unsafe.Pointer(ss)).Fins.Fss = libc.UintptrFromInt32(0)
		(*Tsset)(unsafe.Pointer(ss)).Fins.Fco = WHITE /* give it some value */
		(*Tsset)(unsafe.Pointer(ss)).Fouts = (*Tdfa)(unsafe.Pointer(d)).Foutsarea + uintptr(j*libc.Uint64FromInt32((*Tdfa)(unsafe.Pointer(d)).Fncolors))*8
		(*Tsset)(unsafe.Pointer(ss)).Finchain = (*Tdfa)(unsafe.Pointer(d)).Fincarea + uintptr(j*libc.Uint64FromInt32((*Tdfa)(unsafe.Pointer(d)).Fncolors))*16
		i = 0
		for {
			if !(i < (*Tdfa)(unsafe.Pointer(d)).Fncolors) {
				break
			}
			*(*uintptr)(unsafe.Pointer((*Tsset)(unsafe.Pointer(ss)).Fouts + uintptr(i)*8)) = libc.UintptrFromInt32(0)
			(*(*Tarcp)(unsafe.Pointer((*Tsset)(unsafe.Pointer(ss)).Finchain + uintptr(i)*16))).Fss = libc.UintptrFromInt32(0)
			goto _1
		_1:
			;
			i++
		}
		return ss
	}
	/*
	 * Look for oldest, or old enough anyway.
	 */
	if libc.Uint64FromInt64((int64(cp)-int64(start))/4) > (*Tdfa)(unsafe.Pointer(d)).Fnssets*uint64(2)/uint64(3) { /* oldest 33% are expendable */
		ancient = cp - uintptr((*Tdfa)(unsafe.Pointer(d)).Fnssets*uint64(2)/uint64(3))*4
	} else {
		ancient = start
	}
	ss = (*Tdfa)(unsafe.Pointer(d)).Fsearch
	end = (*Tdfa)(unsafe.Pointer(d)).Fssets + uintptr((*Tdfa)(unsafe.Pointer(d)).Fnssets)*56
	for {
		if !(ss < end) {
			break
		}
		if ((*Tsset)(unsafe.Pointer(ss)).Flastseen == libc.UintptrFromInt32(0) || (*Tsset)(unsafe.Pointer(ss)).Flastseen < ancient) && !((*Tsset)(unsafe.Pointer(ss)).Fflags&libc.Int32FromInt32(LOCKED) != 0) {
			(*Tdfa)(unsafe.Pointer(d)).Fsearch = ss + uintptr(1)*56
			return ss
		}
		goto _2
	_2:
		;
		ss += 56
	}
	ss = (*Tdfa)(unsafe.Pointer(d)).Fssets
	end = (*Tdfa)(unsafe.Pointer(d)).Fsearch
	for {
		if !(ss < end) {
			break
		}
		if ((*Tsset)(unsafe.Pointer(ss)).Flastseen == libc.UintptrFromInt32(0) || (*Tsset)(unsafe.Pointer(ss)).Flastseen < ancient) && !((*Tsset)(unsafe.Pointer(ss)).Fflags&libc.Int32FromInt32(LOCKED) != 0) {
			(*Tdfa)(unsafe.Pointer(d)).Fsearch = ss + uintptr(1)*56
			return ss
		}
		goto _3
	_3:
		;
		ss += 56
	}
	/*
	 * Nobody's old enough?!? -- something's really wrong.
	 */
	if (*Tvars1)(unsafe.Pointer(v)).Ferr != 0 {
		v4 = (*Tvars1)(unsafe.Pointer(v)).Ferr
	} else {
		v4 = int32(REG_ASSERT)
	}
	(*Tvars1)(unsafe.Pointer(v)).Ferr = v4
	return (*Tdfa)(unsafe.Pointer(d)).Fssets
}

/*
 * Magic for allocating a variable workspace. This default version is
 * stack-hungry.
 */

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

// C documentation
//
//	/*
//	 - regfree - free an RE (generic function, punts to RE-specific function)
//	 *
//	 * Ignoring invocation with NULL is a convenience.
//	 */
func XTclReFree(tls *libc.TLS, re uintptr) {
	if re == libc.UintptrFromInt32(0) {
		return
	}
	(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*Tfns)(unsafe.Pointer((*Tregex_t)(unsafe.Pointer(re)).Fre_fns)).Ffree})))(tls, re)
}

/*
 * Magic for allocating a variable workspace. This default version is
 * stack-hungry.
 */

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * Unknown-error explanation.
 */

var _unk = [38]uint8{'*', '*', '*', ' ', 'u', 'n', 'k', 'n', 'o', 'w', 'n', ' ', 'r', 'e', 'g', 'e', 'x', ' ', 'e', 'r', 'r', 'o', 'r', ' ', 'c', 'o', 'd', 'e', ' ', '0', 'x', '%', 'x', ' ', '*', '*', '*'}

/*
 * Struct to map among codes, code names, and explanations.
 */

type Trerr = struct {
	Fcode    int32
	Fname    uintptr
	Fexplain uintptr
}

/*
 * Struct to map among codes, code names, and explanations.
 */

var _rerrs = [21]Trerr{
	0: {
		Fname:    __ccgo_ts + 1192,
		Fexplain: __ccgo_ts + 1201,
	},
	1: {
		Fcode:    int32(REG_NOMATCH),
		Fname:    __ccgo_ts + 1220,
		Fexplain: __ccgo_ts + 1232,
	},
	2: {
		Fcode:    int32(REG_BADPAT),
		Fname:    __ccgo_ts + 1248,
		Fexplain: __ccgo_ts + 1259,
	},
	3: {
		Fcode:    int32(REG_ECOLLATE),
		Fname:    __ccgo_ts + 1292,
		Fexplain: __ccgo_ts + 1305,
	},
	4: {
		Fcode:    int32(REG_ECTYPE),
		Fname:    __ccgo_ts + 1331,
		Fexplain: __ccgo_ts + 1342,
	},
	5: {
		Fcode:    int32(REG_EESCAPE),
		Fname:    __ccgo_ts + 1366,
		Fexplain: __ccgo_ts + 1378,
	},
	6: {
		Fcode:    int32(REG_ESUBREG),
		Fname:    __ccgo_ts + 1404,
		Fexplain: __ccgo_ts + 1416,
	},
	7: {
		Fcode:    int32(REG_EBRACK),
		Fname:    __ccgo_ts + 1445,
		Fexplain: __ccgo_ts + 1456,
	},
	8: {
		Fcode:    int32(REG_EPAREN),
		Fname:    __ccgo_ts + 1481,
		Fexplain: __ccgo_ts + 1492,
	},
	9: {
		Fcode:    int32(REG_EBRACE),
		Fname:    __ccgo_ts + 1520,
		Fexplain: __ccgo_ts + 1531,
	},
	10: {
		Fcode:    int32(REG_BADBR),
		Fname:    __ccgo_ts + 1554,
		Fexplain: __ccgo_ts + 1564,
	},
	11: {
		Fcode:    int32(REG_ERANGE),
		Fname:    __ccgo_ts + 1592,
		Fexplain: __ccgo_ts + 1603,
	},
	12: {
		Fcode:    int32(REG_ESPACE),
		Fname:    __ccgo_ts + 1627,
		Fexplain: __ccgo_ts + 1638,
	},
	13: {
		Fcode:    int32(REG_BADRPT),
		Fname:    __ccgo_ts + 1652,
		Fexplain: __ccgo_ts + 1663,
	},
	14: {
		Fcode:    int32(REG_ASSERT),
		Fname:    __ccgo_ts + 1690,
		Fexplain: __ccgo_ts + 1701,
	},
	15: {
		Fcode:    int32(REG_INVARG),
		Fname:    __ccgo_ts + 1736,
		Fexplain: __ccgo_ts + 1747,
	},
	16: {
		Fcode:    int32(REG_MIXED),
		Fname:    __ccgo_ts + 1782,
		Fexplain: __ccgo_ts + 1792,
	},
	17: {
		Fcode:    int32(REG_BADOPT),
		Fname:    __ccgo_ts + 1836,
		Fexplain: __ccgo_ts + 1847,
	},
	18: {
		Fcode:    int32(REG_ETOOBIG),
		Fname:    __ccgo_ts + 1871,
		Fexplain: __ccgo_ts + 1883,
	},
	19: {
		Fcode:    int32(REG_ECOLORS),
		Fname:    __ccgo_ts + 1917,
		Fexplain: __ccgo_ts + 1929,
	},
	20: {
		Fcode:    -int32(1),
		Fname:    __ccgo_ts + 1945,
		Fexplain: __ccgo_ts + 1946,
	},
}

// C documentation
//
//	/*
//	 - regerror - the interface to error numbers
//	 */
func XTclReError(tls *libc.TLS, code int32, errbuf uintptr, errbuf_size Tsize_t) (r1 Tsize_t) {
	bp := tls.Alloc(112)
	defer tls.Free(112) /* Available space in errbuf, can be 0 */
	var icode int32
	var len1 Tsize_t
	var msg, r uintptr
	var _ /* convbuf at bp+0 */ [88]uint8
	_, _, _, _ = icode, len1, msg, r
	switch code {
	case int32(REG_ATOI):
		goto _1
	case int32(REG_ITOA):
		goto _2
	default:
		goto _3
	}
	goto _4
_1:
	; /* Convert name to number */
	r = uintptr(unsafe.Pointer(&_rerrs))
_7:
	;
	if !((*Trerr)(unsafe.Pointer(r)).Fcode >= 0) {
		goto _5
	}
	if libc.Xstrcmp(tls, (*Trerr)(unsafe.Pointer(r)).Fname, errbuf) == 0 {
		goto _5
	}
	goto _6
_6:
	;
	r += 24
	goto _7
	goto _5
_5:
	;
	libc.X__builtin_snprintf(tls, bp, uint64(88), __ccgo_ts+260, libc.VaList(bp+96, (*Trerr)(unsafe.Pointer(r)).Fcode)) /* -1 for unknown */
	msg = bp
	goto _4
_2:
	;                               /* Convert number to name */
	icode = libc.Xatoi(tls, errbuf) /* Not our problem if this fails */
	r = uintptr(unsafe.Pointer(&_rerrs))
	for {
		if !((*Trerr)(unsafe.Pointer(r)).Fcode >= 0) {
			break
		}
		if (*Trerr)(unsafe.Pointer(r)).Fcode == icode {
			break
		}
		goto _8
	_8:
		;
		r += 24
	}
	if (*Trerr)(unsafe.Pointer(r)).Fcode >= 0 {
		msg = (*Trerr)(unsafe.Pointer(r)).Fname
	} else { /* Unknown; tell him the number */
		libc.X__builtin_snprintf(tls, bp, uint64(88), __ccgo_ts+1951, libc.VaList(bp+96, icode))
		msg = bp
	}
	goto _4
_3:
	; /* A real, normal error code */
	r = uintptr(unsafe.Pointer(&_rerrs))
	for {
		if !((*Trerr)(unsafe.Pointer(r)).Fcode >= 0) {
			break
		}
		if (*Trerr)(unsafe.Pointer(r)).Fcode == code {
			break
		}
		goto _9
	_9:
		;
		r += 24
	}
	if (*Trerr)(unsafe.Pointer(r)).Fcode >= 0 {
		msg = (*Trerr)(unsafe.Pointer(r)).Fexplain
	} else { /* Unknown; say so */
		libc.X__builtin_snprintf(tls, bp, uint64(88), uintptr(unsafe.Pointer(&_unk)), libc.VaList(bp+96, code))
		msg = bp
	}
	goto _4
_4:
	;
	len1 = libc.Xstrlen(tls, msg) + uint64(1) /* Space needed, including NUL */
	if errbuf_size > uint64(0) {
		if errbuf_size > len1 {
			libc.Xstrcpy(tls, errbuf, msg)
		} else { /* Truncate to fit */
			libc.Xstrncpy(tls, errbuf, msg, errbuf_size-uint64(1))
			*(*uint8)(unsafe.Pointer(errbuf + uintptr(errbuf_size-uint64(1)))) = uint8('\000')
		}
	}
	return len1
}

const FP_FAST_FMA = 1
const FP_FAST_FMAF = 1
const FP_FAST_FMAL = 1
const FP_ILOGB0 = -2147483648
const FP_ILOGBNAN = -2147483648
const FP_INFINITE = 1
const FP_NAN = 0
const FP_NORMAL = 4
const FP_SUBNORMAL = 3
const FP_ZERO = 2
const HUGE = 0
const HUGE_VALF = 0
const INFINITY = 0
const MATH_ERREXCEPT = 2
const MATH_ERRNO = 1
const M_1_PI = 0
const M_2_PI = 0
const M_2_SQRTPI = 0
const M_E = 0
const M_LN10 = 0
const M_LN2 = 0
const M_LOG10E = 0
const M_LOG2E = 0
const M_PI = 0
const M_PI_2 = 0
const M_PI_4 = 0
const M_SQRT1_2 = 0
const M_SQRT2 = 0
const NAN = 0
const math_errhandling = 2

type Tfloat_t = float32

type Tdouble_t = float64

/*
 * The structure below defines the arithmetic series Tcl object type by
 * means of procedures that can be invoked by generic object code.
 *
 * The arithmetic series object is a special case of Tcl list representing
 * an interval of an arithmetic series in constant space.
 *
 * The arithmetic series is internally represented with three integers,
 * *start*, *end*, and *step*, Where the length is calculated with
 * the following algorithm:
 *
 * if RANGE == 0 THEN
 *   ERROR
 * if RANGE > 0
 *   LEN is (((END-START)-1)/STEP) + 1
 * else if RANGE < 0
 *   LEN is (((END-START)-1)/STEP) - 1
 *
 * And where the equivalent's list I-th element is calculated
 * as:
 *
 * LIST[i] = START + (STEP * i)
 *
 * Zero elements ranges, like in the case of START=10 END=10 STEP=1
 * are valid and will be equivalent to the empty list.
 */

/*
 * The structure used for the ArithSeries internal representation.
 * Note that the len can in theory be always computed by start,end,step
 * but it's faster to cache it inside the internal representation.
 */

type TArithSeries = struct {
	Flen1     TTcl_Size
	Felements uintptr
	FisDouble int32
}

type TArithSeriesInt = struct {
	Fbase  TArithSeries
	Fstart TTcl_WideInt
	Fend   TTcl_WideInt
	Fstep  TTcl_WideInt
}

type TArithSeriesDbl = struct {
	Fbase      TArithSeries
	Fstart     float64
	Fend       float64
	Fstep      float64
	Fprecision uint32
}

/* ------------------------ ArithSeries object type -------------------------- */

var _arithSeriesType = TTcl_ObjType{
	Fname:    __ccgo_ts + 1958,
	Fversion: uint64(112),
}

func init() {
	p := unsafe.Pointer(&_arithSeriesType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_FreeArithSeriesInternalRep)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_DupArithSeriesInternalRep)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_UpdateStringOfArithSeries)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_SetArithSeriesFromAny)
	*(*uintptr)(unsafe.Add(p, 48)) = __ccgo_fp(_ArithSeriesObjLength)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(_TclArithSeriesObjIndex)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(_TclArithSeriesObjRange)
	*(*uintptr)(unsafe.Add(p, 72)) = __ccgo_fp(_TclArithSeriesObjReverse)
	*(*uintptr)(unsafe.Add(p, 80)) = __ccgo_fp(_TclArithSeriesGetElements)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(_ArithSeriesInOperation)
}

/*
 * Helper functions
 *
 * - power10 -- Fast version of pow(10, (int) n) for common cases.
 * - ArithRound -- Round doubles to the number of significant fractional
 *                 digits
 * - ArithSeriesIndexDbl -- base list indexing operation for doubles
 * - ArithSeriesIndexInt --   "    "      "        "      "  integers
 * - ArithSeriesGetInternalRep -- Return the internal rep from a Tcl_Obj
 * - Precision -- determine the number of factional digits for the given
 *   double value
 * - maxPrecision -- Using the values provide, determine the longest percision
 *   in the arithSeries
 */

func _power10(tls *libc.TLS, n uint32) (r float64) {
	if uint64(n) < libc.Uint64FromInt64(168)/libc.Uint64FromInt64(8) {
		return _powers[n]
	} else {
		// Not an expected case. Doesn't need to be so fast
		return libc.Xpow(tls, libc.Float64FromInt32(10), float64(n))
	}
	return r
}

var _powers = [21]float64{
	0:  libc.Float64FromInt32(1),
	1:  libc.Float64FromInt32(10),
	2:  libc.Float64FromInt32(100),
	3:  libc.Float64FromInt32(1000),
	4:  float64(10000),
	5:  float64(100000),
	6:  float64(1e+06),
	7:  float64(1e+07),
	8:  float64(1e+08),
	9:  float64(1e+09),
	10: float64(1e+10),
	11: float64(1e+11),
	12: float64(1e+12),
	13: float64(1e+13),
	14: float64(1e+14),
	15: float64(1e+15),
	16: float64(1e+16),
	17: float64(1e+17),
	18: float64(1e+18),
	19: float64(1e+19),
	20: float64(1e+20),
}

func _ArithRound(tls *libc.TLS, d float64, n uint32) (r float64) {
	var scalefactor float64
	_ = scalefactor
	scalefactor = _power10(tls, n)
	return libc.X__builtin_round(tls, float64(d*scalefactor)) / scalefactor
}

func _ArithSeriesIndexDbl(tls *libc.TLS, arithSeriesRepPtr uintptr, index TTcl_WideInt) (r float64) {
	var d float64
	var dblRepPtr, intRepPtr uintptr
	_, _, _ = d, dblRepPtr, intRepPtr
	if (*TArithSeries)(unsafe.Pointer(arithSeriesRepPtr)).FisDouble != 0 {
		dblRepPtr = arithSeriesRepPtr
		d = (*TArithSeriesDbl)(unsafe.Pointer(dblRepPtr)).Fstart + float64(float64(index)*(*TArithSeriesDbl)(unsafe.Pointer(dblRepPtr)).Fstep)
		return _ArithRound(tls, d, (*TArithSeriesDbl)(unsafe.Pointer(dblRepPtr)).Fprecision)
	} else {
		intRepPtr = arithSeriesRepPtr
		return float64((*TArithSeriesInt)(unsafe.Pointer(intRepPtr)).Fstart + index*(*TArithSeriesInt)(unsafe.Pointer(intRepPtr)).Fstep)
	}
	return r
}

func _ArithSeriesIndexInt(tls *libc.TLS, arithSeriesRepPtr uintptr, index TTcl_WideInt) (r TTcl_WideInt) {
	var dblRepPtr, intRepPtr uintptr
	_, _ = dblRepPtr, intRepPtr
	if (*TArithSeries)(unsafe.Pointer(arithSeriesRepPtr)).FisDouble != 0 {
		dblRepPtr = arithSeriesRepPtr
		return int64((*TArithSeriesDbl)(unsafe.Pointer(dblRepPtr)).Fstart + float64(float64(index)*(*TArithSeriesDbl)(unsafe.Pointer(dblRepPtr)).Fstep))
	} else {
		intRepPtr = arithSeriesRepPtr
		return (*TArithSeriesInt)(unsafe.Pointer(intRepPtr)).Fstart + index*(*TArithSeriesInt)(unsafe.Pointer(intRepPtr)).Fstep
	}
	return r
}

func _ArithSeriesGetInternalRep(tls *libc.TLS, objPtr uintptr) (r uintptr) {
	var irPtr, v1, v2 uintptr
	_, _, _ = irPtr, v1, v2
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_arithSeriesType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	return v2
}

// C documentation
//
//	/*
//	 * Compute number of significant fractional digits
//	 */
func _Precision(tls *libc.TLS, d float64) (r uint32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var off uintptr
	var v1 uint64
	var _ /* tmp at bp+0 */ [29]uint8
	_, _ = off, v1
	(*(*[29]uint8)(unsafe.Pointer(bp)))[0] = uint8(0)
	XTcl_PrintDouble(tls, libc.UintptrFromInt32(0), d, bp)
	off = libc.Xstrchr(tls, bp, int32('.'))
	if off != 0 {
		v1 = libc.Xstrlen(tls, off+uintptr(1))
	} else {
		v1 = uint64(0)
	}
	return uint32(v1)
}

// C documentation
//
//	/*
//	 * Find longest number of digits after the decimal point.
//	 */
func _maxPrecision(tls *libc.TLS, start float64, end float64, step float64) (r uint32) {
	var dp, i, v1, v2 uint32
	_, _, _, _ = dp, i, v1, v2
	dp = _Precision(tls, step)
	i = _Precision(tls, start)
	if i > dp {
		v1 = i
	} else {
		v1 = dp
	}
	dp = v1
	i = _Precision(tls, end)
	if i > dp {
		v2 = i
	} else {
		v2 = dp
	}
	dp = v2
	return dp
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * ArithSeriesLen --
//	 *
//	 *	Compute the length of the equivalent list where
//	 *	every element is generated starting from *start*,
//	 *	and adding *step* to generate every successive element
//	 *	that's < *end* for positive steps, or > *end* for negative
//	 *	steps.
//	 *
//	 * Results:
//	 *	The length of the list generated by the given range,
//	 *	that may be zero.
//	 *	The function returns -1 if the list is of length infinite.
//	 *
//	 * Side effects:
//	 *	None.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _ArithSeriesLenInt(tls *libc.TLS, start TTcl_WideInt, end TTcl_WideInt, step TTcl_WideInt) (r TTcl_WideInt) {
	var len1 TTcl_WideInt
	var v1 int64
	_, _ = len1, v1
	if step == 0 {
		return 0
	}
	len1 = int64(1) + (end-start)/step
	if len1 < 0 {
		v1 = int64(-int32(1))
	} else {
		v1 = len1
	}
	return v1
}

func _ArithSeriesLenDbl(tls *libc.TLS, start float64, end float64, step float64, precision uint32) (r TTcl_WideInt) {
	var iend, ilen, istart, istep float64
	_, _, _, _ = iend, ilen, istart, istep
	if step == libc.Float64FromInt32(0) {
		return 0
	}
	istart = float64(start * _power10(tls, precision))
	iend = float64(end * _power10(tls, precision))
	istep = float64(step * _power10(tls, precision))
	ilen = (iend - istart + istep) / istep
	return int64(libc.Xfloor(tls, ilen))
}

/*
 *----------------------------------------------------------------------
 *
 * DupArithSeriesInternalRep --
 *
 *	Initialize the internal representation of a arithseries Tcl_Obj to a
 *	copy of the internal representation of an existing arithseries object.
 *	The copy does not share the cache of the elements.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	We set "copyPtr"s internal rep to a pointer to a
 *	newly allocated ArithSeries structure.
 *
 *----------------------------------------------------------------------
 */

func _DupArithSeriesInternalRep(tls *libc.TLS, srcPtr uintptr, copyPtr uintptr) {
	/* Object with internal rep to set. */
	var copyDblPtr, copyIntPtr, srcDblPtr, srcIntPtr, srcRepPtr uintptr
	_, _, _, _, _ = copyDblPtr, copyIntPtr, srcDblPtr, srcIntPtr, srcRepPtr
	srcRepPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(srcPtr + 32))).Fptr1
	if (*TArithSeries)(unsafe.Pointer(srcRepPtr)).FisDouble != 0 {
		srcDblPtr = srcRepPtr
		copyDblPtr = XTcl_Alloc(tls, uint64(56))
		*(*TArithSeriesDbl)(unsafe.Pointer(copyDblPtr)) = *(*TArithSeriesDbl)(unsafe.Pointer(srcDblPtr))
		(*TArithSeriesDbl)(unsafe.Pointer(copyDblPtr)).Fbase.Felements = libc.UintptrFromInt32(0)
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(copyPtr + 32))).Fptr1 = copyDblPtr
	} else {
		srcIntPtr = srcRepPtr
		copyIntPtr = XTcl_Alloc(tls, uint64(48))
		*(*TArithSeriesInt)(unsafe.Pointer(copyIntPtr)) = *(*TArithSeriesInt)(unsafe.Pointer(srcIntPtr))
		(*TArithSeriesInt)(unsafe.Pointer(copyIntPtr)).Fbase.Felements = libc.UintptrFromInt32(0)
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(copyPtr + 32))).Fptr1 = copyIntPtr
	}
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(copyPtr + 32))).Fptr2 = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(copyPtr)).FtypePtr = uintptr(unsafe.Pointer(&_arithSeriesType))
}

/*
 *----------------------------------------------------------------------
 *
 * FreeArithSeriesInternalRep --
 *
 *	Free any allocated memory in the ArithSeries Rep
 *
 * Results:
 *	None.
 *
 * Side effects:
 *
 *----------------------------------------------------------------------
 */

func _FreeElements(tls *libc.TLS, arithSeriesRepPtr uintptr) {
	var _objPtr, v3 uintptr
	var i, len1 TTcl_WideInt
	var v2 TTcl_Size
	_, _, _, _, _ = _objPtr, i, len1, v2, v3
	if (*TArithSeries)(unsafe.Pointer(arithSeriesRepPtr)).Felements != 0 {
		len1 = (*TArithSeries)(unsafe.Pointer(arithSeriesRepPtr)).Flen1
		i = 0
		for {
			if !(i < len1) {
				break
			}
			_objPtr = *(*uintptr)(unsafe.Pointer((*TArithSeries)(unsafe.Pointer(arithSeriesRepPtr)).Felements + uintptr(i)*8))
			v3 = _objPtr
			v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
			*(*TTcl_Size)(unsafe.Pointer(v3))--
			if v2 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			goto _1
		_1:
			;
			i++
		}
		XTclpFree(tls, (*TArithSeries)(unsafe.Pointer(arithSeriesRepPtr)).Felements)
		(*TArithSeries)(unsafe.Pointer(arithSeriesRepPtr)).Felements = libc.UintptrFromInt32(0)
	}
}

func _FreeArithSeriesInternalRep(tls *libc.TLS, arithSeriesObjPtr uintptr) {
	var arithSeriesRepPtr uintptr
	_ = arithSeriesRepPtr
	arithSeriesRepPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(arithSeriesObjPtr + 32))).Fptr1
	if arithSeriesRepPtr != 0 {
		_FreeElements(tls, arithSeriesRepPtr)
		XTclpFree(tls, arithSeriesRepPtr)
	}
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * NewArithSeriesInt --
//	 *
//	 *	Creates a new ArithSeries object. The returned object has
//	 *	refcount = 0.
//	 *
//	 * Results:
//	 *	A Tcl_Obj pointer to the created ArithSeries object.
//	 *	A NULL pointer of the range is invalid.
//	 *
//	 * Side Effects:
//	 *	None.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _NewArithSeriesInt(tls *libc.TLS, start TTcl_WideInt, end TTcl_WideInt, step TTcl_WideInt, len1 TTcl_WideInt) (r uintptr) {
	var arithSeriesObj, arithSeriesRepPtr, cachePtr uintptr
	var length TTcl_WideInt
	var v1 int64
	var v2 bool
	_, _, _, _, _, _ = arithSeriesObj, arithSeriesRepPtr, cachePtr, length, v1, v2
	if len1 >= 0 {
		v1 = len1
	} else {
		v1 = int64(-int32(1))
	}
	length = v1
	if length < 0 {
		length = int64(-int32(1))
	}
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		arithSeriesObj = XTclThreadAllocObj(tls)
	} else {
		arithSeriesObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(arithSeriesObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(arithSeriesObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(arithSeriesObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(arithSeriesObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(arithSeriesObj)).FtypePtr = libc.UintptrFromInt32(0)
	if length <= 0 {
		return arithSeriesObj
	}
	arithSeriesRepPtr = XTcl_Alloc(tls, uint64(48))
	(*TArithSeriesInt)(unsafe.Pointer(arithSeriesRepPtr)).Fbase.Flen1 = length
	(*TArithSeriesInt)(unsafe.Pointer(arithSeriesRepPtr)).Fbase.Felements = libc.UintptrFromInt32(0)
	(*TArithSeriesInt)(unsafe.Pointer(arithSeriesRepPtr)).Fbase.FisDouble = 0
	(*TArithSeriesInt)(unsafe.Pointer(arithSeriesRepPtr)).Fstart = start
	(*TArithSeriesInt)(unsafe.Pointer(arithSeriesRepPtr)).Fend = end
	(*TArithSeriesInt)(unsafe.Pointer(arithSeriesRepPtr)).Fstep = step
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(arithSeriesObj + 32))).Fptr1 = arithSeriesRepPtr
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(arithSeriesObj + 32))).Fptr2 = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(arithSeriesObj)).FtypePtr = uintptr(unsafe.Pointer(&_arithSeriesType))
	if length > 0 {
		XTcl_InvalidateStringRep(tls, arithSeriesObj)
	}
	return arithSeriesObj
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * NewArithSeriesDbl --
//	 *
//	 *	Creates a new ArithSeries object with doubles. The returned object has
//	 *	refcount = 0.
//	 *
//	 * Results:
//	 *	A Tcl_Obj pointer to the created ArithSeries object.
//	 *	A NULL pointer of the range is invalid.
//	 *
//	 * Side Effects:
//	 *	None.
//	 *----------------------------------------------------------------------
//	 */
func _NewArithSeriesDbl(tls *libc.TLS, start float64, end float64, step float64, len1 TTcl_WideInt) (r uintptr) {
	var arithSeriesObj, arithSeriesRepPtr, cachePtr uintptr
	var length TTcl_WideInt
	var v1 int64
	var v2 bool
	_, _, _, _, _, _ = arithSeriesObj, arithSeriesRepPtr, cachePtr, length, v1, v2
	if len1 >= 0 {
		v1 = len1
	} else {
		v1 = int64(-int32(1))
	}
	length = v1
	if length < 0 {
		length = int64(-int32(1))
	}
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		arithSeriesObj = XTclThreadAllocObj(tls)
	} else {
		arithSeriesObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(arithSeriesObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(arithSeriesObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(arithSeriesObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(arithSeriesObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(arithSeriesObj)).FtypePtr = libc.UintptrFromInt32(0)
	if length <= 0 {
		return arithSeriesObj
	}
	arithSeriesRepPtr = XTcl_Alloc(tls, uint64(56))
	(*TArithSeriesDbl)(unsafe.Pointer(arithSeriesRepPtr)).Fbase.Flen1 = length
	(*TArithSeriesDbl)(unsafe.Pointer(arithSeriesRepPtr)).Fbase.Felements = libc.UintptrFromInt32(0)
	(*TArithSeriesDbl)(unsafe.Pointer(arithSeriesRepPtr)).Fbase.FisDouble = int32(1)
	(*TArithSeriesDbl)(unsafe.Pointer(arithSeriesRepPtr)).Fstart = start
	(*TArithSeriesDbl)(unsafe.Pointer(arithSeriesRepPtr)).Fend = end
	(*TArithSeriesDbl)(unsafe.Pointer(arithSeriesRepPtr)).Fstep = step
	(*TArithSeriesDbl)(unsafe.Pointer(arithSeriesRepPtr)).Fprecision = _maxPrecision(tls, start, end, step)
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(arithSeriesObj + 32))).Fptr1 = arithSeriesRepPtr
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(arithSeriesObj + 32))).Fptr2 = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(arithSeriesObj)).FtypePtr = uintptr(unsafe.Pointer(&_arithSeriesType))
	if length > 0 {
		XTcl_InvalidateStringRep(tls, arithSeriesObj)
	}
	return arithSeriesObj
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * assignNumber --
//	 *
//	 *	Create the appropriate Tcl_Obj value for the given numeric values.
//	 *      Used locally only for decoding [lseq] numeric arguments.
//	 *	refcount = 0.
//	 *
//	 * Results:
//	 *	A Tcl_Obj pointer.  No assignment on error.
//	 *
//	 * Side Effects:
//	 *	None.
//	 *----------------------------------------------------------------------
//	 */
func _assignNumber(tls *libc.TLS, interp uintptr, useDoubles int32, intNumberPtr uintptr, dblNumberPtr uintptr, numberObj uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _ /* clientData at bp+0 */ uintptr
	var _ /* tcl_number_type at bp+8 */ int32
	var _ /* w at bp+16 */ TTcl_WideInt
	if XTcl_GetNumberFromObj(tls, interp, numberObj, bp, bp+8) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if *(*int32)(unsafe.Pointer(bp + 8)) == int32(TCL_NUMBER_BIG) {
		XTcl_GetWideIntFromObj(tls, interp, numberObj, bp+16)
		return int32(TCL_ERROR)
	}
	if useDoubles != 0 {
		if *(*int32)(unsafe.Pointer(bp + 8)) != int32(TCL_NUMBER_INT) {
			*(*float64)(unsafe.Pointer(dblNumberPtr)) = *(*float64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))
		} else {
			*(*float64)(unsafe.Pointer(dblNumberPtr)) = float64(*(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))
		}
	} else {
		if *(*int32)(unsafe.Pointer(bp + 8)) == int32(TCL_NUMBER_INT) {
			*(*TTcl_WideInt)(unsafe.Pointer(intNumberPtr)) = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))
		} else {
			*(*TTcl_WideInt)(unsafe.Pointer(intNumberPtr)) = int64(*(*float64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))
		}
	}
	return TCL_OK
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * TclNewArithSeriesObj --
//	 *
//	 *	Creates a new ArithSeries object. Some arguments may be NULL and will
//	 *	be computed based on the other given arguments.
//	 *      refcount = 0.
//	 *
//	 * Results:
//	 *	A Tcl_Obj pointer to the created ArithSeries object.
//	 *	NULL if the range is invalid.
//	 *
//	 * Side Effects:
//	 *	None.
//	 *----------------------------------------------------------------------
//	 */
func XTclNewArithSeriesObj(tls *libc.TLS, interp uintptr, useDoubles int32, startObj uintptr, endObj uintptr, stepObj uintptr, lenObj uintptr) (r uintptr) {
	bp := tls.Alloc(96)
	defer tls.Free(96) /* Number of elements */
	var cachePtr, objPtr, v4 uintptr
	var precision, precision1 uint32
	var v1 bool
	var v2 float64
	var v3 int32
	var _ /* dend at bp+8 */ float64
	var _ /* dstart at bp+0 */ float64
	var _ /* dstep at bp+16 */ float64
	var _ /* end at bp+32 */ TTcl_WideInt
	var _ /* len at bp+48 */ TTcl_WideInt
	var _ /* start at bp+24 */ TTcl_WideInt
	var _ /* step at bp+40 */ TTcl_WideInt
	_, _, _, _, _, _, _, _ = cachePtr, objPtr, precision, precision1, v1, v2, v3, v4
	*(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) = int64(-int32(1))
	if startObj != 0 {
		if _assignNumber(tls, interp, useDoubles, bp+24, bp, startObj) != TCL_OK {
			return libc.UintptrFromInt32(0)
		}
	} else {
		*(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) = 0
		*(*float64)(unsafe.Pointer(bp)) = float64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 24)))
	}
	if stepObj != 0 {
		if _assignNumber(tls, interp, useDoubles, bp+40, bp+16, stepObj) != TCL_OK {
			return libc.UintptrFromInt32(0)
		}
		if useDoubles != 0 {
			*(*TTcl_WideInt)(unsafe.Pointer(bp + 40)) = int64(*(*float64)(unsafe.Pointer(bp + 16)))
		} else {
			*(*float64)(unsafe.Pointer(bp + 16)) = float64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 40)))
		}
		if *(*float64)(unsafe.Pointer(bp + 16)) == libc.Float64FromInt32(0) {
			if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				objPtr = XTclThreadAllocObj(tls)
			} else {
				objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
			return objPtr
		}
	}
	if endObj != 0 {
		if _assignNumber(tls, interp, useDoubles, bp+32, bp+8, endObj) != TCL_OK {
			return libc.UintptrFromInt32(0)
		}
	}
	if lenObj != 0 {
		if TCL_OK != XTcl_GetWideIntFromObj(tls, interp, lenObj, bp+48) {
			return libc.UintptrFromInt32(0)
		}
	}
	if startObj != 0 && endObj != 0 {
		if !(stepObj != 0) {
			if useDoubles != 0 {
				if *(*float64)(unsafe.Pointer(bp)) < *(*float64)(unsafe.Pointer(bp + 8)) {
					v2 = float64(1)
				} else {
					v2 = -libc.Float64FromFloat64(1)
				}
				*(*float64)(unsafe.Pointer(bp + 16)) = v2
				*(*TTcl_WideInt)(unsafe.Pointer(bp + 40)) = int64(*(*float64)(unsafe.Pointer(bp + 16)))
			} else {
				if *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) < *(*TTcl_WideInt)(unsafe.Pointer(bp + 32)) {
					v3 = int32(1)
				} else {
					v3 = -int32(1)
				}
				*(*TTcl_WideInt)(unsafe.Pointer(bp + 40)) = int64(v3)
				*(*float64)(unsafe.Pointer(bp + 16)) = float64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 40)))
			}
		}
		if !(lenObj != 0) {
			if useDoubles != 0 {
				precision = _maxPrecision(tls, *(*float64)(unsafe.Pointer(bp)), *(*float64)(unsafe.Pointer(bp + 8)), *(*float64)(unsafe.Pointer(bp + 16)))
				*(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) = _ArithSeriesLenDbl(tls, *(*float64)(unsafe.Pointer(bp)), *(*float64)(unsafe.Pointer(bp + 8)), *(*float64)(unsafe.Pointer(bp + 16)), precision)
			} else {
				*(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) = _ArithSeriesLenInt(tls, *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)), *(*TTcl_WideInt)(unsafe.Pointer(bp + 32)), *(*TTcl_WideInt)(unsafe.Pointer(bp + 40)))
			}
		}
	}
	if !(endObj != 0) {
		if useDoubles != 0 {
			// Compute precision based on given command argument values
			precision1 = _maxPrecision(tls, *(*float64)(unsafe.Pointer(bp)), float64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 48))), *(*float64)(unsafe.Pointer(bp + 16)))
			*(*float64)(unsafe.Pointer(bp + 8)) = *(*float64)(unsafe.Pointer(bp)) + float64(*(*float64)(unsafe.Pointer(bp + 16))*float64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 48))-libc.Int64FromInt32(1)))
			// Make computed end value match argument(s) precision
			*(*float64)(unsafe.Pointer(bp + 8)) = _ArithRound(tls, *(*float64)(unsafe.Pointer(bp + 8)), precision1)
			*(*TTcl_WideInt)(unsafe.Pointer(bp + 32)) = int64(*(*float64)(unsafe.Pointer(bp + 8)))
		} else {
			*(*TTcl_WideInt)(unsafe.Pointer(bp + 32)) = *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) + *(*TTcl_WideInt)(unsafe.Pointer(bp + 40))*(*(*TTcl_WideInt)(unsafe.Pointer(bp + 48))-int64(1))
			*(*float64)(unsafe.Pointer(bp + 8)) = float64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 32)))
		}
	}
	if *(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) > int64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+1970, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+64, __ccgo_ts+2004, __ccgo_ts+2008, libc.UintptrFromInt32(0)))
		return libc.UintptrFromInt32(0)
	}
	if useDoubles != 0 {
		v4 = _NewArithSeriesDbl(tls, *(*float64)(unsafe.Pointer(bp)), *(*float64)(unsafe.Pointer(bp + 8)), *(*float64)(unsafe.Pointer(bp + 16)), *(*TTcl_WideInt)(unsafe.Pointer(bp + 48)))
	} else {
		v4 = _NewArithSeriesInt(tls, *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)), *(*TTcl_WideInt)(unsafe.Pointer(bp + 32)), *(*TTcl_WideInt)(unsafe.Pointer(bp + 40)), *(*TTcl_WideInt)(unsafe.Pointer(bp + 48)))
	}
	objPtr = v4
	return objPtr
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * TclArithSeriesObjIndex --
//	 *
//	 *	Returns the element with the specified index in the list
//	 *	represented by the specified Arithmetic Sequence object.
//	 *	If the index is out of range, TCL_ERROR is returned,
//	 *	otherwise TCL_OK is returned and the integer value of the
//	 *	element is stored in *element.
//	 *
//	 * Results:
//	 *	TCL_OK on success.
//	 *
//	 * Side Effects:
//	 *	On success, the integer pointed by *element is modified.
//	 *	An empty string ("") is assigned if index is out-of-bounds.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _TclArithSeriesObjIndex(tls *libc.TLS, dummy677 uintptr, arithSeriesObj uintptr, index TTcl_Size, elemObj uintptr) (r int32) {
	/* Return value */
	var arithSeriesRepPtr uintptr
	_ = arithSeriesRepPtr
	arithSeriesRepPtr = _ArithSeriesGetInternalRep(tls, arithSeriesObj)
	if index < 0 || (*TArithSeries)(unsafe.Pointer(arithSeriesRepPtr)).Flen1 <= index {
		*(*uintptr)(unsafe.Pointer(elemObj)) = libc.UintptrFromInt32(0)
	} else {
		/* List[i] = Start + (Step * index) */
		if (*TArithSeries)(unsafe.Pointer(arithSeriesRepPtr)).FisDouble != 0 {
			*(*uintptr)(unsafe.Pointer(elemObj)) = XTcl_NewDoubleObj(tls, _ArithSeriesIndexDbl(tls, arithSeriesRepPtr, index))
		} else {
			*(*uintptr)(unsafe.Pointer(elemObj)) = XTcl_NewWideIntObj(tls, _ArithSeriesIndexInt(tls, arithSeriesRepPtr, index))
		}
	}
	return TCL_OK
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * ArithSeriesObjLength
//	 *
//	 *	Returns the length of the arithmetic series.
//	 *
//	 * Results:
//	 *	The length of the series as Tcl_WideInt.
//	 *
//	 * Side Effects:
//	 *	None.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _ArithSeriesObjLength(tls *libc.TLS, arithSeriesObj uintptr) (r TTcl_Size) {
	var arithSeriesRepPtr uintptr
	_ = arithSeriesRepPtr
	arithSeriesRepPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(arithSeriesObj + 32))).Fptr1
	return (*TArithSeries)(unsafe.Pointer(arithSeriesRepPtr)).Flen1
}

/*
 *----------------------------------------------------------------------
 *
 * TclArithSeriesObjStep --
 *
 *	Return a Tcl_Obj with the step value from the give ArithSeries Obj.
 *	refcount = 0.
 *
 * Results:
 *	A Tcl_Obj pointer to the created ArithSeries object.
 *	A NULL pointer of the range is invalid.
 *
 * Side Effects:
 *	None.
 *----------------------------------------------------------------------
 */

func _TclArithSeriesObjStep(tls *libc.TLS, arithSeriesObj uintptr, stepObj uintptr) (r int32) {
	var arithSeriesRepPtr uintptr
	_ = arithSeriesRepPtr
	arithSeriesRepPtr = _ArithSeriesGetInternalRep(tls, arithSeriesObj)
	if (*TArithSeries)(unsafe.Pointer(arithSeriesRepPtr)).FisDouble != 0 {
		*(*uintptr)(unsafe.Pointer(stepObj)) = XTcl_NewDoubleObj(tls, (*TArithSeriesDbl)(unsafe.Pointer(arithSeriesRepPtr)).Fstep)
	} else {
		*(*uintptr)(unsafe.Pointer(stepObj)) = XTcl_NewWideIntObj(tls, (*TArithSeriesInt)(unsafe.Pointer(arithSeriesRepPtr)).Fstep)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * SetArithSeriesFromAny --
 *
 *	The Arithmetic Series object is just an way to optimize
 *	Lists space complexity, so no one should try to convert
 *	a string to an Arithmetic Series object.
 *
 *	This function is here just to populate the Type structure.
 *
 * Results:
 *	The result is always TCL_ERROR. But see Side Effects.
 *
 * Side effects:
 *	Tcl Panic if called.
 *
 *----------------------------------------------------------------------
 */

func _SetArithSeriesFromAny(tls *libc.TLS, dummy776 uintptr, dummy777 uintptr) (r int32) {
	/* The object to convert. */
	XTcl_Panic(tls, __ccgo_ts+2015, 0)
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * TclArithSeriesObjRange --
 *
 *	Makes a slice of an ArithSeries value.
 *      *arithSeriesObj must be known to be a valid list.
 *
 * Results:
 *	Returns a pointer to the sliced series.
 *      This may be a new object or the same object if not shared.
 *
 * Side effects:
 *	?The possible conversion of the object referenced by listPtr?
 *	?to a list object.?
 *
 *----------------------------------------------------------------------
 */

func _TclArithSeriesObjRange(tls *libc.TLS, interp uintptr, arithSeriesObj uintptr, fromIdx TTcl_Size, toIdx TTcl_Size, newObjPtr uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* return value */
	var _isobjPtr, _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, arithSeriesRepPtr, cachePtr, dblRepPtr, intRepPtr, newSlicePtr, v10, v12, v14, v3, v5, v7 uintptr
	var v1 bool
	var v11, v13, v2, v4, v6, v9 TTcl_Size
	var v8 int32
	var _ /* end at bp+32 */ float64
	var _ /* end at bp+56 */ TTcl_WideInt
	var _ /* endObj at bp+8 */ uintptr
	var _ /* start at bp+24 */ float64
	var _ /* start at bp+48 */ TTcl_WideInt
	var _ /* startObj at bp+0 */ uintptr
	var _ /* step at bp+40 */ float64
	var _ /* step at bp+64 */ TTcl_WideInt
	var _ /* stepObj at bp+16 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _isobjPtr, _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, arithSeriesRepPtr, cachePtr, dblRepPtr, intRepPtr, newSlicePtr, v1, v10, v11, v12, v13, v14, v2, v3, v4, v5, v6, v7, v8, v9
	_ = interp /* silence compiler */
	arithSeriesRepPtr = _ArithSeriesGetInternalRep(tls, arithSeriesObj)
	if fromIdx == int64(-libc.Int32FromInt32(1)) {
		fromIdx = 0
	}
	if toIdx >= (*TArithSeries)(unsafe.Pointer(arithSeriesRepPtr)).Flen1 {
		toIdx = (*TArithSeries)(unsafe.Pointer(arithSeriesRepPtr)).Flen1 - int64(1)
	}
	if fromIdx > toIdx || fromIdx >= (*TArithSeries)(unsafe.Pointer(arithSeriesRepPtr)).Flen1 {
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(newObjPtr)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(newObjPtr)) = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(newObjPtr)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(newObjPtr)))).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(newObjPtr)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(newObjPtr)))).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(newObjPtr)))).FtypePtr = libc.UintptrFromInt32(0)
		return TCL_OK
	}
	if fromIdx < 0 {
		fromIdx = 0
	}
	if toIdx < 0 {
		toIdx = 0
	}
	if toIdx > (*TArithSeries)(unsafe.Pointer(arithSeriesRepPtr)).Flen1-int64(1) {
		toIdx = (*TArithSeries)(unsafe.Pointer(arithSeriesRepPtr)).Flen1 - int64(1)
	}
	_TclArithSeriesObjIndex(tls, interp, arithSeriesObj, fromIdx, bp)
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FrefCount++
	_TclArithSeriesObjIndex(tls, interp, arithSeriesObj, toIdx, bp+8)
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
	_TclArithSeriesObjStep(tls, arithSeriesObj, bp+16)
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount++
	if (*TTcl_Obj)(unsafe.Pointer(arithSeriesObj)).FrefCount > int64(1) {
		newSlicePtr = XTclNewArithSeriesObj(tls, interp, (*TArithSeries)(unsafe.Pointer(arithSeriesRepPtr)).FisDouble, *(*uintptr)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 8)), *(*uintptr)(unsafe.Pointer(bp + 16)), libc.UintptrFromInt32(0))
		*(*uintptr)(unsafe.Pointer(newObjPtr)) = newSlicePtr
		_objPtr = *(*uintptr)(unsafe.Pointer(bp))
		v3 = _objPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		_objPtr1 = *(*uintptr)(unsafe.Pointer(bp + 8))
		v5 = _objPtr1
		v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
		*(*TTcl_Size)(unsafe.Pointer(v5))--
		if v4 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		_objPtr2 = *(*uintptr)(unsafe.Pointer(bp + 16))
		v7 = _objPtr2
		v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
		*(*TTcl_Size)(unsafe.Pointer(v7))--
		if v6 <= int64(1) {
			XTclFreeObj(tls, _objPtr2)
		}
		if newSlicePtr != 0 {
			v8 = TCL_OK
		} else {
			v8 = int32(TCL_ERROR)
		}
		return v8
	}
	/*
	 * In-place is possible.
	 */
	/*
	 * Even if nothing below causes any changes, we still want the
	 * string-canonizing effect of [lrange 0 end].
	 */
	_isobjPtr = arithSeriesObj
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
	if (*TArithSeries)(unsafe.Pointer(arithSeriesRepPtr)).FisDouble != 0 {
		dblRepPtr = arithSeriesRepPtr
		XTcl_GetDoubleFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), bp+24)
		XTcl_GetDoubleFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 8)), bp+32)
		XTcl_GetDoubleFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 16)), bp+40)
		(*TArithSeriesDbl)(unsafe.Pointer(dblRepPtr)).Fstart = *(*float64)(unsafe.Pointer(bp + 24))
		(*TArithSeriesDbl)(unsafe.Pointer(dblRepPtr)).Fend = *(*float64)(unsafe.Pointer(bp + 32))
		(*TArithSeriesDbl)(unsafe.Pointer(dblRepPtr)).Fstep = *(*float64)(unsafe.Pointer(bp + 40))
		(*TArithSeriesDbl)(unsafe.Pointer(dblRepPtr)).Fprecision = _maxPrecision(tls, *(*float64)(unsafe.Pointer(bp + 24)), *(*float64)(unsafe.Pointer(bp + 32)), *(*float64)(unsafe.Pointer(bp + 40)))
		_FreeElements(tls, arithSeriesRepPtr)
		(*TArithSeriesDbl)(unsafe.Pointer(dblRepPtr)).Fbase.Flen1 = _ArithSeriesLenDbl(tls, *(*float64)(unsafe.Pointer(bp + 24)), *(*float64)(unsafe.Pointer(bp + 32)), *(*float64)(unsafe.Pointer(bp + 40)), (*TArithSeriesDbl)(unsafe.Pointer(dblRepPtr)).Fprecision)
	} else {
		intRepPtr = arithSeriesRepPtr
		XTcl_GetWideIntFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), bp+48)
		XTcl_GetWideIntFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 8)), bp+56)
		XTcl_GetWideIntFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 16)), bp+64)
		(*TArithSeriesInt)(unsafe.Pointer(intRepPtr)).Fstart = *(*TTcl_WideInt)(unsafe.Pointer(bp + 48))
		(*TArithSeriesInt)(unsafe.Pointer(intRepPtr)).Fend = *(*TTcl_WideInt)(unsafe.Pointer(bp + 56))
		(*TArithSeriesInt)(unsafe.Pointer(intRepPtr)).Fstep = *(*TTcl_WideInt)(unsafe.Pointer(bp + 64))
		_FreeElements(tls, arithSeriesRepPtr)
		(*TArithSeriesInt)(unsafe.Pointer(intRepPtr)).Fbase.Flen1 = _ArithSeriesLenInt(tls, *(*TTcl_WideInt)(unsafe.Pointer(bp + 48)), *(*TTcl_WideInt)(unsafe.Pointer(bp + 56)), *(*TTcl_WideInt)(unsafe.Pointer(bp + 64)))
	}
	_objPtr3 = *(*uintptr)(unsafe.Pointer(bp))
	v10 = _objPtr3
	v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
	*(*TTcl_Size)(unsafe.Pointer(v10))--
	if v9 <= int64(1) {
		XTclFreeObj(tls, _objPtr3)
	}
	_objPtr4 = *(*uintptr)(unsafe.Pointer(bp + 8))
	v12 = _objPtr4
	v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
	*(*TTcl_Size)(unsafe.Pointer(v12))--
	if v11 <= int64(1) {
		XTclFreeObj(tls, _objPtr4)
	}
	_objPtr5 = *(*uintptr)(unsafe.Pointer(bp + 16))
	v14 = _objPtr5
	v13 = *(*TTcl_Size)(unsafe.Pointer(v14))
	*(*TTcl_Size)(unsafe.Pointer(v14))--
	if v13 <= int64(1) {
		XTclFreeObj(tls, _objPtr5)
	}
	*(*uintptr)(unsafe.Pointer(newObjPtr)) = arithSeriesObj
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclArithSeriesGetElements --
 *
 *	This function returns an (objc,objv) array of the elements in a list
 *	object.
 *
 * Results:
 *	The return value is normally TCL_OK; in this case *objcPtr is set to
 *	the count of list elements and *objvPtr is set to a pointer to an
 *	array of (*objcPtr) pointers to each list element. If listPtr does not
 *	refer to an Abstract List object and the object can not be converted
 *	to one, TCL_ERROR is returned and an error message will be left in the
 *	interpreter's result if interp is not NULL.
 *
 *	The objects referenced by the returned array should be treated as
 *	readonly and their ref counts are _not_ incremented; the caller must
 *	do that if it holds on to a reference. Furthermore, the pointer and
 *	length returned by this function may change as soon as any function is
 *	called on the list object; be careful about retaining the pointer in a
 *	local data structure.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _TclArithSeriesGetElements(tls *libc.TLS, interp uintptr, objPtr uintptr, objcPtr uintptr, objvPtr uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Where to store the pointer to an array of
	 * pointers to the list's objects. */
	var arithSeriesRepPtr, objv uintptr
	var i, objc TTcl_Size
	var status int32
	_, _, _, _, _ = arithSeriesRepPtr, i, objc, objv, status
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_arithSeriesType)) {
		arithSeriesRepPtr = _ArithSeriesGetInternalRep(tls, objPtr)
		objc = (*TArithSeries)(unsafe.Pointer(arithSeriesRepPtr)).Flen1
		if objc > 0 {
			if (*TArithSeries)(unsafe.Pointer(arithSeriesRepPtr)).Felements != 0 {
				/* If this exists, it has already been populated */
				objv = (*TArithSeries)(unsafe.Pointer(arithSeriesRepPtr)).Felements
			} else {
				/* Construct the elements array */
				objv = XTcl_Alloc(tls, uint64(8)*libc.Uint64FromInt64(objc))
				if objv == libc.UintptrFromInt32(0) {
					if interp != 0 {
						XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+1970, int64(-libc.Int32FromInt32(1))))
						XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+2008, libc.UintptrFromInt32(0)))
					}
					return int32(TCL_ERROR)
				}
				(*TArithSeries)(unsafe.Pointer(arithSeriesRepPtr)).Felements = objv
				i = 0
				for {
					if !(i < objc) {
						break
					}
					status = _TclArithSeriesObjIndex(tls, interp, objPtr, i, objv+uintptr(i)*8)
					if status != 0 {
						return int32(TCL_ERROR)
					}
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FrefCount++
					goto _1
				_1:
					;
					i++
				}
			}
		} else {
			objv = libc.UintptrFromInt32(0)
		}
		*(*uintptr)(unsafe.Pointer(objvPtr)) = objv
		*(*TTcl_Size)(unsafe.Pointer(objcPtr)) = objc
	} else {
		if interp != libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+2061, int64(-libc.Int32FromInt32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+2095, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * TclArithSeriesObjReverse --
//	 *
//	 *	Reverse the order of the ArithSeries value. The arithSeriesObj is
//	 *	assumed to be a valid ArithSeries. The new Obj has the Start and End
//	 *	values appropriately swapped and the Step value sign is changed.
//	 *
//	 * Results:
//	 *      The result will be an ArithSeries in the reverse order.
//	 *
//	 * Side effects:
//	 *      The ogiginal obj will be modified and returned if it is not Shared.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _TclArithSeriesObjReverse(tls *libc.TLS, interp uintptr, arithSeriesObj uintptr, newObjPtr uintptr) (r int32) {
	bp := tls.Alloc(112)
	defer tls.Free(112)
	var _isobjPtr, _isobjPtr1, _isobjPtr2, _objPtr, _objPtr1, _objPtr2, _objPtr3, arithSeriesRepPtr, cachePtr, dblRepPtr, intRepPtr, lenObj, resultObj, v3, v5, v7, v9 uintptr
	var isDouble, v10 int32
	var len1 TTcl_WideInt
	var v1 bool
	var v2, v4, v6, v8 TTcl_Size
	var _ /* dend at bp+56 */ float64
	var _ /* dstart at bp+48 */ float64
	var _ /* dstep at bp+64 */ float64
	var _ /* end at bp+32 */ TTcl_WideInt
	var _ /* endObj at bp+8 */ uintptr
	var _ /* ir at bp+72 */ TTcl_ObjInternalRep
	var _ /* ir at bp+88 */ TTcl_ObjInternalRep
	var _ /* start at bp+24 */ TTcl_WideInt
	var _ /* startObj at bp+0 */ uintptr
	var _ /* step at bp+40 */ TTcl_WideInt
	var _ /* stepObj at bp+16 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _isobjPtr, _isobjPtr1, _isobjPtr2, _objPtr, _objPtr1, _objPtr2, _objPtr3, arithSeriesRepPtr, cachePtr, dblRepPtr, intRepPtr, isDouble, len1, lenObj, resultObj, v1, v10, v2, v3, v4, v5, v6, v7, v8, v9
	_ = interp
	if newObjPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	arithSeriesRepPtr = _ArithSeriesGetInternalRep(tls, arithSeriesObj)
	isDouble = (*TArithSeries)(unsafe.Pointer(arithSeriesRepPtr)).FisDouble
	len1 = (*TArithSeries)(unsafe.Pointer(arithSeriesRepPtr)).Flen1
	_TclArithSeriesObjIndex(tls, libc.UintptrFromInt32(0), arithSeriesObj, len1-int64(1), bp)
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FrefCount++
	_TclArithSeriesObjIndex(tls, libc.UintptrFromInt32(0), arithSeriesObj, 0, bp+8)
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
	_TclArithSeriesObjStep(tls, arithSeriesObj, bp+16)
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount++
	if isDouble != 0 {
		XTcl_GetDoubleFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), bp+48)
		XTcl_GetDoubleFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 8)), bp+56)
		XTcl_GetDoubleFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 16)), bp+64)
		*(*float64)(unsafe.Pointer(bp + 64)) = -*(*float64)(unsafe.Pointer(bp + 64))
		*(*float64)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 72)))) = *(*float64)(unsafe.Pointer(bp + 64))
		_isobjPtr = *(*uintptr)(unsafe.Pointer(bp + 16))
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
		}
		XTcl_StoreInternalRep(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), uintptr(unsafe.Pointer(&XtclDoubleType)), bp+72)
	} else {
		XTcl_GetWideIntFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), bp+24)
		XTcl_GetWideIntFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 8)), bp+32)
		XTcl_GetWideIntFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 16)), bp+40)
		*(*TTcl_WideInt)(unsafe.Pointer(bp + 40)) = -*(*TTcl_WideInt)(unsafe.Pointer(bp + 40))
		*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 88)))) = *(*TTcl_WideInt)(unsafe.Pointer(bp + 40))
		_isobjPtr1 = *(*uintptr)(unsafe.Pointer(bp + 16))
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes = libc.UintptrFromInt32(0)
		}
		XTcl_StoreInternalRep(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), uintptr(unsafe.Pointer(&XtclIntType)), bp+88)
	}
	if (*TTcl_Obj)(unsafe.Pointer(arithSeriesObj)).FrefCount > int64(1) {
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			lenObj = XTclThreadAllocObj(tls)
		} else {
			lenObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(lenObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(lenObj)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(lenObj)).Fbytes = libc.UintptrFromInt32(0)
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(lenObj)).FinternalRep)) = len1
		(*TTcl_Obj)(unsafe.Pointer(lenObj)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
		resultObj = XTclNewArithSeriesObj(tls, interp, isDouble, *(*uintptr)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 8)), *(*uintptr)(unsafe.Pointer(bp + 16)), lenObj)
		_objPtr = lenObj
		v3 = _objPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	} else {
		/*
		 * In-place is possible.
		 */
		_isobjPtr2 = arithSeriesObj
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr2)).Fbytes != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr2)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr2)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(_isobjPtr2)).Fbytes = libc.UintptrFromInt32(0)
		}
		if isDouble != 0 {
			dblRepPtr = arithSeriesRepPtr
			(*TArithSeriesDbl)(unsafe.Pointer(dblRepPtr)).Fstart = *(*float64)(unsafe.Pointer(bp + 48))
			(*TArithSeriesDbl)(unsafe.Pointer(dblRepPtr)).Fend = *(*float64)(unsafe.Pointer(bp + 56))
			(*TArithSeriesDbl)(unsafe.Pointer(dblRepPtr)).Fstep = *(*float64)(unsafe.Pointer(bp + 64))
		} else {
			intRepPtr = arithSeriesRepPtr
			(*TArithSeriesInt)(unsafe.Pointer(intRepPtr)).Fstart = *(*TTcl_WideInt)(unsafe.Pointer(bp + 24))
			(*TArithSeriesInt)(unsafe.Pointer(intRepPtr)).Fend = *(*TTcl_WideInt)(unsafe.Pointer(bp + 32))
			(*TArithSeriesInt)(unsafe.Pointer(intRepPtr)).Fstep = *(*TTcl_WideInt)(unsafe.Pointer(bp + 40))
		}
		_FreeElements(tls, arithSeriesRepPtr)
		resultObj = arithSeriesObj
	}
	_objPtr1 = *(*uintptr)(unsafe.Pointer(bp))
	v5 = _objPtr1
	v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
	*(*TTcl_Size)(unsafe.Pointer(v5))--
	if v4 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	_objPtr2 = *(*uintptr)(unsafe.Pointer(bp + 8))
	v7 = _objPtr2
	v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
	*(*TTcl_Size)(unsafe.Pointer(v7))--
	if v6 <= int64(1) {
		XTclFreeObj(tls, _objPtr2)
	}
	_objPtr3 = *(*uintptr)(unsafe.Pointer(bp + 16))
	v9 = _objPtr3
	v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
	*(*TTcl_Size)(unsafe.Pointer(v9))--
	if v8 <= int64(1) {
		XTclFreeObj(tls, _objPtr3)
	}
	*(*uintptr)(unsafe.Pointer(newObjPtr)) = resultObj
	if resultObj != 0 {
		v10 = TCL_OK
	} else {
		v10 = int32(TCL_ERROR)
	}
	return v10
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * UpdateStringOfArithSeries --
//	 *
//	 *	Update the string representation for an arithseries object.
//	 *	Note: This procedure does not invalidate an existing old string rep
//	 *	so storage will be lost if this has not already been done.
//	 *
//	 * Results:
//	 *	None.
//	 *
//	 * Side effects:
//	 *	The object's string is set to a valid string that results from
//	 *	the list-to-string conversion. This string will be empty if the
//	 *	list has no elements. The list internal representation
//	 *	should not be NULL and we assume it is not NULL.
//	 *
//	 * Notes:
//	 *	At the cost of overallocation it's possible to estimate
//	 *	the length of the string representation and make this procedure
//	 *	much faster. Because the programmer shouldn't expect the
//	 *	string conversion of a big arithmetic sequence to be fast
//	 *	this version takes more care of space than time.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _UpdateStringOfArithSeries(tls *libc.TLS, arithSeriesObjPtr uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var _objPtr, arithSeriesRepPtr, p, str, v6, v8 uintptr
	var bytlen, i, v7 TTcl_Size
	var d, d1, v2, v3 float64
	var slen Tsize_t
	var _ /* eleObj at bp+0 */ uintptr
	var _ /* slen at bp+40 */ TTcl_Size
	var _ /* tmp at bp+8 */ [29]uint8
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, arithSeriesRepPtr, bytlen, d, d1, i, p, slen, str, v2, v3, v6, v7, v8
	arithSeriesRepPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(arithSeriesObjPtr + 32))).Fptr1
	bytlen = 0
	/*
	 * Pass 1: estimate space.
	 */
	if !((*TArithSeries)(unsafe.Pointer(arithSeriesRepPtr)).FisDouble != 0) {
		i = 0
		for {
			if !(i < (*TArithSeries)(unsafe.Pointer(arithSeriesRepPtr)).Flen1) {
				break
			}
			d = float64(_ArithSeriesIndexInt(tls, arithSeriesRepPtr, i))
			if d > libc.Float64FromInt32(0) {
				v2 = libc.Xlog10(tls, d) + libc.Float64FromInt32(1)
			} else {
				if d < libc.Float64FromInt32(0) {
					v3 = libc.Xlog10(tls, -d) + libc.Float64FromInt32(2)
				} else {
					v3 = libc.Float64FromInt32(1)
				}
				v2 = v3
			}
			slen = uint64(v2)
			bytlen = TTcl_Size(uint64(bytlen) + slen)
			goto _1
		_1:
			;
			i++
		}
	} else {
		i = 0
		for {
			if !(i < (*TArithSeries)(unsafe.Pointer(arithSeriesRepPtr)).Flen1) {
				break
			}
			d1 = _ArithSeriesIndexDbl(tls, arithSeriesRepPtr, i)
			(*(*[29]uint8)(unsafe.Pointer(bp + 8)))[0] = uint8(0)
			XTcl_PrintDouble(tls, libc.UintptrFromInt32(0), d1, bp+8)
			if libc.Uint64FromInt64(bytlen)+libc.Xstrlen(tls, bp+8) > libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) {
				break // overflow
			}
			bytlen = TTcl_Size(uint64(bytlen) + libc.Xstrlen(tls, bp+8))
			goto _4
		_4:
			;
			i++
		}
	}
	bytlen += (*TArithSeries)(unsafe.Pointer(arithSeriesRepPtr)).Flen1 // Space for each separator
	/*
	 * Pass 2: generate the string repr.
	 */
	p = XTcl_InitStringRep(tls, arithSeriesObjPtr, libc.UintptrFromInt32(0), libc.Uint64FromInt64(bytlen))
	i = 0
	for {
		if !(i < (*TArithSeries)(unsafe.Pointer(arithSeriesRepPtr)).Flen1) {
			break
		}
		if _TclArithSeriesObjIndex(tls, libc.UintptrFromInt32(0), arithSeriesObjPtr, i, bp) == TCL_OK {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Flength
				v6 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes
			} else {
				v6 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+40)
			}
			str = v6
			libc.Xstrcpy(tls, p, str)
			*(*uint8)(unsafe.Pointer(p + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 40))))) = uint8(' ')
			p += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 40)) + int64(1))
			_objPtr = *(*uintptr)(unsafe.Pointer(bp))
			v8 = _objPtr
			v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
			*(*TTcl_Size)(unsafe.Pointer(v8))--
			if v7 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		} // else TODO: report error here?
		goto _5
	_5:
		;
		i++
	}
	if bytlen > 0 {
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(arithSeriesObjPtr)).Fbytes + uintptr(bytlen-int64(1)))) = uint8('\000')
	}
	(*TTcl_Obj)(unsafe.Pointer(arithSeriesObjPtr)).Flength = bytlen - int64(1)
}

/*
 *----------------------------------------------------------------------
 *
 * ArithSeriesInOperator --
 *
 *	Evaluate the "in" operation for expr
 *
 *      This can be done more efficiently in the Arith Series relative to
 *      doing a linear search as implemented in expr.
 *
 * Results:
 *	Boolean true or false (1/0)
 *
 * Side effects:
 *      None
 *
 *----------------------------------------------------------------------
 */

func _ArithSeriesInOperation(tls *libc.TLS, interp uintptr, valueObj uintptr, arithSeriesObjPtr uintptr, boolResult uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var _objPtr, dblRepPtr, estr, estr1, intRepPtr, repPtr, vstr, vstr1, v1, v10, v12, v14, v2, v3, v5, v7, v8, v9 uintptr
	var incr, index, v13, v6 TTcl_Size
	var status, test, v11, v4 int32
	var _ /* elemObj at bp+24 */ uintptr
	var _ /* elemObj at bp+40 */ uintptr
	var _ /* elen at bp+0 */ TTcl_Size
	var _ /* vlen at bp+8 */ TTcl_Size
	var _ /* y at bp+16 */ float64
	var _ /* y at bp+32 */ TTcl_WideInt
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, dblRepPtr, estr, estr1, incr, index, intRepPtr, repPtr, status, test, vstr, vstr1, v1, v10, v11, v12, v13, v14, v2, v3, v4, v5, v6, v7, v8, v9
	repPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(arithSeriesObjPtr + 32))).Fptr1
	if (*TArithSeries)(unsafe.Pointer(repPtr)).FisDouble != 0 {
		dblRepPtr = repPtr
		test = 0
		incr = 0 // Check index+incr where incr is 0 and 1
		status = XTcl_GetDoubleFromObj(tls, interp, valueObj, bp+16)
		if status != TCL_OK {
			test = 0
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(valueObj)).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(valueObj)).Flength
				v1 = (*TTcl_Obj)(unsafe.Pointer(valueObj)).Fbytes
			} else {
				v1 = XTcl_GetStringFromObj(tls, valueObj, bp+8)
			}
			vstr = v1
			index = int64((*(*float64)(unsafe.Pointer(bp + 16)) - (*TArithSeriesDbl)(unsafe.Pointer(dblRepPtr)).Fstart) / (*TArithSeriesDbl)(unsafe.Pointer(dblRepPtr)).Fstep)
			for incr < int64(2) {
				*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
				_TclArithSeriesObjIndex(tls, interp, arithSeriesObjPtr, index+incr, bp+24)
				if *(*uintptr)(unsafe.Pointer(bp + 24)) != 0 {
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Fbytes != 0 {
						*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Flength
						v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Fbytes
					} else {
						v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 24)), bp)
					}
					v2 = v3
				} else {
					v2 = __ccgo_ts + 1945
				}
				estr = v2
				/* "in" operation defined as a string compare */
				if *(*TTcl_Size)(unsafe.Pointer(bp)) == *(*TTcl_Size)(unsafe.Pointer(bp + 8)) {
					v4 = libc.BoolInt32(libc.Xmemcmp(tls, estr, vstr, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))) == 0)
				} else {
					v4 = 0
				}
				test = v4
				v5 = *(*uintptr)(unsafe.Pointer(bp + 24))
				if v5 != 0 {
					if (*TTcl_Obj)(unsafe.Pointer(v5)).FrefCount == libc.Int64FromInt32(0) {
						_objPtr = v5
						v7 = _objPtr
						v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
						*(*TTcl_Size)(unsafe.Pointer(v7))--
						if v6 <= libc.Int64FromInt32(1) {
							XTclFreeObj(tls, _objPtr)
						}
					}
				}
				/* Stop if we have a match */
				if test != 0 {
					break
				}
				incr++
			}
		}
		if boolResult != 0 {
			*(*int32)(unsafe.Pointer(boolResult)) = test
		}
	} else {
		intRepPtr = repPtr
		status = XTcl_GetWideIntFromObj(tls, libc.UintptrFromInt32(0), valueObj, bp+32)
		if status != TCL_OK {
			if boolResult != 0 {
				*(*int32)(unsafe.Pointer(boolResult)) = 0
			}
		} else {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
			index = (*(*TTcl_WideInt)(unsafe.Pointer(bp + 32)) - (*TArithSeriesInt)(unsafe.Pointer(intRepPtr)).Fstart) / (*TArithSeriesInt)(unsafe.Pointer(intRepPtr)).Fstep
			_TclArithSeriesObjIndex(tls, interp, arithSeriesObjPtr, index, bp+40)
			if (*TTcl_Obj)(unsafe.Pointer(valueObj)).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(valueObj)).Flength
				v8 = (*TTcl_Obj)(unsafe.Pointer(valueObj)).Fbytes
			} else {
				v8 = XTcl_GetStringFromObj(tls, valueObj, bp+8)
			}
			vstr1 = v8
			if *(*uintptr)(unsafe.Pointer(bp + 40)) != 0 {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).Fbytes != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).Flength
					v10 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).Fbytes
				} else {
					v10 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 40)), bp)
				}
				v9 = v10
			} else {
				v9 = __ccgo_ts + 1945
			}
			estr1 = v9
			if boolResult != 0 {
				if *(*TTcl_Size)(unsafe.Pointer(bp)) == *(*TTcl_Size)(unsafe.Pointer(bp + 8)) {
					v11 = libc.BoolInt32(libc.Xmemcmp(tls, estr1, vstr1, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))) == 0)
				} else {
					v11 = 0
				}
				*(*int32)(unsafe.Pointer(boolResult)) = v11
			}
			v12 = *(*uintptr)(unsafe.Pointer(bp + 40))
			if v12 != 0 {
				if (*TTcl_Obj)(unsafe.Pointer(v12)).FrefCount == libc.Int64FromInt32(0) {
					_objPtr = v12
					v14 = _objPtr
					v13 = *(*TTcl_Size)(unsafe.Pointer(v14))
					*(*TTcl_Size)(unsafe.Pointer(v14))--
					if v13 <= libc.Int64FromInt32(1) {
						XTclFreeObj(tls, _objPtr)
					}
				}
			}
		}
	}
	return TCL_OK
}

const CALL_CHAIN_STATIC_SIZE = 4
const COMPILEENV_INIT_AUX_DATA_SIZE = 5
const COMPILEENV_INIT_CMD_MAP_SIZE = 40
const COMPILEENV_INIT_CODE_BYTES = 250
const COMPILEENV_INIT_EXCEPT_RANGES = 5
const COMPILEENV_INIT_NUM_OBJECTS = 60
const JUMPFIXUP_INIT_ENTRIES = 10
const LITERAL_CMD_NAME = 2
const LITERAL_ON_HEAP = 1
const LITERAL_UNSHARED = 4
const MAX_INSTRUCTION_OPERANDS = 2
const SCOPE_FLAGS = 0
const TCLOO_PROCEDURE_METHOD_VERSION = 0
const TCLOO_VERSION = "1.3"
const TCL_BYTECODE_PRECOMPILED = 1
const TCL_BYTECODE_RECOMPILE = 4
const TCL_BYTECODE_RESOLVE_VARS = 2
const TCL_LREPLACE4_END_IS_LAST = 1
const TCL_LREPLACE4_SINGLE_INDEX = 2
const TCL_NO_ELEMENT = 2
const TCL_NO_LARGE_INDEX = 1
const TCL_OO_INTERNAL_H = 1
const TCL_OO_METADATA_VERSION_CURRENT = 0
const TCL_OO_METHOD_VERSION_CURRENT = 0
const _TCLCOMPILATION = 1

type TCompileEnv1 = struct {
	FiPtr                    uintptr
	Fsource                  uintptr
	FnumSrcBytes             TTcl_Size
	FprocPtr                 uintptr
	FnumCommands             TTcl_Size
	FexceptDepth             TTcl_Size
	FmaxExceptDepth          TTcl_Size
	FmaxStackDepth           TTcl_Size
	FcurrStackDepth          TTcl_Size
	FlocalLitTable           TLiteralTable
	FcodeStart               uintptr
	FcodeNext                uintptr
	FcodeEnd                 uintptr
	FmallocedCodeArray       int32
	FmallocedExceptArray     int32
	FliteralArrayPtr         uintptr
	FliteralArrayNext        TTcl_Size
	FliteralArrayEnd         TTcl_Size
	FmallocedLiteralArray    int32
	FexceptArrayPtr          uintptr
	FexceptArrayNext         TTcl_Size
	FexceptArrayEnd          TTcl_Size
	FexceptAuxArrayPtr       uintptr
	FcmdMapPtr               uintptr
	FcmdMapEnd               TTcl_Size
	FmallocedCmdMap          int32
	FmallocedAuxDataArray    int32
	FauxDataArrayPtr         uintptr
	FauxDataArrayNext        TTcl_Size
	FauxDataArrayEnd         TTcl_Size
	FstaticCodeSpace         [250]uint8
	FstaticLiteralSpace      [60]TLiteralEntry
	FstaticExceptArraySpace  [5]TExceptionRange
	FstaticExAuxArraySpace   [5]TExceptionAux
	FstaticCmdMapSpace       [40]TCmdLocation
	FstaticAuxDataArraySpace [5]TAuxData
	FextCmdMapPtr            uintptr
	Fline                    TTcl_Size
	FatCmdStart              int32
	FexpandCount             TTcl_Size
	FclNext                  uintptr
}

type TByteCode1 = struct {
	FinterpHandle    TTclHandle
	FcompileEpoch    TTcl_Size
	FnsPtr           uintptr
	FnsEpoch         TTcl_Size
	FrefCount        TTcl_Size
	Fflags           uint32
	Fsource          uintptr
	FprocPtr         uintptr
	FstructureSize   Tsize_t
	FnumCommands     TTcl_Size
	FnumSrcBytes     TTcl_Size
	FnumCodeBytes    TTcl_Size
	FnumLitObjects   TTcl_Size
	FnumExceptRanges TTcl_Size
	FnumAuxDataItems TTcl_Size
	FnumCmdLocBytes  TTcl_Size
	FmaxExceptDepth  TTcl_Size
	FmaxStackDepth   TTcl_Size
	FcodeStart       uintptr
	FobjArrayPtr     uintptr
	FexceptArrayPtr  uintptr
	FauxDataArrayPtr uintptr
	FcodeDeltaStart  uintptr
	FcodeLengthStart uintptr
	FsrcDeltaStart   uintptr
	FsrcLengthStart  uintptr
	FlocalCachePtr   uintptr
}

type TExceptionRangeType = int32

const LOOP_EXCEPTION_RANGE = 0
const CATCH_EXCEPTION_RANGE = 1

type TExceptionRange = struct {
	Ftype1          TExceptionRangeType
	FnestingLevel   TTcl_Size
	FcodeOffset     TTcl_Size
	FnumCodeBytes   TTcl_Size
	FbreakOffset    TTcl_Size
	FcontinueOffset TTcl_Size
	FcatchOffset    TTcl_Size
}

type TExceptionAux = struct {
	FsupportsContinue     int32
	FstackDepth           TTcl_Size
	FexpandTarget         TTcl_Size
	FexpandTargetDepth    TTcl_Size
	FnumBreakTargets      TTcl_Size
	FbreakTargets         uintptr
	FallocBreakTargets    TTcl_Size
	FnumContinueTargets   TTcl_Size
	FcontinueTargets      uintptr
	FallocContinueTargets TTcl_Size
}

type TCmdLocation = struct {
	FcodeOffset   TTcl_Size
	FnumCodeBytes TTcl_Size
	FsrcOffset    TTcl_Size
	FnumSrcBytes  TTcl_Size
}

type TECL = struct {
	FsrcOffset TTcl_Size
	Fnline     TTcl_Size
	Fline      uintptr
	Fnext      uintptr
}

type TExtCmdLoc = struct {
	Ftype1 int32
	Fstart TTcl_Size
	Fpath  uintptr
	Floc   uintptr
	Fnloc  TTcl_Size
	Fnuloc TTcl_Size
}

type TAuxDataType = struct {
	Fname            uintptr
	FdupProc         uintptr
	FfreeProc        uintptr
	FprintProc       uintptr
	FdisassembleProc uintptr
}

type TAuxData = struct {
	Ftype1      uintptr
	FclientData uintptr
}

type TCompileEnv = struct {
	FiPtr                    uintptr
	Fsource                  uintptr
	FnumSrcBytes             TTcl_Size
	FprocPtr                 uintptr
	FnumCommands             TTcl_Size
	FexceptDepth             TTcl_Size
	FmaxExceptDepth          TTcl_Size
	FmaxStackDepth           TTcl_Size
	FcurrStackDepth          TTcl_Size
	FlocalLitTable           TLiteralTable
	FcodeStart               uintptr
	FcodeNext                uintptr
	FcodeEnd                 uintptr
	FmallocedCodeArray       int32
	FmallocedExceptArray     int32
	FliteralArrayPtr         uintptr
	FliteralArrayNext        TTcl_Size
	FliteralArrayEnd         TTcl_Size
	FmallocedLiteralArray    int32
	FexceptArrayPtr          uintptr
	FexceptArrayNext         TTcl_Size
	FexceptArrayEnd          TTcl_Size
	FexceptAuxArrayPtr       uintptr
	FcmdMapPtr               uintptr
	FcmdMapEnd               TTcl_Size
	FmallocedCmdMap          int32
	FmallocedAuxDataArray    int32
	FauxDataArrayPtr         uintptr
	FauxDataArrayNext        TTcl_Size
	FauxDataArrayEnd         TTcl_Size
	FstaticCodeSpace         [250]uint8
	FstaticLiteralSpace      [60]TLiteralEntry
	FstaticExceptArraySpace  [5]TExceptionRange
	FstaticExAuxArraySpace   [5]TExceptionAux
	FstaticCmdMapSpace       [40]TCmdLocation
	FstaticAuxDataArraySpace [5]TAuxData
	FextCmdMapPtr            uintptr
	Fline                    TTcl_Size
	FatCmdStart              int32
	FexpandCount             TTcl_Size
	FclNext                  uintptr
}

type TByteCode = struct {
	FinterpHandle    TTclHandle
	FcompileEpoch    TTcl_Size
	FnsPtr           uintptr
	FnsEpoch         TTcl_Size
	FrefCount        TTcl_Size
	Fflags           uint32
	Fsource          uintptr
	FprocPtr         uintptr
	FstructureSize   Tsize_t
	FnumCommands     TTcl_Size
	FnumSrcBytes     TTcl_Size
	FnumCodeBytes    TTcl_Size
	FnumLitObjects   TTcl_Size
	FnumExceptRanges TTcl_Size
	FnumAuxDataItems TTcl_Size
	FnumCmdLocBytes  TTcl_Size
	FmaxExceptDepth  TTcl_Size
	FmaxStackDepth   TTcl_Size
	FcodeStart       uintptr
	FobjArrayPtr     uintptr
	FexceptArrayPtr  uintptr
	FauxDataArrayPtr uintptr
	FcodeDeltaStart  uintptr
	FcodeLengthStart uintptr
	FsrcDeltaStart   uintptr
	FsrcLengthStart  uintptr
	FlocalCachePtr   uintptr
}

type TclInstruction = int32

const INST_DONE = 0
const INST_PUSH1 = 1
const INST_PUSH4 = 2
const INST_POP = 3
const INST_DUP = 4
const INST_STR_CONCAT1 = 5
const INST_INVOKE_STK1 = 6
const INST_INVOKE_STK4 = 7
const INST_EVAL_STK = 8
const INST_EXPR_STK = 9
const INST_LOAD_SCALAR1 = 10
const INST_LOAD_SCALAR4 = 11
const INST_LOAD_SCALAR_STK = 12
const INST_LOAD_ARRAY1 = 13
const INST_LOAD_ARRAY4 = 14
const INST_LOAD_ARRAY_STK = 15
const INST_LOAD_STK = 16
const INST_STORE_SCALAR1 = 17
const INST_STORE_SCALAR4 = 18
const INST_STORE_SCALAR_STK = 19
const INST_STORE_ARRAY1 = 20
const INST_STORE_ARRAY4 = 21
const INST_STORE_ARRAY_STK = 22
const INST_STORE_STK = 23
const INST_INCR_SCALAR1 = 24
const INST_INCR_SCALAR_STK = 25
const INST_INCR_ARRAY1 = 26
const INST_INCR_ARRAY_STK = 27
const INST_INCR_STK = 28
const INST_INCR_SCALAR1_IMM = 29
const INST_INCR_SCALAR_STK_IMM = 30
const INST_INCR_ARRAY1_IMM = 31
const INST_INCR_ARRAY_STK_IMM = 32
const INST_INCR_STK_IMM = 33
const INST_JUMP1 = 34
const INST_JUMP4 = 35
const INST_JUMP_TRUE1 = 36
const INST_JUMP_TRUE4 = 37
const INST_JUMP_FALSE1 = 38
const INST_JUMP_FALSE4 = 39
const INST_BITOR = 40
const INST_BITXOR = 41
const INST_BITAND = 42
const INST_EQ = 43
const INST_NEQ = 44
const INST_LT = 45
const INST_GT = 46
const INST_LE = 47
const INST_GE = 48
const INST_LSHIFT = 49
const INST_RSHIFT = 50
const INST_ADD = 51
const INST_SUB = 52
const INST_MULT = 53
const INST_DIV = 54
const INST_MOD = 55
const INST_UPLUS = 56
const INST_UMINUS = 57
const INST_BITNOT = 58
const INST_LNOT = 59
const INST_TRY_CVT_TO_NUMERIC = 60
const INST_BREAK = 61
const INST_CONTINUE = 62
const INST_BEGIN_CATCH4 = 63
const INST_END_CATCH = 64
const INST_PUSH_RESULT = 65
const INST_PUSH_RETURN_CODE = 66
const INST_STR_EQ = 67
const INST_STR_NEQ = 68
const INST_STR_CMP = 69
const INST_STR_LEN = 70
const INST_STR_INDEX = 71
const INST_STR_MATCH = 72
const INST_LIST = 73
const INST_LIST_INDEX = 74
const INST_LIST_LENGTH = 75
const INST_APPEND_SCALAR1 = 76
const INST_APPEND_SCALAR4 = 77
const INST_APPEND_ARRAY1 = 78
const INST_APPEND_ARRAY4 = 79
const INST_APPEND_ARRAY_STK = 80
const INST_APPEND_STK = 81
const INST_LAPPEND_SCALAR1 = 82
const INST_LAPPEND_SCALAR4 = 83
const INST_LAPPEND_ARRAY1 = 84
const INST_LAPPEND_ARRAY4 = 85
const INST_LAPPEND_ARRAY_STK = 86
const INST_LAPPEND_STK = 87
const INST_LIST_INDEX_MULTI = 88
const INST_OVER = 89
const INST_LSET_LIST = 90
const INST_LSET_FLAT = 91
const INST_RETURN_IMM = 92
const INST_EXPON = 93
const INST_EXPAND_START = 94
const INST_EXPAND_STKTOP = 95
const INST_INVOKE_EXPANDED = 96
const INST_LIST_INDEX_IMM = 97
const INST_LIST_RANGE_IMM = 98
const INST_START_CMD = 99
const INST_LIST_IN = 100
const INST_LIST_NOT_IN = 101
const INST_PUSH_RETURN_OPTIONS = 102
const INST_RETURN_STK = 103
const INST_DICT_GET = 104
const INST_DICT_SET = 105
const INST_DICT_UNSET = 106
const INST_DICT_INCR_IMM = 107
const INST_DICT_APPEND = 108
const INST_DICT_LAPPEND = 109
const INST_DICT_FIRST = 110
const INST_DICT_NEXT = 111
const INST_DICT_UPDATE_START = 112
const INST_DICT_UPDATE_END = 113
const INST_JUMP_TABLE = 114
const INST_UPVAR = 115
const INST_NSUPVAR = 116
const INST_VARIABLE = 117
const INST_SYNTAX = 118
const INST_REVERSE = 119
const INST_REGEXP = 120
const INST_EXIST_SCALAR = 121
const INST_EXIST_ARRAY = 122
const INST_EXIST_ARRAY_STK = 123
const INST_EXIST_STK = 124
const INST_NOP = 125
const INST_RETURN_CODE_BRANCH = 126
const INST_UNSET_SCALAR = 127
const INST_UNSET_ARRAY = 128
const INST_UNSET_ARRAY_STK = 129
const INST_UNSET_STK = 130
const INST_DICT_EXPAND = 131
const INST_DICT_RECOMBINE_STK = 132
const INST_DICT_RECOMBINE_IMM = 133
const INST_DICT_EXISTS = 134
const INST_DICT_VERIFY = 135
const INST_STR_MAP = 136
const INST_STR_FIND = 137
const INST_STR_FIND_LAST = 138
const INST_STR_RANGE_IMM = 139
const INST_STR_RANGE = 140
const INST_YIELD = 141
const INST_COROUTINE_NAME = 142
const INST_TAILCALL = 143
const INST_NS_CURRENT = 144
const INST_INFO_LEVEL_NUM = 145
const INST_INFO_LEVEL_ARGS = 146
const INST_RESOLVE_COMMAND = 147
const INST_TCLOO_SELF = 148
const INST_TCLOO_CLASS = 149
const INST_TCLOO_NS = 150
const INST_TCLOO_IS_OBJECT = 151
const INST_ARRAY_EXISTS_STK = 152
const INST_ARRAY_EXISTS_IMM = 153
const INST_ARRAY_MAKE_STK = 154
const INST_ARRAY_MAKE_IMM = 155
const INST_INVOKE_REPLACE = 156
const INST_LIST_CONCAT = 157
const INST_EXPAND_DROP = 158
const INST_FOREACH_START = 159
const INST_FOREACH_STEP = 160
const INST_FOREACH_END = 161
const INST_LMAP_COLLECT = 162
const INST_STR_TRIM = 163
const INST_STR_TRIM_LEFT = 164
const INST_STR_TRIM_RIGHT = 165
const INST_CONCAT_STK = 166
const INST_STR_UPPER = 167
const INST_STR_LOWER = 168
const INST_STR_TITLE = 169
const INST_STR_REPLACE = 170
const INST_ORIGIN_COMMAND = 171
const INST_TCLOO_NEXT = 172
const INST_TCLOO_NEXT_CLASS = 173
const INST_YIELD_TO_INVOKE = 174
const INST_NUM_TYPE = 175
const INST_TRY_CVT_TO_BOOLEAN = 176
const INST_STR_CLASS = 177
const INST_LAPPEND_LIST = 178
const INST_LAPPEND_LIST_ARRAY = 179
const INST_LAPPEND_LIST_ARRAY_STK = 180
const INST_LAPPEND_LIST_STK = 181
const INST_CLOCK_READ = 182
const INST_DICT_GET_DEF = 183
const INST_STR_LT = 184
const INST_STR_GT = 185
const INST_STR_LE = 186
const INST_STR_GE = 187
const INST_LREPLACE4 = 188
const INST_CONST_IMM = 189
const INST_CONST_STK = 190
const LAST_INST_OPCODE = 191

type TInstOperandType = int32

type InstOperandType = int32

const OPERAND_NONE = 0
const OPERAND_INT1 = 1
const OPERAND_INT4 = 2
const OPERAND_UINT1 = 3
const OPERAND_UINT4 = 4
const OPERAND_IDX4 = 5
const OPERAND_LVT1 = 6
const OPERAND_LVT4 = 7
const OPERAND_AUX4 = 8
const OPERAND_OFFSET1 = 9
const OPERAND_OFFSET4 = 10
const OPERAND_LIT1 = 11
const OPERAND_LIT4 = 12
const OPERAND_SCLS1 = 13

type TInstructionDesc = struct {
	Fname        uintptr
	FnumBytes    TTcl_Size
	FstackEffect int32
	FnumOperands int32
	FopTypes     [2]TInstOperandType
}

type TInstStringClassType = int32

type InstStringClassType = int32

const STR_CLASS_ALNUM = 0
const STR_CLASS_ALPHA = 1
const STR_CLASS_ASCII = 2
const STR_CLASS_CONTROL = 3
const STR_CLASS_DIGIT = 4
const STR_CLASS_GRAPH = 5
const STR_CLASS_LOWER = 6
const STR_CLASS_PRINT = 7
const STR_CLASS_PUNCT = 8
const STR_CLASS_SPACE = 9
const STR_CLASS_UPPER = 10
const STR_CLASS_WORD = 11
const STR_CLASS_XDIGIT = 12

type TStringClassDesc = struct {
	Fname       [8]uint8
	Fcomparator uintptr
}

type TTclJumpType = int32

const TCL_UNCONDITIONAL_JUMP = 0
const TCL_TRUE_JUMP = 1
const TCL_FALSE_JUMP = 2

type TJumpFixup = struct {
	FjumpType    TTclJumpType
	FcodeOffset  uint32
	FcmdIndex    int32
	FexceptIndex int32
}

type TJumpFixupArray = struct {
	Ffixup            uintptr
	Fnext             TTcl_Size
	Fend              TTcl_Size
	FmallocedArray    int32
	FstaticFixupSpace [10]TJumpFixup
}

type TForeachVarList = struct {
	FnumVars TTcl_Size
}

type TForeachInfo = struct {
	FnumLists       TTcl_Size
	FfirstValueTemp TTcl_Size
	FloopCtTemp     TTcl_Size
}

type TJumptableInfo = struct {
	FhashTable TTcl_HashTable
}

type TDictUpdateInfo = struct {
	Flength TTcl_Size
}

type TTclOpCmdClientData = struct {
	Fop       uintptr
	Fexpected uintptr
	Fi        struct {
		Fidentity [0]int32
		FnumArgs  int32
	}
}

type TTcl_Class = uintptr

type TTcl_Method = uintptr

type TTcl_Object = uintptr

type TTcl_ObjectContext = uintptr

type TTcl_MethodType = struct {
	Fversion    int32
	Fname       uintptr
	FcallProc   uintptr
	FdeleteProc uintptr
	FcloneProc  uintptr
}

type TTcl_MethodType2 = struct {
	Fversion    int32
	Fname       uintptr
	FcallProc   uintptr
	FdeleteProc uintptr
	FcloneProc  uintptr
}

type TclOOMethodVersion = int32

const TCL_OO_METHOD_VERSION_1 = 1
const TCL_OO_METHOD_VERSION_2 = 2

type TclOOMethodVisibilityFlags = int32

const TCL_OO_METHOD_PUBLIC = 1
const TCL_OO_METHOD_UNEXPORTED = 0
const TCL_OO_METHOD_PRIVATE = 32

type TTcl_ObjectMetadataType = struct {
	Fversion    int32
	Fname       uintptr
	FdeleteProc uintptr
	FcloneProc  uintptr
}

type TclOOMetadataVersion = int32

const TCL_OO_METADATA_VERSION_1 = 1

type TTclOOStubHooks = struct {
	FtclOOIntStubs uintptr
}

type TTclOOStubs = struct {
	Fmagic                         int32
	Fhooks                         uintptr
	Ftcl_CopyObjectInstance        uintptr
	Ftcl_GetClassAsObject          uintptr
	Ftcl_GetObjectAsClass          uintptr
	Ftcl_GetObjectCommand          uintptr
	Ftcl_GetObjectFromObj          uintptr
	Ftcl_GetObjectNamespace        uintptr
	Ftcl_MethodDeclarerClass       uintptr
	Ftcl_MethodDeclarerObject      uintptr
	Ftcl_MethodIsPublic            uintptr
	Ftcl_MethodIsType              uintptr
	Ftcl_MethodName                uintptr
	Ftcl_NewInstanceMethod         uintptr
	Ftcl_NewMethod                 uintptr
	Ftcl_NewObjectInstance         uintptr
	Ftcl_ObjectDeleted             uintptr
	Ftcl_ObjectContextIsFiltering  uintptr
	Ftcl_ObjectContextMethod       uintptr
	Ftcl_ObjectContextObject       uintptr
	Ftcl_ObjectContextSkippedArgs  uintptr
	Ftcl_ClassGetMetadata          uintptr
	Ftcl_ClassSetMetadata          uintptr
	Ftcl_ObjectGetMetadata         uintptr
	Ftcl_ObjectSetMetadata         uintptr
	Ftcl_ObjectContextInvokeNext   uintptr
	Ftcl_ObjectGetMethodNameMapper uintptr
	Ftcl_ObjectSetMethodNameMapper uintptr
	Ftcl_ClassSetConstructor       uintptr
	Ftcl_ClassSetDestructor        uintptr
	Ftcl_GetObjectName             uintptr
	Ftcl_MethodIsPrivate           uintptr
	Ftcl_GetClassOfObject          uintptr
	Ftcl_GetObjectClassName        uintptr
	Ftcl_MethodIsType2             uintptr
	Ftcl_NewInstanceMethod2        uintptr
	Ftcl_NewMethod2                uintptr
}

type TCallChain = struct {
	FobjectCreationEpoch TTcl_Size
	FobjectEpoch         TTcl_Size
	Fepoch               TTcl_Size
	Fflags               int32
	FrefCount            TTcl_Size
	FnumChain            TTcl_Size
	Fchain               uintptr
	FstaticChain         [4]TMInvoke
}

type TCallContext = struct {
	FoPtr    uintptr
	Findex   TTcl_Size
	Fskip    TTcl_Size
	FcallPtr uintptr
}

type TClass = struct {
	FthisPtr             uintptr
	Fflags               int32
	Fsuperclasses        TClassList
	Fsubclasses          TVarClassList
	Finstances           TObjectList
	Ffilters             TFilterList
	Fmixins              TClassList
	FmixinSubs           TVarClassList
	FclassMethods        TTcl_HashTable
	FconstructorPtr      uintptr
	FdestructorPtr       uintptr
	FmetadataPtr         uintptr
	FconstructorChainPtr uintptr
	FdestructorChainPtr  uintptr
	FclassChainCache     uintptr
	Fvariables           TVariableNameList
	FprivateVariables    TPrivateVariableList
	FclsDefinitionNs     uintptr
	FobjDefinitionNs     uintptr
	Fproperties          TPropertyStorage
}

type TDeclaredClassMethod = struct {
	Fname       uintptr
	FisPublic   int32
	Fdefinition TTcl_MethodType
}

type TForwardMethod = struct {
	FprefixObj uintptr
}

type TFoundation = struct {
	Finterp               uintptr
	FobjectCls            uintptr
	FclassCls             uintptr
	FooNs                 uintptr
	FhelpersNs            uintptr
	Fepoch                TTcl_Size
	FtsdPtr               uintptr
	FunknownMethodNameObj uintptr
	FconstructorName      uintptr
	FdestructorName       uintptr
	FclonedName           uintptr
	FdefineName           uintptr
	FmyName               uintptr
	FmcdName              uintptr
}

type TMethod = struct {
	F__ccgo0_0 struct {
		Ftype2Ptr [0]uintptr
		FtypePtr  uintptr
	}
	FrefCount           TTcl_Size
	FclientData         uintptr
	FnamePtr            uintptr
	FdeclaringObjectPtr uintptr
	FdeclaringClassPtr  uintptr
	Fflags              int32
}

type TMInvoke = struct {
	FmPtr           uintptr
	FisFilter       int32
	FfilterDeclarer uintptr
}

type TObject = struct {
	FfPtr              uintptr
	FnamespacePtr      uintptr
	Fcommand           TTcl_Command
	FmyCommand         TTcl_Command
	FselfCls           uintptr
	FmethodsPtr        uintptr
	Fmixins            TClassList
	Ffilters           TFilterList
	FclassPtr          uintptr
	FrefCount          TTcl_Size
	Fflags             int32
	FcreationEpoch     TTcl_Size
	Fepoch             TTcl_Size
	FmetadataPtr       uintptr
	FcachedNameObj     uintptr
	FchainCache        uintptr
	FmapMethodNameProc uintptr
	Fvariables         TVariableNameList
	FprivateVariables  TPrivateVariableList
	FmyclassCommand    TTcl_Command
	Fproperties        TPropertyStorage
}

type TPrivateVariableMapping = struct {
	FvariableObj uintptr
	FfullNameObj uintptr
}

type TProcedureMethod = struct {
	Fversion              int32
	FprocPtr              uintptr
	Fflags                int32
	FrefCount             TTcl_Size
	FclientData           uintptr
	FdeleteClientdataProc uintptr
	FcloneClientdataProc  uintptr
	FerrProc              uintptr
	FpreCallProc          uintptr
	FpostCallProc         uintptr
	FgfivProc             uintptr
	Fcmd                  TCommand
	Fefi                  TExtraFrameInfo
	Finterp               uintptr
	Fmethod               TTcl_Method
	FcallSiteFlags        int32
}

type TPropertyStorage = struct {
	Freadable         TPropertyList
	Fwritable         TPropertyList
	FallReadableCache uintptr
	FallWritableCache uintptr
	Fepoch            int32
}

type TMethod1 = struct {
	F__ccgo0_0 struct {
		Ftype2Ptr [0]uintptr
		FtypePtr  uintptr
	}
	FrefCount           TTcl_Size
	FclientData         uintptr
	FnamePtr            uintptr
	FdeclaringObjectPtr uintptr
	FdeclaringClassPtr  uintptr
	Fflags              int32
}

type TProcedureMethod1 = struct {
	Fversion              int32
	FprocPtr              uintptr
	Fflags                int32
	FrefCount             TTcl_Size
	FclientData           uintptr
	FdeleteClientdataProc uintptr
	FcloneClientdataProc  uintptr
	FerrProc              uintptr
	FpreCallProc          uintptr
	FpostCallProc         uintptr
	FgfivProc             uintptr
	Fcmd                  TCommand
	Fefi                  TExtraFrameInfo
	Finterp               uintptr
	Fmethod               TTcl_Method
	FcallSiteFlags        int32
}

type ProcedureMethodVersion = int32

const TCLOO_PROCEDURE_METHOD_VERSION_1 = 0

type ProceudreMethodFlags = int32

const USE_DECLARER_NS = 128

type TForwardMethod1 = struct {
	FprefixObj uintptr
}

type TPrivateVariableMapping1 = struct {
	FvariableObj uintptr
	FfullNameObj uintptr
}

type TClassList = struct {
	Fnum  TTcl_Size
	Flist uintptr
}

type TVarClassList = struct {
	Fnum  TTcl_Size
	Fsize TTcl_Size
	Flist uintptr
}

type TFilterList = struct {
	Fnum  TTcl_Size
	Flist uintptr
}

type TObjectList = struct {
	Fnum  TTcl_Size
	Fsize TTcl_Size
	Flist uintptr
}

type TVariableNameList = struct {
	Fnum  TTcl_Size
	Flist uintptr
}

type TPrivateVariableList = struct {
	Fnum  TTcl_Size
	Flist uintptr
}

type TPropertyList = struct {
	Fnum  TTcl_Size
	Flist uintptr
}

type TPropertyStorage1 = struct {
	Freadable         TPropertyList
	Fwritable         TPropertyList
	FallReadableCache uintptr
	FallWritableCache uintptr
	Fepoch            int32
}

type TObject1 = struct {
	FfPtr              uintptr
	FnamespacePtr      uintptr
	Fcommand           TTcl_Command
	FmyCommand         TTcl_Command
	FselfCls           uintptr
	FmethodsPtr        uintptr
	Fmixins            TClassList
	Ffilters           TFilterList
	FclassPtr          uintptr
	FrefCount          TTcl_Size
	Fflags             int32
	FcreationEpoch     TTcl_Size
	Fepoch             TTcl_Size
	FmetadataPtr       uintptr
	FcachedNameObj     uintptr
	FchainCache        uintptr
	FmapMethodNameProc uintptr
	Fvariables         TVariableNameList
	FprivateVariables  TPrivateVariableList
	FmyclassCommand    TTcl_Command
	Fproperties        TPropertyStorage
}

type ObjectFlags = int32

const OBJECT_DESTRUCTING = 1
const DESTRUCTOR_CALLED = 2
const ROOT_OBJECT = 4096
const FILTER_HANDLING = 8192
const USE_CLASS_CACHE = 16384
const ROOT_CLASS = 32768
const FORCE_UNKNOWN = 65536
const DONT_DELETE = 131072
const HAS_PRIVATE_METHODS = 262144

type TClass1 = struct {
	FthisPtr             uintptr
	Fflags               int32
	Fsuperclasses        TClassList
	Fsubclasses          TVarClassList
	Finstances           TObjectList
	Ffilters             TFilterList
	Fmixins              TClassList
	FmixinSubs           TVarClassList
	FclassMethods        TTcl_HashTable
	FconstructorPtr      uintptr
	FdestructorPtr       uintptr
	FmetadataPtr         uintptr
	FconstructorChainPtr uintptr
	FdestructorChainPtr  uintptr
	FclassChainCache     uintptr
	Fvariables           TVariableNameList
	FprivateVariables    TPrivateVariableList
	FclsDefinitionNs     uintptr
	FobjDefinitionNs     uintptr
	Fproperties          TPropertyStorage
}

type TThreadLocalData = struct {
	FnsCount TTcl_Size
}

type TFoundation1 = struct {
	Finterp               uintptr
	FobjectCls            uintptr
	FclassCls             uintptr
	FooNs                 uintptr
	FhelpersNs            uintptr
	Fepoch                TTcl_Size
	FtsdPtr               uintptr
	FunknownMethodNameObj uintptr
	FconstructorName      uintptr
	FdestructorName       uintptr
	FclonedName           uintptr
	FdefineName           uintptr
	FmyName               uintptr
	FmcdName              uintptr
}

type TMInvoke1 = struct {
	FmPtr           uintptr
	FisFilter       int32
	FfilterDeclarer uintptr
}

type TCallChain1 = struct {
	FobjectCreationEpoch TTcl_Size
	FobjectEpoch         TTcl_Size
	Fepoch               TTcl_Size
	Fflags               int32
	FrefCount            TTcl_Size
	FnumChain            TTcl_Size
	Fchain               uintptr
	FstaticChain         [4]TMInvoke
}

type TCallContext1 = struct {
	FoPtr    uintptr
	Findex   TTcl_Size
	Fskip    TTcl_Size
	FcallPtr uintptr
}

type TclOOCallChainFlags = int32

const PUBLIC_METHOD = 1
const PRIVATE_METHOD = 2
const OO_UNKNOWN_METHOD = 4
const CONSTRUCTOR = 8
const DESTRUCTOR = 16
const TRUE_PRIVATE_METHOD = 32

type TDeclaredClassMethod1 = struct {
	Fname       uintptr
	FisPublic   int32
	Fdefinition TTcl_MethodType
}

type TTclOOIntStubs = struct {
	Fmagic                         int32
	Fhooks                         uintptr
	FtclOOGetDefineCmdContext      uintptr
	FtclOOMakeProcInstanceMethod   uintptr
	FtclOOMakeProcMethod           uintptr
	FtclOONewProcInstanceMethod    uintptr
	FtclOONewProcMethod            uintptr
	FtclOOObjectCmdCore            uintptr
	FtclOOIsReachable              uintptr
	FtclOONewForwardMethod         uintptr
	FtclOONewForwardInstanceMethod uintptr
	FtclOONewProcInstanceMethodEx  uintptr
	FtclOONewProcMethodEx          uintptr
	FtclOOInvokeObject             uintptr
	FtclOOObjectSetFilters         uintptr
	FtclOOClassSetFilters          uintptr
	FtclOOObjectSetMixins          uintptr
	FtclOOClassSetMixins           uintptr
}

/*
 * Structure that represents a range of instructions in the bytecode.
 */

type TCodeRange = struct {
	FstartOffset int32
	FendOffset   int32
}

/*
 * State identified for a basic block's catch context.
 */

type TBasicBlockCatchState = int32

/*
 * State identified for a basic block's catch context.
 */

type BasicBlockCatchState = int32

const BBCS_UNKNOWN = 0
const /* Catch context has not yet been identified */
BBCS_NONE = 1
const /* Block is outside of any catch */
BBCS_INCATCH = 2
const /* Block is within a catch context */
BBCS_CAUGHT = 3

/*
 * Structure that defines a basic block - a linear sequence of bytecode
 * instructions with no jumps in or out (including not changing the
 * state of any exception range).
 */

type TBasicBlock = struct {
	ForiginalStartOffset   int32
	FstartOffset           int32
	FstartLine             int32
	FjumpOffset            int32
	FjumpLine              int32
	FprevPtr               uintptr
	Fpredecessor           uintptr
	Fsuccessor1            uintptr
	FjumpTarget            uintptr
	FinitialStackDepth     int32
	FminStackDepth         int32
	FmaxStackDepth         int32
	FfinalStackDepth       int32
	FcatchState            BasicBlockCatchState
	FcatchDepth            int32
	FenclosingCatch        uintptr
	FforeignExceptionBase  int32
	FforeignExceptionCount int32
	FforeignExceptions     uintptr
	FjtPtr                 uintptr
	Fflags                 int32
}

/*
 * Flags that pertain to a basic block.
 */

type BasicBlockFlags = int32

const BB_VISITED = 1
const /* Block has been visited in the current
 * traversal */
BB_FALLTHRU = 2
const /* Control may pass from this block to a
 * successor */
BB_JUMP1 = 4
const /* Basic block ends with a 1-byte-offset jump
 * and may need expansion */
BB_JUMPTABLE = 8
const /* Basic block ends with a jump table */
BB_BEGINCATCH = 16
const /* Block ends with a 'beginCatch' instruction,
 * marking it as the start of a 'catch'
 * sequence. The 'jumpTarget' is the exception
 * exit from the catch block. */
BB_ENDCATCH = 32

/*
 * Source instruction type recognized by the assembler.
 */

type TTalInstType = int32

const ASSEM_1BYTE = 0
const /* Fixed arity, 1-byte instruction */
ASSEM_BEGIN_CATCH = 1
const /* Begin catch: one 4-byte jump offset to be
 * converted to appropriate exception
 * ranges */
ASSEM_BOOL = 2
const /* One Boolean operand */
ASSEM_BOOL_LVT4 = 3
const /* One Boolean, one 4-byte LVT ref. */
ASSEM_CLOCK_READ = 4
const /* 1-byte unsigned-integer case number, in the
 * range 0-3 */
ASSEM_CONCAT1 = 5
const /* 1-byte unsigned-integer operand count, must
 * be strictly positive, consumes N, produces
 * 1 */
ASSEM_DICT_GET = 6
const /* 'dict get' and related - consumes N+1
 * operands, produces 1, N > 0 */
ASSEM_DICT_SET = 7
const /* specifies key count and LVT index, consumes
 * N+1 operands, produces 1, N > 0 */
ASSEM_DICT_UNSET = 8
const /* specifies key count and LVT index, consumes
 * N operands, produces 1, N > 0 */
ASSEM_END_CATCH = 9
const /* End catch. No args. Exception range popped
 * from stack and stack pointer restored. */
ASSEM_EVAL = 10
const /* 'eval' - evaluate a constant script (by
 * compiling it in line with the assembly
 * code! I love Tcl!) */
ASSEM_INDEX = 11
const /* 4 byte operand, integer or end-integer */
ASSEM_INVOKE = 12
const /* 1- or 4-byte operand count, must be
 * strictly positive, consumes N, produces
 * 1. */
ASSEM_JUMP = 13
const /* Jump instructions */
ASSEM_JUMP4 = 14
const /* Jump instructions forcing a 4-byte offset */
ASSEM_JUMPTABLE = 15
const /* Jumptable (switch -exact) */
ASSEM_LABEL = 16
const /* The assembly directive that defines a
 * label */
ASSEM_LINDEX_MULTI = 17
const /* 4-byte operand count, must be strictly
 * positive, consumes N, produces 1 */
ASSEM_LIST = 18
const /* 4-byte operand count, must be nonnegative,
 * consumses N, produces 1 */
ASSEM_LSET_FLAT = 19
const /* 4-byte operand count, must be >= 3,
 * consumes N, produces 1 */
ASSEM_LVT = 20
const /* One operand that references a local
 * variable */
ASSEM_LVT1 = 21
const /* One 1-byte operand that references a local
 * variable */
ASSEM_LVT1_SINT1 = 22
const /* One 1-byte operand that references a local
 * variable, one signed-integer 1-byte
 * operand */
ASSEM_LVT4 = 23
const /* One 4-byte operand that references a local
 * variable */
ASSEM_OVER = 24
const /* OVER: 4-byte operand count, consumes N+1,
 * produces N+2 */
ASSEM_PUSH = 25
const /* one literal operand */
ASSEM_REGEXP = 26
const /* One Boolean operand, but weird mapping to
 * call flags */
ASSEM_REVERSE = 27
const /* REVERSE: 4-byte operand count, consumes N,
 * produces N */
ASSEM_SINT1 = 28
const /* One 1-byte signed-integer operand
 * (INCR_STK_IMM) */
ASSEM_SINT4_LVT4 = 29
const /* Signed 4-byte integer operand followed by
 * LVT entry.  Fixed arity */
ASSEM_DICT_GET_DEF = 30

/*
 * Description of an instruction recognized by the assembler.
 */

type TTalInstDesc = struct {
	Fname             uintptr
	FinstType         TTalInstType
	FtclInstCode      int32
	FoperandsConsumed int32
	FoperandsProduced int32
}

/*
 * Structure that holds the state of the assembler while generating code.
 */

type TAssemblyEnv = struct {
	FenvPtr        uintptr
	FparsePtr      uintptr
	FlabelHash     TTcl_HashTable
	FcmdLine       TTcl_Size
	FclNext        uintptr
	Fhead_bb       uintptr
	Fcurr_bb       uintptr
	FmaxDepth      int32
	FcurCatchDepth int32
	FmaxCatchDepth int32
	Fflags         int32
}

var _assembleCodeType = TTcl_ObjType{
	Fname: __ccgo_ts + 2103,
}

func init() {
	p := unsafe.Pointer(&_assembleCodeType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_FreeAssembleCodeInternalRep)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_DupAssembleCodeInternalRep)
}

/*
 * Source instructions recognized in the Tcl Assembly Language (TAL)
 */

var _TalInstructionTable = [151]TTalInstDesc{
	0: {
		Fname:             __ccgo_ts + 2116,
		FinstType:         int32(ASSEM_PUSH),
		FtclInstCode:      int32(INST_PUSH1)<<libc.Int32FromInt32(8) | int32(INST_PUSH4),
		FoperandsProduced: int32(1),
	},
	1: {
		Fname:             __ccgo_ts + 2121,
		FtclInstCode:      int32(INST_ADD),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	2: {
		Fname:             __ccgo_ts + 2125,
		FinstType:         int32(ASSEM_LVT),
		FtclInstCode:      int32(INST_APPEND_SCALAR1)<<libc.Int32FromInt32(8) | int32(INST_APPEND_SCALAR4),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	3: {
		Fname:             __ccgo_ts + 2132,
		FinstType:         int32(ASSEM_LVT),
		FtclInstCode:      int32(INST_APPEND_ARRAY1)<<libc.Int32FromInt32(8) | int32(INST_APPEND_ARRAY4),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	4: {
		Fname:             __ccgo_ts + 2144,
		FtclInstCode:      int32(INST_APPEND_ARRAY_STK),
		FoperandsConsumed: int32(3),
		FoperandsProduced: int32(1),
	},
	5: {
		Fname:             __ccgo_ts + 2159,
		FtclInstCode:      int32(INST_APPEND_STK),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	6: {
		Fname:             __ccgo_ts + 2169,
		FinstType:         int32(ASSEM_LVT4),
		FtclInstCode:      int32(INST_ARRAY_EXISTS_IMM),
		FoperandsProduced: int32(1),
	},
	7: {
		Fname:             __ccgo_ts + 2184,
		FtclInstCode:      int32(INST_ARRAY_EXISTS_STK),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	8: {
		Fname:        __ccgo_ts + 2199,
		FinstType:    int32(ASSEM_LVT4),
		FtclInstCode: int32(INST_ARRAY_MAKE_IMM),
	},
	9: {
		Fname:             __ccgo_ts + 2212,
		FtclInstCode:      int32(INST_ARRAY_MAKE_STK),
		FoperandsConsumed: int32(1),
	},
	10: {
		Fname:        __ccgo_ts + 2225,
		FinstType:    int32(ASSEM_BEGIN_CATCH),
		FtclInstCode: int32(INST_BEGIN_CATCH4),
	},
	11: {
		Fname:             __ccgo_ts + 2236,
		FtclInstCode:      int32(INST_BITAND),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	12: {
		Fname:             __ccgo_ts + 2243,
		FtclInstCode:      int32(INST_BITNOT),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	13: {
		Fname:             __ccgo_ts + 2250,
		FtclInstCode:      int32(INST_BITOR),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	14: {
		Fname:             __ccgo_ts + 2256,
		FtclInstCode:      int32(INST_BITXOR),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	15: {
		Fname:             __ccgo_ts + 2263,
		FinstType:         int32(ASSEM_CLOCK_READ),
		FtclInstCode:      int32(INST_CLOCK_READ),
		FoperandsProduced: int32(1),
	},
	16: {
		Fname:             __ccgo_ts + 2273,
		FinstType:         int32(ASSEM_CONCAT1),
		FtclInstCode:      int32(INST_STR_CONCAT1),
		FoperandsConsumed: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FoperandsProduced: int32(1),
	},
	17: {
		Fname:             __ccgo_ts + 2280,
		FinstType:         int32(ASSEM_LIST),
		FtclInstCode:      int32(INST_CONCAT_STK),
		FoperandsConsumed: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FoperandsProduced: int32(1),
	},
	18: {
		Fname:             __ccgo_ts + 2290,
		FtclInstCode:      int32(INST_COROUTINE_NAME),
		FoperandsProduced: int32(1),
	},
	19: {
		Fname:             __ccgo_ts + 2299,
		FtclInstCode:      int32(INST_NS_CURRENT),
		FoperandsProduced: int32(1),
	},
	20: {
		Fname:             __ccgo_ts + 2316,
		FinstType:         int32(ASSEM_LVT4),
		FtclInstCode:      int32(INST_DICT_APPEND),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	21: {
		Fname:             __ccgo_ts + 2327,
		FinstType:         int32(ASSEM_DICT_GET),
		FtclInstCode:      int32(INST_DICT_EXISTS),
		FoperandsConsumed: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FoperandsProduced: int32(1),
	},
	22: {
		Fname:             __ccgo_ts + 2338,
		FtclInstCode:      int32(INST_DICT_EXPAND),
		FoperandsConsumed: int32(3),
		FoperandsProduced: int32(1),
	},
	23: {
		Fname:             __ccgo_ts + 2349,
		FinstType:         int32(ASSEM_DICT_GET),
		FtclInstCode:      int32(INST_DICT_GET),
		FoperandsConsumed: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FoperandsProduced: int32(1),
	},
	24: {
		Fname:             __ccgo_ts + 2357,
		FinstType:         int32(ASSEM_DICT_GET_DEF),
		FtclInstCode:      int32(INST_DICT_GET_DEF),
		FoperandsConsumed: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FoperandsProduced: int32(1),
	},
	25: {
		Fname:             __ccgo_ts + 2368,
		FinstType:         int32(ASSEM_SINT4_LVT4),
		FtclInstCode:      int32(INST_DICT_INCR_IMM),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	26: {
		Fname:             __ccgo_ts + 2380,
		FinstType:         int32(ASSEM_LVT4),
		FtclInstCode:      int32(INST_DICT_LAPPEND),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	27: {
		Fname:             __ccgo_ts + 2392,
		FtclInstCode:      int32(INST_DICT_RECOMBINE_STK),
		FoperandsConsumed: int32(3),
	},
	28: {
		Fname:             __ccgo_ts + 2409,
		FinstType:         int32(ASSEM_LVT4),
		FtclInstCode:      int32(INST_DICT_RECOMBINE_IMM),
		FoperandsConsumed: int32(2),
	},
	29: {
		Fname:             __ccgo_ts + 2426,
		FinstType:         int32(ASSEM_DICT_SET),
		FtclInstCode:      int32(INST_DICT_SET),
		FoperandsConsumed: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FoperandsProduced: int32(1),
	},
	30: {
		Fname:             __ccgo_ts + 2434,
		FinstType:         int32(ASSEM_DICT_UNSET),
		FtclInstCode:      int32(INST_DICT_UNSET),
		FoperandsConsumed: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FoperandsProduced: int32(1),
	},
	31: {
		Fname:             __ccgo_ts + 2444,
		FtclInstCode:      int32(INST_DIV),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	32: {
		Fname:             __ccgo_ts + 2448,
		FtclInstCode:      int32(INST_DUP),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(2),
	},
	33: {
		Fname:        __ccgo_ts + 2452,
		FinstType:    int32(ASSEM_END_CATCH),
		FtclInstCode: int32(INST_END_CATCH),
	},
	34: {
		Fname:             __ccgo_ts + 2461,
		FtclInstCode:      int32(INST_EQ),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	35: {
		Fname:             __ccgo_ts + 2464,
		FinstType:         int32(ASSEM_EVAL),
		FtclInstCode:      int32(INST_EVAL_STK),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	36: {
		Fname:             __ccgo_ts + 2469,
		FtclInstCode:      int32(INST_EVAL_STK),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	37: {
		Fname:             __ccgo_ts + 2477,
		FinstType:         int32(ASSEM_LVT4),
		FtclInstCode:      int32(INST_EXIST_SCALAR),
		FoperandsProduced: int32(1),
	},
	38: {
		Fname:             __ccgo_ts + 2483,
		FinstType:         int32(ASSEM_LVT4),
		FtclInstCode:      int32(INST_EXIST_ARRAY),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	39: {
		Fname:             __ccgo_ts + 2494,
		FtclInstCode:      int32(INST_EXIST_ARRAY_STK),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	40: {
		Fname:             __ccgo_ts + 2508,
		FtclInstCode:      int32(INST_EXIST_STK),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	41: {
		Fname:             __ccgo_ts + 2517,
		FtclInstCode:      int32(INST_EXPON),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	42: {
		Fname:             __ccgo_ts + 2523,
		FinstType:         int32(ASSEM_EVAL),
		FtclInstCode:      int32(INST_EXPR_STK),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	43: {
		Fname:             __ccgo_ts + 2528,
		FtclInstCode:      int32(INST_EXPR_STK),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	44: {
		Fname:             __ccgo_ts + 2536,
		FtclInstCode:      int32(INST_GE),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	45: {
		Fname:             __ccgo_ts + 2539,
		FtclInstCode:      int32(INST_GT),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	46: {
		Fname:             __ccgo_ts + 2542,
		FinstType:         int32(ASSEM_LVT1),
		FtclInstCode:      int32(INST_INCR_SCALAR1),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	47: {
		Fname:             __ccgo_ts + 2547,
		FinstType:         int32(ASSEM_LVT1),
		FtclInstCode:      int32(INST_INCR_ARRAY1),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	48: {
		Fname:             __ccgo_ts + 2557,
		FinstType:         int32(ASSEM_LVT1_SINT1),
		FtclInstCode:      int32(INST_INCR_ARRAY1_IMM),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	49: {
		Fname:             __ccgo_ts + 2570,
		FtclInstCode:      int32(INST_INCR_ARRAY_STK),
		FoperandsConsumed: int32(3),
		FoperandsProduced: int32(1),
	},
	50: {
		Fname:             __ccgo_ts + 2583,
		FinstType:         int32(ASSEM_SINT1),
		FtclInstCode:      int32(INST_INCR_ARRAY_STK_IMM),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	51: {
		Fname:             __ccgo_ts + 2599,
		FinstType:         int32(ASSEM_LVT1_SINT1),
		FtclInstCode:      int32(INST_INCR_SCALAR1_IMM),
		FoperandsProduced: int32(1),
	},
	52: {
		Fname:             __ccgo_ts + 2607,
		FtclInstCode:      int32(INST_INCR_STK),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	53: {
		Fname:             __ccgo_ts + 2615,
		FinstType:         int32(ASSEM_SINT1),
		FtclInstCode:      int32(INST_INCR_STK_IMM),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	54: {
		Fname:             __ccgo_ts + 2626,
		FtclInstCode:      int32(INST_INFO_LEVEL_ARGS),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	55: {
		Fname:             __ccgo_ts + 2640,
		FtclInstCode:      int32(INST_INFO_LEVEL_NUM),
		FoperandsProduced: int32(1),
	},
	56: {
		Fname:             __ccgo_ts + 2656,
		FinstType:         int32(ASSEM_INVOKE),
		FtclInstCode:      int32(INST_INVOKE_STK1)<<libc.Int32FromInt32(8) | int32(INST_INVOKE_STK4),
		FoperandsConsumed: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FoperandsProduced: int32(1),
	},
	57: {
		Fname:        __ccgo_ts + 2666,
		FinstType:    int32(ASSEM_JUMP),
		FtclInstCode: int32(INST_JUMP1),
	},
	58: {
		Fname:        __ccgo_ts + 2671,
		FinstType:    int32(ASSEM_JUMP4),
		FtclInstCode: int32(INST_JUMP4),
	},
	59: {
		Fname:             __ccgo_ts + 2677,
		FinstType:         int32(ASSEM_JUMP),
		FtclInstCode:      int32(INST_JUMP_FALSE1),
		FoperandsConsumed: int32(1),
	},
	60: {
		Fname:             __ccgo_ts + 2687,
		FinstType:         int32(ASSEM_JUMP4),
		FtclInstCode:      int32(INST_JUMP_FALSE4),
		FoperandsConsumed: int32(1),
	},
	61: {
		Fname:             __ccgo_ts + 2698,
		FinstType:         int32(ASSEM_JUMPTABLE),
		FtclInstCode:      int32(INST_JUMP_TABLE),
		FoperandsConsumed: int32(1),
	},
	62: {
		Fname:             __ccgo_ts + 2708,
		FinstType:         int32(ASSEM_JUMP),
		FtclInstCode:      int32(INST_JUMP_TRUE1),
		FoperandsConsumed: int32(1),
	},
	63: {
		Fname:             __ccgo_ts + 2717,
		FinstType:         int32(ASSEM_JUMP4),
		FtclInstCode:      int32(INST_JUMP_TRUE4),
		FoperandsConsumed: int32(1),
	},
	64: {
		Fname:     __ccgo_ts + 2727,
		FinstType: int32(ASSEM_LABEL),
	},
	65: {
		Fname:             __ccgo_ts + 2733,
		FinstType:         int32(ASSEM_LVT),
		FtclInstCode:      int32(INST_LAPPEND_SCALAR1)<<libc.Int32FromInt32(8) | int32(INST_LAPPEND_SCALAR4),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	66: {
		Fname:             __ccgo_ts + 2741,
		FinstType:         int32(ASSEM_LVT),
		FtclInstCode:      int32(INST_LAPPEND_ARRAY1)<<libc.Int32FromInt32(8) | int32(INST_LAPPEND_ARRAY4),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	67: {
		Fname:             __ccgo_ts + 2754,
		FtclInstCode:      int32(INST_LAPPEND_ARRAY_STK),
		FoperandsConsumed: int32(3),
		FoperandsProduced: int32(1),
	},
	68: {
		Fname:             __ccgo_ts + 2770,
		FinstType:         int32(ASSEM_LVT4),
		FtclInstCode:      int32(INST_LAPPEND_LIST),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	69: {
		Fname:             __ccgo_ts + 2782,
		FinstType:         int32(ASSEM_LVT4),
		FtclInstCode:      int32(INST_LAPPEND_LIST_ARRAY),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	70: {
		Fname:             __ccgo_ts + 2799,
		FtclInstCode:      int32(INST_LAPPEND_LIST_ARRAY_STK),
		FoperandsConsumed: int32(3),
		FoperandsProduced: int32(1),
	},
	71: {
		Fname:             __ccgo_ts + 2819,
		FtclInstCode:      int32(INST_LAPPEND_LIST_STK),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	72: {
		Fname:             __ccgo_ts + 2834,
		FtclInstCode:      int32(INST_LAPPEND_STK),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	73: {
		Fname:             __ccgo_ts + 2845,
		FtclInstCode:      int32(INST_LE),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	74: {
		Fname:             __ccgo_ts + 2848,
		FinstType:         int32(ASSEM_LINDEX_MULTI),
		FtclInstCode:      int32(INST_LIST_INDEX_MULTI),
		FoperandsConsumed: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FoperandsProduced: int32(1),
	},
	75: {
		Fname:             __ccgo_ts + 2860,
		FinstType:         int32(ASSEM_LIST),
		FtclInstCode:      int32(INST_LIST),
		FoperandsConsumed: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FoperandsProduced: int32(1),
	},
	76: {
		Fname:             __ccgo_ts + 2865,
		FtclInstCode:      int32(INST_LIST_CONCAT),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	77: {
		Fname:             __ccgo_ts + 2876,
		FtclInstCode:      int32(INST_LIST_IN),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	78: {
		Fname:             __ccgo_ts + 2883,
		FtclInstCode:      int32(INST_LIST_INDEX),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	79: {
		Fname:             __ccgo_ts + 2893,
		FinstType:         int32(ASSEM_INDEX),
		FtclInstCode:      int32(INST_LIST_INDEX_IMM),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	80: {
		Fname:             __ccgo_ts + 2906,
		FtclInstCode:      int32(INST_LIST_LENGTH),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	81: {
		Fname:             __ccgo_ts + 2917,
		FtclInstCode:      int32(INST_LIST_NOT_IN),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	82: {
		Fname:             __ccgo_ts + 2927,
		FinstType:         int32(ASSEM_LVT),
		FtclInstCode:      int32(INST_LOAD_SCALAR1)<<libc.Int32FromInt32(8) | int32(INST_LOAD_SCALAR4),
		FoperandsProduced: int32(1),
	},
	83: {
		Fname:             __ccgo_ts + 2932,
		FinstType:         int32(ASSEM_LVT),
		FtclInstCode:      int32(INST_LOAD_ARRAY1)<<libc.Int32FromInt32(8) | int32(INST_LOAD_ARRAY4),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	84: {
		Fname:             __ccgo_ts + 2942,
		FtclInstCode:      int32(INST_LOAD_ARRAY_STK),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	85: {
		Fname:             __ccgo_ts + 2955,
		FtclInstCode:      int32(INST_LOAD_STK),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	86: {
		Fname:             __ccgo_ts + 2963,
		FinstType:         int32(ASSEM_LSET_FLAT),
		FtclInstCode:      int32(INST_LSET_FLAT),
		FoperandsConsumed: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FoperandsProduced: int32(1),
	},
	87: {
		Fname:             __ccgo_ts + 2972,
		FtclInstCode:      int32(INST_LSET_LIST),
		FoperandsConsumed: int32(3),
		FoperandsProduced: int32(1),
	},
	88: {
		Fname:             __ccgo_ts + 2981,
		FtclInstCode:      int32(INST_LSHIFT),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	89: {
		Fname:             __ccgo_ts + 2988,
		FtclInstCode:      int32(INST_LT),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	90: {
		Fname:             __ccgo_ts + 2991,
		FtclInstCode:      int32(INST_MOD),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	91: {
		Fname:             __ccgo_ts + 2995,
		FtclInstCode:      int32(INST_MULT),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	92: {
		Fname:             __ccgo_ts + 3000,
		FtclInstCode:      int32(INST_NEQ),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	93: {
		Fname:        __ccgo_ts + 3004,
		FtclInstCode: int32(INST_NOP),
	},
	94: {
		Fname:             __ccgo_ts + 3008,
		FtclInstCode:      int32(INST_LNOT),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	95: {
		Fname:             __ccgo_ts + 3012,
		FinstType:         int32(ASSEM_LVT4),
		FtclInstCode:      int32(INST_NSUPVAR),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	96: {
		Fname:             __ccgo_ts + 3020,
		FtclInstCode:      int32(INST_NUM_TYPE),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	97: {
		Fname:             __ccgo_ts + 3032,
		FtclInstCode:      int32(INST_ORIGIN_COMMAND),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	98: {
		Fname:             __ccgo_ts + 3042,
		FinstType:         int32(ASSEM_OVER),
		FtclInstCode:      int32(INST_OVER),
		FoperandsConsumed: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FoperandsProduced: -libc.Int32FromInt32(1) - libc.Int32FromInt32(1),
	},
	99: {
		Fname:             __ccgo_ts + 3047,
		FtclInstCode:      int32(INST_POP),
		FoperandsConsumed: int32(1),
	},
	100: {
		Fname:             __ccgo_ts + 3051,
		FtclInstCode:      int32(INST_PUSH_RETURN_CODE),
		FoperandsProduced: int32(1),
	},
	101: {
		Fname:             __ccgo_ts + 3066,
		FtclInstCode:      int32(INST_PUSH_RETURN_OPTIONS),
		FoperandsProduced: int32(1),
	},
	102: {
		Fname:             __ccgo_ts + 3081,
		FtclInstCode:      int32(INST_PUSH_RESULT),
		FoperandsProduced: int32(1),
	},
	103: {
		Fname:             __ccgo_ts + 3092,
		FinstType:         int32(ASSEM_REGEXP),
		FtclInstCode:      int32(INST_REGEXP),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	104: {
		Fname:             __ccgo_ts + 3099,
		FtclInstCode:      int32(INST_RESOLVE_COMMAND),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	105: {
		Fname:             __ccgo_ts + 3110,
		FinstType:         int32(ASSEM_REVERSE),
		FtclInstCode:      int32(INST_REVERSE),
		FoperandsConsumed: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FoperandsProduced: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0),
	},
	106: {
		Fname:             __ccgo_ts + 3118,
		FtclInstCode:      int32(INST_RSHIFT),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	107: {
		Fname:             __ccgo_ts + 3125,
		FinstType:         int32(ASSEM_LVT),
		FtclInstCode:      int32(INST_STORE_SCALAR1)<<libc.Int32FromInt32(8) | int32(INST_STORE_SCALAR4),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	108: {
		Fname:             __ccgo_ts + 3131,
		FinstType:         int32(ASSEM_LVT),
		FtclInstCode:      int32(INST_STORE_ARRAY1)<<libc.Int32FromInt32(8) | int32(INST_STORE_ARRAY4),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	109: {
		Fname:             __ccgo_ts + 3142,
		FtclInstCode:      int32(INST_STORE_ARRAY_STK),
		FoperandsConsumed: int32(3),
		FoperandsProduced: int32(1),
	},
	110: {
		Fname:             __ccgo_ts + 3156,
		FtclInstCode:      int32(INST_STORE_STK),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	111: {
		Fname:             __ccgo_ts + 3165,
		FtclInstCode:      int32(INST_STR_LOWER),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	112: {
		Fname:             __ccgo_ts + 3178,
		FtclInstCode:      int32(INST_STR_TITLE),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	113: {
		Fname:             __ccgo_ts + 3191,
		FtclInstCode:      int32(INST_STR_UPPER),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	114: {
		Fname:             __ccgo_ts + 3204,
		FtclInstCode:      int32(INST_STR_CMP),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	115: {
		Fname:             __ccgo_ts + 3211,
		FinstType:         int32(ASSEM_CONCAT1),
		FtclInstCode:      int32(INST_STR_CONCAT1),
		FoperandsConsumed: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FoperandsProduced: int32(1),
	},
	116: {
		Fname:             __ccgo_ts + 3218,
		FtclInstCode:      int32(INST_STR_EQ),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	117: {
		Fname:             __ccgo_ts + 3224,
		FtclInstCode:      int32(INST_STR_FIND),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	118: {
		Fname:             __ccgo_ts + 3232,
		FtclInstCode:      int32(INST_STR_GE),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	119: {
		Fname:             __ccgo_ts + 3238,
		FtclInstCode:      int32(INST_STR_GT),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	120: {
		Fname:             __ccgo_ts + 3244,
		FtclInstCode:      int32(INST_STR_INDEX),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	121: {
		Fname:             __ccgo_ts + 3253,
		FtclInstCode:      int32(INST_STR_LE),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	122: {
		Fname:             __ccgo_ts + 3259,
		FtclInstCode:      int32(INST_STR_LEN),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	123: {
		Fname:             __ccgo_ts + 3266,
		FtclInstCode:      int32(INST_STR_LT),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	124: {
		Fname:             __ccgo_ts + 3272,
		FtclInstCode:      int32(INST_STR_MAP),
		FoperandsConsumed: int32(3),
		FoperandsProduced: int32(1),
	},
	125: {
		Fname:             __ccgo_ts + 3279,
		FinstType:         int32(ASSEM_BOOL),
		FtclInstCode:      int32(INST_STR_MATCH),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	126: {
		Fname:             __ccgo_ts + 3288,
		FtclInstCode:      int32(INST_STR_NEQ),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	127: {
		Fname:             __ccgo_ts + 3295,
		FtclInstCode:      int32(INST_STR_RANGE),
		FoperandsConsumed: int32(3),
		FoperandsProduced: int32(1),
	},
	128: {
		Fname:             __ccgo_ts + 3304,
		FtclInstCode:      int32(INST_STR_REPLACE),
		FoperandsConsumed: int32(4),
		FoperandsProduced: int32(1),
	},
	129: {
		Fname:             __ccgo_ts + 3315,
		FtclInstCode:      int32(INST_STR_FIND_LAST),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	130: {
		Fname:             __ccgo_ts + 3324,
		FtclInstCode:      int32(INST_STR_TRIM),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	131: {
		Fname:             __ccgo_ts + 3332,
		FtclInstCode:      int32(INST_STR_TRIM_LEFT),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	132: {
		Fname:             __ccgo_ts + 3344,
		FtclInstCode:      int32(INST_STR_TRIM_RIGHT),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	133: {
		Fname:             __ccgo_ts + 3357,
		FtclInstCode:      int32(INST_SUB),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	134: {
		Fname:             __ccgo_ts + 3361,
		FtclInstCode:      int32(INST_TCLOO_CLASS),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	135: {
		Fname:             __ccgo_ts + 3372,
		FtclInstCode:      int32(INST_TCLOO_IS_OBJECT),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	136: {
		Fname:             __ccgo_ts + 3386,
		FtclInstCode:      int32(INST_TCLOO_NS),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	137: {
		Fname:             __ccgo_ts + 3401,
		FtclInstCode:      int32(INST_TCLOO_SELF),
		FoperandsProduced: int32(1),
	},
	138: {
		Fname:             __ccgo_ts + 3411,
		FtclInstCode:      int32(INST_TRY_CVT_TO_BOOLEAN),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(2),
	},
	139: {
		Fname:             __ccgo_ts + 3427,
		FtclInstCode:      int32(INST_TRY_CVT_TO_NUMERIC),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	140: {
		Fname:             __ccgo_ts + 3443,
		FtclInstCode:      int32(INST_UMINUS),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	141: {
		Fname:        __ccgo_ts + 3450,
		FinstType:    int32(ASSEM_BOOL_LVT4),
		FtclInstCode: int32(INST_UNSET_SCALAR),
	},
	142: {
		Fname:             __ccgo_ts + 3456,
		FinstType:         int32(ASSEM_BOOL_LVT4),
		FtclInstCode:      int32(INST_UNSET_ARRAY),
		FoperandsConsumed: int32(1),
	},
	143: {
		Fname:             __ccgo_ts + 3467,
		FinstType:         int32(ASSEM_BOOL),
		FtclInstCode:      int32(INST_UNSET_ARRAY_STK),
		FoperandsConsumed: int32(2),
	},
	144: {
		Fname:             __ccgo_ts + 3481,
		FinstType:         int32(ASSEM_BOOL),
		FtclInstCode:      int32(INST_UNSET_STK),
		FoperandsConsumed: int32(1),
	},
	145: {
		Fname:             __ccgo_ts + 3490,
		FtclInstCode:      int32(INST_UPLUS),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	146: {
		Fname:             __ccgo_ts + 3496,
		FinstType:         int32(ASSEM_LVT4),
		FtclInstCode:      int32(INST_UPVAR),
		FoperandsConsumed: int32(2),
		FoperandsProduced: int32(1),
	},
	147: {
		Fname:             __ccgo_ts + 3502,
		FinstType:         int32(ASSEM_LVT4),
		FtclInstCode:      int32(INST_VARIABLE),
		FoperandsConsumed: int32(1),
	},
	148: {
		Fname:             __ccgo_ts + 3511,
		FtclInstCode:      int32(INST_DICT_VERIFY),
		FoperandsConsumed: int32(1),
	},
	149: {
		Fname:             __ccgo_ts + 3522,
		FtclInstCode:      int32(INST_YIELD),
		FoperandsConsumed: int32(1),
		FoperandsProduced: int32(1),
	},
	150: {},
}

/*
 * List of instructions that cannot throw an exception under any
 * circumstances.  These instructions are the ones that are permissible after
 * an exception is caught but before the corresponding exception range is
 * popped from the stack.
 * The instructions must be in ascending order by numeric operation code.
 */

var _NonThrowingByteCodes = [36]uint8{
	0:  uint8(INST_PUSH1),
	1:  uint8(INST_PUSH4),
	2:  uint8(INST_POP),
	3:  uint8(INST_DUP),
	4:  uint8(INST_JUMP1),
	5:  uint8(INST_JUMP4),
	6:  uint8(INST_END_CATCH),
	7:  uint8(INST_PUSH_RESULT),
	8:  uint8(INST_PUSH_RETURN_CODE),
	9:  uint8(INST_STR_EQ),
	10: uint8(INST_STR_NEQ),
	11: uint8(INST_STR_CMP),
	12: uint8(INST_STR_LEN),
	13: uint8(INST_LIST),
	14: uint8(INST_OVER),
	15: uint8(INST_PUSH_RETURN_OPTIONS),
	16: uint8(INST_REVERSE),
	17: uint8(INST_NOP),
	18: uint8(INST_STR_MAP),
	19: uint8(INST_STR_FIND),
	20: uint8(INST_COROUTINE_NAME),
	21: uint8(INST_NS_CURRENT),
	22: uint8(INST_INFO_LEVEL_NUM),
	23: uint8(INST_RESOLVE_COMMAND),
	24: uint8(INST_STR_TRIM),
	25: uint8(INST_STR_TRIM_LEFT),
	26: uint8(INST_STR_TRIM_RIGHT),
	27: uint8(INST_CONCAT_STK),
	28: uint8(INST_STR_UPPER),
	29: uint8(INST_STR_LOWER),
	30: uint8(INST_STR_TITLE),
	31: uint8(INST_NUM_TYPE),
	32: uint8(INST_STR_LT),
	33: uint8(INST_STR_GT),
	34: uint8(INST_STR_LE),
	35: uint8(INST_STR_GE),
}

/*
 * Helper macros.
 */

/*
 *-----------------------------------------------------------------------------
 *
 * BBAdjustStackDepth --
 *
 *	When an opcode is emitted, adjusts the stack information in the basic
 *	block to reflect the number of operands produced and consumed.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Updates minimum, maximum and final stack requirements in the basic
 *	block.
 *
 *-----------------------------------------------------------------------------
 */

func _BBAdjustStackDepth(tls *libc.TLS, bbPtr uintptr, consumed int32, produced int32) {
	/* Count of operands produced by the
	 * operation */
	var depth int32
	_ = depth
	depth = (*TBasicBlock)(unsafe.Pointer(bbPtr)).FfinalStackDepth
	depth -= consumed
	if depth < (*TBasicBlock)(unsafe.Pointer(bbPtr)).FminStackDepth {
		(*TBasicBlock)(unsafe.Pointer(bbPtr)).FminStackDepth = depth
	}
	depth += produced
	if depth > (*TBasicBlock)(unsafe.Pointer(bbPtr)).FmaxStackDepth {
		(*TBasicBlock)(unsafe.Pointer(bbPtr)).FmaxStackDepth = depth
	}
	(*TBasicBlock)(unsafe.Pointer(bbPtr)).FfinalStackDepth = depth
}

/*
 *-----------------------------------------------------------------------------
 *
 * BBUpdateStackReqs --
 *
 *	Updates the stack requirements of a basic block, given the opcode
 *	being emitted and an operand count.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Updates min, max and final stack requirements in the basic block.
 *
 * Notes:
 *	This function must not be called for instructions such as REVERSE and
 *	OVER that are variadic but do not consume all their operands. Instead,
 *	BBAdjustStackDepth should be called directly.
 *
 *	count should be provided only for variadic operations. For operations
 *	with known arity, count should be 0.
 *
 *-----------------------------------------------------------------------------
 */

func _BBUpdateStackReqs(tls *libc.TLS, bbPtr uintptr, tblIdx int32, count int32) {
	/* Count of operands for variadic insts */
	var consumed, produced int32
	_, _ = consumed, produced
	consumed = _TalInstructionTable[tblIdx].FoperandsConsumed
	produced = _TalInstructionTable[tblIdx].FoperandsProduced
	if consumed == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
		/*
		 * The instruction is variadic; it consumes 'count' operands, or
		 * 'count+1' for ASSEM_DICT_GET_DEF.
		 */
		consumed = count
		if _TalInstructionTable[tblIdx].FinstType == int32(ASSEM_DICT_GET_DEF) {
			consumed++
		}
	}
	if produced < 0 {
		/*
		 * The instruction leaves some of its variadic operands on the stack,
		 * with net stack effect of '-1-produced'
		 */
		produced = consumed - produced - int32(1)
	}
	_BBAdjustStackDepth(tls, bbPtr, consumed, produced)
}

/*
 *-----------------------------------------------------------------------------
 *
 * BBEmitOpcode, BBEmitInstInt1, BBEmitInstInt4 --
 *
 *	Emit the opcode part of an instruction, or the entirety of an
 *	instruction with a 1- or 4-byte operand, and adjust stack
 *	requirements.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Stores instruction and operand in the operand stream, and adjusts the
 *	stack.
 *
 *-----------------------------------------------------------------------------
 */

func _BBEmitOpcode(tls *libc.TLS, assemEnvPtr uintptr, tblIdx int32, count int32) {
	/* Operand count for variadic ops */
	var bbPtr, envPtr, v1, v2 uintptr
	var op, v3 int32
	_, _, _, _, _, _ = bbPtr, envPtr, op, v1, v2, v3
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr
	/* Compilation environment */
	bbPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fcurr_bb
	/* Current basic block */
	op = _TalInstructionTable[tblIdx].FtclInstCode & int32(0xFF)
	/*
	 * If this is the first instruction in a basic block, record its line
	 * number.
	 */
	if int64((*TBasicBlock)(unsafe.Pointer(bbPtr)).FstartOffset) == int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart) {
		(*TBasicBlock)(unsafe.Pointer(bbPtr)).FstartLine = int32((*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FcmdLine)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr)
	}
	v2 = envPtr + 152
	v1 = *(*uintptr)(unsafe.Pointer(v2))
	*(*uintptr)(unsafe.Pointer(v2))++
	*(*uint8)(unsafe.Pointer(v1)) = uint8(libc.Uint32FromInt32(op))
	if (*TCompileEnv)(unsafe.Pointer(envPtr)).FatCmdStart < int32(2) {
		if op == int32(INST_START_CMD) {
			v3 = int32(1)
		} else {
			v3 = 0
		}
		(*TCompileEnv)(unsafe.Pointer(envPtr)).FatCmdStart = v3
	}
	_BBUpdateStackReqs(tls, bbPtr, tblIdx, count)
}

func _BBEmitInstInt1(tls *libc.TLS, assemEnvPtr uintptr, tblIdx int32, opnd int32, count int32) {
	/* Operand count for variadic ops */
	var v1, v2 uintptr
	_, _ = v1, v2
	_BBEmitOpcode(tls, assemEnvPtr, tblIdx, count)
	if (*TCompileEnv)(unsafe.Pointer((*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr)).FcodeNext == (*TCompileEnv)(unsafe.Pointer((*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr)).FcodeEnd {
		XTclExpandCodeArray(tls, (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr)
	}
	v2 = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr + 152
	v1 = *(*uintptr)(unsafe.Pointer(v2))
	*(*uintptr)(unsafe.Pointer(v2))++
	*(*uint8)(unsafe.Pointer(v1)) = uint8(libc.Uint32FromInt32(opnd))
}

func _BBEmitInstInt4(tls *libc.TLS, assemEnvPtr uintptr, tblIdx int32, opnd int32, count int32) {
	/* Operand count for variadic ops */
	var v1, v2, v3, v4, v5, v6, v7, v8 uintptr
	_, _, _, _, _, _, _, _ = v1, v2, v3, v4, v5, v6, v7, v8
	_BBEmitOpcode(tls, assemEnvPtr, tblIdx, count)
	if (*TCompileEnv)(unsafe.Pointer((*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer((*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr)).FcodeEnd {
		XTclExpandCodeArray(tls, (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr)
	}
	v2 = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr + 152
	v1 = *(*uintptr)(unsafe.Pointer(v2))
	*(*uintptr)(unsafe.Pointer(v2))++
	*(*uint8)(unsafe.Pointer(v1)) = uint8(libc.Uint32FromInt32(opnd) >> libc.Int32FromInt32(24))
	v4 = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr + 152
	v3 = *(*uintptr)(unsafe.Pointer(v4))
	*(*uintptr)(unsafe.Pointer(v4))++
	*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(opnd) >> libc.Int32FromInt32(16))
	v6 = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr + 152
	v5 = *(*uintptr)(unsafe.Pointer(v6))
	*(*uintptr)(unsafe.Pointer(v6))++
	*(*uint8)(unsafe.Pointer(v5)) = uint8(libc.Uint32FromInt32(opnd) >> libc.Int32FromInt32(8))
	v8 = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr + 152
	v7 = *(*uintptr)(unsafe.Pointer(v8))
	*(*uintptr)(unsafe.Pointer(v8))++
	*(*uint8)(unsafe.Pointer(v7)) = uint8(libc.Uint32FromInt32(opnd))
}

/*
 *-----------------------------------------------------------------------------
 *
 * BBEmitInst1or4 --
 *
 *	Emits a 1- or 4-byte operation according to the magnitude of the
 *	operand.
 *
 *-----------------------------------------------------------------------------
 */

func _BBEmitInst1or4(tls *libc.TLS, assemEnvPtr uintptr, tblIdx int32, param int32, count int32) {
	/* Arity if variadic */
	var bbPtr, envPtr, v1, v10, v11, v12, v2, v3, v4, v5, v6, v7, v8, v9 uintptr
	var op, v13 int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bbPtr, envPtr, op, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr
	/* Compilation environment */
	bbPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fcurr_bb
	/* Current basic block */
	op = _TalInstructionTable[tblIdx].FtclInstCode
	if param <= int32(0xFF) {
		op >>= int32(8)
	} else {
		op &= int32(0xFF)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr)
	}
	v2 = envPtr + 152
	v1 = *(*uintptr)(unsafe.Pointer(v2))
	*(*uintptr)(unsafe.Pointer(v2))++
	*(*uint8)(unsafe.Pointer(v1)) = uint8(libc.Uint32FromInt32(op))
	if param <= int32(0xFF) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr)
		}
		v4 = envPtr + 152
		v3 = *(*uintptr)(unsafe.Pointer(v4))
		*(*uintptr)(unsafe.Pointer(v4))++
		*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(param))
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr)
		}
		v6 = envPtr + 152
		v5 = *(*uintptr)(unsafe.Pointer(v6))
		*(*uintptr)(unsafe.Pointer(v6))++
		*(*uint8)(unsafe.Pointer(v5)) = uint8(libc.Uint32FromInt32(param) >> libc.Int32FromInt32(24))
		v8 = envPtr + 152
		v7 = *(*uintptr)(unsafe.Pointer(v8))
		*(*uintptr)(unsafe.Pointer(v8))++
		*(*uint8)(unsafe.Pointer(v7)) = uint8(libc.Uint32FromInt32(param) >> libc.Int32FromInt32(16))
		v10 = envPtr + 152
		v9 = *(*uintptr)(unsafe.Pointer(v10))
		*(*uintptr)(unsafe.Pointer(v10))++
		*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(param) >> libc.Int32FromInt32(8))
		v12 = envPtr + 152
		v11 = *(*uintptr)(unsafe.Pointer(v12))
		*(*uintptr)(unsafe.Pointer(v12))++
		*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(param))
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr)).FatCmdStart < int32(2) {
		if op == int32(INST_START_CMD) {
			v13 = int32(1)
		} else {
			v13 = 0
		}
		(*TCompileEnv)(unsafe.Pointer(envPtr)).FatCmdStart = v13
	}
	_BBUpdateStackReqs(tls, bbPtr, tblIdx, count)
}

/*
 *-----------------------------------------------------------------------------
 *
 * Tcl_AssembleObjCmd, TclNRAssembleObjCmd --
 *
 *	Direct evaluation path for tcl::unsupported::assemble
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	Assembles the code in objv[1], and executes it, so side effects
 *	include whatever the code does.
 *
 *-----------------------------------------------------------------------------
 */

func XTcl_AssembleObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	/*
	 * Boilerplate - make sure that there is an NRE trampoline on the C stack
	 * because there needs to be one in place to execute bytecode.
	 */
	return XTcl_NRCallObjProc(tls, interp, __ccgo_fp(XTclNRAssembleObjCmd), clientData, int64(objc), objv)
}

func XTclNRAssembleObjCmd(tls *libc.TLS, dummy789 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var backtrace, cachePtr, codePtr uintptr
	var v1 bool
	_, _, _, _ = backtrace, cachePtr, codePtr, v1 /* Object where extra error information is
	 * constructed. */
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+3528)
		return int32(TCL_ERROR)
	}
	/*
	 * Assemble the source to bytecode.
	 */
	codePtr = _CompileAssembleObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	/*
	 * On failure, report error line.
	 */
	if codePtr == libc.UintptrFromInt32(0) {
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+3541, int64(-int32(1))))
		XTcl_AppendObjToErrorInfo(tls, interp, *(*uintptr)(unsafe.Pointer(objv)))
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+3549, int64(-int32(1))))
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			backtrace = XTclThreadAllocObj(tls)
		} else {
			backtrace = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(backtrace + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(backtrace)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(backtrace)).Fbytes = libc.UintptrFromInt32(0)
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(backtrace)).FinternalRep)) = int64(XTcl_GetErrorLine(tls, interp))
		(*TTcl_Obj)(unsafe.Pointer(backtrace)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
		XTcl_AppendObjToErrorInfo(tls, interp, backtrace)
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+3563, int64(-int32(1))))
		return int32(TCL_ERROR)
	}
	/*
	 * Use NRE to evaluate the bytecode from the trampoline.
	 */
	return XTclNRExecuteByteCode(tls, interp, codePtr)
}

/*
 *-----------------------------------------------------------------------------
 *
 * CompileAssembleObj --
 *
 *	Sets up and assembles Tcl bytecode for the direct-execution path in
 *	the Tcl bytecode assembler.
 *
 * Results:
 *	Returns a pointer to the assembled code. Returns NULL if the assembly
 *	fails for any reason, with an appropriate error message in the
 *	interpreter.
 *
 *-----------------------------------------------------------------------------
 */

func _CompileAssembleObj(tls *libc.TLS, interp uintptr, objPtr uintptr) (r uintptr) {
	bp := tls.Alloc(4560)
	defer tls.Free(4560) /* Source code to assemble */
	var codePtr, iPtr, irPtr, namespacePtr, source, v1, v2, v3, v4, v5, v7 uintptr
	var delta1, status, v6 int32
	var _ /* compEnv at bp+0 */ TCompileEnv
	var _ /* sourceLen at bp+4544 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = codePtr, delta1, iPtr, irPtr, namespacePtr, source, status, v1, v2, v3, v4, v5, v6, v7
	iPtr = interp                      /* Compilation environment structure */
	codePtr = libc.UintptrFromInt32(0) /* Length of the source code in bytes */
	/*
	 * Get the expression ByteCode from the object. If it exists, make sure it
	 * is valid in the current context.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_assembleCodeType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	codePtr = v2
	if codePtr != 0 {
		namespacePtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FnsPtr
		if *(*uintptr)(unsafe.Pointer((*TByteCode)(unsafe.Pointer(codePtr)).FinterpHandle)) == iPtr && (*TByteCode)(unsafe.Pointer(codePtr)).FcompileEpoch == (*TInterp)(unsafe.Pointer(iPtr)).FcompileEpoch && (*TByteCode)(unsafe.Pointer(codePtr)).FnsPtr == namespacePtr && (*TByteCode)(unsafe.Pointer(codePtr)).FnsEpoch == (*TNamespace)(unsafe.Pointer(namespacePtr)).FresolverEpoch && (*TByteCode)(unsafe.Pointer(codePtr)).FlocalCachePtr == (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FlocalCachePtr {
			return codePtr
		}
		/*
		 * Not valid, so free it and regenerate.
		 */
		XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&_assembleCodeType)), libc.UintptrFromInt32(0))
	}
	/*
	 * Set up the compilation environment, and assemble the code.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 4544)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
		v3 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		v3 = XTcl_GetStringFromObj(tls, objPtr, bp+4544)
	}
	source = v3
	XTclInitCompileEnv(tls, interp, bp, source, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 4544))), libc.UintptrFromInt32(0), 0)
	status = _TclAssembleCode(tls, bp, source, int32(*(*TTcl_Size)(unsafe.Pointer(bp + 4544))), int32(TCL_EVAL_DIRECT))
	if status != TCL_OK {
		/*
		 * Assembly failed. Clean up and report the error.
		 */
		XTclFreeCompileEnv(tls, bp)
		return libc.UintptrFromInt32(0)
	}
	/*
	 * Add a "done" instruction as the last instruction and change the object
	 * into a ByteCode object. Ownership of the literal objects and aux data
	 * items is given to the ByteCode object.
	 */
	if (*TCompileEnv)(unsafe.Pointer(bp)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(bp)).FcodeEnd {
		XTclExpandCodeArray(tls, bp)
	}
	v5 = bp + 152
	v4 = *(*uintptr)(unsafe.Pointer(v5))
	*(*uintptr)(unsafe.Pointer(v5))++
	*(*uint8)(unsafe.Pointer(v4)) = libc.Uint8FromInt32(int32(INST_DONE))
	if (*TCompileEnv)(unsafe.Pointer(bp)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(bp)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_DONE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v6 = delta1
		v7 = bp
		if v6 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v7 + 64)) += int64(v6)
	}
	codePtr = XTclInitByteCodeObj(tls, objPtr, uintptr(unsafe.Pointer(&_assembleCodeType)), bp)
	XTclFreeCompileEnv(tls, bp)
	/*
	 * Record the local variable context to which the bytecode pertains
	 */
	if (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FlocalCachePtr != 0 {
		(*TByteCode)(unsafe.Pointer(codePtr)).FlocalCachePtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FlocalCachePtr
		(*TLocalCache)(unsafe.Pointer((*TByteCode)(unsafe.Pointer(codePtr)).FlocalCachePtr)).FrefCount++
	}
	/*
	 * Report on what the assembler did.
	 */
	_ = objPtr
	return codePtr
}

/*
 *-----------------------------------------------------------------------------
 *
 * TclCompileAssembleCmd --
 *
 *	Compilation procedure for the '::tcl::unsupported::assemble' command.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	Puts the result of assembling the code into the bytecode stream in
 *	'compileEnv'.
 *
 * This procedure makes sure that the command has a single arg, which is
 * constant. If that condition is met, the procedure calls TclAssembleCode to
 * produce bytecode for the given assembly code, and returns any error
 * resulting from the assembly.
 *
 *-----------------------------------------------------------------------------
 */

func XTclCompileAssembleCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy957 uintptr, envPtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Holds resulting instructions. */
	var depth, numCommands Tsize_t
	var offset int32
	var tokenPtr uintptr
	_, _, _, _ = depth, numCommands, offset, tokenPtr /* Token in the input script */
	numCommands = libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr)).FnumCommands)
	offset = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart))
	depth = libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcurrStackDepth)
	/*
	 * Make sure that the command has a single arg that is a simple word.
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
		return int32(TCL_ERROR)
	}
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) {
		return int32(TCL_ERROR)
	}
	/*
	 * Compile the code and convert any error from the compilation into
	 * bytecode reporting the error;
	 */
	if int32(TCL_ERROR) == _TclAssembleCode(tls, envPtr, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, int32((*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize), int32(TCL_EVAL_DIRECT)) {
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+3565, libc.VaList(bp+8, int32((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).Fsize), (*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).Fstart, XTcl_GetErrorLine(tls, interp))))
		(*TCompileEnv)(unsafe.Pointer(envPtr)).FnumCommands = libc.Int64FromUint64(numCommands)
		(*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext = (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr(offset)
		(*TCompileEnv)(unsafe.Pointer(envPtr)).FcurrStackDepth = libc.Int64FromUint64(depth)
		XTclCompileSyntaxError(tls, interp, envPtr)
	}
	return TCL_OK
}

/*
 *-----------------------------------------------------------------------------
 *
 * TclAssembleCode --
 *
 *	Take a list of instructions in a Tcl_Obj, and assemble them to Tcl
 *	bytecodes
 *
 * Results:
 *	Returns TCL_OK on success, TCL_ERROR on failure.  If 'flags' includes
 *	TCL_EVAL_DIRECT, places an error message in the interpreter result.
 *
 * Side effects:
 *	Adds byte codes to the compile environment, and updates the
 *	environment's stack depth.
 *
 *-----------------------------------------------------------------------------
 */

func _TclAssembleCode(tls *libc.TLS, envPtr uintptr, codePtr uintptr, codeLen int32, flags int32) (r int32) {
	/* OR'ed combination of flags */
	var assemEnvPtr, instPtr, interp, nextPtr, parsePtr uintptr
	var bytesLeft, status int32
	var instLen Tsize_t
	_, _, _, _, _, _, _, _ = assemEnvPtr, bytesLeft, instLen, instPtr, interp, nextPtr, parsePtr, status
	interp = (*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr
	/* Tcl interpreter */
	/*
	 * Walk through the assembly script using the Tcl parser.  Each 'command'
	 * will be an instruction or assembly directive.
	 */
	instPtr = codePtr   /* Pointer to the end of the line of code */
	bytesLeft = codeLen /* Tcl status return */
	assemEnvPtr = _NewAssemblyEnv(tls, envPtr, flags)
	parsePtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FparsePtr
	for cond := true; cond; cond = bytesLeft > 0 {
		/*
		 * Parse out one command line from the assembly script.
		 */
		status = XTcl_ParseCommand(tls, interp, instPtr, int64(bytesLeft), 0, parsePtr)
		/*
		 * Report errors in the parse.
		 */
		if status != TCL_OK {
			if flags&int32(TCL_EVAL_DIRECT) != 0 {
				XTcl_LogCommandInfo(tls, interp, codePtr, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart, int64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm+uintptr(1))-int64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart))
			}
			_FreeAssemblyEnv(tls, assemEnvPtr)
			return int32(TCL_ERROR)
		}
		/*
		 * Advance the pointers around any leading commentary.
		 */
		XTclAdvanceLines(tls, assemEnvPtr+120, instPtr, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart)
		XTclAdvanceContinuations(tls, assemEnvPtr+120, assemEnvPtr+128, int32(int64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart)-int64((*TCompileEnv)(unsafe.Pointer(envPtr)).Fsource)))
		/*
		 * Process the line of code.
		 */
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords > 0 {
			instLen = libc.Uint64FromInt64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandSize)
			/* Length in bytes of the current command */
			if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm == (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart+uintptr(instLen)-uintptr(1) {
				instLen--
			}
			/*
			 * If tracing, show each line assembled as it happens.
			 */
			if _AssembleOneLine(tls, assemEnvPtr) != TCL_OK {
				if flags&int32(TCL_EVAL_DIRECT) != 0 {
					XTcl_LogCommandInfo(tls, interp, codePtr, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart, libc.Int64FromUint64(instLen))
				}
				XTcl_FreeParse(tls, parsePtr)
				_FreeAssemblyEnv(tls, assemEnvPtr)
				return int32(TCL_ERROR)
			}
		}
		/*
		 * Advance to the next line of code.
		 */
		nextPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart + uintptr((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandSize)
		bytesLeft = int32(int64(bytesLeft) - (int64(nextPtr) - int64(instPtr)))
		instPtr = nextPtr
		XTclAdvanceLines(tls, assemEnvPtr+120, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart, instPtr)
		XTclAdvanceContinuations(tls, assemEnvPtr+120, assemEnvPtr+128, int32(int64(instPtr)-int64((*TCompileEnv)(unsafe.Pointer(envPtr)).Fsource)))
		XTcl_FreeParse(tls, parsePtr)
	}
	/*
	 * Done with parsing the code.
	 */
	status = _FinishAssembly(tls, assemEnvPtr)
	_FreeAssemblyEnv(tls, assemEnvPtr)
	return status
}

/*
 *-----------------------------------------------------------------------------
 *
 * NewAssemblyEnv --
 *
 *	Creates an environment for the assembler to run in.
 *
 * Results:
 *	Allocates, initialises and returns an assembler environment
 *
 *-----------------------------------------------------------------------------
 */

func _NewAssemblyEnv(tls *libc.TLS, envPtr uintptr, flags int32) (r uintptr) {
	/* Compilation flags (TCL_EVAL_DIRECT) */
	var assemEnvPtr, interp, parsePtr uintptr
	_, _, _ = assemEnvPtr, interp, parsePtr
	interp = (*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr
	/* Tcl interpreter */
	assemEnvPtr = XTclStackAlloc(tls, interp, uint64(168))
	/* Assembler environment under construction */
	parsePtr = XTclStackAlloc(tls, interp, uint64(744))
	/* Parse of one line of assembly code */
	(*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr = envPtr
	(*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FparsePtr = parsePtr
	(*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FcmdLine = int64(1)
	(*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FclNext = (*TCompileEnv)(unsafe.Pointer(envPtr)).FclNext
	/*
	 * Make the hashtables that store symbol resolution.
	 */
	XTcl_InitHashTable(tls, assemEnvPtr+16, TCL_STRING_KEYS)
	/*
	 * Start the first basic block.
	 */
	(*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fcurr_bb = libc.UintptrFromInt32(0)
	(*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fhead_bb = _AllocBB(tls, assemEnvPtr)
	(*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fcurr_bb = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fhead_bb
	(*TBasicBlock)(unsafe.Pointer((*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fhead_bb)).FstartLine = int32(1)
	/*
	 * Stash compilation flags.
	 */
	(*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fflags = flags
	return assemEnvPtr
}

/*
 *-----------------------------------------------------------------------------
 *
 * FreeAssemblyEnv --
 *
 *	Cleans up the assembler environment when assembly is complete.
 *
 *-----------------------------------------------------------------------------
 */

func _FreeAssemblyEnv(tls *libc.TLS, assemEnvPtr uintptr) {
	/* Environment to free */
	var _objPtr, envPtr, interp, nextBB, thisBB, v3 uintptr
	var v2 TTcl_Size
	_, _, _, _, _, _, _ = _objPtr, envPtr, interp, nextBB, thisBB, v2, v3
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr
	/* Compilation environment being used for code
	 * generation */
	interp = (*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr /* Pointer to a deleted basic block's
	 * successor */
	/*
	 * Free all the basic block structures.
	 */
	thisBB = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fhead_bb
	for {
		if !(thisBB != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TBasicBlock)(unsafe.Pointer(thisBB)).FjumpTarget != libc.UintptrFromInt32(0) {
			_objPtr = (*TBasicBlock)(unsafe.Pointer(thisBB)).FjumpTarget
			v3 = _objPtr
			v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
			*(*TTcl_Size)(unsafe.Pointer(v3))--
			if v2 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
		if (*TBasicBlock)(unsafe.Pointer(thisBB)).FforeignExceptions != libc.UintptrFromInt32(0) {
			XTclpFree(tls, (*TBasicBlock)(unsafe.Pointer(thisBB)).FforeignExceptions)
		}
		nextBB = (*TBasicBlock)(unsafe.Pointer(thisBB)).Fsuccessor1
		if (*TBasicBlock)(unsafe.Pointer(thisBB)).FjtPtr != libc.UintptrFromInt32(0) {
			_DeleteMirrorJumpTable(tls, (*TBasicBlock)(unsafe.Pointer(thisBB)).FjtPtr)
			(*TBasicBlock)(unsafe.Pointer(thisBB)).FjtPtr = libc.UintptrFromInt32(0)
		}
		XTclpFree(tls, thisBB)
		goto _1
	_1:
		;
		thisBB = nextBB
	}
	/*
	 * Dispose what's left.
	 */
	XTcl_DeleteHashTable(tls, assemEnvPtr+16)
	XTclStackFree(tls, interp, (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FparsePtr)
	XTclStackFree(tls, interp, assemEnvPtr)
}

/*
 *-----------------------------------------------------------------------------
 *
 * AssembleOneLine --
 *
 *	Assembles a single command from an assembly language source.
 *
 * Results:
 *	Returns TCL_ERROR with an appropriate error message if the assembly
 *	fails. Returns TCL_OK if the assembly succeeds. Updates the assembly
 *	environment with the state of the assembly.
 *
 *-----------------------------------------------------------------------------
 */

func _AssembleOneLine(tls *libc.TLS, assemEnvPtr uintptr) (r int32) {
	bp := tls.Alloc(96)
	defer tls.Free(96) /* State of the assembly */
	var _objPtr, _objPtr1, envPtr, interp, jtPtr, operand1, parsePtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v42, v44, v5, v6, v7, v8, v9 uintptr
	var flags, infoIndex, litIndex, status, v31 int32
	var instType TTalInstType
	var localVar, v41, v43 TTcl_Size
	var _ /* instNameObj at bp+8 */ uintptr
	var _ /* operand1Len at bp+32 */ TTcl_Size
	var _ /* operand1Obj at bp+24 */ uintptr
	var _ /* opnd at bp+40 */ int32
	var _ /* tblIdx at bp+16 */ int32
	var _ /* tokenPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, envPtr, flags, infoIndex, instType, interp, jtPtr, litIndex, localVar, operand1, parsePtr, status, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v5, v6, v7, v8, v9
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr
	/* Compilation environment being used for code
	 * gen */
	interp = (*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr
	/* Tcl interpreter */
	parsePtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FparsePtr /* Type of the instruction */
	*(*uintptr)(unsafe.Pointer(bp + 24)) = libc.UintptrFromInt32(0)   /* Index of the jumptable in auxdata */
	status = int32(TCL_ERROR)                                         /* Return value from this function */
	/*
	 * Make sure that the instruction name is known at compile time.
	 */
	*(*uintptr)(unsafe.Pointer(bp)) = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
	if _GetNextOperand(tls, assemEnvPtr, bp, bp+8) != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Look up the instruction name.
	 */
	if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 8)), uintptr(unsafe.Pointer(&_TalInstructionTable)), libc.Int64FromUint64(libc.Uint64FromInt64(24)), __ccgo_ts+3593, libc.Int32FromInt32(TCL_EXACT)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+16) != TCL_OK {
		goto cleanup
	}
	/*
	 * Vector on the type of instruction being processed.
	 */
	instType = _TalInstructionTable[*(*int32)(unsafe.Pointer(bp + 16))].FinstType
	switch instType {
	case int32(ASSEM_PUSH):
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
			XTcl_WrongNumArgs(tls, interp, int64(1), bp+8, __ccgo_ts+3605)
			goto cleanup
		}
		if _GetNextOperand(tls, assemEnvPtr, bp, bp+24) != TCL_OK {
			goto cleanup
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Flength
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 24)), bp+32)
		}
		operand1 = v1
		litIndex = XTclRegisterLiteral(tls, envPtr, operand1, *(*TTcl_Size)(unsafe.Pointer(bp + 32)), 0)
		_BBEmitInst1or4(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp + 16)), litIndex, 0)
	case int32(ASSEM_1BYTE):
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(1) {
			XTcl_WrongNumArgs(tls, interp, int64(1), bp+8, __ccgo_ts+1945)
			goto cleanup
		}
		_BBEmitOpcode(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp + 16)), 0)
	case int32(ASSEM_BEGIN_CATCH):
		/*
		 * Emit the BEGIN_CATCH instruction with the code offset of the
		 * exception branch target instead of the exception range index. The
		 * correct index will be generated and inserted later, when catches
		 * are being resolved.
		 */
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
			XTcl_WrongNumArgs(tls, interp, int64(1), bp+8, __ccgo_ts+2727)
			goto cleanup
		}
		if _GetNextOperand(tls, assemEnvPtr, bp, bp+24) != TCL_OK {
			goto cleanup
		}
		(*TBasicBlock)(unsafe.Pointer((*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fcurr_bb)).FjumpLine = int32((*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FcmdLine)
		(*TBasicBlock)(unsafe.Pointer((*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fcurr_bb)).FjumpOffset = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart))
		_BBEmitInstInt4(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp + 16)), 0, 0)
		*(*int32)(unsafe.Pointer((*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fcurr_bb + 112)) |= int32(BB_BEGINCATCH)
		_StartBasicBlock(tls, assemEnvPtr, int32(BB_FALLTHRU), *(*uintptr)(unsafe.Pointer(bp + 24)))
	case int32(ASSEM_BOOL):
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
			XTcl_WrongNumArgs(tls, interp, int64(1), bp+8, __ccgo_ts+3611)
			goto cleanup
		}
		if _GetBooleanOperand(tls, assemEnvPtr, bp, bp+40) != TCL_OK {
			goto cleanup
		}
		_BBEmitInstInt1(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp + 16)), *(*int32)(unsafe.Pointer(bp + 40)), 0)
	case int32(ASSEM_BOOL_LVT4):
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(3) {
			XTcl_WrongNumArgs(tls, interp, int64(1), bp+8, __ccgo_ts+3619)
			goto cleanup
		}
		if _GetBooleanOperand(tls, assemEnvPtr, bp, bp+40) != TCL_OK {
			goto cleanup
		}
		localVar = libc.Int64FromUint64(_FindLocalVar(tls, assemEnvPtr, bp))
		if localVar < 0 {
			goto cleanup
		}
		_BBEmitInstInt1(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp + 16)), *(*int32)(unsafe.Pointer(bp + 40)), 0)
		if (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr)
		}
		v3 = envPtr + 152
		v2 = *(*uintptr)(unsafe.Pointer(v3))
		*(*uintptr)(unsafe.Pointer(v3))++
		*(*uint8)(unsafe.Pointer(v2)) = uint8(libc.Uint32FromInt64(localVar) >> libc.Int32FromInt32(24))
		v5 = envPtr + 152
		v4 = *(*uintptr)(unsafe.Pointer(v5))
		*(*uintptr)(unsafe.Pointer(v5))++
		*(*uint8)(unsafe.Pointer(v4)) = uint8(libc.Uint32FromInt64(localVar) >> libc.Int32FromInt32(16))
		v7 = envPtr + 152
		v6 = *(*uintptr)(unsafe.Pointer(v7))
		*(*uintptr)(unsafe.Pointer(v7))++
		*(*uint8)(unsafe.Pointer(v6)) = uint8(libc.Uint32FromInt64(localVar) >> libc.Int32FromInt32(8))
		v9 = envPtr + 152
		v8 = *(*uintptr)(unsafe.Pointer(v9))
		*(*uintptr)(unsafe.Pointer(v9))++
		*(*uint8)(unsafe.Pointer(v8)) = uint8(libc.Uint32FromInt64(localVar))
	case int32(ASSEM_CLOCK_READ):
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
			XTcl_WrongNumArgs(tls, interp, int64(1), bp+8, __ccgo_ts+3635)
			goto cleanup
		}
		if _GetIntegerOperand(tls, assemEnvPtr, bp, bp+40) != TCL_OK {
			goto cleanup
		}
		if *(*int32)(unsafe.Pointer(bp + 40)) < 0 || *(*int32)(unsafe.Pointer(bp + 40)) > int32(3) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+3640, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+56, __ccgo_ts+2004, __ccgo_ts+3663, __ccgo_ts+3669, libc.UintptrFromInt32(0)))
			goto cleanup
		}
		_BBEmitInstInt1(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp + 16)), *(*int32)(unsafe.Pointer(bp + 40)), *(*int32)(unsafe.Pointer(bp + 40)))
	case int32(ASSEM_CONCAT1):
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
			XTcl_WrongNumArgs(tls, interp, int64(1), bp+8, __ccgo_ts+3635)
			goto cleanup
		}
		if _GetIntegerOperand(tls, assemEnvPtr, bp, bp+40) != TCL_OK || _CheckOneByte(tls, interp, *(*int32)(unsafe.Pointer(bp + 40))) != TCL_OK || _CheckStrictlyPositive(tls, interp, *(*int32)(unsafe.Pointer(bp + 40))) != TCL_OK {
			goto cleanup
		}
		_BBEmitInstInt1(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp + 16)), *(*int32)(unsafe.Pointer(bp + 40)), *(*int32)(unsafe.Pointer(bp + 40)))
	case int32(ASSEM_DICT_GET):
		fallthrough
	case int32(ASSEM_DICT_GET_DEF):
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
			XTcl_WrongNumArgs(tls, interp, int64(1), bp+8, __ccgo_ts+3682)
			goto cleanup
		}
		if _GetIntegerOperand(tls, assemEnvPtr, bp, bp+40) != TCL_OK || _CheckStrictlyPositive(tls, interp, *(*int32)(unsafe.Pointer(bp + 40))) != TCL_OK {
			goto cleanup
		}
		_BBEmitInstInt4(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp + 16)), *(*int32)(unsafe.Pointer(bp + 40)), *(*int32)(unsafe.Pointer(bp + 40))+int32(1))
	case int32(ASSEM_DICT_SET):
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(3) {
			XTcl_WrongNumArgs(tls, interp, int64(1), bp+8, __ccgo_ts+3688)
			goto cleanup
		}
		if _GetIntegerOperand(tls, assemEnvPtr, bp, bp+40) != TCL_OK || _CheckStrictlyPositive(tls, interp, *(*int32)(unsafe.Pointer(bp + 40))) != TCL_OK {
			goto cleanup
		}
		localVar = libc.Int64FromUint64(_FindLocalVar(tls, assemEnvPtr, bp))
		if localVar < 0 {
			goto cleanup
		}
		_BBEmitInstInt4(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp + 16)), *(*int32)(unsafe.Pointer(bp + 40)), *(*int32)(unsafe.Pointer(bp + 40))+int32(1))
		if (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr)
		}
		v11 = envPtr + 152
		v10 = *(*uintptr)(unsafe.Pointer(v11))
		*(*uintptr)(unsafe.Pointer(v11))++
		*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt64(localVar) >> libc.Int32FromInt32(24))
		v13 = envPtr + 152
		v12 = *(*uintptr)(unsafe.Pointer(v13))
		*(*uintptr)(unsafe.Pointer(v13))++
		*(*uint8)(unsafe.Pointer(v12)) = uint8(libc.Uint32FromInt64(localVar) >> libc.Int32FromInt32(16))
		v15 = envPtr + 152
		v14 = *(*uintptr)(unsafe.Pointer(v15))
		*(*uintptr)(unsafe.Pointer(v15))++
		*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt64(localVar) >> libc.Int32FromInt32(8))
		v17 = envPtr + 152
		v16 = *(*uintptr)(unsafe.Pointer(v17))
		*(*uintptr)(unsafe.Pointer(v17))++
		*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt64(localVar))
	case int32(ASSEM_DICT_UNSET):
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(3) {
			XTcl_WrongNumArgs(tls, interp, int64(1), bp+8, __ccgo_ts+3688)
			goto cleanup
		}
		if _GetIntegerOperand(tls, assemEnvPtr, bp, bp+40) != TCL_OK || _CheckStrictlyPositive(tls, interp, *(*int32)(unsafe.Pointer(bp + 40))) != TCL_OK {
			goto cleanup
		}
		localVar = libc.Int64FromUint64(_FindLocalVar(tls, assemEnvPtr, bp))
		if localVar < 0 {
			goto cleanup
		}
		_BBEmitInstInt4(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp + 16)), *(*int32)(unsafe.Pointer(bp + 40)), *(*int32)(unsafe.Pointer(bp + 40)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr)
		}
		v19 = envPtr + 152
		v18 = *(*uintptr)(unsafe.Pointer(v19))
		*(*uintptr)(unsafe.Pointer(v19))++
		*(*uint8)(unsafe.Pointer(v18)) = uint8(libc.Uint32FromInt64(localVar) >> libc.Int32FromInt32(24))
		v21 = envPtr + 152
		v20 = *(*uintptr)(unsafe.Pointer(v21))
		*(*uintptr)(unsafe.Pointer(v21))++
		*(*uint8)(unsafe.Pointer(v20)) = uint8(libc.Uint32FromInt64(localVar) >> libc.Int32FromInt32(16))
		v23 = envPtr + 152
		v22 = *(*uintptr)(unsafe.Pointer(v23))
		*(*uintptr)(unsafe.Pointer(v23))++
		*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt64(localVar) >> libc.Int32FromInt32(8))
		v25 = envPtr + 152
		v24 = *(*uintptr)(unsafe.Pointer(v25))
		*(*uintptr)(unsafe.Pointer(v25))++
		*(*uint8)(unsafe.Pointer(v24)) = uint8(libc.Uint32FromInt64(localVar))
	case int32(ASSEM_END_CATCH):
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(1) {
			XTcl_WrongNumArgs(tls, interp, int64(1), bp+8, __ccgo_ts+1945)
			goto cleanup
		}
		*(*int32)(unsafe.Pointer((*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fcurr_bb + 112)) |= int32(BB_ENDCATCH)
		_BBEmitOpcode(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp + 16)), 0)
		_StartBasicBlock(tls, assemEnvPtr, int32(BB_FALLTHRU), libc.UintptrFromInt32(0))
	case int32(ASSEM_EVAL):
		/* TODO - Refactor this stuff into a subroutine that takes the inst
		 * code, the message ("script" or "expression") and an evaluator
		 * callback that calls TclCompileScript or TclCompileExpr. */
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
			if _TalInstructionTable[*(*int32)(unsafe.Pointer(bp + 16))].FtclInstCode == int32(INST_EVAL_STK) {
				v26 = __ccgo_ts + 3702
			} else {
				v26 = __ccgo_ts + 3709
			}
			XTcl_WrongNumArgs(tls, interp, int64(1), bp+8, v26)
			goto cleanup
		}
		if (*TTcl_Token)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_CompileEmbeddedScript(tls, assemEnvPtr, *(*uintptr)(unsafe.Pointer(bp))+uintptr(1)*32, uintptr(unsafe.Pointer(&_TalInstructionTable))+uintptr(*(*int32)(unsafe.Pointer(bp + 16)))*24)
		} else {
			if _GetNextOperand(tls, assemEnvPtr, bp, bp+24) != TCL_OK {
				goto cleanup
			} else {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Fbytes != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Flength
					v27 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Fbytes
				} else {
					v27 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 24)), bp+32)
				}
				operand1 = v27
				litIndex = XTclRegisterLiteral(tls, envPtr, operand1, *(*TTcl_Size)(unsafe.Pointer(bp + 32)), 0)
				/*
				 * Assumes that PUSH is the first slot!
				 */
				_BBEmitInst1or4(tls, assemEnvPtr, 0, litIndex, 0)
				_BBEmitOpcode(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp + 16)), 0)
			}
		}
	case int32(ASSEM_INVOKE):
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
			XTcl_WrongNumArgs(tls, interp, int64(1), bp+8, __ccgo_ts+3682)
			goto cleanup
		}
		if _GetIntegerOperand(tls, assemEnvPtr, bp, bp+40) != TCL_OK || _CheckStrictlyPositive(tls, interp, *(*int32)(unsafe.Pointer(bp + 40))) != TCL_OK {
			goto cleanup
		}
		_BBEmitInst1or4(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp + 16)), *(*int32)(unsafe.Pointer(bp + 40)), *(*int32)(unsafe.Pointer(bp + 40)))
	case int32(ASSEM_JUMP):
		fallthrough
	case int32(ASSEM_JUMP4):
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
			XTcl_WrongNumArgs(tls, interp, int64(1), bp+8, __ccgo_ts+2727)
			goto cleanup
		}
		if _GetNextOperand(tls, assemEnvPtr, bp, bp+24) != TCL_OK {
			goto cleanup
		}
		(*TBasicBlock)(unsafe.Pointer((*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fcurr_bb)).FjumpOffset = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart))
		if instType == int32(ASSEM_JUMP) {
			flags = int32(BB_JUMP1)
			_BBEmitInstInt1(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp + 16)), 0, 0)
		} else {
			flags = 0
			_BBEmitInstInt4(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp + 16)), 0, 0)
		}
		/*
		 * Start a new basic block at the instruction following the jump.
		 */
		(*TBasicBlock)(unsafe.Pointer((*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fcurr_bb)).FjumpLine = int32((*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FcmdLine)
		if _TalInstructionTable[*(*int32)(unsafe.Pointer(bp + 16))].FoperandsConsumed != 0 {
			flags |= int32(BB_FALLTHRU)
		}
		_StartBasicBlock(tls, assemEnvPtr, flags, *(*uintptr)(unsafe.Pointer(bp + 24)))
	case int32(ASSEM_JUMPTABLE):
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
			XTcl_WrongNumArgs(tls, interp, int64(1), bp+8, __ccgo_ts+3720)
			goto cleanup
		}
		if _GetNextOperand(tls, assemEnvPtr, bp, bp+24) != TCL_OK {
			goto cleanup
		}
		jtPtr = XTcl_Alloc(tls, uint64(104))
		XTcl_InitHashTable(tls, jtPtr, TCL_STRING_KEYS)
		(*TBasicBlock)(unsafe.Pointer((*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fcurr_bb)).FjumpLine = int32((*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FcmdLine)
		(*TBasicBlock)(unsafe.Pointer((*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fcurr_bb)).FjumpOffset = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart))
		infoIndex = int32(XTclCreateAuxData(tls, jtPtr, uintptr(unsafe.Pointer(&XtclJumptableInfoType)), envPtr))
		_BBEmitInstInt4(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp + 16)), infoIndex, 0)
		if _CreateMirrorJumpTable(tls, assemEnvPtr, *(*uintptr)(unsafe.Pointer(bp + 24))) != TCL_OK {
			goto cleanup
		}
		_StartBasicBlock(tls, assemEnvPtr, int32(BB_JUMPTABLE)|int32(BB_FALLTHRU), libc.UintptrFromInt32(0))
	case int32(ASSEM_LABEL):
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
			XTcl_WrongNumArgs(tls, interp, int64(1), bp+8, __ccgo_ts+3726)
			goto cleanup
		}
		if _GetNextOperand(tls, assemEnvPtr, bp, bp+24) != TCL_OK {
			goto cleanup
		}
		/*
		 * Add the (label_name, address) pair to the hash table.
		 */
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Fbytes != 0 {
			v28 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Fbytes
		} else {
			v28 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 24)), libc.UintptrFromInt32(0))
		}
		if _DefineLabel(tls, assemEnvPtr, v28) != TCL_OK {
			goto cleanup
		}
	case int32(ASSEM_LINDEX_MULTI):
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
			XTcl_WrongNumArgs(tls, interp, int64(1), bp+8, __ccgo_ts+3682)
			goto cleanup
		}
		if _GetIntegerOperand(tls, assemEnvPtr, bp, bp+40) != TCL_OK || _CheckStrictlyPositive(tls, interp, *(*int32)(unsafe.Pointer(bp + 40))) != TCL_OK {
			goto cleanup
		}
		_BBEmitInstInt4(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp + 16)), *(*int32)(unsafe.Pointer(bp + 40)), *(*int32)(unsafe.Pointer(bp + 40)))
	case int32(ASSEM_LIST):
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
			XTcl_WrongNumArgs(tls, interp, int64(1), bp+8, __ccgo_ts+3682)
			goto cleanup
		}
		if _GetIntegerOperand(tls, assemEnvPtr, bp, bp+40) != TCL_OK || _CheckNonNegative(tls, interp, *(*int32)(unsafe.Pointer(bp + 40))) != TCL_OK {
			goto cleanup
		}
		_BBEmitInstInt4(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp + 16)), *(*int32)(unsafe.Pointer(bp + 40)), *(*int32)(unsafe.Pointer(bp + 40)))
	case int32(ASSEM_INDEX):
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
			XTcl_WrongNumArgs(tls, interp, int64(1), bp+8, __ccgo_ts+3682)
			goto cleanup
		}
		if _GetListIndexOperand(tls, assemEnvPtr, bp, bp+40) != TCL_OK {
			goto cleanup
		}
		_BBEmitInstInt4(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp + 16)), *(*int32)(unsafe.Pointer(bp + 40)), *(*int32)(unsafe.Pointer(bp + 40)))
	case int32(ASSEM_LSET_FLAT):
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
			XTcl_WrongNumArgs(tls, interp, int64(1), bp+8, __ccgo_ts+3682)
			goto cleanup
		}
		if _GetIntegerOperand(tls, assemEnvPtr, bp, bp+40) != TCL_OK {
			goto cleanup
		}
		if *(*int32)(unsafe.Pointer(bp + 40)) < int32(2) {
			if (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fflags&int32(TCL_EVAL_DIRECT) != 0 {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+3731, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+56, __ccgo_ts+2004, __ccgo_ts+3663, __ccgo_ts+3751, libc.UintptrFromInt32(0)))
			}
			goto cleanup
		}
		_BBEmitInstInt4(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp + 16)), *(*int32)(unsafe.Pointer(bp + 40)), *(*int32)(unsafe.Pointer(bp + 40)))
	case int32(ASSEM_LVT):
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
			XTcl_WrongNumArgs(tls, interp, int64(1), bp+8, __ccgo_ts+3762)
			goto cleanup
		}
		localVar = libc.Int64FromUint64(_FindLocalVar(tls, assemEnvPtr, bp))
		if localVar < 0 {
			goto cleanup
		}
		_BBEmitInst1or4(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp + 16)), int32(localVar), 0)
	case int32(ASSEM_LVT1):
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
			XTcl_WrongNumArgs(tls, interp, int64(1), bp+8, __ccgo_ts+3762)
			goto cleanup
		}
		localVar = libc.Int64FromUint64(_FindLocalVar(tls, assemEnvPtr, bp))
		if localVar < 0 || _CheckOneByte(tls, interp, int32(localVar)) != 0 {
			goto cleanup
		}
		_BBEmitInstInt1(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp + 16)), int32(localVar), 0)
	case int32(ASSEM_LVT1_SINT1):
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(3) {
			XTcl_WrongNumArgs(tls, interp, int64(1), bp+8, __ccgo_ts+3770)
			goto cleanup
		}
		localVar = libc.Int64FromUint64(_FindLocalVar(tls, assemEnvPtr, bp))
		if localVar < 0 || _CheckOneByte(tls, interp, int32(localVar)) != 0 || _GetIntegerOperand(tls, assemEnvPtr, bp, bp+40) != TCL_OK || _CheckSignedOneByte(tls, interp, *(*int32)(unsafe.Pointer(bp + 40))) != 0 {
			goto cleanup
		}
		_BBEmitInstInt1(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp + 16)), int32(localVar), 0)
		if (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr)
		}
		v30 = envPtr + 152
		v29 = *(*uintptr)(unsafe.Pointer(v30))
		*(*uintptr)(unsafe.Pointer(v30))++
		*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 40))))
	case int32(ASSEM_LVT4):
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
			XTcl_WrongNumArgs(tls, interp, int64(1), bp+8, __ccgo_ts+3762)
			goto cleanup
		}
		localVar = libc.Int64FromUint64(_FindLocalVar(tls, assemEnvPtr, bp))
		if localVar < 0 {
			goto cleanup
		}
		_BBEmitInstInt4(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp + 16)), int32(localVar), 0)
	case int32(ASSEM_OVER):
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
			XTcl_WrongNumArgs(tls, interp, int64(1), bp+8, __ccgo_ts+3682)
			goto cleanup
		}
		if _GetIntegerOperand(tls, assemEnvPtr, bp, bp+40) != TCL_OK || _CheckNonNegative(tls, interp, *(*int32)(unsafe.Pointer(bp + 40))) != TCL_OK {
			goto cleanup
		}
		_BBEmitInstInt4(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp + 16)), *(*int32)(unsafe.Pointer(bp + 40)), *(*int32)(unsafe.Pointer(bp + 40))+int32(1))
	case int32(ASSEM_REGEXP):
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
			XTcl_WrongNumArgs(tls, interp, int64(1), bp+8, __ccgo_ts+3611)
			goto cleanup
		}
		if _GetBooleanOperand(tls, assemEnvPtr, bp, bp+40) != TCL_OK {
			goto cleanup
		}
		if *(*int32)(unsafe.Pointer(bp + 40)) != 0 {
			v31 = int32(TCL_REG_NOCASE)
		} else {
			v31 = 0
		}
		_BBEmitInstInt1(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp + 16)), int32(TCL_REG_ADVANCED)|v31, 0)
	case int32(ASSEM_REVERSE):
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
			XTcl_WrongNumArgs(tls, interp, int64(1), bp+8, __ccgo_ts+3682)
			goto cleanup
		}
		if _GetIntegerOperand(tls, assemEnvPtr, bp, bp+40) != TCL_OK || _CheckNonNegative(tls, interp, *(*int32)(unsafe.Pointer(bp + 40))) != TCL_OK {
			goto cleanup
		}
		_BBEmitInstInt4(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp + 16)), *(*int32)(unsafe.Pointer(bp + 40)), *(*int32)(unsafe.Pointer(bp + 40)))
	case int32(ASSEM_SINT1):
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
			XTcl_WrongNumArgs(tls, interp, int64(1), bp+8, __ccgo_ts+3635)
			goto cleanup
		}
		if _GetIntegerOperand(tls, assemEnvPtr, bp, bp+40) != TCL_OK || _CheckSignedOneByte(tls, interp, *(*int32)(unsafe.Pointer(bp + 40))) != TCL_OK {
			goto cleanup
		}
		_BBEmitInstInt1(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp + 16)), *(*int32)(unsafe.Pointer(bp + 40)), 0)
	case int32(ASSEM_SINT4_LVT4):
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(3) {
			XTcl_WrongNumArgs(tls, interp, int64(1), bp+8, __ccgo_ts+3688)
			goto cleanup
		}
		if _GetIntegerOperand(tls, assemEnvPtr, bp, bp+40) != TCL_OK {
			goto cleanup
		}
		localVar = libc.Int64FromUint64(_FindLocalVar(tls, assemEnvPtr, bp))
		if localVar < 0 {
			goto cleanup
		}
		_BBEmitInstInt4(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp + 16)), *(*int32)(unsafe.Pointer(bp + 40)), 0)
		if (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr)
		}
		v33 = envPtr + 152
		v32 = *(*uintptr)(unsafe.Pointer(v33))
		*(*uintptr)(unsafe.Pointer(v33))++
		*(*uint8)(unsafe.Pointer(v32)) = uint8(libc.Uint32FromInt64(localVar) >> libc.Int32FromInt32(24))
		v35 = envPtr + 152
		v34 = *(*uintptr)(unsafe.Pointer(v35))
		*(*uintptr)(unsafe.Pointer(v35))++
		*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt64(localVar) >> libc.Int32FromInt32(16))
		v37 = envPtr + 152
		v36 = *(*uintptr)(unsafe.Pointer(v37))
		*(*uintptr)(unsafe.Pointer(v37))++
		*(*uint8)(unsafe.Pointer(v36)) = uint8(libc.Uint32FromInt64(localVar) >> libc.Int32FromInt32(8))
		v39 = envPtr + 152
		v38 = *(*uintptr)(unsafe.Pointer(v39))
		*(*uintptr)(unsafe.Pointer(v39))++
		*(*uint8)(unsafe.Pointer(v38)) = uint8(libc.Uint32FromInt64(localVar))
	default:
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != 0 {
			v40 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes
		} else {
			v40 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), libc.UintptrFromInt32(0))
		}
		XTcl_Panic(tls, __ccgo_ts+3783, libc.VaList(bp+56, v40))
	}
	status = TCL_OK
	goto cleanup
cleanup:
	;
	_objPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
	v42 = _objPtr
	v41 = *(*TTcl_Size)(unsafe.Pointer(v42))
	*(*TTcl_Size)(unsafe.Pointer(v42))--
	if v41 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	if *(*uintptr)(unsafe.Pointer(bp + 24)) != 0 {
		_objPtr1 = *(*uintptr)(unsafe.Pointer(bp + 24))
		v44 = _objPtr1
		v43 = *(*TTcl_Size)(unsafe.Pointer(v44))
		*(*TTcl_Size)(unsafe.Pointer(v44))--
		if v43 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
	return status
}

/*
 *-----------------------------------------------------------------------------
 *
 * CompileEmbeddedScript --
 *
 *	Compile an embedded 'eval' or 'expr' that appears in assembly code.
 *
 * This procedure is called when the 'eval' or 'expr' assembly directive is
 * encountered, and the argument to the directive is a simple word that
 * requires no substitution. The appropriate compiler (TclCompileScript or
 * TclCompileExpr) is invoked recursively, and emits bytecode.
 *
 * Before the compiler is invoked, the compilation environment's stack
 * consumption is reset to zero. Upon return from the compilation, the net
 * stack effect of the compilation is in the compiler env, and this stack
 * effect is posted to the assembler environment. The compile environment's
 * stack consumption is then restored to what it was before (which is actually
 * the state of the stack on entry to the block of assembly code).
 *
 * Any exception ranges pushed by the compilation are copied to the basic
 * block and removed from the compiler environment. They will be rebuilt at
 * the end of assembly, when the exception stack depth is actually known.
 *
 *-----------------------------------------------------------------------------
 */

func _CompileEmbeddedScript(tls *libc.TLS, assemEnvPtr uintptr, tokenPtr uintptr, instPtr uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Instruction that determines whether
	 * the script is 'expr' or 'eval' */
	var envPtr, interp uintptr
	var savedExceptArrayNext int32
	var savedMaxStackDepth, savedStackDepth Tsize_t
	_, _, _, _, _ = envPtr, interp, savedExceptArrayNext, savedMaxStackDepth, savedStackDepth
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr
	/* Compilation environment */
	interp = (*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr
	/* Tcl interpreter */
	/*
	 * The expression or script is not only known at compile time, but
	 * actually a "simple word". It can be compiled inline by invoking the
	 * compiler recursively.
	 *
	 * Save away the stack depth and reset it before compiling the script.
	 * We'll record the stack usage of the script in the BasicBlock, and
	 * accumulate it together with the stack usage of the enclosing assembly
	 * code.
	 */
	savedStackDepth = libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcurrStackDepth)
	savedMaxStackDepth = libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr)).FmaxStackDepth)
	savedExceptArrayNext = int32((*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayNext)
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FcurrStackDepth = 0
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FmaxStackDepth = 0
	_StartBasicBlock(tls, assemEnvPtr, int32(BB_FALLTHRU), libc.UintptrFromInt32(0))
	switch (*TTalInstDesc)(unsafe.Pointer(instPtr)).FtclInstCode {
	case int32(INST_EVAL_STK):
		XTclCompileScript(tls, interp, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize, envPtr)
	case int32(INST_EXPR_STK):
		XTclCompileExpr(tls, interp, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize, envPtr, int32(1))
	default:
		XTcl_Panic(tls, __ccgo_ts+3834, libc.VaList(bp+8, (*TTalInstDesc)(unsafe.Pointer(instPtr)).Fname, (*TTalInstDesc)(unsafe.Pointer(instPtr)).FtclInstCode))
	}
	/*
	 * Roll up the stack usage of the embedded block into the assembler
	 * environment.
	 */
	_SyncStackDepth(tls, assemEnvPtr)
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FcurrStackDepth = libc.Int64FromUint64(savedStackDepth)
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FmaxStackDepth = libc.Int64FromUint64(savedMaxStackDepth)
	/*
	 * Save any exception ranges that were pushed by the compiler; they will
	 * need to be fixed up once the stack depth is known.
	 */
	_MoveExceptionRangesToBasicBlock(tls, assemEnvPtr, savedExceptArrayNext)
	/*
	 * Flush the current basic block.
	 */
	_StartBasicBlock(tls, assemEnvPtr, int32(BB_FALLTHRU), libc.UintptrFromInt32(0))
}

/*
 *-----------------------------------------------------------------------------
 *
 * SyncStackDepth --
 *
 *	Copies the stack depth from the compile environment to a basic block.
 *
 * Side effects:
 *	Current and max stack depth in the current basic block are adjusted.
 *
 * This procedure is called on return from invoking the compiler for the
 * 'eval' and 'expr' operations. It adjusts the stack depth of the current
 * basic block to reflect the stack required by the just-compiled code.
 *
 *-----------------------------------------------------------------------------
 */

func _SyncStackDepth(tls *libc.TLS, assemEnvPtr uintptr) {
	/* Assembly environment */
	var curr_bb, envPtr, p1 uintptr
	var maxStackDepth int32
	_, _, _, _ = curr_bb, envPtr, maxStackDepth, p1
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr
	/* Compilation environment */
	curr_bb = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fcurr_bb
	/* Current basic block */
	maxStackDepth = int32(int64((*TBasicBlock)(unsafe.Pointer(curr_bb)).FfinalStackDepth) + (*TCompileEnv)(unsafe.Pointer(envPtr)).FmaxStackDepth)
	/* Max stack depth in the basic block */
	if maxStackDepth > (*TBasicBlock)(unsafe.Pointer(curr_bb)).FmaxStackDepth {
		(*TBasicBlock)(unsafe.Pointer(curr_bb)).FmaxStackDepth = maxStackDepth
	}
	p1 = curr_bb + 68
	*(*int32)(unsafe.Pointer(p1)) = int32(int64(*(*int32)(unsafe.Pointer(p1))) + (*TCompileEnv)(unsafe.Pointer(envPtr)).FcurrStackDepth)
}

/*
 *-----------------------------------------------------------------------------
 *
 * MoveExceptionRangesToBasicBlock --
 *
 *	Removes exception ranges that were created by compiling an embedded
 *	script from the CompileEnv, and stores them in the BasicBlock. They
 *	will be reinstalled, at the correct stack depth, after control flow
 *	analysis is complete on the assembly code.
 *
 *-----------------------------------------------------------------------------
 */

func _MoveExceptionRangesToBasicBlock(tls *libc.TLS, assemEnvPtr uintptr, savedExceptArrayNext int32) {
	/* Saved index of the end of the exception
	 * range array */
	var curr_bb, envPtr uintptr
	var exceptionCount, i int32
	_, _, _, _ = curr_bb, envPtr, exceptionCount, i
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr
	/* Compilation environment */
	curr_bb = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fcurr_bb
	/* Current basic block */
	exceptionCount = int32((*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayNext - int64(savedExceptArrayNext))
	if exceptionCount == 0 {
		/* Nothing to do */
		return
	}
	/*
	 * Save the exception ranges in the basic block. They will be re-added at
	 * the conclusion of assembly; at this time, the INST_BEGIN_CATCH
	 * instructions in the block will be adjusted from whatever range indices
	 * they have [savedExceptArrayNext .. envPtr->exceptArrayNext) to the
	 * indices that the exceptions acquire. The saved exception ranges are
	 * converted to a relative nesting depth. The depth will be recomputed
	 * once flow analysis has determined the actual stack depth of the block.
	 */
	(*TBasicBlock)(unsafe.Pointer(curr_bb)).FforeignExceptionBase = savedExceptArrayNext
	(*TBasicBlock)(unsafe.Pointer(curr_bb)).FforeignExceptionCount = exceptionCount
	(*TBasicBlock)(unsafe.Pointer(curr_bb)).FforeignExceptions = XTcl_Alloc(tls, libc.Uint64FromInt32(exceptionCount)*uint64(56))
	libc.Xmemcpy(tls, (*TBasicBlock)(unsafe.Pointer(curr_bb)).FforeignExceptions, (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayPtr+uintptr(savedExceptArrayNext)*56, libc.Uint64FromInt32(exceptionCount)*uint64(56))
	i = 0
	for {
		if !(i < exceptionCount) {
			break
		}
		(*(*TExceptionRange)(unsafe.Pointer((*TBasicBlock)(unsafe.Pointer(curr_bb)).FforeignExceptions + uintptr(i)*56))).FnestingLevel -= (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptDepth
		goto _1
	_1:
		;
		i++
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayNext = int64(savedExceptArrayNext)
}

/*
 *-----------------------------------------------------------------------------
 *
 * CreateMirrorJumpTable --
 *
 *	Makes a jump table with comparison values and assembly code labels.
 *
 * Results:
 *	Returns a standard Tcl status, with an error message in the
 *	interpreter on error.
 *
 * Side effects:
 *	Initializes the jump table pointer in the current basic block to a
 *	JumptableInfo. The keys in the JumptableInfo are the comparison
 *	strings. The values, instead of being jump displacements, are
 *	Tcl_Obj's with the code labels.
 */

func _CreateMirrorJumpTable(tls *libc.TLS, assemEnvPtr uintptr, jumps uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* List of alternating keywords and labels */
	var bbPtr, envPtr, hashEntry, interp, jtHashPtr, jtPtr, v7, v8 uintptr
	var i TTcl_Size
	var v1, v3 int32
	var v2, v4, v5 int64
	var _ /* isNew at bp+16 */ int32
	var _ /* objc at bp+0 */ TTcl_Size
	var _ /* objv at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = bbPtr, envPtr, hashEntry, i, interp, jtHashPtr, jtPtr, v1, v2, v3, v4, v5, v7, v8 /* Pointers to the elements in the list */
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr
	/* Compilation environment */
	interp = (*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr
	/* Tcl interpreter */
	bbPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fcurr_bb
	if (*TTcl_Obj)(unsafe.Pointer(jumps)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(jumps + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(jumps + 32))).Fptr2)).FspanLength
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(jumps + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v2
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjLength(tls, interp, jumps, bp)
	}
	if v1 != TCL_OK {
		return int32(TCL_ERROR)
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp))%int64(2) != 0 {
		if (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fflags&int32(TCL_EVAL_DIRECT) != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+3879, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+32, __ccgo_ts+2004, __ccgo_ts+3663, __ccgo_ts+3932, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(jumps)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(jumps + 32))).Fptr2 != 0 {
			v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(jumps + 32))).Fptr2)).FspanStart
		} else {
			v4 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(jumps + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(jumps + 32))).Fptr1 + 40 + uintptr(v4)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(jumps + 32))).Fptr2 != 0 {
			v5 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(jumps + 32))).Fptr2)).FspanLength
		} else {
			v5 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(jumps + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v5
		v3 = libc.Int32FromInt32(TCL_OK)
	} else {
		v3 = XTcl_ListObjGetElements(tls, interp, jumps, bp, bp+8)
	}
	if v3 != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Allocate the jumptable.
	 */
	jtPtr = XTcl_Alloc(tls, uint64(104))
	jtHashPtr = jtPtr
	XTcl_InitHashTable(tls, jtHashPtr, TCL_STRING_KEYS)
	/*
	 * Fill the keys and labels into the table.
	 */
	i = 0
	for {
		if !(i < *(*TTcl_Size)(unsafe.Pointer(bp))) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)))).Fbytes != 0 {
			v7 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)))).Fbytes
		} else {
			v7 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		hashEntry = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(jtHashPtr)).FcreateProc})))(tls, jtHashPtr, v7, bp+16)
		if !(*(*int32)(unsafe.Pointer(bp + 16)) != 0) {
			if (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fflags&int32(TCL_EVAL_DIRECT) != 0 {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)))).Fbytes != 0 {
					v8 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)))).Fbytes
				} else {
					v8 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)), libc.UintptrFromInt32(0))
				}
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+3945, libc.VaList(bp+32, v8)))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+32, __ccgo_ts+2004, __ccgo_ts+3663, __ccgo_ts+3984, libc.UintptrFromInt32(0)))
				_DeleteMirrorJumpTable(tls, jtPtr)
				return int32(TCL_ERROR)
			}
		}
		(*TTcl_HashEntry)(unsafe.Pointer(hashEntry)).FclientData = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i+int64(1))*8))
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i+int64(1))*8)))).FrefCount++
		goto _6
	_6:
		;
		i += int64(2)
	}
	/*
	 * Put the mirror jumptable in the basic block struct.
	 */
	(*TBasicBlock)(unsafe.Pointer(bbPtr)).FjtPtr = jtPtr
	return TCL_OK
}

/*
 *-----------------------------------------------------------------------------
 *
 * DeleteMirrorJumpTable --
 *
 *	Cleans up a jump table when the basic block is deleted.
 *
 *-----------------------------------------------------------------------------
 */

func _DeleteMirrorJumpTable(tls *libc.TLS, jtPtr uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _objPtr, entry, jtHashPtr, label, v3 uintptr
	var v2 TTcl_Size
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _ = _objPtr, entry, jtHashPtr, label, v2, v3
	jtHashPtr = jtPtr /* Jump label from the hash table */
	entry = XTcl_FirstHashEntry(tls, jtHashPtr, bp)
	for {
		if !(entry != libc.UintptrFromInt32(0)) {
			break
		}
		label = (*TTcl_HashEntry)(unsafe.Pointer(entry)).FclientData
		_objPtr = label
		v3 = _objPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		(*TTcl_HashEntry)(unsafe.Pointer(entry)).FclientData = libc.UintptrFromInt32(0)
		goto _1
	_1:
		;
		entry = XTcl_NextHashEntry(tls, bp)
	}
	XTcl_DeleteHashTable(tls, jtHashPtr)
	XTclpFree(tls, jtPtr)
}

/*
 *-----------------------------------------------------------------------------
 *
 * GetNextOperand --
 *
 *	Retrieves the next operand in sequence from an assembly instruction,
 *	and makes sure that its value is known at compile time.
 *
 * Results:
 *	If successful, returns TCL_OK and leaves a Tcl_Obj with the operand
 *	text in *operandObjPtr. In case of failure, returns TCL_ERROR and
 *	leaves *operandObjPtr untouched.
 *
 * Side effects:
 *	Advances *tokenPtrPtr around the token just processed.
 *
 *-----------------------------------------------------------------------------
 */

func _GetNextOperand(tls *libc.TLS, assemEnvPtr uintptr, tokenPtrPtr uintptr, operandObjPtr uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* OUTPUT: Tcl object holding the operand text
	 * with \-substitutions done. */
	var _objPtr, cachePtr, interp, operandObj, v3 uintptr
	var v1 bool
	var v2 TTcl_Size
	_, _, _, _, _, _, _ = _objPtr, cachePtr, interp, operandObj, v1, v2, v3
	interp = (*TCompileEnv)(unsafe.Pointer((*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr)).FiPtr
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		operandObj = XTclThreadAllocObj(tls)
	} else {
		operandObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(operandObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(operandObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(operandObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(operandObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(operandObj)).FtypePtr = libc.UintptrFromInt32(0)
	if !(XTclWordKnownAtCompileTime(tls, *(*uintptr)(unsafe.Pointer(tokenPtrPtr)), operandObj) != 0) {
		_objPtr = operandObj
		v3 = _objPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		if (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fflags&int32(TCL_EVAL_DIRECT) != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+4002, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+3663, __ccgo_ts+4046, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	*(*uintptr)(unsafe.Pointer(tokenPtrPtr)) = *(*uintptr)(unsafe.Pointer(tokenPtrPtr)) + uintptr((*TTcl_Token)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tokenPtrPtr)))).FnumComponents+libc.Int64FromInt32(1))*32
	(*TTcl_Obj)(unsafe.Pointer(operandObj)).FrefCount++
	*(*uintptr)(unsafe.Pointer(operandObjPtr)) = operandObj
	return TCL_OK
}

/*
 *-----------------------------------------------------------------------------
 *
 * GetBooleanOperand --
 *
 *	Retrieves a Boolean operand from the input stream and advances
 *	the token pointer.
 *
 * Results:
 *	Returns a standard Tcl result (with an error message in the
 *	interpreter on failure).
 *
 * Side effects:
 *	Stores the Boolean value in (*result) and advances (*tokenPtrPtr)
 *	to the next token.
 *
 *-----------------------------------------------------------------------------
 */

func _GetBooleanOperand(tls *libc.TLS, assemEnvPtr uintptr, tokenPtrPtr uintptr, result uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* OUTPUT: Integer extracted from the token */
	var _objPtr, envPtr, interp, tokenPtr, v2 uintptr
	var status int32
	var v1 TTcl_Size
	var _ /* intObj at bp+0 */ uintptr
	_, _, _, _, _, _, _ = _objPtr, envPtr, interp, status, tokenPtr, v1, v2
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr
	/* Compilation environment */
	interp = (*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr
	/* Tcl interpreter */
	tokenPtr = *(*uintptr)(unsafe.Pointer(tokenPtrPtr)) /* Tcl status return */
	/*
	 * Extract the next token as a string.
	 */
	if _GetNextOperand(tls, assemEnvPtr, tokenPtrPtr, bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Convert to an integer, advance to the next token and return.
	 */
	status = XTcl_GetBoolFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), (libc.Int32FromInt32(TCL_NULL_OK)-libc.Int32FromInt32(2))&libc.Int32FromInt64(4), result)
	_objPtr = *(*uintptr)(unsafe.Pointer(bp))
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	*(*uintptr)(unsafe.Pointer(tokenPtrPtr)) = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	return status
}

/*
 *-----------------------------------------------------------------------------
 *
 * GetIntegerOperand --
 *
 *	Retrieves an integer operand from the input stream and advances the
 *	token pointer.
 *
 * Results:
 *	Returns a standard Tcl result (with an error message in the
 *	interpreter on failure).
 *
 * Side effects:
 *	Stores the integer value in (*result) and advances (*tokenPtrPtr) to
 *	the next token.
 *
 *-----------------------------------------------------------------------------
 */

func _GetIntegerOperand(tls *libc.TLS, assemEnvPtr uintptr, tokenPtrPtr uintptr, result uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* OUTPUT: Integer extracted from the token */
	var _objPtr, envPtr, interp, tokenPtr, v2 uintptr
	var status int32
	var v1 TTcl_Size
	var _ /* intObj at bp+0 */ uintptr
	_, _, _, _, _, _, _ = _objPtr, envPtr, interp, status, tokenPtr, v1, v2
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr
	/* Compilation environment */
	interp = (*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr
	/* Tcl interpreter */
	tokenPtr = *(*uintptr)(unsafe.Pointer(tokenPtrPtr)) /* Tcl status return */
	/*
	 * Extract the next token as a string.
	 */
	if _GetNextOperand(tls, assemEnvPtr, tokenPtrPtr, bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Convert to an integer, advance to the next token and return.
	 */
	status = XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), result)
	_objPtr = *(*uintptr)(unsafe.Pointer(bp))
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	*(*uintptr)(unsafe.Pointer(tokenPtrPtr)) = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	return status
}

/*
 *-----------------------------------------------------------------------------
 *
 * GetListIndexOperand --
 *
 *	Gets the value of an operand intended to serve as a list index.
 *
 * Results:
 *	Returns a standard Tcl result: TCL_OK if the parse is successful and
 *	TCL_ERROR (with an appropriate error message) if the parse fails.
 *
 * Side effects:
 *	Stores the list index at '*index'. Values between -1 and 0x7FFFFFFF
 *	have their natural meaning; values between -2 and -0x80000000
 *	represent 'end-2-N'.
 *
 *-----------------------------------------------------------------------------
 */

func _GetListIndexOperand(tls *libc.TLS, assemEnvPtr uintptr, tokenPtrPtr uintptr, result uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* OUTPUT: encoded index derived from the token */
	var _objPtr, envPtr, interp, tokenPtr, v2 uintptr
	var status int32
	var v1 TTcl_Size
	var _ /* value at bp+0 */ uintptr
	_, _, _, _, _, _, _ = _objPtr, envPtr, interp, status, tokenPtr, v1, v2
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr
	/* Compilation environment */
	interp = (*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr
	/* Tcl interpreter */
	tokenPtr = *(*uintptr)(unsafe.Pointer(tokenPtrPtr))
	/* General operand validity check */
	if _GetNextOperand(tls, assemEnvPtr, tokenPtrPtr, bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	/* Convert to an integer, advance to the next token and return. */
	/*
	 * NOTE: Indexing a list with an index before it yields the
	 * same result as indexing after it, and might be more easily portable
	 * when list size limits grow.
	 */
	status = XTclIndexEncode(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), int32(int64(-libc.Int32FromInt32(1))), int32(int64(-libc.Int32FromInt32(1))), result)
	_objPtr = *(*uintptr)(unsafe.Pointer(bp))
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	*(*uintptr)(unsafe.Pointer(tokenPtrPtr)) = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	return status
}

/*
 *-----------------------------------------------------------------------------
 *
 * FindLocalVar --
 *
 *	Gets the name of a local variable from the input stream and advances
 *	the token pointer.
 *
 * Results:
 *	Returns the LVT index of the local variable.  Returns -1 if the
 *	variable is non-local, not known at compile time, or cannot be
 *	installed in the LVT (leaving an error message in the interpreter
 *	result if necessary).
 *
 * Side effects:
 *	Advances the token pointer.  May define a new LVT slot if the variable
 *	has not yet been seen and the execution context allows for it.
 *
 *-----------------------------------------------------------------------------
 */

func _FindLocalVar(tls *libc.TLS, assemEnvPtr uintptr, tokenPtrPtr uintptr) (r Tsize_t) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var _objPtr, _objPtr1, envPtr, interp, tokenPtr, varNameStr, v1, v3, v5 uintptr
	var localVar, v2, v4 TTcl_Size
	var _ /* varNameLen at bp+8 */ TTcl_Size
	var _ /* varNameObj at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, envPtr, interp, localVar, tokenPtr, varNameStr, v1, v2, v3, v4, v5
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr
	/* Compilation environment */
	interp = (*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr
	/* Tcl interpreter */
	tokenPtr = *(*uintptr)(unsafe.Pointer(tokenPtrPtr)) /* Index of the variable in the LVT */
	if _GetNextOperand(tls, assemEnvPtr, tokenPtrPtr, bp) != TCL_OK {
		return libc.Uint64FromInt64(int64(-libc.Int32FromInt32(1)))
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+8)
	}
	varNameStr = v1
	if _CheckNamespaceQualifiers(tls, interp, varNameStr, int32(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))) != 0 {
		_objPtr = *(*uintptr)(unsafe.Pointer(bp))
		v3 = _objPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		return libc.Uint64FromInt64(int64(-libc.Int32FromInt32(1)))
	}
	localVar = XTclFindCompiledLocal(tls, varNameStr, *(*TTcl_Size)(unsafe.Pointer(bp + 8)), int32(1), envPtr)
	_objPtr1 = *(*uintptr)(unsafe.Pointer(bp))
	v5 = _objPtr1
	v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
	*(*TTcl_Size)(unsafe.Pointer(v5))--
	if v4 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	if localVar < 0 {
		if (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fflags&int32(TCL_EVAL_DIRECT) != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+4054, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+3663, __ccgo_ts+4125, libc.UintptrFromInt32(0)))
		}
		return libc.Uint64FromInt64(int64(-libc.Int32FromInt32(1)))
	}
	*(*uintptr)(unsafe.Pointer(tokenPtrPtr)) = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	return libc.Uint64FromInt64(localVar)
}

/*
 *-----------------------------------------------------------------------------
 *
 * CheckNamespaceQualifiers --
 *
 *	Verify that a variable name has no namespace qualifiers before
 *	attempting to install it in the LVT.
 *
 * Results:
 *	On success, returns TCL_OK. On failure, returns TCL_ERROR and stores
 *	an error message in the interpreter result.
 *
 *-----------------------------------------------------------------------------
 */

func _CheckNamespaceQualifiers(tls *libc.TLS, interp uintptr, name uintptr, nameLen int32) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Length of the variable */
	var p uintptr
	_ = p
	p = name
	for {
		if !(p+uintptr(2) < name+uintptr(nameLen)) {
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(':') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32(':') {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+4129, libc.VaList(bp+8, name)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+3663, __ccgo_ts+4156, name, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		goto _1
	_1:
		;
		p++
	}
	return TCL_OK
}

/*
 *-----------------------------------------------------------------------------
 *
 * CheckOneByte --
 *
 *	Verify that a constant fits in a single byte in the instruction
 *	stream.
 *
 * Results:
 *	On success, returns TCL_OK. On failure, returns TCL_ERROR and stores
 *	an error message in the interpreter result.
 *
 * This code is here primarily to verify that instructions like INCR_SCALAR1
 * are possible on a given local variable. The fact that there is no
 * INCR_SCALAR4 is puzzling.
 *
 *-----------------------------------------------------------------------------
 */

func _CheckOneByte(tls *libc.TLS, interp uintptr, value int32) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Value to check */
	var result uintptr
	_ = result /* Error message */
	if value < 0 || value > int32(0xFF) {
		result = XTcl_NewStringObj(tls, __ccgo_ts+4165, int64(-int32(1)))
		XTcl_SetObjResult(tls, interp, result)
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+3663, __ccgo_ts+4198, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *-----------------------------------------------------------------------------
 *
 * CheckSignedOneByte --
 *
 *	Verify that a constant fits in a single signed byte in the instruction
 *	stream.
 *
 * Results:
 *	On success, returns TCL_OK. On failure, returns TCL_ERROR and stores
 *	an error message in the interpreter result.
 *
 * This code is here primarily to verify that instructions like INCR_SCALAR1
 * are possible on a given local variable. The fact that there is no
 * INCR_SCALAR4 is puzzling.
 *
 *-----------------------------------------------------------------------------
 */

func _CheckSignedOneByte(tls *libc.TLS, interp uintptr, value int32) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Value to check */
	var result uintptr
	_ = result /* Error message */
	if value > int32(0x7F) || value < -int32(0x80) {
		result = XTcl_NewStringObj(tls, __ccgo_ts+4165, int64(-int32(1)))
		XTcl_SetObjResult(tls, interp, result)
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+3663, __ccgo_ts+4198, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *-----------------------------------------------------------------------------
 *
 * CheckNonNegative --
 *
 *	Verify that a constant is nonnegative
 *
 * Results:
 *	On success, returns TCL_OK. On failure, returns TCL_ERROR and stores
 *	an error message in the interpreter result.
 *
 * This code is here primarily to verify that instructions like INCR_INVOKE
 * are consuming a positive number of operands
 *
 *-----------------------------------------------------------------------------
 */

func _CheckNonNegative(tls *libc.TLS, interp uintptr, value int32) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Value to check */
	var result uintptr
	_ = result /* Error message */
	if value < 0 {
		result = XTcl_NewStringObj(tls, __ccgo_ts+4204, int64(-int32(1)))
		XTcl_SetObjResult(tls, interp, result)
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+3663, __ccgo_ts+4232, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *-----------------------------------------------------------------------------
 *
 * CheckStrictlyPositive --
 *
 *	Verify that a constant is positive
 *
 * Results:
 *	On success, returns TCL_OK. On failure, returns TCL_ERROR and
 *	stores an error message in the interpreter result.
 *
 * This code is here primarily to verify that instructions like INCR_INVOKE
 * are consuming a positive number of operands
 *
 *-----------------------------------------------------------------------------
 */

func _CheckStrictlyPositive(tls *libc.TLS, interp uintptr, value int32) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Value to check */
	var result uintptr
	_ = result /* Error message */
	if value <= 0 {
		result = XTcl_NewStringObj(tls, __ccgo_ts+4244, int64(-int32(1)))
		XTcl_SetObjResult(tls, interp, result)
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+3663, __ccgo_ts+4269, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *-----------------------------------------------------------------------------
 *
 * DefineLabel --
 *
 *	Defines a label appearing in the assembly sequence.
 *
 * Results:
 *	Returns a standard Tcl result. Returns TCL_OK and an empty result if
 *	the definition succeeds; returns TCL_ERROR and an appropriate message
 *	if a duplicate definition is found.
 *
 *-----------------------------------------------------------------------------
 */

func _DefineLabel(tls *libc.TLS, assemEnvPtr uintptr, labelName uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Label being defined */
	var entry, envPtr, interp uintptr
	var _ /* isNew at bp+0 */ int32
	_, _, _ = entry, envPtr, interp
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr
	/* Compilation environment */
	interp = (*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr /* Flag == 1 iff the label was previously
	 * undefined */
	/* TODO - This can now be simplified! */
	_StartBasicBlock(tls, assemEnvPtr, int32(BB_FALLTHRU), libc.UintptrFromInt32(0))
	/*
	 * Look up the newly-defined label in the symbol table.
	 */
	entry = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(assemEnvPtr + 16)).FcreateProc})))(tls, assemEnvPtr+16, labelName, bp)
	if !(*(*int32)(unsafe.Pointer(bp)) != 0) {
		/*
		 * This is a duplicate label.
		 */
		if (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fflags&int32(TCL_EVAL_DIRECT) != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+4278, libc.VaList(bp+16, labelName)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+3663, __ccgo_ts+4313, labelName, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	/*
	 * This is the first appearance of the label in the code.
	 */
	(*TTcl_HashEntry)(unsafe.Pointer(entry)).FclientData = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fcurr_bb
	return TCL_OK
}

/*
 *-----------------------------------------------------------------------------
 *
 * StartBasicBlock --
 *
 *	Starts a new basic block when a label or jump is encountered.
 *
 * Results:
 *	Returns a pointer to the BasicBlock structure of the new
 *	basic block.
 *
 *-----------------------------------------------------------------------------
 */

func _StartBasicBlock(tls *libc.TLS, assemEnvPtr uintptr, flags int32, jumpLabel uintptr) (r uintptr) {
	/* Label of the location that the block jumps
	 * to, or NULL if the block does not jump */
	var currBB, envPtr, newBB uintptr
	_, _, _ = currBB, envPtr, newBB
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr /* BasicBlock structure for the new block */
	currBB = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fcurr_bb
	/*
	 * Coalesce zero-length blocks.
	 */
	if int64((*TBasicBlock)(unsafe.Pointer(currBB)).FstartOffset) == int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart) {
		(*TBasicBlock)(unsafe.Pointer(currBB)).FstartLine = int32((*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FcmdLine)
		return currBB
	}
	/*
	 * Make the new basic block.
	 */
	newBB = _AllocBB(tls, assemEnvPtr)
	/*
	 * Record the jump target if there is one.
	 */
	(*TBasicBlock)(unsafe.Pointer(currBB)).FjumpTarget = jumpLabel
	if jumpLabel != libc.UintptrFromInt32(0) {
		(*TTcl_Obj)(unsafe.Pointer((*TBasicBlock)(unsafe.Pointer(currBB)).FjumpTarget)).FrefCount++
	}
	/*
	 * Record the fallthrough if there is one.
	 */
	*(*int32)(unsafe.Pointer(currBB + 112)) |= flags
	/*
	 * Record the successor block.
	 */
	(*TBasicBlock)(unsafe.Pointer(currBB)).Fsuccessor1 = newBB
	(*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fcurr_bb = newBB
	return newBB
}

/*
 *-----------------------------------------------------------------------------
 *
 * AllocBB --
 *
 *	Allocates a new basic block
 *
 * Results:
 *	Returns a pointer to the newly allocated block, which is initialized
 *	to contain no code and begin at the current instruction pointer.
 *
 *-----------------------------------------------------------------------------
 */

func _AllocBB(tls *libc.TLS, assemEnvPtr uintptr) (r uintptr) {
	/* Assembly environment */
	var bb, envPtr uintptr
	var v1 int32
	_, _, _ = bb, envPtr, v1
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr
	bb = XTcl_Alloc(tls, uint64(120))
	v1 = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart))
	(*TBasicBlock)(unsafe.Pointer(bb)).FstartOffset = v1
	(*TBasicBlock)(unsafe.Pointer(bb)).ForiginalStartOffset = v1
	(*TBasicBlock)(unsafe.Pointer(bb)).FstartLine = int32((*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FcmdLine + int64(1))
	(*TBasicBlock)(unsafe.Pointer(bb)).FjumpOffset = -int32(1)
	(*TBasicBlock)(unsafe.Pointer(bb)).FjumpLine = -int32(1)
	(*TBasicBlock)(unsafe.Pointer(bb)).FprevPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fcurr_bb
	(*TBasicBlock)(unsafe.Pointer(bb)).Fpredecessor = libc.UintptrFromInt32(0)
	(*TBasicBlock)(unsafe.Pointer(bb)).Fsuccessor1 = libc.UintptrFromInt32(0)
	(*TBasicBlock)(unsafe.Pointer(bb)).FjumpTarget = libc.UintptrFromInt32(0)
	(*TBasicBlock)(unsafe.Pointer(bb)).FinitialStackDepth = 0
	(*TBasicBlock)(unsafe.Pointer(bb)).FminStackDepth = 0
	(*TBasicBlock)(unsafe.Pointer(bb)).FmaxStackDepth = 0
	(*TBasicBlock)(unsafe.Pointer(bb)).FfinalStackDepth = 0
	(*TBasicBlock)(unsafe.Pointer(bb)).FcatchDepth = 0
	(*TBasicBlock)(unsafe.Pointer(bb)).FenclosingCatch = libc.UintptrFromInt32(0)
	(*TBasicBlock)(unsafe.Pointer(bb)).FforeignExceptionBase = -int32(1)
	(*TBasicBlock)(unsafe.Pointer(bb)).FforeignExceptionCount = 0
	(*TBasicBlock)(unsafe.Pointer(bb)).FforeignExceptions = libc.UintptrFromInt32(0)
	(*TBasicBlock)(unsafe.Pointer(bb)).FjtPtr = libc.UintptrFromInt32(0)
	(*TBasicBlock)(unsafe.Pointer(bb)).Fflags = 0
	return bb
}

/*
 *-----------------------------------------------------------------------------
 *
 * FinishAssembly --
 *
 *	Postprocessing after all bytecode has been generated for a block of
 *	assembly code.
 *
 * Results:
 *	Returns a standard Tcl result, with an error message left in the
 *	interpreter if appropriate.
 *
 * Side effects:
 *	The program is checked to see if any undefined labels remain.  The
 *	initial stack depth of all the basic blocks in the flow graph is
 *	calculated and saved.  The stack balance on exit is computed, checked
 *	and saved.
 *
 *-----------------------------------------------------------------------------
 */

func _FinishAssembly(tls *libc.TLS, assemEnvPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)                 /* Assembly environment */
	var _ /* mustMove at bp+0 */ int32 /* Amount by which the code needs to be grown
	 * because of expanding jumps */
	/*
	 * Resolve the targets of all jumps and determine whether code needs to be
	 * moved around.
	 */
	if _CalculateJumpRelocations(tls, assemEnvPtr, bp) != 0 {
		return int32(TCL_ERROR)
	}
	/*
	 * Move the code if necessary.
	 */
	if *(*int32)(unsafe.Pointer(bp)) != 0 {
		_MoveCodeForJumps(tls, assemEnvPtr, *(*int32)(unsafe.Pointer(bp)))
	}
	/*
	 * Resolve jump target labels to bytecode offsets.
	 */
	_FillInJumpOffsets(tls, assemEnvPtr)
	/*
	 * Label each basic block with its catch context. Quit on inconsistency.
	 */
	if _ProcessCatches(tls, assemEnvPtr) != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Make sure that no block accessible from a catch's error exit that hasn't
	 * popped the exception stack can throw an exception.
	 */
	if _CheckForThrowInWrongContext(tls, assemEnvPtr) != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Compute stack balance throughout the program.
	 */
	if _CheckStack(tls, assemEnvPtr) != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * TODO - Check for unreachable code. Or maybe not; unreachable code is
	 * Mostly Harmless.
	 */
	return TCL_OK
}

/*
 *-----------------------------------------------------------------------------
 *
 * CalculateJumpRelocations --
 *
 *	Calculate any movement that has to be done in the assembly code to
 *	expand JUMP1 instructions to JUMP4 (because they jump more than a
 *	1-byte range).
 *
 * Results:
 *	Returns a standard Tcl result, with an appropriate error message if
 *	anything fails.
 *
 * Side effects:
 *	Sets the 'startOffset' pointer in every basic block to the new origin
 *	of the block, and turns off JUMP1 flags on instructions that must be
 *	expanded (and adjusts them to the corresponding JUMP4's).  Does *not*
 *	store the jump offsets at this point.
 *
 *	Sets *mustMove to 1 if and only if at least one instruction changed
 *	size so the code must be moved.
 *
 *	As a side effect, also checks for undefined labels and reports them.
 *
 *-----------------------------------------------------------------------------
 */

func _CalculateJumpRelocations(tls *libc.TLS, assemEnvPtr uintptr, mustMove uintptr) (r int32) {
	/* OUTPUT: Number of bytes that have been
	 * added to the code */
	var bbPtr, entry, envPtr, jumpTarget, v2 uintptr
	var motion, offset int32
	var opcode uint32
	_, _, _, _, _, _, _, _ = bbPtr, entry, envPtr, jumpTarget, motion, offset, opcode, v2
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr /* Opcode in the bytecode being adjusted */
	/*
	 * Iterate through basic blocks as long as a change results in code
	 * expansion.
	 */
	*(*int32)(unsafe.Pointer(mustMove)) = 0
	for cond := true; cond; cond = motion != 0 {
		motion = 0
		bbPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fhead_bb
		for {
			if !(bbPtr != libc.UintptrFromInt32(0)) {
				break
			}
			/*
			 * Advance the basic block start offset by however many bytes we
			 * have inserted in the code up to this point
			 */
			*(*int32)(unsafe.Pointer(bbPtr + 4)) += motion
			/*
			 * If the basic block references a label (and hence performs a
			 * jump), find the location of the label. Report an error if the
			 * label is missing.
			 */
			if (*TBasicBlock)(unsafe.Pointer(bbPtr)).FjumpTarget != libc.UintptrFromInt32(0) {
				if (*TTcl_Obj)(unsafe.Pointer((*TBasicBlock)(unsafe.Pointer(bbPtr)).FjumpTarget)).Fbytes != 0 {
					v2 = (*TTcl_Obj)(unsafe.Pointer((*TBasicBlock)(unsafe.Pointer(bbPtr)).FjumpTarget)).Fbytes
				} else {
					v2 = XTcl_GetStringFromObj(tls, (*TBasicBlock)(unsafe.Pointer(bbPtr)).FjumpTarget, libc.UintptrFromInt32(0))
				}
				entry = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(assemEnvPtr + 16)).FfindProc})))(tls, assemEnvPtr+16, v2)
				if entry == libc.UintptrFromInt32(0) {
					_ReportUndefinedLabel(tls, assemEnvPtr, bbPtr, (*TBasicBlock)(unsafe.Pointer(bbPtr)).FjumpTarget)
					return int32(TCL_ERROR)
				}
				/*
				 * If the instruction is a JUMP1, turn it into a JUMP4 if its
				 * target is out of range.
				 */
				jumpTarget = (*TTcl_HashEntry)(unsafe.Pointer(entry)).FclientData
				if (*TBasicBlock)(unsafe.Pointer(bbPtr)).Fflags&int32(BB_JUMP1) != 0 {
					offset = (*TBasicBlock)(unsafe.Pointer(jumpTarget)).FstartOffset - ((*TBasicBlock)(unsafe.Pointer(bbPtr)).FjumpOffset + motion)
					if offset < -int32(0x80) || offset > int32(0x7F) {
						opcode = uint32(*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr((*TBasicBlock)(unsafe.Pointer(bbPtr)).FjumpOffset))))
						opcode++
						*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr((*TBasicBlock)(unsafe.Pointer(bbPtr)).FjumpOffset))) = uint8(opcode)
						motion += int32(3)
						*(*int32)(unsafe.Pointer(bbPtr + 112)) &= ^int32(BB_JUMP1)
					}
				}
			}
			/*
			 * If the basic block references a jump table, that doesn't affect
			 * the code locations, but resolve the labels now, and store basic
			 * block pointers in the jumptable hash.
			 */
			if (*TBasicBlock)(unsafe.Pointer(bbPtr)).Fflags&int32(BB_JUMPTABLE) != 0 {
				if _CheckJumpTableLabels(tls, assemEnvPtr, bbPtr) != TCL_OK {
					return int32(TCL_ERROR)
				}
			}
			goto _1
		_1:
			;
			bbPtr = (*TBasicBlock)(unsafe.Pointer(bbPtr)).Fsuccessor1
		}
		*(*int32)(unsafe.Pointer(mustMove)) += motion
	}
	return TCL_OK
}

/*
 *-----------------------------------------------------------------------------
 *
 * CheckJumpTableLabels --
 *
 *	Make sure that all the labels in a jump table are defined.
 *
 * Results:
 *	Returns TCL_OK if they are, TCL_ERROR if they aren't.
 *
 *-----------------------------------------------------------------------------
 */

func _CheckJumpTableLabels(tls *libc.TLS, assemEnvPtr uintptr, bbPtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Basic block that ends in a jump table */
	var symEntryPtr, symHash, symbolObj, valEntryPtr, v2 uintptr
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _, _ = symEntryPtr, symHash, symbolObj, valEntryPtr, v2
	symHash = (*TBasicBlock)(unsafe.Pointer(bbPtr)).FjtPtr /* Hash entry for the resolutions */
	/*
	 * Look up every jump target in the jump hash.
	 */
	symEntryPtr = XTcl_FirstHashEntry(tls, symHash, bp)
	for {
		if !(symEntryPtr != libc.UintptrFromInt32(0)) {
			break
		}
		symbolObj = (*TTcl_HashEntry)(unsafe.Pointer(symEntryPtr)).FclientData
		if (*TTcl_Obj)(unsafe.Pointer(symbolObj)).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(symbolObj)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, symbolObj, libc.UintptrFromInt32(0))
		}
		valEntryPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(assemEnvPtr + 16)).FfindProc})))(tls, assemEnvPtr+16, v2)
		if valEntryPtr == libc.UintptrFromInt32(0) {
			_ReportUndefinedLabel(tls, assemEnvPtr, bbPtr, symbolObj)
			return int32(TCL_ERROR)
		}
		goto _1
	_1:
		;
		symEntryPtr = XTcl_NextHashEntry(tls, bp)
	}
	return TCL_OK
}

/*
 *-----------------------------------------------------------------------------
 *
 * ReportUndefinedLabel --
 *
 *	Report that a basic block refers to an undefined jump label
 *
 * Side effects:
 *	Stores an error message, error code, and line number information in
 *	the assembler's Tcl interpreter.
 *
 *-----------------------------------------------------------------------------
 */

func _ReportUndefinedLabel(tls *libc.TLS, assemEnvPtr uintptr, bbPtr uintptr, jumpTarget uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Label of a jump target */
	var envPtr, interp, v1, v2 uintptr
	_, _, _, _ = envPtr, interp, v1, v2
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr
	/* Compilation environment */
	interp = (*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr
	/* Tcl interpreter */
	if (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fflags&int32(TCL_EVAL_DIRECT) != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(jumpTarget)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(jumpTarget)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, jumpTarget, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+4322, libc.VaList(bp+8, v1)))
		if (*TTcl_Obj)(unsafe.Pointer(jumpTarget)).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(jumpTarget)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, jumpTarget, libc.UintptrFromInt32(0))
		}
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+3663, __ccgo_ts+4343, v2, libc.UintptrFromInt32(0)))
		XTcl_SetErrorLine(tls, interp, (*TBasicBlock)(unsafe.Pointer(bbPtr)).FjumpLine)
	}
}

/*
 *-----------------------------------------------------------------------------
 *
 * MoveCodeForJumps --
 *
 *	Move bytecodes in memory to accommodate JUMP1 instructions that have
 *	expanded to become JUMP4's.
 *
 *-----------------------------------------------------------------------------
 */

func _MoveCodeForJumps(tls *libc.TLS, assemEnvPtr uintptr, mustMove int32) {
	/* Number of bytes of added code */
	var bbPtr, envPtr uintptr
	var topOffset int32
	_, _, _ = bbPtr, envPtr, topOffset
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr /* Bytecode offset of the following basic
	 * block before code motion */
	/*
	 * Make sure that there is enough space in the bytecode array to
	 * accommodate the expanded code.
	 */
	for (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeEnd < (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext+uintptr(mustMove) {
		XTclExpandCodeArray(tls, envPtr)
	}
	/*
	 * Iterate through the bytecodes in reverse order, and move them upward to
	 * their new homes.
	 */
	topOffset = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart))
	bbPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fcurr_bb
	for {
		if !(bbPtr != libc.UintptrFromInt32(0)) {
			break
		}
		libc.Xmemmove(tls, (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart+uintptr((*TBasicBlock)(unsafe.Pointer(bbPtr)).FstartOffset), (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart+uintptr((*TBasicBlock)(unsafe.Pointer(bbPtr)).ForiginalStartOffset), libc.Uint64FromInt32(topOffset-(*TBasicBlock)(unsafe.Pointer(bbPtr)).ForiginalStartOffset))
		topOffset = (*TBasicBlock)(unsafe.Pointer(bbPtr)).ForiginalStartOffset
		*(*int32)(unsafe.Pointer(bbPtr + 12)) += (*TBasicBlock)(unsafe.Pointer(bbPtr)).FstartOffset - (*TBasicBlock)(unsafe.Pointer(bbPtr)).ForiginalStartOffset
		goto _1
	_1:
		;
		bbPtr = (*TBasicBlock)(unsafe.Pointer(bbPtr)).FprevPtr
	}
	*(*uintptr)(unsafe.Pointer(envPtr + 152)) += uintptr(mustMove)
}

/*
 *-----------------------------------------------------------------------------
 *
 * FillInJumpOffsets --
 *
 *	Fill in the final offsets of all jump instructions once bytecode
 *	locations have been completely determined.
 *
 *-----------------------------------------------------------------------------
 */

func _FillInJumpOffsets(tls *libc.TLS, assemEnvPtr uintptr) {
	/* Assembly environment */
	var bbPtr, entry, envPtr, jumpTarget, v2 uintptr
	var fromOffset, targetOffset int32
	_, _, _, _, _, _, _ = bbPtr, entry, envPtr, fromOffset, jumpTarget, targetOffset, v2
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr /* Bytecode location of a jump instruction's
	 * target */
	bbPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fhead_bb
	for {
		if !(bbPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TBasicBlock)(unsafe.Pointer(bbPtr)).FjumpTarget != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer((*TBasicBlock)(unsafe.Pointer(bbPtr)).FjumpTarget)).Fbytes != 0 {
				v2 = (*TTcl_Obj)(unsafe.Pointer((*TBasicBlock)(unsafe.Pointer(bbPtr)).FjumpTarget)).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, (*TBasicBlock)(unsafe.Pointer(bbPtr)).FjumpTarget, libc.UintptrFromInt32(0))
			}
			entry = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(assemEnvPtr + 16)).FfindProc})))(tls, assemEnvPtr+16, v2)
			jumpTarget = (*TTcl_HashEntry)(unsafe.Pointer(entry)).FclientData
			fromOffset = (*TBasicBlock)(unsafe.Pointer(bbPtr)).FjumpOffset
			targetOffset = (*TBasicBlock)(unsafe.Pointer(jumpTarget)).FstartOffset
			if (*TBasicBlock)(unsafe.Pointer(bbPtr)).Fflags&int32(BB_JUMP1) != 0 {
				*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr(fromOffset) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(targetOffset - fromOffset))
			} else {
				*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr(fromOffset) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(targetOffset-fromOffset) >> libc.Int32FromInt32(24))
				*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr(fromOffset) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(targetOffset-fromOffset) >> libc.Int32FromInt32(16))
				*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr(fromOffset) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt32(targetOffset-fromOffset) >> libc.Int32FromInt32(8))
				*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr(fromOffset) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt32(targetOffset - fromOffset))
			}
		}
		if (*TBasicBlock)(unsafe.Pointer(bbPtr)).Fflags&int32(BB_JUMPTABLE) != 0 {
			_ResolveJumpTableTargets(tls, assemEnvPtr, bbPtr)
		}
		goto _1
	_1:
		;
		bbPtr = (*TBasicBlock)(unsafe.Pointer(bbPtr)).Fsuccessor1
	}
}

/*
 *-----------------------------------------------------------------------------
 *
 * ResolveJumpTableTargets --
 *
 *	Puts bytecode addresses for the targets of a jumptable into the
 *	table
 *
 * Results:
 *	Returns TCL_OK if they are, TCL_ERROR if they aren't.
 *
 *-----------------------------------------------------------------------------
 */

func _ResolveJumpTableTargets(tls *libc.TLS, assemEnvPtr uintptr, bbPtr uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Basic block that ends in a jump table */
	var auxDataIndex int32
	var envPtr, jumpTargetBBPtr, realJumpEntryPtr, realJumpHashPtr, realJumpTablePtr, symEntryPtr, symHash, symbolObj, valEntryPtr, v2, v3 uintptr
	var _ /* junk at bp+24 */ int32
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _, _, _, _, _, _, _ = auxDataIndex, envPtr, jumpTargetBBPtr, realJumpEntryPtr, realJumpHashPtr, realJumpTablePtr, symEntryPtr, symHash, symbolObj, valEntryPtr, v2, v3
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr
	/* Compilation environment */
	symHash = (*TBasicBlock)(unsafe.Pointer(bbPtr)).FjtPtr
	auxDataIndex = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr((*TBasicBlock)(unsafe.Pointer(bbPtr)).FjumpOffset) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr((*TBasicBlock)(unsafe.Pointer(bbPtr)).FjumpOffset) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr((*TBasicBlock)(unsafe.Pointer(bbPtr)).FjumpOffset) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr((*TBasicBlock)(unsafe.Pointer(bbPtr)).FjumpOffset) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
	realJumpTablePtr = (*(*TAuxData)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FauxDataArrayPtr + uintptr(auxDataIndex)*16))).FclientData
	realJumpHashPtr = realJumpTablePtr
	/*
	 * Look up every jump target in the jump hash.
	 */
	symEntryPtr = XTcl_FirstHashEntry(tls, symHash, bp)
	for {
		if !(symEntryPtr != libc.UintptrFromInt32(0)) {
			break
		}
		symbolObj = (*TTcl_HashEntry)(unsafe.Pointer(symEntryPtr)).FclientData
		if (*TTcl_Obj)(unsafe.Pointer(symbolObj)).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(symbolObj)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, symbolObj, libc.UintptrFromInt32(0))
		}
		valEntryPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(assemEnvPtr + 16)).FfindProc})))(tls, assemEnvPtr+16, v2)
		jumpTargetBBPtr = (*TTcl_HashEntry)(unsafe.Pointer(valEntryPtr)).FclientData
		if (*TTcl_HashTable)(unsafe.Pointer(symHash)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(symHash)).FkeyType == -int32(1) {
			v3 = *(*uintptr)(unsafe.Pointer(symEntryPtr + 32))
		} else {
			v3 = symEntryPtr + 32
		}
		realJumpEntryPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(realJumpHashPtr)).FcreateProc})))(tls, realJumpHashPtr, v3, bp+24)
		(*TTcl_HashEntry)(unsafe.Pointer(realJumpEntryPtr)).FclientData = uintptr(int64((*TBasicBlock)(unsafe.Pointer(jumpTargetBBPtr)).FstartOffset - (*TBasicBlock)(unsafe.Pointer(bbPtr)).FjumpOffset))
		goto _1
	_1:
		;
		symEntryPtr = XTcl_NextHashEntry(tls, bp)
	}
}

/*
 *-----------------------------------------------------------------------------
 *
 * CheckForThrowInWrongContext --
 *
 *	Verify that no beginCatch/endCatch sequence can throw an exception
 *	after an original exception is caught and before its exception context
 *	is removed from the stack.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	Stores an appropriate error message in the interpreter as needed.
 *
 *-----------------------------------------------------------------------------
 */

func _CheckForThrowInWrongContext(tls *libc.TLS, assemEnvPtr uintptr) (r int32) {
	/* Assembly environment */
	var blockPtr uintptr
	_ = blockPtr /* Current basic block */
	/*
	 * Walk through the basic blocks in turn, checking all the ones that have
	 * caught an exception and not disposed of it properly.
	 */
	blockPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fhead_bb
	for {
		if !(blockPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TBasicBlock)(unsafe.Pointer(blockPtr)).FcatchState == int32(BBCS_CAUGHT) {
			/*
			 * Walk through the instructions in the basic block.
			 */
			if _CheckNonThrowingBlock(tls, assemEnvPtr, blockPtr) != TCL_OK {
				return int32(TCL_ERROR)
			}
		}
		goto _1
	_1:
		;
		blockPtr = (*TBasicBlock)(unsafe.Pointer(blockPtr)).Fsuccessor1
	}
	return TCL_OK
}

/*
 *-----------------------------------------------------------------------------
 *
 * CheckNonThrowingBlock --
 *
 *	Check that a basic block cannot throw an exception.
 *
 * Results:
 *	Returns TCL_ERROR if the block cannot be proven to be nonthrowing.
 *
 * Side effects:
 *	Stashes an error message in the interpreter result.
 *
 *-----------------------------------------------------------------------------
 */

func _CheckNonThrowingBlock(tls *libc.TLS, assemEnvPtr uintptr, blockPtr uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Basic block where exceptions are not
	 * allowed */
	var bound, offset int32
	var envPtr, interp, nextPtr uintptr
	var opcode uint8
	_, _, _, _, _, _ = bound, envPtr, interp, nextPtr, offset, opcode
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr
	/* Compilation environment */
	interp = (*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr /* Current bytecode instruction */
	/*
	 * Determine where in the code array the basic block ends.
	 */
	nextPtr = (*TBasicBlock)(unsafe.Pointer(blockPtr)).Fsuccessor1
	if nextPtr == libc.UintptrFromInt32(0) {
		bound = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart))
	} else {
		bound = (*TBasicBlock)(unsafe.Pointer(nextPtr)).FstartOffset
	}
	/*
	 * Walk through the instructions of the block.
	 */
	offset = (*TBasicBlock)(unsafe.Pointer(blockPtr)).FstartOffset
	for offset < bound {
		/*
		 * Determine whether an instruction is nonthrowing.
		 */
		opcode = *(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr(offset)))
		if _BytecodeMightThrow(tls, opcode) != 0 {
			/*
			 * Report an error for a throw in the wrong context.
			 */
			if (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fflags&int32(TCL_EVAL_DIRECT) != 0 {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+4351, libc.VaList(bp+8, XtclInstructionTable[opcode].Fname)))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+3663, __ccgo_ts+4452, libc.UintptrFromInt32(0)))
				_AddBasicBlockRangeToErrorInfo(tls, assemEnvPtr, blockPtr)
			}
			return int32(TCL_ERROR)
		}
		offset = int32(int64(offset) + XtclInstructionTable[opcode].FnumBytes)
	}
	return TCL_OK
}

/*
 *-----------------------------------------------------------------------------
 *
 * BytecodeMightThrow --
 *
 *	Tests if a given bytecode instruction might throw an exception.
 *
 * Results:
 *	Returns 1 if the bytecode might throw an exception, 0 if the
 *	instruction is known never to throw.
 *
 *-----------------------------------------------------------------------------
 */

func _BytecodeMightThrow(tls *libc.TLS, opcode uint8) (r int32) {
	var c uint8
	var max, mid, min int32
	_, _, _, _ = c, max, mid, min
	/*
	 * Binary search on the non-throwing bytecode list.
	 */
	min = 0
	max = libc.Int32FromUint64(libc.Uint64FromInt64(36) - libc.Uint64FromInt32(1))
	for max >= min {
		mid = (min + max) / int32(2)
		c = _NonThrowingByteCodes[mid]
		if libc.Int32FromUint8(opcode) < libc.Int32FromUint8(c) {
			max = mid - int32(1)
		} else {
			if libc.Int32FromUint8(opcode) > libc.Int32FromUint8(c) {
				min = mid + int32(1)
			} else {
				/*
				 * Opcode is nonthrowing.
				 */
				return 0
			}
		}
	}
	return int32(1)
}

/*
 *-----------------------------------------------------------------------------
 *
 * CheckStack --
 *
 *	Audit stack usage in a block of assembly code.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	Updates stack depth on entry for all basic blocks in the flowgraph.
 *	Calculates the max stack depth used in the program, and updates the
 *	compilation environment to reflect it.
 *
 *-----------------------------------------------------------------------------
 */

func _CheckStack(tls *libc.TLS, assemEnvPtr uintptr) (r int32) {
	/* Assembly environment */
	var envPtr uintptr
	var maxDepth TTcl_Size
	_, _ = envPtr, maxDepth
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr /* Maximum stack depth overall */
	/*
	 * Checking the head block will check all the other blocks recursively.
	 */
	(*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FmaxDepth = 0
	if _StackCheckBasicBlock(tls, assemEnvPtr, (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fhead_bb, libc.UintptrFromInt32(0), 0) == int32(TCL_ERROR) {
		return int32(TCL_ERROR)
	}
	/*
	 * Post the max stack depth back to the compilation environment.
	 */
	maxDepth = int64((*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FmaxDepth) + (*TCompileEnv)(unsafe.Pointer(envPtr)).FcurrStackDepth
	if maxDepth > (*TCompileEnv)(unsafe.Pointer(envPtr)).FmaxStackDepth {
		(*TCompileEnv)(unsafe.Pointer(envPtr)).FmaxStackDepth = maxDepth
	}
	/*
	 * If the exit is reachable, make sure that the program exits with 1
	 * operand on the stack.
	 */
	if _StackCheckExit(tls, assemEnvPtr) != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Reset the visited state on all basic blocks.
	 */
	_ResetVisitedBasicBlocks(tls, assemEnvPtr)
	return TCL_OK
}

/*
 *-----------------------------------------------------------------------------
 *
 * StackCheckBasicBlock --
 *
 *	Checks stack consumption for a basic block (and recursively for its
 *	successors).
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	Updates initial stack depth for the basic block and its successors.
 *	(Final and maximum stack depth are relative to initial, and are not
 *	touched).
 *
 * This procedure eventually checks, for the entire flow graph, whether stack
 * balance is consistent.  It is an error for a given basic block to be
 * reachable along multiple flow paths with different stack depths.
 *
 *-----------------------------------------------------------------------------
 */

func _StackCheckBasicBlock(tls *libc.TLS, assemEnvPtr uintptr, blockPtr uintptr, predecessor uintptr, initialStackDepth int32) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Stack depth on entry to the block */
	var entry, envPtr, interp, jtEntry, jumpTarget, targetLabel, v1, v3 uintptr
	var maxDepth, result, stackDepth int32
	var _ /* jtSearch at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _, _, _, _, _, _ = entry, envPtr, interp, jtEntry, jumpTarget, maxDepth, result, stackDepth, targetLabel, v1, v3
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr
	/* Compilation environment */
	interp = (*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr /* Hash entry in the label table */
	if (*TBasicBlock)(unsafe.Pointer(blockPtr)).Fflags&int32(BB_VISITED) != 0 {
		/*
		 * If the block is already visited, check stack depth for consistency
		 * among the paths that reach it.
		 */
		if (*TBasicBlock)(unsafe.Pointer(blockPtr)).FinitialStackDepth == initialStackDepth {
			return TCL_OK
		}
		if (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fflags&int32(TCL_EVAL_DIRECT) != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+4461, int64(-int32(1))))
			/*
			 * TODO - add execution trace of both paths
			 */
			XTcl_SetErrorLine(tls, interp, (*TBasicBlock)(unsafe.Pointer(blockPtr)).FstartLine)
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+32, __ccgo_ts+2004, __ccgo_ts+3663, __ccgo_ts+4510, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	/*
	 * If the block is not already visited, set the 'predecessor' link to
	 * indicate how control got to it. Set the initial stack depth to the
	 * current stack depth in the flow of control.
	 */
	*(*int32)(unsafe.Pointer(blockPtr + 112)) |= int32(BB_VISITED)
	(*TBasicBlock)(unsafe.Pointer(blockPtr)).Fpredecessor = predecessor
	(*TBasicBlock)(unsafe.Pointer(blockPtr)).FinitialStackDepth = initialStackDepth
	/*
	 * Calculate minimum stack depth, and flag an error if the block
	 * underflows the stack.
	 */
	if initialStackDepth+(*TBasicBlock)(unsafe.Pointer(blockPtr)).FminStackDepth < 0 {
		if (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fflags&int32(TCL_EVAL_DIRECT) != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+4519, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+32, __ccgo_ts+2004, __ccgo_ts+3663, __ccgo_ts+4510, libc.UintptrFromInt32(0)))
			_AddBasicBlockRangeToErrorInfo(tls, assemEnvPtr, blockPtr)
			XTcl_SetErrorLine(tls, interp, (*TBasicBlock)(unsafe.Pointer(blockPtr)).FstartLine)
		}
		return int32(TCL_ERROR)
	}
	/*
	 * Make sure that the block doesn't try to pop below the stack level of an
	 * enclosing catch.
	 */
	if (*TBasicBlock)(unsafe.Pointer(blockPtr)).FenclosingCatch != uintptr(0) && initialStackDepth+(*TBasicBlock)(unsafe.Pointer(blockPtr)).FminStackDepth < (*TBasicBlock1)(unsafe.Pointer((*TBasicBlock)(unsafe.Pointer(blockPtr)).FenclosingCatch)).FinitialStackDepth+(*TBasicBlock1)(unsafe.Pointer((*TBasicBlock)(unsafe.Pointer(blockPtr)).FenclosingCatch)).FfinalStackDepth {
		if (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fflags&int32(TCL_EVAL_DIRECT) != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+4535, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+32, __ccgo_ts+2004, __ccgo_ts+3663, __ccgo_ts+4582, libc.UintptrFromInt32(0)))
			_AddBasicBlockRangeToErrorInfo(tls, assemEnvPtr, blockPtr)
			XTcl_SetErrorLine(tls, interp, (*TBasicBlock)(unsafe.Pointer(blockPtr)).FstartLine)
		}
		return int32(TCL_ERROR)
	}
	/*
	 * Update maximum stgack depth.
	 */
	maxDepth = initialStackDepth + (*TBasicBlock)(unsafe.Pointer(blockPtr)).FmaxStackDepth
	if maxDepth > (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FmaxDepth {
		(*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FmaxDepth = maxDepth
	}
	/*
	 * Calculate stack depth on exit from the block, and invoke this procedure
	 * recursively to check successor blocks.
	 */
	stackDepth = initialStackDepth + (*TBasicBlock)(unsafe.Pointer(blockPtr)).FfinalStackDepth
	result = TCL_OK
	if (*TBasicBlock)(unsafe.Pointer(blockPtr)).Fflags&int32(BB_FALLTHRU) != 0 {
		result = _StackCheckBasicBlock(tls, assemEnvPtr, (*TBasicBlock)(unsafe.Pointer(blockPtr)).Fsuccessor1, blockPtr, stackDepth)
	}
	if result == TCL_OK && (*TBasicBlock)(unsafe.Pointer(blockPtr)).FjumpTarget != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer((*TBasicBlock)(unsafe.Pointer(blockPtr)).FjumpTarget)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer((*TBasicBlock)(unsafe.Pointer(blockPtr)).FjumpTarget)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, (*TBasicBlock)(unsafe.Pointer(blockPtr)).FjumpTarget, libc.UintptrFromInt32(0))
		}
		entry = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(assemEnvPtr + 16)).FfindProc})))(tls, assemEnvPtr+16, v1)
		jumpTarget = (*TTcl_HashEntry)(unsafe.Pointer(entry)).FclientData
		result = _StackCheckBasicBlock(tls, assemEnvPtr, jumpTarget, blockPtr, stackDepth)
	}
	/*
	 * All blocks referenced in a jump table are successors.
	 */
	if (*TBasicBlock)(unsafe.Pointer(blockPtr)).Fflags&int32(BB_JUMPTABLE) != 0 {
		jtEntry = XTcl_FirstHashEntry(tls, (*TBasicBlock)(unsafe.Pointer(blockPtr)).FjtPtr, bp)
		for {
			if !(result == TCL_OK && jtEntry != libc.UintptrFromInt32(0)) {
				break
			}
			targetLabel = (*TTcl_HashEntry)(unsafe.Pointer(jtEntry)).FclientData
			if (*TTcl_Obj)(unsafe.Pointer(targetLabel)).Fbytes != 0 {
				v3 = (*TTcl_Obj)(unsafe.Pointer(targetLabel)).Fbytes
			} else {
				v3 = XTcl_GetStringFromObj(tls, targetLabel, libc.UintptrFromInt32(0))
			}
			entry = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(assemEnvPtr + 16)).FfindProc})))(tls, assemEnvPtr+16, v3)
			jumpTarget = (*TTcl_HashEntry)(unsafe.Pointer(entry)).FclientData
			result = _StackCheckBasicBlock(tls, assemEnvPtr, jumpTarget, blockPtr, stackDepth)
			goto _2
		_2:
			;
			jtEntry = XTcl_NextHashEntry(tls, bp)
		}
	}
	return result
}

/*
 *-----------------------------------------------------------------------------
 *
 * StackCheckExit --
 *
 *	Makes sure that the net stack effect of an entire assembly language
 *	script is to push 1 result.
 *
 * Results:
 *	Returns a standard Tcl result, with an error message in the
 *	interpreter result if the stack is wrong.
 *
 * Side effects:
 *	If the assembly code had a net stack effect of zero, emits code to the
 *	concluding block to push a null result. In any case, updates the stack
 *	depth in the compile environment to reflect the net effect of the
 *	assembly code.
 *
 *-----------------------------------------------------------------------------
 */

func _StackCheckExit(tls *libc.TLS, assemEnvPtr uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Assembly environment */
	var curr_bb, envPtr, interp uintptr
	var depth, litIndex int32
	_, _, _, _, _ = curr_bb, depth, envPtr, interp, litIndex
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr
	/* Compilation environment */
	interp = (*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr /* Index in the literal pool of the empty
	 * string */
	curr_bb = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fcurr_bb
	/* Final basic block in the assembly */
	/*
	 * Don't perform these checks if execution doesn't reach the exit (either
	 * because of an infinite loop or because the only return is from the
	 * middle.
	 */
	if (*TBasicBlock)(unsafe.Pointer(curr_bb)).Fflags&int32(BB_VISITED) != 0 {
		/*
		 * Exit with no operands; push an empty one.
		 */
		depth = (*TBasicBlock)(unsafe.Pointer(curr_bb)).FfinalStackDepth + (*TBasicBlock)(unsafe.Pointer(curr_bb)).FinitialStackDepth
		if depth == 0 {
			/*
			 * Emit a 'push' of the empty literal.
			 */
			litIndex = XTclRegisterLiteral(tls, envPtr, __ccgo_ts+1945, 0, 0)
			/*
			 * Assumes that 'push' is at slot 0 in TalInstructionTable.
			 */
			_BBEmitInst1or4(tls, assemEnvPtr, 0, litIndex, 0)
			depth++
		}
		/*
		 * Exit with unbalanced stack.
		 */
		if depth != int32(1) {
			if (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fflags&int32(TCL_EVAL_DIRECT) != 0 {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+4598, libc.VaList(bp+8, depth)))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+3663, __ccgo_ts+4510, libc.UintptrFromInt32(0)))
			}
			return int32(TCL_ERROR)
		}
		/*
		 * Record stack usage.
		 */
		*(*TTcl_Size)(unsafe.Pointer(envPtr + 64)) += int64(depth)
	}
	return TCL_OK
}

/*
 *-----------------------------------------------------------------------------
 *
 * ProcessCatches --
 *
 *	First pass of 'catch' processing.
 *
 * Results:
 *	Returns a standard Tcl result, with an appropriate error message if
 *	the result is TCL_ERROR.
 *
 * Side effects:
 *	Labels all basic blocks with their enclosing catches.
 *
 *-----------------------------------------------------------------------------
 */

func _ProcessCatches(tls *libc.TLS, assemEnvPtr uintptr) (r int32) {
	/* Assembly environment */
	var blockPtr uintptr
	_ = blockPtr /* Pointer to a basic block */
	/*
	 * Clear the catch state of all basic blocks.
	 */
	blockPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fhead_bb
	for {
		if !(blockPtr != libc.UintptrFromInt32(0)) {
			break
		}
		(*TBasicBlock)(unsafe.Pointer(blockPtr)).FcatchState = int32(BBCS_UNKNOWN)
		(*TBasicBlock)(unsafe.Pointer(blockPtr)).FenclosingCatch = libc.UintptrFromInt32(0)
		goto _1
	_1:
		;
		blockPtr = (*TBasicBlock)(unsafe.Pointer(blockPtr)).Fsuccessor1
	}
	/*
	 * Start the check recursively from the first basic block, which is
	 * outside any exception context
	 */
	if _ProcessCatchesInBasicBlock(tls, assemEnvPtr, (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fhead_bb, libc.UintptrFromInt32(0), int32(BBCS_NONE), 0) != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Check for unclosed catch on exit.
	 */
	if _CheckForUnclosedCatches(tls, assemEnvPtr) != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Now there's enough information to build the exception ranges.
	 */
	if _BuildExceptionRanges(tls, assemEnvPtr) != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Finally, restore any exception ranges from embedded scripts.
	 */
	_RestoreEmbeddedExceptionRanges(tls, assemEnvPtr)
	return TCL_OK
}

/*
 *-----------------------------------------------------------------------------
 *
 * ProcessCatchesInBasicBlock --
 *
 *	First-pass catch processing for one basic block.
 *
 * Results:
 *	Returns a standard Tcl result, with error message in the interpreter
 *	result if an error occurs.
 *
 * This procedure checks consistency of the exception context through the
 * assembler program, and records the enclosing 'catch' for every basic block.
 *
 *-----------------------------------------------------------------------------
 */

func _ProcessCatchesInBasicBlock(tls *libc.TLS, assemEnvPtr uintptr, bbPtr uintptr, enclosing uintptr, state BasicBlockCatchState, catchDepth int32) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Depth of nesting of catches */
	var changed, result int32
	var entry, envPtr, fallThruEnclosing, interp, jtEntry, jumpEnclosing, jumpTarget, targetLabel, v1, v3 uintptr
	var fallThruState, jumpState BasicBlockCatchState
	var _ /* jtSearch at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = changed, entry, envPtr, fallThruEnclosing, fallThruState, interp, jtEntry, jumpEnclosing, jumpState, jumpTarget, result, targetLabel, v1, v3
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr
	/* Compilation environment */
	interp = (*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr
	/* Catch state of the jump target */
	changed = 0 /* Entry from the label table */
	/*
	 * Update the state of the current block, checking for consistency.  Set
	 * 'changed' to 1 if the state changes and successor blocks need to be
	 * rechecked.
	 */
	if (*TBasicBlock)(unsafe.Pointer(bbPtr)).FcatchState == int32(BBCS_UNKNOWN) {
		(*TBasicBlock)(unsafe.Pointer(bbPtr)).FenclosingCatch = enclosing
	} else {
		if (*TBasicBlock)(unsafe.Pointer(bbPtr)).FenclosingCatch != enclosing {
			if (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fflags&int32(TCL_EVAL_DIRECT) != 0 {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+4651, int64(-int32(1))))
				XTcl_SetErrorLine(tls, interp, (*TBasicBlock)(unsafe.Pointer(bbPtr)).FstartLine)
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+32, __ccgo_ts+2004, __ccgo_ts+3663, __ccgo_ts+4719, libc.UintptrFromInt32(0)))
			}
			return int32(TCL_ERROR)
		}
	}
	if state > (*TBasicBlock)(unsafe.Pointer(bbPtr)).FcatchState {
		(*TBasicBlock)(unsafe.Pointer(bbPtr)).FcatchState = state
		changed = int32(1)
	}
	/*
	 * If this block has been visited before, and its state hasn't changed,
	 * we're done with it for now.
	 */
	if !(changed != 0) {
		return TCL_OK
	}
	(*TBasicBlock)(unsafe.Pointer(bbPtr)).FcatchDepth = catchDepth
	/*
	 * Determine enclosing catch and 'caught' state for the fallthrough and
	 * the jump target. Default for both is the state of the current block.
	 */
	fallThruEnclosing = enclosing
	fallThruState = state
	jumpEnclosing = enclosing
	jumpState = state
	/*
	 * TODO: Make sure that the test cases include validating that a natural
	 * loop can't include 'beginCatch' or 'endCatch'
	 */
	if (*TBasicBlock)(unsafe.Pointer(bbPtr)).Fflags&int32(BB_BEGINCATCH) != 0 {
		/*
		 * If the block begins a catch, the state for the successor is 'in
		 * catch'. The jump target is the exception exit, and the state of the
		 * jump target is 'caught.'
		 */
		fallThruEnclosing = bbPtr
		fallThruState = int32(BBCS_INCATCH)
		jumpEnclosing = bbPtr
		jumpState = int32(BBCS_CAUGHT)
		catchDepth++
	}
	if (*TBasicBlock)(unsafe.Pointer(bbPtr)).Fflags&int32(BB_ENDCATCH) != 0 {
		/*
		 * If the block ends a catch, the state for the successor is whatever
		 * the state was on entry to the catch.
		 */
		if enclosing == libc.UintptrFromInt32(0) {
			if (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fflags&int32(TCL_EVAL_DIRECT) != 0 {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+4728, int64(-int32(1))))
				XTcl_SetErrorLine(tls, interp, (*TBasicBlock)(unsafe.Pointer(bbPtr)).FstartLine)
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+32, __ccgo_ts+2004, __ccgo_ts+3663, __ccgo_ts+4772, libc.UintptrFromInt32(0)))
			}
			return int32(TCL_ERROR)
		}
		fallThruEnclosing = (*TBasicBlock)(unsafe.Pointer(enclosing)).FenclosingCatch
		fallThruState = (*TBasicBlock)(unsafe.Pointer(enclosing)).FcatchState
		catchDepth--
	}
	/*
	 * Visit any successor blocks with the appropriate exception context
	 */
	result = TCL_OK
	if (*TBasicBlock)(unsafe.Pointer(bbPtr)).Fflags&int32(BB_FALLTHRU) != 0 {
		result = _ProcessCatchesInBasicBlock(tls, assemEnvPtr, (*TBasicBlock)(unsafe.Pointer(bbPtr)).Fsuccessor1, fallThruEnclosing, fallThruState, catchDepth)
	}
	if result == TCL_OK && (*TBasicBlock)(unsafe.Pointer(bbPtr)).FjumpTarget != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer((*TBasicBlock)(unsafe.Pointer(bbPtr)).FjumpTarget)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer((*TBasicBlock)(unsafe.Pointer(bbPtr)).FjumpTarget)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, (*TBasicBlock)(unsafe.Pointer(bbPtr)).FjumpTarget, libc.UintptrFromInt32(0))
		}
		entry = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(assemEnvPtr + 16)).FfindProc})))(tls, assemEnvPtr+16, v1)
		jumpTarget = (*TTcl_HashEntry)(unsafe.Pointer(entry)).FclientData
		result = _ProcessCatchesInBasicBlock(tls, assemEnvPtr, jumpTarget, jumpEnclosing, jumpState, catchDepth)
	}
	/*
	 * All blocks referenced in a jump table are successors.
	 */
	if (*TBasicBlock)(unsafe.Pointer(bbPtr)).Fflags&int32(BB_JUMPTABLE) != 0 {
		jtEntry = XTcl_FirstHashEntry(tls, (*TBasicBlock)(unsafe.Pointer(bbPtr)).FjtPtr, bp)
		for {
			if !(result == TCL_OK && jtEntry != libc.UintptrFromInt32(0)) {
				break
			}
			targetLabel = (*TTcl_HashEntry)(unsafe.Pointer(jtEntry)).FclientData
			if (*TTcl_Obj)(unsafe.Pointer(targetLabel)).Fbytes != 0 {
				v3 = (*TTcl_Obj)(unsafe.Pointer(targetLabel)).Fbytes
			} else {
				v3 = XTcl_GetStringFromObj(tls, targetLabel, libc.UintptrFromInt32(0))
			}
			entry = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(assemEnvPtr + 16)).FfindProc})))(tls, assemEnvPtr+16, v3)
			jumpTarget = (*TTcl_HashEntry)(unsafe.Pointer(entry)).FclientData
			result = _ProcessCatchesInBasicBlock(tls, assemEnvPtr, jumpTarget, jumpEnclosing, jumpState, catchDepth)
			goto _2
		_2:
			;
			jtEntry = XTcl_NextHashEntry(tls, bp)
		}
	}
	return result
}

/*
 *-----------------------------------------------------------------------------
 *
 * CheckForUnclosedCatches --
 *
 *	Checks that a sequence of assembly code has no unclosed catches on
 *	exit.
 *
 * Results:
 *	Returns a standard Tcl result, with an error message for unclosed
 *	catches.
 *
 *-----------------------------------------------------------------------------
 */

func _CheckForUnclosedCatches(tls *libc.TLS, assemEnvPtr uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Assembly environment */
	var envPtr, interp uintptr
	_, _ = envPtr, interp
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr
	/* Compilation environment */
	interp = (*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr
	/* Tcl interpreter */
	if (*TBasicBlock)(unsafe.Pointer((*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fcurr_bb)).FcatchState >= int32(BBCS_INCATCH) {
		if (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fflags&int32(TCL_EVAL_DIRECT) != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+4784, int64(-int32(1))))
			XTcl_SetErrorLine(tls, interp, (*TBasicBlock1)(unsafe.Pointer((*TBasicBlock)(unsafe.Pointer((*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fcurr_bb)).FenclosingCatch)).FstartLine)
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+3663, __ccgo_ts+4830, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *-----------------------------------------------------------------------------
 *
 * BuildExceptionRanges --
 *
 *	Walks through the assembly code and builds exception ranges for the
 *	catches embedded therein.
 *
 * Results:
 *	Returns a standard Tcl result with an error message in the interpreter
 *	if anything is unsuccessful.
 *
 * Side effects:
 *	Each contiguous block of code with a given catch exit is assigned an
 *	exception range at the appropriate level.
 *	Exception ranges in embedded blocks have their levels corrected and
 *	collated into the table.
 *	Blocks that end with 'beginCatch' are associated with the innermost
 *	exception range of the following block.
 *
 *-----------------------------------------------------------------------------
 */

func _BuildExceptionRanges(tls *libc.TLS, assemEnvPtr uintptr) (r int32) {
	/* Assembly environment */
	var bbPtr, catchIndices, catches, envPtr, prevPtr uintptr
	var catchDepth, i, maxCatchDepth int32
	_, _, _, _, _, _, _, _ = bbPtr, catchDepth, catchIndices, catches, envPtr, i, maxCatchDepth, prevPtr
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr /* Current basic block */
	prevPtr = libc.UintptrFromInt32(0)                            /* Previous basic block */
	catchDepth = 0                                                /* Current catch depth */
	maxCatchDepth = 0
	/*
	 * Determine the max catch depth for the entire assembly script
	 * (excluding embedded eval's and expr's, which will be handled later).
	 */
	bbPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fhead_bb
	for {
		if !(bbPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TBasicBlock)(unsafe.Pointer(bbPtr)).FcatchDepth > maxCatchDepth {
			maxCatchDepth = (*TBasicBlock)(unsafe.Pointer(bbPtr)).FcatchDepth
		}
		goto _1
	_1:
		;
		bbPtr = (*TBasicBlock)(unsafe.Pointer(bbPtr)).Fsuccessor1
	}
	/*
	 * Allocate memory for a stack of active catches.
	 */
	catches = XTcl_Alloc(tls, libc.Uint64FromInt32(maxCatchDepth)*uint64(8))
	catchIndices = XTcl_Alloc(tls, libc.Uint64FromInt32(maxCatchDepth)*uint64(4))
	i = 0
	for {
		if !(i < maxCatchDepth) {
			break
		}
		*(*uintptr)(unsafe.Pointer(catches + uintptr(i)*8)) = libc.UintptrFromInt32(0)
		*(*int32)(unsafe.Pointer(catchIndices + uintptr(i)*4)) = -int32(1)
		goto _2
	_2:
		;
		i++
	}
	/*
	 * Walk through the basic blocks and manage exception ranges.
	 */
	bbPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fhead_bb
	for {
		if !(bbPtr != libc.UintptrFromInt32(0)) {
			break
		}
		_UnstackExpiredCatches(tls, envPtr, bbPtr, catchDepth, catches, catchIndices)
		_LookForFreshCatches(tls, bbPtr, catches)
		_StackFreshCatches(tls, assemEnvPtr, bbPtr, catchDepth, catches, catchIndices)
		/*
		 * If the last block was a 'begin catch', fill in the exception range.
		 */
		catchDepth = (*TBasicBlock)(unsafe.Pointer(bbPtr)).FcatchDepth
		if prevPtr != libc.UintptrFromInt32(0) && (*TBasicBlock)(unsafe.Pointer(prevPtr)).Fflags&int32(BB_BEGINCATCH) != 0 {
			*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr((*TBasicBlock)(unsafe.Pointer(bbPtr)).FstartOffset) - libc.UintptrFromInt32(4))) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(catchIndices + uintptr(catchDepth-int32(1))*4))) >> libc.Int32FromInt32(24))
			*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr((*TBasicBlock)(unsafe.Pointer(bbPtr)).FstartOffset) - libc.UintptrFromInt32(4) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(catchIndices + uintptr(catchDepth-int32(1))*4))) >> libc.Int32FromInt32(16))
			*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr((*TBasicBlock)(unsafe.Pointer(bbPtr)).FstartOffset) - libc.UintptrFromInt32(4) + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(catchIndices + uintptr(catchDepth-int32(1))*4))) >> libc.Int32FromInt32(8))
			*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr((*TBasicBlock)(unsafe.Pointer(bbPtr)).FstartOffset) - libc.UintptrFromInt32(4) + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(catchIndices + uintptr(catchDepth-int32(1))*4))))
		}
		prevPtr = bbPtr
		goto _3
	_3:
		;
		bbPtr = (*TBasicBlock)(unsafe.Pointer(bbPtr)).Fsuccessor1
	}
	/* Make sure that all catches are closed */
	if catchDepth != 0 {
		XTcl_Panic(tls, __ccgo_ts+4844, 0)
	}
	/* Free temp storage */
	XTclpFree(tls, catchIndices)
	XTclpFree(tls, catches)
	return TCL_OK
}

/*
 *-----------------------------------------------------------------------------
 *
 * UnstackExpiredCatches --
 *
 *	Unstacks and closes the exception ranges for any catch contexts that
 *	were active in the previous basic block but are inactive in the
 *	current one.
 *
 *-----------------------------------------------------------------------------
 */

func _UnstackExpiredCatches(tls *libc.TLS, envPtr uintptr, bbPtr uintptr, catchDepth int32, catches uintptr, catchIndices uintptr) {
	/* Indices of the exception ranges
	 * corresponding to the catch contexts */
	var block, range1 uintptr
	var catchState TBasicBlockCatchState
	_, _, _ = block, catchState, range1
	/* State of the code relative to the catch
	 * block being examined ("in catch" or
	 * "caught"). */
	/*
	 * Unstack any catches that are deeper than the nesting level of the basic
	 * block being entered.
	 */
	for catchDepth > (*TBasicBlock)(unsafe.Pointer(bbPtr)).FcatchDepth {
		catchDepth--
		if *(*uintptr)(unsafe.Pointer(catches + uintptr(catchDepth)*8)) != libc.UintptrFromInt32(0) {
			range1 = (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayPtr + uintptr(*(*int32)(unsafe.Pointer(catchIndices + uintptr(catchDepth)*4)))*56
			(*TExceptionRange)(unsafe.Pointer(range1)).FnumCodeBytes = int64((*TBasicBlock)(unsafe.Pointer(bbPtr)).FstartOffset) - (*TExceptionRange)(unsafe.Pointer(range1)).FcodeOffset
			*(*uintptr)(unsafe.Pointer(catches + uintptr(catchDepth)*8)) = libc.UintptrFromInt32(0)
			*(*int32)(unsafe.Pointer(catchIndices + uintptr(catchDepth)*4)) = -int32(1)
		}
	}
	/*
	 * Unstack any catches that don't match the basic block being entered,
	 * either because they are no longer part of the context, or because the
	 * context has changed from INCATCH to CAUGHT.
	 */
	catchState = (*TBasicBlock)(unsafe.Pointer(bbPtr)).FcatchState
	block = (*TBasicBlock)(unsafe.Pointer(bbPtr)).FenclosingCatch
	for catchDepth > 0 {
		catchDepth--
		if *(*uintptr)(unsafe.Pointer(catches + uintptr(catchDepth)*8)) != libc.UintptrFromInt32(0) {
			if *(*uintptr)(unsafe.Pointer(catches + uintptr(catchDepth)*8)) != block || catchState >= int32(BBCS_CAUGHT) {
				range1 = (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayPtr + uintptr(*(*int32)(unsafe.Pointer(catchIndices + uintptr(catchDepth)*4)))*56
				(*TExceptionRange)(unsafe.Pointer(range1)).FnumCodeBytes = int64((*TBasicBlock)(unsafe.Pointer(bbPtr)).FstartOffset) - (*TExceptionRange)(unsafe.Pointer(range1)).FcodeOffset
				*(*uintptr)(unsafe.Pointer(catches + uintptr(catchDepth)*8)) = libc.UintptrFromInt32(0)
				*(*int32)(unsafe.Pointer(catchIndices + uintptr(catchDepth)*4)) = -int32(1)
			}
			catchState = (*TBasicBlock)(unsafe.Pointer(block)).FcatchState
			block = (*TBasicBlock)(unsafe.Pointer(block)).FenclosingCatch
		}
	}
}

/*
 *-----------------------------------------------------------------------------
 *
 * LookForFreshCatches --
 *
 *	Determines whether a basic block being entered needs any exception
 *	ranges that are not already stacked.
 *
 * Does not create the ranges: this procedure iterates from the innermost
 * catch outward, but exception ranges must be created from the outermost
 * catch inward.
 *
 *-----------------------------------------------------------------------------
 */

func _LookForFreshCatches(tls *libc.TLS, bbPtr uintptr, catches uintptr) {
	/* Array of catch contexts that are already
	 * entered */
	var block uintptr
	var catchDepth int32
	var catchState TBasicBlockCatchState
	_, _, _ = block, catchDepth, catchState /* Nesting depth of the current catch */
	catchState = (*TBasicBlock)(unsafe.Pointer(bbPtr)).FcatchState
	block = (*TBasicBlock)(unsafe.Pointer(bbPtr)).FenclosingCatch
	catchDepth = (*TBasicBlock)(unsafe.Pointer(bbPtr)).FcatchDepth
	for catchDepth > 0 {
		catchDepth--
		if *(*uintptr)(unsafe.Pointer(catches + uintptr(catchDepth)*8)) != block && catchState < int32(BBCS_CAUGHT) {
			*(*uintptr)(unsafe.Pointer(catches + uintptr(catchDepth)*8)) = block
		}
		catchState = (*TBasicBlock)(unsafe.Pointer(block)).FcatchState
		block = (*TBasicBlock)(unsafe.Pointer(block)).FenclosingCatch
	}
}

/*
 *-----------------------------------------------------------------------------
 *
 * StackFreshCatches --
 *
 *	Make ExceptionRange records for any catches that are in the basic
 *	block being entered and were not in the previous basic block.
 *
 *-----------------------------------------------------------------------------
 */

func _StackFreshCatches(tls *libc.TLS, assemEnvPtr uintptr, bbPtr uintptr, catchDepth int32, catches uintptr, catchIndices uintptr) {
	/* Indices of the exception ranges
	 * corresponding to the catch contexts */
	var block, entryPtr, envPtr, errorExit, range1, v3 uintptr
	var v2 int64
	_, _, _, _, _, _, _ = block, entryPtr, envPtr, errorExit, range1, v2, v3
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr
	catchDepth = 0
	/*
	 * Iterate through the enclosing catch blocks from the outside in,
	 * looking for ones that don't have exception ranges (and are uncaught)
	 */
	catchDepth = 0
	for {
		if !(catchDepth < (*TBasicBlock)(unsafe.Pointer(bbPtr)).FcatchDepth) {
			break
		}
		if *(*int32)(unsafe.Pointer(catchIndices + uintptr(catchDepth)*4)) == -int32(1) && *(*uintptr)(unsafe.Pointer(catches + uintptr(catchDepth)*8)) != libc.UintptrFromInt32(0) {
			/*
			 * Create an exception range for a block that needs one.
			 */
			block = *(*uintptr)(unsafe.Pointer(catches + uintptr(catchDepth)*8))
			*(*int32)(unsafe.Pointer(catchIndices + uintptr(catchDepth)*4)) = int32(XTclCreateExceptRange(tls, int32(CATCH_EXCEPTION_RANGE), envPtr))
			range1 = (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayPtr + uintptr(*(*int32)(unsafe.Pointer(catchIndices + uintptr(catchDepth)*4)))*56
			(*TExceptionRange)(unsafe.Pointer(range1)).FnestingLevel = (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptDepth + int64(catchDepth)
			if libc.Uint64FromInt64((*TExceptionRange)(unsafe.Pointer(range1)).FnestingLevel)+uint64(1)+uint64(1) > libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr)).FmaxExceptDepth)+uint64(1) {
				v2 = (*TExceptionRange)(unsafe.Pointer(range1)).FnestingLevel + int64(1)
			} else {
				v2 = (*TCompileEnv)(unsafe.Pointer(envPtr)).FmaxExceptDepth
			}
			(*TCompileEnv)(unsafe.Pointer(envPtr)).FmaxExceptDepth = v2
			(*TExceptionRange)(unsafe.Pointer(range1)).FcodeOffset = int64((*TBasicBlock)(unsafe.Pointer(bbPtr)).FstartOffset)
			if (*TTcl_Obj)(unsafe.Pointer((*TBasicBlock)(unsafe.Pointer(block)).FjumpTarget)).Fbytes != 0 {
				v3 = (*TTcl_Obj)(unsafe.Pointer((*TBasicBlock)(unsafe.Pointer(block)).FjumpTarget)).Fbytes
			} else {
				v3 = XTcl_GetStringFromObj(tls, (*TBasicBlock)(unsafe.Pointer(block)).FjumpTarget, libc.UintptrFromInt32(0))
			}
			entryPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(assemEnvPtr + 16)).FfindProc})))(tls, assemEnvPtr+16, v3)
			if entryPtr == libc.UintptrFromInt32(0) {
				XTcl_Panic(tls, __ccgo_ts+4926, 0)
			}
			errorExit = (*TTcl_HashEntry)(unsafe.Pointer(entryPtr)).FclientData
			(*TExceptionRange)(unsafe.Pointer(range1)).FcatchOffset = int64((*TBasicBlock)(unsafe.Pointer(errorExit)).FstartOffset)
		}
		goto _1
	_1:
		;
		catchDepth++
	}
}

/*
 *-----------------------------------------------------------------------------
 *
 * RestoreEmbeddedExceptionRanges --
 *
 *	Processes an assembly script, replacing any exception ranges that
 *	were present in embedded code.
 *
 *-----------------------------------------------------------------------------
 */

func _RestoreEmbeddedExceptionRanges(tls *libc.TLS, assemEnvPtr uintptr) {
	/* Assembly environment */
	var bbPtr, envPtr, range1 uintptr
	var catchIndex, i, rangeBase int32
	var opcode uint8
	var rangeIndex Tsize_t
	_, _, _, _, _, _, _, _ = bbPtr, catchIndex, envPtr, i, opcode, range1, rangeBase, rangeIndex
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr
	/*
	 * Walk the basic blocks looking for exceptions in embedded scripts.
	 */
	bbPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fhead_bb
	for {
		if !(bbPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TBasicBlock)(unsafe.Pointer(bbPtr)).FforeignExceptionCount != 0 {
			/*
			 * Reinstall the embedded exceptions and track their nesting level
			 */
			rangeBase = int32((*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayNext)
			i = 0
			for {
				if !(i < (*TBasicBlock)(unsafe.Pointer(bbPtr)).FforeignExceptionCount) {
					break
				}
				range1 = (*TBasicBlock)(unsafe.Pointer(bbPtr)).FforeignExceptions + uintptr(i)*56
				rangeIndex = libc.Uint64FromInt64(XTclCreateExceptRange(tls, (*TExceptionRange)(unsafe.Pointer(range1)).Ftype1, envPtr))
				*(*TTcl_Size)(unsafe.Pointer(range1 + 8)) += (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptDepth + int64((*TBasicBlock)(unsafe.Pointer(bbPtr)).FcatchDepth)
				libc.Xmemcpy(tls, (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayPtr+uintptr(rangeIndex)*56, range1, uint64(56))
				if (*TExceptionRange)(unsafe.Pointer(range1)).FnestingLevel+int64(1) >= (*TCompileEnv)(unsafe.Pointer(envPtr)).FmaxExceptDepth+int64(1) {
					(*TCompileEnv)(unsafe.Pointer(envPtr)).FmaxExceptDepth = (*TExceptionRange)(unsafe.Pointer(range1)).FnestingLevel + int64(1)
				}
				goto _2
			_2:
				;
				i++
			}
			/*
			 * Walk through the bytecode of the basic block, and relocate
			 * INST_BEGIN_CATCH4 instructions to the new locations
			 */
			i = (*TBasicBlock)(unsafe.Pointer(bbPtr)).FstartOffset
			for i < (*TBasicBlock1)(unsafe.Pointer((*TBasicBlock)(unsafe.Pointer(bbPtr)).Fsuccessor1)).FstartOffset {
				opcode = *(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr(i)))
				if libc.Int32FromUint8(opcode) == int32(INST_BEGIN_CATCH4) {
					catchIndex = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr(i) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr(i) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr(i) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr(i) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
					if catchIndex >= (*TBasicBlock)(unsafe.Pointer(bbPtr)).FforeignExceptionBase && catchIndex < (*TBasicBlock)(unsafe.Pointer(bbPtr)).FforeignExceptionBase+(*TBasicBlock)(unsafe.Pointer(bbPtr)).FforeignExceptionCount {
						catchIndex -= (*TBasicBlock)(unsafe.Pointer(bbPtr)).FforeignExceptionBase
						catchIndex += rangeBase
						*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr(i) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(catchIndex) >> libc.Int32FromInt32(24))
						*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr(i) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(catchIndex) >> libc.Int32FromInt32(16))
						*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr(i) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt32(catchIndex) >> libc.Int32FromInt32(8))
						*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr(i) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt32(catchIndex))
					}
				}
				i = int32(int64(i) + XtclInstructionTable[opcode].FnumBytes)
			}
		}
		goto _1
	_1:
		;
		bbPtr = (*TBasicBlock)(unsafe.Pointer(bbPtr)).Fsuccessor1
	}
}

/*
 *-----------------------------------------------------------------------------
 *
 * ResetVisitedBasicBlocks --
 *
 *	Turns off the 'visited' flag in all basic blocks at the conclusion
 *	of a pass.
 *
 *-----------------------------------------------------------------------------
 */

func _ResetVisitedBasicBlocks(tls *libc.TLS, assemEnvPtr uintptr) {
	/* Assembly environment */
	var block uintptr
	_ = block
	block = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).Fhead_bb
	for {
		if !(block != libc.UintptrFromInt32(0)) {
			break
		}
		*(*int32)(unsafe.Pointer(block + 112)) &= ^int32(BB_VISITED)
		goto _1
	_1:
		;
		block = (*TBasicBlock)(unsafe.Pointer(block)).Fsuccessor1
	}
}

/*
 *-----------------------------------------------------------------------------
 *
 * AddBasicBlockRangeToErrorInfo --
 *
 *	Updates the error info of the Tcl interpreter to show a given basic
 *	block in the code.
 *
 * This procedure is used to label the callstack with source location
 * information when reporting an error in stack checking.
 *
 *-----------------------------------------------------------------------------
 */

func _AddBasicBlockRangeToErrorInfo(tls *libc.TLS, assemEnvPtr uintptr, bbPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Basic block in which the error is found */
	var _isobjPtr, _objPtr, cachePtr, envPtr, interp, lineNo, v3 uintptr
	var v1 bool
	var v2 TTcl_Size
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_, _, _, _, _, _, _, _, _ = _isobjPtr, _objPtr, cachePtr, envPtr, interp, lineNo, v1, v2, v3
	envPtr = (*TAssemblyEnv)(unsafe.Pointer(assemEnvPtr)).FenvPtr
	/* Compilation environment */
	interp = (*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr /* Line number in the source */
	XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+4994, int64(-int32(1))))
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		lineNo = XTclThreadAllocObj(tls)
	} else {
		lineNo = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(lineNo + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(lineNo)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(lineNo)).Fbytes = libc.UintptrFromInt32(0)
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(lineNo)).FinternalRep)) = int64((*TBasicBlock)(unsafe.Pointer(bbPtr)).FstartLine)
	(*TTcl_Obj)(unsafe.Pointer(lineNo)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	(*TTcl_Obj)(unsafe.Pointer(lineNo)).FrefCount++
	XTcl_AppendObjToErrorInfo(tls, interp, lineNo)
	XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+5031, int64(-int32(1))))
	if (*TBasicBlock)(unsafe.Pointer(bbPtr)).Fsuccessor1 != libc.UintptrFromInt32(0) {
		*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp)))) = int64((*TBasicBlock1)(unsafe.Pointer((*TBasicBlock)(unsafe.Pointer(bbPtr)).Fsuccessor1)).FstartLine)
		_isobjPtr = lineNo
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
		}
		XTcl_StoreInternalRep(tls, lineNo, uintptr(unsafe.Pointer(&XtclIntType)), bp)
		XTcl_AppendObjToErrorInfo(tls, interp, lineNo)
	} else {
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+5037, int64(-int32(1))))
	}
	_objPtr = lineNo
	v3 = _objPtr
	v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
	*(*TTcl_Size)(unsafe.Pointer(v3))--
	if v2 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
}

/*
 *-----------------------------------------------------------------------------
 *
 * DupAssembleCodeInternalRep --
 *
 *	Part of the Tcl object type implementation for Tcl assembly language
 *	bytecode. We do not copy the bytecode internalrep. Instead, we return
 *	without setting copyPtr->typePtr, so the copy is a plain string copy
 *	of the assembly source, and if it is to be used as a compiled
 *	expression, it will need to be reprocessed.
 *
 *	This makes sense, because with Tcl's copy-on-write practices, the
 *	usual (only?) time Tcl_DuplicateObj() will be called is when the copy
 *	is about to be modified, which would invalidate any copied bytecode
 *	anyway. The only reason it might make sense to copy the bytecode is if
 *	we had some modifying routines that operated directly on the internalrep,
 *	as we do for lists and dicts.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *-----------------------------------------------------------------------------
 */

func _DupAssembleCodeInternalRep(tls *libc.TLS, dummy4311 uintptr, dummy4312 uintptr) {
	return
}

/*
 *-----------------------------------------------------------------------------
 *
 * FreeAssembleCodeInternalRep --
 *
 *	Part of the Tcl object type implementation for Tcl expression
 *	bytecode. Frees the storage allocated to hold the internal rep, unless
 *	ref counts indicate bytecode execution is still in progress.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	May free allocated memory. Leaves objPtr untyped.
 *
 *-----------------------------------------------------------------------------
 */

func _FreeAssembleCodeInternalRep(tls *libc.TLS, objPtr uintptr) {
	var codePtr, irPtr, v1, v2 uintptr
	_, _, _, _ = codePtr, irPtr, v1, v2
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_assembleCodeType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	codePtr = v2
	XTclReleaseByteCode(tls, codePtr)
}

type TBasicBlock1 = struct {
	ForiginalStartOffset   int32
	FstartOffset           int32
	FstartLine             int32
	FjumpOffset            int32
	FjumpLine              int32
	FprevPtr               uintptr
	Fpredecessor           uintptr
	Fsuccessor1            uintptr
	FjumpTarget            uintptr
	FinitialStackDepth     int32
	FminStackDepth         int32
	FmaxStackDepth         int32
	FfinalStackDepth       int32
	FcatchState            BasicBlockCatchState
	FcatchDepth            int32
	FenclosingCatch        uintptr
	FforeignExceptionBase  int32
	FforeignExceptionCount int32
	FforeignExceptions     uintptr
	FjtPtr                 uintptr
	Fflags                 int32
}

/* Epoch of the tcl environment
 * (if changed with tcl-env). */

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/* Forward declaration */
type TThreadSpecificData1 = struct {
	FasyncReady  int32
	FasyncActive int32
}

/*
 * One of the following structures exists for each asynchronous handler:
 */

type TAsyncHandler = struct {
	Fready        int32
	FnextPtr      uintptr
	FprevPtr      uintptr
	Fproc         uintptr
	FclientData   uintptr
	ForiginTsd    uintptr
	ForiginThrdId TTcl_ThreadId
	FnotifierData uintptr
}

type TThreadSpecificData = struct {
	FasyncReady  int32
	FasyncActive int32
}

var _dataKey TTcl_ThreadDataKey

// C documentation
//
//	/* Mutex to protect linked-list of AsyncHandlers in the process. */
var _asyncMutex TTcl_Mutex

// C documentation
//
//	/* List of all existing handlers of the process. */
var _firstHandler = libc.UintptrFromInt32(0)
var _lastHandler = libc.UintptrFromInt32(0)

/*
 *----------------------------------------------------------------------
 *
 * TclFinalizeAsync --
 *
 *	Finalizes the thread local data structure for the async
 *	subsystem.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Cleans up left-over async handlers for the calling thread.
 *
 *----------------------------------------------------------------------
 */

func XTclFinalizeAsync(tls *libc.TLS) {
	var nextToken, toDelete, token uintptr
	var self TTcl_ThreadId
	_, _, _, _ = nextToken, self, toDelete, token
	toDelete = libc.UintptrFromInt32(0)
	self = XTcl_GetCurrentThread(tls)
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_asyncMutex)))
	token = _firstHandler
	for {
		if !(token != libc.UintptrFromInt32(0)) {
			break
		}
		nextToken = (*TAsyncHandler)(unsafe.Pointer(token)).FnextPtr
		if (*TAsyncHandler)(unsafe.Pointer(token)).ForiginThrdId == self {
			if (*TAsyncHandler)(unsafe.Pointer(token)).FprevPtr == libc.UintptrFromInt32(0) {
				_firstHandler = (*TAsyncHandler)(unsafe.Pointer(token)).FnextPtr
				if _firstHandler == libc.UintptrFromInt32(0) {
					_lastHandler = libc.UintptrFromInt32(0)
					break
				}
			} else {
				(*TAsyncHandler1)(unsafe.Pointer((*TAsyncHandler)(unsafe.Pointer(token)).FprevPtr)).FnextPtr = (*TAsyncHandler)(unsafe.Pointer(token)).FnextPtr
				if token == _lastHandler {
					_lastHandler = (*TAsyncHandler)(unsafe.Pointer(token)).FprevPtr
				}
			}
			if (*TAsyncHandler)(unsafe.Pointer(token)).FnextPtr != libc.UintptrFromInt32(0) {
				(*TAsyncHandler1)(unsafe.Pointer((*TAsyncHandler)(unsafe.Pointer(token)).FnextPtr)).FprevPtr = (*TAsyncHandler)(unsafe.Pointer(token)).FprevPtr
			}
			(*TAsyncHandler)(unsafe.Pointer(token)).FnextPtr = toDelete
			(*TAsyncHandler)(unsafe.Pointer(token)).FprevPtr = libc.UintptrFromInt32(0)
			toDelete = token
		}
		token = nextToken
		goto _1
	_1:
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_asyncMutex)))
	for toDelete != libc.UintptrFromInt32(0) {
		token = toDelete
		toDelete = (*TAsyncHandler)(unsafe.Pointer(toDelete)).FnextPtr
		XTclpFree(tls, token)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_AsyncCreate --
 *
 *	This procedure creates the data structures for an asynchronous
 *	handler, so that no memory has to be allocated when the handler is
 *	activated.
 *
 * Results:
 *	The return value is a token for the handler, which can be used to
 *	activate it later on.
 *
 * Side effects:
 *	Information about the handler is recorded.
 *
 *----------------------------------------------------------------------
 */

func XTcl_AsyncCreate(tls *libc.TLS, proc uintptr, clientData uintptr) (r TTcl_AsyncHandler) {
	/* Argument to pass to handler. */
	var asyncPtr, tsdPtr uintptr
	_, _ = asyncPtr, tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey)), int64(8))
	asyncPtr = XTcl_Alloc(tls, uint64(64))
	(*TAsyncHandler)(unsafe.Pointer(asyncPtr)).Fready = 0
	(*TAsyncHandler)(unsafe.Pointer(asyncPtr)).FnextPtr = libc.UintptrFromInt32(0)
	(*TAsyncHandler)(unsafe.Pointer(asyncPtr)).FprevPtr = libc.UintptrFromInt32(0)
	(*TAsyncHandler)(unsafe.Pointer(asyncPtr)).Fproc = proc
	(*TAsyncHandler)(unsafe.Pointer(asyncPtr)).FclientData = clientData
	(*TAsyncHandler)(unsafe.Pointer(asyncPtr)).ForiginTsd = tsdPtr
	(*TAsyncHandler)(unsafe.Pointer(asyncPtr)).ForiginThrdId = XTcl_GetCurrentThread(tls)
	(*TAsyncHandler)(unsafe.Pointer(asyncPtr)).FnotifierData = XTclpNotifierData(tls)
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_asyncMutex)))
	if _firstHandler == libc.UintptrFromInt32(0) {
		_firstHandler = asyncPtr
	} else {
		(*TAsyncHandler)(unsafe.Pointer(asyncPtr)).FprevPtr = _lastHandler
		(*TAsyncHandler)(unsafe.Pointer(_lastHandler)).FnextPtr = asyncPtr
	}
	_lastHandler = asyncPtr
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_asyncMutex)))
	return asyncPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_AsyncMark --
 *
 *	This procedure is called to request that an asynchronous handler be
 *	invoked as soon as possible. It's typically called from an interrupt
 *	handler, where it isn't safe to do anything that depends on or
 *	modifies application state.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The handler gets marked for invocation later.
 *
 *----------------------------------------------------------------------
 */

func XTcl_AsyncMark(tls *libc.TLS, async TTcl_AsyncHandler) {
	/* Token for handler. */
	var token uintptr
	_ = token
	token = async
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_asyncMutex)))
	(*TAsyncHandler)(unsafe.Pointer(token)).Fready = int32(1)
	if !((*TThreadSpecificData1)(unsafe.Pointer((*TAsyncHandler)(unsafe.Pointer(token)).ForiginTsd)).FasyncActive != 0) {
		(*TThreadSpecificData1)(unsafe.Pointer((*TAsyncHandler)(unsafe.Pointer(token)).ForiginTsd)).FasyncReady = int32(1)
		XTcl_ThreadAlert(tls, (*TAsyncHandler)(unsafe.Pointer(token)).ForiginThrdId)
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_asyncMutex)))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_AsyncMarkFromSignal --
 *
 *	This procedure is similar to Tcl_AsyncMark but must be used
 *	in POSIX signal contexts. In addition to Tcl_AsyncMark the
 *	signal number is passed.
 *
 * Results:
 *	True, when the handler will be marked, false otherwise.
 *
 * Side effects:
 *	The handler gets marked for invocation later.
 *
 *----------------------------------------------------------------------
 */

func XTcl_AsyncMarkFromSignal(tls *libc.TLS, async TTcl_AsyncHandler, sigNumber int32) (r int32) {
	/* Signal number. */
	var token uintptr
	_ = token
	token = async
	return XTclAsyncNotifier(tls, sigNumber, (*TAsyncHandler)(unsafe.Pointer(token)).ForiginThrdId, (*TAsyncHandler)(unsafe.Pointer(token)).FnotifierData, token, -int32(1))
}

/*
 *----------------------------------------------------------------------
 *
 * TclAsyncMarkFromNotifier --
 *
 *	This procedure is called from the notifier thread and
 *	invokes Tcl_AsyncMark for specifically marked handlers.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Handlers get marked for invocation later.
 *
 *----------------------------------------------------------------------
 */

func XTclAsyncMarkFromNotifier(tls *libc.TLS) {
	var token uintptr
	_ = token
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_asyncMutex)))
	token = _firstHandler
	for {
		if !(token != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TAsyncHandler)(unsafe.Pointer(token)).Fready == -int32(1) {
			(*TAsyncHandler)(unsafe.Pointer(token)).Fready = int32(1)
			if !((*TThreadSpecificData1)(unsafe.Pointer((*TAsyncHandler)(unsafe.Pointer(token)).ForiginTsd)).FasyncActive != 0) {
				(*TThreadSpecificData1)(unsafe.Pointer((*TAsyncHandler)(unsafe.Pointer(token)).ForiginTsd)).FasyncReady = int32(1)
				XTcl_ThreadAlert(tls, (*TAsyncHandler)(unsafe.Pointer(token)).ForiginThrdId)
			}
		}
		goto _1
	_1:
		;
		token = (*TAsyncHandler)(unsafe.Pointer(token)).FnextPtr
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_asyncMutex)))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_AsyncInvoke --
 *
 *	This procedure is called at a "safe" time at background level to
 *	invoke any active asynchronous handlers.
 *
 * Results:
 *	The return value is a normal Tcl result, which is intended to replace
 *	the code argument as the current completion code for interp.
 *
 * Side effects:
 *	Depends on the handlers that are active.
 *
 *----------------------------------------------------------------------
 */

func XTcl_AsyncInvoke(tls *libc.TLS, interp uintptr, code int32) (r int32) {
	/* If interp is non-NULL, this gives
	 * completion code from command that just
	 * completed. */
	var asyncPtr, tsdPtr uintptr
	var self TTcl_ThreadId
	_, _, _ = asyncPtr, self, tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey)), int64(8))
	self = XTcl_GetCurrentThread(tls)
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_asyncMutex)))
	if (*TThreadSpecificData)(unsafe.Pointer(tsdPtr)).FasyncReady == 0 {
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_asyncMutex)))
		return code
	}
	(*TThreadSpecificData)(unsafe.Pointer(tsdPtr)).FasyncReady = 0
	(*TThreadSpecificData)(unsafe.Pointer(tsdPtr)).FasyncActive = int32(1)
	if interp == libc.UintptrFromInt32(0) {
		code = 0
	}
	/*
	 * Make one or more passes over the list of handlers, invoking at most one
	 * handler in each pass. After invoking a handler, go back to the start of
	 * the list again so that (a) if a new higher-priority handler gets marked
	 * while executing a lower priority handler, we execute the higher-
	 * priority handler next, and (b) if a handler gets deleted during the
	 * execution of a handler, then the list structure may change so it isn't
	 * safe to continue down the list anyway.
	 */
	for int32(1) != 0 {
		asyncPtr = _firstHandler
		for {
			if !(asyncPtr != libc.UintptrFromInt32(0)) {
				break
			}
			if (*TAsyncHandler)(unsafe.Pointer(asyncPtr)).ForiginThrdId != self {
				goto _1
			}
			if (*TAsyncHandler)(unsafe.Pointer(asyncPtr)).Fready != 0 {
				break
			}
			goto _1
		_1:
			;
			asyncPtr = (*TAsyncHandler)(unsafe.Pointer(asyncPtr)).FnextPtr
		}
		if asyncPtr == libc.UintptrFromInt32(0) {
			break
		}
		(*TAsyncHandler)(unsafe.Pointer(asyncPtr)).Fready = 0
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_asyncMutex)))
		code = (*(*func(*libc.TLS, uintptr, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{(*TAsyncHandler)(unsafe.Pointer(asyncPtr)).Fproc})))(tls, (*TAsyncHandler)(unsafe.Pointer(asyncPtr)).FclientData, interp, code)
		XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_asyncMutex)))
	}
	(*TThreadSpecificData)(unsafe.Pointer(tsdPtr)).FasyncActive = 0
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_asyncMutex)))
	return code
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_AsyncDelete --
 *
 *	Frees up all the state for an asynchronous handler. The handler should
 *	never be used again.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The state associated with the handler is deleted.
 *
 *	Failure to locate the handler in current thread private list
 *	of async handlers will result in panic; exception: the list
 *	is already empty (potential trouble?).
 *	Consequently, threads should create and delete handlers
 *	themselves.  I.e. a handler created by one should not be
 *	deleted by some other thread.
 *
 *----------------------------------------------------------------------
 */

func XTcl_AsyncDelete(tls *libc.TLS, async TTcl_AsyncHandler) {
	/* Token for handler to delete. */
	var asyncPtr uintptr
	_ = asyncPtr
	asyncPtr = async
	/*
	 * Assure early handling of the constraint
	 */
	if (*TAsyncHandler)(unsafe.Pointer(asyncPtr)).ForiginThrdId != XTcl_GetCurrentThread(tls) {
		XTcl_Panic(tls, __ccgo_ts+5058, 0)
	}
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_asyncMutex)))
	if (*TAsyncHandler)(unsafe.Pointer(asyncPtr)).FprevPtr == libc.UintptrFromInt32(0) {
		_firstHandler = (*TAsyncHandler)(unsafe.Pointer(asyncPtr)).FnextPtr
		if _firstHandler == libc.UintptrFromInt32(0) {
			_lastHandler = libc.UintptrFromInt32(0)
		}
	} else {
		(*TAsyncHandler1)(unsafe.Pointer((*TAsyncHandler)(unsafe.Pointer(asyncPtr)).FprevPtr)).FnextPtr = (*TAsyncHandler)(unsafe.Pointer(asyncPtr)).FnextPtr
		if asyncPtr == _lastHandler {
			_lastHandler = (*TAsyncHandler)(unsafe.Pointer(asyncPtr)).FprevPtr
		}
	}
	if (*TAsyncHandler)(unsafe.Pointer(asyncPtr)).FnextPtr != libc.UintptrFromInt32(0) {
		(*TAsyncHandler1)(unsafe.Pointer((*TAsyncHandler)(unsafe.Pointer(asyncPtr)).FnextPtr)).FprevPtr = (*TAsyncHandler)(unsafe.Pointer(asyncPtr)).FprevPtr
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_asyncMutex)))
	XTclpFree(tls, asyncPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_AsyncReady --
 *
 *	This procedure can be used to tell whether Tcl_AsyncInvoke needs to be
 *	called. This procedure is the external interface for checking the
 *	thread-specific asyncReady variable.
 *
 * Results:
 *	The return value is 1 whenever a handler is ready and is 0 when no
 *	handlers are ready.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_AsyncReady(tls *libc.TLS) (r int32) {
	var tsdPtr uintptr
	_ = tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey)), int64(8))
	return (*TThreadSpecificData)(unsafe.Pointer(tsdPtr)).FasyncReady
}

func XTclGetAsyncReadyPtr(tls *libc.TLS) (r uintptr) {
	var tsdPtr uintptr
	_ = tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey)), int64(8))
	return tsdPtr
}

type TAsyncHandler1 = struct {
	Fready        int32
	FnextPtr      uintptr
	FprevPtr      uintptr
	Fproc         uintptr
	FclientData   uintptr
	ForiginTsd    uintptr
	ForiginThrdId TTcl_ThreadId
	FnotifierData uintptr
}

const CMD_IS_SAFE = 1
const COROUTINE_ARGUMENTS_ARBITRARY = -2
const COROUTINE_ARGUMENTS_SINGLE_OPTIONAL = -1
const CORO_ACTIVATE_YIELD = "NULL"
const CORO_STACK_INITIAL_SIZE = 200
const DIGIT_BIT = 28
const DTraceCmdReturn = "NULL"
const INTERIM_HACK_NAME = "___tmp"
const INTERP_STACK_INITIAL_SIZE = 2000
const LTM_PRIME_2MSB_ON = 8
const LTM_PRIME_BBS = 1
const LTM_PRIME_SAFE = 2
const MATH_FUNC_PREFIX_LEN = 17
const MATH_OP_PREFIX_LEN = 15
const MAX_EXACT = 9.007199254740991e+15
const MP_BIG_ENDIAN = 1
const MP_BUF = -5
const MP_DIGIT_BIT = 28
const MP_DIGIT_MAX = "MP_MASK"
const MP_EQ = 0
const MP_ERR = -1
const MP_GT = 1
const MP_ITER = -4
const MP_LITTLE_ENDIAN = -1
const MP_LSB_FIRST = -1
const MP_LT = -1
const MP_MEM = -2
const MP_MSB_FIRST = 1
const MP_NATIVE_ENDIAN = 0
const MP_NEG = 1
const MP_NO = 0
const MP_OKAY = 0
const MP_PRIME_2MSB_ON = 8
const MP_PRIME_BBS = 1
const MP_PRIME_SAFE = 2
const MP_RANGE = -3
const MP_SIZEOF_MP_DIGIT = 0
const MP_VAL = -3
const MP_YES = 1
const MP_ZPOS = 0
const PRIME_SIZE = 256
const PRIVATE_MP_PRIME_TAB_SIZE = 256
const RAND_IA = 16807
const RAND_IM = 2147483647
const RAND_IQ = 127773
const RAND_IR = 2836
const RAND_MASK = 123459876
const TCLTOMMATH_EPOCH = 0
const TCLTOMMATH_REVISION = 0
const TCL_FPCLASSIFY_MODE = 0
const bn_reverse = 0
const mp_add = 0
const mp_add_d = 0
const mp_and = 0
const mp_clamp = 0
const mp_clear = 0
const mp_clear_multi = 0
const mp_cmp = 0
const mp_cmp_d = 0
const mp_cmp_mag = 0
const mp_cnt_lsb = 0
const mp_copy = 0
const mp_count_bits = 0
const mp_div = 0
const mp_div_2 = 0
const mp_div_2d = 0
const mp_div_d = 0
const mp_exch = 0
const mp_expt_d = 0
const mp_expt_n = 0
const mp_get_mag_u64 = 0
const mp_grow = 0
const mp_init = 0
const mp_init_copy = 0
const mp_init_i64 = 0
const mp_init_multi = 0
const mp_init_set = 0
const mp_init_size = 0
const mp_init_u64 = 0
const mp_lshd = 0
const mp_mod = 0
const mp_mod_2d = 0
const mp_mul = 0
const mp_mul_2 = 0
const mp_mul_2d = 0
const mp_mul_d = 0
const mp_neg = 0
const mp_or = 0
const mp_pack = 0
const mp_pack_count = 0
const mp_radix_size = 0
const mp_read_radix = 0
const mp_rshd = 0
const mp_s_rmap = 0
const mp_s_rmap_reverse = 0
const mp_s_rmap_reverse_sz = 0
const mp_set_i64 = 0
const mp_set_u64 = 0
const mp_shrink = 0
const mp_signed_rsh = 0
const mp_sqrt = 0
const mp_sub = 0
const mp_sub_d = 0
const mp_tc_and = 0
const mp_tc_div_2d = 0
const mp_tc_or = 0
const mp_tc_xor = 0
const mp_to_radix = 0
const mp_to_ubin = 0
const mp_to_unsigned_bin = 0
const mp_to_unsigned_bin_n = 0
const mp_toradix_n = 0
const mp_ubin_size = 0
const mp_unpack = 0
const mp_word = 0
const mp_xor = 0
const mp_zero = 0
const s_mp_add = 0
const s_mp_balance_mul = 0
const s_mp_div_3 = 0
const s_mp_karatsuba_mul = 0
const s_mp_karatsuba_sqr = 0
const s_mp_mul_digs = 0
const s_mp_mul_digs_fast = 0
const s_mp_reverse = 0
const s_mp_sqr = 0
const s_mp_sqr_fast = 0
const s_mp_sub = 0
const s_mp_toom_mul = 0
const s_mp_toom_sqr = 0

type Tmp_digit = uint32

type Tprivate_mp_word = uint64

type Tmp_sign = int32

type Tmp_ord = int32

type Tmp_bool = int32

type Tmp_err = int32

type Tmp_order = int32

type Tmp_endian = int32

type Tmp_int = struct {
	Fused  int32
	Falloc int32
	Fsign  Tmp_sign
	Fdp    uintptr
}

type Tmp_int1 = struct {
	Fused  int32
	Falloc int32
	Fsign  Tmp_sign
	Fdp    uintptr
}

type TTclTomMathStubs = struct {
	Fmagic                int32
	Fhooks                uintptr
	FtclBN_epoch          uintptr
	FtclBN_revision       uintptr
	FtclBN_mp_add         uintptr
	FtclBN_mp_add_d       uintptr
	FtclBN_mp_and         uintptr
	FtclBN_mp_clamp       uintptr
	FtclBN_mp_clear       uintptr
	FtclBN_mp_clear_multi uintptr
	FtclBN_mp_cmp         uintptr
	FtclBN_mp_cmp_d       uintptr
	FtclBN_mp_cmp_mag     uintptr
	FtclBN_mp_copy        uintptr
	FtclBN_mp_count_bits  uintptr
	FtclBN_mp_div         uintptr
	FtclBN_mp_div_d       uintptr
	FtclBN_mp_div_2       uintptr
	FtclBN_mp_div_2d      uintptr
	Freserved17           uintptr
	FtclBN_mp_exch        uintptr
	FtclBN_mp_expt_n      uintptr
	FtclBN_mp_grow        uintptr
	FtclBN_mp_init        uintptr
	FtclBN_mp_init_copy   uintptr
	FtclBN_mp_init_multi  uintptr
	FtclBN_mp_init_set    uintptr
	FtclBN_mp_init_size   uintptr
	FtclBN_mp_lshd        uintptr
	FtclBN_mp_mod         uintptr
	FtclBN_mp_mod_2d      uintptr
	FtclBN_mp_mul         uintptr
	FtclBN_mp_mul_d       uintptr
	FtclBN_mp_mul_2       uintptr
	FtclBN_mp_mul_2d      uintptr
	FtclBN_mp_neg         uintptr
	FtclBN_mp_or          uintptr
	FtclBN_mp_radix_size  uintptr
	FtclBN_mp_read_radix  uintptr
	FtclBN_mp_rshd        uintptr
	FtclBN_mp_shrink      uintptr
	Freserved39           uintptr
	Freserved40           uintptr
	FtclBN_mp_sqrt        uintptr
	FtclBN_mp_sub         uintptr
	FtclBN_mp_sub_d       uintptr
	Freserved44           uintptr
	Freserved45           uintptr
	Freserved46           uintptr
	FtclBN_mp_ubin_size   uintptr
	FtclBN_mp_xor         uintptr
	FtclBN_mp_zero        uintptr
	Freserved50           uintptr
	Freserved51           uintptr
	Freserved52           uintptr
	Freserved53           uintptr
	Freserved54           uintptr
	Freserved55           uintptr
	Freserved56           uintptr
	Freserved57           uintptr
	Freserved58           uintptr
	Freserved59           uintptr
	Freserved60           uintptr
	Freserved61           uintptr
	Freserved62           uintptr
	FtclBN_mp_cnt_lsb     uintptr
	Freserved64           uintptr
	FtclBN_mp_init_i64    uintptr
	FtclBN_mp_init_u64    uintptr
	Freserved67           uintptr
	FtclBN_mp_set_u64     uintptr
	FtclBN_mp_get_mag_u64 uintptr
	FtclBN_mp_set_i64     uintptr
	FtclBN_mp_unpack      uintptr
	FtclBN_mp_pack        uintptr
	Freserved73           uintptr
	Freserved74           uintptr
	Freserved75           uintptr
	FtclBN_mp_signed_rsh  uintptr
	FtclBN_mp_pack_count  uintptr
	FtclBN_mp_to_ubin     uintptr
	Freserved79           uintptr
	FtclBN_mp_to_radix    uintptr
}

/*
 * Determine whether we're using IEEE floating point
 */

/* Largest odd integer that can be represented exactly in a double */

/*
 * This is the script cancellation struct and hash table. The hash table is
 * used to keep track of the information necessary to process script
 * cancellation requests, including the original interp, asynchronous handler
 * tokens (created by Tcl_AsyncCreate), and the clientData and flags arguments
 * passed to Tcl_CancelEval on a per-interp basis. The cancelLock mutex is
 * used for protecting calls to Tcl_CancelEval as well as protecting access to
 * the hash table below.
 */

type TCancelInfo = struct {
	Finterp     uintptr
	Fasync      TTcl_AsyncHandler
	Fresult     uintptr
	Flength     TTcl_Size
	FclientData uintptr
	Fflags      int32
}

var _cancelTable TTcl_HashTable
var _cancelTableInitialized = int32(0) /* 0 means not yet initialized. */

var _cancelLock TTcl_Mutex

/*
 * Table used to map command implementation functions to a human-readable type
 * name, for [info type]. The keys in the table are function addresses, and
 * the values in the table are static char* containing strings in Tcl's
 * internal encoding (almost UTF-8).
 */

var _commandTypeTable TTcl_HashTable
var _commandTypeInit = int32(0)

var _commandTypeLock TTcl_Mutex

/*
 * Magical counts for the number of arguments accepted by a coroutine command
 * after particular kinds of [yield].
 */

/*
 * The following structure define the commands in the Tcl core.
 */

type TCmdInfo = struct {
	Fname        uintptr
	FobjProc     uintptr
	FcompileProc uintptr
	FnreProc     uintptr
	Fflags       int32
}

/* CMD_COMPILES_EXPANDED - Whether the compiler for this command can handle
 * expansion for itself rather than needing the generic layer to take care of
 * it for it. Defined in tclInt.h. */

/*
 * The following struct states that the command it talks about (a subcommand
 * of one of Tcl's built-in ensembles) is unsafe and must be hidden when an
 * interpreter is made safe. (TclHideUnsafeCommands accesses an array of these
 * structs.) Alas, we can't sensibly just store the information directly in
 * the commands.
 */

type TUnsafeEnsembleInfo = struct {
	FensembleNsName uintptr
	FcommandName    uintptr
}

/*
 * The built-in commands, and the functions that implement them:
 */

func _procObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	return XTcl_ProcObjCmd(tls, clientData, interp, int64(objc), objv)
}

var _builtInCmds = [90]TCmdInfo{
	0: {
		Fname:  __ccgo_ts + 2125,
		Fflags: int32(CMD_IS_SAFE),
	},
	1: {
		Fname:  __ccgo_ts + 5117,
		Fflags: int32(CMD_IS_SAFE),
	},
	2: {
		Fname:  __ccgo_ts + 5123,
		Fflags: int32(CMD_IS_SAFE),
	},
	3: {
		Fname:  __ccgo_ts + 5129,
		Fflags: int32(CMD_IS_SAFE),
	},
	4: {
		Fname:  __ccgo_ts + 2273,
		Fflags: int32(CMD_IS_SAFE),
	},
	5: {
		Fname:  __ccgo_ts + 5135,
		Fflags: int32(CMD_IS_SAFE),
	},
	6: {
		Fname:  __ccgo_ts + 5141,
		Fflags: int32(CMD_IS_SAFE),
	},
	7: {
		Fname:  __ccgo_ts + 5150,
		Fflags: int32(CMD_IS_SAFE),
	},
	8: {
		Fname:  __ccgo_ts + 5161,
		Fflags: int32(CMD_IS_SAFE),
	},
	9: {
		Fname:  __ccgo_ts + 5171,
		Fflags: int32(CMD_IS_SAFE),
	},
	10: {
		Fname:  __ccgo_ts + 5181,
		Fflags: int32(CMD_IS_SAFE),
	},
	11: {
		Fname:  __ccgo_ts + 2464,
		Fflags: int32(CMD_IS_SAFE),
	},
	12: {
		Fname:  __ccgo_ts + 2523,
		Fflags: int32(CMD_IS_SAFE),
	},
	13: {
		Fname:  __ccgo_ts + 5187,
		Fflags: int32(CMD_IS_SAFE),
	},
	14: {
		Fname:  __ccgo_ts + 5191,
		Fflags: int32(CMD_IS_SAFE),
	},
	15: {
		Fname:  __ccgo_ts + 5199,
		Fflags: int32(CMD_IS_SAFE),
	},
	16: {
		Fname:  __ccgo_ts + 5206,
		Fflags: int32(CMD_IS_SAFE),
	},
	17: {
		Fname:  __ccgo_ts + 5217,
		Fflags: int32(CMD_IS_SAFE),
	},
	18: {
		Fname:  __ccgo_ts + 5224,
		Fflags: int32(CMD_IS_SAFE),
	},
	19: {
		Fname:  __ccgo_ts + 2542,
		Fflags: int32(CMD_IS_SAFE),
	},
	20: {
		Fname:  __ccgo_ts + 5227,
		Fflags: int32(CMD_IS_SAFE),
	},
	21: {
		Fname:  __ccgo_ts + 2733,
		Fflags: int32(CMD_IS_SAFE),
	},
	22: {
		Fname:  __ccgo_ts + 5232,
		Fflags: int32(CMD_IS_SAFE),
	},
	23: {
		Fname:  __ccgo_ts + 5240,
		Fflags: int32(CMD_IS_SAFE),
	},
	24: {
		Fname:  __ccgo_ts + 5246,
		Fflags: int32(CMD_IS_SAFE),
	},
	25: {
		Fname:  __ccgo_ts + 5253,
		Fflags: int32(CMD_IS_SAFE),
	},
	26: {
		Fname:  __ccgo_ts + 2860,
		Fflags: libc.Int32FromInt32(CMD_IS_SAFE) | libc.Int32FromInt32(CMD_COMPILES_EXPANDED),
	},
	27: {
		Fname:  __ccgo_ts + 5261,
		Fflags: int32(CMD_IS_SAFE),
	},
	28: {
		Fname:  __ccgo_ts + 5269,
		Fflags: int32(CMD_IS_SAFE),
	},
	29: {
		Fname:  __ccgo_ts + 5274,
		Fflags: int32(CMD_IS_SAFE),
	},
	30: {
		Fname:  __ccgo_ts + 5279,
		Fflags: int32(CMD_IS_SAFE),
	},
	31: {
		Fname:  __ccgo_ts + 5286,
		Fflags: int32(CMD_IS_SAFE),
	},
	32: {
		Fname:  __ccgo_ts + 5294,
		Fflags: int32(CMD_IS_SAFE),
	},
	33: {
		Fname:  __ccgo_ts + 5302,
		Fflags: int32(CMD_IS_SAFE),
	},
	34: {
		Fname:  __ccgo_ts + 5311,
		Fflags: int32(CMD_IS_SAFE),
	},
	35: {
		Fname:  __ccgo_ts + 5320,
		Fflags: int32(CMD_IS_SAFE),
	},
	36: {
		Fname:  __ccgo_ts + 5328,
		Fflags: int32(CMD_IS_SAFE),
	},
	37: {
		Fname:  __ccgo_ts + 5333,
		Fflags: int32(CMD_IS_SAFE),
	},
	38: {
		Fname:  __ccgo_ts + 5338,
		Fflags: int32(CMD_IS_SAFE),
	},
	39: {
		Fname:  __ccgo_ts + 5344,
		Fflags: int32(CMD_IS_SAFE),
	},
	40: {
		Fname:  __ccgo_ts + 5352,
		Fflags: int32(CMD_IS_SAFE),
	},
	41: {
		Fname:  __ccgo_ts + 3092,
		Fflags: int32(CMD_IS_SAFE),
	},
	42: {
		Fname:  __ccgo_ts + 5357,
		Fflags: int32(CMD_IS_SAFE),
	},
	43: {
		Fname:  __ccgo_ts + 5364,
		Fflags: int32(CMD_IS_SAFE),
	},
	44: {
		Fname:  __ccgo_ts + 5371,
		Fflags: int32(CMD_IS_SAFE),
	},
	45: {
		Fname:  __ccgo_ts + 5378,
		Fflags: int32(CMD_IS_SAFE),
	},
	46: {
		Fname:  __ccgo_ts + 5383,
		Fflags: int32(CMD_IS_SAFE),
	},
	47: {
		Fname:  __ccgo_ts + 5387,
		Fflags: int32(CMD_IS_SAFE),
	},
	48: {
		Fname:  __ccgo_ts + 5393,
		Fflags: int32(CMD_IS_SAFE),
	},
	49: {
		Fname:  __ccgo_ts + 5399,
		Fflags: int32(CMD_IS_SAFE),
	},
	50: {
		Fname:  __ccgo_ts + 5406,
		Fflags: int32(CMD_IS_SAFE),
	},
	51: {
		Fname:  __ccgo_ts + 5415,
		Fflags: int32(CMD_IS_SAFE),
	},
	52: {
		Fname:  __ccgo_ts + 5421,
		Fflags: int32(CMD_IS_SAFE),
	},
	53: {
		Fname:  __ccgo_ts + 5427,
		Fflags: int32(CMD_IS_SAFE),
	},
	54: {
		Fname:  __ccgo_ts + 3450,
		Fflags: int32(CMD_IS_SAFE),
	},
	55: {
		Fname:  __ccgo_ts + 5431,
		Fflags: int32(CMD_IS_SAFE),
	},
	56: {
		Fname:  __ccgo_ts + 3496,
		Fflags: int32(CMD_IS_SAFE),
	},
	57: {
		Fname:  __ccgo_ts + 3502,
		Fflags: int32(CMD_IS_SAFE),
	},
	58: {
		Fname:  __ccgo_ts + 5439,
		Fflags: int32(CMD_IS_SAFE),
	},
	59: {
		Fname:  __ccgo_ts + 3522,
		Fflags: int32(CMD_IS_SAFE),
	},
	60: {
		Fname:  __ccgo_ts + 5445,
		Fflags: int32(CMD_IS_SAFE),
	},
	61: {
		Fname:  __ccgo_ts + 5453,
		Fflags: int32(CMD_IS_SAFE),
	},
	62: {
		Fname: __ccgo_ts + 5459,
	},
	63: {
		Fname:  __ccgo_ts + 5462,
		Fflags: int32(CMD_IS_SAFE),
	},
	64: {
		Fname:  __ccgo_ts + 5468,
		Fflags: int32(CMD_IS_SAFE),
	},
	65: {
		Fname: __ccgo_ts + 5472,
	},
	66: {
		Fname: __ccgo_ts + 5477,
	},
	67: {
		Fname:  __ccgo_ts + 5482,
		Fflags: int32(CMD_IS_SAFE),
	},
	68: {
		Fname: __ccgo_ts + 5491,
	},
	69: {
		Fname:  __ccgo_ts + 5502,
		Fflags: int32(CMD_IS_SAFE),
	},
	70: {
		Fname:  __ccgo_ts + 5508,
		Fflags: int32(CMD_IS_SAFE),
	},
	71: {
		Fname:  __ccgo_ts + 5518,
		Fflags: int32(CMD_IS_SAFE),
	},
	72: {
		Fname:  __ccgo_ts + 5524,
		Fflags: int32(CMD_IS_SAFE),
	},
	73: {
		Fname: __ccgo_ts + 5529,
	},
	74: {
		Fname: __ccgo_ts + 2927,
	},
	75: {
		Fname: __ccgo_ts + 5534,
	},
	76: {
		Fname:  __ccgo_ts + 5539,
		Fflags: int32(CMD_IS_SAFE),
	},
	77: {
		Fname:  __ccgo_ts + 5543,
		Fflags: int32(CMD_IS_SAFE),
	},
	78: {
		Fname: __ccgo_ts + 5548,
	},
	79: {
		Fname:  __ccgo_ts + 5552,
		Fflags: int32(CMD_IS_SAFE),
	},
	80: {
		Fname:  __ccgo_ts + 5557,
		Fflags: int32(CMD_IS_SAFE),
	},
	81: {
		Fname: __ccgo_ts + 5562,
	},
	82: {
		Fname: __ccgo_ts + 5569,
	},
	83: {
		Fname:  __ccgo_ts + 5576,
		Fflags: int32(CMD_IS_SAFE),
	},
	84: {
		Fname:  __ccgo_ts + 5581,
		Fflags: int32(CMD_IS_SAFE),
	},
	85: {
		Fname:  __ccgo_ts + 5586,
		Fflags: int32(CMD_IS_SAFE),
	},
	86: {
		Fname: __ccgo_ts + 5595,
	},
	87: {
		Fname:  __ccgo_ts + 5602,
		Fflags: int32(CMD_IS_SAFE),
	},
	88: {
		Fname:  __ccgo_ts + 5609,
		Fflags: int32(CMD_IS_SAFE),
	},
	89: {},
}

func init() {
	p := unsafe.Pointer(&_builtInCmds)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(XTcl_AppendObjCmd)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(XTclCompileAppendCmd)
	*(*uintptr)(unsafe.Add(p, 48)) = __ccgo_fp(XTcl_ApplyObjCmd)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(XTclNRApplyObjCmd)
	*(*uintptr)(unsafe.Add(p, 88)) = __ccgo_fp(XTcl_BreakObjCmd)
	*(*uintptr)(unsafe.Add(p, 96)) = __ccgo_fp(XTclCompileBreakCmd)
	*(*uintptr)(unsafe.Add(p, 128)) = __ccgo_fp(XTcl_CatchObjCmd)
	*(*uintptr)(unsafe.Add(p, 136)) = __ccgo_fp(XTclCompileCatchCmd)
	*(*uintptr)(unsafe.Add(p, 144)) = __ccgo_fp(XTclNRCatchObjCmd)
	*(*uintptr)(unsafe.Add(p, 168)) = __ccgo_fp(XTcl_ConcatObjCmd)
	*(*uintptr)(unsafe.Add(p, 176)) = __ccgo_fp(XTclCompileConcatCmd)
	*(*uintptr)(unsafe.Add(p, 208)) = __ccgo_fp(XTcl_ConstObjCmd)
	*(*uintptr)(unsafe.Add(p, 216)) = __ccgo_fp(XTclCompileConstCmd)
	*(*uintptr)(unsafe.Add(p, 248)) = __ccgo_fp(XTcl_ContinueObjCmd)
	*(*uintptr)(unsafe.Add(p, 256)) = __ccgo_fp(XTclCompileContinueCmd)
	*(*uintptr)(unsafe.Add(p, 304)) = __ccgo_fp(_TclNRCoroInjectObjCmd)
	*(*uintptr)(unsafe.Add(p, 344)) = __ccgo_fp(_TclNRCoroProbeObjCmd)
	*(*uintptr)(unsafe.Add(p, 384)) = __ccgo_fp(XTclNRCoroutineObjCmd)
	*(*uintptr)(unsafe.Add(p, 408)) = __ccgo_fp(XTcl_ErrorObjCmd)
	*(*uintptr)(unsafe.Add(p, 416)) = __ccgo_fp(XTclCompileErrorCmd)
	*(*uintptr)(unsafe.Add(p, 448)) = __ccgo_fp(XTcl_EvalObjCmd)
	*(*uintptr)(unsafe.Add(p, 464)) = __ccgo_fp(XTclNREvalObjCmd)
	*(*uintptr)(unsafe.Add(p, 488)) = __ccgo_fp(XTcl_ExprObjCmd)
	*(*uintptr)(unsafe.Add(p, 496)) = __ccgo_fp(XTclCompileExprCmd)
	*(*uintptr)(unsafe.Add(p, 504)) = __ccgo_fp(XTclNRExprObjCmd)
	*(*uintptr)(unsafe.Add(p, 528)) = __ccgo_fp(XTcl_ForObjCmd)
	*(*uintptr)(unsafe.Add(p, 536)) = __ccgo_fp(XTclCompileForCmd)
	*(*uintptr)(unsafe.Add(p, 544)) = __ccgo_fp(XTclNRForObjCmd)
	*(*uintptr)(unsafe.Add(p, 568)) = __ccgo_fp(XTcl_ForeachObjCmd)
	*(*uintptr)(unsafe.Add(p, 576)) = __ccgo_fp(XTclCompileForeachCmd)
	*(*uintptr)(unsafe.Add(p, 584)) = __ccgo_fp(XTclNRForeachCmd)
	*(*uintptr)(unsafe.Add(p, 608)) = __ccgo_fp(XTcl_FormatObjCmd)
	*(*uintptr)(unsafe.Add(p, 616)) = __ccgo_fp(XTclCompileFormatCmd)
	*(*uintptr)(unsafe.Add(p, 648)) = __ccgo_fp(_FloatClassifyObjCmd)
	*(*uintptr)(unsafe.Add(p, 688)) = __ccgo_fp(XTcl_GlobalObjCmd)
	*(*uintptr)(unsafe.Add(p, 696)) = __ccgo_fp(XTclCompileGlobalCmd)
	*(*uintptr)(unsafe.Add(p, 728)) = __ccgo_fp(XTcl_IfObjCmd)
	*(*uintptr)(unsafe.Add(p, 736)) = __ccgo_fp(XTclCompileIfCmd)
	*(*uintptr)(unsafe.Add(p, 744)) = __ccgo_fp(XTclNRIfObjCmd)
	*(*uintptr)(unsafe.Add(p, 768)) = __ccgo_fp(XTcl_IncrObjCmd)
	*(*uintptr)(unsafe.Add(p, 776)) = __ccgo_fp(XTclCompileIncrCmd)
	*(*uintptr)(unsafe.Add(p, 808)) = __ccgo_fp(XTcl_JoinObjCmd)
	*(*uintptr)(unsafe.Add(p, 848)) = __ccgo_fp(XTcl_LappendObjCmd)
	*(*uintptr)(unsafe.Add(p, 856)) = __ccgo_fp(XTclCompileLappendCmd)
	*(*uintptr)(unsafe.Add(p, 888)) = __ccgo_fp(XTcl_LassignObjCmd)
	*(*uintptr)(unsafe.Add(p, 896)) = __ccgo_fp(XTclCompileLassignCmd)
	*(*uintptr)(unsafe.Add(p, 928)) = __ccgo_fp(XTcl_LeditObjCmd)
	*(*uintptr)(unsafe.Add(p, 968)) = __ccgo_fp(XTcl_LindexObjCmd)
	*(*uintptr)(unsafe.Add(p, 976)) = __ccgo_fp(XTclCompileLindexCmd)
	*(*uintptr)(unsafe.Add(p, 1008)) = __ccgo_fp(XTcl_LinsertObjCmd)
	*(*uintptr)(unsafe.Add(p, 1016)) = __ccgo_fp(XTclCompileLinsertCmd)
	*(*uintptr)(unsafe.Add(p, 1048)) = __ccgo_fp(XTcl_ListObjCmd)
	*(*uintptr)(unsafe.Add(p, 1056)) = __ccgo_fp(XTclCompileListCmd)
	*(*uintptr)(unsafe.Add(p, 1088)) = __ccgo_fp(XTcl_LlengthObjCmd)
	*(*uintptr)(unsafe.Add(p, 1096)) = __ccgo_fp(XTclCompileLlengthCmd)
	*(*uintptr)(unsafe.Add(p, 1128)) = __ccgo_fp(XTcl_LmapObjCmd)
	*(*uintptr)(unsafe.Add(p, 1136)) = __ccgo_fp(XTclCompileLmapCmd)
	*(*uintptr)(unsafe.Add(p, 1144)) = __ccgo_fp(XTclNRLmapCmd)
	*(*uintptr)(unsafe.Add(p, 1168)) = __ccgo_fp(XTcl_LpopObjCmd)
	*(*uintptr)(unsafe.Add(p, 1208)) = __ccgo_fp(XTcl_LrangeObjCmd)
	*(*uintptr)(unsafe.Add(p, 1216)) = __ccgo_fp(XTclCompileLrangeCmd)
	*(*uintptr)(unsafe.Add(p, 1248)) = __ccgo_fp(XTcl_LremoveObjCmd)
	*(*uintptr)(unsafe.Add(p, 1288)) = __ccgo_fp(XTcl_LrepeatObjCmd)
	*(*uintptr)(unsafe.Add(p, 1328)) = __ccgo_fp(XTcl_LreplaceObjCmd)
	*(*uintptr)(unsafe.Add(p, 1336)) = __ccgo_fp(XTclCompileLreplaceCmd)
	*(*uintptr)(unsafe.Add(p, 1368)) = __ccgo_fp(XTcl_LreverseObjCmd)
	*(*uintptr)(unsafe.Add(p, 1408)) = __ccgo_fp(XTcl_LsearchObjCmd)
	*(*uintptr)(unsafe.Add(p, 1448)) = __ccgo_fp(XTcl_LseqObjCmd)
	*(*uintptr)(unsafe.Add(p, 1488)) = __ccgo_fp(XTcl_LsetObjCmd)
	*(*uintptr)(unsafe.Add(p, 1496)) = __ccgo_fp(XTclCompileLsetCmd)
	*(*uintptr)(unsafe.Add(p, 1528)) = __ccgo_fp(XTcl_LsortObjCmd)
	*(*uintptr)(unsafe.Add(p, 1568)) = __ccgo_fp(XTcl_PackageObjCmd)
	*(*uintptr)(unsafe.Add(p, 1584)) = __ccgo_fp(XTclNRPackageObjCmd)
	*(*uintptr)(unsafe.Add(p, 1608)) = __ccgo_fp(_procObjCmd)
	*(*uintptr)(unsafe.Add(p, 1648)) = __ccgo_fp(XTcl_RegexpObjCmd)
	*(*uintptr)(unsafe.Add(p, 1656)) = __ccgo_fp(XTclCompileRegexpCmd)
	*(*uintptr)(unsafe.Add(p, 1688)) = __ccgo_fp(XTcl_RegsubObjCmd)
	*(*uintptr)(unsafe.Add(p, 1696)) = __ccgo_fp(XTclCompileRegsubCmd)
	*(*uintptr)(unsafe.Add(p, 1728)) = __ccgo_fp(XTcl_RenameObjCmd)
	*(*uintptr)(unsafe.Add(p, 1768)) = __ccgo_fp(XTcl_ReturnObjCmd)
	*(*uintptr)(unsafe.Add(p, 1776)) = __ccgo_fp(XTclCompileReturnCmd)
	*(*uintptr)(unsafe.Add(p, 1808)) = __ccgo_fp(XTcl_ScanObjCmd)
	*(*uintptr)(unsafe.Add(p, 1848)) = __ccgo_fp(XTcl_SetObjCmd)
	*(*uintptr)(unsafe.Add(p, 1856)) = __ccgo_fp(XTclCompileSetCmd)
	*(*uintptr)(unsafe.Add(p, 1888)) = __ccgo_fp(XTcl_SplitObjCmd)
	*(*uintptr)(unsafe.Add(p, 1928)) = __ccgo_fp(XTcl_SubstObjCmd)
	*(*uintptr)(unsafe.Add(p, 1936)) = __ccgo_fp(XTclCompileSubstCmd)
	*(*uintptr)(unsafe.Add(p, 1944)) = __ccgo_fp(XTclNRSubstObjCmd)
	*(*uintptr)(unsafe.Add(p, 1968)) = __ccgo_fp(XTcl_SwitchObjCmd)
	*(*uintptr)(unsafe.Add(p, 1976)) = __ccgo_fp(XTclCompileSwitchCmd)
	*(*uintptr)(unsafe.Add(p, 1984)) = __ccgo_fp(XTclNRSwitchObjCmd)
	*(*uintptr)(unsafe.Add(p, 2016)) = __ccgo_fp(XTclCompileTailcallCmd)
	*(*uintptr)(unsafe.Add(p, 2024)) = __ccgo_fp(XTclNRTailcallObjCmd)
	*(*uintptr)(unsafe.Add(p, 2048)) = __ccgo_fp(XTcl_ThrowObjCmd)
	*(*uintptr)(unsafe.Add(p, 2056)) = __ccgo_fp(XTclCompileThrowCmd)
	*(*uintptr)(unsafe.Add(p, 2088)) = __ccgo_fp(XTcl_TraceObjCmd)
	*(*uintptr)(unsafe.Add(p, 2128)) = __ccgo_fp(XTcl_TryObjCmd)
	*(*uintptr)(unsafe.Add(p, 2136)) = __ccgo_fp(XTclCompileTryCmd)
	*(*uintptr)(unsafe.Add(p, 2144)) = __ccgo_fp(XTclNRTryObjCmd)
	*(*uintptr)(unsafe.Add(p, 2168)) = __ccgo_fp(XTcl_UnsetObjCmd)
	*(*uintptr)(unsafe.Add(p, 2176)) = __ccgo_fp(XTclCompileUnsetCmd)
	*(*uintptr)(unsafe.Add(p, 2208)) = __ccgo_fp(XTcl_UplevelObjCmd)
	*(*uintptr)(unsafe.Add(p, 2224)) = __ccgo_fp(XTclNRUplevelObjCmd)
	*(*uintptr)(unsafe.Add(p, 2248)) = __ccgo_fp(XTcl_UpvarObjCmd)
	*(*uintptr)(unsafe.Add(p, 2256)) = __ccgo_fp(XTclCompileUpvarCmd)
	*(*uintptr)(unsafe.Add(p, 2288)) = __ccgo_fp(XTcl_VariableObjCmd)
	*(*uintptr)(unsafe.Add(p, 2296)) = __ccgo_fp(XTclCompileVariableCmd)
	*(*uintptr)(unsafe.Add(p, 2328)) = __ccgo_fp(XTcl_WhileObjCmd)
	*(*uintptr)(unsafe.Add(p, 2336)) = __ccgo_fp(XTclCompileWhileCmd)
	*(*uintptr)(unsafe.Add(p, 2344)) = __ccgo_fp(XTclNRWhileObjCmd)
	*(*uintptr)(unsafe.Add(p, 2376)) = __ccgo_fp(XTclCompileYieldCmd)
	*(*uintptr)(unsafe.Add(p, 2384)) = __ccgo_fp(XTclNRYieldObjCmd)
	*(*uintptr)(unsafe.Add(p, 2416)) = __ccgo_fp(XTclCompileYieldToCmd)
	*(*uintptr)(unsafe.Add(p, 2424)) = __ccgo_fp(XTclNRYieldToObjCmd)
	*(*uintptr)(unsafe.Add(p, 2448)) = __ccgo_fp(XTcl_AfterObjCmd)
	*(*uintptr)(unsafe.Add(p, 2488)) = __ccgo_fp(XTcl_CdObjCmd)
	*(*uintptr)(unsafe.Add(p, 2528)) = __ccgo_fp(XTcl_CloseObjCmd)
	*(*uintptr)(unsafe.Add(p, 2568)) = __ccgo_fp(XTcl_EofObjCmd)
	*(*uintptr)(unsafe.Add(p, 2608)) = __ccgo_fp(XTcl_ExecObjCmd)
	*(*uintptr)(unsafe.Add(p, 2648)) = __ccgo_fp(XTcl_ExitObjCmd)
	*(*uintptr)(unsafe.Add(p, 2688)) = __ccgo_fp(XTcl_FblockedObjCmd)
	*(*uintptr)(unsafe.Add(p, 2728)) = __ccgo_fp(XTcl_FconfigureObjCmd)
	*(*uintptr)(unsafe.Add(p, 2768)) = __ccgo_fp(XTcl_FcopyObjCmd)
	*(*uintptr)(unsafe.Add(p, 2808)) = __ccgo_fp(XTcl_FileEventObjCmd)
	*(*uintptr)(unsafe.Add(p, 2848)) = __ccgo_fp(XTcl_FlushObjCmd)
	*(*uintptr)(unsafe.Add(p, 2888)) = __ccgo_fp(XTcl_GetsObjCmd)
	*(*uintptr)(unsafe.Add(p, 2928)) = __ccgo_fp(XTcl_GlobObjCmd)
	*(*uintptr)(unsafe.Add(p, 2968)) = __ccgo_fp(XTcl_LoadObjCmd)
	*(*uintptr)(unsafe.Add(p, 3008)) = __ccgo_fp(XTcl_OpenObjCmd)
	*(*uintptr)(unsafe.Add(p, 3048)) = __ccgo_fp(XTcl_PidObjCmd)
	*(*uintptr)(unsafe.Add(p, 3088)) = __ccgo_fp(XTcl_PutsObjCmd)
	*(*uintptr)(unsafe.Add(p, 3128)) = __ccgo_fp(XTcl_PwdObjCmd)
	*(*uintptr)(unsafe.Add(p, 3168)) = __ccgo_fp(XTcl_ReadObjCmd)
	*(*uintptr)(unsafe.Add(p, 3208)) = __ccgo_fp(XTcl_SeekObjCmd)
	*(*uintptr)(unsafe.Add(p, 3248)) = __ccgo_fp(XTcl_SocketObjCmd)
	*(*uintptr)(unsafe.Add(p, 3288)) = __ccgo_fp(XTcl_SourceObjCmd)
	*(*uintptr)(unsafe.Add(p, 3304)) = __ccgo_fp(XTclNRSourceObjCmd)
	*(*uintptr)(unsafe.Add(p, 3328)) = __ccgo_fp(XTcl_TellObjCmd)
	*(*uintptr)(unsafe.Add(p, 3368)) = __ccgo_fp(XTcl_TimeObjCmd)
	*(*uintptr)(unsafe.Add(p, 3408)) = __ccgo_fp(XTcl_TimeRateObjCmd)
	*(*uintptr)(unsafe.Add(p, 3448)) = __ccgo_fp(XTcl_UnloadObjCmd)
	*(*uintptr)(unsafe.Add(p, 3488)) = __ccgo_fp(XTcl_UpdateObjCmd)
	*(*uintptr)(unsafe.Add(p, 3528)) = __ccgo_fp(XTcl_VwaitObjCmd)
}

/*
 * Information about which pieces of ensembles to hide when making an
 * interpreter safe:
 */

var _unsafeEnsembleCommands = [56]TUnsafeEnsembleInfo{
	0: {
		FensembleNsName: __ccgo_ts + 5615,
	},
	1: {
		FensembleNsName: __ccgo_ts + 5615,
		FcommandName:    __ccgo_ts + 5624,
	},
	2: {
		FensembleNsName: __ccgo_ts + 5615,
		FcommandName:    __ccgo_ts + 5629,
	},
	3: {
		FensembleNsName: __ccgo_ts + 5636,
	},
	4: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5641,
	},
	5: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5647,
	},
	6: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5658,
	},
	7: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5663,
	},
	8: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5670,
	},
	9: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5678,
	},
	10: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5689,
	},
	11: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5696,
	},
	12: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5706,
	},
	13: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5711,
	},
	14: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5723,
	},
	15: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5730,
	},
	16: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5735,
	},
	17: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5741,
	},
	18: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5747,
	},
	19: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5753,
	},
	20: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5764,
	},
	21: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5774,
	},
	22: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5780,
	},
	23: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5789,
	},
	24: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5364,
	},
	25: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5798,
	},
	26: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5807,
	},
	27: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5812,
	},
	28: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5817,
	},
	29: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5822,
	},
	30: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5830,
	},
	31: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5839,
	},
	32: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5851,
	},
	33: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5856,
	},
	34: {
		FensembleNsName: __ccgo_ts + 5636,
		FcommandName:    __ccgo_ts + 5864,
	},
	35: {
		FensembleNsName: __ccgo_ts + 5873,
		FcommandName:    __ccgo_ts + 5878,
	},
	36: {
		FensembleNsName: __ccgo_ts + 5873,
		FcommandName:    __ccgo_ts + 5886,
	},
	37: {
		FensembleNsName: __ccgo_ts + 5903,
		FcommandName:    __ccgo_ts + 2860,
	},
	38: {
		FensembleNsName: __ccgo_ts + 5903,
		FcommandName:    __ccgo_ts + 5911,
	},
	39: {
		FensembleNsName: __ccgo_ts + 5903,
		FcommandName:    __ccgo_ts + 5918,
	},
	40: {
		FensembleNsName: __ccgo_ts + 5903,
		FcommandName:    __ccgo_ts + 5924,
	},
	41: {
		FensembleNsName: __ccgo_ts + 5934,
	},
	42: {
		FensembleNsName: __ccgo_ts + 5934,
		FcommandName:    __ccgo_ts + 5940,
	},
	43: {
		FensembleNsName: __ccgo_ts + 5934,
		FcommandName:    __ccgo_ts + 5689,
	},
	44: {
		FensembleNsName: __ccgo_ts + 5934,
		FcommandName:    __ccgo_ts + 5873,
	},
	45: {
		FensembleNsName: __ccgo_ts + 5934,
		FcommandName:    __ccgo_ts + 2860,
	},
	46: {
		FensembleNsName: __ccgo_ts + 5934,
		FcommandName:    __ccgo_ts + 5950,
	},
	47: {
		FensembleNsName: __ccgo_ts + 5934,
		FcommandName:    __ccgo_ts + 5957,
	},
	48: {
		FensembleNsName: __ccgo_ts + 5934,
		FcommandName:    __ccgo_ts + 5964,
	},
	49: {
		FensembleNsName: __ccgo_ts + 5934,
		FcommandName:    __ccgo_ts + 5970,
	},
	50: {
		FensembleNsName: __ccgo_ts + 5934,
		FcommandName:    __ccgo_ts + 5976,
	},
	51: {
		FensembleNsName: __ccgo_ts + 5934,
		FcommandName:    __ccgo_ts + 5982,
	},
	52: {
		FensembleNsName: __ccgo_ts + 5934,
		FcommandName:    __ccgo_ts + 5988,
	},
	53: {
		FensembleNsName: __ccgo_ts + 5934,
		FcommandName:    __ccgo_ts + 5998,
	},
	54: {
		FensembleNsName: __ccgo_ts + 5934,
		FcommandName:    __ccgo_ts + 6003,
	},
	55: {},
}

type TBuiltinFuncDef = struct {
	Fname       uintptr
	FobjCmdProc uintptr
	Ffn         uintptr
}

var _BuiltinFuncTable = [38]TBuiltinFuncDef{
	0: {
		Fname: __ccgo_ts + 6011,
	},
	1: {
		Fname: __ccgo_ts + 6015,
	},
	2: {
		Fname: __ccgo_ts + 6020,
	},
	3: {
		Fname: __ccgo_ts + 6025,
	},
	4: {
		Fname: __ccgo_ts + 6030,
	},
	5: {
		Fname: __ccgo_ts + 6036,
	},
	6: {
		Fname: __ccgo_ts + 6041,
	},
	7: {
		Fname: __ccgo_ts + 6046,
	},
	8: {
		Fname: __ccgo_ts + 6050,
	},
	9: {
		Fname: __ccgo_ts + 6055,
	},
	10: {
		Fname: __ccgo_ts + 6062,
	},
	11: {
		Fname: __ccgo_ts + 6069,
	},
	12: {
		Fname: __ccgo_ts + 6073,
	},
	13: {
		Fname: __ccgo_ts + 6079,
	},
	14: {
		Fname: __ccgo_ts + 6084,
	},
	15: {
		Fname: __ccgo_ts + 6090,
	},
	16: {
		Fname: __ccgo_ts + 6094,
	},
	17: {
		Fname: __ccgo_ts + 6103,
	},
	18: {
		Fname: __ccgo_ts + 6109,
	},
	19: {
		Fname: __ccgo_ts + 6115,
	},
	20: {
		Fname: __ccgo_ts + 6124,
	},
	21: {
		Fname: __ccgo_ts + 6130,
	},
	22: {
		Fname: __ccgo_ts + 6142,
	},
	23: {
		Fname: __ccgo_ts + 6154,
	},
	24: {
		Fname: __ccgo_ts + 6158,
	},
	25: {
		Fname: __ccgo_ts + 6164,
	},
	26: {
		Fname: __ccgo_ts + 6168,
	},
	27: {
		Fname: __ccgo_ts + 6172,
	},
	28: {
		Fname: __ccgo_ts + 6176,
	},
	29: {
		Fname: __ccgo_ts + 6181,
	},
	30: {
		Fname: __ccgo_ts + 6187,
	},
	31: {
		Fname: __ccgo_ts + 6191,
	},
	32: {
		Fname: __ccgo_ts + 6196,
	},
	33: {
		Fname: __ccgo_ts + 6201,
	},
	34: {
		Fname: __ccgo_ts + 6207,
	},
	35: {
		Fname: __ccgo_ts + 6211,
	},
	36: {
		Fname: __ccgo_ts + 6216,
	},
	37: {},
}

func init() {
	p := unsafe.Pointer(&_BuiltinFuncTable)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_ExprAbsFunc)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_ExprUnaryFunc)
	*(*uintptr)(unsafe.Add(p, 40)) = __ccgo_fp(libc.Xacos)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(_ExprUnaryFunc)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(libc.Xasin)
	*(*uintptr)(unsafe.Add(p, 80)) = __ccgo_fp(_ExprUnaryFunc)
	*(*uintptr)(unsafe.Add(p, 88)) = __ccgo_fp(libc.Xatan)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(_ExprBinaryFunc)
	*(*uintptr)(unsafe.Add(p, 112)) = __ccgo_fp(libc.Xatan2)
	*(*uintptr)(unsafe.Add(p, 128)) = __ccgo_fp(_ExprBoolFunc)
	*(*uintptr)(unsafe.Add(p, 152)) = __ccgo_fp(_ExprCeilFunc)
	*(*uintptr)(unsafe.Add(p, 176)) = __ccgo_fp(_ExprUnaryFunc)
	*(*uintptr)(unsafe.Add(p, 184)) = __ccgo_fp(libc.Xcos)
	*(*uintptr)(unsafe.Add(p, 200)) = __ccgo_fp(_ExprUnaryFunc)
	*(*uintptr)(unsafe.Add(p, 208)) = __ccgo_fp(libc.Xcosh)
	*(*uintptr)(unsafe.Add(p, 224)) = __ccgo_fp(_ExprDoubleFunc)
	*(*uintptr)(unsafe.Add(p, 248)) = __ccgo_fp(_ExprIntFunc)
	*(*uintptr)(unsafe.Add(p, 272)) = __ccgo_fp(_ExprUnaryFunc)
	*(*uintptr)(unsafe.Add(p, 280)) = __ccgo_fp(libc.Xexp)
	*(*uintptr)(unsafe.Add(p, 296)) = __ccgo_fp(_ExprFloorFunc)
	*(*uintptr)(unsafe.Add(p, 320)) = __ccgo_fp(_ExprBinaryFunc)
	*(*uintptr)(unsafe.Add(p, 328)) = __ccgo_fp(libc.Xfmod)
	*(*uintptr)(unsafe.Add(p, 344)) = __ccgo_fp(_ExprBinaryFunc)
	*(*uintptr)(unsafe.Add(p, 352)) = __ccgo_fp(libc.Xhypot)
	*(*uintptr)(unsafe.Add(p, 368)) = __ccgo_fp(_ExprIntFunc)
	*(*uintptr)(unsafe.Add(p, 392)) = __ccgo_fp(_ExprIsFiniteFunc)
	*(*uintptr)(unsafe.Add(p, 416)) = __ccgo_fp(_ExprIsInfinityFunc)
	*(*uintptr)(unsafe.Add(p, 440)) = __ccgo_fp(_ExprIsNaNFunc)
	*(*uintptr)(unsafe.Add(p, 464)) = __ccgo_fp(_ExprIsNormalFunc)
	*(*uintptr)(unsafe.Add(p, 488)) = __ccgo_fp(_ExprIsqrtFunc)
	*(*uintptr)(unsafe.Add(p, 512)) = __ccgo_fp(_ExprIsSubnormalFunc)
	*(*uintptr)(unsafe.Add(p, 536)) = __ccgo_fp(_ExprIsUnorderedFunc)
	*(*uintptr)(unsafe.Add(p, 560)) = __ccgo_fp(_ExprUnaryFunc)
	*(*uintptr)(unsafe.Add(p, 568)) = __ccgo_fp(libc.Xlog)
	*(*uintptr)(unsafe.Add(p, 584)) = __ccgo_fp(_ExprUnaryFunc)
	*(*uintptr)(unsafe.Add(p, 592)) = __ccgo_fp(libc.Xlog10)
	*(*uintptr)(unsafe.Add(p, 608)) = __ccgo_fp(_ExprMaxFunc)
	*(*uintptr)(unsafe.Add(p, 632)) = __ccgo_fp(_ExprMinFunc)
	*(*uintptr)(unsafe.Add(p, 656)) = __ccgo_fp(_ExprBinaryFunc)
	*(*uintptr)(unsafe.Add(p, 664)) = __ccgo_fp(libc.Xpow)
	*(*uintptr)(unsafe.Add(p, 680)) = __ccgo_fp(_ExprRandFunc)
	*(*uintptr)(unsafe.Add(p, 704)) = __ccgo_fp(_ExprRoundFunc)
	*(*uintptr)(unsafe.Add(p, 728)) = __ccgo_fp(_ExprUnaryFunc)
	*(*uintptr)(unsafe.Add(p, 736)) = __ccgo_fp(libc.Xsin)
	*(*uintptr)(unsafe.Add(p, 752)) = __ccgo_fp(_ExprUnaryFunc)
	*(*uintptr)(unsafe.Add(p, 760)) = __ccgo_fp(libc.Xsinh)
	*(*uintptr)(unsafe.Add(p, 776)) = __ccgo_fp(_ExprSqrtFunc)
	*(*uintptr)(unsafe.Add(p, 800)) = __ccgo_fp(_ExprSrandFunc)
	*(*uintptr)(unsafe.Add(p, 824)) = __ccgo_fp(_ExprUnaryFunc)
	*(*uintptr)(unsafe.Add(p, 832)) = __ccgo_fp(libc.Xtan)
	*(*uintptr)(unsafe.Add(p, 848)) = __ccgo_fp(_ExprUnaryFunc)
	*(*uintptr)(unsafe.Add(p, 856)) = __ccgo_fp(libc.Xtanh)
	*(*uintptr)(unsafe.Add(p, 872)) = __ccgo_fp(_ExprWideFunc)
}

/*
 * TIP#174's math operators. All are safe.
 */

type TOpCmdInfo = struct {
	Fname        uintptr
	FobjProc     uintptr
	FcompileProc uintptr
	Fi           struct {
		Fidentity [0]int32
		FnumArgs  int32
	}
	Fexpected uintptr
}

var _mathOpCmds = [28]TOpCmdInfo{
	0: {
		Fname: __ccgo_ts + 6221,
		Fi: *(*struct {
			Fidentity [0]int32
			FnumArgs  int32
		})(unsafe.Pointer(&struct{ f int32 }{f: int32(1)})),
		Fexpected: __ccgo_ts + 6223,
	},
	1: {
		Fname: __ccgo_ts + 6231,
		Fi: *(*struct {
			Fidentity [0]int32
			FnumArgs  int32
		})(unsafe.Pointer(&struct{ f int32 }{f: int32(1)})),
		Fexpected: __ccgo_ts + 3611,
	},
	2: {
		Fname: __ccgo_ts + 6233,
	},
	3: {
		Fname: __ccgo_ts + 6235,
		Fi: *(*struct {
			Fidentity [0]int32
			FnumArgs  int32
		})(unsafe.Pointer(&struct{ f int32 }{f: int32(1)})),
	},
	4: {
		Fname: __ccgo_ts + 6237,
		Fi: *(*struct {
			Fidentity [0]int32
			FnumArgs  int32
		})(unsafe.Pointer(&struct{ f int32 }{f: -int32(1)})),
	},
	5: {
		Fname: __ccgo_ts + 6239,
	},
	6: {
		Fname: __ccgo_ts + 6241,
	},
	7: {
		Fname: __ccgo_ts + 6243,
		Fi: *(*struct {
			Fidentity [0]int32
			FnumArgs  int32
		})(unsafe.Pointer(&struct{ f int32 }{f: int32(1)})),
	},
	8: {
		Fname: __ccgo_ts + 6246,
		Fi: *(*struct {
			Fidentity [0]int32
			FnumArgs  int32
		})(unsafe.Pointer(&struct{ f int32 }{f: int32(2)})),
		Fexpected: __ccgo_ts + 6249,
	},
	9: {
		Fname: __ccgo_ts + 6263,
		Fi: *(*struct {
			Fidentity [0]int32
			FnumArgs  int32
		})(unsafe.Pointer(&struct{ f int32 }{f: int32(2)})),
		Fexpected: __ccgo_ts + 6249,
	},
	10: {
		Fname: __ccgo_ts + 6266,
		Fi: *(*struct {
			Fidentity [0]int32
			FnumArgs  int32
		})(unsafe.Pointer(&struct{ f int32 }{f: int32(2)})),
		Fexpected: __ccgo_ts + 6268,
	},
	11: {
		Fname: __ccgo_ts + 6284,
		Fi: *(*struct {
			Fidentity [0]int32
			FnumArgs  int32
		})(unsafe.Pointer(&struct{ f int32 }{f: int32(2)})),
		Fexpected: __ccgo_ts + 6287,
	},
	12: {
		Fname: __ccgo_ts + 6299,
		Fi: *(*struct {
			Fidentity [0]int32
			FnumArgs  int32
		})(unsafe.Pointer(&struct{ f int32 }{f: int32(2)})),
		Fexpected: __ccgo_ts + 6287,
	},
	13: {
		Fname: __ccgo_ts + 6302,
		Fi: *(*struct {
			Fidentity [0]int32
			FnumArgs  int32
		})(unsafe.Pointer(&struct{ f int32 }{f: int32(2)})),
		Fexpected: __ccgo_ts + 6305,
	},
	14: {
		Fname: __ccgo_ts + 6316,
		Fi: *(*struct {
			Fidentity [0]int32
			FnumArgs  int32
		})(unsafe.Pointer(&struct{ f int32 }{f: int32(2)})),
		Fexpected: __ccgo_ts + 6305,
	},
	15: {
		Fname:     __ccgo_ts + 6319,
		Fexpected: __ccgo_ts + 6321,
	},
	16: {
		Fname:     __ccgo_ts + 6339,
		Fexpected: __ccgo_ts + 6321,
	},
	17: {
		Fname: __ccgo_ts + 6341,
	},
	18: {
		Fname: __ccgo_ts + 6343,
	},
	19: {
		Fname: __ccgo_ts + 6346,
	},
	20: {
		Fname: __ccgo_ts + 6348,
	},
	21: {
		Fname: __ccgo_ts + 6351,
	},
	22: {
		Fname: __ccgo_ts + 2461,
	},
	23: {
		Fname: __ccgo_ts + 2988,
	},
	24: {
		Fname: __ccgo_ts + 2845,
	},
	25: {
		Fname: __ccgo_ts + 2539,
	},
	26: {
		Fname: __ccgo_ts + 2536,
	},
	27: {},
}

func init() {
	p := unsafe.Pointer(&_mathOpCmds)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(XTclSingleOpCmd)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(XTclCompileInvertOpCmd)
	*(*uintptr)(unsafe.Add(p, 48)) = __ccgo_fp(XTclSingleOpCmd)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(XTclCompileNotOpCmd)
	*(*uintptr)(unsafe.Add(p, 88)) = __ccgo_fp(XTclVariadicOpCmd)
	*(*uintptr)(unsafe.Add(p, 96)) = __ccgo_fp(XTclCompileAddOpCmd)
	*(*uintptr)(unsafe.Add(p, 128)) = __ccgo_fp(XTclVariadicOpCmd)
	*(*uintptr)(unsafe.Add(p, 136)) = __ccgo_fp(XTclCompileMulOpCmd)
	*(*uintptr)(unsafe.Add(p, 168)) = __ccgo_fp(XTclVariadicOpCmd)
	*(*uintptr)(unsafe.Add(p, 176)) = __ccgo_fp(XTclCompileAndOpCmd)
	*(*uintptr)(unsafe.Add(p, 208)) = __ccgo_fp(XTclVariadicOpCmd)
	*(*uintptr)(unsafe.Add(p, 216)) = __ccgo_fp(XTclCompileOrOpCmd)
	*(*uintptr)(unsafe.Add(p, 248)) = __ccgo_fp(XTclVariadicOpCmd)
	*(*uintptr)(unsafe.Add(p, 256)) = __ccgo_fp(XTclCompileXorOpCmd)
	*(*uintptr)(unsafe.Add(p, 288)) = __ccgo_fp(XTclVariadicOpCmd)
	*(*uintptr)(unsafe.Add(p, 296)) = __ccgo_fp(XTclCompilePowOpCmd)
	*(*uintptr)(unsafe.Add(p, 328)) = __ccgo_fp(XTclSingleOpCmd)
	*(*uintptr)(unsafe.Add(p, 336)) = __ccgo_fp(XTclCompileLshiftOpCmd)
	*(*uintptr)(unsafe.Add(p, 368)) = __ccgo_fp(XTclSingleOpCmd)
	*(*uintptr)(unsafe.Add(p, 376)) = __ccgo_fp(XTclCompileRshiftOpCmd)
	*(*uintptr)(unsafe.Add(p, 408)) = __ccgo_fp(XTclSingleOpCmd)
	*(*uintptr)(unsafe.Add(p, 416)) = __ccgo_fp(XTclCompileModOpCmd)
	*(*uintptr)(unsafe.Add(p, 448)) = __ccgo_fp(XTclSingleOpCmd)
	*(*uintptr)(unsafe.Add(p, 456)) = __ccgo_fp(XTclCompileNeqOpCmd)
	*(*uintptr)(unsafe.Add(p, 488)) = __ccgo_fp(XTclSingleOpCmd)
	*(*uintptr)(unsafe.Add(p, 496)) = __ccgo_fp(XTclCompileStrneqOpCmd)
	*(*uintptr)(unsafe.Add(p, 528)) = __ccgo_fp(XTclSingleOpCmd)
	*(*uintptr)(unsafe.Add(p, 536)) = __ccgo_fp(XTclCompileInOpCmd)
	*(*uintptr)(unsafe.Add(p, 568)) = __ccgo_fp(XTclSingleOpCmd)
	*(*uintptr)(unsafe.Add(p, 576)) = __ccgo_fp(XTclCompileNiOpCmd)
	*(*uintptr)(unsafe.Add(p, 608)) = __ccgo_fp(XTclNoIdentOpCmd)
	*(*uintptr)(unsafe.Add(p, 616)) = __ccgo_fp(XTclCompileMinusOpCmd)
	*(*uintptr)(unsafe.Add(p, 648)) = __ccgo_fp(XTclNoIdentOpCmd)
	*(*uintptr)(unsafe.Add(p, 656)) = __ccgo_fp(XTclCompileDivOpCmd)
	*(*uintptr)(unsafe.Add(p, 688)) = __ccgo_fp(XTclSortingOpCmd)
	*(*uintptr)(unsafe.Add(p, 696)) = __ccgo_fp(XTclCompileLessOpCmd)
	*(*uintptr)(unsafe.Add(p, 728)) = __ccgo_fp(XTclSortingOpCmd)
	*(*uintptr)(unsafe.Add(p, 736)) = __ccgo_fp(XTclCompileLeqOpCmd)
	*(*uintptr)(unsafe.Add(p, 768)) = __ccgo_fp(XTclSortingOpCmd)
	*(*uintptr)(unsafe.Add(p, 776)) = __ccgo_fp(XTclCompileGreaterOpCmd)
	*(*uintptr)(unsafe.Add(p, 808)) = __ccgo_fp(XTclSortingOpCmd)
	*(*uintptr)(unsafe.Add(p, 816)) = __ccgo_fp(XTclCompileGeqOpCmd)
	*(*uintptr)(unsafe.Add(p, 848)) = __ccgo_fp(XTclSortingOpCmd)
	*(*uintptr)(unsafe.Add(p, 856)) = __ccgo_fp(XTclCompileEqOpCmd)
	*(*uintptr)(unsafe.Add(p, 888)) = __ccgo_fp(XTclSortingOpCmd)
	*(*uintptr)(unsafe.Add(p, 896)) = __ccgo_fp(XTclCompileStreqOpCmd)
	*(*uintptr)(unsafe.Add(p, 928)) = __ccgo_fp(XTclSortingOpCmd)
	*(*uintptr)(unsafe.Add(p, 936)) = __ccgo_fp(XTclCompileStrLtOpCmd)
	*(*uintptr)(unsafe.Add(p, 968)) = __ccgo_fp(XTclSortingOpCmd)
	*(*uintptr)(unsafe.Add(p, 976)) = __ccgo_fp(XTclCompileStrLeOpCmd)
	*(*uintptr)(unsafe.Add(p, 1008)) = __ccgo_fp(XTclSortingOpCmd)
	*(*uintptr)(unsafe.Add(p, 1016)) = __ccgo_fp(XTclCompileStrGtOpCmd)
	*(*uintptr)(unsafe.Add(p, 1048)) = __ccgo_fp(XTclSortingOpCmd)
	*(*uintptr)(unsafe.Add(p, 1056)) = __ccgo_fp(XTclCompileStrGeOpCmd)
}

/*
 *----------------------------------------------------------------------
 *
 * TclFinalizeEvaluation --
 *
 *	Finalizes the script cancellation hash table.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclFinalizeEvaluation(tls *libc.TLS) {
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_cancelLock)))
	if _cancelTableInitialized == int32(1) {
		XTcl_DeleteHashTable(tls, uintptr(unsafe.Pointer(&_cancelTable)))
		_cancelTableInitialized = 0
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_cancelLock)))
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_commandTypeLock)))
	if _commandTypeInit != 0 {
		XTcl_DeleteHashTable(tls, uintptr(unsafe.Pointer(&_commandTypeTable)))
		_commandTypeInit = 0
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_commandTypeLock)))
}

/*
 *----------------------------------------------------------------------
 *
 * buildInfoObjCmd --
 *
 *	Implements tcl::build-info command.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _buildInfoObjCmd2(tls *libc.TLS, clientData uintptr, interp uintptr, objc TTcl_Size, objv uintptr) (r1 int32) {
	bp := tls.Alloc(96)
	defer tls.Free(96) /* Argument objects. */
	var arg, buildData, p, q, r, v10, v11, v12, v13, v17, v18, v19, v21, v22, v7, v8, v9 uintptr
	var _ /* buf at bp+0 */ [80]uint8
	var _ /* idx at bp+88 */ int32
	var _ /* len at bp+80 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = arg, buildData, p, q, r, v10, v11, v12, v13, v17, v18, v19, v21, v22, v7, v8, v9
	buildData = clientData
	if objc > int64(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+6389)
		return int32(TCL_ERROR)
	} else {
		if objc < int64(2) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, buildData, int64(-libc.Int32FromInt32(1))))
			return TCL_OK
		}
	}
	/*
	 * Query for a specific piece of build info
	 */
	if XTcl_GetIndexFromObjStruct(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + 1*8)), uintptr(unsafe.Pointer(&_identifiers)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), libc.UintptrFromInt32(0), libc.Int32FromInt32(TCL_EXACT)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+88) != TCL_OK {
		*(*int32)(unsafe.Pointer(bp + 88)) = 4
	}
	switch *(*int32)(unsafe.Pointer(bp + 88)) {
	case 2:
		goto _1
	case 3:
		goto _2
	case 0:
		goto _3
	case 1:
		goto _4
	default:
		goto _5
	}
	goto _6
_1:
	;
	v7 = libc.Xstrchr(tls, buildData, int32('+'))
	p = v7
	if v7 != libc.UintptrFromInt32(0) {
		libc.Xmemcpy(tls, bp, buildData, libc.Uint64FromInt64(int64(p)-int64(buildData)))
		(*(*[80]uint8)(unsafe.Pointer(bp)))[int64(p)-int64(buildData)] = uint8('\000')
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, bp, int64(-libc.Int32FromInt32(1))))
	}
	return TCL_OK
_2:
	;
	v8 = libc.Xstrchr(tls, buildData, int32('.'))
	p = v8
	if v8 != libc.UintptrFromInt32(0) {
		v9 = p
		p++
		r = libc.Xstrchr(tls, v9, int32('+'))
		q = libc.Xstrchr(tls, p, int32('.'))
		if q < r {
			v10 = q
		} else {
			v10 = r
		}
		p = v10
	}
	if p != libc.UintptrFromInt32(0) {
		libc.Xmemcpy(tls, bp, buildData, libc.Uint64FromInt64(int64(p)-int64(buildData)))
		(*(*[80]uint8)(unsafe.Pointer(bp)))[int64(p)-int64(buildData)] = uint8('\000')
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, bp, int64(-libc.Int32FromInt32(1))))
	}
	return TCL_OK
_3:
	;
	v11 = libc.Xstrchr(tls, buildData, int32('+'))
	p = v11
	if v11 != libc.UintptrFromInt32(0) {
		v13 = p
		p++
		v12 = libc.Xstrchr(tls, v13, int32('.'))
		q = v12
		if v12 != libc.UintptrFromInt32(0) {
			libc.Xmemcpy(tls, bp, p, libc.Uint64FromInt64(int64(q)-int64(p)))
			(*(*[80]uint8)(unsafe.Pointer(bp)))[int64(q)-int64(p)] = uint8('\000')
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, bp, int64(-libc.Int32FromInt32(1))))
		} else {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, p, int64(-libc.Int32FromInt32(1))))
		}
	}
	return TCL_OK
_4:
	;
	p = libc.Xstrchr(tls, buildData, int32('.'))
_16:
	;
	v17 = p
	p++
	if !(v17 != 0) {
		goto _14
	}
	/*
	 * Does the word begin with one of the standard prefixes?
	 */
	if !(libc.Xstrncmp(tls, p, __ccgo_ts+6398, uint64(6)) != 0) || !(libc.Xstrncmp(tls, p, __ccgo_ts+6405, uint64(4)) != 0) || !(libc.Xstrncmp(tls, p, __ccgo_ts+6410, uint64(4)) != 0) || !(libc.Xstrncmp(tls, p, __ccgo_ts+6415, uint64(5)) != 0) {
		v18 = libc.Xstrchr(tls, p, int32('.'))
		q = v18
		if v18 != libc.UintptrFromInt32(0) {
			libc.Xmemcpy(tls, bp, p, libc.Uint64FromInt64(int64(q)-int64(p)))
			(*(*[80]uint8)(unsafe.Pointer(bp)))[int64(q)-int64(p)] = uint8('\000')
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, bp, int64(-libc.Int32FromInt32(1))))
		} else {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, p, int64(-libc.Int32FromInt32(1))))
		}
		return TCL_OK
	}
	goto _15
_15:
	;
	p = libc.Xstrchr(tls, p, int32('.'))
	goto _16
	goto _14
_14:
	;
	goto _6
_5:
	; /* Boolean test for other identifiers' presence */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 80)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Flength
		v19 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v19 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+80)
	}
	arg = v19
	p = libc.Xstrchr(tls, buildData, int32('.'))
	for {
		v21 = p
		p++
		if !(v21 != 0) {
			break
		}
		if !(libc.Xstrncmp(tls, p, arg, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 80)))) != 0) && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 80)))))) == int32('.') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 80)))))) == int32('-') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 80)))))) == int32('\000')) {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 80)))))) == int32('-') {
				p += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 80)))
				p++
				v22 = p
				q = libc.Xstrchr(tls, v22, int32('.'))
				if !(q != 0) {
					q = p + uintptr(libc.Xstrlen(tls, p))
				}
				libc.Xmemcpy(tls, bp, p, libc.Uint64FromInt64(int64(q)-int64(p)))
				(*(*[80]uint8)(unsafe.Pointer(bp)))[int64(q)-int64(p)] = uint8('\000')
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, bp, int64(-libc.Int32FromInt32(1))))
			} else {
				XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(int32(1) != 0)))
			}
			return TCL_OK
		}
		goto _20
	_20:
		;
		p = libc.Xstrchr(tls, p, int32('.'))
	}
_6:
	;
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(0 != 0)))
	return TCL_OK
}

var _identifiers = [5]uintptr{
	0: __ccgo_ts + 6354,
	1: __ccgo_ts + 6361,
	2: __ccgo_ts + 6370,
	3: __ccgo_ts + 6381,
	4: libc.UintptrFromInt32(0),
}

func _buildInfoObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	return _buildInfoObjCmd2(tls, clientData, interp, int64(objc), objv)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_CreateInterp --
 *
 *	Create a new TCL command interpreter.
 *
 * Results:
 *	The return value is a token for the interpreter, which may be used in
 *	calls to functions like Tcl_CreateCmd, Tcl_Eval, or Tcl_DeleteInterp.
 *
 * Side effects:
 *	The command interpreter is initialized with the built-in commands and
 *	with the variables documented in tclvars(n).
 *
 *----------------------------------------------------------------------
 */

func XTcl_CreateInterp(tls *libc.TLS) (r uintptr) {
	bp := tls.Alloc(144)
	defer tls.Free(144)
	var buildInfoCmd TTcl_Command
	var builtinFuncPtr, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cancelInfo, cmdInfoPtr, cmdPtr, framePtr, hPtr, iPtr, interp, nsPtr, occdPtr, opcmdInfoPtr, version, v12 uintptr
	var v1, v2, v3, v4, v5, v6, v7, v8 bool
	var _ /* info2 at bp+40 */ TTcl_CmdInfo
	var _ /* isNew at bp+0 */ int32
	var _ /* mathFuncName at bp+6 */ [32]uint8
	var _ /* order at bp+4 */ struct {
		Fs [0]int16
		Fc [2]uint8
	}
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = buildInfoCmd, builtinFuncPtr, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cancelInfo, cmdInfoPtr, cmdPtr, framePtr, hPtr, iPtr, interp, nsPtr, occdPtr, opcmdInfoPtr, version, v1, v12, v2, v3, v4, v5, v6, v7, v8
	version = XTcl_InitSubsystems(tls)
	/*
	 * Panic if someone updated the CallFrame structure without also updating
	 * the Tcl_CallFrame structure (or vice versa).
	 */
	if uint64(112) < uint64(112) {
		XTcl_Panic(tls, __ccgo_ts+6421, 0)
	}
	if _cancelTableInitialized == 0 {
		XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_cancelLock)))
		if _cancelTableInitialized == 0 {
			XTcl_InitHashTable(tls, uintptr(unsafe.Pointer(&_cancelTable)), int32(TCL_ONE_WORD_KEYS))
			_cancelTableInitialized = int32(1)
		}
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_cancelLock)))
	}
	if _commandTypeInit == 0 {
		XTclRegisterCommandTypeName(tls, __ccgo_fp(XTclObjInterpProc), __ccgo_ts+5352)
		XTclRegisterCommandTypeName(tls, __ccgo_fp(XTclEnsembleImplementationCmd), __ccgo_ts+6470)
		XTclRegisterCommandTypeName(tls, __ccgo_fp(XTclAliasObjCmd), __ccgo_ts+6479)
		XTclRegisterCommandTypeName(tls, __ccgo_fp(XTclLocalAliasObjCmd), __ccgo_ts+6479)
		XTclRegisterCommandTypeName(tls, __ccgo_fp(XTclChildObjCmd), __ccgo_ts+6485)
		XTclRegisterCommandTypeName(tls, __ccgo_fp(XTclInvokeImportedCmd), __ccgo_ts+6492)
		XTclRegisterCommandTypeName(tls, __ccgo_fp(XTclOOPublicObjectCmd), __ccgo_ts+6499)
		XTclRegisterCommandTypeName(tls, __ccgo_fp(XTclOOPrivateObjectCmd), __ccgo_ts+6506)
		XTclRegisterCommandTypeName(tls, __ccgo_fp(XTclOOMyClassObjCmd), __ccgo_ts+6520)
		XTclRegisterCommandTypeName(tls, __ccgo_fp(XTclNRInterpCoroutine), __ccgo_ts+5171)
	}
	/*
	 * Initialize support for namespaces and create the global namespace
	 * (whose name is ""; an alias is "::"). This also initializes the Tcl
	 * object type table and other object management code.
	 */
	iPtr = XTcl_Alloc(tls, uint64(1104))
	interp = iPtr
	(*TInterp)(unsafe.Pointer(iPtr)).FlegacyResult = libc.UintptrFromInt32(0)
	/* Special invalid value: Any attempt to free the legacy result
	 * will cause a crash. */
	(*TInterp)(unsafe.Pointer(iPtr)).FlegacyFreeProc = uintptr(-libc.Int32FromInt32(1))
	(*TInterp)(unsafe.Pointer(iPtr)).FerrorLine = 0
	(*TInterp)(unsafe.Pointer(iPtr)).FstubTable = uintptr(unsafe.Pointer(&XtclStubs))
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		(*TInterp)(unsafe.Pointer(iPtr)).FobjResultPtr = XTclThreadAllocObj(tls)
	} else {
		(*TInterp)(unsafe.Pointer(iPtr)).FobjResultPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FobjResultPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FobjResultPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FobjResultPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FobjResultPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FobjResultPtr)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FobjResultPtr)).FrefCount++
	(*TInterp)(unsafe.Pointer(iPtr)).Fhandle = XTclHandleCreate(tls, iPtr)
	(*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr = libc.UintptrFromInt32(0)
	(*TInterp)(unsafe.Pointer(iPtr)).FhiddenCmdTablePtr = libc.UintptrFromInt32(0)
	(*TInterp)(unsafe.Pointer(iPtr)).FinterpInfo = libc.UintptrFromInt32(0)
	(*TInterp)(unsafe.Pointer(iPtr)).Foptimizer = __ccgo_fp(XTclOptimizeBytecode)
	(*TInterp)(unsafe.Pointer(iPtr)).FnumLevels = 0
	(*TInterp)(unsafe.Pointer(iPtr)).FmaxNestingDepth = int64(MAX_NESTING_DEPTH)
	(*TInterp)(unsafe.Pointer(iPtr)).FframePtr = libc.UintptrFromInt32(0)    /* Initialise as soon as :: is available */
	(*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr = libc.UintptrFromInt32(0) /* Initialise as soon as :: is available */
	/*
	 * TIP #280 - Initialize the arrays used to extend the ByteCode and Proc
	 * structures.
	 */
	(*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr = libc.UintptrFromInt32(0)
	(*TInterp)(unsafe.Pointer(iPtr)).FlinePBodyPtr = XTcl_Alloc(tls, uint64(104))
	(*TInterp)(unsafe.Pointer(iPtr)).FlineBCPtr = XTcl_Alloc(tls, uint64(104))
	(*TInterp)(unsafe.Pointer(iPtr)).FlineLAPtr = XTcl_Alloc(tls, uint64(104))
	(*TInterp)(unsafe.Pointer(iPtr)).FlineLABCPtr = XTcl_Alloc(tls, uint64(104))
	XTcl_InitHashTable(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlinePBodyPtr, int32(TCL_ONE_WORD_KEYS))
	XTcl_InitHashTable(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlineBCPtr, int32(TCL_ONE_WORD_KEYS))
	XTcl_InitHashTable(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlineLAPtr, int32(TCL_ONE_WORD_KEYS))
	XTcl_InitHashTable(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlineLABCPtr, int32(TCL_ONE_WORD_KEYS))
	(*TInterp)(unsafe.Pointer(iPtr)).FscriptCLLocPtr = libc.UintptrFromInt32(0)
	(*TInterp)(unsafe.Pointer(iPtr)).FactiveVarTracePtr = libc.UintptrFromInt32(0)
	(*TInterp)(unsafe.Pointer(iPtr)).FreturnOpts = libc.UintptrFromInt32(0)
	(*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo = libc.UintptrFromInt32(0)
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		(*TInterp)(unsafe.Pointer(iPtr)).FeiVar = XTclThreadAllocObj(tls)
	} else {
		(*TInterp)(unsafe.Pointer(iPtr)).FeiVar = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FeiVar + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FeiVar)).FrefCount = 0
	if libc.Uint64FromInt64(12)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FeiVar)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FeiVar)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FeiVar)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(12)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FeiVar)).Fbytes, __ccgo_ts+6533, libc.Uint64FromInt64(12)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FeiVar)).Fbytes + uintptr(libc.Uint64FromInt64(12)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FeiVar)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(12) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FeiVar)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FeiVar)).FrefCount++
	(*TInterp)(unsafe.Pointer(iPtr)).FerrorStack = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FerrorStack)).FrefCount++
	(*TInterp)(unsafe.Pointer(iPtr)).FresetErrorStack = int32(1)
	if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
		cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
		(*TInterp)(unsafe.Pointer(iPtr)).FupLiteral = XTclThreadAllocObj(tls)
	} else {
		(*TInterp)(unsafe.Pointer(iPtr)).FupLiteral = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FupLiteral + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FupLiteral)).FrefCount = 0
	if libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FupLiteral)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FupLiteral)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FupLiteral)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FupLiteral)).Fbytes, __ccgo_ts+6545, libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FupLiteral)).Fbytes + uintptr(libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FupLiteral)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(3) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FupLiteral)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FupLiteral)).FrefCount++
	if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
		cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
		(*TInterp)(unsafe.Pointer(iPtr)).FcallLiteral = XTclThreadAllocObj(tls)
	} else {
		(*TInterp)(unsafe.Pointer(iPtr)).FcallLiteral = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FcallLiteral + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FcallLiteral)).FrefCount = 0
	if libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FcallLiteral)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FcallLiteral)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FcallLiteral)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FcallLiteral)).Fbytes, __ccgo_ts+6548, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FcallLiteral)).Fbytes + uintptr(libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FcallLiteral)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(5) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FcallLiteral)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FcallLiteral)).FrefCount++
	if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
		cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v5 || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == libc.Uint64FromInt32(0) {
		(*TInterp)(unsafe.Pointer(iPtr)).FinnerLiteral = XTclThreadAllocObj(tls)
	} else {
		(*TInterp)(unsafe.Pointer(iPtr)).FinnerLiteral = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FinnerLiteral + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FinnerLiteral)).FrefCount = 0
	if libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FinnerLiteral)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FinnerLiteral)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FinnerLiteral)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FinnerLiteral)).Fbytes, __ccgo_ts+6553, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FinnerLiteral)).Fbytes + uintptr(libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FinnerLiteral)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(6) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FinnerLiteral)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FinnerLiteral)).FrefCount++
	(*TInterp)(unsafe.Pointer(iPtr)).FinnerContext = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FinnerContext)).FrefCount++
	(*TInterp)(unsafe.Pointer(iPtr)).FerrorCode = libc.UintptrFromInt32(0)
	if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
		cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v6 || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == libc.Uint64FromInt32(0) {
		(*TInterp)(unsafe.Pointer(iPtr)).FecVar = XTclThreadAllocObj(tls)
	} else {
		(*TInterp)(unsafe.Pointer(iPtr)).FecVar = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FecVar + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FecVar)).FrefCount = 0
	if libc.Uint64FromInt64(12)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FecVar)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FecVar)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FecVar)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(12)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FecVar)).Fbytes, __ccgo_ts+6559, libc.Uint64FromInt64(12)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FecVar)).Fbytes + uintptr(libc.Uint64FromInt64(12)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FecVar)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(12) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FecVar)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FecVar)).FrefCount++
	(*TInterp)(unsafe.Pointer(iPtr)).FreturnLevel = int32(1)
	(*TInterp)(unsafe.Pointer(iPtr)).FreturnCode = TCL_OK
	(*TInterp)(unsafe.Pointer(iPtr)).FrootFramePtr = libc.UintptrFromInt32(0) /* Initialise as soon as :: is available */
	(*TInterp)(unsafe.Pointer(iPtr)).FlookupNsPtr = libc.UintptrFromInt32(0)
	XTcl_InitHashTable(tls, iPtr+136, TCL_STRING_KEYS)
	(*TInterp)(unsafe.Pointer(iPtr)).FpackageUnknown = libc.UintptrFromInt32(0)
	/* TIP #268 */
	if libc.Xgetenv(tls, __ccgo_ts+6571) == libc.UintptrFromInt32(0) {
		(*TInterp)(unsafe.Pointer(iPtr)).FpackagePrefer = int32(PKG_PREFER_STABLE)
	} else {
		(*TInterp)(unsafe.Pointer(iPtr)).FpackagePrefer = int32(PKG_PREFER_LATEST)
	}
	(*TInterp)(unsafe.Pointer(iPtr)).FcmdCount = 0
	XTclInitLiteralTable(tls, iPtr+264)
	(*TInterp)(unsafe.Pointer(iPtr)).FcompileEpoch = int64(1)
	(*TInterp)(unsafe.Pointer(iPtr)).FcompiledProcPtr = libc.UintptrFromInt32(0)
	(*TInterp)(unsafe.Pointer(iPtr)).FresolverPtr = libc.UintptrFromInt32(0)
	(*TInterp)(unsafe.Pointer(iPtr)).FevalFlags = 0
	(*TInterp)(unsafe.Pointer(iPtr)).FscriptFile = libc.UintptrFromInt32(0)
	(*TInterp)(unsafe.Pointer(iPtr)).Fflags = 0
	(*TInterp)(unsafe.Pointer(iPtr)).FtracePtr = libc.UintptrFromInt32(0)
	(*TInterp)(unsafe.Pointer(iPtr)).FtracesForbiddingInline = 0
	(*TInterp)(unsafe.Pointer(iPtr)).FactiveCmdTracePtr = libc.UintptrFromInt32(0)
	(*TInterp)(unsafe.Pointer(iPtr)).FactiveInterpTracePtr = libc.UintptrFromInt32(0)
	(*TInterp)(unsafe.Pointer(iPtr)).FassocData = libc.UintptrFromInt32(0)
	(*TInterp)(unsafe.Pointer(iPtr)).FexecEnvPtr = libc.UintptrFromInt32(0) /* Set after namespaces initialized. */
	if v7 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v7 {
		cachePtr6 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v7 || (*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects == libc.Uint64FromInt32(0) {
		(*TInterp)(unsafe.Pointer(iPtr)).FemptyObjPtr = XTclThreadAllocObj(tls)
	} else {
		(*TInterp)(unsafe.Pointer(iPtr)).FemptyObjPtr = (*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FemptyObjPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FemptyObjPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FemptyObjPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FemptyObjPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FemptyObjPtr)).FtypePtr = libc.UintptrFromInt32(0)
	/* Another empty object. */
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FemptyObjPtr)).FrefCount++
	(*TInterp)(unsafe.Pointer(iPtr)).FthreadId = XTcl_GetCurrentThread(tls)
	/* TIP #378 */
	if libc.Xgetenv(tls, __ccgo_ts+6593) != libc.UintptrFromInt32(0) {
		*(*int32)(unsafe.Pointer(iPtr + 368)) |= int32(INTERP_DEBUG_FRAME)
	}
	/*
	 * Initialise the tables for variable traces and searches *before*
	 * creating the global ns - so that the trace on errorInfo can be
	 * recorded.
	 */
	XTcl_InitHashTable(tls, iPtr+792, int32(TCL_ONE_WORD_KEYS))
	XTcl_InitHashTable(tls, iPtr+896, int32(TCL_ONE_WORD_KEYS))
	(*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr = libc.UintptrFromInt32(0) /* Force creation of global ns below. */
	(*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr = XTcl_CreateNamespace(tls, interp, __ccgo_ts+1945, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	if (*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+6616, 0)
	}
	/*
	 * Initialise the rootCallframe. It cannot be allocated on the stack, as
	 * it has to be in place before TclCreateExecEnv tries to use a variable.
	 */
	/* This is needed to satisfy GCC 3.3's strict aliasing rules */
	framePtr = XTcl_Alloc(tls, uint64(112))
	XTcl_PushCallFrame(tls, interp, framePtr, (*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr, 0)
	(*TCallFrame)(unsafe.Pointer(framePtr)).Fobjc = 0
	(*TInterp)(unsafe.Pointer(iPtr)).FframePtr = framePtr
	(*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr = framePtr
	(*TInterp)(unsafe.Pointer(iPtr)).FrootFramePtr = framePtr
	/*
	 * Initialize support for code compilation and execution. We call
	 * TclCreateExecEnv after initializing namespaces since it tries to
	 * reference a Tcl variable (it links to the Tcl "tcl_traceExec"
	 * variable).
	 */
	(*TInterp)(unsafe.Pointer(iPtr)).FexecEnvPtr = XTclCreateExecEnv(tls, interp, uint64(INTERP_STACK_INITIAL_SIZE))
	/*
	 * TIP #219, Tcl Channel Reflection API support.
	 */
	(*TInterp)(unsafe.Pointer(iPtr)).FchanMsg = libc.UintptrFromInt32(0)
	/*
	 * TIP #285, Script cancellation support.
	 */
	if v8 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v8 {
		cachePtr7 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v8 || (*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects == libc.Uint64FromInt32(0) {
		(*TInterp)(unsafe.Pointer(iPtr)).FasyncCancelMsg = XTclThreadAllocObj(tls)
	} else {
		(*TInterp)(unsafe.Pointer(iPtr)).FasyncCancelMsg = (*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FasyncCancelMsg + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FasyncCancelMsg)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FasyncCancelMsg)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FasyncCancelMsg)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FasyncCancelMsg)).FtypePtr = libc.UintptrFromInt32(0)
	cancelInfo = XTcl_Alloc(tls, uint64(48))
	(*TCancelInfo)(unsafe.Pointer(cancelInfo)).Finterp = interp
	(*TInterp)(unsafe.Pointer(iPtr)).FasyncCancel = XTcl_AsyncCreate(tls, __ccgo_fp(_CancelEvalProc), cancelInfo)
	(*TCancelInfo)(unsafe.Pointer(cancelInfo)).Fasync = (*TInterp)(unsafe.Pointer(iPtr)).FasyncCancel
	(*TCancelInfo)(unsafe.Pointer(cancelInfo)).Fresult = libc.UintptrFromInt32(0)
	(*TCancelInfo)(unsafe.Pointer(cancelInfo)).Flength = 0
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_cancelLock)))
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_cancelTable)))).FcreateProc})))(tls, uintptr(unsafe.Pointer(&_cancelTable)), iPtr, bp)
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = cancelInfo
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_cancelLock)))
	/*
	 * Initialize the compilation and execution statistics kept for this
	 * interpreter.
	 */
	/*
	 * Initialize the ensemble error message rewriting support.
	 */
	XTclResetRewriteEnsemble(tls, interp, int32(1))
	/*
	 * TIP#143: Initialise the resource limit support.
	 */
	XTclInitLimitSupport(tls, interp)
	/*
	 * Initialise the thread-specific data ekeko. Note that the thread's alloc
	 * cache was already initialised by the call to alloc the interp struct.
	 */
	(*TInterp)(unsafe.Pointer(iPtr)).FallocCache = XTclpGetAllocCache(tls)
	(*TInterp)(unsafe.Pointer(iPtr)).FpendingObjDataPtr = libc.UintptrFromInt32(0)
	(*TInterp)(unsafe.Pointer(iPtr)).FasyncReadyPtr = XTclGetAsyncReadyPtr(tls)
	(*TInterp)(unsafe.Pointer(iPtr)).FdeferredCallbacks = libc.UintptrFromInt32(0)
	/*
	 * Create the core commands. Do it here, rather than calling Tcl_CreateObjCommand,
	 * because it's faster (there's no need to check for a preexisting command
	 * by the same name). Set the Tcl_CmdProc to NULL.
	 */
	cmdInfoPtr = uintptr(unsafe.Pointer(&_builtInCmds))
	for {
		if !((*TCmdInfo)(unsafe.Pointer(cmdInfoPtr)).Fname != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TCmdInfo)(unsafe.Pointer(cmdInfoPtr)).FobjProc == libc.UintptrFromInt32(0) && (*TCmdInfo)(unsafe.Pointer(cmdInfoPtr)).FcompileProc == libc.UintptrFromInt32(0) && (*TCmdInfo)(unsafe.Pointer(cmdInfoPtr)).FnreProc == libc.UintptrFromInt32(0) {
			XTcl_Panic(tls, __ccgo_ts+6664, 0)
		}
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr + 184)).FcreateProc})))(tls, (*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr+184, (*TCmdInfo)(unsafe.Pointer(cmdInfoPtr)).Fname, bp)
		if *(*int32)(unsafe.Pointer(bp)) != 0 {
			cmdPtr = XTcl_Alloc(tls, uint64(120))
			(*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr = hPtr
			(*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr = (*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr
			(*TCommand)(unsafe.Pointer(cmdPtr)).FrefCount = int64(1)
			(*TCommand)(unsafe.Pointer(cmdPtr)).FcmdEpoch = 0
			(*TCommand)(unsafe.Pointer(cmdPtr)).FcompileProc = (*TCmdInfo)(unsafe.Pointer(cmdInfoPtr)).FcompileProc
			(*TCommand)(unsafe.Pointer(cmdPtr)).Fproc = libc.UintptrFromInt32(0)
			(*TCommand)(unsafe.Pointer(cmdPtr)).FclientData = cmdPtr
			(*TCommand)(unsafe.Pointer(cmdPtr)).FobjProc = (*TCmdInfo)(unsafe.Pointer(cmdInfoPtr)).FobjProc
			(*TCommand)(unsafe.Pointer(cmdPtr)).FobjClientData = libc.UintptrFromInt32(0)
			(*TCommand)(unsafe.Pointer(cmdPtr)).FdeleteProc = libc.UintptrFromInt32(0)
			(*TCommand)(unsafe.Pointer(cmdPtr)).FdeleteData = libc.UintptrFromInt32(0)
			(*TCommand)(unsafe.Pointer(cmdPtr)).Fflags = 0
			if (*TCmdInfo)(unsafe.Pointer(cmdInfoPtr)).Fflags&int32(CMD_COMPILES_EXPANDED) != 0 {
				*(*int32)(unsafe.Pointer(cmdPtr + 88)) |= int32(CMD_COMPILES_EXPANDED)
			}
			(*TCommand)(unsafe.Pointer(cmdPtr)).FimportRefPtr = libc.UintptrFromInt32(0)
			(*TCommand)(unsafe.Pointer(cmdPtr)).FtracePtr = libc.UintptrFromInt32(0)
			(*TCommand)(unsafe.Pointer(cmdPtr)).FnreProc = (*TCmdInfo)(unsafe.Pointer(cmdInfoPtr)).FnreProc
			(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = cmdPtr
		}
		goto _9
	_9:
		;
		cmdInfoPtr += 40
	}
	/*
	 * Create the "array", "binary", "chan", "clock", "dict", "encoding",
	 * "file", "info", "namespace" and "string" ensembles. Note that all these
	 * commands (and their subcommands that are not present in the global
	 * namespace) are wholly safe *except* for "clock", "encoding" and "file".
	 */
	XTclInitArrayCmd(tls, interp)
	XTclInitBinaryCmd(tls, interp)
	XTclInitChanCmd(tls, interp)
	XTclInitDictCmd(tls, interp)
	XTclInitEncodingCmd(tls, interp)
	XTclInitFileCmd(tls, interp)
	XTclInitInfoCmd(tls, interp)
	XTclInitNamespaceCmd(tls, interp)
	XTclInitStringCmd(tls, interp)
	XTclInitPrefixCmd(tls, interp)
	XTclInitProcessCmd(tls, interp)
	/*
	 * Register "clock" subcommands. These *do* go through
	 * Tcl_CreateObjCommand, since they aren't in the global namespace and
	 * involve ensembles.
	 */
	XTclClockInit(tls, interp)
	/*
	 * Register the built-in functions. This is empty now that they are
	 * implemented as commands in the ::tcl::mathfunc namespace.
	 */
	/*
	 * Register the default [interp bgerror] handler.
	 */
	XTcl_CreateObjCommand(tls, interp, __ccgo_ts+6734, __ccgo_fp(XTclDefaultBgErrorHandlerObjCmd), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	/*
	 * Create unsupported commands for debugging bytecode and objects.
	 */
	XTcl_CreateObjCommand(tls, interp, __ccgo_ts+6749, __ccgo_fp(XTcl_DisassembleObjCmd), uintptr(int64(libc.Int32FromInt32(0))), libc.UintptrFromInt32(0))
	XTcl_CreateObjCommand(tls, interp, __ccgo_ts+6781, __ccgo_fp(XTcl_DisassembleObjCmd), uintptr(int64(libc.Int32FromInt32(1))), libc.UintptrFromInt32(0))
	XTcl_CreateObjCommand(tls, interp, __ccgo_ts+6813, __ccgo_fp(XTcl_RepresentationCmd), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	/* Adding the bytecode assembler command */
	cmdPtr = XTcl_NRCreateCommand(tls, interp, __ccgo_ts+6848, __ccgo_fp(XTcl_AssembleObjCmd), __ccgo_fp(XTclNRAssembleObjCmd), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	(*TCommand)(unsafe.Pointer(cmdPtr)).FcompileProc = __ccgo_fp(XTclCompileAssembleCmd)
	/* Coroutine monkeybusiness */
	XTcl_CreateObjCommand(tls, interp, __ccgo_ts+6877, __ccgo_fp(_CoroTypeObjCmd), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	/* Load and intialize ICU */
	XTcl_CreateObjCommand(tls, interp, __ccgo_ts+6906, __ccgo_fp(XTclLoadIcuObjCmd), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	/* Export unsupported commands */
	nsPtr = XTcl_FindNamespace(tls, interp, __ccgo_ts+6934, libc.UintptrFromInt32(0), 0)
	if nsPtr != 0 {
		XTcl_Export(tls, interp, nsPtr, __ccgo_ts+6235, int32(1))
	}
	/*
	 * Register the builtin math functions.
	 */
	nsPtr = XTcl_CreateNamespace(tls, interp, __ccgo_ts+6953, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	if nsPtr == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+6969, 0)
	}
	libc.Xmemcpy(tls, bp+6, __ccgo_ts+7006, uint64(MATH_FUNC_PREFIX_LEN))
	builtinFuncPtr = uintptr(unsafe.Pointer(&_BuiltinFuncTable))
	for {
		if !((*TBuiltinFuncDef)(unsafe.Pointer(builtinFuncPtr)).Fname != libc.UintptrFromInt32(0)) {
			break
		}
		libc.Xstrcpy(tls, bp+6+uintptr(MATH_FUNC_PREFIX_LEN), (*TBuiltinFuncDef)(unsafe.Pointer(builtinFuncPtr)).Fname)
		XTcl_CreateObjCommand(tls, interp, bp+6, (*TBuiltinFuncDef)(unsafe.Pointer(builtinFuncPtr)).FobjCmdProc, (*TBuiltinFuncDef)(unsafe.Pointer(builtinFuncPtr)).Ffn, libc.UintptrFromInt32(0))
		XTcl_Export(tls, interp, nsPtr, (*TBuiltinFuncDef)(unsafe.Pointer(builtinFuncPtr)).Fname, 0)
		goto _10
	_10:
		;
		builtinFuncPtr += 24
	}
	/*
	 * Register the mathematical "operator" commands. [TIP #174]
	 */
	nsPtr = XTcl_CreateNamespace(tls, interp, __ccgo_ts+7024, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	if nsPtr == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+7038, 0)
	}
	XTcl_Export(tls, interp, nsPtr, __ccgo_ts+6235, int32(1))
	libc.Xmemcpy(tls, bp+6, __ccgo_ts+7076, uint64(MATH_OP_PREFIX_LEN))
	opcmdInfoPtr = uintptr(unsafe.Pointer(&_mathOpCmds))
	for {
		if !((*TOpCmdInfo)(unsafe.Pointer(opcmdInfoPtr)).Fname != libc.UintptrFromInt32(0)) {
			break
		}
		occdPtr = XTcl_Alloc(tls, uint64(24))
		(*TTclOpCmdClientData)(unsafe.Pointer(occdPtr)).Fop = (*TOpCmdInfo)(unsafe.Pointer(opcmdInfoPtr)).Fname
		*(*int32)(unsafe.Pointer(occdPtr + 16)) = *(*int32)(unsafe.Pointer(opcmdInfoPtr + 24))
		(*TTclOpCmdClientData)(unsafe.Pointer(occdPtr)).Fexpected = (*TOpCmdInfo)(unsafe.Pointer(opcmdInfoPtr)).Fexpected
		libc.Xstrcpy(tls, bp+6+uintptr(MATH_OP_PREFIX_LEN), (*TOpCmdInfo)(unsafe.Pointer(opcmdInfoPtr)).Fname)
		cmdPtr = XTcl_CreateObjCommand(tls, interp, bp+6, (*TOpCmdInfo)(unsafe.Pointer(opcmdInfoPtr)).FobjProc, occdPtr, __ccgo_fp(_DeleteOpCmdClientData))
		if cmdPtr == libc.UintptrFromInt32(0) {
			XTcl_Panic(tls, __ccgo_ts+7092, libc.VaList(bp+128, (*TOpCmdInfo)(unsafe.Pointer(opcmdInfoPtr)).Fname))
		} else {
			if (*TOpCmdInfo)(unsafe.Pointer(opcmdInfoPtr)).FcompileProc != libc.UintptrFromInt32(0) {
				(*TCommand)(unsafe.Pointer(cmdPtr)).FcompileProc = (*TOpCmdInfo)(unsafe.Pointer(opcmdInfoPtr)).FcompileProc
			}
		}
		goto _11
	_11:
		;
		opcmdInfoPtr += 40
	}
	/*
	 * Do Multiple/Safe Interps Tcl init stuff
	 */
	XTclInterpInit(tls, interp)
	XTclSetupEnv(tls, interp)
	/*
	 * TIP #59: Make embedded configuration information available.
	 */
	XTclInitEmbeddedConfigurationInformation(tls, interp)
	/*
	 * TIP #440: Declare the name of the script engine to be "Tcl".
	 */
	XTcl_SetVar2(tls, interp, __ccgo_ts+7126, __ccgo_ts+7139, __ccgo_ts+7146, int32(TCL_GLOBAL_ONLY))
	/*
	 * Compute the byte order of this machine.
	 */
	*(*int16)(unsafe.Pointer(bp + 4)) = int16(1)
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 4))) == int32(1) {
		v12 = __ccgo_ts + 7150
	} else {
		v12 = __ccgo_ts + 7163
	}
	XTcl_SetVar2(tls, interp, __ccgo_ts+7126, __ccgo_ts+7173, v12, int32(TCL_GLOBAL_ONLY))
	XTcl_SetVar2Ex(tls, interp, __ccgo_ts+7126, __ccgo_ts+7183, XTcl_NewWideIntObj(tls, int64(8)), int32(TCL_GLOBAL_ONLY))
	/* TIP #291 */
	XTcl_SetVar2Ex(tls, interp, __ccgo_ts+7126, __ccgo_ts+7192, XTcl_NewWideIntObj(tls, int64(8)), int32(TCL_GLOBAL_ONLY))
	/*
	 * Set up other variables such as tcl_version and tcl_library
	 */
	XTcl_SetVar2(tls, interp, __ccgo_ts+7204, libc.UintptrFromInt32(0), __ccgo_ts+7219, int32(TCL_GLOBAL_ONLY))
	XTcl_SetVar2(tls, interp, __ccgo_ts+7225, libc.UintptrFromInt32(0), __ccgo_ts+7237, int32(TCL_GLOBAL_ONLY))
	XTclpSetVariables(tls, interp)
	/*
	 * Register Tcl's version number.
	 * TIP #268: Full patchlevel instead of just major.minor
	 * TIP #599: Extended build information "+<UUID>.<tag1>.<tag2>...."
	 */
	XTcl_PkgProvideEx(tls, interp, __ccgo_ts+7146, __ccgo_ts+7219, uintptr(unsafe.Pointer(&XtclStubs)))
	XTcl_PkgProvideEx(tls, interp, __ccgo_ts+7241, __ccgo_ts+7219, uintptr(unsafe.Pointer(&XtclStubs)))
	buildInfoCmd = XTcl_CreateObjCommand(tls, interp, __ccgo_ts+7245, __ccgo_fp(_buildInfoObjCmd), version, libc.UintptrFromInt32(0))
	XTcl_GetCommandInfoFromToken(tls, buildInfoCmd, bp+40)
	(*(*TTcl_CmdInfo)(unsafe.Pointer(bp + 40))).FobjProc2 = __ccgo_fp(_buildInfoObjCmd2)
	(*(*TTcl_CmdInfo)(unsafe.Pointer(bp + 40))).FobjClientData2 = version
	XTcl_SetCommandInfoFromToken(tls, buildInfoCmd, bp+40)
	if XTclTommath_Init(tls, interp) != TCL_OK {
		XTcl_Panic(tls, __ccgo_ts+7263, libc.VaList(bp+128, XTcl_GetStringFromObj(tls, XTcl_GetObjResult(tls, interp), libc.UintptrFromInt32(0))))
	}
	if XTclOOInit(tls, interp) != TCL_OK {
		XTcl_Panic(tls, __ccgo_ts+7263, libc.VaList(bp+128, XTcl_GetStringFromObj(tls, XTcl_GetObjResult(tls, interp), libc.UintptrFromInt32(0))))
	}
	if XTclZlibInit(tls, interp) != TCL_OK || XTclZipfs_Init(tls, interp) != TCL_OK {
		XTcl_Panic(tls, __ccgo_ts+7263, libc.VaList(bp+128, XTcl_GetStringFromObj(tls, XTcl_GetObjResult(tls, interp), libc.UintptrFromInt32(0))))
	}
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FexecEnvPtr)).FcallbackPtr = libc.UintptrFromInt32(0)
	return interp
}

func _DeleteOpCmdClientData(tls *libc.TLS, clientData uintptr) {
	var occdPtr uintptr
	_ = occdPtr
	occdPtr = clientData
	XTclpFree(tls, occdPtr)
}

/*
 * ---------------------------------------------------------------------
 *
 * TclRegisterCommandTypeName, TclGetCommandTypeName --
 *
 *	Command type registration and lookup mechanism. Everything is keyed by
 *	the Tcl_ObjCmdProc for the command, and that is used as the *key* into
 *	the hash table that maps to constant strings that are names. (It is
 *	recommended that those names be ASCII.)
 *
 * ---------------------------------------------------------------------
 */

func XTclRegisterCommandTypeName(tls *libc.TLS, implementationProc uintptr, nameStr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var hPtr uintptr
	var _ /* isNew at bp+0 */ int32
	_ = hPtr
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_commandTypeLock)))
	if _commandTypeInit == 0 {
		XTcl_InitHashTable(tls, uintptr(unsafe.Pointer(&_commandTypeTable)), int32(TCL_ONE_WORD_KEYS))
		_commandTypeInit = int32(1)
	}
	if nameStr != libc.UintptrFromInt32(0) {
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_commandTypeTable)))).FcreateProc})))(tls, uintptr(unsafe.Pointer(&_commandTypeTable)), implementationProc, bp)
		(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = nameStr
	} else {
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_commandTypeTable)))).FfindProc})))(tls, uintptr(unsafe.Pointer(&_commandTypeTable)), implementationProc)
		if hPtr != libc.UintptrFromInt32(0) {
			XTcl_DeleteHashEntry(tls, hPtr)
		}
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_commandTypeLock)))
}

func XTclGetCommandTypeName(tls *libc.TLS, command TTcl_Command) (r uintptr) {
	var cmdPtr, hPtr, name, procPtr uintptr
	_, _, _, _ = cmdPtr, hPtr, name, procPtr
	cmdPtr = command
	procPtr = (*TCommand)(unsafe.Pointer(cmdPtr)).FobjProc
	name = __ccgo_ts + 7266
	if procPtr == libc.UintptrFromInt32(0) {
		procPtr = (*TCommand)(unsafe.Pointer(cmdPtr)).FnreProc
	}
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_commandTypeLock)))
	if _commandTypeInit != 0 {
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_commandTypeTable)))).FfindProc})))(tls, uintptr(unsafe.Pointer(&_commandTypeTable)), procPtr)
		if hPtr != 0 && (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData != 0 {
			name = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		}
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_commandTypeLock)))
	return name
}

/*
 *----------------------------------------------------------------------
 *
 * TclHideUnsafeCommands --
 *
 *	Hides base commands that are not marked as safe from this interpreter.
 *
 * Results:
 *	TCL_OK if it succeeds, TCL_ERROR else.
 *
 * Side effects:
 *	Hides functionality in an interpreter.
 *
 *----------------------------------------------------------------------
 */

func XTclHideUnsafeCommands(tls *libc.TLS, interp uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Hide commands in this interpreter. */
	var cachePtr, cachePtr1, cmdInfoPtr, cmdName, hideName, unsafePtr, v11, v3, v4, v6, v8 uintptr
	var v10, v7 TTcl_Size
	var v12, v5, v9 bool
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cmdInfoPtr, cmdName, hideName, unsafePtr, v10, v11, v12, v3, v4, v5, v6, v7, v8, v9
	if interp == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	cmdInfoPtr = uintptr(unsafe.Pointer(&_builtInCmds))
	for {
		if !((*TCmdInfo)(unsafe.Pointer(cmdInfoPtr)).Fname != libc.UintptrFromInt32(0)) {
			break
		}
		if !((*TCmdInfo)(unsafe.Pointer(cmdInfoPtr)).Fflags&libc.Int32FromInt32(CMD_IS_SAFE) != 0) {
			XTcl_HideCommand(tls, interp, (*TCmdInfo)(unsafe.Pointer(cmdInfoPtr)).Fname, (*TCmdInfo)(unsafe.Pointer(cmdInfoPtr)).Fname)
		}
		goto _1
	_1:
		;
		cmdInfoPtr += 40
	}
	unsafePtr = uintptr(unsafe.Pointer(&_unsafeEnsembleCommands))
	for {
		if !((*TUnsafeEnsembleInfo)(unsafe.Pointer(unsafePtr)).FensembleNsName != 0) {
			break
		}
		if (*TUnsafeEnsembleInfo)(unsafe.Pointer(unsafePtr)).FcommandName != 0 {
			/*
			 * Hide an ensemble subcommand.
			 */
			cmdName = XTcl_ObjPrintf(tls, __ccgo_ts+7273, libc.VaList(bp+8, (*TUnsafeEnsembleInfo)(unsafe.Pointer(unsafePtr)).FensembleNsName, (*TUnsafeEnsembleInfo)(unsafe.Pointer(unsafePtr)).FcommandName))
			hideName = XTcl_ObjPrintf(tls, __ccgo_ts+7287, libc.VaList(bp+8, (*TUnsafeEnsembleInfo)(unsafe.Pointer(unsafePtr)).FensembleNsName, (*TUnsafeEnsembleInfo)(unsafe.Pointer(unsafePtr)).FcommandName))
			if (*TTcl_Obj)(unsafe.Pointer(cmdName)).Fbytes != 0 {
				v3 = (*TTcl_Obj)(unsafe.Pointer(cmdName)).Fbytes
			} else {
				v3 = XTcl_GetStringFromObj(tls, cmdName, libc.UintptrFromInt32(0))
			}
			if v5 = XTclRenameCommand(tls, interp, v3, __ccgo_ts+7297) != TCL_OK; !v5 {
				if (*TTcl_Obj)(unsafe.Pointer(hideName)).Fbytes != 0 {
					v4 = (*TTcl_Obj)(unsafe.Pointer(hideName)).Fbytes
				} else {
					v4 = XTcl_GetStringFromObj(tls, hideName, libc.UintptrFromInt32(0))
				}
			}
			if v5 || XTcl_HideCommand(tls, interp, __ccgo_ts+7297, v4) != TCL_OK {
				XTcl_Panic(tls, __ccgo_ts+7304, libc.VaList(bp+8, (*TUnsafeEnsembleInfo)(unsafe.Pointer(unsafePtr)).FensembleNsName, (*TUnsafeEnsembleInfo)(unsafe.Pointer(unsafePtr)).FcommandName, XTcl_GetStringFromObj(tls, XTcl_GetObjResult(tls, interp), libc.UintptrFromInt32(0))))
			}
			if (*TTcl_Obj)(unsafe.Pointer(cmdName)).Fbytes != 0 {
				v6 = (*TTcl_Obj)(unsafe.Pointer(cmdName)).Fbytes
			} else {
				v6 = XTcl_GetStringFromObj(tls, cmdName, libc.UintptrFromInt32(0))
			}
			XTcl_CreateObjCommand(tls, interp, v6, __ccgo_fp(_BadEnsembleSubcommand), unsafePtr, libc.UintptrFromInt32(0))
			v8 = cmdName
			v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
			*(*TTcl_Size)(unsafe.Pointer(v8))--
			if !(v7 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(cmdName)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(cmdName)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(cmdName)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(cmdName)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(cmdName)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(cmdName)).Flength = int64(-libc.Int32FromInt32(1))
					if v9 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v9 {
						cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v9 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, cmdName)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(cmdName + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = cmdName
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, cmdName)
				}
			}
			v11 = hideName
			v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
			*(*TTcl_Size)(unsafe.Pointer(v11))--
			if !(v10 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(hideName)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(hideName)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(hideName)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(hideName)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(hideName)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(hideName)).Flength = int64(-libc.Int32FromInt32(1))
					if v12 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v12 {
						cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v12 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, hideName)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(hideName + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = hideName
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, hideName)
				}
			}
		} else {
			/*
			 * Hide an ensemble main command (for compatibility).
			 */
			if XTcl_HideCommand(tls, interp, (*TUnsafeEnsembleInfo)(unsafe.Pointer(unsafePtr)).FensembleNsName, (*TUnsafeEnsembleInfo)(unsafe.Pointer(unsafePtr)).FensembleNsName) != TCL_OK {
				XTcl_Panic(tls, __ccgo_ts+7336, libc.VaList(bp+8, (*TUnsafeEnsembleInfo)(unsafe.Pointer(unsafePtr)).FensembleNsName, XTcl_GetStringFromObj(tls, XTcl_GetObjResult(tls, interp), libc.UintptrFromInt32(0))))
			}
		}
		goto _2
	_2:
		;
		unsafePtr += 16
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * BadEnsembleSubcommand --
 *
 *	Command used to act as a backstop implementation when subcommands of
 *	ensembles are unsafe (the real implementations of the subcommands are
 *	hidden). The clientData is description of what was hidden.
 *
 * Results:
 *	A standard Tcl result (always a TCL_ERROR).
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _BadEnsembleSubcommand(tls *libc.TLS, clientData uintptr, interp uintptr, dummy1521 int32, dummy1522 uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var infoPtr uintptr
	_ = infoPtr
	infoPtr = clientData
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+7365, libc.VaList(bp+8, (*TUnsafeEnsembleInfo)(unsafe.Pointer(infoPtr)).FcommandName, (*TUnsafeEnsembleInfo)(unsafe.Pointer(infoPtr)).FensembleNsName)))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7407, __ccgo_ts+7412, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
}

/*
 *--------------------------------------------------------------
 *
 * Tcl_CallWhenDeleted --
 *
 *	Arrange for a function to be called before a given interpreter is
 *	deleted. The function is called as soon as Tcl_DeleteInterp is called;
 *	if Tcl_CallWhenDeleted is called on an interpreter that has already
 *	been deleted, the function will be called when the last Tcl_Release is
 *	done on the interpreter.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	When Tcl_DeleteInterp is invoked to delete interp, proc will be
 *	invoked. See the manual entry for details.
 *
 *--------------------------------------------------------------
 */

func XTcl_CallWhenDeleted(tls *libc.TLS, interp uintptr, proc uintptr, clientData uintptr) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* One-word value to pass to proc. */
	var assocDataCounterPtr, dPtr, hPtr, iPtr uintptr
	var _ /* buffer at bp+4 */ [56]uint8
	var _ /* isNew at bp+0 */ int32
	_, _, _, _ = assocDataCounterPtr, dPtr, hPtr, iPtr
	iPtr = interp
	assocDataCounterPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_assocDataCounterKey)), int64(4))
	dPtr = XTcl_Alloc(tls, uint64(16))
	libc.X__builtin_snprintf(tls, bp+4, uint64(56), __ccgo_ts+7423, libc.VaList(bp+72, *(*int32)(unsafe.Pointer(assocDataCounterPtr))))
	*(*int32)(unsafe.Pointer(assocDataCounterPtr))++
	if (*TInterp)(unsafe.Pointer(iPtr)).FassocData == libc.UintptrFromInt32(0) {
		(*TInterp)(unsafe.Pointer(iPtr)).FassocData = XTcl_Alloc(tls, uint64(104))
		XTcl_InitHashTable(tls, (*TInterp)(unsafe.Pointer(iPtr)).FassocData, TCL_STRING_KEYS)
	}
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FassocData)).FcreateProc})))(tls, (*TInterp)(unsafe.Pointer(iPtr)).FassocData, bp+4, bp)
	(*TAssocData)(unsafe.Pointer(dPtr)).Fproc = proc
	(*TAssocData)(unsafe.Pointer(dPtr)).FclientData = clientData
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = dPtr
}

var _assocDataCounterKey TTcl_ThreadDataKey

/*
 *--------------------------------------------------------------
 *
 * Tcl_DontCallWhenDeleted --
 *
 *	Cancel the arrangement for a function to be called when a given
 *	interpreter is deleted.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	If proc and clientData were previously registered as a callback via
 *	Tcl_CallWhenDeleted, they are unregistered. If they weren't previously
 *	registered then nothing happens.
 *
 *--------------------------------------------------------------
 */

func XTcl_DontCallWhenDeleted(tls *libc.TLS, interp uintptr, proc uintptr, clientData uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* One-word value to pass to proc. */
	var dPtr, hPtr, hTablePtr, iPtr uintptr
	var _ /* hSearch at bp+0 */ TTcl_HashSearch
	_, _, _, _ = dPtr, hPtr, hTablePtr, iPtr
	iPtr = interp
	hTablePtr = (*TInterp)(unsafe.Pointer(iPtr)).FassocData
	if hTablePtr == libc.UintptrFromInt32(0) {
		return
	}
	hPtr = XTcl_FirstHashEntry(tls, hTablePtr, bp)
	for {
		if !(hPtr != libc.UintptrFromInt32(0)) {
			break
		}
		dPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		if (*TAssocData)(unsafe.Pointer(dPtr)).Fproc == proc && (*TAssocData)(unsafe.Pointer(dPtr)).FclientData == clientData {
			XTclpFree(tls, dPtr)
			XTcl_DeleteHashEntry(tls, hPtr)
			return
		}
		goto _1
	_1:
		;
		hPtr = XTcl_NextHashEntry(tls, bp)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetAssocData --
 *
 *	Creates a named association between user-specified data, a delete
 *	function and this interpreter. If the association already exists the
 *	data is overwritten with the new data. The delete function will be
 *	invoked when the interpreter is deleted.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Sets the associated data, creates the association if needed.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetAssocData(tls *libc.TLS, interp uintptr, name uintptr, proc uintptr, clientData uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* One-word value to pass to proc. */
	var dPtr, hPtr, iPtr uintptr
	var _ /* isNew at bp+0 */ int32
	_, _, _ = dPtr, hPtr, iPtr
	iPtr = interp
	if (*TInterp)(unsafe.Pointer(iPtr)).FassocData == libc.UintptrFromInt32(0) {
		(*TInterp)(unsafe.Pointer(iPtr)).FassocData = XTcl_Alloc(tls, uint64(104))
		XTcl_InitHashTable(tls, (*TInterp)(unsafe.Pointer(iPtr)).FassocData, TCL_STRING_KEYS)
	}
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FassocData)).FcreateProc})))(tls, (*TInterp)(unsafe.Pointer(iPtr)).FassocData, name, bp)
	if *(*int32)(unsafe.Pointer(bp)) == 0 {
		dPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
	} else {
		dPtr = XTcl_Alloc(tls, uint64(16))
	}
	(*TAssocData)(unsafe.Pointer(dPtr)).Fproc = proc
	(*TAssocData)(unsafe.Pointer(dPtr)).FclientData = clientData
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = dPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DeleteAssocData --
 *
 *	Deletes a named association of user-specified data with the specified
 *	interpreter.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Deletes the association.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DeleteAssocData(tls *libc.TLS, interp uintptr, name uintptr) {
	/* Name of association. */
	var dPtr, hPtr, iPtr uintptr
	_, _, _ = dPtr, hPtr, iPtr
	iPtr = interp
	if (*TInterp)(unsafe.Pointer(iPtr)).FassocData == libc.UintptrFromInt32(0) {
		return
	}
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FassocData)).FfindProc})))(tls, (*TInterp)(unsafe.Pointer(iPtr)).FassocData, name)
	if hPtr == libc.UintptrFromInt32(0) {
		return
	}
	dPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
	XTcl_DeleteHashEntry(tls, hPtr)
	if (*TAssocData)(unsafe.Pointer(dPtr)).Fproc != libc.UintptrFromInt32(0) {
		(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TAssocData)(unsafe.Pointer(dPtr)).Fproc})))(tls, (*TAssocData)(unsafe.Pointer(dPtr)).FclientData, interp)
	}
	XTclpFree(tls, dPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetAssocData --
 *
 *	Returns the client data associated with this name in the specified
 *	interpreter.
 *
 * Results:
 *	The client data in the AssocData record denoted by the named
 *	association, or NULL.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetAssocData(tls *libc.TLS, interp uintptr, name uintptr, procPtr uintptr) (r uintptr) {
	/* Pointer to place to store address of
	 * current deletion callback. */
	var dPtr, hPtr, iPtr uintptr
	_, _, _ = dPtr, hPtr, iPtr
	iPtr = interp
	if (*TInterp)(unsafe.Pointer(iPtr)).FassocData == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FassocData)).FfindProc})))(tls, (*TInterp)(unsafe.Pointer(iPtr)).FassocData, name)
	if hPtr == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	dPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
	if procPtr != libc.UintptrFromInt32(0) {
		*(*uintptr)(unsafe.Pointer(procPtr)) = (*TAssocData)(unsafe.Pointer(dPtr)).Fproc
	}
	return (*TAssocData)(unsafe.Pointer(dPtr)).FclientData
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_InterpDeleted --
 *
 *	Returns nonzero if the interpreter has been deleted with a call to
 *	Tcl_DeleteInterp.
 *
 * Results:
 *	Nonzero if the interpreter is deleted, zero otherwise.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_InterpDeleted(tls *libc.TLS, interp uintptr) (r int32) {
	var v1 int32
	_ = v1
	if (*TInterp)(unsafe.Pointer(interp)).Fflags&int32(DELETED) != 0 {
		v1 = int32(1)
	} else {
		v1 = 0
	}
	return v1
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DeleteInterp --
 *
 *	Ensures that the interpreter will be deleted eventually. If there are
 *	no Tcl_Preserve calls in effect for this interpreter, it is deleted
 *	immediately, otherwise the interpreter is deleted when the last
 *	Tcl_Preserve is matched by a call to Tcl_Release. In either case, the
 *	function runs the currently registered deletion callbacks.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The interpreter is marked as deleted. The caller may still use it
 *	safely if there are calls to Tcl_Preserve in effect for the
 *	interpreter, but further calls to Tcl_Eval etc in this interpreter
 *	will fail.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DeleteInterp(tls *libc.TLS, interp uintptr) {
	/* Token for command interpreter (returned by
	 * a previous call to Tcl_CreateInterp). */
	var iPtr uintptr
	_ = iPtr
	iPtr = interp
	/*
	 * If the interpreter has already been marked deleted, just punt.
	 */
	if (*TInterp)(unsafe.Pointer(iPtr)).Fflags&int32(DELETED) != 0 {
		return
	}
	/*
	 * Mark the interpreter as deleted. No further evals will be allowed.
	 * Increase the compileEpoch as a signal to compiled bytecodes.
	 */
	*(*int32)(unsafe.Pointer(iPtr + 368)) |= int32(DELETED)
	(*TInterp)(unsafe.Pointer(iPtr)).FcompileEpoch++
	/*
	 * Ensure that the interpreter is eventually deleted.
	 */
	XTcl_EventuallyFree(tls, interp, __ccgo_fp(_DeleteInterpProc))
}

/*
 *----------------------------------------------------------------------
 *
 * DeleteInterpProc --
 *
 *	Helper function to delete an interpreter. This function is called when
 *	the last call to Tcl_Preserve on this interpreter is matched by a call
 *	to Tcl_Release. The function cleans up all resources used in the
 *	interpreter and calls all currently registered interpreter deletion
 *	callbacks.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Whatever the interpreter deletion callbacks do. Frees resources used
 *	by the interpreter.
 *
 *----------------------------------------------------------------------
 */

func _DeleteInterpProc(tls *libc.TLS, blockPtr uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Interpreter to delete. */
	var _objPtr, _objPtr1, _objPtr10, _objPtr11, _objPtr12, _objPtr13, _objPtr14, _objPtr15, _objPtr16, _objPtr2, _objPtr3, _objPtr4, _objPtr5, _objPtr6, _objPtr7, _objPtr8, _objPtr9, cancelInfo, cfPtr, dPtr, eclPtr, hPtr, hTablePtr, iPtr, interp, nextResPtr, procPtr, resPtr, v10, v12, v14, v16, v18, v2, v20, v22, v24, v26, v28, v30, v32, v34, v36, v39, v4, v8 uintptr
	var i, v1, v11, v13, v15, v17, v19, v21, v23, v25, v27, v29, v3, v31, v35, v38, v7, v9 TTcl_Size
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr10, _objPtr11, _objPtr12, _objPtr13, _objPtr14, _objPtr15, _objPtr16, _objPtr2, _objPtr3, _objPtr4, _objPtr5, _objPtr6, _objPtr7, _objPtr8, _objPtr9, cancelInfo, cfPtr, dPtr, eclPtr, hPtr, hTablePtr, i, iPtr, interp, nextResPtr, procPtr, resPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v34, v35, v36, v38, v39, v4, v7, v8, v9
	interp = blockPtr
	iPtr = interp
	/*
		     * Punt if there is an error in the Tcl_Release/Tcl_Preserve matchup,
			 * unless we are exiting.
	*/
	if (*TInterp)(unsafe.Pointer(iPtr)).FnumLevels > 0 && !(XTclInExit(tls) != 0) {
		XTcl_Panic(tls, __ccgo_ts+7442, 0)
	}
	/*
	 * The interpreter should already be marked deleted; otherwise how did we
	 * get here?
	 */
	if !((*TInterp)(unsafe.Pointer(iPtr)).Fflags&libc.Int32FromInt32(DELETED) != 0) {
		XTcl_Panic(tls, __ccgo_ts+7484, 0)
	}
	/*
	 * TIP #219, Tcl Channel Reflection API. Discard a leftover state.
	 */
	if (*TInterp)(unsafe.Pointer(iPtr)).FchanMsg != libc.UintptrFromInt32(0) {
		_objPtr = (*TInterp)(unsafe.Pointer(iPtr)).FchanMsg
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		(*TInterp)(unsafe.Pointer(iPtr)).FchanMsg = libc.UintptrFromInt32(0)
	}
	/*
	 * TIP #285, Script cancellation support. Delete this interp from the
	 * global hash table of CancelInfo structs.
	 */
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_cancelLock)))
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_cancelTable)))).FfindProc})))(tls, uintptr(unsafe.Pointer(&_cancelTable)), iPtr)
	if hPtr != libc.UintptrFromInt32(0) {
		cancelInfo = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		if cancelInfo != libc.UintptrFromInt32(0) {
			if (*TCancelInfo)(unsafe.Pointer(cancelInfo)).Fresult != libc.UintptrFromInt32(0) {
				XTclpFree(tls, (*TCancelInfo)(unsafe.Pointer(cancelInfo)).Fresult)
			}
			XTclpFree(tls, cancelInfo)
		}
		XTcl_DeleteHashEntry(tls, hPtr)
	}
	if (*TInterp)(unsafe.Pointer(iPtr)).FasyncCancel != libc.UintptrFromInt32(0) {
		XTcl_AsyncDelete(tls, (*TInterp)(unsafe.Pointer(iPtr)).FasyncCancel)
		(*TInterp)(unsafe.Pointer(iPtr)).FasyncCancel = libc.UintptrFromInt32(0)
	}
	if (*TInterp)(unsafe.Pointer(iPtr)).FasyncCancelMsg != libc.UintptrFromInt32(0) {
		_objPtr1 = (*TInterp)(unsafe.Pointer(iPtr)).FasyncCancelMsg
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		(*TInterp)(unsafe.Pointer(iPtr)).FasyncCancelMsg = libc.UintptrFromInt32(0)
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_cancelLock)))
	/*
	 * Shut down all limit handler callback scripts that call back into this
	 * interpreter. Then eliminate all limit handlers for this interpreter.
	 */
	XTclRemoveScriptLimitCallbacks(tls, interp)
	XTclLimitRemoveAllHandlers(tls, interp)
	/*
	 * Dismantle the namespace here, before we clear the assocData. If any
	 * background errors occur here, they will be deleted below.
	 *
	 * Dismantle the namespace after freeing the iPtr->handle so that each
	 * bytecode releases its literals without caring to update the literal
	 * table, as it will be freed later in this function without further use.
	 */
	XTclHandleFree(tls, (*TInterp)(unsafe.Pointer(iPtr)).Fhandle)
	XTclTeardownNamespace(tls, (*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr)
	/*
	 * Delete all the hidden commands.
	 */
	hTablePtr = (*TInterp)(unsafe.Pointer(iPtr)).FhiddenCmdTablePtr
	if hTablePtr != libc.UintptrFromInt32(0) {
		/*
		 * Non-pernicious deletion. The deletion callbacks will not be allowed
		 * to create any new hidden or non-hidden commands.
		 * Tcl_DeleteCommandFromToken will remove the entry from the
		 * hiddenCmdTablePtr.
		 */
		hPtr = XTcl_FirstHashEntry(tls, hTablePtr, bp)
		for {
			if !(hPtr != libc.UintptrFromInt32(0)) {
				break
			}
			XTcl_DeleteCommandFromToken(tls, interp, (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData)
			goto _5
		_5:
			;
			hPtr = XTcl_NextHashEntry(tls, bp)
		}
		XTcl_DeleteHashTable(tls, hTablePtr)
		XTclpFree(tls, hTablePtr)
	}
	if (*TInterp)(unsafe.Pointer(iPtr)).FassocData != libc.UintptrFromInt32(0) {
		hTablePtr = (*TInterp)(unsafe.Pointer(iPtr)).FassocData
		/*
		 * Invoke deletion callbacks; note that a callback can create new
		 * callbacks, so we iterate.
		 */
		hPtr = XTcl_FirstHashEntry(tls, hTablePtr, bp)
		for {
			if !(hPtr != libc.UintptrFromInt32(0)) {
				break
			}
			dPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
			XTcl_DeleteHashEntry(tls, hPtr)
			if (*TAssocData)(unsafe.Pointer(dPtr)).Fproc != libc.UintptrFromInt32(0) {
				(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TAssocData)(unsafe.Pointer(dPtr)).Fproc})))(tls, (*TAssocData)(unsafe.Pointer(dPtr)).FclientData, interp)
			}
			XTclpFree(tls, dPtr)
			goto _6
		_6:
			;
			hPtr = XTcl_FirstHashEntry(tls, hTablePtr, bp)
		}
		XTcl_DeleteHashTable(tls, hTablePtr)
		XTclpFree(tls, hTablePtr)
		(*TInterp)(unsafe.Pointer(iPtr)).FassocData = libc.UintptrFromInt32(0)
	}
	/*
	 * Pop the root frame pointer and finish deleting the global
	 * namespace. The order is important [Bug 1658572].
	 */
	if (*TInterp)(unsafe.Pointer(iPtr)).FframePtr != (*TInterp)(unsafe.Pointer(iPtr)).FrootFramePtr && !(XTclInExit(tls) != 0) {
		XTcl_Panic(tls, __ccgo_ts+7542, 0)
	}
	XTcl_PopCallFrame(tls, interp)
	XTclpFree(tls, (*TInterp)(unsafe.Pointer(iPtr)).FrootFramePtr)
	(*TInterp)(unsafe.Pointer(iPtr)).FrootFramePtr = libc.UintptrFromInt32(0)
	XTcl_DeleteNamespace(tls, (*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr)
	/*
	 * Free up the result *after* deleting variables, since variable deletion
	 * could have transferred ownership of the result string to Tcl.
	 */
	_objPtr2 = (*TInterp)(unsafe.Pointer(iPtr)).FobjResultPtr
	v8 = _objPtr2
	v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
	*(*TTcl_Size)(unsafe.Pointer(v8))--
	if v7 <= int64(1) {
		XTclFreeObj(tls, _objPtr2)
	}
	(*TInterp)(unsafe.Pointer(iPtr)).FobjResultPtr = libc.UintptrFromInt32(0)
	_objPtr3 = (*TInterp)(unsafe.Pointer(iPtr)).FecVar
	v10 = _objPtr3
	v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
	*(*TTcl_Size)(unsafe.Pointer(v10))--
	if v9 <= int64(1) {
		XTclFreeObj(tls, _objPtr3)
	}
	if (*TInterp)(unsafe.Pointer(iPtr)).FerrorCode != 0 {
		_objPtr4 = (*TInterp)(unsafe.Pointer(iPtr)).FerrorCode
		v12 = _objPtr4
		v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
		*(*TTcl_Size)(unsafe.Pointer(v12))--
		if v11 <= int64(1) {
			XTclFreeObj(tls, _objPtr4)
		}
		(*TInterp)(unsafe.Pointer(iPtr)).FerrorCode = libc.UintptrFromInt32(0)
	}
	_objPtr5 = (*TInterp)(unsafe.Pointer(iPtr)).FeiVar
	v14 = _objPtr5
	v13 = *(*TTcl_Size)(unsafe.Pointer(v14))
	*(*TTcl_Size)(unsafe.Pointer(v14))--
	if v13 <= int64(1) {
		XTclFreeObj(tls, _objPtr5)
	}
	if (*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo != 0 {
		_objPtr6 = (*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo
		v16 = _objPtr6
		v15 = *(*TTcl_Size)(unsafe.Pointer(v16))
		*(*TTcl_Size)(unsafe.Pointer(v16))--
		if v15 <= int64(1) {
			XTclFreeObj(tls, _objPtr6)
		}
		(*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo = libc.UintptrFromInt32(0)
	}
	_objPtr7 = (*TInterp)(unsafe.Pointer(iPtr)).FerrorStack
	v18 = _objPtr7
	v17 = *(*TTcl_Size)(unsafe.Pointer(v18))
	*(*TTcl_Size)(unsafe.Pointer(v18))--
	if v17 <= int64(1) {
		XTclFreeObj(tls, _objPtr7)
	}
	(*TInterp)(unsafe.Pointer(iPtr)).FerrorStack = libc.UintptrFromInt32(0)
	_objPtr8 = (*TInterp)(unsafe.Pointer(iPtr)).FupLiteral
	v20 = _objPtr8
	v19 = *(*TTcl_Size)(unsafe.Pointer(v20))
	*(*TTcl_Size)(unsafe.Pointer(v20))--
	if v19 <= int64(1) {
		XTclFreeObj(tls, _objPtr8)
	}
	_objPtr9 = (*TInterp)(unsafe.Pointer(iPtr)).FcallLiteral
	v22 = _objPtr9
	v21 = *(*TTcl_Size)(unsafe.Pointer(v22))
	*(*TTcl_Size)(unsafe.Pointer(v22))--
	if v21 <= int64(1) {
		XTclFreeObj(tls, _objPtr9)
	}
	_objPtr10 = (*TInterp)(unsafe.Pointer(iPtr)).FinnerLiteral
	v24 = _objPtr10
	v23 = *(*TTcl_Size)(unsafe.Pointer(v24))
	*(*TTcl_Size)(unsafe.Pointer(v24))--
	if v23 <= int64(1) {
		XTclFreeObj(tls, _objPtr10)
	}
	_objPtr11 = (*TInterp)(unsafe.Pointer(iPtr)).FinnerContext
	v26 = _objPtr11
	v25 = *(*TTcl_Size)(unsafe.Pointer(v26))
	*(*TTcl_Size)(unsafe.Pointer(v26))--
	if v25 <= int64(1) {
		XTclFreeObj(tls, _objPtr11)
	}
	if (*TInterp)(unsafe.Pointer(iPtr)).FreturnOpts != 0 {
		_objPtr12 = (*TInterp)(unsafe.Pointer(iPtr)).FreturnOpts
		v28 = _objPtr12
		v27 = *(*TTcl_Size)(unsafe.Pointer(v28))
		*(*TTcl_Size)(unsafe.Pointer(v28))--
		if v27 <= int64(1) {
			XTclFreeObj(tls, _objPtr12)
		}
	}
	XTclFreePackageInfo(tls, iPtr)
	for (*TInterp)(unsafe.Pointer(iPtr)).FtracePtr != libc.UintptrFromInt32(0) {
		XTcl_DeleteTrace(tls, iPtr, (*TInterp)(unsafe.Pointer(iPtr)).FtracePtr)
	}
	if (*TInterp)(unsafe.Pointer(iPtr)).FexecEnvPtr != libc.UintptrFromInt32(0) {
		XTclDeleteExecEnv(tls, (*TInterp)(unsafe.Pointer(iPtr)).FexecEnvPtr)
	}
	if (*TInterp)(unsafe.Pointer(iPtr)).FscriptFile != 0 {
		_objPtr13 = (*TInterp)(unsafe.Pointer(iPtr)).FscriptFile
		v30 = _objPtr13
		v29 = *(*TTcl_Size)(unsafe.Pointer(v30))
		*(*TTcl_Size)(unsafe.Pointer(v30))--
		if v29 <= int64(1) {
			XTclFreeObj(tls, _objPtr13)
		}
		(*TInterp)(unsafe.Pointer(iPtr)).FscriptFile = libc.UintptrFromInt32(0)
	}
	_objPtr14 = (*TInterp)(unsafe.Pointer(iPtr)).FemptyObjPtr
	v32 = _objPtr14
	v31 = *(*TTcl_Size)(unsafe.Pointer(v32))
	*(*TTcl_Size)(unsafe.Pointer(v32))--
	if v31 <= int64(1) {
		XTclFreeObj(tls, _objPtr14)
	}
	(*TInterp)(unsafe.Pointer(iPtr)).FemptyObjPtr = libc.UintptrFromInt32(0)
	resPtr = (*TInterp)(unsafe.Pointer(iPtr)).FresolverPtr
	for resPtr != 0 {
		nextResPtr = (*TResolverScheme)(unsafe.Pointer(resPtr)).FnextPtr
		XTclpFree(tls, (*TResolverScheme)(unsafe.Pointer(resPtr)).Fname)
		XTclpFree(tls, resPtr)
		resPtr = nextResPtr
	}
	/*
	 * Free up literal objects created for scripts compiled by the
	 * interpreter.
	 */
	XTclDeleteLiteralTable(tls, interp, iPtr+264)
	/*
	 * TIP #280 - Release the arrays for ByteCode/Proc extension, and
	 * contents.
	 */
	hPtr = XTcl_FirstHashEntry(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlinePBodyPtr, bp)
	for {
		if !(hPtr != libc.UintptrFromInt32(0)) {
			break
		}
		cfPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		if (*TTcl_HashTable)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FlinePBodyPtr)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FlinePBodyPtr)).FkeyType == -int32(1) {
			v34 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
		} else {
			v34 = hPtr + 32
		}
		procPtr = v34
		(*TProc)(unsafe.Pointer(procPtr)).FiPtr = libc.UintptrFromInt32(0)
		if cfPtr != 0 {
			if (*TCmdFrame)(unsafe.Pointer(cfPtr)).Ftype1 == int32(TCL_LOCATION_SOURCE) {
				_objPtr15 = (*TCmdFrame)(unsafe.Pointer(cfPtr)).Fdata.Feval.Fpath
				v36 = _objPtr15
				v35 = *(*TTcl_Size)(unsafe.Pointer(v36))
				*(*TTcl_Size)(unsafe.Pointer(v36))--
				if v35 <= int64(1) {
					XTclFreeObj(tls, _objPtr15)
				}
			}
			XTclpFree(tls, (*TCmdFrame)(unsafe.Pointer(cfPtr)).Fline)
			XTclpFree(tls, cfPtr)
		}
		XTcl_DeleteHashEntry(tls, hPtr)
		goto _33
	_33:
		;
		hPtr = XTcl_NextHashEntry(tls, bp)
	}
	XTcl_DeleteHashTable(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlinePBodyPtr)
	XTclpFree(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlinePBodyPtr)
	(*TInterp)(unsafe.Pointer(iPtr)).FlinePBodyPtr = libc.UintptrFromInt32(0)
	/*
	 * See also tclCompile.c, TclCleanupByteCode
	 */
	hPtr = XTcl_FirstHashEntry(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlineBCPtr, bp)
	for {
		if !(hPtr != libc.UintptrFromInt32(0)) {
			break
		}
		eclPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		if (*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Ftype1 == int32(TCL_LOCATION_SOURCE) {
			_objPtr16 = (*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Fpath
			v39 = _objPtr16
			v38 = *(*TTcl_Size)(unsafe.Pointer(v39))
			*(*TTcl_Size)(unsafe.Pointer(v39))--
			if v38 <= int64(1) {
				XTclFreeObj(tls, _objPtr16)
			}
		}
		i = 0
		for {
			if !(i < (*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Fnuloc) {
				break
			}
			XTclpFree(tls, (*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Floc + uintptr(i)*32))).Fline)
			goto _40
		_40:
			;
			i++
		}
		if (*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Floc != libc.UintptrFromInt32(0) {
			XTclpFree(tls, (*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Floc)
		}
		XTclpFree(tls, eclPtr)
		XTcl_DeleteHashEntry(tls, hPtr)
		goto _37
	_37:
		;
		hPtr = XTcl_NextHashEntry(tls, bp)
	}
	XTcl_DeleteHashTable(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlineBCPtr)
	XTclpFree(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlineBCPtr)
	(*TInterp)(unsafe.Pointer(iPtr)).FlineBCPtr = libc.UintptrFromInt32(0)
	/*
	 * Location stack for uplevel/eval/... scripts which were passed through
	 * proc arguments. Actually we track all arguments as we do not and cannot
	 * know which arguments will be used as scripts and which will not.
	 */
	if (*TTcl_HashTable)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FlineLAPtr)).FnumEntries != 0 && !(XTclInExit(tls) != 0) {
		/*
		 * When the interp goes away we have nothing on the stack, so there
		 * are no arguments, so this table has to be empty.
		 */
		XTcl_Panic(tls, __ccgo_ts+7607, 0)
	}
	XTcl_DeleteHashTable(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlineLAPtr)
	XTclpFree(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlineLAPtr)
	(*TInterp)(unsafe.Pointer(iPtr)).FlineLAPtr = libc.UintptrFromInt32(0)
	if (*TTcl_HashTable)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FlineLABCPtr)).FnumEntries != 0 && !(XTclInExit(tls) != 0) {
		/*
		 * When the interp goes away we have nothing on the stack, so there
		 * are no arguments, so this table has to be empty.
		 */
		XTcl_Panic(tls, __ccgo_ts+7607, 0)
	}
	XTcl_DeleteHashTable(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlineLABCPtr)
	XTclpFree(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlineLABCPtr)
	(*TInterp)(unsafe.Pointer(iPtr)).FlineLABCPtr = libc.UintptrFromInt32(0)
	/*
	 * Squelch the tables of traces on variables and searches over arrays in
	 * the in the interpreter.
	 */
	XTcl_DeleteHashTable(tls, iPtr+792)
	XTcl_DeleteHashTable(tls, iPtr+896)
	XTclpFree(tls, iPtr)
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_HideCommand --
 *
 *	Makes a command hidden so that it cannot be invoked from within an
 *	interpreter, only from within an ancestor.
 *
 * Results:
 *	A standard Tcl result; also leaves a message in the interp's result if
 *	an error occurs.
 *
 * Side effects:
 *	Removes a command from the command table and create an entry into the
 *	hidden command table under the specified token name.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_HideCommand(tls *libc.TLS, interp uintptr, cmdName uintptr, hiddenCmdToken uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Token name of the to-be-hidden command. */
	var cmd TTcl_Command
	var cmdPtr, hPtr, hiddenCmdTablePtr, iPtr uintptr
	var _ /* isNew at bp+0 */ int32
	_, _, _, _, _ = cmd, cmdPtr, hPtr, hiddenCmdTablePtr, iPtr
	iPtr = interp
	if (*TInterp)(unsafe.Pointer(iPtr)).Fflags&int32(DELETED) != 0 {
		/*
		 * The interpreter is being deleted. Do not create any new structures,
		 * because it is not safe to modify the interpreter.
		 */
		return int32(TCL_ERROR)
	}
	/*
	 * Disallow hiding of commands that are currently in a namespace or
	 * renaming (as part of hiding) into a namespace (because the current
	 * implementation with a single global table and the needed uniqueness of
	 * names cause problems with namespaces).
	 *
	 * We don't need to check for "::" in cmdName because the real check is on
	 * the nsPtr below.
	 *
	 * hiddenCmdToken is just a string which is not interpreted in any way. It
	 * may contain :: but the string is not interpreted as a namespace
	 * qualifier command name. Thus, hiding foo::bar to foo::bar and then
	 * trying to expose or invoke ::foo::bar will NOT work; but if the
	 * application always uses the same strings it will get consistent
	 * behaviour.
	 *
	 * But as we currently limit ourselves to the global namespace only for
	 * the source, in order to avoid potential confusion, lets prevent "::" in
	 * the token too. - dl
	 */
	if libc.Xstrstr(tls, hiddenCmdToken, __ccgo_ts+7650) != libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+7653, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+7718, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Find the command to hide. An error is returned if cmdName can't be
	 * found. Look up the command only from the global namespace. Full path of
	 * the command must be given if using namespaces.
	 */
	cmd = XTcl_FindCommand(tls, interp, cmdName, libc.UintptrFromInt32(0), libc.Int32FromInt32(TCL_LEAVE_ERR_MSG)|libc.Int32FromInt32(TCL_GLOBAL_ONLY))
	if cmd == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	cmdPtr = cmd
	/*
	 * Check that the command is really in global namespace
	 */
	if (*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr != (*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+7730, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+7793, __ccgo_ts+7798, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Initialize the hidden command table if necessary.
	 */
	hiddenCmdTablePtr = (*TInterp)(unsafe.Pointer(iPtr)).FhiddenCmdTablePtr
	if hiddenCmdTablePtr == libc.UintptrFromInt32(0) {
		hiddenCmdTablePtr = XTcl_Alloc(tls, uint64(104))
		XTcl_InitHashTable(tls, hiddenCmdTablePtr, TCL_STRING_KEYS)
		(*TInterp)(unsafe.Pointer(iPtr)).FhiddenCmdTablePtr = hiddenCmdTablePtr
	}
	/*
	 * It is an error to move an exposed command to a hidden command with
	 * hiddenCmdToken if a hidden command with the name hiddenCmdToken already
	 * exists.
	 */
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(hiddenCmdTablePtr)).FcreateProc})))(tls, hiddenCmdTablePtr, hiddenCmdToken, bp)
	if !(*(*int32)(unsafe.Pointer(bp)) != 0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+7809, libc.VaList(bp+16, hiddenCmdToken)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+7793, __ccgo_ts+7850, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * NB: This code is currently 'like' a rename to a special separate name
	 * table. Changes here and in TclRenameCommand must be kept in synch until
	 * the common parts are actually factorized out.
	 */
	/*
	 * Remove the hash entry for the command from the interpreter command
	 * table. This is like deleting the command, so bump its command epoch
	 * to invalidate any cached references that point to the command.
	 */
	if (*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr != libc.UintptrFromInt32(0) {
		XTcl_DeleteHashEntry(tls, (*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr)
		(*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr = libc.UintptrFromInt32(0)
		(*TCommand)(unsafe.Pointer(cmdPtr)).FcmdEpoch++
	}
	/*
	 * The list of command exported from the namespace might have changed.
	 * However, we do not need to recompute this just yet; next time we need
	 * the info will be soon enough.
	 */
	if (*TNamespace)(unsafe.Pointer((*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr)).FnumExportPatterns != 0 {
		(*TNamespace)(unsafe.Pointer((*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr)).FexportLookupEpoch++
	}
	if (*TNamespace)(unsafe.Pointer((*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr)).FcommandPathLength != 0 {
		(*TNamespace)(unsafe.Pointer((*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr)).FcmdRefEpoch++
	}
	/*
	 * Now link the hash table entry with the command structure. We ensured
	 * above that the nsPtr was right.
	 */
	(*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr = hPtr
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = cmdPtr
	/*
	 * If the command being hidden has a compile function, increment the
	 * interpreter's compileEpoch to invalidate its compiled code. This makes
	 * sure that we don't later try to execute old code compiled with
	 * command-specific (i.e., inline) bytecodes for the now-hidden command.
	 * This field is checked in Tcl_EvalObj and ObjInterpProc, and code whose
	 * compilation epoch doesn't match is recompiled.
	 */
	if (*TCommand)(unsafe.Pointer(cmdPtr)).FcompileProc != libc.UintptrFromInt32(0) {
		(*TInterp)(unsafe.Pointer(iPtr)).FcompileEpoch++
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ExposeCommand --
 *
 *	Makes a previously hidden command callable from inside the interpreter
 *	instead of only by its ancestors.
 *
 * Results:
 *	A standard Tcl result. If an error occurs, a message is left in the
 *	interp's result.
 *
 * Side effects:
 *	Moves commands from one hash table to another.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ExposeCommand(tls *libc.TLS, interp uintptr, hiddenCmdToken uintptr, cmdName uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Name of to-be-exposed command. */
	var cmdPtr, hPtr, hiddenCmdTablePtr, iPtr, nsPtr uintptr
	var _ /* isNew at bp+0 */ int32
	_, _, _, _, _ = cmdPtr, hPtr, hiddenCmdTablePtr, iPtr, nsPtr
	iPtr = interp
	if (*TInterp)(unsafe.Pointer(iPtr)).Fflags&int32(DELETED) != 0 {
		/*
		 * The interpreter is being deleted. Do not create any new structures,
		 * because it is not safe to modify the interpreter.
		 */
		return int32(TCL_ERROR)
	}
	/*
	 * Check that we have a regular name for the command (that the user is not
	 * trying to do an expose and a rename (to another namespace) at the same
	 * time).
	 */
	if libc.Xstrstr(tls, cmdName, __ccgo_ts+7650) != libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+7865, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+7932, __ccgo_ts+7798, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Get the command from the hidden command table:
	 */
	hPtr = libc.UintptrFromInt32(0)
	hiddenCmdTablePtr = (*TInterp)(unsafe.Pointer(iPtr)).FhiddenCmdTablePtr
	if hiddenCmdTablePtr != libc.UintptrFromInt32(0) {
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(hiddenCmdTablePtr)).FfindProc})))(tls, hiddenCmdTablePtr, hiddenCmdToken)
	}
	if hPtr == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+7939, libc.VaList(bp+16, hiddenCmdToken)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+7718, hiddenCmdToken, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	cmdPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
	/*
	 * Check that we have a true global namespace command (enforced by
	 * Tcl_HideCommand but let's double check. (If it was not, we would not
	 * really know how to handle it).
	 */
	if (*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr != (*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr {
		/*
		 * This case is theoretically impossible, we might rather Tcl_Panic
		 * than 'nicely' erroring out ?
		 */
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+7974, int64(-libc.Int32FromInt32(1))))
		return int32(TCL_ERROR)
	}
	/*
	 * This is the global table.
	 */
	nsPtr = (*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr
	/*
	 * It is an error to overwrite an existing exposed command as a result of
	 * exposing a previously hidden command.
	 */
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(nsPtr + 184)).FcreateProc})))(tls, nsPtr+184, cmdName, bp)
	if !(*(*int32)(unsafe.Pointer(bp)) != 0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+8030, libc.VaList(bp+16, cmdName)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+7932, __ccgo_ts+8066, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Command resolvers (per-interp, per-namespace) might have resolved to a
	 * command for the given namespace scope with this command not being
	 * registered with the namespace's command table. During BC compilation,
	 * the so-resolved command turns into a CmdName literal. Without
	 * invalidating a possible CmdName literal here explicitly, such literals
	 * keep being reused while pointing to overhauled commands.
	 */
	XTclInvalidateCmdLiteral(tls, interp, cmdName, nsPtr)
	/*
	 * The list of command exported from the namespace might have changed.
	 * However, we do not need to recompute this just yet; next time we need
	 * the info will be soon enough.
	 */
	if (*TNamespace)(unsafe.Pointer(nsPtr)).FnumExportPatterns != 0 {
		(*TNamespace)(unsafe.Pointer(nsPtr)).FexportLookupEpoch++
	}
	if (*TNamespace)(unsafe.Pointer(nsPtr)).FcommandPathLength != 0 {
		(*TNamespace)(unsafe.Pointer(nsPtr)).FcmdRefEpoch++
	}
	/*
	 * Remove the hash entry for the command from the interpreter hidden
	 * command table.
	 */
	if (*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr != libc.UintptrFromInt32(0) {
		XTcl_DeleteHashEntry(tls, (*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr)
		(*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr = libc.UintptrFromInt32(0)
	}
	/*
	 * Now link the hash table entry with the command structure. This is like
	 * creating a new command, so deal with any shadowing of commands in the
	 * global namespace.
	 */
	(*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr = hPtr
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = cmdPtr
	/*
	 * Not needed as we are only in the global namespace (but would be needed
	 * again if we supported namespace command hiding)
	 *
	 * TclResetShadowedCmdRefs(interp, cmdPtr);
	 */
	/*
	 * If the command being exposed has a compile function, increment
	 * interpreter's compileEpoch to invalidate its compiled code. This makes
	 * sure that we don't later try to execute old code compiled assuming the
	 * command is hidden. This field is checked in Tcl_EvalObj and
	 * ObjInterpProc, and code whose compilation epoch doesn't match is
	 * recompiled.
	 */
	if (*TCommand)(unsafe.Pointer(cmdPtr)).FcompileProc != libc.UintptrFromInt32(0) {
		(*TInterp)(unsafe.Pointer(iPtr)).FcompileEpoch++
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_CreateCommand --
 *
 *	Define a new command in a command table.
 *
 * Results:
 *	The return value is a token for the command, which can be used in
 *	future calls to Tcl_GetCommandName.
 *
 * Side effects:
 *	If a command named cmdName already exists for interp, it is deleted.
 *	In the future, when cmdName is seen as the name of a command by
 *	Tcl_Eval, proc will be called. To support the bytecode interpreter,
 *	the command is created with a wrapper Tcl_ObjCmdProc
 *	(InvokeStringCommand) that eventually calls proc. When the command
 *	is deleted from the table, deleteProc will be called. See the manual
 *	entry for details on the calling sequence.
 *
 *----------------------------------------------------------------------
 */

func XTcl_CreateCommand(tls *libc.TLS, interp uintptr, cmdName uintptr, proc uintptr, clientData uintptr, deleteProc uintptr) (r TTcl_Command) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	/* If not NULL, gives a function to call when
	 * this command is deleted. */
	var cmdPtr, dataPtr, hPtr, iPtr, oldRefPtr, refCmdPtr, v2 uintptr
	var deleted int32
	var v1 TTcl_Size
	var _ /* dummy1 at bp+24 */ uintptr
	var _ /* dummy2 at bp+32 */ uintptr
	var _ /* isNew at bp+16 */ int32
	var _ /* nsPtr at bp+0 */ uintptr
	var _ /* tail at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _ = cmdPtr, dataPtr, deleted, hPtr, iPtr, oldRefPtr, refCmdPtr, v1, v2
	iPtr = interp
	oldRefPtr = libc.UintptrFromInt32(0)
	*(*int32)(unsafe.Pointer(bp + 16)) = 0
	deleted = 0
	if (*TInterp)(unsafe.Pointer(iPtr)).Fflags&int32(DELETED) != 0 {
		/*
		 * The interpreter is being deleted. Don't create any new commands;
		 * it's not safe to muck with the interpreter anymore.
		 */
		return libc.UintptrFromInt32(0)
	}
	/*
	 * If the command name we seek to create already exists, we need to
	 * delete that first.  That can be tricky in the presence of traces.
	 * Loop until we no longer find an existing command in the way, or
	 * until we've deleted one command and that didn't finish the job.
	 */
	for int32(1) != 0 {
		/*
		 * Determine where the command should reside. If its name contains
		 * namespace qualifiers, we put it in the specified namespace;
		 * otherwise, we always put it in the global namespace.
		 */
		if libc.Xstrstr(tls, cmdName, __ccgo_ts+7650) != libc.UintptrFromInt32(0) {
			XTclGetNamespaceForQualName(tls, interp, cmdName, libc.UintptrFromInt32(0), int32(TCL_CREATE_NS_IF_UNKNOWN), bp, bp+24, bp+32, bp+8)
			if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) || *(*uintptr)(unsafe.Pointer(bp + 8)) == libc.UintptrFromInt32(0) {
				return libc.UintptrFromInt32(0)
			}
		} else {
			*(*uintptr)(unsafe.Pointer(bp)) = (*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr
			*(*uintptr)(unsafe.Pointer(bp + 8)) = cmdName
		}
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 184)).FcreateProc})))(tls, *(*uintptr)(unsafe.Pointer(bp))+184, *(*uintptr)(unsafe.Pointer(bp + 8)), bp+16)
		if *(*int32)(unsafe.Pointer(bp + 16)) != 0 || deleted != 0 {
			/*
			 * isNew - No conflict with existing command.
			 * deleted - We've already deleted a conflicting command
			 */
			break
		}
		/*
		 * An existing command conflicts. Try to delete it...
		 */
		cmdPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		/*
		 * Be careful to preserve any existing import links so we can restore
		 * them down below. That way, you can redefine a command and its
		 * import status will remain intact.
		 */
		(*TCommand)(unsafe.Pointer(cmdPtr)).FrefCount++
		if (*TCommand)(unsafe.Pointer(cmdPtr)).FimportRefPtr != 0 {
			*(*int32)(unsafe.Pointer(cmdPtr + 88)) |= int32(CMD_REDEF_IN_PROGRESS)
		}
		XTcl_DeleteCommandFromToken(tls, interp, cmdPtr)
		if (*TCommand)(unsafe.Pointer(cmdPtr)).Fflags&int32(CMD_REDEF_IN_PROGRESS) != 0 {
			oldRefPtr = (*TCommand)(unsafe.Pointer(cmdPtr)).FimportRefPtr
			(*TCommand)(unsafe.Pointer(cmdPtr)).FimportRefPtr = libc.UintptrFromInt32(0)
		}
		v2 = cmdPtr + 16
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclpFree(tls, cmdPtr)
		}
		deleted = int32(1)
	}
	if !(*(*int32)(unsafe.Pointer(bp + 16)) != 0) {
		/*
		 * If the deletion callback recreated the command, just throw away the
		 * new command (if we try to delete it again, we could get stuck in an
		 * infinite loop).
		 */
		XTclpFree(tls, (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData)
	}
	if !(deleted != 0) {
		/*
		 * Command resolvers (per-interp, per-namespace) might have resolved
		 * to a command for the given namespace scope with this command not
		 * being registered with the namespace's command table. During BC
		 * compilation, the so-resolved command turns into a CmdName literal.
		 * Without invalidating a possible CmdName literal here explicitly,
		 * such literals keep being reused while pointing to overhauled
		 * commands.
		 */
		XTclInvalidateCmdLiteral(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 8)), *(*uintptr)(unsafe.Pointer(bp)))
		/*
		 * The list of command exported from the namespace might have changed.
		 * However, we do not need to recompute this just yet; next time we
		 * need the info will be soon enough.
		 */
		if (*TNamespace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnumExportPatterns != 0 {
			(*TNamespace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FexportLookupEpoch++
		}
		if (*TNamespace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FcommandPathLength != 0 {
			(*TNamespace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FcmdRefEpoch++
		}
		XTclInvalidateNsPath(tls, *(*uintptr)(unsafe.Pointer(bp)))
	}
	cmdPtr = XTcl_Alloc(tls, uint64(120))
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = cmdPtr
	(*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr = hPtr
	(*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr = *(*uintptr)(unsafe.Pointer(bp))
	(*TCommand)(unsafe.Pointer(cmdPtr)).FrefCount = int64(1)
	(*TCommand)(unsafe.Pointer(cmdPtr)).FcmdEpoch = 0
	(*TCommand)(unsafe.Pointer(cmdPtr)).FcompileProc = libc.UintptrFromInt32(0)
	(*TCommand)(unsafe.Pointer(cmdPtr)).FobjProc = __ccgo_fp(_InvokeStringCommand)
	(*TCommand)(unsafe.Pointer(cmdPtr)).FobjClientData = cmdPtr
	(*TCommand)(unsafe.Pointer(cmdPtr)).Fproc = proc
	(*TCommand)(unsafe.Pointer(cmdPtr)).FclientData = clientData
	(*TCommand)(unsafe.Pointer(cmdPtr)).FdeleteProc = deleteProc
	(*TCommand)(unsafe.Pointer(cmdPtr)).FdeleteData = clientData
	(*TCommand)(unsafe.Pointer(cmdPtr)).Fflags = 0
	(*TCommand)(unsafe.Pointer(cmdPtr)).FimportRefPtr = libc.UintptrFromInt32(0)
	(*TCommand)(unsafe.Pointer(cmdPtr)).FtracePtr = libc.UintptrFromInt32(0)
	(*TCommand)(unsafe.Pointer(cmdPtr)).FnreProc = libc.UintptrFromInt32(0)
	/*
	 * Plug in any existing import references found above. Be sure to update
	 * all of these references to point to the new command.
	 */
	if oldRefPtr != libc.UintptrFromInt32(0) {
		(*TCommand)(unsafe.Pointer(cmdPtr)).FimportRefPtr = oldRefPtr
		for oldRefPtr != libc.UintptrFromInt32(0) {
			refCmdPtr = (*TImportRef)(unsafe.Pointer(oldRefPtr)).FimportedCmdPtr
			dataPtr = (*TCommand)(unsafe.Pointer(refCmdPtr)).FobjClientData
			(*TImportedCmdData)(unsafe.Pointer(dataPtr)).FrealCmdPtr = cmdPtr
			oldRefPtr = (*TImportRef)(unsafe.Pointer(oldRefPtr)).FnextPtr
		}
	}
	/*
	 * We just created a command, so in its namespace and all of its parent
	 * namespaces, it may shadow global commands with the same name. If any
	 * shadowed commands are found, invalidate all cached command references
	 * in the affected namespaces.
	 */
	XTclResetShadowedCmdRefs(tls, interp, cmdPtr)
	return cmdPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_CreateObjCommand --
 *
 *	Define a new object-based command in a command table.
 *
 * Results:
 *	The return value is a token for the command, which can be used in
 *	future calls to Tcl_GetCommandName.
 *
 * Side effects:
 *	If a command named "cmdName" already exists for interp, it is
 *	first deleted.  Then the new command is created from the arguments.
 *
 *	In the future, during bytecode evaluation when "cmdName" is seen as
 *	the name of a command by Tcl_EvalObj or Tcl_Eval, the object-based
 *	Tcl_ObjCmdProc proc will be called. When the command is deleted from
 *	the table, deleteProc will be called. See the manual entry for details
 *	on the calling sequence.
 *
 *----------------------------------------------------------------------
 */

type TCmdWrapperInfo = struct {
	Fproc       uintptr
	FclientData uintptr
	FdeleteProc uintptr
	FdeleteData uintptr
	FnreProc    uintptr
}

func _cmdWrapperProc(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var info uintptr
	_ = info
	info = clientData
	if objc < 0 {
		objc = -int32(1)
	}
	return (*(*func(*libc.TLS, uintptr, uintptr, TTcl_Size, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TCmdWrapperInfo)(unsafe.Pointer(info)).Fproc})))(tls, (*TCmdWrapperInfo)(unsafe.Pointer(info)).FclientData, interp, int64(objc), objv)
}

func _cmdWrapperDeleteProc(tls *libc.TLS, clientData uintptr) {
	var deleteProc, info uintptr
	_, _ = deleteProc, info
	info = clientData
	clientData = (*TCmdWrapperInfo)(unsafe.Pointer(info)).FdeleteData
	deleteProc = (*TCmdWrapperInfo)(unsafe.Pointer(info)).FdeleteProc
	XTclpFree(tls, info)
	if deleteProc != libc.UintptrFromInt32(0) {
		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{deleteProc})))(tls, clientData)
	}
}

func XTcl_CreateObjCommand2(tls *libc.TLS, interp uintptr, cmdName uintptr, proc uintptr, clientData uintptr, deleteProc uintptr) (r TTcl_Command) {
	/* If not NULL, gives a function to call when
	 * this command is deleted. */
	var info, v1 uintptr
	_, _ = info, v1
	info = XTcl_Alloc(tls, uint64(40))
	(*TCmdWrapperInfo)(unsafe.Pointer(info)).Fproc = proc
	(*TCmdWrapperInfo)(unsafe.Pointer(info)).FclientData = clientData
	(*TCmdWrapperInfo)(unsafe.Pointer(info)).FdeleteProc = deleteProc
	(*TCmdWrapperInfo)(unsafe.Pointer(info)).FdeleteData = clientData
	if proc != 0 {
		v1 = __ccgo_fp(_cmdWrapperProc)
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	return XTcl_CreateObjCommand(tls, interp, cmdName, v1, info, __ccgo_fp(_cmdWrapperDeleteProc))
}

func XTcl_CreateObjCommand(tls *libc.TLS, interp uintptr, cmdName uintptr, proc uintptr, clientData uintptr, deleteProc uintptr) (r TTcl_Command) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	/* If not NULL, gives a function to call when
	 * this command is deleted. */
	var iPtr uintptr
	var _ /* dummy1 at bp+16 */ uintptr
	var _ /* dummy2 at bp+24 */ uintptr
	var _ /* nsPtr at bp+0 */ uintptr
	var _ /* tail at bp+8 */ uintptr
	_ = iPtr
	iPtr = interp
	if (*TInterp)(unsafe.Pointer(iPtr)).Fflags&int32(DELETED) != 0 {
		/*
		 * The interpreter is being deleted. Don't create any new commands;
		 * it's not safe to muck with the interpreter anymore.
		 */
		return libc.UintptrFromInt32(0)
	}
	/*
	 * Determine where the command should reside. If its name contains
	 * namespace qualifiers, we put it in the specified namespace;
	 * otherwise, we always put it in the global namespace.
	 */
	if libc.Xstrstr(tls, cmdName, __ccgo_ts+7650) != libc.UintptrFromInt32(0) {
		XTclGetNamespaceForQualName(tls, interp, cmdName, libc.UintptrFromInt32(0), int32(TCL_CREATE_NS_IF_UNKNOWN), bp, bp+16, bp+24, bp+8)
		if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) || *(*uintptr)(unsafe.Pointer(bp + 8)) == libc.UintptrFromInt32(0) {
			return libc.UintptrFromInt32(0)
		}
	} else {
		*(*uintptr)(unsafe.Pointer(bp)) = (*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr
		*(*uintptr)(unsafe.Pointer(bp + 8)) = cmdName
	}
	return XTclCreateObjCommandInNs(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 8)), *(*uintptr)(unsafe.Pointer(bp)), proc, clientData, deleteProc)
}

func XTclCreateObjCommandInNs(tls *libc.TLS, interp uintptr, cmdName uintptr, namesp uintptr, proc uintptr, clientData uintptr, deleteProc uintptr) (r TTcl_Command) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	/* If not NULL, gives a function to call when
	 * this command is deleted. */
	var cmdPtr, dataPtr, hPtr, nsPtr, oldRefPtr, refCmdPtr, v2, v4 uintptr
	var deleted int32
	var v1, v3 TTcl_Size
	var _ /* isNew at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _ = cmdPtr, dataPtr, deleted, hPtr, nsPtr, oldRefPtr, refCmdPtr, v1, v2, v3, v4
	deleted = 0
	*(*int32)(unsafe.Pointer(bp)) = 0
	oldRefPtr = libc.UintptrFromInt32(0)
	nsPtr = namesp
	/*
	 * If the command name we seek to create already exists, we need to delete
	 * that first. That can be tricky in the presence of traces. Loop until we
	 * no longer find an existing command in the way, or until we've deleted
	 * one command and that didn't finish the job.
	 */
	for int32(1) != 0 {
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(nsPtr + 184)).FcreateProc})))(tls, nsPtr+184, cmdName, bp)
		if *(*int32)(unsafe.Pointer(bp)) != 0 || deleted != 0 {
			/*
			 * isNew - No conflict with existing command.
			 * deleted - We've already deleted a conflicting command
			 */
			break
		}
		/*
		 * An existing command conflicts. Try to delete it...
		 */
		cmdPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		/*
		 * Command already exists; delete it. Be careful to preserve any
		 * existing import links so we can restore them down below. That way,
		 * you can redefine a command and its import status will remain
		 * intact.
		 */
		(*TCommand)(unsafe.Pointer(cmdPtr)).FrefCount++
		if (*TCommand)(unsafe.Pointer(cmdPtr)).FimportRefPtr != 0 {
			*(*int32)(unsafe.Pointer(cmdPtr + 88)) |= int32(CMD_REDEF_IN_PROGRESS)
		}
		/*
		 * Make sure namespace doesn't get deallocated.
		 */
		(*TNamespace)(unsafe.Pointer((*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr)).FrefCount++
		XTcl_DeleteCommandFromToken(tls, interp, cmdPtr)
		nsPtr = XTclEnsureNamespace(tls, interp, (*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr)
		XTclNsDecrRefCount(tls, (*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr)
		if (*TCommand)(unsafe.Pointer(cmdPtr)).Fflags&int32(CMD_REDEF_IN_PROGRESS) != 0 {
			oldRefPtr = (*TCommand)(unsafe.Pointer(cmdPtr)).FimportRefPtr
			(*TCommand)(unsafe.Pointer(cmdPtr)).FimportRefPtr = libc.UintptrFromInt32(0)
		}
		v2 = cmdPtr + 16
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclpFree(tls, cmdPtr)
		}
		deleted = int32(1)
	}
	if !(*(*int32)(unsafe.Pointer(bp)) != 0) {
		/*
		 * If the deletion callback recreated the command, just throw away the
		 * new command (if we try to delete it again, we could get stuck in an
		 * infinite loop).
		 */
		XTclpFree(tls, (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData)
	}
	if !(deleted != 0) {
		/*
		 * Command resolvers (per-interp, per-namespace) might have resolved
		 * to a command for the given namespace scope with this command not
		 * being registered with the namespace's command table. During BC
		 * compilation, the so-resolved command turns into a CmdName literal.
		 * Without invalidating a possible CmdName literal here explicitly,
		 * such literals keep being reused while pointing to overhauled
		 * commands.
		 */
		XTclInvalidateCmdLiteral(tls, interp, cmdName, nsPtr)
		/*
		 * The list of command exported from the namespace might have changed.
		 * However, we do not need to recompute this just yet; next time we
		 * need the info will be soon enough.
		 */
		if (*TNamespace)(unsafe.Pointer(nsPtr)).FnumExportPatterns != 0 {
			(*TNamespace)(unsafe.Pointer(nsPtr)).FexportLookupEpoch++
		}
		if (*TNamespace)(unsafe.Pointer(nsPtr)).FcommandPathLength != 0 {
			(*TNamespace)(unsafe.Pointer(nsPtr)).FcmdRefEpoch++
		}
		XTclInvalidateNsPath(tls, nsPtr)
	}
	cmdPtr = XTcl_Alloc(tls, uint64(120))
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = cmdPtr
	(*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr = hPtr
	(*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr = nsPtr
	(*TCommand)(unsafe.Pointer(cmdPtr)).FrefCount = int64(1)
	(*TCommand)(unsafe.Pointer(cmdPtr)).FcmdEpoch = 0
	(*TCommand)(unsafe.Pointer(cmdPtr)).FcompileProc = libc.UintptrFromInt32(0)
	(*TCommand)(unsafe.Pointer(cmdPtr)).FobjProc = proc
	(*TCommand)(unsafe.Pointer(cmdPtr)).FobjClientData = clientData
	(*TCommand)(unsafe.Pointer(cmdPtr)).Fproc = libc.UintptrFromInt32(0)
	(*TCommand)(unsafe.Pointer(cmdPtr)).FclientData = cmdPtr
	(*TCommand)(unsafe.Pointer(cmdPtr)).FdeleteProc = deleteProc
	(*TCommand)(unsafe.Pointer(cmdPtr)).FdeleteData = clientData
	(*TCommand)(unsafe.Pointer(cmdPtr)).Fflags = 0
	(*TCommand)(unsafe.Pointer(cmdPtr)).FimportRefPtr = libc.UintptrFromInt32(0)
	(*TCommand)(unsafe.Pointer(cmdPtr)).FtracePtr = libc.UintptrFromInt32(0)
	(*TCommand)(unsafe.Pointer(cmdPtr)).FnreProc = libc.UintptrFromInt32(0)
	/*
	 * Plug in any existing import references found above. Be sure to update
	 * all of these references to point to the new command.
	 */
	if oldRefPtr != libc.UintptrFromInt32(0) {
		(*TCommand)(unsafe.Pointer(cmdPtr)).FimportRefPtr = oldRefPtr
		for oldRefPtr != libc.UintptrFromInt32(0) {
			refCmdPtr = (*TImportRef)(unsafe.Pointer(oldRefPtr)).FimportedCmdPtr
			dataPtr = (*TCommand)(unsafe.Pointer(refCmdPtr)).FobjClientData
			(*TCommand)(unsafe.Pointer(cmdPtr)).FrefCount++
			v4 = (*TImportedCmdData)(unsafe.Pointer(dataPtr)).FrealCmdPtr + 16
			v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
			*(*TTcl_Size)(unsafe.Pointer(v4))--
			if v3 <= int64(1) {
				XTclpFree(tls, (*TImportedCmdData)(unsafe.Pointer(dataPtr)).FrealCmdPtr)
			}
			(*TImportedCmdData)(unsafe.Pointer(dataPtr)).FrealCmdPtr = cmdPtr
			oldRefPtr = (*TImportRef)(unsafe.Pointer(oldRefPtr)).FnextPtr
		}
	}
	/*
	 * We just created a command, so in its namespace and all of its parent
	 * namespaces, it may shadow global commands with the same name. If any
	 * shadowed commands are found, invalidate all cached command references
	 * in the affected namespaces.
	 */
	XTclResetShadowedCmdRefs(tls, interp, cmdPtr)
	return cmdPtr
}

/*
 *----------------------------------------------------------------------
 *
 * InvokeStringCommand --
 *
 *	"Wrapper" Tcl_ObjCmdProc used to call an existing string-based
 *	Tcl_CmdProc if no object-based function exists for a command. A
 *	pointer to this function is stored as the Tcl_ObjCmdProc in a Command
 *	structure. It simply turns around and calls the string Tcl_CmdProc in
 *	the Command structure.
 *
 * Results:
 *	A standard Tcl object result value.
 *
 * Side effects:
 *	Besides those side effects of the called Tcl_CmdProc,
 *	InvokeStringCommand allocates and frees storage.
 *
 *----------------------------------------------------------------------
 */

func _InvokeStringCommand(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var argv, cmdPtr, v2 uintptr
	var i, result int32
	_, _, _, _, _ = argv, cmdPtr, i, result, v2
	cmdPtr = clientData
	argv = XTclStackAlloc(tls, interp, libc.Uint64FromInt32(objc+libc.Int32FromInt32(1))*uint64(8))
	i = 0
	for {
		if !(i < objc) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)) = v2
		goto _1
	_1:
		;
		i++
	}
	*(*uintptr)(unsafe.Pointer(argv + uintptr(objc)*8)) = uintptr(0)
	/*
	 * Invoke the command's string-based Tcl_CmdProc.
	 */
	result = (*(*func(*libc.TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TCommand)(unsafe.Pointer(cmdPtr)).Fproc})))(tls, (*TCommand)(unsafe.Pointer(cmdPtr)).FclientData, interp, objc, argv)
	XTclStackFree(tls, interp, argv)
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * TclRenameCommand --
 *
 *	Called to give an existing Tcl command a different name. Both the old
 *	command name and the new command name can have "::" namespace
 *	qualifiers. If the new command has a different namespace context, the
 *	command will be moved to that namespace and will execute in the
 *	context of that new namespace.
 *
 *	If the new command name is NULL or the null string, the command is
 *	deleted.
 *
 * Results:
 *	Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
 *
 * Side effects:
 *	If anything goes wrong, an error message is returned in the
 *	interpreter's result object.
 *
 *----------------------------------------------------------------------
 */

func XTclRenameCommand(tls *libc.TLS, interp uintptr, oldName uintptr, newName uintptr) (r int32) {
	bp := tls.Alloc(320)
	defer tls.Free(320) /* New command name. */
	var cachePtr, cachePtr1, cmdNsPtr, cmdPtr, hPtr, iPtr, oldFullName, oldHPtr, v1, v3, v5, v7 uintptr
	var cmd TTcl_Command
	var result int32
	var v2, v8 bool
	var v4, v6 TTcl_Size
	var _ /* dummy1 at bp+16 */ uintptr
	var _ /* dummy2 at bp+24 */ uintptr
	var _ /* isNew at bp+32 */ int32
	var _ /* newFullName at bp+40 */ TTcl_DString
	var _ /* newNsPtr at bp+8 */ uintptr
	var _ /* newTail at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cmd, cmdNsPtr, cmdPtr, hPtr, iPtr, oldFullName, oldHPtr, result, v1, v2, v3, v4, v5, v6, v7, v8
	iPtr = interp
	/*
	 * Find the existing command. An error is returned if cmdName can't be
	 * found.
	 */
	cmd = XTcl_FindCommand(tls, interp, oldName, libc.UintptrFromInt32(0), 0)
	cmdPtr = cmd
	if cmdPtr == libc.UintptrFromInt32(0) {
		if newName == libc.UintptrFromInt32(0) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(newName))) == int32('\000') {
			v1 = __ccgo_ts + 5663
		} else {
			v1 = __ccgo_ts + 5364
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+8081, libc.VaList(bp+272, v1, oldName)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+272, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+8118, oldName, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * If the new command name is NULL or empty, delete the command. Do this
	 * with Tcl_DeleteCommandFromToken, since we already have the command.
	 */
	if newName == libc.UintptrFromInt32(0) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(newName))) == int32('\000') {
		XTcl_DeleteCommandFromToken(tls, interp, cmd)
		return TCL_OK
	}
	cmdNsPtr = (*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		oldFullName = XTclThreadAllocObj(tls)
	} else {
		oldFullName = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(oldFullName + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(oldFullName)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(oldFullName)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(oldFullName)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(oldFullName)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(oldFullName)).FrefCount++
	XTcl_GetCommandFullName(tls, interp, cmd, oldFullName)
	/*
	 * Make sure that the destination command does not already exist. The
	 * rename operation is like creating a command, so we should automatically
	 * create the containing namespaces just like Tcl_CreateObjCommand would.
	 */
	XTclGetNamespaceForQualName(tls, interp, newName, libc.UintptrFromInt32(0), int32(TCL_CREATE_NS_IF_UNKNOWN), bp+8, bp+16, bp+24, bp)
	if *(*uintptr)(unsafe.Pointer(bp + 8)) == libc.UintptrFromInt32(0) || *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+8126, libc.VaList(bp+272, newName)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+272, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+8118, libc.UintptrFromInt32(0)))
		result = int32(TCL_ERROR)
		goto done
	}
	if (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 184)).FfindProc})))(tls, *(*uintptr)(unsafe.Pointer(bp + 8))+184, *(*uintptr)(unsafe.Pointer(bp))) != libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+8165, libc.VaList(bp+272, newName)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+272, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+8220, __ccgo_ts+8227, libc.UintptrFromInt32(0)))
		result = int32(TCL_ERROR)
		goto done
	}
	/*
	 * Warning: any changes done in the code here are likely to be needed in
	 * Tcl_HideCommand code too (until the common parts are extracted out).
	 * - dl
	 */
	/*
	 * Put the command in the new namespace so we can check for an alias loop.
	 * Since we are adding a new command to a namespace, we must handle any
	 * shadowing of the global commands that this might create.
	 */
	oldHPtr = (*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 184)).FcreateProc})))(tls, *(*uintptr)(unsafe.Pointer(bp + 8))+184, *(*uintptr)(unsafe.Pointer(bp)), bp+32)
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = cmdPtr
	(*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr = hPtr
	(*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
	XTclResetShadowedCmdRefs(tls, interp, cmdPtr)
	/*
	 * Now check for an alias loop. If we detect one, put everything back the
	 * way it was and report the error.
	 */
	result = XTclPreventAliasLoop(tls, interp, interp, cmdPtr)
	if result != TCL_OK {
		XTcl_DeleteHashEntry(tls, (*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr)
		(*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr = oldHPtr
		(*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr = cmdNsPtr
		goto done
	}
	/*
	 * The list of command exported from the namespace might have changed.
	 * However, we do not need to recompute this just yet; next time we need
	 * the info will be soon enough. These might refer to the same variable,
	 * but that's no big deal.
	 */
	if (*TNamespace)(unsafe.Pointer(cmdNsPtr)).FnumExportPatterns != 0 {
		(*TNamespace)(unsafe.Pointer(cmdNsPtr)).FexportLookupEpoch++
	}
	if (*TNamespace)(unsafe.Pointer(cmdNsPtr)).FcommandPathLength != 0 {
		(*TNamespace)(unsafe.Pointer(cmdNsPtr)).FcmdRefEpoch++
	}
	if (*TNamespace)(unsafe.Pointer((*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr)).FnumExportPatterns != 0 {
		(*TNamespace)(unsafe.Pointer((*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr)).FexportLookupEpoch++
	}
	if (*TNamespace)(unsafe.Pointer((*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr)).FcommandPathLength != 0 {
		(*TNamespace)(unsafe.Pointer((*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr)).FcmdRefEpoch++
	}
	/*
	 * Command resolvers (per-interp, per-namespace) might have resolved to a
	 * command for the given namespace scope with this command not being
	 * registered with the namespace's command table. During BC compilation,
	 * the so-resolved command turns into a CmdName literal. Without
	 * invalidating a possible CmdName literal here explicitly, such literals
	 * keep being reused while pointing to overhauled commands.
	 */
	XTclInvalidateCmdLiteral(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), (*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr)
	/*
	 * Script for rename traces can delete the command "oldName". Therefore
	 * increment the reference count for cmdPtr so that it's Command structure
	 * is freed only towards the end of this function by calling
	 * TclCleanupCommand.
	 *
	 * The trace function needs to get a fully qualified name for old and new
	 * commands [Tcl bug #651271], or else there's no way for the trace
	 * function to get the namespace from which the old command is being
	 * renamed!
	 */
	XTcl_DStringInit(tls, bp+40)
	XTcl_DStringAppend(tls, bp+40, (*TNamespace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FfullName, int64(-libc.Int32FromInt32(1)))
	if *(*uintptr)(unsafe.Pointer(bp + 8)) != (*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr {
		XTcl_DStringAppend(tls, bp+40, __ccgo_ts+7650, libc.Int64FromUint64(libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)))
	}
	XTcl_DStringAppend(tls, bp+40, *(*uintptr)(unsafe.Pointer(bp)), int64(-libc.Int32FromInt32(1)))
	(*TCommand)(unsafe.Pointer(cmdPtr)).FrefCount++
	if (*TTcl_Obj)(unsafe.Pointer(oldFullName)).Fbytes != 0 {
		v3 = (*TTcl_Obj)(unsafe.Pointer(oldFullName)).Fbytes
	} else {
		v3 = XTcl_GetStringFromObj(tls, oldFullName, libc.UintptrFromInt32(0))
	}
	_CallCommandTraces(tls, iPtr, cmdPtr, v3, (*TTcl_DString)(unsafe.Pointer(bp+40)).Fstring1, int32(TCL_TRACE_RENAME))
	XTcl_DStringFree(tls, bp+40)
	/*
	 * The new command name is okay, so remove the command from its current
	 * namespace. This is like deleting the command, so bump the cmdEpoch to
	 * invalidate any cached references to the command.
	 */
	XTcl_DeleteHashEntry(tls, oldHPtr)
	(*TCommand)(unsafe.Pointer(cmdPtr)).FcmdEpoch++
	/*
	 * If the command being renamed has a compile function, increment the
	 * interpreter's compileEpoch to invalidate its compiled code. This makes
	 * sure that we don't later try to execute old code compiled for the
	 * now-renamed command.
	 */
	if (*TCommand)(unsafe.Pointer(cmdPtr)).FcompileProc != libc.UintptrFromInt32(0) {
		(*TInterp)(unsafe.Pointer(iPtr)).FcompileEpoch++
	}
	/*
	 * Now free the Command structure, if the "oldName" command has been
	 * deleted by invocation of rename traces.
	 */
	v5 = cmdPtr + 16
	v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
	*(*TTcl_Size)(unsafe.Pointer(v5))--
	if v4 <= int64(1) {
		XTclpFree(tls, cmdPtr)
	}
	result = TCL_OK
	goto done
done:
	;
	v7 = oldFullName
	v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
	*(*TTcl_Size)(unsafe.Pointer(v7))--
	if !(v6 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(oldFullName)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(oldFullName)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(oldFullName)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(oldFullName)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(oldFullName)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(oldFullName)).Flength = int64(-libc.Int32FromInt32(1))
			if v8 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v8 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v8 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, oldFullName)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(oldFullName + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = oldFullName
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, oldFullName)
		}
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetCommandInfo --
 *
 *	Modifies various information about a Tcl command. Note that this
 *	function will not change a command's namespace; use TclRenameCommand
 *	to do that. Also, the isNativeObjectProc member of *infoPtr is
 *	ignored.
 *
 * Results:
 *	If cmdName exists in interp, then the information at *infoPtr is
 *	stored with the command in place of the current information and 1 is
 *	returned. If the command doesn't exist then 0 is returned.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetCommandInfo(tls *libc.TLS, interp uintptr, cmdName uintptr, infoPtr uintptr) (r int32) {
	/* Where to find information to store in the
	 * command. */
	var cmd TTcl_Command
	_ = cmd
	cmd = XTcl_FindCommand(tls, interp, cmdName, libc.UintptrFromInt32(0), 0)
	return XTcl_SetCommandInfoFromToken(tls, cmd, infoPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetCommandInfoFromToken --
 *
 *	Modifies various information about a Tcl command. Note that this
 *	function will not change a command's namespace; use TclRenameCommand
 *	to do that. Also, the isNativeObjectProc member of *infoPtr is
 *	ignored.
 *
 * Results:
 *	If cmdName exists in interp, then the information at *infoPtr is
 *	stored with the command in place of the current information and 1 is
 *	returned. If the command doesn't exist then 0 is returned.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _invokeObj2Command(tls *libc.TLS, clientData uintptr, interp uintptr, objc TTcl_Size, objv uintptr) (r int32) {
	/* Argument objects. */
	var cmdPtr uintptr
	var result int32
	_, _ = cmdPtr, result
	cmdPtr = clientData
	if objc > int64(INT_MAX) {
		return XTclCommandWordLimitError(tls, interp, objc)
	}
	if (*TCommand)(unsafe.Pointer(cmdPtr)).FobjProc != libc.UintptrFromInt32(0) {
		result = (*(*func(*libc.TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TCommand)(unsafe.Pointer(cmdPtr)).FobjProc})))(tls, (*TCommand)(unsafe.Pointer(cmdPtr)).FobjClientData, interp, int32(objc), objv)
	} else {
		result = XTcl_NRCallObjProc(tls, interp, (*TCommand)(unsafe.Pointer(cmdPtr)).FnreProc, (*TCommand)(unsafe.Pointer(cmdPtr)).FobjClientData, objc, objv)
	}
	return result
}

func _cmdWrapper2Proc(tls *libc.TLS, clientData uintptr, interp uintptr, objc TTcl_Size, objv uintptr) (r int32) {
	var cmdPtr uintptr
	_ = cmdPtr
	cmdPtr = clientData
	if objc > int64(INT_MAX) {
		return XTclCommandWordLimitError(tls, interp, objc)
	}
	return (*(*func(*libc.TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TCommand)(unsafe.Pointer(cmdPtr)).FobjProc})))(tls, (*TCommand)(unsafe.Pointer(cmdPtr)).FobjClientData, interp, int32(objc), objv)
}

func XTcl_SetCommandInfoFromToken(tls *libc.TLS, cmd TTcl_Command, infoPtr uintptr) (r int32) {
	var cmdPtr, info, info1 uintptr
	_, _, _ = cmdPtr, info, info1 /* Internal representation of the command */
	if cmd == libc.UintptrFromInt32(0) {
		return 0
	}
	/*
	 * The isNativeObjectProc and nsPtr members of *infoPtr are ignored.
	 */
	cmdPtr = cmd
	(*TCommand)(unsafe.Pointer(cmdPtr)).Fproc = (*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).Fproc
	(*TCommand)(unsafe.Pointer(cmdPtr)).FclientData = (*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FclientData
	if (*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FobjProc == libc.UintptrFromInt32(0) {
		(*TCommand)(unsafe.Pointer(cmdPtr)).FobjProc = __ccgo_fp(_InvokeStringCommand)
		(*TCommand)(unsafe.Pointer(cmdPtr)).FobjClientData = cmdPtr
		(*TCommand)(unsafe.Pointer(cmdPtr)).FnreProc = libc.UintptrFromInt32(0)
	} else {
		if (*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FobjProc != (*TCommand)(unsafe.Pointer(cmdPtr)).FobjProc {
			(*TCommand)(unsafe.Pointer(cmdPtr)).FnreProc = libc.UintptrFromInt32(0)
			(*TCommand)(unsafe.Pointer(cmdPtr)).FobjProc = (*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FobjProc
		}
		(*TCommand)(unsafe.Pointer(cmdPtr)).FobjClientData = (*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FobjClientData
	}
	if (*TCommand)(unsafe.Pointer(cmdPtr)).FdeleteProc == __ccgo_fp(_cmdWrapperDeleteProc) {
		info = (*TCommand)(unsafe.Pointer(cmdPtr)).FdeleteData
		if (*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FobjProc2 == libc.UintptrFromInt32(0) {
			(*TCmdWrapperInfo)(unsafe.Pointer(info)).Fproc = __ccgo_fp(_invokeObj2Command)
			(*TCmdWrapperInfo)(unsafe.Pointer(info)).FclientData = cmdPtr
			(*TCmdWrapperInfo)(unsafe.Pointer(info)).FnreProc = libc.UintptrFromInt32(0)
		} else {
			if (*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FobjProc2 != (*TCmdWrapperInfo)(unsafe.Pointer(info)).Fproc {
				(*TCmdWrapperInfo)(unsafe.Pointer(info)).FnreProc = libc.UintptrFromInt32(0)
				(*TCmdWrapperInfo)(unsafe.Pointer(info)).Fproc = (*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FobjProc2
			}
			(*TCmdWrapperInfo)(unsafe.Pointer(info)).FclientData = (*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FobjClientData2
		}
		(*TCmdWrapperInfo)(unsafe.Pointer(info)).FdeleteProc = (*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FdeleteProc
		(*TCmdWrapperInfo)(unsafe.Pointer(info)).FdeleteData = (*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FdeleteData
	} else {
		if (*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FobjProc2 != libc.UintptrFromInt32(0) && (*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FobjProc2 != __ccgo_fp(_cmdWrapper2Proc) {
			info1 = XTcl_Alloc(tls, uint64(40))
			(*TCmdWrapperInfo)(unsafe.Pointer(info1)).Fproc = (*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FobjProc2
			(*TCmdWrapperInfo)(unsafe.Pointer(info1)).FclientData = (*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FobjClientData2
			(*TCmdWrapperInfo)(unsafe.Pointer(info1)).FnreProc = libc.UintptrFromInt32(0)
			(*TCmdWrapperInfo)(unsafe.Pointer(info1)).FdeleteProc = (*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FdeleteProc
			(*TCmdWrapperInfo)(unsafe.Pointer(info1)).FdeleteData = (*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FdeleteData
			(*TCommand)(unsafe.Pointer(cmdPtr)).FdeleteProc = __ccgo_fp(_cmdWrapperDeleteProc)
			(*TCommand)(unsafe.Pointer(cmdPtr)).FdeleteData = info1
		} else {
			(*TCommand)(unsafe.Pointer(cmdPtr)).FdeleteProc = (*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FdeleteProc
			(*TCommand)(unsafe.Pointer(cmdPtr)).FdeleteData = (*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FdeleteData
		}
	}
	return int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetCommandInfo --
 *
 *	Returns various information about a Tcl command.
 *
 * Results:
 *	If cmdName exists in interp, then *infoPtr is modified to hold
 *	information about cmdName and 1 is returned. If the command doesn't
 *	exist then 0 is returned and *infoPtr isn't modified.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetCommandInfo(tls *libc.TLS, interp uintptr, cmdName uintptr, infoPtr uintptr) (r int32) {
	/* Where to store information about
	 * command. */
	var cmd TTcl_Command
	_ = cmd
	cmd = XTcl_FindCommand(tls, interp, cmdName, libc.UintptrFromInt32(0), 0)
	return XTcl_GetCommandInfoFromToken(tls, cmd, infoPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetCommandInfoFromToken --
 *
 *	Returns various information about a Tcl command.
 *
 * Results:
 *	Copies information from the command identified by 'cmd' into a
 *	caller-supplied structure and returns 1. If the 'cmd' is NULL, leaves
 *	the structure untouched and returns 0.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetCommandInfoFromToken(tls *libc.TLS, cmd TTcl_Command, infoPtr uintptr) (r int32) {
	var cmdPtr, info uintptr
	_, _ = cmdPtr, info /* Internal representation of the command */
	if cmd == libc.UintptrFromInt32(0) {
		return 0
	}
	/*
	 * Set isNativeObjectProc 1 if objProc was registered by a call to
	 * Tcl_CreateObjCommand. Set isNativeObjectProc 2 if objProc was
	 * registered by a call to Tcl_CreateObjCommand2. Otherwise set it to 0.
	 */
	cmdPtr = cmd
	(*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FisNativeObjectProc = libc.BoolInt32((*TCommand)(unsafe.Pointer(cmdPtr)).FobjProc != __ccgo_fp(_InvokeStringCommand))
	(*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FobjProc = (*TCommand)(unsafe.Pointer(cmdPtr)).FobjProc
	(*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FobjClientData = (*TCommand)(unsafe.Pointer(cmdPtr)).FobjClientData
	(*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).Fproc = (*TCommand)(unsafe.Pointer(cmdPtr)).Fproc
	(*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FclientData = (*TCommand)(unsafe.Pointer(cmdPtr)).FclientData
	if (*TCommand)(unsafe.Pointer(cmdPtr)).FdeleteProc == __ccgo_fp(_cmdWrapperDeleteProc) {
		info = (*TCommand)(unsafe.Pointer(cmdPtr)).FdeleteData
		(*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FdeleteProc = (*TCmdWrapperInfo)(unsafe.Pointer(info)).FdeleteProc
		(*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FdeleteData = (*TCmdWrapperInfo)(unsafe.Pointer(info)).FdeleteData
		(*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FobjProc2 = (*TCmdWrapperInfo)(unsafe.Pointer(info)).Fproc
		(*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FobjClientData2 = (*TCmdWrapperInfo)(unsafe.Pointer(info)).FclientData
		if (*TCommand)(unsafe.Pointer(cmdPtr)).FobjProc == __ccgo_fp(_cmdWrapperProc) {
			(*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FisNativeObjectProc = int32(2)
		}
	} else {
		(*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FdeleteProc = (*TCommand)(unsafe.Pointer(cmdPtr)).FdeleteProc
		(*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FdeleteData = (*TCommand)(unsafe.Pointer(cmdPtr)).FdeleteData
		(*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FobjProc2 = __ccgo_fp(_cmdWrapper2Proc)
		(*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FobjClientData2 = cmdPtr
	}
	(*TTcl_CmdInfo)(unsafe.Pointer(infoPtr)).FnamespacePtr = (*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr
	return int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetCommandName --
 *
 *	Given a token returned by Tcl_CreateObjCommand, this function returns the
 *	current name of the command (which may have changed due to renaming).
 *
 * Results:
 *	The return value is the name of the given command.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetCommandName(tls *libc.TLS, dummy3505 uintptr, command TTcl_Command) (r uintptr) {
	/* Token for command returned by a previous
	 * call to Tcl_CreateObjCommand. The command must
	 * not have been deleted. */
	var cmdPtr, v1 uintptr
	_, _ = cmdPtr, v1
	cmdPtr = command
	if cmdPtr == libc.UintptrFromInt32(0) || (*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr == libc.UintptrFromInt32(0) {
		/*
		 * This should only happen if command was "created" after the
		 * interpreter began to be deleted, so there isn't really any command.
		 * Just return an empty string.
		 */
		return __ccgo_ts + 1945
	}
	if (*TTcl_HashTable)(unsafe.Pointer((*TTcl_HashEntry)(unsafe.Pointer((*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr)).FtablePtr)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer((*TTcl_HashEntry)(unsafe.Pointer((*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr)).FtablePtr)).FkeyType == -int32(1) {
		v1 = *(*uintptr)(unsafe.Pointer((*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr + 32))
	} else {
		v1 = (*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr + 32
	}
	return v1
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetCommandFullName --
 *
 *	Given a token returned by, e.g., Tcl_CreateObjCommand or Tcl_FindCommand,
 *	this function appends to an object the command's full name, qualified
 *	by a sequence of parent namespace names. The command's fully-qualified
 *	name may have changed due to renaming.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The command's fully-qualified name is appended to the string
 *	representation of objPtr.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetCommandFullName(tls *libc.TLS, interp uintptr, command TTcl_Command, objPtr uintptr) {
	/* Points to the object onto which the
	 * command's full name is appended. */
	var cmdPtr, iPtr, name, v1 uintptr
	_, _, _, _ = cmdPtr, iPtr, name, v1
	iPtr = interp
	cmdPtr = command
	/*
	 * Add the full name of the containing namespace, followed by the "::"
	 * separator, and the command name.
	 */
	if cmdPtr != libc.UintptrFromInt32(0) && (*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr != libc.UintptrFromInt32(0) {
		if (*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr != libc.UintptrFromInt32(0) {
			XTcl_AppendToObj(tls, objPtr, (*TNamespace)(unsafe.Pointer((*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr)).FfullName, int64(-libc.Int32FromInt32(1)))
			if (*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr != (*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr {
				XTcl_AppendToObj(tls, objPtr, __ccgo_ts+7650, int64(2))
			}
		}
		if (*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr != libc.UintptrFromInt32(0) {
			if (*TTcl_HashTable)(unsafe.Pointer((*TTcl_HashEntry)(unsafe.Pointer((*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr)).FtablePtr)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer((*TTcl_HashEntry)(unsafe.Pointer((*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr)).FtablePtr)).FkeyType == -int32(1) {
				v1 = *(*uintptr)(unsafe.Pointer((*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr + 32))
			} else {
				v1 = (*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr + 32
			}
			name = v1
			XTcl_AppendToObj(tls, objPtr, name, int64(-libc.Int32FromInt32(1)))
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DeleteCommand --
 *
 *	Remove the given command from the given interpreter.
 *
 * Results:
 *	0 is returned if the command was deleted successfully. -1 is returned
 *	if there didn't exist a command by that name.
 *
 * Side effects:
 *	cmdName will no longer be recognized as a valid command for interp.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DeleteCommand(tls *libc.TLS, interp uintptr, cmdName uintptr) (r int32) {
	/* Name of command to remove. */
	var cmd TTcl_Command
	_ = cmd
	/*
	 * Find the desired command and delete it.
	 */
	cmd = XTcl_FindCommand(tls, interp, cmdName, libc.UintptrFromInt32(0), 0)
	if cmd == libc.UintptrFromInt32(0) {
		return -int32(1)
	}
	return XTcl_DeleteCommandFromToken(tls, interp, cmd)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DeleteCommandFromToken --
 *
 *	Removes the given command from the given interpreter. This function
 *	resembles Tcl_DeleteCommand, but takes a Tcl_Command token instead of
 *	a command name for efficiency.
 *
 * Results:
 *	0 is returned if the command was deleted successfully. -1 is returned
 *	if there didn't exist a command by that name.
 *
 * Side effects:
 *	The command specified by "cmd" will no longer be recognized as a valid
 *	command for "interp".
 *
 *----------------------------------------------------------------------
 */

func XTcl_DeleteCommandFromToken(tls *libc.TLS, interp uintptr, cmd TTcl_Command) (r int32) {
	/* Token for command to delete. */
	var cmdPtr, iPtr, nextPtr, nextRefPtr, refPtr, tracePtr, v2, v5 uintptr
	var importCmd TTcl_Command
	var v1, v4 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _ = cmdPtr, iPtr, importCmd, nextPtr, nextRefPtr, refPtr, tracePtr, v1, v2, v4, v5
	iPtr = interp
	cmdPtr = cmd
	/*
	 * The code here is tricky. We can't delete the hash table entry before
	 * invoking the deletion callback because there are cases where the
	 * deletion callback needs to invoke the command (e.g. object systems such
	 * as OTcl). However, this means that the callback could try to delete or
	 * rename the command. The deleted flag allows us to detect these cases
	 * and skip nested deletes.
	 */
	if (*TCommand)(unsafe.Pointer(cmdPtr)).Fflags&int32(CMD_DYING) != 0 {
		/*
		 * Another deletion is already in progress. Remove the hash table
		 * entry now, but don't invoke a callback or free the command
		 * structure. Take care to only remove the hash entry if it has not
		 * already been removed; otherwise if we manage to hit this function
		 * three times, everything goes up in smoke. [Bug 1220058]
		 */
		if (*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr != libc.UintptrFromInt32(0) {
			XTcl_DeleteHashEntry(tls, (*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr)
			(*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr = libc.UintptrFromInt32(0)
		}
		/*
		 * Bump the command epoch counter. This will invalidate all cached
		 * references that point to this command.
		 */
		(*TCommand)(unsafe.Pointer(cmdPtr)).FcmdEpoch++
		return 0
	}
	/*
	 * We must delete this command, even though both traces and delete procs
	 * may try to avoid this (renaming the command etc). Also traces and
	 * delete procs may try to delete the command themselves. This flag
	 * declares that a delete is in progress and that recursive deletes should
	 * be ignored.
	 */
	*(*int32)(unsafe.Pointer(cmdPtr + 88)) |= int32(CMD_DYING)
	/*
	 * Call each functions and then delete the trace.
	 */
	(*TNamespace)(unsafe.Pointer((*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr)).FrefCount++
	if (*TCommand)(unsafe.Pointer(cmdPtr)).FtracePtr != libc.UintptrFromInt32(0) {
		/* CallCommandTraces() does not cmdPtr, that's
		 * done just before Tcl_DeleteCommandFromToken() returns */
		_CallCommandTraces(tls, iPtr, cmdPtr, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), int32(TCL_TRACE_DELETE))
		/*
		 * Now delete these traces.
		 */
		tracePtr = (*TCommand)(unsafe.Pointer(cmdPtr)).FtracePtr
		for tracePtr != libc.UintptrFromInt32(0) {
			nextPtr = (*TCommandTrace)(unsafe.Pointer(tracePtr)).FnextPtr
			v2 = tracePtr + 32
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if v1 <= int64(1) {
				XTclpFree(tls, tracePtr)
			}
			tracePtr = nextPtr
		}
		(*TCommand)(unsafe.Pointer(cmdPtr)).FtracePtr = libc.UintptrFromInt32(0)
	}
	/*
	 * The list of commands exported from the namespace might have changed.
	 * However, we do not need to recompute this just yet; next time we need
	 * the info will be soon enough.
	 */
	if (*TNamespace)(unsafe.Pointer((*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr)).FnumExportPatterns != 0 {
		(*TNamespace)(unsafe.Pointer((*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr)).FexportLookupEpoch++
	}
	if (*TNamespace)(unsafe.Pointer((*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr)).FcommandPathLength != 0 {
		(*TNamespace)(unsafe.Pointer((*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr)).FcmdRefEpoch++
	}
	XTclNsDecrRefCount(tls, (*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr)
	/*
	 * If the command being deleted has a compile function, increment the
	 * interpreter's compileEpoch to invalidate its compiled code. This makes
	 * sure that we don't later try to execute old code compiled with
	 * command-specific (i.e., inline) bytecodes for the now-deleted command.
	 * This field is checked in Tcl_EvalObj and ObjInterpProc, and code whose
	 * compilation epoch doesn't match is recompiled.
	 */
	if (*TCommand)(unsafe.Pointer(cmdPtr)).FcompileProc != libc.UintptrFromInt32(0) {
		(*TInterp)(unsafe.Pointer(iPtr)).FcompileEpoch++
	}
	if !((*TCommand)(unsafe.Pointer(cmdPtr)).Fflags&libc.Int32FromInt32(CMD_REDEF_IN_PROGRESS) != 0) {
		/*
		 * Delete any imports of this routine before deleting this routine itself.
		 * See issue 688fcc7082fa.
		 */
		refPtr = (*TCommand)(unsafe.Pointer(cmdPtr)).FimportRefPtr
		for {
			if !(refPtr != libc.UintptrFromInt32(0)) {
				break
			}
			nextRefPtr = (*TImportRef)(unsafe.Pointer(refPtr)).FnextPtr
			importCmd = (*TImportRef)(unsafe.Pointer(refPtr)).FimportedCmdPtr
			XTcl_DeleteCommandFromToken(tls, interp, importCmd)
			goto _3
		_3:
			;
			refPtr = nextRefPtr
		}
	}
	if (*TCommand)(unsafe.Pointer(cmdPtr)).FdeleteProc != libc.UintptrFromInt32(0) {
		/*
		 * Delete the command's client data. If this was an imported command
		 * created when a command was imported into a namespace, this client
		 * data will be a pointer to a ImportedCmdData structure describing
		 * the "real" command that this imported command refers to.
		 *
		 * If you are getting a crash during the call to deleteProc and
		 * cmdPtr->deleteProc is a pointer to the function free(), the most
		 * likely cause is that your extension allocated memory for the
		 * clientData argument to Tcl_CreateObjCommand with the Tcl_Alloc()
		 * macro and you are now trying to deallocate this memory with free()
		 * instead of Tcl_Free(). You should pass a pointer to your own method
		 * that calls Tcl_Free().
		 */
		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TCommand)(unsafe.Pointer(cmdPtr)).FdeleteProc})))(tls, (*TCommand)(unsafe.Pointer(cmdPtr)).FdeleteData)
	}
	/*
	 * Don't use hPtr to delete the hash entry here, because it's possible
	 * that the deletion callback renamed the command. Instead, use
	 * cmdPtr->hptr, and make sure that no-one else has already deleted the
	 * hash entry.
	 */
	if (*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr != libc.UintptrFromInt32(0) {
		XTcl_DeleteHashEntry(tls, (*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr)
		(*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr = libc.UintptrFromInt32(0)
		/*
		 * Bump the command epoch counter. This will invalidate all cached
		 * references that point to this command.
		 */
		(*TCommand)(unsafe.Pointer(cmdPtr)).FcmdEpoch++
	}
	/*
	 * A number of tests for particular kinds of commands are done by checking
	 * whether the objProc field holds a known value. Set the field to NULL so
	 * that such tests won't have false positives when applied to deleted
	 * commands.
	 */
	(*TCommand)(unsafe.Pointer(cmdPtr)).FobjProc = libc.UintptrFromInt32(0)
	/*
	 * Now free the Command structure, unless there is another reference to it
	 * from a CmdName Tcl object in some ByteCode code sequence. In that case,
	 * delay the cleanup until all references are either discarded (when a
	 * ByteCode is freed) or replaced by a new reference (when a cached
	 * CmdName Command reference is found to be invalid and
	 * TclNRExecuteByteCode looks up the command in the command hashtable).
	 */
	*(*int32)(unsafe.Pointer(cmdPtr + 88)) |= int32(CMD_DEAD)
	v5 = cmdPtr + 16
	v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
	*(*TTcl_Size)(unsafe.Pointer(v5))--
	if v4 <= int64(1) {
		XTclpFree(tls, cmdPtr)
	}
	return 0
}

/*
 *----------------------------------------------------------------------
 *
 * CallCommandTraces --
 *
 *	Abstraction of the code to call traces on a command.
 *
 * Results:
 *	Currently always NULL.
 *
 * Side effects:
 *	Anything; this may recursively evaluate scripts and code exists to do
 *	just that.
 *
 *----------------------------------------------------------------------
 */

func _CallCommandTraces(tls *libc.TLS, iPtr uintptr, cmdPtr uintptr, oldName uintptr, newName uintptr, flags int32) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Flags indicating the type of traces to
	 * trigger, either TCL_TRACE_DELETE or
	 * TCL_TRACE_RENAME. */
	var cachePtr, cachePtr1, oldNamePtr, result, tracePtr, v3, v5, v7 uintptr
	var state TTcl_InterpState
	var v2, v8 bool
	var v4, v6 TTcl_Size
	var _ /* active at bp+0 */ TActiveCommandTrace
	_, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, oldNamePtr, result, state, tracePtr, v2, v3, v4, v5, v6, v7, v8
	oldNamePtr = libc.UintptrFromInt32(0)
	state = libc.UintptrFromInt32(0)
	if (*TCommand)(unsafe.Pointer(cmdPtr)).Fflags&int32(CMD_TRACE_ACTIVE) != 0 {
		/*
		 * While a rename trace is active, we will not process any more rename
		 * traces; while a delete trace is active we will never reach here -
		 * because Tcl_DeleteCommandFromToken checks for the condition
		 * (cmdPtr->flags & CMD_DYING) and returns immediately when a
		 * command deletion is in progress. For all other traces, delete
		 * traces will not be invoked but a call to TraceCommandProc will
		 * ensure that tracePtr->clientData is freed whenever the command
		 * "oldName" is deleted.
		 */
		if (*TCommand)(unsafe.Pointer(cmdPtr)).Fflags&int32(TCL_TRACE_RENAME) != 0 {
			flags &= ^libc.Int32FromInt32(TCL_TRACE_RENAME)
		}
		if flags == 0 {
			return libc.UintptrFromInt32(0)
		}
	}
	*(*int32)(unsafe.Pointer(cmdPtr + 88)) |= int32(CMD_TRACE_ACTIVE)
	result = libc.UintptrFromInt32(0)
	(*(*TActiveCommandTrace)(unsafe.Pointer(bp))).FnextPtr = (*TInterp)(unsafe.Pointer(iPtr)).FactiveCmdTracePtr
	(*(*TActiveCommandTrace)(unsafe.Pointer(bp))).FreverseScan = 0
	(*TInterp)(unsafe.Pointer(iPtr)).FactiveCmdTracePtr = bp
	if flags&int32(TCL_TRACE_DELETE) != 0 {
		flags |= int32(TCL_TRACE_DESTROYED)
	}
	(*(*TActiveCommandTrace)(unsafe.Pointer(bp))).FcmdPtr = cmdPtr
	XTcl_Preserve(tls, iPtr)
	tracePtr = (*TCommand)(unsafe.Pointer(cmdPtr)).FtracePtr
	for {
		if !(tracePtr != libc.UintptrFromInt32(0)) {
			break
		}
		(*(*TActiveCommandTrace)(unsafe.Pointer(bp))).FnextTracePtr = (*TCommandTrace)(unsafe.Pointer(tracePtr)).FnextPtr
		if !((*TCommandTrace)(unsafe.Pointer(tracePtr)).Fflags&flags != 0) {
			goto _1
		}
		*(*int32)(unsafe.Pointer(cmdPtr + 88)) |= (*TCommandTrace)(unsafe.Pointer(tracePtr)).Fflags
		if oldName == libc.UintptrFromInt32(0) {
			if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				oldNamePtr = XTclThreadAllocObj(tls)
			} else {
				oldNamePtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(oldNamePtr + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(oldNamePtr)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(oldNamePtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(oldNamePtr)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(oldNamePtr)).FtypePtr = libc.UintptrFromInt32(0)
			(*TTcl_Obj)(unsafe.Pointer(oldNamePtr)).FrefCount++
			XTcl_GetCommandFullName(tls, iPtr, cmdPtr, oldNamePtr)
			if (*TTcl_Obj)(unsafe.Pointer(oldNamePtr)).Fbytes != 0 {
				v3 = (*TTcl_Obj)(unsafe.Pointer(oldNamePtr)).Fbytes
			} else {
				v3 = XTcl_GetStringFromObj(tls, oldNamePtr, libc.UintptrFromInt32(0))
			}
			oldName = v3
		}
		(*TCommandTrace)(unsafe.Pointer(tracePtr)).FrefCount++
		if state == libc.UintptrFromInt32(0) {
			state = XTcl_SaveInterpState(tls, iPtr, TCL_OK)
		}
		(*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{(*TCommandTrace)(unsafe.Pointer(tracePtr)).FtraceProc})))(tls, (*TCommandTrace)(unsafe.Pointer(tracePtr)).FclientData, iPtr, oldName, newName, flags)
		*(*int32)(unsafe.Pointer(cmdPtr + 88)) &= ^(*TCommandTrace)(unsafe.Pointer(tracePtr)).Fflags
		v5 = tracePtr + 32
		v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
		*(*TTcl_Size)(unsafe.Pointer(v5))--
		if v4 <= int64(1) {
			XTclpFree(tls, tracePtr)
		}
		goto _1
	_1:
		;
		tracePtr = (*(*TActiveCommandTrace)(unsafe.Pointer(bp))).FnextTracePtr
	}
	if state != 0 {
		XTcl_RestoreInterpState(tls, iPtr, state)
	}
	/*
	 * If a new object was created to hold the full oldName, free it now.
	 */
	if oldNamePtr != libc.UintptrFromInt32(0) {
		v7 = oldNamePtr
		v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
		*(*TTcl_Size)(unsafe.Pointer(v7))--
		if !(v6 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(oldNamePtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(oldNamePtr)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(oldNamePtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(oldNamePtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(oldNamePtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(oldNamePtr)).Flength = int64(-libc.Int32FromInt32(1))
				if v8 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v8 {
					cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v8 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, oldNamePtr)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(oldNamePtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = oldNamePtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, oldNamePtr)
			}
		}
	}
	/*
	 * Restore the variable's flags, remove the record of our active traces,
	 * and then return.
	 */
	*(*int32)(unsafe.Pointer(cmdPtr + 88)) &= ^libc.Int32FromInt32(CMD_TRACE_ACTIVE)
	(*TInterp)(unsafe.Pointer(iPtr)).FactiveCmdTracePtr = (*(*TActiveCommandTrace)(unsafe.Pointer(bp))).FnextPtr
	XTcl_Release(tls, iPtr)
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * CancelEvalProc --
 *
 *	Marks this interpreter as being canceled. This causes current
 *	executions to be unwound as the interpreter enters a state where it
 *	refuses to execute more commands or handle [catch] or [try], yet the
 *	interpreter is still able to execute further commands after the
 *	cancelation is cleared (unlike if it is deleted).
 *
 * Results:
 *	The value given for the code argument.
 *
 * Side effects:
 *	Transfers a message from the cancellation message to the interpreter.
 *
 *----------------------------------------------------------------------
 */

func _CancelEvalProc(tls *libc.TLS, clientData uintptr, dummy3952 uintptr, code int32) (r int32) {
	/* Current return code from command. */
	var cancelInfo, iPtr uintptr
	_, _ = cancelInfo, iPtr
	cancelInfo = clientData
	if cancelInfo != libc.UintptrFromInt32(0) {
		XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_cancelLock)))
		iPtr = (*TCancelInfo)(unsafe.Pointer(cancelInfo)).Finterp
		if iPtr != libc.UintptrFromInt32(0) {
			/*
			 * Setting the CANCELED flag will cause the script in progress to
			 * be canceled as soon as possible. The core honors this flag at
			 * all the necessary places to ensure script cancellation is
			 * responsive. Extensions can check for this flag by calling
			 * Tcl_Canceled and checking if TCL_ERROR is returned or they can
			 * choose to ignore the script cancellation flag and the
			 * associated functionality altogether. Currently, the only other
			 * flag we care about here is the TCL_CANCEL_UNWIND flag (from
			 * Tcl_CancelEval). We do not want to simply combine all the flags
			 * from original Tcl_CancelEval call with the interp flags here
			 * just in case the caller passed flags that might cause behaviour
			 * unrelated to script cancellation.
			 */
			*(*int32)(unsafe.Pointer(iPtr + 368)) |= int32(CANCELED)
			if ((*TCancelInfo)(unsafe.Pointer(cancelInfo)).Fflags|int32(CANCELED))&int32(TCL_CANCEL_UNWIND) != 0 {
				*(*int32)(unsafe.Pointer(iPtr + 368)) |= int32(TCL_CANCEL_UNWIND)
			}
			/*
			 * Now, we must set the script cancellation flags on all the child
			 * interpreters belonging to this one.
			 */
			XTclSetChildCancelFlags(tls, iPtr, (*TCancelInfo)(unsafe.Pointer(cancelInfo)).Fflags|int32(CANCELED), 0)
			/*
			 * Create the result object now so that Tcl_Canceled can avoid
			 * locking the cancelLock mutex.
			 */
			if (*TCancelInfo)(unsafe.Pointer(cancelInfo)).Fresult != libc.UintptrFromInt32(0) {
				XTcl_SetStringObj(tls, (*TInterp)(unsafe.Pointer(iPtr)).FasyncCancelMsg, (*TCancelInfo)(unsafe.Pointer(cancelInfo)).Fresult, (*TCancelInfo)(unsafe.Pointer(cancelInfo)).Flength)
			} else {
				XTcl_SetObjLength(tls, (*TInterp)(unsafe.Pointer(iPtr)).FasyncCancelMsg, 0)
			}
		}
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_cancelLock)))
	}
	return code
}

/*
 *----------------------------------------------------------------------
 *
 * TclCleanupCommand --
 *
 *	This function frees up a Command structure unless it is still
 *	referenced from an interpreter's command hashtable or from a CmdName
 *	Tcl object representing the name of a command in a ByteCode
 *	instruction sequence.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Memory gets freed unless a reference to the Command structure still
 *	exists. In that case the cleanup is delayed until the command is
 *	deleted or when the last ByteCode referring to it is freed.
 *
 *----------------------------------------------------------------------
 */

func XTclCleanupCommand(tls *libc.TLS, cmdPtr uintptr) {
	/* Points to the Command structure to
	 * be freed. */
	var v1 TTcl_Size
	var v2 uintptr
	_, _ = v1, v2
	v2 = cmdPtr + 16
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclpFree(tls, cmdPtr)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclInterpReady --
 *
 *	Check if an interpreter is ready to eval commands or scripts, i.e., if
 *	it was not deleted and if the nesting level is not too high.
 *
 * Results:
 *	The return value is TCL_OK if it the interpreter is ready, TCL_ERROR
 *	otherwise.
 *
 * Side effects:
 *	The interpreter's result is cleared.
 *
 *----------------------------------------------------------------------
 */

func XTclInterpReady(tls *libc.TLS, interp uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var iPtr uintptr
	_ = iPtr
	iPtr = interp
	/*
	 * Reset the interpreter's result and clear out any previous error
	 * information.
	 */
	XTcl_ResetResult(tls, interp)
	/*
	 * If the interpreter has been deleted, return an error.
	 */
	if (*TInterp)(unsafe.Pointer(iPtr)).Fflags&int32(DELETED) != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+8241, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+8285, __ccgo_ts+8241, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FexecEnvPtr)).Frewind != 0 {
		return int32(TCL_ERROR)
	}
	/*
	 * Make sure the script being evaluated (if any) has not been canceled.
	 */
	if ((*TInterp)(unsafe.Pointer(iPtr)).Fflags&int32(CANCELED) != 0 || (*TInterp)(unsafe.Pointer(iPtr)).Fflags&int32(TCL_CANCEL_UNWIND) != 0) && TCL_OK != XTcl_Canceled(tls, interp, int32(TCL_LEAVE_ERR_MSG)) {
		return int32(TCL_ERROR)
	}
	/*
	 * Check depth of nested calls to Tcl_Eval: if this gets too large, it's
	 * probably because of an infinite loop somewhere.
	 */
	if (*TInterp)(unsafe.Pointer(iPtr)).FnumLevels <= (*TInterp)(unsafe.Pointer(iPtr)).FmaxNestingDepth {
		return TCL_OK
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+8293, int64(-libc.Int32FromInt32(1))))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+8338, __ccgo_ts+8344, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * TclResetCancellation --
 *
 *	Reset the script cancellation flags if the nesting level
 *	(iPtr->numLevels) for the interp is zero or argument force is
 *	non-zero.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	The script cancellation flags for the interp may be reset.
 *
 *----------------------------------------------------------------------
 */

func XTclResetCancellation(tls *libc.TLS, interp uintptr, force int32) (r int32) {
	var iPtr uintptr
	_ = iPtr
	iPtr = interp
	if iPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if force != 0 || (*TInterp)(unsafe.Pointer(iPtr)).FnumLevels == 0 {
		*(*int32)(unsafe.Pointer(iPtr + 368)) &= ^(libc.Int32FromInt32(CANCELED) | libc.Int32FromInt32(TCL_CANCEL_UNWIND))
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_Canceled --
 *
 *	Check if the script in progress has been canceled, i.e.,
 *	Tcl_CancelEval was called for this interpreter or any of its parent
 *	interpreters.
 *
 * Results:
 *	The return value is TCL_OK if the script evaluation has not been
 *	canceled, TCL_ERROR otherwise.
 *
 *	If "flags" contains TCL_LEAVE_ERR_MSG, an error message is returned in
 *	the interpreter's result object. Otherwise, the interpreter's result
 *	object is left unchanged. If "flags" contains TCL_CANCEL_UNWIND,
 *	TCL_ERROR will only be returned if the script evaluation is being
 *	completely unwound.
 *
 * Side effects:
 *	The CANCELED flag for the interp will be reset if it is set.
 *
 *----------------------------------------------------------------------
 */

func XTcl_Canceled(tls *libc.TLS, interp uintptr, flags int32) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var iPtr, id, message, v1 uintptr
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _ = iPtr, id, message, v1
	iPtr = interp
	/*
	 * Has the current script in progress for this interpreter been canceled
	 * or is the stack being unwound due to the previous script cancellation?
	 */
	if !((*TInterp)(unsafe.Pointer(iPtr)).Fflags&int32(CANCELED) != 0 || (*TInterp)(unsafe.Pointer(iPtr)).Fflags&int32(TCL_CANCEL_UNWIND) != 0) {
		return TCL_OK
	}
	/*
	 * The CANCELED flag is a one-shot flag that is reset immediately upon
	 * being detected; however, if the TCL_CANCEL_UNWIND flag is set we will
	 * continue to report that the script in progress has been canceled
	 * thereby allowing the evaluation stack for the interp to be fully
	 * unwound.
	 */
	*(*int32)(unsafe.Pointer(iPtr + 368)) &= ^libc.Int32FromInt32(CANCELED)
	/*
	 * The CANCELED flag was detected and reset; however, if the caller
	 * specified the TCL_CANCEL_UNWIND flag, we only return TCL_ERROR
	 * (indicating that the script in progress has been canceled) if the
	 * evaluation stack for the interp is being fully unwound.
	 */
	if flags&int32(TCL_CANCEL_UNWIND) != 0 && !((*TInterp)(unsafe.Pointer(iPtr)).Fflags&libc.Int32FromInt32(TCL_CANCEL_UNWIND) != 0) {
		return TCL_OK
	}
	/*
	 * If the TCL_LEAVE_ERR_MSG flags bit is set, place an error in the
	 * interp's result; otherwise, we leave it alone.
	 */
	if flags&int32(TCL_LEAVE_ERR_MSG) != 0 {
		message = libc.UintptrFromInt32(0)
		/*
		 * Setup errorCode variables so that we can differentiate between
		 * being canceled and unwound.
		 */
		if (*TInterp)(unsafe.Pointer(iPtr)).FasyncCancelMsg != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FasyncCancelMsg)).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FasyncCancelMsg)).Flength
				v1 = (*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FasyncCancelMsg)).Fbytes
			} else {
				v1 = XTcl_GetStringFromObj(tls, (*TInterp)(unsafe.Pointer(iPtr)).FasyncCancelMsg, bp)
			}
			message = v1
		} else {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
		}
		if (*TInterp)(unsafe.Pointer(iPtr)).Fflags&int32(TCL_CANCEL_UNWIND) != 0 {
			id = __ccgo_ts + 8350
			if *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
				message = __ccgo_ts + 8358
			}
		} else {
			id = __ccgo_ts + 8371
			if *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
				message = __ccgo_ts + 8379
			}
		}
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, message, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+8393, id, message, libc.UintptrFromInt32(0)))
	}
	/*
	 * Return TCL_ERROR to the caller (not necessarily just the Tcl core
	 * itself) that indicates further processing of the script or command in
	 * progress should halt gracefully and as soon as possible.
	 */
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_CancelEval --
 *
 *	This function schedules the cancellation of the current script in the
 *	given interpreter.
 *
 * Results:
 *	The return value is a standard Tcl completion code such as TCL_OK or
 *	TCL_ERROR. Since the interp may belong to a different thread, no error
 *	message can be left in the interp's result.
 *
 * Side effects:
 *	The script in progress in the specified interpreter will be canceled
 *	with TCL_ERROR after asynchronous handlers are invoked at the next
 *	Tcl_Canceled check.
 *
 *----------------------------------------------------------------------
 */

func XTcl_CancelEval(tls *libc.TLS, interp uintptr, resultObjPtr uintptr, clientData uintptr, flags int32) (r int32) {
	/* Collection of OR-ed bits that control
	 * the cancellation of the script. Only
	 * TCL_CANCEL_UNWIND is currently
	 * supported. */
	var cachePtr, cancelInfo, hPtr, result, v1, v3 uintptr
	var code int32
	var v2 TTcl_Size
	var v4 bool
	_, _, _, _, _, _, _, _, _ = cachePtr, cancelInfo, code, hPtr, result, v1, v2, v3, v4
	code = int32(TCL_ERROR)
	if interp == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_cancelLock)))
	if _cancelTableInitialized != int32(1) {
		/*
		 * No CancelInfo hash table (Tcl_CreateInterp has never been called?)
		 */
		goto done
	}
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_cancelTable)))).FfindProc})))(tls, uintptr(unsafe.Pointer(&_cancelTable)), interp)
	if hPtr == libc.UintptrFromInt32(0) {
		/*
		 * No CancelInfo record for this interpreter.
		 */
		goto done
	}
	cancelInfo = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
	/*
	 * Populate information needed by the interpreter thread to fulfill the
	 * cancellation request. Currently, clientData is ignored. If the
	 * TCL_CANCEL_UNWIND flags bit is set, the script in progress is not
	 * allowed to catch the script cancellation because the evaluation stack
	 * for the interp is completely unwound.
	 */
	if resultObjPtr != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(resultObjPtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(cancelInfo + 24)) = (*TTcl_Obj)(unsafe.Pointer(resultObjPtr)).Flength
			v1 = (*TTcl_Obj)(unsafe.Pointer(resultObjPtr)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, resultObjPtr, cancelInfo+24)
		}
		result = v1
		(*TCancelInfo)(unsafe.Pointer(cancelInfo)).Fresult = XTcl_Realloc(tls, (*TCancelInfo)(unsafe.Pointer(cancelInfo)).Fresult, libc.Uint64FromInt64((*TCancelInfo)(unsafe.Pointer(cancelInfo)).Flength))
		libc.Xmemcpy(tls, (*TCancelInfo)(unsafe.Pointer(cancelInfo)).Fresult, result, libc.Uint64FromInt64((*TCancelInfo)(unsafe.Pointer(cancelInfo)).Flength))
		v3 = resultObjPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if !(v2 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(resultObjPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(resultObjPtr)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(resultObjPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(resultObjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(resultObjPtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(resultObjPtr)).Flength = int64(-libc.Int32FromInt32(1))
				if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v4 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, resultObjPtr)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(resultObjPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = resultObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, resultObjPtr)
			}
		} /* Discard their result object. */
	} else {
		(*TCancelInfo)(unsafe.Pointer(cancelInfo)).Fresult = libc.UintptrFromInt32(0)
		(*TCancelInfo)(unsafe.Pointer(cancelInfo)).Flength = 0
	}
	(*TCancelInfo)(unsafe.Pointer(cancelInfo)).FclientData = clientData
	(*TCancelInfo)(unsafe.Pointer(cancelInfo)).Fflags = flags
	XTcl_AsyncMark(tls, (*TCancelInfo)(unsafe.Pointer(cancelInfo)).Fasync)
	code = TCL_OK
	goto done
done:
	;
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_cancelLock)))
	return code
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_InterpActive --
 *
 *	Returns non-zero if the specified interpreter is in use, i.e. if there
 *	is an evaluation currently active in the interpreter.
 *
 * Results:
 *	See above.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_InterpActive(tls *libc.TLS, interp uintptr) (r int32) {
	return libc.BoolInt32((*TInterp)(unsafe.Pointer(interp)).FnumLevels > 0)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_EvalObjv --
 *
 *	This function evaluates a Tcl command that has already been parsed
 *	into words, with one Tcl_Obj holding each word.
 *
 * Results:
 *	The return value is a standard Tcl completion code such as TCL_OK or
 *	TCL_ERROR. A result or error message is left in interp's result.
 *
 * Side effects:
 *	Always pushes a callback. Other side effects depend on the command.
 *
 *----------------------------------------------------------------------
 */

func XTcl_EvalObjv(tls *libc.TLS, interp uintptr, objc TTcl_Size, objv uintptr, flags int32) (r int32) {
	/* Collection of OR-ed bits that control the
	 * evaluation of the script. Only
	 * TCL_EVAL_GLOBAL, TCL_EVAL_INVOKE and
	 * TCL_EVAL_NOERR are currently supported. */
	var result int32
	var rootPtr uintptr
	_, _ = result, rootPtr
	rootPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	result = XTclNREvalObjv(tls, interp, objc, objv, flags, libc.UintptrFromInt32(0))
	return XTclNRRunCallbacks(tls, interp, result, rootPtr)
}

func XTclNREvalObjv(tls *libc.TLS, interp uintptr, objc TTcl_Size, objv uintptr, flags int32, cmdPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* NULL if the Command is to be looked up
	 * here, otherwise the pointer to the
	 * requested Command struct to be invoked. */
	var _objPtr, _objPtr1, cachePtr, cachePtr1, iPtr uintptr
	var v1, v2 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	var _ /* _callbackPtr at bp+8 */ uintptr
	_, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, cachePtr1, iPtr, v1, v2
	iPtr = interp
	/*
	 * data[1] stores a marker for use by tailcalls; it will be set to 1 by
	 * command redirectors (imports, alias, ensembles) so that tailcall skips
	 * this callback (that marks the end of the target command) and goes back
	 * to the end of the source command.
	 */
	if (*TInterp)(unsafe.Pointer(iPtr)).FdeferredCallbacks != 0 {
		(*TInterp)(unsafe.Pointer(iPtr)).FdeferredCallbacks = libc.UintptrFromInt32(0)
	} else {
		if v1 = interp == libc.UintptrFromInt32(0); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			_objPtr = XTclThreadAllocObj(tls)
		} else {
			_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(_objPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(_NRCommand)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
		(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
	}
	(*TInterp)(unsafe.Pointer(iPtr)).FnumLevels++
	if v2 = interp == libc.UintptrFromInt32(0); !v2 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr1 = XTclThreadAllocObj(tls)
	} else {
		_objPtr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr1 + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 8)) = _objPtr1
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FprocPtr = __ccgo_fp(_EvalObjvCore)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8)) = cmdPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 1*8)) = uintptr(int64(flags))
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 2*8)) = uintptr(objc)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 3*8)) = objv
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
	return TCL_OK
}

func _EvalObjvCore(tls *libc.TLS, data uintptr, interp uintptr, dummy4438 int32) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, cachePtr, cachePtr1, commandPtr, iPtr, lookupNsPtr, objv, preCmdPtr, v1, v3, v5, v8 uintptr
	var code, enterTracesDone, flags int32
	var objc, v2, v4 TTcl_Size
	var v6, v7 bool
	var _ /* _callbackPtr at bp+16 */ uintptr
	var _ /* _callbackPtr at bp+8 */ uintptr
	var _ /* cmdPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, cachePtr, cachePtr1, code, commandPtr, enterTracesDone, flags, iPtr, lookupNsPtr, objc, objv, preCmdPtr, v1, v2, v3, v4, v5, v6, v7, v8
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	preCmdPtr = *(*uintptr)(unsafe.Pointer(data))
	flags = int32(int64(*(*uintptr)(unsafe.Pointer(data + 1*8))))
	objc = int64(*(*uintptr)(unsafe.Pointer(data + 2*8)))
	objv = *(*uintptr)(unsafe.Pointer(data + 3*8))
	iPtr = interp
	lookupNsPtr = libc.UintptrFromInt32(0)
	enterTracesDone = 0
	/*
	 * Push records for task to be done on return, in INVERSE order. First, if
	 * needed, the exception handlers (as they should happen last).
	 */
	if !(flags&libc.Int32FromInt32(TCL_EVAL_NOERR) != 0) {
		_TEOV_PushExceptionHandlers(tls, interp, objc, objv, flags)
	}
	if TCL_OK != XTclInterpReady(tls, interp) {
		return int32(TCL_ERROR)
	}
	if objc == 0 {
		return TCL_OK
	}
	if (*TInterp)(unsafe.Pointer(iPtr)).Flimit.Fexceeded != 0 {
		/* generate error message if not yet already logged at this stage */
		if !((*TInterp)(unsafe.Pointer(iPtr)).Fflags&libc.Int32FromInt32(ERR_ALREADY_LOGGED) != 0) {
			XTcl_LimitCheck(tls, interp)
		}
		return int32(TCL_ERROR)
	}
	/*
	 * Configure evaluation context to match the requested flags.
	 */
	if (*TInterp)(unsafe.Pointer(iPtr)).FlookupNsPtr != 0 {
		/*
		 * Capture the namespace we should do command name resolution in, as
		 * instructed by our caller sneaking it in to us in a private interp
		 * field.  Clear that field right away so we cannot possibly have its
		 * use leak where it should not.  The sneaky message pass is done.
		 *
		 * Use of this mechanism overrides the TCL_EVAL_GLOBAL flag.
		 * TODO: Is that a bug?
		 */
		lookupNsPtr = (*TInterp)(unsafe.Pointer(iPtr)).FlookupNsPtr
		(*TInterp)(unsafe.Pointer(iPtr)).FlookupNsPtr = libc.UintptrFromInt32(0)
	} else {
		if flags&int32(TCL_EVAL_INVOKE) != 0 {
			lookupNsPtr = (*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr
		} else {
			/*
			 * TCL_EVAL_INVOKE was not set: clear rewrite rules
			 */
			XTclResetRewriteEnsemble(tls, interp, int32(1))
			if flags&int32(TCL_EVAL_GLOBAL) != 0 {
				_TEOV_SwitchVarFrame(tls, interp)
				lookupNsPtr = (*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr
			}
		}
	}
	/*
	 * Lookup the Command to dispatch.
	 */
	goto reresolve
reresolve:
	;
	if preCmdPtr != 0 {
		/*
		 * Caller gave it to us.
		 */
		if !((*TCommand)(unsafe.Pointer(preCmdPtr)).Fflags&libc.Int32FromInt32(CMD_DEAD) != 0) {
			/*
			 * So long as it exists, use it.
			 */
			*(*uintptr)(unsafe.Pointer(bp)) = preCmdPtr
		} else {
			if flags&int32(TCL_EVAL_NORESOLVE) != 0 {
				/*
				 * When it's been deleted, and we're told not to attempt resolving
				 * it ourselves, all we can do is raise an error.
				 */
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+8400, 0))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+32, __ccgo_ts+2004, __ccgo_ts+8436, __ccgo_ts+8441, libc.UintptrFromInt32(0)))
				return int32(TCL_ERROR)
			}
		}
	}
	if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
		*(*uintptr)(unsafe.Pointer(bp)) = _TEOV_LookupCmdFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv)), lookupNsPtr)
		if !(*(*uintptr)(unsafe.Pointer(bp)) != 0) {
			return _TEOV_NotFound(tls, interp, objc, objv, lookupNsPtr)
		}
	}
	if enterTracesDone != 0 || (*TInterp)(unsafe.Pointer(iPtr)).FtracePtr != 0 || (*TCommand)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fflags&int32(CMD_HAS_EXEC_TRACES) != 0 {
		if flags&int32(TCL_EVAL_SOURCE_IN_FRAME) != 0 {
			v1 = (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr
		} else {
			v1 = libc.UintptrFromInt32(0)
		}
		commandPtr = XTclGetSourceFromFrame(tls, v1, objc, objv)
		(*TTcl_Obj)(unsafe.Pointer(commandPtr)).FrefCount++
		if !(enterTracesDone != 0) {
			code = _TEOV_RunEnterTraces(tls, interp, bp, commandPtr, objc, objv)
			/*
			 * Send any exception from enter traces back as an exception
			 * raised by the traced command.
			 * TODO: Is this a bug?  Letting an execution trace BREAK or
			 * CONTINUE or RETURN in the place of the traced command?  Would
			 * either converting all exceptions to TCL_ERROR, or just
			 * swallowing them be better?  (Swallowing them has the problem of
			 * permanently hiding program errors.)
			 */
			if code != TCL_OK {
				_objPtr = commandPtr
				v3 = _objPtr
				v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
				*(*TTcl_Size)(unsafe.Pointer(v3))--
				if v2 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
				return code
			}
			/*
			 * If the enter traces made the resolved cmdPtr unusable, go back
			 * and resolve again, but next time don't run enter traces again.
			 */
			if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
				enterTracesDone = int32(1)
				_objPtr1 = commandPtr
				v5 = _objPtr1
				v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
				*(*TTcl_Size)(unsafe.Pointer(v5))--
				if v4 <= int64(1) {
					XTclFreeObj(tls, _objPtr1)
				}
				goto reresolve
			}
		}
		/*
		 * Schedule leave traces.  Raise the refCount on the resolved cmdPtr,
		 * so that when it passes to the leave traces we know it's still
		 * valid.
		 */
		(*TCommand)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FrefCount++
		if v6 = interp == libc.UintptrFromInt32(0); !v6 {
			cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
		}
		if v6 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			_objPtr2 = XTclThreadAllocObj(tls)
		} else {
			_objPtr2 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(_objPtr2 + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = _objPtr2
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FprocPtr = __ccgo_fp(_TEOV_RunLeaveTraces)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8)) = uintptr(objc)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 1*8)) = commandPtr
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 2*8)) = *(*uintptr)(unsafe.Pointer(bp))
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 3*8)) = objv
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
		(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
	}
	if v7 = interp == libc.UintptrFromInt32(0); !v7 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v7 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr3 = XTclThreadAllocObj(tls)
	} else {
		_objPtr3 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr3 + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 16)) = _objPtr3
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FprocPtr = __ccgo_fp(_Dispatch)
	if (*TCommand)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnreProc != 0 {
		v8 = (*TCommand)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnreProc
	} else {
		v8 = (*TCommand)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FobjProc
	}
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8)) = v8
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 1*8)) = (*TCommand)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FobjClientData
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 2*8)) = uintptr(objc)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 3*8)) = objv
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 16))
	return TCL_OK
}

func _Dispatch(tls *libc.TLS, data uintptr, interp uintptr, dummy4602 int32) (r int32) {
	var clientData, iPtr, objProc, objv uintptr
	var objc TTcl_Size
	_, _, _, _, _ = clientData, iPtr, objProc, objc, objv
	objProc = *(*uintptr)(unsafe.Pointer(data))
	clientData = *(*uintptr)(unsafe.Pointer(data + 1*8))
	objc = int64(*(*uintptr)(unsafe.Pointer(data + 2*8)))
	objv = *(*uintptr)(unsafe.Pointer(data + 3*8))
	iPtr = interp
	(*TInterp)(unsafe.Pointer(iPtr)).FcmdCount++
	return (*(*func(*libc.TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{objProc})))(tls, clientData, interp, int32(objc), objv)
}

func XTclNRRunCallbacks(tls *libc.TLS, interp uintptr, result int32, rootPtr uintptr) (r int32) {
	/* All callbacks down to rootPtr not inclusive
	 * are to be run. */
	var cachePtr, callbackPtr, procPtr uintptr
	var v1 bool
	_, _, _, _ = cachePtr, callbackPtr, procPtr, v1
	for (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr != rootPtr {
		callbackPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
		procPtr = (*TNRE_callback)(unsafe.Pointer(callbackPtr)).FprocPtr
		(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = (*TNRE_callback)(unsafe.Pointer(callbackPtr)).FnextPtr
		result = (*(*func(*libc.TLS, uintptr, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{procPtr})))(tls, callbackPtr+8, interp, result)
		if v1 = interp == libc.UintptrFromInt32(0); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
		}
		if v1 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
			XTclThreadFreeObj(tls, callbackPtr)
		} else {
			(*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(callbackPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = callbackPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
		}
	}
	return result
}

func _NRCommand(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, cachePtr, iPtr, listPtr uintptr
	var v1, v5 bool
	var v2, v3, v4 int32
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, iPtr, listPtr, v1, v2, v3, v4, v5
	iPtr = interp
	(*TInterp)(unsafe.Pointer(iPtr)).FnumLevels--
	/*
	 * If there is a tailcall, schedule it next
	 */
	if *(*uintptr)(unsafe.Pointer(data + 1*8)) != 0 && *(*uintptr)(unsafe.Pointer(data + 1*8)) != uintptr(int64(libc.Int32FromInt32(1))) {
		listPtr = *(*uintptr)(unsafe.Pointer(data + 1*8))
		*(*uintptr)(unsafe.Pointer(data + 1*8)) = libc.UintptrFromInt32(0)
		if v1 = interp == libc.UintptrFromInt32(0); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			_objPtr = XTclThreadAllocObj(tls)
		} else {
			_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(_objPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(XTclNRTailcallEval)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = listPtr
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
		(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
	}
	/* OPT ??
	 * Do not interrupt a series of cleanups with async or limit checks:
	 * just check at the end?
	 */
	if *(*int32)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FasyncReadyPtr)) != 0 {
		result = XTcl_AsyncInvoke(tls, interp, result)
	}
	if result == TCL_OK && ((*TInterp)(unsafe.Pointer(iPtr)).Fflags&int32(CANCELED) != 0 || (*TInterp)(unsafe.Pointer(iPtr)).Fflags&int32(TCL_CANCEL_UNWIND) != 0) {
		result = XTcl_Canceled(tls, interp, int32(TCL_LEAVE_ERR_MSG))
	}
	if v5 = result == TCL_OK; v5 {
		if (*TInterp)(unsafe.Pointer(iPtr)).Flimit.Factive == 0 {
			v2 = 0
		} else {
			(*TInterp)(unsafe.Pointer(iPtr)).Flimit.FgranularityTicker++
			if (*TInterp)(unsafe.Pointer(iPtr)).Flimit.Factive&int32(TCL_LIMIT_COMMANDS) != 0 && ((*TInterp)(unsafe.Pointer(iPtr)).Flimit.FcmdGranularity == int32(1) || (*TInterp)(unsafe.Pointer(iPtr)).Flimit.FgranularityTicker%(*TInterp)(unsafe.Pointer(iPtr)).Flimit.FcmdGranularity == 0) {
				v3 = int32(1)
			} else {
				if (*TInterp)(unsafe.Pointer(iPtr)).Flimit.Factive&int32(TCL_LIMIT_TIME) != 0 && ((*TInterp)(unsafe.Pointer(iPtr)).Flimit.FtimeGranularity == int32(1) || (*TInterp)(unsafe.Pointer(iPtr)).Flimit.FgranularityTicker%(*TInterp)(unsafe.Pointer(iPtr)).Flimit.FtimeGranularity == 0) {
					v4 = int32(1)
				} else {
					v4 = 0
				}
				v3 = v4
			}
			v2 = v3
		}
	}
	if v5 && v2 != 0 {
		result = XTcl_LimitCheck(tls, interp)
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * TEOV_Exception	 -
 * TEOV_LookupCmdFromObj -
 * TEOV_RunEnterTraces	 -
 * TEOV_RunLeaveTraces	 -
 * TEOV_NotFound	 -
 *
 *	These are helper functions for Tcl_EvalObjv.
 *
 *----------------------------------------------------------------------
 */

func _TEOV_PushExceptionHandlers(tls *libc.TLS, interp uintptr, objc TTcl_Size, objv uintptr, flags int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, _objPtr1, cachePtr, cachePtr1, iPtr uintptr
	var v1, v2 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	var _ /* _callbackPtr at bp+8 */ uintptr
	_, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, cachePtr1, iPtr, v1, v2
	iPtr = interp
	/*
	 * If any error processing is necessary, push the appropriate records.
	 * Note that we have to push them in the inverse order: first the one that
	 * has to run last.
	 */
	if !(flags&libc.Int32FromInt32(TCL_EVAL_INVOKE) != 0) {
		/*
		 * Error messages
		 */
		if v1 = interp == libc.UintptrFromInt32(0); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			_objPtr = XTclThreadAllocObj(tls)
		} else {
			_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(_objPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(_TEOV_Error)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = uintptr(objc)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = objv
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
		(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
	}
	if (*TInterp)(unsafe.Pointer(iPtr)).FnumLevels == int64(1) {
		/*
		 * No CONTINUE or BREAK at level 0, manage RETURN
		 */
		if v2 = interp == libc.UintptrFromInt32(0); !v2 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
		}
		if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			_objPtr1 = XTclThreadAllocObj(tls)
		} else {
			_objPtr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(_objPtr1 + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = _objPtr1
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FprocPtr = __ccgo_fp(_TEOV_Exception)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8)) = uintptr(int64((*TInterp)(unsafe.Pointer(iPtr)).FevalFlags))
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
		(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
	}
}

func _TEOV_SwitchVarFrame(tls *libc.TLS, interp uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, cachePtr, iPtr uintptr
	var v1 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _, _ = _objPtr, cachePtr, iPtr, v1
	iPtr = interp
	/*
	 * Change the varFrame to be the rootVarFrame, and push a record to
	 * restore things at the end.
	 */
	if v1 = interp == libc.UintptrFromInt32(0); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(_TEOV_RestoreVarFrame)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = (*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
	(*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr = (*TInterp)(unsafe.Pointer(iPtr)).FrootFramePtr
}

func _TEOV_RestoreVarFrame(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	(*TInterp)(unsafe.Pointer(interp)).FvarFramePtr = *(*uintptr)(unsafe.Pointer(data))
	return result
}

func _TEOV_Exception(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	var allowExceptions int32
	var iPtr uintptr
	_, _ = allowExceptions, iPtr
	iPtr = interp
	allowExceptions = int32(int64(*(*uintptr)(unsafe.Pointer(data))) & libc.Int64FromInt32(TCL_ALLOW_EXCEPTIONS))
	if result != TCL_OK {
		if result == int32(TCL_RETURN) {
			result = XTclUpdateReturnInfo(tls, iPtr)
		}
		if result != TCL_OK && result != int32(TCL_ERROR) && !(allowExceptions != 0) {
			_ProcessUnexpectedResult(tls, interp, result)
			result = int32(TCL_ERROR)
		}
	}
	/*
	 * We are returning to level 0, so should process TclResetCancellation. As
	 * numLevels has not *yet* been decreased, do not call it: do the thing
	 * here directly.
	 */
	*(*int32)(unsafe.Pointer(iPtr + 368)) &= ^(libc.Int32FromInt32(CANCELED) | libc.Int32FromInt32(TCL_CANCEL_UNWIND))
	return result
}

func _TEOV_Error(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, cmdString, iPtr, listPtr, objv, v1, v3 uintptr
	var objc, v2 TTcl_Size
	var _ /* cmdLen at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _ = _objPtr, cmdString, iPtr, listPtr, objc, objv, v1, v2, v3
	iPtr = interp
	objc = int64(*(*uintptr)(unsafe.Pointer(data)))
	objv = *(*uintptr)(unsafe.Pointer(data + 1*8))
	if result == int32(TCL_ERROR) && !((*TInterp)(unsafe.Pointer(iPtr)).Fflags&libc.Int32FromInt32(ERR_ALREADY_LOGGED) != 0) {
		/*
		 * If there was an error, a command string will be needed for the
		 * error log: get it out of the itemPtr. The details depend on the
		 * type.
		 */
		listPtr = XTcl_NewListObj(tls, objc, objv)
		if (*TTcl_Obj)(unsafe.Pointer(listPtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(listPtr)).Flength
			v1 = (*TTcl_Obj)(unsafe.Pointer(listPtr)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, listPtr, bp)
		}
		cmdString = v1
		XTcl_LogCommandInfo(tls, interp, cmdString, cmdString, *(*TTcl_Size)(unsafe.Pointer(bp)))
		_objPtr = listPtr
		v3 = _objPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	*(*int32)(unsafe.Pointer(iPtr + 368)) &= ^libc.Int32FromInt32(ERR_ALREADY_LOGGED)
	return result
}

func _TEOV_NotFound(tls *libc.TLS, interp uintptr, objc TTcl_Size, objv uintptr, lookupNsPtr uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var _objPtr, _objPtr1, cachePtr, cachePtr1, cmdPtr, currNsPtr, iPtr, newObjv, savedNsPtr, varFramePtr, v10, v6, v7 uintptr
	var i, newObjc, v9 TTcl_Size
	var v1, v11 bool
	var v3, v4 int64
	var _ /* _callbackPtr at bp+16 */ uintptr
	var _ /* handlerObjc at bp+0 */ TTcl_Size
	var _ /* handlerObjv at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, cachePtr1, cmdPtr, currNsPtr, i, iPtr, newObjc, newObjv, savedNsPtr, varFramePtr, v1, v10, v11, v3, v4, v6, v7, v9
	iPtr = interp
	varFramePtr = (*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr
	currNsPtr = libc.UintptrFromInt32(0) /* Used to check for and invoke any registered
	 * unknown command handler for the current
	 * namespace (TIP 181). */
	savedNsPtr = libc.UintptrFromInt32(0)
	currNsPtr = (*TCallFrame)(unsafe.Pointer(varFramePtr)).FnsPtr
	if currNsPtr == libc.UintptrFromInt32(0) || (*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr == libc.UintptrFromInt32(0) {
		currNsPtr = (*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr
		if currNsPtr == libc.UintptrFromInt32(0) {
			XTcl_Panic(tls, __ccgo_ts+8456, 0)
		}
	}
	/*
	 * Check to see if the resolution namespace has lost its unknown handler.
	 * If so, reset it to "::unknown".
	 */
	if (*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr == libc.UintptrFromInt32(0) {
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			(*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr = XTclThreadAllocObj(tls)
		} else {
			(*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer((*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr)).FrefCount = 0
		if libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr)).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr)).Fbytes, __ccgo_ts+8501, libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr)).Fbytes + uintptr(libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(10) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr)).FtypePtr = libc.UintptrFromInt32(0)
		(*TTcl_Obj)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr)).FrefCount++
	}
	/*
	 * Get the list of words for the unknown handler and allocate enough space
	 * to hold both the handler prefix and all words of the command invocation
	 * itself.
	 */
	if (*TTcl_Obj)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer((*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr + 32))).Fptr2)).FspanStart
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer((*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr + 32))).Fptr1 + 40 + uintptr(v3)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr + 32))).Fptr2 != 0 {
			v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer((*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr + 32))).Fptr2)).FspanLength
		} else {
			v4 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer((*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v4
		_ = libc.Int32FromInt32(TCL_OK)
	} else {
		XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), (*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr, bp, bp+8)
	}
	newObjc = objc + *(*TTcl_Size)(unsafe.Pointer(bp))
	newObjv = XTclStackAlloc(tls, interp, uint64(8)*libc.Uint64FromInt64(newObjc))
	/*
	 * Copy command prefix from unknown handler and add on the real command's
	 * full argument list. Note that we only use memcpy() once because we have
	 * to increment the reference count of all the handler arguments anyway.
	 */
	i = 0
	for {
		if !(i < *(*TTcl_Size)(unsafe.Pointer(bp))) {
			break
		}
		*(*uintptr)(unsafe.Pointer(newObjv + uintptr(i)*8)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8))
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(newObjv + uintptr(i)*8)))).FrefCount++
		goto _5
	_5:
		;
		i++
	}
	libc.Xmemcpy(tls, newObjv+uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))*8, objv, uint64(8)*libc.Uint64FromInt64(objc))
	/*
	 * Look up and invoke the handler (by recursive call to this function). If
	 * there is no handler at all, instead of doing the recursive call we just
	 * generate a generic error message; it would be an infinite-recursion
	 * nightmare otherwise.
	 *
	 * In this case we worry a bit less about recursion for now, and call the
	 * "blocking" interface.
	 */
	cmdPtr = _TEOV_LookupCmdFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(newObjv)), lookupNsPtr)
	if cmdPtr == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes != 0 {
			v6 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes
		} else {
			v6 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+8511, libc.VaList(bp+32, v6)))
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes != 0 {
			v7 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes
		} else {
			v7 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv)), libc.UintptrFromInt32(0))
		}
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+32, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+8118, v7, libc.UintptrFromInt32(0)))
		/*
		 * Release any resources we locked and allocated during the handler
		 * call.
		 */
		i = 0
		for {
			if !(i < *(*TTcl_Size)(unsafe.Pointer(bp))) {
				break
			}
			_objPtr = *(*uintptr)(unsafe.Pointer(newObjv + uintptr(i)*8))
			v10 = _objPtr
			v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
			*(*TTcl_Size)(unsafe.Pointer(v10))--
			if v9 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			goto _8
		_8:
			;
			i++
		}
		XTclStackFree(tls, interp, newObjv)
		return int32(TCL_ERROR)
	}
	if lookupNsPtr != 0 {
		savedNsPtr = (*TCallFrame)(unsafe.Pointer(varFramePtr)).FnsPtr
		(*TCallFrame)(unsafe.Pointer(varFramePtr)).FnsPtr = lookupNsPtr
	}
	XTclSkipTailcall(tls, interp)
	if v11 = interp == libc.UintptrFromInt32(0); !v11 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v11 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr1 = XTclThreadAllocObj(tls)
	} else {
		_objPtr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr1 + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 16)) = _objPtr1
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FprocPtr = __ccgo_fp(_TEOV_NotFoundCallback)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8)) = uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 1*8)) = newObjv
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 2*8)) = savedNsPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 16))
	return XTclNREvalObjv(tls, interp, newObjc, newObjv, int32(TCL_EVAL_NOERR), libc.UintptrFromInt32(0))
}

func _TEOV_NotFoundCallback(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	var _objPtr, iPtr, objv, savedNsPtr, v3 uintptr
	var i, objc, v2 TTcl_Size
	_, _, _, _, _, _, _, _ = _objPtr, i, iPtr, objc, objv, savedNsPtr, v2, v3
	iPtr = interp
	objc = int64(*(*uintptr)(unsafe.Pointer(data)))
	objv = *(*uintptr)(unsafe.Pointer(data + 1*8))
	savedNsPtr = *(*uintptr)(unsafe.Pointer(data + 2*8))
	if savedNsPtr != 0 {
		(*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FnsPtr = savedNsPtr
	}
	/*
	 * Release any resources we locked and allocated during the handler call.
	 */
	i = 0
	for {
		if !(i < objc) {
			break
		}
		_objPtr = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
		v3 = _objPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		goto _1
	_1:
		;
		i++
	}
	XTclStackFree(tls, interp, objv)
	return result
}

func _TEOV_RunEnterTraces(tls *libc.TLS, interp uintptr, cmdPtrPtr uintptr, commandPtr uintptr, objc TTcl_Size, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var cachePtr, cmdPtr, command, iPtr, info, v1, v3 uintptr
	var cmdEpoch, newEpoch, v2 TTcl_Size
	var traceCode int32
	var v4 bool
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cmdEpoch, cmdPtr, command, iPtr, info, newEpoch, traceCode, v1, v2, v3, v4
	iPtr = interp
	cmdPtr = *(*uintptr)(unsafe.Pointer(cmdPtrPtr))
	cmdEpoch = (*TCommand)(unsafe.Pointer(cmdPtr)).FcmdEpoch
	traceCode = TCL_OK
	if (*TTcl_Obj)(unsafe.Pointer(commandPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(commandPtr)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(commandPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, commandPtr, bp)
	}
	command = v1
	/*
	 * Call trace functions.
	 * Execute any command or execution traces. Note that we bump up the
	 * command's reference count for the duration of the calling of the
	 * traces so that the structure doesn't go away underneath our feet.
	 */
	(*TCommand)(unsafe.Pointer(cmdPtr)).FrefCount++
	if (*TInterp)(unsafe.Pointer(iPtr)).FtracePtr != 0 {
		traceCode = XTclCheckInterpTraces(tls, interp, command, *(*TTcl_Size)(unsafe.Pointer(bp)), cmdPtr, TCL_OK, int32(TCL_TRACE_ENTER_EXEC), objc, objv)
	}
	if (*TCommand)(unsafe.Pointer(cmdPtr)).Fflags&int32(CMD_HAS_EXEC_TRACES) != 0 && traceCode == TCL_OK {
		traceCode = XTclCheckExecutionTraces(tls, interp, command, *(*TTcl_Size)(unsafe.Pointer(bp)), cmdPtr, TCL_OK, int32(TCL_TRACE_ENTER_EXEC), objc, objv)
	}
	newEpoch = (*TCommand)(unsafe.Pointer(cmdPtr)).FcmdEpoch
	v3 = cmdPtr + 16
	v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
	*(*TTcl_Size)(unsafe.Pointer(v3))--
	if v2 <= int64(1) {
		XTclpFree(tls, cmdPtr)
	}
	if traceCode != TCL_OK {
		if traceCode == int32(TCL_ERROR) {
			if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				info = XTclThreadAllocObj(tls)
			} else {
				info = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(info + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(info)).FrefCount = 0
			if libc.Uint64FromInt64(23)-libc.Uint64FromInt32(1) == uint64(0) {
				(*TTcl_Obj)(unsafe.Pointer(info)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(info)).Flength = int64(libc.Int32FromInt32(0))
			} else {
				(*TTcl_Obj)(unsafe.Pointer(info)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(23)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
				libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(info)).Fbytes, __ccgo_ts+8537, libc.Uint64FromInt64(23)-libc.Uint64FromInt32(1))
				*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(info)).Fbytes + uintptr(libc.Uint64FromInt64(23)-libc.Uint64FromInt32(1)))) = uint8('\000')
				(*TTcl_Obj)(unsafe.Pointer(info)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(23) - libc.Uint64FromInt32(1))
			}
			(*TTcl_Obj)(unsafe.Pointer(info)).FtypePtr = libc.UintptrFromInt32(0)
			XTcl_AppendLimitedToObj(tls, info, command, *(*TTcl_Size)(unsafe.Pointer(bp)), int64(55), __ccgo_ts+8560)
			XTcl_AppendToObj(tls, info, __ccgo_ts+8564, int64(2))
			XTcl_AppendObjToErrorInfo(tls, interp, info)
			*(*int32)(unsafe.Pointer(iPtr + 368)) |= int32(ERR_ALREADY_LOGGED)
		}
		return traceCode
	}
	if cmdEpoch != newEpoch {
		*(*uintptr)(unsafe.Pointer(cmdPtrPtr)) = libc.UintptrFromInt32(0)
	}
	return TCL_OK
}

func _TEOV_RunLeaveTraces(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, cachePtr, cmdPtr, command, commandPtr, iPtr, info, objv, v1, v3, v6 uintptr
	var objc, v2, v5 TTcl_Size
	var traceCode int32
	var v4 bool
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, cmdPtr, command, commandPtr, iPtr, info, objc, objv, traceCode, v1, v2, v3, v4, v5, v6
	iPtr = interp
	traceCode = TCL_OK
	objc = int64(*(*uintptr)(unsafe.Pointer(data)))
	commandPtr = *(*uintptr)(unsafe.Pointer(data + 1*8))
	cmdPtr = *(*uintptr)(unsafe.Pointer(data + 2*8))
	objv = *(*uintptr)(unsafe.Pointer(data + 3*8))
	if (*TTcl_Obj)(unsafe.Pointer(commandPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(commandPtr)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(commandPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, commandPtr, bp)
	}
	command = v1
	if !((*TCommand)(unsafe.Pointer(cmdPtr)).Fflags&libc.Int32FromInt32(CMD_DYING) != 0) {
		if (*TCommand)(unsafe.Pointer(cmdPtr)).Fflags&int32(CMD_HAS_EXEC_TRACES) != 0 {
			traceCode = XTclCheckExecutionTraces(tls, interp, command, *(*TTcl_Size)(unsafe.Pointer(bp)), cmdPtr, result, int32(TCL_TRACE_LEAVE_EXEC), objc, objv)
		}
		if (*TInterp)(unsafe.Pointer(iPtr)).FtracePtr != libc.UintptrFromInt32(0) && traceCode == TCL_OK {
			traceCode = XTclCheckInterpTraces(tls, interp, command, *(*TTcl_Size)(unsafe.Pointer(bp)), cmdPtr, result, int32(TCL_TRACE_LEAVE_EXEC), objc, objv)
		}
	}
	/*
	 * As cmdPtr is set, TclNRRunCallbacks is about to reduce the numlevels.
	 * Prevent that by resetting the cmdPtr field and dealing right here with
	 * cmdPtr->refCount.
	 */
	v3 = cmdPtr + 16
	v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
	*(*TTcl_Size)(unsafe.Pointer(v3))--
	if v2 <= int64(1) {
		XTclpFree(tls, cmdPtr)
	}
	if traceCode != TCL_OK {
		if traceCode == int32(TCL_ERROR) {
			if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				info = XTclThreadAllocObj(tls)
			} else {
				info = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(info + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(info)).FrefCount = 0
			if libc.Uint64FromInt64(23)-libc.Uint64FromInt32(1) == uint64(0) {
				(*TTcl_Obj)(unsafe.Pointer(info)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(info)).Flength = int64(libc.Int32FromInt32(0))
			} else {
				(*TTcl_Obj)(unsafe.Pointer(info)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(23)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
				libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(info)).Fbytes, __ccgo_ts+8567, libc.Uint64FromInt64(23)-libc.Uint64FromInt32(1))
				*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(info)).Fbytes + uintptr(libc.Uint64FromInt64(23)-libc.Uint64FromInt32(1)))) = uint8('\000')
				(*TTcl_Obj)(unsafe.Pointer(info)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(23) - libc.Uint64FromInt32(1))
			}
			(*TTcl_Obj)(unsafe.Pointer(info)).FtypePtr = libc.UintptrFromInt32(0)
			XTcl_AppendLimitedToObj(tls, info, command, *(*TTcl_Size)(unsafe.Pointer(bp)), int64(55), __ccgo_ts+8560)
			XTcl_AppendToObj(tls, info, __ccgo_ts+8564, int64(2))
			XTcl_AppendObjToErrorInfo(tls, interp, info)
			*(*int32)(unsafe.Pointer(iPtr + 368)) |= int32(ERR_ALREADY_LOGGED)
		}
		result = traceCode
	}
	_objPtr = commandPtr
	v6 = _objPtr
	v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
	*(*TTcl_Size)(unsafe.Pointer(v6))--
	if v5 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return result
}

func _TEOV_LookupCmdFromObj(tls *libc.TLS, interp uintptr, namePtr uintptr, lookupNsPtr uintptr) (r uintptr) {
	var cmdPtr, iPtr, savedNsPtr uintptr
	_, _, _ = cmdPtr, iPtr, savedNsPtr
	iPtr = interp
	savedNsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FnsPtr
	if lookupNsPtr != 0 {
		(*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FnsPtr = lookupNsPtr
	}
	cmdPtr = XTcl_GetCommandFromObj(tls, interp, namePtr)
	(*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FnsPtr = savedNsPtr
	return cmdPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_EvalTokensStandard --
 *
 *	Given an array of tokens parsed from a Tcl command (e.g., the tokens
 *	that make up a word or the index for an array variable) this function
 *	evaluates the tokens and concatenates their values to form a single
 *	result value.
 *
 * Results:
 *	The return value is a standard Tcl completion code such as TCL_OK or
 *	TCL_ERROR. A result or error message is left in interp's result.
 *
 * Side effects:
 *	Depends on the array of tokens being evaled.
 *
 *----------------------------------------------------------------------
 */

func XTcl_EvalTokensStandard(tls *libc.TLS, interp uintptr, tokenPtr uintptr, count TTcl_Size) (r int32) {
	/* Number of tokens to consider at tokenPtr.
	 * Must be at least 1. */
	return XTclSubstTokens(tls, interp, tokenPtr, count, libc.UintptrFromInt32(0), int64(1), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_EvalEx, TclEvalEx --
 *
 *	This function evaluates a Tcl script without using the compiler or
 *	byte-code interpreter. It just parses the script, creates values for
 *	each word of each command, then calls EvalObjv to execute each
 *	command.
 *
 * Results:
 *	The return value is a standard Tcl completion code such as TCL_OK or
 *	TCL_ERROR. A result or error message is left in interp's result.
 *
 * Side effects:
 *	Depends on the script.
 *
 * TIP #280 : Keep public API, internally extended API.
 *----------------------------------------------------------------------
 */

func XTcl_EvalEx(tls *libc.TLS, interp uintptr, script uintptr, numBytes TTcl_Size, flags int32) (r int32) {
	/* Collection of OR-ed bits that control the
	 * evaluation of the script. Only
	 * TCL_EVAL_GLOBAL is currently supported. */
	return XTclEvalEx(tls, interp, script, numBytes, flags, int64(1), libc.UintptrFromInt32(0), script)
}

func XTclEvalEx(tls *libc.TLS, interp uintptr, script uintptr, numBytes TTcl_Size, flags int32, _line TTcl_Size, clNextOuter uintptr, outerScript uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	*(*TTcl_Size)(unsafe.Pointer(bp)) = _line /* continuation line data. This is set only in
	 * TclSubstTokens(), to properly handle
	 * [...]-nested commands. The 'outerScript'
	 * refers to the most-outer script containing
	 * the embedded command, which is referred to
	 * by 'script'. The 'clNextOuter' refers to
	 * the current entry in the table of
	 * continuation lines in this "main script",
	 * and the character offsets are relative to
	 * the 'outerScript' as well.
	 *
	 * If outerScript == script, then this call is
	 * for the outer-most script/command. See
	 * Tcl_EvalEx() and TclEvalObjEx() for places
	 * generating arguments for which this is
	 * true. */
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, _objPtr6, cachePtr, copy1, eeFramePtr, expand, expandStack, iPtr, lcopy, lineSpace, lines, linesStack, next, norm, objv, objvSpace, p, parsePtr, savedVarFramePtr, stackObjArray, temp, tokenPtr, wordStart, v1, v10, v13, v14, v15, v2, v23, v26, v29, v32, v34 uintptr
	var additionalObjsCount, bytesLeft, commandLength, i, numWords, objIdx, objectsNeeded, objectsUsed, wordIdx, v12, v16, v20, v21, v22, v24, v25, v28, v31, v33, v9 TTcl_Size
	var allowExceptions, code, expandRequested, gotParse, minObjs, v3, v7 int32
	var v11, v18, v19, v6, v8 int64
	var v4 bool
	var _ /* clNext at bp+8 */ uintptr
	var _ /* elements at bp+48 */ uintptr
	var _ /* numElements at bp+32 */ TTcl_Size
	var _ /* numElements at bp+40 */ TTcl_Size
	var _ /* wordCLNext at bp+24 */ uintptr
	var _ /* wordLine at bp+16 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, _objPtr6, additionalObjsCount, allowExceptions, bytesLeft, cachePtr, code, commandLength, copy1, eeFramePtr, expand, expandRequested, expandStack, gotParse, i, iPtr, lcopy, lineSpace, lines, linesStack, minObjs, next, norm, numWords, objIdx, objectsNeeded, objectsUsed, objv, objvSpace, p, parsePtr, savedVarFramePtr, stackObjArray, temp, tokenPtr, wordIdx, wordStart, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v28, v29, v3, v31, v32, v33, v34, v4, v6, v7, v8, v9
	iPtr = interp
	minObjs = int32(20)
	code = TCL_OK /* Saves old copy of iPtr->varFramePtr in case
	 * TCL_EVAL_GLOBAL was set. */
	allowExceptions = (*TInterp)(unsafe.Pointer(iPtr)).FevalFlags & int32(TCL_ALLOW_EXCEPTIONS)
	gotParse = 0
	objectsUsed = 0
	/* These variables keep track of how much
	 * state has been allocated while evaluating
	 * the script, so that it can be freed
	 * properly if an error occurs. */
	parsePtr = XTclStackAlloc(tls, interp, uint64(744))
	eeFramePtr = XTclStackAlloc(tls, interp, uint64(88))
	stackObjArray = XTclStackAlloc(tls, interp, libc.Uint64FromInt32(minObjs)*uint64(8))
	expandStack = XTclStackAlloc(tls, interp, libc.Uint64FromInt32(minObjs)*uint64(4))
	linesStack = XTclStackAlloc(tls, interp, libc.Uint64FromInt32(minObjs)*uint64(8))
	/* TIP #280 Structures for tracking of command
	 * locations. */
	*(*uintptr)(unsafe.Pointer(bp + 8)) = libc.UintptrFromInt32(0) /* Pointer for the tracking of invisible
	 * continuation lines. Initialized only if the
	 * caller gave us a table of locations to
	 * track, via scriptCLLocPtr. It always refers
	 * to the table entry holding the location of
	 * the next invisible continuation line to
	 * look for, while parsing the script. */
	if (*TInterp)(unsafe.Pointer(iPtr)).FscriptCLLocPtr != 0 {
		if clNextOuter != 0 {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = clNextOuter
		} else {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TInterp)(unsafe.Pointer(iPtr)).FscriptCLLocPtr + 8
		}
	}
	if numBytes < 0 {
		numBytes = libc.Int64FromUint64(libc.Xstrlen(tls, script))
	}
	XTcl_ResetResult(tls, interp)
	savedVarFramePtr = (*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr
	if flags&int32(TCL_EVAL_GLOBAL) != 0 {
		(*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr = (*TInterp)(unsafe.Pointer(iPtr)).FrootFramePtr
	}
	/*
	 * Each iteration through the following loop parses the next command from
	 * the script and then executes it.
	 */
	v1 = stackObjArray
	objvSpace = v1
	objv = v1
	v2 = linesStack
	lineSpace = v2
	lines = v2
	expand = expandStack
	p = script
	bytesLeft = numBytes
	/*
	 * TIP #280 Initialize tracking. Do not push on the frame stack yet.
	 *
	 * We open a new context, either for a sourced script, or 'eval'.
	 * For sourced files we always have a path object, even if nothing was
	 * specified in the interp itself. That makes code using it simpler as
	 * NULL checks can be left out. Sourced file without path in the
	 * 'scriptFile' is possible during Tcl initialization.
	 */
	if (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr != 0 {
		v3 = (*TCmdFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr)).Flevel + int32(1)
	} else {
		v3 = int32(1)
	}
	(*TCmdFrame)(unsafe.Pointer(eeFramePtr)).Flevel = v3
	(*TCmdFrame)(unsafe.Pointer(eeFramePtr)).FframePtr = (*TInterp)(unsafe.Pointer(iPtr)).FframePtr
	(*TCmdFrame)(unsafe.Pointer(eeFramePtr)).FnextPtr = (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr
	(*TCmdFrame)(unsafe.Pointer(eeFramePtr)).Fnline = 0
	(*TCmdFrame)(unsafe.Pointer(eeFramePtr)).Fline = libc.UintptrFromInt32(0)
	(*TCmdFrame)(unsafe.Pointer(eeFramePtr)).FcmdObj = libc.UintptrFromInt32(0)
	(*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr = eeFramePtr
	if (*TInterp)(unsafe.Pointer(iPtr)).FevalFlags&int32(TCL_EVAL_FILE) != 0 {
		/*
		 * Set up for a sourced file.
		 */
		(*TCmdFrame)(unsafe.Pointer(eeFramePtr)).Ftype1 = int32(TCL_LOCATION_SOURCE)
		if (*TInterp)(unsafe.Pointer(iPtr)).FscriptFile != 0 {
			/*
			 * Normalization here, to have the correct pwd. Should have
			 * negligible impact on performance, as the norm should have been
			 * done already by the 'source' invoking us, and it caches the
			 * result.
			 */
			norm = XTcl_FSGetNormalizedPath(tls, interp, (*TInterp)(unsafe.Pointer(iPtr)).FscriptFile)
			if norm == libc.UintptrFromInt32(0) {
				/*
				 * Error message in the interp result.
				 */
				code = int32(TCL_ERROR)
				goto error
			}
			(*TCmdFrame)(unsafe.Pointer(eeFramePtr)).Fdata.Feval.Fpath = norm
		} else {
			if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				(*TCmdFrame)(unsafe.Pointer(eeFramePtr)).Fdata.Feval.Fpath = XTclThreadAllocObj(tls)
			} else {
				(*TCmdFrame)(unsafe.Pointer(eeFramePtr)).Fdata.Feval.Fpath = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(eeFramePtr)).Fdata.Feval.Fpath + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(eeFramePtr)).Fdata.Feval.Fpath)).FrefCount = 0
			if libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1) == uint64(0) {
				(*TTcl_Obj)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(eeFramePtr)).Fdata.Feval.Fpath)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(eeFramePtr)).Fdata.Feval.Fpath)).Flength = int64(libc.Int32FromInt32(0))
			} else {
				(*TTcl_Obj)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(eeFramePtr)).Fdata.Feval.Fpath)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
				libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(eeFramePtr)).Fdata.Feval.Fpath)).Fbytes, __ccgo_ts+1945, libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1))
				*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(eeFramePtr)).Fdata.Feval.Fpath)).Fbytes + uintptr(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)))) = uint8('\000')
				(*TTcl_Obj)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(eeFramePtr)).Fdata.Feval.Fpath)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(1) - libc.Uint64FromInt32(1))
			}
			(*TTcl_Obj)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(eeFramePtr)).Fdata.Feval.Fpath)).FtypePtr = libc.UintptrFromInt32(0)
		}
		(*TTcl_Obj)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(eeFramePtr)).Fdata.Feval.Fpath)).FrefCount++
	} else {
		/*
		 * Set up for plain eval.
		 */
		(*TCmdFrame)(unsafe.Pointer(eeFramePtr)).Ftype1 = TCL_LOCATION_EVAL
		(*TCmdFrame)(unsafe.Pointer(eeFramePtr)).Fdata.Feval.Fpath = libc.UintptrFromInt32(0)
	}
	(*TInterp)(unsafe.Pointer(iPtr)).FevalFlags = 0
	for cond := true; cond; cond = bytesLeft > 0 {
		if XTcl_ParseCommand(tls, interp, p, bytesLeft, 0, parsePtr) != TCL_OK {
			code = int32(TCL_ERROR)
			XTcl_LogCommandInfo(tls, interp, script, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart, int64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm+uintptr(1))-int64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart))
			goto posterror
		}
		/*
		 * TIP #280 Track lines. The parser may have skipped text till it
		 * found the command we are now at. We have to count the lines in this
		 * block, and do not forget invisible continuation lines.
		 */
		XTclAdvanceLines(tls, bp, p, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart)
		XTclAdvanceContinuations(tls, bp, bp+8, int32(int64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart)-int64(outerScript)))
		gotParse = int32(1)
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords > 0 {
			/*
			 * TIP #280. Track lines within the words of the current
			 * command. We use a separate pointer into the table of
			 * continuation line locations to not lose our position for the
			 * per-command parsing.
			 */
			*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = *(*TTcl_Size)(unsafe.Pointer(bp))
			wordStart = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart
			*(*uintptr)(unsafe.Pointer(bp + 24)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			objectsNeeded = 0
			numWords = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords
			/*
			 * Generate an array of objects for the words of the command.
			 */
			if numWords > int64(minObjs) {
				expand = XTcl_Alloc(tls, libc.Uint64FromInt64(numWords)*uint64(4))
				objvSpace = XTcl_Alloc(tls, libc.Uint64FromInt64(numWords)*uint64(8))
				lineSpace = XTcl_Alloc(tls, libc.Uint64FromInt64(numWords)*uint64(8))
			}
			expandRequested = 0
			objv = objvSpace
			lines = lineSpace
			(*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr = (*TCmdFrame)(unsafe.Pointer(eeFramePtr)).FnextPtr
			objectsUsed = 0
			tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
			for {
				if !(objectsUsed < numWords) {
					break
				}
				/*
				 * TIP #280. Track lines to current word. Save the information
				 * on a per-word basis, signaling dynamic words as needed.
				 * Make the information available to the recursively called
				 * evaluator as well, including the type of context (source
				 * vs. eval).
				 */
				XTclAdvanceLines(tls, bp+16, wordStart, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart)
				XTclAdvanceContinuations(tls, bp+16, bp+24, int32(int64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart)-int64(outerScript)))
				wordStart = (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart
				if XTclWordKnownAtCompileTime(tls, tokenPtr, libc.UintptrFromInt32(0)) != 0 {
					v6 = *(*TTcl_Size)(unsafe.Pointer(bp + 16))
				} else {
					v6 = int64(-int32(1))
				}
				*(*TTcl_Size)(unsafe.Pointer(lines + uintptr(objectsUsed)*8)) = v6
				if (*TCmdFrame)(unsafe.Pointer(eeFramePtr)).Ftype1 == int32(TCL_LOCATION_SOURCE) {
					*(*int32)(unsafe.Pointer(iPtr + 256)) |= int32(TCL_EVAL_FILE)
				}
				code = XTclSubstTokens(tls, interp, tokenPtr+uintptr(1)*32, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents, libc.UintptrFromInt32(0), *(*TTcl_Size)(unsafe.Pointer(bp + 16)), *(*uintptr)(unsafe.Pointer(bp + 24)), outerScript)
				(*TInterp)(unsafe.Pointer(iPtr)).FevalFlags = 0
				if code != TCL_OK {
					break
				}
				*(*uintptr)(unsafe.Pointer(objv + uintptr(objectsUsed)*8)) = XTcl_GetObjResult(tls, interp)
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objectsUsed)*8)))).FrefCount++
				if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_EXPAND_WORD) {
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objectsUsed)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
						if (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objectsUsed)*8)) + 32))).Fptr2 != 0 {
							v8 = (*TListSpan)(unsafe.Pointer((*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objectsUsed)*8)) + 32))).Fptr2)).FspanLength
						} else {
							v8 = (*TListStore)(unsafe.Pointer((*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objectsUsed)*8)) + 32))).Fptr1)).FnumUsed
						}
						*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = v8
						v7 = libc.Int32FromInt32(TCL_OK)
					} else {
						v7 = XTcl_ListObjLength(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(objectsUsed)*8)), bp+32)
					}
					code = v7
					if code == int32(TCL_ERROR) {
						/*
						 * Attempt to expand a non-list.
						 */
						XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+8590, libc.VaList(bp+64, objectsUsed)))
						_objPtr = *(*uintptr)(unsafe.Pointer(objv + uintptr(objectsUsed)*8))
						v10 = _objPtr
						v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
						*(*TTcl_Size)(unsafe.Pointer(v10))--
						if v9 <= int64(1) {
							XTclFreeObj(tls, _objPtr)
						}
						break
					}
					expandRequested = int32(1)
					*(*int32)(unsafe.Pointer(expand + uintptr(objectsUsed)*4)) = int32(1)
					if *(*TTcl_Size)(unsafe.Pointer(bp + 32)) != 0 {
						v11 = *(*TTcl_Size)(unsafe.Pointer(bp + 32))
					} else {
						v11 = int64(1)
					}
					additionalObjsCount = v11
				} else {
					*(*int32)(unsafe.Pointer(expand + uintptr(objectsUsed)*4)) = 0
					additionalObjsCount = int64(1)
				}
				/* Currently max command words in INT_MAX */
				if additionalObjsCount > int64(INT_MAX) || objectsNeeded > int64(INT_MAX)-additionalObjsCount {
					code = XTclCommandWordLimitError(tls, interp, int64(-int32(1)))
					_objPtr1 = *(*uintptr)(unsafe.Pointer(objv + uintptr(objectsUsed)*8))
					v13 = _objPtr1
					v12 = *(*TTcl_Size)(unsafe.Pointer(v13))
					*(*TTcl_Size)(unsafe.Pointer(v13))--
					if v12 <= int64(1) {
						XTclFreeObj(tls, _objPtr1)
					}
					break
				}
				objectsNeeded += additionalObjsCount
				if *(*uintptr)(unsafe.Pointer(bp + 24)) != 0 {
					XTclContinuationsEnterDerived(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(objectsUsed)*8)), int64(wordStart)-int64(outerScript), *(*uintptr)(unsafe.Pointer(bp + 24)))
				}
				goto _5
			_5:
				;
				objectsUsed++
				tokenPtr += uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+int64(1)) * 32
			} /* for loop */
			(*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr = eeFramePtr
			if code != TCL_OK {
				goto error
			}
			if expandRequested != 0 {
				/*
				 * Some word expansion was requested. Check for objv resize.
				 */
				copy1 = objvSpace
				lcopy = lineSpace
				wordIdx = numWords
				objIdx = objectsNeeded - int64(1)
				if numWords > int64(minObjs) || objectsNeeded > int64(minObjs) {
					v14 = XTcl_Alloc(tls, libc.Uint64FromInt64(objectsNeeded)*uint64(8))
					objvSpace = v14
					objv = v14
					v15 = XTcl_Alloc(tls, libc.Uint64FromInt64(objectsNeeded)*uint64(8))
					lineSpace = v15
					lines = v15
				}
				objectsUsed = 0
				for {
					v16 = wordIdx
					wordIdx--
					if !(v16 != 0) {
						break
					}
					if *(*int32)(unsafe.Pointer(expand + uintptr(wordIdx)*4)) != 0 {
						temp = *(*uintptr)(unsafe.Pointer(copy1 + uintptr(wordIdx)*8))
						if (*TTcl_Obj)(unsafe.Pointer(temp)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
							if (*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(temp + 32))).Fptr2 != 0 {
								v18 = (*TListSpan)(unsafe.Pointer((*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer(temp + 32))).Fptr2)).FspanStart
							} else {
								v18 = (*TListStore)(unsafe.Pointer((*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer(temp + 32))).Fptr1)).FfirstUsed
							}
							*(*uintptr)(unsafe.Pointer(bp + 48)) = (*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(temp + 32))).Fptr1 + 40 + uintptr(v18)*8
							if (*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(temp + 32))).Fptr2 != 0 {
								v19 = (*TListSpan)(unsafe.Pointer((*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer(temp + 32))).Fptr2)).FspanLength
							} else {
								v19 = (*TListStore)(unsafe.Pointer((*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer(temp + 32))).Fptr1)).FnumUsed
							}
							*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = v19
							_ = libc.Int32FromInt32(TCL_OK)
						} else {
							XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), temp, bp+40, bp+48)
						}
						objectsUsed += *(*TTcl_Size)(unsafe.Pointer(bp + 40))
						for {
							v20 = *(*TTcl_Size)(unsafe.Pointer(bp + 40))
							*(*TTcl_Size)(unsafe.Pointer(bp + 40))--
							if !(v20 != 0) {
								break
							}
							*(*TTcl_Size)(unsafe.Pointer(lines + uintptr(objIdx)*8)) = int64(-int32(1))
							v21 = objIdx
							objIdx--
							*(*uintptr)(unsafe.Pointer(objv + uintptr(v21)*8)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 40)))*8))
							(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 40)))*8)))).FrefCount++
						}
						_objPtr2 = temp
						v23 = _objPtr2
						v22 = *(*TTcl_Size)(unsafe.Pointer(v23))
						*(*TTcl_Size)(unsafe.Pointer(v23))--
						if v22 <= int64(1) {
							XTclFreeObj(tls, _objPtr2)
						}
					} else {
						*(*TTcl_Size)(unsafe.Pointer(lines + uintptr(objIdx)*8)) = *(*TTcl_Size)(unsafe.Pointer(lcopy + uintptr(wordIdx)*8))
						v24 = objIdx
						objIdx--
						*(*uintptr)(unsafe.Pointer(objv + uintptr(v24)*8)) = *(*uintptr)(unsafe.Pointer(copy1 + uintptr(wordIdx)*8))
						objectsUsed++
					}
				}
				objv += uintptr(objIdx+int64(1)) * 8
				if copy1 != stackObjArray {
					XTclpFree(tls, copy1)
				}
				if lcopy != linesStack {
					XTclpFree(tls, lcopy)
				}
			}
			/*
			 * Execute the command and free the objects for its words.
			 *
			 * TIP #280: Remember the command itself for 'info frame'. We
			 * shorten the visible command by one char to exclude the
			 * termination character, if necessary. Here is where we put our
			 * frame on the stack of frames too. _After_ the nested commands
			 * have been executed.
			 */
			(*TCmdFrame)(unsafe.Pointer(eeFramePtr)).Fcmd = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart
			(*TCmdFrame)(unsafe.Pointer(eeFramePtr)).Flen1 = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandSize
			if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm == (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart+uintptr((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandSize)-uintptr(1) {
				(*TCmdFrame)(unsafe.Pointer(eeFramePtr)).Flen1--
			}
			(*TCmdFrame)(unsafe.Pointer(eeFramePtr)).Fnline = objectsUsed
			(*TCmdFrame)(unsafe.Pointer(eeFramePtr)).Fline = lines
			XTclArgumentEnter(tls, interp, objv, objectsUsed, eeFramePtr)
			code = XTcl_EvalObjv(tls, interp, objectsUsed, objv, libc.Int32FromInt32(TCL_EVAL_NOERR)|libc.Int32FromInt32(TCL_EVAL_SOURCE_IN_FRAME))
			XTclArgumentRelease(tls, interp, objv, objectsUsed)
			(*TCmdFrame)(unsafe.Pointer(eeFramePtr)).Fline = libc.UintptrFromInt32(0)
			(*TCmdFrame)(unsafe.Pointer(eeFramePtr)).Fnline = 0
			if (*TCmdFrame)(unsafe.Pointer(eeFramePtr)).FcmdObj != 0 {
				_objPtr3 = (*TCmdFrame)(unsafe.Pointer(eeFramePtr)).FcmdObj
				v26 = _objPtr3
				v25 = *(*TTcl_Size)(unsafe.Pointer(v26))
				*(*TTcl_Size)(unsafe.Pointer(v26))--
				if v25 <= int64(1) {
					XTclFreeObj(tls, _objPtr3)
				}
				(*TCmdFrame)(unsafe.Pointer(eeFramePtr)).FcmdObj = libc.UintptrFromInt32(0)
			}
			if code != TCL_OK {
				goto error
			}
			i = 0
			for {
				if !(i < objectsUsed) {
					break
				}
				_objPtr4 = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
				v29 = _objPtr4
				v28 = *(*TTcl_Size)(unsafe.Pointer(v29))
				*(*TTcl_Size)(unsafe.Pointer(v29))--
				if v28 <= int64(1) {
					XTclFreeObj(tls, _objPtr4)
				}
				goto _27
			_27:
				;
				i++
			}
			objectsUsed = 0
			if objvSpace != stackObjArray {
				XTclpFree(tls, objvSpace)
				objvSpace = stackObjArray
				XTclpFree(tls, lineSpace)
				lineSpace = linesStack
			}
			/*
			 * Free expand separately since objvSpace could have been
			 * reallocated above.
			 */
			if expand != expandStack {
				XTclpFree(tls, expand)
				expand = expandStack
			}
		}
		/*
		 * Advance to the next command in the script.
		 *
		 * TIP #280 Track Lines. Now we track how many lines were in the
		 * executed command.
		 */
		next = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart + uintptr((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandSize)
		bytesLeft -= int64(next) - int64(p)
		p = next
		XTclAdvanceLines(tls, bp, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart, p)
		XTcl_FreeParse(tls, parsePtr)
		gotParse = 0
	}
	(*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr = savedVarFramePtr
	code = TCL_OK
	goto cleanup_return
	goto error
error:
	;
	/*
	 * Generate and log various pieces of error information.
	 */
	if (*TInterp)(unsafe.Pointer(iPtr)).FnumLevels == 0 {
		if code == int32(TCL_RETURN) {
			code = XTclUpdateReturnInfo(tls, iPtr)
		}
		if code != TCL_OK && code != int32(TCL_ERROR) && !(allowExceptions != 0) {
			_ProcessUnexpectedResult(tls, interp, code)
			code = int32(TCL_ERROR)
		}
	}
	if code == int32(TCL_ERROR) && !((*TInterp)(unsafe.Pointer(iPtr)).Fflags&libc.Int32FromInt32(ERR_ALREADY_LOGGED) != 0) {
		commandLength = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandSize
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm == (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart+uintptr(commandLength)-uintptr(1) {
			/*
			 * The terminator character (such as ; or ]) of the command where
			 * the error occurred is the last character in the parsed command.
			 * Reduce the length by one so that the error message doesn't
			 * include the terminator character.
			 */
			commandLength -= int64(1)
		}
		XTcl_LogCommandInfo(tls, interp, script, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart, commandLength)
	}
	goto posterror
posterror:
	;
	*(*int32)(unsafe.Pointer(iPtr + 368)) &= ^libc.Int32FromInt32(ERR_ALREADY_LOGGED)
	/*
	 * Then free resources that had been allocated to the command.
	 */
	i = 0
	for {
		if !(i < objectsUsed) {
			break
		}
		_objPtr5 = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
		v32 = _objPtr5
		v31 = *(*TTcl_Size)(unsafe.Pointer(v32))
		*(*TTcl_Size)(unsafe.Pointer(v32))--
		if v31 <= int64(1) {
			XTclFreeObj(tls, _objPtr5)
		}
		goto _30
	_30:
		;
		i++
	}
	if gotParse != 0 {
		XTcl_FreeParse(tls, parsePtr)
	}
	if objvSpace != stackObjArray {
		XTclpFree(tls, objvSpace)
		XTclpFree(tls, lineSpace)
	}
	if expand != expandStack {
		XTclpFree(tls, expand)
	}
	(*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr = savedVarFramePtr
	goto cleanup_return
cleanup_return:
	;
	/*
	 * TIP #280. Release the local CmdFrame, and its contents.
	 */
	(*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr = (*TCmdFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr)).FnextPtr
	if (*TCmdFrame)(unsafe.Pointer(eeFramePtr)).Ftype1 == int32(TCL_LOCATION_SOURCE) {
		_objPtr6 = (*TCmdFrame)(unsafe.Pointer(eeFramePtr)).Fdata.Feval.Fpath
		v34 = _objPtr6
		v33 = *(*TTcl_Size)(unsafe.Pointer(v34))
		*(*TTcl_Size)(unsafe.Pointer(v34))--
		if v33 <= int64(1) {
			XTclFreeObj(tls, _objPtr6)
		}
	}
	XTclStackFree(tls, interp, linesStack)
	XTclStackFree(tls, interp, expandStack)
	XTclStackFree(tls, interp, stackObjArray)
	XTclStackFree(tls, interp, eeFramePtr)
	XTclStackFree(tls, interp, parsePtr)
	return code
}

/*
 *----------------------------------------------------------------------
 *
 * TclAdvanceLines --
 *
 *	This function is a helper which counts the number of lines in a block
 *	of text and advances an external counter.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The specified counter is advanced per the number of lines found.
 *
 * TIP #280
 *----------------------------------------------------------------------
 */

func XTclAdvanceLines(tls *libc.TLS, line uintptr, start uintptr, end uintptr) {
	var p uintptr
	_ = p
	p = start
	for {
		if !(p < end) {
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('\n') {
			*(*TTcl_Size)(unsafe.Pointer(line))++
		}
		goto _1
	_1:
		;
		p++
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclAdvanceContinuations --
 *
 *	This procedure is a helper which counts the number of continuation
 *	lines (CL) in a block of text using a table of CL locations and
 *	advances an external counter, and the pointer into the table.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The specified counter is advanced per the number of continuation lines
 *	found.
 *
 * TIP #280
 *----------------------------------------------------------------------
 */

func XTclAdvanceContinuations(tls *libc.TLS, line uintptr, clNextPtrPtr uintptr, loc int32) {
	/*
	 * Track the invisible continuation lines embedded in a script, if any.
	 * Here they are just spaces (already). They were removed by
	 * TclSubstTokens via TclParseBackslash.
	 *
	 * *clNextPtrPtr         <=> We have continuation lines to track.
	 * **clNextPtrPtr >= 0   <=> We are not beyond the last possible location.
	 * loc >= **clNextPtrPtr <=> We stepped beyond the current cont. line.
	 */
	for *(*uintptr)(unsafe.Pointer(clNextPtrPtr)) != 0 && *(*TTcl_Size)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(clNextPtrPtr)))) >= 0 && int64(loc) >= *(*TTcl_Size)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(clNextPtrPtr)))) {
		/*
		 * We just stepped over an invisible continuation line. Adjust the
		 * line counter and step to the table entry holding the location of
		 * the next continuation line to track.
		 */
		*(*TTcl_Size)(unsafe.Pointer(line))++
		*(*uintptr)(unsafe.Pointer(clNextPtrPtr)) += 8
	}
}

/*
 *----------------------------------------------------------------------
 * Note: The whole data structure access for argument location tracking is
 * hidden behind these three functions. The only parts open are the lineLAPtr
 * field in the Interp structure. The CFWord definition is internal to here.
 * Should make it easier to redo the data structures if we find something more
 * space/time efficient.
 */

/*
 *----------------------------------------------------------------------
 *
 * TclArgumentEnter --
 *
 *	This procedure is a helper for the TIP #280 uplevel extension. It
 *	enters location references for the arguments of a command to be
 *	invoked. Only the first entry has the actual data, further entries
 *	simply count the usage up.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	May allocate memory.
 *
 * TIP #280
 *----------------------------------------------------------------------
 */

func XTclArgumentEnter(tls *libc.TLS, interp uintptr, objv uintptr, objc TTcl_Size, cfPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var cfwPtr, hPtr, iPtr uintptr
	var i TTcl_Size
	var _ /* isNew at bp+0 */ int32
	_, _, _, _ = cfwPtr, hPtr, i, iPtr
	iPtr = interp
	i = int64(1)
	for {
		if !(i < objc) {
			break
		}
		/*
		 * Ignore argument words without line information (= dynamic). If they
		 * are variables they may have location information associated with
		 * that, either through globally recorded 'set' invocations, or
		 * literals in bytecode. Either way there is no need to record
		 * something here.
		 */
		if *(*TTcl_Size)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(cfPtr)).Fline + uintptr(i)*8)) < 0 {
			goto _1
		}
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FlineLAPtr)).FcreateProc})))(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlineLAPtr, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp)
		if *(*int32)(unsafe.Pointer(bp)) != 0 {
			/*
			 * The word is not on the stack yet, remember the current location
			 * and initialize references.
			 */
			cfwPtr = XTcl_Alloc(tls, uint64(24))
			(*TCFWord)(unsafe.Pointer(cfwPtr)).FframePtr = cfPtr
			(*TCFWord)(unsafe.Pointer(cfwPtr)).Fword = i
			(*TCFWord)(unsafe.Pointer(cfwPtr)).FrefCount = int64(1)
			(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = cfwPtr
		} else {
			/*
			 * The word is already on the stack, its current location is not
			 * relevant. Just remember the reference to prevent early removal.
			 */
			cfwPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
			(*TCFWord)(unsafe.Pointer(cfwPtr)).FrefCount++
		}
		goto _1
	_1:
		;
		i++
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclArgumentRelease --
 *
 *	This procedure is a helper for the TIP #280 uplevel extension. It
 *	removes the location references for the arguments of a command just
 *	done. Usage is counted down, the data is removed only when no user is
 *	left over.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	May release memory.
 *
 * TIP #280
 *----------------------------------------------------------------------
 */

func XTclArgumentRelease(tls *libc.TLS, interp uintptr, objv uintptr, objc TTcl_Size) {
	var cfwPtr, hPtr, iPtr, v3 uintptr
	var i, v2 TTcl_Size
	_, _, _, _, _, _ = cfwPtr, hPtr, i, iPtr, v2, v3
	iPtr = interp
	i = int64(1)
	for {
		if !(i < objc) {
			break
		}
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FlineLAPtr)).FfindProc})))(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlineLAPtr, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))
		if !(hPtr != 0) {
			goto _1
		}
		cfwPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		v3 = cfwPtr + 16
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 > int64(1) {
			goto _1
		}
		XTclpFree(tls, cfwPtr)
		XTcl_DeleteHashEntry(tls, hPtr)
		goto _1
	_1:
		;
		i++
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclArgumentBCEnter --
 *
 *	This procedure is a helper for the TIP #280 uplevel extension. It
 *	enters location references for the literal arguments of commands in
 *	bytecode about to be invoked. Only the first entry has the actual
 *	data, further entries simply count the usage up.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	May allocate memory.
 *
 * TIP #280
 *----------------------------------------------------------------------
 */

func XTclArgumentBCEnter(tls *libc.TLS, interp uintptr, objv uintptr, objc TTcl_Size, codePtr uintptr, cfPtr uintptr, cmd TTcl_Size, pc TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var cfwPtr, ePtr, eclPtr, hPtr, hePtr, iPtr, lastPtr uintptr
	var word TTcl_Size
	var _ /* isNew at bp+0 */ int32
	_, _, _, _, _, _, _, _ = cfwPtr, ePtr, eclPtr, hPtr, hePtr, iPtr, lastPtr, word
	lastPtr = libc.UintptrFromInt32(0)
	iPtr = interp
	hePtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FlineBCPtr)).FfindProc})))(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlineBCPtr, codePtr)
	if !(hePtr != 0) {
		return
	}
	eclPtr = (*TTcl_HashEntry)(unsafe.Pointer(hePtr)).FclientData
	ePtr = (*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Floc + uintptr(cmd)*32
	/*
	 * ePtr->nline is the number of words originally parsed.
	 *
	 * objc is the number of elements getting invoked.
	 *
	 * If they are not the same, we arrived here by compiling an
	 * ensemble dispatch.  Ensemble subcommands that lead to script
	 * evaluation are not supposed to get compiled, because a command
	 * such as [info level] in the script can expose some of the dispatch
	 * shenanigans.  This means that we don't have to tend to the
	 * housekeeping, and can escape now.
	 */
	if (*TECL)(unsafe.Pointer(ePtr)).Fnline != objc {
		return
	}
	/*
	 * Having disposed of the ensemble cases, we can state...
	 * A few truths ...
	 * (1) ePtr->nline == objc
	 * (2) (ePtr->line[word] < 0) => !literal, for all words
	 * (3) (word == 0) => !literal
	 *
	 * Item (2) is why we can use objv to get the literals, and do not
	 * have to save them at compile time.
	 */
	word = int64(1)
	for {
		if !(word < objc) {
			break
		}
		if *(*TTcl_Size)(unsafe.Pointer((*TECL)(unsafe.Pointer(ePtr)).Fline + uintptr(word)*8)) >= 0 {
			hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FlineLABCPtr)).FcreateProc})))(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlineLABCPtr, *(*uintptr)(unsafe.Pointer(objv + uintptr(word)*8)), bp)
			cfwPtr = XTcl_Alloc(tls, uint64(48))
			(*TCFWordBC)(unsafe.Pointer(cfwPtr)).FframePtr = cfPtr
			(*TCFWordBC)(unsafe.Pointer(cfwPtr)).Fobj = *(*uintptr)(unsafe.Pointer(objv + uintptr(word)*8))
			(*TCFWordBC)(unsafe.Pointer(cfwPtr)).Fpc = pc
			(*TCFWordBC)(unsafe.Pointer(cfwPtr)).Fword = word
			(*TCFWordBC)(unsafe.Pointer(cfwPtr)).FnextPtr = lastPtr
			lastPtr = cfwPtr
			if *(*int32)(unsafe.Pointer(bp)) != 0 {
				/*
				 * The word is not on the stack yet, remember the current
				 * location and initialize references.
				 */
				(*TCFWordBC)(unsafe.Pointer(cfwPtr)).FprevPtr = libc.UintptrFromInt32(0)
			} else {
				/*
				 * The object is already on the stack, however it may have
				 * a different location now (literal sharing may map
				 * multiple location to a single Tcl_Obj*. Save the old
				 * information in the new structure.
				 */
				(*TCFWordBC)(unsafe.Pointer(cfwPtr)).FprevPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
			}
			(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = cfwPtr
		}
		goto _1
	_1:
		;
		word++
	} /* for */
	(*TCmdFrame)(unsafe.Pointer(cfPtr)).Flitarg = lastPtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclArgumentBCRelease --
 *
 *	This procedure is a helper for the TIP #280 uplevel extension. It
 *	removes the location references for the literal arguments of commands
 *	in bytecode just done. Usage is counted down, the data is removed only
 *	when no user is left over.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	May release memory.
 *
 * TIP #280
 *----------------------------------------------------------------------
 */

func XTclArgumentBCRelease(tls *libc.TLS, interp uintptr, cfPtr uintptr) {
	var cfwPtr, hPtr, iPtr, nextPtr, xPtr uintptr
	_, _, _, _, _ = cfwPtr, hPtr, iPtr, nextPtr, xPtr
	iPtr = interp
	cfwPtr = (*TCmdFrame)(unsafe.Pointer(cfPtr)).Flitarg
	for cfwPtr != 0 {
		nextPtr = (*TCFWordBC)(unsafe.Pointer(cfwPtr)).FnextPtr
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FlineLABCPtr)).FfindProc})))(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlineLABCPtr, (*TCFWordBC)(unsafe.Pointer(cfwPtr)).Fobj)
		xPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		if xPtr != cfwPtr {
			XTcl_Panic(tls, __ccgo_ts+8616, 0)
		}
		if (*TCFWordBC)(unsafe.Pointer(cfwPtr)).FprevPtr != 0 {
			(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = (*TCFWordBC)(unsafe.Pointer(cfwPtr)).FprevPtr
		} else {
			XTcl_DeleteHashEntry(tls, hPtr)
		}
		XTclpFree(tls, cfwPtr)
		cfwPtr = nextPtr
	}
	(*TCmdFrame)(unsafe.Pointer(cfPtr)).Flitarg = libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * TclArgumentGet --
 *
 *	This procedure is a helper for the TIP #280 uplevel extension. It
 *	finds the location references for a Tcl_Obj, if any.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Writes found location information into the result arguments.
 *
 * TIP #280
 *----------------------------------------------------------------------
 */

func XTclArgumentGet(tls *libc.TLS, interp uintptr, obj uintptr, cfPtrPtr uintptr, wordPtr uintptr) {
	var cfwPtr, cfwPtr1, framePtr, hPtr, iPtr uintptr
	var v1 int32
	var v2 bool
	_, _, _, _, _, _, _ = cfwPtr, cfwPtr1, framePtr, hPtr, iPtr, v1, v2
	iPtr = interp
	/*
	 * An object which either has no string rep or else is a canonical list is
	 * guaranteed to have been generated dynamically: bail out, this cannot
	 * have a usable absolute location. _Do not touch_ the information the set
	 * up by the caller. It knows better than us.
	 */
	if v2 = !((*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes != libc.UintptrFromInt32(0)); !v2 {
		if (*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			v1 = libc.BoolInt32((*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes == libc.UintptrFromInt32(0) || (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(obj + 32))).Fptr1)).Fflags&int32(LISTSTORE_CANONICAL) != 0 || (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(obj + 32))).Fptr2 != libc.UintptrFromInt32(0))
		} else {
			v1 = 0
		}
	}
	if v2 || v1 != 0 {
		return
	}
	/*
	 * First look for location information recorded in the argument
	 * stack. That is nearest.
	 */
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FlineLAPtr)).FfindProc})))(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlineLAPtr, obj)
	if hPtr != 0 {
		cfwPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		*(*int32)(unsafe.Pointer(wordPtr)) = int32((*TCFWord)(unsafe.Pointer(cfwPtr)).Fword)
		*(*uintptr)(unsafe.Pointer(cfPtrPtr)) = (*TCFWord)(unsafe.Pointer(cfwPtr)).FframePtr
		return
	}
	/*
	 * Check if the Tcl_Obj has location information as a bytecode literal, in
	 * that stack.
	 */
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FlineLABCPtr)).FfindProc})))(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlineLABCPtr, obj)
	if hPtr != 0 {
		cfwPtr1 = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		framePtr = (*TCFWordBC)(unsafe.Pointer(cfwPtr1)).FframePtr
		(*(*struct {
			FcodePtr uintptr
			Fpc      uintptr
		})(unsafe.Pointer(framePtr + 40))).Fpc = (*TByteCode)(unsafe.Pointer((*(*struct {
			FcodePtr uintptr
			Fpc      uintptr
		})(unsafe.Pointer(framePtr + 40))).FcodePtr)).FcodeStart + uintptr((*TCFWordBC)(unsafe.Pointer(cfwPtr1)).Fpc)
		*(*uintptr)(unsafe.Pointer(cfPtrPtr)) = (*TCFWordBC)(unsafe.Pointer(cfwPtr1)).FframePtr
		*(*int32)(unsafe.Pointer(wordPtr)) = int32((*TCFWordBC)(unsafe.Pointer(cfwPtr1)).Fword)
		return
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_EvalObjEx, TclEvalObjEx --
 *
 *	Execute Tcl commands stored in a Tcl object. These commands are
 *	compiled into bytecodes if necessary, unless TCL_EVAL_DIRECT is
 *	specified.
 *
 *	If the flag TCL_EVAL_DIRECT is passed in, the value of invoker
 *	must be NULL.  Support for non-NULL invokers in that mode has
 *	been removed since it was unused and untested.  Failure to
 *	follow this limitation will lead to an assertion panic.
 *
 * Results:
 *	The return value is one of the return codes defined in tcl.h (such as
 *	TCL_OK), and the interpreter's result contains a value to supplement
 *	the return code.
 *
 * Side effects:
 *	The object is converted, if necessary, to a ByteCode object that holds
 *	the bytecode instructions for the commands. Executing the commands
 *	will almost certainly have side effects that depend on those commands.
 *
 * TIP #280 : Keep public API, internally extended API.
 *----------------------------------------------------------------------
 */

func XTcl_EvalObjEx(tls *libc.TLS, interp uintptr, objPtr uintptr, flags int32) (r int32) {
	/* Collection of OR-ed bits that control the
	 * evaluation of the script. Supported values
	 * are TCL_EVAL_GLOBAL and TCL_EVAL_DIRECT. */
	return XTclEvalObjEx(tls, interp, objPtr, flags, libc.UintptrFromInt32(0), 0)
}

func XTclEvalObjEx(tls *libc.TLS, interp uintptr, objPtr uintptr, flags int32, invoker uintptr, word int32) (r int32) {
	/* Index of the word which is in objPtr. */
	var result int32
	var rootPtr uintptr
	_, _ = result, rootPtr
	result = TCL_OK
	rootPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	result = XTclNREvalObjEx(tls, interp, objPtr, flags, invoker, word)
	return XTclNRRunCallbacks(tls, interp, result, rootPtr)
}

func XTclNREvalObjEx(tls *libc.TLS, interp uintptr, objPtr uintptr, flags int32, invoker uintptr, word int32) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Index of the word which is in objPtr. */
	var _objPtr, _objPtr1, cachePtr, cachePtr1, cachePtr2, codePtr, eoFramePtr, iPtr, listPtr, saveCLLocPtr, savedVarFramePtr, script, v10, v8 uintptr
	var allowExceptions, result, v1, v2 int32
	var v11, v3, v7 bool
	var v5, v6 int64
	var v9 TTcl_Size
	var _ /* _callbackPtr at bp+16 */ uintptr
	var _ /* _callbackPtr at bp+24 */ uintptr
	var _ /* numSrcBytes at bp+32 */ TTcl_Size
	var _ /* objc at bp+0 */ TTcl_Size
	var _ /* objv at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, allowExceptions, cachePtr, cachePtr1, cachePtr2, codePtr, eoFramePtr, iPtr, listPtr, result, saveCLLocPtr, savedVarFramePtr, script, v1, v10, v11, v2, v3, v5, v6, v7, v8, v9
	iPtr = interp
	/*
	 * This function consists of three independent blocks for: direct
	 * evaluation of canonical lists, compilation and bytecode execution and
	 * finally direct evaluation. Precisely one of these blocks will be run.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		v1 = libc.BoolInt32((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes == libc.UintptrFromInt32(0) || (*TListStore)(unsafe.Pointer((*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1)).Fflags&int32(LISTSTORE_CANONICAL) != 0 || (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr2 != libc.UintptrFromInt32(0))
	} else {
		v1 = 0
	}
	if v1 != 0 {
		eoFramePtr = libc.UintptrFromInt32(0)
		/*
		 * Canonical List Optimization:  In this case, we
		 * can safely use Tcl_EvalObjv instead and get an appreciable
		 * improvement in execution speed. This is because it allows us to
		 * avoid a setFromAny step that would just pack everything into a
		 * string and back out again.
		 *
		 * This also preserves any associations between list elements and
		 * location information for such elements.
		 */
		/*
		 * Shimmer protection! Always pass an unshared obj. The caller could
		 * incr the refCount of objPtr AFTER calling us! To be completely safe
		 * we always make a copy. The callback takes care of the refCounts for
		 * both listPtr and objPtr.
		 *
		 * TODO: Create a test to demo this need, or eliminate it.
		 * FIXME OPT: preserve just the internal rep?
		 */
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount++
		listPtr = XTclListObjCopy(tls, interp, objPtr)
		(*TTcl_Obj)(unsafe.Pointer(listPtr)).FrefCount++
		if word != -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			/*
			 * TIP #280 Structures for tracking lines. As we know that this is
			 * dynamic execution we ignore the invoker, even if known.
			 *
			 * TIP #280. We do _not_ compute all the line numbers for the
			 * words in the command. For the eval of a pure list the most
			 * sensible choice is to put all words on line 1. Given that we
			 * neither need memory for them nor compute anything. 'line' is
			 * left NULL. The two places using this information (TclInfoFrame,
			 * and TclInitCompileEnv), are special-cased to use the proper
			 * line number directly instead of accessing the 'line' array.
			 *
			 * Note that we use (word==INTMIN) to signal that no command frame
			 * should be pushed, as needed by alias and ensemble redirections.
			 */
			eoFramePtr = XTclStackAlloc(tls, interp, uint64(88))
			(*TCmdFrame)(unsafe.Pointer(eoFramePtr)).Fnline = 0
			(*TCmdFrame)(unsafe.Pointer(eoFramePtr)).Fline = libc.UintptrFromInt32(0)
			(*TCmdFrame)(unsafe.Pointer(eoFramePtr)).Ftype1 = TCL_LOCATION_EVAL
			if (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr == libc.UintptrFromInt32(0) {
				v2 = int32(1)
			} else {
				v2 = (*TCmdFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr)).Flevel + int32(1)
			}
			(*TCmdFrame)(unsafe.Pointer(eoFramePtr)).Flevel = v2
			(*TCmdFrame)(unsafe.Pointer(eoFramePtr)).FframePtr = (*TInterp)(unsafe.Pointer(iPtr)).FframePtr
			(*TCmdFrame)(unsafe.Pointer(eoFramePtr)).FnextPtr = (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr
			(*TCmdFrame)(unsafe.Pointer(eoFramePtr)).FcmdObj = objPtr
			(*TCmdFrame)(unsafe.Pointer(eoFramePtr)).Fcmd = libc.UintptrFromInt32(0)
			(*TCmdFrame)(unsafe.Pointer(eoFramePtr)).Flen1 = 0
			(*TCmdFrame)(unsafe.Pointer(eoFramePtr)).Fdata.Feval.Fpath = libc.UintptrFromInt32(0)
			(*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr = eoFramePtr
			flags |= int32(TCL_EVAL_SOURCE_IN_FRAME)
		}
		XTclMarkTailcall(tls, interp)
		if v3 = interp == libc.UintptrFromInt32(0); !v3 {
			cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
		}
		if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			_objPtr = XTclThreadAllocObj(tls)
		} else {
			_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(_objPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		*(*uintptr)(unsafe.Pointer(bp + 16)) = _objPtr
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FprocPtr = __ccgo_fp(_TEOEx_ListCallback)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8)) = listPtr
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 1*8)) = eoFramePtr
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 2*8)) = objPtr
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
		(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 16))
		if (*TTcl_Obj)(unsafe.Pointer(listPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr + 32))).Fptr2 != 0 {
				v5 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listPtr + 32))).Fptr2)).FspanStart
			} else {
				v5 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listPtr + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr + 32))).Fptr1 + 40 + uintptr(v5)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr + 32))).Fptr2 != 0 {
				v6 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listPtr + 32))).Fptr2)).FspanLength
			} else {
				v6 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listPtr + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp)) = v6
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), listPtr, bp, bp+8)
		}
		return XTclNREvalObjv(tls, interp, *(*TTcl_Size)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 8)), flags, libc.UintptrFromInt32(0))
	}
	if !(flags&libc.Int32FromInt32(TCL_EVAL_DIRECT) != 0) {
		/*
		 * Let the compiler/engine subsystem do the evaluation.
		 *
		 * TIP #280 The invoker provides us with the context for the script.
		 * We transfer this to the byte code compiler.
		 */
		allowExceptions = (*TInterp)(unsafe.Pointer(iPtr)).FevalFlags & int32(TCL_ALLOW_EXCEPTIONS)
		savedVarFramePtr = libc.UintptrFromInt32(0) /* Saves old copy of
		 * iPtr->varFramePtr in case
		 * TCL_EVAL_GLOBAL was set. */
		if XTclInterpReady(tls, interp) != TCL_OK {
			return int32(TCL_ERROR)
		}
		if flags&int32(TCL_EVAL_GLOBAL) != 0 {
			savedVarFramePtr = (*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr
			(*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr = (*TInterp)(unsafe.Pointer(iPtr)).FrootFramePtr
		}
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount++
		codePtr = XTclCompileObj(tls, interp, objPtr, invoker, word)
		if v7 = interp == libc.UintptrFromInt32(0); !v7 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
		}
		if v7 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			_objPtr1 = XTclThreadAllocObj(tls)
		} else {
			_objPtr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(_objPtr1 + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		*(*uintptr)(unsafe.Pointer(bp + 24)) = _objPtr1
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).FprocPtr = __ccgo_fp(_TEOEx_ByteCodeCallback)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 8)) = savedVarFramePtr
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 8 + 1*8)) = objPtr
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 8 + 2*8)) = uintptr(int64(allowExceptions))
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
		(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 24))
		return XTclNRExecuteByteCode(tls, interp, codePtr)
	}
	/*
	 * Now we check if we have data about invisible continuation lines for
	 * the script, and make it available to the direct script parser and
	 * evaluator we are about to call, if so.
	 *
	 * It may be possible that the script Tcl_Obj* can be free'd while the
	 * evaluator is using it, leading to the release of the associated
	 * ContLineLoc structure as well. To ensure that the latter doesn't
	 * happen we set a lock on it. We release this lock later in this
	 * function, after the evaluator is done. The relevant "lineCLPtr"
	 * hashtable is managed in the file "tclObj.c".
	 *
	 * Another important action is to save (and later restore) the
	 * continuation line information of the caller, in case we are
	 * executing nested commands in the eval/direct path.
	 */
	saveCLLocPtr = (*TInterp)(unsafe.Pointer(iPtr)).FscriptCLLocPtr
	(*TInterp)(unsafe.Pointer(iPtr)).FscriptCLLocPtr = XTclContinuationsGet(tls, objPtr)
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount++
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
		v8 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		v8 = XTcl_GetStringFromObj(tls, objPtr, bp+32)
	}
	script = v8
	result = XTcl_EvalEx(tls, interp, script, *(*TTcl_Size)(unsafe.Pointer(bp + 32)), flags)
	v10 = objPtr
	v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
	*(*TTcl_Size)(unsafe.Pointer(v10))--
	if !(v9 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(-libc.Int32FromInt32(1))
			if v11 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v11 {
				cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v11 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, objPtr)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = objPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, objPtr)
		}
	}
	(*TInterp)(unsafe.Pointer(iPtr)).FscriptCLLocPtr = saveCLLocPtr
	return result
	return r
}

func _TEOEx_ByteCodeCallback(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var allowExceptions int32
	var cachePtr, iPtr, objPtr, savedVarFramePtr, script, v1, v3 uintptr
	var v2 TTcl_Size
	var v4 bool
	var _ /* numSrcBytes at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _ = allowExceptions, cachePtr, iPtr, objPtr, savedVarFramePtr, script, v1, v2, v3, v4
	iPtr = interp
	savedVarFramePtr = *(*uintptr)(unsafe.Pointer(data))
	objPtr = *(*uintptr)(unsafe.Pointer(data + 1*8))
	allowExceptions = int32(int64(*(*uintptr)(unsafe.Pointer(data + 2*8))))
	if (*TInterp)(unsafe.Pointer(iPtr)).FnumLevels == 0 {
		if result == int32(TCL_RETURN) {
			result = XTclUpdateReturnInfo(tls, iPtr)
		}
		if result != TCL_OK && result != int32(TCL_ERROR) && !(allowExceptions != 0) {
			_ProcessUnexpectedResult(tls, interp, result)
			result = int32(TCL_ERROR)
			if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
				v1 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
			} else {
				v1 = XTcl_GetStringFromObj(tls, objPtr, bp)
			}
			script = v1
			XTcl_LogCommandInfo(tls, interp, script, script, *(*TTcl_Size)(unsafe.Pointer(bp)))
		}
		/*
		 * We are returning to level 0, so should call TclResetCancellation.
		 * Let us just unset the flags inline.
		 */
		*(*int32)(unsafe.Pointer(iPtr + 368)) &= ^(libc.Int32FromInt32(CANCELED) | libc.Int32FromInt32(TCL_CANCEL_UNWIND))
	}
	(*TInterp)(unsafe.Pointer(iPtr)).FevalFlags = 0
	/*
	 * Restore the callFrame if this was a TCL_EVAL_GLOBAL.
	 */
	if savedVarFramePtr != 0 {
		(*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr = savedVarFramePtr
	}
	v3 = objPtr
	v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
	*(*TTcl_Size)(unsafe.Pointer(v3))--
	if !(v2 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(-libc.Int32FromInt32(1))
			if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v4 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, objPtr)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = objPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, objPtr)
		}
	}
	return result
}

func _TEOEx_ListCallback(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	var cachePtr, cachePtr1, eoFramePtr, iPtr, listPtr, objPtr, v2, v5 uintptr
	var v1, v4 TTcl_Size
	var v3, v6 bool
	_, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, eoFramePtr, iPtr, listPtr, objPtr, v1, v2, v3, v4, v5, v6
	iPtr = interp
	listPtr = *(*uintptr)(unsafe.Pointer(data))
	eoFramePtr = *(*uintptr)(unsafe.Pointer(data + 1*8))
	objPtr = *(*uintptr)(unsafe.Pointer(data + 2*8))
	/*
	 * Remove the cmdFrame
	 */
	if eoFramePtr != 0 {
		(*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr = (*TCmdFrame)(unsafe.Pointer(eoFramePtr)).FnextPtr
		XTclStackFree(tls, interp, eoFramePtr)
	}
	v2 = objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if !(v1 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(-libc.Int32FromInt32(1))
			if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, objPtr)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = objPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, objPtr)
		}
	}
	v5 = listPtr
	v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
	*(*TTcl_Size)(unsafe.Pointer(v5))--
	if !(v4 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(listPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listPtr)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(listPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(listPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(listPtr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(listPtr)).Flength = int64(-libc.Int32FromInt32(1))
			if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v6 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, listPtr)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = listPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, listPtr)
		}
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * ProcessUnexpectedResult --
 *
 *	Function called by Tcl_EvalObj to set the interpreter's result value
 *	to an appropriate error message when the code it evaluates returns an
 *	unexpected result code (not TCL_OK and not TCL_ERROR) to the topmost
 *	evaluation level.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The interpreter result is set to an error message appropriate to the
 *	result code.
 *
 *----------------------------------------------------------------------
 */

func _ProcessUnexpectedResult(tls *libc.TLS, interp uintptr, returnCode int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* The unexpected result code. */
	var _ /* buf at bp+0 */ [24]uint8
	XTcl_ResetResult(tls, interp)
	if returnCode == int32(TCL_BREAK) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+8653, int64(-libc.Int32FromInt32(1))))
	} else {
		if returnCode == int32(TCL_CONTINUE) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+8687, int64(-libc.Int32FromInt32(1))))
		} else {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+8724, libc.VaList(bp+32, returnCode)))
		}
	}
	libc.X__builtin_snprintf(tls, bp, uint64(24), __ccgo_ts+260, libc.VaList(bp+32, returnCode))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+32, __ccgo_ts+2004, __ccgo_ts+8754, bp, libc.UintptrFromInt32(0)))
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_ExprLong, Tcl_ExprDouble, Tcl_ExprBoolean --
 *
 *	Functions to evaluate an expression and return its value in a
 *	particular form.
 *
 * Results:
 *	Each of the functions below returns a standard Tcl result. If an error
 *	occurs then an error message is left in the interp's result. Otherwise
 *	the value of the expression, in the appropriate form, is stored at
 *	*ptr. If the expression had a result that was incompatible with the
 *	desired form then an error is returned.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_ExprLong(tls *libc.TLS, interp uintptr, exprstring uintptr, ptr uintptr) (r int32) {
	/* Where to store result. */
	var _objPtr, exprPtr, v2 uintptr
	var result int32
	var v1 TTcl_Size
	_, _, _, _, _ = _objPtr, exprPtr, result, v1, v2
	result = TCL_OK
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(exprstring))) == int32('\000') {
		/*
		 * Legacy compatibility - return 0 for the zero-length string.
		 */
		*(*int64)(unsafe.Pointer(ptr)) = 0
	} else {
		exprPtr = XTcl_NewStringObj(tls, exprstring, int64(-libc.Int32FromInt32(1)))
		(*TTcl_Obj)(unsafe.Pointer(exprPtr)).FrefCount++
		result = XTcl_ExprLongObj(tls, interp, exprPtr, ptr)
		_objPtr = exprPtr
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	return result
}

func XTcl_ExprDouble(tls *libc.TLS, interp uintptr, exprstring uintptr, ptr uintptr) (r int32) {
	/* Where to store result. */
	var _objPtr, exprPtr, v2 uintptr
	var result int32
	var v1 TTcl_Size
	_, _, _, _, _ = _objPtr, exprPtr, result, v1, v2
	result = TCL_OK
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(exprstring))) == int32('\000') {
		/*
		 * Legacy compatibility - return 0 for the zero-length string.
		 */
		*(*float64)(unsafe.Pointer(ptr)) = float64(0)
	} else {
		exprPtr = XTcl_NewStringObj(tls, exprstring, int64(-libc.Int32FromInt32(1)))
		(*TTcl_Obj)(unsafe.Pointer(exprPtr)).FrefCount++
		result = XTcl_ExprDoubleObj(tls, interp, exprPtr, ptr)
		_objPtr = exprPtr
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		/* Discard the expression object. */
	}
	return result
}

func XTcl_ExprBoolean(tls *libc.TLS, interp uintptr, exprstring uintptr, ptr uintptr) (r int32) {
	/* Where to store 0/1 result. */
	var _objPtr, exprPtr, v2 uintptr
	var result int32
	var v1 TTcl_Size
	_, _, _, _, _ = _objPtr, exprPtr, result, v1, v2
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(exprstring))) == int32('\000') {
		/*
		 * An empty string. Just set the result boolean to 0 (false).
		 */
		*(*int32)(unsafe.Pointer(ptr)) = 0
		return TCL_OK
	} else {
		exprPtr = XTcl_NewStringObj(tls, exprstring, int64(-libc.Int32FromInt32(1)))
		(*TTcl_Obj)(unsafe.Pointer(exprPtr)).FrefCount++
		result = XTcl_ExprBooleanObj(tls, interp, exprPtr, ptr)
		_objPtr = exprPtr
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		return result
	}
	return r
}

/*
 *--------------------------------------------------------------
 *
 * Tcl_ExprLongObj, Tcl_ExprDoubleObj, Tcl_ExprBooleanObj --
 *
 *	Functions to evaluate an expression in an object and return its value
 *	in a particular form.
 *
 * Results:
 *	Each of the functions below returns a standard Tcl result object. If
 *	an error occurs then an error message is left in the interpreter's
 *	result. Otherwise the value of the expression, in the appropriate
 *	form, is stored at *ptr. If the expression had a result that was
 *	incompatible with the desired form then an error is returned.
 *
 * Side effects:
 *	None.
 *
 *--------------------------------------------------------------
 */

func XTcl_ExprLongObj(tls *libc.TLS, interp uintptr, objPtr uintptr, ptr uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Where to store long result. */
	var _objPtr, _objPtr1, v2, v5 uintptr
	var result, v3 int32
	var v1, v4 TTcl_Size
	var _ /* big at bp+32 */ Tmp_int
	var _ /* d at bp+16 */ float64
	var _ /* internalPtr at bp+24 */ uintptr
	var _ /* resultPtr at bp+0 */ uintptr
	var _ /* type at bp+8 */ int32
	_, _, _, _, _, _, _, _ = _objPtr, _objPtr1, result, v1, v2, v3, v4, v5
	result = XTcl_ExprObj(tls, interp, objPtr, bp)
	if result != TCL_OK {
		return int32(TCL_ERROR)
	}
	if XTcl_GetNumberFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), bp+24, bp+8) != TCL_OK {
		return int32(TCL_ERROR)
	}
	switch *(*int32)(unsafe.Pointer(bp + 8)) {
	case int32(TCL_NUMBER_DOUBLE):
		*(*float64)(unsafe.Pointer(bp + 16)) = *(*float64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24))))
		_objPtr = *(*uintptr)(unsafe.Pointer(bp))
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		if XTcl_InitBignumFromDouble(tls, interp, *(*float64)(unsafe.Pointer(bp + 16)), bp+32) != TCL_OK {
			return int32(TCL_ERROR)
		}
		*(*uintptr)(unsafe.Pointer(bp)) = XTcl_NewBignumObj(tls, bp+32)
		/* FALLTHRU */
		fallthrough
	case int32(TCL_NUMBER_INT):
		fallthrough
	case int32(TCL_NUMBER_BIG):
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
			*(*int64)(unsafe.Pointer(ptr)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FinternalRep))
			v3 = libc.Int32FromInt32(TCL_OK)
		} else {
			v3 = XTcl_GetLongFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), ptr)
		}
		result = v3
	case int32(TCL_NUMBER_NAN):
		XTcl_GetDoubleFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), bp+16)
		result = int32(TCL_ERROR)
	}
	_objPtr1 = *(*uintptr)(unsafe.Pointer(bp))
	v5 = _objPtr1
	v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
	*(*TTcl_Size)(unsafe.Pointer(v5))--
	if v4 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	} /* Discard the result object. */
	return result
}

func XTcl_ExprDoubleObj(tls *libc.TLS, interp uintptr, objPtr uintptr, ptr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Where to store double result. */
	var _objPtr, v2 uintptr
	var result int32
	var v1 TTcl_Size
	var _ /* internalPtr at bp+16 */ uintptr
	var _ /* resultPtr at bp+0 */ uintptr
	var _ /* type at bp+8 */ int32
	_, _, _, _ = _objPtr, result, v1, v2
	result = XTcl_ExprObj(tls, interp, objPtr, bp)
	if result != TCL_OK {
		return int32(TCL_ERROR)
	}
	result = XTcl_GetNumberFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), bp+16, bp+8)
	if result == TCL_OK {
		switch *(*int32)(unsafe.Pointer(bp + 8)) {
		case int32(TCL_NUMBER_NAN):
			result = XTcl_GetDoubleFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), ptr)
		case int32(TCL_NUMBER_DOUBLE):
			*(*float64)(unsafe.Pointer(ptr)) = *(*float64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16))))
			result = TCL_OK
		default:
			result = XTcl_GetDoubleFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), ptr)
		}
	}
	_objPtr = *(*uintptr)(unsafe.Pointer(bp))
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	} /* Discard the result object. */
	return result
}

func XTcl_ExprBooleanObj(tls *libc.TLS, interp uintptr, objPtr uintptr, ptr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Where to store 0/1 result. */
	var _objPtr, v2 uintptr
	var result int32
	var v1 TTcl_Size
	var _ /* resultPtr at bp+0 */ uintptr
	_, _, _, _ = _objPtr, result, v1, v2
	result = XTcl_ExprObj(tls, interp, objPtr, bp)
	if result == TCL_OK {
		result = XTcl_GetBoolFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), (libc.Int32FromInt32(TCL_NULL_OK)-libc.Int32FromInt32(2))&libc.Int32FromInt64(4), ptr)
		_objPtr = *(*uintptr)(unsafe.Pointer(bp))
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		/* Discard the result object. */
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * TclObjInvokeNamespace --
 *
 *	Object version: Invokes a Tcl command, given an objv/objc, from either
 *	the exposed or hidden set of commands in the given interpreter.
 *
 *	NOTE: The command is invoked in the global stack frame of the
 *	interpreter or namespace, thus it cannot see any current state on the
 *	stack of that interpreter.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Whatever the command does.
 *
 *----------------------------------------------------------------------
 */

func XTclObjInvokeNamespace(tls *libc.TLS, interp uintptr, objc TTcl_Size, objv uintptr, nsPtr uintptr, flags int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Combination of flags controlling the call:
	 * TCL_INVOKE_HIDDEN, TCL_INVOKE_NO_UNKNOWN,
	 * or TCL_INVOKE_NO_TRACEBACK. */
	var result int32
	var _ /* framePtr at bp+0 */ uintptr
	_ = result
	/*
	 * Make the specified namespace the current namespace and invoke the
	 * command.
	 */
	XTclPushStackFrame(tls, interp, bp, nsPtr, 0)
	result = XTclObjInvoke(tls, interp, objc, objv, flags)
	XTclPopStackFrame(tls, interp)
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * TclObjInvoke --
 *
 *	Invokes a Tcl command, given an objv/objc, from either the exposed or
 *	the hidden sets of commands in the given interpreter.
 *
 * Results:
 *	A standard Tcl object result.
 *
 * Side effects:
 *	Whatever the command does.
 *
 *----------------------------------------------------------------------
 */

func XTclObjInvoke(tls *libc.TLS, interp uintptr, objc TTcl_Size, objv uintptr, flags int32) (r int32) {
	/* Combination of flags controlling the call:
	 * TCL_INVOKE_HIDDEN, TCL_INVOKE_NO_UNKNOWN,
	 * or TCL_INVOKE_NO_TRACEBACK. */
	if interp == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if objc < int64(1) || objv == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+8777, int64(-libc.Int32FromInt32(1))))
		return int32(TCL_ERROR)
	}
	if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(0)) == 0 {
		XTcl_Panic(tls, __ccgo_ts+8801, 0)
	}
	return XTcl_NRCallObjProc(tls, interp, __ccgo_fp(XTclNRInvoke), libc.UintptrFromInt32(0), objc, objv)
}

func XTclNRInvoke(tls *libc.TLS, dummy6713 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var cmdName, cmdPtr, hPtr, hTblPtr, iPtr, v1 uintptr
	_, _, _, _, _, _ = cmdName, cmdPtr, hPtr, hTblPtr, iPtr, v1
	iPtr = interp /* Name of the command from objv[0]. */
	hPtr = libc.UintptrFromInt32(0)
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv)), libc.UintptrFromInt32(0))
	}
	cmdName = v1
	hTblPtr = (*TInterp)(unsafe.Pointer(iPtr)).FhiddenCmdTablePtr
	if hTblPtr != libc.UintptrFromInt32(0) {
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(hTblPtr)).FfindProc})))(tls, hTblPtr, cmdName)
	}
	if hPtr == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+8848, libc.VaList(bp+8, cmdName)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+7718, cmdName, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	cmdPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
	/*
	 * Avoid the exception-handling brain damage when numLevels == 0
	 */
	(*TInterp)(unsafe.Pointer(iPtr)).FnumLevels++
	XTcl_NRAddCallback(tls, interp, __ccgo_fp(_NRPostInvoke), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	/*
	 * Normal command resolution of objv[0] isn't going to find cmdPtr.
	 * That's the whole point of **hidden** commands.  So tell the Eval core
	 * machinery not to even try (and risk finding something wrong).
	 */
	return XTclNREvalObjv(tls, interp, int64(objc), objv, int32(TCL_EVAL_NORESOLVE), cmdPtr)
}

func _NRPostInvoke(tls *libc.TLS, dummy6756 uintptr, interp uintptr, result int32) (r int32) {
	var iPtr uintptr
	_ = iPtr
	iPtr = interp
	(*TInterp)(unsafe.Pointer(iPtr)).FnumLevels--
	return result
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_ExprString --
 *
 *	Evaluate an expression in a string and return its value in string
 *	form.
 *
 * Results:
 *	A standard Tcl result. If the result is TCL_OK, then the interp's
 *	result is set to the string value of the expression. If the result is
 *	TCL_ERROR, then the interp's result contains an error message.
 *
 * Side effects:
 *	A Tcl object is allocated to hold a copy of the expression string.
 *	This expression object is passed to Tcl_ExprObj and then deallocated.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_ExprString(tls *libc.TLS, interp uintptr, expr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Expression to evaluate. */
	var _objPtr, _objPtr1, exprObj, v2, v4 uintptr
	var code int32
	var v1, v3 TTcl_Size
	var _ /* resultPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _ = _objPtr, _objPtr1, code, exprObj, v1, v2, v3, v4
	code = TCL_OK
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(expr))) == int32('\000') {
		/*
		 * An empty string. Just set the interpreter's result to 0.
		 */
		XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, 0))
	} else {
		exprObj = XTcl_NewStringObj(tls, expr, int64(-libc.Int32FromInt32(1)))
		(*TTcl_Obj)(unsafe.Pointer(exprObj)).FrefCount++
		code = XTcl_ExprObj(tls, interp, exprObj, bp)
		_objPtr = exprObj
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		if code == TCL_OK {
			XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(bp)))
			_objPtr1 = *(*uintptr)(unsafe.Pointer(bp))
			v4 = _objPtr1
			v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
			*(*TTcl_Size)(unsafe.Pointer(v4))--
			if v3 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
		}
	}
	return code
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_AppendObjToErrorInfo --
 *
 *	Add a Tcl_Obj value to the errorInfo field that describes the current
 *	error.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The value of the Tcl_obj is appended to the errorInfo field. If we are
 *	just starting to log an error, errorInfo is initialized from the error
 *	message in the interpreter's result.
 *
 *----------------------------------------------------------------------
 */

func XTcl_AppendObjToErrorInfo(tls *libc.TLS, interp uintptr, objPtr uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Message to record. */
	var _objPtr, _objPtr1, iPtr, message, v1, v3, v5 uintptr
	var v2, v4 TTcl_Size
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, iPtr, message, v1, v2, v3, v4, v5
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, objPtr, bp)
	}
	message = v1
	iPtr = interp
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount++
	/*
	 * If we are just starting to log an error, errorInfo is initialized from
	 * the error message in the interpreter's result.
	 */
	*(*int32)(unsafe.Pointer(iPtr + 368)) |= int32(ERR_LEGACY_COPY)
	if (*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo == libc.UintptrFromInt32(0) {
		(*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo = (*TInterp)(unsafe.Pointer(iPtr)).FobjResultPtr
		(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo)).FrefCount++
		if !((*TInterp)(unsafe.Pointer(iPtr)).FerrorCode != 0) {
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+8881, libc.UintptrFromInt32(0)))
		}
	}
	/*
	 * Now append "message" to the end of errorInfo.
	 */
	if *(*TTcl_Size)(unsafe.Pointer(bp)) != 0 {
		if (*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo)).FrefCount > int64(1) {
			_objPtr = (*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo
			v3 = _objPtr
			v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
			*(*TTcl_Size)(unsafe.Pointer(v3))--
			if v2 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			(*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo = XTcl_DuplicateObj(tls, (*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo)
			(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo)).FrefCount++
		}
		XTcl_AppendToObj(tls, (*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo, message, *(*TTcl_Size)(unsafe.Pointer(bp)))
	}
	_objPtr1 = objPtr
	v5 = _objPtr1
	v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
	*(*TTcl_Size)(unsafe.Pointer(v5))--
	if v4 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_VarEval --
 *
 *	Given a variable number of string arguments, concatenate them all
 *	together and execute the result as a Tcl command.
 *
 * Results:
 *	A standard Tcl return result. An error message or other result may be
 *	left in the interp.
 *
 * Side effects:
 *	Depends on what was done by the command.
 *
 *----------------------------------------------------------------------
 */

func XTcl_VarEval(tls *libc.TLS, interp uintptr, va uintptr) (r int32) {
	bp := tls.Alloc(224)
	defer tls.Free(224)
	var argList Tva_list
	var result int32
	var string1 uintptr
	var _ /* buf at bp+0 */ TTcl_DString
	_, _, _ = argList, result, string1
	argList = va
	/*
	 * Copy the strings one after the other into a single larger string. Use
	 * stack-allocated space for small commands, but if the command gets too
	 * large than call Tcl_Alloc to create the space.
	 */
	XTcl_DStringInit(tls, bp)
	for int32(1) != 0 {
		string1 = libc.VaUintptr(&argList)
		if string1 == libc.UintptrFromInt32(0) {
			break
		}
		XTcl_DStringAppend(tls, bp, string1, int64(-libc.Int32FromInt32(1)))
	}
	result = XTcl_EvalEx(tls, interp, (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1, int64(-libc.Int32FromInt32(1)), 0)
	XTcl_DStringFree(tls, bp)
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetRecursionLimit --
 *
 *	Set the maximum number of recursive calls that may be active for an
 *	interpreter at once.
 *
 * Results:
 *	The return value is the old limit on nesting for interp.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetRecursionLimit(tls *libc.TLS, interp uintptr, depth TTcl_Size) (r TTcl_Size) {
	/* New value for maximum depth. */
	var iPtr uintptr
	var old TTcl_Size
	_, _ = iPtr, old
	iPtr = interp
	old = (*TInterp)(unsafe.Pointer(iPtr)).FmaxNestingDepth
	if depth > 0 {
		(*TInterp)(unsafe.Pointer(iPtr)).FmaxNestingDepth = depth
	}
	return old
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_AllowExceptions --
 *
 *	Sets a flag in an interpreter so that exceptions can occur in the next
 *	call to Tcl_Eval without them being turned into errors.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The TCL_ALLOW_EXCEPTIONS flag gets set in the interpreter's evalFlags
 *	structure. See the reference documentation for more details.
 *
 *----------------------------------------------------------------------
 */

func XTcl_AllowExceptions(tls *libc.TLS, interp uintptr) {
	/* Interpreter in which to set flag. */
	var iPtr uintptr
	_ = iPtr
	iPtr = interp
	*(*int32)(unsafe.Pointer(iPtr + 256)) |= int32(TCL_ALLOW_EXCEPTIONS)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetVersion --
 *
 *	Get the Tcl major, minor, and patchlevel version numbers and the
 *	release type. A patch is a release type TCL_FINAL_RELEASE with a
 *	patchLevel > 0.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetVersion(tls *libc.TLS, majorV uintptr, minorV uintptr, patchLevelV uintptr, type1 uintptr) {
	if majorV != libc.UintptrFromInt32(0) {
		*(*int32)(unsafe.Pointer(majorV)) = int32(TCL_MAJOR_VERSION)
	}
	if minorV != libc.UintptrFromInt32(0) {
		*(*int32)(unsafe.Pointer(minorV)) = TCL_MINOR_VERSION
	}
	if patchLevelV != libc.UintptrFromInt32(0) {
		*(*int32)(unsafe.Pointer(patchLevelV)) = int32(TCL_RELEASE_SERIAL)
	}
	if type1 != libc.UintptrFromInt32(0) {
		*(*int32)(unsafe.Pointer(type1)) = int32(TCL_FINAL_RELEASE)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Math Functions --
 *
 *	This page contains the functions that implement all of the built-in
 *	math functions for expressions.
 *
 * Results:
 *	Each function returns TCL_OK if it succeeds and pushes an Tcl object
 *	holding the result. If it fails it returns TCL_ERROR and leaves an
 *	error message in the interpreter's result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _ExprCeilFunc(tls *libc.TLS, dummy7043 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Actual parameter list. */
	var code int32
	var _ /* big at bp+8 */ Tmp_int
	var _ /* d at bp+0 */ float64
	_ = code
	if objc != int32(2) {
		_MathFuncWrongNumArgs(tls, interp, int32(2), objc, objv)
		return int32(TCL_ERROR)
	}
	code = XTcl_GetDoubleFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
	if code != TCL_OK {
		return int32(TCL_ERROR)
	}
	if XTcl_GetBignumFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+8) == TCL_OK {
		XTcl_SetObjResult(tls, interp, XTcl_NewDoubleObj(tls, XTclCeil(tls, bp+8)))
		XTclBN_mp_clear(tls, bp+8)
	} else {
		XTcl_SetObjResult(tls, interp, XTcl_NewDoubleObj(tls, libc.Xceil(tls, *(*float64)(unsafe.Pointer(bp)))))
	}
	return TCL_OK
}

func _ExprFloorFunc(tls *libc.TLS, dummy7083 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Actual parameter list. */
	var code int32
	var _ /* big at bp+8 */ Tmp_int
	var _ /* d at bp+0 */ float64
	_ = code
	if objc != int32(2) {
		_MathFuncWrongNumArgs(tls, interp, int32(2), objc, objv)
		return int32(TCL_ERROR)
	}
	code = XTcl_GetDoubleFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
	if code != TCL_OK {
		return int32(TCL_ERROR)
	}
	if XTcl_GetBignumFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+8) == TCL_OK {
		XTcl_SetObjResult(tls, interp, XTcl_NewDoubleObj(tls, XTclFloor(tls, bp+8)))
		XTclBN_mp_clear(tls, bp+8)
	} else {
		XTcl_SetObjResult(tls, interp, XTcl_NewDoubleObj(tls, libc.Xfloor(tls, *(*float64)(unsafe.Pointer(bp)))))
	}
	return TCL_OK
}

func _ExprIsqrtFunc(tls *libc.TLS, dummy7123 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(128)
	defer tls.Free(128) /* Actual parameter list. */
	var err Tmp_err
	var exact, v1, v2 int32
	var _ /* big at bp+32 */ Tmp_int
	var _ /* d at bp+16 */ float64
	var _ /* ptr at bp+0 */ uintptr
	var _ /* root at bp+56 */ Tmp_int
	var _ /* type at bp+8 */ int32
	var _ /* w at bp+24 */ TTcl_WideInt
	_, _, _, _ = err, exact, v1, v2
	exact = 0 /* Flag ==1 if the argument can be represented
	 * in a double as an exact integer. */
	/*
	 * Check syntax.
	 */
	if objc != int32(2) {
		_MathFuncWrongNumArgs(tls, interp, int32(2), objc, objv)
		return int32(TCL_ERROR)
	}
	/*
	 * Make sure that the arg is a number.
	 */
	if XTcl_GetNumberFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp, bp+8) != TCL_OK {
		return int32(TCL_ERROR)
	}
	switch *(*int32)(unsafe.Pointer(bp + 8)) {
	case int32(TCL_NUMBER_NAN):
		XTcl_GetDoubleFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+16)
		return int32(TCL_ERROR)
	case int32(TCL_NUMBER_DOUBLE):
		*(*float64)(unsafe.Pointer(bp + 16)) = *(*float64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))
		if *(*float64)(unsafe.Pointer(bp + 16)) < libc.Float64FromInt32(0) {
			goto negarg
		}
		if *(*float64)(unsafe.Pointer(bp + 16)) <= float64(9.007199254740991e+15) {
			exact = int32(1)
		}
		if !(exact != 0) {
			if XTcl_InitBignumFromDouble(tls, interp, *(*float64)(unsafe.Pointer(bp + 16)), bp+32) != TCL_OK {
				return int32(TCL_ERROR)
			}
		}
	case int32(TCL_NUMBER_BIG):
		if XTcl_GetBignumFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+32) != TCL_OK {
			return int32(TCL_ERROR)
		}
		if (*Tmp_int)(unsafe.Pointer(bp+32)).Fsign != MP_ZPOS {
			v1 = int32(MP_YES)
		} else {
			v1 = MP_NO
		}
		if v1 != 0 {
			XTclBN_mp_clear(tls, bp+32)
			goto negarg
		}
	default:
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
			*(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FinternalRep))
			v2 = libc.Int32FromInt32(TCL_OK)
		} else {
			v2 = XTcl_GetWideIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+24)
		}
		if v2 != TCL_OK {
			return int32(TCL_ERROR)
		}
		if *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) < 0 {
			goto negarg
		}
		*(*float64)(unsafe.Pointer(bp + 16)) = float64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 24)))
		if *(*float64)(unsafe.Pointer(bp + 16)) < float64(9.007199254740991e+15) {
			exact = int32(1)
		}
		if !(exact != 0) {
			XTcl_GetBignumFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+32)
		}
		break
	}
	if exact != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, int64(libc.Xsqrt(tls, *(*float64)(unsafe.Pointer(bp + 16))))))
	} else {
		err = XTclBN_mp_init(tls, bp+56)
		if err == MP_OKAY {
			err = XTclBN_mp_sqrt(tls, bp+32, bp+56)
		}
		XTclBN_mp_clear(tls, bp+32)
		if err != MP_OKAY {
			return int32(TCL_ERROR)
		}
		XTcl_SetObjResult(tls, interp, XTcl_NewBignumObj(tls, bp+56))
	}
	return TCL_OK
	goto negarg
negarg:
	;
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+8886, int64(-libc.Int32FromInt32(1))))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+88, __ccgo_ts+8919, __ccgo_ts+8925, __ccgo_ts+8932, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
}

func _ExprSqrtFunc(tls *libc.TLS, dummy7229 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Actual parameter list. */
	var code int32
	var err Tmp_err
	var v1 uint64
	var v3 bool
	var _ /* __u at bp+0 */ struct {
		F__i [0]uint64
		F__f float64
	}
	var _ /* big at bp+16 */ Tmp_int
	var _ /* d at bp+8 */ float64
	var _ /* root at bp+40 */ Tmp_int
	_, _, _, _ = code, err, v1, v3
	if objc != int32(2) {
		_MathFuncWrongNumArgs(tls, interp, int32(2), objc, objv)
		return int32(TCL_ERROR)
	}
	code = XTcl_GetDoubleFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+8)
	if code != TCL_OK {
		return int32(TCL_ERROR)
	}
	if v3 = *(*float64)(unsafe.Pointer(bp + 8)) >= float64(0); v3 {
		*(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(bp + 8))
		v1 = *(*uint64)(unsafe.Pointer(bp))
		goto _2
	_2:
	}
	if v3 && libc.BoolInt32(v1&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) == libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 && XTcl_GetBignumFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+16) == TCL_OK {
		err = XTclBN_mp_init(tls, bp+40)
		if err == MP_OKAY {
			err = XTclBN_mp_sqrt(tls, bp+16, bp+40)
		}
		XTclBN_mp_clear(tls, bp+16)
		if err != MP_OKAY {
			XTclBN_mp_clear(tls, bp+40)
			return int32(TCL_ERROR)
		}
		XTcl_SetObjResult(tls, interp, XTcl_NewDoubleObj(tls, XTclBignumToDouble(tls, bp+40)))
		XTclBN_mp_clear(tls, bp+40)
	} else {
		XTcl_SetObjResult(tls, interp, XTcl_NewDoubleObj(tls, libc.Xsqrt(tls, *(*float64)(unsafe.Pointer(bp + 8)))))
	}
	return TCL_OK
}

func _ExprUnaryFunc(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Actual parameter list */
	var code int32
	var func1 uintptr
	var _ /* d at bp+0 */ float64
	_, _ = code, func1
	func1 = clientData
	if objc != int32(2) {
		_MathFuncWrongNumArgs(tls, interp, int32(2), objc, objv)
		return int32(TCL_ERROR)
	}
	code = XTcl_GetDoubleFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
	if code != TCL_OK {
		return int32(TCL_ERROR)
	}
	*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = 0
	return _CheckDoubleResult(tls, interp, (*(*func(*libc.TLS, float64) float64)(unsafe.Pointer(&struct{ uintptr }{func1})))(tls, *(*float64)(unsafe.Pointer(bp))))
}

func _CheckDoubleResult(tls *libc.TLS, interp uintptr, dResult float64) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var v1, v3 uint64
	var v5, v6 bool
	var _ /* __u at bp+0 */ struct {
		F__i [0]uint64
		F__f float64
	}
	_, _, _, _ = v1, v3, v5, v6
	*(*float64)(unsafe.Pointer(bp)) = dResult
	v1 = *(*uint64)(unsafe.Pointer(bp))
	goto _2
_2:
	if libc.BoolInt32(v1&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) > libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
		XTclExprFloatError(tls, interp, dResult)
		return int32(TCL_ERROR)
	}
	if v6 = *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(ERANGE); v6 {
		if v5 = dResult == float64(0); !v5 {
			*(*float64)(unsafe.Pointer(bp)) = dResult
			v3 = *(*uint64)(unsafe.Pointer(bp))
			goto _4
		_4:
		}
	}
	if v6 && (v5 || libc.BoolInt32(v3&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) == libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0) {
		/*
		 * When ERANGE signals under/overflow, just accept 0.0 or +/-Inf
		 */
	} else {
		if *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) != 0 {
			/*
			 * Report other errno values as errors.
			 */
			XTclExprFloatError(tls, interp, dResult)
			return int32(TCL_ERROR)
		}
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewDoubleObj(tls, dResult))
	return TCL_OK
}

func _ExprBinaryFunc(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Parameter vector. */
	var code int32
	var func1 uintptr
	var _ /* d1 at bp+0 */ float64
	var _ /* d2 at bp+8 */ float64
	_, _ = code, func1
	func1 = clientData
	if objc != int32(3) {
		_MathFuncWrongNumArgs(tls, interp, int32(3), objc, objv)
		return int32(TCL_ERROR)
	}
	code = XTcl_GetDoubleFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
	if code != TCL_OK {
		return int32(TCL_ERROR)
	}
	code = XTcl_GetDoubleFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp+8)
	if code != TCL_OK {
		return int32(TCL_ERROR)
	}
	*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = 0
	return _CheckDoubleResult(tls, interp, (*(*func(*libc.TLS, float64, float64) float64)(unsafe.Pointer(&struct{ uintptr }{func1})))(tls, *(*float64)(unsafe.Pointer(bp)), *(*float64)(unsafe.Pointer(bp + 8))))
}

func _ExprAbsFunc(tls *libc.TLS, dummy7397 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* Parameter vector. */
	var bytes, v1 uintptr
	var l TTcl_WideInt
	var v5 int32
	var _ /* big at bp+16 */ Tmp_int
	var _ /* d at bp+56 */ float64
	var _ /* d at bp+64 */ float64
	var _ /* numBytes at bp+40 */ TTcl_Size
	var _ /* ptr at bp+0 */ uintptr
	var _ /* type at bp+8 */ int32
	var _ /* ul at bp+48 */ TTcl_WideUInt
	_, _, _, _ = bytes, l, v1, v5
	if objc != int32(2) {
		_MathFuncWrongNumArgs(tls, interp, int32(2), objc, objv)
		return int32(TCL_ERROR)
	}
	if XTcl_GetNumberFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp, bp+8) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if *(*int32)(unsafe.Pointer(bp + 8)) == int32(TCL_NUMBER_INT) {
		l = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))
		if l > 0 {
			goto unChanged
		} else {
			if l == 0 {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != libc.UintptrFromInt32(0) {
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
						*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Flength
						v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
					} else {
						v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+40)
					}
					bytes = v1
					for *(*TTcl_Size)(unsafe.Pointer(bp + 40)) != 0 {
						if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes))) == int32('-') {
							XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, 0))
							return TCL_OK
						}
						bytes++
						*(*TTcl_Size)(unsafe.Pointer(bp + 40))--
					}
				}
				goto unChanged
			} else {
				if l == libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))+libc.Uint64FromInt32(1)) {
					if uint64(8) > uint64(8) {
						*(*TTcl_WideUInt)(unsafe.Pointer(bp + 48)) = -libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) + libc.Uint64FromInt32(1)))
						if XTclBN_mp_init(tls, bp+16) != MP_OKAY || XTclBN_mp_unpack(tls, bp+16, uint64(1), int32(1), uint64(8), 0, uint64(0), bp+48) != MP_OKAY {
							return int32(TCL_ERROR)
						}
						if XTclBN_mp_neg(tls, bp+16, bp+16) != MP_OKAY {
							return int32(TCL_ERROR)
						}
					} else {
						if XTclBN_mp_init_i64(tls, bp+16, l) != MP_OKAY {
							return int32(TCL_ERROR)
						}
					}
					goto tooLarge
				}
			}
		}
		XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, -l))
		return TCL_OK
	}
	if *(*int32)(unsafe.Pointer(bp + 8)) == int32(TCL_NUMBER_DOUBLE) {
		*(*float64)(unsafe.Pointer(bp + 56)) = *(*float64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))
		/*
		 * We need to distinguish here between positive 0.0 and negative -0.0.
		 * [Bug 2954959]
		 */
		if *(*float64)(unsafe.Pointer(bp + 56)) == -libc.Float64FromFloat64(0) {
			if !(libc.Xmemcmp(tls, bp+56, uintptr(unsafe.Pointer(&_poszero)), uint64(8)) != 0) {
				goto unChanged
			}
		} else {
			if *(*float64)(unsafe.Pointer(bp + 56)) > -libc.Float64FromFloat64(0) {
				goto unChanged
			}
		}
		XTcl_SetObjResult(tls, interp, XTcl_NewDoubleObj(tls, -*(*float64)(unsafe.Pointer(bp + 56))))
		return TCL_OK
	}
	if !(*(*int32)(unsafe.Pointer(bp + 8)) == int32(TCL_NUMBER_BIG)) {
		goto _2
	}
	if (*Tmp_int)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fsign != MP_ZPOS {
		v5 = int32(MP_YES)
	} else {
		v5 = MP_NO
	}
	if !(v5 != 0) {
		goto _3
	}
	XTcl_GetBignumFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+16)
	goto tooLarge
tooLarge:
	;
	if XTclBN_mp_neg(tls, bp+16, bp+16) != MP_OKAY {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewBignumObj(tls, bp+16))
	goto _4
_3:
	;
	goto unChanged
unChanged:
	;
	XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
_4:
	;
	return TCL_OK
_2:
	;
	if *(*int32)(unsafe.Pointer(bp + 8)) == int32(TCL_NUMBER_NAN) {
		XTcl_GetDoubleFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+64)
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

var _poszero = float64(0)

func _ExprBoolFunc(tls *libc.TLS, dummy7506 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Actual parameter vector. */
	var _ /* value at bp+0 */ int32
	if objc != int32(2) {
		_MathFuncWrongNumArgs(tls, interp, int32(2), objc, objv)
		return int32(TCL_ERROR)
	}
	if XTcl_GetBoolFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), (libc.Int32FromInt32(TCL_NULL_OK)-libc.Int32FromInt32(2))&libc.Int32FromInt64(4), bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(*(*int32)(unsafe.Pointer(bp)) != 0)))
	return TCL_OK
}

func _ExprDoubleFunc(tls *libc.TLS, dummy7527 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Actual parameter vector. */
	var _ /* dResult at bp+0 */ float64
	if objc != int32(2) {
		_MathFuncWrongNumArgs(tls, interp, int32(2), objc, objv)
		return int32(TCL_ERROR)
	}
	if XTcl_GetDoubleFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewDoubleObj(tls, *(*float64)(unsafe.Pointer(bp))))
	return TCL_OK
}

func _ExprIntFunc(tls *libc.TLS, dummy7554 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Actual parameter vector. */
	var result TTcl_WideInt
	var _ /* big at bp+24 */ Tmp_int
	var _ /* d at bp+0 */ float64
	var _ /* ptr at bp+16 */ uintptr
	var _ /* type at bp+8 */ int32
	_ = result
	if objc != int32(2) {
		_MathFuncWrongNumArgs(tls, interp, int32(2), objc, objv)
		return int32(TCL_ERROR)
	}
	if XTcl_GetNumberFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+16, bp+8) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if *(*int32)(unsafe.Pointer(bp + 8)) == int32(TCL_NUMBER_DOUBLE) {
		*(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16))))
		if *(*float64)(unsafe.Pointer(bp)) >= float64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) || *(*float64)(unsafe.Pointer(bp)) <= float64(libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))+libc.Uint64FromInt32(1))) {
			if XTcl_InitBignumFromDouble(tls, interp, *(*float64)(unsafe.Pointer(bp)), bp+24) != TCL_OK {
				/* Infinity */
				return int32(TCL_ERROR)
			}
			XTcl_SetObjResult(tls, interp, XTcl_NewBignumObj(tls, bp+24))
			return TCL_OK
		} else {
			result = int64(*(*float64)(unsafe.Pointer(bp)))
			XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, result))
			return TCL_OK
		}
	}
	if *(*int32)(unsafe.Pointer(bp + 8)) != int32(TCL_NUMBER_NAN) {
		/*
		 * All integers are already of integer type.
		 */
		XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
		return TCL_OK
	}
	/*
	 * Get the error message for NaN.
	 */
	XTcl_GetDoubleFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
	return int32(TCL_ERROR)
}

func _ExprWideFunc(tls *libc.TLS, dummy7610 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Actual parameter vector. */
	var _ /* wResult at bp+0 */ TTcl_WideInt
	if _ExprIntFunc(tls, libc.UintptrFromInt32(0), interp, objc, objv) != TCL_OK {
		return int32(TCL_ERROR)
	}
	XTclGetWideBitsFromObj(tls, libc.UintptrFromInt32(0), XTcl_GetObjResult(tls, interp), bp)
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, *(*TTcl_WideInt)(unsafe.Pointer(bp))))
	return TCL_OK
}

// C documentation
//
//	/*
//	 * Common implmentation of max() and min().
//	 */
func _ExprMaxMinFunc(tls *libc.TLS, dummy7631 uintptr, interp uintptr, objc int32, objv uintptr, op int32) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Comparison direction */
	var i int32
	var res uintptr
	var _ /* d at bp+0 */ float64
	var _ /* ptr at bp+16 */ uintptr
	var _ /* type at bp+8 */ int32
	_, _ = i, res
	if objc < int32(2) {
		_MathFuncWrongNumArgs(tls, interp, int32(2), objc, objv)
		return int32(TCL_ERROR)
	}
	res = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	i = int32(1)
	for {
		if !(i < objc) {
			break
		}
		if XTcl_GetNumberFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp+16, bp+8) != TCL_OK {
			return int32(TCL_ERROR)
		}
		if *(*int32)(unsafe.Pointer(bp + 8)) == int32(TCL_NUMBER_NAN) {
			/*
			 * Get the error message for NaN.
			 */
			XTcl_GetDoubleFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp)
			return int32(TCL_ERROR)
		}
		if XTclCompareTwoNumbers(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), res) == op {
			res = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
		}
		goto _1
	_1:
		;
		i++
	}
	XTcl_SetObjResult(tls, interp, res)
	return TCL_OK
}

func _ExprMaxFunc(tls *libc.TLS, dummy7672 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Actual parameter vector. */
	return _ExprMaxMinFunc(tls, libc.UintptrFromInt32(0), interp, objc, objv, int32(MP_GT))
}

func _ExprMinFunc(tls *libc.TLS, dummy7683 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Actual parameter vector. */
	return _ExprMaxMinFunc(tls, libc.UintptrFromInt32(0), interp, objc, objv, -int32(1))
}

func _ExprRandFunc(tls *libc.TLS, dummy7694 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Actual parameter vector. */
	var cachePtr, iPtr, oResult uintptr
	var dResult float64
	var tmp int64
	var v1 bool
	_, _, _, _, _, _ = cachePtr, dResult, iPtr, oResult, tmp, v1
	iPtr = interp
	if objc != int32(1) {
		_MathFuncWrongNumArgs(tls, interp, int32(1), objc, objv)
		return int32(TCL_ERROR)
	}
	if !((*TInterp)(unsafe.Pointer(iPtr)).Fflags&libc.Int32FromInt32(RAND_SEED_INITIALIZED) != 0) {
		*(*int32)(unsafe.Pointer(iPtr + 368)) |= int32(RAND_SEED_INITIALIZED)
		/*
		 * To ensure different seeds in different threads (bug #416643),
		 * take into consideration the thread this interp is running in.
		 */
		(*TInterp)(unsafe.Pointer(iPtr)).FrandSeed = libc.Int64FromUint64(XTclpGetClicks(tls) + uint64(XTcl_GetCurrentThread(tls))*uint64(4093))
		/*
		 * Make sure 1 <= randSeed <= (2^31) - 2. See below.
		 */
		*(*int64)(unsafe.Pointer(iPtr + 376)) &= int64(0x7FFFFFFF)
		if (*TInterp)(unsafe.Pointer(iPtr)).FrandSeed == 0 || (*TInterp)(unsafe.Pointer(iPtr)).FrandSeed == int64(0x7FFFFFFF) {
			*(*int64)(unsafe.Pointer(iPtr + 376)) ^= int64(123459876)
		}
	}
	/*
	 * Generate the random number using the linear congruential generator
	 * defined by the following recurrence:
	 *		seed = ( IA * seed ) mod IM
	 * where IA is 16807 and IM is (2^31) - 1. The recurrence maps a seed in
	 * the range [1, IM - 1] to a new seed in that same range. The recurrence
	 * maps IM to 0, and maps 0 back to 0, so those two values must not be
	 * allowed as initial values of seed.
	 *
	 * In order to avoid potential problems with integer overflow, the
	 * recurrence is implemented in terms of additional constants IQ and IR
	 * such that
	 *		IM = IA*IQ + IR
	 * None of the operations in the implementation overflows a 32-bit signed
	 * integer, and the C type long is guaranteed to be at least 32 bits wide.
	 *
	 * For more details on how this algorithm works, refer to the following
	 * papers:
	 *
	 *	S.K. Park & K.W. Miller, "Random number generators: good ones are hard
	 *	to find," Comm ACM 31(10):1192-1201, Oct 1988
	 *
	 *	W.H. Press & S.A. Teukolsky, "Portable random number generators,"
	 *	Computers in Physics 6(5):522-524, Sep/Oct 1992.
	 */
	tmp = (*TInterp)(unsafe.Pointer(iPtr)).FrandSeed / int64(RAND_IQ)
	(*TInterp)(unsafe.Pointer(iPtr)).FrandSeed = int64(RAND_IA)*((*TInterp)(unsafe.Pointer(iPtr)).FrandSeed-tmp*int64(RAND_IQ)) - int64(RAND_IR)*tmp
	if (*TInterp)(unsafe.Pointer(iPtr)).FrandSeed < 0 {
		*(*int64)(unsafe.Pointer(iPtr + 376)) += int64(RAND_IM)
	}
	/*
	 * Since the recurrence keeps seed values in the range [1, RAND_IM - 1],
	 * dividing by RAND_IM yields a double in the range (0, 1).
	 */
	dResult = float64(float64((*TInterp)(unsafe.Pointer(iPtr)).FrandSeed) * (libc.Float64FromFloat64(1) / libc.Float64FromInt32(RAND_IM)))
	/*
	 * Push a Tcl object with the result.
	 */
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		oResult = XTclThreadAllocObj(tls)
	} else {
		oResult = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(oResult + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(oResult)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(oResult)).Fbytes = libc.UintptrFromInt32(0)
	*(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(oResult)).FinternalRep)) = dResult
	(*TTcl_Obj)(unsafe.Pointer(oResult)).FtypePtr = uintptr(unsafe.Pointer(&XtclDoubleType))
	XTcl_SetObjResult(tls, interp, oResult)
	return TCL_OK
}

func _ExprRoundFunc(tls *libc.TLS, dummy7787 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Parameter vector. */
	var err Tmp_err
	var fractPart float64
	var max, min, result TTcl_WideInt
	var _ /* big at bp+32 */ Tmp_int
	var _ /* d at bp+0 */ float64
	var _ /* intPart at bp+24 */ float64
	var _ /* ptr at bp+8 */ uintptr
	var _ /* type at bp+16 */ int32
	_, _, _, _, _ = err, fractPart, max, min, result
	if objc != int32(2) {
		_MathFuncWrongNumArgs(tls, interp, int32(2), objc, objv)
		return int32(TCL_ERROR)
	}
	if XTcl_GetNumberFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+8, bp+16) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if *(*int32)(unsafe.Pointer(bp + 16)) == int32(TCL_NUMBER_DOUBLE) {
		max = libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
		min = libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) + libc.Uint64FromInt32(1))
		fractPart = libc.Xmodf(tls, *(*float64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))), bp+24)
		if fractPart <= -libc.Float64FromFloat64(0.5) {
			min++
		} else {
			if fractPart >= float64(0.5) {
				max--
			}
		}
		if *(*float64)(unsafe.Pointer(bp + 24)) >= float64(max) || *(*float64)(unsafe.Pointer(bp + 24)) <= float64(min) {
			err = MP_OKAY
			if XTcl_InitBignumFromDouble(tls, interp, *(*float64)(unsafe.Pointer(bp + 24)), bp+32) != TCL_OK {
				/* Infinity */
				return int32(TCL_ERROR)
			}
			if fractPart <= -libc.Float64FromFloat64(0.5) {
				err = XTclBN_mp_sub_d(tls, bp+32, uint32(1), bp+32)
			} else {
				if fractPart >= float64(0.5) {
					err = XTclBN_mp_add_d(tls, bp+32, uint32(1), bp+32)
				}
			}
			if err != MP_OKAY {
				return int32(TCL_ERROR)
			}
			XTcl_SetObjResult(tls, interp, XTcl_NewBignumObj(tls, bp+32))
			return TCL_OK
		} else {
			result = int64(*(*float64)(unsafe.Pointer(bp + 24)))
			if fractPart <= -libc.Float64FromFloat64(0.5) {
				result--
			} else {
				if fractPart >= float64(0.5) {
					result++
				}
			}
			XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, result))
			return TCL_OK
		}
	}
	if *(*int32)(unsafe.Pointer(bp + 16)) != int32(TCL_NUMBER_NAN) {
		/*
		 * All integers are already rounded
		 */
		XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
		return TCL_OK
	}
	/*
	 * Get the error message for NaN.
	 */
	XTcl_GetDoubleFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
	return int32(TCL_ERROR)
}

func _ExprSrandFunc(tls *libc.TLS, dummy7866 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Parameter vector. */
	var iPtr uintptr
	var _ /* w at bp+0 */ TTcl_WideInt
	_ = iPtr
	iPtr = interp
	*(*TTcl_WideInt)(unsafe.Pointer(bp)) = 0 /* Initialized to avoid compiler warning. */
	/*
	 * Convert argument and use it to reset the seed.
	 */
	if objc != int32(2) {
		_MathFuncWrongNumArgs(tls, interp, int32(2), objc, objv)
		return int32(TCL_ERROR)
	}
	if XTclGetWideBitsFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Reset the seed. Make sure 1 <= randSeed <= 2^31 - 2. See comments in
	 * ExprRandFunc for more details.
	 */
	*(*int32)(unsafe.Pointer(iPtr + 368)) |= int32(RAND_SEED_INITIALIZED)
	(*TInterp)(unsafe.Pointer(iPtr)).FrandSeed = *(*TTcl_WideInt)(unsafe.Pointer(bp)) & int64(0x7FFFFFFF)
	if (*TInterp)(unsafe.Pointer(iPtr)).FrandSeed == 0 || (*TInterp)(unsafe.Pointer(iPtr)).FrandSeed == int64(0x7FFFFFFF) {
		*(*int64)(unsafe.Pointer(iPtr + 376)) ^= int64(123459876)
	}
	/*
	 * To avoid duplicating the random number generation code we simply clean
	 * up our state and call the real random number function. That function
	 * will always succeed.
	 */
	return _ExprRandFunc(tls, libc.UintptrFromInt32(0), interp, int32(1), objv)
}

/*
 *----------------------------------------------------------------------
 *
 * Double Classification Functions --
 *
 *	This page contains the functions that implement all of the built-in
 *	math functions for classifying IEEE doubles.
 *
 *	These have to be a little bit careful while Tcl_GetDoubleFromObj()
 *	rejects NaN values, which these functions *explicitly* accept.
 *
 * Results:
 *	Each function returns TCL_OK if it succeeds and pushes an Tcl object
 *	holding the result. If it fails it returns TCL_ERROR and leaves an
 *	error message in the interpreter's result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 *
 * Older MSVC is supported by Tcl, but doesn't have fpclassify(). Of course.
 * But it does sometimes have _fpclass() which does almost the same job; if
 * even that is absent, we grobble around directly in the platform's binary
 * representation of double.
 *
 * The ClassifyDouble() function makes all that conform to a common API
 * (effectively the C99 standard API renamed), and just delegates to the
 * standard macro on platforms that do it correctly.
 */

func _ClassifyDouble(tls *libc.TLS, d float64) (r int32) {
	return libc.X__fpclassify(tls, d)
}

func _ExprIsFiniteFunc(tls *libc.TLS, dummy8055 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Actual parameter list */
	var result int32
	var _ /* d at bp+0 */ float64
	var _ /* ptr at bp+8 */ uintptr
	var _ /* type at bp+16 */ int32
	_ = result
	result = 0
	if objc != int32(2) {
		_MathFuncWrongNumArgs(tls, interp, int32(2), objc, objv)
		return int32(TCL_ERROR)
	}
	if XTcl_GetNumberFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+8, bp+16) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if *(*int32)(unsafe.Pointer(bp + 16)) != int32(TCL_NUMBER_NAN) {
		if XTcl_GetDoubleFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp) != TCL_OK {
			return int32(TCL_ERROR)
		}
		*(*int32)(unsafe.Pointer(bp + 16)) = _ClassifyDouble(tls, *(*float64)(unsafe.Pointer(bp)))
		result = libc.BoolInt32(*(*int32)(unsafe.Pointer(bp + 16)) != int32(FP_INFINITE) && *(*int32)(unsafe.Pointer(bp + 16)) != FP_NAN)
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(result != 0)))
	return TCL_OK
}

func _ExprIsInfinityFunc(tls *libc.TLS, dummy8086 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Actual parameter list */
	var result int32
	var _ /* d at bp+0 */ float64
	var _ /* ptr at bp+8 */ uintptr
	var _ /* type at bp+16 */ int32
	_ = result
	result = 0
	if objc != int32(2) {
		_MathFuncWrongNumArgs(tls, interp, int32(2), objc, objv)
		return int32(TCL_ERROR)
	}
	if XTcl_GetNumberFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+8, bp+16) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if *(*int32)(unsafe.Pointer(bp + 16)) != int32(TCL_NUMBER_NAN) {
		if XTcl_GetDoubleFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp) != TCL_OK {
			return int32(TCL_ERROR)
		}
		result = libc.BoolInt32(_ClassifyDouble(tls, *(*float64)(unsafe.Pointer(bp))) == int32(FP_INFINITE))
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(result != 0)))
	return TCL_OK
}

func _ExprIsNaNFunc(tls *libc.TLS, dummy8116 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Actual parameter list */
	var result int32
	var _ /* d at bp+0 */ float64
	var _ /* ptr at bp+8 */ uintptr
	var _ /* type at bp+16 */ int32
	_ = result
	result = int32(1)
	if objc != int32(2) {
		_MathFuncWrongNumArgs(tls, interp, int32(2), objc, objv)
		return int32(TCL_ERROR)
	}
	if XTcl_GetNumberFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+8, bp+16) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if *(*int32)(unsafe.Pointer(bp + 16)) != int32(TCL_NUMBER_NAN) {
		if XTcl_GetDoubleFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp) != TCL_OK {
			return int32(TCL_ERROR)
		}
		result = libc.BoolInt32(_ClassifyDouble(tls, *(*float64)(unsafe.Pointer(bp))) == FP_NAN)
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(result != 0)))
	return TCL_OK
}

func _ExprIsNormalFunc(tls *libc.TLS, dummy8146 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Actual parameter list */
	var result int32
	var _ /* d at bp+0 */ float64
	var _ /* ptr at bp+8 */ uintptr
	var _ /* type at bp+16 */ int32
	_ = result
	result = 0
	if objc != int32(2) {
		_MathFuncWrongNumArgs(tls, interp, int32(2), objc, objv)
		return int32(TCL_ERROR)
	}
	if XTcl_GetNumberFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+8, bp+16) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if *(*int32)(unsafe.Pointer(bp + 16)) != int32(TCL_NUMBER_NAN) {
		if XTcl_GetDoubleFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp) != TCL_OK {
			return int32(TCL_ERROR)
		}
		result = libc.BoolInt32(_ClassifyDouble(tls, *(*float64)(unsafe.Pointer(bp))) == int32(FP_NORMAL))
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(result != 0)))
	return TCL_OK
}

func _ExprIsSubnormalFunc(tls *libc.TLS, dummy8176 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Actual parameter list */
	var result int32
	var _ /* d at bp+0 */ float64
	var _ /* ptr at bp+8 */ uintptr
	var _ /* type at bp+16 */ int32
	_ = result
	result = 0
	if objc != int32(2) {
		_MathFuncWrongNumArgs(tls, interp, int32(2), objc, objv)
		return int32(TCL_ERROR)
	}
	if XTcl_GetNumberFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+8, bp+16) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if *(*int32)(unsafe.Pointer(bp + 16)) != int32(TCL_NUMBER_NAN) {
		if XTcl_GetDoubleFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp) != TCL_OK {
			return int32(TCL_ERROR)
		}
		result = libc.BoolInt32(_ClassifyDouble(tls, *(*float64)(unsafe.Pointer(bp))) == int32(FP_SUBNORMAL))
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(result != 0)))
	return TCL_OK
}

func _ExprIsUnorderedFunc(tls *libc.TLS, dummy8206 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Actual parameter list */
	var d float64
	var result int32
	var _ /* ptr at bp+0 */ uintptr
	var _ /* type at bp+8 */ int32
	_, _ = d, result
	result = 0
	if objc != int32(3) {
		_MathFuncWrongNumArgs(tls, interp, int32(3), objc, objv)
		return int32(TCL_ERROR)
	}
	if XTcl_GetNumberFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp, bp+8) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if *(*int32)(unsafe.Pointer(bp + 8)) == int32(TCL_NUMBER_NAN) {
		result = int32(1)
	} else {
		d = *(*float64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))
		result = libc.BoolInt32(_ClassifyDouble(tls, d) == FP_NAN)
	}
	if XTcl_GetNumberFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp, bp+8) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if *(*int32)(unsafe.Pointer(bp + 8)) == int32(TCL_NUMBER_NAN) {
		result |= int32(1)
	} else {
		d = *(*float64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))
		result |= libc.BoolInt32(_ClassifyDouble(tls, d) == FP_NAN)
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(result != 0)))
	return TCL_OK
}

func _FloatClassifyObjCmd(tls *libc.TLS, dummy8247 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Actual parameter list */
	var cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, objPtr uintptr
	var v10, v11, v12, v8, v9 bool
	var _ /* d at bp+0 */ float64
	var _ /* ptr at bp+8 */ uintptr
	var _ /* type at bp+16 */ int32
	_, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, objPtr, v10, v11, v12, v8, v9
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+8974)
		return int32(TCL_ERROR)
	}
	if XTcl_GetNumberFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+8, bp+16) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if *(*int32)(unsafe.Pointer(bp + 16)) == int32(TCL_NUMBER_NAN) {
		goto gotNaN
	} else {
		if XTcl_GetDoubleFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp) != TCL_OK {
			return int32(TCL_ERROR)
		}
	}
	switch _ClassifyDouble(tls, *(*float64)(unsafe.Pointer(bp))) {
	case int32(FP_INFINITE):
		goto _1
	case FP_NAN:
		goto _2
	case int32(FP_NORMAL):
		goto _3
	case int32(FP_SUBNORMAL):
		goto _4
	case int32(FP_ZERO):
		goto _5
	default:
		goto _6
	}
	goto _7
_1:
	;
	if v8 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v8 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v8 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	if libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, __ccgo_ts+8985, libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr(libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(9) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	goto _7
_2:
	;
	goto gotNaN
gotNaN:
	;
	if v9 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v9 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v9 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	if libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, __ccgo_ts+8994, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr(libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(4) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	goto _7
_3:
	;
	if v10 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v10 {
		cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v10 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	if libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, __ccgo_ts+8998, libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr(libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(7) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	goto _7
_4:
	;
	if v11 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v11 {
		cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v11 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	if libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, __ccgo_ts+9005, libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr(libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(10) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	goto _7
_5:
	;
	if v12 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v12 {
		cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v12 || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	if libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, __ccgo_ts+765, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr(libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(5) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	goto _7
_6:
	;
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+9015, libc.VaList(bp+32, *(*float64)(unsafe.Pointer(bp)))))
	return int32(TCL_ERROR)
_7:
	;
	XTcl_SetObjResult(tls, interp, objPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * MathFuncWrongNumArgs --
 *
 *	Generate an error message when a math function presents the wrong
 *	number of arguments.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	An error message is stored in the interpreter result.
 *
 *----------------------------------------------------------------------
 */

func _MathFuncWrongNumArgs(tls *libc.TLS, interp uintptr, expected int32, found int32, objv uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Actual parameter vector. */
	var name, tail, v1, v2 uintptr
	_, _, _, _ = name, tail, v1, v2
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv)), libc.UintptrFromInt32(0))
	}
	name = v1
	tail = name + uintptr(libc.Xstrlen(tls, name))
	for tail > name+uintptr(1) {
		tail--
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(tail))) == int32(':') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(tail + uintptr(-libc.Int32FromInt32(1))))) == int32(':') {
			name = tail + uintptr(1)
			break
		}
	}
	if found < expected {
		v2 = __ccgo_ts + 9045
	} else {
		v2 = __ccgo_ts + 9056
	}
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+9065, libc.VaList(bp+8, v2, name)))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+9101, libc.UintptrFromInt32(0)))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_NRCallObjProc --
 *
 *	This function calls an objProc directly while managing things properly
 *	if it happens to be an NR objProc. It is meant to be used by extenders
 *	that provide an NR implementation of a command, as this function
 *	permits a trivial coding of the non-NR objProc.
 *
 * Results:
 *	The return value is a standard Tcl completion code such as TCL_OK or
 *	TCL_ERROR. A result or error message is left in interp's result.
 *
 * Side effects:
 *	Depends on the objProc.
 *
 *----------------------------------------------------------------------
 */

func XTcl_NRCallObjProc(tls *libc.TLS, interp uintptr, objProc uintptr, clientData uintptr, objc TTcl_Size, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, cachePtr, rootPtr uintptr
	var v1 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _, _ = _objPtr, cachePtr, rootPtr, v1
	rootPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	if v1 = interp == libc.UintptrFromInt32(0); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(_Dispatch)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = objProc
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = clientData
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = uintptr(objc)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = objv
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
	return XTclNRRunCallbacks(tls, interp, TCL_OK, rootPtr)
}

func _wrapperNRObjProc(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var info, proc uintptr
	_, _ = info, proc
	info = clientData
	clientData = (*TCmdWrapperInfo)(unsafe.Pointer(info)).FclientData
	proc = (*TCmdWrapperInfo)(unsafe.Pointer(info)).Fproc
	XTclpFree(tls, info)
	if objc < 0 {
		objc = -int32(1)
	}
	return (*(*func(*libc.TLS, uintptr, uintptr, TTcl_Size, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{proc})))(tls, clientData, interp, int64(objc), objv)
}

func XTcl_NRCallObjProc2(tls *libc.TLS, interp uintptr, objProc uintptr, clientData uintptr, objc TTcl_Size, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, cachePtr, info, rootPtr uintptr
	var v1 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _, _, _ = _objPtr, cachePtr, info, rootPtr, v1
	if objc > int64(INT_MAX) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+9111)
		return int32(TCL_ERROR)
	}
	rootPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	info = XTcl_Alloc(tls, uint64(40))
	(*TCmdWrapperInfo)(unsafe.Pointer(info)).FclientData = clientData
	(*TCmdWrapperInfo)(unsafe.Pointer(info)).Fproc = objProc
	if v1 = interp == libc.UintptrFromInt32(0); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(_Dispatch)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = __ccgo_fp(_wrapperNRObjProc)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = info
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = uintptr(objc)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = objv
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
	return XTclNRRunCallbacks(tls, interp, TCL_OK, rootPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_NRCreateCommand --
 *
 *	Define a new NRE-enabled object-based command in a command table.
 *
 * Results:
 *	The return value is a token for the command, which can be used in
 *	future calls to Tcl_GetCommandName.
 *
 * Side effects:
 *	If no command named "cmdName" already exists for interp, one is
 *	created. Otherwise, if a command does exist, then if the object-based
 *	Tcl_ObjCmdProc is InvokeStringCommand, we assume Tcl_CreateCommand
 *	was called previously for the same command and just set its
 *	Tcl_ObjCmdProc to the argument "proc"; otherwise, we delete the old
 *	command.
 *
 *	In the future, during bytecode evaluation when "cmdName" is seen as
 *	the name of a command by Tcl_EvalObj or Tcl_Eval, the object-based
 *	Tcl_ObjCmdProc proc will be called. When the command is deleted from
 *	the table, deleteProc will be called. See the manual entry for details
 *	on the calling sequence.
 *
 *----------------------------------------------------------------------
 */

func _cmdWrapperNreProc(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var info uintptr
	_ = info
	info = clientData
	if objc < 0 {
		objc = -int32(1)
	}
	return (*(*func(*libc.TLS, uintptr, uintptr, TTcl_Size, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TCmdWrapperInfo)(unsafe.Pointer(info)).FnreProc})))(tls, (*TCmdWrapperInfo)(unsafe.Pointer(info)).FclientData, interp, int64(objc), objv)
}

func XTcl_NRCreateCommand2(tls *libc.TLS, interp uintptr, cmdName uintptr, proc uintptr, nreProc uintptr, clientData uintptr, deleteProc uintptr) (r TTcl_Command) {
	/* If not NULL, gives a function to call when
	 * this command is deleted. */
	var info, v1, v2 uintptr
	_, _, _ = info, v1, v2
	info = XTcl_Alloc(tls, uint64(40))
	(*TCmdWrapperInfo)(unsafe.Pointer(info)).Fproc = proc
	(*TCmdWrapperInfo)(unsafe.Pointer(info)).FclientData = clientData
	(*TCmdWrapperInfo)(unsafe.Pointer(info)).FnreProc = nreProc
	(*TCmdWrapperInfo)(unsafe.Pointer(info)).FdeleteProc = deleteProc
	(*TCmdWrapperInfo)(unsafe.Pointer(info)).FdeleteData = clientData
	if proc != 0 {
		v1 = __ccgo_fp(_cmdWrapperProc)
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	if nreProc != 0 {
		v2 = __ccgo_fp(_cmdWrapperNreProc)
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	return XTcl_NRCreateCommand(tls, interp, cmdName, v1, v2, info, __ccgo_fp(_cmdWrapperDeleteProc))
}

func XTcl_NRCreateCommand(tls *libc.TLS, interp uintptr, cmdName uintptr, proc uintptr, nreProc uintptr, clientData uintptr, deleteProc uintptr) (r TTcl_Command) {
	/* If not NULL, gives a function to call when
	 * this command is deleted. */
	var cmdPtr uintptr
	_ = cmdPtr
	cmdPtr = XTcl_CreateObjCommand(tls, interp, cmdName, proc, clientData, deleteProc)
	(*TCommand)(unsafe.Pointer(cmdPtr)).FnreProc = nreProc
	return cmdPtr
}

func XTclNRCreateCommandInNs(tls *libc.TLS, interp uintptr, cmdName uintptr, nsPtr uintptr, proc uintptr, nreProc uintptr, clientData uintptr, deleteProc uintptr) (r TTcl_Command) {
	var cmdPtr uintptr
	_ = cmdPtr
	cmdPtr = XTclCreateObjCommandInNs(tls, interp, cmdName, nsPtr, proc, clientData, deleteProc)
	(*TCommand)(unsafe.Pointer(cmdPtr)).FnreProc = nreProc
	return cmdPtr
}

/****************************************************************************
 * Stuff for the public api
 ****************************************************************************/

func XTcl_NREvalObj(tls *libc.TLS, interp uintptr, objPtr uintptr, flags int32) (r int32) {
	return XTclNREvalObjEx(tls, interp, objPtr, flags, libc.UintptrFromInt32(0), -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff))
}

func XTcl_NREvalObjv(tls *libc.TLS, interp uintptr, objc TTcl_Size, objv uintptr, flags int32) (r int32) {
	/* Collection of OR-ed bits that control the
	 * evaluation of the script. Only
	 * TCL_EVAL_GLOBAL, TCL_EVAL_INVOKE and
	 * TCL_EVAL_NOERR are currently supported. */
	return XTclNREvalObjv(tls, interp, objc, objv, flags, libc.UintptrFromInt32(0))
}

func XTcl_NRCmdSwap(tls *libc.TLS, interp uintptr, cmd TTcl_Command, objc TTcl_Size, objv uintptr, flags int32) (r int32) {
	return XTclNREvalObjv(tls, interp, objc, objv, flags|int32(TCL_EVAL_NOERR), cmd)
}

/*****************************************************************************
 * Tailcall related code
 *****************************************************************************
 *
 * The steps of the tailcall dance are as follows:
 *
 *   1. when [tailcall] is invoked, it stores the corresponding callback in
 *      the current CallFrame and returns TCL_RETURN
 *   2. when the CallFrame is popped, it calls TclSetTailcall to store the
 *      callback in the proper NRCommand callback - the spot where the command
 *      that pushed the CallFrame is completely cleaned up
 *   3. when the NRCommand callback runs, it schedules the tailcall callback
 *      to run immediately after it returns
 *
 *   One delicate point is to properly define the NRCommand where the tailcall
 *   will execute. There are functions whose purpose is to help define the
 *   precise spot:
 *     TclMarkTailcall: if the NEXT command to be pushed tailcalls, execution
 *	 should continue right here
 *     TclSkipTailcall:  if the NEXT command to be pushed tailcalls, execution
 *	 should continue after the CURRENT command is fully returned ("skip
 *	 the next command: we are redirecting to it, tailcalls should run
 *	 after WE return")
 *     TclPushTailcallPoint: the search for a tailcalling spot cannot traverse
 *	 this point. This is special for OO, as some of the oo constructs
 *	 that behave like commands may not push an NRCommand callback.
 */

func XTclMarkTailcall(tls *libc.TLS, interp uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, cachePtr, iPtr uintptr
	var v1 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _, _ = _objPtr, cachePtr, iPtr, v1
	iPtr = interp
	if (*TInterp)(unsafe.Pointer(iPtr)).FdeferredCallbacks == libc.UintptrFromInt32(0) {
		if v1 = interp == libc.UintptrFromInt32(0); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			_objPtr = XTclThreadAllocObj(tls)
		} else {
			_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(_objPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(_NRCommand)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
		(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
		(*TInterp)(unsafe.Pointer(iPtr)).FdeferredCallbacks = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	}
}

func XTclSkipTailcall(tls *libc.TLS, interp uintptr) {
	var iPtr uintptr
	_ = iPtr
	iPtr = interp
	XTclMarkTailcall(tls, interp)
	*(*uintptr)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FdeferredCallbacks + 8 + 1*8)) = uintptr(int64(libc.Int32FromInt32(1)))
}

func XTclPushTailcallPoint(tls *libc.TLS, interp uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, cachePtr uintptr
	var v1 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _ = _objPtr, cachePtr, v1
	if v1 = interp == libc.UintptrFromInt32(0); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(_NRCommand)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
	(*TInterp)(unsafe.Pointer(interp)).FnumLevels++
}

/*
 *----------------------------------------------------------------------
 *
 * TclSetTailcall --
 *
 *	Splice a tailcall command in the proper spot of the NRE callback
 *	stack, so that it runs at the right time.
 *
 *----------------------------------------------------------------------
 */

func XTclSetTailcall(tls *libc.TLS, interp uintptr, listPtr uintptr) {
	var runPtr uintptr
	_ = runPtr
	runPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	for {
		if !(runPtr != 0) {
			break
		}
		if (*TNRE_callback)(unsafe.Pointer(runPtr)).FprocPtr == __ccgo_fp(_NRCommand) && !(*(*uintptr)(unsafe.Pointer(runPtr + 8 + 1*8)) != 0) {
			break
		}
		goto _1
	_1:
		;
		runPtr = (*TNRE_callback)(unsafe.Pointer(runPtr)).FnextPtr
	}
	if !(runPtr != 0) {
		XTcl_Panic(tls, __ccgo_ts+9118, 0)
	}
	*(*uintptr)(unsafe.Pointer(runPtr + 8 + 1*8)) = listPtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclNRTailcallObjCmd --
 *
 *	Prepare the tailcall as a list and store it in the current
 *	varFrame. When the frame is later popped the tailcall will be spliced
 *	at the proper place.
 *
 * Results:
 *	The first NRCommand callback that is not marked to be skipped is
 *	updated so that its data[1] field contains the tailcall list.
 *
 *----------------------------------------------------------------------
 */

func XTclNRTailcallObjCmd(tls *libc.TLS, dummy8827 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var _objPtr, iPtr, listPtr, nsPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _, _, _ = _objPtr, iPtr, listPtr, nsPtr, v1, v2
	iPtr = interp
	if objc < int32(1) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+9183)
		return int32(TCL_ERROR)
	}
	if !((*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FisProcCallFrame&libc.Int32FromInt32(1) != 0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+9203, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+9261, __ccgo_ts+9270, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Invocation without args just clears a scheduled tailcall; invocation
	 * with an argument replaces any previously scheduled tailcall.
	 */
	if (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FtailcallPtr != 0 {
		_objPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FtailcallPtr
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		(*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FtailcallPtr = libc.UintptrFromInt32(0)
	}
	/*
	 * Create the callback to actually evaluate the tailcalled
	 * command, then set it in the varFrame so that PopCallFrame can use it
	 * at the proper time.
	 */
	if objc > int32(1) {
		nsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FnsPtr
		/*
		 * The tailcall data is in a Tcl list: the first element is the
		 * namespace, the rest the command to be tailcalled.
		 */
		listPtr = XTcl_NewListObj(tls, int64(objc), objv)
		XTclListObjSetElement(tls, libc.UintptrFromInt32(0), listPtr, 0, XTclNewNamespaceObj(tls, nsPtr))
		(*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FtailcallPtr = listPtr
	}
	return int32(TCL_RETURN)
}

/*
 *----------------------------------------------------------------------
 *
 * TclNRTailcallEval --
 *
 *	This NREcallback actually causes the tailcall to be evaluated.
 *
 *----------------------------------------------------------------------
 */

func XTclNRTailcallEval(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _objPtr, _objPtr1, cachePtr, iPtr, listPtr, nsObjPtr, v5 uintptr
	var v2, v3 int64
	var v4 TTcl_Size
	var v6 bool
	var _ /* _callbackPtr at bp+24 */ uintptr
	var _ /* nsPtr at bp+0 */ uintptr
	var _ /* objc at bp+8 */ TTcl_Size
	var _ /* objv at bp+16 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, iPtr, listPtr, nsObjPtr, v2, v3, v4, v5, v6
	iPtr = interp
	listPtr = *(*uintptr)(unsafe.Pointer(data))
	if (*TTcl_Obj)(unsafe.Pointer(listPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listPtr + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr + 32))).Fptr2)).FspanStart
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 16)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listPtr + 32))).Fptr1 + 40 + uintptr(v2)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listPtr + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr + 32))).Fptr2)).FspanLength
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v3
		_ = libc.Int32FromInt32(TCL_OK)
	} else {
		XTcl_ListObjGetElements(tls, interp, listPtr, bp+8, bp+16)
	}
	nsObjPtr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16))))
	if result == TCL_OK {
		result = XTclGetNamespaceFromObj(tls, interp, nsObjPtr, bp)
	}
	if result != TCL_OK {
		/*
		 * Tailcall execution was preempted, eg by an intervening catch or by
		 * a now-gone namespace: cleanup and return.
		 */
		_objPtr = listPtr
		v5 = _objPtr
		v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
		*(*TTcl_Size)(unsafe.Pointer(v5))--
		if v4 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		return result
	}
	/*
	 * Perform the tailcall
	 */
	XTclMarkTailcall(tls, interp)
	if v6 = interp == libc.UintptrFromInt32(0); !v6 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v6 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr1 = XTclThreadAllocObj(tls)
	} else {
		_objPtr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr1 + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 24)) = _objPtr1
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).FprocPtr = __ccgo_fp(XTclNRReleaseValues)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 8)) = listPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 24))
	(*TInterp)(unsafe.Pointer(iPtr)).FlookupNsPtr = *(*uintptr)(unsafe.Pointer(bp))
	return XTclNREvalObjv(tls, interp, *(*TTcl_Size)(unsafe.Pointer(bp + 8))-int64(1), *(*uintptr)(unsafe.Pointer(bp + 16))+uintptr(1)*8, 0, libc.UintptrFromInt32(0))
}

func XTclNRReleaseValues(tls *libc.TLS, data uintptr, dummy8931 uintptr, result int32) (r int32) {
	var _objPtr, v2 uintptr
	var i int32
	var v1 TTcl_Size
	_, _, _, _ = _objPtr, i, v1, v2
	i = 0
	for i < int32(4) {
		if *(*uintptr)(unsafe.Pointer(data + uintptr(i)*8)) != 0 {
			_objPtr = *(*uintptr)(unsafe.Pointer(data + uintptr(i)*8))
			v2 = _objPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if v1 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		} else {
			break
		}
		i++
	}
	return result
}

func XTcl_NRAddCallback(tls *libc.TLS, interp uintptr, postProcPtr uintptr, data0 uintptr, data1 uintptr, data2 uintptr, data3 uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, cachePtr uintptr
	var v1 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _ = _objPtr, cachePtr, v1
	if !(postProcPtr != 0) {
		XTcl_Panic(tls, __ccgo_ts+9278, 0)
	}
	if v1 = interp == libc.UintptrFromInt32(0); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = postProcPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = data0
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = data1
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = data2
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = data3
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
}

/*
 *----------------------------------------------------------------------
 *
 * TclNRCoroutineObjCmd -- (and friends)
 *
 *	This object-based function is invoked to process the "coroutine" Tcl
 *	command. It is heavily based on "apply".
 *
 * Results:
 *	A standard Tcl object result value.
 *
 * Side effects:
 *	A new procedure gets created.
 *
 * ** FIRST EXPERIMENTAL IMPLEMENTATION **
 *
 * It is fairly amateurish and not up to our standards - mainly in terms of
 * error messages and [info] interaction. Just to test the infrastructure in
 * teov and tebc.
 *----------------------------------------------------------------------
 */

func XTclNRYieldObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var _objPtr, cachePtr, corPtr uintptr
	var v1 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _, _ = _objPtr, cachePtr, corPtr, v1
	corPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcorPtr
	if objc > int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+9317)
		return int32(TCL_ERROR)
	}
	if !(corPtr != 0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+9331, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+9371, __ccgo_ts+9381, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if objc == int32(2) {
		XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	}
	if v1 = interp == libc.UintptrFromInt32(0); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(XTclNRCoroutineActivateCallback)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = corPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = clientData
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
	return TCL_OK
}

func XTclNRYieldToObjCmd(tls *libc.TLS, dummy9019 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var corPtr, listPtr, nsPtr uintptr
	_, _, _ = corPtr, listPtr, nsPtr
	corPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcorPtr
	nsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FnsPtr
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+9395)
		return int32(TCL_ERROR)
	}
	if !(corPtr != 0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+9413, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+9371, __ccgo_ts+9381, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if (*TNamespace)(unsafe.Pointer(nsPtr)).Fflags&int32(NS_DYING) != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+9455, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+9371, __ccgo_ts+9491, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Add the tailcall in the caller env, then just yield.
	 *
	 * This is essentially code from TclNRTailcallObjCmd
	 */
	listPtr = XTcl_NewListObj(tls, int64(objc), objv)
	XTclListObjSetElement(tls, libc.UintptrFromInt32(0), listPtr, 0, XTclNewNamespaceObj(tls, nsPtr))
	/*
	 * Add the callback in the caller's env, then instruct TEBC to yield.
	 */
	(*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).FcallerEEPtr
	/* Not calling Tcl_IncrRefCount(listPtr) here because listPtr is private */
	XTclSetTailcall(tls, interp, listPtr)
	(*TCoroutineData)(unsafe.Pointer(corPtr)).FyieldPtr = listPtr
	(*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).FeePtr
	return XTclNRYieldObjCmd(tls, uintptr(int64(libc.Int32FromInt32(1))), interp, int32(1), objv)
}

func _RewindCoroutineCallback(tls *libc.TLS, data uintptr, interp uintptr, dummy9074 int32) (r int32) {
	return XTcl_RestoreInterpState(tls, interp, *(*uintptr)(unsafe.Pointer(data)))
}

func _RewindCoroutine(tls *libc.TLS, corPtr uintptr, result int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, cachePtr, interp uintptr
	var state TTcl_InterpState
	var v1 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _, _, _ = _objPtr, cachePtr, interp, state, v1
	interp = (*TExecEnv1)(unsafe.Pointer((*TCoroutineData)(unsafe.Pointer(corPtr)).FeePtr)).Finterp
	state = XTcl_SaveInterpState(tls, interp, result)
	(*TExecEnv1)(unsafe.Pointer((*TCoroutineData)(unsafe.Pointer(corPtr)).FeePtr)).Frewind = int32(1)
	if v1 = interp == libc.UintptrFromInt32(0); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(_RewindCoroutineCallback)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = state
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
	return XTclNRInterpCoroutine(tls, corPtr, interp, 0, libc.UintptrFromInt32(0))
}

func _DeleteCoroutine(tls *libc.TLS, clientData uintptr) {
	var corPtr, interp, rootPtr uintptr
	_, _, _ = corPtr, interp, rootPtr
	corPtr = clientData
	interp = (*TExecEnv1)(unsafe.Pointer((*TCoroutineData)(unsafe.Pointer(corPtr)).FeePtr)).Finterp
	rootPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	if (*TCoroutineData)(unsafe.Pointer(corPtr)).FstackLevel == libc.UintptrFromInt32(0) {
		XTclNRRunCallbacks(tls, interp, _RewindCoroutine(tls, corPtr, TCL_OK), rootPtr)
	}
}

func _NRCoroutineCallerCallback(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	var cmdPtr, corPtr uintptr
	_, _ = cmdPtr, corPtr
	corPtr = *(*uintptr)(unsafe.Pointer(data))
	cmdPtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).FcmdPtr
	/*
	 * This is the last callback in the caller execEnv, right before switching
	 * to the coroutine's
	 */
	if !((*TCoroutineData)(unsafe.Pointer(corPtr)).FeePtr != 0) {
		/*
		 * The execEnv was wound down but not deleted for our sake. We finish
		 * the job here. The caller context has already been restored.
		 */
		XTclpFree(tls, corPtr)
		return result
	}
	(*TCoroutineData)(unsafe.Pointer(corPtr)).Frunning.FframePtr = (*TInterp)(unsafe.Pointer(interp)).FframePtr
	(*TCoroutineData)(unsafe.Pointer(corPtr)).Frunning.FvarFramePtr = (*TInterp)(unsafe.Pointer(interp)).FvarFramePtr
	(*TCoroutineData)(unsafe.Pointer(corPtr)).Frunning.FcmdFramePtr = (*TInterp)(unsafe.Pointer(interp)).FcmdFramePtr
	(*TCoroutineData)(unsafe.Pointer(corPtr)).Frunning.FlineLABCPtr = (*TInterp)(unsafe.Pointer(interp)).FlineLABCPtr
	(*TInterp)(unsafe.Pointer(interp)).FframePtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).Fcaller.FframePtr
	(*TInterp)(unsafe.Pointer(interp)).FvarFramePtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).Fcaller.FvarFramePtr
	(*TInterp)(unsafe.Pointer(interp)).FcmdFramePtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).Fcaller.FcmdFramePtr
	(*TInterp)(unsafe.Pointer(interp)).FlineLABCPtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).Fcaller.FlineLABCPtr
	if (*TCommand)(unsafe.Pointer(cmdPtr)).Fflags&int32(CMD_DYING) != 0 {
		/*
		 * The command was deleted while it was running: wind down the
		 * execEnv, this will do the complete cleanup. RewindCoroutine will
		 * restore both the caller's context and interp state.
		 */
		return _RewindCoroutine(tls, corPtr, result)
	}
	return result
}

func _NRCoroutineExitCallback(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	var cmdPtr, corPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _ = cmdPtr, corPtr, v1, v2
	corPtr = *(*uintptr)(unsafe.Pointer(data))
	cmdPtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).FcmdPtr
	/*
	 * This runs at the bottom of the Coroutine's execEnv: it will be executed
	 * when the coroutine returns or is wound down, but not when it yields. It
	 * deletes the coroutine and restores the caller's environment.
	 */
	(*TCommand)(unsafe.Pointer(cmdPtr)).FdeleteProc = libc.UintptrFromInt32(0)
	XTcl_DeleteCommandFromToken(tls, interp, cmdPtr)
	v2 = cmdPtr + 16
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclpFree(tls, cmdPtr)
	}
	(*TExecEnv1)(unsafe.Pointer((*TCoroutineData)(unsafe.Pointer(corPtr)).FeePtr)).FcorPtr = libc.UintptrFromInt32(0)
	XTclDeleteExecEnv(tls, (*TCoroutineData)(unsafe.Pointer(corPtr)).FeePtr)
	(*TCoroutineData)(unsafe.Pointer(corPtr)).FeePtr = libc.UintptrFromInt32(0)
	(*TCoroutineData)(unsafe.Pointer(corPtr)).FstackLevel = libc.UintptrFromInt32(0)
	/*
	 * #280.
	 * Drop the coroutine-owned copy of the lineLABCPtr hashtable for literal
	 * command arguments in bytecode.
	 */
	XTcl_DeleteHashTable(tls, (*TCoroutineData)(unsafe.Pointer(corPtr)).FlineLABCPtr)
	XTclpFree(tls, (*TCoroutineData)(unsafe.Pointer(corPtr)).FlineLABCPtr)
	(*TCoroutineData)(unsafe.Pointer(corPtr)).FlineLABCPtr = libc.UintptrFromInt32(0)
	(*TInterp)(unsafe.Pointer(interp)).FframePtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).Fcaller.FframePtr
	(*TInterp)(unsafe.Pointer(interp)).FvarFramePtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).Fcaller.FvarFramePtr
	(*TInterp)(unsafe.Pointer(interp)).FcmdFramePtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).Fcaller.FcmdFramePtr
	(*TInterp)(unsafe.Pointer(interp)).FlineLABCPtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).Fcaller.FlineLABCPtr
	(*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).FcallerEEPtr
	(*TInterp)(unsafe.Pointer(interp)).FnumLevels++
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * TclNRCoroutineActivateCallback --
 *
 *	This is the workhorse for coroutines: it implements both yield and
 *	resume.
 *
 *	It is important that both be implemented in the same callback: the
 *	detection of the impossibility to suspend due to a busy C-stack relies
 *	on the precise position of a local variable in the stack. We do not
 *	want the compiler to play tricks on us, either by moving things around
 *	or inlining.
 *
 *----------------------------------------------------------------------
 */

func XTclNRCoroutineActivateCallback(tls *libc.TLS, data uintptr, interp uintptr, dummy9225 int32) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var _objPtr, _objPtr1, cachePtr, corPtr, runPtr, stackLevel, type1, v4 uintptr
	var numLevels, numLevels1, v3 TTcl_Size
	var v1 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, corPtr, numLevels, numLevels1, runPtr, stackLevel, type1, v1, v3, v4
	corPtr = *(*uintptr)(unsafe.Pointer(data))
	stackLevel = _TclGetCStackPtr(tls)
	if !((*TCoroutineData)(unsafe.Pointer(corPtr)).FstackLevel != 0) {
		/*
		 * -- Coroutine is suspended --
		 * Push the callback to restore the caller's context on yield or
		 * return.
		 */
		if v1 = interp == libc.UintptrFromInt32(0); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			_objPtr = XTclThreadAllocObj(tls)
		} else {
			_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(_objPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(_NRCoroutineCallerCallback)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = corPtr
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
		(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
		/*
		 * Record the stackLevel at which the resume is happening, then swap
		 * the interp's environment to make it suitable to run this coroutine.
		 */
		(*TCoroutineData)(unsafe.Pointer(corPtr)).FstackLevel = stackLevel
		numLevels = (*TCoroutineData)(unsafe.Pointer(corPtr)).FauxNumLevels
		(*TCoroutineData)(unsafe.Pointer(corPtr)).FauxNumLevels = (*TInterp)(unsafe.Pointer(interp)).FnumLevels
		(*TCoroutineData)(unsafe.Pointer(corPtr)).Fcaller.FframePtr = (*TInterp)(unsafe.Pointer(interp)).FframePtr
		(*TCoroutineData)(unsafe.Pointer(corPtr)).Fcaller.FvarFramePtr = (*TInterp)(unsafe.Pointer(interp)).FvarFramePtr
		(*TCoroutineData)(unsafe.Pointer(corPtr)).Fcaller.FcmdFramePtr = (*TInterp)(unsafe.Pointer(interp)).FcmdFramePtr
		(*TCoroutineData)(unsafe.Pointer(corPtr)).Fcaller.FlineLABCPtr = (*TInterp)(unsafe.Pointer(interp)).FlineLABCPtr
		(*TCoroutineData)(unsafe.Pointer(corPtr)).FcallerEEPtr = (*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr
		(*TInterp)(unsafe.Pointer(interp)).FframePtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).Frunning.FframePtr
		(*TInterp)(unsafe.Pointer(interp)).FvarFramePtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).Frunning.FvarFramePtr
		(*TInterp)(unsafe.Pointer(interp)).FcmdFramePtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).Frunning.FcmdFramePtr
		(*TInterp)(unsafe.Pointer(interp)).FlineLABCPtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).Frunning.FlineLABCPtr
		(*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).FeePtr
		*(*TTcl_Size)(unsafe.Pointer(interp + 72)) += numLevels
	} else {
		/*
		 * Coroutine is active: yield
		 */
		if (*TCoroutineData)(unsafe.Pointer(corPtr)).FstackLevel != stackLevel {
			(*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).FcallerEEPtr
			if (*TCoroutineData)(unsafe.Pointer(corPtr)).FyieldPtr != 0 {
				runPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
				for {
					if !(runPtr != 0) {
						break
					}
					if *(*uintptr)(unsafe.Pointer(runPtr + 8 + 1*8)) == (*TCoroutineData)(unsafe.Pointer(corPtr)).FyieldPtr {
						_objPtr1 = *(*uintptr)(unsafe.Pointer(runPtr + 8 + 1*8))
						v4 = _objPtr1
						v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
						*(*TTcl_Size)(unsafe.Pointer(v4))--
						if v3 <= int64(1) {
							XTclFreeObj(tls, _objPtr1)
						}
						*(*uintptr)(unsafe.Pointer(runPtr + 8 + 1*8)) = libc.UintptrFromInt32(0)
						(*TCoroutineData)(unsafe.Pointer(corPtr)).FyieldPtr = libc.UintptrFromInt32(0)
						break
					}
					goto _2
				_2:
					;
					runPtr = (*TNRE_callback)(unsafe.Pointer(runPtr)).FnextPtr
				}
			}
			(*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).FeePtr
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+9510, int64(-libc.Int32FromInt32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+9371, __ccgo_ts+9537, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		type1 = *(*uintptr)(unsafe.Pointer(data + 1*8))
		if type1 == libc.UintptrFromInt32(0) {
			(*TCoroutineData)(unsafe.Pointer(corPtr)).Fnargs = int64(-libc.Int32FromInt32(1))
		} else {
			if type1 == uintptr(int64(libc.Int32FromInt32(1))) {
				(*TCoroutineData)(unsafe.Pointer(corPtr)).Fnargs = int64(-libc.Int32FromInt32(2))
			} else {
				XTcl_Panic(tls, __ccgo_ts+9548, 0)
			}
		}
		(*TCoroutineData)(unsafe.Pointer(corPtr)).FyieldPtr = libc.UintptrFromInt32(0)
		(*TCoroutineData)(unsafe.Pointer(corPtr)).FstackLevel = libc.UintptrFromInt32(0)
		numLevels1 = (*TInterp)(unsafe.Pointer(interp)).FnumLevels
		(*TInterp)(unsafe.Pointer(interp)).FnumLevels = (*TCoroutineData)(unsafe.Pointer(corPtr)).FauxNumLevels
		(*TCoroutineData)(unsafe.Pointer(corPtr)).FauxNumLevels = numLevels1 - (*TCoroutineData)(unsafe.Pointer(corPtr)).FauxNumLevels
		(*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).FcallerEEPtr
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * CoroTypeObjCmd --
 *
 *	Implementation of [::tcl::unsupported::corotype] command.
 *
 *----------------------------------------------------------------------
 */

func _CoroTypeObjCmd(tls *libc.TLS, dummy9316 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var cmdPtr, corPtr, v1 uintptr
	_, _, _ = cmdPtr, corPtr, v1
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+2290)
		return int32(TCL_ERROR)
	}
	/*
	 * Look up the coroutine.
	 */
	cmdPtr = XTcl_GetCommandFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if !(cmdPtr != 0) || (*TCommand)(unsafe.Pointer(cmdPtr)).FnreProc != __ccgo_fp(XTclNRInterpCoroutine) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+9598, int64(-libc.Int32FromInt32(1))))
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+9371, v1, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * An active coroutine is "active". Can't tell what it might do in the
	 * future.
	 */
	corPtr = (*TCommand)(unsafe.Pointer(cmdPtr)).FobjClientData
	if !((*TCoroutineData)(unsafe.Pointer(corPtr)).FstackLevel == libc.UintptrFromInt32(0)) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+9641, int64(-libc.Int32FromInt32(1))))
		return TCL_OK
	}
	/*
	 * Inactive coroutines are classified by the (effective) command used to
	 * suspend them, which matters when you're injecting a probe.
	 */
	switch (*TCoroutineData)(unsafe.Pointer(corPtr)).Fnargs {
	case int64(-libc.Int32FromInt32(1)):
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+3522, int64(-libc.Int32FromInt32(1))))
		return TCL_OK
	case int64(-libc.Int32FromInt32(2)):
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+5445, int64(-libc.Int32FromInt32(1))))
		return TCL_OK
	default:
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+9648, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+9371, __ccgo_ts+9671, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * TclNRCoroInjectObjCmd, TclNRCoroProbeObjCmd --
 *
 *	Implementation of [coroinject] and [coroprobe] commands.
 *
 *----------------------------------------------------------------------
 */

func _GetCoroutineFromObj(tls *libc.TLS, interp uintptr, objPtr uintptr, errMsg uintptr) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var cmdPtr, v1 uintptr
	_, _ = cmdPtr, v1
	/*
	 * How to get a coroutine from its handle.
	 */
	cmdPtr = XTcl_GetCommandFromObj(tls, interp, objPtr)
	if !(cmdPtr != 0) || (*TCommand)(unsafe.Pointer(cmdPtr)).FnreProc != __ccgo_fp(XTclNRInterpCoroutine) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, errMsg, int64(-libc.Int32FromInt32(1))))
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
		}
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+9371, v1, libc.UintptrFromInt32(0)))
		return libc.UintptrFromInt32(0)
	}
	return (*TCommand)(unsafe.Pointer(cmdPtr)).FobjClientData
}

func _TclNRCoroInjectObjCmd(tls *libc.TLS, dummy9406 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var _objPtr, cachePtr, corPtr, savedEEPtr uintptr
	var v1 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _, _, _ = _objPtr, cachePtr, corPtr, savedEEPtr, v1
	/*
	 * Usage more or less like tailcall:
	 *   coroinject coroName cmd ?arg1 arg2 ...?
	 */
	if objc < int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+9680)
		return int32(TCL_ERROR)
	}
	corPtr = _GetCoroutineFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), __ccgo_ts+9709)
	if !(corPtr != 0) {
		return int32(TCL_ERROR)
	}
	if !((*TCoroutineData)(unsafe.Pointer(corPtr)).FstackLevel == libc.UintptrFromInt32(0)) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+9752, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+9371, __ccgo_ts+9805, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Add the callback to the coro's execEnv, so that it is the first thing
	 * to happen when the coro is resumed.
	 */
	savedEEPtr = (*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr
	(*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).FeePtr
	if v1 = interp == libc.UintptrFromInt32(0); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(_InjectHandler)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = corPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = XTcl_NewListObj(tls, int64(objc-int32(2)), objv+uintptr(2)*8)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = uintptr((*TCoroutineData)(unsafe.Pointer(corPtr)).Fnargs)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
	(*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr = savedEEPtr
	return TCL_OK
}

func _TclNRCoroProbeObjCmd(tls *libc.TLS, dummy9451 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var _objPtr, _objPtr1, cachePtr, cachePtr1, savedEEPtr uintptr
	var numLevels TTcl_Size
	var v1, v2 bool
	var _ /* _callbackPtr at bp+16 */ uintptr
	var _ /* _callbackPtr at bp+8 */ uintptr
	var _ /* corPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, cachePtr1, numLevels, savedEEPtr, v1, v2
	/*
	 * Usage more or less like tailcall:
	 *   coroprobe coroName cmd ?arg1 arg2 ...?
	 */
	if objc < int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+9680)
		return int32(TCL_ERROR)
	}
	*(*uintptr)(unsafe.Pointer(bp)) = _GetCoroutineFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), __ccgo_ts+9812)
	if !(*(*uintptr)(unsafe.Pointer(bp)) != 0) {
		return int32(TCL_ERROR)
	}
	if !((*TCoroutineData)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FstackLevel == libc.UintptrFromInt32(0)) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+9861, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+32, __ccgo_ts+2004, __ccgo_ts+9371, __ccgo_ts+9805, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Add the callback to the coro's execEnv, so that it is the first thing
	 * to happen when the coro is resumed.
	 */
	savedEEPtr = (*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr
	(*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr = (*TCoroutineData)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FeePtr
	if v1 = interp == libc.UintptrFromInt32(0); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 8)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FprocPtr = __ccgo_fp(_InjectHandler)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8)) = *(*uintptr)(unsafe.Pointer(bp))
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 1*8)) = XTcl_NewListObj(tls, int64(objc-int32(2)), objv+uintptr(2)*8)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 2*8)) = uintptr((*TCoroutineData)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fnargs)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 3*8)) = *(*uintptr)(unsafe.Pointer(bp))
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
	(*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr = savedEEPtr
	/*
	 * Now we immediately transfer control to the coroutine to run our probe.
	 * TRICKY STUFF copied from the [yield] implementation.
	 *
	 * Push the callback to restore the caller's context on yield back.
	 */
	if v2 = interp == libc.UintptrFromInt32(0); !v2 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr1 = XTclThreadAllocObj(tls)
	} else {
		_objPtr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr1 + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 16)) = _objPtr1
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FprocPtr = __ccgo_fp(_NRCoroutineCallerCallback)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8)) = *(*uintptr)(unsafe.Pointer(bp))
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 16))
	/*
	 * Record the stackLevel at which the resume is happening, then swap
	 * the interp's environment to make it suitable to run this coroutine.
	 */
	(*TCoroutineData)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FstackLevel = bp
	numLevels = (*TCoroutineData)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FauxNumLevels
	(*TCoroutineData)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FauxNumLevels = (*TInterp)(unsafe.Pointer(interp)).FnumLevels
	/*
	 * Do the actual stack swap.
	 */
	(*TCoroutineData)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fcaller.FframePtr = (*TInterp)(unsafe.Pointer(interp)).FframePtr
	(*TCoroutineData)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fcaller.FvarFramePtr = (*TInterp)(unsafe.Pointer(interp)).FvarFramePtr
	(*TCoroutineData)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fcaller.FcmdFramePtr = (*TInterp)(unsafe.Pointer(interp)).FcmdFramePtr
	(*TCoroutineData)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fcaller.FlineLABCPtr = (*TInterp)(unsafe.Pointer(interp)).FlineLABCPtr
	(*TCoroutineData)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FcallerEEPtr = (*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr
	(*TInterp)(unsafe.Pointer(interp)).FframePtr = (*TCoroutineData)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Frunning.FframePtr
	(*TInterp)(unsafe.Pointer(interp)).FvarFramePtr = (*TCoroutineData)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Frunning.FvarFramePtr
	(*TInterp)(unsafe.Pointer(interp)).FcmdFramePtr = (*TCoroutineData)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Frunning.FcmdFramePtr
	(*TInterp)(unsafe.Pointer(interp)).FlineLABCPtr = (*TCoroutineData)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Frunning.FlineLABCPtr
	(*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr = (*TCoroutineData)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FeePtr
	*(*TTcl_Size)(unsafe.Pointer(interp + 72)) += numLevels
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * InjectHandler, InjectHandlerPostProc --
 *
 *	Part of the implementation of [coroinject] and [coroprobe]. These are
 *	run inside the context of the coroutine being injected/probed into.
 *
 *	InjectHandler runs a script (possibly adding arguments) in the context
 *	of the coroutine. The script is specified as a one-shot list (with
 *	reference count equal to 1) in data[1]. This function also arranges
 *	for InjectHandlerPostProc to be the part that runs after the script
 *	completes.
 *
 *	InjectHandlerPostProc cleans up after InjectHandler (deleting the
 *	list) and, for the [coroprobe] command *only*, yields back to the
 *	caller context (i.e., where [coroprobe] was run).
 *s
 *----------------------------------------------------------------------
 */

func _InjectHandler(tls *libc.TLS, data uintptr, interp uintptr, dummy9548 int32) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _objPtr, cachePtr, cachePtr1, corPtr, isProbe, listPtr, nargsObj uintptr
	var nargs TTcl_Size
	var v1, v2 bool
	var v4, v5 int64
	var _ /* _callbackPtr at bp+16 */ uintptr
	var _ /* objc at bp+0 */ TTcl_Size
	var _ /* objv at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, cachePtr1, corPtr, isProbe, listPtr, nargs, nargsObj, v1, v2, v4, v5
	corPtr = *(*uintptr)(unsafe.Pointer(data))
	listPtr = *(*uintptr)(unsafe.Pointer(data + 1*8))
	nargs = int64(*(*uintptr)(unsafe.Pointer(data + 2*8)))
	isProbe = *(*uintptr)(unsafe.Pointer(data + 3*8))
	if !(isProbe != 0) {
		/*
		 * If this is [coroinject], add the extra arguments now.
		 */
		if nargs == int64(-libc.Int32FromInt32(1)) {
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listPtr, XTcl_NewStringObj(tls, __ccgo_ts+3522, int64(-libc.Int32FromInt32(1))))
		} else {
			if nargs == int64(-libc.Int32FromInt32(2)) {
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listPtr, XTcl_NewStringObj(tls, __ccgo_ts+5445, int64(-libc.Int32FromInt32(1))))
			} else {
				if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
					nargsObj = XTclThreadAllocObj(tls)
				} else {
					nargsObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(nargsObj + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(nargsObj)).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer(nargsObj)).Fbytes = libc.UintptrFromInt32(0)
				*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(nargsObj)).FinternalRep)) = nargs
				(*TTcl_Obj)(unsafe.Pointer(nargsObj)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listPtr, nargsObj)
			}
		}
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listPtr, XTcl_GetObjResult(tls, interp))
	}
	/*
	 * Call the user's script; we're in the right place.
	 */
	(*TTcl_Obj)(unsafe.Pointer(listPtr)).FrefCount++
	XTclMarkTailcall(tls, interp)
	if v2 = interp == libc.UintptrFromInt32(0); !v2 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 16)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FprocPtr = __ccgo_fp(_InjectHandlerPostCall)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8)) = corPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 1*8)) = listPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 2*8)) = uintptr(nargs)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 3*8)) = isProbe
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 16))
	if (*TTcl_Obj)(unsafe.Pointer(listPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listPtr + 32))).Fptr2 != 0 {
			v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr + 32))).Fptr2)).FspanStart
		} else {
			v4 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listPtr + 32))).Fptr1 + 40 + uintptr(v4)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listPtr + 32))).Fptr2 != 0 {
			v5 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr + 32))).Fptr2)).FspanLength
		} else {
			v5 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v5
		_ = libc.Int32FromInt32(TCL_OK)
	} else {
		XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), listPtr, bp, bp+8)
	}
	return XTclNREvalObjv(tls, interp, *(*TTcl_Size)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 8)), 0, libc.UintptrFromInt32(0))
}

func _InjectHandlerPostCall(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	var _objPtr, corPtr, isProbe, listPtr, v2 uintptr
	var nargs, numLevels, v1 TTcl_Size
	_, _, _, _, _, _, _, _ = _objPtr, corPtr, isProbe, listPtr, nargs, numLevels, v1, v2
	corPtr = *(*uintptr)(unsafe.Pointer(data))
	listPtr = *(*uintptr)(unsafe.Pointer(data + 1*8))
	nargs = int64(*(*uintptr)(unsafe.Pointer(data + 2*8)))
	isProbe = *(*uintptr)(unsafe.Pointer(data + 3*8))
	/*
	 * Delete the command words for what we just executed.
	 */
	_objPtr = listPtr
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	/*
	 * If we were doing a probe, splice ourselves back out of the stack
	 * cleanly here. General injection should instead just look after itself.
	 *
	 * Code from guts of [yield] implementation.
	 */
	if isProbe != 0 {
		if result == int32(TCL_ERROR) {
			XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+9920, int64(-int32(1))))
		}
		(*TCoroutineData)(unsafe.Pointer(corPtr)).Fnargs = nargs
		(*TCoroutineData)(unsafe.Pointer(corPtr)).FstackLevel = libc.UintptrFromInt32(0)
		numLevels = (*TInterp)(unsafe.Pointer(interp)).FnumLevels
		(*TInterp)(unsafe.Pointer(interp)).FnumLevels = (*TCoroutineData)(unsafe.Pointer(corPtr)).FauxNumLevels
		(*TCoroutineData)(unsafe.Pointer(corPtr)).FauxNumLevels = numLevels - (*TCoroutineData)(unsafe.Pointer(corPtr)).FauxNumLevels
		(*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).FcallerEEPtr
	}
	return result
}

func XTclNRInterpCoroutine(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument objects. */
	var _objPtr, cachePtr, corPtr, v1 uintptr
	var v2 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _, _, _ = _objPtr, cachePtr, corPtr, v1, v2
	corPtr = clientData
	if !((*TCoroutineData)(unsafe.Pointer(corPtr)).FstackLevel == libc.UintptrFromInt32(0)) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+9960, libc.VaList(bp+16, v1)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+9371, __ccgo_ts+9994, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Parse all the arguments to work out what to feed as the result of the
	 * [yield]. TRICKY POINT: objc==0 happens here! It occurs when a coroutine
	 * is deleted!
	 */
	switch (*TCoroutineData)(unsafe.Pointer(corPtr)).Fnargs {
	case int64(-libc.Int32FromInt32(1)):
		if objc == int32(2) {
			XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
		} else {
			if objc > int32(2) {
				XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+9999)
				return int32(TCL_ERROR)
			}
		}
	default:
		if (*TCoroutineData)(unsafe.Pointer(corPtr)).Fnargs+int64(1) != int64(objc) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+10005, int64(-libc.Int32FromInt32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+9101, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		/* fallthrough */
		fallthrough
	case int64(-libc.Int32FromInt32(2)):
		if objc > int32(1) {
			XTcl_SetObjResult(tls, interp, XTcl_NewListObj(tls, int64(objc-int32(1)), objv+uintptr(1)*8))
		}
		break
	}
	if v2 = interp == libc.UintptrFromInt32(0); !v2 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(XTclNRCoroutineActivateCallback)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = corPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclNRCoroutineObjCmd --
 *
 *	Implementation of [coroutine] command; see documentation for
 *	description of what this does.
 *
 *----------------------------------------------------------------------
 */

func XTclNRCoroutineObjCmd(tls *libc.TLS, dummy9696 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(128)
	defer tls.Free(128) /* Argument objects. */
	var _objPtr, _objPtr1, cachePtr, cachePtr1, cmdPtr, corPtr, hePtr, inNsPtr, lookupNsPtr, newPtr, procName, v1, v3 uintptr
	var v4, v5 bool
	var _ /* _callbackPtr at bp+64 */ uintptr
	var _ /* _callbackPtr at bp+72 */ uintptr
	var _ /* altNsPtr at bp+16 */ uintptr
	var _ /* cxtNsPtr at bp+24 */ uintptr
	var _ /* hSearch at bp+32 */ TTcl_HashSearch
	var _ /* isNew at bp+56 */ int32
	var _ /* nsPtr at bp+8 */ uintptr
	var _ /* simpleName at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, cachePtr1, cmdPtr, corPtr, hePtr, inNsPtr, lookupNsPtr, newPtr, procName, v1, v3, v4, v5
	inNsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FnsPtr
	lookupNsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FnsPtr
	if objc < int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+10061)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	procName = v1
	XTclGetNamespaceForQualName(tls, interp, procName, inNsPtr, 0, bp+8, bp+16, bp+24, bp)
	if *(*uintptr)(unsafe.Pointer(bp + 8)) == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+10080, libc.VaList(bp+88, procName)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+88, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+10127, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+10137, libc.VaList(bp+88, procName)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+88, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+8118, procName, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * We ARE creating the coroutine command: allocate the corresponding
	 * struct and create the corresponding command.
	 */
	corPtr = XTcl_Alloc(tls, uint64(128))
	cmdPtr = XTclNRCreateCommandInNs(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 8)), libc.UintptrFromInt32(0), __ccgo_fp(XTclNRInterpCoroutine), corPtr, __ccgo_fp(_DeleteCoroutine))
	(*TCoroutineData)(unsafe.Pointer(corPtr)).FcmdPtr = cmdPtr
	(*TCommand)(unsafe.Pointer(cmdPtr)).FrefCount++
	/*
	 * #280.
	 * Provide the new coroutine with its own copy of the lineLABCPtr
	 * hashtable for literal command arguments in bytecode. Note that
	 * CFWordBC chains are not duplicated, only the entrypoints to them. This
	 * means that in the presence of coroutines each chain is potentially a
	 * tree. Like the chain -> tree conversion of the CmdFrame stack.
	 */
	(*TCoroutineData)(unsafe.Pointer(corPtr)).FlineLABCPtr = XTcl_Alloc(tls, uint64(104))
	XTcl_InitHashTable(tls, (*TCoroutineData)(unsafe.Pointer(corPtr)).FlineLABCPtr, int32(TCL_ONE_WORD_KEYS))
	hePtr = XTcl_FirstHashEntry(tls, (*TInterp)(unsafe.Pointer(interp)).FlineLABCPtr, bp+32)
	for {
		if !(hePtr != 0) {
			break
		}
		if (*TTcl_HashTable)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FlineLABCPtr)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FlineLABCPtr)).FkeyType == -int32(1) {
			v3 = *(*uintptr)(unsafe.Pointer(hePtr + 32))
		} else {
			v3 = hePtr + 32
		}
		newPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TCoroutineData)(unsafe.Pointer(corPtr)).FlineLABCPtr)).FcreateProc})))(tls, (*TCoroutineData)(unsafe.Pointer(corPtr)).FlineLABCPtr, v3, bp+56)
		(*TTcl_HashEntry)(unsafe.Pointer(newPtr)).FclientData = (*TTcl_HashEntry)(unsafe.Pointer(hePtr)).FclientData
		goto _2
	_2:
		;
		hePtr = XTcl_NextHashEntry(tls, bp+32)
	}
	/*
	 * Create the base context.
	 */
	(*TCoroutineData)(unsafe.Pointer(corPtr)).Frunning.FframePtr = (*TInterp)(unsafe.Pointer(interp)).FrootFramePtr
	(*TCoroutineData)(unsafe.Pointer(corPtr)).Frunning.FvarFramePtr = (*TInterp)(unsafe.Pointer(interp)).FrootFramePtr
	(*TCoroutineData)(unsafe.Pointer(corPtr)).Frunning.FcmdFramePtr = libc.UintptrFromInt32(0)
	(*TCoroutineData)(unsafe.Pointer(corPtr)).Frunning.FlineLABCPtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).FlineLABCPtr
	(*TCoroutineData)(unsafe.Pointer(corPtr)).FstackLevel = libc.UintptrFromInt32(0)
	(*TCoroutineData)(unsafe.Pointer(corPtr)).FauxNumLevels = 0
	(*TCoroutineData)(unsafe.Pointer(corPtr)).FyieldPtr = libc.UintptrFromInt32(0)
	/*
	 * Create the coro's execEnv, switch to it to push the exit and coro
	 * command callbacks, then switch back.
	 */
	(*TCoroutineData)(unsafe.Pointer(corPtr)).FeePtr = XTclCreateExecEnv(tls, interp, uint64(CORO_STACK_INITIAL_SIZE))
	(*TCoroutineData)(unsafe.Pointer(corPtr)).FcallerEEPtr = (*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr
	(*TExecEnv1)(unsafe.Pointer((*TCoroutineData)(unsafe.Pointer(corPtr)).FeePtr)).FcorPtr = corPtr
	(*TCoroutineData)(unsafe.Pointer(corPtr)).Fcaller.FframePtr = (*TInterp)(unsafe.Pointer(interp)).FframePtr
	(*TCoroutineData)(unsafe.Pointer(corPtr)).Fcaller.FvarFramePtr = (*TInterp)(unsafe.Pointer(interp)).FvarFramePtr
	(*TCoroutineData)(unsafe.Pointer(corPtr)).Fcaller.FcmdFramePtr = (*TInterp)(unsafe.Pointer(interp)).FcmdFramePtr
	(*TCoroutineData)(unsafe.Pointer(corPtr)).Fcaller.FlineLABCPtr = (*TInterp)(unsafe.Pointer(interp)).FlineLABCPtr
	(*TCoroutineData)(unsafe.Pointer(corPtr)).FcallerEEPtr = (*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr
	(*TInterp)(unsafe.Pointer(interp)).FframePtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).Frunning.FframePtr
	(*TInterp)(unsafe.Pointer(interp)).FvarFramePtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).Frunning.FvarFramePtr
	(*TInterp)(unsafe.Pointer(interp)).FcmdFramePtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).Frunning.FcmdFramePtr
	(*TInterp)(unsafe.Pointer(interp)).FlineLABCPtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).Frunning.FlineLABCPtr
	(*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).FeePtr
	if v4 = interp == libc.UintptrFromInt32(0); !v4 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 64)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 64)))).FprocPtr = __ccgo_fp(_NRCoroutineExitCallback)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 64)) + 8)) = corPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 64)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 64)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 64)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 64)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 64))
	/*
	 * Ensure that the command is looked up in the correct namespace.
	 */
	(*TInterp)(unsafe.Pointer(interp)).FlookupNsPtr = lookupNsPtr
	XTcl_NREvalObj(tls, interp, XTcl_NewListObj(tls, int64(objc-int32(2)), objv+uintptr(2)*8), 0)
	(*TInterp)(unsafe.Pointer(interp)).FnumLevels--
	(*TCoroutineData)(unsafe.Pointer(corPtr)).Frunning.FframePtr = (*TInterp)(unsafe.Pointer(interp)).FframePtr
	(*TCoroutineData)(unsafe.Pointer(corPtr)).Frunning.FvarFramePtr = (*TInterp)(unsafe.Pointer(interp)).FvarFramePtr
	(*TCoroutineData)(unsafe.Pointer(corPtr)).Frunning.FcmdFramePtr = (*TInterp)(unsafe.Pointer(interp)).FcmdFramePtr
	(*TCoroutineData)(unsafe.Pointer(corPtr)).Frunning.FlineLABCPtr = (*TInterp)(unsafe.Pointer(interp)).FlineLABCPtr
	(*TInterp)(unsafe.Pointer(interp)).FframePtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).Fcaller.FframePtr
	(*TInterp)(unsafe.Pointer(interp)).FvarFramePtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).Fcaller.FvarFramePtr
	(*TInterp)(unsafe.Pointer(interp)).FcmdFramePtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).Fcaller.FcmdFramePtr
	(*TInterp)(unsafe.Pointer(interp)).FlineLABCPtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).Fcaller.FlineLABCPtr
	(*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).FcallerEEPtr
	/*
	 * Now just resume the coroutine.
	 */
	if v5 = interp == libc.UintptrFromInt32(0); !v5 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v5 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr1 = XTclThreadAllocObj(tls)
	} else {
		_objPtr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr1 + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 72)) = _objPtr1
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)))).FprocPtr = __ccgo_fp(XTclNRCoroutineActivateCallback)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)) + 8)) = corPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 72))
	return TCL_OK
}

/*
 * This is used in the [info] ensemble
 */

func XTclInfoCoroutineCmd(tls *libc.TLS, dummy9830 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var cachePtr, corPtr, namePtr uintptr
	var v1 bool
	_, _, _, _ = cachePtr, corPtr, namePtr, v1
	corPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcorPtr
	if objc != int32(1) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, libc.UintptrFromInt32(0))
		return int32(TCL_ERROR)
	}
	if corPtr != 0 && !((*TCommand1)(unsafe.Pointer((*TCoroutineData)(unsafe.Pointer(corPtr)).FcmdPtr)).Fflags&libc.Int32FromInt32(CMD_DYING) != 0) {
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			namePtr = XTclThreadAllocObj(tls)
		} else {
			namePtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(namePtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(namePtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(namePtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(namePtr)).FtypePtr = libc.UintptrFromInt32(0)
		XTcl_GetCommandFullName(tls, interp, (*TCoroutineData)(unsafe.Pointer(corPtr)).FcmdPtr, namePtr)
		XTcl_SetObjResult(tls, interp, namePtr)
	}
	return TCL_OK
}

type TExecEnv1 = struct {
	FexecStackPtr uintptr
	Fconstants    [2]uintptr
	Finterp       uintptr
	FcallbackPtr  uintptr
	FcorPtr       uintptr
	Frewind       int32
}

const BINARY_ALL = -1
const BINARY_NOCOUNT = -2
const BINARY_SCAN_MAX_CACHE = 260
const BINARY_SIGNED = 0
const BINARY_UNSIGNED = 1
const FLT_MAX1 = 3.4028234663852886e+38

/*
 * The following tables are used by the binary encoders
 */

var _HexDigits = [16]uint8{
	0:  uint8('0'),
	1:  uint8('1'),
	2:  uint8('2'),
	3:  uint8('3'),
	4:  uint8('4'),
	5:  uint8('5'),
	6:  uint8('6'),
	7:  uint8('7'),
	8:  uint8('8'),
	9:  uint8('9'),
	10: uint8('a'),
	11: uint8('b'),
	12: uint8('c'),
	13: uint8('d'),
	14: uint8('e'),
	15: uint8('f'),
}

var _UueDigits = [65]uint8{
	0:  uint8('`'),
	1:  uint8('!'),
	2:  uint8('"'),
	3:  uint8('#'),
	4:  uint8('$'),
	5:  uint8('%'),
	6:  uint8('&'),
	7:  uint8('\''),
	8:  uint8('('),
	9:  uint8(')'),
	10: uint8('*'),
	11: uint8('+'),
	12: uint8(','),
	13: uint8('-'),
	14: uint8('.'),
	15: uint8('/'),
	16: uint8('0'),
	17: uint8('1'),
	18: uint8('2'),
	19: uint8('3'),
	20: uint8('4'),
	21: uint8('5'),
	22: uint8('6'),
	23: uint8('7'),
	24: uint8('8'),
	25: uint8('9'),
	26: uint8(':'),
	27: uint8(';'),
	28: uint8('<'),
	29: uint8('='),
	30: uint8('>'),
	31: uint8('?'),
	32: uint8('@'),
	33: uint8('A'),
	34: uint8('B'),
	35: uint8('C'),
	36: uint8('D'),
	37: uint8('E'),
	38: uint8('F'),
	39: uint8('G'),
	40: uint8('H'),
	41: uint8('I'),
	42: uint8('J'),
	43: uint8('K'),
	44: uint8('L'),
	45: uint8('M'),
	46: uint8('N'),
	47: uint8('O'),
	48: uint8('P'),
	49: uint8('Q'),
	50: uint8('R'),
	51: uint8('S'),
	52: uint8('T'),
	53: uint8('U'),
	54: uint8('V'),
	55: uint8('W'),
	56: uint8('X'),
	57: uint8('Y'),
	58: uint8('Z'),
	59: uint8('['),
	60: uint8('\\'),
	61: uint8(']'),
	62: uint8('^'),
	63: uint8('_'),
	64: uint8('`'),
}

var _B64Digits = [65]uint8{
	0:  uint8('A'),
	1:  uint8('B'),
	2:  uint8('C'),
	3:  uint8('D'),
	4:  uint8('E'),
	5:  uint8('F'),
	6:  uint8('G'),
	7:  uint8('H'),
	8:  uint8('I'),
	9:  uint8('J'),
	10: uint8('K'),
	11: uint8('L'),
	12: uint8('M'),
	13: uint8('N'),
	14: uint8('O'),
	15: uint8('P'),
	16: uint8('Q'),
	17: uint8('R'),
	18: uint8('S'),
	19: uint8('T'),
	20: uint8('U'),
	21: uint8('V'),
	22: uint8('W'),
	23: uint8('X'),
	24: uint8('Y'),
	25: uint8('Z'),
	26: uint8('a'),
	27: uint8('b'),
	28: uint8('c'),
	29: uint8('d'),
	30: uint8('e'),
	31: uint8('f'),
	32: uint8('g'),
	33: uint8('h'),
	34: uint8('i'),
	35: uint8('j'),
	36: uint8('k'),
	37: uint8('l'),
	38: uint8('m'),
	39: uint8('n'),
	40: uint8('o'),
	41: uint8('p'),
	42: uint8('q'),
	43: uint8('r'),
	44: uint8('s'),
	45: uint8('t'),
	46: uint8('u'),
	47: uint8('v'),
	48: uint8('w'),
	49: uint8('x'),
	50: uint8('y'),
	51: uint8('z'),
	52: uint8('0'),
	53: uint8('1'),
	54: uint8('2'),
	55: uint8('3'),
	56: uint8('4'),
	57: uint8('5'),
	58: uint8('6'),
	59: uint8('7'),
	60: uint8('8'),
	61: uint8('9'),
	62: uint8('+'),
	63: uint8('/'),
	64: uint8('='),
}

/*
 * How to construct the ensembles.
 */

var _binaryMap = [5]TEnsembleImplMap{
	0: {
		Fname: __ccgo_ts + 5199,
	},
	1: {
		Fname: __ccgo_ts + 5378,
	},
	2: {
		Fname: __ccgo_ts + 10185,
	},
	3: {
		Fname: __ccgo_ts + 10192,
	},
	4: {},
}

func init() {
	p := unsafe.Pointer(&_binaryMap)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_BinaryFormatCmd)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(XTclCompileBasicMin1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(_BinaryScanCmd)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(XTclCompileBasicMin2ArgCmd)
}

var _encodeMap = [4]TEnsembleImplMap{
	0: {
		Fname: __ccgo_ts + 10199,
	},
	1: {
		Fname: __ccgo_ts + 10203,
	},
	2: {
		Fname: __ccgo_ts + 10212,
	},
	3: {},
}

func init() {
	p := unsafe.Pointer(&_encodeMap)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_BinaryEncodeHex)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(_BinaryEncodeUu)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(_BinaryEncode64)
}

var _decodeMap = [4]TEnsembleImplMap{
	0: {
		Fname: __ccgo_ts + 10199,
	},
	1: {
		Fname: __ccgo_ts + 10203,
	},
	2: {
		Fname: __ccgo_ts + 10212,
	},
	3: {},
}

func init() {
	p := unsafe.Pointer(&_decodeMap)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_BinaryDecodeHex)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(XTclCompileBasic1Or2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(_BinaryDecodeUu)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(XTclCompileBasic1Or2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(_BinaryDecode64)
	*(*uintptr)(unsafe.Add(p, 112)) = __ccgo_fp(XTclCompileBasic1Or2ArgCmd)
}

/*
 * The following Tcl_ObjType represents an array of bytes. The intent is to
 * allow arbitrary binary data to pass through Tcl as a Tcl value without loss
 * or damage. Such values are useful for things like encoded strings or Tk
 * images to name just two.
 *
 * A bytearray is an ordered sequence of bytes. Each byte is an integer value
 * in the range [0-255].  To be a Tcl value type, we need a way to encode each
 * value in the value set as a Tcl string.  A simple encoding is to
 * represent each byte value as the same codepoint value.  A bytearray of N
 * bytes is encoded into a Tcl string of N characters where the codepoint of
 * each character is the value of corresponding byte.  This approach creates a
 * one-to-one map between all bytearray values and a subset of Tcl string
 * values.  Tcl string values outside that subset do no represent any valid
 * bytearray value.  Attempts to treat those values as bytearrays will lead
 * to errors.  See TIP 568 for how this differs from Tcl 8.
 */

var _properByteArrayType = TTcl_ObjType{
	Fname: __ccgo_ts + 10219,
}

func init() {
	p := unsafe.Pointer(&_properByteArrayType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_FreeProperByteArrayInternalRep)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_DupProperByteArrayInternalRep)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_UpdateStringOfByteArray)
}

/*
 * The following structure is the internal rep for a ByteArray object. Keeps
 * track of how much memory has been used and how much has been allocated for
 * the byte array to enable growing and shrinking of the ByteArray object with
 * fewer mallocs.
 */

type TByteArray = struct {
	Fused      TTcl_Size
	Fallocated TTcl_Size
}

func XTclIsPureByteArray(tls *libc.TLS, objPtr uintptr) (r int32) {
	return libc.BoolInt32((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_properByteArrayType)))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_NewByteArrayObj --
 *
 *	This procedure is creates a new ByteArray object and initializes it
 *	from the given array of bytes.
 *
 * Results:
 *	The newly created object is returned. This object has no initial
 *	string representation. The returned object has a ref count of 0.
 *
 * Side effects:
 *	Memory allocated for new object and copy of byte array argument.
 *
 *----------------------------------------------------------------------
 */

func XTcl_NewByteArrayObj(tls *libc.TLS, bytes uintptr, numBytes TTcl_Size) (r uintptr) {
	/* Number of bytes in the array,
	 * must be >= 0. */
	var cachePtr, objPtr uintptr
	var v1 bool
	_, _, _ = cachePtr, objPtr, v1
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	XTcl_SetByteArrayObj(tls, objPtr, bytes, numBytes)
	return objPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DbNewByteArrayObj --
 *
 *	This procedure is normally called when debugging: i.e., when
 *	TCL_MEM_DEBUG is defined. It is the same as the Tcl_NewByteArrayObj
 *	above except that it calls Tcl_DbCkalloc directly with the file name
 *	and line number from its caller. This simplifies debugging since then
 *	the [memory active] command will report the correct file name and line
 *	number when reporting objects that haven't been freed.
 *
 *	When TCL_MEM_DEBUG is not defined, this procedure just returns the
 *	result of calling Tcl_NewByteArrayObj.
 *
 * Results:
 *	The newly created object is returned. This object has no initial
 *	string representation. The returned object has a ref count of 0.
 *
 * Side effects:
 *	Memory allocated for new object and copy of byte array argument.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DbNewByteArrayObj(tls *libc.TLS, bytes uintptr, numBytes TTcl_Size, dummy290 uintptr, dummy291 int32) (r uintptr) {
	return XTcl_NewByteArrayObj(tls, bytes, numBytes)
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_SetByteArrayObj --
 *
 *	Modify an object to be a ByteArray object and to have the specified
 *	array of bytes as its value.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The object's old string rep and internal rep is freed. Memory
 *	allocated for copy of byte array argument.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetByteArrayObj(tls *libc.TLS, objPtr uintptr, bytes uintptr, numBytes TTcl_Size) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Number of bytes in the array,
	 * must be >= 0 */
	var _isobjPtr, byteArrayPtr uintptr
	var v1 uint64
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_, _, _ = _isobjPtr, byteArrayPtr, v1
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+10229, libc.VaList(bp+24, __ccgo_ts+10258))
	}
	_isobjPtr = objPtr
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
	if numBytes < 0 || libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))-libc.Int64FromUint64(uint64(libc.UintptrFromInt32(0)+16)) < numBytes {
		XTcl_Panic(tls, __ccgo_ts+10278, 0)
		v1 = libc.Uint64FromInt32(libc.Int32FromInt32(0))
	} else {
		v1 = uint64(libc.UintptrFromInt32(0)+16) + libc.Uint64FromInt64(numBytes)
	}
	byteArrayPtr = XTcl_Alloc(tls, v1)
	(*TByteArray)(unsafe.Pointer(byteArrayPtr)).Fused = numBytes
	(*TByteArray)(unsafe.Pointer(byteArrayPtr)).Fallocated = numBytes
	if bytes != libc.UintptrFromInt32(0) && numBytes > 0 {
		libc.Xmemcpy(tls, byteArrayPtr+16, bytes, libc.Uint64FromInt64(numBytes))
	}
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr1 = byteArrayPtr
	XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&_properByteArrayType)), bp)
}

/*
 *----------------------------------------------------------------------
 *
 * TclGetBytesFromObj --
 *
 *	Attempt to extract the value from objPtr in the representation
 *	of a byte sequence. On success return the extracted byte sequence.
 *	On failure, return NULL and record error message and code in
 *	interp (if not NULL).
 *
 * Results:
 *	NULL or pointer to array of bytes representing the ByteArray object.
 *	Writes number of bytes in array to *numBytesPtr.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetBytesFromObj(tls *libc.TLS, interp uintptr, objPtr uintptr, numBytesPtr uintptr) (r uintptr) {
	/* If non-NULL, write the number of bytes
	 * in the array here */
	var baPtr, irPtr, v1, v2 uintptr
	_, _, _, _ = baPtr, irPtr, v1, v2
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_properByteArrayType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr == libc.UintptrFromInt32(0) {
		if int32(TCL_ERROR) == _SetByteArrayFromAny(tls, interp, int64(-libc.Int32FromInt32(1)), objPtr) {
			return libc.UintptrFromInt32(0)
		}
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_properByteArrayType)) {
			v2 = objPtr + 32
		} else {
			v2 = libc.UintptrFromInt32(0)
		}
		irPtr = v2
	}
	baPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(irPtr))).Fptr1
	if numBytesPtr != libc.UintptrFromInt32(0) {
		*(*TTcl_Size)(unsafe.Pointer(numBytesPtr)) = (*TByteArray)(unsafe.Pointer(baPtr)).Fused
	}
	return baPtr + 16
}

func XTclGetBytesFromObj(tls *libc.TLS, interp uintptr, objPtr uintptr, numBytesPtr uintptr) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* If non-NULL, write the number of bytes
	 * in the array here */
	var bytes uintptr
	var _ /* numBytes at bp+0 */ TTcl_Size
	_ = bytes
	*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	bytes = XTcl_GetBytesFromObj(tls, interp, objPtr, bp)
	if bytes != 0 && numBytesPtr != 0 {
		if *(*TTcl_Size)(unsafe.Pointer(bp)) > int64(INT_MAX) {
			/* Caller asked for numBytes to be written to an int, but the
			 * value is outside the int range. */
			if interp != 0 {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+10340, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+10377, __ccgo_ts+10381, libc.UintptrFromInt32(0)))
			}
			return libc.UintptrFromInt32(0)
		} else {
			*(*int32)(unsafe.Pointer(numBytesPtr)) = int32(*(*TTcl_Size)(unsafe.Pointer(bp)))
		}
	}
	return bytes
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetByteArrayLength --
 *
 *	This procedure changes the length of the byte array for this object.
 *	Once the caller has set the length of the array, it is acceptable to
 *	directly modify the bytes in the array up until Tcl_GetStringFromObj()
 *	has been called on this object.
 *
 * Results:
 *	The new byte array of the specified length.
 *
 * Side effects:
 *	Allocates enough memory for an array of bytes of the requested size.
 *	When growing the array, the old array is copied to the new array; new
 *	bytes are undefined. When shrinking, the old array is truncated to the
 *	specified length.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetByteArrayLength(tls *libc.TLS, objPtr uintptr, numBytes TTcl_Size) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Number of bytes in resized array
	 * Must be >= 0 */
	var _isobjPtr, byteArrayPtr, irPtr, v1, v2 uintptr
	var v3 uint64
	_, _, _, _, _, _ = _isobjPtr, byteArrayPtr, irPtr, v1, v2, v3
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+10229, libc.VaList(bp+8, __ccgo_ts+10390))
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_properByteArrayType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr == libc.UintptrFromInt32(0) {
		if int32(TCL_ERROR) == _SetByteArrayFromAny(tls, libc.UintptrFromInt32(0), numBytes, objPtr) {
			return libc.UintptrFromInt32(0)
		}
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_properByteArrayType)) {
			v2 = objPtr + 32
		} else {
			v2 = libc.UintptrFromInt32(0)
		}
		irPtr = v2
	}
	byteArrayPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(irPtr))).Fptr1
	if numBytes > (*TByteArray)(unsafe.Pointer(byteArrayPtr)).Fallocated {
		if numBytes < 0 || libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))-libc.Int64FromUint64(uint64(libc.UintptrFromInt32(0)+16)) < numBytes {
			XTcl_Panic(tls, __ccgo_ts+10278, 0)
			v3 = libc.Uint64FromInt32(libc.Int32FromInt32(0))
		} else {
			v3 = uint64(libc.UintptrFromInt32(0)+16) + libc.Uint64FromInt64(numBytes)
		}
		byteArrayPtr = XTcl_Realloc(tls, byteArrayPtr, v3)
		(*TByteArray)(unsafe.Pointer(byteArrayPtr)).Fallocated = numBytes
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1 = byteArrayPtr
	}
	_isobjPtr = objPtr
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
	(*TByteArray)(unsafe.Pointer(byteArrayPtr)).Fused = numBytes
	return byteArrayPtr + 16
}

/*
 *----------------------------------------------------------------------
 *
 * MakeByteArray --
 *
 *	Generate a ByteArray internal rep from the string rep of objPtr.
 *	The generated byte sequence may have no more than limit bytes.
 *	A negative value for limit indicates no limit imposed. If
 *	boolean argument demandProper is true, then no byte sequence should
 *	be output to the caller (write NULL instead). When no bytes sequence
 *	is output and interp is not NULL, leave an error message and error
 *	code in interp explaining why a proper byte sequence could not be
 *	made.
 *
 * Results:
 *	Returns a boolean indicating whether the bytes generated (up to
 *	limit bytes) are a proper representation of (a limited prefix of)
 *	the string. Writes a pointer to the generated ByteArray to
 *	*byteArrayPtrPtr. If not NULL it needs to be released with Tcl_Free().
 *
 *----------------------------------------------------------------------
 */

func _MakeByteArray(tls *libc.TLS, interp uintptr, objPtr uintptr, limit TTcl_Size, demandProper int32, byteArrayPtrPtr uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var byteArrayPtr, dst, dstEnd, src, srcEnd, v1, v6 uintptr
	var count, proper int32
	var numBytes TTcl_Size
	var v2, v5 int64
	var v3 uint64
	var _ /* ch at bp+8 */ int32
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _ = byteArrayPtr, count, dst, dstEnd, numBytes, proper, src, srcEnd, v1, v2, v3, v5, v6
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, objPtr, bp)
	}
	src = v1
	if limit >= 0 && limit < *(*TTcl_Size)(unsafe.Pointer(bp)) {
		v2 = limit
	} else {
		v2 = *(*TTcl_Size)(unsafe.Pointer(bp))
	}
	numBytes = v2
	if numBytes < 0 || libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))-libc.Int64FromUint64(uint64(libc.UintptrFromInt32(0)+16)) < numBytes {
		XTcl_Panic(tls, __ccgo_ts+10278, 0)
		v3 = libc.Uint64FromInt32(libc.Int32FromInt32(0))
	} else {
		v3 = uint64(libc.UintptrFromInt32(0)+16) + libc.Uint64FromInt64(numBytes)
	}
	byteArrayPtr = XTcl_Alloc(tls, v3)
	dst = byteArrayPtr + 16
	dstEnd = dst + uintptr(numBytes)
	srcEnd = src + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))
	proper = int32(1)
	for {
		if !(src < srcEnd && dst < dstEnd) {
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) < int32(0x80) {
			*(*int32)(unsafe.Pointer(bp + 8)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))
			v5 = int64(libc.Int32FromInt32(1))
		} else {
			v5 = XTcl_UtfToUniChar(tls, src, bp+8)
		}
		count = int32(v5)
		if *(*int32)(unsafe.Pointer(bp + 8)) > int32(255) {
			proper = 0
			if demandProper != 0 {
				if interp != 0 {
					XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+10413, libc.VaList(bp+24, int64(dst)-T__predefined_ptrdiff_t(byteArrayPtr+16), src, *(*int32)(unsafe.Pointer(bp + 8)))))
					XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+10473, libc.UintptrFromInt32(0)))
				}
				XTclpFree(tls, byteArrayPtr)
				*(*uintptr)(unsafe.Pointer(byteArrayPtrPtr)) = libc.UintptrFromInt32(0)
				return proper
			}
		}
		src += uintptr(count)
		v6 = dst
		dst++
		*(*uint8)(unsafe.Pointer(v6)) = libc.Uint8FromInt32(*(*int32)(unsafe.Pointer(bp + 8)))
		goto _4
	_4:
	}
	(*TByteArray)(unsafe.Pointer(byteArrayPtr)).Fused = int64(dst) - T__predefined_ptrdiff_t(byteArrayPtr+16)
	(*TByteArray)(unsafe.Pointer(byteArrayPtr)).Fallocated = numBytes
	*(*uintptr)(unsafe.Pointer(byteArrayPtrPtr)) = byteArrayPtr
	return proper
}

func _TclNarrowToBytes(tls *libc.TLS, objPtr uintptr) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _isobjPtr, cachePtr, v1 uintptr
	var v2 bool
	var _ /* byteArrayPtr at bp+16 */ uintptr
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_, _, _, _ = _isobjPtr, cachePtr, v1, v2
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_properByteArrayType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	if libc.UintptrFromInt32(0) == v1 {
		if 0 == _MakeByteArray(tls, libc.UintptrFromInt32(0), objPtr, int64(-libc.Int32FromInt32(1)), 0, bp+16) {
			if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				objPtr = XTclThreadAllocObj(tls)
			} else {
				objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
			_isobjPtr = objPtr
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
				if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
			}
		}
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(bp))).Fptr1 = *(*uintptr)(unsafe.Pointer(bp + 16))
		XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&_properByteArrayType)), bp)
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount++
	return objPtr
}

/*
 *----------------------------------------------------------------------
 *
 * SetByteArrayFromAny --
 *
 *	Generate the ByteArray internal rep from the string rep.
 *
 * Results:
 *	Tcl return code indicating OK or ERROR.
 *
 * Side effects:
 *	A ByteArray struct may be stored as the internal rep of objPtr.
 *
 *----------------------------------------------------------------------
 */

func _SetByteArrayFromAny(tls *libc.TLS, interp uintptr, limit TTcl_Size, objPtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* The object to convert to type ByteArray. */
	var _ /* byteArrayPtr at bp+0 */ uintptr
	var _ /* ir at bp+8 */ TTcl_ObjInternalRep
	if 0 == _MakeByteArray(tls, interp, objPtr, limit, int32(1), bp) {
		return int32(TCL_ERROR)
	}
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp + 8))).Fptr1 = *(*uintptr)(unsafe.Pointer(bp))
	XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&_properByteArrayType)), bp+8)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * FreeByteArrayInternalRep --
 *
 *	Deallocate the storage associated with a ByteArray data object's
 *	internal representation.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Frees memory.
 *
 *----------------------------------------------------------------------
 */

func _FreeProperByteArrayInternalRep(tls *libc.TLS, objPtr uintptr) {
	/* Object with internal rep to free. */
	var v1 uintptr
	_ = v1
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_properByteArrayType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	XTclpFree(tls, (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(v1))).Fptr1)
}

/*
 *----------------------------------------------------------------------
 *
 * DupByteArrayInternalRep --
 *
 *	Initialize the internal representation of a ByteArray Tcl_Obj to a
 *	copy of the internal representation of an existing ByteArray object.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Allocates memory.
 *
 *----------------------------------------------------------------------
 */

func _DupProperByteArrayInternalRep(tls *libc.TLS, srcPtr uintptr, copyPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Object with internal rep to set. */
	var copyArrayPtr, srcArrayPtr, v1 uintptr
	var length TTcl_Size
	var v2 uint64
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_, _, _, _, _ = copyArrayPtr, length, srcArrayPtr, v1, v2
	if (*TTcl_Obj)(unsafe.Pointer(srcPtr)).FtypePtr == uintptr(unsafe.Pointer(&_properByteArrayType)) {
		v1 = srcPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	srcArrayPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(v1))).Fptr1
	length = (*TByteArray)(unsafe.Pointer(srcArrayPtr)).Fused
	if length < 0 || libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))-libc.Int64FromUint64(uint64(libc.UintptrFromInt32(0)+16)) < length {
		XTcl_Panic(tls, __ccgo_ts+10278, 0)
		v2 = libc.Uint64FromInt32(libc.Int32FromInt32(0))
	} else {
		v2 = uint64(libc.UintptrFromInt32(0)+16) + libc.Uint64FromInt64(length)
	}
	copyArrayPtr = XTcl_Alloc(tls, v2)
	(*TByteArray)(unsafe.Pointer(copyArrayPtr)).Fused = length
	(*TByteArray)(unsafe.Pointer(copyArrayPtr)).Fallocated = length
	libc.Xmemcpy(tls, copyArrayPtr+16, srcArrayPtr+16, libc.Uint64FromInt64(length))
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr1 = copyArrayPtr
	XTcl_StoreInternalRep(tls, copyPtr, uintptr(unsafe.Pointer(&_properByteArrayType)), bp)
}

/*
 *----------------------------------------------------------------------
 *
 * UpdateStringOfByteArray --
 *
 *	Update the string representation for a ByteArray data object.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The object's string is set to a valid string that results from the
 *	ByteArray-to-string conversion.
 *
 *----------------------------------------------------------------------
 */

func _UpdateStringOfByteArray(tls *libc.TLS, objPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* ByteArray object whose string rep to
	 * update. */
	var byteArrayPtr, dst, dst1, irPtr, src, v1 uintptr
	var i, length, size TTcl_Size
	var v3, v4, v5, v6 bool
	_, _, _, _, _, _, _, _, _, _, _, _, _ = byteArrayPtr, dst, dst1, i, irPtr, length, size, src, v1, v3, v4, v5, v6
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_properByteArrayType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	byteArrayPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(irPtr))).Fptr1
	src = byteArrayPtr + 16
	length = (*TByteArray)(unsafe.Pointer(byteArrayPtr)).Fused
	size = length
	/*
	 * How much space will string rep need?
	 */
	i = 0
	for {
		if !(i < length) {
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + uintptr(i)))) == 0 || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + uintptr(i)))) > int32(127) {
			size++
		}
		goto _2
	_2:
		;
		i++
	}
	if size == length {
		dst = XTcl_InitStringRep(tls, objPtr, src, libc.Uint64FromInt64(size))
		if v4 = size != 0; v4 {
			if v3 = dst != 0; !v3 {
				XTcl_Panic(tls, __ccgo_ts+10479, libc.VaList(bp+8, libc.Uint64FromInt64(size)))
			}
		}
		_ = v4 && (v3 || libc.Bool(libc.Int32FromInt32(1) != 0))
	} else {
		dst1 = XTcl_InitStringRep(tls, objPtr, libc.UintptrFromInt32(0), libc.Uint64FromInt64(size))
		if v6 = size != 0; v6 {
			if v5 = dst1 != 0; !v5 {
				XTcl_Panic(tls, __ccgo_ts+10479, libc.VaList(bp+8, libc.Uint64FromInt64(size)))
			}
		}
		_ = v6 && (v5 || libc.Bool(libc.Int32FromInt32(1) != 0))
		i = 0
		for {
			if !(i < length) {
				break
			}
			dst1 += uintptr(XTcl_UniCharToUtf(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + uintptr(i)))), dst1))
			goto _7
		_7:
			;
			i++
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclAppendBytesToByteArray --
 *
 *	This function appends an array of bytes to a byte array object. Note
 *	that the object *must* be unshared, and the array of bytes *must not*
 *	refer to the object being appended to.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Allocates enough memory for an array of bytes of the requested total
 *	size, or possibly larger. [Bug 2992970]
 *
 *----------------------------------------------------------------------
 */

func XTclAppendBytesToByteArray(tls *libc.TLS, objPtr uintptr, bytes uintptr, len1 TTcl_Size) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _isobjPtr, byteArrayPtr, irPtr, v1, v2 uintptr
	var needed TTcl_Size
	var _ /* newCapacity at bp+0 */ TTcl_Size
	_, _, _, _, _, _ = _isobjPtr, byteArrayPtr, irPtr, needed, v1, v2
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+10229, libc.VaList(bp+16, __ccgo_ts+10505))
	}
	if len1 < 0 {
		XTcl_Panic(tls, __ccgo_ts+10531, libc.VaList(bp+16, __ccgo_ts+10505))
	}
	if len1 == 0 {
		/*
		 * Append zero bytes is a no-op.
		 */
		return
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_properByteArrayType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr == libc.UintptrFromInt32(0) {
		if int32(TCL_ERROR) == _SetByteArrayFromAny(tls, libc.UintptrFromInt32(0), int64(-libc.Int32FromInt32(1)), objPtr) {
			XTcl_Panic(tls, __ccgo_ts+10589, 0)
		}
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_properByteArrayType)) {
			v2 = objPtr + 32
		} else {
			v2 = libc.UintptrFromInt32(0)
		}
		irPtr = v2
	}
	byteArrayPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(irPtr))).Fptr1
	/*
	 * If we need to, resize the allocated space in the byte array.
	 */
	if libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))-libc.Int64FromUint64(uint64(libc.UintptrFromInt32(0)+16))-(*TByteArray)(unsafe.Pointer(byteArrayPtr)).Fused < len1 {
		/* Will wrap around !! */
		XTcl_Panic(tls, __ccgo_ts+10630, 0)
	}
	needed = (*TByteArray)(unsafe.Pointer(byteArrayPtr)).Fused + len1
	if needed > (*TByteArray)(unsafe.Pointer(byteArrayPtr)).Fallocated {
		byteArrayPtr = XTclReallocElemsEx(tls, byteArrayPtr, needed, int64(1), libc.Int64FromUint64(uint64(libc.UintptrFromInt32(0)+16)), bp)
		(*TByteArray)(unsafe.Pointer(byteArrayPtr)).Fallocated = *(*TTcl_Size)(unsafe.Pointer(bp))
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1 = byteArrayPtr
	}
	if bytes != 0 {
		libc.Xmemcpy(tls, byteArrayPtr+16+uintptr((*TByteArray)(unsafe.Pointer(byteArrayPtr)).Fused), bytes, libc.Uint64FromInt64(len1))
	}
	*(*TTcl_Size)(unsafe.Pointer(byteArrayPtr)) += len1
	_isobjPtr = objPtr
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclInitBinaryCmd --
 *
 *	This function is called to create the "binary" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A command token for the new command.
 *
 * Side effects:
 *	Creates a new binary command as a mapped ensemble.
 *
 *----------------------------------------------------------------------
 */

func XTclInitBinaryCmd(tls *libc.TLS, interp uintptr) (r TTcl_Command) {
	var binaryEnsemble TTcl_Command
	_ = binaryEnsemble
	binaryEnsemble = XTclMakeEnsemble(tls, interp, __ccgo_ts+10664, uintptr(unsafe.Pointer(&_binaryMap)))
	XTclMakeEnsemble(tls, interp, __ccgo_ts+10671, uintptr(unsafe.Pointer(&_encodeMap)))
	XTclMakeEnsemble(tls, interp, __ccgo_ts+10685, uintptr(unsafe.Pointer(&_decodeMap)))
	return binaryEnsemble
}

/*
 *----------------------------------------------------------------------
 *
 * BinaryFormatCmd --
 *
 *	This procedure implements the "binary format" Tcl command.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _BinaryFormatCmd(tls *libc.TLS, dummy837 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(128)
	defer tls.Free(128) /* Argument objects. */
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, buffer, bytes, cachePtr, copy1, errorString, errorValue, last, last1, maxPos, resultPtr, str, v1, v35, v39, v40, v43, v44, v47, v48, v49, v50, v51, v54, v55, v58, v59, v60, v61, v67 uintptr
	var arg, c, value, v29, v31, v36, v37 int32
	var i, offset, size, v38, v42, v46, v53, v57, v66 TTcl_Size
	var pad uint8
	var v30, v32, v33, v63, v64 int64
	var v34 bool
	var _ /* buf at bp+85 */ [5]uint8
	var _ /* ch at bp+80 */ TTcl_UniChar
	var _ /* cmd at bp+0 */ uint8
	var _ /* count at bp+8 */ TTcl_Size
	var _ /* cursor at bp+32 */ uintptr
	var _ /* flags at bp+16 */ int32
	var _ /* format at bp+24 */ uintptr
	var _ /* length at bp+40 */ TTcl_Size
	var _ /* listc at bp+48 */ TTcl_Size
	var _ /* listc at bp+64 */ TTcl_Size
	var _ /* listv at bp+56 */ uintptr
	var _ /* listv at bp+72 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, arg, buffer, bytes, c, cachePtr, copy1, errorString, errorValue, i, last, last1, maxPos, offset, pad, resultPtr, size, str, value, v1, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v42, v43, v44, v46, v47, v48, v49, v50, v51, v53, v54, v55, v57, v58, v59, v60, v61, v63, v64, v66, v67 /* Index of next argument to consume. */
	value = 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            /* Pointer to current position in format
	 * string. */
	resultPtr = libc.UintptrFromInt32(0)
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+10699)
		return int32(TCL_ERROR)
	}
	/*
	 * To avoid copying the data, we format the string in two passes. The
	 * first pass computes the size of the output buffer. The second pass
	 * places the formatted data into the buffer.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	*(*uintptr)(unsafe.Pointer(bp + 24)) = v1
	arg = int32(2)
	offset = 0
	*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = 0
	for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24))))) != int32('\000') {
		str = *(*uintptr)(unsafe.Pointer(bp + 24))
		*(*int32)(unsafe.Pointer(bp + 16)) = 0
		if !(_GetFormatSpec(tls, bp+24, bp, bp+8, bp+16) != 0) {
			break
		}
		switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) {
		case int32('H'):
			goto _2
		case int32('h'):
			goto _3
		case int32('B'):
			goto _4
		case int32('b'):
			goto _5
		case int32('A'):
			goto _6
		case int32('a'):
			goto _7
		case int32('c'):
			goto _8
		case int32('S'):
			goto _9
		case int32('s'):
			goto _10
		case int32('t'):
			goto _11
		case int32('I'):
			goto _12
		case int32('i'):
			goto _13
		case int32('n'):
			goto _14
		case int32('W'):
			goto _15
		case int32('w'):
			goto _16
		case int32('m'):
			goto _17
		case int32('f'):
			goto _18
		case int32('R'):
			goto _19
		case int32('r'):
			goto _20
		case int32('d'):
			goto _21
		case int32('Q'):
			goto _22
		case int32('q'):
			goto _23
		case int32('x'):
			goto _24
		case int32('X'):
			goto _25
		case int32('@'):
			goto _26
		default:
			goto _27
		}
		goto _28
	_7:
		;
	_6:
		;
	_5:
		;
	_4:
		;
	_3:
		;
	_2:
		;
		/*
		 * For string-type specifiers, the count corresponds to the number
		 * of bytes in a single argument.
		 */
		if arg >= objc {
			goto badIndex
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(1)) {
			if XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)), bp+8) == libc.UintptrFromInt32(0) {
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = XTcl_GetCharLength(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)))
			}
		} else {
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(2)) {
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = int64(1)
			}
		}
		arg++
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32('a') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32('A') {
			offset += *(*TTcl_Size)(unsafe.Pointer(bp + 8))
		} else {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32('b') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32('B') {
				offset += (*(*TTcl_Size)(unsafe.Pointer(bp + 8)) + int64(7)) / int64(8)
			} else {
				offset += (*(*TTcl_Size)(unsafe.Pointer(bp + 8)) + int64(1)) / int64(2)
			}
		}
		goto _28
	_8:
		;
		size = int64(1)
		goto doNumbers
	_11:
		;
	_10:
		;
	_9:
		;
		size = int64(2)
		goto doNumbers
	_14:
		;
	_13:
		;
	_12:
		;
		size = int64(4)
		goto doNumbers
	_17:
		;
	_16:
		;
	_15:
		;
		size = int64(8)
		goto doNumbers
	_20:
		;
	_19:
		;
	_18:
		;
		size = int64(4)
		goto doNumbers
	_23:
		;
	_22:
		;
	_21:
		;
		size = int64(8)
		goto doNumbers
	doNumbers:
		;
		if arg >= objc {
			goto badIndex
		}
		/*
		 * For number-type specifiers, the count corresponds to the number
		 * of elements in the list stored in a single argument. If no
		 * count is specified, then the argument is taken as a single
		 * non-list value.
		 */
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(2)) {
			arg++
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = int64(1)
		} else {
			/*
			 * The macro evals its args more than once: avoid arg++
			 */
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)) + 32))).Fptr2 != 0 {
					v30 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)) + 32))).Fptr2)).FspanLength
				} else {
					v30 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)) + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp + 48)) = v30
				v29 = libc.Int32FromInt32(TCL_OK)
			} else {
				v29 = XTcl_ListObjLength(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)), bp+48)
			}
			if v29 != TCL_OK {
				return int32(TCL_ERROR)
			}
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(1)) {
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = *(*TTcl_Size)(unsafe.Pointer(bp + 48))
			} else {
				if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > *(*TTcl_Size)(unsafe.Pointer(bp + 48)) {
					XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+10722, int64(-int32(1))))
					return int32(TCL_ERROR)
				}
			}
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)) + 32))).Fptr2 != 0 {
					v32 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)) + 32))).Fptr2)).FspanStart
				} else {
					v32 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)) + 32))).Fptr1)).FfirstUsed
				}
				*(*uintptr)(unsafe.Pointer(bp + 56)) = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)) + 32))).Fptr1 + 40 + uintptr(v32)*8
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)) + 32))).Fptr2 != 0 {
					v33 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)) + 32))).Fptr2)).FspanLength
				} else {
					v33 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)) + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp + 48)) = v33
				v31 = libc.Int32FromInt32(TCL_OK)
			} else {
				v31 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)), bp+48, bp+56)
			}
			if v31 != TCL_OK {
				return int32(TCL_ERROR)
			}
			arg++
		}
		offset += *(*TTcl_Size)(unsafe.Pointer(bp + 8)) * size
		goto _28
	_24:
		;
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(1)) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+10770, int64(-int32(1))))
			return int32(TCL_ERROR)
		} else {
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(2)) {
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = int64(1)
			}
		}
		offset += *(*TTcl_Size)(unsafe.Pointer(bp + 8))
		goto _28
	_25:
		;
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(2)) {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = int64(1)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > offset || *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(1)) {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = offset
		}
		if offset > *(*TTcl_Size)(unsafe.Pointer(bp + 40)) {
			*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = offset
		}
		offset -= *(*TTcl_Size)(unsafe.Pointer(bp + 8))
		goto _28
	_26:
		;
		if offset > *(*TTcl_Size)(unsafe.Pointer(bp + 40)) {
			*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = offset
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(1)) {
			offset = *(*TTcl_Size)(unsafe.Pointer(bp + 40))
		} else {
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(2)) {
				goto badCount
			} else {
				offset = *(*TTcl_Size)(unsafe.Pointer(bp + 8))
			}
		}
		goto _28
	_27:
		;
		errorString = str
		goto badField
	_28:
	}
	if offset > *(*TTcl_Size)(unsafe.Pointer(bp + 40)) {
		*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = offset
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp + 40)) == 0 {
		return TCL_OK
	}
	/*
	 * Prepare the result object by preallocating the calculated number of
	 * bytes and filling with nulls.
	 */
	if v34 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v34 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v34 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultPtr = XTclThreadAllocObj(tls)
	} else {
		resultPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FtypePtr = libc.UintptrFromInt32(0)
	buffer = XTcl_SetByteArrayLength(tls, resultPtr, *(*TTcl_Size)(unsafe.Pointer(bp + 40)))
	libc.Xmemset(tls, buffer, 0, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 40))))
	/*
	 * Pack the data into the result object. Note that we can skip the error
	 * checking during this pass, since we have already parsed the string
	 * once.
	 */
	arg = int32(2)
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v35 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v35 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	*(*uintptr)(unsafe.Pointer(bp + 24)) = v35
	*(*uintptr)(unsafe.Pointer(bp + 32)) = buffer
	maxPos = *(*uintptr)(unsafe.Pointer(bp + 32))
	for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24))))) != 0 {
		*(*int32)(unsafe.Pointer(bp + 16)) = 0
		if !(_GetFormatSpec(tls, bp+24, bp, bp+8, bp+16) != 0) {
			break
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) != int32('@') {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) != int32('x') {
				arg++
			}
			continue
		}
		switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) {
		case int32('a'):
			fallthrough
		case int32('A'):
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32('a') {
				v36 = int32('\000')
			} else {
				v36 = int32(' ')
			}
			pad = libc.Uint8FromInt32(v36)
			v37 = arg
			arg++
			copy1 = _TclNarrowToBytes(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(v37)*8)))
			bytes = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), copy1, bp+40)
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(1)) {
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = *(*TTcl_Size)(unsafe.Pointer(bp + 40))
			} else {
				if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(2)) {
					*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = int64(1)
				}
			}
			if *(*TTcl_Size)(unsafe.Pointer(bp + 40)) >= *(*TTcl_Size)(unsafe.Pointer(bp + 8)) {
				libc.Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(bp + 32)), bytes, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8))))
			} else {
				libc.Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(bp + 32)), bytes, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 40))))
				libc.Xmemset(tls, *(*uintptr)(unsafe.Pointer(bp + 32))+uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 40))), libc.Int32FromUint8(pad), libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8))-*(*TTcl_Size)(unsafe.Pointer(bp + 40))))
			}
			*(*uintptr)(unsafe.Pointer(bp + 32)) += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
			_objPtr = copy1
			v39 = _objPtr
			v38 = *(*TTcl_Size)(unsafe.Pointer(v39))
			*(*TTcl_Size)(unsafe.Pointer(v39))--
			if v38 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		case int32('b'):
			fallthrough
		case int32('B'):
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)))).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)))).Flength
				v40 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)))).Fbytes
			} else {
				v40 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)), bp+40)
			}
			str = v40
			arg++
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(1)) {
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = *(*TTcl_Size)(unsafe.Pointer(bp + 40))
			} else {
				if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(2)) {
					*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = int64(1)
				}
			}
			last = *(*uintptr)(unsafe.Pointer(bp + 32)) + uintptr((*(*TTcl_Size)(unsafe.Pointer(bp + 8))+libc.Int64FromInt32(7))/libc.Int64FromInt32(8))
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > *(*TTcl_Size)(unsafe.Pointer(bp + 40)) {
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = *(*TTcl_Size)(unsafe.Pointer(bp + 40))
			}
			value = 0
			errorString = __ccgo_ts + 10664
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32('B') {
				offset = 0
				for {
					if !(offset < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) {
						break
					}
					value <<= int32(1)
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str + uintptr(offset)))) == int32('1') {
						value |= int32(1)
					} else {
						if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str + uintptr(offset)))) != int32('0') {
							errorValue = str
							_objPtr1 = resultPtr
							v43 = _objPtr1
							v42 = *(*TTcl_Size)(unsafe.Pointer(v43))
							*(*TTcl_Size)(unsafe.Pointer(v43))--
							if v42 <= int64(1) {
								XTclFreeObj(tls, _objPtr1)
							}
							goto badValue
						}
					}
					if (offset+int64(1))%int64(8) == 0 {
						v44 = *(*uintptr)(unsafe.Pointer(bp + 32))
						*(*uintptr)(unsafe.Pointer(bp + 32))++
						*(*uint8)(unsafe.Pointer(v44)) = libc.Uint8FromInt32(value)
						value = 0
					}
					goto _41
				_41:
					;
					offset++
				}
			} else {
				offset = 0
				for {
					if !(offset < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) {
						break
					}
					value >>= int32(1)
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str + uintptr(offset)))) == int32('1') {
						value |= int32(128)
					} else {
						if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str + uintptr(offset)))) != int32('0') {
							errorValue = str
							_objPtr2 = resultPtr
							v47 = _objPtr2
							v46 = *(*TTcl_Size)(unsafe.Pointer(v47))
							*(*TTcl_Size)(unsafe.Pointer(v47))--
							if v46 <= int64(1) {
								XTclFreeObj(tls, _objPtr2)
							}
							goto badValue
						}
					}
					if !((offset+libc.Int64FromInt32(1))%libc.Int64FromInt32(8) != 0) {
						v48 = *(*uintptr)(unsafe.Pointer(bp + 32))
						*(*uintptr)(unsafe.Pointer(bp + 32))++
						*(*uint8)(unsafe.Pointer(v48)) = libc.Uint8FromInt32(value)
						value = 0
					}
					goto _45
				_45:
					;
					offset++
				}
			}
			if offset%int64(8) != 0 {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32('B') {
					value = int32(int64(value) << (libc.Int64FromInt32(8) - offset%libc.Int64FromInt32(8)))
				} else {
					value = int32(int64(value) >> (libc.Int64FromInt32(8) - offset%libc.Int64FromInt32(8)))
				}
				v49 = *(*uintptr)(unsafe.Pointer(bp + 32))
				*(*uintptr)(unsafe.Pointer(bp + 32))++
				*(*uint8)(unsafe.Pointer(v49)) = libc.Uint8FromInt32(value)
			}
			for *(*uintptr)(unsafe.Pointer(bp + 32)) < last {
				v50 = *(*uintptr)(unsafe.Pointer(bp + 32))
				*(*uintptr)(unsafe.Pointer(bp + 32))++
				*(*uint8)(unsafe.Pointer(v50)) = uint8('\000')
			}
		case int32('h'):
			fallthrough
		case int32('H'):
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)))).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)))).Flength
				v51 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)))).Fbytes
			} else {
				v51 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)), bp+40)
			}
			str = v51
			arg++
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(1)) {
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = *(*TTcl_Size)(unsafe.Pointer(bp + 40))
			} else {
				if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(2)) {
					*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = int64(1)
				}
			}
			last1 = *(*uintptr)(unsafe.Pointer(bp + 32)) + uintptr((*(*TTcl_Size)(unsafe.Pointer(bp + 8))+libc.Int64FromInt32(1))/libc.Int64FromInt32(2))
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > *(*TTcl_Size)(unsafe.Pointer(bp + 40)) {
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = *(*TTcl_Size)(unsafe.Pointer(bp + 40))
			}
			value = 0
			errorString = __ccgo_ts + 10811
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32('H') {
				offset = 0
				for {
					if !(offset < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) {
						break
					}
					value <<= int32(4)
					if !(libc.Xisxdigit(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str + uintptr(offset))))) != 0) { /* INTL: digit */
						errorValue = str
						_objPtr3 = resultPtr
						v54 = _objPtr3
						v53 = *(*TTcl_Size)(unsafe.Pointer(v54))
						*(*TTcl_Size)(unsafe.Pointer(v54))--
						if v53 <= int64(1) {
							XTclFreeObj(tls, _objPtr3)
						}
						goto badValue
					}
					c = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str + uintptr(offset)))) - int32('0')
					if c > int32(9) {
						c += libc.Int32FromUint8('0') - libc.Int32FromUint8('A') + libc.Int32FromInt32(10)
					}
					if c > int32(16) {
						c += libc.Int32FromUint8('A') - libc.Int32FromUint8('a')
					}
					value |= c & int32(0xF)
					if offset%int64(2) != 0 {
						v55 = *(*uintptr)(unsafe.Pointer(bp + 32))
						*(*uintptr)(unsafe.Pointer(bp + 32))++
						*(*uint8)(unsafe.Pointer(v55)) = uint8(libc.Uint8FromInt32(value))
						value = 0
					}
					goto _52
				_52:
					;
					offset++
				}
			} else {
				offset = 0
				for {
					if !(offset < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) {
						break
					}
					value >>= int32(4)
					if !(libc.Xisxdigit(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str + uintptr(offset))))) != 0) { /* INTL: digit */
						errorValue = str
						_objPtr4 = resultPtr
						v58 = _objPtr4
						v57 = *(*TTcl_Size)(unsafe.Pointer(v58))
						*(*TTcl_Size)(unsafe.Pointer(v58))--
						if v57 <= int64(1) {
							XTclFreeObj(tls, _objPtr4)
						}
						goto badValue
					}
					c = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str + uintptr(offset)))) - int32('0')
					if c > int32(9) {
						c += libc.Int32FromUint8('0') - libc.Int32FromUint8('A') + libc.Int32FromInt32(10)
					}
					if c > int32(16) {
						c += libc.Int32FromUint8('A') - libc.Int32FromUint8('a')
					}
					value |= c << int32(4) & int32(0xF0)
					if offset%int64(2) != 0 {
						v59 = *(*uintptr)(unsafe.Pointer(bp + 32))
						*(*uintptr)(unsafe.Pointer(bp + 32))++
						*(*uint8)(unsafe.Pointer(v59)) = libc.Uint8FromInt32(value & libc.Int32FromInt32(0xFF))
						value = 0
					}
					goto _56
				_56:
					;
					offset++
				}
			}
			if offset%int64(2) != 0 {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32('H') {
					value <<= int32(4)
				} else {
					value >>= int32(4)
				}
				v60 = *(*uintptr)(unsafe.Pointer(bp + 32))
				*(*uintptr)(unsafe.Pointer(bp + 32))++
				*(*uint8)(unsafe.Pointer(v60)) = libc.Uint8FromInt32(value)
			}
			for *(*uintptr)(unsafe.Pointer(bp + 32)) < last1 {
				v61 = *(*uintptr)(unsafe.Pointer(bp + 32))
				*(*uintptr)(unsafe.Pointer(bp + 32))++
				*(*uint8)(unsafe.Pointer(v61)) = uint8('\000')
			}
		case int32('c'):
			fallthrough
		case int32('t'):
			fallthrough
		case int32('s'):
			fallthrough
		case int32('S'):
			fallthrough
		case int32('n'):
			fallthrough
		case int32('i'):
			fallthrough
		case int32('I'):
			fallthrough
		case int32('m'):
			fallthrough
		case int32('w'):
			fallthrough
		case int32('W'):
			fallthrough
		case int32('r'):
			fallthrough
		case int32('R'):
			fallthrough
		case int32('d'):
			fallthrough
		case int32('q'):
			fallthrough
		case int32('Q'):
			fallthrough
		case int32('f'):
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(2)) {
				/*
				 * Note that we are casting away the const-ness of objv, but
				 * this is safe since we aren't going to modify the array.
				 */
				*(*uintptr)(unsafe.Pointer(bp + 72)) = objv + uintptr(arg)*8
				*(*TTcl_Size)(unsafe.Pointer(bp + 64)) = int64(1)
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = int64(1)
			} else {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
					if (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)) + 32))).Fptr2 != 0 {
						v63 = (*TListSpan)(unsafe.Pointer((*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)) + 32))).Fptr2)).FspanStart
					} else {
						v63 = (*TListStore)(unsafe.Pointer((*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)) + 32))).Fptr1)).FfirstUsed
					}
					*(*uintptr)(unsafe.Pointer(bp + 72)) = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)) + 32))).Fptr1 + 40 + uintptr(v63)*8
					if (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)) + 32))).Fptr2 != 0 {
						v64 = (*TListSpan)(unsafe.Pointer((*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)) + 32))).Fptr2)).FspanLength
					} else {
						v64 = (*TListStore)(unsafe.Pointer((*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)) + 32))).Fptr1)).FnumUsed
					}
					*(*TTcl_Size)(unsafe.Pointer(bp + 64)) = v64
					_ = libc.Int32FromInt32(TCL_OK)
				} else {
					XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)), bp+64, bp+72)
				}
				if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(1)) {
					*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = *(*TTcl_Size)(unsafe.Pointer(bp + 64))
				}
			}
			arg++
			i = 0
			for {
				if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) {
					break
				}
				if _FormatNumber(tls, interp, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))), *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)) + uintptr(i)*8)), bp+32) != TCL_OK {
					_objPtr5 = resultPtr
					v67 = _objPtr5
					v66 = *(*TTcl_Size)(unsafe.Pointer(v67))
					*(*TTcl_Size)(unsafe.Pointer(v67))--
					if v66 <= int64(1) {
						XTclFreeObj(tls, _objPtr5)
					}
					return int32(TCL_ERROR)
				}
				goto _65
			_65:
				;
				i++
			}
		case int32('x'):
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(2)) {
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = int64(1)
			}
			libc.Xmemset(tls, *(*uintptr)(unsafe.Pointer(bp + 32)), 0, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8))))
			*(*uintptr)(unsafe.Pointer(bp + 32)) += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
		case int32('X'):
			if *(*uintptr)(unsafe.Pointer(bp + 32)) > maxPos {
				maxPos = *(*uintptr)(unsafe.Pointer(bp + 32))
			}
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(2)) {
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = int64(1)
			}
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(1)) || *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > int64(*(*uintptr)(unsafe.Pointer(bp + 32)))-int64(buffer) {
				*(*uintptr)(unsafe.Pointer(bp + 32)) = buffer
			} else {
				*(*uintptr)(unsafe.Pointer(bp + 32)) -= uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
			}
		case int32('@'):
			if *(*uintptr)(unsafe.Pointer(bp + 32)) > maxPos {
				maxPos = *(*uintptr)(unsafe.Pointer(bp + 32))
			}
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(1)) {
				*(*uintptr)(unsafe.Pointer(bp + 32)) = maxPos
			} else {
				*(*uintptr)(unsafe.Pointer(bp + 32)) = buffer + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
			}
			break
		}
	}
	XTcl_SetObjResult(tls, interp, resultPtr)
	return TCL_OK
	goto badValue
badValue:
	;
	XTcl_ResetResult(tls, interp)
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+10823, libc.VaList(bp+104, errorString, errorValue)))
	return int32(TCL_ERROR)
	goto badCount
badCount:
	;
	errorString = __ccgo_ts + 10863
	goto error
	goto badIndex
badIndex:
	;
	errorString = __ccgo_ts + 10901
	goto error
	goto badField
badField:
	;
	*(*TTcl_UniChar)(unsafe.Pointer(bp + 80)) = 0
	*(*[5]uint8)(unsafe.Pointer(bp + 85)) = [5]uint8{}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(errorString))) < int32(0x80) {
		*(*TTcl_UniChar)(unsafe.Pointer(bp + 80)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(errorString)))
		_ = libc.Int32FromInt32(1)
	} else {
		XTcl_UtfToUniChar(tls, errorString, bp+80)
	}
	(*(*[5]uint8)(unsafe.Pointer(bp + 85)))[XTcl_UniCharToUtf(tls, *(*TTcl_UniChar)(unsafe.Pointer(bp + 80)), bp+85)] = uint8('\000')
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+10948, libc.VaList(bp+104, bp+85)))
	return int32(TCL_ERROR)
	goto error
error:
	;
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, errorString, int64(-int32(1))))
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * BinaryScanCmd --
 *
 *	This procedure implements the "binary scan" Tcl command.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _BinaryScanCmd(tls *libc.TLS, dummy1349 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(192)
	defer tls.Free(192) /* Argument objects. */
	var arg, value, v36, v40 int32
	var buffer, cachePtr, cachePtr1, cachePtr2, dest, dest1, elementPtr, errorString, resultPtr, src, src1, src2, src3, str, valuePtr, v1, v32, v34, v35, v38, v39, v42, v44, v45, v47, v48 uintptr
	var i, offset, size TTcl_Size
	var v31, v41, v49 bool
	var _ /* buf at bp+160 */ [5]uint8
	var _ /* ch at bp+152 */ TTcl_UniChar
	var _ /* cmd at bp+0 */ uint8
	var _ /* count at bp+8 */ TTcl_Size
	var _ /* flags at bp+16 */ int32
	var _ /* format at bp+24 */ uintptr
	var _ /* length at bp+32 */ TTcl_Size
	var _ /* numberCacheHash at bp+40 */ TTcl_HashTable
	var _ /* numberCachePtr at bp+144 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = arg, buffer, cachePtr, cachePtr1, cachePtr2, dest, dest1, elementPtr, errorString, i, offset, resultPtr, size, src, src1, src2, src3, str, value, valuePtr, v1, v31, v32, v34, v35, v36, v38, v39, v40, v41, v42, v44, v45, v47, v48, v49 /* Index of next argument to consume. */
	value = 0                                                                                                                                                                                                                                                                                                                                              /* Pointer to current position in format
	 * string. */
	resultPtr = libc.UintptrFromInt32(0)
	*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = 0
	if objc < int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+10973)
		return int32(TCL_ERROR)
	}
	buffer = XTcl_GetBytesFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+32)
	if buffer == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	*(*uintptr)(unsafe.Pointer(bp + 144)) = bp + 40
	XTcl_InitHashTable(tls, *(*uintptr)(unsafe.Pointer(bp + 144)), int32(TCL_ONE_WORD_KEYS))
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
	}
	*(*uintptr)(unsafe.Pointer(bp + 24)) = v1
	arg = int32(3)
	offset = 0
	for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24))))) != int32('\000') {
		str = *(*uintptr)(unsafe.Pointer(bp + 24))
		*(*int32)(unsafe.Pointer(bp + 16)) = 0
		if !(_GetFormatSpec(tls, bp+24, bp, bp+8, bp+16) != 0) {
			goto done
		}
		switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) {
		case int32('C'):
			goto _2
		case int32('A'):
			goto _3
		case int32('a'):
			goto _4
		case int32('B'):
			goto _5
		case int32('b'):
			goto _6
		case int32('H'):
			goto _7
		case int32('h'):
			goto _8
		case int32('c'):
			goto _9
		case int32('S'):
			goto _10
		case int32('s'):
			goto _11
		case int32('t'):
			goto _12
		case int32('I'):
			goto _13
		case int32('i'):
			goto _14
		case int32('n'):
			goto _15
		case int32('W'):
			goto _16
		case int32('w'):
			goto _17
		case int32('m'):
			goto _18
		case int32('f'):
			goto _19
		case int32('R'):
			goto _20
		case int32('r'):
			goto _21
		case int32('d'):
			goto _22
		case int32('Q'):
			goto _23
		case int32('q'):
			goto _24
		case int32('x'):
			goto _25
		case int32('X'):
			goto _26
		case int32('@'):
			goto _27
		default:
			goto _28
		}
		goto _29
	_4:
		;
	_3:
		;
	_2:
		;
		if arg >= objc {
			_DeleteScanNumberCache(tls, *(*uintptr)(unsafe.Pointer(bp + 144)))
			goto badIndex
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(1)) {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = *(*TTcl_Size)(unsafe.Pointer(bp + 32)) - offset
		} else {
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(2)) {
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = int64(1)
			}
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > *(*TTcl_Size)(unsafe.Pointer(bp + 32))-offset {
				goto done
			}
		}
		src = buffer + uintptr(offset)
		size = *(*TTcl_Size)(unsafe.Pointer(bp + 8))
		/*
		 * Apply C string semantics or trim trailing
		 * nulls and spaces, if necessary.
		 */
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32('C') {
			i = 0
			for {
				if !(i < size) {
					break
				}
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + uintptr(i)))) == int32('\000') {
					size = i
					break
				}
				goto _30
			_30:
				;
				i++
			}
		} else {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32('A') {
				for size > 0 {
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + uintptr(size-int64(1))))) != int32('\000') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + uintptr(size-int64(1))))) != int32(' ') {
						break
					}
					size--
				}
			}
		}
		/*
		 * Have to do this #ifdef-fery because (as part of defining
		 * Tcl_NewByteArrayObj) we removed the #def that hides this stuff
		 * normally. If this code ever gets copied to another file, it
		 * should be changed back to the simpler version.
		 */
		valuePtr = XTcl_NewByteArrayObj(tls, src, size)
		resultPtr = XTcl_ObjSetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)), libc.UintptrFromInt32(0), valuePtr, int32(TCL_LEAVE_ERR_MSG))
		arg++
		if resultPtr == libc.UintptrFromInt32(0) {
			_DeleteScanNumberCache(tls, *(*uintptr)(unsafe.Pointer(bp + 144)))
			return int32(TCL_ERROR)
		}
		offset += *(*TTcl_Size)(unsafe.Pointer(bp + 8))
		goto _29
	_6:
		;
	_5:
		;
		if arg >= objc {
			_DeleteScanNumberCache(tls, *(*uintptr)(unsafe.Pointer(bp + 144)))
			goto badIndex
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(1)) {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*(*TTcl_Size)(unsafe.Pointer(bp + 32)) - offset) * int64(8)
		} else {
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(2)) {
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = int64(1)
			}
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > (*(*TTcl_Size)(unsafe.Pointer(bp + 32))-offset)*int64(8) {
				goto done
			}
		}
		src1 = buffer + uintptr(offset)
		if v31 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v31 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v31 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			valuePtr = XTclThreadAllocObj(tls)
		} else {
			valuePtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(valuePtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(valuePtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(valuePtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(valuePtr)).FtypePtr = libc.UintptrFromInt32(0)
		XTcl_SetObjLength(tls, valuePtr, *(*TTcl_Size)(unsafe.Pointer(bp + 8)))
		if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).Fbytes != 0 {
			v32 = (*TTcl_Obj)(unsafe.Pointer(valuePtr)).Fbytes
		} else {
			v32 = XTcl_GetStringFromObj(tls, valuePtr, libc.UintptrFromInt32(0))
		}
		dest = v32
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32('b') {
			i = 0
			for {
				if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) {
					break
				}
				if i%int64(8) != 0 {
					value >>= int32(1)
				} else {
					v34 = src1
					src1++
					value = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v34)))
				}
				v35 = dest
				dest++
				if value&int32(1) != 0 {
					v36 = int32('1')
				} else {
					v36 = int32('0')
				}
				*(*uint8)(unsafe.Pointer(v35)) = libc.Uint8FromInt32(v36)
				goto _33
			_33:
				;
				i++
			}
		} else {
			i = 0
			for {
				if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) {
					break
				}
				if i%int64(8) != 0 {
					value <<= int32(1)
				} else {
					v38 = src1
					src1++
					value = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v38)))
				}
				v39 = dest
				dest++
				if value&int32(0x80) != 0 {
					v40 = int32('1')
				} else {
					v40 = int32('0')
				}
				*(*uint8)(unsafe.Pointer(v39)) = libc.Uint8FromInt32(v40)
				goto _37
			_37:
				;
				i++
			}
		}
		resultPtr = XTcl_ObjSetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)), libc.UintptrFromInt32(0), valuePtr, int32(TCL_LEAVE_ERR_MSG))
		arg++
		if resultPtr == libc.UintptrFromInt32(0) {
			_DeleteScanNumberCache(tls, *(*uintptr)(unsafe.Pointer(bp + 144)))
			return int32(TCL_ERROR)
		}
		offset += (*(*TTcl_Size)(unsafe.Pointer(bp + 8)) + int64(7)) / int64(8)
		goto _29
	_8:
		;
	_7:
		;
		if arg >= objc {
			_DeleteScanNumberCache(tls, *(*uintptr)(unsafe.Pointer(bp + 144)))
			goto badIndex
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(1)) {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*(*TTcl_Size)(unsafe.Pointer(bp + 32)) - offset) * int64(2)
		} else {
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(2)) {
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = int64(1)
			}
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > (*(*TTcl_Size)(unsafe.Pointer(bp + 32))-offset)*int64(2) {
				goto done
			}
		}
		src2 = buffer + uintptr(offset)
		if v41 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v41 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v41 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			valuePtr = XTclThreadAllocObj(tls)
		} else {
			valuePtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(valuePtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(valuePtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(valuePtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(valuePtr)).FtypePtr = libc.UintptrFromInt32(0)
		XTcl_SetObjLength(tls, valuePtr, *(*TTcl_Size)(unsafe.Pointer(bp + 8)))
		if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).Fbytes != 0 {
			v42 = (*TTcl_Obj)(unsafe.Pointer(valuePtr)).Fbytes
		} else {
			v42 = XTcl_GetStringFromObj(tls, valuePtr, libc.UintptrFromInt32(0))
		}
		dest1 = v42
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32('h') {
			i = 0
			for {
				if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) {
					break
				}
				if i%int64(2) != 0 {
					value >>= int32(4)
				} else {
					v44 = src2
					src2++
					value = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v44)))
				}
				v45 = dest1
				dest1++
				*(*uint8)(unsafe.Pointer(v45)) = _hexdigit[value&int32(0xF)]
				goto _43
			_43:
				;
				i++
			}
		} else {
			i = 0
			for {
				if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) {
					break
				}
				if i%int64(2) != 0 {
					value <<= int32(4)
				} else {
					v47 = src2
					src2++
					value = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v47)))
				}
				v48 = dest1
				dest1++
				*(*uint8)(unsafe.Pointer(v48)) = _hexdigit[value>>int32(4)&int32(0xF)]
				goto _46
			_46:
				;
				i++
			}
		}
		resultPtr = XTcl_ObjSetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)), libc.UintptrFromInt32(0), valuePtr, int32(TCL_LEAVE_ERR_MSG))
		arg++
		if resultPtr == libc.UintptrFromInt32(0) {
			_DeleteScanNumberCache(tls, *(*uintptr)(unsafe.Pointer(bp + 144)))
			return int32(TCL_ERROR)
		}
		offset += (*(*TTcl_Size)(unsafe.Pointer(bp + 8)) + int64(1)) / int64(2)
		goto _29
	_9:
		;
		size = int64(1)
		goto scanNumber
	_12:
		;
	_11:
		;
	_10:
		;
		size = int64(2)
		goto scanNumber
	_15:
		;
	_14:
		;
	_13:
		;
		size = int64(4)
		goto scanNumber
	_18:
		;
	_17:
		;
	_16:
		;
		size = int64(8)
		goto scanNumber
	_21:
		;
	_20:
		;
	_19:
		;
		size = int64(4)
		goto scanNumber
	_24:
		;
	_23:
		;
	_22:
		;
		size = int64(8)
		/* fall through */
		goto scanNumber
	scanNumber:
		;
		if arg >= objc {
			_DeleteScanNumberCache(tls, *(*uintptr)(unsafe.Pointer(bp + 144)))
			goto badIndex
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(2)) {
			if *(*TTcl_Size)(unsafe.Pointer(bp + 32)) < size+offset {
				goto done
			}
			valuePtr = _ScanNumber(tls, buffer+uintptr(offset), libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))), *(*int32)(unsafe.Pointer(bp + 16)), bp+144)
			offset += size
		} else {
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(1)) {
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*(*TTcl_Size)(unsafe.Pointer(bp + 32)) - offset) / size
			}
			if *(*TTcl_Size)(unsafe.Pointer(bp + 32))-offset < *(*TTcl_Size)(unsafe.Pointer(bp + 8))*size {
				goto done
			}
			if v49 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v49 {
				cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v49 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
				valuePtr = XTclThreadAllocObj(tls)
			} else {
				valuePtr = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(valuePtr + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(valuePtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(valuePtr)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(valuePtr)).FtypePtr = libc.UintptrFromInt32(0)
			src3 = buffer + uintptr(offset)
			i = 0
			for {
				if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) {
					break
				}
				elementPtr = _ScanNumber(tls, src3, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))), *(*int32)(unsafe.Pointer(bp + 16)), bp+144)
				src3 += uintptr(size)
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), valuePtr, elementPtr)
				goto _50
			_50:
				;
				i++
			}
			offset += *(*TTcl_Size)(unsafe.Pointer(bp + 8)) * size
		}
		resultPtr = XTcl_ObjSetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(arg)*8)), libc.UintptrFromInt32(0), valuePtr, int32(TCL_LEAVE_ERR_MSG))
		arg++
		if resultPtr == libc.UintptrFromInt32(0) {
			_DeleteScanNumberCache(tls, *(*uintptr)(unsafe.Pointer(bp + 144)))
			return int32(TCL_ERROR)
		}
		goto _29
	_25:
		;
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(2)) {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = int64(1)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(1)) || *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > *(*TTcl_Size)(unsafe.Pointer(bp + 32))-offset {
			offset = *(*TTcl_Size)(unsafe.Pointer(bp + 32))
		} else {
			offset += *(*TTcl_Size)(unsafe.Pointer(bp + 8))
		}
		goto _29
	_26:
		;
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(2)) {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = int64(1)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(1)) || *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > offset {
			offset = 0
		} else {
			offset -= *(*TTcl_Size)(unsafe.Pointer(bp + 8))
		}
		goto _29
	_27:
		;
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(2)) {
			_DeleteScanNumberCache(tls, *(*uintptr)(unsafe.Pointer(bp + 144)))
			goto badCount
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(-int32(1)) || *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > *(*TTcl_Size)(unsafe.Pointer(bp + 32)) {
			offset = *(*TTcl_Size)(unsafe.Pointer(bp + 32))
		} else {
			offset = *(*TTcl_Size)(unsafe.Pointer(bp + 8))
		}
		goto _29
	_28:
		;
		_DeleteScanNumberCache(tls, *(*uintptr)(unsafe.Pointer(bp + 144)))
		errorString = str
		goto badField
	_29:
	}
	/*
	 * Set the result to the last position of the cursor.
	 */
	goto done
done:
	;
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, int64(arg-int32(3))))
	_DeleteScanNumberCache(tls, *(*uintptr)(unsafe.Pointer(bp + 144)))
	return TCL_OK
	goto badCount
badCount:
	;
	errorString = __ccgo_ts + 10863
	goto error
	goto badIndex
badIndex:
	;
	errorString = __ccgo_ts + 10901
	goto error
	goto badField
badField:
	;
	*(*TTcl_UniChar)(unsafe.Pointer(bp + 152)) = 0
	*(*[5]uint8)(unsafe.Pointer(bp + 160)) = [5]uint8{}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(errorString))) < int32(0x80) {
		*(*TTcl_UniChar)(unsafe.Pointer(bp + 152)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(errorString)))
		_ = libc.Int32FromInt32(1)
	} else {
		XTcl_UtfToUniChar(tls, errorString, bp+152)
	}
	(*(*[5]uint8)(unsafe.Pointer(bp + 160)))[XTcl_UniCharToUtf(tls, *(*TTcl_UniChar)(unsafe.Pointer(bp + 152)), bp+160)] = uint8('\000')
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+10948, libc.VaList(bp+176, bp+160)))
	return int32(TCL_ERROR)
	goto error
error:
	;
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, errorString, int64(-int32(1))))
	return int32(TCL_ERROR)
}

var _hexdigit = [17]uint8{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}

/*
 *----------------------------------------------------------------------
 *
 * GetFormatSpec --
 *
 *	This function parses the format strings used in the binary format and
 *	scan commands.
 *
 * Results:
 *	Moves the formatPtr to the start of the next command. Returns the
 *	current command character and count in cmdPtr and countPtr. The count
 *	is set to BINARY_ALL if the count character was '*' or BINARY_NOCOUNT
 *	if no count was specified. Returns 1 on success, or 0 if the string
 *	did not have a format specifier.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _GetFormatSpec(tls *libc.TLS, formatPtr uintptr, cmdPtr uintptr, countPtr uintptr, flagsPtr uintptr) (r int32) {
	/* Pointer to field flags */
	var count uint64
	_ = count
	/*
	 * Skip any leading blanks.
	 */
	for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(formatPtr))))) == int32(' ') {
		*(*uintptr)(unsafe.Pointer(formatPtr))++
	}
	/*
	 * The string was empty, except for whitespace, so fail.
	 */
	if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(formatPtr)))) != 0) {
		return 0
	}
	/*
	 * Extract the command character and any trailing digits or '*'.
	 */
	*(*uint8)(unsafe.Pointer(cmdPtr)) = *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(formatPtr))))
	*(*uintptr)(unsafe.Pointer(formatPtr))++
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(formatPtr))))) == int32('u') {
		*(*uintptr)(unsafe.Pointer(formatPtr))++
		*(*int32)(unsafe.Pointer(flagsPtr)) |= int32(BINARY_UNSIGNED)
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(formatPtr))))) == int32('*') {
		*(*uintptr)(unsafe.Pointer(formatPtr))++
		*(*TTcl_Size)(unsafe.Pointer(countPtr)) = int64(-int32(1))
	} else {
		if libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(formatPtr)))))-uint32('0') < uint32(10)) != 0 {
			*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = 0
			count = libc.Xstrtoull(tls, *(*uintptr)(unsafe.Pointer(formatPtr)), formatPtr, int32(10))
			if *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) != 0 || count > libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) {
				*(*TTcl_Size)(unsafe.Pointer(countPtr)) = libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
			} else {
				*(*TTcl_Size)(unsafe.Pointer(countPtr)) = libc.Int64FromUint64(count)
			}
		} else {
			*(*TTcl_Size)(unsafe.Pointer(countPtr)) = int64(-int32(2))
		}
	}
	return int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * NeedReversing --
 *
 *	This routine determines, if bytes of a number need to be re-ordered,
 *	and returns a numeric code indicating the re-ordering to be done.
 *	This depends on the endianness of the machine and the desired format.
 *	It is in effect a table (whose contents depend on the endianness of
 *	the system) describing whether a value needs reversing or not. Anyone
 *	porting the code to a big-endian platform should take care to make
 *	sure that they define WORDS_BIGENDIAN though this is already done by
 *	configure for the Unix build; little-endian platforms (including
 *	Windows) don't need to do anything.
 *
 * Results:
 *	0	No re-ordering needed.
 *	1	Reverse the bytes:	01234567 <-> 76543210 (little to big)
 *	2	Apply this re-ordering: 01234567 <-> 45670123 (Nokia to little)
 *	3	Apply this re-ordering: 01234567 <-> 32107654 (Nokia to big)
 *
 * Side effects:
 *	None
 *
 *----------------------------------------------------------------------
 */

func _NeedReversing(tls *libc.TLS, format int32) (r int32) {
	switch format {
	/* native floats and doubles: never reverse */
	case int32('d'):
		fallthrough
	case int32('f'):
		/* big endian ints: never reverse */
		fallthrough
	case int32('I'):
		fallthrough
	case int32('S'):
		fallthrough
	case int32('W'):
		/* native ints: reverse if we're little-endian */
		fallthrough
	case int32('n'):
		fallthrough
	case int32('t'):
		fallthrough
	case int32('m'):
		/* f: reverse if we're little-endian */
		fallthrough
	case int32('Q'):
		fallthrough
	case int32('R'):
		return 0
		/* small endian floats: reverse if we're big-endian */
		fallthrough
	case int32('q'):
		fallthrough
	case int32('r'):
		/* small endian ints: always reverse */
		fallthrough
	case int32('i'):
		fallthrough
	case int32('s'):
		fallthrough
	case int32('w'):
		return int32(1)
	}
	XTcl_Panic(tls, __ccgo_ts+11006, 0)
	return 0
}

/*
 *----------------------------------------------------------------------
 *
 * CopyNumber --
 *
 *	This routine is called by FormatNumber and ScanNumber to copy a
 *	floating-point number. If required, bytes are reversed while copying.
 *	The behaviour is only fully defined when used with IEEE float and
 *	double values (guaranteed to be 4 and 8 bytes long, respectively.)
 *
 * Results:
 *	None
 *
 * Side effects:
 *	Copies length bytes
 *
 *----------------------------------------------------------------------
 */

func _CopyNumber(tls *libc.TLS, from uintptr, to uintptr, length Tsize_t, type1 int32) {
	/* What type of thing are we copying? */
	var fromPtr, fromPtr1, fromPtr2, toPtr, toPtr1, toPtr2 uintptr
	_, _, _, _, _, _ = fromPtr, fromPtr1, fromPtr2, toPtr, toPtr1, toPtr2
	switch _NeedReversing(tls, type1) {
	case 0:
		libc.Xmemcpy(tls, to, from, length)
	case int32(1):
		fromPtr = from
		toPtr = to
		switch length {
		case uint64(4):
			*(*uint8)(unsafe.Pointer(toPtr)) = *(*uint8)(unsafe.Pointer(fromPtr + 3))
			*(*uint8)(unsafe.Pointer(toPtr + 1)) = *(*uint8)(unsafe.Pointer(fromPtr + 2))
			*(*uint8)(unsafe.Pointer(toPtr + 2)) = *(*uint8)(unsafe.Pointer(fromPtr + 1))
			*(*uint8)(unsafe.Pointer(toPtr + 3)) = *(*uint8)(unsafe.Pointer(fromPtr))
		case uint64(8):
			*(*uint8)(unsafe.Pointer(toPtr)) = *(*uint8)(unsafe.Pointer(fromPtr + 7))
			*(*uint8)(unsafe.Pointer(toPtr + 1)) = *(*uint8)(unsafe.Pointer(fromPtr + 6))
			*(*uint8)(unsafe.Pointer(toPtr + 2)) = *(*uint8)(unsafe.Pointer(fromPtr + 5))
			*(*uint8)(unsafe.Pointer(toPtr + 3)) = *(*uint8)(unsafe.Pointer(fromPtr + 4))
			*(*uint8)(unsafe.Pointer(toPtr + 4)) = *(*uint8)(unsafe.Pointer(fromPtr + 3))
			*(*uint8)(unsafe.Pointer(toPtr + 5)) = *(*uint8)(unsafe.Pointer(fromPtr + 2))
			*(*uint8)(unsafe.Pointer(toPtr + 6)) = *(*uint8)(unsafe.Pointer(fromPtr + 1))
			*(*uint8)(unsafe.Pointer(toPtr + 7)) = *(*uint8)(unsafe.Pointer(fromPtr))
			break
		}
	case int32(2):
		fromPtr1 = from
		toPtr1 = to
		*(*uint8)(unsafe.Pointer(toPtr1)) = *(*uint8)(unsafe.Pointer(fromPtr1 + 4))
		*(*uint8)(unsafe.Pointer(toPtr1 + 1)) = *(*uint8)(unsafe.Pointer(fromPtr1 + 5))
		*(*uint8)(unsafe.Pointer(toPtr1 + 2)) = *(*uint8)(unsafe.Pointer(fromPtr1 + 6))
		*(*uint8)(unsafe.Pointer(toPtr1 + 3)) = *(*uint8)(unsafe.Pointer(fromPtr1 + 7))
		*(*uint8)(unsafe.Pointer(toPtr1 + 4)) = *(*uint8)(unsafe.Pointer(fromPtr1))
		*(*uint8)(unsafe.Pointer(toPtr1 + 5)) = *(*uint8)(unsafe.Pointer(fromPtr1 + 1))
		*(*uint8)(unsafe.Pointer(toPtr1 + 6)) = *(*uint8)(unsafe.Pointer(fromPtr1 + 2))
		*(*uint8)(unsafe.Pointer(toPtr1 + 7)) = *(*uint8)(unsafe.Pointer(fromPtr1 + 3))
	case int32(3):
		fromPtr2 = from
		toPtr2 = to
		*(*uint8)(unsafe.Pointer(toPtr2)) = *(*uint8)(unsafe.Pointer(fromPtr2 + 3))
		*(*uint8)(unsafe.Pointer(toPtr2 + 1)) = *(*uint8)(unsafe.Pointer(fromPtr2 + 2))
		*(*uint8)(unsafe.Pointer(toPtr2 + 2)) = *(*uint8)(unsafe.Pointer(fromPtr2 + 1))
		*(*uint8)(unsafe.Pointer(toPtr2 + 3)) = *(*uint8)(unsafe.Pointer(fromPtr2))
		*(*uint8)(unsafe.Pointer(toPtr2 + 4)) = *(*uint8)(unsafe.Pointer(fromPtr2 + 7))
		*(*uint8)(unsafe.Pointer(toPtr2 + 5)) = *(*uint8)(unsafe.Pointer(fromPtr2 + 6))
		*(*uint8)(unsafe.Pointer(toPtr2 + 6)) = *(*uint8)(unsafe.Pointer(fromPtr2 + 5))
		*(*uint8)(unsafe.Pointer(toPtr2 + 7)) = *(*uint8)(unsafe.Pointer(fromPtr2 + 4))
		break
	}
}

/*
 *----------------------------------------------------------------------
 *
 * FormatNumber --
 *
 *	This routine is called by Tcl_BinaryObjCmd to format a number into a
 *	location pointed at by cursor.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Moves the cursor to the next location to be written into.
 *
 *----------------------------------------------------------------------
 */

func _FormatNumber(tls *libc.TLS, interp uintptr, type1 int32, src uintptr, cursorPtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Pointer to index into destination buffer. */
	var irPtr, irPtr1, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v7, v8, v9 uintptr
	var v3, v4 float32
	var _ /* dvalue at bp+0 */ float64
	var _ /* fvalue at bp+16 */ float32
	var _ /* wvalue at bp+8 */ TTcl_WideInt
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = irPtr, irPtr1, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v7, v8, v9
	switch type1 {
	case int32('d'):
		fallthrough
	case int32('q'):
		fallthrough
	case int32('Q'):
		/*
		 * Double-precision floating point values. Tcl_GetDoubleFromObj
		 * returns TCL_ERROR for NaN, but we can check by comparing the
		 * object's type pointer.
		 */
		if XTcl_GetDoubleFromObj(tls, interp, src, bp) != TCL_OK {
			if (*TTcl_Obj)(unsafe.Pointer(src)).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
				v1 = src + 32
			} else {
				v1 = libc.UintptrFromInt32(0)
			}
			irPtr = v1
			if irPtr == libc.UintptrFromInt32(0) {
				return int32(TCL_ERROR)
			}
			*(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(irPtr))
		}
		_CopyNumber(tls, bp, *(*uintptr)(unsafe.Pointer(cursorPtr)), uint64(8), type1)
		*(*uintptr)(unsafe.Pointer(cursorPtr)) += uintptr(8)
		return TCL_OK
	case int32('f'):
		fallthrough
	case int32('r'):
		fallthrough
	case int32('R'):
		/*
		 * Single-precision floating point values. Tcl_GetDoubleFromObj
		 * returns TCL_ERROR for NaN, but we can check by comparing the
		 * object's type pointer.
		 */
		if XTcl_GetDoubleFromObj(tls, interp, src, bp) != TCL_OK {
			if (*TTcl_Obj)(unsafe.Pointer(src)).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
				v2 = src + 32
			} else {
				v2 = libc.UintptrFromInt32(0)
			}
			irPtr1 = v2
			if irPtr1 == libc.UintptrFromInt32(0) {
				return int32(TCL_ERROR)
			}
			*(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(irPtr1))
		}
		/*
		 * Because some compilers will generate floating point exceptions on
		 * an overflow cast (e.g. Borland), we restrict the values to the
		 * valid range for float.
		 */
		if libc.Xfabs(tls, *(*float64)(unsafe.Pointer(bp))) > libc.Float64FromFloat32(3.4028234663852886e+38) {
			if libc.Xfabs(tls, *(*float64)(unsafe.Pointer(bp))) > libc.Float64FromFloat32(3.4028234663852886e+38)+libc.Xpow(tls, libc.Float64FromInt32(2), float64(libc.Int32FromInt32(FLT_MAX_EXP)-libc.Int32FromInt32(FLT_MANT_DIG)-libc.Int32FromInt32(1))) {
				if *(*float64)(unsafe.Pointer(bp)) >= float64(0) {
					v3 = libc.X__builtin_inff(tls)
				} else {
					v3 = -libc.X__builtin_inff(tls)
				}
				*(*float32)(unsafe.Pointer(bp + 16)) = v3 // c99
			} else {
				if *(*float64)(unsafe.Pointer(bp)) >= float64(0) {
					v4 = libc.Float32FromFloat32(3.4028234663852886e+38)
				} else {
					v4 = -libc.Float32FromFloat32(3.4028234663852886e+38)
				}
				*(*float32)(unsafe.Pointer(bp + 16)) = v4
			}
		} else {
			*(*float32)(unsafe.Pointer(bp + 16)) = float32(*(*float64)(unsafe.Pointer(bp)))
		}
		_CopyNumber(tls, bp+16, *(*uintptr)(unsafe.Pointer(cursorPtr)), uint64(4), type1)
		*(*uintptr)(unsafe.Pointer(cursorPtr)) += uintptr(4)
		return TCL_OK
		/*
		 * 64-bit integer values.
		 */
		fallthrough
	case int32('w'):
		fallthrough
	case int32('W'):
		fallthrough
	case int32('m'):
		if XTclGetWideBitsFromObj(tls, interp, src, bp+8) != TCL_OK {
			return int32(TCL_ERROR)
		}
		if _NeedReversing(tls, type1) != 0 {
			v6 = cursorPtr
			v5 = *(*uintptr)(unsafe.Pointer(v6))
			*(*uintptr)(unsafe.Pointer(v6))++
			*(*uint8)(unsafe.Pointer(v5)) = libc.Uint8FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)))
			v8 = cursorPtr
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) >> libc.Int32FromInt32(8))
			v10 = cursorPtr
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = libc.Uint8FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) >> libc.Int32FromInt32(16))
			v12 = cursorPtr
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = libc.Uint8FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) >> libc.Int32FromInt32(24))
			v14 = cursorPtr
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = libc.Uint8FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) >> libc.Int32FromInt32(32))
			v16 = cursorPtr
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = libc.Uint8FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) >> libc.Int32FromInt32(40))
			v18 = cursorPtr
			v17 = *(*uintptr)(unsafe.Pointer(v18))
			*(*uintptr)(unsafe.Pointer(v18))++
			*(*uint8)(unsafe.Pointer(v17)) = libc.Uint8FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) >> libc.Int32FromInt32(48))
			v20 = cursorPtr
			v19 = *(*uintptr)(unsafe.Pointer(v20))
			*(*uintptr)(unsafe.Pointer(v20))++
			*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) >> libc.Int32FromInt32(56))
		} else {
			v22 = cursorPtr
			v21 = *(*uintptr)(unsafe.Pointer(v22))
			*(*uintptr)(unsafe.Pointer(v22))++
			*(*uint8)(unsafe.Pointer(v21)) = libc.Uint8FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) >> libc.Int32FromInt32(56))
			v24 = cursorPtr
			v23 = *(*uintptr)(unsafe.Pointer(v24))
			*(*uintptr)(unsafe.Pointer(v24))++
			*(*uint8)(unsafe.Pointer(v23)) = libc.Uint8FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) >> libc.Int32FromInt32(48))
			v26 = cursorPtr
			v25 = *(*uintptr)(unsafe.Pointer(v26))
			*(*uintptr)(unsafe.Pointer(v26))++
			*(*uint8)(unsafe.Pointer(v25)) = libc.Uint8FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) >> libc.Int32FromInt32(40))
			v28 = cursorPtr
			v27 = *(*uintptr)(unsafe.Pointer(v28))
			*(*uintptr)(unsafe.Pointer(v28))++
			*(*uint8)(unsafe.Pointer(v27)) = libc.Uint8FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) >> libc.Int32FromInt32(32))
			v30 = cursorPtr
			v29 = *(*uintptr)(unsafe.Pointer(v30))
			*(*uintptr)(unsafe.Pointer(v30))++
			*(*uint8)(unsafe.Pointer(v29)) = libc.Uint8FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) >> libc.Int32FromInt32(24))
			v32 = cursorPtr
			v31 = *(*uintptr)(unsafe.Pointer(v32))
			*(*uintptr)(unsafe.Pointer(v32))++
			*(*uint8)(unsafe.Pointer(v31)) = libc.Uint8FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) >> libc.Int32FromInt32(16))
			v34 = cursorPtr
			v33 = *(*uintptr)(unsafe.Pointer(v34))
			*(*uintptr)(unsafe.Pointer(v34))++
			*(*uint8)(unsafe.Pointer(v33)) = libc.Uint8FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) >> libc.Int32FromInt32(8))
			v36 = cursorPtr
			v35 = *(*uintptr)(unsafe.Pointer(v36))
			*(*uintptr)(unsafe.Pointer(v36))++
			*(*uint8)(unsafe.Pointer(v35)) = libc.Uint8FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)))
		}
		return TCL_OK
		/*
		 * 32-bit integer values.
		 */
		fallthrough
	case int32('i'):
		fallthrough
	case int32('I'):
		fallthrough
	case int32('n'):
		if XTclGetWideBitsFromObj(tls, interp, src, bp+8) != TCL_OK {
			return int32(TCL_ERROR)
		}
		if _NeedReversing(tls, type1) != 0 {
			v38 = cursorPtr
			v37 = *(*uintptr)(unsafe.Pointer(v38))
			*(*uintptr)(unsafe.Pointer(v38))++
			*(*uint8)(unsafe.Pointer(v37)) = libc.Uint8FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)))
			v40 = cursorPtr
			v39 = *(*uintptr)(unsafe.Pointer(v40))
			*(*uintptr)(unsafe.Pointer(v40))++
			*(*uint8)(unsafe.Pointer(v39)) = libc.Uint8FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) >> libc.Int32FromInt32(8))
			v42 = cursorPtr
			v41 = *(*uintptr)(unsafe.Pointer(v42))
			*(*uintptr)(unsafe.Pointer(v42))++
			*(*uint8)(unsafe.Pointer(v41)) = libc.Uint8FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) >> libc.Int32FromInt32(16))
			v44 = cursorPtr
			v43 = *(*uintptr)(unsafe.Pointer(v44))
			*(*uintptr)(unsafe.Pointer(v44))++
			*(*uint8)(unsafe.Pointer(v43)) = libc.Uint8FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) >> libc.Int32FromInt32(24))
		} else {
			v46 = cursorPtr
			v45 = *(*uintptr)(unsafe.Pointer(v46))
			*(*uintptr)(unsafe.Pointer(v46))++
			*(*uint8)(unsafe.Pointer(v45)) = libc.Uint8FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) >> libc.Int32FromInt32(24))
			v48 = cursorPtr
			v47 = *(*uintptr)(unsafe.Pointer(v48))
			*(*uintptr)(unsafe.Pointer(v48))++
			*(*uint8)(unsafe.Pointer(v47)) = libc.Uint8FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) >> libc.Int32FromInt32(16))
			v50 = cursorPtr
			v49 = *(*uintptr)(unsafe.Pointer(v50))
			*(*uintptr)(unsafe.Pointer(v50))++
			*(*uint8)(unsafe.Pointer(v49)) = libc.Uint8FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) >> libc.Int32FromInt32(8))
			v52 = cursorPtr
			v51 = *(*uintptr)(unsafe.Pointer(v52))
			*(*uintptr)(unsafe.Pointer(v52))++
			*(*uint8)(unsafe.Pointer(v51)) = libc.Uint8FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)))
		}
		return TCL_OK
		/*
		 * 16-bit integer values.
		 */
		fallthrough
	case int32('s'):
		fallthrough
	case int32('S'):
		fallthrough
	case int32('t'):
		if XTclGetWideBitsFromObj(tls, interp, src, bp+8) != TCL_OK {
			return int32(TCL_ERROR)
		}
		if _NeedReversing(tls, type1) != 0 {
			v54 = cursorPtr
			v53 = *(*uintptr)(unsafe.Pointer(v54))
			*(*uintptr)(unsafe.Pointer(v54))++
			*(*uint8)(unsafe.Pointer(v53)) = libc.Uint8FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)))
			v56 = cursorPtr
			v55 = *(*uintptr)(unsafe.Pointer(v56))
			*(*uintptr)(unsafe.Pointer(v56))++
			*(*uint8)(unsafe.Pointer(v55)) = libc.Uint8FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) >> libc.Int32FromInt32(8))
		} else {
			v58 = cursorPtr
			v57 = *(*uintptr)(unsafe.Pointer(v58))
			*(*uintptr)(unsafe.Pointer(v58))++
			*(*uint8)(unsafe.Pointer(v57)) = libc.Uint8FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) >> libc.Int32FromInt32(8))
			v60 = cursorPtr
			v59 = *(*uintptr)(unsafe.Pointer(v60))
			*(*uintptr)(unsafe.Pointer(v60))++
			*(*uint8)(unsafe.Pointer(v59)) = libc.Uint8FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)))
		}
		return TCL_OK
		/*
		 * 8-bit integer values.
		 */
		fallthrough
	case int32('c'):
		if XTclGetWideBitsFromObj(tls, interp, src, bp+8) != TCL_OK {
			return int32(TCL_ERROR)
		}
		v62 = cursorPtr
		v61 = *(*uintptr)(unsafe.Pointer(v62))
		*(*uintptr)(unsafe.Pointer(v62))++
		*(*uint8)(unsafe.Pointer(v61)) = libc.Uint8FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)))
		return TCL_OK
	default:
		XTcl_Panic(tls, __ccgo_ts+11006, 0)
		return int32(TCL_ERROR)
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * ScanNumber --
 *
 *	This routine is called by Tcl_BinaryObjCmd to scan a number out of a
 *	buffer.
 *
 * Results:
 *	Returns a newly created object containing the scanned number. This
 *	object has a ref count of zero.
 *
 * Side effects:
 *	Might reuse an object in the number cache, place a new object in the
 *	cache, or delete the cache and set the reference to it (itself passed
 *	in by reference) to NULL.
 *
 *----------------------------------------------------------------------
 */

func _ScanNumber(tls *libc.TLS, buffer uintptr, type1 int32, flags int32, numberCachePtrPtr uintptr) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	/* Place to look for cache of scanned value
	 * objects, or NULL if too many different
	 * numbers have been scanned. */
	var bigObj, cachePtr, hPtr, objPtr, tablePtr uintptr
	var uwvalue TTcl_WideUInt
	var value int64
	var v18 bool
	var _ /* big at bp+24 */ Tmp_int
	var _ /* dvalue at bp+8 */ float64
	var _ /* fvalue at bp+0 */ float32
	var _ /* isNew at bp+16 */ int32
	_, _, _, _, _, _, _, _ = bigObj, cachePtr, hPtr, objPtr, tablePtr, uwvalue, value, v18
	/*
	 * We cannot rely on the compiler to properly sign extend integer values
	 * when we cast from smaller values to larger values because we don't know
	 * the exact size of the integer types. So, we have to handle sign
	 * extension explicitly by checking the high bit and padding with 1's as
	 * needed. This practice is disabled if the BINARY_UNSIGNED flag is set.
	 */
	switch type1 {
	case int32('c'):
		goto _1
	case int32('t'):
		goto _2
	case int32('S'):
		goto _3
	case int32('s'):
		goto _4
	case int32('n'):
		goto _5
	case int32('I'):
		goto _6
	case int32('i'):
		goto _7
	case int32('m'):
		goto _8
	case int32('W'):
		goto _9
	case int32('w'):
		goto _10
	case int32('r'):
		goto _11
	case int32('R'):
		goto _12
	case int32('f'):
		goto _13
	case int32('q'):
		goto _14
	case int32('Q'):
		goto _15
	case int32('d'):
		goto _16
	}
	goto _17
_1:
	;
	/*
	 * Characters need special handling. We want to produce a signed
	 * result, but on some platforms (such as AIX) chars are unsigned. To
	 * deal with this, check for a value that should be negative but
	 * isn't.
	 */
	value = libc.Int64FromUint8(*(*uint8)(unsafe.Pointer(buffer)))
	if !(flags&libc.Int32FromInt32(BINARY_UNSIGNED) != 0) {
		if value&int64(0x80) != 0 {
			value |= int64(-int32(0x100))
		}
	}
	goto returnNumericObject
	/*
	 * 16-bit numeric values. We need the sign extension trick (see above)
	 * here as well.
	 */
_4:
	;
_3:
	;
_2:
	;
	if _NeedReversing(tls, type1) != 0 {
		value = int64(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(buffer))) + libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(buffer + 1)))<<libc.Int32FromInt32(8))
	} else {
		value = int64(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(buffer + 1))) + libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(buffer)))<<libc.Int32FromInt32(8))
	}
	if !(flags&libc.Int32FromInt32(BINARY_UNSIGNED) != 0) {
		if value&int64(0x8000) != 0 {
			value |= int64(-int32(0x10000))
		}
	}
	goto returnNumericObject
	/*
	 * 32-bit numeric values.
	 */
_7:
	;
_6:
	;
_5:
	;
	if _NeedReversing(tls, type1) != 0 {
		value = libc.Int64FromUint64(libc.Uint64FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(buffer)))+libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(buffer + 1)))<<libc.Int32FromInt32(8)+libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(buffer + 2)))<<libc.Int32FromInt32(16)) + uint64(*(*uint8)(unsafe.Pointer(buffer + 3)))<<libc.Int32FromInt32(24))
	} else {
		value = libc.Int64FromUint64(libc.Uint64FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(buffer + 3)))+libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(buffer + 2)))<<libc.Int32FromInt32(8)+libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(buffer + 1)))<<libc.Int32FromInt32(16)) + uint64(*(*uint8)(unsafe.Pointer(buffer)))<<libc.Int32FromInt32(24))
	}
	/*
	 * Check to see if the value was sign extended properly on systems
	 * where an int is more than 32-bits.
	 *
	 * We avoid caching unsigned integers as we cannot distinguish between
	 * 32bit signed and unsigned in the hash (short and char are ok).
	 */
	if flags&int32(BINARY_UNSIGNED) != 0 {
		return XTcl_NewWideIntObj(tls, libc.Int64FromUint64(libc.Uint64FromInt64(value)))
	}
	if value&libc.Int64FromUint32(libc.Uint32FromUint32(1)<<libc.Int32FromInt32(31)) != 0 && value > 0 {
		value -= libc.Int64FromUint32(libc.Uint32FromUint32(1) << libc.Int32FromInt32(31))
		value -= libc.Int64FromUint32(libc.Uint32FromUint32(1) << libc.Int32FromInt32(31))
	}
	goto returnNumericObject
returnNumericObject:
	;
	if *(*uintptr)(unsafe.Pointer(numberCachePtrPtr)) == libc.UintptrFromInt32(0) {
		return XTcl_NewWideIntObj(tls, value)
	} else {
		tablePtr = *(*uintptr)(unsafe.Pointer(numberCachePtrPtr))
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FcreateProc})))(tls, tablePtr, uintptr(value), bp+16)
		if !(*(*int32)(unsafe.Pointer(bp + 16)) != 0) {
			return (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		}
		if (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FnumEntries <= int64(BINARY_SCAN_MAX_CACHE) {
			if v18 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v18 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v18 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				objPtr = XTclThreadAllocObj(tls)
			} else {
				objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = libc.UintptrFromInt32(0)
			*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) = value
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount++
			(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = objPtr
			return objPtr
		}
		/*
		 * We've overflowed the cache! Someone's parsing a LOT of varied
		 * binary data in a single call! Bail out by switching back to the
		 * old behaviour for the rest of the scan.
		 *
		 * Note that anyone just using the 'c' conversion (for bytes)
		 * cannot trigger this.
		 */
		_DeleteScanNumberCache(tls, tablePtr)
		*(*uintptr)(unsafe.Pointer(numberCachePtrPtr)) = libc.UintptrFromInt32(0)
		return XTcl_NewWideIntObj(tls, value)
	}
	/*
	 * Do not cache wide (64-bit) values; they are already too large to
	 * use as keys.
	 */
_10:
	;
_9:
	;
_8:
	;
	if _NeedReversing(tls, type1) != 0 {
		uwvalue = uint64(*(*uint8)(unsafe.Pointer(buffer))) | uint64(*(*uint8)(unsafe.Pointer(buffer + 1)))<<libc.Int32FromInt32(8) | uint64(*(*uint8)(unsafe.Pointer(buffer + 2)))<<libc.Int32FromInt32(16) | uint64(*(*uint8)(unsafe.Pointer(buffer + 3)))<<libc.Int32FromInt32(24) | uint64(*(*uint8)(unsafe.Pointer(buffer + 4)))<<libc.Int32FromInt32(32) | uint64(*(*uint8)(unsafe.Pointer(buffer + 5)))<<libc.Int32FromInt32(40) | uint64(*(*uint8)(unsafe.Pointer(buffer + 6)))<<libc.Int32FromInt32(48) | uint64(*(*uint8)(unsafe.Pointer(buffer + 7)))<<libc.Int32FromInt32(56)
	} else {
		uwvalue = uint64(*(*uint8)(unsafe.Pointer(buffer + 7))) | uint64(*(*uint8)(unsafe.Pointer(buffer + 6)))<<libc.Int32FromInt32(8) | uint64(*(*uint8)(unsafe.Pointer(buffer + 5)))<<libc.Int32FromInt32(16) | uint64(*(*uint8)(unsafe.Pointer(buffer + 4)))<<libc.Int32FromInt32(24) | uint64(*(*uint8)(unsafe.Pointer(buffer + 3)))<<libc.Int32FromInt32(32) | uint64(*(*uint8)(unsafe.Pointer(buffer + 2)))<<libc.Int32FromInt32(40) | uint64(*(*uint8)(unsafe.Pointer(buffer + 1)))<<libc.Int32FromInt32(48) | uint64(*(*uint8)(unsafe.Pointer(buffer)))<<libc.Int32FromInt32(56)
	}
	if flags&int32(BINARY_UNSIGNED) != 0 {
		bigObj = libc.UintptrFromInt32(0)
		if XTclBN_mp_init_u64(tls, bp+24, uwvalue) == MP_OKAY {
			bigObj = XTcl_NewBignumObj(tls, bp+24)
		}
		return bigObj
	}
	return XTcl_NewWideIntObj(tls, libc.Int64FromUint64(uwvalue))
	/*
	 * Do not cache double values; they are already too large to use as
	 * keys and the values stored are utterly incompatible with the
	 * integer part of the cache.
	 */
	/*
	 * 32-bit IEEE single-precision floating point.
	 */
_13:
	;
_12:
	;
_11:
	;
	_CopyNumber(tls, buffer, bp, uint64(4), type1)
	return XTcl_NewDoubleObj(tls, float64(*(*float32)(unsafe.Pointer(bp))))
	/*
	 * 64-bit IEEE double-precision floating point.
	 */
_16:
	;
_15:
	;
_14:
	;
	_CopyNumber(tls, buffer, bp+8, uint64(8), type1)
	return XTcl_NewDoubleObj(tls, *(*float64)(unsafe.Pointer(bp + 8)))
_17:
	;
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * DeleteScanNumberCache --
 *
 *	Deletes the hash table acting as a scan number cache.
 *
 * Results:
 *	None
 *
 * Side effects:
 *	Decrements the reference counts of the objects in the cache.
 *
 *----------------------------------------------------------------------
 */

func _DeleteScanNumberCache(tls *libc.TLS, numberCachePtr uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	/* Pointer to the hash table, or NULL (when
	 * the cache has already been deleted due to
	 * overflow.) */
	var _objPtr, hEntry, value, v2 uintptr
	var v1 TTcl_Size
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _, _ = _objPtr, hEntry, value, v1, v2
	if numberCachePtr == libc.UintptrFromInt32(0) {
		return
	}
	hEntry = XTcl_FirstHashEntry(tls, numberCachePtr, bp)
	for hEntry != libc.UintptrFromInt32(0) {
		value = (*TTcl_HashEntry)(unsafe.Pointer(hEntry)).FclientData
		if value != libc.UintptrFromInt32(0) {
			_objPtr = value
			v2 = _objPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if v1 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
		hEntry = XTcl_NextHashEntry(tls, bp)
	}
	XTcl_DeleteHashTable(tls, numberCachePtr)
}

/*
 * ----------------------------------------------------------------------
 *
 * NOTES --
 *
 *	Some measurements show that it is faster to use a table to perform
 *	uuencode and base64 value encoding than to calculate the output (at
 *	least on intel P4 arch).
 *
 *	Conversely using a lookup table for the decoding is slower than just
 *	calculating the values. We therefore use the fastest of each method.
 *
 *	Presumably this has to do with the size of the tables. The base64
 *	decode table is 255 bytes while the encode table is only 65 bytes. The
 *	choice likely depends on CPU memory cache sizes.
 */

/*
 *----------------------------------------------------------------------
 *
 * BinaryEncodeHex --
 *
 *	Implement the [binary encode hex] binary encoding. clientData must be
 *	a table to convert values to hexadecimal digits.
 *
 * Results:
 *	Interp result set to an encoded byte array object
 *
 * Side effects:
 *	None
 *
 *----------------------------------------------------------------------
 */

func _BinaryEncodeHex(tls *libc.TLS, dummy2433 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var cachePtr, cursor, data, resultObj, v3, v4 uintptr
	var offset TTcl_Size
	var v1 bool
	var _ /* count at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _ = cachePtr, cursor, data, offset, resultObj, v1, v3, v4
	resultObj = libc.UintptrFromInt32(0)
	data = libc.UintptrFromInt32(0)
	cursor = libc.UintptrFromInt32(0)
	offset = 0
	*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+11029)
		return int32(TCL_ERROR)
	}
	data = XTcl_GetBytesFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
	if data == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	cursor = XTcl_SetByteArrayLength(tls, resultObj, *(*TTcl_Size)(unsafe.Pointer(bp))*int64(2))
	offset = 0
	for {
		if !(offset < *(*TTcl_Size)(unsafe.Pointer(bp))) {
			break
		}
		v3 = cursor
		cursor++
		*(*uint8)(unsafe.Pointer(v3)) = _HexDigits[libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(data + uintptr(offset))))>>int32(4)&int32(0x0F)]
		v4 = cursor
		cursor++
		*(*uint8)(unsafe.Pointer(v4)) = _HexDigits[libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(data + uintptr(offset))))&int32(0x0F)]
		goto _2
	_2:
		;
		offset++
	}
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * BinaryDecodeHex --
 *
 *	Implement the [binary decode hex] binary encoding.
 *
 * Results:
 *	Interp result set to an decoded byte array object
 *
 * Side effects:
 *	None
 *
 *----------------------------------------------------------------------
 */

func _BinaryDecodeHex(tls *libc.TLS, dummy2481 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var begin, cachePtr, cachePtr1, cursor, data, dataend, datastart, resultObj, v10, v3, v4, v6, v7 uintptr
	var c uint8
	var cut, size, v9 TTcl_Size
	var i, pure, strict, value int32
	var v11, v2 bool
	var _ /* count at bp+8 */ TTcl_Size
	var _ /* index at bp+0 */ int32
	var _ /* ucs4 at bp+16 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = begin, c, cachePtr, cachePtr1, cursor, cut, data, dataend, datastart, i, pure, resultObj, size, strict, value, v10, v11, v2, v3, v4, v6, v7, v9
	resultObj = libc.UintptrFromInt32(0)
	pure = int32(1)
	strict = 0
	cut = 0
	*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0
	if objc < int32(2) || objc > int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+11042)
		return int32(TCL_ERROR)
	}
	i = int32(1)
	for {
		if !(i < objc-int32(1)) {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_optStrings)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(TCL_EXACT)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
			return int32(TCL_ERROR)
		}
		switch *(*int32)(unsafe.Pointer(bp)) {
		case 0:
			strict = int32(1)
			break
		}
		goto _1
	_1:
		;
		i++
	}
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	data = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), bp+8)
	if data == libc.UintptrFromInt32(0) {
		pure = 0
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))).Flength
			v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), bp+8)
		}
		data = v3
	}
	datastart = data
	dataend = data + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
	size = (*(*TTcl_Size)(unsafe.Pointer(bp + 8)) + int64(1)) / int64(2)
	v4 = XTcl_SetByteArrayLength(tls, resultObj, size)
	cursor = v4
	begin = v4
	for data < dataend {
		value = 0
		i = 0
		for {
			if !(i < int32(2)) {
				break
			}
			if data >= dataend {
				value <<= int32(4)
				break
			}
			v6 = data
			data++
			c = *(*uint8)(unsafe.Pointer(v6))
			if !(libc.Xisxdigit(tls, libc.Int32FromUint8(c)) != 0) {
				if strict != 0 || !(XTclIsSpaceProc(tls, libc.Int32FromUint8(c)) != 0) {
					goto badChar
				}
				i--
				goto _5
			}
			value <<= int32(4)
			c = uint8(int32(c) - libc.Int32FromUint8('0'))
			if libc.Int32FromUint8(c) > int32(9) {
				c = uint8(int32(c) + (libc.Int32FromUint8('0') - libc.Int32FromUint8('A') + libc.Int32FromInt32(10)))
			}
			if libc.Int32FromUint8(c) > int32(16) {
				c = uint8(int32(c) + (libc.Int32FromUint8('A') - libc.Int32FromUint8('a')))
			}
			value |= libc.Int32FromUint8(c) & int32(0xF)
			goto _5
		_5:
			;
			i++
		}
		if i < int32(2) {
			cut++
		}
		v7 = cursor
		cursor++
		*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(value)
		value = 0
	}
	if cut > size {
		cut = size
	}
	XTcl_SetByteArrayLength(tls, resultObj, int64(cursor)-int64(begin)-cut)
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
	goto badChar
badChar:
	;
	if pure != 0 {
		*(*int32)(unsafe.Pointer(bp + 16)) = libc.Int32FromUint8(c)
	} else {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(data - libc.UintptrFromInt32(1)))) < int32(0x80) {
			*(*int32)(unsafe.Pointer(bp + 16)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(data - libc.UintptrFromInt32(1))))
			_ = libc.Int32FromInt32(1)
		} else {
			XTcl_UtfToUniChar(tls, data-libc.UintptrFromInt32(1), bp+16)
		}
	}
	v10 = resultObj
	v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
	*(*TTcl_Size)(unsafe.Pointer(v10))--
	if !(v9 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v11 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v11 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v11 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, resultObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(resultObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = resultObj
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, resultObj)
		}
	}
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+11064, libc.VaList(bp+32, *(*int32)(unsafe.Pointer(bp + 16)), *(*int32)(unsafe.Pointer(bp + 16)), int64(data)-int64(datastart)-int64(1))))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+32, __ccgo_ts+2004, __ccgo_ts+11120, __ccgo_ts+11127, __ccgo_ts+11134, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
}

var _optStrings = [2]uintptr{
	0: __ccgo_ts + 11034,
	1: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * BinaryEncode64 --
 *
 *	This procedure implements the "binary encode base64" Tcl command.
 *
 * Results:
 *	The base64 encoded value prescribed by the input arguments.
 *
 *----------------------------------------------------------------------
 */

func _BinaryEncode64(tls *libc.TLS, dummy2606 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var adjusted, purewrap, v2 int32
	var cachePtr, cursor, data, limit, resultObj, wrapchar, v10, v11, v12, v13, v3, v5, v8, v9 uintptr
	var d [3]uint8
	var i, offset, outindex, size TTcl_Size
	var v4 bool
	var _ /* count at bp+24 */ TTcl_Size
	var _ /* index at bp+16 */ int32
	var _ /* maxlen at bp+0 */ TTcl_WideInt
	var _ /* wrapcharlen at bp+8 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = adjusted, cachePtr, cursor, d, data, i, limit, offset, outindex, purewrap, resultObj, size, wrapchar, v10, v11, v12, v13, v2, v3, v4, v5, v8, v9
	*(*TTcl_WideInt)(unsafe.Pointer(bp)) = 0
	wrapchar = __ccgo_ts + 286
	*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = int64(1)
	purewrap = int32(1)
	outindex = 0
	*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = 0
	if objc < int32(2) || objc%int32(2) != 0 {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+11160)
		return int32(TCL_ERROR)
	}
	i = int64(1)
	for {
		if !(i < int64(objc-int32(1))) {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_optStrings1)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(TCL_EXACT)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+16) != TCL_OK {
			return int32(TCL_ERROR)
		}
		switch *(*int32)(unsafe.Pointer(bp + 16)) {
		case 0:
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
				*(*TTcl_WideInt)(unsafe.Pointer(bp)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).FinternalRep))
				v2 = libc.Int32FromInt32(TCL_OK)
			} else {
				v2 = XTcl_GetWideIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)), bp)
			}
			if v2 != TCL_OK {
				return int32(TCL_ERROR)
			}
			if *(*TTcl_WideInt)(unsafe.Pointer(bp)) < 0 {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+11196, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+11120, __ccgo_ts+11221, __ccgo_ts+11228, libc.UintptrFromInt32(0)))
				return int32(TCL_ERROR)
			}
		case 1:
			wrapchar = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)), bp+8)
			if wrapchar == libc.UintptrFromInt32(0) {
				purewrap = 0
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).Fbytes != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).Flength
					v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).Fbytes
				} else {
					v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)), bp+8)
				}
				wrapchar = v3
			}
			break
		}
		goto _1
	_1:
		;
		i += int64(2)
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == 0 {
		*(*TTcl_WideInt)(unsafe.Pointer(bp)) = 0
	}
	data = XTcl_GetBytesFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), bp+24)
	if data == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	if *(*TTcl_Size)(unsafe.Pointer(bp + 24)) > 0 {
		cursor = libc.UintptrFromInt32(0)
		size = (*(*TTcl_Size)(unsafe.Pointer(bp + 24))*int64(4)/int64(3) + int64(3)) & int64(^libc.Int32FromInt32(3)) /* ensure 4 byte chunks */
		if *(*TTcl_WideInt)(unsafe.Pointer(bp)) > 0 && size > *(*TTcl_WideInt)(unsafe.Pointer(bp)) {
			adjusted = int32(size + *(*TTcl_Size)(unsafe.Pointer(bp + 8))*(size / *(*TTcl_WideInt)(unsafe.Pointer(bp))))
			if size%*(*TTcl_WideInt)(unsafe.Pointer(bp)) == 0 {
				adjusted = int32(int64(adjusted) - *(*TTcl_Size)(unsafe.Pointer(bp + 8)))
			}
			size = int64(adjusted)
			if purewrap == 0 {
				/* Wrapchar is (possibly) non-byte, so build result as
				 * general string, not bytearray */
				XTcl_SetObjLength(tls, resultObj, size)
				if (*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes != 0 {
					v5 = (*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes
				} else {
					v5 = XTcl_GetStringFromObj(tls, resultObj, libc.UintptrFromInt32(0))
				}
				cursor = v5
			}
		}
		if cursor == libc.UintptrFromInt32(0) {
			cursor = XTcl_SetByteArrayLength(tls, resultObj, size)
		}
		limit = cursor + uintptr(size)
		offset = 0
		for {
			if !(offset < *(*TTcl_Size)(unsafe.Pointer(bp + 24))) {
				break
			}
			d = [3]uint8{}
			i = 0
			for {
				if !(i < int64(3) && offset+i < *(*TTcl_Size)(unsafe.Pointer(bp + 24))) {
					break
				}
				d[i] = *(*uint8)(unsafe.Pointer(data + uintptr(offset+i)))
				goto _7
			_7:
				;
				i++
			}
			v8 = cursor
			cursor++
			*(*uint8)(unsafe.Pointer(v8)) = _B64Digits[libc.Int32FromUint8(d[0])>>int32(2)]
			outindex++
			if *(*TTcl_WideInt)(unsafe.Pointer(bp)) > 0 && cursor != limit {
				if outindex == *(*TTcl_WideInt)(unsafe.Pointer(bp)) {
					libc.Xmemcpy(tls, cursor, wrapchar, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8))))
					cursor += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
					outindex = 0
				}
			}
			if cursor > limit {
				XTcl_Panic(tls, __ccgo_ts+11240, 0)
			}
			v9 = cursor
			cursor++
			*(*uint8)(unsafe.Pointer(v9)) = _B64Digits[libc.Int32FromUint8(d[0])&int32(0x03)<<int32(4)|libc.Int32FromUint8(d[int32(1)])>>int32(4)]
			outindex++
			if *(*TTcl_WideInt)(unsafe.Pointer(bp)) > 0 && cursor != limit {
				if outindex == *(*TTcl_WideInt)(unsafe.Pointer(bp)) {
					libc.Xmemcpy(tls, cursor, wrapchar, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8))))
					cursor += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
					outindex = 0
				}
			}
			if cursor > limit {
				XTcl_Panic(tls, __ccgo_ts+11240, 0)
			}
			if offset+int64(1) < *(*TTcl_Size)(unsafe.Pointer(bp + 24)) {
				v10 = cursor
				cursor++
				*(*uint8)(unsafe.Pointer(v10)) = _B64Digits[libc.Int32FromUint8(d[int32(1)])&int32(0x0F)<<int32(2)|libc.Int32FromUint8(d[int32(2)])>>int32(6)]
				outindex++
				if *(*TTcl_WideInt)(unsafe.Pointer(bp)) > 0 && cursor != limit {
					if outindex == *(*TTcl_WideInt)(unsafe.Pointer(bp)) {
						libc.Xmemcpy(tls, cursor, wrapchar, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8))))
						cursor += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
						outindex = 0
					}
				}
				if cursor > limit {
					XTcl_Panic(tls, __ccgo_ts+11240, 0)
				}
			} else {
				v11 = cursor
				cursor++
				*(*uint8)(unsafe.Pointer(v11)) = _B64Digits[int32(64)]
				outindex++
				if *(*TTcl_WideInt)(unsafe.Pointer(bp)) > 0 && cursor != limit {
					if outindex == *(*TTcl_WideInt)(unsafe.Pointer(bp)) {
						libc.Xmemcpy(tls, cursor, wrapchar, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8))))
						cursor += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
						outindex = 0
					}
				}
				if cursor > limit {
					XTcl_Panic(tls, __ccgo_ts+11240, 0)
				}
			}
			if offset+int64(2) < *(*TTcl_Size)(unsafe.Pointer(bp + 24)) {
				v12 = cursor
				cursor++
				*(*uint8)(unsafe.Pointer(v12)) = _B64Digits[libc.Int32FromUint8(d[int32(2)])&int32(0x3F)]
				outindex++
				if *(*TTcl_WideInt)(unsafe.Pointer(bp)) > 0 && cursor != limit {
					if outindex == *(*TTcl_WideInt)(unsafe.Pointer(bp)) {
						libc.Xmemcpy(tls, cursor, wrapchar, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8))))
						cursor += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
						outindex = 0
					}
				}
				if cursor > limit {
					XTcl_Panic(tls, __ccgo_ts+11240, 0)
				}
			} else {
				v13 = cursor
				cursor++
				*(*uint8)(unsafe.Pointer(v13)) = _B64Digits[int32(64)]
				outindex++
				if *(*TTcl_WideInt)(unsafe.Pointer(bp)) > 0 && cursor != limit {
					if outindex == *(*TTcl_WideInt)(unsafe.Pointer(bp)) {
						libc.Xmemcpy(tls, cursor, wrapchar, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8))))
						cursor += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
						outindex = 0
					}
				}
				if cursor > limit {
					XTcl_Panic(tls, __ccgo_ts+11240, 0)
				}
			}
			goto _6
		_6:
			;
			offset += int64(3)
		}
	}
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
}

var _optStrings1 = [3]uintptr{
	0: __ccgo_ts + 11142,
	1: __ccgo_ts + 11150,
	2: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * BinaryEncodeUu --
 *
 *	This implements the uuencode binary encoding. Input is broken into 6
 *	bit chunks and a lookup table is used to turn these values into output
 *	characters. This differs from the generic code above in that line
 *	lengths are also encoded.
 *
 * Results:
 *	Interp result set to an encoded byte array object
 *
 * Side effects:
 *	None
 *
 *----------------------------------------------------------------------
 */

func _BinaryEncodeUu(tls *libc.TLS, dummy2732 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var bits, i, v14 int32
	var cachePtr, cursor, data, p, resultObj, start, wrapchar, v13, v15, v19, v2, v20, v22 uintptr
	var j, lineLen, numBytes, offset, rawLength, v17 TTcl_Size
	var n uint32
	var v12 bool
	var _ /* SingleNewline at bp+8 */ [1]uint8
	var _ /* count at bp+16 */ TTcl_Size
	var _ /* index at bp+0 */ int32
	var _ /* lineLength at bp+4 */ int32
	var _ /* wrapcharlen at bp+24 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bits, cachePtr, cursor, data, i, j, lineLen, n, numBytes, offset, p, rawLength, resultObj, start, wrapchar, v12, v13, v14, v15, v17, v19, v2, v20, v22
	*(*int32)(unsafe.Pointer(bp + 4)) = int32(61)
	*(*[1]uint8)(unsafe.Pointer(bp + 8)) = [1]uint8{
		0: libc.Uint8FromInt32(libc.Int32FromUint8('\n')),
	}
	wrapchar = bp + 8
	*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = 0
	*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = int64(1)
	if objc < int32(2) || objc%int32(2) != 0 {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+11160)
		return int32(TCL_ERROR)
	}
	i = int32(1)
	for {
		if !(i < objc-int32(1)) {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_optStrings2)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(TCL_EXACT)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
			return int32(TCL_ERROR)
		}
		switch *(*int32)(unsafe.Pointer(bp)) {
		case 0:
			if XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)), bp+4) != TCL_OK {
				return int32(TCL_ERROR)
			}
			if *(*int32)(unsafe.Pointer(bp + 4)) < int32(5) || *(*int32)(unsafe.Pointer(bp + 4)) > int32(85) {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+11196, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+11120, __ccgo_ts+11221, __ccgo_ts+11228, libc.UintptrFromInt32(0)))
				return int32(TCL_ERROR)
			}
			*(*int32)(unsafe.Pointer(bp + 4)) = (*(*int32)(unsafe.Pointer(bp + 4))-int32(1))&-int32(4) + int32(1) /* 5, 9, 13 ... */
		case 1:
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)))).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)))).Flength
				v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)))).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)), bp+24)
			}
			wrapchar = v2
			p = wrapchar
			numBytes = *(*TTcl_Size)(unsafe.Pointer(bp + 24))
		_4:
			;
			if !(numBytes != 0) {
				goto _3
			}
			switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) {
			case int32('\r'):
				goto _5
			case int32('\f'):
				goto _6
			case int32('\v'):
				goto _7
			case int32('\t'):
				goto _8
			case int32('\n'):
				goto _9
			default:
				goto _10
			}
			goto _11
		_8:
			;
		_7:
			;
		_6:
			;
		_5:
			;
			p++
			numBytes--
			goto _4
		_9:
			;
			numBytes--
			goto _11
		_10:
			;
			goto badwrap
		badwrap:
			;
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+11250, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+11120, __ccgo_ts+11221, __ccgo_ts+11289, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		_11:
			;
			goto _4
		_3:
			;
			if numBytes != 0 {
				goto badwrap
			}
			break
		}
		goto _1
	_1:
		;
		i += int32(2)
	}
	/*
	 * Allocate the buffer. This is a little bit too long, but is "good
	 * enough".
	 */
	offset = 0
	data = XTcl_GetBytesFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), bp+16)
	if data == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if v12 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v12 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v12 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	rawLength = int64((*(*int32)(unsafe.Pointer(bp + 4)) - int32(1)) * int32(3) / int32(4))
	v13 = XTcl_SetByteArrayLength(tls, resultObj, (int64(*(*int32)(unsafe.Pointer(bp + 4)))+*(*TTcl_Size)(unsafe.Pointer(bp + 24)))*((*(*TTcl_Size)(unsafe.Pointer(bp + 16))+(rawLength-int64(1)))/rawLength))
	cursor = v13
	start = v13
	v14 = libc.Int32FromInt32(0)
	bits = v14
	n = libc.Uint32FromInt32(v14)
	/*
	 * Encode the data. Each output line first has the length of raw data
	 * encoded by the output line described in it by one encoded byte, then
	 * the encoded data follows (encoding each 6 bits as one character).
	 * Encoded lines are always terminated by a newline.
	 */
	for offset < *(*TTcl_Size)(unsafe.Pointer(bp + 16)) {
		lineLen = *(*TTcl_Size)(unsafe.Pointer(bp + 16)) - offset
		if lineLen > rawLength {
			lineLen = rawLength
		}
		v15 = cursor
		cursor++
		*(*uint8)(unsafe.Pointer(v15)) = _UueDigits[lineLen]
		i = 0
		for {
			if !(int64(i) < lineLen) {
				break
			}
			n <<= uint32(8)
			v17 = offset
			offset++
			n |= uint32(*(*uint8)(unsafe.Pointer(data + uintptr(v17))))
			bits += int32(8)
			for {
				if !(bits > int32(6)) {
					break
				}
				v19 = cursor
				cursor++
				*(*uint8)(unsafe.Pointer(v19)) = _UueDigits[n>>(bits-int32(6))&uint32(0x3F)]
				goto _18
			_18:
				;
				bits -= int32(6)
			}
			goto _16
		_16:
			;
			i++
		}
		if bits > 0 {
			n <<= uint32(8)
			v20 = cursor
			cursor++
			*(*uint8)(unsafe.Pointer(v20)) = _UueDigits[n>>(bits+int32(2))&uint32(0x3F)]
			bits = 0
		}
		j = 0
		for {
			if !(j < *(*TTcl_Size)(unsafe.Pointer(bp + 24))) {
				break
			}
			v22 = cursor
			cursor++
			*(*uint8)(unsafe.Pointer(v22)) = *(*uint8)(unsafe.Pointer(wrapchar + uintptr(j)))
			goto _21
		_21:
			;
			j++
		}
	}
	/*
	 * Fix the length of the output bytearray.
	 */
	XTcl_SetByteArrayLength(tls, resultObj, int64(cursor)-int64(start))
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
}

var _optStrings2 = [3]uintptr{
	0: __ccgo_ts + 11142,
	1: __ccgo_ts + 11150,
	2: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * BinaryDecodeUu --
 *
 *	Decode a uuencoded string.
 *
 * Results:
 *	Interp result set to an byte array object
 *
 * Side effects:
 *	None
 *
 *----------------------------------------------------------------------
 */

func _BinaryDecodeUu(tls *libc.TLS, dummy2884 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var begin, cachePtr, cachePtr1, cachePtr2, cursor, data, dataend, datastart, resultObj, v11, v13, v14, v16, v20, v3, v4, v5, v8, v9 uintptr
	var c, v7 uint8
	var d [4]uint8
	var i, lineLen, pure, strict, v10, v12 int32
	var size, v15, v19 TTcl_Size
	var v17, v2, v21 bool
	var _ /* count at bp+8 */ TTcl_Size
	var _ /* index at bp+0 */ int32
	var _ /* ucs4 at bp+16 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = begin, c, cachePtr, cachePtr1, cachePtr2, cursor, d, data, dataend, datastart, i, lineLen, pure, resultObj, size, strict, v10, v11, v12, v13, v14, v15, v16, v17, v19, v2, v20, v21, v3, v4, v5, v7, v8, v9
	resultObj = libc.UintptrFromInt32(0)
	pure = int32(1)
	strict = 0
	*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0
	if objc < int32(2) || objc > int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+11042)
		return int32(TCL_ERROR)
	}
	i = int32(1)
	for {
		if !(i < objc-int32(1)) {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_optStrings3)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(TCL_EXACT)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
			return int32(TCL_ERROR)
		}
		switch *(*int32)(unsafe.Pointer(bp)) {
		case 0:
			strict = int32(1)
			break
		}
		goto _1
	_1:
		;
		i++
	}
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	data = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), bp+8)
	if data == libc.UintptrFromInt32(0) {
		pure = 0
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))).Flength
			v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), bp+8)
		}
		data = v3
	}
	datastart = data
	dataend = data + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
	size = (*(*TTcl_Size)(unsafe.Pointer(bp + 8)) + int64(3)) & int64(^libc.Int32FromInt32(3)) * int64(3) / int64(4)
	v4 = XTcl_SetByteArrayLength(tls, resultObj, size)
	cursor = v4
	begin = v4
	lineLen = -int32(1)
	/*
	 * The decoding loop. First, we get the length of line (strictly, the
	 * number of data bytes we expect to generate from the line) we're
	 * processing this time round if it is not already known (i.e., when the
	 * lineLen variable is set to the magic value, -1).
	 */
	for data < dataend {
		d = [4]uint8{}
		if lineLen < 0 {
			v5 = data
			data++
			c = *(*uint8)(unsafe.Pointer(v5))
			if libc.Int32FromUint8(c) < int32(32) || libc.Int32FromUint8(c) > int32(96) {
				if strict != 0 || !(XTclIsSpaceProc(tls, libc.Int32FromUint8(c)) != 0) {
					goto badUu
				}
				i--
				continue
			}
			lineLen = (libc.Int32FromUint8(c) - int32(32)) & int32(0x3F)
		}
		/*
		 * Now we read a four-character grouping.
		 */
		i = 0
		for {
			if !(i < int32(4)) {
				break
			}
			if data < dataend {
				v8 = data
				data++
				v7 = *(*uint8)(unsafe.Pointer(v8))
				c = v7
				d[i] = v7
				if libc.Int32FromUint8(c) < int32(32) || libc.Int32FromUint8(c) > int32(96) {
					if strict != 0 {
						if !(XTclIsSpaceProc(tls, libc.Int32FromUint8(c)) != 0) {
							goto badUu
						} else {
							if libc.Int32FromUint8(c) == int32('\n') {
								goto shortUu
							}
						}
					}
					i--
					goto _6
				}
			}
			goto _6
		_6:
			;
			i++
		}
		/*
		 * Translate that grouping into (up to) three binary bytes output.
		 */
		if lineLen > 0 {
			v9 = cursor
			cursor++
			*(*uint8)(unsafe.Pointer(v9)) = libc.Uint8FromInt32((libc.Int32FromUint8(d[0])-int32(0x20))&int32(0x3F)<<int32(2) | (libc.Int32FromUint8(d[int32(1)])-int32(0x20))&int32(0x3F)>>int32(4))
			lineLen--
			v10 = lineLen
			if v10 > 0 {
				v11 = cursor
				cursor++
				*(*uint8)(unsafe.Pointer(v11)) = libc.Uint8FromInt32((libc.Int32FromUint8(d[int32(1)])-int32(0x20))&int32(0x3F)<<int32(4) | (libc.Int32FromUint8(d[int32(2)])-int32(0x20))&int32(0x3F)>>int32(2))
				lineLen--
				v12 = lineLen
				if v12 > 0 {
					v13 = cursor
					cursor++
					*(*uint8)(unsafe.Pointer(v13)) = libc.Uint8FromInt32((libc.Int32FromUint8(d[int32(2)])-int32(0x20))&int32(0x3F)<<int32(6) | (libc.Int32FromUint8(d[int32(3)])-int32(0x20))&int32(0x3F))
					lineLen--
				}
			}
		}
		/*
		 * If we've reached the end of the line, skip until we process a
		 * newline.
		 */
		if lineLen == 0 && data < dataend {
			lineLen = -int32(1)
			for cond := true; cond; cond = data < dataend {
				v14 = data
				data++
				c = *(*uint8)(unsafe.Pointer(v14))
				if libc.Int32FromUint8(c) == int32('\n') {
					break
				} else {
					if libc.Int32FromUint8(c) >= int32(32) && libc.Int32FromUint8(c) <= int32(96) {
						data--
						break
					} else {
						if strict != 0 || !(XTclIsSpaceProc(tls, libc.Int32FromUint8(c)) != 0) {
							goto badUu
						}
					}
				}
			}
		}
	}
	/*
	 * Sanity check, clean up and finish.
	 */
	if lineLen > 0 && strict != 0 {
		goto shortUu
	}
	XTcl_SetByteArrayLength(tls, resultObj, int64(cursor)-int64(begin))
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
	goto shortUu
shortUu:
	;
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+11298, 0))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+32, __ccgo_ts+2004, __ccgo_ts+11120, __ccgo_ts+11127, __ccgo_ts+11318, libc.UintptrFromInt32(0)))
	v16 = resultObj
	v15 = *(*TTcl_Size)(unsafe.Pointer(v16))
	*(*TTcl_Size)(unsafe.Pointer(v16))--
	if !(v15 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v17 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v17 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v17 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, resultObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(resultObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = resultObj
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, resultObj)
		}
	}
	return int32(TCL_ERROR)
	goto badUu
badUu:
	;
	if pure != 0 {
		*(*int32)(unsafe.Pointer(bp + 16)) = libc.Int32FromUint8(c)
	} else {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(data - libc.UintptrFromInt32(1)))) < int32(0x80) {
			*(*int32)(unsafe.Pointer(bp + 16)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(data - libc.UintptrFromInt32(1))))
			_ = libc.Int32FromInt32(1)
		} else {
			XTcl_UtfToUniChar(tls, data-libc.UintptrFromInt32(1), bp+16)
		}
	}
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+11324, libc.VaList(bp+32, *(*int32)(unsafe.Pointer(bp + 16)), *(*int32)(unsafe.Pointer(bp + 16)), int64(data)-int64(datastart)-int64(1))))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+32, __ccgo_ts+2004, __ccgo_ts+11120, __ccgo_ts+11127, __ccgo_ts+11134, libc.UintptrFromInt32(0)))
	v20 = resultObj
	v19 = *(*TTcl_Size)(unsafe.Pointer(v20))
	*(*TTcl_Size)(unsafe.Pointer(v20))--
	if !(v19 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v21 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v21 {
				cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v21 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, resultObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(resultObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = resultObj
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, resultObj)
		}
	}
	return int32(TCL_ERROR)
}

var _optStrings3 = [2]uintptr{
	0: __ccgo_ts + 11034,
	1: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * BinaryDecode64 --
 *
 *	Decode a base64 encoded string.
 *
 * Results:
 *	Interp result set to an byte array object
 *
 * Side effects:
 *	None
 *
 *----------------------------------------------------------------------
 */

func _BinaryDecode64(tls *libc.TLS, dummy3058 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var begin, cachePtr, cachePtr1, cursor, data, dataend, datastart, resultObj, v12, v3, v4, v6, v7, v8, v9 uintptr
	var c uint8
	var cut, i, pure, strict int32
	var size, v11 TTcl_Size
	var value uint64
	var v13, v2 bool
	var _ /* count at bp+8 */ TTcl_Size
	var _ /* index at bp+0 */ int32
	var _ /* ucs4 at bp+16 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = begin, c, cachePtr, cachePtr1, cursor, cut, data, dataend, datastart, i, pure, resultObj, size, strict, value, v11, v12, v13, v2, v3, v4, v6, v7, v8, v9
	resultObj = libc.UintptrFromInt32(0)
	c = uint8('\000')
	begin = libc.UintptrFromInt32(0)
	cursor = libc.UintptrFromInt32(0)
	pure = int32(1)
	strict = 0
	cut = 0
	*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0
	if objc < int32(2) || objc > int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+11042)
		return int32(TCL_ERROR)
	}
	i = int32(1)
	for {
		if !(i < objc-int32(1)) {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_optStrings4)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(TCL_EXACT)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
			return int32(TCL_ERROR)
		}
		switch *(*int32)(unsafe.Pointer(bp)) {
		case 0:
			strict = int32(1)
			break
		}
		goto _1
	_1:
		;
		i++
	}
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	data = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), bp+8)
	if data == libc.UintptrFromInt32(0) {
		pure = 0
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))).Flength
			v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), bp+8)
		}
		data = v3
	}
	datastart = data
	dataend = data + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
	size = (*(*TTcl_Size)(unsafe.Pointer(bp + 8)) + int64(3)) & int64(^libc.Int32FromInt32(3)) * int64(3) / int64(4)
	v4 = XTcl_SetByteArrayLength(tls, resultObj, size)
	cursor = v4
	begin = v4
	for data < dataend {
		value = uint64(0)
		/*
		 * Decode the current block. Each base64 block consists of four input
		 * characters A-Z, a-z, 0-9, +, or /. Each character supplies six bits
		 * of output data, so each block's output is 24 bits (three bytes) in
		 * length. The final block can be shorter by one or two bytes, denoted
		 * by the input ending with one or two ='s, respectively.
		 */
		i = 0
		for {
			if !(i < int32(4)) {
				break
			}
			/*
			 * Get the next input character. At end of input, pad with at most
			 * two ='s. If more than two ='s would be needed, instead discard
			 * the block read thus far.
			 */
			if data < dataend {
				v6 = data
				data++
				c = *(*uint8)(unsafe.Pointer(v6))
			} else {
				if i > int32(1) {
					c = uint8('=')
				} else {
					if strict != 0 && i <= int32(1) {
						/*
						 * Single resp. unfulfilled char (each 4th next single
						 * char) is rather bad64 error case in strict mode.
						 */
						goto bad64
					}
					cut += int32(3)
					break
				}
			}
			/*
			 * Load the character into the block value. Handle ='s specially
			 * because they're only valid as the last character or two of the
			 * final block of input. Unless strict mode is enabled, skip any
			 * input whitespace characters.
			 */
			if cut != 0 {
				if libc.Int32FromUint8(c) == int32('=') && i > int32(1) {
					value <<= uint64(6)
					cut++
				} else {
					if !(strict != 0) {
						i--
					} else {
						goto bad64
					}
				}
			} else {
				if libc.Int32FromUint8(c) >= int32('A') && libc.Int32FromUint8(c) <= int32('Z') {
					value = value<<int32(6) | libc.Uint64FromInt32((libc.Int32FromUint8(c)-libc.Int32FromUint8('A'))&libc.Int32FromInt32(0x3F))
				} else {
					if libc.Int32FromUint8(c) >= int32('a') && libc.Int32FromUint8(c) <= int32('z') {
						value = value<<int32(6) | libc.Uint64FromInt32((libc.Int32FromUint8(c)-libc.Int32FromUint8('a')+libc.Int32FromInt32(26))&libc.Int32FromInt32(0x3F))
					} else {
						if libc.Int32FromUint8(c) >= int32('0') && libc.Int32FromUint8(c) <= int32('9') {
							value = value<<int32(6) | libc.Uint64FromInt32((libc.Int32FromUint8(c)-libc.Int32FromUint8('0')+libc.Int32FromInt32(52))&libc.Int32FromInt32(0x3F))
						} else {
							if libc.Int32FromUint8(c) == int32('+') {
								value = value<<int32(6) | uint64(0x3E)
							} else {
								if libc.Int32FromUint8(c) == int32('/') {
									value = value<<int32(6) | uint64(0x3F)
								} else {
									if libc.Int32FromUint8(c) == int32('=') && (!(strict != 0) || i > int32(1)) {
										/*
										 * "=" and "a=" is rather bad64 error case in strict mode.
										 */
										value <<= uint64(6)
										if i != 0 {
											cut++
										}
									} else {
										if strict != 0 {
											goto bad64
										} else {
											i--
										}
									}
								}
							}
						}
					}
				}
			}
			goto _5
		_5:
			;
			i++
		}
		v7 = cursor
		cursor++
		*(*uint8)(unsafe.Pointer(v7)) = uint8(value >> libc.Int32FromInt32(16) & libc.Uint64FromInt32(0xFF))
		v8 = cursor
		cursor++
		*(*uint8)(unsafe.Pointer(v8)) = uint8(value >> libc.Int32FromInt32(8) & libc.Uint64FromInt32(0xFF))
		v9 = cursor
		cursor++
		*(*uint8)(unsafe.Pointer(v9)) = uint8(value & libc.Uint64FromInt32(0xFF))
		/*
		 * Since = is only valid within the final block, if it was encountered
		 * but there are still more input characters, confirm that strict mode
		 * is off and all subsequent characters are whitespace.
		 */
		if cut != 0 && data < dataend {
			if strict != 0 {
				goto bad64
			}
		}
	}
	XTcl_SetByteArrayLength(tls, resultObj, int64(cursor)-int64(begin)-int64(cut))
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
	goto bad64
bad64:
	;
	if pure != 0 {
		*(*int32)(unsafe.Pointer(bp + 16)) = libc.Int32FromUint8(c)
	} else {
		/* The decoder is byte-oriented. If we saw a byte that's not a
		 * valid member of the base64 alphabet, it could be the lead byte
		 * of a multi-byte character. */
		/* Safe because we know data is NUL-terminated */
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(data - libc.UintptrFromInt32(1)))) < int32(0x80) {
			*(*int32)(unsafe.Pointer(bp + 16)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(data - libc.UintptrFromInt32(1))))
			_ = libc.Int32FromInt32(1)
		} else {
			XTcl_UtfToUniChar(tls, data-libc.UintptrFromInt32(1), bp+16)
		}
	}
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+11381, libc.VaList(bp+32, *(*int32)(unsafe.Pointer(bp + 16)), *(*int32)(unsafe.Pointer(bp + 16)), int64(data)-int64(datastart)-int64(1))))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+32, __ccgo_ts+2004, __ccgo_ts+11120, __ccgo_ts+11127, __ccgo_ts+11134, libc.UintptrFromInt32(0)))
	v12 = resultObj
	v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
	*(*TTcl_Size)(unsafe.Pointer(v12))--
	if !(v11 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v13 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v13 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v13 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, resultObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(resultObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = resultObj
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, resultObj)
		}
	}
	return int32(TCL_ERROR)
}

var _optStrings4 = [2]uintptr{
	0: __ccgo_ts + 11034,
	1: libc.UintptrFromInt32(0),
}

const FALSE = 0
const FLT_MAX2 = 0
const TRUE = 1

/* This is the !TCL_MEM_DEBUG case */

/*
 *----------------------------------------------------------------------
 *
 * Tcl_Alloc --
 *
 *	Interface to TclpAlloc when TCL_MEM_DEBUG is disabled. It does check
 *	that memory was actually allocated.
 *
 *----------------------------------------------------------------------
 */

func XTcl_Alloc(tls *libc.TLS, size Tsize_t) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var result uintptr
	_ = result
	result = XTclpAlloc(tls, size)
	/*
	 * Most systems will not alloc(0), instead bumping it to one so that NULL
	 * isn't returned. Some systems (AIX, Tru64) will alloc(0) by returning
	 * NULL, so we have to check that the NULL we get is not in response to
	 * alloc(0).
	 *
	 * The ANSI spec actually says that systems either return NULL *or* a
	 * special pointer on failure, but we only check for NULL
	 */
	if result == libc.UintptrFromInt32(0) && size != 0 {
		XTcl_Panic(tls, __ccgo_ts+10479, libc.VaList(bp+8, size))
	}
	return result
}

func XTcl_DbCkalloc(tls *libc.TLS, size Tsize_t, file uintptr, line int32) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var result uintptr
	_ = result
	result = XTclpAlloc(tls, size)
	if result == libc.UintptrFromInt32(0) && size != 0 {
		libc.Xfflush(tls, libc.Xstdout)
		XTcl_Panic(tls, __ccgo_ts+11436, libc.VaList(bp+8, size, file, line))
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_AttemptAlloc --
 *
 *	Interface to TclpAlloc when TCL_MEM_DEBUG is disabled. It does not
 *	check that memory was actually allocated.
 *
 *----------------------------------------------------------------------
 */

func XTcl_AttemptAlloc(tls *libc.TLS, size Tsize_t) (r uintptr) {
	return XTclpAlloc(tls, size)
}

func XTcl_AttemptDbCkalloc(tls *libc.TLS, size Tsize_t, dummy1090 uintptr, dummy1091 int32) (r uintptr) {
	return XTclpAlloc(tls, size)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_Realloc --
 *
 *	Interface to TclpRealloc when TCL_MEM_DEBUG is disabled. It does check
 *	that memory was actually allocated.
 *
 *----------------------------------------------------------------------
 */

func XTcl_Realloc(tls *libc.TLS, ptr uintptr, size Tsize_t) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var result uintptr
	_ = result
	result = XTclpRealloc(tls, ptr, size)
	if result == libc.UintptrFromInt32(0) && size != 0 {
		XTcl_Panic(tls, __ccgo_ts+11474, libc.VaList(bp+8, size))
	}
	return result
}

func XTcl_DbCkrealloc(tls *libc.TLS, ptr uintptr, size Tsize_t, file uintptr, line int32) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var result uintptr
	_ = result
	result = XTclpRealloc(tls, ptr, size)
	if result == libc.UintptrFromInt32(0) && size != 0 {
		libc.Xfflush(tls, libc.Xstdout)
		XTcl_Panic(tls, __ccgo_ts+11502, libc.VaList(bp+8, size, file, line))
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_AttemptRealloc --
 *
 *	Interface to TclpRealloc when TCL_MEM_DEBUG is disabled. It does not
 *	check that memory was actually allocated.
 *
 *----------------------------------------------------------------------
 */

func XTcl_AttemptRealloc(tls *libc.TLS, ptr uintptr, size Tsize_t) (r uintptr) {
	return XTclpRealloc(tls, ptr, size)
}

func XTcl_AttemptDbCkrealloc(tls *libc.TLS, ptr uintptr, size Tsize_t, dummy1160 uintptr, dummy1161 int32) (r uintptr) {
	return XTclpRealloc(tls, ptr, size)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_Free --
 *
 *	Interface to TclpFree when TCL_MEM_DEBUG is disabled. Done here rather
 *	in the macro to keep some modules from being compiled with
 *	TCL_MEM_DEBUG enabled and some with it disabled.
 *
 *----------------------------------------------------------------------
 */

func XTcl_Free(tls *libc.TLS, ptr uintptr) {
	XTclpFree(tls, ptr)
}

func XTcl_DbCkfree(tls *libc.TLS, ptr uintptr, dummy1188 uintptr, dummy1189 int32) {
	XTclpFree(tls, ptr)
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * Tcl_InitMemory --
//	 *
//	 *	Dummy initialization for memory command, which is only available if
//	 *	TCL_MEM_DEBUG is on.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func XTcl_InitMemory(tls *libc.TLS, dummy1206 uintptr) {
}

func XTcl_DumpActiveMemory(tls *libc.TLS, dummy1212 uintptr) (r int32) {
	return TCL_OK
}

func XTcl_ValidateAllMemory(tls *libc.TLS, dummy1219 uintptr, dummy1220 int32) {
}

func XTclDumpMemoryInfo(tls *libc.TLS, dummy1226 uintptr, dummy1227 int32) (r int32) {
	return int32(1)
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * TclAllocElemsEx --
//	 *
//	 *    See TclAttemptAllocElemsEx. This function differs in that it panics
//	 *    on failure.
//	 *
//	 * Results:
//	 *    Non-NULL pointer to allocated memory block.
//	 *
//	 * Side effects:
//	 *    Panics if memory of at least the requested size could not be
//	 *    allocated.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func XTclAllocElemsEx(tls *libc.TLS, elemCount TTcl_Size, elemSize TTcl_Size, leadSize TTcl_Size, capacityPtr uintptr) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* OUTPUT: Actual capacity is stored here if
	 * non-NULL. Only modified on success */
	var ptr uintptr
	_ = ptr
	ptr = XTclAttemptReallocElemsEx(tls, libc.UintptrFromInt32(0), elemCount, elemSize, leadSize, capacityPtr)
	if ptr == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+11542, libc.VaList(bp+8, elemCount, elemSize))
	}
	return ptr
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * TclAttemptReallocElemsEx --
//	 *
//	 *    Attempts to allocate (oldPtr == NULL) or reallocate memory of the
//	 *    requested size plus some more for future growth. The amount of
//	 *    reallocation is adjusted depending on failure.
//	 *
//	 *
//	 * Results:
//	 *    Pointer to allocated memory block which is at least as large
//	 *    as the requested size or NULL if allocation failed.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func XTclAttemptReallocElemsEx(tls *libc.TLS, oldPtr uintptr, elemCount TTcl_Size, elemSize TTcl_Size, leadSize TTcl_Size, capacityPtr uintptr) (r uintptr) {
	/* OUTPUT: Actual capacity is stored here if
	 * non-NULL. Only modified on success */
	var attempt, limit1, v1, v2, v3, v5, v6, v7 TTcl_Size
	var ptr uintptr
	_, _, _, _, _, _, _, _, _ = attempt, limit1, ptr, v1, v2, v3, v5, v6, v7
	limit1 = (libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)) - leadSize) / elemSize
	if elemCount > limit1 {
		return libc.UintptrFromInt32(0)
	}
	/* Loop trying for extra space, reducing request each time */
	v1 = elemCount
	v2 = limit1
	if v1 < v2-v1/libc.Int64FromInt32(2) {
		v3 = v1 + v1/int64(2)
		goto _4
	} else {
		v3 = v2
		goto _4
	}
_4:
	attempt = v3
	ptr = libc.UintptrFromInt32(0)
	for attempt > elemCount {
		if oldPtr != 0 {
			ptr = XTcl_AttemptRealloc(tls, oldPtr, libc.Uint64FromInt64(leadSize+attempt*elemSize))
		} else {
			ptr = XTcl_AttemptAlloc(tls, libc.Uint64FromInt64(leadSize+attempt*elemSize))
		}
		if ptr != 0 {
			break
		}
		v5 = elemCount
		v6 = attempt
		if v5 < v6-libc.Int64FromInt32(1) {
			v7 = v5 + (v6-v5)/int64(2)
			goto _8
		} else {
			v7 = v5
			goto _8
		}
	_8:
		attempt = v7
	}
	/* Try exact size as a last resort */
	if ptr == libc.UintptrFromInt32(0) {
		attempt = elemCount
		if oldPtr != 0 {
			ptr = XTcl_AttemptRealloc(tls, oldPtr, libc.Uint64FromInt64(leadSize+attempt*elemSize))
		} else {
			ptr = XTcl_AttemptAlloc(tls, libc.Uint64FromInt64(leadSize+attempt*elemSize))
		}
	}
	if ptr != 0 && capacityPtr != 0 {
		*(*TTcl_Size)(unsafe.Pointer(capacityPtr)) = attempt
	}
	return ptr
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * TclReallocElemsEx --
//	 *
//	 *    See TclAttemptReallocElemsEx. This function differs in that it panics
//	 *    on failure.
//	 *
//	 * Results:
//	 *    Non-NULL pointer to allocated memory block.
//	 *
//	 * Side effects:
//	 *    Panics if memory of at least the requested size could not be
//	 *    allocated.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func XTclReallocElemsEx(tls *libc.TLS, oldPtr uintptr, elemCount TTcl_Size, elemSize TTcl_Size, leadSize TTcl_Size, capacityPtr uintptr) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* OUTPUT: Actual capacity is stored here if
	 * non-NULL. Only modified on success */
	var ptr uintptr
	_ = ptr
	ptr = XTclAttemptReallocElemsEx(tls, oldPtr, elemCount, elemSize, leadSize, capacityPtr)
	if ptr == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+11593, libc.VaList(bp+8, elemCount, elemSize))
	}
	return ptr
}

/*
 *---------------------------------------------------------------------------
 *
 * TclFinalizeMemorySubsystem --
 *
 *	This procedure is called to finalize all the structures that are used
 *	by the memory allocator on a per-process basis.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	This subsystem is self-initializing, since memory can be allocated
 *	before Tcl is formally initialized. After this call, this subsystem
 *	has been reset to its initial state and is usable again.
 *
 *---------------------------------------------------------------------------
 */

func XTclFinalizeMemorySubsystem(tls *libc.TLS) {
}

const CLOCK_FMT_SCN_STORAGE_GC_SIZE = 32
const CLOCK_MIN_TOK_CHAIN_BLOCK_SIZE = 2
const ClockDefaultCenturySwitch = 38
const ClockDefaultYearCentury = 2000
const FOUR_CENTURIES = 146097
const FOUR_YEARS = 1461
const GREGORIAN_CHANGE_DATE = 2361222
const JDAY_1_JAN_1_CE_GREGORIAN = 1721426
const JDAY_1_JAN_1_CE_JULIAN = 1721424
const JULIAN_DAY_POSIX_EPOCH = 2440588
const MAX_FMT_RESULT_THRESHOLD = 2
const MIN_FMT_RESULT_BLOCK_ALLOC = 80
const MIN_FMT_RESULT_BLOCK_DELTA = 0
const ONE_CENTURY_GREGORIAN = 36524
const ONE_YEAR = 365
const RODDENBERRY = 1946
const SECONDS_PER_DAY = 86400
const TCL_CLOCK_PREFIX_LEN = 14
const TCL_INV_SECONDS = -67553994410557441
const TCL_MAX_SECONDS = 67553994410557440
const TCL_MIN_SECONDS = -67553994410557440
const WCHAR = 0
const wcscmp = 0
const wcscpy = 0
const wcslen = 0

type TTclStrIdx = struct {
	FchildTree TTclStrIdxTree
	FnextPtr   uintptr
	FprevPtr   uintptr
	Fkey       uintptr
	Flength    TTcl_Size
	Fvalue     uintptr
}

type TTclStrIdxTree = struct {
	FfirstPtr uintptr
	FlastPtr  uintptr
}

type TTclStrIdx1 = struct {
	FchildTree TTclStrIdxTree
	FnextPtr   uintptr
	FprevPtr   uintptr
	Fkey       uintptr
	Flength    TTcl_Size
	Fvalue     uintptr
}

type DateInfoFlags = int32

const CLF_OPTIONAL = 1
const CLF_POSIXSEC = 2
const CLF_LOCALSEC = 4
const CLF_JULIANDAY = 8
const CLF_TIME = 16
const CLF_ZONE = 32
const CLF_CENTURY = 64
const CLF_DAYOFMONTH = 128
const CLF_DAYOFYEAR = 256
const CLF_MONTH = 512
const CLF_YEAR = 1024
const CLF_DAYOFWEEK = 2048
const CLF_ISO8601YEAR = 4096
const CLF_ISO8601WEEK = 8192
const CLF_ISO8601CENTURY = 16384
const CLF_SIGNED = 32768
const CLF_HAVEDATE = 1664
const CLF_DATE = 16264
const CLF_RELCONV = 131072
const CLF_ORDINALMONTH = 262144
const CLF_ASSEMBLE_DATE = 268435456
const CLF_ASSEMBLE_JULIANDAY = 536870912
const CLF_ASSEMBLE_SECONDS = 1073741824

type TClockLiteral = int32

type ClockLiteral = int32

const LIT__NIL = 0
const LIT__DEFAULT_FORMAT = 1
const LIT_SYSTEM = 2
const LIT_CURRENT = 3
const LIT_C = 4
const LIT_BCE = 5
const LIT_CE = 6
const LIT_DAYOFMONTH = 7
const LIT_DAYOFWEEK = 8
const LIT_DAYOFYEAR = 9
const LIT_ERA = 10
const LIT_GMT = 11
const LIT_GREGORIAN = 12
const LIT_INTEGER_VALUE_TOO_LARGE = 13
const LIT_ISO8601WEEK = 14
const LIT_ISO8601YEAR = 15
const LIT_JULIANDAY = 16
const LIT_LOCALSECONDS = 17
const LIT_MONTH = 18
const LIT_SECONDS = 19
const LIT_TZNAME = 20
const LIT_TZOFFSET = 21
const LIT_YEAR = 22
const LIT_TZDATA = 23
const LIT_GETSYSTEMTIMEZONE = 24
const LIT_SETUPTIMEZONE = 25
const LIT_MCGET = 26
const LIT_GETSYSTEMLOCALE = 27
const LIT_GETCURRENTLOCALE = 28
const LIT_LOCALIZE_FORMAT = 29
const LIT__END = 30

type TClockMsgCtLiteral = int32

type ClockMsgCtLiteral = int32

const MCLIT__NIL = 0
const MCLIT_MONTHS_FULL = 1
const MCLIT_MONTHS_ABBREV = 2
const MCLIT_MONTHS_COMB = 3
const MCLIT_DAYS_OF_WEEK_FULL = 4
const MCLIT_DAYS_OF_WEEK_ABBREV = 5
const MCLIT_DAYS_OF_WEEK_COMB = 6
const MCLIT_AM = 7
const MCLIT_PM = 8
const MCLIT_LOCALE_ERAS = 9
const MCLIT_BCE = 10
const MCLIT_CE = 11
const MCLIT_BCE2 = 12
const MCLIT_CE2 = 13
const MCLIT_BCE3 = 14
const MCLIT_CE3 = 15
const MCLIT_LOCALE_NUMERALS = 16
const MCLIT__END = 17

type TclDateFieldsFlags = int32

const CLF_CTZ = 16

type TTclDateFields = struct {
	Fseconds      TTcl_WideInt
	FlocalSeconds TTcl_WideInt
	FtzOffset     int32
	FjulianDay    TTcl_WideInt
	FisBce        int32
	Fgregorian    int32
	Fyear         int32
	FdayOfYear    int32
	Fmonth        int32
	FdayOfMonth   int32
	Fiso8601Year  int32
	Fiso8601Week  int32
	FdayOfWeek    int32
	Fhour         int32
	Fminutes      int32
	FsecondOfMin  TTcl_WideInt
	FsecondOfDay  TTcl_WideInt
	Fflags        int32
	FtzName       uintptr
}

type TMERIDIAN = int32

type _MERIDIAN = int32

const MERam = 0
const MERpm = 1
const MER24 = 2

type TDateInfo = struct {
	FdateStart            uintptr
	FdateInput            uintptr
	FdateEnd              uintptr
	Fdate                 TTclDateFields
	Fflags                int32
	FerrFlags             int32
	FdateMeridian         TMERIDIAN
	FdateTimezone         int32
	FdateDSTmode          int32
	FdateRelMonth         TTcl_WideInt
	FdateRelDay           TTcl_WideInt
	FdateRelSeconds       TTcl_WideInt
	FdateMonthOrdinalIncr int32
	FdateMonthOrdinal     int32
	FdateDayOrdinal       int32
	FdateRelPointer       uintptr
	FdateSpaceCount       int32
	FdateDigitCount       int32
	FdateCentury          int32
	Fmessages             uintptr
	Fseparatrix           uintptr
}

type ClockFmtScnCmdArgsFlags = int32

const CLF_VALIDATE_S1 = 1
const CLF_VALIDATE_S2 = 2
const CLF_VALIDATE = 3
const CLF_EXTENDED = 16
const CLF_STRICT = 256
const CLF_LOCALE_USED = 32768

type TClockClientData = struct {
	FrefCount                Tsize_t
	Fliterals                uintptr
	FmcLiterals              uintptr
	FmcLitIdxs               uintptr
	FmcDicts                 uintptr
	FlastTZEpoch             Tsize_t
	FcurrentYearCentury      int32
	FyearOfCenturySwitch     int32
	FvalidMinYear            int32
	FvalidMaxYear            int32
	FmaxJDN                  float64
	FsystemTimeZone          uintptr
	FsystemSetupTZData       uintptr
	FgmtSetupTimeZoneUnnorm  uintptr
	FgmtSetupTimeZone        uintptr
	FgmtSetupTZData          uintptr
	FgmtTZName               uintptr
	FlastSetupTimeZoneUnnorm uintptr
	FlastSetupTimeZone       uintptr
	FlastSetupTZData         uintptr
	FprevSetupTimeZoneUnnorm uintptr
	FprevSetupTimeZone       uintptr
	FprevSetupTZData         uintptr
	FdefaultLocale           uintptr
	FdefaultLocaleDict       uintptr
	FcurrentLocale           uintptr
	FcurrentLocaleDict       uintptr
	FlastUsedLocaleUnnorm    uintptr
	FlastUsedLocale          uintptr
	FlastUsedLocaleDict      uintptr
	FprevUsedLocaleUnnorm    uintptr
	FprevUsedLocale          uintptr
	FprevUsedLocaleDict      uintptr
	FlastBase                struct {
		FtimezoneObj uintptr
		Fdate        TTclDateFields
	}
	FlastTZOffsCache [2]TClockLastTZOffs
	FdefFlags        int32
}

type TClockFmtScnCmdArgs = struct {
	FdataPtr     uintptr
	Finterp      uintptr
	FformatObj   uintptr
	FlocaleObj   uintptr
	FtimezoneObj uintptr
	FbaseObj     uintptr
	Fflags       int32
	FmcDictObj   uintptr
}

type TClockLastTZOffs = struct {
	FtimezoneObj  uintptr
	Fchangeover   int32
	FlocalSeconds TTcl_WideInt
	FrangesVal    [2]TTcl_WideInt
	FtzOffset     int32
	FtzName       uintptr
}

type TClockScanToken = struct {
	Fmap1    uintptr
	FtokWord struct {
		Fstart uintptr
		Fend   uintptr
	}
	FendDistance uint16
	FlookAhMin   uint16
	FlookAhMax   uint16
	FlookAhTok   uint16
}

type TCLCKTOK_TYPE = int32

type _CLCKTOK_TYPE = int32

const CTOKT_INT = 1
const CTOKT_WIDE = 2
const CTOKT_PARSER = 3
const CTOKT_SPACE = 4
const CTOKT_WORD = 5
const CTOKT_CHAR = 6
const CFMTT_PROC = 7

type TClockScanTokenMap = struct {
	Ftype1      uint16
	Fflags      uint16
	FclearFlags uint16
	FminSize    uint16
	FmaxSize    uint16
	Foffs       uint16
	Fparser     uintptr
	Fdata       uintptr
}

type TClockScanToken1 = struct {
	Fmap1    uintptr
	FtokWord struct {
		Fstart uintptr
		Fend   uintptr
	}
	FendDistance uint16
	FlookAhMin   uint16
	FlookAhMax   uint16
	FlookAhTok   uint16
}

type TDateFormat = struct {
	FresMem    uintptr
	FresEnd    uintptr
	Foutput    uintptr
	Fdate      TTclDateFields
	FlocaleEra uintptr
}

type ClockFormatTokenMapFlags = int32

const CLFMT_INCR = 8
const CLFMT_DECR = 16
const CLFMT_CALC = 32
const CLFMT_LOCALE_INDX = 256

type TClockFormatToken = struct {
	Fmap1    uintptr
	FtokWord struct {
		Fstart uintptr
		Fend   uintptr
	}
}

type TClockFormatTokenMap = struct {
	Ftype1   uint16
	Ftostr   uintptr
	Fwidth   uint16
	Fflags   uint16
	Fdivider uint16
	Fdivmod  uint16
	Foffs    uint16
	Ffmtproc uintptr
	Fdata    uintptr
}

type TClockFormatToken1 = struct {
	Fmap1    uintptr
	FtokWord struct {
		Fstart uintptr
		Fend   uintptr
	}
}

type TClockFmtScnStorage = struct {
	FobjRefCount   int32
	FscnTok        uintptr
	FscnTokC       uint32
	FscnSpaceCount uint32
	FfmtTok        uintptr
	FfmtTokC       uint32
	FnextPtr       uintptr
	FprevPtr       uintptr
	FfmtMinAlloc   Tsize_t
}

type TClockFmtScnStorage1 = struct {
	FobjRefCount   int32
	FscnTok        uintptr
	FscnTokC       uint32
	FscnSpaceCount uint32
	FfmtTok        uintptr
	FfmtTokC       uint32
	FnextPtr       uintptr
	FprevPtr       uintptr
	FfmtMinAlloc   Tsize_t
}

/*
 * Table of the days in each month, leap and common years
 */

var _hath = [2][12]int32{
	0: {
		0:  int32(31),
		1:  int32(28),
		2:  int32(31),
		3:  int32(30),
		4:  int32(31),
		5:  int32(30),
		6:  int32(31),
		7:  int32(31),
		8:  int32(30),
		9:  int32(31),
		10: int32(30),
		11: int32(31),
	},
	1: {
		0:  int32(31),
		1:  int32(29),
		2:  int32(31),
		3:  int32(30),
		4:  int32(31),
		5:  int32(30),
		6:  int32(31),
		7:  int32(31),
		8:  int32(30),
		9:  int32(31),
		10: int32(30),
		11: int32(31),
	},
}
var _daysInPriorMonths = [2][13]int32{
	0: {
		1:  int32(31),
		2:  int32(59),
		3:  int32(90),
		4:  int32(120),
		5:  int32(151),
		6:  int32(181),
		7:  int32(212),
		8:  int32(243),
		9:  int32(273),
		10: int32(304),
		11: int32(334),
		12: int32(365),
	},
	1: {
		1:  int32(31),
		2:  int32(60),
		3:  int32(91),
		4:  int32(121),
		5:  int32(152),
		6:  int32(182),
		7:  int32(213),
		8:  int32(244),
		9:  int32(274),
		10: int32(305),
		11: int32(335),
		12: int32(366),
	},
}

/*
 * Enumeration of the string literals used in [clock]
 */
var _Literals = [30]uintptr{
	0:  __ccgo_ts + 1945,
	1:  __ccgo_ts + 11646,
	2:  __ccgo_ts + 5629,
	3:  __ccgo_ts + 11670,
	4:  __ccgo_ts + 11678,
	5:  __ccgo_ts + 11680,
	6:  __ccgo_ts + 11684,
	7:  __ccgo_ts + 11687,
	8:  __ccgo_ts + 11698,
	9:  __ccgo_ts + 11708,
	10: __ccgo_ts + 11718,
	11: __ccgo_ts + 11722,
	12: __ccgo_ts + 11727,
	13: __ccgo_ts + 11737,
	14: __ccgo_ts + 11774,
	15: __ccgo_ts + 11786,
	16: __ccgo_ts + 11798,
	17: __ccgo_ts + 11808,
	18: __ccgo_ts + 11821,
	19: __ccgo_ts + 11827,
	20: __ccgo_ts + 11835,
	21: __ccgo_ts + 11842,
	22: __ccgo_ts + 11851,
	23: __ccgo_ts + 11856,
	24: __ccgo_ts + 11877,
	25: __ccgo_ts + 11909,
	26: __ccgo_ts + 11937,
	27: __ccgo_ts + 11957,
	28: __ccgo_ts + 11987,
	29: __ccgo_ts + 12010,
}

// C documentation
//
//	/* Msgcat literals for exact match (mcKey) */
var _MsgCtLiterals = [17]uintptr{
	0:  __ccgo_ts + 1945,
	1:  __ccgo_ts + 12039,
	2:  __ccgo_ts + 12051,
	3:  __ccgo_ts + 12065,
	4:  __ccgo_ts + 12077,
	5:  __ccgo_ts + 12095,
	6:  __ccgo_ts + 12115,
	7:  __ccgo_ts + 12133,
	8:  __ccgo_ts + 12136,
	9:  __ccgo_ts + 12139,
	10: __ccgo_ts + 11680,
	11: __ccgo_ts + 11684,
	12: __ccgo_ts + 12151,
	13: __ccgo_ts + 12158,
	14: __ccgo_ts + 12163,
	15: __ccgo_ts + 12168,
	16: __ccgo_ts + 12173,
}

// C documentation
//
//	/* Msgcat index literals prefixed with _IDX_, used for quick dictionary search */
var _MsgCtLitIdxs = [17]uintptr{
	0:  __ccgo_ts + 12189,
	1:  __ccgo_ts + 12195,
	2:  __ccgo_ts + 12212,
	3:  __ccgo_ts + 12231,
	4:  __ccgo_ts + 12248,
	5:  __ccgo_ts + 12271,
	6:  __ccgo_ts + 12296,
	7:  __ccgo_ts + 12319,
	8:  __ccgo_ts + 12327,
	9:  __ccgo_ts + 12335,
	10: __ccgo_ts + 12352,
	11: __ccgo_ts + 12361,
	12: __ccgo_ts + 12369,
	13: __ccgo_ts + 12381,
	14: __ccgo_ts + 12391,
	15: __ccgo_ts + 12401,
	16: __ccgo_ts + 12411,
}

var _eras = [3]uintptr{
	0: __ccgo_ts + 11684,
	1: __ccgo_ts + 11680,
	2: libc.UintptrFromInt32(0),
}

/*
 * Thread specific data block holding a 'struct tm' for the 'gmtime' and
 * 'localtime' library calls.
 */

var _tmKey TTcl_ThreadDataKey

/*
 * Mutex protecting 'gmtime', 'localtime' and 'mktime' calls and the statics
 * in the date parsing code.
 */
var _clockMutex TTcl_Mutex

/*
 * Structure containing description of "native" clock commands to create.
 */

type TClockCommand = struct {
	Fname        uintptr
	FobjCmdProc  uintptr
	FcompileProc uintptr
	FclientData  uintptr
}

var _clockCommands = [14]TClockCommand{
	0: {
		Fname: __ccgo_ts + 2121,
	},
	1: {
		Fname: __ccgo_ts + 12432,
	},
	2: {
		Fname: __ccgo_ts + 5199,
	},
	3: {
		Fname: __ccgo_ts + 12439,
	},
	4: {
		Fname:       __ccgo_ts + 12446,
		FclientData: uintptr(int64(libc.Int32FromInt32(1))),
	},
	5: {
		Fname:       __ccgo_ts + 12459,
		FclientData: uintptr(int64(libc.Int32FromInt32(2))),
	},
	6: {
		Fname: __ccgo_ts + 5378,
	},
	7: {
		Fname:       __ccgo_ts + 11827,
		FclientData: uintptr(int64(libc.Int32FromInt32(3))),
	},
	8: {
		Fname: __ccgo_ts + 12472,
	},
	9: {
		Fname: __ccgo_ts + 12490,
	},
	10: {
		Fname: __ccgo_ts + 12504,
	},
	11: {
		Fname: __ccgo_ts + 12536,
	},
	12: {
		Fname: __ccgo_ts + 5129,
	},
	13: {},
}

func init() {
	p := unsafe.Pointer(&_clockCommands)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_ClockAddObjCmd)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(XTclCompileBasicMin1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 40)) = __ccgo_fp(_ClockClicksObjCmd)
	*(*uintptr)(unsafe.Add(p, 48)) = __ccgo_fp(XTclCompileClockClicksCmd)
	*(*uintptr)(unsafe.Add(p, 72)) = __ccgo_fp(_ClockFormatObjCmd)
	*(*uintptr)(unsafe.Add(p, 80)) = __ccgo_fp(XTclCompileBasicMin1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(_ClockGetenvObjCmd)
	*(*uintptr)(unsafe.Add(p, 112)) = __ccgo_fp(XTclCompileBasicMin1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 136)) = __ccgo_fp(_ClockMicrosecondsObjCmd)
	*(*uintptr)(unsafe.Add(p, 144)) = __ccgo_fp(XTclCompileClockReadingCmd)
	*(*uintptr)(unsafe.Add(p, 168)) = __ccgo_fp(_ClockMillisecondsObjCmd)
	*(*uintptr)(unsafe.Add(p, 176)) = __ccgo_fp(XTclCompileClockReadingCmd)
	*(*uintptr)(unsafe.Add(p, 200)) = __ccgo_fp(_ClockScanObjCmd)
	*(*uintptr)(unsafe.Add(p, 208)) = __ccgo_fp(XTclCompileBasicMin1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 232)) = __ccgo_fp(_ClockSecondsObjCmd)
	*(*uintptr)(unsafe.Add(p, 240)) = __ccgo_fp(XTclCompileClockReadingCmd)
	*(*uintptr)(unsafe.Add(p, 264)) = __ccgo_fp(_ClockConvertlocaltoutcObjCmd)
	*(*uintptr)(unsafe.Add(p, 296)) = __ccgo_fp(_ClockGetdatefieldsObjCmd)
	*(*uintptr)(unsafe.Add(p, 328)) = __ccgo_fp(_ClockGetjuliandayfromerayearmonthdayObjCmd)
	*(*uintptr)(unsafe.Add(p, 360)) = __ccgo_fp(_ClockGetjuliandayfromerayearweekdayObjCmd)
	*(*uintptr)(unsafe.Add(p, 392)) = __ccgo_fp(_ClockSafeCatchCmd)
	*(*uintptr)(unsafe.Add(p, 400)) = __ccgo_fp(XTclCompileBasicMin1ArgCmd)
}

/*
 *----------------------------------------------------------------------
 *
 * TclClockInit --
 *
 *	Registers the 'clock' subcommands with the Tcl interpreter and
 *	initializes its client data (which consists mostly of constant
 *	Tcl_Obj's that it is too much trouble to keep recreating).
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Installs the commands and creates the client data
 *
 *----------------------------------------------------------------------
 */

func XTclClockInit(tls *libc.TLS, interp uintptr) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Tcl interpreter */
	var clientData, clockCmdPtr, cmdPtr, data, v3, v4, v5 uintptr
	var i int32
	var _ /* cmdName at bp+0 */ [50]uint8
	_, _, _, _, _, _, _, _ = clientData, clockCmdPtr, cmdPtr, data, i, v3, v4, v5
	/*
	 * Register handler to finalize clock on exit.
	 */
	if !(_initialized != 0) {
		XTcl_CreateExitHandler(tls, __ccgo_fp(_ClockFinalize), libc.UintptrFromInt32(0))
		_initialized = int32(1)
	}
	/*
	 * Safe interps get [::clock] as alias to a parent, so do not need their
	 * own copies of the support routines.
	 */
	if XTcl_IsSafe(tls, interp) != 0 {
		return
	}
	/*
	 * Create the client data, which is a refcounted literal pool.
	 */
	data = XTcl_Alloc(tls, uint64(488))
	(*TClockClientData)(unsafe.Pointer(data)).FrefCount = uint64(0)
	(*TClockClientData)(unsafe.Pointer(data)).Fliterals = XTcl_Alloc(tls, uint64(LIT__END)*libc.Uint64FromInt64(8))
	i = 0
	for {
		if !(i < int32(LIT__END)) {
			break
		}
		*(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(data)).Fliterals + uintptr(i)*8)) = XTcl_NewStringObj(tls, _Literals[i], int64(-libc.Int32FromInt32(1)))
		if *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(data)).Fliterals + uintptr(i)*8)) != 0 {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(data)).Fliterals + uintptr(i)*8)))).FrefCount++
		}
		goto _1
	_1:
		;
		i++
	}
	(*TClockClientData)(unsafe.Pointer(data)).FmcLiterals = libc.UintptrFromInt32(0)
	(*TClockClientData)(unsafe.Pointer(data)).FmcLitIdxs = libc.UintptrFromInt32(0)
	(*TClockClientData)(unsafe.Pointer(data)).FmcDicts = libc.UintptrFromInt32(0)
	(*TClockClientData)(unsafe.Pointer(data)).FlastTZEpoch = uint64(0)
	(*TClockClientData)(unsafe.Pointer(data)).FcurrentYearCentury = int32(ClockDefaultYearCentury)
	(*TClockClientData)(unsafe.Pointer(data)).FyearOfCenturySwitch = int32(ClockDefaultCenturySwitch)
	(*TClockClientData)(unsafe.Pointer(data)).FvalidMinYear = -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff)
	(*TClockClientData)(unsafe.Pointer(data)).FvalidMaxYear = int32(INT_MAX)
	/* corresponds max of JDN in sqlite - 9999-12-31 23:59:59 per default */
	(*TClockClientData)(unsafe.Pointer(data)).FmaxJDN = float64(5.373484499999994e+06)
	(*TClockClientData)(unsafe.Pointer(data)).FsystemTimeZone = libc.UintptrFromInt32(0)
	(*TClockClientData)(unsafe.Pointer(data)).FsystemSetupTZData = libc.UintptrFromInt32(0)
	(*TClockClientData)(unsafe.Pointer(data)).FgmtSetupTimeZoneUnnorm = libc.UintptrFromInt32(0)
	(*TClockClientData)(unsafe.Pointer(data)).FgmtSetupTimeZone = libc.UintptrFromInt32(0)
	(*TClockClientData)(unsafe.Pointer(data)).FgmtSetupTZData = libc.UintptrFromInt32(0)
	(*TClockClientData)(unsafe.Pointer(data)).FgmtTZName = libc.UintptrFromInt32(0)
	(*TClockClientData)(unsafe.Pointer(data)).FlastSetupTimeZoneUnnorm = libc.UintptrFromInt32(0)
	(*TClockClientData)(unsafe.Pointer(data)).FlastSetupTimeZone = libc.UintptrFromInt32(0)
	(*TClockClientData)(unsafe.Pointer(data)).FlastSetupTZData = libc.UintptrFromInt32(0)
	(*TClockClientData)(unsafe.Pointer(data)).FprevSetupTimeZoneUnnorm = libc.UintptrFromInt32(0)
	(*TClockClientData)(unsafe.Pointer(data)).FprevSetupTimeZone = libc.UintptrFromInt32(0)
	(*TClockClientData)(unsafe.Pointer(data)).FprevSetupTZData = libc.UintptrFromInt32(0)
	(*TClockClientData)(unsafe.Pointer(data)).FdefaultLocale = libc.UintptrFromInt32(0)
	(*TClockClientData)(unsafe.Pointer(data)).FdefaultLocaleDict = libc.UintptrFromInt32(0)
	(*TClockClientData)(unsafe.Pointer(data)).FcurrentLocale = libc.UintptrFromInt32(0)
	(*TClockClientData)(unsafe.Pointer(data)).FcurrentLocaleDict = libc.UintptrFromInt32(0)
	(*TClockClientData)(unsafe.Pointer(data)).FlastUsedLocaleUnnorm = libc.UintptrFromInt32(0)
	(*TClockClientData)(unsafe.Pointer(data)).FlastUsedLocale = libc.UintptrFromInt32(0)
	(*TClockClientData)(unsafe.Pointer(data)).FlastUsedLocaleDict = libc.UintptrFromInt32(0)
	(*TClockClientData)(unsafe.Pointer(data)).FprevUsedLocaleUnnorm = libc.UintptrFromInt32(0)
	(*TClockClientData)(unsafe.Pointer(data)).FprevUsedLocale = libc.UintptrFromInt32(0)
	(*TClockClientData)(unsafe.Pointer(data)).FprevUsedLocaleDict = libc.UintptrFromInt32(0)
	(*TClockClientData)(unsafe.Pointer(data)).FlastBase.FtimezoneObj = libc.UintptrFromInt32(0)
	libc.Xmemset(tls, data+368, 0, uint64(112))
	(*TClockClientData)(unsafe.Pointer(data)).FdefFlags = int32(CLF_VALIDATE)
	/*
	 * Install the commands.
	 */
	libc.Xmemcpy(tls, bp, __ccgo_ts+12567, uint64(TCL_CLOCK_PREFIX_LEN))
	clockCmdPtr = uintptr(unsafe.Pointer(&_clockCommands))
	for {
		if !((*TClockCommand)(unsafe.Pointer(clockCmdPtr)).Fname != libc.UintptrFromInt32(0)) {
			break
		}
		libc.Xstrcpy(tls, bp+uintptr(TCL_CLOCK_PREFIX_LEN), (*TClockCommand)(unsafe.Pointer(clockCmdPtr)).Fname)
		v3 = (*TClockCommand)(unsafe.Pointer(clockCmdPtr)).FclientData
		clientData = v3
		if !(v3 != 0) {
			clientData = data
			(*TClockClientData)(unsafe.Pointer(data)).FrefCount++
		}
		if (*TClockCommand)(unsafe.Pointer(clockCmdPtr)).FclientData != 0 {
			v4 = libc.UintptrFromInt32(0)
		} else {
			v4 = __ccgo_fp(_ClockDeleteCmdProc)
		}
		cmdPtr = XTcl_CreateObjCommand(tls, interp, bp, (*TClockCommand)(unsafe.Pointer(clockCmdPtr)).FobjCmdProc, clientData, v4)
		if (*TClockCommand)(unsafe.Pointer(clockCmdPtr)).FcompileProc != 0 {
			v5 = (*TClockCommand)(unsafe.Pointer(clockCmdPtr)).FcompileProc
		} else {
			v5 = __ccgo_fp(XTclCompileBasicMin0ArgCmd)
		}
		(*TCommand)(unsafe.Pointer(cmdPtr)).FcompileProc = v5
		goto _2
	_2:
		;
		clockCmdPtr += 32
	}
	cmdPtr = XTcl_CreateObjCommand(tls, interp, __ccgo_ts+12582, __ccgo_fp(_ClockConfigureObjCmd), data, __ccgo_fp(_ClockDeleteCmdProc))
	(*TClockClientData)(unsafe.Pointer(data)).FrefCount++
	(*TCommand)(unsafe.Pointer(cmdPtr)).FcompileProc = __ccgo_fp(XTclCompileBasicMin0ArgCmd)
}

var _initialized int32 /* global clock engine initialized (in process) */

/*
 *----------------------------------------------------------------------
 *
 * ClockConfigureClear --
 *
 *	Clean up cached resp. run-time storages used in clock commands.
 *
 *	Shared usage for clean-up (ClockDeleteCmdProc) and "configure -clear".
 *
 * Results:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _ClockConfigureClear(tls *libc.TLS, data uintptr) {
	var _objPtr, _objPtr1, _objPtr10, _objPtr11, _objPtr12, _objPtr13, _objPtr14, _objPtr15, _objPtr16, _objPtr17, _objPtr18, _objPtr19, _objPtr2, _objPtr20, _objPtr21, _objPtr22, _objPtr23, _objPtr3, _objPtr4, _objPtr5, _objPtr6, _objPtr7, _objPtr8, _objPtr9, v10, v12, v14, v16, v18, v2, v20, v22, v24, v26, v28, v30, v32, v34, v36, v38, v4, v40, v42, v44, v46, v48, v6, v8 uintptr
	var v1, v11, v13, v15, v17, v19, v21, v23, v25, v27, v29, v3, v31, v33, v35, v37, v39, v41, v43, v45, v47, v5, v7, v9 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr10, _objPtr11, _objPtr12, _objPtr13, _objPtr14, _objPtr15, _objPtr16, _objPtr17, _objPtr18, _objPtr19, _objPtr2, _objPtr20, _objPtr21, _objPtr22, _objPtr23, _objPtr3, _objPtr4, _objPtr5, _objPtr6, _objPtr7, _objPtr8, _objPtr9, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v5, v6, v7, v8, v9
	XClockFrmScnClearCaches(tls)
	(*TClockClientData)(unsafe.Pointer(data)).FlastTZEpoch = uint64(0)
	if (*TClockClientData)(unsafe.Pointer(data)).FsystemTimeZone != libc.UintptrFromInt32(0) {
		_objPtr = (*TClockClientData)(unsafe.Pointer(data)).FsystemTimeZone
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		(*TClockClientData)(unsafe.Pointer(data)).FsystemTimeZone = libc.UintptrFromInt32(0)
	}
	if (*TClockClientData)(unsafe.Pointer(data)).FsystemSetupTZData != libc.UintptrFromInt32(0) {
		_objPtr1 = (*TClockClientData)(unsafe.Pointer(data)).FsystemSetupTZData
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		(*TClockClientData)(unsafe.Pointer(data)).FsystemSetupTZData = libc.UintptrFromInt32(0)
	}
	if (*TClockClientData)(unsafe.Pointer(data)).FgmtSetupTimeZoneUnnorm != libc.UintptrFromInt32(0) {
		_objPtr2 = (*TClockClientData)(unsafe.Pointer(data)).FgmtSetupTimeZoneUnnorm
		v6 = _objPtr2
		v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
		*(*TTcl_Size)(unsafe.Pointer(v6))--
		if v5 <= int64(1) {
			XTclFreeObj(tls, _objPtr2)
		}
		(*TClockClientData)(unsafe.Pointer(data)).FgmtSetupTimeZoneUnnorm = libc.UintptrFromInt32(0)
	}
	if (*TClockClientData)(unsafe.Pointer(data)).FgmtSetupTimeZone != libc.UintptrFromInt32(0) {
		_objPtr3 = (*TClockClientData)(unsafe.Pointer(data)).FgmtSetupTimeZone
		v8 = _objPtr3
		v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
		*(*TTcl_Size)(unsafe.Pointer(v8))--
		if v7 <= int64(1) {
			XTclFreeObj(tls, _objPtr3)
		}
		(*TClockClientData)(unsafe.Pointer(data)).FgmtSetupTimeZone = libc.UintptrFromInt32(0)
	}
	if (*TClockClientData)(unsafe.Pointer(data)).FgmtSetupTZData != libc.UintptrFromInt32(0) {
		_objPtr4 = (*TClockClientData)(unsafe.Pointer(data)).FgmtSetupTZData
		v10 = _objPtr4
		v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
		*(*TTcl_Size)(unsafe.Pointer(v10))--
		if v9 <= int64(1) {
			XTclFreeObj(tls, _objPtr4)
		}
		(*TClockClientData)(unsafe.Pointer(data)).FgmtSetupTZData = libc.UintptrFromInt32(0)
	}
	if (*TClockClientData)(unsafe.Pointer(data)).FgmtTZName != libc.UintptrFromInt32(0) {
		_objPtr5 = (*TClockClientData)(unsafe.Pointer(data)).FgmtTZName
		v12 = _objPtr5
		v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
		*(*TTcl_Size)(unsafe.Pointer(v12))--
		if v11 <= int64(1) {
			XTclFreeObj(tls, _objPtr5)
		}
		(*TClockClientData)(unsafe.Pointer(data)).FgmtTZName = libc.UintptrFromInt32(0)
	}
	if (*TClockClientData)(unsafe.Pointer(data)).FlastSetupTimeZoneUnnorm != libc.UintptrFromInt32(0) {
		_objPtr6 = (*TClockClientData)(unsafe.Pointer(data)).FlastSetupTimeZoneUnnorm
		v14 = _objPtr6
		v13 = *(*TTcl_Size)(unsafe.Pointer(v14))
		*(*TTcl_Size)(unsafe.Pointer(v14))--
		if v13 <= int64(1) {
			XTclFreeObj(tls, _objPtr6)
		}
		(*TClockClientData)(unsafe.Pointer(data)).FlastSetupTimeZoneUnnorm = libc.UintptrFromInt32(0)
	}
	if (*TClockClientData)(unsafe.Pointer(data)).FlastSetupTimeZone != libc.UintptrFromInt32(0) {
		_objPtr7 = (*TClockClientData)(unsafe.Pointer(data)).FlastSetupTimeZone
		v16 = _objPtr7
		v15 = *(*TTcl_Size)(unsafe.Pointer(v16))
		*(*TTcl_Size)(unsafe.Pointer(v16))--
		if v15 <= int64(1) {
			XTclFreeObj(tls, _objPtr7)
		}
		(*TClockClientData)(unsafe.Pointer(data)).FlastSetupTimeZone = libc.UintptrFromInt32(0)
	}
	if (*TClockClientData)(unsafe.Pointer(data)).FlastSetupTZData != libc.UintptrFromInt32(0) {
		_objPtr8 = (*TClockClientData)(unsafe.Pointer(data)).FlastSetupTZData
		v18 = _objPtr8
		v17 = *(*TTcl_Size)(unsafe.Pointer(v18))
		*(*TTcl_Size)(unsafe.Pointer(v18))--
		if v17 <= int64(1) {
			XTclFreeObj(tls, _objPtr8)
		}
		(*TClockClientData)(unsafe.Pointer(data)).FlastSetupTZData = libc.UintptrFromInt32(0)
	}
	if (*TClockClientData)(unsafe.Pointer(data)).FprevSetupTimeZoneUnnorm != libc.UintptrFromInt32(0) {
		_objPtr9 = (*TClockClientData)(unsafe.Pointer(data)).FprevSetupTimeZoneUnnorm
		v20 = _objPtr9
		v19 = *(*TTcl_Size)(unsafe.Pointer(v20))
		*(*TTcl_Size)(unsafe.Pointer(v20))--
		if v19 <= int64(1) {
			XTclFreeObj(tls, _objPtr9)
		}
		(*TClockClientData)(unsafe.Pointer(data)).FprevSetupTimeZoneUnnorm = libc.UintptrFromInt32(0)
	}
	if (*TClockClientData)(unsafe.Pointer(data)).FprevSetupTimeZone != libc.UintptrFromInt32(0) {
		_objPtr10 = (*TClockClientData)(unsafe.Pointer(data)).FprevSetupTimeZone
		v22 = _objPtr10
		v21 = *(*TTcl_Size)(unsafe.Pointer(v22))
		*(*TTcl_Size)(unsafe.Pointer(v22))--
		if v21 <= int64(1) {
			XTclFreeObj(tls, _objPtr10)
		}
		(*TClockClientData)(unsafe.Pointer(data)).FprevSetupTimeZone = libc.UintptrFromInt32(0)
	}
	if (*TClockClientData)(unsafe.Pointer(data)).FprevSetupTZData != libc.UintptrFromInt32(0) {
		_objPtr11 = (*TClockClientData)(unsafe.Pointer(data)).FprevSetupTZData
		v24 = _objPtr11
		v23 = *(*TTcl_Size)(unsafe.Pointer(v24))
		*(*TTcl_Size)(unsafe.Pointer(v24))--
		if v23 <= int64(1) {
			XTclFreeObj(tls, _objPtr11)
		}
		(*TClockClientData)(unsafe.Pointer(data)).FprevSetupTZData = libc.UintptrFromInt32(0)
	}
	if (*TClockClientData)(unsafe.Pointer(data)).FdefaultLocale != libc.UintptrFromInt32(0) {
		_objPtr12 = (*TClockClientData)(unsafe.Pointer(data)).FdefaultLocale
		v26 = _objPtr12
		v25 = *(*TTcl_Size)(unsafe.Pointer(v26))
		*(*TTcl_Size)(unsafe.Pointer(v26))--
		if v25 <= int64(1) {
			XTclFreeObj(tls, _objPtr12)
		}
		(*TClockClientData)(unsafe.Pointer(data)).FdefaultLocale = libc.UintptrFromInt32(0)
	}
	(*TClockClientData)(unsafe.Pointer(data)).FdefaultLocaleDict = libc.UintptrFromInt32(0)
	if (*TClockClientData)(unsafe.Pointer(data)).FcurrentLocale != libc.UintptrFromInt32(0) {
		_objPtr13 = (*TClockClientData)(unsafe.Pointer(data)).FcurrentLocale
		v28 = _objPtr13
		v27 = *(*TTcl_Size)(unsafe.Pointer(v28))
		*(*TTcl_Size)(unsafe.Pointer(v28))--
		if v27 <= int64(1) {
			XTclFreeObj(tls, _objPtr13)
		}
		(*TClockClientData)(unsafe.Pointer(data)).FcurrentLocale = libc.UintptrFromInt32(0)
	}
	(*TClockClientData)(unsafe.Pointer(data)).FcurrentLocaleDict = libc.UintptrFromInt32(0)
	if (*TClockClientData)(unsafe.Pointer(data)).FlastUsedLocaleUnnorm != libc.UintptrFromInt32(0) {
		_objPtr14 = (*TClockClientData)(unsafe.Pointer(data)).FlastUsedLocaleUnnorm
		v30 = _objPtr14
		v29 = *(*TTcl_Size)(unsafe.Pointer(v30))
		*(*TTcl_Size)(unsafe.Pointer(v30))--
		if v29 <= int64(1) {
			XTclFreeObj(tls, _objPtr14)
		}
		(*TClockClientData)(unsafe.Pointer(data)).FlastUsedLocaleUnnorm = libc.UintptrFromInt32(0)
	}
	if (*TClockClientData)(unsafe.Pointer(data)).FlastUsedLocale != libc.UintptrFromInt32(0) {
		_objPtr15 = (*TClockClientData)(unsafe.Pointer(data)).FlastUsedLocale
		v32 = _objPtr15
		v31 = *(*TTcl_Size)(unsafe.Pointer(v32))
		*(*TTcl_Size)(unsafe.Pointer(v32))--
		if v31 <= int64(1) {
			XTclFreeObj(tls, _objPtr15)
		}
		(*TClockClientData)(unsafe.Pointer(data)).FlastUsedLocale = libc.UintptrFromInt32(0)
	}
	(*TClockClientData)(unsafe.Pointer(data)).FlastUsedLocaleDict = libc.UintptrFromInt32(0)
	if (*TClockClientData)(unsafe.Pointer(data)).FprevUsedLocaleUnnorm != libc.UintptrFromInt32(0) {
		_objPtr16 = (*TClockClientData)(unsafe.Pointer(data)).FprevUsedLocaleUnnorm
		v34 = _objPtr16
		v33 = *(*TTcl_Size)(unsafe.Pointer(v34))
		*(*TTcl_Size)(unsafe.Pointer(v34))--
		if v33 <= int64(1) {
			XTclFreeObj(tls, _objPtr16)
		}
		(*TClockClientData)(unsafe.Pointer(data)).FprevUsedLocaleUnnorm = libc.UintptrFromInt32(0)
	}
	if (*TClockClientData)(unsafe.Pointer(data)).FprevUsedLocale != libc.UintptrFromInt32(0) {
		_objPtr17 = (*TClockClientData)(unsafe.Pointer(data)).FprevUsedLocale
		v36 = _objPtr17
		v35 = *(*TTcl_Size)(unsafe.Pointer(v36))
		*(*TTcl_Size)(unsafe.Pointer(v36))--
		if v35 <= int64(1) {
			XTclFreeObj(tls, _objPtr17)
		}
		(*TClockClientData)(unsafe.Pointer(data)).FprevUsedLocale = libc.UintptrFromInt32(0)
	}
	(*TClockClientData)(unsafe.Pointer(data)).FprevUsedLocaleDict = libc.UintptrFromInt32(0)
	if (*TClockClientData)(unsafe.Pointer(data)).FlastBase.FtimezoneObj != libc.UintptrFromInt32(0) {
		_objPtr18 = (*TClockClientData)(unsafe.Pointer(data)).FlastBase.FtimezoneObj
		v38 = _objPtr18
		v37 = *(*TTcl_Size)(unsafe.Pointer(v38))
		*(*TTcl_Size)(unsafe.Pointer(v38))--
		if v37 <= int64(1) {
			XTclFreeObj(tls, _objPtr18)
		}
		(*TClockClientData)(unsafe.Pointer(data)).FlastBase.FtimezoneObj = libc.UintptrFromInt32(0)
	}
	if (*(*TClockLastTZOffs)(unsafe.Pointer(data + 368))).FtimezoneObj != libc.UintptrFromInt32(0) {
		_objPtr19 = (*(*TClockLastTZOffs)(unsafe.Pointer(data + 368))).FtimezoneObj
		v40 = _objPtr19
		v39 = *(*TTcl_Size)(unsafe.Pointer(v40))
		*(*TTcl_Size)(unsafe.Pointer(v40))--
		if v39 <= int64(1) {
			XTclFreeObj(tls, _objPtr19)
		}
		(*(*TClockLastTZOffs)(unsafe.Pointer(data + 368))).FtimezoneObj = libc.UintptrFromInt32(0)
	}
	if (*(*TClockLastTZOffs)(unsafe.Pointer(data + 368))).FtzName != libc.UintptrFromInt32(0) {
		_objPtr20 = (*(*TClockLastTZOffs)(unsafe.Pointer(data + 368))).FtzName
		v42 = _objPtr20
		v41 = *(*TTcl_Size)(unsafe.Pointer(v42))
		*(*TTcl_Size)(unsafe.Pointer(v42))--
		if v41 <= int64(1) {
			XTclFreeObj(tls, _objPtr20)
		}
		(*(*TClockLastTZOffs)(unsafe.Pointer(data + 368))).FtzName = libc.UintptrFromInt32(0)
	}
	if (*(*TClockLastTZOffs)(unsafe.Pointer(data + 368 + 1*56))).FtimezoneObj != libc.UintptrFromInt32(0) {
		_objPtr21 = (*(*TClockLastTZOffs)(unsafe.Pointer(data + 368 + 1*56))).FtimezoneObj
		v44 = _objPtr21
		v43 = *(*TTcl_Size)(unsafe.Pointer(v44))
		*(*TTcl_Size)(unsafe.Pointer(v44))--
		if v43 <= int64(1) {
			XTclFreeObj(tls, _objPtr21)
		}
		(*(*TClockLastTZOffs)(unsafe.Pointer(data + 368 + 1*56))).FtimezoneObj = libc.UintptrFromInt32(0)
	}
	if (*(*TClockLastTZOffs)(unsafe.Pointer(data + 368 + 1*56))).FtzName != libc.UintptrFromInt32(0) {
		_objPtr22 = (*(*TClockLastTZOffs)(unsafe.Pointer(data + 368 + 1*56))).FtzName
		v46 = _objPtr22
		v45 = *(*TTcl_Size)(unsafe.Pointer(v46))
		*(*TTcl_Size)(unsafe.Pointer(v46))--
		if v45 <= int64(1) {
			XTclFreeObj(tls, _objPtr22)
		}
		(*(*TClockLastTZOffs)(unsafe.Pointer(data + 368 + 1*56))).FtzName = libc.UintptrFromInt32(0)
	}
	if (*TClockClientData)(unsafe.Pointer(data)).FmcDicts != libc.UintptrFromInt32(0) {
		_objPtr23 = (*TClockClientData)(unsafe.Pointer(data)).FmcDicts
		v48 = _objPtr23
		v47 = *(*TTcl_Size)(unsafe.Pointer(v48))
		*(*TTcl_Size)(unsafe.Pointer(v48))--
		if v47 <= int64(1) {
			XTclFreeObj(tls, _objPtr23)
		}
		(*TClockClientData)(unsafe.Pointer(data)).FmcDicts = libc.UintptrFromInt32(0)
	}
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * ClockDeleteCmdProc --
//	 *
//	 *	Remove a reference to the clock client data, and clean up memory
//	 *	when it's all gone.
//	 *
//	 * Results:
//	 *	None.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _ClockDeleteCmdProc(tls *libc.TLS, clientData uintptr) {
	/* Opaque pointer to the client data */
	var _objPtr, _objPtr1, _objPtr2, data, v11, v2, v5, v8 uintptr
	var i int32
	var v1 Tsize_t
	var v10, v4, v7 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, data, i, v1, v10, v11, v2, v4, v5, v7, v8
	data = clientData
	v2 = data
	v1 = *(*Tsize_t)(unsafe.Pointer(v2))
	*(*Tsize_t)(unsafe.Pointer(v2))--
	if v1 <= uint64(1) {
		i = 0
		for {
			if !(i < int32(LIT__END)) {
				break
			}
			_objPtr = *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(data)).Fliterals + uintptr(i)*8))
			v5 = _objPtr
			v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
			*(*TTcl_Size)(unsafe.Pointer(v5))--
			if v4 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			goto _3
		_3:
			;
			i++
		}
		if (*TClockClientData)(unsafe.Pointer(data)).FmcLiterals != libc.UintptrFromInt32(0) {
			i = 0
			for {
				if !(i < int32(MCLIT__END)) {
					break
				}
				_objPtr1 = *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(data)).FmcLiterals + uintptr(i)*8))
				v8 = _objPtr1
				v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
				*(*TTcl_Size)(unsafe.Pointer(v8))--
				if v7 <= int64(1) {
					XTclFreeObj(tls, _objPtr1)
				}
				goto _6
			_6:
				;
				i++
			}
			XTclpFree(tls, (*TClockClientData)(unsafe.Pointer(data)).FmcLiterals)
			(*TClockClientData)(unsafe.Pointer(data)).FmcLiterals = libc.UintptrFromInt32(0)
		}
		if (*TClockClientData)(unsafe.Pointer(data)).FmcLitIdxs != libc.UintptrFromInt32(0) {
			i = 0
			for {
				if !(i < int32(MCLIT__END)) {
					break
				}
				_objPtr2 = *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(data)).FmcLitIdxs + uintptr(i)*8))
				v11 = _objPtr2
				v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
				*(*TTcl_Size)(unsafe.Pointer(v11))--
				if v10 <= int64(1) {
					XTclFreeObj(tls, _objPtr2)
				}
				goto _9
			_9:
				;
				i++
			}
			XTclpFree(tls, (*TClockClientData)(unsafe.Pointer(data)).FmcLitIdxs)
			(*TClockClientData)(unsafe.Pointer(data)).FmcLitIdxs = libc.UintptrFromInt32(0)
		}
		_ClockConfigureClear(tls, data)
		XTclpFree(tls, (*TClockClientData)(unsafe.Pointer(data)).Fliterals)
		XTclpFree(tls, data)
	}
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * SavePrevTimezoneObj --
//	 *
//	 *	Used to store previously used/cached time zone (makes it reusable).
//	 *
//	 *	This enables faster switch between time zones (e. g. to convert from
//	 *	one to another).
//	 *
//	 * Results:
//	 *	None.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _SavePrevTimezoneObj(tls *libc.TLS, dataPtr uintptr) {
	/* Client data containing literal pool */
	var _objPtr, _objPtr1, _objPtr2, nval, nval1, nval2, prev, prev1, prev2, timezoneObj, v2, v4, v6 uintptr
	var v1, v3, v5 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, nval, nval1, nval2, prev, prev1, prev2, timezoneObj, v1, v2, v3, v4, v5, v6
	timezoneObj = (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZone
	if timezoneObj != 0 && timezoneObj != (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZone {
		nval = (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZoneUnnorm
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZoneUnnorm != nval {
			prev = (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZoneUnnorm
			(*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZoneUnnorm = nval
			if (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZoneUnnorm != 0 {
				(*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZoneUnnorm)).FrefCount++
			}
			if prev != libc.UintptrFromInt32(0) {
				_objPtr = prev
				v2 = _objPtr
				v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
				*(*TTcl_Size)(unsafe.Pointer(v2))--
				if v1 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
		}
		nval1 = timezoneObj
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZone != nval1 {
			prev1 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZone
			(*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZone = nval1
			if (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZone != 0 {
				(*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZone)).FrefCount++
			}
			if prev1 != libc.UintptrFromInt32(0) {
				_objPtr1 = prev1
				v4 = _objPtr1
				v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
				*(*TTcl_Size)(unsafe.Pointer(v4))--
				if v3 <= int64(1) {
					XTclFreeObj(tls, _objPtr1)
				}
			}
		}
		nval2 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTZData
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTZData != nval2 {
			prev2 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTZData
			(*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTZData = nval2
			if (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTZData != 0 {
				(*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTZData)).FrefCount++
			}
			if prev2 != libc.UintptrFromInt32(0) {
				_objPtr2 = prev2
				v6 = _objPtr2
				v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
				*(*TTcl_Size)(unsafe.Pointer(v6))--
				if v5 <= int64(1) {
					XTclFreeObj(tls, _objPtr2)
				}
			}
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * NormTimezoneObj --
 *
 *	Normalizes the timezone object (used for caching puposes).
 *
 *	If already cached time zone could be found, returns this
 *	object (last setup or last used, system (current) or gmt).
 *
 * Results:
 *	Normalized tcl object pointer.
 *
 *----------------------------------------------------------------------
 */

func _NormTimezoneObj(tls *libc.TLS, dataPtr uintptr, timezoneObj uintptr, loaded uintptr) (r uintptr) {
	/* Used to recognized TZ was loaded */
	var _objPtr, _objPtr1, _objPtr2, nval, nval1, nval2, prev, prev1, prev2, tz, v1, v10, v13, v2, v5, v6, v9 uintptr
	var v11, v3, v7 bool
	var v12, v4, v8 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, nval, nval1, nval2, prev, prev1, prev2, tz, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9
	*(*int32)(unsafe.Pointer(loaded)) = int32(1)
	if timezoneObj == (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZoneUnnorm && (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZone != libc.UintptrFromInt32(0) {
		return (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZone
	}
	if timezoneObj == (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZoneUnnorm && (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZone != libc.UintptrFromInt32(0) {
		return (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZone
	}
	if timezoneObj == (*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtSetupTimeZoneUnnorm && (*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtSetupTimeZone != libc.UintptrFromInt32(0) {
		return *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals + uintptr(LIT_GMT)*8))
	}
	if timezoneObj == (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZone || timezoneObj == (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZone || timezoneObj == (*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtSetupTimeZone || timezoneObj == (*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemTimeZone {
		return timezoneObj
	}
	if (*TTcl_Obj)(unsafe.Pointer(timezoneObj)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(timezoneObj)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, timezoneObj, libc.UintptrFromInt32(0))
	}
	tz = v1
	if v3 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZone != libc.UintptrFromInt32(0); v3 {
		if (*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZone)).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZone)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZone, libc.UintptrFromInt32(0))
		}
	}
	if v3 && libc.Xstrcmp(tls, tz, v2) == 0 {
		nval = timezoneObj
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZoneUnnorm != nval {
			prev = (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZoneUnnorm
			(*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZoneUnnorm = nval
			if (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZoneUnnorm != 0 {
				(*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZoneUnnorm)).FrefCount++
			}
			if prev != libc.UintptrFromInt32(0) {
				_objPtr = prev
				v5 = _objPtr
				v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
				*(*TTcl_Size)(unsafe.Pointer(v5))--
				if v4 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
		}
		return (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZone
	}
	if v7 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZone != libc.UintptrFromInt32(0); v7 {
		if (*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZone)).Fbytes != 0 {
			v6 = (*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZone)).Fbytes
		} else {
			v6 = XTcl_GetStringFromObj(tls, (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZone, libc.UintptrFromInt32(0))
		}
	}
	if v7 && libc.Xstrcmp(tls, tz, v6) == 0 {
		nval1 = timezoneObj
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZoneUnnorm != nval1 {
			prev1 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZoneUnnorm
			(*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZoneUnnorm = nval1
			if (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZoneUnnorm != 0 {
				(*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZoneUnnorm)).FrefCount++
			}
			if prev1 != libc.UintptrFromInt32(0) {
				_objPtr1 = prev1
				v9 = _objPtr1
				v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
				*(*TTcl_Size)(unsafe.Pointer(v9))--
				if v8 <= int64(1) {
					XTclFreeObj(tls, _objPtr1)
				}
			}
		}
		return (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZone
	}
	if v11 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemTimeZone != libc.UintptrFromInt32(0); v11 {
		if (*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemTimeZone)).Fbytes != 0 {
			v10 = (*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemTimeZone)).Fbytes
		} else {
			v10 = XTcl_GetStringFromObj(tls, (*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemTimeZone, libc.UintptrFromInt32(0))
		}
	}
	if v11 && libc.Xstrcmp(tls, tz, v10) == 0 {
		return (*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemTimeZone
	}
	if libc.Xstrcmp(tls, tz, _Literals[int32(LIT_GMT)]) == 0 {
		nval2 = timezoneObj
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtSetupTimeZoneUnnorm != nval2 {
			prev2 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtSetupTimeZoneUnnorm
			(*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtSetupTimeZoneUnnorm = nval2
			if (*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtSetupTimeZoneUnnorm != 0 {
				(*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtSetupTimeZoneUnnorm)).FrefCount++
			}
			if prev2 != libc.UintptrFromInt32(0) {
				_objPtr2 = prev2
				v13 = _objPtr2
				v12 = *(*TTcl_Size)(unsafe.Pointer(v13))
				*(*TTcl_Size)(unsafe.Pointer(v13))--
				if v12 <= int64(1) {
					XTclFreeObj(tls, _objPtr2)
				}
			}
		}
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtSetupTimeZone == libc.UintptrFromInt32(0) {
			*(*int32)(unsafe.Pointer(loaded)) = 0
		}
		return *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals + uintptr(LIT_GMT)*8))
	}
	/* unknown/unloaded tz - recache/revalidate later as last-setup if needed */
	*(*int32)(unsafe.Pointer(loaded)) = 0
	return timezoneObj
}

/*
 *----------------------------------------------------------------------
 *
 * ClockGetSystemLocale --
 *
 *	Returns system locale.
 *
 *	Executes ::tcl::clock::GetSystemLocale in given interpreter.
 *
 * Results:
 *	Returns system locale tcl object.
 *
 *----------------------------------------------------------------------
 */

func _ClockGetSystemLocale(tls *libc.TLS, dataPtr uintptr, interp uintptr) (r uintptr) {
	/* Tcl interpreter */
	if XTcl_EvalObjv(tls, interp, int64(1), (*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals+uintptr(LIT_GETSYSTEMLOCALE)*8, 0) != TCL_OK {
		return libc.UintptrFromInt32(0)
	}
	return XTcl_GetObjResult(tls, interp)
}

/*
 *----------------------------------------------------------------------
 *
 * ClockGetCurrentLocale --
 *
 *	Returns current locale.
 *
 *	Executes ::tcl::clock::mclocale in given interpreter.
 *
 * Results:
 *	Returns current locale tcl object.
 *
 *----------------------------------------------------------------------
 */

func _ClockGetCurrentLocale(tls *libc.TLS, dataPtr uintptr, interp uintptr) (r uintptr) {
	/* Tcl interpreter */
	var _objPtr, nval, prev, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _, _ = _objPtr, nval, prev, v1, v2
	if XTcl_EvalObjv(tls, interp, int64(1), (*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals+uintptr(LIT_GETCURRENTLOCALE)*8, 0) != TCL_OK {
		return libc.UintptrFromInt32(0)
	}
	nval = XTcl_GetObjResult(tls, interp)
	if (*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocale != nval {
		prev = (*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocale
		(*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocale = nval
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocale != 0 {
			(*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocale)).FrefCount++
		}
		if prev != libc.UintptrFromInt32(0) {
			_objPtr = prev
			v2 = _objPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if v1 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
	}
	(*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocaleDict = libc.UintptrFromInt32(0)
	XTcl_ResetResult(tls, interp)
	return (*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocale
}

/*
 *----------------------------------------------------------------------
 *
 * SavePrevLocaleObj --
 *
 *	Used to store previously used/cached locale (makes it reusable).
 *
 *	This enables faster switch between locales (e. g. to convert from one to another).
 *
 * Results:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _SavePrevLocaleObj(tls *libc.TLS, dataPtr uintptr) {
	/* Client data containing literal pool */
	var _objPtr, _objPtr1, localeObj, nval, nval1, prev, prev1, v2, v4 uintptr
	var v1, v3 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, localeObj, nval, nval1, prev, prev1, v1, v2, v3, v4
	localeObj = (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocale
	if localeObj != 0 && localeObj != (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevUsedLocale {
		nval = (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocaleUnnorm
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevUsedLocaleUnnorm != nval {
			prev = (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevUsedLocaleUnnorm
			(*TClockClientData)(unsafe.Pointer(dataPtr)).FprevUsedLocaleUnnorm = nval
			if (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevUsedLocaleUnnorm != 0 {
				(*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FprevUsedLocaleUnnorm)).FrefCount++
			}
			if prev != libc.UintptrFromInt32(0) {
				_objPtr = prev
				v2 = _objPtr
				v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
				*(*TTcl_Size)(unsafe.Pointer(v2))--
				if v1 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
		}
		nval1 = localeObj
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevUsedLocale != nval1 {
			prev1 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevUsedLocale
			(*TClockClientData)(unsafe.Pointer(dataPtr)).FprevUsedLocale = nval1
			if (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevUsedLocale != 0 {
				(*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FprevUsedLocale)).FrefCount++
			}
			if prev1 != libc.UintptrFromInt32(0) {
				_objPtr1 = prev1
				v4 = _objPtr1
				v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
				*(*TTcl_Size)(unsafe.Pointer(v4))--
				if v3 <= int64(1) {
					XTclFreeObj(tls, _objPtr1)
				}
			}
		}
		/* mcDicts owns reference to dict */
		(*TClockClientData)(unsafe.Pointer(dataPtr)).FprevUsedLocaleDict = (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocaleDict
	}
}

/*
 *----------------------------------------------------------------------
 *
 * NormLocaleObj --
 *
 *	Normalizes the locale object (used for caching puposes).
 *
 *	If already cached locale could be found, returns this
 *	object (current, system (OS) or last used locales).
 *
 * Results:
 *	Normalized tcl object pointer.
 *
 *----------------------------------------------------------------------
 */

func _NormLocaleObj(tls *libc.TLS, dataPtr uintptr, interp uintptr, localeObj uintptr, mcDictObj uintptr) (r uintptr) {
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, loc, loc2, nval, nval1, nval2, nval3, prev, prev1, prev2, prev3, v1, v12, v13, v18, v19, v2, v20, v23, v25, v27, v3, v7 uintptr
	var v10, v14, v15, v16, v21, v22, v4, v5, v6, v8, v9 bool
	var v11, v17, v24, v26 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, loc, loc2, nval, nval1, nval2, nval3, prev, prev1, prev2, prev3, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v3, v4, v5, v6, v7, v8, v9
	if localeObj == libc.UintptrFromInt32(0) || localeObj == *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals + uintptr(LIT_C)*8)) || localeObj == (*TClockClientData)(unsafe.Pointer(dataPtr)).FdefaultLocale {
		*(*uintptr)(unsafe.Pointer(mcDictObj)) = (*TClockClientData)(unsafe.Pointer(dataPtr)).FdefaultLocaleDict
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FdefaultLocale != 0 {
			v1 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FdefaultLocale
		} else {
			v1 = *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals + uintptr(LIT_C)*8))
		}
		return v1
	}
	if localeObj == (*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocale || localeObj == *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals + uintptr(LIT_CURRENT)*8)) {
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocale == libc.UintptrFromInt32(0) {
			_ClockGetCurrentLocale(tls, dataPtr, interp)
		}
		*(*uintptr)(unsafe.Pointer(mcDictObj)) = (*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocaleDict
		return (*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocale
	}
	if localeObj == (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocale || localeObj == (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocaleUnnorm {
		*(*uintptr)(unsafe.Pointer(mcDictObj)) = (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocaleDict
		return (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocale
	}
	if localeObj == (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevUsedLocale || localeObj == (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevUsedLocaleUnnorm {
		*(*uintptr)(unsafe.Pointer(mcDictObj)) = (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevUsedLocaleDict
		return (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevUsedLocale
	}
	if (*TTcl_Obj)(unsafe.Pointer(localeObj)).Fbytes != 0 {
		v2 = (*TTcl_Obj)(unsafe.Pointer(localeObj)).Fbytes
	} else {
		v2 = XTcl_GetStringFromObj(tls, localeObj, libc.UintptrFromInt32(0))
	}
	loc = v2
	if v6 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocale != libc.UintptrFromInt32(0); v6 {
		if v5 = localeObj == (*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocale; !v5 {
			if v4 = (*TTcl_Obj)(unsafe.Pointer(localeObj)).Flength == (*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocale)).Flength; v4 {
				if (*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocale)).Fbytes != 0 {
					v3 = (*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocale)).Fbytes
				} else {
					v3 = XTcl_GetStringFromObj(tls, (*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocale, libc.UintptrFromInt32(0))
				}
			}
		}
	}
	if v6 && (v5 || v4 && libc.Xstrcasecmp(tls, loc, v3) == 0) {
		*(*uintptr)(unsafe.Pointer(mcDictObj)) = (*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocaleDict
		return (*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocale
	}
	if v10 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocale != libc.UintptrFromInt32(0); v10 {
		if v9 = localeObj == (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocale; !v9 {
			if v8 = (*TTcl_Obj)(unsafe.Pointer(localeObj)).Flength == (*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocale)).Flength; v8 {
				if (*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocale)).Fbytes != 0 {
					v7 = (*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocale)).Fbytes
				} else {
					v7 = XTcl_GetStringFromObj(tls, (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocale, libc.UintptrFromInt32(0))
				}
			}
		}
	}
	if v10 && (v9 || v8 && libc.Xstrcasecmp(tls, loc, v7) == 0) {
		*(*uintptr)(unsafe.Pointer(mcDictObj)) = (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocaleDict
		nval = localeObj
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocaleUnnorm != nval {
			prev = (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocaleUnnorm
			(*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocaleUnnorm = nval
			if (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocaleUnnorm != 0 {
				(*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocaleUnnorm)).FrefCount++
			}
			if prev != libc.UintptrFromInt32(0) {
				_objPtr = prev
				v12 = _objPtr
				v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
				*(*TTcl_Size)(unsafe.Pointer(v12))--
				if v11 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
		}
		return (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocale
	}
	if v16 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevUsedLocale != libc.UintptrFromInt32(0); v16 {
		if v15 = localeObj == (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevUsedLocale; !v15 {
			if v14 = (*TTcl_Obj)(unsafe.Pointer(localeObj)).Flength == (*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FprevUsedLocale)).Flength; v14 {
				if (*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FprevUsedLocale)).Fbytes != 0 {
					v13 = (*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FprevUsedLocale)).Fbytes
				} else {
					v13 = XTcl_GetStringFromObj(tls, (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevUsedLocale, libc.UintptrFromInt32(0))
				}
			}
		}
	}
	if v16 && (v15 || v14 && libc.Xstrcasecmp(tls, loc, v13) == 0) {
		*(*uintptr)(unsafe.Pointer(mcDictObj)) = (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevUsedLocaleDict
		nval1 = localeObj
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevUsedLocaleUnnorm != nval1 {
			prev1 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevUsedLocaleUnnorm
			(*TClockClientData)(unsafe.Pointer(dataPtr)).FprevUsedLocaleUnnorm = nval1
			if (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevUsedLocaleUnnorm != 0 {
				(*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FprevUsedLocaleUnnorm)).FrefCount++
			}
			if prev1 != libc.UintptrFromInt32(0) {
				_objPtr1 = prev1
				v18 = _objPtr1
				v17 = *(*TTcl_Size)(unsafe.Pointer(v18))
				*(*TTcl_Size)(unsafe.Pointer(v18))--
				if v17 <= int64(1) {
					XTclFreeObj(tls, _objPtr1)
				}
			}
		}
		return (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevUsedLocale
	}
	if v22 = (*TTcl_Obj)(unsafe.Pointer(localeObj)).Flength == int64(1) && libc.Xstrcasecmp(tls, loc, _Literals[int32(LIT_C)]) == 0; !v22 {
		if v21 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FdefaultLocale != 0; v21 {
			if (*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FdefaultLocale)).Fbytes != 0 {
				v20 = (*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FdefaultLocale)).Fbytes
			} else {
				v20 = XTcl_GetStringFromObj(tls, (*TClockClientData)(unsafe.Pointer(dataPtr)).FdefaultLocale, libc.UintptrFromInt32(0))
			}
			v19 = v20
			loc2 = v19
		}
	}
	if v22 || v21 && v19 != 0 && (*TTcl_Obj)(unsafe.Pointer(localeObj)).Flength == (*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FdefaultLocale)).Flength && libc.Xstrcasecmp(tls, loc, loc2) == 0 {
		*(*uintptr)(unsafe.Pointer(mcDictObj)) = (*TClockClientData)(unsafe.Pointer(dataPtr)).FdefaultLocaleDict
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FdefaultLocale != 0 {
			v23 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FdefaultLocale
		} else {
			v23 = *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals + uintptr(LIT_C)*8))
		}
		return v23
	}
	if (*TTcl_Obj)(unsafe.Pointer(localeObj)).Flength == int64(7) && libc.Xstrcasecmp(tls, loc, _Literals[int32(LIT_CURRENT)]) == 0 {
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocale == libc.UintptrFromInt32(0) {
			_ClockGetCurrentLocale(tls, dataPtr, interp)
		}
		*(*uintptr)(unsafe.Pointer(mcDictObj)) = (*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocaleDict
		return (*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocale
	}
	if (*TTcl_Obj)(unsafe.Pointer(localeObj)).Flength == int64(6) && libc.Xstrcasecmp(tls, loc, _Literals[int32(LIT_SYSTEM)]) == 0 {
		_SavePrevLocaleObj(tls, dataPtr)
		nval2 = localeObj
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocaleUnnorm != nval2 {
			prev2 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocaleUnnorm
			(*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocaleUnnorm = nval2
			if (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocaleUnnorm != 0 {
				(*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocaleUnnorm)).FrefCount++
			}
			if prev2 != libc.UintptrFromInt32(0) {
				_objPtr2 = prev2
				v25 = _objPtr2
				v24 = *(*TTcl_Size)(unsafe.Pointer(v25))
				*(*TTcl_Size)(unsafe.Pointer(v25))--
				if v24 <= int64(1) {
					XTclFreeObj(tls, _objPtr2)
				}
			}
		}
		localeObj = _ClockGetSystemLocale(tls, dataPtr, interp)
		nval3 = localeObj
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocale != nval3 {
			prev3 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocale
			(*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocale = nval3
			if (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocale != 0 {
				(*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocale)).FrefCount++
			}
			if prev3 != libc.UintptrFromInt32(0) {
				_objPtr3 = prev3
				v27 = _objPtr3
				v26 = *(*TTcl_Size)(unsafe.Pointer(v27))
				*(*TTcl_Size)(unsafe.Pointer(v27))--
				if v26 <= int64(1) {
					XTclFreeObj(tls, _objPtr3)
				}
			}
		}
		*(*uintptr)(unsafe.Pointer(mcDictObj)) = libc.UintptrFromInt32(0)
		return localeObj
	}
	*(*uintptr)(unsafe.Pointer(mcDictObj)) = libc.UintptrFromInt32(0)
	return localeObj
}

/*
 *----------------------------------------------------------------------
 *
 * ClockMCDict --
 *
 *	Retrieves a localized storage dictionary object for the given
 *	locale object.
 *
 *	This corresponds with call `::tcl::clock::mcget locale`.
 *	Cached representation stored in options (for further access).
 *
 * Results:
 *	Tcl-object contains smart reference to msgcat dictionary.
 *
 *----------------------------------------------------------------------
 */

func XClockMCDict(tls *libc.TLS, opts uintptr) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var _objPtr, _objPtr1, _objPtr2, dataPtr, nval, nval1, prev, prev1, v3, v5, v7 uintptr
	var i int32
	var ref, v2, v4, v6 TTcl_Size
	var _ /* callargs at bp+0 */ [2]uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, dataPtr, i, nval, nval1, prev, prev1, ref, v2, v3, v4, v5, v6, v7
	dataPtr = (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FdataPtr
	/* if dict not yet retrieved */
	if (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj == libc.UintptrFromInt32(0) {
		/* if locale was not yet used */
		if !((*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Fflags&int32(CLF_LOCALE_USED) != 0) {
			(*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FlocaleObj = _NormLocaleObj(tls, dataPtr, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FlocaleObj, opts+56)
			if (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FlocaleObj == libc.UintptrFromInt32(0) {
				XTcl_SetObjResult(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, XTcl_NewStringObj(tls, __ccgo_ts+12619, int64(-libc.Int32FromInt32(1))))
				XTcl_SetErrorCode(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, libc.VaList(bp+24, __ccgo_ts+12666, __ccgo_ts+12672, libc.UintptrFromInt32(0)))
				return libc.UintptrFromInt32(0)
			}
			*(*int32)(unsafe.Pointer(opts + 48)) |= int32(CLF_LOCALE_USED)
			/* check locale literals already available (on demand creation) */
			if (*TClockClientData)(unsafe.Pointer(dataPtr)).FmcLiterals == libc.UintptrFromInt32(0) {
				(*TClockClientData)(unsafe.Pointer(dataPtr)).FmcLiterals = XTcl_Alloc(tls, uint64(MCLIT__END)*libc.Uint64FromInt64(8))
				i = 0
				for {
					if !(i < int32(MCLIT__END)) {
						break
					}
					*(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FmcLiterals + uintptr(i)*8)) = XTcl_NewStringObj(tls, _MsgCtLiterals[i], int64(-libc.Int32FromInt32(1)))
					if *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FmcLiterals + uintptr(i)*8)) != 0 {
						(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FmcLiterals + uintptr(i)*8)))).FrefCount++
					}
					goto _1
				_1:
					;
					i++
				}
			}
		}
		/* check or obtain mcDictObj (be sure it's modifiable) */
		if (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj == libc.UintptrFromInt32(0) || (*TTcl_Obj)(unsafe.Pointer((*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj)).FrefCount > int64(1) {
			ref = int64(1)
			/* first try to find locale catalog dict */
			if (*TClockClientData)(unsafe.Pointer(dataPtr)).FmcDicts == libc.UintptrFromInt32(0) {
				nval = XTcl_NewDictObj(tls)
				if (*TClockClientData)(unsafe.Pointer(dataPtr)).FmcDicts != nval {
					prev = (*TClockClientData)(unsafe.Pointer(dataPtr)).FmcDicts
					(*TClockClientData)(unsafe.Pointer(dataPtr)).FmcDicts = nval
					if (*TClockClientData)(unsafe.Pointer(dataPtr)).FmcDicts != 0 {
						(*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FmcDicts)).FrefCount++
					}
					if prev != libc.UintptrFromInt32(0) {
						_objPtr = prev
						v3 = _objPtr
						v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
						*(*TTcl_Size)(unsafe.Pointer(v3))--
						if v2 <= int64(1) {
							XTclFreeObj(tls, _objPtr)
						}
					}
				}
			}
			XTcl_DictObjGet(tls, libc.UintptrFromInt32(0), (*TClockClientData)(unsafe.Pointer(dataPtr)).FmcDicts, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FlocaleObj, opts+56)
			if (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj == libc.UintptrFromInt32(0) {
				(*(*[2]uintptr)(unsafe.Pointer(bp)))[0] = *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals + uintptr(LIT_MCGET)*8))
				(*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)] = (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FlocaleObj
				if XTcl_EvalObjv(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, int64(2), bp, 0) != TCL_OK {
					return libc.UintptrFromInt32(0)
				}
				(*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj = XTcl_GetObjResult(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp)
				XTcl_ResetResult(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp)
				ref = 0 /* new object is not yet referenced */
			}
			/* be sure that object reference doesn't increase (dict changeable) */
			if (*TTcl_Obj)(unsafe.Pointer((*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj)).FrefCount > ref {
				/* smart reference (shared dict as object with no ref-counter) */
				(*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj = XTclDictObjSmartRef(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj)
			}
			/* create exactly one reference to catalog / make it searchable for future */
			XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), (*TClockClientData)(unsafe.Pointer(dataPtr)).FmcDicts, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FlocaleObj, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj)
			if (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FlocaleObj == *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals + uintptr(LIT_C)*8)) || (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FlocaleObj == (*TClockClientData)(unsafe.Pointer(dataPtr)).FdefaultLocale {
				(*TClockClientData)(unsafe.Pointer(dataPtr)).FdefaultLocaleDict = (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj
			}
			if (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FlocaleObj == (*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocale {
				(*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocaleDict = (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj
			} else {
				if (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FlocaleObj == (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocale {
					(*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocaleDict = (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj
				} else {
					_SavePrevLocaleObj(tls, dataPtr)
					nval1 = (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FlocaleObj
					if (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocale != nval1 {
						prev1 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocale
						(*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocale = nval1
						if (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocale != 0 {
							(*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocale)).FrefCount++
						}
						if prev1 != libc.UintptrFromInt32(0) {
							_objPtr1 = prev1
							v5 = _objPtr1
							v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
							*(*TTcl_Size)(unsafe.Pointer(v5))--
							if v4 <= int64(1) {
								XTclFreeObj(tls, _objPtr1)
							}
						}
					}
					if (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocaleUnnorm != libc.UintptrFromInt32(0) {
						_objPtr2 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocaleUnnorm
						v7 = _objPtr2
						v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
						*(*TTcl_Size)(unsafe.Pointer(v7))--
						if v6 <= int64(1) {
							XTclFreeObj(tls, _objPtr2)
						}
						(*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocaleUnnorm = libc.UintptrFromInt32(0)
					}
					(*TClockClientData)(unsafe.Pointer(dataPtr)).FlastUsedLocaleDict = (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj
				}
			}
		}
	}
	return (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj
}

/*
 *----------------------------------------------------------------------
 *
 * ClockMCGet --
 *
 *	Retrieves a msgcat value for the given literal integer mcKey
 *	from localized storage (corresponding given locale object)
 *	by mcLiterals[mcKey] (e. g. MONTHS_FULL).
 *
 * Results:
 *	Tcl-object contains localized value.
 *
 *----------------------------------------------------------------------
 */

func XClockMCGet(tls *libc.TLS, opts uintptr, mcKey int32) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _ /* valObj at bp+0 */ uintptr
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	if (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj == libc.UintptrFromInt32(0) {
		XClockMCDict(tls, opts)
		if (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj == libc.UintptrFromInt32(0) {
			return libc.UintptrFromInt32(0)
		}
	}
	XTcl_DictObjGet(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj, *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer((*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FdataPtr)).FmcLiterals + uintptr(mcKey)*8)), bp)
	return *(*uintptr)(unsafe.Pointer(bp)) /* or NULL in obscure case if Tcl_DictObjGet failed */
}

/*
 *----------------------------------------------------------------------
 *
 * ClockMCGetIdx --
 *
 *	Retrieves an indexed msgcat value for the given literal integer mcKey
 *	from localized storage (corresponding given locale object)
 *	by mcLitIdxs[mcKey] (e. g. _IDX_MONTHS_FULL).
 *
 * Results:
 *	Tcl-object contains localized indexed value.
 *
 *----------------------------------------------------------------------
 */
func XClockMCGetIdx(tls *libc.TLS, opts uintptr, mcKey int32) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var dataPtr uintptr
	var _ /* valObj at bp+0 */ uintptr
	_ = dataPtr
	dataPtr = (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FdataPtr
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	if (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj == libc.UintptrFromInt32(0) {
		XClockMCDict(tls, opts)
		if (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj == libc.UintptrFromInt32(0) {
			return libc.UintptrFromInt32(0)
		}
	}
	/* try to get indices object */
	if (*TClockClientData)(unsafe.Pointer(dataPtr)).FmcLitIdxs == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	if XTcl_DictObjGet(tls, libc.UintptrFromInt32(0), (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj, *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FmcLitIdxs + uintptr(mcKey)*8)), bp) != TCL_OK {
		return libc.UintptrFromInt32(0)
	}
	return *(*uintptr)(unsafe.Pointer(bp))
}

/*
 *----------------------------------------------------------------------
 *
 * ClockMCSetIdx --
 *
 *	Sets an indexed msgcat value for the given literal integer mcKey
 *	in localized storage (corresponding given locale object)
 *	by mcLitIdxs[mcKey] (e. g. _IDX_MONTHS_FULL).
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 *----------------------------------------------------------------------
 */

func XClockMCSetIdx(tls *libc.TLS, opts uintptr, mcKey int32, valObj uintptr) (r int32) {
	var dataPtr uintptr
	var i int32
	_, _ = dataPtr, i
	dataPtr = (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FdataPtr
	if (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj == libc.UintptrFromInt32(0) {
		XClockMCDict(tls, opts)
		if (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
	}
	/* if literal storage for indices not yet created */
	if (*TClockClientData)(unsafe.Pointer(dataPtr)).FmcLitIdxs == libc.UintptrFromInt32(0) {
		(*TClockClientData)(unsafe.Pointer(dataPtr)).FmcLitIdxs = XTcl_Alloc(tls, uint64(MCLIT__END)*libc.Uint64FromInt64(8))
		i = 0
		for {
			if !(i < int32(MCLIT__END)) {
				break
			}
			*(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FmcLitIdxs + uintptr(i)*8)) = XTcl_NewStringObj(tls, _MsgCtLitIdxs[i], int64(-libc.Int32FromInt32(1)))
			if *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FmcLitIdxs + uintptr(i)*8)) != 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FmcLitIdxs + uintptr(i)*8)))).FrefCount++
			}
			goto _1
		_1:
			;
			i++
		}
	}
	return XTcl_DictObjPut(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj, *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FmcLitIdxs + uintptr(mcKey)*8)), valObj)
}

func _TimezoneLoaded(tls *libc.TLS, dataPtr uintptr, timezoneObj uintptr, tzUnnormObj uintptr) {
	/* Name of zone was loaded */
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, nval, nval1, nval2, nval3, prev, prev1, prev2, prev3, v10, v2, v4, v6, v8 uintptr
	var v1, v3, v5, v7, v9 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, nval, nval1, nval2, nval3, prev, prev1, prev2, prev3, v1, v10, v2, v3, v4, v5, v6, v7, v8, v9
	/* don't overwrite last-setup with GMT (special case) */
	if timezoneObj == *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals + uintptr(LIT_GMT)*8)) {
		/* mark GMT zone loaded */
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtSetupTimeZone == libc.UintptrFromInt32(0) {
			nval = *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals + uintptr(LIT_GMT)*8))
			if (*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtSetupTimeZone != nval {
				prev = (*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtSetupTimeZone
				(*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtSetupTimeZone = nval
				if (*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtSetupTimeZone != 0 {
					(*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtSetupTimeZone)).FrefCount++
				}
				if prev != libc.UintptrFromInt32(0) {
					_objPtr = prev
					v2 = _objPtr
					v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
					*(*TTcl_Size)(unsafe.Pointer(v2))--
					if v1 <= int64(1) {
						XTclFreeObj(tls, _objPtr)
					}
				}
			}
		}
		nval1 = tzUnnormObj
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtSetupTimeZoneUnnorm != nval1 {
			prev1 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtSetupTimeZoneUnnorm
			(*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtSetupTimeZoneUnnorm = nval1
			if (*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtSetupTimeZoneUnnorm != 0 {
				(*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtSetupTimeZoneUnnorm)).FrefCount++
			}
			if prev1 != libc.UintptrFromInt32(0) {
				_objPtr1 = prev1
				v4 = _objPtr1
				v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
				*(*TTcl_Size)(unsafe.Pointer(v4))--
				if v3 <= int64(1) {
					XTclFreeObj(tls, _objPtr1)
				}
			}
		}
		return
	}
	/* last setup zone loaded */
	if (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZone != timezoneObj {
		_SavePrevTimezoneObj(tls, dataPtr)
		nval2 = timezoneObj
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZone != nval2 {
			prev2 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZone
			(*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZone = nval2
			if (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZone != 0 {
				(*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZone)).FrefCount++
			}
			if prev2 != libc.UintptrFromInt32(0) {
				_objPtr2 = prev2
				v6 = _objPtr2
				v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
				*(*TTcl_Size)(unsafe.Pointer(v6))--
				if v5 <= int64(1) {
					XTclFreeObj(tls, _objPtr2)
				}
			}
		}
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTZData != libc.UintptrFromInt32(0) {
			_objPtr3 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTZData
			v8 = _objPtr3
			v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
			*(*TTcl_Size)(unsafe.Pointer(v8))--
			if v7 <= int64(1) {
				XTclFreeObj(tls, _objPtr3)
			}
			(*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTZData = libc.UintptrFromInt32(0)
		}
	}
	nval3 = tzUnnormObj
	if (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZoneUnnorm != nval3 {
		prev3 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZoneUnnorm
		(*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZoneUnnorm = nval3
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZoneUnnorm != 0 {
			(*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZoneUnnorm)).FrefCount++
		}
		if prev3 != libc.UintptrFromInt32(0) {
			_objPtr4 = prev3
			v10 = _objPtr4
			v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
			*(*TTcl_Size)(unsafe.Pointer(v10))--
			if v9 <= int64(1) {
				XTclFreeObj(tls, _objPtr4)
			}
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * ClockConfigureObjCmd --
 *
 *	This function is invoked to process the Tcl "::tcl::unsupported::clock::configure"
 *	(internal, unsupported) command.
 *
 * Usage:
 *	::tcl::unsupported::clock::configure ?-option ?value??
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _ClockConfigureObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* Parameter vector */
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, dataPtr, nval, nval1, nval2, prev, prev1, prev2, timezoneObj, v10, v12, v3, v5, v7, v9 uintptr
	var i, v11, v2, v4, v6, v8 TTcl_Size
	var lastTZEpoch Tsize_t
	var token TTcl_Command
	var v13, v14, v15, v16 int32
	var _ /* ensFlags at bp+36 */ int32
	var _ /* jd at bp+24 */ float64
	var _ /* loaded at bp+4 */ int32
	var _ /* optionIndex at bp+0 */ int32
	var _ /* val at bp+32 */ int32
	var _ /* year at bp+12 */ int32
	var _ /* year at bp+16 */ int32
	var _ /* year at bp+20 */ int32
	var _ /* year at bp+8 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, dataPtr, i, lastTZEpoch, nval, nval1, nval2, prev, prev1, prev2, timezoneObj, token, v10, v11, v12, v13, v14, v15, v16, v2, v3, v4, v5, v6, v7, v8, v9
	dataPtr = clientData
	i = int64(1)
	for {
		if !(i < int64(objc)) {
			break
		}
		v2 = i
		i++
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(v2)*8)), uintptr(unsafe.Pointer(&_options)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i-int64(1))*8)))).Fbytes != 0 {
				v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i-int64(1))*8)))).Fbytes
			} else {
				v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i-int64(1))*8)), libc.UintptrFromInt32(0))
			}
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+48, __ccgo_ts+12666, __ccgo_ts+12672, v3, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		switch *(*int32)(unsafe.Pointer(bp)) {
		case 11:
			/* validate current tz-epoch */
			lastTZEpoch = _TzsetIfNecessary(tls)
			if i < int64(objc) {
				if (*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemTimeZone != *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) {
					nval = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
					if (*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemTimeZone != nval {
						prev = (*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemTimeZone
						(*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemTimeZone = nval
						if (*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemTimeZone != 0 {
							(*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemTimeZone)).FrefCount++
						}
						if prev != libc.UintptrFromInt32(0) {
							_objPtr = prev
							v5 = _objPtr
							v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
							*(*TTcl_Size)(unsafe.Pointer(v5))--
							if v4 <= int64(1) {
								XTclFreeObj(tls, _objPtr)
							}
						}
					}
					if (*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemSetupTZData != libc.UintptrFromInt32(0) {
						_objPtr1 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemSetupTZData
						v7 = _objPtr1
						v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
						*(*TTcl_Size)(unsafe.Pointer(v7))--
						if v6 <= int64(1) {
							XTclFreeObj(tls, _objPtr1)
						}
						(*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemSetupTZData = libc.UintptrFromInt32(0)
					}
				}
				(*TClockClientData)(unsafe.Pointer(dataPtr)).FlastTZEpoch = lastTZEpoch
			}
			if i+int64(1) >= int64(objc) && (*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemTimeZone != libc.UintptrFromInt32(0) && (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastTZEpoch == lastTZEpoch {
				XTcl_SetObjResult(tls, interp, (*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemTimeZone)
			}
		case 10:
			if i < int64(objc) {
				timezoneObj = _NormTimezoneObj(tls, dataPtr, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp+4)
				if !(*(*int32)(unsafe.Pointer(bp + 4)) != 0) {
					_TimezoneLoaded(tls, dataPtr, timezoneObj, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))
				}
				XTcl_SetObjResult(tls, interp, timezoneObj)
			} else {
				if i+int64(1) >= int64(objc) && (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZone != libc.UintptrFromInt32(0) {
					XTcl_SetObjResult(tls, interp, (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZone)
				}
			}
		case 0:
			if i < int64(objc) {
				if (*TClockClientData)(unsafe.Pointer(dataPtr)).FdefaultLocale != *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) {
					nval1 = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
					if (*TClockClientData)(unsafe.Pointer(dataPtr)).FdefaultLocale != nval1 {
						prev1 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FdefaultLocale
						(*TClockClientData)(unsafe.Pointer(dataPtr)).FdefaultLocale = nval1
						if (*TClockClientData)(unsafe.Pointer(dataPtr)).FdefaultLocale != 0 {
							(*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FdefaultLocale)).FrefCount++
						}
						if prev1 != libc.UintptrFromInt32(0) {
							_objPtr2 = prev1
							v9 = _objPtr2
							v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
							*(*TTcl_Size)(unsafe.Pointer(v9))--
							if v8 <= int64(1) {
								XTclFreeObj(tls, _objPtr2)
							}
						}
					}
					(*TClockClientData)(unsafe.Pointer(dataPtr)).FdefaultLocaleDict = libc.UintptrFromInt32(0)
				}
			}
			if i+int64(1) >= int64(objc) {
				if (*TClockClientData)(unsafe.Pointer(dataPtr)).FdefaultLocale != 0 {
					v10 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FdefaultLocale
				} else {
					v10 = *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals + uintptr(LIT_C)*8))
				}
				XTcl_SetObjResult(tls, interp, v10)
			}
		case 2:
			if i < int64(objc) {
				if (*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocale != *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) {
					nval2 = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
					if (*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocale != nval2 {
						prev2 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocale
						(*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocale = nval2
						if (*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocale != 0 {
							(*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocale)).FrefCount++
						}
						if prev2 != libc.UintptrFromInt32(0) {
							_objPtr3 = prev2
							v12 = _objPtr3
							v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
							*(*TTcl_Size)(unsafe.Pointer(v12))--
							if v11 <= int64(1) {
								XTclFreeObj(tls, _objPtr3)
							}
						}
					}
					(*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocaleDict = libc.UintptrFromInt32(0)
				}
			}
			if i+int64(1) >= int64(objc) && (*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocale != libc.UintptrFromInt32(0) {
				XTcl_SetObjResult(tls, interp, (*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentLocale)
			}
		case 3:
			if i < int64(objc) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
					*(*int32)(unsafe.Pointer(bp + 8)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep)))
					v13 = libc.Int32FromInt32(TCL_OK)
				} else {
					v13 = XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp+8)
				}
				if v13 != TCL_OK {
					return int32(TCL_ERROR)
				}
				(*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentYearCentury = *(*int32)(unsafe.Pointer(bp + 8))
				if i+int64(1) >= int64(objc) {
					XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))
				}
				goto _1
			}
			if i+int64(1) >= int64(objc) {
				XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, int64((*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentYearCentury)))
			}
		case 4:
			if i < int64(objc) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
					*(*int32)(unsafe.Pointer(bp + 12)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep)))
					v14 = libc.Int32FromInt32(TCL_OK)
				} else {
					v14 = XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp+12)
				}
				if v14 != TCL_OK {
					return int32(TCL_ERROR)
				}
				(*TClockClientData)(unsafe.Pointer(dataPtr)).FyearOfCenturySwitch = *(*int32)(unsafe.Pointer(bp + 12))
				XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))
				goto _1
			}
			if i+int64(1) >= int64(objc) {
				XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, int64((*TClockClientData)(unsafe.Pointer(dataPtr)).FyearOfCenturySwitch)))
			}
		case 5:
			if i < int64(objc) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
					*(*int32)(unsafe.Pointer(bp + 16)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep)))
					v15 = libc.Int32FromInt32(TCL_OK)
				} else {
					v15 = XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp+16)
				}
				if v15 != TCL_OK {
					return int32(TCL_ERROR)
				}
				(*TClockClientData)(unsafe.Pointer(dataPtr)).FvalidMinYear = *(*int32)(unsafe.Pointer(bp + 16))
				XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))
				goto _1
			}
			if i+int64(1) >= int64(objc) {
				XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, int64((*TClockClientData)(unsafe.Pointer(dataPtr)).FvalidMinYear)))
			}
		case 6:
			if i < int64(objc) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
					*(*int32)(unsafe.Pointer(bp + 20)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep)))
					v16 = libc.Int32FromInt32(TCL_OK)
				} else {
					v16 = XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp+20)
				}
				if v16 != TCL_OK {
					return int32(TCL_ERROR)
				}
				(*TClockClientData)(unsafe.Pointer(dataPtr)).FvalidMaxYear = *(*int32)(unsafe.Pointer(bp + 20))
				XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))
				goto _1
			}
			if i+int64(1) >= int64(objc) {
				XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, int64((*TClockClientData)(unsafe.Pointer(dataPtr)).FvalidMaxYear)))
			}
		case 7:
			if i < int64(objc) {
				if XTcl_GetDoubleFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp+24) != TCL_OK {
					return int32(TCL_ERROR)
				}
				(*TClockClientData)(unsafe.Pointer(dataPtr)).FmaxJDN = *(*float64)(unsafe.Pointer(bp + 24))
				XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))
				goto _1
			}
			if i+int64(1) >= int64(objc) {
				XTcl_SetObjResult(tls, interp, XTcl_NewDoubleObj(tls, (*TClockClientData)(unsafe.Pointer(dataPtr)).FmaxJDN))
			}
		case 8:
			if i < int64(objc) {
				if XTcl_GetBoolFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), (libc.Int32FromInt32(TCL_NULL_OK)-libc.Int32FromInt32(2))&libc.Int32FromInt64(4), bp+32) != TCL_OK {
					return int32(TCL_ERROR)
				}
				if *(*int32)(unsafe.Pointer(bp + 32)) != 0 {
					*(*int32)(unsafe.Pointer(dataPtr + 480)) |= int32(CLF_VALIDATE)
				} else {
					*(*int32)(unsafe.Pointer(dataPtr + 480)) &= ^int32(CLF_VALIDATE)
				}
			}
			if i+int64(1) >= int64(objc) {
				XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64((*TClockClientData)(unsafe.Pointer(dataPtr)).FdefFlags&int32(CLF_VALIDATE) != 0)))
			}
		case 1:
			_ClockConfigureClear(tls, dataPtr)
		case 9:
			/*
			 * Init completed.
			 * Compile clock ensemble (performance purposes).
			 */
			token = XTcl_FindCommand(tls, interp, __ccgo_ts+12826, libc.UintptrFromInt32(0), int32(TCL_GLOBAL_ONLY))
			if !(token != 0) {
				return int32(TCL_ERROR)
			}
			*(*int32)(unsafe.Pointer(bp + 36)) = 0
			if XTcl_GetEnsembleFlags(tls, interp, token, bp+36) != TCL_OK {
				return int32(TCL_ERROR)
			}
			*(*int32)(unsafe.Pointer(bp + 36)) |= int32(ENSEMBLE_COMPILE)
			if XTcl_SetEnsembleFlags(tls, interp, token, *(*int32)(unsafe.Pointer(bp + 36))) != TCL_OK {
				return int32(TCL_ERROR)
			}
			break
		}
		goto _1
	_1:
		;
		i++
	}
	return TCL_OK
}

var _options = [13]uintptr{
	0:  __ccgo_ts + 12682,
	1:  __ccgo_ts + 12698,
	2:  __ccgo_ts + 12705,
	3:  __ccgo_ts + 12721,
	4:  __ccgo_ts + 12735,
	5:  __ccgo_ts + 12751,
	6:  __ccgo_ts + 12761,
	7:  __ccgo_ts + 12771,
	8:  __ccgo_ts + 12780,
	9:  __ccgo_ts + 12790,
	10: __ccgo_ts + 12805,
	11: __ccgo_ts + 12815,
	12: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * ClockGetTZData --
 *
 *	Retrieves tzdata table for given normalized timezone.
 *
 * Results:
 *	Returns a tcl object with tzdata.
 *
 * Side effects:
 *	The tzdata can be cached in ClockClientData structure.
 *
 *----------------------------------------------------------------------
 */

func _ClockGetTZData(tls *libc.TLS, dataPtr uintptr, interp uintptr, timezoneObj uintptr) (r uintptr) {
	/* Name of the timezone */
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, nval, nval1, nval2, out, prev, prev1, prev2, ret, v2, v4, v6, v8 uintptr
	var v1, v3, v5, v7 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, nval, nval1, nval2, out, prev, prev1, prev2, ret, v1, v2, v3, v4, v5, v6, v7, v8
	out = libc.UintptrFromInt32(0)
	/* if cached (if already setup this one) */
	if timezoneObj == (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZone || timezoneObj == (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZoneUnnorm {
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTZData != libc.UintptrFromInt32(0) {
			return (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTZData
		}
		out = dataPtr + 136
	}
	/* differentiate GMT and system zones, because used often */
	/* simple caching, because almost used the tz-data of last timezone
	 */
	if timezoneObj == (*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemTimeZone {
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemSetupTZData != libc.UintptrFromInt32(0) {
			return (*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemSetupTZData
		}
		out = dataPtr + 80
	} else {
		if timezoneObj == *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals + uintptr(LIT_GMT)*8)) || timezoneObj == (*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtSetupTimeZoneUnnorm {
			if (*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtSetupTZData != libc.UintptrFromInt32(0) {
				return (*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtSetupTZData
			}
			out = dataPtr + 104
		} else {
			if timezoneObj == (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZone || timezoneObj == (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZoneUnnorm {
				if (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTZData != libc.UintptrFromInt32(0) {
					return (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTZData
				}
				out = dataPtr + 160
			}
		}
	}
	ret = XTcl_ObjGetVar2(tls, interp, *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals + uintptr(LIT_TZDATA)*8)), timezoneObj, int32(TCL_LEAVE_ERR_MSG))
	/* cache using corresponding slot and as last used */
	if out != libc.UintptrFromInt32(0) {
		nval = ret
		if *(*uintptr)(unsafe.Pointer(out)) != nval {
			prev = *(*uintptr)(unsafe.Pointer(out))
			*(*uintptr)(unsafe.Pointer(out)) = nval
			if *(*uintptr)(unsafe.Pointer(out)) != 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(out)))).FrefCount++
			}
			if prev != libc.UintptrFromInt32(0) {
				_objPtr = prev
				v2 = _objPtr
				v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
				*(*TTcl_Size)(unsafe.Pointer(v2))--
				if v1 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
		}
	} else {
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZone != timezoneObj {
			_SavePrevTimezoneObj(tls, dataPtr)
			nval1 = timezoneObj
			if (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZone != nval1 {
				prev1 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZone
				(*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZone = nval1
				if (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZone != 0 {
					(*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZone)).FrefCount++
				}
				if prev1 != libc.UintptrFromInt32(0) {
					_objPtr1 = prev1
					v4 = _objPtr1
					v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
					*(*TTcl_Size)(unsafe.Pointer(v4))--
					if v3 <= int64(1) {
						XTclFreeObj(tls, _objPtr1)
					}
				}
			}
			if (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZoneUnnorm != libc.UintptrFromInt32(0) {
				_objPtr2 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZoneUnnorm
				v6 = _objPtr2
				v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
				*(*TTcl_Size)(unsafe.Pointer(v6))--
				if v5 <= int64(1) {
					XTclFreeObj(tls, _objPtr2)
				}
				(*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZoneUnnorm = libc.UintptrFromInt32(0)
			}
			nval2 = ret
			if (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTZData != nval2 {
				prev2 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTZData
				(*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTZData = nval2
				if (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTZData != 0 {
					(*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTZData)).FrefCount++
				}
				if prev2 != libc.UintptrFromInt32(0) {
					_objPtr3 = prev2
					v8 = _objPtr3
					v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
					*(*TTcl_Size)(unsafe.Pointer(v8))--
					if v7 <= int64(1) {
						XTclFreeObj(tls, _objPtr3)
					}
				}
			}
		}
	}
	return ret
}

/*
 *----------------------------------------------------------------------
 *
 * ClockGetSystemTimeZone --
 *
 *	Returns system (current) timezone.
 *
 *	If system zone not yet cached, it executes ::tcl::clock::GetSystemTimeZone
 *	in given interpreter and caches its result.
 *
 * Results:
 *	Returns normalized timezone object.
 *
 *----------------------------------------------------------------------
 */

func _ClockGetSystemTimeZone(tls *libc.TLS, dataPtr uintptr, interp uintptr) (r uintptr) {
	/* Tcl interpreter */
	var _objPtr, _objPtr1, _objPtr2, nval, prev, v2, v4, v6 uintptr
	var v1, v3, v5 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, nval, prev, v1, v2, v3, v4, v5, v6
	/* if known (cached and same epoch) - return now */
	if (*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemTimeZone != libc.UintptrFromInt32(0) && (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastTZEpoch == _TzsetIfNecessary(tls) {
		return (*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemTimeZone
	}
	if (*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemTimeZone != libc.UintptrFromInt32(0) {
		_objPtr = (*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemTimeZone
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		(*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemTimeZone = libc.UintptrFromInt32(0)
	}
	if (*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemSetupTZData != libc.UintptrFromInt32(0) {
		_objPtr1 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemSetupTZData
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		(*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemSetupTZData = libc.UintptrFromInt32(0)
	}
	if XTcl_EvalObjv(tls, interp, int64(1), (*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals+uintptr(LIT_GETSYSTEMTIMEZONE)*8, 0) != TCL_OK {
		return libc.UintptrFromInt32(0)
	}
	if (*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemTimeZone == libc.UintptrFromInt32(0) {
		nval = XTcl_GetObjResult(tls, interp)
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemTimeZone != nval {
			prev = (*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemTimeZone
			(*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemTimeZone = nval
			if (*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemTimeZone != 0 {
				(*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemTimeZone)).FrefCount++
			}
			if prev != libc.UintptrFromInt32(0) {
				_objPtr2 = prev
				v6 = _objPtr2
				v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
				*(*TTcl_Size)(unsafe.Pointer(v6))--
				if v5 <= int64(1) {
					XTclFreeObj(tls, _objPtr2)
				}
			}
		}
	}
	XTcl_ResetResult(tls, interp)
	return (*TClockClientData)(unsafe.Pointer(dataPtr)).FsystemTimeZone
}

/*
 *----------------------------------------------------------------------
 *
 * ClockSetupTimeZone --
 *
 *	Sets up the timezone. Loads tzdata, etc.
 *
 * Results:
 *	Returns normalized timezone object.
 *
 *----------------------------------------------------------------------
 */

func XClockSetupTimeZone(tls *libc.TLS, dataPtr uintptr, interp uintptr, timezoneObj uintptr) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _objPtr, nval, prev, v2 uintptr
	var v1 TTcl_Size
	var _ /* callargs at bp+8 */ [2]uintptr
	var _ /* loaded at bp+0 */ int32
	_, _, _, _, _ = _objPtr, nval, prev, v1, v2
	/* if cached (if already setup this one) */
	if timezoneObj == *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals + uintptr(LIT_GMT)*8)) && (*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtSetupTZData != libc.UintptrFromInt32(0) {
		return timezoneObj
	}
	if (timezoneObj == (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZone || timezoneObj == (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZoneUnnorm) && (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZone != libc.UintptrFromInt32(0) {
		return (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZone
	}
	if (timezoneObj == (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZone || timezoneObj == (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZoneUnnorm) && (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZone != libc.UintptrFromInt32(0) {
		return (*TClockClientData)(unsafe.Pointer(dataPtr)).FprevSetupTimeZone
	}
	/* differentiate normalized (last, GMT and system) zones, because used often and already set */
	(*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] = _NormTimezoneObj(tls, dataPtr, timezoneObj, bp)
	/* if loaded (setup already called for this TZ) */
	if *(*int32)(unsafe.Pointer(bp)) != 0 {
		return (*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)]
	}
	/* before setup just take a look in TZData variable */
	if XTcl_ObjGetVar2(tls, interp, *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals + uintptr(LIT_TZDATA)*8)), timezoneObj, 0) != 0 {
		/* put it to last slot and return normalized */
		_TimezoneLoaded(tls, dataPtr, (*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)], timezoneObj)
		return (*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)]
	}
	/* setup now */
	(*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0] = *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals + uintptr(LIT_SETUPTIMEZONE)*8))
	if XTcl_EvalObjv(tls, interp, int64(2), bp+8, 0) == TCL_OK {
		/* save unnormalized last used */
		nval = timezoneObj
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZoneUnnorm != nval {
			prev = (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZoneUnnorm
			(*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZoneUnnorm = nval
			if (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZoneUnnorm != 0 {
				(*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FlastSetupTimeZoneUnnorm)).FrefCount++
			}
			if prev != libc.UintptrFromInt32(0) {
				_objPtr = prev
				v2 = _objPtr
				v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
				*(*TTcl_Size)(unsafe.Pointer(v2))--
				if v1 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
		}
		return (*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)]
	}
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * ClockFormatNumericTimeZone --
 *
 *	Formats a time zone as +hhmmss
 *
 * Parameters:
 *	z - Time zone in seconds east of Greenwich
 *
 * Results:
 *	Returns the time zone object (formatted in a numeric form)
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XClockFormatNumericTimeZone(tls *libc.TLS, z int32) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var p uintptr
	var _ /* buf at bp+0 */ [13]uint8
	_ = p
	if z < 0 {
		z = -z
		*(*uint8)(unsafe.Pointer(bp)) = uint8('-')
	} else {
		*(*uint8)(unsafe.Pointer(bp)) = uint8('+')
	}
	XTclItoAw(tls, bp+uintptr(1), z/int32(3600), uint8('0'), uint16(2))
	z %= int32(3600)
	p = XTclItoAw(tls, bp+uintptr(3), z/int32(60), uint8('0'), uint16(2))
	z %= int32(60)
	if z != 0 {
		p = XTclItoAw(tls, bp+uintptr(5), z, uint8('0'), uint16(2))
	}
	return XTcl_NewStringObj(tls, bp, int64(p)-T__predefined_ptrdiff_t(bp))
}

/*
 *----------------------------------------------------------------------
 *
 * ClockConvertlocaltoutcObjCmd --
 *
 *	Tcl command that converts a UTC time to a local time by whatever means
 *	is available.
 *
 * Usage:
 *	::tcl::clock::ConvertUTCToLocal dictionary timezone changeover
 *
 * Parameters:
 *	dict - Dictionary containing a 'localSeconds' entry.
 *	timezone - Time zone
 *	changeover - Julian Day of the adoption of the Gregorian calendar.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	On success, sets the interpreter result to the given dictionary
 *	augmented with a 'seconds' field giving the UTC time. On failure,
 *	leaves an error message in the interpreter result.
 *
 *----------------------------------------------------------------------
 */

func _ClockConvertlocaltoutcObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(128)
	defer tls.Free(128) /* Parameter vector */
	var _objPtr, dataPtr, dict, v5 uintptr
	var created, status, v1, v2 int32
	var v3 bool
	var v4 TTcl_Size
	var _ /* changeover at bp+8 */ int32
	var _ /* fields at bp+16 */ TTclDateFields
	var _ /* secondsObj at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _ = _objPtr, created, dataPtr, dict, status, v1, v2, v3, v4, v5
	dataPtr = clientData
	created = 0
	(*(*TTclDateFields)(unsafe.Pointer(bp + 16))).FtzName = libc.UintptrFromInt32(0)
	/*
	 * Check params and convert time.
	 */
	if objc != int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+12834)
		return int32(TCL_ERROR)
	}
	dict = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	if XTcl_DictObjGet(tls, interp, dict, *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals + uintptr(LIT_LOCALSECONDS)*8)), bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+12859, int64(-libc.Int32FromInt32(1))))
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*TTcl_WideInt)(unsafe.Pointer(bp + 16 + 8)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FinternalRep))
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_GetWideIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), bp+16+8)
	}
	if v3 = v1 != TCL_OK; !v3 {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
			*(*int32)(unsafe.Pointer(bp + 8)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep)))
			v2 = libc.Int32FromInt32(TCL_OK)
		} else {
			v2 = XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)), bp+8)
		}
	}
	if v3 || v2 != TCL_OK || _ConvertLocalToUTC(tls, dataPtr, interp, bp+16, *(*uintptr)(unsafe.Pointer(objv + 2*8)), *(*int32)(unsafe.Pointer(bp + 8))) != 0 {
		return int32(TCL_ERROR)
	}
	/*
	 * Copy-on-write; set the 'seconds' field in the dictionary and place the
	 * modified dictionary in the interpreter result.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(dict)).FrefCount > int64(1) {
		dict = XTcl_DuplicateObj(tls, dict)
		created = int32(1)
		(*TTcl_Obj)(unsafe.Pointer(dict)).FrefCount++
	}
	status = XTcl_DictObjPut(tls, interp, dict, *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals + uintptr(LIT_SECONDS)*8)), XTcl_NewWideIntObj(tls, (*(*TTclDateFields)(unsafe.Pointer(bp + 16))).Fseconds))
	if status == TCL_OK {
		XTcl_SetObjResult(tls, interp, dict)
	}
	if created != 0 {
		_objPtr = dict
		v5 = _objPtr
		v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
		*(*TTcl_Size)(unsafe.Pointer(v5))--
		if v4 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	return status
}

/*
 *----------------------------------------------------------------------
 *
 * ClockGetdatefieldsObjCmd --
 *
 *	Tcl command that determines the values that [clock format] will use in
 *	formatting a date, and populates a dictionary with them.
 *
 * Usage:
 *	::tcl::clock::GetDateFields seconds timezone changeover
 *
 * Parameters:
 *	seconds - Time expressed in seconds from the Posix epoch.
 *	timezone - Time zone in which time is to be expressed.
 *	changeover - Julian Day Number at which the current locale adopted
 *		     the Gregorian calendar
 *
 * Results:
 *	Returns a dictonary populated with the fields:
 *		seconds - Seconds from the Posix epoch
 *		localSeconds - Nominal seconds from the Posix epoch in the
 *			       local time zone.
 *		tzOffset - Time zone offset in seconds east of Greenwich
 *		tzName - Time zone name
 *		julianDay - Julian Day Number in the local time zone
 *
 *----------------------------------------------------------------------
 */

func _ClockGetdatefieldsObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(128)
	defer tls.Free(128) /* Parameter vector */
	var _objPtr, dataPtr, dict, lit, v5 uintptr
	var v1, v2, v6 int32
	var v3 bool
	var v4 TTcl_Size
	var _ /* changeover at bp+112 */ int32
	var _ /* fields at bp+0 */ TTclDateFields
	_, _, _, _, _, _, _, _, _, _ = _objPtr, dataPtr, dict, lit, v1, v2, v3, v4, v5, v6
	dataPtr = clientData
	lit = (*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals
	(*(*TTclDateFields)(unsafe.Pointer(bp))).FtzName = libc.UintptrFromInt32(0)
	/*
	 * Check params.
	 */
	if objc != int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+12902)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*TTcl_WideInt)(unsafe.Pointer(bp)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FinternalRep))
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_GetWideIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
	}
	if v3 = v1 != TCL_OK; !v3 {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
			*(*int32)(unsafe.Pointer(bp + 112)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep)))
			v2 = libc.Int32FromInt32(TCL_OK)
		} else {
			v2 = XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)), bp+112)
		}
	}
	if v3 || v2 != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * fields.seconds could be an unsigned number that overflowed. Make sure
	 * that it isn't.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclBignumType)) {
		XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(lit + uintptr(LIT_INTEGER_VALUE_TOO_LARGE)*8)))
		return int32(TCL_ERROR)
	}
	/* Extract fields */
	if _ClockGetDateFields(tls, dataPtr, interp, bp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), *(*int32)(unsafe.Pointer(bp + 112))) != TCL_OK {
		return int32(TCL_ERROR)
	}
	/* Make dict of fields */
	dict = XTcl_NewDictObj(tls)
	XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dict, *(*uintptr)(unsafe.Pointer(lit + uintptr(LIT_LOCALSECONDS)*8)), XTcl_NewWideIntObj(tls, (*(*TTclDateFields)(unsafe.Pointer(bp))).FlocalSeconds))
	XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dict, *(*uintptr)(unsafe.Pointer(lit + uintptr(LIT_SECONDS)*8)), XTcl_NewWideIntObj(tls, (*(*TTclDateFields)(unsafe.Pointer(bp))).Fseconds))
	XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dict, *(*uintptr)(unsafe.Pointer(lit + uintptr(LIT_TZNAME)*8)), (*(*TTclDateFields)(unsafe.Pointer(bp))).FtzName)
	_objPtr = (*(*TTclDateFields)(unsafe.Pointer(bp))).FtzName
	v5 = _objPtr
	v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
	*(*TTcl_Size)(unsafe.Pointer(v5))--
	if v4 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dict, *(*uintptr)(unsafe.Pointer(lit + uintptr(LIT_TZOFFSET)*8)), XTcl_NewWideIntObj(tls, int64((*(*TTclDateFields)(unsafe.Pointer(bp))).FtzOffset)))
	XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dict, *(*uintptr)(unsafe.Pointer(lit + uintptr(LIT_JULIANDAY)*8)), XTcl_NewWideIntObj(tls, (*(*TTclDateFields)(unsafe.Pointer(bp))).FjulianDay))
	XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dict, *(*uintptr)(unsafe.Pointer(lit + uintptr(LIT_GREGORIAN)*8)), XTcl_NewWideIntObj(tls, int64((*(*TTclDateFields)(unsafe.Pointer(bp))).Fgregorian)))
	if (*(*TTclDateFields)(unsafe.Pointer(bp))).FisBce != 0 {
		v6 = int32(LIT_BCE)
	} else {
		v6 = int32(LIT_CE)
	}
	XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dict, *(*uintptr)(unsafe.Pointer(lit + uintptr(LIT_ERA)*8)), *(*uintptr)(unsafe.Pointer(lit + uintptr(v6)*8)))
	XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dict, *(*uintptr)(unsafe.Pointer(lit + uintptr(LIT_YEAR)*8)), XTcl_NewWideIntObj(tls, int64((*(*TTclDateFields)(unsafe.Pointer(bp))).Fyear)))
	XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dict, *(*uintptr)(unsafe.Pointer(lit + uintptr(LIT_DAYOFYEAR)*8)), XTcl_NewWideIntObj(tls, int64((*(*TTclDateFields)(unsafe.Pointer(bp))).FdayOfYear)))
	XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dict, *(*uintptr)(unsafe.Pointer(lit + uintptr(LIT_MONTH)*8)), XTcl_NewWideIntObj(tls, int64((*(*TTclDateFields)(unsafe.Pointer(bp))).Fmonth)))
	XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dict, *(*uintptr)(unsafe.Pointer(lit + uintptr(LIT_DAYOFMONTH)*8)), XTcl_NewWideIntObj(tls, int64((*(*TTclDateFields)(unsafe.Pointer(bp))).FdayOfMonth)))
	XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dict, *(*uintptr)(unsafe.Pointer(lit + uintptr(LIT_ISO8601YEAR)*8)), XTcl_NewWideIntObj(tls, int64((*(*TTclDateFields)(unsafe.Pointer(bp))).Fiso8601Year)))
	XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dict, *(*uintptr)(unsafe.Pointer(lit + uintptr(LIT_ISO8601WEEK)*8)), XTcl_NewWideIntObj(tls, int64((*(*TTclDateFields)(unsafe.Pointer(bp))).Fiso8601Week)))
	XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dict, *(*uintptr)(unsafe.Pointer(lit + uintptr(LIT_DAYOFWEEK)*8)), XTcl_NewWideIntObj(tls, int64((*(*TTclDateFields)(unsafe.Pointer(bp))).FdayOfWeek)))
	XTcl_SetObjResult(tls, interp, dict)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * ClockGetDateFields --
 *
 *	Converts given UTC time (seconds in a TclDateFields structure)
 *	to local time and determines the values that clock routines will
 *	use in scanning or formatting a date.
 *
 * Results:
 *	Date-time values are stored in structure "fields".
 *	Returns a standard Tcl result.
 *
 *----------------------------------------------------------------------
 */

func _ClockGetDateFields(tls *libc.TLS, dataPtr uintptr, interp uintptr, fields uintptr, timezoneObj uintptr, changeover int32) (r int32) {
	/* Julian Day Number */
	/*
	 * Convert UTC time to local.
	 */
	if XConvertUTCToLocal(tls, dataPtr, interp, fields, timezoneObj, changeover) != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Extract Julian day and seconds of the day.
	 */
	(*TTclDateFields)(unsafe.Pointer(fields)).FjulianDay = (*TTclDateFields)(unsafe.Pointer(fields)).FlocalSeconds + libc.Int64FromInt32(JULIAN_DAY_POSIX_EPOCH)*libc.Int64FromInt32(SECONDS_PER_DAY)
	if (*TTclDateFields)(unsafe.Pointer(fields)).FjulianDay >= int64(SECONDS_PER_DAY) || (*TTclDateFields)(unsafe.Pointer(fields)).FjulianDay <= int64(-int32(SECONDS_PER_DAY)) {
		*(*TTcl_WideInt)(unsafe.Pointer(fields + 24)) /= int64(SECONDS_PER_DAY)
		(*TTclDateFields)(unsafe.Pointer(fields)).FsecondOfDay = int64(int32((*TTclDateFields)(unsafe.Pointer(fields)).FlocalSeconds % libc.Int64FromInt32(SECONDS_PER_DAY)))
	} else {
		(*TTclDateFields)(unsafe.Pointer(fields)).FsecondOfDay = int64(int32((*TTclDateFields)(unsafe.Pointer(fields)).FjulianDay))
		(*TTclDateFields)(unsafe.Pointer(fields)).FjulianDay = libc.Int64FromInt32(0)
	}
	if (*TTclDateFields)(unsafe.Pointer(fields)).FsecondOfDay < 0 {
		*(*TTcl_WideInt)(unsafe.Pointer(fields + 88)) += int64(SECONDS_PER_DAY) /* JD is affected, if switched into negative (avoid 24 hours difference) */
		if (*TTclDateFields)(unsafe.Pointer(fields)).FjulianDay <= 0 {
			(*TTclDateFields)(unsafe.Pointer(fields)).FjulianDay--
		}
	}
	/*
	 * Convert to Julian or Gregorian calendar.
	 */
	_GetGregorianEraYearDay(tls, fields, changeover)
	_GetMonthDay(tls, fields)
	_GetYearWeekDay(tls, fields, changeover)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * ClockGetjuliandayfromerayearmonthdayObjCmd --
 *
 *	Tcl command that converts a time from era-year-month-day to a Julian
 *	Day Number.
 *
 * Parameters:
 *	dict - Dictionary that contains 'era', 'year', 'month' and
 *	       'dayOfMonth' keys.
 *	changeover - Julian Day of changeover to the Gregorian calendar
 *
 * Results:
 *	Result is either TCL_OK, with the interpreter result being the
 *	dictionary augmented with a 'julianDay' key, or TCL_ERROR,
 *	with the result being an error message.
 *
 *----------------------------------------------------------------------
 */

func _FetchEraField(tls *libc.TLS, interp uintptr, dict uintptr, key uintptr, storePtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _ /* value at bp+0 */ uintptr
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	if XTcl_DictObjGet(tls, interp, dict, key, bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+12930, int64(-libc.Int32FromInt32(1))))
		return int32(TCL_ERROR)
	}
	return XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), uintptr(unsafe.Pointer(&_eras)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11718, libc.Int32FromInt32(TCL_EXACT)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), storePtr)
}

func _FetchIntField(tls *libc.TLS, interp uintptr, dict uintptr, key uintptr, storePtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var v1 int32
	var _ /* value at bp+0 */ uintptr
	_ = v1
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	if XTcl_DictObjGet(tls, interp, dict, key, bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+12930, int64(-libc.Int32FromInt32(1))))
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
		*(*int32)(unsafe.Pointer(storePtr)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FinternalRep)))
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), storePtr)
	}
	return v1
}

func _ClockGetjuliandayfromerayearmonthdayObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(128)
	defer tls.Free(128) /* Parameter vector */
	var _objPtr, data, dict, lit, v4 uintptr
	var copied, status, v1 int32
	var v2 bool
	var v3 TTcl_Size
	var _ /* changeover at bp+112 */ int32
	var _ /* fields at bp+0 */ TTclDateFields
	var _ /* isBce at bp+116 */ int32
	_, _, _, _, _, _, _, _, _, _ = _objPtr, copied, data, dict, lit, status, v1, v2, v3, v4
	data = clientData
	lit = (*TClockClientData)(unsafe.Pointer(data)).Fliterals
	copied = 0
	*(*int32)(unsafe.Pointer(bp + 116)) = 0
	(*(*TTclDateFields)(unsafe.Pointer(bp))).FtzName = libc.UintptrFromInt32(0)
	/*
	 * Check params.
	 */
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+12970)
		return int32(TCL_ERROR)
	}
	dict = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	if v2 = _FetchEraField(tls, interp, dict, *(*uintptr)(unsafe.Pointer(lit + uintptr(LIT_ERA)*8)), bp+116) != TCL_OK || _FetchIntField(tls, interp, dict, *(*uintptr)(unsafe.Pointer(lit + uintptr(LIT_YEAR)*8)), bp+40) != TCL_OK || _FetchIntField(tls, interp, dict, *(*uintptr)(unsafe.Pointer(lit + uintptr(LIT_MONTH)*8)), bp+48) != TCL_OK || _FetchIntField(tls, interp, dict, *(*uintptr)(unsafe.Pointer(lit + uintptr(LIT_DAYOFMONTH)*8)), bp+52) != TCL_OK; !v2 {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
			*(*int32)(unsafe.Pointer(bp + 112)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)))
			v1 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1 = XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp+112)
		}
	}
	if v2 || v1 != TCL_OK {
		return int32(TCL_ERROR)
	}
	(*(*TTclDateFields)(unsafe.Pointer(bp))).FisBce = *(*int32)(unsafe.Pointer(bp + 116))
	/*
	 * Get Julian day.
	 */
	XGetJulianDayFromEraYearMonthDay(tls, bp, *(*int32)(unsafe.Pointer(bp + 112)))
	/*
	 * Store Julian day in the dictionary - copy on write.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(dict)).FrefCount > int64(1) {
		dict = XTcl_DuplicateObj(tls, dict)
		(*TTcl_Obj)(unsafe.Pointer(dict)).FrefCount++
		copied = int32(1)
	}
	status = XTcl_DictObjPut(tls, interp, dict, *(*uintptr)(unsafe.Pointer(lit + uintptr(LIT_JULIANDAY)*8)), XTcl_NewWideIntObj(tls, (*(*TTclDateFields)(unsafe.Pointer(bp))).FjulianDay))
	if status == TCL_OK {
		XTcl_SetObjResult(tls, interp, dict)
	}
	if copied != 0 {
		_objPtr = dict
		v4 = _objPtr
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	return status
}

/*
 *----------------------------------------------------------------------
 *
 * ClockGetjuliandayfromerayearweekdayObjCmd --
 *
 *	Tcl command that converts a time from the ISO calendar to a Julian Day
 *	Number.
 *
 * Parameters:
 *	dict - Dictionary that contains 'era', 'iso8601Year', 'iso8601Week'
 *	       and 'dayOfWeek' keys.
 *	changeover - Julian Day of changeover to the Gregorian calendar
 *
 * Results:
 *	Result is either TCL_OK, with the interpreter result being the
 *	dictionary augmented with a 'julianDay' key, or TCL_ERROR, with the
 *	result being an error message.
 *
 *----------------------------------------------------------------------
 */

func _ClockGetjuliandayfromerayearweekdayObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(128)
	defer tls.Free(128) /* Parameter vector */
	var _objPtr, data, dict, lit, v4 uintptr
	var copied, status, v1 int32
	var v2 bool
	var v3 TTcl_Size
	var _ /* changeover at bp+112 */ int32
	var _ /* fields at bp+0 */ TTclDateFields
	var _ /* isBce at bp+116 */ int32
	_, _, _, _, _, _, _, _, _, _ = _objPtr, copied, data, dict, lit, status, v1, v2, v3, v4
	data = clientData
	lit = (*TClockClientData)(unsafe.Pointer(data)).Fliterals
	copied = 0
	*(*int32)(unsafe.Pointer(bp + 116)) = 0
	(*(*TTclDateFields)(unsafe.Pointer(bp))).FtzName = libc.UintptrFromInt32(0)
	/*
	 * Check params.
	 */
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+12970)
		return int32(TCL_ERROR)
	}
	dict = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	if v2 = _FetchEraField(tls, interp, dict, *(*uintptr)(unsafe.Pointer(lit + uintptr(LIT_ERA)*8)), bp+116) != TCL_OK || _FetchIntField(tls, interp, dict, *(*uintptr)(unsafe.Pointer(lit + uintptr(LIT_ISO8601YEAR)*8)), bp+56) != TCL_OK || _FetchIntField(tls, interp, dict, *(*uintptr)(unsafe.Pointer(lit + uintptr(LIT_ISO8601WEEK)*8)), bp+60) != TCL_OK || _FetchIntField(tls, interp, dict, *(*uintptr)(unsafe.Pointer(lit + uintptr(LIT_DAYOFWEEK)*8)), bp+64) != TCL_OK; !v2 {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
			*(*int32)(unsafe.Pointer(bp + 112)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)))
			v1 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1 = XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp+112)
		}
	}
	if v2 || v1 != TCL_OK {
		return int32(TCL_ERROR)
	}
	(*(*TTclDateFields)(unsafe.Pointer(bp))).FisBce = *(*int32)(unsafe.Pointer(bp + 116))
	/*
	 * Get Julian day.
	 */
	XGetJulianDayFromEraYearWeekDay(tls, bp, *(*int32)(unsafe.Pointer(bp + 112)))
	/*
	 * Store Julian day in the dictionary - copy on write.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(dict)).FrefCount > int64(1) {
		dict = XTcl_DuplicateObj(tls, dict)
		(*TTcl_Obj)(unsafe.Pointer(dict)).FrefCount++
		copied = int32(1)
	}
	status = XTcl_DictObjPut(tls, interp, dict, *(*uintptr)(unsafe.Pointer(lit + uintptr(LIT_JULIANDAY)*8)), XTcl_NewWideIntObj(tls, (*(*TTclDateFields)(unsafe.Pointer(bp))).FjulianDay))
	if status == TCL_OK {
		XTcl_SetObjResult(tls, interp, dict)
	}
	if copied != 0 {
		_objPtr = dict
		v4 = _objPtr
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	return status
}

/*
 *----------------------------------------------------------------------
 *
 * ConvertLocalToUTC --
 *
 *	Converts a time (in a TclDateFields structure) from the local wall
 *	clock to UTC.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	Populates the 'seconds' field if successful; stores an error message
 *	in the interpreter result on failure.
 *
 *----------------------------------------------------------------------
 */

func _ConvertLocalToUTC(tls *libc.TLS, dataPtr uintptr, interp uintptr, fields uintptr, timezoneObj uintptr, changeover int32) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Julian Day of the Gregorian transition */
	var _objPtr, _objPtr1, _objPtr2, ltzoc, nval, prev, tzdata, v10, v6, v8 uintptr
	var seconds TTcl_WideInt
	var v2 int32
	var v3, v4 int64
	var v5, v7, v9 TTcl_Size
	var _ /* rangesVal at bp+16 */ [2]TTcl_WideInt
	var _ /* rowc at bp+0 */ TTcl_Size
	var _ /* rowv at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, ltzoc, nval, prev, seconds, tzdata, v10, v2, v3, v4, v5, v6, v7, v8, v9
	ltzoc = libc.UintptrFromInt32(0)
	/* fast phase-out for shared GMT-object (don't need to convert UTC 2 UTC) */
	if timezoneObj == *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals + uintptr(LIT_GMT)*8)) {
		(*TTclDateFields)(unsafe.Pointer(fields)).Fseconds = (*TTclDateFields)(unsafe.Pointer(fields)).FlocalSeconds
		(*TTclDateFields)(unsafe.Pointer(fields)).FtzOffset = 0
		return TCL_OK
	}
	/*
	 * Check cacheable conversion could be used
	 * (last-period UTC2Local cache within the same TZ and seconds)
	 */
	*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	for {
		if !(*(*TTcl_Size)(unsafe.Pointer(bp)) < int64(2)) {
			break
		}
		ltzoc = dataPtr + 368 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))*56
		if timezoneObj != (*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtimezoneObj || changeover != (*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).Fchangeover {
			ltzoc = libc.UintptrFromInt32(0)
			goto _1
		}
		seconds = (*TTclDateFields)(unsafe.Pointer(fields)).FlocalSeconds - int64((*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtzOffset)
		if seconds >= *(*TTcl_WideInt)(unsafe.Pointer(ltzoc + 24)) && seconds < *(*TTcl_WideInt)(unsafe.Pointer(ltzoc + 24 + 1*8)) {
			/* the same time zone and offset (UTC time inside the last minute) */
			(*TTclDateFields)(unsafe.Pointer(fields)).FtzOffset = (*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtzOffset
			(*TTclDateFields)(unsafe.Pointer(fields)).Fseconds = seconds
			return TCL_OK
		}
		/* in the DST-hole (because of the check above) - correct localSeconds */
		if (*TTclDateFields)(unsafe.Pointer(fields)).FlocalSeconds == (*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FlocalSeconds {
			/* the same time zone and offset (but we'll shift local-time) */
			(*TTclDateFields)(unsafe.Pointer(fields)).FtzOffset = (*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtzOffset
			(*TTclDateFields)(unsafe.Pointer(fields)).Fseconds = seconds
			goto dstHole
		}
		goto _1
	_1:
		;
		*(*TTcl_Size)(unsafe.Pointer(bp))++
	}
	/*
	 * Unpack the tz data.
	 */
	tzdata = _ClockGetTZData(tls, dataPtr, interp, timezoneObj)
	if tzdata == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(tzdata)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(tzdata + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(tzdata + 32))).Fptr2)).FspanStart
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(tzdata + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(tzdata + 32))).Fptr1 + 40 + uintptr(v3)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(tzdata + 32))).Fptr2 != 0 {
			v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(tzdata + 32))).Fptr2)).FspanLength
		} else {
			v4 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(tzdata + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v4
		v2 = libc.Int32FromInt32(TCL_OK)
	} else {
		v2 = XTcl_ListObjGetElements(tls, interp, tzdata, bp, bp+8)
	}
	if v2 != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Special case: If the time zone is :localtime, the tzdata will be empty.
	 * Use 'mktime' to convert the time to local
	 */
	if *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
		if _ConvertLocalToUTCUsingC(tls, interp, fields, changeover) != TCL_OK {
			return int32(TCL_ERROR)
		}
		/* we cannot cache (ranges unknown yet) - todo: check later the DST-hole here */
		return TCL_OK
	} else {
		if _ConvertLocalToUTCUsingTable(tls, interp, fields, int32(*(*TTcl_Size)(unsafe.Pointer(bp))), *(*uintptr)(unsafe.Pointer(bp + 8)), bp+16) != TCL_OK {
			return int32(TCL_ERROR)
		}
		seconds = (*TTclDateFields)(unsafe.Pointer(fields)).Fseconds
		/* Cache the last conversion */
		if ltzoc != libc.UintptrFromInt32(0) { /* slot was found above */
			/* timezoneObj and changeover are the same */
			nval = (*TTclDateFields)(unsafe.Pointer(fields)).FtzName
			if (*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtzName != nval {
				prev = (*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtzName
				(*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtzName = nval
				if (*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtzName != 0 {
					(*TTcl_Obj)(unsafe.Pointer((*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtzName)).FrefCount++
				}
				if prev != libc.UintptrFromInt32(0) {
					_objPtr = prev
					v6 = _objPtr
					v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
					*(*TTcl_Size)(unsafe.Pointer(v6))--
					if v5 <= int64(1) {
						XTclFreeObj(tls, _objPtr)
					}
				}
			} /* may be NULL */
		} else {
			/* no TZ in cache - just move second slot down and use the first one */
			ltzoc = dataPtr + 368
			if (*(*TClockLastTZOffs)(unsafe.Pointer(dataPtr + 368 + 1*56))).FtimezoneObj != libc.UintptrFromInt32(0) {
				_objPtr1 = (*(*TClockLastTZOffs)(unsafe.Pointer(dataPtr + 368 + 1*56))).FtimezoneObj
				v8 = _objPtr1
				v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
				*(*TTcl_Size)(unsafe.Pointer(v8))--
				if v7 <= int64(1) {
					XTclFreeObj(tls, _objPtr1)
				}
				(*(*TClockLastTZOffs)(unsafe.Pointer(dataPtr + 368 + 1*56))).FtimezoneObj = libc.UintptrFromInt32(0)
			}
			if (*(*TClockLastTZOffs)(unsafe.Pointer(dataPtr + 368 + 1*56))).FtzName != libc.UintptrFromInt32(0) {
				_objPtr2 = (*(*TClockLastTZOffs)(unsafe.Pointer(dataPtr + 368 + 1*56))).FtzName
				v10 = _objPtr2
				v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
				*(*TTcl_Size)(unsafe.Pointer(v10))--
				if v9 <= int64(1) {
					XTclFreeObj(tls, _objPtr2)
				}
				(*(*TClockLastTZOffs)(unsafe.Pointer(dataPtr + 368 + 1*56))).FtzName = libc.UintptrFromInt32(0)
			}
			libc.Xmemcpy(tls, dataPtr+368+1*56, ltzoc, uint64(56))
			(*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtimezoneObj = timezoneObj
			if (*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtimezoneObj != 0 {
				(*TTcl_Obj)(unsafe.Pointer((*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtimezoneObj)).FrefCount++
			}
			(*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).Fchangeover = changeover
			(*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtzName = (*TTclDateFields)(unsafe.Pointer(fields)).FtzName
			if (*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtzName != 0 {
				(*TTcl_Obj)(unsafe.Pointer((*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtzName)).FrefCount++
			} /* may be NULL */
		}
		(*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FlocalSeconds = (*TTclDateFields)(unsafe.Pointer(fields)).FlocalSeconds
		*(*TTcl_WideInt)(unsafe.Pointer(ltzoc + 24)) = (*(*[2]TTcl_WideInt)(unsafe.Pointer(bp + 16)))[0]
		*(*TTcl_WideInt)(unsafe.Pointer(ltzoc + 24 + 1*8)) = (*(*[2]TTcl_WideInt)(unsafe.Pointer(bp + 16)))[int32(1)]
		(*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtzOffset = (*TTclDateFields)(unsafe.Pointer(fields)).FtzOffset
	}
	/* check DST-hole: if retrieved seconds is out of range */
	if !(*(*TTcl_WideInt)(unsafe.Pointer(ltzoc + 24)) > seconds || seconds >= *(*TTcl_WideInt)(unsafe.Pointer(ltzoc + 24 + 1*8))) {
		goto _11
	}
	goto dstHole
dstHole:
	;
	/* because we don't know real TZ (we're outsize), just invalidate local
	 * time (which could be verified in ClockValidDate later) */
	(*TTclDateFields)(unsafe.Pointer(fields)).FlocalSeconds = -libc.Int64FromInt64(0x00F0000000000000) - libc.Int64FromInt32(1) /* not valid seconds */
_11:
	;
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * ConvertLocalToUTCUsingTable --
 *
 *	Converts a time (in a TclDateFields structure) from local time in a
 *	given time zone to UTC.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	Stores an error message in the interpreter if an error occurs; if
 *	successful, stores the 'seconds' field in 'fields.
 *
 *----------------------------------------------------------------------
 */

func _ConvertLocalToUTCUsingTable(tls *libc.TLS, interp uintptr, fields uintptr, rowc int32, rowv uintptr, rangesVal uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Return bounds for time period */
	var _objPtr, nval, prev, row, v10 uintptr
	var have [8]struct {
		FtzName   uintptr
		FtzOffset int32
	}
	var i, v9 TTcl_Size
	var nHave, v1, v5, v8 int32
	var v2, v3 int64
	var v4, v6 bool
	var _ /* cellc at bp+0 */ TTcl_Size
	var _ /* cellv at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, have, i, nHave, nval, prev, row, v1, v10, v2, v3, v4, v5, v6, v8, v9
	nHave = 0
	/*
	 * Perform an initial lookup assuming that local == UTC, and locate the
	 * last time conversion prior to that time. Get the offset from that row,
	 * and look up again. Continue until we find an offset that we found
	 * before. This definition, rather than "the same offset" ensures that we
	 * don't enter an endless loop, as would otherwise happen when trying to
	 * convert a non-existent time such as 02:30 during the US Spring Daylight
	 * Saving Time transition.
	 */
	(*TTclDateFields)(unsafe.Pointer(fields)).FtzOffset = 0
	(*TTclDateFields)(unsafe.Pointer(fields)).Fseconds = (*TTclDateFields)(unsafe.Pointer(fields)).FlocalSeconds
	for int32(1) != 0 {
		row = XLookupLastTransition(tls, interp, (*TTclDateFields)(unsafe.Pointer(fields)).Fseconds, int64(rowc), rowv, rangesVal)
		if v4 = row == libc.UintptrFromInt32(0); !v4 {
			if (*TTcl_Obj)(unsafe.Pointer(row)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(row + 32))).Fptr2 != 0 {
					v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(row + 32))).Fptr2)).FspanStart
				} else {
					v2 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(row + 32))).Fptr1)).FfirstUsed
				}
				*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(row + 32))).Fptr1 + 40 + uintptr(v2)*8
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(row + 32))).Fptr2 != 0 {
					v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(row + 32))).Fptr2)).FspanLength
				} else {
					v3 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(row + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp)) = v3
				v1 = libc.Int32FromInt32(TCL_OK)
			} else {
				v1 = XTcl_ListObjGetElements(tls, interp, row, bp, bp+8)
			}
		}
		if v6 = v4 || v1 != TCL_OK; !v6 {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*8)))).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*8)))).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
				*(*int32)(unsafe.Pointer(fields + 16)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*8)))).FinternalRep)))
				v5 = libc.Int32FromInt32(TCL_OK)
			} else {
				v5 = XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*8)), fields+16)
			}
		}
		if v6 || v5 != TCL_OK {
			return int32(TCL_ERROR)
		}
		i = 0
		for {
			if !(i < int64(nHave)) {
				break
			}
			if have[i].FtzOffset == (*TTclDateFields)(unsafe.Pointer(fields)).FtzOffset {
				goto found
			}
			goto _7
		_7:
			;
			i++
		}
		if nHave == int32(8) {
			XTcl_Panic(tls, __ccgo_ts+12986, 0)
		}
		have[nHave].FtzName = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 3*8))
		v8 = nHave
		nHave++
		have[v8].FtzOffset = (*TTclDateFields)(unsafe.Pointer(fields)).FtzOffset
		(*TTclDateFields)(unsafe.Pointer(fields)).Fseconds = (*TTclDateFields)(unsafe.Pointer(fields)).FlocalSeconds - int64((*TTclDateFields)(unsafe.Pointer(fields)).FtzOffset)
	}
	goto found
found:
	;
	(*TTclDateFields)(unsafe.Pointer(fields)).FtzOffset = have[i].FtzOffset
	(*TTclDateFields)(unsafe.Pointer(fields)).Fseconds = (*TTclDateFields)(unsafe.Pointer(fields)).FlocalSeconds - int64((*TTclDateFields)(unsafe.Pointer(fields)).FtzOffset)
	nval = have[i].FtzName
	if (*TTclDateFields)(unsafe.Pointer(fields)).FtzName != nval {
		prev = (*TTclDateFields)(unsafe.Pointer(fields)).FtzName
		(*TTclDateFields)(unsafe.Pointer(fields)).FtzName = nval
		if (*TTclDateFields)(unsafe.Pointer(fields)).FtzName != 0 {
			(*TTcl_Obj)(unsafe.Pointer((*TTclDateFields)(unsafe.Pointer(fields)).FtzName)).FrefCount++
		}
		if prev != libc.UintptrFromInt32(0) {
			_objPtr = prev
			v10 = _objPtr
			v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
			*(*TTcl_Size)(unsafe.Pointer(v10))--
			if v9 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * ConvertLocalToUTCUsingC --
 *
 *	Converts a time from local wall clock to UTC when the local time zone
 *	cannot be determined. Uses 'mktime' to do the job.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	Stores an error message in the interpreter if an error occurs; if
 *	successful, stores the 'seconds' field in 'fields.
 *
 *----------------------------------------------------------------------
 */

func _ConvertLocalToUTCUsingC(tls *libc.TLS, interp uintptr, fields uintptr, changeover int32) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Julian Day of the Gregorian transition */
	var localErrno, secondOfDay, v1 int32
	var _ /* timeVal at bp+0 */ Ttm
	_, _, _ = localErrno, secondOfDay, v1
	/*
	 * Convert the given time to a date.
	 */
	(*TTclDateFields)(unsafe.Pointer(fields)).FjulianDay = (*TTclDateFields)(unsafe.Pointer(fields)).FlocalSeconds + libc.Int64FromInt32(JULIAN_DAY_POSIX_EPOCH)*libc.Int64FromInt32(SECONDS_PER_DAY)
	if (*TTclDateFields)(unsafe.Pointer(fields)).FjulianDay >= int64(SECONDS_PER_DAY) || (*TTclDateFields)(unsafe.Pointer(fields)).FjulianDay <= int64(-int32(SECONDS_PER_DAY)) {
		*(*TTcl_WideInt)(unsafe.Pointer(fields + 24)) /= int64(SECONDS_PER_DAY)
		secondOfDay = int32((*TTclDateFields)(unsafe.Pointer(fields)).FlocalSeconds % libc.Int64FromInt32(SECONDS_PER_DAY))
	} else {
		secondOfDay = int32((*TTclDateFields)(unsafe.Pointer(fields)).FjulianDay)
		(*TTclDateFields)(unsafe.Pointer(fields)).FjulianDay = libc.Int64FromInt32(0)
	}
	if secondOfDay < 0 {
		secondOfDay += int32(SECONDS_PER_DAY) /* JD is affected, if switched into negative (avoid 24 hours difference) */
		if (*TTclDateFields)(unsafe.Pointer(fields)).FjulianDay <= 0 {
			(*TTclDateFields)(unsafe.Pointer(fields)).FjulianDay--
		}
	}
	_GetGregorianEraYearDay(tls, fields, changeover)
	_GetMonthDay(tls, fields)
	/*
	 * Convert the date/time to a 'struct tm'.
	 */
	(*(*Ttm)(unsafe.Pointer(bp))).Ftm_year = (*TTclDateFields)(unsafe.Pointer(fields)).Fyear - int32(1900)
	(*(*Ttm)(unsafe.Pointer(bp))).Ftm_mon = (*TTclDateFields)(unsafe.Pointer(fields)).Fmonth - int32(1)
	(*(*Ttm)(unsafe.Pointer(bp))).Ftm_mday = (*TTclDateFields)(unsafe.Pointer(fields)).FdayOfMonth
	(*(*Ttm)(unsafe.Pointer(bp))).Ftm_hour = secondOfDay / int32(3600) % int32(24)
	(*(*Ttm)(unsafe.Pointer(bp))).Ftm_min = secondOfDay / int32(60) % int32(60)
	(*(*Ttm)(unsafe.Pointer(bp))).Ftm_sec = secondOfDay % int32(60)
	(*(*Ttm)(unsafe.Pointer(bp))).Ftm_isdst = -int32(1)
	(*(*Ttm)(unsafe.Pointer(bp))).Ftm_wday = -int32(1)
	(*(*Ttm)(unsafe.Pointer(bp))).Ftm_yday = -int32(1)
	/*
	 * Get local time. It is rumored that mktime is not thread safe on some
	 * platforms, so seize a mutex before attempting this.
	 */
	_TzsetIfNecessary(tls)
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_clockMutex)))
	*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = 0
	(*TTclDateFields)(unsafe.Pointer(fields)).Fseconds = int64(libc.Xmktime(tls, bp))
	if (*TTclDateFields)(unsafe.Pointer(fields)).Fseconds == int64(-int32(1)) {
		v1 = *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))
	} else {
		v1 = 0
	}
	localErrno = v1
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_clockMutex)))
	/*
	 * If conversion fails, report an error.
	 */
	if localErrno != 0 || (*TTclDateFields)(unsafe.Pointer(fields)).Fseconds == int64(-int32(1)) && (*(*Ttm)(unsafe.Pointer(bp))).Ftm_yday == -int32(1) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+13022, int64(-libc.Int32FromInt32(1))))
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * ConvertUTCToLocal --
 *
 *	Converts a time (in a TclDateFields structure) from UTC to local time.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	Populates the 'tzName' and 'tzOffset' fields.
 *
 *----------------------------------------------------------------------
 */

func XConvertUTCToLocal(tls *libc.TLS, dataPtr uintptr, interp uintptr, fields uintptr, timezoneObj uintptr, changeover int32) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Julian Day of the Gregorian transition */
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, ltzoc, nval, nval1, nval2, nval3, prev, prev1, prev2, prev3, tzdata, v10, v15, v17, v19, v5, v7 uintptr
	var v1, v11 int32
	var v12, v13, v2, v3 int64
	var v14, v16, v18, v4, v6, v9 TTcl_Size
	var _ /* rangesVal at bp+24 */ [2]TTcl_WideInt
	var _ /* rowc at bp+0 */ TTcl_Size
	var _ /* rowv at bp+8 */ uintptr
	var _ /* tzName at bp+16 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, ltzoc, nval, nval1, nval2, nval3, prev, prev1, prev2, prev3, tzdata, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v3, v4, v5, v6, v7, v9 /* Pointers to the rows */
	ltzoc = libc.UintptrFromInt32(0)
	/* fast phase-out for shared GMT-object (don't need to convert UTC 2 UTC) */
	if timezoneObj == *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals + uintptr(LIT_GMT)*8)) {
		(*TTclDateFields)(unsafe.Pointer(fields)).FlocalSeconds = (*TTclDateFields)(unsafe.Pointer(fields)).Fseconds
		(*TTclDateFields)(unsafe.Pointer(fields)).FtzOffset = 0
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtTZName == libc.UintptrFromInt32(0) {
			tzdata = _ClockGetTZData(tls, dataPtr, interp, timezoneObj)
			if (*TTcl_Obj)(unsafe.Pointer(tzdata)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(tzdata + 32))).Fptr2 != 0 {
					v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(tzdata + 32))).Fptr2)).FspanStart
				} else {
					v2 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(tzdata + 32))).Fptr1)).FfirstUsed
				}
				*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(tzdata + 32))).Fptr1 + 40 + uintptr(v2)*8
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(tzdata + 32))).Fptr2 != 0 {
					v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(tzdata + 32))).Fptr2)).FspanLength
				} else {
					v3 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(tzdata + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp)) = v3
				v1 = libc.Int32FromInt32(TCL_OK)
			} else {
				v1 = XTcl_ListObjGetElements(tls, interp, tzdata, bp, bp+8)
			}
			if v1 != TCL_OK || XTcl_ListObjIndex(tls, interp, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))), int64(3), bp+16) != TCL_OK {
				return int32(TCL_ERROR)
			}
			nval = *(*uintptr)(unsafe.Pointer(bp + 16))
			if (*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtTZName != nval {
				prev = (*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtTZName
				(*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtTZName = nval
				if (*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtTZName != 0 {
					(*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtTZName)).FrefCount++
				}
				if prev != libc.UintptrFromInt32(0) {
					_objPtr = prev
					v5 = _objPtr
					v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
					*(*TTcl_Size)(unsafe.Pointer(v5))--
					if v4 <= int64(1) {
						XTclFreeObj(tls, _objPtr)
					}
				}
			}
		}
		nval1 = (*TClockClientData)(unsafe.Pointer(dataPtr)).FgmtTZName
		if (*TTclDateFields)(unsafe.Pointer(fields)).FtzName != nval1 {
			prev1 = (*TTclDateFields)(unsafe.Pointer(fields)).FtzName
			(*TTclDateFields)(unsafe.Pointer(fields)).FtzName = nval1
			if (*TTclDateFields)(unsafe.Pointer(fields)).FtzName != 0 {
				(*TTcl_Obj)(unsafe.Pointer((*TTclDateFields)(unsafe.Pointer(fields)).FtzName)).FrefCount++
			}
			if prev1 != libc.UintptrFromInt32(0) {
				_objPtr1 = prev1
				v7 = _objPtr1
				v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
				*(*TTcl_Size)(unsafe.Pointer(v7))--
				if v6 <= int64(1) {
					XTclFreeObj(tls, _objPtr1)
				}
			}
		}
		return TCL_OK
	}
	/*
	 * Check cacheable conversion could be used
	 * (last-period UTC2Local cache within the same TZ and seconds)
	 */
	*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	for {
		if !(*(*TTcl_Size)(unsafe.Pointer(bp)) < int64(2)) {
			break
		}
		ltzoc = dataPtr + 368 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))*56
		if timezoneObj != (*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtimezoneObj || changeover != (*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).Fchangeover {
			ltzoc = libc.UintptrFromInt32(0)
			goto _8
		}
		if (*TTclDateFields)(unsafe.Pointer(fields)).Fseconds >= *(*TTcl_WideInt)(unsafe.Pointer(ltzoc + 24)) && (*TTclDateFields)(unsafe.Pointer(fields)).Fseconds < *(*TTcl_WideInt)(unsafe.Pointer(ltzoc + 24 + 1*8)) {
			/* the same time zone and offset (UTC time inside the last minute) */
			(*TTclDateFields)(unsafe.Pointer(fields)).FtzOffset = (*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtzOffset
			(*TTclDateFields)(unsafe.Pointer(fields)).FlocalSeconds = (*TTclDateFields)(unsafe.Pointer(fields)).Fseconds + int64((*TTclDateFields)(unsafe.Pointer(fields)).FtzOffset)
			nval2 = (*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtzName
			if (*TTclDateFields)(unsafe.Pointer(fields)).FtzName != nval2 {
				prev2 = (*TTclDateFields)(unsafe.Pointer(fields)).FtzName
				(*TTclDateFields)(unsafe.Pointer(fields)).FtzName = nval2
				if (*TTclDateFields)(unsafe.Pointer(fields)).FtzName != 0 {
					(*TTcl_Obj)(unsafe.Pointer((*TTclDateFields)(unsafe.Pointer(fields)).FtzName)).FrefCount++
				}
				if prev2 != libc.UintptrFromInt32(0) {
					_objPtr2 = prev2
					v10 = _objPtr2
					v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
					*(*TTcl_Size)(unsafe.Pointer(v10))--
					if v9 <= int64(1) {
						XTclFreeObj(tls, _objPtr2)
					}
				}
			}
			return TCL_OK
		}
		goto _8
	_8:
		;
		*(*TTcl_Size)(unsafe.Pointer(bp))++
	}
	/*
	 * Unpack the tz data.
	 */
	tzdata = _ClockGetTZData(tls, dataPtr, interp, timezoneObj)
	if tzdata == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(tzdata)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(tzdata + 32))).Fptr2 != 0 {
			v12 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(tzdata + 32))).Fptr2)).FspanStart
		} else {
			v12 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(tzdata + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(tzdata + 32))).Fptr1 + 40 + uintptr(v12)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(tzdata + 32))).Fptr2 != 0 {
			v13 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(tzdata + 32))).Fptr2)).FspanLength
		} else {
			v13 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(tzdata + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v13
		v11 = libc.Int32FromInt32(TCL_OK)
	} else {
		v11 = XTcl_ListObjGetElements(tls, interp, tzdata, bp, bp+8)
	}
	if v11 != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Special case: If the time zone is :localtime, the tzdata will be empty.
	 * Use 'localtime' to convert the time to local
	 */
	if *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
		if _ConvertUTCToLocalUsingC(tls, interp, fields, changeover) != TCL_OK {
			return int32(TCL_ERROR)
		}
		/* signal we need to revalidate TZ epoch next time fields gets used. */
		*(*int32)(unsafe.Pointer(fields + 96)) |= int32(CLF_CTZ)
		/* we cannot cache (ranges unknown yet) */
	} else {
		if _ConvertUTCToLocalUsingTable(tls, interp, fields, *(*TTcl_Size)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 8)), bp+24) != TCL_OK {
			return int32(TCL_ERROR)
		}
		/* converted using table (TZ isn't :localtime) */
		*(*int32)(unsafe.Pointer(fields + 96)) &= ^int32(CLF_CTZ)
		/* Cache the last conversion */
		if ltzoc != libc.UintptrFromInt32(0) { /* slot was found above */
			/* timezoneObj and changeover are the same */
			nval3 = (*TTclDateFields)(unsafe.Pointer(fields)).FtzName
			if (*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtzName != nval3 {
				prev3 = (*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtzName
				(*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtzName = nval3
				if (*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtzName != 0 {
					(*TTcl_Obj)(unsafe.Pointer((*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtzName)).FrefCount++
				}
				if prev3 != libc.UintptrFromInt32(0) {
					_objPtr3 = prev3
					v15 = _objPtr3
					v14 = *(*TTcl_Size)(unsafe.Pointer(v15))
					*(*TTcl_Size)(unsafe.Pointer(v15))--
					if v14 <= int64(1) {
						XTclFreeObj(tls, _objPtr3)
					}
				}
			}
		} else {
			/* no TZ in cache - just move second slot down and use the first one */
			ltzoc = dataPtr + 368
			if (*(*TClockLastTZOffs)(unsafe.Pointer(dataPtr + 368 + 1*56))).FtimezoneObj != libc.UintptrFromInt32(0) {
				_objPtr4 = (*(*TClockLastTZOffs)(unsafe.Pointer(dataPtr + 368 + 1*56))).FtimezoneObj
				v17 = _objPtr4
				v16 = *(*TTcl_Size)(unsafe.Pointer(v17))
				*(*TTcl_Size)(unsafe.Pointer(v17))--
				if v16 <= int64(1) {
					XTclFreeObj(tls, _objPtr4)
				}
				(*(*TClockLastTZOffs)(unsafe.Pointer(dataPtr + 368 + 1*56))).FtimezoneObj = libc.UintptrFromInt32(0)
			}
			if (*(*TClockLastTZOffs)(unsafe.Pointer(dataPtr + 368 + 1*56))).FtzName != libc.UintptrFromInt32(0) {
				_objPtr5 = (*(*TClockLastTZOffs)(unsafe.Pointer(dataPtr + 368 + 1*56))).FtzName
				v19 = _objPtr5
				v18 = *(*TTcl_Size)(unsafe.Pointer(v19))
				*(*TTcl_Size)(unsafe.Pointer(v19))--
				if v18 <= int64(1) {
					XTclFreeObj(tls, _objPtr5)
				}
				(*(*TClockLastTZOffs)(unsafe.Pointer(dataPtr + 368 + 1*56))).FtzName = libc.UintptrFromInt32(0)
			}
			libc.Xmemcpy(tls, dataPtr+368+1*56, ltzoc, uint64(56))
			(*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtimezoneObj = timezoneObj
			if (*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtimezoneObj != 0 {
				(*TTcl_Obj)(unsafe.Pointer((*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtimezoneObj)).FrefCount++
			}
			(*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).Fchangeover = changeover
			(*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtzName = (*TTclDateFields)(unsafe.Pointer(fields)).FtzName
			if (*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtzName != 0 {
				(*TTcl_Obj)(unsafe.Pointer((*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtzName)).FrefCount++
			}
		}
		(*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FlocalSeconds = (*TTclDateFields)(unsafe.Pointer(fields)).FlocalSeconds
		*(*TTcl_WideInt)(unsafe.Pointer(ltzoc + 24)) = (*(*[2]TTcl_WideInt)(unsafe.Pointer(bp + 24)))[0]
		*(*TTcl_WideInt)(unsafe.Pointer(ltzoc + 24 + 1*8)) = (*(*[2]TTcl_WideInt)(unsafe.Pointer(bp + 24)))[int32(1)]
		(*TClockLastTZOffs)(unsafe.Pointer(ltzoc)).FtzOffset = (*TTclDateFields)(unsafe.Pointer(fields)).FtzOffset
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * ConvertUTCToLocalUsingTable --
 *
 *	Converts UTC to local time, given a table of transition points
 *
 * Results:
 *	Returns a standard Tcl result
 *
 * Side effects:
 *	On success, fills fields->tzName, fields->tzOffset and
 *	fields->localSeconds. On failure, places an error message in the
 *	interpreter result.
 *
 *----------------------------------------------------------------------
 */

func _ConvertUTCToLocalUsingTable(tls *libc.TLS, interp uintptr, fields uintptr, rowc TTcl_Size, rowv uintptr, rangesVal uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Return bounds for time period */
	var _objPtr, nval, prev, row, v8 uintptr
	var v1, v5 int32
	var v2, v3 int64
	var v4, v6 bool
	var v7 TTcl_Size
	var _ /* cellc at bp+0 */ TTcl_Size
	var _ /* cellv at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, nval, prev, row, v1, v2, v3, v4, v5, v6, v7, v8 /* Pointers to the cells */
	/*
	 * Look up the nearest transition time.
	 */
	row = XLookupLastTransition(tls, interp, (*TTclDateFields)(unsafe.Pointer(fields)).Fseconds, rowc, rowv, rangesVal)
	if v4 = row == libc.UintptrFromInt32(0); !v4 {
		if (*TTcl_Obj)(unsafe.Pointer(row)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(row + 32))).Fptr2 != 0 {
				v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(row + 32))).Fptr2)).FspanStart
			} else {
				v2 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(row + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(row + 32))).Fptr1 + 40 + uintptr(v2)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(row + 32))).Fptr2 != 0 {
				v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(row + 32))).Fptr2)).FspanLength
			} else {
				v3 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(row + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp)) = v3
			v1 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1 = XTcl_ListObjGetElements(tls, interp, row, bp, bp+8)
		}
	}
	if v6 = v4 || v1 != TCL_OK; !v6 {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*8)))).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*8)))).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
			*(*int32)(unsafe.Pointer(fields + 16)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*8)))).FinternalRep)))
			v5 = libc.Int32FromInt32(TCL_OK)
		} else {
			v5 = XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*8)), fields+16)
		}
	}
	if v6 || v5 != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Convert the time.
	 */
	nval = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 3*8))
	if (*TTclDateFields)(unsafe.Pointer(fields)).FtzName != nval {
		prev = (*TTclDateFields)(unsafe.Pointer(fields)).FtzName
		(*TTclDateFields)(unsafe.Pointer(fields)).FtzName = nval
		if (*TTclDateFields)(unsafe.Pointer(fields)).FtzName != 0 {
			(*TTcl_Obj)(unsafe.Pointer((*TTclDateFields)(unsafe.Pointer(fields)).FtzName)).FrefCount++
		}
		if prev != libc.UintptrFromInt32(0) {
			_objPtr = prev
			v8 = _objPtr
			v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
			*(*TTcl_Size)(unsafe.Pointer(v8))--
			if v7 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
	}
	(*TTclDateFields)(unsafe.Pointer(fields)).FlocalSeconds = (*TTclDateFields)(unsafe.Pointer(fields)).Fseconds + int64((*TTclDateFields)(unsafe.Pointer(fields)).FtzOffset)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * ConvertUTCToLocalUsingC --
 *
 *	Converts UTC to localtime in cases where the local time zone is not
 *	determinable, using the C 'localtime' function to do it.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	On success, fills fields->tzName, fields->tzOffset and
 *	fields->localSeconds. On failure, places an error message in the
 *	interpreter result.
 *
 *----------------------------------------------------------------------
 */

func _ConvertUTCToLocalUsingC(tls *libc.TLS, interp uintptr, fields uintptr, changeover int32) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Julian Day of the Gregorian transition */
	var _objPtr, nval, p, prev, timeVal, v2 uintptr
	var diff int32
	var v1 TTcl_Size
	var _ /* buffer at bp+8 */ [16]uint8
	var _ /* tock at bp+0 */ Ttime_t
	_, _, _, _, _, _, _, _ = _objPtr, diff, nval, p, prev, timeVal, v1, v2 /* Buffer for time zone name */
	/*
	 * Use 'localtime' to determine local year, month, day, time of day.
	 */
	*(*Ttime_t)(unsafe.Pointer(bp)) = (*TTclDateFields)(unsafe.Pointer(fields)).Fseconds
	if *(*Ttime_t)(unsafe.Pointer(bp)) != (*TTclDateFields)(unsafe.Pointer(fields)).Fseconds {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+13062, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+32, __ccgo_ts+12666, __ccgo_ts+13108, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	_TzsetIfNecessary(tls)
	timeVal = _ThreadSafeLocalTime(tls, bp)
	if timeVal == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+13120, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+32, __ccgo_ts+12666, __ccgo_ts+13187, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Fill in the date in 'fields' and use it to derive Julian Day.
	 */
	(*TTclDateFields)(unsafe.Pointer(fields)).FisBce = 0
	(*TTclDateFields)(unsafe.Pointer(fields)).Fyear = (*Ttm)(unsafe.Pointer(timeVal)).Ftm_year + int32(1900)
	(*TTclDateFields)(unsafe.Pointer(fields)).Fmonth = (*Ttm)(unsafe.Pointer(timeVal)).Ftm_mon + int32(1)
	(*TTclDateFields)(unsafe.Pointer(fields)).FdayOfMonth = (*Ttm)(unsafe.Pointer(timeVal)).Ftm_mday
	XGetJulianDayFromEraYearMonthDay(tls, fields, changeover)
	/*
	 * Convert that value to seconds.
	 */
	(*TTclDateFields)(unsafe.Pointer(fields)).FlocalSeconds = (((*TTclDateFields)(unsafe.Pointer(fields)).FjulianDay*int64(24)+int64((*Ttm)(unsafe.Pointer(timeVal)).Ftm_hour))*int64(60)+int64((*Ttm)(unsafe.Pointer(timeVal)).Ftm_min))*int64(60) + int64((*Ttm)(unsafe.Pointer(timeVal)).Ftm_sec) - libc.Int64FromInt32(JULIAN_DAY_POSIX_EPOCH)*libc.Int64FromInt32(SECONDS_PER_DAY)
	/*
	 * Determine a time zone offset and name; just use +hhmm for the name.
	 */
	diff = int32((*TTclDateFields)(unsafe.Pointer(fields)).FlocalSeconds - (*TTclDateFields)(unsafe.Pointer(fields)).Fseconds)
	(*TTclDateFields)(unsafe.Pointer(fields)).FtzOffset = diff
	if diff < 0 {
		*(*uint8)(unsafe.Pointer(bp + 8)) = uint8('-')
		diff = -diff
	} else {
		*(*uint8)(unsafe.Pointer(bp + 8)) = uint8('+')
	}
	XTclItoAw(tls, bp+8+uintptr(1), diff/int32(3600), uint8('0'), uint16(2))
	diff %= int32(3600)
	p = XTclItoAw(tls, bp+8+uintptr(3), diff/int32(60), uint8('0'), uint16(2))
	diff %= int32(60)
	if diff != 0 {
		p = XTclItoAw(tls, bp+8+uintptr(5), diff, uint8('0'), uint16(2))
	}
	nval = XTcl_NewStringObj(tls, bp+8, int64(p)-T__predefined_ptrdiff_t(bp+8))
	if (*TTclDateFields)(unsafe.Pointer(fields)).FtzName != nval {
		prev = (*TTclDateFields)(unsafe.Pointer(fields)).FtzName
		(*TTclDateFields)(unsafe.Pointer(fields)).FtzName = nval
		if (*TTclDateFields)(unsafe.Pointer(fields)).FtzName != 0 {
			(*TTcl_Obj)(unsafe.Pointer((*TTclDateFields)(unsafe.Pointer(fields)).FtzName)).FrefCount++
		}
		if prev != libc.UintptrFromInt32(0) {
			_objPtr = prev
			v2 = _objPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if v1 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * LookupLastTransition --
 *
 *	Given a UTC time and a tzdata array, looks up the last transition on
 *	or before the given time.
 *
 * Results:
 *	Returns a pointer to the row, or NULL if an error occurs.
 *
 *----------------------------------------------------------------------
 */

func XLookupLastTransition(tls *libc.TLS, interp uintptr, tick TTcl_WideInt, rowc TTcl_Size, rowv uintptr, rangesVal uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Return bounds for time period */
	var fromVal, toVal, v3 TTcl_WideInt
	var l, m, u TTcl_Size
	var v1, v4 int32
	var v2, v5 bool
	var _ /* compObj at bp+0 */ uintptr
	var _ /* compVal at bp+8 */ TTcl_WideInt
	_, _, _, _, _, _, _, _, _, _ = fromVal, l, m, toVal, u, v1, v2, v3, v4, v5
	fromVal = -libc.Int64FromInt64(0x7fffffffffffffff) - libc.Int64FromInt32(1)
	toVal = int64(0x7fffffffffffffff)
	/*
	 * Examine the first row to make sure we're in bounds.
	 */
	if v2 = XTcl_ListObjIndex(tls, interp, *(*uintptr)(unsafe.Pointer(rowv)), 0, bp) != TCL_OK; !v2 {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
			*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FinternalRep))
			v1 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1 = XTcl_GetWideIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), bp+8)
		}
	}
	if v2 || v1 != TCL_OK {
		return libc.UintptrFromInt32(0)
	}
	/*
	 * Bizarre case - first row doesn't begin at MIN_WIDE_INT. Return it
	 * anyway.
	 */
	v3 = *(*TTcl_WideInt)(unsafe.Pointer(bp + 8))
	fromVal = v3
	if tick < v3 {
		if rangesVal != 0 {
			*(*TTcl_WideInt)(unsafe.Pointer(rangesVal)) = fromVal
			*(*TTcl_WideInt)(unsafe.Pointer(rangesVal + 1*8)) = toVal
		}
		return *(*uintptr)(unsafe.Pointer(rowv))
	}
	/*
	 * Binary-search to find the transition.
	 */
	l = 0
	u = rowc - int64(1)
	for l < u {
		m = (l + u + int64(1)) / int64(2)
		if v5 = XTcl_ListObjIndex(tls, interp, *(*uintptr)(unsafe.Pointer(rowv + uintptr(m)*8)), 0, bp) != TCL_OK; !v5 {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
				*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FinternalRep))
				v4 = libc.Int32FromInt32(TCL_OK)
			} else {
				v4 = XTcl_GetWideIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), bp+8)
			}
		}
		if v5 || v4 != TCL_OK {
			return libc.UintptrFromInt32(0)
		}
		if tick >= *(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) {
			l = m
			fromVal = *(*TTcl_WideInt)(unsafe.Pointer(bp + 8))
		} else {
			u = m - int64(1)
			toVal = *(*TTcl_WideInt)(unsafe.Pointer(bp + 8))
		}
	}
	if rangesVal != 0 {
		*(*TTcl_WideInt)(unsafe.Pointer(rangesVal)) = fromVal
		*(*TTcl_WideInt)(unsafe.Pointer(rangesVal + 1*8)) = toVal
	}
	return *(*uintptr)(unsafe.Pointer(rowv + uintptr(l)*8))
}

/*
 *----------------------------------------------------------------------
 *
 * GetYearWeekDay --
 *
 *	Given a date with Julian Calendar Day, compute the year, week, and day
 *	in the ISO8601 calendar.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Stores 'iso8601Year', 'iso8601Week' and 'dayOfWeek' in the date
 *	fields.
 *
 *----------------------------------------------------------------------
 */

func _GetYearWeekDay(tls *libc.TLS, fields uintptr, changeover int32) {
	bp := tls.Alloc(112)
	defer tls.Free(112) /* Julian Day Number of the Gregorian
	 * transition */
	var dayOfFiscalYear int32
	var _ /* temp at bp+0 */ TTclDateFields
	_ = dayOfFiscalYear
	(*(*TTclDateFields)(unsafe.Pointer(bp))).FtzName = libc.UintptrFromInt32(0)
	/*
	 * Find the given date, minus three days, plus one year. That date's
	 * iso8601 year is an upper bound on the ISO8601 year of the given date.
	 */
	(*(*TTclDateFields)(unsafe.Pointer(bp))).FjulianDay = (*TTclDateFields)(unsafe.Pointer(fields)).FjulianDay - int64(3)
	_GetGregorianEraYearDay(tls, bp, changeover)
	if (*(*TTclDateFields)(unsafe.Pointer(bp))).FisBce != 0 {
		(*(*TTclDateFields)(unsafe.Pointer(bp))).Fiso8601Year = (*(*TTclDateFields)(unsafe.Pointer(bp))).Fyear - int32(1)
	} else {
		(*(*TTclDateFields)(unsafe.Pointer(bp))).Fiso8601Year = (*(*TTclDateFields)(unsafe.Pointer(bp))).Fyear + int32(1)
	}
	(*(*TTclDateFields)(unsafe.Pointer(bp))).Fiso8601Week = int32(1)
	(*(*TTclDateFields)(unsafe.Pointer(bp))).FdayOfWeek = int32(1)
	XGetJulianDayFromEraYearWeekDay(tls, bp, changeover)
	/*
	 * temp.julianDay is now the start of an ISO8601 year, either the one
	 * corresponding to the given date, or the one after. If we guessed high,
	 * move one year earlier
	 */
	if (*TTclDateFields)(unsafe.Pointer(fields)).FjulianDay < (*(*TTclDateFields)(unsafe.Pointer(bp))).FjulianDay {
		if (*(*TTclDateFields)(unsafe.Pointer(bp))).FisBce != 0 {
			(*(*TTclDateFields)(unsafe.Pointer(bp))).Fiso8601Year += int32(1)
		} else {
			(*(*TTclDateFields)(unsafe.Pointer(bp))).Fiso8601Year -= int32(1)
		}
		XGetJulianDayFromEraYearWeekDay(tls, bp, changeover)
	}
	(*TTclDateFields)(unsafe.Pointer(fields)).Fiso8601Year = (*(*TTclDateFields)(unsafe.Pointer(bp))).Fiso8601Year
	dayOfFiscalYear = int32((*TTclDateFields)(unsafe.Pointer(fields)).FjulianDay - (*(*TTclDateFields)(unsafe.Pointer(bp))).FjulianDay)
	(*TTclDateFields)(unsafe.Pointer(fields)).Fiso8601Week = dayOfFiscalYear/int32(7) + int32(1)
	(*TTclDateFields)(unsafe.Pointer(fields)).FdayOfWeek = (dayOfFiscalYear + int32(1)) % int32(7)
	if (*TTclDateFields)(unsafe.Pointer(fields)).FdayOfWeek < int32(1) { /* Mon .. Sun == 1 .. 7 */
		*(*int32)(unsafe.Pointer(fields + 64)) += int32(7)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * GetGregorianEraYearDay --
 *
 *	Given a Julian Day Number, extracts the year and day of the year and
 *	puts them into TclDateFields, along with the era (BCE or CE) and a
 *	flag indicating whether the date is Gregorian or Julian.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Stores 'era', 'gregorian', 'year', and 'dayOfYear'.
 *
 *----------------------------------------------------------------------
 */

func _GetGregorianEraYearDay(tls *libc.TLS, fields uintptr, changeover int32) {
	/* Gregorian transition date */
	var day, jday, n, year TTcl_WideInt
	_, _, _, _ = day, jday, n, year
	jday = (*TTclDateFields)(unsafe.Pointer(fields)).FjulianDay
	if jday >= int64(changeover) {
		/*
		 * Gregorian calendar.
		 */
		(*TTclDateFields)(unsafe.Pointer(fields)).Fgregorian = int32(1)
		year = int64(1)
		/*
		 * n = Number of 400-year cycles since 1 January, 1 CE in the
		 * proleptic Gregorian calendar. day = remaining days.
		 */
		day = jday - int64(JDAY_1_JAN_1_CE_GREGORIAN)
		n = day / int64(FOUR_CENTURIES)
		day %= int64(FOUR_CENTURIES)
		if day < 0 {
			day += int64(FOUR_CENTURIES)
			n--
		}
		year += int64(400) * n
		/*
		 * n = number of centuries since the start of (year);
		 * day = remaining days
		 */
		n = day / int64(ONE_CENTURY_GREGORIAN)
		day %= int64(ONE_CENTURY_GREGORIAN)
		if n > int64(3) {
			/*
			 * 31 December in the last year of a 400-year cycle.
			 */
			n = int64(3)
			day += int64(ONE_CENTURY_GREGORIAN)
		}
		year += int64(100) * n
	} else {
		/*
		 * Julian calendar.
		 */
		(*TTclDateFields)(unsafe.Pointer(fields)).Fgregorian = 0
		year = int64(1)
		day = jday - int64(JDAY_1_JAN_1_CE_JULIAN)
	}
	/*
	 * n = number of 4-year cycles; days = remaining days.
	 */
	n = day / int64(FOUR_YEARS)
	day %= int64(FOUR_YEARS)
	if day < 0 {
		day += int64(FOUR_YEARS)
		n--
	}
	year += int64(4) * n
	/*
	 * n = number of years; days = remaining days.
	 */
	n = day / int64(ONE_YEAR)
	day %= int64(ONE_YEAR)
	if n > int64(3) {
		/*
		 * 31 December of a leap year.
		 */
		n = int64(3)
		day += int64(365)
	}
	year += n
	/*
	 * store era/year/day back into fields.
	 */
	if year <= 0 {
		(*TTclDateFields)(unsafe.Pointer(fields)).FisBce = int32(1)
		(*TTclDateFields)(unsafe.Pointer(fields)).Fyear = int32(int64(1) - year)
	} else {
		(*TTclDateFields)(unsafe.Pointer(fields)).FisBce = 0
		(*TTclDateFields)(unsafe.Pointer(fields)).Fyear = int32(year)
	}
	(*TTclDateFields)(unsafe.Pointer(fields)).FdayOfYear = int32(day + int64(1))
}

/*
 *----------------------------------------------------------------------
 *
 * GetMonthDay --
 *
 *	Given a date as year and day-of-year, find month and day.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Stores 'month' and 'dayOfMonth' in the 'fields' structure.
 *
 *----------------------------------------------------------------------
 */

func _GetMonthDay(tls *libc.TLS, fields uintptr) {
	/* Date to convert */
	var day, month int32
	var dipm uintptr
	_, _, _ = day, dipm, month
	day = (*TTclDateFields)(unsafe.Pointer(fields)).FdayOfYear
	dipm = uintptr(unsafe.Pointer(&_daysInPriorMonths)) + uintptr(XIsGregorianLeapYear(tls, fields))*52
	/*
	 * Estimate month by calculating `dayOfYear / (365/12)`
	 */
	month = day * int32(12) / *(*int32)(unsafe.Pointer(dipm + 12*4))
	/* then do forwards backwards correction */
	for int32(1) != 0 {
		if day > *(*int32)(unsafe.Pointer(dipm + uintptr(month)*4)) {
			if month >= int32(11) || day <= *(*int32)(unsafe.Pointer(dipm + uintptr(month+int32(1))*4)) {
				break
			}
			month++
		} else {
			if month == 0 {
				break
			}
			month--
		}
	}
	day -= *(*int32)(unsafe.Pointer(dipm + uintptr(month)*4))
	(*TTclDateFields)(unsafe.Pointer(fields)).Fmonth = month + int32(1)
	(*TTclDateFields)(unsafe.Pointer(fields)).FdayOfMonth = day
}

/*
 *----------------------------------------------------------------------
 *
 * GetJulianDayFromEraYearWeekDay --
 *
 *	Given a TclDateFields structure containing era, ISO8601 year, ISO8601
 *	week, and day of week, computes the Julian Day Number.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Stores 'julianDay' in the fields.
 *
 *----------------------------------------------------------------------
 */

func XGetJulianDayFromEraYearWeekDay(tls *libc.TLS, fields uintptr, changeover int32) {
	bp := tls.Alloc(112)
	defer tls.Free(112) /* Julian Day Number of the Gregorian
	 * transition */
	var firstMonday TTcl_WideInt
	var _ /* firstWeek at bp+0 */ TTclDateFields
	_ = firstMonday
	(*(*TTclDateFields)(unsafe.Pointer(bp))).FtzName = libc.UintptrFromInt32(0)
	/*
	 * Find January 4 in the ISO8601 year, which will always be in week 1.
	 */
	(*(*TTclDateFields)(unsafe.Pointer(bp))).FisBce = (*TTclDateFields)(unsafe.Pointer(fields)).FisBce
	(*(*TTclDateFields)(unsafe.Pointer(bp))).Fyear = (*TTclDateFields)(unsafe.Pointer(fields)).Fiso8601Year
	(*(*TTclDateFields)(unsafe.Pointer(bp))).Fmonth = int32(1)
	(*(*TTclDateFields)(unsafe.Pointer(bp))).FdayOfMonth = int32(4)
	XGetJulianDayFromEraYearMonthDay(tls, bp, changeover)
	/*
	 * Find Monday of week 1.
	 */
	firstMonday = _WeekdayOnOrBefore(tls, int32(1), (*(*TTclDateFields)(unsafe.Pointer(bp))).FjulianDay)
	/*
	 * Advance to the given week and day.
	 */
	(*TTclDateFields)(unsafe.Pointer(fields)).FjulianDay = firstMonday + int64(int32(7)*((*TTclDateFields)(unsafe.Pointer(fields)).Fiso8601Week-int32(1))) + int64((*TTclDateFields)(unsafe.Pointer(fields)).FdayOfWeek) - int64(1)
}

/*
 *----------------------------------------------------------------------
 *
 * GetJulianDayFromEraYearMonthDay --
 *
 *	Given era, year, month, and dayOfMonth (in TclDateFields), and the
 *	Gregorian transition date, computes the Julian Day Number.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Stores day number in 'julianDay'
 *
 *----------------------------------------------------------------------
 */

func XGetJulianDayFromEraYearMonthDay(tls *libc.TLS, fields uintptr, changeover int32) {
	/* Gregorian transition date as a Julian Day */
	var mm1, month, q, r int32
	var year, ym1, ym1o100, ym1o4, ym1o400 TTcl_WideInt
	_, _, _, _, _, _, _, _, _ = mm1, month, q, r, year, ym1, ym1o100, ym1o4, ym1o400
	if (*TTclDateFields)(unsafe.Pointer(fields)).FisBce != 0 {
		year = int64(int32(1) - (*TTclDateFields)(unsafe.Pointer(fields)).Fyear)
	} else {
		year = int64((*TTclDateFields)(unsafe.Pointer(fields)).Fyear)
	}
	/*
	 * Reduce month modulo 12.
	 */
	month = (*TTclDateFields)(unsafe.Pointer(fields)).Fmonth
	mm1 = month - int32(1)
	q = mm1 / int32(12)
	r = mm1 % int32(12)
	if r < 0 {
		r += int32(12)
		q -= int32(1)
	}
	year += int64(q)
	month = r + int32(1)
	ym1 = year - int64(1)
	/*
	 * Adjust the year after reducing the month.
	 */
	(*TTclDateFields)(unsafe.Pointer(fields)).Fgregorian = int32(1)
	if year < int64(1) {
		(*TTclDateFields)(unsafe.Pointer(fields)).FisBce = int32(1)
		(*TTclDateFields)(unsafe.Pointer(fields)).Fyear = int32(int64(1) - year)
	} else {
		(*TTclDateFields)(unsafe.Pointer(fields)).FisBce = 0
		(*TTclDateFields)(unsafe.Pointer(fields)).Fyear = int32(year)
	}
	/*
	 * Try an initial conversion in the Gregorian calendar.
	 */
	/*
	 * Have to make sure quotient is truncated towards 0 when negative.
	 * See above bug for details. The casts are necessary.
	 */
	if ym1 >= 0 {
		ym1o4 = ym1 / int64(4)
	} else {
		ym1o4 = int64(-libc.Int32FromUint32(libc.Uint32FromInt64(-ym1) / libc.Uint32FromInt32(4)))
	}
	if ym1%int64(4) < 0 {
		ym1o4--
	}
	ym1o100 = ym1 / int64(100)
	if ym1%int64(100) < 0 {
		ym1o100--
	}
	ym1o400 = ym1 / int64(400)
	if ym1%int64(400) < 0 {
		ym1o400--
	}
	(*TTclDateFields)(unsafe.Pointer(fields)).FjulianDay = int64(libc.Int32FromInt32(JDAY_1_JAN_1_CE_GREGORIAN)-libc.Int32FromInt32(1)+(*TTclDateFields)(unsafe.Pointer(fields)).FdayOfMonth+*(*int32)(unsafe.Pointer(uintptr(unsafe.Pointer(&_daysInPriorMonths)) + uintptr(XIsGregorianLeapYear(tls, fields))*52 + uintptr(month-int32(1))*4))) + int64(ONE_YEAR)*ym1 + ym1o4 - ym1o100 + ym1o400
	/*
	 * If the resulting date is before the Gregorian changeover, convert in
	 * the Julian calendar instead.
	 */
	if (*TTclDateFields)(unsafe.Pointer(fields)).FjulianDay < int64(changeover) {
		(*TTclDateFields)(unsafe.Pointer(fields)).Fgregorian = 0
		(*TTclDateFields)(unsafe.Pointer(fields)).FjulianDay = int64(libc.Int32FromInt32(JDAY_1_JAN_1_CE_JULIAN)-libc.Int32FromInt32(1)+(*TTclDateFields)(unsafe.Pointer(fields)).FdayOfMonth+*(*int32)(unsafe.Pointer(uintptr(unsafe.Pointer(&_daysInPriorMonths)) + libc.BoolUintptr(year%int64(4) == 0)*52 + uintptr(month-int32(1))*4))) + int64(365)*ym1 + ym1o4
	}
}

/*
 *----------------------------------------------------------------------
 *
 * GetJulianDayFromEraYearDay --
 *
 *	Given era, year, and dayOfYear (in TclDateFields), and the
 *	Gregorian transition date, computes the Julian Day Number.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Stores day number in 'julianDay'
 *
 *----------------------------------------------------------------------
 */

func XGetJulianDayFromEraYearDay(tls *libc.TLS, fields uintptr, changeover int32) {
	/* Gregorian transition date as a Julian Day */
	var year, ym1 TTcl_WideInt
	_, _ = year, ym1
	/* Get absolute year number from the civil year */
	if (*TTclDateFields)(unsafe.Pointer(fields)).FisBce != 0 {
		year = int64(int32(1) - (*TTclDateFields)(unsafe.Pointer(fields)).Fyear)
	} else {
		year = int64((*TTclDateFields)(unsafe.Pointer(fields)).Fyear)
	}
	ym1 = year - int64(1)
	/* Try the Gregorian calendar first. */
	(*TTclDateFields)(unsafe.Pointer(fields)).Fgregorian = int32(1)
	(*TTclDateFields)(unsafe.Pointer(fields)).FjulianDay = int64(int32(1721425)+(*TTclDateFields)(unsafe.Pointer(fields)).FdayOfYear) + int64(365)*ym1 + ym1/int64(4) - ym1/int64(100) + ym1/int64(400)
	/* If the date is before the Gregorian change, use the Julian calendar. */
	if (*TTclDateFields)(unsafe.Pointer(fields)).FjulianDay < int64(changeover) {
		(*TTclDateFields)(unsafe.Pointer(fields)).Fgregorian = 0
		(*TTclDateFields)(unsafe.Pointer(fields)).FjulianDay = int64(int32(1721423)+(*TTclDateFields)(unsafe.Pointer(fields)).FdayOfYear) + int64(365)*ym1 + ym1/int64(4)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * IsGregorianLeapYear --
 *
 *	Tests whether a given year is a leap year, in either Julian or
 *	Gregorian calendar.
 *
 * Results:
 *	Returns 1 for a leap year, 0 otherwise.
 *
 *----------------------------------------------------------------------
 */

func XIsGregorianLeapYear(tls *libc.TLS, fields uintptr) (r int32) {
	/* Date to test */
	var year TTcl_WideInt
	_ = year
	year = int64((*TTclDateFields)(unsafe.Pointer(fields)).Fyear)
	if (*TTclDateFields)(unsafe.Pointer(fields)).FisBce != 0 {
		year = int64(1) - year
	}
	if year%int64(4) != 0 {
		return 0
	} else {
		if !((*TTclDateFields)(unsafe.Pointer(fields)).Fgregorian != 0) {
			return int32(1)
		} else {
			if year%int64(400) == 0 {
				return int32(1)
			} else {
				if year%int64(100) == 0 {
					return 0
				} else {
					return int32(1)
				}
			}
		}
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * WeekdayOnOrBefore --
 *
 *	Finds the Julian Day Number of a given day of the week that falls on
 *	or before a given date, expressed as Julian Day Number.
 *
 * Results:
 *	Returns the Julian Day Number
 *
 *----------------------------------------------------------------------
 */

func _WeekdayOnOrBefore(tls *libc.TLS, dayOfWeek int32, julianDay TTcl_WideInt) (r TTcl_WideInt) {
	/* Reference date */
	var k int32
	_ = k
	k = (dayOfWeek + int32(6)) % int32(7)
	if k < 0 {
		k += int32(7)
	}
	return julianDay - (julianDay-int64(k))%int64(7)
}

/*
 *----------------------------------------------------------------------
 *
 * ClockGetenvObjCmd --
 *
 *	Tcl command that reads an environment variable from the system
 *
 * Usage:
 *	::tcl::clock::getEnv NAME
 *
 * Parameters:
 *	NAME - Name of the environment variable desired
 *
 * Results:
 *	Returns a standard Tcl result. Returns an error if the variable does
 *	not exist, with a message left in the interpreter. Returns TCL_OK and
 *	the value of the variable if the variable does exist,
 *
 *----------------------------------------------------------------------
 */

func _ClockGetenvObjCmd(tls *libc.TLS, dummy3013 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var varName, varValue, v1 uintptr
	_, _, _ = varName, varValue, v1
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+3726)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	varName = v1
	varValue = libc.Xgetenv(tls, varName)
	if varValue != libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, varValue, int64(-libc.Int32FromInt32(1))))
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * ThreadSafeLocalTime --
 *
 *	Wrapper around the 'localtime' library function to make it thread
 *	safe.
 *
 * Results:
 *	Returns a pointer to a 'struct tm' in thread-specific data.
 *
 * Side effects:
 *	Invokes localtime or localtime_r as appropriate.
 *
 *----------------------------------------------------------------------
 */

func _ThreadSafeLocalTime(tls *libc.TLS, timePtr uintptr) (r uintptr) {
	/* Pointer to the number of seconds since the
	 * local system's epoch */
	var tmPtr uintptr
	_ = tmPtr
	/*
	 * Get a thread-local buffer to hold the returned time.
	 */
	tmPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_tmKey)), int64(56))
	tmPtr = libc.Xlocaltime_r(tls, timePtr, tmPtr)
	return tmPtr
}

/*----------------------------------------------------------------------
 *
 * ClockClicksObjCmd --
 *
 *	Returns a high-resolution counter.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 * This function implements the 'clock clicks' Tcl command. Refer to the user
 * documentation for details on what it does.
 *
 *----------------------------------------------------------------------
 */

func _ClockClicksObjCmd(tls *libc.TLS, dummy3117 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Parameter values */
	var clicks TTcl_WideInt
	var _ /* index at bp+0 */ int32
	var _ /* now at bp+8 */ TTcl_Time
	_ = clicks
	*(*int32)(unsafe.Pointer(bp)) = 2
	clicks = 0
	switch objc {
	case int32(1):
	case int32(2):
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), uintptr(unsafe.Pointer(&_clicksSwitches)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
			return int32(TCL_ERROR)
		}
	default:
		XTcl_WrongNumArgs(tls, interp, 0, objv, __ccgo_ts+13231)
		return int32(TCL_ERROR)
	}
	switch *(*int32)(unsafe.Pointer(bp)) {
	case 0:
		XTcl_GetTime(tls, bp+8)
		clicks = (*(*TTcl_Time)(unsafe.Pointer(bp + 8))).Fsec*int64(1000) + (*(*TTcl_Time)(unsafe.Pointer(bp + 8))).Fusec/int64(1000)
	case 2:
		clicks = libc.Int64FromUint64(XTclpGetClicks(tls))
	case 1:
		clicks = XTclpGetMicroseconds(tls)
		break
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, clicks))
	return TCL_OK
}

var _clicksSwitches = [3]uintptr{
	0: __ccgo_ts + 13203,
	1: __ccgo_ts + 13217,
	2: libc.UintptrFromInt32(0),
}

/*----------------------------------------------------------------------
 *
 * ClockMillisecondsObjCmd -
 *
 *	Returns a count of milliseconds since the epoch.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 * This function implements the 'clock milliseconds' Tcl command. Refer to the
 * user documentation for details on what it does.
 *
 *----------------------------------------------------------------------
 */

func _ClockMillisecondsObjCmd(tls *libc.TLS, dummy3187 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Parameter values */
	var cachePtr, timeObj uintptr
	var uw_ TTcl_WideUInt
	var v1 bool
	var _ /* bignumValue_ at bp+16 */ Tmp_int
	var _ /* now at bp+0 */ TTcl_Time
	_, _, _, _ = cachePtr, timeObj, uw_, v1
	if objc != int32(1) {
		XTcl_WrongNumArgs(tls, interp, 0, objv, __ccgo_ts+13254)
		return int32(TCL_ERROR)
	}
	XTcl_GetTime(tls, bp)
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		timeObj = XTclThreadAllocObj(tls)
	} else {
		timeObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(timeObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(timeObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(timeObj)).Fbytes = libc.UintptrFromInt32(0)
	uw_ = libc.Uint64FromInt64((*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec)*libc.Uint64FromInt32(1000) + libc.Uint64FromInt64((*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec/libc.Int64FromInt32(1000))
	if uw_ > libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) {
		if XTclBN_mp_init_u64(tls, bp+16, uw_) != MP_OKAY {
			XTcl_Panic(tls, __ccgo_ts+13273, libc.VaList(bp+48, __ccgo_ts+13293))
		}
		XTclSetBignumInternalRep(tls, timeObj, bp+16)
	} else {
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(timeObj)).FinternalRep)) = libc.Int64FromUint64(uw_)
		(*TTcl_Obj)(unsafe.Pointer(timeObj)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	}
	XTcl_SetObjResult(tls, interp, timeObj)
	return TCL_OK
}

/*----------------------------------------------------------------------
 *
 * ClockMicrosecondsObjCmd -
 *
 *	Returns a count of microseconds since the epoch.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 * This function implements the 'clock microseconds' Tcl command. Refer to the
 * user documentation for details on what it does.
 *
 *----------------------------------------------------------------------
 */

func _ClockMicrosecondsObjCmd(tls *libc.TLS, dummy3226 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Parameter values */
	if objc != int32(1) {
		XTcl_WrongNumArgs(tls, interp, 0, objv, __ccgo_ts+13307)
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, XTclpGetMicroseconds(tls)))
	return TCL_OK
}

func _ClockInitFmtScnArgs(tls *libc.TLS, dataPtr uintptr, interp uintptr, opts uintptr) {
	libc.Xmemset(tls, opts, 0, uint64(64))
	(*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FdataPtr = dataPtr
	(*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp = interp
}

/*
 *-----------------------------------------------------------------------------
 *
 * ClockParseFmtScnArgs --
 *
 *	Parses the arguments for sub-commands "scan", "format" and "add".
 *
 *	Note:	common options table used here, because for the options often used
 *		the same literals (objects), so it avoids permanent "recompiling" of
 *		option object representation to indexType with another table.
 *
 * Results:
 *	Returns a standard Tcl result, and stores parsed options
 *	(format, the locale, timezone and base) in structure "opts".
 *
 *-----------------------------------------------------------------------------
 */

type TClockOperation = int32

/*
 *-----------------------------------------------------------------------------
 *
 * ClockParseFmtScnArgs --
 *
 *	Parses the arguments for sub-commands "scan", "format" and "add".
 *
 *	Note:	common options table used here, because for the options often used
 *		the same literals (objects), so it avoids permanent "recompiling" of
 *		option object representation to indexType with another table.
 *
 * Results:
 *	Returns a standard Tcl result, and stores parsed options
 *	(format, the locale, timezone and base) in structure "opts".
 *
 *-----------------------------------------------------------------------------
 */

type ClockOperation = int32

const CLC_OP_FMT = 0
const /* Doing [clock format] */
CLC_OP_SCN = 1
const /* Doing [clock scan] */
CLC_OP_ADD = 2

func _ClockParseFmtScnArgs(tls *libc.TLS, opts uintptr, date uintptr, objc TTcl_Size, objv uintptr, operation TClockOperation, syntax uintptr) (r int32) {
	bp := tls.Alloc(96)
	defer tls.Free(96) /* Syntax of the current command */
	var _objPtr, baseObj, dataPtr, interp, nval, prev, v12, v15, v16, v17, v18, v4, v6 uintptr
	var baseIdx, i, v1, v14, v5 TTcl_Size
	var saw, v10, v3 int32
	var v11, v7 bool
	var _ /* baseVal at bp+8 */ TTcl_WideInt
	var _ /* gmtFlag at bp+0 */ int32
	var _ /* idx at bp+28 */ int32
	var _ /* now at bp+32 */ TTcl_Time
	var _ /* num at bp+16 */ TTcl_WideInt
	var _ /* optionIndex at bp+4 */ int32
	var _ /* val at bp+24 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, baseIdx, baseObj, dataPtr, i, interp, nval, prev, saw, v1, v10, v11, v12, v14, v15, v16, v17, v18, v3, v4, v5, v6, v7
	interp = (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp
	dataPtr = (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FdataPtr
	*(*int32)(unsafe.Pointer(bp)) = 0
	saw = 0 /* Base time, expressed in seconds from the Epoch */
	if operation == int32(CLC_OP_SCN) {
		/* default flags (from configure) */
		*(*int32)(unsafe.Pointer(opts + 48)) |= (*TClockClientData)(unsafe.Pointer(dataPtr)).FdefFlags & int32(CLF_VALIDATE)
	} else {
		/* clock value (as current base) */
		v1 = libc.Int64FromInt32(1)
		baseIdx = v1
		(*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FbaseObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(v1)*8))
		saw |= libc.Int32FromInt32(1) << 0
	}
	/*
	 * Extract values for the keywords.
	 */
	i = int64(2)
	for {
		if !(i < objc) {
			break
		}
		/* bypass integers (offsets) by "clock add" */
		if operation == int32(CLC_OP_ADD) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
				*(*TTcl_WideInt)(unsafe.Pointer(bp + 16)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep))
				v3 = libc.Int32FromInt32(TCL_OK)
			} else {
				v3 = XTcl_GetWideIntFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp+16)
			}
			if v3 == TCL_OK {
				goto _2
			}
		}
		/* get option */
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_options1)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+4) != TCL_OK {
			goto badOptionMsg
		}
		/* if already specified */
		if saw&(int32(1)<<*(*int32)(unsafe.Pointer(bp + 4))) != 0 {
			if operation != int32(CLC_OP_SCN) && *(*int32)(unsafe.Pointer(bp + 4)) == 0 {
				goto badOptionMsg
			}
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
				v4 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
			} else {
				v4 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+13363, libc.VaList(bp+56, v4)))
			goto badOption
		}
		switch *(*int32)(unsafe.Pointer(bp + 4)) {
		case 1:
			if operation == int32(CLC_OP_ADD) {
				goto badOptionMsg
			}
			(*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FformatObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8))
		case 2:
			if XTcl_GetBoolFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)), (libc.Int32FromInt32(TCL_NULL_OK)-libc.Int32FromInt32(2))&libc.Int32FromInt64(4), bp) != TCL_OK {
				return int32(TCL_ERROR)
			}
		case 3:
			(*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FlocaleObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8))
		case 4:
			(*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FtimezoneObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8))
		case 0:
			v5 = i + libc.Int64FromInt32(1)
			baseIdx = v5
			(*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FbaseObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(v5)*8))
		case 5:
			if operation != int32(CLC_OP_SCN) {
				goto badOptionMsg
			} else {
				if XTcl_GetBoolFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)), (libc.Int32FromInt32(TCL_NULL_OK)-libc.Int32FromInt32(2))&libc.Int32FromInt64(4), bp+24) != TCL_OK {
					return int32(TCL_ERROR)
				}
				if *(*int32)(unsafe.Pointer(bp + 24)) != 0 {
					*(*int32)(unsafe.Pointer(opts + 48)) |= int32(CLF_VALIDATE)
				} else {
					*(*int32)(unsafe.Pointer(opts + 48)) &= ^int32(CLF_VALIDATE)
				}
			}
			break
		}
		saw |= int32(1) << *(*int32)(unsafe.Pointer(bp + 4))
		goto _2
	_2:
		;
		i += int64(2)
	}
	/*
	 * Check options.
	 */
	if saw&(libc.Int32FromInt32(1)<<2) != 0 && saw&(libc.Int32FromInt32(1)<<4) != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+13395, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+56, __ccgo_ts+12666, __ccgo_ts+13438, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if *(*int32)(unsafe.Pointer(bp)) != 0 {
		(*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FtimezoneObj = *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals + uintptr(LIT_GMT)*8))
	} else {
		if v7 = (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FtimezoneObj == libc.UintptrFromInt32(0); !v7 {
			if (*TTcl_Obj)(unsafe.Pointer((*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FtimezoneObj)).Fbytes != 0 {
				v6 = (*TTcl_Obj)(unsafe.Pointer((*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FtimezoneObj)).Fbytes
			} else {
				v6 = XTcl_GetStringFromObj(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FtimezoneObj, libc.UintptrFromInt32(0))
			}
		}
		if v7 || v6 == libc.UintptrFromInt32(0) || (*TTcl_Obj)(unsafe.Pointer((*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FtimezoneObj)).Flength == 0 {
			/* If time zone not specified use system time zone */
			(*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FtimezoneObj = _ClockGetSystemTimeZone(tls, dataPtr, interp)
			if (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FtimezoneObj == libc.UintptrFromInt32(0) {
				return int32(TCL_ERROR)
			}
		}
	}
	/* Setup timezone (normalize object if needed and load TZ on demand) */
	(*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FtimezoneObj = XClockSetupTimeZone(tls, dataPtr, interp, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FtimezoneObj)
	if (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FtimezoneObj == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/* Base (by scan or add) or clock value (by format) */
	if !((*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FbaseObj != libc.UintptrFromInt32(0)) {
		goto _8
	}
	baseObj = (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FbaseObj
	/* bypass integer recognition if looks like "now" or "-now" */
	if v11 = (*TTcl_Obj)(unsafe.Pointer(baseObj)).Fbytes != 0 && ((*TTcl_Obj)(unsafe.Pointer(baseObj)).Flength == int64(3) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(baseObj)).Fbytes))) == int32('n') || (*TTcl_Obj)(unsafe.Pointer(baseObj)).Flength == int64(4) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(baseObj)).Fbytes + 1))) == int32('n')); !v11 {
		if (*TTcl_Obj)(unsafe.Pointer(baseObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
			*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(baseObj)).FinternalRep))
			v10 = libc.Int32FromInt32(TCL_OK)
		} else {
			v10 = XTcl_GetWideIntFromObj(tls, libc.UintptrFromInt32(0), baseObj, bp+8)
		}
	}
	if v11 || v10 != TCL_OK {
		if XTcl_GetIndexFromObjStruct(tls, libc.UintptrFromInt32(0), baseObj, uintptr(unsafe.Pointer(&_nowOpts)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11827, libc.Int32FromInt32(TCL_EXACT)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+28) == TCL_OK {
			goto baseNow
		}
		if (*TTcl_Obj)(unsafe.Pointer(baseObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclBignumType)) {
			goto baseOverflow
		}
		if (*TTcl_Obj)(unsafe.Pointer(baseObj)).Fbytes != 0 {
			v12 = (*TTcl_Obj)(unsafe.Pointer(baseObj)).Fbytes
		} else {
			v12 = XTcl_GetStringFromObj(tls, baseObj, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+13463, libc.VaList(bp+56, v12)))
		i = baseIdx
		goto badOption
	}
	/*
	 * Seconds could be an unsigned number that overflowed. Make sure
	 * that it isn't. Additionally it may be too complex to calculate
	 * julianday etc (forwards/backwards) by too large/small values, thus
	 * just let accept a bit shorter values to avoid overflow.
	 * Note the year is currently an integer, thus avoid to overflow it also.
	 */
	if !((*TTcl_Obj)(unsafe.Pointer(baseObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclBignumType)) || *(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) < -int64(0x00F0000000000000) || *(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) > int64(0x00F0000000000000)) {
		goto _13
	}
	goto baseOverflow
baseOverflow:
	;
	XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals + uintptr(LIT_INTEGER_VALUE_TOO_LARGE)*8)))
	i = baseIdx
	goto badOption
_13:
	;
	goto _9
_8:
	;
	goto baseNow
baseNow:
	;
	XTcl_GetTime(tls, bp+32)
	*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) = (*(*TTcl_Time)(unsafe.Pointer(bp + 32))).Fsec
_9:
	;
	/*
	 * Extract year, month and day from the base time for the parser to use as
	 * defaults
	 */
	/* check base fields already cached (by TZ, last-second cache) */
	if (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastBase.FtimezoneObj == (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FtimezoneObj && (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastBase.Fdate.Fseconds == *(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) && (!((*TClockClientData)(unsafe.Pointer(dataPtr)).FlastBase.Fdate.Fflags&int32(CLF_CTZ) != 0) || (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastTZEpoch == _TzsetIfNecessary(tls)) {
		libc.Xmemcpy(tls, date, dataPtr+248+8, uint64(libc.UintptrFromInt32(0)+104))
	} else {
		/* extact fields from base */
		(*TTclDateFields)(unsafe.Pointer(date)).Fseconds = *(*TTcl_WideInt)(unsafe.Pointer(bp + 8))
		if _ClockGetDateFields(tls, dataPtr, interp, date, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FtimezoneObj, int32(GREGORIAN_CHANGE_DATE)) != TCL_OK {
			/* TODO - GREGORIAN_CHANGE_DATE should be locale-dependent */
			return int32(TCL_ERROR)
		}
		/* cache last base */
		libc.Xmemcpy(tls, dataPtr+248+8, date, uint64(libc.UintptrFromInt32(0)+104))
		nval = (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FtimezoneObj
		if (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastBase.FtimezoneObj != nval {
			prev = (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastBase.FtimezoneObj
			(*TClockClientData)(unsafe.Pointer(dataPtr)).FlastBase.FtimezoneObj = nval
			if (*TClockClientData)(unsafe.Pointer(dataPtr)).FlastBase.FtimezoneObj != 0 {
				(*TTcl_Obj)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FlastBase.FtimezoneObj)).FrefCount++
			}
			if prev != libc.UintptrFromInt32(0) {
				_objPtr = prev
				v15 = _objPtr
				v14 = *(*TTcl_Size)(unsafe.Pointer(v15))
				*(*TTcl_Size)(unsafe.Pointer(v15))--
				if v14 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
		}
	}
	return TCL_OK
	goto badOptionMsg
badOptionMsg:
	;
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
		v16 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
	} else {
		v16 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
	}
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+13504, libc.VaList(bp+56, v16, syntax)))
	goto badOption
badOption:
	;
	if i < objc {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
			v18 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
		} else {
			v18 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		v17 = v18
	} else {
		v17 = libc.UintptrFromInt32(0)
	}
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+56, __ccgo_ts+12666, __ccgo_ts+12672, v17, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
}

var _options1 = [7]uintptr{
	0: __ccgo_ts + 13326,
	1: __ccgo_ts + 13332,
	2: __ccgo_ts + 13340,
	3: __ccgo_ts + 13345,
	4: __ccgo_ts + 13353,
	5: __ccgo_ts + 12780,
	6: libc.UintptrFromInt32(0),
} /* Index of an option. */

/* we accept "now" and "-now" as current date-time */
var _nowOpts = [3]uintptr{
	0: __ccgo_ts + 13454,
	1: __ccgo_ts + 13458,
	2: libc.UintptrFromInt32(0),
}

/*----------------------------------------------------------------------
 *
 * ClockFormatObjCmd -- , clock format --
 *
 *	This function is invoked to process the Tcl "clock format" command.
 *
 *	Formats a count of seconds since the Posix Epoch as a time of day.
 *
 *	The 'clock format' command formats times of day for output.  Refer
 *	to the user documentation to see what it does.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _ClockFormatObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(240)
	defer tls.Free(240) /* Parameter values */
	var _objPtr, dataPtr, v2 uintptr
	var ret int32
	var v1 TTcl_Size
	var _ /* dateFmt at bp+64 */ TDateFormat
	var _ /* opts at bp+0 */ TClockFmtScnCmdArgs
	_, _, _, _, _ = _objPtr, dataPtr, ret, v1, v2
	dataPtr = clientData
	/* even number of arguments */
	if objc&int32(1) == int32(1) {
		XTcl_WrongNumArgs(tls, interp, 0, objv, _syntax)
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+216, __ccgo_ts+12666, __ccgo_ts+13624, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	libc.Xmemset(tls, bp+64, 0, uint64(144))
	/*
	 * Extract values for the keywords.
	 */
	_ClockInitFmtScnArgs(tls, dataPtr, interp, bp)
	ret = _ClockParseFmtScnArgs(tls, bp, bp+64+24, int64(objc), objv, int32(CLC_OP_FMT), __ccgo_ts+13637)
	if ret != TCL_OK {
		goto done
	}
	/* Default format */
	if (*(*TClockFmtScnCmdArgs)(unsafe.Pointer(bp))).FformatObj == libc.UintptrFromInt32(0) {
		(*(*TClockFmtScnCmdArgs)(unsafe.Pointer(bp))).FformatObj = *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals + uintptr(LIT__DEFAULT_FORMAT)*8))
	}
	/* Use compiled version of Format - */
	ret = XClockFormat(tls, bp+64, bp)
	goto done
done:
	;
	if (*(*TDateFormat)(unsafe.Pointer(bp + 64))).Fdate.FtzName != libc.UintptrFromInt32(0) {
		_objPtr = (*(*TDateFormat)(unsafe.Pointer(bp + 64))).Fdate.FtzName
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		(*(*TDateFormat)(unsafe.Pointer(bp + 64))).Fdate.FtzName = libc.UintptrFromInt32(0)
	}
	return ret
}

var _syntax = __ccgo_ts + 13532 /* Common structure used for formatting */

/*----------------------------------------------------------------------
 *
 * ClockScanObjCmd -- , clock scan --
 *
 *	This function is invoked to process the Tcl "clock scan" command.
 *
 *	Inputs a count of seconds since the Posix Epoch as a time of day.
 *
 *	The 'clock scan' command scans times of day on input. Refer to the
 *	user documentation to see what it does.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _ClockScanObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(336)
	defer tls.Free(336) /* Parameter values */
	var _objPtr, dataPtr, info1, v5 uintptr
	var ret, v1 int32
	var v2, v3 TTcl_WideInt
	var v4 TTcl_Size
	var _ /* opts at bp+0 */ TClockFmtScnCmdArgs
	var _ /* yy at bp+64 */ TDateInfo
	_, _, _, _, _, _, _, _, _ = _objPtr, dataPtr, info1, ret, v1, v2, v3, v4, v5
	dataPtr = clientData
	info1 = bp + 64
	/* even number of arguments */
	if objc&int32(1) == int32(1) {
		XTcl_WrongNumArgs(tls, interp, 0, objv, _syntax1)
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+312, __ccgo_ts+12666, __ccgo_ts+13624, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	libc.Xmemset(tls, bp+64, 0, uint64(240))
	/*
	 * Extract values for the keywords.
	 */
	_ClockInitFmtScnArgs(tls, dataPtr, interp, bp)
	ret = _ClockParseFmtScnArgs(tls, bp, bp+64+24, int64(objc), objv, int32(CLC_OP_SCN), __ccgo_ts+13794)
	if ret != TCL_OK {
		goto done
	}
	/* seconds are in localSeconds (relative base date), so reset time here */
	v3 = libc.Int64FromInt32(0)
	(*TDateInfo)(unsafe.Pointer(info1)).Fdate.FsecondOfDay = v3
	v2 = v3
	(*TDateInfo)(unsafe.Pointer(info1)).Fdate.FsecondOfMin = v2
	v1 = int32(v2)
	(*TDateInfo)(unsafe.Pointer(info1)).Fdate.Fminutes = v1
	(*TDateInfo)(unsafe.Pointer(info1)).Fdate.Fhour = v1
	(*TDateInfo)(unsafe.Pointer(info1)).FdateMeridian = int32(MER24)
	/* If free scan */
	if (*(*TClockFmtScnCmdArgs)(unsafe.Pointer(bp))).FformatObj == libc.UintptrFromInt32(0) {
		/* Use compiled version of FreeScan - */
		/* [SB] TODO: Perhaps someday we'll localize the legacy code. Right now,
		 * it's not localized. */
		if (*(*TClockFmtScnCmdArgs)(unsafe.Pointer(bp))).FlocaleObj != libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+13848, int64(-libc.Int32FromInt32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+312, __ccgo_ts+12666, __ccgo_ts+13893, libc.UintptrFromInt32(0)))
			ret = int32(TCL_ERROR)
			goto done
		}
		ret = _ClockFreeScan(tls, bp+64, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
	} else {
		/* Use compiled version of Scan - */
		ret = XClockScan(tls, bp+64, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
	}
	if ret != TCL_OK {
		goto done
	}
	/*
	 * If no GMT and not free-scan (where valid stage 1 is done in-between),
	 * validate with stage 1 before local time conversion, otherwise it may
	 * adjust date/time tokens to valid values
	 */
	if (*(*TClockFmtScnCmdArgs)(unsafe.Pointer(bp))).Fflags&int32(CLF_VALIDATE_S1) != 0 && (*TDateInfo)(unsafe.Pointer(info1)).Fflags&(int32(CLF_ASSEMBLE_SECONDS)|int32(CLF_LOCALSEC)) != 0 {
		ret = _ClockValidDate(tls, bp+64, bp, int32(CLF_VALIDATE_S1))
		if ret != TCL_OK {
			goto done
		}
	}
	/* Convert date info structure into UTC seconds */
	ret = _ClockScanCommit(tls, bp+64, bp)
	if ret != TCL_OK {
		goto done
	}
	/* Apply remaining validation rules, if expected */
	if (*(*TClockFmtScnCmdArgs)(unsafe.Pointer(bp))).Fflags&int32(CLF_VALIDATE) != 0 {
		ret = _ClockValidDate(tls, bp+64, bp, (*(*TClockFmtScnCmdArgs)(unsafe.Pointer(bp))).Fflags&int32(CLF_VALIDATE))
		if ret != TCL_OK {
			goto done
		}
	}
	goto done
done:
	;
	if (*(*TDateInfo)(unsafe.Pointer(bp + 64))).Fdate.FtzName != libc.UintptrFromInt32(0) {
		_objPtr = (*(*TDateInfo)(unsafe.Pointer(bp + 64))).Fdate.FtzName
		v5 = _objPtr
		v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
		*(*TTcl_Size)(unsafe.Pointer(v5))--
		if v4 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		(*(*TDateInfo)(unsafe.Pointer(bp + 64))).Fdate.FtzName = libc.UintptrFromInt32(0)
	}
	if ret != TCL_OK {
		return ret
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, (*(*TDateInfo)(unsafe.Pointer(bp + 64))).Fdate.Fseconds))
	return TCL_OK
}

var _syntax1 = __ccgo_ts + 13674 /* Common structure used for parsing */

/*----------------------------------------------------------------------
 *
 * ClockScanCommit --
 *
 *	Converts date info structure into UTC seconds.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _ClockScanCommit(tls *libc.TLS, info uintptr, opts uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Format, locale, timezone and base */
	var curJDN float64
	_ = curJDN
	/* If needed assemble julianDay using year, month, etc. */
	if (*TDateInfo)(unsafe.Pointer(info)).Fflags&int32(CLF_ASSEMBLE_JULIANDAY) != 0 {
		if (*TDateInfo)(unsafe.Pointer(info)).Fflags&int32(CLF_ISO8601WEEK) != 0 {
			XGetJulianDayFromEraYearWeekDay(tls, info+24, int32(GREGORIAN_CHANGE_DATE))
		} else {
			if !((*TDateInfo)(unsafe.Pointer(info)).Fflags&int32(CLF_DAYOFYEAR) != 0) || (*TDateInfo)(unsafe.Pointer(info)).Fflags&(int32(CLF_DAYOFMONTH)|int32(CLF_MONTH)) == int32(CLF_DAYOFMONTH)|int32(CLF_MONTH) {
				XGetJulianDayFromEraYearMonthDay(tls, info+24, int32(GREGORIAN_CHANGE_DATE))
			} else {
				XGetJulianDayFromEraYearDay(tls, info+24, int32(GREGORIAN_CHANGE_DATE))
			}
		}
		*(*int32)(unsafe.Pointer(info + 136)) |= int32(CLF_ASSEMBLE_SECONDS)
		*(*int32)(unsafe.Pointer(info + 136)) &= ^int32(CLF_ASSEMBLE_JULIANDAY)
	}
	/* some overflow checks */
	if (*TDateInfo)(unsafe.Pointer(info)).Fflags&int32(CLF_JULIANDAY) != 0 {
		curJDN = float64((*TDateInfo)(unsafe.Pointer(info)).Fdate.FjulianDay) + (float64((*TDateInfo)(unsafe.Pointer(info)).Fdate.FsecondOfDay)-float64(libc.Int32FromInt32(SECONDS_PER_DAY)/libc.Int32FromInt32(2)))/libc.Float64FromInt32(SECONDS_PER_DAY)
		if curJDN > (*TClockClientData)(unsafe.Pointer((*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FdataPtr)).FmaxJDN {
			XTcl_SetObjResult(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, XTcl_NewStringObj(tls, __ccgo_ts+13914, int64(-libc.Int32FromInt32(1))))
			XTcl_SetErrorCode(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, libc.VaList(bp+8, __ccgo_ts+12666, __ccgo_ts+13952, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
	}
	/* If seconds overflows the day (not valide case, or 24:00), increase days */
	if (*TDateInfo)(unsafe.Pointer(info)).Fdate.FsecondOfDay >= int64(SECONDS_PER_DAY) {
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FjulianDay += (*TDateInfo)(unsafe.Pointer(info)).Fdate.FsecondOfDay / int64(SECONDS_PER_DAY)
		*(*TTcl_WideInt)(unsafe.Pointer(info + 24 + 88)) %= int64(SECONDS_PER_DAY)
	}
	/* Local seconds to UTC (stored in yydate.seconds) */
	if (*TDateInfo)(unsafe.Pointer(info)).Fflags&int32(CLF_ASSEMBLE_SECONDS) != 0 {
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FlocalSeconds = -int64(210866803200) + int64(SECONDS_PER_DAY)*(*TDateInfo)(unsafe.Pointer(info)).Fdate.FjulianDay + (*TDateInfo)(unsafe.Pointer(info)).Fdate.FsecondOfDay
	}
	if (*TDateInfo)(unsafe.Pointer(info)).Fflags&(int32(CLF_ASSEMBLE_SECONDS)|int32(CLF_LOCALSEC)) != 0 {
		if _ConvertLocalToUTC(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FdataPtr, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, info+24, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FtimezoneObj, int32(GREGORIAN_CHANGE_DATE)) != TCL_OK {
			return int32(TCL_ERROR)
		}
	}
	/* Increment UTC seconds with relative time */
	(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fseconds += (*TDateInfo)(unsafe.Pointer(info)).FdateRelSeconds
	return TCL_OK
}

/*----------------------------------------------------------------------
 *
 * ClockValidDate --
 *
 *	Validate date info structure for wrong data (e. g. out of ranges).
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _ClockValidDate(tls *libc.TLS, info uintptr, opts uintptr, stage int32) (r int32) {
	bp := tls.Alloc(160)
	defer tls.Free(160) /* Stage to validate (1, 2 or 3 for both) */
	var dataPtr, errCode, errMsg, h, v4 uintptr
	var tempCpyFlg, v1, v3 int32
	var v2 bool
	var _ /* temp at bp+0 */ TTclDateFields
	_, _, _, _, _, _, _, _, _ = dataPtr, errCode, errMsg, h, tempCpyFlg, v1, v2, v3, v4
	errMsg = __ccgo_ts + 1945
	errCode = __ccgo_ts + 1945
	tempCpyFlg = 0
	dataPtr = (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FdataPtr
	if !(stage&int32(CLF_VALIDATE_S1) != 0) || !((*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Fflags&int32(CLF_VALIDATE_S1) != 0) {
		goto stage_2
	}
	*(*int32)(unsafe.Pointer(opts + 48)) &= ^int32(CLF_VALIDATE_S1) /* stage 1 is done */
	/* first year (used later in hath / daysInPriorMonths) */
	if (*TDateInfo)(unsafe.Pointer(info)).Fflags&(int32(CLF_YEAR)|int32(CLF_ISO8601YEAR)) != 0 {
		if (*TDateInfo)(unsafe.Pointer(info)).Fflags&int32(CLF_ISO8601YEAR) != 0 {
			if (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fiso8601Year < (*TClockClientData)(unsafe.Pointer(dataPtr)).FvalidMinYear || (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fiso8601Year > (*TClockClientData)(unsafe.Pointer(dataPtr)).FvalidMaxYear {
				errMsg = __ccgo_ts + 13965
				errCode = __ccgo_ts + 13982
				goto error
			}
		}
		if (*TDateInfo)(unsafe.Pointer(info)).Fflags&int32(CLF_YEAR) != 0 {
			if (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fyear < (*TClockClientData)(unsafe.Pointer(dataPtr)).FvalidMinYear || (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fyear > (*TClockClientData)(unsafe.Pointer(dataPtr)).FvalidMaxYear {
				errMsg = __ccgo_ts + 13991
				errCode = __ccgo_ts + 11851
				goto error
			}
		} else {
			if (*TDateInfo)(unsafe.Pointer(info)).Fflags&int32(CLF_ISO8601YEAR) != 0 {
				(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fyear = (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fiso8601Year /* used to recognize leap */
			}
		}
		if (*TDateInfo)(unsafe.Pointer(info)).Fflags&(int32(CLF_ISO8601YEAR)|int32(CLF_YEAR)) == int32(CLF_ISO8601YEAR)|int32(CLF_YEAR) {
			if (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fyear != (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fiso8601Year {
				errMsg = __ccgo_ts + 14004
				errCode = __ccgo_ts + 11851
				goto error
			}
		}
	}
	/* and month (used later in hath) */
	if (*TDateInfo)(unsafe.Pointer(info)).Fflags&int32(CLF_MONTH) != 0 {
		if (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fmonth < int32(1) || (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fmonth > int32(12) {
			errMsg = __ccgo_ts + 14019
			errCode = __ccgo_ts + 11821
			goto error
		}
	}
	/* day of month */
	if (*TDateInfo)(unsafe.Pointer(info)).Fflags&(int32(CLF_DAYOFMONTH)|int32(CLF_DAYOFWEEK)) != 0 {
		if (*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfMonth < int32(1) || (*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfMonth > int32(31) {
			errMsg = __ccgo_ts + 14033
			errCode = __ccgo_ts + 14045
			goto error
		}
		if (*TDateInfo)(unsafe.Pointer(info)).Fflags&int32(CLF_MONTH) != 0 {
			h = uintptr(unsafe.Pointer(&_hath)) + uintptr(XIsGregorianLeapYear(tls, info+24))*48
			if (*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfMonth > *(*int32)(unsafe.Pointer(h + uintptr((*TDateInfo)(unsafe.Pointer(info)).Fdate.Fmonth-int32(1))*4)) {
				errMsg = __ccgo_ts + 14033
				errCode = __ccgo_ts + 14045
				goto error
			}
		}
	}
	if (*TDateInfo)(unsafe.Pointer(info)).Fflags&int32(CLF_DAYOFYEAR) != 0 {
		if (*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfYear < int32(1) || (*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfYear > *(*int32)(unsafe.Pointer(uintptr(unsafe.Pointer(&_daysInPriorMonths)) + uintptr(XIsGregorianLeapYear(tls, info+24))*52 + 12*4)) {
			errMsg = __ccgo_ts + 14049
			errCode = __ccgo_ts + 14069
			goto error
		}
	}
	/* mmdd !~ ddd */
	if (*TDateInfo)(unsafe.Pointer(info)).Fflags&(int32(CLF_DAYOFYEAR)|int32(CLF_DAYOFMONTH)|int32(CLF_MONTH)) == int32(CLF_DAYOFYEAR)|int32(CLF_DAYOFMONTH)|int32(CLF_MONTH) {
		if !(tempCpyFlg != 0) {
			libc.Xmemcpy(tls, bp, info+24, uint64(112))
			tempCpyFlg = int32(1)
		}
		XGetJulianDayFromEraYearDay(tls, bp, int32(GREGORIAN_CHANGE_DATE))
		if (*(*TTclDateFields)(unsafe.Pointer(bp))).FjulianDay != (*TDateInfo)(unsafe.Pointer(info)).Fdate.FjulianDay {
			errMsg = __ccgo_ts + 14081
			errCode = __ccgo_ts + 14045
			goto error
		}
	}
	if (*TDateInfo)(unsafe.Pointer(info)).Fflags&int32(CLF_TIME) != 0 {
		/* hour */
		if v2 = (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fhour < 0; !v2 {
			if (*TDateInfo)(unsafe.Pointer(info)).FdateMeridian == int32(MER24) {
				v1 = int32(23)
			} else {
				v1 = int32(12)
			}
		}
		if v2 || (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fhour > v1 {
			/* allow 24:00:00 as special case, see [aee9f2b916afd976] */
			if (*TDateInfo)(unsafe.Pointer(info)).FdateMeridian == int32(MER24) && (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fhour == int32(24) {
				if (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fminutes != 0 || (*TDateInfo)(unsafe.Pointer(info)).Fdate.FsecondOfMin != 0 {
					errMsg = __ccgo_ts + 14095
					errCode = __ccgo_ts + 5581
					goto error
				}
				/* 24:00 is next day 00:00, correct day of week if given */
				if (*TDateInfo)(unsafe.Pointer(info)).Fflags&int32(CLF_DAYOFWEEK) != 0 {
					v4 = info + 24 + 64
					*(*int32)(unsafe.Pointer(v4))++
					v3 = *(*int32)(unsafe.Pointer(v4))
					if v3 > int32(7) { /* Mon .. Sun == 1 .. 7 */
						(*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfWeek = int32(1)
					}
				}
			} else {
				errMsg = __ccgo_ts + 14108
				errCode = __ccgo_ts + 14128
				goto error
			}
		}
		/* minutes */
		if (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fminutes < 0 || (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fminutes > int32(59) {
			errMsg = __ccgo_ts + 14133
			errCode = __ccgo_ts + 14156
			goto error
		}
		/* oldscan could return secondOfDay -1 by invalid time (see ToSeconds) */
		if (*TDateInfo)(unsafe.Pointer(info)).Fdate.FsecondOfMin < 0 || (*TDateInfo)(unsafe.Pointer(info)).Fdate.FsecondOfMin > int64(59) || (*TDateInfo)(unsafe.Pointer(info)).Fdate.FsecondOfDay <= int64(-int32(1)) {
			errMsg = __ccgo_ts + 14095
			errCode = __ccgo_ts + 11827
			goto error
		}
	}
	if !(stage&int32(CLF_VALIDATE_S2) != 0) || !((*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Fflags&int32(CLF_VALIDATE_S2) != 0) {
		return TCL_OK
	}
	/*
	 * Further tests expected ready calculated julianDay (inclusive relative),
	 * and time-zone conversion (local to UTC time).
	 */
	goto stage_2
stage_2:
	;
	*(*int32)(unsafe.Pointer(opts + 48)) &= ^int32(CLF_VALIDATE_S2) /* stage 2 is done */
	/* time, regarding the modifications by the time-zone (looks for given time
	 * in between DST-time hole, so does not exist in this time-zone) */
	if (*TDateInfo)(unsafe.Pointer(info)).Fflags&int32(CLF_TIME) != 0 {
		/*
		 * we don't need to do the backwards time-conversion (UTC to local) and
		 * compare results, because the after conversion (local to UTC) we
		 * should have valid localSeconds (was not invalidated to TCL_INV_SECONDS),
		 * so if it was invalidated - invalid time, outside the time-zone (in DST-hole)
		 */
		if (*TDateInfo)(unsafe.Pointer(info)).Fdate.FlocalSeconds == -libc.Int64FromInt64(0x00F0000000000000)-libc.Int64FromInt32(1) {
			errMsg = __ccgo_ts + 14164
			errCode = __ccgo_ts + 14212
			goto error
		}
	}
	/* day of week */
	if (*TDateInfo)(unsafe.Pointer(info)).Fflags&int32(CLF_DAYOFWEEK) != 0 {
		if !(tempCpyFlg != 0) {
			libc.Xmemcpy(tls, bp, info+24, uint64(112))
			tempCpyFlg = int32(1)
		}
		_GetYearWeekDay(tls, bp, int32(GREGORIAN_CHANGE_DATE))
		if (*(*TTclDateFields)(unsafe.Pointer(bp))).FdayOfWeek != (*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfWeek {
			errMsg = __ccgo_ts + 14224
			errCode = __ccgo_ts + 14244
			goto error
		}
	}
	return TCL_OK
	goto error
error:
	;
	XTcl_SetObjResult(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, XTcl_ObjPrintf(tls, __ccgo_ts+14256, libc.VaList(bp+120, errMsg)))
	XTcl_SetErrorCode(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, libc.VaList(bp+120, __ccgo_ts+12666, __ccgo_ts+14291, errCode, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
}

/*----------------------------------------------------------------------
 *
 * ClockFreeScan --
 *
 *	Used by ClockScanObjCmd for free scanning without format.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _ClockFreeScan(tls *libc.TLS, info uintptr, strObj uintptr, opts uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Command options */
	var _objPtr, dataPtr, interp, tzObjStor, v1, v2, v4 uintptr
	var dstFlag, minEast, ret int32
	var v3 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _ = _objPtr, dataPtr, dstFlag, interp, minEast, ret, tzObjStor, v1, v2, v3, v4
	interp = (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp
	dataPtr = (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FdataPtr
	ret = int32(TCL_ERROR)
	/*
	 * Parse the date. The parser will fill a structure "info" with date,
	 * time, time zone, relative month/day/seconds, relative weekday, ordinal
	 * month.
	 * Notice that many yy-defines point to values in the "info" or "date"
	 * structure, e. g. yySecondOfDay -> info->date.secondOfDay or
	 *			yyMonth -> info->date.month (same as yydate.month)
	 */
	if (*TTcl_Obj)(unsafe.Pointer(strObj)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(strObj)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, strObj, libc.UintptrFromInt32(0))
	}
	(*TDateInfo)(unsafe.Pointer(info)).FdateInput = v1
	if XTclClockFreeScan(tls, interp, info) != TCL_OK {
		if (*TTcl_Obj)(unsafe.Pointer(strObj)).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(strObj)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, strObj, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+14301, libc.VaList(bp+8, v2, XTcl_GetStringFromObj(tls, XTcl_GetObjResult(tls, interp), libc.UintptrFromInt32(0)))))
		goto done
	}
	/*
	 * If the caller supplied a date in the string, update the date with
	 * the value. If the caller didn't specify a time with the date, default to
	 * midnight.
	 */
	if (*TDateInfo)(unsafe.Pointer(info)).Fflags&int32(CLF_YEAR) != 0 {
		if (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fyear < int32(100) {
			if (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fyear >= (*TClockClientData)(unsafe.Pointer(dataPtr)).FyearOfCenturySwitch {
				*(*int32)(unsafe.Pointer(info + 24 + 40)) -= int32(100)
			}
			*(*int32)(unsafe.Pointer(info + 24 + 40)) += (*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentYearCentury
		}
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FisBce = 0
		*(*int32)(unsafe.Pointer(info + 136)) |= int32(CLF_ASSEMBLE_JULIANDAY) | int32(CLF_ASSEMBLE_SECONDS)
	}
	/*
	 * If the caller supplied a time zone in the string, make it into a time
	 * zone indicator of +-hhmm and setup this time zone.
	 */
	if (*TDateInfo)(unsafe.Pointer(info)).Fflags&int32(CLF_ZONE) != 0 {
		if (*TDateInfo)(unsafe.Pointer(info)).FdateTimezone != 0 || !((*TDateInfo)(unsafe.Pointer(info)).FdateDSTmode != 0) {
			/* Real time zone from numeric zone */
			tzObjStor = libc.UintptrFromInt32(0)
			minEast = -(*TDateInfo)(unsafe.Pointer(info)).FdateTimezone
			dstFlag = int32(1) - (*TDateInfo)(unsafe.Pointer(info)).FdateDSTmode
			tzObjStor = XClockFormatNumericTimeZone(tls, int32(60)*minEast+int32(3600)*dstFlag)
			(*TTcl_Obj)(unsafe.Pointer(tzObjStor)).FrefCount++
			(*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FtimezoneObj = XClockSetupTimeZone(tls, dataPtr, interp, tzObjStor)
			_objPtr = tzObjStor
			v4 = _objPtr
			v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
			*(*TTcl_Size)(unsafe.Pointer(v4))--
			if v3 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		} else {
			/* simplest case - GMT / UTC */
			(*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FtimezoneObj = XClockSetupTimeZone(tls, dataPtr, interp, *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals + uintptr(LIT_GMT)*8)))
		}
		if (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FtimezoneObj == libc.UintptrFromInt32(0) {
			goto done
		}
		// TclSetObjRef(yydate.tzName, opts->timezoneObj);
		*(*int32)(unsafe.Pointer(info + 136)) |= int32(CLF_ASSEMBLE_SECONDS)
	}
	/*
	 * For freescan apply validation rules (stage 1) before mixed with
	 * relative time (otherwise always valid recalculated date & time).
	 */
	if (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Fflags&int32(CLF_VALIDATE) != 0 {
		if _ClockValidDate(tls, info, opts, int32(CLF_VALIDATE_S1)) != TCL_OK {
			goto done
		}
	}
	/*
	 * Assemble date, time, zone into seconds-from-epoch
	 */
	if (*TDateInfo)(unsafe.Pointer(info)).Fflags&(int32(CLF_TIME)|int32(CLF_HAVEDATE)) == int32(CLF_HAVEDATE) {
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FsecondOfDay = 0
		*(*int32)(unsafe.Pointer(info + 136)) |= int32(CLF_ASSEMBLE_SECONDS)
	} else {
		if (*TDateInfo)(unsafe.Pointer(info)).Fflags&int32(CLF_TIME) != 0 {
			(*TDateInfo)(unsafe.Pointer(info)).Fdate.FsecondOfDay = int64(XToSeconds(tls, (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fhour, (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fminutes, int32((*TDateInfo)(unsafe.Pointer(info)).Fdate.FsecondOfMin), (*TDateInfo)(unsafe.Pointer(info)).FdateMeridian))
			*(*int32)(unsafe.Pointer(info + 136)) |= int32(CLF_ASSEMBLE_SECONDS)
		} else {
			if (*TDateInfo)(unsafe.Pointer(info)).Fflags&(int32(CLF_DAYOFWEEK)|int32(CLF_HAVEDATE)) == int32(CLF_DAYOFWEEK) || (*TDateInfo)(unsafe.Pointer(info)).Fflags&int32(CLF_ORDINALMONTH) != 0 || (*TDateInfo)(unsafe.Pointer(info)).Fflags&int32(CLF_RELCONV) != 0 && ((*TDateInfo)(unsafe.Pointer(info)).FdateRelMonth != 0 || (*TDateInfo)(unsafe.Pointer(info)).FdateRelDay != 0) {
				(*TDateInfo)(unsafe.Pointer(info)).Fdate.FsecondOfDay = 0
				*(*int32)(unsafe.Pointer(info + 136)) |= int32(CLF_ASSEMBLE_SECONDS)
			} else {
				(*TDateInfo)(unsafe.Pointer(info)).Fdate.FsecondOfDay = (*TDateInfo)(unsafe.Pointer(info)).Fdate.FlocalSeconds % int64(SECONDS_PER_DAY)
			}
		}
	}
	/*
	 * Do relative times
	 */
	ret = _ClockCalcRelTime(tls, info)
	/* Free scanning completed - date ready */
	goto done
done:
	;
	return ret
	return r
}

// C documentation
//
//	/*----------------------------------------------------------------------
//	 *
//	 * ClockCalcRelTime --
//	 *
//	 *	Used for calculating of relative times.
//	 *
//	 * Results:
//	 *	Returns a standard Tcl result.
//	 *
//	 * Side effects:
//	 *	None.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _ClockCalcRelTime(tls *libc.TLS, info uintptr) (r int32) {
	/* Date fields used for converting */
	var h, m, monthDiff, prevDayOfWeek int32
	var newSecs TTcl_WideInt
	var p1 uintptr
	_, _, _, _, _, _ = h, m, monthDiff, newSecs, prevDayOfWeek, p1
	prevDayOfWeek = (*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfWeek /* preserve unchanged day of week */
	/*
	 * Because some calculations require in-between conversion of the
	 * julian day, we can repeat this processing multiple times
	 */
	goto repeat_rel
repeat_rel:
	;
	if (*TDateInfo)(unsafe.Pointer(info)).Fflags&int32(CLF_RELCONV) != 0 {
		/*
		 * Relative conversion normally possible in UTC time only, because
		 * of possible wrong local time increment if ignores in-between DST-hole.
		 * (see test-cases clock-34.53, clock-34.54).
		 * So increment date in julianDay, but time inside day in UTC (seconds).
		 */
		/* add months (or years in months) */
		if (*TDateInfo)(unsafe.Pointer(info)).FdateRelMonth != 0 {
			/* if needed extract year, month, etc. again */
			if (*TDateInfo)(unsafe.Pointer(info)).Fflags&int32(CLF_ASSEMBLE_DATE) != 0 {
				_GetGregorianEraYearDay(tls, info+24, int32(GREGORIAN_CHANGE_DATE))
				_GetMonthDay(tls, info+24)
				_GetYearWeekDay(tls, info+24, int32(GREGORIAN_CHANGE_DATE))
				*(*int32)(unsafe.Pointer(info + 136)) &= ^int32(CLF_ASSEMBLE_DATE)
			}
			/* add the requisite number of months */
			p1 = info + 24 + 48
			*(*int32)(unsafe.Pointer(p1)) = int32(int64(*(*int32)(unsafe.Pointer(p1))) + ((*TDateInfo)(unsafe.Pointer(info)).FdateRelMonth - libc.Int64FromInt32(1)))
			*(*int32)(unsafe.Pointer(info + 24 + 40)) += (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fmonth / int32(12)
			m = (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fmonth % int32(12)
			/* compiler fix for negative offs - wrap y, m = (0, -1) -> (-1, 11) */
			if m < 0 {
				(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fyear--
				m = int32(12) + m
			}
			(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fmonth = m + int32(1)
			/* if the day doesn't exist in the current month, repair it */
			h = *(*int32)(unsafe.Pointer(uintptr(unsafe.Pointer(&_hath)) + uintptr(XIsGregorianLeapYear(tls, info+24))*48 + uintptr(m)*4))
			if (*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfMonth > h {
				(*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfMonth = h
			}
			/* on demand (lazy) assemble julianDay using new year, month, etc. */
			*(*int32)(unsafe.Pointer(info + 136)) |= int32(CLF_ASSEMBLE_JULIANDAY) | int32(CLF_ASSEMBLE_SECONDS)
			(*TDateInfo)(unsafe.Pointer(info)).FdateRelMonth = 0
		}
		/* add days (or other parts aligned to days) */
		if (*TDateInfo)(unsafe.Pointer(info)).FdateRelDay != 0 {
			/* assemble julianDay using new year, month, etc. */
			if (*TDateInfo)(unsafe.Pointer(info)).Fflags&int32(CLF_ASSEMBLE_JULIANDAY) != 0 {
				XGetJulianDayFromEraYearMonthDay(tls, info+24, int32(GREGORIAN_CHANGE_DATE))
				*(*int32)(unsafe.Pointer(info + 136)) &= ^int32(CLF_ASSEMBLE_JULIANDAY)
			}
			(*TDateInfo)(unsafe.Pointer(info)).Fdate.FjulianDay += (*TDateInfo)(unsafe.Pointer(info)).FdateRelDay
			/* julianDay was changed, on demand (lazy) extract year, month, etc. again */
			*(*int32)(unsafe.Pointer(info + 136)) |= int32(CLF_ASSEMBLE_DATE) | int32(CLF_ASSEMBLE_SECONDS)
			(*TDateInfo)(unsafe.Pointer(info)).FdateRelDay = 0
		}
		/* relative time (seconds), if exceeds current date, do the day conversion and
		 * leave rest of the increment in yyRelSeconds to add it hereafter in UTC seconds */
		if (*TDateInfo)(unsafe.Pointer(info)).FdateRelSeconds != 0 {
			newSecs = (*TDateInfo)(unsafe.Pointer(info)).Fdate.FsecondOfDay + (*TDateInfo)(unsafe.Pointer(info)).FdateRelSeconds
			/* if seconds increment outside of current date, increment day */
			if newSecs/int64(SECONDS_PER_DAY) != (*TDateInfo)(unsafe.Pointer(info)).Fdate.FsecondOfDay/int64(SECONDS_PER_DAY) {
				*(*TTcl_WideInt)(unsafe.Pointer(info + 168)) += newSecs / int64(SECONDS_PER_DAY)
				(*TDateInfo)(unsafe.Pointer(info)).Fdate.FsecondOfDay = 0
				(*TDateInfo)(unsafe.Pointer(info)).FdateRelSeconds = newSecs % int64(SECONDS_PER_DAY)
				goto repeat_rel
			}
		}
		*(*int32)(unsafe.Pointer(info + 136)) &= ^int32(CLF_RELCONV)
	}
	/*
	 * Do relative (ordinal) month
	 */
	if (*TDateInfo)(unsafe.Pointer(info)).Fflags&int32(CLF_ORDINALMONTH) != 0 {
		/* if needed extract year, month, etc. again */
		if (*TDateInfo)(unsafe.Pointer(info)).Fflags&int32(CLF_ASSEMBLE_DATE) != 0 {
			_GetGregorianEraYearDay(tls, info+24, int32(GREGORIAN_CHANGE_DATE))
			_GetMonthDay(tls, info+24)
			_GetYearWeekDay(tls, info+24, int32(GREGORIAN_CHANGE_DATE))
			*(*int32)(unsafe.Pointer(info + 136)) &= ^int32(CLF_ASSEMBLE_DATE)
		}
		if (*TDateInfo)(unsafe.Pointer(info)).FdateMonthOrdinalIncr > 0 {
			monthDiff = (*TDateInfo)(unsafe.Pointer(info)).FdateMonthOrdinal - (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fmonth
			if monthDiff <= 0 {
				monthDiff += int32(12)
			}
			(*TDateInfo)(unsafe.Pointer(info)).FdateMonthOrdinalIncr--
		} else {
			monthDiff = (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fmonth - (*TDateInfo)(unsafe.Pointer(info)).FdateMonthOrdinal
			if monthDiff >= 0 {
				monthDiff -= int32(12)
			}
			(*TDateInfo)(unsafe.Pointer(info)).FdateMonthOrdinalIncr++
		}
		/* process it further via relative times */
		*(*int32)(unsafe.Pointer(info + 24 + 40)) += (*TDateInfo)(unsafe.Pointer(info)).FdateMonthOrdinalIncr
		*(*TTcl_WideInt)(unsafe.Pointer(info + 160)) += int64(monthDiff)
		*(*int32)(unsafe.Pointer(info + 136)) &= ^int32(CLF_ORDINALMONTH)
		*(*int32)(unsafe.Pointer(info + 136)) |= int32(CLF_RELCONV) | int32(CLF_ASSEMBLE_JULIANDAY) | int32(CLF_ASSEMBLE_SECONDS)
		goto repeat_rel
	}
	/*
	 * Do relative weekday
	 */
	if (*TDateInfo)(unsafe.Pointer(info)).Fflags&(int32(CLF_DAYOFWEEK)|int32(CLF_HAVEDATE)) == int32(CLF_DAYOFWEEK) {
		/* restore scanned day of week */
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfWeek = prevDayOfWeek
		/* if needed assemble julianDay now */
		if (*TDateInfo)(unsafe.Pointer(info)).Fflags&int32(CLF_ASSEMBLE_JULIANDAY) != 0 {
			XGetJulianDayFromEraYearMonthDay(tls, info+24, int32(GREGORIAN_CHANGE_DATE))
			*(*int32)(unsafe.Pointer(info + 136)) &= ^int32(CLF_ASSEMBLE_JULIANDAY)
		}
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FisBce = 0
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FjulianDay = _WeekdayOnOrBefore(tls, (*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfWeek, (*TDateInfo)(unsafe.Pointer(info)).Fdate.FjulianDay+int64(6)) + int64(int32(7)*(*TDateInfo)(unsafe.Pointer(info)).FdateDayOrdinal)
		if (*TDateInfo)(unsafe.Pointer(info)).FdateDayOrdinal > 0 {
			(*TDateInfo)(unsafe.Pointer(info)).Fdate.FjulianDay -= int64(7)
		}
		*(*int32)(unsafe.Pointer(info + 136)) |= int32(CLF_ASSEMBLE_DATE) | int32(CLF_ASSEMBLE_SECONDS)
	}
	return TCL_OK
}

/*----------------------------------------------------------------------
 *
 * ClockWeekdaysOffs --
 *
 *	Get offset in days for the number of week days corresponding the
 *	given day of week (skipping Saturdays and Sundays).
 *
 *
 * Results:
 *	Returns a day increment adjusted the given weekdays
 *
 *----------------------------------------------------------------------
 */

func _ClockWeekdaysOffs(tls *libc.TLS, dayOfWeek int32, offs int32) (r int32) {
	var adj, day, resDayOfWeek, weeks int32
	_, _, _, _ = adj, day, resDayOfWeek, weeks
	/* offset in days */
	weeks = offs / int32(5)
	offs = offs % int32(5)
	/* compiler fix for negative offs - wrap (0, -1) -> (-1, 4) */
	if offs < 0 {
		weeks--
		offs = int32(5) + offs
	}
	offs += int32(7) * weeks
	/* resulting day of week */
	day = offs % int32(7)
	/* compiler fix for negative offs - wrap (0, -1) -> (-1, 6) */
	if day < 0 {
		day = int32(7) + day
	}
	resDayOfWeek = dayOfWeek + day
	/* adjust if we start from a weekend */
	if dayOfWeek > int32(5) {
		adj = int32(5) - dayOfWeek
		offs += adj
		resDayOfWeek += adj
	}
	/* adjust if we end up on a weekend */
	if resDayOfWeek > int32(5) {
		offs += int32(2)
	}
	return offs
}

/*----------------------------------------------------------------------
 *
 * ClockAddObjCmd -- , clock add --
 *
 *	Adds an offset to a given time.
 *
 *	Refer to the user documentation to see what it exactly does.
 *
 * Syntax:
 *   clock add clockval ?count unit?... ?-option value?
 *
 * Parameters:
 *   clockval -- Starting time value
 *   count -- Amount of a unit of time to add
 *   unit -- Unit of time to add, must be one of:
 *	     years year months month weeks week
 *	     days day hours hour minutes minute
 *	     seconds second
 *
 * Options:
 *   -gmt BOOLEAN
 *	 Flag synonymous with '-timezone :GMT'
 *   -timezone ZONE
 *	 Name of the time zone in which calculations are to be done.
 *   -locale NAME
 *	 Name of the locale in which calculations are to be done.
 *	 Used to determine the Gregorian change date.
 *
 * Results:
 *	Returns a standard Tcl result with the given time adjusted
 *	by the given offset(s) in order.
 *
 * Notes:
 *   It is possible that adding a number of months or years will adjust the
 *   day of the month as well.	For instance, the time at one month after
 *   31 January is either 28 or 29 February, because February has fewer
 *   than 31 days.
 *
 *----------------------------------------------------------------------
 */

func _ClockAddObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(352)
	defer tls.Free(352) /* Parameter values */
	var _objPtr, dataPtr, info1, v9 uintptr
	var i, v8 TTcl_Size
	var ret, v3 int32
	var v1 TTcl_WideInt
	var v4, v6 int64
	var v5, v7 bool
	var _ /* offs at bp+312 */ TTcl_WideInt
	var _ /* opts at bp+0 */ TClockFmtScnCmdArgs
	var _ /* unitIndex at bp+304 */ int32
	var _ /* yy at bp+64 */ TDateInfo
	_, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, dataPtr, i, info1, ret, v1, v3, v4, v5, v6, v7, v8, v9
	dataPtr = clientData /* Common structure used for parsing */
	info1 = bp + 64
	/* even number of arguments */
	if objc&int32(1) == int32(1) {
		XTcl_WrongNumArgs(tls, interp, 0, objv, _syntax2)
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+328, __ccgo_ts+12666, __ccgo_ts+13624, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	libc.Xmemset(tls, bp+64, 0, uint64(240))
	/*
	 * Extract values for the keywords.
	 */
	_ClockInitFmtScnArgs(tls, dataPtr, interp, bp)
	ret = _ClockParseFmtScnArgs(tls, bp, bp+64+24, int64(objc), objv, int32(CLC_OP_ADD), __ccgo_ts+14478)
	if ret != TCL_OK {
		goto done
	}
	/* time together as seconds of the day */
	v1 = (*TDateInfo)(unsafe.Pointer(info1)).Fdate.FlocalSeconds % libc.Int64FromInt32(SECONDS_PER_DAY)
	(*TDateInfo)(unsafe.Pointer(info1)).Fdate.FsecondOfMin = v1
	(*TDateInfo)(unsafe.Pointer(info1)).Fdate.FsecondOfDay = v1
	/* seconds are in localSeconds (relative base date), so reset time here */
	(*TDateInfo)(unsafe.Pointer(info1)).Fdate.Fhour = 0
	(*TDateInfo)(unsafe.Pointer(info1)).Fdate.Fminutes = 0
	(*TDateInfo)(unsafe.Pointer(info1)).FdateMeridian = int32(MER24)
	ret = int32(TCL_ERROR)
	/*
	 * Find each offset and process date increment
	 */
	i = int64(2)
	for {
		if !(i < int64(objc)) {
			break
		}
		/* bypass not integers (options, allready processed above in ClockParseFmtScnArgs) */
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
			*(*TTcl_WideInt)(unsafe.Pointer(bp + 312)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep))
			v3 = libc.Int32FromInt32(TCL_OK)
		} else {
			v3 = XTcl_GetWideIntFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp+312)
		}
		if v3 != TCL_OK {
			goto _2
		}
		/* get unit */
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)), uintptr(unsafe.Pointer(&_units)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+14506, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+304) != TCL_OK {
			goto done
		}
		if v5 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclBignumType)); !v5 {
			if *(*int32)(unsafe.Pointer(bp + 304)) < 6 {
				v4 = int64(0x7fffffff)
			} else {
				v4 = int64(0x00F0000000000000)
			}
		}
		if v7 = v5 || *(*TTcl_WideInt)(unsafe.Pointer(bp + 312)) > v4; !v7 {
			if *(*int32)(unsafe.Pointer(bp + 304)) < 6 {
				v6 = int64(-int32(0x7fffffff))
			} else {
				v6 = -int64(0x00F0000000000000)
			}
		}
		if v7 || *(*TTcl_WideInt)(unsafe.Pointer(bp + 312)) < v6 {
			XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals + uintptr(LIT_INTEGER_VALUE_TOO_LARGE)*8)))
			goto done
		}
		/* nothing to do if zero quantity */
		if !(*(*TTcl_WideInt)(unsafe.Pointer(bp + 312)) != 0) {
			goto _2
		}
		/* if in-between conversion needed (already have relative date/time),
		 * correct date info, because the date may be changed,
		 * so refresh it now */
		if (*TDateInfo)(unsafe.Pointer(info1)).Fflags&int32(CLF_RELCONV) != 0 && (*(*int32)(unsafe.Pointer(bp + 304)) == 5 || (*TDateInfo)(unsafe.Pointer(info1)).FdateRelMonth != 0 || (*TDateInfo)(unsafe.Pointer(info1)).FdateRelDay != 0 || (*TDateInfo)(unsafe.Pointer(info1)).Fdate.FsecondOfMin+(*TDateInfo)(unsafe.Pointer(info1)).FdateRelSeconds > int64(SECONDS_PER_DAY) || (*TDateInfo)(unsafe.Pointer(info1)).Fdate.FsecondOfMin+(*TDateInfo)(unsafe.Pointer(info1)).FdateRelSeconds < 0) {
			if _ClockCalcRelTime(tls, info1) != TCL_OK {
				goto done
			}
		}
		/* process increment by offset + unit */
		*(*int32)(unsafe.Pointer(info1 + 136)) |= int32(CLF_RELCONV)
		switch *(*int32)(unsafe.Pointer(bp + 304)) {
		case 0:
			*(*TTcl_WideInt)(unsafe.Pointer(info1 + 160)) += *(*TTcl_WideInt)(unsafe.Pointer(bp + 312)) * int64(12)
		case 1:
			*(*TTcl_WideInt)(unsafe.Pointer(info1 + 160)) += *(*TTcl_WideInt)(unsafe.Pointer(bp + 312))
		case 2:
			fallthrough
		case 3:
			*(*TTcl_WideInt)(unsafe.Pointer(info1 + 168)) += *(*TTcl_WideInt)(unsafe.Pointer(bp + 312)) * int64(7)
		case 4:
			*(*TTcl_WideInt)(unsafe.Pointer(info1 + 168)) += *(*TTcl_WideInt)(unsafe.Pointer(bp + 312))
		case 5:
			/* add number of week days (skipping Saturdays and Sundays)
			 * to a relative days value. */
			*(*TTcl_WideInt)(unsafe.Pointer(bp + 312)) = int64(_ClockWeekdaysOffs(tls, (*(*TDateInfo)(unsafe.Pointer(bp + 64))).Fdate.FdayOfWeek, int32(*(*TTcl_WideInt)(unsafe.Pointer(bp + 312)))))
			*(*TTcl_WideInt)(unsafe.Pointer(info1 + 168)) += *(*TTcl_WideInt)(unsafe.Pointer(bp + 312))
		case 6:
			*(*TTcl_WideInt)(unsafe.Pointer(info1 + 176)) += *(*TTcl_WideInt)(unsafe.Pointer(bp + 312)) * int64(60) * int64(60)
		case 7:
			*(*TTcl_WideInt)(unsafe.Pointer(info1 + 176)) += *(*TTcl_WideInt)(unsafe.Pointer(bp + 312)) * int64(60)
		case 8:
			*(*TTcl_WideInt)(unsafe.Pointer(info1 + 176)) += *(*TTcl_WideInt)(unsafe.Pointer(bp + 312))
			break
		}
		goto _2
	_2:
		;
		i += int64(2)
	}
	/*
	 * Do relative times (if not yet already processed interim):
	 */
	if (*TDateInfo)(unsafe.Pointer(info1)).Fflags&int32(CLF_RELCONV) != 0 {
		if _ClockCalcRelTime(tls, info1) != TCL_OK {
			goto done
		}
	}
	/* Convert date info structure into UTC seconds */
	ret = _ClockScanCommit(tls, bp+64, bp)
	goto done
done:
	;
	if (*(*TDateInfo)(unsafe.Pointer(bp + 64))).Fdate.FtzName != libc.UintptrFromInt32(0) {
		_objPtr = (*(*TDateInfo)(unsafe.Pointer(bp + 64))).Fdate.FtzName
		v9 = _objPtr
		v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
		*(*TTcl_Size)(unsafe.Pointer(v9))--
		if v8 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		(*(*TDateInfo)(unsafe.Pointer(bp + 64))).Fdate.FtzName = libc.UintptrFromInt32(0)
	}
	if ret != TCL_OK {
		return ret
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, (*(*TDateInfo)(unsafe.Pointer(bp + 64))).Fdate.Fseconds))
	return TCL_OK
}

var _syntax2 = __ccgo_ts + 14345

/* add "week" to units also (because otherwise ambiguous) */
var _units = [10]uintptr{
	0: __ccgo_ts + 14434,
	1: __ccgo_ts + 14440,
	2: __ccgo_ts + 14447,
	3: __ccgo_ts + 14452,
	4: __ccgo_ts + 14458,
	5: __ccgo_ts + 14463,
	6: __ccgo_ts + 14472,
	7: __ccgo_ts + 14156,
	8: __ccgo_ts + 11827,
	9: libc.UintptrFromInt32(0),
}

/*----------------------------------------------------------------------
 *
 * ClockSecondsObjCmd -
 *
 *	Returns a count of microseconds since the epoch.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 * This function implements the 'clock seconds' Tcl command. Refer to the user
 * documentation for details on what it does.
 *
 *----------------------------------------------------------------------
 */

func _ClockSecondsObjCmd(tls *libc.TLS, dummy4548 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Parameter values */
	var cachePtr, timeObj uintptr
	var uw_ TTcl_WideUInt
	var v1 bool
	var _ /* bignumValue_ at bp+16 */ Tmp_int
	var _ /* now at bp+0 */ TTcl_Time
	_, _, _, _ = cachePtr, timeObj, uw_, v1
	if objc != int32(1) {
		XTcl_WrongNumArgs(tls, interp, 0, objv, __ccgo_ts+14511)
		return int32(TCL_ERROR)
	}
	XTcl_GetTime(tls, bp)
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		timeObj = XTclThreadAllocObj(tls)
	} else {
		timeObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(timeObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(timeObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(timeObj)).Fbytes = libc.UintptrFromInt32(0)
	uw_ = libc.Uint64FromInt64((*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec)
	if uw_ > libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) {
		if XTclBN_mp_init_u64(tls, bp+16, uw_) != MP_OKAY {
			XTcl_Panic(tls, __ccgo_ts+13273, libc.VaList(bp+48, __ccgo_ts+13293))
		}
		XTclSetBignumInternalRep(tls, timeObj, bp+16)
	} else {
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(timeObj)).FinternalRep)) = libc.Int64FromUint64(uw_)
		(*TTcl_Obj)(unsafe.Pointer(timeObj)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	}
	XTcl_SetObjResult(tls, interp, timeObj)
	return TCL_OK
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * ClockSafeCatchCmd --
//	 *
//	 *	Same as "::catch" command but avoids overwriting of interp state.
//	 *
//	 *	See [554117edde] for more info (and proper solution).
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _ClockSafeCatchCmd(tls *libc.TLS, dummy4580 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var _objPtr, iPtr, nval, prev, statePtr, v2 uintptr
	var flags, ret int32
	var v1 TTcl_Size
	_, _, _, _, _, _, _, _, _ = _objPtr, flags, iPtr, nval, prev, ret, statePtr, v1, v2
	iPtr = interp
	flags = 0
	if objc == int32(1) {
		/* wrong # args : */
		return XTcl_CatchObjCmd(tls, libc.UintptrFromInt32(0), interp, objc, objv)
	}
	statePtr = XTcl_SaveInterpState(tls, interp, 0)
	if !((*struct {
		Fstatus          int32
		Fflags           int32
		FreturnLevel     int32
		FreturnCode      int32
		FerrorInfo       uintptr
		FerrorCode       uintptr
		FreturnOpts      uintptr
		FobjResult       uintptr
		FerrorStack      uintptr
		FresetErrorStack int32
	})(unsafe.Pointer(statePtr)).FerrorInfo != 0) {
		/* todo: avoid traced get of errorInfo here */
		(*struct {
			Fstatus          int32
			Fflags           int32
			FreturnLevel     int32
			FreturnCode      int32
			FerrorInfo       uintptr
			FerrorCode       uintptr
			FreturnOpts      uintptr
			FobjResult       uintptr
			FerrorStack      uintptr
			FresetErrorStack int32
		})(unsafe.Pointer(statePtr)).FerrorInfo = XTcl_ObjGetVar2(tls, interp, (*TInterp)(unsafe.Pointer(iPtr)).FeiVar, libc.UintptrFromInt32(0), 0)
		if (*struct {
			Fstatus          int32
			Fflags           int32
			FreturnLevel     int32
			FreturnCode      int32
			FerrorInfo       uintptr
			FerrorCode       uintptr
			FreturnOpts      uintptr
			FobjResult       uintptr
			FerrorStack      uintptr
			FresetErrorStack int32
		})(unsafe.Pointer(statePtr)).FerrorInfo != 0 {
			(*TTcl_Obj)(unsafe.Pointer((*struct {
				Fstatus          int32
				Fflags           int32
				FreturnLevel     int32
				FreturnCode      int32
				FerrorInfo       uintptr
				FerrorCode       uintptr
				FreturnOpts      uintptr
				FobjResult       uintptr
				FerrorStack      uintptr
				FresetErrorStack int32
			})(unsafe.Pointer(statePtr)).FerrorInfo)).FrefCount++
		}
		flags |= int32(ERR_LEGACY_COPY)
	}
	if !((*struct {
		Fstatus          int32
		Fflags           int32
		FreturnLevel     int32
		FreturnCode      int32
		FerrorInfo       uintptr
		FerrorCode       uintptr
		FreturnOpts      uintptr
		FobjResult       uintptr
		FerrorStack      uintptr
		FresetErrorStack int32
	})(unsafe.Pointer(statePtr)).FerrorCode != 0) {
		/* todo: avoid traced get of errorCode here */
		(*struct {
			Fstatus          int32
			Fflags           int32
			FreturnLevel     int32
			FreturnCode      int32
			FerrorInfo       uintptr
			FerrorCode       uintptr
			FreturnOpts      uintptr
			FobjResult       uintptr
			FerrorStack      uintptr
			FresetErrorStack int32
		})(unsafe.Pointer(statePtr)).FerrorCode = XTcl_ObjGetVar2(tls, interp, (*TInterp)(unsafe.Pointer(iPtr)).FecVar, libc.UintptrFromInt32(0), 0)
		if (*struct {
			Fstatus          int32
			Fflags           int32
			FreturnLevel     int32
			FreturnCode      int32
			FerrorInfo       uintptr
			FerrorCode       uintptr
			FreturnOpts      uintptr
			FobjResult       uintptr
			FerrorStack      uintptr
			FresetErrorStack int32
		})(unsafe.Pointer(statePtr)).FerrorCode != 0 {
			(*TTcl_Obj)(unsafe.Pointer((*struct {
				Fstatus          int32
				Fflags           int32
				FreturnLevel     int32
				FreturnCode      int32
				FerrorInfo       uintptr
				FerrorCode       uintptr
				FreturnOpts      uintptr
				FobjResult       uintptr
				FerrorStack      uintptr
				FresetErrorStack int32
			})(unsafe.Pointer(statePtr)).FerrorCode)).FrefCount++
		}
		flags |= int32(ERR_LEGACY_COPY)
	}
	/* original catch */
	ret = XTcl_CatchObjCmd(tls, libc.UintptrFromInt32(0), interp, objc, objv)
	if ret == int32(TCL_ERROR) {
		XTcl_DiscardInterpState(tls, statePtr)
		return int32(TCL_ERROR)
	}
	/* overwrite result in state with catch result */
	nval = XTcl_GetObjResult(tls, interp)
	if (*struct {
		Fstatus          int32
		Fflags           int32
		FreturnLevel     int32
		FreturnCode      int32
		FerrorInfo       uintptr
		FerrorCode       uintptr
		FreturnOpts      uintptr
		FobjResult       uintptr
		FerrorStack      uintptr
		FresetErrorStack int32
	})(unsafe.Pointer(statePtr)).FobjResult != nval {
		prev = (*struct {
			Fstatus          int32
			Fflags           int32
			FreturnLevel     int32
			FreturnCode      int32
			FerrorInfo       uintptr
			FerrorCode       uintptr
			FreturnOpts      uintptr
			FobjResult       uintptr
			FerrorStack      uintptr
			FresetErrorStack int32
		})(unsafe.Pointer(statePtr)).FobjResult
		(*struct {
			Fstatus          int32
			Fflags           int32
			FreturnLevel     int32
			FreturnCode      int32
			FerrorInfo       uintptr
			FerrorCode       uintptr
			FreturnOpts      uintptr
			FobjResult       uintptr
			FerrorStack      uintptr
			FresetErrorStack int32
		})(unsafe.Pointer(statePtr)).FobjResult = nval
		if (*struct {
			Fstatus          int32
			Fflags           int32
			FreturnLevel     int32
			FreturnCode      int32
			FerrorInfo       uintptr
			FerrorCode       uintptr
			FreturnOpts      uintptr
			FobjResult       uintptr
			FerrorStack      uintptr
			FresetErrorStack int32
		})(unsafe.Pointer(statePtr)).FobjResult != 0 {
			(*TTcl_Obj)(unsafe.Pointer((*struct {
				Fstatus          int32
				Fflags           int32
				FreturnLevel     int32
				FreturnCode      int32
				FerrorInfo       uintptr
				FerrorCode       uintptr
				FreturnOpts      uintptr
				FobjResult       uintptr
				FerrorStack      uintptr
				FresetErrorStack int32
			})(unsafe.Pointer(statePtr)).FobjResult)).FrefCount++
		}
		if prev != libc.UintptrFromInt32(0) {
			_objPtr = prev
			v2 = _objPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if v1 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
	}
	/* set result (together with restore state) to interpreter */
	XTcl_RestoreInterpState(tls, interp, statePtr)
	/* todo: unless ERR_LEGACY_COPY not set in restore (branch [bug-554117edde] not merged yet) */
	*(*int32)(unsafe.Pointer(iPtr + 368)) |= flags & int32(ERR_LEGACY_COPY)
	return ret
}

/*
 *----------------------------------------------------------------------
 *
 * TzsetIfNecessary --
 *
 *	Calls the tzset() library function if the contents of the TZ
 *	environment variable has changed.
 *
 * Results:
 *	An epoch counter to allow efficient checking if the timezone has
 *	changed.
 *
 * Side effects:
 *	Calls tzset.
 *
 *----------------------------------------------------------------------
 */

type TClockTzStatic = struct {
	Fwas         uintptr
	FlastRefresh int64
	Fepoch       Tsize_t
	FenvEpoch    Tsize_t
}

var _tz = TClockTzStatic{
	Fwas: uintptr(int64(-libc.Int32FromInt32(1))),
}

func _TzsetIfNecessary(tls *libc.TLS) (r Tsize_t) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var epoch, v1, v3 Tsize_t
	var tzNow, v2, v4 uintptr
	var _ /* now at bp+0 */ TTcl_Time
	_, _, _, _, _, _ = epoch, tzNow, v1, v2, v3, v4 /* The tz.epoch that the TZ was read at. */
	/*
	 * Prevent performance regression on some platforms by resolving of system time zone:
	 * small latency for check whether environment was changed (once per second)
	 * no latency if environment was changed with tcl-env (compare both epoch values)
	 */
	XTcl_GetTime(tls, bp)
	if (*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec == _tz.FlastRefresh && _tz.FenvEpoch == XTclEnvEpoch {
		return _tz.Fepoch
	}
	_tz.FenvEpoch = XTclEnvEpoch
	_tz.FlastRefresh = (*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec
	/* check in lock */
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_clockMutex)))
	tzNow = libc.Xgetenv(tls, __ccgo_ts+14525)
	if tzNow == libc.UintptrFromInt32(0) {
		tzNow = libc.Xgetenv(tls, __ccgo_ts+14532)
	}
	if tzNow != libc.UintptrFromInt32(0) && (_tz.Fwas == libc.UintptrFromInt32(0) || _tz.Fwas == uintptr(int64(-libc.Int32FromInt32(1))) || libc.Xstrcmp(tls, tzNow, _tz.Fwas) != 0) {
		libc.Xtzset(tls)
		if _tz.Fwas != libc.UintptrFromInt32(0) && _tz.Fwas != uintptr(int64(-libc.Int32FromInt32(1))) {
			XTclpFree(tls, _tz.Fwas)
		}
		_tz.Fwas = XTcl_Alloc(tls, uint64(1)*(libc.Xstrlen(tls, tzNow)+uint64(1)))
		libc.Xstrcpy(tls, _tz.Fwas, tzNow)
		v2 = uintptr(unsafe.Pointer(&_tz)) + 16
		*(*Tsize_t)(unsafe.Pointer(v2))++
		v1 = *(*Tsize_t)(unsafe.Pointer(v2))
		epoch = v1
	} else {
		if tzNow == libc.UintptrFromInt32(0) && _tz.Fwas != libc.UintptrFromInt32(0) {
			libc.Xtzset(tls)
			if _tz.Fwas != uintptr(int64(-libc.Int32FromInt32(1))) {
				XTclpFree(tls, _tz.Fwas)
			}
			_tz.Fwas = libc.UintptrFromInt32(0)
			v4 = uintptr(unsafe.Pointer(&_tz)) + 16
			*(*Tsize_t)(unsafe.Pointer(v4))++
			v3 = *(*Tsize_t)(unsafe.Pointer(v4))
			epoch = v3
		} else {
			epoch = _tz.Fepoch
		}
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_clockMutex)))
	return epoch
}

func _ClockFinalize(tls *libc.TLS, dummy4734 uintptr) {
	XClockFrmScnFinalize(tls)
	if _tz.Fwas != 0 && _tz.Fwas != uintptr(int64(-libc.Int32FromInt32(1))) {
		XTclpFree(tls, _tz.Fwas)
	}
	XTcl_MutexFinalize(tls, uintptr(unsafe.Pointer(&_clockMutex)))
}

const JDN_MAX_PRECBOUND = 100000000
const JDN_MAX_PRECISION = 8
const TCL_CLOCK_FULL_COMPAT = 1

var _ClockFmtMutex TTcl_Mutex /* Serializes access to common format list. */

/*
 * Derivation of tclStringHashKeyType with extra memory management trickery.
 */

var _ClockFmtScnStorageHashKeyType = TTcl_HashKeyType{
	Fversion: int32(TCL_HASH_KEY_TYPE_VERSION),
}

func init() {
	p := unsafe.Pointer(&_ClockFmtScnStorageHashKeyType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(XTclHashStringKey)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(XTclCompareStringKeys)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_ClockFmtScnStorageAllocProc)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_ClockFmtScnStorageFreeProc)
}

/*
 * Clock scan and format facilities.
 */

/*
 *----------------------------------------------------------------------
 *
 * Clock_str2int, Clock_str2wideInt --
 *
 *	Fast inline-convertion of string to signed int or wide int by given
 *	start/end.
 *
 *	The given string should contain numbers chars only (because already
 *	pre-validated within parsing routines)
 *
 * Results:
 *	Returns a standard Tcl result.
 *	TCL_OK - by successful conversion, TCL_ERROR by (wide) int overflow
 *
 *----------------------------------------------------------------------
 */

func _Clock_str2int_no(tls *libc.TLS, out uintptr, p uintptr, e uintptr, sign int32) {
	var val int32
	var v1 uintptr
	_, _ = val, v1
	/* assert(e <= p + 10); */
	val = 0
	/* overflow impossible for 10 digits ("9..9"), so no needs to check at all */
	for p < e { /* never overflows */
		v1 = p
		p++
		val = val*int32(10) + (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) - int32('0'))
	}
	if sign < 0 {
		val = -val
	}
	*(*int32)(unsafe.Pointer(out)) = val
}

func _Clock_str2wideInt_no(tls *libc.TLS, out uintptr, p uintptr, e uintptr, sign int32) {
	var val TTcl_WideInt
	var v1 uintptr
	_, _ = val, v1
	/* assert(e <= p + 18); */
	val = 0
	/* overflow impossible for 18 digits ("9..9"), so no needs to check at all */
	for p < e { /* never overflows */
		v1 = p
		p++
		val = val*int64(10) + int64(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v1)))-libc.Int32FromUint8('0'))
	}
	if sign < 0 {
		val = -val
	}
	*(*TTcl_WideInt)(unsafe.Pointer(out)) = val
}

/* int & Tcl_WideInt overflows may happens here (expected case) */

func _Clock_str2int(tls *libc.TLS, out uintptr, p uintptr, e uintptr, sign int32) (r int32) {
	var eNO, v1, v2, v3 uintptr
	var prev, prev1, val int32
	_, _, _, _, _, _, _ = eNO, prev, prev1, val, v1, v2, v3
	val = 0
	/* overflow impossible for 10 digits ("9..9"), so no needs to check before */
	eNO = p + uintptr(10)
	if eNO > e {
		eNO = e
	}
	for p < eNO { /* never overflows */
		v1 = p
		p++
		val = val*int32(10) + (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) - int32('0'))
	}
	if sign >= 0 {
		for p < e { /* check for overflow */
			prev = val
			v2 = p
			p++
			val = val*int32(10) + (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) - int32('0'))
			if val/int32(10) < prev {
				return int32(TCL_ERROR)
			}
		}
	} else {
		val = -val
		for p < e { /* check for overflow */
			prev1 = val
			v3 = p
			p++
			val = val*int32(10) - (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) - int32('0'))
			if val/int32(10) > prev1 {
				return int32(TCL_ERROR)
			}
		}
	}
	*(*int32)(unsafe.Pointer(out)) = val
	return TCL_OK
}

func _Clock_str2wideInt(tls *libc.TLS, out uintptr, p uintptr, e uintptr, sign int32) (r int32) {
	var eNO, v1, v2, v3 uintptr
	var prev, prev1, val TTcl_WideInt
	_, _, _, _, _, _, _ = eNO, prev, prev1, val, v1, v2, v3
	val = 0
	/* overflow impossible for 18 digits ("9..9"), so no needs to check before */
	eNO = p + uintptr(18)
	if eNO > e {
		eNO = e
	}
	for p < eNO { /* never overflows */
		v1 = p
		p++
		val = val*int64(10) + int64(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v1)))-libc.Int32FromUint8('0'))
	}
	if sign >= 0 {
		for p < e { /* check for overflow */
			prev = val
			v2 = p
			p++
			val = val*int64(10) + int64(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v2)))-libc.Int32FromUint8('0'))
			if val/int64(10) < prev {
				return int32(TCL_ERROR)
			}
		}
	} else {
		val = -val
		for p < e { /* check for overflow */
			prev1 = val
			v3 = p
			p++
			val = val*int64(10) - int64(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v3)))-libc.Int32FromUint8('0'))
			if val/int64(10) > prev1 {
				return int32(TCL_ERROR)
			}
		}
	}
	*(*TTcl_WideInt)(unsafe.Pointer(out)) = val
	return TCL_OK
}

func XTclAtoWIe(tls *libc.TLS, out uintptr, p uintptr, e uintptr, sign int32) (r int32) {
	return _Clock_str2wideInt(tls, out, p, e, sign)
}

/*
 *----------------------------------------------------------------------
 *
 * Clock_itoaw, Clock_witoaw --
 *
 *	Fast inline-convertion of signed int or wide int to string, using
 *	given padding with specified padchar and width (or without padding).
 *
 *	This is a very fast replacement for sprintf("%02d").
 *
 * Results:
 *	Returns position in buffer after end of conversion result.
 *
 *----------------------------------------------------------------------
 */

func _Clock_itoaw(tls *libc.TLS, buf uintptr, val int32, padchar uint8, width uint16) (r uintptr) {
	var c, c1, c2 uint8
	var p, v1, v2, v3, v4, v5, v6, v7, v8 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _ = c, c1, c2, p, v1, v2, v3, v4, v5, v6, v7, v8
	/* positive integer */
	if val >= 0 {
		/* check resp. recalculate width */
		for libc.Int32FromUint16(width) <= int32(9) && val >= _wrange[width] {
			width++
		}
		/* number to string backwards */
		p = buf + uintptr(width)
		v1 = p
		p--
		*(*uint8)(unsafe.Pointer(v1)) = uint8('\000')
		for cond := true; cond; cond = val > 0 {
			c = libc.Uint8FromInt32(val % int32(10))
			val /= int32(10)
			v2 = p
			p--
			*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32('0') + libc.Int32FromUint8(c))
		}
		/* filling with pad-char */
		for p >= buf {
			v3 = p
			p--
			*(*uint8)(unsafe.Pointer(v3)) = padchar
		}
		return buf + uintptr(width)
	}
	/* negative integer */
	if !(width != 0) {
		width++
	}
	/* check resp. recalculate width (regarding sign) */
	width--
	for libc.Int32FromUint16(width) <= int32(9) && val <= -_wrange[width] {
		width++
	}
	width++
	/* number to string backwards */
	p = buf + uintptr(width)
	v4 = p
	p--
	*(*uint8)(unsafe.Pointer(v4)) = uint8('\000')
	/* differentiate platforms with -1 % 10 == 1 and -1 % 10 == -1 */
	if -libc.Int32FromInt32(1)%libc.Int32FromInt32(10) == -int32(1) {
		for cond := true; cond; cond = val < 0 {
			c1 = libc.Uint8FromInt32(val % int32(10))
			val /= int32(10)
			v5 = p
			p--
			*(*uint8)(unsafe.Pointer(v5)) = libc.Uint8FromInt32(int32('0') - libc.Int32FromUint8(c1))
		}
	} else {
		for cond := true; cond; cond = val < 0 {
			c2 = libc.Uint8FromInt32(val % int32(10))
			val /= int32(10)
			v6 = p
			p--
			*(*uint8)(unsafe.Pointer(v6)) = libc.Uint8FromInt32(int32('0') + libc.Int32FromUint8(c2))
		}
	}
	/* sign by 0 padding */
	if libc.Int32FromUint8(padchar) != int32('0') {
		v7 = p
		p--
		*(*uint8)(unsafe.Pointer(v7)) = uint8('-')
	}
	/* filling with pad-char */
	for p >= buf+uintptr(1) {
		v8 = p
		p--
		*(*uint8)(unsafe.Pointer(v8)) = padchar
	}
	/* sign by non 0 padding */
	if libc.Int32FromUint8(padchar) == int32('0') {
		*(*uint8)(unsafe.Pointer(p)) = uint8('-')
	}
	return buf + uintptr(width)
}

var _wrange = [10]int32{
	0: int32(1),
	1: int32(10),
	2: int32(100),
	3: int32(1000),
	4: int32(10000),
	5: int32(100000),
	6: int32(1000000),
	7: int32(10000000),
	8: int32(100000000),
	9: int32(1000000000),
}

func XTclItoAw(tls *libc.TLS, buf uintptr, val int32, padchar uint8, width uint16) (r uintptr) {
	return _Clock_itoaw(tls, buf, val, padchar, width)
}

func _Clock_witoaw(tls *libc.TLS, buf uintptr, val TTcl_WideInt, padchar uint8, width uint16) (r uintptr) {
	var c, c1, c2 uint8
	var p, v1, v2, v3, v4, v5, v6, v7, v8 uintptr
	var val2, val21 TTcl_WideInt
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, c1, c2, p, val2, val21, v1, v2, v3, v4, v5, v6, v7, v8
	/* positive integer */
	if val >= 0 {
		/* check resp. recalculate width */
		if val >= int64(10000000000) {
			val2 = val / int64(10000000000)
			for libc.Int32FromUint16(width) <= int32(9) && val2 >= int64(_wrange1[width]) {
				width++
			}
			width = uint16(int32(width) + libc.Int32FromInt32(10))
		} else {
			for libc.Int32FromUint16(width) <= int32(9) && val >= int64(_wrange1[width]) {
				width++
			}
		}
		/* number to string backwards */
		p = buf + uintptr(width)
		v1 = p
		p--
		*(*uint8)(unsafe.Pointer(v1)) = uint8('\000')
		for cond := true; cond; cond = val > 0 {
			c = libc.Uint8FromInt64(val % libc.Int64FromInt32(10))
			val /= int64(10)
			v2 = p
			p--
			*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32('0') + libc.Int32FromUint8(c))
		}
		/* filling with pad-char */
		for p >= buf {
			v3 = p
			p--
			*(*uint8)(unsafe.Pointer(v3)) = padchar
		}
		return buf + uintptr(width)
	}
	/* negative integer */
	if !(width != 0) {
		width++
	}
	/* check resp. recalculate width (regarding sign) */
	width--
	if val <= -int64(10000000000) {
		val21 = val / int64(10000000000)
		for libc.Int32FromUint16(width) <= int32(9) && val21 <= int64(-_wrange1[width]) {
			width++
		}
		width = uint16(int32(width) + libc.Int32FromInt32(10))
	} else {
		for libc.Int32FromUint16(width) <= int32(9) && val <= int64(-_wrange1[width]) {
			width++
		}
	}
	width++
	/* number to string backwards */
	p = buf + uintptr(width)
	v4 = p
	p--
	*(*uint8)(unsafe.Pointer(v4)) = uint8('\000')
	/* differentiate platforms with -1 % 10 == 1 and -1 % 10 == -1 */
	if -libc.Int32FromInt32(1)%libc.Int32FromInt32(10) == -int32(1) {
		for cond := true; cond; cond = val < 0 {
			c1 = libc.Uint8FromInt64(val % int64(10))
			val /= int64(10)
			v5 = p
			p--
			*(*uint8)(unsafe.Pointer(v5)) = libc.Uint8FromInt32(int32('0') - libc.Int32FromUint8(c1))
		}
	} else {
		for cond := true; cond; cond = val < 0 {
			c2 = libc.Uint8FromInt64(val % int64(10))
			val /= int64(10)
			v6 = p
			p--
			*(*uint8)(unsafe.Pointer(v6)) = libc.Uint8FromInt32(int32('0') + libc.Int32FromUint8(c2))
		}
	}
	/* sign by 0 padding */
	if libc.Int32FromUint8(padchar) != int32('0') {
		v7 = p
		p--
		*(*uint8)(unsafe.Pointer(v7)) = uint8('-')
	}
	/* filling with pad-char */
	for p >= buf+uintptr(1) {
		v8 = p
		p--
		*(*uint8)(unsafe.Pointer(v8)) = padchar
	}
	/* sign by non 0 padding */
	if libc.Int32FromUint8(padchar) == int32('0') {
		*(*uint8)(unsafe.Pointer(p)) = uint8('-')
	}
	return buf + uintptr(width)
}

var _wrange1 = [10]int32{
	0: int32(1),
	1: int32(10),
	2: int32(100),
	3: int32(1000),
	4: int32(10000),
	5: int32(100000),
	6: int32(1000000),
	7: int32(10000000),
	8: int32(100000000),
	9: int32(1000000000),
}

/*
 * Global GC as LIFO for released scan/format object storages.
 *
 * Used to holds last released CLOCK_FMT_SCN_STORAGE_GC_SIZE formats
 * (after last reference from Tcl-object will be removed). This is helpful
 * to avoid continuous (re)creation and compiling by some dynamically resp.
 * variable format objects, that could be often reused.
 *
 * As long as format storage is used resp. belongs to GC, it takes place in
 * FmtScnHashTable also.
 */

type TClockFmtScnStorage_GC = struct {
	FstackPtr   uintptr
	FstackBound uintptr
	Fcount      uint32
}

/*
 * Global GC as LIFO for released scan/format object storages.
 *
 * Used to holds last released CLOCK_FMT_SCN_STORAGE_GC_SIZE formats
 * (after last reference from Tcl-object will be removed). This is helpful
 * to avoid continuous (re)creation and compiling by some dynamically resp.
 * variable format objects, that could be often reused.
 *
 * As long as format storage is used resp. belongs to GC, it takes place in
 * FmtScnHashTable also.
 */

var _ClockFmtScnStorage_GC = TClockFmtScnStorage_GC{}

/*
 *----------------------------------------------------------------------
 *
 * ClockFmtScnStorageGC_In --
 *
 *	Adds an format storage object to GC.
 *
 *	If current GC is full (size larger as CLOCK_FMT_SCN_STORAGE_GC_SIZE)
 *	this removes last unused storage at begin of GC stack (LIFO).
 *
 *	Assumes caller holds the ClockFmtMutex.
 *
 * Results:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _ClockFmtScnStorageGC_In(tls *libc.TLS, entry uintptr) {
	var delEnt, v1 uintptr
	_, _ = delEnt, v1
	/* add new entry */
	(*TClockFmtScnStorage)(unsafe.Pointer(entry)).FnextPtr = _ClockFmtScnStorage_GC.FstackPtr
	if _ClockFmtScnStorage_GC.FstackPtr != libc.UintptrFromInt32(0) {
		(*TClockFmtScnStorage)(unsafe.Pointer(_ClockFmtScnStorage_GC.FstackPtr)).FprevPtr = entry
	}
	(*TClockFmtScnStorage)(unsafe.Pointer(entry)).FprevPtr = libc.UintptrFromInt32(0)
	_ClockFmtScnStorage_GC.FstackPtr = entry
	if _ClockFmtScnStorage_GC.FstackBound == libc.UintptrFromInt32(0) {
		_ClockFmtScnStorage_GC.FstackBound = entry
	}
	_ClockFmtScnStorage_GC.Fcount++
	/* if GC ist full */
	if _ClockFmtScnStorage_GC.Fcount > uint32(CLOCK_FMT_SCN_STORAGE_GC_SIZE) {
		/* GC stack is LIFO: delete first inserted entry */
		delEnt = _ClockFmtScnStorage_GC.FstackBound
		_ClockFmtScnStorage_GC.FstackBound = (*TClockFmtScnStorage)(unsafe.Pointer(delEnt)).FprevPtr
		if (*TClockFmtScnStorage)(unsafe.Pointer(delEnt)).FprevPtr != libc.UintptrFromInt32(0) {
			(*TClockFmtScnStorage)(unsafe.Pointer((*TClockFmtScnStorage)(unsafe.Pointer(delEnt)).FprevPtr)).FnextPtr = (*TClockFmtScnStorage)(unsafe.Pointer(delEnt)).FnextPtr
		} else {
			_ClockFmtScnStorage_GC.FstackPtr = (*TClockFmtScnStorage)(unsafe.Pointer(delEnt)).FnextPtr
		}
		if (*TClockFmtScnStorage)(unsafe.Pointer(delEnt)).FnextPtr != libc.UintptrFromInt32(0) {
			(*TClockFmtScnStorage)(unsafe.Pointer((*TClockFmtScnStorage)(unsafe.Pointer(delEnt)).FnextPtr)).FprevPtr = (*TClockFmtScnStorage)(unsafe.Pointer(delEnt)).FprevPtr
		}
		_ClockFmtScnStorage_GC.Fcount--
		v1 = libc.UintptrFromInt32(0)
		(*TClockFmtScnStorage)(unsafe.Pointer(delEnt)).FnextPtr = v1
		(*TClockFmtScnStorage)(unsafe.Pointer(delEnt)).FprevPtr = v1
		/* remove it now */
		_ClockFmtScnStorageDelete(tls, delEnt)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * ClockFmtScnStorage_GC_Out --
 *
 *	Restores (for reusing) given format storage object from GC.
 *
 *	Assumes caller holds the ClockFmtMutex.
 *
 * Results:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _ClockFmtScnStorage_GC_Out(tls *libc.TLS, entry uintptr) {
	var v1 uintptr
	_ = v1
	if (*TClockFmtScnStorage)(unsafe.Pointer(entry)).FprevPtr != libc.UintptrFromInt32(0) {
		(*TClockFmtScnStorage)(unsafe.Pointer((*TClockFmtScnStorage)(unsafe.Pointer(entry)).FprevPtr)).FnextPtr = (*TClockFmtScnStorage)(unsafe.Pointer(entry)).FnextPtr
	} else {
		_ClockFmtScnStorage_GC.FstackPtr = (*TClockFmtScnStorage)(unsafe.Pointer(entry)).FnextPtr
	}
	if (*TClockFmtScnStorage)(unsafe.Pointer(entry)).FnextPtr != libc.UintptrFromInt32(0) {
		(*TClockFmtScnStorage)(unsafe.Pointer((*TClockFmtScnStorage)(unsafe.Pointer(entry)).FnextPtr)).FprevPtr = (*TClockFmtScnStorage)(unsafe.Pointer(entry)).FprevPtr
	}
	_ClockFmtScnStorage_GC.Fcount--
	if _ClockFmtScnStorage_GC.FstackBound == entry {
		_ClockFmtScnStorage_GC.FstackBound = (*TClockFmtScnStorage)(unsafe.Pointer(entry)).FprevPtr
	}
	v1 = libc.UintptrFromInt32(0)
	(*TClockFmtScnStorage)(unsafe.Pointer(entry)).FnextPtr = v1
	(*TClockFmtScnStorage)(unsafe.Pointer(entry)).FprevPtr = v1
}

// C documentation
//
//	/*
//	 * Global format storage hash table of type ClockFmtScnStorageHashKeyType
//	 * (contains list of scan/format object storages, shared across all threads).
//	 *
//	 * Used for fast searching by format string.
//	 */
var _FmtScnHashTable TTcl_HashTable
var _initialized1 = int32(0)

// C documentation
//
//	/*
//	 * Wrappers between pointers to hash entry and format storage object
//	 */
func _HashEntry4FmtScn(tls *libc.TLS, fss uintptr) (r uintptr) {
	return fss + libc.UintptrFromInt32(1)*64
}

func _FmtScn4HashEntry(tls *libc.TLS, hKeyPtr uintptr) (r uintptr) {
	return hKeyPtr - libc.UintptrFromInt64(64)
}

/*
 *----------------------------------------------------------------------
 *
 * ClockFmtScnStorageAllocProc --
 *
 *	Allocate space for a hash entry containing format storage together
 *	with the string key.
 *
 * Results:
 *	The return value is a pointer to the created entry.
 *
 *----------------------------------------------------------------------
 */

func _ClockFmtScnStorageAllocProc(tls *libc.TLS, dummy554 uintptr, keyPtr uintptr) (r uintptr) {
	/* Key to store in the hash table entry. */
	var allocsize, size uint32
	var fss, hPtr, string1 uintptr
	_, _, _, _, _ = allocsize, fss, hPtr, size, string1
	string1 = keyPtr
	size = uint32(libc.Xstrlen(tls, string1) + uint64(1))
	allocsize = uint32(libc.Uint64FromInt64(64) + libc.Uint64FromInt64(40))
	allocsize += size
	if uint64(size) > uint64(8) {
		allocsize = uint32(uint64(allocsize) - libc.Uint64FromInt64(8))
	}
	fss = XTcl_Alloc(tls, uint64(allocsize))
	/* initialize */
	libc.Xmemset(tls, fss, 0, uint64(64))
	hPtr = _HashEntry4FmtScn(tls, fss)
	libc.Xmemcpy(tls, hPtr+32, string1, uint64(size))
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = uintptr(0) /* currently unused */
	return hPtr
}

/*
 *----------------------------------------------------------------------
 *
 * ClockFmtScnStorageFreeProc --
 *
 *	Free format storage object and space of given hash entry.
 *
 * Results:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _ClockFmtScnStorageFreeProc(tls *libc.TLS, hPtr uintptr) {
	var fss uintptr
	_ = fss
	fss = _FmtScn4HashEntry(tls, hPtr)
	if (*TClockFmtScnStorage)(unsafe.Pointer(fss)).FscnTok != libc.UintptrFromInt32(0) {
		XTclpFree(tls, (*TClockFmtScnStorage)(unsafe.Pointer(fss)).FscnTok)
		(*TClockFmtScnStorage)(unsafe.Pointer(fss)).FscnTok = libc.UintptrFromInt32(0)
		(*TClockFmtScnStorage)(unsafe.Pointer(fss)).FscnTokC = uint32(0)
	}
	if (*TClockFmtScnStorage)(unsafe.Pointer(fss)).FfmtTok != libc.UintptrFromInt32(0) {
		XTclpFree(tls, (*TClockFmtScnStorage)(unsafe.Pointer(fss)).FfmtTok)
		(*TClockFmtScnStorage)(unsafe.Pointer(fss)).FfmtTok = libc.UintptrFromInt32(0)
		(*TClockFmtScnStorage)(unsafe.Pointer(fss)).FfmtTokC = uint32(0)
	}
	XTclpFree(tls, fss)
}

/*
 *----------------------------------------------------------------------
 *
 * ClockFmtScnStorageDelete --
 *
 *	Delete format storage object.
 *
 * Results:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _ClockFmtScnStorageDelete(tls *libc.TLS, fss uintptr) {
	var hPtr uintptr
	_ = hPtr
	hPtr = _HashEntry4FmtScn(tls, fss)
	/*
	 * This will delete a hash entry and call "Tcl_Free" for storage self, if
	 * some additionally handling required, freeEntryProc can be used instead
	 */
	XTcl_DeleteHashEntry(tls, hPtr)
}

/*
 * Type definition of clock-format tcl object type.
 */

var _ClockFmtObjType = TTcl_ObjType{
	Fname: __ccgo_ts + 14535,
}

func init() {
	p := unsafe.Pointer(&_ClockFmtObjType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_ClockFmtObj_FreeInternalRep)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_ClockFmtObj_DupInternalRep)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_ClockFmtObj_UpdateString)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_ClockFmtObj_SetFromAny)
}

func _ClockFmtObj_DupInternalRep(tls *libc.TLS, srcPtr uintptr, copyPtr uintptr) {
	var fss uintptr
	_ = fss
	fss = *(*uintptr)(unsafe.Pointer(srcPtr + 32))
	if fss != libc.UintptrFromInt32(0) {
		XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_ClockFmtMutex)))
		(*TClockFmtScnStorage)(unsafe.Pointer(fss)).FobjRefCount++
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_ClockFmtMutex)))
	}
	*(*uintptr)(unsafe.Pointer(copyPtr + 32)) = fss
	/* regards special case - format not localizable */
	if *(*uintptr)(unsafe.Pointer(srcPtr + 32 + 8)) != srcPtr {
		*(*uintptr)(unsafe.Pointer(copyPtr + 32 + 8)) = *(*uintptr)(unsafe.Pointer(srcPtr + 32 + 8))
		if *(*uintptr)(unsafe.Pointer(copyPtr + 32 + 8)) != 0 {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(copyPtr + 32 + 8)))).FrefCount++
		}
	} else {
		*(*uintptr)(unsafe.Pointer(copyPtr + 32 + 8)) = copyPtr
	}
	(*TTcl_Obj)(unsafe.Pointer(copyPtr)).FtypePtr = uintptr(unsafe.Pointer(&_ClockFmtObjType))
	/* if no format representation, dup string representation */
	if fss == libc.UintptrFromInt32(0) {
		(*TTcl_Obj)(unsafe.Pointer(copyPtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64((*TTcl_Obj)(unsafe.Pointer(srcPtr)).Flength+int64(1)))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(copyPtr)).Fbytes, (*TTcl_Obj)(unsafe.Pointer(srcPtr)).Fbytes, libc.Uint64FromInt64((*TTcl_Obj)(unsafe.Pointer(srcPtr)).Flength+int64(1)))
		(*TTcl_Obj)(unsafe.Pointer(copyPtr)).Flength = (*TTcl_Obj)(unsafe.Pointer(srcPtr)).Flength
	}
}

func _ClockFmtObj_FreeInternalRep(tls *libc.TLS, objPtr uintptr) {
	var _objPtr, fss, v2, v4 uintptr
	var v1 int32
	var v3 TTcl_Size
	_, _, _, _, _, _ = _objPtr, fss, v1, v2, v3, v4
	fss = *(*uintptr)(unsafe.Pointer(objPtr + 32))
	if fss != libc.UintptrFromInt32(0) && _initialized1 != 0 {
		XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_ClockFmtMutex)))
		/* decrement object reference count of format/scan storage */
		v2 = fss
		*(*int32)(unsafe.Pointer(v2))--
		v1 = *(*int32)(unsafe.Pointer(v2))
		if v1 <= 0 {
			/* don't remove it right now (may be reusable), just add to GC */
			_ClockFmtScnStorageGC_In(tls, fss)
		}
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_ClockFmtMutex)))
	}
	*(*uintptr)(unsafe.Pointer(objPtr + 32)) = libc.UintptrFromInt32(0)
	if *(*uintptr)(unsafe.Pointer(objPtr + 32 + 8)) != objPtr {
		if *(*uintptr)(unsafe.Pointer(objPtr + 32 + 8)) != libc.UintptrFromInt32(0) {
			_objPtr = *(*uintptr)(unsafe.Pointer(objPtr + 32 + 8))
			v4 = _objPtr
			v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
			*(*TTcl_Size)(unsafe.Pointer(v4))--
			if v3 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			*(*uintptr)(unsafe.Pointer(objPtr + 32 + 8)) = libc.UintptrFromInt32(0)
		}
	} else {
		*(*uintptr)(unsafe.Pointer(objPtr + 32 + 8)) = libc.UintptrFromInt32(0)
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
}

func _ClockFmtObj_SetFromAny(tls *libc.TLS, dummy717 uintptr, objPtr uintptr) (r int32) {
	/* validate string representation before free old internal representation */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		_ = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
	}
	/* free old internal representation */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != libc.UintptrFromInt32(0) {
		if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc})))(tls, objPtr)
		}
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	}
	/* initial state of format object */
	*(*uintptr)(unsafe.Pointer(objPtr + 32)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(objPtr + 32 + 8)) = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = uintptr(unsafe.Pointer(&_ClockFmtObjType))
	return TCL_OK
}

func _ClockFmtObj_UpdateString(tls *libc.TLS, objPtr uintptr) {
	var fss, hPtr, name uintptr
	var len1, v1 Tsize_t
	_, _, _, _, _ = fss, hPtr, len1, name, v1
	name = __ccgo_ts + 2095
	fss = *(*uintptr)(unsafe.Pointer(objPtr + 32))
	if fss != libc.UintptrFromInt32(0) {
		hPtr = _HashEntry4FmtScn(tls, fss)
		name = hPtr + 32
	}
	len1 = libc.Xstrlen(tls, name)
	v1 = len1
	len1++
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = libc.Int64FromUint64(v1)
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = XTclpAlloc(tls, len1)
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, name, len1)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * ClockFrmObjGetLocFmtKey --
 *
 *	Retrieves format key object used to search localized format.
 *
 *	This is normally stored in second pointer of internal representation.
 *	If format object is not localizable, it is equal the given format
 *	pointer (special case to fast fallback by not-localizable formats).
 *
 * Results:
 *	Returns tcl object with key or format object if not localizable.
 *
 * Side effects:
 *	Converts given format object to ClockFmtObjType on demand for caching
 *	the key inside its internal representation.
 *
 *----------------------------------------------------------------------
 */

func XClockFrmObjGetLocFmtKey(tls *libc.TLS, interp uintptr, objPtr uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var keyObj, v1 uintptr
	_, _ = keyObj, v1
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != uintptr(unsafe.Pointer(&_ClockFmtObjType)) {
		if _ClockFmtObj_SetFromAny(tls, interp, objPtr) != TCL_OK {
			return libc.UintptrFromInt32(0)
		}
	}
	keyObj = *(*uintptr)(unsafe.Pointer(objPtr + 32 + 8))
	if keyObj != 0 {
		return keyObj
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
	}
	keyObj = XTcl_ObjPrintf(tls, __ccgo_ts+14548, libc.VaList(bp+8, v1))
	*(*uintptr)(unsafe.Pointer(objPtr + 32 + 8)) = keyObj
	if *(*uintptr)(unsafe.Pointer(objPtr + 32 + 8)) != 0 {
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objPtr + 32 + 8)))).FrefCount++
	}
	return keyObj
}

/*
 *----------------------------------------------------------------------
 *
 * FindOrCreateFmtScnStorage --
 *
 *	Retrieves format storage for given string format.
 *
 *	This will find the given format in the global storage hash table
 *	or create a format storage object on demaind and save the
 *	reference in the first pointer of internal representation of given
 *	object.
 *
 * Results:
 *	Returns scan/format storage pointer to ClockFmtScnStorage.
 *
 * Side effects:
 *	Converts given format object to ClockFmtObjType on demand for caching
 *	the format storage reference inside its internal representation.
 *	Increments objRefCount of the ClockFmtScnStorage reference.
 *
 *----------------------------------------------------------------------
 */

func _FindOrCreateFmtScnStorage(tls *libc.TLS, interp uintptr, objPtr uintptr) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var fss, hPtr, strFmt, v1, v2 uintptr
	var _ /* isNew at bp+0 */ int32
	_, _, _, _, _ = fss, hPtr, strFmt, v1, v2
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
	}
	strFmt = v1
	fss = libc.UintptrFromInt32(0)
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_ClockFmtMutex)))
	/* if not yet initialized */
	if !(_initialized1 != 0) {
		/* initialize hash table */
		XTcl_InitCustomHashTable(tls, uintptr(unsafe.Pointer(&_FmtScnHashTable)), -int32(2), uintptr(unsafe.Pointer(&_ClockFmtScnStorageHashKeyType)))
		_initialized1 = int32(1)
	}
	/* get or create entry (and alocate storage) */
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_FmtScnHashTable)))).FcreateProc})))(tls, uintptr(unsafe.Pointer(&_FmtScnHashTable)), strFmt, bp)
	if hPtr != libc.UintptrFromInt32(0) {
		fss = _FmtScn4HashEntry(tls, hPtr)
		/* unlink if it is currently in GC */
		if *(*int32)(unsafe.Pointer(bp)) == 0 && (*TClockFmtScnStorage)(unsafe.Pointer(fss)).FobjRefCount == 0 {
			_ClockFmtScnStorage_GC_Out(tls, fss)
		}
		/* new reference, so increment in lock right now */
		(*TClockFmtScnStorage)(unsafe.Pointer(fss)).FobjRefCount++
		*(*uintptr)(unsafe.Pointer(objPtr + 32)) = fss
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_ClockFmtMutex)))
	if fss == libc.UintptrFromInt32(0) && interp != libc.UintptrFromInt32(0) {
		if strFmt != 0 {
			v2 = strFmt
		} else {
			v2 = __ccgo_ts + 1945
		}
		XTcl_AppendResult(tls, interp, libc.VaList(bp+16, __ccgo_ts+14555, v2, __ccgo_ts+14586, libc.UintptrFromInt32(0)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+14588, libc.UintptrFromInt32(0)))
	}
	return fss
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetClockFrmScnFromObj --
 *
 *	Returns a clock format/scan representation of (*objPtr), if possible.
 *	If something goes wrong, NULL is returned, and if interp is non-NULL,
 *	an error message is written there.
 *
 * Results:
 *	Valid representation of type ClockFmtScnStorage.
 *
 * Side effects:
 *	Caches the ClockFmtScnStorage reference as the internal rep of (*objPtr)
 *	and in global hash table, shared across all threads.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetClockFrmScnFromObj(tls *libc.TLS, interp uintptr, objPtr uintptr) (r uintptr) {
	var fss uintptr
	_ = fss
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != uintptr(unsafe.Pointer(&_ClockFmtObjType)) {
		if _ClockFmtObj_SetFromAny(tls, interp, objPtr) != TCL_OK {
			return libc.UintptrFromInt32(0)
		}
	}
	fss = *(*uintptr)(unsafe.Pointer(objPtr + 32))
	if fss == libc.UintptrFromInt32(0) {
		fss = _FindOrCreateFmtScnStorage(tls, interp, objPtr)
	}
	return fss
}

/*
 *----------------------------------------------------------------------
 *
 * ClockLocalizeFormat --
 *
 *	Wrap the format object in options to the localized format,
 *	corresponding given locale.
 *
 *	This searches localized format in locale catalog, and if not yet
 *	exists, it executes ::tcl::clock::LocalizeFormat in given interpreter
 *	and caches its result in the locale catalog.
 *
 * Results:
 *	Localized format object.
 *
 * Side effects:
 *	Caches the localized format inside locale catalog.
 *
 *----------------------------------------------------------------------
 */

func XClockLocalizeFormat(tls *libc.TLS, opts uintptr) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var _objPtr, _objPtr1, dataPtr, keyObj, v2, v4, v5 uintptr
	var v1, v3 TTcl_Size
	var _ /* callargs at bp+8 */ [4]uintptr
	var _ /* valObj at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, dataPtr, keyObj, v1, v2, v3, v4, v5
	dataPtr = (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FdataPtr
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	keyObj = XClockFrmObjGetLocFmtKey(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FformatObj)
	/* special case - format object is not localizable */
	if keyObj == (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FformatObj {
		return (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FformatObj
	}
	/* prevents loss of key object if the format object (where key stored)
	 * becomes changed (loses its internal representation during evals) */
	(*TTcl_Obj)(unsafe.Pointer(keyObj)).FrefCount++
	if (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj == libc.UintptrFromInt32(0) {
		XClockMCDict(tls, opts)
		if (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj == libc.UintptrFromInt32(0) {
			goto done
		}
	}
	/* try to find in cache within locale mc-catalog */
	if XTcl_DictObjGet(tls, libc.UintptrFromInt32(0), (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj, keyObj, bp) != TCL_OK {
		goto done
	}
	/* call LocalizeFormat locale format fmtkey */
	if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
		(*(*[4]uintptr)(unsafe.Pointer(bp + 8)))[0] = *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).Fliterals + uintptr(LIT_LOCALIZE_FORMAT)*8))
		(*(*[4]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] = (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FlocaleObj
		(*(*[4]uintptr)(unsafe.Pointer(bp + 8)))[int32(2)] = (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FformatObj
		(*(*[4]uintptr)(unsafe.Pointer(bp + 8)))[int32(3)] = (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj
		if XTcl_EvalObjv(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, int64(4), bp+8, 0) == TCL_OK {
			*(*uintptr)(unsafe.Pointer(bp)) = XTcl_GetObjResult(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp)
		}
		/* ensure mcDictObj remains unshared */
		if (*TTcl_Obj)(unsafe.Pointer((*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj)).FrefCount > int64(1) {
			/* smart reference (shared dict as object with no ref-counter) */
			(*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj = XTclDictObjSmartRef(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj)
		}
		if !(*(*uintptr)(unsafe.Pointer(bp)) != 0) {
			goto done
		}
		/* cache it inside mc-dictionary (this incr. ref count of keyObj/valObj) */
		if XTcl_DictObjPut(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FmcDictObj, keyObj, *(*uintptr)(unsafe.Pointer(bp))) != TCL_OK {
			*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
			goto done
		}
		XTcl_ResetResult(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp)
		/* check special case - format object is not localizable */
		if *(*uintptr)(unsafe.Pointer(bp)) == (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FformatObj {
			/* mark it as unlocalizable, by setting self as key (without refcount incr) */
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr == uintptr(unsafe.Pointer(&_ClockFmtObjType)) {
				if *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32 + 8)) != libc.UintptrFromInt32(0) {
					_objPtr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32 + 8))
					v2 = _objPtr
					v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
					*(*TTcl_Size)(unsafe.Pointer(v2))--
					if v1 <= int64(1) {
						XTclFreeObj(tls, _objPtr)
					}
					*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32 + 8)) = libc.UintptrFromInt32(0)
				}
				*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32 + 8)) = *(*uintptr)(unsafe.Pointer(bp))
			}
		}
	}
	goto done
done:
	;
	if keyObj != libc.UintptrFromInt32(0) {
		_objPtr1 = keyObj
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		keyObj = libc.UintptrFromInt32(0)
	}
	v5 = *(*uintptr)(unsafe.Pointer(bp))
	(*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FformatObj = v5
	return v5
}

/*
 *----------------------------------------------------------------------
 *
 * FindTokenBegin --
 *
 *	Find begin of given scan token in string, corresponding token type.
 *
 * Results:
 *	Position of token inside string if found. Otherwise - end of string.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _FindTokenBegin(tls *libc.TLS, p uintptr, end uintptr, tok uintptr, flags int32) (r uintptr) {
	var c uint8
	var v10, v12, v14, v21, v25, v27, v29 bool
	var v11, v13, v20, v26, v28 uintptr
	var v17, v18, v22, v23, v7, v8 int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, v10, v11, v12, v13, v14, v17, v18, v20, v21, v22, v23, v25, v26, v27, v28, v29, v7, v8
	if p < end {
		/* next token a known token type */
		switch libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer((*TClockScanToken)(unsafe.Pointer(tok)).Fmap1)).Ftype1) {
		case int32(CTOKT_WIDE):
			goto _1
		case int32(CTOKT_INT):
			goto _2
		case int32(CTOKT_WORD):
			goto _3
		case int32(CTOKT_SPACE):
			goto _4
		case int32(CTOKT_CHAR):
			goto _5
		}
		goto _6
	_2:
		;
	_1:
		;
		if !(flags&int32(CLF_STRICT) != 0) {
			/* should match at least one digit or space */
			for {
				if v10 = !(libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-libc.Uint32FromUint8('0') < libc.Uint32FromInt32(10)) != 0); v10 {
					v7 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))
					v8 = libc.BoolInt32(v7 == int32(' ') || libc.Uint32FromInt32(v7)-uint32('\t') < uint32(5))
					goto _9
				_9:
				}
				if v12 = v10 && !(v8 != 0); v12 {
					v11 = XTcl_UtfNext(tls, p)
					p = v11
				}
				if !(v12 && v11 < end) {
					break
				}
			}
		} else {
			/* should match at least one digit */
			for {
				if v14 = !(libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-libc.Uint32FromUint8('0') < libc.Uint32FromInt32(10)) != 0); v14 {
					v13 = XTcl_UtfNext(tls, p)
					p = v13
				}
				if !(v14 && v13 < end) {
					break
				}
			}
		}
		return p
	_3:
		;
		c = *(*uint8)(unsafe.Pointer((*TClockScanToken)(unsafe.Pointer(tok)).FtokWord.Fstart))
		goto findChar
	_4:
		;
	_16:
		;
		v17 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))
		v18 = libc.BoolInt32(v17 == int32(' ') || libc.Uint32FromInt32(v17)-uint32('\t') < uint32(5))
		goto _19
	_19:
		;
		if v21 = !(v18 != 0); v21 {
			v20 = XTcl_UtfNext(tls, p)
			p = v20
		}
		if !(v21 && v20 < end) {
			goto _15
		}
		goto _16
	_15:
		;
		return p
	_5:
		;
		c = *(*uint8)(unsafe.Pointer((*TClockScanTokenMap)(unsafe.Pointer((*TClockScanToken)(unsafe.Pointer(tok)).Fmap1)).Fdata))
		goto findChar
	findChar:
		;
		if !(flags&int32(CLF_STRICT) != 0) {
			/* should match the char or space */
			for {
				if v25 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != libc.Int32FromUint8(c); v25 {
					v22 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))
					v23 = libc.BoolInt32(v22 == int32(' ') || libc.Uint32FromInt32(v22)-uint32('\t') < uint32(5))
					goto _24
				_24:
				}
				if v27 = v25 && !(v23 != 0); v27 {
					v26 = XTcl_UtfNext(tls, p)
					p = v26
				}
				if !(v27 && v26 < end) {
					break
				}
			}
		} else {
			/* should match the char */
			for {
				if v29 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != libc.Int32FromUint8(c); v29 {
					v28 = XTcl_UtfNext(tls, p)
					p = v28
				}
				if !(v29 && v28 < end) {
					break
				}
			}
		}
		return p
	_6:
	}
	return p
}

/*
 *----------------------------------------------------------------------
 *
 * DetermineGreedySearchLen --
 *
 *	Determine min/max lengths as exact as possible (speed, greedy match).
 *
 * Results:
 *	None. Lengths are stored in *minLenPtr, *maxLenPtr.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _DetermineGreedySearchLen(tls *libc.TLS, opts uintptr, info uintptr, tok uintptr, minLenPtr uintptr, maxLenPtr uintptr) {
	var end, f, laTok, p uintptr
	var maxLen, minLen int32
	_, _, _, _, _, _ = end, f, laTok, maxLen, minLen, p
	minLen = libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer((*TClockScanToken)(unsafe.Pointer(tok)).Fmap1)).FminSize)
	p = (*TDateInfo)(unsafe.Pointer(info)).FdateInput + uintptr(minLen)
	end = (*TDateInfo)(unsafe.Pointer(info)).FdateEnd
	/* if still tokens available, try to correct minimum length */
	if (*TClockScanToken)(unsafe.Pointer(tok+libc.UintptrFromInt32(1)*32)).Fmap1 != 0 {
		end -= uintptr(libc.Int32FromUint16((*TClockScanToken)(unsafe.Pointer(tok)).FendDistance) + (*TDateInfo)(unsafe.Pointer(info)).FdateSpaceCount)
		/* find position of next known token */
		p = _FindTokenBegin(tls, p, end, tok+uintptr(1)*32, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Fflags)
		if p < end {
			minLen = int32(int64(p) - int64((*TDateInfo)(unsafe.Pointer(info)).FdateInput))
		}
	}
	/* max length to the end regarding distance to end (min-width of following tokens) */
	maxLen = int32(int64(end) - int64((*TDateInfo)(unsafe.Pointer(info)).FdateInput))
	/* several amendments */
	if maxLen > libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer((*TClockScanToken)(unsafe.Pointer(tok)).Fmap1)).FmaxSize) {
		maxLen = libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer((*TClockScanToken)(unsafe.Pointer(tok)).Fmap1)).FmaxSize)
	}
	if minLen < libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer((*TClockScanToken)(unsafe.Pointer(tok)).Fmap1)).FminSize) {
		minLen = libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer((*TClockScanToken)(unsafe.Pointer(tok)).Fmap1)).FminSize)
	}
	if minLen > maxLen {
		maxLen = minLen
	}
	if int64(maxLen) > int64((*TDateInfo)(unsafe.Pointer(info)).FdateEnd)-int64((*TDateInfo)(unsafe.Pointer(info)).FdateInput) {
		maxLen = int32(int64((*TDateInfo)(unsafe.Pointer(info)).FdateEnd) - int64((*TDateInfo)(unsafe.Pointer(info)).FdateInput))
	}
	/* check digits rigth now */
	if libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer((*TClockScanToken)(unsafe.Pointer(tok)).Fmap1)).Ftype1) == int32(CTOKT_INT) || libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer((*TClockScanToken)(unsafe.Pointer(tok)).Fmap1)).Ftype1) == int32(CTOKT_WIDE) {
		p = (*TDateInfo)(unsafe.Pointer(info)).FdateInput
		end = p + uintptr(maxLen)
		if end > (*TDateInfo)(unsafe.Pointer(info)).FdateEnd {
			end = (*TDateInfo)(unsafe.Pointer(info)).FdateEnd
		}
		for libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && p < end {
			p++
		}
		maxLen = int32(int64(p) - int64((*TDateInfo)(unsafe.Pointer(info)).FdateInput))
	}
	/* try to get max length more precise for greedy match,
	 * check the next ahead token available there */
	if minLen < maxLen && (*TClockScanToken)(unsafe.Pointer(tok)).FlookAhTok != 0 {
		laTok = tok + uintptr((*TClockScanToken)(unsafe.Pointer(tok)).FlookAhTok)*32 + uintptr(1)*32
		p = (*TDateInfo)(unsafe.Pointer(info)).FdateInput + uintptr(maxLen)
		/* regards all possible spaces here (because they are optional) */
		end = p + uintptr((*TClockScanToken)(unsafe.Pointer(tok)).FlookAhMax) + uintptr((*TDateInfo)(unsafe.Pointer(info)).FdateSpaceCount) + uintptr(1)
		if end > (*TDateInfo)(unsafe.Pointer(info)).FdateEnd {
			end = (*TDateInfo)(unsafe.Pointer(info)).FdateEnd
		}
		p += uintptr((*TClockScanToken)(unsafe.Pointer(tok)).FlookAhMin)
		if (*TClockScanToken)(unsafe.Pointer(laTok)).Fmap1 != 0 && p < end {
			/* try to find laTok between [lookAhMin, lookAhMax] */
			for minLen < maxLen {
				f = _FindTokenBegin(tls, p, end, laTok, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Fflags)
				/* if found (not below lookAhMax) */
				if f < end {
					break
				}
				/* try again with fewer length */
				maxLen--
				p--
				end--
			}
		} else {
			if p > end {
				maxLen = int32(int64(maxLen) - (int64(p) - int64(end)))
				if maxLen < minLen {
					maxLen = minLen
				}
			}
		}
	}
	*(*int32)(unsafe.Pointer(minLenPtr)) = minLen
	*(*int32)(unsafe.Pointer(maxLenPtr)) = maxLen
}

/*
 *----------------------------------------------------------------------
 *
 * ObjListSearch --
 *
 *	Find largest part of the input string from start regarding min and
 *	max lengths in the given list (utf-8, case sensitive).
 *
 * Results:
 *	TCL_OK - match found, TCL_RETURN - not matched, TCL_ERROR in error case.
 *
 * Side effects:
 *	Input points to end of the found token in string.
 *
 *----------------------------------------------------------------------
 */

func _ObjListSearch(tls *libc.TLS, info uintptr, val uintptr, lstv uintptr, lstc TTcl_Size, minLen int32, maxLen int32) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var f, ret, s, v10, v2, v3, v4, v5, v6 uintptr
	var i, lf TTcl_Size
	var v12 bool
	var v8, v9 int64
	var _ /* ch1 at bp+0 */ TTcl_UniChar
	var _ /* ch2 at bp+4 */ TTcl_UniChar
	var _ /* l at bp+8 */ TTcl_Size
	var _ /* sf at bp+16 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, lf, ret, s, v10, v12, v2, v3, v4, v5, v6, v8, v9
	lf = int64(-int32(1))
	/* search in list */
	i = 0
	for {
		if !(i < lstc) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(lstv + uintptr(i)*8)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(lstv + uintptr(i)*8)))).Flength
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(lstv + uintptr(i)*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(lstv + uintptr(i)*8)), bp+8)
		}
		s = v2
		if v12 = *(*TTcl_Size)(unsafe.Pointer(bp + 8)) >= int64(minLen); v12 {
			v4 = (*TDateInfo)(unsafe.Pointer(info)).FdateInput
			v5 = s
			ret = v4
			for {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) < int32(0x80) {
					*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v4)))
					v8 = int64(libc.Int32FromInt32(1))
				} else {
					v8 = XTcl_UtfToUniChar(tls, v4, bp)
				}
				v4 += uintptr(v8)
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) < int32(0x80) {
					*(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v5)))
					v9 = int64(libc.Int32FromInt32(1))
				} else {
					v9 = XTcl_UtfToUniChar(tls, v5, bp+4)
				}
				v5 += uintptr(v9)
				if *(*TTcl_UniChar)(unsafe.Pointer(bp)) != *(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) {
					*(*TTcl_UniChar)(unsafe.Pointer(bp)) = XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(bp)))
					*(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) = XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(bp + 4)))
					if *(*TTcl_UniChar)(unsafe.Pointer(bp)) != *(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) {
						break
					}
				}
				*(*uintptr)(unsafe.Pointer(bp + 16)) = v5
				goto _7
			_7:
				;
				v6 = v4
				ret = v6
				if !(v6 < (*TDateInfo)(unsafe.Pointer(info)).FdateInput+uintptr(maxLen) && v5 < s+uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))) {
					break
				}
			}
			v10 = ret
			goto _11
		_11:
			v3 = v10
			f = v3
		}
		if v12 && v3 > (*TDateInfo)(unsafe.Pointer(info)).FdateInput {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = int64(f) - int64((*TDateInfo)(unsafe.Pointer(info)).FdateInput)
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) < int64(minLen) {
				goto _1
			}
			/* found, try to find longest value (greedy search) */
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) < int64(maxLen) && minLen != maxLen {
				lf = i
				minLen = int32(*(*TTcl_Size)(unsafe.Pointer(bp + 8)) + int64(1))
				goto _1
			}
			/* max possible - end of search */
			*(*int32)(unsafe.Pointer(val)) = int32(i)
			*(*uintptr)(unsafe.Pointer(info + 8)) += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
			break
		}
		goto _1
	_1:
		;
		i++
	}
	/* if found */
	if i < lstc {
		return TCL_OK
	}
	if lf >= 0 {
		*(*int32)(unsafe.Pointer(val)) = int32(lf)
		*(*uintptr)(unsafe.Pointer(info + 8)) += uintptr(minLen - int32(1))
		return TCL_OK
	}
	return int32(TCL_RETURN)
}

/*
 *----------------------------------------------------------------------
 *
 * ClockMCGetListIdxTree --
 *
 *	Retrieves localized string indexed tree in the locale catalog for
 *	given literal index mcKey (and builds it on demand).
 *
 *	Searches localized index in locale catalog, and if not yet exists,
 *	creates string indexed tree and stores it in the locale catalog.
 *
 * Results:
 *	Localized string index tree.
 *
 * Side effects:
 *	Caches the localized string index tree inside locale catalog.
 *
 *----------------------------------------------------------------------
 */

func _ClockMCGetListIdxTree(tls *libc.TLS, opts uintptr, mcKey int32) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, idxTree, objPtr, valObj, v1, v3, v8 uintptr
	var v2 bool
	var v4 int32
	var v5, v6 int64
	var v7 TTcl_Size
	var _ /* lstc at bp+8 */ TTcl_Size
	var _ /* lstv at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, idxTree, objPtr, valObj, v1, v2, v3, v4, v5, v6, v7, v8
	objPtr = XClockMCGetIdx(tls, opts, mcKey)
	if v2 = objPtr != libc.UintptrFromInt32(0); v2 {
		v1 = XTclStrIdxTreeGetFromObj(tls, objPtr)
		idxTree = v1
	}
	if v2 && v1 != libc.UintptrFromInt32(0) {
		return idxTree
	} else {
		objPtr = XTclStrIdxTreeNewObj(tls)
		v3 = XTclStrIdxTreeGetFromObj(tls, objPtr)
		idxTree = v3
		if v3 == libc.UintptrFromInt32(0) {
			goto done /* unexpected, but ...*/
		}
		valObj = XClockMCGet(tls, opts, mcKey)
		if valObj == libc.UintptrFromInt32(0) {
			goto done
		}
		if (*TTcl_Obj)(unsafe.Pointer(valObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(valObj + 32))).Fptr2 != 0 {
				v5 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(valObj + 32))).Fptr2)).FspanStart
			} else {
				v5 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(valObj + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(valObj + 32))).Fptr1 + 40 + uintptr(v5)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(valObj + 32))).Fptr2 != 0 {
				v6 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(valObj + 32))).Fptr2)).FspanLength
			} else {
				v6 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(valObj + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v6
			v4 = libc.Int32FromInt32(TCL_OK)
		} else {
			v4 = XTcl_ListObjGetElements(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, valObj, bp+8, bp)
		}
		if v4 != TCL_OK {
			goto done
		}
		if XTclStrIdxTreeBuildFromList(tls, idxTree, *(*TTcl_Size)(unsafe.Pointer(bp + 8)), *(*uintptr)(unsafe.Pointer(bp)), libc.UintptrFromInt32(0)) != TCL_OK {
			goto done
		}
		XClockMCSetIdx(tls, opts, mcKey, objPtr)
		objPtr = libc.UintptrFromInt32(0)
	}
	goto done
done:
	;
	if objPtr != 0 {
		_objPtr = objPtr
		v8 = _objPtr
		v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
		*(*TTcl_Size)(unsafe.Pointer(v8))--
		if v7 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		idxTree = libc.UintptrFromInt32(0)
	}
	return idxTree
}

/*
 *----------------------------------------------------------------------
 *
 * ClockMCGetMultiListIdxTree --
 *
 *	Retrieves localized string indexed tree in the locale catalog for
 *	multiple lists by literal indices mcKeys (and builds it on demand).
 *
 *	Searches localized index in locale catalog for mcKey, and if not
 *	yet exists, creates string indexed tree and stores it in the
 *	locale catalog.
 *
 * Results:
 *	Localized string index tree.
 *
 * Side effects:
 *	Caches the localized string index tree inside locale catalog.
 *
 *----------------------------------------------------------------------
 */

func _ClockMCGetMultiListIdxTree(tls *libc.TLS, opts uintptr, mcKey int32, mcKeys uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, idxTree, objPtr, valObj, v1, v3, v8 uintptr
	var v2 bool
	var v4 int32
	var v5, v6 int64
	var v7 TTcl_Size
	var _ /* lstc at bp+8 */ TTcl_Size
	var _ /* lstv at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, idxTree, objPtr, valObj, v1, v2, v3, v4, v5, v6, v7, v8
	objPtr = XClockMCGetIdx(tls, opts, mcKey)
	if v2 = objPtr != libc.UintptrFromInt32(0); v2 {
		v1 = XTclStrIdxTreeGetFromObj(tls, objPtr)
		idxTree = v1
	}
	if v2 && v1 != libc.UintptrFromInt32(0) {
		return idxTree
	} else {
		objPtr = XTclStrIdxTreeNewObj(tls)
		v3 = XTclStrIdxTreeGetFromObj(tls, objPtr)
		idxTree = v3
		if v3 == libc.UintptrFromInt32(0) {
			goto done /* unexpected, but ...*/
		}
		for *(*int32)(unsafe.Pointer(mcKeys)) != 0 {
			valObj = XClockMCGet(tls, opts, *(*int32)(unsafe.Pointer(mcKeys)))
			if valObj == libc.UintptrFromInt32(0) {
				goto done
			}
			if (*TTcl_Obj)(unsafe.Pointer(valObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(valObj + 32))).Fptr2 != 0 {
					v5 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(valObj + 32))).Fptr2)).FspanStart
				} else {
					v5 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(valObj + 32))).Fptr1)).FfirstUsed
				}
				*(*uintptr)(unsafe.Pointer(bp)) = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(valObj + 32))).Fptr1 + 40 + uintptr(v5)*8
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(valObj + 32))).Fptr2 != 0 {
					v6 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(valObj + 32))).Fptr2)).FspanLength
				} else {
					v6 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(valObj + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v6
				v4 = libc.Int32FromInt32(TCL_OK)
			} else {
				v4 = XTcl_ListObjGetElements(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, valObj, bp+8, bp)
			}
			if v4 != TCL_OK {
				goto done
			}
			if XTclStrIdxTreeBuildFromList(tls, idxTree, *(*TTcl_Size)(unsafe.Pointer(bp + 8)), *(*uintptr)(unsafe.Pointer(bp)), libc.UintptrFromInt32(0)) != TCL_OK {
				goto done
			}
			mcKeys += 4
		}
		XClockMCSetIdx(tls, opts, mcKey, objPtr)
		objPtr = libc.UintptrFromInt32(0)
	}
	goto done
done:
	;
	if objPtr != 0 {
		_objPtr = objPtr
		v8 = _objPtr
		v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
		*(*TTcl_Size)(unsafe.Pointer(v8))--
		if v7 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		idxTree = libc.UintptrFromInt32(0)
	}
	return idxTree
}

/*
 *----------------------------------------------------------------------
 *
 * ClockStrIdxTreeSearch --
 *
 *	Find largest part of the input string from start regarding lengths
 *	in the given localized string indexed tree (utf-8, case sensitive).
 *
 * Results:
 *	TCL_OK - match found and the index stored in *val,
 *	TCL_RETURN - not matched or ambigous,
 *	TCL_ERROR - in error case.
 *
 * Side effects:
 *	Input points to end of the found token in string.
 *
 *----------------------------------------------------------------------
 */

func _ClockStrIdxTreeSearch(tls *libc.TLS, info uintptr, idxTree uintptr, val uintptr, minLen int32, maxLen int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var f uintptr
	var _ /* foundItem at bp+0 */ uintptr
	_ = f
	f = XTclStrIdxTreeSearch(tls, libc.UintptrFromInt32(0), bp, idxTree, (*TDateInfo)(unsafe.Pointer(info)).FdateInput, (*TDateInfo)(unsafe.Pointer(info)).FdateInput+uintptr(maxLen))
	if f <= (*TDateInfo)(unsafe.Pointer(info)).FdateInput || int64(f)-int64((*TDateInfo)(unsafe.Pointer(info)).FdateInput) < int64(minLen) {
		/* not found */
		return int32(TCL_RETURN)
	}
	if !((*TTclStrIdx)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fvalue != 0) {
		/* ambigous */
		return int32(TCL_RETURN)
	}
	*(*int32)(unsafe.Pointer(val)) = int32(int64((*TTclStrIdx)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fvalue))
	/* shift input pointer */
	(*TDateInfo)(unsafe.Pointer(info)).FdateInput = f
	return TCL_OK
}

func _FindWordEnd(tls *libc.TLS, tok uintptr, p uintptr, end uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var ret, x, v1, v2, v3, v4, v8 uintptr
	var v6, v7 int64
	var _ /* ch1 at bp+0 */ TTcl_UniChar
	var _ /* ch2 at bp+4 */ TTcl_UniChar
	var _ /* pfnd at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _ = ret, x, v1, v2, v3, v4, v6, v7, v8
	x = (*TClockScanToken)(unsafe.Pointer(tok)).FtokWord.Fstart
	*(*uintptr)(unsafe.Pointer(bp + 8)) = p
	if x == (*TClockScanToken)(unsafe.Pointer(tok)).FtokWord.Fend-uintptr(1) { /* fast phase-out for single char word */
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(x))) {
			p++
			v1 = p
			return v1
		}
	}
	/* multi-char word */
	v2 = x
	v3 = p
	ret = v2
	for {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v2)))
			v6 = int64(libc.Int32FromInt32(1))
		} else {
			v6 = XTcl_UtfToUniChar(tls, v2, bp)
		}
		v2 += uintptr(v6)
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v3)))
			v7 = int64(libc.Int32FromInt32(1))
		} else {
			v7 = XTcl_UtfToUniChar(tls, v3, bp+4)
		}
		v3 += uintptr(v7)
		if *(*TTcl_UniChar)(unsafe.Pointer(bp)) != *(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp)) = XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(bp)))
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) = XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(bp + 4)))
			if *(*TTcl_UniChar)(unsafe.Pointer(bp)) != *(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) {
				break
			}
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = v3
		goto _5
	_5:
		;
		v4 = v2
		ret = v4
		if !(v4 < (*TClockScanToken)(unsafe.Pointer(tok)).FtokWord.Fend && v3 < end) {
			break
		}
	}
	v8 = ret
	goto _9
_9:
	x = v8
	if x < (*TClockScanToken)(unsafe.Pointer(tok)).FtokWord.Fend {
		/* no match -> error */
		return libc.UintptrFromInt32(0)
	}
	return *(*uintptr)(unsafe.Pointer(bp + 8))
}

func _ClockScnToken_Month_Proc(tls *libc.TLS, opts uintptr, info uintptr, tok uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var idxTree uintptr
	var ret int32
	var _ /* maxLen at bp+8 */ int32
	var _ /* minLen at bp+4 */ int32
	var _ /* val at bp+0 */ int32
	_, _ = idxTree, ret
	_DetermineGreedySearchLen(tls, opts, info, tok, bp+4, bp+8)
	/* get or create tree in msgcat dict */
	idxTree = _ClockMCGetMultiListIdxTree(tls, opts, int32(MCLIT_MONTHS_COMB), uintptr(unsafe.Pointer(&_monthsKeys)))
	if idxTree == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	ret = _ClockStrIdxTreeSearch(tls, info, idxTree, bp, *(*int32)(unsafe.Pointer(bp + 4)), *(*int32)(unsafe.Pointer(bp + 8)))
	if ret != TCL_OK {
		return ret
	}
	(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fmonth = *(*int32)(unsafe.Pointer(bp))
	return TCL_OK
}

var _monthsKeys = [3]int32{
	0: int32(MCLIT_MONTHS_FULL),
	1: int32(MCLIT_MONTHS_ABBREV),
}

func _ClockScnToken_DayOfWeek_Proc(tls *libc.TLS, opts uintptr, info uintptr, tok uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var curTok uint8
	var idxTree uintptr
	var ret int32
	var _ /* maxLen at bp+8 */ int32
	var _ /* minLen at bp+4 */ int32
	var _ /* val at bp+0 */ int32
	_, _, _ = curTok, idxTree, ret
	curTok = *(*uint8)(unsafe.Pointer((*TClockScanToken)(unsafe.Pointer(tok)).FtokWord.Fstart))
	_DetermineGreedySearchLen(tls, opts, info, tok, bp+4, bp+8)
	/* %u %w %Ou %Ow */
	if libc.Int32FromUint8(curTok) != int32('a') && libc.Int32FromUint8(curTok) != int32('A') && (*(*int32)(unsafe.Pointer(bp + 4)) <= int32(1) && *(*int32)(unsafe.Pointer(bp + 8)) >= int32(1) || int64((*TClockScanTokenMap)(unsafe.Pointer((*TClockScanToken)(unsafe.Pointer(tok)).Fmap1)).Fdata) != 0) {
		*(*int32)(unsafe.Pointer(bp)) = -int32(1)
		if int64((*TClockScanTokenMap)(unsafe.Pointer((*TClockScanToken)(unsafe.Pointer(tok)).Fmap1)).Fdata) == 0 {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TDateInfo)(unsafe.Pointer(info)).FdateInput))) >= int32('0') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TDateInfo)(unsafe.Pointer(info)).FdateInput))) <= int32('9') {
				*(*int32)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TDateInfo)(unsafe.Pointer(info)).FdateInput))) - int32('0')
			}
		} else {
			idxTree = _ClockMCGetListIdxTree(tls, opts, int32(int64((*TClockScanTokenMap)(unsafe.Pointer((*TClockScanToken)(unsafe.Pointer(tok)).Fmap1)).Fdata)))
			if idxTree == libc.UintptrFromInt32(0) {
				return int32(TCL_ERROR)
			}
			ret = _ClockStrIdxTreeSearch(tls, info, idxTree, bp, *(*int32)(unsafe.Pointer(bp + 4)), *(*int32)(unsafe.Pointer(bp + 8)))
			if ret != TCL_OK {
				return ret
			}
			*(*int32)(unsafe.Pointer(bp))--
		}
		if *(*int32)(unsafe.Pointer(bp)) == -int32(1) {
			return int32(TCL_RETURN)
		}
		if *(*int32)(unsafe.Pointer(bp)) == 0 {
			*(*int32)(unsafe.Pointer(bp)) = int32(7)
		}
		if *(*int32)(unsafe.Pointer(bp)) > int32(7) {
			XTcl_SetObjResult(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, XTcl_NewStringObj(tls, __ccgo_ts+14595, int64(-libc.Int32FromInt32(1))))
			XTcl_SetErrorCode(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, libc.VaList(bp+24, __ccgo_ts+12666, __ccgo_ts+14625, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfWeek = *(*int32)(unsafe.Pointer(bp))
		(*TDateInfo)(unsafe.Pointer(info)).FdateInput++
		return TCL_OK
	}
	/* %a %A */
	idxTree = _ClockMCGetMultiListIdxTree(tls, opts, int32(MCLIT_DAYS_OF_WEEK_COMB), uintptr(unsafe.Pointer(&_dowKeys)))
	if idxTree == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	ret = _ClockStrIdxTreeSearch(tls, info, idxTree, bp, *(*int32)(unsafe.Pointer(bp + 4)), *(*int32)(unsafe.Pointer(bp + 8)))
	if ret != TCL_OK {
		return ret
	}
	*(*int32)(unsafe.Pointer(bp))--
	if *(*int32)(unsafe.Pointer(bp)) == 0 {
		*(*int32)(unsafe.Pointer(bp)) = int32(7)
	}
	(*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfWeek = *(*int32)(unsafe.Pointer(bp))
	return TCL_OK
}

var _dowKeys = [3]int32{
	0: int32(MCLIT_DAYS_OF_WEEK_ABBREV),
	1: int32(MCLIT_DAYS_OF_WEEK_FULL),
}

func _ClockScnToken_amPmInd_Proc(tls *libc.TLS, opts uintptr, info uintptr, tok uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var ret int32
	var _ /* amPmObj at bp+16 */ [2]uintptr
	var _ /* maxLen at bp+8 */ int32
	var _ /* minLen at bp+4 */ int32
	var _ /* val at bp+0 */ int32
	_ = ret
	_DetermineGreedySearchLen(tls, opts, info, tok, bp+4, bp+8)
	(*(*[2]uintptr)(unsafe.Pointer(bp + 16)))[0] = XClockMCGet(tls, opts, int32(MCLIT_AM))
	(*(*[2]uintptr)(unsafe.Pointer(bp + 16)))[int32(1)] = XClockMCGet(tls, opts, int32(MCLIT_PM))
	if (*(*[2]uintptr)(unsafe.Pointer(bp + 16)))[0] == libc.UintptrFromInt32(0) || (*(*[2]uintptr)(unsafe.Pointer(bp + 16)))[int32(1)] == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	ret = _ObjListSearch(tls, info, bp, bp+16, int64(2), *(*int32)(unsafe.Pointer(bp + 4)), *(*int32)(unsafe.Pointer(bp + 8)))
	if ret != TCL_OK {
		return ret
	}
	if *(*int32)(unsafe.Pointer(bp)) == 0 {
		(*TDateInfo)(unsafe.Pointer(info)).FdateMeridian = int32(MERam)
	} else {
		(*TDateInfo)(unsafe.Pointer(info)).FdateMeridian = int32(MERpm)
	}
	return TCL_OK
}

func _ClockScnToken_LocaleERA_Proc(tls *libc.TLS, opts uintptr, info uintptr, tok uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var dataPtr uintptr
	var ret int32
	var _ /* eraObj at bp+16 */ [6]uintptr
	var _ /* maxLen at bp+8 */ int32
	var _ /* minLen at bp+4 */ int32
	var _ /* val at bp+0 */ int32
	_, _ = dataPtr, ret
	dataPtr = (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FdataPtr
	_DetermineGreedySearchLen(tls, opts, info, tok, bp+4, bp+8)
	(*(*[6]uintptr)(unsafe.Pointer(bp + 16)))[0] = XClockMCGet(tls, opts, int32(MCLIT_BCE))
	(*(*[6]uintptr)(unsafe.Pointer(bp + 16)))[int32(1)] = XClockMCGet(tls, opts, int32(MCLIT_CE))
	(*(*[6]uintptr)(unsafe.Pointer(bp + 16)))[int32(2)] = *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FmcLiterals + uintptr(MCLIT_BCE2)*8))
	(*(*[6]uintptr)(unsafe.Pointer(bp + 16)))[int32(3)] = *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FmcLiterals + uintptr(MCLIT_CE2)*8))
	(*(*[6]uintptr)(unsafe.Pointer(bp + 16)))[int32(4)] = *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FmcLiterals + uintptr(MCLIT_BCE3)*8))
	(*(*[6]uintptr)(unsafe.Pointer(bp + 16)))[int32(5)] = *(*uintptr)(unsafe.Pointer((*TClockClientData)(unsafe.Pointer(dataPtr)).FmcLiterals + uintptr(MCLIT_CE3)*8))
	if (*(*[6]uintptr)(unsafe.Pointer(bp + 16)))[0] == libc.UintptrFromInt32(0) || (*(*[6]uintptr)(unsafe.Pointer(bp + 16)))[int32(1)] == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	ret = _ObjListSearch(tls, info, bp, bp+16, int64(6), *(*int32)(unsafe.Pointer(bp + 4)), *(*int32)(unsafe.Pointer(bp + 8)))
	if ret != TCL_OK {
		return ret
	}
	if *(*int32)(unsafe.Pointer(bp))&int32(1) != 0 {
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FisBce = 0
	} else {
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FisBce = int32(1)
	}
	return TCL_OK
}

func _ClockScnToken_LocaleListMatcher_Proc(tls *libc.TLS, opts uintptr, info uintptr, tok uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var idxTree uintptr
	var ret, v1 int32
	var _ /* maxLen at bp+8 */ int32
	var _ /* minLen at bp+4 */ int32
	var _ /* val at bp+0 */ int32
	_, _, _ = idxTree, ret, v1
	_DetermineGreedySearchLen(tls, opts, info, tok, bp+4, bp+8)
	/* get or create tree in msgcat dict */
	idxTree = _ClockMCGetListIdxTree(tls, opts, int32(int64((*TClockScanTokenMap)(unsafe.Pointer((*TClockScanToken)(unsafe.Pointer(tok)).Fmap1)).Fdata)))
	if idxTree == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	ret = _ClockStrIdxTreeSearch(tls, info, idxTree, bp, *(*int32)(unsafe.Pointer(bp + 4)), *(*int32)(unsafe.Pointer(bp + 8)))
	if ret != TCL_OK {
		return ret
	}
	if libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer((*TClockScanToken)(unsafe.Pointer(tok)).Fmap1)).Foffs) > 0 {
		*(*int32)(unsafe.Pointer(bp))--
		v1 = *(*int32)(unsafe.Pointer(bp))
		*(*int32)(unsafe.Pointer(info + uintptr((*TClockScanTokenMap)(unsafe.Pointer((*TClockScanToken)(unsafe.Pointer(tok)).Fmap1)).Foffs))) = v1
	}
	return TCL_OK
}

func _ClockScnToken_JDN_Proc(tls *libc.TLS, opts uintptr, info uintptr, tok uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var end, p, s, v2 uintptr
	var fractJDDiv, v1 int32
	var v3 bool
	var _ /* fractJD at bp+16 */ int32
	var _ /* intJD at bp+8 */ TTcl_WideInt
	var _ /* maxLen at bp+4 */ int32
	var _ /* minLen at bp+0 */ int32
	_, _, _, _, _, _, _ = end, fractJDDiv, p, s, v1, v2, v3
	p = (*TDateInfo)(unsafe.Pointer(info)).FdateInput
	*(*int32)(unsafe.Pointer(bp + 16)) = 0
	fractJDDiv = int32(1)
	_DetermineGreedySearchLen(tls, opts, info, tok, bp, bp+4)
	end = (*TDateInfo)(unsafe.Pointer(info)).FdateInput + uintptr(*(*int32)(unsafe.Pointer(bp + 4)))
	/* currently positive astronomic dates only */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('+') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') {
		p++
	}
	s = p
	for p < end && libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 {
		p++
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TDateInfo)(unsafe.Pointer(info)).FdateInput))) != int32('-') {
		v1 = int32(1)
	} else {
		v1 = -int32(1)
	}
	if _Clock_str2wideInt(tls, bp+8, s, p, v1) != TCL_OK {
		return int32(TCL_RETURN)
	}
	(*TDateInfo)(unsafe.Pointer(info)).FdateInput = p
	if v3 = p >= end; !v3 {
		v2 = p
		p++
	}
	if v3 || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) != int32('.') { /* allow pure integer JDN */
		/* by astronomical JD the seconds of day offs is 12 hours */
		if (*TClockScanTokenMap)(unsafe.Pointer((*TClockScanToken)(unsafe.Pointer(tok)).Fmap1)).Foffs != 0 {
			goto done
		}
		/* calendar JD */
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FjulianDay = *(*TTcl_WideInt)(unsafe.Pointer(bp + 8))
		return TCL_OK
	}
	s = p
	for p < end && libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 {
		fractJDDiv *= int32(10)
		p++
	}
	if _Clock_str2int(tls, bp+16, s, p, int32(1)) != TCL_OK {
		return int32(TCL_RETURN)
	}
	(*TDateInfo)(unsafe.Pointer(info)).FdateInput = p
	goto done
done:
	;
	/*
	 * Build a date from julian day (integer and fraction).
	 * Note, astronomical JDN starts at noon in opposite to calendar julianday.
	 */
	*(*int32)(unsafe.Pointer(bp + 16)) = libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer((*TClockScanToken)(unsafe.Pointer(tok)).Fmap1)).Foffs) + int32(libc.Int64FromInt32(SECONDS_PER_DAY)*int64(*(*int32)(unsafe.Pointer(bp + 16)))/int64(fractJDDiv))
	if *(*int32)(unsafe.Pointer(bp + 16)) >= int32(SECONDS_PER_DAY) {
		*(*int32)(unsafe.Pointer(bp + 16)) %= int32(SECONDS_PER_DAY)
		*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) += int64(1)
	}
	(*TDateInfo)(unsafe.Pointer(info)).Fdate.FsecondOfDay = int64(*(*int32)(unsafe.Pointer(bp + 16)))
	(*TDateInfo)(unsafe.Pointer(info)).Fdate.FjulianDay = *(*TTcl_WideInt)(unsafe.Pointer(bp + 8))
	(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fseconds = -int64(210866803200) + int64(SECONDS_PER_DAY)**(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) + int64(*(*int32)(unsafe.Pointer(bp + 16)))
	*(*int32)(unsafe.Pointer(info + 136)) |= int32(CLF_POSIXSEC)
	return TCL_OK
}

func _ClockScnToken_TimeZone_Proc(tls *libc.TLS, opts uintptr, info uintptr, tok uintptr) (r int32) {
	bp1 := tls.Alloc(32)
	defer tls.Free(32)
	var _objPtr, bp, p, tzObjStor, v1, v2, v3, v4, v5, v6, v8 uintptr
	var len1 int32
	var v7 TTcl_Size
	var _ /* buf at bp+8 */ [10]uint8
	var _ /* maxLen at bp+4 */ int32
	var _ /* minLen at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, bp, len1, p, tzObjStor, v1, v2, v3, v4, v5, v6, v7, v8
	len1 = 0
	p = (*TDateInfo)(unsafe.Pointer(info)).FdateInput
	tzObjStor = libc.UintptrFromInt32(0)
	_DetermineGreedySearchLen(tls, opts, info, tok, bp1, bp1+4)
	/* numeric timezone */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('+') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') {
		bp = bp1 + 8
		v1 = bp
		bp++
		v2 = p
		p++
		*(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2))
		len1++
		if *(*int32)(unsafe.Pointer(bp1 + 4)) > int32(9) {
			*(*int32)(unsafe.Pointer(bp1 + 4)) = int32(9)
		}
		/* cumulate zone into buf without ':' */
		for len1+int32(1) < *(*int32)(unsafe.Pointer(bp1 + 4)) {
			if !(libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-libc.Uint32FromUint8('0') < libc.Uint32FromInt32(10)) != 0) {
				break
			}
			v3 = bp
			bp++
			v4 = p
			p++
			*(*uint8)(unsafe.Pointer(v3)) = *(*uint8)(unsafe.Pointer(v4))
			len1++
			if !(libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-libc.Uint32FromUint8('0') < libc.Uint32FromInt32(10)) != 0) {
				break
			}
			v5 = bp
			bp++
			v6 = p
			p++
			*(*uint8)(unsafe.Pointer(v5)) = *(*uint8)(unsafe.Pointer(v6))
			len1++
			if len1+int32(2) < *(*int32)(unsafe.Pointer(bp1 + 4)) {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(':') {
					p++
					len1++
				}
			}
		}
		*(*uint8)(unsafe.Pointer(bp)) = uint8('\000')
		if len1 < *(*int32)(unsafe.Pointer(bp1)) {
			return int32(TCL_RETURN)
		}
		/* timezone */
		tzObjStor = XTcl_NewStringObj(tls, bp1+8, int64(bp)-T__predefined_ptrdiff_t(bp1+8))
	} else {
		/* legacy (alnum) timezone like CEST, etc. */
		if *(*int32)(unsafe.Pointer(bp1 + 4)) > int32(4) {
			*(*int32)(unsafe.Pointer(bp1 + 4)) = int32(4)
		}
		for len1 < *(*int32)(unsafe.Pointer(bp1 + 4)) {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))&int32(0x80) != 0 || !(libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))|libc.Uint32FromInt32(32)-libc.Uint32FromUint8('a') < libc.Uint32FromInt32(26)) != 0) && !(libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-libc.Uint32FromUint8('0') < libc.Uint32FromInt32(10)) != 0) { /* INTL: ISO only. */
				break
			}
			p++
			len1++
		}
		if len1 < *(*int32)(unsafe.Pointer(bp1)) {
			return int32(TCL_RETURN)
		}
		/* timezone */
		tzObjStor = XTcl_NewStringObj(tls, (*TDateInfo)(unsafe.Pointer(info)).FdateInput, int64(p)-int64((*TDateInfo)(unsafe.Pointer(info)).FdateInput))
		/* convert using dict */
	}
	/* try to apply new time zone */
	(*TTcl_Obj)(unsafe.Pointer(tzObjStor)).FrefCount++
	(*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FtimezoneObj = XClockSetupTimeZone(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FdataPtr, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, tzObjStor)
	_objPtr = tzObjStor
	v8 = _objPtr
	v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
	*(*TTcl_Size)(unsafe.Pointer(v8))--
	if v7 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	if (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FtimezoneObj == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	*(*uintptr)(unsafe.Pointer(info + 8)) += uintptr(len1)
	return TCL_OK
}

func _ClockScnToken_StarDate_Proc(tls *libc.TLS, opts uintptr, info uintptr, tok uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var end, p, ret, v1, v13, v2, v3, v7 uintptr
	var fractDayDiv, v10, v9 int32
	var v12 bool
	var v5, v6 int64
	var _ /* ch1 at bp+0 */ TTcl_UniChar
	var _ /* ch2 at bp+4 */ TTcl_UniChar
	var _ /* fractDay at bp+32 */ int32
	var _ /* fractYear at bp+28 */ int32
	var _ /* maxLen at bp+12 */ int32
	var _ /* minLen at bp+8 */ int32
	var _ /* s at bp+16 */ uintptr
	var _ /* year at bp+24 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = end, fractDayDiv, p, ret, v1, v10, v12, v13, v2, v3, v5, v6, v7, v9
	p = (*TDateInfo)(unsafe.Pointer(info)).FdateInput
	_DetermineGreedySearchLen(tls, opts, info, tok, bp+8, bp+12)
	end = (*TDateInfo)(unsafe.Pointer(info)).FdateInput + uintptr(*(*int32)(unsafe.Pointer(bp + 12)))
	/* stardate string */
	v1 = p
	v2 = _stardatePref
	ret = v1
	for {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v1)))
			v5 = int64(libc.Int32FromInt32(1))
		} else {
			v5 = XTcl_UtfToUniChar(tls, v1, bp)
		}
		v1 += uintptr(v5)
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v2)))
			v6 = int64(libc.Int32FromInt32(1))
		} else {
			v6 = XTcl_UtfToUniChar(tls, v2, bp+4)
		}
		v2 += uintptr(v6)
		if *(*TTcl_UniChar)(unsafe.Pointer(bp)) != *(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp)) = XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(bp)))
			if *(*TTcl_UniChar)(unsafe.Pointer(bp)) != *(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) {
				break
			}
		}
		*(*uintptr)(unsafe.Pointer(bp + 16)) = v2
		goto _4
	_4:
		;
		v3 = v1
		ret = v3
		if !(v3 < end && v2 < _stardatePref+uintptr(9)) {
			break
		}
	}
	v7 = ret
	goto _8
_8:
	p = v7
	if p >= end || int64(p)-int64((*TDateInfo)(unsafe.Pointer(info)).FdateInput) < int64(9) {
		return int32(TCL_RETURN)
	}
	/* bypass spaces */
	for {
		if v12 = p < end; v12 {
			v9 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))
			v10 = libc.BoolInt32(v9 == int32(' ') || libc.Uint32FromInt32(v9)-uint32('\t') < uint32(5))
			goto _11
		_11:
		}
		if !(v12 && v10 != 0) {
			break
		}
		p++
	}
	if p >= end {
		return int32(TCL_RETURN)
	}
	/* currently positive stardate only */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('+') {
		p++
	}
	*(*uintptr)(unsafe.Pointer(bp + 16)) = p
	for p < end && libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 {
		p++
	}
	if p >= end || int64(p)-int64(*(*uintptr)(unsafe.Pointer(bp + 16))) < int64(4) {
		return int32(TCL_RETURN)
	}
	if _Clock_str2int(tls, bp+24, *(*uintptr)(unsafe.Pointer(bp + 16)), p-uintptr(3), int32(1)) != TCL_OK || _Clock_str2int(tls, bp+28, p-uintptr(3), p, int32(1)) != TCL_OK {
		return int32(TCL_RETURN)
	}
	v13 = p
	p++
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v13))) != int32('.') {
		return int32(TCL_RETURN)
	}
	*(*uintptr)(unsafe.Pointer(bp + 16)) = p
	fractDayDiv = int32(1)
	for p < end && libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 {
		fractDayDiv *= int32(10)
		p++
	}
	if _Clock_str2int(tls, bp+32, *(*uintptr)(unsafe.Pointer(bp + 16)), p, int32(1)) != TCL_OK {
		return int32(TCL_RETURN)
	}
	(*TDateInfo)(unsafe.Pointer(info)).FdateInput = p
	/* Build a date from year and fraction. */
	(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fyear = *(*int32)(unsafe.Pointer(bp + 24)) + int32(RODDENBERRY)
	(*TDateInfo)(unsafe.Pointer(info)).Fdate.FisBce = 0
	(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fgregorian = int32(1)
	if XIsGregorianLeapYear(tls, info+24) != 0 {
		*(*int32)(unsafe.Pointer(bp + 28)) *= int32(366)
	} else {
		*(*int32)(unsafe.Pointer(bp + 28)) *= int32(365)
	}
	(*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfYear = *(*int32)(unsafe.Pointer(bp + 28))/int32(1000) + int32(1)
	if *(*int32)(unsafe.Pointer(bp + 28))%int32(1000) >= int32(500) {
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfYear++
	}
	XGetJulianDayFromEraYearDay(tls, info+24, int32(GREGORIAN_CHANGE_DATE))
	(*TDateInfo)(unsafe.Pointer(info)).Fdate.FlocalSeconds = -int64(210866803200) + int64(SECONDS_PER_DAY)*(*TDateInfo)(unsafe.Pointer(info)).Fdate.FjulianDay + int64(libc.Int32FromInt32(SECONDS_PER_DAY)**(*int32)(unsafe.Pointer(bp + 32))/fractDayDiv)
	return TCL_OK
}

var _stardatePref = __ccgo_ts + 14638

/*
 * Descriptors for the various fields in [clock scan].
 */

var _ScnSTokenMapIndex = __ccgo_ts + 14648
var _ScnSTokenMap = [22]TClockScanTokenMap{
	0: {
		Ftype1:   uint16(CTOKT_INT),
		Fflags:   uint16(CLF_DAYOFMONTH),
		FminSize: uint16(1),
		FmaxSize: uint16(2),
		Foffs:    uint16(uint64(libc.UintptrFromInt32(0) + 24 + 52)),
	},
	1: {
		Ftype1:   uint16(CTOKT_INT),
		Fflags:   uint16(CLF_MONTH),
		FminSize: uint16(1),
		FmaxSize: uint16(2),
		Foffs:    uint16(uint64(libc.UintptrFromInt32(0) + 24 + 48)),
	},
	2: {
		Ftype1:   uint16(CTOKT_PARSER),
		Fflags:   uint16(CLF_MONTH),
		FmaxSize: uint16(0xffff),
	},
	3: {
		Ftype1:   uint16(CTOKT_INT),
		Fflags:   uint16(CLF_YEAR),
		FminSize: uint16(1),
		FmaxSize: uint16(2),
		Foffs:    uint16(uint64(libc.UintptrFromInt32(0) + 24 + 40)),
	},
	4: {
		Ftype1:   uint16(CTOKT_INT),
		Fflags:   libc.Uint16FromInt32(int32(CLF_YEAR) | int32(CLF_CENTURY)),
		FminSize: uint16(4),
		FmaxSize: uint16(4),
		Foffs:    uint16(uint64(libc.UintptrFromInt32(0) + 24 + 40)),
	},
	5: {
		Ftype1:   uint16(CTOKT_INT),
		Fflags:   uint16(CLF_TIME),
		FminSize: uint16(1),
		FmaxSize: uint16(2),
		Foffs:    uint16(uint64(libc.UintptrFromInt32(0) + 24 + 68)),
	},
	6: {
		Ftype1:   uint16(CTOKT_INT),
		Fflags:   uint16(CLF_TIME),
		FminSize: uint16(1),
		FmaxSize: uint16(2),
		Foffs:    uint16(uint64(libc.UintptrFromInt32(0) + 24 + 72)),
	},
	7: {
		Ftype1:   uint16(CTOKT_INT),
		Fflags:   uint16(CLF_TIME),
		FminSize: uint16(1),
		FmaxSize: uint16(2),
		Foffs:    uint16(uint64(libc.UintptrFromInt32(0) + 24 + 80)),
	},
	8: {
		Ftype1:   uint16(CTOKT_PARSER),
		FmaxSize: uint16(0xffff),
	},
	9: {
		Ftype1:   uint16(CTOKT_WIDE),
		Fflags:   libc.Uint16FromInt32(int32(CLF_JULIANDAY) | int32(CLF_SIGNED)),
		FminSize: uint16(1),
		FmaxSize: uint16(0xffff),
		Foffs:    uint16(uint64(libc.UintptrFromInt32(0) + 24 + 24)),
	},
	10: {
		Ftype1:   uint16(CTOKT_INT),
		Fflags:   uint16(CLF_DAYOFYEAR),
		FminSize: uint16(1),
		FmaxSize: uint16(3),
		Foffs:    uint16(uint64(libc.UintptrFromInt32(0) + 24 + 44)),
	},
	11: {
		Ftype1:   uint16(CTOKT_INT),
		Fflags:   libc.Uint16FromInt32(int32(CLF_CENTURY) | int32(CLF_ISO8601CENTURY)),
		FminSize: uint16(1),
		FmaxSize: uint16(2),
		Foffs:    uint16(uint64(libc.UintptrFromInt32(0) + 216)),
	},
	12: {
		Ftype1:   uint16(CTOKT_INT),
		Fflags:   uint16(CLF_ISO8601YEAR),
		FminSize: uint16(2),
		FmaxSize: uint16(2),
		Foffs:    uint16(uint64(libc.UintptrFromInt32(0) + 24 + 56)),
	},
	13: {
		Ftype1:   uint16(CTOKT_INT),
		Fflags:   libc.Uint16FromInt32(int32(CLF_ISO8601YEAR) | int32(CLF_ISO8601CENTURY)),
		FminSize: uint16(4),
		FmaxSize: uint16(4),
		Foffs:    uint16(uint64(libc.UintptrFromInt32(0) + 24 + 56)),
	},
	14: {
		Ftype1:   uint16(CTOKT_INT),
		Fflags:   uint16(CLF_ISO8601WEEK),
		FminSize: uint16(1),
		FmaxSize: uint16(2),
		Foffs:    uint16(uint64(libc.UintptrFromInt32(0) + 24 + 60)),
	},
	15: {
		Ftype1:   uint16(CTOKT_PARSER),
		Fflags:   uint16(CLF_DAYOFWEEK),
		FmaxSize: uint16(0xffff),
	},
	16: {
		Ftype1:   uint16(CTOKT_PARSER),
		Fflags:   uint16(CLF_OPTIONAL),
		FmaxSize: uint16(0xffff),
	},
	17: {
		Ftype1:   uint16(CTOKT_INT),
		Fflags:   uint16(CLF_OPTIONAL),
		FminSize: uint16(1),
		FmaxSize: uint16(2),
	},
	18: {
		Ftype1:   uint16(CTOKT_WIDE),
		Fflags:   libc.Uint16FromInt32(int32(CLF_POSIXSEC) | int32(CLF_SIGNED)),
		FminSize: uint16(1),
		FmaxSize: uint16(0xffff),
		Foffs:    uint16(uint64(libc.UintptrFromInt32(0) + 24)),
	},
	19: {
		Ftype1:   uint16(CTOKT_CHAR),
		FminSize: uint16(1),
		FmaxSize: uint16(1),
		Fdata:    __ccgo_ts + 286,
	},
	20: {
		Ftype1:   uint16(CTOKT_CHAR),
		FminSize: uint16(1),
		FmaxSize: uint16(1),
		Fdata:    __ccgo_ts + 14671,
	},
	21: {
		Ftype1:   uint16(CTOKT_PARSER),
		Fflags:   uint16(CLF_LOCALSEC),
		FminSize: uint16(16),
		FmaxSize: uint16(30),
	},
}

func init() {
	p := unsafe.Pointer(&_ScnSTokenMap)
	*(*uintptr)(unsafe.Add(p, 80)) = __ccgo_fp(_ClockScnToken_Month_Proc)
	*(*uintptr)(unsafe.Add(p, 272)) = __ccgo_fp(_ClockScnToken_amPmInd_Proc)
	*(*uintptr)(unsafe.Add(p, 496)) = __ccgo_fp(_ClockScnToken_DayOfWeek_Proc)
	*(*uintptr)(unsafe.Add(p, 528)) = __ccgo_fp(_ClockScnToken_TimeZone_Proc)
	*(*uintptr)(unsafe.Add(p, 688)) = __ccgo_fp(_ClockScnToken_StarDate_Proc)
}

var _ScnSTokenMapAliasIndex = [2]uintptr{
	0: __ccgo_ts + 14673,
	1: __ccgo_ts + 14687,
}

var _ScnETokenMapIndex = __ccgo_ts + 14701
var _ScnETokenMap = [5]TClockScanTokenMap{
	0: {
		Ftype1:   uint16(CTOKT_PARSER),
		FmaxSize: uint16(0xffff),
		Foffs:    uint16(uint64(libc.UintptrFromInt32(0) + 24 + 40)),
		Fdata:    uintptr(MCLIT_LOCALE_NUMERALS),
	},
	1: {
		Ftype1:   uint16(CTOKT_PARSER),
		Fflags:   libc.Uint16FromInt32(int32(CLF_JULIANDAY) | int32(CLF_SIGNED)),
		FminSize: uint16(1),
		FmaxSize: uint16(0xffff),
	},
	2: {
		Ftype1:   uint16(CTOKT_PARSER),
		Fflags:   libc.Uint16FromInt32(int32(CLF_JULIANDAY) | int32(CLF_SIGNED)),
		FminSize: uint16(1),
		FmaxSize: uint16(0xffff),
		Foffs:    libc.Uint16FromInt32(libc.Int32FromInt32(SECONDS_PER_DAY) / libc.Int32FromInt32(2)),
	},
	3: {
		Ftype1:   uint16(CTOKT_PARSER),
		FmaxSize: uint16(0xffff),
		Fdata:    uintptr(MCLIT_LOCALE_NUMERALS),
	},
	4: {
		Ftype1:   uint16(CTOKT_WIDE),
		Fflags:   libc.Uint16FromInt32(int32(CLF_LOCALSEC) | int32(CLF_SIGNED)),
		FminSize: uint16(1),
		FmaxSize: uint16(0xffff),
		Foffs:    uint16(uint64(libc.UintptrFromInt32(0) + 24 + 8)),
	},
}

func init() {
	p := unsafe.Pointer(&_ScnETokenMap)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_ClockScnToken_LocaleERA_Proc)
	*(*uintptr)(unsafe.Add(p, 48)) = __ccgo_fp(_ClockScnToken_JDN_Proc)
	*(*uintptr)(unsafe.Add(p, 80)) = __ccgo_fp(_ClockScnToken_JDN_Proc)
	*(*uintptr)(unsafe.Add(p, 112)) = __ccgo_fp(_ClockScnToken_LocaleListMatcher_Proc)
}

var _ScnETokenMapAliasIndex = [2]uintptr{
	0: __ccgo_ts + 1945,
	1: __ccgo_ts + 1945,
}

var _ScnOTokenMapIndex = __ccgo_ts + 14707
var _ScnOTokenMap = [7]TClockScanTokenMap{
	0: {
		Ftype1:   uint16(CTOKT_PARSER),
		Fflags:   uint16(CLF_DAYOFMONTH),
		FmaxSize: uint16(0xffff),
		Foffs:    uint16(uint64(libc.UintptrFromInt32(0) + 24 + 52)),
		Fdata:    uintptr(MCLIT_LOCALE_NUMERALS),
	},
	1: {
		Ftype1:   uint16(CTOKT_PARSER),
		Fflags:   uint16(CLF_MONTH),
		FmaxSize: uint16(0xffff),
		Foffs:    uint16(uint64(libc.UintptrFromInt32(0) + 24 + 48)),
		Fdata:    uintptr(MCLIT_LOCALE_NUMERALS),
	},
	2: {
		Ftype1:   uint16(CTOKT_PARSER),
		Fflags:   uint16(CLF_YEAR),
		FmaxSize: uint16(0xffff),
		Foffs:    uint16(uint64(libc.UintptrFromInt32(0) + 24 + 40)),
		Fdata:    uintptr(MCLIT_LOCALE_NUMERALS),
	},
	3: {
		Ftype1:   uint16(CTOKT_PARSER),
		Fflags:   uint16(CLF_TIME),
		FmaxSize: uint16(0xffff),
		Foffs:    uint16(uint64(libc.UintptrFromInt32(0) + 24 + 68)),
		Fdata:    uintptr(MCLIT_LOCALE_NUMERALS),
	},
	4: {
		Ftype1:   uint16(CTOKT_PARSER),
		Fflags:   uint16(CLF_TIME),
		FmaxSize: uint16(0xffff),
		Foffs:    uint16(uint64(libc.UintptrFromInt32(0) + 24 + 72)),
		Fdata:    uintptr(MCLIT_LOCALE_NUMERALS),
	},
	5: {
		Ftype1:   uint16(CTOKT_PARSER),
		Fflags:   uint16(CLF_TIME),
		FmaxSize: uint16(0xffff),
		Foffs:    uint16(uint64(libc.UintptrFromInt32(0) + 24 + 80)),
		Fdata:    uintptr(MCLIT_LOCALE_NUMERALS),
	},
	6: {
		Ftype1:   uint16(CTOKT_PARSER),
		Fflags:   uint16(CLF_DAYOFWEEK),
		FmaxSize: uint16(0xffff),
		Fdata:    uintptr(MCLIT_LOCALE_NUMERALS),
	},
}

func init() {
	p := unsafe.Pointer(&_ScnOTokenMap)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_ClockScnToken_LocaleListMatcher_Proc)
	*(*uintptr)(unsafe.Add(p, 48)) = __ccgo_fp(_ClockScnToken_LocaleListMatcher_Proc)
	*(*uintptr)(unsafe.Add(p, 80)) = __ccgo_fp(_ClockScnToken_LocaleListMatcher_Proc)
	*(*uintptr)(unsafe.Add(p, 112)) = __ccgo_fp(_ClockScnToken_LocaleListMatcher_Proc)
	*(*uintptr)(unsafe.Add(p, 144)) = __ccgo_fp(_ClockScnToken_LocaleListMatcher_Proc)
	*(*uintptr)(unsafe.Add(p, 176)) = __ccgo_fp(_ClockScnToken_LocaleListMatcher_Proc)
	*(*uintptr)(unsafe.Add(p, 208)) = __ccgo_fp(_ClockScnToken_DayOfWeek_Proc)
}

var _ScnOTokenMapAliasIndex = [2]uintptr{
	0: __ccgo_ts + 14715,
	1: __ccgo_ts + 14721,
}

// C documentation
//
//	/* Token map reserved for CTOKT_SPACE */
var _ScnSpaceTokenMap = TClockScanTokenMap{
	Ftype1:   uint16(CTOKT_SPACE),
	FminSize: uint16(1),
	FmaxSize: uint16(1),
}

var _ScnWordTokenMap = TClockScanTokenMap{
	Ftype1:   uint16(CTOKT_WORD),
	FminSize: uint16(1),
	FmaxSize: uint16(1),
}

func _EstimateTokenCount(tls *libc.TLS, fmt uintptr, end uintptr) (r uint32) {
	var p, v1 uintptr
	var tokcnt, v2 uint32
	_, _, _, _ = p, tokcnt, v1, v2
	p = fmt
	/* estimate token count by % char and format length */
	tokcnt = uint32(0)
	for p <= end {
		v1 = p
		p++
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) == int32('%') {
			tokcnt++
			p++
		}
	}
	p = fmt + uintptr(tokcnt*uint32(2))
	if p < end {
		if libc.Uint32FromInt64(int64(end)-int64(p)) < tokcnt {
			tokcnt = uint32(int64(tokcnt) + (int64(end) - int64(p)))
		} else {
			tokcnt += tokcnt
		}
	}
	tokcnt++
	v2 = tokcnt
	return v2
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 */
func XClockGetOrParseScanFormat(tls *libc.TLS, interp uintptr, formatObj uintptr) (r uintptr) {
	/* Format container */
	var aliasIndex, cp, e, fss, mapIndex, p, prevTok, prevTok1, scnMap, scnTok, tok, wordTok, v1, v13, v17, v2, v22, v26, v27, v6, p7, p8 uintptr
	var endDist, tokCnt uint32
	var v10, v14, v15, v18, v19, v23, v24, v9 int32
	var v12, v21 bool
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = aliasIndex, cp, e, endDist, fss, mapIndex, p, prevTok, prevTok1, scnMap, scnTok, tok, tokCnt, wordTok, v1, v10, v12, v13, v14, v15, v17, v18, v19, v2, v21, v22, v23, v24, v26, v27, v6, v9, p7, p8
	fss = XTcl_GetClockFrmScnFromObj(tls, interp, formatObj)
	if fss == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	/* if format (scnTok) already tokenized */
	if (*TClockFmtScnStorage)(unsafe.Pointer(fss)).FscnTok != libc.UintptrFromInt32(0) {
		return fss
	}
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_ClockFmtMutex)))
	/* first time scanning - tokenize format */
	if (*TClockFmtScnStorage)(unsafe.Pointer(fss)).FscnTok == libc.UintptrFromInt32(0) {
		v1 = _HashEntry4FmtScn(tls, fss) + 32
		p = v1
		e = v1
		e += uintptr(libc.Xstrlen(tls, p))
		/* estimate token count by % char and format length */
		(*TClockFmtScnStorage)(unsafe.Pointer(fss)).FscnTokC = _EstimateTokenCount(tls, p, e)
		(*TClockFmtScnStorage)(unsafe.Pointer(fss)).FscnSpaceCount = uint32(0)
		v2 = XTcl_Alloc(tls, uint64(32)*uint64((*TClockFmtScnStorage)(unsafe.Pointer(fss)).FscnTokC))
		tok = v2
		scnTok = v2
		libc.Xmemset(tls, tok, 0, uint64(32))
		tokCnt = uint32(1)
		for p < e {
			switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) {
			case int32('%'):
				goto _3
			default:
				goto _4
			}
			goto _5
		_3:
			;
			scnMap = uintptr(unsafe.Pointer(&_ScnSTokenMap))
			mapIndex = _ScnSTokenMapIndex
			aliasIndex = uintptr(unsafe.Pointer(&_ScnSTokenMapAliasIndex))
			if p+uintptr(1) >= e {
				goto word_tok
			}
			p++
			/* try to find modifier: */
			switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) {
			case int32('%'):
				/* begin new word token - don't join with previous word token,
				 * because current mapping should be "...%%..." -> "...%..." */
				(*TClockScanToken)(unsafe.Pointer(tok)).Fmap1 = uintptr(unsafe.Pointer(&_ScnWordTokenMap))
				(*TClockScanToken)(unsafe.Pointer(tok)).FtokWord.Fstart = p
				(*TClockScanToken)(unsafe.Pointer(tok)).FtokWord.Fend = p + uintptr(1)
				tok += 32
				v6 = tok
				if v6 >= scnTok+uintptr((*TClockFmtScnStorage)(unsafe.Pointer(fss)).FscnTokC)*32 {
					scnTok = XTcl_Realloc(tls, scnTok, uint64((*TClockFmtScnStorage)(unsafe.Pointer(fss)).FscnTokC+libc.Uint32FromInt32(CLOCK_MIN_TOK_CHAIN_BLOCK_SIZE))*uint64(32))
					tok = scnTok + uintptr((*TClockFmtScnStorage)(unsafe.Pointer(fss)).FscnTokC)*32
					*(*uint32)(unsafe.Pointer(fss + 16)) += uint32(CLOCK_MIN_TOK_CHAIN_BLOCK_SIZE)
				}
				libc.Xmemset(tls, tok, 0, uint64(32))
				tokCnt++
				p++
				continue
			case int32('E'):
				scnMap = uintptr(unsafe.Pointer(&_ScnETokenMap))
				mapIndex = _ScnETokenMapIndex
				aliasIndex = uintptr(unsafe.Pointer(&_ScnETokenMapAliasIndex))
				p++
			case int32('O'):
				scnMap = uintptr(unsafe.Pointer(&_ScnOTokenMap))
				mapIndex = _ScnOTokenMapIndex
				aliasIndex = uintptr(unsafe.Pointer(&_ScnOTokenMapAliasIndex))
				p++
				break
			}
			/* search direct index */
			cp = libc.Xstrchr(tls, mapIndex, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))))
			if !(cp != 0) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cp))) == int32('\000') {
				/* search wrapper index (multiple chars for same token) */
				cp = libc.Xstrchr(tls, *(*uintptr)(unsafe.Pointer(aliasIndex)), libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))))
				if !(cp != 0) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cp))) == int32('\000') {
					p--
					if scnMap != uintptr(unsafe.Pointer(&_ScnSTokenMap)) {
						p--
					}
					goto word_tok
				}
				cp = libc.Xstrchr(tls, mapIndex, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(aliasIndex + 1*8)) + uintptr(int64(cp)-int64(*(*uintptr)(unsafe.Pointer(aliasIndex))))))))
				if !(cp != 0) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cp))) == int32('\000') { /* unexpected, but ... */
					p--
					if scnMap != uintptr(unsafe.Pointer(&_ScnSTokenMap)) {
						p--
					}
					goto word_tok
				}
			}
			(*TClockScanToken)(unsafe.Pointer(tok)).Fmap1 = scnMap + uintptr(int64(cp)-int64(mapIndex))*32
			(*TClockScanToken)(unsafe.Pointer(tok)).FtokWord.Fstart = p
			/* calculate look ahead value by standing together tokens */
			if tok > scnTok {
				prevTok = tok - uintptr(1)*32
				for prevTok >= scnTok {
					if libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer((*TClockScanToken)(unsafe.Pointer(prevTok)).Fmap1)).Ftype1) != libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer((*TClockScanToken)(unsafe.Pointer(tok)).Fmap1)).Ftype1) {
						break
					}
					p7 = prevTok + 26
					*(*uint16)(unsafe.Pointer(p7)) = uint16(int32(*(*uint16)(unsafe.Pointer(p7))) + libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer((*TClockScanToken)(unsafe.Pointer(tok)).Fmap1)).FminSize))
					p8 = prevTok + 28
					*(*uint16)(unsafe.Pointer(p8)) = uint16(int32(*(*uint16)(unsafe.Pointer(p8))) + libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer((*TClockScanToken)(unsafe.Pointer(tok)).Fmap1)).FmaxSize))
					(*TClockScanToken)(unsafe.Pointer(prevTok)).FlookAhTok++
					prevTok -= 32
				}
			}
			/* increase space count used in format */
			if v12 = libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer((*TClockScanToken)(unsafe.Pointer(tok)).Fmap1)).Ftype1) == int32(CTOKT_CHAR); v12 {
				v9 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TClockScanTokenMap)(unsafe.Pointer((*TClockScanToken)(unsafe.Pointer(tok)).Fmap1)).Fdata)))
				v10 = libc.BoolInt32(v9 == int32(' ') || libc.Uint32FromInt32(v9)-uint32('\t') < uint32(5))
				goto _11
			_11:
			}
			if v12 && v10 != 0 {
				(*TClockFmtScnStorage)(unsafe.Pointer(fss)).FscnSpaceCount++
			}
			/* next token */
			tok += 32
			v13 = tok
			if v13 >= scnTok+uintptr((*TClockFmtScnStorage)(unsafe.Pointer(fss)).FscnTokC)*32 {
				scnTok = XTcl_Realloc(tls, scnTok, uint64((*TClockFmtScnStorage)(unsafe.Pointer(fss)).FscnTokC+libc.Uint32FromInt32(CLOCK_MIN_TOK_CHAIN_BLOCK_SIZE))*uint64(32))
				tok = scnTok + uintptr((*TClockFmtScnStorage)(unsafe.Pointer(fss)).FscnTokC)*32
				*(*uint32)(unsafe.Pointer(fss + 16)) += uint32(CLOCK_MIN_TOK_CHAIN_BLOCK_SIZE)
			}
			libc.Xmemset(tls, tok, 0, uint64(32))
			tokCnt++
			p++
			continue
		_4:
			;
			v14 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))
			v15 = libc.BoolInt32(v14 == int32(' ') || libc.Uint32FromInt32(v14)-uint32('\t') < uint32(5))
			goto _16
		_16:
			if v15 != 0 {
				(*TClockScanToken)(unsafe.Pointer(tok)).Fmap1 = uintptr(unsafe.Pointer(&_ScnSpaceTokenMap))
				v17 = p
				p++
				(*TClockScanToken)(unsafe.Pointer(tok)).FtokWord.Fstart = v17
				for {
					if v21 = p < e; v21 {
						v18 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))
						v19 = libc.BoolInt32(v18 == int32(' ') || libc.Uint32FromInt32(v18)-uint32('\t') < uint32(5))
						goto _20
					_20:
					}
					if !(v21 && v19 != 0) {
						break
					}
					p++
				}
				(*TClockScanToken)(unsafe.Pointer(tok)).FtokWord.Fend = p
				/* increase space count used in format */
				(*TClockFmtScnStorage)(unsafe.Pointer(fss)).FscnSpaceCount++
				/* next token */
				tok += 32
				v22 = tok
				if v22 >= scnTok+uintptr((*TClockFmtScnStorage)(unsafe.Pointer(fss)).FscnTokC)*32 {
					scnTok = XTcl_Realloc(tls, scnTok, uint64((*TClockFmtScnStorage)(unsafe.Pointer(fss)).FscnTokC+libc.Uint32FromInt32(CLOCK_MIN_TOK_CHAIN_BLOCK_SIZE))*uint64(32))
					tok = scnTok + uintptr((*TClockFmtScnStorage)(unsafe.Pointer(fss)).FscnTokC)*32
					*(*uint32)(unsafe.Pointer(fss + 16)) += uint32(CLOCK_MIN_TOK_CHAIN_BLOCK_SIZE)
				}
				libc.Xmemset(tls, tok, 0, uint64(32))
				tokCnt++
				continue
			}
			goto word_tok
		word_tok:
			;
			/* try continue with previous word token */
			wordTok = tok - uintptr(1)*32
			if wordTok < scnTok || (*TClockScanToken)(unsafe.Pointer(wordTok)).Fmap1 != uintptr(unsafe.Pointer(&_ScnWordTokenMap)) {
				/* start with new word token */
				wordTok = tok
				(*TClockScanToken)(unsafe.Pointer(wordTok)).FtokWord.Fstart = p
				(*TClockScanToken)(unsafe.Pointer(wordTok)).Fmap1 = uintptr(unsafe.Pointer(&_ScnWordTokenMap))
			}
			for cond := true; cond; cond = p < e && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('%') {
				v23 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))
				v24 = libc.BoolInt32(v23 == int32(' ') || libc.Uint32FromInt32(v23)-uint32('\t') < uint32(5))
				goto _25
			_25:
				if v24 != 0 {
					(*TClockFmtScnStorage)(unsafe.Pointer(fss)).FscnSpaceCount++
				}
				p = XTcl_UtfNext(tls, p)
			}
			(*TClockScanToken)(unsafe.Pointer(wordTok)).FtokWord.Fend = p
			if wordTok == tok {
				tok += 32
				v26 = tok
				if v26 >= scnTok+uintptr((*TClockFmtScnStorage)(unsafe.Pointer(fss)).FscnTokC)*32 {
					scnTok = XTcl_Realloc(tls, scnTok, uint64((*TClockFmtScnStorage)(unsafe.Pointer(fss)).FscnTokC+libc.Uint32FromInt32(CLOCK_MIN_TOK_CHAIN_BLOCK_SIZE))*uint64(32))
					tok = scnTok + uintptr((*TClockFmtScnStorage)(unsafe.Pointer(fss)).FscnTokC)*32
					*(*uint32)(unsafe.Pointer(fss + 16)) += uint32(CLOCK_MIN_TOK_CHAIN_BLOCK_SIZE)
				}
				libc.Xmemset(tls, tok, 0, uint64(32))
				tokCnt++
			}
			goto _5
		_5:
		}
		/* calculate end distance value for each tokens */
		if tok > scnTok {
			endDist = uint32(0)
			prevTok1 = tok - uintptr(1)*32
			for prevTok1 >= scnTok {
				(*TClockScanToken)(unsafe.Pointer(prevTok1)).FendDistance = uint16(endDist)
				if libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer((*TClockScanToken)(unsafe.Pointer(prevTok1)).Fmap1)).Ftype1) != int32(CTOKT_WORD) {
					endDist += uint32((*TClockScanTokenMap)(unsafe.Pointer((*TClockScanToken)(unsafe.Pointer(prevTok1)).Fmap1)).FminSize)
				} else {
					endDist = uint32(int64(endDist) + (int64((*TClockScanToken)(unsafe.Pointer(prevTok1)).FtokWord.Fend) - int64((*TClockScanToken)(unsafe.Pointer(prevTok1)).FtokWord.Fstart)))
				}
				prevTok1 -= 32
			}
		}
		/* correct count of real used tokens and free mem if desired
		 * (1 is acceptable delta to prevent memory fragmentation) */
		if (*TClockFmtScnStorage)(unsafe.Pointer(fss)).FscnTokC > tokCnt+libc.Uint32FromInt32(libc.Int32FromInt32(CLOCK_MIN_TOK_CHAIN_BLOCK_SIZE)/libc.Int32FromInt32(2)) {
			v27 = XTclpRealloc(tls, scnTok, uint64(tokCnt)*uint64(32))
			tok = v27
			if v27 != libc.UintptrFromInt32(0) {
				scnTok = tok
			}
		}
		/* now we're ready - assign now to storage (note the threaded race condition) */
		(*TClockFmtScnStorage)(unsafe.Pointer(fss)).FscnTok = scnTok
		(*TClockFmtScnStorage)(unsafe.Pointer(fss)).FscnTokC = tokCnt
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_ClockFmtMutex)))
	return fss
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 */
func XClockScan(tls *libc.TLS, info uintptr, strObj uintptr, opts uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Command options */
	var dataPtr, end, fss, map1, p, tok, x, v1, v12, v19, v2, v25, v26, v4, p17, p18 uintptr
	var flags uint16
	var ret, sign, v10, v13, v14, v21, v22, v27, v28, v30, v31, v33, v34, v37, v38, v40, v41, v44, v45, v5, v6, v9 int32
	var v16, v24, v3, v36, v43, v47, v8 bool
	var _ /* minLen at bp+0 */ int32
	var _ /* size at bp+4 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = dataPtr, end, flags, fss, map1, p, ret, sign, tok, x, v1, v10, v12, v13, v14, v16, v19, v2, v21, v22, v24, v25, v26, v27, v28, v3, v30, v31, v33, v34, v36, v37, v38, v4, v40, v41, v43, v44, v45, v47, v5, v6, v8, v9, p17, p18
	dataPtr = (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FdataPtr
	flags = uint16(0)
	ret = int32(TCL_ERROR)
	/* get localized format */
	if XClockLocalizeFormat(tls, opts) == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	v1 = XClockGetOrParseScanFormat(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FformatObj)
	fss = v1
	if v3 = !(v1 != 0); !v3 {
		v2 = (*TClockFmtScnStorage)(unsafe.Pointer(fss)).FscnTok
		tok = v2
	}
	if v3 || !(v2 != 0) {
		return int32(TCL_ERROR)
	}
	/* prepare parsing */
	(*TDateInfo)(unsafe.Pointer(info)).FdateMeridian = int32(MER24)
	if (*TTcl_Obj)(unsafe.Pointer(strObj)).Fbytes != 0 {
		v4 = (*TTcl_Obj)(unsafe.Pointer(strObj)).Fbytes
	} else {
		v4 = XTcl_GetStringFromObj(tls, strObj, libc.UintptrFromInt32(0))
	}
	p = v4
	end = p + uintptr((*TTcl_Obj)(unsafe.Pointer(strObj)).Flength)
	/* in strict mode - bypass spaces at begin / end only (not between tokens) */
	if (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Fflags&int32(CLF_STRICT) != 0 {
		for {
			if v8 = p < end; v8 {
				v5 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))
				v6 = libc.BoolInt32(v5 == int32(' ') || libc.Uint32FromInt32(v5)-uint32('\t') < uint32(5))
				goto _7
			_7:
			}
			if !(v8 && v6 != 0) {
				break
			}
			p++
		}
	}
	(*TDateInfo)(unsafe.Pointer(info)).FdateInput = p
	/* look ahead to count spaces (bypass it by count length and distances) */
	x = end
	for p < end {
		v9 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))
		v10 = libc.BoolInt32(v9 == int32(' ') || libc.Uint32FromInt32(v9)-uint32('\t') < uint32(5))
		goto _11
	_11:
		if v10 != 0 {
			p++
			v12 = p
			x = v12 /* after first space in space block */
			(*TDateInfo)(unsafe.Pointer(info)).FdateSpaceCount++
			for {
				if v16 = p < end; v16 {
					v13 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))
					v14 = libc.BoolInt32(v13 == int32(' ') || libc.Uint32FromInt32(v13)-uint32('\t') < uint32(5))
					goto _15
				_15:
				}
				if !(v16 && v14 != 0) {
					break
				}
				p++
				(*TDateInfo)(unsafe.Pointer(info)).FdateSpaceCount++
			}
			continue
		}
		x = end
		p++
	}
	/* ignore more as 1 space at end */
	p17 = info + 208
	*(*int32)(unsafe.Pointer(p17)) = int32(int64(*(*int32)(unsafe.Pointer(p17))) - (int64(end) - int64(x)))
	end = x
	/* ignore mandatory spaces used in format */
	p18 = info + 208
	*(*int32)(unsafe.Pointer(p18)) = int32(uint32(*(*int32)(unsafe.Pointer(p18))) - (*TClockFmtScnStorage)(unsafe.Pointer(fss)).FscnSpaceCount)
	if (*TDateInfo)(unsafe.Pointer(info)).FdateSpaceCount < 0 {
		(*TDateInfo)(unsafe.Pointer(info)).FdateSpaceCount = 0
	}
	v19 = (*TDateInfo)(unsafe.Pointer(info)).FdateInput
	p = v19
	(*TDateInfo)(unsafe.Pointer(info)).FdateStart = v19
	(*TDateInfo)(unsafe.Pointer(info)).FdateEnd = end
	/* parse string */
	for {
		if !((*TClockScanToken)(unsafe.Pointer(tok)).Fmap1 != libc.UintptrFromInt32(0)) {
			break
		}
		map1 = (*TClockScanToken)(unsafe.Pointer(tok)).Fmap1
		/* bypass spaces at begin of input before parsing each token */
		if !((*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Fflags&int32(CLF_STRICT) != 0) && (libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer(map1)).Ftype1) != int32(CTOKT_SPACE) && libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer(map1)).Ftype1) != int32(CTOKT_WORD) && libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer(map1)).Ftype1) != int32(CTOKT_CHAR)) {
			for {
				if v24 = p < end; v24 {
					v21 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))
					v22 = libc.BoolInt32(v21 == int32(' ') || libc.Uint32FromInt32(v21)-uint32('\t') < uint32(5))
					goto _23
				_23:
				}
				if !(v24 && v22 != 0) {
					break
				}
				(*TDateInfo)(unsafe.Pointer(info)).FdateSpaceCount--
				p++
			}
		}
		(*TDateInfo)(unsafe.Pointer(info)).FdateInput = p
		/* end of input string */
		if p >= end {
			break
		}
		switch libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer(map1)).Ftype1) {
		case int32(CTOKT_INT):
			fallthrough
		case int32(CTOKT_WIDE):
			sign = int32(1)
			if libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer(map1)).Fflags)&int32(CLF_SIGNED) != 0 {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('+') {
					p++
					v25 = p
					(*TDateInfo)(unsafe.Pointer(info)).FdateInput = v25
				} else {
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') {
						p++
						v26 = p
						(*TDateInfo)(unsafe.Pointer(info)).FdateInput = v26
						sign = -int32(1)
					}
				}
			}
			_DetermineGreedySearchLen(tls, opts, info, tok, bp, bp+4)
			if *(*int32)(unsafe.Pointer(bp + 4)) < libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer(map1)).FminSize) {
				/* missing input -> error */
				if libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer(map1)).Fflags)&int32(CLF_OPTIONAL) != 0 {
					goto _20
				}
				goto not_match
			}
			/* string 2 number, put number into info structure by offset */
			if (*TClockScanTokenMap)(unsafe.Pointer(map1)).Foffs != 0 {
				p = (*TDateInfo)(unsafe.Pointer(info)).FdateInput
				x = p + uintptr(*(*int32)(unsafe.Pointer(bp + 4)))
				if libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer(map1)).Ftype1) == int32(CTOKT_INT) {
					if *(*int32)(unsafe.Pointer(bp + 4)) <= int32(10) {
						_Clock_str2int_no(tls, info+uintptr((*TClockScanTokenMap)(unsafe.Pointer(map1)).Foffs), p, x, sign)
					} else {
						if _Clock_str2int(tls, info+uintptr((*TClockScanTokenMap)(unsafe.Pointer(map1)).Foffs), p, x, sign) != TCL_OK {
							goto overflow
						}
					}
					p = x
				} else {
					if *(*int32)(unsafe.Pointer(bp + 4)) <= int32(18) {
						_Clock_str2wideInt_no(tls, info+uintptr((*TClockScanTokenMap)(unsafe.Pointer(map1)).Foffs), p, x, sign)
					} else {
						if _Clock_str2wideInt(tls, info+uintptr((*TClockScanTokenMap)(unsafe.Pointer(map1)).Foffs), p, x, sign) != TCL_OK {
							goto overflow
						}
					}
					p = x
				}
				flags = libc.Uint16FromInt32(libc.Int32FromUint16(flags) & ^libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer(map1)).FclearFlags) | libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer(map1)).Fflags))
			}
		case int32(CTOKT_PARSER):
			switch (*(*func(*libc.TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TClockScanTokenMap)(unsafe.Pointer(map1)).Fparser})))(tls, opts, info, tok) {
			case TCL_OK:
			case int32(TCL_RETURN):
				if libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer(map1)).Fflags)&int32(CLF_OPTIONAL) != 0 {
					(*TDateInfo)(unsafe.Pointer(info)).FdateInput = p
					goto _20
				}
				goto not_match
			default:
				goto done
			}
			/* decrement count for possible spaces in match */
			for p < (*TDateInfo)(unsafe.Pointer(info)).FdateInput {
				v27 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))
				v28 = libc.BoolInt32(v27 == int32(' ') || libc.Uint32FromInt32(v27)-uint32('\t') < uint32(5))
				goto _29
			_29:
				if v28 != 0 {
					(*TDateInfo)(unsafe.Pointer(info)).FdateSpaceCount--
				}
				p++
			}
			p = (*TDateInfo)(unsafe.Pointer(info)).FdateInput
			flags = libc.Uint16FromInt32(libc.Int32FromUint16(flags) & ^libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer(map1)).FclearFlags) | libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer(map1)).Fflags))
		case int32(CTOKT_SPACE):
			/* at least one space */
			v30 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))
			v31 = libc.BoolInt32(v30 == int32(' ') || libc.Uint32FromInt32(v30)-uint32('\t') < uint32(5))
			goto _32
		_32:
			if !(v31 != 0) {
				/* unmatched -> error */
				goto not_match
			}
			/* don't decrement yySpaceCount by regular (first expected space),
			 * already considered above with fss->scnSpaceCount */
			p++
			for {
				if v36 = p < end; v36 {
					v33 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))
					v34 = libc.BoolInt32(v33 == int32(' ') || libc.Uint32FromInt32(v33)-uint32('\t') < uint32(5))
					goto _35
				_35:
				}
				if !(v36 && v34 != 0) {
					break
				}
				(*TDateInfo)(unsafe.Pointer(info)).FdateSpaceCount--
				p++
			}
		case int32(CTOKT_WORD):
			x = _FindWordEnd(tls, tok, p, end)
			if !(x != 0) {
				/* no match -> error */
				goto not_match
			}
			p = x
		case int32(CTOKT_CHAR):
			x = (*TClockScanTokenMap)(unsafe.Pointer(map1)).Fdata
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(x))) != libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) {
				/* no match -> error */
				goto not_match
			}
			v37 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(x)))
			v38 = libc.BoolInt32(v37 == int32(' ') || libc.Uint32FromInt32(v37)-uint32('\t') < uint32(5))
			goto _39
		_39:
			if v38 != 0 {
				(*TDateInfo)(unsafe.Pointer(info)).FdateSpaceCount--
			}
			p++
			break
		}
		goto _20
	_20:
		;
		tok += 32
	}
	/* check end was reached */
	if p < end {
		/* in non-strict mode bypass spaces at end of input */
		if v43 = !((*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Fflags&int32(CLF_STRICT) != 0); v43 {
			v40 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))
			v41 = libc.BoolInt32(v40 == int32(' ') || libc.Uint32FromInt32(v40)-uint32('\t') < uint32(5))
			goto _42
		_42:
		}
		if v43 && v41 != 0 {
			p++
			for {
				if v47 = p < end; v47 {
					v44 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))
					v45 = libc.BoolInt32(v44 == int32(' ') || libc.Uint32FromInt32(v44)-uint32('\t') < uint32(5))
					goto _46
				_46:
				}
				if !(v47 && v45 != 0) {
					break
				}
				p++
			}
		}
		/* something after last token - wrong format */
		if p < end {
			goto not_match
		}
	}
	/* end of string, check only optional tokens at end, otherwise - not match */
	for (*TClockScanToken)(unsafe.Pointer(tok)).Fmap1 != libc.UintptrFromInt32(0) {
		if !((*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Fflags&int32(CLF_STRICT) != 0) && libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer((*TClockScanToken)(unsafe.Pointer(tok)).Fmap1)).Ftype1) == int32(CTOKT_SPACE) {
			tok += 32
			if (*TClockScanToken)(unsafe.Pointer(tok)).Fmap1 == libc.UintptrFromInt32(0) {
				/* no tokens anymore - trailing spaces are mandatory */
				goto not_match
			}
		}
		if !(libc.Int32FromUint16((*TClockScanTokenMap)(unsafe.Pointer((*TClockScanToken)(unsafe.Pointer(tok)).Fmap1)).Fflags)&int32(CLF_OPTIONAL) != 0) {
			goto not_match
		}
		tok += 32
	}
	/*
	 * Invalidate result
	 */
	flags = uint16(int32(flags) | (*TDateInfo)(unsafe.Pointer(info)).Fflags)
	/* seconds token (%s) take precedence over all other tokens */
	if (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Fflags&int32(CLF_EXTENDED) != 0 || !(libc.Int32FromUint16(flags)&int32(CLF_POSIXSEC) != 0) {
		if libc.Int32FromUint16(flags)&int32(CLF_DATE) != 0 {
			if !(libc.Int32FromUint16(flags)&int32(CLF_JULIANDAY) != 0) {
				*(*int32)(unsafe.Pointer(info + 136)) |= int32(CLF_ASSEMBLE_SECONDS) | int32(CLF_ASSEMBLE_JULIANDAY)
				/* dd precedence below ddd */
				switch libc.Int32FromUint16(flags) & (int32(CLF_MONTH) | int32(CLF_DAYOFYEAR) | int32(CLF_DAYOFMONTH)) {
				case int32(CLF_DAYOFYEAR) | int32(CLF_DAYOFMONTH):
					/* miss month: ddd over dd (without month) */
					flags = uint16(int32(flags) & ^int32(CLF_DAYOFMONTH))
					/* fallthrough */
					fallthrough
				case int32(CLF_DAYOFYEAR):
					/* ddd over naked weekday */
					if !(libc.Int32FromUint16(flags)&int32(CLF_ISO8601YEAR) != 0) {
						flags = uint16(int32(flags) & ^int32(CLF_ISO8601WEEK))
					}
				case int32(CLF_MONTH) | int32(CLF_DAYOFYEAR) | int32(CLF_DAYOFMONTH):
					/* both available: mmdd over ddd */
					fallthrough
				case int32(CLF_MONTH) | int32(CLF_DAYOFMONTH):
					fallthrough
				case int32(CLF_DAYOFMONTH):
					/* mmdd / dd over naked weekday */
					if !(libc.Int32FromUint16(flags)&int32(CLF_ISO8601YEAR) != 0) {
						flags = uint16(int32(flags) & ^int32(CLF_ISO8601WEEK))
					}
					break
					/* neither mmdd nor ddd available */
					fallthrough
				case 0:
					/* but we have day of the week, which can be used */
					if libc.Int32FromUint16(flags)&int32(CLF_DAYOFWEEK) != 0 {
						/* prefer week based calculation of julianday */
						flags = uint16(int32(flags) | int32(CLF_ISO8601WEEK))
					}
				}
				/* YearWeekDay below YearMonthDay */
				if libc.Int32FromUint16(flags)&int32(CLF_ISO8601WEEK) != 0 && (libc.Int32FromUint16(flags)&(int32(CLF_YEAR)|int32(CLF_DAYOFYEAR)) == int32(CLF_YEAR)|int32(CLF_DAYOFYEAR) || libc.Int32FromUint16(flags)&(int32(CLF_YEAR)|int32(CLF_DAYOFMONTH)|int32(CLF_MONTH)) == int32(CLF_YEAR)|int32(CLF_DAYOFMONTH)|int32(CLF_MONTH)) {
					/* yy precedence below yyyy */
					if !(libc.Int32FromUint16(flags)&int32(CLF_ISO8601CENTURY) != 0) && libc.Int32FromUint16(flags)&int32(CLF_CENTURY) != 0 {
						/* normally precedence of ISO is higher, but no century - so put it down */
						flags = uint16(int32(flags) & ^int32(CLF_ISO8601WEEK))
					} else {
						if !(libc.Int32FromUint16(flags)&int32(CLF_ISO8601YEAR) != 0) {
							/* yymmdd or yyddd over naked weekday */
							flags = uint16(int32(flags) & ^int32(CLF_ISO8601WEEK))
						}
					}
				}
				if libc.Int32FromUint16(flags)&int32(CLF_YEAR) != 0 {
					if (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fyear < int32(100) {
						if !(libc.Int32FromUint16(flags)&int32(CLF_CENTURY) != 0) {
							if (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fyear >= (*TClockClientData)(unsafe.Pointer(dataPtr)).FyearOfCenturySwitch {
								*(*int32)(unsafe.Pointer(info + 24 + 40)) -= int32(100)
							}
							*(*int32)(unsafe.Pointer(info + 24 + 40)) += (*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentYearCentury
						} else {
							*(*int32)(unsafe.Pointer(info + 24 + 40)) += (*TDateInfo)(unsafe.Pointer(info)).FdateCentury * int32(100)
						}
					}
				}
				if libc.Int32FromUint16(flags)&(int32(CLF_ISO8601WEEK)|int32(CLF_ISO8601YEAR)) != 0 {
					if libc.Int32FromUint16(flags)&(int32(CLF_ISO8601YEAR)|int32(CLF_YEAR)) == int32(CLF_YEAR) {
						/* for calculations expected iso year */
						(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fiso8601Year = (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fyear
					} else {
						if (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fiso8601Year < int32(100) {
							if !(libc.Int32FromUint16(flags)&int32(CLF_ISO8601CENTURY) != 0) {
								if (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fiso8601Year >= (*TClockClientData)(unsafe.Pointer(dataPtr)).FyearOfCenturySwitch {
									(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fiso8601Year -= int32(100)
								}
								(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fiso8601Year += (*TClockClientData)(unsafe.Pointer(dataPtr)).FcurrentYearCentury
							} else {
								(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fiso8601Year += (*TDateInfo)(unsafe.Pointer(info)).FdateCentury * int32(100)
							}
						}
					}
					if libc.Int32FromUint16(flags)&(int32(CLF_ISO8601YEAR)|int32(CLF_YEAR)) == int32(CLF_ISO8601YEAR) {
						/* for calculations expected year (e. g. CLF_ISO8601WEEK not set) */
						(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fyear = (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fiso8601Year
					}
				}
			}
		}
		/* if no time - reset time */
		if !(libc.Int32FromUint16(flags)&(int32(CLF_TIME)|int32(CLF_LOCALSEC)|int32(CLF_POSIXSEC)) != 0) {
			*(*int32)(unsafe.Pointer(info + 136)) |= int32(CLF_ASSEMBLE_SECONDS)
			(*TDateInfo)(unsafe.Pointer(info)).Fdate.FlocalSeconds = 0
		}
		if libc.Int32FromUint16(flags)&int32(CLF_TIME) != 0 {
			*(*int32)(unsafe.Pointer(info + 136)) |= int32(CLF_ASSEMBLE_SECONDS)
			(*TDateInfo)(unsafe.Pointer(info)).Fdate.FsecondOfDay = int64(XToSeconds(tls, (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fhour, (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fminutes, int32((*TDateInfo)(unsafe.Pointer(info)).Fdate.FsecondOfMin), (*TDateInfo)(unsafe.Pointer(info)).FdateMeridian))
		} else {
			if !(libc.Int32FromUint16(flags)&(int32(CLF_LOCALSEC)|int32(CLF_POSIXSEC)) != 0) {
				*(*int32)(unsafe.Pointer(info + 136)) |= int32(CLF_ASSEMBLE_SECONDS)
				(*TDateInfo)(unsafe.Pointer(info)).Fdate.FsecondOfDay = (*TDateInfo)(unsafe.Pointer(info)).Fdate.FlocalSeconds % int64(SECONDS_PER_DAY)
			}
		}
	}
	/* tell caller which flags were set */
	*(*int32)(unsafe.Pointer(info + 136)) |= libc.Int32FromUint16(flags)
	ret = TCL_OK
	goto done
done:
	;
	return ret
	/* Error case reporting. */
	goto overflow
overflow:
	;
	XTcl_SetObjResult(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, XTcl_NewStringObj(tls, __ccgo_ts+11737, int64(-libc.Int32FromInt32(1))))
	XTcl_SetErrorCode(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, libc.VaList(bp+16, __ccgo_ts+12666, __ccgo_ts+13952, libc.UintptrFromInt32(0)))
	goto done
	goto not_match
not_match:
	;
	XTcl_SetObjResult(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, XTcl_NewStringObj(tls, __ccgo_ts+14727, int64(-libc.Int32FromInt32(1))))
	XTcl_SetErrorCode(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, libc.VaList(bp+16, __ccgo_ts+12666, __ccgo_ts+14771, libc.UintptrFromInt32(0)))
	goto done
	return r
}

func _FrmResultAllocate(tls *libc.TLS, dateFmt uintptr, len1 int32) (r int32) {
	var needed, newsize int32
	var newRes uintptr
	_, _, _ = needed, newRes, newsize
	needed = int32(int64((*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput+uintptr(len1)) - int64((*TDateFormat)(unsafe.Pointer(dateFmt)).FresEnd))
	if needed >= 0 { /* >= 0 - regards NTS zero */
		newsize = int32(int64((*TDateFormat)(unsafe.Pointer(dateFmt)).FresEnd) - int64((*TDateFormat)(unsafe.Pointer(dateFmt)).FresMem) + int64(needed) + int64(libc.Int32FromInt32(MIN_FMT_RESULT_BLOCK_ALLOC)*libc.Int32FromInt32(2)))
		/* differentiate between stack and memory */
		if !(int64((*TDateFormat)(unsafe.Pointer(dateFmt)).FresEnd)-int64((*TDateFormat)(unsafe.Pointer(dateFmt)).FresMem) > libc.Int64FromInt32(MIN_FMT_RESULT_BLOCK_ALLOC)) {
			newRes = XTclpAlloc(tls, libc.Uint64FromInt32(newsize))
			if newRes == libc.UintptrFromInt32(0) {
				return int32(TCL_ERROR)
			}
			libc.Xmemcpy(tls, newRes, (*TDateFormat)(unsafe.Pointer(dateFmt)).FresMem, libc.Uint64FromInt64(int64((*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput)-int64((*TDateFormat)(unsafe.Pointer(dateFmt)).FresMem)))
		} else {
			newRes = XTclpRealloc(tls, (*TDateFormat)(unsafe.Pointer(dateFmt)).FresMem, libc.Uint64FromInt32(newsize))
			if newRes == libc.UintptrFromInt32(0) {
				return int32(TCL_ERROR)
			}
		}
		(*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput = newRes + uintptr(int64((*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput)-int64((*TDateFormat)(unsafe.Pointer(dateFmt)).FresMem))
		(*TDateFormat)(unsafe.Pointer(dateFmt)).FresMem = newRes
		(*TDateFormat)(unsafe.Pointer(dateFmt)).FresEnd = newRes + uintptr(newsize)
	}
	return TCL_OK
}

func _ClockFmtToken_HourAMPM_Proc(tls *libc.TLS, dummy2762 uintptr, dummy2763 uintptr, dummy2764 uintptr, val uintptr) (r int32) {
	*(*int32)(unsafe.Pointer(val)) = (*(*int32)(unsafe.Pointer(val))+int32(SECONDS_PER_DAY)-int32(3600))/int32(3600)%int32(12) + int32(1)
	return TCL_OK
}

func _ClockFmtToken_AMPM_Proc(tls *libc.TLS, opts uintptr, dateFmt uintptr, tok uintptr, val uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var mcObj, s, v1 uintptr
	var _ /* len at bp+0 */ TTcl_Size
	_, _, _ = mcObj, s, v1
	if *(*int32)(unsafe.Pointer(val)) < libc.Int32FromInt32(SECONDS_PER_DAY)/libc.Int32FromInt32(2) {
		mcObj = XClockMCGet(tls, opts, int32(MCLIT_AM))
	} else {
		mcObj = XClockMCGet(tls, opts, int32(MCLIT_PM))
	}
	if mcObj == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(mcObj)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(mcObj)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(mcObj)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, mcObj, bp)
	}
	s = v1
	if _FrmResultAllocate(tls, dateFmt, int32(*(*TTcl_Size)(unsafe.Pointer(bp)))) != TCL_OK {
		return int32(TCL_ERROR)
	}
	libc.Xmemcpy(tls, (*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput, s, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))+int64(1)))
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TClockFormatToken)(unsafe.Pointer(tok)).FtokWord.Fstart))) == int32('p') {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = XTcl_UtfToUpper(tls, (*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput)
	}
	*(*uintptr)(unsafe.Pointer(dateFmt + 16)) += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))
	return TCL_OK
}

func _ClockFmtToken_StarDate_Proc(tls *libc.TLS, dummy2805 uintptr, dateFmt uintptr, dummy2807 uintptr, dummy2808 uintptr) (r int32) {
	var fractYear, v int32
	var v1, v2 uintptr
	_, _, _, _ = fractYear, v, v1, v2
	/* Get day of year, zero based */
	v = (*TDateFormat)(unsafe.Pointer(dateFmt)).Fdate.FdayOfYear - int32(1)
	/* Convert day of year to a fractional year */
	if XIsGregorianLeapYear(tls, dateFmt+24) != 0 {
		fractYear = int32(1000) * v / int32(366)
	} else {
		fractYear = int32(1000) * v / int32(365)
	}
	/* Put together the StarDate as "Stardate %02d%03d.%1d" */
	if _FrmResultAllocate(tls, dateFmt, int32(30)) != TCL_OK {
		return int32(TCL_ERROR)
	}
	libc.Xmemcpy(tls, (*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput, __ccgo_ts+14786, uint64(9))
	*(*uintptr)(unsafe.Pointer(dateFmt + 16)) += uintptr(9)
	(*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput = _Clock_itoaw(tls, (*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput, (*TDateFormat)(unsafe.Pointer(dateFmt)).Fdate.Fyear-int32(RODDENBERRY), uint8('0'), uint16(2))
	(*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput = _Clock_itoaw(tls, (*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput, fractYear, uint8('0'), uint16(3))
	v2 = dateFmt + 16
	v1 = *(*uintptr)(unsafe.Pointer(v2))
	*(*uintptr)(unsafe.Pointer(v2))++
	*(*uint8)(unsafe.Pointer(v1)) = uint8('.')
	/* be sure positive after decimal point (note: clock-value can be negative) */
	v = int32((*TDateFormat)(unsafe.Pointer(dateFmt)).Fdate.FsecondOfDay / int64(libc.Int32FromInt32(SECONDS_PER_DAY)/libc.Int32FromInt32(10)))
	if v < 0 {
		v = int32(10) + v
	}
	(*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput = _Clock_itoaw(tls, (*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput, v, uint8('0'), uint16(1))
	return TCL_OK
}

func _ClockFmtToken_WeekOfYear_Proc(tls *libc.TLS, dummy2842 uintptr, dateFmt uintptr, tok uintptr, val uintptr) (r int32) {
	var dow int32
	_ = dow
	dow = (*TDateFormat)(unsafe.Pointer(dateFmt)).Fdate.FdayOfWeek
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TClockFormatToken)(unsafe.Pointer(tok)).FtokWord.Fstart))) == int32('U') {
		if dow == int32(7) {
			dow = 0
		}
		dow++
	}
	*(*int32)(unsafe.Pointer(val)) = ((*TDateFormat)(unsafe.Pointer(dateFmt)).Fdate.FdayOfYear - dow + int32(7)) / int32(7)
	return TCL_OK
}

func _ClockFmtToken_JDN_Proc(tls *libc.TLS, dummy2860 uintptr, dateFmt uintptr, tok uintptr, dummy2863 uintptr) (r int32) {
	var fractJD, v7 int32
	var intJD TTcl_WideInt
	var p, v1, v2, v3, v4, v5, v6, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _ = fractJD, intJD, p, v1, v2, v3, v4, v5, v6, v7, v8, v9
	intJD = (*TDateFormat)(unsafe.Pointer(dateFmt)).Fdate.FjulianDay
	/* Convert to JDN parts (regarding start offset) and time fraction */
	fractJD = int32((*TDateFormat)(unsafe.Pointer(dateFmt)).Fdate.FsecondOfDay - int64(libc.Int32FromUint16((*TClockFormatTokenMap)(unsafe.Pointer((*TClockFormatToken)(unsafe.Pointer(tok)).Fmap1)).Foffs))) /* 0 for calendar or 43200 for astro JD */
	if fractJD < 0 {
		intJD--
		fractJD += int32(SECONDS_PER_DAY)
	}
	if fractJD != 0 && intJD < 0 { /* avoid jump over 0, by negative JD's */
		intJD++
		if intJD == 0 {
			/* -0.0 / -0.9 has zero integer part, so append "-" extra */
			if _FrmResultAllocate(tls, dateFmt, int32(1)) != TCL_OK {
				return int32(TCL_ERROR)
			}
			v2 = dateFmt + 16
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = uint8('-')
		}
		/* and inverse seconds of day, -0(75) -> -0.25 as float */
		fractJD = int32(SECONDS_PER_DAY) - fractJD
	}
	/* 21 is max width of (negative) wide-int (rather smaller, but anyway a time fraction below) */
	if _FrmResultAllocate(tls, dateFmt, int32(21)) != TCL_OK {
		return int32(TCL_ERROR)
	}
	(*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput = _Clock_witoaw(tls, (*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput, intJD, uint8('0'), uint16(1))
	/* simplest cases .0 and .5 */
	if !(fractJD != 0) || fractJD == libc.Int32FromInt32(SECONDS_PER_DAY)/libc.Int32FromInt32(2) {
		/* point + 0 or 5 */
		if _FrmResultAllocate(tls, dateFmt, libc.Int32FromInt32(1)+libc.Int32FromInt32(1)) != TCL_OK {
			return int32(TCL_ERROR)
		}
		v4 = dateFmt + 16
		v3 = *(*uintptr)(unsafe.Pointer(v4))
		*(*uintptr)(unsafe.Pointer(v4))++
		*(*uint8)(unsafe.Pointer(v3)) = uint8('.')
		v6 = dateFmt + 16
		v5 = *(*uintptr)(unsafe.Pointer(v6))
		*(*uintptr)(unsafe.Pointer(v6))++
		if !(fractJD != 0) {
			v7 = int32('0')
		} else {
			v7 = int32('5')
		}
		*(*uint8)(unsafe.Pointer(v5)) = libc.Uint8FromInt32(v7)
		*(*uint8)(unsafe.Pointer((*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput)) = uint8('\000')
		return TCL_OK
	} else {
		/* to float (part after floating point, + 0.5 to round it up) */
		fractJD = int32(float64(float64(fractJD)*libc.Float64FromInt32(JDN_MAX_PRECBOUND))/libc.Float64FromInt32(SECONDS_PER_DAY) + libc.Float64FromFloat64(0.5))
		/* point + integer (as time fraction after floating point) */
		if _FrmResultAllocate(tls, dateFmt, libc.Int32FromInt32(1)+libc.Int32FromInt32(JDN_MAX_PRECISION)) != TCL_OK {
			return int32(TCL_ERROR)
		}
		v9 = dateFmt + 16
		v8 = *(*uintptr)(unsafe.Pointer(v9))
		*(*uintptr)(unsafe.Pointer(v9))++
		*(*uint8)(unsafe.Pointer(v8)) = uint8('.')
		p = _Clock_itoaw(tls, (*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput, fractJD, uint8('0'), uint16(JDN_MAX_PRECISION))
		/* remove trailing zero's */
		(*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput++
		for p > (*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-libc.Int32FromInt32(1))))) == int32('0') {
			p--
		}
		*(*uint8)(unsafe.Pointer(p)) = uint8('\000')
		(*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput = p
	}
	return TCL_OK
}

func _ClockFmtToken_TimeZone_Proc(tls *libc.TLS, opts uintptr, dateFmt uintptr, tok uintptr, dummy2935 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var objPtr, s, v1, v2, v3 uintptr
	var sign uint8
	var z int32
	var _ /* len at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _ = objPtr, s, sign, z, v1, v2, v3
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TClockFormatToken)(unsafe.Pointer(tok)).FtokWord.Fstart))) == int32('z') {
		z = (*TDateFormat)(unsafe.Pointer(dateFmt)).Fdate.FtzOffset
		sign = uint8('+')
		if z < 0 {
			z = -z
			sign = uint8('-')
		}
		if _FrmResultAllocate(tls, dateFmt, int32(7)) != TCL_OK {
			return int32(TCL_ERROR)
		}
		v2 = dateFmt + 16
		v1 = *(*uintptr)(unsafe.Pointer(v2))
		*(*uintptr)(unsafe.Pointer(v2))++
		*(*uint8)(unsafe.Pointer(v1)) = sign
		(*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput = _Clock_itoaw(tls, (*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput, z/int32(3600), uint8('0'), uint16(2))
		z %= int32(3600)
		(*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput = _Clock_itoaw(tls, (*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput, z/int32(60), uint8('0'), uint16(2))
		z %= int32(60)
		if z != 0 {
			(*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput = _Clock_itoaw(tls, (*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput, z, uint8('0'), uint16(2))
		}
	} else {
		/* convert seconds to local seconds to obtain tzName object */
		if XConvertUTCToLocal(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FdataPtr, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, dateFmt+24, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FtimezoneObj, int32(GREGORIAN_CHANGE_DATE)) != TCL_OK {
			return int32(TCL_ERROR)
		}
		objPtr = (*TDateFormat)(unsafe.Pointer(dateFmt)).Fdate.FtzName
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
			v3 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, objPtr, bp)
		}
		s = v3
		if _FrmResultAllocate(tls, dateFmt, int32(*(*TTcl_Size)(unsafe.Pointer(bp)))) != TCL_OK {
			return int32(TCL_ERROR)
		}
		libc.Xmemcpy(tls, (*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput, s, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))+int64(1)))
		*(*uintptr)(unsafe.Pointer(dateFmt + 16)) += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))
	}
	return TCL_OK
}

func _ClockFmtToken_LocaleERA_Proc(tls *libc.TLS, opts uintptr, dateFmt uintptr, dummy2982 uintptr, dummy2983 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var mcObj, s, v1 uintptr
	var _ /* len at bp+0 */ TTcl_Size
	_, _, _ = mcObj, s, v1
	if (*TDateFormat)(unsafe.Pointer(dateFmt)).Fdate.FisBce != 0 {
		mcObj = XClockMCGet(tls, opts, int32(MCLIT_BCE))
	} else {
		mcObj = XClockMCGet(tls, opts, int32(MCLIT_CE))
	}
	if mcObj == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(mcObj)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(mcObj)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(mcObj)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, mcObj, bp)
	}
	s = v1
	if _FrmResultAllocate(tls, dateFmt, int32(*(*TTcl_Size)(unsafe.Pointer(bp)))) != TCL_OK {
		return int32(TCL_ERROR)
	}
	libc.Xmemcpy(tls, (*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput, s, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))+int64(1)))
	*(*uintptr)(unsafe.Pointer(dateFmt + 16)) += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))
	return TCL_OK
}

func _ClockFmtToken_LocaleERAYear_Proc(tls *libc.TLS, opts uintptr, dateFmt uintptr, tok uintptr, val uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var mcObj, mcObj1, s, v4 uintptr
	var v1 int32
	var v2, v3 int64
	var _ /* len at bp+24 */ TTcl_Size
	var _ /* objPtr at bp+16 */ uintptr
	var _ /* rowc at bp+0 */ TTcl_Size
	var _ /* rowv at bp+8 */ uintptr
	_, _, _, _, _, _, _ = mcObj, mcObj1, s, v1, v2, v3, v4
	if (*TDateFormat)(unsafe.Pointer(dateFmt)).FlocaleEra == libc.UintptrFromInt32(0) {
		mcObj = XClockMCGet(tls, opts, int32(MCLIT_LOCALE_ERAS))
		if mcObj == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
		if (*TTcl_Obj)(unsafe.Pointer(mcObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(mcObj + 32))).Fptr2 != 0 {
				v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(mcObj + 32))).Fptr2)).FspanStart
			} else {
				v2 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(mcObj + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(mcObj + 32))).Fptr1 + 40 + uintptr(v2)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(mcObj + 32))).Fptr2 != 0 {
				v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(mcObj + 32))).Fptr2)).FspanLength
			} else {
				v3 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(mcObj + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp)) = v3
			v1 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1 = XTcl_ListObjGetElements(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, mcObj, bp, bp+8)
		}
		if v1 != TCL_OK {
			return int32(TCL_ERROR)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp)) != 0 {
			(*TDateFormat)(unsafe.Pointer(dateFmt)).FlocaleEra = XLookupLastTransition(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, (*TDateFormat)(unsafe.Pointer(dateFmt)).Fdate.FlocalSeconds, *(*TTcl_Size)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 8)), libc.UintptrFromInt32(0))
		}
		if (*TDateFormat)(unsafe.Pointer(dateFmt)).FlocaleEra == libc.UintptrFromInt32(0) {
			(*TDateFormat)(unsafe.Pointer(dateFmt)).FlocaleEra = libc.UintptrFromInt32(1)
		}
	}
	/* if no LOCALE_ERAS in catalog or era not found */
	if (*TDateFormat)(unsafe.Pointer(dateFmt)).FlocaleEra == libc.UintptrFromInt32(1) {
		if _FrmResultAllocate(tls, dateFmt, int32(11)) != TCL_OK {
			return int32(TCL_ERROR)
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TClockFormatToken)(unsafe.Pointer(tok)).FtokWord.Fstart))) == int32('C') { /* %EC */
			*(*int32)(unsafe.Pointer(val)) = (*TDateFormat)(unsafe.Pointer(dateFmt)).Fdate.Fyear / int32(100)
			(*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput = _Clock_itoaw(tls, (*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput, *(*int32)(unsafe.Pointer(val)), uint8('0'), uint16(2))
		} else { /* %Ey */
			*(*int32)(unsafe.Pointer(val)) = (*TDateFormat)(unsafe.Pointer(dateFmt)).Fdate.Fyear % int32(100)
			(*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput = _Clock_itoaw(tls, (*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput, *(*int32)(unsafe.Pointer(val)), uint8('0'), uint16(2))
		}
	} else {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TClockFormatToken)(unsafe.Pointer(tok)).FtokWord.Fstart))) == int32('C') { /* %EC */
			if XTcl_ListObjIndex(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, (*TDateFormat)(unsafe.Pointer(dateFmt)).FlocaleEra, int64(1), bp+16) != TCL_OK {
				return int32(TCL_ERROR)
			}
		} else { /* %Ey */
			if XTcl_ListObjIndex(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, (*TDateFormat)(unsafe.Pointer(dateFmt)).FlocaleEra, int64(2), bp+16) != TCL_OK {
				return int32(TCL_ERROR)
			}
			if XTcl_GetIntFromObj(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, *(*uintptr)(unsafe.Pointer(bp + 16)), val) != TCL_OK {
				return int32(TCL_ERROR)
			}
			*(*int32)(unsafe.Pointer(val)) = (*TDateFormat)(unsafe.Pointer(dateFmt)).Fdate.Fyear - *(*int32)(unsafe.Pointer(val))
			/* if year in locale numerals */
			if *(*int32)(unsafe.Pointer(val)) >= 0 && *(*int32)(unsafe.Pointer(val)) < int32(100) {
				/* year as integer */
				mcObj1 = XClockMCGet(tls, opts, int32(MCLIT_LOCALE_NUMERALS))
				if mcObj1 == libc.UintptrFromInt32(0) {
					return int32(TCL_ERROR)
				}
				if XTcl_ListObjIndex(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, mcObj1, int64(*(*int32)(unsafe.Pointer(val))), bp+16) != TCL_OK {
					return int32(TCL_ERROR)
				}
			} else {
				/* year as integer */
				if _FrmResultAllocate(tls, dateFmt, int32(11)) != TCL_OK {
					return int32(TCL_ERROR)
				}
				(*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput = _Clock_itoaw(tls, (*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput, *(*int32)(unsafe.Pointer(val)), uint8('0'), uint16(2))
				return TCL_OK
			}
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength
			v4 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes
		} else {
			v4 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), bp+24)
		}
		s = v4
		if _FrmResultAllocate(tls, dateFmt, int32(*(*TTcl_Size)(unsafe.Pointer(bp + 24)))) != TCL_OK {
			return int32(TCL_ERROR)
		}
		libc.Xmemcpy(tls, (*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput, s, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 24))+int64(1)))
		*(*uintptr)(unsafe.Pointer(dateFmt + 16)) += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 24)))
	}
	return TCL_OK
}

/*
 * Descriptors for the various fields in [clock format].
 */

var _FmtSTokenMapIndex = __ccgo_ts + 14796
var _FmtSTokenMap = [31]TClockFormatTokenMap{
	0: {
		Ftype1: uint16(CTOKT_INT),
		Ftostr: __ccgo_ts + 14828,
		Fwidth: uint16(2),
		Foffs:  uint16(uint64(libc.UintptrFromInt32(0) + 24 + 52)),
	},
	1: {
		Ftype1: uint16(CTOKT_INT),
		Ftostr: __ccgo_ts + 14830,
		Fwidth: uint16(2),
		Foffs:  uint16(uint64(libc.UintptrFromInt32(0) + 24 + 52)),
	},
	2: {
		Ftype1: uint16(CTOKT_INT),
		Ftostr: __ccgo_ts + 14828,
		Fwidth: uint16(2),
		Foffs:  uint16(uint64(libc.UintptrFromInt32(0) + 24 + 48)),
	},
	3: {
		Ftype1: uint16(CTOKT_INT),
		Ftostr: __ccgo_ts + 14830,
		Fwidth: uint16(2),
		Foffs:  uint16(uint64(libc.UintptrFromInt32(0) + 24 + 48)),
	},
	4: {
		Ftype1:  uint16(CTOKT_INT),
		Fflags:  libc.Uint16FromInt32(int32(CLFMT_LOCALE_INDX) | int32(CLFMT_DECR)),
		Fdivmod: uint16(12),
		Foffs:   uint16(uint64(libc.UintptrFromInt32(0) + 24 + 48)),
		Fdata:   uintptr(MCLIT_MONTHS_ABBREV),
	},
	5: {
		Ftype1:  uint16(CTOKT_INT),
		Fflags:  libc.Uint16FromInt32(int32(CLFMT_LOCALE_INDX) | int32(CLFMT_DECR)),
		Fdivmod: uint16(12),
		Foffs:   uint16(uint64(libc.UintptrFromInt32(0) + 24 + 48)),
		Fdata:   uintptr(MCLIT_MONTHS_FULL),
	},
	6: {
		Ftype1:  uint16(CTOKT_INT),
		Ftostr:  __ccgo_ts + 14828,
		Fwidth:  uint16(2),
		Fdivmod: uint16(100),
		Foffs:   uint16(uint64(libc.UintptrFromInt32(0) + 24 + 40)),
	},
	7: {
		Ftype1: uint16(CTOKT_INT),
		Ftostr: __ccgo_ts + 14828,
		Fwidth: uint16(4),
		Foffs:  uint16(uint64(libc.UintptrFromInt32(0) + 24 + 40)),
	},
	8: {
		Ftype1:   uint16(CTOKT_INT),
		Ftostr:   __ccgo_ts + 14828,
		Fwidth:   uint16(2),
		Fdivider: uint16(100),
		Foffs:    uint16(uint64(libc.UintptrFromInt32(0) + 24 + 40)),
	},
	9: {
		Ftype1:   uint16(CTOKT_INT),
		Ftostr:   __ccgo_ts + 14828,
		Fwidth:   uint16(2),
		Fdivider: uint16(3600),
		Fdivmod:  uint16(24),
		Foffs:    uint16(uint64(libc.UintptrFromInt32(0) + 24 + 88)),
	},
	10: {
		Ftype1:   uint16(CTOKT_INT),
		Ftostr:   __ccgo_ts + 14828,
		Fwidth:   uint16(2),
		Fdivider: uint16(60),
		Fdivmod:  uint16(60),
		Foffs:    uint16(uint64(libc.UintptrFromInt32(0) + 24 + 88)),
	},
	11: {
		Ftype1:  uint16(CTOKT_INT),
		Ftostr:  __ccgo_ts + 14828,
		Fwidth:  uint16(2),
		Fdivmod: uint16(60),
		Foffs:   uint16(uint64(libc.UintptrFromInt32(0) + 24 + 88)),
	},
	12: {
		Ftype1: uint16(CTOKT_INT),
		Ftostr: __ccgo_ts + 14828,
		Fwidth: uint16(2),
		Fflags: uint16(CLFMT_CALC),
		Foffs:  uint16(uint64(libc.UintptrFromInt32(0) + 24 + 88)),
	},
	13: {
		Ftype1:   uint16(CTOKT_INT),
		Ftostr:   __ccgo_ts + 14830,
		Fwidth:   uint16(2),
		Fdivider: uint16(3600),
		Fdivmod:  uint16(24),
		Foffs:    uint16(uint64(libc.UintptrFromInt32(0) + 24 + 88)),
	},
	14: {
		Ftype1: uint16(CTOKT_INT),
		Ftostr: __ccgo_ts + 14830,
		Fwidth: uint16(2),
		Fflags: uint16(CLFMT_CALC),
		Foffs:  uint16(uint64(libc.UintptrFromInt32(0) + 24 + 88)),
	},
	15: {
		Ftype1: uint16(CTOKT_INT),
		Foffs:  uint16(uint64(libc.UintptrFromInt32(0) + 24 + 88)),
	},
	16: {
		Ftype1:  uint16(CTOKT_INT),
		Fflags:  uint16(CLFMT_LOCALE_INDX),
		Fdivmod: uint16(7),
		Foffs:   uint16(uint64(libc.UintptrFromInt32(0) + 24 + 64)),
		Fdata:   uintptr(MCLIT_DAYS_OF_WEEK_ABBREV),
	},
	17: {
		Ftype1:  uint16(CTOKT_INT),
		Fflags:  uint16(CLFMT_LOCALE_INDX),
		Fdivmod: uint16(7),
		Foffs:   uint16(uint64(libc.UintptrFromInt32(0) + 24 + 64)),
		Fdata:   uintptr(MCLIT_DAYS_OF_WEEK_FULL),
	},
	18: {
		Ftype1: uint16(CTOKT_INT),
		Ftostr: __ccgo_ts + 14830,
		Fwidth: uint16(1),
		Foffs:  uint16(uint64(libc.UintptrFromInt32(0) + 24 + 64)),
	},
	19: {
		Ftype1:  uint16(CTOKT_INT),
		Ftostr:  __ccgo_ts + 14830,
		Fwidth:  uint16(1),
		Fdivmod: uint16(7),
		Foffs:   uint16(uint64(libc.UintptrFromInt32(0) + 24 + 64)),
	},
	20: {
		Ftype1: uint16(CTOKT_INT),
		Ftostr: __ccgo_ts + 14828,
		Fwidth: uint16(2),
		Fflags: uint16(CLFMT_CALC),
		Foffs:  uint16(uint64(libc.UintptrFromInt32(0) + 24 + 44)),
	},
	21: {
		Ftype1: uint16(CTOKT_INT),
		Ftostr: __ccgo_ts + 14828,
		Fwidth: uint16(2),
		Foffs:  uint16(uint64(libc.UintptrFromInt32(0) + 24 + 60)),
	},
	22: {
		Ftype1: uint16(CFMTT_PROC),
	},
	23: {
		Ftype1:  uint16(CTOKT_INT),
		Ftostr:  __ccgo_ts + 14828,
		Fwidth:  uint16(2),
		Fdivmod: uint16(100),
		Foffs:   uint16(uint64(libc.UintptrFromInt32(0) + 24 + 56)),
	},
	24: {
		Ftype1: uint16(CTOKT_INT),
		Ftostr: __ccgo_ts + 14828,
		Fwidth: uint16(4),
		Foffs:  uint16(uint64(libc.UintptrFromInt32(0) + 24 + 56)),
	},
	25: {
		Ftype1: uint16(CTOKT_INT),
		Ftostr: __ccgo_ts + 14828,
		Fwidth: uint16(3),
		Foffs:  uint16(uint64(libc.UintptrFromInt32(0) + 24 + 44)),
	},
	26: {
		Ftype1: uint16(CTOKT_WIDE),
		Ftostr: __ccgo_ts + 14828,
		Fwidth: uint16(7),
		Foffs:  uint16(uint64(libc.UintptrFromInt32(0) + 24 + 24)),
	},
	27: {
		Ftype1: uint16(CTOKT_WIDE),
		Ftostr: __ccgo_ts + 14828,
		Fwidth: uint16(1),
		Foffs:  uint16(uint64(libc.UintptrFromInt32(0) + 24)),
	},
	28: {
		Ftype1: uint16(CTOKT_CHAR),
		Ftostr: __ccgo_ts + 286,
	},
	29: {
		Ftype1: uint16(CTOKT_CHAR),
		Ftostr: __ccgo_ts + 14671,
	},
	30: {
		Ftype1: uint16(CFMTT_PROC),
	},
}

func init() {
	p := unsafe.Pointer(&_FmtSTokenMap)
	*(*uintptr)(unsafe.Add(p, 608)) = __ccgo_fp(_ClockFmtToken_HourAMPM_Proc)
	*(*uintptr)(unsafe.Add(p, 704)) = __ccgo_fp(_ClockFmtToken_HourAMPM_Proc)
	*(*uintptr)(unsafe.Add(p, 752)) = __ccgo_fp(_ClockFmtToken_AMPM_Proc)
	*(*uintptr)(unsafe.Add(p, 992)) = __ccgo_fp(_ClockFmtToken_WeekOfYear_Proc)
	*(*uintptr)(unsafe.Add(p, 1088)) = __ccgo_fp(_ClockFmtToken_TimeZone_Proc)
	*(*uintptr)(unsafe.Add(p, 1472)) = __ccgo_fp(_ClockFmtToken_StarDate_Proc)
}

var _FmtSTokenMapAliasIndex = [2]uintptr{
	0: __ccgo_ts + 14832,
	1: __ccgo_ts + 14837,
}

var _FmtETokenMapIndex = __ccgo_ts + 14701
var _FmtETokenMap = [5]TClockFormatTokenMap{
	0: {
		Ftype1: uint16(CFMTT_PROC),
	},
	1: {
		Ftype1: uint16(CFMTT_PROC),
	},
	2: {
		Ftype1: uint16(CFMTT_PROC),
		Foffs:  libc.Uint16FromInt32(libc.Int32FromInt32(SECONDS_PER_DAY) / libc.Int32FromInt32(2)),
	},
	3: {
		Ftype1: uint16(CTOKT_INT),
		Foffs:  uint16(uint64(libc.UintptrFromInt32(0) + 24 + 40)),
	},
	4: {
		Ftype1: uint16(CTOKT_WIDE),
		Ftostr: __ccgo_ts + 14828,
		Fwidth: uint16(1),
		Foffs:  uint16(uint64(libc.UintptrFromInt32(0) + 24 + 8)),
	},
}

func init() {
	p := unsafe.Pointer(&_FmtETokenMap)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_ClockFmtToken_LocaleERA_Proc)
	*(*uintptr)(unsafe.Add(p, 80)) = __ccgo_fp(_ClockFmtToken_JDN_Proc)
	*(*uintptr)(unsafe.Add(p, 128)) = __ccgo_fp(_ClockFmtToken_JDN_Proc)
	*(*uintptr)(unsafe.Add(p, 176)) = __ccgo_fp(_ClockFmtToken_LocaleERAYear_Proc)
}

var _FmtETokenMapAliasIndex = [2]uintptr{
	0: __ccgo_ts + 11678,
	1: __ccgo_ts + 14842,
}

var _FmtOTokenMapIndex = __ccgo_ts + 14844
var _FmtOTokenMap = [9]TClockFormatTokenMap{
	0: {
		Ftype1:  uint16(CTOKT_INT),
		Fflags:  uint16(CLFMT_LOCALE_INDX),
		Fdivmod: uint16(100),
		Foffs:   uint16(uint64(libc.UintptrFromInt32(0) + 24 + 52)),
		Fdata:   uintptr(MCLIT_LOCALE_NUMERALS),
	},
	1: {
		Ftype1:  uint16(CTOKT_INT),
		Fflags:  uint16(CLFMT_LOCALE_INDX),
		Fdivmod: uint16(100),
		Foffs:   uint16(uint64(libc.UintptrFromInt32(0) + 24 + 48)),
		Fdata:   uintptr(MCLIT_LOCALE_NUMERALS),
	},
	2: {
		Ftype1:  uint16(CTOKT_INT),
		Fflags:  uint16(CLFMT_LOCALE_INDX),
		Fdivmod: uint16(100),
		Foffs:   uint16(uint64(libc.UintptrFromInt32(0) + 24 + 40)),
		Fdata:   uintptr(MCLIT_LOCALE_NUMERALS),
	},
	3: {
		Ftype1:   uint16(CTOKT_INT),
		Fflags:   uint16(CLFMT_LOCALE_INDX),
		Fdivider: uint16(3600),
		Fdivmod:  uint16(24),
		Foffs:    uint16(uint64(libc.UintptrFromInt32(0) + 24 + 88)),
		Fdata:    uintptr(MCLIT_LOCALE_NUMERALS),
	},
	4: {
		Ftype1: uint16(CTOKT_INT),
		Fflags: libc.Uint16FromInt32(int32(CLFMT_CALC) | int32(CLFMT_LOCALE_INDX)),
		Foffs:  uint16(uint64(libc.UintptrFromInt32(0) + 24 + 88)),
		Fdata:  uintptr(MCLIT_LOCALE_NUMERALS),
	},
	5: {
		Ftype1:   uint16(CTOKT_INT),
		Fflags:   uint16(CLFMT_LOCALE_INDX),
		Fdivider: uint16(60),
		Fdivmod:  uint16(60),
		Foffs:    uint16(uint64(libc.UintptrFromInt32(0) + 24 + 88)),
		Fdata:    uintptr(MCLIT_LOCALE_NUMERALS),
	},
	6: {
		Ftype1:  uint16(CTOKT_INT),
		Fflags:  uint16(CLFMT_LOCALE_INDX),
		Fdivmod: uint16(60),
		Foffs:   uint16(uint64(libc.UintptrFromInt32(0) + 24 + 88)),
		Fdata:   uintptr(MCLIT_LOCALE_NUMERALS),
	},
	7: {
		Ftype1:  uint16(CTOKT_INT),
		Fflags:  uint16(CLFMT_LOCALE_INDX),
		Fdivmod: uint16(100),
		Foffs:   uint16(uint64(libc.UintptrFromInt32(0) + 24 + 64)),
		Fdata:   uintptr(MCLIT_LOCALE_NUMERALS),
	},
	8: {
		Ftype1:  uint16(CTOKT_INT),
		Fflags:  uint16(CLFMT_LOCALE_INDX),
		Fdivmod: uint16(7),
		Foffs:   uint16(uint64(libc.UintptrFromInt32(0) + 24 + 64)),
		Fdata:   uintptr(MCLIT_LOCALE_NUMERALS),
	},
}

func init() {
	p := unsafe.Pointer(&_FmtOTokenMap)
	*(*uintptr)(unsafe.Add(p, 224)) = __ccgo_fp(_ClockFmtToken_HourAMPM_Proc)
}

var _FmtOTokenMapAliasIndex = [2]uintptr{
	0: __ccgo_ts + 14854,
	1: __ccgo_ts + 14858,
}

var _FmtWordTokenMap = TClockFormatTokenMap{
	Ftype1: uint16(CTOKT_WORD),
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 */
func XClockGetOrParseFmtFormat(tls *libc.TLS, interp uintptr, formatObj uintptr) (r uintptr) {
	/* Format container */
	var aliasIndex, cp, e, fmtMap, fmtTok, fss, mapIndex, p, tok, wordTok, v1, v2, v6, v7, v8, v9 uintptr
	var tokCnt uint32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = aliasIndex, cp, e, fmtMap, fmtTok, fss, mapIndex, p, tok, tokCnt, wordTok, v1, v2, v6, v7, v8, v9
	fss = XTcl_GetClockFrmScnFromObj(tls, interp, formatObj)
	if fss == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	/* if format (fmtTok) already tokenized */
	if (*TClockFmtScnStorage)(unsafe.Pointer(fss)).FfmtTok != libc.UintptrFromInt32(0) {
		return fss
	}
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_ClockFmtMutex)))
	/* first time formatting - tokenize format */
	if (*TClockFmtScnStorage)(unsafe.Pointer(fss)).FfmtTok == libc.UintptrFromInt32(0) {
		v1 = _HashEntry4FmtScn(tls, fss) + 32
		p = v1
		e = v1
		e += uintptr(libc.Xstrlen(tls, p))
		/* estimate token count by % char and format length */
		(*TClockFmtScnStorage)(unsafe.Pointer(fss)).FfmtTokC = _EstimateTokenCount(tls, p, e)
		v2 = XTcl_Alloc(tls, uint64(24)*uint64((*TClockFmtScnStorage)(unsafe.Pointer(fss)).FfmtTokC))
		tok = v2
		fmtTok = v2
		libc.Xmemset(tls, tok, 0, uint64(24))
		tokCnt = uint32(1)
		for p < e {
			switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) {
			case int32('%'):
				goto _3
			default:
				goto _4
			}
			goto _5
		_3:
			;
			fmtMap = uintptr(unsafe.Pointer(&_FmtSTokenMap))
			mapIndex = _FmtSTokenMapIndex
			aliasIndex = uintptr(unsafe.Pointer(&_FmtSTokenMapAliasIndex))
			if p+uintptr(1) >= e {
				goto word_tok
			}
			p++
			/* try to find modifier: */
			switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) {
			case int32('%'):
				/* begin new word token - don't join with previous word token,
				 * because current mapping should be "...%%..." -> "...%..." */
				(*TClockFormatToken)(unsafe.Pointer(tok)).Fmap1 = uintptr(unsafe.Pointer(&_FmtWordTokenMap))
				(*TClockFormatToken)(unsafe.Pointer(tok)).FtokWord.Fstart = p
				(*TClockFormatToken)(unsafe.Pointer(tok)).FtokWord.Fend = p + uintptr(1)
				tok += 24
				v6 = tok
				if v6 >= fmtTok+uintptr((*TClockFmtScnStorage)(unsafe.Pointer(fss)).FfmtTokC)*24 {
					fmtTok = XTcl_Realloc(tls, fmtTok, uint64((*TClockFmtScnStorage)(unsafe.Pointer(fss)).FfmtTokC+libc.Uint32FromInt32(CLOCK_MIN_TOK_CHAIN_BLOCK_SIZE))*uint64(24))
					tok = fmtTok + uintptr((*TClockFmtScnStorage)(unsafe.Pointer(fss)).FfmtTokC)*24
					*(*uint32)(unsafe.Pointer(fss + 32)) += uint32(CLOCK_MIN_TOK_CHAIN_BLOCK_SIZE)
				}
				libc.Xmemset(tls, tok, 0, uint64(24))
				tokCnt++
				p++
				continue
			case int32('E'):
				fmtMap = uintptr(unsafe.Pointer(&_FmtETokenMap))
				mapIndex = _FmtETokenMapIndex
				aliasIndex = uintptr(unsafe.Pointer(&_FmtETokenMapAliasIndex))
				p++
			case int32('O'):
				fmtMap = uintptr(unsafe.Pointer(&_FmtOTokenMap))
				mapIndex = _FmtOTokenMapIndex
				aliasIndex = uintptr(unsafe.Pointer(&_FmtOTokenMapAliasIndex))
				p++
				break
			}
			/* search direct index */
			cp = libc.Xstrchr(tls, mapIndex, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))))
			if !(cp != 0) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cp))) == int32('\000') {
				/* search wrapper index (multiple chars for same token) */
				cp = libc.Xstrchr(tls, *(*uintptr)(unsafe.Pointer(aliasIndex)), libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))))
				if !(cp != 0) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cp))) == int32('\000') {
					p--
					if fmtMap != uintptr(unsafe.Pointer(&_FmtSTokenMap)) {
						p--
					}
					goto word_tok
				}
				cp = libc.Xstrchr(tls, mapIndex, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(aliasIndex + 1*8)) + uintptr(int64(cp)-int64(*(*uintptr)(unsafe.Pointer(aliasIndex))))))))
				if !(cp != 0) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cp))) == int32('\000') { /* unexpected, but ... */
					p--
					if fmtMap != uintptr(unsafe.Pointer(&_FmtSTokenMap)) {
						p--
					}
					goto word_tok
				}
			}
			(*TClockFormatToken)(unsafe.Pointer(tok)).Fmap1 = fmtMap + uintptr(int64(cp)-int64(mapIndex))*48
			(*TClockFormatToken)(unsafe.Pointer(tok)).FtokWord.Fstart = p
			/* next token */
			tok += 24
			v7 = tok
			if v7 >= fmtTok+uintptr((*TClockFmtScnStorage)(unsafe.Pointer(fss)).FfmtTokC)*24 {
				fmtTok = XTcl_Realloc(tls, fmtTok, uint64((*TClockFmtScnStorage)(unsafe.Pointer(fss)).FfmtTokC+libc.Uint32FromInt32(CLOCK_MIN_TOK_CHAIN_BLOCK_SIZE))*uint64(24))
				tok = fmtTok + uintptr((*TClockFmtScnStorage)(unsafe.Pointer(fss)).FfmtTokC)*24
				*(*uint32)(unsafe.Pointer(fss + 32)) += uint32(CLOCK_MIN_TOK_CHAIN_BLOCK_SIZE)
			}
			libc.Xmemset(tls, tok, 0, uint64(24))
			tokCnt++
			p++
			continue
		_4:
			;
			goto word_tok
		word_tok:
			;
			/* try continue with previous word token */
			wordTok = tok - uintptr(1)*24
			if wordTok < fmtTok || (*TClockFormatToken)(unsafe.Pointer(wordTok)).Fmap1 != uintptr(unsafe.Pointer(&_FmtWordTokenMap)) {
				/* start with new word token */
				wordTok = tok
				(*TClockFormatToken)(unsafe.Pointer(wordTok)).FtokWord.Fstart = p
				(*TClockFormatToken)(unsafe.Pointer(wordTok)).Fmap1 = uintptr(unsafe.Pointer(&_FmtWordTokenMap))
			}
			for cond := true; cond; cond = p < e && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('%') {
				p = XTcl_UtfNext(tls, p)
			}
			(*TClockFormatToken)(unsafe.Pointer(wordTok)).FtokWord.Fend = p
			if wordTok == tok {
				tok += 24
				v8 = tok
				if v8 >= fmtTok+uintptr((*TClockFmtScnStorage)(unsafe.Pointer(fss)).FfmtTokC)*24 {
					fmtTok = XTcl_Realloc(tls, fmtTok, uint64((*TClockFmtScnStorage)(unsafe.Pointer(fss)).FfmtTokC+libc.Uint32FromInt32(CLOCK_MIN_TOK_CHAIN_BLOCK_SIZE))*uint64(24))
					tok = fmtTok + uintptr((*TClockFmtScnStorage)(unsafe.Pointer(fss)).FfmtTokC)*24
					*(*uint32)(unsafe.Pointer(fss + 32)) += uint32(CLOCK_MIN_TOK_CHAIN_BLOCK_SIZE)
				}
				libc.Xmemset(tls, tok, 0, uint64(24))
				tokCnt++
			}
			goto _5
		_5:
		}
		/* correct count of real used tokens and free mem if desired
		 * (1 is acceptable delta to prevent memory fragmentation) */
		if (*TClockFmtScnStorage)(unsafe.Pointer(fss)).FfmtTokC > tokCnt+libc.Uint32FromInt32(libc.Int32FromInt32(CLOCK_MIN_TOK_CHAIN_BLOCK_SIZE)/libc.Int32FromInt32(2)) {
			v9 = XTclpRealloc(tls, fmtTok, uint64(tokCnt)*uint64(24))
			tok = v9
			if v9 != libc.UintptrFromInt32(0) {
				fmtTok = tok
			}
		}
		/* now we're ready - assign now to storage (note the threaded race condition) */
		(*TClockFmtScnStorage)(unsafe.Pointer(fss)).FfmtTok = fmtTok
		(*TClockFmtScnStorage)(unsafe.Pointer(fss)).FfmtTokC = tokCnt
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_ClockFmtMutex)))
	return fss
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 */
func XClockFormat(tls *libc.TLS, dateFmt uintptr, opts uintptr) (r int32) {
	bp := tls.Alloc(112)
	defer tls.Free(112) /* Command options */
	var cachePtr, fss, map1, result, s, tok, v1, v2, v5, v6, v7, v8, v9 uintptr
	var len1 TTcl_Size
	var size Tsize_t
	var val1 TTcl_WideInt
	var v10, v3 bool
	var _ /* mcObj at bp+88 */ uintptr
	var _ /* resMem at bp+0 */ [80]uint8
	var _ /* val at bp+80 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, fss, len1, map1, result, s, size, tok, val1, v1, v10, v2, v3, v5, v6, v7, v8, v9
	/* get localized format */
	if XClockLocalizeFormat(tls, opts) == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	v1 = XClockGetOrParseFmtFormat(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).FformatObj)
	fss = v1
	if v3 = !(v1 != 0); !v3 {
		v2 = (*TClockFmtScnStorage)(unsafe.Pointer(fss)).FfmtTok
		tok = v2
	}
	if v3 || !(v2 != 0) {
		return int32(TCL_ERROR)
	}
	/* result container object */
	(*TDateFormat)(unsafe.Pointer(dateFmt)).FresMem = bp
	(*TDateFormat)(unsafe.Pointer(dateFmt)).FresEnd = (*TDateFormat)(unsafe.Pointer(dateFmt)).FresMem + uintptr(80)
	if (*TClockFmtScnStorage)(unsafe.Pointer(fss)).FfmtMinAlloc > uint64(80) {
		(*TDateFormat)(unsafe.Pointer(dateFmt)).FresMem = XTclpAlloc(tls, (*TClockFmtScnStorage)(unsafe.Pointer(fss)).FfmtMinAlloc)
		if (*TDateFormat)(unsafe.Pointer(dateFmt)).FresMem == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
		(*TDateFormat)(unsafe.Pointer(dateFmt)).FresEnd = (*TDateFormat)(unsafe.Pointer(dateFmt)).FresMem + uintptr((*TClockFmtScnStorage)(unsafe.Pointer(fss)).FfmtMinAlloc)
	}
	(*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput = (*TDateFormat)(unsafe.Pointer(dateFmt)).FresMem
	*(*uint8)(unsafe.Pointer((*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput)) = uint8('\000')
	/* do format each token */
	for {
		if !((*TClockFormatToken)(unsafe.Pointer(tok)).Fmap1 != libc.UintptrFromInt32(0)) {
			break
		}
		map1 = (*TClockFormatToken)(unsafe.Pointer(tok)).Fmap1
		switch libc.Int32FromUint16((*TClockFormatTokenMap)(unsafe.Pointer(map1)).Ftype1) {
		case int32(CTOKT_INT):
			*(*int32)(unsafe.Pointer(bp + 80)) = *(*int32)(unsafe.Pointer(dateFmt + uintptr((*TClockFormatTokenMap)(unsafe.Pointer(map1)).Foffs)))
			if (*TClockFormatTokenMap)(unsafe.Pointer(map1)).Ffmtproc == libc.UintptrFromInt32(0) {
				if libc.Int32FromUint16((*TClockFormatTokenMap)(unsafe.Pointer(map1)).Fflags)&int32(CLFMT_DECR) != 0 {
					*(*int32)(unsafe.Pointer(bp + 80))--
				}
				if libc.Int32FromUint16((*TClockFormatTokenMap)(unsafe.Pointer(map1)).Fflags)&int32(CLFMT_INCR) != 0 {
					*(*int32)(unsafe.Pointer(bp + 80))++
				}
				if (*TClockFormatTokenMap)(unsafe.Pointer(map1)).Fdivider != 0 {
					*(*int32)(unsafe.Pointer(bp + 80)) /= libc.Int32FromUint16((*TClockFormatTokenMap)(unsafe.Pointer(map1)).Fdivider)
				}
				if (*TClockFormatTokenMap)(unsafe.Pointer(map1)).Fdivmod != 0 {
					*(*int32)(unsafe.Pointer(bp + 80)) %= libc.Int32FromUint16((*TClockFormatTokenMap)(unsafe.Pointer(map1)).Fdivmod)
				}
			} else {
				if (*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TClockFormatTokenMap)(unsafe.Pointer(map1)).Ffmtproc})))(tls, opts, dateFmt, tok, bp+80) != TCL_OK {
					goto done
				}
				/* if not calculate only (output inside fmtproc) */
				if !(libc.Int32FromUint16((*TClockFormatTokenMap)(unsafe.Pointer(map1)).Fflags)&int32(CLFMT_CALC) != 0) {
					goto _4
				}
			}
			if !(libc.Int32FromUint16((*TClockFormatTokenMap)(unsafe.Pointer(map1)).Fflags)&int32(CLFMT_LOCALE_INDX) != 0) {
				if _FrmResultAllocate(tls, dateFmt, int32(11)) != TCL_OK {
					goto error
				}
				if (*TClockFormatTokenMap)(unsafe.Pointer(map1)).Fwidth != 0 {
					(*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput = _Clock_itoaw(tls, (*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput, *(*int32)(unsafe.Pointer(bp + 80)), *(*uint8)(unsafe.Pointer((*TClockFormatTokenMap)(unsafe.Pointer(map1)).Ftostr)), (*TClockFormatTokenMap)(unsafe.Pointer(map1)).Fwidth)
				} else {
					*(*uintptr)(unsafe.Pointer(dateFmt + 16)) += uintptr(libc.Xsprintf(tls, (*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput, (*TClockFormatTokenMap)(unsafe.Pointer(map1)).Ftostr, libc.VaList(bp+104, *(*int32)(unsafe.Pointer(bp + 80)))))
				}
			} else {
				*(*uintptr)(unsafe.Pointer(bp + 88)) = XClockMCGet(tls, opts, int32(int64((*TClockFormatTokenMap)(unsafe.Pointer(map1)).Fdata)))
				if *(*uintptr)(unsafe.Pointer(bp + 88)) == libc.UintptrFromInt32(0) {
					goto error
				}
				if XTcl_ListObjIndex(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, *(*uintptr)(unsafe.Pointer(bp + 88)), int64(*(*int32)(unsafe.Pointer(bp + 80))), bp+88) != TCL_OK || *(*uintptr)(unsafe.Pointer(bp + 88)) == libc.UintptrFromInt32(0) {
					goto error
				}
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 88)))).Fbytes != 0 {
					v5 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 88)))).Fbytes
				} else {
					v5 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 88)), libc.UintptrFromInt32(0))
				}
				s = v5
				if _FrmResultAllocate(tls, dateFmt, int32((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 88)))).Flength)) != TCL_OK {
					goto error
				}
				libc.Xmemcpy(tls, (*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput, s, libc.Uint64FromInt64((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 88)))).Flength+int64(1)))
				*(*uintptr)(unsafe.Pointer(dateFmt + 16)) += uintptr((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 88)))).Flength)
			}
		case int32(CTOKT_WIDE):
			val1 = *(*TTcl_WideInt)(unsafe.Pointer(dateFmt + uintptr((*TClockFormatTokenMap)(unsafe.Pointer(map1)).Foffs)))
			if _FrmResultAllocate(tls, dateFmt, int32(21)) != TCL_OK {
				goto error
			}
			if (*TClockFormatTokenMap)(unsafe.Pointer(map1)).Fwidth != 0 {
				(*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput = _Clock_witoaw(tls, (*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput, val1, *(*uint8)(unsafe.Pointer((*TClockFormatTokenMap)(unsafe.Pointer(map1)).Ftostr)), (*TClockFormatTokenMap)(unsafe.Pointer(map1)).Fwidth)
			} else {
				*(*uintptr)(unsafe.Pointer(dateFmt + 16)) += uintptr(libc.Xsprintf(tls, (*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput, (*TClockFormatTokenMap)(unsafe.Pointer(map1)).Ftostr, libc.VaList(bp+104, val1)))
			}
		case int32(CTOKT_CHAR):
			if _FrmResultAllocate(tls, dateFmt, int32(1)) != TCL_OK {
				goto error
			}
			v7 = dateFmt + 16
			v6 = *(*uintptr)(unsafe.Pointer(v7))
			*(*uintptr)(unsafe.Pointer(v7))++
			*(*uint8)(unsafe.Pointer(v6)) = *(*uint8)(unsafe.Pointer((*TClockFormatTokenMap)(unsafe.Pointer(map1)).Ftostr))
		case int32(CFMTT_PROC):
			if (*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TClockFormatTokenMap)(unsafe.Pointer(map1)).Ffmtproc})))(tls, opts, dateFmt, tok, libc.UintptrFromInt32(0)) != TCL_OK {
				goto error
			}
		case int32(CTOKT_WORD):
			len1 = int64((*TClockFormatToken)(unsafe.Pointer(tok)).FtokWord.Fend) - int64((*TClockFormatToken)(unsafe.Pointer(tok)).FtokWord.Fstart)
			if _FrmResultAllocate(tls, dateFmt, int32(len1)) != TCL_OK {
				goto error
			}
			if len1 == int64(1) {
				v9 = dateFmt + 16
				v8 = *(*uintptr)(unsafe.Pointer(v9))
				*(*uintptr)(unsafe.Pointer(v9))++
				*(*uint8)(unsafe.Pointer(v8)) = *(*uint8)(unsafe.Pointer((*TClockFormatToken)(unsafe.Pointer(tok)).FtokWord.Fstart))
			} else {
				libc.Xmemcpy(tls, (*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput, (*TClockFormatToken)(unsafe.Pointer(tok)).FtokWord.Fstart, libc.Uint64FromInt64(len1))
				*(*uintptr)(unsafe.Pointer(dateFmt + 16)) += uintptr(len1)
			}
			break
		}
		goto _4
	_4:
		;
		tok += 24
	}
	goto done
	goto error
error:
	;
	if (*TDateFormat)(unsafe.Pointer(dateFmt)).FresMem != bp {
		XTclpFree(tls, (*TDateFormat)(unsafe.Pointer(dateFmt)).FresMem)
	}
	(*TDateFormat)(unsafe.Pointer(dateFmt)).FresMem = libc.UintptrFromInt32(0)
	goto done
done:
	;
	if (*TDateFormat)(unsafe.Pointer(dateFmt)).FresMem != 0 {
		if v10 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v10 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v10 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			result = XTclThreadAllocObj(tls)
		} else {
			result = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(result + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(result)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(result)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(result)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(result)).FtypePtr = libc.UintptrFromInt32(0)
		(*TTcl_Obj)(unsafe.Pointer(result)).Flength = int64((*TDateFormat)(unsafe.Pointer(dateFmt)).Foutput) - int64((*TDateFormat)(unsafe.Pointer(dateFmt)).FresMem)
		size = libc.Uint64FromInt64((*TTcl_Obj)(unsafe.Pointer(result)).Flength + int64(1))
		if (*TDateFormat)(unsafe.Pointer(dateFmt)).FresMem == bp {
			(*TTcl_Obj)(unsafe.Pointer(result)).Fbytes = XTclpAlloc(tls, size)
			if (*TTcl_Obj)(unsafe.Pointer(result)).Fbytes == libc.UintptrFromInt32(0) {
				return int32(TCL_ERROR)
			}
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(result)).Fbytes, (*TDateFormat)(unsafe.Pointer(dateFmt)).FresMem, size)
		} else {
			if libc.Uint64FromInt64(int64((*TDateFormat)(unsafe.Pointer(dateFmt)).FresEnd)-int64((*TDateFormat)(unsafe.Pointer(dateFmt)).FresMem))/size > uint64(MAX_FMT_RESULT_THRESHOLD) {
				(*TTcl_Obj)(unsafe.Pointer(result)).Fbytes = XTclpRealloc(tls, (*TDateFormat)(unsafe.Pointer(dateFmt)).FresMem, size)
				if (*TTcl_Obj)(unsafe.Pointer(result)).Fbytes == libc.UintptrFromInt32(0) {
					(*TTcl_Obj)(unsafe.Pointer(result)).Fbytes = (*TDateFormat)(unsafe.Pointer(dateFmt)).FresMem
				}
			} else {
				(*TTcl_Obj)(unsafe.Pointer(result)).Fbytes = (*TDateFormat)(unsafe.Pointer(dateFmt)).FresMem
			}
		}
		/* save last used buffer length */
		if (*TDateFormat)(unsafe.Pointer(dateFmt)).FresMem != bp && (*TClockFmtScnStorage)(unsafe.Pointer(fss)).FfmtMinAlloc < size+uint64(MIN_FMT_RESULT_BLOCK_DELTA) {
			(*TClockFmtScnStorage)(unsafe.Pointer(fss)).FfmtMinAlloc = size + uint64(MIN_FMT_RESULT_BLOCK_DELTA)
		}
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(result)).Fbytes + uintptr((*TTcl_Obj)(unsafe.Pointer(result)).Flength))) = uint8('\000')
		XTcl_SetObjResult(tls, (*TClockFmtScnCmdArgs)(unsafe.Pointer(opts)).Finterp, result)
		return TCL_OK
	}
	return int32(TCL_ERROR)
}

func XClockFrmScnClearCaches(tls *libc.TLS) {
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_ClockFmtMutex)))
	/* clear caches ... */
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_ClockFmtMutex)))
}

func XClockFrmScnFinalize(tls *libc.TLS) {
	if !(_initialized1 != 0) {
		return
	}
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_ClockFmtMutex)))
	/* clear GC */
	_ClockFmtScnStorage_GC.FstackPtr = libc.UintptrFromInt32(0)
	_ClockFmtScnStorage_GC.FstackBound = libc.UintptrFromInt32(0)
	_ClockFmtScnStorage_GC.Fcount = uint32(0)
	if _initialized1 != 0 {
		_initialized1 = 0
		XTcl_DeleteHashTable(tls, uintptr(unsafe.Pointer(&_FmtScnHashTable)))
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_ClockFmtMutex)))
	XTcl_MutexFinalize(tls, uintptr(unsafe.Pointer(&_ClockFmtMutex)))
}

const BG_FLUSH_SCHEDULED = 128
const BUFFER_PADDING = 16
const CHANNELBUFFER_DEFAULT_SIZE = 4096
const CHANNEL_BLOCKED = 2048
const CHANNEL_CLOSED = 256
const CHANNEL_CLOSEDWRITE = 2097152
const CHANNEL_DEAD = 8192
const CHANNEL_ENCODING_ERROR = 32768
const CHANNEL_EOF = 512
const CHANNEL_INCLOSE = 524288
const CHANNEL_LINEBUFFERED = 131072
const CHANNEL_NEED_MORE_DATA = 16384
const CHANNEL_NONBLOCKING = 64
const CHANNEL_RAW_MODE = 65536
const CHANNEL_STICKY_EOF = 1024
const CHANNEL_UNBUFFERED = 262144
const INPUT_SAW_CR = 4096
const SYNTHETIC_EVENT_TIME = 0

type TChannelBuffer = struct {
	FrefCount    TTcl_Size
	FnextAdded   TTcl_Size
	FnextRemoved TTcl_Size
	FbufLength   TTcl_Size
	FnextPtr     uintptr
}

type TEventScriptRecord = struct {
	FchanPtr   uintptr
	FscriptPtr uintptr
	Finterp    uintptr
	Fmask      int32
	FnextPtr   uintptr
}

type TChannel = struct {
	Fstate        uintptr
	FinstanceData uintptr
	FtypePtr      uintptr
	FdownChanPtr  uintptr
	FupChanPtr    uintptr
	FinQueueHead  uintptr
	FinQueueTail  uintptr
	FrefCount     TTcl_Size
}

type TChannelState = struct {
	FchannelName         uintptr
	Fflags               int32
	Fencoding            TTcl_Encoding
	FinputEncodingState  TTcl_EncodingState
	FinputEncodingFlags  int32
	FoutputEncodingState TTcl_EncodingState
	FoutputEncodingFlags int32
	FinputTranslation    TTclEolTranslation
	FoutputTranslation   TTclEolTranslation
	FinEofChar           int32
	FunreportedError     int32
	FrefCount            TTcl_Size
	FcloseCbPtr          uintptr
	FoutputStage         uintptr
	FcurOutPtr           uintptr
	FoutQueueHead        uintptr
	FoutQueueTail        uintptr
	FsaveInBufPtr        uintptr
	FinQueueHead         uintptr
	FinQueueTail         uintptr
	FchPtr               uintptr
	FinterestMask        int32
	FscriptRecordPtr     uintptr
	FbufSize             TTcl_Size
	Ftimer               TTcl_TimerToken
	FtimerChanPtr        uintptr
	FcsPtrR              uintptr
	FcsPtrW              uintptr
	FtopChanPtr          uintptr
	FbottomChanPtr       uintptr
	FnextCSPtr           uintptr
	FmanagingThread      TTcl_ThreadId
	FchanMsg             uintptr
	FunreportedMsg       uintptr
	Fepoch               TTcl_Size
	FmaxPerms            int32
}

/* !END!: Do not edit above this line. */

/*
 * The state structure used by [foreach]. Note that the actual structure has
 * all its working arrays appended afterwards so they can be allocated and
 * freed in a single step.
 */

type TForeachState = struct {
	FbodyPtr    uintptr
	FbodyIdx    TTcl_Size
	Fj          TTcl_Size
	Fmaxj       TTcl_Size
	FnumLists   TTcl_Size
	Findex      uintptr
	FvarcList   uintptr
	FvarvList   uintptr
	FvCopyList  uintptr
	FargcList   uintptr
	FargvList   uintptr
	FaCopyList  uintptr
	FresultList uintptr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_BreakObjCmd --
 *
 *	This procedure is invoked to process the "break" Tcl command. See the
 *	user documentation for details on what it does.
 *
 *	With the bytecode compiler, this procedure is only called when a
 *	command name is computed at runtime, and is "break" or the name to
 *	which "break" was renamed: e.g., "set z break; $z"
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_BreakObjCmd(tls *libc.TLS, dummy125 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	if objc != int32(1) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, libc.UintptrFromInt32(0))
		return int32(TCL_ERROR)
	}
	return int32(TCL_BREAK)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_CatchObjCmd --
 *
 *	This object-based procedure is invoked to process the "catch" Tcl
 *	command. See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl object result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_CatchObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	return XTcl_NRCallObjProc(tls, interp, __ccgo_fp(XTclNRCatchObjCmd), clientData, int64(objc), objv)
}

func XTclNRCatchObjCmd(tls *libc.TLS, dummy166 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var _objPtr, cachePtr, iPtr, optionVarNamePtr, varNamePtr uintptr
	var v1 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _, _, _, _ = _objPtr, cachePtr, iPtr, optionVarNamePtr, varNamePtr, v1
	varNamePtr = libc.UintptrFromInt32(0)
	optionVarNamePtr = libc.UintptrFromInt32(0)
	iPtr = interp
	if objc < int32(2) || objc > int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+14862)
		return int32(TCL_ERROR)
	}
	if objc >= int32(3) {
		varNamePtr = *(*uintptr)(unsafe.Pointer(objv + 2*8))
	}
	if objc == int32(4) {
		optionVarNamePtr = *(*uintptr)(unsafe.Pointer(objv + 3*8))
	}
	if v1 = interp == libc.UintptrFromInt32(0); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(_CatchObjCmdCallback)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = uintptr(int64(objc))
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = varNamePtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = optionVarNamePtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
	/*
	 * TIP #280. Make invoking context available to caught script.
	 */
	return XTclNREvalObjEx(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), 0, (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr, int32(1))
}

func _CatchObjCmdCallback(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var iPtr, optionVarNamePtr, options, varNamePtr uintptr
	var objc, rewind int32
	_, _, _, _, _, _ = iPtr, objc, optionVarNamePtr, options, rewind, varNamePtr
	iPtr = interp
	objc = int32(int64(*(*uintptr)(unsafe.Pointer(data))))
	varNamePtr = *(*uintptr)(unsafe.Pointer(data + 1*8))
	optionVarNamePtr = *(*uintptr)(unsafe.Pointer(data + 2*8))
	rewind = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FexecEnvPtr)).Frewind
	/*
	 * We disable catch in interpreters where the limit has been exceeded.
	 */
	if rewind != 0 || XTcl_LimitExceeded(tls, interp) != 0 {
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+14901, libc.VaList(bp+8, XTcl_GetErrorLine(tls, interp))))
		return int32(TCL_ERROR)
	}
	if objc >= int32(3) {
		if libc.UintptrFromInt32(0) == XTcl_ObjSetVar2(tls, interp, varNamePtr, libc.UintptrFromInt32(0), XTcl_GetObjResult(tls, interp), int32(TCL_LEAVE_ERR_MSG)) {
			return int32(TCL_ERROR)
		}
	}
	if objc == int32(4) {
		options = XTcl_GetReturnOptions(tls, interp, result)
		if libc.UintptrFromInt32(0) == XTcl_ObjSetVar2(tls, interp, optionVarNamePtr, libc.UintptrFromInt32(0), options, int32(TCL_LEAVE_ERR_MSG)) {
			/* Do not decrRefCount 'options', it was already done by
			 * Tcl_ObjSetVar2 */
			return int32(TCL_ERROR)
		}
	}
	XTcl_ResetResult(tls, interp)
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, int64(result)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_CdObjCmd --
 *
 *	This procedure is invoked to process the "cd" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_CdObjCmd(tls *libc.TLS, dummy261 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(256)
	defer tls.Free(256) /* Argument objects. */
	var _objPtr, dir, v1, v2, v4 uintptr
	var result int32
	var v3 TTcl_Size
	var _ /* ds at bp+0 */ TTcl_DString
	_, _, _, _, _, _, _ = _objPtr, dir, result, v1, v2, v3, v4
	if objc > int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+14929)
		return int32(TCL_ERROR)
	}
	if objc == int32(2) {
		dir = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	} else {
		dir = XTclGetHomeDirObj(tls, interp, libc.UintptrFromInt32(0))
		if dir == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
		(*TTcl_Obj)(unsafe.Pointer(dir)).FrefCount++
	}
	if XTcl_FSConvertToPathType(tls, interp, dir) != TCL_OK {
		result = int32(TCL_ERROR)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(dir)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(dir)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, dir, libc.UintptrFromInt32(0))
		}
		result = XTcl_UtfToExternalDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), v1, int64(-int32(1)), 0, bp, libc.UintptrFromInt32(0))
		XTcl_DStringFree(tls, bp)
		if result == TCL_OK {
			result = XTcl_FSChdir(tls, dir)
		}
		if result != TCL_OK {
			if (*TTcl_Obj)(unsafe.Pointer(dir)).Fbytes != 0 {
				v2 = (*TTcl_Obj)(unsafe.Pointer(dir)).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, dir, libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+14939, libc.VaList(bp+232, v2, XTcl_PosixError(tls, interp))))
			result = int32(TCL_ERROR)
		}
	}
	if objc != int32(2) {
		_objPtr = dir
		v4 = _objPtr
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ConcatObjCmd --
 *
 *	This object-based procedure is invoked to process the "concat" Tcl
 *	command. See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl object result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ConcatObjCmd(tls *libc.TLS, dummy324 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	if objc >= int32(2) {
		XTcl_SetObjResult(tls, interp, XTcl_ConcatObj(tls, int64(objc-int32(1)), objv+uintptr(1)*8))
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ContinueObjCmd --
 *
 *	This procedure is invoked to process the "continue" Tcl command. See
 *	the user documentation for details on what it does.
 *
 *	With the bytecode compiler, this procedure is only called when a
 *	command name is computed at runtime, and is "continue" or the name to
 *	which "continue" was renamed: e.g., "set z continue; $z"
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ContinueObjCmd(tls *libc.TLS, dummy358 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	if objc != int32(1) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, libc.UintptrFromInt32(0))
		return int32(TCL_ERROR)
	}
	return int32(TCL_CONTINUE)
}

/*
 *-----------------------------------------------------------------------------
 *
 * TclInitEncodingCmd --
 *
 *	This function creates the 'encoding' ensemble.
 *
 * Results:
 *	Returns the Tcl_Command so created.
 *
 * Side effects:
 *	The ensemble is initialized.
 *
 * This command is hidden in a safe interpreter.
 */

func XTclInitEncodingCmd(tls *libc.TLS, interp uintptr) (r TTcl_Command) {
	return XTclMakeEnsemble(tls, interp, __ccgo_ts+5615, uintptr(unsafe.Pointer(&_encodingImplMap)))
}

/* Tcl interpreter */
var _encodingImplMap = [7]TEnsembleImplMap{
	0: {
		Fname: __ccgo_ts + 14985,
	},
	1: {
		Fname: __ccgo_ts + 14997,
	},
	2: {
		Fname:   __ccgo_ts + 5624,
		Funsafe: int32(1),
	},
	3: {
		Fname: __ccgo_ts + 15007,
	},
	4: {
		Fname: __ccgo_ts + 15013,
	},
	5: {
		Fname:   __ccgo_ts + 5629,
		Funsafe: int32(1),
	},
	6: {},
}

func init() {
	p := unsafe.Pointer(&_encodingImplMap)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_EncodingConvertfromObjCmd)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(XTclCompileBasic1To3ArgCmd)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(_EncodingConverttoObjCmd)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(XTclCompileBasic1To3ArgCmd)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(_EncodingDirsObjCmd)
	*(*uintptr)(unsafe.Add(p, 112)) = __ccgo_fp(XTclCompileBasic0Or1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 152)) = __ccgo_fp(_EncodingNamesObjCmd)
	*(*uintptr)(unsafe.Add(p, 160)) = __ccgo_fp(XTclCompileBasic0ArgCmd)
	*(*uintptr)(unsafe.Add(p, 200)) = __ccgo_fp(_EncodingProfilesObjCmd)
	*(*uintptr)(unsafe.Add(p, 208)) = __ccgo_fp(XTclCompileBasic0ArgCmd)
	*(*uintptr)(unsafe.Add(p, 248)) = __ccgo_fp(_EncodingSystemObjCmd)
	*(*uintptr)(unsafe.Add(p, 256)) = __ccgo_fp(XTclCompileBasic0Or1ArgCmd)
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * EncodingConvertParseOptions --
//	 *
//	 *    Common routine for parsing arguments passed to encoding convertfrom
//	 *    and encoding convertto.
//	 *
//	 * Results:
//	 *    TCL_OK or TCL_ERROR.
//	 *
//	 * Side effects:
//	 *    On success,
//	 *    - *encPtr is set to the encoding. Must be freed with Tcl_FreeEncoding
//	 *      if non-NULL
//	 *    - *dataObjPtr is set to the Tcl_Obj containing the data to encode or
//	 *      decode
//	 *    - *profilePtr is set to encoding error handling profile
//	 *    - *failVarPtr is set to -failindex option value or NULL
//	 *    On error, all of the above are uninitialized.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _EncodingConvertParseOptions(tls *libc.TLS, interp uintptr, objc int32, objv uintptr, encPtr uintptr, dataObjPtr uintptr, profilePtr uintptr, failVarPtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Where to store -failindex option value */
	var argIndex, v3 int32
	var dataObj, failVarObj uintptr
	var _ /* encoding at bp+8 */ TTcl_Encoding
	var _ /* optIndex at bp+0 */ int32
	var _ /* profile at bp+16 */ int32
	_, _, _, _ = argIndex, dataObj, failVarObj, v3
	*(*int32)(unsafe.Pointer(bp + 16)) = TCL_ENCODING_STOPONERROR
	/*
	 * Possible combinations:
	 * 1) data						-> objc = 2
	 * 2) ?options? encoding data			-> objc >= 3
	 * It is intentional that specifying option forces encoding to be
	 * specified. Less prone to user error. This should have always been
	 * the case even in 8.6 imho where there were no options (ie (1)
	 * should never have been allowed)
	 */
	if !(objc == int32(1)) {
		goto _1
	}
	goto numArgsError
numArgsError:
	; /* ONLY jump here if nothing needs to be freed!!! */
	XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+15042)
	*(*int32)(unsafe.Pointer(interp + 368)) |= int32(INTERP_ALTERNATE_WRONG_ARGS)
	XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+11029)
	return int32(TCL_ERROR)
_1:
	;
	failVarObj = libc.UintptrFromInt32(0)
	if objc == int32(2) {
		*(*TTcl_Encoding)(unsafe.Pointer(bp + 8)) = XTcl_GetEncoding(tls, interp, libc.UintptrFromInt32(0))
		dataObj = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	} else {
		argIndex = int32(1)
		for {
			if !(argIndex < objc-int32(2)) {
				break
			}
			if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(argIndex)*8)), uintptr(unsafe.Pointer(&_options2)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
				return int32(TCL_ERROR)
			}
			argIndex++
			v3 = argIndex
			if v3 == objc-int32(2) {
				goto numArgsError
			}
			switch *(*int32)(unsafe.Pointer(bp)) {
			case 0:
				if XTclEncodingProfileNameToId(tls, interp, XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(argIndex)*8)), libc.UintptrFromInt32(0)), bp+16) != TCL_OK {
					return int32(TCL_ERROR)
				}
			case 1:
				failVarObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(argIndex)*8))
				break
			}
			goto _2
		_2:
			;
			argIndex++
		}
		/* Get encoding after opts so no need to free it on option error */
		if XTcl_GetEncodingFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)), bp+8) != TCL_OK {
			return int32(TCL_ERROR)
		}
		dataObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8))
	}
	*(*TTcl_Encoding)(unsafe.Pointer(encPtr)) = *(*TTcl_Encoding)(unsafe.Pointer(bp + 8))
	*(*uintptr)(unsafe.Pointer(dataObjPtr)) = dataObj
	*(*int32)(unsafe.Pointer(profilePtr)) = *(*int32)(unsafe.Pointer(bp + 16))
	*(*uintptr)(unsafe.Pointer(failVarPtr)) = failVarObj
	return TCL_OK
}

var _options2 = [3]uintptr{
	0: __ccgo_ts + 15022,
	1: __ccgo_ts + 15031,
	2: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * EncodingConvertfromObjCmd --
 *
 *	This command converts a byte array in an external encoding into a
 *	Tcl string
 *
 * Results:
 *	A standard Tcl result.
 *
 *----------------------------------------------------------------------
 */

func _EncodingConvertfromObjCmd(tls *libc.TLS, dummy519 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(272)
	defer tls.Free(272) /* Argument objects. */
	var bytesPtr, cachePtr, failIndex, v1 uintptr
	var result int32
	var v2 bool
	var _ /* data at bp+0 */ uintptr
	var _ /* ds at bp+8 */ TTcl_DString
	var _ /* encoding at bp+232 */ TTcl_Encoding
	var _ /* errorLocation at bp+264 */ TTcl_Size
	var _ /* failVarObj at bp+256 */ uintptr
	var _ /* flags at bp+248 */ int32
	var _ /* length at bp+240 */ TTcl_Size
	_, _, _, _, _, _ = bytesPtr, cachePtr, failIndex, result, v1, v2 /* Encoding to use */
	*(*TTcl_Size)(unsafe.Pointer(bp + 240)) = 0
	if _EncodingConvertParseOptions(tls, interp, objc, objv, bp+232, bp, bp+248, bp+256) != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Convert the string into a byte array in 'ds'.
	 */
	bytesPtr = XTcl_GetBytesFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), bp+240)
	if bytesPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if *(*uintptr)(unsafe.Pointer(bp + 256)) != 0 {
		v1 = bp + 264
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	result = XTcl_ExternalToUtfDStringEx(tls, interp, *(*TTcl_Encoding)(unsafe.Pointer(bp + 232)), bytesPtr, *(*TTcl_Size)(unsafe.Pointer(bp + 240)), *(*int32)(unsafe.Pointer(bp + 248)), bp+8, v1)
	/* NOTE: ds must be freed beyond this point even on error */
	switch result {
	case TCL_OK:
		*(*TTcl_Size)(unsafe.Pointer(bp + 264)) = int64(-libc.Int32FromInt32(1))
	case int32(TCL_ERROR):
		/* Error in parameters. Should not happen. interp will have error */
		XTcl_DStringFree(tls, bp+8)
		return int32(TCL_ERROR)
	default:
		/*
		 * One of the TCL_CONVERT_* errors. If we were not interested in the
		 * error location, interp result would already have been filled in
		 * and we can just return the error. Otherwise, we have to return
		 * what could be decoded and the returned error location.
		 */
		if *(*uintptr)(unsafe.Pointer(bp + 256)) == libc.UintptrFromInt32(0) {
			XTcl_DStringFree(tls, bp+8)
			return int32(TCL_ERROR)
		}
		break
	}
	/*
	 * TCL_OK or a TCL_CONVERT_* error where the caller wants back as much
	 * data as was converted.
	 */
	if *(*uintptr)(unsafe.Pointer(bp + 256)) != 0 {
		if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			failIndex = XTclThreadAllocObj(tls)
		} else {
			failIndex = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(failIndex + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(failIndex)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(failIndex)).Fbytes = libc.UintptrFromInt32(0)
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(failIndex)).FinternalRep)) = *(*TTcl_Size)(unsafe.Pointer(bp + 264))
		(*TTcl_Obj)(unsafe.Pointer(failIndex)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
		if XTcl_ObjSetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 256)), libc.UintptrFromInt32(0), failIndex, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
			XTcl_DStringFree(tls, bp+8)
			return int32(TCL_ERROR)
		}
	}
	/*
	 * Note that we cannot use Tcl_DStringResult here because it will
	 * truncate the string at the first null byte.
	 */
	XTcl_SetObjResult(tls, interp, XTcl_DStringToObj(tls, bp+8))
	/* We're done with the encoding */
	XTcl_FreeEncoding(tls, *(*TTcl_Encoding)(unsafe.Pointer(bp + 232)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * EncodingConverttoObjCmd --
 *
 *	This command converts a Tcl string into a byte array that
 *	encodes the string according to some encoding.
 *
 * Results:
 *	A standard Tcl result.
 *
 *----------------------------------------------------------------------
 */

func _EncodingConverttoObjCmd(tls *libc.TLS, dummy615 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(272)
	defer tls.Free(272) /* Argument objects. */
	var cachePtr, failIndex, stringPtr, v1, v2 uintptr
	var result int32
	var v3 bool
	var _ /* data at bp+0 */ uintptr
	var _ /* ds at bp+8 */ TTcl_DString
	var _ /* encoding at bp+232 */ TTcl_Encoding
	var _ /* errorLocation at bp+264 */ TTcl_Size
	var _ /* failVarObj at bp+256 */ uintptr
	var _ /* flags at bp+248 */ int32
	var _ /* length at bp+240 */ TTcl_Size
	_, _, _, _, _, _, _ = cachePtr, failIndex, result, stringPtr, v1, v2, v3
	if _EncodingConvertParseOptions(tls, interp, objc, objv, bp+232, bp, bp+248, bp+256) != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Convert the string to a byte array in 'ds'
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 240)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+240)
	}
	stringPtr = v1
	if *(*uintptr)(unsafe.Pointer(bp + 256)) != 0 {
		v2 = bp + 264
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	result = XTcl_UtfToExternalDStringEx(tls, interp, *(*TTcl_Encoding)(unsafe.Pointer(bp + 232)), stringPtr, *(*TTcl_Size)(unsafe.Pointer(bp + 240)), *(*int32)(unsafe.Pointer(bp + 248)), bp+8, v2)
	/* NOTE: ds must be freed beyond this point even on error */
	switch result {
	case TCL_OK:
		*(*TTcl_Size)(unsafe.Pointer(bp + 264)) = int64(-libc.Int32FromInt32(1))
	case int32(TCL_ERROR):
		/* Error in parameters. Should not happen. interp will have error */
		XTcl_DStringFree(tls, bp+8)
		return int32(TCL_ERROR)
	default:
		/*
		 * One of the TCL_CONVERT_* errors. If we were not interested in the
		 * error location, interp result would already have been filled in
		 * and we can just return the error. Otherwise, we have to return
		 * what could be decoded and the returned error location.
		 */
		if *(*uintptr)(unsafe.Pointer(bp + 256)) == libc.UintptrFromInt32(0) {
			XTcl_DStringFree(tls, bp+8)
			return int32(TCL_ERROR)
		}
		break
	}
	/*
	 * TCL_OK or a TCL_CONVERT_* error where the caller wants back as much
	 * data as was converted.
	 */
	if *(*uintptr)(unsafe.Pointer(bp + 256)) != 0 {
		if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			failIndex = XTclThreadAllocObj(tls)
		} else {
			failIndex = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(failIndex + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(failIndex)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(failIndex)).Fbytes = libc.UintptrFromInt32(0)
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(failIndex)).FinternalRep)) = *(*TTcl_Size)(unsafe.Pointer(bp + 264))
		(*TTcl_Obj)(unsafe.Pointer(failIndex)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
		if XTcl_ObjSetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 256)), libc.UintptrFromInt32(0), failIndex, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
			XTcl_DStringFree(tls, bp+8)
			return int32(TCL_ERROR)
		}
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewByteArrayObj(tls, (*TTcl_DString)(unsafe.Pointer(bp+8)).Fstring1, (*TTcl_DString)(unsafe.Pointer(bp+8)).Flength))
	XTcl_DStringFree(tls, bp+8)
	/* We're done with the encoding */
	XTcl_FreeEncoding(tls, *(*TTcl_Encoding)(unsafe.Pointer(bp + 232)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * EncodingDirsObjCmd --
 *
 *	This command manipulates the encoding search path.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Can set the encoding search path.
 *
 *----------------------------------------------------------------------
 */

func _EncodingDirsObjCmd(tls *libc.TLS, dummy710 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument objects. */
	var dirListObj, v1 uintptr
	_, _ = dirListObj, v1
	if objc > int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+15092)
		return int32(TCL_ERROR)
	}
	if objc == int32(1) {
		XTcl_SetObjResult(tls, interp, XTcl_GetEncodingSearchPath(tls))
		return TCL_OK
	}
	dirListObj = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	if XTcl_SetEncodingSearchPath(tls, dirListObj) == int32(TCL_ERROR) {
		if (*TTcl_Obj)(unsafe.Pointer(dirListObj)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(dirListObj)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, dirListObj, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+15102, libc.VaList(bp+8, v1)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+15139, __ccgo_ts+15148, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, dirListObj)
	return TCL_OK
}

/*
 *-----------------------------------------------------------------------------
 *
 * EncodingNamesObjCmd --
 *
 *	This command returns a list of the available encoding names
 *
 * Results:
 *	Returns a standard Tcl result
 *
 *-----------------------------------------------------------------------------
 */

func _EncodingNamesObjCmd(tls *libc.TLS, dummy754 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Vector of command line args */
	if objc > int32(1) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, libc.UintptrFromInt32(0))
		return int32(TCL_ERROR)
	}
	XTcl_GetEncodingNames(tls, interp)
	return TCL_OK
}

/*
 *-----------------------------------------------------------------------------
 *
 * EncodingProfilesObjCmd --
 *
 *	This command returns a list of the available encoding profiles
 *
 * Results:
 *	Returns a standard Tcl result
 *
 *-----------------------------------------------------------------------------
 */

func _EncodingProfilesObjCmd(tls *libc.TLS, dummy782 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Vector of command line args */
	if objc > int32(1) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, libc.UintptrFromInt32(0))
		return int32(TCL_ERROR)
	}
	XTclGetEncodingProfiles(tls, interp)
	return TCL_OK
}

/*
 *-----------------------------------------------------------------------------
 *
 * EncodingSystemObjCmd --
 *
 *	This command retrieves or changes the system encoding
 *
 * Results:
 *	Returns a standard Tcl result
 *
 * Side effects:
 *	May change the system encoding.
 *
 *-----------------------------------------------------------------------------
 */

func _EncodingSystemObjCmd(tls *libc.TLS, dummy813 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Vector of command line args */
	var v1 uintptr
	_ = v1
	if objc > int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+15156)
		return int32(TCL_ERROR)
	}
	if objc == int32(1) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, XTcl_GetEncodingName(tls, libc.UintptrFromInt32(0)), int64(-int32(1))))
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
		}
		return XTcl_SetSystemEncoding(tls, interp, v1)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ErrorObjCmd --
 *
 *	This procedure is invoked to process the "error" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl object result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ErrorObjCmd(tls *libc.TLS, dummy850 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var cachePtr, cachePtr1, cachePtr2, optName, options uintptr
	var v1, v2, v3 bool
	_, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, optName, options, v1, v2, v3
	if objc < int32(2) || objc > int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+15167)
		return int32(TCL_ERROR)
	}
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		options = XTclThreadAllocObj(tls)
	} else {
		options = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(options + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(options)).FrefCount = 0
	if libc.Uint64FromInt64(21)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(options)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(options)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(options)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(21)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(options)).Fbytes, __ccgo_ts+15199, libc.Uint64FromInt64(21)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(options)).Fbytes + uintptr(libc.Uint64FromInt64(21)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(options)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(21) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(options)).FtypePtr = libc.UintptrFromInt32(0)
	if objc >= int32(3) { /* Process the optional info argument */
		if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			optName = XTclThreadAllocObj(tls)
		} else {
			optName = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(optName + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(optName)).FrefCount = 0
		if libc.Uint64FromInt64(11)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer(optName)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(optName)).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(optName)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(11)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(optName)).Fbytes, __ccgo_ts+15220, libc.Uint64FromInt64(11)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(optName)).Fbytes + uintptr(libc.Uint64FromInt64(11)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(optName)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(11) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer(optName)).FtypePtr = libc.UintptrFromInt32(0)
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), options, optName)
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), options, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
	}
	if objc >= int32(4) { /* Process the optional code argument */
		if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
			cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
			optName = XTclThreadAllocObj(tls)
		} else {
			optName = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(optName + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(optName)).FrefCount = 0
		if libc.Uint64FromInt64(11)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer(optName)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(optName)).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(optName)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(11)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(optName)).Fbytes, __ccgo_ts+15231, libc.Uint64FromInt64(11)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(optName)).Fbytes + uintptr(libc.Uint64FromInt64(11)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(optName)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(11) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer(optName)).FtypePtr = libc.UintptrFromInt32(0)
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), options, optName)
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), options, *(*uintptr)(unsafe.Pointer(objv + 3*8)))
	}
	XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	return XTcl_SetReturnOptions(tls, interp, options)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_EvalObjCmd --
 *
 *	This object-based procedure is invoked to process the "eval" Tcl
 *	command. See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl object result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _EvalCmdErrMsg(tls *libc.TLS, dummy899 uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	if result == int32(TCL_ERROR) {
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+15242, libc.VaList(bp+8, XTcl_GetErrorLine(tls, interp))))
	}
	return result
}

func XTcl_EvalObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	return XTcl_NRCallObjProc(tls, interp, __ccgo_fp(XTclNREvalObjCmd), clientData, int64(objc), objv)
}

func XTclNREvalObjCmd(tls *libc.TLS, dummy922 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Argument objects. */
	var _objPtr, cachePtr, iPtr, objPtr uintptr
	var v1 bool
	var _ /* _callbackPtr at bp+16 */ uintptr
	var _ /* invoker at bp+0 */ uintptr
	var _ /* word at bp+8 */ int32
	_, _, _, _, _ = _objPtr, cachePtr, iPtr, objPtr, v1
	iPtr = interp
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	*(*int32)(unsafe.Pointer(bp + 8)) = 0
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+15269)
		return int32(TCL_ERROR)
	}
	if objc == int32(2) {
		/*
		 * TIP #280. Make argument location available to eval'd script.
		 */
		*(*uintptr)(unsafe.Pointer(bp)) = (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr
		*(*int32)(unsafe.Pointer(bp + 8)) = int32(1)
		objPtr = *(*uintptr)(unsafe.Pointer(objv + 1*8))
		XTclArgumentGet(tls, interp, objPtr, bp, bp+8)
	} else {
		/*
		 * More than one argument: concatenate them together with spaces
		 * between, then evaluate the result. Tcl_EvalObjEx will delete the
		 * object when it decrements its refcount after eval'ing it.
		 *
		 * TIP #280. Make invoking context available to eval'd script, done
		 * with the default values.
		 */
		objPtr = XTcl_ConcatObj(tls, int64(objc-int32(1)), objv+uintptr(1)*8)
	}
	if v1 = interp == libc.UintptrFromInt32(0); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 16)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FprocPtr = __ccgo_fp(_EvalCmdErrMsg)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 16))
	return XTclNREvalObjEx(tls, interp, objPtr, 0, *(*uintptr)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 8)))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ExitObjCmd --
 *
 *	This procedure is invoked to process the "exit" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl object result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ExitObjCmd(tls *libc.TLS, dummy981 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var _ /* value at bp+0 */ TTcl_WideInt
	if objc != int32(1) && objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+15283)
		return int32(TCL_ERROR)
	}
	if objc == int32(1) {
		*(*TTcl_WideInt)(unsafe.Pointer(bp)) = 0
	} else {
		if XTclGetWideBitsFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp) != TCL_OK {
			return int32(TCL_ERROR)
		}
	}
	XTcl_Exit(tls, int32(*(*TTcl_WideInt)(unsafe.Pointer(bp))))
	return TCL_OK /* Better not ever reach this! */
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ExprObjCmd --
 *
 *	This object-based procedure is invoked to process the "expr" Tcl
 *	command. See the user documentation for details on what it does.
 *
 *	With the bytecode compiler, this procedure is called in two
 *	circumstances: 1) to execute expr commands that are too complicated or
 *	too unsafe to try compiling directly into an inline sequence of
 *	instructions, and 2) to execute commands where the command name is
 *	computed at runtime and is "expr" or the name to which "expr" was
 *	renamed (e.g., "set z expr; $z 2+3")
 *
 * Results:
 *	A standard Tcl object result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ExprObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	return XTcl_NRCallObjProc(tls, interp, __ccgo_fp(XTclNRExprObjCmd), clientData, int64(objc), objv)
}

func XTclNRExprObjCmd(tls *libc.TLS, dummy1038 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var _objPtr, _objPtr1, cachePtr, cachePtr1, cachePtr2, objPtr, resultPtr uintptr
	var v1, v2, v3 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	var _ /* _callbackPtr at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, cachePtr1, cachePtr2, objPtr, resultPtr, v1, v2, v3
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+15269)
		return int32(TCL_ERROR)
	}
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultPtr = XTclThreadAllocObj(tls)
	} else {
		resultPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount++
	if objc == int32(2) {
		objPtr = *(*uintptr)(unsafe.Pointer(objv + 1*8))
		if v2 = interp == libc.UintptrFromInt32(0); !v2 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
		}
		if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			_objPtr = XTclThreadAllocObj(tls)
		} else {
			_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(_objPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(_ExprCallback)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = resultPtr
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
		(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
	} else {
		objPtr = XTcl_ConcatObj(tls, int64(objc-int32(1)), objv+uintptr(1)*8)
		if v3 = interp == libc.UintptrFromInt32(0); !v3 {
			cachePtr2 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
		}
		if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
			_objPtr1 = XTclThreadAllocObj(tls)
		} else {
			_objPtr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(_objPtr1 + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = _objPtr1
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FprocPtr = __ccgo_fp(_ExprCallback)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8)) = resultPtr
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 1*8)) = objPtr
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
		(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
	}
	return XTcl_NRExprObj(tls, interp, objPtr, resultPtr)
}

func _ExprCallback(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	var _objPtr, _objPtr1, objPtr, resultPtr, v2, v4 uintptr
	var v1, v3 TTcl_Size
	_, _, _, _, _, _, _, _ = _objPtr, _objPtr1, objPtr, resultPtr, v1, v2, v3, v4
	resultPtr = *(*uintptr)(unsafe.Pointer(data))
	objPtr = *(*uintptr)(unsafe.Pointer(data + 1*8))
	if objPtr != libc.UintptrFromInt32(0) {
		_objPtr = objPtr
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	if result == TCL_OK {
		XTcl_SetObjResult(tls, interp, resultPtr)
	}
	_objPtr1 = resultPtr
	v4 = _objPtr1
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	if v3 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * TclInitFileCmd --
 *
 *	This function builds the "file" Tcl command ensemble. See the user
 *	documentation for details on what that ensemble does.
 *
 *	PLEASE NOTE THAT THIS FAILS WITH FILENAMES AND PATHS WITH EMBEDDED
 *	NULLS. With the object-based Tcl_FS APIs, the above NOTE may no longer
 *	be true. In any case this assertion should be tested.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTclInitFileCmd(tls *libc.TLS, interp uintptr) (r TTcl_Command) {
	return XTclMakeEnsemble(tls, interp, __ccgo_ts+5636, uintptr(unsafe.Pointer(&_initMap)))
}

/*
 * Note that most subcommands are unsafe because either they manipulate
 * the native filesystem or because they reveal information about the
 * native filesystem.
 */

var _initMap = [38]TEnsembleImplMap{
	0: {
		Fname:   __ccgo_ts + 5641,
		Funsafe: int32(1),
	},
	1: {
		Fname:   __ccgo_ts + 5647,
		Funsafe: int32(1),
	},
	2: {
		Fname: __ccgo_ts + 15296,
	},
	3: {
		Fname:   __ccgo_ts + 5658,
		Funsafe: int32(1),
	},
	4: {
		Fname:   __ccgo_ts + 5663,
		Funsafe: int32(1),
	},
	5: {
		Fname:   __ccgo_ts + 5670,
		Funsafe: int32(1),
	},
	6: {
		Fname:   __ccgo_ts + 5678,
		Funsafe: int32(1),
	},
	7: {
		Fname:   __ccgo_ts + 5689,
		Funsafe: int32(1),
	},
	8: {
		Fname:   __ccgo_ts + 5696,
		Funsafe: int32(1),
	},
	9: {
		Fname:   __ccgo_ts + 5706,
		Funsafe: int32(1),
	},
	10: {
		Fname:   __ccgo_ts + 5711,
		Funsafe: int32(1),
	},
	11: {
		Fname:   __ccgo_ts + 5723,
		Funsafe: int32(1),
	},
	12: {
		Fname: __ccgo_ts + 5227,
	},
	13: {
		Fname:   __ccgo_ts + 5730,
		Funsafe: int32(1),
	},
	14: {
		Fname:   __ccgo_ts + 5735,
		Funsafe: int32(1),
	},
	15: {
		Fname:   __ccgo_ts + 5741,
		Funsafe: int32(1),
	},
	16: {
		Fname:   __ccgo_ts + 5747,
		Funsafe: int32(1),
	},
	17: {
		Fname:   __ccgo_ts + 5753,
		Funsafe: int32(1),
	},
	18: {
		Fname:   __ccgo_ts + 5764,
		Funsafe: int32(1),
	},
	19: {
		Fname:   __ccgo_ts + 5774,
		Funsafe: int32(1),
	},
	20: {
		Fname: __ccgo_ts + 15305,
	},
	21: {
		Fname:   __ccgo_ts + 5780,
		Funsafe: int32(1),
	},
	22: {
		Fname:   __ccgo_ts + 5789,
		Funsafe: int32(1),
	},
	23: {
		Fname:   __ccgo_ts + 5364,
		Funsafe: int32(1),
	},
	24: {
		Fname:   __ccgo_ts + 5798,
		Funsafe: int32(1),
	},
	25: {
		Fname: __ccgo_ts + 15314,
	},
	26: {
		Fname:   __ccgo_ts + 5807,
		Funsafe: int32(1),
	},
	27: {
		Fname: __ccgo_ts + 5387,
	},
	28: {
		Fname:   __ccgo_ts + 5812,
		Funsafe: int32(1),
	},
	29: {
		Fname: __ccgo_ts + 5629,
	},
	30: {
		Fname:   __ccgo_ts + 5817,
		Funsafe: int32(1),
	},
	31: {
		Fname:   __ccgo_ts + 5822,
		Funsafe: int32(1),
	},
	32: {
		Fname:   __ccgo_ts + 5830,
		Funsafe: int32(1),
	},
	33: {
		Fname:   __ccgo_ts + 5839,
		Funsafe: int32(1),
	},
	34: {
		Fname:   __ccgo_ts + 5851,
		Funsafe: int32(1),
	},
	35: {
		Fname:   __ccgo_ts + 5856,
		Funsafe: int32(1),
	},
	36: {
		Fname:   __ccgo_ts + 5864,
		Funsafe: int32(1),
	},
	37: {},
}

func init() {
	p := unsafe.Pointer(&_initMap)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_FileAttrAccessTimeCmd)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(XTclCompileBasic1Or2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(XTclFileAttrsCmd)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(XTclChannelNamesCmd)
	*(*uintptr)(unsafe.Add(p, 112)) = __ccgo_fp(XTclCompileBasic0Or1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 152)) = __ccgo_fp(XTclFileCopyCmd)
	*(*uintptr)(unsafe.Add(p, 200)) = __ccgo_fp(XTclFileDeleteCmd)
	*(*uintptr)(unsafe.Add(p, 208)) = __ccgo_fp(XTclCompileBasicMin0ArgCmd)
	*(*uintptr)(unsafe.Add(p, 248)) = __ccgo_fp(_PathDirNameCmd)
	*(*uintptr)(unsafe.Add(p, 256)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 296)) = __ccgo_fp(_FileAttrIsExecutableCmd)
	*(*uintptr)(unsafe.Add(p, 304)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 344)) = __ccgo_fp(_FileAttrIsExistingCmd)
	*(*uintptr)(unsafe.Add(p, 352)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 392)) = __ccgo_fp(_PathExtensionCmd)
	*(*uintptr)(unsafe.Add(p, 400)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 440)) = __ccgo_fp(XTclFileHomeCmd)
	*(*uintptr)(unsafe.Add(p, 448)) = __ccgo_fp(XTclCompileBasic0Or1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 488)) = __ccgo_fp(_FileAttrIsDirectoryCmd)
	*(*uintptr)(unsafe.Add(p, 496)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 536)) = __ccgo_fp(_FileAttrIsFileCmd)
	*(*uintptr)(unsafe.Add(p, 544)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 584)) = __ccgo_fp(_PathJoinCmd)
	*(*uintptr)(unsafe.Add(p, 592)) = __ccgo_fp(XTclCompileBasicMin1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 632)) = __ccgo_fp(XTclFileLinkCmd)
	*(*uintptr)(unsafe.Add(p, 640)) = __ccgo_fp(XTclCompileBasic1To3ArgCmd)
	*(*uintptr)(unsafe.Add(p, 680)) = __ccgo_fp(_FileAttrLinkStatCmd)
	*(*uintptr)(unsafe.Add(p, 688)) = __ccgo_fp(XTclCompileBasic2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 728)) = __ccgo_fp(_FileAttrModifyTimeCmd)
	*(*uintptr)(unsafe.Add(p, 736)) = __ccgo_fp(XTclCompileBasic1Or2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 776)) = __ccgo_fp(XTclFileMakeDirsCmd)
	*(*uintptr)(unsafe.Add(p, 784)) = __ccgo_fp(XTclCompileBasicMin0ArgCmd)
	*(*uintptr)(unsafe.Add(p, 824)) = __ccgo_fp(_PathNativeNameCmd)
	*(*uintptr)(unsafe.Add(p, 832)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 872)) = __ccgo_fp(_PathNormalizeCmd)
	*(*uintptr)(unsafe.Add(p, 880)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 920)) = __ccgo_fp(_FileAttrIsOwnedCmd)
	*(*uintptr)(unsafe.Add(p, 928)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 968)) = __ccgo_fp(_PathTypeCmd)
	*(*uintptr)(unsafe.Add(p, 976)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 1016)) = __ccgo_fp(_FileAttrIsReadableCmd)
	*(*uintptr)(unsafe.Add(p, 1024)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 1064)) = __ccgo_fp(XTclFileReadLinkCmd)
	*(*uintptr)(unsafe.Add(p, 1072)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 1112)) = __ccgo_fp(XTclFileRenameCmd)
	*(*uintptr)(unsafe.Add(p, 1160)) = __ccgo_fp(_PathRootNameCmd)
	*(*uintptr)(unsafe.Add(p, 1168)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 1208)) = __ccgo_fp(_FilesystemSeparatorCmd)
	*(*uintptr)(unsafe.Add(p, 1216)) = __ccgo_fp(XTclCompileBasic0Or1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 1256)) = __ccgo_fp(_FileAttrSizeCmd)
	*(*uintptr)(unsafe.Add(p, 1264)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 1304)) = __ccgo_fp(_PathSplitCmd)
	*(*uintptr)(unsafe.Add(p, 1312)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 1352)) = __ccgo_fp(_FileAttrStatCmd)
	*(*uintptr)(unsafe.Add(p, 1360)) = __ccgo_fp(XTclCompileBasic2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 1400)) = __ccgo_fp(_PathFilesystemCmd)
	*(*uintptr)(unsafe.Add(p, 1408)) = __ccgo_fp(XTclCompileBasic0Or1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 1448)) = __ccgo_fp(_PathTailCmd)
	*(*uintptr)(unsafe.Add(p, 1456)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 1496)) = __ccgo_fp(XTclFileTempDirCmd)
	*(*uintptr)(unsafe.Add(p, 1504)) = __ccgo_fp(XTclCompileBasic0Or1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 1544)) = __ccgo_fp(XTclFileTemporaryCmd)
	*(*uintptr)(unsafe.Add(p, 1552)) = __ccgo_fp(XTclCompileBasic0To2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 1592)) = __ccgo_fp(XTclFileTildeExpandCmd)
	*(*uintptr)(unsafe.Add(p, 1600)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 1640)) = __ccgo_fp(_FileAttrTypeCmd)
	*(*uintptr)(unsafe.Add(p, 1648)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 1688)) = __ccgo_fp(_FilesystemVolumesCmd)
	*(*uintptr)(unsafe.Add(p, 1696)) = __ccgo_fp(XTclCompileBasic0ArgCmd)
	*(*uintptr)(unsafe.Add(p, 1736)) = __ccgo_fp(_FileAttrIsWritableCmd)
	*(*uintptr)(unsafe.Add(p, 1744)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
}

/*
 *----------------------------------------------------------------------
 *
 * FileAttrAccessTimeCmd --
 *
 *	This function is invoked to process the "file atime" Tcl command. See
 *	the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	May update the access time on the file, if requested by the user.
 *
 *----------------------------------------------------------------------
 */

func _FileAttrAccessTimeCmd(tls *libc.TLS, dummy1176 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(192)
	defer tls.Free(192)
	var v1 int32
	var v2 uintptr
	var _ /* buf at bp+0 */ TTcl_StatBuf
	var _ /* newTime at bp+160 */ TTcl_WideInt
	var _ /* tval at bp+144 */ Tutimbuf
	_, _ = v1, v2
	if objc < int32(2) || objc > int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+15324)
		return int32(TCL_ERROR)
	}
	if _GetStatBuf(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), __ccgo_fp(XTcl_FSStat), bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if objc == int32(3) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
			*(*TTcl_WideInt)(unsafe.Pointer(bp + 160)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep))
			v1 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1 = XTcl_GetWideIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp+160)
		}
		if v1 != TCL_OK {
			return int32(TCL_ERROR)
		}
		(*(*Tutimbuf)(unsafe.Pointer(bp + 144))).Factime = *(*TTcl_WideInt)(unsafe.Pointer(bp + 160))
		(*(*Tutimbuf)(unsafe.Pointer(bp + 144))).Fmodtime = XTcl_GetModificationTimeFromStat(tls, bp)
		if XTcl_FSUtime(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+144) != 0 {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
				v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+15336, libc.VaList(bp+176, v2, XTcl_PosixError(tls, interp))))
			return int32(TCL_ERROR)
		}
		/*
		 * Do another stat to ensure that the we return the new recognized
		 * atime - hopefully the same as the one we sent in. However, fs's
		 * like FAT don't even know what atime is.
		 */
		if _GetStatBuf(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), __ccgo_fp(XTcl_FSStat), bp) != TCL_OK {
			return int32(TCL_ERROR)
		}
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, XTcl_GetAccessTimeFromStat(tls, bp)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * FileAttrModifyTimeCmd --
 *
 *	This function is invoked to process the "file mtime" Tcl command. See
 *	the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	May update the modification time on the file, if requested by the
 *	user.
 *
 *----------------------------------------------------------------------
 */

func _FileAttrModifyTimeCmd(tls *libc.TLS, dummy1258 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(192)
	defer tls.Free(192)
	var v1 int32
	var v2 uintptr
	var _ /* buf at bp+0 */ TTcl_StatBuf
	var _ /* newTime at bp+160 */ TTcl_WideInt
	var _ /* tval at bp+144 */ Tutimbuf
	_, _ = v1, v2
	if objc < int32(2) || objc > int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+15324)
		return int32(TCL_ERROR)
	}
	if _GetStatBuf(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), __ccgo_fp(XTcl_FSStat), bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if objc == int32(3) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
			*(*TTcl_WideInt)(unsafe.Pointer(bp + 160)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep))
			v1 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1 = XTcl_GetWideIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp+160)
		}
		if v1 != TCL_OK {
			return int32(TCL_ERROR)
		}
		(*(*Tutimbuf)(unsafe.Pointer(bp + 144))).Factime = XTcl_GetAccessTimeFromStat(tls, bp)
		(*(*Tutimbuf)(unsafe.Pointer(bp + 144))).Fmodtime = *(*TTcl_WideInt)(unsafe.Pointer(bp + 160))
		if XTcl_FSUtime(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+144) != 0 {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
				v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+15380, libc.VaList(bp+176, v2, XTcl_PosixError(tls, interp))))
			return int32(TCL_ERROR)
		}
		/*
		 * Do another stat to ensure that the we return the new recognized
		 * mtime - hopefully the same as the one we sent in.
		 */
		if _GetStatBuf(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), __ccgo_fp(XTcl_FSStat), bp) != TCL_OK {
			return int32(TCL_ERROR)
		}
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, XTcl_GetModificationTimeFromStat(tls, bp)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * FileAttrLinkStatCmd --
 *
 *	This function is invoked to process the "file lstat" Tcl command. See
 *	the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Writes to an array named by the user.
 *
 *----------------------------------------------------------------------
 */

func _FileAttrLinkStatCmd(tls *libc.TLS, dummy1337 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(144)
	defer tls.Free(144)
	var _ /* buf at bp+0 */ TTcl_StatBuf
	if objc < int32(2) || objc > int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+15430)
		return int32(TCL_ERROR)
	}
	if _GetStatBuf(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), __ccgo_fp(XTcl_FSLstat), bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if objc == int32(2) {
		return _StoreStatData(tls, interp, libc.UintptrFromInt32(0), bp)
	} else {
		return _StoreStatData(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp)
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * FileAttrStatCmd --
 *
 *	This function is invoked to process the "file stat" Tcl command. See
 *	the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Writes to an array named by the user.
 *
 *----------------------------------------------------------------------
 */

func _FileAttrStatCmd(tls *libc.TLS, dummy1377 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(144)
	defer tls.Free(144)
	var _ /* buf at bp+0 */ TTcl_StatBuf
	if objc < int32(2) || objc > int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+15430)
		return int32(TCL_ERROR)
	}
	if _GetStatBuf(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), __ccgo_fp(XTcl_FSStat), bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if objc == int32(2) {
		return _StoreStatData(tls, interp, libc.UintptrFromInt32(0), bp)
	} else {
		return _StoreStatData(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp)
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * FileAttrTypeCmd --
 *
 *	This function is invoked to process the "file type" Tcl command. See
 *	the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _FileAttrTypeCmd(tls *libc.TLS, dummy1417 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(144)
	defer tls.Free(144)
	var _ /* buf at bp+0 */ TTcl_StatBuf
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+3726)
		return int32(TCL_ERROR)
	}
	if _GetStatBuf(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), __ccgo_fp(XTcl_FSLstat), bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, _GetTypeFromMode(tls, libc.Int32FromUint16(uint16((*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_mode))), int64(-int32(1))))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * FileAttrSizeCmd --
 *
 *	This function is invoked to process the "file size" Tcl command. See
 *	the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _FileAttrSizeCmd(tls *libc.TLS, dummy1455 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(144)
	defer tls.Free(144)
	var _ /* buf at bp+0 */ TTcl_StatBuf
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+3726)
		return int32(TCL_ERROR)
	}
	if _GetStatBuf(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), __ccgo_fp(XTcl_FSStat), bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_size))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * FileAttrIsDirectoryCmd --
 *
 *	This function is invoked to process the "file isdirectory" Tcl
 *	command. See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _FileAttrIsDirectoryCmd(tls *libc.TLS, dummy1492 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(144)
	defer tls.Free(144)
	var value int32
	var _ /* buf at bp+0 */ TTcl_StatBuf
	_ = value
	value = 0
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+3726)
		return int32(TCL_ERROR)
	}
	if _GetStatBuf(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + 1*8)), __ccgo_fp(XTcl_FSStat), bp) == TCL_OK {
		value = libc.BoolInt32((*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR))
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(value != 0)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * FileAttrIsExecutableCmd --
 *
 *	This function is invoked to process the "file executable" Tcl command.
 *	See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _FileAttrIsExecutableCmd(tls *libc.TLS, dummy1530 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+3726)
		return int32(TCL_ERROR)
	}
	return _CheckAccess(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), int32(X_OK))
}

/*
 *----------------------------------------------------------------------
 *
 * FileAttrIsExistingCmd --
 *
 *	This function is invoked to process the "file exists" Tcl command. See
 *	the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _FileAttrIsExistingCmd(tls *libc.TLS, dummy1561 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+3726)
		return int32(TCL_ERROR)
	}
	return _CheckAccess(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), F_OK)
}

/*
 *----------------------------------------------------------------------
 *
 * FileAttrIsFileCmd --
 *
 *	This function is invoked to process the "file isfile" Tcl command. See
 *	the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _FileAttrIsFileCmd(tls *libc.TLS, dummy1592 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(144)
	defer tls.Free(144)
	var value int32
	var _ /* buf at bp+0 */ TTcl_StatBuf
	_ = value
	value = 0
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+3726)
		return int32(TCL_ERROR)
	}
	if _GetStatBuf(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + 1*8)), __ccgo_fp(XTcl_FSStat), bp) == TCL_OK {
		value = libc.BoolInt32((*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFREG))
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(value != 0)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * FileAttrIsOwnedCmd --
 *
 *	This function is invoked to process the "file owned" Tcl command. See
 *	the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _FileAttrIsOwnedCmd(tls *libc.TLS, dummy1630 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(144)
	defer tls.Free(144)
	var normPathPtr, v1 uintptr
	var value int32
	var _ /* buf at bp+0 */ TTcl_StatBuf
	_, _, _ = normPathPtr, value, v1
	value = 0
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+3726)
		return int32(TCL_ERROR)
	}
	normPathPtr = XTcl_FSGetNormalizedPath(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	/* Note normPathPtr owned by Tcl, no need to free it */
	if normPathPtr != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(normPathPtr)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(normPathPtr)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, normPathPtr, libc.UintptrFromInt32(0))
		}
		if XTclIsZipfsPath(tls, v1) != 0 {
			return _CheckAccess(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), F_OK)
		}
		/* Not zipfs, try native. */
	}
	/*
	 * Note use objv[1] below, NOT normPathPtr even if not NULL because
	 * for native paths we may not want links to be resolved.
	 */
	if _GetStatBuf(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + 1*8)), __ccgo_fp(XTcl_FSStat), bp) == TCL_OK {
		value = libc.BoolInt32(libc.Xgeteuid(tls) == (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_uid)
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(value != 0)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * FileAttrIsReadableCmd --
 *
 *	This function is invoked to process the "file readable" Tcl command.
 *	See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _FileAttrIsReadableCmd(tls *libc.TLS, dummy1692 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+3726)
		return int32(TCL_ERROR)
	}
	return _CheckAccess(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), int32(R_OK))
}

/*
 *----------------------------------------------------------------------
 *
 * FileAttrIsWritableCmd --
 *
 *	This function is invoked to process the "file writable" Tcl command.
 *	See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _FileAttrIsWritableCmd(tls *libc.TLS, dummy1723 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+3726)
		return int32(TCL_ERROR)
	}
	return _CheckAccess(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), int32(W_OK))
}

/*
 *----------------------------------------------------------------------
 *
 * PathDirNameCmd --
 *
 *	This function is invoked to process the "file dirname" Tcl command.
 *	See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _PathDirNameCmd(tls *libc.TLS, dummy1754 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var _objPtr, dirPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _ = _objPtr, dirPtr, v1, v2
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+3726)
		return int32(TCL_ERROR)
	}
	dirPtr = XTclPathPart(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), int32(TCL_PATH_DIRNAME))
	if dirPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, dirPtr)
	_objPtr = dirPtr
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * PathExtensionCmd --
 *
 *	This function is invoked to process the "file extension" Tcl command.
 *	See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _PathExtensionCmd(tls *libc.TLS, dummy1793 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var _objPtr, dirPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _ = _objPtr, dirPtr, v1, v2
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+3726)
		return int32(TCL_ERROR)
	}
	dirPtr = XTclPathPart(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), int32(TCL_PATH_EXTENSION))
	if dirPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, dirPtr)
	_objPtr = dirPtr
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * PathRootNameCmd --
 *
 *	This function is invoked to process the "file root" Tcl command. See
 *	the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _PathRootNameCmd(tls *libc.TLS, dummy1832 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var _objPtr, dirPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _ = _objPtr, dirPtr, v1, v2
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+3726)
		return int32(TCL_ERROR)
	}
	dirPtr = XTclPathPart(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), int32(TCL_PATH_ROOT))
	if dirPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, dirPtr)
	_objPtr = dirPtr
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * PathTailCmd --
 *
 *	This function is invoked to process the "file tail" Tcl command. See
 *	the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _PathTailCmd(tls *libc.TLS, dummy1871 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var _objPtr, dirPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _ = _objPtr, dirPtr, v1, v2
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+3726)
		return int32(TCL_ERROR)
	}
	dirPtr = XTclPathPart(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), int32(TCL_PATH_TAIL))
	if dirPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, dirPtr)
	_objPtr = dirPtr
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * PathFilesystemCmd --
 *
 *	This function is invoked to process the "file system" Tcl command. See
 *	the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _PathFilesystemCmd(tls *libc.TLS, dummy1910 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var fsInfo, v1 uintptr
	_, _ = fsInfo, v1
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+3726)
		return int32(TCL_ERROR)
	}
	fsInfo = XTcl_FSFileSystemInfo(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if fsInfo == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+15445, int64(-int32(1))))
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+15463, v1, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, fsInfo)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * PathJoinCmd --
 *
 *	This function is invoked to process the "file join" Tcl command. See
 *	the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _PathJoinCmd(tls *libc.TLS, dummy1951 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+15474)
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTclJoinPath(tls, int64(objc-int32(1)), objv+uintptr(1)*8, 0))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * PathNativeNameCmd --
 *
 *	This function is invoked to process the "file nativename" Tcl command.
 *	See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _PathNativeNameCmd(tls *libc.TLS, dummy1983 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(224)
	defer tls.Free(224)
	var v1 uintptr
	var _ /* ds at bp+0 */ TTcl_DString
	_ = v1
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+3726)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	if XTcl_TranslateFileName(tls, interp, v1, bp) == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTcl_DStringToObj(tls, bp))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * PathNormalizeCmd --
 *
 *	This function is invoked to process the "file normalize" Tcl command.
 *	See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _PathNormalizeCmd(tls *libc.TLS, dummy2020 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var fileName uintptr
	_ = fileName
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+3726)
		return int32(TCL_ERROR)
	}
	fileName = XTcl_FSGetNormalizedPath(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if fileName == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, fileName)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * PathSplitCmd --
 *
 *	This function is invoked to process the "file split" Tcl command. See
 *	the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _PathSplitCmd(tls *libc.TLS, dummy2058 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var res, v1 uintptr
	_, _ = res, v1
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+3726)
		return int32(TCL_ERROR)
	}
	res = XTcl_FSSplitPath(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	if res == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+15490, libc.VaList(bp+8, v1)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+15537, __ccgo_ts+15547, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, res)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * PathTypeCmd --
 *
 *	This function is invoked to process the "file pathtype" Tcl command.
 *	See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _PathTypeCmd(tls *libc.TLS, dummy2101 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var cachePtr, cachePtr1, cachePtr2, typeName uintptr
	var v10, v11, v9 bool
	_, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, typeName, v10, v11, v9
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+3726)
		return int32(TCL_ERROR)
	}
	switch XTcl_FSGetPathType(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8))) {
	case int32(TCL_PATH_ABSOLUTE):
		goto _1
	case int32(TCL_PATH_RELATIVE):
		goto _2
	case int32(TCL_PATH_VOLUME_RELATIVE):
		goto _3
	default:
		goto _4
	}
	goto _5
_1:
	;
_8:
	;
	if v9 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v9 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v9 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		typeName = XTclThreadAllocObj(tls)
	} else {
		typeName = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(typeName + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(typeName)).FrefCount = 0
	if libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(typeName)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(typeName)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(typeName)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(typeName)).Fbytes, __ccgo_ts+15556, libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(typeName)).Fbytes + uintptr(libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(typeName)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(9) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(typeName)).FtypePtr = libc.UintptrFromInt32(0)
	goto _7
_7:
	;
	if 0 != 0 {
		goto _8
	}
	goto _6
_6:
	;
	goto _5
_2:
	;
	if v10 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v10 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v10 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		typeName = XTclThreadAllocObj(tls)
	} else {
		typeName = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(typeName + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(typeName)).FrefCount = 0
	if libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(typeName)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(typeName)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(typeName)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(typeName)).Fbytes, __ccgo_ts+15565, libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(typeName)).Fbytes + uintptr(libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(typeName)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(9) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(typeName)).FtypePtr = libc.UintptrFromInt32(0)
	goto _5
_3:
	;
	if v11 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v11 {
		cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v11 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
		typeName = XTclThreadAllocObj(tls)
	} else {
		typeName = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(typeName + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(typeName)).FrefCount = 0
	if libc.Uint64FromInt64(15)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(typeName)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(typeName)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(typeName)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(15)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(typeName)).Fbytes, __ccgo_ts+15574, libc.Uint64FromInt64(15)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(typeName)).Fbytes + uintptr(libc.Uint64FromInt64(15)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(typeName)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(15) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(typeName)).FtypePtr = libc.UintptrFromInt32(0)
	goto _5
_4:
	;
	/* Should be unreachable */
	return TCL_OK
_5:
	;
	XTcl_SetObjResult(tls, interp, typeName)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * FilesystemSeparatorCmd --
 *
 *	This function is invoked to process the "file separator" Tcl command.
 *	See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _FilesystemSeparatorCmd(tls *libc.TLS, dummy2149 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var separator, separatorObj, v1 uintptr
	_, _, _ = separator, separatorObj, v1
	if objc < int32(1) || objc > int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+15589)
		return int32(TCL_ERROR)
	}
	if objc == int32(1) {
		separator = libc.UintptrFromInt32(0)
		switch XtclPlatform {
		case int32(TCL_PLATFORM_UNIX):
			separator = __ccgo_ts + 6339
		case int32(TCL_PLATFORM_WINDOWS):
			separator = __ccgo_ts + 15596
			break
		}
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, separator, int64(1)))
	} else {
		separatorObj = XTcl_FSPathSeparator(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
		if separatorObj == libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+15445, int64(-int32(1))))
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
				v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
			} else {
				v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
			}
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+15463, v1, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		XTcl_SetObjResult(tls, interp, separatorObj)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * FilesystemVolumesCmd --
 *
 *	This function is invoked to process the "file volumes" Tcl command.
 *	See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _FilesystemVolumesCmd(tls *libc.TLS, dummy2204 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	if objc != int32(1) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, libc.UintptrFromInt32(0))
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTcl_FSListVolumes(tls))
	return TCL_OK
}

/*
 *---------------------------------------------------------------------------
 *
 * CheckAccess --
 *
 *	Utility procedure used by Tcl_FileObjCmd() to query file attributes
 *	available through the access() system call.
 *
 * Results:
 *	Always returns TCL_OK. Sets interp's result to boolean true or false
 *	depending on whether the file has the specified attribute.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func _CheckAccess(tls *libc.TLS, interp uintptr, pathPtr uintptr, mode int32) (r int32) {
	bp := tls.Alloc(224)
	defer tls.Free(224) /* Attribute to check; passed as argument to
	 * access(). */
	var value int32
	var v1 uintptr
	var _ /* ds at bp+0 */ TTcl_DString
	_, _ = value, v1
	if XTcl_FSConvertToPathType(tls, interp, pathPtr) != TCL_OK {
		value = 0
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
		}
		if XTcl_UtfToExternalDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), v1, int64(-libc.Int32FromInt32(1)), 0, bp, libc.UintptrFromInt32(0)) != TCL_OK {
			value = 0
			XTcl_DStringFree(tls, bp)
		} else {
			XTcl_DStringFree(tls, bp)
			value = libc.BoolInt32(XTcl_FSAccess(tls, pathPtr, mode) == 0)
		}
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(value != 0)))
	return TCL_OK
}

/*
 *---------------------------------------------------------------------------
 *
 * GetStatBuf --
 *
 *	Utility procedure used by Tcl_FileObjCmd() to query file attributes
 *	available through the stat() or lstat() system call.
 *
 * Results:
 *	The return value is TCL_OK if the specified file exists and can be
 *	stat'ed, TCL_ERROR otherwise. If TCL_ERROR is returned, an error
 *	message is left in interp's result. If TCL_OK is returned, *statPtr is
 *	filled with information about the specified file.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func _GetStatBuf(tls *libc.TLS, interp uintptr, pathPtr uintptr, statProc uintptr, statPtr uintptr) (r int32) {
	bp := tls.Alloc(256)
	defer tls.Free(256) /* Filled with info about file obtained by
	 * calling (*statProc)(). */
	var status int32
	var v1, v2 uintptr
	var _ /* ds at bp+0 */ TTcl_DString
	_, _, _ = status, v1, v2
	if XTcl_FSConvertToPathType(tls, interp, pathPtr) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
	}
	if XTcl_UtfToExternalDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), v1, int64(-libc.Int32FromInt32(1)), 0, bp, libc.UintptrFromInt32(0)) != TCL_OK {
		status = -int32(1)
	} else {
		status = (*(*func(*libc.TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{statProc})))(tls, pathPtr, statPtr)
	}
	XTcl_DStringFree(tls, bp)
	if status < 0 {
		if interp != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
				v2 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+15598, libc.VaList(bp+232, v2, XTcl_PosixError(tls, interp))))
		}
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * StoreStatData --
 *
 *	This is a utility procedure that breaks out the fields of a "stat"
 *	structure and stores them in textual form into the elements of an
 *	associative array (if given) or returns a dictionary.
 *
 * Results:
 *	Returns a standard Tcl return value. If an error occurs then a message
 *	is left in interp's result.
 *
 * Side effects:
 *	Elements of the associative array given by "varName" are modified.
 *
 *----------------------------------------------------------------------
 */

func _StoreStatData(tls *libc.TLS, interp uintptr, varName uintptr, statPtr uintptr) (r int32) {
	/* Pointer to buffer containing stat data to
	 * store in varName. */
	var _objPtr, cachePtr, cachePtr1, cachePtr10, cachePtr11, cachePtr12, cachePtr13, cachePtr14, cachePtr15, cachePtr16, cachePtr17, cachePtr18, cachePtr19, cachePtr2, cachePtr20, cachePtr21, cachePtr22, cachePtr23, cachePtr24, cachePtr25, cachePtr26, cachePtr27, cachePtr28, cachePtr29, cachePtr3, cachePtr30, cachePtr31, cachePtr32, cachePtr33, cachePtr34, cachePtr35, cachePtr36, cachePtr37, cachePtr38, cachePtr39, cachePtr4, cachePtr40, cachePtr41, cachePtr42, cachePtr5, cachePtr6, cachePtr7, cachePtr8, cachePtr9, field, result, value, v100, v13, v16, v20, v23, v27, v3, v30, v34, v37, v41, v44, v48, v51, v55, v58, v6, v62, v65, v69, v72, v76, v79, v83, v86, v9, v90, v93, v97 uintptr
	var mode uint16
	var v1, v10, v101, v11, v14, v17, v18, v21, v24, v25, v28, v31, v32, v35, v38, v39, v4, v42, v45, v46, v49, v52, v53, v56, v59, v60, v63, v66, v67, v7, v70, v73, v74, v77, v80, v81, v84, v87, v88, v91, v94, v95, v98 bool
	var v12, v15, v19, v2, v22, v26, v29, v33, v36, v40, v43, v47, v5, v50, v54, v57, v61, v64, v68, v71, v75, v78, v8, v82, v85, v89, v92, v96, v99 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, cachePtr1, cachePtr10, cachePtr11, cachePtr12, cachePtr13, cachePtr14, cachePtr15, cachePtr16, cachePtr17, cachePtr18, cachePtr19, cachePtr2, cachePtr20, cachePtr21, cachePtr22, cachePtr23, cachePtr24, cachePtr25, cachePtr26, cachePtr27, cachePtr28, cachePtr29, cachePtr3, cachePtr30, cachePtr31, cachePtr32, cachePtr33, cachePtr34, cachePtr35, cachePtr36, cachePtr37, cachePtr38, cachePtr39, cachePtr4, cachePtr40, cachePtr41, cachePtr42, cachePtr5, cachePtr6, cachePtr7, cachePtr8, cachePtr9, field, mode, result, value, v1, v10, v100, v101, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99
	if varName == libc.UintptrFromInt32(0) {
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			result = XTclThreadAllocObj(tls)
		} else {
			result = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(result + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(result)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(result)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(result)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(result)).FtypePtr = libc.UintptrFromInt32(0)
		(*TTcl_Obj)(unsafe.Pointer(result)).FrefCount++
		XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), result, XTcl_NewStringObj(tls, __ccgo_ts+15622, int64(-int32(1))), XTcl_NewWideIntObj(tls, int64(libc.Int64FromUint64((*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_dev))))
		XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), result, XTcl_NewStringObj(tls, __ccgo_ts+15626, int64(-int32(1))), XTcl_NewWideIntObj(tls, libc.Int64FromUint64((*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_ino)))
		XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), result, XTcl_NewStringObj(tls, __ccgo_ts+15630, int64(-int32(1))), XTcl_NewWideIntObj(tls, int64(libc.Int64FromUint64((*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_nlink))))
		XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), result, XTcl_NewStringObj(tls, __ccgo_ts+15636, int64(-int32(1))), XTcl_NewWideIntObj(tls, int64(libc.Int64FromUint32((*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_uid))))
		XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), result, XTcl_NewStringObj(tls, __ccgo_ts+15640, int64(-int32(1))), XTcl_NewWideIntObj(tls, int64(libc.Int64FromUint32((*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_gid))))
		XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), result, XTcl_NewStringObj(tls, __ccgo_ts+5807, int64(-int32(1))), XTcl_NewWideIntObj(tls, (*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_size))
		XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), result, XTcl_NewStringObj(tls, __ccgo_ts+15644, int64(-int32(1))), XTcl_NewWideIntObj(tls, (*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_blocks))
		XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), result, XTcl_NewStringObj(tls, __ccgo_ts+15651, int64(-int32(1))), XTcl_NewWideIntObj(tls, (*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_blksize))
		XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), result, XTcl_NewStringObj(tls, __ccgo_ts+5641, int64(-int32(1))), XTcl_NewWideIntObj(tls, XTcl_GetAccessTimeFromStat(tls, statPtr)))
		XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), result, XTcl_NewStringObj(tls, __ccgo_ts+5741, int64(-int32(1))), XTcl_NewWideIntObj(tls, XTcl_GetModificationTimeFromStat(tls, statPtr)))
		XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), result, XTcl_NewStringObj(tls, __ccgo_ts+15659, int64(-int32(1))), XTcl_NewWideIntObj(tls, XTcl_GetChangeTimeFromStat(tls, statPtr)))
		mode = uint16((*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_mode)
		XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), result, XTcl_NewStringObj(tls, __ccgo_ts+15665, int64(-int32(1))), XTcl_NewWideIntObj(tls, libc.Int64FromUint16(mode)))
		XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), result, XTcl_NewStringObj(tls, __ccgo_ts+5851, int64(-int32(1))), XTcl_NewStringObj(tls, _GetTypeFromMode(tls, libc.Int32FromUint16(mode)), int64(-int32(1))))
		XTcl_SetObjResult(tls, interp, result)
		_objPtr = result
		v3 = _objPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		return TCL_OK
	}
	/*
	 * Might be a better idea to call Tcl_SetVar2Ex() instead, except we want
	 * to have an object (i.e. possibly cached) array variable name but a
	 * string element name, so no API exists. Messy.
	 */
	/*
	 * Watch out porters; the inode is meant to be an *unsigned* value, so the
	 * cast might fail when there isn't a real arithmetic 'long long' type...
	 */
	if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		field = XTclThreadAllocObj(tls)
	} else {
		field = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(field + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(field)).FrefCount = 0
	if libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(field)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(field)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes, __ccgo_ts+15622, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).Fbytes + uintptr(libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(field)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(4) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(field)).FrefCount++
	value = XTcl_NewWideIntObj(tls, int64(libc.Int64FromUint64((*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_dev)))
	if XTcl_ObjSetVar2(tls, interp, varName, field, value, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
		v6 = field
		v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
		*(*TTcl_Size)(unsafe.Pointer(v6))--
		if !(v5 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(-libc.Int32FromInt32(1))
				if v7 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v7 {
					cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v7 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, field)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(field + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = field
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, field)
			}
		}
		return int32(TCL_ERROR)
	}
	v9 = field
	v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
	*(*TTcl_Size)(unsafe.Pointer(v9))--
	if !(v8 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(-libc.Int32FromInt32(1))
			if v10 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v10 {
				cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v10 || ((*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, field)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(field + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = field
				(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, field)
		}
	}
	if v11 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v11 {
		cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v11 || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == libc.Uint64FromInt32(0) {
		field = XTclThreadAllocObj(tls)
	} else {
		field = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(field + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(field)).FrefCount = 0
	if libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(field)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(field)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes, __ccgo_ts+15626, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).Fbytes + uintptr(libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(field)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(4) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(field)).FrefCount++
	value = XTcl_NewWideIntObj(tls, libc.Int64FromUint64((*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_ino))
	if XTcl_ObjSetVar2(tls, interp, varName, field, value, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
		v13 = field
		v12 = *(*TTcl_Size)(unsafe.Pointer(v13))
		*(*TTcl_Size)(unsafe.Pointer(v13))--
		if !(v12 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(-libc.Int32FromInt32(1))
				if v14 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v14 {
					cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v14 || ((*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, field)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(field + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = field
					(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, field)
			}
		}
		return int32(TCL_ERROR)
	}
	v16 = field
	v15 = *(*TTcl_Size)(unsafe.Pointer(v16))
	*(*TTcl_Size)(unsafe.Pointer(v16))--
	if !(v15 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(-libc.Int32FromInt32(1))
			if v17 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v17 {
				cachePtr6 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v17 || ((*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, field)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(field + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr = field
				(*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, field)
		}
	}
	if v18 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v18 {
		cachePtr7 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v18 || (*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects == libc.Uint64FromInt32(0) {
		field = XTclThreadAllocObj(tls)
	} else {
		field = (*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(field + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(field)).FrefCount = 0
	if libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(field)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(field)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes, __ccgo_ts+15630, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).Fbytes + uintptr(libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(field)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(6) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(field)).FrefCount++
	value = XTcl_NewWideIntObj(tls, int64(libc.Int64FromUint64((*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_nlink)))
	if XTcl_ObjSetVar2(tls, interp, varName, field, value, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
		v20 = field
		v19 = *(*TTcl_Size)(unsafe.Pointer(v20))
		*(*TTcl_Size)(unsafe.Pointer(v20))--
		if !(v19 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(-libc.Int32FromInt32(1))
				if v21 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v21 {
					cachePtr8 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v21 || ((*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, field)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(field + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr8)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr8)).FfirstObjPtr = field
					(*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, field)
			}
		}
		return int32(TCL_ERROR)
	}
	v23 = field
	v22 = *(*TTcl_Size)(unsafe.Pointer(v23))
	*(*TTcl_Size)(unsafe.Pointer(v23))--
	if !(v22 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(-libc.Int32FromInt32(1))
			if v24 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v24 {
				cachePtr9 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v24 || ((*TAllocCache)(unsafe.Pointer(cachePtr9)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr9)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, field)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(field + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr9)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr9)).FfirstObjPtr = field
				(*TAllocCache)(unsafe.Pointer(cachePtr9)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, field)
		}
	}
	if v25 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v25 {
		cachePtr10 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v25 || (*TAllocCache)(unsafe.Pointer(cachePtr10)).FnumObjects == libc.Uint64FromInt32(0) {
		field = XTclThreadAllocObj(tls)
	} else {
		field = (*TAllocCache)(unsafe.Pointer(cachePtr10)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr10)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(field + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr10)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(field)).FrefCount = 0
	if libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(field)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(field)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes, __ccgo_ts+15636, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).Fbytes + uintptr(libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(field)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(4) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(field)).FrefCount++
	value = XTcl_NewWideIntObj(tls, int64(libc.Int64FromUint32((*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_uid)))
	if XTcl_ObjSetVar2(tls, interp, varName, field, value, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
		v27 = field
		v26 = *(*TTcl_Size)(unsafe.Pointer(v27))
		*(*TTcl_Size)(unsafe.Pointer(v27))--
		if !(v26 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(-libc.Int32FromInt32(1))
				if v28 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v28 {
					cachePtr11 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v28 || ((*TAllocCache)(unsafe.Pointer(cachePtr11)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr11)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, field)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(field + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr11)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr11)).FfirstObjPtr = field
					(*TAllocCache)(unsafe.Pointer(cachePtr11)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, field)
			}
		}
		return int32(TCL_ERROR)
	}
	v30 = field
	v29 = *(*TTcl_Size)(unsafe.Pointer(v30))
	*(*TTcl_Size)(unsafe.Pointer(v30))--
	if !(v29 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(-libc.Int32FromInt32(1))
			if v31 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v31 {
				cachePtr12 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v31 || ((*TAllocCache)(unsafe.Pointer(cachePtr12)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr12)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, field)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(field + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr12)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr12)).FfirstObjPtr = field
				(*TAllocCache)(unsafe.Pointer(cachePtr12)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, field)
		}
	}
	if v32 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v32 {
		cachePtr13 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v32 || (*TAllocCache)(unsafe.Pointer(cachePtr13)).FnumObjects == libc.Uint64FromInt32(0) {
		field = XTclThreadAllocObj(tls)
	} else {
		field = (*TAllocCache)(unsafe.Pointer(cachePtr13)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr13)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(field + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr13)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(field)).FrefCount = 0
	if libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(field)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(field)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes, __ccgo_ts+15640, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).Fbytes + uintptr(libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(field)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(4) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(field)).FrefCount++
	value = XTcl_NewWideIntObj(tls, int64(libc.Int64FromUint32((*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_gid)))
	if XTcl_ObjSetVar2(tls, interp, varName, field, value, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
		v34 = field
		v33 = *(*TTcl_Size)(unsafe.Pointer(v34))
		*(*TTcl_Size)(unsafe.Pointer(v34))--
		if !(v33 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(-libc.Int32FromInt32(1))
				if v35 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v35 {
					cachePtr14 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v35 || ((*TAllocCache)(unsafe.Pointer(cachePtr14)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr14)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, field)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(field + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr14)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr14)).FfirstObjPtr = field
					(*TAllocCache)(unsafe.Pointer(cachePtr14)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, field)
			}
		}
		return int32(TCL_ERROR)
	}
	v37 = field
	v36 = *(*TTcl_Size)(unsafe.Pointer(v37))
	*(*TTcl_Size)(unsafe.Pointer(v37))--
	if !(v36 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(-libc.Int32FromInt32(1))
			if v38 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v38 {
				cachePtr15 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v38 || ((*TAllocCache)(unsafe.Pointer(cachePtr15)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr15)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, field)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(field + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr15)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr15)).FfirstObjPtr = field
				(*TAllocCache)(unsafe.Pointer(cachePtr15)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, field)
		}
	}
	if v39 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v39 {
		cachePtr16 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v39 || (*TAllocCache)(unsafe.Pointer(cachePtr16)).FnumObjects == libc.Uint64FromInt32(0) {
		field = XTclThreadAllocObj(tls)
	} else {
		field = (*TAllocCache)(unsafe.Pointer(cachePtr16)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr16)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(field + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr16)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(field)).FrefCount = 0
	if libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(field)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(field)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes, __ccgo_ts+5807, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).Fbytes + uintptr(libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(field)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(5) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(field)).FrefCount++
	value = XTcl_NewWideIntObj(tls, (*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_size)
	if XTcl_ObjSetVar2(tls, interp, varName, field, value, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
		v41 = field
		v40 = *(*TTcl_Size)(unsafe.Pointer(v41))
		*(*TTcl_Size)(unsafe.Pointer(v41))--
		if !(v40 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(-libc.Int32FromInt32(1))
				if v42 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v42 {
					cachePtr17 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v42 || ((*TAllocCache)(unsafe.Pointer(cachePtr17)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr17)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, field)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(field + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr17)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr17)).FfirstObjPtr = field
					(*TAllocCache)(unsafe.Pointer(cachePtr17)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, field)
			}
		}
		return int32(TCL_ERROR)
	}
	v44 = field
	v43 = *(*TTcl_Size)(unsafe.Pointer(v44))
	*(*TTcl_Size)(unsafe.Pointer(v44))--
	if !(v43 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(-libc.Int32FromInt32(1))
			if v45 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v45 {
				cachePtr18 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v45 || ((*TAllocCache)(unsafe.Pointer(cachePtr18)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr18)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, field)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(field + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr18)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr18)).FfirstObjPtr = field
				(*TAllocCache)(unsafe.Pointer(cachePtr18)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, field)
		}
	}
	if v46 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v46 {
		cachePtr19 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v46 || (*TAllocCache)(unsafe.Pointer(cachePtr19)).FnumObjects == libc.Uint64FromInt32(0) {
		field = XTclThreadAllocObj(tls)
	} else {
		field = (*TAllocCache)(unsafe.Pointer(cachePtr19)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr19)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(field + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr19)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(field)).FrefCount = 0
	if libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(field)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(field)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes, __ccgo_ts+15644, libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).Fbytes + uintptr(libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(field)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(7) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(field)).FrefCount++
	value = XTcl_NewWideIntObj(tls, (*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_blocks)
	if XTcl_ObjSetVar2(tls, interp, varName, field, value, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
		v48 = field
		v47 = *(*TTcl_Size)(unsafe.Pointer(v48))
		*(*TTcl_Size)(unsafe.Pointer(v48))--
		if !(v47 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(-libc.Int32FromInt32(1))
				if v49 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v49 {
					cachePtr20 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v49 || ((*TAllocCache)(unsafe.Pointer(cachePtr20)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr20)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, field)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(field + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr20)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr20)).FfirstObjPtr = field
					(*TAllocCache)(unsafe.Pointer(cachePtr20)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, field)
			}
		}
		return int32(TCL_ERROR)
	}
	v51 = field
	v50 = *(*TTcl_Size)(unsafe.Pointer(v51))
	*(*TTcl_Size)(unsafe.Pointer(v51))--
	if !(v50 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(-libc.Int32FromInt32(1))
			if v52 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v52 {
				cachePtr21 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v52 || ((*TAllocCache)(unsafe.Pointer(cachePtr21)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr21)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, field)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(field + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr21)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr21)).FfirstObjPtr = field
				(*TAllocCache)(unsafe.Pointer(cachePtr21)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, field)
		}
	}
	if v53 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v53 {
		cachePtr22 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v53 || (*TAllocCache)(unsafe.Pointer(cachePtr22)).FnumObjects == libc.Uint64FromInt32(0) {
		field = XTclThreadAllocObj(tls)
	} else {
		field = (*TAllocCache)(unsafe.Pointer(cachePtr22)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr22)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(field + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr22)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(field)).FrefCount = 0
	if libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(field)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(field)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes, __ccgo_ts+15651, libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).Fbytes + uintptr(libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(field)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(8) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(field)).FrefCount++
	value = XTcl_NewWideIntObj(tls, (*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_blksize)
	if XTcl_ObjSetVar2(tls, interp, varName, field, value, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
		v55 = field
		v54 = *(*TTcl_Size)(unsafe.Pointer(v55))
		*(*TTcl_Size)(unsafe.Pointer(v55))--
		if !(v54 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(-libc.Int32FromInt32(1))
				if v56 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v56 {
					cachePtr23 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v56 || ((*TAllocCache)(unsafe.Pointer(cachePtr23)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr23)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, field)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(field + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr23)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr23)).FfirstObjPtr = field
					(*TAllocCache)(unsafe.Pointer(cachePtr23)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, field)
			}
		}
		return int32(TCL_ERROR)
	}
	v58 = field
	v57 = *(*TTcl_Size)(unsafe.Pointer(v58))
	*(*TTcl_Size)(unsafe.Pointer(v58))--
	if !(v57 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(-libc.Int32FromInt32(1))
			if v59 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v59 {
				cachePtr24 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v59 || ((*TAllocCache)(unsafe.Pointer(cachePtr24)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr24)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, field)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(field + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr24)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr24)).FfirstObjPtr = field
				(*TAllocCache)(unsafe.Pointer(cachePtr24)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, field)
		}
	}
	if (*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_mode&uint32(S_IFMT) == uint32(S_IFCHR) || (*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_mode&uint32(S_IFMT) == uint32(S_IFBLK) {
		if v60 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v60 {
			cachePtr25 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v60 || (*TAllocCache)(unsafe.Pointer(cachePtr25)).FnumObjects == libc.Uint64FromInt32(0) {
			field = XTclThreadAllocObj(tls)
		} else {
			field = (*TAllocCache)(unsafe.Pointer(cachePtr25)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr25)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(field + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr25)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(field)).FrefCount = 0
		if libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer(field)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(field)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes, __ccgo_ts+15670, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).Fbytes + uintptr(libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(field)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(5) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr = libc.UintptrFromInt32(0)
		(*TTcl_Obj)(unsafe.Pointer(field)).FrefCount++
		value = XTcl_NewWideIntObj(tls, int64(libc.Int64FromUint64((*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_rdev)))
		if XTcl_ObjSetVar2(tls, interp, varName, field, value, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
			v62 = field
			v61 = *(*TTcl_Size)(unsafe.Pointer(v62))
			*(*TTcl_Size)(unsafe.Pointer(v62))--
			if !(v61 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(-libc.Int32FromInt32(1))
					if v63 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v63 {
						cachePtr26 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v63 || ((*TAllocCache)(unsafe.Pointer(cachePtr26)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr26)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, field)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(field + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr26)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr26)).FfirstObjPtr = field
						(*TAllocCache)(unsafe.Pointer(cachePtr26)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, field)
				}
			}
			return int32(TCL_ERROR)
		}
		v65 = field
		v64 = *(*TTcl_Size)(unsafe.Pointer(v65))
		*(*TTcl_Size)(unsafe.Pointer(v65))--
		if !(v64 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(-libc.Int32FromInt32(1))
				if v66 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v66 {
					cachePtr27 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v66 || ((*TAllocCache)(unsafe.Pointer(cachePtr27)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr27)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, field)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(field + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr27)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr27)).FfirstObjPtr = field
					(*TAllocCache)(unsafe.Pointer(cachePtr27)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, field)
			}
		}
	}
	if v67 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v67 {
		cachePtr28 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v67 || (*TAllocCache)(unsafe.Pointer(cachePtr28)).FnumObjects == libc.Uint64FromInt32(0) {
		field = XTclThreadAllocObj(tls)
	} else {
		field = (*TAllocCache)(unsafe.Pointer(cachePtr28)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr28)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(field + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr28)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(field)).FrefCount = 0
	if libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(field)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(field)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes, __ccgo_ts+5641, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).Fbytes + uintptr(libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(field)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(6) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(field)).FrefCount++
	value = XTcl_NewWideIntObj(tls, XTcl_GetAccessTimeFromStat(tls, statPtr))
	if XTcl_ObjSetVar2(tls, interp, varName, field, value, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
		v69 = field
		v68 = *(*TTcl_Size)(unsafe.Pointer(v69))
		*(*TTcl_Size)(unsafe.Pointer(v69))--
		if !(v68 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(-libc.Int32FromInt32(1))
				if v70 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v70 {
					cachePtr29 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v70 || ((*TAllocCache)(unsafe.Pointer(cachePtr29)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr29)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, field)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(field + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr29)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr29)).FfirstObjPtr = field
					(*TAllocCache)(unsafe.Pointer(cachePtr29)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, field)
			}
		}
		return int32(TCL_ERROR)
	}
	v72 = field
	v71 = *(*TTcl_Size)(unsafe.Pointer(v72))
	*(*TTcl_Size)(unsafe.Pointer(v72))--
	if !(v71 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(-libc.Int32FromInt32(1))
			if v73 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v73 {
				cachePtr30 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v73 || ((*TAllocCache)(unsafe.Pointer(cachePtr30)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr30)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, field)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(field + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr30)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr30)).FfirstObjPtr = field
				(*TAllocCache)(unsafe.Pointer(cachePtr30)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, field)
		}
	}
	if v74 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v74 {
		cachePtr31 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v74 || (*TAllocCache)(unsafe.Pointer(cachePtr31)).FnumObjects == libc.Uint64FromInt32(0) {
		field = XTclThreadAllocObj(tls)
	} else {
		field = (*TAllocCache)(unsafe.Pointer(cachePtr31)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr31)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(field + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr31)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(field)).FrefCount = 0
	if libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(field)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(field)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes, __ccgo_ts+5741, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).Fbytes + uintptr(libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(field)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(6) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(field)).FrefCount++
	value = XTcl_NewWideIntObj(tls, XTcl_GetModificationTimeFromStat(tls, statPtr))
	if XTcl_ObjSetVar2(tls, interp, varName, field, value, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
		v76 = field
		v75 = *(*TTcl_Size)(unsafe.Pointer(v76))
		*(*TTcl_Size)(unsafe.Pointer(v76))--
		if !(v75 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(-libc.Int32FromInt32(1))
				if v77 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v77 {
					cachePtr32 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v77 || ((*TAllocCache)(unsafe.Pointer(cachePtr32)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr32)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, field)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(field + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr32)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr32)).FfirstObjPtr = field
					(*TAllocCache)(unsafe.Pointer(cachePtr32)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, field)
			}
		}
		return int32(TCL_ERROR)
	}
	v79 = field
	v78 = *(*TTcl_Size)(unsafe.Pointer(v79))
	*(*TTcl_Size)(unsafe.Pointer(v79))--
	if !(v78 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(-libc.Int32FromInt32(1))
			if v80 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v80 {
				cachePtr33 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v80 || ((*TAllocCache)(unsafe.Pointer(cachePtr33)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr33)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, field)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(field + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr33)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr33)).FfirstObjPtr = field
				(*TAllocCache)(unsafe.Pointer(cachePtr33)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, field)
		}
	}
	if v81 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v81 {
		cachePtr34 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v81 || (*TAllocCache)(unsafe.Pointer(cachePtr34)).FnumObjects == libc.Uint64FromInt32(0) {
		field = XTclThreadAllocObj(tls)
	} else {
		field = (*TAllocCache)(unsafe.Pointer(cachePtr34)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr34)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(field + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr34)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(field)).FrefCount = 0
	if libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(field)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(field)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes, __ccgo_ts+15659, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).Fbytes + uintptr(libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(field)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(6) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(field)).FrefCount++
	value = XTcl_NewWideIntObj(tls, XTcl_GetChangeTimeFromStat(tls, statPtr))
	if XTcl_ObjSetVar2(tls, interp, varName, field, value, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
		v83 = field
		v82 = *(*TTcl_Size)(unsafe.Pointer(v83))
		*(*TTcl_Size)(unsafe.Pointer(v83))--
		if !(v82 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(-libc.Int32FromInt32(1))
				if v84 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v84 {
					cachePtr35 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v84 || ((*TAllocCache)(unsafe.Pointer(cachePtr35)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr35)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, field)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(field + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr35)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr35)).FfirstObjPtr = field
					(*TAllocCache)(unsafe.Pointer(cachePtr35)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, field)
			}
		}
		return int32(TCL_ERROR)
	}
	v86 = field
	v85 = *(*TTcl_Size)(unsafe.Pointer(v86))
	*(*TTcl_Size)(unsafe.Pointer(v86))--
	if !(v85 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(-libc.Int32FromInt32(1))
			if v87 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v87 {
				cachePtr36 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v87 || ((*TAllocCache)(unsafe.Pointer(cachePtr36)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr36)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, field)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(field + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr36)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr36)).FfirstObjPtr = field
				(*TAllocCache)(unsafe.Pointer(cachePtr36)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, field)
		}
	}
	mode = uint16((*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_mode)
	if v88 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v88 {
		cachePtr37 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v88 || (*TAllocCache)(unsafe.Pointer(cachePtr37)).FnumObjects == libc.Uint64FromInt32(0) {
		field = XTclThreadAllocObj(tls)
	} else {
		field = (*TAllocCache)(unsafe.Pointer(cachePtr37)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr37)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(field + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr37)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(field)).FrefCount = 0
	if libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(field)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(field)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes, __ccgo_ts+15665, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).Fbytes + uintptr(libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(field)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(5) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(field)).FrefCount++
	value = XTcl_NewWideIntObj(tls, libc.Int64FromUint16(mode))
	if XTcl_ObjSetVar2(tls, interp, varName, field, value, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
		v90 = field
		v89 = *(*TTcl_Size)(unsafe.Pointer(v90))
		*(*TTcl_Size)(unsafe.Pointer(v90))--
		if !(v89 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(-libc.Int32FromInt32(1))
				if v91 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v91 {
					cachePtr38 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v91 || ((*TAllocCache)(unsafe.Pointer(cachePtr38)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr38)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, field)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(field + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr38)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr38)).FfirstObjPtr = field
					(*TAllocCache)(unsafe.Pointer(cachePtr38)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, field)
			}
		}
		return int32(TCL_ERROR)
	}
	v93 = field
	v92 = *(*TTcl_Size)(unsafe.Pointer(v93))
	*(*TTcl_Size)(unsafe.Pointer(v93))--
	if !(v92 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(-libc.Int32FromInt32(1))
			if v94 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v94 {
				cachePtr39 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v94 || ((*TAllocCache)(unsafe.Pointer(cachePtr39)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr39)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, field)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(field + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr39)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr39)).FfirstObjPtr = field
				(*TAllocCache)(unsafe.Pointer(cachePtr39)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, field)
		}
	}
	if v95 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v95 {
		cachePtr40 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v95 || (*TAllocCache)(unsafe.Pointer(cachePtr40)).FnumObjects == libc.Uint64FromInt32(0) {
		field = XTclThreadAllocObj(tls)
	} else {
		field = (*TAllocCache)(unsafe.Pointer(cachePtr40)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr40)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(field + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr40)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(field)).FrefCount = 0
	if libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(field)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(field)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes, __ccgo_ts+5851, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).Fbytes + uintptr(libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(field)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(5) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(field)).FrefCount++
	value = XTcl_NewStringObj(tls, _GetTypeFromMode(tls, libc.Int32FromUint16(mode)), int64(-int32(1)))
	if XTcl_ObjSetVar2(tls, interp, varName, field, value, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
		v97 = field
		v96 = *(*TTcl_Size)(unsafe.Pointer(v97))
		*(*TTcl_Size)(unsafe.Pointer(v97))--
		if !(v96 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(-libc.Int32FromInt32(1))
				if v98 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v98 {
					cachePtr41 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v98 || ((*TAllocCache)(unsafe.Pointer(cachePtr41)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr41)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, field)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(field + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr41)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr41)).FfirstObjPtr = field
					(*TAllocCache)(unsafe.Pointer(cachePtr41)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, field)
			}
		}
		return int32(TCL_ERROR)
	}
	v100 = field
	v99 = *(*TTcl_Size)(unsafe.Pointer(v100))
	*(*TTcl_Size)(unsafe.Pointer(v100))--
	if !(v99 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(field)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(field)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(field)).Flength = int64(-libc.Int32FromInt32(1))
			if v101 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v101 {
				cachePtr42 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v101 || ((*TAllocCache)(unsafe.Pointer(cachePtr42)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr42)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, field)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(field + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr42)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr42)).FfirstObjPtr = field
				(*TAllocCache)(unsafe.Pointer(cachePtr42)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, field)
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * GetTypeFromMode --
 *
 *	Given a mode word, returns a string identifying the type of a file.
 *
 * Results:
 *	A static text string giving the file type from mode.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _GetTypeFromMode(tls *libc.TLS, mode int32) (r uintptr) {
	if mode&int32(S_IFMT) == int32(S_IFREG) {
		return __ccgo_ts + 5636
	} else {
		if mode&int32(S_IFMT) == int32(S_IFDIR) {
			return __ccgo_ts + 15675
		} else {
			if mode&int32(S_IFMT) == int32(S_IFCHR) {
				return __ccgo_ts + 15685
			} else {
				if mode&int32(S_IFMT) == int32(S_IFBLK) {
					return __ccgo_ts + 15702
				} else {
					if mode&int32(S_IFMT) == int32(S_IFIFO) {
						return __ccgo_ts + 15715
					} else {
						if mode&int32(S_IFMT) == int32(S_IFLNK) {
							return __ccgo_ts + 5730
						} else {
							if mode&int32(S_IFMT) == int32(S_IFSOCK) {
								return __ccgo_ts + 5562
							}
						}
					}
				}
			}
		}
	}
	return __ccgo_ts + 15720
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ForObjCmd --
 *
 *	This procedure is invoked to process the "for" Tcl command. See the
 *	user documentation for details on what it does.
 *
 *	With the bytecode compiler, this procedure is only called when a
 *	command name is computed at runtime, and is "for" or the name to which
 *	"for" was renamed: e.g.,
 *	"set z for; $z {set i 0} {$i<100} {incr i} {puts $i}"
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 * Notes:
 *	This command is split into a lot of pieces so that it can avoid doing
 *	reentrant TEBC calls. This makes things rather hard to follow, but
 *	here's the plan:
 *
 *	NR:	---------------_ *	Direct:	Tcl_ForObjCmd -> TclNRForObjCmd
 *					|
 *				ForSetupCallback
 *					|
 *	[while] ------------> TclNRForIterCallback <---------.
 *					|		     |
 *				 ForCondCallback	     |
 *					|		     |
 *				 ForNextCallback ------------|
 *					|		     |
 *			       ForPostNextCallback	     |
 *					|____________________|
 *
 *----------------------------------------------------------------------
 */

func XTcl_ForObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	return XTcl_NRCallObjProc(tls, interp, __ccgo_fp(XTclNRForObjCmd), clientData, int64(objc), objv)
}

func XTclNRForObjCmd(tls *libc.TLS, dummy2522 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var _objPtr, _objPtr1, cachePtr, cachePtr1, iPtr uintptr
	var v1, v2 bool
	var _ /* _callbackPtr at bp+8 */ uintptr
	var _ /* iterPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, cachePtr1, iPtr, v1, v2
	iPtr = interp
	if objc != int32(5) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+15728)
		return int32(TCL_ERROR)
	}
	if v1 = interp == libc.UintptrFromInt32(0); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
	(*TForIterData)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fcond = *(*uintptr)(unsafe.Pointer(objv + 2*8))
	(*TForIterData)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbody = *(*uintptr)(unsafe.Pointer(objv + 4*8))
	(*TForIterData)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fnext = *(*uintptr)(unsafe.Pointer(objv + 3*8))
	(*TForIterData)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fmsg = __ccgo_ts + 15752
	(*TForIterData)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fword = int64(4)
	if v2 = interp == libc.UintptrFromInt32(0); !v2 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr1 = XTclThreadAllocObj(tls)
	} else {
		_objPtr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr1 + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 8)) = _objPtr1
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FprocPtr = __ccgo_fp(_ForSetupCallback)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8)) = *(*uintptr)(unsafe.Pointer(bp))
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
	/*
	 * TIP #280. Make invoking context available to initial script.
	 */
	return XTclNREvalObjEx(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), 0, (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr, int32(1))
}

func _ForSetupCallback(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, cachePtr, cachePtr1, iterPtr uintptr
	var v1, v2 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _, _, _, _ = _objPtr, cachePtr, cachePtr1, iterPtr, v1, v2
	iterPtr = *(*uintptr)(unsafe.Pointer(data))
	if result != TCL_OK {
		if result == int32(TCL_ERROR) {
			XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+15778, int64(-int32(1))))
		}
		if v1 = interp == libc.UintptrFromInt32(0); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
		}
		if v1 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
			XTclThreadFreeObj(tls, iterPtr)
		} else {
			(*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(iterPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = iterPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
		}
		return result
	}
	if v2 = interp == libc.UintptrFromInt32(0); !v2 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(XTclNRForIterCallback)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = iterPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
	return TCL_OK
}

func XTclNRForIterCallback(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _objPtr, boolObj, cachePtr, cachePtr1, cachePtr2, iterPtr uintptr
	var v1, v2, v3 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _ = _objPtr, boolObj, cachePtr, cachePtr1, cachePtr2, iterPtr, v1, v2, v3
	iterPtr = *(*uintptr)(unsafe.Pointer(data))
	switch result {
	case TCL_OK:
		fallthrough
	case int32(TCL_CONTINUE):
		/*
		 * We need to reset the result before evaluating the expression.
		 * Otherwise, any error message will be appended to the result of the
		 * last evaluation.
		 */
		XTcl_ResetResult(tls, interp)
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			boolObj = XTclThreadAllocObj(tls)
		} else {
			boolObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(boolObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(boolObj)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(boolObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(boolObj)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(boolObj)).FtypePtr = libc.UintptrFromInt32(0)
		if v2 = interp == libc.UintptrFromInt32(0); !v2 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
		}
		if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			_objPtr = XTclThreadAllocObj(tls)
		} else {
			_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(_objPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(_ForCondCallback)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = iterPtr
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = boolObj
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
		(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
		return XTcl_NRExprObj(tls, interp, (*TForIterData)(unsafe.Pointer(iterPtr)).Fcond, boolObj)
	case int32(TCL_BREAK):
		result = TCL_OK
		XTcl_ResetResult(tls, interp)
	case int32(TCL_ERROR):
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, (*TForIterData)(unsafe.Pointer(iterPtr)).Fmsg, libc.VaList(bp+16, XTcl_GetErrorLine(tls, interp))))
	}
	if v3 = interp == libc.UintptrFromInt32(0); !v3 {
		cachePtr2 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
		XTclThreadFreeObj(tls, iterPtr)
	} else {
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(iterPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = iterPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
	}
	return result
}

func _ForCondCallback(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, boolObj, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, iPtr, iterPtr, v2, v5, v8 uintptr
	var v1, v4, v7 TTcl_Size
	var v10, v11, v3, v6, v9 bool
	var _ /* _callbackPtr at bp+16 */ uintptr
	var _ /* _callbackPtr at bp+8 */ uintptr
	var _ /* value at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, boolObj, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, iPtr, iterPtr, v1, v10, v11, v2, v3, v4, v5, v6, v7, v8, v9
	iPtr = interp
	iterPtr = *(*uintptr)(unsafe.Pointer(data))
	boolObj = *(*uintptr)(unsafe.Pointer(data + 1*8))
	if result != TCL_OK {
		_objPtr = boolObj
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		if v3 = interp == libc.UintptrFromInt32(0); !v3 {
			cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
		}
		if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
			XTclThreadFreeObj(tls, iterPtr)
		} else {
			(*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(iterPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = iterPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
		}
		return result
	} else {
		if XTcl_GetBoolFromObj(tls, interp, boolObj, (libc.Int32FromInt32(TCL_NULL_OK)-libc.Int32FromInt32(2))&libc.Int32FromInt64(4), bp) != TCL_OK {
			_objPtr1 = boolObj
			v5 = _objPtr1
			v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
			*(*TTcl_Size)(unsafe.Pointer(v5))--
			if v4 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
			if v6 = interp == libc.UintptrFromInt32(0); !v6 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
			}
			if v6 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, iterPtr)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(iterPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = iterPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
			}
			return int32(TCL_ERROR)
		}
	}
	_objPtr2 = boolObj
	v8 = _objPtr2
	v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
	*(*TTcl_Size)(unsafe.Pointer(v8))--
	if v7 <= int64(1) {
		XTclFreeObj(tls, _objPtr2)
	}
	if *(*int32)(unsafe.Pointer(bp)) != 0 {
		/* TIP #280. */
		if (*TForIterData)(unsafe.Pointer(iterPtr)).Fnext != 0 {
			if v9 = interp == libc.UintptrFromInt32(0); !v9 {
				cachePtr2 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
			}
			if v9 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
				_objPtr3 = XTclThreadAllocObj(tls)
			} else {
				_objPtr3 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(_objPtr3 + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
			}
			*(*uintptr)(unsafe.Pointer(bp + 8)) = _objPtr3
			(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FprocPtr = __ccgo_fp(_ForNextCallback)
			*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8)) = iterPtr
			*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
			*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
			*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
			(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
			(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
		} else {
			if v10 = interp == libc.UintptrFromInt32(0); !v10 {
				cachePtr3 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
			}
			if v10 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
				_objPtr4 = XTclThreadAllocObj(tls)
			} else {
				_objPtr4 = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(_objPtr4 + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
			}
			*(*uintptr)(unsafe.Pointer(bp + 16)) = _objPtr4
			(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FprocPtr = __ccgo_fp(XTclNRForIterCallback)
			*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8)) = iterPtr
			*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
			*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
			*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
			(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
			(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 16))
		}
		return XTclNREvalObjEx(tls, interp, (*TForIterData)(unsafe.Pointer(iterPtr)).Fbody, 0, (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr, int32((*TForIterData)(unsafe.Pointer(iterPtr)).Fword))
	}
	if v11 = interp == libc.UintptrFromInt32(0); !v11 {
		cachePtr4 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v11 || ((*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
		XTclThreadFreeObj(tls, iterPtr)
	} else {
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(iterPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = iterPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects++
	}
	return result
}

func _ForNextCallback(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, _objPtr1, cachePtr, cachePtr1, iPtr, iterPtr, next uintptr
	var v1, v2 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	var _ /* _callbackPtr at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, cachePtr1, iPtr, iterPtr, next, v1, v2
	iPtr = interp
	iterPtr = *(*uintptr)(unsafe.Pointer(data))
	next = (*TForIterData)(unsafe.Pointer(iterPtr)).Fnext
	if result == TCL_OK || result == int32(TCL_CONTINUE) {
		if v1 = interp == libc.UintptrFromInt32(0); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			_objPtr = XTclThreadAllocObj(tls)
		} else {
			_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(_objPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(_ForPostNextCallback)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = iterPtr
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
		(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
		/*
		 * TIP #280. Make invoking context available to next script.
		 */
		return XTclNREvalObjEx(tls, interp, next, 0, (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr, int32(3))
	}
	if v2 = interp == libc.UintptrFromInt32(0); !v2 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr1 = XTclThreadAllocObj(tls)
	} else {
		_objPtr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr1 + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 8)) = _objPtr1
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FprocPtr = __ccgo_fp(XTclNRForIterCallback)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8)) = iterPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
	return result
}

func _ForPostNextCallback(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, cachePtr, cachePtr1, iterPtr uintptr
	var v1, v2 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _, _, _, _ = _objPtr, cachePtr, cachePtr1, iterPtr, v1, v2
	iterPtr = *(*uintptr)(unsafe.Pointer(data))
	if result != int32(TCL_BREAK) && result != TCL_OK {
		if result == int32(TCL_ERROR) {
			XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+15807, int64(-int32(1))))
			if v1 = interp == libc.UintptrFromInt32(0); !v1 {
				cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
			}
			if v1 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, iterPtr)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(iterPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = iterPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
			}
		}
		return result
	}
	if v2 = interp == libc.UintptrFromInt32(0); !v2 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(XTclNRForIterCallback)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = iterPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ForeachObjCmd, TclNRForeachCmd, EachloopCmd --
 *
 *	This object-based procedure is invoked to process the "foreach" Tcl
 *	command. See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl object result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ForeachObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	return XTcl_NRCallObjProc(tls, interp, __ccgo_fp(XTclNRForeachCmd), clientData, int64(objc), objv)
}

func XTclNRForeachCmd(tls *libc.TLS, dummy2716 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	return _EachloopCmd(tls, interp, TCL_EACH_KEEP_NONE, objc, objv)
}

func XTcl_LmapObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	return XTcl_NRCallObjProc(tls, interp, __ccgo_fp(XTclNRLmapCmd), clientData, int64(objc), objv)
}

func XTclNRLmapCmd(tls *libc.TLS, dummy2736 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	return _EachloopCmd(tls, interp, int32(TCL_EACH_COLLECT), objc, objv)
}

func _EachloopCmd(tls *libc.TLS, interp uintptr, collect int32, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var _objPtr, cachePtr, proc, statePtr, v10, v11, v4, v5, v9 uintptr
	var i, numLists, result, v14, v2 int32
	var j, v12 TTcl_Size
	var v15, v16, v3, v7, v8 int64
	var v17 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, i, j, numLists, proc, result, statePtr, v10, v11, v12, v14, v15, v16, v17, v2, v3, v4, v5, v7, v8, v9
	numLists = (objc - int32(2)) / int32(2)
	if objc < int32(4) || objc%int32(2) != 0 {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+15837)
		return int32(TCL_ERROR)
	}
	/*
	 * Manage numList parallel value lists.
	 * statePtr->argvList[i] is a value list counted by statePtr->argcList[i];
	 * statePtr->varvList[i] is the list of variables associated with the
	 *		value list;
	 * statePtr->varcList[i] is the number of variables associated with the
	 *		value list;
	 * statePtr->index[i] is the current pointer into the value list
	 *		statePtr->argvList[i].
	 *
	 * The setting up of all of these pointers is moderately messy, but allows
	 * the rest of this code to be simple and for us to use a single memory
	 * allocation for better performance.
	 */
	statePtr = XTclStackAlloc(tls, interp, uint64(104)+libc.Uint64FromInt32(int32(3)*numLists)*uint64(8)+libc.Uint64FromInt32(int32(2)*numLists)*(libc.Uint64FromInt64(8)+libc.Uint64FromInt64(8)))
	libc.Xmemset(tls, statePtr, 0, uint64(104)+libc.Uint64FromInt32(int32(3)*numLists)*uint64(8)+libc.Uint64FromInt32(int32(2)*numLists)*(libc.Uint64FromInt64(8)+libc.Uint64FromInt64(8)))
	(*TForeachState)(unsafe.Pointer(statePtr)).FvarvList = statePtr + libc.UintptrFromInt32(1)*104
	(*TForeachState)(unsafe.Pointer(statePtr)).FargvList = (*TForeachState)(unsafe.Pointer(statePtr)).FvarvList + uintptr(numLists)*8
	(*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList = (*TForeachState)(unsafe.Pointer(statePtr)).FargvList + uintptr(numLists)*8
	(*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList = (*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList + uintptr(numLists)*8
	(*TForeachState)(unsafe.Pointer(statePtr)).Findex = (*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(numLists)*8
	(*TForeachState)(unsafe.Pointer(statePtr)).FvarcList = (*TForeachState)(unsafe.Pointer(statePtr)).Findex + uintptr(numLists)*8
	(*TForeachState)(unsafe.Pointer(statePtr)).FargcList = (*TForeachState)(unsafe.Pointer(statePtr)).FvarcList + uintptr(numLists)*8
	(*TForeachState)(unsafe.Pointer(statePtr)).FnumLists = int64(numLists)
	(*TForeachState)(unsafe.Pointer(statePtr)).FbodyPtr = *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8))
	(*TForeachState)(unsafe.Pointer(statePtr)).FbodyIdx = int64(objc - int32(1))
	if collect == int32(TCL_EACH_COLLECT) {
		(*TForeachState)(unsafe.Pointer(statePtr)).FresultList = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
	} else {
		(*TForeachState)(unsafe.Pointer(statePtr)).FresultList = libc.UintptrFromInt32(0)
	}
	/*
	 * Break up the value lists and variable lists into elements.
	 */
	i = 0
	for {
		if !(i < numLists) {
			break
		}
		/* List */
		/* Variables */
		*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList + uintptr(i)*8)) = XTclListObjCopy(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(int32(1)+i*int32(2))*8)))
		if *(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			result = int32(TCL_ERROR)
			goto done
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList + uintptr(i)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList + uintptr(i)*8)) + 32))).Fptr2 != 0 {
				v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList + uintptr(i)*8)) + 32))).Fptr2)).FspanLength
			} else {
				v3 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList + uintptr(i)*8)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvarcList + uintptr(i)*8)) = v3
			v2 = libc.Int32FromInt32(TCL_OK)
		} else {
			v2 = XTcl_ListObjLength(tls, interp, *(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList + uintptr(i)*8)), (*TForeachState)(unsafe.Pointer(statePtr)).FvarcList+uintptr(i)*8)
		}
		result = v2
		if result != TCL_OK {
			result = int32(TCL_ERROR)
			goto done
		}
		if *(*TTcl_Size)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvarcList + uintptr(i)*8)) < int64(1) {
			if (*TForeachState)(unsafe.Pointer(statePtr)).FresultList != libc.UintptrFromInt32(0) {
				v4 = __ccgo_ts + 5269
			} else {
				v4 = __ccgo_ts + 5191
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+15877, libc.VaList(bp+16, v4)))
			if (*TForeachState)(unsafe.Pointer(statePtr)).FresultList != libc.UintptrFromInt32(0) {
				v5 = __ccgo_ts + 15897
			} else {
				v5 = __ccgo_ts + 15902
			}
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+8210, v5, __ccgo_ts+15910, libc.UintptrFromInt32(0)))
			result = int32(TCL_ERROR)
			goto done
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList + uintptr(i)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList + uintptr(i)*8)) + 32))).Fptr2 != 0 {
				v7 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList + uintptr(i)*8)) + 32))).Fptr2)).FspanStart
			} else {
				v7 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList + uintptr(i)*8)) + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvarvList + uintptr(i)*8)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList + uintptr(i)*8)) + 32))).Fptr1 + 40 + uintptr(v7)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList + uintptr(i)*8)) + 32))).Fptr2 != 0 {
				v8 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList + uintptr(i)*8)) + 32))).Fptr2)).FspanLength
			} else {
				v8 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList + uintptr(i)*8)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvarcList + uintptr(i)*8)) = v8
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList + uintptr(i)*8)), (*TForeachState)(unsafe.Pointer(statePtr)).FvarcList+uintptr(i)*8, (*TForeachState)(unsafe.Pointer(statePtr)).FvarvList+uintptr(i)*8)
		}
		/* Values */
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(int32(2)+i*int32(2))*8)))).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+56) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+56) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(int32(2)+i*int32(2))*8)))).FtypePtr)).Fversion) {
			v9 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(int32(2)+i*int32(2))*8)))).FtypePtr)).FindexProc
		} else {
			v9 = libc.UintptrFromInt32(0)
		}
		if v9 != 0 {
			/* Special case for AbstractList */
			*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8)) = XTcl_DuplicateObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(int32(2)+i*int32(2))*8)))
			if *(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				result = int32(TCL_ERROR)
				goto done
			}
			/* Don't compute values here, wait until the last moment */
			v10 = *(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8))
			if (*TTcl_Obj)(unsafe.Pointer(v10)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+48) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+48) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v10)).FtypePtr)).Fversion) {
				v11 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v10)).FtypePtr)).FlengthProc
			} else {
				v11 = libc.UintptrFromInt32(0)
			}
			proc = v11
			v12 = (*(*func(*libc.TLS, uintptr) TTcl_Size)(unsafe.Pointer(&struct{ uintptr }{proc})))(tls, v10)
			goto _13
		_13:
			*(*TTcl_Size)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FargcList + uintptr(i)*8)) = v12
		} else {
			/* List values */
			*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8)) = XTclListObjCopy(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(int32(2)+i*int32(2))*8)))
			if *(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				result = int32(TCL_ERROR)
				goto done
			}
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8)) + 32))).Fptr2 != 0 {
					v15 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8)) + 32))).Fptr2)).FspanStart
				} else {
					v15 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8)) + 32))).Fptr1)).FfirstUsed
				}
				*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FargvList + uintptr(i)*8)) = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8)) + 32))).Fptr1 + 40 + uintptr(v15)*8
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8)) + 32))).Fptr2 != 0 {
					v16 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8)) + 32))).Fptr2)).FspanLength
				} else {
					v16 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8)) + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FargcList + uintptr(i)*8)) = v16
				v14 = libc.Int32FromInt32(TCL_OK)
			} else {
				v14 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8)), (*TForeachState)(unsafe.Pointer(statePtr)).FargcList+uintptr(i)*8, (*TForeachState)(unsafe.Pointer(statePtr)).FargvList+uintptr(i)*8)
			}
			result = v14
			if result != TCL_OK {
				goto done
			}
		}
		/* account for variable <> value mismatch */
		j = *(*TTcl_Size)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FargcList + uintptr(i)*8)) / *(*TTcl_Size)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvarcList + uintptr(i)*8))
		if *(*TTcl_Size)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FargcList + uintptr(i)*8))%*(*TTcl_Size)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvarcList + uintptr(i)*8)) != 0 {
			j++
		}
		if j > (*TForeachState)(unsafe.Pointer(statePtr)).Fmaxj {
			(*TForeachState)(unsafe.Pointer(statePtr)).Fmaxj = j
		}
		goto _1
	_1:
		;
		i++
	}
	/*
	 * If there is any work to do, assign the variables and set things going
	 * non-recursively.
	 */
	if (*TForeachState)(unsafe.Pointer(statePtr)).Fmaxj > 0 {
		result = _ForeachAssignments(tls, interp, statePtr)
		if result == int32(TCL_ERROR) {
			goto done
		}
		if v17 = interp == libc.UintptrFromInt32(0); !v17 {
			cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
		}
		if v17 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			_objPtr = XTclThreadAllocObj(tls)
		} else {
			_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(_objPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(_ForeachLoopStep)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = statePtr
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
		(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
		return XTclNREvalObjEx(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), 0, (*TInterp)(unsafe.Pointer(interp)).FcmdFramePtr, objc-int32(1))
	}
	/*
	 * This cleanup stage is only used when an error occurs during setup or if
	 * there is no work to do.
	 */
	result = TCL_OK
	goto done
done:
	;
	_ForeachCleanup(tls, interp, statePtr)
	return result
}

/*
 * Post-body processing handler.
 */

func _ForeachLoopStep(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _objPtr, cachePtr, statePtr, v1, v3 uintptr
	var v2 TTcl_Size
	var v4 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _ = _objPtr, cachePtr, statePtr, v1, v2, v3, v4
	statePtr = *(*uintptr)(unsafe.Pointer(data))
	/*
	 * Process the result code from this run of the [foreach] body. Note that
	 * this switch uses fallthroughs in several places. Maintainer aware!
	 */
	switch result {
	case int32(TCL_CONTINUE):
		result = TCL_OK
	case TCL_OK:
		if (*TForeachState)(unsafe.Pointer(statePtr)).FresultList != libc.UintptrFromInt32(0) {
			result = XTcl_ListObjAppendElement(tls, interp, (*TForeachState)(unsafe.Pointer(statePtr)).FresultList, XTcl_GetObjResult(tls, interp))
			if result != TCL_OK {
				/* e.g. memory alloc failure on big data tests */
				goto done
			}
		}
	case int32(TCL_BREAK):
		result = TCL_OK
		goto finish
	case int32(TCL_ERROR):
		if (*TForeachState)(unsafe.Pointer(statePtr)).FresultList != libc.UintptrFromInt32(0) {
			v1 = __ccgo_ts + 5269
		} else {
			v1 = __ccgo_ts + 5191
		}
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+15919, libc.VaList(bp+16, v1, XTcl_GetErrorLine(tls, interp))))
		fallthrough
	default:
		goto done
	}
	/*
	 * Test if there is work still to be done. If so, do the next round of
	 * variable assignments, reschedule ourselves and run the body again.
	 */
	v3 = statePtr + 16
	*(*TTcl_Size)(unsafe.Pointer(v3))++
	v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
	if (*TForeachState)(unsafe.Pointer(statePtr)).Fmaxj > v2 {
		result = _ForeachAssignments(tls, interp, statePtr)
		if result == int32(TCL_ERROR) {
			goto done
		}
		if v4 = interp == libc.UintptrFromInt32(0); !v4 {
			cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
		}
		if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			_objPtr = XTclThreadAllocObj(tls)
		} else {
			_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(_objPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(_ForeachLoopStep)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = statePtr
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
		(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
		return XTclNREvalObjEx(tls, interp, (*TForeachState)(unsafe.Pointer(statePtr)).FbodyPtr, 0, (*TInterp)(unsafe.Pointer(interp)).FcmdFramePtr, int32((*TForeachState)(unsafe.Pointer(statePtr)).FbodyIdx))
	}
	/*
	 * We're done. Tidy up our work space and finish off.
	 */
	goto finish
finish:
	;
	if (*TForeachState)(unsafe.Pointer(statePtr)).FresultList == libc.UintptrFromInt32(0) {
		XTcl_ResetResult(tls, interp)
	} else {
		XTcl_SetObjResult(tls, interp, (*TForeachState)(unsafe.Pointer(statePtr)).FresultList)
		(*TForeachState)(unsafe.Pointer(statePtr)).FresultList = libc.UintptrFromInt32(0) /* Don't clean it up */
	}
	goto done
done:
	;
	_ForeachCleanup(tls, interp, statePtr)
	return result
}

/*
 * Factored out code to do the assignments in [foreach].
 */

func _ForeachAssignments(tls *libc.TLS, interp1 uintptr, statePtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var cachePtr, proc, varValuePtr, v10, v11, v13, v14, v2, v5, v6, v7 uintptr
	var i, isAbstractList, v8 int32
	var k, v, v4 TTcl_Size
	var v12 bool
	var _ /* valuePtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, i, isAbstractList, k, proc, v, varValuePtr, v10, v11, v12, v13, v14, v2, v4, v5, v6, v7, v8
	i = 0
	for {
		if !(int64(i) < (*TForeachState)(unsafe.Pointer(statePtr)).FnumLists) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8)))).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+56) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+56) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8)))).FtypePtr)).Fversion) {
			v2 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8)))).FtypePtr)).FindexProc
		} else {
			v2 = libc.UintptrFromInt32(0)
		}
		isAbstractList = libc.BoolInt32(v2 != libc.UintptrFromInt32(0))
		v = 0
		for {
			if !(v < *(*TTcl_Size)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvarcList + uintptr(i)*8))) {
				break
			}
			v5 = (*TForeachState)(unsafe.Pointer(statePtr)).Findex + uintptr(i)*8
			v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
			*(*TTcl_Size)(unsafe.Pointer(v5))++
			k = v4
			if k < *(*TTcl_Size)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FargcList + uintptr(i)*8)) {
				if isAbstractList != 0 {
					v6 = *(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8))
					if (*TTcl_Obj)(unsafe.Pointer(v6)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+56) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+56) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v6)).FtypePtr)).Fversion) {
						v7 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v6)).FtypePtr)).FindexProc
					} else {
						v7 = libc.UintptrFromInt32(0)
					}
					proc = v7
					v8 = (*(*func(*libc.TLS, uintptr, uintptr, TTcl_Size, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{proc})))(tls, interp1, v6, k, bp)
					goto _9
				_9:
					if v8 != TCL_OK {
						if (*TForeachState)(unsafe.Pointer(statePtr)).FresultList != libc.UintptrFromInt32(0) {
							v10 = __ccgo_ts + 5269
						} else {
							v10 = __ccgo_ts + 5191
						}
						if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvarvList + uintptr(i)*8)) + uintptr(v)*8)))).Fbytes != 0 {
							v11 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvarvList + uintptr(i)*8)) + uintptr(v)*8)))).Fbytes
						} else {
							v11 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvarvList + uintptr(i)*8)) + uintptr(v)*8)), libc.UintptrFromInt32(0))
						}
						XTcl_AppendObjToErrorInfo(tls, interp1, XTcl_ObjPrintf(tls, __ccgo_ts+15944, libc.VaList(bp+16, v10, v11)))
						return int32(TCL_ERROR)
					}
				} else {
					*(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FargvList + uintptr(i)*8)) + uintptr(k)*8))
				}
			} else {
				if v12 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v12 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v12 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
					*(*uintptr)(unsafe.Pointer(bp)) = XTclThreadAllocObj(tls)
				} else {
					*(*uintptr)(unsafe.Pointer(bp)) = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Flength = 0
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr = libc.UintptrFromInt32(0) /* Empty string */
			}
			varValuePtr = XTcl_ObjSetVar2(tls, interp1, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvarvList + uintptr(i)*8)) + uintptr(v)*8)), libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), int32(TCL_LEAVE_ERR_MSG))
			if varValuePtr == libc.UintptrFromInt32(0) {
				if (*TForeachState)(unsafe.Pointer(statePtr)).FresultList != libc.UintptrFromInt32(0) {
					v13 = __ccgo_ts + 5269
				} else {
					v13 = __ccgo_ts + 5191
				}
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvarvList + uintptr(i)*8)) + uintptr(v)*8)))).Fbytes != 0 {
					v14 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvarvList + uintptr(i)*8)) + uintptr(v)*8)))).Fbytes
				} else {
					v14 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvarvList + uintptr(i)*8)) + uintptr(v)*8)), libc.UintptrFromInt32(0))
				}
				XTcl_AppendObjToErrorInfo(tls, interp1, XTcl_ObjPrintf(tls, __ccgo_ts+15944, libc.VaList(bp+16, v13, v14)))
				return int32(TCL_ERROR)
			}
			goto _3
		_3:
			;
			v++
		}
		goto _1
	_1:
		;
		i++
	}
	return TCL_OK
}

/*
 * Factored out code for cleaning up the state of the foreach.
 */

func _ForeachCleanup(tls *libc.TLS, interp uintptr, statePtr uintptr) {
	var cachePtr, cachePtr1, cachePtr2, v3, v6, v9 uintptr
	var i int32
	var v10, v4, v7 bool
	var v2, v5, v8 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, i, v10, v2, v3, v4, v5, v6, v7, v8, v9
	i = 0
	for {
		if !(int64(i) < (*TForeachState)(unsafe.Pointer(statePtr)).FnumLists) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList + uintptr(i)*8)) != 0 {
			v3 = *(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList + uintptr(i)*8))
			v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
			*(*TTcl_Size)(unsafe.Pointer(v3))--
			if !(v2 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList + uintptr(i)*8)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList + uintptr(i)*8)))).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList + uintptr(i)*8)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList + uintptr(i)*8)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList + uintptr(i)*8)))).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList + uintptr(i)*8)))).Flength = int64(-libc.Int32FromInt32(1))
					if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
						cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v4 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList + uintptr(i)*8)))
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList + uintptr(i)*8)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList + uintptr(i)*8))
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FvCopyList + uintptr(i)*8)))
				}
			}
		}
		if *(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8)) != 0 {
			v6 = *(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8))
			v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
			*(*TTcl_Size)(unsafe.Pointer(v6))--
			if !(v5 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8)))).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8)))).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8)))).Flength = int64(-libc.Int32FromInt32(1))
					if v7 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v7 {
						cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v7 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8)))
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8))
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FaCopyList + uintptr(i)*8)))
				}
			}
		}
		goto _1
	_1:
		;
		i++
	}
	if (*TForeachState)(unsafe.Pointer(statePtr)).FresultList != libc.UintptrFromInt32(0) {
		v9 = (*TForeachState)(unsafe.Pointer(statePtr)).FresultList
		v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
		*(*TTcl_Size)(unsafe.Pointer(v9))--
		if !(v8 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FresultList)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FresultList)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FresultList)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FresultList)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FresultList)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FresultList)).Flength = int64(-libc.Int32FromInt32(1))
				if v10 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v10 {
					cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v10 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, (*TForeachState)(unsafe.Pointer(statePtr)).FresultList)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer((*TForeachState)(unsafe.Pointer(statePtr)).FresultList + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*TForeachState)(unsafe.Pointer(statePtr)).FresultList
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, (*TForeachState)(unsafe.Pointer(statePtr)).FresultList)
			}
		}
	}
	XTclStackFree(tls, interp, statePtr)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FormatObjCmd --
 *
 *	This procedure is invoked to process the "format" Tcl command. See
 *	the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FormatObjCmd(tls *libc.TLS, dummy3065 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var resultPtr, v1 uintptr
	_, _ = resultPtr, v1 /* Where result is stored finally. */
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+10699)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	resultPtr = XTcl_Format(tls, interp, v1, int64(objc-int32(2)), objv+uintptr(2)*8)
	if resultPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, resultPtr)
	return TCL_OK
}

const MAXCALLOC = 1024000
const NUM_LISTS = 30
const SORTMODE_ASCII = 0
const SORTMODE_ASCII_NC = 8
const SORTMODE_COMMAND = 3
const SORTMODE_DICTIONARY = 4
const SORTMODE_INTEGER = 1
const SORTMODE_REAL = 2
const __REG_WIDE_COMPILE = 0
const __REG_WIDE_EXEC = 0
const __REG_WIDE_T = 0

type TTclRegexp = struct {
	Fflags      int32
	Fre         Tregex_t
	Fstring1    uintptr
	FobjPtr     uintptr
	FglobObjPtr uintptr
	Fmatches    uintptr
	Fdetails    Trm_detail_t
	FrefCount   TTcl_Size
}

/*
 * During execution of the "lsort" command, structures of the following type
 * are used to arrange the objects being sorted into a collection of linked
 * lists.
 */

type TSortElement = struct {
	FcollationKey struct {
		FwideValue   [0]TTcl_WideInt
		FdoubleValue [0]float64
		FobjValuePtr [0]uintptr
		FstrValuePtr uintptr
	}
	Fpayload struct {
		Findex  [0]Tsize_t
		FobjPtr uintptr
	}
	FnextPtr uintptr
}

/*
 * These function pointer types are used with the "lsearch" and "lsort"
 * commands to facilitate the "-nocase" option.
 */

type TSortStrCmpFn_t = uintptr

type TSortMemCmpFn_t = uintptr

/*
 * The "lsort" command needs to pass certain information down to the function
 * that compares two list elements, and the comparison function needs to pass
 * success or failure information back up to the top-level "lsort" command.
 * The following structure is used to pass this information.
 */

type TSortInfo = struct {
	FisIncreasing  int32
	FsortMode      int32
	FcompareCmdPtr uintptr
	Findexv        uintptr
	Findexc        TTcl_Size
	FsingleIndex   int32
	Funique        int32
	FnumElements   int32
	Finterp        uintptr
	FresultCode    int32
}

/*
 * The "sortMode" field of the SortInfo structure can take on any of the
 * following values.
 */

// C documentation
//
//	/*
//	 * Definitions for [lseq] command
//	 */
var _seq_operations = [5]uintptr{
	0: __ccgo_ts + 15981,
	1: __ccgo_ts + 15984,
	2: __ccgo_ts + 3682,
	3: __ccgo_ts + 15987,
	4: libc.UintptrFromInt32(0),
}

type TSequenceOperators = int32

const LSEQ_DOTS = 0
const LSEQ_TO = 1
const LSEQ_COUNT = 2
const LSEQ_BY = 3

type TSequenceDecoded = int32

const NoneArg = 0
const NumericArg = 1
const RangeKeywordArg = 2
const ErrArg = 3
const LastArg = 8

/*
 * Array of values describing how to implement each standard subcommand of the
 * "info" command.
 */

var _defaultInfoMap = [28]TEnsembleImplMap{
	0: {
		Fname: __ccgo_ts + 15990,
	},
	1: {
		Fname: __ccgo_ts + 15995,
	},
	2: {
		Fname: __ccgo_ts + 16000,
	},
	3: {
		Fname:   __ccgo_ts + 5878,
		Funsafe: int32(1),
	},
	4: {
		Fname: __ccgo_ts + 16009,
	},
	5: {
		Fname: __ccgo_ts + 16018,
	},
	6: {
		Fname: __ccgo_ts + 16027,
	},
	7: {
		Fname: __ccgo_ts + 16036,
	},
	8: {
		Fname: __ccgo_ts + 5171,
	},
	9: {
		Fname: __ccgo_ts + 16043,
	},
	10: {
		Fname: __ccgo_ts + 16051,
	},
	11: {
		Fname: __ccgo_ts + 5689,
	},
	12: {
		Fname: __ccgo_ts + 16062,
	},
	13: {
		Fname: __ccgo_ts + 16068,
	},
	14: {
		Fname: __ccgo_ts + 16078,
	},
	15: {
		Fname: __ccgo_ts + 16086,
	},
	16: {
		Fname: __ccgo_ts + 16095,
	},
	17: {
		Fname: __ccgo_ts + 16101,
	},
	18: {
		Fname: __ccgo_ts + 16109,
	},
	19: {
		Fname: __ccgo_ts + 16116,
	},
	20: {
		Fname:   __ccgo_ts + 5886,
		Funsafe: int32(1),
	},
	21: {
		Fname: __ccgo_ts + 6370,
	},
	22: {
		Fname: __ccgo_ts + 16123,
	},
	23: {
		Fname: __ccgo_ts + 3702,
	},
	24: {
		Fname: __ccgo_ts + 16129,
	},
	25: {
		Fname: __ccgo_ts + 16148,
	},
	26: {
		Fname: __ccgo_ts + 16159,
	},
	27: {},
}

func init() {
	p := unsafe.Pointer(&_defaultInfoMap)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_InfoArgsCmd)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(_InfoBodyCmd)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(_InfoCmdCountCmd)
	*(*uintptr)(unsafe.Add(p, 112)) = __ccgo_fp(XTclCompileBasic0ArgCmd)
	*(*uintptr)(unsafe.Add(p, 152)) = __ccgo_fp(_InfoCmdTypeCmd)
	*(*uintptr)(unsafe.Add(p, 160)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 200)) = __ccgo_fp(_InfoCommandsCmd)
	*(*uintptr)(unsafe.Add(p, 208)) = __ccgo_fp(XTclCompileInfoCommandsCmd)
	*(*uintptr)(unsafe.Add(p, 248)) = __ccgo_fp(_InfoCompleteCmd)
	*(*uintptr)(unsafe.Add(p, 256)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 296)) = __ccgo_fp(XTclInfoConstantCmd)
	*(*uintptr)(unsafe.Add(p, 304)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 344)) = __ccgo_fp(XTclInfoConstsCmd)
	*(*uintptr)(unsafe.Add(p, 352)) = __ccgo_fp(XTclCompileBasic0Or1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 392)) = __ccgo_fp(XTclInfoCoroutineCmd)
	*(*uintptr)(unsafe.Add(p, 400)) = __ccgo_fp(XTclCompileInfoCoroutineCmd)
	*(*uintptr)(unsafe.Add(p, 440)) = __ccgo_fp(_InfoDefaultCmd)
	*(*uintptr)(unsafe.Add(p, 448)) = __ccgo_fp(XTclCompileBasic3ArgCmd)
	*(*uintptr)(unsafe.Add(p, 488)) = __ccgo_fp(_InfoErrorStackCmd)
	*(*uintptr)(unsafe.Add(p, 496)) = __ccgo_fp(XTclCompileBasic0Or1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 536)) = __ccgo_fp(XTclInfoExistsCmd)
	*(*uintptr)(unsafe.Add(p, 544)) = __ccgo_fp(XTclCompileInfoExistsCmd)
	*(*uintptr)(unsafe.Add(p, 584)) = __ccgo_fp(_InfoFrameCmd)
	*(*uintptr)(unsafe.Add(p, 592)) = __ccgo_fp(XTclCompileBasic0Or1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 632)) = __ccgo_fp(_InfoFunctionsCmd)
	*(*uintptr)(unsafe.Add(p, 640)) = __ccgo_fp(XTclCompileBasic0Or1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 680)) = __ccgo_fp(XTclInfoGlobalsCmd)
	*(*uintptr)(unsafe.Add(p, 688)) = __ccgo_fp(XTclCompileBasic0Or1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 728)) = __ccgo_fp(_InfoHostnameCmd)
	*(*uintptr)(unsafe.Add(p, 736)) = __ccgo_fp(XTclCompileBasic0ArgCmd)
	*(*uintptr)(unsafe.Add(p, 776)) = __ccgo_fp(_InfoLevelCmd)
	*(*uintptr)(unsafe.Add(p, 784)) = __ccgo_fp(XTclCompileInfoLevelCmd)
	*(*uintptr)(unsafe.Add(p, 824)) = __ccgo_fp(_InfoLibraryCmd)
	*(*uintptr)(unsafe.Add(p, 832)) = __ccgo_fp(XTclCompileBasic0ArgCmd)
	*(*uintptr)(unsafe.Add(p, 872)) = __ccgo_fp(_InfoLoadedCmd)
	*(*uintptr)(unsafe.Add(p, 880)) = __ccgo_fp(XTclCompileBasic0Or1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 920)) = __ccgo_fp(XTclInfoLocalsCmd)
	*(*uintptr)(unsafe.Add(p, 928)) = __ccgo_fp(XTclCompileBasic0Or1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 968)) = __ccgo_fp(_InfoNameOfExecutableCmd)
	*(*uintptr)(unsafe.Add(p, 976)) = __ccgo_fp(XTclCompileBasic0ArgCmd)
	*(*uintptr)(unsafe.Add(p, 1016)) = __ccgo_fp(_InfoPatchLevelCmd)
	*(*uintptr)(unsafe.Add(p, 1024)) = __ccgo_fp(XTclCompileBasic0ArgCmd)
	*(*uintptr)(unsafe.Add(p, 1064)) = __ccgo_fp(_InfoProcsCmd)
	*(*uintptr)(unsafe.Add(p, 1072)) = __ccgo_fp(XTclCompileBasic0Or1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 1112)) = __ccgo_fp(_InfoScriptCmd)
	*(*uintptr)(unsafe.Add(p, 1120)) = __ccgo_fp(XTclCompileBasic0Or1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 1160)) = __ccgo_fp(_InfoSharedlibCmd)
	*(*uintptr)(unsafe.Add(p, 1168)) = __ccgo_fp(XTclCompileBasic0ArgCmd)
	*(*uintptr)(unsafe.Add(p, 1208)) = __ccgo_fp(_InfoTclVersionCmd)
	*(*uintptr)(unsafe.Add(p, 1216)) = __ccgo_fp(XTclCompileBasic0ArgCmd)
	*(*uintptr)(unsafe.Add(p, 1256)) = __ccgo_fp(XTclInfoVarsCmd)
	*(*uintptr)(unsafe.Add(p, 1264)) = __ccgo_fp(XTclCompileBasic0Or1ArgCmd)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_IfObjCmd --
 *
 *	This procedure is invoked to process the "if" Tcl command. See the
 *	user documentation for details on what it does.
 *
 *	With the bytecode compiler, this procedure is only called when a
 *	command name is computed at runtime, and is "if" or the name to which
 *	"if" was renamed: e.g., "set z if; $z 1 {puts foo}"
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_IfObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	return XTcl_NRCallObjProc(tls, interp, __ccgo_fp(XTclNRIfObjCmd), clientData, int64(objc), objv)
}

func XTclNRIfObjCmd(tls *libc.TLS, dummy216 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Argument objects. */
	var boolObj, cachePtr, v1 uintptr
	var v2 bool
	_, _, _, _ = boolObj, cachePtr, v1, v2
	if objc <= int32(1) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+16164, libc.VaList(bp+8, v1)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+9101, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * At this point, objv[1] refers to the main expression to test. The
	 * arguments after the expression must be "then" (optional) and a script
	 * to execute if the expression is true.
	 */
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		boolObj = XTclThreadAllocObj(tls)
	} else {
		boolObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(boolObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(boolObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(boolObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(boolObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(boolObj)).FtypePtr = libc.UintptrFromInt32(0)
	XTcl_NRAddCallback(tls, interp, __ccgo_fp(_IfConditionCallback), uintptr(int64(objc)), objv, uintptr(int64(libc.Int32FromInt32(1))), boolObj)
	return XTcl_NRExprObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), boolObj)
}

func _IfConditionCallback(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var boolObj, cachePtr, cachePtr1, cachePtr2, cachePtr3, clause, iPtr, objv, v10, v11, v13, v2, v5, v8 uintptr
	var i, objc, thenScriptIndex int32
	var v1, v4, v7 TTcl_Size
	var v12, v3, v6, v9 bool
	var _ /* value at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = boolObj, cachePtr, cachePtr1, cachePtr2, cachePtr3, clause, i, iPtr, objc, objv, thenScriptIndex, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9
	iPtr = interp
	objc = int32(int64(*(*uintptr)(unsafe.Pointer(data))))
	objv = *(*uintptr)(unsafe.Pointer(data + 1*8))
	i = int32(int64(*(*uintptr)(unsafe.Pointer(data + 2*8))))
	boolObj = *(*uintptr)(unsafe.Pointer(data + 3*8))
	thenScriptIndex = 0
	if result != TCL_OK {
		v2 = boolObj
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if !(v1 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(boolObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(boolObj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(boolObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(boolObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(boolObj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(boolObj)).Flength = int64(-libc.Int32FromInt32(1))
				if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, boolObj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(boolObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = boolObj
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, boolObj)
			}
		}
		return result
	}
	if XTcl_GetBoolFromObj(tls, interp, boolObj, (libc.Int32FromInt32(TCL_NULL_OK)-libc.Int32FromInt32(2))&libc.Int32FromInt64(4), bp) != TCL_OK {
		v5 = boolObj
		v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
		*(*TTcl_Size)(unsafe.Pointer(v5))--
		if !(v4 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(boolObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(boolObj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(boolObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(boolObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(boolObj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(boolObj)).Flength = int64(-libc.Int32FromInt32(1))
				if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
					cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v6 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, boolObj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(boolObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = boolObj
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, boolObj)
			}
		}
		return int32(TCL_ERROR)
	}
	v8 = boolObj
	v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
	*(*TTcl_Size)(unsafe.Pointer(v8))--
	if !(v7 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(boolObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(boolObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(boolObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(boolObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(boolObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(boolObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v9 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v9 {
				cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v9 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, boolObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(boolObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = boolObj
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, boolObj)
		}
	}
	for int32(1) != 0 {
		i++
		if i >= objc {
			goto missingScript
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
			v10 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
		} else {
			v10 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		clause = v10
		if i < objc && libc.Xstrcmp(tls, clause, __ccgo_ts+16212) == 0 {
			i++
		}
		if i >= objc {
			goto missingScript
		}
		if *(*int32)(unsafe.Pointer(bp)) != 0 {
			thenScriptIndex = i
			*(*int32)(unsafe.Pointer(bp)) = 0
		}
		/*
		 * The expression evaluated to false. Skip the command, then see if
		 * there is an "else" or "elseif" clause.
		 */
		i++
		if i >= objc {
			if thenScriptIndex != 0 {
				/*
				 * TIP #280. Make invoking context available to branch.
				 */
				return XTclNREvalObjEx(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(thenScriptIndex)*8)), 0, (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr, thenScriptIndex)
			}
			return TCL_OK
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
			v11 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
		} else {
			v11 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		clause = v11
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(clause))) != int32('e') || libc.Xstrcmp(tls, clause, __ccgo_ts+16217) != 0 {
			break
		}
		i++
		/*
		 * At this point in the loop, objv and objc refer to an expression to
		 * test, either for the main expression or an expression following an
		 * "elseif". The arguments after the expression must be "then"
		 * (optional) and a script to execute if the expression is true.
		 */
		if i >= objc {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+16164, libc.VaList(bp+16, clause)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+9101, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		if !(thenScriptIndex != 0) {
			if v12 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v12 {
				cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v12 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
				boolObj = XTclThreadAllocObj(tls)
			} else {
				boolObj = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(boolObj + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(boolObj)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(boolObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(boolObj)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(boolObj)).FtypePtr = libc.UintptrFromInt32(0)
			XTcl_NRAddCallback(tls, interp, __ccgo_fp(_IfConditionCallback), *(*uintptr)(unsafe.Pointer(data)), *(*uintptr)(unsafe.Pointer(data + 1*8)), uintptr(int64(i)), boolObj)
			return XTcl_NRExprObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), boolObj)
		}
	}
	/*
	 * Couldn't find a "then" or "elseif" clause to execute. Check now for an
	 * "else" clause. We know that there's at least one more argument when we
	 * get here.
	 */
	if libc.Xstrcmp(tls, clause, __ccgo_ts+16224) == 0 {
		i++
		if i >= objc {
			goto missingScript
		}
	}
	if i < objc-int32(1) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+16229, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+9101, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if thenScriptIndex != 0 {
		/*
		 * TIP #280. Make invoking context available to branch/else.
		 */
		return XTclNREvalObjEx(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(thenScriptIndex)*8)), 0, (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr, thenScriptIndex)
	}
	return XTclNREvalObjEx(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), 0, (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr, i)
	goto missingScript
missingScript:
	;
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i-int32(1))*8)))).Fbytes != 0 {
		v13 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i-int32(1))*8)))).Fbytes
	} else {
		v13 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i-int32(1))*8)), libc.UintptrFromInt32(0))
	}
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+16291, libc.VaList(bp+16, v13)))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+9101, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_IncrObjCmd --
 *
 *	This procedure is invoked to process the "incr" Tcl command. See the
 *	user documentation for details on what it does.
 *
 *	With the bytecode compiler, this procedure is only called when a
 *	command name is computed at runtime, and is "incr" or the name to
 *	which "incr" was renamed: e.g., "set z incr; $z i -1"
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_IncrObjCmd(tls *libc.TLS, dummy389 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var _objPtr, cachePtr, incrPtr, newValuePtr, v3 uintptr
	var v1 bool
	var v2 TTcl_Size
	_, _, _, _, _, _, _ = _objPtr, cachePtr, incrPtr, newValuePtr, v1, v2, v3
	if objc != int32(2) && objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+16339)
		return int32(TCL_ERROR)
	}
	if objc == int32(3) {
		incrPtr = *(*uintptr)(unsafe.Pointer(objv + 2*8))
	} else {
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			incrPtr = XTclThreadAllocObj(tls)
		} else {
			incrPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(incrPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(incrPtr)).Fbytes = libc.UintptrFromInt32(0)
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FinternalRep)) = int64(libc.Int32FromInt32(1))
		(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	}
	(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FrefCount++
	newValuePtr = XTclIncrObjVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), incrPtr, int32(TCL_LEAVE_ERR_MSG))
	_objPtr = incrPtr
	v3 = _objPtr
	v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
	*(*TTcl_Size)(unsafe.Pointer(v3))--
	if v2 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	if newValuePtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Set the interpreter's object result to refer to the variable's new
	 * value object.
	 */
	XTcl_SetObjResult(tls, interp, newValuePtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclInitInfoCmd --
 *
 *	This function is called to create the "info" Tcl command. See the user
 *	documentation for details on what it does.
 *
 * Results:
 *	Handle for the info command, or NULL on failure.
 *
 * Side effects:
 *	none
 *
 *----------------------------------------------------------------------
 */

func XTclInitInfoCmd(tls *libc.TLS, interp uintptr) (r TTcl_Command) {
	/* Current interpreter. */
	return XTclMakeEnsemble(tls, interp, __ccgo_ts+5873, uintptr(unsafe.Pointer(&_defaultInfoMap)))
}

/*
 *----------------------------------------------------------------------
 *
 * InfoArgsCmd --
 *
 *	Called to implement the "info args" command that returns the argument
 *	list for a procedure. Handles the following syntax:
 *
 *	    info args procName
 *
 * Results:
 *	Returns TCL_OK if successful and TCL_ERROR if there is an error.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If there is an
 *	error, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func _InfoArgsCmd(tls *libc.TLS, dummy470 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument objects. */
	var iPtr, listObjPtr, localPtr, name, procPtr, v1 uintptr
	_, _, _, _, _, _ = iPtr, listObjPtr, localPtr, name, procPtr, v1
	iPtr = interp
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+16359)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	name = v1
	procPtr = XTclFindProc(tls, iPtr, name)
	if procPtr == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+16368, libc.VaList(bp+8, name)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+16391, name, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Build a return list containing the arguments.
	 */
	listObjPtr = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
	localPtr = (*TProc)(unsafe.Pointer(procPtr)).FfirstLocalPtr
	for {
		if !(localPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TCompiledLocal)(unsafe.Pointer(localPtr)).Fflags&int32(VAR_ARGUMENT) != 0 {
			XTcl_ListObjAppendElement(tls, interp, listObjPtr, XTcl_NewStringObj(tls, localPtr+44, int64(-int32(1))))
		}
		goto _2
	_2:
		;
		localPtr = (*TCompiledLocal)(unsafe.Pointer(localPtr)).FnextPtr
	}
	XTcl_SetObjResult(tls, interp, listObjPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * InfoBodyCmd --
 *
 *	Called to implement the "info body" command that returns the body for
 *	a procedure. Handles the following syntax:
 *
 *	    info body procName
 *
 * Results:
 *	Returns TCL_OK if successful and TCL_ERROR if there is an error.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If there is an
 *	error, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func _InfoBodyCmd(tls *libc.TLS, dummy533 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Argument objects. */
	var bytes, iPtr, name, procPtr, v1, v2 uintptr
	var _ /* numBytes at bp+0 */ TTcl_Size
	_, _, _, _, _, _ = bytes, iPtr, name, procPtr, v1, v2
	iPtr = interp
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+16359)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	name = v1
	procPtr = XTclFindProc(tls, iPtr, name)
	if procPtr == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+16368, libc.VaList(bp+16, name)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+16391, name, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Here we used to return procPtr->bodyPtr, except when the body was
	 * bytecompiled - in that case, the return was a copy of the body's string
	 * rep. In order to better isolate the implementation details of the
	 * compiler/engine subsystem, we now always return a copy of the string
	 * rep. It is important to return a copy so that later manipulations of
	 * the object do not invalidate the internal rep.
	 */
	if (*TTcl_Obj)(unsafe.Pointer((*TProc)(unsafe.Pointer(procPtr)).FbodyPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer((*TProc)(unsafe.Pointer(procPtr)).FbodyPtr)).Flength
		v2 = (*TTcl_Obj)(unsafe.Pointer((*TProc)(unsafe.Pointer(procPtr)).FbodyPtr)).Fbytes
	} else {
		v2 = XTcl_GetStringFromObj(tls, (*TProc)(unsafe.Pointer(procPtr)).FbodyPtr, bp)
	}
	bytes = v2
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, bytes, *(*TTcl_Size)(unsafe.Pointer(bp))))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * InfoCmdCountCmd --
 *
 *	Called to implement the "info cmdcount" command that returns the
 *	number of commands that have been executed. Handles the following
 *	syntax:
 *
 *	    info cmdcount
 *
 * Results:
 *	Returns TCL_OK if successful and TCL_ERROR if there is an error.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If there is an
 *	error, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func _InfoCmdCountCmd(tls *libc.TLS, dummy594 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var iPtr uintptr
	_ = iPtr
	iPtr = interp
	if objc != int32(1) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, libc.UintptrFromInt32(0))
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, (*TInterp)(unsafe.Pointer(iPtr)).FcmdCount))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * InfoCommandsCmd --
 *
 *	Called to implement the "info commands" command that returns the list
 *	of commands in the interpreter that match an optional pattern. The
 *	pattern, if any, consists of an optional sequence of namespace names
 *	separated by "::" qualifiers, which is followed by a glob-style
 *	pattern that restricts which commands are returned. Handles the
 *	following syntax:
 *
 *	    info commands ?pattern?
 *
 * Results:
 *	Returns TCL_OK if successful and TCL_ERROR if there is an error.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If there is an
 *	error, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func _InfoCommandsCmd(tls *libc.TLS, dummy636 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(176)
	defer tls.Free(176) /* Argument objects. */
	var cachePtr, cachePtr1, cachePtr2, cachePtr3, cmdName, currNsPtr, elemObjPtr, entryPtr, globalNsPtr, listPtr, pathNsPtr, pathNsPtr1, pattern, tablePtr, v1, v11, v13, v15, v17, v3, v5, v6, v8, v9 uintptr
	var cmd TTcl_Command
	var foundGlobal, specificNsInPattern int32
	var i, v12, v16 TTcl_Size
	var v14, v18, v2, v7 bool
	var _ /* addedCommandsTable at bp+56 */ TTcl_HashTable
	var _ /* dummy1NsPtr at bp+40 */ uintptr
	var _ /* dummy2NsPtr at bp+48 */ uintptr
	var _ /* isNew at bp+160 */ int32
	var _ /* nsPtr at bp+32 */ uintptr
	var _ /* search at bp+8 */ TTcl_HashSearch
	var _ /* simplePattern at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, cachePtr3, cmd, cmdName, currNsPtr, elemObjPtr, entryPtr, foundGlobal, globalNsPtr, i, listPtr, pathNsPtr, pathNsPtr1, pattern, specificNsInPattern, tablePtr, v1, v11, v12, v13, v14, v15, v16, v17, v18, v2, v3, v5, v6, v7, v8, v9
	globalNsPtr = XTcl_GetGlobalNamespace(tls, interp)
	currNsPtr = XTcl_GetCurrentNamespace(tls, interp)
	specificNsInPattern = 0
	/*
	 * Get the pattern and find the "effective namespace" in which to list
	 * commands.
	 */
	if objc == int32(1) {
		*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(bp + 32)) = currNsPtr
		specificNsInPattern = 0
	} else {
		if objc == int32(2) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
				v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
			} else {
				v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
			}
			pattern = v1
			XTclGetNamespaceForQualName(tls, interp, pattern, libc.UintptrFromInt32(0), 0, bp+32, bp+40, bp+48, bp)
			if *(*uintptr)(unsafe.Pointer(bp + 32)) != libc.UintptrFromInt32(0) { /* We successfully found the pattern's ns. */
				specificNsInPattern = libc.BoolInt32(libc.Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(bp)), pattern) != 0)
			}
		} else {
			XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+16401)
			return int32(TCL_ERROR)
		}
	}
	/*
	 * Exit as quickly as possible if we couldn't find the namespace.
	 */
	if *(*uintptr)(unsafe.Pointer(bp + 32)) == libc.UintptrFromInt32(0) {
		return TCL_OK
	}
	/*
	 * Scan through the effective namespace's command table and create a list
	 * with all commands that match the pattern. If a specific namespace was
	 * requested in the pattern, qualify the command names with the namespace
	 * name.
	 */
	listPtr = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
	if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) && libc.Xstrpbrk(tls, *(*uintptr)(unsafe.Pointer(bp)), __ccgo_ts+16411) == libc.UintptrFromInt32(0) {
		/*
		 * Special case for when the pattern doesn't include any of glob's
		 * special characters. This lets us avoid scans of any hash tables.
		 */
		entryPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)) + 184)).FfindProc})))(tls, *(*uintptr)(unsafe.Pointer(bp + 32))+184, *(*uintptr)(unsafe.Pointer(bp)))
		if entryPtr != libc.UintptrFromInt32(0) {
			if specificNsInPattern != 0 {
				cmd = (*TTcl_HashEntry)(unsafe.Pointer(entryPtr)).FclientData
				if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
					elemObjPtr = XTclThreadAllocObj(tls)
				} else {
					elemObjPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(elemObjPtr + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).Flength = 0
				(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).FtypePtr = libc.UintptrFromInt32(0)
				XTcl_GetCommandFullName(tls, interp, cmd, elemObjPtr)
			} else {
				if (*TTcl_HashTable)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32))+184)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32))+184)).FkeyType == -int32(1) {
					v3 = *(*uintptr)(unsafe.Pointer(entryPtr + 32))
				} else {
					v3 = entryPtr + 32
				}
				cmdName = v3
				elemObjPtr = XTcl_NewStringObj(tls, cmdName, int64(-int32(1)))
			}
			XTcl_ListObjAppendElement(tls, interp, listPtr, elemObjPtr)
			XTcl_SetObjResult(tls, interp, listPtr)
			return TCL_OK
		}
		if *(*uintptr)(unsafe.Pointer(bp + 32)) != globalNsPtr && !(specificNsInPattern != 0) {
			tablePtr = libc.UintptrFromInt32(0) /* Quell warning. */
			i = 0
			for {
				if !(i < (*TNamespace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))).FcommandPathLength) {
					break
				}
				pathNsPtr = (*(*TNamespacePathEntry)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))).FcommandPathArray + uintptr(i)*32))).FnsPtr
				if pathNsPtr == libc.UintptrFromInt32(0) {
					goto _4
				}
				tablePtr = pathNsPtr + 184
				entryPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FfindProc})))(tls, tablePtr, *(*uintptr)(unsafe.Pointer(bp)))
				if entryPtr != libc.UintptrFromInt32(0) {
					break
				}
				goto _4
			_4:
				;
				i++
			}
			if entryPtr == libc.UintptrFromInt32(0) {
				tablePtr = globalNsPtr + 184
				entryPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FfindProc})))(tls, tablePtr, *(*uintptr)(unsafe.Pointer(bp)))
			}
			if entryPtr != libc.UintptrFromInt32(0) {
				if (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FkeyType == -int32(1) {
					v5 = *(*uintptr)(unsafe.Pointer(entryPtr + 32))
				} else {
					v5 = entryPtr + 32
				}
				cmdName = v5
				XTcl_ListObjAppendElement(tls, interp, listPtr, XTcl_NewStringObj(tls, cmdName, int64(-int32(1))))
				XTcl_SetObjResult(tls, interp, listPtr)
				return TCL_OK
			}
		}
	} else {
		if (*TNamespace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))).FcommandPathLength == 0 || specificNsInPattern != 0 {
			/*
			 * The pattern is non-trivial, but either there is no explicit path or
			 * there is an explicit namespace in the pattern. In both cases, the
			 * old matching scheme is perfect.
			 */
			entryPtr = XTcl_FirstHashEntry(tls, *(*uintptr)(unsafe.Pointer(bp + 32))+184, bp+8)
			for entryPtr != libc.UintptrFromInt32(0) {
				if (*TTcl_HashTable)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32))+184)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32))+184)).FkeyType == -int32(1) {
					v6 = *(*uintptr)(unsafe.Pointer(entryPtr + 32))
				} else {
					v6 = entryPtr + 32
				}
				cmdName = v6
				if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) || XTcl_StringCaseMatch(tls, cmdName, *(*uintptr)(unsafe.Pointer(bp)), 0) != 0 {
					if specificNsInPattern != 0 {
						cmd = (*TTcl_HashEntry)(unsafe.Pointer(entryPtr)).FclientData
						if v7 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v7 {
							cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v7 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
							elemObjPtr = XTclThreadAllocObj(tls)
						} else {
							elemObjPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(elemObjPtr + 32))).Fptr1
							(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
						}
						(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).FrefCount = 0
						(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
						(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).Flength = 0
						(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).FtypePtr = libc.UintptrFromInt32(0)
						XTcl_GetCommandFullName(tls, interp, cmd, elemObjPtr)
					} else {
						elemObjPtr = XTcl_NewStringObj(tls, cmdName, int64(-int32(1)))
					}
					XTcl_ListObjAppendElement(tls, interp, listPtr, elemObjPtr)
				}
				entryPtr = XTcl_NextHashEntry(tls, bp+8)
			}
			/*
			 * If the effective namespace isn't the global :: namespace, and a
			 * specific namespace wasn't requested in the pattern, then add in all
			 * global :: commands that match the simple pattern. Of course, we add
			 * in only those commands that aren't hidden by a command in the
			 * effective namespace.
			 */
			if *(*uintptr)(unsafe.Pointer(bp + 32)) != globalNsPtr && !(specificNsInPattern != 0) {
				entryPtr = XTcl_FirstHashEntry(tls, globalNsPtr+184, bp+8)
				for entryPtr != libc.UintptrFromInt32(0) {
					if (*TTcl_HashTable)(unsafe.Pointer(globalNsPtr+184)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(globalNsPtr+184)).FkeyType == -int32(1) {
						v8 = *(*uintptr)(unsafe.Pointer(entryPtr + 32))
					} else {
						v8 = entryPtr + 32
					}
					cmdName = v8
					if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) || XTcl_StringCaseMatch(tls, cmdName, *(*uintptr)(unsafe.Pointer(bp)), 0) != 0 {
						if (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)) + 184)).FfindProc})))(tls, *(*uintptr)(unsafe.Pointer(bp + 32))+184, cmdName) == libc.UintptrFromInt32(0) {
							XTcl_ListObjAppendElement(tls, interp, listPtr, XTcl_NewStringObj(tls, cmdName, int64(-int32(1))))
						}
					}
					entryPtr = XTcl_NextHashEntry(tls, bp+8)
				}
			}
		} else {
			foundGlobal = libc.BoolInt32(*(*uintptr)(unsafe.Pointer(bp + 32)) == globalNsPtr)
			/*
			 * We keep a hash of the objects already added to the result list.
			 */
			XTcl_InitObjHashTable(tls, bp+56)
			entryPtr = XTcl_FirstHashEntry(tls, *(*uintptr)(unsafe.Pointer(bp + 32))+184, bp+8)
			for entryPtr != libc.UintptrFromInt32(0) {
				if (*TTcl_HashTable)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32))+184)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32))+184)).FkeyType == -int32(1) {
					v9 = *(*uintptr)(unsafe.Pointer(entryPtr + 32))
				} else {
					v9 = entryPtr + 32
				}
				cmdName = v9
				if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) || XTcl_StringCaseMatch(tls, cmdName, *(*uintptr)(unsafe.Pointer(bp)), 0) != 0 {
					elemObjPtr = XTcl_NewStringObj(tls, cmdName, int64(-int32(1)))
					XTcl_ListObjAppendElement(tls, interp, listPtr, elemObjPtr)
					(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(bp + 56)).FcreateProc})))(tls, bp+56, elemObjPtr, bp+160)
				}
				entryPtr = XTcl_NextHashEntry(tls, bp+8)
			}
			/*
			 * Search the path next.
			 */
			i = 0
			for {
				if !(i < (*TNamespace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))).FcommandPathLength) {
					break
				}
				pathNsPtr1 = (*(*TNamespacePathEntry)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))).FcommandPathArray + uintptr(i)*32))).FnsPtr
				if pathNsPtr1 == libc.UintptrFromInt32(0) {
					goto _10
				}
				if pathNsPtr1 == globalNsPtr {
					foundGlobal = int32(1)
				}
				entryPtr = XTcl_FirstHashEntry(tls, pathNsPtr1+184, bp+8)
				for entryPtr != libc.UintptrFromInt32(0) {
					if (*TTcl_HashTable)(unsafe.Pointer(pathNsPtr1+184)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(pathNsPtr1+184)).FkeyType == -int32(1) {
						v11 = *(*uintptr)(unsafe.Pointer(entryPtr + 32))
					} else {
						v11 = entryPtr + 32
					}
					cmdName = v11
					if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) || XTcl_StringCaseMatch(tls, cmdName, *(*uintptr)(unsafe.Pointer(bp)), 0) != 0 {
						elemObjPtr = XTcl_NewStringObj(tls, cmdName, int64(-int32(1)))
						(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(bp + 56)).FcreateProc})))(tls, bp+56, elemObjPtr, bp+160)
						if *(*int32)(unsafe.Pointer(bp + 160)) != 0 {
							XTcl_ListObjAppendElement(tls, interp, listPtr, elemObjPtr)
						} else {
							v13 = elemObjPtr
							v12 = *(*TTcl_Size)(unsafe.Pointer(v13))
							*(*TTcl_Size)(unsafe.Pointer(v13))--
							if !(v12 > int64(1)) {
								if !((*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).FtypePtr)).FfreeIntRepProc != 0) {
									if (*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
										XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).Fbytes)
									}
									(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).Flength = int64(-libc.Int32FromInt32(1))
									if v14 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v14 {
										cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
									}
									if v14 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
										XTclThreadFreeObj(tls, elemObjPtr)
									} else {
										(*(*struct {
											Fptr1 uintptr
											Fptr2 uintptr
										})(unsafe.Pointer(elemObjPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
										(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = elemObjPtr
										(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
									}
								} else {
									XTclFreeObj(tls, elemObjPtr)
								}
							}
						}
					}
					entryPtr = XTcl_NextHashEntry(tls, bp+8)
				}
				goto _10
			_10:
				;
				i++
			}
			/*
			 * If the effective namespace isn't the global :: namespace, and a
			 * specific namespace wasn't requested in the pattern, then add in all
			 * global :: commands that match the simple pattern. Of course, we add
			 * in only those commands that aren't hidden by a command in the
			 * effective namespace.
			 */
			if !(foundGlobal != 0) {
				entryPtr = XTcl_FirstHashEntry(tls, globalNsPtr+184, bp+8)
				for entryPtr != libc.UintptrFromInt32(0) {
					if (*TTcl_HashTable)(unsafe.Pointer(globalNsPtr+184)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(globalNsPtr+184)).FkeyType == -int32(1) {
						v15 = *(*uintptr)(unsafe.Pointer(entryPtr + 32))
					} else {
						v15 = entryPtr + 32
					}
					cmdName = v15
					if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) || XTcl_StringCaseMatch(tls, cmdName, *(*uintptr)(unsafe.Pointer(bp)), 0) != 0 {
						elemObjPtr = XTcl_NewStringObj(tls, cmdName, int64(-int32(1)))
						if (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(bp + 56)).FfindProc})))(tls, bp+56, elemObjPtr) == libc.UintptrFromInt32(0) {
							XTcl_ListObjAppendElement(tls, interp, listPtr, elemObjPtr)
						} else {
							v17 = elemObjPtr
							v16 = *(*TTcl_Size)(unsafe.Pointer(v17))
							*(*TTcl_Size)(unsafe.Pointer(v17))--
							if !(v16 > int64(1)) {
								if !((*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).FtypePtr)).FfreeIntRepProc != 0) {
									if (*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
										XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).Fbytes)
									}
									(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).Flength = int64(-libc.Int32FromInt32(1))
									if v18 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v18 {
										cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
									}
									if v18 || ((*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
										XTclThreadFreeObj(tls, elemObjPtr)
									} else {
										(*(*struct {
											Fptr1 uintptr
											Fptr2 uintptr
										})(unsafe.Pointer(elemObjPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
										(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = elemObjPtr
										(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects++
									}
								} else {
									XTclFreeObj(tls, elemObjPtr)
								}
							}
						}
					}
					entryPtr = XTcl_NextHashEntry(tls, bp+8)
				}
			}
			XTcl_DeleteHashTable(tls, bp+56)
		}
	}
	XTcl_SetObjResult(tls, interp, listPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * InfoCompleteCmd --
 *
 *	Called to implement the "info complete" command that determines
 *	whether a string is a complete Tcl command. Handles the following
 *	syntax:
 *
 *	    info complete command
 *
 * Results:
 *	Returns TCL_OK if successful and TCL_ERROR if there is an error.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If there is an
 *	error, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func _InfoCompleteCmd(tls *libc.TLS, dummy913 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+16416)
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(XTclObjCommandComplete(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8))) != 0)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * InfoDefaultCmd --
 *
 *	Called to implement the "info default" command that returns the
 *	default value for a procedure argument. Handles the following syntax:
 *
 *	    info default procName arg varName
 *
 * Results:
 *	Returns TCL_OK if successful and TCL_ERROR if there is an error.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If there is an
 *	error, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func _InfoDefaultCmd(tls *libc.TLS, dummy950 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument objects. */
	var argName, cachePtr, iPtr, localPtr, nullObjPtr, procName, procPtr, valueObjPtr, v1, v2 uintptr
	var v4 bool
	_, _, _, _, _, _, _, _, _, _, _ = argName, cachePtr, iPtr, localPtr, nullObjPtr, procName, procPtr, valueObjPtr, v1, v2, v4
	iPtr = interp
	if objc != int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+16424)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	procName = v1
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
		v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
	} else {
		v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
	}
	argName = v2
	procPtr = XTclFindProc(tls, iPtr, procName)
	if procPtr == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+16368, libc.VaList(bp+8, procName)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+16391, procName, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	localPtr = (*TProc)(unsafe.Pointer(procPtr)).FfirstLocalPtr
	for {
		if !(localPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TCompiledLocal)(unsafe.Pointer(localPtr)).Fflags&int32(VAR_ARGUMENT) != 0 && libc.Xstrcmp(tls, argName, localPtr+44) == 0 {
			if (*TCompiledLocal)(unsafe.Pointer(localPtr)).FdefValuePtr != libc.UintptrFromInt32(0) {
				valueObjPtr = XTcl_ObjSetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0), (*TCompiledLocal)(unsafe.Pointer(localPtr)).FdefValuePtr, int32(TCL_LEAVE_ERR_MSG))
				if valueObjPtr == libc.UintptrFromInt32(0) {
					return int32(TCL_ERROR)
				}
				XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(int32(1) != 0)))
			} else {
				if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
					nullObjPtr = XTclThreadAllocObj(tls)
				} else {
					nullObjPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(nullObjPtr + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(nullObjPtr)).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer(nullObjPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(nullObjPtr)).Flength = 0
				(*TTcl_Obj)(unsafe.Pointer(nullObjPtr)).FtypePtr = libc.UintptrFromInt32(0)
				valueObjPtr = XTcl_ObjSetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0), nullObjPtr, int32(TCL_LEAVE_ERR_MSG))
				if valueObjPtr == libc.UintptrFromInt32(0) {
					return int32(TCL_ERROR)
				}
				XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(0 != 0)))
			}
			return TCL_OK
		}
		goto _3
	_3:
		;
		localPtr = (*TCompiledLocal)(unsafe.Pointer(localPtr)).FnextPtr
	}
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+16445, libc.VaList(bp+8, procName, argName)))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+16490, argName, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * InfoErrorStackCmd --
 *
 *	Called to implement the "info errorstack" command that returns information
 *	about the last error's call stack. Handles the following syntax:
 *
 *	    info errorstack ?interp?
 *
 * Results:
 *	Returns TCL_OK if successful and TCL_ERROR if there is an error.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If there is an
 *	error, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func _InfoErrorStackCmd(tls *libc.TLS, dummy1033 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var iPtr, target, v1 uintptr
	_, _, _ = iPtr, target, v1
	if objc != int32(1) && objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+16499)
		return int32(TCL_ERROR)
	}
	target = interp
	if objc == int32(2) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
		}
		target = XTcl_GetChild(tls, interp, v1)
		if target == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
	}
	iPtr = target
	XTcl_SetObjResult(tls, interp, (*TInterp)(unsafe.Pointer(iPtr)).FerrorStack)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclInfoExistsCmd --
 *
 *	Called to implement the "info exists" command that determines whether
 *	a variable exists. Handles the following syntax:
 *
 *	    info exists varName
 *
 * Results:
 *	Returns TCL_OK if successful and TCL_ERROR if there is an error.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If there is an
 *	error, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func XTclInfoExistsCmd(tls *libc.TLS, dummy1082 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var varName, varPtr, v1 uintptr
	_, _, _ = varName, varPtr, v1
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+16508)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	varName = v1
	varPtr = XTclVarTraceExists(tls, interp, varName)
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(libc.BoolInt32(varPtr != 0 && *(*uintptr)(unsafe.Pointer(varPtr + 8)) != 0) != 0)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * InfoFrameCmd --
 *	TIP #280
 *
 *	Called to implement the "info frame" command that returns the location
 *	of either the currently executing command, or its caller. Handles the
 *	following syntax:
 *
 *		info frame ?number?
 *
 * Results:
 *	Returns TCL_OK if successful and TCL_ERROR if there is an error.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If there is an
 *	error, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func _InfoFrameCmd(tls *libc.TLS, dummy1127 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Argument objects. */
	var cmdFramePtrPtr, corPtr, endPtr, framePtr, iPtr, runPtr, v5, v6 uintptr
	var code, topLevel, v1, v2, v3, v7 int32
	var _ /* level at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = cmdFramePtrPtr, code, corPtr, endPtr, framePtr, iPtr, runPtr, topLevel, v1, v2, v3, v5, v6, v7
	iPtr = interp
	code = TCL_OK
	cmdFramePtrPtr = iPtr + 720
	corPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FexecEnvPtr)).FcorPtr
	topLevel = 0
	if objc > int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+16516)
		return int32(TCL_ERROR)
	}
	for corPtr != 0 {
		for *(*uintptr)(unsafe.Pointer(cmdFramePtrPtr)) != 0 {
			topLevel++
			cmdFramePtrPtr = *(*uintptr)(unsafe.Pointer(cmdFramePtrPtr)) + 32
		}
		if (*TCoroutineData)(unsafe.Pointer(corPtr)).Fcaller.FcmdFramePtr != 0 {
			*(*uintptr)(unsafe.Pointer(cmdFramePtrPtr)) = (*TCoroutineData)(unsafe.Pointer(corPtr)).Fcaller.FcmdFramePtr
		}
		corPtr = (*TExecEnv1)(unsafe.Pointer((*TCoroutineData)(unsafe.Pointer(corPtr)).FcallerEEPtr)).FcorPtr
	}
	if *(*uintptr)(unsafe.Pointer(cmdFramePtrPtr)) != 0 {
		v1 = (*TCmdFrame)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(cmdFramePtrPtr)))).Flevel
	} else {
		v1 = int32(1)
	}
	topLevel += v1
	if (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr != 0 && topLevel != (*TCmdFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr)).Flevel {
		framePtr = (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr
		for framePtr != 0 {
			v2 = topLevel
			topLevel--
			(*TCmdFrame)(unsafe.Pointer(framePtr)).Flevel = v2
			framePtr = (*TCmdFrame)(unsafe.Pointer(framePtr)).FnextPtr
		}
		if topLevel != 0 {
			XTcl_Panic(tls, __ccgo_ts+16525, 0)
		}
		topLevel = (*TCmdFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr)).Flevel
	}
	if objc == int32(1) {
		/*
		 * Just "info frame".
		 */
		XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, int64(topLevel)))
		goto done
	}
	/*
	 * We've got "info frame level" and must parse the level first.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
		*(*int32)(unsafe.Pointer(bp)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FinternalRep)))
		v3 = libc.Int32FromInt32(TCL_OK)
	} else {
		v3 = XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
	}
	if v3 != TCL_OK {
		code = int32(TCL_ERROR)
		goto done
	}
	if !(*(*int32)(unsafe.Pointer(bp)) > topLevel || *(*int32)(unsafe.Pointer(bp)) <= -topLevel) {
		goto _4
	}
	goto levelError
levelError:
	;
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v5 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v5 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+16556, libc.VaList(bp+16, v5)))
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v6 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v6 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+16571, v6, libc.UintptrFromInt32(0)))
	code = int32(TCL_ERROR)
	goto done
_4:
	;
	/*
	 * Let us convert to relative so that we know how many levels to go back
	 */
	if *(*int32)(unsafe.Pointer(bp)) > 0 {
		*(*int32)(unsafe.Pointer(bp)) -= topLevel
	}
	framePtr = (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr
	for {
		*(*int32)(unsafe.Pointer(bp))++
		v7 = *(*int32)(unsafe.Pointer(bp))
		if !(v7 <= 0) {
			break
		}
		framePtr = (*TCmdFrame)(unsafe.Pointer(framePtr)).FnextPtr
		if !(framePtr != 0) {
			goto levelError
		}
	}
	XTcl_SetObjResult(tls, interp, XTclInfoFrame(tls, interp, framePtr))
	goto done
done:
	;
	cmdFramePtrPtr = iPtr + 720
	corPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FexecEnvPtr)).FcorPtr
	for corPtr != 0 {
		endPtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).Fcaller.FcmdFramePtr
		if endPtr != 0 {
			if *(*uintptr)(unsafe.Pointer(cmdFramePtrPtr)) == endPtr {
				*(*uintptr)(unsafe.Pointer(cmdFramePtrPtr)) = libc.UintptrFromInt32(0)
			} else {
				runPtr = *(*uintptr)(unsafe.Pointer(cmdFramePtrPtr))
				for (*TCmdFrame)(unsafe.Pointer(runPtr)).FnextPtr != endPtr {
					*(*int32)(unsafe.Pointer(runPtr + 4)) -= (*TCmdFrame)(unsafe.Pointer(endPtr)).Flevel
					runPtr = (*TCmdFrame)(unsafe.Pointer(runPtr)).FnextPtr
				}
				(*TCmdFrame)(unsafe.Pointer(runPtr)).Flevel = int32(1)
				(*TCmdFrame)(unsafe.Pointer(runPtr)).FnextPtr = libc.UintptrFromInt32(0)
			}
			cmdFramePtrPtr = corPtr + 24 + 16
		}
		corPtr = (*TExecEnv1)(unsafe.Pointer((*TCoroutineData)(unsafe.Pointer(corPtr)).FcallerEEPtr)).FcorPtr
	}
	return code
}

/*
 *----------------------------------------------------------------------
 *
 * TclInfoFrame --
 *
 *	Core of InfoFrameCmd, returns TIP280 dict for a given frame.
 *
 * Results:
 *	Returns TIP280 dict.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclInfoFrame(tls *libc.TLS, interp uintptr, framePtr uintptr) (r uintptr) {
	bp := tls.Alloc(160)
	defer tls.Free(160) /* Frame to get info for. */
	var _objPtr, _objPtr1, cachePtr, cachePtr1, cachePtr10, cachePtr11, cachePtr12, cachePtr13, cachePtr14, cachePtr15, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cachePtr8, cachePtr9, current, efiPtr, fPtr, iPtr, idx, namePtr, procNameObj, procPtr, tmpObj, top, v1, v33, v62 uintptr
	var c, lc, needsFree, t, v10, v12, v13, v15, v16, v18, v19, v21, v22, v24, v25, v27, v28, v30, v31, v35, v36, v38, v39, v41, v42, v44, v45, v47, v48, v51, v52, v54, v55, v56, v59, v60, v9 int32
	var i, v32, v61 TTcl_Size
	var v11, v14, v17, v20, v23, v26, v29, v34, v37, v40, v43, v46, v49, v50, v58, v8 bool
	var _ /* lv at bp+0 */ [20]uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, c, cachePtr, cachePtr1, cachePtr10, cachePtr11, cachePtr12, cachePtr13, cachePtr14, cachePtr15, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cachePtr8, cachePtr9, current, efiPtr, fPtr, i, iPtr, idx, lc, namePtr, needsFree, procNameObj, procPtr, t, tmpObj, top, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v54, v55, v56, v58, v59, v60, v61, v62, v8, v9
	iPtr = interp
	*(*[20]uintptr)(unsafe.Pointer(bp)) = [20]uintptr{} /* Keep uptodate when more keys are added to
	 * the dict. */
	lc = 0
	procPtr = libc.UintptrFromInt32(0)
	needsFree = -int32(1)
	if !(framePtr != 0) {
		goto precompiled
	}
	if (*TCmdFrame)(unsafe.Pointer(framePtr)).FframePtr != 0 {
		v1 = (*TCallFrame)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(framePtr)).FframePtr)).FprocPtr
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	procPtr = v1
	/*
	 * Pull the information and construct the dictionary to return, as list.
	 * Regarding use of the CmdFrame fields see tclInt.h, and its definition.
	 */
	switch (*TCmdFrame)(unsafe.Pointer(framePtr)).Ftype1 {
	case TCL_LOCATION_EVAL:
		goto _2
	case int32(TCL_LOCATION_PREBC):
		goto _3
	case int32(TCL_LOCATION_BC):
		goto _4
	case int32(TCL_LOCATION_SOURCE):
		goto _5
	case int32(TCL_LOCATION_PROC):
		goto _6
	}
	goto _7
_2:
	;
	/*
	 * Evaluation, dynamic script. Type, line, cmd, the latter through
	 * str.
	 */
	if v8 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v8 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v8 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		tmpObj = XTclThreadAllocObj(tls)
	} else {
		tmpObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(tmpObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FrefCount = 0
	if libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes, __ccgo_ts+5851, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes + uintptr(libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(5) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr = libc.UintptrFromInt32(0)
	v9 = lc
	lc++
	(*(*[20]uintptr)(unsafe.Pointer(bp)))[v9] = tmpObj
	v10 = lc
	lc++
	(*(*[20]uintptr)(unsafe.Pointer(bp)))[v10] = XTcl_NewStringObj(tls, _typeString[(*TCmdFrame)(unsafe.Pointer(framePtr)).Ftype1], int64(-int32(1)))
	if (*TCmdFrame)(unsafe.Pointer(framePtr)).Fline != 0 {
		if v11 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v11 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v11 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			tmpObj = XTclThreadAllocObj(tls)
		} else {
			tmpObj = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(tmpObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FrefCount = 0
		if libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes, __ccgo_ts+16589, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes + uintptr(libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(5) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr = libc.UintptrFromInt32(0)
		v12 = lc
		lc++
		(*(*[20]uintptr)(unsafe.Pointer(bp)))[v12] = tmpObj
		v13 = lc
		lc++
		(*(*[20]uintptr)(unsafe.Pointer(bp)))[v13] = XTcl_NewWideIntObj(tls, *(*TTcl_Size)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(framePtr)).Fline)))
	} else {
		if v14 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v14 {
			cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v14 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
			tmpObj = XTclThreadAllocObj(tls)
		} else {
			tmpObj = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(tmpObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FrefCount = 0
		if libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes, __ccgo_ts+16589, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes + uintptr(libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(5) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr = libc.UintptrFromInt32(0)
		v15 = lc
		lc++
		(*(*[20]uintptr)(unsafe.Pointer(bp)))[v15] = tmpObj
		v16 = lc
		lc++
		(*(*[20]uintptr)(unsafe.Pointer(bp)))[v16] = XTcl_NewWideIntObj(tls, int64(1))
	}
	if v17 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v17 {
		cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v17 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
		tmpObj = XTclThreadAllocObj(tls)
	} else {
		tmpObj = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(tmpObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FrefCount = 0
	if libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes, __ccgo_ts+16594, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes + uintptr(libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(4) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr = libc.UintptrFromInt32(0)
	v18 = lc
	lc++
	(*(*[20]uintptr)(unsafe.Pointer(bp)))[v18] = tmpObj
	v19 = lc
	lc++
	(*(*[20]uintptr)(unsafe.Pointer(bp)))[v19] = XTclGetSourceFromFrame(tls, framePtr, 0, libc.UintptrFromInt32(0))
	goto _7
_3:
	;
	goto precompiled
precompiled:
	;
	/*
	 * Precompiled. Result contains the type as signal, nothing else.
	 */
	if v20 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v20 {
		cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v20 || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == libc.Uint64FromInt32(0) {
		tmpObj = XTclThreadAllocObj(tls)
	} else {
		tmpObj = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(tmpObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FrefCount = 0
	if libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes, __ccgo_ts+5851, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes + uintptr(libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(5) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr = libc.UintptrFromInt32(0)
	v21 = lc
	lc++
	(*(*[20]uintptr)(unsafe.Pointer(bp)))[v21] = tmpObj
	v22 = lc
	lc++
	(*(*[20]uintptr)(unsafe.Pointer(bp)))[v22] = XTcl_NewStringObj(tls, _typeString[int32(TCL_LOCATION_PREBC)], int64(-int32(1)))
	goto _7
_4:
	;
	/*
	 * Execution of bytecode. Talk to the BC engine to fill out the frame.
	 */
	fPtr = XTclStackAlloc(tls, interp, uint64(88))
	*(*TCmdFrame)(unsafe.Pointer(fPtr)) = *(*TCmdFrame)(unsafe.Pointer(framePtr))
	/*
	 * Note:
	 * Type BC => f.data.eval.path	  is not used.
	 *	      f.data.tebc.codePtr is used instead.
	 */
	XTclGetSrcInfoForPc(tls, fPtr)
	/*
	 * Now filled: cmd.str.(cmd,len), line
	 * Possibly modified: type, path!
	 */
	if v23 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v23 {
		cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v23 || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == libc.Uint64FromInt32(0) {
		tmpObj = XTclThreadAllocObj(tls)
	} else {
		tmpObj = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(tmpObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FrefCount = 0
	if libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes, __ccgo_ts+5851, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes + uintptr(libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(5) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr = libc.UintptrFromInt32(0)
	v24 = lc
	lc++
	(*(*[20]uintptr)(unsafe.Pointer(bp)))[v24] = tmpObj
	v25 = lc
	lc++
	(*(*[20]uintptr)(unsafe.Pointer(bp)))[v25] = XTcl_NewStringObj(tls, _typeString[(*TCmdFrame)(unsafe.Pointer(fPtr)).Ftype1], int64(-int32(1)))
	if (*TCmdFrame)(unsafe.Pointer(fPtr)).Fline != 0 {
		if v26 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v26 {
			cachePtr6 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v26 || (*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects == libc.Uint64FromInt32(0) {
			tmpObj = XTclThreadAllocObj(tls)
		} else {
			tmpObj = (*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(tmpObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FrefCount = 0
		if libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes, __ccgo_ts+16589, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes + uintptr(libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(5) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr = libc.UintptrFromInt32(0)
		v27 = lc
		lc++
		(*(*[20]uintptr)(unsafe.Pointer(bp)))[v27] = tmpObj
		v28 = lc
		lc++
		(*(*[20]uintptr)(unsafe.Pointer(bp)))[v28] = XTcl_NewWideIntObj(tls, *(*TTcl_Size)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(fPtr)).Fline)))
	}
	if (*TCmdFrame)(unsafe.Pointer(fPtr)).Ftype1 == int32(TCL_LOCATION_SOURCE) {
		if v29 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v29 {
			cachePtr7 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v29 || (*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects == libc.Uint64FromInt32(0) {
			tmpObj = XTclThreadAllocObj(tls)
		} else {
			tmpObj = (*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(tmpObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FrefCount = 0
		if libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes, __ccgo_ts+5636, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes + uintptr(libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(5) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr = libc.UintptrFromInt32(0)
		v30 = lc
		lc++
		(*(*[20]uintptr)(unsafe.Pointer(bp)))[v30] = tmpObj
		v31 = lc
		lc++
		(*(*[20]uintptr)(unsafe.Pointer(bp)))[v31] = (*TCmdFrame)(unsafe.Pointer(fPtr)).Fdata.Feval.Fpath
		/*
		 * Death of reference by TclGetSrcInfoForPc.
		 */
		_objPtr = (*TCmdFrame)(unsafe.Pointer(fPtr)).Fdata.Feval.Fpath
		v33 = _objPtr
		v32 = *(*TTcl_Size)(unsafe.Pointer(v33))
		*(*TTcl_Size)(unsafe.Pointer(v33))--
		if v32 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	if v34 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v34 {
		cachePtr8 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v34 || (*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects == libc.Uint64FromInt32(0) {
		tmpObj = XTclThreadAllocObj(tls)
	} else {
		tmpObj = (*TAllocCache)(unsafe.Pointer(cachePtr8)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr8)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(tmpObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FrefCount = 0
	if libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes, __ccgo_ts+16594, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes + uintptr(libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(4) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr = libc.UintptrFromInt32(0)
	v35 = lc
	lc++
	(*(*[20]uintptr)(unsafe.Pointer(bp)))[v35] = tmpObj
	v36 = lc
	lc++
	(*(*[20]uintptr)(unsafe.Pointer(bp)))[v36] = XTclGetSourceFromFrame(tls, fPtr, 0, libc.UintptrFromInt32(0))
	if (*TCmdFrame)(unsafe.Pointer(fPtr)).FcmdObj != 0 && (*TCmdFrame)(unsafe.Pointer(framePtr)).FcmdObj == libc.UintptrFromInt32(0) {
		needsFree = lc - int32(1)
	}
	XTclStackFree(tls, interp, fPtr)
	goto _7
_5:
	;
	/*
	 * Evaluation of a script file.
	 */
	if v37 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v37 {
		cachePtr9 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v37 || (*TAllocCache)(unsafe.Pointer(cachePtr9)).FnumObjects == libc.Uint64FromInt32(0) {
		tmpObj = XTclThreadAllocObj(tls)
	} else {
		tmpObj = (*TAllocCache)(unsafe.Pointer(cachePtr9)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr9)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(tmpObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr9)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FrefCount = 0
	if libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes, __ccgo_ts+5851, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes + uintptr(libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(5) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr = libc.UintptrFromInt32(0)
	v38 = lc
	lc++
	(*(*[20]uintptr)(unsafe.Pointer(bp)))[v38] = tmpObj
	v39 = lc
	lc++
	(*(*[20]uintptr)(unsafe.Pointer(bp)))[v39] = XTcl_NewStringObj(tls, _typeString[(*TCmdFrame)(unsafe.Pointer(framePtr)).Ftype1], int64(-int32(1)))
	if v40 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v40 {
		cachePtr10 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v40 || (*TAllocCache)(unsafe.Pointer(cachePtr10)).FnumObjects == libc.Uint64FromInt32(0) {
		tmpObj = XTclThreadAllocObj(tls)
	} else {
		tmpObj = (*TAllocCache)(unsafe.Pointer(cachePtr10)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr10)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(tmpObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr10)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FrefCount = 0
	if libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes, __ccgo_ts+16589, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes + uintptr(libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(5) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr = libc.UintptrFromInt32(0)
	v41 = lc
	lc++
	(*(*[20]uintptr)(unsafe.Pointer(bp)))[v41] = tmpObj
	v42 = lc
	lc++
	(*(*[20]uintptr)(unsafe.Pointer(bp)))[v42] = XTcl_NewWideIntObj(tls, *(*TTcl_Size)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(framePtr)).Fline)))
	if v43 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v43 {
		cachePtr11 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v43 || (*TAllocCache)(unsafe.Pointer(cachePtr11)).FnumObjects == libc.Uint64FromInt32(0) {
		tmpObj = XTclThreadAllocObj(tls)
	} else {
		tmpObj = (*TAllocCache)(unsafe.Pointer(cachePtr11)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr11)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(tmpObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr11)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FrefCount = 0
	if libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes, __ccgo_ts+5636, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes + uintptr(libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(5) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr = libc.UintptrFromInt32(0)
	v44 = lc
	lc++
	(*(*[20]uintptr)(unsafe.Pointer(bp)))[v44] = tmpObj
	v45 = lc
	lc++
	(*(*[20]uintptr)(unsafe.Pointer(bp)))[v45] = (*TCmdFrame)(unsafe.Pointer(framePtr)).Fdata.Feval.Fpath
	/*
	 * Refcount framePtr->data.eval.path goes up when lv is converted into
	 * the result list object.
	 */
	if v46 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v46 {
		cachePtr12 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v46 || (*TAllocCache)(unsafe.Pointer(cachePtr12)).FnumObjects == libc.Uint64FromInt32(0) {
		tmpObj = XTclThreadAllocObj(tls)
	} else {
		tmpObj = (*TAllocCache)(unsafe.Pointer(cachePtr12)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr12)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(tmpObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr12)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FrefCount = 0
	if libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes, __ccgo_ts+16594, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes + uintptr(libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(4) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr = libc.UintptrFromInt32(0)
	v47 = lc
	lc++
	(*(*[20]uintptr)(unsafe.Pointer(bp)))[v47] = tmpObj
	v48 = lc
	lc++
	(*(*[20]uintptr)(unsafe.Pointer(bp)))[v48] = XTclGetSourceFromFrame(tls, framePtr, 0, libc.UintptrFromInt32(0))
	goto _7
_6:
	;
	XTcl_Panic(tls, __ccgo_ts+16598, 0)
	goto _7
_7:
	;
	/*
	 * 'proc'. Common to all frame types. Conditional on having an associated
	 * Procedure CallFrame.
	 */
	if procPtr != libc.UintptrFromInt32(0) {
		namePtr = (*TCommand1)(unsafe.Pointer((*TProc)(unsafe.Pointer(procPtr)).FcmdPtr)).FhPtr
		if namePtr != 0 {
			/*
			 * This is a regular command.
			 */
			if v49 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v49 {
				cachePtr13 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v49 || (*TAllocCache)(unsafe.Pointer(cachePtr13)).FnumObjects == libc.Uint64FromInt32(0) {
				procNameObj = XTclThreadAllocObj(tls)
			} else {
				procNameObj = (*TAllocCache)(unsafe.Pointer(cachePtr13)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr13)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(procNameObj + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr13)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(procNameObj)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(procNameObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(procNameObj)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(procNameObj)).FtypePtr = libc.UintptrFromInt32(0)
			XTcl_GetCommandFullName(tls, interp, (*TProc)(unsafe.Pointer(procPtr)).FcmdPtr, procNameObj)
			if v50 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v50 {
				cachePtr14 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v50 || (*TAllocCache)(unsafe.Pointer(cachePtr14)).FnumObjects == libc.Uint64FromInt32(0) {
				tmpObj = XTclThreadAllocObj(tls)
			} else {
				tmpObj = (*TAllocCache)(unsafe.Pointer(cachePtr14)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr14)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(tmpObj + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr14)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FrefCount = 0
			if libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1) == uint64(0) {
				(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = int64(libc.Int32FromInt32(0))
			} else {
				(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
				libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes, __ccgo_ts+5352, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1))
				*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes + uintptr(libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)))) = uint8('\000')
				(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(5) - libc.Uint64FromInt32(1))
			}
			(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr = libc.UintptrFromInt32(0)
			v51 = lc
			lc++
			(*(*[20]uintptr)(unsafe.Pointer(bp)))[v51] = tmpObj
			v52 = lc
			lc++
			(*(*[20]uintptr)(unsafe.Pointer(bp)))[v52] = procNameObj
		} else {
			if (*TCommand1)(unsafe.Pointer((*TProc)(unsafe.Pointer(procPtr)).FcmdPtr)).FclientData != 0 {
				efiPtr = (*TCommand1)(unsafe.Pointer((*TProc)(unsafe.Pointer(procPtr)).FcmdPtr)).FclientData
				/*
				 * This is a non-standard command. Luckily, it's told us how to
				 * render extra information about its frame.
				 */
				i = 0
				for {
					if !(i < (*TExtraFrameInfo)(unsafe.Pointer(efiPtr)).Flength) {
						break
					}
					v54 = lc
					lc++
					(*(*[20]uintptr)(unsafe.Pointer(bp)))[v54] = XTcl_NewStringObj(tls, (*(*TExtraFrameInfoField)(unsafe.Pointer(efiPtr + 8 + uintptr(i)*24))).Fname, int64(-int32(1)))
					if (*(*TExtraFrameInfoField)(unsafe.Pointer(efiPtr + 8 + uintptr(i)*24))).Fproc != 0 {
						v55 = lc
						lc++
						(*(*[20]uintptr)(unsafe.Pointer(bp)))[v55] = (*(*func(*libc.TLS, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*(*TExtraFrameInfoField)(unsafe.Pointer(efiPtr + 8 + uintptr(i)*24))).Fproc})))(tls, (*(*TExtraFrameInfoField)(unsafe.Pointer(efiPtr + 8 + uintptr(i)*24))).FclientData)
					} else {
						v56 = lc
						lc++
						(*(*[20]uintptr)(unsafe.Pointer(bp)))[v56] = (*(*TExtraFrameInfoField)(unsafe.Pointer(efiPtr + 8 + uintptr(i)*24))).FclientData
					}
					goto _53
				_53:
					;
					i++
				}
			}
		}
	}
	/*
	 * 'level'. Common to all frame types. Conditional on having an associated
	 * _visible_ CallFrame.
	 */
	if framePtr != 0 && (*TCmdFrame)(unsafe.Pointer(framePtr)).FframePtr != libc.UintptrFromInt32(0) && (*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr != libc.UintptrFromInt32(0) {
		current = (*TCmdFrame)(unsafe.Pointer(framePtr)).FframePtr
		top = (*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr
		idx = top
		for {
			if !(idx != libc.UintptrFromInt32(0)) {
				break
			}
			if idx == current {
				c = int32((*TCallFrame)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(framePtr)).FframePtr)).Flevel)
				t = int32((*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).Flevel)
				if v58 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v58 {
					cachePtr15 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v58 || (*TAllocCache)(unsafe.Pointer(cachePtr15)).FnumObjects == libc.Uint64FromInt32(0) {
					tmpObj = XTclThreadAllocObj(tls)
				} else {
					tmpObj = (*TAllocCache)(unsafe.Pointer(cachePtr15)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr15)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(tmpObj + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr15)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FrefCount = 0
				if libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1) == uint64(0) {
					(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = int64(libc.Int32FromInt32(0))
				} else {
					(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
					libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes, __ccgo_ts+16095, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1))
					*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes + uintptr(libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)))) = uint8('\000')
					(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(6) - libc.Uint64FromInt32(1))
				}
				(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr = libc.UintptrFromInt32(0)
				v59 = lc
				lc++
				(*(*[20]uintptr)(unsafe.Pointer(bp)))[v59] = tmpObj
				v60 = lc
				lc++
				(*(*[20]uintptr)(unsafe.Pointer(bp)))[v60] = XTcl_NewWideIntObj(tls, int64(t-c))
				break
			}
			goto _57
		_57:
			;
			idx = (*TCallFrame)(unsafe.Pointer(idx)).FcallerVarPtr
		}
	}
	tmpObj = XTcl_NewListObj(tls, int64(lc), bp)
	if needsFree >= 0 {
		_objPtr1 = (*(*[20]uintptr)(unsafe.Pointer(bp)))[needsFree]
		v62 = _objPtr1
		v61 = *(*TTcl_Size)(unsafe.Pointer(v62))
		*(*TTcl_Size)(unsafe.Pointer(v62))--
		if v61 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
	return tmpObj
}

/*
 * This array is indexed by the TCL_LOCATION_... values, except
 * for _LAST.
 */
var _typeString = [6]uintptr{
	0: __ccgo_ts + 2464,
	1: __ccgo_ts + 2464,
	2: __ccgo_ts + 2464,
	3: __ccgo_ts + 16577,
	4: __ccgo_ts + 5569,
	5: __ccgo_ts + 5352,
}

/*
 *----------------------------------------------------------------------
 *
 * InfoFunctionsCmd --
 *
 *	Called to implement the "info functions" command that returns the list
 *	of math functions matching an optional pattern. Handles the following
 *	syntax:
 *
 *	    info functions ?pattern?
 *
 * Results:
 *	Returns TCL_OK if successful and TCL_ERROR if there is an error.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If there is an
 *	error, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func _InfoFunctionsCmd(tls *libc.TLS, dummy1472 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var _objPtr, _objPtr1, arg, script, v2, v4 uintptr
	var code int32
	var v1, v3 TTcl_Size
	_, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, arg, code, script, v1, v2, v3, v4
	if objc > int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+16401)
		return int32(TCL_ERROR)
	}
	script = XTcl_NewStringObj(tls, __ccgo_ts+16640, int64(-int32(1)))
	if objc == int32(2) {
		arg = XTcl_NewListObj(tls, int64(1), objv+1*8)
		XTcl_AppendObjToObj(tls, script, arg)
		_objPtr = arg
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	(*TTcl_Obj)(unsafe.Pointer(script)).FrefCount++
	code = XTcl_EvalObjEx(tls, interp, script, 0)
	_objPtr1 = script
	v4 = _objPtr1
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	if v3 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	return code
}

/*
 *----------------------------------------------------------------------
 *
 * InfoHostnameCmd --
 *
 *	Called to implement the "info hostname" command that returns the host
 *	name. Handles the following syntax:
 *
 *	    info hostname
 *
 * Results:
 *	Returns TCL_OK if successful and TCL_ERROR if there is an error.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If there is an
 *	error, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func _InfoHostnameCmd(tls *libc.TLS, dummy1537 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument objects. */
	var name uintptr
	_ = name
	if objc != int32(1) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, libc.UintptrFromInt32(0))
		return int32(TCL_ERROR)
	}
	name = XTcl_GetHostName(tls)
	if name != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, name, int64(-int32(1))))
		return TCL_OK
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+17016, int64(-int32(1))))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+17049, __ccgo_ts+2095, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * InfoLevelCmd --
 *
 *	Called to implement the "info level" command that returns information
 *	about the call stack. Handles the following syntax:
 *
 *	    info level ?number?
 *
 * Results:
 *	Returns TCL_OK if successful and TCL_ERROR if there is an error.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If there is an
 *	error, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func _InfoLevelCmd(tls *libc.TLS, dummy1583 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Argument objects. */
	var framePtr, iPtr, rootFramePtr, v3, v4 uintptr
	var v1 int32
	var _ /* level at bp+0 */ int32
	_, _, _, _, _, _ = framePtr, iPtr, rootFramePtr, v1, v3, v4
	iPtr = interp
	if objc == int32(1) { /* Just "info level" */
		XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, int64(int32((*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).Flevel))))
		return TCL_OK
	}
	if objc == int32(2) {
		rootFramePtr = (*TInterp)(unsafe.Pointer(iPtr)).FrootFramePtr
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
			*(*int32)(unsafe.Pointer(bp)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FinternalRep)))
			v1 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1 = XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
		}
		if v1 != TCL_OK {
			return int32(TCL_ERROR)
		}
		if *(*int32)(unsafe.Pointer(bp)) <= 0 {
			if (*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr == rootFramePtr {
				goto levelError
			}
			*(*int32)(unsafe.Pointer(bp)) = int32(int64(*(*int32)(unsafe.Pointer(bp))) + (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).Flevel)
		}
		framePtr = (*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr
		for {
			if !(framePtr != rootFramePtr) {
				break
			}
			if int32((*TCallFrame)(unsafe.Pointer(framePtr)).Flevel) == *(*int32)(unsafe.Pointer(bp)) {
				break
			}
			goto _2
		_2:
			;
			framePtr = (*TCallFrame)(unsafe.Pointer(framePtr)).FcallerVarPtr
		}
		if framePtr == rootFramePtr {
			goto levelError
		}
		XTcl_SetObjResult(tls, interp, XTcl_NewListObj(tls, (*TCallFrame)(unsafe.Pointer(framePtr)).Fobjc, (*TCallFrame)(unsafe.Pointer(framePtr)).Fobjv))
		return TCL_OK
	}
	XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+16516)
	return int32(TCL_ERROR)
	goto levelError
levelError:
	;
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+16556, libc.VaList(bp+16, v3)))
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v4 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v4 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+16571, v4, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * InfoLibraryCmd --
 *
 *	Called to implement the "info library" command that returns the
 *	library directory for the Tcl installation. Handles the following
 *	syntax:
 *
 *	    info library
 *
 * Results:
 *	Returns TCL_OK if successful and TCL_ERROR if there is an error.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If there is an
 *	error, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func _InfoLibraryCmd(tls *libc.TLS, dummy1657 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument objects. */
	var libDirName uintptr
	_ = libDirName
	if objc != int32(1) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, libc.UintptrFromInt32(0))
		return int32(TCL_ERROR)
	}
	libDirName = XTcl_GetVar2(tls, interp, __ccgo_ts+17058, libc.UintptrFromInt32(0), int32(TCL_GLOBAL_ONLY))
	if libDirName != libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, libDirName, int64(-int32(1))))
		return TCL_OK
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+17070, int64(-int32(1))))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+17108, __ccgo_ts+17058, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * InfoLoadedCmd --
 *
 *	Called to implement the "info loaded" command that returns the
 *	packages that have been loaded into an interpreter. Handles the
 *	following syntax:
 *
 *	    info loaded ?interp?
 *
 * Results:
 *	Returns TCL_OK if successful and TCL_ERROR if there is an error.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If there is an
 *	error, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func _InfoLoadedCmd(tls *libc.TLS, dummy1704 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var interpName, prefix, v1, v2 uintptr
	_, _, _, _ = interpName, prefix, v1, v2
	if objc > int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+17117)
		return int32(TCL_ERROR)
	}
	if objc < int32(2) { /* Get loaded pkgs in all interpreters. */
		interpName = libc.UintptrFromInt32(0)
	} else { /* Get pkgs just in specified interp. */
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
		}
		interpName = v1
	}
	if objc < int32(3) { /* Get loaded files in all packages. */
		prefix = libc.UintptrFromInt32(0)
	} else { /* Get pkgs just in specified interp. */
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		prefix = v2
	}
	return XTclGetLoadedLibraries(tls, interp, interpName, prefix)
}

/*
 *----------------------------------------------------------------------
 *
 * InfoNameOfExecutableCmd --
 *
 *	Called to implement the "info nameofexecutable" command that returns
 *	the name of the binary file running this application. Handles the
 *	following syntax:
 *
 *	    info nameofexecutable
 *
 * Results:
 *	Returns TCL_OK if successful and TCL_ERROR if there is an error.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If there is an
 *	error, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func _InfoNameOfExecutableCmd(tls *libc.TLS, dummy1752 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	if objc != int32(1) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, libc.UintptrFromInt32(0))
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTclGetObjNameOfExecutable(tls))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * InfoPatchLevelCmd --
 *
 *	Called to implement the "info patchlevel" command that returns the
 *	default value for an argument to a procedure. Handles the following
 *	syntax:
 *
 *	    info patchlevel
 *
 * Results:
 *	Returns TCL_OK if successful and TCL_ERROR if there is an error.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If there is an
 *	error, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func _InfoPatchLevelCmd(tls *libc.TLS, dummy1788 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var patchlevel uintptr
	_ = patchlevel
	if objc != int32(1) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, libc.UintptrFromInt32(0))
		return int32(TCL_ERROR)
	}
	patchlevel = XTcl_GetVar2(tls, interp, __ccgo_ts+7204, libc.UintptrFromInt32(0), libc.Int32FromInt32(TCL_GLOBAL_ONLY)|libc.Int32FromInt32(TCL_LEAVE_ERR_MSG))
	if patchlevel != libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, patchlevel, int64(-int32(1))))
		return TCL_OK
	}
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * InfoProcsCmd --
 *
 *	Called to implement the "info procs" command that returns the list of
 *	procedures in the interpreter that match an optional pattern. The
 *	pattern, if any, consists of an optional sequence of namespace names
 *	separated by "::" qualifiers, which is followed by a glob-style
 *	pattern that restricts which commands are returned. Handles the
 *	following syntax:
 *
 *	    info procs ?pattern?
 *
 * Results:
 *	Returns TCL_OK if successful and TCL_ERROR if there is an error.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If there is an
 *	error, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func _InfoProcsCmd(tls *libc.TLS, dummy1835 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Argument objects. */
	var cachePtr, cachePtr1, cmdName, cmdPtr, currNsPtr, elemObjPtr, entryPtr, listPtr, pattern, realCmdPtr, v1, v5 uintptr
	var specificNsInPattern int32
	var v4, v8 bool
	var _ /* dummy1NsPtr at bp+40 */ uintptr
	var _ /* dummy2NsPtr at bp+48 */ uintptr
	var _ /* nsPtr at bp+8 */ uintptr
	var _ /* search at bp+16 */ TTcl_HashSearch
	var _ /* simplePattern at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cmdName, cmdPtr, currNsPtr, elemObjPtr, entryPtr, listPtr, pattern, realCmdPtr, specificNsInPattern, v1, v4, v5, v8
	currNsPtr = XTcl_GetCurrentNamespace(tls, interp)
	specificNsInPattern = 0
	/*
	 * Get the pattern and find the "effective namespace" in which to list
	 * procs.
	 */
	if objc == int32(1) {
		*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(bp + 8)) = currNsPtr
		specificNsInPattern = 0
	} else {
		if objc == int32(2) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
				v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
			} else {
				v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
			}
			pattern = v1
			XTclGetNamespaceForQualName(tls, interp, pattern, libc.UintptrFromInt32(0), 0, bp+8, bp+40, bp+48, bp)
			if *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) { /* We successfully found the pattern's ns. */
				specificNsInPattern = libc.BoolInt32(libc.Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(bp)), pattern) != 0)
			}
		} else {
			XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+16401)
			return int32(TCL_ERROR)
		}
	}
	if *(*uintptr)(unsafe.Pointer(bp + 8)) == libc.UintptrFromInt32(0) {
		return TCL_OK
	}
	/*
	 * Scan through the effective namespace's command table and create a list
	 * with all procs that match the pattern. If a specific namespace was
	 * requested in the pattern, qualify the command names with the namespace
	 * name.
	 */
	listPtr = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
	if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) && libc.Xstrpbrk(tls, *(*uintptr)(unsafe.Pointer(bp)), __ccgo_ts+16411) == libc.UintptrFromInt32(0) {
		entryPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 184)).FfindProc})))(tls, *(*uintptr)(unsafe.Pointer(bp + 8))+184, *(*uintptr)(unsafe.Pointer(bp)))
		if entryPtr != libc.UintptrFromInt32(0) {
			cmdPtr = (*TTcl_HashEntry)(unsafe.Pointer(entryPtr)).FclientData
			if !!(XTclIsProc(tls, cmdPtr) != 0) {
				goto _2
			}
			realCmdPtr = XTclGetOriginalCommand(tls, cmdPtr)
			if realCmdPtr != libc.UintptrFromInt32(0) && XTclIsProc(tls, realCmdPtr) != 0 {
				goto simpleProcOK
			}
			goto _3
		_2:
			;
			goto simpleProcOK
		simpleProcOK:
			;
			if specificNsInPattern != 0 {
				if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
					elemObjPtr = XTclThreadAllocObj(tls)
				} else {
					elemObjPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(elemObjPtr + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).Flength = 0
				(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).FtypePtr = libc.UintptrFromInt32(0)
				XTcl_GetCommandFullName(tls, interp, cmdPtr, elemObjPtr)
			} else {
				elemObjPtr = XTcl_NewStringObj(tls, *(*uintptr)(unsafe.Pointer(bp)), int64(-int32(1)))
			}
			XTcl_ListObjAppendElement(tls, interp, listPtr, elemObjPtr)
		_3:
		}
	} else {
		entryPtr = XTcl_FirstHashEntry(tls, *(*uintptr)(unsafe.Pointer(bp + 8))+184, bp+16)
		for entryPtr != libc.UintptrFromInt32(0) {
			if (*TTcl_HashTable)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))+184)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))+184)).FkeyType == -int32(1) {
				v5 = *(*uintptr)(unsafe.Pointer(entryPtr + 32))
			} else {
				v5 = entryPtr + 32
			}
			cmdName = v5
			if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) || XTcl_StringCaseMatch(tls, cmdName, *(*uintptr)(unsafe.Pointer(bp)), 0) != 0 {
				cmdPtr = (*TTcl_HashEntry)(unsafe.Pointer(entryPtr)).FclientData
				if !!(XTclIsProc(tls, cmdPtr) != 0) {
					goto _6
				}
				realCmdPtr = XTclGetOriginalCommand(tls, cmdPtr)
				if realCmdPtr != libc.UintptrFromInt32(0) && XTclIsProc(tls, realCmdPtr) != 0 {
					goto procOK
				}
				goto _7
			_6:
				;
				goto procOK
			procOK:
				;
				if specificNsInPattern != 0 {
					if v8 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v8 {
						cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v8 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
						elemObjPtr = XTclThreadAllocObj(tls)
					} else {
						elemObjPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(elemObjPtr + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).FrefCount = 0
					(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).Flength = 0
					(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).FtypePtr = libc.UintptrFromInt32(0)
					XTcl_GetCommandFullName(tls, interp, cmdPtr, elemObjPtr)
				} else {
					elemObjPtr = XTcl_NewStringObj(tls, cmdName, int64(-int32(1)))
				}
				XTcl_ListObjAppendElement(tls, interp, listPtr, elemObjPtr)
			_7:
			}
			entryPtr = XTcl_NextHashEntry(tls, bp+16)
		}
	}
	XTcl_SetObjResult(tls, interp, listPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * InfoScriptCmd --
 *
 *	Called to implement the "info script" command that returns the script
 *	file that is currently being evaluated. Handles the following syntax:
 *
 *	    info script ?newName?
 *
 *	If newName is specified, it will set that as the internal name.
 *
 * Results:
 *	Returns TCL_OK if successful and TCL_ERROR if there is an error.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If there is an
 *	error, the result is an error message. It may change the internal
 *	script filename.
 *
 *----------------------------------------------------------------------
 */

func _InfoScriptCmd(tls *libc.TLS, dummy1976 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var _objPtr, iPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _ = _objPtr, iPtr, v1, v2
	iPtr = interp
	if objc != int32(1) && objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+17135)
		return int32(TCL_ERROR)
	}
	if objc == int32(2) {
		if (*TInterp)(unsafe.Pointer(iPtr)).FscriptFile != libc.UintptrFromInt32(0) {
			_objPtr = (*TInterp)(unsafe.Pointer(iPtr)).FscriptFile
			v2 = _objPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if v1 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
		(*TInterp)(unsafe.Pointer(iPtr)).FscriptFile = *(*uintptr)(unsafe.Pointer(objv + 1*8))
		(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FscriptFile)).FrefCount++
	}
	if (*TInterp)(unsafe.Pointer(iPtr)).FscriptFile != libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, (*TInterp)(unsafe.Pointer(iPtr)).FscriptFile)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * InfoSharedlibCmd --
 *
 *	Called to implement the "info sharedlibextension" command that returns
 *	the file extension used for shared libraries. Handles the following
 *	syntax:
 *
 *	    info sharedlibextension
 *
 * Results:
 *	Returns TCL_OK if successful and TCL_ERROR if there is an error.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If there is an
 *	error, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func _InfoSharedlibCmd(tls *libc.TLS, dummy2024 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	if objc != int32(1) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, libc.UintptrFromInt32(0))
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+1945, int64(-int32(1))))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * InfoTclVersionCmd --
 *
 *	Called to implement the "info tclversion" command that returns the
 *	version number for this Tcl library. Handles the following syntax:
 *
 *	    info tclversion
 *
 * Results:
 *	Returns TCL_OK if successful and TCL_ERROR if there is an error.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If there is an
 *	error, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func _InfoTclVersionCmd(tls *libc.TLS, dummy2062 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var version uintptr
	_ = version
	if objc != int32(1) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, libc.UintptrFromInt32(0))
		return int32(TCL_ERROR)
	}
	version = XTcl_GetVar2Ex(tls, interp, __ccgo_ts+7225, libc.UintptrFromInt32(0), libc.Int32FromInt32(TCL_GLOBAL_ONLY)|libc.Int32FromInt32(TCL_LEAVE_ERR_MSG))
	if version != libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, version)
		return TCL_OK
	}
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * InfoCmdTypeCmd --
 *
 *	Called to implement the "info cmdtype" command that returns the type
 *	of a given command. Handles the following syntax:
 *
 *	    info cmdtype cmdName
 *
 * Results:
 *	Returns TCL_OK if successful and TCL_ERROR if there is an error.
 *
 * Side effects:
 *	Returns a type name. If there is an error, the result is an error
 *	message.
 *
 *----------------------------------------------------------------------
 */

func _InfoCmdTypeCmd(tls *libc.TLS, dummy2105 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Argument objects. */
	var command TTcl_Command
	var v1 uintptr
	_, _ = command, v1
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+17146)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	command = XTcl_FindCommand(tls, interp, v1, libc.UintptrFromInt32(0), int32(TCL_LEAVE_ERR_MSG))
	if command == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * There's one special case: safe child interpreters can't see aliases as
	 * aliases as they're part of the security mechanisms.
	 */
	if XTcl_IsSafe(tls, interp) != 0 && (*TCommand)(unsafe.Pointer(command)).FobjProc == __ccgo_fp(XTclAliasObjCmd) {
		XTcl_AppendResult(tls, interp, libc.VaList(bp+8, __ccgo_ts+7266, libc.UintptrFromInt32(0)))
	} else {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, XTclGetCommandTypeName(tls, command), int64(-int32(1))))
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_JoinObjCmd --
 *
 *	This procedure is invoked to process the "join" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl object result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_JoinObjCmd(tls *libc.TLS, dummy2156 uintptr, interp2 uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* The argument objects. */
	var _objPtr, cachePtr, joinObjPtr, proc, proc1, proc2, resObjPtr, v1, v15, v16, v19, v2, v24, v3, v7, v8 uintptr
	var i, v23, v4 TTcl_Size
	var isAbstractList, v12, v17, v6, v9 int32
	var v11, v21 bool
	var v13, v14 int64
	var _ /* elemObj at bp+24 */ uintptr
	var _ /* elemPtrs at bp+16 */ uintptr
	var _ /* length at bp+0 */ TTcl_Size
	var _ /* listLen at bp+8 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, i, isAbstractList, joinObjPtr, proc, proc1, proc2, resObjPtr, v1, v11, v12, v13, v14, v15, v16, v17, v19, v2, v21, v23, v24, v3, v4, v6, v7, v8, v9
	isAbstractList = 0
	resObjPtr = libc.UintptrFromInt32(0)
	if objc < int32(2) || objc > int32(3) {
		XTcl_WrongNumArgs(tls, interp2, int64(1), objv, __ccgo_ts+17158)
		return int32(TCL_ERROR)
	}
	/*
	 * Make sure the list argument is a list object and get its length and a
	 * pointer to its array of element pointers.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+80) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+80) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr)).Fversion) {
		v1 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr)).FgetElementsProc
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	if v1 != 0 {
		v2 = *(*uintptr)(unsafe.Pointer(objv + 1*8))
		if (*TTcl_Obj)(unsafe.Pointer(v2)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+48) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+48) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v2)).FtypePtr)).Fversion) {
			v3 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v2)).FtypePtr)).FlengthProc
		} else {
			v3 = libc.UintptrFromInt32(0)
		}
		proc = v3
		v4 = (*(*func(*libc.TLS, uintptr) TTcl_Size)(unsafe.Pointer(&struct{ uintptr }{proc})))(tls, v2)
		goto _5
	_5:
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v4
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) != 0 {
			v6 = int32(1)
		} else {
			v6 = 0
		}
		isAbstractList = v6
		if v11 = *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > int64(1); v11 {
			v7 = *(*uintptr)(unsafe.Pointer(objv + 1*8))
			if (*TTcl_Obj)(unsafe.Pointer(v7)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+80) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+80) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v7)).FtypePtr)).Fversion) {
				v8 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v7)).FtypePtr)).FgetElementsProc
			} else {
				v8 = libc.UintptrFromInt32(0)
			}
			proc2 = v8
			v9 = (*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{proc2})))(tls, interp2, v7, bp+8, bp+16)
			goto _10
		_10:
		}
		if v11 && v9 != TCL_OK {
			return int32(TCL_ERROR)
		}
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
				v13 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanStart
			} else {
				v13 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 16)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1 + 40 + uintptr(v13)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
				v14 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanLength
			} else {
				v14 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v14
			v12 = libc.Int32FromInt32(TCL_OK)
		} else {
			v12 = XTcl_ListObjGetElements(tls, interp2, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+8, bp+16)
		}
		if v12 != TCL_OK {
			return int32(TCL_ERROR)
		}
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == 0 {
		/* No elements to join; default empty result is correct. */
		return TCL_OK
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(1) {
		/* One element; return it */
		if !(isAbstractList != 0) {
			XTcl_SetObjResult(tls, interp2, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))))
		} else {
			v15 = *(*uintptr)(unsafe.Pointer(objv + 1*8))
			if (*TTcl_Obj)(unsafe.Pointer(v15)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+56) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+56) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v15)).FtypePtr)).Fversion) {
				v16 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v15)).FtypePtr)).FindexProc
			} else {
				v16 = libc.UintptrFromInt32(0)
			}
			proc1 = v16
			v17 = (*(*func(*libc.TLS, uintptr, uintptr, TTcl_Size, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{proc1})))(tls, interp2, v15, 0, bp+24)
			goto _18
		_18:
			if v17 != TCL_OK {
				return int32(TCL_ERROR)
			}
			XTcl_SetObjResult(tls, interp2, *(*uintptr)(unsafe.Pointer(bp + 24)))
		}
		return TCL_OK
	}
	if objc == int32(2) {
		v19 = XTcl_NewStringObj(tls, __ccgo_ts+14830, int64(1))
	} else {
		v19 = *(*uintptr)(unsafe.Pointer(objv + 2*8))
	}
	joinObjPtr = v19
	(*TTcl_Obj)(unsafe.Pointer(joinObjPtr)).FrefCount++
	if (*TTcl_Obj)(unsafe.Pointer(joinObjPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(joinObjPtr)).Flength
		_ = (*TTcl_Obj)(unsafe.Pointer(joinObjPtr)).Fbytes
	} else {
		XTcl_GetStringFromObj(tls, joinObjPtr, bp)
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
		resObjPtr = XTclStringCat(tls, interp2, *(*TTcl_Size)(unsafe.Pointer(bp + 8)), *(*uintptr)(unsafe.Pointer(bp + 16)), 0)
	} else {
		if v21 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v21 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v21 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			resObjPtr = XTclThreadAllocObj(tls)
		} else {
			resObjPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(resObjPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(resObjPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(resObjPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(resObjPtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(resObjPtr)).FtypePtr = libc.UintptrFromInt32(0)
		i = 0
		for {
			if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) {
				break
			}
			if i > 0 {
				/*
				 * NOTE: This code is relying on Tcl_AppendObjToObj() **NOT**
				 * to shimmer joinObjPtr.  If it did, then the case where
				 * objv[1] and objv[2] are the same value would not be safe.
				 * Accessing elemPtrs would crash.
				 */
				XTcl_AppendObjToObj(tls, resObjPtr, joinObjPtr)
			}
			XTcl_AppendObjToObj(tls, resObjPtr, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i)*8)))
			goto _22
		_22:
			;
			i++
		}
	}
	_objPtr = joinObjPtr
	v24 = _objPtr
	v23 = *(*TTcl_Size)(unsafe.Pointer(v24))
	*(*TTcl_Size)(unsafe.Pointer(v24))--
	if v23 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	if resObjPtr != 0 {
		XTcl_SetObjResult(tls, interp2, resObjPtr)
		return TCL_OK
	}
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LassignObjCmd --
 *
 *	This object-based procedure is invoked to process the "lassign" Tcl
 *	command. See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl object result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LassignObjCmd(tls *libc.TLS, dummy2258 uintptr, interp1 uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Argument objects. */
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, cachePtr, emptyObj, listPtr, proc, v11, v13, v15, v16, v17, v18, v4, v6, v8 uintptr
	var fromIdx1, origListObjc, toIdx1, v12, v14, v5, v7 TTcl_Size
	var i, v1, v10, v19 int32
	var v2 int64
	var v9 bool
	var _ /* elemObj at bp+8 */ uintptr
	var _ /* listObjc at bp+0 */ TTcl_Size
	var _ /* resultObjPtr at bp+16 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, cachePtr, emptyObj, fromIdx1, i, listPtr, origListObjc, proc, toIdx1, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v4, v5, v6, v7, v8, v9
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp1, int64(1), objv, __ccgo_ts+17176)
		return int32(TCL_ERROR)
	}
	/*
	 * Note: no need to Dup the list to avoid shimmering. That is only
	 * needed when Tcl_ListObjGetElements is used since that returns
	 * pointers to internal structures. Using Tcl_ListObjIndex does not
	 * have that problem. However, we now have to IncrRef each elemObj
	 * (see below). I see that as preferable as duping lists is potentially
	 * expensive for abstract lists when they have a string representation.
	 */
	listPtr = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	if (*TTcl_Obj)(unsafe.Pointer(listPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listPtr + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr + 32))).Fptr2)).FspanLength
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v2
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjLength(tls, interp1, listPtr, bp)
	}
	if v1 != TCL_OK {
		return int32(TCL_ERROR)
	}
	origListObjc = *(*TTcl_Size)(unsafe.Pointer(bp))
	objc -= int32(2)
	objv += uintptr(2) * 8
	i = 0
	for {
		if !(i < objc && int64(i) < *(*TTcl_Size)(unsafe.Pointer(bp))) {
			break
		}
		if XTcl_ListObjIndex(tls, interp1, listPtr, int64(i), bp+8) != TCL_OK {
			return int32(TCL_ERROR)
		}
		/*
		 * Must incrref elemObj. If the var name being set is same as the
		 * list value, ObjSetVar2 will shimmer the list to a VAR freeing
		 * the elements in the list (in case list refCount was 1) BEFORE
		 * the elemObj is stored in the var. See tests 6.{25,26}
		 */
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
		v4 = objv
		objv += 8
		if XTcl_ObjSetVar2(tls, interp1, *(*uintptr)(unsafe.Pointer(v4)), libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 8)), int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
			_objPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
			v6 = _objPtr
			v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
			*(*TTcl_Size)(unsafe.Pointer(v6))--
			if v5 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			return int32(TCL_ERROR)
		}
		_objPtr1 = *(*uintptr)(unsafe.Pointer(bp + 8))
		v8 = _objPtr1
		v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
		*(*TTcl_Size)(unsafe.Pointer(v8))--
		if v7 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		goto _3
	_3:
		;
		i++
	}
	objc -= i
	*(*TTcl_Size)(unsafe.Pointer(bp)) -= int64(i)
	if objc > 0 {
		if v9 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v9 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v9 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			emptyObj = XTclThreadAllocObj(tls)
		} else {
			emptyObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(emptyObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(emptyObj)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(emptyObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(emptyObj)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(emptyObj)).FtypePtr = libc.UintptrFromInt32(0)
		(*TTcl_Obj)(unsafe.Pointer(emptyObj)).FrefCount++
		for {
			v10 = objc
			objc--
			if !(v10 > 0) {
				break
			}
			v11 = objv
			objv += 8
			if XTcl_ObjSetVar2(tls, interp1, *(*uintptr)(unsafe.Pointer(v11)), libc.UintptrFromInt32(0), emptyObj, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
				_objPtr2 = emptyObj
				v13 = _objPtr2
				v12 = *(*TTcl_Size)(unsafe.Pointer(v13))
				*(*TTcl_Size)(unsafe.Pointer(v13))--
				if v12 <= int64(1) {
					XTclFreeObj(tls, _objPtr2)
				}
				return int32(TCL_ERROR)
			}
		}
		_objPtr3 = emptyObj
		v15 = _objPtr3
		v14 = *(*TTcl_Size)(unsafe.Pointer(v15))
		*(*TTcl_Size)(unsafe.Pointer(v15))--
		if v14 <= int64(1) {
			XTclFreeObj(tls, _objPtr3)
		}
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp)) > 0 {
		*(*uintptr)(unsafe.Pointer(bp + 16)) = libc.UintptrFromInt32(0)
		fromIdx1 = origListObjc - *(*TTcl_Size)(unsafe.Pointer(bp))
		toIdx1 = origListObjc - int64(1)
		if (*TTcl_Obj)(unsafe.Pointer(listPtr)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+64) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+64) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listPtr)).FtypePtr)).Fversion) {
			v16 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listPtr)).FtypePtr)).FsliceProc
		} else {
			v16 = libc.UintptrFromInt32(0)
		}
		if v16 != 0 {
			v17 = listPtr
			if (*TTcl_Obj)(unsafe.Pointer(v17)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+64) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+64) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v17)).FtypePtr)).Fversion) {
				v18 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v17)).FtypePtr)).FsliceProc
			} else {
				v18 = libc.UintptrFromInt32(0)
			}
			proc = v18
			v19 = (*(*func(*libc.TLS, uintptr, uintptr, TTcl_Size, TTcl_Size, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{proc})))(tls, interp1, v17, fromIdx1, toIdx1, bp+16)
			goto _20
		_20:
			if v19 != TCL_OK {
				return int32(TCL_ERROR)
			}
		} else {
			*(*uintptr)(unsafe.Pointer(bp + 16)) = XTclListObjRange(tls, interp1, listPtr, origListObjc-*(*TTcl_Size)(unsafe.Pointer(bp)), origListObjc-int64(1))
			if *(*uintptr)(unsafe.Pointer(bp + 16)) == libc.UintptrFromInt32(0) {
				return int32(TCL_ERROR)
			}
		}
		XTcl_SetObjResult(tls, interp1, *(*uintptr)(unsafe.Pointer(bp + 16)))
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LindexObjCmd --
 *
 *	This object-based procedure is invoked to process the "lindex" Tcl
 *	command. See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl object result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LindexObjCmd(tls *libc.TLS, dummy2370 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var _objPtr, elemPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _ = _objPtr, elemPtr, v1, v2 /* Pointer to the element being extracted. */
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+17195)
		return int32(TCL_ERROR)
	}
	/*
	 * If objc==3, then objv[2] may be either a single index or a list of
	 * indices: go to TclLindexList to determine which. If objc>=4, or
	 * objc==2, then objv[2 .. objc-2] are all single indices and processed as
	 * such in TclLindexFlat.
	 */
	if objc == int32(3) {
		elemPtr = XTclLindexList(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), *(*uintptr)(unsafe.Pointer(objv + 2*8)))
	} else {
		elemPtr = XTclLindexFlat(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), int64(objc-int32(2)), objv+uintptr(2)*8)
	}
	/*
	 * Set the interpreter's object result to the last element extracted.
	 */
	if elemPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, elemPtr)
	_objPtr = elemPtr
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LinsertObjCmd --
 *
 *	This object-based procedure is invoked to process the "linsert" Tcl
 *	command. See the user documentation for details on what it does.
 *
 * Results:
 *	A new Tcl list object formed by inserting zero or more elements into a
 *	list.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LinsertObjCmd(tls *libc.TLS, dummy2428 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var _objPtr, _objPtr1, listPtr, v5, v7 uintptr
	var copied, result, v1, v3 int32
	var v2 int64
	var v4, v6 TTcl_Size
	var _ /* index at bp+8 */ TTcl_Size
	var _ /* len at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, copied, listPtr, result, v1, v2, v3, v4, v5, v6, v7
	copied = 0
	if objc < int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+17212)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanLength
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v2
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjLength(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
	}
	result = v1
	if result != TCL_OK {
		return result
	}
	/*
	 * Get the index. "end" is interpreted to be the index after the last
	 * element, such that using it will cause any inserted elements to be
	 * appended to the list.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) <= *(*TTcl_Size)(unsafe.Pointer(bp)) {
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep))
		v3 = libc.Int32FromInt32(TCL_OK)
	} else {
		v3 = XTcl_GetIntForIndex(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), *(*TTcl_Size)(unsafe.Pointer(bp)), bp+8)
	}
	result = v3
	if result != TCL_OK {
		return result
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > *(*TTcl_Size)(unsafe.Pointer(bp)) {
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = *(*TTcl_Size)(unsafe.Pointer(bp))
	}
	/*
	 * If the list object is unshared we can modify it directly. Otherwise we
	 * create a copy to modify: this is "copy on write".
	 */
	listPtr = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	if (*TTcl_Obj)(unsafe.Pointer(listPtr)).FrefCount > int64(1) {
		listPtr = XTclListObjCopy(tls, libc.UintptrFromInt32(0), listPtr)
		copied = int32(1)
	}
	if objc == int32(4) && *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == *(*TTcl_Size)(unsafe.Pointer(bp)) {
		/*
		 * Special case: insert one element at the end of the list.
		 */
		result = XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listPtr, *(*uintptr)(unsafe.Pointer(objv + 3*8)))
		if result != TCL_OK {
			if copied != 0 {
				_objPtr = listPtr
				v5 = _objPtr
				v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
				*(*TTcl_Size)(unsafe.Pointer(v5))--
				if v4 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
			return result
		}
	} else {
		if TCL_OK != XTcl_ListObjReplace(tls, interp, listPtr, *(*TTcl_Size)(unsafe.Pointer(bp + 8)), 0, int64(objc-libc.Int32FromInt32(3)), objv+3*8) {
			if copied != 0 {
				_objPtr1 = listPtr
				v7 = _objPtr1
				v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
				*(*TTcl_Size)(unsafe.Pointer(v7))--
				if v6 <= int64(1) {
					XTclFreeObj(tls, _objPtr1)
				}
			}
			return int32(TCL_ERROR)
		}
	}
	/*
	 * Set the interpreter's object result.
	 */
	XTcl_SetObjResult(tls, interp, listPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ListObjCmd --
 *
 *	This procedure is invoked to process the "list" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl object result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ListObjCmd(tls *libc.TLS, dummy2521 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* The argument objects. */
	/*
	 * If there are no list elements, the result is an empty object.
	 * Otherwise set the interpreter's result object to be a list object.
	 */
	if objc > int32(1) {
		XTcl_SetObjResult(tls, interp, XTcl_NewListObj(tls, int64(objc-int32(1)), objv+1*8))
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LlengthObjCmd --
 *
 *	This object-based procedure is invoked to process the "llength" Tcl
 *	command. See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl object result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LlengthObjCmd(tls *libc.TLS, dummy2557 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	/* Argument objects. */
	var cachePtr, objPtr uintptr
	var result, v1 int32
	var uw_ TTcl_WideUInt
	var v2 int64
	var v3 bool
	var _ /* bignumValue_ at bp+8 */ Tmp_int
	var _ /* listLen at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _ = cachePtr, objPtr, result, uw_, v1, v2, v3
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+2860)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanLength
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v2
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjLength(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
	}
	result = v1
	if result != TCL_OK {
		return result
	}
	/*
	 * Set the interpreter's object result to an integer object holding the
	 * length.
	 */
	if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = libc.UintptrFromInt32(0)
	uw_ = libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))
	if uw_ > libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) {
		if XTclBN_mp_init_u64(tls, bp+8, uw_) != MP_OKAY {
			XTcl_Panic(tls, __ccgo_ts+13273, libc.VaList(bp+40, __ccgo_ts+13293))
		}
		XTclSetBignumInternalRep(tls, objPtr, bp+8)
	} else {
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) = libc.Int64FromUint64(uw_)
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	}
	XTcl_SetObjResult(tls, interp, objPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LpopObjCmd --
 *
 *	This procedure is invoked to process the "lpop" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl object result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LpopObjCmd(tls *libc.TLS, dummy2606 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	/* Argument objects. */
	var _objPtr, _objPtr1, _objPtr2, listPtr, newListPtr, proc, stored, v4, v6, v7, v9 uintptr
	var copied, result, v1 int32
	var v2 int64
	var v3, v5, v8 TTcl_Size
	var _ /* elemPtr at bp+8 */ uintptr
	var _ /* listLen at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, copied, listPtr, newListPtr, proc, result, stored, v1, v2, v3, v4, v5, v6, v7, v8, v9
	copied = 0
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+17237)
		return int32(TCL_ERROR)
	}
	listPtr = XTcl_ObjGetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), int32(TCL_LEAVE_ERR_MSG))
	if listPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(listPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listPtr + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr + 32))).Fptr2)).FspanLength
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v2
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjLength(tls, interp, listPtr, bp)
	}
	result = v1
	if result != TCL_OK {
		return result
	}
	/*
	 * First, extract the element to be returned.
	 * TclLindexFlat adds a ref count which is handled.
	 */
	if objc == int32(2) {
		if !(*(*TTcl_Size)(unsafe.Pointer(bp)) != 0) {
			/* empty list, throw the same error as with index "end" */
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+17253, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+17278, __ccgo_ts+17284, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		result = XTcl_ListObjIndex(tls, interp, listPtr, *(*TTcl_Size)(unsafe.Pointer(bp))-libc.Int64FromInt32(1), bp+8)
		if result != TCL_OK {
			return result
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
	} else {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclLindexFlat(tls, interp, listPtr, int64(objc-int32(2)), objv+uintptr(2)*8)
		if *(*uintptr)(unsafe.Pointer(bp + 8)) == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
	}
	XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 8)))
	_objPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
	v4 = _objPtr
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	if v3 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	/*
	 * Second, remove the element.
	 * TclLsetFlat adds a ref count which is handled.
	 */
	if objc == int32(2) {
		if (*TTcl_Obj)(unsafe.Pointer(listPtr)).FrefCount > int64(1) {
			listPtr = XTclListObjCopy(tls, libc.UintptrFromInt32(0), listPtr)
			copied = int32(1)
		}
		result = XTcl_ListObjReplace(tls, interp, listPtr, *(*TTcl_Size)(unsafe.Pointer(bp))-int64(1), int64(1), 0, libc.UintptrFromInt32(0))
		if result != TCL_OK {
			if copied != 0 {
				_objPtr1 = listPtr
				v6 = _objPtr1
				v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
				*(*TTcl_Size)(unsafe.Pointer(v6))--
				if v5 <= int64(1) {
					XTclFreeObj(tls, _objPtr1)
				}
			}
			return result
		}
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(listPtr)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+88) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+88) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listPtr)).FtypePtr)).Fversion) {
			v7 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listPtr)).FtypePtr)).FsetElementProc
		} else {
			v7 = libc.UintptrFromInt32(0)
		}
		proc = v7
		if proc != 0 {
			newListPtr = (*(*func(*libc.TLS, uintptr, uintptr, TTcl_Size, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{proc})))(tls, interp, listPtr, int64(objc-int32(2)), objv+uintptr(2)*8, libc.UintptrFromInt32(0))
		} else {
			newListPtr = XTclLsetFlat(tls, interp, listPtr, int64(objc-int32(2)), objv+uintptr(2)*8, libc.UintptrFromInt32(0))
		}
		if newListPtr == libc.UintptrFromInt32(0) {
			if copied != 0 {
				_objPtr2 = listPtr
				v9 = _objPtr2
				v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
				*(*TTcl_Size)(unsafe.Pointer(v9))--
				if v8 <= int64(1) {
					XTclFreeObj(tls, _objPtr2)
				}
			}
			return int32(TCL_ERROR)
		} else {
			listPtr = newListPtr
			XTclUndoRefCount(tls, listPtr)
		}
	}
	stored = XTcl_ObjSetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), listPtr, int32(TCL_LEAVE_ERR_MSG))
	if stored == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LrangeObjCmd --
 *
 *	This procedure is invoked to process the "lrange" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl object result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LrangeObjCmd(tls *libc.TLS, dummy2725 uintptr, interp1 uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	/* Argument objects. */
	var proc, resultObj1, v5, v6, v7 uintptr
	var result, status, v1, v3, v4, v8 int32
	var v2 int64
	var _ /* first at bp+8 */ TTcl_Size
	var _ /* last at bp+16 */ TTcl_Size
	var _ /* listLen at bp+0 */ TTcl_Size
	var _ /* resultObj at bp+24 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _ = proc, result, resultObj1, status, v1, v2, v3, v4, v5, v6, v7, v8
	if objc != int32(4) {
		XTcl_WrongNumArgs(tls, interp1, int64(1), objv, __ccgo_ts+17295)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanLength
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v2
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjLength(tls, interp1, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
	}
	result = v1
	if result != TCL_OK {
		return result
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) <= *(*TTcl_Size)(unsafe.Pointer(bp))-int64(1) {
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep))
		v3 = libc.Int32FromInt32(TCL_OK)
	} else {
		v3 = XTcl_GetIntForIndex(tls, interp1, *(*uintptr)(unsafe.Pointer(objv + 2*8)), *(*TTcl_Size)(unsafe.Pointer(bp))-libc.Int64FromInt32(1), bp+8)
	}
	result = v3
	if result != TCL_OK {
		return result
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep)) <= *(*TTcl_Size)(unsafe.Pointer(bp))-int64(1) {
		*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep))
		v4 = libc.Int32FromInt32(TCL_OK)
	} else {
		v4 = XTcl_GetIntForIndex(tls, interp1, *(*uintptr)(unsafe.Pointer(objv + 3*8)), *(*TTcl_Size)(unsafe.Pointer(bp))-libc.Int64FromInt32(1), bp+16)
	}
	result = v4
	if result != TCL_OK {
		return result
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+64) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+64) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr)).Fversion) {
		v5 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr)).FsliceProc
	} else {
		v5 = libc.UintptrFromInt32(0)
	}
	if v5 != 0 {
		v6 = *(*uintptr)(unsafe.Pointer(objv + 1*8))
		if (*TTcl_Obj)(unsafe.Pointer(v6)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+64) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+64) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v6)).FtypePtr)).Fversion) {
			v7 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v6)).FtypePtr)).FsliceProc
		} else {
			v7 = libc.UintptrFromInt32(0)
		}
		proc = v7
		v8 = (*(*func(*libc.TLS, uintptr, uintptr, TTcl_Size, TTcl_Size, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{proc})))(tls, interp1, v6, *(*TTcl_Size)(unsafe.Pointer(bp + 8)), *(*TTcl_Size)(unsafe.Pointer(bp + 16)), bp+24)
		goto _9
	_9:
		status = v8
		if status == TCL_OK {
			XTcl_SetObjResult(tls, interp1, *(*uintptr)(unsafe.Pointer(bp + 24)))
		} else {
			return int32(TCL_ERROR)
		}
	} else {
		resultObj1 = XTclListObjRange(tls, interp1, *(*uintptr)(unsafe.Pointer(objv + 1*8)), *(*TTcl_Size)(unsafe.Pointer(bp + 8)), *(*TTcl_Size)(unsafe.Pointer(bp + 16)))
		if resultObj1 == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
		XTcl_SetObjResult(tls, interp1, resultObj1)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LremoveObjCmd --
 *
 *	This procedure is invoked to process the "lremove" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl object result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _LremoveIndexCompare(tls *libc.TLS, el1Ptr uintptr, el2Ptr uintptr) (r int32) {
	var idx1, idx2 TTcl_Size
	var v1, v2 int32
	_, _, _, _ = idx1, idx2, v1, v2
	idx1 = *(*TTcl_Size)(unsafe.Pointer(el1Ptr))
	idx2 = *(*TTcl_Size)(unsafe.Pointer(el2Ptr))
	/*
	 * This will put the larger element first.
	 */
	if idx1 < idx2 {
		v1 = int32(1)
	} else {
		if idx1 > idx2 {
			v2 = -int32(1)
		} else {
			v2 = 0
		}
		v1 = v2
	}
	return v1
}

func XTcl_LremoveObjCmd(tls *libc.TLS, dummy2807 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var _objPtr, idxv, listObj, v7 uintptr
	var copied, status, v1, v4 int32
	var first, i, idx, idxc, num, prevIdx, v6 TTcl_Size
	var v2 int64
	var _ /* listLen at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, copied, first, i, idx, idxc, idxv, listObj, num, prevIdx, status, v1, v2, v4, v6, v7
	copied = 0
	status = TCL_OK
	/*
	 * Parse the arguments.
	 */
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+17195)
		return int32(TCL_ERROR)
	}
	listObj = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	if (*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listObj + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr2)).FspanLength
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v2
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjLength(tls, interp, listObj, bp)
	}
	if v1 != TCL_OK {
		return int32(TCL_ERROR)
	}
	idxc = int64(objc - int32(2))
	if idxc == 0 {
		XTcl_SetObjResult(tls, interp, listObj)
		return TCL_OK
	}
	idxv = XTcl_Alloc(tls, libc.Uint64FromInt32(objc-libc.Int32FromInt32(2))*uint64(8))
	i = int64(2)
	for {
		if !(i < int64(objc)) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep)) <= *(*TTcl_Size)(unsafe.Pointer(bp))-int64(1) {
			*(*TTcl_Size)(unsafe.Pointer(idxv + uintptr(i-int64(2))*8)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep))
			v4 = libc.Int32FromInt32(TCL_OK)
		} else {
			v4 = XTcl_GetIntForIndex(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), *(*TTcl_Size)(unsafe.Pointer(bp))-libc.Int64FromInt32(1), idxv+uintptr(i-int64(2))*8)
		}
		status = libc.BoolInt32(v4 != TCL_OK)
		if status != TCL_OK {
			goto done
		}
		goto _3
	_3:
		;
		i++
	}
	/*
	 * Sort the indices, large to small so that when we remove an index we
	 * don't change the indices still to be processed.
	 */
	if idxc > int64(1) {
		libc.Xqsort(tls, idxv, libc.Uint64FromInt64(idxc), uint64(8), __ccgo_fp(_LremoveIndexCompare))
	}
	/*
	 * Make our working copy, then do the actual removes piecemeal.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(listObj)).FrefCount > int64(1) {
		listObj = XTclListObjCopy(tls, libc.UintptrFromInt32(0), listObj)
		copied = int32(1)
	}
	num = 0
	first = *(*TTcl_Size)(unsafe.Pointer(bp))
	i = 0
	prevIdx = int64(-libc.Int32FromInt32(1))
	for {
		if !(i < idxc) {
			break
		}
		idx = *(*TTcl_Size)(unsafe.Pointer(idxv + uintptr(i)*8))
		/*
		 * Repeated index and sanity check.
		 */
		if idx == prevIdx {
			goto _5
		}
		prevIdx = idx
		if idx < 0 || idx >= *(*TTcl_Size)(unsafe.Pointer(bp)) {
			goto _5
		}
		/*
		 * Coalesce adjacent removes to reduce the number of copies.
		 */
		if num == 0 {
			num = int64(1)
			first = idx
		} else {
			if idx+int64(1) == first {
				num++
				first = idx
			} else {
				/*
				 * Note that this operation can't fail now; we know we have a list
				 * and we're only ever contracting that list.
				 */
				status = XTcl_ListObjReplace(tls, interp, listObj, first, num, 0, libc.UintptrFromInt32(0))
				if status != TCL_OK {
					goto done
				}
				*(*TTcl_Size)(unsafe.Pointer(bp)) -= num
				num = int64(1)
				first = idx
			}
		}
		goto _5
	_5:
		;
		i++
	}
	if num != 0 {
		status = XTcl_ListObjReplace(tls, interp, listObj, first, num, 0, libc.UintptrFromInt32(0))
		if status != TCL_OK {
			if copied != 0 {
				_objPtr = listObj
				v7 = _objPtr
				v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
				*(*TTcl_Size)(unsafe.Pointer(v7))--
				if v6 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
			goto done
		}
	}
	XTcl_SetObjResult(tls, interp, listObj)
	goto done
done:
	;
	XTclpFree(tls, idxv)
	return status
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LrepeatObjCmd --
 *
 *	This procedure is invoked to process the "lrepeat" Tcl command. See
 *	the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl object result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LrepeatObjCmd(tls *libc.TLS, dummy2938 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	/* The argument objects. */
	var dataArray, listPtr, tmpPtr, p3 uintptr
	var i TTcl_WideInt
	var j, k, totalElems, v7 TTcl_Size
	var v1 int32
	var v2 int64
	var _ /* elementCount at bp+0 */ TTcl_WideInt
	var _ /* listRep at bp+8 */ TListRep
	_, _, _, _, _, _, _, _, _, _, _ = dataArray, i, j, k, listPtr, tmpPtr, totalElems, v1, v2, v7, p3
	dataArray = libc.UintptrFromInt32(0)
	/*
	 * Check arguments for legality:
	 *		lrepeat count ?value ...?
	 */
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+17311)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*TTcl_WideInt)(unsafe.Pointer(bp)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FinternalRep))
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_GetWideIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
	}
	if TCL_OK != v1 {
		return int32(TCL_ERROR)
	}
	if *(*TTcl_WideInt)(unsafe.Pointer(bp)) < 0 {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+17329, libc.VaList(bp+32, *(*TTcl_WideInt)(unsafe.Pointer(bp)))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+32, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+17368, __ccgo_ts+17376, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Skip forward to the interesting arguments now we've finished parsing.
	 */
	objc -= int32(2)
	objv += uintptr(2) * 8
	/* Final sanity check. Do not exceed limits on max list length. */
	if *(*TTcl_WideInt)(unsafe.Pointer(bp)) != 0 && int64(objc) > int64(libc.Int64FromUint64((libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))-uint64(libc.UintptrFromInt32(0)+40))/libc.Uint64FromInt64(8))) / *(*TTcl_WideInt)(unsafe.Pointer(bp)) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+17383, libc.VaList(bp+32, libc.Int64FromUint64((libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))-uint64(libc.UintptrFromInt32(0)+40))/libc.Uint64FromInt64(8)))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+32, __ccgo_ts+2004, __ccgo_ts+2008, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	totalElems = int64(objc) * *(*TTcl_WideInt)(unsafe.Pointer(bp))
	/*
	 * Get an empty list object that is allocated large enough to hold each
	 * init value elementCount times.
	 */
	listPtr = XTcl_NewListObj(tls, totalElems, libc.UintptrFromInt32(0))
	if totalElems != 0 {
		(*TListRep)(unsafe.Pointer(bp + 8)).FstorePtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listPtr + 32))).Fptr1
		(*TListRep)(unsafe.Pointer(bp + 8)).FspanPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listPtr + 32))).Fptr2
		if (*TListRep)(unsafe.Pointer(bp+8)).FspanPtr != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp + 8)).FspanPtr)).FspanStart
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp + 8)).FstorePtr)).FfirstUsed
		}
		dataArray = (*TListRep)(unsafe.Pointer(bp+8)).FstorePtr + 40 + uintptr(v2)*8
		(*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp + 8))).FstorePtr)).FnumUsed = totalElems
		if (*(*TListRep)(unsafe.Pointer(bp + 8))).FspanPtr != 0 {
			/* Future proofing in case Tcl_NewListObj returns a span */
			(*TListSpan)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp + 8))).FspanPtr)).FspanStart = (*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp + 8))).FstorePtr)).FfirstUsed
			(*TListSpan)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp + 8))).FspanPtr)).FspanLength = (*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp + 8))).FstorePtr)).FnumUsed
		}
	}
	/*
	 * Set the elements. Note that we handle the common degenerate case of a
	 * single value being repeated separately to permit the compiler as much
	 * room as possible to optimize a loop that might be run a very large
	 * number of times.
	 */
	if objc == int32(1) {
		tmpPtr = *(*uintptr)(unsafe.Pointer(objv))
		p3 = tmpPtr
		*(*TTcl_Size)(unsafe.Pointer(p3)) = *(*TTcl_Size)(unsafe.Pointer(p3)) + *(*TTcl_WideInt)(unsafe.Pointer(bp))
		i = 0
		for {
			if !(i < *(*TTcl_WideInt)(unsafe.Pointer(bp))) {
				break
			}
			*(*uintptr)(unsafe.Pointer(dataArray + uintptr(i)*8)) = tmpPtr
			goto _4
		_4:
			;
			i++
		}
	} else {
		k = 0
		i = 0
		for {
			if !(i < *(*TTcl_WideInt)(unsafe.Pointer(bp))) {
				break
			}
			j = 0
			for {
				if !(j < int64(objc)) {
					break
				}
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(j)*8)))).FrefCount++
				v7 = k
				k++
				*(*uintptr)(unsafe.Pointer(dataArray + uintptr(v7)*8)) = *(*uintptr)(unsafe.Pointer(objv + uintptr(j)*8))
				goto _6
			_6:
				;
				j++
			}
			goto _5
		_5:
			;
			i++
		}
	}
	XTcl_SetObjResult(tls, interp, listPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LreplaceObjCmd --
 *
 *	This object-based procedure is invoked to process the "lreplace" Tcl
 *	command. See the user documentation for details on what it does.
 *
 * Results:
 *	A new Tcl list object formed by replacing zero or more elements of a
 *	list.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LreplaceObjCmd(tls *libc.TLS, dummy3053 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Argument objects. */
	var _objPtr, listPtr, v6 uintptr
	var numToDelete, v5 TTcl_Size
	var result, v1, v3, v4 int32
	var v2 int64
	var _ /* first at bp+8 */ TTcl_Size
	var _ /* last at bp+16 */ TTcl_Size
	var _ /* listLen at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _ = _objPtr, listPtr, numToDelete, result, v1, v2, v3, v4, v5, v6
	if objc < int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+17432)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanLength
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v2
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjLength(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
	}
	result = v1
	if result != TCL_OK {
		return result
	}
	/*
	 * Get the first and last indexes. "end" is interpreted to be the index
	 * for the last element, such that using it will cause that element to be
	 * included for deletion.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) <= *(*TTcl_Size)(unsafe.Pointer(bp))-int64(1) {
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep))
		v3 = libc.Int32FromInt32(TCL_OK)
	} else {
		v3 = XTcl_GetIntForIndex(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), *(*TTcl_Size)(unsafe.Pointer(bp))-libc.Int64FromInt32(1), bp+8)
	}
	result = v3
	if result != TCL_OK {
		return result
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep)) <= *(*TTcl_Size)(unsafe.Pointer(bp))-int64(1) {
		*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep))
		v4 = libc.Int32FromInt32(TCL_OK)
	} else {
		v4 = XTcl_GetIntForIndex(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)), *(*TTcl_Size)(unsafe.Pointer(bp))-libc.Int64FromInt32(1), bp+16)
	}
	result = v4
	if result != TCL_OK {
		return result
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) < 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0
	} else {
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > *(*TTcl_Size)(unsafe.Pointer(bp)) {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = *(*TTcl_Size)(unsafe.Pointer(bp))
		}
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) >= *(*TTcl_Size)(unsafe.Pointer(bp)) {
		*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = *(*TTcl_Size)(unsafe.Pointer(bp)) - int64(1)
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) <= *(*TTcl_Size)(unsafe.Pointer(bp + 16)) {
		numToDelete = libc.Int64FromUint64(libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 16))) - libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8))) + uint64(1)) /* See [3d3124d01d] */
	} else {
		numToDelete = 0
	}
	/*
	 * If the list object is unshared we can modify it directly, otherwise we
	 * create a copy to modify: this is "copy on write".
	 */
	listPtr = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	if (*TTcl_Obj)(unsafe.Pointer(listPtr)).FrefCount > int64(1) {
		listPtr = XTclListObjCopy(tls, libc.UintptrFromInt32(0), listPtr)
	}
	/*
	 * Note that we call Tcl_ListObjReplace even when numToDelete == 0 and
	 * objc == 4. In this case, the list value of listPtr is not changed (no
	 * elements are removed or added), but by making the call we are assured
	 * we end up with a list in canonical form. Resist any temptation to
	 * optimize this case away.
	 */
	if TCL_OK != XTcl_ListObjReplace(tls, interp, listPtr, *(*TTcl_Size)(unsafe.Pointer(bp + 8)), numToDelete, int64(objc-int32(4)), objv+uintptr(4)*8) {
		_objPtr = listPtr
		v6 = _objPtr
		v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
		*(*TTcl_Size)(unsafe.Pointer(v6))--
		if v5 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		return int32(TCL_ERROR)
	}
	/*
	 * Set the interpreter's object result.
	 */
	XTcl_SetObjResult(tls, interp, listPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LreverseObjCmd --
 *
 *	This procedure is invoked to process the "lreverse" Tcl command. See
 *	the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LreverseObjCmd(tls *libc.TLS, dummy3155 uintptr, interp1 uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument values. */
	var _isobjPtr, dataArray, proc, resultObj1, tmp, v1, v2, v3 uintptr
	var i, j TTcl_Size
	var v10, v11, v7, v9 int64
	var v4, v6, v8 int32
	var _ /* elemc at bp+8 */ TTcl_Size
	var _ /* elemv at bp+0 */ uintptr
	var _ /* listRep at bp+24 */ TListRep
	var _ /* resultObj at bp+16 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _isobjPtr, dataArray, i, j, proc, resultObj1, tmp, v1, v10, v11, v2, v3, v4, v6, v7, v8, v9
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp1, int64(1), objv, __ccgo_ts+2860)
		return int32(TCL_ERROR)
	}
	/*
	 *  Handle AbstractList special case - do not shimmer into a list, if it
	 *  supports a private Reverse function, just to reverse it.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+72) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+72) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr)).Fversion) {
		v1 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr)).FreverseProc
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	if v1 != 0 {
		v2 = *(*uintptr)(unsafe.Pointer(objv + 1*8))
		if (*TTcl_Obj)(unsafe.Pointer(v2)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+72) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+72) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v2)).FtypePtr)).Fversion) {
			v3 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v2)).FtypePtr)).FreverseProc
		} else {
			v3 = libc.UintptrFromInt32(0)
		}
		proc = v3
		v4 = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{proc})))(tls, interp1, v2, bp+16)
		goto _5
	_5:
		if v4 == TCL_OK {
			XTcl_SetObjResult(tls, interp1, *(*uintptr)(unsafe.Pointer(bp + 16)))
			return TCL_OK
		}
	} /* end Abstract List */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
			v7 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanLength
		} else {
			v7 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v7
		v6 = libc.Int32FromInt32(TCL_OK)
	} else {
		v6 = XTcl_ListObjLength(tls, interp1, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+8)
	}
	if v6 != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * If the list is empty, just return it. [Bug 1876793]
	 */
	if !(*(*TTcl_Size)(unsafe.Pointer(bp + 8)) != 0) {
		XTcl_SetObjResult(tls, interp1, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
		return TCL_OK
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
			v9 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanStart
		} else {
			v9 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1 + 40 + uintptr(v9)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
			v10 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanLength
		} else {
			v10 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v10
		v8 = libc.Int32FromInt32(TCL_OK)
	} else {
		v8 = XTcl_ListObjGetElements(tls, interp1, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+8, bp)
	}
	if v8 != TCL_OK {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FrefCount > int64(1) || (*TListStore)(unsafe.Pointer((*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FrefCount > uint64(1) {
		resultObj1 = XTcl_NewListObj(tls, *(*TTcl_Size)(unsafe.Pointer(bp + 8)), libc.UintptrFromInt32(0))
		/* Modify the internal rep in-place */
		(*TListRep)(unsafe.Pointer(bp + 24)).FstorePtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj1 + 32))).Fptr1
		(*TListRep)(unsafe.Pointer(bp + 24)).FspanPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj1 + 32))).Fptr2
		(*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp + 24))).FstorePtr)).FnumUsed = *(*TTcl_Size)(unsafe.Pointer(bp + 8))
		if (*TListRep)(unsafe.Pointer(bp+24)).FspanPtr != 0 {
			v11 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp + 24)).FspanPtr)).FspanStart
		} else {
			v11 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp + 24)).FstorePtr)).FfirstUsed
		}
		dataArray = (*TListRep)(unsafe.Pointer(bp+24)).FstorePtr + 40 + uintptr(v11)*8
		if (*(*TListRep)(unsafe.Pointer(bp + 24))).FspanPtr != 0 {
			/* Future proofing */
			(*TListSpan)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp + 24))).FspanPtr)).FspanStart = (*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp + 24))).FstorePtr)).FfirstUsed
			(*TListSpan)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp + 24))).FspanPtr)).FspanLength = (*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp + 24))).FstorePtr)).FnumUsed
		}
		i = 0
		j = *(*TTcl_Size)(unsafe.Pointer(bp + 8)) - libc.Int64FromInt32(1)
		for {
			if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) {
				break
			}
			*(*uintptr)(unsafe.Pointer(dataArray + uintptr(j)*8)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(i)*8))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(i)*8)))).FrefCount++
			goto _12
		_12:
			;
			i++
			j--
		}
		XTcl_SetObjResult(tls, interp1, resultObj1)
	} else {
		/*
		 * Not shared, so swap "in place". This relies on Tcl_LOGE above
		 * returning a pointer to the live array of Tcl_Obj values.
		 */
		i = 0
		j = *(*TTcl_Size)(unsafe.Pointer(bp + 8)) - libc.Int64FromInt32(1)
		for {
			if !(i < j) {
				break
			}
			tmp = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(i)*8))
			*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(i)*8)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(j)*8))
			*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(j)*8)) = tmp
			goto _13
		_13:
			;
			i++
			j--
		}
		_isobjPtr = *(*uintptr)(unsafe.Pointer(objv + 1*8))
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
		}
		XTcl_SetObjResult(tls, interp1, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LsearchObjCmd --
 *
 *	This procedure is invoked to process the "lsearch" Tcl command. See
 *	the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LsearchObjCmd(tls *libc.TLS, dummy3258 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(224)
	defer tls.Free(224) /* Argument values. */
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, _objPtr6, _objPtr7, bytes, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, elObj, elObj1, elObj2, itemPtr, listPtr, patObj, patternBytes, startPtr, v18, v26, v27, v29, v3, v30, v31, v34, v36, v38, v39, v40, v43, v45, v46, v48, v50, v51, v53, v54, v56, v57, v59, v63, v65, v70, v72, v74, v9 uintptr
	var allMatches, allocatedIndexVector, bisect, dataType, inlineReturn, isIncreasing, match, mode, negatedMatch, noCase, result, returnSubindices, v10, v11, v12, v16, v19, v32, v4, v41, v5 int32
	var elValue, elValue1 Tsize_t
	var groupOffset, i, index, j, j1, j2, lower, upper, v2, v28, v35, v37, v42, v44, v47, v49, v52, v55, v58, v64, v71, v73 TTcl_Size
	var groupSize TTcl_WideInt
	var regexp TTcl_RegExp
	var strCmpFn TSortStrCmpFn_t
	var v13, v14, v21, v22, v24, v25, v6, v7 int64
	var v17, v60, v62, v66, v68, v69 bool
	var _ /* elemLen at bp+16 */ TTcl_Size
	var _ /* encoded at bp+160 */ int32
	var _ /* idx at bp+144 */ int32
	var _ /* indices at bp+152 */ uintptr
	var _ /* length at bp+0 */ TTcl_Size
	var _ /* listc at bp+8 */ TTcl_Size
	var _ /* listv at bp+136 */ uintptr
	var _ /* objDouble at bp+64 */ float64
	var _ /* objWide at bp+40 */ TTcl_WideInt
	var _ /* patDouble at bp+56 */ float64
	var _ /* patWide at bp+32 */ TTcl_WideInt
	var _ /* sortInfo at bp+72 */ TSortInfo
	var _ /* start at bp+24 */ TTcl_Size
	var _ /* wide at bp+48 */ TTcl_WideInt
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, _objPtr6, _objPtr7, allMatches, allocatedIndexVector, bisect, bytes, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, dataType, elObj, elObj1, elObj2, elValue, elValue1, groupOffset, groupSize, i, index, inlineReturn, isIncreasing, itemPtr, j, j1, j2, listPtr, lower, match, mode, negatedMatch, noCase, patObj, patternBytes, regexp, result, returnSubindices, startPtr, strCmpFn, upper, v10, v11, v12, v13, v14, v16, v17, v18, v19, v2, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v62, v63, v64, v65, v66, v68, v69, v7, v70, v71, v72, v73, v74, v9
	result = TCL_OK
	*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	allocatedIndexVector = 0
	itemPtr = libc.UintptrFromInt32(0)
	strCmpFn = __ccgo_fp(XTclUtfCmp)
	regexp = libc.UintptrFromInt32(0)
	mode = 1
	dataType = 0
	isIncreasing = int32(1)
	allMatches = 0
	inlineReturn = 0
	returnSubindices = 0
	negatedMatch = 0
	bisect = 0
	listPtr = libc.UintptrFromInt32(0)
	startPtr = libc.UintptrFromInt32(0)
	groupSize = int64(1)
	groupOffset = 0
	*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = 0
	noCase = 0
	(*(*TSortInfo)(unsafe.Pointer(bp + 72))).FcompareCmdPtr = libc.UintptrFromInt32(0)
	(*(*TSortInfo)(unsafe.Pointer(bp + 72))).FisIncreasing = int32(1)
	(*(*TSortInfo)(unsafe.Pointer(bp + 72))).FsortMode = 0
	(*(*TSortInfo)(unsafe.Pointer(bp + 72))).Finterp = interp
	(*(*TSortInfo)(unsafe.Pointer(bp + 72))).FresultCode = TCL_OK
	(*(*TSortInfo)(unsafe.Pointer(bp + 72))).Findexv = libc.UintptrFromInt32(0)
	(*(*TSortInfo)(unsafe.Pointer(bp + 72))).Findexc = 0
	if objc < int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+17617)
		return int32(TCL_ERROR)
	}
	i = int64(1)
	for {
		if !(i < int64(objc-int32(2))) {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_options3)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+144) != TCL_OK {
			result = int32(TCL_ERROR)
			goto done
		}
		switch *(*int32)(unsafe.Pointer(bp + 144)) {
		case 0: /* -all */
			allMatches = int32(1)
		case 1: /* -ascii */
			dataType = 0
		case 2: /* -bisect */
			mode = 3
			bisect = int32(1)
		case 3: /* -decreasing */
			isIncreasing = 0
			(*(*TSortInfo)(unsafe.Pointer(bp + 72))).FisIncreasing = 0
		case 4: /* -dictionary */
			dataType = 1
		case 5: /* -increasing */
			mode = 0
		case 6: /* -glob */
			mode = 1
		case 7: /* -increasing */
			isIncreasing = int32(1)
			(*(*TSortInfo)(unsafe.Pointer(bp + 72))).FisIncreasing = int32(1)
		case 9: /* -inline */
			inlineReturn = int32(1)
		case 10: /* -integer */
			dataType = 2
		case 11: /* -nocase */
			strCmpFn = __ccgo_fp(XTclUtfCasecmp)
			noCase = int32(1)
		case 12: /* -not */
			negatedMatch = int32(1)
		case 13: /* -real */
			dataType = 3
		case 14: /* -regexp */
			mode = 2
		case 15: /* -sorted */
			mode = 3
		case 18: /* -subindices */
			returnSubindices = int32(1)
		case 16: /* -start */
			/*
			 * If there was a previous -start option, release its saved index
			 * because it will either be replaced or there will be an error.
			 */
			if startPtr != libc.UintptrFromInt32(0) {
				_objPtr1 = startPtr
				v3 = _objPtr1
				v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
				*(*TTcl_Size)(unsafe.Pointer(v3))--
				if v2 <= int64(1) {
					XTclFreeObj(tls, _objPtr1)
				}
				startPtr = libc.UintptrFromInt32(0)
			}
			if i > int64(objc-int32(4)) {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+17650, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+176, __ccgo_ts+2004, __ccgo_ts+16490, __ccgo_ts+17673, libc.UintptrFromInt32(0)))
				result = int32(TCL_ERROR)
				goto done
			}
			i++
			if *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) == *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) {
				/*
				 * Take copy to prevent shimmering problems. Note that it does
				 * not matter if the index obj is also a component of the list
				 * being searched. We only need to copy where the list and the
				 * index are one-and-the-same.
				 */
				startPtr = XTcl_DuplicateObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))
			} else {
				startPtr = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
			}
			(*TTcl_Obj)(unsafe.Pointer(startPtr)).FrefCount++
		case 17: /* -stride */
			if i > int64(objc-int32(4)) {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+17681, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+176, __ccgo_ts+2004, __ccgo_ts+16490, __ccgo_ts+17673, libc.UintptrFromInt32(0)))
				result = int32(TCL_ERROR)
				goto done
			}
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
				*(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).FinternalRep))
				v4 = libc.Int32FromInt32(TCL_OK)
			} else {
				v4 = XTcl_GetWideIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)), bp+48)
			}
			if v4 != TCL_OK {
				result = int32(TCL_ERROR)
				goto done
			}
			if *(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) < int64(1) {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+17732, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+176, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+17765, __ccgo_ts+17773, libc.UintptrFromInt32(0)))
				result = int32(TCL_ERROR)
				goto done
			}
			groupSize = *(*TTcl_WideInt)(unsafe.Pointer(bp + 48))
			i++
		case 8:
			if allocatedIndexVector != 0 {
				XTclStackFree(tls, interp, (*(*TSortInfo)(unsafe.Pointer(bp + 72))).Findexv)
				allocatedIndexVector = 0
			}
			if i > int64(objc-int32(4)) {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+17783, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+176, __ccgo_ts+2004, __ccgo_ts+16490, __ccgo_ts+17673, libc.UintptrFromInt32(0)))
				result = int32(TCL_ERROR)
				goto done
			}
			/*
			 * Store the extracted indices for processing by sublist
			 * extraction. Note that we don't do this using objects because
			 * that has shimmering problems.
			 */
			i++
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) + 32))).Fptr2 != 0 {
					v6 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) + 32))).Fptr2)).FspanStart
				} else {
					v6 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) + 32))).Fptr1)).FfirstUsed
				}
				*(*uintptr)(unsafe.Pointer(bp + 152)) = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) + 32))).Fptr1 + 40 + uintptr(v6)*8
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) + 32))).Fptr2 != 0 {
					v7 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) + 32))).Fptr2)).FspanLength
				} else {
					v7 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp + 72 + 24)) = v7
				v5 = libc.Int32FromInt32(TCL_OK)
			} else {
				v5 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp+72+24, bp+152)
			}
			if v5 != TCL_OK {
				result = int32(TCL_ERROR)
				goto done
			}
			switch (*(*TSortInfo)(unsafe.Pointer(bp + 72))).Findexc {
			case 0:
				(*(*TSortInfo)(unsafe.Pointer(bp + 72))).Findexv = libc.UintptrFromInt32(0)
			case int64(1):
				(*(*TSortInfo)(unsafe.Pointer(bp + 72))).Findexv = bp + 72 + 32
			default:
				(*(*TSortInfo)(unsafe.Pointer(bp + 72))).Findexv = XTclStackAlloc(tls, interp, uint64(4)*libc.Uint64FromInt64((*(*TSortInfo)(unsafe.Pointer(bp + 72))).Findexc))
				allocatedIndexVector = int32(1) /* Cannot use indexc field, as it
				 * might be decreased by 1 later. */
			}
			/*
			 * Fill the array by parsing each index. We don't know whether
			 * their scale is sensible yet, but we at least perform the
			 * syntactic check here.
			 */
			j = 0
			for {
				if !(j < (*(*TSortInfo)(unsafe.Pointer(bp + 72))).Findexc) {
					break
				}
				*(*int32)(unsafe.Pointer(bp + 160)) = 0
				if XTclIndexEncode(tls, interp, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 152)) + uintptr(j)*8)), int32(int64(-libc.Int32FromInt32(1))), int32(int64(-libc.Int32FromInt32(1))), bp+160) != TCL_OK {
					result = int32(TCL_ERROR)
				}
				if *(*int32)(unsafe.Pointer(bp + 160)) == int32(int64(-libc.Int32FromInt32(1))) {
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 152)) + uintptr(j)*8)))).Fbytes != 0 {
						v9 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 152)) + uintptr(j)*8)))).Fbytes
					} else {
						v9 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 152)) + uintptr(j)*8)), libc.UintptrFromInt32(0))
					}
					XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+17830, libc.VaList(bp+176, v9)))
					XTcl_SetErrorCode(tls, interp, libc.VaList(bp+176, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+17278, __ccgo_ts+17284, libc.UintptrFromInt32(0)))
					result = int32(TCL_ERROR)
				}
				if result == int32(TCL_ERROR) {
					XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+17854, libc.VaList(bp+176, j)))
					goto done
				}
				*(*int32)(unsafe.Pointer((*(*TSortInfo)(unsafe.Pointer(bp + 72))).Findexv + uintptr(j)*4)) = *(*int32)(unsafe.Pointer(bp + 160))
				goto _8
			_8:
				;
				j++
			}
			break
		}
		goto _1
	_1:
		;
		i++
	}
	/*
	 * Subindices only make sense if asked for with -index option set.
	 */
	if returnSubindices != 0 && (*(*TSortInfo)(unsafe.Pointer(bp + 72))).Findexc == 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+17891, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+176, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+17765, __ccgo_ts+17940, libc.UintptrFromInt32(0)))
		result = int32(TCL_ERROR)
		goto done
	}
	if bisect != 0 && (allMatches != 0 || negatedMatch != 0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+17955, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+176, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+17765, __ccgo_ts+17940, libc.UintptrFromInt32(0)))
		result = int32(TCL_ERROR)
		goto done
	}
	if mode == 2 {
		/*
		 * We can shimmer regexp/list if listv[i] == pattern, so get the
		 * regexp rep before the list rep. First time round, omit the interp
		 * and hope that the compilation will succeed. If it fails, we'll
		 * recompile in "expensive" mode with a place to put error messages.
		 */
		if noCase != 0 {
			v10 = int32(TCL_REG_NOCASE)
		} else {
			v10 = 0
		}
		regexp = XTcl_GetRegExpFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), libc.Int32FromInt32(TCL_REG_ADVANCED)|libc.Int32FromInt32(TCL_REG_NOSUB)|v10)
		if regexp == libc.UintptrFromInt32(0) {
			/*
			 * Failed to compile the RE. Try again without the TCL_REG_NOSUB
			 * flag in case the RE had sub-expressions in it [Bug 1366683]. If
			 * this fails, an error message will be left in the interpreter.
			 */
			if noCase != 0 {
				v11 = int32(TCL_REG_NOCASE)
			} else {
				v11 = 0
			}
			regexp = XTcl_GetRegExpFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), int32(TCL_REG_ADVANCED)|v11)
		}
		if regexp == libc.UintptrFromInt32(0) {
			result = int32(TCL_ERROR)
			goto done
		}
	}
	/*
	 * Make sure the list argument is a list object and get its length and a
	 * pointer to its array of element pointers.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) + 32))).Fptr2 != 0 {
			v13 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) + 32))).Fptr2)).FspanStart
		} else {
			v13 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 136)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) + 32))).Fptr1 + 40 + uintptr(v13)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) + 32))).Fptr2 != 0 {
			v14 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) + 32))).Fptr2)).FspanLength
		} else {
			v14 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v14
		v12 = libc.Int32FromInt32(TCL_OK)
	} else {
		v12 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)), bp+8, bp+136)
	}
	result = v12
	if result != TCL_OK {
		goto done
	}
	/*
	 * Check for sanity when grouping elements of the overall list together
	 * because of the -stride option. [TIP #351]
	 */
	if groupSize > int64(1) {
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8))%groupSize != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+17999, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+176, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+17765, __ccgo_ts+17773, libc.UintptrFromInt32(0)))
			result = int32(TCL_ERROR)
			goto done
		}
		if (*(*TSortInfo)(unsafe.Pointer(bp + 72))).Findexc > 0 {
			/*
			 * Use the first value in the list supplied to -index as the
			 * offset of the element within each group by which to sort.
			 */
			groupOffset = XTclIndexDecode(tls, *(*int32)(unsafe.Pointer((*(*TSortInfo)(unsafe.Pointer(bp + 72))).Findexv)), groupSize-int64(1))
			if groupOffset < 0 || groupOffset >= groupSize {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+18049, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+176, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+17765, __ccgo_ts+18127, libc.UintptrFromInt32(0)))
				result = int32(TCL_ERROR)
				goto done
			}
			if (*(*TSortInfo)(unsafe.Pointer(bp + 72))).Findexc == int64(1) {
				(*(*TSortInfo)(unsafe.Pointer(bp + 72))).Findexc = 0
				(*(*TSortInfo)(unsafe.Pointer(bp + 72))).Findexv = libc.UintptrFromInt32(0)
			} else {
				(*(*TSortInfo)(unsafe.Pointer(bp + 72))).Findexc--
				i = 0
				for {
					if !(i < (*(*TSortInfo)(unsafe.Pointer(bp + 72))).Findexc) {
						break
					}
					*(*int32)(unsafe.Pointer((*(*TSortInfo)(unsafe.Pointer(bp + 72))).Findexv + uintptr(i)*4)) = *(*int32)(unsafe.Pointer((*(*TSortInfo)(unsafe.Pointer(bp + 72))).Findexv + uintptr(i+int64(1))*4))
					goto _15
				_15:
					;
					i++
				}
			}
		}
	}
	/*
	 * Get the user-specified start offset.
	 */
	if startPtr != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(startPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(startPtr)).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(startPtr)).FinternalRep)) <= *(*TTcl_Size)(unsafe.Pointer(bp + 8))-int64(1) {
			*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(startPtr)).FinternalRep))
			v16 = libc.Int32FromInt32(TCL_OK)
		} else {
			v16 = XTcl_GetIntForIndex(tls, interp, startPtr, *(*TTcl_Size)(unsafe.Pointer(bp + 8))-libc.Int64FromInt32(1), bp+24)
		}
		result = v16
		if result != TCL_OK {
			goto done
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 24)) == int64(-libc.Int32FromInt32(1)) {
			*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = libc.Int64FromInt32(0)
		}
		/*
		 * If the search started past the end of the list, we just return a
		 * "did not match anything at all" result straight away. [Bug 1374778]
		 */
		if *(*TTcl_Size)(unsafe.Pointer(bp + 24)) >= *(*TTcl_Size)(unsafe.Pointer(bp + 8)) {
			if allMatches != 0 || inlineReturn != 0 {
				XTcl_ResetResult(tls, interp)
			} else {
				if v17 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v17 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v17 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
					itemPtr = XTclThreadAllocObj(tls)
				} else {
					itemPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(itemPtr + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(itemPtr)).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer(itemPtr)).Fbytes = libc.UintptrFromInt32(0)
				*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(itemPtr)).FinternalRep)) = int64(-libc.Int32FromInt32(1))
				(*TTcl_Obj)(unsafe.Pointer(itemPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
				XTcl_SetObjResult(tls, interp, itemPtr)
			}
			goto done
		}
		/*
		 * If start points within a group, it points to the start of the group.
		 */
		if groupSize > int64(1) {
			*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = *(*TTcl_Size)(unsafe.Pointer(bp + 24)) - *(*TTcl_Size)(unsafe.Pointer(bp + 24))%groupSize
		}
	}
	patObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8))
	patternBytes = libc.UintptrFromInt32(0)
	if mode == 0 || mode == 3 {
		switch dataType {
		case 0:
			fallthrough
		case 1:
			if (*TTcl_Obj)(unsafe.Pointer(patObj)).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(patObj)).Flength
				v18 = (*TTcl_Obj)(unsafe.Pointer(patObj)).Fbytes
			} else {
				v18 = XTcl_GetStringFromObj(tls, patObj, bp)
			}
			patternBytes = v18
		case 2:
			if (*TTcl_Obj)(unsafe.Pointer(patObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
				*(*TTcl_WideInt)(unsafe.Pointer(bp + 32)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(patObj)).FinternalRep))
				v19 = libc.Int32FromInt32(TCL_OK)
			} else {
				v19 = XTcl_GetWideIntFromObj(tls, interp, patObj, bp+32)
			}
			result = v19
			if result != TCL_OK {
				goto done
			}
			/*
			 * List representation might have been shimmered; restore it. [Bug
			 * 1844789]
			 */
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) + 32))).Fptr2 != 0 {
					v21 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) + 32))).Fptr2)).FspanStart
				} else {
					v21 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) + 32))).Fptr1)).FfirstUsed
				}
				*(*uintptr)(unsafe.Pointer(bp + 136)) = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) + 32))).Fptr1 + 40 + uintptr(v21)*8
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) + 32))).Fptr2 != 0 {
					v22 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) + 32))).Fptr2)).FspanLength
				} else {
					v22 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v22
				_ = libc.Int32FromInt32(TCL_OK)
			} else {
				XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)), bp+8, bp+136)
			}
		case 3:
			result = XTcl_GetDoubleFromObj(tls, interp, patObj, bp+56)
			if result != TCL_OK {
				goto done
			}
			/*
			 * List representation might have been shimmered; restore it. [Bug
			 * 1844789]
			 */
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) + 32))).Fptr2 != 0 {
					v24 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) + 32))).Fptr2)).FspanStart
				} else {
					v24 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) + 32))).Fptr1)).FfirstUsed
				}
				*(*uintptr)(unsafe.Pointer(bp + 136)) = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) + 32))).Fptr1 + 40 + uintptr(v24)*8
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) + 32))).Fptr2 != 0 {
					v25 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) + 32))).Fptr2)).FspanLength
				} else {
					v25 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v25
				_ = libc.Int32FromInt32(TCL_OK)
			} else {
				XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)), bp+8, bp+136)
			}
			break
		}
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(patObj)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(patObj)).Flength
			v26 = (*TTcl_Obj)(unsafe.Pointer(patObj)).Fbytes
		} else {
			v26 = XTcl_GetStringFromObj(tls, patObj, bp)
		}
		patternBytes = v26
	}
	/*
	 * Set default index value to -1, indicating failure; if we find the item
	 * in the course of our search, index will be set to the correct value.
	 */
	index = int64(-int32(1))
	match = 0
	if mode == 3 && !(allMatches != 0) && !(negatedMatch != 0) {
		/*
		 * If the data is sorted, we can do a more intelligent search. Note
		 * that there is no point in being smart when -all was specified; in
		 * that case, we have to look at all items anyway, and there is no
		 * sense in doing this when the match sense is inverted.
		 */
		/*
		 * With -stride, lower, upper and i are kept as multiples of groupSize.
		 */
		lower = *(*TTcl_Size)(unsafe.Pointer(bp + 24)) - groupSize
		upper = *(*TTcl_Size)(unsafe.Pointer(bp + 8))
		itemPtr = libc.UintptrFromInt32(0)
		for lower+groupSize != upper && (*(*TSortInfo)(unsafe.Pointer(bp + 72))).FresultCode == TCL_OK {
			i = (lower + upper) / int64(2)
			i = i - i%groupSize
			v27 = itemPtr
			if v27 != 0 {
				if (*TTcl_Obj)(unsafe.Pointer(v27)).FrefCount == libc.Int64FromInt32(0) {
					_objPtr = v27
					v29 = _objPtr
					v28 = *(*TTcl_Size)(unsafe.Pointer(v29))
					*(*TTcl_Size)(unsafe.Pointer(v29))--
					if v28 <= libc.Int64FromInt32(1) {
						XTclFreeObj(tls, _objPtr)
					}
				}
			}
			itemPtr = libc.UintptrFromInt32(0)
			if (*(*TSortInfo)(unsafe.Pointer(bp + 72))).Findexc != 0 {
				itemPtr = _SelectObjFromSublist(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 136)) + uintptr(i+groupOffset)*8)), bp+72)
				if (*(*TSortInfo)(unsafe.Pointer(bp + 72))).FresultCode != TCL_OK {
					result = (*(*TSortInfo)(unsafe.Pointer(bp + 72))).FresultCode
					goto done
				}
			} else {
				itemPtr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 136)) + uintptr(i+groupOffset)*8))
			}
			switch dataType {
			case 0:
				if (*TTcl_Obj)(unsafe.Pointer(itemPtr)).Fbytes != 0 {
					v30 = (*TTcl_Obj)(unsafe.Pointer(itemPtr)).Fbytes
				} else {
					v30 = XTcl_GetStringFromObj(tls, itemPtr, libc.UintptrFromInt32(0))
				}
				bytes = v30
				match = (*(*func(*libc.TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{strCmpFn})))(tls, patternBytes, bytes)
			case 1:
				if (*TTcl_Obj)(unsafe.Pointer(itemPtr)).Fbytes != 0 {
					v31 = (*TTcl_Obj)(unsafe.Pointer(itemPtr)).Fbytes
				} else {
					v31 = XTcl_GetStringFromObj(tls, itemPtr, libc.UintptrFromInt32(0))
				}
				bytes = v31
				match = _DictionaryCompare(tls, patternBytes, bytes)
			case 2:
				if (*TTcl_Obj)(unsafe.Pointer(itemPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
					*(*TTcl_WideInt)(unsafe.Pointer(bp + 40)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(itemPtr)).FinternalRep))
					v32 = libc.Int32FromInt32(TCL_OK)
				} else {
					v32 = XTcl_GetWideIntFromObj(tls, interp, itemPtr, bp+40)
				}
				result = v32
				if result != TCL_OK {
					goto done
				}
				if *(*TTcl_WideInt)(unsafe.Pointer(bp + 32)) == *(*TTcl_WideInt)(unsafe.Pointer(bp + 40)) {
					match = 0
				} else {
					if *(*TTcl_WideInt)(unsafe.Pointer(bp + 32)) < *(*TTcl_WideInt)(unsafe.Pointer(bp + 40)) {
						match = -int32(1)
					} else {
						match = int32(1)
					}
				}
			case 3:
				result = XTcl_GetDoubleFromObj(tls, interp, itemPtr, bp+64)
				if result != TCL_OK {
					goto done
				}
				if *(*float64)(unsafe.Pointer(bp + 56)) == *(*float64)(unsafe.Pointer(bp + 64)) {
					match = 0
				} else {
					if *(*float64)(unsafe.Pointer(bp + 56)) < *(*float64)(unsafe.Pointer(bp + 64)) {
						match = -int32(1)
					} else {
						match = int32(1)
					}
				}
				break
			}
			if match == 0 {
				/*
				 * Normally, binary search is written to stop when it finds a
				 * match. If there are duplicates of an element in the list,
				 * our first match might not be the first occurrence.
				 * Consider: 0 0 0 1 1 1 2 2 2
				 *
				 * To maintain consistency with standard lsearch semantics, we
				 * must find the leftmost occurrence of the pattern in the
				 * list. Thus we don't just stop searching here. This
				 * variation means that a search always makes log n
				 * comparisons (normal binary search might "get lucky" with an
				 * early comparison).
				 *
				 * In bisect mode though, we want the last of equals.
				 */
				index = i
				if bisect != 0 {
					lower = i
				} else {
					upper = i
				}
			} else {
				if match > 0 {
					if isIncreasing != 0 {
						lower = i
					} else {
						upper = i
					}
				} else {
					if isIncreasing != 0 {
						upper = i
					} else {
						lower = i
					}
				}
			}
		}
		if bisect != 0 && index < 0 {
			index = lower
		}
	} else {
		/*
		 * We need to do a linear search, because (at least one) of:
		 *   - our matcher can only tell equal vs. not equal
		 *   - our matching sense is negated
		 *   - we're building a list of all matched items
		 */
		if allMatches != 0 {
			listPtr = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
		}
		i = *(*TTcl_Size)(unsafe.Pointer(bp + 24))
		for {
			if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) {
				break
			}
			match = 0
			v34 = itemPtr
			if v34 != 0 {
				if (*TTcl_Obj)(unsafe.Pointer(v34)).FrefCount == libc.Int64FromInt32(0) {
					_objPtr = v34
					v36 = _objPtr
					v35 = *(*TTcl_Size)(unsafe.Pointer(v36))
					*(*TTcl_Size)(unsafe.Pointer(v36))--
					if v35 <= libc.Int64FromInt32(1) {
						XTclFreeObj(tls, _objPtr)
					}
				}
			}
			itemPtr = libc.UintptrFromInt32(0)
			if (*(*TSortInfo)(unsafe.Pointer(bp + 72))).Findexc != 0 {
				itemPtr = _SelectObjFromSublist(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 136)) + uintptr(i+groupOffset)*8)), bp+72)
				if (*(*TSortInfo)(unsafe.Pointer(bp + 72))).FresultCode != TCL_OK {
					if listPtr != libc.UintptrFromInt32(0) {
						_objPtr2 = listPtr
						v38 = _objPtr2
						v37 = *(*TTcl_Size)(unsafe.Pointer(v38))
						*(*TTcl_Size)(unsafe.Pointer(v38))--
						if v37 <= int64(1) {
							XTclFreeObj(tls, _objPtr2)
						}
					}
					result = (*(*TSortInfo)(unsafe.Pointer(bp + 72))).FresultCode
					goto done
				}
			} else {
				itemPtr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 136)) + uintptr(i+groupOffset)*8))
			}
			switch mode {
			case 3:
				fallthrough
			case 0:
				switch dataType {
				case 0:
					if (*TTcl_Obj)(unsafe.Pointer(itemPtr)).Fbytes != 0 {
						*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = (*TTcl_Obj)(unsafe.Pointer(itemPtr)).Flength
						v39 = (*TTcl_Obj)(unsafe.Pointer(itemPtr)).Fbytes
					} else {
						v39 = XTcl_GetStringFromObj(tls, itemPtr, bp+16)
					}
					bytes = v39
					if *(*TTcl_Size)(unsafe.Pointer(bp)) == *(*TTcl_Size)(unsafe.Pointer(bp + 16)) {
						/*
						 * This split allows for more optimal compilation of
						 * memcmp/strcasecmp.
						 */
						if noCase != 0 {
							match = libc.BoolInt32(XTclUtfCasecmp(tls, bytes, patternBytes) == 0)
						} else {
							match = libc.BoolInt32(libc.Xmemcmp(tls, bytes, patternBytes, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))) == 0)
						}
					}
				case 1:
					if (*TTcl_Obj)(unsafe.Pointer(itemPtr)).Fbytes != 0 {
						v40 = (*TTcl_Obj)(unsafe.Pointer(itemPtr)).Fbytes
					} else {
						v40 = XTcl_GetStringFromObj(tls, itemPtr, libc.UintptrFromInt32(0))
					}
					bytes = v40
					match = libc.BoolInt32(_DictionaryCompare(tls, bytes, patternBytes) == 0)
				case 2:
					if (*TTcl_Obj)(unsafe.Pointer(itemPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
						*(*TTcl_WideInt)(unsafe.Pointer(bp + 40)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(itemPtr)).FinternalRep))
						v41 = libc.Int32FromInt32(TCL_OK)
					} else {
						v41 = XTcl_GetWideIntFromObj(tls, interp, itemPtr, bp+40)
					}
					result = v41
					if result != TCL_OK {
						if listPtr != libc.UintptrFromInt32(0) {
							_objPtr3 = listPtr
							v43 = _objPtr3
							v42 = *(*TTcl_Size)(unsafe.Pointer(v43))
							*(*TTcl_Size)(unsafe.Pointer(v43))--
							if v42 <= int64(1) {
								XTclFreeObj(tls, _objPtr3)
							}
						}
						goto done
					}
					match = libc.BoolInt32(*(*TTcl_WideInt)(unsafe.Pointer(bp + 40)) == *(*TTcl_WideInt)(unsafe.Pointer(bp + 32)))
				case 3:
					result = XTcl_GetDoubleFromObj(tls, interp, itemPtr, bp+64)
					if result != TCL_OK {
						if listPtr != 0 {
							_objPtr4 = listPtr
							v45 = _objPtr4
							v44 = *(*TTcl_Size)(unsafe.Pointer(v45))
							*(*TTcl_Size)(unsafe.Pointer(v45))--
							if v44 <= int64(1) {
								XTclFreeObj(tls, _objPtr4)
							}
						}
						goto done
					}
					match = libc.BoolInt32(*(*float64)(unsafe.Pointer(bp + 64)) == *(*float64)(unsafe.Pointer(bp + 56)))
					break
				}
			case 1:
				if (*TTcl_Obj)(unsafe.Pointer(itemPtr)).Fbytes != 0 {
					v46 = (*TTcl_Obj)(unsafe.Pointer(itemPtr)).Fbytes
				} else {
					v46 = XTcl_GetStringFromObj(tls, itemPtr, libc.UintptrFromInt32(0))
				}
				match = XTcl_StringCaseMatch(tls, v46, patternBytes, noCase)
			case 2:
				match = XTcl_RegExpExecObj(tls, interp, regexp, itemPtr, 0, 0, 0)
				if match < 0 {
					_objPtr5 = patObj
					v48 = _objPtr5
					v47 = *(*TTcl_Size)(unsafe.Pointer(v48))
					*(*TTcl_Size)(unsafe.Pointer(v48))--
					if v47 <= int64(1) {
						XTclFreeObj(tls, _objPtr5)
					}
					if listPtr != libc.UintptrFromInt32(0) {
						_objPtr6 = listPtr
						v50 = _objPtr6
						v49 = *(*TTcl_Size)(unsafe.Pointer(v50))
						*(*TTcl_Size)(unsafe.Pointer(v50))--
						if v49 <= int64(1) {
							XTclFreeObj(tls, _objPtr6)
						}
					}
					result = int32(TCL_ERROR)
					goto done
				}
				break
			}
			/*
			 * Invert match condition for -not.
			 */
			if negatedMatch != 0 {
				match = libc.BoolInt32(!(match != 0))
			}
			if !(match != 0) {
				goto _33
			}
			if !(allMatches != 0) {
				index = i
				break
			} else {
				if inlineReturn != 0 {
					/*
					 * Note that these appends are not expected to fail.
					 */
					if returnSubindices != 0 && (*(*TSortInfo)(unsafe.Pointer(bp + 72))).Findexc != 0 {
						v51 = itemPtr
						if v51 != 0 {
							if (*TTcl_Obj)(unsafe.Pointer(v51)).FrefCount == libc.Int64FromInt32(0) {
								_objPtr = v51
								v53 = _objPtr
								v52 = *(*TTcl_Size)(unsafe.Pointer(v53))
								*(*TTcl_Size)(unsafe.Pointer(v53))--
								if v52 <= libc.Int64FromInt32(1) {
									XTclFreeObj(tls, _objPtr)
								}
							}
						}
						itemPtr = _SelectObjFromSublist(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 136)) + uintptr(i+groupOffset)*8)), bp+72)
						XTcl_ListObjAppendElement(tls, interp, listPtr, itemPtr)
					} else {
						if returnSubindices != 0 && (*(*TSortInfo)(unsafe.Pointer(bp + 72))).Findexc == 0 && groupSize > int64(1) {
							v54 = itemPtr
							if v54 != 0 {
								if (*TTcl_Obj)(unsafe.Pointer(v54)).FrefCount == libc.Int64FromInt32(0) {
									_objPtr = v54
									v56 = _objPtr
									v55 = *(*TTcl_Size)(unsafe.Pointer(v56))
									*(*TTcl_Size)(unsafe.Pointer(v56))--
									if v55 <= libc.Int64FromInt32(1) {
										XTclFreeObj(tls, _objPtr)
									}
								}
							}
							itemPtr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 136)) + uintptr(i+groupOffset)*8))
							XTcl_ListObjAppendElement(tls, interp, listPtr, itemPtr)
						} else {
							if groupSize > int64(1) {
								XTcl_ListObjReplace(tls, interp, listPtr, libc.Int64FromUint64((libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))-uint64(libc.UintptrFromInt32(0)+40))/libc.Uint64FromInt64(8)), 0, groupSize, *(*uintptr)(unsafe.Pointer(bp + 136))+uintptr(i)*8)
							} else {
								v57 = itemPtr
								if v57 != 0 {
									if (*TTcl_Obj)(unsafe.Pointer(v57)).FrefCount == libc.Int64FromInt32(0) {
										_objPtr = v57
										v59 = _objPtr
										v58 = *(*TTcl_Size)(unsafe.Pointer(v59))
										*(*TTcl_Size)(unsafe.Pointer(v59))--
										if v58 <= libc.Int64FromInt32(1) {
											XTclFreeObj(tls, _objPtr)
										}
									}
								}
								itemPtr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 136)) + uintptr(i)*8))
								XTcl_ListObjAppendElement(tls, interp, listPtr, itemPtr)
							}
						}
					}
				} else {
					if returnSubindices != 0 {
						if v60 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v60 {
							cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v60 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
							itemPtr = XTclThreadAllocObj(tls)
						} else {
							itemPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(itemPtr + 32))).Fptr1
							(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
						}
						(*TTcl_Obj)(unsafe.Pointer(itemPtr)).FrefCount = 0
						(*TTcl_Obj)(unsafe.Pointer(itemPtr)).Fbytes = libc.UintptrFromInt32(0)
						*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(itemPtr)).FinternalRep)) = i + groupOffset
						(*TTcl_Obj)(unsafe.Pointer(itemPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
						j1 = 0
						for {
							if !(j1 < (*(*TSortInfo)(unsafe.Pointer(bp + 72))).Findexc) {
								break
							}
							elValue = libc.Uint64FromInt64(XTclIndexDecode(tls, *(*int32)(unsafe.Pointer((*(*TSortInfo)(unsafe.Pointer(bp + 72))).Findexv + uintptr(j1)*4)), *(*TTcl_Size)(unsafe.Pointer(bp + 8))))
							if v62 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v62 {
								cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
							}
							if v62 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
								elObj = XTclThreadAllocObj(tls)
							} else {
								elObj = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
								(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer(elObj + 32))).Fptr1
								(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
							}
							(*TTcl_Obj)(unsafe.Pointer(elObj)).FrefCount = 0
							(*TTcl_Obj)(unsafe.Pointer(elObj)).Fbytes = libc.UintptrFromInt32(0)
							*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(elObj)).FinternalRep)) = libc.Int64FromUint64(elValue)
							(*TTcl_Obj)(unsafe.Pointer(elObj)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
							XTcl_ListObjAppendElement(tls, interp, itemPtr, elObj)
							goto _61
						_61:
							;
							j1++
						}
						XTcl_ListObjAppendElement(tls, interp, listPtr, itemPtr)
					} else {
						XTcl_ListObjAppendElement(tls, interp, listPtr, XTcl_NewWideIntObj(tls, i))
					}
				}
			}
			goto _33
		_33:
			;
			i = i + groupSize
		}
	}
	v63 = itemPtr
	if v63 != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(v63)).FrefCount == libc.Int64FromInt32(0) {
			_objPtr = v63
			v65 = _objPtr
			v64 = *(*TTcl_Size)(unsafe.Pointer(v65))
			*(*TTcl_Size)(unsafe.Pointer(v65))--
			if v64 <= libc.Int64FromInt32(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
	}
	itemPtr = libc.UintptrFromInt32(0)
	/*
	 * Return everything or a single value.
	 */
	if allMatches != 0 {
		XTcl_SetObjResult(tls, interp, listPtr)
	} else {
		if !(inlineReturn != 0) {
			if returnSubindices != 0 {
				if v66 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v66 {
					cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v66 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
					itemPtr = XTclThreadAllocObj(tls)
				} else {
					itemPtr = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(itemPtr + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(itemPtr)).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer(itemPtr)).Fbytes = libc.UintptrFromInt32(0)
				*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(itemPtr)).FinternalRep)) = index + groupOffset
				(*TTcl_Obj)(unsafe.Pointer(itemPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
				j2 = 0
				for {
					if !(j2 < (*(*TSortInfo)(unsafe.Pointer(bp + 72))).Findexc) {
						break
					}
					elValue1 = libc.Uint64FromInt64(XTclIndexDecode(tls, *(*int32)(unsafe.Pointer((*(*TSortInfo)(unsafe.Pointer(bp + 72))).Findexv + uintptr(j2)*4)), *(*TTcl_Size)(unsafe.Pointer(bp + 8))))
					if v68 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v68 {
						cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v68 || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == libc.Uint64FromInt32(0) {
						elObj1 = XTclThreadAllocObj(tls)
					} else {
						elObj1 = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(elObj1 + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer(elObj1)).FrefCount = 0
					(*TTcl_Obj)(unsafe.Pointer(elObj1)).Fbytes = libc.UintptrFromInt32(0)
					*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(elObj1)).FinternalRep)) = libc.Int64FromUint64(elValue1)
					(*TTcl_Obj)(unsafe.Pointer(elObj1)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
					XTcl_ListObjAppendElement(tls, interp, itemPtr, elObj1)
					goto _67
				_67:
					;
					j2++
				}
				XTcl_SetObjResult(tls, interp, itemPtr)
			} else {
				if v69 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v69 {
					cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v69 || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == libc.Uint64FromInt32(0) {
					elObj2 = XTclThreadAllocObj(tls)
				} else {
					elObj2 = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(elObj2 + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(elObj2)).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer(elObj2)).Fbytes = libc.UintptrFromInt32(0)
				*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(elObj2)).FinternalRep)) = index
				(*TTcl_Obj)(unsafe.Pointer(elObj2)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
				XTcl_SetObjResult(tls, interp, elObj2)
			}
		} else {
			if index < 0 {
				/*
				 * Is this superfluous? The result should be a blank object by
				 * default...
				 */
				XTcl_SetObjResult(tls, interp, XTcl_NewObj(tls))
			} else {
				if returnSubindices != 0 {
					XTcl_SetObjResult(tls, interp, _SelectObjFromSublist(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 136)) + uintptr(i+groupOffset)*8)), bp+72))
				} else {
					if groupSize > int64(1) {
						XTcl_SetObjResult(tls, interp, XTcl_NewListObj(tls, groupSize, *(*uintptr)(unsafe.Pointer(bp + 136))+uintptr(index)*8))
					} else {
						XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 136)) + uintptr(index)*8)))
					}
				}
			}
		}
	}
	result = TCL_OK
	/*
	 * Cleanup the index list array.
	 */
	goto done
done:
	;
	/* potential lingering abstract list element */
	v70 = itemPtr
	if v70 != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(v70)).FrefCount == libc.Int64FromInt32(0) {
			_objPtr = v70
			v72 = _objPtr
			v71 = *(*TTcl_Size)(unsafe.Pointer(v72))
			*(*TTcl_Size)(unsafe.Pointer(v72))--
			if v71 <= libc.Int64FromInt32(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
	}
	if startPtr != libc.UintptrFromInt32(0) {
		_objPtr7 = startPtr
		v74 = _objPtr7
		v73 = *(*TTcl_Size)(unsafe.Pointer(v74))
		*(*TTcl_Size)(unsafe.Pointer(v74))--
		if v73 <= int64(1) {
			XTclFreeObj(tls, _objPtr7)
		}
	}
	if allocatedIndexVector != 0 {
		XTclStackFree(tls, interp, (*(*TSortInfo)(unsafe.Pointer(bp + 72))).Findexv)
	}
	return result
}

var _options3 = [20]uintptr{
	0:  __ccgo_ts + 17462,
	1:  __ccgo_ts + 17467,
	2:  __ccgo_ts + 17474,
	3:  __ccgo_ts + 17482,
	4:  __ccgo_ts + 17494,
	5:  __ccgo_ts + 17506,
	6:  __ccgo_ts + 17513,
	7:  __ccgo_ts + 17519,
	8:  __ccgo_ts + 17531,
	9:  __ccgo_ts + 17538,
	10: __ccgo_ts + 17546,
	11: __ccgo_ts + 17555,
	12: __ccgo_ts + 17563,
	13: __ccgo_ts + 17568,
	14: __ccgo_ts + 17574,
	15: __ccgo_ts + 17582,
	16: __ccgo_ts + 17590,
	17: __ccgo_ts + 17597,
	18: __ccgo_ts + 17605,
	19: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * SequenceIdentifyArgument --
 *   (for [lseq] command)
 *
 *  Given a Tcl_Obj, identify if it is a keyword or a number
 *
 *  Return Value
 *    0 - failure, unexpected value
 *    1 - value is a number
 *    2 - value is an operand keyword
 *    3 - value is a by keyword
 *
 *  The decoded value will be assigned to the appropriate
 *  pointer, numValuePtr reference count is incremented.
 */

func _SequenceIdentifyArgument(tls *libc.TLS, interp uintptr, argPtr uintptr, allowedArgs int32, numValuePtr uintptr, keywordIndexPtr uintptr) (r TSequenceDecoded) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Return keyword enum  */
	var result int32
	var v3 uintptr
	var _ /* exprValueObj at bp+16 */ uintptr
	var _ /* internalPtr at bp+8 */ uintptr
	var _ /* keyword at bp+24 */ int32
	var _ /* opmode at bp+0 */ TSequenceOperators
	_, _ = result, v3
	result = int32(TCL_ERROR)
	if allowedArgs&int32(NumericArg) != 0 {
		/* speed-up a bit (and avoid shimmer for compiled expressions) */
		if (*TTcl_Obj)(unsafe.Pointer(argPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclExprCodeType)) {
			goto doExpr
		}
		result = XTcl_GetNumberFromObj(tls, libc.UintptrFromInt32(0), argPtr, bp+8, keywordIndexPtr)
		if result == TCL_OK {
			*(*uintptr)(unsafe.Pointer(numValuePtr)) = argPtr
			(*TTcl_Obj)(unsafe.Pointer(argPtr)).FrefCount++
			return int32(NumericArg)
		}
	}
	if allowedArgs&int32(RangeKeywordArg) != 0 {
		result = XTcl_GetIndexFromObjStruct(tls, libc.UintptrFromInt32(0), argPtr, uintptr(unsafe.Pointer(&_seq_operations)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+18136, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp)
	}
	if !(result == TCL_OK) {
		goto _1
	}
	if allowedArgs&int32(LastArg) != 0 {
		/* keyword found, but no followed number */
		if (*TTcl_Obj)(unsafe.Pointer(argPtr)).Fbytes != 0 {
			v3 = (*TTcl_Obj)(unsafe.Pointer(argPtr)).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, argPtr, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+18152, libc.VaList(bp+40, v3)))
		return int32(ErrArg)
	}
	*(*int32)(unsafe.Pointer(keywordIndexPtr)) = *(*TSequenceOperators)(unsafe.Pointer(bp))
	return int32(RangeKeywordArg)
	goto _2
_1:
	;
	if !(allowedArgs&int32(NumericArg) != 0) {
		return int32(NoneArg)
	}
	goto doExpr
doExpr:
	;
	/* Check for an index expression */
	if XTcl_ExprObj(tls, interp, argPtr, bp+16) != TCL_OK {
		return int32(ErrArg)
	}
	/* Determine if result of expression is double or int */
	if XTcl_GetNumberFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 16)), bp+8, bp+24) != TCL_OK {
		return int32(ErrArg)
	}
	*(*uintptr)(unsafe.Pointer(numValuePtr)) = *(*uintptr)(unsafe.Pointer(bp + 16)) /* incremented in Tcl_ExprObj */
	*(*int32)(unsafe.Pointer(keywordIndexPtr)) = *(*int32)(unsafe.Pointer(bp + 24)) /* type of expression result */
	return int32(NumericArg)
_2:
	;
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LseqObjCmd --
 *
 *	This procedure is invoked to process the "lseq" Tcl command.
 *	See the user documentation for details on what it does.
 *
 * Enumerated possible argument patterns:
 *
 * 1:
 *    lseq n
 * 2:
 *    lseq n n
 * 3:
 *    lseq n n n
 *    lseq n 'to' n
 *    lseq n 'count' n
 *    lseq n 'by' n
 * 4:
 *    lseq n 'to' n n
 *    lseq n n 'by' n
 *    lseq n 'count' n n
 * 5:
 *    lseq n 'to' n 'by' n
 *    lseq n 'count' n 'by' n
 *
 * Results:
 *	A standard Tcl object result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LseqObjCmd(tls *libc.TLS, dummy4136 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* The argument objects. */
	var _objPtr, _objPtr1, arithSeriesPtr, elementCount, end, start, step, v16, v18 uintptr
	var allowedArgs, arg_key, i, remNums, status, useDoubles, value_i, v13, v14, v2, v3 int32
	var decoded TSequenceDecoded
	var numValues [5]uintptr
	var values [5]TTcl_WideInt
	var v15, v17 TTcl_Size
	var _ /* big at bp+24 */ Tmp_int
	var _ /* d at bp+16 */ float64
	var _ /* keyword at bp+8 */ int32
	var _ /* numberObj at bp+0 */ uintptr
	var _ /* opmode at bp+12 */ TSequenceOperators
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, allowedArgs, arg_key, arithSeriesPtr, decoded, elementCount, end, i, numValues, remNums, start, status, step, useDoubles, value_i, values, v13, v14, v15, v16, v17, v18, v2, v3
	elementCount = libc.UintptrFromInt32(0)
	start = libc.UintptrFromInt32(0)
	end = libc.UintptrFromInt32(0)
	step = libc.UintptrFromInt32(0)
	status = int32(TCL_ERROR)
	allowedArgs = int32(NumericArg)
	useDoubles = 0
	remNums = int32(3)
	arg_key = 0
	value_i = 0
	/* Default constants */
	/*
	 * Create a decoding key by looping through the arguments and identify
	 * what kind of argument each one is.  Encode each argument as a decimal
	 * digit.
	 */
	if objc > int32(6) {
		/* Too many arguments */
		goto syntax
	}
	i = int32(1)
	for {
		if !(i < objc) {
			break
		}
		arg_key = arg_key * int32(10)
		numValues[value_i] = libc.UintptrFromInt32(0)
		if i == objc-int32(1) {
			v2 = int32(LastArg)
		} else {
			v2 = 0
		}
		decoded = _SequenceIdentifyArgument(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), allowedArgs|v2, bp, bp+8)
		switch decoded {
		case int32(NoneArg):
			/*
			 * Unrecognizable argument
			 * Reproduce operation error message
			 */
			status = XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_seq_operations)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+18172, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+12)
			goto done
		case int32(NumericArg):
			remNums--
			arg_key += int32(NumericArg)
			allowedArgs = int32(RangeKeywordArg)
			/* if last number but 2 arguments remain, next is not numeric */
			if remNums != int32(1) || objc-int32(1)-i != int32(2) {
				allowedArgs |= int32(NumericArg)
			}
			numValues[value_i] = *(*uintptr)(unsafe.Pointer(bp))
			values[value_i] = int64(*(*int32)(unsafe.Pointer(bp + 8))) /* TCL_NUMBER_* */
			if *(*int32)(unsafe.Pointer(bp + 8)) == int32(TCL_NUMBER_DOUBLE) {
				v3 = int32(1)
			} else {
				v3 = 0
			}
			useDoubles += v3
			value_i++
		case int32(RangeKeywordArg):
			arg_key += int32(RangeKeywordArg)
			allowedArgs = int32(NumericArg)                            /* after keyword always numeric only */
			values[value_i] = int64(*(*int32)(unsafe.Pointer(bp + 8))) /* SequenceOperators */
			value_i++
		default: /* Error state */
			status = int32(TCL_ERROR)
			goto done
		}
		goto _1
	_1:
		;
		i++
	}
	/*
	 * The key encoding defines a valid set of arguments, or indicates an
	 * error condition; process the values accordningly.
	 */
	switch arg_key {
	case int32(1):
		goto _4
	case int32(11):
		goto _5
	case int32(111):
		goto _6
	case int32(121):
		goto _7
	case int32(1211):
		goto _8
	case int32(1121):
		goto _9
	case int32(12121):
		goto _10
	default:
		goto _11
	}
	goto _12
	/*    lseq n */
_4:
	;
	start = *(*uintptr)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr + 8))
	elementCount = numValues[0]
	end = libc.UintptrFromInt32(0)
	step = *(*uintptr)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr + 8 + 1*8))
	useDoubles = 0 // Can only have Integer value. If a fractional value
	// is given, this will fail later. In other words,
	// "3.0" is allowed and used as Integer, but "3.1"
	// will be flagged as an error. (bug f4a4bd7f1070)
	goto _12
	/*    lseq n n */
_5:
	;
	start = numValues[0]
	end = numValues[int32(1)]
	goto _12
	/*    lseq n n n */
_6:
	;
	start = numValues[0]
	end = numValues[int32(1)]
	step = numValues[int32(2)]
	goto _12
	/*    lseq n 'to' n    */
	/*    lseq n 'count' n */
	/*    lseq n 'by' n    */
_7:
	;
	*(*TSequenceOperators)(unsafe.Pointer(bp + 12)) = int32(values[int32(1)])
	switch *(*TSequenceOperators)(unsafe.Pointer(bp + 12)) {
	case int32(LSEQ_DOTS):
		fallthrough
	case int32(LSEQ_TO):
		start = numValues[0]
		end = numValues[int32(2)]
	case int32(LSEQ_BY):
		start = *(*uintptr)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr + 8))
		elementCount = numValues[0]
		step = numValues[int32(2)]
	case int32(LSEQ_COUNT):
		start = numValues[0]
		elementCount = numValues[int32(2)]
		step = *(*uintptr)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr + 8 + 1*8))
	default:
		goto done
	}
	goto _12
	/*    lseq n 'to' n n    */
	/*    lseq n 'count' n n */
_8:
	;
	*(*TSequenceOperators)(unsafe.Pointer(bp + 12)) = int32(values[int32(1)])
	switch *(*TSequenceOperators)(unsafe.Pointer(bp + 12)) {
	case int32(LSEQ_DOTS):
		fallthrough
	case int32(LSEQ_TO):
		start = numValues[0]
		end = numValues[int32(2)]
		step = numValues[int32(3)]
	case int32(LSEQ_COUNT):
		start = numValues[0]
		elementCount = numValues[int32(2)]
		step = numValues[int32(3)]
	case int32(LSEQ_BY):
		/* Error case */
		goto done
	default:
		goto done
		break
	}
	goto _12
	/*    lseq n n 'by' n */
_9:
	;
	start = numValues[0]
	end = numValues[int32(1)]
	*(*TSequenceOperators)(unsafe.Pointer(bp + 12)) = int32(values[int32(2)])
	switch *(*TSequenceOperators)(unsafe.Pointer(bp + 12)) {
	case int32(LSEQ_BY):
		step = numValues[int32(3)]
	case int32(LSEQ_DOTS):
		fallthrough
	case int32(LSEQ_TO):
		fallthrough
	case int32(LSEQ_COUNT):
		fallthrough
	default:
		goto done
		break
	}
	goto _12
	/*    lseq n 'to' n 'by' n    */
	/*    lseq n 'count' n 'by' n */
_10:
	;
	start = numValues[0]
	*(*TSequenceOperators)(unsafe.Pointer(bp + 12)) = int32(values[int32(3)])
	switch *(*TSequenceOperators)(unsafe.Pointer(bp + 12)) {
	case int32(LSEQ_BY):
		step = numValues[int32(4)]
	default:
		goto done
		break
	}
	*(*TSequenceOperators)(unsafe.Pointer(bp + 12)) = int32(values[int32(1)])
	switch *(*TSequenceOperators)(unsafe.Pointer(bp + 12)) {
	case int32(LSEQ_DOTS):
		fallthrough
	case int32(LSEQ_TO):
		start = numValues[0]
		end = numValues[int32(2)]
	case int32(LSEQ_COUNT):
		start = numValues[0]
		elementCount = numValues[int32(2)]
	default:
		goto done
		break
	}
	goto _12
	/*    All other argument errors */
_11:
	;
	goto syntax
syntax:
	;
	XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+18182)
	goto done
	goto _12
_12:
	;
	/* Count needs to be integer, so try to convert if possible */
	if elementCount != 0 && (*TTcl_Obj)(unsafe.Pointer(elementCount)).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
		// Don't consider Count type to indicate using double values in seqence
		if useDoubles > 0 {
			v13 = int32(1)
		} else {
			v13 = 0
		}
		useDoubles -= v13
		XTcl_GetDoubleFromObj(tls, libc.UintptrFromInt32(0), elementCount, bp+16)
		if libc.Xfloor(tls, *(*float64)(unsafe.Pointer(bp + 16))) == *(*float64)(unsafe.Pointer(bp + 16)) {
			if *(*float64)(unsafe.Pointer(bp + 16)) >= float64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) || *(*float64)(unsafe.Pointer(bp + 16)) <= float64(libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))+libc.Uint64FromInt32(1))) {
				if XTcl_InitBignumFromDouble(tls, libc.UintptrFromInt32(0), *(*float64)(unsafe.Pointer(bp + 16)), bp+24) == TCL_OK {
					elementCount = XTcl_NewBignumObj(tls, bp+24)
					*(*int32)(unsafe.Pointer(bp + 8)) = int32(TCL_NUMBER_INT)
				}
				/* Infinity, don't convert, let fail later */
			} else {
				elementCount = XTcl_NewWideIntObj(tls, int64(*(*float64)(unsafe.Pointer(bp + 16))))
				*(*int32)(unsafe.Pointer(bp + 8)) = int32(TCL_NUMBER_INT)
			}
		}
	}
	/*
	 * Success!  Now lets create the series object.
	 */
	arithSeriesPtr = XTclNewArithSeriesObj(tls, interp, useDoubles, start, end, step, elementCount)
	status = int32(TCL_ERROR)
	if arithSeriesPtr != 0 {
		status = TCL_OK
		XTcl_SetObjResult(tls, interp, arithSeriesPtr)
	}
	goto done
done:
	;
	// Free number arguments.
	for {
		value_i--
		v14 = value_i
		if !(v14 >= 0) {
			break
		}
		if numValues[value_i] != 0 {
			if elementCount == numValues[value_i] {
				elementCount = libc.UintptrFromInt32(0)
			}
			_objPtr = numValues[value_i]
			v16 = _objPtr
			v15 = *(*TTcl_Size)(unsafe.Pointer(v16))
			*(*TTcl_Size)(unsafe.Pointer(v16))--
			if v15 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
	}
	if elementCount != 0 {
		_objPtr1 = elementCount
		v18 = _objPtr1
		v17 = *(*TTcl_Size)(unsafe.Pointer(v18))
		*(*TTcl_Size)(unsafe.Pointer(v18))--
		if v17 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
	/* Undef constants */
	return status
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LsetObjCmd --
 *
 *	This procedure is invoked to process the "lset" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LsetObjCmd(tls *libc.TLS, dummy4423 uintptr, interp1 uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument values. */
	var _objPtr, finalValuePtr, listPtr, proc, v1, v2, v3, v4, v7 uintptr
	var v6 TTcl_Size
	_, _, _, _, _, _, _, _, _, _ = _objPtr, finalValuePtr, listPtr, proc, v1, v2, v3, v4, v6, v7 /* Value finally assigned to the variable. */
	/*
	 * Check parameter count.
	 */
	if objc < int32(3) {
		XTcl_WrongNumArgs(tls, interp1, int64(1), objv, __ccgo_ts+18202)
		return int32(TCL_ERROR)
	}
	/*
	 * Look up the list variable's value.
	 */
	listPtr = XTcl_ObjGetVar2(tls, interp1, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), int32(TCL_LEAVE_ERR_MSG))
	if listPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Substitute the value in the value. Return either the value or else an
	 * unshared copy of it.
	 */
	if objc == int32(4) {
		finalValuePtr = XTclLsetList(tls, interp1, listPtr, *(*uintptr)(unsafe.Pointer(objv + 2*8)), *(*uintptr)(unsafe.Pointer(objv + 3*8)))
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(listPtr)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+88) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+88) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listPtr)).FtypePtr)).Fversion) {
			v1 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listPtr)).FtypePtr)).FsetElementProc
		} else {
			v1 = libc.UintptrFromInt32(0)
		}
		if v1 != 0 {
			v2 = listPtr
			if (*TTcl_Obj)(unsafe.Pointer(v2)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+88) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+88) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v2)).FtypePtr)).Fversion) {
				v3 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v2)).FtypePtr)).FsetElementProc
			} else {
				v3 = libc.UintptrFromInt32(0)
			}
			proc = v3
			v4 = (*(*func(*libc.TLS, uintptr, uintptr, TTcl_Size, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{proc})))(tls, interp1, v2, int64(objc-int32(3)), objv+uintptr(2)*8, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))
			goto _5
		_5:
			finalValuePtr = v4
			if finalValuePtr != 0 {
				(*TTcl_Obj)(unsafe.Pointer(finalValuePtr)).FrefCount++
			}
		} else {
			finalValuePtr = XTclLsetFlat(tls, interp1, listPtr, int64(objc-int32(3)), objv+uintptr(2)*8, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))
		}
	}
	/*
	 * If substitution has failed, bail out.
	 */
	if finalValuePtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Finally, update the variable so that traces fire.
	 */
	listPtr = XTcl_ObjSetVar2(tls, interp1, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), finalValuePtr, int32(TCL_LEAVE_ERR_MSG))
	_objPtr = finalValuePtr
	v7 = _objPtr
	v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
	*(*TTcl_Size)(unsafe.Pointer(v7))--
	if v6 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	if listPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Return the new value of the variable as the interpreter result.
	 */
	XTcl_SetObjResult(tls, interp1, listPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LsortObjCmd --
 *
 *	This procedure is invoked to process the "lsort" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LsortObjCmd(tls *libc.TLS, dummy4516 uintptr, interp1 uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(208)
	defer tls.Free(208) /* Argument values. */
	var allocatedIndexVector, group, indexc, indices, nocase, result, sortMode, v2, v22, v24, v31, v7 int32
	var cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cmdPtr, elementArray, elementPtr, indexPtr, listObj, newArray, newCommandPtr, newObjPtr, objPtr1, proc, resultPtr, v14, v17, v19, v20, v21, v30, v46, v49, v6 uintptr
	var elmArrSize, groupOffset, i, idx, j, v13, v16, v38, v39, v42, v44, v45, v48 TTcl_Size
	var groupSize TTcl_WideInt
	var subList [31]uintptr
	var v10, v25, v26, v3, v34, v4, v9 int64
	var v12, v15, v18, v37, v41, v47, v50 bool
	var _ /* a at bp+128 */ TTcl_WideInt
	var _ /* a at bp+136 */ float64
	var _ /* encoded at bp+112 */ int32
	var _ /* index at bp+88 */ int32
	var _ /* indexv at bp+104 */ uintptr
	var _ /* indexv at bp+120 */ uintptr
	var _ /* length at bp+0 */ TTcl_Size
	var _ /* listObjPtrs at bp+16 */ uintptr
	var _ /* listRep at bp+144 */ TListRep
	var _ /* sortInfo at bp+24 */ TSortInfo
	var _ /* sortindex at bp+96 */ TTcl_Size
	var _ /* wide at bp+8 */ TTcl_WideInt
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = allocatedIndexVector, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cmdPtr, elementArray, elementPtr, elmArrSize, group, groupOffset, groupSize, i, idx, indexPtr, indexc, indices, j, listObj, newArray, newCommandPtr, newObjPtr, nocase, objPtr1, proc, result, resultPtr, sortMode, subList, v10, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v24, v25, v26, v3, v30, v31, v34, v37, v38, v39, v4, v41, v42, v44, v45, v46, v47, v48, v49, v50, v6, v7, v9
	nocase = 0
	sortMode = SORTMODE_ASCII
	allocatedIndexVector = 0
	elementArray = libc.UintptrFromInt32(0)
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp1, int64(1), objv, __ccgo_ts+18262)
		return int32(TCL_ERROR)
	}
	/*
	 * Parse arguments to set up the mode for the sort.
	 */
	(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FisIncreasing = int32(1)
	(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FsortMode = SORTMODE_ASCII
	(*(*TSortInfo)(unsafe.Pointer(bp + 24))).Findexv = libc.UintptrFromInt32(0)
	(*(*TSortInfo)(unsafe.Pointer(bp + 24))).Findexc = 0
	(*(*TSortInfo)(unsafe.Pointer(bp + 24))).Funique = 0
	(*(*TSortInfo)(unsafe.Pointer(bp + 24))).Finterp = interp1
	(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FresultCode = TCL_OK
	cmdPtr = libc.UintptrFromInt32(0)
	indices = 0
	group = 0
	groupSize = int64(1)
	groupOffset = 0
	indexPtr = libc.UintptrFromInt32(0)
	i = int64(1)
	for {
		if !(i < int64(objc-int32(1))) {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp1, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_switches)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+88) != TCL_OK {
			(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FresultCode = int32(TCL_ERROR)
			goto done
		}
		switch *(*int32)(unsafe.Pointer(bp + 88)) {
		case 0:
			(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FsortMode = SORTMODE_ASCII
		case 1:
			if i == int64(objc-int32(2)) {
				XTcl_SetObjResult(tls, interp1, XTcl_NewStringObj(tls, __ccgo_ts+18287, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp1, libc.VaList(bp+168, __ccgo_ts+2004, __ccgo_ts+16490, __ccgo_ts+17673, libc.UintptrFromInt32(0)))
				(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FresultCode = int32(TCL_ERROR)
				goto done
			}
			(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FsortMode = int32(SORTMODE_COMMAND)
			cmdPtr = *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8))
			i++
		case 2:
			(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FisIncreasing = 0
		case 3:
			(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FsortMode = int32(SORTMODE_DICTIONARY)
		case 4:
			(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FisIncreasing = int32(1)
		case 5:
			if i == int64(objc-int32(2)) {
				XTcl_SetObjResult(tls, interp1, XTcl_NewStringObj(tls, __ccgo_ts+17783, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp1, libc.VaList(bp+168, __ccgo_ts+2004, __ccgo_ts+16490, __ccgo_ts+17673, libc.UintptrFromInt32(0)))
				(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FresultCode = int32(TCL_ERROR)
				goto done
			}
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)) + 32))).Fptr2 != 0 {
					v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)) + 32))).Fptr2)).FspanStart
				} else {
					v3 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)) + 32))).Fptr1)).FfirstUsed
				}
				*(*uintptr)(unsafe.Pointer(bp + 104)) = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)) + 32))).Fptr1 + 40 + uintptr(v3)*8
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)) + 32))).Fptr2 != 0 {
					v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)) + 32))).Fptr2)).FspanLength
				} else {
					v4 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)) + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp + 96)) = v4
				v2 = libc.Int32FromInt32(TCL_OK)
			} else {
				v2 = XTcl_ListObjGetElements(tls, interp1, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)), bp+96, bp+104)
			}
			if v2 != TCL_OK {
				(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FresultCode = int32(TCL_ERROR)
				goto done
			}
			/*
			 * Check each of the indices for syntactic correctness. Note that
			 * we do not store the converted values here because we do not
			 * know if this is the only -index option yet and so we can't
			 * allocate any space; that happens after the scan through all the
			 * options is done.
			 */
			j = 0
			for {
				if !(j < *(*TTcl_Size)(unsafe.Pointer(bp + 96))) {
					break
				}
				*(*int32)(unsafe.Pointer(bp + 112)) = 0
				result = XTclIndexEncode(tls, interp1, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 104)) + uintptr(j)*8)), int32(int64(-libc.Int32FromInt32(1))), int32(int64(-libc.Int32FromInt32(1))), bp+112)
				if result == TCL_OK && *(*int32)(unsafe.Pointer(bp + 112)) == int32(int64(-libc.Int32FromInt32(1))) {
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 104)) + uintptr(j)*8)))).Fbytes != 0 {
						v6 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 104)) + uintptr(j)*8)))).Fbytes
					} else {
						v6 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 104)) + uintptr(j)*8)), libc.UintptrFromInt32(0))
					}
					XTcl_SetObjResult(tls, interp1, XTcl_ObjPrintf(tls, __ccgo_ts+17830, libc.VaList(bp+168, v6)))
					XTcl_SetErrorCode(tls, interp1, libc.VaList(bp+168, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+17278, __ccgo_ts+17284, libc.UintptrFromInt32(0)))
					result = int32(TCL_ERROR)
				}
				if result == int32(TCL_ERROR) {
					XTcl_AppendObjToErrorInfo(tls, interp1, XTcl_ObjPrintf(tls, __ccgo_ts+17854, libc.VaList(bp+168, j)))
					(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FresultCode = int32(TCL_ERROR)
					goto done
				}
				goto _5
			_5:
				;
				j++
			}
			indexPtr = *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8))
			i++
		case 7:
			(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FsortMode = int32(SORTMODE_INTEGER)
		case 8:
			nocase = int32(1)
		case 9:
			(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FsortMode = int32(SORTMODE_REAL)
		case 11:
			(*(*TSortInfo)(unsafe.Pointer(bp + 24))).Funique = int32(1)
		case 6:
			indices = int32(1)
		case 10:
			if i == int64(objc-int32(2)) {
				XTcl_SetObjResult(tls, interp1, XTcl_NewStringObj(tls, __ccgo_ts+17681, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp1, libc.VaList(bp+168, __ccgo_ts+2004, __ccgo_ts+16490, __ccgo_ts+17673, libc.UintptrFromInt32(0)))
				(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FresultCode = int32(TCL_ERROR)
				goto done
			}
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
				*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).FinternalRep))
				v7 = libc.Int32FromInt32(TCL_OK)
			} else {
				v7 = XTcl_GetWideIntFromObj(tls, interp1, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)), bp+8)
			}
			if v7 != TCL_OK {
				(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FresultCode = int32(TCL_ERROR)
				goto done
			}
			if *(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) < int64(2) {
				XTcl_SetObjResult(tls, interp1, XTcl_NewStringObj(tls, __ccgo_ts+18344, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp1, libc.VaList(bp+168, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+18377, __ccgo_ts+17773, libc.UintptrFromInt32(0)))
				(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FresultCode = int32(TCL_ERROR)
				goto done
			}
			groupSize = *(*TTcl_WideInt)(unsafe.Pointer(bp + 8))
			group = int32(1)
			i++
			break
		}
		goto _1
	_1:
		;
		i++
	}
	if nocase != 0 && (*(*TSortInfo)(unsafe.Pointer(bp + 24))).FsortMode == SORTMODE_ASCII {
		(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FsortMode = int32(SORTMODE_ASCII_NC)
	}
	/*
	 * Now extract the -index list for real, if present. No failures are
	 * expected here; the values are all of the right type or convertible to
	 * it.
	 */
	if indexPtr != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(indexPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(indexPtr + 32))).Fptr2 != 0 {
				v9 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(indexPtr + 32))).Fptr2)).FspanStart
			} else {
				v9 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(indexPtr + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 120)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(indexPtr + 32))).Fptr1 + 40 + uintptr(v9)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(indexPtr + 32))).Fptr2 != 0 {
				v10 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(indexPtr + 32))).Fptr2)).FspanLength
			} else {
				v10 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(indexPtr + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 24 + 24)) = v10
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_ListObjGetElements(tls, interp1, indexPtr, bp+24+24, bp+120)
		}
		switch (*(*TSortInfo)(unsafe.Pointer(bp + 24))).Findexc {
		case 0:
			(*(*TSortInfo)(unsafe.Pointer(bp + 24))).Findexv = libc.UintptrFromInt32(0)
		case int64(1):
			(*(*TSortInfo)(unsafe.Pointer(bp + 24))).Findexv = bp + 24 + 32
		default:
			(*(*TSortInfo)(unsafe.Pointer(bp + 24))).Findexv = XTclStackAlloc(tls, interp1, uint64(4)*libc.Uint64FromInt64((*(*TSortInfo)(unsafe.Pointer(bp + 24))).Findexc))
			allocatedIndexVector = int32(1) /* Cannot use indexc field, as it
			 * might be decreased by 1 later. */
		}
		j = 0
		for {
			if !(j < (*(*TSortInfo)(unsafe.Pointer(bp + 24))).Findexc) {
				break
			}
			/* Prescreened values, no errors or out of range possible */
			XTclIndexEncode(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 120)) + uintptr(j)*8)), int32(int64(-libc.Int32FromInt32(1))), int32(int64(-libc.Int32FromInt32(1))), (*(*TSortInfo)(unsafe.Pointer(bp + 24))).Findexv+uintptr(j)*4)
			goto _11
		_11:
			;
			j++
		}
	}
	listObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8))
	if (*(*TSortInfo)(unsafe.Pointer(bp + 24))).FsortMode == int32(SORTMODE_COMMAND) {
		/*
		 * When sorting using a command, we are reentrant and therefore might
		 * have the representation of the list being sorted shimmered out from
		 * underneath our feet. Take a copy (cheap) to prevent this. [Bug
		 * 1675116]
		 */
		listObj = XTclListObjCopy(tls, interp1, listObj)
		if listObj == libc.UintptrFromInt32(0) {
			(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FresultCode = int32(TCL_ERROR)
			goto done
		}
		/*
		 * The existing command is a list. We want to flatten it, append two
		 * dummy arguments on the end, and replace these arguments later.
		 */
		newCommandPtr = XTcl_DuplicateObj(tls, cmdPtr)
		if v12 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v12 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v12 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			newObjPtr = XTclThreadAllocObj(tls)
		} else {
			newObjPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(newObjPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(newObjPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(newObjPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(newObjPtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(newObjPtr)).FtypePtr = libc.UintptrFromInt32(0)
		(*TTcl_Obj)(unsafe.Pointer(newCommandPtr)).FrefCount++
		if XTcl_ListObjAppendElement(tls, interp1, newCommandPtr, newObjPtr) != TCL_OK {
			v14 = newCommandPtr
			v13 = *(*TTcl_Size)(unsafe.Pointer(v14))
			*(*TTcl_Size)(unsafe.Pointer(v14))--
			if !(v13 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(newCommandPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(newCommandPtr)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(newCommandPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(newCommandPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(newCommandPtr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(newCommandPtr)).Flength = int64(-libc.Int32FromInt32(1))
					if v15 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v15 {
						cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v15 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, newCommandPtr)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(newCommandPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = newCommandPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, newCommandPtr)
				}
			}
			v17 = newObjPtr
			v16 = *(*TTcl_Size)(unsafe.Pointer(v17))
			*(*TTcl_Size)(unsafe.Pointer(v17))--
			if !(v16 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(newObjPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(newObjPtr)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(newObjPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(newObjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(newObjPtr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(newObjPtr)).Flength = int64(-libc.Int32FromInt32(1))
					if v18 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v18 {
						cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v18 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, newObjPtr)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(newObjPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = newObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, newObjPtr)
				}
			}
			(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FresultCode = int32(TCL_ERROR)
			goto done
		}
		XTcl_ListObjAppendElement(tls, interp1, newCommandPtr, XTcl_NewObj(tls))
		(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FcompareCmdPtr = newCommandPtr
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+80) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+80) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr)).Fversion) {
		v19 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr)).FgetElementsProc
	} else {
		v19 = libc.UintptrFromInt32(0)
	}
	if v19 != 0 {
		v20 = listObj
		if (*TTcl_Obj)(unsafe.Pointer(v20)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+80) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+80) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v20)).FtypePtr)).Fversion) {
			v21 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v20)).FtypePtr)).FgetElementsProc
		} else {
			v21 = libc.UintptrFromInt32(0)
		}
		proc = v21
		v22 = (*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{proc})))(tls, interp1, v20, bp, bp+16)
		goto _23
	_23:
		(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FresultCode = v22
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr2 != 0 {
				v25 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr2)).FspanStart
			} else {
				v25 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 16)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr1 + 40 + uintptr(v25)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr2 != 0 {
				v26 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr2)).FspanLength
			} else {
				v26 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp)) = v26
			v24 = libc.Int32FromInt32(TCL_OK)
		} else {
			v24 = XTcl_ListObjGetElements(tls, interp1, listObj, bp, bp+16)
		}
		(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FresultCode = v24
	}
	if (*(*TSortInfo)(unsafe.Pointer(bp + 24))).FresultCode != TCL_OK || *(*TTcl_Size)(unsafe.Pointer(bp)) <= 0 {
		goto done
	}
	/*
	 * Check for sanity when grouping elements of the overall list together
	 * because of the -stride option. [TIP #326]
	 */
	if group != 0 {
		if *(*TTcl_Size)(unsafe.Pointer(bp))%groupSize != 0 {
			XTcl_SetObjResult(tls, interp1, XTcl_NewStringObj(tls, __ccgo_ts+17999, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp1, libc.VaList(bp+168, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+18377, __ccgo_ts+17773, libc.UintptrFromInt32(0)))
			(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FresultCode = int32(TCL_ERROR)
			goto done
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = *(*TTcl_Size)(unsafe.Pointer(bp)) / groupSize
		if (*(*TSortInfo)(unsafe.Pointer(bp + 24))).Findexc > 0 {
			/*
			 * Use the first value in the list supplied to -index as the
			 * offset of the element within each group by which to sort.
			 */
			groupOffset = XTclIndexDecode(tls, *(*int32)(unsafe.Pointer((*(*TSortInfo)(unsafe.Pointer(bp + 24))).Findexv)), groupSize-int64(1))
			if groupOffset < 0 || groupOffset >= groupSize {
				XTcl_SetObjResult(tls, interp1, XTcl_NewStringObj(tls, __ccgo_ts+18049, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp1, libc.VaList(bp+168, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+18377, __ccgo_ts+18127, libc.UintptrFromInt32(0)))
				(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FresultCode = int32(TCL_ERROR)
				goto done
			}
			if (*(*TSortInfo)(unsafe.Pointer(bp + 24))).Findexc == int64(1) {
				(*(*TSortInfo)(unsafe.Pointer(bp + 24))).Findexc = 0
				(*(*TSortInfo)(unsafe.Pointer(bp + 24))).Findexv = libc.UintptrFromInt32(0)
			} else {
				(*(*TSortInfo)(unsafe.Pointer(bp + 24))).Findexc--
				/*
				 * Do not shrink the actual memory block used; that doesn't
				 * work with TclStackAlloc-allocated memory. [Bug 2918962]
				 *
				 * TODO: Consider a pointer increment to replace this
				 * array shift.
				 */
				i = 0
				for {
					if !(i < (*(*TSortInfo)(unsafe.Pointer(bp + 24))).Findexc) {
						break
					}
					*(*int32)(unsafe.Pointer((*(*TSortInfo)(unsafe.Pointer(bp + 24))).Findexv + uintptr(i)*4)) = *(*int32)(unsafe.Pointer((*(*TSortInfo)(unsafe.Pointer(bp + 24))).Findexv + uintptr(i+int64(1))*4))
					goto _27
				_27:
					;
					i++
				}
			}
		}
	}
	(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FnumElements = int32(*(*TTcl_Size)(unsafe.Pointer(bp)))
	indexc = int32((*(*TSortInfo)(unsafe.Pointer(bp + 24))).Findexc)
	sortMode = (*(*TSortInfo)(unsafe.Pointer(bp + 24))).FsortMode
	if sortMode == int32(SORTMODE_ASCII_NC) || sortMode == int32(SORTMODE_DICTIONARY) {
		/*
		 * For this function's purpose all string-based modes are equivalent
		 */
		sortMode = SORTMODE_ASCII
	}
	/*
	 * Initialize the sublists. After the following loop, subList[i] will
	 * contain a sorted sublist of length 2**i. Use one extra subList at the
	 * end, always at NULL, to indicate the end of the lists.
	 */
	j = 0
	for {
		if !(j <= int64(NUM_LISTS)) {
			break
		}
		subList[j] = libc.UintptrFromInt32(0)
		goto _28
	_28:
		;
		j++
	}
	/*
	 * The following loop creates a SortElement for each list element and
	 * begins sorting it into the sublists as it appears.
	 */
	elmArrSize = libc.Int64FromUint64(libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))) * uint64(24))
	if elmArrSize <= int64(MAXCALLOC) {
		elementArray = XTcl_Alloc(tls, libc.Uint64FromInt64(elmArrSize))
	} else {
		elementArray = libc.Xmalloc(tls, libc.Uint64FromInt64(elmArrSize))
	}
	if !(elementArray != 0) {
		XTcl_SetObjResult(tls, interp1, XTcl_ObjPrintf(tls, __ccgo_ts+18383, libc.VaList(bp+168, *(*TTcl_Size)(unsafe.Pointer(bp)))))
		XTcl_SetErrorCode(tls, interp1, libc.VaList(bp+168, __ccgo_ts+2004, __ccgo_ts+2008, libc.UintptrFromInt32(0)))
		(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FresultCode = int32(TCL_ERROR)
		goto done
	}
	i = 0
	for {
		if !(i < *(*TTcl_Size)(unsafe.Pointer(bp))) {
			break
		}
		idx = groupSize*i + groupOffset
		if indexc != 0 {
			/*
			 * If this is an indexed sort, retrieve the corresponding element
			 */
			indexPtr = _SelectObjFromSublist(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(idx)*8)), bp+24)
			if (*(*TSortInfo)(unsafe.Pointer(bp + 24))).FresultCode != TCL_OK {
				goto done
			}
		} else {
			indexPtr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(idx)*8))
		}
		/*
		 * Determine the "value" of this object for sorting purposes
		 */
		if sortMode == SORTMODE_ASCII {
			if (*TTcl_Obj)(unsafe.Pointer(indexPtr)).Fbytes != 0 {
				v30 = (*TTcl_Obj)(unsafe.Pointer(indexPtr)).Fbytes
			} else {
				v30 = XTcl_GetStringFromObj(tls, indexPtr, libc.UintptrFromInt32(0))
			}
			*(*uintptr)(unsafe.Pointer(elementArray + uintptr(i)*24)) = v30
		} else {
			if sortMode == int32(SORTMODE_INTEGER) {
				if (*TTcl_Obj)(unsafe.Pointer(indexPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
					*(*TTcl_WideInt)(unsafe.Pointer(bp + 128)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(indexPtr)).FinternalRep))
					v31 = libc.Int32FromInt32(TCL_OK)
				} else {
					v31 = XTcl_GetWideIntFromObj(tls, (*(*TSortInfo)(unsafe.Pointer(bp + 24))).Finterp, indexPtr, bp+128)
				}
				if v31 != TCL_OK {
					(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FresultCode = int32(TCL_ERROR)
					goto done
				}
				*(*TTcl_WideInt)(unsafe.Pointer(elementArray + uintptr(i)*24)) = *(*TTcl_WideInt)(unsafe.Pointer(bp + 128))
			} else {
				if sortMode == int32(SORTMODE_REAL) {
					if XTcl_GetDoubleFromObj(tls, (*(*TSortInfo)(unsafe.Pointer(bp + 24))).Finterp, indexPtr, bp+136) != TCL_OK {
						(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FresultCode = int32(TCL_ERROR)
						goto done
					}
					*(*float64)(unsafe.Pointer(elementArray + uintptr(i)*24)) = *(*float64)(unsafe.Pointer(bp + 136))
				} else {
					*(*uintptr)(unsafe.Pointer(elementArray + uintptr(i)*24)) = indexPtr
				}
			}
		}
		/*
		 * Determine the representation of this element in the result: either
		 * the objPtr itself, or its index in the original list.
		 */
		if indices != 0 || group != 0 {
			*(*Tsize_t)(unsafe.Pointer(elementArray + uintptr(i)*24 + 8)) = libc.Uint64FromInt64(idx)
		} else {
			*(*uintptr)(unsafe.Pointer(elementArray + uintptr(i)*24 + 8)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(idx)*8))
		}
		/*
		 * Merge this element in the preexisting sublists (and merge together
		 * sublists when we have two of the same size).
		 */
		(*(*TSortElement)(unsafe.Pointer(elementArray + uintptr(i)*24))).FnextPtr = libc.UintptrFromInt32(0)
		elementPtr = elementArray + uintptr(i)*24
		j = 0
		for {
			if !(subList[j] != 0) {
				break
			}
			elementPtr = _MergeLists(tls, subList[j], elementPtr, bp+24)
			subList[j] = libc.UintptrFromInt32(0)
			goto _32
		_32:
			;
			j++
		}
		if j >= int64(NUM_LISTS) {
			j = int64(libc.Int32FromInt32(NUM_LISTS) - libc.Int32FromInt32(1))
		}
		subList[j] = elementPtr
		goto _29
	_29:
		;
		i++
	}
	/*
	 * Merge all sublists
	 */
	elementPtr = subList[0]
	j = int64(1)
	for {
		if !(j < int64(NUM_LISTS)) {
			break
		}
		elementPtr = _MergeLists(tls, subList[j], elementPtr, bp+24)
		goto _33
	_33:
		;
		j++
	}
	/*
	 * Now store the sorted elements in the result list.
	 */
	if (*(*TSortInfo)(unsafe.Pointer(bp + 24))).FresultCode == TCL_OK {
		resultPtr = XTcl_NewListObj(tls, int64((*(*TSortInfo)(unsafe.Pointer(bp + 24))).FnumElements)*groupSize, libc.UintptrFromInt32(0))
		(*TListRep)(unsafe.Pointer(bp + 144)).FstorePtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultPtr + 32))).Fptr1
		(*TListRep)(unsafe.Pointer(bp + 144)).FspanPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultPtr + 32))).Fptr2
		if (*TListRep)(unsafe.Pointer(bp+144)).FspanPtr != 0 {
			v34 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp + 144)).FspanPtr)).FspanStart
		} else {
			v34 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp + 144)).FstorePtr)).FfirstUsed
		}
		newArray = (*TListRep)(unsafe.Pointer(bp+144)).FstorePtr + 40 + uintptr(v34)*8
		if group != 0 {
			i = 0
			for {
				if !(elementPtr != libc.UintptrFromInt32(0)) {
					break
				}
				idx = libc.Int64FromUint64(*(*Tsize_t)(unsafe.Pointer(elementPtr + 8)))
				j = 0
				for {
					if !(j < groupSize) {
						break
					}
					if indices != 0 {
						if v37 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v37 {
							cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v37 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
							objPtr1 = XTclThreadAllocObj(tls)
						} else {
							objPtr1 = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(objPtr1 + 32))).Fptr1
							(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
						}
						(*TTcl_Obj)(unsafe.Pointer(objPtr1)).FrefCount = 0
						(*TTcl_Obj)(unsafe.Pointer(objPtr1)).Fbytes = libc.UintptrFromInt32(0)
						*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr1)).FinternalRep)) = idx + j - groupOffset
						(*TTcl_Obj)(unsafe.Pointer(objPtr1)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
						v38 = i
						i++
						*(*uintptr)(unsafe.Pointer(newArray + uintptr(v38)*8)) = objPtr1
						(*TTcl_Obj)(unsafe.Pointer(objPtr1)).FrefCount++
					} else {
						objPtr1 = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(idx+j-groupOffset)*8))
						v39 = i
						i++
						*(*uintptr)(unsafe.Pointer(newArray + uintptr(v39)*8)) = objPtr1
						(*TTcl_Obj)(unsafe.Pointer(objPtr1)).FrefCount++
					}
					goto _36
				_36:
					;
					j++
				}
				goto _35
			_35:
				;
				elementPtr = (*TSortElement)(unsafe.Pointer(elementPtr)).FnextPtr
			}
		} else {
			if indices != 0 {
				i = 0
				for {
					if !(elementPtr != libc.UintptrFromInt32(0)) {
						break
					}
					if v41 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v41 {
						cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v41 || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == libc.Uint64FromInt32(0) {
						objPtr1 = XTclThreadAllocObj(tls)
					} else {
						objPtr1 = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(objPtr1 + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer(objPtr1)).FrefCount = 0
					(*TTcl_Obj)(unsafe.Pointer(objPtr1)).Fbytes = libc.UintptrFromInt32(0)
					*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr1)).FinternalRep)) = libc.Int64FromUint64(*(*Tsize_t)(unsafe.Pointer(elementPtr + 8)))
					(*TTcl_Obj)(unsafe.Pointer(objPtr1)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
					v42 = i
					i++
					*(*uintptr)(unsafe.Pointer(newArray + uintptr(v42)*8)) = objPtr1
					(*TTcl_Obj)(unsafe.Pointer(objPtr1)).FrefCount++
					goto _40
				_40:
					;
					elementPtr = (*TSortElement)(unsafe.Pointer(elementPtr)).FnextPtr
				}
			} else {
				i = 0
				for {
					if !(elementPtr != libc.UintptrFromInt32(0)) {
						break
					}
					objPtr1 = *(*uintptr)(unsafe.Pointer(elementPtr + 8))
					v44 = i
					i++
					*(*uintptr)(unsafe.Pointer(newArray + uintptr(v44)*8)) = objPtr1
					(*TTcl_Obj)(unsafe.Pointer(objPtr1)).FrefCount++
					goto _43
				_43:
					;
					elementPtr = (*TSortElement)(unsafe.Pointer(elementPtr)).FnextPtr
				}
			}
		}
		(*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp + 144))).FstorePtr)).FnumUsed = i
		if (*(*TListRep)(unsafe.Pointer(bp + 144))).FspanPtr != 0 {
			(*TListSpan)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp + 144))).FspanPtr)).FspanStart = (*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp + 144))).FstorePtr)).FfirstUsed
			(*TListSpan)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp + 144))).FspanPtr)).FspanLength = (*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp + 144))).FstorePtr)).FnumUsed
		}
		XTcl_SetObjResult(tls, interp1, resultPtr)
	}
	goto done
done:
	;
	if sortMode == int32(SORTMODE_COMMAND) {
		v46 = (*(*TSortInfo)(unsafe.Pointer(bp + 24))).FcompareCmdPtr
		v45 = *(*TTcl_Size)(unsafe.Pointer(v46))
		*(*TTcl_Size)(unsafe.Pointer(v46))--
		if !(v45 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer((*(*TSortInfo)(unsafe.Pointer(bp + 24))).FcompareCmdPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*(*TSortInfo)(unsafe.Pointer(bp + 24))).FcompareCmdPtr)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer((*(*TSortInfo)(unsafe.Pointer(bp + 24))).FcompareCmdPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*(*TSortInfo)(unsafe.Pointer(bp + 24))).FcompareCmdPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*(*TSortInfo)(unsafe.Pointer(bp + 24))).FcompareCmdPtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer((*(*TSortInfo)(unsafe.Pointer(bp + 24))).FcompareCmdPtr)).Flength = int64(-libc.Int32FromInt32(1))
				if v47 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v47 {
					cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v47 || ((*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, (*(*TSortInfo)(unsafe.Pointer(bp + 24))).FcompareCmdPtr)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer((*(*TSortInfo)(unsafe.Pointer(bp + 24))).FcompareCmdPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = (*(*TSortInfo)(unsafe.Pointer(bp + 24))).FcompareCmdPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, (*(*TSortInfo)(unsafe.Pointer(bp + 24))).FcompareCmdPtr)
			}
		}
		v49 = listObj
		v48 = *(*TTcl_Size)(unsafe.Pointer(v49))
		*(*TTcl_Size)(unsafe.Pointer(v49))--
		if !(v48 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(listObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(listObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(listObj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(listObj)).Flength = int64(-libc.Int32FromInt32(1))
				if v50 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v50 {
					cachePtr6 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v50 || ((*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, listObj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(listObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr = listObj
					(*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, listObj)
			}
		}
		(*(*TSortInfo)(unsafe.Pointer(bp + 24))).FcompareCmdPtr = libc.UintptrFromInt32(0)
	}
	if allocatedIndexVector != 0 {
		XTclStackFree(tls, interp1, (*(*TSortInfo)(unsafe.Pointer(bp + 24))).Findexv)
	}
	if elementArray != 0 {
		if elmArrSize <= int64(MAXCALLOC) {
			XTclpFree(tls, elementArray)
		} else {
			libc.Xfree(tls, elementArray)
		}
	}
	return (*(*TSortInfo)(unsafe.Pointer(bp + 24))).FresultCode
}

/* This array holds pointers to temporary
 * lists built during the merge sort. Element
 * i of the array holds a list of length
 * 2**i. */
var _switches = [13]uintptr{
	0:  __ccgo_ts + 17467,
	1:  __ccgo_ts + 18236,
	2:  __ccgo_ts + 17482,
	3:  __ccgo_ts + 17494,
	4:  __ccgo_ts + 17519,
	5:  __ccgo_ts + 17531,
	6:  __ccgo_ts + 18245,
	7:  __ccgo_ts + 17546,
	8:  __ccgo_ts + 17555,
	9:  __ccgo_ts + 17568,
	10: __ccgo_ts + 17597,
	11: __ccgo_ts + 18254,
	12: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LeditObjCmd --
 *
 *	This procedure is invoked to process the "ledit" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LeditObjCmd(tls *libc.TLS, dummy5033 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Argument values. */
	var _objPtr, finalValuePtr, listPtr, v6 uintptr
	var createdNewObj, result, v1, v3, v4 int32
	var numToDelete, v5 TTcl_Size
	var v2 int64
	var _ /* first at bp+0 */ TTcl_Size
	var _ /* last at bp+8 */ TTcl_Size
	var _ /* listLen at bp+16 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, createdNewObj, finalValuePtr, listPtr, numToDelete, result, v1, v2, v3, v4, v5, v6
	if objc < int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+18430)
		return int32(TCL_ERROR)
	}
	listPtr = XTcl_ObjGetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), int32(TCL_LEAVE_ERR_MSG))
	if listPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * TODO - refactor the index extraction into a common function shared
	 * by Tcl_{Lrange,Lreplace,Ledit}ObjCmd
	 */
	if (*TTcl_Obj)(unsafe.Pointer(listPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listPtr + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr + 32))).Fptr2)).FspanLength
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = v2
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjLength(tls, interp, listPtr, bp+16)
	}
	result = v1
	if result != TCL_OK {
		return result
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) <= *(*TTcl_Size)(unsafe.Pointer(bp + 16))-int64(1) {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep))
		v3 = libc.Int32FromInt32(TCL_OK)
	} else {
		v3 = XTcl_GetIntForIndex(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), *(*TTcl_Size)(unsafe.Pointer(bp + 16))-libc.Int64FromInt32(1), bp)
	}
	result = v3
	if result != TCL_OK {
		return result
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep)) <= *(*TTcl_Size)(unsafe.Pointer(bp + 16))-int64(1) {
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep))
		v4 = libc.Int32FromInt32(TCL_OK)
	} else {
		v4 = XTcl_GetIntForIndex(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)), *(*TTcl_Size)(unsafe.Pointer(bp + 16))-libc.Int64FromInt32(1), bp+8)
	}
	result = v4
	if result != TCL_OK {
		return result
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp)) < 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	} else {
		if *(*TTcl_Size)(unsafe.Pointer(bp)) > *(*TTcl_Size)(unsafe.Pointer(bp + 16)) {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = *(*TTcl_Size)(unsafe.Pointer(bp + 16))
		}
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) >= *(*TTcl_Size)(unsafe.Pointer(bp + 16)) {
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = *(*TTcl_Size)(unsafe.Pointer(bp + 16)) - int64(1)
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp)) <= *(*TTcl_Size)(unsafe.Pointer(bp + 8)) {
		numToDelete = libc.Int64FromUint64(libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8))) - libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))) + uint64(1)) /* See [3d3124d01d] */
	} else {
		numToDelete = 0
	}
	if (*TTcl_Obj)(unsafe.Pointer(listPtr)).FrefCount > int64(1) {
		listPtr = XTclListObjCopy(tls, libc.UintptrFromInt32(0), listPtr)
		createdNewObj = int32(1)
	} else {
		createdNewObj = 0
	}
	result = XTcl_ListObjReplace(tls, interp, listPtr, *(*TTcl_Size)(unsafe.Pointer(bp)), numToDelete, int64(objc-int32(4)), objv+uintptr(4)*8)
	if result != TCL_OK {
		if createdNewObj != 0 {
			_objPtr = listPtr
			v6 = _objPtr
			v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
			*(*TTcl_Size)(unsafe.Pointer(v6))--
			if v5 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
		return result
	}
	/*
	 * Tcl_ObjSetVar2 may return a value different from listPtr in the
	 * presence of traces etc.
	 */
	finalValuePtr = XTcl_ObjSetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), listPtr, int32(TCL_LEAVE_ERR_MSG))
	if finalValuePtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, finalValuePtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * MergeLists -
 *
 *	This procedure combines two sorted lists of SortElement structures
 *	into a single sorted list.
 *
 * Results:
 *	The unified list of SortElement structures.
 *
 * Side effects:
 *	If infoPtr->unique is set then infoPtr->numElements may be updated.
 *	Possibly others, if a user-defined comparison command does something
 *	weird.
 *
 * Note:
 *	If infoPtr->unique is set, the merge assumes that there are no
 *	"repeated" elements in each of the left and right lists. In that case,
 *	if any element of the left list is equivalent to one in the right list
 *	it is omitted from the merged list.
 *
 *	This simplified mechanism works because of the special way our
 *	MergeSort creates the sublists to be merged and will fail to eliminate
 *	all repeats in the general case where they are already present in
 *	either the left or right list. A general code would need to skip
 *	adjacent initial repeats in the left and right lists before comparing
 *	their initial elements, at each step.
 *
 *----------------------------------------------------------------------
 */

func _MergeLists(tls *libc.TLS, leftPtr uintptr, rightPtr uintptr, infoPtr uintptr) (r uintptr) {
	/* Information needed by the comparison
	 * operator. */
	var cmp int32
	var headPtr, tailPtr uintptr
	_, _, _ = cmp, headPtr, tailPtr
	if leftPtr == libc.UintptrFromInt32(0) {
		return rightPtr
	}
	if rightPtr == libc.UintptrFromInt32(0) {
		return leftPtr
	}
	cmp = _SortCompare(tls, leftPtr, rightPtr, infoPtr)
	if cmp > 0 || cmp == 0 && (*TSortInfo)(unsafe.Pointer(infoPtr)).Funique != 0 {
		if cmp == 0 {
			(*TSortInfo)(unsafe.Pointer(infoPtr)).FnumElements--
			leftPtr = (*TSortElement)(unsafe.Pointer(leftPtr)).FnextPtr
		}
		tailPtr = rightPtr
		rightPtr = (*TSortElement)(unsafe.Pointer(rightPtr)).FnextPtr
	} else {
		tailPtr = leftPtr
		leftPtr = (*TSortElement)(unsafe.Pointer(leftPtr)).FnextPtr
	}
	headPtr = tailPtr
	if !((*TSortInfo)(unsafe.Pointer(infoPtr)).Funique != 0) {
		for leftPtr != libc.UintptrFromInt32(0) && rightPtr != libc.UintptrFromInt32(0) {
			cmp = _SortCompare(tls, leftPtr, rightPtr, infoPtr)
			if cmp > 0 {
				(*TSortElement)(unsafe.Pointer(tailPtr)).FnextPtr = rightPtr
				tailPtr = rightPtr
				rightPtr = (*TSortElement)(unsafe.Pointer(rightPtr)).FnextPtr
			} else {
				(*TSortElement)(unsafe.Pointer(tailPtr)).FnextPtr = leftPtr
				tailPtr = leftPtr
				leftPtr = (*TSortElement)(unsafe.Pointer(leftPtr)).FnextPtr
			}
		}
	} else {
		for leftPtr != libc.UintptrFromInt32(0) && rightPtr != libc.UintptrFromInt32(0) {
			cmp = _SortCompare(tls, leftPtr, rightPtr, infoPtr)
			if cmp >= 0 {
				if cmp == 0 {
					(*TSortInfo)(unsafe.Pointer(infoPtr)).FnumElements--
					leftPtr = (*TSortElement)(unsafe.Pointer(leftPtr)).FnextPtr
				}
				(*TSortElement)(unsafe.Pointer(tailPtr)).FnextPtr = rightPtr
				tailPtr = rightPtr
				rightPtr = (*TSortElement)(unsafe.Pointer(rightPtr)).FnextPtr
			} else {
				(*TSortElement)(unsafe.Pointer(tailPtr)).FnextPtr = leftPtr
				tailPtr = leftPtr
				leftPtr = (*TSortElement)(unsafe.Pointer(leftPtr)).FnextPtr
			}
		}
	}
	if leftPtr != libc.UintptrFromInt32(0) {
		(*TSortElement)(unsafe.Pointer(tailPtr)).FnextPtr = leftPtr
	} else {
		(*TSortElement)(unsafe.Pointer(tailPtr)).FnextPtr = rightPtr
	}
	return headPtr
}

/*
 *----------------------------------------------------------------------
 *
 * SortCompare --
 *
 *	This procedure is invoked by MergeLists to determine the proper
 *	ordering between two elements.
 *
 * Results:
 *	A negative results means the first element comes before the
 *	second, and a positive results means that the second element should
 *	come first. A result of zero means the two elements are equal and it
 *	doesn't matter which comes first.
 *
 * Side effects:
 *	None, unless a user-defined comparison command does something weird.
 *
 *----------------------------------------------------------------------
 */

func _SortCompare(tls *libc.TLS, elemPtr1 uintptr, elemPtr2 uintptr, infoPtr uintptr) (r int32) {
	bp := tls.Alloc(96)
	defer tls.Free(96) /* Information passed from the top-level
	 * "lsort" command. */
	var a, b TTcl_WideInt
	var a1, b1 float64
	var objPtr1, objPtr2 uintptr
	var v2, v4, v5 int64
	var v6 int32
	var _ /* objc at bp+32 */ TTcl_Size
	var _ /* objv at bp+8 */ uintptr
	var _ /* order at bp+0 */ int32
	var _ /* paramObjv at bp+16 */ [2]uintptr
	_, _, _, _, _, _, _, _, _, _ = a, a1, b, b1, objPtr1, objPtr2, v2, v4, v5, v6
	*(*int32)(unsafe.Pointer(bp)) = 0
	if (*TSortInfo)(unsafe.Pointer(infoPtr)).FsortMode == SORTMODE_ASCII {
		*(*int32)(unsafe.Pointer(bp)) = XTclUtfCmp(tls, *(*uintptr)(unsafe.Pointer(elemPtr1)), *(*uintptr)(unsafe.Pointer(elemPtr2)))
	} else {
		if (*TSortInfo)(unsafe.Pointer(infoPtr)).FsortMode == int32(SORTMODE_ASCII_NC) {
			*(*int32)(unsafe.Pointer(bp)) = XTclUtfCasecmp(tls, *(*uintptr)(unsafe.Pointer(elemPtr1)), *(*uintptr)(unsafe.Pointer(elemPtr2)))
		} else {
			if (*TSortInfo)(unsafe.Pointer(infoPtr)).FsortMode == int32(SORTMODE_DICTIONARY) {
				*(*int32)(unsafe.Pointer(bp)) = _DictionaryCompare(tls, *(*uintptr)(unsafe.Pointer(elemPtr1)), *(*uintptr)(unsafe.Pointer(elemPtr2)))
			} else {
				if (*TSortInfo)(unsafe.Pointer(infoPtr)).FsortMode == int32(SORTMODE_INTEGER) {
					a = *(*TTcl_WideInt)(unsafe.Pointer(elemPtr1))
					b = *(*TTcl_WideInt)(unsafe.Pointer(elemPtr2))
					*(*int32)(unsafe.Pointer(bp)) = libc.BoolInt32(a >= b) - libc.BoolInt32(a <= b)
				} else {
					if (*TSortInfo)(unsafe.Pointer(infoPtr)).FsortMode == int32(SORTMODE_REAL) {
						a1 = *(*float64)(unsafe.Pointer(elemPtr1))
						b1 = *(*float64)(unsafe.Pointer(elemPtr2))
						*(*int32)(unsafe.Pointer(bp)) = libc.BoolInt32(a1 >= b1) - libc.BoolInt32(a1 <= b1)
					} else {
						if (*TSortInfo)(unsafe.Pointer(infoPtr)).FresultCode != TCL_OK {
							/*
							 * Once an error has occurred, skip any future comparisons so as
							 * to preserve the error message in sortInterp->result.
							 */
							return 0
						}
						objPtr1 = *(*uintptr)(unsafe.Pointer(elemPtr1))
						objPtr2 = *(*uintptr)(unsafe.Pointer(elemPtr2))
						(*(*[2]uintptr)(unsafe.Pointer(bp + 16)))[0] = objPtr1
						(*(*[2]uintptr)(unsafe.Pointer(bp + 16)))[int32(1)] = objPtr2
						/*
						 * We made space in the command list for the two things to compare.
						 * Replace them and evaluate the result.
						 */
						if (*TTcl_Obj)(unsafe.Pointer((*TSortInfo)(unsafe.Pointer(infoPtr)).FcompareCmdPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
							if (*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer((*TSortInfo)(unsafe.Pointer(infoPtr)).FcompareCmdPtr + 32))).Fptr2 != 0 {
								v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer((*TSortInfo)(unsafe.Pointer(infoPtr)).FcompareCmdPtr + 32))).Fptr2)).FspanLength
							} else {
								v2 = (*TListStore)(unsafe.Pointer((*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer((*TSortInfo)(unsafe.Pointer(infoPtr)).FcompareCmdPtr + 32))).Fptr1)).FnumUsed
							}
							*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = v2
							_ = libc.Int32FromInt32(TCL_OK)
						} else {
							XTcl_ListObjLength(tls, (*TSortInfo)(unsafe.Pointer(infoPtr)).Finterp, (*TSortInfo)(unsafe.Pointer(infoPtr)).FcompareCmdPtr, bp+32)
						}
						XTcl_ListObjReplace(tls, (*TSortInfo)(unsafe.Pointer(infoPtr)).Finterp, (*TSortInfo)(unsafe.Pointer(infoPtr)).FcompareCmdPtr, *(*TTcl_Size)(unsafe.Pointer(bp + 32))-int64(2), int64(2), int64(2), bp+16)
						if (*TTcl_Obj)(unsafe.Pointer((*TSortInfo)(unsafe.Pointer(infoPtr)).FcompareCmdPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
							if (*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer((*TSortInfo)(unsafe.Pointer(infoPtr)).FcompareCmdPtr + 32))).Fptr2 != 0 {
								v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer((*TSortInfo)(unsafe.Pointer(infoPtr)).FcompareCmdPtr + 32))).Fptr2)).FspanStart
							} else {
								v4 = (*TListStore)(unsafe.Pointer((*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer((*TSortInfo)(unsafe.Pointer(infoPtr)).FcompareCmdPtr + 32))).Fptr1)).FfirstUsed
							}
							*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer((*TSortInfo)(unsafe.Pointer(infoPtr)).FcompareCmdPtr + 32))).Fptr1 + 40 + uintptr(v4)*8
							if (*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer((*TSortInfo)(unsafe.Pointer(infoPtr)).FcompareCmdPtr + 32))).Fptr2 != 0 {
								v5 = (*TListSpan)(unsafe.Pointer((*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer((*TSortInfo)(unsafe.Pointer(infoPtr)).FcompareCmdPtr + 32))).Fptr2)).FspanLength
							} else {
								v5 = (*TListStore)(unsafe.Pointer((*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer((*TSortInfo)(unsafe.Pointer(infoPtr)).FcompareCmdPtr + 32))).Fptr1)).FnumUsed
							}
							*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = v5
							_ = libc.Int32FromInt32(TCL_OK)
						} else {
							XTcl_ListObjGetElements(tls, (*TSortInfo)(unsafe.Pointer(infoPtr)).Finterp, (*TSortInfo)(unsafe.Pointer(infoPtr)).FcompareCmdPtr, bp+32, bp+8)
						}
						(*TSortInfo)(unsafe.Pointer(infoPtr)).FresultCode = XTcl_EvalObjv(tls, (*TSortInfo)(unsafe.Pointer(infoPtr)).Finterp, *(*TTcl_Size)(unsafe.Pointer(bp + 32)), *(*uintptr)(unsafe.Pointer(bp + 8)), 0)
						if (*TSortInfo)(unsafe.Pointer(infoPtr)).FresultCode != TCL_OK {
							XTcl_AppendObjToErrorInfo(tls, (*TSortInfo)(unsafe.Pointer(infoPtr)).Finterp, XTcl_NewStringObj(tls, __ccgo_ts+18463, int64(-int32(1))))
							return 0
						}
						/*
						 * Parse the result of the command.
						 */
						if (*TTcl_Obj)(unsafe.Pointer(XTcl_GetObjResult(tls, (*TSortInfo)(unsafe.Pointer(infoPtr)).Finterp))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(XTcl_GetObjResult(tls, (*TSortInfo)(unsafe.Pointer(infoPtr)).Finterp))).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(XTcl_GetObjResult(tls, (*TSortInfo)(unsafe.Pointer(infoPtr)).Finterp))).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
							*(*int32)(unsafe.Pointer(bp)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(XTcl_GetObjResult(tls, (*TSortInfo)(unsafe.Pointer(infoPtr)).Finterp))).FinternalRep)))
							v6 = libc.Int32FromInt32(TCL_OK)
						} else {
							v6 = XTcl_GetIntFromObj(tls, (*TSortInfo)(unsafe.Pointer(infoPtr)).Finterp, XTcl_GetObjResult(tls, (*TSortInfo)(unsafe.Pointer(infoPtr)).Finterp), bp)
						}
						if v6 != TCL_OK {
							XTcl_SetObjResult(tls, (*TSortInfo)(unsafe.Pointer(infoPtr)).Finterp, XTcl_NewStringObj(tls, __ccgo_ts+18487, int64(-int32(1))))
							XTcl_SetErrorCode(tls, (*TSortInfo)(unsafe.Pointer(infoPtr)).Finterp, libc.VaList(bp+48, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+18377, __ccgo_ts+18532, libc.UintptrFromInt32(0)))
							(*TSortInfo)(unsafe.Pointer(infoPtr)).FresultCode = int32(TCL_ERROR)
							return 0
						}
					}
				}
			}
		}
	}
	if !((*TSortInfo)(unsafe.Pointer(infoPtr)).FisIncreasing != 0) {
		*(*int32)(unsafe.Pointer(bp)) = -*(*int32)(unsafe.Pointer(bp))
	}
	return *(*int32)(unsafe.Pointer(bp))
}

/*
 *----------------------------------------------------------------------
 *
 * DictionaryCompare
 *
 *	This function compares two strings as if they were being used in an
 *	index or card catalog. The case of alphabetic characters is ignored,
 *	except to break ties. Thus "B" comes before "b" but after "a". Also,
 *	integers embedded in the strings compare in numerical order. In other
 *	words, "x10y" comes after "x9y", not * before it as it would when
 *	using strcmp().
 *
 * Results:
 *	A negative result means that the first element comes before the
 *	second, and a positive result means that the second element should
 *	come first. A result of zero means the two elements are equal and it
 *	doesn't matter which comes first.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _DictionaryCompare(tls *libc.TLS, left uintptr, right uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The strings to compare. */
	var diff, secondaryDiff, uniLeftLower, uniRightLower, zeros int32
	var v1, v2 int64
	var _ /* uniLeft at bp+0 */ int32
	var _ /* uniRight at bp+4 */ int32
	_, _, _, _, _, _, _ = diff, secondaryDiff, uniLeftLower, uniRightLower, zeros, v1, v2
	*(*int32)(unsafe.Pointer(bp)) = 0
	*(*int32)(unsafe.Pointer(bp + 4)) = 0
	secondaryDiff = 0
	for int32(1) != 0 {
		if libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(right)))-uint32('0') < uint32(10)) != 0 && libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(left)))-uint32('0') < uint32(10)) != 0 { /* INTL: digit */
			/*
			 * There are decimal numbers embedded in the two strings. Compare
			 * them as numbers, rather than strings. If one number has more
			 * leading zeros than the other, the number with more leading
			 * zeros sorts later, but only as a secondary choice.
			 */
			zeros = 0
			for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(right))) == int32('0') && libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(right + 1)))-uint32('0') < uint32(10)) != 0 {
				right++
				zeros--
			}
			for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(left))) == int32('0') && libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(left + 1)))-uint32('0') < uint32(10)) != 0 {
				left++
				zeros++
			}
			if secondaryDiff == 0 {
				secondaryDiff = zeros
			}
			/*
			 * The code below compares the numbers in the two strings without
			 * ever converting them to integers. It does this by first
			 * comparing the lengths of the numbers and then comparing the
			 * digit values.
			 */
			diff = 0
			for int32(1) != 0 {
				if diff == 0 {
					diff = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(left))) - libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(right)))
				}
				right++
				left++
				if !(libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(right)))-libc.Uint32FromUint8('0') < libc.Uint32FromInt32(10)) != 0) { /* INTL: digit */
					if libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(left)))-uint32('0') < uint32(10)) != 0 { /* INTL: digit */
						return int32(1)
					} else {
						/*
						 * The two numbers have the same length. See if their
						 * values are different.
						 */
						if diff != 0 {
							return diff
						}
						break
					}
				} else {
					if !(libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(left)))-libc.Uint32FromUint8('0') < libc.Uint32FromInt32(10)) != 0) { /* INTL: digit */
						return -int32(1)
					}
				}
			}
			continue
		}
		/*
		 * Convert character to Unicode for comparison purposes. If either
		 * string is at the terminating null, do a byte-wise comparison and
		 * bail out immediately.
		 */
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(left))) != int32('\000') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(right))) != int32('\000') {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(left))) < int32(0x80) {
				*(*int32)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(left)))
				v1 = int64(libc.Int32FromInt32(1))
			} else {
				v1 = XTcl_UtfToUniChar(tls, left, bp)
			}
			left += uintptr(v1)
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(right))) < int32(0x80) {
				*(*int32)(unsafe.Pointer(bp + 4)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(right)))
				v2 = int64(libc.Int32FromInt32(1))
			} else {
				v2 = XTcl_UtfToUniChar(tls, right, bp+4)
			}
			right += uintptr(v2)
			/*
			 * Convert both chars to lower for the comparison, because
			 * dictionary sorts are case-insensitive. Covert to lower, not
			 * upper, so chars between Z and a will sort before A (where most
			 * other interesting punctuations occur).
			 */
			uniLeftLower = XTcl_UniCharToLower(tls, *(*int32)(unsafe.Pointer(bp)))
			uniRightLower = XTcl_UniCharToLower(tls, *(*int32)(unsafe.Pointer(bp + 4)))
		} else {
			diff = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(left))) - libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(right)))
			break
		}
		diff = uniLeftLower - uniRightLower
		if diff != 0 {
			return diff
		}
		if secondaryDiff == 0 {
			if XTcl_UniCharIsUpper(tls, *(*int32)(unsafe.Pointer(bp))) != 0 && XTcl_UniCharIsLower(tls, *(*int32)(unsafe.Pointer(bp + 4))) != 0 {
				secondaryDiff = -int32(1)
			} else {
				if XTcl_UniCharIsUpper(tls, *(*int32)(unsafe.Pointer(bp + 4))) != 0 && XTcl_UniCharIsLower(tls, *(*int32)(unsafe.Pointer(bp))) != 0 {
					secondaryDiff = int32(1)
				}
			}
		}
	}
	if diff == 0 {
		diff = secondaryDiff
	}
	return diff
}

/*
 *----------------------------------------------------------------------
 *
 * SelectObjFromSublist --
 *
 *	This procedure is invoked from lsearch and SortCompare. It is used for
 *	implementing the -index option, for the lsort and lsearch commands.
 *
 * Results:
 *	Returns NULL if a failure occurs, and sets the result in the infoPtr.
 *	Otherwise returns the Tcl_Obj* to the item.
 *
 * Side effects:
 *	None.
 *
 * Note:
 *	No reference counting is done, as the result is only used internally
 *	and never passed directly to user code.
 *
 *----------------------------------------------------------------------
 */

func _SelectObjFromSublist(tls *libc.TLS, objPtr1 uintptr, infoPtr uintptr) (r uintptr) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Information passed from the top-level
	 * "lsearch" or "lsort" command. */
	var _objPtr, lastObj, v4, v5, v6, v8 uintptr
	var i, v7 TTcl_Size
	var index, v2 int32
	var v3 int64
	var _ /* currentObj at bp+8 */ uintptr
	var _ /* listLen at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _ = _objPtr, i, index, lastObj, v2, v3, v4, v5, v6, v7, v8
	/*
	 * Quick check for case when no "-index" option is there.
	 */
	if (*TSortInfo)(unsafe.Pointer(infoPtr)).Findexc == 0 {
		return objPtr1
	}
	/*
	 * Iterate over the indices, traversing through the nested sublists as we
	 * go.
	 */
	i = 0
	for {
		if !(i < (*TSortInfo)(unsafe.Pointer(infoPtr)).Findexc) {
			break
		}
		lastObj = libc.UintptrFromInt32(0)
		if (*TTcl_Obj)(unsafe.Pointer(objPtr1)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr1 + 32))).Fptr2 != 0 {
				v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr1 + 32))).Fptr2)).FspanLength
			} else {
				v3 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr1 + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp)) = v3
			v2 = libc.Int32FromInt32(TCL_OK)
		} else {
			v2 = XTcl_ListObjLength(tls, (*TSortInfo)(unsafe.Pointer(infoPtr)).Finterp, objPtr1, bp)
		}
		if v2 != TCL_OK {
			(*TSortInfo)(unsafe.Pointer(infoPtr)).FresultCode = int32(TCL_ERROR)
			return libc.UintptrFromInt32(0)
		}
		index = int32(XTclIndexDecode(tls, *(*int32)(unsafe.Pointer((*TSortInfo)(unsafe.Pointer(infoPtr)).Findexv + uintptr(i)*4)), *(*TTcl_Size)(unsafe.Pointer(bp))-int64(1)))
		if XTcl_ListObjIndex(tls, (*TSortInfo)(unsafe.Pointer(infoPtr)).Finterp, objPtr1, int64(index), bp+8) != TCL_OK {
			(*TSortInfo)(unsafe.Pointer(infoPtr)).FresultCode = int32(TCL_ERROR)
			return libc.UintptrFromInt32(0)
		}
		if *(*uintptr)(unsafe.Pointer(bp + 8)) == libc.UintptrFromInt32(0) {
			if int64(index) == int64(-libc.Int32FromInt32(1)) {
				index = int32(int64(-libc.Int32FromInt32(2)) - int64(*(*int32)(unsafe.Pointer((*TSortInfo)(unsafe.Pointer(infoPtr)).Findexv + uintptr(i)*4))))
				if (*TTcl_Obj)(unsafe.Pointer(objPtr1)).Fbytes != 0 {
					v4 = (*TTcl_Obj)(unsafe.Pointer(objPtr1)).Fbytes
				} else {
					v4 = XTcl_GetStringFromObj(tls, objPtr1, libc.UintptrFromInt32(0))
				}
				XTcl_SetObjResult(tls, (*TSortInfo)(unsafe.Pointer(infoPtr)).Finterp, XTcl_ObjPrintf(tls, __ccgo_ts+18549, libc.VaList(bp+24, index, v4)))
			} else {
				if (*TTcl_Obj)(unsafe.Pointer(objPtr1)).Fbytes != 0 {
					v5 = (*TTcl_Obj)(unsafe.Pointer(objPtr1)).Fbytes
				} else {
					v5 = XTcl_GetStringFromObj(tls, objPtr1, libc.UintptrFromInt32(0))
				}
				XTcl_SetObjResult(tls, (*TSortInfo)(unsafe.Pointer(infoPtr)).Finterp, XTcl_ObjPrintf(tls, __ccgo_ts+18590, libc.VaList(bp+24, index, v5)))
			}
			XTcl_SetErrorCode(tls, (*TSortInfo)(unsafe.Pointer(infoPtr)).Finterp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+18377, __ccgo_ts+18627, libc.UintptrFromInt32(0)))
			(*TSortInfo)(unsafe.Pointer(infoPtr)).FresultCode = int32(TCL_ERROR)
			return libc.UintptrFromInt32(0)
		}
		objPtr1 = *(*uintptr)(unsafe.Pointer(bp + 8))
		v6 = lastObj
		if v6 != 0 {
			if (*TTcl_Obj)(unsafe.Pointer(v6)).FrefCount == libc.Int64FromInt32(0) {
				_objPtr = v6
				v8 = _objPtr
				v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
				*(*TTcl_Size)(unsafe.Pointer(v8))--
				if v7 <= libc.Int64FromInt32(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
		}
		lastObj = *(*uintptr)(unsafe.Pointer(bp + 8))
		goto _1
	_1:
		;
		i++
	}
	return objPtr1
}

const CONCAT_TRIM_SET = " \\f\\v\\r\\t\\n"

/*
 *----------------------------------------------------------------------
 *
 * Tcl_PwdObjCmd --
 *
 *	This procedure is invoked to process the "pwd" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_PwdObjCmd(tls *libc.TLS, dummy89 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var _objPtr, retVal, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _ = _objPtr, retVal, v1, v2
	if objc != int32(1) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, libc.UintptrFromInt32(0))
		return int32(TCL_ERROR)
	}
	retVal = XTcl_FSGetCwd(tls, interp)
	if retVal == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, retVal)
	_objPtr = retVal
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_RegexpObjCmd --
 *
 *	This procedure is invoked to process the "regexp" Tcl command. See
 *	the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_RegexpObjCmd(tls *libc.TLS, dummy129 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(112)
	defer tls.Free(112) /* Argument objects. */
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, cachePtr, cachePtr1, cachePtr2, cachePtr3, name, newPtr, objPtr, resultPtr, startIndex, v10, v13, v2, v21, v23, v6 uintptr
	var about, all, doinline, i, indices, match, numMatchesSaved, v14, v24, v3, v4 int32
	var cflags, eflags, end, matchLength, start, stringLength, v12, v20, v22, v5, v9 TTcl_Size
	var regExpr TTcl_RegExp
	var v15, v17, v18, v19 bool
	var _ /* index at bp+32 */ int32
	var _ /* info at bp+8 */ TTcl_RegExpInfo
	var _ /* objs at bp+48 */ [2]uintptr
	var _ /* offset at bp+0 */ TTcl_Size
	var _ /* temp at bp+40 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, about, all, cachePtr, cachePtr1, cachePtr2, cachePtr3, cflags, doinline, eflags, end, i, indices, match, matchLength, name, newPtr, numMatchesSaved, objPtr, regExpr, resultPtr, start, startIndex, stringLength, v10, v12, v13, v14, v15, v17, v18, v19, v2, v20, v21, v22, v23, v24, v3, v4, v5, v6, v9
	startIndex = libc.UintptrFromInt32(0)
	resultPtr = libc.UintptrFromInt32(0)
	indices = 0
	about = 0
	cflags = int64(TCL_REG_ADVANCED)
	*(*TTcl_Size)(unsafe.Pointer(bp)) = libc.Int64FromInt32(0)
	all = 0
	doinline = 0
	i = int32(1)
	for {
		if !(i < objc) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		name = v2
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) != int32('-') {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_options4)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(TCL_EXACT)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+32) != TCL_OK {
			goto optionError
		}
		switch *(*int32)(unsafe.Pointer(bp + 32)) {
		case 0:
			all = int32(1)
		case 2:
			indices = int32(1)
		case 3:
			doinline = int32(1)
		case 8:
			cflags |= int64(TCL_REG_NOCASE)
		case 1:
			about = int32(1)
		case 4:
			cflags |= int64(TCL_REG_EXPANDED)
		case 5:
			cflags |= int64(TCL_REG_NEWLINE)
		case 6:
			cflags |= int64(TCL_REG_NLSTOP)
		case 7:
			cflags |= int64(TCL_REG_NLANCH)
		case 9:
			i++
			v3 = i
			if v3 >= objc {
				goto endOfForLoop
			}
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep)) <= int64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))-libc.Int64FromInt32(1)) {
				*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep))
				v4 = libc.Int32FromInt32(TCL_OK)
			} else {
				v4 = XTcl_GetIntForIndex(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))-libc.Int64FromInt32(1), bp+40)
			}
			if v4 != TCL_OK {
				goto optionError
			}
			if startIndex != 0 {
				_objPtr = startIndex
				v6 = _objPtr
				v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
				*(*TTcl_Size)(unsafe.Pointer(v6))--
				if v5 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
			startIndex = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
			(*TTcl_Obj)(unsafe.Pointer(startIndex)).FrefCount++
		case 10:
			i++
			goto endOfForLoop
		}
		goto _1
	_1:
		;
		i++
	}
	goto endOfForLoop
endOfForLoop:
	;
	if objc-i < int32(2)-about {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+18687)
		goto optionError
	}
	objc -= i
	objv += uintptr(i) * 8
	/*
	 * Check if the user requested -inline, but specified match variables; a
	 * no-no.
	 */
	if doinline != 0 && objc-int32(2) != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+18741, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+72, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+18795, __ccgo_ts+18802, libc.UintptrFromInt32(0)))
		goto optionError
	}
	/*
	 * Handle the odd about case separately.
	 */
	if !(about != 0) {
		goto _7
	}
	regExpr = XTcl_GetRegExpFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv)), int32(cflags))
	if !(regExpr == libc.UintptrFromInt32(0) || XTclRegAbout(tls, interp, regExpr) < 0) {
		goto _8
	}
	goto optionError
optionError:
	;
	if startIndex != 0 {
		_objPtr1 = startIndex
		v10 = _objPtr1
		v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
		*(*TTcl_Size)(unsafe.Pointer(v10))--
		if v9 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
	return int32(TCL_ERROR)
_8:
	;
	return TCL_OK
_7:
	;
	/*
	 * Get the length of the string that we are matching against so we can do
	 * the termination test for -all matches. Do this before getting the
	 * regexp to avoid shimmering problems.
	 */
	objPtr = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	stringLength = XTcl_GetCharLength(tls, objPtr)
	if startIndex != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(startIndex)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(startIndex)).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(startIndex)).FinternalRep)) <= stringLength {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(startIndex)).FinternalRep))
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_GetIntForIndex(tls, interp, startIndex, stringLength, bp)
		}
		_objPtr2 = startIndex
		v13 = _objPtr2
		v12 = *(*TTcl_Size)(unsafe.Pointer(v13))
		*(*TTcl_Size)(unsafe.Pointer(v13))--
		if v12 <= int64(1) {
			XTclFreeObj(tls, _objPtr2)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp)) < 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = libc.Int64FromInt32(0)
		}
	}
	regExpr = XTcl_GetRegExpFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv)), int32(cflags))
	if regExpr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	objc -= int32(2)
	objv += uintptr(2) * 8
	if doinline != 0 {
		/*
		 * Save all the subexpressions, as we will return them as a list
		 */
		numMatchesSaved = -int32(1)
	} else {
		/*
		 * Save only enough subexpressions for matches we want to keep, expect
		 * in the case of -all, where we need to keep at least one to know
		 * where to move the offset.
		 */
		if objc == 0 {
			v14 = all
		} else {
			v14 = objc
		}
		numMatchesSaved = v14
	}
	/*
	 * The following loop is to handle multiple matches within the same source
	 * string; each iteration handles one match. If "-all" hasn't been
	 * specified then the loop body only gets executed once. We terminate the
	 * loop when the starting offset is past the end of the string.
	 */
	for int32(1) != 0 {
		/*
		 * Pass either 0 or TCL_REG_NOTBOL in the eflags. Passing
		 * TCL_REG_NOTBOL indicates that the character at offset should not be
		 * considered the start of the line. If for example the pattern {^} is
		 * passed and -start is positive, then the pattern will not match the
		 * start of the string unless the previous character is a newline.
		 */
		if *(*TTcl_Size)(unsafe.Pointer(bp)) == libc.Int64FromInt32(0) {
			eflags = 0
		} else {
			if *(*TTcl_Size)(unsafe.Pointer(bp)) > stringLength {
				eflags = int64(TCL_REG_NOTBOL)
			} else {
				if XTcl_GetUniChar(tls, objPtr, *(*TTcl_Size)(unsafe.Pointer(bp))-int64(1)) == int32('\n') {
					eflags = 0
				} else {
					eflags = int64(TCL_REG_NOTBOL)
				}
			}
		}
		match = XTcl_RegExpExecObj(tls, interp, regExpr, objPtr, *(*TTcl_Size)(unsafe.Pointer(bp)), int64(numMatchesSaved), int32(eflags))
		if match < 0 {
			return int32(TCL_ERROR)
		}
		if match == 0 {
			/*
			 * We want to set the value of the interpreter result only when
			 * this is the first time through the loop.
			 */
			if all <= int32(1) {
				/*
				 * If inlining, the interpreter's object result remains an
				 * empty list, otherwise set it to an integer object w/ value
				 * 0.
				 */
				if !(doinline != 0) {
					XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, 0))
				}
				return TCL_OK
			}
			break
		}
		/*
		 * If additional variable names have been specified, return index
		 * information in those variables.
		 */
		XTcl_RegExpGetInfo(tls, regExpr, bp+8)
		if doinline != 0 {
			/*
			 * It's the number of substitutions, plus one for the matchVar at
			 * index 0
			 */
			objc = int32((*(*TTcl_RegExpInfo)(unsafe.Pointer(bp + 8))).Fnsubs + int64(1))
			if all <= int32(1) {
				if v15 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v15 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v15 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
					resultPtr = XTclThreadAllocObj(tls)
				} else {
					resultPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(resultPtr + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Flength = 0
				(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FtypePtr = libc.UintptrFromInt32(0)
			}
		}
		i = 0
		for {
			if !(i < objc) {
				break
			}
			if indices != 0 {
				/*
				 * Only adjust the match area if there was a match for that
				 * area. (Scriptics Bug 4391/SF Bug #219232)
				 */
				if i <= int32((*(*TTcl_RegExpInfo)(unsafe.Pointer(bp + 8))).Fnsubs) && (*(*TTcl_RegExpIndices)(unsafe.Pointer((*(*TTcl_RegExpInfo)(unsafe.Pointer(bp + 8))).Fmatches + uintptr(i)*16))).Fstart >= 0 {
					start = *(*TTcl_Size)(unsafe.Pointer(bp)) + (*(*TTcl_RegExpIndices)(unsafe.Pointer((*(*TTcl_RegExpInfo)(unsafe.Pointer(bp + 8))).Fmatches + uintptr(i)*16))).Fstart
					end = *(*TTcl_Size)(unsafe.Pointer(bp)) + (*(*TTcl_RegExpIndices)(unsafe.Pointer((*(*TTcl_RegExpInfo)(unsafe.Pointer(bp + 8))).Fmatches + uintptr(i)*16))).Fend
					/*
					 * Adjust index so it refers to the last character in the
					 * match instead of the first character after the match.
					 */
					if end >= *(*TTcl_Size)(unsafe.Pointer(bp)) {
						end--
					}
				} else {
					start = int64(-libc.Int32FromInt32(1))
					end = int64(-libc.Int32FromInt32(1))
				}
				if v17 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v17 {
					cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v17 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
					(*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[0] = XTclThreadAllocObj(tls)
				} else {
					(*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[0] = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[0] + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[0])).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[0])).Fbytes = libc.UintptrFromInt32(0)
				*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[0])).FinternalRep)) = start
				(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[0])).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
				if v18 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v18 {
					cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v18 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
					(*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[int32(1)] = XTclThreadAllocObj(tls)
				} else {
					(*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[int32(1)] = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[int32(1)] + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[int32(1)])).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[int32(1)])).Fbytes = libc.UintptrFromInt32(0)
				*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[int32(1)])).FinternalRep)) = end
				(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[int32(1)])).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
				newPtr = XTcl_NewListObj(tls, int64(2), bp+48)
			} else {
				if i <= int32((*(*TTcl_RegExpInfo)(unsafe.Pointer(bp + 8))).Fnsubs) && (*(*TTcl_RegExpIndices)(unsafe.Pointer((*(*TTcl_RegExpInfo)(unsafe.Pointer(bp + 8))).Fmatches + uintptr(i)*16))).Fend > 0 {
					newPtr = XTcl_GetRange(tls, objPtr, *(*TTcl_Size)(unsafe.Pointer(bp))+(*(*TTcl_RegExpIndices)(unsafe.Pointer((*(*TTcl_RegExpInfo)(unsafe.Pointer(bp + 8))).Fmatches + uintptr(i)*16))).Fstart, *(*TTcl_Size)(unsafe.Pointer(bp))+(*(*TTcl_RegExpIndices)(unsafe.Pointer((*(*TTcl_RegExpInfo)(unsafe.Pointer(bp + 8))).Fmatches + uintptr(i)*16))).Fend-int64(1))
				} else {
					if v19 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v19 {
						cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v19 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
						newPtr = XTclThreadAllocObj(tls)
					} else {
						newPtr = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(newPtr + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer(newPtr)).FrefCount = 0
					(*TTcl_Obj)(unsafe.Pointer(newPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(newPtr)).Flength = 0
					(*TTcl_Obj)(unsafe.Pointer(newPtr)).FtypePtr = libc.UintptrFromInt32(0)
				}
			}
			if doinline != 0 {
				if XTcl_ListObjAppendElement(tls, interp, resultPtr, newPtr) != TCL_OK {
					_objPtr3 = newPtr
					v21 = _objPtr3
					v20 = *(*TTcl_Size)(unsafe.Pointer(v21))
					*(*TTcl_Size)(unsafe.Pointer(v21))--
					if v20 <= int64(1) {
						XTclFreeObj(tls, _objPtr3)
					}
					_objPtr4 = resultPtr
					v23 = _objPtr4
					v22 = *(*TTcl_Size)(unsafe.Pointer(v23))
					*(*TTcl_Size)(unsafe.Pointer(v23))--
					if v22 <= int64(1) {
						XTclFreeObj(tls, _objPtr4)
					}
					return int32(TCL_ERROR)
				}
			} else {
				if XTcl_ObjSetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0), newPtr, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
					return int32(TCL_ERROR)
				}
			}
			goto _16
		_16:
			;
			i++
		}
		if all == 0 {
			break
		}
		/*
		 * Adjust the offset to the character just after the last one in the
		 * matchVar and increment all to count how many times we are making a
		 * match. We always increment the offset by at least one to prevent
		 * endless looping (as in the case: regexp -all {a*} a). Otherwise,
		 * when we match the NULL string at the end of the input string, we
		 * will loop indefinitely (because the length of the match is 0, so
		 * offset never changes).
		 */
		matchLength = (*(*TTcl_RegExpIndices)(unsafe.Pointer((*(*TTcl_RegExpInfo)(unsafe.Pointer(bp + 8))).Fmatches))).Fend - (*(*TTcl_RegExpIndices)(unsafe.Pointer((*(*TTcl_RegExpInfo)(unsafe.Pointer(bp + 8))).Fmatches))).Fstart
		*(*TTcl_Size)(unsafe.Pointer(bp)) += (*(*TTcl_RegExpIndices)(unsafe.Pointer((*(*TTcl_RegExpInfo)(unsafe.Pointer(bp + 8))).Fmatches))).Fend
		/*
		 * A match of length zero could happen for {^} {$} or {.*} and in
		 * these cases we always want to bump the index up one.
		 */
		if matchLength == 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp))++
		}
		all++
		if *(*TTcl_Size)(unsafe.Pointer(bp)) >= stringLength {
			break
		}
	}
	/*
	 * Set the interpreter's object result to an integer object with value 1
	 * if -all wasn't specified, otherwise it's all-1 (the number of times
	 * through the while - 1).
	 */
	if doinline != 0 {
		XTcl_SetObjResult(tls, interp, resultPtr)
	} else {
		if all != 0 {
			v24 = all - int32(1)
		} else {
			v24 = int32(1)
		}
		XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, int64(v24)))
	}
	return TCL_OK
}

var _options4 = [12]uintptr{
	0:  __ccgo_ts + 17462,
	1:  __ccgo_ts + 18639,
	2:  __ccgo_ts + 18245,
	3:  __ccgo_ts + 17538,
	4:  __ccgo_ts + 18646,
	5:  __ccgo_ts + 18656,
	6:  __ccgo_ts + 18662,
	7:  __ccgo_ts + 18672,
	8:  __ccgo_ts + 17555,
	9:  __ccgo_ts + 17590,
	10: __ccgo_ts + 18684,
	11: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_RegsubObjCmd --
 *
 *	This procedure is invoked to process the "regsub" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_RegsubObjCmd(tls *libc.TLS, dummy488 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(144)
	defer tls.Free(144) /* Argument objects. */
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, args, cachePtr, name, objPtr, p, resultPtr, startIndex, strCmpFn, subPtr, wend, wfirstChar, wsrc, wstring, wsubspec, v12, v13, v15, v17, v2, v21, v32, v34, v37, v39, v41, v6, v9 uintptr
	var all, cflags, command, match, nocase, result, wsrclc, v22, v25, v4 int32
	var ch TTcl_UniChar
	var end, idx, numArgs, numMatches, start, stringLength, subEnd, subStart, v11, v3, v31, v36, v38, v40, v5, v8 TTcl_Size
	var regExpr TTcl_RegExp
	var v14, v16, v33 bool
	var v18, v23, v27, v28 int64
	var _ /* index at bp+56 */ int32
	var _ /* info at bp+32 */ TTcl_RegExpInfo
	var _ /* numParts at bp+24 */ TTcl_Size
	var _ /* offset at bp+16 */ TTcl_Size
	var _ /* parts at bp+80 */ uintptr
	var _ /* slen at bp+72 */ TTcl_Size
	var _ /* temp at bp+64 */ TTcl_Size
	var _ /* wlen at bp+0 */ TTcl_Size
	var _ /* wsublen at bp+8 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, all, args, cachePtr, cflags, ch, command, end, idx, match, name, nocase, numArgs, numMatches, objPtr, p, regExpr, result, resultPtr, start, startIndex, strCmpFn, stringLength, subEnd, subPtr, subStart, wend, wfirstChar, wsrc, wsrclc, wstring, wsubspec, v11, v12, v13, v14, v15, v16, v17, v18, v2, v21, v22, v23, v25, v27, v28, v3, v31, v32, v33, v34, v36, v37, v38, v39, v4, v40, v41, v5, v6, v8, v9
	*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0
	startIndex = libc.UintptrFromInt32(0)
	wsubspec = uintptr(0)
	cflags = int32(TCL_REG_ADVANCED)
	all = 0
	*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = libc.Int64FromInt32(0)
	command = 0
	resultPtr = libc.UintptrFromInt32(0)
	idx = int64(1)
	for {
		if !(idx < int64(objc)) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(idx)*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(idx)*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(idx)*8)), libc.UintptrFromInt32(0))
		}
		name = v2
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) != int32('-') {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(idx)*8)), uintptr(unsafe.Pointer(&_options5)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(TCL_EXACT)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+56) != TCL_OK {
			goto optionError
		}
		switch *(*int32)(unsafe.Pointer(bp + 56)) {
		case 0:
			all = int32(1)
		case 6:
			cflags |= int32(TCL_REG_NOCASE)
		case 1:
			command = int32(1)
		case 2:
			cflags |= int32(TCL_REG_EXPANDED)
		case 3:
			cflags |= int32(TCL_REG_NEWLINE)
		case 4:
			cflags |= int32(TCL_REG_NLSTOP)
		case 5:
			cflags |= int32(TCL_REG_NLANCH)
		case 7:
			idx++
			v3 = idx
			if v3 >= int64(objc) {
				goto endOfForLoop
			}
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(idx)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(idx)*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(idx)*8)))).FinternalRep)) <= int64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))-libc.Int64FromInt32(1)) {
				*(*TTcl_Size)(unsafe.Pointer(bp + 64)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(idx)*8)))).FinternalRep))
				v4 = libc.Int32FromInt32(TCL_OK)
			} else {
				v4 = XTcl_GetIntForIndex(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(idx)*8)), libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))-libc.Int64FromInt32(1), bp+64)
			}
			if v4 != TCL_OK {
				goto optionError
			}
			if startIndex != 0 {
				_objPtr = startIndex
				v6 = _objPtr
				v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
				*(*TTcl_Size)(unsafe.Pointer(v6))--
				if v5 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
			startIndex = *(*uintptr)(unsafe.Pointer(objv + uintptr(idx)*8))
			(*TTcl_Obj)(unsafe.Pointer(startIndex)).FrefCount++
		case 8:
			idx++
			goto endOfForLoop
		}
		goto _1
	_1:
		;
		idx++
	}
	goto endOfForLoop
endOfForLoop:
	;
	if !(int64(objc) < idx+int64(3) || int64(objc) > idx+int64(4)) {
		goto _7
	}
	XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+18817)
	goto optionError
optionError:
	;
	if startIndex != 0 {
		_objPtr1 = startIndex
		v9 = _objPtr1
		v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
		*(*TTcl_Size)(unsafe.Pointer(v9))--
		if v8 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
	return int32(TCL_ERROR)
_7:
	;
	objc = int32(int64(objc) - idx)
	objv += uintptr(idx) * 8
	if startIndex != 0 {
		stringLength = XTcl_GetCharLength(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
		if (*TTcl_Obj)(unsafe.Pointer(startIndex)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(startIndex)).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(startIndex)).FinternalRep)) <= stringLength {
			*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(startIndex)).FinternalRep))
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_GetIntForIndex(tls, interp, startIndex, stringLength, bp+16)
		}
		_objPtr2 = startIndex
		v12 = _objPtr2
		v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
		*(*TTcl_Size)(unsafe.Pointer(v12))--
		if v11 <= int64(1) {
			XTclFreeObj(tls, _objPtr2)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) < 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = 0
		}
	}
	if v14 = all != 0 && *(*TTcl_Size)(unsafe.Pointer(bp + 16)) == 0 && command == 0; v14 {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v13 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v13 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
	}
	if v16 = v14 && libc.Xstrpbrk(tls, v13, __ccgo_ts+18860) == libc.UintptrFromInt32(0); v16 {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes != 0 {
			v15 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes
		} else {
			v15 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv)), libc.UintptrFromInt32(0))
		}
	}
	if v16 && libc.Xstrpbrk(tls, v15, __ccgo_ts+18863) == libc.UintptrFromInt32(0) {
		numMatches = 0
		nocase = cflags & int32(TCL_REG_NOCASE)
		if nocase != 0 {
			v17 = __ccgo_fp(XTclUniCharNcasecmp)
		} else {
			v17 = __ccgo_fp(XTclUniCharNcmp)
		}
		strCmpFn = v17
		wsrc = XTcl_GetUnicodeFromObj(tls, *(*uintptr)(unsafe.Pointer(objv)), bp+72)
		wstring = XTcl_GetUnicodeFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
		wsubspec = XTcl_GetUnicodeFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp+8)
		if *(*TTcl_Size)(unsafe.Pointer(bp + 72)) != 0 {
			v18 = *(*TTcl_Size)(unsafe.Pointer(bp + 72)) - int64(1)
		} else {
			v18 = 0
		}
		wend = wstring + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))*4 - uintptr(v18)*4
		result = TCL_OK
		if *(*TTcl_Size)(unsafe.Pointer(bp + 72)) == 0 {
			/*
			 * regsub behavior for "" matches between each character. 'string
			 * map' skips the "" case.
			 */
			if wstring < wend {
				resultPtr = XTcl_NewUnicodeObj(tls, wstring, 0)
				(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount++
				for {
					if !(wstring < wend) {
						break
					}
					XTcl_AppendUnicodeToObj(tls, resultPtr, wsubspec, *(*TTcl_Size)(unsafe.Pointer(bp + 8)))
					XTcl_AppendUnicodeToObj(tls, resultPtr, wstring, int64(1))
					numMatches++
					goto _19
				_19:
					;
					wstring += 4
				}
				*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
			}
		} else {
			wsrclc = XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(wsrc)))
			v21 = wstring
			wfirstChar = v21
			p = v21
			for {
				if !(wstring < wend) {
					break
				}
				if (*(*TTcl_UniChar)(unsafe.Pointer(wstring)) == *(*TTcl_UniChar)(unsafe.Pointer(wsrc)) || nocase != 0 && XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(wstring))) == wsrclc) && (*(*TTcl_Size)(unsafe.Pointer(bp + 72)) == int64(1) || (*(*func(*libc.TLS, uintptr, uintptr, Tsize_t) int32)(unsafe.Pointer(&struct{ uintptr }{strCmpFn})))(tls, wstring, wsrc, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 72)))) == 0) {
					if numMatches == 0 {
						resultPtr = XTcl_NewUnicodeObj(tls, wstring, 0)
						(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount++
					}
					if p != wstring {
						XTcl_AppendUnicodeToObj(tls, resultPtr, p, (int64(wstring)-int64(p))/4)
						p = wstring + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 72)))*4
					} else {
						p += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 72))) * 4
					}
					wstring = p - uintptr(1)*4
					XTcl_AppendUnicodeToObj(tls, resultPtr, wsubspec, *(*TTcl_Size)(unsafe.Pointer(bp + 8)))
					numMatches++
				}
				goto _20
			_20:
				;
				wstring += 4
			}
			if numMatches != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp)) = (int64(wfirstChar+uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))*4) - int64(p)) / 4
				wstring = p
			}
		}
		objPtr = libc.UintptrFromInt32(0)
		subPtr = libc.UintptrFromInt32(0)
		goto regsubDone
	}
	regExpr = XTcl_GetRegExpFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv)), cflags)
	if regExpr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if command != 0 {
		/*
		 * In command-prefix mode, we require that the third non-option
		 * argument be a list, so we enforce that here. Afterwards, we fetch
		 * the RE compilation again in case objv[0] and objv[2] are the same
		 * object. (If they aren't, that's cheap to do.)
		 */
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)) + 32))).Fptr2 != 0 {
				v23 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)) + 32))).Fptr2)).FspanLength
			} else {
				v23 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = v23
			v22 = libc.Int32FromInt32(TCL_OK)
		} else {
			v22 = XTcl_ListObjLength(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp+24)
		}
		if v22 != TCL_OK {
			return int32(TCL_ERROR)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 24)) < int64(1) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+18878, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+96, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+18932, __ccgo_ts+18939, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		regExpr = XTcl_GetRegExpFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv)), cflags)
	}
	/*
	 * Make sure to avoid problems where the objects are shared. This can
	 * cause RegExpObj <> UnicodeObj shimmering that causes data corruption.
	 * [Bug #461322]
	 */
	if *(*uintptr)(unsafe.Pointer(objv + 1*8)) == *(*uintptr)(unsafe.Pointer(objv)) {
		objPtr = XTcl_DuplicateObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	} else {
		objPtr = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	}
	wstring = XTcl_GetUnicodeFromObj(tls, objPtr, bp)
	if *(*uintptr)(unsafe.Pointer(objv + 2*8)) == *(*uintptr)(unsafe.Pointer(objv)) {
		subPtr = XTcl_DuplicateObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
	} else {
		subPtr = *(*uintptr)(unsafe.Pointer(objv + 2*8))
	}
	if !(command != 0) {
		wsubspec = XTcl_GetUnicodeFromObj(tls, subPtr, bp+8)
	}
	result = TCL_OK
	/*
	 * The following loop is to handle multiple matches within the same source
	 * string; each iteration handles one match and its corresponding
	 * substitution. If "-all" hasn't been specified then the loop body only
	 * gets executed once. We must use 'offset <= wlen' in particular for the
	 * case where the regexp pattern can match the empty string - this is
	 * useful when doing, say, 'regsub -- ^ $str ...' when $str might be
	 * empty.
	 */
	numMatches = 0
	for {
		if !(*(*TTcl_Size)(unsafe.Pointer(bp + 16)) <= *(*TTcl_Size)(unsafe.Pointer(bp))) {
			break
		}
		/*
		 * The flags argument is set if string is part of a larger string, so
		 * that "^" won't match.
		 */
		if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) > 0 && *(*TTcl_UniChar)(unsafe.Pointer(wstring + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 16))-int64(1))*4)) != libc.Int32FromUint8('\n') {
			v25 = int32(TCL_REG_NOTBOL)
		} else {
			v25 = 0
		}
		match = XTcl_RegExpExecObj(tls, interp, regExpr, objPtr, *(*TTcl_Size)(unsafe.Pointer(bp + 16)), int64(10), v25)
		if match < 0 {
			result = int32(TCL_ERROR)
			goto done
		}
		if match == 0 {
			break
		}
		if numMatches == 0 {
			resultPtr = XTcl_NewUnicodeObj(tls, wstring, 0)
			(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount++
			if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) > libc.Int64FromInt32(0) {
				/*
				 * Copy the initial portion of the string in if an offset was
				 * specified.
				 */
				XTcl_AppendUnicodeToObj(tls, resultPtr, wstring, *(*TTcl_Size)(unsafe.Pointer(bp + 16)))
			}
		}
		numMatches++
		/*
		 * Copy the portion of the source string before the match to the
		 * result variable.
		 */
		XTcl_RegExpGetInfo(tls, regExpr, bp+32)
		start = (*(*TTcl_RegExpIndices)(unsafe.Pointer((*(*TTcl_RegExpInfo)(unsafe.Pointer(bp + 32))).Fmatches))).Fstart
		end = (*(*TTcl_RegExpIndices)(unsafe.Pointer((*(*TTcl_RegExpInfo)(unsafe.Pointer(bp + 32))).Fmatches))).Fend
		XTcl_AppendUnicodeToObj(tls, resultPtr, wstring+uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 16)))*4, start)
		/*
		 * In command-prefix mode, the substitutions are added as quoted
		 * arguments to the subSpec to form a command, that is then executed
		 * and the result used as the string to substitute in. Actually,
		 * everything is passed through Tcl_EvalObjv, as that's much faster.
		 */
		if command != 0 {
			args = libc.UintptrFromInt32(0)
			if (*TTcl_Obj)(unsafe.Pointer(subPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(subPtr + 32))).Fptr2 != 0 {
					v27 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(subPtr + 32))).Fptr2)).FspanStart
				} else {
					v27 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(subPtr + 32))).Fptr1)).FfirstUsed
				}
				*(*uintptr)(unsafe.Pointer(bp + 80)) = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(subPtr + 32))).Fptr1 + 40 + uintptr(v27)*8
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(subPtr + 32))).Fptr2 != 0 {
					v28 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(subPtr + 32))).Fptr2)).FspanLength
				} else {
					v28 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(subPtr + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = v28
				_ = libc.Int32FromInt32(TCL_OK)
			} else {
				XTcl_ListObjGetElements(tls, interp, subPtr, bp+24, bp+80)
			}
			numArgs = *(*TTcl_Size)(unsafe.Pointer(bp + 24)) + (*(*TTcl_RegExpInfo)(unsafe.Pointer(bp + 32))).Fnsubs + int64(1)
			args = XTcl_Alloc(tls, uint64(8)*libc.Uint64FromInt64(numArgs))
			libc.Xmemcpy(tls, args, *(*uintptr)(unsafe.Pointer(bp + 80)), uint64(8)*libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 24))))
			idx = 0
			for {
				if !(idx <= (*(*TTcl_RegExpInfo)(unsafe.Pointer(bp + 32))).Fnsubs) {
					break
				}
				subStart = (*(*TTcl_RegExpIndices)(unsafe.Pointer((*(*TTcl_RegExpInfo)(unsafe.Pointer(bp + 32))).Fmatches + uintptr(idx)*16))).Fstart
				subEnd = (*(*TTcl_RegExpIndices)(unsafe.Pointer((*(*TTcl_RegExpInfo)(unsafe.Pointer(bp + 32))).Fmatches + uintptr(idx)*16))).Fend
				if subStart >= 0 && subEnd >= 0 {
					*(*uintptr)(unsafe.Pointer(args + uintptr(idx+*(*TTcl_Size)(unsafe.Pointer(bp + 24)))*8)) = XTcl_NewUnicodeObj(tls, wstring+uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 16)))*4+uintptr(subStart)*4, subEnd-subStart)
				} else {
					*(*uintptr)(unsafe.Pointer(args + uintptr(idx+*(*TTcl_Size)(unsafe.Pointer(bp + 24)))*8)) = XTcl_NewObj(tls)
				}
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(args + uintptr(idx+*(*TTcl_Size)(unsafe.Pointer(bp + 24)))*8)))).FrefCount++
				goto _29
			_29:
				;
				idx++
			}
			/*
			 * At this point, we're locally holding the references to the
			 * argument words we added for this time round the loop, and the
			 * subPtr is holding the references to the words that the user
			 * supplied directly. None are zero-refcount, which is important
			 * because Tcl_EvalObjv is "hairy monster" in terms of refcount
			 * handling, being able to optionally add references to any of its
			 * argument words. We'll drop the local refs immediately
			 * afterwards; subPtr is handled in the main exit stanza.
			 */
			result = XTcl_EvalObjv(tls, interp, numArgs, args, 0)
			idx = 0
			for {
				if !(idx <= (*(*TTcl_RegExpInfo)(unsafe.Pointer(bp + 32))).Fnsubs) {
					break
				}
				v32 = *(*uintptr)(unsafe.Pointer(args + uintptr(idx+*(*TTcl_Size)(unsafe.Pointer(bp + 24)))*8))
				v31 = *(*TTcl_Size)(unsafe.Pointer(v32))
				*(*TTcl_Size)(unsafe.Pointer(v32))--
				if !(v31 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(args + uintptr(idx+*(*TTcl_Size)(unsafe.Pointer(bp + 24)))*8)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(args + uintptr(idx+*(*TTcl_Size)(unsafe.Pointer(bp + 24)))*8)))).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(args + uintptr(idx+*(*TTcl_Size)(unsafe.Pointer(bp + 24)))*8)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(args + uintptr(idx+*(*TTcl_Size)(unsafe.Pointer(bp + 24)))*8)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(args + uintptr(idx+*(*TTcl_Size)(unsafe.Pointer(bp + 24)))*8)))).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(args + uintptr(idx+*(*TTcl_Size)(unsafe.Pointer(bp + 24)))*8)))).Flength = int64(-libc.Int32FromInt32(1))
						if v33 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v33 {
							cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v33 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(args + uintptr(idx+*(*TTcl_Size)(unsafe.Pointer(bp + 24)))*8)))
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(args + uintptr(idx+*(*TTcl_Size)(unsafe.Pointer(bp + 24)))*8)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(args + uintptr(idx+*(*TTcl_Size)(unsafe.Pointer(bp + 24)))*8))
							(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(args + uintptr(idx+*(*TTcl_Size)(unsafe.Pointer(bp + 24)))*8)))
					}
				}
				goto _30
			_30:
				;
				idx++
			}
			XTclpFree(tls, args)
			if result != TCL_OK {
				if result == int32(TCL_ERROR) {
					XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+18948, libc.VaList(bp+96, _options5[1])))
				}
				goto done
			}
			XTcl_AppendObjToObj(tls, resultPtr, XTcl_GetObjResult(tls, interp))
			XTcl_ResetResult(tls, interp)
			/*
			 * Refetch the unicode, in case the representation was smashed by
			 * the user code.
			 */
			wstring = XTcl_GetUnicodeFromObj(tls, objPtr, bp)
			*(*TTcl_Size)(unsafe.Pointer(bp + 16)) += end
			if end == 0 || start == end {
				/*
				 * Always consume at least one character of the input string
				 * in order to prevent infinite loops, even when we
				 * technically matched the empty string; we must not match
				 * again at the same spot.
				 */
				if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) < *(*TTcl_Size)(unsafe.Pointer(bp)) {
					XTcl_AppendUnicodeToObj(tls, resultPtr, wstring+uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 16)))*4, int64(1))
				}
				*(*TTcl_Size)(unsafe.Pointer(bp + 16))++
			}
			if all != 0 {
				goto _24
			} else {
				break
			}
		}
		/*
		 * Append the subSpec argument to the variable, making appropriate
		 * substitutions. This code is a bit hairy because of the backslash
		 * conventions and because the code saves up ranges of characters in
		 * subSpec to reduce the number of calls to Tcl_SetVar.
		 */
		v34 = wsubspec
		wfirstChar = v34
		wsrc = v34
		wend = wsubspec + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))*4
		ch = *(*TTcl_UniChar)(unsafe.Pointer(wsrc))
		for {
			if !(wsrc != wend) {
				break
			}
			if ch == int32('&') {
				idx = 0
			} else {
				if ch == int32('\\') {
					ch = *(*TTcl_UniChar)(unsafe.Pointer(wsrc + 1*4))
					if ch >= int32('0') && ch <= int32('9') {
						idx = int64(ch - int32('0'))
					} else {
						if ch == int32('\\') || ch == int32('&') {
							*(*TTcl_UniChar)(unsafe.Pointer(wsrc)) = ch
							XTcl_AppendUnicodeToObj(tls, resultPtr, wfirstChar, (int64(wsrc)-int64(wfirstChar))/4+int64(1))
							*(*TTcl_UniChar)(unsafe.Pointer(wsrc)) = int32('\\')
							wfirstChar = wsrc + uintptr(2)*4
							wsrc += 4
							goto _35
						} else {
							goto _35
						}
					}
				} else {
					goto _35
				}
			}
			if wfirstChar != wsrc {
				XTcl_AppendUnicodeToObj(tls, resultPtr, wfirstChar, (int64(wsrc)-int64(wfirstChar))/4)
			}
			if idx <= (*(*TTcl_RegExpInfo)(unsafe.Pointer(bp + 32))).Fnsubs {
				subStart = (*(*TTcl_RegExpIndices)(unsafe.Pointer((*(*TTcl_RegExpInfo)(unsafe.Pointer(bp + 32))).Fmatches + uintptr(idx)*16))).Fstart
				subEnd = (*(*TTcl_RegExpIndices)(unsafe.Pointer((*(*TTcl_RegExpInfo)(unsafe.Pointer(bp + 32))).Fmatches + uintptr(idx)*16))).Fend
				if subStart >= 0 && subEnd >= 0 {
					XTcl_AppendUnicodeToObj(tls, resultPtr, wstring+uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 16)))*4+uintptr(subStart)*4, subEnd-subStart)
				}
			}
			if *(*TTcl_UniChar)(unsafe.Pointer(wsrc)) == int32('\\') {
				wsrc += 4
			}
			wfirstChar = wsrc + uintptr(1)*4
			goto _35
		_35:
			;
			wsrc += 4
			ch = *(*TTcl_UniChar)(unsafe.Pointer(wsrc))
		}
		if wfirstChar != wsrc {
			XTcl_AppendUnicodeToObj(tls, resultPtr, wfirstChar, (int64(wsrc)-int64(wfirstChar))/4)
		}
		if end == 0 {
			/*
			 * Always consume at least one character of the input string in
			 * order to prevent infinite loops.
			 */
			if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) < *(*TTcl_Size)(unsafe.Pointer(bp)) {
				XTcl_AppendUnicodeToObj(tls, resultPtr, wstring+uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 16)))*4, int64(1))
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 16))++
		} else {
			*(*TTcl_Size)(unsafe.Pointer(bp + 16)) += end
			if start == end {
				/*
				 * We matched an empty string, which means we must go forward
				 * one more step so we don't match again at the same spot.
				 */
				if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) < *(*TTcl_Size)(unsafe.Pointer(bp)) {
					XTcl_AppendUnicodeToObj(tls, resultPtr, wstring+uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 16)))*4, int64(1))
				}
				*(*TTcl_Size)(unsafe.Pointer(bp + 16))++
			}
		}
		if !(all != 0) {
			break
		}
		goto _24
	_24:
	}
	/*
	 * Copy the portion of the source string after the last match to the
	 * result variable.
	 */
	goto regsubDone
regsubDone:
	;
	if numMatches == 0 {
		/*
		 * On zero matches, just ignore the offset, since it shouldn't matter
		 * to us in this case, and the user may have skewed it.
		 */
		resultPtr = *(*uintptr)(unsafe.Pointer(objv + 1*8))
		(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount++
	} else {
		if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) < *(*TTcl_Size)(unsafe.Pointer(bp)) {
			XTcl_AppendUnicodeToObj(tls, resultPtr, wstring+uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 16)))*4, *(*TTcl_Size)(unsafe.Pointer(bp))-*(*TTcl_Size)(unsafe.Pointer(bp + 16)))
		}
	}
	if objc == int32(4) {
		if XTcl_ObjSetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0), resultPtr, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
			result = int32(TCL_ERROR)
		} else {
			/*
			 * Set the interpreter's object result to an integer object
			 * holding the number of matches.
			 */
			XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, numMatches))
		}
	} else {
		/*
		 * No varname supplied, so just return the modified string.
		 */
		XTcl_SetObjResult(tls, interp, resultPtr)
	}
	goto done
done:
	;
	if objPtr != 0 && *(*uintptr)(unsafe.Pointer(objv + 1*8)) == *(*uintptr)(unsafe.Pointer(objv)) {
		_objPtr3 = objPtr
		v37 = _objPtr3
		v36 = *(*TTcl_Size)(unsafe.Pointer(v37))
		*(*TTcl_Size)(unsafe.Pointer(v37))--
		if v36 <= int64(1) {
			XTclFreeObj(tls, _objPtr3)
		}
	}
	if subPtr != 0 && *(*uintptr)(unsafe.Pointer(objv + 2*8)) == *(*uintptr)(unsafe.Pointer(objv)) {
		_objPtr4 = subPtr
		v39 = _objPtr4
		v38 = *(*TTcl_Size)(unsafe.Pointer(v39))
		*(*TTcl_Size)(unsafe.Pointer(v39))--
		if v38 <= int64(1) {
			XTclFreeObj(tls, _objPtr4)
		}
	}
	if resultPtr != 0 {
		_objPtr5 = resultPtr
		v41 = _objPtr5
		v40 = *(*TTcl_Size)(unsafe.Pointer(v41))
		*(*TTcl_Size)(unsafe.Pointer(v41))--
		if v40 <= int64(1) {
			XTclFreeObj(tls, _objPtr5)
		}
	}
	return result
}

var _options5 = [10]uintptr{
	0: __ccgo_ts + 17462,
	1: __ccgo_ts + 18236,
	2: __ccgo_ts + 18646,
	3: __ccgo_ts + 18656,
	4: __ccgo_ts + 18662,
	5: __ccgo_ts + 18672,
	6: __ccgo_ts + 17555,
	7: __ccgo_ts + 17590,
	8: __ccgo_ts + 18684,
	9: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_RenameObjCmd --
 *
 *	This procedure is invoked to process the "rename" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl object result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_RenameObjCmd(tls *libc.TLS, dummy1008 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var newName, oldName, v1, v2 uintptr
	_, _, _, _ = newName, oldName, v1, v2
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+18990)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	oldName = v1
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
		v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
	} else {
		v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
	}
	newName = v2
	return XTclRenameCommand(tls, interp, oldName, newName)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ReturnObjCmd --
 *
 *	This object-based procedure is invoked to process the "return" Tcl
 *	command. See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl object result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ReturnObjCmd(tls *libc.TLS, dummy1044 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var explicitResult, numOptionWords int32
	var _ /* code at bp+0 */ int32
	var _ /* level at bp+4 */ int32
	var _ /* returnOpts at bp+8 */ uintptr
	_, _ = explicitResult, numOptionWords
	/*
	 * General syntax: [return ?-option value ...? ?result?]
	 * An even number of words means an explicit result argument is present.
	 */
	explicitResult = libc.BoolInt32(0 == objc%int32(2))
	numOptionWords = objc - int32(1) - explicitResult
	if int32(TCL_ERROR) == XTclMergeReturnOptions(tls, interp, numOptionWords, objv+uintptr(1)*8, bp+8, bp, bp+4) {
		return int32(TCL_ERROR)
	}
	*(*int32)(unsafe.Pointer(bp)) = XTclProcessReturn(tls, interp, *(*int32)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 4)), *(*uintptr)(unsafe.Pointer(bp + 8)))
	if explicitResult != 0 {
		XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))
	}
	return *(*int32)(unsafe.Pointer(bp))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SourceObjCmd --
 *
 *	This procedure is invoked to process the "source" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl object result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SourceObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	return XTcl_NRCallObjProc(tls, interp, __ccgo_fp(XTclNRSourceObjCmd), clientData, int64(objc), objv)
}

func XTclNRSourceObjCmd(tls *libc.TLS, dummy1101 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var encodingName, fileName, names, pkgFiles, v1 uintptr
	var result int32
	var _ /* index at bp+0 */ int32
	var _ /* index at bp+4 */ int32
	_, _, _, _, _, _ = encodingName, fileName, names, pkgFiles, result, v1
	encodingName = libc.UintptrFromInt32(0)
	pkgFiles = libc.UintptrFromInt32(0)
	names = libc.UintptrFromInt32(0)
	if objc < int32(2) || objc > int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+19006)
		return int32(TCL_ERROR)
	}
	fileName = *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8))
	if objc == int32(4) {
		if int32(TCL_ERROR) == XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), uintptr(unsafe.Pointer(&_options6)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(TCL_EXACT)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) {
			return int32(TCL_ERROR)
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		encodingName = v1
	} else {
		if objc == int32(3) {
			if int32(TCL_ERROR) == XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), uintptr(unsafe.Pointer(&_nopkgoptions)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(TCL_EXACT)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+4) {
				return int32(TCL_ERROR)
			}
			pkgFiles = XTcl_GetAssocData(tls, interp, __ccgo_ts+19053, libc.UintptrFromInt32(0))
			/* Make sure that during the following TclNREvalFile no filenames
			 * are recorded for inclusion in the "package files" command */
			names = *(*uintptr)(unsafe.Pointer(pkgFiles))
			*(*uintptr)(unsafe.Pointer(pkgFiles)) = libc.UintptrFromInt32(0)
		}
	}
	result = XTclNREvalFile(tls, interp, fileName, encodingName)
	if pkgFiles != 0 {
		/* restore "tclPkgFiles" assocdata to how it was. */
		*(*uintptr)(unsafe.Pointer(pkgFiles)) = names
	}
	return result
}

var _options6 = [2]uintptr{
	0: __ccgo_ts + 19036,
	1: libc.UintptrFromInt32(0),
}

/* Handle undocumented -nopkg option. This should only be
 * used by the internal ::tcl::Pkg::source utility function. */
var _nopkgoptions = [2]uintptr{
	0: __ccgo_ts + 19046,
	1: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SplitObjCmd --
 *
 *	This procedure is invoked to process the "split" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SplitObjCmd(tls *libc.TLS, dummy1175 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(144)
	defer tls.Free(144) /* Argument objects. */
	var cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, element, end, hPtr, listPtr, objPtr, p, p1, splitChars, splitEnd, stringPtr, v1, v11, v17, v19, v2, v7, v8 uintptr
	var len1 int32
	var splitLen TTcl_Size
	var v10, v16, v18, v3, v6, v9 bool
	var v13, v15, v5 int64
	var _ /* ch at bp+0 */ int32
	var _ /* charReuseTable at bp+24 */ TTcl_HashTable
	var _ /* isNew at bp+128 */ int32
	var _ /* splitChar at bp+132 */ int32
	var _ /* splitCharLen at bp+8 */ TTcl_Size
	var _ /* stringLen at bp+16 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, element, end, hPtr, len1, listPtr, objPtr, p, p1, splitChars, splitEnd, splitLen, stringPtr, v1, v10, v11, v13, v15, v16, v17, v18, v19, v2, v3, v5, v6, v7, v8, v9
	*(*int32)(unsafe.Pointer(bp)) = 0
	if objc == int32(2) {
		splitChars = __ccgo_ts + 19065
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = int64(4)
	} else {
		if objc == int32(3) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Flength
				v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
			} else {
				v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp+8)
			}
			splitChars = v1
		} else {
			XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+19070)
			return int32(TCL_ERROR)
		}
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Flength
		v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+16)
	}
	stringPtr = v2
	end = stringPtr + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 16)))
	if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		listPtr = XTclThreadAllocObj(tls)
	} else {
		listPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(listPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(listPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(listPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(listPtr)).FtypePtr = libc.UintptrFromInt32(0)
	if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) == 0 {
		/*
		 * Do nothing.
		 */
	} else {
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == 0 {
			/*
			 * Handle the special case of splitting on every character.
			 *
			 * Uses a hash table to ensure that each kind of character has only
			 * one Tcl_Obj instance (multiply-referenced) in the final list. This
			 * is a *major* win when splitting on a long string (especially in the
			 * megabyte range!) - DKF
			 */
			XTcl_InitHashTable(tls, bp+24, int32(TCL_ONE_WORD_KEYS))
			for {
				if !(stringPtr < end) {
					break
				}
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(stringPtr))) < int32(0x80) {
					*(*int32)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(stringPtr)))
					v5 = int64(libc.Int32FromInt32(1))
				} else {
					v5 = XTcl_UtfToUniChar(tls, stringPtr, bp)
				}
				len1 = int32(v5)
				hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(bp + 24)).FcreateProc})))(tls, bp+24, uintptr(int64(*(*int32)(unsafe.Pointer(bp)))), bp+128)
				if *(*int32)(unsafe.Pointer(bp + 128)) != 0 {
					if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
						cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v6 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
						objPtr = XTclThreadAllocObj(tls)
					} else {
						objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(objPtr + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
					if len1 == 0 {
						(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
						(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(libc.Int32FromInt32(0))
					} else {
						(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = XTcl_Alloc(tls, uint64(libc.Uint32FromInt32(len1)+uint32(1)))
						if stringPtr != 0 {
							v7 = stringPtr
						} else {
							v7 = uintptr(unsafe.Pointer(&XtclEmptyString))
						}
						libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, v7, libc.Uint64FromInt32(len1))
						*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr(len1))) = uint8('\000')
						(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(len1)
					}
					(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
					/*
					 * Don't need to fiddle with refcount...
					 */
					(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = objPtr
				} else {
					objPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
				}
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listPtr, objPtr)
				goto _4
			_4:
				;
				stringPtr += uintptr(len1)
			}
			XTcl_DeleteHashTable(tls, bp+24)
		} else {
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(1) {
				/*
				 * Handle the special case of splitting on a single character. This is
				 * only true for the one-char ASCII case, as one Unicode char is > 1
				 * byte in length.
				 */
				for {
					if v9 = *(*uint8)(unsafe.Pointer(stringPtr)) != 0; v9 {
						v8 = libc.Xstrchr(tls, stringPtr, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(splitChars))))
						p = v8
					}
					if !(v9 && v8 != libc.UintptrFromInt32(0)) {
						break
					}
					objPtr = XTcl_NewStringObj(tls, stringPtr, int64(p)-int64(stringPtr))
					XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listPtr, objPtr)
					stringPtr = p + uintptr(1)
				}
				if v10 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v10 {
					cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v10 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
					objPtr = XTclThreadAllocObj(tls)
				} else {
					objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(objPtr + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
				if int64(end)-int64(stringPtr) == 0 {
					(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(libc.Int32FromInt32(0))
				} else {
					(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(int64(end)-int64(stringPtr)+libc.Int64FromUint32(1)))
					if stringPtr != 0 {
						v11 = stringPtr
					} else {
						v11 = uintptr(unsafe.Pointer(&XtclEmptyString))
					}
					libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, v11, libc.Uint64FromInt64(int64(end)-int64(stringPtr)))
					*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr(int64(end)-int64(stringPtr)))) = uint8('\000')
					(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(end) - int64(stringPtr)
				}
				(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listPtr, objPtr)
			} else {
				/*
				 * Normal case: split on any of a given set of characters. Discard
				 * instances of the split characters.
				 */
				splitEnd = splitChars + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
				element = stringPtr
				for {
					if !(stringPtr < end) {
						break
					}
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(stringPtr))) < int32(0x80) {
						*(*int32)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(stringPtr)))
						v13 = int64(libc.Int32FromInt32(1))
					} else {
						v13 = XTcl_UtfToUniChar(tls, stringPtr, bp)
					}
					len1 = int32(v13)
					p1 = splitChars
					for {
						if !(p1 < splitEnd) {
							break
						}
						if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p1))) < int32(0x80) {
							*(*int32)(unsafe.Pointer(bp + 132)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p1)))
							v15 = int64(libc.Int32FromInt32(1))
						} else {
							v15 = XTcl_UtfToUniChar(tls, p1, bp+132)
						}
						splitLen = v15
						if *(*int32)(unsafe.Pointer(bp)) == *(*int32)(unsafe.Pointer(bp + 132)) {
							if v16 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v16 {
								cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
							}
							if v16 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
								objPtr = XTclThreadAllocObj(tls)
							} else {
								objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
								(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer(objPtr + 32))).Fptr1
								(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
							}
							(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
							if int64(stringPtr)-int64(element) == 0 {
								(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
								(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(libc.Int32FromInt32(0))
							} else {
								(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(int64(stringPtr)-int64(element)+libc.Int64FromUint32(1)))
								if element != 0 {
									v17 = element
								} else {
									v17 = uintptr(unsafe.Pointer(&XtclEmptyString))
								}
								libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, v17, libc.Uint64FromInt64(int64(stringPtr)-int64(element)))
								*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr(int64(stringPtr)-int64(element)))) = uint8('\000')
								(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(stringPtr) - int64(element)
							}
							(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
							XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listPtr, objPtr)
							element = stringPtr + uintptr(len1)
							break
						}
						goto _14
					_14:
						;
						p1 += uintptr(splitLen)
					}
					goto _12
				_12:
					;
					stringPtr += uintptr(len1)
				}
				if v18 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v18 {
					cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v18 || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == libc.Uint64FromInt32(0) {
					objPtr = XTclThreadAllocObj(tls)
				} else {
					objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(objPtr + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
				if int64(stringPtr)-int64(element) == 0 {
					(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(libc.Int32FromInt32(0))
				} else {
					(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(int64(stringPtr)-int64(element)+libc.Int64FromUint32(1)))
					if element != 0 {
						v19 = element
					} else {
						v19 = uintptr(unsafe.Pointer(&XtclEmptyString))
					}
					libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, v19, libc.Uint64FromInt64(int64(stringPtr)-int64(element)))
					*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr(int64(stringPtr)-int64(element)))) = uint8('\000')
					(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(stringPtr) - int64(element)
				}
				(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listPtr, objPtr)
			}
		}
	}
	XTcl_SetObjResult(tls, interp, listPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * StringFirstCmd --
 *
 *	This procedure is invoked to process the "string first" Tcl command.
 *	See the user documentation for details on what it does. Note that this
 *	command only functions correctly on properly formed Tcl UTF strings.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _StringFirstCmd(tls *libc.TLS, dummy1308 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var end TTcl_Size
	var v1 int32
	var _ /* start at bp+0 */ TTcl_Size
	_, _ = end, v1
	*(*TTcl_Size)(unsafe.Pointer(bp)) = libc.Int64FromInt32(0)
	if objc < int32(3) || objc > int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+19090)
		return int32(TCL_ERROR)
	}
	if objc == int32(4) {
		end = XTcl_GetCharLength(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8))) - int64(1)
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep)) <= end {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep))
			v1 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1 = XTcl_GetIntForIndex(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)), end, bp)
		}
		if TCL_OK != v1 {
			return int32(TCL_ERROR)
		}
	}
	XTcl_SetObjResult(tls, interp, XTclStringFirst(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), *(*uintptr)(unsafe.Pointer(objv + 2*8)), *(*TTcl_Size)(unsafe.Pointer(bp))))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * StringLastCmd --
 *
 *	This procedure is invoked to process the "string last" Tcl command.
 *	See the user documentation for details on what it does. Note that this
 *	command only functions correctly on properly formed Tcl UTF strings.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _StringLastCmd(tls *libc.TLS, dummy1352 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var end TTcl_Size
	var v1 int32
	var _ /* last at bp+0 */ TTcl_Size
	_, _ = end, v1
	*(*TTcl_Size)(unsafe.Pointer(bp)) = libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
	if objc < int32(3) || objc > int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+19131)
		return int32(TCL_ERROR)
	}
	if objc == int32(4) {
		end = XTcl_GetCharLength(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8))) - int64(1)
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep)) <= end {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep))
			v1 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1 = XTcl_GetIntForIndex(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)), end, bp)
		}
		if TCL_OK != v1 {
			return int32(TCL_ERROR)
		}
	}
	XTcl_SetObjResult(tls, interp, XTclStringLast(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), *(*uintptr)(unsafe.Pointer(objv + 2*8)), *(*TTcl_Size)(unsafe.Pointer(bp))))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * StringIndexCmd --
 *
 *	This procedure is invoked to process the "string index" Tcl command.
 *	See the user documentation for details on what it does. Note that this
 *	command only functions correctly on properly formed Tcl UTF strings.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _StringIndexCmd(tls *libc.TLS, dummy1396 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var ch, v1 int32
	var end TTcl_Size
	var _ /* buf at bp+12 */ [4]uint8
	var _ /* index at bp+0 */ TTcl_Size
	var _ /* uch at bp+8 */ uint8
	_, _, _ = ch, end, v1
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+19171)
		return int32(TCL_ERROR)
	}
	/*
	 * Get the char length to calculate what 'end' means.
	 */
	end = XTcl_GetCharLength(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8))) - int64(1)
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) <= end {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep))
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_GetIntForIndex(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), end, bp)
	}
	if v1 != TCL_OK {
		return int32(TCL_ERROR)
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp)) >= 0 && *(*TTcl_Size)(unsafe.Pointer(bp)) <= end {
		ch = XTcl_GetUniChar(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), *(*TTcl_Size)(unsafe.Pointer(bp)))
		if ch == -int32(1) {
			return TCL_OK
		}
		/*
		 * If we have a ByteArray object, we're careful to generate a new
		 * bytearray for a result.
		 */
		if XTclIsPureByteArray(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8))) != 0 {
			*(*uint8)(unsafe.Pointer(bp + 8)) = libc.Uint8FromInt32(ch)
			XTcl_SetObjResult(tls, interp, XTcl_NewByteArrayObj(tls, bp+8, int64(1)))
		} else {
			*(*[4]uint8)(unsafe.Pointer(bp + 12)) = [4]uint8{}
			end = XTcl_UniCharToUtf(tls, ch, bp+12)
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, bp+12, end))
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * StringInsertCmd --
 *
 *	This procedure is invoked to process the "string insert" Tcl command.
 *	See the user documentation for details on what it does. Note that this
 *	command only functions correctly on properly formed Tcl UTF strings.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _StringInsertCmd(tls *libc.TLS, dummy1463 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects */
	var length TTcl_Size
	var outObj uintptr
	var v1 int32
	var _ /* index at bp+0 */ TTcl_Size
	_, _, _ = length, outObj, v1 /* Output object */
	if objc != int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+19188)
		return int32(TCL_ERROR)
	}
	length = XTcl_GetCharLength(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) <= length {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep))
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_GetIntForIndex(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), length, bp)
	}
	if v1 != TCL_OK {
		return int32(TCL_ERROR)
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp)) < 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = libc.Int64FromInt32(0)
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp)) > length {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = length
	}
	outObj = XTclStringReplace(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), *(*TTcl_Size)(unsafe.Pointer(bp)), 0, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.Int32FromInt32(1)<<libc.Int32FromInt32(1))
	if outObj != libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, outObj)
		return TCL_OK
	}
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * StringIsCmd --
 *
 *	This procedure is invoked to process the "string is" Tcl command. See
 *	the user documentation for details on what it does. Note that this
 *	command only functions correctly on properly formed Tcl UTF strings.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _StringIsCmd(tls *libc.TLS, dummy1520 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(112)
	defer tls.Free(112) /* Argument objects. */
	var cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, chcomp, end, failVarObj, objPtr, p, p1, string1, tmpStr, tmpStr1, v11, v13, v14, v16, v19, v23, v25, v27, v3, v6, v9 uintptr
	var dresult, i, result, strict, v15, v17, v2, v21, v4, v5 int32
	var failat, lenRemain, lenRemain1, length2, v10, v24 TTcl_Size
	var v12, v22, v26, v30, v8 bool
	var v18, v29 int64
	var _ /* dsize at bp+40 */ TTcl_Size
	var _ /* elemSize at bp+64 */ TTcl_Size
	var _ /* elemSize at bp+88 */ TTcl_Size
	var _ /* elemStart at bp+48 */ uintptr
	var _ /* elemStart at bp+72 */ uintptr
	var _ /* idx2 at bp+36 */ int32
	var _ /* index at bp+32 */ int32
	var _ /* length1 at bp+8 */ TTcl_Size
	var _ /* length3 at bp+16 */ TTcl_Size
	var _ /* nextElem at bp+56 */ uintptr
	var _ /* nextElem at bp+80 */ uintptr
	var _ /* stop at bp+0 */ uintptr
	var _ /* ucs4 at bp+96 */ int32
	var _ /* w at bp+24 */ TTcl_WideInt
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, chcomp, dresult, end, failVarObj, failat, i, lenRemain, lenRemain1, length2, objPtr, p, p1, result, strict, string1, tmpStr, tmpStr1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v21, v22, v23, v24, v25, v26, v27, v29, v3, v30, v4, v5, v6, v8, v9
	chcomp = libc.UintptrFromInt32(0)
	result = int32(1)
	strict = 0
	failat = 0
	failVarObj = libc.UintptrFromInt32(0)
	if objc < int32(3) || objc > int32(6) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+19259)
		return int32(TCL_ERROR)
	}
	if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), uintptr(unsafe.Pointer(&_isClasses)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+19296, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+32) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if objc != int32(3) {
		i = int32(2)
		for {
			if !(i < objc-int32(1)) {
				break
			}
			if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_isOptions)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+36) != TCL_OK {
				return int32(TCL_ERROR)
			}
			switch *(*int32)(unsafe.Pointer(bp + 36)) {
			case 0:
				strict = int32(1)
			case 1:
				if i+int32(1) >= objc-int32(1) {
					XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+19302)
					return int32(TCL_ERROR)
				}
				i++
				v2 = i
				failVarObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(v2)*8))
				break
			}
			goto _1
		_1:
			;
			i++
		}
	}
	/*
	 * We get the objPtr so that we can short-cut for some classes by checking
	 * the object type (int and double), but we need the string otherwise,
	 * because we don't want any conversion of type occurring (as, for example,
	 * Tcl_Get*FromObj would do).
	 */
	objPtr = *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8))
	/*
	 * When entering here, result == 1 and failat == 0.
	 */
	switch *(*int32)(unsafe.Pointer(bp + 32)) {
	case 0:
		chcomp = __ccgo_fp(XTcl_UniCharIsAlnum)
	case 1:
		chcomp = __ccgo_fp(XTcl_UniCharIsAlpha)
	case 2:
		chcomp = __ccgo_fp(_UniCharIsAscii)
	case 4:
		fallthrough
	case 17:
		fallthrough
	case 9:
		if !((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclBooleanType))) && TCL_OK != XTclSetBooleanFromAny(tls, libc.UintptrFromInt32(0), objPtr) {
			if strict != 0 {
				result = 0
			} else {
				if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
					v3 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
				} else {
					v3 = XTcl_GetStringFromObj(tls, objPtr, bp+8)
				}
				string1 = v3
				result = libc.BoolInt32(*(*TTcl_Size)(unsafe.Pointer(bp + 8)) == 0)
			}
		} else {
			if *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) != 0 {
				v4 = libc.BoolInt32(*(*int32)(unsafe.Pointer(bp + 32)) == 9)
			} else {
				v4 = libc.BoolInt32(*(*int32)(unsafe.Pointer(bp + 32)) == 17)
			}
			if v4 != 0 {
				result = 0
			}
		}
	case 3:
		chcomp = __ccgo_fp(XTcl_UniCharIsControl)
	case 5:
		dresult = XTcl_DictObjSize(tls, interp, objPtr, bp+40)
		XTcl_ResetResult(tls, interp)
		if dresult == TCL_OK {
			v5 = int32(1)
		} else {
			v5 = 0
		}
		result = v5
		if dresult != TCL_OK && failVarObj != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
				v6 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
			} else {
				v6 = XTcl_GetStringFromObj(tls, objPtr, bp+8)
			}
			string1 = v6
			end = string1 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
			failat = int64(-int32(1))
			p = string1
			lenRemain = *(*TTcl_Size)(unsafe.Pointer(bp + 8))
			for {
				if !(lenRemain > 0) {
					break
				}
				if int32(TCL_ERROR) == XTclFindElement(tls, libc.UintptrFromInt32(0), p, lenRemain, bp+48, bp+56, bp+64, libc.UintptrFromInt32(0)) {
					/*
					 * This is the simplest way of getting the number of
					 * characters parsed. Note that this is not the same as
					 * the number of bytes when parsing strings with non-ASCII
					 * characters in them.
					 *
					 * Skip leading spaces first. This is only really an issue
					 * if it is the first "element" that has the failure.
					 */
					for XTclIsSpaceProc(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))) != 0 {
						p++
					}
					if v8 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v8 {
						cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v8 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
						tmpStr = XTclThreadAllocObj(tls)
					} else {
						tmpStr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(tmpStr + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer(tmpStr)).FrefCount = 0
					if int64(p)-int64(string1) == 0 {
						(*TTcl_Obj)(unsafe.Pointer(tmpStr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
						(*TTcl_Obj)(unsafe.Pointer(tmpStr)).Flength = int64(libc.Int32FromInt32(0))
					} else {
						(*TTcl_Obj)(unsafe.Pointer(tmpStr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(int64(p)-int64(string1)+libc.Int64FromUint32(1)))
						if string1 != 0 {
							v9 = string1
						} else {
							v9 = uintptr(unsafe.Pointer(&XtclEmptyString))
						}
						libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(tmpStr)).Fbytes, v9, libc.Uint64FromInt64(int64(p)-int64(string1)))
						*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpStr)).Fbytes + uintptr(int64(p)-int64(string1)))) = uint8('\000')
						(*TTcl_Obj)(unsafe.Pointer(tmpStr)).Flength = int64(p) - int64(string1)
					}
					(*TTcl_Obj)(unsafe.Pointer(tmpStr)).FtypePtr = libc.UintptrFromInt32(0)
					failat = XTcl_GetCharLength(tls, tmpStr)
					v11 = tmpStr
					v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
					*(*TTcl_Size)(unsafe.Pointer(v11))--
					if !(v10 > int64(1)) {
						if !((*TTcl_Obj)(unsafe.Pointer(tmpStr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpStr)).FtypePtr)).FfreeIntRepProc != 0) {
							if (*TTcl_Obj)(unsafe.Pointer(tmpStr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(tmpStr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
								XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(tmpStr)).Fbytes)
							}
							(*TTcl_Obj)(unsafe.Pointer(tmpStr)).Flength = int64(-libc.Int32FromInt32(1))
							if v12 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v12 {
								cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
							}
							if v12 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
								XTclThreadFreeObj(tls, tmpStr)
							} else {
								(*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer(tmpStr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
								(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = tmpStr
								(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
							}
						} else {
							XTclFreeObj(tls, tmpStr)
						}
					}
					break
				}
				goto _7
			_7:
				;
				p = *(*uintptr)(unsafe.Pointer(bp + 56))
				lenRemain = int64(end) - int64(*(*uintptr)(unsafe.Pointer(bp + 56)))
			}
		}
	case 6:
		chcomp = __ccgo_fp(XTcl_UniCharIsDigit)
	case 7:
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) || (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) || (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclBignumType)) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
			v13 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		} else {
			v13 = XTcl_GetStringFromObj(tls, objPtr, bp+8)
		}
		string1 = v13
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == 0 {
			if strict != 0 {
				result = 0
			}
			goto str_is_done
		}
		end = string1 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
		if XTclParseNumber(tls, libc.UintptrFromInt32(0), objPtr, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), int64(-libc.Int32FromInt32(1)), bp, 0) != TCL_OK {
			result = 0
			failat = 0
		} else {
			failat = int64(*(*uintptr)(unsafe.Pointer(bp))) - int64(string1)
			if *(*uintptr)(unsafe.Pointer(bp)) < end {
				result = 0
				if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != libc.UintptrFromInt32(0) {
					if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
						(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc})))(tls, objPtr)
					}
					(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
				}
			}
		}
	case 10:
		chcomp = __ccgo_fp(XTcl_UniCharIsGraph)
	case 11:
		fallthrough
	case 8:
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) || (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclBignumType)) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
			v14 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		} else {
			v14 = XTcl_GetStringFromObj(tls, objPtr, bp+8)
		}
		string1 = v14
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == 0 {
			if strict != 0 {
				result = 0
			}
			goto str_is_done
		}
		end = string1 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
		if XTclParseNumber(tls, libc.UintptrFromInt32(0), objPtr, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), int64(-libc.Int32FromInt32(1)), bp, int32(TCL_PARSE_INTEGER_ONLY)) == TCL_OK {
			if *(*uintptr)(unsafe.Pointer(bp)) == end {
				/*
				 * Entire string parses as an integer.
				 */
				break
			} else {
				/*
				 * Some prefix parsed as an integer, but not the whole string,
				 * so return failure index as the point where parsing stopped.
				 * Clear out the internal rep, since keeping it would leave
				 * *objPtr in an inconsistent state.
				 */
				result = 0
				failat = int64(*(*uintptr)(unsafe.Pointer(bp))) - int64(string1)
				if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != libc.UintptrFromInt32(0) {
					if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
						(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc})))(tls, objPtr)
					}
					(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
				}
			}
		} else {
			/*
			 * No prefix is a valid integer. Fail at beginning.
			 */
			result = 0
			failat = 0
		}
	case 19:
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
			*(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep))
			v15 = libc.Int32FromInt32(TCL_OK)
		} else {
			v15 = XTcl_GetWideIntFromObj(tls, libc.UintptrFromInt32(0), objPtr, bp+24)
		}
		if TCL_OK == v15 {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
			v16 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		} else {
			v16 = XTcl_GetStringFromObj(tls, objPtr, bp+8)
		}
		string1 = v16
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == 0 {
			if strict != 0 {
				result = 0
			}
			goto str_is_done
		}
		result = 0
		if failVarObj == libc.UintptrFromInt32(0) {
			/*
			 * Don't bother computing the failure point if we're not going to
			 * return it.
			 */
			break
		}
		end = string1 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
		if XTclParseNumber(tls, libc.UintptrFromInt32(0), objPtr, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), int64(-libc.Int32FromInt32(1)), bp, int32(TCL_PARSE_INTEGER_ONLY)) == TCL_OK {
			if *(*uintptr)(unsafe.Pointer(bp)) == end {
				/*
				 * Entire string parses as an integer, but rejected by
				 * Tcl_Get(Wide)IntFromObj() so we must have overflowed the
				 * target type, and our convention is to return failure at
				 * index -1 in that situation.
				 */
				failat = int64(-int32(1))
			} else {
				/*
				 * Some prefix parsed as an integer, but not the whole string,
				 * so return failure index as the point where parsing stopped.
				 * Clear out the internal rep, since keeping it would leave
				 * *objPtr in an inconsistent state.
				 */
				failat = int64(*(*uintptr)(unsafe.Pointer(bp))) - int64(string1)
				if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != libc.UintptrFromInt32(0) {
					if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
						(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc})))(tls, objPtr)
					}
					(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
				}
			}
		} else {
			/*
			 * No prefix is a valid integer. Fail at beginning.
			 */
			failat = 0
		}
	case 12:
		/*
		 * We ignore the strictness here, since empty strings are always
		 * well-formed lists.
		 */
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr2 != 0 {
				v18 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr2)).FspanLength
			} else {
				v18 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = v18
			v17 = libc.Int32FromInt32(TCL_OK)
		} else {
			v17 = XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), objPtr, bp+16)
		}
		if TCL_OK == v17 {
			break
		}
		if failVarObj != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
				v19 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
			} else {
				v19 = XTcl_GetStringFromObj(tls, objPtr, bp+8)
			}
			string1 = v19
			end = string1 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
			failat = int64(-int32(1))
			p1 = string1
			lenRemain1 = *(*TTcl_Size)(unsafe.Pointer(bp + 8))
			for {
				if !(lenRemain1 > 0) {
					break
				}
				if int32(TCL_ERROR) == XTclFindElement(tls, libc.UintptrFromInt32(0), p1, lenRemain1, bp+72, bp+80, bp+88, libc.UintptrFromInt32(0)) {
					/*
					 * This is the simplest way of getting the number of
					 * characters parsed. Note that this is not the same as
					 * the number of bytes when parsing strings with non-ASCII
					 * characters in them.
					 *
					 * Skip leading spaces first. This is only really an issue
					 * if it is the first "element" that has the failure.
					 */
					for {
						if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p1))) > int32(0x20) {
							v21 = 0
						} else {
							v21 = XTclIsSpaceProc(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p1))))
						}
						if !(v21 != 0) {
							break
						}
						p1++
					}
					if v22 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v22 {
						cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v22 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
						tmpStr1 = XTclThreadAllocObj(tls)
					} else {
						tmpStr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(tmpStr1 + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer(tmpStr1)).FrefCount = 0
					if int64(p1)-int64(string1) == 0 {
						(*TTcl_Obj)(unsafe.Pointer(tmpStr1)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
						(*TTcl_Obj)(unsafe.Pointer(tmpStr1)).Flength = int64(libc.Int32FromInt32(0))
					} else {
						(*TTcl_Obj)(unsafe.Pointer(tmpStr1)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(int64(p1)-int64(string1)+libc.Int64FromUint32(1)))
						if string1 != 0 {
							v23 = string1
						} else {
							v23 = uintptr(unsafe.Pointer(&XtclEmptyString))
						}
						libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(tmpStr1)).Fbytes, v23, libc.Uint64FromInt64(int64(p1)-int64(string1)))
						*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpStr1)).Fbytes + uintptr(int64(p1)-int64(string1)))) = uint8('\000')
						(*TTcl_Obj)(unsafe.Pointer(tmpStr1)).Flength = int64(p1) - int64(string1)
					}
					(*TTcl_Obj)(unsafe.Pointer(tmpStr1)).FtypePtr = libc.UintptrFromInt32(0)
					failat = XTcl_GetCharLength(tls, tmpStr1)
					v25 = tmpStr1
					v24 = *(*TTcl_Size)(unsafe.Pointer(v25))
					*(*TTcl_Size)(unsafe.Pointer(v25))--
					if !(v24 > int64(1)) {
						if !((*TTcl_Obj)(unsafe.Pointer(tmpStr1)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpStr1)).FtypePtr)).FfreeIntRepProc != 0) {
							if (*TTcl_Obj)(unsafe.Pointer(tmpStr1)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(tmpStr1)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
								XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(tmpStr1)).Fbytes)
							}
							(*TTcl_Obj)(unsafe.Pointer(tmpStr1)).Flength = int64(-libc.Int32FromInt32(1))
							if v26 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v26 {
								cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
							}
							if v26 || ((*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
								XTclThreadFreeObj(tls, tmpStr1)
							} else {
								(*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer(tmpStr1 + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
								(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = tmpStr1
								(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects++
							}
						} else {
							XTclFreeObj(tls, tmpStr1)
						}
					}
					break
				}
				goto _20
			_20:
				;
				p1 = *(*uintptr)(unsafe.Pointer(bp + 80))
				lenRemain1 = int64(end) - int64(*(*uintptr)(unsafe.Pointer(bp + 80)))
			}
		}
		result = 0
	case 13:
		chcomp = __ccgo_fp(XTcl_UniCharIsLower)
	case 14:
		chcomp = __ccgo_fp(XTcl_UniCharIsPrint)
	case 15:
		chcomp = __ccgo_fp(XTcl_UniCharIsPunct)
	case 16:
		chcomp = __ccgo_fp(XTcl_UniCharIsSpace)
	case 18:
		chcomp = __ccgo_fp(XTcl_UniCharIsUpper)
	case 20:
		chcomp = __ccgo_fp(XTcl_UniCharIsWordChar)
	case 21:
		chcomp = __ccgo_fp(_UniCharIsHexDigit)
		break
	}
	if chcomp != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
			v27 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		} else {
			v27 = XTcl_GetStringFromObj(tls, objPtr, bp+8)
		}
		string1 = v27
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == 0 {
			if strict != 0 {
				result = 0
			}
			goto str_is_done
		}
		end = string1 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
		for {
			if !(string1 < end) {
				break
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1))) < int32(0x80) {
				*(*int32)(unsafe.Pointer(bp + 96)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1)))
				v29 = int64(libc.Int32FromInt32(1))
			} else {
				v29 = XTcl_UtfToUniChar(tls, string1, bp+96)
			}
			length2 = v29
			if !((*(*func(*libc.TLS, int32) int32)(unsafe.Pointer(&struct{ uintptr }{chcomp})))(tls, *(*int32)(unsafe.Pointer(bp + 96))) != 0) {
				result = 0
				break
			}
			goto _28
		_28:
			;
			string1 += uintptr(length2)
			failat++
		}
	}
	/*
	 * Only set the failVarObj when we will return 0 and we have indicated a
	 * valid fail index (>= 0).
	 */
	goto str_is_done
str_is_done:
	;
	if result == 0 && failVarObj != libc.UintptrFromInt32(0) {
		if v30 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v30 {
			cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v30 || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == libc.Uint64FromInt32(0) {
			objPtr = XTclThreadAllocObj(tls)
		} else {
			objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = libc.UintptrFromInt32(0)
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) = failat
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
		if XTcl_ObjSetVar2(tls, interp, failVarObj, libc.UintptrFromInt32(0), objPtr, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(result != 0)))
	return TCL_OK
}

var _isClasses = [23]uintptr{
	0:  __ccgo_ts + 1119,
	1:  __ccgo_ts + 1125,
	2:  __ccgo_ts + 1131,
	3:  __ccgo_ts + 19214,
	4:  __ccgo_ts + 3611,
	5:  __ccgo_ts + 19222,
	6:  __ccgo_ts + 1149,
	7:  __ccgo_ts + 6055,
	8:  __ccgo_ts + 6062,
	9:  __ccgo_ts + 19227,
	10: __ccgo_ts + 1155,
	11: __ccgo_ts + 6223,
	12: __ccgo_ts + 2860,
	13: __ccgo_ts + 1161,
	14: __ccgo_ts + 1167,
	15: __ccgo_ts + 1173,
	16: __ccgo_ts + 558,
	17: __ccgo_ts + 19233,
	18: __ccgo_ts + 1179,
	19: __ccgo_ts + 19238,
	20: __ccgo_ts + 19250,
	21: __ccgo_ts + 1185,
	22: libc.UintptrFromInt32(0),
}

var _isOptions = [3]uintptr{
	0: __ccgo_ts + 11034,
	1: __ccgo_ts + 15031,
	2: libc.UintptrFromInt32(0),
}

func _UniCharIsAscii(tls *libc.TLS, character int32) (r int32) {
	return libc.BoolInt32(character >= 0 && character < int32(0x80))
}

func _UniCharIsHexDigit(tls *libc.TLS, character int32) (r int32) {
	return libc.BoolInt32(character >= 0 && character < int32(0x80) && libc.Xisxdigit(tls, libc.Int32FromUint8(libc.Uint8FromInt32(character))) != 0)
}

/*
 *----------------------------------------------------------------------
 *
 * StringMapCmd --
 *
 *	This procedure is invoked to process the "string map" Tcl command. See
 *	the user documentation for details on what it does. Note that this
 *	command only functions correctly on properly formed Tcl UTF strings.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _StringMapCmd(tls *libc.TLS, dummy1952 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(144)
	defer tls.Free(144) /* Argument objects. */
	var _objPtr, end, mapLens, mapString, mapStrings, p, resultPtr, sourceObj, strCmpFn, string1, u2lc1, ustring1, ustring2, v1, v13, v6 uintptr
	var copySource, mapWithDict, nocase, u2lc, v3, v7 int32
	var index, mapElemc, v12 TTcl_Size
	var v4, v5 int64
	var _ /* done at bp+32 */ int32
	var _ /* i at bp+24 */ TTcl_Size
	var _ /* i at bp+64 */ TTcl_Size
	var _ /* length1 at bp+0 */ TTcl_Size
	var _ /* length2 at bp+8 */ TTcl_Size
	var _ /* mapElemv at bp+16 */ uintptr
	var _ /* mapLen at bp+72 */ TTcl_Size
	var _ /* search at bp+40 */ TTcl_DictSearch
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, copySource, end, index, mapElemc, mapLens, mapString, mapStrings, mapWithDict, nocase, p, resultPtr, sourceObj, strCmpFn, string1, u2lc, u2lc1, ustring1, ustring2, v1, v12, v13, v3, v4, v5, v6, v7
	nocase = 0
	mapWithDict = 0
	copySource = 0
	if objc < int32(3) || objc > int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+19333)
		return int32(TCL_ERROR)
	}
	if objc == int32(4) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Flength
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+8)
		}
		string1 = v1
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > int64(1) && libc.Xstrncmp(tls, string1, __ccgo_ts+17555, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))) == 0 {
			nocase = int32(1)
		} else {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+19358, libc.VaList(bp+88, string1)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+88, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+17278, __ccgo_ts+11057, string1, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
	}
	/*
	 * This test is tricky, but has to be that way or you get other strange
	 * inconsistencies (see test string-10.20.1 for illustration why!)
	 */
	if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)))).Fbytes != libc.UintptrFromInt32(0)) && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclDictType)) {
		/*
		 * We know the type exactly, so all dict operations will succeed for
		 * sure. This shortens this code quite a bit.
		 */
		XTcl_DictObjSize(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)), bp+24)
		if *(*TTcl_Size)(unsafe.Pointer(bp + 24)) == 0 {
			/*
			 * Empty charMap, just return whatever string was given.
			 */
			XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))
			return TCL_OK
		}
		mapElemc = int64(2) * *(*TTcl_Size)(unsafe.Pointer(bp + 24))
		mapWithDict = int32(1)
		/*
		 * Copy the dictionary out into an array; that's the easiest way to
		 * adapt this code...
		 */
		*(*uintptr)(unsafe.Pointer(bp + 16)) = XTclStackAlloc(tls, interp, uint64(8)*libc.Uint64FromInt64(mapElemc))
		XTcl_DictObjFirst(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)), bp+40, *(*uintptr)(unsafe.Pointer(bp + 16))+uintptr(0)*8, *(*uintptr)(unsafe.Pointer(bp + 16))+uintptr(1)*8, bp+32)
		index = int64(2)
		for {
			if !(index < mapElemc) {
				break
			}
			XTcl_DictObjNext(tls, bp+40, *(*uintptr)(unsafe.Pointer(bp + 16))+uintptr(index)*8, *(*uintptr)(unsafe.Pointer(bp + 16))+uintptr(index)*8+uintptr(1)*8, bp+32)
			goto _2
		_2:
			;
			index += int64(2)
		}
		XTcl_DictObjDone(tls, bp+40)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) + 32))).Fptr2 != 0 {
				v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) + 32))).Fptr2)).FspanStart
			} else {
				v4 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 16)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) + 32))).Fptr1 + 40 + uintptr(v4)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) + 32))).Fptr2 != 0 {
				v5 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) + 32))).Fptr2)).FspanLength
			} else {
				v5 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 64)) = v5
			v3 = libc.Int32FromInt32(TCL_OK)
		} else {
			v3 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)), bp+64, bp+16)
		}
		if v3 != TCL_OK {
			return int32(TCL_ERROR)
		}
		mapElemc = *(*TTcl_Size)(unsafe.Pointer(bp + 64))
		if mapElemc == 0 {
			/*
			 * empty charMap, just return whatever string was given.
			 */
			XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))
			return TCL_OK
		} else {
			if mapElemc&int64(1) != 0 {
				/*
				 * The charMap must be an even number of key/value items.
				 */
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+19391, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+88, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+19416, __ccgo_ts+19420, libc.UintptrFromInt32(0)))
				return int32(TCL_ERROR)
			}
		}
	}
	/*
	 * Take a copy of the source string object if it is the same as the map
	 * string to cut out nasty sharing crashes. [Bug 1018562]
	 */
	if *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)) == *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)) {
		sourceObj = XTcl_DuplicateObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))
		copySource = int32(1)
	} else {
		sourceObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8))
	}
	ustring1 = XTcl_GetUnicodeFromObj(tls, sourceObj, bp)
	if *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
		/*
		 * Empty input string, just stop now.
		 */
		goto done
	}
	end = ustring1 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))*4
	if nocase != 0 {
		v6 = __ccgo_fp(XTclUniCharNcasecmp)
	} else {
		v6 = __ccgo_fp(XTclUniCharNcmp)
	}
	strCmpFn = v6
	/*
	 * Force result to be Unicode
	 */
	resultPtr = XTcl_NewUnicodeObj(tls, ustring1, 0)
	if mapElemc == int64(2) {
		ustring2 = XTcl_GetUnicodeFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))), bp+8)
		p = ustring1
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > *(*TTcl_Size)(unsafe.Pointer(bp)) || *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == 0 {
			/*
			 * Match string is either longer than input or empty.
			 */
			ustring1 = end
		} else {
			mapString = XTcl_GetUnicodeFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 1*8)), bp+72)
			if nocase != 0 {
				v7 = XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(ustring2)))
			} else {
				v7 = 0
			}
			u2lc = v7
			for {
				if !(ustring1 < end) {
					break
				}
				if (*(*TTcl_UniChar)(unsafe.Pointer(ustring1)) == *(*TTcl_UniChar)(unsafe.Pointer(ustring2)) || nocase != 0 && XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(ustring1))) == u2lc) && (*(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(1) || (*(*func(*libc.TLS, uintptr, uintptr, Tsize_t) int32)(unsafe.Pointer(&struct{ uintptr }{strCmpFn})))(tls, ustring1, ustring2, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))) == 0) {
					if p != ustring1 {
						XTcl_AppendUnicodeToObj(tls, resultPtr, p, (int64(ustring1)-int64(p))/4)
						p = ustring1 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))*4
					} else {
						p += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8))) * 4
					}
					ustring1 = p - uintptr(1)*4
					XTcl_AppendUnicodeToObj(tls, resultPtr, mapString, *(*TTcl_Size)(unsafe.Pointer(bp + 72)))
				}
				goto _8
			_8:
				;
				ustring1 += 4
			}
		}
	} else {
		u2lc1 = uintptr(0)
		/*
		 * Precompute pointers to the Unicode string and length. This saves us
		 * repeated function calls later, significantly speeding up the
		 * algorithm. We only need the lowercase first char in the nocase
		 * case.
		 */
		mapStrings = XTclStackAlloc(tls, interp, libc.Uint64FromInt64(mapElemc)*uint64(8)*uint64(2))
		mapLens = XTclStackAlloc(tls, interp, libc.Uint64FromInt64(mapElemc)*uint64(8)*uint64(2))
		if nocase != 0 {
			u2lc1 = XTclStackAlloc(tls, interp, libc.Uint64FromInt64(mapElemc)*uint64(4))
		}
		index = 0
		for {
			if !(index < mapElemc) {
				break
			}
			*(*uintptr)(unsafe.Pointer(mapStrings + uintptr(index)*8)) = XTcl_GetUnicodeFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(index)*8)), mapLens+uintptr(index)*8)
			if nocase != 0 && index%int64(2) == 0 {
				*(*int32)(unsafe.Pointer(u2lc1 + uintptr(index/int64(2))*4)) = XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mapStrings + uintptr(index)*8)))))
			}
			goto _9
		_9:
			;
			index++
		}
		p = ustring1
		for {
			if !(ustring1 < end) {
				break
			}
			index = 0
			for {
				if !(index < mapElemc) {
					break
				}
				/*
				 * Get the key string to match on.
				 */
				ustring2 = *(*uintptr)(unsafe.Pointer(mapStrings + uintptr(index)*8))
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = *(*TTcl_Size)(unsafe.Pointer(mapLens + uintptr(index)*8))
				if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > 0 && (*(*TTcl_UniChar)(unsafe.Pointer(ustring1)) == *(*TTcl_UniChar)(unsafe.Pointer(ustring2)) || nocase != 0 && XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(ustring1))) == *(*int32)(unsafe.Pointer(u2lc1 + uintptr(index/int64(2))*4))) && (int64(end)-int64(ustring1))/4 >= *(*TTcl_Size)(unsafe.Pointer(bp + 8)) && (*(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(1) || !((*(*func(*libc.TLS, uintptr, uintptr, Tsize_t) int32)(unsafe.Pointer(&struct{ uintptr }{strCmpFn})))(tls, ustring2, ustring1, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))) != 0)) {
					if p != ustring1 {
						/*
						 * Put the skipped chars onto the result first.
						 */
						XTcl_AppendUnicodeToObj(tls, resultPtr, p, (int64(ustring1)-int64(p))/4)
						p = ustring1 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))*4
					} else {
						p += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8))) * 4
					}
					/*
					 * Adjust len to be full length of matched string.
					 */
					ustring1 = p - uintptr(1)*4
					/*
					 * Append the map value to the Unicode string.
					 */
					XTcl_AppendUnicodeToObj(tls, resultPtr, *(*uintptr)(unsafe.Pointer(mapStrings + uintptr(index+int64(1))*8)), *(*TTcl_Size)(unsafe.Pointer(mapLens + uintptr(index+int64(1))*8)))
					break
				}
				goto _11
			_11:
				;
				index += int64(2)
			}
			goto _10
		_10:
			;
			ustring1 += 4
		}
		if nocase != 0 {
			XTclStackFree(tls, interp, u2lc1)
		}
		XTclStackFree(tls, interp, mapLens)
		XTclStackFree(tls, interp, mapStrings)
	}
	if p != ustring1 {
		/*
		 * Put the rest of the unmapped chars onto result.
		 */
		XTcl_AppendUnicodeToObj(tls, resultPtr, p, (int64(ustring1)-int64(p))/4)
	}
	XTcl_SetObjResult(tls, interp, resultPtr)
	goto done
done:
	;
	if mapWithDict != 0 {
		XTclStackFree(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 16)))
	}
	if copySource != 0 {
		_objPtr = sourceObj
		v13 = _objPtr
		v12 = *(*TTcl_Size)(unsafe.Pointer(v13))
		*(*TTcl_Size)(unsafe.Pointer(v13))--
		if v12 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * StringMatchCmd --
 *
 *	This procedure is invoked to process the "string match" Tcl command.
 *	See the user documentation for details on what it does. Note that this
 *	command only functions correctly on properly formed Tcl UTF strings.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _StringMatchCmd(tls *libc.TLS, dummy2228 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Argument objects. */
	var nocase int32
	var string1, v1 uintptr
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _ = nocase, string1, v1
	nocase = 0
	if objc < int32(3) || objc > int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+19431)
		return int32(TCL_ERROR)
	}
	if objc == int32(4) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Flength
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
		}
		string1 = v1
		if *(*TTcl_Size)(unsafe.Pointer(bp)) > int64(1) && libc.Xstrncmp(tls, string1, __ccgo_ts+17555, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))) == 0 {
			nocase = libc.Int32FromInt32(1) << libc.Int32FromInt32(0)
		} else {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+19358, libc.VaList(bp+16, string1)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+17278, __ccgo_ts+11057, string1, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(XTclStringMatchObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)), nocase) != 0)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * StringRangeCmd --
 *
 *	This procedure is invoked to process the "string range" Tcl command.
 *	See the user documentation for details on what it does. Note that this
 *	command only functions correctly on properly formed Tcl UTF strings.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _StringRangeCmd(tls *libc.TLS, dummy2279 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var end TTcl_Size
	var v1, v2 int32
	var v3 bool
	var _ /* first at bp+0 */ TTcl_Size
	var _ /* last at bp+8 */ TTcl_Size
	_, _, _, _ = end, v1, v2, v3
	if objc != int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+19456)
		return int32(TCL_ERROR)
	}
	/*
	 * Get the length in actual characters; Then reduce it by one because
	 * 'end' refers to the last character, not one past it.
	 */
	end = XTcl_GetCharLength(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8))) - int64(1)
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) <= end {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep))
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_GetIntForIndex(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), end, bp)
	}
	if v3 = v1 != TCL_OK; !v3 {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep)) <= end {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep))
			v2 = libc.Int32FromInt32(TCL_OK)
		} else {
			v2 = XTcl_GetIntForIndex(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)), end, bp+8)
		}
	}
	if v3 || v2 != TCL_OK {
		return int32(TCL_ERROR)
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) >= 0 {
		XTcl_SetObjResult(tls, interp, XTcl_GetRange(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), *(*TTcl_Size)(unsafe.Pointer(bp)), *(*TTcl_Size)(unsafe.Pointer(bp + 8))))
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * StringReptCmd --
 *
 *	This procedure is invoked to process the "string repeat" Tcl command.
 *	See the user documentation for details on what it does. Note that this
 *	command only functions correctly on properly formed Tcl UTF strings.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _StringReptCmd(tls *libc.TLS, dummy2329 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var resultPtr uintptr
	var v1 int32
	var _ /* count at bp+0 */ TTcl_WideInt
	_, _ = resultPtr, v1
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+19474)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*TTcl_WideInt)(unsafe.Pointer(bp)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep))
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_GetWideIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp)
	}
	if v1 != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Check for cases that allow us to skip copying stuff.
	 */
	if *(*TTcl_WideInt)(unsafe.Pointer(bp)) == int64(1) {
		XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
		return TCL_OK
	} else {
		if *(*TTcl_WideInt)(unsafe.Pointer(bp)) < int64(1) {
			return TCL_OK
		}
	}
	resultPtr = XTclStringRepeat(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), *(*TTcl_WideInt)(unsafe.Pointer(bp)), libc.Int32FromInt32(1)<<libc.Int32FromInt32(1))
	if resultPtr != 0 {
		XTcl_SetObjResult(tls, interp, resultPtr)
		return TCL_OK
	}
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * StringRplcCmd --
 *
 *	This procedure is invoked to process the "string replace" Tcl command.
 *	See the user documentation for details on what it does. Note that this
 *	command only functions correctly on properly formed Tcl UTF strings.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _StringRplcCmd(tls *libc.TLS, dummy2385 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var end TTcl_Size
	var resultPtr, v4 uintptr
	var v1, v2 int32
	var v3 bool
	var _ /* first at bp+0 */ TTcl_Size
	var _ /* last at bp+8 */ TTcl_Size
	_, _, _, _, _, _ = end, resultPtr, v1, v2, v3, v4
	if objc < int32(4) || objc > int32(5) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+19487)
		return int32(TCL_ERROR)
	}
	end = XTcl_GetCharLength(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8))) - int64(1)
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) <= end {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep))
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_GetIntForIndex(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), end, bp)
	}
	if v3 = v1 != TCL_OK; !v3 {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep)) <= end {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep))
			v2 = libc.Int32FromInt32(TCL_OK)
		} else {
			v2 = XTcl_GetIntForIndex(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)), end, bp+8)
		}
	}
	if v3 || v2 != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * The following test screens out most empty substrings as candidates for
	 * replacement. When they are detected, no replacement is done, and the
	 * result is the original string.
	 */
	if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) < 0 || *(*TTcl_Size)(unsafe.Pointer(bp)) > end || *(*TTcl_Size)(unsafe.Pointer(bp + 8)) < *(*TTcl_Size)(unsafe.Pointer(bp)) { /* Range begins after it starts */
		/*
		 * BUT!!! when (end < 0) -- an empty original string -- we can
		 * have (first <= end < 0 <= last) and an empty string is permitted
		 * to be replaced.
		 */
		XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	} else {
		if *(*TTcl_Size)(unsafe.Pointer(bp)) < 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = libc.Int64FromInt32(0)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > end {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = end
		}
		if objc == int32(5) {
			v4 = *(*uintptr)(unsafe.Pointer(objv + 4*8))
		} else {
			v4 = libc.UintptrFromInt32(0)
		}
		resultPtr = XTclStringReplace(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), *(*TTcl_Size)(unsafe.Pointer(bp)), *(*TTcl_Size)(unsafe.Pointer(bp + 8))+int64(1)-*(*TTcl_Size)(unsafe.Pointer(bp)), v4, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1))
		if resultPtr == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
		XTcl_SetObjResult(tls, interp, resultPtr)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * StringRevCmd --
 *
 *	This procedure is invoked to process the "string reverse" Tcl command.
 *	See the user documentation for details on what it does. Note that this
 *	command only functions correctly on properly formed Tcl UTF strings.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _StringRevCmd(tls *libc.TLS, dummy2462 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+19514)
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTclStringReverse(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * StringStartCmd --
 *
 *	This procedure is invoked to process the "string wordstart" Tcl
 *	command. See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _StringStartCmd(tls *libc.TLS, dummy2495 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var cachePtr, next, obj, p, string1, v3 uintptr
	var ch, delta, v1 int32
	var cur TTcl_Size
	var v4 bool
	var _ /* index at bp+0 */ TTcl_Size
	var _ /* length at bp+8 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _ = cachePtr, ch, cur, delta, next, obj, p, string1, v1, v3, v4
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+19521)
		return int32(TCL_ERROR)
	}
	string1 = XTcl_GetUnicodeFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+8)
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) <= *(*TTcl_Size)(unsafe.Pointer(bp + 8))-int64(1) {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep))
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_GetIntForIndex(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), *(*TTcl_Size)(unsafe.Pointer(bp + 8))-libc.Int64FromInt32(1), bp)
	}
	if v1 != TCL_OK {
		return int32(TCL_ERROR)
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp)) >= *(*TTcl_Size)(unsafe.Pointer(bp + 8)) {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = *(*TTcl_Size)(unsafe.Pointer(bp + 8)) - int64(1)
	}
	cur = 0
	if *(*TTcl_Size)(unsafe.Pointer(bp)) > 0 {
		p = string1 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))*4
		ch = *(*TTcl_UniChar)(unsafe.Pointer(p))
		cur = *(*TTcl_Size)(unsafe.Pointer(bp))
		for {
			if !(cur != int64(-libc.Int32FromInt32(1))) {
				break
			}
			delta = 0
			if !(XTcl_UniCharIsWordChar(tls, ch) != 0) {
				break
			}
			if p > string1 {
				v3 = p - uintptr(1)*4
			} else {
				v3 = p
			}
			next = v3
			for cond := true; cond; cond = next+uintptr(delta)*4 < p {
				next += uintptr(delta) * 4
				ch = *(*TTcl_UniChar)(unsafe.Pointer(next))
				delta = int32(1)
			}
			p = next
			goto _2
		_2:
			;
			cur--
		}
		if cur != *(*TTcl_Size)(unsafe.Pointer(bp)) {
			cur += int64(1)
		}
	}
	if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		obj = XTclThreadAllocObj(tls)
	} else {
		obj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(obj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(obj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes = libc.UintptrFromInt32(0)
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(obj)).FinternalRep)) = cur
	(*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	XTcl_SetObjResult(tls, interp, obj)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * StringEndCmd --
 *
 *	This procedure is invoked to process the "string wordend" Tcl command.
 *	See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _StringEndCmd(tls *libc.TLS, dummy2566 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var cachePtr, end, obj, p, string1, v3 uintptr
	var ch, v1 int32
	var cur TTcl_Size
	var v4 bool
	var _ /* index at bp+0 */ TTcl_Size
	var _ /* length at bp+8 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _ = cachePtr, ch, cur, end, obj, p, string1, v1, v3, v4
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+19521)
		return int32(TCL_ERROR)
	}
	string1 = XTcl_GetUnicodeFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+8)
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) <= *(*TTcl_Size)(unsafe.Pointer(bp + 8))-int64(1) {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep))
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_GetIntForIndex(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), *(*TTcl_Size)(unsafe.Pointer(bp + 8))-libc.Int64FromInt32(1), bp)
	}
	if v1 != TCL_OK {
		return int32(TCL_ERROR)
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp)) < 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp)) < *(*TTcl_Size)(unsafe.Pointer(bp + 8)) {
		p = string1 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))*4
		end = string1 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))*4
		cur = *(*TTcl_Size)(unsafe.Pointer(bp))
		for {
			if !(p < end) {
				break
			}
			v3 = p
			p += 4
			ch = *(*TTcl_UniChar)(unsafe.Pointer(v3))
			if !(XTcl_UniCharIsWordChar(tls, ch) != 0) {
				break
			}
			goto _2
		_2:
			;
			cur++
		}
		if cur == *(*TTcl_Size)(unsafe.Pointer(bp)) {
			cur++
		}
	} else {
		cur = *(*TTcl_Size)(unsafe.Pointer(bp + 8))
	}
	if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		obj = XTclThreadAllocObj(tls)
	} else {
		obj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(obj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(obj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes = libc.UintptrFromInt32(0)
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(obj)).FinternalRep)) = cur
	(*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	XTcl_SetObjResult(tls, interp, obj)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * StringEqualCmd --
 *
 *	This procedure is invoked to process the "string equal" Tcl command.
 *	See the user documentation for details on what it does. Note that this
 *	command only functions correctly on properly formed Tcl UTF strings.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _StringEqualCmd(tls *libc.TLS, dummy2628 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* Argument objects. */
	var i, match, nocase, v4, v5 int32
	var string2, v3 uintptr
	var _ /* length at bp+0 */ TTcl_Size
	var _ /* reqlength at bp+8 */ TTcl_WideInt
	_, _, _, _, _, _, _ = i, match, nocase, string2, v3, v4, v5
	nocase = 0
	*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) = int64(-int32(1))
	if !(objc < int32(3) || objc > int32(6)) {
		goto _1
	}
	goto str_cmp_args
str_cmp_args:
	;
	XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+19534)
	return int32(TCL_ERROR)
_1:
	;
	i = int32(1)
	for {
		if !(i < objc-int32(2)) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Flength
			v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp)
		}
		string2 = v3
		if *(*TTcl_Size)(unsafe.Pointer(bp)) > int64(1) && !(libc.Xstrncmp(tls, string2, __ccgo_ts+17555, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))) != 0) {
			nocase = int32(1)
		} else {
			if *(*TTcl_Size)(unsafe.Pointer(bp)) > int64(1) && !(libc.Xstrncmp(tls, string2, __ccgo_ts+19574, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))) != 0) {
				if i+int32(1) >= objc-int32(2) {
					goto str_cmp_args
				}
				i++
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
					*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep))
					v4 = libc.Int32FromInt32(TCL_OK)
				} else {
					v4 = XTcl_GetWideIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp+8)
				}
				if v4 != TCL_OK {
					return int32(TCL_ERROR)
				}
				if libc.Uint64FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8))) > libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) {
					*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) = int64(-int32(1))
				}
			} else {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+19582, libc.VaList(bp+24, string2)))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+17278, __ccgo_ts+11057, string2, libc.UintptrFromInt32(0)))
				return int32(TCL_ERROR)
			}
		}
		goto _2
	_2:
		;
		i++
	}
	/*
	 * From now on, we only access the two objects at the end of the argument
	 * array.
	 */
	objv += uintptr(objc-int32(2)) * 8
	match = XTclStringCmp(tls, *(*uintptr)(unsafe.Pointer(objv)), *(*uintptr)(unsafe.Pointer(objv + 1*8)), int32(1), nocase, *(*TTcl_WideInt)(unsafe.Pointer(bp + 8)))
	if match != 0 {
		v5 = 0
	} else {
		v5 = int32(1)
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(v5 != 0)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * StringCmpCmd --
 *
 *	This procedure is invoked to process the "string compare" Tcl command.
 *	See the user documentation for details on what it does. Note that this
 *	command only functions correctly on properly formed Tcl UTF strings.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _StringCmpCmd(tls *libc.TLS, dummy2708 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var match, status int32
	var _ /* nocase at bp+0 */ int32
	var _ /* reqlength at bp+8 */ TTcl_Size
	_, _ = match, status
	*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = int64(-int32(1))
	status = _StringCmpOpts(tls, interp, objc, objv, bp, bp+8)
	if status != TCL_OK {
		return status
	}
	objv += uintptr(objc-int32(2)) * 8
	match = XTclStringCmp(tls, *(*uintptr)(unsafe.Pointer(objv)), *(*uintptr)(unsafe.Pointer(objv + 1*8)), 0, *(*int32)(unsafe.Pointer(bp)), *(*TTcl_Size)(unsafe.Pointer(bp + 8)))
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, int64(match)))
	return TCL_OK
}

func _StringCmpOpts(tls *libc.TLS, interp uintptr, objc int32, objv uintptr, nocase uintptr, reqlength uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var i, v4 int32
	var string1, v3 uintptr
	var _ /* length at bp+0 */ TTcl_Size
	var _ /* wreqlength at bp+8 */ TTcl_WideInt
	_, _, _, _ = i, string1, v3, v4
	*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) = int64(-int32(1))
	*(*int32)(unsafe.Pointer(nocase)) = 0
	if !(objc < int32(3) || objc > int32(6)) {
		goto _1
	}
	goto str_cmp_args
str_cmp_args:
	;
	XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+19534)
	return int32(TCL_ERROR)
_1:
	;
	i = int32(1)
	for {
		if !(i < objc-int32(2)) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Flength
			v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp)
		}
		string1 = v3
		if *(*TTcl_Size)(unsafe.Pointer(bp)) > int64(1) && !(libc.Xstrncmp(tls, string1, __ccgo_ts+17555, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))) != 0) {
			*(*int32)(unsafe.Pointer(nocase)) = int32(1)
		} else {
			if *(*TTcl_Size)(unsafe.Pointer(bp)) > int64(1) && !(libc.Xstrncmp(tls, string1, __ccgo_ts+19574, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))) != 0) {
				if i+int32(1) >= objc-int32(2) {
					goto str_cmp_args
				}
				i++
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
					*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep))
					v4 = libc.Int32FromInt32(TCL_OK)
				} else {
					v4 = XTcl_GetWideIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp+8)
				}
				if v4 != TCL_OK {
					return int32(TCL_ERROR)
				}
				if libc.Uint64FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8))) > libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) {
					*(*TTcl_Size)(unsafe.Pointer(reqlength)) = int64(-int32(1))
				} else {
					*(*TTcl_Size)(unsafe.Pointer(reqlength)) = *(*TTcl_WideInt)(unsafe.Pointer(bp + 8))
				}
			} else {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+19582, libc.VaList(bp+24, string1)))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+17278, __ccgo_ts+11057, string1, libc.UintptrFromInt32(0)))
				return int32(TCL_ERROR)
			}
		}
		goto _2
	_2:
		;
		i++
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * StringCatCmd --
 *
 *	This procedure is invoked to process the "string cat" Tcl command.
 *	See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _StringCatCmd(tls *libc.TLS, dummy2803 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var objResultPtr uintptr
	_ = objResultPtr
	if objc < int32(2) {
		/*
		 * If there are no args, the result is an empty object.
		 * Just leave the preset empty interp result.
		 */
		return TCL_OK
	}
	objResultPtr = XTclStringCat(tls, interp, int64(objc-int32(1)), objv+uintptr(1)*8, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1))
	if objResultPtr != 0 {
		XTcl_SetObjResult(tls, interp, objResultPtr)
		return TCL_OK
	}
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * StringLenCmd --
 *
 *	This procedure is invoked to process the "string length" Tcl command.
 *	See the user documentation for details on what it does. Note that this
 *	command only functions correctly on properly formed Tcl UTF strings.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _StringLenCmd(tls *libc.TLS, dummy2848 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+19514)
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, XTcl_GetCharLength(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)))))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * StringLowerCmd --
 *
 *	This procedure is invoked to process the "string tolower" Tcl command.
 *	See the user documentation for details on what it does. Note that this
 *	command only functions correctly on properly formed Tcl UTF strings.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _StringLowerCmd(tls *libc.TLS, dummy2882 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Argument objects. */
	var end, resultPtr, resultPtr1, start, string1, string2, v1, v2, v6, v7 uintptr
	var length2 TTcl_Size
	var v3, v4 int32
	var v5 bool
	var _ /* first at bp+8 */ TTcl_Size
	var _ /* last at bp+16 */ TTcl_Size
	var _ /* length1 at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = end, length2, resultPtr, resultPtr1, start, string1, string2, v1, v2, v3, v4, v5, v6, v7
	if objc < int32(2) || objc > int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+19626)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
	}
	string1 = v1
	if objc == int32(2) {
		resultPtr = XTcl_NewStringObj(tls, string1, *(*TTcl_Size)(unsafe.Pointer(bp)))
		if (*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, resultPtr, libc.UintptrFromInt32(0))
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = XTcl_UtfToLower(tls, v2)
		XTcl_SetObjLength(tls, resultPtr, *(*TTcl_Size)(unsafe.Pointer(bp)))
		XTcl_SetObjResult(tls, interp, resultPtr)
	} else {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = XTcl_NumUtfChars(tls, string1, *(*TTcl_Size)(unsafe.Pointer(bp))) - int64(1)
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) <= *(*TTcl_Size)(unsafe.Pointer(bp)) {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep))
			v3 = libc.Int32FromInt32(TCL_OK)
		} else {
			v3 = XTcl_GetIntForIndex(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), *(*TTcl_Size)(unsafe.Pointer(bp)), bp+8)
		}
		if v3 != TCL_OK {
			return int32(TCL_ERROR)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) < 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = *(*TTcl_Size)(unsafe.Pointer(bp + 8))
		if v5 = objc == int32(4); v5 {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep)) <= *(*TTcl_Size)(unsafe.Pointer(bp)) {
				*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep))
				v4 = libc.Int32FromInt32(TCL_OK)
			} else {
				v4 = XTcl_GetIntForIndex(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)), *(*TTcl_Size)(unsafe.Pointer(bp)), bp+16)
			}
		}
		if v5 && v4 != TCL_OK {
			return int32(TCL_ERROR)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) >= *(*TTcl_Size)(unsafe.Pointer(bp)) {
			*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = *(*TTcl_Size)(unsafe.Pointer(bp))
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) < *(*TTcl_Size)(unsafe.Pointer(bp + 8)) {
			XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
			return TCL_OK
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Flength
			v6 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
		} else {
			v6 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
		}
		string1 = v6
		start = XTcl_UtfAtIndex(tls, string1, *(*TTcl_Size)(unsafe.Pointer(bp + 8)))
		end = XTcl_UtfAtIndex(tls, start, *(*TTcl_Size)(unsafe.Pointer(bp + 16))-*(*TTcl_Size)(unsafe.Pointer(bp + 8))+int64(1))
		resultPtr1 = XTcl_NewStringObj(tls, string1, int64(end)-int64(string1))
		if (*TTcl_Obj)(unsafe.Pointer(resultPtr1)).Fbytes != 0 {
			v7 = (*TTcl_Obj)(unsafe.Pointer(resultPtr1)).Fbytes
		} else {
			v7 = XTcl_GetStringFromObj(tls, resultPtr1, libc.UintptrFromInt32(0))
		}
		string2 = v7 + uintptr(int64(start)-int64(string1))
		length2 = XTcl_UtfToLower(tls, string2)
		XTcl_SetObjLength(tls, resultPtr1, length2+(int64(start)-int64(string1)))
		XTcl_AppendToObj(tls, resultPtr1, end, int64(-int32(1)))
		XTcl_SetObjResult(tls, interp, resultPtr1)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * StringUpperCmd --
 *
 *	This procedure is invoked to process the "string toupper" Tcl command.
 *	See the user documentation for details on what it does. Note that this
 *	command only functions correctly on properly formed Tcl UTF strings.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _StringUpperCmd(tls *libc.TLS, dummy2967 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Argument objects. */
	var end, resultPtr, resultPtr1, start, string1, string2, v1, v2, v6, v7 uintptr
	var length2 TTcl_Size
	var v3, v4 int32
	var v5 bool
	var _ /* first at bp+8 */ TTcl_Size
	var _ /* last at bp+16 */ TTcl_Size
	var _ /* length1 at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = end, length2, resultPtr, resultPtr1, start, string1, string2, v1, v2, v3, v4, v5, v6, v7
	if objc < int32(2) || objc > int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+19626)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
	}
	string1 = v1
	if objc == int32(2) {
		resultPtr = XTcl_NewStringObj(tls, string1, *(*TTcl_Size)(unsafe.Pointer(bp)))
		if (*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, resultPtr, libc.UintptrFromInt32(0))
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = XTcl_UtfToUpper(tls, v2)
		XTcl_SetObjLength(tls, resultPtr, *(*TTcl_Size)(unsafe.Pointer(bp)))
		XTcl_SetObjResult(tls, interp, resultPtr)
	} else {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = XTcl_NumUtfChars(tls, string1, *(*TTcl_Size)(unsafe.Pointer(bp))) - int64(1)
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) <= *(*TTcl_Size)(unsafe.Pointer(bp)) {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep))
			v3 = libc.Int32FromInt32(TCL_OK)
		} else {
			v3 = XTcl_GetIntForIndex(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), *(*TTcl_Size)(unsafe.Pointer(bp)), bp+8)
		}
		if v3 != TCL_OK {
			return int32(TCL_ERROR)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) < 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = *(*TTcl_Size)(unsafe.Pointer(bp + 8))
		if v5 = objc == int32(4); v5 {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep)) <= *(*TTcl_Size)(unsafe.Pointer(bp)) {
				*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep))
				v4 = libc.Int32FromInt32(TCL_OK)
			} else {
				v4 = XTcl_GetIntForIndex(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)), *(*TTcl_Size)(unsafe.Pointer(bp)), bp+16)
			}
		}
		if v5 && v4 != TCL_OK {
			return int32(TCL_ERROR)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) >= *(*TTcl_Size)(unsafe.Pointer(bp)) {
			*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = *(*TTcl_Size)(unsafe.Pointer(bp))
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) < *(*TTcl_Size)(unsafe.Pointer(bp + 8)) {
			XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
			return TCL_OK
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Flength
			v6 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
		} else {
			v6 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
		}
		string1 = v6
		start = XTcl_UtfAtIndex(tls, string1, *(*TTcl_Size)(unsafe.Pointer(bp + 8)))
		end = XTcl_UtfAtIndex(tls, start, *(*TTcl_Size)(unsafe.Pointer(bp + 16))-*(*TTcl_Size)(unsafe.Pointer(bp + 8))+int64(1))
		resultPtr1 = XTcl_NewStringObj(tls, string1, int64(end)-int64(string1))
		if (*TTcl_Obj)(unsafe.Pointer(resultPtr1)).Fbytes != 0 {
			v7 = (*TTcl_Obj)(unsafe.Pointer(resultPtr1)).Fbytes
		} else {
			v7 = XTcl_GetStringFromObj(tls, resultPtr1, libc.UintptrFromInt32(0))
		}
		string2 = v7 + uintptr(int64(start)-int64(string1))
		length2 = XTcl_UtfToUpper(tls, string2)
		XTcl_SetObjLength(tls, resultPtr1, length2+(int64(start)-int64(string1)))
		XTcl_AppendToObj(tls, resultPtr1, end, int64(-int32(1)))
		XTcl_SetObjResult(tls, interp, resultPtr1)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * StringTitleCmd --
 *
 *	This procedure is invoked to process the "string totitle" Tcl command.
 *	See the user documentation for details on what it does. Note that this
 *	command only functions correctly on properly formed Tcl UTF strings.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _StringTitleCmd(tls *libc.TLS, dummy3052 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Argument objects. */
	var end, resultPtr, resultPtr1, start, string1, string2, v1, v2, v6, v7 uintptr
	var length2 TTcl_Size
	var v3, v4 int32
	var v5 bool
	var _ /* first at bp+8 */ TTcl_Size
	var _ /* last at bp+16 */ TTcl_Size
	var _ /* length1 at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = end, length2, resultPtr, resultPtr1, start, string1, string2, v1, v2, v3, v4, v5, v6, v7
	if objc < int32(2) || objc > int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+19626)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
	}
	string1 = v1
	if objc == int32(2) {
		resultPtr = XTcl_NewStringObj(tls, string1, *(*TTcl_Size)(unsafe.Pointer(bp)))
		if (*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, resultPtr, libc.UintptrFromInt32(0))
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = XTcl_UtfToTitle(tls, v2)
		XTcl_SetObjLength(tls, resultPtr, *(*TTcl_Size)(unsafe.Pointer(bp)))
		XTcl_SetObjResult(tls, interp, resultPtr)
	} else {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = XTcl_NumUtfChars(tls, string1, *(*TTcl_Size)(unsafe.Pointer(bp))) - int64(1)
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) <= *(*TTcl_Size)(unsafe.Pointer(bp)) {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep))
			v3 = libc.Int32FromInt32(TCL_OK)
		} else {
			v3 = XTcl_GetIntForIndex(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), *(*TTcl_Size)(unsafe.Pointer(bp)), bp+8)
		}
		if v3 != TCL_OK {
			return int32(TCL_ERROR)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) < 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = *(*TTcl_Size)(unsafe.Pointer(bp + 8))
		if v5 = objc == int32(4); v5 {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep)) <= *(*TTcl_Size)(unsafe.Pointer(bp)) {
				*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep))
				v4 = libc.Int32FromInt32(TCL_OK)
			} else {
				v4 = XTcl_GetIntForIndex(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)), *(*TTcl_Size)(unsafe.Pointer(bp)), bp+16)
			}
		}
		if v5 && v4 != TCL_OK {
			return int32(TCL_ERROR)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) >= *(*TTcl_Size)(unsafe.Pointer(bp)) {
			*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = *(*TTcl_Size)(unsafe.Pointer(bp))
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) < *(*TTcl_Size)(unsafe.Pointer(bp + 8)) {
			XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
			return TCL_OK
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Flength
			v6 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
		} else {
			v6 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
		}
		string1 = v6
		start = XTcl_UtfAtIndex(tls, string1, *(*TTcl_Size)(unsafe.Pointer(bp + 8)))
		end = XTcl_UtfAtIndex(tls, start, *(*TTcl_Size)(unsafe.Pointer(bp + 16))-*(*TTcl_Size)(unsafe.Pointer(bp + 8))+int64(1))
		resultPtr1 = XTcl_NewStringObj(tls, string1, int64(end)-int64(string1))
		if (*TTcl_Obj)(unsafe.Pointer(resultPtr1)).Fbytes != 0 {
			v7 = (*TTcl_Obj)(unsafe.Pointer(resultPtr1)).Fbytes
		} else {
			v7 = XTcl_GetStringFromObj(tls, resultPtr1, libc.UintptrFromInt32(0))
		}
		string2 = v7 + uintptr(int64(start)-int64(string1))
		length2 = XTcl_UtfToTitle(tls, string2)
		XTcl_SetObjLength(tls, resultPtr1, length2+(int64(start)-int64(string1)))
		XTcl_AppendToObj(tls, resultPtr1, end, int64(-int32(1)))
		XTcl_SetObjResult(tls, interp, resultPtr1)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * StringTrimCmd --
 *
 *	This procedure is invoked to process the "string trim" Tcl command.
 *	See the user documentation for details on what it does. Note that this
 *	command only functions correctly on properly formed Tcl UTF strings.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _StringTrimCmd(tls *libc.TLS, dummy3137 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Argument objects. */
	var string1, string2, v1, v2 uintptr
	var triml TTcl_Size
	var _ /* length1 at bp+8 */ TTcl_Size
	var _ /* length2 at bp+16 */ TTcl_Size
	var _ /* trimr at bp+0 */ TTcl_Size
	_, _, _, _, _ = string1, string2, triml, v1, v2
	if objc == int32(3) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Flength
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp+16)
		}
		string2 = v1
	} else {
		if objc == int32(2) {
			string2 = uintptr(unsafe.Pointer(&XtclDefaultTrimSet))
			*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = libc.Int64FromUint64(libc.Xstrlen(tls, uintptr(unsafe.Pointer(&XtclDefaultTrimSet))))
		} else {
			XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+19648)
			return int32(TCL_ERROR)
		}
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Flength
		v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+8)
	}
	string1 = v2
	triml = XTclTrim(tls, string1, *(*TTcl_Size)(unsafe.Pointer(bp + 8)), string2, *(*TTcl_Size)(unsafe.Pointer(bp + 16)), bp)
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, string1+uintptr(triml), *(*TTcl_Size)(unsafe.Pointer(bp + 8))-triml-*(*TTcl_Size)(unsafe.Pointer(bp))))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * StringTrimLCmd --
 *
 *	This procedure is invoked to process the "string trimleft" Tcl
 *	command. See the user documentation for details on what it does. Note
 *	that this command only functions correctly on properly formed Tcl UTF
 *	strings.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _StringTrimLCmd(tls *libc.TLS, dummy3184 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var string1, string2, v1, v2 uintptr
	var trim int32
	var _ /* length1 at bp+0 */ TTcl_Size
	var _ /* length2 at bp+8 */ TTcl_Size
	_, _, _, _, _ = string1, string2, trim, v1, v2
	if objc == int32(3) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Flength
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp+8)
		}
		string2 = v1
	} else {
		if objc == int32(2) {
			string2 = uintptr(unsafe.Pointer(&XtclDefaultTrimSet))
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = libc.Int64FromUint64(libc.Xstrlen(tls, uintptr(unsafe.Pointer(&XtclDefaultTrimSet))))
		} else {
			XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+19648)
			return int32(TCL_ERROR)
		}
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Flength
		v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
	}
	string1 = v2
	trim = int32(XTclTrimLeft(tls, string1, *(*TTcl_Size)(unsafe.Pointer(bp)), string2, *(*TTcl_Size)(unsafe.Pointer(bp + 8))))
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, string1+uintptr(trim), *(*TTcl_Size)(unsafe.Pointer(bp))-int64(trim)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * StringTrimRCmd --
 *
 *	This procedure is invoked to process the "string trimright" Tcl
 *	command. See the user documentation for details on what it does. Note
 *	that this command only functions correctly on properly formed Tcl UTF
 *	strings.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _StringTrimRCmd(tls *libc.TLS, dummy3231 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var string1, string2, v1, v2 uintptr
	var trim int32
	var _ /* length1 at bp+0 */ TTcl_Size
	var _ /* length2 at bp+8 */ TTcl_Size
	_, _, _, _, _ = string1, string2, trim, v1, v2
	if objc == int32(3) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Flength
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp+8)
		}
		string2 = v1
	} else {
		if objc == int32(2) {
			string2 = uintptr(unsafe.Pointer(&XtclDefaultTrimSet))
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = libc.Int64FromUint64(libc.Xstrlen(tls, uintptr(unsafe.Pointer(&XtclDefaultTrimSet))))
		} else {
			XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+19648)
			return int32(TCL_ERROR)
		}
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Flength
		v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
	}
	string1 = v2
	trim = int32(XTclTrimRight(tls, string1, *(*TTcl_Size)(unsafe.Pointer(bp)), string2, *(*TTcl_Size)(unsafe.Pointer(bp + 8))))
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, string1, *(*TTcl_Size)(unsafe.Pointer(bp))-int64(trim)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclInitStringCmd --
 *
 *	This procedure creates the "string" Tcl command. See the user
 *	documentation for details on what it does. Note that this command only
 *	functions correctly on properly formed Tcl UTF strings.
 *
 *	Also note that the primary methods here (equal, compare, match, ...)
 *	have bytecode equivalents. You will find the code for those in
 *	tclExecute.c. The code here will only be used in the non-bc case (like
 *	in an 'eval').
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTclInitStringCmd(tls *libc.TLS, interp uintptr) (r TTcl_Command) {
	return XTclMakeEnsemble(tls, interp, __ccgo_ts+19514, uintptr(unsafe.Pointer(&_stringImplMap)))
}

/* Current interpreter. */
var _stringImplMap = [24]TEnsembleImplMap{
	0: {
		Fname: __ccgo_ts + 19663,
	},
	1: {
		Fname: __ccgo_ts + 19667,
	},
	2: {
		Fname: __ccgo_ts + 19675,
	},
	3: {
		Fname: __ccgo_ts + 19681,
	},
	4: {
		Fname: __ccgo_ts + 19687,
	},
	5: {
		Fname: __ccgo_ts + 19693,
	},
	6: {
		Fname: __ccgo_ts + 19700,
	},
	7: {
		Fname: __ccgo_ts + 19703,
	},
	8: {
		Fname: __ccgo_ts + 19708,
	},
	9: {
		Fname: __ccgo_ts + 19715,
	},
	10: {
		Fname: __ccgo_ts + 19719,
	},
	11: {
		Fname: __ccgo_ts + 19725,
	},
	12: {
		Fname: __ccgo_ts + 19731,
	},
	13: {
		Fname: __ccgo_ts + 19738,
	},
	14: {
		Fname: __ccgo_ts + 3110,
	},
	15: {
		Fname: __ccgo_ts + 19746,
	},
	16: {
		Fname: __ccgo_ts + 19754,
	},
	17: {
		Fname: __ccgo_ts + 19762,
	},
	18: {
		Fname: __ccgo_ts + 19770,
	},
	19: {
		Fname: __ccgo_ts + 19775,
	},
	20: {
		Fname: __ccgo_ts + 19784,
	},
	21: {
		Fname: __ccgo_ts + 19794,
	},
	22: {
		Fname: __ccgo_ts + 19802,
	},
	23: {},
}

func init() {
	p := unsafe.Pointer(&_stringImplMap)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_StringCatCmd)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(XTclCompileStringCatCmd)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(_StringCmpCmd)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(XTclCompileStringCmpCmd)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(_StringEqualCmd)
	*(*uintptr)(unsafe.Add(p, 112)) = __ccgo_fp(XTclCompileStringEqualCmd)
	*(*uintptr)(unsafe.Add(p, 152)) = __ccgo_fp(_StringFirstCmd)
	*(*uintptr)(unsafe.Add(p, 160)) = __ccgo_fp(XTclCompileStringFirstCmd)
	*(*uintptr)(unsafe.Add(p, 200)) = __ccgo_fp(_StringIndexCmd)
	*(*uintptr)(unsafe.Add(p, 208)) = __ccgo_fp(XTclCompileStringIndexCmd)
	*(*uintptr)(unsafe.Add(p, 248)) = __ccgo_fp(_StringInsertCmd)
	*(*uintptr)(unsafe.Add(p, 256)) = __ccgo_fp(XTclCompileStringInsertCmd)
	*(*uintptr)(unsafe.Add(p, 296)) = __ccgo_fp(_StringIsCmd)
	*(*uintptr)(unsafe.Add(p, 304)) = __ccgo_fp(XTclCompileStringIsCmd)
	*(*uintptr)(unsafe.Add(p, 344)) = __ccgo_fp(_StringLastCmd)
	*(*uintptr)(unsafe.Add(p, 352)) = __ccgo_fp(XTclCompileStringLastCmd)
	*(*uintptr)(unsafe.Add(p, 392)) = __ccgo_fp(_StringLenCmd)
	*(*uintptr)(unsafe.Add(p, 400)) = __ccgo_fp(XTclCompileStringLenCmd)
	*(*uintptr)(unsafe.Add(p, 440)) = __ccgo_fp(_StringMapCmd)
	*(*uintptr)(unsafe.Add(p, 448)) = __ccgo_fp(XTclCompileStringMapCmd)
	*(*uintptr)(unsafe.Add(p, 488)) = __ccgo_fp(_StringMatchCmd)
	*(*uintptr)(unsafe.Add(p, 496)) = __ccgo_fp(XTclCompileStringMatchCmd)
	*(*uintptr)(unsafe.Add(p, 536)) = __ccgo_fp(_StringRangeCmd)
	*(*uintptr)(unsafe.Add(p, 544)) = __ccgo_fp(XTclCompileStringRangeCmd)
	*(*uintptr)(unsafe.Add(p, 584)) = __ccgo_fp(_StringReptCmd)
	*(*uintptr)(unsafe.Add(p, 592)) = __ccgo_fp(XTclCompileBasic2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 632)) = __ccgo_fp(_StringRplcCmd)
	*(*uintptr)(unsafe.Add(p, 640)) = __ccgo_fp(XTclCompileStringReplaceCmd)
	*(*uintptr)(unsafe.Add(p, 680)) = __ccgo_fp(_StringRevCmd)
	*(*uintptr)(unsafe.Add(p, 688)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 728)) = __ccgo_fp(_StringLowerCmd)
	*(*uintptr)(unsafe.Add(p, 736)) = __ccgo_fp(XTclCompileStringToLowerCmd)
	*(*uintptr)(unsafe.Add(p, 776)) = __ccgo_fp(_StringUpperCmd)
	*(*uintptr)(unsafe.Add(p, 784)) = __ccgo_fp(XTclCompileStringToUpperCmd)
	*(*uintptr)(unsafe.Add(p, 824)) = __ccgo_fp(_StringTitleCmd)
	*(*uintptr)(unsafe.Add(p, 832)) = __ccgo_fp(XTclCompileStringToTitleCmd)
	*(*uintptr)(unsafe.Add(p, 872)) = __ccgo_fp(_StringTrimCmd)
	*(*uintptr)(unsafe.Add(p, 880)) = __ccgo_fp(XTclCompileStringTrimCmd)
	*(*uintptr)(unsafe.Add(p, 920)) = __ccgo_fp(_StringTrimLCmd)
	*(*uintptr)(unsafe.Add(p, 928)) = __ccgo_fp(XTclCompileStringTrimLCmd)
	*(*uintptr)(unsafe.Add(p, 968)) = __ccgo_fp(_StringTrimRCmd)
	*(*uintptr)(unsafe.Add(p, 976)) = __ccgo_fp(XTclCompileStringTrimRCmd)
	*(*uintptr)(unsafe.Add(p, 1016)) = __ccgo_fp(_StringEndCmd)
	*(*uintptr)(unsafe.Add(p, 1024)) = __ccgo_fp(XTclCompileBasic2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 1064)) = __ccgo_fp(_StringStartCmd)
	*(*uintptr)(unsafe.Add(p, 1072)) = __ccgo_fp(XTclCompileBasic2ArgCmd)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SubstObjCmd --
 *
 *	This procedure is invoked to process the "subst" Tcl command. See the
 *	user documentation for details on what it does. This command relies on
 *	Tcl_SubstObj() for its implementation.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTclSubstOptions(tls *libc.TLS, interp uintptr, numOpts TTcl_Size, opts uintptr, flagPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var flags, i int32
	var _ /* optionIndex at bp+0 */ int32
	_, _ = flags, i
	flags = int32(TCL_SUBST_ALL)
	i = 0
	for {
		if !(int64(i) < numOpts) {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(opts + uintptr(i)*8)), uintptr(unsafe.Pointer(&_substOptions)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
			return int32(TCL_ERROR)
		}
		switch *(*int32)(unsafe.Pointer(bp)) {
		case 0:
			flags &= ^libc.Int32FromInt32(TCL_SUBST_BACKSLASHES)
		case 1:
			flags &= ^libc.Int32FromInt32(TCL_SUBST_COMMANDS)
		case 2:
			flags &= ^libc.Int32FromInt32(TCL_SUBST_VARIABLES)
		default:
			XTcl_Panic(tls, __ccgo_ts+19852, 0)
		}
		goto _1
	_1:
		;
		i++
	}
	*(*int32)(unsafe.Pointer(flagPtr)) = flags
	return TCL_OK
}

var _substOptions = [4]uintptr{
	0: __ccgo_ts + 19812,
	1: __ccgo_ts + 19827,
	2: __ccgo_ts + 19839,
	3: libc.UintptrFromInt32(0),
}

func XTcl_SubstObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	return XTcl_NRCallObjProc(tls, interp, __ccgo_fp(XTclNRSubstObjCmd), clientData, int64(objc), objv)
}

func XTclNRSubstObjCmd(tls *libc.TLS, dummy3384 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var _ /* flags at bp+0 */ int32
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+19902)
		return int32(TCL_ERROR)
	}
	if XTclSubstOptions(tls, interp, int64(objc-int32(2)), objv+uintptr(1)*8, bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	return XTcl_NRSubstObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), *(*int32)(unsafe.Pointer(bp)))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SwitchObjCmd --
 *
 *	This object-based procedure is invoked to process the "switch" Tcl
 *	command. See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl object result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SwitchObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	return XTcl_NRCallObjProc(tls, interp, __ccgo_fp(XTclNRSwitchObjCmd), clientData, int64(objc), objv)
}

func XTclNRSwitchObjCmd(tls *libc.TLS, dummy3431 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(128)
	defer tls.Free(128) /* Argument objects. */
	var _objPtr, blist, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, ctxPtr, emptyObj, iPtr, indexVarObj, indicesObj, matchVarObj, matchesObj, pattern, savedObjv, strCmpFn, stringObj, substringObj, v10, v11, v12, v14, v17, v18, v2, v28, v3, v31 uintptr
	var bidx, bline, foundmode, i, k, matched, mode, noCase, numMatchesSaved, pc, splitObjs, v19, v4, v6 int32
	var j, v27 TTcl_Size
	var regExpr TTcl_RegExp
	var v15, v16, v20, v21, v23, v24, v25, v26 bool
	var v32, v5, v7, v8 int64
	var _ /* index at bp+8 */ int32
	var _ /* info at bp+32 */ TTcl_RegExpInfo
	var _ /* listc at bp+24 */ TTcl_Size
	var _ /* listv at bp+16 */ uintptr
	var _ /* patternLength at bp+0 */ TTcl_Size
	var _ /* rangeObjAry at bp+56 */ [2]uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, bidx, bline, blist, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, ctxPtr, emptyObj, foundmode, i, iPtr, indexVarObj, indicesObj, j, k, matchVarObj, matched, matchesObj, mode, noCase, numMatchesSaved, pattern, pc, regExpr, savedObjv, splitObjs, strCmpFn, stringObj, substringObj, v10, v11, v12, v14, v15, v16, v17, v18, v19, v2, v20, v21, v23, v24, v25, v26, v27, v28, v3, v31, v32, v4, v5, v6, v7, v8
	savedObjv = objv
	regExpr = libc.UintptrFromInt32(0)
	iPtr = interp
	pc = 0
	bidx = 0                         /* Index of body argument. */
	blist = libc.UintptrFromInt32(0) /* Copy of the topmost cmdframe, to allow us
	 * to mess with the line information */
	strCmpFn = __ccgo_fp(XTclUtfCmp)
	mode = 0
	foundmode = 0
	indexVarObj = libc.UintptrFromInt32(0)
	matchVarObj = libc.UintptrFromInt32(0)
	numMatchesSaved = 0
	noCase = 0
	i = int32(1)
	for {
		if !(i < objc-int32(2)) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) != int32('-') {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_options7)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+8) != TCL_OK {
			return int32(TCL_ERROR)
		}
		switch *(*int32)(unsafe.Pointer(bp + 8)) {
		/*
		 * General options.
		 */
		case 6:
			i++
			goto finishedOptions
		case 4:
			strCmpFn = __ccgo_fp(XTclUtfCasecmp)
			noCase = int32(1)
			break
			/*
			 * Handle the different switch mode options.
			 */
			fallthrough
		default:
			if foundmode != 0 {
				/*
				 * Mode already set via -exact, -glob, or -regexp.
				 */
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
					v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
				} else {
					v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
				}
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+19975, libc.VaList(bp+80, v3, _options7[mode])))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+80, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+20016, __ccgo_ts+20023, libc.UintptrFromInt32(0)))
				return int32(TCL_ERROR)
			}
			foundmode = int32(1)
			mode = *(*int32)(unsafe.Pointer(bp + 8))
			break
			/*
			 * Check for TIP#75 options specifying the variables to write
			 * regexp information into.
			 */
			fallthrough
		case 2:
			i++
			if i >= objc-int32(2) {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+20033, libc.VaList(bp+80, __ccgo_ts+19955)))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+80, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+20016, __ccgo_ts+20077, libc.UintptrFromInt32(0)))
				return int32(TCL_ERROR)
			}
			indexVarObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
			numMatchesSaved = -int32(1)
		case 3:
			i++
			if i >= objc-int32(2) {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+20033, libc.VaList(bp+80, __ccgo_ts+19965)))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+80, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+20016, __ccgo_ts+20077, libc.UintptrFromInt32(0)))
				return int32(TCL_ERROR)
			}
			matchVarObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
			numMatchesSaved = -int32(1)
			break
		}
		goto _1
	_1:
		;
		i++
	}
	goto finishedOptions
finishedOptions:
	;
	if objc-i < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+20083)
		return int32(TCL_ERROR)
	}
	if indexVarObj != libc.UintptrFromInt32(0) && mode != 5 {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+20138, libc.VaList(bp+80, __ccgo_ts+19955)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+80, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+20016, __ccgo_ts+20172, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if matchVarObj != libc.UintptrFromInt32(0) && mode != 5 {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+20138, libc.VaList(bp+80, __ccgo_ts+19965)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+80, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+20016, __ccgo_ts+20172, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	stringObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
	objc -= i + int32(1)
	objv += uintptr(i+int32(1)) * 8
	bidx = i + int32(1) /* First after the match string. */
	/*
	 * If all of the pattern/command pairs are lumped into a single argument,
	 * split them out again.
	 *
	 * TIP #280: Determine the lines the words in the list start at, based on
	 * the same data for the list word itself. The cmdFramePtr line
	 * information is manipulated directly.
	 */
	splitObjs = 0
	if objc == int32(1) {
		blist = *(*uintptr)(unsafe.Pointer(objv))
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2 != 0 {
				v5 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2)).FspanLength
			} else {
				v5 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = v5
			v4 = libc.Int32FromInt32(TCL_OK)
		} else {
			v4 = XTcl_ListObjLength(tls, interp, *(*uintptr)(unsafe.Pointer(objv)), bp+24)
		}
		if v4 != TCL_OK {
			return int32(TCL_ERROR)
		}
		/*
		 * Ensure that the list is non-empty.
		 */
		if *(*TTcl_Size)(unsafe.Pointer(bp + 24)) < int64(1) || *(*TTcl_Size)(unsafe.Pointer(bp + 24)) > int64(INT_MAX) {
			XTcl_WrongNumArgs(tls, interp, int64(1), savedObjv, __ccgo_ts+20188)
			return int32(TCL_ERROR)
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2 != 0 {
				v7 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2)).FspanStart
			} else {
				v7 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 16)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1 + 40 + uintptr(v7)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2 != 0 {
				v8 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2)).FspanLength
			} else {
				v8 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = v8
			v6 = libc.Int32FromInt32(TCL_OK)
		} else {
			v6 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(objv)), bp+24, bp+16)
		}
		if v6 != TCL_OK {
			return int32(TCL_ERROR)
		}
		objc = int32(*(*TTcl_Size)(unsafe.Pointer(bp + 24)))
		objv = *(*uintptr)(unsafe.Pointer(bp + 16))
		splitObjs = int32(1)
	}
	/*
	 * Complain if there is an odd number of words in the list of patterns and
	 * bodies.
	 */
	if objc%int32(2) != 0 {
		XTcl_ResetResult(tls, interp)
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+20245, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+80, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+20016, __ccgo_ts+20279, libc.UintptrFromInt32(0)))
		/*
		 * Check if this can be due to a badly placed comment in the switch
		 * block.
		 *
		 * The following is an heuristic to detect the infamous "comment in
		 * switch" error: just check if a pattern begins with '#'.
		 */
		if splitObjs != 0 {
			i = 0
			for {
				if !(i < objc) {
					break
				}
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
					v10 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
				} else {
					v10 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
				}
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) == int32('#') {
					XTcl_AppendToObj(tls, XTcl_GetObjResult(tls, interp), __ccgo_ts+20286, int64(-int32(1)))
					XTcl_SetErrorCode(tls, interp, libc.VaList(bp+80, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+20016, __ccgo_ts+20279, __ccgo_ts+20394, libc.UintptrFromInt32(0)))
					break
				}
				goto _9
			_9:
				;
				i += int32(2)
			}
		}
		return int32(TCL_ERROR)
	}
	/*
	 * Complain if the last body is a continuation. Note that this check
	 * assumes that the list is non-empty!
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))).Fbytes != 0 {
		v11 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))).Fbytes
	} else {
		v11 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), libc.UintptrFromInt32(0))
	}
	if libc.Xstrcmp(tls, v11, __ccgo_ts+6319) == 0 {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)))).Fbytes != 0 {
			v12 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)))).Fbytes
		} else {
			v12 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+20403, libc.VaList(bp+80, v12)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+80, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+20016, __ccgo_ts+20279, __ccgo_ts+20438, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	i = 0
	for {
		if !(i < objc) {
			break
		}
		/*
		 * See if the pattern matches the string.
		 */
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Flength
			v14 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
		} else {
			v14 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp)
		}
		pattern = v14
		if i == objc-int32(2) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) == int32('d') && libc.Xstrcmp(tls, pattern, __ccgo_ts+16043) == 0 {
			emptyObj = libc.UintptrFromInt32(0)
			/*
			 * If either indexVarObj or matchVarObj are non-NULL, we're in
			 * REGEXP mode but have reached the default clause anyway. TIP#75
			 * specifies that we set the variables to empty lists (== empty
			 * objects) in that case.
			 */
			if indexVarObj != libc.UintptrFromInt32(0) {
				if v15 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v15 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v15 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
					emptyObj = XTclThreadAllocObj(tls)
				} else {
					emptyObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(emptyObj + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(emptyObj)).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer(emptyObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(emptyObj)).Flength = 0
				(*TTcl_Obj)(unsafe.Pointer(emptyObj)).FtypePtr = libc.UintptrFromInt32(0)
				if XTcl_ObjSetVar2(tls, interp, indexVarObj, libc.UintptrFromInt32(0), emptyObj, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
					return int32(TCL_ERROR)
				}
			}
			if matchVarObj != libc.UintptrFromInt32(0) {
				if emptyObj == libc.UintptrFromInt32(0) {
					if v16 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v16 {
						cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v16 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
						emptyObj = XTclThreadAllocObj(tls)
					} else {
						emptyObj = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(emptyObj + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer(emptyObj)).FrefCount = 0
					(*TTcl_Obj)(unsafe.Pointer(emptyObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(emptyObj)).Flength = 0
					(*TTcl_Obj)(unsafe.Pointer(emptyObj)).FtypePtr = libc.UintptrFromInt32(0)
				}
				if XTcl_ObjSetVar2(tls, interp, matchVarObj, libc.UintptrFromInt32(0), emptyObj, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
					return int32(TCL_ERROR)
				}
			}
			goto matchFound
		}
		switch mode {
		case 0:
			if (*TTcl_Obj)(unsafe.Pointer(stringObj)).Fbytes != 0 {
				v17 = (*TTcl_Obj)(unsafe.Pointer(stringObj)).Fbytes
			} else {
				v17 = XTcl_GetStringFromObj(tls, stringObj, libc.UintptrFromInt32(0))
			}
			if (*(*func(*libc.TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{strCmpFn})))(tls, v17, pattern) == 0 {
				goto matchFound
			}
		case 1:
			if (*TTcl_Obj)(unsafe.Pointer(stringObj)).Fbytes != 0 {
				v18 = (*TTcl_Obj)(unsafe.Pointer(stringObj)).Fbytes
			} else {
				v18 = XTcl_GetStringFromObj(tls, stringObj, libc.UintptrFromInt32(0))
			}
			if XTcl_StringCaseMatch(tls, v18, pattern, noCase) != 0 {
				goto matchFound
			}
		case 5:
			if noCase != 0 {
				v19 = int32(TCL_REG_NOCASE)
			} else {
				v19 = 0
			}
			regExpr = XTcl_GetRegExpFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), int32(TCL_REG_ADVANCED)|v19)
			if regExpr == libc.UintptrFromInt32(0) {
				return int32(TCL_ERROR)
			} else {
				matched = XTcl_RegExpExecObj(tls, interp, regExpr, stringObj, 0, int64(numMatchesSaved), 0)
				if matched < 0 {
					return int32(TCL_ERROR)
				} else {
					if matched != 0 {
						goto matchFoundRegexp
					}
				}
			}
			break
		}
		goto _13
	_13:
		;
		i += int32(2)
	}
	return TCL_OK
	goto matchFoundRegexp
matchFoundRegexp:
	;
	/*
	 * We are operating in REGEXP mode and we need to store information about
	 * what we matched in some user-nominated arrays. So build the lists of
	 * values and indices to write here. [TIP#75]
	 */
	if numMatchesSaved != 0 {
		indicesObj = libc.UintptrFromInt32(0)
		XTcl_RegExpGetInfo(tls, regExpr, bp+32)
		if matchVarObj != libc.UintptrFromInt32(0) {
			if v20 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v20 {
				cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v20 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
				matchesObj = XTclThreadAllocObj(tls)
			} else {
				matchesObj = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(matchesObj + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(matchesObj)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(matchesObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(matchesObj)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(matchesObj)).FtypePtr = libc.UintptrFromInt32(0)
		} else {
			matchesObj = libc.UintptrFromInt32(0)
		}
		if indexVarObj != libc.UintptrFromInt32(0) {
			if v21 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v21 {
				cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v21 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
				indicesObj = XTclThreadAllocObj(tls)
			} else {
				indicesObj = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(indicesObj + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(indicesObj)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(indicesObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(indicesObj)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(indicesObj)).FtypePtr = libc.UintptrFromInt32(0)
		}
		j = 0
		for {
			if !(j <= (*(*TTcl_RegExpInfo)(unsafe.Pointer(bp + 32))).Fnsubs) {
				break
			}
			if indexVarObj != libc.UintptrFromInt32(0) {
				if (*(*TTcl_RegExpIndices)(unsafe.Pointer((*(*TTcl_RegExpInfo)(unsafe.Pointer(bp + 32))).Fmatches + uintptr(j)*16))).Fend > 0 {
					if v23 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v23 {
						cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v23 || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == libc.Uint64FromInt32(0) {
						(*(*[2]uintptr)(unsafe.Pointer(bp + 56)))[0] = XTclThreadAllocObj(tls)
					} else {
						(*(*[2]uintptr)(unsafe.Pointer(bp + 56)))[0] = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 56)))[0] + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 56)))[0])).FrefCount = 0
					(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 56)))[0])).Fbytes = libc.UintptrFromInt32(0)
					*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 56)))[0])).FinternalRep)) = (*(*TTcl_RegExpIndices)(unsafe.Pointer((*(*TTcl_RegExpInfo)(unsafe.Pointer(bp + 32))).Fmatches + uintptr(j)*16))).Fstart
					(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 56)))[0])).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
					if v24 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v24 {
						cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v24 || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == libc.Uint64FromInt32(0) {
						(*(*[2]uintptr)(unsafe.Pointer(bp + 56)))[int32(1)] = XTclThreadAllocObj(tls)
					} else {
						(*(*[2]uintptr)(unsafe.Pointer(bp + 56)))[int32(1)] = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 56)))[int32(1)] + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 56)))[int32(1)])).FrefCount = 0
					(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 56)))[int32(1)])).Fbytes = libc.UintptrFromInt32(0)
					*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 56)))[int32(1)])).FinternalRep)) = int64((*(*TTcl_RegExpIndices)(unsafe.Pointer((*(*TTcl_RegExpInfo)(unsafe.Pointer(bp + 32))).Fmatches + uintptr(j)*16))).Fend - libc.Int64FromInt32(1))
					(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 56)))[int32(1)])).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
				} else {
					if v25 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v25 {
						cachePtr6 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v25 || (*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects == libc.Uint64FromInt32(0) {
						(*(*[2]uintptr)(unsafe.Pointer(bp + 56)))[int32(1)] = XTclThreadAllocObj(tls)
					} else {
						(*(*[2]uintptr)(unsafe.Pointer(bp + 56)))[int32(1)] = (*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 56)))[int32(1)] + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 56)))[int32(1)])).FrefCount = 0
					(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 56)))[int32(1)])).Fbytes = libc.UintptrFromInt32(0)
					*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 56)))[int32(1)])).FinternalRep)) = int64(-libc.Int32FromInt32(1))
					(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 56)))[int32(1)])).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
					(*(*[2]uintptr)(unsafe.Pointer(bp + 56)))[0] = (*(*[2]uintptr)(unsafe.Pointer(bp + 56)))[int32(1)]
				}
				/*
				 * Never fails; the object is always clean at this point.
				 */
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), indicesObj, XTcl_NewListObj(tls, int64(2), bp+56))
			}
			if matchVarObj != libc.UintptrFromInt32(0) {
				if (*(*TTcl_RegExpIndices)(unsafe.Pointer((*(*TTcl_RegExpInfo)(unsafe.Pointer(bp + 32))).Fmatches + uintptr(j)*16))).Fend > 0 {
					substringObj = XTcl_GetRange(tls, stringObj, (*(*TTcl_RegExpIndices)(unsafe.Pointer((*(*TTcl_RegExpInfo)(unsafe.Pointer(bp + 32))).Fmatches + uintptr(j)*16))).Fstart, (*(*TTcl_RegExpIndices)(unsafe.Pointer((*(*TTcl_RegExpInfo)(unsafe.Pointer(bp + 32))).Fmatches + uintptr(j)*16))).Fend-int64(1))
				} else {
					if v26 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v26 {
						cachePtr7 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v26 || (*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects == libc.Uint64FromInt32(0) {
						substringObj = XTclThreadAllocObj(tls)
					} else {
						substringObj = (*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(substringObj + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer(substringObj)).FrefCount = 0
					(*TTcl_Obj)(unsafe.Pointer(substringObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(substringObj)).Flength = 0
					(*TTcl_Obj)(unsafe.Pointer(substringObj)).FtypePtr = libc.UintptrFromInt32(0)
				}
				/*
				 * Never fails; the object is always clean at this point.
				 */
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), matchesObj, substringObj)
			}
			goto _22
		_22:
			;
			j++
		}
		if indexVarObj != libc.UintptrFromInt32(0) {
			if XTcl_ObjSetVar2(tls, interp, indexVarObj, libc.UintptrFromInt32(0), indicesObj, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
				/*
				 * Careful! Check to see if we have allocated the list of
				 * matched strings; if so (but there was an error assigning
				 * the indices list) we have a potential memory leak because
				 * the match list has not been written to a variable. Except
				 * that we'll clean that up right now.
				 */
				if matchesObj != libc.UintptrFromInt32(0) {
					_objPtr = matchesObj
					v28 = _objPtr
					v27 = *(*TTcl_Size)(unsafe.Pointer(v28))
					*(*TTcl_Size)(unsafe.Pointer(v28))--
					if v27 <= int64(1) {
						XTclFreeObj(tls, _objPtr)
					}
				}
				return int32(TCL_ERROR)
			}
		}
		if matchVarObj != libc.UintptrFromInt32(0) {
			if XTcl_ObjSetVar2(tls, interp, matchVarObj, libc.UintptrFromInt32(0), matchesObj, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
				/*
				 * Unlike above, if indicesObj is non-NULL at this point, it
				 * will have been written to a variable already and will hence
				 * not be leaked.
				 */
				return int32(TCL_ERROR)
			}
		}
	}
	/*
	 * We've got a match. Find a body to execute, skipping bodies that are
	 * "-".
	 */
	goto matchFound
matchFound:
	;
	ctxPtr = XTclStackAlloc(tls, interp, uint64(88))
	*(*TCmdFrame)(unsafe.Pointer(ctxPtr)) = *(*TCmdFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr))
	if splitObjs != 0 {
		/*
		 * We have to perform the GetSrc and other type dependent handling of
		 * the frame here because we are munging with the line numbers,
		 * something the other commands like if, etc. are not doing. Them are
		 * fine with simply passing the CmdFrame through and having the
		 * special handling done in 'info frame', or the bc compiler
		 */
		if (*TCmdFrame)(unsafe.Pointer(ctxPtr)).Ftype1 == int32(TCL_LOCATION_BC) {
			/*
			 * Type BC => ctxPtr->data.eval.path    is not used.
			 *		  ctxPtr->data.tebc.codePtr is used instead.
			 */
			XTclGetSrcInfoForPc(tls, ctxPtr)
			pc = int32(1)
			/*
			 * The line information in the cmdFrame is now a copy we do not
			 * own.
			 */
		}
		if (*TCmdFrame)(unsafe.Pointer(ctxPtr)).Ftype1 == int32(TCL_LOCATION_SOURCE) && *(*TTcl_Size)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(ctxPtr)).Fline + uintptr(bidx)*8)) >= 0 {
			bline = int32(*(*TTcl_Size)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(ctxPtr)).Fline + uintptr(bidx)*8)))
			(*TCmdFrame)(unsafe.Pointer(ctxPtr)).Fline = XTcl_Alloc(tls, libc.Uint64FromInt32(objc)*uint64(8))
			(*TCmdFrame)(unsafe.Pointer(ctxPtr)).Fnline = int64(objc)
			XTclListLines(tls, blist, int64(bline), int64(objc), (*TCmdFrame)(unsafe.Pointer(ctxPtr)).Fline, objv)
		} else {
			(*TCmdFrame)(unsafe.Pointer(ctxPtr)).Fline = XTcl_Alloc(tls, libc.Uint64FromInt32(objc)*uint64(8))
			(*TCmdFrame)(unsafe.Pointer(ctxPtr)).Fnline = int64(objc)
			k = 0
			for {
				if !(k < objc) {
					break
				}
				*(*TTcl_Size)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(ctxPtr)).Fline + uintptr(k)*8)) = int64(-int32(1))
				goto _29
			_29:
				;
				k++
			}
		}
	}
	j = int64(i + int32(1))
	for {
		if j >= int64(objc) {
			/*
			 * This shouldn't happen since we've checked that the last body is
			 * not a continuation...
			 */
			XTcl_Panic(tls, __ccgo_ts+20450, 0)
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(j)*8)))).Fbytes != 0 {
			v31 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(j)*8)))).Fbytes
		} else {
			v31 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(j)*8)), libc.UintptrFromInt32(0))
		}
		if libc.Xstrcmp(tls, v31, __ccgo_ts+6319) != 0 {
			break
		}
		goto _30
	_30:
		;
		j += int64(2)
	}
	/*
	 * TIP #280: Make invoking context available to switch branch.
	 */
	XTcl_NRAddCallback(tls, interp, __ccgo_fp(_SwitchPostProc), uintptr(int64(splitObjs)), ctxPtr, uintptr(int64(pc)), pattern)
	if splitObjs != 0 {
		v32 = j
	} else {
		v32 = int64(bidx) + j
	}
	return XTclNREvalObjEx(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(j)*8)), 0, ctxPtr, int32(v32))
}

/*
 * If you add options that make -e and -g not unique prefixes of -exact or
 * -glob, you *must* fix TclCompileSwitchCmd's option parser as well.
 */

var _options7 = [8]uintptr{
	0: __ccgo_ts + 17506,
	1: __ccgo_ts + 17513,
	2: __ccgo_ts + 19955,
	3: __ccgo_ts + 19965,
	4: __ccgo_ts + 17555,
	5: __ccgo_ts + 17574,
	6: __ccgo_ts + 18684,
	7: libc.UintptrFromInt32(0),
}

func _SwitchPostProc(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Result to return*/
	var _objPtr, ctxPtr, pattern, v2, v4 uintptr
	var limit, overflow, pc, splitObjs int32
	var patternLength, v1 TTcl_Size
	var v3 int64
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, ctxPtr, limit, overflow, pattern, patternLength, pc, splitObjs, v1, v2, v3, v4
	/* Unpack the preserved data */
	splitObjs = int32(int64(*(*uintptr)(unsafe.Pointer(data))))
	ctxPtr = *(*uintptr)(unsafe.Pointer(data + 1*8))
	pc = int32(int64(*(*uintptr)(unsafe.Pointer(data + 2*8))))
	pattern = *(*uintptr)(unsafe.Pointer(data + 3*8))
	patternLength = libc.Int64FromUint64(libc.Xstrlen(tls, pattern))
	/*
	 * Clean up TIP 280 context information
	 */
	if splitObjs != 0 {
		XTclpFree(tls, (*TCmdFrame)(unsafe.Pointer(ctxPtr)).Fline)
		if pc != 0 && (*TCmdFrame)(unsafe.Pointer(ctxPtr)).Ftype1 == int32(TCL_LOCATION_SOURCE) {
			/*
			 * Death of SrcInfo reference.
			 */
			_objPtr = (*TCmdFrame)(unsafe.Pointer(ctxPtr)).Fdata.Feval.Fpath
			v2 = _objPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if v1 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
	}
	/*
	 * Generate an error message if necessary.
	 */
	if result == int32(TCL_ERROR) {
		limit = int32(50)
		overflow = libc.BoolInt32(patternLength > int64(limit))
		if overflow != 0 {
			v3 = int64(limit)
		} else {
			v3 = patternLength
		}
		if overflow != 0 {
			v4 = __ccgo_ts + 8560
		} else {
			v4 = __ccgo_ts + 1945
		}
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+20500, libc.VaList(bp+8, int32(v3), pattern, v4, XTcl_GetErrorLine(tls, interp))))
	}
	XTclStackFree(tls, interp, ctxPtr)
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ThrowObjCmd --
 *
 *	This procedure is invoked to process the "throw" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ThrowObjCmd(tls *libc.TLS, dummy3965 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Argument objects. */
	var cachePtr, options uintptr
	var v1 int32
	var v2 int64
	var v3 bool
	var _ /* len at bp+0 */ TTcl_Size
	_, _, _, _, _ = cachePtr, options, v1, v2, v3
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+20528)
		return int32(TCL_ERROR)
	}
	/*
	 * The type must be a list of at least length 1.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanLength
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v2
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjLength(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
	}
	if v1 != TCL_OK {
		return int32(TCL_ERROR)
	} else {
		if *(*TTcl_Size)(unsafe.Pointer(bp)) < int64(1) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+20541, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+20569, __ccgo_ts+20575, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
	}
	/*
	 * Now prepare the result options dictionary. We use the list API as it is
	 * slightly more convenient.
	 */
	if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		options = XTclThreadAllocObj(tls)
	} else {
		options = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(options + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(options)).FrefCount = 0
	if libc.Uint64FromInt64(32)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(options)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(options)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(options)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(32)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(options)).Fbytes, __ccgo_ts+20588, libc.Uint64FromInt64(32)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(options)).Fbytes + uintptr(libc.Uint64FromInt64(32)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(options)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(32) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(options)).FtypePtr = libc.UintptrFromInt32(0)
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), options, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	/*
	 * We're ready to go. Fire things into the low-level result machinery.
	 */
	XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
	return XTcl_SetReturnOptions(tls, interp, options)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_TimeObjCmd --
 *
 *	This object-based procedure is invoked to process the "time" Tcl
 *	command. See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl object result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_TimeObjCmd(tls *libc.TLS, dummy4027 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* Argument objects. */
	var cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, objPtr uintptr
	var i, result, v1, v2 int32
	var totalMicroSec float64
	var v3, v5, v6, v7, v8 bool
	var v4 int64
	var _ /* count at bp+32 */ int32
	var _ /* objs at bp+0 */ [4]uintptr
	var _ /* start at bp+40 */ TTcl_Time
	var _ /* stop at bp+56 */ TTcl_Time
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, i, objPtr, result, totalMicroSec, v1, v2, v3, v4, v5, v6, v7, v8
	if objc == int32(2) {
		*(*int32)(unsafe.Pointer(bp + 32)) = int32(1)
	} else {
		if objc == int32(3) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
				*(*int32)(unsafe.Pointer(bp + 32)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep)))
				v1 = libc.Int32FromInt32(TCL_OK)
			} else {
				v1 = XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp+32)
			}
			result = v1
			if result != TCL_OK {
				return result
			}
		} else {
			XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+20620)
			return int32(TCL_ERROR)
		}
	}
	objPtr = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	i = *(*int32)(unsafe.Pointer(bp + 32))
	XTcl_GetTime(tls, bp+40)
	for {
		v2 = i
		i--
		if !(v2 > 0) {
			break
		}
		result = XTclEvalObjEx(tls, interp, objPtr, 0, libc.UintptrFromInt32(0), 0)
		if result != TCL_OK {
			return result
		}
	}
	XTcl_GetTime(tls, bp+56)
	totalMicroSec = float64(float64((*(*TTcl_Time)(unsafe.Pointer(bp + 56))).Fsec-(*(*TTcl_Time)(unsafe.Pointer(bp + 40))).Fsec)*float64(1e+06)) + float64((*(*TTcl_Time)(unsafe.Pointer(bp + 56))).Fusec-(*(*TTcl_Time)(unsafe.Pointer(bp + 40))).Fusec)
	if *(*int32)(unsafe.Pointer(bp + 32)) <= int32(1) {
		/*
		 * Use int obj since we know time is not fractional. [Bug 1202178]
		 */
		if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			(*(*[4]uintptr)(unsafe.Pointer(bp)))[0] = XTclThreadAllocObj(tls)
		} else {
			(*(*[4]uintptr)(unsafe.Pointer(bp)))[0] = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[0] + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[0])).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[0])).Fbytes = libc.UintptrFromInt32(0)
		if *(*int32)(unsafe.Pointer(bp + 32)) <= 0 {
			v4 = 0
		} else {
			v4 = int64(totalMicroSec)
		}
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[0])).FinternalRep)) = v4
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[0])).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	} else {
		if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v5 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			(*(*[4]uintptr)(unsafe.Pointer(bp)))[0] = XTclThreadAllocObj(tls)
		} else {
			(*(*[4]uintptr)(unsafe.Pointer(bp)))[0] = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[0] + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[0])).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[0])).Fbytes = libc.UintptrFromInt32(0)
		*(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[0])).FinternalRep)) = totalMicroSec / float64(*(*int32)(unsafe.Pointer(bp + 32)))
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[0])).FtypePtr = uintptr(unsafe.Pointer(&XtclDoubleType))
	}
	/*
	 * Construct the result as a list because many programs have always parsed
	 * as such (extracting the first element, typically).
	 */
	if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
		cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v6 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(1)] = XTclThreadAllocObj(tls)
	} else {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(1)] = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(1)] + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(1)])).FrefCount = 0
	if libc.Uint64FromInt64(13)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(1)])).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(1)])).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(1)])).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(13)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(1)])).Fbytes, __ccgo_ts+12446, libc.Uint64FromInt64(13)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(1)])).Fbytes + uintptr(libc.Uint64FromInt64(13)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(1)])).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(13) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(1)])).FtypePtr = libc.UintptrFromInt32(0)
	if v7 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v7 {
		cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v7 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)] = XTclThreadAllocObj(tls)
	} else {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)] = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)] + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).FrefCount = 0
	if libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes, __ccgo_ts+20636, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes + uintptr(libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(4) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).FtypePtr = libc.UintptrFromInt32(0)
	if v8 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v8 {
		cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v8 || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == libc.Uint64FromInt32(0) {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(3)] = XTclThreadAllocObj(tls)
	} else {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(3)] = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(3)] + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(3)])).FrefCount = 0
	if libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(3)])).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(3)])).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(3)])).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(3)])).Fbytes, __ccgo_ts+20640, libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(3)])).Fbytes + uintptr(libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(3)])).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(10) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(3)])).FtypePtr = libc.UintptrFromInt32(0)
	XTcl_SetObjResult(tls, interp, XTcl_NewListObj(tls, int64(4), bp))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_TimeRateObjCmd --
 *
 *	This object-based procedure is invoked to process the "timerate" Tcl
 *	command.
 *
 *	This is similar to command "time", except the execution limited by
 *	given time (in milliseconds) instead of repetition count.
 *
 * Example:
 *	timerate {after 5} 1000; # equivalent to: time {after 5} [expr 1000/5]
 *
 * Results:
 *	A standard Tcl object result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_TimeRateObjCmd(tls *libc.TLS, dummy4125 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(192)
	defer tls.Free(192) /* Argument objects. */
	var _objPtr, _objPtr1, cachePtr, cachePtr1, cachePtr10, cachePtr11, cachePtr12, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cachePtr8, cachePtr9, calibrate, codePtr, direct, objPtr, objs, rootPtr, v12, v17, v20 uintptr
	var count, curOverhead, maxIterTm, maxcnt, threshold, usec, val, v18 TTcl_WideUInt
	var digits, i, result, v13, v14, v2, v4, v5, v6, v8, v9 int32
	var factor uint16
	var lastMeasureOverhead float64
	var maxCalTime, middle, start, stop TTcl_WideInt
	var v10, v15, v19, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30 bool
	var v11, v16 TTcl_Size
	var v7 int64
	var _ /* clobjv at bp+48 */ [6]uintptr
	var _ /* index at bp+32 */ int32
	var _ /* maxms at bp+8 */ TTcl_WideInt
	var _ /* now at bp+16 */ TTcl_Time
	var _ /* objarr at bp+96 */ [8]uintptr
	var _ /* overhead at bp+0 */ float64
	var _ /* v at bp+40 */ TTcl_WideInt
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, cachePtr1, cachePtr10, cachePtr11, cachePtr12, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cachePtr8, cachePtr9, calibrate, codePtr, count, curOverhead, digits, direct, factor, i, lastMeasureOverhead, maxCalTime, maxIterTm, maxcnt, middle, objPtr, objs, result, rootPtr, start, stop, threshold, usec, val, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v4, v5, v6, v7, v8, v9
	/* global measure-overhead */
	*(*float64)(unsafe.Pointer(bp)) = float64(-libc.Int32FromInt32(1))
	calibrate = libc.UintptrFromInt32(0)
	direct = libc.UintptrFromInt32(0)
	count = uint64(0) /* Holds repetition count */
	*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) = libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) + libc.Uint64FromInt32(1))
	/* Maximal running time (in milliseconds) */
	maxcnt = libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1)))
	/* Maximal count of iterations. */
	threshold = uint64(1) /* Current threshold for check time (faster
	 * repeat count without time check) */
	maxIterTm = uint64(1) /* Max time of some iteration as max
	 * threshold, additionally avoiding divide to
	 * zero (i.e., never < 1) */
	factor = uint16(50)
	codePtr = libc.UintptrFromInt32(0)
	i = int32(1)
	for {
		if !(i < objc-int32(1)) {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_options8)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(TCL_EXACT)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+32) != TCL_OK {
			break
		}
		if *(*int32)(unsafe.Pointer(bp + 32)) == 3 {
			i++
			break
		}
		switch *(*int32)(unsafe.Pointer(bp + 32)) {
		case 0:
			direct = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
		case 1:
			i++
			v2 = i
			if v2 >= objc-int32(1) {
				goto usage
			}
			if XTcl_GetDoubleFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp) != TCL_OK {
				return int32(TCL_ERROR)
			}
		case 2:
			calibrate = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
		case 3:
			break
		}
		goto _1
	_1:
		;
		i++
	}
	if !(i >= objc || i < objc-int32(3)) {
		goto _3
	}
	goto usage
usage:
	;
	XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+20679)
	return int32(TCL_ERROR)
_3:
	;
	v4 = i
	i++
	objPtr = *(*uintptr)(unsafe.Pointer(objv + uintptr(v4)*8))
	if i < objc { /* max-time */
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
			*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep))
			v5 = libc.Int32FromInt32(TCL_OK)
		} else {
			v5 = XTcl_GetWideIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp+8)
		}
		result = v5
		i++ // Keep this separate from TclGetWideIntFromObj macro above!
		if result != TCL_OK {
			return result
		}
		if i < objc {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
				*(*TTcl_WideInt)(unsafe.Pointer(bp + 40)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep))
				v6 = libc.Int32FromInt32(TCL_OK)
			} else {
				v6 = XTcl_GetWideIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp+40)
			}
			result = v6
			if result != TCL_OK {
				return result
			}
			if *(*TTcl_WideInt)(unsafe.Pointer(bp + 40)) > 0 {
				v7 = *(*TTcl_WideInt)(unsafe.Pointer(bp + 40))
			} else {
				v7 = 0
			}
			maxcnt = libc.Uint64FromInt64(v7)
		}
	}
	/*
	 * If we are doing calibration.
	 */
	if calibrate != 0 {
		/*
		 * If no time specified for the calibration.
		 */
		if *(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) == libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))+libc.Uint64FromInt32(1)) {
			maxCalTime = int64(5000)
			lastMeasureOverhead = _measureOverhead
			(*(*[6]uintptr)(unsafe.Pointer(bp + 48)))[0] = *(*uintptr)(unsafe.Pointer(objv))
			i = int32(1)
			if direct != 0 {
				v8 = i
				i++
				(*(*[6]uintptr)(unsafe.Pointer(bp + 48)))[v8] = direct
			}
			v9 = i
			i++
			(*(*[6]uintptr)(unsafe.Pointer(bp + 48)))[v9] = objPtr
			/*
			 * Reset last measurement overhead.
			 */
			_measureOverhead = libc.Float64FromInt32(0)
			/*
			 * Self-call with 100 milliseconds to warm-up, before entering the
			 * calibration cycle.
			 */
			if v10 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v10 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v10 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				(*(*[6]uintptr)(unsafe.Pointer(bp + 48)))[i] = XTclThreadAllocObj(tls)
			} else {
				(*(*[6]uintptr)(unsafe.Pointer(bp + 48)))[i] = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*(*[6]uintptr)(unsafe.Pointer(bp + 48)))[i] + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer((*(*[6]uintptr)(unsafe.Pointer(bp + 48)))[i])).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer((*(*[6]uintptr)(unsafe.Pointer(bp + 48)))[i])).Fbytes = libc.UintptrFromInt32(0)
			*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer((*(*[6]uintptr)(unsafe.Pointer(bp + 48)))[i])).FinternalRep)) = int64(libc.Int32FromInt32(100))
			(*TTcl_Obj)(unsafe.Pointer((*(*[6]uintptr)(unsafe.Pointer(bp + 48)))[i])).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
			(*TTcl_Obj)(unsafe.Pointer((*(*[6]uintptr)(unsafe.Pointer(bp + 48)))[i])).FrefCount++
			result = XTcl_TimeRateObjCmd(tls, libc.UintptrFromInt32(0), interp, i+int32(1), bp+48)
			_objPtr = (*(*[6]uintptr)(unsafe.Pointer(bp + 48)))[i]
			v12 = _objPtr
			v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
			*(*TTcl_Size)(unsafe.Pointer(v12))--
			if v11 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			if result != TCL_OK {
				return result
			}
			i--
			v13 = i
			i++
			(*(*[6]uintptr)(unsafe.Pointer(bp + 48)))[v13] = calibrate
			v14 = i
			i++
			(*(*[6]uintptr)(unsafe.Pointer(bp + 48)))[v14] = objPtr
			/*
			 * Set last measurement overhead to max.
			 */
			_measureOverhead = float64(libc.Uint64FromInt32(-libc.Int32FromInt32(1)))
			/*
			 * Run the calibration cycle until it is more precise.
			 */
			*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) = int64(-int32(1000))
			for cond := true; cond; cond = (_measureOverhead >= lastMeasureOverhead || _measureOverhead/lastMeasureOverhead <= float64(0.9995)) && maxCalTime > 0 {
				lastMeasureOverhead = _measureOverhead
				if v15 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v15 {
					cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v15 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
					(*(*[6]uintptr)(unsafe.Pointer(bp + 48)))[i] = XTclThreadAllocObj(tls)
				} else {
					(*(*[6]uintptr)(unsafe.Pointer(bp + 48)))[i] = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer((*(*[6]uintptr)(unsafe.Pointer(bp + 48)))[i] + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer((*(*[6]uintptr)(unsafe.Pointer(bp + 48)))[i])).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer((*(*[6]uintptr)(unsafe.Pointer(bp + 48)))[i])).Fbytes = libc.UintptrFromInt32(0)
				*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer((*(*[6]uintptr)(unsafe.Pointer(bp + 48)))[i])).FinternalRep)) = int64(int32(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8))))
				(*TTcl_Obj)(unsafe.Pointer((*(*[6]uintptr)(unsafe.Pointer(bp + 48)))[i])).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
				(*TTcl_Obj)(unsafe.Pointer((*(*[6]uintptr)(unsafe.Pointer(bp + 48)))[i])).FrefCount++
				result = XTcl_TimeRateObjCmd(tls, libc.UintptrFromInt32(0), interp, i+int32(1), bp+48)
				_objPtr1 = (*(*[6]uintptr)(unsafe.Pointer(bp + 48)))[i]
				v17 = _objPtr1
				v16 = *(*TTcl_Size)(unsafe.Pointer(v17))
				*(*TTcl_Size)(unsafe.Pointer(v17))--
				if v16 <= int64(1) {
					XTclFreeObj(tls, _objPtr1)
				}
				if result != TCL_OK {
					return result
				}
				maxCalTime += *(*TTcl_WideInt)(unsafe.Pointer(bp + 8))
				/*
				 * Increase maxms for more precise calibration.
				 */
				*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) -= -*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) / int64(4)
				/*
				 * As long as new value more as 0.05% better
				 */
			}
			return result
		}
		if *(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) == 0 {
			/*
			 * Reset last measurement overhead
			 */
			_measureOverhead = libc.Float64FromInt32(0)
			XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, 0))
			return TCL_OK
		}
		/*
		 * If time is negative, make current overhead more precise.
		 */
		if *(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) > 0 {
			/*
			 * Set last measurement overhead to max.
			 */
			_measureOverhead = float64(libc.Uint64FromInt32(-libc.Int32FromInt32(1)))
		} else {
			*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) = -*(*TTcl_WideInt)(unsafe.Pointer(bp + 8))
		}
	}
	if *(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) == libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))+libc.Uint64FromInt32(1)) {
		*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) = int64(1000)
	}
	if *(*float64)(unsafe.Pointer(bp)) == float64(-libc.Int32FromInt32(1)) {
		*(*float64)(unsafe.Pointer(bp)) = _measureOverhead
	}
	/*
	 * Ensure that resetting of result will not smudge the further
	 * measurement.
	 */
	XTcl_ResetResult(tls, interp)
	/*
	 * Compile object if needed.
	 */
	if !(direct != 0) {
		if XTclInterpReady(tls, interp) != TCL_OK {
			return int32(TCL_ERROR)
		}
		codePtr = XTclCompileObj(tls, interp, objPtr, libc.UintptrFromInt32(0), 0)
		XTclPreserveByteCode(tls, codePtr)
	}
	/*
	 * Get start and stop time.
	 */
	XTcl_GetTime(tls, bp+16)
	start = (*(*TTcl_Time)(unsafe.Pointer(bp + 16))).Fsec
	start *= int64(1000000)
	start += (*(*TTcl_Time)(unsafe.Pointer(bp + 16))).Fusec
	middle = start
	/*
	 * Time to stop execution (in microsecs).
	 */
	stop = start + *(*TTcl_WideInt)(unsafe.Pointer(bp + 8))*int64(1000)
	/*
	 * Start measurement.
	 */
	if maxcnt > uint64(0) {
		for int32(1) != 0 {
			/*
			 * Evaluate a single iteration.
			 */
			count++
			if !(direct != 0) { /* precompiled */
				rootPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
				/*
				 * Use loop optimized TEBC call (TCL_EVAL_DISCARD_RESULT): it's a part of
				 * iteration, this way evaluation will be more similar to a cycle (also
				 * avoids extra overhead to set result to interp, etc.)
				 */
				*(*int32)(unsafe.Pointer(interp + 256)) |= int32(TCL_EVAL_DISCARD_RESULT)
				result = XTclNRExecuteByteCode(tls, interp, codePtr)
				result = XTclNRRunCallbacks(tls, interp, result, rootPtr)
			} else { /* eval */
				result = XTclEvalObjEx(tls, interp, objPtr, 0, libc.UintptrFromInt32(0), 0)
			}
			/*
			 * Allow break and continue from measurement cycle (used for
			 * conditional stop and flow control of iterations).
			 */
			switch result {
			case TCL_OK:
			case int32(TCL_BREAK):
				/*
				 * Force stop immediately.
				 */
				threshold = uint64(1)
				maxcnt = uint64(0)
				/* FALLTHRU */
				fallthrough
			case int32(TCL_CONTINUE):
				result = TCL_OK
			default:
				goto done
			}
			/*
			 * Don't check time up to threshold.
			 */
			threshold--
			v18 = threshold
			if v18 > uint64(0) {
				continue
			}
			/*
			 * Check stop time reached, estimate new threshold.
			 */
			XTcl_GetTime(tls, bp+16)
			middle = (*(*TTcl_Time)(unsafe.Pointer(bp + 16))).Fsec
			middle *= int64(1000000)
			middle += (*(*TTcl_Time)(unsafe.Pointer(bp + 16))).Fusec
			if middle >= stop || count >= maxcnt {
				break
			}
			/*
			 * Don't calculate threshold by few iterations, because sometimes
			 * first iteration(s) can be too fast or slow (cached, delayed
			 * clean up, etc).
			 */
			if count < uint64(10) {
				threshold = uint64(1)
				continue
			}
			/*
			 * Average iteration time in microsecs.
			 */
			threshold = libc.Uint64FromInt64(middle-start) / count
			if threshold > maxIterTm {
				maxIterTm = threshold
				/*
				 * Iterations seem to be longer.
				 */
				if threshold > maxIterTm*uint64(2) {
					factor = uint16(int32(factor) * libc.Int32FromInt32(2))
					if libc.Int32FromUint16(factor) > int32(50) {
						factor = uint16(50)
					}
				} else {
					if libc.Int32FromUint16(factor) < int32(50) {
						factor++
					}
				}
			} else {
				if libc.Int32FromUint16(factor) > int32(4) {
					/*
					 * Iterations seem to be shorter.
					 */
					if threshold < maxIterTm/uint64(2) {
						factor = uint16(int32(factor) / libc.Int32FromInt32(2))
						if libc.Int32FromUint16(factor) < int32(4) {
							factor = uint16(4)
						}
					} else {
						factor--
					}
				}
			}
			/*
			 * As relation between remaining time and time since last check,
			 * maximal some % of time (by factor), so avoid growing of the
			 * execution time if iterations are not consistent, e.g. was
			 * continuously on time).
			 */
			threshold = libc.Uint64FromInt64(stop-middle)/maxIterTm/uint64(factor) + uint64(1)
			if threshold > uint64(100000) { /* fix for too large threshold */
				threshold = uint64(100000)
			}
			/*
			 * Consider max-count
			 */
			if threshold > maxcnt-count {
				threshold = maxcnt - count
			}
		}
	}
	objs = bp + 96
	/*
	 * Absolute execution time in microseconds or in wide clicks.
	 */
	usec = libc.Uint64FromInt64(middle - start)
	if !(count != 0) { /* no iterations - avoid divide by zero */
		if v19 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v19 {
			cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v19 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(objs + 4*8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(objs + 4*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 4*8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 4*8)))).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 4*8)))).Fbytes = libc.UintptrFromInt32(0)
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 4*8)))).FinternalRep)) = int64(libc.Int32FromInt32(0))
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 4*8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
		v20 = *(*uintptr)(unsafe.Pointer(objs + 4*8))
		*(*uintptr)(unsafe.Pointer(objs + 2*8)) = v20
		*(*uintptr)(unsafe.Pointer(objs)) = v20
		goto retRes
	}
	/*
	 * If not calibrating...
	 */
	if !(calibrate != 0) {
		/*
		 * Minimize influence of measurement overhead.
		 */
		if *(*float64)(unsafe.Pointer(bp)) > libc.Float64FromInt32(0) {
			/*
			 * Estimate the time of overhead (microsecs).
			 */
			curOverhead = uint64(*(*float64)(unsafe.Pointer(bp)) * float64(count))
			if usec > curOverhead {
				usec -= curOverhead
			} else {
				usec = uint64(0)
			}
		}
	} else {
		/*
		 * Calibration: obtaining new measurement overhead.
		 */
		if _measureOverhead > float64(usec)/float64(count) {
			_measureOverhead = float64(usec) / float64(count)
		}
		if v21 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v21 {
			cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v21 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(objs)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(objs)) = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs)))).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs)))).Fbytes = libc.UintptrFromInt32(0)
		*(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs)))).FinternalRep)) = _measureOverhead
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs)))).FtypePtr = uintptr(unsafe.Pointer(&XtclDoubleType))
		if v22 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v22 {
			cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v22 || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(objs + 1*8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(objs + 1*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 1*8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 1*8)))).FrefCount = 0
		if libc.Uint64FromInt64(15)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 1*8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 1*8)))).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 1*8)))).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(15)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 1*8)))).Fbytes, __ccgo_ts+20748, libc.Uint64FromInt64(15)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 1*8)))).Fbytes + uintptr(libc.Uint64FromInt64(15)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 1*8)))).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(15) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 1*8)))).FtypePtr = libc.UintptrFromInt32(0) /* mics */
		objs += uintptr(2) * 8
	}
	val = usec / count /* microsecs per iteration */
	if val >= uint64(1000000) {
		if v23 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v23 {
			cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v23 || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(objs)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(objs)) = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs)))).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs)))).Fbytes = libc.UintptrFromInt32(0)
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs)))).FinternalRep)) = libc.Int64FromUint64(val)
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	} else {
		if val < uint64(10) {
			digits = int32(6)
		} else {
			if val < uint64(100) {
				digits = int32(4)
			} else {
				if val < uint64(1000) {
					digits = int32(3)
				} else {
					if val < uint64(10000) {
						digits = int32(2)
					} else {
						digits = int32(1)
					}
				}
			}
		}
		*(*uintptr)(unsafe.Pointer(objs)) = XTcl_ObjPrintf(tls, __ccgo_ts+20763, libc.VaList(bp+168, digits, float64(usec)/float64(count)))
	}
	if v24 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v24 {
		cachePtr6 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v24 || (*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects == libc.Uint64FromInt32(0) {
		*(*uintptr)(unsafe.Pointer(objs + 2*8)) = XTclThreadAllocObj(tls)
	} else {
		*(*uintptr)(unsafe.Pointer(objs + 2*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 2*8)) + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 2*8)))).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 2*8)))).Fbytes = libc.UintptrFromInt32(0)
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 2*8)))).FinternalRep)) = libc.Int64FromUint64(count)
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 2*8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType)) /* iterations */
	/*
	 * Calculate speed as rate (count) per sec
	 */
	if !(usec != 0) {
		usec++ /* Avoid divide by zero. */
	}
	if count < libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))/libc.Int64FromInt32(1000000)) {
		val = count * uint64(1000000) / usec
		if val < uint64(100000) {
			if val < uint64(100) {
				digits = int32(3)
			} else {
				if val < uint64(1000) {
					digits = int32(2)
				} else {
					digits = int32(1)
				}
			}
			*(*uintptr)(unsafe.Pointer(objs + 4*8)) = XTcl_ObjPrintf(tls, __ccgo_ts+20763, libc.VaList(bp+168, digits, float64(count*libc.Uint64FromInt32(1000000))/float64(usec)))
		} else {
			if v25 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v25 {
				cachePtr7 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v25 || (*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects == libc.Uint64FromInt32(0) {
				*(*uintptr)(unsafe.Pointer(objs + 4*8)) = XTclThreadAllocObj(tls)
			} else {
				*(*uintptr)(unsafe.Pointer(objs + 4*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 4*8)) + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 4*8)))).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 4*8)))).Fbytes = libc.UintptrFromInt32(0)
			*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 4*8)))).FinternalRep)) = libc.Int64FromUint64(val)
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 4*8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
		}
	} else {
		*(*uintptr)(unsafe.Pointer(objs + 4*8)) = XTcl_NewWideIntObj(tls, libc.Int64FromUint64(count/usec*uint64(1000000)))
	}
	goto retRes
retRes:
	;
	/*
	 * Estimated net execution time (in millisecs).
	 */
	if !(calibrate != 0) {
		if usec >= uint64(1) {
			*(*uintptr)(unsafe.Pointer(objs + 6*8)) = XTcl_ObjPrintf(tls, __ccgo_ts+20768, libc.VaList(bp+168, float64(usec)/libc.Float64FromInt32(1000)))
		} else {
			if v26 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v26 {
				cachePtr8 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v26 || (*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects == libc.Uint64FromInt32(0) {
				*(*uintptr)(unsafe.Pointer(objs + 6*8)) = XTclThreadAllocObj(tls)
			} else {
				*(*uintptr)(unsafe.Pointer(objs + 6*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr8)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr8)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 6*8)) + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 6*8)))).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 6*8)))).Fbytes = libc.UintptrFromInt32(0)
			*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 6*8)))).FinternalRep)) = int64(libc.Int32FromInt32(0))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 6*8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
		}
		if v27 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v27 {
			cachePtr9 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v27 || (*TAllocCache)(unsafe.Pointer(cachePtr9)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(objs + 7*8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(objs + 7*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr9)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr9)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 7*8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr9)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 7*8)))).FrefCount = 0
		if libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 7*8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 7*8)))).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 7*8)))).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 7*8)))).Fbytes, __ccgo_ts+20773, libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 7*8)))).Fbytes + uintptr(libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 7*8)))).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(7) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 7*8)))).FtypePtr = libc.UintptrFromInt32(0)
	}
	/*
	 * Construct the result as a list because many programs have always
	 * parsed as such (extracting the first element, typically).
	 */
	if v28 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v28 {
		cachePtr10 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v28 || (*TAllocCache)(unsafe.Pointer(cachePtr10)).FnumObjects == libc.Uint64FromInt32(0) {
		*(*uintptr)(unsafe.Pointer(objs + 1*8)) = XTclThreadAllocObj(tls)
	} else {
		*(*uintptr)(unsafe.Pointer(objs + 1*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr10)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr10)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 1*8)) + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr10)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 1*8)))).FrefCount = 0
	if libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 1*8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 1*8)))).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 1*8)))).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 1*8)))).Fbytes, __ccgo_ts+20780, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 1*8)))).Fbytes + uintptr(libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 1*8)))).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(6) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 1*8)))).FtypePtr = libc.UintptrFromInt32(0) /* mics/# */
	if v29 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v29 {
		cachePtr11 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v29 || (*TAllocCache)(unsafe.Pointer(cachePtr11)).FnumObjects == libc.Uint64FromInt32(0) {
		*(*uintptr)(unsafe.Pointer(objs + 3*8)) = XTclThreadAllocObj(tls)
	} else {
		*(*uintptr)(unsafe.Pointer(objs + 3*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr11)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr11)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 3*8)) + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr11)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 3*8)))).FrefCount = 0
	if libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 3*8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 3*8)))).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 3*8)))).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 3*8)))).Fbytes, __ccgo_ts+20786, libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 3*8)))).Fbytes + uintptr(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 3*8)))).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(2) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 3*8)))).FtypePtr = libc.UintptrFromInt32(0)
	if v30 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v30 {
		cachePtr12 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v30 || (*TAllocCache)(unsafe.Pointer(cachePtr12)).FnumObjects == libc.Uint64FromInt32(0) {
		*(*uintptr)(unsafe.Pointer(objs + 5*8)) = XTclThreadAllocObj(tls)
	} else {
		*(*uintptr)(unsafe.Pointer(objs + 5*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr12)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr12)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 5*8)) + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr12)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 5*8)))).FrefCount = 0
	if libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 5*8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 5*8)))).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 5*8)))).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 5*8)))).Fbytes, __ccgo_ts+20788, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 5*8)))).Fbytes + uintptr(libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 5*8)))).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(6) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objs + 5*8)))).FtypePtr = libc.UintptrFromInt32(0)
	XTcl_SetObjResult(tls, interp, XTcl_NewListObj(tls, int64(8), bp+96))
	goto done
done:
	;
	if codePtr != libc.UintptrFromInt32(0) {
		XTclReleaseByteCode(tls, codePtr)
	}
	return result
}

var _measureOverhead = libc.Float64FromInt32(0)

var _options8 = [5]uintptr{
	0: __ccgo_ts + 20650,
	1: __ccgo_ts + 20658,
	2: __ccgo_ts + 20668,
	3: __ccgo_ts + 18684,
	4: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_TryObjCmd, TclNRTryObjCmd --
 *
 *	This procedure is invoked to process the "try" Tcl command. See the
 *	user documentation (or TIP #329) for details on what it does.
 *
 * Results:
 *	A standard Tcl object result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_TryObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	return XTcl_NRCallObjProc(tls, interp, __ccgo_fp(XTclNRTryObjCmd), clientData, int64(objc), objv)
}

func XTclNRTryObjCmd(tls *libc.TLS, dummy4682 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(128)
	defer tls.Free(128) /* Argument objects. */
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, _objPtr6, _objPtr7, _objPtr8, _objPtr9, bodyObj, cachePtr, cachePtr1, cachePtr2, finallyObj, handlersObj, v10, v12, v15, v17, v19, v22, v24, v28, v31, v33, v35, v4 uintptr
	var bodyShared, haveHandlers, i, v13, v20, v25 int32
	var v1, v29, v30 bool
	var v11, v14, v16, v18, v23, v27, v3, v32, v34, v9 TTcl_Size
	var v21, v26 int64
	var _ /* code at bp+0 */ int32
	var _ /* dummy at bp+8 */ TTcl_Size
	var _ /* info at bp+24 */ [5]uintptr
	var _ /* type at bp+16 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, _objPtr6, _objPtr7, _objPtr8, _objPtr9, bodyObj, bodyShared, cachePtr, cachePtr1, cachePtr2, finallyObj, handlersObj, haveHandlers, i, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v4, v9
	finallyObj = libc.UintptrFromInt32(0)
	/*
	 * Parse the arguments. The handlers are passed to subsequent callbacks as
	 * a Tcl_Obj list of the 5-tuples like (type, returnCode, errorCodePrefix,
	 * bindVariables, script), and the finally script is just passed as it is.
	 */
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+20810)
		return int32(TCL_ERROR)
	}
	bodyObj = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		handlersObj = XTclThreadAllocObj(tls)
	} else {
		handlersObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(handlersObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(handlersObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(handlersObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(handlersObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(handlersObj)).FtypePtr = libc.UintptrFromInt32(0)
	bodyShared = 0
	haveHandlers = 0
	i = int32(2)
	for {
		if !(i < objc) {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_handlerNames)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+20846, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+16) != TCL_OK {
			_objPtr = handlersObj
			v4 = _objPtr
			v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
			*(*TTcl_Size)(unsafe.Pointer(v4))--
			if v3 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			return int32(TCL_ERROR)
		}
		switch *(*int32)(unsafe.Pointer(bp + 16)) {
		case 0:
			goto _5
		case 1:
			goto _6
		case 2:
			goto _7
		}
		goto _8
	_5:
		; /* finally script */
		if i < objc-int32(2) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+20859, int64(-int32(1))))
			_objPtr1 = handlersObj
			v10 = _objPtr1
			v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
			*(*TTcl_Size)(unsafe.Pointer(v10))--
			if v9 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+72, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+20887, __ccgo_ts+20891, __ccgo_ts+20899, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		} else {
			if i == objc-int32(1) {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+20911, int64(-int32(1))))
				_objPtr2 = handlersObj
				v12 = _objPtr2
				v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
				*(*TTcl_Size)(unsafe.Pointer(v12))--
				if v11 <= int64(1) {
					XTclFreeObj(tls, _objPtr2)
				}
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+72, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+20887, __ccgo_ts+20891, __ccgo_ts+16490, libc.UintptrFromInt32(0)))
				return int32(TCL_ERROR)
			}
		}
		i++
		v13 = i
		finallyObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(v13)*8))
		goto _8
	_6:
		; /* on code variableList script */
		if i > objc-int32(4) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+20972, int64(-int32(1))))
			_objPtr3 = handlersObj
			v15 = _objPtr3
			v14 = *(*TTcl_Size)(unsafe.Pointer(v15))
			*(*TTcl_Size)(unsafe.Pointer(v15))--
			if v14 <= int64(1) {
				XTclFreeObj(tls, _objPtr3)
			}
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+72, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+20887, __ccgo_ts+21041, __ccgo_ts+16490, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		if XTclGetCompletionCodeFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)), bp) != TCL_OK {
			_objPtr4 = handlersObj
			v17 = _objPtr4
			v16 = *(*TTcl_Size)(unsafe.Pointer(v17))
			*(*TTcl_Size)(unsafe.Pointer(v17))--
			if v16 <= int64(1) {
				XTclFreeObj(tls, _objPtr4)
			}
			return int32(TCL_ERROR)
		}
		(*(*[5]uintptr)(unsafe.Pointer(bp + 24)))[int32(2)] = libc.UintptrFromInt32(0)
		goto commonHandler
	_7:
		; /* trap pattern variableList script */
		if i > objc-int32(4) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+21044, int64(-int32(1))))
			_objPtr5 = handlersObj
			v19 = _objPtr5
			v18 = *(*TTcl_Size)(unsafe.Pointer(v19))
			*(*TTcl_Size)(unsafe.Pointer(v19))--
			if v18 <= int64(1) {
				XTclFreeObj(tls, _objPtr5)
			}
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+72, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+20887, __ccgo_ts+21120, __ccgo_ts+16490, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		*(*int32)(unsafe.Pointer(bp)) = int32(1)
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)) + 32))).Fptr2 != 0 {
				v21 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)) + 32))).Fptr2)).FspanLength
			} else {
				v21 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v21
			v20 = libc.Int32FromInt32(TCL_OK)
		} else {
			v20 = XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)), bp+8)
		}
		if v20 != TCL_OK {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)))).Fbytes != 0 {
				v22 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)))).Fbytes
			} else {
				v22 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)), libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+21125, libc.VaList(bp+72, v22)))
			_objPtr6 = handlersObj
			v24 = _objPtr6
			v23 = *(*TTcl_Size)(unsafe.Pointer(v24))
			*(*TTcl_Size)(unsafe.Pointer(v24))--
			if v23 <= int64(1) {
				XTclFreeObj(tls, _objPtr6)
			}
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+72, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+20887, __ccgo_ts+21120, __ccgo_ts+21157, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		(*(*[5]uintptr)(unsafe.Pointer(bp + 24)))[int32(2)] = *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8))
		goto commonHandler
	commonHandler:
		;
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(2))*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(2))*8)) + 32))).Fptr2 != 0 {
				v26 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(2))*8)) + 32))).Fptr2)).FspanLength
			} else {
				v26 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(2))*8)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v26
			v25 = libc.Int32FromInt32(TCL_OK)
		} else {
			v25 = XTcl_ListObjLength(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(2))*8)), bp+8)
		}
		if v25 != TCL_OK {
			_objPtr7 = handlersObj
			v28 = _objPtr7
			v27 = *(*TTcl_Size)(unsafe.Pointer(v28))
			*(*TTcl_Size)(unsafe.Pointer(v28))--
			if v27 <= int64(1) {
				XTclFreeObj(tls, _objPtr7)
			}
			return int32(TCL_ERROR)
		}
		(*(*[5]uintptr)(unsafe.Pointer(bp + 24)))[0] = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) /* type */
		if v29 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v29 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v29 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			(*(*[5]uintptr)(unsafe.Pointer(bp + 24)))[int32(1)] = XTclThreadAllocObj(tls)
		} else {
			(*(*[5]uintptr)(unsafe.Pointer(bp + 24)))[int32(1)] = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 24)))[int32(1)] + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 24)))[int32(1)])).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 24)))[int32(1)])).Fbytes = libc.UintptrFromInt32(0)
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 24)))[int32(1)])).FinternalRep)) = int64(*(*int32)(unsafe.Pointer(bp)))
		(*TTcl_Obj)(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 24)))[int32(1)])).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType)) /* returnCode */
		if (*(*[5]uintptr)(unsafe.Pointer(bp + 24)))[int32(2)] == libc.UintptrFromInt32(0) {                                              /* errorCodePrefix */
			if v30 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v30 {
				cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v30 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
				(*(*[5]uintptr)(unsafe.Pointer(bp + 24)))[int32(2)] = XTclThreadAllocObj(tls)
			} else {
				(*(*[5]uintptr)(unsafe.Pointer(bp + 24)))[int32(2)] = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 24)))[int32(2)] + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 24)))[int32(2)])).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 24)))[int32(2)])).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 24)))[int32(2)])).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 24)))[int32(2)])).FtypePtr = libc.UintptrFromInt32(0)
		}
		(*(*[5]uintptr)(unsafe.Pointer(bp + 24)))[int32(3)] = *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(2))*8)) /* bindVariables */
		(*(*[5]uintptr)(unsafe.Pointer(bp + 24)))[int32(4)] = *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(3))*8)) /* script */
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(3))*8)))).Fbytes != 0 {
			v31 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(3))*8)))).Fbytes
		} else {
			v31 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(3))*8)), libc.UintptrFromInt32(0))
		}
		bodyShared = libc.BoolInt32(!(libc.Xstrcmp(tls, v31, __ccgo_ts+6319) != 0))
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), handlersObj, XTcl_NewListObj(tls, int64(5), bp+24))
		haveHandlers = int32(1)
		i += int32(3)
		goto _8
	_8:
		;
		goto _2
	_2:
		;
		i++
	}
	if bodyShared != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+21167, int64(-int32(1))))
		_objPtr8 = handlersObj
		v33 = _objPtr8
		v32 = *(*TTcl_Size)(unsafe.Pointer(v33))
		*(*TTcl_Size)(unsafe.Pointer(v33))--
		if v32 <= int64(1) {
			XTclFreeObj(tls, _objPtr8)
		}
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+72, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+20887, __ccgo_ts+21219, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if !(haveHandlers != 0) {
		_objPtr9 = handlersObj
		v35 = _objPtr9
		v34 = *(*TTcl_Size)(unsafe.Pointer(v35))
		*(*TTcl_Size)(unsafe.Pointer(v35))--
		if v34 <= int64(1) {
			XTclFreeObj(tls, _objPtr9)
		}
		handlersObj = libc.UintptrFromInt32(0)
	}
	/*
	 * Execute the body.
	 */
	XTcl_NRAddCallback(tls, interp, __ccgo_fp(_TryPostBody), handlersObj, finallyObj, objv, uintptr(int64(objc)))
	return XTclNREvalObjEx(tls, interp, bodyObj, 0, (*TInterp)(unsafe.Pointer(interp)).FcmdFramePtr, int32(1))
}

var _handlerNames = [4]uintptr{
	0: __ccgo_ts + 20794,
	1: __ccgo_ts + 20802,
	2: __ccgo_ts + 20805,
	3: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * During --
 *
 *	This helper function patches together the updates to the interpreter's
 *	return options that are needed when things fail during the processing
 *	of a handler or finally script for the [try] command.
 *
 * Returns:
 *	The new option dictionary.
 *
 *----------------------------------------------------------------------
 */

func _During(tls *libc.TLS, interp uintptr, resultCode int32, oldOptions uintptr, errorInfo uintptr) (r uintptr) {
	/* An object to append to the errorinfo and
	 * release, or NULL if nothing is to be added.
	 * Designed to be used with Tcl_ObjPrintf. */
	var _objPtr, options, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _ = _objPtr, options, v1, v2
	if errorInfo != libc.UintptrFromInt32(0) {
		XTcl_AppendObjToErrorInfo(tls, interp, errorInfo)
	}
	options = XTcl_GetReturnOptions(tls, interp, resultCode)
	XTclDictPut(tls, interp, options, __ccgo_ts+21234, oldOptions)
	(*TTcl_Obj)(unsafe.Pointer(options)).FrefCount++
	_objPtr = oldOptions
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return options
}

/*
 *----------------------------------------------------------------------
 *
 * TryPostBody --
 *
 *	Callback to handle the outcome of the execution of the body of a 'try'
 *	command.
 *
 *----------------------------------------------------------------------
 */

func _TryPostBody(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(112)
	defer tls.Free(112)
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, _objPtr6, _objPtr7, cmdObj, finallyObj, handlerBodyObj, handlersObj, objv, options, resultObj, v1, v19, v23, v25, v27, v3, v30, v32, v34, v36, v4 uintptr
	var found, objc, v15, v28 int32
	var i, j, v2, v22, v24, v26, v29, v31, v33, v35 TTcl_Size
	var v10, v11, v13, v14, v16, v17, v21, v6, v7 int64
	var _ /* bits1 at bp+48 */ uintptr
	var _ /* bits2 at bp+56 */ uintptr
	var _ /* code at bp+0 */ int32
	var _ /* errcode at bp+40 */ uintptr
	var _ /* handlers at bp+16 */ uintptr
	var _ /* info at bp+24 */ uintptr
	var _ /* len1 at bp+64 */ TTcl_Size
	var _ /* len2 at bp+72 */ TTcl_Size
	var _ /* numElems at bp+32 */ TTcl_Size
	var _ /* numHandlers at bp+8 */ TTcl_Size
	var _ /* varName at bp+80 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, _objPtr6, _objPtr7, cmdObj, finallyObj, found, handlerBodyObj, handlersObj, i, j, objc, objv, options, resultObj, v1, v10, v11, v13, v14, v15, v16, v17, v19, v2, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v4, v6, v7
	*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0
	handlersObj = *(*uintptr)(unsafe.Pointer(data))
	finallyObj = *(*uintptr)(unsafe.Pointer(data + 1*8))
	objv = *(*uintptr)(unsafe.Pointer(data + 2*8))
	objc = int32(int64(*(*uintptr)(unsafe.Pointer(data + 3*8))))
	cmdObj = *(*uintptr)(unsafe.Pointer(objv))
	/*
	 * Check for limits/rewinding, which override normal trapping behaviour.
	 */
	if (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).Frewind != 0 || XTcl_LimitExceeded(tls, interp) != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, cmdObj, libc.UintptrFromInt32(0))
		}
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+15919, libc.VaList(bp+96, v1, XTcl_GetErrorLine(tls, interp))))
		if handlersObj != libc.UintptrFromInt32(0) {
			_objPtr = handlersObj
			v3 = _objPtr
			v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
			*(*TTcl_Size)(unsafe.Pointer(v3))--
			if v2 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
		return int32(TCL_ERROR)
	}
	/*
	 * Basic processing of the outcome of the script, including adding of
	 * errorinfo trace.
	 */
	if result == int32(TCL_ERROR) {
		if (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes != 0 {
			v4 = (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes
		} else {
			v4 = XTcl_GetStringFromObj(tls, cmdObj, libc.UintptrFromInt32(0))
		}
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+15919, libc.VaList(bp+96, v4, XTcl_GetErrorLine(tls, interp))))
	}
	resultObj = XTcl_GetObjResult(tls, interp)
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount++
	options = XTcl_GetReturnOptions(tls, interp, result)
	(*TTcl_Obj)(unsafe.Pointer(options)).FrefCount++
	XTcl_ResetResult(tls, interp)
	/*
	 * Handle the results.
	 */
	if handlersObj != libc.UintptrFromInt32(0) {
		found = 0
		if (*TTcl_Obj)(unsafe.Pointer(handlersObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(handlersObj + 32))).Fptr2 != 0 {
				v6 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(handlersObj + 32))).Fptr2)).FspanStart
			} else {
				v6 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(handlersObj + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 16)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(handlersObj + 32))).Fptr1 + 40 + uintptr(v6)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(handlersObj + 32))).Fptr2 != 0 {
				v7 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(handlersObj + 32))).Fptr2)).FspanLength
			} else {
				v7 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(handlersObj + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v7
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), handlersObj, bp+8, bp+16)
		}
		i = 0
		for {
			if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) {
				break
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = 0
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i)*8)) + 32))).Fptr2 != 0 {
					v10 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i)*8)) + 32))).Fptr2)).FspanStart
				} else {
					v10 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i)*8)) + 32))).Fptr1)).FfirstUsed
				}
				*(*uintptr)(unsafe.Pointer(bp + 24)) = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i)*8)) + 32))).Fptr1 + 40 + uintptr(v10)*8
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i)*8)) + 32))).Fptr2 != 0 {
					v11 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i)*8)) + 32))).Fptr2)).FspanLength
				} else {
					v11 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i)*8)) + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = v11
				_ = libc.Int32FromInt32(TCL_OK)
			} else {
				XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i)*8)), bp+32, bp+24)
			}
			if !(found != 0) {
				XTcl_GetIntFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 1*8)), bp)
				if *(*int32)(unsafe.Pointer(bp)) != result {
					goto _8
				}
				/*
				 * When processing an error, we must also perform list-prefix
				 * matching of the errorcode list. However, if this was an
				 * 'on' handler, the list that we are matching against will be
				 * empty.
				 */
				if *(*int32)(unsafe.Pointer(bp)) == int32(TCL_ERROR) {
					XTclDictGet(tls, libc.UintptrFromInt32(0), options, __ccgo_ts+15231, bp+40)
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 2*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
						if (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 2*8)) + 32))).Fptr2 != 0 {
							v13 = (*TListSpan)(unsafe.Pointer((*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 2*8)) + 32))).Fptr2)).FspanStart
						} else {
							v13 = (*TListStore)(unsafe.Pointer((*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 2*8)) + 32))).Fptr1)).FfirstUsed
						}
						*(*uintptr)(unsafe.Pointer(bp + 48)) = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 2*8)) + 32))).Fptr1 + 40 + uintptr(v13)*8
						if (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 2*8)) + 32))).Fptr2 != 0 {
							v14 = (*TListSpan)(unsafe.Pointer((*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 2*8)) + 32))).Fptr2)).FspanLength
						} else {
							v14 = (*TListStore)(unsafe.Pointer((*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 2*8)) + 32))).Fptr1)).FnumUsed
						}
						*(*TTcl_Size)(unsafe.Pointer(bp + 64)) = v14
						_ = libc.Int32FromInt32(TCL_OK)
					} else {
						XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 2*8)), bp+64, bp+48)
					}
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
						if (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr2 != 0 {
							v16 = (*TListSpan)(unsafe.Pointer((*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr2)).FspanStart
						} else {
							v16 = (*TListStore)(unsafe.Pointer((*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr1)).FfirstUsed
						}
						*(*uintptr)(unsafe.Pointer(bp + 56)) = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr1 + 40 + uintptr(v16)*8
						if (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr2 != 0 {
							v17 = (*TListSpan)(unsafe.Pointer((*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr2)).FspanLength
						} else {
							v17 = (*TListStore)(unsafe.Pointer((*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr1)).FnumUsed
						}
						*(*TTcl_Size)(unsafe.Pointer(bp + 72)) = v17
						v15 = libc.Int32FromInt32(TCL_OK)
					} else {
						v15 = XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 40)), bp+72, bp+56)
					}
					if v15 != TCL_OK {
						goto _8
					}
					if *(*TTcl_Size)(unsafe.Pointer(bp + 72)) < *(*TTcl_Size)(unsafe.Pointer(bp + 64)) {
						goto _8
					}
					j = 0
					for {
						if !(j < *(*TTcl_Size)(unsafe.Pointer(bp + 64))) {
							break
						}
						if XTclStringCmp(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + uintptr(j)*8)), *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)) + uintptr(j)*8)), int32(1), 0, int64(-libc.Int32FromInt32(1))) != 0 {
							/*
							 * Really want 'continue outerloop;', but C does
							 * not give us that.
							 */
							goto didNotMatch
						}
						goto _18
					_18:
						;
						j++
					}
				}
				found = int32(1)
			}
			/*
			 * Now we need to scan forward over "-" bodies. Note that we've
			 * already checked that the last body is not a "-", so this search
			 * will terminate successfully.
			 */
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 4*8)))).Fbytes != 0 {
				v19 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 4*8)))).Fbytes
			} else {
				v19 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 4*8)), libc.UintptrFromInt32(0))
			}
			if !(libc.Xstrcmp(tls, v19, __ccgo_ts+6319) != 0) {
				goto _8
			}
			/*
			 * Bind the variables. We already know this is a list of variable
			 * names, but it might be empty.
			 */
			XTcl_ResetResult(tls, interp)
			result = int32(TCL_ERROR)
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 3*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 3*8)) + 32))).Fptr2 != 0 {
					v21 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 3*8)) + 32))).Fptr2)).FspanLength
				} else {
					v21 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 3*8)) + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = v21
				_ = libc.Int32FromInt32(TCL_OK)
			} else {
				XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 3*8)), bp+32)
			}
			if *(*TTcl_Size)(unsafe.Pointer(bp + 32)) > 0 {
				XTcl_ListObjIndex(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 3*8)), 0, bp+80)
				if XTcl_ObjSetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 80)), libc.UintptrFromInt32(0), resultObj, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
					_objPtr1 = resultObj
					v23 = _objPtr1
					v22 = *(*TTcl_Size)(unsafe.Pointer(v23))
					*(*TTcl_Size)(unsafe.Pointer(v23))--
					if v22 <= int64(1) {
						XTclFreeObj(tls, _objPtr1)
					}
					goto handlerFailed
				}
				_objPtr2 = resultObj
				v25 = _objPtr2
				v24 = *(*TTcl_Size)(unsafe.Pointer(v25))
				*(*TTcl_Size)(unsafe.Pointer(v25))--
				if v24 <= int64(1) {
					XTclFreeObj(tls, _objPtr2)
				}
				if *(*TTcl_Size)(unsafe.Pointer(bp + 32)) > int64(1) {
					XTcl_ListObjIndex(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 3*8)), int64(1), bp+80)
					if XTcl_ObjSetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 80)), libc.UintptrFromInt32(0), options, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
						goto handlerFailed
					}
				}
			} else {
				/*
				 * Dispose of the result to prevent a memleak. [Bug 2910044]
				 */
				_objPtr3 = resultObj
				v27 = _objPtr3
				v26 = *(*TTcl_Size)(unsafe.Pointer(v27))
				*(*TTcl_Size)(unsafe.Pointer(v27))--
				if v26 <= int64(1) {
					XTclFreeObj(tls, _objPtr3)
				}
			}
			/*
			 * Evaluate the handler body and process the outcome. Note that we
			 * need to keep the kind of handler for debugging purposes, and in
			 * any case anything we want from info[] must be extracted right
			 * now because the info[] array is about to become invalid. There
			 * is very little refcount handling here however, since we know
			 * that the objects that we still want to refer to now were input
			 * arguments to [try] and so are still on the Tcl value stack.
			 */
			handlerBodyObj = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 4*8))
			if finallyObj == libc.UintptrFromInt32(0) {
				v28 = 0
			} else {
				v28 = objc - int32(1)
			}
			XTcl_NRAddCallback(tls, interp, __ccgo_fp(_TryPostHandler), objv, options, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))), uintptr(int64(v28)))
			_objPtr4 = handlersObj
			v30 = _objPtr4
			v29 = *(*TTcl_Size)(unsafe.Pointer(v30))
			*(*TTcl_Size)(unsafe.Pointer(v30))--
			if v29 <= int64(1) {
				XTclFreeObj(tls, _objPtr4)
			}
			return XTclNREvalObjEx(tls, interp, handlerBodyObj, 0, (*TInterp)(unsafe.Pointer(interp)).FcmdFramePtr, int32(int64(4)*i+int64(5)))
			goto handlerFailed
		handlerFailed:
			;
			resultObj = XTcl_GetObjResult(tls, interp)
			(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount++
			options = _During(tls, interp, result, options, libc.UintptrFromInt32(0))
			break
			goto didNotMatch
		didNotMatch:
			;
			goto _8
			goto _8
		_8:
			;
			i++
		}
		/*
		 * No handler matched; get rid of the list of handlers.
		 */
		_objPtr5 = handlersObj
		v32 = _objPtr5
		v31 = *(*TTcl_Size)(unsafe.Pointer(v32))
		*(*TTcl_Size)(unsafe.Pointer(v32))--
		if v31 <= int64(1) {
			XTclFreeObj(tls, _objPtr5)
		}
	}
	/*
	 * Process the finally clause.
	 */
	if finallyObj != libc.UintptrFromInt32(0) {
		XTcl_NRAddCallback(tls, interp, __ccgo_fp(_TryPostFinal), resultObj, options, cmdObj, libc.UintptrFromInt32(0))
		return XTclNREvalObjEx(tls, interp, finallyObj, 0, (*TInterp)(unsafe.Pointer(interp)).FcmdFramePtr, objc-int32(1))
	}
	/*
	 * Install the correct result/options into the interpreter and clean up
	 * any temporary storage.
	 */
	result = XTcl_SetReturnOptions(tls, interp, options)
	_objPtr6 = options
	v34 = _objPtr6
	v33 = *(*TTcl_Size)(unsafe.Pointer(v34))
	*(*TTcl_Size)(unsafe.Pointer(v34))--
	if v33 <= int64(1) {
		XTclFreeObj(tls, _objPtr6)
	}
	XTcl_SetObjResult(tls, interp, resultObj)
	_objPtr7 = resultObj
	v36 = _objPtr7
	v35 = *(*TTcl_Size)(unsafe.Pointer(v36))
	*(*TTcl_Size)(unsafe.Pointer(v36))--
	if v35 <= int64(1) {
		XTclFreeObj(tls, _objPtr7)
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * TryPostHandler --
 *
 *	Callback to handle the outcome of the execution of a handler of a
 *	'try' command.
 *
 *----------------------------------------------------------------------
 */

func _TryPostHandler(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, cmdObj, finallyObj, handlerKindObj, iPtr, objv, options, resultObj, v1, v11, v13, v2, v3, v5, v6, v7, v9 uintptr
	var finallyIndex int32
	var v10, v12, v4, v8 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, cmdObj, finallyIndex, finallyObj, handlerKindObj, iPtr, objv, options, resultObj, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9
	objv = *(*uintptr)(unsafe.Pointer(data))
	options = *(*uintptr)(unsafe.Pointer(data + 1*8))
	handlerKindObj = *(*uintptr)(unsafe.Pointer(data + 2*8))
	finallyIndex = int32(int64(*(*uintptr)(unsafe.Pointer(data + 3*8))))
	cmdObj = *(*uintptr)(unsafe.Pointer(objv))
	if finallyIndex != 0 {
		v1 = *(*uintptr)(unsafe.Pointer(objv + uintptr(finallyIndex)*8))
	} else {
		v1 = uintptr(0)
	}
	finallyObj = v1
	/*
	 * Check for limits/rewinding, which override normal trapping behaviour.
	 */
	if (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).Frewind != 0 || XTcl_LimitExceeded(tls, interp) != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, cmdObj, libc.UintptrFromInt32(0))
		}
		if (*TTcl_Obj)(unsafe.Pointer(handlerKindObj)).Fbytes != 0 {
			v3 = (*TTcl_Obj)(unsafe.Pointer(handlerKindObj)).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, handlerKindObj, libc.UintptrFromInt32(0))
		}
		options = _During(tls, interp, result, options, XTcl_ObjPrintf(tls, __ccgo_ts+21242, libc.VaList(bp+8, v2, v3, XTcl_GetErrorLine(tls, interp))))
		_objPtr = options
		v5 = _objPtr
		v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
		*(*TTcl_Size)(unsafe.Pointer(v5))--
		if v4 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		return int32(TCL_ERROR)
	}
	/*
	 * The handler result completely substitutes for the result of the body.
	 */
	resultObj = XTcl_GetObjResult(tls, interp)
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount++
	if result == int32(TCL_ERROR) {
		if (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes != 0 {
			v6 = (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes
		} else {
			v6 = XTcl_GetStringFromObj(tls, cmdObj, libc.UintptrFromInt32(0))
		}
		if (*TTcl_Obj)(unsafe.Pointer(handlerKindObj)).Fbytes != 0 {
			v7 = (*TTcl_Obj)(unsafe.Pointer(handlerKindObj)).Fbytes
		} else {
			v7 = XTcl_GetStringFromObj(tls, handlerKindObj, libc.UintptrFromInt32(0))
		}
		options = _During(tls, interp, result, options, XTcl_ObjPrintf(tls, __ccgo_ts+21242, libc.VaList(bp+8, v6, v7, XTcl_GetErrorLine(tls, interp))))
	} else {
		_objPtr1 = options
		v9 = _objPtr1
		v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
		*(*TTcl_Size)(unsafe.Pointer(v9))--
		if v8 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		options = XTcl_GetReturnOptions(tls, interp, result)
		(*TTcl_Obj)(unsafe.Pointer(options)).FrefCount++
	}
	/*
	 * Process the finally clause if it is present.
	 */
	if finallyObj != libc.UintptrFromInt32(0) {
		iPtr = interp
		XTcl_NRAddCallback(tls, interp, __ccgo_fp(_TryPostFinal), resultObj, options, cmdObj, libc.UintptrFromInt32(0))
		/* The 'finally' script is always the last argument word. */
		return XTclNREvalObjEx(tls, interp, finallyObj, 0, (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr, finallyIndex)
	}
	/*
	 * Install the correct result/options into the interpreter and clean up
	 * any temporary storage.
	 */
	result = XTcl_SetReturnOptions(tls, interp, options)
	_objPtr2 = options
	v11 = _objPtr2
	v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
	*(*TTcl_Size)(unsafe.Pointer(v11))--
	if v10 <= int64(1) {
		XTclFreeObj(tls, _objPtr2)
	}
	XTcl_SetObjResult(tls, interp, resultObj)
	_objPtr3 = resultObj
	v13 = _objPtr3
	v12 = *(*TTcl_Size)(unsafe.Pointer(v13))
	*(*TTcl_Size)(unsafe.Pointer(v13))--
	if v12 <= int64(1) {
		XTclFreeObj(tls, _objPtr3)
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * TryPostFinal --
 *
 *	Callback to handle the outcome of the execution of the finally script
 *	of a 'try' command.
 *
 *----------------------------------------------------------------------
 */

func _TryPostFinal(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, cmdObj, options, origOptions, resultObj, v2, v3, v5, v7, v9 uintptr
	var v1, v4, v6, v8 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, cmdObj, options, origOptions, resultObj, v1, v2, v3, v4, v5, v6, v7, v8, v9
	resultObj = *(*uintptr)(unsafe.Pointer(data))
	options = *(*uintptr)(unsafe.Pointer(data + 1*8))
	cmdObj = *(*uintptr)(unsafe.Pointer(data + 2*8))
	/*
	 * If the result wasn't OK, we need to adjust the result options.
	 */
	if result != TCL_OK {
		_objPtr = resultObj
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		resultObj = libc.UintptrFromInt32(0)
		if result == int32(TCL_ERROR) {
			if (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes != 0 {
				v3 = (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes
			} else {
				v3 = XTcl_GetStringFromObj(tls, cmdObj, libc.UintptrFromInt32(0))
			}
			options = _During(tls, interp, result, options, XTcl_ObjPrintf(tls, __ccgo_ts+21277, libc.VaList(bp+8, v3, XTcl_GetErrorLine(tls, interp))))
		} else {
			origOptions = options
			options = XTcl_GetReturnOptions(tls, interp, result)
			(*TTcl_Obj)(unsafe.Pointer(options)).FrefCount++
			_objPtr1 = origOptions
			v5 = _objPtr1
			v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
			*(*TTcl_Size)(unsafe.Pointer(v5))--
			if v4 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
		}
	}
	/*
	 * Install the correct result/options into the interpreter and clean up
	 * any temporary storage.
	 */
	result = XTcl_SetReturnOptions(tls, interp, options)
	_objPtr2 = options
	v7 = _objPtr2
	v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
	*(*TTcl_Size)(unsafe.Pointer(v7))--
	if v6 <= int64(1) {
		XTclFreeObj(tls, _objPtr2)
	}
	if resultObj != libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, resultObj)
		_objPtr3 = resultObj
		v9 = _objPtr3
		v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
		*(*TTcl_Size)(unsafe.Pointer(v9))--
		if v8 <= int64(1) {
			XTclFreeObj(tls, _objPtr3)
		}
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_WhileObjCmd --
 *
 *	This procedure is invoked to process the "while" Tcl command. See the
 *	user documentation for details on what it does.
 *
 *	With the bytecode compiler, this procedure is only called when a
 *	command name is computed at runtime, and is "while" or the name to
 *	which "while" was renamed: e.g., "set z while; $z {$i<100} {}"
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_WhileObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	return XTcl_NRCallObjProc(tls, interp, __ccgo_fp(XTclNRWhileObjCmd), clientData, int64(objc), objv)
}

func XTclNRWhileObjCmd(tls *libc.TLS, dummy5255 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var _objPtr, _objPtr1, cachePtr, cachePtr1 uintptr
	var v1, v2 bool
	var _ /* _callbackPtr at bp+8 */ uintptr
	var _ /* iterPtr at bp+0 */ uintptr
	_, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, cachePtr1, v1, v2
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+21314)
		return int32(TCL_ERROR)
	}
	/*
	 * We reuse [for]'s callback, passing a NULL for the 'next' script.
	 */
	if v1 = interp == libc.UintptrFromInt32(0); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
	(*TForIterData)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fcond = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	(*TForIterData)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbody = *(*uintptr)(unsafe.Pointer(objv + 2*8))
	(*TForIterData)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fnext = libc.UintptrFromInt32(0)
	(*TForIterData)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fmsg = __ccgo_ts + 21327
	(*TForIterData)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fword = int64(2)
	if v2 = interp == libc.UintptrFromInt32(0); !v2 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr1 = XTclThreadAllocObj(tls)
	} else {
		_objPtr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr1 + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 8)) = _objPtr1
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FprocPtr = __ccgo_fp(XTclNRForIterCallback)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8)) = *(*uintptr)(unsafe.Pointer(bp))
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclListLines --
 *
 *	???
 *
 * Results:
 *	Filled in array of line numbers?
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclListLines(tls *libc.TLS, listObj uintptr, _line TTcl_Size, n TTcl_Size, lines uintptr, elems uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	*(*TTcl_Size)(unsafe.Pointer(bp)) = _line /* The list elems as Tcl_Obj*, in need of
	 * derived continuation data */
	var clLocPtr, listHead, listStr, v1, v2 uintptr
	var i, length TTcl_Size
	var _ /* clNext at bp+24 */ uintptr
	var _ /* element at bp+8 */ uintptr
	var _ /* next at bp+16 */ uintptr
	_, _, _, _, _, _, _ = clLocPtr, i, length, listHead, listStr, v1, v2
	if (*TTcl_Obj)(unsafe.Pointer(listObj)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(listObj)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, listObj, libc.UintptrFromInt32(0))
	}
	listStr = v1
	listHead = listStr
	length = libc.Int64FromUint64(libc.Xstrlen(tls, listStr))
	*(*uintptr)(unsafe.Pointer(bp + 8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(bp + 16)) = libc.UintptrFromInt32(0)
	clLocPtr = XTclContinuationsGet(tls, listObj)
	if clLocPtr != 0 {
		v2 = clLocPtr + 8
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	*(*uintptr)(unsafe.Pointer(bp + 24)) = v2
	i = 0
	for {
		if !(i < n) {
			break
		}
		XTclFindElement(tls, libc.UintptrFromInt32(0), listStr, length, bp+8, bp+16, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
		XTclAdvanceLines(tls, bp, listStr, *(*uintptr)(unsafe.Pointer(bp + 8)))
		/* Leading whitespace */
		XTclAdvanceContinuations(tls, bp, bp+24, int32(int64(*(*uintptr)(unsafe.Pointer(bp + 8)))-int64(listHead)))
		if elems != 0 && *(*uintptr)(unsafe.Pointer(bp + 24)) != 0 {
			XTclContinuationsEnterDerived(tls, *(*uintptr)(unsafe.Pointer(elems + uintptr(i)*8)), int64(*(*uintptr)(unsafe.Pointer(bp + 8)))-int64(listHead), *(*uintptr)(unsafe.Pointer(bp + 24)))
		}
		*(*TTcl_Size)(unsafe.Pointer(lines + uintptr(i)*8)) = *(*TTcl_Size)(unsafe.Pointer(bp))
		length -= int64(*(*uintptr)(unsafe.Pointer(bp + 16))) - int64(listStr)
		XTclAdvanceLines(tls, bp, *(*uintptr)(unsafe.Pointer(bp + 8)), *(*uintptr)(unsafe.Pointer(bp + 16)))
		/* Element */
		listStr = *(*uintptr)(unsafe.Pointer(bp + 16))
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))) == 0 {
			/* ASSERT i == n */
			break
		}
		goto _3
	_3:
		;
		i++
	}
}

/*
 * The structures below define the AuxData types defined in this file.
 */

var _foreachInfoType = TAuxDataType{
	Fname: __ccgo_ts + 21355,
}

func init() {
	p := unsafe.Pointer(&_foreachInfoType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_DupForeachInfo)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_FreeForeachInfo)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_PrintForeachInfo)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_DisassembleForeachInfo)
}

var _newForeachInfoType = TAuxDataType{
	Fname: __ccgo_ts + 21367,
}

func init() {
	p := unsafe.Pointer(&_newForeachInfoType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_DupForeachInfo)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_FreeForeachInfo)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_PrintNewForeachInfo)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_DisassembleNewForeachInfo)
}

var _dictUpdateInfoType = TAuxDataType{
	Fname: __ccgo_ts + 21382,
}

func init() {
	p := unsafe.Pointer(&_dictUpdateInfoType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_DupDictUpdateInfo)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_FreeDictUpdateInfo)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_PrintDictUpdateInfo)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_DisassembleDictUpdateInfo)
}

/*
 *----------------------------------------------------------------------
 *
 * TclGetAuxDataType --
 *
 *	This procedure looks up an Auxdata type by name.
 *
 * Results:
 *	If an AuxData type with name matching "typeName" is found, a pointer
 *	to its AuxDataType structure is returned; otherwise, NULL is returned.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclGetAuxDataType(tls *libc.TLS, typeName uintptr) (r uintptr) {
	/* Name of AuxData type to look up. */
	if !(libc.Xstrcmp(tls, typeName, _foreachInfoType.Fname) != 0) {
		return uintptr(unsafe.Pointer(&_foreachInfoType))
	} else {
		if !(libc.Xstrcmp(tls, typeName, _newForeachInfoType.Fname) != 0) {
			return uintptr(unsafe.Pointer(&_newForeachInfoType))
		} else {
			if !(libc.Xstrcmp(tls, typeName, _dictUpdateInfoType.Fname) != 0) {
				return uintptr(unsafe.Pointer(&_dictUpdateInfoType))
			} else {
				if !(libc.Xstrcmp(tls, typeName, XtclJumptableInfoType.Fname) != 0) {
					return uintptr(unsafe.Pointer(&XtclJumptableInfoType))
				}
			}
		}
	}
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileAppendCmd --
 *
 *	Procedure called to compile the "append" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "append" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileAppendCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, delta1, i1, numWords, v111, v113, v116, v17, v21, v27, v39, v43, v49, v5, v61, v68, v80, v92, v99 int32
	var eclIndex TTcl_Size
	var mapPtr, valueTokenPtr, varTokenPtr, v1, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v112, v114, v115, v117, v12, v13, v14, v15, v16, v18, v19, v2, v20, v22, v23, v24, v25, v26, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v4, v40, v41, v42, v44, v45, v46, v47, v48, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v62, v64, v65, v66, v67, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v93, v95, v96, v97, v98 uintptr
	var _ /* isScalar at bp+0 */ int32
	var _ /* localIndex at bp+4 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, delta1, eclIndex, i1, mapPtr, numWords, valueTokenPtr, varTokenPtr, v1, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v95, v96, v97, v98, v99
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	/* TODO: Consider support for compiling expanded args. */
	numWords = int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)
	if numWords == int32(1) {
		return int32(TCL_ERROR)
	} else {
		if numWords == int32(2) {
			/*
			 * append varName == set varName
			 */
			return XTclCompileSetCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
		} else {
			if numWords > int32(3) {
				/*
				 * APPEND instructions currently only handle one value, but we can
				 * handle some multi-value cases by stringing them together.
				 */
				goto appendMultiple
			}
		}
	}
	/*
	 * Decide if we can use a frame slot for the var/array name or if we need
	 * to emit code to compute and push the name at runtime. We use a frame
	 * slot (entry in the array of local vars) if we are compiling a procedure
	 * body and if the name is simple text that does not include namespace
	 * qualifiers.
	 */
	varTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
	XTclPushVarName(tls, interp, varTokenPtr, envPtr2, 0, bp+4, bp)
	/*
	 * We are doing an assignment, otherwise TclCompileSetCmd was called, so
	 * push the new value. This will need to be extended to push a value for
	 * each argument.
	 */
	valueTokenPtr = varTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(valueTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(valueTokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
		XTclCompileTokens(tls, interp, valueTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).FnumComponents), envPtr2)
	}
	/*
	 * Emit instructions to set/get the variable.
	 */
	if *(*int32)(unsafe.Pointer(bp)) != 0 {
		if *(*int32)(unsafe.Pointer(bp + 4)) < 0 {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v20 = envPtr2 + 152
			v19 = *(*uintptr)(unsafe.Pointer(v20))
			*(*uintptr)(unsafe.Pointer(v20))++
			*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_APPEND_STK))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_APPEND_STK)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v21 = delta1
				v22 = envPtr2
				if v21 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v22 + 64)) += int64(v21)
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 4)) <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v24 = envPtr2 + 152
				v23 = *(*uintptr)(unsafe.Pointer(v24))
				*(*uintptr)(unsafe.Pointer(v24))++
				*(*uint8)(unsafe.Pointer(v23)) = libc.Uint8FromInt32(int32(INST_APPEND_SCALAR1))
				v26 = envPtr2 + 152
				v25 = *(*uintptr)(unsafe.Pointer(v26))
				*(*uintptr)(unsafe.Pointer(v26))++
				*(*uint8)(unsafe.Pointer(v25)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_APPEND_SCALAR1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
					}
					v27 = delta1
					v28 = envPtr2
					if v27 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v28)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v28)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v28)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v28)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v28 + 64)) += int64(v27)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v30 = envPtr2 + 152
				v29 = *(*uintptr)(unsafe.Pointer(v30))
				*(*uintptr)(unsafe.Pointer(v30))++
				*(*uint8)(unsafe.Pointer(v29)) = libc.Uint8FromInt32(int32(INST_APPEND_SCALAR4))
				v32 = envPtr2 + 152
				v31 = *(*uintptr)(unsafe.Pointer(v32))
				*(*uintptr)(unsafe.Pointer(v32))++
				*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(24))
				v34 = envPtr2 + 152
				v33 = *(*uintptr)(unsafe.Pointer(v34))
				*(*uintptr)(unsafe.Pointer(v34))++
				*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(16))
				v36 = envPtr2 + 152
				v35 = *(*uintptr)(unsafe.Pointer(v36))
				*(*uintptr)(unsafe.Pointer(v36))++
				*(*uint8)(unsafe.Pointer(v35)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(8))
				v38 = envPtr2 + 152
				v37 = *(*uintptr)(unsafe.Pointer(v38))
				*(*uintptr)(unsafe.Pointer(v38))++
				*(*uint8)(unsafe.Pointer(v37)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_APPEND_SCALAR4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
					}
					v39 = delta1
					v40 = envPtr2
					if v39 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v40 + 64)) += int64(v39)
				}
			}
		}
	} else {
		if *(*int32)(unsafe.Pointer(bp + 4)) < 0 {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v42 = envPtr2 + 152
			v41 = *(*uintptr)(unsafe.Pointer(v42))
			*(*uintptr)(unsafe.Pointer(v42))++
			*(*uint8)(unsafe.Pointer(v41)) = libc.Uint8FromInt32(int32(INST_APPEND_ARRAY_STK))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_APPEND_ARRAY_STK)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v43 = delta1
				v44 = envPtr2
				if v43 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v44)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v44)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v44)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v44)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v44 + 64)) += int64(v43)
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 4)) <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v46 = envPtr2 + 152
				v45 = *(*uintptr)(unsafe.Pointer(v46))
				*(*uintptr)(unsafe.Pointer(v46))++
				*(*uint8)(unsafe.Pointer(v45)) = libc.Uint8FromInt32(int32(INST_APPEND_ARRAY1))
				v48 = envPtr2 + 152
				v47 = *(*uintptr)(unsafe.Pointer(v48))
				*(*uintptr)(unsafe.Pointer(v48))++
				*(*uint8)(unsafe.Pointer(v47)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_APPEND_ARRAY1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
					}
					v49 = delta1
					v50 = envPtr2
					if v49 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v50)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v50)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v50)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v50)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v50 + 64)) += int64(v49)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v52 = envPtr2 + 152
				v51 = *(*uintptr)(unsafe.Pointer(v52))
				*(*uintptr)(unsafe.Pointer(v52))++
				*(*uint8)(unsafe.Pointer(v51)) = libc.Uint8FromInt32(int32(INST_APPEND_ARRAY4))
				v54 = envPtr2 + 152
				v53 = *(*uintptr)(unsafe.Pointer(v54))
				*(*uintptr)(unsafe.Pointer(v54))++
				*(*uint8)(unsafe.Pointer(v53)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(24))
				v56 = envPtr2 + 152
				v55 = *(*uintptr)(unsafe.Pointer(v56))
				*(*uintptr)(unsafe.Pointer(v56))++
				*(*uint8)(unsafe.Pointer(v55)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(16))
				v58 = envPtr2 + 152
				v57 = *(*uintptr)(unsafe.Pointer(v58))
				*(*uintptr)(unsafe.Pointer(v58))++
				*(*uint8)(unsafe.Pointer(v57)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(8))
				v60 = envPtr2 + 152
				v59 = *(*uintptr)(unsafe.Pointer(v60))
				*(*uintptr)(unsafe.Pointer(v60))++
				*(*uint8)(unsafe.Pointer(v59)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_APPEND_ARRAY4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
					}
					v61 = delta1
					v62 = envPtr2
					if v61 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v62)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v62)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v62)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v62)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v62 + 64)) += int64(v61)
				}
			}
		}
	}
	return TCL_OK
	goto appendMultiple
appendMultiple:
	;
	/*
	 * Can only handle the case where we are appending to a local scalar when
	 * there are multiple values to append.  Fortunately, this is common.
	 */
	varTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	*(*int32)(unsafe.Pointer(bp + 4)) = libc.Int32FromUint64(XTclLocalScalarFromToken(tls, varTokenPtr, envPtr2))
	if *(*int32)(unsafe.Pointer(bp + 4)) < 0 {
		return int32(TCL_ERROR)
	}
	/*
	 * Definitely appending to a local scalar; generate the words and append
	 * them.
	 */
	valueTokenPtr = varTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	i1 = int32(2)
	for {
		if !(i1 < numWords) {
			break
		}
		if (*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(valueTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(valueTokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy1 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v65 = envPtr2 + 152
				v64 = *(*uintptr)(unsafe.Pointer(v65))
				*(*uintptr)(unsafe.Pointer(v65))++
				*(*uint8)(unsafe.Pointer(v64)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v67 = envPtr2 + 152
				v66 = *(*uintptr)(unsafe.Pointer(v67))
				*(*uintptr)(unsafe.Pointer(v67))++
				*(*uint8)(unsafe.Pointer(v66)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v68 = delta1
					v69 = envPtr2
					if v68 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v69)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v69)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v69)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v69)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v69 + 64)) += int64(v68)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v71 = envPtr2 + 152
				v70 = *(*uintptr)(unsafe.Pointer(v71))
				*(*uintptr)(unsafe.Pointer(v71))++
				*(*uint8)(unsafe.Pointer(v70)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v73 = envPtr2 + 152
				v72 = *(*uintptr)(unsafe.Pointer(v73))
				*(*uintptr)(unsafe.Pointer(v73))++
				*(*uint8)(unsafe.Pointer(v72)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
				v75 = envPtr2 + 152
				v74 = *(*uintptr)(unsafe.Pointer(v75))
				*(*uintptr)(unsafe.Pointer(v75))++
				*(*uint8)(unsafe.Pointer(v74)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
				v77 = envPtr2 + 152
				v76 = *(*uintptr)(unsafe.Pointer(v77))
				*(*uintptr)(unsafe.Pointer(v77))++
				*(*uint8)(unsafe.Pointer(v76)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
				v79 = envPtr2 + 152
				v78 = *(*uintptr)(unsafe.Pointer(v79))
				*(*uintptr)(unsafe.Pointer(v79))++
				*(*uint8)(unsafe.Pointer(v78)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v80 = delta1
					v81 = envPtr2
					if v80 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v81)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v81)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v81)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v81)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v81 + 64)) += int64(v80)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
			XTclCompileTokens(tls, interp, valueTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).FnumComponents), envPtr2)
		}
		valueTokenPtr = valueTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		goto _63
	_63:
		;
		i1++
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v83 = envPtr2 + 152
	v82 = *(*uintptr)(unsafe.Pointer(v83))
	*(*uintptr)(unsafe.Pointer(v83))++
	*(*uint8)(unsafe.Pointer(v82)) = libc.Uint8FromInt32(int32(INST_REVERSE))
	v85 = envPtr2 + 152
	v84 = *(*uintptr)(unsafe.Pointer(v85))
	*(*uintptr)(unsafe.Pointer(v85))++
	*(*uint8)(unsafe.Pointer(v84)) = uint8(libc.Uint32FromInt32(numWords-libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
	v87 = envPtr2 + 152
	v86 = *(*uintptr)(unsafe.Pointer(v87))
	*(*uintptr)(unsafe.Pointer(v87))++
	*(*uint8)(unsafe.Pointer(v86)) = uint8(libc.Uint32FromInt32(numWords-libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
	v89 = envPtr2 + 152
	v88 = *(*uintptr)(unsafe.Pointer(v89))
	*(*uintptr)(unsafe.Pointer(v89))++
	*(*uint8)(unsafe.Pointer(v88)) = uint8(libc.Uint32FromInt32(numWords-libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
	v91 = envPtr2 + 152
	v90 = *(*uintptr)(unsafe.Pointer(v91))
	*(*uintptr)(unsafe.Pointer(v91))++
	*(*uint8)(unsafe.Pointer(v90)) = uint8(libc.Uint32FromInt32(numWords - libc.Int32FromInt32(2)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - (numWords - int32(2))
		}
		v92 = delta1
		v93 = envPtr2
		if v92 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v93)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v93)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v93)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v93)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v93 + 64)) += int64(v92)
	}
	i1 = int32(2)
	for {
		if !(i1 < numWords) {
			break
		}
		if *(*int32)(unsafe.Pointer(bp + 4)) <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v96 = envPtr2 + 152
			v95 = *(*uintptr)(unsafe.Pointer(v96))
			*(*uintptr)(unsafe.Pointer(v96))++
			*(*uint8)(unsafe.Pointer(v95)) = libc.Uint8FromInt32(int32(INST_APPEND_SCALAR1))
			v98 = envPtr2 + 152
			v97 = *(*uintptr)(unsafe.Pointer(v98))
			*(*uintptr)(unsafe.Pointer(v98))++
			*(*uint8)(unsafe.Pointer(v97)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_APPEND_SCALAR1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
				}
				v99 = delta1
				v100 = envPtr2
				if v99 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v100)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v100)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v100)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v100)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v100 + 64)) += int64(v99)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v102 = envPtr2 + 152
			v101 = *(*uintptr)(unsafe.Pointer(v102))
			*(*uintptr)(unsafe.Pointer(v102))++
			*(*uint8)(unsafe.Pointer(v101)) = libc.Uint8FromInt32(int32(INST_APPEND_SCALAR4))
			v104 = envPtr2 + 152
			v103 = *(*uintptr)(unsafe.Pointer(v104))
			*(*uintptr)(unsafe.Pointer(v104))++
			*(*uint8)(unsafe.Pointer(v103)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(24))
			v106 = envPtr2 + 152
			v105 = *(*uintptr)(unsafe.Pointer(v106))
			*(*uintptr)(unsafe.Pointer(v106))++
			*(*uint8)(unsafe.Pointer(v105)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(16))
			v108 = envPtr2 + 152
			v107 = *(*uintptr)(unsafe.Pointer(v108))
			*(*uintptr)(unsafe.Pointer(v108))++
			*(*uint8)(unsafe.Pointer(v107)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(8))
			v110 = envPtr2 + 152
			v109 = *(*uintptr)(unsafe.Pointer(v110))
			*(*uintptr)(unsafe.Pointer(v110))++
			*(*uint8)(unsafe.Pointer(v109)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_APPEND_SCALAR4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
				}
				v111 = delta1
				v112 = envPtr2
				if v111 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v112)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v112)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v112)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v112)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v112 + 64)) += int64(v111)
			}
		}
		i1++
		v113 = i1
		if v113 < numWords {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v115 = envPtr2 + 152
			v114 = *(*uintptr)(unsafe.Pointer(v115))
			*(*uintptr)(unsafe.Pointer(v115))++
			*(*uint8)(unsafe.Pointer(v114)) = libc.Uint8FromInt32(int32(INST_POP))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v116 = delta1
				v117 = envPtr2
				if v116 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v117)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v117)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v117)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v117)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v117 + 64)) += int64(v116)
			}
		}
		goto _94
	_94:
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileArray*Cmd --
 *
 *	Functions called to compile "array" subcommands.
 *
 * Results:
 *	All return TCL_OK for a successful compile, and TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "array" subcommand at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileArrayExistsCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy251 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds resulting instructions. */
	var delta1, v11, v15 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v12, v13, v14, v16, v2, v3, v4, v5, v6, v7, v8, v9 uintptr
	var _ /* isScalar at bp+0 */ int32
	var _ /* localIndex at bp+4 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = delta1, eclIndex, mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v2, v3, v4, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
		return int32(TCL_ERROR)
	}
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
	XTclPushVarName(tls, interp, tokenPtr, envPtr2, int32(TCL_NO_ELEMENT), bp+4, bp)
	if !(*(*int32)(unsafe.Pointer(bp)) != 0) {
		return int32(TCL_ERROR)
	}
	if *(*int32)(unsafe.Pointer(bp + 4)) >= 0 {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v2 = envPtr2 + 152
		v1 = *(*uintptr)(unsafe.Pointer(v2))
		*(*uintptr)(unsafe.Pointer(v2))++
		*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_ARRAY_EXISTS_IMM))
		v4 = envPtr2 + 152
		v3 = *(*uintptr)(unsafe.Pointer(v4))
		*(*uintptr)(unsafe.Pointer(v4))++
		*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(24))
		v6 = envPtr2 + 152
		v5 = *(*uintptr)(unsafe.Pointer(v6))
		*(*uintptr)(unsafe.Pointer(v6))++
		*(*uint8)(unsafe.Pointer(v5)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(16))
		v8 = envPtr2 + 152
		v7 = *(*uintptr)(unsafe.Pointer(v8))
		*(*uintptr)(unsafe.Pointer(v8))++
		*(*uint8)(unsafe.Pointer(v7)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(8))
		v10 = envPtr2 + 152
		v9 = *(*uintptr)(unsafe.Pointer(v10))
		*(*uintptr)(unsafe.Pointer(v10))++
		*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_ARRAY_EXISTS_IMM)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
			}
			v11 = delta1
			v12 = envPtr2
			if v11 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v12)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v12)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v12)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v12)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v12 + 64)) += int64(v11)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v14 = envPtr2 + 152
		v13 = *(*uintptr)(unsafe.Pointer(v14))
		*(*uintptr)(unsafe.Pointer(v14))++
		*(*uint8)(unsafe.Pointer(v13)) = libc.Uint8FromInt32(int32(INST_ARRAY_EXISTS_STK))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_ARRAY_EXISTS_STK)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v15 = delta1
			v16 = envPtr2
			if v15 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v16)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v16)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v16)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v16)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v16 + 64)) += int64(v15)
		}
	}
	return TCL_OK
}

func XTclCompileArraySetCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, _objIndexCopy4, _objIndexCopy5, _objIndexCopy6, code, delta1, fwd, infoIndex, isDataEven, isDataLiteral, isDataValid, keyVar, offsetBack, offsetFwd, valVar, v111, v123, v127, v139, v145, v15, v157, v163, v175, v179, v183, v189, v2, v201, v205, v21, v211, v217, v229, v235, v247, v259, v269, v281, v287, v299, v305, v317, v323, v33, v335, v339, v343, v347, v349, v355, v367, v37, v41, v47, v51, v57, v59, v63, v69, v81, v87, v99 int32
	var _objPtr, cachePtr, dataTokenPtr, infoPtr, literalObj, mapPtr, varTokenPtr, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v124, v125, v126, v128, v129, v13, v130, v131, v132, v133, v134, v135, v136, v137, v138, v14, v140, v141, v142, v143, v144, v146, v147, v148, v149, v150, v151, v152, v153, v154, v155, v156, v158, v159, v16, v160, v161, v162, v164, v165, v166, v167, v168, v169, v17, v170, v171, v172, v173, v174, v176, v177, v178, v18, v180, v181, v182, v184, v185, v186, v187, v188, v19, v190, v191, v192, v193, v194, v195, v196, v197, v198, v199, v20, v200, v202, v203, v204, v206, v207, v208, v209, v210, v212, v213, v214, v215, v216, v218, v219, v22, v220, v221, v222, v223, v224, v225, v226, v227, v228, v23, v230, v231, v232, v233, v234, v236, v237, v238, v239, v24, v240, v241, v242, v243, v244, v245, v246, v248, v249, v25, v250, v251, v252, v253, v254, v255, v256, v257, v258, v26, v260, v261, v262, v263, v264, v265, v266, v267, v268, v27, v270, v271, v272, v273, v274, v275, v276, v277, v278, v279, v28, v280, v282, v283, v284, v285, v286, v288, v289, v29, v290, v291, v292, v293, v294, v295, v296, v297, v298, v30, v300, v301, v302, v303, v304, v306, v307, v308, v309, v31, v310, v311, v312, v313, v314, v315, v316, v318, v319, v32, v320, v321, v322, v324, v325, v326, v327, v328, v329, v330, v331, v332, v333, v334, v336, v337, v338, v34, v340, v341, v342, v344, v345, v346, v348, v35, v350, v351, v352, v353, v354, v356, v357, v358, v359, v36, v360, v361, v362, v363, v364, v365, v366, v368, v370, v38, v39, v40, v42, v43, v44, v45, v46, v48, v49, v5, v50, v52, v53, v54, v55, v56, v58, v6, v60, v61, v62, v64, v65, v66, v67, v68, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v82, v83, v84, v85, v86, v88, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98 uintptr
	var eclIndex, v369 TTcl_Size
	var v1, v4 bool
	var v3 int64
	var _ /* isScalar at bp+0 */ int32
	var _ /* len at bp+8 */ TTcl_Size
	var _ /* localIndex at bp+4 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, _objIndexCopy4, _objIndexCopy5, _objIndexCopy6, _objPtr, cachePtr, code, dataTokenPtr, delta1, eclIndex, fwd, infoIndex, infoPtr, isDataEven, isDataLiteral, isDataValid, keyVar, literalObj, mapPtr, offsetBack, offsetFwd, valVar, varTokenPtr, v1, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v123, v124, v125, v126, v127, v128, v129, v13, v130, v131, v132, v133, v134, v135, v136, v137, v138, v139, v14, v140, v141, v142, v143, v144, v145, v146, v147, v148, v149, v15, v150, v151, v152, v153, v154, v155, v156, v157, v158, v159, v16, v160, v161, v162, v163, v164, v165, v166, v167, v168, v169, v17, v170, v171, v172, v173, v174, v175, v176, v177, v178, v179, v18, v180, v181, v182, v183, v184, v185, v186, v187, v188, v189, v19, v190, v191, v192, v193, v194, v195, v196, v197, v198, v199, v2, v20, v200, v201, v202, v203, v204, v205, v206, v207, v208, v209, v21, v210, v211, v212, v213, v214, v215, v216, v217, v218, v219, v22, v220, v221, v222, v223, v224, v225, v226, v227, v228, v229, v23, v230, v231, v232, v233, v234, v235, v236, v237, v238, v239, v24, v240, v241, v242, v243, v244, v245, v246, v247, v248, v249, v25, v250, v251, v252, v253, v254, v255, v256, v257, v258, v259, v26, v260, v261, v262, v263, v264, v265, v266, v267, v268, v269, v27, v270, v271, v272, v273, v274, v275, v276, v277, v278, v279, v28, v280, v281, v282, v283, v284, v285, v286, v287, v288, v289, v29, v290, v291, v292, v293, v294, v295, v296, v297, v298, v299, v3, v30, v300, v301, v302, v303, v304, v305, v306, v307, v308, v309, v31, v310, v311, v312, v313, v314, v315, v316, v317, v318, v319, v32, v320, v321, v322, v323, v324, v325, v326, v327, v328, v329, v33, v330, v331, v332, v333, v334, v335, v336, v337, v338, v339, v34, v340, v341, v342, v343, v344, v345, v346, v347, v348, v349, v35, v350, v351, v352, v353, v354, v355, v356, v357, v358, v359, v36, v360, v361, v362, v363, v364, v365, v366, v367, v368, v369, v37, v370, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	code = TCL_OK
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(3) {
		return int32(TCL_ERROR)
	}
	varTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	dataTokenPtr = varTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		literalObj = XTclThreadAllocObj(tls)
	} else {
		literalObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(literalObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(literalObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(literalObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(literalObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(literalObj)).FtypePtr = libc.UintptrFromInt32(0)
	isDataLiteral = XTclWordKnownAtCompileTime(tls, dataTokenPtr, literalObj)
	if v4 = isDataLiteral != 0; v4 {
		if (*TTcl_Obj)(unsafe.Pointer(literalObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(literalObj + 32))).Fptr2 != 0 {
				v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(literalObj + 32))).Fptr2)).FspanLength
			} else {
				v3 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(literalObj + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v3
			v2 = libc.Int32FromInt32(TCL_OK)
		} else {
			v2 = XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), literalObj, bp+8)
		}
	}
	isDataValid = libc.BoolInt32(v4 && v2 == TCL_OK)
	isDataEven = libc.BoolInt32(isDataValid != 0 && *(*TTcl_Size)(unsafe.Pointer(bp + 8))&int64(1) == 0)
	/*
	 * Special case: literal odd-length argument is always an error.
	 */
	if isDataValid != 0 && !(isDataEven != 0) {
		/* Abandon custom compile and let invocation raise the error */
		code = XTclCompileBasic2ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
		goto done
		/*
			 * We used to compile to the bytecode that would throw the error,
			 * but that was wrong because it would not invoke the array trace
			 * on the variable.
			 *
			PushStringLiteral(envPtr, "list must have an even number of elements");
			PushStringLiteral(envPtr, "-errorcode {TCL ARGUMENT FORMAT}");
			TclEmitInstInt4(INST_RETURN_IMM, TCL_ERROR,		envPtr);
			TclEmitInt4(		0,				envPtr);
			goto done;
			 *
		*/
	}
	/*
	 * Except for the special "ensure array" case below, when we're not in
	 * a proc, we cannot do a better compile than generic.
	 */
	if (*TTcl_Token)(unsafe.Pointer(varTokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) || (*TCompileEnv)(unsafe.Pointer(envPtr2)).FprocPtr == libc.UintptrFromInt32(0) && !(isDataEven != 0 && *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == 0) {
		code = XTclCompileBasic2ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
		goto done
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
	XTclPushVarName(tls, interp, varTokenPtr, envPtr2, int32(TCL_NO_ELEMENT), bp+4, bp)
	if !(*(*int32)(unsafe.Pointer(bp)) != 0) {
		code = int32(TCL_ERROR)
		goto done
	}
	/*
	 * Special case: literal empty value argument is just an "ensure array"
	 * operation.
	 */
	if isDataEven != 0 && *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == 0 {
		if *(*int32)(unsafe.Pointer(bp + 4)) >= 0 {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v6 = envPtr2 + 152
			v5 = *(*uintptr)(unsafe.Pointer(v6))
			*(*uintptr)(unsafe.Pointer(v6))++
			*(*uint8)(unsafe.Pointer(v5)) = libc.Uint8FromInt32(int32(INST_ARRAY_EXISTS_IMM))
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(24))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(16))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(8))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_ARRAY_EXISTS_IMM)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
				}
				v15 = delta1
				v16 = envPtr2
				if v15 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v16)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v16)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v16)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v16)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v16 + 64)) += int64(v15)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v18 = envPtr2 + 152
			v17 = *(*uintptr)(unsafe.Pointer(v18))
			*(*uintptr)(unsafe.Pointer(v18))++
			*(*uint8)(unsafe.Pointer(v17)) = libc.Uint8FromInt32(int32(INST_JUMP_TRUE1))
			v20 = envPtr2 + 152
			v19 = *(*uintptr)(unsafe.Pointer(v20))
			*(*uintptr)(unsafe.Pointer(v20))++
			*(*uint8)(unsafe.Pointer(v19)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(7)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_JUMP_TRUE1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - int32(7)
				}
				v21 = delta1
				v22 = envPtr2
				if v21 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v22 + 64)) += int64(v21)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v24 = envPtr2 + 152
			v23 = *(*uintptr)(unsafe.Pointer(v24))
			*(*uintptr)(unsafe.Pointer(v24))++
			*(*uint8)(unsafe.Pointer(v23)) = libc.Uint8FromInt32(int32(INST_ARRAY_MAKE_IMM))
			v26 = envPtr2 + 152
			v25 = *(*uintptr)(unsafe.Pointer(v26))
			*(*uintptr)(unsafe.Pointer(v26))++
			*(*uint8)(unsafe.Pointer(v25)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(24))
			v28 = envPtr2 + 152
			v27 = *(*uintptr)(unsafe.Pointer(v28))
			*(*uintptr)(unsafe.Pointer(v28))++
			*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(16))
			v30 = envPtr2 + 152
			v29 = *(*uintptr)(unsafe.Pointer(v30))
			*(*uintptr)(unsafe.Pointer(v30))++
			*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(8))
			v32 = envPtr2 + 152
			v31 = *(*uintptr)(unsafe.Pointer(v32))
			*(*uintptr)(unsafe.Pointer(v32))++
			*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_ARRAY_MAKE_IMM)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
				}
				v33 = delta1
				v34 = envPtr2
				if v33 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v34)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v34)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v34)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v34)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v34 + 64)) += int64(v33)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v36 = envPtr2 + 152
			v35 = *(*uintptr)(unsafe.Pointer(v36))
			*(*uintptr)(unsafe.Pointer(v36))++
			*(*uint8)(unsafe.Pointer(v35)) = libc.Uint8FromInt32(int32(INST_DUP))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_DUP)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v37 = delta1
				v38 = envPtr2
				if v37 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v38)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v38)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v38)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v38)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v38 + 64)) += int64(v37)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v40 = envPtr2 + 152
			v39 = *(*uintptr)(unsafe.Pointer(v40))
			*(*uintptr)(unsafe.Pointer(v40))++
			*(*uint8)(unsafe.Pointer(v39)) = libc.Uint8FromInt32(int32(INST_ARRAY_EXISTS_STK))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_ARRAY_EXISTS_STK)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v41 = delta1
				v42 = envPtr2
				if v41 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v42)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v42)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v42)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v42)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v42 + 64)) += int64(v41)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v44 = envPtr2 + 152
			v43 = *(*uintptr)(unsafe.Pointer(v44))
			*(*uintptr)(unsafe.Pointer(v44))++
			*(*uint8)(unsafe.Pointer(v43)) = libc.Uint8FromInt32(int32(INST_JUMP_TRUE1))
			v46 = envPtr2 + 152
			v45 = *(*uintptr)(unsafe.Pointer(v46))
			*(*uintptr)(unsafe.Pointer(v46))++
			*(*uint8)(unsafe.Pointer(v45)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(5)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_JUMP_TRUE1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - int32(5)
				}
				v47 = delta1
				v48 = envPtr2
				if v47 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v48)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v48)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v48)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v48)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v48 + 64)) += int64(v47)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v50 = envPtr2 + 152
			v49 = *(*uintptr)(unsafe.Pointer(v50))
			*(*uintptr)(unsafe.Pointer(v50))++
			*(*uint8)(unsafe.Pointer(v49)) = libc.Uint8FromInt32(int32(INST_ARRAY_MAKE_STK))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_ARRAY_MAKE_STK)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v51 = delta1
				v52 = envPtr2
				if v51 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v52)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v52)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v52)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v52)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v52 + 64)) += int64(v51)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v54 = envPtr2 + 152
			v53 = *(*uintptr)(unsafe.Pointer(v54))
			*(*uintptr)(unsafe.Pointer(v54))++
			*(*uint8)(unsafe.Pointer(v53)) = libc.Uint8FromInt32(int32(INST_JUMP1))
			v56 = envPtr2 + 152
			v55 = *(*uintptr)(unsafe.Pointer(v56))
			*(*uintptr)(unsafe.Pointer(v56))++
			*(*uint8)(unsafe.Pointer(v55)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_JUMP1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - int32(3)
				}
				v57 = delta1
				v58 = envPtr2
				if v57 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v58)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v58)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v58)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v58)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v58 + 64)) += int64(v57)
			}
			/* Each branch decrements stack depth, but we only take one. */
			v59 = int32(1)
			v60 = envPtr2
			if v59 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v60)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v60)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v60)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v60)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v60 + 64)) += int64(v59)
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v62 = envPtr2 + 152
			v61 = *(*uintptr)(unsafe.Pointer(v62))
			*(*uintptr)(unsafe.Pointer(v62))++
			*(*uint8)(unsafe.Pointer(v61)) = libc.Uint8FromInt32(int32(INST_POP))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v63 = delta1
				v64 = envPtr2
				if v63 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v64)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v64)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v64)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v64)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v64 + 64)) += int64(v63)
			}
		}
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v66 = envPtr2 + 152
			v65 = *(*uintptr)(unsafe.Pointer(v66))
			*(*uintptr)(unsafe.Pointer(v66))++
			*(*uint8)(unsafe.Pointer(v65)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v68 = envPtr2 + 152
			v67 = *(*uintptr)(unsafe.Pointer(v68))
			*(*uintptr)(unsafe.Pointer(v68))++
			*(*uint8)(unsafe.Pointer(v67)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v69 = delta1
				v70 = envPtr2
				if v69 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v70 + 64)) += int64(v69)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v72 = envPtr2 + 152
			v71 = *(*uintptr)(unsafe.Pointer(v72))
			*(*uintptr)(unsafe.Pointer(v72))++
			*(*uint8)(unsafe.Pointer(v71)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v74 = envPtr2 + 152
			v73 = *(*uintptr)(unsafe.Pointer(v74))
			*(*uintptr)(unsafe.Pointer(v74))++
			*(*uint8)(unsafe.Pointer(v73)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v76 = envPtr2 + 152
			v75 = *(*uintptr)(unsafe.Pointer(v76))
			*(*uintptr)(unsafe.Pointer(v76))++
			*(*uint8)(unsafe.Pointer(v75)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v78 = envPtr2 + 152
			v77 = *(*uintptr)(unsafe.Pointer(v78))
			*(*uintptr)(unsafe.Pointer(v78))++
			*(*uint8)(unsafe.Pointer(v77)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v80 = envPtr2 + 152
			v79 = *(*uintptr)(unsafe.Pointer(v80))
			*(*uintptr)(unsafe.Pointer(v80))++
			*(*uint8)(unsafe.Pointer(v79)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v81 = delta1
				v82 = envPtr2
				if v81 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v82)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v82)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v82)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v82)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v82 + 64)) += int64(v81)
			}
		}
		goto done
	}
	if *(*int32)(unsafe.Pointer(bp + 4)) < 0 {
		/*
		 * a non-local variable: upvar from a local one! This consumes the
		 * variable name that was left at stacktop.
		 */
		*(*int32)(unsafe.Pointer(bp + 4)) = int32(XTclFindCompiledLocal(tls, (*TTcl_Token)(unsafe.Pointer(varTokenPtr)).Fstart, (*TTcl_Token)(unsafe.Pointer(varTokenPtr)).Fsize, int32(1), envPtr2))
		_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+14828, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy1 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v84 = envPtr2 + 152
			v83 = *(*uintptr)(unsafe.Pointer(v84))
			*(*uintptr)(unsafe.Pointer(v84))++
			*(*uint8)(unsafe.Pointer(v83)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v86 = envPtr2 + 152
			v85 = *(*uintptr)(unsafe.Pointer(v86))
			*(*uintptr)(unsafe.Pointer(v86))++
			*(*uint8)(unsafe.Pointer(v85)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v87 = delta1
				v88 = envPtr2
				if v87 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v88)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v88)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v88)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v88)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v88 + 64)) += int64(v87)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v90 = envPtr2 + 152
			v89 = *(*uintptr)(unsafe.Pointer(v90))
			*(*uintptr)(unsafe.Pointer(v90))++
			*(*uint8)(unsafe.Pointer(v89)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v92 = envPtr2 + 152
			v91 = *(*uintptr)(unsafe.Pointer(v92))
			*(*uintptr)(unsafe.Pointer(v92))++
			*(*uint8)(unsafe.Pointer(v91)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
			v94 = envPtr2 + 152
			v93 = *(*uintptr)(unsafe.Pointer(v94))
			*(*uintptr)(unsafe.Pointer(v94))++
			*(*uint8)(unsafe.Pointer(v93)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
			v96 = envPtr2 + 152
			v95 = *(*uintptr)(unsafe.Pointer(v96))
			*(*uintptr)(unsafe.Pointer(v96))++
			*(*uint8)(unsafe.Pointer(v95)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
			v98 = envPtr2 + 152
			v97 = *(*uintptr)(unsafe.Pointer(v98))
			*(*uintptr)(unsafe.Pointer(v98))++
			*(*uint8)(unsafe.Pointer(v97)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v99 = delta1
				v100 = envPtr2
				if v99 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v100)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v100)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v100)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v100)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v100 + 64)) += int64(v99)
			}
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v102 = envPtr2 + 152
		v101 = *(*uintptr)(unsafe.Pointer(v102))
		*(*uintptr)(unsafe.Pointer(v102))++
		*(*uint8)(unsafe.Pointer(v101)) = libc.Uint8FromInt32(int32(INST_REVERSE))
		v104 = envPtr2 + 152
		v103 = *(*uintptr)(unsafe.Pointer(v104))
		*(*uintptr)(unsafe.Pointer(v104))++
		*(*uint8)(unsafe.Pointer(v103)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
		v106 = envPtr2 + 152
		v105 = *(*uintptr)(unsafe.Pointer(v106))
		*(*uintptr)(unsafe.Pointer(v106))++
		*(*uint8)(unsafe.Pointer(v105)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
		v108 = envPtr2 + 152
		v107 = *(*uintptr)(unsafe.Pointer(v108))
		*(*uintptr)(unsafe.Pointer(v108))++
		*(*uint8)(unsafe.Pointer(v107)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
		v110 = envPtr2 + 152
		v109 = *(*uintptr)(unsafe.Pointer(v110))
		*(*uintptr)(unsafe.Pointer(v110))++
		*(*uint8)(unsafe.Pointer(v109)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(2)
			}
			v111 = delta1
			v112 = envPtr2
			if v111 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v112)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v112)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v112)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v112)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v112 + 64)) += int64(v111)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v114 = envPtr2 + 152
		v113 = *(*uintptr)(unsafe.Pointer(v114))
		*(*uintptr)(unsafe.Pointer(v114))++
		*(*uint8)(unsafe.Pointer(v113)) = libc.Uint8FromInt32(int32(INST_UPVAR))
		v116 = envPtr2 + 152
		v115 = *(*uintptr)(unsafe.Pointer(v116))
		*(*uintptr)(unsafe.Pointer(v116))++
		*(*uint8)(unsafe.Pointer(v115)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(24))
		v118 = envPtr2 + 152
		v117 = *(*uintptr)(unsafe.Pointer(v118))
		*(*uintptr)(unsafe.Pointer(v118))++
		*(*uint8)(unsafe.Pointer(v117)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(16))
		v120 = envPtr2 + 152
		v119 = *(*uintptr)(unsafe.Pointer(v120))
		*(*uintptr)(unsafe.Pointer(v120))++
		*(*uint8)(unsafe.Pointer(v119)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(8))
		v122 = envPtr2 + 152
		v121 = *(*uintptr)(unsafe.Pointer(v122))
		*(*uintptr)(unsafe.Pointer(v122))++
		*(*uint8)(unsafe.Pointer(v121)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_UPVAR)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
			}
			v123 = delta1
			v124 = envPtr2
			if v123 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v124)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v124)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v124)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v124)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v124 + 64)) += int64(v123)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v126 = envPtr2 + 152
		v125 = *(*uintptr)(unsafe.Pointer(v126))
		*(*uintptr)(unsafe.Pointer(v126))++
		*(*uint8)(unsafe.Pointer(v125)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v127 = delta1
			v128 = envPtr2
			if v127 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v128)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v128)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v128)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v128)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v128 + 64)) += int64(v127)
		}
	}
	/*
	 * Prepare for the internal foreach.
	 */
	keyVar = int32(XTclFindCompiledLocal(tls, libc.UintptrFromInt32(0), 0, int32(1), envPtr2))
	valVar = int32(XTclFindCompiledLocal(tls, libc.UintptrFromInt32(0), 0, int32(1), envPtr2))
	infoPtr = XTcl_Alloc(tls, uint64(libc.UintptrFromInt32(0)+24)+libc.Uint64FromInt64(8))
	(*TForeachInfo)(unsafe.Pointer(infoPtr)).FnumLists = int64(1)
	*(*uintptr)(unsafe.Pointer(infoPtr + 24)) = XTcl_Alloc(tls, uint64(libc.UintptrFromInt32(0)+8)+libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8))
	(*TForeachVarList)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(infoPtr + 24)))).FnumVars = int64(2)
	*(*TTcl_Size)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(infoPtr + 24)) + 8)) = int64(keyVar)
	*(*TTcl_Size)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(infoPtr + 24)) + 8 + 1*8)) = int64(valVar)
	infoIndex = int32(XTclCreateAuxData(tls, infoPtr, uintptr(unsafe.Pointer(&_newForeachInfoType)), envPtr2))
	/*
	 * Start issuing instructions to write to the array.
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v130 = envPtr2 + 152
	v129 = *(*uintptr)(unsafe.Pointer(v130))
	*(*uintptr)(unsafe.Pointer(v130))++
	*(*uint8)(unsafe.Pointer(v129)) = libc.Uint8FromInt32(int32(INST_ARRAY_EXISTS_IMM))
	v132 = envPtr2 + 152
	v131 = *(*uintptr)(unsafe.Pointer(v132))
	*(*uintptr)(unsafe.Pointer(v132))++
	*(*uint8)(unsafe.Pointer(v131)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(24))
	v134 = envPtr2 + 152
	v133 = *(*uintptr)(unsafe.Pointer(v134))
	*(*uintptr)(unsafe.Pointer(v134))++
	*(*uint8)(unsafe.Pointer(v133)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(16))
	v136 = envPtr2 + 152
	v135 = *(*uintptr)(unsafe.Pointer(v136))
	*(*uintptr)(unsafe.Pointer(v136))++
	*(*uint8)(unsafe.Pointer(v135)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(8))
	v138 = envPtr2 + 152
	v137 = *(*uintptr)(unsafe.Pointer(v138))
	*(*uintptr)(unsafe.Pointer(v138))++
	*(*uint8)(unsafe.Pointer(v137)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_ARRAY_EXISTS_IMM)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
		}
		v139 = delta1
		v140 = envPtr2
		if v139 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v140)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v140)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v140)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v140)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v140 + 64)) += int64(v139)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v142 = envPtr2 + 152
	v141 = *(*uintptr)(unsafe.Pointer(v142))
	*(*uintptr)(unsafe.Pointer(v142))++
	*(*uint8)(unsafe.Pointer(v141)) = libc.Uint8FromInt32(int32(INST_JUMP_TRUE1))
	v144 = envPtr2 + 152
	v143 = *(*uintptr)(unsafe.Pointer(v144))
	*(*uintptr)(unsafe.Pointer(v144))++
	*(*uint8)(unsafe.Pointer(v143)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(7)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_JUMP_TRUE1)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32(7)
		}
		v145 = delta1
		v146 = envPtr2
		if v145 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v146)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v146)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v146)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v146)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v146 + 64)) += int64(v145)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v148 = envPtr2 + 152
	v147 = *(*uintptr)(unsafe.Pointer(v148))
	*(*uintptr)(unsafe.Pointer(v148))++
	*(*uint8)(unsafe.Pointer(v147)) = libc.Uint8FromInt32(int32(INST_ARRAY_MAKE_IMM))
	v150 = envPtr2 + 152
	v149 = *(*uintptr)(unsafe.Pointer(v150))
	*(*uintptr)(unsafe.Pointer(v150))++
	*(*uint8)(unsafe.Pointer(v149)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(24))
	v152 = envPtr2 + 152
	v151 = *(*uintptr)(unsafe.Pointer(v152))
	*(*uintptr)(unsafe.Pointer(v152))++
	*(*uint8)(unsafe.Pointer(v151)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(16))
	v154 = envPtr2 + 152
	v153 = *(*uintptr)(unsafe.Pointer(v154))
	*(*uintptr)(unsafe.Pointer(v154))++
	*(*uint8)(unsafe.Pointer(v153)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(8))
	v156 = envPtr2 + 152
	v155 = *(*uintptr)(unsafe.Pointer(v156))
	*(*uintptr)(unsafe.Pointer(v156))++
	*(*uint8)(unsafe.Pointer(v155)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_ARRAY_MAKE_IMM)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
		}
		v157 = delta1
		v158 = envPtr2
		if v157 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v158)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v158)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v158)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v158)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v158 + 64)) += int64(v157)
	}
	if (*TTcl_Token)(unsafe.Pointer(dataTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(dataTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(dataTokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy2 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v160 = envPtr2 + 152
			v159 = *(*uintptr)(unsafe.Pointer(v160))
			*(*uintptr)(unsafe.Pointer(v160))++
			*(*uint8)(unsafe.Pointer(v159)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v162 = envPtr2 + 152
			v161 = *(*uintptr)(unsafe.Pointer(v162))
			*(*uintptr)(unsafe.Pointer(v162))++
			*(*uint8)(unsafe.Pointer(v161)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v163 = delta1
				v164 = envPtr2
				if v163 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v164)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v164)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v164)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v164)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v164 + 64)) += int64(v163)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v166 = envPtr2 + 152
			v165 = *(*uintptr)(unsafe.Pointer(v166))
			*(*uintptr)(unsafe.Pointer(v166))++
			*(*uint8)(unsafe.Pointer(v165)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v168 = envPtr2 + 152
			v167 = *(*uintptr)(unsafe.Pointer(v168))
			*(*uintptr)(unsafe.Pointer(v168))++
			*(*uint8)(unsafe.Pointer(v167)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
			v170 = envPtr2 + 152
			v169 = *(*uintptr)(unsafe.Pointer(v170))
			*(*uintptr)(unsafe.Pointer(v170))++
			*(*uint8)(unsafe.Pointer(v169)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
			v172 = envPtr2 + 152
			v171 = *(*uintptr)(unsafe.Pointer(v172))
			*(*uintptr)(unsafe.Pointer(v172))++
			*(*uint8)(unsafe.Pointer(v171)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
			v174 = envPtr2 + 152
			v173 = *(*uintptr)(unsafe.Pointer(v174))
			*(*uintptr)(unsafe.Pointer(v174))++
			*(*uint8)(unsafe.Pointer(v173)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v175 = delta1
				v176 = envPtr2
				if v175 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v176)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v176)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v176)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v176)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v176 + 64)) += int64(v175)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
		XTclCompileTokens(tls, interp, dataTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(dataTokenPtr)).FnumComponents), envPtr2)
	}
	if !(isDataLiteral != 0) || !(isDataValid != 0) {
		/*
		 * Only need this safety check if we're handling a non-literal or list
		 * containing an invalid literal; with valid list literals, we've
		 * already checked (worth it because literals are a very common
		 * use-case with [array set]).
		 */
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v178 = envPtr2 + 152
		v177 = *(*uintptr)(unsafe.Pointer(v178))
		*(*uintptr)(unsafe.Pointer(v178))++
		*(*uint8)(unsafe.Pointer(v177)) = libc.Uint8FromInt32(int32(INST_DUP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_DUP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v179 = delta1
			v180 = envPtr2
			if v179 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v180)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v180)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v180)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v180)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v180 + 64)) += int64(v179)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v182 = envPtr2 + 152
		v181 = *(*uintptr)(unsafe.Pointer(v182))
		*(*uintptr)(unsafe.Pointer(v182))++
		*(*uint8)(unsafe.Pointer(v181)) = libc.Uint8FromInt32(int32(INST_LIST_LENGTH))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LIST_LENGTH)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v183 = delta1
			v184 = envPtr2
			if v183 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v184)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v184)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v184)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v184)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v184 + 64)) += int64(v183)
		}
		_objIndexCopy3 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+21397, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy3 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v186 = envPtr2 + 152
			v185 = *(*uintptr)(unsafe.Pointer(v186))
			*(*uintptr)(unsafe.Pointer(v186))++
			*(*uint8)(unsafe.Pointer(v185)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v188 = envPtr2 + 152
			v187 = *(*uintptr)(unsafe.Pointer(v188))
			*(*uintptr)(unsafe.Pointer(v188))++
			*(*uint8)(unsafe.Pointer(v187)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy3
				}
				v189 = delta1
				v190 = envPtr2
				if v189 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v190)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v190)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v190)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v190)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v190 + 64)) += int64(v189)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v192 = envPtr2 + 152
			v191 = *(*uintptr)(unsafe.Pointer(v192))
			*(*uintptr)(unsafe.Pointer(v192))++
			*(*uint8)(unsafe.Pointer(v191)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v194 = envPtr2 + 152
			v193 = *(*uintptr)(unsafe.Pointer(v194))
			*(*uintptr)(unsafe.Pointer(v194))++
			*(*uint8)(unsafe.Pointer(v193)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(24))
			v196 = envPtr2 + 152
			v195 = *(*uintptr)(unsafe.Pointer(v196))
			*(*uintptr)(unsafe.Pointer(v196))++
			*(*uint8)(unsafe.Pointer(v195)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(16))
			v198 = envPtr2 + 152
			v197 = *(*uintptr)(unsafe.Pointer(v198))
			*(*uintptr)(unsafe.Pointer(v198))++
			*(*uint8)(unsafe.Pointer(v197)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(8))
			v200 = envPtr2 + 152
			v199 = *(*uintptr)(unsafe.Pointer(v200))
			*(*uintptr)(unsafe.Pointer(v200))++
			*(*uint8)(unsafe.Pointer(v199)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy3
				}
				v201 = delta1
				v202 = envPtr2
				if v201 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v202)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v202)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v202)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v202)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v202 + 64)) += int64(v201)
			}
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v204 = envPtr2 + 152
		v203 = *(*uintptr)(unsafe.Pointer(v204))
		*(*uintptr)(unsafe.Pointer(v204))++
		*(*uint8)(unsafe.Pointer(v203)) = libc.Uint8FromInt32(int32(INST_BITAND))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_BITAND)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v205 = delta1
			v206 = envPtr2
			if v205 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v206)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v206)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v206)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v206)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v206 + 64)) += int64(v205)
		}
		offsetFwd = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v208 = envPtr2 + 152
		v207 = *(*uintptr)(unsafe.Pointer(v208))
		*(*uintptr)(unsafe.Pointer(v208))++
		*(*uint8)(unsafe.Pointer(v207)) = libc.Uint8FromInt32(int32(INST_JUMP_FALSE1))
		v210 = envPtr2 + 152
		v209 = *(*uintptr)(unsafe.Pointer(v210))
		*(*uintptr)(unsafe.Pointer(v210))++
		*(*uint8)(unsafe.Pointer(v209)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP_FALSE1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v211 = delta1
			v212 = envPtr2
			if v211 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v212)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v212)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v212)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v212)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v212 + 64)) += int64(v211)
		}
		_objIndexCopy4 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+21399, libc.Int64FromUint64(libc.Uint64FromInt64(42)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy4 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v214 = envPtr2 + 152
			v213 = *(*uintptr)(unsafe.Pointer(v214))
			*(*uintptr)(unsafe.Pointer(v214))++
			*(*uint8)(unsafe.Pointer(v213)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v216 = envPtr2 + 152
			v215 = *(*uintptr)(unsafe.Pointer(v216))
			*(*uintptr)(unsafe.Pointer(v216))++
			*(*uint8)(unsafe.Pointer(v215)) = uint8(libc.Uint32FromInt32(_objIndexCopy4))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy4
				}
				v217 = delta1
				v218 = envPtr2
				if v217 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v218)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v218)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v218)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v218)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v218 + 64)) += int64(v217)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v220 = envPtr2 + 152
			v219 = *(*uintptr)(unsafe.Pointer(v220))
			*(*uintptr)(unsafe.Pointer(v220))++
			*(*uint8)(unsafe.Pointer(v219)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v222 = envPtr2 + 152
			v221 = *(*uintptr)(unsafe.Pointer(v222))
			*(*uintptr)(unsafe.Pointer(v222))++
			*(*uint8)(unsafe.Pointer(v221)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(24))
			v224 = envPtr2 + 152
			v223 = *(*uintptr)(unsafe.Pointer(v224))
			*(*uintptr)(unsafe.Pointer(v224))++
			*(*uint8)(unsafe.Pointer(v223)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(16))
			v226 = envPtr2 + 152
			v225 = *(*uintptr)(unsafe.Pointer(v226))
			*(*uintptr)(unsafe.Pointer(v226))++
			*(*uint8)(unsafe.Pointer(v225)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(8))
			v228 = envPtr2 + 152
			v227 = *(*uintptr)(unsafe.Pointer(v228))
			*(*uintptr)(unsafe.Pointer(v228))++
			*(*uint8)(unsafe.Pointer(v227)) = uint8(libc.Uint32FromInt32(_objIndexCopy4))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy4
				}
				v229 = delta1
				v230 = envPtr2
				if v229 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v230)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v230)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v230)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v230)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v230 + 64)) += int64(v229)
			}
		}
		_objIndexCopy5 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+21441, libc.Int64FromUint64(libc.Uint64FromInt64(33)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy5 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v232 = envPtr2 + 152
			v231 = *(*uintptr)(unsafe.Pointer(v232))
			*(*uintptr)(unsafe.Pointer(v232))++
			*(*uint8)(unsafe.Pointer(v231)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v234 = envPtr2 + 152
			v233 = *(*uintptr)(unsafe.Pointer(v234))
			*(*uintptr)(unsafe.Pointer(v234))++
			*(*uint8)(unsafe.Pointer(v233)) = uint8(libc.Uint32FromInt32(_objIndexCopy5))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy5
				}
				v235 = delta1
				v236 = envPtr2
				if v235 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v236)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v236)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v236)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v236)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v236 + 64)) += int64(v235)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v238 = envPtr2 + 152
			v237 = *(*uintptr)(unsafe.Pointer(v238))
			*(*uintptr)(unsafe.Pointer(v238))++
			*(*uint8)(unsafe.Pointer(v237)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v240 = envPtr2 + 152
			v239 = *(*uintptr)(unsafe.Pointer(v240))
			*(*uintptr)(unsafe.Pointer(v240))++
			*(*uint8)(unsafe.Pointer(v239)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(24))
			v242 = envPtr2 + 152
			v241 = *(*uintptr)(unsafe.Pointer(v242))
			*(*uintptr)(unsafe.Pointer(v242))++
			*(*uint8)(unsafe.Pointer(v241)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(16))
			v244 = envPtr2 + 152
			v243 = *(*uintptr)(unsafe.Pointer(v244))
			*(*uintptr)(unsafe.Pointer(v244))++
			*(*uint8)(unsafe.Pointer(v243)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(8))
			v246 = envPtr2 + 152
			v245 = *(*uintptr)(unsafe.Pointer(v246))
			*(*uintptr)(unsafe.Pointer(v246))++
			*(*uint8)(unsafe.Pointer(v245)) = uint8(libc.Uint32FromInt32(_objIndexCopy5))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy5
				}
				v247 = delta1
				v248 = envPtr2
				if v247 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v248)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v248)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v248)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v248)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v248 + 64)) += int64(v247)
			}
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v250 = envPtr2 + 152
		v249 = *(*uintptr)(unsafe.Pointer(v250))
		*(*uintptr)(unsafe.Pointer(v250))++
		*(*uint8)(unsafe.Pointer(v249)) = libc.Uint8FromInt32(int32(INST_RETURN_IMM))
		v252 = envPtr2 + 152
		v251 = *(*uintptr)(unsafe.Pointer(v252))
		*(*uintptr)(unsafe.Pointer(v252))++
		*(*uint8)(unsafe.Pointer(v251)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(TCL_ERROR)) >> libc.Int32FromInt32(24))
		v254 = envPtr2 + 152
		v253 = *(*uintptr)(unsafe.Pointer(v254))
		*(*uintptr)(unsafe.Pointer(v254))++
		*(*uint8)(unsafe.Pointer(v253)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(TCL_ERROR)) >> libc.Int32FromInt32(16))
		v256 = envPtr2 + 152
		v255 = *(*uintptr)(unsafe.Pointer(v256))
		*(*uintptr)(unsafe.Pointer(v256))++
		*(*uint8)(unsafe.Pointer(v255)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(TCL_ERROR)) >> libc.Int32FromInt32(8))
		v258 = envPtr2 + 152
		v257 = *(*uintptr)(unsafe.Pointer(v258))
		*(*uintptr)(unsafe.Pointer(v258))++
		*(*uint8)(unsafe.Pointer(v257)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(TCL_ERROR)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_RETURN_IMM)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(TCL_ERROR)
			}
			v259 = delta1
			v260 = envPtr2
			if v259 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v260)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v260)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v260)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v260)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v260 + 64)) += int64(v259)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v262 = envPtr2 + 152
		v261 = *(*uintptr)(unsafe.Pointer(v262))
		*(*uintptr)(unsafe.Pointer(v262))++
		*(*uint8)(unsafe.Pointer(v261)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
		v264 = envPtr2 + 152
		v263 = *(*uintptr)(unsafe.Pointer(v264))
		*(*uintptr)(unsafe.Pointer(v264))++
		*(*uint8)(unsafe.Pointer(v263)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
		v266 = envPtr2 + 152
		v265 = *(*uintptr)(unsafe.Pointer(v266))
		*(*uintptr)(unsafe.Pointer(v266))++
		*(*uint8)(unsafe.Pointer(v265)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
		v268 = envPtr2 + 152
		v267 = *(*uintptr)(unsafe.Pointer(v268))
		*(*uintptr)(unsafe.Pointer(v268))++
		*(*uint8)(unsafe.Pointer(v267)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
		v269 = -int32(1)
		v270 = envPtr2
		if v269 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v270)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v270)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v270)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v270)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v270 + 64)) += int64(v269)
		fwd = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(offsetFwd))
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(offsetFwd) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(fwd))
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v272 = envPtr2 + 152
	v271 = *(*uintptr)(unsafe.Pointer(v272))
	*(*uintptr)(unsafe.Pointer(v272))++
	*(*uint8)(unsafe.Pointer(v271)) = libc.Uint8FromInt32(int32(INST_FOREACH_START))
	v274 = envPtr2 + 152
	v273 = *(*uintptr)(unsafe.Pointer(v274))
	*(*uintptr)(unsafe.Pointer(v274))++
	*(*uint8)(unsafe.Pointer(v273)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(24))
	v276 = envPtr2 + 152
	v275 = *(*uintptr)(unsafe.Pointer(v276))
	*(*uintptr)(unsafe.Pointer(v276))++
	*(*uint8)(unsafe.Pointer(v275)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(16))
	v278 = envPtr2 + 152
	v277 = *(*uintptr)(unsafe.Pointer(v278))
	*(*uintptr)(unsafe.Pointer(v278))++
	*(*uint8)(unsafe.Pointer(v277)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(8))
	v280 = envPtr2 + 152
	v279 = *(*uintptr)(unsafe.Pointer(v280))
	*(*uintptr)(unsafe.Pointer(v280))++
	*(*uint8)(unsafe.Pointer(v279)) = uint8(libc.Uint32FromInt32(infoIndex))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_FOREACH_START)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - infoIndex
		}
		v281 = delta1
		v282 = envPtr2
		if v281 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v282)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v282)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v282)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v282)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v282 + 64)) += int64(v281)
	}
	offsetBack = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
	if keyVar <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v284 = envPtr2 + 152
		v283 = *(*uintptr)(unsafe.Pointer(v284))
		*(*uintptr)(unsafe.Pointer(v284))++
		*(*uint8)(unsafe.Pointer(v283)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
		v286 = envPtr2 + 152
		v285 = *(*uintptr)(unsafe.Pointer(v286))
		*(*uintptr)(unsafe.Pointer(v286))++
		*(*uint8)(unsafe.Pointer(v285)) = uint8(libc.Uint32FromInt32(keyVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - keyVar
			}
			v287 = delta1
			v288 = envPtr2
			if v287 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v288)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v288)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v288)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v288)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v288 + 64)) += int64(v287)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v290 = envPtr2 + 152
		v289 = *(*uintptr)(unsafe.Pointer(v290))
		*(*uintptr)(unsafe.Pointer(v290))++
		*(*uint8)(unsafe.Pointer(v289)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
		v292 = envPtr2 + 152
		v291 = *(*uintptr)(unsafe.Pointer(v292))
		*(*uintptr)(unsafe.Pointer(v292))++
		*(*uint8)(unsafe.Pointer(v291)) = uint8(libc.Uint32FromInt32(keyVar) >> libc.Int32FromInt32(24))
		v294 = envPtr2 + 152
		v293 = *(*uintptr)(unsafe.Pointer(v294))
		*(*uintptr)(unsafe.Pointer(v294))++
		*(*uint8)(unsafe.Pointer(v293)) = uint8(libc.Uint32FromInt32(keyVar) >> libc.Int32FromInt32(16))
		v296 = envPtr2 + 152
		v295 = *(*uintptr)(unsafe.Pointer(v296))
		*(*uintptr)(unsafe.Pointer(v296))++
		*(*uint8)(unsafe.Pointer(v295)) = uint8(libc.Uint32FromInt32(keyVar) >> libc.Int32FromInt32(8))
		v298 = envPtr2 + 152
		v297 = *(*uintptr)(unsafe.Pointer(v298))
		*(*uintptr)(unsafe.Pointer(v298))++
		*(*uint8)(unsafe.Pointer(v297)) = uint8(libc.Uint32FromInt32(keyVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - keyVar
			}
			v299 = delta1
			v300 = envPtr2
			if v299 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v300)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v300)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v300)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v300)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v300 + 64)) += int64(v299)
		}
	}
	if valVar <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v302 = envPtr2 + 152
		v301 = *(*uintptr)(unsafe.Pointer(v302))
		*(*uintptr)(unsafe.Pointer(v302))++
		*(*uint8)(unsafe.Pointer(v301)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
		v304 = envPtr2 + 152
		v303 = *(*uintptr)(unsafe.Pointer(v304))
		*(*uintptr)(unsafe.Pointer(v304))++
		*(*uint8)(unsafe.Pointer(v303)) = uint8(libc.Uint32FromInt32(valVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - valVar
			}
			v305 = delta1
			v306 = envPtr2
			if v305 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v306)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v306)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v306)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v306)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v306 + 64)) += int64(v305)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v308 = envPtr2 + 152
		v307 = *(*uintptr)(unsafe.Pointer(v308))
		*(*uintptr)(unsafe.Pointer(v308))++
		*(*uint8)(unsafe.Pointer(v307)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
		v310 = envPtr2 + 152
		v309 = *(*uintptr)(unsafe.Pointer(v310))
		*(*uintptr)(unsafe.Pointer(v310))++
		*(*uint8)(unsafe.Pointer(v309)) = uint8(libc.Uint32FromInt32(valVar) >> libc.Int32FromInt32(24))
		v312 = envPtr2 + 152
		v311 = *(*uintptr)(unsafe.Pointer(v312))
		*(*uintptr)(unsafe.Pointer(v312))++
		*(*uint8)(unsafe.Pointer(v311)) = uint8(libc.Uint32FromInt32(valVar) >> libc.Int32FromInt32(16))
		v314 = envPtr2 + 152
		v313 = *(*uintptr)(unsafe.Pointer(v314))
		*(*uintptr)(unsafe.Pointer(v314))++
		*(*uint8)(unsafe.Pointer(v313)) = uint8(libc.Uint32FromInt32(valVar) >> libc.Int32FromInt32(8))
		v316 = envPtr2 + 152
		v315 = *(*uintptr)(unsafe.Pointer(v316))
		*(*uintptr)(unsafe.Pointer(v316))++
		*(*uint8)(unsafe.Pointer(v315)) = uint8(libc.Uint32FromInt32(valVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - valVar
			}
			v317 = delta1
			v318 = envPtr2
			if v317 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v318)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v318)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v318)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v318)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v318 + 64)) += int64(v317)
		}
	}
	if *(*int32)(unsafe.Pointer(bp + 4)) <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v320 = envPtr2 + 152
		v319 = *(*uintptr)(unsafe.Pointer(v320))
		*(*uintptr)(unsafe.Pointer(v320))++
		*(*uint8)(unsafe.Pointer(v319)) = libc.Uint8FromInt32(int32(INST_STORE_ARRAY1))
		v322 = envPtr2 + 152
		v321 = *(*uintptr)(unsafe.Pointer(v322))
		*(*uintptr)(unsafe.Pointer(v322))++
		*(*uint8)(unsafe.Pointer(v321)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STORE_ARRAY1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
			}
			v323 = delta1
			v324 = envPtr2
			if v323 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v324)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v324)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v324)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v324)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v324 + 64)) += int64(v323)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v326 = envPtr2 + 152
		v325 = *(*uintptr)(unsafe.Pointer(v326))
		*(*uintptr)(unsafe.Pointer(v326))++
		*(*uint8)(unsafe.Pointer(v325)) = libc.Uint8FromInt32(int32(INST_STORE_ARRAY4))
		v328 = envPtr2 + 152
		v327 = *(*uintptr)(unsafe.Pointer(v328))
		*(*uintptr)(unsafe.Pointer(v328))++
		*(*uint8)(unsafe.Pointer(v327)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(24))
		v330 = envPtr2 + 152
		v329 = *(*uintptr)(unsafe.Pointer(v330))
		*(*uintptr)(unsafe.Pointer(v330))++
		*(*uint8)(unsafe.Pointer(v329)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(16))
		v332 = envPtr2 + 152
		v331 = *(*uintptr)(unsafe.Pointer(v332))
		*(*uintptr)(unsafe.Pointer(v332))++
		*(*uint8)(unsafe.Pointer(v331)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(8))
		v334 = envPtr2 + 152
		v333 = *(*uintptr)(unsafe.Pointer(v334))
		*(*uintptr)(unsafe.Pointer(v334))++
		*(*uint8)(unsafe.Pointer(v333)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STORE_ARRAY4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
			}
			v335 = delta1
			v336 = envPtr2
			if v335 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v336)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v336)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v336)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v336)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v336 + 64)) += int64(v335)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v338 = envPtr2 + 152
	v337 = *(*uintptr)(unsafe.Pointer(v338))
	*(*uintptr)(unsafe.Pointer(v338))++
	*(*uint8)(unsafe.Pointer(v337)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v339 = delta1
		v340 = envPtr2
		if v339 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v340)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v340)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v340)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v340)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v340 + 64)) += int64(v339)
	}
	(*TForeachInfo)(unsafe.Pointer(infoPtr)).FloopCtTemp = int64(offsetBack) - (int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)) /*misuse */
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v342 = envPtr2 + 152
	v341 = *(*uintptr)(unsafe.Pointer(v342))
	*(*uintptr)(unsafe.Pointer(v342))++
	*(*uint8)(unsafe.Pointer(v341)) = libc.Uint8FromInt32(int32(INST_FOREACH_STEP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_FOREACH_STEP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v343 = delta1
		v344 = envPtr2
		if v343 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v344)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v344)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v344)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v344)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v344 + 64)) += int64(v343)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v346 = envPtr2 + 152
	v345 = *(*uintptr)(unsafe.Pointer(v346))
	*(*uintptr)(unsafe.Pointer(v346))++
	*(*uint8)(unsafe.Pointer(v345)) = libc.Uint8FromInt32(int32(INST_FOREACH_END))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_FOREACH_END)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v347 = delta1
		v348 = envPtr2
		if v347 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v348)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v348)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v348)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v348)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v348 + 64)) += int64(v347)
	}
	v349 = -int32(3)
	v350 = envPtr2
	if v349 < libc.Int32FromInt32(0) {
		if int32((*TCompileEnv)(unsafe.Pointer(v350)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v350)).FcurrStackDepth) {
			(*TCompileEnv)(unsafe.Pointer(v350)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v350)).FcurrStackDepth
		}
	}
	*(*TTcl_Size)(unsafe.Pointer(v350 + 64)) += int64(v349)
	_objIndexCopy6 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy6 <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v352 = envPtr2 + 152
		v351 = *(*uintptr)(unsafe.Pointer(v352))
		*(*uintptr)(unsafe.Pointer(v352))++
		*(*uint8)(unsafe.Pointer(v351)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v354 = envPtr2 + 152
		v353 = *(*uintptr)(unsafe.Pointer(v354))
		*(*uintptr)(unsafe.Pointer(v354))++
		*(*uint8)(unsafe.Pointer(v353)) = uint8(libc.Uint32FromInt32(_objIndexCopy6))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy6
			}
			v355 = delta1
			v356 = envPtr2
			if v355 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v356)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v356)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v356)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v356)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v356 + 64)) += int64(v355)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v358 = envPtr2 + 152
		v357 = *(*uintptr)(unsafe.Pointer(v358))
		*(*uintptr)(unsafe.Pointer(v358))++
		*(*uint8)(unsafe.Pointer(v357)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v360 = envPtr2 + 152
		v359 = *(*uintptr)(unsafe.Pointer(v360))
		*(*uintptr)(unsafe.Pointer(v360))++
		*(*uint8)(unsafe.Pointer(v359)) = uint8(libc.Uint32FromInt32(_objIndexCopy6) >> libc.Int32FromInt32(24))
		v362 = envPtr2 + 152
		v361 = *(*uintptr)(unsafe.Pointer(v362))
		*(*uintptr)(unsafe.Pointer(v362))++
		*(*uint8)(unsafe.Pointer(v361)) = uint8(libc.Uint32FromInt32(_objIndexCopy6) >> libc.Int32FromInt32(16))
		v364 = envPtr2 + 152
		v363 = *(*uintptr)(unsafe.Pointer(v364))
		*(*uintptr)(unsafe.Pointer(v364))++
		*(*uint8)(unsafe.Pointer(v363)) = uint8(libc.Uint32FromInt32(_objIndexCopy6) >> libc.Int32FromInt32(8))
		v366 = envPtr2 + 152
		v365 = *(*uintptr)(unsafe.Pointer(v366))
		*(*uintptr)(unsafe.Pointer(v366))++
		*(*uint8)(unsafe.Pointer(v365)) = uint8(libc.Uint32FromInt32(_objIndexCopy6))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy6
			}
			v367 = delta1
			v368 = envPtr2
			if v367 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v368)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v368)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v368)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v368)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v368 + 64)) += int64(v367)
		}
	}
	goto done
done:
	;
	_objPtr = literalObj
	v370 = _objPtr
	v369 = *(*TTcl_Size)(unsafe.Pointer(v370))
	*(*TTcl_Size)(unsafe.Pointer(v370))--
	if v369 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return code
}

func XTclCompileArrayUnsetCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds resulting instructions. */
	var _objIndexCopy, delta1, v11, v17, v23, v35, v39, v45, v51, v57, v59, v63, v69, v81 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v12, v13, v14, v15, v16, v18, v19, v2, v20, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v36, v37, v38, v4, v40, v41, v42, v43, v44, v46, v47, v48, v49, v5, v50, v52, v53, v54, v55, v56, v58, v6, v60, v61, v62, v64, v65, v66, v67, v68, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v82, v9 uintptr
	var _ /* isScalar at bp+0 */ int32
	var _ /* localIndex at bp+4 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, eclIndex, mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1) /* TIP #280 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
		return XTclCompileBasic2ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
	XTclPushVarName(tls, interp, tokenPtr, envPtr2, int32(TCL_NO_ELEMENT), bp+4, bp)
	if !(*(*int32)(unsafe.Pointer(bp)) != 0) {
		return int32(TCL_ERROR)
	}
	if *(*int32)(unsafe.Pointer(bp + 4)) >= 0 {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v2 = envPtr2 + 152
		v1 = *(*uintptr)(unsafe.Pointer(v2))
		*(*uintptr)(unsafe.Pointer(v2))++
		*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_ARRAY_EXISTS_IMM))
		v4 = envPtr2 + 152
		v3 = *(*uintptr)(unsafe.Pointer(v4))
		*(*uintptr)(unsafe.Pointer(v4))++
		*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(24))
		v6 = envPtr2 + 152
		v5 = *(*uintptr)(unsafe.Pointer(v6))
		*(*uintptr)(unsafe.Pointer(v6))++
		*(*uint8)(unsafe.Pointer(v5)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(16))
		v8 = envPtr2 + 152
		v7 = *(*uintptr)(unsafe.Pointer(v8))
		*(*uintptr)(unsafe.Pointer(v8))++
		*(*uint8)(unsafe.Pointer(v7)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(8))
		v10 = envPtr2 + 152
		v9 = *(*uintptr)(unsafe.Pointer(v10))
		*(*uintptr)(unsafe.Pointer(v10))++
		*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_ARRAY_EXISTS_IMM)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
			}
			v11 = delta1
			v12 = envPtr2
			if v11 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v12)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v12)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v12)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v12)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v12 + 64)) += int64(v11)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v14 = envPtr2 + 152
		v13 = *(*uintptr)(unsafe.Pointer(v14))
		*(*uintptr)(unsafe.Pointer(v14))++
		*(*uint8)(unsafe.Pointer(v13)) = libc.Uint8FromInt32(int32(INST_JUMP_FALSE1))
		v16 = envPtr2 + 152
		v15 = *(*uintptr)(unsafe.Pointer(v16))
		*(*uintptr)(unsafe.Pointer(v16))++
		*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(8)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP_FALSE1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(8)
			}
			v17 = delta1
			v18 = envPtr2
			if v17 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v20 = envPtr2 + 152
		v19 = *(*uintptr)(unsafe.Pointer(v20))
		*(*uintptr)(unsafe.Pointer(v20))++
		*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_UNSET_SCALAR))
		v22 = envPtr2 + 152
		v21 = *(*uintptr)(unsafe.Pointer(v22))
		*(*uintptr)(unsafe.Pointer(v22))++
		*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_UNSET_SCALAR)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(1)
			}
			v23 = delta1
			v24 = envPtr2
			if v23 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v24 + 64)) += int64(v23)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v26 = envPtr2 + 152
		v25 = *(*uintptr)(unsafe.Pointer(v26))
		*(*uintptr)(unsafe.Pointer(v26))++
		*(*uint8)(unsafe.Pointer(v25)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(24))
		v28 = envPtr2 + 152
		v27 = *(*uintptr)(unsafe.Pointer(v28))
		*(*uintptr)(unsafe.Pointer(v28))++
		*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(16))
		v30 = envPtr2 + 152
		v29 = *(*uintptr)(unsafe.Pointer(v30))
		*(*uintptr)(unsafe.Pointer(v30))++
		*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(8))
		v32 = envPtr2 + 152
		v31 = *(*uintptr)(unsafe.Pointer(v32))
		*(*uintptr)(unsafe.Pointer(v32))++
		*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v34 = envPtr2 + 152
		v33 = *(*uintptr)(unsafe.Pointer(v34))
		*(*uintptr)(unsafe.Pointer(v34))++
		*(*uint8)(unsafe.Pointer(v33)) = libc.Uint8FromInt32(int32(INST_DUP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_DUP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v35 = delta1
			v36 = envPtr2
			if v35 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v36 + 64)) += int64(v35)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v38 = envPtr2 + 152
		v37 = *(*uintptr)(unsafe.Pointer(v38))
		*(*uintptr)(unsafe.Pointer(v38))++
		*(*uint8)(unsafe.Pointer(v37)) = libc.Uint8FromInt32(int32(INST_ARRAY_EXISTS_STK))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_ARRAY_EXISTS_STK)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v39 = delta1
			v40 = envPtr2
			if v39 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v40 + 64)) += int64(v39)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v42 = envPtr2 + 152
		v41 = *(*uintptr)(unsafe.Pointer(v42))
		*(*uintptr)(unsafe.Pointer(v42))++
		*(*uint8)(unsafe.Pointer(v41)) = libc.Uint8FromInt32(int32(INST_JUMP_FALSE1))
		v44 = envPtr2 + 152
		v43 = *(*uintptr)(unsafe.Pointer(v44))
		*(*uintptr)(unsafe.Pointer(v44))++
		*(*uint8)(unsafe.Pointer(v43)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(6)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP_FALSE1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(6)
			}
			v45 = delta1
			v46 = envPtr2
			if v45 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v46)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v46)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v46)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v46)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v46 + 64)) += int64(v45)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v48 = envPtr2 + 152
		v47 = *(*uintptr)(unsafe.Pointer(v48))
		*(*uintptr)(unsafe.Pointer(v48))++
		*(*uint8)(unsafe.Pointer(v47)) = libc.Uint8FromInt32(int32(INST_UNSET_STK))
		v50 = envPtr2 + 152
		v49 = *(*uintptr)(unsafe.Pointer(v50))
		*(*uintptr)(unsafe.Pointer(v50))++
		*(*uint8)(unsafe.Pointer(v49)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_UNSET_STK)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(1)
			}
			v51 = delta1
			v52 = envPtr2
			if v51 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v52)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v52)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v52)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v52)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v52 + 64)) += int64(v51)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v54 = envPtr2 + 152
		v53 = *(*uintptr)(unsafe.Pointer(v54))
		*(*uintptr)(unsafe.Pointer(v54))++
		*(*uint8)(unsafe.Pointer(v53)) = libc.Uint8FromInt32(int32(INST_JUMP1))
		v56 = envPtr2 + 152
		v55 = *(*uintptr)(unsafe.Pointer(v56))
		*(*uintptr)(unsafe.Pointer(v56))++
		*(*uint8)(unsafe.Pointer(v55)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(3)
			}
			v57 = delta1
			v58 = envPtr2
			if v57 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v58)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v58)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v58)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v58)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v58 + 64)) += int64(v57)
		}
		/* Each branch decrements stack depth, but we only take one. */
		v59 = int32(1)
		v60 = envPtr2
		if v59 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v60)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v60)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v60)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v60)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v60 + 64)) += int64(v59)
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v62 = envPtr2 + 152
		v61 = *(*uintptr)(unsafe.Pointer(v62))
		*(*uintptr)(unsafe.Pointer(v62))++
		*(*uint8)(unsafe.Pointer(v61)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v63 = delta1
			v64 = envPtr2
			if v63 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v64)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v64)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v64)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v64)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v64 + 64)) += int64(v63)
		}
	}
	_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v66 = envPtr2 + 152
		v65 = *(*uintptr)(unsafe.Pointer(v66))
		*(*uintptr)(unsafe.Pointer(v66))++
		*(*uint8)(unsafe.Pointer(v65)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v68 = envPtr2 + 152
		v67 = *(*uintptr)(unsafe.Pointer(v68))
		*(*uintptr)(unsafe.Pointer(v68))++
		*(*uint8)(unsafe.Pointer(v67)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v69 = delta1
			v70 = envPtr2
			if v69 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v70 + 64)) += int64(v69)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v72 = envPtr2 + 152
		v71 = *(*uintptr)(unsafe.Pointer(v72))
		*(*uintptr)(unsafe.Pointer(v72))++
		*(*uint8)(unsafe.Pointer(v71)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v74 = envPtr2 + 152
		v73 = *(*uintptr)(unsafe.Pointer(v74))
		*(*uintptr)(unsafe.Pointer(v74))++
		*(*uint8)(unsafe.Pointer(v73)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
		v76 = envPtr2 + 152
		v75 = *(*uintptr)(unsafe.Pointer(v76))
		*(*uintptr)(unsafe.Pointer(v76))++
		*(*uint8)(unsafe.Pointer(v75)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
		v78 = envPtr2 + 152
		v77 = *(*uintptr)(unsafe.Pointer(v78))
		*(*uintptr)(unsafe.Pointer(v78))++
		*(*uint8)(unsafe.Pointer(v77)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
		v80 = envPtr2 + 152
		v79 = *(*uintptr)(unsafe.Pointer(v80))
		*(*uintptr)(unsafe.Pointer(v80))++
		*(*uint8)(unsafe.Pointer(v79)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v81 = delta1
			v82 = envPtr2
			if v81 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v82)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v82)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v82)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v82)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v82 + 64)) += int64(v81)
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileBreakCmd --
 *
 *	Procedure called to compile the "break" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "break" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileBreakCmd(tls *libc.TLS, dummy513 uintptr, parsePtr uintptr, dummy516 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds resulting instructions. */
	var delta1, v3, v5 int32
	var rangePtr, v1, v2, v4, v6 uintptr
	var _ /* auxPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _ = delta1, rangePtr, v1, v2, v3, v4, v5, v6
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(1) {
		return int32(TCL_ERROR)
	}
	/*
	 * Find the innermost exception range that contains this command.
	 */
	rangePtr = XTclGetInnermostExceptionRange(tls, envPtr2, int32(TCL_BREAK), bp)
	if rangePtr != 0 && (*TExceptionRange)(unsafe.Pointer(rangePtr)).Ftype1 == int32(LOOP_EXCEPTION_RANGE) {
		/*
		 * Found the target! No need for a nasty INST_BREAK here.
		 */
		XTclCleanupStackForBreakContinue(tls, envPtr2, *(*uintptr)(unsafe.Pointer(bp)))
		XTclAddLoopBreakFixup(tls, envPtr2, *(*uintptr)(unsafe.Pointer(bp)))
	} else {
		/*
		 * Emit a real break.
		 */
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v2 = envPtr2 + 152
		v1 = *(*uintptr)(unsafe.Pointer(v2))
		*(*uintptr)(unsafe.Pointer(v2))++
		*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_BREAK))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_BREAK)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v3 = delta1
			v4 = envPtr2
			if v3 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v4)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v4)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v4)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v4)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v4 + 64)) += int64(v3)
		}
	}
	v5 = int32(1)
	v6 = envPtr2
	if v5 < libc.Int32FromInt32(0) {
		if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
			(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
		}
	}
	*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileCatchCmd --
 *
 *	Procedure called to compile the "catch" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "catch" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileCatchCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy573 uintptr, envPtr3 uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Holds resulting instructions. */
	var _objIndexCopy, delta1, depth1, dropScript, optsIndex, range1, resultIndex, v1, v104, v108, v12, v120, v126, v138, v142, v25, v30, v42, v46, v54, v66, v70, v74, v78, v82, v86, v92 int32
	var cmdTokenPtr, mapPtr, optsNameTokenPtr, resultNameTokenPtr, v10, v100, v101, v102, v103, v105, v106, v107, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v121, v122, v123, v124, v125, v127, v128, v129, v13, v130, v131, v132, v133, v134, v135, v136, v137, v139, v140, v141, v143, v145, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v26, v28, v29, v3, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v43, v44, v45, v47, v49, v5, v50, v51, v52, v53, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v67, v68, v69, v7, v71, v72, v73, v75, v76, v77, v79, v8, v80, v81, v83, v84, v85, v87, v88, v89, v9, v90, v91, v93, v94, v95, v96, v97, v98, v99 uintptr
	var eclIndex TTcl_Size
	var v14, v27 int64
	var v144, v48 Tsize_t
	var _ /* jumpFixup at bp+0 */ TJumpFixup
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, cmdTokenPtr, delta1, depth1, dropScript, eclIndex, mapPtr, optsIndex, optsNameTokenPtr, range1, resultIndex, resultNameTokenPtr, v1, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v123, v124, v125, v126, v127, v128, v129, v13, v130, v131, v132, v133, v134, v135, v136, v137, v138, v139, v14, v140, v141, v142, v143, v144, v145, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr3)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	dropScript = 0
	depth1 = int32((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcurrStackDepth)
	/*
	 * If syntax does not match what we expect for [catch], do not compile.
	 * Let runtime checks determine if syntax has changed.
	 */
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) < int32(2) || int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) > int32(4) {
		return int32(TCL_ERROR)
	}
	/*
	 * If variables were specified and the catch command is at global level
	 * (not in a procedure), don't compile it inline: the payoff is too small.
	 */
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) >= int32(3) && !((*TCompileEnv)(unsafe.Pointer(envPtr3)).FprocPtr != 0 || (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr3)).FiPtr)).FvarFramePtr)).FlocalCachePtr != 0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Make sure the variable names, if any, have no substitutions and just
	 * refer to local scalars.
	 */
	v1 = -libc.Int32FromInt32(1)
	optsIndex = v1
	resultIndex = v1
	cmdTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) >= int32(3) {
		resultNameTokenPtr = cmdTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(cmdTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		/* DGP */
		resultIndex = libc.Int32FromUint64(XTclLocalScalarFromToken(tls, resultNameTokenPtr, envPtr3))
		if resultIndex < 0 {
			return int32(TCL_ERROR)
		}
		/* DKF */
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(4) {
			optsNameTokenPtr = resultNameTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(resultNameTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
			optsIndex = libc.Int32FromUint64(XTclLocalScalarFromToken(tls, optsNameTokenPtr, envPtr3))
			if optsIndex < 0 {
				return int32(TCL_ERROR)
			}
		}
	}
	/*
	 * We will compile the catch command. Declare the exception range that it
	 * uses.
	 *
	 * If the body is a simple word, compile a BEGIN_CATCH instruction,
	 * followed by the instructions to eval the body.
	 * Otherwise, compile instructions to substitute the body text before
	 * starting the catch, then BEGIN_CATCH, and then EVAL_STK to evaluate the
	 * substituted body.
	 * Care has to be taken to make sure that substitution happens outside the
	 * catch range so that errors in the substitution are not caught.
	 * [Bug 219184]
	 * The reason for duplicating the script is that EVAL_STK would otherwise
	 * begin by underflowing the stack below the mark set by BEGIN_CATCH4.
	 */
	range1 = int32(XTclCreateExceptRange(tls, int32(CATCH_EXCEPTION_RANGE), envPtr3))
	if (*TTcl_Token)(unsafe.Pointer(cmdTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr3)
		}
		v3 = envPtr3 + 152
		v2 = *(*uintptr)(unsafe.Pointer(v3))
		*(*uintptr)(unsafe.Pointer(v3))++
		*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32(INST_BEGIN_CATCH4))
		v5 = envPtr3 + 152
		v4 = *(*uintptr)(unsafe.Pointer(v5))
		*(*uintptr)(unsafe.Pointer(v5))++
		*(*uint8)(unsafe.Pointer(v4)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(24))
		v7 = envPtr3 + 152
		v6 = *(*uintptr)(unsafe.Pointer(v7))
		*(*uintptr)(unsafe.Pointer(v7))++
		*(*uint8)(unsafe.Pointer(v6)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(16))
		v9 = envPtr3 + 152
		v8 = *(*uintptr)(unsafe.Pointer(v9))
		*(*uintptr)(unsafe.Pointer(v9))++
		*(*uint8)(unsafe.Pointer(v8)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(8))
		v11 = envPtr3 + 152
		v10 = *(*uintptr)(unsafe.Pointer(v11))
		*(*uintptr)(unsafe.Pointer(v11))++
		*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt32(range1))
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_BEGIN_CATCH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - range1
			}
			v12 = delta1
			v13 = envPtr3
			if v12 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v13)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v13)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v13)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v13)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v13 + 64)) += int64(v12)
		}
		(*TCompileEnv)(unsafe.Pointer(envPtr3)).FexceptDepth++
		if libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FexceptDepth)+uint64(1) > libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FmaxExceptDepth)+uint64(1) {
			v14 = (*TCompileEnv)(unsafe.Pointer(envPtr3)).FexceptDepth
		} else {
			v14 = (*TCompileEnv)(unsafe.Pointer(envPtr3)).FmaxExceptDepth
		}
		(*TCompileEnv)(unsafe.Pointer(envPtr3)).FmaxExceptDepth = v14
		(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr3)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeStart)
		(*TCompileEnv)(unsafe.Pointer(envPtr3)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr3)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileCmdWord(tls, interp, cmdTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(cmdTokenPtr)).FnumComponents), envPtr3)
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr3)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr3)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, cmdTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(cmdTokenPtr)).FnumComponents), envPtr3)
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr3)
		}
		v16 = envPtr3 + 152
		v15 = *(*uintptr)(unsafe.Pointer(v16))
		*(*uintptr)(unsafe.Pointer(v16))++
		*(*uint8)(unsafe.Pointer(v15)) = libc.Uint8FromInt32(int32(INST_BEGIN_CATCH4))
		v18 = envPtr3 + 152
		v17 = *(*uintptr)(unsafe.Pointer(v18))
		*(*uintptr)(unsafe.Pointer(v18))++
		*(*uint8)(unsafe.Pointer(v17)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(24))
		v20 = envPtr3 + 152
		v19 = *(*uintptr)(unsafe.Pointer(v20))
		*(*uintptr)(unsafe.Pointer(v20))++
		*(*uint8)(unsafe.Pointer(v19)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(16))
		v22 = envPtr3 + 152
		v21 = *(*uintptr)(unsafe.Pointer(v22))
		*(*uintptr)(unsafe.Pointer(v22))++
		*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(8))
		v24 = envPtr3 + 152
		v23 = *(*uintptr)(unsafe.Pointer(v24))
		*(*uintptr)(unsafe.Pointer(v24))++
		*(*uint8)(unsafe.Pointer(v23)) = uint8(libc.Uint32FromInt32(range1))
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_BEGIN_CATCH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - range1
			}
			v25 = delta1
			v26 = envPtr3
			if v25 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v26)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v26)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v26)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v26)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v26 + 64)) += int64(v25)
		}
		(*TCompileEnv)(unsafe.Pointer(envPtr3)).FexceptDepth++
		if libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FexceptDepth)+uint64(1) > libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FmaxExceptDepth)+uint64(1) {
			v27 = (*TCompileEnv)(unsafe.Pointer(envPtr3)).FexceptDepth
		} else {
			v27 = (*TCompileEnv)(unsafe.Pointer(envPtr3)).FmaxExceptDepth
		}
		(*TCompileEnv)(unsafe.Pointer(envPtr3)).FmaxExceptDepth = v27
		(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr3)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeStart)
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr3)
		}
		v29 = envPtr3 + 152
		v28 = *(*uintptr)(unsafe.Pointer(v29))
		*(*uintptr)(unsafe.Pointer(v29))++
		*(*uint8)(unsafe.Pointer(v28)) = libc.Uint8FromInt32(int32(INST_DUP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_DUP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v30 = delta1
			v31 = envPtr3
			if v30 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v31)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v31)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v31)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v31)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v31 + 64)) += int64(v30)
		}
		XTclEmitInvoke(tls, envPtr3, int32(INST_EVAL_STK), 0)
		/* drop the script */
		dropScript = int32(1)
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr3)
		}
		v33 = envPtr3 + 152
		v32 = *(*uintptr)(unsafe.Pointer(v33))
		*(*uintptr)(unsafe.Pointer(v33))++
		*(*uint8)(unsafe.Pointer(v32)) = libc.Uint8FromInt32(int32(INST_REVERSE))
		v35 = envPtr3 + 152
		v34 = *(*uintptr)(unsafe.Pointer(v35))
		*(*uintptr)(unsafe.Pointer(v35))++
		*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
		v37 = envPtr3 + 152
		v36 = *(*uintptr)(unsafe.Pointer(v37))
		*(*uintptr)(unsafe.Pointer(v37))++
		*(*uint8)(unsafe.Pointer(v36)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
		v39 = envPtr3 + 152
		v38 = *(*uintptr)(unsafe.Pointer(v39))
		*(*uintptr)(unsafe.Pointer(v39))++
		*(*uint8)(unsafe.Pointer(v38)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
		v41 = envPtr3 + 152
		v40 = *(*uintptr)(unsafe.Pointer(v41))
		*(*uintptr)(unsafe.Pointer(v41))++
		*(*uint8)(unsafe.Pointer(v40)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(2)
			}
			v42 = delta1
			v43 = envPtr3
			if v42 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v43)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v43)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v43)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v43)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v43 + 64)) += int64(v42)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr3)
		}
		v45 = envPtr3 + 152
		v44 = *(*uintptr)(unsafe.Pointer(v45))
		*(*uintptr)(unsafe.Pointer(v45))++
		*(*uint8)(unsafe.Pointer(v44)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v46 = delta1
			v47 = envPtr3
			if v46 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v47)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v47)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v47)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v47)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v47 + 64)) += int64(v46)
		}
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr3)).FexceptDepth--
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr3)).FexceptArrayPtr + uintptr(range1)*56))).FnumCodeBytes = int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeStart) - int64(int32((*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr3)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset))
	/*
	 * Emit the "no errors" epilogue: push "0" (TCL_OK) as the catch result,
	 * and jump around the "error case" code.
	 */
	v48 = libc.Uint64FromInt32(depth1 + int32(1))
	v49 = envPtr3
	if v48 != libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(v49)).FcurrStackDepth) {
		XTcl_Panic(tls, __ccgo_ts+21474, libc.VaList(bp+24, libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(v49)).FcurrStackDepth), v48))
	}
	_objIndexCopy = XTclRegisterLiteral(tls, envPtr3, __ccgo_ts+14828, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr3)
		}
		v51 = envPtr3 + 152
		v50 = *(*uintptr)(unsafe.Pointer(v51))
		*(*uintptr)(unsafe.Pointer(v51))++
		*(*uint8)(unsafe.Pointer(v50)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v53 = envPtr3 + 152
		v52 = *(*uintptr)(unsafe.Pointer(v53))
		*(*uintptr)(unsafe.Pointer(v53))++
		*(*uint8)(unsafe.Pointer(v52)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v54 = delta1
			v55 = envPtr3
			if v54 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v55)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v55)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v55)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v55)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v55 + 64)) += int64(v54)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr3)
		}
		v57 = envPtr3 + 152
		v56 = *(*uintptr)(unsafe.Pointer(v57))
		*(*uintptr)(unsafe.Pointer(v57))++
		*(*uint8)(unsafe.Pointer(v56)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v59 = envPtr3 + 152
		v58 = *(*uintptr)(unsafe.Pointer(v59))
		*(*uintptr)(unsafe.Pointer(v59))++
		*(*uint8)(unsafe.Pointer(v58)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
		v61 = envPtr3 + 152
		v60 = *(*uintptr)(unsafe.Pointer(v61))
		*(*uintptr)(unsafe.Pointer(v61))++
		*(*uint8)(unsafe.Pointer(v60)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
		v63 = envPtr3 + 152
		v62 = *(*uintptr)(unsafe.Pointer(v63))
		*(*uintptr)(unsafe.Pointer(v63))++
		*(*uint8)(unsafe.Pointer(v62)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
		v65 = envPtr3 + 152
		v64 = *(*uintptr)(unsafe.Pointer(v65))
		*(*uintptr)(unsafe.Pointer(v65))++
		*(*uint8)(unsafe.Pointer(v64)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v66 = delta1
			v67 = envPtr3
			if v66 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v67)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v67)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v67)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v67)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v67 + 64)) += int64(v66)
		}
	}
	XTclEmitForwardJump(tls, envPtr3, int32(TCL_UNCONDITIONAL_JUMP), bp)
	/*
	 * Emit the "error case" epilogue. Push the interpreter result and the
	 * return code.
	 */
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr3)).FexceptArrayPtr + uintptr(range1)*56))).FcatchOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeStart)
	(*TCompileEnv)(unsafe.Pointer(envPtr3)).FcurrStackDepth = int64(depth1 + dropScript)
	if dropScript != 0 {
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr3)
		}
		v69 = envPtr3 + 152
		v68 = *(*uintptr)(unsafe.Pointer(v69))
		*(*uintptr)(unsafe.Pointer(v69))++
		*(*uint8)(unsafe.Pointer(v68)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v70 = delta1
			v71 = envPtr3
			if v70 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v71)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v71)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v71)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v71)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v71 + 64)) += int64(v70)
		}
	}
	/* Stack at this point is empty */
	if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr3)
	}
	v73 = envPtr3 + 152
	v72 = *(*uintptr)(unsafe.Pointer(v73))
	*(*uintptr)(unsafe.Pointer(v73))++
	*(*uint8)(unsafe.Pointer(v72)) = libc.Uint8FromInt32(int32(INST_PUSH_RESULT))
	if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_PUSH_RESULT)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v74 = delta1
		v75 = envPtr3
		if v74 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v75)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v75)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v75)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v75)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v75 + 64)) += int64(v74)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr3)
	}
	v77 = envPtr3 + 152
	v76 = *(*uintptr)(unsafe.Pointer(v77))
	*(*uintptr)(unsafe.Pointer(v77))++
	*(*uint8)(unsafe.Pointer(v76)) = libc.Uint8FromInt32(int32(INST_PUSH_RETURN_CODE))
	if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_PUSH_RETURN_CODE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v78 = delta1
		v79 = envPtr3
		if v78 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v79)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v79)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v79)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v79)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v79 + 64)) += int64(v78)
	}
	/* Stack at this point on both branches: result returnCode */
	if XTclFixupForwardJump(tls, envPtr3, bp, int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeStart)-int64(libc.Int32FromUint32((*TJumpFixup)(unsafe.Pointer(bp)).FcodeOffset))), int32(127)) != 0 {
		XTcl_Panic(tls, __ccgo_ts+21526, libc.VaList(bp+24, int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeStart)-libc.Int64FromUint32((*(*TJumpFixup)(unsafe.Pointer(bp))).FcodeOffset)))
	}
	/*
	 * Push the return options if the caller wants them. This needs to happen
	 * before INST_END_CATCH
	 */
	if optsIndex != -int32(1) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr3)
		}
		v81 = envPtr3 + 152
		v80 = *(*uintptr)(unsafe.Pointer(v81))
		*(*uintptr)(unsafe.Pointer(v81))++
		*(*uint8)(unsafe.Pointer(v80)) = libc.Uint8FromInt32(int32(INST_PUSH_RETURN_OPTIONS))
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH_RETURN_OPTIONS)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v82 = delta1
			v83 = envPtr3
			if v82 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v83)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v83)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v83)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v83)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v83 + 64)) += int64(v82)
		}
	}
	/*
	 * End the catch
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr3)
	}
	v85 = envPtr3 + 152
	v84 = *(*uintptr)(unsafe.Pointer(v85))
	*(*uintptr)(unsafe.Pointer(v85))++
	*(*uint8)(unsafe.Pointer(v84)) = libc.Uint8FromInt32(int32(INST_END_CATCH))
	if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_END_CATCH)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v86 = delta1
		v87 = envPtr3
		if v86 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v87)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v87)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v87)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v87)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v87 + 64)) += int64(v86)
	}
	/*
	 * Save the result and return options if the caller wants them. This needs
	 * to happen after INST_END_CATCH (compile-3.6/7).
	 */
	if optsIndex != -int32(1) {
		if optsIndex <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr3)
			}
			v89 = envPtr3 + 152
			v88 = *(*uintptr)(unsafe.Pointer(v89))
			*(*uintptr)(unsafe.Pointer(v89))++
			*(*uint8)(unsafe.Pointer(v88)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
			v91 = envPtr3 + 152
			v90 = *(*uintptr)(unsafe.Pointer(v91))
			*(*uintptr)(unsafe.Pointer(v91))++
			*(*uint8)(unsafe.Pointer(v90)) = uint8(libc.Uint32FromInt32(optsIndex))
			if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - optsIndex
				}
				v92 = delta1
				v93 = envPtr3
				if v92 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v93)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v93)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v93)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v93)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v93 + 64)) += int64(v92)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr3)
			}
			v95 = envPtr3 + 152
			v94 = *(*uintptr)(unsafe.Pointer(v95))
			*(*uintptr)(unsafe.Pointer(v95))++
			*(*uint8)(unsafe.Pointer(v94)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
			v97 = envPtr3 + 152
			v96 = *(*uintptr)(unsafe.Pointer(v97))
			*(*uintptr)(unsafe.Pointer(v97))++
			*(*uint8)(unsafe.Pointer(v96)) = uint8(libc.Uint32FromInt32(optsIndex) >> libc.Int32FromInt32(24))
			v99 = envPtr3 + 152
			v98 = *(*uintptr)(unsafe.Pointer(v99))
			*(*uintptr)(unsafe.Pointer(v99))++
			*(*uint8)(unsafe.Pointer(v98)) = uint8(libc.Uint32FromInt32(optsIndex) >> libc.Int32FromInt32(16))
			v101 = envPtr3 + 152
			v100 = *(*uintptr)(unsafe.Pointer(v101))
			*(*uintptr)(unsafe.Pointer(v101))++
			*(*uint8)(unsafe.Pointer(v100)) = uint8(libc.Uint32FromInt32(optsIndex) >> libc.Int32FromInt32(8))
			v103 = envPtr3 + 152
			v102 = *(*uintptr)(unsafe.Pointer(v103))
			*(*uintptr)(unsafe.Pointer(v103))++
			*(*uint8)(unsafe.Pointer(v102)) = uint8(libc.Uint32FromInt32(optsIndex))
			if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - optsIndex
				}
				v104 = delta1
				v105 = envPtr3
				if v104 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v105)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v105)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v105)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v105)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v105 + 64)) += int64(v104)
			}
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr3)
		}
		v107 = envPtr3 + 152
		v106 = *(*uintptr)(unsafe.Pointer(v107))
		*(*uintptr)(unsafe.Pointer(v107))++
		*(*uint8)(unsafe.Pointer(v106)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v108 = delta1
			v109 = envPtr3
			if v108 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v109)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v109)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v109)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v109)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v109 + 64)) += int64(v108)
		}
	}
	/*
	 * At this point, the top of the stack is inconveniently ordered:
	 *		result returnCode
	 * Reverse the stack to store the result.
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr3)
	}
	v111 = envPtr3 + 152
	v110 = *(*uintptr)(unsafe.Pointer(v111))
	*(*uintptr)(unsafe.Pointer(v111))++
	*(*uint8)(unsafe.Pointer(v110)) = libc.Uint8FromInt32(int32(INST_REVERSE))
	v113 = envPtr3 + 152
	v112 = *(*uintptr)(unsafe.Pointer(v113))
	*(*uintptr)(unsafe.Pointer(v113))++
	*(*uint8)(unsafe.Pointer(v112)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
	v115 = envPtr3 + 152
	v114 = *(*uintptr)(unsafe.Pointer(v115))
	*(*uintptr)(unsafe.Pointer(v115))++
	*(*uint8)(unsafe.Pointer(v114)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
	v117 = envPtr3 + 152
	v116 = *(*uintptr)(unsafe.Pointer(v117))
	*(*uintptr)(unsafe.Pointer(v117))++
	*(*uint8)(unsafe.Pointer(v116)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
	v119 = envPtr3 + 152
	v118 = *(*uintptr)(unsafe.Pointer(v119))
	*(*uintptr)(unsafe.Pointer(v119))++
	*(*uint8)(unsafe.Pointer(v118)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32(2)
		}
		v120 = delta1
		v121 = envPtr3
		if v120 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v121)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v121)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v121)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v121)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v121 + 64)) += int64(v120)
	}
	if resultIndex != -int32(1) {
		if resultIndex <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr3)
			}
			v123 = envPtr3 + 152
			v122 = *(*uintptr)(unsafe.Pointer(v123))
			*(*uintptr)(unsafe.Pointer(v123))++
			*(*uint8)(unsafe.Pointer(v122)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
			v125 = envPtr3 + 152
			v124 = *(*uintptr)(unsafe.Pointer(v125))
			*(*uintptr)(unsafe.Pointer(v125))++
			*(*uint8)(unsafe.Pointer(v124)) = uint8(libc.Uint32FromInt32(resultIndex))
			if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - resultIndex
				}
				v126 = delta1
				v127 = envPtr3
				if v126 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v127)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v127)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v127)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v127)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v127 + 64)) += int64(v126)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr3)
			}
			v129 = envPtr3 + 152
			v128 = *(*uintptr)(unsafe.Pointer(v129))
			*(*uintptr)(unsafe.Pointer(v129))++
			*(*uint8)(unsafe.Pointer(v128)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
			v131 = envPtr3 + 152
			v130 = *(*uintptr)(unsafe.Pointer(v131))
			*(*uintptr)(unsafe.Pointer(v131))++
			*(*uint8)(unsafe.Pointer(v130)) = uint8(libc.Uint32FromInt32(resultIndex) >> libc.Int32FromInt32(24))
			v133 = envPtr3 + 152
			v132 = *(*uintptr)(unsafe.Pointer(v133))
			*(*uintptr)(unsafe.Pointer(v133))++
			*(*uint8)(unsafe.Pointer(v132)) = uint8(libc.Uint32FromInt32(resultIndex) >> libc.Int32FromInt32(16))
			v135 = envPtr3 + 152
			v134 = *(*uintptr)(unsafe.Pointer(v135))
			*(*uintptr)(unsafe.Pointer(v135))++
			*(*uint8)(unsafe.Pointer(v134)) = uint8(libc.Uint32FromInt32(resultIndex) >> libc.Int32FromInt32(8))
			v137 = envPtr3 + 152
			v136 = *(*uintptr)(unsafe.Pointer(v137))
			*(*uintptr)(unsafe.Pointer(v137))++
			*(*uint8)(unsafe.Pointer(v136)) = uint8(libc.Uint32FromInt32(resultIndex))
			if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - resultIndex
				}
				v138 = delta1
				v139 = envPtr3
				if v138 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v139)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v139)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v139)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v139)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v139 + 64)) += int64(v138)
			}
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr3)
	}
	v141 = envPtr3 + 152
	v140 = *(*uintptr)(unsafe.Pointer(v141))
	*(*uintptr)(unsafe.Pointer(v141))++
	*(*uint8)(unsafe.Pointer(v140)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v142 = delta1
		v143 = envPtr3
		if v142 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v143)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v143)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v143)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v143)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v143 + 64)) += int64(v142)
	}
	v144 = libc.Uint64FromInt32(depth1 + int32(1))
	v145 = envPtr3
	if v144 != libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(v145)).FcurrStackDepth) {
		XTcl_Panic(tls, __ccgo_ts+21474, libc.VaList(bp+24, libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(v145)).FcurrStackDepth), v144))
	}
	return TCL_OK
}

/*----------------------------------------------------------------------
 *
 * TclCompileClockClicksCmd --
 *
 *	Procedure called to compile the "tcl::clock::clicks" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to run time.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "clock clicks"
 *	command at runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileClockClicksCmd(tls *libc.TLS, dummy752 uintptr, parsePtr uintptr, dummy755 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var delta1, v12, v18, v24 int32
	var tokenPtr, v10, v11, v13, v14, v15, v16, v17, v19, v20, v21, v22, v23, v25, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = delta1, tokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v8, v9
	switch (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords {
	case int64(1):
		goto _1
	case int64(2):
		goto _2
	default:
		goto _3
	}
	goto _4
_1:
	;
	/*
	 * No args
	 */
_7:
	;
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v9 = envPtr2 + 152
	v8 = *(*uintptr)(unsafe.Pointer(v9))
	*(*uintptr)(unsafe.Pointer(v9))++
	*(*uint8)(unsafe.Pointer(v8)) = libc.Uint8FromInt32(int32(INST_CLOCK_READ))
	v11 = envPtr2 + 152
	v10 = *(*uintptr)(unsafe.Pointer(v11))
	*(*uintptr)(unsafe.Pointer(v11))++
	*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_CLOCK_READ)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v12 = delta1
		v13 = envPtr2
		if v12 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v13)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v13)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v13)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v13)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v13 + 64)) += int64(v12)
	}
	goto _6
_6:
	;
	if 0 != 0 {
		goto _7
	}
	goto _5
_5:
	;
	goto _4
_2:
	;
	/*
	 * -milliseconds or -microseconds
	 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) || (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize < int64(4) || (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize > int64(13) {
		return int32(TCL_ERROR)
	} else {
		if !(libc.Xstrncmp(tls, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, __ccgo_ts+13217, libc.Uint64FromInt64((*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize)) != 0) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v15 = envPtr2 + 152
			v14 = *(*uintptr)(unsafe.Pointer(v15))
			*(*uintptr)(unsafe.Pointer(v15))++
			*(*uint8)(unsafe.Pointer(v14)) = libc.Uint8FromInt32(int32(INST_CLOCK_READ))
			v17 = envPtr2 + 152
			v16 = *(*uintptr)(unsafe.Pointer(v17))
			*(*uintptr)(unsafe.Pointer(v17))++
			*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_CLOCK_READ)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - int32(1)
				}
				v18 = delta1
				v19 = envPtr2
				if v18 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v19 + 64)) += int64(v18)
			}
			goto _4
		} else {
			if !(libc.Xstrncmp(tls, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, __ccgo_ts+13203, libc.Uint64FromInt64((*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize)) != 0) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v21 = envPtr2 + 152
				v20 = *(*uintptr)(unsafe.Pointer(v21))
				*(*uintptr)(unsafe.Pointer(v21))++
				*(*uint8)(unsafe.Pointer(v20)) = libc.Uint8FromInt32(int32(INST_CLOCK_READ))
				v23 = envPtr2 + 152
				v22 = *(*uintptr)(unsafe.Pointer(v23))
				*(*uintptr)(unsafe.Pointer(v23))++
				*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_CLOCK_READ)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - int32(2)
					}
					v24 = delta1
					v25 = envPtr2
					if v24 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v25 + 64)) += int64(v24)
				}
				goto _4
			} else {
				return int32(TCL_ERROR)
			}
		}
	}
_3:
	;
	return int32(TCL_ERROR)
_4:
	;
	return TCL_OK
}

/*----------------------------------------------------------------------
 *
 * TclCompileClockReadingCmd --
 *
 *	Procedure called to compile the "tcl::clock::microseconds",
 *	"tcl::clock::milliseconds" and "tcl::clock::seconds" commands.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to run time.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "clock clicks"
 *	command at runtime.
 *
 * Client data is 1 for microseconds, 2 for milliseconds, 3 for seconds.
 *----------------------------------------------------------------------
 */

func XTclCompileClockReadingCmd(tls *libc.TLS, dummy814 uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var delta1, v5 int32
	var v1, v2, v3, v4, v6 uintptr
	_, _, _, _, _, _, _ = delta1, v1, v2, v3, v4, v5, v6
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(1) {
		return int32(TCL_ERROR)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v2 = envPtr2 + 152
	v1 = *(*uintptr)(unsafe.Pointer(v2))
	*(*uintptr)(unsafe.Pointer(v2))++
	*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_CLOCK_READ))
	v4 = envPtr2 + 152
	v3 = *(*uintptr)(unsafe.Pointer(v4))
	*(*uintptr)(unsafe.Pointer(v4))++
	*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt64(int64((*TCommand)(unsafe.Pointer(cmdPtr)).FobjClientData)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_CLOCK_READ)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32(int64((*TCommand)(unsafe.Pointer(cmdPtr)).FobjClientData))
		}
		v5 = delta1
		v6 = envPtr2
		if v5 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileConcatCmd --
 *
 *	Procedure called to compile the "concat" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "concat" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileConcatCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy853 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, delta1, i1, v17, v36, v48, v5, v57, v69, v81 int32
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, bytes, cachePtr, cachePtr1, listObj, mapPtr, objPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v2, v23, v25, v3, v30, v31, v32, v33, v34, v35, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v49, v51, v53, v54, v55, v56, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v82, v9 uintptr
	var eclIndex, v22, v24, v29, v50 TTcl_Size
	var v19, v21 bool
	var v27, v28 int64
	var _ /* len at bp+8 */ TTcl_Size
	var _ /* objs at bp+0 */ uintptr
	var _ /* slen at bp+16 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objPtr, _objPtr1, _objPtr2, _objPtr3, bytes, cachePtr, cachePtr1, delta1, eclIndex, i1, listObj, mapPtr, objPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v21, v22, v23, v24, v25, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	/* TODO: Consider compiling expansion case. */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(1) {
		/*
		 * [concat] without arguments just pushes an empty object.
		 */
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
		return TCL_OK
	}
	/*
	 * Test if all arguments are compile-time known. If they are, we can
	 * implement with a simple push.
	 */
	if v19 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v19 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v19 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		listObj = XTclThreadAllocObj(tls)
	} else {
		listObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(listObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(listObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(listObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr = libc.UintptrFromInt32(0)
	i1 = int32(1)
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
	for {
		if !(i1 < int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)) {
			break
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if v21 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v21 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v21 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			objPtr = XTclThreadAllocObj(tls)
		} else {
			objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
		if !(XTclWordKnownAtCompileTime(tls, tokenPtr, objPtr) != 0) {
			_objPtr = objPtr
			v23 = _objPtr
			v22 = *(*TTcl_Size)(unsafe.Pointer(v23))
			*(*TTcl_Size)(unsafe.Pointer(v23))--
			if v22 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			_objPtr1 = listObj
			v25 = _objPtr1
			v24 = *(*TTcl_Size)(unsafe.Pointer(v25))
			*(*TTcl_Size)(unsafe.Pointer(v25))--
			if v24 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
			listObj = libc.UintptrFromInt32(0)
			break
		}
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listObj, objPtr)
		goto _20
	_20:
		;
		i1++
	}
	if listObj != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr2 != 0 {
				v27 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr2)).FspanStart
			} else {
				v27 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr1 + 40 + uintptr(v27)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr2 != 0 {
				v28 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr2)).FspanLength
			} else {
				v28 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v28
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), listObj, bp+8, bp)
		}
		objPtr = XTcl_ConcatObj(tls, *(*TTcl_Size)(unsafe.Pointer(bp + 8)), *(*uintptr)(unsafe.Pointer(bp)))
		_objPtr2 = listObj
		v30 = _objPtr2
		v29 = *(*TTcl_Size)(unsafe.Pointer(v30))
		*(*TTcl_Size)(unsafe.Pointer(v30))--
		if v29 <= int64(1) {
			XTclFreeObj(tls, _objPtr2)
		}
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
			v31 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		} else {
			v31 = XTcl_GetStringFromObj(tls, objPtr, bp+16)
		}
		bytes = v31
		_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, bytes, *(*TTcl_Size)(unsafe.Pointer(bp + 16)), 0)
		if _objIndexCopy1 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v33 = envPtr2 + 152
			v32 = *(*uintptr)(unsafe.Pointer(v33))
			*(*uintptr)(unsafe.Pointer(v33))++
			*(*uint8)(unsafe.Pointer(v32)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v35 = envPtr2 + 152
			v34 = *(*uintptr)(unsafe.Pointer(v35))
			*(*uintptr)(unsafe.Pointer(v35))++
			*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v36 = delta1
				v37 = envPtr2
				if v36 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v37 + 64)) += int64(v36)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v39 = envPtr2 + 152
			v38 = *(*uintptr)(unsafe.Pointer(v39))
			*(*uintptr)(unsafe.Pointer(v39))++
			*(*uint8)(unsafe.Pointer(v38)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v41 = envPtr2 + 152
			v40 = *(*uintptr)(unsafe.Pointer(v41))
			*(*uintptr)(unsafe.Pointer(v41))++
			*(*uint8)(unsafe.Pointer(v40)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
			v43 = envPtr2 + 152
			v42 = *(*uintptr)(unsafe.Pointer(v43))
			*(*uintptr)(unsafe.Pointer(v43))++
			*(*uint8)(unsafe.Pointer(v42)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
			v45 = envPtr2 + 152
			v44 = *(*uintptr)(unsafe.Pointer(v45))
			*(*uintptr)(unsafe.Pointer(v45))++
			*(*uint8)(unsafe.Pointer(v44)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
			v47 = envPtr2 + 152
			v46 = *(*uintptr)(unsafe.Pointer(v47))
			*(*uintptr)(unsafe.Pointer(v47))++
			*(*uint8)(unsafe.Pointer(v46)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v48 = delta1
				v49 = envPtr2
				if v48 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v49)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v49)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v49)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v49)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v49 + 64)) += int64(v48)
			}
		}
		_objPtr3 = objPtr
		v51 = _objPtr3
		v50 = *(*TTcl_Size)(unsafe.Pointer(v51))
		*(*TTcl_Size)(unsafe.Pointer(v51))--
		if v50 <= int64(1) {
			XTclFreeObj(tls, _objPtr3)
		}
		return TCL_OK
	}
	/*
	 * General case: runtime concat.
	 */
	i1 = int32(1)
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
	for {
		if !(i1 < int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)) {
			break
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy2 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v54 = envPtr2 + 152
				v53 = *(*uintptr)(unsafe.Pointer(v54))
				*(*uintptr)(unsafe.Pointer(v54))++
				*(*uint8)(unsafe.Pointer(v53)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v56 = envPtr2 + 152
				v55 = *(*uintptr)(unsafe.Pointer(v56))
				*(*uintptr)(unsafe.Pointer(v56))++
				*(*uint8)(unsafe.Pointer(v55)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy2
					}
					v57 = delta1
					v58 = envPtr2
					if v57 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v58)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v58)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v58)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v58)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v58 + 64)) += int64(v57)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v60 = envPtr2 + 152
				v59 = *(*uintptr)(unsafe.Pointer(v60))
				*(*uintptr)(unsafe.Pointer(v60))++
				*(*uint8)(unsafe.Pointer(v59)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v62 = envPtr2 + 152
				v61 = *(*uintptr)(unsafe.Pointer(v62))
				*(*uintptr)(unsafe.Pointer(v62))++
				*(*uint8)(unsafe.Pointer(v61)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
				v64 = envPtr2 + 152
				v63 = *(*uintptr)(unsafe.Pointer(v64))
				*(*uintptr)(unsafe.Pointer(v64))++
				*(*uint8)(unsafe.Pointer(v63)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
				v66 = envPtr2 + 152
				v65 = *(*uintptr)(unsafe.Pointer(v66))
				*(*uintptr)(unsafe.Pointer(v66))++
				*(*uint8)(unsafe.Pointer(v65)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
				v68 = envPtr2 + 152
				v67 = *(*uintptr)(unsafe.Pointer(v68))
				*(*uintptr)(unsafe.Pointer(v68))++
				*(*uint8)(unsafe.Pointer(v67)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy2
					}
					v69 = delta1
					v70 = envPtr2
					if v69 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v70 + 64)) += int64(v69)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
		}
		goto _52
	_52:
		;
		i1++
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v72 = envPtr2 + 152
	v71 = *(*uintptr)(unsafe.Pointer(v72))
	*(*uintptr)(unsafe.Pointer(v72))++
	*(*uint8)(unsafe.Pointer(v71)) = libc.Uint8FromInt32(int32(INST_CONCAT_STK))
	v74 = envPtr2 + 152
	v73 = *(*uintptr)(unsafe.Pointer(v74))
	*(*uintptr)(unsafe.Pointer(v74))++
	*(*uint8)(unsafe.Pointer(v73)) = uint8(libc.Uint32FromInt32(i1-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(24))
	v76 = envPtr2 + 152
	v75 = *(*uintptr)(unsafe.Pointer(v76))
	*(*uintptr)(unsafe.Pointer(v76))++
	*(*uint8)(unsafe.Pointer(v75)) = uint8(libc.Uint32FromInt32(i1-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(16))
	v78 = envPtr2 + 152
	v77 = *(*uintptr)(unsafe.Pointer(v78))
	*(*uintptr)(unsafe.Pointer(v78))++
	*(*uint8)(unsafe.Pointer(v77)) = uint8(libc.Uint32FromInt32(i1-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(8))
	v80 = envPtr2 + 152
	v79 = *(*uintptr)(unsafe.Pointer(v80))
	*(*uintptr)(unsafe.Pointer(v80))++
	*(*uint8)(unsafe.Pointer(v79)) = uint8(libc.Uint32FromInt32(i1 - libc.Int32FromInt32(1)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_CONCAT_STK)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - (i1 - int32(1))
		}
		v81 = delta1
		v82 = envPtr2
		if v81 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v82)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v82)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v82)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v82)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v82 + 64)) += int64(v81)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileConstCmd --
 *
 *	Procedure called to compile the "const" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "const" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileConstCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy939 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, delta1, v17, v21, v33, v39, v5, v51 int32
	var eclIndex TTcl_Size
	var mapPtr, valueTokenPtr, varTokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v34, v35, v36, v37, v38, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v52, v6, v7, v8, v9 uintptr
	var _ /* isScalar at bp+0 */ int32
	var _ /* localIndex at bp+4 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, delta1, eclIndex, mapPtr, valueTokenPtr, varTokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	/*
	 * Need exactly two arguments.
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(3) {
		return int32(TCL_ERROR)
	}
	/*
	 * Decide if we can use a frame slot for the var/array name or if we need
	 * to emit code to compute and push the name at runtime. We use a frame
	 * slot (entry in the array of local vars) if we are compiling a procedure
	 * body and if the name is simple text that does not include namespace
	 * qualifiers.
	 */
	varTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
	XTclPushVarName(tls, interp, varTokenPtr, envPtr2, 0, bp+4, bp)
	/*
	 * If the user specified an array element, we don't bother handling
	 * that.
	 */
	if !(*(*int32)(unsafe.Pointer(bp)) != 0) {
		return int32(TCL_ERROR)
	}
	/*
	 * We are doing an assignment to set the value of the constant. This will
	 * need to be extended to push a value for each argument.
	 */
	valueTokenPtr = varTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(valueTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(valueTokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
		XTclCompileTokens(tls, interp, valueTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).FnumComponents), envPtr2)
	}
	if *(*int32)(unsafe.Pointer(bp + 4)) < 0 {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v20 = envPtr2 + 152
		v19 = *(*uintptr)(unsafe.Pointer(v20))
		*(*uintptr)(unsafe.Pointer(v20))++
		*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_CONST_STK))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_CONST_STK)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v21 = delta1
			v22 = envPtr2
			if v21 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v22 + 64)) += int64(v21)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v24 = envPtr2 + 152
		v23 = *(*uintptr)(unsafe.Pointer(v24))
		*(*uintptr)(unsafe.Pointer(v24))++
		*(*uint8)(unsafe.Pointer(v23)) = libc.Uint8FromInt32(int32(INST_CONST_IMM))
		v26 = envPtr2 + 152
		v25 = *(*uintptr)(unsafe.Pointer(v26))
		*(*uintptr)(unsafe.Pointer(v26))++
		*(*uint8)(unsafe.Pointer(v25)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(24))
		v28 = envPtr2 + 152
		v27 = *(*uintptr)(unsafe.Pointer(v28))
		*(*uintptr)(unsafe.Pointer(v28))++
		*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(16))
		v30 = envPtr2 + 152
		v29 = *(*uintptr)(unsafe.Pointer(v30))
		*(*uintptr)(unsafe.Pointer(v30))++
		*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(8))
		v32 = envPtr2 + 152
		v31 = *(*uintptr)(unsafe.Pointer(v32))
		*(*uintptr)(unsafe.Pointer(v32))++
		*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_CONST_IMM)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
			}
			v33 = delta1
			v34 = envPtr2
			if v33 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v34)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v34)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v34)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v34)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v34 + 64)) += int64(v33)
		}
	}
	/*
	 * The const command's result is an empty string.
	 */
	_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy1 <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v36 = envPtr2 + 152
		v35 = *(*uintptr)(unsafe.Pointer(v36))
		*(*uintptr)(unsafe.Pointer(v36))++
		*(*uint8)(unsafe.Pointer(v35)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v38 = envPtr2 + 152
		v37 = *(*uintptr)(unsafe.Pointer(v38))
		*(*uintptr)(unsafe.Pointer(v38))++
		*(*uint8)(unsafe.Pointer(v37)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy1
			}
			v39 = delta1
			v40 = envPtr2
			if v39 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v40 + 64)) += int64(v39)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v42 = envPtr2 + 152
		v41 = *(*uintptr)(unsafe.Pointer(v42))
		*(*uintptr)(unsafe.Pointer(v42))++
		*(*uint8)(unsafe.Pointer(v41)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v44 = envPtr2 + 152
		v43 = *(*uintptr)(unsafe.Pointer(v44))
		*(*uintptr)(unsafe.Pointer(v44))++
		*(*uint8)(unsafe.Pointer(v43)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
		v46 = envPtr2 + 152
		v45 = *(*uintptr)(unsafe.Pointer(v46))
		*(*uintptr)(unsafe.Pointer(v46))++
		*(*uint8)(unsafe.Pointer(v45)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
		v48 = envPtr2 + 152
		v47 = *(*uintptr)(unsafe.Pointer(v48))
		*(*uintptr)(unsafe.Pointer(v48))++
		*(*uint8)(unsafe.Pointer(v47)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
		v50 = envPtr2 + 152
		v49 = *(*uintptr)(unsafe.Pointer(v50))
		*(*uintptr)(unsafe.Pointer(v50))++
		*(*uint8)(unsafe.Pointer(v49)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy1
			}
			v51 = delta1
			v52 = envPtr2
			if v51 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v52)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v52)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v52)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v52)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v52 + 64)) += int64(v51)
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileContinueCmd --
 *
 *	Procedure called to compile the "continue" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "continue" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileContinueCmd(tls *libc.TLS, dummy1014 uintptr, parsePtr uintptr, dummy1017 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds resulting instructions. */
	var delta1, v3, v5 int32
	var rangePtr, v1, v2, v4, v6 uintptr
	var _ /* auxPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _ = delta1, rangePtr, v1, v2, v3, v4, v5, v6
	/*
	 * There should be no argument after the "continue".
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(1) {
		return int32(TCL_ERROR)
	}
	/*
	 * See if we can find a valid continueOffset (i.e., not -1) in the
	 * innermost containing exception range.
	 */
	rangePtr = XTclGetInnermostExceptionRange(tls, envPtr2, int32(TCL_CONTINUE), bp)
	if rangePtr != 0 && (*TExceptionRange)(unsafe.Pointer(rangePtr)).Ftype1 == int32(LOOP_EXCEPTION_RANGE) {
		/*
		 * Found the target! No need for a nasty INST_CONTINUE here.
		 */
		XTclCleanupStackForBreakContinue(tls, envPtr2, *(*uintptr)(unsafe.Pointer(bp)))
		XTclAddLoopContinueFixup(tls, envPtr2, *(*uintptr)(unsafe.Pointer(bp)))
	} else {
		/*
		 * Emit a real continue.
		 */
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v2 = envPtr2 + 152
		v1 = *(*uintptr)(unsafe.Pointer(v2))
		*(*uintptr)(unsafe.Pointer(v2))++
		*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_CONTINUE))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_CONTINUE)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v3 = delta1
			v4 = envPtr2
			if v3 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v4)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v4)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v4)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v4)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v4 + 64)) += int64(v3)
		}
	}
	v5 = int32(1)
	v6 = envPtr2
	if v5 < libc.Int32FromInt32(0) {
		if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
			(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
		}
	}
	*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileDict*Cmd --
 *
 *	Functions called to compile "dict" subcommands.
 *
 * Results:
 *	All return TCL_OK for a successful compile, and TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "dict" subcommand at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileDictSetCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy1079 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, delta1, dictVarIndex, i1, v18, v30, v40, v6 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, varTokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v41, v5, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, dictVarIndex, eclIndex, i1, mapPtr, tokenPtr, varTokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	/*
	 * There must be at least one argument after the command.
	 */
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) < int32(4) {
		return int32(TCL_ERROR)
	}
	/*
	 * The dictionary variable must be a local scalar that is knowable at
	 * compile time; anything else exceeds the complexity of the opcode. So
	 * discover what the index is.
	 */
	varTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	dictVarIndex = libc.Int32FromUint64(XTclLocalScalarFromToken(tls, varTokenPtr, envPtr2))
	if dictVarIndex < 0 {
		return int32(TCL_ERROR)
	}
	/*
	 * Remaining words (key path and value to set) can be handled normally.
	 */
	tokenPtr = varTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	i1 = int32(2)
	for {
		if !(i1 < int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)) {
			break
		}
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v3 = envPtr2 + 152
				v2 = *(*uintptr)(unsafe.Pointer(v3))
				*(*uintptr)(unsafe.Pointer(v3))++
				*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v5 = envPtr2 + 152
				v4 = *(*uintptr)(unsafe.Pointer(v5))
				*(*uintptr)(unsafe.Pointer(v5))++
				*(*uint8)(unsafe.Pointer(v4)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v6 = delta1
					v7 = envPtr2
					if v6 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v7 + 64)) += int64(v6)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v9 = envPtr2 + 152
				v8 = *(*uintptr)(unsafe.Pointer(v9))
				*(*uintptr)(unsafe.Pointer(v9))++
				*(*uint8)(unsafe.Pointer(v8)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v11 = envPtr2 + 152
				v10 = *(*uintptr)(unsafe.Pointer(v11))
				*(*uintptr)(unsafe.Pointer(v11))++
				*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
				v13 = envPtr2 + 152
				v12 = *(*uintptr)(unsafe.Pointer(v13))
				*(*uintptr)(unsafe.Pointer(v13))++
				*(*uint8)(unsafe.Pointer(v12)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
				v15 = envPtr2 + 152
				v14 = *(*uintptr)(unsafe.Pointer(v15))
				*(*uintptr)(unsafe.Pointer(v15))++
				*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
				v17 = envPtr2 + 152
				v16 = *(*uintptr)(unsafe.Pointer(v17))
				*(*uintptr)(unsafe.Pointer(v17))++
				*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v18 = delta1
					v19 = envPtr2
					if v18 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v19 + 64)) += int64(v18)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		goto _1
	_1:
		;
		i1++
	}
	/*
	 * Now emit the instruction to do the dict manipulation.
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v21 = envPtr2 + 152
	v20 = *(*uintptr)(unsafe.Pointer(v21))
	*(*uintptr)(unsafe.Pointer(v21))++
	*(*uint8)(unsafe.Pointer(v20)) = libc.Uint8FromInt32(int32(INST_DICT_SET))
	v23 = envPtr2 + 152
	v22 = *(*uintptr)(unsafe.Pointer(v23))
	*(*uintptr)(unsafe.Pointer(v23))++
	*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(3)) >> libc.Int32FromInt32(24))
	v25 = envPtr2 + 152
	v24 = *(*uintptr)(unsafe.Pointer(v25))
	*(*uintptr)(unsafe.Pointer(v25))++
	*(*uint8)(unsafe.Pointer(v24)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(3)) >> libc.Int32FromInt32(16))
	v27 = envPtr2 + 152
	v26 = *(*uintptr)(unsafe.Pointer(v27))
	*(*uintptr)(unsafe.Pointer(v27))++
	*(*uint8)(unsafe.Pointer(v26)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(3)) >> libc.Int32FromInt32(8))
	v29 = envPtr2 + 152
	v28 = *(*uintptr)(unsafe.Pointer(v29))
	*(*uintptr)(unsafe.Pointer(v29))++
	*(*uint8)(unsafe.Pointer(v28)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) - libc.Int32FromInt32(3)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_DICT_SET)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - (int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) - int32(3))
		}
		v30 = delta1
		v31 = envPtr2
		if v30 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v31)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v31)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v31)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v31)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v31 + 64)) += int64(v30)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v33 = envPtr2 + 152
	v32 = *(*uintptr)(unsafe.Pointer(v33))
	*(*uintptr)(unsafe.Pointer(v33))++
	*(*uint8)(unsafe.Pointer(v32)) = uint8(libc.Uint32FromInt32(dictVarIndex) >> libc.Int32FromInt32(24))
	v35 = envPtr2 + 152
	v34 = *(*uintptr)(unsafe.Pointer(v35))
	*(*uintptr)(unsafe.Pointer(v35))++
	*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt32(dictVarIndex) >> libc.Int32FromInt32(16))
	v37 = envPtr2 + 152
	v36 = *(*uintptr)(unsafe.Pointer(v37))
	*(*uintptr)(unsafe.Pointer(v37))++
	*(*uint8)(unsafe.Pointer(v36)) = uint8(libc.Uint32FromInt32(dictVarIndex) >> libc.Int32FromInt32(8))
	v39 = envPtr2 + 152
	v38 = *(*uintptr)(unsafe.Pointer(v39))
	*(*uintptr)(unsafe.Pointer(v39))++
	*(*uint8)(unsafe.Pointer(v38)) = uint8(libc.Uint32FromInt32(dictVarIndex))
	v40 = -int32(1)
	v41 = envPtr2
	if v40 < libc.Int32FromInt32(0) {
		if int32((*TCompileEnv)(unsafe.Pointer(v41)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v41)).FcurrStackDepth) {
			(*TCompileEnv)(unsafe.Pointer(v41)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v41)).FcurrStackDepth
		}
	}
	*(*TTcl_Size)(unsafe.Pointer(v41 + 64)) += int64(v40)
	return TCL_OK
}

func XTclCompileDictIncrCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds resulting instructions. */
	var _objIndexCopy, code, delta1, dictVarIndex, v1, v21, v33, v9 int32
	var cachePtr, incrTokenPtr, intObj, keyTokenPtr, mapPtr, varTokenPtr, word, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v34, v35, v36, v37, v38, v39, v40, v41, v42, v5, v6, v7, v8 uintptr
	var eclIndex, numBytes, v2 TTcl_Size
	var v4 bool
	var _ /* incrAmount at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, cachePtr, code, delta1, dictVarIndex, eclIndex, incrTokenPtr, intObj, keyTokenPtr, mapPtr, numBytes, varTokenPtr, word, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	/*
	 * There must be at least two arguments after the command.
	 */
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) < int32(3) || int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) > int32(4) {
		return int32(TCL_ERROR)
	}
	varTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	keyTokenPtr = varTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	/*
	 * Parse the increment amount, if present.
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(4) {
		incrTokenPtr = keyTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(keyTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if (*TTcl_Token)(unsafe.Pointer(incrTokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) {
			return XTclCompileBasic2Or3ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
		}
		word = (*(*TTcl_Token)(unsafe.Pointer(incrTokenPtr + 1*32))).Fstart
		numBytes = (*(*TTcl_Token)(unsafe.Pointer(incrTokenPtr + 1*32))).Fsize
		intObj = XTcl_NewStringObj(tls, word, numBytes)
		(*TTcl_Obj)(unsafe.Pointer(intObj)).FrefCount++
		if (*TTcl_Obj)(unsafe.Pointer(intObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(intObj)).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(intObj)).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
			*(*int32)(unsafe.Pointer(bp)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(intObj)).FinternalRep)))
			v1 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1 = XTcl_GetIntFromObj(tls, libc.UintptrFromInt32(0), intObj, bp)
		}
		code = v1
		v3 = intObj
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if !(v2 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(intObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(intObj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(intObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(intObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(intObj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(intObj)).Flength = int64(-libc.Int32FromInt32(1))
				if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v4 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, intObj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(intObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = intObj
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, intObj)
			}
		}
		if code != TCL_OK {
			return XTclCompileBasic2Or3ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
		}
	} else {
		*(*int32)(unsafe.Pointer(bp)) = int32(1)
	}
	/*
	 * The dictionary variable must be a local scalar that is knowable at
	 * compile time; anything else exceeds the complexity of the opcode. So
	 * discover what the index is.
	 */
	dictVarIndex = libc.Int32FromUint64(XTclLocalScalarFromToken(tls, varTokenPtr, envPtr2))
	if dictVarIndex < 0 {
		return XTclCompileBasic2Or3ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
	}
	/*
	 * Emit the key and the code to actually do the increment.
	 */
	if (*TTcl_Token)(unsafe.Pointer(keyTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(keyTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(keyTokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v6 = envPtr2 + 152
			v5 = *(*uintptr)(unsafe.Pointer(v6))
			*(*uintptr)(unsafe.Pointer(v6))++
			*(*uint8)(unsafe.Pointer(v5)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v9 = delta1
				v10 = envPtr2
				if v9 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v10)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v10)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v10)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v10)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v10 + 64)) += int64(v9)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v18 = envPtr2 + 152
			v17 = *(*uintptr)(unsafe.Pointer(v18))
			*(*uintptr)(unsafe.Pointer(v18))++
			*(*uint8)(unsafe.Pointer(v17)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v20 = envPtr2 + 152
			v19 = *(*uintptr)(unsafe.Pointer(v20))
			*(*uintptr)(unsafe.Pointer(v20))++
			*(*uint8)(unsafe.Pointer(v19)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v21 = delta1
				v22 = envPtr2
				if v21 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v22 + 64)) += int64(v21)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
		XTclCompileTokens(tls, interp, keyTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(keyTokenPtr)).FnumComponents), envPtr2)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v24 = envPtr2 + 152
	v23 = *(*uintptr)(unsafe.Pointer(v24))
	*(*uintptr)(unsafe.Pointer(v24))++
	*(*uint8)(unsafe.Pointer(v23)) = libc.Uint8FromInt32(int32(INST_DICT_INCR_IMM))
	v26 = envPtr2 + 152
	v25 = *(*uintptr)(unsafe.Pointer(v26))
	*(*uintptr)(unsafe.Pointer(v26))++
	*(*uint8)(unsafe.Pointer(v25)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))) >> libc.Int32FromInt32(24))
	v28 = envPtr2 + 152
	v27 = *(*uintptr)(unsafe.Pointer(v28))
	*(*uintptr)(unsafe.Pointer(v28))++
	*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))) >> libc.Int32FromInt32(16))
	v30 = envPtr2 + 152
	v29 = *(*uintptr)(unsafe.Pointer(v30))
	*(*uintptr)(unsafe.Pointer(v30))++
	*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))) >> libc.Int32FromInt32(8))
	v32 = envPtr2 + 152
	v31 = *(*uintptr)(unsafe.Pointer(v32))
	*(*uintptr)(unsafe.Pointer(v32))++
	*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_DICT_INCR_IMM)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp))
		}
		v33 = delta1
		v34 = envPtr2
		if v33 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v34)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v34)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v34)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v34)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v34 + 64)) += int64(v33)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v36 = envPtr2 + 152
	v35 = *(*uintptr)(unsafe.Pointer(v36))
	*(*uintptr)(unsafe.Pointer(v36))++
	*(*uint8)(unsafe.Pointer(v35)) = uint8(libc.Uint32FromInt32(dictVarIndex) >> libc.Int32FromInt32(24))
	v38 = envPtr2 + 152
	v37 = *(*uintptr)(unsafe.Pointer(v38))
	*(*uintptr)(unsafe.Pointer(v38))++
	*(*uint8)(unsafe.Pointer(v37)) = uint8(libc.Uint32FromInt32(dictVarIndex) >> libc.Int32FromInt32(16))
	v40 = envPtr2 + 152
	v39 = *(*uintptr)(unsafe.Pointer(v40))
	*(*uintptr)(unsafe.Pointer(v40))++
	*(*uint8)(unsafe.Pointer(v39)) = uint8(libc.Uint32FromInt32(dictVarIndex) >> libc.Int32FromInt32(8))
	v42 = envPtr2 + 152
	v41 = *(*uintptr)(unsafe.Pointer(v42))
	*(*uintptr)(unsafe.Pointer(v42))++
	*(*uint8)(unsafe.Pointer(v41)) = uint8(libc.Uint32FromInt32(dictVarIndex))
	return TCL_OK
}

func XTclCompileDictGetCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy1205 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, delta1, i1, v18, v30, v32, v6 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v31, v33, v4, v5, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, eclIndex, i1, mapPtr, tokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v4, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	/*
	 * There must be at least two arguments after the command (the single-arg
	 * case is legal, but too special and magic for us to deal with here).
	 */
	/* TODO: Consider support for compiling expanded args. */
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) < int32(3) {
		return int32(TCL_ERROR)
	}
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	/*
	 * Only compile this because we need INST_DICT_GET anyway.
	 */
	i1 = int32(1)
	for {
		if !(i1 < int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)) {
			break
		}
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v3 = envPtr2 + 152
				v2 = *(*uintptr)(unsafe.Pointer(v3))
				*(*uintptr)(unsafe.Pointer(v3))++
				*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v5 = envPtr2 + 152
				v4 = *(*uintptr)(unsafe.Pointer(v5))
				*(*uintptr)(unsafe.Pointer(v5))++
				*(*uint8)(unsafe.Pointer(v4)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v6 = delta1
					v7 = envPtr2
					if v6 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v7 + 64)) += int64(v6)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v9 = envPtr2 + 152
				v8 = *(*uintptr)(unsafe.Pointer(v9))
				*(*uintptr)(unsafe.Pointer(v9))++
				*(*uint8)(unsafe.Pointer(v8)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v11 = envPtr2 + 152
				v10 = *(*uintptr)(unsafe.Pointer(v11))
				*(*uintptr)(unsafe.Pointer(v11))++
				*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
				v13 = envPtr2 + 152
				v12 = *(*uintptr)(unsafe.Pointer(v13))
				*(*uintptr)(unsafe.Pointer(v13))++
				*(*uint8)(unsafe.Pointer(v12)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
				v15 = envPtr2 + 152
				v14 = *(*uintptr)(unsafe.Pointer(v15))
				*(*uintptr)(unsafe.Pointer(v15))++
				*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
				v17 = envPtr2 + 152
				v16 = *(*uintptr)(unsafe.Pointer(v17))
				*(*uintptr)(unsafe.Pointer(v17))++
				*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v18 = delta1
					v19 = envPtr2
					if v18 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v19 + 64)) += int64(v18)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		goto _1
	_1:
		;
		i1++
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v21 = envPtr2 + 152
	v20 = *(*uintptr)(unsafe.Pointer(v21))
	*(*uintptr)(unsafe.Pointer(v21))++
	*(*uint8)(unsafe.Pointer(v20)) = libc.Uint8FromInt32(int32(INST_DICT_GET))
	v23 = envPtr2 + 152
	v22 = *(*uintptr)(unsafe.Pointer(v23))
	*(*uintptr)(unsafe.Pointer(v23))++
	*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
	v25 = envPtr2 + 152
	v24 = *(*uintptr)(unsafe.Pointer(v25))
	*(*uintptr)(unsafe.Pointer(v25))++
	*(*uint8)(unsafe.Pointer(v24)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
	v27 = envPtr2 + 152
	v26 = *(*uintptr)(unsafe.Pointer(v27))
	*(*uintptr)(unsafe.Pointer(v27))++
	*(*uint8)(unsafe.Pointer(v26)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
	v29 = envPtr2 + 152
	v28 = *(*uintptr)(unsafe.Pointer(v29))
	*(*uintptr)(unsafe.Pointer(v29))++
	*(*uint8)(unsafe.Pointer(v28)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) - libc.Int32FromInt32(2)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_DICT_GET)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - (int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) - int32(2))
		}
		v30 = delta1
		v31 = envPtr2
		if v30 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v31)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v31)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v31)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v31)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v31 + 64)) += int64(v30)
	}
	v32 = -int32(1)
	v33 = envPtr2
	if v32 < libc.Int32FromInt32(0) {
		if int32((*TCompileEnv)(unsafe.Pointer(v33)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v33)).FcurrStackDepth) {
			(*TCompileEnv)(unsafe.Pointer(v33)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v33)).FcurrStackDepth
		}
	}
	*(*TTcl_Size)(unsafe.Pointer(v33 + 64)) += int64(v32)
	return TCL_OK
}

func XTclCompileDictGetWithDefaultCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy1241 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, delta1, i1, v18, v30, v32, v6 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v31, v33, v4, v5, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, eclIndex, i1, mapPtr, tokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v4, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	/*
	 * There must be at least three arguments after the command.
	 */
	/* TODO: Consider support for compiling expanded args. */
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) < int32(4) {
		return int32(TCL_ERROR)
	}
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	i1 = int32(1)
	for {
		if !(i1 < int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)) {
			break
		}
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v3 = envPtr2 + 152
				v2 = *(*uintptr)(unsafe.Pointer(v3))
				*(*uintptr)(unsafe.Pointer(v3))++
				*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v5 = envPtr2 + 152
				v4 = *(*uintptr)(unsafe.Pointer(v5))
				*(*uintptr)(unsafe.Pointer(v5))++
				*(*uint8)(unsafe.Pointer(v4)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v6 = delta1
					v7 = envPtr2
					if v6 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v7 + 64)) += int64(v6)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v9 = envPtr2 + 152
				v8 = *(*uintptr)(unsafe.Pointer(v9))
				*(*uintptr)(unsafe.Pointer(v9))++
				*(*uint8)(unsafe.Pointer(v8)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v11 = envPtr2 + 152
				v10 = *(*uintptr)(unsafe.Pointer(v11))
				*(*uintptr)(unsafe.Pointer(v11))++
				*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
				v13 = envPtr2 + 152
				v12 = *(*uintptr)(unsafe.Pointer(v13))
				*(*uintptr)(unsafe.Pointer(v13))++
				*(*uint8)(unsafe.Pointer(v12)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
				v15 = envPtr2 + 152
				v14 = *(*uintptr)(unsafe.Pointer(v15))
				*(*uintptr)(unsafe.Pointer(v15))++
				*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
				v17 = envPtr2 + 152
				v16 = *(*uintptr)(unsafe.Pointer(v17))
				*(*uintptr)(unsafe.Pointer(v17))++
				*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v18 = delta1
					v19 = envPtr2
					if v18 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v19 + 64)) += int64(v18)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		goto _1
	_1:
		;
		i1++
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v21 = envPtr2 + 152
	v20 = *(*uintptr)(unsafe.Pointer(v21))
	*(*uintptr)(unsafe.Pointer(v21))++
	*(*uint8)(unsafe.Pointer(v20)) = libc.Uint8FromInt32(int32(INST_DICT_GET_DEF))
	v23 = envPtr2 + 152
	v22 = *(*uintptr)(unsafe.Pointer(v23))
	*(*uintptr)(unsafe.Pointer(v23))++
	*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(3)) >> libc.Int32FromInt32(24))
	v25 = envPtr2 + 152
	v24 = *(*uintptr)(unsafe.Pointer(v25))
	*(*uintptr)(unsafe.Pointer(v25))++
	*(*uint8)(unsafe.Pointer(v24)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(3)) >> libc.Int32FromInt32(16))
	v27 = envPtr2 + 152
	v26 = *(*uintptr)(unsafe.Pointer(v27))
	*(*uintptr)(unsafe.Pointer(v27))++
	*(*uint8)(unsafe.Pointer(v26)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(3)) >> libc.Int32FromInt32(8))
	v29 = envPtr2 + 152
	v28 = *(*uintptr)(unsafe.Pointer(v29))
	*(*uintptr)(unsafe.Pointer(v29))++
	*(*uint8)(unsafe.Pointer(v28)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) - libc.Int32FromInt32(3)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_DICT_GET_DEF)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - (int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) - int32(3))
		}
		v30 = delta1
		v31 = envPtr2
		if v30 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v31)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v31)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v31)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v31)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v31 + 64)) += int64(v30)
	}
	v32 = -int32(2)
	v33 = envPtr2
	if v32 < libc.Int32FromInt32(0) {
		if int32((*TCompileEnv)(unsafe.Pointer(v33)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v33)).FcurrStackDepth) {
			(*TCompileEnv)(unsafe.Pointer(v33)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v33)).FcurrStackDepth
		}
	}
	*(*TTcl_Size)(unsafe.Pointer(v33 + 64)) += int64(v32)
	return TCL_OK
}

func XTclCompileDictExistsCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy1272 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, delta1, i1, v18, v30, v32, v6 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v31, v33, v4, v5, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, eclIndex, i1, mapPtr, tokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v4, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	/*
	 * There must be at least two arguments after the command (the single-arg
	 * case is legal, but too special and magic for us to deal with here).
	 */
	/* TODO: Consider support for compiling expanded args. */
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) < int32(3) {
		return int32(TCL_ERROR)
	}
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	/*
	 * Now we do the code generation.
	 */
	i1 = int32(1)
	for {
		if !(i1 < int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)) {
			break
		}
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v3 = envPtr2 + 152
				v2 = *(*uintptr)(unsafe.Pointer(v3))
				*(*uintptr)(unsafe.Pointer(v3))++
				*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v5 = envPtr2 + 152
				v4 = *(*uintptr)(unsafe.Pointer(v5))
				*(*uintptr)(unsafe.Pointer(v5))++
				*(*uint8)(unsafe.Pointer(v4)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v6 = delta1
					v7 = envPtr2
					if v6 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v7 + 64)) += int64(v6)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v9 = envPtr2 + 152
				v8 = *(*uintptr)(unsafe.Pointer(v9))
				*(*uintptr)(unsafe.Pointer(v9))++
				*(*uint8)(unsafe.Pointer(v8)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v11 = envPtr2 + 152
				v10 = *(*uintptr)(unsafe.Pointer(v11))
				*(*uintptr)(unsafe.Pointer(v11))++
				*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
				v13 = envPtr2 + 152
				v12 = *(*uintptr)(unsafe.Pointer(v13))
				*(*uintptr)(unsafe.Pointer(v13))++
				*(*uint8)(unsafe.Pointer(v12)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
				v15 = envPtr2 + 152
				v14 = *(*uintptr)(unsafe.Pointer(v15))
				*(*uintptr)(unsafe.Pointer(v15))++
				*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
				v17 = envPtr2 + 152
				v16 = *(*uintptr)(unsafe.Pointer(v17))
				*(*uintptr)(unsafe.Pointer(v17))++
				*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v18 = delta1
					v19 = envPtr2
					if v18 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v19 + 64)) += int64(v18)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		goto _1
	_1:
		;
		i1++
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v21 = envPtr2 + 152
	v20 = *(*uintptr)(unsafe.Pointer(v21))
	*(*uintptr)(unsafe.Pointer(v21))++
	*(*uint8)(unsafe.Pointer(v20)) = libc.Uint8FromInt32(int32(INST_DICT_EXISTS))
	v23 = envPtr2 + 152
	v22 = *(*uintptr)(unsafe.Pointer(v23))
	*(*uintptr)(unsafe.Pointer(v23))++
	*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
	v25 = envPtr2 + 152
	v24 = *(*uintptr)(unsafe.Pointer(v25))
	*(*uintptr)(unsafe.Pointer(v25))++
	*(*uint8)(unsafe.Pointer(v24)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
	v27 = envPtr2 + 152
	v26 = *(*uintptr)(unsafe.Pointer(v27))
	*(*uintptr)(unsafe.Pointer(v27))++
	*(*uint8)(unsafe.Pointer(v26)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
	v29 = envPtr2 + 152
	v28 = *(*uintptr)(unsafe.Pointer(v29))
	*(*uintptr)(unsafe.Pointer(v29))++
	*(*uint8)(unsafe.Pointer(v28)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) - libc.Int32FromInt32(2)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_DICT_EXISTS)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - (int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) - int32(2))
		}
		v30 = delta1
		v31 = envPtr2
		if v30 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v31)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v31)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v31)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v31)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v31 + 64)) += int64(v30)
	}
	v32 = -int32(1)
	v33 = envPtr2
	if v32 < libc.Int32FromInt32(0) {
		if int32((*TCompileEnv)(unsafe.Pointer(v33)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v33)).FcurrStackDepth) {
			(*TCompileEnv)(unsafe.Pointer(v33)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v33)).FcurrStackDepth
		}
	}
	*(*TTcl_Size)(unsafe.Pointer(v33 + 64)) += int64(v32)
	return TCL_OK
}

func XTclCompileDictUnsetCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, delta1, dictVarIndex, i1, v18, v30, v6 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v5, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, dictVarIndex, eclIndex, i1, mapPtr, tokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	/*
	 * There must be at least one argument after the variable name for us to
	 * compile to bytecode.
	 */
	/* TODO: Consider support for compiling expanded args. */
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) < int32(3) {
		return int32(TCL_ERROR)
	}
	/*
	 * The dictionary variable must be a local scalar that is knowable at
	 * compile time; anything else exceeds the complexity of the opcode. So
	 * discover what the index is.
	 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	dictVarIndex = libc.Int32FromUint64(XTclLocalScalarFromToken(tls, tokenPtr, envPtr2))
	if dictVarIndex < 0 {
		return XTclCompileBasicMin2ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
	}
	/*
	 * Remaining words (the key path) can be handled normally.
	 */
	i1 = int32(2)
	for {
		if !(i1 < int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)) {
			break
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v3 = envPtr2 + 152
				v2 = *(*uintptr)(unsafe.Pointer(v3))
				*(*uintptr)(unsafe.Pointer(v3))++
				*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v5 = envPtr2 + 152
				v4 = *(*uintptr)(unsafe.Pointer(v5))
				*(*uintptr)(unsafe.Pointer(v5))++
				*(*uint8)(unsafe.Pointer(v4)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v6 = delta1
					v7 = envPtr2
					if v6 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v7 + 64)) += int64(v6)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v9 = envPtr2 + 152
				v8 = *(*uintptr)(unsafe.Pointer(v9))
				*(*uintptr)(unsafe.Pointer(v9))++
				*(*uint8)(unsafe.Pointer(v8)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v11 = envPtr2 + 152
				v10 = *(*uintptr)(unsafe.Pointer(v11))
				*(*uintptr)(unsafe.Pointer(v11))++
				*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
				v13 = envPtr2 + 152
				v12 = *(*uintptr)(unsafe.Pointer(v13))
				*(*uintptr)(unsafe.Pointer(v13))++
				*(*uint8)(unsafe.Pointer(v12)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
				v15 = envPtr2 + 152
				v14 = *(*uintptr)(unsafe.Pointer(v15))
				*(*uintptr)(unsafe.Pointer(v15))++
				*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
				v17 = envPtr2 + 152
				v16 = *(*uintptr)(unsafe.Pointer(v17))
				*(*uintptr)(unsafe.Pointer(v17))++
				*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v18 = delta1
					v19 = envPtr2
					if v18 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v19 + 64)) += int64(v18)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
		}
		goto _1
	_1:
		;
		i1++
	}
	/*
	 * Now emit the instruction to do the dict manipulation.
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v21 = envPtr2 + 152
	v20 = *(*uintptr)(unsafe.Pointer(v21))
	*(*uintptr)(unsafe.Pointer(v21))++
	*(*uint8)(unsafe.Pointer(v20)) = libc.Uint8FromInt32(int32(INST_DICT_UNSET))
	v23 = envPtr2 + 152
	v22 = *(*uintptr)(unsafe.Pointer(v23))
	*(*uintptr)(unsafe.Pointer(v23))++
	*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
	v25 = envPtr2 + 152
	v24 = *(*uintptr)(unsafe.Pointer(v25))
	*(*uintptr)(unsafe.Pointer(v25))++
	*(*uint8)(unsafe.Pointer(v24)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
	v27 = envPtr2 + 152
	v26 = *(*uintptr)(unsafe.Pointer(v27))
	*(*uintptr)(unsafe.Pointer(v27))++
	*(*uint8)(unsafe.Pointer(v26)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
	v29 = envPtr2 + 152
	v28 = *(*uintptr)(unsafe.Pointer(v29))
	*(*uintptr)(unsafe.Pointer(v29))++
	*(*uint8)(unsafe.Pointer(v28)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) - libc.Int32FromInt32(2)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_DICT_UNSET)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - (int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) - int32(2))
		}
		v30 = delta1
		v31 = envPtr2
		if v30 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v31)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v31)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v31)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v31)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v31 + 64)) += int64(v30)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v33 = envPtr2 + 152
	v32 = *(*uintptr)(unsafe.Pointer(v33))
	*(*uintptr)(unsafe.Pointer(v33))++
	*(*uint8)(unsafe.Pointer(v32)) = uint8(libc.Uint32FromInt32(dictVarIndex) >> libc.Int32FromInt32(24))
	v35 = envPtr2 + 152
	v34 = *(*uintptr)(unsafe.Pointer(v35))
	*(*uintptr)(unsafe.Pointer(v35))++
	*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt32(dictVarIndex) >> libc.Int32FromInt32(16))
	v37 = envPtr2 + 152
	v36 = *(*uintptr)(unsafe.Pointer(v37))
	*(*uintptr)(unsafe.Pointer(v37))++
	*(*uint8)(unsafe.Pointer(v36)) = uint8(libc.Uint32FromInt32(dictVarIndex) >> libc.Int32FromInt32(8))
	v39 = envPtr2 + 152
	v38 = *(*uintptr)(unsafe.Pointer(v39))
	*(*uintptr)(unsafe.Pointer(v39))++
	*(*uint8)(unsafe.Pointer(v38)) = uint8(libc.Uint32FromInt32(dictVarIndex))
	return TCL_OK
}

func XTclCompileDictCreateCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, delta1, i1, worker, v105, v111, v123, v135, v145, v149, v155, v167, v173, v24, v36, v40, v44, v52, v64, v70, v82, v86, v93 int32
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, _objPtr6, _objPtr7, bytes, cachePtr, cachePtr1, cachePtr2, dictObj, keyObj, mapPtr, tokenPtr, valueObj, v10, v100, v101, v102, v103, v104, v106, v107, v108, v109, v110, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v124, v125, v126, v127, v128, v129, v130, v131, v132, v133, v134, v136, v137, v138, v139, v14, v140, v141, v142, v143, v144, v146, v147, v148, v150, v151, v152, v153, v154, v156, v157, v158, v159, v16, v160, v161, v162, v163, v164, v165, v166, v168, v169, v170, v171, v172, v174, v175, v176, v177, v178, v179, v18, v180, v181, v182, v19, v20, v21, v22, v23, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v37, v38, v39, v41, v42, v43, v45, v47, v48, v49, v5, v50, v51, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63, v65, v66, v67, v68, v69, v7, v71, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v83, v84, v85, v87, v89, v90, v91, v92, v94, v95, v96, v97, v98, v99 uintptr
	var eclIndex, v11, v13, v15, v17, v4, v46, v6, v9 TTcl_Size
	var v1, v3, v8 bool
	var _ /* len at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, _objPtr6, _objPtr7, bytes, cachePtr, cachePtr1, cachePtr2, delta1, dictObj, eclIndex, i1, keyObj, mapPtr, tokenPtr, valueObj, worker, v1, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v123, v124, v125, v126, v127, v128, v129, v13, v130, v131, v132, v133, v134, v135, v136, v137, v138, v139, v14, v140, v141, v142, v143, v144, v145, v146, v147, v148, v149, v15, v150, v151, v152, v153, v154, v155, v156, v157, v158, v159, v16, v160, v161, v162, v163, v164, v165, v166, v167, v168, v169, v17, v170, v171, v172, v173, v174, v175, v176, v177, v178, v179, v18, v180, v181, v182, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords&int64(1) == 0 {
		return int32(TCL_ERROR)
	}
	/*
	 * See if we can build the value at compile time...
	 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		dictObj = XTclThreadAllocObj(tls)
	} else {
		dictObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(dictObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(dictObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(dictObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(dictObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(dictObj)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(dictObj)).FrefCount++
	i1 = int32(1)
	for {
		if !(i1 < int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)) {
			break
		}
		if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			keyObj = XTclThreadAllocObj(tls)
		} else {
			keyObj = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(keyObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(keyObj)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(keyObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(keyObj)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(keyObj)).FtypePtr = libc.UintptrFromInt32(0)
		(*TTcl_Obj)(unsafe.Pointer(keyObj)).FrefCount++
		if !(XTclWordKnownAtCompileTime(tls, tokenPtr, keyObj) != 0) {
			_objPtr = keyObj
			v5 = _objPtr
			v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
			*(*TTcl_Size)(unsafe.Pointer(v5))--
			if v4 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			_objPtr1 = dictObj
			v7 = _objPtr1
			v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
			*(*TTcl_Size)(unsafe.Pointer(v7))--
			if v6 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
			goto nonConstant
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if v8 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v8 {
			cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v8 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
			valueObj = XTclThreadAllocObj(tls)
		} else {
			valueObj = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(valueObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(valueObj)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(valueObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(valueObj)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(valueObj)).FtypePtr = libc.UintptrFromInt32(0)
		(*TTcl_Obj)(unsafe.Pointer(valueObj)).FrefCount++
		if !(XTclWordKnownAtCompileTime(tls, tokenPtr, valueObj) != 0) {
			_objPtr2 = keyObj
			v10 = _objPtr2
			v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
			*(*TTcl_Size)(unsafe.Pointer(v10))--
			if v9 <= int64(1) {
				XTclFreeObj(tls, _objPtr2)
			}
			_objPtr3 = valueObj
			v12 = _objPtr3
			v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
			*(*TTcl_Size)(unsafe.Pointer(v12))--
			if v11 <= int64(1) {
				XTclFreeObj(tls, _objPtr3)
			}
			_objPtr4 = dictObj
			v14 = _objPtr4
			v13 = *(*TTcl_Size)(unsafe.Pointer(v14))
			*(*TTcl_Size)(unsafe.Pointer(v14))--
			if v13 <= int64(1) {
				XTclFreeObj(tls, _objPtr4)
			}
			goto nonConstant
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dictObj, keyObj, valueObj)
		_objPtr5 = keyObj
		v16 = _objPtr5
		v15 = *(*TTcl_Size)(unsafe.Pointer(v16))
		*(*TTcl_Size)(unsafe.Pointer(v16))--
		if v15 <= int64(1) {
			XTclFreeObj(tls, _objPtr5)
		}
		_objPtr6 = valueObj
		v18 = _objPtr6
		v17 = *(*TTcl_Size)(unsafe.Pointer(v18))
		*(*TTcl_Size)(unsafe.Pointer(v18))--
		if v17 <= int64(1) {
			XTclFreeObj(tls, _objPtr6)
		}
		goto _2
	_2:
		;
		i1 += int32(2)
	}
	/*
	 * We did! Excellent. The "verifyDict" is to do type forcing.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(dictObj)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(dictObj)).Flength
		v19 = (*TTcl_Obj)(unsafe.Pointer(dictObj)).Fbytes
	} else {
		v19 = XTcl_GetStringFromObj(tls, dictObj, bp)
	}
	bytes = v19
	_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, bytes, *(*TTcl_Size)(unsafe.Pointer(bp)), 0)
	if _objIndexCopy <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v21 = envPtr2 + 152
		v20 = *(*uintptr)(unsafe.Pointer(v21))
		*(*uintptr)(unsafe.Pointer(v21))++
		*(*uint8)(unsafe.Pointer(v20)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v23 = envPtr2 + 152
		v22 = *(*uintptr)(unsafe.Pointer(v23))
		*(*uintptr)(unsafe.Pointer(v23))++
		*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v24 = delta1
			v25 = envPtr2
			if v24 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v25 + 64)) += int64(v24)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v27 = envPtr2 + 152
		v26 = *(*uintptr)(unsafe.Pointer(v27))
		*(*uintptr)(unsafe.Pointer(v27))++
		*(*uint8)(unsafe.Pointer(v26)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v29 = envPtr2 + 152
		v28 = *(*uintptr)(unsafe.Pointer(v29))
		*(*uintptr)(unsafe.Pointer(v29))++
		*(*uint8)(unsafe.Pointer(v28)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
		v31 = envPtr2 + 152
		v30 = *(*uintptr)(unsafe.Pointer(v31))
		*(*uintptr)(unsafe.Pointer(v31))++
		*(*uint8)(unsafe.Pointer(v30)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
		v33 = envPtr2 + 152
		v32 = *(*uintptr)(unsafe.Pointer(v33))
		*(*uintptr)(unsafe.Pointer(v33))++
		*(*uint8)(unsafe.Pointer(v32)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
		v35 = envPtr2 + 152
		v34 = *(*uintptr)(unsafe.Pointer(v35))
		*(*uintptr)(unsafe.Pointer(v35))++
		*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v36 = delta1
			v37 = envPtr2
			if v36 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v37 + 64)) += int64(v36)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v39 = envPtr2 + 152
	v38 = *(*uintptr)(unsafe.Pointer(v39))
	*(*uintptr)(unsafe.Pointer(v39))++
	*(*uint8)(unsafe.Pointer(v38)) = libc.Uint8FromInt32(int32(INST_DUP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_DUP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v40 = delta1
		v41 = envPtr2
		if v40 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v41)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v41)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v41)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v41)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v41 + 64)) += int64(v40)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v43 = envPtr2 + 152
	v42 = *(*uintptr)(unsafe.Pointer(v43))
	*(*uintptr)(unsafe.Pointer(v43))++
	*(*uint8)(unsafe.Pointer(v42)) = libc.Uint8FromInt32(int32(INST_DICT_VERIFY))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_DICT_VERIFY)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v44 = delta1
		v45 = envPtr2
		if v44 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v45)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v45)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v45)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v45)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v45 + 64)) += int64(v44)
	}
	_objPtr7 = dictObj
	v47 = _objPtr7
	v46 = *(*TTcl_Size)(unsafe.Pointer(v47))
	*(*TTcl_Size)(unsafe.Pointer(v47))--
	if v46 <= int64(1) {
		XTclFreeObj(tls, _objPtr7)
	}
	return TCL_OK
	/*
	 * Otherwise, we've got to issue runtime code to do the building, which we
	 * do by [dict set]ting into an unnamed local variable. This requires that
	 * we are in a context with an LVT.
	 */
	goto nonConstant
nonConstant:
	;
	worker = int32(XTclFindCompiledLocal(tls, libc.UintptrFromInt32(0), 0, int32(1), envPtr2))
	if worker < 0 {
		return XTclCompileBasicMin0ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
	}
	_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy1 <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v49 = envPtr2 + 152
		v48 = *(*uintptr)(unsafe.Pointer(v49))
		*(*uintptr)(unsafe.Pointer(v49))++
		*(*uint8)(unsafe.Pointer(v48)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v51 = envPtr2 + 152
		v50 = *(*uintptr)(unsafe.Pointer(v51))
		*(*uintptr)(unsafe.Pointer(v51))++
		*(*uint8)(unsafe.Pointer(v50)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy1
			}
			v52 = delta1
			v53 = envPtr2
			if v52 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v53)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v53)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v53)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v53)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v53 + 64)) += int64(v52)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v55 = envPtr2 + 152
		v54 = *(*uintptr)(unsafe.Pointer(v55))
		*(*uintptr)(unsafe.Pointer(v55))++
		*(*uint8)(unsafe.Pointer(v54)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v57 = envPtr2 + 152
		v56 = *(*uintptr)(unsafe.Pointer(v57))
		*(*uintptr)(unsafe.Pointer(v57))++
		*(*uint8)(unsafe.Pointer(v56)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
		v59 = envPtr2 + 152
		v58 = *(*uintptr)(unsafe.Pointer(v59))
		*(*uintptr)(unsafe.Pointer(v59))++
		*(*uint8)(unsafe.Pointer(v58)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
		v61 = envPtr2 + 152
		v60 = *(*uintptr)(unsafe.Pointer(v61))
		*(*uintptr)(unsafe.Pointer(v61))++
		*(*uint8)(unsafe.Pointer(v60)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
		v63 = envPtr2 + 152
		v62 = *(*uintptr)(unsafe.Pointer(v63))
		*(*uintptr)(unsafe.Pointer(v63))++
		*(*uint8)(unsafe.Pointer(v62)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy1
			}
			v64 = delta1
			v65 = envPtr2
			if v64 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v65)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v65)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v65)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v65)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v65 + 64)) += int64(v64)
		}
	}
	if worker <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v67 = envPtr2 + 152
		v66 = *(*uintptr)(unsafe.Pointer(v67))
		*(*uintptr)(unsafe.Pointer(v67))++
		*(*uint8)(unsafe.Pointer(v66)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
		v69 = envPtr2 + 152
		v68 = *(*uintptr)(unsafe.Pointer(v69))
		*(*uintptr)(unsafe.Pointer(v69))++
		*(*uint8)(unsafe.Pointer(v68)) = uint8(libc.Uint32FromInt32(worker))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - worker
			}
			v70 = delta1
			v71 = envPtr2
			if v70 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v71)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v71)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v71)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v71)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v71 + 64)) += int64(v70)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v73 = envPtr2 + 152
		v72 = *(*uintptr)(unsafe.Pointer(v73))
		*(*uintptr)(unsafe.Pointer(v73))++
		*(*uint8)(unsafe.Pointer(v72)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
		v75 = envPtr2 + 152
		v74 = *(*uintptr)(unsafe.Pointer(v75))
		*(*uintptr)(unsafe.Pointer(v75))++
		*(*uint8)(unsafe.Pointer(v74)) = uint8(libc.Uint32FromInt32(worker) >> libc.Int32FromInt32(24))
		v77 = envPtr2 + 152
		v76 = *(*uintptr)(unsafe.Pointer(v77))
		*(*uintptr)(unsafe.Pointer(v77))++
		*(*uint8)(unsafe.Pointer(v76)) = uint8(libc.Uint32FromInt32(worker) >> libc.Int32FromInt32(16))
		v79 = envPtr2 + 152
		v78 = *(*uintptr)(unsafe.Pointer(v79))
		*(*uintptr)(unsafe.Pointer(v79))++
		*(*uint8)(unsafe.Pointer(v78)) = uint8(libc.Uint32FromInt32(worker) >> libc.Int32FromInt32(8))
		v81 = envPtr2 + 152
		v80 = *(*uintptr)(unsafe.Pointer(v81))
		*(*uintptr)(unsafe.Pointer(v81))++
		*(*uint8)(unsafe.Pointer(v80)) = uint8(libc.Uint32FromInt32(worker))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - worker
			}
			v82 = delta1
			v83 = envPtr2
			if v82 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v83)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v83)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v83)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v83)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v83 + 64)) += int64(v82)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v85 = envPtr2 + 152
	v84 = *(*uintptr)(unsafe.Pointer(v85))
	*(*uintptr)(unsafe.Pointer(v85))++
	*(*uint8)(unsafe.Pointer(v84)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v86 = delta1
		v87 = envPtr2
		if v86 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v87)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v87)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v87)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v87)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v87 + 64)) += int64(v86)
	}
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	i1 = int32(1)
	for {
		if !(i1 < int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)) {
			break
		}
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy2 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v90 = envPtr2 + 152
				v89 = *(*uintptr)(unsafe.Pointer(v90))
				*(*uintptr)(unsafe.Pointer(v90))++
				*(*uint8)(unsafe.Pointer(v89)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v92 = envPtr2 + 152
				v91 = *(*uintptr)(unsafe.Pointer(v92))
				*(*uintptr)(unsafe.Pointer(v92))++
				*(*uint8)(unsafe.Pointer(v91)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy2
					}
					v93 = delta1
					v94 = envPtr2
					if v93 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v94)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v94)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v94)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v94)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v94 + 64)) += int64(v93)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v96 = envPtr2 + 152
				v95 = *(*uintptr)(unsafe.Pointer(v96))
				*(*uintptr)(unsafe.Pointer(v96))++
				*(*uint8)(unsafe.Pointer(v95)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v98 = envPtr2 + 152
				v97 = *(*uintptr)(unsafe.Pointer(v98))
				*(*uintptr)(unsafe.Pointer(v98))++
				*(*uint8)(unsafe.Pointer(v97)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
				v100 = envPtr2 + 152
				v99 = *(*uintptr)(unsafe.Pointer(v100))
				*(*uintptr)(unsafe.Pointer(v100))++
				*(*uint8)(unsafe.Pointer(v99)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
				v102 = envPtr2 + 152
				v101 = *(*uintptr)(unsafe.Pointer(v102))
				*(*uintptr)(unsafe.Pointer(v102))++
				*(*uint8)(unsafe.Pointer(v101)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
				v104 = envPtr2 + 152
				v103 = *(*uintptr)(unsafe.Pointer(v104))
				*(*uintptr)(unsafe.Pointer(v104))++
				*(*uint8)(unsafe.Pointer(v103)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy2
					}
					v105 = delta1
					v106 = envPtr2
					if v105 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v106)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v106)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v106)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v106)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v106 + 64)) += int64(v105)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy3 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy3 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v108 = envPtr2 + 152
				v107 = *(*uintptr)(unsafe.Pointer(v108))
				*(*uintptr)(unsafe.Pointer(v108))++
				*(*uint8)(unsafe.Pointer(v107)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v110 = envPtr2 + 152
				v109 = *(*uintptr)(unsafe.Pointer(v110))
				*(*uintptr)(unsafe.Pointer(v110))++
				*(*uint8)(unsafe.Pointer(v109)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy3
					}
					v111 = delta1
					v112 = envPtr2
					if v111 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v112)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v112)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v112)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v112)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v112 + 64)) += int64(v111)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v114 = envPtr2 + 152
				v113 = *(*uintptr)(unsafe.Pointer(v114))
				*(*uintptr)(unsafe.Pointer(v114))++
				*(*uint8)(unsafe.Pointer(v113)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v116 = envPtr2 + 152
				v115 = *(*uintptr)(unsafe.Pointer(v116))
				*(*uintptr)(unsafe.Pointer(v116))++
				*(*uint8)(unsafe.Pointer(v115)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(24))
				v118 = envPtr2 + 152
				v117 = *(*uintptr)(unsafe.Pointer(v118))
				*(*uintptr)(unsafe.Pointer(v118))++
				*(*uint8)(unsafe.Pointer(v117)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(16))
				v120 = envPtr2 + 152
				v119 = *(*uintptr)(unsafe.Pointer(v120))
				*(*uintptr)(unsafe.Pointer(v120))++
				*(*uint8)(unsafe.Pointer(v119)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(8))
				v122 = envPtr2 + 152
				v121 = *(*uintptr)(unsafe.Pointer(v122))
				*(*uintptr)(unsafe.Pointer(v122))++
				*(*uint8)(unsafe.Pointer(v121)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy3
					}
					v123 = delta1
					v124 = envPtr2
					if v123 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v124)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v124)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v124)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v124)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v124 + 64)) += int64(v123)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1+libc.Int32FromInt32(1))*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1+libc.Int32FromInt32(1))*8))
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v126 = envPtr2 + 152
		v125 = *(*uintptr)(unsafe.Pointer(v126))
		*(*uintptr)(unsafe.Pointer(v126))++
		*(*uint8)(unsafe.Pointer(v125)) = libc.Uint8FromInt32(int32(INST_DICT_SET))
		v128 = envPtr2 + 152
		v127 = *(*uintptr)(unsafe.Pointer(v128))
		*(*uintptr)(unsafe.Pointer(v128))++
		*(*uint8)(unsafe.Pointer(v127)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(24))
		v130 = envPtr2 + 152
		v129 = *(*uintptr)(unsafe.Pointer(v130))
		*(*uintptr)(unsafe.Pointer(v130))++
		*(*uint8)(unsafe.Pointer(v129)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(16))
		v132 = envPtr2 + 152
		v131 = *(*uintptr)(unsafe.Pointer(v132))
		*(*uintptr)(unsafe.Pointer(v132))++
		*(*uint8)(unsafe.Pointer(v131)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(8))
		v134 = envPtr2 + 152
		v133 = *(*uintptr)(unsafe.Pointer(v134))
		*(*uintptr)(unsafe.Pointer(v134))++
		*(*uint8)(unsafe.Pointer(v133)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_DICT_SET)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(1)
			}
			v135 = delta1
			v136 = envPtr2
			if v135 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v136)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v136)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v136)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v136)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v136 + 64)) += int64(v135)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v138 = envPtr2 + 152
		v137 = *(*uintptr)(unsafe.Pointer(v138))
		*(*uintptr)(unsafe.Pointer(v138))++
		*(*uint8)(unsafe.Pointer(v137)) = uint8(libc.Uint32FromInt32(worker) >> libc.Int32FromInt32(24))
		v140 = envPtr2 + 152
		v139 = *(*uintptr)(unsafe.Pointer(v140))
		*(*uintptr)(unsafe.Pointer(v140))++
		*(*uint8)(unsafe.Pointer(v139)) = uint8(libc.Uint32FromInt32(worker) >> libc.Int32FromInt32(16))
		v142 = envPtr2 + 152
		v141 = *(*uintptr)(unsafe.Pointer(v142))
		*(*uintptr)(unsafe.Pointer(v142))++
		*(*uint8)(unsafe.Pointer(v141)) = uint8(libc.Uint32FromInt32(worker) >> libc.Int32FromInt32(8))
		v144 = envPtr2 + 152
		v143 = *(*uintptr)(unsafe.Pointer(v144))
		*(*uintptr)(unsafe.Pointer(v144))++
		*(*uint8)(unsafe.Pointer(v143)) = uint8(libc.Uint32FromInt32(worker))
		v145 = -int32(1)
		v146 = envPtr2
		if v145 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v146)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v146)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v146)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v146)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v146 + 64)) += int64(v145)
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v148 = envPtr2 + 152
		v147 = *(*uintptr)(unsafe.Pointer(v148))
		*(*uintptr)(unsafe.Pointer(v148))++
		*(*uint8)(unsafe.Pointer(v147)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v149 = delta1
			v150 = envPtr2
			if v149 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v150)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v150)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v150)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v150)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v150 + 64)) += int64(v149)
		}
		goto _88
	_88:
		;
		i1 += int32(2)
	}
	if worker <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v152 = envPtr2 + 152
		v151 = *(*uintptr)(unsafe.Pointer(v152))
		*(*uintptr)(unsafe.Pointer(v152))++
		*(*uint8)(unsafe.Pointer(v151)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
		v154 = envPtr2 + 152
		v153 = *(*uintptr)(unsafe.Pointer(v154))
		*(*uintptr)(unsafe.Pointer(v154))++
		*(*uint8)(unsafe.Pointer(v153)) = uint8(libc.Uint32FromInt32(worker))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - worker
			}
			v155 = delta1
			v156 = envPtr2
			if v155 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v156)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v156)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v156)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v156)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v156 + 64)) += int64(v155)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v158 = envPtr2 + 152
		v157 = *(*uintptr)(unsafe.Pointer(v158))
		*(*uintptr)(unsafe.Pointer(v158))++
		*(*uint8)(unsafe.Pointer(v157)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
		v160 = envPtr2 + 152
		v159 = *(*uintptr)(unsafe.Pointer(v160))
		*(*uintptr)(unsafe.Pointer(v160))++
		*(*uint8)(unsafe.Pointer(v159)) = uint8(libc.Uint32FromInt32(worker) >> libc.Int32FromInt32(24))
		v162 = envPtr2 + 152
		v161 = *(*uintptr)(unsafe.Pointer(v162))
		*(*uintptr)(unsafe.Pointer(v162))++
		*(*uint8)(unsafe.Pointer(v161)) = uint8(libc.Uint32FromInt32(worker) >> libc.Int32FromInt32(16))
		v164 = envPtr2 + 152
		v163 = *(*uintptr)(unsafe.Pointer(v164))
		*(*uintptr)(unsafe.Pointer(v164))++
		*(*uint8)(unsafe.Pointer(v163)) = uint8(libc.Uint32FromInt32(worker) >> libc.Int32FromInt32(8))
		v166 = envPtr2 + 152
		v165 = *(*uintptr)(unsafe.Pointer(v166))
		*(*uintptr)(unsafe.Pointer(v166))++
		*(*uint8)(unsafe.Pointer(v165)) = uint8(libc.Uint32FromInt32(worker))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - worker
			}
			v167 = delta1
			v168 = envPtr2
			if v167 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v168)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v168)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v168)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v168)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v168 + 64)) += int64(v167)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v170 = envPtr2 + 152
	v169 = *(*uintptr)(unsafe.Pointer(v170))
	*(*uintptr)(unsafe.Pointer(v170))++
	*(*uint8)(unsafe.Pointer(v169)) = libc.Uint8FromInt32(int32(INST_UNSET_SCALAR))
	v172 = envPtr2 + 152
	v171 = *(*uintptr)(unsafe.Pointer(v172))
	*(*uintptr)(unsafe.Pointer(v172))++
	*(*uint8)(unsafe.Pointer(v171)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_UNSET_SCALAR)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v173 = delta1
		v174 = envPtr2
		if v173 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v174)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v174)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v174)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v174)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v174 + 64)) += int64(v173)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v176 = envPtr2 + 152
	v175 = *(*uintptr)(unsafe.Pointer(v176))
	*(*uintptr)(unsafe.Pointer(v176))++
	*(*uint8)(unsafe.Pointer(v175)) = uint8(libc.Uint32FromInt32(worker) >> libc.Int32FromInt32(24))
	v178 = envPtr2 + 152
	v177 = *(*uintptr)(unsafe.Pointer(v178))
	*(*uintptr)(unsafe.Pointer(v178))++
	*(*uint8)(unsafe.Pointer(v177)) = uint8(libc.Uint32FromInt32(worker) >> libc.Int32FromInt32(16))
	v180 = envPtr2 + 152
	v179 = *(*uintptr)(unsafe.Pointer(v180))
	*(*uintptr)(unsafe.Pointer(v180))++
	*(*uint8)(unsafe.Pointer(v179)) = uint8(libc.Uint32FromInt32(worker) >> libc.Int32FromInt32(8))
	v182 = envPtr2 + 152
	v181 = *(*uintptr)(unsafe.Pointer(v182))
	*(*uintptr)(unsafe.Pointer(v182))++
	*(*uint8)(unsafe.Pointer(v181)) = uint8(libc.Uint32FromInt32(worker))
	return TCL_OK
}

func XTclCompileDictMergeCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, delta1, i1, infoIndex, outLoop, workerIndex, v103, v111, v123, v135, v141, v153, v165, v17, v175, v179, v191, v197, v201, v205, v211, v223, v229, v23, v241, v247, v261, v263, v267, v271, v275, v281, v295, v307, v35, v39, v43, v49, v5, v61, v65, v69, v75, v87, v91 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v100, v101, v102, v104, v107, v108, v109, v11, v110, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v124, v125, v126, v127, v128, v129, v13, v130, v131, v132, v133, v134, v136, v137, v138, v139, v14, v140, v142, v143, v144, v145, v146, v147, v148, v149, v15, v150, v151, v152, v154, v155, v156, v157, v158, v159, v16, v160, v161, v162, v163, v164, v166, v167, v168, v169, v170, v171, v172, v173, v174, v176, v177, v178, v18, v180, v181, v182, v183, v184, v185, v186, v187, v188, v189, v19, v190, v192, v193, v194, v195, v196, v198, v199, v2, v20, v200, v202, v203, v204, v206, v207, v208, v209, v21, v210, v212, v213, v214, v215, v216, v217, v218, v219, v22, v220, v221, v222, v224, v225, v226, v227, v228, v230, v231, v232, v233, v234, v235, v236, v237, v238, v239, v24, v240, v242, v243, v244, v245, v246, v248, v249, v25, v250, v251, v252, v253, v254, v255, v256, v257, v258, v259, v26, v260, v262, v264, v265, v266, v268, v269, v27, v270, v272, v273, v274, v276, v277, v278, v279, v28, v280, v282, v283, v284, v285, v286, v287, v288, v289, v29, v290, v291, v292, v293, v294, v296, v297, v298, v299, v3, v30, v300, v301, v302, v303, v304, v305, v306, v308, v31, v32, v33, v34, v36, v37, v38, v4, v40, v41, v42, v44, v45, v46, v47, v48, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v62, v63, v64, v66, v67, v68, v7, v70, v71, v72, v73, v74, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v88, v89, v9, v90, v92, v93, v94, v95, v96, v97, v98, v99 uintptr
	var v105 int64
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, delta1, eclIndex, i1, infoIndex, mapPtr, outLoop, tokenPtr, workerIndex, v1, v10, v100, v101, v102, v103, v104, v105, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v123, v124, v125, v126, v127, v128, v129, v13, v130, v131, v132, v133, v134, v135, v136, v137, v138, v139, v14, v140, v141, v142, v143, v144, v145, v146, v147, v148, v149, v15, v150, v151, v152, v153, v154, v155, v156, v157, v158, v159, v16, v160, v161, v162, v163, v164, v165, v166, v167, v168, v169, v17, v170, v171, v172, v173, v174, v175, v176, v177, v178, v179, v18, v180, v181, v182, v183, v184, v185, v186, v187, v188, v189, v19, v190, v191, v192, v193, v194, v195, v196, v197, v198, v199, v2, v20, v200, v201, v202, v203, v204, v205, v206, v207, v208, v209, v21, v210, v211, v212, v213, v214, v215, v216, v217, v218, v219, v22, v220, v221, v222, v223, v224, v225, v226, v227, v228, v229, v23, v230, v231, v232, v233, v234, v235, v236, v237, v238, v239, v24, v240, v241, v242, v243, v244, v245, v246, v247, v248, v249, v25, v250, v251, v252, v253, v254, v255, v256, v257, v258, v259, v26, v260, v261, v262, v263, v264, v265, v266, v267, v268, v269, v27, v270, v271, v272, v273, v274, v275, v276, v277, v278, v279, v28, v280, v281, v282, v283, v284, v285, v286, v287, v288, v289, v29, v290, v291, v292, v293, v294, v295, v296, v297, v298, v299, v3, v30, v300, v301, v302, v303, v304, v305, v306, v307, v308, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	/*
	 * Deal with some special edge cases. Note that in the case with one
	 * argument, the only thing to do is to verify the dict-ness.
	 */
	/* TODO: Consider support for compiling expanded args. (less likely) */
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) < int32(2) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
		return TCL_OK
	} else {
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(2) {
			tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
			if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
				_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
				if _objIndexCopy1 <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v20 = envPtr2 + 152
					v19 = *(*uintptr)(unsafe.Pointer(v20))
					*(*uintptr)(unsafe.Pointer(v20))++
					*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_PUSH1))
					v22 = envPtr2 + 152
					v21 = *(*uintptr)(unsafe.Pointer(v22))
					*(*uintptr)(unsafe.Pointer(v22))++
					*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy1
						}
						v23 = delta1
						v24 = envPtr2
						if v23 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v24 + 64)) += int64(v23)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v26 = envPtr2 + 152
					v25 = *(*uintptr)(unsafe.Pointer(v26))
					*(*uintptr)(unsafe.Pointer(v26))++
					*(*uint8)(unsafe.Pointer(v25)) = libc.Uint8FromInt32(int32(INST_PUSH4))
					v28 = envPtr2 + 152
					v27 = *(*uintptr)(unsafe.Pointer(v28))
					*(*uintptr)(unsafe.Pointer(v28))++
					*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
					v30 = envPtr2 + 152
					v29 = *(*uintptr)(unsafe.Pointer(v30))
					*(*uintptr)(unsafe.Pointer(v30))++
					*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
					v32 = envPtr2 + 152
					v31 = *(*uintptr)(unsafe.Pointer(v32))
					*(*uintptr)(unsafe.Pointer(v32))++
					*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
					v34 = envPtr2 + 152
					v33 = *(*uintptr)(unsafe.Pointer(v34))
					*(*uintptr)(unsafe.Pointer(v34))++
					*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy1
						}
						v35 = delta1
						v36 = envPtr2
						if v35 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v36 + 64)) += int64(v35)
					}
				}
			} else {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
				XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v38 = envPtr2 + 152
			v37 = *(*uintptr)(unsafe.Pointer(v38))
			*(*uintptr)(unsafe.Pointer(v38))++
			*(*uint8)(unsafe.Pointer(v37)) = libc.Uint8FromInt32(int32(INST_DUP))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_DUP)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v39 = delta1
				v40 = envPtr2
				if v39 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v40 + 64)) += int64(v39)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v42 = envPtr2 + 152
			v41 = *(*uintptr)(unsafe.Pointer(v42))
			*(*uintptr)(unsafe.Pointer(v42))++
			*(*uint8)(unsafe.Pointer(v41)) = libc.Uint8FromInt32(int32(INST_DICT_VERIFY))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_DICT_VERIFY)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v43 = delta1
				v44 = envPtr2
				if v43 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v44)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v44)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v44)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v44)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v44 + 64)) += int64(v43)
			}
			return TCL_OK
		}
	}
	/*
	 * There's real merging work to do.
	 *
	 * Allocate some working space. This means we'll only ever compile this
	 * command when there's an LVT present.
	 */
	workerIndex = int32(XTclFindCompiledLocal(tls, libc.UintptrFromInt32(0), 0, int32(1), envPtr2))
	if workerIndex < 0 {
		return XTclCompileBasicMin2ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
	}
	infoIndex = int32(XTclFindCompiledLocal(tls, libc.UintptrFromInt32(0), 0, int32(1), envPtr2))
	/*
	 * Get the first dictionary and verify that it is so.
	 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy2 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v46 = envPtr2 + 152
			v45 = *(*uintptr)(unsafe.Pointer(v46))
			*(*uintptr)(unsafe.Pointer(v46))++
			*(*uint8)(unsafe.Pointer(v45)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v48 = envPtr2 + 152
			v47 = *(*uintptr)(unsafe.Pointer(v48))
			*(*uintptr)(unsafe.Pointer(v48))++
			*(*uint8)(unsafe.Pointer(v47)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v49 = delta1
				v50 = envPtr2
				if v49 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v50)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v50)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v50)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v50)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v50 + 64)) += int64(v49)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v52 = envPtr2 + 152
			v51 = *(*uintptr)(unsafe.Pointer(v52))
			*(*uintptr)(unsafe.Pointer(v52))++
			*(*uint8)(unsafe.Pointer(v51)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v54 = envPtr2 + 152
			v53 = *(*uintptr)(unsafe.Pointer(v54))
			*(*uintptr)(unsafe.Pointer(v54))++
			*(*uint8)(unsafe.Pointer(v53)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
			v56 = envPtr2 + 152
			v55 = *(*uintptr)(unsafe.Pointer(v56))
			*(*uintptr)(unsafe.Pointer(v56))++
			*(*uint8)(unsafe.Pointer(v55)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
			v58 = envPtr2 + 152
			v57 = *(*uintptr)(unsafe.Pointer(v58))
			*(*uintptr)(unsafe.Pointer(v58))++
			*(*uint8)(unsafe.Pointer(v57)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
			v60 = envPtr2 + 152
			v59 = *(*uintptr)(unsafe.Pointer(v60))
			*(*uintptr)(unsafe.Pointer(v60))++
			*(*uint8)(unsafe.Pointer(v59)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v61 = delta1
				v62 = envPtr2
				if v61 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v62)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v62)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v62)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v62)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v62 + 64)) += int64(v61)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v64 = envPtr2 + 152
	v63 = *(*uintptr)(unsafe.Pointer(v64))
	*(*uintptr)(unsafe.Pointer(v64))++
	*(*uint8)(unsafe.Pointer(v63)) = libc.Uint8FromInt32(int32(INST_DUP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_DUP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v65 = delta1
		v66 = envPtr2
		if v65 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v66)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v66)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v66)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v66)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v66 + 64)) += int64(v65)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v68 = envPtr2 + 152
	v67 = *(*uintptr)(unsafe.Pointer(v68))
	*(*uintptr)(unsafe.Pointer(v68))++
	*(*uint8)(unsafe.Pointer(v67)) = libc.Uint8FromInt32(int32(INST_DICT_VERIFY))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_DICT_VERIFY)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v69 = delta1
		v70 = envPtr2
		if v69 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v70 + 64)) += int64(v69)
	}
	if workerIndex <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v72 = envPtr2 + 152
		v71 = *(*uintptr)(unsafe.Pointer(v72))
		*(*uintptr)(unsafe.Pointer(v72))++
		*(*uint8)(unsafe.Pointer(v71)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
		v74 = envPtr2 + 152
		v73 = *(*uintptr)(unsafe.Pointer(v74))
		*(*uintptr)(unsafe.Pointer(v74))++
		*(*uint8)(unsafe.Pointer(v73)) = uint8(libc.Uint32FromInt32(workerIndex))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - workerIndex
			}
			v75 = delta1
			v76 = envPtr2
			if v75 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v76)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v76)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v76)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v76)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v76 + 64)) += int64(v75)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v78 = envPtr2 + 152
		v77 = *(*uintptr)(unsafe.Pointer(v78))
		*(*uintptr)(unsafe.Pointer(v78))++
		*(*uint8)(unsafe.Pointer(v77)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
		v80 = envPtr2 + 152
		v79 = *(*uintptr)(unsafe.Pointer(v80))
		*(*uintptr)(unsafe.Pointer(v80))++
		*(*uint8)(unsafe.Pointer(v79)) = uint8(libc.Uint32FromInt32(workerIndex) >> libc.Int32FromInt32(24))
		v82 = envPtr2 + 152
		v81 = *(*uintptr)(unsafe.Pointer(v82))
		*(*uintptr)(unsafe.Pointer(v82))++
		*(*uint8)(unsafe.Pointer(v81)) = uint8(libc.Uint32FromInt32(workerIndex) >> libc.Int32FromInt32(16))
		v84 = envPtr2 + 152
		v83 = *(*uintptr)(unsafe.Pointer(v84))
		*(*uintptr)(unsafe.Pointer(v84))++
		*(*uint8)(unsafe.Pointer(v83)) = uint8(libc.Uint32FromInt32(workerIndex) >> libc.Int32FromInt32(8))
		v86 = envPtr2 + 152
		v85 = *(*uintptr)(unsafe.Pointer(v86))
		*(*uintptr)(unsafe.Pointer(v86))++
		*(*uint8)(unsafe.Pointer(v85)) = uint8(libc.Uint32FromInt32(workerIndex))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - workerIndex
			}
			v87 = delta1
			v88 = envPtr2
			if v87 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v88)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v88)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v88)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v88)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v88 + 64)) += int64(v87)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v90 = envPtr2 + 152
	v89 = *(*uintptr)(unsafe.Pointer(v90))
	*(*uintptr)(unsafe.Pointer(v90))++
	*(*uint8)(unsafe.Pointer(v89)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v91 = delta1
		v92 = envPtr2
		if v91 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v92)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v92)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v92)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v92)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v92 + 64)) += int64(v91)
	}
	/*
	 * For each of the remaining dictionaries...
	 */
	outLoop = int32(XTclCreateExceptRange(tls, int32(CATCH_EXCEPTION_RANGE), envPtr2))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v94 = envPtr2 + 152
	v93 = *(*uintptr)(unsafe.Pointer(v94))
	*(*uintptr)(unsafe.Pointer(v94))++
	*(*uint8)(unsafe.Pointer(v93)) = libc.Uint8FromInt32(int32(INST_BEGIN_CATCH4))
	v96 = envPtr2 + 152
	v95 = *(*uintptr)(unsafe.Pointer(v96))
	*(*uintptr)(unsafe.Pointer(v96))++
	*(*uint8)(unsafe.Pointer(v95)) = uint8(libc.Uint32FromInt32(outLoop) >> libc.Int32FromInt32(24))
	v98 = envPtr2 + 152
	v97 = *(*uintptr)(unsafe.Pointer(v98))
	*(*uintptr)(unsafe.Pointer(v98))++
	*(*uint8)(unsafe.Pointer(v97)) = uint8(libc.Uint32FromInt32(outLoop) >> libc.Int32FromInt32(16))
	v100 = envPtr2 + 152
	v99 = *(*uintptr)(unsafe.Pointer(v100))
	*(*uintptr)(unsafe.Pointer(v100))++
	*(*uint8)(unsafe.Pointer(v99)) = uint8(libc.Uint32FromInt32(outLoop) >> libc.Int32FromInt32(8))
	v102 = envPtr2 + 152
	v101 = *(*uintptr)(unsafe.Pointer(v102))
	*(*uintptr)(unsafe.Pointer(v102))++
	*(*uint8)(unsafe.Pointer(v101)) = uint8(libc.Uint32FromInt32(outLoop))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_BEGIN_CATCH4)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - outLoop
		}
		v103 = delta1
		v104 = envPtr2
		if v103 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v104)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v104)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v104)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v104)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v104 + 64)) += int64(v103)
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth++
	if libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth)+uint64(1) > libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth)+uint64(1) {
		v105 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth
	} else {
		v105 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth = v105
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(outLoop)*56))).FcodeOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	i1 = int32(2)
	for {
		if !(i1 < int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)) {
			break
		}
		/*
		 * Get the dictionary, and merge its pairs into the first dict (using
		 * a small loop).
		 */
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy3 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy3 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v108 = envPtr2 + 152
				v107 = *(*uintptr)(unsafe.Pointer(v108))
				*(*uintptr)(unsafe.Pointer(v108))++
				*(*uint8)(unsafe.Pointer(v107)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v110 = envPtr2 + 152
				v109 = *(*uintptr)(unsafe.Pointer(v110))
				*(*uintptr)(unsafe.Pointer(v110))++
				*(*uint8)(unsafe.Pointer(v109)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy3
					}
					v111 = delta1
					v112 = envPtr2
					if v111 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v112)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v112)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v112)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v112)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v112 + 64)) += int64(v111)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v114 = envPtr2 + 152
				v113 = *(*uintptr)(unsafe.Pointer(v114))
				*(*uintptr)(unsafe.Pointer(v114))++
				*(*uint8)(unsafe.Pointer(v113)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v116 = envPtr2 + 152
				v115 = *(*uintptr)(unsafe.Pointer(v116))
				*(*uintptr)(unsafe.Pointer(v116))++
				*(*uint8)(unsafe.Pointer(v115)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(24))
				v118 = envPtr2 + 152
				v117 = *(*uintptr)(unsafe.Pointer(v118))
				*(*uintptr)(unsafe.Pointer(v118))++
				*(*uint8)(unsafe.Pointer(v117)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(16))
				v120 = envPtr2 + 152
				v119 = *(*uintptr)(unsafe.Pointer(v120))
				*(*uintptr)(unsafe.Pointer(v120))++
				*(*uint8)(unsafe.Pointer(v119)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(8))
				v122 = envPtr2 + 152
				v121 = *(*uintptr)(unsafe.Pointer(v122))
				*(*uintptr)(unsafe.Pointer(v122))++
				*(*uint8)(unsafe.Pointer(v121)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy3
					}
					v123 = delta1
					v124 = envPtr2
					if v123 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v124)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v124)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v124)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v124)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v124 + 64)) += int64(v123)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v126 = envPtr2 + 152
		v125 = *(*uintptr)(unsafe.Pointer(v126))
		*(*uintptr)(unsafe.Pointer(v126))++
		*(*uint8)(unsafe.Pointer(v125)) = libc.Uint8FromInt32(int32(INST_DICT_FIRST))
		v128 = envPtr2 + 152
		v127 = *(*uintptr)(unsafe.Pointer(v128))
		*(*uintptr)(unsafe.Pointer(v128))++
		*(*uint8)(unsafe.Pointer(v127)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(24))
		v130 = envPtr2 + 152
		v129 = *(*uintptr)(unsafe.Pointer(v130))
		*(*uintptr)(unsafe.Pointer(v130))++
		*(*uint8)(unsafe.Pointer(v129)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(16))
		v132 = envPtr2 + 152
		v131 = *(*uintptr)(unsafe.Pointer(v132))
		*(*uintptr)(unsafe.Pointer(v132))++
		*(*uint8)(unsafe.Pointer(v131)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(8))
		v134 = envPtr2 + 152
		v133 = *(*uintptr)(unsafe.Pointer(v134))
		*(*uintptr)(unsafe.Pointer(v134))++
		*(*uint8)(unsafe.Pointer(v133)) = uint8(libc.Uint32FromInt32(infoIndex))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_DICT_FIRST)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - infoIndex
			}
			v135 = delta1
			v136 = envPtr2
			if v135 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v136)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v136)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v136)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v136)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v136 + 64)) += int64(v135)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v138 = envPtr2 + 152
		v137 = *(*uintptr)(unsafe.Pointer(v138))
		*(*uintptr)(unsafe.Pointer(v138))++
		*(*uint8)(unsafe.Pointer(v137)) = libc.Uint8FromInt32(int32(INST_JUMP_TRUE1))
		v140 = envPtr2 + 152
		v139 = *(*uintptr)(unsafe.Pointer(v140))
		*(*uintptr)(unsafe.Pointer(v140))++
		*(*uint8)(unsafe.Pointer(v139)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(24)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP_TRUE1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(24)
			}
			v141 = delta1
			v142 = envPtr2
			if v141 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v142)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v142)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v142)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v142)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v142 + 64)) += int64(v141)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v144 = envPtr2 + 152
		v143 = *(*uintptr)(unsafe.Pointer(v144))
		*(*uintptr)(unsafe.Pointer(v144))++
		*(*uint8)(unsafe.Pointer(v143)) = libc.Uint8FromInt32(int32(INST_REVERSE))
		v146 = envPtr2 + 152
		v145 = *(*uintptr)(unsafe.Pointer(v146))
		*(*uintptr)(unsafe.Pointer(v146))++
		*(*uint8)(unsafe.Pointer(v145)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
		v148 = envPtr2 + 152
		v147 = *(*uintptr)(unsafe.Pointer(v148))
		*(*uintptr)(unsafe.Pointer(v148))++
		*(*uint8)(unsafe.Pointer(v147)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
		v150 = envPtr2 + 152
		v149 = *(*uintptr)(unsafe.Pointer(v150))
		*(*uintptr)(unsafe.Pointer(v150))++
		*(*uint8)(unsafe.Pointer(v149)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
		v152 = envPtr2 + 152
		v151 = *(*uintptr)(unsafe.Pointer(v152))
		*(*uintptr)(unsafe.Pointer(v152))++
		*(*uint8)(unsafe.Pointer(v151)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(2)
			}
			v153 = delta1
			v154 = envPtr2
			if v153 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v154)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v154)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v154)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v154)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v154 + 64)) += int64(v153)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v156 = envPtr2 + 152
		v155 = *(*uintptr)(unsafe.Pointer(v156))
		*(*uintptr)(unsafe.Pointer(v156))++
		*(*uint8)(unsafe.Pointer(v155)) = libc.Uint8FromInt32(int32(INST_DICT_SET))
		v158 = envPtr2 + 152
		v157 = *(*uintptr)(unsafe.Pointer(v158))
		*(*uintptr)(unsafe.Pointer(v158))++
		*(*uint8)(unsafe.Pointer(v157)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(24))
		v160 = envPtr2 + 152
		v159 = *(*uintptr)(unsafe.Pointer(v160))
		*(*uintptr)(unsafe.Pointer(v160))++
		*(*uint8)(unsafe.Pointer(v159)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(16))
		v162 = envPtr2 + 152
		v161 = *(*uintptr)(unsafe.Pointer(v162))
		*(*uintptr)(unsafe.Pointer(v162))++
		*(*uint8)(unsafe.Pointer(v161)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(8))
		v164 = envPtr2 + 152
		v163 = *(*uintptr)(unsafe.Pointer(v164))
		*(*uintptr)(unsafe.Pointer(v164))++
		*(*uint8)(unsafe.Pointer(v163)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_DICT_SET)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(1)
			}
			v165 = delta1
			v166 = envPtr2
			if v165 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v166)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v166)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v166)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v166)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v166 + 64)) += int64(v165)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v168 = envPtr2 + 152
		v167 = *(*uintptr)(unsafe.Pointer(v168))
		*(*uintptr)(unsafe.Pointer(v168))++
		*(*uint8)(unsafe.Pointer(v167)) = uint8(libc.Uint32FromInt32(workerIndex) >> libc.Int32FromInt32(24))
		v170 = envPtr2 + 152
		v169 = *(*uintptr)(unsafe.Pointer(v170))
		*(*uintptr)(unsafe.Pointer(v170))++
		*(*uint8)(unsafe.Pointer(v169)) = uint8(libc.Uint32FromInt32(workerIndex) >> libc.Int32FromInt32(16))
		v172 = envPtr2 + 152
		v171 = *(*uintptr)(unsafe.Pointer(v172))
		*(*uintptr)(unsafe.Pointer(v172))++
		*(*uint8)(unsafe.Pointer(v171)) = uint8(libc.Uint32FromInt32(workerIndex) >> libc.Int32FromInt32(8))
		v174 = envPtr2 + 152
		v173 = *(*uintptr)(unsafe.Pointer(v174))
		*(*uintptr)(unsafe.Pointer(v174))++
		*(*uint8)(unsafe.Pointer(v173)) = uint8(libc.Uint32FromInt32(workerIndex))
		v175 = -int32(1)
		v176 = envPtr2
		if v175 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v176)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v176)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v176)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v176)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v176 + 64)) += int64(v175)
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v178 = envPtr2 + 152
		v177 = *(*uintptr)(unsafe.Pointer(v178))
		*(*uintptr)(unsafe.Pointer(v178))++
		*(*uint8)(unsafe.Pointer(v177)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v179 = delta1
			v180 = envPtr2
			if v179 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v180)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v180)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v180)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v180)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v180 + 64)) += int64(v179)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v182 = envPtr2 + 152
		v181 = *(*uintptr)(unsafe.Pointer(v182))
		*(*uintptr)(unsafe.Pointer(v182))++
		*(*uint8)(unsafe.Pointer(v181)) = libc.Uint8FromInt32(int32(INST_DICT_NEXT))
		v184 = envPtr2 + 152
		v183 = *(*uintptr)(unsafe.Pointer(v184))
		*(*uintptr)(unsafe.Pointer(v184))++
		*(*uint8)(unsafe.Pointer(v183)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(24))
		v186 = envPtr2 + 152
		v185 = *(*uintptr)(unsafe.Pointer(v186))
		*(*uintptr)(unsafe.Pointer(v186))++
		*(*uint8)(unsafe.Pointer(v185)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(16))
		v188 = envPtr2 + 152
		v187 = *(*uintptr)(unsafe.Pointer(v188))
		*(*uintptr)(unsafe.Pointer(v188))++
		*(*uint8)(unsafe.Pointer(v187)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(8))
		v190 = envPtr2 + 152
		v189 = *(*uintptr)(unsafe.Pointer(v190))
		*(*uintptr)(unsafe.Pointer(v190))++
		*(*uint8)(unsafe.Pointer(v189)) = uint8(libc.Uint32FromInt32(infoIndex))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_DICT_NEXT)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - infoIndex
			}
			v191 = delta1
			v192 = envPtr2
			if v191 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v192)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v192)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v192)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v192)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v192 + 64)) += int64(v191)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v194 = envPtr2 + 152
		v193 = *(*uintptr)(unsafe.Pointer(v194))
		*(*uintptr)(unsafe.Pointer(v194))++
		*(*uint8)(unsafe.Pointer(v193)) = libc.Uint8FromInt32(int32(INST_JUMP_FALSE1))
		v196 = envPtr2 + 152
		v195 = *(*uintptr)(unsafe.Pointer(v196))
		*(*uintptr)(unsafe.Pointer(v196))++
		*(*uint8)(unsafe.Pointer(v195)) = uint8(libc.Uint32FromInt32(-libc.Int32FromInt32(20)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP_FALSE1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - -int32(20)
			}
			v197 = delta1
			v198 = envPtr2
			if v197 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v198)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v198)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v198)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v198)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v198 + 64)) += int64(v197)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v200 = envPtr2 + 152
		v199 = *(*uintptr)(unsafe.Pointer(v200))
		*(*uintptr)(unsafe.Pointer(v200))++
		*(*uint8)(unsafe.Pointer(v199)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v201 = delta1
			v202 = envPtr2
			if v201 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v202)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v202)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v202)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v202)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v202 + 64)) += int64(v201)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v204 = envPtr2 + 152
		v203 = *(*uintptr)(unsafe.Pointer(v204))
		*(*uintptr)(unsafe.Pointer(v204))++
		*(*uint8)(unsafe.Pointer(v203)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v205 = delta1
			v206 = envPtr2
			if v205 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v206)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v206)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v206)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v206)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v206 + 64)) += int64(v205)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v208 = envPtr2 + 152
		v207 = *(*uintptr)(unsafe.Pointer(v208))
		*(*uintptr)(unsafe.Pointer(v208))++
		*(*uint8)(unsafe.Pointer(v207)) = libc.Uint8FromInt32(int32(INST_UNSET_SCALAR))
		v210 = envPtr2 + 152
		v209 = *(*uintptr)(unsafe.Pointer(v210))
		*(*uintptr)(unsafe.Pointer(v210))++
		*(*uint8)(unsafe.Pointer(v209)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_UNSET_SCALAR)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v211 = delta1
			v212 = envPtr2
			if v211 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v212)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v212)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v212)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v212)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v212 + 64)) += int64(v211)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v214 = envPtr2 + 152
		v213 = *(*uintptr)(unsafe.Pointer(v214))
		*(*uintptr)(unsafe.Pointer(v214))++
		*(*uint8)(unsafe.Pointer(v213)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(24))
		v216 = envPtr2 + 152
		v215 = *(*uintptr)(unsafe.Pointer(v216))
		*(*uintptr)(unsafe.Pointer(v216))++
		*(*uint8)(unsafe.Pointer(v215)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(16))
		v218 = envPtr2 + 152
		v217 = *(*uintptr)(unsafe.Pointer(v218))
		*(*uintptr)(unsafe.Pointer(v218))++
		*(*uint8)(unsafe.Pointer(v217)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(8))
		v220 = envPtr2 + 152
		v219 = *(*uintptr)(unsafe.Pointer(v220))
		*(*uintptr)(unsafe.Pointer(v220))++
		*(*uint8)(unsafe.Pointer(v219)) = uint8(libc.Uint32FromInt32(infoIndex))
		goto _106
	_106:
		;
		i1++
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth--
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(outLoop)*56))).FnumCodeBytes = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(int32((*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(outLoop)*56))).FcodeOffset))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v222 = envPtr2 + 152
	v221 = *(*uintptr)(unsafe.Pointer(v222))
	*(*uintptr)(unsafe.Pointer(v222))++
	*(*uint8)(unsafe.Pointer(v221)) = libc.Uint8FromInt32(int32(INST_END_CATCH))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_END_CATCH)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v223 = delta1
		v224 = envPtr2
		if v223 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v224)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v224)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v224)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v224)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v224 + 64)) += int64(v223)
	}
	/*
	 * Clean up any state left over.
	 */
	if workerIndex <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v226 = envPtr2 + 152
		v225 = *(*uintptr)(unsafe.Pointer(v226))
		*(*uintptr)(unsafe.Pointer(v226))++
		*(*uint8)(unsafe.Pointer(v225)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
		v228 = envPtr2 + 152
		v227 = *(*uintptr)(unsafe.Pointer(v228))
		*(*uintptr)(unsafe.Pointer(v228))++
		*(*uint8)(unsafe.Pointer(v227)) = uint8(libc.Uint32FromInt32(workerIndex))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - workerIndex
			}
			v229 = delta1
			v230 = envPtr2
			if v229 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v230)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v230)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v230)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v230)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v230 + 64)) += int64(v229)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v232 = envPtr2 + 152
		v231 = *(*uintptr)(unsafe.Pointer(v232))
		*(*uintptr)(unsafe.Pointer(v232))++
		*(*uint8)(unsafe.Pointer(v231)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
		v234 = envPtr2 + 152
		v233 = *(*uintptr)(unsafe.Pointer(v234))
		*(*uintptr)(unsafe.Pointer(v234))++
		*(*uint8)(unsafe.Pointer(v233)) = uint8(libc.Uint32FromInt32(workerIndex) >> libc.Int32FromInt32(24))
		v236 = envPtr2 + 152
		v235 = *(*uintptr)(unsafe.Pointer(v236))
		*(*uintptr)(unsafe.Pointer(v236))++
		*(*uint8)(unsafe.Pointer(v235)) = uint8(libc.Uint32FromInt32(workerIndex) >> libc.Int32FromInt32(16))
		v238 = envPtr2 + 152
		v237 = *(*uintptr)(unsafe.Pointer(v238))
		*(*uintptr)(unsafe.Pointer(v238))++
		*(*uint8)(unsafe.Pointer(v237)) = uint8(libc.Uint32FromInt32(workerIndex) >> libc.Int32FromInt32(8))
		v240 = envPtr2 + 152
		v239 = *(*uintptr)(unsafe.Pointer(v240))
		*(*uintptr)(unsafe.Pointer(v240))++
		*(*uint8)(unsafe.Pointer(v239)) = uint8(libc.Uint32FromInt32(workerIndex))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - workerIndex
			}
			v241 = delta1
			v242 = envPtr2
			if v241 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v242)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v242)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v242)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v242)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v242 + 64)) += int64(v241)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v244 = envPtr2 + 152
	v243 = *(*uintptr)(unsafe.Pointer(v244))
	*(*uintptr)(unsafe.Pointer(v244))++
	*(*uint8)(unsafe.Pointer(v243)) = libc.Uint8FromInt32(int32(INST_UNSET_SCALAR))
	v246 = envPtr2 + 152
	v245 = *(*uintptr)(unsafe.Pointer(v246))
	*(*uintptr)(unsafe.Pointer(v246))++
	*(*uint8)(unsafe.Pointer(v245)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_UNSET_SCALAR)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v247 = delta1
		v248 = envPtr2
		if v247 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v248)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v248)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v248)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v248)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v248 + 64)) += int64(v247)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v250 = envPtr2 + 152
	v249 = *(*uintptr)(unsafe.Pointer(v250))
	*(*uintptr)(unsafe.Pointer(v250))++
	*(*uint8)(unsafe.Pointer(v249)) = uint8(libc.Uint32FromInt32(workerIndex) >> libc.Int32FromInt32(24))
	v252 = envPtr2 + 152
	v251 = *(*uintptr)(unsafe.Pointer(v252))
	*(*uintptr)(unsafe.Pointer(v252))++
	*(*uint8)(unsafe.Pointer(v251)) = uint8(libc.Uint32FromInt32(workerIndex) >> libc.Int32FromInt32(16))
	v254 = envPtr2 + 152
	v253 = *(*uintptr)(unsafe.Pointer(v254))
	*(*uintptr)(unsafe.Pointer(v254))++
	*(*uint8)(unsafe.Pointer(v253)) = uint8(libc.Uint32FromInt32(workerIndex) >> libc.Int32FromInt32(8))
	v256 = envPtr2 + 152
	v255 = *(*uintptr)(unsafe.Pointer(v256))
	*(*uintptr)(unsafe.Pointer(v256))++
	*(*uint8)(unsafe.Pointer(v255)) = uint8(libc.Uint32FromInt32(workerIndex))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v258 = envPtr2 + 152
	v257 = *(*uintptr)(unsafe.Pointer(v258))
	*(*uintptr)(unsafe.Pointer(v258))++
	*(*uint8)(unsafe.Pointer(v257)) = libc.Uint8FromInt32(int32(INST_JUMP1))
	v260 = envPtr2 + 152
	v259 = *(*uintptr)(unsafe.Pointer(v260))
	*(*uintptr)(unsafe.Pointer(v260))++
	*(*uint8)(unsafe.Pointer(v259)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(18)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_JUMP1)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32(18)
		}
		v261 = delta1
		v262 = envPtr2
		if v261 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v262)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v262)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v262)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v262)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v262 + 64)) += int64(v261)
	}
	/*
	 * If an exception happens when starting to iterate over the second (and
	 * subsequent) dicts. This is strictly not necessary, but it is nice.
	 */
	v263 = -int32(1)
	v264 = envPtr2
	if v263 < libc.Int32FromInt32(0) {
		if int32((*TCompileEnv)(unsafe.Pointer(v264)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v264)).FcurrStackDepth) {
			(*TCompileEnv)(unsafe.Pointer(v264)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v264)).FcurrStackDepth
		}
	}
	*(*TTcl_Size)(unsafe.Pointer(v264 + 64)) += int64(v263)
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(outLoop)*56))).FcatchOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v266 = envPtr2 + 152
	v265 = *(*uintptr)(unsafe.Pointer(v266))
	*(*uintptr)(unsafe.Pointer(v266))++
	*(*uint8)(unsafe.Pointer(v265)) = libc.Uint8FromInt32(int32(INST_PUSH_RETURN_OPTIONS))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_PUSH_RETURN_OPTIONS)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v267 = delta1
		v268 = envPtr2
		if v267 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v268)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v268)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v268)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v268)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v268 + 64)) += int64(v267)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v270 = envPtr2 + 152
	v269 = *(*uintptr)(unsafe.Pointer(v270))
	*(*uintptr)(unsafe.Pointer(v270))++
	*(*uint8)(unsafe.Pointer(v269)) = libc.Uint8FromInt32(int32(INST_PUSH_RESULT))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_PUSH_RESULT)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v271 = delta1
		v272 = envPtr2
		if v271 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v272)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v272)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v272)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v272)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v272 + 64)) += int64(v271)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v274 = envPtr2 + 152
	v273 = *(*uintptr)(unsafe.Pointer(v274))
	*(*uintptr)(unsafe.Pointer(v274))++
	*(*uint8)(unsafe.Pointer(v273)) = libc.Uint8FromInt32(int32(INST_END_CATCH))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_END_CATCH)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v275 = delta1
		v276 = envPtr2
		if v275 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v276)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v276)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v276)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v276)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v276 + 64)) += int64(v275)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v278 = envPtr2 + 152
	v277 = *(*uintptr)(unsafe.Pointer(v278))
	*(*uintptr)(unsafe.Pointer(v278))++
	*(*uint8)(unsafe.Pointer(v277)) = libc.Uint8FromInt32(int32(INST_UNSET_SCALAR))
	v280 = envPtr2 + 152
	v279 = *(*uintptr)(unsafe.Pointer(v280))
	*(*uintptr)(unsafe.Pointer(v280))++
	*(*uint8)(unsafe.Pointer(v279)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_UNSET_SCALAR)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v281 = delta1
		v282 = envPtr2
		if v281 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v282)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v282)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v282)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v282)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v282 + 64)) += int64(v281)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v284 = envPtr2 + 152
	v283 = *(*uintptr)(unsafe.Pointer(v284))
	*(*uintptr)(unsafe.Pointer(v284))++
	*(*uint8)(unsafe.Pointer(v283)) = uint8(libc.Uint32FromInt32(workerIndex) >> libc.Int32FromInt32(24))
	v286 = envPtr2 + 152
	v285 = *(*uintptr)(unsafe.Pointer(v286))
	*(*uintptr)(unsafe.Pointer(v286))++
	*(*uint8)(unsafe.Pointer(v285)) = uint8(libc.Uint32FromInt32(workerIndex) >> libc.Int32FromInt32(16))
	v288 = envPtr2 + 152
	v287 = *(*uintptr)(unsafe.Pointer(v288))
	*(*uintptr)(unsafe.Pointer(v288))++
	*(*uint8)(unsafe.Pointer(v287)) = uint8(libc.Uint32FromInt32(workerIndex) >> libc.Int32FromInt32(8))
	v290 = envPtr2 + 152
	v289 = *(*uintptr)(unsafe.Pointer(v290))
	*(*uintptr)(unsafe.Pointer(v290))++
	*(*uint8)(unsafe.Pointer(v289)) = uint8(libc.Uint32FromInt32(workerIndex))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v292 = envPtr2 + 152
	v291 = *(*uintptr)(unsafe.Pointer(v292))
	*(*uintptr)(unsafe.Pointer(v292))++
	*(*uint8)(unsafe.Pointer(v291)) = libc.Uint8FromInt32(int32(INST_UNSET_SCALAR))
	v294 = envPtr2 + 152
	v293 = *(*uintptr)(unsafe.Pointer(v294))
	*(*uintptr)(unsafe.Pointer(v294))++
	*(*uint8)(unsafe.Pointer(v293)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_UNSET_SCALAR)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v295 = delta1
		v296 = envPtr2
		if v295 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v296)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v296)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v296)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v296)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v296 + 64)) += int64(v295)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v298 = envPtr2 + 152
	v297 = *(*uintptr)(unsafe.Pointer(v298))
	*(*uintptr)(unsafe.Pointer(v298))++
	*(*uint8)(unsafe.Pointer(v297)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(24))
	v300 = envPtr2 + 152
	v299 = *(*uintptr)(unsafe.Pointer(v300))
	*(*uintptr)(unsafe.Pointer(v300))++
	*(*uint8)(unsafe.Pointer(v299)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(16))
	v302 = envPtr2 + 152
	v301 = *(*uintptr)(unsafe.Pointer(v302))
	*(*uintptr)(unsafe.Pointer(v302))++
	*(*uint8)(unsafe.Pointer(v301)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(8))
	v304 = envPtr2 + 152
	v303 = *(*uintptr)(unsafe.Pointer(v304))
	*(*uintptr)(unsafe.Pointer(v304))++
	*(*uint8)(unsafe.Pointer(v303)) = uint8(libc.Uint32FromInt32(infoIndex))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v306 = envPtr2 + 152
	v305 = *(*uintptr)(unsafe.Pointer(v306))
	*(*uintptr)(unsafe.Pointer(v306))++
	*(*uint8)(unsafe.Pointer(v305)) = libc.Uint8FromInt32(int32(INST_RETURN_STK))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_RETURN_STK)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v307 = delta1
		v308 = envPtr2
		if v307 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v308)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v308)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v308)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v308)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v308 + 64)) += int64(v307)
	}
	return TCL_OK
}

func XTclCompileDictForCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr uintptr) (r int32) {
	/* Holds resulting instructions. */
	return _CompileDictEachCmd(tls, interp, parsePtr, cmdPtr, envPtr, TCL_EACH_KEEP_NONE)
}

func XTclCompileDictMapCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr uintptr) (r int32) {
	/* Holds resulting instructions. */
	return _CompileDictEachCmd(tls, interp, parsePtr, cmdPtr, envPtr, int32(TCL_EACH_COLLECT))
}

func _CompileDictEachCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr2 uintptr, collect int32) (r int32) {
	bp := tls.Alloc(240)
	defer tls.Free(240) /* Flag == TCL_EACH_COLLECT to collect and
	 * construct a new dictionary with the loop
	 * body result. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, bodyTargetOffset, catchRange, collectVar, delta1, emptyTargetOffset, endTargetOffset, infoIndex, jumpDisplacement, keyVarIndex, loopRange, nameChars, valueVarIndex, v100, v112, v116, v122, v134, v138, v145, v157, v169, v17, v181, v191, v195, v199, v211, v223, v229, v23, v231, v235, v239, v243, v249, v263, v275, v279, v283, v287, v293, v307, v319, v325, v339, v35, v351, v39, v45, v5, v57, v69, v82, v94 int32
	var bodyTokenPtr, dictTokenPtr, mapPtr, varsTokenPtr, v1, v10, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v113, v114, v115, v117, v118, v119, v12, v120, v121, v123, v124, v125, v126, v127, v128, v129, v13, v130, v131, v132, v133, v135, v136, v137, v139, v14, v141, v142, v143, v144, v146, v147, v148, v149, v15, v150, v151, v152, v153, v154, v155, v156, v158, v159, v16, v160, v161, v162, v163, v164, v165, v166, v167, v168, v170, v171, v172, v173, v174, v175, v176, v177, v178, v179, v18, v180, v182, v183, v184, v185, v186, v187, v188, v189, v19, v190, v192, v193, v194, v196, v197, v198, v2, v20, v200, v201, v202, v203, v204, v205, v206, v207, v208, v209, v21, v210, v212, v213, v214, v215, v216, v217, v218, v219, v22, v220, v221, v222, v224, v225, v226, v227, v228, v230, v232, v233, v234, v236, v237, v238, v24, v240, v241, v242, v244, v245, v246, v247, v248, v25, v250, v251, v252, v253, v254, v255, v256, v257, v258, v259, v26, v260, v261, v262, v264, v265, v266, v267, v268, v269, v27, v270, v271, v272, v273, v274, v276, v277, v278, v28, v280, v281, v282, v284, v285, v286, v288, v289, v29, v290, v291, v292, v294, v295, v296, v297, v298, v299, v3, v30, v300, v301, v302, v303, v304, v305, v306, v308, v309, v31, v310, v311, v312, v313, v314, v315, v316, v317, v318, v32, v320, v321, v322, v323, v324, v326, v327, v328, v329, v33, v330, v331, v332, v333, v334, v335, v336, v337, v338, v34, v340, v341, v342, v343, v344, v345, v346, v347, v348, v349, v350, v352, v36, v37, v38, v4, v40, v41, v42, v43, v44, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v7, v70, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v95, v96, v97, v98, v99 uintptr
	var eclIndex TTcl_Size
	var v140, v71 int64
	var _ /* argv at bp+8 */ uintptr
	var _ /* buffer at bp+16 */ TTcl_DString
	var _ /* numVars at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, bodyTargetOffset, bodyTokenPtr, catchRange, collectVar, delta1, dictTokenPtr, eclIndex, emptyTargetOffset, endTargetOffset, infoIndex, jumpDisplacement, keyVarIndex, loopRange, mapPtr, nameChars, valueVarIndex, varsTokenPtr, v1, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v123, v124, v125, v126, v127, v128, v129, v13, v130, v131, v132, v133, v134, v135, v136, v137, v138, v139, v14, v140, v141, v142, v143, v144, v145, v146, v147, v148, v149, v15, v150, v151, v152, v153, v154, v155, v156, v157, v158, v159, v16, v160, v161, v162, v163, v164, v165, v166, v167, v168, v169, v17, v170, v171, v172, v173, v174, v175, v176, v177, v178, v179, v18, v180, v181, v182, v183, v184, v185, v186, v187, v188, v189, v19, v190, v191, v192, v193, v194, v195, v196, v197, v198, v199, v2, v20, v200, v201, v202, v203, v204, v205, v206, v207, v208, v209, v21, v210, v211, v212, v213, v214, v215, v216, v217, v218, v219, v22, v220, v221, v222, v223, v224, v225, v226, v227, v228, v229, v23, v230, v231, v232, v233, v234, v235, v236, v237, v238, v239, v24, v240, v241, v242, v243, v244, v245, v246, v247, v248, v249, v25, v250, v251, v252, v253, v254, v255, v256, v257, v258, v259, v26, v260, v261, v262, v263, v264, v265, v266, v267, v268, v269, v27, v270, v271, v272, v273, v274, v275, v276, v277, v278, v279, v28, v280, v281, v282, v283, v284, v285, v286, v287, v288, v289, v29, v290, v291, v292, v293, v294, v295, v296, v297, v298, v299, v3, v30, v300, v301, v302, v303, v304, v305, v306, v307, v308, v309, v31, v310, v311, v312, v313, v314, v315, v316, v317, v318, v319, v32, v320, v321, v322, v323, v324, v325, v326, v327, v328, v329, v33, v330, v331, v332, v333, v334, v335, v336, v337, v338, v339, v34, v340, v341, v342, v343, v344, v345, v346, v347, v348, v349, v35, v350, v351, v352, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	collectVar = -int32(1)
	/*
	 * There must be three arguments after the command.
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(4) {
		return XTclCompileBasic3ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
	}
	varsTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	dictTokenPtr = varsTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(varsTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	bodyTokenPtr = dictTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(dictTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(varsTokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) || (*TTcl_Token)(unsafe.Pointer(bodyTokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) {
		return XTclCompileBasic3ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
	}
	/*
	 * Create temporary variable to capture return values from loop body when
	 * we're collecting results.
	 */
	if collect == int32(TCL_EACH_COLLECT) {
		collectVar = int32(XTclFindCompiledLocal(tls, libc.UintptrFromInt32(0), 0, int32(1), envPtr2))
		if collectVar < 0 {
			return XTclCompileBasic3ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
		}
	}
	/*
	 * Check we've got a pair of variables and that they are local variables.
	 * Then extract their indices in the LVT.
	 */
	XTcl_DStringInit(tls, bp+16)
	XTcl_DStringAppend(tls, bp+16, (*TTcl_Token)(unsafe.Pointer(varsTokenPtr+1*32)).Fstart, (*TTcl_Token)(unsafe.Pointer(varsTokenPtr+1*32)).Fsize)
	if XTcl_SplitList(tls, libc.UintptrFromInt32(0), (*TTcl_DString)(unsafe.Pointer(bp+16)).Fstring1, bp, bp+8) != TCL_OK {
		XTcl_DStringFree(tls, bp+16)
		return XTclCompileBasic3ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
	}
	XTcl_DStringFree(tls, bp+16)
	if *(*TTcl_Size)(unsafe.Pointer(bp)) != int64(2) {
		XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
		return XTclCompileBasic3ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
	}
	nameChars = libc.Int32FromUint64(libc.Xstrlen(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))))
	keyVarIndex = libc.Int32FromUint64(XTclLocalScalar(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))), libc.Uint64FromInt32(nameChars), envPtr2))
	nameChars = libc.Int32FromUint64(libc.Xstrlen(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*8))))
	valueVarIndex = libc.Int32FromUint64(XTclLocalScalar(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*8)), libc.Uint64FromInt32(nameChars), envPtr2))
	XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
	if keyVarIndex < 0 || valueVarIndex < 0 {
		return XTclCompileBasic3ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
	}
	/*
	 * Allocate a temporary variable to store the iterator reference. The
	 * variable will contain a Tcl_DictSearch reference which will be
	 * allocated by INST_DICT_FIRST and disposed when the variable is unset
	 * (at which point it should also have been finished with).
	 */
	infoIndex = int32(XTclFindCompiledLocal(tls, libc.UintptrFromInt32(0), 0, int32(1), envPtr2))
	if infoIndex < 0 {
		return XTclCompileBasic3ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
	}
	/*
	 * Preparation complete; issue instructions. Note that this code issues
	 * fixed-sized jumps. That simplifies things a lot!
	 *
	 * First up, initialize the accumulator dictionary if needed.
	 */
	if collect == int32(TCL_EACH_COLLECT) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
		if collectVar <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v20 = envPtr2 + 152
			v19 = *(*uintptr)(unsafe.Pointer(v20))
			*(*uintptr)(unsafe.Pointer(v20))++
			*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
			v22 = envPtr2 + 152
			v21 = *(*uintptr)(unsafe.Pointer(v22))
			*(*uintptr)(unsafe.Pointer(v22))++
			*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(collectVar))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - collectVar
				}
				v23 = delta1
				v24 = envPtr2
				if v23 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v24 + 64)) += int64(v23)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v26 = envPtr2 + 152
			v25 = *(*uintptr)(unsafe.Pointer(v26))
			*(*uintptr)(unsafe.Pointer(v26))++
			*(*uint8)(unsafe.Pointer(v25)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
			v28 = envPtr2 + 152
			v27 = *(*uintptr)(unsafe.Pointer(v28))
			*(*uintptr)(unsafe.Pointer(v28))++
			*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(collectVar) >> libc.Int32FromInt32(24))
			v30 = envPtr2 + 152
			v29 = *(*uintptr)(unsafe.Pointer(v30))
			*(*uintptr)(unsafe.Pointer(v30))++
			*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(collectVar) >> libc.Int32FromInt32(16))
			v32 = envPtr2 + 152
			v31 = *(*uintptr)(unsafe.Pointer(v32))
			*(*uintptr)(unsafe.Pointer(v32))++
			*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(collectVar) >> libc.Int32FromInt32(8))
			v34 = envPtr2 + 152
			v33 = *(*uintptr)(unsafe.Pointer(v34))
			*(*uintptr)(unsafe.Pointer(v34))++
			*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(collectVar))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - collectVar
				}
				v35 = delta1
				v36 = envPtr2
				if v35 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v36 + 64)) += int64(v35)
			}
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v38 = envPtr2 + 152
		v37 = *(*uintptr)(unsafe.Pointer(v38))
		*(*uintptr)(unsafe.Pointer(v38))++
		*(*uint8)(unsafe.Pointer(v37)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v39 = delta1
			v40 = envPtr2
			if v39 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v40 + 64)) += int64(v39)
		}
	}
	/*
	 * Get the dictionary and start the iteration. No catching of errors at
	 * this point.
	 */
	if (*TTcl_Token)(unsafe.Pointer(dictTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(dictTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(dictTokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy1 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v42 = envPtr2 + 152
			v41 = *(*uintptr)(unsafe.Pointer(v42))
			*(*uintptr)(unsafe.Pointer(v42))++
			*(*uint8)(unsafe.Pointer(v41)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v44 = envPtr2 + 152
			v43 = *(*uintptr)(unsafe.Pointer(v44))
			*(*uintptr)(unsafe.Pointer(v44))++
			*(*uint8)(unsafe.Pointer(v43)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v45 = delta1
				v46 = envPtr2
				if v45 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v46)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v46)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v46)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v46)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v46 + 64)) += int64(v45)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v48 = envPtr2 + 152
			v47 = *(*uintptr)(unsafe.Pointer(v48))
			*(*uintptr)(unsafe.Pointer(v48))++
			*(*uint8)(unsafe.Pointer(v47)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v50 = envPtr2 + 152
			v49 = *(*uintptr)(unsafe.Pointer(v50))
			*(*uintptr)(unsafe.Pointer(v50))++
			*(*uint8)(unsafe.Pointer(v49)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
			v52 = envPtr2 + 152
			v51 = *(*uintptr)(unsafe.Pointer(v52))
			*(*uintptr)(unsafe.Pointer(v52))++
			*(*uint8)(unsafe.Pointer(v51)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
			v54 = envPtr2 + 152
			v53 = *(*uintptr)(unsafe.Pointer(v54))
			*(*uintptr)(unsafe.Pointer(v54))++
			*(*uint8)(unsafe.Pointer(v53)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
			v56 = envPtr2 + 152
			v55 = *(*uintptr)(unsafe.Pointer(v56))
			*(*uintptr)(unsafe.Pointer(v56))++
			*(*uint8)(unsafe.Pointer(v55)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v57 = delta1
				v58 = envPtr2
				if v57 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v58)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v58)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v58)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v58)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v58 + 64)) += int64(v57)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
		XTclCompileTokens(tls, interp, dictTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(dictTokenPtr)).FnumComponents), envPtr2)
	}
	/*
	 * Now we catch errors from here on so that we can finalize the search
	 * started by Tcl_DictObjFirst above.
	 */
	catchRange = int32(XTclCreateExceptRange(tls, int32(CATCH_EXCEPTION_RANGE), envPtr2))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v60 = envPtr2 + 152
	v59 = *(*uintptr)(unsafe.Pointer(v60))
	*(*uintptr)(unsafe.Pointer(v60))++
	*(*uint8)(unsafe.Pointer(v59)) = libc.Uint8FromInt32(int32(INST_BEGIN_CATCH4))
	v62 = envPtr2 + 152
	v61 = *(*uintptr)(unsafe.Pointer(v62))
	*(*uintptr)(unsafe.Pointer(v62))++
	*(*uint8)(unsafe.Pointer(v61)) = uint8(libc.Uint32FromInt32(catchRange) >> libc.Int32FromInt32(24))
	v64 = envPtr2 + 152
	v63 = *(*uintptr)(unsafe.Pointer(v64))
	*(*uintptr)(unsafe.Pointer(v64))++
	*(*uint8)(unsafe.Pointer(v63)) = uint8(libc.Uint32FromInt32(catchRange) >> libc.Int32FromInt32(16))
	v66 = envPtr2 + 152
	v65 = *(*uintptr)(unsafe.Pointer(v66))
	*(*uintptr)(unsafe.Pointer(v66))++
	*(*uint8)(unsafe.Pointer(v65)) = uint8(libc.Uint32FromInt32(catchRange) >> libc.Int32FromInt32(8))
	v68 = envPtr2 + 152
	v67 = *(*uintptr)(unsafe.Pointer(v68))
	*(*uintptr)(unsafe.Pointer(v68))++
	*(*uint8)(unsafe.Pointer(v67)) = uint8(libc.Uint32FromInt32(catchRange))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_BEGIN_CATCH4)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - catchRange
		}
		v69 = delta1
		v70 = envPtr2
		if v69 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v70 + 64)) += int64(v69)
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth++
	if libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth)+uint64(1) > libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth)+uint64(1) {
		v71 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth
	} else {
		v71 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth = v71
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(catchRange)*56))).FcodeOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v73 = envPtr2 + 152
	v72 = *(*uintptr)(unsafe.Pointer(v73))
	*(*uintptr)(unsafe.Pointer(v73))++
	*(*uint8)(unsafe.Pointer(v72)) = libc.Uint8FromInt32(int32(INST_DICT_FIRST))
	v75 = envPtr2 + 152
	v74 = *(*uintptr)(unsafe.Pointer(v75))
	*(*uintptr)(unsafe.Pointer(v75))++
	*(*uint8)(unsafe.Pointer(v74)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(24))
	v77 = envPtr2 + 152
	v76 = *(*uintptr)(unsafe.Pointer(v77))
	*(*uintptr)(unsafe.Pointer(v77))++
	*(*uint8)(unsafe.Pointer(v76)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(16))
	v79 = envPtr2 + 152
	v78 = *(*uintptr)(unsafe.Pointer(v79))
	*(*uintptr)(unsafe.Pointer(v79))++
	*(*uint8)(unsafe.Pointer(v78)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(8))
	v81 = envPtr2 + 152
	v80 = *(*uintptr)(unsafe.Pointer(v81))
	*(*uintptr)(unsafe.Pointer(v81))++
	*(*uint8)(unsafe.Pointer(v80)) = uint8(libc.Uint32FromInt32(infoIndex))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_DICT_FIRST)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - infoIndex
		}
		v82 = delta1
		v83 = envPtr2
		if v82 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v83)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v83)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v83)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v83)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v83 + 64)) += int64(v82)
	}
	emptyTargetOffset = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v85 = envPtr2 + 152
	v84 = *(*uintptr)(unsafe.Pointer(v85))
	*(*uintptr)(unsafe.Pointer(v85))++
	*(*uint8)(unsafe.Pointer(v84)) = libc.Uint8FromInt32(int32(INST_JUMP_TRUE4))
	v87 = envPtr2 + 152
	v86 = *(*uintptr)(unsafe.Pointer(v87))
	*(*uintptr)(unsafe.Pointer(v87))++
	*(*uint8)(unsafe.Pointer(v86)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
	v89 = envPtr2 + 152
	v88 = *(*uintptr)(unsafe.Pointer(v89))
	*(*uintptr)(unsafe.Pointer(v89))++
	*(*uint8)(unsafe.Pointer(v88)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
	v91 = envPtr2 + 152
	v90 = *(*uintptr)(unsafe.Pointer(v91))
	*(*uintptr)(unsafe.Pointer(v91))++
	*(*uint8)(unsafe.Pointer(v90)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
	v93 = envPtr2 + 152
	v92 = *(*uintptr)(unsafe.Pointer(v93))
	*(*uintptr)(unsafe.Pointer(v93))++
	*(*uint8)(unsafe.Pointer(v92)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_JUMP_TRUE4)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v94 = delta1
		v95 = envPtr2
		if v94 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v95)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v95)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v95)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v95)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v95 + 64)) += int64(v94)
	}
	/*
	 * Inside the iteration, write the loop variables.
	 */
	bodyTargetOffset = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
	if keyVarIndex <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v97 = envPtr2 + 152
		v96 = *(*uintptr)(unsafe.Pointer(v97))
		*(*uintptr)(unsafe.Pointer(v97))++
		*(*uint8)(unsafe.Pointer(v96)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
		v99 = envPtr2 + 152
		v98 = *(*uintptr)(unsafe.Pointer(v99))
		*(*uintptr)(unsafe.Pointer(v99))++
		*(*uint8)(unsafe.Pointer(v98)) = uint8(libc.Uint32FromInt32(keyVarIndex))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - keyVarIndex
			}
			v100 = delta1
			v101 = envPtr2
			if v100 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v101)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v101)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v101)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v101)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v101 + 64)) += int64(v100)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v103 = envPtr2 + 152
		v102 = *(*uintptr)(unsafe.Pointer(v103))
		*(*uintptr)(unsafe.Pointer(v103))++
		*(*uint8)(unsafe.Pointer(v102)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
		v105 = envPtr2 + 152
		v104 = *(*uintptr)(unsafe.Pointer(v105))
		*(*uintptr)(unsafe.Pointer(v105))++
		*(*uint8)(unsafe.Pointer(v104)) = uint8(libc.Uint32FromInt32(keyVarIndex) >> libc.Int32FromInt32(24))
		v107 = envPtr2 + 152
		v106 = *(*uintptr)(unsafe.Pointer(v107))
		*(*uintptr)(unsafe.Pointer(v107))++
		*(*uint8)(unsafe.Pointer(v106)) = uint8(libc.Uint32FromInt32(keyVarIndex) >> libc.Int32FromInt32(16))
		v109 = envPtr2 + 152
		v108 = *(*uintptr)(unsafe.Pointer(v109))
		*(*uintptr)(unsafe.Pointer(v109))++
		*(*uint8)(unsafe.Pointer(v108)) = uint8(libc.Uint32FromInt32(keyVarIndex) >> libc.Int32FromInt32(8))
		v111 = envPtr2 + 152
		v110 = *(*uintptr)(unsafe.Pointer(v111))
		*(*uintptr)(unsafe.Pointer(v111))++
		*(*uint8)(unsafe.Pointer(v110)) = uint8(libc.Uint32FromInt32(keyVarIndex))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - keyVarIndex
			}
			v112 = delta1
			v113 = envPtr2
			if v112 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v113)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v113)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v113)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v113)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v113 + 64)) += int64(v112)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v115 = envPtr2 + 152
	v114 = *(*uintptr)(unsafe.Pointer(v115))
	*(*uintptr)(unsafe.Pointer(v115))++
	*(*uint8)(unsafe.Pointer(v114)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v116 = delta1
		v117 = envPtr2
		if v116 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v117)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v117)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v117)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v117)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v117 + 64)) += int64(v116)
	}
	if valueVarIndex <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v119 = envPtr2 + 152
		v118 = *(*uintptr)(unsafe.Pointer(v119))
		*(*uintptr)(unsafe.Pointer(v119))++
		*(*uint8)(unsafe.Pointer(v118)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
		v121 = envPtr2 + 152
		v120 = *(*uintptr)(unsafe.Pointer(v121))
		*(*uintptr)(unsafe.Pointer(v121))++
		*(*uint8)(unsafe.Pointer(v120)) = uint8(libc.Uint32FromInt32(valueVarIndex))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - valueVarIndex
			}
			v122 = delta1
			v123 = envPtr2
			if v122 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v123)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v123)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v123)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v123)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v123 + 64)) += int64(v122)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v125 = envPtr2 + 152
		v124 = *(*uintptr)(unsafe.Pointer(v125))
		*(*uintptr)(unsafe.Pointer(v125))++
		*(*uint8)(unsafe.Pointer(v124)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
		v127 = envPtr2 + 152
		v126 = *(*uintptr)(unsafe.Pointer(v127))
		*(*uintptr)(unsafe.Pointer(v127))++
		*(*uint8)(unsafe.Pointer(v126)) = uint8(libc.Uint32FromInt32(valueVarIndex) >> libc.Int32FromInt32(24))
		v129 = envPtr2 + 152
		v128 = *(*uintptr)(unsafe.Pointer(v129))
		*(*uintptr)(unsafe.Pointer(v129))++
		*(*uint8)(unsafe.Pointer(v128)) = uint8(libc.Uint32FromInt32(valueVarIndex) >> libc.Int32FromInt32(16))
		v131 = envPtr2 + 152
		v130 = *(*uintptr)(unsafe.Pointer(v131))
		*(*uintptr)(unsafe.Pointer(v131))++
		*(*uint8)(unsafe.Pointer(v130)) = uint8(libc.Uint32FromInt32(valueVarIndex) >> libc.Int32FromInt32(8))
		v133 = envPtr2 + 152
		v132 = *(*uintptr)(unsafe.Pointer(v133))
		*(*uintptr)(unsafe.Pointer(v133))++
		*(*uint8)(unsafe.Pointer(v132)) = uint8(libc.Uint32FromInt32(valueVarIndex))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - valueVarIndex
			}
			v134 = delta1
			v135 = envPtr2
			if v134 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v135)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v135)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v135)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v135)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v135 + 64)) += int64(v134)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v137 = envPtr2 + 152
	v136 = *(*uintptr)(unsafe.Pointer(v137))
	*(*uintptr)(unsafe.Pointer(v137))++
	*(*uint8)(unsafe.Pointer(v136)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v138 = delta1
		v139 = envPtr2
		if v138 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v139)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v139)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v139)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v139)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v139 + 64)) += int64(v138)
	}
	/*
	 * Set up the loop exception targets.
	 */
	loopRange = int32(XTclCreateExceptRange(tls, int32(LOOP_EXCEPTION_RANGE), envPtr2))
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth++
	if libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth)+uint64(1) > libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth)+uint64(1) {
		v140 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth
	} else {
		v140 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth = v140
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(loopRange)*56))).FcodeOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	/*
	 * Compile the loop body itself. It should be stack-neutral.
	 */
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 3*8))
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 3*8))
	XTclCompileCmdWord(tls, interp, bodyTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(bodyTokenPtr)).FnumComponents), envPtr2)
	if collect == int32(TCL_EACH_COLLECT) {
		if keyVarIndex <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v142 = envPtr2 + 152
			v141 = *(*uintptr)(unsafe.Pointer(v142))
			*(*uintptr)(unsafe.Pointer(v142))++
			*(*uint8)(unsafe.Pointer(v141)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
			v144 = envPtr2 + 152
			v143 = *(*uintptr)(unsafe.Pointer(v144))
			*(*uintptr)(unsafe.Pointer(v144))++
			*(*uint8)(unsafe.Pointer(v143)) = uint8(libc.Uint32FromInt32(keyVarIndex))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - keyVarIndex
				}
				v145 = delta1
				v146 = envPtr2
				if v145 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v146)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v146)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v146)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v146)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v146 + 64)) += int64(v145)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v148 = envPtr2 + 152
			v147 = *(*uintptr)(unsafe.Pointer(v148))
			*(*uintptr)(unsafe.Pointer(v148))++
			*(*uint8)(unsafe.Pointer(v147)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
			v150 = envPtr2 + 152
			v149 = *(*uintptr)(unsafe.Pointer(v150))
			*(*uintptr)(unsafe.Pointer(v150))++
			*(*uint8)(unsafe.Pointer(v149)) = uint8(libc.Uint32FromInt32(keyVarIndex) >> libc.Int32FromInt32(24))
			v152 = envPtr2 + 152
			v151 = *(*uintptr)(unsafe.Pointer(v152))
			*(*uintptr)(unsafe.Pointer(v152))++
			*(*uint8)(unsafe.Pointer(v151)) = uint8(libc.Uint32FromInt32(keyVarIndex) >> libc.Int32FromInt32(16))
			v154 = envPtr2 + 152
			v153 = *(*uintptr)(unsafe.Pointer(v154))
			*(*uintptr)(unsafe.Pointer(v154))++
			*(*uint8)(unsafe.Pointer(v153)) = uint8(libc.Uint32FromInt32(keyVarIndex) >> libc.Int32FromInt32(8))
			v156 = envPtr2 + 152
			v155 = *(*uintptr)(unsafe.Pointer(v156))
			*(*uintptr)(unsafe.Pointer(v156))++
			*(*uint8)(unsafe.Pointer(v155)) = uint8(libc.Uint32FromInt32(keyVarIndex))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - keyVarIndex
				}
				v157 = delta1
				v158 = envPtr2
				if v157 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v158)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v158)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v158)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v158)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v158 + 64)) += int64(v157)
			}
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v160 = envPtr2 + 152
		v159 = *(*uintptr)(unsafe.Pointer(v160))
		*(*uintptr)(unsafe.Pointer(v160))++
		*(*uint8)(unsafe.Pointer(v159)) = libc.Uint8FromInt32(int32(INST_OVER))
		v162 = envPtr2 + 152
		v161 = *(*uintptr)(unsafe.Pointer(v162))
		*(*uintptr)(unsafe.Pointer(v162))++
		*(*uint8)(unsafe.Pointer(v161)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(24))
		v164 = envPtr2 + 152
		v163 = *(*uintptr)(unsafe.Pointer(v164))
		*(*uintptr)(unsafe.Pointer(v164))++
		*(*uint8)(unsafe.Pointer(v163)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(16))
		v166 = envPtr2 + 152
		v165 = *(*uintptr)(unsafe.Pointer(v166))
		*(*uintptr)(unsafe.Pointer(v166))++
		*(*uint8)(unsafe.Pointer(v165)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(8))
		v168 = envPtr2 + 152
		v167 = *(*uintptr)(unsafe.Pointer(v168))
		*(*uintptr)(unsafe.Pointer(v168))++
		*(*uint8)(unsafe.Pointer(v167)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_OVER)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(1)
			}
			v169 = delta1
			v170 = envPtr2
			if v169 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v170)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v170)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v170)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v170)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v170 + 64)) += int64(v169)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v172 = envPtr2 + 152
		v171 = *(*uintptr)(unsafe.Pointer(v172))
		*(*uintptr)(unsafe.Pointer(v172))++
		*(*uint8)(unsafe.Pointer(v171)) = libc.Uint8FromInt32(int32(INST_DICT_SET))
		v174 = envPtr2 + 152
		v173 = *(*uintptr)(unsafe.Pointer(v174))
		*(*uintptr)(unsafe.Pointer(v174))++
		*(*uint8)(unsafe.Pointer(v173)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(24))
		v176 = envPtr2 + 152
		v175 = *(*uintptr)(unsafe.Pointer(v176))
		*(*uintptr)(unsafe.Pointer(v176))++
		*(*uint8)(unsafe.Pointer(v175)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(16))
		v178 = envPtr2 + 152
		v177 = *(*uintptr)(unsafe.Pointer(v178))
		*(*uintptr)(unsafe.Pointer(v178))++
		*(*uint8)(unsafe.Pointer(v177)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(8))
		v180 = envPtr2 + 152
		v179 = *(*uintptr)(unsafe.Pointer(v180))
		*(*uintptr)(unsafe.Pointer(v180))++
		*(*uint8)(unsafe.Pointer(v179)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_DICT_SET)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(1)
			}
			v181 = delta1
			v182 = envPtr2
			if v181 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v182)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v182)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v182)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v182)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v182 + 64)) += int64(v181)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v184 = envPtr2 + 152
		v183 = *(*uintptr)(unsafe.Pointer(v184))
		*(*uintptr)(unsafe.Pointer(v184))++
		*(*uint8)(unsafe.Pointer(v183)) = uint8(libc.Uint32FromInt32(collectVar) >> libc.Int32FromInt32(24))
		v186 = envPtr2 + 152
		v185 = *(*uintptr)(unsafe.Pointer(v186))
		*(*uintptr)(unsafe.Pointer(v186))++
		*(*uint8)(unsafe.Pointer(v185)) = uint8(libc.Uint32FromInt32(collectVar) >> libc.Int32FromInt32(16))
		v188 = envPtr2 + 152
		v187 = *(*uintptr)(unsafe.Pointer(v188))
		*(*uintptr)(unsafe.Pointer(v188))++
		*(*uint8)(unsafe.Pointer(v187)) = uint8(libc.Uint32FromInt32(collectVar) >> libc.Int32FromInt32(8))
		v190 = envPtr2 + 152
		v189 = *(*uintptr)(unsafe.Pointer(v190))
		*(*uintptr)(unsafe.Pointer(v190))++
		*(*uint8)(unsafe.Pointer(v189)) = uint8(libc.Uint32FromInt32(collectVar))
		v191 = -int32(1)
		v192 = envPtr2
		if v191 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v192)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v192)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v192)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v192)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v192 + 64)) += int64(v191)
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v194 = envPtr2 + 152
		v193 = *(*uintptr)(unsafe.Pointer(v194))
		*(*uintptr)(unsafe.Pointer(v194))++
		*(*uint8)(unsafe.Pointer(v193)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v195 = delta1
			v196 = envPtr2
			if v195 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v196)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v196)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v196)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v196)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v196 + 64)) += int64(v195)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v198 = envPtr2 + 152
	v197 = *(*uintptr)(unsafe.Pointer(v198))
	*(*uintptr)(unsafe.Pointer(v198))++
	*(*uint8)(unsafe.Pointer(v197)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v199 = delta1
		v200 = envPtr2
		if v199 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v200)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v200)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v200)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v200)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v200 + 64)) += int64(v199)
	}
	/*
	 * Both exception target ranges (error and loop) end here.
	 */
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth--
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(loopRange)*56))).FnumCodeBytes = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(int32((*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(loopRange)*56))).FcodeOffset))
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth--
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(catchRange)*56))).FnumCodeBytes = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(int32((*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(catchRange)*56))).FcodeOffset))
	/*
	 * Continue (or just normally process) by getting the next pair of items
	 * from the dictionary and jumping back to the code to write them into
	 * variables if there is another pair.
	 */
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(loopRange)*56))).FcontinueOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v202 = envPtr2 + 152
	v201 = *(*uintptr)(unsafe.Pointer(v202))
	*(*uintptr)(unsafe.Pointer(v202))++
	*(*uint8)(unsafe.Pointer(v201)) = libc.Uint8FromInt32(int32(INST_DICT_NEXT))
	v204 = envPtr2 + 152
	v203 = *(*uintptr)(unsafe.Pointer(v204))
	*(*uintptr)(unsafe.Pointer(v204))++
	*(*uint8)(unsafe.Pointer(v203)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(24))
	v206 = envPtr2 + 152
	v205 = *(*uintptr)(unsafe.Pointer(v206))
	*(*uintptr)(unsafe.Pointer(v206))++
	*(*uint8)(unsafe.Pointer(v205)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(16))
	v208 = envPtr2 + 152
	v207 = *(*uintptr)(unsafe.Pointer(v208))
	*(*uintptr)(unsafe.Pointer(v208))++
	*(*uint8)(unsafe.Pointer(v207)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(8))
	v210 = envPtr2 + 152
	v209 = *(*uintptr)(unsafe.Pointer(v210))
	*(*uintptr)(unsafe.Pointer(v210))++
	*(*uint8)(unsafe.Pointer(v209)) = uint8(libc.Uint32FromInt32(infoIndex))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_DICT_NEXT)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - infoIndex
		}
		v211 = delta1
		v212 = envPtr2
		if v211 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v212)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v212)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v212)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v212)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v212 + 64)) += int64(v211)
	}
	jumpDisplacement = int32(int64(bodyTargetOffset) - (int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v214 = envPtr2 + 152
	v213 = *(*uintptr)(unsafe.Pointer(v214))
	*(*uintptr)(unsafe.Pointer(v214))++
	*(*uint8)(unsafe.Pointer(v213)) = libc.Uint8FromInt32(int32(INST_JUMP_FALSE4))
	v216 = envPtr2 + 152
	v215 = *(*uintptr)(unsafe.Pointer(v216))
	*(*uintptr)(unsafe.Pointer(v216))++
	*(*uint8)(unsafe.Pointer(v215)) = uint8(libc.Uint32FromInt32(jumpDisplacement) >> libc.Int32FromInt32(24))
	v218 = envPtr2 + 152
	v217 = *(*uintptr)(unsafe.Pointer(v218))
	*(*uintptr)(unsafe.Pointer(v218))++
	*(*uint8)(unsafe.Pointer(v217)) = uint8(libc.Uint32FromInt32(jumpDisplacement) >> libc.Int32FromInt32(16))
	v220 = envPtr2 + 152
	v219 = *(*uintptr)(unsafe.Pointer(v220))
	*(*uintptr)(unsafe.Pointer(v220))++
	*(*uint8)(unsafe.Pointer(v219)) = uint8(libc.Uint32FromInt32(jumpDisplacement) >> libc.Int32FromInt32(8))
	v222 = envPtr2 + 152
	v221 = *(*uintptr)(unsafe.Pointer(v222))
	*(*uintptr)(unsafe.Pointer(v222))++
	*(*uint8)(unsafe.Pointer(v221)) = uint8(libc.Uint32FromInt32(jumpDisplacement))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_JUMP_FALSE4)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - jumpDisplacement
		}
		v223 = delta1
		v224 = envPtr2
		if v223 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v224)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v224)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v224)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v224)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v224 + 64)) += int64(v223)
	}
	endTargetOffset = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v226 = envPtr2 + 152
	v225 = *(*uintptr)(unsafe.Pointer(v226))
	*(*uintptr)(unsafe.Pointer(v226))++
	*(*uint8)(unsafe.Pointer(v225)) = libc.Uint8FromInt32(int32(INST_JUMP1))
	v228 = envPtr2 + 152
	v227 = *(*uintptr)(unsafe.Pointer(v228))
	*(*uintptr)(unsafe.Pointer(v228))++
	*(*uint8)(unsafe.Pointer(v227)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_JUMP1)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v229 = delta1
		v230 = envPtr2
		if v229 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v230)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v230)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v230)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v230)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v230 + 64)) += int64(v229)
	}
	/*
	 * Error handler "finally" clause, which force-terminates the iteration
	 * and re-throws the error.
	 */
	v231 = -int32(1)
	v232 = envPtr2
	if v231 < libc.Int32FromInt32(0) {
		if int32((*TCompileEnv)(unsafe.Pointer(v232)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v232)).FcurrStackDepth) {
			(*TCompileEnv)(unsafe.Pointer(v232)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v232)).FcurrStackDepth
		}
	}
	*(*TTcl_Size)(unsafe.Pointer(v232 + 64)) += int64(v231)
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(catchRange)*56))).FcatchOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v234 = envPtr2 + 152
	v233 = *(*uintptr)(unsafe.Pointer(v234))
	*(*uintptr)(unsafe.Pointer(v234))++
	*(*uint8)(unsafe.Pointer(v233)) = libc.Uint8FromInt32(int32(INST_PUSH_RETURN_OPTIONS))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_PUSH_RETURN_OPTIONS)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v235 = delta1
		v236 = envPtr2
		if v235 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v236)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v236)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v236)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v236)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v236 + 64)) += int64(v235)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v238 = envPtr2 + 152
	v237 = *(*uintptr)(unsafe.Pointer(v238))
	*(*uintptr)(unsafe.Pointer(v238))++
	*(*uint8)(unsafe.Pointer(v237)) = libc.Uint8FromInt32(int32(INST_PUSH_RESULT))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_PUSH_RESULT)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v239 = delta1
		v240 = envPtr2
		if v239 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v240)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v240)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v240)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v240)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v240 + 64)) += int64(v239)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v242 = envPtr2 + 152
	v241 = *(*uintptr)(unsafe.Pointer(v242))
	*(*uintptr)(unsafe.Pointer(v242))++
	*(*uint8)(unsafe.Pointer(v241)) = libc.Uint8FromInt32(int32(INST_END_CATCH))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_END_CATCH)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v243 = delta1
		v244 = envPtr2
		if v243 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v244)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v244)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v244)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v244)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v244 + 64)) += int64(v243)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v246 = envPtr2 + 152
	v245 = *(*uintptr)(unsafe.Pointer(v246))
	*(*uintptr)(unsafe.Pointer(v246))++
	*(*uint8)(unsafe.Pointer(v245)) = libc.Uint8FromInt32(int32(INST_UNSET_SCALAR))
	v248 = envPtr2 + 152
	v247 = *(*uintptr)(unsafe.Pointer(v248))
	*(*uintptr)(unsafe.Pointer(v248))++
	*(*uint8)(unsafe.Pointer(v247)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_UNSET_SCALAR)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v249 = delta1
		v250 = envPtr2
		if v249 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v250)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v250)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v250)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v250)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v250 + 64)) += int64(v249)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v252 = envPtr2 + 152
	v251 = *(*uintptr)(unsafe.Pointer(v252))
	*(*uintptr)(unsafe.Pointer(v252))++
	*(*uint8)(unsafe.Pointer(v251)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(24))
	v254 = envPtr2 + 152
	v253 = *(*uintptr)(unsafe.Pointer(v254))
	*(*uintptr)(unsafe.Pointer(v254))++
	*(*uint8)(unsafe.Pointer(v253)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(16))
	v256 = envPtr2 + 152
	v255 = *(*uintptr)(unsafe.Pointer(v256))
	*(*uintptr)(unsafe.Pointer(v256))++
	*(*uint8)(unsafe.Pointer(v255)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(8))
	v258 = envPtr2 + 152
	v257 = *(*uintptr)(unsafe.Pointer(v258))
	*(*uintptr)(unsafe.Pointer(v258))++
	*(*uint8)(unsafe.Pointer(v257)) = uint8(libc.Uint32FromInt32(infoIndex))
	if collect == int32(TCL_EACH_COLLECT) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v260 = envPtr2 + 152
		v259 = *(*uintptr)(unsafe.Pointer(v260))
		*(*uintptr)(unsafe.Pointer(v260))++
		*(*uint8)(unsafe.Pointer(v259)) = libc.Uint8FromInt32(int32(INST_UNSET_SCALAR))
		v262 = envPtr2 + 152
		v261 = *(*uintptr)(unsafe.Pointer(v262))
		*(*uintptr)(unsafe.Pointer(v262))++
		*(*uint8)(unsafe.Pointer(v261)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_UNSET_SCALAR)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v263 = delta1
			v264 = envPtr2
			if v263 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v264)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v264)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v264)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v264)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v264 + 64)) += int64(v263)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v266 = envPtr2 + 152
		v265 = *(*uintptr)(unsafe.Pointer(v266))
		*(*uintptr)(unsafe.Pointer(v266))++
		*(*uint8)(unsafe.Pointer(v265)) = uint8(libc.Uint32FromInt32(collectVar) >> libc.Int32FromInt32(24))
		v268 = envPtr2 + 152
		v267 = *(*uintptr)(unsafe.Pointer(v268))
		*(*uintptr)(unsafe.Pointer(v268))++
		*(*uint8)(unsafe.Pointer(v267)) = uint8(libc.Uint32FromInt32(collectVar) >> libc.Int32FromInt32(16))
		v270 = envPtr2 + 152
		v269 = *(*uintptr)(unsafe.Pointer(v270))
		*(*uintptr)(unsafe.Pointer(v270))++
		*(*uint8)(unsafe.Pointer(v269)) = uint8(libc.Uint32FromInt32(collectVar) >> libc.Int32FromInt32(8))
		v272 = envPtr2 + 152
		v271 = *(*uintptr)(unsafe.Pointer(v272))
		*(*uintptr)(unsafe.Pointer(v272))++
		*(*uint8)(unsafe.Pointer(v271)) = uint8(libc.Uint32FromInt32(collectVar))
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v274 = envPtr2 + 152
	v273 = *(*uintptr)(unsafe.Pointer(v274))
	*(*uintptr)(unsafe.Pointer(v274))++
	*(*uint8)(unsafe.Pointer(v273)) = libc.Uint8FromInt32(int32(INST_RETURN_STK))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_RETURN_STK)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v275 = delta1
		v276 = envPtr2
		if v275 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v276)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v276)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v276)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v276)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v276 + 64)) += int64(v275)
	}
	/*
	 * Otherwise we're done (the jump after the DICT_FIRST points here) and we
	 * need to pop the bogus key/value pair (pushed to keep stack calculations
	 * easy!) Note that we skip the END_CATCH. [Bug 1382528]
	 */
	jumpDisplacement = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(emptyTargetOffset))
	*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(emptyTargetOffset))) = libc.Uint8FromInt32(int32(INST_JUMP_TRUE4))
	*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(emptyTargetOffset) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(jumpDisplacement) >> libc.Int32FromInt32(24))
	*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(emptyTargetOffset) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(jumpDisplacement) >> libc.Int32FromInt32(16))
	*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(emptyTargetOffset) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt32(jumpDisplacement) >> libc.Int32FromInt32(8))
	*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(emptyTargetOffset) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt32(jumpDisplacement))
	jumpDisplacement = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(endTargetOffset))
	*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(endTargetOffset))) = libc.Uint8FromInt32(int32(INST_JUMP1))
	*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(endTargetOffset) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(jumpDisplacement))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v278 = envPtr2 + 152
	v277 = *(*uintptr)(unsafe.Pointer(v278))
	*(*uintptr)(unsafe.Pointer(v278))++
	*(*uint8)(unsafe.Pointer(v277)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v279 = delta1
		v280 = envPtr2
		if v279 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v280)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v280)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v280)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v280)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v280 + 64)) += int64(v279)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v282 = envPtr2 + 152
	v281 = *(*uintptr)(unsafe.Pointer(v282))
	*(*uintptr)(unsafe.Pointer(v282))++
	*(*uint8)(unsafe.Pointer(v281)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v283 = delta1
		v284 = envPtr2
		if v283 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v284)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v284)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v284)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v284)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v284 + 64)) += int64(v283)
	}
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(loopRange)*56))).FbreakOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	XTclFinalizeLoopExceptionRange(tls, envPtr2, loopRange)
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v286 = envPtr2 + 152
	v285 = *(*uintptr)(unsafe.Pointer(v286))
	*(*uintptr)(unsafe.Pointer(v286))++
	*(*uint8)(unsafe.Pointer(v285)) = libc.Uint8FromInt32(int32(INST_END_CATCH))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_END_CATCH)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v287 = delta1
		v288 = envPtr2
		if v287 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v288)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v288)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v288)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v288)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v288 + 64)) += int64(v287)
	}
	/*
	 * Final stage of the command (normal case) is that we push an empty
	 * object (or push the accumulator as the result object). This is done
	 * last to promote peephole optimization when it's dropped immediately.
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v290 = envPtr2 + 152
	v289 = *(*uintptr)(unsafe.Pointer(v290))
	*(*uintptr)(unsafe.Pointer(v290))++
	*(*uint8)(unsafe.Pointer(v289)) = libc.Uint8FromInt32(int32(INST_UNSET_SCALAR))
	v292 = envPtr2 + 152
	v291 = *(*uintptr)(unsafe.Pointer(v292))
	*(*uintptr)(unsafe.Pointer(v292))++
	*(*uint8)(unsafe.Pointer(v291)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_UNSET_SCALAR)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v293 = delta1
		v294 = envPtr2
		if v293 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v294)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v294)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v294)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v294)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v294 + 64)) += int64(v293)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v296 = envPtr2 + 152
	v295 = *(*uintptr)(unsafe.Pointer(v296))
	*(*uintptr)(unsafe.Pointer(v296))++
	*(*uint8)(unsafe.Pointer(v295)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(24))
	v298 = envPtr2 + 152
	v297 = *(*uintptr)(unsafe.Pointer(v298))
	*(*uintptr)(unsafe.Pointer(v298))++
	*(*uint8)(unsafe.Pointer(v297)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(16))
	v300 = envPtr2 + 152
	v299 = *(*uintptr)(unsafe.Pointer(v300))
	*(*uintptr)(unsafe.Pointer(v300))++
	*(*uint8)(unsafe.Pointer(v299)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(8))
	v302 = envPtr2 + 152
	v301 = *(*uintptr)(unsafe.Pointer(v302))
	*(*uintptr)(unsafe.Pointer(v302))++
	*(*uint8)(unsafe.Pointer(v301)) = uint8(libc.Uint32FromInt32(infoIndex))
	if collect == int32(TCL_EACH_COLLECT) {
		if collectVar <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v304 = envPtr2 + 152
			v303 = *(*uintptr)(unsafe.Pointer(v304))
			*(*uintptr)(unsafe.Pointer(v304))++
			*(*uint8)(unsafe.Pointer(v303)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
			v306 = envPtr2 + 152
			v305 = *(*uintptr)(unsafe.Pointer(v306))
			*(*uintptr)(unsafe.Pointer(v306))++
			*(*uint8)(unsafe.Pointer(v305)) = uint8(libc.Uint32FromInt32(collectVar))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - collectVar
				}
				v307 = delta1
				v308 = envPtr2
				if v307 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v308)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v308)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v308)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v308)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v308 + 64)) += int64(v307)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v310 = envPtr2 + 152
			v309 = *(*uintptr)(unsafe.Pointer(v310))
			*(*uintptr)(unsafe.Pointer(v310))++
			*(*uint8)(unsafe.Pointer(v309)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
			v312 = envPtr2 + 152
			v311 = *(*uintptr)(unsafe.Pointer(v312))
			*(*uintptr)(unsafe.Pointer(v312))++
			*(*uint8)(unsafe.Pointer(v311)) = uint8(libc.Uint32FromInt32(collectVar) >> libc.Int32FromInt32(24))
			v314 = envPtr2 + 152
			v313 = *(*uintptr)(unsafe.Pointer(v314))
			*(*uintptr)(unsafe.Pointer(v314))++
			*(*uint8)(unsafe.Pointer(v313)) = uint8(libc.Uint32FromInt32(collectVar) >> libc.Int32FromInt32(16))
			v316 = envPtr2 + 152
			v315 = *(*uintptr)(unsafe.Pointer(v316))
			*(*uintptr)(unsafe.Pointer(v316))++
			*(*uint8)(unsafe.Pointer(v315)) = uint8(libc.Uint32FromInt32(collectVar) >> libc.Int32FromInt32(8))
			v318 = envPtr2 + 152
			v317 = *(*uintptr)(unsafe.Pointer(v318))
			*(*uintptr)(unsafe.Pointer(v318))++
			*(*uint8)(unsafe.Pointer(v317)) = uint8(libc.Uint32FromInt32(collectVar))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - collectVar
				}
				v319 = delta1
				v320 = envPtr2
				if v319 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v320)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v320)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v320)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v320)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v320 + 64)) += int64(v319)
			}
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v322 = envPtr2 + 152
		v321 = *(*uintptr)(unsafe.Pointer(v322))
		*(*uintptr)(unsafe.Pointer(v322))++
		*(*uint8)(unsafe.Pointer(v321)) = libc.Uint8FromInt32(int32(INST_UNSET_SCALAR))
		v324 = envPtr2 + 152
		v323 = *(*uintptr)(unsafe.Pointer(v324))
		*(*uintptr)(unsafe.Pointer(v324))++
		*(*uint8)(unsafe.Pointer(v323)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_UNSET_SCALAR)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v325 = delta1
			v326 = envPtr2
			if v325 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v326)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v326)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v326)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v326)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v326 + 64)) += int64(v325)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v328 = envPtr2 + 152
		v327 = *(*uintptr)(unsafe.Pointer(v328))
		*(*uintptr)(unsafe.Pointer(v328))++
		*(*uint8)(unsafe.Pointer(v327)) = uint8(libc.Uint32FromInt32(collectVar) >> libc.Int32FromInt32(24))
		v330 = envPtr2 + 152
		v329 = *(*uintptr)(unsafe.Pointer(v330))
		*(*uintptr)(unsafe.Pointer(v330))++
		*(*uint8)(unsafe.Pointer(v329)) = uint8(libc.Uint32FromInt32(collectVar) >> libc.Int32FromInt32(16))
		v332 = envPtr2 + 152
		v331 = *(*uintptr)(unsafe.Pointer(v332))
		*(*uintptr)(unsafe.Pointer(v332))++
		*(*uint8)(unsafe.Pointer(v331)) = uint8(libc.Uint32FromInt32(collectVar) >> libc.Int32FromInt32(8))
		v334 = envPtr2 + 152
		v333 = *(*uintptr)(unsafe.Pointer(v334))
		*(*uintptr)(unsafe.Pointer(v334))++
		*(*uint8)(unsafe.Pointer(v333)) = uint8(libc.Uint32FromInt32(collectVar))
	} else {
		_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy2 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v336 = envPtr2 + 152
			v335 = *(*uintptr)(unsafe.Pointer(v336))
			*(*uintptr)(unsafe.Pointer(v336))++
			*(*uint8)(unsafe.Pointer(v335)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v338 = envPtr2 + 152
			v337 = *(*uintptr)(unsafe.Pointer(v338))
			*(*uintptr)(unsafe.Pointer(v338))++
			*(*uint8)(unsafe.Pointer(v337)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v339 = delta1
				v340 = envPtr2
				if v339 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v340)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v340)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v340)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v340)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v340 + 64)) += int64(v339)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v342 = envPtr2 + 152
			v341 = *(*uintptr)(unsafe.Pointer(v342))
			*(*uintptr)(unsafe.Pointer(v342))++
			*(*uint8)(unsafe.Pointer(v341)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v344 = envPtr2 + 152
			v343 = *(*uintptr)(unsafe.Pointer(v344))
			*(*uintptr)(unsafe.Pointer(v344))++
			*(*uint8)(unsafe.Pointer(v343)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
			v346 = envPtr2 + 152
			v345 = *(*uintptr)(unsafe.Pointer(v346))
			*(*uintptr)(unsafe.Pointer(v346))++
			*(*uint8)(unsafe.Pointer(v345)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
			v348 = envPtr2 + 152
			v347 = *(*uintptr)(unsafe.Pointer(v348))
			*(*uintptr)(unsafe.Pointer(v348))++
			*(*uint8)(unsafe.Pointer(v347)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
			v350 = envPtr2 + 152
			v349 = *(*uintptr)(unsafe.Pointer(v350))
			*(*uintptr)(unsafe.Pointer(v350))++
			*(*uint8)(unsafe.Pointer(v349)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v351 = delta1
				v352 = envPtr2
				if v351 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v352)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v352)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v352)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v352)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v352 + 64)) += int64(v351)
			}
		}
	}
	return TCL_OK
}

func XTclCompileDictUpdateCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Holds resulting instructions. */
	var _objIndexCopy, delta1, dictIndex, i1, infoIndex, numVars, range1, v104, v108, v112, v124, v136, v19, v31, v43, v63, v68, v7, v80, v92 int32
	var bodyTokenPtr, dictVarTokenPtr, duiPtr, keyTokenPtrs, mapPtr, tokenPtr, v10, v100, v101, v102, v103, v105, v106, v107, v109, v11, v110, v111, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v123, v125, v126, v127, v128, v129, v13, v130, v131, v132, v133, v134, v135, v137, v138, v139, v14, v140, v141, v142, v143, v144, v145, v15, v16, v17, v18, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v64, v66, v67, v69, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v93, v94, v95, v96, v97, v98, v99 uintptr
	var eclIndex TTcl_Size
	var v65 int64
	var _ /* jumpFixup at bp+0 */ TJumpFixup
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, bodyTokenPtr, delta1, dictIndex, dictVarTokenPtr, duiPtr, eclIndex, i1, infoIndex, keyTokenPtrs, mapPtr, numVars, range1, tokenPtr, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v123, v124, v125, v126, v127, v128, v129, v13, v130, v131, v132, v133, v134, v135, v136, v137, v138, v139, v14, v140, v141, v142, v143, v144, v145, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	/*
	 * There must be at least one argument after the command.
	 */
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) < int32(5) {
		return int32(TCL_ERROR)
	}
	/*
	 * Parse the command. Expect the following:
	 *   dict update <lit(eral)> <any> <lit> ?<any> <lit> ...? <lit>
	 */
	if (int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-int32(1))&int32(1) != 0 {
		return int32(TCL_ERROR)
	}
	numVars = int32(((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords - int64(3)) / int64(2))
	/*
	 * The dictionary variable must be a local scalar that is knowable at
	 * compile time; anything else exceeds the complexity of the opcode. So
	 * discover what the index is.
	 */
	dictVarTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	dictIndex = libc.Int32FromUint64(XTclLocalScalarFromToken(tls, dictVarTokenPtr, envPtr2))
	if dictIndex < 0 {
		goto issueFallback
	}
	/*
	 * Assemble the instruction metadata. This is complex enough that it is
	 * represented as auxData; it holds an ordered list of variable indices
	 * that are to be used.
	 */
	duiPtr = XTcl_Alloc(tls, uint64(libc.UintptrFromInt32(0)+8)+uint64(8)*libc.Uint64FromInt32(numVars))
	(*TDictUpdateInfo)(unsafe.Pointer(duiPtr)).Flength = int64(numVars)
	keyTokenPtrs = XTclStackAlloc(tls, interp, uint64(8)*libc.Uint64FromInt32(numVars))
	tokenPtr = dictVarTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(dictVarTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	i1 = 0
	for {
		if !(i1 < numVars) {
			break
		}
		/*
		 * Put keys to one side for later compilation to bytecode.
		 */
		*(*uintptr)(unsafe.Pointer(keyTokenPtrs + uintptr(i1)*8)) = tokenPtr
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		/*
		 * Stash the index in the auxiliary data (if it is indeed a local
		 * scalar that is resolvable at compile-time).
		 */
		*(*TTcl_Size)(unsafe.Pointer(duiPtr + 8 + uintptr(i1)*8)) = libc.Int64FromUint64(XTclLocalScalarFromToken(tls, tokenPtr, envPtr2))
		if *(*TTcl_Size)(unsafe.Pointer(duiPtr + 8 + uintptr(i1)*8)) == int64(-libc.Int32FromInt32(1)) {
			goto failedUpdateInfoAssembly
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		goto _1
	_1:
		;
		i1++
	}
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) {
		goto failedUpdateInfoAssembly
	}
	bodyTokenPtr = tokenPtr
	/*
	 * The list of variables to bind is stored in auxiliary data so that it
	 * can't be snagged by literal sharing and forced to shimmer dangerously.
	 */
	infoIndex = int32(XTclCreateAuxData(tls, duiPtr, uintptr(unsafe.Pointer(&_dictUpdateInfoType)), envPtr2))
	i1 = 0
	for {
		if !(i1 < numVars) {
			break
		}
		if (*TTcl_Token)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keyTokenPtrs + uintptr(i1)*8)))).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keyTokenPtrs + uintptr(i1)*8)) + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keyTokenPtrs + uintptr(i1)*8)) + 1*32))).Fsize, 0)
			if _objIndexCopy <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v4 = envPtr2 + 152
				v3 = *(*uintptr)(unsafe.Pointer(v4))
				*(*uintptr)(unsafe.Pointer(v4))++
				*(*uint8)(unsafe.Pointer(v3)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v6 = envPtr2 + 152
				v5 = *(*uintptr)(unsafe.Pointer(v6))
				*(*uintptr)(unsafe.Pointer(v6))++
				*(*uint8)(unsafe.Pointer(v5)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v7 = delta1
					v8 = envPtr2
					if v7 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v8)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v8)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v8)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v8)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v8 + 64)) += int64(v7)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v10 = envPtr2 + 152
				v9 = *(*uintptr)(unsafe.Pointer(v10))
				*(*uintptr)(unsafe.Pointer(v10))++
				*(*uint8)(unsafe.Pointer(v9)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v12 = envPtr2 + 152
				v11 = *(*uintptr)(unsafe.Pointer(v12))
				*(*uintptr)(unsafe.Pointer(v12))++
				*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
				v14 = envPtr2 + 152
				v13 = *(*uintptr)(unsafe.Pointer(v14))
				*(*uintptr)(unsafe.Pointer(v14))++
				*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
				v16 = envPtr2 + 152
				v15 = *(*uintptr)(unsafe.Pointer(v16))
				*(*uintptr)(unsafe.Pointer(v16))++
				*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
				v18 = envPtr2 + 152
				v17 = *(*uintptr)(unsafe.Pointer(v18))
				*(*uintptr)(unsafe.Pointer(v18))++
				*(*uint8)(unsafe.Pointer(v17)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v19 = delta1
					v20 = envPtr2
					if v19 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v20)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v20)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v20)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v20)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v20 + 64)) += int64(v19)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(libc.Int32FromInt32(2)*i1+libc.Int32FromInt32(2))*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(libc.Int32FromInt32(2)*i1+libc.Int32FromInt32(2))*8))
			XTclCompileTokens(tls, interp, *(*uintptr)(unsafe.Pointer(keyTokenPtrs + uintptr(i1)*8))+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keyTokenPtrs + uintptr(i1)*8)))).FnumComponents), envPtr2)
		}
		goto _2
	_2:
		;
		i1++
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v22 = envPtr2 + 152
	v21 = *(*uintptr)(unsafe.Pointer(v22))
	*(*uintptr)(unsafe.Pointer(v22))++
	*(*uint8)(unsafe.Pointer(v21)) = libc.Uint8FromInt32(int32(INST_LIST))
	v24 = envPtr2 + 152
	v23 = *(*uintptr)(unsafe.Pointer(v24))
	*(*uintptr)(unsafe.Pointer(v24))++
	*(*uint8)(unsafe.Pointer(v23)) = uint8(libc.Uint32FromInt32(numVars) >> libc.Int32FromInt32(24))
	v26 = envPtr2 + 152
	v25 = *(*uintptr)(unsafe.Pointer(v26))
	*(*uintptr)(unsafe.Pointer(v26))++
	*(*uint8)(unsafe.Pointer(v25)) = uint8(libc.Uint32FromInt32(numVars) >> libc.Int32FromInt32(16))
	v28 = envPtr2 + 152
	v27 = *(*uintptr)(unsafe.Pointer(v28))
	*(*uintptr)(unsafe.Pointer(v28))++
	*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(numVars) >> libc.Int32FromInt32(8))
	v30 = envPtr2 + 152
	v29 = *(*uintptr)(unsafe.Pointer(v30))
	*(*uintptr)(unsafe.Pointer(v30))++
	*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(numVars))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_LIST)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - numVars
		}
		v31 = delta1
		v32 = envPtr2
		if v31 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v32)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v32)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v32)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v32)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v32 + 64)) += int64(v31)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v34 = envPtr2 + 152
	v33 = *(*uintptr)(unsafe.Pointer(v34))
	*(*uintptr)(unsafe.Pointer(v34))++
	*(*uint8)(unsafe.Pointer(v33)) = libc.Uint8FromInt32(int32(INST_DICT_UPDATE_START))
	v36 = envPtr2 + 152
	v35 = *(*uintptr)(unsafe.Pointer(v36))
	*(*uintptr)(unsafe.Pointer(v36))++
	*(*uint8)(unsafe.Pointer(v35)) = uint8(libc.Uint32FromInt32(dictIndex) >> libc.Int32FromInt32(24))
	v38 = envPtr2 + 152
	v37 = *(*uintptr)(unsafe.Pointer(v38))
	*(*uintptr)(unsafe.Pointer(v38))++
	*(*uint8)(unsafe.Pointer(v37)) = uint8(libc.Uint32FromInt32(dictIndex) >> libc.Int32FromInt32(16))
	v40 = envPtr2 + 152
	v39 = *(*uintptr)(unsafe.Pointer(v40))
	*(*uintptr)(unsafe.Pointer(v40))++
	*(*uint8)(unsafe.Pointer(v39)) = uint8(libc.Uint32FromInt32(dictIndex) >> libc.Int32FromInt32(8))
	v42 = envPtr2 + 152
	v41 = *(*uintptr)(unsafe.Pointer(v42))
	*(*uintptr)(unsafe.Pointer(v42))++
	*(*uint8)(unsafe.Pointer(v41)) = uint8(libc.Uint32FromInt32(dictIndex))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_DICT_UPDATE_START)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - dictIndex
		}
		v43 = delta1
		v44 = envPtr2
		if v43 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v44)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v44)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v44)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v44)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v44 + 64)) += int64(v43)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v46 = envPtr2 + 152
	v45 = *(*uintptr)(unsafe.Pointer(v46))
	*(*uintptr)(unsafe.Pointer(v46))++
	*(*uint8)(unsafe.Pointer(v45)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(24))
	v48 = envPtr2 + 152
	v47 = *(*uintptr)(unsafe.Pointer(v48))
	*(*uintptr)(unsafe.Pointer(v48))++
	*(*uint8)(unsafe.Pointer(v47)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(16))
	v50 = envPtr2 + 152
	v49 = *(*uintptr)(unsafe.Pointer(v50))
	*(*uintptr)(unsafe.Pointer(v50))++
	*(*uint8)(unsafe.Pointer(v49)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(8))
	v52 = envPtr2 + 152
	v51 = *(*uintptr)(unsafe.Pointer(v52))
	*(*uintptr)(unsafe.Pointer(v52))++
	*(*uint8)(unsafe.Pointer(v51)) = uint8(libc.Uint32FromInt32(infoIndex))
	range1 = int32(XTclCreateExceptRange(tls, int32(CATCH_EXCEPTION_RANGE), envPtr2))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v54 = envPtr2 + 152
	v53 = *(*uintptr)(unsafe.Pointer(v54))
	*(*uintptr)(unsafe.Pointer(v54))++
	*(*uint8)(unsafe.Pointer(v53)) = libc.Uint8FromInt32(int32(INST_BEGIN_CATCH4))
	v56 = envPtr2 + 152
	v55 = *(*uintptr)(unsafe.Pointer(v56))
	*(*uintptr)(unsafe.Pointer(v56))++
	*(*uint8)(unsafe.Pointer(v55)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(24))
	v58 = envPtr2 + 152
	v57 = *(*uintptr)(unsafe.Pointer(v58))
	*(*uintptr)(unsafe.Pointer(v58))++
	*(*uint8)(unsafe.Pointer(v57)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(16))
	v60 = envPtr2 + 152
	v59 = *(*uintptr)(unsafe.Pointer(v60))
	*(*uintptr)(unsafe.Pointer(v60))++
	*(*uint8)(unsafe.Pointer(v59)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(8))
	v62 = envPtr2 + 152
	v61 = *(*uintptr)(unsafe.Pointer(v62))
	*(*uintptr)(unsafe.Pointer(v62))++
	*(*uint8)(unsafe.Pointer(v61)) = uint8(libc.Uint32FromInt32(range1))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_BEGIN_CATCH4)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - range1
		}
		v63 = delta1
		v64 = envPtr2
		if v63 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v64)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v64)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v64)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v64)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v64 + 64)) += int64(v63)
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth++
	if libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth)+uint64(1) > libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth)+uint64(1) {
		v65 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth
	} else {
		v65 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth = v65
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords-libc.Int64FromInt32(1))*8))
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords-libc.Int64FromInt32(1))*8))
	XTclCompileCmdWord(tls, interp, bodyTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(bodyTokenPtr)).FnumComponents), envPtr2)
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth--
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FnumCodeBytes = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(int32((*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset))
	/*
	 * Normal termination code: the stack has the key list below the result of
	 * the body evaluation: swap them and finish the update code.
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v67 = envPtr2 + 152
	v66 = *(*uintptr)(unsafe.Pointer(v67))
	*(*uintptr)(unsafe.Pointer(v67))++
	*(*uint8)(unsafe.Pointer(v66)) = libc.Uint8FromInt32(int32(INST_END_CATCH))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_END_CATCH)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v68 = delta1
		v69 = envPtr2
		if v68 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v69)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v69)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v69)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v69)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v69 + 64)) += int64(v68)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v71 = envPtr2 + 152
	v70 = *(*uintptr)(unsafe.Pointer(v71))
	*(*uintptr)(unsafe.Pointer(v71))++
	*(*uint8)(unsafe.Pointer(v70)) = libc.Uint8FromInt32(int32(INST_REVERSE))
	v73 = envPtr2 + 152
	v72 = *(*uintptr)(unsafe.Pointer(v73))
	*(*uintptr)(unsafe.Pointer(v73))++
	*(*uint8)(unsafe.Pointer(v72)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
	v75 = envPtr2 + 152
	v74 = *(*uintptr)(unsafe.Pointer(v75))
	*(*uintptr)(unsafe.Pointer(v75))++
	*(*uint8)(unsafe.Pointer(v74)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
	v77 = envPtr2 + 152
	v76 = *(*uintptr)(unsafe.Pointer(v77))
	*(*uintptr)(unsafe.Pointer(v77))++
	*(*uint8)(unsafe.Pointer(v76)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
	v79 = envPtr2 + 152
	v78 = *(*uintptr)(unsafe.Pointer(v79))
	*(*uintptr)(unsafe.Pointer(v79))++
	*(*uint8)(unsafe.Pointer(v78)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32(2)
		}
		v80 = delta1
		v81 = envPtr2
		if v80 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v81)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v81)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v81)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v81)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v81 + 64)) += int64(v80)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v83 = envPtr2 + 152
	v82 = *(*uintptr)(unsafe.Pointer(v83))
	*(*uintptr)(unsafe.Pointer(v83))++
	*(*uint8)(unsafe.Pointer(v82)) = libc.Uint8FromInt32(int32(INST_DICT_UPDATE_END))
	v85 = envPtr2 + 152
	v84 = *(*uintptr)(unsafe.Pointer(v85))
	*(*uintptr)(unsafe.Pointer(v85))++
	*(*uint8)(unsafe.Pointer(v84)) = uint8(libc.Uint32FromInt32(dictIndex) >> libc.Int32FromInt32(24))
	v87 = envPtr2 + 152
	v86 = *(*uintptr)(unsafe.Pointer(v87))
	*(*uintptr)(unsafe.Pointer(v87))++
	*(*uint8)(unsafe.Pointer(v86)) = uint8(libc.Uint32FromInt32(dictIndex) >> libc.Int32FromInt32(16))
	v89 = envPtr2 + 152
	v88 = *(*uintptr)(unsafe.Pointer(v89))
	*(*uintptr)(unsafe.Pointer(v89))++
	*(*uint8)(unsafe.Pointer(v88)) = uint8(libc.Uint32FromInt32(dictIndex) >> libc.Int32FromInt32(8))
	v91 = envPtr2 + 152
	v90 = *(*uintptr)(unsafe.Pointer(v91))
	*(*uintptr)(unsafe.Pointer(v91))++
	*(*uint8)(unsafe.Pointer(v90)) = uint8(libc.Uint32FromInt32(dictIndex))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_DICT_UPDATE_END)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - dictIndex
		}
		v92 = delta1
		v93 = envPtr2
		if v92 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v93)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v93)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v93)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v93)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v93 + 64)) += int64(v92)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v95 = envPtr2 + 152
	v94 = *(*uintptr)(unsafe.Pointer(v95))
	*(*uintptr)(unsafe.Pointer(v95))++
	*(*uint8)(unsafe.Pointer(v94)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(24))
	v97 = envPtr2 + 152
	v96 = *(*uintptr)(unsafe.Pointer(v97))
	*(*uintptr)(unsafe.Pointer(v97))++
	*(*uint8)(unsafe.Pointer(v96)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(16))
	v99 = envPtr2 + 152
	v98 = *(*uintptr)(unsafe.Pointer(v99))
	*(*uintptr)(unsafe.Pointer(v99))++
	*(*uint8)(unsafe.Pointer(v98)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(8))
	v101 = envPtr2 + 152
	v100 = *(*uintptr)(unsafe.Pointer(v101))
	*(*uintptr)(unsafe.Pointer(v101))++
	*(*uint8)(unsafe.Pointer(v100)) = uint8(libc.Uint32FromInt32(infoIndex))
	/*
	 * Jump around the exceptional termination code.
	 */
	XTclEmitForwardJump(tls, envPtr2, int32(TCL_UNCONDITIONAL_JUMP), bp)
	/*
	 * Termination code for non-ok returns: stash the result and return
	 * options in the stack, bring up the key list, finish the update code,
	 * and finally return with the caught return data
	 */
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcatchOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v103 = envPtr2 + 152
	v102 = *(*uintptr)(unsafe.Pointer(v103))
	*(*uintptr)(unsafe.Pointer(v103))++
	*(*uint8)(unsafe.Pointer(v102)) = libc.Uint8FromInt32(int32(INST_PUSH_RESULT))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_PUSH_RESULT)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v104 = delta1
		v105 = envPtr2
		if v104 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v105)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v105)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v105)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v105)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v105 + 64)) += int64(v104)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v107 = envPtr2 + 152
	v106 = *(*uintptr)(unsafe.Pointer(v107))
	*(*uintptr)(unsafe.Pointer(v107))++
	*(*uint8)(unsafe.Pointer(v106)) = libc.Uint8FromInt32(int32(INST_PUSH_RETURN_OPTIONS))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_PUSH_RETURN_OPTIONS)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v108 = delta1
		v109 = envPtr2
		if v108 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v109)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v109)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v109)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v109)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v109 + 64)) += int64(v108)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v111 = envPtr2 + 152
	v110 = *(*uintptr)(unsafe.Pointer(v111))
	*(*uintptr)(unsafe.Pointer(v111))++
	*(*uint8)(unsafe.Pointer(v110)) = libc.Uint8FromInt32(int32(INST_END_CATCH))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_END_CATCH)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v112 = delta1
		v113 = envPtr2
		if v112 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v113)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v113)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v113)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v113)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v113 + 64)) += int64(v112)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v115 = envPtr2 + 152
	v114 = *(*uintptr)(unsafe.Pointer(v115))
	*(*uintptr)(unsafe.Pointer(v115))++
	*(*uint8)(unsafe.Pointer(v114)) = libc.Uint8FromInt32(int32(INST_REVERSE))
	v117 = envPtr2 + 152
	v116 = *(*uintptr)(unsafe.Pointer(v117))
	*(*uintptr)(unsafe.Pointer(v117))++
	*(*uint8)(unsafe.Pointer(v116)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)) >> libc.Int32FromInt32(24))
	v119 = envPtr2 + 152
	v118 = *(*uintptr)(unsafe.Pointer(v119))
	*(*uintptr)(unsafe.Pointer(v119))++
	*(*uint8)(unsafe.Pointer(v118)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)) >> libc.Int32FromInt32(16))
	v121 = envPtr2 + 152
	v120 = *(*uintptr)(unsafe.Pointer(v121))
	*(*uintptr)(unsafe.Pointer(v121))++
	*(*uint8)(unsafe.Pointer(v120)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)) >> libc.Int32FromInt32(8))
	v123 = envPtr2 + 152
	v122 = *(*uintptr)(unsafe.Pointer(v123))
	*(*uintptr)(unsafe.Pointer(v123))++
	*(*uint8)(unsafe.Pointer(v122)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32(3)
		}
		v124 = delta1
		v125 = envPtr2
		if v124 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v125)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v125)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v125)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v125)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v125 + 64)) += int64(v124)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v127 = envPtr2 + 152
	v126 = *(*uintptr)(unsafe.Pointer(v127))
	*(*uintptr)(unsafe.Pointer(v127))++
	*(*uint8)(unsafe.Pointer(v126)) = libc.Uint8FromInt32(int32(INST_DICT_UPDATE_END))
	v129 = envPtr2 + 152
	v128 = *(*uintptr)(unsafe.Pointer(v129))
	*(*uintptr)(unsafe.Pointer(v129))++
	*(*uint8)(unsafe.Pointer(v128)) = uint8(libc.Uint32FromInt32(dictIndex) >> libc.Int32FromInt32(24))
	v131 = envPtr2 + 152
	v130 = *(*uintptr)(unsafe.Pointer(v131))
	*(*uintptr)(unsafe.Pointer(v131))++
	*(*uint8)(unsafe.Pointer(v130)) = uint8(libc.Uint32FromInt32(dictIndex) >> libc.Int32FromInt32(16))
	v133 = envPtr2 + 152
	v132 = *(*uintptr)(unsafe.Pointer(v133))
	*(*uintptr)(unsafe.Pointer(v133))++
	*(*uint8)(unsafe.Pointer(v132)) = uint8(libc.Uint32FromInt32(dictIndex) >> libc.Int32FromInt32(8))
	v135 = envPtr2 + 152
	v134 = *(*uintptr)(unsafe.Pointer(v135))
	*(*uintptr)(unsafe.Pointer(v135))++
	*(*uint8)(unsafe.Pointer(v134)) = uint8(libc.Uint32FromInt32(dictIndex))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_DICT_UPDATE_END)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - dictIndex
		}
		v136 = delta1
		v137 = envPtr2
		if v136 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v137)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v137)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v137)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v137)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v137 + 64)) += int64(v136)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v139 = envPtr2 + 152
	v138 = *(*uintptr)(unsafe.Pointer(v139))
	*(*uintptr)(unsafe.Pointer(v139))++
	*(*uint8)(unsafe.Pointer(v138)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(24))
	v141 = envPtr2 + 152
	v140 = *(*uintptr)(unsafe.Pointer(v141))
	*(*uintptr)(unsafe.Pointer(v141))++
	*(*uint8)(unsafe.Pointer(v140)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(16))
	v143 = envPtr2 + 152
	v142 = *(*uintptr)(unsafe.Pointer(v143))
	*(*uintptr)(unsafe.Pointer(v143))++
	*(*uint8)(unsafe.Pointer(v142)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(8))
	v145 = envPtr2 + 152
	v144 = *(*uintptr)(unsafe.Pointer(v145))
	*(*uintptr)(unsafe.Pointer(v145))++
	*(*uint8)(unsafe.Pointer(v144)) = uint8(libc.Uint32FromInt32(infoIndex))
	XTclEmitInvoke(tls, envPtr2, int32(INST_RETURN_STK), 0)
	if XTclFixupForwardJump(tls, envPtr2, bp, int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(libc.Int32FromUint32((*TJumpFixup)(unsafe.Pointer(bp)).FcodeOffset))), int32(127)) != 0 {
		XTcl_Panic(tls, __ccgo_ts+21568, libc.VaList(bp+24, int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-libc.Int64FromUint32((*(*TJumpFixup)(unsafe.Pointer(bp))).FcodeOffset)))
	}
	XTclStackFree(tls, interp, keyTokenPtrs)
	return TCL_OK
	/*
	 * Clean up after a failure to create the DictUpdateInfo structure.
	 */
	goto failedUpdateInfoAssembly
failedUpdateInfoAssembly:
	;
	XTclpFree(tls, duiPtr)
	XTclStackFree(tls, interp, keyTokenPtrs)
	goto issueFallback
issueFallback:
	;
	return XTclCompileBasicMin2ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
	return r
}

func XTclCompileDictAppendCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, delta1, dictVarIndex, i1, v18, v24, v36, v6 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v19, v2, v20, v21, v22, v23, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v37, v4, v5, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, dictVarIndex, eclIndex, i1, mapPtr, tokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v4, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	/*
	 * There must be at least two argument after the command. And we impose an
	 * (arbitrary) safe limit; anyone exceeding it should stop worrying about
	 * speed quite so much. ;-)
	 */
	/* TODO: Consider support for compiling expanded args. */
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) < int32(4) || int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) > int32(100) {
		return int32(TCL_ERROR)
	}
	/*
	 * Get the index of the local variable that we will be working with.
	 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	dictVarIndex = libc.Int32FromUint64(XTclLocalScalarFromToken(tls, tokenPtr, envPtr2))
	if dictVarIndex < 0 {
		return XTclCompileBasicMin2ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
	}
	/*
	 * Produce the string to concatenate onto the dictionary entry.
	 */
	tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	i1 = int32(2)
	for {
		if !(i1 < int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)) {
			break
		}
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v3 = envPtr2 + 152
				v2 = *(*uintptr)(unsafe.Pointer(v3))
				*(*uintptr)(unsafe.Pointer(v3))++
				*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v5 = envPtr2 + 152
				v4 = *(*uintptr)(unsafe.Pointer(v5))
				*(*uintptr)(unsafe.Pointer(v5))++
				*(*uint8)(unsafe.Pointer(v4)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v6 = delta1
					v7 = envPtr2
					if v6 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v7 + 64)) += int64(v6)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v9 = envPtr2 + 152
				v8 = *(*uintptr)(unsafe.Pointer(v9))
				*(*uintptr)(unsafe.Pointer(v9))++
				*(*uint8)(unsafe.Pointer(v8)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v11 = envPtr2 + 152
				v10 = *(*uintptr)(unsafe.Pointer(v11))
				*(*uintptr)(unsafe.Pointer(v11))++
				*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
				v13 = envPtr2 + 152
				v12 = *(*uintptr)(unsafe.Pointer(v13))
				*(*uintptr)(unsafe.Pointer(v13))++
				*(*uint8)(unsafe.Pointer(v12)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
				v15 = envPtr2 + 152
				v14 = *(*uintptr)(unsafe.Pointer(v15))
				*(*uintptr)(unsafe.Pointer(v15))++
				*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
				v17 = envPtr2 + 152
				v16 = *(*uintptr)(unsafe.Pointer(v17))
				*(*uintptr)(unsafe.Pointer(v17))++
				*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v18 = delta1
					v19 = envPtr2
					if v18 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v19 + 64)) += int64(v18)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		goto _1
	_1:
		;
		i1++
	}
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) > int32(4) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v21 = envPtr2 + 152
		v20 = *(*uintptr)(unsafe.Pointer(v21))
		*(*uintptr)(unsafe.Pointer(v21))++
		*(*uint8)(unsafe.Pointer(v20)) = libc.Uint8FromInt32(int32(INST_STR_CONCAT1))
		v23 = envPtr2 + 152
		v22 = *(*uintptr)(unsafe.Pointer(v23))
		*(*uintptr)(unsafe.Pointer(v23))++
		*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) - libc.Int32FromInt32(3)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STR_CONCAT1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - (int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) - int32(3))
			}
			v24 = delta1
			v25 = envPtr2
			if v24 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v25 + 64)) += int64(v24)
		}
	}
	/*
	 * Do the concatenation.
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v27 = envPtr2 + 152
	v26 = *(*uintptr)(unsafe.Pointer(v27))
	*(*uintptr)(unsafe.Pointer(v27))++
	*(*uint8)(unsafe.Pointer(v26)) = libc.Uint8FromInt32(int32(INST_DICT_APPEND))
	v29 = envPtr2 + 152
	v28 = *(*uintptr)(unsafe.Pointer(v29))
	*(*uintptr)(unsafe.Pointer(v29))++
	*(*uint8)(unsafe.Pointer(v28)) = uint8(libc.Uint32FromInt32(dictVarIndex) >> libc.Int32FromInt32(24))
	v31 = envPtr2 + 152
	v30 = *(*uintptr)(unsafe.Pointer(v31))
	*(*uintptr)(unsafe.Pointer(v31))++
	*(*uint8)(unsafe.Pointer(v30)) = uint8(libc.Uint32FromInt32(dictVarIndex) >> libc.Int32FromInt32(16))
	v33 = envPtr2 + 152
	v32 = *(*uintptr)(unsafe.Pointer(v33))
	*(*uintptr)(unsafe.Pointer(v33))++
	*(*uint8)(unsafe.Pointer(v32)) = uint8(libc.Uint32FromInt32(dictVarIndex) >> libc.Int32FromInt32(8))
	v35 = envPtr2 + 152
	v34 = *(*uintptr)(unsafe.Pointer(v35))
	*(*uintptr)(unsafe.Pointer(v35))++
	*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt32(dictVarIndex))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_DICT_APPEND)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - dictVarIndex
		}
		v36 = delta1
		v37 = envPtr2
		if v36 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v37 + 64)) += int64(v36)
	}
	return TCL_OK
}

func XTclCompileDictLappendCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, delta1, dictVarIndex, v17, v23, v35, v47, v5 int32
	var eclIndex TTcl_Size
	var keyTokenPtr, mapPtr, valueTokenPtr, varTokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v48, v6, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, delta1, dictVarIndex, eclIndex, keyTokenPtr, mapPtr, valueTokenPtr, varTokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	/*
	 * There must be three arguments after the command.
	 */
	/* TODO: Consider support for compiling expanded args. */
	/* Probably not.  Why is INST_DICT_LAPPEND limited to one value? */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(4) {
		return int32(TCL_ERROR)
	}
	/*
	 * Parse the arguments.
	 */
	varTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	keyTokenPtr = varTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	valueTokenPtr = keyTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(keyTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	dictVarIndex = libc.Int32FromUint64(XTclLocalScalarFromToken(tls, varTokenPtr, envPtr2))
	if dictVarIndex < 0 {
		return XTclCompileBasic3ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
	}
	/*
	 * Issue the implementation.
	 */
	if (*TTcl_Token)(unsafe.Pointer(keyTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(keyTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(keyTokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
		XTclCompileTokens(tls, interp, keyTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(keyTokenPtr)).FnumComponents), envPtr2)
	}
	if (*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(valueTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(valueTokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy1 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v20 = envPtr2 + 152
			v19 = *(*uintptr)(unsafe.Pointer(v20))
			*(*uintptr)(unsafe.Pointer(v20))++
			*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v22 = envPtr2 + 152
			v21 = *(*uintptr)(unsafe.Pointer(v22))
			*(*uintptr)(unsafe.Pointer(v22))++
			*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v23 = delta1
				v24 = envPtr2
				if v23 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v24 + 64)) += int64(v23)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v26 = envPtr2 + 152
			v25 = *(*uintptr)(unsafe.Pointer(v26))
			*(*uintptr)(unsafe.Pointer(v26))++
			*(*uint8)(unsafe.Pointer(v25)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v28 = envPtr2 + 152
			v27 = *(*uintptr)(unsafe.Pointer(v28))
			*(*uintptr)(unsafe.Pointer(v28))++
			*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
			v30 = envPtr2 + 152
			v29 = *(*uintptr)(unsafe.Pointer(v30))
			*(*uintptr)(unsafe.Pointer(v30))++
			*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
			v32 = envPtr2 + 152
			v31 = *(*uintptr)(unsafe.Pointer(v32))
			*(*uintptr)(unsafe.Pointer(v32))++
			*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
			v34 = envPtr2 + 152
			v33 = *(*uintptr)(unsafe.Pointer(v34))
			*(*uintptr)(unsafe.Pointer(v34))++
			*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v35 = delta1
				v36 = envPtr2
				if v35 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v36 + 64)) += int64(v35)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 3*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 3*8))
		XTclCompileTokens(tls, interp, valueTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).FnumComponents), envPtr2)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v38 = envPtr2 + 152
	v37 = *(*uintptr)(unsafe.Pointer(v38))
	*(*uintptr)(unsafe.Pointer(v38))++
	*(*uint8)(unsafe.Pointer(v37)) = libc.Uint8FromInt32(int32(INST_DICT_LAPPEND))
	v40 = envPtr2 + 152
	v39 = *(*uintptr)(unsafe.Pointer(v40))
	*(*uintptr)(unsafe.Pointer(v40))++
	*(*uint8)(unsafe.Pointer(v39)) = uint8(libc.Uint32FromInt32(dictVarIndex) >> libc.Int32FromInt32(24))
	v42 = envPtr2 + 152
	v41 = *(*uintptr)(unsafe.Pointer(v42))
	*(*uintptr)(unsafe.Pointer(v42))++
	*(*uint8)(unsafe.Pointer(v41)) = uint8(libc.Uint32FromInt32(dictVarIndex) >> libc.Int32FromInt32(16))
	v44 = envPtr2 + 152
	v43 = *(*uintptr)(unsafe.Pointer(v44))
	*(*uintptr)(unsafe.Pointer(v44))++
	*(*uint8)(unsafe.Pointer(v43)) = uint8(libc.Uint32FromInt32(dictVarIndex) >> libc.Int32FromInt32(8))
	v46 = envPtr2 + 152
	v45 = *(*uintptr)(unsafe.Pointer(v46))
	*(*uintptr)(unsafe.Pointer(v46))++
	*(*uint8)(unsafe.Pointer(v45)) = uint8(libc.Uint32FromInt32(dictVarIndex))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_DICT_LAPPEND)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - dictVarIndex
		}
		v47 = delta1
		v48 = envPtr2
		if v47 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v48)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v48)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v48)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v48)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v48 + 64)) += int64(v47)
	}
	return TCL_OK
}

func XTclCompileDictWithCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy10, _objIndexCopy11, _objIndexCopy12, _objIndexCopy2, _objIndexCopy3, _objIndexCopy4, _objIndexCopy5, _objIndexCopy6, _objIndexCopy7, _objIndexCopy8, _objIndexCopy9, bodyIsEmpty, delta1, dictVar, gotPath, i1, keysTmp, pathTmp, range1, varNameTmp, v102, v114, v120, v132, v136, v148, v155, v167, v179, v191, v195, v20, v207, v211, v215, v221, v233, v237, v241, v247, v259, v263, v269, v281, v293, v297, v303, v315, v32, v321, v333, v339, v351, v358, v370, v38, v382, v388, v400, v404, v408, v414, v426, v432, v444, v450, v462, v466, v472, v484, v488, v50, v500, v505, v511, v523, v529, v541, v547, v559, v565, v577, v581, v593, v595, v599, v603, v607, v613, v62, v625, v631, v643, v649, v66, v661, v667, v679, v683, v695, v78, v8, v84, v96 int32
	var eclIndex TTcl_Size
	var end, mapPtr, ptr, tokenPtr, varTokenPtr, v10, v100, v101, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v115, v116, v117, v118, v119, v12, v121, v122, v123, v124, v125, v126, v127, v128, v129, v13, v130, v131, v133, v134, v135, v137, v138, v139, v14, v140, v141, v142, v143, v144, v145, v146, v147, v149, v15, v151, v152, v153, v154, v156, v157, v158, v159, v16, v160, v161, v162, v163, v164, v165, v166, v168, v169, v17, v170, v171, v172, v173, v174, v175, v176, v177, v178, v18, v180, v181, v182, v183, v184, v185, v186, v187, v188, v189, v19, v190, v192, v193, v194, v196, v197, v198, v199, v200, v201, v202, v203, v204, v205, v206, v208, v209, v21, v210, v212, v213, v214, v216, v217, v218, v219, v22, v220, v222, v223, v224, v225, v226, v227, v228, v229, v23, v230, v231, v232, v234, v235, v236, v238, v239, v24, v240, v242, v243, v244, v245, v246, v248, v249, v25, v250, v251, v252, v253, v254, v255, v256, v257, v258, v26, v260, v261, v262, v264, v265, v266, v267, v268, v27, v270, v271, v272, v273, v274, v275, v276, v277, v278, v279, v28, v280, v282, v283, v284, v285, v286, v287, v288, v289, v29, v290, v291, v292, v294, v295, v296, v298, v299, v30, v300, v301, v302, v304, v305, v306, v307, v308, v309, v31, v310, v311, v312, v313, v314, v316, v317, v318, v319, v320, v322, v323, v324, v325, v326, v327, v328, v329, v33, v330, v331, v332, v334, v335, v336, v337, v338, v34, v340, v341, v342, v343, v344, v345, v346, v347, v348, v349, v35, v350, v352, v354, v355, v356, v357, v359, v36, v360, v361, v362, v363, v364, v365, v366, v367, v368, v369, v37, v371, v372, v373, v374, v375, v376, v377, v378, v379, v380, v381, v383, v384, v385, v386, v387, v389, v39, v390, v391, v392, v393, v394, v395, v396, v397, v398, v399, v4, v40, v401, v402, v403, v405, v406, v407, v409, v41, v410, v411, v412, v413, v415, v416, v417, v418, v419, v42, v420, v421, v422, v423, v424, v425, v427, v428, v429, v43, v430, v431, v433, v434, v435, v436, v437, v438, v439, v44, v440, v441, v442, v443, v445, v446, v447, v448, v449, v45, v451, v452, v453, v454, v455, v456, v457, v458, v459, v46, v460, v461, v463, v464, v465, v467, v468, v469, v47, v470, v471, v473, v474, v475, v476, v477, v478, v479, v48, v480, v481, v482, v483, v485, v486, v487, v489, v49, v490, v491, v492, v493, v494, v495, v496, v497, v498, v499, v5, v501, v503, v504, v506, v507, v508, v509, v51, v510, v512, v513, v514, v515, v516, v517, v518, v519, v52, v520, v521, v522, v524, v525, v526, v527, v528, v53, v530, v531, v532, v533, v534, v535, v536, v537, v538, v539, v54, v540, v542, v543, v544, v545, v546, v548, v549, v55, v550, v551, v552, v553, v554, v555, v556, v557, v558, v56, v560, v561, v562, v563, v564, v566, v567, v568, v569, v57, v570, v571, v572, v573, v574, v575, v576, v578, v579, v58, v580, v582, v583, v584, v585, v586, v587, v588, v589, v59, v590, v591, v592, v594, v596, v597, v598, v6, v60, v600, v601, v602, v604, v605, v606, v608, v609, v61, v610, v611, v612, v614, v615, v616, v617, v618, v619, v620, v621, v622, v623, v624, v626, v627, v628, v629, v63, v630, v632, v633, v634, v635, v636, v637, v638, v639, v64, v640, v641, v642, v644, v645, v646, v647, v648, v65, v650, v651, v652, v653, v654, v655, v656, v657, v658, v659, v660, v662, v663, v664, v665, v666, v668, v669, v67, v670, v671, v672, v673, v674, v675, v676, v677, v678, v68, v680, v681, v682, v684, v685, v686, v687, v688, v689, v69, v690, v691, v692, v693, v694, v696, v7, v70, v71, v72, v73, v74, v75, v76, v77, v79, v80, v81, v82, v83, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v95, v97, v98, v99 uintptr
	var v502 int64
	var _ /* jumpFixup at bp+0 */ TJumpFixup
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy10, _objIndexCopy11, _objIndexCopy12, _objIndexCopy2, _objIndexCopy3, _objIndexCopy4, _objIndexCopy5, _objIndexCopy6, _objIndexCopy7, _objIndexCopy8, _objIndexCopy9, bodyIsEmpty, delta1, dictVar, eclIndex, end, gotPath, i1, keysTmp, mapPtr, pathTmp, ptr, range1, tokenPtr, varNameTmp, varTokenPtr, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v123, v124, v125, v126, v127, v128, v129, v13, v130, v131, v132, v133, v134, v135, v136, v137, v138, v139, v14, v140, v141, v142, v143, v144, v145, v146, v147, v148, v149, v15, v151, v152, v153, v154, v155, v156, v157, v158, v159, v16, v160, v161, v162, v163, v164, v165, v166, v167, v168, v169, v17, v170, v171, v172, v173, v174, v175, v176, v177, v178, v179, v18, v180, v181, v182, v183, v184, v185, v186, v187, v188, v189, v19, v190, v191, v192, v193, v194, v195, v196, v197, v198, v199, v20, v200, v201, v202, v203, v204, v205, v206, v207, v208, v209, v21, v210, v211, v212, v213, v214, v215, v216, v217, v218, v219, v22, v220, v221, v222, v223, v224, v225, v226, v227, v228, v229, v23, v230, v231, v232, v233, v234, v235, v236, v237, v238, v239, v24, v240, v241, v242, v243, v244, v245, v246, v247, v248, v249, v25, v250, v251, v252, v253, v254, v255, v256, v257, v258, v259, v26, v260, v261, v262, v263, v264, v265, v266, v267, v268, v269, v27, v270, v271, v272, v273, v274, v275, v276, v277, v278, v279, v28, v280, v281, v282, v283, v284, v285, v286, v287, v288, v289, v29, v290, v291, v292, v293, v294, v295, v296, v297, v298, v299, v30, v300, v301, v302, v303, v304, v305, v306, v307, v308, v309, v31, v310, v311, v312, v313, v314, v315, v316, v317, v318, v319, v32, v320, v321, v322, v323, v324, v325, v326, v327, v328, v329, v33, v330, v331, v332, v333, v334, v335, v336, v337, v338, v339, v34, v340, v341, v342, v343, v344, v345, v346, v347, v348, v349, v35, v350, v351, v352, v354, v355, v356, v357, v358, v359, v36, v360, v361, v362, v363, v364, v365, v366, v367, v368, v369, v37, v370, v371, v372, v373, v374, v375, v376, v377, v378, v379, v38, v380, v381, v382, v383, v384, v385, v386, v387, v388, v389, v39, v390, v391, v392, v393, v394, v395, v396, v397, v398, v399, v4, v40, v400, v401, v402, v403, v404, v405, v406, v407, v408, v409, v41, v410, v411, v412, v413, v414, v415, v416, v417, v418, v419, v42, v420, v421, v422, v423, v424, v425, v426, v427, v428, v429, v43, v430, v431, v432, v433, v434, v435, v436, v437, v438, v439, v44, v440, v441, v442, v443, v444, v445, v446, v447, v448, v449, v45, v450, v451, v452, v453, v454, v455, v456, v457, v458, v459, v46, v460, v461, v462, v463, v464, v465, v466, v467, v468, v469, v47, v470, v471, v472, v473, v474, v475, v476, v477, v478, v479, v48, v480, v481, v482, v483, v484, v485, v486, v487, v488, v489, v49, v490, v491, v492, v493, v494, v495, v496, v497, v498, v499, v5, v50, v500, v501, v502, v503, v504, v505, v506, v507, v508, v509, v51, v510, v511, v512, v513, v514, v515, v516, v517, v518, v519, v52, v520, v521, v522, v523, v524, v525, v526, v527, v528, v529, v53, v530, v531, v532, v533, v534, v535, v536, v537, v538, v539, v54, v540, v541, v542, v543, v544, v545, v546, v547, v548, v549, v55, v550, v551, v552, v553, v554, v555, v556, v557, v558, v559, v56, v560, v561, v562, v563, v564, v565, v566, v567, v568, v569, v57, v570, v571, v572, v573, v574, v575, v576, v577, v578, v579, v58, v580, v581, v582, v583, v584, v585, v586, v587, v588, v589, v59, v590, v591, v592, v593, v594, v595, v596, v597, v598, v599, v6, v60, v600, v601, v602, v603, v604, v605, v606, v607, v608, v609, v61, v610, v611, v612, v613, v614, v615, v616, v617, v618, v619, v62, v620, v621, v622, v623, v624, v625, v626, v627, v628, v629, v63, v630, v631, v632, v633, v634, v635, v636, v637, v638, v639, v64, v640, v641, v642, v643, v644, v645, v646, v647, v648, v649, v65, v650, v651, v652, v653, v654, v655, v656, v657, v658, v659, v66, v660, v661, v662, v663, v664, v665, v666, v667, v668, v669, v67, v670, v671, v672, v673, v674, v675, v676, v677, v678, v679, v68, v680, v681, v682, v683, v684, v685, v686, v687, v688, v689, v69, v690, v691, v692, v693, v694, v695, v696, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	varNameTmp = -int32(1)
	pathTmp = -int32(1)
	bodyIsEmpty = int32(1)
	/*
	 * There must be at least one argument after the command.
	 */
	/* TODO: Consider support for compiling expanded args. */
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) < int32(3) {
		return int32(TCL_ERROR)
	}
	/*
	 * Parse the command (trivially). Expect the following:
	 *   dict with <any (varName)> ?<any> ...? <literal>
	 */
	varTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	tokenPtr = varTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	i1 = int32(3)
	for {
		if !(i1 < int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)) {
			break
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		goto _1
	_1:
		;
		i1++
	}
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) {
		return XTclCompileBasicMin2ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
	}
	/*
	 * Test if the last word is an empty script; if so, we can compile it in
	 * all cases, but if it is non-empty we need local variable table entries
	 * to hold the temporary variables (used to keep stack usage simple).
	 */
	ptr = (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart
	end = ptr + uintptr((*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize)
	for {
		if !(ptr != end) {
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ptr))) != int32(' ') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ptr))) != int32('\t') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ptr))) != int32('\n') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ptr))) != int32('\r') {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FprocPtr == libc.UintptrFromInt32(0) {
				return XTclCompileBasicMin2ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
			}
			bodyIsEmpty = 0
			break
		}
		goto _2
	_2:
		;
		ptr++
	}
	/*
	 * Determine if we're manipulating a dict in a simple local variable.
	 */
	gotPath = libc.BoolInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) > int32(3))
	dictVar = libc.Int32FromUint64(XTclLocalScalarFromToken(tls, varTokenPtr, envPtr2))
	/*
	 * Special case: an empty body means we definitely have no need to issue
	 * try-finally style code or to allocate local variable table entries for
	 * storing temporaries. Still need to do both INST_DICT_EXPAND and
	 * INST_DICT_RECOMBINE_* though, because we can't determine if we're free
	 * of traces.
	 */
	if bodyIsEmpty != 0 {
		if dictVar >= 0 {
			if gotPath != 0 {
				/*
				 * Case: Path into dict in LVT with empty body.
				 */
				tokenPtr = varTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
				i1 = int32(2)
				for {
					if !(i1 < int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-int32(1)) {
						break
					}
					if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
						_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
						if _objIndexCopy <= int32(255) {
							if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
								XTclExpandCodeArray(tls, envPtr2)
							}
							v5 = envPtr2 + 152
							v4 = *(*uintptr)(unsafe.Pointer(v5))
							*(*uintptr)(unsafe.Pointer(v5))++
							*(*uint8)(unsafe.Pointer(v4)) = libc.Uint8FromInt32(int32(INST_PUSH1))
							v7 = envPtr2 + 152
							v6 = *(*uintptr)(unsafe.Pointer(v7))
							*(*uintptr)(unsafe.Pointer(v7))++
							*(*uint8)(unsafe.Pointer(v6)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
							if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
								(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
							}
							delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
							if delta1 != 0 {
								if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
									delta1 = int32(1) - _objIndexCopy
								}
								v8 = delta1
								v9 = envPtr2
								if v8 < libc.Int32FromInt32(0) {
									if int32((*TCompileEnv)(unsafe.Pointer(v9)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v9)).FcurrStackDepth) {
										(*TCompileEnv)(unsafe.Pointer(v9)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v9)).FcurrStackDepth
									}
								}
								*(*TTcl_Size)(unsafe.Pointer(v9 + 64)) += int64(v8)
							}
						} else {
							if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
								XTclExpandCodeArray(tls, envPtr2)
							}
							v11 = envPtr2 + 152
							v10 = *(*uintptr)(unsafe.Pointer(v11))
							*(*uintptr)(unsafe.Pointer(v11))++
							*(*uint8)(unsafe.Pointer(v10)) = libc.Uint8FromInt32(int32(INST_PUSH4))
							v13 = envPtr2 + 152
							v12 = *(*uintptr)(unsafe.Pointer(v13))
							*(*uintptr)(unsafe.Pointer(v13))++
							*(*uint8)(unsafe.Pointer(v12)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
							v15 = envPtr2 + 152
							v14 = *(*uintptr)(unsafe.Pointer(v15))
							*(*uintptr)(unsafe.Pointer(v15))++
							*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
							v17 = envPtr2 + 152
							v16 = *(*uintptr)(unsafe.Pointer(v17))
							*(*uintptr)(unsafe.Pointer(v17))++
							*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
							v19 = envPtr2 + 152
							v18 = *(*uintptr)(unsafe.Pointer(v19))
							*(*uintptr)(unsafe.Pointer(v19))++
							*(*uint8)(unsafe.Pointer(v18)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
							if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
								(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
							}
							delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
							if delta1 != 0 {
								if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
									delta1 = int32(1) - _objIndexCopy
								}
								v20 = delta1
								v21 = envPtr2
								if v20 < libc.Int32FromInt32(0) {
									if int32((*TCompileEnv)(unsafe.Pointer(v21)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v21)).FcurrStackDepth) {
										(*TCompileEnv)(unsafe.Pointer(v21)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v21)).FcurrStackDepth
									}
								}
								*(*TTcl_Size)(unsafe.Pointer(v21 + 64)) += int64(v20)
							}
						}
					} else {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
						XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
					}
					tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
					goto _3
				_3:
					;
					i1++
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v23 = envPtr2 + 152
				v22 = *(*uintptr)(unsafe.Pointer(v23))
				*(*uintptr)(unsafe.Pointer(v23))++
				*(*uint8)(unsafe.Pointer(v22)) = libc.Uint8FromInt32(int32(INST_LIST))
				v25 = envPtr2 + 152
				v24 = *(*uintptr)(unsafe.Pointer(v25))
				*(*uintptr)(unsafe.Pointer(v25))++
				*(*uint8)(unsafe.Pointer(v24)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(3)) >> libc.Int32FromInt32(24))
				v27 = envPtr2 + 152
				v26 = *(*uintptr)(unsafe.Pointer(v27))
				*(*uintptr)(unsafe.Pointer(v27))++
				*(*uint8)(unsafe.Pointer(v26)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(3)) >> libc.Int32FromInt32(16))
				v29 = envPtr2 + 152
				v28 = *(*uintptr)(unsafe.Pointer(v29))
				*(*uintptr)(unsafe.Pointer(v29))++
				*(*uint8)(unsafe.Pointer(v28)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(3)) >> libc.Int32FromInt32(8))
				v31 = envPtr2 + 152
				v30 = *(*uintptr)(unsafe.Pointer(v31))
				*(*uintptr)(unsafe.Pointer(v31))++
				*(*uint8)(unsafe.Pointer(v30)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) - libc.Int32FromInt32(3)))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LIST)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - (int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) - int32(3))
					}
					v32 = delta1
					v33 = envPtr2
					if v32 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v33)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v33)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v33)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v33)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v33 + 64)) += int64(v32)
				}
				if dictVar <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v35 = envPtr2 + 152
					v34 = *(*uintptr)(unsafe.Pointer(v35))
					*(*uintptr)(unsafe.Pointer(v35))++
					*(*uint8)(unsafe.Pointer(v34)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
					v37 = envPtr2 + 152
					v36 = *(*uintptr)(unsafe.Pointer(v37))
					*(*uintptr)(unsafe.Pointer(v37))++
					*(*uint8)(unsafe.Pointer(v36)) = uint8(libc.Uint32FromInt32(dictVar))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - dictVar
						}
						v38 = delta1
						v39 = envPtr2
						if v38 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v39)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v39)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v39)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v39)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v39 + 64)) += int64(v38)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v41 = envPtr2 + 152
					v40 = *(*uintptr)(unsafe.Pointer(v41))
					*(*uintptr)(unsafe.Pointer(v41))++
					*(*uint8)(unsafe.Pointer(v40)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
					v43 = envPtr2 + 152
					v42 = *(*uintptr)(unsafe.Pointer(v43))
					*(*uintptr)(unsafe.Pointer(v43))++
					*(*uint8)(unsafe.Pointer(v42)) = uint8(libc.Uint32FromInt32(dictVar) >> libc.Int32FromInt32(24))
					v45 = envPtr2 + 152
					v44 = *(*uintptr)(unsafe.Pointer(v45))
					*(*uintptr)(unsafe.Pointer(v45))++
					*(*uint8)(unsafe.Pointer(v44)) = uint8(libc.Uint32FromInt32(dictVar) >> libc.Int32FromInt32(16))
					v47 = envPtr2 + 152
					v46 = *(*uintptr)(unsafe.Pointer(v47))
					*(*uintptr)(unsafe.Pointer(v47))++
					*(*uint8)(unsafe.Pointer(v46)) = uint8(libc.Uint32FromInt32(dictVar) >> libc.Int32FromInt32(8))
					v49 = envPtr2 + 152
					v48 = *(*uintptr)(unsafe.Pointer(v49))
					*(*uintptr)(unsafe.Pointer(v49))++
					*(*uint8)(unsafe.Pointer(v48)) = uint8(libc.Uint32FromInt32(dictVar))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - dictVar
						}
						v50 = delta1
						v51 = envPtr2
						if v50 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v51)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v51)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v51)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v51)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v51 + 64)) += int64(v50)
					}
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v53 = envPtr2 + 152
				v52 = *(*uintptr)(unsafe.Pointer(v53))
				*(*uintptr)(unsafe.Pointer(v53))++
				*(*uint8)(unsafe.Pointer(v52)) = libc.Uint8FromInt32(int32(INST_OVER))
				v55 = envPtr2 + 152
				v54 = *(*uintptr)(unsafe.Pointer(v55))
				*(*uintptr)(unsafe.Pointer(v55))++
				*(*uint8)(unsafe.Pointer(v54)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(24))
				v57 = envPtr2 + 152
				v56 = *(*uintptr)(unsafe.Pointer(v57))
				*(*uintptr)(unsafe.Pointer(v57))++
				*(*uint8)(unsafe.Pointer(v56)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(16))
				v59 = envPtr2 + 152
				v58 = *(*uintptr)(unsafe.Pointer(v59))
				*(*uintptr)(unsafe.Pointer(v59))++
				*(*uint8)(unsafe.Pointer(v58)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(8))
				v61 = envPtr2 + 152
				v60 = *(*uintptr)(unsafe.Pointer(v61))
				*(*uintptr)(unsafe.Pointer(v61))++
				*(*uint8)(unsafe.Pointer(v60)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_OVER)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - int32(1)
					}
					v62 = delta1
					v63 = envPtr2
					if v62 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v63)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v63)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v63)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v63)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v63 + 64)) += int64(v62)
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v65 = envPtr2 + 152
				v64 = *(*uintptr)(unsafe.Pointer(v65))
				*(*uintptr)(unsafe.Pointer(v65))++
				*(*uint8)(unsafe.Pointer(v64)) = libc.Uint8FromInt32(int32(INST_DICT_EXPAND))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_DICT_EXPAND)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v66 = delta1
					v67 = envPtr2
					if v66 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v67)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v67)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v67)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v67)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v67 + 64)) += int64(v66)
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v69 = envPtr2 + 152
				v68 = *(*uintptr)(unsafe.Pointer(v69))
				*(*uintptr)(unsafe.Pointer(v69))++
				*(*uint8)(unsafe.Pointer(v68)) = libc.Uint8FromInt32(int32(INST_DICT_RECOMBINE_IMM))
				v71 = envPtr2 + 152
				v70 = *(*uintptr)(unsafe.Pointer(v71))
				*(*uintptr)(unsafe.Pointer(v71))++
				*(*uint8)(unsafe.Pointer(v70)) = uint8(libc.Uint32FromInt32(dictVar) >> libc.Int32FromInt32(24))
				v73 = envPtr2 + 152
				v72 = *(*uintptr)(unsafe.Pointer(v73))
				*(*uintptr)(unsafe.Pointer(v73))++
				*(*uint8)(unsafe.Pointer(v72)) = uint8(libc.Uint32FromInt32(dictVar) >> libc.Int32FromInt32(16))
				v75 = envPtr2 + 152
				v74 = *(*uintptr)(unsafe.Pointer(v75))
				*(*uintptr)(unsafe.Pointer(v75))++
				*(*uint8)(unsafe.Pointer(v74)) = uint8(libc.Uint32FromInt32(dictVar) >> libc.Int32FromInt32(8))
				v77 = envPtr2 + 152
				v76 = *(*uintptr)(unsafe.Pointer(v77))
				*(*uintptr)(unsafe.Pointer(v77))++
				*(*uint8)(unsafe.Pointer(v76)) = uint8(libc.Uint32FromInt32(dictVar))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_DICT_RECOMBINE_IMM)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - dictVar
					}
					v78 = delta1
					v79 = envPtr2
					if v78 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v79)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v79)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v79)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v79)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v79 + 64)) += int64(v78)
				}
			} else {
				/*
				 * Case: Direct dict in LVT with empty body.
				 */
				_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
				if _objIndexCopy1 <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v81 = envPtr2 + 152
					v80 = *(*uintptr)(unsafe.Pointer(v81))
					*(*uintptr)(unsafe.Pointer(v81))++
					*(*uint8)(unsafe.Pointer(v80)) = libc.Uint8FromInt32(int32(INST_PUSH1))
					v83 = envPtr2 + 152
					v82 = *(*uintptr)(unsafe.Pointer(v83))
					*(*uintptr)(unsafe.Pointer(v83))++
					*(*uint8)(unsafe.Pointer(v82)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy1
						}
						v84 = delta1
						v85 = envPtr2
						if v84 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v85)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v85)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v85)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v85)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v85 + 64)) += int64(v84)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v87 = envPtr2 + 152
					v86 = *(*uintptr)(unsafe.Pointer(v87))
					*(*uintptr)(unsafe.Pointer(v87))++
					*(*uint8)(unsafe.Pointer(v86)) = libc.Uint8FromInt32(int32(INST_PUSH4))
					v89 = envPtr2 + 152
					v88 = *(*uintptr)(unsafe.Pointer(v89))
					*(*uintptr)(unsafe.Pointer(v89))++
					*(*uint8)(unsafe.Pointer(v88)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
					v91 = envPtr2 + 152
					v90 = *(*uintptr)(unsafe.Pointer(v91))
					*(*uintptr)(unsafe.Pointer(v91))++
					*(*uint8)(unsafe.Pointer(v90)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
					v93 = envPtr2 + 152
					v92 = *(*uintptr)(unsafe.Pointer(v93))
					*(*uintptr)(unsafe.Pointer(v93))++
					*(*uint8)(unsafe.Pointer(v92)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
					v95 = envPtr2 + 152
					v94 = *(*uintptr)(unsafe.Pointer(v95))
					*(*uintptr)(unsafe.Pointer(v95))++
					*(*uint8)(unsafe.Pointer(v94)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy1
						}
						v96 = delta1
						v97 = envPtr2
						if v96 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v97)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v97)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v97)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v97)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v97 + 64)) += int64(v96)
					}
				}
				if dictVar <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v99 = envPtr2 + 152
					v98 = *(*uintptr)(unsafe.Pointer(v99))
					*(*uintptr)(unsafe.Pointer(v99))++
					*(*uint8)(unsafe.Pointer(v98)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
					v101 = envPtr2 + 152
					v100 = *(*uintptr)(unsafe.Pointer(v101))
					*(*uintptr)(unsafe.Pointer(v101))++
					*(*uint8)(unsafe.Pointer(v100)) = uint8(libc.Uint32FromInt32(dictVar))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - dictVar
						}
						v102 = delta1
						v103 = envPtr2
						if v102 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v103)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v103)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v103)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v103)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v103 + 64)) += int64(v102)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v105 = envPtr2 + 152
					v104 = *(*uintptr)(unsafe.Pointer(v105))
					*(*uintptr)(unsafe.Pointer(v105))++
					*(*uint8)(unsafe.Pointer(v104)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
					v107 = envPtr2 + 152
					v106 = *(*uintptr)(unsafe.Pointer(v107))
					*(*uintptr)(unsafe.Pointer(v107))++
					*(*uint8)(unsafe.Pointer(v106)) = uint8(libc.Uint32FromInt32(dictVar) >> libc.Int32FromInt32(24))
					v109 = envPtr2 + 152
					v108 = *(*uintptr)(unsafe.Pointer(v109))
					*(*uintptr)(unsafe.Pointer(v109))++
					*(*uint8)(unsafe.Pointer(v108)) = uint8(libc.Uint32FromInt32(dictVar) >> libc.Int32FromInt32(16))
					v111 = envPtr2 + 152
					v110 = *(*uintptr)(unsafe.Pointer(v111))
					*(*uintptr)(unsafe.Pointer(v111))++
					*(*uint8)(unsafe.Pointer(v110)) = uint8(libc.Uint32FromInt32(dictVar) >> libc.Int32FromInt32(8))
					v113 = envPtr2 + 152
					v112 = *(*uintptr)(unsafe.Pointer(v113))
					*(*uintptr)(unsafe.Pointer(v113))++
					*(*uint8)(unsafe.Pointer(v112)) = uint8(libc.Uint32FromInt32(dictVar))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - dictVar
						}
						v114 = delta1
						v115 = envPtr2
						if v114 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v115)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v115)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v115)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v115)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v115 + 64)) += int64(v114)
					}
				}
				_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
				if _objIndexCopy2 <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v117 = envPtr2 + 152
					v116 = *(*uintptr)(unsafe.Pointer(v117))
					*(*uintptr)(unsafe.Pointer(v117))++
					*(*uint8)(unsafe.Pointer(v116)) = libc.Uint8FromInt32(int32(INST_PUSH1))
					v119 = envPtr2 + 152
					v118 = *(*uintptr)(unsafe.Pointer(v119))
					*(*uintptr)(unsafe.Pointer(v119))++
					*(*uint8)(unsafe.Pointer(v118)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy2
						}
						v120 = delta1
						v121 = envPtr2
						if v120 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v121)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v121)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v121)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v121)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v121 + 64)) += int64(v120)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v123 = envPtr2 + 152
					v122 = *(*uintptr)(unsafe.Pointer(v123))
					*(*uintptr)(unsafe.Pointer(v123))++
					*(*uint8)(unsafe.Pointer(v122)) = libc.Uint8FromInt32(int32(INST_PUSH4))
					v125 = envPtr2 + 152
					v124 = *(*uintptr)(unsafe.Pointer(v125))
					*(*uintptr)(unsafe.Pointer(v125))++
					*(*uint8)(unsafe.Pointer(v124)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
					v127 = envPtr2 + 152
					v126 = *(*uintptr)(unsafe.Pointer(v127))
					*(*uintptr)(unsafe.Pointer(v127))++
					*(*uint8)(unsafe.Pointer(v126)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
					v129 = envPtr2 + 152
					v128 = *(*uintptr)(unsafe.Pointer(v129))
					*(*uintptr)(unsafe.Pointer(v129))++
					*(*uint8)(unsafe.Pointer(v128)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
					v131 = envPtr2 + 152
					v130 = *(*uintptr)(unsafe.Pointer(v131))
					*(*uintptr)(unsafe.Pointer(v131))++
					*(*uint8)(unsafe.Pointer(v130)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy2
						}
						v132 = delta1
						v133 = envPtr2
						if v132 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v133)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v133)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v133)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v133)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v133 + 64)) += int64(v132)
					}
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v135 = envPtr2 + 152
				v134 = *(*uintptr)(unsafe.Pointer(v135))
				*(*uintptr)(unsafe.Pointer(v135))++
				*(*uint8)(unsafe.Pointer(v134)) = libc.Uint8FromInt32(int32(INST_DICT_EXPAND))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_DICT_EXPAND)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v136 = delta1
					v137 = envPtr2
					if v136 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v137)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v137)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v137)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v137)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v137 + 64)) += int64(v136)
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v139 = envPtr2 + 152
				v138 = *(*uintptr)(unsafe.Pointer(v139))
				*(*uintptr)(unsafe.Pointer(v139))++
				*(*uint8)(unsafe.Pointer(v138)) = libc.Uint8FromInt32(int32(INST_DICT_RECOMBINE_IMM))
				v141 = envPtr2 + 152
				v140 = *(*uintptr)(unsafe.Pointer(v141))
				*(*uintptr)(unsafe.Pointer(v141))++
				*(*uint8)(unsafe.Pointer(v140)) = uint8(libc.Uint32FromInt32(dictVar) >> libc.Int32FromInt32(24))
				v143 = envPtr2 + 152
				v142 = *(*uintptr)(unsafe.Pointer(v143))
				*(*uintptr)(unsafe.Pointer(v143))++
				*(*uint8)(unsafe.Pointer(v142)) = uint8(libc.Uint32FromInt32(dictVar) >> libc.Int32FromInt32(16))
				v145 = envPtr2 + 152
				v144 = *(*uintptr)(unsafe.Pointer(v145))
				*(*uintptr)(unsafe.Pointer(v145))++
				*(*uint8)(unsafe.Pointer(v144)) = uint8(libc.Uint32FromInt32(dictVar) >> libc.Int32FromInt32(8))
				v147 = envPtr2 + 152
				v146 = *(*uintptr)(unsafe.Pointer(v147))
				*(*uintptr)(unsafe.Pointer(v147))++
				*(*uint8)(unsafe.Pointer(v146)) = uint8(libc.Uint32FromInt32(dictVar))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_DICT_RECOMBINE_IMM)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - dictVar
					}
					v148 = delta1
					v149 = envPtr2
					if v148 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v149)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v149)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v149)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v149)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v149 + 64)) += int64(v148)
				}
			}
		} else {
			if gotPath != 0 {
				/*
				 * Case: Path into dict in non-simple var with empty body.
				 */
				tokenPtr = varTokenPtr
				i1 = int32(1)
				for {
					if !(i1 < int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-int32(1)) {
						break
					}
					if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
						_objIndexCopy3 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
						if _objIndexCopy3 <= int32(255) {
							if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
								XTclExpandCodeArray(tls, envPtr2)
							}
							v152 = envPtr2 + 152
							v151 = *(*uintptr)(unsafe.Pointer(v152))
							*(*uintptr)(unsafe.Pointer(v152))++
							*(*uint8)(unsafe.Pointer(v151)) = libc.Uint8FromInt32(int32(INST_PUSH1))
							v154 = envPtr2 + 152
							v153 = *(*uintptr)(unsafe.Pointer(v154))
							*(*uintptr)(unsafe.Pointer(v154))++
							*(*uint8)(unsafe.Pointer(v153)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
							if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
								(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
							}
							delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
							if delta1 != 0 {
								if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
									delta1 = int32(1) - _objIndexCopy3
								}
								v155 = delta1
								v156 = envPtr2
								if v155 < libc.Int32FromInt32(0) {
									if int32((*TCompileEnv)(unsafe.Pointer(v156)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v156)).FcurrStackDepth) {
										(*TCompileEnv)(unsafe.Pointer(v156)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v156)).FcurrStackDepth
									}
								}
								*(*TTcl_Size)(unsafe.Pointer(v156 + 64)) += int64(v155)
							}
						} else {
							if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
								XTclExpandCodeArray(tls, envPtr2)
							}
							v158 = envPtr2 + 152
							v157 = *(*uintptr)(unsafe.Pointer(v158))
							*(*uintptr)(unsafe.Pointer(v158))++
							*(*uint8)(unsafe.Pointer(v157)) = libc.Uint8FromInt32(int32(INST_PUSH4))
							v160 = envPtr2 + 152
							v159 = *(*uintptr)(unsafe.Pointer(v160))
							*(*uintptr)(unsafe.Pointer(v160))++
							*(*uint8)(unsafe.Pointer(v159)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(24))
							v162 = envPtr2 + 152
							v161 = *(*uintptr)(unsafe.Pointer(v162))
							*(*uintptr)(unsafe.Pointer(v162))++
							*(*uint8)(unsafe.Pointer(v161)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(16))
							v164 = envPtr2 + 152
							v163 = *(*uintptr)(unsafe.Pointer(v164))
							*(*uintptr)(unsafe.Pointer(v164))++
							*(*uint8)(unsafe.Pointer(v163)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(8))
							v166 = envPtr2 + 152
							v165 = *(*uintptr)(unsafe.Pointer(v166))
							*(*uintptr)(unsafe.Pointer(v166))++
							*(*uint8)(unsafe.Pointer(v165)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
							if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
								(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
							}
							delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
							if delta1 != 0 {
								if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
									delta1 = int32(1) - _objIndexCopy3
								}
								v167 = delta1
								v168 = envPtr2
								if v167 < libc.Int32FromInt32(0) {
									if int32((*TCompileEnv)(unsafe.Pointer(v168)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v168)).FcurrStackDepth) {
										(*TCompileEnv)(unsafe.Pointer(v168)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v168)).FcurrStackDepth
									}
								}
								*(*TTcl_Size)(unsafe.Pointer(v168 + 64)) += int64(v167)
							}
						}
					} else {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
						XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
					}
					tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
					goto _150
				_150:
					;
					i1++
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v170 = envPtr2 + 152
				v169 = *(*uintptr)(unsafe.Pointer(v170))
				*(*uintptr)(unsafe.Pointer(v170))++
				*(*uint8)(unsafe.Pointer(v169)) = libc.Uint8FromInt32(int32(INST_LIST))
				v172 = envPtr2 + 152
				v171 = *(*uintptr)(unsafe.Pointer(v172))
				*(*uintptr)(unsafe.Pointer(v172))++
				*(*uint8)(unsafe.Pointer(v171)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(3)) >> libc.Int32FromInt32(24))
				v174 = envPtr2 + 152
				v173 = *(*uintptr)(unsafe.Pointer(v174))
				*(*uintptr)(unsafe.Pointer(v174))++
				*(*uint8)(unsafe.Pointer(v173)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(3)) >> libc.Int32FromInt32(16))
				v176 = envPtr2 + 152
				v175 = *(*uintptr)(unsafe.Pointer(v176))
				*(*uintptr)(unsafe.Pointer(v176))++
				*(*uint8)(unsafe.Pointer(v175)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(3)) >> libc.Int32FromInt32(8))
				v178 = envPtr2 + 152
				v177 = *(*uintptr)(unsafe.Pointer(v178))
				*(*uintptr)(unsafe.Pointer(v178))++
				*(*uint8)(unsafe.Pointer(v177)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) - libc.Int32FromInt32(3)))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LIST)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - (int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) - int32(3))
					}
					v179 = delta1
					v180 = envPtr2
					if v179 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v180)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v180)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v180)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v180)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v180 + 64)) += int64(v179)
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v182 = envPtr2 + 152
				v181 = *(*uintptr)(unsafe.Pointer(v182))
				*(*uintptr)(unsafe.Pointer(v182))++
				*(*uint8)(unsafe.Pointer(v181)) = libc.Uint8FromInt32(int32(INST_OVER))
				v184 = envPtr2 + 152
				v183 = *(*uintptr)(unsafe.Pointer(v184))
				*(*uintptr)(unsafe.Pointer(v184))++
				*(*uint8)(unsafe.Pointer(v183)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(24))
				v186 = envPtr2 + 152
				v185 = *(*uintptr)(unsafe.Pointer(v186))
				*(*uintptr)(unsafe.Pointer(v186))++
				*(*uint8)(unsafe.Pointer(v185)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(16))
				v188 = envPtr2 + 152
				v187 = *(*uintptr)(unsafe.Pointer(v188))
				*(*uintptr)(unsafe.Pointer(v188))++
				*(*uint8)(unsafe.Pointer(v187)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(8))
				v190 = envPtr2 + 152
				v189 = *(*uintptr)(unsafe.Pointer(v190))
				*(*uintptr)(unsafe.Pointer(v190))++
				*(*uint8)(unsafe.Pointer(v189)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_OVER)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - int32(1)
					}
					v191 = delta1
					v192 = envPtr2
					if v191 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v192)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v192)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v192)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v192)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v192 + 64)) += int64(v191)
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v194 = envPtr2 + 152
				v193 = *(*uintptr)(unsafe.Pointer(v194))
				*(*uintptr)(unsafe.Pointer(v194))++
				*(*uint8)(unsafe.Pointer(v193)) = libc.Uint8FromInt32(int32(INST_LOAD_STK))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LOAD_STK)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v195 = delta1
					v196 = envPtr2
					if v195 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v196)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v196)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v196)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v196)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v196 + 64)) += int64(v195)
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v198 = envPtr2 + 152
				v197 = *(*uintptr)(unsafe.Pointer(v198))
				*(*uintptr)(unsafe.Pointer(v198))++
				*(*uint8)(unsafe.Pointer(v197)) = libc.Uint8FromInt32(int32(INST_OVER))
				v200 = envPtr2 + 152
				v199 = *(*uintptr)(unsafe.Pointer(v200))
				*(*uintptr)(unsafe.Pointer(v200))++
				*(*uint8)(unsafe.Pointer(v199)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(24))
				v202 = envPtr2 + 152
				v201 = *(*uintptr)(unsafe.Pointer(v202))
				*(*uintptr)(unsafe.Pointer(v202))++
				*(*uint8)(unsafe.Pointer(v201)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(16))
				v204 = envPtr2 + 152
				v203 = *(*uintptr)(unsafe.Pointer(v204))
				*(*uintptr)(unsafe.Pointer(v204))++
				*(*uint8)(unsafe.Pointer(v203)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(8))
				v206 = envPtr2 + 152
				v205 = *(*uintptr)(unsafe.Pointer(v206))
				*(*uintptr)(unsafe.Pointer(v206))++
				*(*uint8)(unsafe.Pointer(v205)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_OVER)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - int32(1)
					}
					v207 = delta1
					v208 = envPtr2
					if v207 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v208)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v208)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v208)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v208)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v208 + 64)) += int64(v207)
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v210 = envPtr2 + 152
				v209 = *(*uintptr)(unsafe.Pointer(v210))
				*(*uintptr)(unsafe.Pointer(v210))++
				*(*uint8)(unsafe.Pointer(v209)) = libc.Uint8FromInt32(int32(INST_DICT_EXPAND))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_DICT_EXPAND)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v211 = delta1
					v212 = envPtr2
					if v211 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v212)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v212)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v212)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v212)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v212 + 64)) += int64(v211)
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v214 = envPtr2 + 152
				v213 = *(*uintptr)(unsafe.Pointer(v214))
				*(*uintptr)(unsafe.Pointer(v214))++
				*(*uint8)(unsafe.Pointer(v213)) = libc.Uint8FromInt32(int32(INST_DICT_RECOMBINE_STK))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_DICT_RECOMBINE_STK)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v215 = delta1
					v216 = envPtr2
					if v215 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v216)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v216)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v216)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v216)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v216 + 64)) += int64(v215)
				}
			} else {
				/*
				 * Case: Direct dict in non-simple var with empty body.
				 */
				if (*TTcl_Token)(unsafe.Pointer(varTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
					_objIndexCopy4 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Fsize, 0)
					if _objIndexCopy4 <= int32(255) {
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
							XTclExpandCodeArray(tls, envPtr2)
						}
						v218 = envPtr2 + 152
						v217 = *(*uintptr)(unsafe.Pointer(v218))
						*(*uintptr)(unsafe.Pointer(v218))++
						*(*uint8)(unsafe.Pointer(v217)) = libc.Uint8FromInt32(int32(INST_PUSH1))
						v220 = envPtr2 + 152
						v219 = *(*uintptr)(unsafe.Pointer(v220))
						*(*uintptr)(unsafe.Pointer(v220))++
						*(*uint8)(unsafe.Pointer(v219)) = uint8(libc.Uint32FromInt32(_objIndexCopy4))
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
							(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
						}
						delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
						if delta1 != 0 {
							if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
								delta1 = int32(1) - _objIndexCopy4
							}
							v221 = delta1
							v222 = envPtr2
							if v221 < libc.Int32FromInt32(0) {
								if int32((*TCompileEnv)(unsafe.Pointer(v222)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v222)).FcurrStackDepth) {
									(*TCompileEnv)(unsafe.Pointer(v222)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v222)).FcurrStackDepth
								}
							}
							*(*TTcl_Size)(unsafe.Pointer(v222 + 64)) += int64(v221)
						}
					} else {
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
							XTclExpandCodeArray(tls, envPtr2)
						}
						v224 = envPtr2 + 152
						v223 = *(*uintptr)(unsafe.Pointer(v224))
						*(*uintptr)(unsafe.Pointer(v224))++
						*(*uint8)(unsafe.Pointer(v223)) = libc.Uint8FromInt32(int32(INST_PUSH4))
						v226 = envPtr2 + 152
						v225 = *(*uintptr)(unsafe.Pointer(v226))
						*(*uintptr)(unsafe.Pointer(v226))++
						*(*uint8)(unsafe.Pointer(v225)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(24))
						v228 = envPtr2 + 152
						v227 = *(*uintptr)(unsafe.Pointer(v228))
						*(*uintptr)(unsafe.Pointer(v228))++
						*(*uint8)(unsafe.Pointer(v227)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(16))
						v230 = envPtr2 + 152
						v229 = *(*uintptr)(unsafe.Pointer(v230))
						*(*uintptr)(unsafe.Pointer(v230))++
						*(*uint8)(unsafe.Pointer(v229)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(8))
						v232 = envPtr2 + 152
						v231 = *(*uintptr)(unsafe.Pointer(v232))
						*(*uintptr)(unsafe.Pointer(v232))++
						*(*uint8)(unsafe.Pointer(v231)) = uint8(libc.Uint32FromInt32(_objIndexCopy4))
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
							(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
						}
						delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
						if delta1 != 0 {
							if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
								delta1 = int32(1) - _objIndexCopy4
							}
							v233 = delta1
							v234 = envPtr2
							if v233 < libc.Int32FromInt32(0) {
								if int32((*TCompileEnv)(unsafe.Pointer(v234)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v234)).FcurrStackDepth) {
									(*TCompileEnv)(unsafe.Pointer(v234)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v234)).FcurrStackDepth
								}
							}
							*(*TTcl_Size)(unsafe.Pointer(v234 + 64)) += int64(v233)
						}
					}
				} else {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
					XTclCompileTokens(tls, interp, varTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents), envPtr2)
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v236 = envPtr2 + 152
				v235 = *(*uintptr)(unsafe.Pointer(v236))
				*(*uintptr)(unsafe.Pointer(v236))++
				*(*uint8)(unsafe.Pointer(v235)) = libc.Uint8FromInt32(int32(INST_DUP))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_DUP)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v237 = delta1
					v238 = envPtr2
					if v237 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v238)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v238)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v238)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v238)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v238 + 64)) += int64(v237)
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v240 = envPtr2 + 152
				v239 = *(*uintptr)(unsafe.Pointer(v240))
				*(*uintptr)(unsafe.Pointer(v240))++
				*(*uint8)(unsafe.Pointer(v239)) = libc.Uint8FromInt32(int32(INST_LOAD_STK))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LOAD_STK)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v241 = delta1
					v242 = envPtr2
					if v241 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v242)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v242)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v242)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v242)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v242 + 64)) += int64(v241)
				}
				_objIndexCopy5 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
				if _objIndexCopy5 <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v244 = envPtr2 + 152
					v243 = *(*uintptr)(unsafe.Pointer(v244))
					*(*uintptr)(unsafe.Pointer(v244))++
					*(*uint8)(unsafe.Pointer(v243)) = libc.Uint8FromInt32(int32(INST_PUSH1))
					v246 = envPtr2 + 152
					v245 = *(*uintptr)(unsafe.Pointer(v246))
					*(*uintptr)(unsafe.Pointer(v246))++
					*(*uint8)(unsafe.Pointer(v245)) = uint8(libc.Uint32FromInt32(_objIndexCopy5))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy5
						}
						v247 = delta1
						v248 = envPtr2
						if v247 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v248)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v248)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v248)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v248)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v248 + 64)) += int64(v247)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v250 = envPtr2 + 152
					v249 = *(*uintptr)(unsafe.Pointer(v250))
					*(*uintptr)(unsafe.Pointer(v250))++
					*(*uint8)(unsafe.Pointer(v249)) = libc.Uint8FromInt32(int32(INST_PUSH4))
					v252 = envPtr2 + 152
					v251 = *(*uintptr)(unsafe.Pointer(v252))
					*(*uintptr)(unsafe.Pointer(v252))++
					*(*uint8)(unsafe.Pointer(v251)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(24))
					v254 = envPtr2 + 152
					v253 = *(*uintptr)(unsafe.Pointer(v254))
					*(*uintptr)(unsafe.Pointer(v254))++
					*(*uint8)(unsafe.Pointer(v253)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(16))
					v256 = envPtr2 + 152
					v255 = *(*uintptr)(unsafe.Pointer(v256))
					*(*uintptr)(unsafe.Pointer(v256))++
					*(*uint8)(unsafe.Pointer(v255)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(8))
					v258 = envPtr2 + 152
					v257 = *(*uintptr)(unsafe.Pointer(v258))
					*(*uintptr)(unsafe.Pointer(v258))++
					*(*uint8)(unsafe.Pointer(v257)) = uint8(libc.Uint32FromInt32(_objIndexCopy5))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy5
						}
						v259 = delta1
						v260 = envPtr2
						if v259 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v260)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v260)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v260)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v260)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v260 + 64)) += int64(v259)
					}
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v262 = envPtr2 + 152
				v261 = *(*uintptr)(unsafe.Pointer(v262))
				*(*uintptr)(unsafe.Pointer(v262))++
				*(*uint8)(unsafe.Pointer(v261)) = libc.Uint8FromInt32(int32(INST_DICT_EXPAND))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_DICT_EXPAND)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v263 = delta1
					v264 = envPtr2
					if v263 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v264)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v264)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v264)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v264)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v264 + 64)) += int64(v263)
				}
				_objIndexCopy6 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
				if _objIndexCopy6 <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v266 = envPtr2 + 152
					v265 = *(*uintptr)(unsafe.Pointer(v266))
					*(*uintptr)(unsafe.Pointer(v266))++
					*(*uint8)(unsafe.Pointer(v265)) = libc.Uint8FromInt32(int32(INST_PUSH1))
					v268 = envPtr2 + 152
					v267 = *(*uintptr)(unsafe.Pointer(v268))
					*(*uintptr)(unsafe.Pointer(v268))++
					*(*uint8)(unsafe.Pointer(v267)) = uint8(libc.Uint32FromInt32(_objIndexCopy6))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy6
						}
						v269 = delta1
						v270 = envPtr2
						if v269 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v270)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v270)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v270)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v270)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v270 + 64)) += int64(v269)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v272 = envPtr2 + 152
					v271 = *(*uintptr)(unsafe.Pointer(v272))
					*(*uintptr)(unsafe.Pointer(v272))++
					*(*uint8)(unsafe.Pointer(v271)) = libc.Uint8FromInt32(int32(INST_PUSH4))
					v274 = envPtr2 + 152
					v273 = *(*uintptr)(unsafe.Pointer(v274))
					*(*uintptr)(unsafe.Pointer(v274))++
					*(*uint8)(unsafe.Pointer(v273)) = uint8(libc.Uint32FromInt32(_objIndexCopy6) >> libc.Int32FromInt32(24))
					v276 = envPtr2 + 152
					v275 = *(*uintptr)(unsafe.Pointer(v276))
					*(*uintptr)(unsafe.Pointer(v276))++
					*(*uint8)(unsafe.Pointer(v275)) = uint8(libc.Uint32FromInt32(_objIndexCopy6) >> libc.Int32FromInt32(16))
					v278 = envPtr2 + 152
					v277 = *(*uintptr)(unsafe.Pointer(v278))
					*(*uintptr)(unsafe.Pointer(v278))++
					*(*uint8)(unsafe.Pointer(v277)) = uint8(libc.Uint32FromInt32(_objIndexCopy6) >> libc.Int32FromInt32(8))
					v280 = envPtr2 + 152
					v279 = *(*uintptr)(unsafe.Pointer(v280))
					*(*uintptr)(unsafe.Pointer(v280))++
					*(*uint8)(unsafe.Pointer(v279)) = uint8(libc.Uint32FromInt32(_objIndexCopy6))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy6
						}
						v281 = delta1
						v282 = envPtr2
						if v281 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v282)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v282)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v282)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v282)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v282 + 64)) += int64(v281)
					}
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v284 = envPtr2 + 152
				v283 = *(*uintptr)(unsafe.Pointer(v284))
				*(*uintptr)(unsafe.Pointer(v284))++
				*(*uint8)(unsafe.Pointer(v283)) = libc.Uint8FromInt32(int32(INST_REVERSE))
				v286 = envPtr2 + 152
				v285 = *(*uintptr)(unsafe.Pointer(v286))
				*(*uintptr)(unsafe.Pointer(v286))++
				*(*uint8)(unsafe.Pointer(v285)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
				v288 = envPtr2 + 152
				v287 = *(*uintptr)(unsafe.Pointer(v288))
				*(*uintptr)(unsafe.Pointer(v288))++
				*(*uint8)(unsafe.Pointer(v287)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
				v290 = envPtr2 + 152
				v289 = *(*uintptr)(unsafe.Pointer(v290))
				*(*uintptr)(unsafe.Pointer(v290))++
				*(*uint8)(unsafe.Pointer(v289)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
				v292 = envPtr2 + 152
				v291 = *(*uintptr)(unsafe.Pointer(v292))
				*(*uintptr)(unsafe.Pointer(v292))++
				*(*uint8)(unsafe.Pointer(v291)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - int32(2)
					}
					v293 = delta1
					v294 = envPtr2
					if v293 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v294)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v294)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v294)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v294)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v294 + 64)) += int64(v293)
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v296 = envPtr2 + 152
				v295 = *(*uintptr)(unsafe.Pointer(v296))
				*(*uintptr)(unsafe.Pointer(v296))++
				*(*uint8)(unsafe.Pointer(v295)) = libc.Uint8FromInt32(int32(INST_DICT_RECOMBINE_STK))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_DICT_RECOMBINE_STK)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v297 = delta1
					v298 = envPtr2
					if v297 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v298)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v298)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v298)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v298)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v298 + 64)) += int64(v297)
				}
			}
		}
		_objIndexCopy7 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy7 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v300 = envPtr2 + 152
			v299 = *(*uintptr)(unsafe.Pointer(v300))
			*(*uintptr)(unsafe.Pointer(v300))++
			*(*uint8)(unsafe.Pointer(v299)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v302 = envPtr2 + 152
			v301 = *(*uintptr)(unsafe.Pointer(v302))
			*(*uintptr)(unsafe.Pointer(v302))++
			*(*uint8)(unsafe.Pointer(v301)) = uint8(libc.Uint32FromInt32(_objIndexCopy7))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy7
				}
				v303 = delta1
				v304 = envPtr2
				if v303 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v304)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v304)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v304)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v304)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v304 + 64)) += int64(v303)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v306 = envPtr2 + 152
			v305 = *(*uintptr)(unsafe.Pointer(v306))
			*(*uintptr)(unsafe.Pointer(v306))++
			*(*uint8)(unsafe.Pointer(v305)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v308 = envPtr2 + 152
			v307 = *(*uintptr)(unsafe.Pointer(v308))
			*(*uintptr)(unsafe.Pointer(v308))++
			*(*uint8)(unsafe.Pointer(v307)) = uint8(libc.Uint32FromInt32(_objIndexCopy7) >> libc.Int32FromInt32(24))
			v310 = envPtr2 + 152
			v309 = *(*uintptr)(unsafe.Pointer(v310))
			*(*uintptr)(unsafe.Pointer(v310))++
			*(*uint8)(unsafe.Pointer(v309)) = uint8(libc.Uint32FromInt32(_objIndexCopy7) >> libc.Int32FromInt32(16))
			v312 = envPtr2 + 152
			v311 = *(*uintptr)(unsafe.Pointer(v312))
			*(*uintptr)(unsafe.Pointer(v312))++
			*(*uint8)(unsafe.Pointer(v311)) = uint8(libc.Uint32FromInt32(_objIndexCopy7) >> libc.Int32FromInt32(8))
			v314 = envPtr2 + 152
			v313 = *(*uintptr)(unsafe.Pointer(v314))
			*(*uintptr)(unsafe.Pointer(v314))++
			*(*uint8)(unsafe.Pointer(v313)) = uint8(libc.Uint32FromInt32(_objIndexCopy7))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy7
				}
				v315 = delta1
				v316 = envPtr2
				if v315 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v316)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v316)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v316)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v316)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v316 + 64)) += int64(v315)
			}
		}
		return TCL_OK
	}
	/*
	 * OK, we have a non-trivial body. This means that the focus is on
	 * generating a try-finally structure where the INST_DICT_RECOMBINE_* goes
	 * in the 'finally' clause.
	 *
	 * Start by allocating local (unnamed, untraced) working variables.
	 */
	if dictVar == -int32(1) {
		varNameTmp = int32(XTclFindCompiledLocal(tls, libc.UintptrFromInt32(0), 0, int32(1), envPtr2))
	}
	if gotPath != 0 {
		pathTmp = int32(XTclFindCompiledLocal(tls, libc.UintptrFromInt32(0), 0, int32(1), envPtr2))
	}
	keysTmp = int32(XTclFindCompiledLocal(tls, libc.UintptrFromInt32(0), 0, int32(1), envPtr2))
	/*
	 * Issue instructions. First, the part to expand the dictionary.
	 */
	if dictVar == -int32(1) {
		if (*TTcl_Token)(unsafe.Pointer(varTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy8 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy8 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v318 = envPtr2 + 152
				v317 = *(*uintptr)(unsafe.Pointer(v318))
				*(*uintptr)(unsafe.Pointer(v318))++
				*(*uint8)(unsafe.Pointer(v317)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v320 = envPtr2 + 152
				v319 = *(*uintptr)(unsafe.Pointer(v320))
				*(*uintptr)(unsafe.Pointer(v320))++
				*(*uint8)(unsafe.Pointer(v319)) = uint8(libc.Uint32FromInt32(_objIndexCopy8))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy8
					}
					v321 = delta1
					v322 = envPtr2
					if v321 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v322)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v322)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v322)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v322)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v322 + 64)) += int64(v321)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v324 = envPtr2 + 152
				v323 = *(*uintptr)(unsafe.Pointer(v324))
				*(*uintptr)(unsafe.Pointer(v324))++
				*(*uint8)(unsafe.Pointer(v323)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v326 = envPtr2 + 152
				v325 = *(*uintptr)(unsafe.Pointer(v326))
				*(*uintptr)(unsafe.Pointer(v326))++
				*(*uint8)(unsafe.Pointer(v325)) = uint8(libc.Uint32FromInt32(_objIndexCopy8) >> libc.Int32FromInt32(24))
				v328 = envPtr2 + 152
				v327 = *(*uintptr)(unsafe.Pointer(v328))
				*(*uintptr)(unsafe.Pointer(v328))++
				*(*uint8)(unsafe.Pointer(v327)) = uint8(libc.Uint32FromInt32(_objIndexCopy8) >> libc.Int32FromInt32(16))
				v330 = envPtr2 + 152
				v329 = *(*uintptr)(unsafe.Pointer(v330))
				*(*uintptr)(unsafe.Pointer(v330))++
				*(*uint8)(unsafe.Pointer(v329)) = uint8(libc.Uint32FromInt32(_objIndexCopy8) >> libc.Int32FromInt32(8))
				v332 = envPtr2 + 152
				v331 = *(*uintptr)(unsafe.Pointer(v332))
				*(*uintptr)(unsafe.Pointer(v332))++
				*(*uint8)(unsafe.Pointer(v331)) = uint8(libc.Uint32FromInt32(_objIndexCopy8))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy8
					}
					v333 = delta1
					v334 = envPtr2
					if v333 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v334)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v334)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v334)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v334)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v334 + 64)) += int64(v333)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
			XTclCompileTokens(tls, interp, varTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents), envPtr2)
		}
		if varNameTmp <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v336 = envPtr2 + 152
			v335 = *(*uintptr)(unsafe.Pointer(v336))
			*(*uintptr)(unsafe.Pointer(v336))++
			*(*uint8)(unsafe.Pointer(v335)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
			v338 = envPtr2 + 152
			v337 = *(*uintptr)(unsafe.Pointer(v338))
			*(*uintptr)(unsafe.Pointer(v338))++
			*(*uint8)(unsafe.Pointer(v337)) = uint8(libc.Uint32FromInt32(varNameTmp))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - varNameTmp
				}
				v339 = delta1
				v340 = envPtr2
				if v339 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v340)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v340)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v340)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v340)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v340 + 64)) += int64(v339)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v342 = envPtr2 + 152
			v341 = *(*uintptr)(unsafe.Pointer(v342))
			*(*uintptr)(unsafe.Pointer(v342))++
			*(*uint8)(unsafe.Pointer(v341)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
			v344 = envPtr2 + 152
			v343 = *(*uintptr)(unsafe.Pointer(v344))
			*(*uintptr)(unsafe.Pointer(v344))++
			*(*uint8)(unsafe.Pointer(v343)) = uint8(libc.Uint32FromInt32(varNameTmp) >> libc.Int32FromInt32(24))
			v346 = envPtr2 + 152
			v345 = *(*uintptr)(unsafe.Pointer(v346))
			*(*uintptr)(unsafe.Pointer(v346))++
			*(*uint8)(unsafe.Pointer(v345)) = uint8(libc.Uint32FromInt32(varNameTmp) >> libc.Int32FromInt32(16))
			v348 = envPtr2 + 152
			v347 = *(*uintptr)(unsafe.Pointer(v348))
			*(*uintptr)(unsafe.Pointer(v348))++
			*(*uint8)(unsafe.Pointer(v347)) = uint8(libc.Uint32FromInt32(varNameTmp) >> libc.Int32FromInt32(8))
			v350 = envPtr2 + 152
			v349 = *(*uintptr)(unsafe.Pointer(v350))
			*(*uintptr)(unsafe.Pointer(v350))++
			*(*uint8)(unsafe.Pointer(v349)) = uint8(libc.Uint32FromInt32(varNameTmp))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - varNameTmp
				}
				v351 = delta1
				v352 = envPtr2
				if v351 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v352)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v352)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v352)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v352)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v352 + 64)) += int64(v351)
			}
		}
	}
	tokenPtr = varTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if gotPath != 0 {
		i1 = int32(2)
		for {
			if !(i1 < int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-int32(1)) {
				break
			}
			if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
				_objIndexCopy9 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
				if _objIndexCopy9 <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v355 = envPtr2 + 152
					v354 = *(*uintptr)(unsafe.Pointer(v355))
					*(*uintptr)(unsafe.Pointer(v355))++
					*(*uint8)(unsafe.Pointer(v354)) = libc.Uint8FromInt32(int32(INST_PUSH1))
					v357 = envPtr2 + 152
					v356 = *(*uintptr)(unsafe.Pointer(v357))
					*(*uintptr)(unsafe.Pointer(v357))++
					*(*uint8)(unsafe.Pointer(v356)) = uint8(libc.Uint32FromInt32(_objIndexCopy9))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy9
						}
						v358 = delta1
						v359 = envPtr2
						if v358 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v359)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v359)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v359)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v359)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v359 + 64)) += int64(v358)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v361 = envPtr2 + 152
					v360 = *(*uintptr)(unsafe.Pointer(v361))
					*(*uintptr)(unsafe.Pointer(v361))++
					*(*uint8)(unsafe.Pointer(v360)) = libc.Uint8FromInt32(int32(INST_PUSH4))
					v363 = envPtr2 + 152
					v362 = *(*uintptr)(unsafe.Pointer(v363))
					*(*uintptr)(unsafe.Pointer(v363))++
					*(*uint8)(unsafe.Pointer(v362)) = uint8(libc.Uint32FromInt32(_objIndexCopy9) >> libc.Int32FromInt32(24))
					v365 = envPtr2 + 152
					v364 = *(*uintptr)(unsafe.Pointer(v365))
					*(*uintptr)(unsafe.Pointer(v365))++
					*(*uint8)(unsafe.Pointer(v364)) = uint8(libc.Uint32FromInt32(_objIndexCopy9) >> libc.Int32FromInt32(16))
					v367 = envPtr2 + 152
					v366 = *(*uintptr)(unsafe.Pointer(v367))
					*(*uintptr)(unsafe.Pointer(v367))++
					*(*uint8)(unsafe.Pointer(v366)) = uint8(libc.Uint32FromInt32(_objIndexCopy9) >> libc.Int32FromInt32(8))
					v369 = envPtr2 + 152
					v368 = *(*uintptr)(unsafe.Pointer(v369))
					*(*uintptr)(unsafe.Pointer(v369))++
					*(*uint8)(unsafe.Pointer(v368)) = uint8(libc.Uint32FromInt32(_objIndexCopy9))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy9
						}
						v370 = delta1
						v371 = envPtr2
						if v370 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v371)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v371)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v371)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v371)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v371 + 64)) += int64(v370)
					}
				}
			} else {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
				XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
			}
			tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
			goto _353
		_353:
			;
			i1++
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v373 = envPtr2 + 152
		v372 = *(*uintptr)(unsafe.Pointer(v373))
		*(*uintptr)(unsafe.Pointer(v373))++
		*(*uint8)(unsafe.Pointer(v372)) = libc.Uint8FromInt32(int32(INST_LIST))
		v375 = envPtr2 + 152
		v374 = *(*uintptr)(unsafe.Pointer(v375))
		*(*uintptr)(unsafe.Pointer(v375))++
		*(*uint8)(unsafe.Pointer(v374)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(3)) >> libc.Int32FromInt32(24))
		v377 = envPtr2 + 152
		v376 = *(*uintptr)(unsafe.Pointer(v377))
		*(*uintptr)(unsafe.Pointer(v377))++
		*(*uint8)(unsafe.Pointer(v376)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(3)) >> libc.Int32FromInt32(16))
		v379 = envPtr2 + 152
		v378 = *(*uintptr)(unsafe.Pointer(v379))
		*(*uintptr)(unsafe.Pointer(v379))++
		*(*uint8)(unsafe.Pointer(v378)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(3)) >> libc.Int32FromInt32(8))
		v381 = envPtr2 + 152
		v380 = *(*uintptr)(unsafe.Pointer(v381))
		*(*uintptr)(unsafe.Pointer(v381))++
		*(*uint8)(unsafe.Pointer(v380)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) - libc.Int32FromInt32(3)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LIST)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - (int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) - int32(3))
			}
			v382 = delta1
			v383 = envPtr2
			if v382 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v383)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v383)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v383)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v383)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v383 + 64)) += int64(v382)
		}
		if pathTmp <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v385 = envPtr2 + 152
			v384 = *(*uintptr)(unsafe.Pointer(v385))
			*(*uintptr)(unsafe.Pointer(v385))++
			*(*uint8)(unsafe.Pointer(v384)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
			v387 = envPtr2 + 152
			v386 = *(*uintptr)(unsafe.Pointer(v387))
			*(*uintptr)(unsafe.Pointer(v387))++
			*(*uint8)(unsafe.Pointer(v386)) = uint8(libc.Uint32FromInt32(pathTmp))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - pathTmp
				}
				v388 = delta1
				v389 = envPtr2
				if v388 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v389)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v389)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v389)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v389)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v389 + 64)) += int64(v388)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v391 = envPtr2 + 152
			v390 = *(*uintptr)(unsafe.Pointer(v391))
			*(*uintptr)(unsafe.Pointer(v391))++
			*(*uint8)(unsafe.Pointer(v390)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
			v393 = envPtr2 + 152
			v392 = *(*uintptr)(unsafe.Pointer(v393))
			*(*uintptr)(unsafe.Pointer(v393))++
			*(*uint8)(unsafe.Pointer(v392)) = uint8(libc.Uint32FromInt32(pathTmp) >> libc.Int32FromInt32(24))
			v395 = envPtr2 + 152
			v394 = *(*uintptr)(unsafe.Pointer(v395))
			*(*uintptr)(unsafe.Pointer(v395))++
			*(*uint8)(unsafe.Pointer(v394)) = uint8(libc.Uint32FromInt32(pathTmp) >> libc.Int32FromInt32(16))
			v397 = envPtr2 + 152
			v396 = *(*uintptr)(unsafe.Pointer(v397))
			*(*uintptr)(unsafe.Pointer(v397))++
			*(*uint8)(unsafe.Pointer(v396)) = uint8(libc.Uint32FromInt32(pathTmp) >> libc.Int32FromInt32(8))
			v399 = envPtr2 + 152
			v398 = *(*uintptr)(unsafe.Pointer(v399))
			*(*uintptr)(unsafe.Pointer(v399))++
			*(*uint8)(unsafe.Pointer(v398)) = uint8(libc.Uint32FromInt32(pathTmp))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - pathTmp
				}
				v400 = delta1
				v401 = envPtr2
				if v400 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v401)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v401)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v401)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v401)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v401 + 64)) += int64(v400)
			}
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v403 = envPtr2 + 152
		v402 = *(*uintptr)(unsafe.Pointer(v403))
		*(*uintptr)(unsafe.Pointer(v403))++
		*(*uint8)(unsafe.Pointer(v402)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v404 = delta1
			v405 = envPtr2
			if v404 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v405)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v405)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v405)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v405)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v405 + 64)) += int64(v404)
		}
	}
	if dictVar == -int32(1) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v407 = envPtr2 + 152
		v406 = *(*uintptr)(unsafe.Pointer(v407))
		*(*uintptr)(unsafe.Pointer(v407))++
		*(*uint8)(unsafe.Pointer(v406)) = libc.Uint8FromInt32(int32(INST_LOAD_STK))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LOAD_STK)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v408 = delta1
			v409 = envPtr2
			if v408 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v409)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v409)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v409)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v409)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v409 + 64)) += int64(v408)
		}
	} else {
		if dictVar <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v411 = envPtr2 + 152
			v410 = *(*uintptr)(unsafe.Pointer(v411))
			*(*uintptr)(unsafe.Pointer(v411))++
			*(*uint8)(unsafe.Pointer(v410)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
			v413 = envPtr2 + 152
			v412 = *(*uintptr)(unsafe.Pointer(v413))
			*(*uintptr)(unsafe.Pointer(v413))++
			*(*uint8)(unsafe.Pointer(v412)) = uint8(libc.Uint32FromInt32(dictVar))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - dictVar
				}
				v414 = delta1
				v415 = envPtr2
				if v414 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v415)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v415)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v415)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v415)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v415 + 64)) += int64(v414)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v417 = envPtr2 + 152
			v416 = *(*uintptr)(unsafe.Pointer(v417))
			*(*uintptr)(unsafe.Pointer(v417))++
			*(*uint8)(unsafe.Pointer(v416)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
			v419 = envPtr2 + 152
			v418 = *(*uintptr)(unsafe.Pointer(v419))
			*(*uintptr)(unsafe.Pointer(v419))++
			*(*uint8)(unsafe.Pointer(v418)) = uint8(libc.Uint32FromInt32(dictVar) >> libc.Int32FromInt32(24))
			v421 = envPtr2 + 152
			v420 = *(*uintptr)(unsafe.Pointer(v421))
			*(*uintptr)(unsafe.Pointer(v421))++
			*(*uint8)(unsafe.Pointer(v420)) = uint8(libc.Uint32FromInt32(dictVar) >> libc.Int32FromInt32(16))
			v423 = envPtr2 + 152
			v422 = *(*uintptr)(unsafe.Pointer(v423))
			*(*uintptr)(unsafe.Pointer(v423))++
			*(*uint8)(unsafe.Pointer(v422)) = uint8(libc.Uint32FromInt32(dictVar) >> libc.Int32FromInt32(8))
			v425 = envPtr2 + 152
			v424 = *(*uintptr)(unsafe.Pointer(v425))
			*(*uintptr)(unsafe.Pointer(v425))++
			*(*uint8)(unsafe.Pointer(v424)) = uint8(libc.Uint32FromInt32(dictVar))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - dictVar
				}
				v426 = delta1
				v427 = envPtr2
				if v426 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v427)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v427)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v427)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v427)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v427 + 64)) += int64(v426)
			}
		}
	}
	if gotPath != 0 {
		if pathTmp <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v429 = envPtr2 + 152
			v428 = *(*uintptr)(unsafe.Pointer(v429))
			*(*uintptr)(unsafe.Pointer(v429))++
			*(*uint8)(unsafe.Pointer(v428)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
			v431 = envPtr2 + 152
			v430 = *(*uintptr)(unsafe.Pointer(v431))
			*(*uintptr)(unsafe.Pointer(v431))++
			*(*uint8)(unsafe.Pointer(v430)) = uint8(libc.Uint32FromInt32(pathTmp))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - pathTmp
				}
				v432 = delta1
				v433 = envPtr2
				if v432 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v433)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v433)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v433)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v433)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v433 + 64)) += int64(v432)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v435 = envPtr2 + 152
			v434 = *(*uintptr)(unsafe.Pointer(v435))
			*(*uintptr)(unsafe.Pointer(v435))++
			*(*uint8)(unsafe.Pointer(v434)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
			v437 = envPtr2 + 152
			v436 = *(*uintptr)(unsafe.Pointer(v437))
			*(*uintptr)(unsafe.Pointer(v437))++
			*(*uint8)(unsafe.Pointer(v436)) = uint8(libc.Uint32FromInt32(pathTmp) >> libc.Int32FromInt32(24))
			v439 = envPtr2 + 152
			v438 = *(*uintptr)(unsafe.Pointer(v439))
			*(*uintptr)(unsafe.Pointer(v439))++
			*(*uint8)(unsafe.Pointer(v438)) = uint8(libc.Uint32FromInt32(pathTmp) >> libc.Int32FromInt32(16))
			v441 = envPtr2 + 152
			v440 = *(*uintptr)(unsafe.Pointer(v441))
			*(*uintptr)(unsafe.Pointer(v441))++
			*(*uint8)(unsafe.Pointer(v440)) = uint8(libc.Uint32FromInt32(pathTmp) >> libc.Int32FromInt32(8))
			v443 = envPtr2 + 152
			v442 = *(*uintptr)(unsafe.Pointer(v443))
			*(*uintptr)(unsafe.Pointer(v443))++
			*(*uint8)(unsafe.Pointer(v442)) = uint8(libc.Uint32FromInt32(pathTmp))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - pathTmp
				}
				v444 = delta1
				v445 = envPtr2
				if v444 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v445)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v445)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v445)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v445)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v445 + 64)) += int64(v444)
			}
		}
	} else {
		_objIndexCopy10 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy10 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v447 = envPtr2 + 152
			v446 = *(*uintptr)(unsafe.Pointer(v447))
			*(*uintptr)(unsafe.Pointer(v447))++
			*(*uint8)(unsafe.Pointer(v446)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v449 = envPtr2 + 152
			v448 = *(*uintptr)(unsafe.Pointer(v449))
			*(*uintptr)(unsafe.Pointer(v449))++
			*(*uint8)(unsafe.Pointer(v448)) = uint8(libc.Uint32FromInt32(_objIndexCopy10))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy10
				}
				v450 = delta1
				v451 = envPtr2
				if v450 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v451)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v451)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v451)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v451)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v451 + 64)) += int64(v450)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v453 = envPtr2 + 152
			v452 = *(*uintptr)(unsafe.Pointer(v453))
			*(*uintptr)(unsafe.Pointer(v453))++
			*(*uint8)(unsafe.Pointer(v452)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v455 = envPtr2 + 152
			v454 = *(*uintptr)(unsafe.Pointer(v455))
			*(*uintptr)(unsafe.Pointer(v455))++
			*(*uint8)(unsafe.Pointer(v454)) = uint8(libc.Uint32FromInt32(_objIndexCopy10) >> libc.Int32FromInt32(24))
			v457 = envPtr2 + 152
			v456 = *(*uintptr)(unsafe.Pointer(v457))
			*(*uintptr)(unsafe.Pointer(v457))++
			*(*uint8)(unsafe.Pointer(v456)) = uint8(libc.Uint32FromInt32(_objIndexCopy10) >> libc.Int32FromInt32(16))
			v459 = envPtr2 + 152
			v458 = *(*uintptr)(unsafe.Pointer(v459))
			*(*uintptr)(unsafe.Pointer(v459))++
			*(*uint8)(unsafe.Pointer(v458)) = uint8(libc.Uint32FromInt32(_objIndexCopy10) >> libc.Int32FromInt32(8))
			v461 = envPtr2 + 152
			v460 = *(*uintptr)(unsafe.Pointer(v461))
			*(*uintptr)(unsafe.Pointer(v461))++
			*(*uint8)(unsafe.Pointer(v460)) = uint8(libc.Uint32FromInt32(_objIndexCopy10))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy10
				}
				v462 = delta1
				v463 = envPtr2
				if v462 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v463)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v463)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v463)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v463)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v463 + 64)) += int64(v462)
			}
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v465 = envPtr2 + 152
	v464 = *(*uintptr)(unsafe.Pointer(v465))
	*(*uintptr)(unsafe.Pointer(v465))++
	*(*uint8)(unsafe.Pointer(v464)) = libc.Uint8FromInt32(int32(INST_DICT_EXPAND))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_DICT_EXPAND)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v466 = delta1
		v467 = envPtr2
		if v466 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v467)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v467)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v467)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v467)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v467 + 64)) += int64(v466)
	}
	if keysTmp <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v469 = envPtr2 + 152
		v468 = *(*uintptr)(unsafe.Pointer(v469))
		*(*uintptr)(unsafe.Pointer(v469))++
		*(*uint8)(unsafe.Pointer(v468)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
		v471 = envPtr2 + 152
		v470 = *(*uintptr)(unsafe.Pointer(v471))
		*(*uintptr)(unsafe.Pointer(v471))++
		*(*uint8)(unsafe.Pointer(v470)) = uint8(libc.Uint32FromInt32(keysTmp))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - keysTmp
			}
			v472 = delta1
			v473 = envPtr2
			if v472 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v473)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v473)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v473)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v473)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v473 + 64)) += int64(v472)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v475 = envPtr2 + 152
		v474 = *(*uintptr)(unsafe.Pointer(v475))
		*(*uintptr)(unsafe.Pointer(v475))++
		*(*uint8)(unsafe.Pointer(v474)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
		v477 = envPtr2 + 152
		v476 = *(*uintptr)(unsafe.Pointer(v477))
		*(*uintptr)(unsafe.Pointer(v477))++
		*(*uint8)(unsafe.Pointer(v476)) = uint8(libc.Uint32FromInt32(keysTmp) >> libc.Int32FromInt32(24))
		v479 = envPtr2 + 152
		v478 = *(*uintptr)(unsafe.Pointer(v479))
		*(*uintptr)(unsafe.Pointer(v479))++
		*(*uint8)(unsafe.Pointer(v478)) = uint8(libc.Uint32FromInt32(keysTmp) >> libc.Int32FromInt32(16))
		v481 = envPtr2 + 152
		v480 = *(*uintptr)(unsafe.Pointer(v481))
		*(*uintptr)(unsafe.Pointer(v481))++
		*(*uint8)(unsafe.Pointer(v480)) = uint8(libc.Uint32FromInt32(keysTmp) >> libc.Int32FromInt32(8))
		v483 = envPtr2 + 152
		v482 = *(*uintptr)(unsafe.Pointer(v483))
		*(*uintptr)(unsafe.Pointer(v483))++
		*(*uint8)(unsafe.Pointer(v482)) = uint8(libc.Uint32FromInt32(keysTmp))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - keysTmp
			}
			v484 = delta1
			v485 = envPtr2
			if v484 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v485)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v485)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v485)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v485)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v485 + 64)) += int64(v484)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v487 = envPtr2 + 152
	v486 = *(*uintptr)(unsafe.Pointer(v487))
	*(*uintptr)(unsafe.Pointer(v487))++
	*(*uint8)(unsafe.Pointer(v486)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v488 = delta1
		v489 = envPtr2
		if v488 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v489)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v489)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v489)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v489)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v489 + 64)) += int64(v488)
	}
	/*
	 * Now the body of the [dict with].
	 */
	range1 = int32(XTclCreateExceptRange(tls, int32(CATCH_EXCEPTION_RANGE), envPtr2))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v491 = envPtr2 + 152
	v490 = *(*uintptr)(unsafe.Pointer(v491))
	*(*uintptr)(unsafe.Pointer(v491))++
	*(*uint8)(unsafe.Pointer(v490)) = libc.Uint8FromInt32(int32(INST_BEGIN_CATCH4))
	v493 = envPtr2 + 152
	v492 = *(*uintptr)(unsafe.Pointer(v493))
	*(*uintptr)(unsafe.Pointer(v493))++
	*(*uint8)(unsafe.Pointer(v492)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(24))
	v495 = envPtr2 + 152
	v494 = *(*uintptr)(unsafe.Pointer(v495))
	*(*uintptr)(unsafe.Pointer(v495))++
	*(*uint8)(unsafe.Pointer(v494)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(16))
	v497 = envPtr2 + 152
	v496 = *(*uintptr)(unsafe.Pointer(v497))
	*(*uintptr)(unsafe.Pointer(v497))++
	*(*uint8)(unsafe.Pointer(v496)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(8))
	v499 = envPtr2 + 152
	v498 = *(*uintptr)(unsafe.Pointer(v499))
	*(*uintptr)(unsafe.Pointer(v499))++
	*(*uint8)(unsafe.Pointer(v498)) = uint8(libc.Uint32FromInt32(range1))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_BEGIN_CATCH4)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - range1
		}
		v500 = delta1
		v501 = envPtr2
		if v500 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v501)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v501)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v501)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v501)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v501 + 64)) += int64(v500)
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth++
	if libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth)+uint64(1) > libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth)+uint64(1) {
		v502 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth
	} else {
		v502 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth = v502
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords-libc.Int64FromInt32(1))*8))
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords-libc.Int64FromInt32(1))*8))
	XTclCompileCmdWord(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth--
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FnumCodeBytes = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(int32((*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset))
	/*
	 * Now fold the results back into the dictionary in the OK case.
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v504 = envPtr2 + 152
	v503 = *(*uintptr)(unsafe.Pointer(v504))
	*(*uintptr)(unsafe.Pointer(v504))++
	*(*uint8)(unsafe.Pointer(v503)) = libc.Uint8FromInt32(int32(INST_END_CATCH))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_END_CATCH)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v505 = delta1
		v506 = envPtr2
		if v505 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v506)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v506)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v506)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v506)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v506 + 64)) += int64(v505)
	}
	if dictVar == -int32(1) {
		if varNameTmp <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v508 = envPtr2 + 152
			v507 = *(*uintptr)(unsafe.Pointer(v508))
			*(*uintptr)(unsafe.Pointer(v508))++
			*(*uint8)(unsafe.Pointer(v507)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
			v510 = envPtr2 + 152
			v509 = *(*uintptr)(unsafe.Pointer(v510))
			*(*uintptr)(unsafe.Pointer(v510))++
			*(*uint8)(unsafe.Pointer(v509)) = uint8(libc.Uint32FromInt32(varNameTmp))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - varNameTmp
				}
				v511 = delta1
				v512 = envPtr2
				if v511 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v512)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v512)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v512)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v512)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v512 + 64)) += int64(v511)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v514 = envPtr2 + 152
			v513 = *(*uintptr)(unsafe.Pointer(v514))
			*(*uintptr)(unsafe.Pointer(v514))++
			*(*uint8)(unsafe.Pointer(v513)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
			v516 = envPtr2 + 152
			v515 = *(*uintptr)(unsafe.Pointer(v516))
			*(*uintptr)(unsafe.Pointer(v516))++
			*(*uint8)(unsafe.Pointer(v515)) = uint8(libc.Uint32FromInt32(varNameTmp) >> libc.Int32FromInt32(24))
			v518 = envPtr2 + 152
			v517 = *(*uintptr)(unsafe.Pointer(v518))
			*(*uintptr)(unsafe.Pointer(v518))++
			*(*uint8)(unsafe.Pointer(v517)) = uint8(libc.Uint32FromInt32(varNameTmp) >> libc.Int32FromInt32(16))
			v520 = envPtr2 + 152
			v519 = *(*uintptr)(unsafe.Pointer(v520))
			*(*uintptr)(unsafe.Pointer(v520))++
			*(*uint8)(unsafe.Pointer(v519)) = uint8(libc.Uint32FromInt32(varNameTmp) >> libc.Int32FromInt32(8))
			v522 = envPtr2 + 152
			v521 = *(*uintptr)(unsafe.Pointer(v522))
			*(*uintptr)(unsafe.Pointer(v522))++
			*(*uint8)(unsafe.Pointer(v521)) = uint8(libc.Uint32FromInt32(varNameTmp))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - varNameTmp
				}
				v523 = delta1
				v524 = envPtr2
				if v523 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v524)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v524)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v524)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v524)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v524 + 64)) += int64(v523)
			}
		}
	}
	if gotPath != 0 {
		if pathTmp <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v526 = envPtr2 + 152
			v525 = *(*uintptr)(unsafe.Pointer(v526))
			*(*uintptr)(unsafe.Pointer(v526))++
			*(*uint8)(unsafe.Pointer(v525)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
			v528 = envPtr2 + 152
			v527 = *(*uintptr)(unsafe.Pointer(v528))
			*(*uintptr)(unsafe.Pointer(v528))++
			*(*uint8)(unsafe.Pointer(v527)) = uint8(libc.Uint32FromInt32(pathTmp))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - pathTmp
				}
				v529 = delta1
				v530 = envPtr2
				if v529 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v530)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v530)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v530)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v530)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v530 + 64)) += int64(v529)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v532 = envPtr2 + 152
			v531 = *(*uintptr)(unsafe.Pointer(v532))
			*(*uintptr)(unsafe.Pointer(v532))++
			*(*uint8)(unsafe.Pointer(v531)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
			v534 = envPtr2 + 152
			v533 = *(*uintptr)(unsafe.Pointer(v534))
			*(*uintptr)(unsafe.Pointer(v534))++
			*(*uint8)(unsafe.Pointer(v533)) = uint8(libc.Uint32FromInt32(pathTmp) >> libc.Int32FromInt32(24))
			v536 = envPtr2 + 152
			v535 = *(*uintptr)(unsafe.Pointer(v536))
			*(*uintptr)(unsafe.Pointer(v536))++
			*(*uint8)(unsafe.Pointer(v535)) = uint8(libc.Uint32FromInt32(pathTmp) >> libc.Int32FromInt32(16))
			v538 = envPtr2 + 152
			v537 = *(*uintptr)(unsafe.Pointer(v538))
			*(*uintptr)(unsafe.Pointer(v538))++
			*(*uint8)(unsafe.Pointer(v537)) = uint8(libc.Uint32FromInt32(pathTmp) >> libc.Int32FromInt32(8))
			v540 = envPtr2 + 152
			v539 = *(*uintptr)(unsafe.Pointer(v540))
			*(*uintptr)(unsafe.Pointer(v540))++
			*(*uint8)(unsafe.Pointer(v539)) = uint8(libc.Uint32FromInt32(pathTmp))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - pathTmp
				}
				v541 = delta1
				v542 = envPtr2
				if v541 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v542)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v542)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v542)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v542)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v542 + 64)) += int64(v541)
			}
		}
	} else {
		_objIndexCopy11 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy11 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v544 = envPtr2 + 152
			v543 = *(*uintptr)(unsafe.Pointer(v544))
			*(*uintptr)(unsafe.Pointer(v544))++
			*(*uint8)(unsafe.Pointer(v543)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v546 = envPtr2 + 152
			v545 = *(*uintptr)(unsafe.Pointer(v546))
			*(*uintptr)(unsafe.Pointer(v546))++
			*(*uint8)(unsafe.Pointer(v545)) = uint8(libc.Uint32FromInt32(_objIndexCopy11))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy11
				}
				v547 = delta1
				v548 = envPtr2
				if v547 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v548)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v548)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v548)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v548)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v548 + 64)) += int64(v547)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v550 = envPtr2 + 152
			v549 = *(*uintptr)(unsafe.Pointer(v550))
			*(*uintptr)(unsafe.Pointer(v550))++
			*(*uint8)(unsafe.Pointer(v549)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v552 = envPtr2 + 152
			v551 = *(*uintptr)(unsafe.Pointer(v552))
			*(*uintptr)(unsafe.Pointer(v552))++
			*(*uint8)(unsafe.Pointer(v551)) = uint8(libc.Uint32FromInt32(_objIndexCopy11) >> libc.Int32FromInt32(24))
			v554 = envPtr2 + 152
			v553 = *(*uintptr)(unsafe.Pointer(v554))
			*(*uintptr)(unsafe.Pointer(v554))++
			*(*uint8)(unsafe.Pointer(v553)) = uint8(libc.Uint32FromInt32(_objIndexCopy11) >> libc.Int32FromInt32(16))
			v556 = envPtr2 + 152
			v555 = *(*uintptr)(unsafe.Pointer(v556))
			*(*uintptr)(unsafe.Pointer(v556))++
			*(*uint8)(unsafe.Pointer(v555)) = uint8(libc.Uint32FromInt32(_objIndexCopy11) >> libc.Int32FromInt32(8))
			v558 = envPtr2 + 152
			v557 = *(*uintptr)(unsafe.Pointer(v558))
			*(*uintptr)(unsafe.Pointer(v558))++
			*(*uint8)(unsafe.Pointer(v557)) = uint8(libc.Uint32FromInt32(_objIndexCopy11))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy11
				}
				v559 = delta1
				v560 = envPtr2
				if v559 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v560)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v560)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v560)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v560)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v560 + 64)) += int64(v559)
			}
		}
	}
	if keysTmp <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v562 = envPtr2 + 152
		v561 = *(*uintptr)(unsafe.Pointer(v562))
		*(*uintptr)(unsafe.Pointer(v562))++
		*(*uint8)(unsafe.Pointer(v561)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
		v564 = envPtr2 + 152
		v563 = *(*uintptr)(unsafe.Pointer(v564))
		*(*uintptr)(unsafe.Pointer(v564))++
		*(*uint8)(unsafe.Pointer(v563)) = uint8(libc.Uint32FromInt32(keysTmp))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - keysTmp
			}
			v565 = delta1
			v566 = envPtr2
			if v565 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v566)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v566)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v566)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v566)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v566 + 64)) += int64(v565)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v568 = envPtr2 + 152
		v567 = *(*uintptr)(unsafe.Pointer(v568))
		*(*uintptr)(unsafe.Pointer(v568))++
		*(*uint8)(unsafe.Pointer(v567)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
		v570 = envPtr2 + 152
		v569 = *(*uintptr)(unsafe.Pointer(v570))
		*(*uintptr)(unsafe.Pointer(v570))++
		*(*uint8)(unsafe.Pointer(v569)) = uint8(libc.Uint32FromInt32(keysTmp) >> libc.Int32FromInt32(24))
		v572 = envPtr2 + 152
		v571 = *(*uintptr)(unsafe.Pointer(v572))
		*(*uintptr)(unsafe.Pointer(v572))++
		*(*uint8)(unsafe.Pointer(v571)) = uint8(libc.Uint32FromInt32(keysTmp) >> libc.Int32FromInt32(16))
		v574 = envPtr2 + 152
		v573 = *(*uintptr)(unsafe.Pointer(v574))
		*(*uintptr)(unsafe.Pointer(v574))++
		*(*uint8)(unsafe.Pointer(v573)) = uint8(libc.Uint32FromInt32(keysTmp) >> libc.Int32FromInt32(8))
		v576 = envPtr2 + 152
		v575 = *(*uintptr)(unsafe.Pointer(v576))
		*(*uintptr)(unsafe.Pointer(v576))++
		*(*uint8)(unsafe.Pointer(v575)) = uint8(libc.Uint32FromInt32(keysTmp))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - keysTmp
			}
			v577 = delta1
			v578 = envPtr2
			if v577 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v578)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v578)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v578)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v578)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v578 + 64)) += int64(v577)
		}
	}
	if dictVar == -int32(1) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v580 = envPtr2 + 152
		v579 = *(*uintptr)(unsafe.Pointer(v580))
		*(*uintptr)(unsafe.Pointer(v580))++
		*(*uint8)(unsafe.Pointer(v579)) = libc.Uint8FromInt32(int32(INST_DICT_RECOMBINE_STK))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_DICT_RECOMBINE_STK)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v581 = delta1
			v582 = envPtr2
			if v581 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v582)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v582)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v582)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v582)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v582 + 64)) += int64(v581)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v584 = envPtr2 + 152
		v583 = *(*uintptr)(unsafe.Pointer(v584))
		*(*uintptr)(unsafe.Pointer(v584))++
		*(*uint8)(unsafe.Pointer(v583)) = libc.Uint8FromInt32(int32(INST_DICT_RECOMBINE_IMM))
		v586 = envPtr2 + 152
		v585 = *(*uintptr)(unsafe.Pointer(v586))
		*(*uintptr)(unsafe.Pointer(v586))++
		*(*uint8)(unsafe.Pointer(v585)) = uint8(libc.Uint32FromInt32(dictVar) >> libc.Int32FromInt32(24))
		v588 = envPtr2 + 152
		v587 = *(*uintptr)(unsafe.Pointer(v588))
		*(*uintptr)(unsafe.Pointer(v588))++
		*(*uint8)(unsafe.Pointer(v587)) = uint8(libc.Uint32FromInt32(dictVar) >> libc.Int32FromInt32(16))
		v590 = envPtr2 + 152
		v589 = *(*uintptr)(unsafe.Pointer(v590))
		*(*uintptr)(unsafe.Pointer(v590))++
		*(*uint8)(unsafe.Pointer(v589)) = uint8(libc.Uint32FromInt32(dictVar) >> libc.Int32FromInt32(8))
		v592 = envPtr2 + 152
		v591 = *(*uintptr)(unsafe.Pointer(v592))
		*(*uintptr)(unsafe.Pointer(v592))++
		*(*uint8)(unsafe.Pointer(v591)) = uint8(libc.Uint32FromInt32(dictVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_DICT_RECOMBINE_IMM)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - dictVar
			}
			v593 = delta1
			v594 = envPtr2
			if v593 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v594)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v594)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v594)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v594)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v594 + 64)) += int64(v593)
		}
	}
	XTclEmitForwardJump(tls, envPtr2, int32(TCL_UNCONDITIONAL_JUMP), bp)
	/*
	 * Now fold the results back into the dictionary in the exception case.
	 */
	v595 = -int32(1)
	v596 = envPtr2
	if v595 < libc.Int32FromInt32(0) {
		if int32((*TCompileEnv)(unsafe.Pointer(v596)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v596)).FcurrStackDepth) {
			(*TCompileEnv)(unsafe.Pointer(v596)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v596)).FcurrStackDepth
		}
	}
	*(*TTcl_Size)(unsafe.Pointer(v596 + 64)) += int64(v595)
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcatchOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v598 = envPtr2 + 152
	v597 = *(*uintptr)(unsafe.Pointer(v598))
	*(*uintptr)(unsafe.Pointer(v598))++
	*(*uint8)(unsafe.Pointer(v597)) = libc.Uint8FromInt32(int32(INST_PUSH_RETURN_OPTIONS))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_PUSH_RETURN_OPTIONS)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v599 = delta1
		v600 = envPtr2
		if v599 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v600)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v600)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v600)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v600)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v600 + 64)) += int64(v599)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v602 = envPtr2 + 152
	v601 = *(*uintptr)(unsafe.Pointer(v602))
	*(*uintptr)(unsafe.Pointer(v602))++
	*(*uint8)(unsafe.Pointer(v601)) = libc.Uint8FromInt32(int32(INST_PUSH_RESULT))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_PUSH_RESULT)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v603 = delta1
		v604 = envPtr2
		if v603 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v604)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v604)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v604)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v604)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v604 + 64)) += int64(v603)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v606 = envPtr2 + 152
	v605 = *(*uintptr)(unsafe.Pointer(v606))
	*(*uintptr)(unsafe.Pointer(v606))++
	*(*uint8)(unsafe.Pointer(v605)) = libc.Uint8FromInt32(int32(INST_END_CATCH))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_END_CATCH)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v607 = delta1
		v608 = envPtr2
		if v607 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v608)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v608)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v608)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v608)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v608 + 64)) += int64(v607)
	}
	if dictVar == -int32(1) {
		if varNameTmp <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v610 = envPtr2 + 152
			v609 = *(*uintptr)(unsafe.Pointer(v610))
			*(*uintptr)(unsafe.Pointer(v610))++
			*(*uint8)(unsafe.Pointer(v609)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
			v612 = envPtr2 + 152
			v611 = *(*uintptr)(unsafe.Pointer(v612))
			*(*uintptr)(unsafe.Pointer(v612))++
			*(*uint8)(unsafe.Pointer(v611)) = uint8(libc.Uint32FromInt32(varNameTmp))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - varNameTmp
				}
				v613 = delta1
				v614 = envPtr2
				if v613 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v614)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v614)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v614)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v614)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v614 + 64)) += int64(v613)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v616 = envPtr2 + 152
			v615 = *(*uintptr)(unsafe.Pointer(v616))
			*(*uintptr)(unsafe.Pointer(v616))++
			*(*uint8)(unsafe.Pointer(v615)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
			v618 = envPtr2 + 152
			v617 = *(*uintptr)(unsafe.Pointer(v618))
			*(*uintptr)(unsafe.Pointer(v618))++
			*(*uint8)(unsafe.Pointer(v617)) = uint8(libc.Uint32FromInt32(varNameTmp) >> libc.Int32FromInt32(24))
			v620 = envPtr2 + 152
			v619 = *(*uintptr)(unsafe.Pointer(v620))
			*(*uintptr)(unsafe.Pointer(v620))++
			*(*uint8)(unsafe.Pointer(v619)) = uint8(libc.Uint32FromInt32(varNameTmp) >> libc.Int32FromInt32(16))
			v622 = envPtr2 + 152
			v621 = *(*uintptr)(unsafe.Pointer(v622))
			*(*uintptr)(unsafe.Pointer(v622))++
			*(*uint8)(unsafe.Pointer(v621)) = uint8(libc.Uint32FromInt32(varNameTmp) >> libc.Int32FromInt32(8))
			v624 = envPtr2 + 152
			v623 = *(*uintptr)(unsafe.Pointer(v624))
			*(*uintptr)(unsafe.Pointer(v624))++
			*(*uint8)(unsafe.Pointer(v623)) = uint8(libc.Uint32FromInt32(varNameTmp))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - varNameTmp
				}
				v625 = delta1
				v626 = envPtr2
				if v625 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v626)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v626)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v626)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v626)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v626 + 64)) += int64(v625)
			}
		}
	}
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) > int32(3) {
		if pathTmp <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v628 = envPtr2 + 152
			v627 = *(*uintptr)(unsafe.Pointer(v628))
			*(*uintptr)(unsafe.Pointer(v628))++
			*(*uint8)(unsafe.Pointer(v627)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
			v630 = envPtr2 + 152
			v629 = *(*uintptr)(unsafe.Pointer(v630))
			*(*uintptr)(unsafe.Pointer(v630))++
			*(*uint8)(unsafe.Pointer(v629)) = uint8(libc.Uint32FromInt32(pathTmp))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - pathTmp
				}
				v631 = delta1
				v632 = envPtr2
				if v631 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v632)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v632)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v632)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v632)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v632 + 64)) += int64(v631)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v634 = envPtr2 + 152
			v633 = *(*uintptr)(unsafe.Pointer(v634))
			*(*uintptr)(unsafe.Pointer(v634))++
			*(*uint8)(unsafe.Pointer(v633)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
			v636 = envPtr2 + 152
			v635 = *(*uintptr)(unsafe.Pointer(v636))
			*(*uintptr)(unsafe.Pointer(v636))++
			*(*uint8)(unsafe.Pointer(v635)) = uint8(libc.Uint32FromInt32(pathTmp) >> libc.Int32FromInt32(24))
			v638 = envPtr2 + 152
			v637 = *(*uintptr)(unsafe.Pointer(v638))
			*(*uintptr)(unsafe.Pointer(v638))++
			*(*uint8)(unsafe.Pointer(v637)) = uint8(libc.Uint32FromInt32(pathTmp) >> libc.Int32FromInt32(16))
			v640 = envPtr2 + 152
			v639 = *(*uintptr)(unsafe.Pointer(v640))
			*(*uintptr)(unsafe.Pointer(v640))++
			*(*uint8)(unsafe.Pointer(v639)) = uint8(libc.Uint32FromInt32(pathTmp) >> libc.Int32FromInt32(8))
			v642 = envPtr2 + 152
			v641 = *(*uintptr)(unsafe.Pointer(v642))
			*(*uintptr)(unsafe.Pointer(v642))++
			*(*uint8)(unsafe.Pointer(v641)) = uint8(libc.Uint32FromInt32(pathTmp))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - pathTmp
				}
				v643 = delta1
				v644 = envPtr2
				if v643 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v644)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v644)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v644)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v644)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v644 + 64)) += int64(v643)
			}
		}
	} else {
		_objIndexCopy12 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy12 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v646 = envPtr2 + 152
			v645 = *(*uintptr)(unsafe.Pointer(v646))
			*(*uintptr)(unsafe.Pointer(v646))++
			*(*uint8)(unsafe.Pointer(v645)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v648 = envPtr2 + 152
			v647 = *(*uintptr)(unsafe.Pointer(v648))
			*(*uintptr)(unsafe.Pointer(v648))++
			*(*uint8)(unsafe.Pointer(v647)) = uint8(libc.Uint32FromInt32(_objIndexCopy12))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy12
				}
				v649 = delta1
				v650 = envPtr2
				if v649 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v650)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v650)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v650)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v650)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v650 + 64)) += int64(v649)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v652 = envPtr2 + 152
			v651 = *(*uintptr)(unsafe.Pointer(v652))
			*(*uintptr)(unsafe.Pointer(v652))++
			*(*uint8)(unsafe.Pointer(v651)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v654 = envPtr2 + 152
			v653 = *(*uintptr)(unsafe.Pointer(v654))
			*(*uintptr)(unsafe.Pointer(v654))++
			*(*uint8)(unsafe.Pointer(v653)) = uint8(libc.Uint32FromInt32(_objIndexCopy12) >> libc.Int32FromInt32(24))
			v656 = envPtr2 + 152
			v655 = *(*uintptr)(unsafe.Pointer(v656))
			*(*uintptr)(unsafe.Pointer(v656))++
			*(*uint8)(unsafe.Pointer(v655)) = uint8(libc.Uint32FromInt32(_objIndexCopy12) >> libc.Int32FromInt32(16))
			v658 = envPtr2 + 152
			v657 = *(*uintptr)(unsafe.Pointer(v658))
			*(*uintptr)(unsafe.Pointer(v658))++
			*(*uint8)(unsafe.Pointer(v657)) = uint8(libc.Uint32FromInt32(_objIndexCopy12) >> libc.Int32FromInt32(8))
			v660 = envPtr2 + 152
			v659 = *(*uintptr)(unsafe.Pointer(v660))
			*(*uintptr)(unsafe.Pointer(v660))++
			*(*uint8)(unsafe.Pointer(v659)) = uint8(libc.Uint32FromInt32(_objIndexCopy12))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy12
				}
				v661 = delta1
				v662 = envPtr2
				if v661 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v662)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v662)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v662)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v662)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v662 + 64)) += int64(v661)
			}
		}
	}
	if keysTmp <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v664 = envPtr2 + 152
		v663 = *(*uintptr)(unsafe.Pointer(v664))
		*(*uintptr)(unsafe.Pointer(v664))++
		*(*uint8)(unsafe.Pointer(v663)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
		v666 = envPtr2 + 152
		v665 = *(*uintptr)(unsafe.Pointer(v666))
		*(*uintptr)(unsafe.Pointer(v666))++
		*(*uint8)(unsafe.Pointer(v665)) = uint8(libc.Uint32FromInt32(keysTmp))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - keysTmp
			}
			v667 = delta1
			v668 = envPtr2
			if v667 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v668)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v668)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v668)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v668)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v668 + 64)) += int64(v667)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v670 = envPtr2 + 152
		v669 = *(*uintptr)(unsafe.Pointer(v670))
		*(*uintptr)(unsafe.Pointer(v670))++
		*(*uint8)(unsafe.Pointer(v669)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
		v672 = envPtr2 + 152
		v671 = *(*uintptr)(unsafe.Pointer(v672))
		*(*uintptr)(unsafe.Pointer(v672))++
		*(*uint8)(unsafe.Pointer(v671)) = uint8(libc.Uint32FromInt32(keysTmp) >> libc.Int32FromInt32(24))
		v674 = envPtr2 + 152
		v673 = *(*uintptr)(unsafe.Pointer(v674))
		*(*uintptr)(unsafe.Pointer(v674))++
		*(*uint8)(unsafe.Pointer(v673)) = uint8(libc.Uint32FromInt32(keysTmp) >> libc.Int32FromInt32(16))
		v676 = envPtr2 + 152
		v675 = *(*uintptr)(unsafe.Pointer(v676))
		*(*uintptr)(unsafe.Pointer(v676))++
		*(*uint8)(unsafe.Pointer(v675)) = uint8(libc.Uint32FromInt32(keysTmp) >> libc.Int32FromInt32(8))
		v678 = envPtr2 + 152
		v677 = *(*uintptr)(unsafe.Pointer(v678))
		*(*uintptr)(unsafe.Pointer(v678))++
		*(*uint8)(unsafe.Pointer(v677)) = uint8(libc.Uint32FromInt32(keysTmp))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - keysTmp
			}
			v679 = delta1
			v680 = envPtr2
			if v679 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v680)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v680)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v680)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v680)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v680 + 64)) += int64(v679)
		}
	}
	if dictVar == -int32(1) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v682 = envPtr2 + 152
		v681 = *(*uintptr)(unsafe.Pointer(v682))
		*(*uintptr)(unsafe.Pointer(v682))++
		*(*uint8)(unsafe.Pointer(v681)) = libc.Uint8FromInt32(int32(INST_DICT_RECOMBINE_STK))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_DICT_RECOMBINE_STK)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v683 = delta1
			v684 = envPtr2
			if v683 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v684)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v684)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v684)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v684)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v684 + 64)) += int64(v683)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v686 = envPtr2 + 152
		v685 = *(*uintptr)(unsafe.Pointer(v686))
		*(*uintptr)(unsafe.Pointer(v686))++
		*(*uint8)(unsafe.Pointer(v685)) = libc.Uint8FromInt32(int32(INST_DICT_RECOMBINE_IMM))
		v688 = envPtr2 + 152
		v687 = *(*uintptr)(unsafe.Pointer(v688))
		*(*uintptr)(unsafe.Pointer(v688))++
		*(*uint8)(unsafe.Pointer(v687)) = uint8(libc.Uint32FromInt32(dictVar) >> libc.Int32FromInt32(24))
		v690 = envPtr2 + 152
		v689 = *(*uintptr)(unsafe.Pointer(v690))
		*(*uintptr)(unsafe.Pointer(v690))++
		*(*uint8)(unsafe.Pointer(v689)) = uint8(libc.Uint32FromInt32(dictVar) >> libc.Int32FromInt32(16))
		v692 = envPtr2 + 152
		v691 = *(*uintptr)(unsafe.Pointer(v692))
		*(*uintptr)(unsafe.Pointer(v692))++
		*(*uint8)(unsafe.Pointer(v691)) = uint8(libc.Uint32FromInt32(dictVar) >> libc.Int32FromInt32(8))
		v694 = envPtr2 + 152
		v693 = *(*uintptr)(unsafe.Pointer(v694))
		*(*uintptr)(unsafe.Pointer(v694))++
		*(*uint8)(unsafe.Pointer(v693)) = uint8(libc.Uint32FromInt32(dictVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_DICT_RECOMBINE_IMM)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - dictVar
			}
			v695 = delta1
			v696 = envPtr2
			if v695 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v696)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v696)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v696)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v696)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v696 + 64)) += int64(v695)
		}
	}
	XTclEmitInvoke(tls, envPtr2, int32(INST_RETURN_STK), 0)
	/*
	 * Prepare for the start of the next command.
	 */
	if XTclFixupForwardJump(tls, envPtr2, bp, int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(libc.Int32FromUint32((*TJumpFixup)(unsafe.Pointer(bp)).FcodeOffset))), int32(127)) != 0 {
		XTcl_Panic(tls, __ccgo_ts+21568, libc.VaList(bp+24, int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-libc.Int64FromUint32((*(*TJumpFixup)(unsafe.Pointer(bp))).FcodeOffset)))
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * DupDictUpdateInfo, FreeDictUpdateInfo --
 *
 *	Functions to duplicate, release and print the aux data created for use
 *	with the INST_DICT_UPDATE_START and INST_DICT_UPDATE_END instructions.
 *
 * Results:
 *	DupDictUpdateInfo: a copy of the auxiliary data
 *	FreeDictUpdateInfo: none
 *	PrintDictUpdateInfo: none
 *	DisassembleDictUpdateInfo: none
 *
 * Side effects:
 *	DupDictUpdateInfo: allocates memory
 *	FreeDictUpdateInfo: releases memory
 *	PrintDictUpdateInfo: none
 *	DisassembleDictUpdateInfo: none
 *
 *----------------------------------------------------------------------
 */

func _DupDictUpdateInfo(tls *libc.TLS, clientData uintptr) (r uintptr) {
	var dui1Ptr, dui2Ptr uintptr
	var len1 Tsize_t
	_, _, _ = dui1Ptr, dui2Ptr, len1
	dui1Ptr = clientData
	len1 = uint64(libc.UintptrFromInt32(0)+8) + uint64(8)*libc.Uint64FromInt64((*TDictUpdateInfo)(unsafe.Pointer(dui1Ptr)).Flength)
	dui2Ptr = XTcl_Alloc(tls, len1)
	libc.Xmemcpy(tls, dui2Ptr, dui1Ptr, len1)
	return dui2Ptr
}

func _FreeDictUpdateInfo(tls *libc.TLS, clientData uintptr) {
	XTclpFree(tls, clientData)
}

func _PrintDictUpdateInfo(tls *libc.TLS, clientData uintptr, appendObj uintptr, dummy2370 uintptr, dummy2371 Tsize_t) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var duiPtr uintptr
	var i TTcl_Size
	_, _ = duiPtr, i
	duiPtr = clientData
	i = 0
	for {
		if !(i < (*TDictUpdateInfo)(unsafe.Pointer(duiPtr)).Flength) {
			break
		}
		if i != 0 {
			XTcl_AppendToObj(tls, appendObj, __ccgo_ts+21617, int64(-int32(1)))
		}
		XTcl_AppendPrintfToObj(tls, appendObj, __ccgo_ts+21620, libc.VaList(bp+8, *(*TTcl_Size)(unsafe.Pointer(duiPtr + 8 + uintptr(i)*8))))
		goto _1
	_1:
		;
		i++
	}
}

func _DisassembleDictUpdateInfo(tls *libc.TLS, clientData uintptr, dictObj uintptr, dummy2388 uintptr, dummy2389 Tsize_t) {
	var cachePtr, duiPtr, variables uintptr
	var i TTcl_Size
	var v1 bool
	_, _, _, _, _ = cachePtr, duiPtr, i, variables, v1
	duiPtr = clientData
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		variables = XTclThreadAllocObj(tls)
	} else {
		variables = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(variables + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(variables)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(variables)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(variables)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(variables)).FtypePtr = libc.UintptrFromInt32(0)
	i = 0
	for {
		if !(i < (*TDictUpdateInfo)(unsafe.Pointer(duiPtr)).Flength) {
			break
		}
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), variables, XTcl_NewWideIntObj(tls, *(*TTcl_Size)(unsafe.Pointer(duiPtr + 8 + uintptr(i)*8))))
		goto _2
	_2:
		;
		i++
	}
	XTclDictPut(tls, libc.UintptrFromInt32(0), dictObj, __ccgo_ts+21627, variables)
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileErrorCmd --
 *
 *	Procedure called to compile the "error" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "error" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileErrorCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy2426 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, _objIndexCopy4, _objIndexCopy5, delta1, v101, v107, v119, v131, v143, v17, v23, v35, v41, v5, v53, v59, v71, v83, v89 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v100, v102, v103, v104, v105, v106, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v12, v120, v121, v122, v123, v124, v125, v126, v127, v128, v129, v13, v130, v132, v133, v134, v135, v136, v137, v138, v139, v14, v140, v141, v142, v144, v145, v146, v147, v148, v149, v15, v150, v151, v152, v16, v18, v19, v2, v20, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v36, v37, v38, v39, v4, v40, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v54, v55, v56, v57, v58, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v84, v85, v86, v87, v88, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, _objIndexCopy4, _objIndexCopy5, delta1, eclIndex, mapPtr, tokenPtr, v1, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v123, v124, v125, v126, v127, v128, v129, v13, v130, v131, v132, v133, v134, v135, v136, v137, v138, v139, v14, v140, v141, v142, v143, v144, v145, v146, v147, v148, v149, v15, v150, v151, v152, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	/*
	 * General syntax: [error message ?errorInfo? ?errorCode?]
	 */
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) < int32(2) || int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) > int32(4) {
		return int32(TCL_ERROR)
	}
	/*
	 * Handle the message.
	 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	/*
	 * Construct the options. Note that -code and -level are not here.
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(2) {
		_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy1 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v20 = envPtr2 + 152
			v19 = *(*uintptr)(unsafe.Pointer(v20))
			*(*uintptr)(unsafe.Pointer(v20))++
			*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v22 = envPtr2 + 152
			v21 = *(*uintptr)(unsafe.Pointer(v22))
			*(*uintptr)(unsafe.Pointer(v22))++
			*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v23 = delta1
				v24 = envPtr2
				if v23 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v24 + 64)) += int64(v23)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v26 = envPtr2 + 152
			v25 = *(*uintptr)(unsafe.Pointer(v26))
			*(*uintptr)(unsafe.Pointer(v26))++
			*(*uint8)(unsafe.Pointer(v25)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v28 = envPtr2 + 152
			v27 = *(*uintptr)(unsafe.Pointer(v28))
			*(*uintptr)(unsafe.Pointer(v28))++
			*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
			v30 = envPtr2 + 152
			v29 = *(*uintptr)(unsafe.Pointer(v30))
			*(*uintptr)(unsafe.Pointer(v30))++
			*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
			v32 = envPtr2 + 152
			v31 = *(*uintptr)(unsafe.Pointer(v32))
			*(*uintptr)(unsafe.Pointer(v32))++
			*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
			v34 = envPtr2 + 152
			v33 = *(*uintptr)(unsafe.Pointer(v34))
			*(*uintptr)(unsafe.Pointer(v34))++
			*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v35 = delta1
				v36 = envPtr2
				if v35 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v36 + 64)) += int64(v35)
			}
		}
	} else {
		_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+15220, libc.Int64FromUint64(libc.Uint64FromInt64(11)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy2 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v38 = envPtr2 + 152
			v37 = *(*uintptr)(unsafe.Pointer(v38))
			*(*uintptr)(unsafe.Pointer(v38))++
			*(*uint8)(unsafe.Pointer(v37)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v40 = envPtr2 + 152
			v39 = *(*uintptr)(unsafe.Pointer(v40))
			*(*uintptr)(unsafe.Pointer(v40))++
			*(*uint8)(unsafe.Pointer(v39)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v41 = delta1
				v42 = envPtr2
				if v41 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v42)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v42)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v42)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v42)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v42 + 64)) += int64(v41)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v44 = envPtr2 + 152
			v43 = *(*uintptr)(unsafe.Pointer(v44))
			*(*uintptr)(unsafe.Pointer(v44))++
			*(*uint8)(unsafe.Pointer(v43)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v46 = envPtr2 + 152
			v45 = *(*uintptr)(unsafe.Pointer(v46))
			*(*uintptr)(unsafe.Pointer(v46))++
			*(*uint8)(unsafe.Pointer(v45)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
			v48 = envPtr2 + 152
			v47 = *(*uintptr)(unsafe.Pointer(v48))
			*(*uintptr)(unsafe.Pointer(v48))++
			*(*uint8)(unsafe.Pointer(v47)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
			v50 = envPtr2 + 152
			v49 = *(*uintptr)(unsafe.Pointer(v50))
			*(*uintptr)(unsafe.Pointer(v50))++
			*(*uint8)(unsafe.Pointer(v49)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
			v52 = envPtr2 + 152
			v51 = *(*uintptr)(unsafe.Pointer(v52))
			*(*uintptr)(unsafe.Pointer(v52))++
			*(*uint8)(unsafe.Pointer(v51)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v53 = delta1
				v54 = envPtr2
				if v53 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v54)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v54)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v54)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v54)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v54 + 64)) += int64(v53)
			}
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy3 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy3 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v56 = envPtr2 + 152
				v55 = *(*uintptr)(unsafe.Pointer(v56))
				*(*uintptr)(unsafe.Pointer(v56))++
				*(*uint8)(unsafe.Pointer(v55)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v58 = envPtr2 + 152
				v57 = *(*uintptr)(unsafe.Pointer(v58))
				*(*uintptr)(unsafe.Pointer(v58))++
				*(*uint8)(unsafe.Pointer(v57)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy3
					}
					v59 = delta1
					v60 = envPtr2
					if v59 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v60)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v60)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v60)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v60)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v60 + 64)) += int64(v59)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v62 = envPtr2 + 152
				v61 = *(*uintptr)(unsafe.Pointer(v62))
				*(*uintptr)(unsafe.Pointer(v62))++
				*(*uint8)(unsafe.Pointer(v61)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v64 = envPtr2 + 152
				v63 = *(*uintptr)(unsafe.Pointer(v64))
				*(*uintptr)(unsafe.Pointer(v64))++
				*(*uint8)(unsafe.Pointer(v63)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(24))
				v66 = envPtr2 + 152
				v65 = *(*uintptr)(unsafe.Pointer(v66))
				*(*uintptr)(unsafe.Pointer(v66))++
				*(*uint8)(unsafe.Pointer(v65)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(16))
				v68 = envPtr2 + 152
				v67 = *(*uintptr)(unsafe.Pointer(v68))
				*(*uintptr)(unsafe.Pointer(v68))++
				*(*uint8)(unsafe.Pointer(v67)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(8))
				v70 = envPtr2 + 152
				v69 = *(*uintptr)(unsafe.Pointer(v70))
				*(*uintptr)(unsafe.Pointer(v70))++
				*(*uint8)(unsafe.Pointer(v69)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy3
					}
					v71 = delta1
					v72 = envPtr2
					if v71 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v72)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v72)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v72)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v72)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v72 + 64)) += int64(v71)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
		}
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(3) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v74 = envPtr2 + 152
			v73 = *(*uintptr)(unsafe.Pointer(v74))
			*(*uintptr)(unsafe.Pointer(v74))++
			*(*uint8)(unsafe.Pointer(v73)) = libc.Uint8FromInt32(int32(INST_LIST))
			v76 = envPtr2 + 152
			v75 = *(*uintptr)(unsafe.Pointer(v76))
			*(*uintptr)(unsafe.Pointer(v76))++
			*(*uint8)(unsafe.Pointer(v75)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
			v78 = envPtr2 + 152
			v77 = *(*uintptr)(unsafe.Pointer(v78))
			*(*uintptr)(unsafe.Pointer(v78))++
			*(*uint8)(unsafe.Pointer(v77)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
			v80 = envPtr2 + 152
			v79 = *(*uintptr)(unsafe.Pointer(v80))
			*(*uintptr)(unsafe.Pointer(v80))++
			*(*uint8)(unsafe.Pointer(v79)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
			v82 = envPtr2 + 152
			v81 = *(*uintptr)(unsafe.Pointer(v82))
			*(*uintptr)(unsafe.Pointer(v82))++
			*(*uint8)(unsafe.Pointer(v81)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LIST)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - int32(2)
				}
				v83 = delta1
				v84 = envPtr2
				if v83 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v84)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v84)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v84)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v84)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v84 + 64)) += int64(v83)
			}
		} else {
			_objIndexCopy4 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+15231, libc.Int64FromUint64(libc.Uint64FromInt64(11)-libc.Uint64FromInt32(1)), 0)
			if _objIndexCopy4 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v86 = envPtr2 + 152
				v85 = *(*uintptr)(unsafe.Pointer(v86))
				*(*uintptr)(unsafe.Pointer(v86))++
				*(*uint8)(unsafe.Pointer(v85)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v88 = envPtr2 + 152
				v87 = *(*uintptr)(unsafe.Pointer(v88))
				*(*uintptr)(unsafe.Pointer(v88))++
				*(*uint8)(unsafe.Pointer(v87)) = uint8(libc.Uint32FromInt32(_objIndexCopy4))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy4
					}
					v89 = delta1
					v90 = envPtr2
					if v89 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v90)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v90)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v90)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v90)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v90 + 64)) += int64(v89)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v92 = envPtr2 + 152
				v91 = *(*uintptr)(unsafe.Pointer(v92))
				*(*uintptr)(unsafe.Pointer(v92))++
				*(*uint8)(unsafe.Pointer(v91)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v94 = envPtr2 + 152
				v93 = *(*uintptr)(unsafe.Pointer(v94))
				*(*uintptr)(unsafe.Pointer(v94))++
				*(*uint8)(unsafe.Pointer(v93)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(24))
				v96 = envPtr2 + 152
				v95 = *(*uintptr)(unsafe.Pointer(v96))
				*(*uintptr)(unsafe.Pointer(v96))++
				*(*uint8)(unsafe.Pointer(v95)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(16))
				v98 = envPtr2 + 152
				v97 = *(*uintptr)(unsafe.Pointer(v98))
				*(*uintptr)(unsafe.Pointer(v98))++
				*(*uint8)(unsafe.Pointer(v97)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(8))
				v100 = envPtr2 + 152
				v99 = *(*uintptr)(unsafe.Pointer(v100))
				*(*uintptr)(unsafe.Pointer(v100))++
				*(*uint8)(unsafe.Pointer(v99)) = uint8(libc.Uint32FromInt32(_objIndexCopy4))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy4
					}
					v101 = delta1
					v102 = envPtr2
					if v101 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v102)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v102)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v102)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v102)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v102 + 64)) += int64(v101)
				}
			}
			tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
			if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
				_objIndexCopy5 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
				if _objIndexCopy5 <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v104 = envPtr2 + 152
					v103 = *(*uintptr)(unsafe.Pointer(v104))
					*(*uintptr)(unsafe.Pointer(v104))++
					*(*uint8)(unsafe.Pointer(v103)) = libc.Uint8FromInt32(int32(INST_PUSH1))
					v106 = envPtr2 + 152
					v105 = *(*uintptr)(unsafe.Pointer(v106))
					*(*uintptr)(unsafe.Pointer(v106))++
					*(*uint8)(unsafe.Pointer(v105)) = uint8(libc.Uint32FromInt32(_objIndexCopy5))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy5
						}
						v107 = delta1
						v108 = envPtr2
						if v107 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v108)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v108)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v108)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v108)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v108 + 64)) += int64(v107)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v110 = envPtr2 + 152
					v109 = *(*uintptr)(unsafe.Pointer(v110))
					*(*uintptr)(unsafe.Pointer(v110))++
					*(*uint8)(unsafe.Pointer(v109)) = libc.Uint8FromInt32(int32(INST_PUSH4))
					v112 = envPtr2 + 152
					v111 = *(*uintptr)(unsafe.Pointer(v112))
					*(*uintptr)(unsafe.Pointer(v112))++
					*(*uint8)(unsafe.Pointer(v111)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(24))
					v114 = envPtr2 + 152
					v113 = *(*uintptr)(unsafe.Pointer(v114))
					*(*uintptr)(unsafe.Pointer(v114))++
					*(*uint8)(unsafe.Pointer(v113)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(16))
					v116 = envPtr2 + 152
					v115 = *(*uintptr)(unsafe.Pointer(v116))
					*(*uintptr)(unsafe.Pointer(v116))++
					*(*uint8)(unsafe.Pointer(v115)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(8))
					v118 = envPtr2 + 152
					v117 = *(*uintptr)(unsafe.Pointer(v118))
					*(*uintptr)(unsafe.Pointer(v118))++
					*(*uint8)(unsafe.Pointer(v117)) = uint8(libc.Uint32FromInt32(_objIndexCopy5))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy5
						}
						v119 = delta1
						v120 = envPtr2
						if v119 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v120)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v120)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v120)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v120)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v120 + 64)) += int64(v119)
					}
				}
			} else {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 3*8))
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 3*8))
				XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v122 = envPtr2 + 152
			v121 = *(*uintptr)(unsafe.Pointer(v122))
			*(*uintptr)(unsafe.Pointer(v122))++
			*(*uint8)(unsafe.Pointer(v121)) = libc.Uint8FromInt32(int32(INST_LIST))
			v124 = envPtr2 + 152
			v123 = *(*uintptr)(unsafe.Pointer(v124))
			*(*uintptr)(unsafe.Pointer(v124))++
			*(*uint8)(unsafe.Pointer(v123)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(4)) >> libc.Int32FromInt32(24))
			v126 = envPtr2 + 152
			v125 = *(*uintptr)(unsafe.Pointer(v126))
			*(*uintptr)(unsafe.Pointer(v126))++
			*(*uint8)(unsafe.Pointer(v125)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(4)) >> libc.Int32FromInt32(16))
			v128 = envPtr2 + 152
			v127 = *(*uintptr)(unsafe.Pointer(v128))
			*(*uintptr)(unsafe.Pointer(v128))++
			*(*uint8)(unsafe.Pointer(v127)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(4)) >> libc.Int32FromInt32(8))
			v130 = envPtr2 + 152
			v129 = *(*uintptr)(unsafe.Pointer(v130))
			*(*uintptr)(unsafe.Pointer(v130))++
			*(*uint8)(unsafe.Pointer(v129)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(4)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LIST)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - int32(4)
				}
				v131 = delta1
				v132 = envPtr2
				if v131 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v132)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v132)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v132)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v132)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v132 + 64)) += int64(v131)
			}
		}
	}
	/*
	 * Issue the error via 'returnImm error 0'.
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v134 = envPtr2 + 152
	v133 = *(*uintptr)(unsafe.Pointer(v134))
	*(*uintptr)(unsafe.Pointer(v134))++
	*(*uint8)(unsafe.Pointer(v133)) = libc.Uint8FromInt32(int32(INST_RETURN_IMM))
	v136 = envPtr2 + 152
	v135 = *(*uintptr)(unsafe.Pointer(v136))
	*(*uintptr)(unsafe.Pointer(v136))++
	*(*uint8)(unsafe.Pointer(v135)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(TCL_ERROR)) >> libc.Int32FromInt32(24))
	v138 = envPtr2 + 152
	v137 = *(*uintptr)(unsafe.Pointer(v138))
	*(*uintptr)(unsafe.Pointer(v138))++
	*(*uint8)(unsafe.Pointer(v137)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(TCL_ERROR)) >> libc.Int32FromInt32(16))
	v140 = envPtr2 + 152
	v139 = *(*uintptr)(unsafe.Pointer(v140))
	*(*uintptr)(unsafe.Pointer(v140))++
	*(*uint8)(unsafe.Pointer(v139)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(TCL_ERROR)) >> libc.Int32FromInt32(8))
	v142 = envPtr2 + 152
	v141 = *(*uintptr)(unsafe.Pointer(v142))
	*(*uintptr)(unsafe.Pointer(v142))++
	*(*uint8)(unsafe.Pointer(v141)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(TCL_ERROR)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_RETURN_IMM)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32(TCL_ERROR)
		}
		v143 = delta1
		v144 = envPtr2
		if v143 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v144)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v144)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v144)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v144)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v144 + 64)) += int64(v143)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v146 = envPtr2 + 152
	v145 = *(*uintptr)(unsafe.Pointer(v146))
	*(*uintptr)(unsafe.Pointer(v146))++
	*(*uint8)(unsafe.Pointer(v145)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
	v148 = envPtr2 + 152
	v147 = *(*uintptr)(unsafe.Pointer(v148))
	*(*uintptr)(unsafe.Pointer(v148))++
	*(*uint8)(unsafe.Pointer(v147)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
	v150 = envPtr2 + 152
	v149 = *(*uintptr)(unsafe.Pointer(v150))
	*(*uintptr)(unsafe.Pointer(v150))++
	*(*uint8)(unsafe.Pointer(v149)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
	v152 = envPtr2 + 152
	v151 = *(*uintptr)(unsafe.Pointer(v152))
	*(*uintptr)(unsafe.Pointer(v152))++
	*(*uint8)(unsafe.Pointer(v151)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileExprCmd --
 *
 *	Procedure called to compile the "expr" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "expr" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileExprCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy2499 uintptr, envPtr uintptr) (r int32) {
	/* Holds resulting instructions. */
	var firstWordPtr uintptr
	_ = firstWordPtr
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(1) {
		return int32(TCL_ERROR)
	}
	/*
	 * TIP #280: Use the per-word line information of the current command.
	 */
	(*TCompileEnv)(unsafe.Pointer(envPtr)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Floc + uintptr((*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fnuloc-int64(1))*32))).Fline + 1*8))
	firstWordPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	XTclCompileExprWords(tls, interp, firstWordPtr, libc.Uint64FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-int32(1)), envPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileForCmd --
 *
 *	Procedure called to compile the "for" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "for" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileForCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy2543 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds resulting instructions. */
	var _objIndexCopy, bodyCodeOffset, bodyRange, delta1, jumpDist, nextCodeOffset, nextRange, v15, v27, v3, v33, v39, v51, v9 int32
	var bodyTokenPtr, mapPtr, nextTokenPtr, startTokenPtr, testTokenPtr, v1, v10, v13, v14, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v28, v29, v30, v31, v32, v34, v35, v36, v37, v38, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v52, v7, v8 uintptr
	var eclIndex, v12, v6 TTcl_Size
	var v11, v5 int64
	var _ /* jumpEvalCondFixup at bp+0 */ TJumpFixup
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, bodyCodeOffset, bodyRange, bodyTokenPtr, delta1, eclIndex, jumpDist, mapPtr, nextCodeOffset, nextRange, nextTokenPtr, startTokenPtr, testTokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(5) {
		return int32(TCL_ERROR)
	}
	/*
	 * If the test expression requires substitutions, don't compile the for
	 * command inline. E.g., the expression might cause the loop to never
	 * execute or execute forever, as in "for {} "$x > 5" {incr x} {}".
	 */
	startTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	testTokenPtr = startTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(startTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(testTokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) {
		return int32(TCL_ERROR)
	}
	/*
	 * Bail out also if the body or the next expression require substitutions
	 * in order to insure correct behaviour [Bug 219166]
	 */
	nextTokenPtr = testTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(testTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	bodyTokenPtr = nextTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(nextTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(nextTokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) || (*TTcl_Token)(unsafe.Pointer(bodyTokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) {
		return int32(TCL_ERROR)
	}
	/*
	 * Inline compile the initial command.
	 */
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
	XTclCompileCmdWord(tls, interp, startTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(startTokenPtr)).FnumComponents), envPtr2)
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v2 = envPtr2 + 152
	v1 = *(*uintptr)(unsafe.Pointer(v2))
	*(*uintptr)(unsafe.Pointer(v2))++
	*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v3 = delta1
		v4 = envPtr2
		if v3 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v4)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v4)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v4)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v4)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v4 + 64)) += int64(v3)
	}
	/*
	 * Jump to the evaluation of the condition. This code uses the "loop
	 * rotation" optimisation (which eliminates one branch from the loop).
	 * "for start cond next body" produces then:
	 *       start
	 *       goto A
	 *    B: body                : bodyCodeOffset
	 *       next                : nextCodeOffset, continueOffset
	 *    A: cond -> result      : testCodeOffset
	 *       if (result) goto B
	 */
	XTclEmitForwardJump(tls, envPtr2, int32(TCL_UNCONDITIONAL_JUMP), bp)
	/*
	 * Compile the loop body.
	 */
	bodyRange = int32(XTclCreateExceptRange(tls, int32(LOOP_EXCEPTION_RANGE), envPtr2))
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth++
	if libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth)+uint64(1) > libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth)+uint64(1) {
		v5 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth
	} else {
		v5 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth = v5
	v6 = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(bodyRange)*56))).FcodeOffset = v6
	bodyCodeOffset = int32(v6)
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 4*8))
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 4*8))
	XTclCompileCmdWord(tls, interp, bodyTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(bodyTokenPtr)).FnumComponents), envPtr2)
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth--
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(bodyRange)*56))).FnumCodeBytes = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(int32((*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(bodyRange)*56))).FcodeOffset))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v8 = envPtr2 + 152
	v7 = *(*uintptr)(unsafe.Pointer(v8))
	*(*uintptr)(unsafe.Pointer(v8))++
	*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v9 = delta1
		v10 = envPtr2
		if v9 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v10)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v10)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v10)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v10)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v10 + 64)) += int64(v9)
	}
	/*
	 * Compile the "next" subcommand. Note that this exception range will not
	 * have a continueOffset (other than -1) connected to it; it won't trap
	 * TCL_CONTINUE but rather just TCL_BREAK.
	 */
	nextRange = int32(XTclCreateExceptRange(tls, int32(LOOP_EXCEPTION_RANGE), envPtr2))
	(*(*TExceptionAux)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptAuxArrayPtr + uintptr(nextRange)*80))).FsupportsContinue = 0
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth++
	if libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth)+uint64(1) > libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth)+uint64(1) {
		v11 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth
	} else {
		v11 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth = v11
	v12 = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(nextRange)*56))).FcodeOffset = v12
	nextCodeOffset = int32(v12)
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 3*8))
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 3*8))
	XTclCompileCmdWord(tls, interp, nextTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(nextTokenPtr)).FnumComponents), envPtr2)
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth--
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(nextRange)*56))).FnumCodeBytes = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(int32((*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(nextRange)*56))).FcodeOffset))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v14 = envPtr2 + 152
	v13 = *(*uintptr)(unsafe.Pointer(v14))
	*(*uintptr)(unsafe.Pointer(v14))++
	*(*uint8)(unsafe.Pointer(v13)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v15 = delta1
		v16 = envPtr2
		if v15 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v16)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v16)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v16)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v16)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v16 + 64)) += int64(v15)
	}
	/*
	 * Compile the test expression then emit the conditional jump that
	 * terminates the for.
	 */
	if XTclFixupForwardJump(tls, envPtr2, bp, int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(libc.Int32FromUint32((*TJumpFixup)(unsafe.Pointer(bp)).FcodeOffset))), int32(127)) != 0 {
		bodyCodeOffset += int32(3)
		nextCodeOffset += int32(3)
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
	XTclCompileExprWords(tls, interp, testTokenPtr, uint64(1), envPtr2)
	jumpDist = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(bodyCodeOffset))
	if jumpDist > int32(127) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v18 = envPtr2 + 152
		v17 = *(*uintptr)(unsafe.Pointer(v18))
		*(*uintptr)(unsafe.Pointer(v18))++
		*(*uint8)(unsafe.Pointer(v17)) = libc.Uint8FromInt32(int32(INST_JUMP_TRUE4))
		v20 = envPtr2 + 152
		v19 = *(*uintptr)(unsafe.Pointer(v20))
		*(*uintptr)(unsafe.Pointer(v20))++
		*(*uint8)(unsafe.Pointer(v19)) = uint8(libc.Uint32FromInt32(-jumpDist) >> libc.Int32FromInt32(24))
		v22 = envPtr2 + 152
		v21 = *(*uintptr)(unsafe.Pointer(v22))
		*(*uintptr)(unsafe.Pointer(v22))++
		*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(-jumpDist) >> libc.Int32FromInt32(16))
		v24 = envPtr2 + 152
		v23 = *(*uintptr)(unsafe.Pointer(v24))
		*(*uintptr)(unsafe.Pointer(v24))++
		*(*uint8)(unsafe.Pointer(v23)) = uint8(libc.Uint32FromInt32(-jumpDist) >> libc.Int32FromInt32(8))
		v26 = envPtr2 + 152
		v25 = *(*uintptr)(unsafe.Pointer(v26))
		*(*uintptr)(unsafe.Pointer(v26))++
		*(*uint8)(unsafe.Pointer(v25)) = uint8(libc.Uint32FromInt32(-jumpDist))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP_TRUE4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - -jumpDist
			}
			v27 = delta1
			v28 = envPtr2
			if v27 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v28)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v28)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v28)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v28)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v28 + 64)) += int64(v27)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v30 = envPtr2 + 152
		v29 = *(*uintptr)(unsafe.Pointer(v30))
		*(*uintptr)(unsafe.Pointer(v30))++
		*(*uint8)(unsafe.Pointer(v29)) = libc.Uint8FromInt32(int32(INST_JUMP_TRUE1))
		v32 = envPtr2 + 152
		v31 = *(*uintptr)(unsafe.Pointer(v32))
		*(*uintptr)(unsafe.Pointer(v32))++
		*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(-jumpDist))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP_TRUE1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - -jumpDist
			}
			v33 = delta1
			v34 = envPtr2
			if v33 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v34)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v34)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v34)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v34)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v34 + 64)) += int64(v33)
		}
	}
	/*
	 * Fix the starting points of the exception ranges (may have moved due to
	 * jump type modification) and set where the exceptions target.
	 */
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(bodyRange)*56))).FcodeOffset = int64(bodyCodeOffset)
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(bodyRange)*56))).FcontinueOffset = int64(nextCodeOffset)
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(nextRange)*56))).FcodeOffset = int64(nextCodeOffset)
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(bodyRange)*56))).FbreakOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(nextRange)*56))).FbreakOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	XTclFinalizeLoopExceptionRange(tls, envPtr2, bodyRange)
	XTclFinalizeLoopExceptionRange(tls, envPtr2, nextRange)
	/*
	 * The for command's result is an empty string.
	 */
	_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v36 = envPtr2 + 152
		v35 = *(*uintptr)(unsafe.Pointer(v36))
		*(*uintptr)(unsafe.Pointer(v36))++
		*(*uint8)(unsafe.Pointer(v35)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v38 = envPtr2 + 152
		v37 = *(*uintptr)(unsafe.Pointer(v38))
		*(*uintptr)(unsafe.Pointer(v38))++
		*(*uint8)(unsafe.Pointer(v37)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v39 = delta1
			v40 = envPtr2
			if v39 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v40 + 64)) += int64(v39)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v42 = envPtr2 + 152
		v41 = *(*uintptr)(unsafe.Pointer(v42))
		*(*uintptr)(unsafe.Pointer(v42))++
		*(*uint8)(unsafe.Pointer(v41)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v44 = envPtr2 + 152
		v43 = *(*uintptr)(unsafe.Pointer(v44))
		*(*uintptr)(unsafe.Pointer(v44))++
		*(*uint8)(unsafe.Pointer(v43)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
		v46 = envPtr2 + 152
		v45 = *(*uintptr)(unsafe.Pointer(v46))
		*(*uintptr)(unsafe.Pointer(v46))++
		*(*uint8)(unsafe.Pointer(v45)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
		v48 = envPtr2 + 152
		v47 = *(*uintptr)(unsafe.Pointer(v48))
		*(*uintptr)(unsafe.Pointer(v48))++
		*(*uint8)(unsafe.Pointer(v47)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
		v50 = envPtr2 + 152
		v49 = *(*uintptr)(unsafe.Pointer(v50))
		*(*uintptr)(unsafe.Pointer(v50))++
		*(*uint8)(unsafe.Pointer(v49)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v51 = delta1
			v52 = envPtr2
			if v51 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v52)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v52)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v52)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v52)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v52 + 64)) += int64(v51)
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileForeachCmd --
 *
 *	Procedure called to compile the "foreach" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "foreach" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileForeachCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr uintptr) (r int32) {
	/* Holds resulting instructions. */
	return _CompileEachloopCmd(tls, interp, parsePtr, cmdPtr, envPtr, TCL_EACH_KEEP_NONE)
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileLmapCmd --
 *
 *	Procedure called to compile the "lmap" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "lmap" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileLmapCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr uintptr) (r int32) {
	/* Holds resulting instructions. */
	return _CompileEachloopCmd(tls, interp, parsePtr, cmdPtr, envPtr, int32(TCL_EACH_COLLECT))
}

/*
 *----------------------------------------------------------------------
 *
 * CompileEachloopCmd --
 *
 *	Procedure called to compile the "foreach" and "lmap" commands.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "foreach" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func _CompileEachloopCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy2753 uintptr, envPtr2 uintptr, collect int32) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Select collecting or accumulating mode
	 * (TCL_EACH_*) */
	var _objIndexCopy, _objIndexCopy1, code, delta1, i1, infoIndex, jumpBackOffset, numLists, numWords, range1, varIndex, v19, v26, v38, v4, v50, v55, v59, v63, v67, v69, v75, v87 int32
	var _objPtr, bodyTokenPtr, bytes, cachePtr, infoPtr, mapPtr, procPtr, tokenPtr, varListObj, varListPtr, v10, v11, v12, v13, v14, v15, v16, v17, v18, v20, v22, v23, v24, v25, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v51, v53, v54, v56, v57, v58, v60, v61, v62, v64, v65, v66, v68, v70, v71, v72, v73, v74, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v88, v9, v90 uintptr
	var eclIndex, j, v89 TTcl_Size
	var v2, v6 bool
	var v5, v52 int64
	var _ /* length at bp+16 */ TTcl_Size
	var _ /* numVars at bp+0 */ TTcl_Size
	var _ /* varNameObj at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objPtr, bodyTokenPtr, bytes, cachePtr, code, delta1, eclIndex, i1, infoIndex, infoPtr, j, jumpBackOffset, mapPtr, numLists, numWords, procPtr, range1, tokenPtr, varIndex, varListObj, varListPtr, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1) /* TIP #280 */
	procPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FprocPtr
	infoPtr = libc.UintptrFromInt32(0)
	code = TCL_OK
	varListObj = libc.UintptrFromInt32(0)
	/*
	 * If the foreach command isn't in a procedure, don't compile it inline:
	 * the payoff is too small.
	 */
	if procPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	numWords = int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)
	if numWords < int32(4) || numWords%int32(2) != 0 {
		return int32(TCL_ERROR)
	}
	/*
	 * Bail out if the body requires substitutions in order to ensure correct
	 * behaviour. [Bug 219166]
	 */
	i1 = 0
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
	for {
		if !(i1 < numWords-int32(1)) {
			break
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		goto _1
	_1:
		;
		i1++
	}
	bodyTokenPtr = tokenPtr
	if (*TTcl_Token)(unsafe.Pointer(bodyTokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) {
		return int32(TCL_ERROR)
	}
	/*
	 * Create and initialize the ForeachInfo and ForeachVarList data
	 * structures describing this command. Then create a AuxData record
	 * pointing to the ForeachInfo structure.
	 */
	numLists = (numWords - int32(2)) / int32(2)
	infoPtr = XTcl_Alloc(tls, uint64(libc.UintptrFromInt32(0)+24)+libc.Uint64FromInt32(numLists)*uint64(8))
	(*TForeachInfo)(unsafe.Pointer(infoPtr)).FnumLists = 0 /* Count this up as we go */
	/*
	 * Parse each var list into sequence of var names.  Don't
	 * compile the foreach inline if any var name needs substitutions or isn't
	 * a scalar, or if any var list needs substitutions.
	 */
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		varListObj = XTclThreadAllocObj(tls)
	} else {
		varListObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(varListObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(varListObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(varListObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(varListObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(varListObj)).FtypePtr = libc.UintptrFromInt32(0)
	i1 = 0
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
	for {
		if !(i1 < numWords-int32(1)) {
			break
		}
		if i1%int32(2) != int32(1) {
			goto _3
		}
		/*
		 * If the variable list is empty, we can enter an infinite loop when
		 * the interpreted version would not.  Take care to ensure this does
		 * not happen.  [Bug 1671138]
		 */
		if v6 = !(XTclWordKnownAtCompileTime(tls, tokenPtr, varListObj) != 0); !v6 {
			if (*TTcl_Obj)(unsafe.Pointer(varListObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(varListObj + 32))).Fptr2 != 0 {
					v5 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(varListObj + 32))).Fptr2)).FspanLength
				} else {
					v5 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(varListObj + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp)) = v5
				v4 = libc.Int32FromInt32(TCL_OK)
			} else {
				v4 = XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), varListObj, bp)
			}
		}
		if v6 || TCL_OK != v4 || *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
			code = int32(TCL_ERROR)
			goto done
		}
		varListPtr = XTcl_Alloc(tls, uint64(libc.UintptrFromInt32(0)+8)+libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))*uint64(8))
		(*TForeachVarList)(unsafe.Pointer(varListPtr)).FnumVars = *(*TTcl_Size)(unsafe.Pointer(bp))
		*(*uintptr)(unsafe.Pointer(infoPtr + 24 + uintptr(i1/int32(2))*8)) = varListPtr
		(*TForeachInfo)(unsafe.Pointer(infoPtr)).FnumLists++
		j = 0
		for {
			if !(j < *(*TTcl_Size)(unsafe.Pointer(bp))) {
				break
			}
			XTcl_ListObjIndex(tls, libc.UintptrFromInt32(0), varListObj, j, bp+8)
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength
				v8 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes
			} else {
				v8 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), bp+16)
			}
			bytes = v8
			varIndex = libc.Int32FromUint64(XTclLocalScalar(tls, bytes, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 16))), envPtr2))
			if varIndex < 0 {
				code = int32(TCL_ERROR)
				goto done
			}
			*(*TTcl_Size)(unsafe.Pointer(varListPtr + 8 + uintptr(j)*8)) = int64(varIndex)
			goto _7
		_7:
			;
			j++
		}
		XTcl_SetObjLength(tls, varListObj, 0)
		goto _3
	_3:
		;
		i1++
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	}
	/*
	 * We will compile the foreach command.
	 */
	infoIndex = int32(XTclCreateAuxData(tls, infoPtr, uintptr(unsafe.Pointer(&_newForeachInfoType)), envPtr2))
	/*
	 * Create the collecting object, unshared.
	 */
	if collect == int32(TCL_EACH_COLLECT) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v10 = envPtr2 + 152
		v9 = *(*uintptr)(unsafe.Pointer(v10))
		*(*uintptr)(unsafe.Pointer(v10))++
		*(*uint8)(unsafe.Pointer(v9)) = libc.Uint8FromInt32(int32(INST_LIST))
		v12 = envPtr2 + 152
		v11 = *(*uintptr)(unsafe.Pointer(v12))
		*(*uintptr)(unsafe.Pointer(v12))++
		*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
		v14 = envPtr2 + 152
		v13 = *(*uintptr)(unsafe.Pointer(v14))
		*(*uintptr)(unsafe.Pointer(v14))++
		*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
		v16 = envPtr2 + 152
		v15 = *(*uintptr)(unsafe.Pointer(v16))
		*(*uintptr)(unsafe.Pointer(v16))++
		*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
		v18 = envPtr2 + 152
		v17 = *(*uintptr)(unsafe.Pointer(v18))
		*(*uintptr)(unsafe.Pointer(v18))++
		*(*uint8)(unsafe.Pointer(v17)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LIST)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v19 = delta1
			v20 = envPtr2
			if v19 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v20)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v20)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v20)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v20)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v20 + 64)) += int64(v19)
		}
	}
	/*
	 * Evaluate each value list and leave it on stack.
	 */
	i1 = 0
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
	for {
		if !(i1 < numWords-int32(1)) {
			break
		}
		if i1%int32(2) == 0 && i1 > 0 {
			if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
				_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
				if _objIndexCopy <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v23 = envPtr2 + 152
					v22 = *(*uintptr)(unsafe.Pointer(v23))
					*(*uintptr)(unsafe.Pointer(v23))++
					*(*uint8)(unsafe.Pointer(v22)) = libc.Uint8FromInt32(int32(INST_PUSH1))
					v25 = envPtr2 + 152
					v24 = *(*uintptr)(unsafe.Pointer(v25))
					*(*uintptr)(unsafe.Pointer(v25))++
					*(*uint8)(unsafe.Pointer(v24)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy
						}
						v26 = delta1
						v27 = envPtr2
						if v26 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v27)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v27)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v27)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v27)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v27 + 64)) += int64(v26)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v29 = envPtr2 + 152
					v28 = *(*uintptr)(unsafe.Pointer(v29))
					*(*uintptr)(unsafe.Pointer(v29))++
					*(*uint8)(unsafe.Pointer(v28)) = libc.Uint8FromInt32(int32(INST_PUSH4))
					v31 = envPtr2 + 152
					v30 = *(*uintptr)(unsafe.Pointer(v31))
					*(*uintptr)(unsafe.Pointer(v31))++
					*(*uint8)(unsafe.Pointer(v30)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
					v33 = envPtr2 + 152
					v32 = *(*uintptr)(unsafe.Pointer(v33))
					*(*uintptr)(unsafe.Pointer(v33))++
					*(*uint8)(unsafe.Pointer(v32)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
					v35 = envPtr2 + 152
					v34 = *(*uintptr)(unsafe.Pointer(v35))
					*(*uintptr)(unsafe.Pointer(v35))++
					*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
					v37 = envPtr2 + 152
					v36 = *(*uintptr)(unsafe.Pointer(v37))
					*(*uintptr)(unsafe.Pointer(v37))++
					*(*uint8)(unsafe.Pointer(v36)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy
						}
						v38 = delta1
						v39 = envPtr2
						if v38 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v39)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v39)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v39)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v39)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v39 + 64)) += int64(v38)
					}
				}
			} else {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
				XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
			}
		}
		goto _21
	_21:
		;
		i1++
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v41 = envPtr2 + 152
	v40 = *(*uintptr)(unsafe.Pointer(v41))
	*(*uintptr)(unsafe.Pointer(v41))++
	*(*uint8)(unsafe.Pointer(v40)) = libc.Uint8FromInt32(int32(INST_FOREACH_START))
	v43 = envPtr2 + 152
	v42 = *(*uintptr)(unsafe.Pointer(v43))
	*(*uintptr)(unsafe.Pointer(v43))++
	*(*uint8)(unsafe.Pointer(v42)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(24))
	v45 = envPtr2 + 152
	v44 = *(*uintptr)(unsafe.Pointer(v45))
	*(*uintptr)(unsafe.Pointer(v45))++
	*(*uint8)(unsafe.Pointer(v44)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(16))
	v47 = envPtr2 + 152
	v46 = *(*uintptr)(unsafe.Pointer(v47))
	*(*uintptr)(unsafe.Pointer(v47))++
	*(*uint8)(unsafe.Pointer(v46)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(8))
	v49 = envPtr2 + 152
	v48 = *(*uintptr)(unsafe.Pointer(v49))
	*(*uintptr)(unsafe.Pointer(v49))++
	*(*uint8)(unsafe.Pointer(v48)) = uint8(libc.Uint32FromInt32(infoIndex))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_FOREACH_START)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - infoIndex
		}
		v50 = delta1
		v51 = envPtr2
		if v50 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v51)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v51)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v51)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v51)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v51 + 64)) += int64(v50)
	}
	/*
	 * Inline compile the loop body.
	 */
	range1 = int32(XTclCreateExceptRange(tls, int32(LOOP_EXCEPTION_RANGE), envPtr2))
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth++
	if libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth)+uint64(1) > libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth)+uint64(1) {
		v52 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth
	} else {
		v52 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth = v52
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(numWords-libc.Int32FromInt32(1))*8))
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(numWords-libc.Int32FromInt32(1))*8))
	XTclCompileCmdWord(tls, interp, bodyTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(bodyTokenPtr)).FnumComponents), envPtr2)
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth--
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FnumCodeBytes = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(int32((*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset))
	if collect == int32(TCL_EACH_COLLECT) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v54 = envPtr2 + 152
		v53 = *(*uintptr)(unsafe.Pointer(v54))
		*(*uintptr)(unsafe.Pointer(v54))++
		*(*uint8)(unsafe.Pointer(v53)) = libc.Uint8FromInt32(int32(INST_LMAP_COLLECT))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LMAP_COLLECT)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v55 = delta1
			v56 = envPtr2
			if v55 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v56)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v56)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v56)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v56)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v56 + 64)) += int64(v55)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v58 = envPtr2 + 152
		v57 = *(*uintptr)(unsafe.Pointer(v58))
		*(*uintptr)(unsafe.Pointer(v58))++
		*(*uint8)(unsafe.Pointer(v57)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v59 = delta1
			v60 = envPtr2
			if v59 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v60)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v60)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v60)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v60)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v60 + 64)) += int64(v59)
		}
	}
	/*
	 * Bottom of loop code: assign each loop variable and check whether
	 * to terminate the loop. Set the loop's break target.
	 */
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcontinueOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v62 = envPtr2 + 152
	v61 = *(*uintptr)(unsafe.Pointer(v62))
	*(*uintptr)(unsafe.Pointer(v62))++
	*(*uint8)(unsafe.Pointer(v61)) = libc.Uint8FromInt32(int32(INST_FOREACH_STEP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_FOREACH_STEP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v63 = delta1
		v64 = envPtr2
		if v63 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v64)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v64)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v64)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v64)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v64 + 64)) += int64(v63)
	}
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FbreakOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	XTclFinalizeLoopExceptionRange(tls, envPtr2, range1)
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v66 = envPtr2 + 152
	v65 = *(*uintptr)(unsafe.Pointer(v66))
	*(*uintptr)(unsafe.Pointer(v66))++
	*(*uint8)(unsafe.Pointer(v65)) = libc.Uint8FromInt32(int32(INST_FOREACH_END))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_FOREACH_END)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v67 = delta1
		v68 = envPtr2
		if v67 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v68)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v68)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v68)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v68)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v68 + 64)) += int64(v67)
	}
	v69 = -(numLists + int32(2))
	v70 = envPtr2
	if v69 < libc.Int32FromInt32(0) {
		if int32((*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth) {
			(*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth
		}
	}
	*(*TTcl_Size)(unsafe.Pointer(v70 + 64)) += int64(v69)
	/*
	 * Set the jumpback distance from INST_FOREACH_STEP to the start of the
	 * body's code. Misuse loopCtTemp for storing the jump size.
	 */
	jumpBackOffset = int32((*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcontinueOffset - (*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset)
	(*TForeachInfo)(unsafe.Pointer(infoPtr)).FloopCtTemp = int64(-jumpBackOffset)
	/*
	 * The command's result is an empty string if not collecting. If
	 * collecting, it is automatically left on stack after FOREACH_END.
	 */
	if collect != int32(TCL_EACH_COLLECT) {
		_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy1 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v72 = envPtr2 + 152
			v71 = *(*uintptr)(unsafe.Pointer(v72))
			*(*uintptr)(unsafe.Pointer(v72))++
			*(*uint8)(unsafe.Pointer(v71)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v74 = envPtr2 + 152
			v73 = *(*uintptr)(unsafe.Pointer(v74))
			*(*uintptr)(unsafe.Pointer(v74))++
			*(*uint8)(unsafe.Pointer(v73)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v75 = delta1
				v76 = envPtr2
				if v75 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v76)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v76)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v76)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v76)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v76 + 64)) += int64(v75)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v78 = envPtr2 + 152
			v77 = *(*uintptr)(unsafe.Pointer(v78))
			*(*uintptr)(unsafe.Pointer(v78))++
			*(*uint8)(unsafe.Pointer(v77)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v80 = envPtr2 + 152
			v79 = *(*uintptr)(unsafe.Pointer(v80))
			*(*uintptr)(unsafe.Pointer(v80))++
			*(*uint8)(unsafe.Pointer(v79)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
			v82 = envPtr2 + 152
			v81 = *(*uintptr)(unsafe.Pointer(v82))
			*(*uintptr)(unsafe.Pointer(v82))++
			*(*uint8)(unsafe.Pointer(v81)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
			v84 = envPtr2 + 152
			v83 = *(*uintptr)(unsafe.Pointer(v84))
			*(*uintptr)(unsafe.Pointer(v84))++
			*(*uint8)(unsafe.Pointer(v83)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
			v86 = envPtr2 + 152
			v85 = *(*uintptr)(unsafe.Pointer(v86))
			*(*uintptr)(unsafe.Pointer(v86))++
			*(*uint8)(unsafe.Pointer(v85)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v87 = delta1
				v88 = envPtr2
				if v87 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v88)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v88)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v88)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v88)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v88 + 64)) += int64(v87)
			}
		}
	}
	goto done
done:
	;
	if code == int32(TCL_ERROR) {
		_FreeForeachInfo(tls, infoPtr)
	}
	_objPtr = varListObj
	v90 = _objPtr
	v89 = *(*TTcl_Size)(unsafe.Pointer(v90))
	*(*TTcl_Size)(unsafe.Pointer(v90))--
	if v89 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return code
}

/*
 *----------------------------------------------------------------------
 *
 * DupForeachInfo --
 *
 *	This procedure duplicates a ForeachInfo structure created as auxiliary
 *	data during the compilation of a foreach command.
 *
 * Results:
 *	A pointer to a newly allocated copy of the existing ForeachInfo
 *	structure is returned.
 *
 * Side effects:
 *	Storage for the copied ForeachInfo record is allocated. If the
 *	original ForeachInfo structure pointed to any ForeachVarList records,
 *	these structures are also copied and pointers to them are stored in
 *	the new ForeachInfo record.
 *
 *----------------------------------------------------------------------
 */

func _DupForeachInfo(tls *libc.TLS, clientData uintptr) (r uintptr) {
	/* The foreach command's compilation auxiliary
	 * data to duplicate. */
	var dupListPtr, dupPtr, srcListPtr, srcPtr uintptr
	var i, j, numLists, numVars int32
	_, _, _, _, _, _, _, _ = dupListPtr, dupPtr, i, j, numLists, numVars, srcListPtr, srcPtr
	srcPtr = clientData
	numLists = int32((*TForeachInfo)(unsafe.Pointer(srcPtr)).FnumLists)
	dupPtr = XTcl_Alloc(tls, uint64(libc.UintptrFromInt32(0)+24)+libc.Uint64FromInt32(numLists)*uint64(8))
	(*TForeachInfo)(unsafe.Pointer(dupPtr)).FnumLists = int64(numLists)
	(*TForeachInfo)(unsafe.Pointer(dupPtr)).FfirstValueTemp = (*TForeachInfo)(unsafe.Pointer(srcPtr)).FfirstValueTemp
	(*TForeachInfo)(unsafe.Pointer(dupPtr)).FloopCtTemp = (*TForeachInfo)(unsafe.Pointer(srcPtr)).FloopCtTemp
	i = 0
	for {
		if !(i < numLists) {
			break
		}
		srcListPtr = *(*uintptr)(unsafe.Pointer(srcPtr + 24 + uintptr(i)*8))
		numVars = int32((*TForeachVarList)(unsafe.Pointer(srcListPtr)).FnumVars)
		dupListPtr = XTcl_Alloc(tls, uint64(libc.UintptrFromInt32(0)+8)+libc.Uint64FromInt32(numVars)*uint64(8))
		(*TForeachVarList)(unsafe.Pointer(dupListPtr)).FnumVars = int64(numVars)
		j = 0
		for {
			if !(j < numVars) {
				break
			}
			*(*TTcl_Size)(unsafe.Pointer(dupListPtr + 8 + uintptr(j)*8)) = *(*TTcl_Size)(unsafe.Pointer(srcListPtr + 8 + uintptr(j)*8))
			goto _2
		_2:
			;
			j++
		}
		*(*uintptr)(unsafe.Pointer(dupPtr + 24 + uintptr(i)*8)) = dupListPtr
		goto _1
	_1:
		;
		i++
	}
	return dupPtr
}

/*
 *----------------------------------------------------------------------
 *
 * FreeForeachInfo --
 *
 *	Procedure to free a ForeachInfo structure created as auxiliary data
 *	during the compilation of a foreach command.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Storage for the ForeachInfo structure pointed to by the ClientData
 *	argument is freed as is any ForeachVarList record pointed to by the
 *	ForeachInfo structure.
 *
 *----------------------------------------------------------------------
 */

func _FreeForeachInfo(tls *libc.TLS, clientData uintptr) {
	/* The foreach command's compilation auxiliary
	 * data to free. */
	var i, numLists Tsize_t
	var infoPtr, listPtr uintptr
	_, _, _, _ = i, infoPtr, listPtr, numLists
	infoPtr = clientData
	numLists = libc.Uint64FromInt64((*TForeachInfo)(unsafe.Pointer(infoPtr)).FnumLists)
	i = uint64(0)
	for {
		if !(i < numLists) {
			break
		}
		listPtr = *(*uintptr)(unsafe.Pointer(infoPtr + 24 + uintptr(i)*8))
		XTclpFree(tls, listPtr)
		goto _1
	_1:
		;
		i++
	}
	XTclpFree(tls, infoPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * PrintForeachInfo, DisassembleForeachInfo --
 *
 *	Functions to write a human-readable or script-readablerepresentation
 *	of a ForeachInfo structure to a Tcl_Obj for debugging.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _PrintForeachInfo(tls *libc.TLS, clientData uintptr, appendObj uintptr, dummy3051 uintptr, dummy3052 Tsize_t) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var i, j TTcl_Size
	var infoPtr, varsPtr uintptr
	_, _, _, _ = i, infoPtr, j, varsPtr
	infoPtr = clientData
	XTcl_AppendToObj(tls, appendObj, __ccgo_ts+21637, int64(-int32(1)))
	i = 0
	for {
		if !(i < (*TForeachInfo)(unsafe.Pointer(infoPtr)).FnumLists) {
			break
		}
		if i != 0 {
			XTcl_AppendToObj(tls, appendObj, __ccgo_ts+21617, int64(-int32(1)))
		}
		XTcl_AppendPrintfToObj(tls, appendObj, __ccgo_ts+21620, libc.VaList(bp+8, (*TForeachInfo)(unsafe.Pointer(infoPtr)).FfirstValueTemp+i))
		goto _1
	_1:
		;
		i++
	}
	XTcl_AppendPrintfToObj(tls, appendObj, __ccgo_ts+21644, libc.VaList(bp+8, (*TForeachInfo)(unsafe.Pointer(infoPtr)).FloopCtTemp))
	i = 0
	for {
		if !(i < (*TForeachInfo)(unsafe.Pointer(infoPtr)).FnumLists) {
			break
		}
		if i != 0 {
			XTcl_AppendToObj(tls, appendObj, __ccgo_ts+21659, int64(-int32(1)))
		}
		XTcl_AppendPrintfToObj(tls, appendObj, __ccgo_ts+21661, libc.VaList(bp+8, (*TForeachInfo)(unsafe.Pointer(infoPtr)).FfirstValueTemp+i))
		varsPtr = *(*uintptr)(unsafe.Pointer(infoPtr + 24 + uintptr(i)*8))
		j = 0
		for {
			if !(j < (*TForeachVarList)(unsafe.Pointer(varsPtr)).FnumVars) {
				break
			}
			if j != 0 {
				XTcl_AppendToObj(tls, appendObj, __ccgo_ts+21617, int64(-int32(1)))
			}
			XTcl_AppendPrintfToObj(tls, appendObj, __ccgo_ts+21620, libc.VaList(bp+8, *(*TTcl_Size)(unsafe.Pointer(varsPtr + 8 + uintptr(j)*8))))
			goto _3
		_3:
			;
			j++
		}
		XTcl_AppendToObj(tls, appendObj, __ccgo_ts+21676, int64(-int32(1)))
		goto _2
	_2:
		;
		i++
	}
}

func _PrintNewForeachInfo(tls *libc.TLS, clientData uintptr, appendObj uintptr, dummy3091 uintptr, dummy3092 Tsize_t) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var i, j TTcl_Size
	var infoPtr, varsPtr uintptr
	_, _, _, _ = i, infoPtr, j, varsPtr
	infoPtr = clientData
	XTcl_AppendPrintfToObj(tls, appendObj, __ccgo_ts+21678, libc.VaList(bp+8, (*TForeachInfo)(unsafe.Pointer(infoPtr)).FloopCtTemp))
	i = 0
	for {
		if !(i < (*TForeachInfo)(unsafe.Pointer(infoPtr)).FnumLists) {
			break
		}
		if i != 0 {
			XTcl_AppendToObj(tls, appendObj, __ccgo_ts+21659, int64(-int32(1)))
		}
		XTcl_AppendToObj(tls, appendObj, __ccgo_ts+21701, int64(-int32(1)))
		varsPtr = *(*uintptr)(unsafe.Pointer(infoPtr + 24 + uintptr(i)*8))
		j = 0
		for {
			if !(j < (*TForeachVarList)(unsafe.Pointer(varsPtr)).FnumVars) {
				break
			}
			if j != 0 {
				XTcl_AppendToObj(tls, appendObj, __ccgo_ts+21659, int64(-int32(1)))
			}
			XTcl_AppendPrintfToObj(tls, appendObj, __ccgo_ts+21620, libc.VaList(bp+8, *(*TTcl_Size)(unsafe.Pointer(varsPtr + 8 + uintptr(j)*8))))
			goto _2
		_2:
			;
			j++
		}
		XTcl_AppendToObj(tls, appendObj, __ccgo_ts+21676, int64(-int32(1)))
		goto _1
	_1:
		;
		i++
	}
}

func _DisassembleForeachInfo(tls *libc.TLS, clientData uintptr, dictObj uintptr, dummy3121 uintptr, dummy3122 Tsize_t) {
	var cachePtr, cachePtr1, cachePtr2, infoPtr, innerPtr, objPtr, varsPtr uintptr
	var i, j TTcl_Size
	var v1, v3, v5 bool
	_, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, i, infoPtr, innerPtr, j, objPtr, varsPtr, v1, v3, v5
	infoPtr = clientData
	/*
	 * Data stores.
	 */
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	i = 0
	for {
		if !(i < (*TForeachInfo)(unsafe.Pointer(infoPtr)).FnumLists) {
			break
		}
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), objPtr, XTcl_NewWideIntObj(tls, (*TForeachInfo)(unsafe.Pointer(infoPtr)).FfirstValueTemp+i))
		goto _2
	_2:
		;
		i++
	}
	XTclDictPut(tls, libc.UintptrFromInt32(0), dictObj, __ccgo_ts+11029, objPtr)
	/*
	 * Loop counter.
	 */
	XTclDictPut(tls, libc.UintptrFromInt32(0), dictObj, __ccgo_ts+21703, XTcl_NewWideIntObj(tls, (*TForeachInfo)(unsafe.Pointer(infoPtr)).FloopCtTemp))
	/*
	 * Assignment targets.
	 */
	if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	i = 0
	for {
		if !(i < (*TForeachInfo)(unsafe.Pointer(infoPtr)).FnumLists) {
			break
		}
		if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
			cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v5 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
			innerPtr = XTclThreadAllocObj(tls)
		} else {
			innerPtr = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(innerPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(innerPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(innerPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(innerPtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(innerPtr)).FtypePtr = libc.UintptrFromInt32(0)
		varsPtr = *(*uintptr)(unsafe.Pointer(infoPtr + 24 + uintptr(i)*8))
		j = 0
		for {
			if !(j < (*TForeachVarList)(unsafe.Pointer(varsPtr)).FnumVars) {
				break
			}
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), innerPtr, XTcl_NewWideIntObj(tls, *(*TTcl_Size)(unsafe.Pointer(varsPtr + 8 + uintptr(j)*8))))
			goto _6
		_6:
			;
			j++
		}
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), objPtr, innerPtr)
		goto _4
	_4:
		;
		i++
	}
	XTclDictPut(tls, libc.UintptrFromInt32(0), dictObj, __ccgo_ts+21708, objPtr)
}

func _DisassembleNewForeachInfo(tls *libc.TLS, clientData uintptr, dictObj uintptr, dummy3167 uintptr, dummy3168 Tsize_t) {
	var cachePtr, cachePtr1, infoPtr, innerPtr, objPtr, varsPtr uintptr
	var i, j TTcl_Size
	var v1, v3 bool
	_, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, i, infoPtr, innerPtr, j, objPtr, varsPtr, v1, v3
	infoPtr = clientData
	/*
	 * Jump offset.
	 */
	XTclDictPut(tls, libc.UintptrFromInt32(0), dictObj, __ccgo_ts+21715, XTcl_NewWideIntObj(tls, (*TForeachInfo)(unsafe.Pointer(infoPtr)).FloopCtTemp))
	/*
	 * Assignment targets.
	 */
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	i = 0
	for {
		if !(i < (*TForeachInfo)(unsafe.Pointer(infoPtr)).FnumLists) {
			break
		}
		if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			innerPtr = XTclThreadAllocObj(tls)
		} else {
			innerPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(innerPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(innerPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(innerPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(innerPtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(innerPtr)).FtypePtr = libc.UintptrFromInt32(0)
		varsPtr = *(*uintptr)(unsafe.Pointer(infoPtr + 24 + uintptr(i)*8))
		j = 0
		for {
			if !(j < (*TForeachVarList)(unsafe.Pointer(varsPtr)).FnumVars) {
				break
			}
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), innerPtr, XTcl_NewWideIntObj(tls, *(*TTcl_Size)(unsafe.Pointer(varsPtr + 8 + uintptr(j)*8))))
			goto _4
		_4:
			;
			j++
		}
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), objPtr, innerPtr)
		goto _2
	_2:
		;
		i++
	}
	XTclDictPut(tls, libc.UintptrFromInt32(0), dictObj, __ccgo_ts+21708, objPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileFormatCmd --
 *
 *	Procedure called to compile the "format" command. Handles cases that
 *	can be done as constants or simple string concatenation only.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "format" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileFormatCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy3223 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, delta1, i1, j, v104, v114, v18, v30, v52, v64, v73, v8, v85, v92 int32
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, _objPtr6, _objPtr7, _objPtr8, _objPtr9, b, bytes, cachePtr, cachePtr1, cachePtr2, cachePtr3, formatObj, mapPtr, objv, start, tmpObj, tokenPtr, v10, v100, v101, v102, v103, v105, v107, v109, v110, v111, v112, v113, v115, v12, v13, v14, v15, v16, v17, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v31, v33, v36, v38, v40, v42, v43, v46, v47, v48, v49, v50, v51, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v65, v67, v69, v70, v71, v72, v74, v75, v76, v77, v78, v79, v80, v81, v82, v83, v84, v86, v87, v88, v89, v90, v91, v93, v94, v95, v96, v97, v98, v99 uintptr
	var eclIndex, v106, v108, v11, v2, v32, v35, v39, v41, v66, v9 TTcl_Size
	var v1, v44, v5, v68 bool
	var _ /* len at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, _objPtr6, _objPtr7, _objPtr8, _objPtr9, b, bytes, cachePtr, cachePtr1, cachePtr2, cachePtr3, delta1, eclIndex, formatObj, i1, j, mapPtr, objv, start, tmpObj, tokenPtr, v1, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v35, v36, v38, v39, v40, v41, v42, v43, v44, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1) /* TIP #280 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
	/*
	 * Don't handle any guaranteed-error cases.
	 */
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) < int32(2) {
		return int32(TCL_ERROR)
	}
	/*
	 * Check if the argument words are all compile-time-known literals; that's
	 * a case we can handle by compiling to a constant.
	 */
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		formatObj = XTclThreadAllocObj(tls)
	} else {
		formatObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(formatObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(formatObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(formatObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(formatObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(formatObj)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(formatObj)).FrefCount++
	tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if !(XTclWordKnownAtCompileTime(tls, tokenPtr, formatObj) != 0) {
		_objPtr = formatObj
		v3 = _objPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		return int32(TCL_ERROR)
	}
	objv = XTcl_Alloc(tls, libc.Uint64FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(2))*uint64(8))
	i1 = 0
	for {
		if !(i1+int32(2) < int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)) {
			break
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v5 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(objv + uintptr(i1)*8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(objv + uintptr(i1)*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i1)*8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i1)*8)))).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i1)*8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i1)*8)))).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i1)*8)))).FtypePtr = libc.UintptrFromInt32(0)
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i1)*8)))).FrefCount++
		if !(XTclWordKnownAtCompileTime(tls, tokenPtr, *(*uintptr)(unsafe.Pointer(objv + uintptr(i1)*8))) != 0) {
			goto checkForStringConcatCase
		}
		goto _4
	_4:
		;
		i1++
	}
	/*
	 * Everything is a literal, so the result is constant too (or an error if
	 * the format is broken). Do the format now.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(formatObj)).Fbytes != 0 {
		v6 = (*TTcl_Obj)(unsafe.Pointer(formatObj)).Fbytes
	} else {
		v6 = XTcl_GetStringFromObj(tls, formatObj, libc.UintptrFromInt32(0))
	}
	tmpObj = XTcl_Format(tls, interp, v6, int64(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-int32(2)), objv)
	for {
		i1--
		v8 = i1
		if !(v8 >= 0) {
			break
		}
		_objPtr1 = *(*uintptr)(unsafe.Pointer(objv + uintptr(i1)*8))
		v10 = _objPtr1
		v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
		*(*TTcl_Size)(unsafe.Pointer(v10))--
		if v9 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		goto _7
	_7:
	}
	XTclpFree(tls, objv)
	_objPtr2 = formatObj
	v12 = _objPtr2
	v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
	*(*TTcl_Size)(unsafe.Pointer(v12))--
	if v11 <= int64(1) {
		XTclFreeObj(tls, _objPtr2)
	}
	if tmpObj == libc.UintptrFromInt32(0) {
		XTclCompileSyntaxError(tls, interp, envPtr2)
		return TCL_OK
	}
	/*
	 * Not an error, always a constant result, so just push the result as a
	 * literal. Job done.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength
		v13 = (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes
	} else {
		v13 = XTcl_GetStringFromObj(tls, tmpObj, bp)
	}
	bytes = v13
	_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, bytes, *(*TTcl_Size)(unsafe.Pointer(bp)), 0)
	if _objIndexCopy <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v15 = envPtr2 + 152
		v14 = *(*uintptr)(unsafe.Pointer(v15))
		*(*uintptr)(unsafe.Pointer(v15))++
		*(*uint8)(unsafe.Pointer(v14)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v17 = envPtr2 + 152
		v16 = *(*uintptr)(unsafe.Pointer(v17))
		*(*uintptr)(unsafe.Pointer(v17))++
		*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v18 = delta1
			v19 = envPtr2
			if v18 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v19 + 64)) += int64(v18)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v21 = envPtr2 + 152
		v20 = *(*uintptr)(unsafe.Pointer(v21))
		*(*uintptr)(unsafe.Pointer(v21))++
		*(*uint8)(unsafe.Pointer(v20)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v23 = envPtr2 + 152
		v22 = *(*uintptr)(unsafe.Pointer(v23))
		*(*uintptr)(unsafe.Pointer(v23))++
		*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
		v25 = envPtr2 + 152
		v24 = *(*uintptr)(unsafe.Pointer(v25))
		*(*uintptr)(unsafe.Pointer(v25))++
		*(*uint8)(unsafe.Pointer(v24)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
		v27 = envPtr2 + 152
		v26 = *(*uintptr)(unsafe.Pointer(v27))
		*(*uintptr)(unsafe.Pointer(v27))++
		*(*uint8)(unsafe.Pointer(v26)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
		v29 = envPtr2 + 152
		v28 = *(*uintptr)(unsafe.Pointer(v29))
		*(*uintptr)(unsafe.Pointer(v29))++
		*(*uint8)(unsafe.Pointer(v28)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v30 = delta1
			v31 = envPtr2
			if v30 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v31)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v31)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v31)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v31)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v31 + 64)) += int64(v30)
		}
	}
	_objPtr3 = tmpObj
	v33 = _objPtr3
	v32 = *(*TTcl_Size)(unsafe.Pointer(v33))
	*(*TTcl_Size)(unsafe.Pointer(v33))--
	if v32 <= int64(1) {
		XTclFreeObj(tls, _objPtr3)
	}
	return TCL_OK
	goto checkForStringConcatCase
checkForStringConcatCase:
	;
	/*
	 * See if we can generate a sequence of things to concatenate. This
	 * requires that all the % sequences be %s or %%, as everything else is
	 * sufficiently complex that we don't bother.
	 *
	 * First, get the state of the system relatively sensible (cleaning up
	 * after our attempt to spot a literal).
	 */
	for {
		if !(i1 >= 0) {
			break
		}
		_objPtr4 = *(*uintptr)(unsafe.Pointer(objv + uintptr(i1)*8))
		v36 = _objPtr4
		v35 = *(*TTcl_Size)(unsafe.Pointer(v36))
		*(*TTcl_Size)(unsafe.Pointer(v36))--
		if v35 <= int64(1) {
			XTclFreeObj(tls, _objPtr4)
		}
		goto _34
	_34:
		;
		i1--
	}
	XTclpFree(tls, objv)
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	i1 = 0
	/*
	 * Now scan through and check for non-%s and non-%% substitutions.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(formatObj)).Fbytes != 0 {
		v38 = (*TTcl_Obj)(unsafe.Pointer(formatObj)).Fbytes
	} else {
		v38 = XTcl_GetStringFromObj(tls, formatObj, libc.UintptrFromInt32(0))
	}
	bytes = v38
	for {
		if !(*(*uint8)(unsafe.Pointer(bytes)) != 0) {
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes))) == int32('%') {
			bytes++
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes))) == int32('s') {
				i1++
				goto _37
			} else {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes))) == int32('%') {
					goto _37
				}
			}
			_objPtr5 = formatObj
			v40 = _objPtr5
			v39 = *(*TTcl_Size)(unsafe.Pointer(v40))
			*(*TTcl_Size)(unsafe.Pointer(v40))--
			if v39 <= int64(1) {
				XTclFreeObj(tls, _objPtr5)
			}
			return int32(TCL_ERROR)
		}
		goto _37
	_37:
		;
		bytes++
	}
	/*
	 * Check if the number of things to concatenate will fit in a byte.
	 */
	if i1+int32(2) != int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) || i1 > int32(125) {
		_objPtr6 = formatObj
		v42 = _objPtr6
		v41 = *(*TTcl_Size)(unsafe.Pointer(v42))
		*(*TTcl_Size)(unsafe.Pointer(v42))--
		if v41 <= int64(1) {
			XTclFreeObj(tls, _objPtr6)
		}
		return int32(TCL_ERROR)
	}
	/*
	 * Generate the pushes of the things to concatenate, a sequence of
	 * literals and compiled tokens (of which at least one is non-literal or
	 * we'd have the case in the first half of this function) which we will
	 * concatenate.
	 */
	i1 = 0       /* The count of things to concat. */
	j = int32(2) /* The index into the argument tokens, for
	 * TIP#280 handling. */
	if (*TTcl_Obj)(unsafe.Pointer(formatObj)).Fbytes != 0 {
		v43 = (*TTcl_Obj)(unsafe.Pointer(formatObj)).Fbytes
	} else {
		v43 = XTcl_GetStringFromObj(tls, formatObj, libc.UintptrFromInt32(0))
	}
	start = v43
	/* The start of the currently-scanned literal
	 * in the format string. */
	if v44 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v44 {
		cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v44 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
		tmpObj = XTclThreadAllocObj(tls)
	} else {
		tmpObj = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(tmpObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr = libc.UintptrFromInt32(0) /* The buffer used to accumulate the literal
	 * being built. */
	bytes = start
	for {
		if !(*(*uint8)(unsafe.Pointer(bytes)) != 0) {
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes))) == int32('%') {
			XTcl_AppendToObj(tls, tmpObj, start, int64(bytes)-int64(start))
			bytes++
			v46 = bytes
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v46))) == int32('%') {
				XTcl_AppendToObj(tls, tmpObj, __ccgo_ts+6266, int64(1))
			} else {
				if (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength
					v47 = (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes
				} else {
					v47 = XTcl_GetStringFromObj(tls, tmpObj, bp)
				}
				b = v47
				/*
				 * If there is a non-empty literal from the format string,
				 * push it and reset.
				 */
				if *(*TTcl_Size)(unsafe.Pointer(bp)) > 0 {
					_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, b, *(*TTcl_Size)(unsafe.Pointer(bp)), 0)
					if _objIndexCopy1 <= int32(255) {
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
							XTclExpandCodeArray(tls, envPtr2)
						}
						v49 = envPtr2 + 152
						v48 = *(*uintptr)(unsafe.Pointer(v49))
						*(*uintptr)(unsafe.Pointer(v49))++
						*(*uint8)(unsafe.Pointer(v48)) = libc.Uint8FromInt32(int32(INST_PUSH1))
						v51 = envPtr2 + 152
						v50 = *(*uintptr)(unsafe.Pointer(v51))
						*(*uintptr)(unsafe.Pointer(v51))++
						*(*uint8)(unsafe.Pointer(v50)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
							(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
						}
						delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
						if delta1 != 0 {
							if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
								delta1 = int32(1) - _objIndexCopy1
							}
							v52 = delta1
							v53 = envPtr2
							if v52 < libc.Int32FromInt32(0) {
								if int32((*TCompileEnv)(unsafe.Pointer(v53)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v53)).FcurrStackDepth) {
									(*TCompileEnv)(unsafe.Pointer(v53)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v53)).FcurrStackDepth
								}
							}
							*(*TTcl_Size)(unsafe.Pointer(v53 + 64)) += int64(v52)
						}
					} else {
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
							XTclExpandCodeArray(tls, envPtr2)
						}
						v55 = envPtr2 + 152
						v54 = *(*uintptr)(unsafe.Pointer(v55))
						*(*uintptr)(unsafe.Pointer(v55))++
						*(*uint8)(unsafe.Pointer(v54)) = libc.Uint8FromInt32(int32(INST_PUSH4))
						v57 = envPtr2 + 152
						v56 = *(*uintptr)(unsafe.Pointer(v57))
						*(*uintptr)(unsafe.Pointer(v57))++
						*(*uint8)(unsafe.Pointer(v56)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
						v59 = envPtr2 + 152
						v58 = *(*uintptr)(unsafe.Pointer(v59))
						*(*uintptr)(unsafe.Pointer(v59))++
						*(*uint8)(unsafe.Pointer(v58)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
						v61 = envPtr2 + 152
						v60 = *(*uintptr)(unsafe.Pointer(v61))
						*(*uintptr)(unsafe.Pointer(v61))++
						*(*uint8)(unsafe.Pointer(v60)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
						v63 = envPtr2 + 152
						v62 = *(*uintptr)(unsafe.Pointer(v63))
						*(*uintptr)(unsafe.Pointer(v63))++
						*(*uint8)(unsafe.Pointer(v62)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
							(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
						}
						delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
						if delta1 != 0 {
							if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
								delta1 = int32(1) - _objIndexCopy1
							}
							v64 = delta1
							v65 = envPtr2
							if v64 < libc.Int32FromInt32(0) {
								if int32((*TCompileEnv)(unsafe.Pointer(v65)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v65)).FcurrStackDepth) {
									(*TCompileEnv)(unsafe.Pointer(v65)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v65)).FcurrStackDepth
								}
							}
							*(*TTcl_Size)(unsafe.Pointer(v65 + 64)) += int64(v64)
						}
					}
					_objPtr7 = tmpObj
					v67 = _objPtr7
					v66 = *(*TTcl_Size)(unsafe.Pointer(v67))
					*(*TTcl_Size)(unsafe.Pointer(v67))--
					if v66 <= int64(1) {
						XTclFreeObj(tls, _objPtr7)
					}
					if v68 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v68 {
						cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v68 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
						tmpObj = XTclThreadAllocObj(tls)
					} else {
						tmpObj = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(tmpObj + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FrefCount = 0
					(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = 0
					(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr = libc.UintptrFromInt32(0)
					i1++
				}
				/*
				 * Push the code to produce the string that would be
				 * substituted with %s, except we'll be concatenating
				 * directly.
				 */
				if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
					_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
					if _objIndexCopy2 <= int32(255) {
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
							XTclExpandCodeArray(tls, envPtr2)
						}
						v70 = envPtr2 + 152
						v69 = *(*uintptr)(unsafe.Pointer(v70))
						*(*uintptr)(unsafe.Pointer(v70))++
						*(*uint8)(unsafe.Pointer(v69)) = libc.Uint8FromInt32(int32(INST_PUSH1))
						v72 = envPtr2 + 152
						v71 = *(*uintptr)(unsafe.Pointer(v72))
						*(*uintptr)(unsafe.Pointer(v72))++
						*(*uint8)(unsafe.Pointer(v71)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
							(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
						}
						delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
						if delta1 != 0 {
							if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
								delta1 = int32(1) - _objIndexCopy2
							}
							v73 = delta1
							v74 = envPtr2
							if v73 < libc.Int32FromInt32(0) {
								if int32((*TCompileEnv)(unsafe.Pointer(v74)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v74)).FcurrStackDepth) {
									(*TCompileEnv)(unsafe.Pointer(v74)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v74)).FcurrStackDepth
								}
							}
							*(*TTcl_Size)(unsafe.Pointer(v74 + 64)) += int64(v73)
						}
					} else {
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
							XTclExpandCodeArray(tls, envPtr2)
						}
						v76 = envPtr2 + 152
						v75 = *(*uintptr)(unsafe.Pointer(v76))
						*(*uintptr)(unsafe.Pointer(v76))++
						*(*uint8)(unsafe.Pointer(v75)) = libc.Uint8FromInt32(int32(INST_PUSH4))
						v78 = envPtr2 + 152
						v77 = *(*uintptr)(unsafe.Pointer(v78))
						*(*uintptr)(unsafe.Pointer(v78))++
						*(*uint8)(unsafe.Pointer(v77)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
						v80 = envPtr2 + 152
						v79 = *(*uintptr)(unsafe.Pointer(v80))
						*(*uintptr)(unsafe.Pointer(v80))++
						*(*uint8)(unsafe.Pointer(v79)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
						v82 = envPtr2 + 152
						v81 = *(*uintptr)(unsafe.Pointer(v82))
						*(*uintptr)(unsafe.Pointer(v82))++
						*(*uint8)(unsafe.Pointer(v81)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
						v84 = envPtr2 + 152
						v83 = *(*uintptr)(unsafe.Pointer(v84))
						*(*uintptr)(unsafe.Pointer(v84))++
						*(*uint8)(unsafe.Pointer(v83)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
							(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
						}
						delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
						if delta1 != 0 {
							if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
								delta1 = int32(1) - _objIndexCopy2
							}
							v85 = delta1
							v86 = envPtr2
							if v85 < libc.Int32FromInt32(0) {
								if int32((*TCompileEnv)(unsafe.Pointer(v86)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v86)).FcurrStackDepth) {
									(*TCompileEnv)(unsafe.Pointer(v86)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v86)).FcurrStackDepth
								}
							}
							*(*TTcl_Size)(unsafe.Pointer(v86 + 64)) += int64(v85)
						}
					}
				} else {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(j)*8))
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(j)*8))
					XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
				}
				tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
				j++
				i1++
			}
			start = bytes + uintptr(1)
		}
		goto _45
	_45:
		;
		bytes++
	}
	/*
	 * Handle the case of a trailing literal.
	 */
	XTcl_AppendToObj(tls, tmpObj, start, int64(bytes)-int64(start))
	if (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength
		v87 = (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes
	} else {
		v87 = XTcl_GetStringFromObj(tls, tmpObj, bp)
	}
	bytes = v87
	if *(*TTcl_Size)(unsafe.Pointer(bp)) > 0 {
		_objIndexCopy3 = XTclRegisterLiteral(tls, envPtr2, bytes, *(*TTcl_Size)(unsafe.Pointer(bp)), 0)
		if _objIndexCopy3 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v89 = envPtr2 + 152
			v88 = *(*uintptr)(unsafe.Pointer(v89))
			*(*uintptr)(unsafe.Pointer(v89))++
			*(*uint8)(unsafe.Pointer(v88)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v91 = envPtr2 + 152
			v90 = *(*uintptr)(unsafe.Pointer(v91))
			*(*uintptr)(unsafe.Pointer(v91))++
			*(*uint8)(unsafe.Pointer(v90)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy3
				}
				v92 = delta1
				v93 = envPtr2
				if v92 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v93)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v93)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v93)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v93)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v93 + 64)) += int64(v92)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v95 = envPtr2 + 152
			v94 = *(*uintptr)(unsafe.Pointer(v95))
			*(*uintptr)(unsafe.Pointer(v95))++
			*(*uint8)(unsafe.Pointer(v94)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v97 = envPtr2 + 152
			v96 = *(*uintptr)(unsafe.Pointer(v97))
			*(*uintptr)(unsafe.Pointer(v97))++
			*(*uint8)(unsafe.Pointer(v96)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(24))
			v99 = envPtr2 + 152
			v98 = *(*uintptr)(unsafe.Pointer(v99))
			*(*uintptr)(unsafe.Pointer(v99))++
			*(*uint8)(unsafe.Pointer(v98)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(16))
			v101 = envPtr2 + 152
			v100 = *(*uintptr)(unsafe.Pointer(v101))
			*(*uintptr)(unsafe.Pointer(v101))++
			*(*uint8)(unsafe.Pointer(v100)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(8))
			v103 = envPtr2 + 152
			v102 = *(*uintptr)(unsafe.Pointer(v103))
			*(*uintptr)(unsafe.Pointer(v103))++
			*(*uint8)(unsafe.Pointer(v102)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy3
				}
				v104 = delta1
				v105 = envPtr2
				if v104 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v105)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v105)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v105)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v105)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v105 + 64)) += int64(v104)
			}
		}
		i1++
	}
	_objPtr8 = tmpObj
	v107 = _objPtr8
	v106 = *(*TTcl_Size)(unsafe.Pointer(v107))
	*(*TTcl_Size)(unsafe.Pointer(v107))--
	if v106 <= int64(1) {
		XTclFreeObj(tls, _objPtr8)
	}
	_objPtr9 = formatObj
	v109 = _objPtr9
	v108 = *(*TTcl_Size)(unsafe.Pointer(v109))
	*(*TTcl_Size)(unsafe.Pointer(v109))--
	if v108 <= int64(1) {
		XTclFreeObj(tls, _objPtr9)
	}
	if i1 > int32(1) {
		/*
		 * Do the concatenation, which produces the result.
		 */
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v111 = envPtr2 + 152
		v110 = *(*uintptr)(unsafe.Pointer(v111))
		*(*uintptr)(unsafe.Pointer(v111))++
		*(*uint8)(unsafe.Pointer(v110)) = libc.Uint8FromInt32(int32(INST_STR_CONCAT1))
		v113 = envPtr2 + 152
		v112 = *(*uintptr)(unsafe.Pointer(v113))
		*(*uintptr)(unsafe.Pointer(v113))++
		*(*uint8)(unsafe.Pointer(v112)) = uint8(libc.Uint32FromInt32(i1))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STR_CONCAT1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - i1
			}
			v114 = delta1
			v115 = envPtr2
			if v114 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v115)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v115)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v115)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v115)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v115 + 64)) += int64(v114)
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclLocalScalarFromToken --
 *
 *	Get the index into the table of compiled locals that corresponds
 *	to a local scalar variable name.
 *
 * Results:
 *	Returns the non-negative integer index value into the table of
 *	compiled locals corresponding to a local scalar variable name.
 *	If the arguments passed in do not identify a local scalar variable
 *	then return TCL_INDEX_NONE.
 *
 * Side effects:
 *	May add an entry into the table of compiled locals.
 *
 *----------------------------------------------------------------------
 */

func XTclLocalScalarFromToken(tls *libc.TLS, tokenPtr uintptr, envPtr uintptr) (r Tsize_t) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _ /* index at bp+4 */ int32
	var _ /* isScalar at bp+0 */ int32
	XTclPushVarName(tls, libc.UintptrFromInt32(0), tokenPtr, envPtr, int32(TCL_NO_ELEMENT), bp+4, bp)
	if !(*(*int32)(unsafe.Pointer(bp)) != 0) {
		*(*int32)(unsafe.Pointer(bp + 4)) = -int32(1)
	}
	return libc.Uint64FromInt32(*(*int32)(unsafe.Pointer(bp + 4)))
}

func XTclLocalScalar(tls *libc.TLS, bytes uintptr, numBytes Tsize_t, envPtr uintptr) (r Tsize_t) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var _ /* token at bp+0 */ [2]TTcl_Token
	*(*[2]TTcl_Token)(unsafe.Pointer(bp)) = [2]TTcl_Token{
		0: {
			Ftype1:         int32(TCL_TOKEN_SIMPLE_WORD),
			FnumComponents: int64(1),
		},
		1: {
			Ftype1: int32(TCL_TOKEN_TEXT),
		},
	}
	(*(*[2]TTcl_Token)(unsafe.Pointer(bp)))[int32(1)].Fstart = bytes
	(*(*[2]TTcl_Token)(unsafe.Pointer(bp)))[int32(1)].Fsize = libc.Int64FromUint64(numBytes)
	return XTclLocalScalarFromToken(tls, bp, envPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * TclPushVarName --
 *
 *	Procedure used in the compiling where pushing a variable name is
 *	necessary (append, lappend, set).
 *
 * Results:
 *	The values written to *localIndexPtr and *isScalarPtr signal to
 *	the caller what the instructions emitted by this routine will do:
 *
 *	*isScalarPtr	(*localIndexPtr < 0)
 *	1		1	Push the varname on the stack. (Stack +1)
 *	1		0	*localIndexPtr is the index of the compiled
 *				local for this varname.  No instructions
 *				emitted.	(Stack +0)
 *	0		1	Push part1 and part2 names of array element
 *				on the stack.	(Stack +2)
 *	0		0	*localIndexPtr is the index of the compiled
 *				local for this array.  Element name is pushed
 *				on the stack.	(Stack +1)
 *
 * Side effects:
 *	Instructions are added to envPtr.
 *
 *----------------------------------------------------------------------
 */

func XTclPushVarName(tls *libc.TLS, interp uintptr, varTokenPtr uintptr, envPtr2 uintptr, flags int32, localIndexPtr uintptr, isScalarPtr uintptr) {
	/* Must not be NULL. */
	var _objIndexCopy, _objIndexCopy1, allocedTokens, delta1, elemTokenCount, hasNsQualifiers, localIndex, removedParen, simpleVarName, v12, v24, v30, v42 int32
	var elName, elemTokenPtr, last, name, p, v1, v10, v11, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v25, v26, v27, v28, v29, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v43, v8, v9 uintptr
	var elNameLen, n, nameLen, remainingLen, v2, v4 Tsize_t
	var v5 bool
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, allocedTokens, delta1, elName, elNameLen, elemTokenCount, elemTokenPtr, hasNsQualifiers, last, localIndex, n, name, nameLen, p, remainingLen, removedParen, simpleVarName, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v5, v8, v9
	elemTokenPtr = libc.UintptrFromInt32(0)
	elemTokenCount = 0
	allocedTokens = 0
	removedParen = 0
	/*
	 * Decide if we can use a frame slot for the var/array name or if we need
	 * to emit code to compute and push the name at runtime. We use a frame
	 * slot (entry in the array of local vars) if we are compiling a procedure
	 * body and if the name is simple text that does not include namespace
	 * qualifiers.
	 */
	simpleVarName = 0
	v1 = libc.UintptrFromInt32(0)
	elName = v1
	name = v1
	v2 = libc.Uint64FromInt32(0)
	elNameLen = v2
	nameLen = v2
	localIndex = -int32(1)
	if (*TTcl_Token)(unsafe.Pointer(varTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		/*
		 * A simple variable name. Divide it up into "name" and "elName"
		 * strings. If it is not a local variable, look it up at runtime.
		 */
		simpleVarName = int32(1)
		name = (*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Fstart
		nameLen = libc.Uint64FromInt64((*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Fsize)
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(nameLen-uint64(1))))) == int32(')') {
			/*
			 * last char is ')' => potential array reference.
			 */
			last = name + uintptr(nameLen-uint64(1))
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(last))) == int32(')') {
				p = name
				for {
					if !(p < last) {
						break
					}
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('(') {
						elName = p + uintptr(1)
						elNameLen = libc.Uint64FromInt64(int64(last) - int64(elName))
						nameLen = libc.Uint64FromInt64(int64(p) - int64(name))
						break
					}
					goto _3
				_3:
					;
					p++
				}
			}
			if !(flags&libc.Int32FromInt32(TCL_NO_ELEMENT) != 0) && elNameLen != 0 {
				/*
				 * An array element, the element name is a simple string:
				 * assemble the corresponding token.
				 */
				elemTokenPtr = XTclStackAlloc(tls, interp, uint64(32))
				allocedTokens = int32(1)
				(*TTcl_Token)(unsafe.Pointer(elemTokenPtr)).Ftype1 = int32(TCL_TOKEN_TEXT)
				(*TTcl_Token)(unsafe.Pointer(elemTokenPtr)).Fstart = elName
				(*TTcl_Token)(unsafe.Pointer(elemTokenPtr)).Fsize = libc.Int64FromUint64(elNameLen)
				(*TTcl_Token)(unsafe.Pointer(elemTokenPtr)).FnumComponents = 0
				elemTokenCount = int32(1)
			}
		}
	} else {
		if v5 = interp != 0; v5 {
			v4 = libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents)
			n = v4
		}
		if v5 && v4 > uint64(1) && (*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Ftype1 == int32(TCL_TOKEN_TEXT) && (*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + uintptr(n)*32))).Ftype1 == int32(TCL_TOKEN_TEXT) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + uintptr(n)*32))).Fstart + uintptr((*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + uintptr(n)*32))).Fsize) - libc.UintptrFromInt32(1)))) == int32(')') {
			/*
			 * Check for parentheses inside first token.
			 */
			simpleVarName = 0
			p = (*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Fstart
			last = p + uintptr((*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Fsize)
			for {
				if !(p < last) {
					break
				}
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('(') {
					simpleVarName = int32(1)
					break
				}
				goto _6
			_6:
				;
				p++
			}
			if simpleVarName != 0 {
				/*
				 * Check the last token: if it is just ')', do not count it.
				 * Otherwise, remove the ')' and flag so that it is restored at
				 * the end.
				 */
				if (*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + uintptr(n)*32))).Fsize == int64(1) {
					n--
				} else {
					(*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + uintptr(n)*32))).Fsize--
					removedParen = libc.Int32FromUint64(n)
				}
				name = (*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Fstart
				nameLen = libc.Uint64FromInt64(int64(p) - int64((*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Fstart))
				elName = p + uintptr(1)
				remainingLen = libc.Uint64FromInt64(int64((*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 2*32))).Fstart) - int64(p) - int64(1))
				elNameLen = libc.Uint64FromInt64(int64((*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + uintptr(n)*32))).Fstart) - int64(p) + (*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + uintptr(n)*32))).Fsize - int64(1))
				if !(flags&libc.Int32FromInt32(TCL_NO_ELEMENT) != 0) {
					if remainingLen != 0 {
						/*
						 * Make a first token with the extra characters in the first
						 * token.
						 */
						elemTokenPtr = XTclStackAlloc(tls, interp, n*uint64(32))
						allocedTokens = int32(1)
						(*TTcl_Token)(unsafe.Pointer(elemTokenPtr)).Ftype1 = int32(TCL_TOKEN_TEXT)
						(*TTcl_Token)(unsafe.Pointer(elemTokenPtr)).Fstart = elName
						(*TTcl_Token)(unsafe.Pointer(elemTokenPtr)).Fsize = libc.Int64FromUint64(remainingLen)
						(*TTcl_Token)(unsafe.Pointer(elemTokenPtr)).FnumComponents = 0
						elemTokenCount = libc.Int32FromUint64(n)
						/*
						 * Copy the remaining tokens.
						 */
						libc.Xmemcpy(tls, elemTokenPtr+uintptr(1)*32, varTokenPtr+uintptr(2)*32, (n-uint64(1))*uint64(32))
					} else {
						/*
						 * Use the already available tokens.
						 */
						elemTokenPtr = varTokenPtr + 2*32
						elemTokenCount = libc.Int32FromUint64(n - uint64(1))
					}
				}
			}
		}
	}
	if simpleVarName != 0 {
		/*
		 * See whether name has any namespace separators (::'s).
		 */
		hasNsQualifiers = 0
		p = name
		last = p + uintptr(nameLen) - libc.UintptrFromInt32(1)
		for {
			if !(p < last) {
				break
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(':') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32(':') {
				hasNsQualifiers = int32(1)
				break
			}
			goto _7
		_7:
			;
			p++
		}
		/*
		 * Look up the var name's index in the array of local vars in the proc
		 * frame. If retrieving the var's value and it doesn't already exist,
		 * push its name and look it up at runtime.
		 */
		if !(hasNsQualifiers != 0) {
			localIndex = int32(XTclFindCompiledLocal(tls, name, libc.Int64FromUint64(nameLen), int32(1), envPtr2))
			if flags&int32(TCL_NO_LARGE_INDEX) != 0 && localIndex > int32(255) {
				/*
				 * We'll push the name.
				 */
				localIndex = -int32(1)
			}
		}
		if interp != 0 && localIndex < 0 {
			_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, name, libc.Int64FromUint64(nameLen), 0)
			if _objIndexCopy <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v9 = envPtr2 + 152
				v8 = *(*uintptr)(unsafe.Pointer(v9))
				*(*uintptr)(unsafe.Pointer(v9))++
				*(*uint8)(unsafe.Pointer(v8)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v11 = envPtr2 + 152
				v10 = *(*uintptr)(unsafe.Pointer(v11))
				*(*uintptr)(unsafe.Pointer(v11))++
				*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v12 = delta1
					v13 = envPtr2
					if v12 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v13)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v13)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v13)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v13)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v13 + 64)) += int64(v12)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v15 = envPtr2 + 152
				v14 = *(*uintptr)(unsafe.Pointer(v15))
				*(*uintptr)(unsafe.Pointer(v15))++
				*(*uint8)(unsafe.Pointer(v14)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v17 = envPtr2 + 152
				v16 = *(*uintptr)(unsafe.Pointer(v17))
				*(*uintptr)(unsafe.Pointer(v17))++
				*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
				v19 = envPtr2 + 152
				v18 = *(*uintptr)(unsafe.Pointer(v19))
				*(*uintptr)(unsafe.Pointer(v19))++
				*(*uint8)(unsafe.Pointer(v18)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
				v21 = envPtr2 + 152
				v20 = *(*uintptr)(unsafe.Pointer(v21))
				*(*uintptr)(unsafe.Pointer(v21))++
				*(*uint8)(unsafe.Pointer(v20)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
				v23 = envPtr2 + 152
				v22 = *(*uintptr)(unsafe.Pointer(v23))
				*(*uintptr)(unsafe.Pointer(v23))++
				*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v24 = delta1
					v25 = envPtr2
					if v24 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v25 + 64)) += int64(v24)
				}
			}
		}
		/*
		 * Compile the element script, if any, and only if not inhibited. [Bug
		 * 3600328]
		 */
		if elName != libc.UintptrFromInt32(0) && !(flags&libc.Int32FromInt32(TCL_NO_ELEMENT) != 0) {
			if elNameLen != 0 {
				XTclCompileTokens(tls, interp, elemTokenPtr, libc.Uint64FromInt32(elemTokenCount), envPtr2)
			} else {
				_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
				if _objIndexCopy1 <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v27 = envPtr2 + 152
					v26 = *(*uintptr)(unsafe.Pointer(v27))
					*(*uintptr)(unsafe.Pointer(v27))++
					*(*uint8)(unsafe.Pointer(v26)) = libc.Uint8FromInt32(int32(INST_PUSH1))
					v29 = envPtr2 + 152
					v28 = *(*uintptr)(unsafe.Pointer(v29))
					*(*uintptr)(unsafe.Pointer(v29))++
					*(*uint8)(unsafe.Pointer(v28)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy1
						}
						v30 = delta1
						v31 = envPtr2
						if v30 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v31)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v31)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v31)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v31)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v31 + 64)) += int64(v30)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v33 = envPtr2 + 152
					v32 = *(*uintptr)(unsafe.Pointer(v33))
					*(*uintptr)(unsafe.Pointer(v33))++
					*(*uint8)(unsafe.Pointer(v32)) = libc.Uint8FromInt32(int32(INST_PUSH4))
					v35 = envPtr2 + 152
					v34 = *(*uintptr)(unsafe.Pointer(v35))
					*(*uintptr)(unsafe.Pointer(v35))++
					*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
					v37 = envPtr2 + 152
					v36 = *(*uintptr)(unsafe.Pointer(v37))
					*(*uintptr)(unsafe.Pointer(v37))++
					*(*uint8)(unsafe.Pointer(v36)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
					v39 = envPtr2 + 152
					v38 = *(*uintptr)(unsafe.Pointer(v39))
					*(*uintptr)(unsafe.Pointer(v39))++
					*(*uint8)(unsafe.Pointer(v38)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
					v41 = envPtr2 + 152
					v40 = *(*uintptr)(unsafe.Pointer(v41))
					*(*uintptr)(unsafe.Pointer(v41))++
					*(*uint8)(unsafe.Pointer(v40)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy1
						}
						v42 = delta1
						v43 = envPtr2
						if v42 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v43)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v43)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v43)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v43)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v43 + 64)) += int64(v42)
					}
				}
			}
		}
	} else {
		if interp != 0 {
			/*
			 * The var name isn't simple: compile and push it.
			 */
			XTclCompileTokens(tls, interp, varTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents), envPtr2)
		}
	}
	if removedParen != 0 {
		(*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + uintptr(removedParen)*32))).Fsize++
	}
	if allocedTokens != 0 {
		XTclStackFree(tls, interp, elemTokenPtr)
	}
	*(*int32)(unsafe.Pointer(localIndexPtr)) = localIndex
	*(*int32)(unsafe.Pointer(isScalarPtr)) = libc.BoolInt32(elName == libc.UintptrFromInt32(0))
}

/*
 *----------------------------------------------------------------------
 *
 * TclGetIndexFromToken --
 *
 *	Parse a token to determine if an index value is known at
 *	compile time.
 *
 * Returns:
 *	TCL_OK if parsing succeeded, and TCL_ERROR if it failed.
 *
 * Side effects:
 *	When TCL_OK is returned, the encoded index value is written
 *	to *index.
 *
 *----------------------------------------------------------------------
 */

func XTclGetIndexFromToken(tls *libc.TLS, tokenPtr uintptr, before Tsize_t, after Tsize_t, indexPtr uintptr) (r int32) {
	var _objPtr, cachePtr, tmpObj, v3 uintptr
	var result int32
	var v1 bool
	var v2 TTcl_Size
	_, _, _, _, _, _, _ = _objPtr, cachePtr, result, tmpObj, v1, v2, v3
	result = int32(TCL_ERROR)
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		tmpObj = XTclThreadAllocObj(tls)
	} else {
		tmpObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(tmpObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr = libc.UintptrFromInt32(0)
	if XTclWordKnownAtCompileTime(tls, tokenPtr, tmpObj) != 0 {
		result = XTclIndexEncode(tls, libc.UintptrFromInt32(0), tmpObj, libc.Int32FromUint64(before), libc.Int32FromUint64(after), indexPtr)
	}
	_objPtr = tmpObj
	v3 = _objPtr
	v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
	*(*TTcl_Size)(unsafe.Pointer(v3))--
	if v2 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileGlobalCmd --
 *
 *	Procedure called to compile the "global" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "global" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileGlobalCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy90 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, delta1, i1, localIndex, numWords, v17, v24, v36, v48, v5, v52, v58, v70 int32
	var eclIndex TTcl_Size
	var mapPtr, varTokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v2, v20, v21, v22, v23, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v49, v50, v51, v53, v54, v55, v56, v57, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v71, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, delta1, eclIndex, i1, localIndex, mapPtr, numWords, varTokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	/* TODO: Consider support for compiling expanded args. */
	numWords = int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)
	if numWords < int32(2) {
		return int32(TCL_ERROR)
	}
	/*
	 * 'global' has no effect outside of proc bodies; handle that at runtime
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FprocPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Push the namespace
	 */
	_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+7650, libc.Int64FromUint64(libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v2 = envPtr2 + 152
		v1 = *(*uintptr)(unsafe.Pointer(v2))
		*(*uintptr)(unsafe.Pointer(v2))++
		*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v4 = envPtr2 + 152
		v3 = *(*uintptr)(unsafe.Pointer(v4))
		*(*uintptr)(unsafe.Pointer(v4))++
		*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v5 = delta1
			v6 = envPtr2
			if v5 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v8 = envPtr2 + 152
		v7 = *(*uintptr)(unsafe.Pointer(v8))
		*(*uintptr)(unsafe.Pointer(v8))++
		*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v10 = envPtr2 + 152
		v9 = *(*uintptr)(unsafe.Pointer(v10))
		*(*uintptr)(unsafe.Pointer(v10))++
		*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
		v12 = envPtr2 + 152
		v11 = *(*uintptr)(unsafe.Pointer(v12))
		*(*uintptr)(unsafe.Pointer(v12))++
		*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
		v14 = envPtr2 + 152
		v13 = *(*uintptr)(unsafe.Pointer(v14))
		*(*uintptr)(unsafe.Pointer(v14))++
		*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
		v16 = envPtr2 + 152
		v15 = *(*uintptr)(unsafe.Pointer(v16))
		*(*uintptr)(unsafe.Pointer(v16))++
		*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v17 = delta1
			v18 = envPtr2
			if v17 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
		}
	}
	/*
	 * Loop over the variables.
	 */
	varTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	i1 = int32(1)
	for {
		if !(i1 < numWords) {
			break
		}
		localIndex = _IndexTailVarIfKnown(tls, interp, varTokenPtr, envPtr2)
		if localIndex < 0 {
			return int32(TCL_ERROR)
		}
		/*
		 * TODO: Consider what value can pass through the
		 * IndexTailVarIfKnown() screen. Full CompileWord() likely does not
		 * apply here. Push known value instead.
		 */
		if (*TTcl_Token)(unsafe.Pointer(varTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy1 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v21 = envPtr2 + 152
				v20 = *(*uintptr)(unsafe.Pointer(v21))
				*(*uintptr)(unsafe.Pointer(v21))++
				*(*uint8)(unsafe.Pointer(v20)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v23 = envPtr2 + 152
				v22 = *(*uintptr)(unsafe.Pointer(v23))
				*(*uintptr)(unsafe.Pointer(v23))++
				*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v24 = delta1
					v25 = envPtr2
					if v24 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v25 + 64)) += int64(v24)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v27 = envPtr2 + 152
				v26 = *(*uintptr)(unsafe.Pointer(v27))
				*(*uintptr)(unsafe.Pointer(v27))++
				*(*uint8)(unsafe.Pointer(v26)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v29 = envPtr2 + 152
				v28 = *(*uintptr)(unsafe.Pointer(v29))
				*(*uintptr)(unsafe.Pointer(v29))++
				*(*uint8)(unsafe.Pointer(v28)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
				v31 = envPtr2 + 152
				v30 = *(*uintptr)(unsafe.Pointer(v31))
				*(*uintptr)(unsafe.Pointer(v31))++
				*(*uint8)(unsafe.Pointer(v30)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
				v33 = envPtr2 + 152
				v32 = *(*uintptr)(unsafe.Pointer(v33))
				*(*uintptr)(unsafe.Pointer(v33))++
				*(*uint8)(unsafe.Pointer(v32)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
				v35 = envPtr2 + 152
				v34 = *(*uintptr)(unsafe.Pointer(v35))
				*(*uintptr)(unsafe.Pointer(v35))++
				*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v36 = delta1
					v37 = envPtr2
					if v36 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v37 + 64)) += int64(v36)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
			XTclCompileTokens(tls, interp, varTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents), envPtr2)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v39 = envPtr2 + 152
		v38 = *(*uintptr)(unsafe.Pointer(v39))
		*(*uintptr)(unsafe.Pointer(v39))++
		*(*uint8)(unsafe.Pointer(v38)) = libc.Uint8FromInt32(int32(INST_NSUPVAR))
		v41 = envPtr2 + 152
		v40 = *(*uintptr)(unsafe.Pointer(v41))
		*(*uintptr)(unsafe.Pointer(v41))++
		*(*uint8)(unsafe.Pointer(v40)) = uint8(libc.Uint32FromInt32(localIndex) >> libc.Int32FromInt32(24))
		v43 = envPtr2 + 152
		v42 = *(*uintptr)(unsafe.Pointer(v43))
		*(*uintptr)(unsafe.Pointer(v43))++
		*(*uint8)(unsafe.Pointer(v42)) = uint8(libc.Uint32FromInt32(localIndex) >> libc.Int32FromInt32(16))
		v45 = envPtr2 + 152
		v44 = *(*uintptr)(unsafe.Pointer(v45))
		*(*uintptr)(unsafe.Pointer(v45))++
		*(*uint8)(unsafe.Pointer(v44)) = uint8(libc.Uint32FromInt32(localIndex) >> libc.Int32FromInt32(8))
		v47 = envPtr2 + 152
		v46 = *(*uintptr)(unsafe.Pointer(v47))
		*(*uintptr)(unsafe.Pointer(v47))++
		*(*uint8)(unsafe.Pointer(v46)) = uint8(libc.Uint32FromInt32(localIndex))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_NSUPVAR)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - localIndex
			}
			v48 = delta1
			v49 = envPtr2
			if v48 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v49)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v49)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v49)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v49)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v49 + 64)) += int64(v48)
		}
		goto _19
	_19:
		;
		varTokenPtr = varTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		i1++
	}
	/*
	 * Pop the namespace, and set the result to empty
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v51 = envPtr2 + 152
	v50 = *(*uintptr)(unsafe.Pointer(v51))
	*(*uintptr)(unsafe.Pointer(v51))++
	*(*uint8)(unsafe.Pointer(v50)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v52 = delta1
		v53 = envPtr2
		if v52 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v53)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v53)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v53)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v53)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v53 + 64)) += int64(v52)
	}
	_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy2 <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v55 = envPtr2 + 152
		v54 = *(*uintptr)(unsafe.Pointer(v55))
		*(*uintptr)(unsafe.Pointer(v55))++
		*(*uint8)(unsafe.Pointer(v54)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v57 = envPtr2 + 152
		v56 = *(*uintptr)(unsafe.Pointer(v57))
		*(*uintptr)(unsafe.Pointer(v57))++
		*(*uint8)(unsafe.Pointer(v56)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy2
			}
			v58 = delta1
			v59 = envPtr2
			if v58 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v59)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v59)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v59)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v59)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v59 + 64)) += int64(v58)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v61 = envPtr2 + 152
		v60 = *(*uintptr)(unsafe.Pointer(v61))
		*(*uintptr)(unsafe.Pointer(v61))++
		*(*uint8)(unsafe.Pointer(v60)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v63 = envPtr2 + 152
		v62 = *(*uintptr)(unsafe.Pointer(v63))
		*(*uintptr)(unsafe.Pointer(v63))++
		*(*uint8)(unsafe.Pointer(v62)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
		v65 = envPtr2 + 152
		v64 = *(*uintptr)(unsafe.Pointer(v65))
		*(*uintptr)(unsafe.Pointer(v65))++
		*(*uint8)(unsafe.Pointer(v64)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
		v67 = envPtr2 + 152
		v66 = *(*uintptr)(unsafe.Pointer(v67))
		*(*uintptr)(unsafe.Pointer(v67))++
		*(*uint8)(unsafe.Pointer(v66)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
		v69 = envPtr2 + 152
		v68 = *(*uintptr)(unsafe.Pointer(v69))
		*(*uintptr)(unsafe.Pointer(v69))++
		*(*uint8)(unsafe.Pointer(v68)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy2
			}
			v70 = delta1
			v71 = envPtr2
			if v70 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v71)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v71)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v71)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v71)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v71 + 64)) += int64(v70)
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileIfCmd --
 *
 *	Procedure called to compile the "if" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "if" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileIfCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy171 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(416)
	defer tls.Free(416) /* Holds resulting instructions. */
	var _objIndexCopy, code, compileScripts, delta1, jumpFalseDist, jumpIndex, numWords, realCond, wordIdx, v11, v23, v5 int32
	var boolObj, cachePtr, ifFalsePc, mapPtr, testTokenPtr, tokenPtr, word, v10, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v24, v3, v6, v7, v8, v9 uintptr
	var eclIndex, v2 TTcl_Size
	var j, numBytes Tsize_t
	var opCode uint8
	var v4 bool
	var _ /* boolVal at bp+384 */ int32
	var _ /* jumpEndFixupArray at bp+192 */ TJumpFixupArray
	var _ /* jumpFalseFixupArray at bp+0 */ TJumpFixupArray
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, boolObj, cachePtr, code, compileScripts, delta1, eclIndex, ifFalsePc, j, jumpFalseDist, jumpIndex, mapPtr, numBytes, numWords, opCode, realCond, testTokenPtr, tokenPtr, word, wordIdx, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v3, v4, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	jumpIndex = 0
	realCond = int32(1) /* Value of static condition. */
	compileScripts = int32(1)
	/*
	 * Only compile the "if" command if all arguments are simple words, in
	 * order to insure correct substitution [Bug 219166]
	 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
	wordIdx = 0
	numWords = int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)
	wordIdx = 0
	for {
		if !(wordIdx < numWords) {
			break
		}
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) {
			return int32(TCL_ERROR)
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		goto _1
	_1:
		;
		wordIdx++
	}
	XTclInitJumpFixupArray(tls, bp)
	XTclInitJumpFixupArray(tls, bp+192)
	code = TCL_OK
	/*
	 * Each iteration of this loop compiles one "if expr ?then? body" or
	 * "elseif expr ?then? body" clause.
	 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
	wordIdx = 0
	for wordIdx < numWords {
		/*
		 * Stop looping if the token isn't "if" or "elseif".
		 */
		word = (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart
		numBytes = libc.Uint64FromInt64((*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize)
		if tokenPtr == (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr || numBytes == uint64(6) && libc.Xstrncmp(tls, word, __ccgo_ts+16217, uint64(6)) == 0 {
			tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
			wordIdx++
		} else {
			break
		}
		if wordIdx >= numWords {
			code = int32(TCL_ERROR)
			goto done
		}
		/*
		 * Compile the test expression then emit the conditional jump around
		 * the "then" part.
		 */
		testTokenPtr = tokenPtr
		if realCond != 0 {
			/*
			 * Find out if the condition is a constant.
			 */
			boolObj = XTcl_NewStringObj(tls, (*(*TTcl_Token)(unsafe.Pointer(testTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(testTokenPtr + 1*32))).Fsize)
			(*TTcl_Obj)(unsafe.Pointer(boolObj)).FrefCount++
			code = XTcl_GetBoolFromObj(tls, libc.UintptrFromInt32(0), boolObj, (libc.Int32FromInt32(TCL_NULL_OK)-libc.Int32FromInt32(2))&libc.Int32FromInt64(4), bp+384)
			v3 = boolObj
			v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
			*(*TTcl_Size)(unsafe.Pointer(v3))--
			if !(v2 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(boolObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(boolObj)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(boolObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(boolObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(boolObj)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(boolObj)).Flength = int64(-libc.Int32FromInt32(1))
					if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
						cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v4 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, boolObj)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(boolObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = boolObj
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, boolObj)
				}
			}
			if code == TCL_OK {
				/*
				 * A static condition.
				 */
				realCond = 0
				if !(*(*int32)(unsafe.Pointer(bp + 384)) != 0) {
					compileScripts = 0
				}
			} else {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(wordIdx)*8))
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(wordIdx)*8))
				XTcl_ResetResult(tls, interp)
				XTclCompileExprWords(tls, interp, testTokenPtr, uint64(1), envPtr2)
				if (*(*TJumpFixupArray)(unsafe.Pointer(bp))).Fnext >= (*(*TJumpFixupArray)(unsafe.Pointer(bp))).Fend {
					XTclExpandJumpFixupArray(tls, bp)
				}
				jumpIndex = int32((*(*TJumpFixupArray)(unsafe.Pointer(bp))).Fnext)
				(*(*TJumpFixupArray)(unsafe.Pointer(bp))).Fnext++
				XTclEmitForwardJump(tls, envPtr2, int32(TCL_FALSE_JUMP), (*(*TJumpFixupArray)(unsafe.Pointer(bp))).Ffixup+uintptr(jumpIndex)*16)
			}
			code = TCL_OK
		}
		/*
		 * Skip over the optional "then" before the then clause.
		 */
		tokenPtr = testTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(testTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		wordIdx++
		if wordIdx >= numWords {
			code = int32(TCL_ERROR)
			goto done
		}
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			word = (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart
			numBytes = libc.Uint64FromInt64((*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize)
			if numBytes == uint64(4) && libc.Xstrncmp(tls, word, __ccgo_ts+16212, uint64(4)) == 0 {
				tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
				wordIdx++
				if wordIdx >= numWords {
					code = int32(TCL_ERROR)
					goto done
				}
			}
		}
		/*
		 * Compile the "then" command body.
		 */
		if compileScripts != 0 {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(wordIdx)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(wordIdx)*8))
			XTclCompileCmdWord(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
		}
		if realCond != 0 {
			/*
			 * Jump to the end of the "if" command. Both jumpFalseFixupArray
			 * and jumpEndFixupArray are indexed by "jumpIndex".
			 */
			if (*(*TJumpFixupArray)(unsafe.Pointer(bp + 192))).Fnext >= (*(*TJumpFixupArray)(unsafe.Pointer(bp + 192))).Fend {
				XTclExpandJumpFixupArray(tls, bp+192)
			}
			(*(*TJumpFixupArray)(unsafe.Pointer(bp + 192))).Fnext++
			XTclEmitForwardJump(tls, envPtr2, int32(TCL_UNCONDITIONAL_JUMP), (*(*TJumpFixupArray)(unsafe.Pointer(bp + 192))).Ffixup+uintptr(jumpIndex)*16)
			/*
			 * Fix the target of the jumpFalse after the test. Generate a 4
			 * byte jump if the distance is > 120 bytes. This is conservative,
			 * and ensures that we won't have to replace this jump if we later
			 * also need to replace the proceeding jump to the end of the "if"
			 * with a 4 byte jump.
			 */
			v5 = -int32(1)
			v6 = envPtr2
			if v5 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			if XTclFixupForwardJump(tls, envPtr2, (*(*TJumpFixupArray)(unsafe.Pointer(bp))).Ffixup+uintptr(jumpIndex)*16, int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(libc.Int32FromUint32((*TJumpFixup)(unsafe.Pointer((*(*TJumpFixupArray)(unsafe.Pointer(bp))).Ffixup+uintptr(jumpIndex)*16)).FcodeOffset))), int32(120)) != 0 {
				/*
				 * Adjust the code offset for the proceeding jump to the end
				 * of the "if" command.
				 */
				(*(*TJumpFixup)(unsafe.Pointer((*(*TJumpFixupArray)(unsafe.Pointer(bp + 192))).Ffixup + uintptr(jumpIndex)*16))).FcodeOffset += uint32(3)
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 384)) != 0 {
				/*
				 * We were processing an "if 1 {...}"; stop compiling scripts.
				 */
				compileScripts = 0
			} else {
				/*
				 * We were processing an "if 0 {...}"; reset so that the rest
				 * (elseif, else) is compiled correctly.
				 */
				realCond = int32(1)
				compileScripts = int32(1)
			}
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		wordIdx++
	}
	/*
	 * Check for the optional else clause. Do not compile anything if this was
	 * an "if 1 {...}" case.
	 */
	if wordIdx < numWords && (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		/*
		 * There is an else clause. Skip over the optional "else" word.
		 */
		word = (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart
		numBytes = libc.Uint64FromInt64((*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize)
		if numBytes == uint64(4) && libc.Xstrncmp(tls, word, __ccgo_ts+16224, uint64(4)) == 0 {
			tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
			wordIdx++
			if wordIdx >= numWords {
				code = int32(TCL_ERROR)
				goto done
			}
		}
		if compileScripts != 0 {
			/*
			 * Compile the else command body.
			 */
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(wordIdx)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(wordIdx)*8))
			XTclCompileCmdWord(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
		}
		/*
		 * Make sure there are no words after the else clause.
		 */
		wordIdx++
		if wordIdx < numWords {
			code = int32(TCL_ERROR)
			goto done
		}
	} else {
		/*
		 * No else clause: the "if" command's result is an empty string.
		 */
		if compileScripts != 0 {
			_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
			if _objIndexCopy <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v8 = envPtr2 + 152
				v7 = *(*uintptr)(unsafe.Pointer(v8))
				*(*uintptr)(unsafe.Pointer(v8))++
				*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v10 = envPtr2 + 152
				v9 = *(*uintptr)(unsafe.Pointer(v10))
				*(*uintptr)(unsafe.Pointer(v10))++
				*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v11 = delta1
					v12 = envPtr2
					if v11 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v12)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v12)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v12)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v12)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v12 + 64)) += int64(v11)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v14 = envPtr2 + 152
				v13 = *(*uintptr)(unsafe.Pointer(v14))
				*(*uintptr)(unsafe.Pointer(v14))++
				*(*uint8)(unsafe.Pointer(v13)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v16 = envPtr2 + 152
				v15 = *(*uintptr)(unsafe.Pointer(v16))
				*(*uintptr)(unsafe.Pointer(v16))++
				*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
				v18 = envPtr2 + 152
				v17 = *(*uintptr)(unsafe.Pointer(v18))
				*(*uintptr)(unsafe.Pointer(v18))++
				*(*uint8)(unsafe.Pointer(v17)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
				v20 = envPtr2 + 152
				v19 = *(*uintptr)(unsafe.Pointer(v20))
				*(*uintptr)(unsafe.Pointer(v20))++
				*(*uint8)(unsafe.Pointer(v19)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
				v22 = envPtr2 + 152
				v21 = *(*uintptr)(unsafe.Pointer(v22))
				*(*uintptr)(unsafe.Pointer(v22))++
				*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v23 = delta1
					v24 = envPtr2
					if v23 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v24 + 64)) += int64(v23)
				}
			}
		}
	}
	/*
	 * Fix the unconditional jumps to the end of the "if" command.
	 */
	j = libc.Uint64FromInt64((*(*TJumpFixupArray)(unsafe.Pointer(bp + 192))).Fnext)
	for {
		if !(j > uint64(0)) {
			break
		}
		jumpIndex = libc.Int32FromUint64(j - libc.Uint64FromInt32(1)) /* i.e. process the closest jump first. */
		if XTclFixupForwardJump(tls, envPtr2, (*(*TJumpFixupArray)(unsafe.Pointer(bp + 192))).Ffixup+uintptr(jumpIndex)*16, int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(libc.Int32FromUint32((*TJumpFixup)(unsafe.Pointer((*(*TJumpFixupArray)(unsafe.Pointer(bp + 192))).Ffixup+uintptr(jumpIndex)*16)).FcodeOffset))), int32(127)) != 0 {
			/*
			 * Adjust the immediately preceding "ifFalse" jump. We moved it's
			 * target (just after this jump) down three bytes.
			 */
			ifFalsePc = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr((*(*TJumpFixup)(unsafe.Pointer((*(*TJumpFixupArray)(unsafe.Pointer(bp))).Ffixup + uintptr(jumpIndex)*16))).FcodeOffset)
			opCode = *(*uint8)(unsafe.Pointer(ifFalsePc))
			if libc.Int32FromUint8(opCode) == int32(INST_JUMP_FALSE1) {
				jumpFalseDist = int32(*(*int8)(unsafe.Pointer(ifFalsePc + libc.UintptrFromInt32(1))))
				jumpFalseDist += int32(3)
				*(*uint8)(unsafe.Pointer(ifFalsePc + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(jumpFalseDist))
			} else {
				if libc.Int32FromUint8(opCode) == int32(INST_JUMP_FALSE4) {
					jumpFalseDist = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(ifFalsePc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ifFalsePc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ifFalsePc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(ifFalsePc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
					jumpFalseDist += int32(3)
					*(*uint8)(unsafe.Pointer(ifFalsePc + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(jumpFalseDist) >> libc.Int32FromInt32(24))
					*(*uint8)(unsafe.Pointer(ifFalsePc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(jumpFalseDist) >> libc.Int32FromInt32(16))
					*(*uint8)(unsafe.Pointer(ifFalsePc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt32(jumpFalseDist) >> libc.Int32FromInt32(8))
					*(*uint8)(unsafe.Pointer(ifFalsePc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt32(jumpFalseDist))
				} else {
					XTcl_Panic(tls, __ccgo_ts+21726, libc.VaList(bp+400, libc.Int32FromUint8(opCode)))
				}
			}
		}
		goto _25
	_25:
		;
		j--
	}
	/*
	 * Free the jumpFixupArray array if malloc'ed storage was used.
	 */
	goto done
done:
	;
	XTclFreeJumpFixupArray(tls, bp)
	XTclFreeJumpFixupArray(tls, bp+192)
	return code
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileIncrCmd --
 *
 *	Procedure called to compile the "incr" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "incr" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileIncrCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy474 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds resulting instructions. */
	var _objIndexCopy, code, delta1, haveImmValue, v1, v21, v27, v35, v41, v45, v51, v59, v65, v69, v9 int32
	var cachePtr, incrTokenPtr, intObj, mapPtr, varTokenPtr, word, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v22, v23, v24, v25, v26, v28, v29, v3, v30, v31, v32, v33, v34, v36, v37, v38, v39, v40, v42, v43, v44, v46, v47, v48, v49, v5, v50, v52, v53, v54, v55, v56, v57, v58, v6, v60, v61, v62, v63, v64, v66, v67, v68, v7, v70, v8 uintptr
	var eclIndex, v2 TTcl_Size
	var numBytes Tsize_t
	var v4 bool
	var _ /* immValue at bp+8 */ TTcl_WideInt
	var _ /* isScalar at bp+0 */ int32
	var _ /* localIndex at bp+4 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, cachePtr, code, delta1, eclIndex, haveImmValue, incrTokenPtr, intObj, mapPtr, numBytes, varTokenPtr, word, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) && (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(3) {
		return int32(TCL_ERROR)
	}
	varTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
	XTclPushVarName(tls, interp, varTokenPtr, envPtr2, int32(TCL_NO_LARGE_INDEX), bp+4, bp)
	/*
	 * If an increment is given, push it, but see first if it's a small
	 * integer.
	 */
	haveImmValue = 0
	*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) = int64(1)
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(3) {
		incrTokenPtr = varTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if (*TTcl_Token)(unsafe.Pointer(incrTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			word = (*(*TTcl_Token)(unsafe.Pointer(incrTokenPtr + 1*32))).Fstart
			numBytes = libc.Uint64FromInt64((*(*TTcl_Token)(unsafe.Pointer(incrTokenPtr + 1*32))).Fsize)
			intObj = XTcl_NewStringObj(tls, word, libc.Int64FromUint64(numBytes))
			(*TTcl_Obj)(unsafe.Pointer(intObj)).FrefCount++
			if (*TTcl_Obj)(unsafe.Pointer(intObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
				*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(intObj)).FinternalRep))
				v1 = libc.Int32FromInt32(TCL_OK)
			} else {
				v1 = XTcl_GetWideIntFromObj(tls, libc.UintptrFromInt32(0), intObj, bp+8)
			}
			code = v1
			if code == TCL_OK && int64(-int32(127)) <= *(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) && *(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) <= int64(127) {
				haveImmValue = int32(1)
			}
			v3 = intObj
			v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
			*(*TTcl_Size)(unsafe.Pointer(v3))--
			if !(v2 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(intObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(intObj)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(intObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(intObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(intObj)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(intObj)).Flength = int64(-libc.Int32FromInt32(1))
					if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
						cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v4 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, intObj)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(intObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = intObj
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, intObj)
				}
			}
			if !(haveImmValue != 0) {
				_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, word, libc.Int64FromUint64(numBytes), 0)
				if _objIndexCopy <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v6 = envPtr2 + 152
					v5 = *(*uintptr)(unsafe.Pointer(v6))
					*(*uintptr)(unsafe.Pointer(v6))++
					*(*uint8)(unsafe.Pointer(v5)) = libc.Uint8FromInt32(int32(INST_PUSH1))
					v8 = envPtr2 + 152
					v7 = *(*uintptr)(unsafe.Pointer(v8))
					*(*uintptr)(unsafe.Pointer(v8))++
					*(*uint8)(unsafe.Pointer(v7)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy
						}
						v9 = delta1
						v10 = envPtr2
						if v9 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v10)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v10)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v10)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v10)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v10 + 64)) += int64(v9)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v12 = envPtr2 + 152
					v11 = *(*uintptr)(unsafe.Pointer(v12))
					*(*uintptr)(unsafe.Pointer(v12))++
					*(*uint8)(unsafe.Pointer(v11)) = libc.Uint8FromInt32(int32(INST_PUSH4))
					v14 = envPtr2 + 152
					v13 = *(*uintptr)(unsafe.Pointer(v14))
					*(*uintptr)(unsafe.Pointer(v14))++
					*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
					v16 = envPtr2 + 152
					v15 = *(*uintptr)(unsafe.Pointer(v16))
					*(*uintptr)(unsafe.Pointer(v16))++
					*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
					v18 = envPtr2 + 152
					v17 = *(*uintptr)(unsafe.Pointer(v18))
					*(*uintptr)(unsafe.Pointer(v18))++
					*(*uint8)(unsafe.Pointer(v17)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
					v20 = envPtr2 + 152
					v19 = *(*uintptr)(unsafe.Pointer(v20))
					*(*uintptr)(unsafe.Pointer(v20))++
					*(*uint8)(unsafe.Pointer(v19)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy
						}
						v21 = delta1
						v22 = envPtr2
						if v21 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v22 + 64)) += int64(v21)
					}
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
			XTclCompileTokens(tls, interp, incrTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(incrTokenPtr)).FnumComponents), envPtr2)
		}
	} else { /* No incr amount given so use 1. */
		haveImmValue = int32(1)
	}
	/*
	 * Emit the instruction to increment the variable.
	 */
	if *(*int32)(unsafe.Pointer(bp)) != 0 { /* Simple scalar variable. */
		if *(*int32)(unsafe.Pointer(bp + 4)) >= 0 {
			if haveImmValue != 0 {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v24 = envPtr2 + 152
				v23 = *(*uintptr)(unsafe.Pointer(v24))
				*(*uintptr)(unsafe.Pointer(v24))++
				*(*uint8)(unsafe.Pointer(v23)) = libc.Uint8FromInt32(int32(INST_INCR_SCALAR1_IMM))
				v26 = envPtr2 + 152
				v25 = *(*uintptr)(unsafe.Pointer(v26))
				*(*uintptr)(unsafe.Pointer(v26))++
				*(*uint8)(unsafe.Pointer(v25)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_INCR_SCALAR1_IMM)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
					}
					v27 = delta1
					v28 = envPtr2
					if v27 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v28)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v28)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v28)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v28)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v28 + 64)) += int64(v27)
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v30 = envPtr2 + 152
				v29 = *(*uintptr)(unsafe.Pointer(v30))
				*(*uintptr)(unsafe.Pointer(v30))++
				*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8))))
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v32 = envPtr2 + 152
				v31 = *(*uintptr)(unsafe.Pointer(v32))
				*(*uintptr)(unsafe.Pointer(v32))++
				*(*uint8)(unsafe.Pointer(v31)) = libc.Uint8FromInt32(int32(INST_INCR_SCALAR1))
				v34 = envPtr2 + 152
				v33 = *(*uintptr)(unsafe.Pointer(v34))
				*(*uintptr)(unsafe.Pointer(v34))++
				*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_INCR_SCALAR1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
					}
					v35 = delta1
					v36 = envPtr2
					if v35 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v36 + 64)) += int64(v35)
				}
			}
		} else {
			if haveImmValue != 0 {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v38 = envPtr2 + 152
				v37 = *(*uintptr)(unsafe.Pointer(v38))
				*(*uintptr)(unsafe.Pointer(v38))++
				*(*uint8)(unsafe.Pointer(v37)) = libc.Uint8FromInt32(int32(INST_INCR_STK_IMM))
				v40 = envPtr2 + 152
				v39 = *(*uintptr)(unsafe.Pointer(v40))
				*(*uintptr)(unsafe.Pointer(v40))++
				*(*uint8)(unsafe.Pointer(v39)) = uint8(libc.Uint32FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_INCR_STK_IMM)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - int32(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)))
					}
					v41 = delta1
					v42 = envPtr2
					if v41 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v42)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v42)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v42)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v42)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v42 + 64)) += int64(v41)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v44 = envPtr2 + 152
				v43 = *(*uintptr)(unsafe.Pointer(v44))
				*(*uintptr)(unsafe.Pointer(v44))++
				*(*uint8)(unsafe.Pointer(v43)) = libc.Uint8FromInt32(int32(INST_INCR_STK))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_INCR_STK)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v45 = delta1
					v46 = envPtr2
					if v45 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v46)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v46)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v46)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v46)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v46 + 64)) += int64(v45)
				}
			}
		}
	} else { /* Simple array variable. */
		if *(*int32)(unsafe.Pointer(bp + 4)) >= 0 {
			if haveImmValue != 0 {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v48 = envPtr2 + 152
				v47 = *(*uintptr)(unsafe.Pointer(v48))
				*(*uintptr)(unsafe.Pointer(v48))++
				*(*uint8)(unsafe.Pointer(v47)) = libc.Uint8FromInt32(int32(INST_INCR_ARRAY1_IMM))
				v50 = envPtr2 + 152
				v49 = *(*uintptr)(unsafe.Pointer(v50))
				*(*uintptr)(unsafe.Pointer(v50))++
				*(*uint8)(unsafe.Pointer(v49)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_INCR_ARRAY1_IMM)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
					}
					v51 = delta1
					v52 = envPtr2
					if v51 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v52)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v52)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v52)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v52)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v52 + 64)) += int64(v51)
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v54 = envPtr2 + 152
				v53 = *(*uintptr)(unsafe.Pointer(v54))
				*(*uintptr)(unsafe.Pointer(v54))++
				*(*uint8)(unsafe.Pointer(v53)) = uint8(libc.Uint32FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8))))
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v56 = envPtr2 + 152
				v55 = *(*uintptr)(unsafe.Pointer(v56))
				*(*uintptr)(unsafe.Pointer(v56))++
				*(*uint8)(unsafe.Pointer(v55)) = libc.Uint8FromInt32(int32(INST_INCR_ARRAY1))
				v58 = envPtr2 + 152
				v57 = *(*uintptr)(unsafe.Pointer(v58))
				*(*uintptr)(unsafe.Pointer(v58))++
				*(*uint8)(unsafe.Pointer(v57)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_INCR_ARRAY1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
					}
					v59 = delta1
					v60 = envPtr2
					if v59 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v60)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v60)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v60)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v60)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v60 + 64)) += int64(v59)
				}
			}
		} else {
			if haveImmValue != 0 {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v62 = envPtr2 + 152
				v61 = *(*uintptr)(unsafe.Pointer(v62))
				*(*uintptr)(unsafe.Pointer(v62))++
				*(*uint8)(unsafe.Pointer(v61)) = libc.Uint8FromInt32(int32(INST_INCR_ARRAY_STK_IMM))
				v64 = envPtr2 + 152
				v63 = *(*uintptr)(unsafe.Pointer(v64))
				*(*uintptr)(unsafe.Pointer(v64))++
				*(*uint8)(unsafe.Pointer(v63)) = uint8(libc.Uint32FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_INCR_ARRAY_STK_IMM)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - int32(*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)))
					}
					v65 = delta1
					v66 = envPtr2
					if v65 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v66)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v66)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v66)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v66)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v66 + 64)) += int64(v65)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v68 = envPtr2 + 152
				v67 = *(*uintptr)(unsafe.Pointer(v68))
				*(*uintptr)(unsafe.Pointer(v68))++
				*(*uint8)(unsafe.Pointer(v67)) = libc.Uint8FromInt32(int32(INST_INCR_ARRAY_STK))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_INCR_ARRAY_STK)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v69 = delta1
					v70 = envPtr2
					if v69 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v70 + 64)) += int64(v69)
				}
			}
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileInfo*Cmd --
 *
 *	Procedures called to compile "info" subcommands.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "info" subcommand at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileInfoCommandsCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr2 uintptr) (r int32) {
	var _objIndexCopy, delta1, v21, v25, v29, v33, v39, v51, v9 int32
	var _objPtr, _objPtr1, bytes, cachePtr, mapPtr, objPtr, tokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v22, v23, v24, v26, v27, v28, v30, v31, v32, v34, v35, v36, v37, v38, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v52, v54, v6, v7, v8 uintptr
	var eclIndex, v3, v53 TTcl_Size
	var v1 bool
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objPtr, _objPtr1, bytes, cachePtr, delta1, eclIndex, mapPtr, objPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	/*
	 * We require one compile-time known argument for the case we can compile.
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(1) {
		return XTclCompileBasic0ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
	} else {
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
			return int32(TCL_ERROR)
		}
	}
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount++
	if !(XTclWordKnownAtCompileTime(tls, tokenPtr, objPtr) != 0) {
		goto notCompilable
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		v2 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		v2 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
	}
	bytes = v2
	/*
	 * We require that the argument start with "::" and not have any of "*\[?"
	 * in it. (Theoretically, we should look in only the final component, but
	 * the difference is so slight given current naming practices.)
	 */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes))) != int32(':') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes + 1))) != int32(':') || !(libc.Xstrpbrk(tls, bytes, __ccgo_ts+16411) == libc.UintptrFromInt32(0)) {
		goto notCompilable
	}
	_objPtr = objPtr
	v4 = _objPtr
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	if v3 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	/*
	 * Confirmed as a literal that will not frighten the horses. Compile.
	 * The result must be made into a list.
	 */
	/* TODO: Just push the known value */
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v6 = envPtr2 + 152
			v5 = *(*uintptr)(unsafe.Pointer(v6))
			*(*uintptr)(unsafe.Pointer(v6))++
			*(*uint8)(unsafe.Pointer(v5)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v9 = delta1
				v10 = envPtr2
				if v9 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v10)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v10)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v10)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v10)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v10 + 64)) += int64(v9)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v18 = envPtr2 + 152
			v17 = *(*uintptr)(unsafe.Pointer(v18))
			*(*uintptr)(unsafe.Pointer(v18))++
			*(*uint8)(unsafe.Pointer(v17)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v20 = envPtr2 + 152
			v19 = *(*uintptr)(unsafe.Pointer(v20))
			*(*uintptr)(unsafe.Pointer(v20))++
			*(*uint8)(unsafe.Pointer(v19)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v21 = delta1
				v22 = envPtr2
				if v21 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v22 + 64)) += int64(v21)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v24 = envPtr2 + 152
	v23 = *(*uintptr)(unsafe.Pointer(v24))
	*(*uintptr)(unsafe.Pointer(v24))++
	*(*uint8)(unsafe.Pointer(v23)) = libc.Uint8FromInt32(int32(INST_RESOLVE_COMMAND))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_RESOLVE_COMMAND)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v25 = delta1
		v26 = envPtr2
		if v25 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v26)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v26)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v26)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v26)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v26 + 64)) += int64(v25)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v28 = envPtr2 + 152
	v27 = *(*uintptr)(unsafe.Pointer(v28))
	*(*uintptr)(unsafe.Pointer(v28))++
	*(*uint8)(unsafe.Pointer(v27)) = libc.Uint8FromInt32(int32(INST_DUP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_DUP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v29 = delta1
		v30 = envPtr2
		if v29 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v30)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v30)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v30)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v30)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v30 + 64)) += int64(v29)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v32 = envPtr2 + 152
	v31 = *(*uintptr)(unsafe.Pointer(v32))
	*(*uintptr)(unsafe.Pointer(v32))++
	*(*uint8)(unsafe.Pointer(v31)) = libc.Uint8FromInt32(int32(INST_STR_LEN))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_STR_LEN)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v33 = delta1
		v34 = envPtr2
		if v33 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v34)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v34)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v34)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v34)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v34 + 64)) += int64(v33)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v36 = envPtr2 + 152
	v35 = *(*uintptr)(unsafe.Pointer(v36))
	*(*uintptr)(unsafe.Pointer(v36))++
	*(*uint8)(unsafe.Pointer(v35)) = libc.Uint8FromInt32(int32(INST_JUMP_FALSE1))
	v38 = envPtr2 + 152
	v37 = *(*uintptr)(unsafe.Pointer(v38))
	*(*uintptr)(unsafe.Pointer(v38))++
	*(*uint8)(unsafe.Pointer(v37)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(7)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_JUMP_FALSE1)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32(7)
		}
		v39 = delta1
		v40 = envPtr2
		if v39 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v40 + 64)) += int64(v39)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v42 = envPtr2 + 152
	v41 = *(*uintptr)(unsafe.Pointer(v42))
	*(*uintptr)(unsafe.Pointer(v42))++
	*(*uint8)(unsafe.Pointer(v41)) = libc.Uint8FromInt32(int32(INST_LIST))
	v44 = envPtr2 + 152
	v43 = *(*uintptr)(unsafe.Pointer(v44))
	*(*uintptr)(unsafe.Pointer(v44))++
	*(*uint8)(unsafe.Pointer(v43)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(24))
	v46 = envPtr2 + 152
	v45 = *(*uintptr)(unsafe.Pointer(v46))
	*(*uintptr)(unsafe.Pointer(v46))++
	*(*uint8)(unsafe.Pointer(v45)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(16))
	v48 = envPtr2 + 152
	v47 = *(*uintptr)(unsafe.Pointer(v48))
	*(*uintptr)(unsafe.Pointer(v48))++
	*(*uint8)(unsafe.Pointer(v47)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(8))
	v50 = envPtr2 + 152
	v49 = *(*uintptr)(unsafe.Pointer(v50))
	*(*uintptr)(unsafe.Pointer(v50))++
	*(*uint8)(unsafe.Pointer(v49)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_LIST)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32(1)
		}
		v51 = delta1
		v52 = envPtr2
		if v51 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v52)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v52)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v52)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v52)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v52 + 64)) += int64(v51)
	}
	return TCL_OK
	goto notCompilable
notCompilable:
	;
	_objPtr1 = objPtr
	v54 = _objPtr1
	v53 = *(*TTcl_Size)(unsafe.Pointer(v54))
	*(*TTcl_Size)(unsafe.Pointer(v54))--
	if v53 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	return XTclCompileBasic1ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
}

func XTclCompileInfoCoroutineCmd(tls *libc.TLS, dummy643 uintptr, parsePtr uintptr, dummy646 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var delta1, v3 int32
	var v1, v2, v4 uintptr
	_, _, _, _, _ = delta1, v1, v2, v3, v4
	/*
	 * Only compile [info coroutine] without arguments.
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(1) {
		return int32(TCL_ERROR)
	}
	/*
	 * Not much to do; we compile to a single instruction...
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v2 = envPtr2 + 152
	v1 = *(*uintptr)(unsafe.Pointer(v2))
	*(*uintptr)(unsafe.Pointer(v2))++
	*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_COROUTINE_NAME))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_COROUTINE_NAME)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v3 = delta1
		v4 = envPtr2
		if v3 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v4)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v4)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v4)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v4)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v4 + 64)) += int64(v3)
	}
	return TCL_OK
}

func XTclCompileInfoExistsCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy670 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds resulting instructions. */
	var delta1, v15, v19, v3, v31 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v16, v17, v18, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v32, v4, v5, v6, v7, v8, v9 uintptr
	var _ /* isScalar at bp+0 */ int32
	var _ /* localIndex at bp+4 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = delta1, eclIndex, mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v4, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
		return int32(TCL_ERROR)
	}
	/*
	 * Decide if we can use a frame slot for the var/array name or if we need
	 * to emit code to compute and push the name at runtime. We use a frame
	 * slot (entry in the array of local vars) if we are compiling a procedure
	 * body and if the name is simple text that does not include namespace
	 * qualifiers.
	 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
	XTclPushVarName(tls, interp, tokenPtr, envPtr2, 0, bp+4, bp)
	/*
	 * Emit instruction to check the variable for existence.
	 */
	if *(*int32)(unsafe.Pointer(bp)) != 0 {
		if *(*int32)(unsafe.Pointer(bp + 4)) < 0 {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_EXIST_STK))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_EXIST_STK)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v3 = delta1
				v4 = envPtr2
				if v3 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v4)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v4)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v4)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v4)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v4 + 64)) += int64(v3)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v6 = envPtr2 + 152
			v5 = *(*uintptr)(unsafe.Pointer(v6))
			*(*uintptr)(unsafe.Pointer(v6))++
			*(*uint8)(unsafe.Pointer(v5)) = libc.Uint8FromInt32(int32(INST_EXIST_SCALAR))
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(24))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(16))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(8))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_EXIST_SCALAR)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
				}
				v15 = delta1
				v16 = envPtr2
				if v15 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v16)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v16)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v16)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v16)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v16 + 64)) += int64(v15)
			}
		}
	} else {
		if *(*int32)(unsafe.Pointer(bp + 4)) < 0 {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v18 = envPtr2 + 152
			v17 = *(*uintptr)(unsafe.Pointer(v18))
			*(*uintptr)(unsafe.Pointer(v18))++
			*(*uint8)(unsafe.Pointer(v17)) = libc.Uint8FromInt32(int32(INST_EXIST_ARRAY_STK))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_EXIST_ARRAY_STK)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v19 = delta1
				v20 = envPtr2
				if v19 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v20)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v20)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v20)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v20)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v20 + 64)) += int64(v19)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v22 = envPtr2 + 152
			v21 = *(*uintptr)(unsafe.Pointer(v22))
			*(*uintptr)(unsafe.Pointer(v22))++
			*(*uint8)(unsafe.Pointer(v21)) = libc.Uint8FromInt32(int32(INST_EXIST_ARRAY))
			v24 = envPtr2 + 152
			v23 = *(*uintptr)(unsafe.Pointer(v24))
			*(*uintptr)(unsafe.Pointer(v24))++
			*(*uint8)(unsafe.Pointer(v23)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(24))
			v26 = envPtr2 + 152
			v25 = *(*uintptr)(unsafe.Pointer(v26))
			*(*uintptr)(unsafe.Pointer(v26))++
			*(*uint8)(unsafe.Pointer(v25)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(16))
			v28 = envPtr2 + 152
			v27 = *(*uintptr)(unsafe.Pointer(v28))
			*(*uintptr)(unsafe.Pointer(v28))++
			*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(8))
			v30 = envPtr2 + 152
			v29 = *(*uintptr)(unsafe.Pointer(v30))
			*(*uintptr)(unsafe.Pointer(v30))++
			*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_EXIST_ARRAY)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
				}
				v31 = delta1
				v32 = envPtr2
				if v31 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v32)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v32)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v32)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v32)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v32 + 64)) += int64(v31)
			}
		}
	}
	return TCL_OK
}

func XTclCompileInfoLevelCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy718 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, delta1, v21, v25, v3, v9 int32
	var eclIndex TTcl_Size
	var mapPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v22, v23, v24, v26, v4, v5, v6, v7, v8 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, eclIndex, mapPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v3, v4, v5, v6, v7, v8, v9
	/*
	 * Only compile [info level] without arguments or with a single argument.
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(1) {
		/*
		 * Not much to do; we compile to a single instruction...
		 */
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v2 = envPtr2 + 152
		v1 = *(*uintptr)(unsafe.Pointer(v2))
		*(*uintptr)(unsafe.Pointer(v2))++
		*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_INFO_LEVEL_NUM))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_INFO_LEVEL_NUM)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v3 = delta1
			v4 = envPtr2
			if v3 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v4)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v4)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v4)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v4)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v4 + 64)) += int64(v3)
		}
	} else {
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
			return int32(TCL_ERROR)
		} else {
			mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
			eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1) /* TIP #280 */
			/*
			 * Compile the argument, then add the instruction to convert it into a
			 * list of arguments.
			 */
			if (*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr+uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
				_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32 + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32 + 1*32))).Fsize, 0)
				if _objIndexCopy <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v6 = envPtr2 + 152
					v5 = *(*uintptr)(unsafe.Pointer(v6))
					*(*uintptr)(unsafe.Pointer(v6))++
					*(*uint8)(unsafe.Pointer(v5)) = libc.Uint8FromInt32(int32(INST_PUSH1))
					v8 = envPtr2 + 152
					v7 = *(*uintptr)(unsafe.Pointer(v8))
					*(*uintptr)(unsafe.Pointer(v8))++
					*(*uint8)(unsafe.Pointer(v7)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy
						}
						v9 = delta1
						v10 = envPtr2
						if v9 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v10)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v10)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v10)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v10)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v10 + 64)) += int64(v9)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v12 = envPtr2 + 152
					v11 = *(*uintptr)(unsafe.Pointer(v12))
					*(*uintptr)(unsafe.Pointer(v12))++
					*(*uint8)(unsafe.Pointer(v11)) = libc.Uint8FromInt32(int32(INST_PUSH4))
					v14 = envPtr2 + 152
					v13 = *(*uintptr)(unsafe.Pointer(v14))
					*(*uintptr)(unsafe.Pointer(v14))++
					*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
					v16 = envPtr2 + 152
					v15 = *(*uintptr)(unsafe.Pointer(v16))
					*(*uintptr)(unsafe.Pointer(v16))++
					*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
					v18 = envPtr2 + 152
					v17 = *(*uintptr)(unsafe.Pointer(v18))
					*(*uintptr)(unsafe.Pointer(v18))++
					*(*uint8)(unsafe.Pointer(v17)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
					v20 = envPtr2 + 152
					v19 = *(*uintptr)(unsafe.Pointer(v20))
					*(*uintptr)(unsafe.Pointer(v20))++
					*(*uint8)(unsafe.Pointer(v19)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy
						}
						v21 = delta1
						v22 = envPtr2
						if v21 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v22 + 64)) += int64(v21)
					}
				}
			} else {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
				XTclCompileTokens(tls, interp, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr+uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr+uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32)).FnumComponents), envPtr2)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v24 = envPtr2 + 152
			v23 = *(*uintptr)(unsafe.Pointer(v24))
			*(*uintptr)(unsafe.Pointer(v24))++
			*(*uint8)(unsafe.Pointer(v23)) = libc.Uint8FromInt32(int32(INST_INFO_LEVEL_ARGS))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_INFO_LEVEL_ARGS)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v25 = delta1
				v26 = envPtr2
				if v25 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v26)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v26)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v26)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v26)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v26 + 64)) += int64(v25)
			}
		}
	}
	return TCL_OK
}

func XTclCompileInfoObjectClassCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy752 uintptr, envPtr2 uintptr) (r int32) {
	var _objIndexCopy, delta1, v17, v21, v5 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v22, v3, v4, v6, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, eclIndex, mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v3, v4, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1) /* TIP #280 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v20 = envPtr2 + 152
	v19 = *(*uintptr)(unsafe.Pointer(v20))
	*(*uintptr)(unsafe.Pointer(v20))++
	*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_TCLOO_CLASS))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_TCLOO_CLASS)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v21 = delta1
		v22 = envPtr2
		if v21 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v22 + 64)) += int64(v21)
	}
	return TCL_OK
}

func XTclCompileInfoObjectIsACmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy771 uintptr, envPtr2 uintptr) (r int32) {
	var _objIndexCopy, delta1, v17, v21, v5 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v22, v3, v4, v6, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, eclIndex, mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v3, v4, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1) /* TIP #280 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	/*
	 * We only handle [info object isa object <somevalue>]. The first three
	 * words are compressed to a single token by the ensemble compilation
	 * engine.
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(3) {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) || (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize < int64(1) || libc.Xstrncmp(tls, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, __ccgo_ts+6499, libc.Uint64FromInt64((*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize)) != 0 {
		return int32(TCL_ERROR)
	}
	tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	/*
	 * Issue the code.
	 */
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v20 = envPtr2 + 152
	v19 = *(*uintptr)(unsafe.Pointer(v20))
	*(*uintptr)(unsafe.Pointer(v20))++
	*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_TCLOO_IS_OBJECT))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_TCLOO_IS_OBJECT)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v21 = delta1
		v22 = envPtr2
		if v21 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v22 + 64)) += int64(v21)
	}
	return TCL_OK
}

func XTclCompileInfoObjectNamespaceCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy806 uintptr, envPtr2 uintptr) (r int32) {
	var _objIndexCopy, delta1, v17, v21, v5 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v22, v3, v4, v6, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, eclIndex, mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v3, v4, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1) /* TIP #280 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v20 = envPtr2 + 152
	v19 = *(*uintptr)(unsafe.Pointer(v20))
	*(*uintptr)(unsafe.Pointer(v20))++
	*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_TCLOO_NS))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_TCLOO_NS)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v21 = delta1
		v22 = envPtr2
		if v21 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v22 + 64)) += int64(v21)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileLappendCmd --
 *
 *	Procedure called to compile the "lappend" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "lappend" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileLappendCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy843 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, delta1, i1, numWords, v108, v112, v124, v17, v21, v27, v39, v43, v49, v5, v61, v68, v80, v92, v96 int32
	var eclIndex TTcl_Size
	var mapPtr, valueTokenPtr, varTokenPtr, v1, v10, v100, v101, v102, v103, v104, v105, v106, v107, v109, v11, v110, v111, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v123, v125, v13, v14, v15, v16, v18, v19, v2, v20, v22, v23, v24, v25, v26, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v4, v40, v41, v42, v44, v45, v46, v47, v48, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v62, v64, v65, v66, v67, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v93, v94, v95, v97, v98, v99 uintptr
	var _ /* isScalar at bp+0 */ int32
	var _ /* localIndex at bp+4 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, delta1, eclIndex, i1, mapPtr, numWords, valueTokenPtr, varTokenPtr, v1, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v123, v124, v125, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	/* TODO: Consider support for compiling expanded args. */
	numWords = int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)
	if numWords < int32(3) {
		return int32(TCL_ERROR)
	}
	if numWords != int32(3) || (*TCompileEnv)(unsafe.Pointer(envPtr2)).FprocPtr == libc.UintptrFromInt32(0) {
		goto lappendMultiple
	}
	/*
	 * Decide if we can use a frame slot for the var/array name or if we
	 * need to emit code to compute and push the name at runtime. We use a
	 * frame slot (entry in the array of local vars) if we are compiling a
	 * procedure body and if the name is simple text that does not include
	 * namespace qualifiers.
	 */
	varTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
	XTclPushVarName(tls, interp, varTokenPtr, envPtr2, 0, bp+4, bp)
	/*
	 * If we are doing an assignment, push the new value. In the no values
	 * case, create an empty object.
	 */
	if numWords > int32(2) {
		valueTokenPtr = varTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if (*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(valueTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(valueTokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v2 = envPtr2 + 152
				v1 = *(*uintptr)(unsafe.Pointer(v2))
				*(*uintptr)(unsafe.Pointer(v2))++
				*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v4 = envPtr2 + 152
				v3 = *(*uintptr)(unsafe.Pointer(v4))
				*(*uintptr)(unsafe.Pointer(v4))++
				*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v5 = delta1
					v6 = envPtr2
					if v5 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v8 = envPtr2 + 152
				v7 = *(*uintptr)(unsafe.Pointer(v8))
				*(*uintptr)(unsafe.Pointer(v8))++
				*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v10 = envPtr2 + 152
				v9 = *(*uintptr)(unsafe.Pointer(v10))
				*(*uintptr)(unsafe.Pointer(v10))++
				*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
				v12 = envPtr2 + 152
				v11 = *(*uintptr)(unsafe.Pointer(v12))
				*(*uintptr)(unsafe.Pointer(v12))++
				*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
				v14 = envPtr2 + 152
				v13 = *(*uintptr)(unsafe.Pointer(v14))
				*(*uintptr)(unsafe.Pointer(v14))++
				*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
				v16 = envPtr2 + 152
				v15 = *(*uintptr)(unsafe.Pointer(v16))
				*(*uintptr)(unsafe.Pointer(v16))++
				*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v17 = delta1
					v18 = envPtr2
					if v17 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
			XTclCompileTokens(tls, interp, valueTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).FnumComponents), envPtr2)
		}
	}
	/*
	 * Emit instructions to set/get the variable.
	 */
	/*
	 * The *_STK opcodes should be refactored to make better use of existing
	 * LOAD/STORE instructions.
	 */
	if *(*int32)(unsafe.Pointer(bp)) != 0 {
		if *(*int32)(unsafe.Pointer(bp + 4)) < 0 {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v20 = envPtr2 + 152
			v19 = *(*uintptr)(unsafe.Pointer(v20))
			*(*uintptr)(unsafe.Pointer(v20))++
			*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_LAPPEND_STK))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LAPPEND_STK)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v21 = delta1
				v22 = envPtr2
				if v21 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v22 + 64)) += int64(v21)
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 4)) <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v24 = envPtr2 + 152
				v23 = *(*uintptr)(unsafe.Pointer(v24))
				*(*uintptr)(unsafe.Pointer(v24))++
				*(*uint8)(unsafe.Pointer(v23)) = libc.Uint8FromInt32(int32(INST_LAPPEND_SCALAR1))
				v26 = envPtr2 + 152
				v25 = *(*uintptr)(unsafe.Pointer(v26))
				*(*uintptr)(unsafe.Pointer(v26))++
				*(*uint8)(unsafe.Pointer(v25)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LAPPEND_SCALAR1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
					}
					v27 = delta1
					v28 = envPtr2
					if v27 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v28)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v28)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v28)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v28)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v28 + 64)) += int64(v27)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v30 = envPtr2 + 152
				v29 = *(*uintptr)(unsafe.Pointer(v30))
				*(*uintptr)(unsafe.Pointer(v30))++
				*(*uint8)(unsafe.Pointer(v29)) = libc.Uint8FromInt32(int32(INST_LAPPEND_SCALAR4))
				v32 = envPtr2 + 152
				v31 = *(*uintptr)(unsafe.Pointer(v32))
				*(*uintptr)(unsafe.Pointer(v32))++
				*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(24))
				v34 = envPtr2 + 152
				v33 = *(*uintptr)(unsafe.Pointer(v34))
				*(*uintptr)(unsafe.Pointer(v34))++
				*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(16))
				v36 = envPtr2 + 152
				v35 = *(*uintptr)(unsafe.Pointer(v36))
				*(*uintptr)(unsafe.Pointer(v36))++
				*(*uint8)(unsafe.Pointer(v35)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(8))
				v38 = envPtr2 + 152
				v37 = *(*uintptr)(unsafe.Pointer(v38))
				*(*uintptr)(unsafe.Pointer(v38))++
				*(*uint8)(unsafe.Pointer(v37)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LAPPEND_SCALAR4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
					}
					v39 = delta1
					v40 = envPtr2
					if v39 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v40 + 64)) += int64(v39)
				}
			}
		}
	} else {
		if *(*int32)(unsafe.Pointer(bp + 4)) < 0 {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v42 = envPtr2 + 152
			v41 = *(*uintptr)(unsafe.Pointer(v42))
			*(*uintptr)(unsafe.Pointer(v42))++
			*(*uint8)(unsafe.Pointer(v41)) = libc.Uint8FromInt32(int32(INST_LAPPEND_ARRAY_STK))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LAPPEND_ARRAY_STK)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v43 = delta1
				v44 = envPtr2
				if v43 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v44)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v44)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v44)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v44)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v44 + 64)) += int64(v43)
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 4)) <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v46 = envPtr2 + 152
				v45 = *(*uintptr)(unsafe.Pointer(v46))
				*(*uintptr)(unsafe.Pointer(v46))++
				*(*uint8)(unsafe.Pointer(v45)) = libc.Uint8FromInt32(int32(INST_LAPPEND_ARRAY1))
				v48 = envPtr2 + 152
				v47 = *(*uintptr)(unsafe.Pointer(v48))
				*(*uintptr)(unsafe.Pointer(v48))++
				*(*uint8)(unsafe.Pointer(v47)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LAPPEND_ARRAY1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
					}
					v49 = delta1
					v50 = envPtr2
					if v49 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v50)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v50)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v50)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v50)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v50 + 64)) += int64(v49)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v52 = envPtr2 + 152
				v51 = *(*uintptr)(unsafe.Pointer(v52))
				*(*uintptr)(unsafe.Pointer(v52))++
				*(*uint8)(unsafe.Pointer(v51)) = libc.Uint8FromInt32(int32(INST_LAPPEND_ARRAY4))
				v54 = envPtr2 + 152
				v53 = *(*uintptr)(unsafe.Pointer(v54))
				*(*uintptr)(unsafe.Pointer(v54))++
				*(*uint8)(unsafe.Pointer(v53)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(24))
				v56 = envPtr2 + 152
				v55 = *(*uintptr)(unsafe.Pointer(v56))
				*(*uintptr)(unsafe.Pointer(v56))++
				*(*uint8)(unsafe.Pointer(v55)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(16))
				v58 = envPtr2 + 152
				v57 = *(*uintptr)(unsafe.Pointer(v58))
				*(*uintptr)(unsafe.Pointer(v58))++
				*(*uint8)(unsafe.Pointer(v57)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(8))
				v60 = envPtr2 + 152
				v59 = *(*uintptr)(unsafe.Pointer(v60))
				*(*uintptr)(unsafe.Pointer(v60))++
				*(*uint8)(unsafe.Pointer(v59)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LAPPEND_ARRAY4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
					}
					v61 = delta1
					v62 = envPtr2
					if v61 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v62)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v62)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v62)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v62)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v62 + 64)) += int64(v61)
				}
			}
		}
	}
	return TCL_OK
	goto lappendMultiple
lappendMultiple:
	;
	varTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
	XTclPushVarName(tls, interp, varTokenPtr, envPtr2, 0, bp+4, bp)
	valueTokenPtr = varTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	i1 = int32(2)
	for {
		if !(i1 < numWords) {
			break
		}
		if (*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(valueTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(valueTokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy1 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v65 = envPtr2 + 152
				v64 = *(*uintptr)(unsafe.Pointer(v65))
				*(*uintptr)(unsafe.Pointer(v65))++
				*(*uint8)(unsafe.Pointer(v64)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v67 = envPtr2 + 152
				v66 = *(*uintptr)(unsafe.Pointer(v67))
				*(*uintptr)(unsafe.Pointer(v67))++
				*(*uint8)(unsafe.Pointer(v66)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v68 = delta1
					v69 = envPtr2
					if v68 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v69)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v69)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v69)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v69)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v69 + 64)) += int64(v68)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v71 = envPtr2 + 152
				v70 = *(*uintptr)(unsafe.Pointer(v71))
				*(*uintptr)(unsafe.Pointer(v71))++
				*(*uint8)(unsafe.Pointer(v70)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v73 = envPtr2 + 152
				v72 = *(*uintptr)(unsafe.Pointer(v73))
				*(*uintptr)(unsafe.Pointer(v73))++
				*(*uint8)(unsafe.Pointer(v72)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
				v75 = envPtr2 + 152
				v74 = *(*uintptr)(unsafe.Pointer(v75))
				*(*uintptr)(unsafe.Pointer(v75))++
				*(*uint8)(unsafe.Pointer(v74)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
				v77 = envPtr2 + 152
				v76 = *(*uintptr)(unsafe.Pointer(v77))
				*(*uintptr)(unsafe.Pointer(v77))++
				*(*uint8)(unsafe.Pointer(v76)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
				v79 = envPtr2 + 152
				v78 = *(*uintptr)(unsafe.Pointer(v79))
				*(*uintptr)(unsafe.Pointer(v79))++
				*(*uint8)(unsafe.Pointer(v78)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v80 = delta1
					v81 = envPtr2
					if v80 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v81)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v81)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v81)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v81)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v81 + 64)) += int64(v80)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
			XTclCompileTokens(tls, interp, valueTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).FnumComponents), envPtr2)
		}
		valueTokenPtr = valueTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		goto _63
	_63:
		;
		i1++
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v83 = envPtr2 + 152
	v82 = *(*uintptr)(unsafe.Pointer(v83))
	*(*uintptr)(unsafe.Pointer(v83))++
	*(*uint8)(unsafe.Pointer(v82)) = libc.Uint8FromInt32(int32(INST_LIST))
	v85 = envPtr2 + 152
	v84 = *(*uintptr)(unsafe.Pointer(v85))
	*(*uintptr)(unsafe.Pointer(v85))++
	*(*uint8)(unsafe.Pointer(v84)) = uint8(libc.Uint32FromInt32(numWords-libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
	v87 = envPtr2 + 152
	v86 = *(*uintptr)(unsafe.Pointer(v87))
	*(*uintptr)(unsafe.Pointer(v87))++
	*(*uint8)(unsafe.Pointer(v86)) = uint8(libc.Uint32FromInt32(numWords-libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
	v89 = envPtr2 + 152
	v88 = *(*uintptr)(unsafe.Pointer(v89))
	*(*uintptr)(unsafe.Pointer(v89))++
	*(*uint8)(unsafe.Pointer(v88)) = uint8(libc.Uint32FromInt32(numWords-libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
	v91 = envPtr2 + 152
	v90 = *(*uintptr)(unsafe.Pointer(v91))
	*(*uintptr)(unsafe.Pointer(v91))++
	*(*uint8)(unsafe.Pointer(v90)) = uint8(libc.Uint32FromInt32(numWords - libc.Int32FromInt32(2)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_LIST)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - (numWords - int32(2))
		}
		v92 = delta1
		v93 = envPtr2
		if v92 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v93)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v93)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v93)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v93)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v93 + 64)) += int64(v92)
	}
	if *(*int32)(unsafe.Pointer(bp)) != 0 {
		if *(*int32)(unsafe.Pointer(bp + 4)) < 0 {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v95 = envPtr2 + 152
			v94 = *(*uintptr)(unsafe.Pointer(v95))
			*(*uintptr)(unsafe.Pointer(v95))++
			*(*uint8)(unsafe.Pointer(v94)) = libc.Uint8FromInt32(int32(INST_LAPPEND_LIST_STK))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LAPPEND_LIST_STK)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v96 = delta1
				v97 = envPtr2
				if v96 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v97)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v97)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v97)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v97)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v97 + 64)) += int64(v96)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v99 = envPtr2 + 152
			v98 = *(*uintptr)(unsafe.Pointer(v99))
			*(*uintptr)(unsafe.Pointer(v99))++
			*(*uint8)(unsafe.Pointer(v98)) = libc.Uint8FromInt32(int32(INST_LAPPEND_LIST))
			v101 = envPtr2 + 152
			v100 = *(*uintptr)(unsafe.Pointer(v101))
			*(*uintptr)(unsafe.Pointer(v101))++
			*(*uint8)(unsafe.Pointer(v100)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(24))
			v103 = envPtr2 + 152
			v102 = *(*uintptr)(unsafe.Pointer(v103))
			*(*uintptr)(unsafe.Pointer(v103))++
			*(*uint8)(unsafe.Pointer(v102)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(16))
			v105 = envPtr2 + 152
			v104 = *(*uintptr)(unsafe.Pointer(v105))
			*(*uintptr)(unsafe.Pointer(v105))++
			*(*uint8)(unsafe.Pointer(v104)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(8))
			v107 = envPtr2 + 152
			v106 = *(*uintptr)(unsafe.Pointer(v107))
			*(*uintptr)(unsafe.Pointer(v107))++
			*(*uint8)(unsafe.Pointer(v106)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LAPPEND_LIST)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
				}
				v108 = delta1
				v109 = envPtr2
				if v108 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v109)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v109)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v109)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v109)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v109 + 64)) += int64(v108)
			}
		}
	} else {
		if *(*int32)(unsafe.Pointer(bp + 4)) < 0 {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v111 = envPtr2 + 152
			v110 = *(*uintptr)(unsafe.Pointer(v111))
			*(*uintptr)(unsafe.Pointer(v111))++
			*(*uint8)(unsafe.Pointer(v110)) = libc.Uint8FromInt32(int32(INST_LAPPEND_LIST_ARRAY_STK))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LAPPEND_LIST_ARRAY_STK)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v112 = delta1
				v113 = envPtr2
				if v112 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v113)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v113)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v113)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v113)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v113 + 64)) += int64(v112)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v115 = envPtr2 + 152
			v114 = *(*uintptr)(unsafe.Pointer(v115))
			*(*uintptr)(unsafe.Pointer(v115))++
			*(*uint8)(unsafe.Pointer(v114)) = libc.Uint8FromInt32(int32(INST_LAPPEND_LIST_ARRAY))
			v117 = envPtr2 + 152
			v116 = *(*uintptr)(unsafe.Pointer(v117))
			*(*uintptr)(unsafe.Pointer(v117))++
			*(*uint8)(unsafe.Pointer(v116)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(24))
			v119 = envPtr2 + 152
			v118 = *(*uintptr)(unsafe.Pointer(v119))
			*(*uintptr)(unsafe.Pointer(v119))++
			*(*uint8)(unsafe.Pointer(v118)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(16))
			v121 = envPtr2 + 152
			v120 = *(*uintptr)(unsafe.Pointer(v121))
			*(*uintptr)(unsafe.Pointer(v121))++
			*(*uint8)(unsafe.Pointer(v120)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(8))
			v123 = envPtr2 + 152
			v122 = *(*uintptr)(unsafe.Pointer(v123))
			*(*uintptr)(unsafe.Pointer(v123))++
			*(*uint8)(unsafe.Pointer(v122)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LAPPEND_LIST_ARRAY)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
				}
				v124 = delta1
				v125 = envPtr2
				if v124 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v125)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v125)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v125)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v125)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v125 + 64)) += int64(v124)
			}
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileLassignCmd --
 *
 *	Procedure called to compile the "lassign" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "lassign" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileLassignCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy958 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds resulting instructions. */
	var _objIndexCopy, delta1, idx, numWords, v100, v112, v118, v130, v134, v146, v158, v162, v166, v17, v178, v22, v34, v40, v5, v52, v56, v68, v80, v84, v88 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v113, v114, v115, v116, v117, v119, v12, v120, v121, v122, v123, v124, v125, v126, v127, v128, v129, v13, v131, v132, v133, v135, v136, v137, v138, v139, v14, v140, v141, v142, v143, v144, v145, v147, v148, v149, v15, v150, v151, v152, v153, v154, v155, v156, v157, v159, v16, v160, v161, v163, v164, v165, v167, v168, v169, v170, v171, v172, v173, v174, v175, v176, v177, v179, v18, v180, v181, v182, v183, v184, v185, v186, v187, v2, v20, v21, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v35, v36, v37, v38, v39, v4, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v53, v54, v55, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v81, v82, v83, v85, v86, v87, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99 uintptr
	var _ /* isScalar at bp+0 */ int32
	var _ /* localIndex at bp+4 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, eclIndex, idx, mapPtr, numWords, tokenPtr, v1, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v123, v124, v125, v126, v127, v128, v129, v13, v130, v131, v132, v133, v134, v135, v136, v137, v138, v139, v14, v140, v141, v142, v143, v144, v145, v146, v147, v148, v149, v15, v150, v151, v152, v153, v154, v155, v156, v157, v158, v159, v16, v160, v161, v162, v163, v164, v165, v166, v167, v168, v169, v17, v170, v171, v172, v173, v174, v175, v176, v177, v178, v179, v18, v180, v181, v182, v183, v184, v185, v186, v187, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	numWords = int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)
	/*
	 * Check for command syntax error, but we'll punt that to runtime.
	 */
	if numWords < int32(3) {
		return int32(TCL_ERROR)
	}
	/*
	 * Generate code to push list being taken apart by [lassign].
	 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	/*
	 * Generate code to assign values from the list to variables.
	 */
	idx = 0
	for {
		if !(idx < numWords-int32(2)) {
			break
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		/*
		 * Generate the next variable name.
		 */
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(idx+libc.Int32FromInt32(2))*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(idx+libc.Int32FromInt32(2))*8))
		XTclPushVarName(tls, interp, tokenPtr, envPtr2, 0, bp+4, bp)
		/*
		 * Emit instructions to get the idx'th item out of the list value on
		 * the stack and assign it to the variable.
		 */
		if *(*int32)(unsafe.Pointer(bp)) != 0 {
			if *(*int32)(unsafe.Pointer(bp + 4)) >= 0 {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v21 = envPtr2 + 152
				v20 = *(*uintptr)(unsafe.Pointer(v21))
				*(*uintptr)(unsafe.Pointer(v21))++
				*(*uint8)(unsafe.Pointer(v20)) = libc.Uint8FromInt32(int32(INST_DUP))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_DUP)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v22 = delta1
					v23 = envPtr2
					if v22 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v23)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v23)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v23)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v23)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v23 + 64)) += int64(v22)
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v25 = envPtr2 + 152
				v24 = *(*uintptr)(unsafe.Pointer(v25))
				*(*uintptr)(unsafe.Pointer(v25))++
				*(*uint8)(unsafe.Pointer(v24)) = libc.Uint8FromInt32(int32(INST_LIST_INDEX_IMM))
				v27 = envPtr2 + 152
				v26 = *(*uintptr)(unsafe.Pointer(v27))
				*(*uintptr)(unsafe.Pointer(v27))++
				*(*uint8)(unsafe.Pointer(v26)) = uint8(libc.Uint32FromInt32(idx) >> libc.Int32FromInt32(24))
				v29 = envPtr2 + 152
				v28 = *(*uintptr)(unsafe.Pointer(v29))
				*(*uintptr)(unsafe.Pointer(v29))++
				*(*uint8)(unsafe.Pointer(v28)) = uint8(libc.Uint32FromInt32(idx) >> libc.Int32FromInt32(16))
				v31 = envPtr2 + 152
				v30 = *(*uintptr)(unsafe.Pointer(v31))
				*(*uintptr)(unsafe.Pointer(v31))++
				*(*uint8)(unsafe.Pointer(v30)) = uint8(libc.Uint32FromInt32(idx) >> libc.Int32FromInt32(8))
				v33 = envPtr2 + 152
				v32 = *(*uintptr)(unsafe.Pointer(v33))
				*(*uintptr)(unsafe.Pointer(v33))++
				*(*uint8)(unsafe.Pointer(v32)) = uint8(libc.Uint32FromInt32(idx))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LIST_INDEX_IMM)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - idx
					}
					v34 = delta1
					v35 = envPtr2
					if v34 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v35)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v35)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v35)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v35)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v35 + 64)) += int64(v34)
				}
				if *(*int32)(unsafe.Pointer(bp + 4)) <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v37 = envPtr2 + 152
					v36 = *(*uintptr)(unsafe.Pointer(v37))
					*(*uintptr)(unsafe.Pointer(v37))++
					*(*uint8)(unsafe.Pointer(v36)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
					v39 = envPtr2 + 152
					v38 = *(*uintptr)(unsafe.Pointer(v39))
					*(*uintptr)(unsafe.Pointer(v39))++
					*(*uint8)(unsafe.Pointer(v38)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
						}
						v40 = delta1
						v41 = envPtr2
						if v40 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v41)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v41)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v41)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v41)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v41 + 64)) += int64(v40)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v43 = envPtr2 + 152
					v42 = *(*uintptr)(unsafe.Pointer(v43))
					*(*uintptr)(unsafe.Pointer(v43))++
					*(*uint8)(unsafe.Pointer(v42)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
					v45 = envPtr2 + 152
					v44 = *(*uintptr)(unsafe.Pointer(v45))
					*(*uintptr)(unsafe.Pointer(v45))++
					*(*uint8)(unsafe.Pointer(v44)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(24))
					v47 = envPtr2 + 152
					v46 = *(*uintptr)(unsafe.Pointer(v47))
					*(*uintptr)(unsafe.Pointer(v47))++
					*(*uint8)(unsafe.Pointer(v46)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(16))
					v49 = envPtr2 + 152
					v48 = *(*uintptr)(unsafe.Pointer(v49))
					*(*uintptr)(unsafe.Pointer(v49))++
					*(*uint8)(unsafe.Pointer(v48)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(8))
					v51 = envPtr2 + 152
					v50 = *(*uintptr)(unsafe.Pointer(v51))
					*(*uintptr)(unsafe.Pointer(v51))++
					*(*uint8)(unsafe.Pointer(v50)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
						}
						v52 = delta1
						v53 = envPtr2
						if v52 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v53)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v53)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v53)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v53)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v53 + 64)) += int64(v52)
					}
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v55 = envPtr2 + 152
				v54 = *(*uintptr)(unsafe.Pointer(v55))
				*(*uintptr)(unsafe.Pointer(v55))++
				*(*uint8)(unsafe.Pointer(v54)) = libc.Uint8FromInt32(int32(INST_POP))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v56 = delta1
					v57 = envPtr2
					if v56 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v57)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v57)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v57)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v57)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v57 + 64)) += int64(v56)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v59 = envPtr2 + 152
				v58 = *(*uintptr)(unsafe.Pointer(v59))
				*(*uintptr)(unsafe.Pointer(v59))++
				*(*uint8)(unsafe.Pointer(v58)) = libc.Uint8FromInt32(int32(INST_OVER))
				v61 = envPtr2 + 152
				v60 = *(*uintptr)(unsafe.Pointer(v61))
				*(*uintptr)(unsafe.Pointer(v61))++
				*(*uint8)(unsafe.Pointer(v60)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(24))
				v63 = envPtr2 + 152
				v62 = *(*uintptr)(unsafe.Pointer(v63))
				*(*uintptr)(unsafe.Pointer(v63))++
				*(*uint8)(unsafe.Pointer(v62)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(16))
				v65 = envPtr2 + 152
				v64 = *(*uintptr)(unsafe.Pointer(v65))
				*(*uintptr)(unsafe.Pointer(v65))++
				*(*uint8)(unsafe.Pointer(v64)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(8))
				v67 = envPtr2 + 152
				v66 = *(*uintptr)(unsafe.Pointer(v67))
				*(*uintptr)(unsafe.Pointer(v67))++
				*(*uint8)(unsafe.Pointer(v66)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_OVER)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - int32(1)
					}
					v68 = delta1
					v69 = envPtr2
					if v68 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v69)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v69)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v69)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v69)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v69 + 64)) += int64(v68)
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v71 = envPtr2 + 152
				v70 = *(*uintptr)(unsafe.Pointer(v71))
				*(*uintptr)(unsafe.Pointer(v71))++
				*(*uint8)(unsafe.Pointer(v70)) = libc.Uint8FromInt32(int32(INST_LIST_INDEX_IMM))
				v73 = envPtr2 + 152
				v72 = *(*uintptr)(unsafe.Pointer(v73))
				*(*uintptr)(unsafe.Pointer(v73))++
				*(*uint8)(unsafe.Pointer(v72)) = uint8(libc.Uint32FromInt32(idx) >> libc.Int32FromInt32(24))
				v75 = envPtr2 + 152
				v74 = *(*uintptr)(unsafe.Pointer(v75))
				*(*uintptr)(unsafe.Pointer(v75))++
				*(*uint8)(unsafe.Pointer(v74)) = uint8(libc.Uint32FromInt32(idx) >> libc.Int32FromInt32(16))
				v77 = envPtr2 + 152
				v76 = *(*uintptr)(unsafe.Pointer(v77))
				*(*uintptr)(unsafe.Pointer(v77))++
				*(*uint8)(unsafe.Pointer(v76)) = uint8(libc.Uint32FromInt32(idx) >> libc.Int32FromInt32(8))
				v79 = envPtr2 + 152
				v78 = *(*uintptr)(unsafe.Pointer(v79))
				*(*uintptr)(unsafe.Pointer(v79))++
				*(*uint8)(unsafe.Pointer(v78)) = uint8(libc.Uint32FromInt32(idx))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LIST_INDEX_IMM)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - idx
					}
					v80 = delta1
					v81 = envPtr2
					if v80 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v81)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v81)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v81)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v81)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v81 + 64)) += int64(v80)
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v83 = envPtr2 + 152
				v82 = *(*uintptr)(unsafe.Pointer(v83))
				*(*uintptr)(unsafe.Pointer(v83))++
				*(*uint8)(unsafe.Pointer(v82)) = libc.Uint8FromInt32(int32(INST_STORE_STK))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_STORE_STK)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v84 = delta1
					v85 = envPtr2
					if v84 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v85)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v85)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v85)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v85)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v85 + 64)) += int64(v84)
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v87 = envPtr2 + 152
				v86 = *(*uintptr)(unsafe.Pointer(v87))
				*(*uintptr)(unsafe.Pointer(v87))++
				*(*uint8)(unsafe.Pointer(v86)) = libc.Uint8FromInt32(int32(INST_POP))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v88 = delta1
					v89 = envPtr2
					if v88 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v89)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v89)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v89)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v89)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v89 + 64)) += int64(v88)
				}
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 4)) >= 0 {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v91 = envPtr2 + 152
				v90 = *(*uintptr)(unsafe.Pointer(v91))
				*(*uintptr)(unsafe.Pointer(v91))++
				*(*uint8)(unsafe.Pointer(v90)) = libc.Uint8FromInt32(int32(INST_OVER))
				v93 = envPtr2 + 152
				v92 = *(*uintptr)(unsafe.Pointer(v93))
				*(*uintptr)(unsafe.Pointer(v93))++
				*(*uint8)(unsafe.Pointer(v92)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(24))
				v95 = envPtr2 + 152
				v94 = *(*uintptr)(unsafe.Pointer(v95))
				*(*uintptr)(unsafe.Pointer(v95))++
				*(*uint8)(unsafe.Pointer(v94)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(16))
				v97 = envPtr2 + 152
				v96 = *(*uintptr)(unsafe.Pointer(v97))
				*(*uintptr)(unsafe.Pointer(v97))++
				*(*uint8)(unsafe.Pointer(v96)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(8))
				v99 = envPtr2 + 152
				v98 = *(*uintptr)(unsafe.Pointer(v99))
				*(*uintptr)(unsafe.Pointer(v99))++
				*(*uint8)(unsafe.Pointer(v98)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_OVER)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - int32(1)
					}
					v100 = delta1
					v101 = envPtr2
					if v100 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v101)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v101)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v101)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v101)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v101 + 64)) += int64(v100)
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v103 = envPtr2 + 152
				v102 = *(*uintptr)(unsafe.Pointer(v103))
				*(*uintptr)(unsafe.Pointer(v103))++
				*(*uint8)(unsafe.Pointer(v102)) = libc.Uint8FromInt32(int32(INST_LIST_INDEX_IMM))
				v105 = envPtr2 + 152
				v104 = *(*uintptr)(unsafe.Pointer(v105))
				*(*uintptr)(unsafe.Pointer(v105))++
				*(*uint8)(unsafe.Pointer(v104)) = uint8(libc.Uint32FromInt32(idx) >> libc.Int32FromInt32(24))
				v107 = envPtr2 + 152
				v106 = *(*uintptr)(unsafe.Pointer(v107))
				*(*uintptr)(unsafe.Pointer(v107))++
				*(*uint8)(unsafe.Pointer(v106)) = uint8(libc.Uint32FromInt32(idx) >> libc.Int32FromInt32(16))
				v109 = envPtr2 + 152
				v108 = *(*uintptr)(unsafe.Pointer(v109))
				*(*uintptr)(unsafe.Pointer(v109))++
				*(*uint8)(unsafe.Pointer(v108)) = uint8(libc.Uint32FromInt32(idx) >> libc.Int32FromInt32(8))
				v111 = envPtr2 + 152
				v110 = *(*uintptr)(unsafe.Pointer(v111))
				*(*uintptr)(unsafe.Pointer(v111))++
				*(*uint8)(unsafe.Pointer(v110)) = uint8(libc.Uint32FromInt32(idx))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LIST_INDEX_IMM)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - idx
					}
					v112 = delta1
					v113 = envPtr2
					if v112 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v113)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v113)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v113)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v113)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v113 + 64)) += int64(v112)
				}
				if *(*int32)(unsafe.Pointer(bp + 4)) <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v115 = envPtr2 + 152
					v114 = *(*uintptr)(unsafe.Pointer(v115))
					*(*uintptr)(unsafe.Pointer(v115))++
					*(*uint8)(unsafe.Pointer(v114)) = libc.Uint8FromInt32(int32(INST_STORE_ARRAY1))
					v117 = envPtr2 + 152
					v116 = *(*uintptr)(unsafe.Pointer(v117))
					*(*uintptr)(unsafe.Pointer(v117))++
					*(*uint8)(unsafe.Pointer(v116)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_STORE_ARRAY1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
						}
						v118 = delta1
						v119 = envPtr2
						if v118 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v119)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v119)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v119)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v119)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v119 + 64)) += int64(v118)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v121 = envPtr2 + 152
					v120 = *(*uintptr)(unsafe.Pointer(v121))
					*(*uintptr)(unsafe.Pointer(v121))++
					*(*uint8)(unsafe.Pointer(v120)) = libc.Uint8FromInt32(int32(INST_STORE_ARRAY4))
					v123 = envPtr2 + 152
					v122 = *(*uintptr)(unsafe.Pointer(v123))
					*(*uintptr)(unsafe.Pointer(v123))++
					*(*uint8)(unsafe.Pointer(v122)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(24))
					v125 = envPtr2 + 152
					v124 = *(*uintptr)(unsafe.Pointer(v125))
					*(*uintptr)(unsafe.Pointer(v125))++
					*(*uint8)(unsafe.Pointer(v124)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(16))
					v127 = envPtr2 + 152
					v126 = *(*uintptr)(unsafe.Pointer(v127))
					*(*uintptr)(unsafe.Pointer(v127))++
					*(*uint8)(unsafe.Pointer(v126)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(8))
					v129 = envPtr2 + 152
					v128 = *(*uintptr)(unsafe.Pointer(v129))
					*(*uintptr)(unsafe.Pointer(v129))++
					*(*uint8)(unsafe.Pointer(v128)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_STORE_ARRAY4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
						}
						v130 = delta1
						v131 = envPtr2
						if v130 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v131)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v131)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v131)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v131)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v131 + 64)) += int64(v130)
					}
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v133 = envPtr2 + 152
				v132 = *(*uintptr)(unsafe.Pointer(v133))
				*(*uintptr)(unsafe.Pointer(v133))++
				*(*uint8)(unsafe.Pointer(v132)) = libc.Uint8FromInt32(int32(INST_POP))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v134 = delta1
					v135 = envPtr2
					if v134 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v135)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v135)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v135)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v135)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v135 + 64)) += int64(v134)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v137 = envPtr2 + 152
				v136 = *(*uintptr)(unsafe.Pointer(v137))
				*(*uintptr)(unsafe.Pointer(v137))++
				*(*uint8)(unsafe.Pointer(v136)) = libc.Uint8FromInt32(int32(INST_OVER))
				v139 = envPtr2 + 152
				v138 = *(*uintptr)(unsafe.Pointer(v139))
				*(*uintptr)(unsafe.Pointer(v139))++
				*(*uint8)(unsafe.Pointer(v138)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
				v141 = envPtr2 + 152
				v140 = *(*uintptr)(unsafe.Pointer(v141))
				*(*uintptr)(unsafe.Pointer(v141))++
				*(*uint8)(unsafe.Pointer(v140)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
				v143 = envPtr2 + 152
				v142 = *(*uintptr)(unsafe.Pointer(v143))
				*(*uintptr)(unsafe.Pointer(v143))++
				*(*uint8)(unsafe.Pointer(v142)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
				v145 = envPtr2 + 152
				v144 = *(*uintptr)(unsafe.Pointer(v145))
				*(*uintptr)(unsafe.Pointer(v145))++
				*(*uint8)(unsafe.Pointer(v144)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_OVER)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - int32(2)
					}
					v146 = delta1
					v147 = envPtr2
					if v146 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v147)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v147)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v147)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v147)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v147 + 64)) += int64(v146)
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v149 = envPtr2 + 152
				v148 = *(*uintptr)(unsafe.Pointer(v149))
				*(*uintptr)(unsafe.Pointer(v149))++
				*(*uint8)(unsafe.Pointer(v148)) = libc.Uint8FromInt32(int32(INST_LIST_INDEX_IMM))
				v151 = envPtr2 + 152
				v150 = *(*uintptr)(unsafe.Pointer(v151))
				*(*uintptr)(unsafe.Pointer(v151))++
				*(*uint8)(unsafe.Pointer(v150)) = uint8(libc.Uint32FromInt32(idx) >> libc.Int32FromInt32(24))
				v153 = envPtr2 + 152
				v152 = *(*uintptr)(unsafe.Pointer(v153))
				*(*uintptr)(unsafe.Pointer(v153))++
				*(*uint8)(unsafe.Pointer(v152)) = uint8(libc.Uint32FromInt32(idx) >> libc.Int32FromInt32(16))
				v155 = envPtr2 + 152
				v154 = *(*uintptr)(unsafe.Pointer(v155))
				*(*uintptr)(unsafe.Pointer(v155))++
				*(*uint8)(unsafe.Pointer(v154)) = uint8(libc.Uint32FromInt32(idx) >> libc.Int32FromInt32(8))
				v157 = envPtr2 + 152
				v156 = *(*uintptr)(unsafe.Pointer(v157))
				*(*uintptr)(unsafe.Pointer(v157))++
				*(*uint8)(unsafe.Pointer(v156)) = uint8(libc.Uint32FromInt32(idx))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LIST_INDEX_IMM)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - idx
					}
					v158 = delta1
					v159 = envPtr2
					if v158 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v159)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v159)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v159)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v159)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v159 + 64)) += int64(v158)
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v161 = envPtr2 + 152
				v160 = *(*uintptr)(unsafe.Pointer(v161))
				*(*uintptr)(unsafe.Pointer(v161))++
				*(*uint8)(unsafe.Pointer(v160)) = libc.Uint8FromInt32(int32(INST_STORE_ARRAY_STK))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_STORE_ARRAY_STK)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v162 = delta1
					v163 = envPtr2
					if v162 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v163)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v163)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v163)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v163)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v163 + 64)) += int64(v162)
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v165 = envPtr2 + 152
				v164 = *(*uintptr)(unsafe.Pointer(v165))
				*(*uintptr)(unsafe.Pointer(v165))++
				*(*uint8)(unsafe.Pointer(v164)) = libc.Uint8FromInt32(int32(INST_POP))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v166 = delta1
					v167 = envPtr2
					if v166 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v167)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v167)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v167)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v167)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v167 + 64)) += int64(v166)
				}
			}
		}
		goto _19
	_19:
		;
		idx++
	}
	/*
	 * Generate code to leave the rest of the list on the stack.
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v169 = envPtr2 + 152
	v168 = *(*uintptr)(unsafe.Pointer(v169))
	*(*uintptr)(unsafe.Pointer(v169))++
	*(*uint8)(unsafe.Pointer(v168)) = libc.Uint8FromInt32(int32(INST_LIST_RANGE_IMM))
	v171 = envPtr2 + 152
	v170 = *(*uintptr)(unsafe.Pointer(v171))
	*(*uintptr)(unsafe.Pointer(v171))++
	*(*uint8)(unsafe.Pointer(v170)) = uint8(libc.Uint32FromInt32(idx) >> libc.Int32FromInt32(24))
	v173 = envPtr2 + 152
	v172 = *(*uintptr)(unsafe.Pointer(v173))
	*(*uintptr)(unsafe.Pointer(v173))++
	*(*uint8)(unsafe.Pointer(v172)) = uint8(libc.Uint32FromInt32(idx) >> libc.Int32FromInt32(16))
	v175 = envPtr2 + 152
	v174 = *(*uintptr)(unsafe.Pointer(v175))
	*(*uintptr)(unsafe.Pointer(v175))++
	*(*uint8)(unsafe.Pointer(v174)) = uint8(libc.Uint32FromInt32(idx) >> libc.Int32FromInt32(8))
	v177 = envPtr2 + 152
	v176 = *(*uintptr)(unsafe.Pointer(v177))
	*(*uintptr)(unsafe.Pointer(v177))++
	*(*uint8)(unsafe.Pointer(v176)) = uint8(libc.Uint32FromInt32(idx))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_LIST_RANGE_IMM)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - idx
		}
		v178 = delta1
		v179 = envPtr2
		if v178 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v179)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v179)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v179)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v179)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v179 + 64)) += int64(v178)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v181 = envPtr2 + 152
	v180 = *(*uintptr)(unsafe.Pointer(v181))
	*(*uintptr)(unsafe.Pointer(v181))++
	*(*uint8)(unsafe.Pointer(v180)) = uint8(libc.Uint32FromInt32(int32(int64(-libc.Int32FromInt32(2)))) >> libc.Int32FromInt32(24))
	v183 = envPtr2 + 152
	v182 = *(*uintptr)(unsafe.Pointer(v183))
	*(*uintptr)(unsafe.Pointer(v183))++
	*(*uint8)(unsafe.Pointer(v182)) = uint8(libc.Uint32FromInt32(int32(int64(-libc.Int32FromInt32(2)))) >> libc.Int32FromInt32(16))
	v185 = envPtr2 + 152
	v184 = *(*uintptr)(unsafe.Pointer(v185))
	*(*uintptr)(unsafe.Pointer(v185))++
	*(*uint8)(unsafe.Pointer(v184)) = uint8(libc.Uint32FromInt32(int32(int64(-libc.Int32FromInt32(2)))) >> libc.Int32FromInt32(8))
	v187 = envPtr2 + 152
	v186 = *(*uintptr)(unsafe.Pointer(v187))
	*(*uintptr)(unsafe.Pointer(v187))++
	*(*uint8)(unsafe.Pointer(v186)) = uint8(libc.Uint32FromInt32(int32(int64(-libc.Int32FromInt32(2)))))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileLindexCmd --
 *
 *	Procedure called to compile the "lindex" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "lindex" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileLindexCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy1061 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, delta1, i1, numWords, v17, v29, v36, v48, v5, v52, v64 int32
	var eclIndex TTcl_Size
	var idxTokenPtr, mapPtr, valTokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v3, v30, v32, v33, v34, v35, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v49, v50, v51, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v65, v7, v8, v9 uintptr
	var _ /* idx at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, delta1, eclIndex, i1, idxTokenPtr, mapPtr, numWords, valTokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	numWords = int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)
	/*
	 * Quit if not enough args.
	 */
	/* TODO: Consider support for compiling expanded args. */
	if numWords <= int32(1) {
		return int32(TCL_ERROR)
	}
	valTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if numWords != int32(3) {
		goto emitComplexLindex
	}
	idxTokenPtr = valTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(valTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if XTclGetIndexFromToken(tls, idxTokenPtr, libc.Uint64FromInt64(int64(-libc.Int32FromInt32(1))), libc.Uint64FromInt64(int64(-libc.Int32FromInt32(1))), bp) == TCL_OK {
		/*
		 * The idxTokenPtr parsed as a valid index value and was
		 * encoded as expected by INST_LIST_INDEX_IMM.
		 *
		 * NOTE: that we rely on indexing before a list producing the
		 * same result as indexing after a list.
		 */
		if (*TTcl_Token)(unsafe.Pointer(valTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(valTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(valTokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v2 = envPtr2 + 152
				v1 = *(*uintptr)(unsafe.Pointer(v2))
				*(*uintptr)(unsafe.Pointer(v2))++
				*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v4 = envPtr2 + 152
				v3 = *(*uintptr)(unsafe.Pointer(v4))
				*(*uintptr)(unsafe.Pointer(v4))++
				*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v5 = delta1
					v6 = envPtr2
					if v5 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v8 = envPtr2 + 152
				v7 = *(*uintptr)(unsafe.Pointer(v8))
				*(*uintptr)(unsafe.Pointer(v8))++
				*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v10 = envPtr2 + 152
				v9 = *(*uintptr)(unsafe.Pointer(v10))
				*(*uintptr)(unsafe.Pointer(v10))++
				*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
				v12 = envPtr2 + 152
				v11 = *(*uintptr)(unsafe.Pointer(v12))
				*(*uintptr)(unsafe.Pointer(v12))++
				*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
				v14 = envPtr2 + 152
				v13 = *(*uintptr)(unsafe.Pointer(v14))
				*(*uintptr)(unsafe.Pointer(v14))++
				*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
				v16 = envPtr2 + 152
				v15 = *(*uintptr)(unsafe.Pointer(v16))
				*(*uintptr)(unsafe.Pointer(v16))++
				*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v17 = delta1
					v18 = envPtr2
					if v17 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
			XTclCompileTokens(tls, interp, valTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(valTokenPtr)).FnumComponents), envPtr2)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v20 = envPtr2 + 152
		v19 = *(*uintptr)(unsafe.Pointer(v20))
		*(*uintptr)(unsafe.Pointer(v20))++
		*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_LIST_INDEX_IMM))
		v22 = envPtr2 + 152
		v21 = *(*uintptr)(unsafe.Pointer(v22))
		*(*uintptr)(unsafe.Pointer(v22))++
		*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))) >> libc.Int32FromInt32(24))
		v24 = envPtr2 + 152
		v23 = *(*uintptr)(unsafe.Pointer(v24))
		*(*uintptr)(unsafe.Pointer(v24))++
		*(*uint8)(unsafe.Pointer(v23)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))) >> libc.Int32FromInt32(16))
		v26 = envPtr2 + 152
		v25 = *(*uintptr)(unsafe.Pointer(v26))
		*(*uintptr)(unsafe.Pointer(v26))++
		*(*uint8)(unsafe.Pointer(v25)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))) >> libc.Int32FromInt32(8))
		v28 = envPtr2 + 152
		v27 = *(*uintptr)(unsafe.Pointer(v28))
		*(*uintptr)(unsafe.Pointer(v28))++
		*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LIST_INDEX_IMM)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp))
			}
			v29 = delta1
			v30 = envPtr2
			if v29 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v30)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v30)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v30)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v30)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v30 + 64)) += int64(v29)
		}
		return TCL_OK
	}
	/*
	 * If the value was not known at compile time, the conversion failed or
	 * the value was negative, we just keep on going with the more complex
	 * compilation.
	 */
	/*
	 * Push the operands onto the stack.
	 */
	goto emitComplexLindex
emitComplexLindex:
	;
	i1 = int32(1)
	for {
		if !(i1 < numWords) {
			break
		}
		if (*TTcl_Token)(unsafe.Pointer(valTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(valTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(valTokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy1 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v33 = envPtr2 + 152
				v32 = *(*uintptr)(unsafe.Pointer(v33))
				*(*uintptr)(unsafe.Pointer(v33))++
				*(*uint8)(unsafe.Pointer(v32)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v35 = envPtr2 + 152
				v34 = *(*uintptr)(unsafe.Pointer(v35))
				*(*uintptr)(unsafe.Pointer(v35))++
				*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v36 = delta1
					v37 = envPtr2
					if v36 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v37 + 64)) += int64(v36)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v39 = envPtr2 + 152
				v38 = *(*uintptr)(unsafe.Pointer(v39))
				*(*uintptr)(unsafe.Pointer(v39))++
				*(*uint8)(unsafe.Pointer(v38)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v41 = envPtr2 + 152
				v40 = *(*uintptr)(unsafe.Pointer(v41))
				*(*uintptr)(unsafe.Pointer(v41))++
				*(*uint8)(unsafe.Pointer(v40)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
				v43 = envPtr2 + 152
				v42 = *(*uintptr)(unsafe.Pointer(v43))
				*(*uintptr)(unsafe.Pointer(v43))++
				*(*uint8)(unsafe.Pointer(v42)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
				v45 = envPtr2 + 152
				v44 = *(*uintptr)(unsafe.Pointer(v45))
				*(*uintptr)(unsafe.Pointer(v45))++
				*(*uint8)(unsafe.Pointer(v44)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
				v47 = envPtr2 + 152
				v46 = *(*uintptr)(unsafe.Pointer(v47))
				*(*uintptr)(unsafe.Pointer(v47))++
				*(*uint8)(unsafe.Pointer(v46)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v48 = delta1
					v49 = envPtr2
					if v48 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v49)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v49)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v49)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v49)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v49 + 64)) += int64(v48)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
			XTclCompileTokens(tls, interp, valTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(valTokenPtr)).FnumComponents), envPtr2)
		}
		valTokenPtr = valTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(valTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		goto _31
	_31:
		;
		i1++
	}
	/*
	 * Emit INST_LIST_INDEX if objc==3, or INST_LIST_INDEX_MULTI if there are
	 * multiple index args.
	 */
	if numWords == int32(3) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v51 = envPtr2 + 152
		v50 = *(*uintptr)(unsafe.Pointer(v51))
		*(*uintptr)(unsafe.Pointer(v51))++
		*(*uint8)(unsafe.Pointer(v50)) = libc.Uint8FromInt32(int32(INST_LIST_INDEX))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LIST_INDEX)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v52 = delta1
			v53 = envPtr2
			if v52 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v53)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v53)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v53)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v53)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v53 + 64)) += int64(v52)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v55 = envPtr2 + 152
		v54 = *(*uintptr)(unsafe.Pointer(v55))
		*(*uintptr)(unsafe.Pointer(v55))++
		*(*uint8)(unsafe.Pointer(v54)) = libc.Uint8FromInt32(int32(INST_LIST_INDEX_MULTI))
		v57 = envPtr2 + 152
		v56 = *(*uintptr)(unsafe.Pointer(v57))
		*(*uintptr)(unsafe.Pointer(v57))++
		*(*uint8)(unsafe.Pointer(v56)) = uint8(libc.Uint32FromInt32(numWords-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(24))
		v59 = envPtr2 + 152
		v58 = *(*uintptr)(unsafe.Pointer(v59))
		*(*uintptr)(unsafe.Pointer(v59))++
		*(*uint8)(unsafe.Pointer(v58)) = uint8(libc.Uint32FromInt32(numWords-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(16))
		v61 = envPtr2 + 152
		v60 = *(*uintptr)(unsafe.Pointer(v61))
		*(*uintptr)(unsafe.Pointer(v61))++
		*(*uint8)(unsafe.Pointer(v60)) = uint8(libc.Uint32FromInt32(numWords-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(8))
		v63 = envPtr2 + 152
		v62 = *(*uintptr)(unsafe.Pointer(v63))
		*(*uintptr)(unsafe.Pointer(v63))++
		*(*uint8)(unsafe.Pointer(v62)) = uint8(libc.Uint32FromInt32(numWords - libc.Int32FromInt32(1)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LIST_INDEX_MULTI)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - (numWords - int32(1))
			}
			v64 = delta1
			v65 = envPtr2
			if v64 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v65)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v65)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v65)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v65)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v65 + 64)) += int64(v64)
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileListCmd --
 *
 *	Procedure called to compile the "list" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "list" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileListCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy1151 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, build, concat, delta1, i1, numWords, v110, v17, v30, v42, v44, v5, v56, v60, v66, v78, v82, v94, v98 int32
	var _objPtr, _objPtr1, cachePtr, cachePtr1, listObj, mapPtr, objPtr, valueTokenPtr, v1, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v13, v14, v15, v16, v18, v2, v23, v25, v26, v27, v28, v29, v3, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v43, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v57, v58, v59, v6, v61, v62, v63, v64, v65, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v79, v8, v80, v81, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v95, v96, v97, v99 uintptr
	var eclIndex, v22, v24 TTcl_Size
	var v19, v21 bool
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objPtr, _objPtr1, build, cachePtr, cachePtr1, concat, delta1, eclIndex, i1, listObj, mapPtr, numWords, objPtr, valueTokenPtr, v1, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v13, v14, v15, v16, v17, v18, v19, v2, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(1) {
		/*
		 * [list] without arguments just pushes an empty object.
		 */
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
		return TCL_OK
	}
	/*
	 * Test if all arguments are compile-time known. If they are, we can
	 * implement with a simple push.
	 */
	numWords = int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)
	valueTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if v19 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v19 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v19 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		listObj = XTclThreadAllocObj(tls)
	} else {
		listObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(listObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(listObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(listObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr = libc.UintptrFromInt32(0)
	i1 = int32(1)
	for {
		if !(i1 < numWords && listObj != libc.UintptrFromInt32(0)) {
			break
		}
		if v21 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v21 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v21 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			objPtr = XTclThreadAllocObj(tls)
		} else {
			objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
		if XTclWordKnownAtCompileTime(tls, valueTokenPtr, objPtr) != 0 {
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listObj, objPtr)
		} else {
			_objPtr = objPtr
			v23 = _objPtr
			v22 = *(*TTcl_Size)(unsafe.Pointer(v23))
			*(*TTcl_Size)(unsafe.Pointer(v23))--
			if v22 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			_objPtr1 = listObj
			v25 = _objPtr1
			v24 = *(*TTcl_Size)(unsafe.Pointer(v25))
			*(*TTcl_Size)(unsafe.Pointer(v25))--
			if v24 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
			listObj = libc.UintptrFromInt32(0)
		}
		valueTokenPtr = valueTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		goto _20
	_20:
		;
		i1++
	}
	if listObj != libc.UintptrFromInt32(0) {
		_objIndexCopy1 = XTclAddLiteralObj(tls, envPtr2, listObj, libc.UintptrFromInt32(0))
		if _objIndexCopy1 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v27 = envPtr2 + 152
			v26 = *(*uintptr)(unsafe.Pointer(v27))
			*(*uintptr)(unsafe.Pointer(v27))++
			*(*uint8)(unsafe.Pointer(v26)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v29 = envPtr2 + 152
			v28 = *(*uintptr)(unsafe.Pointer(v29))
			*(*uintptr)(unsafe.Pointer(v29))++
			*(*uint8)(unsafe.Pointer(v28)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v30 = delta1
				v31 = envPtr2
				if v30 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v31)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v31)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v31)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v31)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v31 + 64)) += int64(v30)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v33 = envPtr2 + 152
			v32 = *(*uintptr)(unsafe.Pointer(v33))
			*(*uintptr)(unsafe.Pointer(v33))++
			*(*uint8)(unsafe.Pointer(v32)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v35 = envPtr2 + 152
			v34 = *(*uintptr)(unsafe.Pointer(v35))
			*(*uintptr)(unsafe.Pointer(v35))++
			*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
			v37 = envPtr2 + 152
			v36 = *(*uintptr)(unsafe.Pointer(v37))
			*(*uintptr)(unsafe.Pointer(v37))++
			*(*uint8)(unsafe.Pointer(v36)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
			v39 = envPtr2 + 152
			v38 = *(*uintptr)(unsafe.Pointer(v39))
			*(*uintptr)(unsafe.Pointer(v39))++
			*(*uint8)(unsafe.Pointer(v38)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
			v41 = envPtr2 + 152
			v40 = *(*uintptr)(unsafe.Pointer(v41))
			*(*uintptr)(unsafe.Pointer(v41))++
			*(*uint8)(unsafe.Pointer(v40)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v42 = delta1
				v43 = envPtr2
				if v42 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v43)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v43)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v43)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v43)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v43 + 64)) += int64(v42)
			}
		}
		return TCL_OK
	}
	/*
	 * Push the all values onto the stack.
	 */
	numWords = int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)
	valueTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	v44 = libc.Int32FromInt32(0)
	build = v44
	concat = v44
	i1 = int32(1)
	for {
		if !(i1 < numWords) {
			break
		}
		if (*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).Ftype1 == int32(TCL_TOKEN_EXPAND_WORD) && build > 0 {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v47 = envPtr2 + 152
			v46 = *(*uintptr)(unsafe.Pointer(v47))
			*(*uintptr)(unsafe.Pointer(v47))++
			*(*uint8)(unsafe.Pointer(v46)) = libc.Uint8FromInt32(int32(INST_LIST))
			v49 = envPtr2 + 152
			v48 = *(*uintptr)(unsafe.Pointer(v49))
			*(*uintptr)(unsafe.Pointer(v49))++
			*(*uint8)(unsafe.Pointer(v48)) = uint8(libc.Uint32FromInt32(build) >> libc.Int32FromInt32(24))
			v51 = envPtr2 + 152
			v50 = *(*uintptr)(unsafe.Pointer(v51))
			*(*uintptr)(unsafe.Pointer(v51))++
			*(*uint8)(unsafe.Pointer(v50)) = uint8(libc.Uint32FromInt32(build) >> libc.Int32FromInt32(16))
			v53 = envPtr2 + 152
			v52 = *(*uintptr)(unsafe.Pointer(v53))
			*(*uintptr)(unsafe.Pointer(v53))++
			*(*uint8)(unsafe.Pointer(v52)) = uint8(libc.Uint32FromInt32(build) >> libc.Int32FromInt32(8))
			v55 = envPtr2 + 152
			v54 = *(*uintptr)(unsafe.Pointer(v55))
			*(*uintptr)(unsafe.Pointer(v55))++
			*(*uint8)(unsafe.Pointer(v54)) = uint8(libc.Uint32FromInt32(build))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LIST)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - build
				}
				v56 = delta1
				v57 = envPtr2
				if v56 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v57)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v57)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v57)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v57)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v57 + 64)) += int64(v56)
			}
			if concat != 0 {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v59 = envPtr2 + 152
				v58 = *(*uintptr)(unsafe.Pointer(v59))
				*(*uintptr)(unsafe.Pointer(v59))++
				*(*uint8)(unsafe.Pointer(v58)) = libc.Uint8FromInt32(int32(INST_LIST_CONCAT))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LIST_CONCAT)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v60 = delta1
					v61 = envPtr2
					if v60 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v61)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v61)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v61)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v61)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v61 + 64)) += int64(v60)
				}
			}
			build = 0
			concat = int32(1)
		}
		if (*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(valueTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(valueTokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy2 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v63 = envPtr2 + 152
				v62 = *(*uintptr)(unsafe.Pointer(v63))
				*(*uintptr)(unsafe.Pointer(v63))++
				*(*uint8)(unsafe.Pointer(v62)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v65 = envPtr2 + 152
				v64 = *(*uintptr)(unsafe.Pointer(v65))
				*(*uintptr)(unsafe.Pointer(v65))++
				*(*uint8)(unsafe.Pointer(v64)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy2
					}
					v66 = delta1
					v67 = envPtr2
					if v66 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v67)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v67)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v67)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v67)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v67 + 64)) += int64(v66)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v69 = envPtr2 + 152
				v68 = *(*uintptr)(unsafe.Pointer(v69))
				*(*uintptr)(unsafe.Pointer(v69))++
				*(*uint8)(unsafe.Pointer(v68)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v71 = envPtr2 + 152
				v70 = *(*uintptr)(unsafe.Pointer(v71))
				*(*uintptr)(unsafe.Pointer(v71))++
				*(*uint8)(unsafe.Pointer(v70)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
				v73 = envPtr2 + 152
				v72 = *(*uintptr)(unsafe.Pointer(v73))
				*(*uintptr)(unsafe.Pointer(v73))++
				*(*uint8)(unsafe.Pointer(v72)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
				v75 = envPtr2 + 152
				v74 = *(*uintptr)(unsafe.Pointer(v75))
				*(*uintptr)(unsafe.Pointer(v75))++
				*(*uint8)(unsafe.Pointer(v74)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
				v77 = envPtr2 + 152
				v76 = *(*uintptr)(unsafe.Pointer(v77))
				*(*uintptr)(unsafe.Pointer(v77))++
				*(*uint8)(unsafe.Pointer(v76)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy2
					}
					v78 = delta1
					v79 = envPtr2
					if v78 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v79)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v79)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v79)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v79)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v79 + 64)) += int64(v78)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
			XTclCompileTokens(tls, interp, valueTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).FnumComponents), envPtr2)
		}
		if (*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).Ftype1 == int32(TCL_TOKEN_EXPAND_WORD) {
			if concat != 0 {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v81 = envPtr2 + 152
				v80 = *(*uintptr)(unsafe.Pointer(v81))
				*(*uintptr)(unsafe.Pointer(v81))++
				*(*uint8)(unsafe.Pointer(v80)) = libc.Uint8FromInt32(int32(INST_LIST_CONCAT))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LIST_CONCAT)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v82 = delta1
					v83 = envPtr2
					if v82 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v83)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v83)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v83)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v83)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v83 + 64)) += int64(v82)
				}
			} else {
				concat = int32(1)
			}
		} else {
			build++
		}
		valueTokenPtr = valueTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		goto _45
	_45:
		;
		i1++
	}
	if build > 0 {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v85 = envPtr2 + 152
		v84 = *(*uintptr)(unsafe.Pointer(v85))
		*(*uintptr)(unsafe.Pointer(v85))++
		*(*uint8)(unsafe.Pointer(v84)) = libc.Uint8FromInt32(int32(INST_LIST))
		v87 = envPtr2 + 152
		v86 = *(*uintptr)(unsafe.Pointer(v87))
		*(*uintptr)(unsafe.Pointer(v87))++
		*(*uint8)(unsafe.Pointer(v86)) = uint8(libc.Uint32FromInt32(build) >> libc.Int32FromInt32(24))
		v89 = envPtr2 + 152
		v88 = *(*uintptr)(unsafe.Pointer(v89))
		*(*uintptr)(unsafe.Pointer(v89))++
		*(*uint8)(unsafe.Pointer(v88)) = uint8(libc.Uint32FromInt32(build) >> libc.Int32FromInt32(16))
		v91 = envPtr2 + 152
		v90 = *(*uintptr)(unsafe.Pointer(v91))
		*(*uintptr)(unsafe.Pointer(v91))++
		*(*uint8)(unsafe.Pointer(v90)) = uint8(libc.Uint32FromInt32(build) >> libc.Int32FromInt32(8))
		v93 = envPtr2 + 152
		v92 = *(*uintptr)(unsafe.Pointer(v93))
		*(*uintptr)(unsafe.Pointer(v93))++
		*(*uint8)(unsafe.Pointer(v92)) = uint8(libc.Uint32FromInt32(build))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LIST)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - build
			}
			v94 = delta1
			v95 = envPtr2
			if v94 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v95)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v95)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v95)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v95)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v95 + 64)) += int64(v94)
		}
		if concat != 0 {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v97 = envPtr2 + 152
			v96 = *(*uintptr)(unsafe.Pointer(v97))
			*(*uintptr)(unsafe.Pointer(v97))++
			*(*uint8)(unsafe.Pointer(v96)) = libc.Uint8FromInt32(int32(INST_LIST_CONCAT))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LIST_CONCAT)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v98 = delta1
				v99 = envPtr2
				if v98 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v99)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v99)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v99)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v99)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v99 + 64)) += int64(v98)
			}
		}
	}
	/*
	 * If there was just one expanded word, we must ensure that it is a list
	 * at this point. We use an [lrange ... 0 end] for this (instead of
	 * [llength], as with literals) as we must drop any string representation
	 * that might be hanging around.
	 */
	if concat != 0 && numWords == int32(2) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v101 = envPtr2 + 152
		v100 = *(*uintptr)(unsafe.Pointer(v101))
		*(*uintptr)(unsafe.Pointer(v101))++
		*(*uint8)(unsafe.Pointer(v100)) = libc.Uint8FromInt32(int32(INST_LIST_RANGE_IMM))
		v103 = envPtr2 + 152
		v102 = *(*uintptr)(unsafe.Pointer(v103))
		*(*uintptr)(unsafe.Pointer(v103))++
		*(*uint8)(unsafe.Pointer(v102)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
		v105 = envPtr2 + 152
		v104 = *(*uintptr)(unsafe.Pointer(v105))
		*(*uintptr)(unsafe.Pointer(v105))++
		*(*uint8)(unsafe.Pointer(v104)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
		v107 = envPtr2 + 152
		v106 = *(*uintptr)(unsafe.Pointer(v107))
		*(*uintptr)(unsafe.Pointer(v107))++
		*(*uint8)(unsafe.Pointer(v106)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
		v109 = envPtr2 + 152
		v108 = *(*uintptr)(unsafe.Pointer(v109))
		*(*uintptr)(unsafe.Pointer(v109))++
		*(*uint8)(unsafe.Pointer(v108)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LIST_RANGE_IMM)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v110 = delta1
			v111 = envPtr2
			if v110 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v111)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v111)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v111)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v111)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v111 + 64)) += int64(v110)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v113 = envPtr2 + 152
		v112 = *(*uintptr)(unsafe.Pointer(v113))
		*(*uintptr)(unsafe.Pointer(v113))++
		*(*uint8)(unsafe.Pointer(v112)) = uint8(libc.Uint32FromInt32(int32(int64(-libc.Int32FromInt32(2)))) >> libc.Int32FromInt32(24))
		v115 = envPtr2 + 152
		v114 = *(*uintptr)(unsafe.Pointer(v115))
		*(*uintptr)(unsafe.Pointer(v115))++
		*(*uint8)(unsafe.Pointer(v114)) = uint8(libc.Uint32FromInt32(int32(int64(-libc.Int32FromInt32(2)))) >> libc.Int32FromInt32(16))
		v117 = envPtr2 + 152
		v116 = *(*uintptr)(unsafe.Pointer(v117))
		*(*uintptr)(unsafe.Pointer(v117))++
		*(*uint8)(unsafe.Pointer(v116)) = uint8(libc.Uint32FromInt32(int32(int64(-libc.Int32FromInt32(2)))) >> libc.Int32FromInt32(8))
		v119 = envPtr2 + 152
		v118 = *(*uintptr)(unsafe.Pointer(v119))
		*(*uintptr)(unsafe.Pointer(v119))++
		*(*uint8)(unsafe.Pointer(v118)) = uint8(libc.Uint32FromInt32(int32(int64(-libc.Int32FromInt32(2)))))
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileLlengthCmd --
 *
 *	Procedure called to compile the "llength" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "llength" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileLlengthCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy1264 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, delta1, v17, v21, v5 int32
	var eclIndex TTcl_Size
	var mapPtr, varTokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v22, v3, v4, v6, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, eclIndex, mapPtr, varTokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v3, v4, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
		return int32(TCL_ERROR)
	}
	varTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(varTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, varTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents), envPtr2)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v20 = envPtr2 + 152
	v19 = *(*uintptr)(unsafe.Pointer(v20))
	*(*uintptr)(unsafe.Pointer(v20))++
	*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_LIST_LENGTH))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_LIST_LENGTH)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v21 = delta1
		v22 = envPtr2
		if v21 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v22 + 64)) += int64(v21)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileLrangeCmd --
 *
 *	How to compile the "lrange" command. We only bother because we needed
 *	the opcode anyway for "lassign".
 *
 *----------------------------------------------------------------------
 */

func XTclCompileLrangeCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy1296 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds the resulting instructions. */
	var _objIndexCopy, delta1, v17, v29, v5 int32
	var eclIndex TTcl_Size
	var listTokenPtr, mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v4, v6, v7, v8, v9 uintptr
	var _ /* idx1 at bp+0 */ int32
	var _ /* idx2 at bp+4 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, eclIndex, listTokenPtr, mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v4, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(4) {
		return int32(TCL_ERROR)
	}
	listTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	tokenPtr = listTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(listTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if XTclGetIndexFromToken(tls, tokenPtr, libc.Uint64FromInt64(libc.Int64FromInt32(0)), libc.Uint64FromInt64(int64(-libc.Int32FromInt32(1))), bp) != TCL_OK || *(*int32)(unsafe.Pointer(bp)) == int32(int64(-libc.Int32FromInt32(1))) {
		return int32(TCL_ERROR)
	}
	/*
	 * Token was an index value, and we treat all "first" indices
	 * before the list same as the start of the list.
	 */
	tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if XTclGetIndexFromToken(tls, tokenPtr, libc.Uint64FromInt64(int64(-libc.Int32FromInt32(1))), libc.Uint64FromInt64(int64(-libc.Int32FromInt32(2))), bp+4) != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Token was an index value, and we treat all "last" indices
	 * after the list same as the end of the list.
	 */
	/*
	 * Issue instructions. It's not safe to skip doing the LIST_RANGE, as
	 * we've not proved that the 'list' argument is really a list. Not that it
	 * is worth trying to do that given current knowledge.
	 */
	if (*TTcl_Token)(unsafe.Pointer(listTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(listTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(listTokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, listTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(listTokenPtr)).FnumComponents), envPtr2)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v20 = envPtr2 + 152
	v19 = *(*uintptr)(unsafe.Pointer(v20))
	*(*uintptr)(unsafe.Pointer(v20))++
	*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_LIST_RANGE_IMM))
	v22 = envPtr2 + 152
	v21 = *(*uintptr)(unsafe.Pointer(v22))
	*(*uintptr)(unsafe.Pointer(v22))++
	*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))) >> libc.Int32FromInt32(24))
	v24 = envPtr2 + 152
	v23 = *(*uintptr)(unsafe.Pointer(v24))
	*(*uintptr)(unsafe.Pointer(v24))++
	*(*uint8)(unsafe.Pointer(v23)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))) >> libc.Int32FromInt32(16))
	v26 = envPtr2 + 152
	v25 = *(*uintptr)(unsafe.Pointer(v26))
	*(*uintptr)(unsafe.Pointer(v26))++
	*(*uint8)(unsafe.Pointer(v25)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))) >> libc.Int32FromInt32(8))
	v28 = envPtr2 + 152
	v27 = *(*uintptr)(unsafe.Pointer(v28))
	*(*uintptr)(unsafe.Pointer(v28))++
	*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_LIST_RANGE_IMM)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp))
		}
		v29 = delta1
		v30 = envPtr2
		if v29 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v30)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v30)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v30)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v30)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v30 + 64)) += int64(v29)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v32 = envPtr2 + 152
	v31 = *(*uintptr)(unsafe.Pointer(v32))
	*(*uintptr)(unsafe.Pointer(v32))++
	*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(24))
	v34 = envPtr2 + 152
	v33 = *(*uintptr)(unsafe.Pointer(v34))
	*(*uintptr)(unsafe.Pointer(v34))++
	*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(16))
	v36 = envPtr2 + 152
	v35 = *(*uintptr)(unsafe.Pointer(v36))
	*(*uintptr)(unsafe.Pointer(v36))++
	*(*uint8)(unsafe.Pointer(v35)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(8))
	v38 = envPtr2 + 152
	v37 = *(*uintptr)(unsafe.Pointer(v38))
	*(*uintptr)(unsafe.Pointer(v38))++
	*(*uint8)(unsafe.Pointer(v37)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileLinsertCmd --
 *
 *	How to compile the "linsert" command. We only bother with the case
 *	where the index is constant.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileLinsertCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy1356 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds the resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, delta1, i1, v17, v23, v35, v42, v5, v54, v66 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v36, v38, v39, v4, v40, v41, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v67, v68, v69, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, delta1, eclIndex, i1, mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) < int32(3) {
		return int32(TCL_ERROR)
	}
	/* Push list, insertion index onto the stack */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy1 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v20 = envPtr2 + 152
			v19 = *(*uintptr)(unsafe.Pointer(v20))
			*(*uintptr)(unsafe.Pointer(v20))++
			*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v22 = envPtr2 + 152
			v21 = *(*uintptr)(unsafe.Pointer(v22))
			*(*uintptr)(unsafe.Pointer(v22))++
			*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v23 = delta1
				v24 = envPtr2
				if v23 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v24 + 64)) += int64(v23)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v26 = envPtr2 + 152
			v25 = *(*uintptr)(unsafe.Pointer(v26))
			*(*uintptr)(unsafe.Pointer(v26))++
			*(*uint8)(unsafe.Pointer(v25)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v28 = envPtr2 + 152
			v27 = *(*uintptr)(unsafe.Pointer(v28))
			*(*uintptr)(unsafe.Pointer(v28))++
			*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
			v30 = envPtr2 + 152
			v29 = *(*uintptr)(unsafe.Pointer(v30))
			*(*uintptr)(unsafe.Pointer(v30))++
			*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
			v32 = envPtr2 + 152
			v31 = *(*uintptr)(unsafe.Pointer(v32))
			*(*uintptr)(unsafe.Pointer(v32))++
			*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
			v34 = envPtr2 + 152
			v33 = *(*uintptr)(unsafe.Pointer(v34))
			*(*uintptr)(unsafe.Pointer(v34))++
			*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v35 = delta1
				v36 = envPtr2
				if v35 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v36 + 64)) += int64(v35)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	/* Push new elements to be inserted */
	i1 = int32(3)
	for {
		if !(i1 < int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)) {
			break
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy2 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v39 = envPtr2 + 152
				v38 = *(*uintptr)(unsafe.Pointer(v39))
				*(*uintptr)(unsafe.Pointer(v39))++
				*(*uint8)(unsafe.Pointer(v38)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v41 = envPtr2 + 152
				v40 = *(*uintptr)(unsafe.Pointer(v41))
				*(*uintptr)(unsafe.Pointer(v41))++
				*(*uint8)(unsafe.Pointer(v40)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy2
					}
					v42 = delta1
					v43 = envPtr2
					if v42 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v43)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v43)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v43)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v43)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v43 + 64)) += int64(v42)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v45 = envPtr2 + 152
				v44 = *(*uintptr)(unsafe.Pointer(v45))
				*(*uintptr)(unsafe.Pointer(v45))++
				*(*uint8)(unsafe.Pointer(v44)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v47 = envPtr2 + 152
				v46 = *(*uintptr)(unsafe.Pointer(v47))
				*(*uintptr)(unsafe.Pointer(v47))++
				*(*uint8)(unsafe.Pointer(v46)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
				v49 = envPtr2 + 152
				v48 = *(*uintptr)(unsafe.Pointer(v49))
				*(*uintptr)(unsafe.Pointer(v49))++
				*(*uint8)(unsafe.Pointer(v48)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
				v51 = envPtr2 + 152
				v50 = *(*uintptr)(unsafe.Pointer(v51))
				*(*uintptr)(unsafe.Pointer(v51))++
				*(*uint8)(unsafe.Pointer(v50)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
				v53 = envPtr2 + 152
				v52 = *(*uintptr)(unsafe.Pointer(v53))
				*(*uintptr)(unsafe.Pointer(v53))++
				*(*uint8)(unsafe.Pointer(v52)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy2
					}
					v54 = delta1
					v55 = envPtr2
					if v54 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v55)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v55)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v55)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v55)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v55 + 64)) += int64(v54)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
		}
		goto _37
	_37:
		;
		i1++
	}
	/* First operand is count of arguments */
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v57 = envPtr2 + 152
	v56 = *(*uintptr)(unsafe.Pointer(v57))
	*(*uintptr)(unsafe.Pointer(v57))++
	*(*uint8)(unsafe.Pointer(v56)) = libc.Uint8FromInt32(int32(INST_LREPLACE4))
	v59 = envPtr2 + 152
	v58 = *(*uintptr)(unsafe.Pointer(v59))
	*(*uintptr)(unsafe.Pointer(v59))++
	*(*uint8)(unsafe.Pointer(v58)) = uint8(libc.Uint32FromInt64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords-libc.Int64FromInt32(1)) >> libc.Int32FromInt32(24))
	v61 = envPtr2 + 152
	v60 = *(*uintptr)(unsafe.Pointer(v61))
	*(*uintptr)(unsafe.Pointer(v61))++
	*(*uint8)(unsafe.Pointer(v60)) = uint8(libc.Uint32FromInt64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords-libc.Int64FromInt32(1)) >> libc.Int32FromInt32(16))
	v63 = envPtr2 + 152
	v62 = *(*uintptr)(unsafe.Pointer(v63))
	*(*uintptr)(unsafe.Pointer(v63))++
	*(*uint8)(unsafe.Pointer(v62)) = uint8(libc.Uint32FromInt64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords-libc.Int64FromInt32(1)) >> libc.Int32FromInt32(8))
	v65 = envPtr2 + 152
	v64 = *(*uintptr)(unsafe.Pointer(v65))
	*(*uintptr)(unsafe.Pointer(v65))++
	*(*uint8)(unsafe.Pointer(v64)) = uint8(libc.Uint32FromInt64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords - libc.Int64FromInt32(1)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_LREPLACE4)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords-int64(1))
		}
		v66 = delta1
		v67 = envPtr2
		if v66 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v67)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v67)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v67)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v67)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v67 + 64)) += int64(v66)
	}
	/*
	 * Second operand is bitmask
	 *  TCL_LREPLACE4_END_IS_LAST - end refers to last element
	 *  TCL_LREPLACE4_SINGLE_INDEX - second index is not present
	 *     indicating this is a pure insert
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v69 = envPtr2 + 152
	v68 = *(*uintptr)(unsafe.Pointer(v69))
	*(*uintptr)(unsafe.Pointer(v69))++
	*(*uint8)(unsafe.Pointer(v68)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(TCL_LREPLACE4_SINGLE_INDEX)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileLreplaceCmd --
 *
 *	How to compile the "lreplace" command. We only bother with the case
 *	where the indices are constant.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileLreplaceCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy1408 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds the resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, delta1, i1, v17, v23, v35, v41, v5, v53, v60, v72, v84 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v36, v37, v38, v39, v4, v40, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v54, v56, v57, v58, v59, v6, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v85, v86, v87, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, delta1, eclIndex, i1, mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords < int64(4) {
		return int32(TCL_ERROR)
	}
	/* Push list, first, last onto the stack */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy1 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v20 = envPtr2 + 152
			v19 = *(*uintptr)(unsafe.Pointer(v20))
			*(*uintptr)(unsafe.Pointer(v20))++
			*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v22 = envPtr2 + 152
			v21 = *(*uintptr)(unsafe.Pointer(v22))
			*(*uintptr)(unsafe.Pointer(v22))++
			*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v23 = delta1
				v24 = envPtr2
				if v23 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v24 + 64)) += int64(v23)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v26 = envPtr2 + 152
			v25 = *(*uintptr)(unsafe.Pointer(v26))
			*(*uintptr)(unsafe.Pointer(v26))++
			*(*uint8)(unsafe.Pointer(v25)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v28 = envPtr2 + 152
			v27 = *(*uintptr)(unsafe.Pointer(v28))
			*(*uintptr)(unsafe.Pointer(v28))++
			*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
			v30 = envPtr2 + 152
			v29 = *(*uintptr)(unsafe.Pointer(v30))
			*(*uintptr)(unsafe.Pointer(v30))++
			*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
			v32 = envPtr2 + 152
			v31 = *(*uintptr)(unsafe.Pointer(v32))
			*(*uintptr)(unsafe.Pointer(v32))++
			*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
			v34 = envPtr2 + 152
			v33 = *(*uintptr)(unsafe.Pointer(v34))
			*(*uintptr)(unsafe.Pointer(v34))++
			*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v35 = delta1
				v36 = envPtr2
				if v35 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v36 + 64)) += int64(v35)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy2 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v38 = envPtr2 + 152
			v37 = *(*uintptr)(unsafe.Pointer(v38))
			*(*uintptr)(unsafe.Pointer(v38))++
			*(*uint8)(unsafe.Pointer(v37)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v40 = envPtr2 + 152
			v39 = *(*uintptr)(unsafe.Pointer(v40))
			*(*uintptr)(unsafe.Pointer(v40))++
			*(*uint8)(unsafe.Pointer(v39)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v41 = delta1
				v42 = envPtr2
				if v41 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v42)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v42)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v42)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v42)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v42 + 64)) += int64(v41)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v44 = envPtr2 + 152
			v43 = *(*uintptr)(unsafe.Pointer(v44))
			*(*uintptr)(unsafe.Pointer(v44))++
			*(*uint8)(unsafe.Pointer(v43)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v46 = envPtr2 + 152
			v45 = *(*uintptr)(unsafe.Pointer(v46))
			*(*uintptr)(unsafe.Pointer(v46))++
			*(*uint8)(unsafe.Pointer(v45)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
			v48 = envPtr2 + 152
			v47 = *(*uintptr)(unsafe.Pointer(v48))
			*(*uintptr)(unsafe.Pointer(v48))++
			*(*uint8)(unsafe.Pointer(v47)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
			v50 = envPtr2 + 152
			v49 = *(*uintptr)(unsafe.Pointer(v50))
			*(*uintptr)(unsafe.Pointer(v50))++
			*(*uint8)(unsafe.Pointer(v49)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
			v52 = envPtr2 + 152
			v51 = *(*uintptr)(unsafe.Pointer(v52))
			*(*uintptr)(unsafe.Pointer(v52))++
			*(*uint8)(unsafe.Pointer(v51)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v53 = delta1
				v54 = envPtr2
				if v53 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v54)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v54)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v54)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v54)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v54 + 64)) += int64(v53)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 3*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 3*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	/* Push new elements to be inserted */
	i1 = int32(4)
	for {
		if !(i1 < int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)) {
			break
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy3 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy3 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v57 = envPtr2 + 152
				v56 = *(*uintptr)(unsafe.Pointer(v57))
				*(*uintptr)(unsafe.Pointer(v57))++
				*(*uint8)(unsafe.Pointer(v56)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v59 = envPtr2 + 152
				v58 = *(*uintptr)(unsafe.Pointer(v59))
				*(*uintptr)(unsafe.Pointer(v59))++
				*(*uint8)(unsafe.Pointer(v58)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy3
					}
					v60 = delta1
					v61 = envPtr2
					if v60 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v61)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v61)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v61)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v61)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v61 + 64)) += int64(v60)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v63 = envPtr2 + 152
				v62 = *(*uintptr)(unsafe.Pointer(v63))
				*(*uintptr)(unsafe.Pointer(v63))++
				*(*uint8)(unsafe.Pointer(v62)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v65 = envPtr2 + 152
				v64 = *(*uintptr)(unsafe.Pointer(v65))
				*(*uintptr)(unsafe.Pointer(v65))++
				*(*uint8)(unsafe.Pointer(v64)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(24))
				v67 = envPtr2 + 152
				v66 = *(*uintptr)(unsafe.Pointer(v67))
				*(*uintptr)(unsafe.Pointer(v67))++
				*(*uint8)(unsafe.Pointer(v66)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(16))
				v69 = envPtr2 + 152
				v68 = *(*uintptr)(unsafe.Pointer(v69))
				*(*uintptr)(unsafe.Pointer(v69))++
				*(*uint8)(unsafe.Pointer(v68)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(8))
				v71 = envPtr2 + 152
				v70 = *(*uintptr)(unsafe.Pointer(v71))
				*(*uintptr)(unsafe.Pointer(v71))++
				*(*uint8)(unsafe.Pointer(v70)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy3
					}
					v72 = delta1
					v73 = envPtr2
					if v72 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v73)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v73)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v73)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v73)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v73 + 64)) += int64(v72)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
		}
		goto _55
	_55:
		;
		i1++
	}
	/* First operand is count of arguments */
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v75 = envPtr2 + 152
	v74 = *(*uintptr)(unsafe.Pointer(v75))
	*(*uintptr)(unsafe.Pointer(v75))++
	*(*uint8)(unsafe.Pointer(v74)) = libc.Uint8FromInt32(int32(INST_LREPLACE4))
	v77 = envPtr2 + 152
	v76 = *(*uintptr)(unsafe.Pointer(v77))
	*(*uintptr)(unsafe.Pointer(v77))++
	*(*uint8)(unsafe.Pointer(v76)) = uint8(libc.Uint32FromInt64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords-libc.Int64FromInt32(1)) >> libc.Int32FromInt32(24))
	v79 = envPtr2 + 152
	v78 = *(*uintptr)(unsafe.Pointer(v79))
	*(*uintptr)(unsafe.Pointer(v79))++
	*(*uint8)(unsafe.Pointer(v78)) = uint8(libc.Uint32FromInt64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords-libc.Int64FromInt32(1)) >> libc.Int32FromInt32(16))
	v81 = envPtr2 + 152
	v80 = *(*uintptr)(unsafe.Pointer(v81))
	*(*uintptr)(unsafe.Pointer(v81))++
	*(*uint8)(unsafe.Pointer(v80)) = uint8(libc.Uint32FromInt64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords-libc.Int64FromInt32(1)) >> libc.Int32FromInt32(8))
	v83 = envPtr2 + 152
	v82 = *(*uintptr)(unsafe.Pointer(v83))
	*(*uintptr)(unsafe.Pointer(v83))++
	*(*uint8)(unsafe.Pointer(v82)) = uint8(libc.Uint32FromInt64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords - libc.Int64FromInt32(1)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_LREPLACE4)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords-int64(1))
		}
		v84 = delta1
		v85 = envPtr2
		if v84 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v85)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v85)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v85)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v85)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v85 + 64)) += int64(v84)
	}
	/*
	 * Second operand is bitmask
	 *  TCL_LREPLACE4_END_IS_LAST - end refers to last element
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v87 = envPtr2 + 152
	v86 = *(*uintptr)(unsafe.Pointer(v87))
	*(*uintptr)(unsafe.Pointer(v87))++
	*(*uint8)(unsafe.Pointer(v86)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(TCL_LREPLACE4_END_IS_LAST)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileLsetCmd --
 *
 *	Procedure called to compile the "lset" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "lset" command at
 *	runtime.
 *
 * The general template for execution of the "lset" command is:
 *	(1) Instructions to push the variable name, unless the variable is
 *	    local to the stack frame.
 *	(2) If the variable is an array element, instructions to push the
 *	    array element name.
 *	(3) Instructions to push each of zero or more "index" arguments to the
 *	    stack, followed with the "newValue" element.
 *	(4) Instructions to duplicate the variable name and/or array element
 *	    name onto the top of the stack, if either was pushed at steps (1)
 *	    and (2).
 *	(5) The appropriate INST_LOAD_* instruction to place the original
 *	    value of the list variable at top of stack.
 *	(6) At this point, the stack contains:
 *		varName? arrayElementName? index1 index2 ... newValue oldList
 *	    The compiler emits one of INST_LSET_FLAT or INST_LSET_LIST
 *	    according as whether there is exactly one index element (LIST) or
 *	    either zero or else two or more (FLAT). This instruction removes
 *	    everything from the stack except for the two names and pushes the
 *	    new value of the variable.
 *	(7) Finally, INST_STORE_* stores the new value in the variable and
 *	    cleans up the stack.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileLsetCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy1489 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds the resulting instructions. */
	var _objIndexCopy, delta1, i1, tempDepth, v102, v106, v112, v124, v128, v134, v146, v18, v30, v42, v46, v52, v6, v64, v68, v74, v86, v90 int32
	var eclIndex TTcl_Size
	var mapPtr, varTokenPtr, v10, v100, v101, v103, v104, v105, v107, v108, v109, v11, v110, v111, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v123, v125, v126, v127, v129, v13, v130, v131, v132, v133, v135, v136, v137, v138, v139, v14, v140, v141, v142, v143, v144, v145, v147, v15, v16, v17, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v43, v44, v45, v47, v48, v49, v5, v50, v51, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63, v65, v66, v67, v69, v7, v70, v71, v72, v73, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v87, v88, v89, v9, v91, v92, v93, v94, v95, v96, v97, v98, v99 uintptr
	var _ /* isScalar at bp+4 */ int32
	var _ /* localIndex at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, eclIndex, i1, mapPtr, tempDepth, varTokenPtr, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v123, v124, v125, v126, v127, v128, v129, v13, v130, v131, v132, v133, v134, v135, v136, v137, v138, v139, v14, v140, v141, v142, v143, v144, v145, v146, v147, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	/*
	 * Check argument count.
	 */
	/* TODO: Consider support for compiling expanded args. */
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) < int32(3) {
		/*
		 * Fail at run time, not in compilation.
		 */
		return int32(TCL_ERROR)
	}
	/*
	 * Decide if we can use a frame slot for the var/array name or if we need
	 * to emit code to compute and push the name at runtime. We use a frame
	 * slot (entry in the array of local vars) if we are compiling a procedure
	 * body and if the name is simple text that does not include namespace
	 * qualifiers.
	 */
	varTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
	XTclPushVarName(tls, interp, varTokenPtr, envPtr2, 0, bp, bp+4)
	/*
	 * Push the "index" args and the new element value.
	 */
	i1 = int32(2)
	for {
		if !(i1 < int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)) {
			break
		}
		varTokenPtr = varTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if (*TTcl_Token)(unsafe.Pointer(varTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v3 = envPtr2 + 152
				v2 = *(*uintptr)(unsafe.Pointer(v3))
				*(*uintptr)(unsafe.Pointer(v3))++
				*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v5 = envPtr2 + 152
				v4 = *(*uintptr)(unsafe.Pointer(v5))
				*(*uintptr)(unsafe.Pointer(v5))++
				*(*uint8)(unsafe.Pointer(v4)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v6 = delta1
					v7 = envPtr2
					if v6 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v7 + 64)) += int64(v6)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v9 = envPtr2 + 152
				v8 = *(*uintptr)(unsafe.Pointer(v9))
				*(*uintptr)(unsafe.Pointer(v9))++
				*(*uint8)(unsafe.Pointer(v8)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v11 = envPtr2 + 152
				v10 = *(*uintptr)(unsafe.Pointer(v11))
				*(*uintptr)(unsafe.Pointer(v11))++
				*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
				v13 = envPtr2 + 152
				v12 = *(*uintptr)(unsafe.Pointer(v13))
				*(*uintptr)(unsafe.Pointer(v13))++
				*(*uint8)(unsafe.Pointer(v12)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
				v15 = envPtr2 + 152
				v14 = *(*uintptr)(unsafe.Pointer(v15))
				*(*uintptr)(unsafe.Pointer(v15))++
				*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
				v17 = envPtr2 + 152
				v16 = *(*uintptr)(unsafe.Pointer(v17))
				*(*uintptr)(unsafe.Pointer(v17))++
				*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v18 = delta1
					v19 = envPtr2
					if v18 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v19 + 64)) += int64(v18)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
			XTclCompileTokens(tls, interp, varTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents), envPtr2)
		}
		goto _1
	_1:
		;
		i1++
	}
	/*
	 * Duplicate the variable name if it's been pushed.
	 */
	if *(*int32)(unsafe.Pointer(bp)) < 0 {
		if *(*int32)(unsafe.Pointer(bp + 4)) != 0 {
			tempDepth = int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords - int64(2))
		} else {
			tempDepth = int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords - int64(1))
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v21 = envPtr2 + 152
		v20 = *(*uintptr)(unsafe.Pointer(v21))
		*(*uintptr)(unsafe.Pointer(v21))++
		*(*uint8)(unsafe.Pointer(v20)) = libc.Uint8FromInt32(int32(INST_OVER))
		v23 = envPtr2 + 152
		v22 = *(*uintptr)(unsafe.Pointer(v23))
		*(*uintptr)(unsafe.Pointer(v23))++
		*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(tempDepth) >> libc.Int32FromInt32(24))
		v25 = envPtr2 + 152
		v24 = *(*uintptr)(unsafe.Pointer(v25))
		*(*uintptr)(unsafe.Pointer(v25))++
		*(*uint8)(unsafe.Pointer(v24)) = uint8(libc.Uint32FromInt32(tempDepth) >> libc.Int32FromInt32(16))
		v27 = envPtr2 + 152
		v26 = *(*uintptr)(unsafe.Pointer(v27))
		*(*uintptr)(unsafe.Pointer(v27))++
		*(*uint8)(unsafe.Pointer(v26)) = uint8(libc.Uint32FromInt32(tempDepth) >> libc.Int32FromInt32(8))
		v29 = envPtr2 + 152
		v28 = *(*uintptr)(unsafe.Pointer(v29))
		*(*uintptr)(unsafe.Pointer(v29))++
		*(*uint8)(unsafe.Pointer(v28)) = uint8(libc.Uint32FromInt32(tempDepth))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_OVER)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - tempDepth
			}
			v30 = delta1
			v31 = envPtr2
			if v30 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v31)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v31)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v31)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v31)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v31 + 64)) += int64(v30)
		}
	}
	/*
	 * Duplicate an array index if one's been pushed.
	 */
	if !(*(*int32)(unsafe.Pointer(bp + 4)) != 0) {
		if *(*int32)(unsafe.Pointer(bp)) < 0 {
			tempDepth = int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords - int64(1))
		} else {
			tempDepth = int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords - int64(2))
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v33 = envPtr2 + 152
		v32 = *(*uintptr)(unsafe.Pointer(v33))
		*(*uintptr)(unsafe.Pointer(v33))++
		*(*uint8)(unsafe.Pointer(v32)) = libc.Uint8FromInt32(int32(INST_OVER))
		v35 = envPtr2 + 152
		v34 = *(*uintptr)(unsafe.Pointer(v35))
		*(*uintptr)(unsafe.Pointer(v35))++
		*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt32(tempDepth) >> libc.Int32FromInt32(24))
		v37 = envPtr2 + 152
		v36 = *(*uintptr)(unsafe.Pointer(v37))
		*(*uintptr)(unsafe.Pointer(v37))++
		*(*uint8)(unsafe.Pointer(v36)) = uint8(libc.Uint32FromInt32(tempDepth) >> libc.Int32FromInt32(16))
		v39 = envPtr2 + 152
		v38 = *(*uintptr)(unsafe.Pointer(v39))
		*(*uintptr)(unsafe.Pointer(v39))++
		*(*uint8)(unsafe.Pointer(v38)) = uint8(libc.Uint32FromInt32(tempDepth) >> libc.Int32FromInt32(8))
		v41 = envPtr2 + 152
		v40 = *(*uintptr)(unsafe.Pointer(v41))
		*(*uintptr)(unsafe.Pointer(v41))++
		*(*uint8)(unsafe.Pointer(v40)) = uint8(libc.Uint32FromInt32(tempDepth))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_OVER)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - tempDepth
			}
			v42 = delta1
			v43 = envPtr2
			if v42 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v43)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v43)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v43)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v43)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v43 + 64)) += int64(v42)
		}
	}
	/*
	 * Emit code to load the variable's value.
	 */
	if *(*int32)(unsafe.Pointer(bp + 4)) != 0 {
		if *(*int32)(unsafe.Pointer(bp)) < 0 {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v45 = envPtr2 + 152
			v44 = *(*uintptr)(unsafe.Pointer(v45))
			*(*uintptr)(unsafe.Pointer(v45))++
			*(*uint8)(unsafe.Pointer(v44)) = libc.Uint8FromInt32(int32(INST_LOAD_STK))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LOAD_STK)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v46 = delta1
				v47 = envPtr2
				if v46 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v47)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v47)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v47)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v47)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v47 + 64)) += int64(v46)
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp)) <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v49 = envPtr2 + 152
				v48 = *(*uintptr)(unsafe.Pointer(v49))
				*(*uintptr)(unsafe.Pointer(v49))++
				*(*uint8)(unsafe.Pointer(v48)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
				v51 = envPtr2 + 152
				v50 = *(*uintptr)(unsafe.Pointer(v51))
				*(*uintptr)(unsafe.Pointer(v51))++
				*(*uint8)(unsafe.Pointer(v50)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp))
					}
					v52 = delta1
					v53 = envPtr2
					if v52 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v53)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v53)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v53)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v53)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v53 + 64)) += int64(v52)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v55 = envPtr2 + 152
				v54 = *(*uintptr)(unsafe.Pointer(v55))
				*(*uintptr)(unsafe.Pointer(v55))++
				*(*uint8)(unsafe.Pointer(v54)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
				v57 = envPtr2 + 152
				v56 = *(*uintptr)(unsafe.Pointer(v57))
				*(*uintptr)(unsafe.Pointer(v57))++
				*(*uint8)(unsafe.Pointer(v56)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))) >> libc.Int32FromInt32(24))
				v59 = envPtr2 + 152
				v58 = *(*uintptr)(unsafe.Pointer(v59))
				*(*uintptr)(unsafe.Pointer(v59))++
				*(*uint8)(unsafe.Pointer(v58)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))) >> libc.Int32FromInt32(16))
				v61 = envPtr2 + 152
				v60 = *(*uintptr)(unsafe.Pointer(v61))
				*(*uintptr)(unsafe.Pointer(v61))++
				*(*uint8)(unsafe.Pointer(v60)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))) >> libc.Int32FromInt32(8))
				v63 = envPtr2 + 152
				v62 = *(*uintptr)(unsafe.Pointer(v63))
				*(*uintptr)(unsafe.Pointer(v63))++
				*(*uint8)(unsafe.Pointer(v62)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp))
					}
					v64 = delta1
					v65 = envPtr2
					if v64 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v65)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v65)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v65)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v65)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v65 + 64)) += int64(v64)
				}
			}
		}
	} else {
		if *(*int32)(unsafe.Pointer(bp)) < 0 {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v67 = envPtr2 + 152
			v66 = *(*uintptr)(unsafe.Pointer(v67))
			*(*uintptr)(unsafe.Pointer(v67))++
			*(*uint8)(unsafe.Pointer(v66)) = libc.Uint8FromInt32(int32(INST_LOAD_ARRAY_STK))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LOAD_ARRAY_STK)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v68 = delta1
				v69 = envPtr2
				if v68 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v69)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v69)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v69)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v69)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v69 + 64)) += int64(v68)
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp)) <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v71 = envPtr2 + 152
				v70 = *(*uintptr)(unsafe.Pointer(v71))
				*(*uintptr)(unsafe.Pointer(v71))++
				*(*uint8)(unsafe.Pointer(v70)) = libc.Uint8FromInt32(int32(INST_LOAD_ARRAY1))
				v73 = envPtr2 + 152
				v72 = *(*uintptr)(unsafe.Pointer(v73))
				*(*uintptr)(unsafe.Pointer(v73))++
				*(*uint8)(unsafe.Pointer(v72)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LOAD_ARRAY1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp))
					}
					v74 = delta1
					v75 = envPtr2
					if v74 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v75)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v75)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v75)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v75)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v75 + 64)) += int64(v74)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v77 = envPtr2 + 152
				v76 = *(*uintptr)(unsafe.Pointer(v77))
				*(*uintptr)(unsafe.Pointer(v77))++
				*(*uint8)(unsafe.Pointer(v76)) = libc.Uint8FromInt32(int32(INST_LOAD_ARRAY4))
				v79 = envPtr2 + 152
				v78 = *(*uintptr)(unsafe.Pointer(v79))
				*(*uintptr)(unsafe.Pointer(v79))++
				*(*uint8)(unsafe.Pointer(v78)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))) >> libc.Int32FromInt32(24))
				v81 = envPtr2 + 152
				v80 = *(*uintptr)(unsafe.Pointer(v81))
				*(*uintptr)(unsafe.Pointer(v81))++
				*(*uint8)(unsafe.Pointer(v80)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))) >> libc.Int32FromInt32(16))
				v83 = envPtr2 + 152
				v82 = *(*uintptr)(unsafe.Pointer(v83))
				*(*uintptr)(unsafe.Pointer(v83))++
				*(*uint8)(unsafe.Pointer(v82)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))) >> libc.Int32FromInt32(8))
				v85 = envPtr2 + 152
				v84 = *(*uintptr)(unsafe.Pointer(v85))
				*(*uintptr)(unsafe.Pointer(v85))++
				*(*uint8)(unsafe.Pointer(v84)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LOAD_ARRAY4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp))
					}
					v86 = delta1
					v87 = envPtr2
					if v86 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v87)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v87)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v87)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v87)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v87 + 64)) += int64(v86)
				}
			}
		}
	}
	/*
	 * Emit the correct variety of 'lset' instruction.
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(4) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v89 = envPtr2 + 152
		v88 = *(*uintptr)(unsafe.Pointer(v89))
		*(*uintptr)(unsafe.Pointer(v89))++
		*(*uint8)(unsafe.Pointer(v88)) = libc.Uint8FromInt32(int32(INST_LSET_LIST))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LSET_LIST)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v90 = delta1
			v91 = envPtr2
			if v90 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v91)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v91)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v91)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v91)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v91 + 64)) += int64(v90)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v93 = envPtr2 + 152
		v92 = *(*uintptr)(unsafe.Pointer(v93))
		*(*uintptr)(unsafe.Pointer(v93))++
		*(*uint8)(unsafe.Pointer(v92)) = libc.Uint8FromInt32(int32(INST_LSET_FLAT))
		v95 = envPtr2 + 152
		v94 = *(*uintptr)(unsafe.Pointer(v95))
		*(*uintptr)(unsafe.Pointer(v95))++
		*(*uint8)(unsafe.Pointer(v94)) = uint8(libc.Uint32FromInt64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords-libc.Int64FromInt32(1)) >> libc.Int32FromInt32(24))
		v97 = envPtr2 + 152
		v96 = *(*uintptr)(unsafe.Pointer(v97))
		*(*uintptr)(unsafe.Pointer(v97))++
		*(*uint8)(unsafe.Pointer(v96)) = uint8(libc.Uint32FromInt64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords-libc.Int64FromInt32(1)) >> libc.Int32FromInt32(16))
		v99 = envPtr2 + 152
		v98 = *(*uintptr)(unsafe.Pointer(v99))
		*(*uintptr)(unsafe.Pointer(v99))++
		*(*uint8)(unsafe.Pointer(v98)) = uint8(libc.Uint32FromInt64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords-libc.Int64FromInt32(1)) >> libc.Int32FromInt32(8))
		v101 = envPtr2 + 152
		v100 = *(*uintptr)(unsafe.Pointer(v101))
		*(*uintptr)(unsafe.Pointer(v101))++
		*(*uint8)(unsafe.Pointer(v100)) = uint8(libc.Uint32FromInt64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords - libc.Int64FromInt32(1)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LSET_FLAT)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords-int64(1))
			}
			v102 = delta1
			v103 = envPtr2
			if v102 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v103)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v103)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v103)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v103)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v103 + 64)) += int64(v102)
		}
	}
	/*
	 * Emit code to put the value back in the variable.
	 */
	if *(*int32)(unsafe.Pointer(bp + 4)) != 0 {
		if *(*int32)(unsafe.Pointer(bp)) < 0 {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v105 = envPtr2 + 152
			v104 = *(*uintptr)(unsafe.Pointer(v105))
			*(*uintptr)(unsafe.Pointer(v105))++
			*(*uint8)(unsafe.Pointer(v104)) = libc.Uint8FromInt32(int32(INST_STORE_STK))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STORE_STK)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v106 = delta1
				v107 = envPtr2
				if v106 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v107)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v107)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v107)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v107)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v107 + 64)) += int64(v106)
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp)) <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v109 = envPtr2 + 152
				v108 = *(*uintptr)(unsafe.Pointer(v109))
				*(*uintptr)(unsafe.Pointer(v109))++
				*(*uint8)(unsafe.Pointer(v108)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
				v111 = envPtr2 + 152
				v110 = *(*uintptr)(unsafe.Pointer(v111))
				*(*uintptr)(unsafe.Pointer(v111))++
				*(*uint8)(unsafe.Pointer(v110)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp))
					}
					v112 = delta1
					v113 = envPtr2
					if v112 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v113)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v113)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v113)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v113)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v113 + 64)) += int64(v112)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v115 = envPtr2 + 152
				v114 = *(*uintptr)(unsafe.Pointer(v115))
				*(*uintptr)(unsafe.Pointer(v115))++
				*(*uint8)(unsafe.Pointer(v114)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
				v117 = envPtr2 + 152
				v116 = *(*uintptr)(unsafe.Pointer(v117))
				*(*uintptr)(unsafe.Pointer(v117))++
				*(*uint8)(unsafe.Pointer(v116)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))) >> libc.Int32FromInt32(24))
				v119 = envPtr2 + 152
				v118 = *(*uintptr)(unsafe.Pointer(v119))
				*(*uintptr)(unsafe.Pointer(v119))++
				*(*uint8)(unsafe.Pointer(v118)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))) >> libc.Int32FromInt32(16))
				v121 = envPtr2 + 152
				v120 = *(*uintptr)(unsafe.Pointer(v121))
				*(*uintptr)(unsafe.Pointer(v121))++
				*(*uint8)(unsafe.Pointer(v120)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))) >> libc.Int32FromInt32(8))
				v123 = envPtr2 + 152
				v122 = *(*uintptr)(unsafe.Pointer(v123))
				*(*uintptr)(unsafe.Pointer(v123))++
				*(*uint8)(unsafe.Pointer(v122)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp))
					}
					v124 = delta1
					v125 = envPtr2
					if v124 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v125)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v125)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v125)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v125)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v125 + 64)) += int64(v124)
				}
			}
		}
	} else {
		if *(*int32)(unsafe.Pointer(bp)) < 0 {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v127 = envPtr2 + 152
			v126 = *(*uintptr)(unsafe.Pointer(v127))
			*(*uintptr)(unsafe.Pointer(v127))++
			*(*uint8)(unsafe.Pointer(v126)) = libc.Uint8FromInt32(int32(INST_STORE_ARRAY_STK))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STORE_ARRAY_STK)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v128 = delta1
				v129 = envPtr2
				if v128 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v129)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v129)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v129)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v129)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v129 + 64)) += int64(v128)
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp)) <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v131 = envPtr2 + 152
				v130 = *(*uintptr)(unsafe.Pointer(v131))
				*(*uintptr)(unsafe.Pointer(v131))++
				*(*uint8)(unsafe.Pointer(v130)) = libc.Uint8FromInt32(int32(INST_STORE_ARRAY1))
				v133 = envPtr2 + 152
				v132 = *(*uintptr)(unsafe.Pointer(v133))
				*(*uintptr)(unsafe.Pointer(v133))++
				*(*uint8)(unsafe.Pointer(v132)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_STORE_ARRAY1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp))
					}
					v134 = delta1
					v135 = envPtr2
					if v134 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v135)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v135)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v135)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v135)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v135 + 64)) += int64(v134)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v137 = envPtr2 + 152
				v136 = *(*uintptr)(unsafe.Pointer(v137))
				*(*uintptr)(unsafe.Pointer(v137))++
				*(*uint8)(unsafe.Pointer(v136)) = libc.Uint8FromInt32(int32(INST_STORE_ARRAY4))
				v139 = envPtr2 + 152
				v138 = *(*uintptr)(unsafe.Pointer(v139))
				*(*uintptr)(unsafe.Pointer(v139))++
				*(*uint8)(unsafe.Pointer(v138)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))) >> libc.Int32FromInt32(24))
				v141 = envPtr2 + 152
				v140 = *(*uintptr)(unsafe.Pointer(v141))
				*(*uintptr)(unsafe.Pointer(v141))++
				*(*uint8)(unsafe.Pointer(v140)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))) >> libc.Int32FromInt32(16))
				v143 = envPtr2 + 152
				v142 = *(*uintptr)(unsafe.Pointer(v143))
				*(*uintptr)(unsafe.Pointer(v143))++
				*(*uint8)(unsafe.Pointer(v142)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))) >> libc.Int32FromInt32(8))
				v145 = envPtr2 + 152
				v144 = *(*uintptr)(unsafe.Pointer(v145))
				*(*uintptr)(unsafe.Pointer(v145))++
				*(*uint8)(unsafe.Pointer(v144)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_STORE_ARRAY4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp))
					}
					v146 = delta1
					v147 = envPtr2
					if v146 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v147)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v147)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v147)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v147)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v147 + 64)) += int64(v146)
				}
			}
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileNamespace*Cmd --
 *
 *	Procedures called to compile the "namespace" command; currently, only
 *	the subcommands "namespace current" and "namespace upvar" are compiled
 *	to bytecodes, and the latter only inside a procedure(-like) context.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "namespace upvar"
 *	command at runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileNamespaceCurrentCmd(tls *libc.TLS, dummy1632 uintptr, parsePtr uintptr, dummy1635 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var delta1, v3 int32
	var v1, v2, v4 uintptr
	_, _, _, _, _ = delta1, v1, v2, v3, v4
	/*
	 * Only compile [namespace current] without arguments.
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(1) {
		return int32(TCL_ERROR)
	}
	/*
	 * Not much to do; we compile to a single instruction...
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v2 = envPtr2 + 152
	v1 = *(*uintptr)(unsafe.Pointer(v2))
	*(*uintptr)(unsafe.Pointer(v2))++
	*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_NS_CURRENT))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_NS_CURRENT)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v3 = delta1
		v4 = envPtr2
		if v3 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v4)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v4)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v4)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v4)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v4 + 64)) += int64(v3)
	}
	return TCL_OK
}

func XTclCompileNamespaceCodeCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy1659 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, delta1, v17, v23, v35, v39, v45, v5, v57, v69 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v36, v37, v38, v4, v40, v41, v42, v43, v44, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v7, v70, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, delta1, eclIndex, mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
		return int32(TCL_ERROR)
	}
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	/*
	 * The specification of [namespace code] is rather shocking, in that it is
	 * supposed to check if the argument is itself the result of [namespace
	 * code] and not apply itself in that case. Which is excessively cautious,
	 * but what the test suite checks for.
	 */
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) || (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize > int64(20) && libc.Xstrncmp(tls, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, __ccgo_ts+21788, uint64(20)) == 0 {
		/*
		 * Technically, we could just pass a literal '::namespace inscope '
		 * term through, but that's something which really shouldn't be
		 * occurring as something that the user writes so we'll just punt it.
		 */
		return int32(TCL_ERROR)
	}
	/*
	 * Now we can compile using the same strategy as [namespace code]'s normal
	 * implementation does internally. Note that we can't bind the namespace
	 * name directly here, because TclOO plays complex games with namespaces;
	 * the value needs to be determined at runtime for safety.
	 */
	_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+21809, libc.Int64FromUint64(libc.Uint64FromInt64(12)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v2 = envPtr2 + 152
		v1 = *(*uintptr)(unsafe.Pointer(v2))
		*(*uintptr)(unsafe.Pointer(v2))++
		*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v4 = envPtr2 + 152
		v3 = *(*uintptr)(unsafe.Pointer(v4))
		*(*uintptr)(unsafe.Pointer(v4))++
		*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v5 = delta1
			v6 = envPtr2
			if v5 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v8 = envPtr2 + 152
		v7 = *(*uintptr)(unsafe.Pointer(v8))
		*(*uintptr)(unsafe.Pointer(v8))++
		*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v10 = envPtr2 + 152
		v9 = *(*uintptr)(unsafe.Pointer(v10))
		*(*uintptr)(unsafe.Pointer(v10))++
		*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
		v12 = envPtr2 + 152
		v11 = *(*uintptr)(unsafe.Pointer(v12))
		*(*uintptr)(unsafe.Pointer(v12))++
		*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
		v14 = envPtr2 + 152
		v13 = *(*uintptr)(unsafe.Pointer(v14))
		*(*uintptr)(unsafe.Pointer(v14))++
		*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
		v16 = envPtr2 + 152
		v15 = *(*uintptr)(unsafe.Pointer(v16))
		*(*uintptr)(unsafe.Pointer(v16))++
		*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v17 = delta1
			v18 = envPtr2
			if v17 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
		}
	}
	_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+21821, libc.Int64FromUint64(libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy1 <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v20 = envPtr2 + 152
		v19 = *(*uintptr)(unsafe.Pointer(v20))
		*(*uintptr)(unsafe.Pointer(v20))++
		*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v22 = envPtr2 + 152
		v21 = *(*uintptr)(unsafe.Pointer(v22))
		*(*uintptr)(unsafe.Pointer(v22))++
		*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy1
			}
			v23 = delta1
			v24 = envPtr2
			if v23 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v24 + 64)) += int64(v23)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v26 = envPtr2 + 152
		v25 = *(*uintptr)(unsafe.Pointer(v26))
		*(*uintptr)(unsafe.Pointer(v26))++
		*(*uint8)(unsafe.Pointer(v25)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v28 = envPtr2 + 152
		v27 = *(*uintptr)(unsafe.Pointer(v28))
		*(*uintptr)(unsafe.Pointer(v28))++
		*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
		v30 = envPtr2 + 152
		v29 = *(*uintptr)(unsafe.Pointer(v30))
		*(*uintptr)(unsafe.Pointer(v30))++
		*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
		v32 = envPtr2 + 152
		v31 = *(*uintptr)(unsafe.Pointer(v32))
		*(*uintptr)(unsafe.Pointer(v32))++
		*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
		v34 = envPtr2 + 152
		v33 = *(*uintptr)(unsafe.Pointer(v34))
		*(*uintptr)(unsafe.Pointer(v34))++
		*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy1
			}
			v35 = delta1
			v36 = envPtr2
			if v35 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v36 + 64)) += int64(v35)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v38 = envPtr2 + 152
	v37 = *(*uintptr)(unsafe.Pointer(v38))
	*(*uintptr)(unsafe.Pointer(v38))++
	*(*uint8)(unsafe.Pointer(v37)) = libc.Uint8FromInt32(int32(INST_NS_CURRENT))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_NS_CURRENT)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v39 = delta1
		v40 = envPtr2
		if v39 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v40 + 64)) += int64(v39)
	}
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy2 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v42 = envPtr2 + 152
			v41 = *(*uintptr)(unsafe.Pointer(v42))
			*(*uintptr)(unsafe.Pointer(v42))++
			*(*uint8)(unsafe.Pointer(v41)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v44 = envPtr2 + 152
			v43 = *(*uintptr)(unsafe.Pointer(v44))
			*(*uintptr)(unsafe.Pointer(v44))++
			*(*uint8)(unsafe.Pointer(v43)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v45 = delta1
				v46 = envPtr2
				if v45 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v46)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v46)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v46)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v46)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v46 + 64)) += int64(v45)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v48 = envPtr2 + 152
			v47 = *(*uintptr)(unsafe.Pointer(v48))
			*(*uintptr)(unsafe.Pointer(v48))++
			*(*uint8)(unsafe.Pointer(v47)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v50 = envPtr2 + 152
			v49 = *(*uintptr)(unsafe.Pointer(v50))
			*(*uintptr)(unsafe.Pointer(v50))++
			*(*uint8)(unsafe.Pointer(v49)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
			v52 = envPtr2 + 152
			v51 = *(*uintptr)(unsafe.Pointer(v52))
			*(*uintptr)(unsafe.Pointer(v52))++
			*(*uint8)(unsafe.Pointer(v51)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
			v54 = envPtr2 + 152
			v53 = *(*uintptr)(unsafe.Pointer(v54))
			*(*uintptr)(unsafe.Pointer(v54))++
			*(*uint8)(unsafe.Pointer(v53)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
			v56 = envPtr2 + 152
			v55 = *(*uintptr)(unsafe.Pointer(v56))
			*(*uintptr)(unsafe.Pointer(v56))++
			*(*uint8)(unsafe.Pointer(v55)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v57 = delta1
				v58 = envPtr2
				if v57 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v58)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v58)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v58)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v58)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v58 + 64)) += int64(v57)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v60 = envPtr2 + 152
	v59 = *(*uintptr)(unsafe.Pointer(v60))
	*(*uintptr)(unsafe.Pointer(v60))++
	*(*uint8)(unsafe.Pointer(v59)) = libc.Uint8FromInt32(int32(INST_LIST))
	v62 = envPtr2 + 152
	v61 = *(*uintptr)(unsafe.Pointer(v62))
	*(*uintptr)(unsafe.Pointer(v62))++
	*(*uint8)(unsafe.Pointer(v61)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(4)) >> libc.Int32FromInt32(24))
	v64 = envPtr2 + 152
	v63 = *(*uintptr)(unsafe.Pointer(v64))
	*(*uintptr)(unsafe.Pointer(v64))++
	*(*uint8)(unsafe.Pointer(v63)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(4)) >> libc.Int32FromInt32(16))
	v66 = envPtr2 + 152
	v65 = *(*uintptr)(unsafe.Pointer(v66))
	*(*uintptr)(unsafe.Pointer(v66))++
	*(*uint8)(unsafe.Pointer(v65)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(4)) >> libc.Int32FromInt32(8))
	v68 = envPtr2 + 152
	v67 = *(*uintptr)(unsafe.Pointer(v68))
	*(*uintptr)(unsafe.Pointer(v68))++
	*(*uint8)(unsafe.Pointer(v67)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(4)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_LIST)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32(4)
		}
		v69 = delta1
		v70 = envPtr2
		if v69 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v70 + 64)) += int64(v69)
	}
	return TCL_OK
}

func XTclCompileNamespaceOriginCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy1708 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, delta1, v17, v21, v5 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v22, v3, v4, v6, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, eclIndex, mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v3, v4, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
		return int32(TCL_ERROR)
	}
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v20 = envPtr2 + 152
	v19 = *(*uintptr)(unsafe.Pointer(v20))
	*(*uintptr)(unsafe.Pointer(v20))++
	*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_ORIGIN_COMMAND))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_ORIGIN_COMMAND)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v21 = delta1
		v22 = envPtr2
		if v21 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v22 + 64)) += int64(v21)
	}
	return TCL_OK
}

func XTclCompileNamespaceQualifiersCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy1729 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, _objIndexCopy4, delta1, off, v103, v115, v119, v125, v137, v141, v147, v151, v17, v23, v35, v41, v5, v53, v65, v69, v75, v87, v91 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v100, v101, v102, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v116, v117, v118, v12, v120, v121, v122, v123, v124, v126, v127, v128, v129, v13, v130, v131, v132, v133, v134, v135, v136, v138, v139, v14, v140, v142, v143, v144, v145, v146, v148, v149, v15, v150, v152, v16, v18, v19, v2, v20, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v36, v37, v38, v39, v4, v40, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v66, v67, v68, v7, v70, v71, v72, v73, v74, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v88, v89, v9, v90, v92, v93, v94, v95, v96, v97, v98, v99 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, _objIndexCopy4, delta1, eclIndex, mapPtr, off, tokenPtr, v1, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v123, v124, v125, v126, v127, v128, v129, v13, v130, v131, v132, v133, v134, v135, v136, v137, v138, v139, v14, v140, v141, v142, v143, v144, v145, v146, v147, v148, v149, v15, v150, v151, v152, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1) /* TIP #280 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+14828, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy1 <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v20 = envPtr2 + 152
		v19 = *(*uintptr)(unsafe.Pointer(v20))
		*(*uintptr)(unsafe.Pointer(v20))++
		*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v22 = envPtr2 + 152
		v21 = *(*uintptr)(unsafe.Pointer(v22))
		*(*uintptr)(unsafe.Pointer(v22))++
		*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy1
			}
			v23 = delta1
			v24 = envPtr2
			if v23 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v24 + 64)) += int64(v23)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v26 = envPtr2 + 152
		v25 = *(*uintptr)(unsafe.Pointer(v26))
		*(*uintptr)(unsafe.Pointer(v26))++
		*(*uint8)(unsafe.Pointer(v25)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v28 = envPtr2 + 152
		v27 = *(*uintptr)(unsafe.Pointer(v28))
		*(*uintptr)(unsafe.Pointer(v28))++
		*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
		v30 = envPtr2 + 152
		v29 = *(*uintptr)(unsafe.Pointer(v30))
		*(*uintptr)(unsafe.Pointer(v30))++
		*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
		v32 = envPtr2 + 152
		v31 = *(*uintptr)(unsafe.Pointer(v32))
		*(*uintptr)(unsafe.Pointer(v32))++
		*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
		v34 = envPtr2 + 152
		v33 = *(*uintptr)(unsafe.Pointer(v34))
		*(*uintptr)(unsafe.Pointer(v34))++
		*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy1
			}
			v35 = delta1
			v36 = envPtr2
			if v35 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v36 + 64)) += int64(v35)
		}
	}
	_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+7650, libc.Int64FromUint64(libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy2 <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v38 = envPtr2 + 152
		v37 = *(*uintptr)(unsafe.Pointer(v38))
		*(*uintptr)(unsafe.Pointer(v38))++
		*(*uint8)(unsafe.Pointer(v37)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v40 = envPtr2 + 152
		v39 = *(*uintptr)(unsafe.Pointer(v40))
		*(*uintptr)(unsafe.Pointer(v40))++
		*(*uint8)(unsafe.Pointer(v39)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy2
			}
			v41 = delta1
			v42 = envPtr2
			if v41 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v42)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v42)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v42)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v42)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v42 + 64)) += int64(v41)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v44 = envPtr2 + 152
		v43 = *(*uintptr)(unsafe.Pointer(v44))
		*(*uintptr)(unsafe.Pointer(v44))++
		*(*uint8)(unsafe.Pointer(v43)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v46 = envPtr2 + 152
		v45 = *(*uintptr)(unsafe.Pointer(v46))
		*(*uintptr)(unsafe.Pointer(v46))++
		*(*uint8)(unsafe.Pointer(v45)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
		v48 = envPtr2 + 152
		v47 = *(*uintptr)(unsafe.Pointer(v48))
		*(*uintptr)(unsafe.Pointer(v48))++
		*(*uint8)(unsafe.Pointer(v47)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
		v50 = envPtr2 + 152
		v49 = *(*uintptr)(unsafe.Pointer(v50))
		*(*uintptr)(unsafe.Pointer(v50))++
		*(*uint8)(unsafe.Pointer(v49)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
		v52 = envPtr2 + 152
		v51 = *(*uintptr)(unsafe.Pointer(v52))
		*(*uintptr)(unsafe.Pointer(v52))++
		*(*uint8)(unsafe.Pointer(v51)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy2
			}
			v53 = delta1
			v54 = envPtr2
			if v53 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v54)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v54)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v54)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v54)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v54 + 64)) += int64(v53)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v56 = envPtr2 + 152
	v55 = *(*uintptr)(unsafe.Pointer(v56))
	*(*uintptr)(unsafe.Pointer(v56))++
	*(*uint8)(unsafe.Pointer(v55)) = libc.Uint8FromInt32(int32(INST_OVER))
	v58 = envPtr2 + 152
	v57 = *(*uintptr)(unsafe.Pointer(v58))
	*(*uintptr)(unsafe.Pointer(v58))++
	*(*uint8)(unsafe.Pointer(v57)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
	v60 = envPtr2 + 152
	v59 = *(*uintptr)(unsafe.Pointer(v60))
	*(*uintptr)(unsafe.Pointer(v60))++
	*(*uint8)(unsafe.Pointer(v59)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
	v62 = envPtr2 + 152
	v61 = *(*uintptr)(unsafe.Pointer(v62))
	*(*uintptr)(unsafe.Pointer(v62))++
	*(*uint8)(unsafe.Pointer(v61)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
	v64 = envPtr2 + 152
	v63 = *(*uintptr)(unsafe.Pointer(v64))
	*(*uintptr)(unsafe.Pointer(v64))++
	*(*uint8)(unsafe.Pointer(v63)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_OVER)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32(2)
		}
		v65 = delta1
		v66 = envPtr2
		if v65 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v66)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v66)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v66)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v66)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v66 + 64)) += int64(v65)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v68 = envPtr2 + 152
	v67 = *(*uintptr)(unsafe.Pointer(v68))
	*(*uintptr)(unsafe.Pointer(v68))++
	*(*uint8)(unsafe.Pointer(v67)) = libc.Uint8FromInt32(int32(INST_STR_FIND_LAST))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_STR_FIND_LAST)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v69 = delta1
		v70 = envPtr2
		if v69 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v70 + 64)) += int64(v69)
	}
	off = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
	_objIndexCopy3 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+21397, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy3 <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v72 = envPtr2 + 152
		v71 = *(*uintptr)(unsafe.Pointer(v72))
		*(*uintptr)(unsafe.Pointer(v72))++
		*(*uint8)(unsafe.Pointer(v71)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v74 = envPtr2 + 152
		v73 = *(*uintptr)(unsafe.Pointer(v74))
		*(*uintptr)(unsafe.Pointer(v74))++
		*(*uint8)(unsafe.Pointer(v73)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy3
			}
			v75 = delta1
			v76 = envPtr2
			if v75 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v76)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v76)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v76)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v76)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v76 + 64)) += int64(v75)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v78 = envPtr2 + 152
		v77 = *(*uintptr)(unsafe.Pointer(v78))
		*(*uintptr)(unsafe.Pointer(v78))++
		*(*uint8)(unsafe.Pointer(v77)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v80 = envPtr2 + 152
		v79 = *(*uintptr)(unsafe.Pointer(v80))
		*(*uintptr)(unsafe.Pointer(v80))++
		*(*uint8)(unsafe.Pointer(v79)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(24))
		v82 = envPtr2 + 152
		v81 = *(*uintptr)(unsafe.Pointer(v82))
		*(*uintptr)(unsafe.Pointer(v82))++
		*(*uint8)(unsafe.Pointer(v81)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(16))
		v84 = envPtr2 + 152
		v83 = *(*uintptr)(unsafe.Pointer(v84))
		*(*uintptr)(unsafe.Pointer(v84))++
		*(*uint8)(unsafe.Pointer(v83)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(8))
		v86 = envPtr2 + 152
		v85 = *(*uintptr)(unsafe.Pointer(v86))
		*(*uintptr)(unsafe.Pointer(v86))++
		*(*uint8)(unsafe.Pointer(v85)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy3
			}
			v87 = delta1
			v88 = envPtr2
			if v87 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v88)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v88)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v88)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v88)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v88 + 64)) += int64(v87)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v90 = envPtr2 + 152
	v89 = *(*uintptr)(unsafe.Pointer(v90))
	*(*uintptr)(unsafe.Pointer(v90))++
	*(*uint8)(unsafe.Pointer(v89)) = libc.Uint8FromInt32(int32(INST_SUB))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_SUB)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v91 = delta1
		v92 = envPtr2
		if v91 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v92)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v92)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v92)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v92)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v92 + 64)) += int64(v91)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v94 = envPtr2 + 152
	v93 = *(*uintptr)(unsafe.Pointer(v94))
	*(*uintptr)(unsafe.Pointer(v94))++
	*(*uint8)(unsafe.Pointer(v93)) = libc.Uint8FromInt32(int32(INST_OVER))
	v96 = envPtr2 + 152
	v95 = *(*uintptr)(unsafe.Pointer(v96))
	*(*uintptr)(unsafe.Pointer(v96))++
	*(*uint8)(unsafe.Pointer(v95)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
	v98 = envPtr2 + 152
	v97 = *(*uintptr)(unsafe.Pointer(v98))
	*(*uintptr)(unsafe.Pointer(v98))++
	*(*uint8)(unsafe.Pointer(v97)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
	v100 = envPtr2 + 152
	v99 = *(*uintptr)(unsafe.Pointer(v100))
	*(*uintptr)(unsafe.Pointer(v100))++
	*(*uint8)(unsafe.Pointer(v99)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
	v102 = envPtr2 + 152
	v101 = *(*uintptr)(unsafe.Pointer(v102))
	*(*uintptr)(unsafe.Pointer(v102))++
	*(*uint8)(unsafe.Pointer(v101)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_OVER)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32(2)
		}
		v103 = delta1
		v104 = envPtr2
		if v103 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v104)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v104)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v104)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v104)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v104 + 64)) += int64(v103)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v106 = envPtr2 + 152
	v105 = *(*uintptr)(unsafe.Pointer(v106))
	*(*uintptr)(unsafe.Pointer(v106))++
	*(*uint8)(unsafe.Pointer(v105)) = libc.Uint8FromInt32(int32(INST_OVER))
	v108 = envPtr2 + 152
	v107 = *(*uintptr)(unsafe.Pointer(v108))
	*(*uintptr)(unsafe.Pointer(v108))++
	*(*uint8)(unsafe.Pointer(v107)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(24))
	v110 = envPtr2 + 152
	v109 = *(*uintptr)(unsafe.Pointer(v110))
	*(*uintptr)(unsafe.Pointer(v110))++
	*(*uint8)(unsafe.Pointer(v109)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(16))
	v112 = envPtr2 + 152
	v111 = *(*uintptr)(unsafe.Pointer(v112))
	*(*uintptr)(unsafe.Pointer(v112))++
	*(*uint8)(unsafe.Pointer(v111)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(8))
	v114 = envPtr2 + 152
	v113 = *(*uintptr)(unsafe.Pointer(v114))
	*(*uintptr)(unsafe.Pointer(v114))++
	*(*uint8)(unsafe.Pointer(v113)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_OVER)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32(1)
		}
		v115 = delta1
		v116 = envPtr2
		if v115 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v116)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v116)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v116)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v116)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v116 + 64)) += int64(v115)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v118 = envPtr2 + 152
	v117 = *(*uintptr)(unsafe.Pointer(v118))
	*(*uintptr)(unsafe.Pointer(v118))++
	*(*uint8)(unsafe.Pointer(v117)) = libc.Uint8FromInt32(int32(INST_STR_INDEX))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_STR_INDEX)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v119 = delta1
		v120 = envPtr2
		if v119 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v120)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v120)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v120)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v120)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v120 + 64)) += int64(v119)
	}
	_objIndexCopy4 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+21829, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy4 <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v122 = envPtr2 + 152
		v121 = *(*uintptr)(unsafe.Pointer(v122))
		*(*uintptr)(unsafe.Pointer(v122))++
		*(*uint8)(unsafe.Pointer(v121)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v124 = envPtr2 + 152
		v123 = *(*uintptr)(unsafe.Pointer(v124))
		*(*uintptr)(unsafe.Pointer(v124))++
		*(*uint8)(unsafe.Pointer(v123)) = uint8(libc.Uint32FromInt32(_objIndexCopy4))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy4
			}
			v125 = delta1
			v126 = envPtr2
			if v125 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v126)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v126)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v126)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v126)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v126 + 64)) += int64(v125)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v128 = envPtr2 + 152
		v127 = *(*uintptr)(unsafe.Pointer(v128))
		*(*uintptr)(unsafe.Pointer(v128))++
		*(*uint8)(unsafe.Pointer(v127)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v130 = envPtr2 + 152
		v129 = *(*uintptr)(unsafe.Pointer(v130))
		*(*uintptr)(unsafe.Pointer(v130))++
		*(*uint8)(unsafe.Pointer(v129)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(24))
		v132 = envPtr2 + 152
		v131 = *(*uintptr)(unsafe.Pointer(v132))
		*(*uintptr)(unsafe.Pointer(v132))++
		*(*uint8)(unsafe.Pointer(v131)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(16))
		v134 = envPtr2 + 152
		v133 = *(*uintptr)(unsafe.Pointer(v134))
		*(*uintptr)(unsafe.Pointer(v134))++
		*(*uint8)(unsafe.Pointer(v133)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(8))
		v136 = envPtr2 + 152
		v135 = *(*uintptr)(unsafe.Pointer(v136))
		*(*uintptr)(unsafe.Pointer(v136))++
		*(*uint8)(unsafe.Pointer(v135)) = uint8(libc.Uint32FromInt32(_objIndexCopy4))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy4
			}
			v137 = delta1
			v138 = envPtr2
			if v137 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v138)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v138)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v138)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v138)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v138 + 64)) += int64(v137)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v140 = envPtr2 + 152
	v139 = *(*uintptr)(unsafe.Pointer(v140))
	*(*uintptr)(unsafe.Pointer(v140))++
	*(*uint8)(unsafe.Pointer(v139)) = libc.Uint8FromInt32(int32(INST_STR_EQ))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_STR_EQ)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v141 = delta1
		v142 = envPtr2
		if v141 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v142)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v142)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v142)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v142)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v142 + 64)) += int64(v141)
	}
	off = int32(int64(off) - (int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v144 = envPtr2 + 152
	v143 = *(*uintptr)(unsafe.Pointer(v144))
	*(*uintptr)(unsafe.Pointer(v144))++
	*(*uint8)(unsafe.Pointer(v143)) = libc.Uint8FromInt32(int32(INST_JUMP_TRUE1))
	v146 = envPtr2 + 152
	v145 = *(*uintptr)(unsafe.Pointer(v146))
	*(*uintptr)(unsafe.Pointer(v146))++
	*(*uint8)(unsafe.Pointer(v145)) = uint8(libc.Uint32FromInt32(off))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_JUMP_TRUE1)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - off
		}
		v147 = delta1
		v148 = envPtr2
		if v147 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v148)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v148)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v148)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v148)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v148 + 64)) += int64(v147)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v150 = envPtr2 + 152
	v149 = *(*uintptr)(unsafe.Pointer(v150))
	*(*uintptr)(unsafe.Pointer(v150))++
	*(*uint8)(unsafe.Pointer(v149)) = libc.Uint8FromInt32(int32(INST_STR_RANGE))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_STR_RANGE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v151 = delta1
		v152 = envPtr2
		if v151 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v152)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v152)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v152)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v152)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v152 + 64)) += int64(v151)
	}
	return TCL_OK
}

func XTclCompileNamespaceTailCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy1764 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, _objIndexCopy4, delta1, v105, v117, v121, v17, v23, v35, v47, v5, v51, v55, v61, v73, v77, v83, v95, v99 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v100, v101, v102, v103, v104, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v118, v119, v12, v120, v122, v13, v14, v15, v16, v18, v19, v2, v20, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v48, v49, v50, v52, v53, v54, v56, v57, v58, v59, v6, v60, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v74, v75, v76, v78, v79, v8, v80, v81, v82, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v96, v97, v98 uintptr
	var _ /* jumpFixup at bp+0 */ TJumpFixup
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, _objIndexCopy4, delta1, eclIndex, mapPtr, tokenPtr, v1, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1) /* TIP #280 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
		return int32(TCL_ERROR)
	}
	/*
	 * Take care; only add 2 to found index if the string was actually found.
	 */
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+7650, libc.Int64FromUint64(libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy1 <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v20 = envPtr2 + 152
		v19 = *(*uintptr)(unsafe.Pointer(v20))
		*(*uintptr)(unsafe.Pointer(v20))++
		*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v22 = envPtr2 + 152
		v21 = *(*uintptr)(unsafe.Pointer(v22))
		*(*uintptr)(unsafe.Pointer(v22))++
		*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy1
			}
			v23 = delta1
			v24 = envPtr2
			if v23 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v24 + 64)) += int64(v23)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v26 = envPtr2 + 152
		v25 = *(*uintptr)(unsafe.Pointer(v26))
		*(*uintptr)(unsafe.Pointer(v26))++
		*(*uint8)(unsafe.Pointer(v25)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v28 = envPtr2 + 152
		v27 = *(*uintptr)(unsafe.Pointer(v28))
		*(*uintptr)(unsafe.Pointer(v28))++
		*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
		v30 = envPtr2 + 152
		v29 = *(*uintptr)(unsafe.Pointer(v30))
		*(*uintptr)(unsafe.Pointer(v30))++
		*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
		v32 = envPtr2 + 152
		v31 = *(*uintptr)(unsafe.Pointer(v32))
		*(*uintptr)(unsafe.Pointer(v32))++
		*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
		v34 = envPtr2 + 152
		v33 = *(*uintptr)(unsafe.Pointer(v34))
		*(*uintptr)(unsafe.Pointer(v34))++
		*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy1
			}
			v35 = delta1
			v36 = envPtr2
			if v35 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v36 + 64)) += int64(v35)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v38 = envPtr2 + 152
	v37 = *(*uintptr)(unsafe.Pointer(v38))
	*(*uintptr)(unsafe.Pointer(v38))++
	*(*uint8)(unsafe.Pointer(v37)) = libc.Uint8FromInt32(int32(INST_OVER))
	v40 = envPtr2 + 152
	v39 = *(*uintptr)(unsafe.Pointer(v40))
	*(*uintptr)(unsafe.Pointer(v40))++
	*(*uint8)(unsafe.Pointer(v39)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(24))
	v42 = envPtr2 + 152
	v41 = *(*uintptr)(unsafe.Pointer(v42))
	*(*uintptr)(unsafe.Pointer(v42))++
	*(*uint8)(unsafe.Pointer(v41)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(16))
	v44 = envPtr2 + 152
	v43 = *(*uintptr)(unsafe.Pointer(v44))
	*(*uintptr)(unsafe.Pointer(v44))++
	*(*uint8)(unsafe.Pointer(v43)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(8))
	v46 = envPtr2 + 152
	v45 = *(*uintptr)(unsafe.Pointer(v46))
	*(*uintptr)(unsafe.Pointer(v46))++
	*(*uint8)(unsafe.Pointer(v45)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_OVER)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32(1)
		}
		v47 = delta1
		v48 = envPtr2
		if v47 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v48)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v48)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v48)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v48)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v48 + 64)) += int64(v47)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v50 = envPtr2 + 152
	v49 = *(*uintptr)(unsafe.Pointer(v50))
	*(*uintptr)(unsafe.Pointer(v50))++
	*(*uint8)(unsafe.Pointer(v49)) = libc.Uint8FromInt32(int32(INST_STR_FIND_LAST))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_STR_FIND_LAST)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v51 = delta1
		v52 = envPtr2
		if v51 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v52)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v52)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v52)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v52)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v52 + 64)) += int64(v51)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v54 = envPtr2 + 152
	v53 = *(*uintptr)(unsafe.Pointer(v54))
	*(*uintptr)(unsafe.Pointer(v54))++
	*(*uint8)(unsafe.Pointer(v53)) = libc.Uint8FromInt32(int32(INST_DUP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_DUP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v55 = delta1
		v56 = envPtr2
		if v55 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v56)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v56)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v56)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v56)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v56 + 64)) += int64(v55)
	}
	_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+14828, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy2 <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v58 = envPtr2 + 152
		v57 = *(*uintptr)(unsafe.Pointer(v58))
		*(*uintptr)(unsafe.Pointer(v58))++
		*(*uint8)(unsafe.Pointer(v57)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v60 = envPtr2 + 152
		v59 = *(*uintptr)(unsafe.Pointer(v60))
		*(*uintptr)(unsafe.Pointer(v60))++
		*(*uint8)(unsafe.Pointer(v59)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy2
			}
			v61 = delta1
			v62 = envPtr2
			if v61 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v62)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v62)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v62)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v62)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v62 + 64)) += int64(v61)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v64 = envPtr2 + 152
		v63 = *(*uintptr)(unsafe.Pointer(v64))
		*(*uintptr)(unsafe.Pointer(v64))++
		*(*uint8)(unsafe.Pointer(v63)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v66 = envPtr2 + 152
		v65 = *(*uintptr)(unsafe.Pointer(v66))
		*(*uintptr)(unsafe.Pointer(v66))++
		*(*uint8)(unsafe.Pointer(v65)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
		v68 = envPtr2 + 152
		v67 = *(*uintptr)(unsafe.Pointer(v68))
		*(*uintptr)(unsafe.Pointer(v68))++
		*(*uint8)(unsafe.Pointer(v67)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
		v70 = envPtr2 + 152
		v69 = *(*uintptr)(unsafe.Pointer(v70))
		*(*uintptr)(unsafe.Pointer(v70))++
		*(*uint8)(unsafe.Pointer(v69)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
		v72 = envPtr2 + 152
		v71 = *(*uintptr)(unsafe.Pointer(v72))
		*(*uintptr)(unsafe.Pointer(v72))++
		*(*uint8)(unsafe.Pointer(v71)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy2
			}
			v73 = delta1
			v74 = envPtr2
			if v73 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v74)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v74)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v74)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v74)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v74 + 64)) += int64(v73)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v76 = envPtr2 + 152
	v75 = *(*uintptr)(unsafe.Pointer(v76))
	*(*uintptr)(unsafe.Pointer(v76))++
	*(*uint8)(unsafe.Pointer(v75)) = libc.Uint8FromInt32(int32(INST_GE))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_GE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v77 = delta1
		v78 = envPtr2
		if v77 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v78)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v78)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v78)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v78)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v78 + 64)) += int64(v77)
	}
	XTclEmitForwardJump(tls, envPtr2, int32(TCL_FALSE_JUMP), bp)
	_objIndexCopy3 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+21831, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy3 <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v80 = envPtr2 + 152
		v79 = *(*uintptr)(unsafe.Pointer(v80))
		*(*uintptr)(unsafe.Pointer(v80))++
		*(*uint8)(unsafe.Pointer(v79)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v82 = envPtr2 + 152
		v81 = *(*uintptr)(unsafe.Pointer(v82))
		*(*uintptr)(unsafe.Pointer(v82))++
		*(*uint8)(unsafe.Pointer(v81)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy3
			}
			v83 = delta1
			v84 = envPtr2
			if v83 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v84)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v84)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v84)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v84)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v84 + 64)) += int64(v83)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v86 = envPtr2 + 152
		v85 = *(*uintptr)(unsafe.Pointer(v86))
		*(*uintptr)(unsafe.Pointer(v86))++
		*(*uint8)(unsafe.Pointer(v85)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v88 = envPtr2 + 152
		v87 = *(*uintptr)(unsafe.Pointer(v88))
		*(*uintptr)(unsafe.Pointer(v88))++
		*(*uint8)(unsafe.Pointer(v87)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(24))
		v90 = envPtr2 + 152
		v89 = *(*uintptr)(unsafe.Pointer(v90))
		*(*uintptr)(unsafe.Pointer(v90))++
		*(*uint8)(unsafe.Pointer(v89)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(16))
		v92 = envPtr2 + 152
		v91 = *(*uintptr)(unsafe.Pointer(v92))
		*(*uintptr)(unsafe.Pointer(v92))++
		*(*uint8)(unsafe.Pointer(v91)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(8))
		v94 = envPtr2 + 152
		v93 = *(*uintptr)(unsafe.Pointer(v94))
		*(*uintptr)(unsafe.Pointer(v94))++
		*(*uint8)(unsafe.Pointer(v93)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy3
			}
			v95 = delta1
			v96 = envPtr2
			if v95 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v96)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v96)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v96)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v96)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v96 + 64)) += int64(v95)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v98 = envPtr2 + 152
	v97 = *(*uintptr)(unsafe.Pointer(v98))
	*(*uintptr)(unsafe.Pointer(v98))++
	*(*uint8)(unsafe.Pointer(v97)) = libc.Uint8FromInt32(int32(INST_ADD))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_ADD)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v99 = delta1
		v100 = envPtr2
		if v99 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v100)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v100)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v100)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v100)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v100 + 64)) += int64(v99)
	}
	XTclFixupForwardJump(tls, envPtr2, bp, int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(libc.Int32FromUint32((*TJumpFixup)(unsafe.Pointer(bp)).FcodeOffset))), int32(127))
	_objIndexCopy4 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+21833, libc.Int64FromUint64(libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy4 <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v102 = envPtr2 + 152
		v101 = *(*uintptr)(unsafe.Pointer(v102))
		*(*uintptr)(unsafe.Pointer(v102))++
		*(*uint8)(unsafe.Pointer(v101)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v104 = envPtr2 + 152
		v103 = *(*uintptr)(unsafe.Pointer(v104))
		*(*uintptr)(unsafe.Pointer(v104))++
		*(*uint8)(unsafe.Pointer(v103)) = uint8(libc.Uint32FromInt32(_objIndexCopy4))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy4
			}
			v105 = delta1
			v106 = envPtr2
			if v105 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v106)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v106)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v106)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v106)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v106 + 64)) += int64(v105)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v108 = envPtr2 + 152
		v107 = *(*uintptr)(unsafe.Pointer(v108))
		*(*uintptr)(unsafe.Pointer(v108))++
		*(*uint8)(unsafe.Pointer(v107)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v110 = envPtr2 + 152
		v109 = *(*uintptr)(unsafe.Pointer(v110))
		*(*uintptr)(unsafe.Pointer(v110))++
		*(*uint8)(unsafe.Pointer(v109)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(24))
		v112 = envPtr2 + 152
		v111 = *(*uintptr)(unsafe.Pointer(v112))
		*(*uintptr)(unsafe.Pointer(v112))++
		*(*uint8)(unsafe.Pointer(v111)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(16))
		v114 = envPtr2 + 152
		v113 = *(*uintptr)(unsafe.Pointer(v114))
		*(*uintptr)(unsafe.Pointer(v114))++
		*(*uint8)(unsafe.Pointer(v113)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(8))
		v116 = envPtr2 + 152
		v115 = *(*uintptr)(unsafe.Pointer(v116))
		*(*uintptr)(unsafe.Pointer(v116))++
		*(*uint8)(unsafe.Pointer(v115)) = uint8(libc.Uint32FromInt32(_objIndexCopy4))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy4
			}
			v117 = delta1
			v118 = envPtr2
			if v117 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v118)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v118)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v118)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v118)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v118 + 64)) += int64(v117)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v120 = envPtr2 + 152
	v119 = *(*uintptr)(unsafe.Pointer(v120))
	*(*uintptr)(unsafe.Pointer(v120))++
	*(*uint8)(unsafe.Pointer(v119)) = libc.Uint8FromInt32(int32(INST_STR_RANGE))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_STR_RANGE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v121 = delta1
		v122 = envPtr2
		if v121 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v122)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v122)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v122)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v122)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v122 + 64)) += int64(v121)
	}
	return TCL_OK
}

func XTclCompileNamespaceUpvarCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy1800 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, delta1, i1, localIndex, numWords, v17, v24, v36, v48, v5, v52, v58, v70 int32
	var eclIndex TTcl_Size
	var localTokenPtr, mapPtr, otherTokenPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v2, v20, v21, v22, v23, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v49, v50, v51, v53, v54, v55, v56, v57, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v71, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, delta1, eclIndex, i1, localIndex, localTokenPtr, mapPtr, numWords, otherTokenPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FprocPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Only compile [namespace upvar ...]: needs an even number of args, >=4
	 */
	numWords = int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)
	if numWords%int32(2) != 0 || numWords < int32(4) {
		return int32(TCL_ERROR)
	}
	/*
	 * Push the namespace
	 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	/*
	 * Loop over the (otherVar, thisVar) pairs. If any of the thisVar is not a
	 * local variable, return an error so that the non-compiled command will
	 * be called at runtime.
	 */
	localTokenPtr = tokenPtr
	i1 = int32(2)
	for {
		if !(i1 < numWords) {
			break
		}
		otherTokenPtr = localTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(localTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		localTokenPtr = otherTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(otherTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if (*TTcl_Token)(unsafe.Pointer(otherTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(otherTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(otherTokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy1 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v21 = envPtr2 + 152
				v20 = *(*uintptr)(unsafe.Pointer(v21))
				*(*uintptr)(unsafe.Pointer(v21))++
				*(*uint8)(unsafe.Pointer(v20)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v23 = envPtr2 + 152
				v22 = *(*uintptr)(unsafe.Pointer(v23))
				*(*uintptr)(unsafe.Pointer(v23))++
				*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v24 = delta1
					v25 = envPtr2
					if v24 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v25 + 64)) += int64(v24)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v27 = envPtr2 + 152
				v26 = *(*uintptr)(unsafe.Pointer(v27))
				*(*uintptr)(unsafe.Pointer(v27))++
				*(*uint8)(unsafe.Pointer(v26)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v29 = envPtr2 + 152
				v28 = *(*uintptr)(unsafe.Pointer(v29))
				*(*uintptr)(unsafe.Pointer(v29))++
				*(*uint8)(unsafe.Pointer(v28)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
				v31 = envPtr2 + 152
				v30 = *(*uintptr)(unsafe.Pointer(v31))
				*(*uintptr)(unsafe.Pointer(v31))++
				*(*uint8)(unsafe.Pointer(v30)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
				v33 = envPtr2 + 152
				v32 = *(*uintptr)(unsafe.Pointer(v33))
				*(*uintptr)(unsafe.Pointer(v33))++
				*(*uint8)(unsafe.Pointer(v32)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
				v35 = envPtr2 + 152
				v34 = *(*uintptr)(unsafe.Pointer(v35))
				*(*uintptr)(unsafe.Pointer(v35))++
				*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v36 = delta1
					v37 = envPtr2
					if v36 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v37 + 64)) += int64(v36)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
			XTclCompileTokens(tls, interp, otherTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(otherTokenPtr)).FnumComponents), envPtr2)
		}
		localIndex = libc.Int32FromUint64(XTclLocalScalarFromToken(tls, localTokenPtr, envPtr2))
		if localIndex < 0 {
			return int32(TCL_ERROR)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v39 = envPtr2 + 152
		v38 = *(*uintptr)(unsafe.Pointer(v39))
		*(*uintptr)(unsafe.Pointer(v39))++
		*(*uint8)(unsafe.Pointer(v38)) = libc.Uint8FromInt32(int32(INST_NSUPVAR))
		v41 = envPtr2 + 152
		v40 = *(*uintptr)(unsafe.Pointer(v41))
		*(*uintptr)(unsafe.Pointer(v41))++
		*(*uint8)(unsafe.Pointer(v40)) = uint8(libc.Uint32FromInt32(localIndex) >> libc.Int32FromInt32(24))
		v43 = envPtr2 + 152
		v42 = *(*uintptr)(unsafe.Pointer(v43))
		*(*uintptr)(unsafe.Pointer(v43))++
		*(*uint8)(unsafe.Pointer(v42)) = uint8(libc.Uint32FromInt32(localIndex) >> libc.Int32FromInt32(16))
		v45 = envPtr2 + 152
		v44 = *(*uintptr)(unsafe.Pointer(v45))
		*(*uintptr)(unsafe.Pointer(v45))++
		*(*uint8)(unsafe.Pointer(v44)) = uint8(libc.Uint32FromInt32(localIndex) >> libc.Int32FromInt32(8))
		v47 = envPtr2 + 152
		v46 = *(*uintptr)(unsafe.Pointer(v47))
		*(*uintptr)(unsafe.Pointer(v47))++
		*(*uint8)(unsafe.Pointer(v46)) = uint8(libc.Uint32FromInt32(localIndex))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_NSUPVAR)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - localIndex
			}
			v48 = delta1
			v49 = envPtr2
			if v48 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v49)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v49)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v49)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v49)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v49 + 64)) += int64(v48)
		}
		goto _19
	_19:
		;
		i1 += int32(2)
	}
	/*
	 * Pop the namespace, and set the result to empty
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v51 = envPtr2 + 152
	v50 = *(*uintptr)(unsafe.Pointer(v51))
	*(*uintptr)(unsafe.Pointer(v51))++
	*(*uint8)(unsafe.Pointer(v50)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v52 = delta1
		v53 = envPtr2
		if v52 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v53)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v53)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v53)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v53)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v53 + 64)) += int64(v52)
	}
	_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy2 <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v55 = envPtr2 + 152
		v54 = *(*uintptr)(unsafe.Pointer(v55))
		*(*uintptr)(unsafe.Pointer(v55))++
		*(*uint8)(unsafe.Pointer(v54)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v57 = envPtr2 + 152
		v56 = *(*uintptr)(unsafe.Pointer(v57))
		*(*uintptr)(unsafe.Pointer(v57))++
		*(*uint8)(unsafe.Pointer(v56)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy2
			}
			v58 = delta1
			v59 = envPtr2
			if v58 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v59)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v59)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v59)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v59)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v59 + 64)) += int64(v58)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v61 = envPtr2 + 152
		v60 = *(*uintptr)(unsafe.Pointer(v61))
		*(*uintptr)(unsafe.Pointer(v61))++
		*(*uint8)(unsafe.Pointer(v60)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v63 = envPtr2 + 152
		v62 = *(*uintptr)(unsafe.Pointer(v63))
		*(*uintptr)(unsafe.Pointer(v63))++
		*(*uint8)(unsafe.Pointer(v62)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
		v65 = envPtr2 + 152
		v64 = *(*uintptr)(unsafe.Pointer(v65))
		*(*uintptr)(unsafe.Pointer(v65))++
		*(*uint8)(unsafe.Pointer(v64)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
		v67 = envPtr2 + 152
		v66 = *(*uintptr)(unsafe.Pointer(v67))
		*(*uintptr)(unsafe.Pointer(v67))++
		*(*uint8)(unsafe.Pointer(v66)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
		v69 = envPtr2 + 152
		v68 = *(*uintptr)(unsafe.Pointer(v69))
		*(*uintptr)(unsafe.Pointer(v69))++
		*(*uint8)(unsafe.Pointer(v68)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy2
			}
			v70 = delta1
			v71 = envPtr2
			if v70 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v71)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v71)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v71)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v71)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v71 + 64)) += int64(v70)
		}
	}
	return TCL_OK
}

func XTclCompileNamespaceWhichCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy1860 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, delta1, idx, v17, v21, v5 int32
	var eclIndex TTcl_Size
	var mapPtr, opt, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v22, v3, v4, v6, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, eclIndex, idx, mapPtr, opt, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v3, v4, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) < int32(2) || int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) > int32(3) {
		return int32(TCL_ERROR)
	}
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	idx = int32(1)
	/*
	 * If there's an option, check that it's "-command". We don't handle
	 * "-variable" (currently) and anything else is an error.
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(3) {
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) {
			return int32(TCL_ERROR)
		}
		opt = tokenPtr + uintptr(1)*32
		if (*TTcl_Token)(unsafe.Pointer(opt)).Fsize < int64(2) || (*TTcl_Token)(unsafe.Pointer(opt)).Fsize > int64(8) || libc.Xstrncmp(tls, (*TTcl_Token)(unsafe.Pointer(opt)).Fstart, __ccgo_ts+18236, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(opt)).Fsize)) != 0 {
			return int32(TCL_ERROR)
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		idx++
	}
	/*
	 * Issue the bytecode.
	 */
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(idx)*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(idx)*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v20 = envPtr2 + 152
	v19 = *(*uintptr)(unsafe.Pointer(v20))
	*(*uintptr)(unsafe.Pointer(v20))++
	*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_RESOLVE_COMMAND))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_RESOLVE_COMMAND)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v21 = delta1
		v22 = envPtr2
		if v21 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v22 + 64)) += int64(v21)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileRegexpCmd --
 *
 *	Procedure called to compile the "regexp" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "regexp" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileRegexpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy1923 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(240)
	defer tls.Free(240) /* Holds the resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, cflags, delta1, i1, nocase, sawLast, simple, v18, v24, v36, v42, v54, v6, v60, v72, v76, v82, v84, v89 int32
	var eclIndex TTcl_Size
	var len1 Tsize_t
	var mapPtr, str, varTokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v19, v2, v20, v21, v22, v23, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v37, v38, v39, v4, v40, v41, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v55, v56, v57, v58, v59, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v73, v74, v75, v77, v78, v79, v8, v80, v81, v83, v85, v86, v87, v88, v9, v90 uintptr
	var _ /* ds at bp+8 */ TTcl_DString
	var _ /* exact at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, cflags, delta1, eclIndex, i1, len1, mapPtr, nocase, sawLast, simple, str, varTokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	/*
	 * We are only interested in compiling simple regexp cases. Currently
	 * supported compile cases are:
	 *   regexp ?-nocase? ?--? staticString $var
	 *   regexp ?-nocase? ?--? {^staticString$} $var
	 */
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) < int32(3) {
		return int32(TCL_ERROR)
	}
	simple = 0
	nocase = 0
	sawLast = 0
	varTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
	/*
	 * We only look for -nocase and -- as options. Everything else gets pushed
	 * to runtime execution. This is different than regexp's runtime option
	 * handling, but satisfies our stricter needs.
	 */
	i1 = int32(1)
	for {
		if !(i1 < int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-int32(2)) {
			break
		}
		varTokenPtr = varTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if (*TTcl_Token)(unsafe.Pointer(varTokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) {
			/*
			 * Not a simple string, so punt to runtime.
			 */
			return int32(TCL_ERROR)
		}
		str = (*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Fstart
		len1 = libc.Uint64FromInt64((*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Fsize)
		if len1 == uint64(2) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) == int32('-') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str + 1))) == int32('-') {
			sawLast++
			i1++
			break
		} else {
			if len1 > uint64(1) && libc.Xstrncmp(tls, str, __ccgo_ts+17555, len1) == 0 {
				nocase = int32(1)
			} else {
				/*
				 * Not an option we recognize.
				 */
				return int32(TCL_ERROR)
			}
		}
		goto _1
	_1:
		;
		i1++
	}
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-i1 != int32(2) {
		/*
		 * We don't support capturing to variables.
		 */
		return int32(TCL_ERROR)
	}
	/*
	 * Get the regexp string. If it is not a simple string or can't be
	 * converted to a glob pattern, push the word for the INST_REGEXP.
	 * Keep changes here in sync with TclCompileSwitchCmd Switch_Regexp.
	 */
	varTokenPtr = varTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(varTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		str = (*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Fstart
		len1 = libc.Uint64FromInt64((*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Fsize)
		/*
		 * If it has a '-', it could be an incorrectly formed regexp command.
		 */
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) == int32('-') && !(sawLast != 0) {
			return int32(TCL_ERROR)
		}
		if len1 == uint64(0) {
			/*
			 * The semantics of regexp are always match on re == "".
			 */
			_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+21397, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
			if _objIndexCopy <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v3 = envPtr2 + 152
				v2 = *(*uintptr)(unsafe.Pointer(v3))
				*(*uintptr)(unsafe.Pointer(v3))++
				*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v5 = envPtr2 + 152
				v4 = *(*uintptr)(unsafe.Pointer(v5))
				*(*uintptr)(unsafe.Pointer(v5))++
				*(*uint8)(unsafe.Pointer(v4)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v6 = delta1
					v7 = envPtr2
					if v6 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v7 + 64)) += int64(v6)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v9 = envPtr2 + 152
				v8 = *(*uintptr)(unsafe.Pointer(v9))
				*(*uintptr)(unsafe.Pointer(v9))++
				*(*uint8)(unsafe.Pointer(v8)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v11 = envPtr2 + 152
				v10 = *(*uintptr)(unsafe.Pointer(v11))
				*(*uintptr)(unsafe.Pointer(v11))++
				*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
				v13 = envPtr2 + 152
				v12 = *(*uintptr)(unsafe.Pointer(v13))
				*(*uintptr)(unsafe.Pointer(v13))++
				*(*uint8)(unsafe.Pointer(v12)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
				v15 = envPtr2 + 152
				v14 = *(*uintptr)(unsafe.Pointer(v15))
				*(*uintptr)(unsafe.Pointer(v15))++
				*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
				v17 = envPtr2 + 152
				v16 = *(*uintptr)(unsafe.Pointer(v17))
				*(*uintptr)(unsafe.Pointer(v17))++
				*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v18 = delta1
					v19 = envPtr2
					if v18 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v19 + 64)) += int64(v18)
				}
			}
			return TCL_OK
		}
		/*
		 * Attempt to convert pattern to glob.  If successful, push the
		 * converted pattern as a literal.
		 */
		if XTclReToGlob(tls, libc.UintptrFromInt32(0), (*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Fstart, libc.Int64FromUint64(len1), bp+8, bp, libc.UintptrFromInt32(0)) == TCL_OK {
			simple = int32(1)
			_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, (*TTcl_DString)(unsafe.Pointer(bp+8)).Fstring1, (*TTcl_DString)(unsafe.Pointer(bp+8)).Flength, 0)
			if _objIndexCopy1 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v21 = envPtr2 + 152
				v20 = *(*uintptr)(unsafe.Pointer(v21))
				*(*uintptr)(unsafe.Pointer(v21))++
				*(*uint8)(unsafe.Pointer(v20)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v23 = envPtr2 + 152
				v22 = *(*uintptr)(unsafe.Pointer(v23))
				*(*uintptr)(unsafe.Pointer(v23))++
				*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v24 = delta1
					v25 = envPtr2
					if v24 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v25 + 64)) += int64(v24)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v27 = envPtr2 + 152
				v26 = *(*uintptr)(unsafe.Pointer(v27))
				*(*uintptr)(unsafe.Pointer(v27))++
				*(*uint8)(unsafe.Pointer(v26)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v29 = envPtr2 + 152
				v28 = *(*uintptr)(unsafe.Pointer(v29))
				*(*uintptr)(unsafe.Pointer(v29))++
				*(*uint8)(unsafe.Pointer(v28)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
				v31 = envPtr2 + 152
				v30 = *(*uintptr)(unsafe.Pointer(v31))
				*(*uintptr)(unsafe.Pointer(v31))++
				*(*uint8)(unsafe.Pointer(v30)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
				v33 = envPtr2 + 152
				v32 = *(*uintptr)(unsafe.Pointer(v33))
				*(*uintptr)(unsafe.Pointer(v33))++
				*(*uint8)(unsafe.Pointer(v32)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
				v35 = envPtr2 + 152
				v34 = *(*uintptr)(unsafe.Pointer(v35))
				*(*uintptr)(unsafe.Pointer(v35))++
				*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v36 = delta1
					v37 = envPtr2
					if v36 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v37 + 64)) += int64(v36)
				}
			}
			XTcl_DStringFree(tls, bp+8)
		}
	}
	if !(simple != 0) {
		if (*TTcl_Token)(unsafe.Pointer(varTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy2 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v39 = envPtr2 + 152
				v38 = *(*uintptr)(unsafe.Pointer(v39))
				*(*uintptr)(unsafe.Pointer(v39))++
				*(*uint8)(unsafe.Pointer(v38)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v41 = envPtr2 + 152
				v40 = *(*uintptr)(unsafe.Pointer(v41))
				*(*uintptr)(unsafe.Pointer(v41))++
				*(*uint8)(unsafe.Pointer(v40)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy2
					}
					v42 = delta1
					v43 = envPtr2
					if v42 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v43)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v43)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v43)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v43)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v43 + 64)) += int64(v42)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v45 = envPtr2 + 152
				v44 = *(*uintptr)(unsafe.Pointer(v45))
				*(*uintptr)(unsafe.Pointer(v45))++
				*(*uint8)(unsafe.Pointer(v44)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v47 = envPtr2 + 152
				v46 = *(*uintptr)(unsafe.Pointer(v47))
				*(*uintptr)(unsafe.Pointer(v47))++
				*(*uint8)(unsafe.Pointer(v46)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
				v49 = envPtr2 + 152
				v48 = *(*uintptr)(unsafe.Pointer(v49))
				*(*uintptr)(unsafe.Pointer(v49))++
				*(*uint8)(unsafe.Pointer(v48)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
				v51 = envPtr2 + 152
				v50 = *(*uintptr)(unsafe.Pointer(v51))
				*(*uintptr)(unsafe.Pointer(v51))++
				*(*uint8)(unsafe.Pointer(v50)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
				v53 = envPtr2 + 152
				v52 = *(*uintptr)(unsafe.Pointer(v53))
				*(*uintptr)(unsafe.Pointer(v53))++
				*(*uint8)(unsafe.Pointer(v52)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy2
					}
					v54 = delta1
					v55 = envPtr2
					if v54 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v55)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v55)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v55)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v55)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v55 + 64)) += int64(v54)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(2))*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(2))*8))
			XTclCompileTokens(tls, interp, varTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents), envPtr2)
		}
	}
	/*
	 * Push the string arg.
	 */
	varTokenPtr = varTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(varTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy3 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy3 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v57 = envPtr2 + 152
			v56 = *(*uintptr)(unsafe.Pointer(v57))
			*(*uintptr)(unsafe.Pointer(v57))++
			*(*uint8)(unsafe.Pointer(v56)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v59 = envPtr2 + 152
			v58 = *(*uintptr)(unsafe.Pointer(v59))
			*(*uintptr)(unsafe.Pointer(v59))++
			*(*uint8)(unsafe.Pointer(v58)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy3
				}
				v60 = delta1
				v61 = envPtr2
				if v60 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v61)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v61)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v61)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v61)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v61 + 64)) += int64(v60)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v63 = envPtr2 + 152
			v62 = *(*uintptr)(unsafe.Pointer(v63))
			*(*uintptr)(unsafe.Pointer(v63))++
			*(*uint8)(unsafe.Pointer(v62)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v65 = envPtr2 + 152
			v64 = *(*uintptr)(unsafe.Pointer(v65))
			*(*uintptr)(unsafe.Pointer(v65))++
			*(*uint8)(unsafe.Pointer(v64)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(24))
			v67 = envPtr2 + 152
			v66 = *(*uintptr)(unsafe.Pointer(v67))
			*(*uintptr)(unsafe.Pointer(v67))++
			*(*uint8)(unsafe.Pointer(v66)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(16))
			v69 = envPtr2 + 152
			v68 = *(*uintptr)(unsafe.Pointer(v69))
			*(*uintptr)(unsafe.Pointer(v69))++
			*(*uint8)(unsafe.Pointer(v68)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(8))
			v71 = envPtr2 + 152
			v70 = *(*uintptr)(unsafe.Pointer(v71))
			*(*uintptr)(unsafe.Pointer(v71))++
			*(*uint8)(unsafe.Pointer(v70)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy3
				}
				v72 = delta1
				v73 = envPtr2
				if v72 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v73)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v73)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v73)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v73)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v73 + 64)) += int64(v72)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(1))*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(1))*8))
		XTclCompileTokens(tls, interp, varTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents), envPtr2)
	}
	if simple != 0 {
		if *(*int32)(unsafe.Pointer(bp)) != 0 && !(nocase != 0) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v75 = envPtr2 + 152
			v74 = *(*uintptr)(unsafe.Pointer(v75))
			*(*uintptr)(unsafe.Pointer(v75))++
			*(*uint8)(unsafe.Pointer(v74)) = libc.Uint8FromInt32(int32(INST_STR_EQ))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STR_EQ)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v76 = delta1
				v77 = envPtr2
				if v76 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v77)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v77)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v77)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v77)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v77 + 64)) += int64(v76)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v79 = envPtr2 + 152
			v78 = *(*uintptr)(unsafe.Pointer(v79))
			*(*uintptr)(unsafe.Pointer(v79))++
			*(*uint8)(unsafe.Pointer(v78)) = libc.Uint8FromInt32(int32(INST_STR_MATCH))
			v81 = envPtr2 + 152
			v80 = *(*uintptr)(unsafe.Pointer(v81))
			*(*uintptr)(unsafe.Pointer(v81))++
			*(*uint8)(unsafe.Pointer(v80)) = uint8(libc.Uint32FromInt32(nocase))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STR_MATCH)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - nocase
				}
				v82 = delta1
				v83 = envPtr2
				if v82 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v83)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v83)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v83)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v83)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v83 + 64)) += int64(v82)
			}
		}
	} else {
		if nocase != 0 {
			v84 = int32(TCL_REG_NOCASE)
		} else {
			v84 = 0
		}
		/*
		 * Pass correct RE compile flags.  We use only Int1 (8-bit), but
		 * that handles all the flags we want to pass.
		 * Don't use TCL_REG_NOSUB as we may have backrefs.
		 */
		cflags = int32(TCL_REG_ADVANCED) | v84
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v86 = envPtr2 + 152
		v85 = *(*uintptr)(unsafe.Pointer(v86))
		*(*uintptr)(unsafe.Pointer(v86))++
		*(*uint8)(unsafe.Pointer(v85)) = libc.Uint8FromInt32(int32(INST_REGEXP))
		v88 = envPtr2 + 152
		v87 = *(*uintptr)(unsafe.Pointer(v88))
		*(*uintptr)(unsafe.Pointer(v88))++
		*(*uint8)(unsafe.Pointer(v87)) = uint8(libc.Uint32FromInt32(cflags))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_REGEXP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - cflags
			}
			v89 = delta1
			v90 = envPtr2
			if v89 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v90)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v90)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v90)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v90)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v90 + 64)) += int64(v89)
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileRegsubCmd --
 *
 *	Procedure called to compile the "regsub" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "regsub" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileRegsubCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy2088 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(240)
	defer tls.Free(240) /* Holds the resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, delta1, result, v16, v28, v35, v47, v53, v65, v69 int32
	var _objPtr, _objPtr1, _objPtr2, bytes, cachePtr, cachePtr1, cachePtr2, mapPtr, patternObj, replacementObj, stringTokenPtr, tokenPtr, v11, v12, v13, v14, v15, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v29, v3, v30, v31, v32, v33, v34, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v48, v49, v5, v50, v51, v52, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63, v64, v66, v67, v68, v70, v72, v74, v8, v9 uintptr
	var eclIndex, v4, v71, v73 TTcl_Size
	var v1, v6, v7 bool
	var _ /* exact at bp+224 */ int32
	var _ /* len at bp+232 */ TTcl_Size
	var _ /* pattern at bp+0 */ TTcl_DString
	var _ /* quantified at bp+228 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objPtr, _objPtr1, _objPtr2, bytes, cachePtr, cachePtr1, cachePtr2, delta1, eclIndex, mapPtr, patternObj, replacementObj, result, stringTokenPtr, tokenPtr, v1, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v8, v9
	/*
	 * We only compile the case with [regsub -all] where the pattern is both
	 * known at compile time and simple (i.e., no RE metacharacters). That is,
	 * the pattern must be translatable into a glob like "*foo*" with no other
	 * glob metacharacters inside it; there must be some "foo" in there too.
	 * The substitution string must also be known at compile time and free of
	 * metacharacters ("\digit" and "&"). Finally, there must not be a
	 * variable mentioned in the [regsub] to write the result back to (because
	 * we can't get the count of substitutions that would be the result in
	 * that case). The key is that these are the conditions under which a
	 * [string map] could be used instead, in particular a [string map] of the
	 * form we can compile to bytecode.
	 *
	 * In short, we look for:
	 *
	 *   regsub -all [--] simpleRE string simpleReplacement
	 *
	 * The only optional part is the "--", and no other options are handled.
	 */
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	patternObj = libc.UintptrFromInt32(0)
	replacementObj = libc.UintptrFromInt32(0)
	result = int32(TCL_ERROR)
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) < int32(5) || int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) > int32(6) {
		return int32(TCL_ERROR)
	}
	/*
	 * Parse the "-all", which must be the first argument (other options not
	 * supported, non-"-all" substitution we can't compile).
	 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) || (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize != int64(4) || libc.Xstrncmp(tls, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, __ccgo_ts+17462, uint64(4)) != 0 {
		return int32(TCL_ERROR)
	}
	/*
	 * Get the pattern into patternObj, checking for "--" in the process.
	 */
	XTcl_DStringInit(tls, bp)
	tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		patternObj = XTclThreadAllocObj(tls)
	} else {
		patternObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(patternObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(patternObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(patternObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(patternObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(patternObj)).FtypePtr = libc.UintptrFromInt32(0)
	if !(XTclWordKnownAtCompileTime(tls, tokenPtr, patternObj) != 0) {
		goto done
	}
	if (*TTcl_Obj)(unsafe.Pointer(patternObj)).Fbytes != 0 {
		v2 = (*TTcl_Obj)(unsafe.Pointer(patternObj)).Fbytes
	} else {
		v2 = XTcl_GetStringFromObj(tls, patternObj, libc.UintptrFromInt32(0))
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) == int32('-') {
		if (*TTcl_Obj)(unsafe.Pointer(patternObj)).Fbytes != 0 {
			v3 = (*TTcl_Obj)(unsafe.Pointer(patternObj)).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, patternObj, libc.UintptrFromInt32(0))
		}
		if libc.Xstrcmp(tls, v3, __ccgo_ts+18684) != 0 || (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(5) {
			goto done
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		_objPtr = patternObj
		v5 = _objPtr
		v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
		*(*TTcl_Size)(unsafe.Pointer(v5))--
		if v4 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v6 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			patternObj = XTclThreadAllocObj(tls)
		} else {
			patternObj = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(patternObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(patternObj)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(patternObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(patternObj)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(patternObj)).FtypePtr = libc.UintptrFromInt32(0)
		if !(XTclWordKnownAtCompileTime(tls, tokenPtr, patternObj) != 0) {
			goto done
		}
	} else {
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(6) {
			goto done
		}
	}
	/*
	 * Identify the code which produces the string to apply the substitution
	 * to (stringTokenPtr), and the replacement string (into replacementObj).
	 */
	stringTokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	tokenPtr = stringTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(stringTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if v7 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v7 {
		cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v7 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
		replacementObj = XTclThreadAllocObj(tls)
	} else {
		replacementObj = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(replacementObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(replacementObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(replacementObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(replacementObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(replacementObj)).FtypePtr = libc.UintptrFromInt32(0)
	if !(XTclWordKnownAtCompileTime(tls, tokenPtr, replacementObj) != 0) {
		goto done
	}
	/*
	 * Next, higher-level checks. Is the RE a very simple glob? Is the
	 * replacement "simple"?
	 */
	if (*TTcl_Obj)(unsafe.Pointer(patternObj)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 232)) = (*TTcl_Obj)(unsafe.Pointer(patternObj)).Flength
		v8 = (*TTcl_Obj)(unsafe.Pointer(patternObj)).Fbytes
	} else {
		v8 = XTcl_GetStringFromObj(tls, patternObj, bp+232)
	}
	bytes = v8
	if XTclReToGlob(tls, libc.UintptrFromInt32(0), bytes, *(*TTcl_Size)(unsafe.Pointer(bp + 232)), bp, bp+224, bp+228) != TCL_OK || *(*int32)(unsafe.Pointer(bp + 224)) != 0 || *(*int32)(unsafe.Pointer(bp + 228)) != 0 {
		goto done
	}
	bytes = (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1
	v9 = bytes
	bytes++
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) != int32('*') {
		goto done
	}
	for int32(1) != 0 {
		switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes))) {
		case int32('*'):
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes + 1))) == int32('\000') {
				/*
				 * OK, we've proved there are no metacharacters except for the
				 * '*' at each end.
				 */
				*(*TTcl_Size)(unsafe.Pointer(bp + 232)) = (*TTcl_DString)(unsafe.Pointer(bp)).Flength - int64(2)
				if *(*TTcl_Size)(unsafe.Pointer(bp + 232))+int64(2) > int64(2) {
					goto isSimpleGlob
				}
				/*
				 * The pattern is "**"! I believe that should be impossible,
				 * but we definitely can't handle that at all.
				 */
			}
			fallthrough
		case int32('\000'):
			fallthrough
		case int32('?'):
			fallthrough
		case int32('['):
			fallthrough
		case int32('\\'):
			goto done
		}
		bytes++
	}
	goto isSimpleGlob
isSimpleGlob:
	;
	if (*TTcl_Obj)(unsafe.Pointer(replacementObj)).Fbytes != 0 {
		v11 = (*TTcl_Obj)(unsafe.Pointer(replacementObj)).Fbytes
	} else {
		v11 = XTcl_GetStringFromObj(tls, replacementObj, libc.UintptrFromInt32(0))
	}
	bytes = v11
	for {
		if !(*(*uint8)(unsafe.Pointer(bytes)) != 0) {
			break
		}
		switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes))) {
		case int32('\\'):
			fallthrough
		case int32('&'):
			goto done
		}
		goto _10
	_10:
		;
		bytes++
	}
	/*
	 * Proved the simplicity constraints! Time to issue the code.
	 */
	result = TCL_OK
	bytes = (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1 + uintptr(1)
	_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, bytes, *(*TTcl_Size)(unsafe.Pointer(bp + 232)), 0)
	if _objIndexCopy <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v13 = envPtr2 + 152
		v12 = *(*uintptr)(unsafe.Pointer(v13))
		*(*uintptr)(unsafe.Pointer(v13))++
		*(*uint8)(unsafe.Pointer(v12)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v15 = envPtr2 + 152
		v14 = *(*uintptr)(unsafe.Pointer(v15))
		*(*uintptr)(unsafe.Pointer(v15))++
		*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v16 = delta1
			v17 = envPtr2
			if v16 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v17)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v17)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v17)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v17)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v17 + 64)) += int64(v16)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v19 = envPtr2 + 152
		v18 = *(*uintptr)(unsafe.Pointer(v19))
		*(*uintptr)(unsafe.Pointer(v19))++
		*(*uint8)(unsafe.Pointer(v18)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v21 = envPtr2 + 152
		v20 = *(*uintptr)(unsafe.Pointer(v21))
		*(*uintptr)(unsafe.Pointer(v21))++
		*(*uint8)(unsafe.Pointer(v20)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
		v23 = envPtr2 + 152
		v22 = *(*uintptr)(unsafe.Pointer(v23))
		*(*uintptr)(unsafe.Pointer(v23))++
		*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
		v25 = envPtr2 + 152
		v24 = *(*uintptr)(unsafe.Pointer(v25))
		*(*uintptr)(unsafe.Pointer(v25))++
		*(*uint8)(unsafe.Pointer(v24)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
		v27 = envPtr2 + 152
		v26 = *(*uintptr)(unsafe.Pointer(v27))
		*(*uintptr)(unsafe.Pointer(v27))++
		*(*uint8)(unsafe.Pointer(v26)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v28 = delta1
			v29 = envPtr2
			if v28 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v29)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v29)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v29)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v29)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v29 + 64)) += int64(v28)
		}
	}
	if (*TTcl_Obj)(unsafe.Pointer(replacementObj)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 232)) = (*TTcl_Obj)(unsafe.Pointer(replacementObj)).Flength
		v30 = (*TTcl_Obj)(unsafe.Pointer(replacementObj)).Fbytes
	} else {
		v30 = XTcl_GetStringFromObj(tls, replacementObj, bp+232)
	}
	bytes = v30
	_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, bytes, *(*TTcl_Size)(unsafe.Pointer(bp + 232)), 0)
	if _objIndexCopy1 <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v32 = envPtr2 + 152
		v31 = *(*uintptr)(unsafe.Pointer(v32))
		*(*uintptr)(unsafe.Pointer(v32))++
		*(*uint8)(unsafe.Pointer(v31)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v34 = envPtr2 + 152
		v33 = *(*uintptr)(unsafe.Pointer(v34))
		*(*uintptr)(unsafe.Pointer(v34))++
		*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy1
			}
			v35 = delta1
			v36 = envPtr2
			if v35 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v36 + 64)) += int64(v35)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v38 = envPtr2 + 152
		v37 = *(*uintptr)(unsafe.Pointer(v38))
		*(*uintptr)(unsafe.Pointer(v38))++
		*(*uint8)(unsafe.Pointer(v37)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v40 = envPtr2 + 152
		v39 = *(*uintptr)(unsafe.Pointer(v40))
		*(*uintptr)(unsafe.Pointer(v40))++
		*(*uint8)(unsafe.Pointer(v39)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
		v42 = envPtr2 + 152
		v41 = *(*uintptr)(unsafe.Pointer(v42))
		*(*uintptr)(unsafe.Pointer(v42))++
		*(*uint8)(unsafe.Pointer(v41)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
		v44 = envPtr2 + 152
		v43 = *(*uintptr)(unsafe.Pointer(v44))
		*(*uintptr)(unsafe.Pointer(v44))++
		*(*uint8)(unsafe.Pointer(v43)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
		v46 = envPtr2 + 152
		v45 = *(*uintptr)(unsafe.Pointer(v46))
		*(*uintptr)(unsafe.Pointer(v46))++
		*(*uint8)(unsafe.Pointer(v45)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy1
			}
			v47 = delta1
			v48 = envPtr2
			if v47 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v48)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v48)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v48)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v48)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v48 + 64)) += int64(v47)
		}
	}
	if (*TTcl_Token)(unsafe.Pointer(stringTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(stringTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(stringTokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy2 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v50 = envPtr2 + 152
			v49 = *(*uintptr)(unsafe.Pointer(v50))
			*(*uintptr)(unsafe.Pointer(v50))++
			*(*uint8)(unsafe.Pointer(v49)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v52 = envPtr2 + 152
			v51 = *(*uintptr)(unsafe.Pointer(v52))
			*(*uintptr)(unsafe.Pointer(v52))++
			*(*uint8)(unsafe.Pointer(v51)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v53 = delta1
				v54 = envPtr2
				if v53 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v54)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v54)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v54)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v54)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v54 + 64)) += int64(v53)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v56 = envPtr2 + 152
			v55 = *(*uintptr)(unsafe.Pointer(v56))
			*(*uintptr)(unsafe.Pointer(v56))++
			*(*uint8)(unsafe.Pointer(v55)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v58 = envPtr2 + 152
			v57 = *(*uintptr)(unsafe.Pointer(v58))
			*(*uintptr)(unsafe.Pointer(v58))++
			*(*uint8)(unsafe.Pointer(v57)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
			v60 = envPtr2 + 152
			v59 = *(*uintptr)(unsafe.Pointer(v60))
			*(*uintptr)(unsafe.Pointer(v60))++
			*(*uint8)(unsafe.Pointer(v59)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
			v62 = envPtr2 + 152
			v61 = *(*uintptr)(unsafe.Pointer(v62))
			*(*uintptr)(unsafe.Pointer(v62))++
			*(*uint8)(unsafe.Pointer(v61)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
			v64 = envPtr2 + 152
			v63 = *(*uintptr)(unsafe.Pointer(v64))
			*(*uintptr)(unsafe.Pointer(v64))++
			*(*uint8)(unsafe.Pointer(v63)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v65 = delta1
				v66 = envPtr2
				if v65 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v66)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v66)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v66)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v66)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v66 + 64)) += int64(v65)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(2))*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(2))*8))
		XTclCompileTokens(tls, interp, stringTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(stringTokenPtr)).FnumComponents), envPtr2)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v68 = envPtr2 + 152
	v67 = *(*uintptr)(unsafe.Pointer(v68))
	*(*uintptr)(unsafe.Pointer(v68))++
	*(*uint8)(unsafe.Pointer(v67)) = libc.Uint8FromInt32(int32(INST_STR_MAP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_STR_MAP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v69 = delta1
		v70 = envPtr2
		if v69 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v70 + 64)) += int64(v69)
	}
	goto done
done:
	;
	XTcl_DStringFree(tls, bp)
	if patternObj != 0 {
		_objPtr1 = patternObj
		v72 = _objPtr1
		v71 = *(*TTcl_Size)(unsafe.Pointer(v72))
		*(*TTcl_Size)(unsafe.Pointer(v72))--
		if v71 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
	if replacementObj != 0 {
		_objPtr2 = replacementObj
		v74 = _objPtr2
		v73 = *(*TTcl_Size)(unsafe.Pointer(v74))
		*(*TTcl_Size)(unsafe.Pointer(v74))--
		if v73 <= int64(1) {
			XTclFreeObj(tls, _objPtr2)
		}
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileReturnCmd --
 *
 *	Procedure called to compile the "return" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "return" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileReturnCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy2263 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, _objIndexCopy4, _objIndexCopy5, _objIndexCopy6, delta1, enclosingCatch, explicitResult, index, numOptionWords, numWords, objc, status, v110, v122, v128, v140, v146, v158, v17, v23, v35, v43, v5, v51, v63, v69, v81, v87, v89, v98 int32
	var _objPtr, _objPtr1, cachePtr, cachePtr1, cachePtr2, mapPtr, msgTokenPtr, objv, optsTokenPtr, wordTokenPtr, v1, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v123, v124, v125, v126, v127, v129, v13, v130, v131, v132, v133, v134, v135, v136, v137, v138, v139, v14, v141, v142, v143, v144, v145, v147, v148, v149, v15, v150, v151, v152, v153, v154, v155, v156, v157, v159, v16, v18, v19, v2, v20, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v36, v4, v41, v45, v47, v48, v49, v50, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v64, v65, v66, v67, v68, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v82, v84, v85, v86, v88, v9, v90, v92, v94, v95, v96, v97, v99 uintptr
	var eclIndex, v40, v44, v83, v91 TTcl_Size
	var range1 TExceptionRange
	var v38, v42, v46 bool
	var _ /* code at bp+4 */ int32
	var _ /* level at bp+0 */ int32
	var _ /* returnOpts at bp+16 */ uintptr
	var _ /* size at bp+8 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, _objIndexCopy4, _objIndexCopy5, _objIndexCopy6, _objPtr, _objPtr1, cachePtr, cachePtr1, cachePtr2, delta1, eclIndex, enclosingCatch, explicitResult, index, mapPtr, msgTokenPtr, numOptionWords, numWords, objc, objv, optsTokenPtr, range1, status, wordTokenPtr, v1, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v123, v124, v125, v126, v127, v128, v129, v13, v130, v131, v132, v133, v134, v135, v136, v137, v138, v139, v14, v140, v141, v142, v143, v144, v145, v146, v147, v148, v149, v15, v150, v151, v152, v153, v154, v155, v156, v157, v158, v159, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v38, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v94, v95, v96, v97, v98, v99
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	status = TCL_OK
	numWords = int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)
	explicitResult = libc.BoolInt32(0 == numWords%int32(2))
	numOptionWords = numWords - int32(1) - explicitResult
	wordTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	/*
	 * Check for special case which can always be compiled:
	 *	    return -options <opts> <msg>
	 * Unlike the normal [return] compilation, this version does everything at
	 * runtime so it can handle arbitrary words and not just literals. Note
	 * that if INST_RETURN_STK wasn't already needed for something else
	 * ('finally' clause processing) this piece of code would not be present.
	 */
	if numWords == int32(4) && (*TTcl_Token)(unsafe.Pointer(wordTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) && (*(*TTcl_Token)(unsafe.Pointer(wordTokenPtr + 1*32))).Fsize == int64(8) && libc.Xstrncmp(tls, (*(*TTcl_Token)(unsafe.Pointer(wordTokenPtr + 1*32))).Fstart, __ccgo_ts+21837, uint64(8)) == 0 {
		optsTokenPtr = wordTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(wordTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		msgTokenPtr = optsTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(optsTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if (*TTcl_Token)(unsafe.Pointer(optsTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(optsTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(optsTokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v2 = envPtr2 + 152
				v1 = *(*uintptr)(unsafe.Pointer(v2))
				*(*uintptr)(unsafe.Pointer(v2))++
				*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v4 = envPtr2 + 152
				v3 = *(*uintptr)(unsafe.Pointer(v4))
				*(*uintptr)(unsafe.Pointer(v4))++
				*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v5 = delta1
					v6 = envPtr2
					if v5 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v8 = envPtr2 + 152
				v7 = *(*uintptr)(unsafe.Pointer(v8))
				*(*uintptr)(unsafe.Pointer(v8))++
				*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v10 = envPtr2 + 152
				v9 = *(*uintptr)(unsafe.Pointer(v10))
				*(*uintptr)(unsafe.Pointer(v10))++
				*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
				v12 = envPtr2 + 152
				v11 = *(*uintptr)(unsafe.Pointer(v12))
				*(*uintptr)(unsafe.Pointer(v12))++
				*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
				v14 = envPtr2 + 152
				v13 = *(*uintptr)(unsafe.Pointer(v14))
				*(*uintptr)(unsafe.Pointer(v14))++
				*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
				v16 = envPtr2 + 152
				v15 = *(*uintptr)(unsafe.Pointer(v16))
				*(*uintptr)(unsafe.Pointer(v16))++
				*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v17 = delta1
					v18 = envPtr2
					if v17 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
			XTclCompileTokens(tls, interp, optsTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(optsTokenPtr)).FnumComponents), envPtr2)
		}
		if (*TTcl_Token)(unsafe.Pointer(msgTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(msgTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(msgTokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy1 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v20 = envPtr2 + 152
				v19 = *(*uintptr)(unsafe.Pointer(v20))
				*(*uintptr)(unsafe.Pointer(v20))++
				*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v22 = envPtr2 + 152
				v21 = *(*uintptr)(unsafe.Pointer(v22))
				*(*uintptr)(unsafe.Pointer(v22))++
				*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v23 = delta1
					v24 = envPtr2
					if v23 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v24 + 64)) += int64(v23)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v26 = envPtr2 + 152
				v25 = *(*uintptr)(unsafe.Pointer(v26))
				*(*uintptr)(unsafe.Pointer(v26))++
				*(*uint8)(unsafe.Pointer(v25)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v28 = envPtr2 + 152
				v27 = *(*uintptr)(unsafe.Pointer(v28))
				*(*uintptr)(unsafe.Pointer(v28))++
				*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
				v30 = envPtr2 + 152
				v29 = *(*uintptr)(unsafe.Pointer(v30))
				*(*uintptr)(unsafe.Pointer(v30))++
				*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
				v32 = envPtr2 + 152
				v31 = *(*uintptr)(unsafe.Pointer(v32))
				*(*uintptr)(unsafe.Pointer(v32))++
				*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
				v34 = envPtr2 + 152
				v33 = *(*uintptr)(unsafe.Pointer(v34))
				*(*uintptr)(unsafe.Pointer(v34))++
				*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v35 = delta1
					v36 = envPtr2
					if v35 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v36 + 64)) += int64(v35)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 3*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 3*8))
			XTclCompileTokens(tls, interp, msgTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(msgTokenPtr)).FnumComponents), envPtr2)
		}
		XTclEmitInvoke(tls, envPtr2, int32(INST_RETURN_STK), 0)
		return TCL_OK
	}
	/*
	 * Allocate some working space.
	 */
	objv = XTclStackAlloc(tls, interp, libc.Uint64FromInt32(numOptionWords)*uint64(8))
	/*
	 * Scan through the return options. If any are unknown at compile time,
	 * there is no value in bytecompiling. Save the option values known in an
	 * objv array for merging into a return options dictionary.
	 *
	 * TODO: There is potential for improvement if all option keys are known
	 * at compile time and all option values relating to '-code' and '-level'
	 * are known at compile time.
	 */
	objc = 0
	for {
		if !(objc < numOptionWords) {
			break
		}
		if v38 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v38 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v38 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))).FtypePtr = libc.UintptrFromInt32(0)
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))).FrefCount++
		if !(XTclWordKnownAtCompileTime(tls, wordTokenPtr, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8))) != 0) {
			/*
			 * Non-literal, so punt to run-time assembly of the dictionary.
			 */
			for {
				if !(objc >= 0) {
					break
				}
				v41 = *(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8))
				v40 = *(*TTcl_Size)(unsafe.Pointer(v41))
				*(*TTcl_Size)(unsafe.Pointer(v41))--
				if !(v40 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))).Flength = int64(-libc.Int32FromInt32(1))
						if v42 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v42 {
							cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v42 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8))
							(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))
					}
				}
				goto _39
			_39:
				;
				objc--
			}
			XTclStackFree(tls, interp, objv)
			goto issueRuntimeReturn
		}
		wordTokenPtr = wordTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(wordTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		goto _37
	_37:
		;
		objc++
	}
	status = XTclMergeReturnOptions(tls, interp, objc, objv, bp+16, bp+4, bp)
	for {
		objc--
		v43 = objc
		if !(v43 >= 0) {
			break
		}
		v45 = *(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8))
		v44 = *(*TTcl_Size)(unsafe.Pointer(v45))
		*(*TTcl_Size)(unsafe.Pointer(v45))--
		if !(v44 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))).Flength = int64(-libc.Int32FromInt32(1))
				if v46 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v46 {
					cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v46 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8))
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))
			}
		}
	}
	XTclStackFree(tls, interp, objv)
	if int32(TCL_ERROR) == status {
		/*
		 * Something was bogus in the return options. Clear the error message,
		 * and report back to the compiler that this must be interpreted at
		 * runtime.
		 */
		XTcl_ResetResult(tls, interp)
		return int32(TCL_ERROR)
	}
	/*
	 * All options are known at compile time, so we're going to bytecompile.
	 * Emit instructions to push the result on the stack.
	 */
	if explicitResult != 0 {
		if (*TTcl_Token)(unsafe.Pointer(wordTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(wordTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(wordTokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy2 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v48 = envPtr2 + 152
				v47 = *(*uintptr)(unsafe.Pointer(v48))
				*(*uintptr)(unsafe.Pointer(v48))++
				*(*uint8)(unsafe.Pointer(v47)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v50 = envPtr2 + 152
				v49 = *(*uintptr)(unsafe.Pointer(v50))
				*(*uintptr)(unsafe.Pointer(v50))++
				*(*uint8)(unsafe.Pointer(v49)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy2
					}
					v51 = delta1
					v52 = envPtr2
					if v51 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v52)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v52)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v52)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v52)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v52 + 64)) += int64(v51)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v54 = envPtr2 + 152
				v53 = *(*uintptr)(unsafe.Pointer(v54))
				*(*uintptr)(unsafe.Pointer(v54))++
				*(*uint8)(unsafe.Pointer(v53)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v56 = envPtr2 + 152
				v55 = *(*uintptr)(unsafe.Pointer(v56))
				*(*uintptr)(unsafe.Pointer(v56))++
				*(*uint8)(unsafe.Pointer(v55)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
				v58 = envPtr2 + 152
				v57 = *(*uintptr)(unsafe.Pointer(v58))
				*(*uintptr)(unsafe.Pointer(v58))++
				*(*uint8)(unsafe.Pointer(v57)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
				v60 = envPtr2 + 152
				v59 = *(*uintptr)(unsafe.Pointer(v60))
				*(*uintptr)(unsafe.Pointer(v60))++
				*(*uint8)(unsafe.Pointer(v59)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
				v62 = envPtr2 + 152
				v61 = *(*uintptr)(unsafe.Pointer(v62))
				*(*uintptr)(unsafe.Pointer(v62))++
				*(*uint8)(unsafe.Pointer(v61)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy2
					}
					v63 = delta1
					v64 = envPtr2
					if v63 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v64)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v64)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v64)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v64)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v64 + 64)) += int64(v63)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(numWords-libc.Int32FromInt32(1))*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(numWords-libc.Int32FromInt32(1))*8))
			XTclCompileTokens(tls, interp, wordTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(wordTokenPtr)).FnumComponents), envPtr2)
		}
	} else {
		/*
		 * No explict result argument, so default result is empty string.
		 */
		_objIndexCopy3 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy3 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v66 = envPtr2 + 152
			v65 = *(*uintptr)(unsafe.Pointer(v66))
			*(*uintptr)(unsafe.Pointer(v66))++
			*(*uint8)(unsafe.Pointer(v65)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v68 = envPtr2 + 152
			v67 = *(*uintptr)(unsafe.Pointer(v68))
			*(*uintptr)(unsafe.Pointer(v68))++
			*(*uint8)(unsafe.Pointer(v67)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy3
				}
				v69 = delta1
				v70 = envPtr2
				if v69 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v70 + 64)) += int64(v69)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v72 = envPtr2 + 152
			v71 = *(*uintptr)(unsafe.Pointer(v72))
			*(*uintptr)(unsafe.Pointer(v72))++
			*(*uint8)(unsafe.Pointer(v71)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v74 = envPtr2 + 152
			v73 = *(*uintptr)(unsafe.Pointer(v74))
			*(*uintptr)(unsafe.Pointer(v74))++
			*(*uint8)(unsafe.Pointer(v73)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(24))
			v76 = envPtr2 + 152
			v75 = *(*uintptr)(unsafe.Pointer(v76))
			*(*uintptr)(unsafe.Pointer(v76))++
			*(*uint8)(unsafe.Pointer(v75)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(16))
			v78 = envPtr2 + 152
			v77 = *(*uintptr)(unsafe.Pointer(v78))
			*(*uintptr)(unsafe.Pointer(v78))++
			*(*uint8)(unsafe.Pointer(v77)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(8))
			v80 = envPtr2 + 152
			v79 = *(*uintptr)(unsafe.Pointer(v80))
			*(*uintptr)(unsafe.Pointer(v80))++
			*(*uint8)(unsafe.Pointer(v79)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy3
				}
				v81 = delta1
				v82 = envPtr2
				if v81 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v82)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v82)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v82)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v82)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v82 + 64)) += int64(v81)
			}
		}
	}
	/*
	 * Check for optimization: When [return] is in a proc, and there's no
	 * enclosing [catch], and there are no return options, then the INST_DONE
	 * instruction is equivalent, and may be more efficient.
	 */
	if numOptionWords == 0 && (*TCompileEnv)(unsafe.Pointer(envPtr2)).FprocPtr != libc.UintptrFromInt32(0) {
		/*
		 * We have default return options and we're in a proc ...
		 */
		index = int32((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayNext - int64(1))
		enclosingCatch = 0
		for index >= 0 {
			range1 = *(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(index)*56))
			if range1.Ftype1 == int32(CATCH_EXCEPTION_RANGE) && range1.FcatchOffset == int64(-libc.Int32FromInt32(1)) {
				enclosingCatch = int32(1)
				break
			}
			index--
		}
		if !(enclosingCatch != 0) {
			/*
			 * ... and there is no enclosing catch. Issue the maximally
			 * efficient exit instruction.
			 */
			_objPtr = *(*uintptr)(unsafe.Pointer(bp + 16))
			v84 = _objPtr
			v83 = *(*TTcl_Size)(unsafe.Pointer(v84))
			*(*TTcl_Size)(unsafe.Pointer(v84))--
			if v83 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v86 = envPtr2 + 152
			v85 = *(*uintptr)(unsafe.Pointer(v86))
			*(*uintptr)(unsafe.Pointer(v86))++
			*(*uint8)(unsafe.Pointer(v85)) = libc.Uint8FromInt32(int32(INST_DONE))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_DONE)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v87 = delta1
				v88 = envPtr2
				if v87 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v88)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v88)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v88)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v88)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v88 + 64)) += int64(v87)
			}
			v89 = int32(1)
			v90 = envPtr2
			if v89 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v90)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v90)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v90)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v90)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v90 + 64)) += int64(v89)
			return TCL_OK
		}
	}
	/* Optimize [return -level 0 $x]. */
	XTcl_DictObjSize(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 16)), bp+8)
	if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == 0 && *(*int32)(unsafe.Pointer(bp)) == 0 && *(*int32)(unsafe.Pointer(bp + 4)) == TCL_OK {
		_objPtr1 = *(*uintptr)(unsafe.Pointer(bp + 16))
		v92 = _objPtr1
		v91 = *(*TTcl_Size)(unsafe.Pointer(v92))
		*(*TTcl_Size)(unsafe.Pointer(v92))--
		if v91 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		return TCL_OK
	}
	/*
	 * Could not use the optimization, so we push the return options dict, and
	 * emit the INST_RETURN_IMM instruction with code and level as operands.
	 */
	_CompileReturnInternal(tls, envPtr2, uint8(INST_RETURN_IMM), *(*int32)(unsafe.Pointer(bp + 4)), *(*int32)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 16)))
	return TCL_OK
	goto issueRuntimeReturn
issueRuntimeReturn:
	;
	/*
	 * Assemble the option dictionary (as a list as that's good enough).
	 */
	wordTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	objc = int32(1)
	for {
		if !(objc <= numOptionWords) {
			break
		}
		if (*TTcl_Token)(unsafe.Pointer(wordTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy4 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(wordTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(wordTokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy4 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v95 = envPtr2 + 152
				v94 = *(*uintptr)(unsafe.Pointer(v95))
				*(*uintptr)(unsafe.Pointer(v95))++
				*(*uint8)(unsafe.Pointer(v94)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v97 = envPtr2 + 152
				v96 = *(*uintptr)(unsafe.Pointer(v97))
				*(*uintptr)(unsafe.Pointer(v97))++
				*(*uint8)(unsafe.Pointer(v96)) = uint8(libc.Uint32FromInt32(_objIndexCopy4))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy4
					}
					v98 = delta1
					v99 = envPtr2
					if v98 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v99)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v99)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v99)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v99)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v99 + 64)) += int64(v98)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v101 = envPtr2 + 152
				v100 = *(*uintptr)(unsafe.Pointer(v101))
				*(*uintptr)(unsafe.Pointer(v101))++
				*(*uint8)(unsafe.Pointer(v100)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v103 = envPtr2 + 152
				v102 = *(*uintptr)(unsafe.Pointer(v103))
				*(*uintptr)(unsafe.Pointer(v103))++
				*(*uint8)(unsafe.Pointer(v102)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(24))
				v105 = envPtr2 + 152
				v104 = *(*uintptr)(unsafe.Pointer(v105))
				*(*uintptr)(unsafe.Pointer(v105))++
				*(*uint8)(unsafe.Pointer(v104)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(16))
				v107 = envPtr2 + 152
				v106 = *(*uintptr)(unsafe.Pointer(v107))
				*(*uintptr)(unsafe.Pointer(v107))++
				*(*uint8)(unsafe.Pointer(v106)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(8))
				v109 = envPtr2 + 152
				v108 = *(*uintptr)(unsafe.Pointer(v109))
				*(*uintptr)(unsafe.Pointer(v109))++
				*(*uint8)(unsafe.Pointer(v108)) = uint8(libc.Uint32FromInt32(_objIndexCopy4))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy4
					}
					v110 = delta1
					v111 = envPtr2
					if v110 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v111)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v111)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v111)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v111)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v111 + 64)) += int64(v110)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(objc)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(objc)*8))
			XTclCompileTokens(tls, interp, wordTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(wordTokenPtr)).FnumComponents), envPtr2)
		}
		wordTokenPtr = wordTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(wordTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		goto _93
	_93:
		;
		objc++
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v113 = envPtr2 + 152
	v112 = *(*uintptr)(unsafe.Pointer(v113))
	*(*uintptr)(unsafe.Pointer(v113))++
	*(*uint8)(unsafe.Pointer(v112)) = libc.Uint8FromInt32(int32(INST_LIST))
	v115 = envPtr2 + 152
	v114 = *(*uintptr)(unsafe.Pointer(v115))
	*(*uintptr)(unsafe.Pointer(v115))++
	*(*uint8)(unsafe.Pointer(v114)) = uint8(libc.Uint32FromInt32(numOptionWords) >> libc.Int32FromInt32(24))
	v117 = envPtr2 + 152
	v116 = *(*uintptr)(unsafe.Pointer(v117))
	*(*uintptr)(unsafe.Pointer(v117))++
	*(*uint8)(unsafe.Pointer(v116)) = uint8(libc.Uint32FromInt32(numOptionWords) >> libc.Int32FromInt32(16))
	v119 = envPtr2 + 152
	v118 = *(*uintptr)(unsafe.Pointer(v119))
	*(*uintptr)(unsafe.Pointer(v119))++
	*(*uint8)(unsafe.Pointer(v118)) = uint8(libc.Uint32FromInt32(numOptionWords) >> libc.Int32FromInt32(8))
	v121 = envPtr2 + 152
	v120 = *(*uintptr)(unsafe.Pointer(v121))
	*(*uintptr)(unsafe.Pointer(v121))++
	*(*uint8)(unsafe.Pointer(v120)) = uint8(libc.Uint32FromInt32(numOptionWords))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_LIST)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - numOptionWords
		}
		v122 = delta1
		v123 = envPtr2
		if v122 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v123)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v123)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v123)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v123)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v123 + 64)) += int64(v122)
	}
	/*
	 * Push the result.
	 */
	if explicitResult != 0 {
		if (*TTcl_Token)(unsafe.Pointer(wordTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy5 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(wordTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(wordTokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy5 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v125 = envPtr2 + 152
				v124 = *(*uintptr)(unsafe.Pointer(v125))
				*(*uintptr)(unsafe.Pointer(v125))++
				*(*uint8)(unsafe.Pointer(v124)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v127 = envPtr2 + 152
				v126 = *(*uintptr)(unsafe.Pointer(v127))
				*(*uintptr)(unsafe.Pointer(v127))++
				*(*uint8)(unsafe.Pointer(v126)) = uint8(libc.Uint32FromInt32(_objIndexCopy5))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy5
					}
					v128 = delta1
					v129 = envPtr2
					if v128 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v129)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v129)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v129)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v129)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v129 + 64)) += int64(v128)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v131 = envPtr2 + 152
				v130 = *(*uintptr)(unsafe.Pointer(v131))
				*(*uintptr)(unsafe.Pointer(v131))++
				*(*uint8)(unsafe.Pointer(v130)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v133 = envPtr2 + 152
				v132 = *(*uintptr)(unsafe.Pointer(v133))
				*(*uintptr)(unsafe.Pointer(v133))++
				*(*uint8)(unsafe.Pointer(v132)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(24))
				v135 = envPtr2 + 152
				v134 = *(*uintptr)(unsafe.Pointer(v135))
				*(*uintptr)(unsafe.Pointer(v135))++
				*(*uint8)(unsafe.Pointer(v134)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(16))
				v137 = envPtr2 + 152
				v136 = *(*uintptr)(unsafe.Pointer(v137))
				*(*uintptr)(unsafe.Pointer(v137))++
				*(*uint8)(unsafe.Pointer(v136)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(8))
				v139 = envPtr2 + 152
				v138 = *(*uintptr)(unsafe.Pointer(v139))
				*(*uintptr)(unsafe.Pointer(v139))++
				*(*uint8)(unsafe.Pointer(v138)) = uint8(libc.Uint32FromInt32(_objIndexCopy5))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy5
					}
					v140 = delta1
					v141 = envPtr2
					if v140 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v141)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v141)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v141)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v141)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v141 + 64)) += int64(v140)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(numWords-libc.Int32FromInt32(1))*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(numWords-libc.Int32FromInt32(1))*8))
			XTclCompileTokens(tls, interp, wordTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(wordTokenPtr)).FnumComponents), envPtr2)
		}
	} else {
		_objIndexCopy6 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy6 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v143 = envPtr2 + 152
			v142 = *(*uintptr)(unsafe.Pointer(v143))
			*(*uintptr)(unsafe.Pointer(v143))++
			*(*uint8)(unsafe.Pointer(v142)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v145 = envPtr2 + 152
			v144 = *(*uintptr)(unsafe.Pointer(v145))
			*(*uintptr)(unsafe.Pointer(v145))++
			*(*uint8)(unsafe.Pointer(v144)) = uint8(libc.Uint32FromInt32(_objIndexCopy6))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy6
				}
				v146 = delta1
				v147 = envPtr2
				if v146 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v147)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v147)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v147)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v147)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v147 + 64)) += int64(v146)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v149 = envPtr2 + 152
			v148 = *(*uintptr)(unsafe.Pointer(v149))
			*(*uintptr)(unsafe.Pointer(v149))++
			*(*uint8)(unsafe.Pointer(v148)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v151 = envPtr2 + 152
			v150 = *(*uintptr)(unsafe.Pointer(v151))
			*(*uintptr)(unsafe.Pointer(v151))++
			*(*uint8)(unsafe.Pointer(v150)) = uint8(libc.Uint32FromInt32(_objIndexCopy6) >> libc.Int32FromInt32(24))
			v153 = envPtr2 + 152
			v152 = *(*uintptr)(unsafe.Pointer(v153))
			*(*uintptr)(unsafe.Pointer(v153))++
			*(*uint8)(unsafe.Pointer(v152)) = uint8(libc.Uint32FromInt32(_objIndexCopy6) >> libc.Int32FromInt32(16))
			v155 = envPtr2 + 152
			v154 = *(*uintptr)(unsafe.Pointer(v155))
			*(*uintptr)(unsafe.Pointer(v155))++
			*(*uint8)(unsafe.Pointer(v154)) = uint8(libc.Uint32FromInt32(_objIndexCopy6) >> libc.Int32FromInt32(8))
			v157 = envPtr2 + 152
			v156 = *(*uintptr)(unsafe.Pointer(v157))
			*(*uintptr)(unsafe.Pointer(v157))++
			*(*uint8)(unsafe.Pointer(v156)) = uint8(libc.Uint32FromInt32(_objIndexCopy6))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy6
				}
				v158 = delta1
				v159 = envPtr2
				if v158 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v159)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v159)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v159)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v159)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v159 + 64)) += int64(v158)
			}
		}
	}
	/*
	 * Issue the RETURN itself.
	 */
	XTclEmitInvoke(tls, envPtr2, int32(INST_RETURN_STK), 0)
	return TCL_OK
}

func _CompileReturnInternal(tls *libc.TLS, envPtr2 uintptr, op1 uint8, code int32, level int32, returnOpts uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objIndexCopy, delta1, v19, v31, v32, v7 int32
	var _objPtr, rangePtr, v10, v11, v12, v13, v14, v15, v16, v17, v18, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v5, v6, v8, v9 uintptr
	var v1 TTcl_Size
	var _ /* exceptAux at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objPtr, delta1, rangePtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v5, v6, v7, v8, v9
	if level == 0 && (code == int32(TCL_BREAK) || code == int32(TCL_CONTINUE)) {
		rangePtr = XTclGetInnermostExceptionRange(tls, envPtr2, code, bp)
		if rangePtr != 0 && (*TExceptionRange)(unsafe.Pointer(rangePtr)).Ftype1 == int32(LOOP_EXCEPTION_RANGE) {
			XTclCleanupStackForBreakContinue(tls, envPtr2, *(*uintptr)(unsafe.Pointer(bp)))
			if code == int32(TCL_BREAK) {
				XTclAddLoopBreakFixup(tls, envPtr2, *(*uintptr)(unsafe.Pointer(bp)))
			} else {
				XTclAddLoopContinueFixup(tls, envPtr2, *(*uintptr)(unsafe.Pointer(bp)))
			}
			_objPtr = returnOpts
			v2 = _objPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if v1 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			return
		}
	}
	_objIndexCopy = XTclAddLiteralObj(tls, envPtr2, returnOpts, libc.UintptrFromInt32(0))
	if _objIndexCopy <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v4 = envPtr2 + 152
		v3 = *(*uintptr)(unsafe.Pointer(v4))
		*(*uintptr)(unsafe.Pointer(v4))++
		*(*uint8)(unsafe.Pointer(v3)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v6 = envPtr2 + 152
		v5 = *(*uintptr)(unsafe.Pointer(v6))
		*(*uintptr)(unsafe.Pointer(v6))++
		*(*uint8)(unsafe.Pointer(v5)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v7 = delta1
			v8 = envPtr2
			if v7 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v8)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v8)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v8)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v8)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v8 + 64)) += int64(v7)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v10 = envPtr2 + 152
		v9 = *(*uintptr)(unsafe.Pointer(v10))
		*(*uintptr)(unsafe.Pointer(v10))++
		*(*uint8)(unsafe.Pointer(v9)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v12 = envPtr2 + 152
		v11 = *(*uintptr)(unsafe.Pointer(v12))
		*(*uintptr)(unsafe.Pointer(v12))++
		*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
		v14 = envPtr2 + 152
		v13 = *(*uintptr)(unsafe.Pointer(v14))
		*(*uintptr)(unsafe.Pointer(v14))++
		*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
		v16 = envPtr2 + 152
		v15 = *(*uintptr)(unsafe.Pointer(v16))
		*(*uintptr)(unsafe.Pointer(v16))++
		*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
		v18 = envPtr2 + 152
		v17 = *(*uintptr)(unsafe.Pointer(v18))
		*(*uintptr)(unsafe.Pointer(v18))++
		*(*uint8)(unsafe.Pointer(v17)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v19 = delta1
			v20 = envPtr2
			if v19 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v20)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v20)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v20)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v20)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v20 + 64)) += int64(v19)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v22 = envPtr2 + 152
	v21 = *(*uintptr)(unsafe.Pointer(v22))
	*(*uintptr)(unsafe.Pointer(v22))++
	*(*uint8)(unsafe.Pointer(v21)) = op1
	v24 = envPtr2 + 152
	v23 = *(*uintptr)(unsafe.Pointer(v24))
	*(*uintptr)(unsafe.Pointer(v24))++
	*(*uint8)(unsafe.Pointer(v23)) = uint8(libc.Uint32FromInt32(code) >> libc.Int32FromInt32(24))
	v26 = envPtr2 + 152
	v25 = *(*uintptr)(unsafe.Pointer(v26))
	*(*uintptr)(unsafe.Pointer(v26))++
	*(*uint8)(unsafe.Pointer(v25)) = uint8(libc.Uint32FromInt32(code) >> libc.Int32FromInt32(16))
	v28 = envPtr2 + 152
	v27 = *(*uintptr)(unsafe.Pointer(v28))
	*(*uintptr)(unsafe.Pointer(v28))++
	*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(code) >> libc.Int32FromInt32(8))
	v30 = envPtr2 + 152
	v29 = *(*uintptr)(unsafe.Pointer(v30))
	*(*uintptr)(unsafe.Pointer(v30))++
	*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(code))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		if libc.Int32FromUint8(op1) == int32(INST_START_CMD) {
			v31 = int32(1)
		} else {
			v31 = 0
		}
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = v31
	}
	delta1 = XtclInstructionTable[op1].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - code
		}
		v32 = delta1
		v33 = envPtr2
		if v32 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v33)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v33)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v33)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v33)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v33 + 64)) += int64(v32)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v35 = envPtr2 + 152
	v34 = *(*uintptr)(unsafe.Pointer(v35))
	*(*uintptr)(unsafe.Pointer(v35))++
	*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt32(level) >> libc.Int32FromInt32(24))
	v37 = envPtr2 + 152
	v36 = *(*uintptr)(unsafe.Pointer(v37))
	*(*uintptr)(unsafe.Pointer(v37))++
	*(*uint8)(unsafe.Pointer(v36)) = uint8(libc.Uint32FromInt32(level) >> libc.Int32FromInt32(16))
	v39 = envPtr2 + 152
	v38 = *(*uintptr)(unsafe.Pointer(v39))
	*(*uintptr)(unsafe.Pointer(v39))++
	*(*uint8)(unsafe.Pointer(v38)) = uint8(libc.Uint32FromInt32(level) >> libc.Int32FromInt32(8))
	v41 = envPtr2 + 152
	v40 = *(*uintptr)(unsafe.Pointer(v41))
	*(*uintptr)(unsafe.Pointer(v41))++
	*(*uint8)(unsafe.Pointer(v40)) = uint8(libc.Uint32FromInt32(level))
}

func XTclCompileSyntaxError(tls *libc.TLS, interp uintptr, envPtr2 uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objIndexCopy, delta1, v18, v6 int32
	var bytes, msg, v1, v10, v11, v12, v13, v14, v15, v16, v17, v19, v2, v3, v4, v5, v7, v8, v9 uintptr
	var _ /* numBytes at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, bytes, delta1, msg, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v3, v4, v5, v6, v7, v8, v9
	msg = XTcl_GetObjResult(tls, interp)
	if (*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(msg)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, msg, bp)
	}
	bytes = v1
	XTclErrorStackResetIf(tls, interp, bytes, *(*TTcl_Size)(unsafe.Pointer(bp)))
	_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, bytes, *(*TTcl_Size)(unsafe.Pointer(bp)), 0)
	if _objIndexCopy <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v3 = envPtr2 + 152
		v2 = *(*uintptr)(unsafe.Pointer(v3))
		*(*uintptr)(unsafe.Pointer(v3))++
		*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v5 = envPtr2 + 152
		v4 = *(*uintptr)(unsafe.Pointer(v5))
		*(*uintptr)(unsafe.Pointer(v5))++
		*(*uint8)(unsafe.Pointer(v4)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v6 = delta1
			v7 = envPtr2
			if v6 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v7 + 64)) += int64(v6)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v9 = envPtr2 + 152
		v8 = *(*uintptr)(unsafe.Pointer(v9))
		*(*uintptr)(unsafe.Pointer(v9))++
		*(*uint8)(unsafe.Pointer(v8)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v11 = envPtr2 + 152
		v10 = *(*uintptr)(unsafe.Pointer(v11))
		*(*uintptr)(unsafe.Pointer(v11))++
		*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
		v13 = envPtr2 + 152
		v12 = *(*uintptr)(unsafe.Pointer(v13))
		*(*uintptr)(unsafe.Pointer(v13))++
		*(*uint8)(unsafe.Pointer(v12)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
		v15 = envPtr2 + 152
		v14 = *(*uintptr)(unsafe.Pointer(v15))
		*(*uintptr)(unsafe.Pointer(v15))++
		*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
		v17 = envPtr2 + 152
		v16 = *(*uintptr)(unsafe.Pointer(v17))
		*(*uintptr)(unsafe.Pointer(v17))++
		*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v18 = delta1
			v19 = envPtr2
			if v18 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v19 + 64)) += int64(v18)
		}
	}
	_CompileReturnInternal(tls, envPtr2, uint8(INST_SYNTAX), int32(TCL_ERROR), 0, XTclNoErrorStack(tls, interp, XTcl_GetReturnOptions(tls, interp, int32(TCL_ERROR))))
	XTcl_ResetResult(tls, interp)
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileUpvarCmd --
 *
 *	Procedure called to compile the "upvar" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "upvar" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileUpvarCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy2515 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, delta1, i1, localIndex, numWords, v20, v26, v38, v47, v59, v71, v75, v8, v81, v93 int32
	var _objPtr, _objPtr1, cachePtr, localTokenPtr, mapPtr, newTypePtr, objPtr, otherTokenPtr, tokenPtr, typePtr, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v21, v22, v23, v24, v25, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v39, v4, v41, v43, v44, v45, v46, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v72, v73, v74, v76, v77, v78, v79, v80, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v94 uintptr
	var eclIndex, v2, v40 TTcl_Size
	var v1 bool
	var _ /* framePtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, _objPtr, _objPtr1, cachePtr, delta1, eclIndex, i1, localIndex, localTokenPtr, mapPtr, newTypePtr, numWords, objPtr, otherTokenPtr, tokenPtr, typePtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FprocPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	numWords = int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)
	if numWords < int32(3) {
		return int32(TCL_ERROR)
	}
	/*
	 * Push the frame index if it is known at compile time
	 */
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if XTclWordKnownAtCompileTime(tls, tokenPtr, objPtr) != 0 {
		typePtr = (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr
		/*
		 * Attempt to convert to a level reference. Note that TclObjGetFrame
		 * only changes the obj type when a conversion was successful.
		 */
		XTclObjGetFrame(tls, interp, objPtr, bp)
		newTypePtr = (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr
		_objPtr = objPtr
		v3 = _objPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		if newTypePtr != typePtr {
			if numWords%int32(2) != 0 {
				return int32(TCL_ERROR)
			}
			/* TODO: Push the known value instead? */
			if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
				_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
				if _objIndexCopy <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v5 = envPtr2 + 152
					v4 = *(*uintptr)(unsafe.Pointer(v5))
					*(*uintptr)(unsafe.Pointer(v5))++
					*(*uint8)(unsafe.Pointer(v4)) = libc.Uint8FromInt32(int32(INST_PUSH1))
					v7 = envPtr2 + 152
					v6 = *(*uintptr)(unsafe.Pointer(v7))
					*(*uintptr)(unsafe.Pointer(v7))++
					*(*uint8)(unsafe.Pointer(v6)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy
						}
						v8 = delta1
						v9 = envPtr2
						if v8 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v9)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v9)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v9)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v9)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v9 + 64)) += int64(v8)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v11 = envPtr2 + 152
					v10 = *(*uintptr)(unsafe.Pointer(v11))
					*(*uintptr)(unsafe.Pointer(v11))++
					*(*uint8)(unsafe.Pointer(v10)) = libc.Uint8FromInt32(int32(INST_PUSH4))
					v13 = envPtr2 + 152
					v12 = *(*uintptr)(unsafe.Pointer(v13))
					*(*uintptr)(unsafe.Pointer(v13))++
					*(*uint8)(unsafe.Pointer(v12)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
					v15 = envPtr2 + 152
					v14 = *(*uintptr)(unsafe.Pointer(v15))
					*(*uintptr)(unsafe.Pointer(v15))++
					*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
					v17 = envPtr2 + 152
					v16 = *(*uintptr)(unsafe.Pointer(v17))
					*(*uintptr)(unsafe.Pointer(v17))++
					*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
					v19 = envPtr2 + 152
					v18 = *(*uintptr)(unsafe.Pointer(v19))
					*(*uintptr)(unsafe.Pointer(v19))++
					*(*uint8)(unsafe.Pointer(v18)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy
						}
						v20 = delta1
						v21 = envPtr2
						if v20 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v21)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v21)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v21)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v21)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v21 + 64)) += int64(v20)
					}
				}
			} else {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
				XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
			}
			otherTokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
			i1 = int32(2)
		} else {
			if !(numWords%libc.Int32FromInt32(2) != 0) {
				return int32(TCL_ERROR)
			}
			_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+21397, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
			if _objIndexCopy1 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v23 = envPtr2 + 152
				v22 = *(*uintptr)(unsafe.Pointer(v23))
				*(*uintptr)(unsafe.Pointer(v23))++
				*(*uint8)(unsafe.Pointer(v22)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v25 = envPtr2 + 152
				v24 = *(*uintptr)(unsafe.Pointer(v25))
				*(*uintptr)(unsafe.Pointer(v25))++
				*(*uint8)(unsafe.Pointer(v24)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v26 = delta1
					v27 = envPtr2
					if v26 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v27)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v27)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v27)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v27)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v27 + 64)) += int64(v26)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v29 = envPtr2 + 152
				v28 = *(*uintptr)(unsafe.Pointer(v29))
				*(*uintptr)(unsafe.Pointer(v29))++
				*(*uint8)(unsafe.Pointer(v28)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v31 = envPtr2 + 152
				v30 = *(*uintptr)(unsafe.Pointer(v31))
				*(*uintptr)(unsafe.Pointer(v31))++
				*(*uint8)(unsafe.Pointer(v30)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
				v33 = envPtr2 + 152
				v32 = *(*uintptr)(unsafe.Pointer(v33))
				*(*uintptr)(unsafe.Pointer(v33))++
				*(*uint8)(unsafe.Pointer(v32)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
				v35 = envPtr2 + 152
				v34 = *(*uintptr)(unsafe.Pointer(v35))
				*(*uintptr)(unsafe.Pointer(v35))++
				*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
				v37 = envPtr2 + 152
				v36 = *(*uintptr)(unsafe.Pointer(v37))
				*(*uintptr)(unsafe.Pointer(v37))++
				*(*uint8)(unsafe.Pointer(v36)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v38 = delta1
					v39 = envPtr2
					if v38 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v39)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v39)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v39)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v39)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v39 + 64)) += int64(v38)
				}
			}
			otherTokenPtr = tokenPtr
			i1 = int32(1)
		}
	} else {
		_objPtr1 = objPtr
		v41 = _objPtr1
		v40 = *(*TTcl_Size)(unsafe.Pointer(v41))
		*(*TTcl_Size)(unsafe.Pointer(v41))--
		if v40 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		return int32(TCL_ERROR)
	}
	/*
	 * Loop over the (otherVar, thisVar) pairs. If any of the thisVar is not a
	 * local variable, return an error so that the non-compiled command will
	 * be called at runtime.
	 */
	for {
		if !(i1 < numWords) {
			break
		}
		localTokenPtr = otherTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(otherTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if (*TTcl_Token)(unsafe.Pointer(otherTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(otherTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(otherTokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy2 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v44 = envPtr2 + 152
				v43 = *(*uintptr)(unsafe.Pointer(v44))
				*(*uintptr)(unsafe.Pointer(v44))++
				*(*uint8)(unsafe.Pointer(v43)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v46 = envPtr2 + 152
				v45 = *(*uintptr)(unsafe.Pointer(v46))
				*(*uintptr)(unsafe.Pointer(v46))++
				*(*uint8)(unsafe.Pointer(v45)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy2
					}
					v47 = delta1
					v48 = envPtr2
					if v47 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v48)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v48)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v48)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v48)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v48 + 64)) += int64(v47)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v50 = envPtr2 + 152
				v49 = *(*uintptr)(unsafe.Pointer(v50))
				*(*uintptr)(unsafe.Pointer(v50))++
				*(*uint8)(unsafe.Pointer(v49)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v52 = envPtr2 + 152
				v51 = *(*uintptr)(unsafe.Pointer(v52))
				*(*uintptr)(unsafe.Pointer(v52))++
				*(*uint8)(unsafe.Pointer(v51)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
				v54 = envPtr2 + 152
				v53 = *(*uintptr)(unsafe.Pointer(v54))
				*(*uintptr)(unsafe.Pointer(v54))++
				*(*uint8)(unsafe.Pointer(v53)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
				v56 = envPtr2 + 152
				v55 = *(*uintptr)(unsafe.Pointer(v56))
				*(*uintptr)(unsafe.Pointer(v56))++
				*(*uint8)(unsafe.Pointer(v55)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
				v58 = envPtr2 + 152
				v57 = *(*uintptr)(unsafe.Pointer(v58))
				*(*uintptr)(unsafe.Pointer(v58))++
				*(*uint8)(unsafe.Pointer(v57)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy2
					}
					v59 = delta1
					v60 = envPtr2
					if v59 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v60)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v60)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v60)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v60)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v60 + 64)) += int64(v59)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
			XTclCompileTokens(tls, interp, otherTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(otherTokenPtr)).FnumComponents), envPtr2)
		}
		localIndex = libc.Int32FromUint64(XTclLocalScalarFromToken(tls, localTokenPtr, envPtr2))
		if localIndex < 0 {
			return int32(TCL_ERROR)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v62 = envPtr2 + 152
		v61 = *(*uintptr)(unsafe.Pointer(v62))
		*(*uintptr)(unsafe.Pointer(v62))++
		*(*uint8)(unsafe.Pointer(v61)) = libc.Uint8FromInt32(int32(INST_UPVAR))
		v64 = envPtr2 + 152
		v63 = *(*uintptr)(unsafe.Pointer(v64))
		*(*uintptr)(unsafe.Pointer(v64))++
		*(*uint8)(unsafe.Pointer(v63)) = uint8(libc.Uint32FromInt32(localIndex) >> libc.Int32FromInt32(24))
		v66 = envPtr2 + 152
		v65 = *(*uintptr)(unsafe.Pointer(v66))
		*(*uintptr)(unsafe.Pointer(v66))++
		*(*uint8)(unsafe.Pointer(v65)) = uint8(libc.Uint32FromInt32(localIndex) >> libc.Int32FromInt32(16))
		v68 = envPtr2 + 152
		v67 = *(*uintptr)(unsafe.Pointer(v68))
		*(*uintptr)(unsafe.Pointer(v68))++
		*(*uint8)(unsafe.Pointer(v67)) = uint8(libc.Uint32FromInt32(localIndex) >> libc.Int32FromInt32(8))
		v70 = envPtr2 + 152
		v69 = *(*uintptr)(unsafe.Pointer(v70))
		*(*uintptr)(unsafe.Pointer(v70))++
		*(*uint8)(unsafe.Pointer(v69)) = uint8(libc.Uint32FromInt32(localIndex))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_UPVAR)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - localIndex
			}
			v71 = delta1
			v72 = envPtr2
			if v71 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v72)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v72)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v72)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v72)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v72 + 64)) += int64(v71)
		}
		goto _42
	_42:
		;
		i1 += int32(2)
		otherTokenPtr = localTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(localTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	}
	/*
	 * Pop the frame index, and set the result to empty
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v74 = envPtr2 + 152
	v73 = *(*uintptr)(unsafe.Pointer(v74))
	*(*uintptr)(unsafe.Pointer(v74))++
	*(*uint8)(unsafe.Pointer(v73)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v75 = delta1
		v76 = envPtr2
		if v75 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v76)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v76)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v76)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v76)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v76 + 64)) += int64(v75)
	}
	_objIndexCopy3 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy3 <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v78 = envPtr2 + 152
		v77 = *(*uintptr)(unsafe.Pointer(v78))
		*(*uintptr)(unsafe.Pointer(v78))++
		*(*uint8)(unsafe.Pointer(v77)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v80 = envPtr2 + 152
		v79 = *(*uintptr)(unsafe.Pointer(v80))
		*(*uintptr)(unsafe.Pointer(v80))++
		*(*uint8)(unsafe.Pointer(v79)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy3
			}
			v81 = delta1
			v82 = envPtr2
			if v81 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v82)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v82)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v82)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v82)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v82 + 64)) += int64(v81)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v84 = envPtr2 + 152
		v83 = *(*uintptr)(unsafe.Pointer(v84))
		*(*uintptr)(unsafe.Pointer(v84))++
		*(*uint8)(unsafe.Pointer(v83)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v86 = envPtr2 + 152
		v85 = *(*uintptr)(unsafe.Pointer(v86))
		*(*uintptr)(unsafe.Pointer(v86))++
		*(*uint8)(unsafe.Pointer(v85)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(24))
		v88 = envPtr2 + 152
		v87 = *(*uintptr)(unsafe.Pointer(v88))
		*(*uintptr)(unsafe.Pointer(v88))++
		*(*uint8)(unsafe.Pointer(v87)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(16))
		v90 = envPtr2 + 152
		v89 = *(*uintptr)(unsafe.Pointer(v90))
		*(*uintptr)(unsafe.Pointer(v90))++
		*(*uint8)(unsafe.Pointer(v89)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(8))
		v92 = envPtr2 + 152
		v91 = *(*uintptr)(unsafe.Pointer(v92))
		*(*uintptr)(unsafe.Pointer(v92))++
		*(*uint8)(unsafe.Pointer(v91)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy3
			}
			v93 = delta1
			v94 = envPtr2
			if v93 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v94)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v94)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v94)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v94)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v94 + 64)) += int64(v93)
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileVariableCmd --
 *
 *	Procedure called to compile the "variable" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "variable" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileVariableCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy2621 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, delta1, i1, localIndex, numWords, v18, v30, v36, v48, v54, v6, v66, v70, v76, v88 int32
	var eclIndex TTcl_Size
	var mapPtr, valueTokenPtr, varTokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v31, v32, v33, v34, v35, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v49, v5, v50, v51, v52, v53, v55, v56, v57, v58, v59, v60, v61, v62, v63, v64, v65, v67, v68, v69, v7, v71, v72, v73, v74, v75, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v89, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, delta1, eclIndex, i1, localIndex, mapPtr, numWords, valueTokenPtr, varTokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	numWords = int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)
	if numWords < int32(2) {
		return int32(TCL_ERROR)
	}
	/*
	 * Bail out if not compiling a proc body
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FprocPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Loop over the (var, value) pairs.
	 */
	valueTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
	i1 = int32(1)
	for {
		if !(i1 < numWords) {
			break
		}
		varTokenPtr = valueTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		valueTokenPtr = varTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		localIndex = _IndexTailVarIfKnown(tls, interp, varTokenPtr, envPtr2)
		if localIndex < 0 {
			return int32(TCL_ERROR)
		}
		/* TODO: Consider what value can pass through the
		 * IndexTailVarIfKnown() screen.  Full CompileWord()
		 * likely does not apply here.  Push known value instead. */
		if (*TTcl_Token)(unsafe.Pointer(varTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v3 = envPtr2 + 152
				v2 = *(*uintptr)(unsafe.Pointer(v3))
				*(*uintptr)(unsafe.Pointer(v3))++
				*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v5 = envPtr2 + 152
				v4 = *(*uintptr)(unsafe.Pointer(v5))
				*(*uintptr)(unsafe.Pointer(v5))++
				*(*uint8)(unsafe.Pointer(v4)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v6 = delta1
					v7 = envPtr2
					if v6 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v7 + 64)) += int64(v6)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v9 = envPtr2 + 152
				v8 = *(*uintptr)(unsafe.Pointer(v9))
				*(*uintptr)(unsafe.Pointer(v9))++
				*(*uint8)(unsafe.Pointer(v8)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v11 = envPtr2 + 152
				v10 = *(*uintptr)(unsafe.Pointer(v11))
				*(*uintptr)(unsafe.Pointer(v11))++
				*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
				v13 = envPtr2 + 152
				v12 = *(*uintptr)(unsafe.Pointer(v13))
				*(*uintptr)(unsafe.Pointer(v13))++
				*(*uint8)(unsafe.Pointer(v12)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
				v15 = envPtr2 + 152
				v14 = *(*uintptr)(unsafe.Pointer(v15))
				*(*uintptr)(unsafe.Pointer(v15))++
				*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
				v17 = envPtr2 + 152
				v16 = *(*uintptr)(unsafe.Pointer(v17))
				*(*uintptr)(unsafe.Pointer(v17))++
				*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v18 = delta1
					v19 = envPtr2
					if v18 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v19 + 64)) += int64(v18)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
			XTclCompileTokens(tls, interp, varTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents), envPtr2)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v21 = envPtr2 + 152
		v20 = *(*uintptr)(unsafe.Pointer(v21))
		*(*uintptr)(unsafe.Pointer(v21))++
		*(*uint8)(unsafe.Pointer(v20)) = libc.Uint8FromInt32(int32(INST_VARIABLE))
		v23 = envPtr2 + 152
		v22 = *(*uintptr)(unsafe.Pointer(v23))
		*(*uintptr)(unsafe.Pointer(v23))++
		*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(localIndex) >> libc.Int32FromInt32(24))
		v25 = envPtr2 + 152
		v24 = *(*uintptr)(unsafe.Pointer(v25))
		*(*uintptr)(unsafe.Pointer(v25))++
		*(*uint8)(unsafe.Pointer(v24)) = uint8(libc.Uint32FromInt32(localIndex) >> libc.Int32FromInt32(16))
		v27 = envPtr2 + 152
		v26 = *(*uintptr)(unsafe.Pointer(v27))
		*(*uintptr)(unsafe.Pointer(v27))++
		*(*uint8)(unsafe.Pointer(v26)) = uint8(libc.Uint32FromInt32(localIndex) >> libc.Int32FromInt32(8))
		v29 = envPtr2 + 152
		v28 = *(*uintptr)(unsafe.Pointer(v29))
		*(*uintptr)(unsafe.Pointer(v29))++
		*(*uint8)(unsafe.Pointer(v28)) = uint8(libc.Uint32FromInt32(localIndex))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_VARIABLE)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - localIndex
			}
			v30 = delta1
			v31 = envPtr2
			if v30 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v31)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v31)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v31)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v31)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v31 + 64)) += int64(v30)
		}
		if i1+int32(1) < numWords {
			/*
			 * A value has been given: set the variable, pop the value
			 */
			if (*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
				_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(valueTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(valueTokenPtr + 1*32))).Fsize, 0)
				if _objIndexCopy1 <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v33 = envPtr2 + 152
					v32 = *(*uintptr)(unsafe.Pointer(v33))
					*(*uintptr)(unsafe.Pointer(v33))++
					*(*uint8)(unsafe.Pointer(v32)) = libc.Uint8FromInt32(int32(INST_PUSH1))
					v35 = envPtr2 + 152
					v34 = *(*uintptr)(unsafe.Pointer(v35))
					*(*uintptr)(unsafe.Pointer(v35))++
					*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy1
						}
						v36 = delta1
						v37 = envPtr2
						if v36 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v37 + 64)) += int64(v36)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v39 = envPtr2 + 152
					v38 = *(*uintptr)(unsafe.Pointer(v39))
					*(*uintptr)(unsafe.Pointer(v39))++
					*(*uint8)(unsafe.Pointer(v38)) = libc.Uint8FromInt32(int32(INST_PUSH4))
					v41 = envPtr2 + 152
					v40 = *(*uintptr)(unsafe.Pointer(v41))
					*(*uintptr)(unsafe.Pointer(v41))++
					*(*uint8)(unsafe.Pointer(v40)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
					v43 = envPtr2 + 152
					v42 = *(*uintptr)(unsafe.Pointer(v43))
					*(*uintptr)(unsafe.Pointer(v43))++
					*(*uint8)(unsafe.Pointer(v42)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
					v45 = envPtr2 + 152
					v44 = *(*uintptr)(unsafe.Pointer(v45))
					*(*uintptr)(unsafe.Pointer(v45))++
					*(*uint8)(unsafe.Pointer(v44)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
					v47 = envPtr2 + 152
					v46 = *(*uintptr)(unsafe.Pointer(v47))
					*(*uintptr)(unsafe.Pointer(v47))++
					*(*uint8)(unsafe.Pointer(v46)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy1
						}
						v48 = delta1
						v49 = envPtr2
						if v48 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v49)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v49)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v49)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v49)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v49 + 64)) += int64(v48)
					}
				}
			} else {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1+libc.Int32FromInt32(1))*8))
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1+libc.Int32FromInt32(1))*8))
				XTclCompileTokens(tls, interp, valueTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).FnumComponents), envPtr2)
			}
			if localIndex <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v51 = envPtr2 + 152
				v50 = *(*uintptr)(unsafe.Pointer(v51))
				*(*uintptr)(unsafe.Pointer(v51))++
				*(*uint8)(unsafe.Pointer(v50)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
				v53 = envPtr2 + 152
				v52 = *(*uintptr)(unsafe.Pointer(v53))
				*(*uintptr)(unsafe.Pointer(v53))++
				*(*uint8)(unsafe.Pointer(v52)) = uint8(libc.Uint32FromInt32(localIndex))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - localIndex
					}
					v54 = delta1
					v55 = envPtr2
					if v54 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v55)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v55)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v55)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v55)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v55 + 64)) += int64(v54)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v57 = envPtr2 + 152
				v56 = *(*uintptr)(unsafe.Pointer(v57))
				*(*uintptr)(unsafe.Pointer(v57))++
				*(*uint8)(unsafe.Pointer(v56)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
				v59 = envPtr2 + 152
				v58 = *(*uintptr)(unsafe.Pointer(v59))
				*(*uintptr)(unsafe.Pointer(v59))++
				*(*uint8)(unsafe.Pointer(v58)) = uint8(libc.Uint32FromInt32(localIndex) >> libc.Int32FromInt32(24))
				v61 = envPtr2 + 152
				v60 = *(*uintptr)(unsafe.Pointer(v61))
				*(*uintptr)(unsafe.Pointer(v61))++
				*(*uint8)(unsafe.Pointer(v60)) = uint8(libc.Uint32FromInt32(localIndex) >> libc.Int32FromInt32(16))
				v63 = envPtr2 + 152
				v62 = *(*uintptr)(unsafe.Pointer(v63))
				*(*uintptr)(unsafe.Pointer(v63))++
				*(*uint8)(unsafe.Pointer(v62)) = uint8(libc.Uint32FromInt32(localIndex) >> libc.Int32FromInt32(8))
				v65 = envPtr2 + 152
				v64 = *(*uintptr)(unsafe.Pointer(v65))
				*(*uintptr)(unsafe.Pointer(v65))++
				*(*uint8)(unsafe.Pointer(v64)) = uint8(libc.Uint32FromInt32(localIndex))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - localIndex
					}
					v66 = delta1
					v67 = envPtr2
					if v66 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v67)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v67)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v67)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v67)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v67 + 64)) += int64(v66)
				}
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v69 = envPtr2 + 152
			v68 = *(*uintptr)(unsafe.Pointer(v69))
			*(*uintptr)(unsafe.Pointer(v69))++
			*(*uint8)(unsafe.Pointer(v68)) = libc.Uint8FromInt32(int32(INST_POP))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v70 = delta1
				v71 = envPtr2
				if v70 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v71)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v71)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v71)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v71)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v71 + 64)) += int64(v70)
			}
		}
		goto _1
	_1:
		;
		i1 += int32(2)
	}
	/*
	 * Set the result to empty
	 */
	_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy2 <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v73 = envPtr2 + 152
		v72 = *(*uintptr)(unsafe.Pointer(v73))
		*(*uintptr)(unsafe.Pointer(v73))++
		*(*uint8)(unsafe.Pointer(v72)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v75 = envPtr2 + 152
		v74 = *(*uintptr)(unsafe.Pointer(v75))
		*(*uintptr)(unsafe.Pointer(v75))++
		*(*uint8)(unsafe.Pointer(v74)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy2
			}
			v76 = delta1
			v77 = envPtr2
			if v76 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v77)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v77)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v77)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v77)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v77 + 64)) += int64(v76)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v79 = envPtr2 + 152
		v78 = *(*uintptr)(unsafe.Pointer(v79))
		*(*uintptr)(unsafe.Pointer(v79))++
		*(*uint8)(unsafe.Pointer(v78)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v81 = envPtr2 + 152
		v80 = *(*uintptr)(unsafe.Pointer(v81))
		*(*uintptr)(unsafe.Pointer(v81))++
		*(*uint8)(unsafe.Pointer(v80)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
		v83 = envPtr2 + 152
		v82 = *(*uintptr)(unsafe.Pointer(v83))
		*(*uintptr)(unsafe.Pointer(v83))++
		*(*uint8)(unsafe.Pointer(v82)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
		v85 = envPtr2 + 152
		v84 = *(*uintptr)(unsafe.Pointer(v85))
		*(*uintptr)(unsafe.Pointer(v85))++
		*(*uint8)(unsafe.Pointer(v84)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
		v87 = envPtr2 + 152
		v86 = *(*uintptr)(unsafe.Pointer(v87))
		*(*uintptr)(unsafe.Pointer(v87))++
		*(*uint8)(unsafe.Pointer(v86)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy2
			}
			v88 = delta1
			v89 = envPtr2
			if v88 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v89)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v89)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v89)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v89)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v89 + 64)) += int64(v88)
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * IndexTailVarIfKnown --
 *
 *	Procedure used in compiling [global] and [variable] commands. It
 *	inspects the variable name described by varTokenPtr and, if the tail
 *	is known at compile time, defines a corresponding local variable.
 *
 * Results:
 *	Returns the variable's index in the table of compiled locals if the
 *	tail is known at compile time, or -1 otherwise.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _IndexTailVarIfKnown(tls *libc.TLS, dummy2702 uintptr, varTokenPtr uintptr, envPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds resulting instructions. */
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, cachePtr, lastTokenPtr, p, tailName, tailPtr, v11, v3, v4, v6, v9 uintptr
	var full, localIndex, n int32
	var v1 bool
	var v10, v2, v5, v8 TTcl_Size
	var _ /* len at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, cachePtr, full, lastTokenPtr, localIndex, n, p, tailName, tailPtr, v1, v10, v11, v2, v3, v4, v5, v6, v8, v9
	n = int32((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents)
	/*
	 * Determine if the tail is (a) known at compile time, and (b) not an
	 * array element. Should any of these fail, return an error so that the
	 * non-compiled command will be called at runtime.
	 *
	 * In order for the tail to be known at compile time, the last token in
	 * the word has to be constant and contain "::" if it is not the only one.
	 */
	if !((*TCompileEnv)(unsafe.Pointer(envPtr)).FprocPtr != 0 || (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr)).FvarFramePtr)).FlocalCachePtr != 0) {
		return -int32(1)
	}
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		tailPtr = XTclThreadAllocObj(tls)
	} else {
		tailPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(tailPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(tailPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(tailPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(tailPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(tailPtr)).FtypePtr = libc.UintptrFromInt32(0)
	if XTclWordKnownAtCompileTime(tls, varTokenPtr, tailPtr) != 0 {
		full = int32(1)
		lastTokenPtr = varTokenPtr
	} else {
		full = 0
		lastTokenPtr = varTokenPtr + uintptr(n)*32
		if (*TTcl_Token)(unsafe.Pointer(lastTokenPtr)).Ftype1 != int32(TCL_TOKEN_TEXT) {
			_objPtr = tailPtr
			v3 = _objPtr
			v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
			*(*TTcl_Size)(unsafe.Pointer(v3))--
			if v2 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			return -int32(1)
		}
		XTcl_SetStringObj(tls, tailPtr, (*TTcl_Token)(unsafe.Pointer(lastTokenPtr)).Fstart, (*TTcl_Token)(unsafe.Pointer(lastTokenPtr)).Fsize)
	}
	if (*TTcl_Obj)(unsafe.Pointer(tailPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(tailPtr)).Flength
		v4 = (*TTcl_Obj)(unsafe.Pointer(tailPtr)).Fbytes
	} else {
		v4 = XTcl_GetStringFromObj(tls, tailPtr, bp)
	}
	tailName = v4
	if *(*TTcl_Size)(unsafe.Pointer(bp)) != 0 {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(tailName + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp))) - libc.UintptrFromInt32(1)))) == int32(')') {
			/*
			 * Possible array: bail out
			 */
			_objPtr1 = tailPtr
			v6 = _objPtr1
			v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
			*(*TTcl_Size)(unsafe.Pointer(v6))--
			if v5 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
			return -int32(1)
		}
		/*
		 * Get the tail: immediately after the last '::'
		 */
		p = tailName + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp))) - uintptr(1)
		for {
			if !(p > tailName) {
				break
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(':') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-libc.Int32FromInt32(1))))) == int32(':') {
				p++
				break
			}
			goto _7
		_7:
			;
			p--
		}
		if !(full != 0) && p == tailName {
			/*
			 * No :: in the last component.
			 */
			_objPtr2 = tailPtr
			v9 = _objPtr2
			v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
			*(*TTcl_Size)(unsafe.Pointer(v9))--
			if v8 <= int64(1) {
				XTclFreeObj(tls, _objPtr2)
			}
			return -int32(1)
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) -= int64(p) - int64(tailName)
		tailName = p
	}
	localIndex = int32(XTclFindCompiledLocal(tls, tailName, *(*TTcl_Size)(unsafe.Pointer(bp)), int32(1), envPtr))
	_objPtr3 = tailPtr
	v11 = _objPtr3
	v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
	*(*TTcl_Size)(unsafe.Pointer(v11))--
	if v10 <= int64(1) {
		XTclFreeObj(tls, _objPtr3)
	}
	return localIndex
}

/*
 * ----------------------------------------------------------------------
 *
 * TclCompileObjectNextCmd, TclCompileObjectSelfCmd --
 *
 *	Compilations of the TclOO utility commands [next] and [self].
 *
 * ----------------------------------------------------------------------
 */

func XTclCompileObjectNextCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy2795 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, delta1, i1, v18, v24, v6 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v19, v2, v20, v21, v22, v23, v25, v3, v4, v5, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, eclIndex, i1, mapPtr, tokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v3, v4, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1) /* TIP #280 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) > int32(255) {
		return int32(TCL_ERROR)
	}
	i1 = 0
	for {
		if !(i1 < int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)) {
			break
		}
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v3 = envPtr2 + 152
				v2 = *(*uintptr)(unsafe.Pointer(v3))
				*(*uintptr)(unsafe.Pointer(v3))++
				*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v5 = envPtr2 + 152
				v4 = *(*uintptr)(unsafe.Pointer(v5))
				*(*uintptr)(unsafe.Pointer(v5))++
				*(*uint8)(unsafe.Pointer(v4)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v6 = delta1
					v7 = envPtr2
					if v6 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v7 + 64)) += int64(v6)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v9 = envPtr2 + 152
				v8 = *(*uintptr)(unsafe.Pointer(v9))
				*(*uintptr)(unsafe.Pointer(v9))++
				*(*uint8)(unsafe.Pointer(v8)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v11 = envPtr2 + 152
				v10 = *(*uintptr)(unsafe.Pointer(v11))
				*(*uintptr)(unsafe.Pointer(v11))++
				*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
				v13 = envPtr2 + 152
				v12 = *(*uintptr)(unsafe.Pointer(v13))
				*(*uintptr)(unsafe.Pointer(v13))++
				*(*uint8)(unsafe.Pointer(v12)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
				v15 = envPtr2 + 152
				v14 = *(*uintptr)(unsafe.Pointer(v15))
				*(*uintptr)(unsafe.Pointer(v15))++
				*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
				v17 = envPtr2 + 152
				v16 = *(*uintptr)(unsafe.Pointer(v17))
				*(*uintptr)(unsafe.Pointer(v17))++
				*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v18 = delta1
					v19 = envPtr2
					if v18 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v19 + 64)) += int64(v18)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		goto _1
	_1:
		;
		i1++
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v21 = envPtr2 + 152
	v20 = *(*uintptr)(unsafe.Pointer(v21))
	*(*uintptr)(unsafe.Pointer(v21))++
	*(*uint8)(unsafe.Pointer(v20)) = libc.Uint8FromInt32(int32(INST_TCLOO_NEXT))
	v23 = envPtr2 + 152
	v22 = *(*uintptr)(unsafe.Pointer(v23))
	*(*uintptr)(unsafe.Pointer(v23))++
	*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(i1))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_TCLOO_NEXT)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - i1
		}
		v24 = delta1
		v25 = envPtr2
		if v24 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v25 + 64)) += int64(v24)
	}
	return TCL_OK
}

func XTclCompileObjectNextToCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy2819 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, delta1, i1, v18, v24, v6 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v19, v2, v20, v21, v22, v23, v25, v3, v4, v5, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, eclIndex, i1, mapPtr, tokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v3, v4, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1) /* TIP #280 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) < int32(2) || int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) > int32(255) {
		return int32(TCL_ERROR)
	}
	i1 = 0
	for {
		if !(i1 < int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)) {
			break
		}
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v3 = envPtr2 + 152
				v2 = *(*uintptr)(unsafe.Pointer(v3))
				*(*uintptr)(unsafe.Pointer(v3))++
				*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v5 = envPtr2 + 152
				v4 = *(*uintptr)(unsafe.Pointer(v5))
				*(*uintptr)(unsafe.Pointer(v5))++
				*(*uint8)(unsafe.Pointer(v4)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v6 = delta1
					v7 = envPtr2
					if v6 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v7 + 64)) += int64(v6)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v9 = envPtr2 + 152
				v8 = *(*uintptr)(unsafe.Pointer(v9))
				*(*uintptr)(unsafe.Pointer(v9))++
				*(*uint8)(unsafe.Pointer(v8)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v11 = envPtr2 + 152
				v10 = *(*uintptr)(unsafe.Pointer(v11))
				*(*uintptr)(unsafe.Pointer(v11))++
				*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
				v13 = envPtr2 + 152
				v12 = *(*uintptr)(unsafe.Pointer(v13))
				*(*uintptr)(unsafe.Pointer(v13))++
				*(*uint8)(unsafe.Pointer(v12)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
				v15 = envPtr2 + 152
				v14 = *(*uintptr)(unsafe.Pointer(v15))
				*(*uintptr)(unsafe.Pointer(v15))++
				*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
				v17 = envPtr2 + 152
				v16 = *(*uintptr)(unsafe.Pointer(v17))
				*(*uintptr)(unsafe.Pointer(v17))++
				*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v18 = delta1
					v19 = envPtr2
					if v18 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v19 + 64)) += int64(v18)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		goto _1
	_1:
		;
		i1++
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v21 = envPtr2 + 152
	v20 = *(*uintptr)(unsafe.Pointer(v21))
	*(*uintptr)(unsafe.Pointer(v21))++
	*(*uint8)(unsafe.Pointer(v20)) = libc.Uint8FromInt32(int32(INST_TCLOO_NEXT_CLASS))
	v23 = envPtr2 + 152
	v22 = *(*uintptr)(unsafe.Pointer(v23))
	*(*uintptr)(unsafe.Pointer(v23))++
	*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(i1))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_TCLOO_NEXT_CLASS)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - i1
		}
		v24 = delta1
		v25 = envPtr2
		if v24 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v25 + 64)) += int64(v24)
	}
	return TCL_OK
}

func XTclCompileObjectSelfCmd(tls *libc.TLS, dummy2840 uintptr, parsePtr uintptr, dummy2843 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var delta1, v11, v15, v3, v7 int32
	var subcmd, tokenPtr, v1, v10, v12, v13, v14, v16, v2, v4, v5, v6, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = delta1, subcmd, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v2, v3, v4, v5, v6, v7, v8, v9
	/*
	 * We only handle [self] and [self object] (which is the same operation).
	 * These are the only very common operations on [self] for which
	 * bytecoding is at all reasonable.
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(1) {
		goto compileSelfObject
	} else {
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(2) {
			tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
			if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) || (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize == 0 {
				return int32(TCL_ERROR)
			}
			subcmd = tokenPtr + uintptr(1)*32
			if libc.Xstrncmp(tls, (*TTcl_Token)(unsafe.Pointer(subcmd)).Fstart, __ccgo_ts+6499, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(subcmd)).Fsize)) == 0 {
				goto compileSelfObject
			} else {
				if libc.Xstrncmp(tls, (*TTcl_Token)(unsafe.Pointer(subcmd)).Fstart, __ccgo_ts+21846, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(subcmd)).Fsize)) == 0 {
					goto compileSelfNamespace
				}
			}
		}
	}
	/*
	 * Can't compile; handle with runtime call.
	 */
	return int32(TCL_ERROR)
	goto compileSelfObject
compileSelfObject:
	;
	/*
	 * This delegates the entire problem to a single opcode.
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v2 = envPtr2 + 152
	v1 = *(*uintptr)(unsafe.Pointer(v2))
	*(*uintptr)(unsafe.Pointer(v2))++
	*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_TCLOO_SELF))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_TCLOO_SELF)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v3 = delta1
		v4 = envPtr2
		if v3 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v4)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v4)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v4)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v4)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v4 + 64)) += int64(v3)
	}
	return TCL_OK
	goto compileSelfNamespace
compileSelfNamespace:
	;
	/*
	 * This is formally only correct with TclOO methods as they are currently
	 * implemented; it assumes that the current namespace is invariably when a
	 * TclOO context is present is the object's namespace, and that's
	 * technically only something that's a matter of current policy. But it
	 * avoids creating another opcode, so that's all good!
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v6 = envPtr2 + 152
	v5 = *(*uintptr)(unsafe.Pointer(v6))
	*(*uintptr)(unsafe.Pointer(v6))++
	*(*uint8)(unsafe.Pointer(v5)) = libc.Uint8FromInt32(int32(INST_TCLOO_SELF))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_TCLOO_SELF)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v7 = delta1
		v8 = envPtr2
		if v7 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v8)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v8)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v8)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v8)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v8 + 64)) += int64(v7)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v10 = envPtr2 + 152
	v9 = *(*uintptr)(unsafe.Pointer(v10))
	*(*uintptr)(unsafe.Pointer(v10))++
	*(*uint8)(unsafe.Pointer(v9)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v11 = delta1
		v12 = envPtr2
		if v11 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v12)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v12)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v12)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v12)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v12 + 64)) += int64(v11)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v14 = envPtr2 + 152
	v13 = *(*uintptr)(unsafe.Pointer(v14))
	*(*uintptr)(unsafe.Pointer(v14))++
	*(*uint8)(unsafe.Pointer(v13)) = libc.Uint8FromInt32(int32(INST_NS_CURRENT))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_NS_CURRENT)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v15 = delta1
		v16 = envPtr2
		if v15 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v16)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v16)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v16)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v16)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v16 + 64)) += int64(v15)
	}
	return TCL_OK
}

func init() {
	p := unsafe.Pointer(&XtclJumptableInfoType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_DupJumptableInfo)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_FreeJumptableInfo)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_PrintJumptableInfo)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_DisassembleJumptableInfo)
}

/*
 * Shorthand macros for instruction issuing.
 */

/*
 *----------------------------------------------------------------------
 *
 * TclCompileSetCmd --
 *
 *	Procedure called to compile the "set" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "set" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileSetCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy128 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds resulting instructions. */
	var _objIndexCopy, delta1, isAssignment, numWords, v17, v21, v22, v23, v24, v25, v29, v32, v33, v34, v35, v39, v48, v49, v5, v50, v51, v55, v56, v57, v58, v59, v63, v66, v67, v68, v69, v73, v82, v83, v84, v85 int32
	var eclIndex TTcl_Size
	var mapPtr, valueTokenPtr, varTokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v26, v27, v28, v3, v30, v31, v36, v37, v38, v4, v40, v41, v42, v43, v44, v45, v46, v47, v52, v53, v54, v6, v60, v61, v62, v64, v65, v7, v70, v71, v72, v74, v75, v76, v77, v78, v79, v8, v80, v81, v86, v9 uintptr
	var _ /* isScalar at bp+0 */ int32
	var _ /* localIndex at bp+4 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, eclIndex, isAssignment, mapPtr, numWords, valueTokenPtr, varTokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	numWords = int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)
	if numWords != int32(2) && numWords != int32(3) {
		return int32(TCL_ERROR)
	}
	isAssignment = libc.BoolInt32(numWords == int32(3))
	/*
	 * Decide if we can use a frame slot for the var/array name or if we need
	 * to emit code to compute and push the name at runtime. We use a frame
	 * slot (entry in the array of local vars) if we are compiling a procedure
	 * body and if the name is simple text that does not include namespace
	 * qualifiers.
	 */
	varTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
	XTclPushVarName(tls, interp, varTokenPtr, envPtr2, 0, bp+4, bp)
	/*
	 * If we are doing an assignment, push the new value.
	 */
	if isAssignment != 0 {
		valueTokenPtr = varTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if (*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(valueTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(valueTokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v2 = envPtr2 + 152
				v1 = *(*uintptr)(unsafe.Pointer(v2))
				*(*uintptr)(unsafe.Pointer(v2))++
				*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v4 = envPtr2 + 152
				v3 = *(*uintptr)(unsafe.Pointer(v4))
				*(*uintptr)(unsafe.Pointer(v4))++
				*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v5 = delta1
					v6 = envPtr2
					if v5 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v8 = envPtr2 + 152
				v7 = *(*uintptr)(unsafe.Pointer(v8))
				*(*uintptr)(unsafe.Pointer(v8))++
				*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v10 = envPtr2 + 152
				v9 = *(*uintptr)(unsafe.Pointer(v10))
				*(*uintptr)(unsafe.Pointer(v10))++
				*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
				v12 = envPtr2 + 152
				v11 = *(*uintptr)(unsafe.Pointer(v12))
				*(*uintptr)(unsafe.Pointer(v12))++
				*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
				v14 = envPtr2 + 152
				v13 = *(*uintptr)(unsafe.Pointer(v14))
				*(*uintptr)(unsafe.Pointer(v14))++
				*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
				v16 = envPtr2 + 152
				v15 = *(*uintptr)(unsafe.Pointer(v16))
				*(*uintptr)(unsafe.Pointer(v16))++
				*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v17 = delta1
					v18 = envPtr2
					if v17 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
			XTclCompileTokens(tls, interp, valueTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).FnumComponents), envPtr2)
		}
	}
	/*
	 * Emit instructions to set/get the variable.
	 */
	if *(*int32)(unsafe.Pointer(bp)) != 0 {
		if *(*int32)(unsafe.Pointer(bp + 4)) < 0 {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v20 = envPtr2 + 152
			v19 = *(*uintptr)(unsafe.Pointer(v20))
			*(*uintptr)(unsafe.Pointer(v20))++
			if isAssignment != 0 {
				v21 = int32(INST_STORE_STK)
			} else {
				v21 = int32(INST_LOAD_STK)
			}
			*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(v21)
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				if isAssignment != 0 {
					v23 = int32(INST_STORE_STK)
				} else {
					v23 = int32(INST_LOAD_STK)
				}
				if v23 == int32(INST_START_CMD) {
					v22 = int32(1)
				} else {
					v22 = 0
				}
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = v22
			}
			if isAssignment != 0 {
				v24 = int32(INST_STORE_STK)
			} else {
				v24 = int32(INST_LOAD_STK)
			}
			delta1 = XtclInstructionTable[libc.Uint8FromInt32(v24)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v25 = delta1
				v26 = envPtr2
				if v25 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v26)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v26)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v26)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v26)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v26 + 64)) += int64(v25)
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 4)) <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v28 = envPtr2 + 152
				v27 = *(*uintptr)(unsafe.Pointer(v28))
				*(*uintptr)(unsafe.Pointer(v28))++
				if isAssignment != 0 {
					v29 = int32(INST_STORE_SCALAR1)
				} else {
					v29 = int32(INST_LOAD_SCALAR1)
				}
				*(*uint8)(unsafe.Pointer(v27)) = libc.Uint8FromInt32(v29)
				v31 = envPtr2 + 152
				v30 = *(*uintptr)(unsafe.Pointer(v31))
				*(*uintptr)(unsafe.Pointer(v31))++
				*(*uint8)(unsafe.Pointer(v30)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					if isAssignment != 0 {
						v33 = int32(INST_STORE_SCALAR1)
					} else {
						v33 = int32(INST_LOAD_SCALAR1)
					}
					if v33 == int32(INST_START_CMD) {
						v32 = int32(1)
					} else {
						v32 = 0
					}
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = v32
				}
				if isAssignment != 0 {
					v34 = int32(INST_STORE_SCALAR1)
				} else {
					v34 = int32(INST_LOAD_SCALAR1)
				}
				delta1 = XtclInstructionTable[libc.Uint8FromInt32(v34)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
					}
					v35 = delta1
					v36 = envPtr2
					if v35 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v36 + 64)) += int64(v35)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v38 = envPtr2 + 152
				v37 = *(*uintptr)(unsafe.Pointer(v38))
				*(*uintptr)(unsafe.Pointer(v38))++
				if isAssignment != 0 {
					v39 = int32(INST_STORE_SCALAR4)
				} else {
					v39 = int32(INST_LOAD_SCALAR4)
				}
				*(*uint8)(unsafe.Pointer(v37)) = libc.Uint8FromInt32(v39)
				v41 = envPtr2 + 152
				v40 = *(*uintptr)(unsafe.Pointer(v41))
				*(*uintptr)(unsafe.Pointer(v41))++
				*(*uint8)(unsafe.Pointer(v40)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(24))
				v43 = envPtr2 + 152
				v42 = *(*uintptr)(unsafe.Pointer(v43))
				*(*uintptr)(unsafe.Pointer(v43))++
				*(*uint8)(unsafe.Pointer(v42)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(16))
				v45 = envPtr2 + 152
				v44 = *(*uintptr)(unsafe.Pointer(v45))
				*(*uintptr)(unsafe.Pointer(v45))++
				*(*uint8)(unsafe.Pointer(v44)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(8))
				v47 = envPtr2 + 152
				v46 = *(*uintptr)(unsafe.Pointer(v47))
				*(*uintptr)(unsafe.Pointer(v47))++
				*(*uint8)(unsafe.Pointer(v46)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					if isAssignment != 0 {
						v49 = int32(INST_STORE_SCALAR4)
					} else {
						v49 = int32(INST_LOAD_SCALAR4)
					}
					if v49 == int32(INST_START_CMD) {
						v48 = int32(1)
					} else {
						v48 = 0
					}
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = v48
				}
				if isAssignment != 0 {
					v50 = int32(INST_STORE_SCALAR4)
				} else {
					v50 = int32(INST_LOAD_SCALAR4)
				}
				delta1 = XtclInstructionTable[libc.Uint8FromInt32(v50)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
					}
					v51 = delta1
					v52 = envPtr2
					if v51 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v52)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v52)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v52)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v52)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v52 + 64)) += int64(v51)
				}
			}
		}
	} else {
		if *(*int32)(unsafe.Pointer(bp + 4)) < 0 {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v54 = envPtr2 + 152
			v53 = *(*uintptr)(unsafe.Pointer(v54))
			*(*uintptr)(unsafe.Pointer(v54))++
			if isAssignment != 0 {
				v55 = int32(INST_STORE_ARRAY_STK)
			} else {
				v55 = int32(INST_LOAD_ARRAY_STK)
			}
			*(*uint8)(unsafe.Pointer(v53)) = libc.Uint8FromInt32(v55)
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				if isAssignment != 0 {
					v57 = int32(INST_STORE_ARRAY_STK)
				} else {
					v57 = int32(INST_LOAD_ARRAY_STK)
				}
				if v57 == int32(INST_START_CMD) {
					v56 = int32(1)
				} else {
					v56 = 0
				}
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = v56
			}
			if isAssignment != 0 {
				v58 = int32(INST_STORE_ARRAY_STK)
			} else {
				v58 = int32(INST_LOAD_ARRAY_STK)
			}
			delta1 = XtclInstructionTable[libc.Uint8FromInt32(v58)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v59 = delta1
				v60 = envPtr2
				if v59 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v60)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v60)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v60)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v60)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v60 + 64)) += int64(v59)
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 4)) <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v62 = envPtr2 + 152
				v61 = *(*uintptr)(unsafe.Pointer(v62))
				*(*uintptr)(unsafe.Pointer(v62))++
				if isAssignment != 0 {
					v63 = int32(INST_STORE_ARRAY1)
				} else {
					v63 = int32(INST_LOAD_ARRAY1)
				}
				*(*uint8)(unsafe.Pointer(v61)) = libc.Uint8FromInt32(v63)
				v65 = envPtr2 + 152
				v64 = *(*uintptr)(unsafe.Pointer(v65))
				*(*uintptr)(unsafe.Pointer(v65))++
				*(*uint8)(unsafe.Pointer(v64)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					if isAssignment != 0 {
						v67 = int32(INST_STORE_ARRAY1)
					} else {
						v67 = int32(INST_LOAD_ARRAY1)
					}
					if v67 == int32(INST_START_CMD) {
						v66 = int32(1)
					} else {
						v66 = 0
					}
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = v66
				}
				if isAssignment != 0 {
					v68 = int32(INST_STORE_ARRAY1)
				} else {
					v68 = int32(INST_LOAD_ARRAY1)
				}
				delta1 = XtclInstructionTable[libc.Uint8FromInt32(v68)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
					}
					v69 = delta1
					v70 = envPtr2
					if v69 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v70 + 64)) += int64(v69)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v72 = envPtr2 + 152
				v71 = *(*uintptr)(unsafe.Pointer(v72))
				*(*uintptr)(unsafe.Pointer(v72))++
				if isAssignment != 0 {
					v73 = int32(INST_STORE_ARRAY4)
				} else {
					v73 = int32(INST_LOAD_ARRAY4)
				}
				*(*uint8)(unsafe.Pointer(v71)) = libc.Uint8FromInt32(v73)
				v75 = envPtr2 + 152
				v74 = *(*uintptr)(unsafe.Pointer(v75))
				*(*uintptr)(unsafe.Pointer(v75))++
				*(*uint8)(unsafe.Pointer(v74)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(24))
				v77 = envPtr2 + 152
				v76 = *(*uintptr)(unsafe.Pointer(v77))
				*(*uintptr)(unsafe.Pointer(v77))++
				*(*uint8)(unsafe.Pointer(v76)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(16))
				v79 = envPtr2 + 152
				v78 = *(*uintptr)(unsafe.Pointer(v79))
				*(*uintptr)(unsafe.Pointer(v79))++
				*(*uint8)(unsafe.Pointer(v78)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(8))
				v81 = envPtr2 + 152
				v80 = *(*uintptr)(unsafe.Pointer(v81))
				*(*uintptr)(unsafe.Pointer(v81))++
				*(*uint8)(unsafe.Pointer(v80)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					if isAssignment != 0 {
						v83 = int32(INST_STORE_ARRAY4)
					} else {
						v83 = int32(INST_LOAD_ARRAY4)
					}
					if v83 == int32(INST_START_CMD) {
						v82 = int32(1)
					} else {
						v82 = 0
					}
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = v82
				}
				if isAssignment != 0 {
					v84 = int32(INST_STORE_ARRAY4)
				} else {
					v84 = int32(INST_LOAD_ARRAY4)
				}
				delta1 = XtclInstructionTable[libc.Uint8FromInt32(v84)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp + 4))
					}
					v85 = delta1
					v86 = envPtr2
					if v85 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v86)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v86)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v86)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v86)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v86 + 64)) += int64(v85)
				}
			}
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileString*Cmd --
 *
 *	Procedures called to compile various subcommands of the "string"
 *	command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "string" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileStringCatCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy221 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, delta1, i1, numArgs, numWords, v17, v30, v42, v5, v50, v62, v68, v75, v87, v95 int32
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, bytes, bytes1, cachePtr, folded, mapPtr, obj, wordTokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v2, v22, v24, v25, v26, v27, v28, v29, v3, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v43, v45, v46, v47, v48, v49, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v63, v64, v65, v66, v67, v69, v7, v70, v71, v72, v73, v74, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v88, v9, v90, v91, v92, v93, v94, v96 uintptr
	var eclIndex, v21, v23, v44, v89 TTcl_Size
	var v20 bool
	var _ /* len at bp+0 */ TTcl_Size
	var _ /* len at bp+8 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, _objPtr, _objPtr1, _objPtr2, _objPtr3, bytes, bytes1, cachePtr, delta1, eclIndex, folded, i1, mapPtr, numArgs, numWords, obj, wordTokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v95, v96
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	numWords = int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)
	/* Trivial case, no arg */
	if numWords < int32(2) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
		return TCL_OK
	}
	/* General case: issue CONCAT1's (by chunks of 254 if needed), folding
	 * contiguous constants along the way */
	numArgs = 0
	folded = libc.UintptrFromInt32(0)
	wordTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	i1 = int32(1)
	for {
		if !(i1 < numWords) {
			break
		}
		if v20 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v20 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v20 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			obj = XTclThreadAllocObj(tls)
		} else {
			obj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(obj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(obj)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(obj)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr = libc.UintptrFromInt32(0)
		if XTclWordKnownAtCompileTime(tls, wordTokenPtr, obj) != 0 {
			if folded != 0 {
				XTcl_AppendObjToObj(tls, folded, obj)
				_objPtr = obj
				v22 = _objPtr
				v21 = *(*TTcl_Size)(unsafe.Pointer(v22))
				*(*TTcl_Size)(unsafe.Pointer(v22))--
				if v21 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
			} else {
				folded = obj
			}
		} else {
			_objPtr1 = obj
			v24 = _objPtr1
			v23 = *(*TTcl_Size)(unsafe.Pointer(v24))
			*(*TTcl_Size)(unsafe.Pointer(v24))--
			if v23 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
			if folded != 0 {
				if (*TTcl_Obj)(unsafe.Pointer(folded)).Fbytes != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(folded)).Flength
					v25 = (*TTcl_Obj)(unsafe.Pointer(folded)).Fbytes
				} else {
					v25 = XTcl_GetStringFromObj(tls, folded, bp)
				}
				bytes = v25
				_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, bytes, *(*TTcl_Size)(unsafe.Pointer(bp)), 0)
				if _objIndexCopy1 <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v27 = envPtr2 + 152
					v26 = *(*uintptr)(unsafe.Pointer(v27))
					*(*uintptr)(unsafe.Pointer(v27))++
					*(*uint8)(unsafe.Pointer(v26)) = libc.Uint8FromInt32(int32(INST_PUSH1))
					v29 = envPtr2 + 152
					v28 = *(*uintptr)(unsafe.Pointer(v29))
					*(*uintptr)(unsafe.Pointer(v29))++
					*(*uint8)(unsafe.Pointer(v28)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy1
						}
						v30 = delta1
						v31 = envPtr2
						if v30 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v31)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v31)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v31)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v31)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v31 + 64)) += int64(v30)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v33 = envPtr2 + 152
					v32 = *(*uintptr)(unsafe.Pointer(v33))
					*(*uintptr)(unsafe.Pointer(v33))++
					*(*uint8)(unsafe.Pointer(v32)) = libc.Uint8FromInt32(int32(INST_PUSH4))
					v35 = envPtr2 + 152
					v34 = *(*uintptr)(unsafe.Pointer(v35))
					*(*uintptr)(unsafe.Pointer(v35))++
					*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
					v37 = envPtr2 + 152
					v36 = *(*uintptr)(unsafe.Pointer(v37))
					*(*uintptr)(unsafe.Pointer(v37))++
					*(*uint8)(unsafe.Pointer(v36)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
					v39 = envPtr2 + 152
					v38 = *(*uintptr)(unsafe.Pointer(v39))
					*(*uintptr)(unsafe.Pointer(v39))++
					*(*uint8)(unsafe.Pointer(v38)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
					v41 = envPtr2 + 152
					v40 = *(*uintptr)(unsafe.Pointer(v41))
					*(*uintptr)(unsafe.Pointer(v41))++
					*(*uint8)(unsafe.Pointer(v40)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy1
						}
						v42 = delta1
						v43 = envPtr2
						if v42 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v43)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v43)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v43)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v43)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v43 + 64)) += int64(v42)
					}
				}
				_objPtr2 = folded
				v45 = _objPtr2
				v44 = *(*TTcl_Size)(unsafe.Pointer(v45))
				*(*TTcl_Size)(unsafe.Pointer(v45))--
				if v44 <= int64(1) {
					XTclFreeObj(tls, _objPtr2)
				}
				folded = libc.UintptrFromInt32(0)
				numArgs++
			}
			if (*TTcl_Token)(unsafe.Pointer(wordTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
				_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(wordTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(wordTokenPtr + 1*32))).Fsize, 0)
				if _objIndexCopy2 <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v47 = envPtr2 + 152
					v46 = *(*uintptr)(unsafe.Pointer(v47))
					*(*uintptr)(unsafe.Pointer(v47))++
					*(*uint8)(unsafe.Pointer(v46)) = libc.Uint8FromInt32(int32(INST_PUSH1))
					v49 = envPtr2 + 152
					v48 = *(*uintptr)(unsafe.Pointer(v49))
					*(*uintptr)(unsafe.Pointer(v49))++
					*(*uint8)(unsafe.Pointer(v48)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy2
						}
						v50 = delta1
						v51 = envPtr2
						if v50 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v51)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v51)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v51)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v51)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v51 + 64)) += int64(v50)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v53 = envPtr2 + 152
					v52 = *(*uintptr)(unsafe.Pointer(v53))
					*(*uintptr)(unsafe.Pointer(v53))++
					*(*uint8)(unsafe.Pointer(v52)) = libc.Uint8FromInt32(int32(INST_PUSH4))
					v55 = envPtr2 + 152
					v54 = *(*uintptr)(unsafe.Pointer(v55))
					*(*uintptr)(unsafe.Pointer(v55))++
					*(*uint8)(unsafe.Pointer(v54)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
					v57 = envPtr2 + 152
					v56 = *(*uintptr)(unsafe.Pointer(v57))
					*(*uintptr)(unsafe.Pointer(v57))++
					*(*uint8)(unsafe.Pointer(v56)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
					v59 = envPtr2 + 152
					v58 = *(*uintptr)(unsafe.Pointer(v59))
					*(*uintptr)(unsafe.Pointer(v59))++
					*(*uint8)(unsafe.Pointer(v58)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
					v61 = envPtr2 + 152
					v60 = *(*uintptr)(unsafe.Pointer(v61))
					*(*uintptr)(unsafe.Pointer(v61))++
					*(*uint8)(unsafe.Pointer(v60)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy2
						}
						v62 = delta1
						v63 = envPtr2
						if v62 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v63)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v63)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v63)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v63)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v63 + 64)) += int64(v62)
					}
				}
			} else {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
				XTclCompileTokens(tls, interp, wordTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(wordTokenPtr)).FnumComponents), envPtr2)
			}
			numArgs++
			if numArgs >= int32(254) { /* 254 to take care of the possible +1 of "folded" above */
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v65 = envPtr2 + 152
				v64 = *(*uintptr)(unsafe.Pointer(v65))
				*(*uintptr)(unsafe.Pointer(v65))++
				*(*uint8)(unsafe.Pointer(v64)) = libc.Uint8FromInt32(int32(INST_STR_CONCAT1))
				v67 = envPtr2 + 152
				v66 = *(*uintptr)(unsafe.Pointer(v67))
				*(*uintptr)(unsafe.Pointer(v67))++
				*(*uint8)(unsafe.Pointer(v66)) = uint8(libc.Uint32FromInt32(numArgs))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_STR_CONCAT1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - numArgs
					}
					v68 = delta1
					v69 = envPtr2
					if v68 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v69)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v69)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v69)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v69)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v69 + 64)) += int64(v68)
				}
				numArgs = int32(1) /* concat pushes 1 obj, the result */
			}
		}
		wordTokenPtr = wordTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(wordTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		goto _19
	_19:
		;
		i1++
	}
	if folded != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(folded)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(folded)).Flength
			v70 = (*TTcl_Obj)(unsafe.Pointer(folded)).Fbytes
		} else {
			v70 = XTcl_GetStringFromObj(tls, folded, bp+8)
		}
		bytes1 = v70
		_objIndexCopy3 = XTclRegisterLiteral(tls, envPtr2, bytes1, *(*TTcl_Size)(unsafe.Pointer(bp + 8)), 0)
		if _objIndexCopy3 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v72 = envPtr2 + 152
			v71 = *(*uintptr)(unsafe.Pointer(v72))
			*(*uintptr)(unsafe.Pointer(v72))++
			*(*uint8)(unsafe.Pointer(v71)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v74 = envPtr2 + 152
			v73 = *(*uintptr)(unsafe.Pointer(v74))
			*(*uintptr)(unsafe.Pointer(v74))++
			*(*uint8)(unsafe.Pointer(v73)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy3
				}
				v75 = delta1
				v76 = envPtr2
				if v75 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v76)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v76)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v76)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v76)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v76 + 64)) += int64(v75)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v78 = envPtr2 + 152
			v77 = *(*uintptr)(unsafe.Pointer(v78))
			*(*uintptr)(unsafe.Pointer(v78))++
			*(*uint8)(unsafe.Pointer(v77)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v80 = envPtr2 + 152
			v79 = *(*uintptr)(unsafe.Pointer(v80))
			*(*uintptr)(unsafe.Pointer(v80))++
			*(*uint8)(unsafe.Pointer(v79)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(24))
			v82 = envPtr2 + 152
			v81 = *(*uintptr)(unsafe.Pointer(v82))
			*(*uintptr)(unsafe.Pointer(v82))++
			*(*uint8)(unsafe.Pointer(v81)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(16))
			v84 = envPtr2 + 152
			v83 = *(*uintptr)(unsafe.Pointer(v84))
			*(*uintptr)(unsafe.Pointer(v84))++
			*(*uint8)(unsafe.Pointer(v83)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(8))
			v86 = envPtr2 + 152
			v85 = *(*uintptr)(unsafe.Pointer(v86))
			*(*uintptr)(unsafe.Pointer(v86))++
			*(*uint8)(unsafe.Pointer(v85)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy3
				}
				v87 = delta1
				v88 = envPtr2
				if v87 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v88)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v88)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v88)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v88)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v88 + 64)) += int64(v87)
			}
		}
		_objPtr3 = folded
		v90 = _objPtr3
		v89 = *(*TTcl_Size)(unsafe.Pointer(v90))
		*(*TTcl_Size)(unsafe.Pointer(v90))--
		if v89 <= int64(1) {
			XTclFreeObj(tls, _objPtr3)
		}
		folded = libc.UintptrFromInt32(0)
		numArgs++
	}
	if numArgs > int32(1) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v92 = envPtr2 + 152
		v91 = *(*uintptr)(unsafe.Pointer(v92))
		*(*uintptr)(unsafe.Pointer(v92))++
		*(*uint8)(unsafe.Pointer(v91)) = libc.Uint8FromInt32(int32(INST_STR_CONCAT1))
		v94 = envPtr2 + 152
		v93 = *(*uintptr)(unsafe.Pointer(v94))
		*(*uintptr)(unsafe.Pointer(v94))++
		*(*uint8)(unsafe.Pointer(v93)) = uint8(libc.Uint32FromInt32(numArgs))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STR_CONCAT1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - numArgs
			}
			v95 = delta1
			v96 = envPtr2
			if v95 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v96)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v96)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v96)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v96)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v96 + 64)) += int64(v95)
		}
	}
	return TCL_OK
}

func XTclCompileStringCmpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy292 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, delta1, v17, v23, v35, v39, v5 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v36, v37, v38, v4, v40, v6, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, delta1, eclIndex, mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	/*
	 * We don't support any flags; the bytecode isn't that sophisticated.
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(3) {
		return int32(TCL_ERROR)
	}
	/*
	 * Push the two operands onto the stack and then the test.
	 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy1 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v20 = envPtr2 + 152
			v19 = *(*uintptr)(unsafe.Pointer(v20))
			*(*uintptr)(unsafe.Pointer(v20))++
			*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v22 = envPtr2 + 152
			v21 = *(*uintptr)(unsafe.Pointer(v22))
			*(*uintptr)(unsafe.Pointer(v22))++
			*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v23 = delta1
				v24 = envPtr2
				if v23 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v24 + 64)) += int64(v23)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v26 = envPtr2 + 152
			v25 = *(*uintptr)(unsafe.Pointer(v26))
			*(*uintptr)(unsafe.Pointer(v26))++
			*(*uint8)(unsafe.Pointer(v25)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v28 = envPtr2 + 152
			v27 = *(*uintptr)(unsafe.Pointer(v28))
			*(*uintptr)(unsafe.Pointer(v28))++
			*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
			v30 = envPtr2 + 152
			v29 = *(*uintptr)(unsafe.Pointer(v30))
			*(*uintptr)(unsafe.Pointer(v30))++
			*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
			v32 = envPtr2 + 152
			v31 = *(*uintptr)(unsafe.Pointer(v32))
			*(*uintptr)(unsafe.Pointer(v32))++
			*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
			v34 = envPtr2 + 152
			v33 = *(*uintptr)(unsafe.Pointer(v34))
			*(*uintptr)(unsafe.Pointer(v34))++
			*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v35 = delta1
				v36 = envPtr2
				if v35 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v36 + 64)) += int64(v35)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v38 = envPtr2 + 152
	v37 = *(*uintptr)(unsafe.Pointer(v38))
	*(*uintptr)(unsafe.Pointer(v38))++
	*(*uint8)(unsafe.Pointer(v37)) = libc.Uint8FromInt32(int32(INST_STR_CMP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_STR_CMP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v39 = delta1
		v40 = envPtr2
		if v39 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v40 + 64)) += int64(v39)
	}
	return TCL_OK
}

func XTclCompileStringEqualCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy323 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, delta1, v17, v23, v35, v39, v5 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v36, v37, v38, v4, v40, v6, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, delta1, eclIndex, mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	/*
	 * We don't support any flags; the bytecode isn't that sophisticated.
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(3) {
		return int32(TCL_ERROR)
	}
	/*
	 * Push the two operands onto the stack and then the test.
	 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy1 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v20 = envPtr2 + 152
			v19 = *(*uintptr)(unsafe.Pointer(v20))
			*(*uintptr)(unsafe.Pointer(v20))++
			*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v22 = envPtr2 + 152
			v21 = *(*uintptr)(unsafe.Pointer(v22))
			*(*uintptr)(unsafe.Pointer(v22))++
			*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v23 = delta1
				v24 = envPtr2
				if v23 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v24 + 64)) += int64(v23)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v26 = envPtr2 + 152
			v25 = *(*uintptr)(unsafe.Pointer(v26))
			*(*uintptr)(unsafe.Pointer(v26))++
			*(*uint8)(unsafe.Pointer(v25)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v28 = envPtr2 + 152
			v27 = *(*uintptr)(unsafe.Pointer(v28))
			*(*uintptr)(unsafe.Pointer(v28))++
			*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
			v30 = envPtr2 + 152
			v29 = *(*uintptr)(unsafe.Pointer(v30))
			*(*uintptr)(unsafe.Pointer(v30))++
			*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
			v32 = envPtr2 + 152
			v31 = *(*uintptr)(unsafe.Pointer(v32))
			*(*uintptr)(unsafe.Pointer(v32))++
			*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
			v34 = envPtr2 + 152
			v33 = *(*uintptr)(unsafe.Pointer(v34))
			*(*uintptr)(unsafe.Pointer(v34))++
			*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v35 = delta1
				v36 = envPtr2
				if v35 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v36 + 64)) += int64(v35)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v38 = envPtr2 + 152
	v37 = *(*uintptr)(unsafe.Pointer(v38))
	*(*uintptr)(unsafe.Pointer(v38))++
	*(*uint8)(unsafe.Pointer(v37)) = libc.Uint8FromInt32(int32(INST_STR_EQ))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_STR_EQ)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v39 = delta1
		v40 = envPtr2
		if v39 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v40 + 64)) += int64(v39)
	}
	return TCL_OK
}

func XTclCompileStringFirstCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy354 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, delta1, v17, v23, v35, v39, v5 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v36, v37, v38, v4, v40, v6, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, delta1, eclIndex, mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	/*
	 * We don't support any flags; the bytecode isn't that sophisticated.
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(3) {
		return int32(TCL_ERROR)
	}
	/*
	 * Push the two operands onto the stack and then the test.
	 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy1 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v20 = envPtr2 + 152
			v19 = *(*uintptr)(unsafe.Pointer(v20))
			*(*uintptr)(unsafe.Pointer(v20))++
			*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v22 = envPtr2 + 152
			v21 = *(*uintptr)(unsafe.Pointer(v22))
			*(*uintptr)(unsafe.Pointer(v22))++
			*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v23 = delta1
				v24 = envPtr2
				if v23 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v24 + 64)) += int64(v23)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v26 = envPtr2 + 152
			v25 = *(*uintptr)(unsafe.Pointer(v26))
			*(*uintptr)(unsafe.Pointer(v26))++
			*(*uint8)(unsafe.Pointer(v25)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v28 = envPtr2 + 152
			v27 = *(*uintptr)(unsafe.Pointer(v28))
			*(*uintptr)(unsafe.Pointer(v28))++
			*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
			v30 = envPtr2 + 152
			v29 = *(*uintptr)(unsafe.Pointer(v30))
			*(*uintptr)(unsafe.Pointer(v30))++
			*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
			v32 = envPtr2 + 152
			v31 = *(*uintptr)(unsafe.Pointer(v32))
			*(*uintptr)(unsafe.Pointer(v32))++
			*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
			v34 = envPtr2 + 152
			v33 = *(*uintptr)(unsafe.Pointer(v34))
			*(*uintptr)(unsafe.Pointer(v34))++
			*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v35 = delta1
				v36 = envPtr2
				if v35 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v36 + 64)) += int64(v35)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v38 = envPtr2 + 152
	v37 = *(*uintptr)(unsafe.Pointer(v38))
	*(*uintptr)(unsafe.Pointer(v38))++
	*(*uint8)(unsafe.Pointer(v37)) = libc.Uint8FromInt32(int32(INST_STR_FIND))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_STR_FIND)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v39 = delta1
		v40 = envPtr2
		if v39 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v40 + 64)) += int64(v39)
	}
	return TCL_OK
}

func XTclCompileStringLastCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy385 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, delta1, v17, v23, v35, v39, v5 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v36, v37, v38, v4, v40, v6, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, delta1, eclIndex, mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	/*
	 * We don't support any flags; the bytecode isn't that sophisticated.
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(3) {
		return int32(TCL_ERROR)
	}
	/*
	 * Push the two operands onto the stack and then the test.
	 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy1 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v20 = envPtr2 + 152
			v19 = *(*uintptr)(unsafe.Pointer(v20))
			*(*uintptr)(unsafe.Pointer(v20))++
			*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v22 = envPtr2 + 152
			v21 = *(*uintptr)(unsafe.Pointer(v22))
			*(*uintptr)(unsafe.Pointer(v22))++
			*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v23 = delta1
				v24 = envPtr2
				if v23 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v24 + 64)) += int64(v23)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v26 = envPtr2 + 152
			v25 = *(*uintptr)(unsafe.Pointer(v26))
			*(*uintptr)(unsafe.Pointer(v26))++
			*(*uint8)(unsafe.Pointer(v25)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v28 = envPtr2 + 152
			v27 = *(*uintptr)(unsafe.Pointer(v28))
			*(*uintptr)(unsafe.Pointer(v28))++
			*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
			v30 = envPtr2 + 152
			v29 = *(*uintptr)(unsafe.Pointer(v30))
			*(*uintptr)(unsafe.Pointer(v30))++
			*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
			v32 = envPtr2 + 152
			v31 = *(*uintptr)(unsafe.Pointer(v32))
			*(*uintptr)(unsafe.Pointer(v32))++
			*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
			v34 = envPtr2 + 152
			v33 = *(*uintptr)(unsafe.Pointer(v34))
			*(*uintptr)(unsafe.Pointer(v34))++
			*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v35 = delta1
				v36 = envPtr2
				if v35 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v36 + 64)) += int64(v35)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v38 = envPtr2 + 152
	v37 = *(*uintptr)(unsafe.Pointer(v38))
	*(*uintptr)(unsafe.Pointer(v38))++
	*(*uint8)(unsafe.Pointer(v37)) = libc.Uint8FromInt32(int32(INST_STR_FIND_LAST))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_STR_FIND_LAST)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v39 = delta1
		v40 = envPtr2
		if v39 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v40 + 64)) += int64(v39)
	}
	return TCL_OK
}

func XTclCompileStringIndexCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy416 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, delta1, v17, v23, v35, v39, v5 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v36, v37, v38, v4, v40, v6, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, delta1, eclIndex, mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(3) {
		return int32(TCL_ERROR)
	}
	/*
	 * Push the two operands onto the stack and then the index operation.
	 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy1 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v20 = envPtr2 + 152
			v19 = *(*uintptr)(unsafe.Pointer(v20))
			*(*uintptr)(unsafe.Pointer(v20))++
			*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v22 = envPtr2 + 152
			v21 = *(*uintptr)(unsafe.Pointer(v22))
			*(*uintptr)(unsafe.Pointer(v22))++
			*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v23 = delta1
				v24 = envPtr2
				if v23 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v24 + 64)) += int64(v23)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v26 = envPtr2 + 152
			v25 = *(*uintptr)(unsafe.Pointer(v26))
			*(*uintptr)(unsafe.Pointer(v26))++
			*(*uint8)(unsafe.Pointer(v25)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v28 = envPtr2 + 152
			v27 = *(*uintptr)(unsafe.Pointer(v28))
			*(*uintptr)(unsafe.Pointer(v28))++
			*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
			v30 = envPtr2 + 152
			v29 = *(*uintptr)(unsafe.Pointer(v30))
			*(*uintptr)(unsafe.Pointer(v30))++
			*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
			v32 = envPtr2 + 152
			v31 = *(*uintptr)(unsafe.Pointer(v32))
			*(*uintptr)(unsafe.Pointer(v32))++
			*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
			v34 = envPtr2 + 152
			v33 = *(*uintptr)(unsafe.Pointer(v34))
			*(*uintptr)(unsafe.Pointer(v34))++
			*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v35 = delta1
				v36 = envPtr2
				if v35 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v36 + 64)) += int64(v35)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v38 = envPtr2 + 152
	v37 = *(*uintptr)(unsafe.Pointer(v38))
	*(*uintptr)(unsafe.Pointer(v38))++
	*(*uint8)(unsafe.Pointer(v37)) = libc.Uint8FromInt32(int32(INST_STR_INDEX))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_STR_INDEX)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v39 = delta1
		v40 = envPtr2
		if v39 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v40 + 64)) += int64(v39)
	}
	return TCL_OK
}

func XTclCompileStringInsertCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy443 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, delta1, v103, v115, v129, v17, v23, v35, v47, v5, v53, v59, v71, v83 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v100, v101, v102, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v116, v117, v118, v119, v12, v120, v121, v122, v123, v124, v125, v126, v127, v128, v13, v130, v14, v15, v16, v18, v19, v2, v20, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v48, v49, v50, v51, v52, v54, v55, v56, v57, v58, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99 uintptr
	var _ /* idx at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, delta1, eclIndex, mapPtr, tokenPtr, v1, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v123, v124, v125, v126, v127, v128, v129, v13, v130, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(4) {
		return int32(TCL_ERROR)
	}
	/* Compute and push the string in which to insert */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	/* See what can be discovered about index at compile time */
	tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if TCL_OK != XTclGetIndexFromToken(tls, tokenPtr, libc.Uint64FromInt64(libc.Int64FromInt32(0)), libc.Uint64FromInt64(int64(-libc.Int32FromInt32(2))), bp) {
		/* Nothing useful knowable - cease compile; let it direct eval */
		return int32(TCL_ERROR)
	}
	/* Compute and push the string to be inserted */
	tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy1 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v20 = envPtr2 + 152
			v19 = *(*uintptr)(unsafe.Pointer(v20))
			*(*uintptr)(unsafe.Pointer(v20))++
			*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v22 = envPtr2 + 152
			v21 = *(*uintptr)(unsafe.Pointer(v22))
			*(*uintptr)(unsafe.Pointer(v22))++
			*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v23 = delta1
				v24 = envPtr2
				if v23 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v24 + 64)) += int64(v23)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v26 = envPtr2 + 152
			v25 = *(*uintptr)(unsafe.Pointer(v26))
			*(*uintptr)(unsafe.Pointer(v26))++
			*(*uint8)(unsafe.Pointer(v25)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v28 = envPtr2 + 152
			v27 = *(*uintptr)(unsafe.Pointer(v28))
			*(*uintptr)(unsafe.Pointer(v28))++
			*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
			v30 = envPtr2 + 152
			v29 = *(*uintptr)(unsafe.Pointer(v30))
			*(*uintptr)(unsafe.Pointer(v30))++
			*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
			v32 = envPtr2 + 152
			v31 = *(*uintptr)(unsafe.Pointer(v32))
			*(*uintptr)(unsafe.Pointer(v32))++
			*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
			v34 = envPtr2 + 152
			v33 = *(*uintptr)(unsafe.Pointer(v34))
			*(*uintptr)(unsafe.Pointer(v34))++
			*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v35 = delta1
				v36 = envPtr2
				if v35 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v36 + 64)) += int64(v35)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 3*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 3*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	if *(*int32)(unsafe.Pointer(bp)) == int32(libc.Int64FromInt32(0)) {
		/* Prepend the insertion string */
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v38 = envPtr2 + 152
		v37 = *(*uintptr)(unsafe.Pointer(v38))
		*(*uintptr)(unsafe.Pointer(v38))++
		*(*uint8)(unsafe.Pointer(v37)) = libc.Uint8FromInt32(int32(INST_REVERSE))
		v40 = envPtr2 + 152
		v39 = *(*uintptr)(unsafe.Pointer(v40))
		*(*uintptr)(unsafe.Pointer(v40))++
		*(*uint8)(unsafe.Pointer(v39)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
		v42 = envPtr2 + 152
		v41 = *(*uintptr)(unsafe.Pointer(v42))
		*(*uintptr)(unsafe.Pointer(v42))++
		*(*uint8)(unsafe.Pointer(v41)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
		v44 = envPtr2 + 152
		v43 = *(*uintptr)(unsafe.Pointer(v44))
		*(*uintptr)(unsafe.Pointer(v44))++
		*(*uint8)(unsafe.Pointer(v43)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
		v46 = envPtr2 + 152
		v45 = *(*uintptr)(unsafe.Pointer(v46))
		*(*uintptr)(unsafe.Pointer(v46))++
		*(*uint8)(unsafe.Pointer(v45)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(2)
			}
			v47 = delta1
			v48 = envPtr2
			if v47 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v48)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v48)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v48)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v48)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v48 + 64)) += int64(v47)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v50 = envPtr2 + 152
		v49 = *(*uintptr)(unsafe.Pointer(v50))
		*(*uintptr)(unsafe.Pointer(v50))++
		*(*uint8)(unsafe.Pointer(v49)) = libc.Uint8FromInt32(int32(INST_STR_CONCAT1))
		v52 = envPtr2 + 152
		v51 = *(*uintptr)(unsafe.Pointer(v52))
		*(*uintptr)(unsafe.Pointer(v52))++
		*(*uint8)(unsafe.Pointer(v51)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STR_CONCAT1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(2)
			}
			v53 = delta1
			v54 = envPtr2
			if v53 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v54)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v54)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v54)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v54)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v54 + 64)) += int64(v53)
		}
	} else {
		if *(*int32)(unsafe.Pointer(bp)) == int32(int64(-libc.Int32FromInt32(2))) {
			/* Append the insertion string */
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v56 = envPtr2 + 152
			v55 = *(*uintptr)(unsafe.Pointer(v56))
			*(*uintptr)(unsafe.Pointer(v56))++
			*(*uint8)(unsafe.Pointer(v55)) = libc.Uint8FromInt32(int32(INST_STR_CONCAT1))
			v58 = envPtr2 + 152
			v57 = *(*uintptr)(unsafe.Pointer(v58))
			*(*uintptr)(unsafe.Pointer(v58))++
			*(*uint8)(unsafe.Pointer(v57)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STR_CONCAT1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - int32(2)
				}
				v59 = delta1
				v60 = envPtr2
				if v59 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v60)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v60)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v60)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v60)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v60 + 64)) += int64(v59)
			}
		} else {
			/* Prefix + insertion + suffix */
			if *(*int32)(unsafe.Pointer(bp)) < int32(int64(-libc.Int32FromInt32(2))) {
				/* See comments in compiler for [linsert]. */
				*(*int32)(unsafe.Pointer(bp))++
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v62 = envPtr2 + 152
			v61 = *(*uintptr)(unsafe.Pointer(v62))
			*(*uintptr)(unsafe.Pointer(v62))++
			*(*uint8)(unsafe.Pointer(v61)) = libc.Uint8FromInt32(int32(INST_OVER))
			v64 = envPtr2 + 152
			v63 = *(*uintptr)(unsafe.Pointer(v64))
			*(*uintptr)(unsafe.Pointer(v64))++
			*(*uint8)(unsafe.Pointer(v63)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(24))
			v66 = envPtr2 + 152
			v65 = *(*uintptr)(unsafe.Pointer(v66))
			*(*uintptr)(unsafe.Pointer(v66))++
			*(*uint8)(unsafe.Pointer(v65)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(16))
			v68 = envPtr2 + 152
			v67 = *(*uintptr)(unsafe.Pointer(v68))
			*(*uintptr)(unsafe.Pointer(v68))++
			*(*uint8)(unsafe.Pointer(v67)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(8))
			v70 = envPtr2 + 152
			v69 = *(*uintptr)(unsafe.Pointer(v70))
			*(*uintptr)(unsafe.Pointer(v70))++
			*(*uint8)(unsafe.Pointer(v69)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_OVER)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - int32(1)
				}
				v71 = delta1
				v72 = envPtr2
				if v71 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v72)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v72)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v72)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v72)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v72 + 64)) += int64(v71)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v74 = envPtr2 + 152
			v73 = *(*uintptr)(unsafe.Pointer(v74))
			*(*uintptr)(unsafe.Pointer(v74))++
			*(*uint8)(unsafe.Pointer(v73)) = libc.Uint8FromInt32(int32(INST_STR_RANGE_IMM))
			v76 = envPtr2 + 152
			v75 = *(*uintptr)(unsafe.Pointer(v76))
			*(*uintptr)(unsafe.Pointer(v76))++
			*(*uint8)(unsafe.Pointer(v75)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
			v78 = envPtr2 + 152
			v77 = *(*uintptr)(unsafe.Pointer(v78))
			*(*uintptr)(unsafe.Pointer(v78))++
			*(*uint8)(unsafe.Pointer(v77)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
			v80 = envPtr2 + 152
			v79 = *(*uintptr)(unsafe.Pointer(v80))
			*(*uintptr)(unsafe.Pointer(v80))++
			*(*uint8)(unsafe.Pointer(v79)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
			v82 = envPtr2 + 152
			v81 = *(*uintptr)(unsafe.Pointer(v82))
			*(*uintptr)(unsafe.Pointer(v82))++
			*(*uint8)(unsafe.Pointer(v81)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STR_RANGE_IMM)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v83 = delta1
				v84 = envPtr2
				if v83 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v84)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v84)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v84)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v84)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v84 + 64)) += int64(v83)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v86 = envPtr2 + 152
			v85 = *(*uintptr)(unsafe.Pointer(v86))
			*(*uintptr)(unsafe.Pointer(v86))++
			*(*uint8)(unsafe.Pointer(v85)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(24))
			v88 = envPtr2 + 152
			v87 = *(*uintptr)(unsafe.Pointer(v88))
			*(*uintptr)(unsafe.Pointer(v88))++
			*(*uint8)(unsafe.Pointer(v87)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(16))
			v90 = envPtr2 + 152
			v89 = *(*uintptr)(unsafe.Pointer(v90))
			*(*uintptr)(unsafe.Pointer(v90))++
			*(*uint8)(unsafe.Pointer(v89)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(8))
			v92 = envPtr2 + 152
			v91 = *(*uintptr)(unsafe.Pointer(v92))
			*(*uintptr)(unsafe.Pointer(v92))++
			*(*uint8)(unsafe.Pointer(v91)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp)) - libc.Int32FromInt32(1)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v94 = envPtr2 + 152
			v93 = *(*uintptr)(unsafe.Pointer(v94))
			*(*uintptr)(unsafe.Pointer(v94))++
			*(*uint8)(unsafe.Pointer(v93)) = libc.Uint8FromInt32(int32(INST_REVERSE))
			v96 = envPtr2 + 152
			v95 = *(*uintptr)(unsafe.Pointer(v96))
			*(*uintptr)(unsafe.Pointer(v96))++
			*(*uint8)(unsafe.Pointer(v95)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)) >> libc.Int32FromInt32(24))
			v98 = envPtr2 + 152
			v97 = *(*uintptr)(unsafe.Pointer(v98))
			*(*uintptr)(unsafe.Pointer(v98))++
			*(*uint8)(unsafe.Pointer(v97)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)) >> libc.Int32FromInt32(16))
			v100 = envPtr2 + 152
			v99 = *(*uintptr)(unsafe.Pointer(v100))
			*(*uintptr)(unsafe.Pointer(v100))++
			*(*uint8)(unsafe.Pointer(v99)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)) >> libc.Int32FromInt32(8))
			v102 = envPtr2 + 152
			v101 = *(*uintptr)(unsafe.Pointer(v102))
			*(*uintptr)(unsafe.Pointer(v102))++
			*(*uint8)(unsafe.Pointer(v101)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - int32(3)
				}
				v103 = delta1
				v104 = envPtr2
				if v103 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v104)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v104)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v104)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v104)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v104 + 64)) += int64(v103)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v106 = envPtr2 + 152
			v105 = *(*uintptr)(unsafe.Pointer(v106))
			*(*uintptr)(unsafe.Pointer(v106))++
			*(*uint8)(unsafe.Pointer(v105)) = libc.Uint8FromInt32(int32(INST_STR_RANGE_IMM))
			v108 = envPtr2 + 152
			v107 = *(*uintptr)(unsafe.Pointer(v108))
			*(*uintptr)(unsafe.Pointer(v108))++
			*(*uint8)(unsafe.Pointer(v107)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))) >> libc.Int32FromInt32(24))
			v110 = envPtr2 + 152
			v109 = *(*uintptr)(unsafe.Pointer(v110))
			*(*uintptr)(unsafe.Pointer(v110))++
			*(*uint8)(unsafe.Pointer(v109)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))) >> libc.Int32FromInt32(16))
			v112 = envPtr2 + 152
			v111 = *(*uintptr)(unsafe.Pointer(v112))
			*(*uintptr)(unsafe.Pointer(v112))++
			*(*uint8)(unsafe.Pointer(v111)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))) >> libc.Int32FromInt32(8))
			v114 = envPtr2 + 152
			v113 = *(*uintptr)(unsafe.Pointer(v114))
			*(*uintptr)(unsafe.Pointer(v114))++
			*(*uint8)(unsafe.Pointer(v113)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STR_RANGE_IMM)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp))
				}
				v115 = delta1
				v116 = envPtr2
				if v115 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v116)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v116)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v116)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v116)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v116 + 64)) += int64(v115)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v118 = envPtr2 + 152
			v117 = *(*uintptr)(unsafe.Pointer(v118))
			*(*uintptr)(unsafe.Pointer(v118))++
			*(*uint8)(unsafe.Pointer(v117)) = uint8(libc.Uint32FromInt64(int64(-libc.Int32FromInt32(2))) >> libc.Int32FromInt32(24))
			v120 = envPtr2 + 152
			v119 = *(*uintptr)(unsafe.Pointer(v120))
			*(*uintptr)(unsafe.Pointer(v120))++
			*(*uint8)(unsafe.Pointer(v119)) = uint8(libc.Uint32FromInt64(int64(-libc.Int32FromInt32(2))) >> libc.Int32FromInt32(16))
			v122 = envPtr2 + 152
			v121 = *(*uintptr)(unsafe.Pointer(v122))
			*(*uintptr)(unsafe.Pointer(v122))++
			*(*uint8)(unsafe.Pointer(v121)) = uint8(libc.Uint32FromInt64(int64(-libc.Int32FromInt32(2))) >> libc.Int32FromInt32(8))
			v124 = envPtr2 + 152
			v123 = *(*uintptr)(unsafe.Pointer(v124))
			*(*uintptr)(unsafe.Pointer(v124))++
			*(*uint8)(unsafe.Pointer(v123)) = uint8(libc.Uint32FromInt64(int64(-libc.Int32FromInt32(2))))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v126 = envPtr2 + 152
			v125 = *(*uintptr)(unsafe.Pointer(v126))
			*(*uintptr)(unsafe.Pointer(v126))++
			*(*uint8)(unsafe.Pointer(v125)) = libc.Uint8FromInt32(int32(INST_STR_CONCAT1))
			v128 = envPtr2 + 152
			v127 = *(*uintptr)(unsafe.Pointer(v128))
			*(*uintptr)(unsafe.Pointer(v128))++
			*(*uint8)(unsafe.Pointer(v127)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STR_CONCAT1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - int32(3)
				}
				v129 = delta1
				v130 = envPtr2
				if v129 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v130)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v130)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v130)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v130)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v130 + 64)) += int64(v129)
			}
		}
	}
	return TCL_OK
}

func XTclCompileStringIsCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy10, _objIndexCopy11, _objIndexCopy12, _objIndexCopy13, _objIndexCopy14, _objIndexCopy15, _objIndexCopy2, _objIndexCopy3, _objIndexCopy4, _objIndexCopy5, _objIndexCopy6, _objIndexCopy7, _objIndexCopy8, _objIndexCopy9, allowEmpty, delta1, end, isEmpty, over, over1, over2, over21, range1, satisfied, testNumType, v103, v115, v119, v12, v123, v134, v140, v152, v156, v162, v166, v172, v184, v196, v200, v206, v212, v224, v228, v232, v238, v24, v250, v254, v258, v264, v270, v282, v286, v290, v296, v308, v312, v316, v322, v334, v338, v344, v348, v354, v360, v372, v378, v382, v386, v392, v398, v410, v416, v418, v424, v436, v440, v444, v448, v454, v458, v464, v476, v480, v486, v488, v500, v504, v508, v512, v518, v53, v532, v544, v548, v554, v566, v57, v570, v582, v587, v591, v595, v599, v603, v607, v619, v624, v628, v63, v632, v636, v640, v644, v648, v69, v73, v79, v91, v97 int32
	var _objPtr, _objPtr1, _objPtr2, cachePtr, isClass, mapPtr, tokenPtr, v10, v100, v101, v102, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v116, v117, v118, v120, v121, v122, v124, v13, v130, v131, v132, v133, v135, v136, v137, v138, v139, v14, v141, v142, v143, v144, v145, v146, v147, v148, v149, v15, v150, v151, v153, v154, v155, v157, v158, v159, v16, v160, v161, v163, v164, v165, v167, v168, v169, v17, v170, v171, v173, v174, v175, v176, v177, v178, v179, v18, v180, v181, v182, v183, v185, v186, v187, v188, v189, v19, v190, v191, v192, v193, v194, v195, v197, v198, v199, v20, v201, v202, v203, v204, v205, v207, v208, v209, v21, v210, v211, v213, v214, v215, v216, v217, v218, v219, v22, v220, v221, v222, v223, v225, v226, v227, v229, v23, v230, v231, v233, v234, v235, v236, v237, v239, v240, v241, v242, v243, v244, v245, v246, v247, v248, v249, v25, v251, v252, v253, v255, v256, v257, v259, v260, v261, v262, v263, v265, v266, v267, v268, v269, v271, v272, v273, v274, v275, v276, v277, v278, v279, v280, v281, v283, v284, v285, v287, v288, v289, v291, v292, v293, v294, v295, v297, v298, v299, v3, v300, v301, v302, v303, v304, v305, v306, v307, v309, v310, v311, v313, v314, v315, v317, v318, v319, v320, v321, v323, v324, v325, v326, v327, v328, v329, v330, v331, v332, v333, v335, v336, v337, v339, v340, v341, v342, v343, v345, v346, v347, v349, v350, v351, v352, v353, v355, v356, v357, v358, v359, v361, v362, v363, v364, v365, v366, v367, v368, v369, v370, v371, v373, v374, v375, v376, v377, v379, v380, v381, v383, v384, v385, v387, v388, v389, v390, v391, v393, v394, v395, v396, v397, v399, v400, v401, v402, v403, v404, v405, v406, v407, v408, v409, v411, v412, v413, v414, v415, v417, v419, v420, v421, v422, v423, v425, v426, v427, v428, v429, v430, v431, v432, v433, v434, v435, v437, v438, v439, v441, v442, v443, v445, v446, v447, v449, v450, v451, v452, v453, v455, v456, v457, v459, v460, v461, v462, v463, v465, v466, v467, v468, v469, v470, v471, v472, v473, v474, v475, v477, v478, v479, v481, v482, v483, v484, v485, v487, v489, v49, v490, v491, v492, v493, v494, v495, v496, v497, v498, v499, v5, v50, v501, v502, v503, v505, v506, v507, v509, v51, v510, v511, v513, v514, v515, v516, v517, v519, v52, v528, v529, v530, v531, v533, v534, v535, v536, v537, v538, v539, v54, v540, v541, v542, v543, v545, v546, v547, v549, v55, v550, v551, v552, v553, v555, v556, v557, v558, v559, v56, v560, v561, v562, v563, v564, v565, v567, v568, v569, v571, v572, v573, v574, v575, v576, v577, v578, v579, v58, v580, v581, v583, v585, v586, v588, v589, v59, v590, v592, v593, v594, v596, v597, v598, v60, v600, v601, v602, v604, v605, v606, v608, v609, v61, v610, v611, v612, v613, v614, v615, v616, v617, v618, v62, v620, v622, v623, v625, v626, v627, v629, v630, v631, v633, v634, v635, v637, v638, v639, v64, v641, v642, v643, v645, v646, v647, v649, v65, v66, v67, v68, v7, v70, v71, v72, v74, v75, v76, v77, v78, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v92, v93, v94, v95, v96, v98, v99 uintptr
	var eclIndex, v2, v4, v6 TTcl_Size
	var strClassType TInstStringClassType
	var v1 bool
	var v584, v621 int64
	var _ /* t at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy10, _objIndexCopy11, _objIndexCopy12, _objIndexCopy13, _objIndexCopy14, _objIndexCopy15, _objIndexCopy2, _objIndexCopy3, _objIndexCopy4, _objIndexCopy5, _objIndexCopy6, _objIndexCopy7, _objIndexCopy8, _objIndexCopy9, _objPtr, _objPtr1, _objPtr2, allowEmpty, cachePtr, delta1, eclIndex, end, isClass, isEmpty, mapPtr, over, over1, over2, over21, range1, satisfied, strClassType, testNumType, tokenPtr, v1, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v123, v124, v13, v130, v131, v132, v133, v134, v135, v136, v137, v138, v139, v14, v140, v141, v142, v143, v144, v145, v146, v147, v148, v149, v15, v150, v151, v152, v153, v154, v155, v156, v157, v158, v159, v16, v160, v161, v162, v163, v164, v165, v166, v167, v168, v169, v17, v170, v171, v172, v173, v174, v175, v176, v177, v178, v179, v18, v180, v181, v182, v183, v184, v185, v186, v187, v188, v189, v19, v190, v191, v192, v193, v194, v195, v196, v197, v198, v199, v2, v20, v200, v201, v202, v203, v204, v205, v206, v207, v208, v209, v21, v210, v211, v212, v213, v214, v215, v216, v217, v218, v219, v22, v220, v221, v222, v223, v224, v225, v226, v227, v228, v229, v23, v230, v231, v232, v233, v234, v235, v236, v237, v238, v239, v24, v240, v241, v242, v243, v244, v245, v246, v247, v248, v249, v25, v250, v251, v252, v253, v254, v255, v256, v257, v258, v259, v260, v261, v262, v263, v264, v265, v266, v267, v268, v269, v270, v271, v272, v273, v274, v275, v276, v277, v278, v279, v280, v281, v282, v283, v284, v285, v286, v287, v288, v289, v290, v291, v292, v293, v294, v295, v296, v297, v298, v299, v3, v300, v301, v302, v303, v304, v305, v306, v307, v308, v309, v310, v311, v312, v313, v314, v315, v316, v317, v318, v319, v320, v321, v322, v323, v324, v325, v326, v327, v328, v329, v330, v331, v332, v333, v334, v335, v336, v337, v338, v339, v340, v341, v342, v343, v344, v345, v346, v347, v348, v349, v350, v351, v352, v353, v354, v355, v356, v357, v358, v359, v360, v361, v362, v363, v364, v365, v366, v367, v368, v369, v370, v371, v372, v373, v374, v375, v376, v377, v378, v379, v380, v381, v382, v383, v384, v385, v386, v387, v388, v389, v390, v391, v392, v393, v394, v395, v396, v397, v398, v399, v4, v400, v401, v402, v403, v404, v405, v406, v407, v408, v409, v410, v411, v412, v413, v414, v415, v416, v417, v418, v419, v420, v421, v422, v423, v424, v425, v426, v427, v428, v429, v430, v431, v432, v433, v434, v435, v436, v437, v438, v439, v440, v441, v442, v443, v444, v445, v446, v447, v448, v449, v450, v451, v452, v453, v454, v455, v456, v457, v458, v459, v460, v461, v462, v463, v464, v465, v466, v467, v468, v469, v470, v471, v472, v473, v474, v475, v476, v477, v478, v479, v480, v481, v482, v483, v484, v485, v486, v487, v488, v489, v49, v490, v491, v492, v493, v494, v495, v496, v497, v498, v499, v5, v50, v500, v501, v502, v503, v504, v505, v506, v507, v508, v509, v51, v510, v511, v512, v513, v514, v515, v516, v517, v518, v519, v52, v528, v529, v53, v530, v531, v532, v533, v534, v535, v536, v537, v538, v539, v54, v540, v541, v542, v543, v544, v545, v546, v547, v548, v549, v55, v550, v551, v552, v553, v554, v555, v556, v557, v558, v559, v56, v560, v561, v562, v563, v564, v565, v566, v567, v568, v569, v57, v570, v571, v572, v573, v574, v575, v576, v577, v578, v579, v58, v580, v581, v582, v583, v584, v585, v586, v587, v588, v589, v59, v590, v591, v592, v593, v594, v595, v596, v597, v598, v599, v6, v60, v600, v601, v602, v603, v604, v605, v606, v607, v608, v609, v61, v610, v611, v612, v613, v614, v615, v616, v617, v618, v619, v62, v620, v621, v622, v623, v624, v625, v626, v627, v628, v629, v63, v630, v631, v632, v633, v634, v635, v636, v637, v638, v639, v64, v640, v641, v642, v643, v644, v645, v646, v647, v648, v649, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1) /* TIP #280 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	allowEmpty = 0
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords < int64(3) || (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords > int64(6) {
		return int32(TCL_ERROR)
	}
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		isClass = XTclThreadAllocObj(tls)
	} else {
		isClass = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(isClass + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(isClass)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(isClass)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(isClass)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(isClass)).FtypePtr = libc.UintptrFromInt32(0)
	if !(XTclWordKnownAtCompileTime(tls, tokenPtr, isClass) != 0) {
		_objPtr = isClass
		v3 = _objPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		return int32(TCL_ERROR)
	} else {
		if XTcl_GetIndexFromObjStruct(tls, interp, isClass, uintptr(unsafe.Pointer(&_isClasses1)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+19296, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
			_objPtr1 = isClass
			v5 = _objPtr1
			v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
			*(*TTcl_Size)(unsafe.Pointer(v5))--
			if v4 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
			XTclCompileSyntaxError(tls, interp, envPtr2)
			return TCL_OK
		}
	}
	_objPtr2 = isClass
	v7 = _objPtr2
	v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
	*(*TTcl_Size)(unsafe.Pointer(v7))--
	if v6 <= int64(1) {
		XTclFreeObj(tls, _objPtr2)
	}
	/*
	 * Cannot handle the -failindex option at all, and that's the only legal
	 * way to have more than 4 arguments.
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(3) && (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(4) {
		return int32(TCL_ERROR)
	}
	tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(3) {
		allowEmpty = int32(1)
	} else {
		if !((*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) && (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize > int64(1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 11034))) && libc.Xstrncmp(tls, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, __ccgo_ts+11034, libc.Uint64FromInt64((*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize)) == 0) {
			return int32(TCL_ERROR)
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	}
	/*
	 * Compile the code. There are several main classes of check here.
	 *	1. Character classes
	 *	2. Booleans
	 *	3. Integers
	 *	4. Floats
	 *	5. Lists
	 */
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v9 = envPtr2 + 152
			v8 = *(*uintptr)(unsafe.Pointer(v9))
			*(*uintptr)(unsafe.Pointer(v9))++
			*(*uint8)(unsafe.Pointer(v8)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v11 = envPtr2 + 152
			v10 = *(*uintptr)(unsafe.Pointer(v11))
			*(*uintptr)(unsafe.Pointer(v11))++
			*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v12 = delta1
				v13 = envPtr2
				if v12 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v13)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v13)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v13)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v13)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v13 + 64)) += int64(v12)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v15 = envPtr2 + 152
			v14 = *(*uintptr)(unsafe.Pointer(v15))
			*(*uintptr)(unsafe.Pointer(v15))++
			*(*uint8)(unsafe.Pointer(v14)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v17 = envPtr2 + 152
			v16 = *(*uintptr)(unsafe.Pointer(v17))
			*(*uintptr)(unsafe.Pointer(v17))++
			*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v19 = envPtr2 + 152
			v18 = *(*uintptr)(unsafe.Pointer(v19))
			*(*uintptr)(unsafe.Pointer(v19))++
			*(*uint8)(unsafe.Pointer(v18)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v21 = envPtr2 + 152
			v20 = *(*uintptr)(unsafe.Pointer(v21))
			*(*uintptr)(unsafe.Pointer(v21))++
			*(*uint8)(unsafe.Pointer(v20)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v23 = envPtr2 + 152
			v22 = *(*uintptr)(unsafe.Pointer(v23))
			*(*uintptr)(unsafe.Pointer(v23))++
			*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v24 = delta1
				v25 = envPtr2
				if v24 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v25 + 64)) += int64(v24)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(1))*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)-libc.Int32FromInt32(1))*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	switch *(*int32)(unsafe.Pointer(bp)) {
	case 0:
		goto _26
	case 1:
		goto _27
	case 2:
		goto _28
	case 3:
		goto _29
	case 6:
		goto _30
	case 10:
		goto _31
	case 13:
		goto _32
	case 14:
		goto _33
	case 15:
		goto _34
	case 16:
		goto _35
	case 18:
		goto _36
	case 20:
		goto _37
	case 21:
		goto _38
	case 17:
		goto _39
	case 9:
		goto _40
	case 4:
		goto _41
	case 7:
		goto _42
	case 8:
		goto _43
	case 19:
		goto _44
	case 11:
		goto _45
	case 5:
		goto _46
	case 12:
		goto _47
	}
	goto _48
_26:
	;
	strClassType = int32(STR_CLASS_ALNUM)
	goto compileStrClass
_27:
	;
	strClassType = int32(STR_CLASS_ALPHA)
	goto compileStrClass
_28:
	;
	strClassType = int32(STR_CLASS_ASCII)
	goto compileStrClass
_29:
	;
	strClassType = int32(STR_CLASS_CONTROL)
	goto compileStrClass
_30:
	;
	strClassType = int32(STR_CLASS_DIGIT)
	goto compileStrClass
_31:
	;
	strClassType = int32(STR_CLASS_GRAPH)
	goto compileStrClass
_32:
	;
	strClassType = int32(STR_CLASS_LOWER)
	goto compileStrClass
_33:
	;
	strClassType = int32(STR_CLASS_PRINT)
	goto compileStrClass
_34:
	;
	strClassType = int32(STR_CLASS_PUNCT)
	goto compileStrClass
_35:
	;
	strClassType = int32(STR_CLASS_SPACE)
	goto compileStrClass
_36:
	;
	strClassType = int32(STR_CLASS_UPPER)
	goto compileStrClass
_37:
	;
	strClassType = int32(STR_CLASS_WORD)
	goto compileStrClass
_38:
	;
	strClassType = int32(STR_CLASS_XDIGIT)
	goto compileStrClass
compileStrClass:
	;
	if allowEmpty != 0 {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v50 = envPtr2 + 152
		v49 = *(*uintptr)(unsafe.Pointer(v50))
		*(*uintptr)(unsafe.Pointer(v50))++
		*(*uint8)(unsafe.Pointer(v49)) = libc.Uint8FromInt32(int32(INST_STR_CLASS))
		v52 = envPtr2 + 152
		v51 = *(*uintptr)(unsafe.Pointer(v52))
		*(*uintptr)(unsafe.Pointer(v52))++
		*(*uint8)(unsafe.Pointer(v51)) = uint8(libc.Uint32FromInt32(strClassType))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STR_CLASS)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - strClassType
			}
			v53 = delta1
			v54 = envPtr2
			if v53 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v54)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v54)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v54)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v54)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v54 + 64)) += int64(v53)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v56 = envPtr2 + 152
		v55 = *(*uintptr)(unsafe.Pointer(v56))
		*(*uintptr)(unsafe.Pointer(v56))++
		*(*uint8)(unsafe.Pointer(v55)) = libc.Uint8FromInt32(int32(INST_DUP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_DUP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v57 = delta1
			v58 = envPtr2
			if v57 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v58)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v58)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v58)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v58)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v58 + 64)) += int64(v57)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v60 = envPtr2 + 152
		v59 = *(*uintptr)(unsafe.Pointer(v60))
		*(*uintptr)(unsafe.Pointer(v60))++
		*(*uint8)(unsafe.Pointer(v59)) = libc.Uint8FromInt32(int32(INST_STR_CLASS))
		v62 = envPtr2 + 152
		v61 = *(*uintptr)(unsafe.Pointer(v62))
		*(*uintptr)(unsafe.Pointer(v62))++
		*(*uint8)(unsafe.Pointer(v61)) = uint8(libc.Uint32FromInt32(strClassType))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STR_CLASS)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - strClassType
			}
			v63 = delta1
			v64 = envPtr2
			if v63 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v64)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v64)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v64)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v64)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v64 + 64)) += int64(v63)
		}
		over = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v66 = envPtr2 + 152
		v65 = *(*uintptr)(unsafe.Pointer(v66))
		*(*uintptr)(unsafe.Pointer(v66))++
		*(*uint8)(unsafe.Pointer(v65)) = libc.Uint8FromInt32(int32(INST_JUMP_TRUE1))
		v68 = envPtr2 + 152
		v67 = *(*uintptr)(unsafe.Pointer(v68))
		*(*uintptr)(unsafe.Pointer(v68))++
		*(*uint8)(unsafe.Pointer(v67)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP_TRUE1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v69 = delta1
			v70 = envPtr2
			if v69 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v70 + 64)) += int64(v69)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v72 = envPtr2 + 152
		v71 = *(*uintptr)(unsafe.Pointer(v72))
		*(*uintptr)(unsafe.Pointer(v72))++
		*(*uint8)(unsafe.Pointer(v71)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v73 = delta1
			v74 = envPtr2
			if v73 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v74)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v74)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v74)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v74)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v74 + 64)) += int64(v73)
		}
		_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+14828, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy1 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v76 = envPtr2 + 152
			v75 = *(*uintptr)(unsafe.Pointer(v76))
			*(*uintptr)(unsafe.Pointer(v76))++
			*(*uint8)(unsafe.Pointer(v75)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v78 = envPtr2 + 152
			v77 = *(*uintptr)(unsafe.Pointer(v78))
			*(*uintptr)(unsafe.Pointer(v78))++
			*(*uint8)(unsafe.Pointer(v77)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v79 = delta1
				v80 = envPtr2
				if v79 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v80)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v80)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v80)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v80)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v80 + 64)) += int64(v79)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v82 = envPtr2 + 152
			v81 = *(*uintptr)(unsafe.Pointer(v82))
			*(*uintptr)(unsafe.Pointer(v82))++
			*(*uint8)(unsafe.Pointer(v81)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v84 = envPtr2 + 152
			v83 = *(*uintptr)(unsafe.Pointer(v84))
			*(*uintptr)(unsafe.Pointer(v84))++
			*(*uint8)(unsafe.Pointer(v83)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
			v86 = envPtr2 + 152
			v85 = *(*uintptr)(unsafe.Pointer(v86))
			*(*uintptr)(unsafe.Pointer(v86))++
			*(*uint8)(unsafe.Pointer(v85)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
			v88 = envPtr2 + 152
			v87 = *(*uintptr)(unsafe.Pointer(v88))
			*(*uintptr)(unsafe.Pointer(v88))++
			*(*uint8)(unsafe.Pointer(v87)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
			v90 = envPtr2 + 152
			v89 = *(*uintptr)(unsafe.Pointer(v90))
			*(*uintptr)(unsafe.Pointer(v90))++
			*(*uint8)(unsafe.Pointer(v89)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v91 = delta1
				v92 = envPtr2
				if v91 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v92)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v92)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v92)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v92)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v92 + 64)) += int64(v91)
			}
		}
		over2 = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v94 = envPtr2 + 152
		v93 = *(*uintptr)(unsafe.Pointer(v94))
		*(*uintptr)(unsafe.Pointer(v94))++
		*(*uint8)(unsafe.Pointer(v93)) = libc.Uint8FromInt32(int32(INST_JUMP1))
		v96 = envPtr2 + 152
		v95 = *(*uintptr)(unsafe.Pointer(v96))
		*(*uintptr)(unsafe.Pointer(v96))++
		*(*uint8)(unsafe.Pointer(v95)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v97 = delta1
			v98 = envPtr2
			if v97 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v98)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v98)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v98)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v98)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v98 + 64)) += int64(v97)
		}
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(over) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(over)))
		_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy2 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v100 = envPtr2 + 152
			v99 = *(*uintptr)(unsafe.Pointer(v100))
			*(*uintptr)(unsafe.Pointer(v100))++
			*(*uint8)(unsafe.Pointer(v99)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v102 = envPtr2 + 152
			v101 = *(*uintptr)(unsafe.Pointer(v102))
			*(*uintptr)(unsafe.Pointer(v102))++
			*(*uint8)(unsafe.Pointer(v101)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v103 = delta1
				v104 = envPtr2
				if v103 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v104)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v104)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v104)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v104)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v104 + 64)) += int64(v103)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v106 = envPtr2 + 152
			v105 = *(*uintptr)(unsafe.Pointer(v106))
			*(*uintptr)(unsafe.Pointer(v106))++
			*(*uint8)(unsafe.Pointer(v105)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v108 = envPtr2 + 152
			v107 = *(*uintptr)(unsafe.Pointer(v108))
			*(*uintptr)(unsafe.Pointer(v108))++
			*(*uint8)(unsafe.Pointer(v107)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
			v110 = envPtr2 + 152
			v109 = *(*uintptr)(unsafe.Pointer(v110))
			*(*uintptr)(unsafe.Pointer(v110))++
			*(*uint8)(unsafe.Pointer(v109)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
			v112 = envPtr2 + 152
			v111 = *(*uintptr)(unsafe.Pointer(v112))
			*(*uintptr)(unsafe.Pointer(v112))++
			*(*uint8)(unsafe.Pointer(v111)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
			v114 = envPtr2 + 152
			v113 = *(*uintptr)(unsafe.Pointer(v114))
			*(*uintptr)(unsafe.Pointer(v114))++
			*(*uint8)(unsafe.Pointer(v113)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v115 = delta1
				v116 = envPtr2
				if v115 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v116)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v116)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v116)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v116)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v116 + 64)) += int64(v115)
			}
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v118 = envPtr2 + 152
		v117 = *(*uintptr)(unsafe.Pointer(v118))
		*(*uintptr)(unsafe.Pointer(v118))++
		*(*uint8)(unsafe.Pointer(v117)) = libc.Uint8FromInt32(int32(INST_STR_NEQ))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STR_NEQ)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v119 = delta1
			v120 = envPtr2
			if v119 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v120)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v120)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v120)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v120)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v120 + 64)) += int64(v119)
		}
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(over2) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(over2)))
	}
	return TCL_OK
_41:
	;
_40:
	;
_39:
	;
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v122 = envPtr2 + 152
	v121 = *(*uintptr)(unsafe.Pointer(v122))
	*(*uintptr)(unsafe.Pointer(v122))++
	*(*uint8)(unsafe.Pointer(v121)) = libc.Uint8FromInt32(int32(INST_TRY_CVT_TO_BOOLEAN))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_TRY_CVT_TO_BOOLEAN)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v123 = delta1
		v124 = envPtr2
		if v123 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v124)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v124)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v124)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v124)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v124 + 64)) += int64(v123)
	}
	switch *(*int32)(unsafe.Pointer(bp)) {
	case 4:
		goto _125
	case 17:
		goto _126
	case 9:
		goto _127
	default:
		goto _128
	}
	goto _129
_125:
	;
	if allowEmpty != 0 {
		over1 = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v131 = envPtr2 + 152
		v130 = *(*uintptr)(unsafe.Pointer(v131))
		*(*uintptr)(unsafe.Pointer(v131))++
		*(*uint8)(unsafe.Pointer(v130)) = libc.Uint8FromInt32(int32(INST_JUMP_TRUE1))
		v133 = envPtr2 + 152
		v132 = *(*uintptr)(unsafe.Pointer(v133))
		*(*uintptr)(unsafe.Pointer(v133))++
		*(*uint8)(unsafe.Pointer(v132)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP_TRUE1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v134 = delta1
			v135 = envPtr2
			if v134 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v135)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v135)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v135)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v135)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v135 + 64)) += int64(v134)
		}
		_objIndexCopy3 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy3 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v137 = envPtr2 + 152
			v136 = *(*uintptr)(unsafe.Pointer(v137))
			*(*uintptr)(unsafe.Pointer(v137))++
			*(*uint8)(unsafe.Pointer(v136)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v139 = envPtr2 + 152
			v138 = *(*uintptr)(unsafe.Pointer(v139))
			*(*uintptr)(unsafe.Pointer(v139))++
			*(*uint8)(unsafe.Pointer(v138)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy3
				}
				v140 = delta1
				v141 = envPtr2
				if v140 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v141)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v141)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v141)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v141)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v141 + 64)) += int64(v140)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v143 = envPtr2 + 152
			v142 = *(*uintptr)(unsafe.Pointer(v143))
			*(*uintptr)(unsafe.Pointer(v143))++
			*(*uint8)(unsafe.Pointer(v142)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v145 = envPtr2 + 152
			v144 = *(*uintptr)(unsafe.Pointer(v145))
			*(*uintptr)(unsafe.Pointer(v145))++
			*(*uint8)(unsafe.Pointer(v144)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(24))
			v147 = envPtr2 + 152
			v146 = *(*uintptr)(unsafe.Pointer(v147))
			*(*uintptr)(unsafe.Pointer(v147))++
			*(*uint8)(unsafe.Pointer(v146)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(16))
			v149 = envPtr2 + 152
			v148 = *(*uintptr)(unsafe.Pointer(v149))
			*(*uintptr)(unsafe.Pointer(v149))++
			*(*uint8)(unsafe.Pointer(v148)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(8))
			v151 = envPtr2 + 152
			v150 = *(*uintptr)(unsafe.Pointer(v151))
			*(*uintptr)(unsafe.Pointer(v151))++
			*(*uint8)(unsafe.Pointer(v150)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy3
				}
				v152 = delta1
				v153 = envPtr2
				if v152 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v153)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v153)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v153)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v153)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v153 + 64)) += int64(v152)
			}
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v155 = envPtr2 + 152
		v154 = *(*uintptr)(unsafe.Pointer(v155))
		*(*uintptr)(unsafe.Pointer(v155))++
		*(*uint8)(unsafe.Pointer(v154)) = libc.Uint8FromInt32(int32(INST_STR_EQ))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STR_EQ)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v156 = delta1
			v157 = envPtr2
			if v156 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v157)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v157)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v157)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v157)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v157 + 64)) += int64(v156)
		}
		over21 = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v159 = envPtr2 + 152
		v158 = *(*uintptr)(unsafe.Pointer(v159))
		*(*uintptr)(unsafe.Pointer(v159))++
		*(*uint8)(unsafe.Pointer(v158)) = libc.Uint8FromInt32(int32(INST_JUMP1))
		v161 = envPtr2 + 152
		v160 = *(*uintptr)(unsafe.Pointer(v161))
		*(*uintptr)(unsafe.Pointer(v161))++
		*(*uint8)(unsafe.Pointer(v160)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v162 = delta1
			v163 = envPtr2
			if v162 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v163)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v163)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v163)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v163)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v163 + 64)) += int64(v162)
		}
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(over1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(over1)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v165 = envPtr2 + 152
		v164 = *(*uintptr)(unsafe.Pointer(v165))
		*(*uintptr)(unsafe.Pointer(v165))++
		*(*uint8)(unsafe.Pointer(v164)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v166 = delta1
			v167 = envPtr2
			if v166 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v167)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v167)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v167)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v167)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v167 + 64)) += int64(v166)
		}
		_objIndexCopy4 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+21397, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy4 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v169 = envPtr2 + 152
			v168 = *(*uintptr)(unsafe.Pointer(v169))
			*(*uintptr)(unsafe.Pointer(v169))++
			*(*uint8)(unsafe.Pointer(v168)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v171 = envPtr2 + 152
			v170 = *(*uintptr)(unsafe.Pointer(v171))
			*(*uintptr)(unsafe.Pointer(v171))++
			*(*uint8)(unsafe.Pointer(v170)) = uint8(libc.Uint32FromInt32(_objIndexCopy4))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy4
				}
				v172 = delta1
				v173 = envPtr2
				if v172 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v173)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v173)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v173)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v173)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v173 + 64)) += int64(v172)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v175 = envPtr2 + 152
			v174 = *(*uintptr)(unsafe.Pointer(v175))
			*(*uintptr)(unsafe.Pointer(v175))++
			*(*uint8)(unsafe.Pointer(v174)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v177 = envPtr2 + 152
			v176 = *(*uintptr)(unsafe.Pointer(v177))
			*(*uintptr)(unsafe.Pointer(v177))++
			*(*uint8)(unsafe.Pointer(v176)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(24))
			v179 = envPtr2 + 152
			v178 = *(*uintptr)(unsafe.Pointer(v179))
			*(*uintptr)(unsafe.Pointer(v179))++
			*(*uint8)(unsafe.Pointer(v178)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(16))
			v181 = envPtr2 + 152
			v180 = *(*uintptr)(unsafe.Pointer(v181))
			*(*uintptr)(unsafe.Pointer(v181))++
			*(*uint8)(unsafe.Pointer(v180)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(8))
			v183 = envPtr2 + 152
			v182 = *(*uintptr)(unsafe.Pointer(v183))
			*(*uintptr)(unsafe.Pointer(v183))++
			*(*uint8)(unsafe.Pointer(v182)) = uint8(libc.Uint32FromInt32(_objIndexCopy4))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy4
				}
				v184 = delta1
				v185 = envPtr2
				if v184 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v185)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v185)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v185)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v185)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v185 + 64)) += int64(v184)
			}
		}
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(over21) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(over21)))
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v187 = envPtr2 + 152
		v186 = *(*uintptr)(unsafe.Pointer(v187))
		*(*uintptr)(unsafe.Pointer(v187))++
		*(*uint8)(unsafe.Pointer(v186)) = libc.Uint8FromInt32(int32(INST_REVERSE))
		v189 = envPtr2 + 152
		v188 = *(*uintptr)(unsafe.Pointer(v189))
		*(*uintptr)(unsafe.Pointer(v189))++
		*(*uint8)(unsafe.Pointer(v188)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
		v191 = envPtr2 + 152
		v190 = *(*uintptr)(unsafe.Pointer(v191))
		*(*uintptr)(unsafe.Pointer(v191))++
		*(*uint8)(unsafe.Pointer(v190)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
		v193 = envPtr2 + 152
		v192 = *(*uintptr)(unsafe.Pointer(v193))
		*(*uintptr)(unsafe.Pointer(v193))++
		*(*uint8)(unsafe.Pointer(v192)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
		v195 = envPtr2 + 152
		v194 = *(*uintptr)(unsafe.Pointer(v195))
		*(*uintptr)(unsafe.Pointer(v195))++
		*(*uint8)(unsafe.Pointer(v194)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(2)
			}
			v196 = delta1
			v197 = envPtr2
			if v196 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v197)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v197)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v197)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v197)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v197 + 64)) += int64(v196)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v199 = envPtr2 + 152
		v198 = *(*uintptr)(unsafe.Pointer(v199))
		*(*uintptr)(unsafe.Pointer(v199))++
		*(*uint8)(unsafe.Pointer(v198)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v200 = delta1
			v201 = envPtr2
			if v200 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v201)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v201)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v201)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v201)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v201 + 64)) += int64(v200)
		}
	}
	return TCL_OK
_126:
	;
	over1 = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v203 = envPtr2 + 152
	v202 = *(*uintptr)(unsafe.Pointer(v203))
	*(*uintptr)(unsafe.Pointer(v203))++
	*(*uint8)(unsafe.Pointer(v202)) = libc.Uint8FromInt32(int32(INST_JUMP_TRUE1))
	v205 = envPtr2 + 152
	v204 = *(*uintptr)(unsafe.Pointer(v205))
	*(*uintptr)(unsafe.Pointer(v205))++
	*(*uint8)(unsafe.Pointer(v204)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_JUMP_TRUE1)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v206 = delta1
		v207 = envPtr2
		if v206 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v207)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v207)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v207)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v207)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v207 + 64)) += int64(v206)
	}
	if allowEmpty != 0 {
		_objIndexCopy5 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy5 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v209 = envPtr2 + 152
			v208 = *(*uintptr)(unsafe.Pointer(v209))
			*(*uintptr)(unsafe.Pointer(v209))++
			*(*uint8)(unsafe.Pointer(v208)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v211 = envPtr2 + 152
			v210 = *(*uintptr)(unsafe.Pointer(v211))
			*(*uintptr)(unsafe.Pointer(v211))++
			*(*uint8)(unsafe.Pointer(v210)) = uint8(libc.Uint32FromInt32(_objIndexCopy5))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy5
				}
				v212 = delta1
				v213 = envPtr2
				if v212 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v213)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v213)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v213)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v213)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v213 + 64)) += int64(v212)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v215 = envPtr2 + 152
			v214 = *(*uintptr)(unsafe.Pointer(v215))
			*(*uintptr)(unsafe.Pointer(v215))++
			*(*uint8)(unsafe.Pointer(v214)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v217 = envPtr2 + 152
			v216 = *(*uintptr)(unsafe.Pointer(v217))
			*(*uintptr)(unsafe.Pointer(v217))++
			*(*uint8)(unsafe.Pointer(v216)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(24))
			v219 = envPtr2 + 152
			v218 = *(*uintptr)(unsafe.Pointer(v219))
			*(*uintptr)(unsafe.Pointer(v219))++
			*(*uint8)(unsafe.Pointer(v218)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(16))
			v221 = envPtr2 + 152
			v220 = *(*uintptr)(unsafe.Pointer(v221))
			*(*uintptr)(unsafe.Pointer(v221))++
			*(*uint8)(unsafe.Pointer(v220)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(8))
			v223 = envPtr2 + 152
			v222 = *(*uintptr)(unsafe.Pointer(v223))
			*(*uintptr)(unsafe.Pointer(v223))++
			*(*uint8)(unsafe.Pointer(v222)) = uint8(libc.Uint32FromInt32(_objIndexCopy5))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy5
				}
				v224 = delta1
				v225 = envPtr2
				if v224 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v225)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v225)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v225)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v225)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v225 + 64)) += int64(v224)
			}
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v227 = envPtr2 + 152
		v226 = *(*uintptr)(unsafe.Pointer(v227))
		*(*uintptr)(unsafe.Pointer(v227))++
		*(*uint8)(unsafe.Pointer(v226)) = libc.Uint8FromInt32(int32(INST_STR_EQ))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STR_EQ)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v228 = delta1
			v229 = envPtr2
			if v228 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v229)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v229)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v229)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v229)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v229 + 64)) += int64(v228)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v231 = envPtr2 + 152
		v230 = *(*uintptr)(unsafe.Pointer(v231))
		*(*uintptr)(unsafe.Pointer(v231))++
		*(*uint8)(unsafe.Pointer(v230)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v232 = delta1
			v233 = envPtr2
			if v232 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v233)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v233)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v233)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v233)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v233 + 64)) += int64(v232)
		}
		_objIndexCopy6 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+14828, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy6 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v235 = envPtr2 + 152
			v234 = *(*uintptr)(unsafe.Pointer(v235))
			*(*uintptr)(unsafe.Pointer(v235))++
			*(*uint8)(unsafe.Pointer(v234)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v237 = envPtr2 + 152
			v236 = *(*uintptr)(unsafe.Pointer(v237))
			*(*uintptr)(unsafe.Pointer(v237))++
			*(*uint8)(unsafe.Pointer(v236)) = uint8(libc.Uint32FromInt32(_objIndexCopy6))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy6
				}
				v238 = delta1
				v239 = envPtr2
				if v238 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v239)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v239)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v239)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v239)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v239 + 64)) += int64(v238)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v241 = envPtr2 + 152
			v240 = *(*uintptr)(unsafe.Pointer(v241))
			*(*uintptr)(unsafe.Pointer(v241))++
			*(*uint8)(unsafe.Pointer(v240)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v243 = envPtr2 + 152
			v242 = *(*uintptr)(unsafe.Pointer(v243))
			*(*uintptr)(unsafe.Pointer(v243))++
			*(*uint8)(unsafe.Pointer(v242)) = uint8(libc.Uint32FromInt32(_objIndexCopy6) >> libc.Int32FromInt32(24))
			v245 = envPtr2 + 152
			v244 = *(*uintptr)(unsafe.Pointer(v245))
			*(*uintptr)(unsafe.Pointer(v245))++
			*(*uint8)(unsafe.Pointer(v244)) = uint8(libc.Uint32FromInt32(_objIndexCopy6) >> libc.Int32FromInt32(16))
			v247 = envPtr2 + 152
			v246 = *(*uintptr)(unsafe.Pointer(v247))
			*(*uintptr)(unsafe.Pointer(v247))++
			*(*uint8)(unsafe.Pointer(v246)) = uint8(libc.Uint32FromInt32(_objIndexCopy6) >> libc.Int32FromInt32(8))
			v249 = envPtr2 + 152
			v248 = *(*uintptr)(unsafe.Pointer(v249))
			*(*uintptr)(unsafe.Pointer(v249))++
			*(*uint8)(unsafe.Pointer(v248)) = uint8(libc.Uint32FromInt32(_objIndexCopy6))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy6
				}
				v250 = delta1
				v251 = envPtr2
				if v250 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v251)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v251)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v251)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v251)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v251 + 64)) += int64(v250)
			}
		}
	}
	*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(over1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(over1)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v253 = envPtr2 + 152
	v252 = *(*uintptr)(unsafe.Pointer(v253))
	*(*uintptr)(unsafe.Pointer(v253))++
	*(*uint8)(unsafe.Pointer(v252)) = libc.Uint8FromInt32(int32(INST_LNOT))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_LNOT)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v254 = delta1
		v255 = envPtr2
		if v254 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v255)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v255)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v255)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v255)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v255 + 64)) += int64(v254)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v257 = envPtr2 + 152
	v256 = *(*uintptr)(unsafe.Pointer(v257))
	*(*uintptr)(unsafe.Pointer(v257))++
	*(*uint8)(unsafe.Pointer(v256)) = libc.Uint8FromInt32(int32(INST_LNOT))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_LNOT)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v258 = delta1
		v259 = envPtr2
		if v258 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v259)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v259)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v259)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v259)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v259 + 64)) += int64(v258)
	}
	return TCL_OK
_127:
	;
	over1 = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v261 = envPtr2 + 152
	v260 = *(*uintptr)(unsafe.Pointer(v261))
	*(*uintptr)(unsafe.Pointer(v261))++
	*(*uint8)(unsafe.Pointer(v260)) = libc.Uint8FromInt32(int32(INST_JUMP_TRUE1))
	v263 = envPtr2 + 152
	v262 = *(*uintptr)(unsafe.Pointer(v263))
	*(*uintptr)(unsafe.Pointer(v263))++
	*(*uint8)(unsafe.Pointer(v262)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_JUMP_TRUE1)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v264 = delta1
		v265 = envPtr2
		if v264 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v265)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v265)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v265)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v265)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v265 + 64)) += int64(v264)
	}
	if allowEmpty != 0 {
		_objIndexCopy7 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy7 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v267 = envPtr2 + 152
			v266 = *(*uintptr)(unsafe.Pointer(v267))
			*(*uintptr)(unsafe.Pointer(v267))++
			*(*uint8)(unsafe.Pointer(v266)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v269 = envPtr2 + 152
			v268 = *(*uintptr)(unsafe.Pointer(v269))
			*(*uintptr)(unsafe.Pointer(v269))++
			*(*uint8)(unsafe.Pointer(v268)) = uint8(libc.Uint32FromInt32(_objIndexCopy7))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy7
				}
				v270 = delta1
				v271 = envPtr2
				if v270 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v271)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v271)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v271)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v271)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v271 + 64)) += int64(v270)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v273 = envPtr2 + 152
			v272 = *(*uintptr)(unsafe.Pointer(v273))
			*(*uintptr)(unsafe.Pointer(v273))++
			*(*uint8)(unsafe.Pointer(v272)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v275 = envPtr2 + 152
			v274 = *(*uintptr)(unsafe.Pointer(v275))
			*(*uintptr)(unsafe.Pointer(v275))++
			*(*uint8)(unsafe.Pointer(v274)) = uint8(libc.Uint32FromInt32(_objIndexCopy7) >> libc.Int32FromInt32(24))
			v277 = envPtr2 + 152
			v276 = *(*uintptr)(unsafe.Pointer(v277))
			*(*uintptr)(unsafe.Pointer(v277))++
			*(*uint8)(unsafe.Pointer(v276)) = uint8(libc.Uint32FromInt32(_objIndexCopy7) >> libc.Int32FromInt32(16))
			v279 = envPtr2 + 152
			v278 = *(*uintptr)(unsafe.Pointer(v279))
			*(*uintptr)(unsafe.Pointer(v279))++
			*(*uint8)(unsafe.Pointer(v278)) = uint8(libc.Uint32FromInt32(_objIndexCopy7) >> libc.Int32FromInt32(8))
			v281 = envPtr2 + 152
			v280 = *(*uintptr)(unsafe.Pointer(v281))
			*(*uintptr)(unsafe.Pointer(v281))++
			*(*uint8)(unsafe.Pointer(v280)) = uint8(libc.Uint32FromInt32(_objIndexCopy7))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy7
				}
				v282 = delta1
				v283 = envPtr2
				if v282 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v283)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v283)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v283)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v283)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v283 + 64)) += int64(v282)
			}
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v285 = envPtr2 + 152
		v284 = *(*uintptr)(unsafe.Pointer(v285))
		*(*uintptr)(unsafe.Pointer(v285))++
		*(*uint8)(unsafe.Pointer(v284)) = libc.Uint8FromInt32(int32(INST_STR_NEQ))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STR_NEQ)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v286 = delta1
			v287 = envPtr2
			if v286 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v287)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v287)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v287)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v287)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v287 + 64)) += int64(v286)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v289 = envPtr2 + 152
		v288 = *(*uintptr)(unsafe.Pointer(v289))
		*(*uintptr)(unsafe.Pointer(v289))++
		*(*uint8)(unsafe.Pointer(v288)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v290 = delta1
			v291 = envPtr2
			if v290 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v291)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v291)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v291)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v291)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v291 + 64)) += int64(v290)
		}
		_objIndexCopy8 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+21397, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy8 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v293 = envPtr2 + 152
			v292 = *(*uintptr)(unsafe.Pointer(v293))
			*(*uintptr)(unsafe.Pointer(v293))++
			*(*uint8)(unsafe.Pointer(v292)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v295 = envPtr2 + 152
			v294 = *(*uintptr)(unsafe.Pointer(v295))
			*(*uintptr)(unsafe.Pointer(v295))++
			*(*uint8)(unsafe.Pointer(v294)) = uint8(libc.Uint32FromInt32(_objIndexCopy8))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy8
				}
				v296 = delta1
				v297 = envPtr2
				if v296 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v297)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v297)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v297)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v297)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v297 + 64)) += int64(v296)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v299 = envPtr2 + 152
			v298 = *(*uintptr)(unsafe.Pointer(v299))
			*(*uintptr)(unsafe.Pointer(v299))++
			*(*uint8)(unsafe.Pointer(v298)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v301 = envPtr2 + 152
			v300 = *(*uintptr)(unsafe.Pointer(v301))
			*(*uintptr)(unsafe.Pointer(v301))++
			*(*uint8)(unsafe.Pointer(v300)) = uint8(libc.Uint32FromInt32(_objIndexCopy8) >> libc.Int32FromInt32(24))
			v303 = envPtr2 + 152
			v302 = *(*uintptr)(unsafe.Pointer(v303))
			*(*uintptr)(unsafe.Pointer(v303))++
			*(*uint8)(unsafe.Pointer(v302)) = uint8(libc.Uint32FromInt32(_objIndexCopy8) >> libc.Int32FromInt32(16))
			v305 = envPtr2 + 152
			v304 = *(*uintptr)(unsafe.Pointer(v305))
			*(*uintptr)(unsafe.Pointer(v305))++
			*(*uint8)(unsafe.Pointer(v304)) = uint8(libc.Uint32FromInt32(_objIndexCopy8) >> libc.Int32FromInt32(8))
			v307 = envPtr2 + 152
			v306 = *(*uintptr)(unsafe.Pointer(v307))
			*(*uintptr)(unsafe.Pointer(v307))++
			*(*uint8)(unsafe.Pointer(v306)) = uint8(libc.Uint32FromInt32(_objIndexCopy8))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy8
				}
				v308 = delta1
				v309 = envPtr2
				if v308 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v309)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v309)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v309)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v309)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v309 + 64)) += int64(v308)
			}
		}
	}
	*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(over1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(over1)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v311 = envPtr2 + 152
	v310 = *(*uintptr)(unsafe.Pointer(v311))
	*(*uintptr)(unsafe.Pointer(v311))++
	*(*uint8)(unsafe.Pointer(v310)) = libc.Uint8FromInt32(int32(INST_LNOT))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_LNOT)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v312 = delta1
		v313 = envPtr2
		if v312 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v313)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v313)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v313)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v313)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v313 + 64)) += int64(v312)
	}
	return TCL_OK
_128:
	;
	goto _129
_129:
	;
	goto _48
_42:
	;
	if allowEmpty != 0 {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v315 = envPtr2 + 152
		v314 = *(*uintptr)(unsafe.Pointer(v315))
		*(*uintptr)(unsafe.Pointer(v315))++
		*(*uint8)(unsafe.Pointer(v314)) = libc.Uint8FromInt32(int32(INST_DUP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_DUP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v316 = delta1
			v317 = envPtr2
			if v316 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v317)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v317)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v317)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v317)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v317 + 64)) += int64(v316)
		}
		_objIndexCopy9 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy9 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v319 = envPtr2 + 152
			v318 = *(*uintptr)(unsafe.Pointer(v319))
			*(*uintptr)(unsafe.Pointer(v319))++
			*(*uint8)(unsafe.Pointer(v318)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v321 = envPtr2 + 152
			v320 = *(*uintptr)(unsafe.Pointer(v321))
			*(*uintptr)(unsafe.Pointer(v321))++
			*(*uint8)(unsafe.Pointer(v320)) = uint8(libc.Uint32FromInt32(_objIndexCopy9))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy9
				}
				v322 = delta1
				v323 = envPtr2
				if v322 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v323)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v323)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v323)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v323)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v323 + 64)) += int64(v322)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v325 = envPtr2 + 152
			v324 = *(*uintptr)(unsafe.Pointer(v325))
			*(*uintptr)(unsafe.Pointer(v325))++
			*(*uint8)(unsafe.Pointer(v324)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v327 = envPtr2 + 152
			v326 = *(*uintptr)(unsafe.Pointer(v327))
			*(*uintptr)(unsafe.Pointer(v327))++
			*(*uint8)(unsafe.Pointer(v326)) = uint8(libc.Uint32FromInt32(_objIndexCopy9) >> libc.Int32FromInt32(24))
			v329 = envPtr2 + 152
			v328 = *(*uintptr)(unsafe.Pointer(v329))
			*(*uintptr)(unsafe.Pointer(v329))++
			*(*uint8)(unsafe.Pointer(v328)) = uint8(libc.Uint32FromInt32(_objIndexCopy9) >> libc.Int32FromInt32(16))
			v331 = envPtr2 + 152
			v330 = *(*uintptr)(unsafe.Pointer(v331))
			*(*uintptr)(unsafe.Pointer(v331))++
			*(*uint8)(unsafe.Pointer(v330)) = uint8(libc.Uint32FromInt32(_objIndexCopy9) >> libc.Int32FromInt32(8))
			v333 = envPtr2 + 152
			v332 = *(*uintptr)(unsafe.Pointer(v333))
			*(*uintptr)(unsafe.Pointer(v333))++
			*(*uint8)(unsafe.Pointer(v332)) = uint8(libc.Uint32FromInt32(_objIndexCopy9))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy9
				}
				v334 = delta1
				v335 = envPtr2
				if v334 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v335)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v335)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v335)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v335)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v335 + 64)) += int64(v334)
			}
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v337 = envPtr2 + 152
		v336 = *(*uintptr)(unsafe.Pointer(v337))
		*(*uintptr)(unsafe.Pointer(v337))++
		*(*uint8)(unsafe.Pointer(v336)) = libc.Uint8FromInt32(int32(INST_STR_EQ))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STR_EQ)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v338 = delta1
			v339 = envPtr2
			if v338 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v339)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v339)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v339)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v339)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v339 + 64)) += int64(v338)
		}
		isEmpty = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v341 = envPtr2 + 152
		v340 = *(*uintptr)(unsafe.Pointer(v341))
		*(*uintptr)(unsafe.Pointer(v341))++
		*(*uint8)(unsafe.Pointer(v340)) = libc.Uint8FromInt32(int32(INST_JUMP_TRUE1))
		v343 = envPtr2 + 152
		v342 = *(*uintptr)(unsafe.Pointer(v343))
		*(*uintptr)(unsafe.Pointer(v343))++
		*(*uint8)(unsafe.Pointer(v342)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP_TRUE1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v344 = delta1
			v345 = envPtr2
			if v344 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v345)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v345)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v345)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v345)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v345 + 64)) += int64(v344)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v347 = envPtr2 + 152
		v346 = *(*uintptr)(unsafe.Pointer(v347))
		*(*uintptr)(unsafe.Pointer(v347))++
		*(*uint8)(unsafe.Pointer(v346)) = libc.Uint8FromInt32(int32(INST_NUM_TYPE))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_NUM_TYPE)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v348 = delta1
			v349 = envPtr2
			if v348 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v349)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v349)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v349)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v349)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v349 + 64)) += int64(v348)
		}
		satisfied = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v351 = envPtr2 + 152
		v350 = *(*uintptr)(unsafe.Pointer(v351))
		*(*uintptr)(unsafe.Pointer(v351))++
		*(*uint8)(unsafe.Pointer(v350)) = libc.Uint8FromInt32(int32(INST_JUMP_TRUE1))
		v353 = envPtr2 + 152
		v352 = *(*uintptr)(unsafe.Pointer(v353))
		*(*uintptr)(unsafe.Pointer(v353))++
		*(*uint8)(unsafe.Pointer(v352)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP_TRUE1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v354 = delta1
			v355 = envPtr2
			if v354 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v355)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v355)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v355)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v355)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v355 + 64)) += int64(v354)
		}
		_objIndexCopy10 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+14828, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy10 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v357 = envPtr2 + 152
			v356 = *(*uintptr)(unsafe.Pointer(v357))
			*(*uintptr)(unsafe.Pointer(v357))++
			*(*uint8)(unsafe.Pointer(v356)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v359 = envPtr2 + 152
			v358 = *(*uintptr)(unsafe.Pointer(v359))
			*(*uintptr)(unsafe.Pointer(v359))++
			*(*uint8)(unsafe.Pointer(v358)) = uint8(libc.Uint32FromInt32(_objIndexCopy10))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy10
				}
				v360 = delta1
				v361 = envPtr2
				if v360 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v361)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v361)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v361)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v361)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v361 + 64)) += int64(v360)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v363 = envPtr2 + 152
			v362 = *(*uintptr)(unsafe.Pointer(v363))
			*(*uintptr)(unsafe.Pointer(v363))++
			*(*uint8)(unsafe.Pointer(v362)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v365 = envPtr2 + 152
			v364 = *(*uintptr)(unsafe.Pointer(v365))
			*(*uintptr)(unsafe.Pointer(v365))++
			*(*uint8)(unsafe.Pointer(v364)) = uint8(libc.Uint32FromInt32(_objIndexCopy10) >> libc.Int32FromInt32(24))
			v367 = envPtr2 + 152
			v366 = *(*uintptr)(unsafe.Pointer(v367))
			*(*uintptr)(unsafe.Pointer(v367))++
			*(*uint8)(unsafe.Pointer(v366)) = uint8(libc.Uint32FromInt32(_objIndexCopy10) >> libc.Int32FromInt32(16))
			v369 = envPtr2 + 152
			v368 = *(*uintptr)(unsafe.Pointer(v369))
			*(*uintptr)(unsafe.Pointer(v369))++
			*(*uint8)(unsafe.Pointer(v368)) = uint8(libc.Uint32FromInt32(_objIndexCopy10) >> libc.Int32FromInt32(8))
			v371 = envPtr2 + 152
			v370 = *(*uintptr)(unsafe.Pointer(v371))
			*(*uintptr)(unsafe.Pointer(v371))++
			*(*uint8)(unsafe.Pointer(v370)) = uint8(libc.Uint32FromInt32(_objIndexCopy10))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy10
				}
				v372 = delta1
				v373 = envPtr2
				if v372 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v373)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v373)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v373)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v373)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v373 + 64)) += int64(v372)
			}
		}
		end = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v375 = envPtr2 + 152
		v374 = *(*uintptr)(unsafe.Pointer(v375))
		*(*uintptr)(unsafe.Pointer(v375))++
		*(*uint8)(unsafe.Pointer(v374)) = libc.Uint8FromInt32(int32(INST_JUMP1))
		v377 = envPtr2 + 152
		v376 = *(*uintptr)(unsafe.Pointer(v377))
		*(*uintptr)(unsafe.Pointer(v377))++
		*(*uint8)(unsafe.Pointer(v376)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v378 = delta1
			v379 = envPtr2
			if v378 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v379)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v379)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v379)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v379)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v379 + 64)) += int64(v378)
		}
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(isEmpty) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(isEmpty)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v381 = envPtr2 + 152
		v380 = *(*uintptr)(unsafe.Pointer(v381))
		*(*uintptr)(unsafe.Pointer(v381))++
		*(*uint8)(unsafe.Pointer(v380)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v382 = delta1
			v383 = envPtr2
			if v382 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v383)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v383)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v383)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v383)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v383 + 64)) += int64(v382)
		}
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(satisfied) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(satisfied)))
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v385 = envPtr2 + 152
		v384 = *(*uintptr)(unsafe.Pointer(v385))
		*(*uintptr)(unsafe.Pointer(v385))++
		*(*uint8)(unsafe.Pointer(v384)) = libc.Uint8FromInt32(int32(INST_NUM_TYPE))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_NUM_TYPE)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v386 = delta1
			v387 = envPtr2
			if v386 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v387)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v387)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v387)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v387)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v387 + 64)) += int64(v386)
		}
		satisfied = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v389 = envPtr2 + 152
		v388 = *(*uintptr)(unsafe.Pointer(v389))
		*(*uintptr)(unsafe.Pointer(v389))++
		*(*uint8)(unsafe.Pointer(v388)) = libc.Uint8FromInt32(int32(INST_JUMP_TRUE1))
		v391 = envPtr2 + 152
		v390 = *(*uintptr)(unsafe.Pointer(v391))
		*(*uintptr)(unsafe.Pointer(v391))++
		*(*uint8)(unsafe.Pointer(v390)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP_TRUE1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v392 = delta1
			v393 = envPtr2
			if v392 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v393)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v393)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v393)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v393)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v393 + 64)) += int64(v392)
		}
		_objIndexCopy11 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+14828, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy11 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v395 = envPtr2 + 152
			v394 = *(*uintptr)(unsafe.Pointer(v395))
			*(*uintptr)(unsafe.Pointer(v395))++
			*(*uint8)(unsafe.Pointer(v394)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v397 = envPtr2 + 152
			v396 = *(*uintptr)(unsafe.Pointer(v397))
			*(*uintptr)(unsafe.Pointer(v397))++
			*(*uint8)(unsafe.Pointer(v396)) = uint8(libc.Uint32FromInt32(_objIndexCopy11))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy11
				}
				v398 = delta1
				v399 = envPtr2
				if v398 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v399)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v399)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v399)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v399)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v399 + 64)) += int64(v398)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v401 = envPtr2 + 152
			v400 = *(*uintptr)(unsafe.Pointer(v401))
			*(*uintptr)(unsafe.Pointer(v401))++
			*(*uint8)(unsafe.Pointer(v400)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v403 = envPtr2 + 152
			v402 = *(*uintptr)(unsafe.Pointer(v403))
			*(*uintptr)(unsafe.Pointer(v403))++
			*(*uint8)(unsafe.Pointer(v402)) = uint8(libc.Uint32FromInt32(_objIndexCopy11) >> libc.Int32FromInt32(24))
			v405 = envPtr2 + 152
			v404 = *(*uintptr)(unsafe.Pointer(v405))
			*(*uintptr)(unsafe.Pointer(v405))++
			*(*uint8)(unsafe.Pointer(v404)) = uint8(libc.Uint32FromInt32(_objIndexCopy11) >> libc.Int32FromInt32(16))
			v407 = envPtr2 + 152
			v406 = *(*uintptr)(unsafe.Pointer(v407))
			*(*uintptr)(unsafe.Pointer(v407))++
			*(*uint8)(unsafe.Pointer(v406)) = uint8(libc.Uint32FromInt32(_objIndexCopy11) >> libc.Int32FromInt32(8))
			v409 = envPtr2 + 152
			v408 = *(*uintptr)(unsafe.Pointer(v409))
			*(*uintptr)(unsafe.Pointer(v409))++
			*(*uint8)(unsafe.Pointer(v408)) = uint8(libc.Uint32FromInt32(_objIndexCopy11))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy11
				}
				v410 = delta1
				v411 = envPtr2
				if v410 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v411)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v411)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v411)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v411)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v411 + 64)) += int64(v410)
			}
		}
		end = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v413 = envPtr2 + 152
		v412 = *(*uintptr)(unsafe.Pointer(v413))
		*(*uintptr)(unsafe.Pointer(v413))++
		*(*uint8)(unsafe.Pointer(v412)) = libc.Uint8FromInt32(int32(INST_JUMP1))
		v415 = envPtr2 + 152
		v414 = *(*uintptr)(unsafe.Pointer(v415))
		*(*uintptr)(unsafe.Pointer(v415))++
		*(*uint8)(unsafe.Pointer(v414)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v416 = delta1
			v417 = envPtr2
			if v416 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v417)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v417)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v417)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v417)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v417 + 64)) += int64(v416)
		}
		v418 = -int32(1)
		v419 = envPtr2
		if v418 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v419)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v419)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v419)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v419)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v419 + 64)) += int64(v418)
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(satisfied) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(satisfied)))
	}
	_objIndexCopy12 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+21397, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy12 <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v421 = envPtr2 + 152
		v420 = *(*uintptr)(unsafe.Pointer(v421))
		*(*uintptr)(unsafe.Pointer(v421))++
		*(*uint8)(unsafe.Pointer(v420)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v423 = envPtr2 + 152
		v422 = *(*uintptr)(unsafe.Pointer(v423))
		*(*uintptr)(unsafe.Pointer(v423))++
		*(*uint8)(unsafe.Pointer(v422)) = uint8(libc.Uint32FromInt32(_objIndexCopy12))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy12
			}
			v424 = delta1
			v425 = envPtr2
			if v424 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v425)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v425)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v425)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v425)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v425 + 64)) += int64(v424)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v427 = envPtr2 + 152
		v426 = *(*uintptr)(unsafe.Pointer(v427))
		*(*uintptr)(unsafe.Pointer(v427))++
		*(*uint8)(unsafe.Pointer(v426)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v429 = envPtr2 + 152
		v428 = *(*uintptr)(unsafe.Pointer(v429))
		*(*uintptr)(unsafe.Pointer(v429))++
		*(*uint8)(unsafe.Pointer(v428)) = uint8(libc.Uint32FromInt32(_objIndexCopy12) >> libc.Int32FromInt32(24))
		v431 = envPtr2 + 152
		v430 = *(*uintptr)(unsafe.Pointer(v431))
		*(*uintptr)(unsafe.Pointer(v431))++
		*(*uint8)(unsafe.Pointer(v430)) = uint8(libc.Uint32FromInt32(_objIndexCopy12) >> libc.Int32FromInt32(16))
		v433 = envPtr2 + 152
		v432 = *(*uintptr)(unsafe.Pointer(v433))
		*(*uintptr)(unsafe.Pointer(v433))++
		*(*uint8)(unsafe.Pointer(v432)) = uint8(libc.Uint32FromInt32(_objIndexCopy12) >> libc.Int32FromInt32(8))
		v435 = envPtr2 + 152
		v434 = *(*uintptr)(unsafe.Pointer(v435))
		*(*uintptr)(unsafe.Pointer(v435))++
		*(*uint8)(unsafe.Pointer(v434)) = uint8(libc.Uint32FromInt32(_objIndexCopy12))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy12
			}
			v436 = delta1
			v437 = envPtr2
			if v436 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v437)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v437)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v437)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v437)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v437 + 64)) += int64(v436)
		}
	}
	*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(end) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(end)))
	return TCL_OK
_45:
	;
_44:
	;
_43:
	;
	if allowEmpty != 0 {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v439 = envPtr2 + 152
		v438 = *(*uintptr)(unsafe.Pointer(v439))
		*(*uintptr)(unsafe.Pointer(v439))++
		*(*uint8)(unsafe.Pointer(v438)) = libc.Uint8FromInt32(int32(INST_DUP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_DUP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v440 = delta1
			v441 = envPtr2
			if v440 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v441)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v441)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v441)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v441)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v441 + 64)) += int64(v440)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v443 = envPtr2 + 152
		v442 = *(*uintptr)(unsafe.Pointer(v443))
		*(*uintptr)(unsafe.Pointer(v443))++
		*(*uint8)(unsafe.Pointer(v442)) = libc.Uint8FromInt32(int32(INST_NUM_TYPE))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_NUM_TYPE)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v444 = delta1
			v445 = envPtr2
			if v444 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v445)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v445)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v445)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v445)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v445 + 64)) += int64(v444)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v447 = envPtr2 + 152
		v446 = *(*uintptr)(unsafe.Pointer(v447))
		*(*uintptr)(unsafe.Pointer(v447))++
		*(*uint8)(unsafe.Pointer(v446)) = libc.Uint8FromInt32(int32(INST_DUP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_DUP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v448 = delta1
			v449 = envPtr2
			if v448 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v449)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v449)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v449)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v449)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v449 + 64)) += int64(v448)
		}
		testNumType = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v451 = envPtr2 + 152
		v450 = *(*uintptr)(unsafe.Pointer(v451))
		*(*uintptr)(unsafe.Pointer(v451))++
		*(*uint8)(unsafe.Pointer(v450)) = libc.Uint8FromInt32(int32(INST_JUMP_TRUE1))
		v453 = envPtr2 + 152
		v452 = *(*uintptr)(unsafe.Pointer(v453))
		*(*uintptr)(unsafe.Pointer(v453))++
		*(*uint8)(unsafe.Pointer(v452)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP_TRUE1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v454 = delta1
			v455 = envPtr2
			if v454 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v455)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v455)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v455)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v455)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v455 + 64)) += int64(v454)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v457 = envPtr2 + 152
		v456 = *(*uintptr)(unsafe.Pointer(v457))
		*(*uintptr)(unsafe.Pointer(v457))++
		*(*uint8)(unsafe.Pointer(v456)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v458 = delta1
			v459 = envPtr2
			if v458 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v459)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v459)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v459)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v459)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v459 + 64)) += int64(v458)
		}
		_objIndexCopy13 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy13 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v461 = envPtr2 + 152
			v460 = *(*uintptr)(unsafe.Pointer(v461))
			*(*uintptr)(unsafe.Pointer(v461))++
			*(*uint8)(unsafe.Pointer(v460)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v463 = envPtr2 + 152
			v462 = *(*uintptr)(unsafe.Pointer(v463))
			*(*uintptr)(unsafe.Pointer(v463))++
			*(*uint8)(unsafe.Pointer(v462)) = uint8(libc.Uint32FromInt32(_objIndexCopy13))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy13
				}
				v464 = delta1
				v465 = envPtr2
				if v464 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v465)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v465)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v465)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v465)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v465 + 64)) += int64(v464)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v467 = envPtr2 + 152
			v466 = *(*uintptr)(unsafe.Pointer(v467))
			*(*uintptr)(unsafe.Pointer(v467))++
			*(*uint8)(unsafe.Pointer(v466)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v469 = envPtr2 + 152
			v468 = *(*uintptr)(unsafe.Pointer(v469))
			*(*uintptr)(unsafe.Pointer(v469))++
			*(*uint8)(unsafe.Pointer(v468)) = uint8(libc.Uint32FromInt32(_objIndexCopy13) >> libc.Int32FromInt32(24))
			v471 = envPtr2 + 152
			v470 = *(*uintptr)(unsafe.Pointer(v471))
			*(*uintptr)(unsafe.Pointer(v471))++
			*(*uint8)(unsafe.Pointer(v470)) = uint8(libc.Uint32FromInt32(_objIndexCopy13) >> libc.Int32FromInt32(16))
			v473 = envPtr2 + 152
			v472 = *(*uintptr)(unsafe.Pointer(v473))
			*(*uintptr)(unsafe.Pointer(v473))++
			*(*uint8)(unsafe.Pointer(v472)) = uint8(libc.Uint32FromInt32(_objIndexCopy13) >> libc.Int32FromInt32(8))
			v475 = envPtr2 + 152
			v474 = *(*uintptr)(unsafe.Pointer(v475))
			*(*uintptr)(unsafe.Pointer(v475))++
			*(*uint8)(unsafe.Pointer(v474)) = uint8(libc.Uint32FromInt32(_objIndexCopy13))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy13
				}
				v476 = delta1
				v477 = envPtr2
				if v476 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v477)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v477)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v477)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v477)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v477 + 64)) += int64(v476)
			}
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v479 = envPtr2 + 152
		v478 = *(*uintptr)(unsafe.Pointer(v479))
		*(*uintptr)(unsafe.Pointer(v479))++
		*(*uint8)(unsafe.Pointer(v478)) = libc.Uint8FromInt32(int32(INST_STR_EQ))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STR_EQ)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v480 = delta1
			v481 = envPtr2
			if v480 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v481)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v481)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v481)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v481)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v481 + 64)) += int64(v480)
		}
		end = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v483 = envPtr2 + 152
		v482 = *(*uintptr)(unsafe.Pointer(v483))
		*(*uintptr)(unsafe.Pointer(v483))++
		*(*uint8)(unsafe.Pointer(v482)) = libc.Uint8FromInt32(int32(INST_JUMP1))
		v485 = envPtr2 + 152
		v484 = *(*uintptr)(unsafe.Pointer(v485))
		*(*uintptr)(unsafe.Pointer(v485))++
		*(*uint8)(unsafe.Pointer(v484)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v486 = delta1
			v487 = envPtr2
			if v486 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v487)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v487)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v487)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v487)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v487 + 64)) += int64(v486)
		}
		v488 = int32(1)
		v489 = envPtr2
		if v488 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v489)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v489)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v489)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v489)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v489 + 64)) += int64(v488)
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(testNumType) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(testNumType)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v491 = envPtr2 + 152
		v490 = *(*uintptr)(unsafe.Pointer(v491))
		*(*uintptr)(unsafe.Pointer(v491))++
		*(*uint8)(unsafe.Pointer(v490)) = libc.Uint8FromInt32(int32(INST_REVERSE))
		v493 = envPtr2 + 152
		v492 = *(*uintptr)(unsafe.Pointer(v493))
		*(*uintptr)(unsafe.Pointer(v493))++
		*(*uint8)(unsafe.Pointer(v492)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
		v495 = envPtr2 + 152
		v494 = *(*uintptr)(unsafe.Pointer(v495))
		*(*uintptr)(unsafe.Pointer(v495))++
		*(*uint8)(unsafe.Pointer(v494)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
		v497 = envPtr2 + 152
		v496 = *(*uintptr)(unsafe.Pointer(v497))
		*(*uintptr)(unsafe.Pointer(v497))++
		*(*uint8)(unsafe.Pointer(v496)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
		v499 = envPtr2 + 152
		v498 = *(*uintptr)(unsafe.Pointer(v499))
		*(*uintptr)(unsafe.Pointer(v499))++
		*(*uint8)(unsafe.Pointer(v498)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(2)
			}
			v500 = delta1
			v501 = envPtr2
			if v500 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v501)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v501)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v501)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v501)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v501 + 64)) += int64(v500)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v503 = envPtr2 + 152
		v502 = *(*uintptr)(unsafe.Pointer(v503))
		*(*uintptr)(unsafe.Pointer(v503))++
		*(*uint8)(unsafe.Pointer(v502)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v504 = delta1
			v505 = envPtr2
			if v504 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v505)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v505)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v505)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v505)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v505 + 64)) += int64(v504)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v507 = envPtr2 + 152
		v506 = *(*uintptr)(unsafe.Pointer(v507))
		*(*uintptr)(unsafe.Pointer(v507))++
		*(*uint8)(unsafe.Pointer(v506)) = libc.Uint8FromInt32(int32(INST_NUM_TYPE))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_NUM_TYPE)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v508 = delta1
			v509 = envPtr2
			if v508 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v509)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v509)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v509)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v509)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v509 + 64)) += int64(v508)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v511 = envPtr2 + 152
		v510 = *(*uintptr)(unsafe.Pointer(v511))
		*(*uintptr)(unsafe.Pointer(v511))++
		*(*uint8)(unsafe.Pointer(v510)) = libc.Uint8FromInt32(int32(INST_DUP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_DUP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v512 = delta1
			v513 = envPtr2
			if v512 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v513)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v513)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v513)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v513)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v513 + 64)) += int64(v512)
		}
		end = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v515 = envPtr2 + 152
		v514 = *(*uintptr)(unsafe.Pointer(v515))
		*(*uintptr)(unsafe.Pointer(v515))++
		*(*uint8)(unsafe.Pointer(v514)) = libc.Uint8FromInt32(int32(INST_JUMP_FALSE1))
		v517 = envPtr2 + 152
		v516 = *(*uintptr)(unsafe.Pointer(v517))
		*(*uintptr)(unsafe.Pointer(v517))++
		*(*uint8)(unsafe.Pointer(v516)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP_FALSE1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v518 = delta1
			v519 = envPtr2
			if v518 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v519)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v519)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v519)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v519)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v519 + 64)) += int64(v518)
		}
	}
	switch *(*int32)(unsafe.Pointer(bp)) {
	case 19:
		goto _520
	case 8:
		goto _521
	case 11:
		goto _522
	default:
		goto _523
	}
	goto _524
_520:
	;
_527:
	;
	_objIndexCopy14 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+21831, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy14 <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v529 = envPtr2 + 152
		v528 = *(*uintptr)(unsafe.Pointer(v529))
		*(*uintptr)(unsafe.Pointer(v529))++
		*(*uint8)(unsafe.Pointer(v528)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v531 = envPtr2 + 152
		v530 = *(*uintptr)(unsafe.Pointer(v531))
		*(*uintptr)(unsafe.Pointer(v531))++
		*(*uint8)(unsafe.Pointer(v530)) = uint8(libc.Uint32FromInt32(_objIndexCopy14))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy14
			}
			v532 = delta1
			v533 = envPtr2
			if v532 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v533)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v533)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v533)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v533)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v533 + 64)) += int64(v532)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v535 = envPtr2 + 152
		v534 = *(*uintptr)(unsafe.Pointer(v535))
		*(*uintptr)(unsafe.Pointer(v535))++
		*(*uint8)(unsafe.Pointer(v534)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v537 = envPtr2 + 152
		v536 = *(*uintptr)(unsafe.Pointer(v537))
		*(*uintptr)(unsafe.Pointer(v537))++
		*(*uint8)(unsafe.Pointer(v536)) = uint8(libc.Uint32FromInt32(_objIndexCopy14) >> libc.Int32FromInt32(24))
		v539 = envPtr2 + 152
		v538 = *(*uintptr)(unsafe.Pointer(v539))
		*(*uintptr)(unsafe.Pointer(v539))++
		*(*uint8)(unsafe.Pointer(v538)) = uint8(libc.Uint32FromInt32(_objIndexCopy14) >> libc.Int32FromInt32(16))
		v541 = envPtr2 + 152
		v540 = *(*uintptr)(unsafe.Pointer(v541))
		*(*uintptr)(unsafe.Pointer(v541))++
		*(*uint8)(unsafe.Pointer(v540)) = uint8(libc.Uint32FromInt32(_objIndexCopy14) >> libc.Int32FromInt32(8))
		v543 = envPtr2 + 152
		v542 = *(*uintptr)(unsafe.Pointer(v543))
		*(*uintptr)(unsafe.Pointer(v543))++
		*(*uint8)(unsafe.Pointer(v542)) = uint8(libc.Uint32FromInt32(_objIndexCopy14))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy14
			}
			v544 = delta1
			v545 = envPtr2
			if v544 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v545)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v545)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v545)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v545)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v545 + 64)) += int64(v544)
		}
	}
	goto _526
_526:
	;
	if 0 != 0 {
		goto _527
	}
	goto _525
_525:
	;
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v547 = envPtr2 + 152
	v546 = *(*uintptr)(unsafe.Pointer(v547))
	*(*uintptr)(unsafe.Pointer(v547))++
	*(*uint8)(unsafe.Pointer(v546)) = libc.Uint8FromInt32(int32(INST_LE))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_LE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v548 = delta1
		v549 = envPtr2
		if v548 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v549)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v549)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v549)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v549)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v549 + 64)) += int64(v548)
	}
	goto _524
_522:
	;
_521:
	;
	_objIndexCopy15 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+21870, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy15 <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v551 = envPtr2 + 152
		v550 = *(*uintptr)(unsafe.Pointer(v551))
		*(*uintptr)(unsafe.Pointer(v551))++
		*(*uint8)(unsafe.Pointer(v550)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v553 = envPtr2 + 152
		v552 = *(*uintptr)(unsafe.Pointer(v553))
		*(*uintptr)(unsafe.Pointer(v553))++
		*(*uint8)(unsafe.Pointer(v552)) = uint8(libc.Uint32FromInt32(_objIndexCopy15))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy15
			}
			v554 = delta1
			v555 = envPtr2
			if v554 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v555)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v555)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v555)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v555)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v555 + 64)) += int64(v554)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v557 = envPtr2 + 152
		v556 = *(*uintptr)(unsafe.Pointer(v557))
		*(*uintptr)(unsafe.Pointer(v557))++
		*(*uint8)(unsafe.Pointer(v556)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v559 = envPtr2 + 152
		v558 = *(*uintptr)(unsafe.Pointer(v559))
		*(*uintptr)(unsafe.Pointer(v559))++
		*(*uint8)(unsafe.Pointer(v558)) = uint8(libc.Uint32FromInt32(_objIndexCopy15) >> libc.Int32FromInt32(24))
		v561 = envPtr2 + 152
		v560 = *(*uintptr)(unsafe.Pointer(v561))
		*(*uintptr)(unsafe.Pointer(v561))++
		*(*uint8)(unsafe.Pointer(v560)) = uint8(libc.Uint32FromInt32(_objIndexCopy15) >> libc.Int32FromInt32(16))
		v563 = envPtr2 + 152
		v562 = *(*uintptr)(unsafe.Pointer(v563))
		*(*uintptr)(unsafe.Pointer(v563))++
		*(*uint8)(unsafe.Pointer(v562)) = uint8(libc.Uint32FromInt32(_objIndexCopy15) >> libc.Int32FromInt32(8))
		v565 = envPtr2 + 152
		v564 = *(*uintptr)(unsafe.Pointer(v565))
		*(*uintptr)(unsafe.Pointer(v565))++
		*(*uint8)(unsafe.Pointer(v564)) = uint8(libc.Uint32FromInt32(_objIndexCopy15))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy15
			}
			v566 = delta1
			v567 = envPtr2
			if v566 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v567)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v567)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v567)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v567)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v567 + 64)) += int64(v566)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v569 = envPtr2 + 152
	v568 = *(*uintptr)(unsafe.Pointer(v569))
	*(*uintptr)(unsafe.Pointer(v569))++
	*(*uint8)(unsafe.Pointer(v568)) = libc.Uint8FromInt32(int32(INST_LE))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_LE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v570 = delta1
		v571 = envPtr2
		if v570 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v571)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v571)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v571)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v571)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v571 + 64)) += int64(v570)
	}
	goto _524
_523:
	;
	goto _524
_524:
	;
	*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(end) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(end)))
	return TCL_OK
_46:
	;
	range1 = int32(XTclCreateExceptRange(tls, int32(CATCH_EXCEPTION_RANGE), envPtr2))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v573 = envPtr2 + 152
	v572 = *(*uintptr)(unsafe.Pointer(v573))
	*(*uintptr)(unsafe.Pointer(v573))++
	*(*uint8)(unsafe.Pointer(v572)) = libc.Uint8FromInt32(int32(INST_BEGIN_CATCH4))
	v575 = envPtr2 + 152
	v574 = *(*uintptr)(unsafe.Pointer(v575))
	*(*uintptr)(unsafe.Pointer(v575))++
	*(*uint8)(unsafe.Pointer(v574)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(24))
	v577 = envPtr2 + 152
	v576 = *(*uintptr)(unsafe.Pointer(v577))
	*(*uintptr)(unsafe.Pointer(v577))++
	*(*uint8)(unsafe.Pointer(v576)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(16))
	v579 = envPtr2 + 152
	v578 = *(*uintptr)(unsafe.Pointer(v579))
	*(*uintptr)(unsafe.Pointer(v579))++
	*(*uint8)(unsafe.Pointer(v578)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(8))
	v581 = envPtr2 + 152
	v580 = *(*uintptr)(unsafe.Pointer(v581))
	*(*uintptr)(unsafe.Pointer(v581))++
	*(*uint8)(unsafe.Pointer(v580)) = uint8(libc.Uint32FromInt32(range1))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_BEGIN_CATCH4)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - range1
		}
		v582 = delta1
		v583 = envPtr2
		if v582 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v583)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v583)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v583)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v583)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v583 + 64)) += int64(v582)
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth++
	if libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth)+uint64(1) > libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth)+uint64(1) {
		v584 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth
	} else {
		v584 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth = v584
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v586 = envPtr2 + 152
	v585 = *(*uintptr)(unsafe.Pointer(v586))
	*(*uintptr)(unsafe.Pointer(v586))++
	*(*uint8)(unsafe.Pointer(v585)) = libc.Uint8FromInt32(int32(INST_DUP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_DUP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v587 = delta1
		v588 = envPtr2
		if v587 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v588)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v588)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v588)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v588)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v588 + 64)) += int64(v587)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v590 = envPtr2 + 152
	v589 = *(*uintptr)(unsafe.Pointer(v590))
	*(*uintptr)(unsafe.Pointer(v590))++
	*(*uint8)(unsafe.Pointer(v589)) = libc.Uint8FromInt32(int32(INST_DICT_VERIFY))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_DICT_VERIFY)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v591 = delta1
		v592 = envPtr2
		if v591 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v592)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v592)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v592)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v592)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v592 + 64)) += int64(v591)
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth--
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FnumCodeBytes = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(int32((*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset))
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcatchOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v594 = envPtr2 + 152
	v593 = *(*uintptr)(unsafe.Pointer(v594))
	*(*uintptr)(unsafe.Pointer(v594))++
	*(*uint8)(unsafe.Pointer(v593)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v595 = delta1
		v596 = envPtr2
		if v595 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v596)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v596)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v596)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v596)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v596 + 64)) += int64(v595)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v598 = envPtr2 + 152
	v597 = *(*uintptr)(unsafe.Pointer(v598))
	*(*uintptr)(unsafe.Pointer(v598))++
	*(*uint8)(unsafe.Pointer(v597)) = libc.Uint8FromInt32(int32(INST_PUSH_RETURN_CODE))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_PUSH_RETURN_CODE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v599 = delta1
		v600 = envPtr2
		if v599 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v600)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v600)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v600)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v600)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v600 + 64)) += int64(v599)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v602 = envPtr2 + 152
	v601 = *(*uintptr)(unsafe.Pointer(v602))
	*(*uintptr)(unsafe.Pointer(v602))++
	*(*uint8)(unsafe.Pointer(v601)) = libc.Uint8FromInt32(int32(INST_END_CATCH))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_END_CATCH)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v603 = delta1
		v604 = envPtr2
		if v603 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v604)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v604)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v604)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v604)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v604 + 64)) += int64(v603)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v606 = envPtr2 + 152
	v605 = *(*uintptr)(unsafe.Pointer(v606))
	*(*uintptr)(unsafe.Pointer(v606))++
	*(*uint8)(unsafe.Pointer(v605)) = libc.Uint8FromInt32(int32(INST_LNOT))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_LNOT)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v607 = delta1
		v608 = envPtr2
		if v607 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v608)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v608)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v608)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v608)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v608 + 64)) += int64(v607)
	}
	return TCL_OK
_47:
	;
	range1 = int32(XTclCreateExceptRange(tls, int32(CATCH_EXCEPTION_RANGE), envPtr2))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v610 = envPtr2 + 152
	v609 = *(*uintptr)(unsafe.Pointer(v610))
	*(*uintptr)(unsafe.Pointer(v610))++
	*(*uint8)(unsafe.Pointer(v609)) = libc.Uint8FromInt32(int32(INST_BEGIN_CATCH4))
	v612 = envPtr2 + 152
	v611 = *(*uintptr)(unsafe.Pointer(v612))
	*(*uintptr)(unsafe.Pointer(v612))++
	*(*uint8)(unsafe.Pointer(v611)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(24))
	v614 = envPtr2 + 152
	v613 = *(*uintptr)(unsafe.Pointer(v614))
	*(*uintptr)(unsafe.Pointer(v614))++
	*(*uint8)(unsafe.Pointer(v613)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(16))
	v616 = envPtr2 + 152
	v615 = *(*uintptr)(unsafe.Pointer(v616))
	*(*uintptr)(unsafe.Pointer(v616))++
	*(*uint8)(unsafe.Pointer(v615)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(8))
	v618 = envPtr2 + 152
	v617 = *(*uintptr)(unsafe.Pointer(v618))
	*(*uintptr)(unsafe.Pointer(v618))++
	*(*uint8)(unsafe.Pointer(v617)) = uint8(libc.Uint32FromInt32(range1))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_BEGIN_CATCH4)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - range1
		}
		v619 = delta1
		v620 = envPtr2
		if v619 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v620)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v620)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v620)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v620)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v620 + 64)) += int64(v619)
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth++
	if libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth)+uint64(1) > libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth)+uint64(1) {
		v621 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth
	} else {
		v621 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth = v621
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v623 = envPtr2 + 152
	v622 = *(*uintptr)(unsafe.Pointer(v623))
	*(*uintptr)(unsafe.Pointer(v623))++
	*(*uint8)(unsafe.Pointer(v622)) = libc.Uint8FromInt32(int32(INST_DUP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_DUP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v624 = delta1
		v625 = envPtr2
		if v624 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v625)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v625)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v625)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v625)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v625 + 64)) += int64(v624)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v627 = envPtr2 + 152
	v626 = *(*uintptr)(unsafe.Pointer(v627))
	*(*uintptr)(unsafe.Pointer(v627))++
	*(*uint8)(unsafe.Pointer(v626)) = libc.Uint8FromInt32(int32(INST_LIST_LENGTH))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_LIST_LENGTH)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v628 = delta1
		v629 = envPtr2
		if v628 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v629)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v629)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v629)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v629)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v629 + 64)) += int64(v628)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v631 = envPtr2 + 152
	v630 = *(*uintptr)(unsafe.Pointer(v631))
	*(*uintptr)(unsafe.Pointer(v631))++
	*(*uint8)(unsafe.Pointer(v630)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v632 = delta1
		v633 = envPtr2
		if v632 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v633)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v633)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v633)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v633)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v633 + 64)) += int64(v632)
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth--
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FnumCodeBytes = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(int32((*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset))
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcatchOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v635 = envPtr2 + 152
	v634 = *(*uintptr)(unsafe.Pointer(v635))
	*(*uintptr)(unsafe.Pointer(v635))++
	*(*uint8)(unsafe.Pointer(v634)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v636 = delta1
		v637 = envPtr2
		if v636 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v637)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v637)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v637)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v637)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v637 + 64)) += int64(v636)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v639 = envPtr2 + 152
	v638 = *(*uintptr)(unsafe.Pointer(v639))
	*(*uintptr)(unsafe.Pointer(v639))++
	*(*uint8)(unsafe.Pointer(v638)) = libc.Uint8FromInt32(int32(INST_PUSH_RETURN_CODE))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_PUSH_RETURN_CODE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v640 = delta1
		v641 = envPtr2
		if v640 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v641)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v641)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v641)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v641)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v641 + 64)) += int64(v640)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v643 = envPtr2 + 152
	v642 = *(*uintptr)(unsafe.Pointer(v643))
	*(*uintptr)(unsafe.Pointer(v643))++
	*(*uint8)(unsafe.Pointer(v642)) = libc.Uint8FromInt32(int32(INST_END_CATCH))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_END_CATCH)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v644 = delta1
		v645 = envPtr2
		if v644 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v645)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v645)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v645)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v645)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v645 + 64)) += int64(v644)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v647 = envPtr2 + 152
	v646 = *(*uintptr)(unsafe.Pointer(v647))
	*(*uintptr)(unsafe.Pointer(v647))++
	*(*uint8)(unsafe.Pointer(v646)) = libc.Uint8FromInt32(int32(INST_LNOT))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_LNOT)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v648 = delta1
		v649 = envPtr2
		if v648 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v649)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v649)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v649)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v649)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v649 + 64)) += int64(v648)
	}
	return TCL_OK
_48:
	;
	return XTclCompileBasicMin0ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
}

var _isClasses1 = [23]uintptr{
	0:  __ccgo_ts + 1119,
	1:  __ccgo_ts + 1125,
	2:  __ccgo_ts + 1131,
	3:  __ccgo_ts + 19214,
	4:  __ccgo_ts + 3611,
	5:  __ccgo_ts + 19222,
	6:  __ccgo_ts + 1149,
	7:  __ccgo_ts + 6055,
	8:  __ccgo_ts + 6062,
	9:  __ccgo_ts + 19227,
	10: __ccgo_ts + 1155,
	11: __ccgo_ts + 6223,
	12: __ccgo_ts + 2860,
	13: __ccgo_ts + 1161,
	14: __ccgo_ts + 1167,
	15: __ccgo_ts + 1173,
	16: __ccgo_ts + 558,
	17: __ccgo_ts + 19233,
	18: __ccgo_ts + 1179,
	19: __ccgo_ts + 19238,
	20: __ccgo_ts + 19250,
	21: __ccgo_ts + 1185,
	22: libc.UintptrFromInt32(0),
}

func XTclCompileStringMatchCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, delta1, exactMatch, i1, nocase, v10, v22, v26, v32 int32
	var cachePtr, copy1, mapPtr, str, tokenPtr, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v23, v24, v25, v27, v28, v29, v30, v31, v33, v4, v6, v7, v8, v9 uintptr
	var eclIndex, v3 TTcl_Size
	var length Tsize_t
	var v5 bool
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, cachePtr, copy1, delta1, eclIndex, exactMatch, i1, length, mapPtr, nocase, str, tokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v4, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	exactMatch = 0
	nocase = 0
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords < int64(3) || (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords > int64(4) {
		return int32(TCL_ERROR)
	}
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	/*
	 * Check if we have a -nocase flag.
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(4) {
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) {
			return XTclCompileBasic3ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
		}
		str = (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart
		length = libc.Uint64FromInt64((*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize)
		if length <= uint64(1) || libc.Xstrncmp(tls, str, __ccgo_ts+17555, length) != 0 {
			/*
			 * Fail at run time, not in compilation.
			 */
			return XTclCompileBasic3ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
		}
		nocase = int32(1)
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	}
	/*
	 * Push the strings to match against each other.
	 */
	i1 = 0
	for {
		if !(i1 < int32(2)) {
			break
		}
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			str = (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart
			length = libc.Uint64FromInt64((*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize)
			if !(nocase != 0) && i1 == 0 {
				/*
				 * Trivial matches can be done by 'string equal'. If -nocase
				 * was specified, we can't do this because INST_STR_EQ has no
				 * support for nocase.
				 */
				copy1 = XTcl_NewStringObj(tls, str, libc.Int64FromUint64(length))
				(*TTcl_Obj)(unsafe.Pointer(copy1)).FrefCount++
				if (*TTcl_Obj)(unsafe.Pointer(copy1)).Fbytes != 0 {
					v2 = (*TTcl_Obj)(unsafe.Pointer(copy1)).Fbytes
				} else {
					v2 = XTcl_GetStringFromObj(tls, copy1, libc.UintptrFromInt32(0))
				}
				exactMatch = libc.BoolInt32(libc.Xstrpbrk(tls, v2, __ccgo_ts+16411) == libc.UintptrFromInt32(0))
				v4 = copy1
				v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
				*(*TTcl_Size)(unsafe.Pointer(v4))--
				if !(v3 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(copy1)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(copy1)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(copy1)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(copy1)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(copy1)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(copy1)).Flength = int64(-libc.Int32FromInt32(1))
						if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
							cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v5 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, copy1)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(copy1 + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = copy1
							(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, copy1)
					}
				}
			}
			_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, str, libc.Int64FromUint64(length), 0)
			if _objIndexCopy <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v7 = envPtr2 + 152
				v6 = *(*uintptr)(unsafe.Pointer(v7))
				*(*uintptr)(unsafe.Pointer(v7))++
				*(*uint8)(unsafe.Pointer(v6)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v9 = envPtr2 + 152
				v8 = *(*uintptr)(unsafe.Pointer(v9))
				*(*uintptr)(unsafe.Pointer(v9))++
				*(*uint8)(unsafe.Pointer(v8)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v10 = delta1
					v11 = envPtr2
					if v10 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v11)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v11)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v11)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v11)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v11 + 64)) += int64(v10)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v13 = envPtr2 + 152
				v12 = *(*uintptr)(unsafe.Pointer(v13))
				*(*uintptr)(unsafe.Pointer(v13))++
				*(*uint8)(unsafe.Pointer(v12)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v15 = envPtr2 + 152
				v14 = *(*uintptr)(unsafe.Pointer(v15))
				*(*uintptr)(unsafe.Pointer(v15))++
				*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
				v17 = envPtr2 + 152
				v16 = *(*uintptr)(unsafe.Pointer(v17))
				*(*uintptr)(unsafe.Pointer(v17))++
				*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
				v19 = envPtr2 + 152
				v18 = *(*uintptr)(unsafe.Pointer(v19))
				*(*uintptr)(unsafe.Pointer(v19))++
				*(*uint8)(unsafe.Pointer(v18)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
				v21 = envPtr2 + 152
				v20 = *(*uintptr)(unsafe.Pointer(v21))
				*(*uintptr)(unsafe.Pointer(v21))++
				*(*uint8)(unsafe.Pointer(v20)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v22 = delta1
					v23 = envPtr2
					if v22 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v23)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v23)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v23)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v23)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v23 + 64)) += int64(v22)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1+libc.Int32FromInt32(1)+nocase)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1+libc.Int32FromInt32(1)+nocase)*8))
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		goto _1
	_1:
		;
		i1++
	}
	/*
	 * Push the matcher.
	 */
	if exactMatch != 0 {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v25 = envPtr2 + 152
		v24 = *(*uintptr)(unsafe.Pointer(v25))
		*(*uintptr)(unsafe.Pointer(v25))++
		*(*uint8)(unsafe.Pointer(v24)) = libc.Uint8FromInt32(int32(INST_STR_EQ))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STR_EQ)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v26 = delta1
			v27 = envPtr2
			if v26 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v27)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v27)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v27)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v27)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v27 + 64)) += int64(v26)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v29 = envPtr2 + 152
		v28 = *(*uintptr)(unsafe.Pointer(v29))
		*(*uintptr)(unsafe.Pointer(v29))++
		*(*uint8)(unsafe.Pointer(v28)) = libc.Uint8FromInt32(int32(INST_STR_MATCH))
		v31 = envPtr2 + 152
		v30 = *(*uintptr)(unsafe.Pointer(v31))
		*(*uintptr)(unsafe.Pointer(v31))++
		*(*uint8)(unsafe.Pointer(v30)) = uint8(libc.Uint32FromInt32(nocase))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STR_MATCH)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - nocase
			}
			v32 = delta1
			v33 = envPtr2
			if v32 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v33)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v33)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v33)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v33)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v33 + 64)) += int64(v32)
		}
	}
	return TCL_OK
}

func XTclCompileStringLenCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy873 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Holds resulting instructions. */
	var _objIndexCopy, delta1, v18, v22, v6 int32
	var cachePtr, cachePtr1, mapPtr, objPtr, tokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v19, v2, v20, v21, v23, v25, v3, v4, v5, v7, v8, v9 uintptr
	var eclIndex, v24 TTcl_Size
	var len1 Tsize_t
	var v1, v26 bool
	var _ /* buf at bp+0 */ [24]uint8
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, cachePtr, cachePtr1, delta1, eclIndex, len1, mapPtr, objPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v3, v4, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
		return int32(TCL_ERROR)
	}
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	if XTclWordKnownAtCompileTime(tls, tokenPtr, objPtr) != 0 {
		len1 = libc.Uint64FromInt64(XTcl_GetCharLength(tls, objPtr))
		len1 = libc.Uint64FromInt32(libc.X__builtin_snprintf(tls, bp, uint64(24), __ccgo_ts+21872, libc.VaList(bp+32, len1)))
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, bp, libc.Int64FromUint64(len1), 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v3 = envPtr2 + 152
			v2 = *(*uintptr)(unsafe.Pointer(v3))
			*(*uintptr)(unsafe.Pointer(v3))++
			*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v5 = envPtr2 + 152
			v4 = *(*uintptr)(unsafe.Pointer(v5))
			*(*uintptr)(unsafe.Pointer(v5))++
			*(*uint8)(unsafe.Pointer(v4)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v6 = delta1
				v7 = envPtr2
				if v6 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v7 + 64)) += int64(v6)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v9 = envPtr2 + 152
			v8 = *(*uintptr)(unsafe.Pointer(v9))
			*(*uintptr)(unsafe.Pointer(v9))++
			*(*uint8)(unsafe.Pointer(v8)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v11 = envPtr2 + 152
			v10 = *(*uintptr)(unsafe.Pointer(v11))
			*(*uintptr)(unsafe.Pointer(v11))++
			*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v13 = envPtr2 + 152
			v12 = *(*uintptr)(unsafe.Pointer(v13))
			*(*uintptr)(unsafe.Pointer(v13))++
			*(*uint8)(unsafe.Pointer(v12)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v15 = envPtr2 + 152
			v14 = *(*uintptr)(unsafe.Pointer(v15))
			*(*uintptr)(unsafe.Pointer(v15))++
			*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v17 = envPtr2 + 152
			v16 = *(*uintptr)(unsafe.Pointer(v17))
			*(*uintptr)(unsafe.Pointer(v17))++
			*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v18 = delta1
				v19 = envPtr2
				if v18 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v19 + 64)) += int64(v18)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v21 = envPtr2 + 152
		v20 = *(*uintptr)(unsafe.Pointer(v21))
		*(*uintptr)(unsafe.Pointer(v21))++
		*(*uint8)(unsafe.Pointer(v20)) = libc.Uint8FromInt32(int32(INST_STR_LEN))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STR_LEN)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v22 = delta1
			v23 = envPtr2
			if v22 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v23)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v23)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v23)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v23)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v23 + 64)) += int64(v22)
		}
	}
	v25 = objPtr
	v24 = *(*TTcl_Size)(unsafe.Pointer(v25))
	*(*TTcl_Size)(unsafe.Pointer(v25))--
	if !(v24 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(-libc.Int32FromInt32(1))
			if v26 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v26 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v26 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, objPtr)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = objPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, objPtr)
		}
	}
	return TCL_OK
}

func XTclCompileStringMapCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, delta1, v16, v28, v34, v4, v46, v53, v65, v71, v83, v87 int32
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, bytes, cachePtr, mapObj, mapPtr, mapTokenPtr, stringTokenPtr, v10, v11, v12, v13, v14, v15, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v29, v3, v30, v31, v32, v33, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v47, v48, v49, v50, v51, v52, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63, v64, v66, v67, v68, v69, v70, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v84, v85, v86, v88, v90 uintptr
	var eclIndex, v2, v7, v89, v9 TTcl_Size
	var v1 bool
	var v5, v6 int64
	var _ /* len at bp+8 */ TTcl_Size
	var _ /* objv at bp+0 */ uintptr
	var _ /* slen at bp+16 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, _objPtr, _objPtr1, _objPtr2, _objPtr3, bytes, cachePtr, delta1, eclIndex, mapObj, mapPtr, mapTokenPtr, stringTokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	/*
	 * We only handle the case:
	 *
	 *    string map {foo bar} $thing
	 *
	 * That is, a literal two-element list (doesn't need to be brace-quoted,
	 * but does need to be compile-time knowable) and any old argument (the
	 * thing to map).
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(3) {
		return int32(TCL_ERROR)
	}
	mapTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	stringTokenPtr = mapTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(mapTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		mapObj = XTclThreadAllocObj(tls)
	} else {
		mapObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(mapObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(mapObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(mapObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(mapObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(mapObj)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(mapObj)).FrefCount++
	if !(XTclWordKnownAtCompileTime(tls, mapTokenPtr, mapObj) != 0) {
		_objPtr = mapObj
		v3 = _objPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		return XTclCompileBasic2ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(mapObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(mapObj + 32))).Fptr2 != 0 {
				v5 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(mapObj + 32))).Fptr2)).FspanStart
			} else {
				v5 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(mapObj + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(mapObj + 32))).Fptr1 + 40 + uintptr(v5)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(mapObj + 32))).Fptr2 != 0 {
				v6 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(mapObj + 32))).Fptr2)).FspanLength
			} else {
				v6 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(mapObj + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v6
			v4 = libc.Int32FromInt32(TCL_OK)
		} else {
			v4 = XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), mapObj, bp+8, bp)
		}
		if v4 != TCL_OK {
			_objPtr1 = mapObj
			v8 = _objPtr1
			v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
			*(*TTcl_Size)(unsafe.Pointer(v8))--
			if v7 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
			return XTclCompileBasic2ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
		} else {
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) != int64(2) {
				_objPtr2 = mapObj
				v10 = _objPtr2
				v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
				*(*TTcl_Size)(unsafe.Pointer(v10))--
				if v9 <= int64(1) {
					XTclFreeObj(tls, _objPtr2)
				}
				return XTclCompileBasic2ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
			}
		}
	}
	/*
	 * Now issue the opcodes. Note that in the case that we know that the
	 * first word is an empty word, we don't issue the map at all. That is the
	 * correct semantics for mapping.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))).Flength
		v11 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))).Fbytes
	} else {
		v11 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))), bp+16)
	}
	bytes = v11
	if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) == 0 {
		if (*TTcl_Token)(unsafe.Pointer(stringTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(stringTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(stringTokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v13 = envPtr2 + 152
				v12 = *(*uintptr)(unsafe.Pointer(v13))
				*(*uintptr)(unsafe.Pointer(v13))++
				*(*uint8)(unsafe.Pointer(v12)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v15 = envPtr2 + 152
				v14 = *(*uintptr)(unsafe.Pointer(v15))
				*(*uintptr)(unsafe.Pointer(v15))++
				*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v16 = delta1
					v17 = envPtr2
					if v16 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v17)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v17)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v17)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v17)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v17 + 64)) += int64(v16)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v19 = envPtr2 + 152
				v18 = *(*uintptr)(unsafe.Pointer(v19))
				*(*uintptr)(unsafe.Pointer(v19))++
				*(*uint8)(unsafe.Pointer(v18)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v21 = envPtr2 + 152
				v20 = *(*uintptr)(unsafe.Pointer(v21))
				*(*uintptr)(unsafe.Pointer(v21))++
				*(*uint8)(unsafe.Pointer(v20)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
				v23 = envPtr2 + 152
				v22 = *(*uintptr)(unsafe.Pointer(v23))
				*(*uintptr)(unsafe.Pointer(v23))++
				*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
				v25 = envPtr2 + 152
				v24 = *(*uintptr)(unsafe.Pointer(v25))
				*(*uintptr)(unsafe.Pointer(v25))++
				*(*uint8)(unsafe.Pointer(v24)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
				v27 = envPtr2 + 152
				v26 = *(*uintptr)(unsafe.Pointer(v27))
				*(*uintptr)(unsafe.Pointer(v27))++
				*(*uint8)(unsafe.Pointer(v26)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v28 = delta1
					v29 = envPtr2
					if v28 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v29)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v29)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v29)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v29)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v29 + 64)) += int64(v28)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
			XTclCompileTokens(tls, interp, stringTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(stringTokenPtr)).FnumComponents), envPtr2)
		}
	} else {
		_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, bytes, *(*TTcl_Size)(unsafe.Pointer(bp + 16)), 0)
		if _objIndexCopy1 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v31 = envPtr2 + 152
			v30 = *(*uintptr)(unsafe.Pointer(v31))
			*(*uintptr)(unsafe.Pointer(v31))++
			*(*uint8)(unsafe.Pointer(v30)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v33 = envPtr2 + 152
			v32 = *(*uintptr)(unsafe.Pointer(v33))
			*(*uintptr)(unsafe.Pointer(v33))++
			*(*uint8)(unsafe.Pointer(v32)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v34 = delta1
				v35 = envPtr2
				if v34 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v35)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v35)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v35)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v35)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v35 + 64)) += int64(v34)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v37 = envPtr2 + 152
			v36 = *(*uintptr)(unsafe.Pointer(v37))
			*(*uintptr)(unsafe.Pointer(v37))++
			*(*uint8)(unsafe.Pointer(v36)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v39 = envPtr2 + 152
			v38 = *(*uintptr)(unsafe.Pointer(v39))
			*(*uintptr)(unsafe.Pointer(v39))++
			*(*uint8)(unsafe.Pointer(v38)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
			v41 = envPtr2 + 152
			v40 = *(*uintptr)(unsafe.Pointer(v41))
			*(*uintptr)(unsafe.Pointer(v41))++
			*(*uint8)(unsafe.Pointer(v40)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
			v43 = envPtr2 + 152
			v42 = *(*uintptr)(unsafe.Pointer(v43))
			*(*uintptr)(unsafe.Pointer(v43))++
			*(*uint8)(unsafe.Pointer(v42)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
			v45 = envPtr2 + 152
			v44 = *(*uintptr)(unsafe.Pointer(v45))
			*(*uintptr)(unsafe.Pointer(v45))++
			*(*uint8)(unsafe.Pointer(v44)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v46 = delta1
				v47 = envPtr2
				if v46 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v47)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v47)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v47)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v47)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v47 + 64)) += int64(v46)
			}
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1*8)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1*8)))).Flength
			v48 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1*8)))).Fbytes
		} else {
			v48 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1*8)), bp+16)
		}
		bytes = v48
		_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, bytes, *(*TTcl_Size)(unsafe.Pointer(bp + 16)), 0)
		if _objIndexCopy2 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v50 = envPtr2 + 152
			v49 = *(*uintptr)(unsafe.Pointer(v50))
			*(*uintptr)(unsafe.Pointer(v50))++
			*(*uint8)(unsafe.Pointer(v49)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v52 = envPtr2 + 152
			v51 = *(*uintptr)(unsafe.Pointer(v52))
			*(*uintptr)(unsafe.Pointer(v52))++
			*(*uint8)(unsafe.Pointer(v51)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v53 = delta1
				v54 = envPtr2
				if v53 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v54)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v54)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v54)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v54)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v54 + 64)) += int64(v53)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v56 = envPtr2 + 152
			v55 = *(*uintptr)(unsafe.Pointer(v56))
			*(*uintptr)(unsafe.Pointer(v56))++
			*(*uint8)(unsafe.Pointer(v55)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v58 = envPtr2 + 152
			v57 = *(*uintptr)(unsafe.Pointer(v58))
			*(*uintptr)(unsafe.Pointer(v58))++
			*(*uint8)(unsafe.Pointer(v57)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
			v60 = envPtr2 + 152
			v59 = *(*uintptr)(unsafe.Pointer(v60))
			*(*uintptr)(unsafe.Pointer(v60))++
			*(*uint8)(unsafe.Pointer(v59)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
			v62 = envPtr2 + 152
			v61 = *(*uintptr)(unsafe.Pointer(v62))
			*(*uintptr)(unsafe.Pointer(v62))++
			*(*uint8)(unsafe.Pointer(v61)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
			v64 = envPtr2 + 152
			v63 = *(*uintptr)(unsafe.Pointer(v64))
			*(*uintptr)(unsafe.Pointer(v64))++
			*(*uint8)(unsafe.Pointer(v63)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v65 = delta1
				v66 = envPtr2
				if v65 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v66)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v66)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v66)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v66)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v66 + 64)) += int64(v65)
			}
		}
		if (*TTcl_Token)(unsafe.Pointer(stringTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy3 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(stringTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(stringTokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy3 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v68 = envPtr2 + 152
				v67 = *(*uintptr)(unsafe.Pointer(v68))
				*(*uintptr)(unsafe.Pointer(v68))++
				*(*uint8)(unsafe.Pointer(v67)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v70 = envPtr2 + 152
				v69 = *(*uintptr)(unsafe.Pointer(v70))
				*(*uintptr)(unsafe.Pointer(v70))++
				*(*uint8)(unsafe.Pointer(v69)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy3
					}
					v71 = delta1
					v72 = envPtr2
					if v71 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v72)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v72)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v72)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v72)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v72 + 64)) += int64(v71)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v74 = envPtr2 + 152
				v73 = *(*uintptr)(unsafe.Pointer(v74))
				*(*uintptr)(unsafe.Pointer(v74))++
				*(*uint8)(unsafe.Pointer(v73)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v76 = envPtr2 + 152
				v75 = *(*uintptr)(unsafe.Pointer(v76))
				*(*uintptr)(unsafe.Pointer(v76))++
				*(*uint8)(unsafe.Pointer(v75)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(24))
				v78 = envPtr2 + 152
				v77 = *(*uintptr)(unsafe.Pointer(v78))
				*(*uintptr)(unsafe.Pointer(v78))++
				*(*uint8)(unsafe.Pointer(v77)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(16))
				v80 = envPtr2 + 152
				v79 = *(*uintptr)(unsafe.Pointer(v80))
				*(*uintptr)(unsafe.Pointer(v80))++
				*(*uint8)(unsafe.Pointer(v79)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(8))
				v82 = envPtr2 + 152
				v81 = *(*uintptr)(unsafe.Pointer(v82))
				*(*uintptr)(unsafe.Pointer(v82))++
				*(*uint8)(unsafe.Pointer(v81)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy3
					}
					v83 = delta1
					v84 = envPtr2
					if v83 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v84)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v84)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v84)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v84)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v84 + 64)) += int64(v83)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
			XTclCompileTokens(tls, interp, stringTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(stringTokenPtr)).FnumComponents), envPtr2)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v86 = envPtr2 + 152
		v85 = *(*uintptr)(unsafe.Pointer(v86))
		*(*uintptr)(unsafe.Pointer(v86))++
		*(*uint8)(unsafe.Pointer(v85)) = libc.Uint8FromInt32(int32(INST_STR_MAP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STR_MAP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v87 = delta1
			v88 = envPtr2
			if v87 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v88)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v88)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v88)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v88)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v88 + 64)) += int64(v87)
		}
	}
	_objPtr3 = mapObj
	v90 = _objPtr3
	v89 = *(*TTcl_Size)(unsafe.Pointer(v90))
	*(*TTcl_Size)(unsafe.Pointer(v90))--
	if v89 <= int64(1) {
		XTclFreeObj(tls, _objPtr3)
	}
	return TCL_OK
}

func XTclCompileStringRangeCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy975 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, _objIndexCopy4, delta1, v105, v117, v121, v17, v21, v27, v39, v43, v49, v5, v61, v73, v87, v99 int32
	var eclIndex TTcl_Size
	var fromTokenPtr, mapPtr, stringTokenPtr, toTokenPtr, v1, v10, v100, v101, v102, v103, v104, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v118, v119, v12, v120, v122, v13, v14, v15, v16, v18, v19, v2, v20, v22, v23, v24, v25, v26, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v4, v40, v41, v42, v44, v45, v46, v47, v48, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v88, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98 uintptr
	var _ /* idx1 at bp+0 */ int32
	var _ /* idx2 at bp+4 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, _objIndexCopy4, delta1, eclIndex, fromTokenPtr, mapPtr, stringTokenPtr, toTokenPtr, v1, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(4) {
		return int32(TCL_ERROR)
	}
	stringTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	fromTokenPtr = stringTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(stringTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	toTokenPtr = fromTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(fromTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	/* Every path must push the string argument */
	if (*TTcl_Token)(unsafe.Pointer(stringTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(stringTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(stringTokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, stringTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(stringTokenPtr)).FnumComponents), envPtr2)
	}
	/*
	 * Parse the two indices.
	 */
	if XTclGetIndexFromToken(tls, fromTokenPtr, libc.Uint64FromInt64(libc.Int64FromInt32(0)), libc.Uint64FromInt64(int64(-libc.Int32FromInt32(1))), bp) != TCL_OK {
		goto nonConstantIndices
	}
	/*
	 * Token parsed as an index expression. We treat all indices before
	 * the string the same as the start of the string.
	 */
	if *(*int32)(unsafe.Pointer(bp)) == int32(int64(-libc.Int32FromInt32(1))) {
		/* [string range $s end+1 $last] must be empty string */
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v20 = envPtr2 + 152
		v19 = *(*uintptr)(unsafe.Pointer(v20))
		*(*uintptr)(unsafe.Pointer(v20))++
		*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v21 = delta1
			v22 = envPtr2
			if v21 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v22 + 64)) += int64(v21)
		}
		_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy1 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v24 = envPtr2 + 152
			v23 = *(*uintptr)(unsafe.Pointer(v24))
			*(*uintptr)(unsafe.Pointer(v24))++
			*(*uint8)(unsafe.Pointer(v23)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v26 = envPtr2 + 152
			v25 = *(*uintptr)(unsafe.Pointer(v26))
			*(*uintptr)(unsafe.Pointer(v26))++
			*(*uint8)(unsafe.Pointer(v25)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v27 = delta1
				v28 = envPtr2
				if v27 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v28)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v28)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v28)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v28)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v28 + 64)) += int64(v27)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v30 = envPtr2 + 152
			v29 = *(*uintptr)(unsafe.Pointer(v30))
			*(*uintptr)(unsafe.Pointer(v30))++
			*(*uint8)(unsafe.Pointer(v29)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v32 = envPtr2 + 152
			v31 = *(*uintptr)(unsafe.Pointer(v32))
			*(*uintptr)(unsafe.Pointer(v32))++
			*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
			v34 = envPtr2 + 152
			v33 = *(*uintptr)(unsafe.Pointer(v34))
			*(*uintptr)(unsafe.Pointer(v34))++
			*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
			v36 = envPtr2 + 152
			v35 = *(*uintptr)(unsafe.Pointer(v36))
			*(*uintptr)(unsafe.Pointer(v36))++
			*(*uint8)(unsafe.Pointer(v35)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
			v38 = envPtr2 + 152
			v37 = *(*uintptr)(unsafe.Pointer(v38))
			*(*uintptr)(unsafe.Pointer(v38))++
			*(*uint8)(unsafe.Pointer(v37)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v39 = delta1
				v40 = envPtr2
				if v39 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v40 + 64)) += int64(v39)
			}
		}
		return TCL_OK
	}
	if XTclGetIndexFromToken(tls, toTokenPtr, libc.Uint64FromInt64(int64(-libc.Int32FromInt32(1))), libc.Uint64FromInt64(int64(-libc.Int32FromInt32(2))), bp+4) != TCL_OK {
		goto nonConstantIndices
	}
	/*
	 * Token parsed as an index expression. We treat all indices after
	 * the string the same as the end of the string.
	 */
	if *(*int32)(unsafe.Pointer(bp + 4)) == int32(int64(-libc.Int32FromInt32(1))) {
		/* [string range $s $first -1] must be empty string */
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v42 = envPtr2 + 152
		v41 = *(*uintptr)(unsafe.Pointer(v42))
		*(*uintptr)(unsafe.Pointer(v42))++
		*(*uint8)(unsafe.Pointer(v41)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v43 = delta1
			v44 = envPtr2
			if v43 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v44)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v44)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v44)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v44)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v44 + 64)) += int64(v43)
		}
		_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy2 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v46 = envPtr2 + 152
			v45 = *(*uintptr)(unsafe.Pointer(v46))
			*(*uintptr)(unsafe.Pointer(v46))++
			*(*uint8)(unsafe.Pointer(v45)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v48 = envPtr2 + 152
			v47 = *(*uintptr)(unsafe.Pointer(v48))
			*(*uintptr)(unsafe.Pointer(v48))++
			*(*uint8)(unsafe.Pointer(v47)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v49 = delta1
				v50 = envPtr2
				if v49 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v50)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v50)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v50)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v50)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v50 + 64)) += int64(v49)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v52 = envPtr2 + 152
			v51 = *(*uintptr)(unsafe.Pointer(v52))
			*(*uintptr)(unsafe.Pointer(v52))++
			*(*uint8)(unsafe.Pointer(v51)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v54 = envPtr2 + 152
			v53 = *(*uintptr)(unsafe.Pointer(v54))
			*(*uintptr)(unsafe.Pointer(v54))++
			*(*uint8)(unsafe.Pointer(v53)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
			v56 = envPtr2 + 152
			v55 = *(*uintptr)(unsafe.Pointer(v56))
			*(*uintptr)(unsafe.Pointer(v56))++
			*(*uint8)(unsafe.Pointer(v55)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
			v58 = envPtr2 + 152
			v57 = *(*uintptr)(unsafe.Pointer(v58))
			*(*uintptr)(unsafe.Pointer(v58))++
			*(*uint8)(unsafe.Pointer(v57)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
			v60 = envPtr2 + 152
			v59 = *(*uintptr)(unsafe.Pointer(v60))
			*(*uintptr)(unsafe.Pointer(v60))++
			*(*uint8)(unsafe.Pointer(v59)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v61 = delta1
				v62 = envPtr2
				if v61 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v62)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v62)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v62)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v62)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v62 + 64)) += int64(v61)
			}
		}
		return TCL_OK
	}
	/*
	 * Push the operand onto the stack and then the substring operation.
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v64 = envPtr2 + 152
	v63 = *(*uintptr)(unsafe.Pointer(v64))
	*(*uintptr)(unsafe.Pointer(v64))++
	*(*uint8)(unsafe.Pointer(v63)) = libc.Uint8FromInt32(int32(INST_STR_RANGE_IMM))
	v66 = envPtr2 + 152
	v65 = *(*uintptr)(unsafe.Pointer(v66))
	*(*uintptr)(unsafe.Pointer(v66))++
	*(*uint8)(unsafe.Pointer(v65)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))) >> libc.Int32FromInt32(24))
	v68 = envPtr2 + 152
	v67 = *(*uintptr)(unsafe.Pointer(v68))
	*(*uintptr)(unsafe.Pointer(v68))++
	*(*uint8)(unsafe.Pointer(v67)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))) >> libc.Int32FromInt32(16))
	v70 = envPtr2 + 152
	v69 = *(*uintptr)(unsafe.Pointer(v70))
	*(*uintptr)(unsafe.Pointer(v70))++
	*(*uint8)(unsafe.Pointer(v69)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))) >> libc.Int32FromInt32(8))
	v72 = envPtr2 + 152
	v71 = *(*uintptr)(unsafe.Pointer(v72))
	*(*uintptr)(unsafe.Pointer(v72))++
	*(*uint8)(unsafe.Pointer(v71)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_STR_RANGE_IMM)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - *(*int32)(unsafe.Pointer(bp))
		}
		v73 = delta1
		v74 = envPtr2
		if v73 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v74)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v74)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v74)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v74)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v74 + 64)) += int64(v73)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v76 = envPtr2 + 152
	v75 = *(*uintptr)(unsafe.Pointer(v76))
	*(*uintptr)(unsafe.Pointer(v76))++
	*(*uint8)(unsafe.Pointer(v75)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(24))
	v78 = envPtr2 + 152
	v77 = *(*uintptr)(unsafe.Pointer(v78))
	*(*uintptr)(unsafe.Pointer(v78))++
	*(*uint8)(unsafe.Pointer(v77)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(16))
	v80 = envPtr2 + 152
	v79 = *(*uintptr)(unsafe.Pointer(v80))
	*(*uintptr)(unsafe.Pointer(v80))++
	*(*uint8)(unsafe.Pointer(v79)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(8))
	v82 = envPtr2 + 152
	v81 = *(*uintptr)(unsafe.Pointer(v82))
	*(*uintptr)(unsafe.Pointer(v82))++
	*(*uint8)(unsafe.Pointer(v81)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
	return TCL_OK
	/*
	 * Push the operands onto the stack and then the substring operation.
	 */
	goto nonConstantIndices
nonConstantIndices:
	;
	if (*TTcl_Token)(unsafe.Pointer(fromTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy3 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(fromTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(fromTokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy3 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v84 = envPtr2 + 152
			v83 = *(*uintptr)(unsafe.Pointer(v84))
			*(*uintptr)(unsafe.Pointer(v84))++
			*(*uint8)(unsafe.Pointer(v83)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v86 = envPtr2 + 152
			v85 = *(*uintptr)(unsafe.Pointer(v86))
			*(*uintptr)(unsafe.Pointer(v86))++
			*(*uint8)(unsafe.Pointer(v85)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy3
				}
				v87 = delta1
				v88 = envPtr2
				if v87 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v88)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v88)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v88)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v88)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v88 + 64)) += int64(v87)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v90 = envPtr2 + 152
			v89 = *(*uintptr)(unsafe.Pointer(v90))
			*(*uintptr)(unsafe.Pointer(v90))++
			*(*uint8)(unsafe.Pointer(v89)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v92 = envPtr2 + 152
			v91 = *(*uintptr)(unsafe.Pointer(v92))
			*(*uintptr)(unsafe.Pointer(v92))++
			*(*uint8)(unsafe.Pointer(v91)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(24))
			v94 = envPtr2 + 152
			v93 = *(*uintptr)(unsafe.Pointer(v94))
			*(*uintptr)(unsafe.Pointer(v94))++
			*(*uint8)(unsafe.Pointer(v93)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(16))
			v96 = envPtr2 + 152
			v95 = *(*uintptr)(unsafe.Pointer(v96))
			*(*uintptr)(unsafe.Pointer(v96))++
			*(*uint8)(unsafe.Pointer(v95)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(8))
			v98 = envPtr2 + 152
			v97 = *(*uintptr)(unsafe.Pointer(v98))
			*(*uintptr)(unsafe.Pointer(v98))++
			*(*uint8)(unsafe.Pointer(v97)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy3
				}
				v99 = delta1
				v100 = envPtr2
				if v99 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v100)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v100)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v100)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v100)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v100 + 64)) += int64(v99)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
		XTclCompileTokens(tls, interp, fromTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(fromTokenPtr)).FnumComponents), envPtr2)
	}
	if (*TTcl_Token)(unsafe.Pointer(toTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy4 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(toTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(toTokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy4 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v102 = envPtr2 + 152
			v101 = *(*uintptr)(unsafe.Pointer(v102))
			*(*uintptr)(unsafe.Pointer(v102))++
			*(*uint8)(unsafe.Pointer(v101)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v104 = envPtr2 + 152
			v103 = *(*uintptr)(unsafe.Pointer(v104))
			*(*uintptr)(unsafe.Pointer(v104))++
			*(*uint8)(unsafe.Pointer(v103)) = uint8(libc.Uint32FromInt32(_objIndexCopy4))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy4
				}
				v105 = delta1
				v106 = envPtr2
				if v105 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v106)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v106)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v106)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v106)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v106 + 64)) += int64(v105)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v108 = envPtr2 + 152
			v107 = *(*uintptr)(unsafe.Pointer(v108))
			*(*uintptr)(unsafe.Pointer(v108))++
			*(*uint8)(unsafe.Pointer(v107)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v110 = envPtr2 + 152
			v109 = *(*uintptr)(unsafe.Pointer(v110))
			*(*uintptr)(unsafe.Pointer(v110))++
			*(*uint8)(unsafe.Pointer(v109)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(24))
			v112 = envPtr2 + 152
			v111 = *(*uintptr)(unsafe.Pointer(v112))
			*(*uintptr)(unsafe.Pointer(v112))++
			*(*uint8)(unsafe.Pointer(v111)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(16))
			v114 = envPtr2 + 152
			v113 = *(*uintptr)(unsafe.Pointer(v114))
			*(*uintptr)(unsafe.Pointer(v114))++
			*(*uint8)(unsafe.Pointer(v113)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(8))
			v116 = envPtr2 + 152
			v115 = *(*uintptr)(unsafe.Pointer(v116))
			*(*uintptr)(unsafe.Pointer(v116))++
			*(*uint8)(unsafe.Pointer(v115)) = uint8(libc.Uint32FromInt32(_objIndexCopy4))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy4
				}
				v117 = delta1
				v118 = envPtr2
				if v117 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v118)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v118)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v118)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v118)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v118 + 64)) += int64(v117)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 3*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 3*8))
		XTclCompileTokens(tls, interp, toTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(toTokenPtr)).FnumComponents), envPtr2)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v120 = envPtr2 + 152
	v119 = *(*uintptr)(unsafe.Pointer(v120))
	*(*uintptr)(unsafe.Pointer(v120))++
	*(*uint8)(unsafe.Pointer(v119)) = libc.Uint8FromInt32(int32(INST_STR_RANGE))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_STR_RANGE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v121 = delta1
		v122 = envPtr2
		if v121 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v122)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v122)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v122)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v122)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v122 + 64)) += int64(v121)
	}
	return TCL_OK
}

func XTclCompileStringReplaceCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy1050 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds the resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, _objIndexCopy4, _objIndexCopy5, _objIndexCopy6, _objIndexCopy7, _objIndexCopy8, delta1, v111, v125, v137, v143, v147, v153, v165, v17, v177, v197, v209, v221, v23, v241, v253, v267, v273, v285, v291, v303, v309, v321, v327, v339, v343, v35, v39, v45, v5, v57, v69, v73, v85, v99 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, valueTokenPtr, v1, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v123, v124, v126, v127, v128, v129, v13, v130, v131, v132, v133, v134, v135, v136, v138, v139, v14, v140, v141, v142, v144, v145, v146, v148, v149, v15, v150, v151, v152, v154, v155, v156, v157, v158, v159, v16, v160, v161, v162, v163, v164, v166, v167, v168, v169, v170, v171, v172, v173, v174, v175, v176, v178, v179, v18, v180, v181, v182, v183, v184, v185, v186, v187, v188, v189, v19, v190, v191, v192, v193, v194, v195, v196, v198, v199, v2, v20, v200, v201, v202, v203, v204, v205, v206, v207, v208, v21, v210, v211, v212, v213, v214, v215, v216, v217, v218, v219, v22, v220, v222, v223, v224, v225, v226, v227, v228, v229, v230, v231, v232, v233, v234, v235, v236, v237, v238, v239, v24, v240, v242, v243, v244, v245, v246, v247, v248, v249, v25, v250, v251, v252, v254, v255, v256, v257, v258, v259, v26, v260, v261, v262, v263, v264, v265, v266, v268, v269, v27, v270, v271, v272, v274, v275, v276, v277, v278, v279, v28, v280, v281, v282, v283, v284, v286, v287, v288, v289, v29, v290, v292, v293, v294, v295, v296, v297, v298, v299, v3, v30, v300, v301, v302, v304, v305, v306, v307, v308, v31, v310, v311, v312, v313, v314, v315, v316, v317, v318, v319, v32, v320, v322, v323, v324, v325, v326, v328, v329, v33, v330, v331, v332, v333, v334, v335, v336, v337, v338, v34, v340, v341, v342, v344, v36, v37, v38, v4, v40, v41, v42, v43, v44, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v7, v70, v71, v72, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98 uintptr
	var _ /* first at bp+0 */ int32
	var _ /* last at bp+4 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, _objIndexCopy4, _objIndexCopy5, _objIndexCopy6, _objIndexCopy7, _objIndexCopy8, delta1, eclIndex, mapPtr, tokenPtr, valueTokenPtr, v1, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v123, v124, v125, v126, v127, v128, v129, v13, v130, v131, v132, v133, v134, v135, v136, v137, v138, v139, v14, v140, v141, v142, v143, v144, v145, v146, v147, v148, v149, v15, v150, v151, v152, v153, v154, v155, v156, v157, v158, v159, v16, v160, v161, v162, v163, v164, v165, v166, v167, v168, v169, v17, v170, v171, v172, v173, v174, v175, v176, v177, v178, v179, v18, v180, v181, v182, v183, v184, v185, v186, v187, v188, v189, v19, v190, v191, v192, v193, v194, v195, v196, v197, v198, v199, v2, v20, v200, v201, v202, v203, v204, v205, v206, v207, v208, v209, v21, v210, v211, v212, v213, v214, v215, v216, v217, v218, v219, v22, v220, v221, v222, v223, v224, v225, v226, v227, v228, v229, v23, v230, v231, v232, v233, v234, v235, v236, v237, v238, v239, v24, v240, v241, v242, v243, v244, v245, v246, v247, v248, v249, v25, v250, v251, v252, v253, v254, v255, v256, v257, v258, v259, v26, v260, v261, v262, v263, v264, v265, v266, v267, v268, v269, v27, v270, v271, v272, v273, v274, v275, v276, v277, v278, v279, v28, v280, v281, v282, v283, v284, v285, v286, v287, v288, v289, v29, v290, v291, v292, v293, v294, v295, v296, v297, v298, v299, v3, v30, v300, v301, v302, v303, v304, v305, v306, v307, v308, v309, v31, v310, v311, v312, v313, v314, v315, v316, v317, v318, v319, v32, v320, v321, v322, v323, v324, v325, v326, v327, v328, v329, v33, v330, v331, v332, v333, v334, v335, v336, v337, v338, v339, v34, v340, v341, v342, v343, v344, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) < int32(4) || int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) > int32(5) {
		return int32(TCL_ERROR)
	}
	/* Bytecode to compute/push string argument being replaced */
	valueTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(valueTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(valueTokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, valueTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).FnumComponents), envPtr2)
	}
	/*
	 * Check for first index known and useful at compile time.
	 */
	tokenPtr = valueTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if XTclGetIndexFromToken(tls, tokenPtr, libc.Uint64FromInt64(libc.Int64FromInt32(0)), libc.Uint64FromInt64(int64(-libc.Int32FromInt32(1))), bp) != TCL_OK {
		goto genericReplace
	}
	/*
	 * Check for last index known and useful at compile time.
	 */
	tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if XTclGetIndexFromToken(tls, tokenPtr, libc.Uint64FromInt64(int64(-libc.Int32FromInt32(1))), libc.Uint64FromInt64(int64(-libc.Int32FromInt32(2))), bp+4) != TCL_OK {
		goto genericReplace
	}
	/*
	 * [string replace] is an odd bird.  For many arguments it is
	 * a conventional substring replacer.  However it also goes out
	 * of its way to become a no-op for many cases where it would be
	 * replacing an empty substring.  Precisely, it is a no-op when
	 *
	 *		(last < first)		OR
	 *		(last < 0)		OR
	 *		(end < first)
	 *
	 * For some compile-time values we can detect these cases, and
	 * compile direct to bytecode implementing the no-op.
	 */
	if *(*int32)(unsafe.Pointer(bp + 4)) == int32(int64(-libc.Int32FromInt32(1))) || *(*int32)(unsafe.Pointer(bp)) == int32(int64(-libc.Int32FromInt32(1))) || *(*int32)(unsafe.Pointer(bp)) <= int32(int64(-libc.Int32FromInt32(2))) && *(*int32)(unsafe.Pointer(bp + 4)) <= int32(int64(-libc.Int32FromInt32(2))) && *(*int32)(unsafe.Pointer(bp + 4)) < *(*int32)(unsafe.Pointer(bp)) || *(*int32)(unsafe.Pointer(bp)) >= int32(libc.Int64FromInt32(0)) && *(*int32)(unsafe.Pointer(bp + 4)) >= int32(libc.Int64FromInt32(0)) && *(*int32)(unsafe.Pointer(bp + 4)) < *(*int32)(unsafe.Pointer(bp)) { /* Know (last < first) */
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(5) {
			tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
			if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
				_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
				if _objIndexCopy1 <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v20 = envPtr2 + 152
					v19 = *(*uintptr)(unsafe.Pointer(v20))
					*(*uintptr)(unsafe.Pointer(v20))++
					*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_PUSH1))
					v22 = envPtr2 + 152
					v21 = *(*uintptr)(unsafe.Pointer(v22))
					*(*uintptr)(unsafe.Pointer(v22))++
					*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy1
						}
						v23 = delta1
						v24 = envPtr2
						if v23 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v24 + 64)) += int64(v23)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v26 = envPtr2 + 152
					v25 = *(*uintptr)(unsafe.Pointer(v26))
					*(*uintptr)(unsafe.Pointer(v26))++
					*(*uint8)(unsafe.Pointer(v25)) = libc.Uint8FromInt32(int32(INST_PUSH4))
					v28 = envPtr2 + 152
					v27 = *(*uintptr)(unsafe.Pointer(v28))
					*(*uintptr)(unsafe.Pointer(v28))++
					*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
					v30 = envPtr2 + 152
					v29 = *(*uintptr)(unsafe.Pointer(v30))
					*(*uintptr)(unsafe.Pointer(v30))++
					*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
					v32 = envPtr2 + 152
					v31 = *(*uintptr)(unsafe.Pointer(v32))
					*(*uintptr)(unsafe.Pointer(v32))++
					*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
					v34 = envPtr2 + 152
					v33 = *(*uintptr)(unsafe.Pointer(v34))
					*(*uintptr)(unsafe.Pointer(v34))++
					*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy1
						}
						v35 = delta1
						v36 = envPtr2
						if v35 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v36 + 64)) += int64(v35)
					}
				}
			} else {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 4*8))
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 4*8))
				XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v38 = envPtr2 + 152
			v37 = *(*uintptr)(unsafe.Pointer(v38))
			*(*uintptr)(unsafe.Pointer(v38))++
			*(*uint8)(unsafe.Pointer(v37)) = libc.Uint8FromInt32(int32(INST_POP))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v39 = delta1
				v40 = envPtr2
				if v39 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v40 + 64)) += int64(v39)
			} /* Pop newString */
		}
		/* Original string argument now on TOS as result */
		return TCL_OK
	}
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(5) {
		/*
		 * When we have a string replacement, we have to take care about
		 * not replacing empty substrings that [string replace] promises
		 * not to replace
		 *
		 * The remaining index values might be suitable for conventional
		 * string replacement, but only if they cannot possibly meet the
		 * conditions described above at runtime. If there's a chance they
		 * might, we would have to emit bytecode to check and at that point
		 * we're paying more in bytecode execution time than would make
		 * things worthwhile. Trouble is we are very limited in
		 * how much we can detect that at compile time. After decoding,
		 * we need, first:
		 *
		 *		(first <= end)
		 *
		 * The encoded indices (first <= TCL_INDEX END) and
		 * (first == TCL_INDEX_NONE) always meets this condition, but
		 * any other encoded first index has some list for which it fails.
		 *
		 * We also need, second:
		 *
		 *		(last >= 0)
		 *
		 * The encoded index (last >= TCL_INDEX_START) always meet this
		 * condition but any other encoded last index has some list for
		 * which it fails.
		 *
		 * Finally we need, third:
		 *
		 *		(first <= last)
		 *
		 * Considered in combination with the constraints we already have,
		 * we see that we can proceed when (first == TCL_INDEX_NONE).
		 * These also permit simplification of the prefix|replace|suffix
		 * construction. The other constraints, though, interfere with
		 * getting a guarantee that first <= last.
		 */
		if *(*int32)(unsafe.Pointer(bp)) == int32(libc.Int64FromInt32(0)) && *(*int32)(unsafe.Pointer(bp + 4)) >= int32(libc.Int64FromInt32(0)) {
			/* empty prefix */
			tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
			if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
				_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
				if _objIndexCopy2 <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v42 = envPtr2 + 152
					v41 = *(*uintptr)(unsafe.Pointer(v42))
					*(*uintptr)(unsafe.Pointer(v42))++
					*(*uint8)(unsafe.Pointer(v41)) = libc.Uint8FromInt32(int32(INST_PUSH1))
					v44 = envPtr2 + 152
					v43 = *(*uintptr)(unsafe.Pointer(v44))
					*(*uintptr)(unsafe.Pointer(v44))++
					*(*uint8)(unsafe.Pointer(v43)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy2
						}
						v45 = delta1
						v46 = envPtr2
						if v45 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v46)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v46)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v46)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v46)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v46 + 64)) += int64(v45)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v48 = envPtr2 + 152
					v47 = *(*uintptr)(unsafe.Pointer(v48))
					*(*uintptr)(unsafe.Pointer(v48))++
					*(*uint8)(unsafe.Pointer(v47)) = libc.Uint8FromInt32(int32(INST_PUSH4))
					v50 = envPtr2 + 152
					v49 = *(*uintptr)(unsafe.Pointer(v50))
					*(*uintptr)(unsafe.Pointer(v50))++
					*(*uint8)(unsafe.Pointer(v49)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
					v52 = envPtr2 + 152
					v51 = *(*uintptr)(unsafe.Pointer(v52))
					*(*uintptr)(unsafe.Pointer(v52))++
					*(*uint8)(unsafe.Pointer(v51)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
					v54 = envPtr2 + 152
					v53 = *(*uintptr)(unsafe.Pointer(v54))
					*(*uintptr)(unsafe.Pointer(v54))++
					*(*uint8)(unsafe.Pointer(v53)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
					v56 = envPtr2 + 152
					v55 = *(*uintptr)(unsafe.Pointer(v56))
					*(*uintptr)(unsafe.Pointer(v56))++
					*(*uint8)(unsafe.Pointer(v55)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy2
						}
						v57 = delta1
						v58 = envPtr2
						if v57 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v58)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v58)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v58)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v58)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v58 + 64)) += int64(v57)
					}
				}
			} else {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 4*8))
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 4*8))
				XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v60 = envPtr2 + 152
			v59 = *(*uintptr)(unsafe.Pointer(v60))
			*(*uintptr)(unsafe.Pointer(v60))++
			*(*uint8)(unsafe.Pointer(v59)) = libc.Uint8FromInt32(int32(INST_REVERSE))
			v62 = envPtr2 + 152
			v61 = *(*uintptr)(unsafe.Pointer(v62))
			*(*uintptr)(unsafe.Pointer(v62))++
			*(*uint8)(unsafe.Pointer(v61)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
			v64 = envPtr2 + 152
			v63 = *(*uintptr)(unsafe.Pointer(v64))
			*(*uintptr)(unsafe.Pointer(v64))++
			*(*uint8)(unsafe.Pointer(v63)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
			v66 = envPtr2 + 152
			v65 = *(*uintptr)(unsafe.Pointer(v66))
			*(*uintptr)(unsafe.Pointer(v66))++
			*(*uint8)(unsafe.Pointer(v65)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
			v68 = envPtr2 + 152
			v67 = *(*uintptr)(unsafe.Pointer(v68))
			*(*uintptr)(unsafe.Pointer(v68))++
			*(*uint8)(unsafe.Pointer(v67)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - int32(2)
				}
				v69 = delta1
				v70 = envPtr2
				if v69 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v70 + 64)) += int64(v69)
			}
			if *(*int32)(unsafe.Pointer(bp + 4)) == int32(INT_MAX) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v72 = envPtr2 + 152
				v71 = *(*uintptr)(unsafe.Pointer(v72))
				*(*uintptr)(unsafe.Pointer(v72))++
				*(*uint8)(unsafe.Pointer(v71)) = libc.Uint8FromInt32(int32(INST_POP))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v73 = delta1
					v74 = envPtr2
					if v73 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v74)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v74)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v74)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v74)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v74 + 64)) += int64(v73)
				} /* Pop  original */
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v76 = envPtr2 + 152
				v75 = *(*uintptr)(unsafe.Pointer(v76))
				*(*uintptr)(unsafe.Pointer(v76))++
				*(*uint8)(unsafe.Pointer(v75)) = libc.Uint8FromInt32(int32(INST_STR_RANGE_IMM))
				v78 = envPtr2 + 152
				v77 = *(*uintptr)(unsafe.Pointer(v78))
				*(*uintptr)(unsafe.Pointer(v78))++
				*(*uint8)(unsafe.Pointer(v77)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))+libc.Int32FromInt32(1)) >> libc.Int32FromInt32(24))
				v80 = envPtr2 + 152
				v79 = *(*uintptr)(unsafe.Pointer(v80))
				*(*uintptr)(unsafe.Pointer(v80))++
				*(*uint8)(unsafe.Pointer(v79)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))+libc.Int32FromInt32(1)) >> libc.Int32FromInt32(16))
				v82 = envPtr2 + 152
				v81 = *(*uintptr)(unsafe.Pointer(v82))
				*(*uintptr)(unsafe.Pointer(v82))++
				*(*uint8)(unsafe.Pointer(v81)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))+libc.Int32FromInt32(1)) >> libc.Int32FromInt32(8))
				v84 = envPtr2 + 152
				v83 = *(*uintptr)(unsafe.Pointer(v84))
				*(*uintptr)(unsafe.Pointer(v84))++
				*(*uint8)(unsafe.Pointer(v83)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4)) + libc.Int32FromInt32(1)))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_STR_RANGE_IMM)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - (*(*int32)(unsafe.Pointer(bp + 4)) + int32(1))
					}
					v85 = delta1
					v86 = envPtr2
					if v85 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v86)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v86)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v86)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v86)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v86 + 64)) += int64(v85)
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v88 = envPtr2 + 152
				v87 = *(*uintptr)(unsafe.Pointer(v88))
				*(*uintptr)(unsafe.Pointer(v88))++
				*(*uint8)(unsafe.Pointer(v87)) = uint8(libc.Uint32FromInt32(int32(int64(-libc.Int32FromInt32(2)))) >> libc.Int32FromInt32(24))
				v90 = envPtr2 + 152
				v89 = *(*uintptr)(unsafe.Pointer(v90))
				*(*uintptr)(unsafe.Pointer(v90))++
				*(*uint8)(unsafe.Pointer(v89)) = uint8(libc.Uint32FromInt32(int32(int64(-libc.Int32FromInt32(2)))) >> libc.Int32FromInt32(16))
				v92 = envPtr2 + 152
				v91 = *(*uintptr)(unsafe.Pointer(v92))
				*(*uintptr)(unsafe.Pointer(v92))++
				*(*uint8)(unsafe.Pointer(v91)) = uint8(libc.Uint32FromInt32(int32(int64(-libc.Int32FromInt32(2)))) >> libc.Int32FromInt32(8))
				v94 = envPtr2 + 152
				v93 = *(*uintptr)(unsafe.Pointer(v94))
				*(*uintptr)(unsafe.Pointer(v94))++
				*(*uint8)(unsafe.Pointer(v93)) = uint8(libc.Uint32FromInt32(int32(int64(-libc.Int32FromInt32(2)))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v96 = envPtr2 + 152
				v95 = *(*uintptr)(unsafe.Pointer(v96))
				*(*uintptr)(unsafe.Pointer(v96))++
				*(*uint8)(unsafe.Pointer(v95)) = libc.Uint8FromInt32(int32(INST_STR_CONCAT1))
				v98 = envPtr2 + 152
				v97 = *(*uintptr)(unsafe.Pointer(v98))
				*(*uintptr)(unsafe.Pointer(v98))++
				*(*uint8)(unsafe.Pointer(v97)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_STR_CONCAT1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - int32(2)
					}
					v99 = delta1
					v100 = envPtr2
					if v99 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v100)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v100)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v100)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v100)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v100 + 64)) += int64(v99)
				}
			}
			return TCL_OK
		}
		if *(*int32)(unsafe.Pointer(bp + 4)) == int32(int64(-libc.Int32FromInt32(1))) && *(*int32)(unsafe.Pointer(bp)) <= int32(int64(-libc.Int32FromInt32(2))) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v102 = envPtr2 + 152
			v101 = *(*uintptr)(unsafe.Pointer(v102))
			*(*uintptr)(unsafe.Pointer(v102))++
			*(*uint8)(unsafe.Pointer(v101)) = libc.Uint8FromInt32(int32(INST_STR_RANGE_IMM))
			v104 = envPtr2 + 152
			v103 = *(*uintptr)(unsafe.Pointer(v104))
			*(*uintptr)(unsafe.Pointer(v104))++
			*(*uint8)(unsafe.Pointer(v103)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
			v106 = envPtr2 + 152
			v105 = *(*uintptr)(unsafe.Pointer(v106))
			*(*uintptr)(unsafe.Pointer(v106))++
			*(*uint8)(unsafe.Pointer(v105)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
			v108 = envPtr2 + 152
			v107 = *(*uintptr)(unsafe.Pointer(v108))
			*(*uintptr)(unsafe.Pointer(v108))++
			*(*uint8)(unsafe.Pointer(v107)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
			v110 = envPtr2 + 152
			v109 = *(*uintptr)(unsafe.Pointer(v110))
			*(*uintptr)(unsafe.Pointer(v110))++
			*(*uint8)(unsafe.Pointer(v109)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STR_RANGE_IMM)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v111 = delta1
				v112 = envPtr2
				if v111 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v112)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v112)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v112)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v112)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v112 + 64)) += int64(v111)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v114 = envPtr2 + 152
			v113 = *(*uintptr)(unsafe.Pointer(v114))
			*(*uintptr)(unsafe.Pointer(v114))++
			*(*uint8)(unsafe.Pointer(v113)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(24))
			v116 = envPtr2 + 152
			v115 = *(*uintptr)(unsafe.Pointer(v116))
			*(*uintptr)(unsafe.Pointer(v116))++
			*(*uint8)(unsafe.Pointer(v115)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(16))
			v118 = envPtr2 + 152
			v117 = *(*uintptr)(unsafe.Pointer(v118))
			*(*uintptr)(unsafe.Pointer(v118))++
			*(*uint8)(unsafe.Pointer(v117)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(8))
			v120 = envPtr2 + 152
			v119 = *(*uintptr)(unsafe.Pointer(v120))
			*(*uintptr)(unsafe.Pointer(v120))++
			*(*uint8)(unsafe.Pointer(v119)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp)) - libc.Int32FromInt32(1)))
			tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
			if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
				_objIndexCopy3 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
				if _objIndexCopy3 <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v122 = envPtr2 + 152
					v121 = *(*uintptr)(unsafe.Pointer(v122))
					*(*uintptr)(unsafe.Pointer(v122))++
					*(*uint8)(unsafe.Pointer(v121)) = libc.Uint8FromInt32(int32(INST_PUSH1))
					v124 = envPtr2 + 152
					v123 = *(*uintptr)(unsafe.Pointer(v124))
					*(*uintptr)(unsafe.Pointer(v124))++
					*(*uint8)(unsafe.Pointer(v123)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy3
						}
						v125 = delta1
						v126 = envPtr2
						if v125 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v126)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v126)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v126)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v126)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v126 + 64)) += int64(v125)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v128 = envPtr2 + 152
					v127 = *(*uintptr)(unsafe.Pointer(v128))
					*(*uintptr)(unsafe.Pointer(v128))++
					*(*uint8)(unsafe.Pointer(v127)) = libc.Uint8FromInt32(int32(INST_PUSH4))
					v130 = envPtr2 + 152
					v129 = *(*uintptr)(unsafe.Pointer(v130))
					*(*uintptr)(unsafe.Pointer(v130))++
					*(*uint8)(unsafe.Pointer(v129)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(24))
					v132 = envPtr2 + 152
					v131 = *(*uintptr)(unsafe.Pointer(v132))
					*(*uintptr)(unsafe.Pointer(v132))++
					*(*uint8)(unsafe.Pointer(v131)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(16))
					v134 = envPtr2 + 152
					v133 = *(*uintptr)(unsafe.Pointer(v134))
					*(*uintptr)(unsafe.Pointer(v134))++
					*(*uint8)(unsafe.Pointer(v133)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(8))
					v136 = envPtr2 + 152
					v135 = *(*uintptr)(unsafe.Pointer(v136))
					*(*uintptr)(unsafe.Pointer(v136))++
					*(*uint8)(unsafe.Pointer(v135)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy3
						}
						v137 = delta1
						v138 = envPtr2
						if v137 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v138)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v138)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v138)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v138)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v138 + 64)) += int64(v137)
					}
				}
			} else {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 4*8))
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 4*8))
				XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v140 = envPtr2 + 152
			v139 = *(*uintptr)(unsafe.Pointer(v140))
			*(*uintptr)(unsafe.Pointer(v140))++
			*(*uint8)(unsafe.Pointer(v139)) = libc.Uint8FromInt32(int32(INST_STR_CONCAT1))
			v142 = envPtr2 + 152
			v141 = *(*uintptr)(unsafe.Pointer(v142))
			*(*uintptr)(unsafe.Pointer(v142))++
			*(*uint8)(unsafe.Pointer(v141)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STR_CONCAT1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - int32(2)
				}
				v143 = delta1
				v144 = envPtr2
				if v143 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v144)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v144)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v144)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v144)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v144 + 64)) += int64(v143)
			}
			return TCL_OK
		}
		/* FLOW THROUGH TO genericReplace */
	} else {
		/*
		 * When we have no replacement string to worry about, we may
		 * have more luck, because the forbidden empty string replacements
		 * are harmless when they are replaced by another empty string.
		 */
		if *(*int32)(unsafe.Pointer(bp)) == int32(libc.Int64FromInt32(0)) {
			/* empty prefix - build suffix only */
			if *(*int32)(unsafe.Pointer(bp + 4)) == int32(int64(-libc.Int32FromInt32(2))) {
				/* empty suffix too => empty result */
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v146 = envPtr2 + 152
				v145 = *(*uintptr)(unsafe.Pointer(v146))
				*(*uintptr)(unsafe.Pointer(v146))++
				*(*uint8)(unsafe.Pointer(v145)) = libc.Uint8FromInt32(int32(INST_POP))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v147 = delta1
					v148 = envPtr2
					if v147 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v148)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v148)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v148)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v148)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v148 + 64)) += int64(v147)
				} /* Pop  original */
				_objIndexCopy4 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
				if _objIndexCopy4 <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v150 = envPtr2 + 152
					v149 = *(*uintptr)(unsafe.Pointer(v150))
					*(*uintptr)(unsafe.Pointer(v150))++
					*(*uint8)(unsafe.Pointer(v149)) = libc.Uint8FromInt32(int32(INST_PUSH1))
					v152 = envPtr2 + 152
					v151 = *(*uintptr)(unsafe.Pointer(v152))
					*(*uintptr)(unsafe.Pointer(v152))++
					*(*uint8)(unsafe.Pointer(v151)) = uint8(libc.Uint32FromInt32(_objIndexCopy4))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy4
						}
						v153 = delta1
						v154 = envPtr2
						if v153 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v154)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v154)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v154)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v154)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v154 + 64)) += int64(v153)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v156 = envPtr2 + 152
					v155 = *(*uintptr)(unsafe.Pointer(v156))
					*(*uintptr)(unsafe.Pointer(v156))++
					*(*uint8)(unsafe.Pointer(v155)) = libc.Uint8FromInt32(int32(INST_PUSH4))
					v158 = envPtr2 + 152
					v157 = *(*uintptr)(unsafe.Pointer(v158))
					*(*uintptr)(unsafe.Pointer(v158))++
					*(*uint8)(unsafe.Pointer(v157)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(24))
					v160 = envPtr2 + 152
					v159 = *(*uintptr)(unsafe.Pointer(v160))
					*(*uintptr)(unsafe.Pointer(v160))++
					*(*uint8)(unsafe.Pointer(v159)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(16))
					v162 = envPtr2 + 152
					v161 = *(*uintptr)(unsafe.Pointer(v162))
					*(*uintptr)(unsafe.Pointer(v162))++
					*(*uint8)(unsafe.Pointer(v161)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(8))
					v164 = envPtr2 + 152
					v163 = *(*uintptr)(unsafe.Pointer(v164))
					*(*uintptr)(unsafe.Pointer(v164))++
					*(*uint8)(unsafe.Pointer(v163)) = uint8(libc.Uint32FromInt32(_objIndexCopy4))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy4
						}
						v165 = delta1
						v166 = envPtr2
						if v165 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v166)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v166)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v166)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v166)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v166 + 64)) += int64(v165)
					}
				}
				return TCL_OK
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v168 = envPtr2 + 152
			v167 = *(*uintptr)(unsafe.Pointer(v168))
			*(*uintptr)(unsafe.Pointer(v168))++
			*(*uint8)(unsafe.Pointer(v167)) = libc.Uint8FromInt32(int32(INST_STR_RANGE_IMM))
			v170 = envPtr2 + 152
			v169 = *(*uintptr)(unsafe.Pointer(v170))
			*(*uintptr)(unsafe.Pointer(v170))++
			*(*uint8)(unsafe.Pointer(v169)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))+libc.Int32FromInt32(1)) >> libc.Int32FromInt32(24))
			v172 = envPtr2 + 152
			v171 = *(*uintptr)(unsafe.Pointer(v172))
			*(*uintptr)(unsafe.Pointer(v172))++
			*(*uint8)(unsafe.Pointer(v171)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))+libc.Int32FromInt32(1)) >> libc.Int32FromInt32(16))
			v174 = envPtr2 + 152
			v173 = *(*uintptr)(unsafe.Pointer(v174))
			*(*uintptr)(unsafe.Pointer(v174))++
			*(*uint8)(unsafe.Pointer(v173)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))+libc.Int32FromInt32(1)) >> libc.Int32FromInt32(8))
			v176 = envPtr2 + 152
			v175 = *(*uintptr)(unsafe.Pointer(v176))
			*(*uintptr)(unsafe.Pointer(v176))++
			*(*uint8)(unsafe.Pointer(v175)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4)) + libc.Int32FromInt32(1)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STR_RANGE_IMM)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - (*(*int32)(unsafe.Pointer(bp + 4)) + int32(1))
				}
				v177 = delta1
				v178 = envPtr2
				if v177 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v178)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v178)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v178)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v178)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v178 + 64)) += int64(v177)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v180 = envPtr2 + 152
			v179 = *(*uintptr)(unsafe.Pointer(v180))
			*(*uintptr)(unsafe.Pointer(v180))++
			*(*uint8)(unsafe.Pointer(v179)) = uint8(libc.Uint32FromInt32(int32(int64(-libc.Int32FromInt32(2)))) >> libc.Int32FromInt32(24))
			v182 = envPtr2 + 152
			v181 = *(*uintptr)(unsafe.Pointer(v182))
			*(*uintptr)(unsafe.Pointer(v182))++
			*(*uint8)(unsafe.Pointer(v181)) = uint8(libc.Uint32FromInt32(int32(int64(-libc.Int32FromInt32(2)))) >> libc.Int32FromInt32(16))
			v184 = envPtr2 + 152
			v183 = *(*uintptr)(unsafe.Pointer(v184))
			*(*uintptr)(unsafe.Pointer(v184))++
			*(*uint8)(unsafe.Pointer(v183)) = uint8(libc.Uint32FromInt32(int32(int64(-libc.Int32FromInt32(2)))) >> libc.Int32FromInt32(8))
			v186 = envPtr2 + 152
			v185 = *(*uintptr)(unsafe.Pointer(v186))
			*(*uintptr)(unsafe.Pointer(v186))++
			*(*uint8)(unsafe.Pointer(v185)) = uint8(libc.Uint32FromInt32(int32(int64(-libc.Int32FromInt32(2)))))
			return TCL_OK
		} else {
			if *(*int32)(unsafe.Pointer(bp + 4)) == int32(int64(-libc.Int32FromInt32(2))) {
				/* empty suffix - build prefix only */
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v188 = envPtr2 + 152
				v187 = *(*uintptr)(unsafe.Pointer(v188))
				*(*uintptr)(unsafe.Pointer(v188))++
				*(*uint8)(unsafe.Pointer(v187)) = libc.Uint8FromInt32(int32(INST_STR_RANGE_IMM))
				v190 = envPtr2 + 152
				v189 = *(*uintptr)(unsafe.Pointer(v190))
				*(*uintptr)(unsafe.Pointer(v190))++
				*(*uint8)(unsafe.Pointer(v189)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
				v192 = envPtr2 + 152
				v191 = *(*uintptr)(unsafe.Pointer(v192))
				*(*uintptr)(unsafe.Pointer(v192))++
				*(*uint8)(unsafe.Pointer(v191)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
				v194 = envPtr2 + 152
				v193 = *(*uintptr)(unsafe.Pointer(v194))
				*(*uintptr)(unsafe.Pointer(v194))++
				*(*uint8)(unsafe.Pointer(v193)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
				v196 = envPtr2 + 152
				v195 = *(*uintptr)(unsafe.Pointer(v196))
				*(*uintptr)(unsafe.Pointer(v196))++
				*(*uint8)(unsafe.Pointer(v195)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_STR_RANGE_IMM)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v197 = delta1
					v198 = envPtr2
					if v197 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v198)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v198)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v198)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v198)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v198 + 64)) += int64(v197)
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v200 = envPtr2 + 152
				v199 = *(*uintptr)(unsafe.Pointer(v200))
				*(*uintptr)(unsafe.Pointer(v200))++
				*(*uint8)(unsafe.Pointer(v199)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(24))
				v202 = envPtr2 + 152
				v201 = *(*uintptr)(unsafe.Pointer(v202))
				*(*uintptr)(unsafe.Pointer(v202))++
				*(*uint8)(unsafe.Pointer(v201)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(16))
				v204 = envPtr2 + 152
				v203 = *(*uintptr)(unsafe.Pointer(v204))
				*(*uintptr)(unsafe.Pointer(v204))++
				*(*uint8)(unsafe.Pointer(v203)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(8))
				v206 = envPtr2 + 152
				v205 = *(*uintptr)(unsafe.Pointer(v206))
				*(*uintptr)(unsafe.Pointer(v206))++
				*(*uint8)(unsafe.Pointer(v205)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp)) - libc.Int32FromInt32(1)))
				return TCL_OK
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v208 = envPtr2 + 152
			v207 = *(*uintptr)(unsafe.Pointer(v208))
			*(*uintptr)(unsafe.Pointer(v208))++
			*(*uint8)(unsafe.Pointer(v207)) = libc.Uint8FromInt32(int32(INST_DUP))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_DUP)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v209 = delta1
				v210 = envPtr2
				if v209 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v210)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v210)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v210)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v210)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v210 + 64)) += int64(v209)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v212 = envPtr2 + 152
			v211 = *(*uintptr)(unsafe.Pointer(v212))
			*(*uintptr)(unsafe.Pointer(v212))++
			*(*uint8)(unsafe.Pointer(v211)) = libc.Uint8FromInt32(int32(INST_STR_RANGE_IMM))
			v214 = envPtr2 + 152
			v213 = *(*uintptr)(unsafe.Pointer(v214))
			*(*uintptr)(unsafe.Pointer(v214))++
			*(*uint8)(unsafe.Pointer(v213)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
			v216 = envPtr2 + 152
			v215 = *(*uintptr)(unsafe.Pointer(v216))
			*(*uintptr)(unsafe.Pointer(v216))++
			*(*uint8)(unsafe.Pointer(v215)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
			v218 = envPtr2 + 152
			v217 = *(*uintptr)(unsafe.Pointer(v218))
			*(*uintptr)(unsafe.Pointer(v218))++
			*(*uint8)(unsafe.Pointer(v217)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
			v220 = envPtr2 + 152
			v219 = *(*uintptr)(unsafe.Pointer(v220))
			*(*uintptr)(unsafe.Pointer(v220))++
			*(*uint8)(unsafe.Pointer(v219)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STR_RANGE_IMM)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v221 = delta1
				v222 = envPtr2
				if v221 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v222)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v222)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v222)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v222)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v222 + 64)) += int64(v221)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v224 = envPtr2 + 152
			v223 = *(*uintptr)(unsafe.Pointer(v224))
			*(*uintptr)(unsafe.Pointer(v224))++
			*(*uint8)(unsafe.Pointer(v223)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(24))
			v226 = envPtr2 + 152
			v225 = *(*uintptr)(unsafe.Pointer(v226))
			*(*uintptr)(unsafe.Pointer(v226))++
			*(*uint8)(unsafe.Pointer(v225)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(16))
			v228 = envPtr2 + 152
			v227 = *(*uintptr)(unsafe.Pointer(v228))
			*(*uintptr)(unsafe.Pointer(v228))++
			*(*uint8)(unsafe.Pointer(v227)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(8))
			v230 = envPtr2 + 152
			v229 = *(*uintptr)(unsafe.Pointer(v230))
			*(*uintptr)(unsafe.Pointer(v230))++
			*(*uint8)(unsafe.Pointer(v229)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp)) - libc.Int32FromInt32(1)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v232 = envPtr2 + 152
			v231 = *(*uintptr)(unsafe.Pointer(v232))
			*(*uintptr)(unsafe.Pointer(v232))++
			*(*uint8)(unsafe.Pointer(v231)) = libc.Uint8FromInt32(int32(INST_REVERSE))
			v234 = envPtr2 + 152
			v233 = *(*uintptr)(unsafe.Pointer(v234))
			*(*uintptr)(unsafe.Pointer(v234))++
			*(*uint8)(unsafe.Pointer(v233)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
			v236 = envPtr2 + 152
			v235 = *(*uintptr)(unsafe.Pointer(v236))
			*(*uintptr)(unsafe.Pointer(v236))++
			*(*uint8)(unsafe.Pointer(v235)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
			v238 = envPtr2 + 152
			v237 = *(*uintptr)(unsafe.Pointer(v238))
			*(*uintptr)(unsafe.Pointer(v238))++
			*(*uint8)(unsafe.Pointer(v237)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
			v240 = envPtr2 + 152
			v239 = *(*uintptr)(unsafe.Pointer(v240))
			*(*uintptr)(unsafe.Pointer(v240))++
			*(*uint8)(unsafe.Pointer(v239)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - int32(2)
				}
				v241 = delta1
				v242 = envPtr2
				if v241 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v242)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v242)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v242)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v242)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v242 + 64)) += int64(v241)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v244 = envPtr2 + 152
			v243 = *(*uintptr)(unsafe.Pointer(v244))
			*(*uintptr)(unsafe.Pointer(v244))++
			*(*uint8)(unsafe.Pointer(v243)) = libc.Uint8FromInt32(int32(INST_STR_RANGE_IMM))
			v246 = envPtr2 + 152
			v245 = *(*uintptr)(unsafe.Pointer(v246))
			*(*uintptr)(unsafe.Pointer(v246))++
			*(*uint8)(unsafe.Pointer(v245)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))+libc.Int32FromInt32(1)) >> libc.Int32FromInt32(24))
			v248 = envPtr2 + 152
			v247 = *(*uintptr)(unsafe.Pointer(v248))
			*(*uintptr)(unsafe.Pointer(v248))++
			*(*uint8)(unsafe.Pointer(v247)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))+libc.Int32FromInt32(1)) >> libc.Int32FromInt32(16))
			v250 = envPtr2 + 152
			v249 = *(*uintptr)(unsafe.Pointer(v250))
			*(*uintptr)(unsafe.Pointer(v250))++
			*(*uint8)(unsafe.Pointer(v249)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))+libc.Int32FromInt32(1)) >> libc.Int32FromInt32(8))
			v252 = envPtr2 + 152
			v251 = *(*uintptr)(unsafe.Pointer(v252))
			*(*uintptr)(unsafe.Pointer(v252))++
			*(*uint8)(unsafe.Pointer(v251)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4)) + libc.Int32FromInt32(1)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STR_RANGE_IMM)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - (*(*int32)(unsafe.Pointer(bp + 4)) + int32(1))
				}
				v253 = delta1
				v254 = envPtr2
				if v253 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v254)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v254)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v254)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v254)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v254 + 64)) += int64(v253)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v256 = envPtr2 + 152
			v255 = *(*uintptr)(unsafe.Pointer(v256))
			*(*uintptr)(unsafe.Pointer(v256))++
			*(*uint8)(unsafe.Pointer(v255)) = uint8(libc.Uint32FromInt32(int32(int64(-libc.Int32FromInt32(2)))) >> libc.Int32FromInt32(24))
			v258 = envPtr2 + 152
			v257 = *(*uintptr)(unsafe.Pointer(v258))
			*(*uintptr)(unsafe.Pointer(v258))++
			*(*uint8)(unsafe.Pointer(v257)) = uint8(libc.Uint32FromInt32(int32(int64(-libc.Int32FromInt32(2)))) >> libc.Int32FromInt32(16))
			v260 = envPtr2 + 152
			v259 = *(*uintptr)(unsafe.Pointer(v260))
			*(*uintptr)(unsafe.Pointer(v260))++
			*(*uint8)(unsafe.Pointer(v259)) = uint8(libc.Uint32FromInt32(int32(int64(-libc.Int32FromInt32(2)))) >> libc.Int32FromInt32(8))
			v262 = envPtr2 + 152
			v261 = *(*uintptr)(unsafe.Pointer(v262))
			*(*uintptr)(unsafe.Pointer(v262))++
			*(*uint8)(unsafe.Pointer(v261)) = uint8(libc.Uint32FromInt32(int32(int64(-libc.Int32FromInt32(2)))))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v264 = envPtr2 + 152
			v263 = *(*uintptr)(unsafe.Pointer(v264))
			*(*uintptr)(unsafe.Pointer(v264))++
			*(*uint8)(unsafe.Pointer(v263)) = libc.Uint8FromInt32(int32(INST_STR_CONCAT1))
			v266 = envPtr2 + 152
			v265 = *(*uintptr)(unsafe.Pointer(v266))
			*(*uintptr)(unsafe.Pointer(v266))++
			*(*uint8)(unsafe.Pointer(v265)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STR_CONCAT1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - int32(2)
				}
				v267 = delta1
				v268 = envPtr2
				if v267 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v268)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v268)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v268)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v268)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v268 + 64)) += int64(v267)
			}
			return TCL_OK
		}
	}
	goto genericReplace
genericReplace:
	;
	tokenPtr = valueTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy5 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy5 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v270 = envPtr2 + 152
			v269 = *(*uintptr)(unsafe.Pointer(v270))
			*(*uintptr)(unsafe.Pointer(v270))++
			*(*uint8)(unsafe.Pointer(v269)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v272 = envPtr2 + 152
			v271 = *(*uintptr)(unsafe.Pointer(v272))
			*(*uintptr)(unsafe.Pointer(v272))++
			*(*uint8)(unsafe.Pointer(v271)) = uint8(libc.Uint32FromInt32(_objIndexCopy5))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy5
				}
				v273 = delta1
				v274 = envPtr2
				if v273 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v274)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v274)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v274)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v274)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v274 + 64)) += int64(v273)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v276 = envPtr2 + 152
			v275 = *(*uintptr)(unsafe.Pointer(v276))
			*(*uintptr)(unsafe.Pointer(v276))++
			*(*uint8)(unsafe.Pointer(v275)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v278 = envPtr2 + 152
			v277 = *(*uintptr)(unsafe.Pointer(v278))
			*(*uintptr)(unsafe.Pointer(v278))++
			*(*uint8)(unsafe.Pointer(v277)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(24))
			v280 = envPtr2 + 152
			v279 = *(*uintptr)(unsafe.Pointer(v280))
			*(*uintptr)(unsafe.Pointer(v280))++
			*(*uint8)(unsafe.Pointer(v279)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(16))
			v282 = envPtr2 + 152
			v281 = *(*uintptr)(unsafe.Pointer(v282))
			*(*uintptr)(unsafe.Pointer(v282))++
			*(*uint8)(unsafe.Pointer(v281)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(8))
			v284 = envPtr2 + 152
			v283 = *(*uintptr)(unsafe.Pointer(v284))
			*(*uintptr)(unsafe.Pointer(v284))++
			*(*uint8)(unsafe.Pointer(v283)) = uint8(libc.Uint32FromInt32(_objIndexCopy5))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy5
				}
				v285 = delta1
				v286 = envPtr2
				if v285 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v286)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v286)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v286)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v286)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v286 + 64)) += int64(v285)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy6 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy6 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v288 = envPtr2 + 152
			v287 = *(*uintptr)(unsafe.Pointer(v288))
			*(*uintptr)(unsafe.Pointer(v288))++
			*(*uint8)(unsafe.Pointer(v287)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v290 = envPtr2 + 152
			v289 = *(*uintptr)(unsafe.Pointer(v290))
			*(*uintptr)(unsafe.Pointer(v290))++
			*(*uint8)(unsafe.Pointer(v289)) = uint8(libc.Uint32FromInt32(_objIndexCopy6))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy6
				}
				v291 = delta1
				v292 = envPtr2
				if v291 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v292)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v292)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v292)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v292)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v292 + 64)) += int64(v291)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v294 = envPtr2 + 152
			v293 = *(*uintptr)(unsafe.Pointer(v294))
			*(*uintptr)(unsafe.Pointer(v294))++
			*(*uint8)(unsafe.Pointer(v293)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v296 = envPtr2 + 152
			v295 = *(*uintptr)(unsafe.Pointer(v296))
			*(*uintptr)(unsafe.Pointer(v296))++
			*(*uint8)(unsafe.Pointer(v295)) = uint8(libc.Uint32FromInt32(_objIndexCopy6) >> libc.Int32FromInt32(24))
			v298 = envPtr2 + 152
			v297 = *(*uintptr)(unsafe.Pointer(v298))
			*(*uintptr)(unsafe.Pointer(v298))++
			*(*uint8)(unsafe.Pointer(v297)) = uint8(libc.Uint32FromInt32(_objIndexCopy6) >> libc.Int32FromInt32(16))
			v300 = envPtr2 + 152
			v299 = *(*uintptr)(unsafe.Pointer(v300))
			*(*uintptr)(unsafe.Pointer(v300))++
			*(*uint8)(unsafe.Pointer(v299)) = uint8(libc.Uint32FromInt32(_objIndexCopy6) >> libc.Int32FromInt32(8))
			v302 = envPtr2 + 152
			v301 = *(*uintptr)(unsafe.Pointer(v302))
			*(*uintptr)(unsafe.Pointer(v302))++
			*(*uint8)(unsafe.Pointer(v301)) = uint8(libc.Uint32FromInt32(_objIndexCopy6))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy6
				}
				v303 = delta1
				v304 = envPtr2
				if v303 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v304)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v304)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v304)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v304)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v304 + 64)) += int64(v303)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 3*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 3*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(5) {
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy7 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy7 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v306 = envPtr2 + 152
				v305 = *(*uintptr)(unsafe.Pointer(v306))
				*(*uintptr)(unsafe.Pointer(v306))++
				*(*uint8)(unsafe.Pointer(v305)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v308 = envPtr2 + 152
				v307 = *(*uintptr)(unsafe.Pointer(v308))
				*(*uintptr)(unsafe.Pointer(v308))++
				*(*uint8)(unsafe.Pointer(v307)) = uint8(libc.Uint32FromInt32(_objIndexCopy7))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy7
					}
					v309 = delta1
					v310 = envPtr2
					if v309 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v310)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v310)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v310)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v310)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v310 + 64)) += int64(v309)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v312 = envPtr2 + 152
				v311 = *(*uintptr)(unsafe.Pointer(v312))
				*(*uintptr)(unsafe.Pointer(v312))++
				*(*uint8)(unsafe.Pointer(v311)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v314 = envPtr2 + 152
				v313 = *(*uintptr)(unsafe.Pointer(v314))
				*(*uintptr)(unsafe.Pointer(v314))++
				*(*uint8)(unsafe.Pointer(v313)) = uint8(libc.Uint32FromInt32(_objIndexCopy7) >> libc.Int32FromInt32(24))
				v316 = envPtr2 + 152
				v315 = *(*uintptr)(unsafe.Pointer(v316))
				*(*uintptr)(unsafe.Pointer(v316))++
				*(*uint8)(unsafe.Pointer(v315)) = uint8(libc.Uint32FromInt32(_objIndexCopy7) >> libc.Int32FromInt32(16))
				v318 = envPtr2 + 152
				v317 = *(*uintptr)(unsafe.Pointer(v318))
				*(*uintptr)(unsafe.Pointer(v318))++
				*(*uint8)(unsafe.Pointer(v317)) = uint8(libc.Uint32FromInt32(_objIndexCopy7) >> libc.Int32FromInt32(8))
				v320 = envPtr2 + 152
				v319 = *(*uintptr)(unsafe.Pointer(v320))
				*(*uintptr)(unsafe.Pointer(v320))++
				*(*uint8)(unsafe.Pointer(v319)) = uint8(libc.Uint32FromInt32(_objIndexCopy7))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy7
					}
					v321 = delta1
					v322 = envPtr2
					if v321 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v322)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v322)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v322)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v322)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v322 + 64)) += int64(v321)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 4*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 4*8))
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
		}
	} else {
		_objIndexCopy8 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy8 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v324 = envPtr2 + 152
			v323 = *(*uintptr)(unsafe.Pointer(v324))
			*(*uintptr)(unsafe.Pointer(v324))++
			*(*uint8)(unsafe.Pointer(v323)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v326 = envPtr2 + 152
			v325 = *(*uintptr)(unsafe.Pointer(v326))
			*(*uintptr)(unsafe.Pointer(v326))++
			*(*uint8)(unsafe.Pointer(v325)) = uint8(libc.Uint32FromInt32(_objIndexCopy8))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy8
				}
				v327 = delta1
				v328 = envPtr2
				if v327 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v328)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v328)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v328)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v328)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v328 + 64)) += int64(v327)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v330 = envPtr2 + 152
			v329 = *(*uintptr)(unsafe.Pointer(v330))
			*(*uintptr)(unsafe.Pointer(v330))++
			*(*uint8)(unsafe.Pointer(v329)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v332 = envPtr2 + 152
			v331 = *(*uintptr)(unsafe.Pointer(v332))
			*(*uintptr)(unsafe.Pointer(v332))++
			*(*uint8)(unsafe.Pointer(v331)) = uint8(libc.Uint32FromInt32(_objIndexCopy8) >> libc.Int32FromInt32(24))
			v334 = envPtr2 + 152
			v333 = *(*uintptr)(unsafe.Pointer(v334))
			*(*uintptr)(unsafe.Pointer(v334))++
			*(*uint8)(unsafe.Pointer(v333)) = uint8(libc.Uint32FromInt32(_objIndexCopy8) >> libc.Int32FromInt32(16))
			v336 = envPtr2 + 152
			v335 = *(*uintptr)(unsafe.Pointer(v336))
			*(*uintptr)(unsafe.Pointer(v336))++
			*(*uint8)(unsafe.Pointer(v335)) = uint8(libc.Uint32FromInt32(_objIndexCopy8) >> libc.Int32FromInt32(8))
			v338 = envPtr2 + 152
			v337 = *(*uintptr)(unsafe.Pointer(v338))
			*(*uintptr)(unsafe.Pointer(v338))++
			*(*uint8)(unsafe.Pointer(v337)) = uint8(libc.Uint32FromInt32(_objIndexCopy8))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy8
				}
				v339 = delta1
				v340 = envPtr2
				if v339 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v340)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v340)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v340)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v340)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v340 + 64)) += int64(v339)
			}
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v342 = envPtr2 + 152
	v341 = *(*uintptr)(unsafe.Pointer(v342))
	*(*uintptr)(unsafe.Pointer(v342))++
	*(*uint8)(unsafe.Pointer(v341)) = libc.Uint8FromInt32(int32(INST_STR_REPLACE))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_STR_REPLACE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v343 = delta1
		v344 = envPtr2
		if v343 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v344)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v344)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v344)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v344)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v344 + 64)) += int64(v343)
	}
	return TCL_OK
}

func XTclCompileStringTrimLCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy1248 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, delta1, v17, v23, v35, v41, v5, v53, v57 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v36, v37, v38, v39, v4, v40, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v54, v55, v56, v58, v6, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, delta1, eclIndex, mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) && (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(3) {
		return int32(TCL_ERROR)
	}
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(3) {
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy1 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v20 = envPtr2 + 152
				v19 = *(*uintptr)(unsafe.Pointer(v20))
				*(*uintptr)(unsafe.Pointer(v20))++
				*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v22 = envPtr2 + 152
				v21 = *(*uintptr)(unsafe.Pointer(v22))
				*(*uintptr)(unsafe.Pointer(v22))++
				*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v23 = delta1
					v24 = envPtr2
					if v23 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v24 + 64)) += int64(v23)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v26 = envPtr2 + 152
				v25 = *(*uintptr)(unsafe.Pointer(v26))
				*(*uintptr)(unsafe.Pointer(v26))++
				*(*uint8)(unsafe.Pointer(v25)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v28 = envPtr2 + 152
				v27 = *(*uintptr)(unsafe.Pointer(v28))
				*(*uintptr)(unsafe.Pointer(v28))++
				*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
				v30 = envPtr2 + 152
				v29 = *(*uintptr)(unsafe.Pointer(v30))
				*(*uintptr)(unsafe.Pointer(v30))++
				*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
				v32 = envPtr2 + 152
				v31 = *(*uintptr)(unsafe.Pointer(v32))
				*(*uintptr)(unsafe.Pointer(v32))++
				*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
				v34 = envPtr2 + 152
				v33 = *(*uintptr)(unsafe.Pointer(v34))
				*(*uintptr)(unsafe.Pointer(v34))++
				*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v35 = delta1
					v36 = envPtr2
					if v35 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v36 + 64)) += int64(v35)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
		}
	} else {
		_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, uintptr(unsafe.Pointer(&XtclDefaultTrimSet)), libc.Int64FromUint64(libc.Xstrlen(tls, uintptr(unsafe.Pointer(&XtclDefaultTrimSet)))), 0)
		if _objIndexCopy2 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v38 = envPtr2 + 152
			v37 = *(*uintptr)(unsafe.Pointer(v38))
			*(*uintptr)(unsafe.Pointer(v38))++
			*(*uint8)(unsafe.Pointer(v37)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v40 = envPtr2 + 152
			v39 = *(*uintptr)(unsafe.Pointer(v40))
			*(*uintptr)(unsafe.Pointer(v40))++
			*(*uint8)(unsafe.Pointer(v39)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v41 = delta1
				v42 = envPtr2
				if v41 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v42)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v42)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v42)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v42)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v42 + 64)) += int64(v41)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v44 = envPtr2 + 152
			v43 = *(*uintptr)(unsafe.Pointer(v44))
			*(*uintptr)(unsafe.Pointer(v44))++
			*(*uint8)(unsafe.Pointer(v43)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v46 = envPtr2 + 152
			v45 = *(*uintptr)(unsafe.Pointer(v46))
			*(*uintptr)(unsafe.Pointer(v46))++
			*(*uint8)(unsafe.Pointer(v45)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
			v48 = envPtr2 + 152
			v47 = *(*uintptr)(unsafe.Pointer(v48))
			*(*uintptr)(unsafe.Pointer(v48))++
			*(*uint8)(unsafe.Pointer(v47)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
			v50 = envPtr2 + 152
			v49 = *(*uintptr)(unsafe.Pointer(v50))
			*(*uintptr)(unsafe.Pointer(v50))++
			*(*uint8)(unsafe.Pointer(v49)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
			v52 = envPtr2 + 152
			v51 = *(*uintptr)(unsafe.Pointer(v52))
			*(*uintptr)(unsafe.Pointer(v52))++
			*(*uint8)(unsafe.Pointer(v51)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v53 = delta1
				v54 = envPtr2
				if v53 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v54)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v54)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v54)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v54)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v54 + 64)) += int64(v53)
			}
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v56 = envPtr2 + 152
	v55 = *(*uintptr)(unsafe.Pointer(v56))
	*(*uintptr)(unsafe.Pointer(v56))++
	*(*uint8)(unsafe.Pointer(v55)) = libc.Uint8FromInt32(int32(INST_STR_TRIM_LEFT))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_STR_TRIM_LEFT)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v57 = delta1
		v58 = envPtr2
		if v57 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v58)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v58)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v58)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v58)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v58 + 64)) += int64(v57)
	}
	return TCL_OK
}

func XTclCompileStringTrimRCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy1275 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, delta1, v17, v23, v35, v41, v5, v53, v57 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v36, v37, v38, v39, v4, v40, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v54, v55, v56, v58, v6, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, delta1, eclIndex, mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) && (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(3) {
		return int32(TCL_ERROR)
	}
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(3) {
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy1 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v20 = envPtr2 + 152
				v19 = *(*uintptr)(unsafe.Pointer(v20))
				*(*uintptr)(unsafe.Pointer(v20))++
				*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v22 = envPtr2 + 152
				v21 = *(*uintptr)(unsafe.Pointer(v22))
				*(*uintptr)(unsafe.Pointer(v22))++
				*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v23 = delta1
					v24 = envPtr2
					if v23 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v24 + 64)) += int64(v23)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v26 = envPtr2 + 152
				v25 = *(*uintptr)(unsafe.Pointer(v26))
				*(*uintptr)(unsafe.Pointer(v26))++
				*(*uint8)(unsafe.Pointer(v25)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v28 = envPtr2 + 152
				v27 = *(*uintptr)(unsafe.Pointer(v28))
				*(*uintptr)(unsafe.Pointer(v28))++
				*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
				v30 = envPtr2 + 152
				v29 = *(*uintptr)(unsafe.Pointer(v30))
				*(*uintptr)(unsafe.Pointer(v30))++
				*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
				v32 = envPtr2 + 152
				v31 = *(*uintptr)(unsafe.Pointer(v32))
				*(*uintptr)(unsafe.Pointer(v32))++
				*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
				v34 = envPtr2 + 152
				v33 = *(*uintptr)(unsafe.Pointer(v34))
				*(*uintptr)(unsafe.Pointer(v34))++
				*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v35 = delta1
					v36 = envPtr2
					if v35 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v36 + 64)) += int64(v35)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
		}
	} else {
		_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, uintptr(unsafe.Pointer(&XtclDefaultTrimSet)), libc.Int64FromUint64(libc.Xstrlen(tls, uintptr(unsafe.Pointer(&XtclDefaultTrimSet)))), 0)
		if _objIndexCopy2 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v38 = envPtr2 + 152
			v37 = *(*uintptr)(unsafe.Pointer(v38))
			*(*uintptr)(unsafe.Pointer(v38))++
			*(*uint8)(unsafe.Pointer(v37)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v40 = envPtr2 + 152
			v39 = *(*uintptr)(unsafe.Pointer(v40))
			*(*uintptr)(unsafe.Pointer(v40))++
			*(*uint8)(unsafe.Pointer(v39)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v41 = delta1
				v42 = envPtr2
				if v41 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v42)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v42)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v42)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v42)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v42 + 64)) += int64(v41)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v44 = envPtr2 + 152
			v43 = *(*uintptr)(unsafe.Pointer(v44))
			*(*uintptr)(unsafe.Pointer(v44))++
			*(*uint8)(unsafe.Pointer(v43)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v46 = envPtr2 + 152
			v45 = *(*uintptr)(unsafe.Pointer(v46))
			*(*uintptr)(unsafe.Pointer(v46))++
			*(*uint8)(unsafe.Pointer(v45)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
			v48 = envPtr2 + 152
			v47 = *(*uintptr)(unsafe.Pointer(v48))
			*(*uintptr)(unsafe.Pointer(v48))++
			*(*uint8)(unsafe.Pointer(v47)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
			v50 = envPtr2 + 152
			v49 = *(*uintptr)(unsafe.Pointer(v50))
			*(*uintptr)(unsafe.Pointer(v50))++
			*(*uint8)(unsafe.Pointer(v49)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
			v52 = envPtr2 + 152
			v51 = *(*uintptr)(unsafe.Pointer(v52))
			*(*uintptr)(unsafe.Pointer(v52))++
			*(*uint8)(unsafe.Pointer(v51)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v53 = delta1
				v54 = envPtr2
				if v53 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v54)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v54)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v54)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v54)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v54 + 64)) += int64(v53)
			}
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v56 = envPtr2 + 152
	v55 = *(*uintptr)(unsafe.Pointer(v56))
	*(*uintptr)(unsafe.Pointer(v56))++
	*(*uint8)(unsafe.Pointer(v55)) = libc.Uint8FromInt32(int32(INST_STR_TRIM_RIGHT))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_STR_TRIM_RIGHT)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v57 = delta1
		v58 = envPtr2
		if v57 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v58)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v58)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v58)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v58)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v58 + 64)) += int64(v57)
	}
	return TCL_OK
}

func XTclCompileStringTrimCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy1302 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, delta1, v17, v23, v35, v41, v5, v53, v57 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v36, v37, v38, v39, v4, v40, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v54, v55, v56, v58, v6, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, delta1, eclIndex, mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) && (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(3) {
		return int32(TCL_ERROR)
	}
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(3) {
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy1 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v20 = envPtr2 + 152
				v19 = *(*uintptr)(unsafe.Pointer(v20))
				*(*uintptr)(unsafe.Pointer(v20))++
				*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v22 = envPtr2 + 152
				v21 = *(*uintptr)(unsafe.Pointer(v22))
				*(*uintptr)(unsafe.Pointer(v22))++
				*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v23 = delta1
					v24 = envPtr2
					if v23 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v24 + 64)) += int64(v23)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v26 = envPtr2 + 152
				v25 = *(*uintptr)(unsafe.Pointer(v26))
				*(*uintptr)(unsafe.Pointer(v26))++
				*(*uint8)(unsafe.Pointer(v25)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v28 = envPtr2 + 152
				v27 = *(*uintptr)(unsafe.Pointer(v28))
				*(*uintptr)(unsafe.Pointer(v28))++
				*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
				v30 = envPtr2 + 152
				v29 = *(*uintptr)(unsafe.Pointer(v30))
				*(*uintptr)(unsafe.Pointer(v30))++
				*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
				v32 = envPtr2 + 152
				v31 = *(*uintptr)(unsafe.Pointer(v32))
				*(*uintptr)(unsafe.Pointer(v32))++
				*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
				v34 = envPtr2 + 152
				v33 = *(*uintptr)(unsafe.Pointer(v34))
				*(*uintptr)(unsafe.Pointer(v34))++
				*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v35 = delta1
					v36 = envPtr2
					if v35 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v36 + 64)) += int64(v35)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
		}
	} else {
		_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, uintptr(unsafe.Pointer(&XtclDefaultTrimSet)), libc.Int64FromUint64(libc.Xstrlen(tls, uintptr(unsafe.Pointer(&XtclDefaultTrimSet)))), 0)
		if _objIndexCopy2 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v38 = envPtr2 + 152
			v37 = *(*uintptr)(unsafe.Pointer(v38))
			*(*uintptr)(unsafe.Pointer(v38))++
			*(*uint8)(unsafe.Pointer(v37)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v40 = envPtr2 + 152
			v39 = *(*uintptr)(unsafe.Pointer(v40))
			*(*uintptr)(unsafe.Pointer(v40))++
			*(*uint8)(unsafe.Pointer(v39)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v41 = delta1
				v42 = envPtr2
				if v41 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v42)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v42)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v42)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v42)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v42 + 64)) += int64(v41)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v44 = envPtr2 + 152
			v43 = *(*uintptr)(unsafe.Pointer(v44))
			*(*uintptr)(unsafe.Pointer(v44))++
			*(*uint8)(unsafe.Pointer(v43)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v46 = envPtr2 + 152
			v45 = *(*uintptr)(unsafe.Pointer(v46))
			*(*uintptr)(unsafe.Pointer(v46))++
			*(*uint8)(unsafe.Pointer(v45)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
			v48 = envPtr2 + 152
			v47 = *(*uintptr)(unsafe.Pointer(v48))
			*(*uintptr)(unsafe.Pointer(v48))++
			*(*uint8)(unsafe.Pointer(v47)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
			v50 = envPtr2 + 152
			v49 = *(*uintptr)(unsafe.Pointer(v50))
			*(*uintptr)(unsafe.Pointer(v50))++
			*(*uint8)(unsafe.Pointer(v49)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
			v52 = envPtr2 + 152
			v51 = *(*uintptr)(unsafe.Pointer(v52))
			*(*uintptr)(unsafe.Pointer(v52))++
			*(*uint8)(unsafe.Pointer(v51)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v53 = delta1
				v54 = envPtr2
				if v53 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v54)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v54)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v54)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v54)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v54 + 64)) += int64(v53)
			}
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v56 = envPtr2 + 152
	v55 = *(*uintptr)(unsafe.Pointer(v56))
	*(*uintptr)(unsafe.Pointer(v56))++
	*(*uint8)(unsafe.Pointer(v55)) = libc.Uint8FromInt32(int32(INST_STR_TRIM))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_STR_TRIM)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v57 = delta1
		v58 = envPtr2
		if v57 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v58)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v58)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v58)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v58)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v58 + 64)) += int64(v57)
	}
	return TCL_OK
}

func XTclCompileStringToUpperCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, delta1, v17, v21, v5 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v22, v3, v4, v6, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, eclIndex, mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v3, v4, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
		return XTclCompileBasic1To3ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
	}
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v20 = envPtr2 + 152
	v19 = *(*uintptr)(unsafe.Pointer(v20))
	*(*uintptr)(unsafe.Pointer(v20))++
	*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_STR_UPPER))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_STR_UPPER)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v21 = delta1
		v22 = envPtr2
		if v21 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v22 + 64)) += int64(v21)
	}
	return TCL_OK
}

func XTclCompileStringToLowerCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, delta1, v17, v21, v5 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v22, v3, v4, v6, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, eclIndex, mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v3, v4, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
		return XTclCompileBasic1To3ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
	}
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v20 = envPtr2 + 152
	v19 = *(*uintptr)(unsafe.Pointer(v20))
	*(*uintptr)(unsafe.Pointer(v20))++
	*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_STR_LOWER))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_STR_LOWER)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v21 = delta1
		v22 = envPtr2
		if v21 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v22 + 64)) += int64(v21)
	}
	return TCL_OK
}

func XTclCompileStringToTitleCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, delta1, v17, v21, v5 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v22, v3, v4, v6, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, eclIndex, mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v3, v4, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
		return XTclCompileBasic1To3ArgCmd(tls, interp, parsePtr, cmdPtr, envPtr2)
	}
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v20 = envPtr2 + 152
	v19 = *(*uintptr)(unsafe.Pointer(v20))
	*(*uintptr)(unsafe.Pointer(v20))++
	*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_STR_TITLE))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_STR_TITLE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v21 = delta1
		v22 = envPtr2
		if v21 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v22)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v22 + 64)) += int64(v21)
	}
	return TCL_OK
}

/*
 * Support definitions for the [string is] compilation.
 */

func _UniCharIsAscii1(tls *libc.TLS, character int32) (r int32) {
	return libc.BoolInt32(character >= 0 && character < int32(0x80))
}

func _UniCharIsHexDigit1(tls *libc.TLS, character int32) (r int32) {
	return libc.BoolInt32(character >= 0 && character < int32(0x80) && libc.Xisxdigit(tls, libc.Int32FromUint8(libc.Uint8FromInt32(character))) != 0)
}

func init() {
	p := unsafe.Pointer(&XtclStringClassTable)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(XTcl_UniCharIsAlnum)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(XTcl_UniCharIsAlpha)
	*(*uintptr)(unsafe.Add(p, 40)) = __ccgo_fp(_UniCharIsAscii1)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(XTcl_UniCharIsControl)
	*(*uintptr)(unsafe.Add(p, 72)) = __ccgo_fp(XTcl_UniCharIsDigit)
	*(*uintptr)(unsafe.Add(p, 88)) = __ccgo_fp(XTcl_UniCharIsGraph)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(XTcl_UniCharIsLower)
	*(*uintptr)(unsafe.Add(p, 120)) = __ccgo_fp(XTcl_UniCharIsPrint)
	*(*uintptr)(unsafe.Add(p, 136)) = __ccgo_fp(XTcl_UniCharIsPunct)
	*(*uintptr)(unsafe.Add(p, 152)) = __ccgo_fp(XTcl_UniCharIsSpace)
	*(*uintptr)(unsafe.Add(p, 168)) = __ccgo_fp(XTcl_UniCharIsUpper)
	*(*uintptr)(unsafe.Add(p, 184)) = __ccgo_fp(XTcl_UniCharIsWordChar)
	*(*uintptr)(unsafe.Add(p, 200)) = __ccgo_fp(_UniCharIsHexDigit1)
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileSubstCmd --
 *
 *	Procedure called to compile the "subst" command.
 *
 * Results:
 *	Returns TCL_OK for successful compile, or TCL_ERROR to defer
 *	evaluation to runtime (either when it is too complex to get the
 *	semantics right, or when we know for sure that it is an error but need
 *	the error to happen at the right time).
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "subst" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileSubstCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy1450 uintptr, envPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds resulting instructions. */
	var cachePtr, cachePtr1, mapPtr, objv, wordTokenPtr, v5 uintptr
	var code, numArgs, numOpts, objc, v3 int32
	var eclIndex, v4 TTcl_Size
	var v2, v6 bool
	var _ /* flags at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, code, eclIndex, mapPtr, numArgs, numOpts, objc, objv, wordTokenPtr, v2, v3, v4, v5, v6
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1) /* TIP #280 */
	numArgs = int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords - int64(1))
	numOpts = numArgs - int32(1)
	*(*int32)(unsafe.Pointer(bp)) = int32(TCL_SUBST_ALL)
	wordTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	code = int32(TCL_ERROR)
	if numArgs == 0 {
		return int32(TCL_ERROR)
	}
	objv = XTclStackAlloc(tls, interp, libc.Uint64FromInt32(numOpts)*uint64(8))
	objc = 0
	for {
		if !(objc < numOpts) {
			break
		}
		if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))).FtypePtr = libc.UintptrFromInt32(0)
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))).FrefCount++
		if !(XTclWordKnownAtCompileTime(tls, wordTokenPtr, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8))) != 0) {
			objc++
			goto cleanup
		}
		wordTokenPtr = wordTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(wordTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		goto _1
	_1:
		;
		objc++
	}
	/*
	       if (TclSubstOptions(NULL, numOpts, objv, &flags) == TCL_OK) {
	   	toSubst = objv[numOpts];
	   	Tcl_IncrRefCount(toSubst);
	       }
	*/
	/* TODO: Figure out expansion to cover WordKnownAtCompileTime
	 *	The difficulty is that WKACT makes a copy, and if TclSubstParse
	 *	below parses the copy of the original source string, some deep
	 *	parts of the compile machinery get upset.  They want all pointers
	 *	stored in Tcl_Tokens to point back to the same original string.
	 */
	if (*TTcl_Token)(unsafe.Pointer(wordTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		code = XTclSubstOptions(tls, libc.UintptrFromInt32(0), int64(numOpts), objv, bp)
	}
	goto cleanup
cleanup:
	;
	for {
		objc--
		v3 = objc
		if !(v3 >= 0) {
			break
		}
		v5 = *(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8))
		v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
		*(*TTcl_Size)(unsafe.Pointer(v5))--
		if !(v4 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))).Flength = int64(-libc.Int32FromInt32(1))
				if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
					cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v6 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8))
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc)*8)))
			}
		}
	}
	XTclStackFree(tls, interp, objv)
	if code != TCL_OK {
		return int32(TCL_ERROR)
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(numArgs)*8))
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(numArgs)*8))
	XTclSubstCompile(tls, interp, (*(*TTcl_Token)(unsafe.Pointer(wordTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(wordTokenPtr + 1*32))).Fsize, *(*int32)(unsafe.Pointer(bp)), *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(numArgs)*8)), envPtr)
	/*    TclDecrRefCount(toSubst);*/
	return TCL_OK
}

func XTclSubstCompile(tls *libc.TLS, interp uintptr, bytes uintptr, numBytes TTcl_Size, flags int32, line TTcl_Size, envPtr2 uintptr) {
	bp := tls.Alloc(896)
	defer tls.Free(896)
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, breakJump, breakOffset, catchRange, count, delta1, foundCommand, literal, v102, v106, v110, v114, v118, v122, v126, v128, v132, v136, v148, v154, v156, v160, v164, v166, v17, v178, v182, v188, v194, v200, v202, v24, v36, v42, v5, v54, v61, v67, v79, v91, v96, v98 int32
	var endTokenPtr, tokenPtr, v1, v10, v100, v101, v103, v104, v105, v107, v108, v109, v11, v111, v112, v113, v115, v116, v117, v119, v12, v120, v121, v123, v124, v125, v127, v129, v13, v130, v131, v133, v134, v135, v137, v138, v139, v14, v140, v141, v142, v143, v144, v145, v146, v147, v149, v15, v150, v151, v152, v153, v155, v157, v158, v159, v16, v161, v162, v163, v165, v167, v168, v169, v170, v171, v172, v173, v174, v175, v176, v177, v179, v18, v180, v181, v183, v184, v185, v186, v187, v189, v190, v191, v192, v193, v195, v196, v197, v198, v199, v2, v20, v201, v203, v21, v22, v23, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v37, v38, v39, v4, v40, v41, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v55, v57, v58, v59, v6, v60, v62, v63, v64, v65, v66, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v92, v94, v95, v97, v99 uintptr
	var i1, length TTcl_Size
	var v93 int64
	var _ /* bline at bp+0 */ TTcl_Size
	var _ /* breakFixup at bp+812 */ TJumpFixup
	var _ /* buf at bp+760 */ [4]uint8
	var _ /* continueFixup at bp+828 */ TJumpFixup
	var _ /* endFixup at bp+860 */ TJumpFixup
	var _ /* okFixup at bp+780 */ TJumpFixup
	var _ /* otherFixup at bp+844 */ TJumpFixup
	var _ /* parse at bp+8 */ TTcl_Parse
	var _ /* returnFixup at bp+796 */ TJumpFixup
	var _ /* startFixup at bp+764 */ TJumpFixup
	var _ /* state at bp+752 */ TTcl_InterpState
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, breakJump, breakOffset, catchRange, count, delta1, endTokenPtr, foundCommand, i1, length, literal, tokenPtr, v1, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v123, v124, v125, v126, v127, v128, v129, v13, v130, v131, v132, v133, v134, v135, v136, v137, v138, v139, v14, v140, v141, v142, v143, v144, v145, v146, v147, v148, v149, v15, v150, v151, v152, v153, v154, v155, v156, v157, v158, v159, v16, v160, v161, v162, v163, v164, v165, v166, v167, v168, v169, v17, v170, v171, v172, v173, v174, v175, v176, v177, v178, v179, v18, v180, v181, v182, v183, v184, v185, v186, v187, v188, v189, v190, v191, v192, v193, v194, v195, v196, v197, v198, v199, v2, v20, v200, v201, v202, v203, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99
	breakOffset = 0
	count = 0
	*(*TTcl_Size)(unsafe.Pointer(bp)) = line
	*(*TTcl_InterpState)(unsafe.Pointer(bp + 752)) = libc.UintptrFromInt32(0)
	XTclSubstParse(tls, interp, bytes, numBytes, flags, bp+8, bp+752)
	if *(*TTcl_InterpState)(unsafe.Pointer(bp + 752)) != libc.UintptrFromInt32(0) {
		XTcl_ResetResult(tls, interp)
	}
	/*
	 * Tricky point! If the first token does not result in a *guaranteed* push
	 * of a Tcl_Obj on the stack, we must push an empty object. Otherwise it
	 * is possible to get to an INST_STR_CONCAT1 or INST_DONE without enough
	 * values on the stack, resulting in a crash. Thanks to Joe Mistachkin for
	 * identifying a script that could trigger this case.
	 */
	tokenPtr = (*(*TTcl_Parse)(unsafe.Pointer(bp + 8))).FtokenPtr
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 != int32(TCL_TOKEN_TEXT) && (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 != int32(TCL_TOKEN_BS) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
		count++
	}
	endTokenPtr = tokenPtr + uintptr((*(*TTcl_Parse)(unsafe.Pointer(bp + 8))).FnumTokens)*32
	for {
		if !(tokenPtr < endTokenPtr) {
			break
		}
		*(*[4]uint8)(unsafe.Pointer(bp + 760)) = [4]uint8{}
		switch (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 {
		case int32(TCL_TOKEN_TEXT):
			literal = XTclRegisterLiteral(tls, envPtr2, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize, 0)
			_objIndexCopy1 = literal
			if _objIndexCopy1 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v21 = envPtr2 + 152
				v20 = *(*uintptr)(unsafe.Pointer(v21))
				*(*uintptr)(unsafe.Pointer(v21))++
				*(*uint8)(unsafe.Pointer(v20)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v23 = envPtr2 + 152
				v22 = *(*uintptr)(unsafe.Pointer(v23))
				*(*uintptr)(unsafe.Pointer(v23))++
				*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v24 = delta1
					v25 = envPtr2
					if v24 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v25 + 64)) += int64(v24)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v27 = envPtr2 + 152
				v26 = *(*uintptr)(unsafe.Pointer(v27))
				*(*uintptr)(unsafe.Pointer(v27))++
				*(*uint8)(unsafe.Pointer(v26)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v29 = envPtr2 + 152
				v28 = *(*uintptr)(unsafe.Pointer(v29))
				*(*uintptr)(unsafe.Pointer(v29))++
				*(*uint8)(unsafe.Pointer(v28)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
				v31 = envPtr2 + 152
				v30 = *(*uintptr)(unsafe.Pointer(v31))
				*(*uintptr)(unsafe.Pointer(v31))++
				*(*uint8)(unsafe.Pointer(v30)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
				v33 = envPtr2 + 152
				v32 = *(*uintptr)(unsafe.Pointer(v33))
				*(*uintptr)(unsafe.Pointer(v33))++
				*(*uint8)(unsafe.Pointer(v32)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
				v35 = envPtr2 + 152
				v34 = *(*uintptr)(unsafe.Pointer(v35))
				*(*uintptr)(unsafe.Pointer(v35))++
				*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v36 = delta1
					v37 = envPtr2
					if v36 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v37 + 64)) += int64(v36)
				}
			}
			XTclAdvanceLines(tls, bp, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart+uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize))
			count++
			goto _19
		case int32(TCL_TOKEN_BS):
			length = int64(XTclParseBackslash(tls, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize, libc.UintptrFromInt32(0), bp+760))
			literal = XTclRegisterLiteral(tls, envPtr2, bp+760, length, 0)
			_objIndexCopy2 = literal
			if _objIndexCopy2 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v39 = envPtr2 + 152
				v38 = *(*uintptr)(unsafe.Pointer(v39))
				*(*uintptr)(unsafe.Pointer(v39))++
				*(*uint8)(unsafe.Pointer(v38)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v41 = envPtr2 + 152
				v40 = *(*uintptr)(unsafe.Pointer(v41))
				*(*uintptr)(unsafe.Pointer(v41))++
				*(*uint8)(unsafe.Pointer(v40)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy2
					}
					v42 = delta1
					v43 = envPtr2
					if v42 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v43)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v43)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v43)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v43)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v43 + 64)) += int64(v42)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v45 = envPtr2 + 152
				v44 = *(*uintptr)(unsafe.Pointer(v45))
				*(*uintptr)(unsafe.Pointer(v45))++
				*(*uint8)(unsafe.Pointer(v44)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v47 = envPtr2 + 152
				v46 = *(*uintptr)(unsafe.Pointer(v47))
				*(*uintptr)(unsafe.Pointer(v47))++
				*(*uint8)(unsafe.Pointer(v46)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
				v49 = envPtr2 + 152
				v48 = *(*uintptr)(unsafe.Pointer(v49))
				*(*uintptr)(unsafe.Pointer(v49))++
				*(*uint8)(unsafe.Pointer(v48)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
				v51 = envPtr2 + 152
				v50 = *(*uintptr)(unsafe.Pointer(v51))
				*(*uintptr)(unsafe.Pointer(v51))++
				*(*uint8)(unsafe.Pointer(v50)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
				v53 = envPtr2 + 152
				v52 = *(*uintptr)(unsafe.Pointer(v53))
				*(*uintptr)(unsafe.Pointer(v53))++
				*(*uint8)(unsafe.Pointer(v52)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy2
					}
					v54 = delta1
					v55 = envPtr2
					if v54 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v55)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v55)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v55)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v55)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v55 + 64)) += int64(v54)
				}
			}
			count++
			goto _19
		case int32(TCL_TOKEN_VARIABLE):
			/*
			 * Check for simple variable access; see if we can only generate
			 * TCL_OK or TCL_ERROR from the substituted variable read; if so,
			 * there is no need to generate elaborate exception-management
			 * code. Note that the first component of TCL_TOKEN_VARIABLE is
			 * always TCL_TOKEN_TEXT...
			 */
			if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents > int64(1) {
				foundCommand = 0
				i1 = int64(2)
				for {
					if !(i1 <= (*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents) {
						break
					}
					if (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + uintptr(i1)*32))).Ftype1 == int32(TCL_TOKEN_COMMAND) {
						foundCommand = int32(1)
						break
					}
					goto _56
				_56:
					;
					i1++
				}
				if foundCommand != 0 {
					break
				}
			}
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer(bp))
			XTclCompileVarSubst(tls, interp, tokenPtr, envPtr2)
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline
			count++
			goto _19
		}
		for count > int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v58 = envPtr2 + 152
			v57 = *(*uintptr)(unsafe.Pointer(v58))
			*(*uintptr)(unsafe.Pointer(v58))++
			*(*uint8)(unsafe.Pointer(v57)) = libc.Uint8FromInt32(int32(INST_STR_CONCAT1))
			v60 = envPtr2 + 152
			v59 = *(*uintptr)(unsafe.Pointer(v60))
			*(*uintptr)(unsafe.Pointer(v60))++
			*(*uint8)(unsafe.Pointer(v59)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(255)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STR_CONCAT1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - int32(255)
				}
				v61 = delta1
				v62 = envPtr2
				if v61 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v62)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v62)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v62)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v62)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v62 + 64)) += int64(v61)
			}
			count -= int32(254)
		}
		if count > int32(1) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v64 = envPtr2 + 152
			v63 = *(*uintptr)(unsafe.Pointer(v64))
			*(*uintptr)(unsafe.Pointer(v64))++
			*(*uint8)(unsafe.Pointer(v63)) = libc.Uint8FromInt32(int32(INST_STR_CONCAT1))
			v66 = envPtr2 + 152
			v65 = *(*uintptr)(unsafe.Pointer(v66))
			*(*uintptr)(unsafe.Pointer(v66))++
			*(*uint8)(unsafe.Pointer(v65)) = uint8(libc.Uint32FromInt32(count))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STR_CONCAT1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - count
				}
				v67 = delta1
				v68 = envPtr2
				if v67 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v68)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v68)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v68)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v68)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v68 + 64)) += int64(v67)
			}
			count = int32(1)
		}
		if breakOffset == 0 {
			/* Jump to the start (jump over the jump to end) */
			XTclEmitForwardJump(tls, envPtr2, int32(TCL_UNCONDITIONAL_JUMP), bp+764)
			/* Jump to the end (all BREAKs land here) */
			breakOffset = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v70 = envPtr2 + 152
			v69 = *(*uintptr)(unsafe.Pointer(v70))
			*(*uintptr)(unsafe.Pointer(v70))++
			*(*uint8)(unsafe.Pointer(v69)) = libc.Uint8FromInt32(int32(INST_JUMP4))
			v72 = envPtr2 + 152
			v71 = *(*uintptr)(unsafe.Pointer(v72))
			*(*uintptr)(unsafe.Pointer(v72))++
			*(*uint8)(unsafe.Pointer(v71)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
			v74 = envPtr2 + 152
			v73 = *(*uintptr)(unsafe.Pointer(v74))
			*(*uintptr)(unsafe.Pointer(v74))++
			*(*uint8)(unsafe.Pointer(v73)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
			v76 = envPtr2 + 152
			v75 = *(*uintptr)(unsafe.Pointer(v76))
			*(*uintptr)(unsafe.Pointer(v76))++
			*(*uint8)(unsafe.Pointer(v75)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
			v78 = envPtr2 + 152
			v77 = *(*uintptr)(unsafe.Pointer(v78))
			*(*uintptr)(unsafe.Pointer(v78))++
			*(*uint8)(unsafe.Pointer(v77)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_JUMP4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v79 = delta1
				v80 = envPtr2
				if v79 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v80)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v80)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v80)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v80)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v80 + 64)) += int64(v79)
			}
			/* Start */
			if XTclFixupForwardJump(tls, envPtr2, bp+764, int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(libc.Int32FromUint32((*TJumpFixup)(unsafe.Pointer(bp+764)).FcodeOffset))), int32(127)) != 0 {
				XTcl_Panic(tls, __ccgo_ts+21876, libc.VaList(bp+888, int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-libc.Int64FromUint32((*(*TJumpFixup)(unsafe.Pointer(bp + 764))).FcodeOffset)))
			}
		}
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer(bp))
		catchRange = int32(XTclCreateExceptRange(tls, int32(CATCH_EXCEPTION_RANGE), envPtr2))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v82 = envPtr2 + 152
		v81 = *(*uintptr)(unsafe.Pointer(v82))
		*(*uintptr)(unsafe.Pointer(v82))++
		*(*uint8)(unsafe.Pointer(v81)) = libc.Uint8FromInt32(int32(INST_BEGIN_CATCH4))
		v84 = envPtr2 + 152
		v83 = *(*uintptr)(unsafe.Pointer(v84))
		*(*uintptr)(unsafe.Pointer(v84))++
		*(*uint8)(unsafe.Pointer(v83)) = uint8(libc.Uint32FromInt32(catchRange) >> libc.Int32FromInt32(24))
		v86 = envPtr2 + 152
		v85 = *(*uintptr)(unsafe.Pointer(v86))
		*(*uintptr)(unsafe.Pointer(v86))++
		*(*uint8)(unsafe.Pointer(v85)) = uint8(libc.Uint32FromInt32(catchRange) >> libc.Int32FromInt32(16))
		v88 = envPtr2 + 152
		v87 = *(*uintptr)(unsafe.Pointer(v88))
		*(*uintptr)(unsafe.Pointer(v88))++
		*(*uint8)(unsafe.Pointer(v87)) = uint8(libc.Uint32FromInt32(catchRange) >> libc.Int32FromInt32(8))
		v90 = envPtr2 + 152
		v89 = *(*uintptr)(unsafe.Pointer(v90))
		*(*uintptr)(unsafe.Pointer(v90))++
		*(*uint8)(unsafe.Pointer(v89)) = uint8(libc.Uint32FromInt32(catchRange))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_BEGIN_CATCH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - catchRange
			}
			v91 = delta1
			v92 = envPtr2
			if v91 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v92)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v92)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v92)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v92)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v92 + 64)) += int64(v91)
		}
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth++
		if libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth)+uint64(1) > libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth)+uint64(1) {
			v93 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth
		} else {
			v93 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth
		}
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth = v93
		(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(catchRange)*56))).FcodeOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
		switch (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 {
		case int32(TCL_TOKEN_COMMAND):
			XTclCompileScript(tls, interp, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart+uintptr(1), (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize-int64(2), envPtr2)
			count++
		case int32(TCL_TOKEN_VARIABLE):
			XTclCompileVarSubst(tls, interp, tokenPtr, envPtr2)
			count++
		default:
			XTcl_Panic(tls, __ccgo_ts+21924, libc.VaList(bp+888, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1))
		}
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth--
		(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(catchRange)*56))).FnumCodeBytes = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(int32((*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(catchRange)*56))).FcodeOffset))
		/* Substitution produced TCL_OK */
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v95 = envPtr2 + 152
		v94 = *(*uintptr)(unsafe.Pointer(v95))
		*(*uintptr)(unsafe.Pointer(v95))++
		*(*uint8)(unsafe.Pointer(v94)) = libc.Uint8FromInt32(int32(INST_END_CATCH))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_END_CATCH)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v96 = delta1
			v97 = envPtr2
			if v96 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v97)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v97)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v97)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v97)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v97 + 64)) += int64(v96)
		}
		XTclEmitForwardJump(tls, envPtr2, int32(TCL_UNCONDITIONAL_JUMP), bp+780)
		v98 = -int32(1)
		v99 = envPtr2
		if v98 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v99)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v99)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v99)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v99)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v99 + 64)) += int64(v98)
		/* Exceptional return codes processed here */
		(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(catchRange)*56))).FcatchOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v101 = envPtr2 + 152
		v100 = *(*uintptr)(unsafe.Pointer(v101))
		*(*uintptr)(unsafe.Pointer(v101))++
		*(*uint8)(unsafe.Pointer(v100)) = libc.Uint8FromInt32(int32(INST_PUSH_RETURN_OPTIONS))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH_RETURN_OPTIONS)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v102 = delta1
			v103 = envPtr2
			if v102 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v103)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v103)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v103)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v103)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v103 + 64)) += int64(v102)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v105 = envPtr2 + 152
		v104 = *(*uintptr)(unsafe.Pointer(v105))
		*(*uintptr)(unsafe.Pointer(v105))++
		*(*uint8)(unsafe.Pointer(v104)) = libc.Uint8FromInt32(int32(INST_PUSH_RESULT))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH_RESULT)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v106 = delta1
			v107 = envPtr2
			if v106 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v107)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v107)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v107)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v107)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v107 + 64)) += int64(v106)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v109 = envPtr2 + 152
		v108 = *(*uintptr)(unsafe.Pointer(v109))
		*(*uintptr)(unsafe.Pointer(v109))++
		*(*uint8)(unsafe.Pointer(v108)) = libc.Uint8FromInt32(int32(INST_PUSH_RETURN_CODE))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH_RETURN_CODE)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v110 = delta1
			v111 = envPtr2
			if v110 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v111)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v111)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v111)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v111)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v111 + 64)) += int64(v110)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v113 = envPtr2 + 152
		v112 = *(*uintptr)(unsafe.Pointer(v113))
		*(*uintptr)(unsafe.Pointer(v113))++
		*(*uint8)(unsafe.Pointer(v112)) = libc.Uint8FromInt32(int32(INST_END_CATCH))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_END_CATCH)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v114 = delta1
			v115 = envPtr2
			if v114 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v115)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v115)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v115)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v115)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v115 + 64)) += int64(v114)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v117 = envPtr2 + 152
		v116 = *(*uintptr)(unsafe.Pointer(v117))
		*(*uintptr)(unsafe.Pointer(v117))++
		*(*uint8)(unsafe.Pointer(v116)) = libc.Uint8FromInt32(int32(INST_RETURN_CODE_BRANCH))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_RETURN_CODE_BRANCH)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v118 = delta1
			v119 = envPtr2
			if v118 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v119)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v119)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v119)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v119)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v119 + 64)) += int64(v118)
		}
		/* ERROR -> reraise it; NB: can't require BREAK/CONTINUE handling */
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v121 = envPtr2 + 152
		v120 = *(*uintptr)(unsafe.Pointer(v121))
		*(*uintptr)(unsafe.Pointer(v121))++
		*(*uint8)(unsafe.Pointer(v120)) = libc.Uint8FromInt32(int32(INST_RETURN_STK))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_RETURN_STK)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v122 = delta1
			v123 = envPtr2
			if v122 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v123)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v123)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v123)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v123)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v123 + 64)) += int64(v122)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v125 = envPtr2 + 152
		v124 = *(*uintptr)(unsafe.Pointer(v125))
		*(*uintptr)(unsafe.Pointer(v125))++
		*(*uint8)(unsafe.Pointer(v124)) = libc.Uint8FromInt32(int32(INST_NOP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_NOP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v126 = delta1
			v127 = envPtr2
			if v126 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v127)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v127)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v127)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v127)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v127 + 64)) += int64(v126)
		}
		/* RETURN */
		XTclEmitForwardJump(tls, envPtr2, int32(TCL_UNCONDITIONAL_JUMP), bp+796)
		/* BREAK */
		XTclEmitForwardJump(tls, envPtr2, int32(TCL_UNCONDITIONAL_JUMP), bp+812)
		/* CONTINUE */
		XTclEmitForwardJump(tls, envPtr2, int32(TCL_UNCONDITIONAL_JUMP), bp+828)
		/* OTHER */
		XTclEmitForwardJump(tls, envPtr2, int32(TCL_UNCONDITIONAL_JUMP), bp+844)
		v128 = int32(1)
		v129 = envPtr2
		if v128 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v129)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v129)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v129)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v129)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v129 + 64)) += int64(v128)
		/* BREAK destination */
		if XTclFixupForwardJump(tls, envPtr2, bp+812, int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(libc.Int32FromUint32((*TJumpFixup)(unsafe.Pointer(bp+812)).FcodeOffset))), int32(127)) != 0 {
			XTcl_Panic(tls, __ccgo_ts+21972, libc.VaList(bp+888, int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-libc.Int64FromUint32((*(*TJumpFixup)(unsafe.Pointer(bp + 812))).FcodeOffset)))
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v131 = envPtr2 + 152
		v130 = *(*uintptr)(unsafe.Pointer(v131))
		*(*uintptr)(unsafe.Pointer(v131))++
		*(*uint8)(unsafe.Pointer(v130)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v132 = delta1
			v133 = envPtr2
			if v132 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v133)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v133)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v133)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v133)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v133 + 64)) += int64(v132)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v135 = envPtr2 + 152
		v134 = *(*uintptr)(unsafe.Pointer(v135))
		*(*uintptr)(unsafe.Pointer(v135))++
		*(*uint8)(unsafe.Pointer(v134)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v136 = delta1
			v137 = envPtr2
			if v136 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v137)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v137)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v137)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v137)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v137 + 64)) += int64(v136)
		}
		breakJump = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(breakOffset))
		if breakJump > int32(127) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v139 = envPtr2 + 152
			v138 = *(*uintptr)(unsafe.Pointer(v139))
			*(*uintptr)(unsafe.Pointer(v139))++
			*(*uint8)(unsafe.Pointer(v138)) = libc.Uint8FromInt32(int32(INST_JUMP4))
			v141 = envPtr2 + 152
			v140 = *(*uintptr)(unsafe.Pointer(v141))
			*(*uintptr)(unsafe.Pointer(v141))++
			*(*uint8)(unsafe.Pointer(v140)) = uint8(libc.Uint32FromInt32(-breakJump) >> libc.Int32FromInt32(24))
			v143 = envPtr2 + 152
			v142 = *(*uintptr)(unsafe.Pointer(v143))
			*(*uintptr)(unsafe.Pointer(v143))++
			*(*uint8)(unsafe.Pointer(v142)) = uint8(libc.Uint32FromInt32(-breakJump) >> libc.Int32FromInt32(16))
			v145 = envPtr2 + 152
			v144 = *(*uintptr)(unsafe.Pointer(v145))
			*(*uintptr)(unsafe.Pointer(v145))++
			*(*uint8)(unsafe.Pointer(v144)) = uint8(libc.Uint32FromInt32(-breakJump) >> libc.Int32FromInt32(8))
			v147 = envPtr2 + 152
			v146 = *(*uintptr)(unsafe.Pointer(v147))
			*(*uintptr)(unsafe.Pointer(v147))++
			*(*uint8)(unsafe.Pointer(v146)) = uint8(libc.Uint32FromInt32(-breakJump))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_JUMP4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - -breakJump
				}
				v148 = delta1
				v149 = envPtr2
				if v148 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v149)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v149)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v149)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v149)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v149 + 64)) += int64(v148)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v151 = envPtr2 + 152
			v150 = *(*uintptr)(unsafe.Pointer(v151))
			*(*uintptr)(unsafe.Pointer(v151))++
			*(*uint8)(unsafe.Pointer(v150)) = libc.Uint8FromInt32(int32(INST_JUMP1))
			v153 = envPtr2 + 152
			v152 = *(*uintptr)(unsafe.Pointer(v153))
			*(*uintptr)(unsafe.Pointer(v153))++
			*(*uint8)(unsafe.Pointer(v152)) = uint8(libc.Uint32FromInt32(-breakJump))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_JUMP1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - -breakJump
				}
				v154 = delta1
				v155 = envPtr2
				if v154 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v155)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v155)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v155)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v155)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v155 + 64)) += int64(v154)
			}
		}
		v156 = int32(2)
		v157 = envPtr2
		if v156 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v157)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v157)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v157)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v157)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v157 + 64)) += int64(v156)
		/* CONTINUE destination */
		if XTclFixupForwardJump(tls, envPtr2, bp+828, int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(libc.Int32FromUint32((*TJumpFixup)(unsafe.Pointer(bp+828)).FcodeOffset))), int32(127)) != 0 {
			XTcl_Panic(tls, __ccgo_ts+22020, libc.VaList(bp+888, int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-libc.Int64FromUint32((*(*TJumpFixup)(unsafe.Pointer(bp + 828))).FcodeOffset)))
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v159 = envPtr2 + 152
		v158 = *(*uintptr)(unsafe.Pointer(v159))
		*(*uintptr)(unsafe.Pointer(v159))++
		*(*uint8)(unsafe.Pointer(v158)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v160 = delta1
			v161 = envPtr2
			if v160 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v161)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v161)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v161)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v161)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v161 + 64)) += int64(v160)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v163 = envPtr2 + 152
		v162 = *(*uintptr)(unsafe.Pointer(v163))
		*(*uintptr)(unsafe.Pointer(v163))++
		*(*uint8)(unsafe.Pointer(v162)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v164 = delta1
			v165 = envPtr2
			if v164 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v165)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v165)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v165)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v165)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v165 + 64)) += int64(v164)
		}
		XTclEmitForwardJump(tls, envPtr2, int32(TCL_UNCONDITIONAL_JUMP), bp+860)
		v166 = int32(2)
		v167 = envPtr2
		if v166 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v167)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v167)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v167)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v167)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v167 + 64)) += int64(v166)
		/* RETURN + other destination */
		if XTclFixupForwardJump(tls, envPtr2, bp+796, int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(libc.Int32FromUint32((*TJumpFixup)(unsafe.Pointer(bp+796)).FcodeOffset))), int32(127)) != 0 {
			XTcl_Panic(tls, __ccgo_ts+22071, libc.VaList(bp+888, int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-libc.Int64FromUint32((*(*TJumpFixup)(unsafe.Pointer(bp + 796))).FcodeOffset)))
		}
		if XTclFixupForwardJump(tls, envPtr2, bp+844, int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(libc.Int32FromUint32((*TJumpFixup)(unsafe.Pointer(bp+844)).FcodeOffset))), int32(127)) != 0 {
			XTcl_Panic(tls, __ccgo_ts+22120, libc.VaList(bp+888, int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-libc.Int64FromUint32((*(*TJumpFixup)(unsafe.Pointer(bp + 844))).FcodeOffset)))
		}
		/*
		 * Pull the result to top of stack, discard options dict.
		 */
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v169 = envPtr2 + 152
		v168 = *(*uintptr)(unsafe.Pointer(v169))
		*(*uintptr)(unsafe.Pointer(v169))++
		*(*uint8)(unsafe.Pointer(v168)) = libc.Uint8FromInt32(int32(INST_REVERSE))
		v171 = envPtr2 + 152
		v170 = *(*uintptr)(unsafe.Pointer(v171))
		*(*uintptr)(unsafe.Pointer(v171))++
		*(*uint8)(unsafe.Pointer(v170)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
		v173 = envPtr2 + 152
		v172 = *(*uintptr)(unsafe.Pointer(v173))
		*(*uintptr)(unsafe.Pointer(v173))++
		*(*uint8)(unsafe.Pointer(v172)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
		v175 = envPtr2 + 152
		v174 = *(*uintptr)(unsafe.Pointer(v175))
		*(*uintptr)(unsafe.Pointer(v175))++
		*(*uint8)(unsafe.Pointer(v174)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
		v177 = envPtr2 + 152
		v176 = *(*uintptr)(unsafe.Pointer(v177))
		*(*uintptr)(unsafe.Pointer(v177))++
		*(*uint8)(unsafe.Pointer(v176)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(2)
			}
			v178 = delta1
			v179 = envPtr2
			if v178 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v179)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v179)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v179)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v179)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v179 + 64)) += int64(v178)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v181 = envPtr2 + 152
		v180 = *(*uintptr)(unsafe.Pointer(v181))
		*(*uintptr)(unsafe.Pointer(v181))++
		*(*uint8)(unsafe.Pointer(v180)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v182 = delta1
			v183 = envPtr2
			if v182 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v183)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v183)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v183)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v183)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v183 + 64)) += int64(v182)
		}
		/* OK destination */
		if XTclFixupForwardJump(tls, envPtr2, bp+780, int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(libc.Int32FromUint32((*TJumpFixup)(unsafe.Pointer(bp+780)).FcodeOffset))), int32(127)) != 0 {
			XTcl_Panic(tls, __ccgo_ts+22168, libc.VaList(bp+888, int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-libc.Int64FromUint32((*(*TJumpFixup)(unsafe.Pointer(bp + 780))).FcodeOffset)))
		}
		if count > int32(1) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v185 = envPtr2 + 152
			v184 = *(*uintptr)(unsafe.Pointer(v185))
			*(*uintptr)(unsafe.Pointer(v185))++
			*(*uint8)(unsafe.Pointer(v184)) = libc.Uint8FromInt32(int32(INST_STR_CONCAT1))
			v187 = envPtr2 + 152
			v186 = *(*uintptr)(unsafe.Pointer(v187))
			*(*uintptr)(unsafe.Pointer(v187))++
			*(*uint8)(unsafe.Pointer(v186)) = uint8(libc.Uint32FromInt32(count))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STR_CONCAT1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - count
				}
				v188 = delta1
				v189 = envPtr2
				if v188 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v189)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v189)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v189)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v189)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v189 + 64)) += int64(v188)
			}
			count = int32(1)
		}
		/* CONTINUE jump to here */
		if XTclFixupForwardJump(tls, envPtr2, bp+860, int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(libc.Int32FromUint32((*TJumpFixup)(unsafe.Pointer(bp+860)).FcodeOffset))), int32(127)) != 0 {
			XTcl_Panic(tls, __ccgo_ts+22213, libc.VaList(bp+888, int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-libc.Int64FromUint32((*(*TJumpFixup)(unsafe.Pointer(bp + 860))).FcodeOffset)))
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline
		goto _19
	_19:
		;
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	}
	for count > int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v191 = envPtr2 + 152
		v190 = *(*uintptr)(unsafe.Pointer(v191))
		*(*uintptr)(unsafe.Pointer(v191))++
		*(*uint8)(unsafe.Pointer(v190)) = libc.Uint8FromInt32(int32(INST_STR_CONCAT1))
		v193 = envPtr2 + 152
		v192 = *(*uintptr)(unsafe.Pointer(v193))
		*(*uintptr)(unsafe.Pointer(v193))++
		*(*uint8)(unsafe.Pointer(v192)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(255)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STR_CONCAT1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(255)
			}
			v194 = delta1
			v195 = envPtr2
			if v194 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v195)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v195)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v195)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v195)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v195 + 64)) += int64(v194)
		}
		count -= int32(254)
	}
	if count > int32(1) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v197 = envPtr2 + 152
		v196 = *(*uintptr)(unsafe.Pointer(v197))
		*(*uintptr)(unsafe.Pointer(v197))++
		*(*uint8)(unsafe.Pointer(v196)) = libc.Uint8FromInt32(int32(INST_STR_CONCAT1))
		v199 = envPtr2 + 152
		v198 = *(*uintptr)(unsafe.Pointer(v199))
		*(*uintptr)(unsafe.Pointer(v199))++
		*(*uint8)(unsafe.Pointer(v198)) = uint8(libc.Uint32FromInt32(count))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STR_CONCAT1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - count
			}
			v200 = delta1
			v201 = envPtr2
			if v200 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v201)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v201)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v201)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v201)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v201 + 64)) += int64(v200)
		}
	}
	XTcl_FreeParse(tls, bp+8)
	if *(*TTcl_InterpState)(unsafe.Pointer(bp + 752)) != libc.UintptrFromInt32(0) {
		XTcl_RestoreInterpState(tls, interp, *(*TTcl_InterpState)(unsafe.Pointer(bp + 752)))
		XTclCompileSyntaxError(tls, interp, envPtr2)
		v202 = -int32(1)
		v203 = envPtr2
		if v202 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v203)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v203)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v203)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v203)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v203 + 64)) += int64(v202)
	}
	/* Final target of the multi-jump from all BREAKs */
	if breakOffset > 0 {
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(breakOffset))) = libc.Uint8FromInt32(int32(INST_JUMP4))
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(breakOffset) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(breakOffset)) >> libc.Int32FromInt32(24))
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(breakOffset) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(breakOffset)) >> libc.Int32FromInt32(16))
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(breakOffset) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(breakOffset)) >> libc.Int32FromInt32(8))
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(breakOffset) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(breakOffset)))
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileSwitchCmd --
 *
 *	Procedure called to compile the "switch" command.
 *
 * Results:
 *	Returns TCL_OK for successful compile, or TCL_ERROR to defer
 *	evaluation to runtime (either when it is too complex to get the
 *	semantics right, or when we know for sure that it is an error but need
 *	the error to happen at the right time).
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "switch" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileSwitchCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy1785 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Holds resulting instructions. */
	var _objIndexCopy, delta1, foundMode, i1, mode, noCase, numWords, result, valueIndex, v10, v22 int32
	var bodyContLines, bodyLines, bodyToken, bodyTokenArray, chrs, mapPtr, prevBytes, tokenPtr, valueTokenPtr, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v23, v6, v7, v8, v9 uintptr
	var eclIndex, maxLen, numBytes TTcl_Size
	var size Tsize_t
	var _ /* bline at bp+16 */ TTcl_Size
	var _ /* bytes at bp+8 */ uintptr
	var _ /* clNext at bp+0 */ uintptr
	var _ /* literal at bp+24 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, bodyContLines, bodyLines, bodyToken, bodyTokenArray, chrs, delta1, eclIndex, foundMode, i1, mapPtr, maxLen, mode, noCase, numBytes, numWords, prevBytes, result, size, tokenPtr, valueIndex, valueTokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1) /* Has the -nocase flag been given? */
	foundMode = 0
	result = int32(TCL_ERROR)
	*(*uintptr)(unsafe.Pointer(bp)) = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext
	/*
	 * Only handle the following versions:
	 *   switch         ?--? word {pattern body ...}
	 *   switch -exact  ?--? word {pattern body ...}
	 *   switch -glob   ?--? word {pattern body ...}
	 *   switch -regexp ?--? word {pattern body ...}
	 *   switch         --   word simpleWordPattern simpleWordBody ...
	 *   switch -exact  --   word simpleWordPattern simpleWordBody ...
	 *   switch -glob   --   word simpleWordPattern simpleWordBody ...
	 *   switch -regexp --   word simpleWordPattern simpleWordBody ...
	 * When the mode is -glob, can also handle a -nocase flag.
	 *
	 * First off, we don't care how the command's word was generated; we're
	 * compiling it anyway! So skip it...
	 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	valueIndex = int32(1)
	numWords = int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords - int64(1))
	/*
	 * Check for options.
	 */
	noCase = 0
	mode = 0
	if numWords == int32(2) {
		/*
		 * There's just the switch value and the bodies list. In that case, we
		 * can skip all option parsing and move on to consider switch values
		 * and the body list.
		 */
		goto finishedOptionParse
	}
	/*
	 * There must be at least one option, --, because without that there is no
	 * way to statically avoid the problems you get from strings-to-be-matched
	 * that start with a - (the interpreted code falls apart if it encounters
	 * them, so we punt if we *might* encounter them as that is the easiest
	 * way of emulating the behaviour).
	 */
	for {
		if !(numWords >= int32(3)) {
			break
		}
		size = libc.Uint64FromInt64((*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize)
		chrs = (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart
		/*
		 * We only process literal options, and we assume that -e, -g and -n
		 * are unique prefixes of -exact, -glob and -nocase respectively (true
		 * at time of writing). Note that -exact and -glob may only be given
		 * at most once or we bail out (error case).
		 */
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) || size < uint64(2) {
			return int32(TCL_ERROR)
		}
		if size <= uint64(6) && !(libc.Xmemcmp(tls, chrs, __ccgo_ts+17506, size) != 0) {
			if foundMode != 0 {
				return int32(TCL_ERROR)
			}
			mode = 0
			foundMode = int32(1)
			valueIndex++
			goto _1
		} else {
			if size <= uint64(5) && !(libc.Xmemcmp(tls, chrs, __ccgo_ts+17513, size) != 0) {
				if foundMode != 0 {
					return int32(TCL_ERROR)
				}
				mode = 1
				foundMode = int32(1)
				valueIndex++
				goto _1
			} else {
				if size <= uint64(7) && !(libc.Xmemcmp(tls, chrs, __ccgo_ts+17574, size) != 0) {
					if foundMode != 0 {
						return int32(TCL_ERROR)
					}
					mode = 2
					foundMode = int32(1)
					valueIndex++
					goto _1
				} else {
					if size <= uint64(7) && !(libc.Xmemcmp(tls, chrs, __ccgo_ts+17555, size) != 0) {
						noCase = int32(1)
						valueIndex++
						goto _1
					} else {
						if size == uint64(2) && !(libc.Xmemcmp(tls, chrs, __ccgo_ts+18684, uint64(2)) != 0) {
							valueIndex++
							break
						}
					}
				}
			}
		}
		/*
		 * The switch command has many flags we cannot compile at all (e.g.
		 * all the RE-related ones) which we must have encountered. Either
		 * that or we have run off the end. The action here is the same: punt
		 * to interpreted version.
		 */
		return int32(TCL_ERROR)
		goto _1
	_1:
		;
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		numWords--
	}
	if numWords < int32(3) {
		return int32(TCL_ERROR)
	}
	tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	numWords--
	if noCase != 0 && mode == 0 {
		/*
		 * Can't compile this case; no opcode for case-insensitive equality!
		 */
		return int32(TCL_ERROR)
	}
	/*
	 * The value to test against is going to always get pushed on the stack.
	 * But not yet; we need to verify that the rest of the command is
	 * compilable too.
	 */
	goto finishedOptionParse
finishedOptionParse:
	;
	valueTokenPtr = tokenPtr
	/* For valueIndex, see previous loop. */
	tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	numWords--
	/*
	 * Build an array of tokens for the matcher terms and script bodies. Note
	 * that in the case of the quoted bodies, this is tricky as we cannot use
	 * copies of the string from the input token for the generated tokens (it
	 * causes a crash during exception handling). When multiple tokens are
	 * available at this point, this is pretty easy.
	 */
	if !(numWords == int32(1)) {
		goto _2
	} /* TIP #280: line of the pattern/action list,
	 * and start of list for when tracking the
	 * location. This list comes immediately after
	 * the value we switch on. */
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) {
		return int32(TCL_ERROR)
	}
	*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart
	numBytes = (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize
	/* Allocate enough space to work in. */
	maxLen = XTclMaxListLength(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), numBytes, libc.UintptrFromInt32(0))
	if maxLen < int64(2) {
		return int32(TCL_ERROR)
	}
	bodyTokenArray = XTcl_Alloc(tls, uint64(32)*libc.Uint64FromInt64(maxLen))
	bodyToken = XTcl_Alloc(tls, uint64(8)*libc.Uint64FromInt64(maxLen))
	bodyLines = XTcl_Alloc(tls, uint64(8)*libc.Uint64FromInt64(maxLen))
	bodyContLines = XTcl_Alloc(tls, uint64(8)*libc.Uint64FromInt64(maxLen))
	*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(valueIndex+int32(1))*8))
	numWords = 0
	for numBytes > 0 {
		prevBytes = *(*uintptr)(unsafe.Pointer(bp + 8))
		if TCL_OK != XTclFindElement(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 8)), numBytes, bodyTokenArray+uintptr(numWords)*32+8, bp+8, bodyTokenArray+uintptr(numWords)*32+16, bp+24) || !(*(*int32)(unsafe.Pointer(bp + 24)) != 0) {
			goto abort
		}
		(*(*TTcl_Token)(unsafe.Pointer(bodyTokenArray + uintptr(numWords)*32))).Ftype1 = int32(TCL_TOKEN_TEXT)
		(*(*TTcl_Token)(unsafe.Pointer(bodyTokenArray + uintptr(numWords)*32))).FnumComponents = 0
		*(*uintptr)(unsafe.Pointer(bodyToken + uintptr(numWords)*8)) = bodyTokenArray + uintptr(numWords)*32
		/*
		 * TIP #280: Now determine the line the list element starts on
		 * (there is no need to do it earlier, due to the possibility of
		 * aborting, see above).
		 */
		XTclAdvanceLines(tls, bp+16, prevBytes, (*(*TTcl_Token)(unsafe.Pointer(bodyTokenArray + uintptr(numWords)*32))).Fstart)
		XTclAdvanceContinuations(tls, bp+16, bp, int32(int64((*(*TTcl_Token)(unsafe.Pointer(bodyTokenArray + uintptr(numWords)*32))).Fstart)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).Fsource)))
		*(*TTcl_Size)(unsafe.Pointer(bodyLines + uintptr(numWords)*8)) = *(*TTcl_Size)(unsafe.Pointer(bp + 16))
		*(*uintptr)(unsafe.Pointer(bodyContLines + uintptr(numWords)*8)) = *(*uintptr)(unsafe.Pointer(bp))
		XTclAdvanceLines(tls, bp+16, (*(*TTcl_Token)(unsafe.Pointer(bodyTokenArray + uintptr(numWords)*32))).Fstart, *(*uintptr)(unsafe.Pointer(bp + 8)))
		XTclAdvanceContinuations(tls, bp+16, bp, int32(int64(*(*uintptr)(unsafe.Pointer(bp + 8)))-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).Fsource)))
		numBytes -= int64(*(*uintptr)(unsafe.Pointer(bp + 8))) - int64(prevBytes)
		numWords++
	}
	if !(numWords%int32(2) != 0) {
		goto _4
	}
	goto abort
abort:
	;
	XTclpFree(tls, bodyToken)
	XTclpFree(tls, bodyTokenArray)
	XTclpFree(tls, bodyLines)
	XTclpFree(tls, bodyContLines)
	return int32(TCL_ERROR)
_4:
	;
	goto _3
_2:
	;
	if numWords%int32(2) != 0 || numWords == 0 {
		/*
		 * Odd number of words (>1) available, or no words at all available.
		 * Both are error cases, so punt and let the interpreted-version
		 * generate the error message. Note that the second case probably
		 * should get caught earlier, but it's easy to check here again anyway
		 * because it'd cause a nasty crash otherwise.
		 */
		return int32(TCL_ERROR)
	} else {
		/*
		 * Multi-word definition of patterns & actions.
		 */
		bodyToken = XTcl_Alloc(tls, uint64(8)*libc.Uint64FromInt32(numWords))
		bodyLines = XTcl_Alloc(tls, uint64(8)*libc.Uint64FromInt32(numWords))
		bodyContLines = XTcl_Alloc(tls, uint64(8)*libc.Uint64FromInt32(numWords))
		bodyTokenArray = libc.UintptrFromInt32(0)
		i1 = 0
		for {
			if !(i1 < numWords) {
				break
			}
			/*
			 * We only handle the very simplest case. Anything more complex is
			 * a good reason to go to the interpreted case anyway due to
			 * traces, etc.
			 */
			if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) {
				goto freeTemporaries
			}
			*(*uintptr)(unsafe.Pointer(bodyToken + uintptr(i1)*8)) = tokenPtr + uintptr(1)*32
			/*
			 * TIP #280: Copy line information from regular cmd info.
			 */
			*(*TTcl_Size)(unsafe.Pointer(bodyLines + uintptr(i1)*8)) = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(valueIndex+int32(1)+i1)*8))
			*(*uintptr)(unsafe.Pointer(bodyContLines + uintptr(i1)*8)) = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(valueIndex+int32(1)+i1)*8))
			tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
			goto _5
		_5:
			;
			i1++
		}
	}
_3:
	;
	/*
	 * Fall back to interpreted if the last body is a continuation (it's
	 * illegal, but this makes the error happen at the right time).
	 */
	if (*TTcl_Token)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bodyToken + uintptr(numWords-int32(1))*8)))).Fsize == int64(1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_Token)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bodyToken + uintptr(numWords-int32(1))*8)))).Fstart))) == int32('-') {
		goto freeTemporaries
	}
	/*
	 * Now we commit to generating code; the parsing stage per se is done.
	 * Check if we can generate a jump table, since if so that's faster than
	 * doing an explicit compare with each body. Note that we're definitely
	 * over-conservative with determining whether we can do the jump table,
	 * but it handles the most common case well enough.
	 */
	/* Both methods push the value to match against onto the stack. */
	if (*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(valueTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(valueTokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v7 = envPtr2 + 152
			v6 = *(*uintptr)(unsafe.Pointer(v7))
			*(*uintptr)(unsafe.Pointer(v7))++
			*(*uint8)(unsafe.Pointer(v6)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v9 = envPtr2 + 152
			v8 = *(*uintptr)(unsafe.Pointer(v9))
			*(*uintptr)(unsafe.Pointer(v9))++
			*(*uint8)(unsafe.Pointer(v8)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v10 = delta1
				v11 = envPtr2
				if v10 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v11)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v11)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v11)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v11)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v11 + 64)) += int64(v10)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v13 = envPtr2 + 152
			v12 = *(*uintptr)(unsafe.Pointer(v13))
			*(*uintptr)(unsafe.Pointer(v13))++
			*(*uint8)(unsafe.Pointer(v12)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v15 = envPtr2 + 152
			v14 = *(*uintptr)(unsafe.Pointer(v15))
			*(*uintptr)(unsafe.Pointer(v15))++
			*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v17 = envPtr2 + 152
			v16 = *(*uintptr)(unsafe.Pointer(v17))
			*(*uintptr)(unsafe.Pointer(v17))++
			*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v19 = envPtr2 + 152
			v18 = *(*uintptr)(unsafe.Pointer(v19))
			*(*uintptr)(unsafe.Pointer(v19))++
			*(*uint8)(unsafe.Pointer(v18)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v21 = envPtr2 + 152
			v20 = *(*uintptr)(unsafe.Pointer(v21))
			*(*uintptr)(unsafe.Pointer(v21))++
			*(*uint8)(unsafe.Pointer(v20)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v22 = delta1
				v23 = envPtr2
				if v22 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v23)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v23)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v23)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v23)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v23 + 64)) += int64(v22)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(valueIndex)*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(valueIndex)*8))
		XTclCompileTokens(tls, interp, valueTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).FnumComponents), envPtr2)
	}
	if mode == 0 {
		_IssueSwitchJumpTable(tls, interp, envPtr2, numWords, bodyToken, bodyLines, bodyContLines)
	} else {
		_IssueSwitchChainedTests(tls, interp, envPtr2, mode, noCase, int64(numWords), bodyToken, bodyLines, bodyContLines)
	}
	result = TCL_OK
	/*
	 * Clean up all our temporary space and return.
	 */
	goto freeTemporaries
freeTemporaries:
	;
	XTclpFree(tls, bodyToken)
	XTclpFree(tls, bodyLines)
	XTclpFree(tls, bodyContLines)
	if bodyTokenArray != libc.UintptrFromInt32(0) {
		XTclpFree(tls, bodyTokenArray)
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * IssueSwitchChainedTests --
 *
 *	Generate instructions for a [switch] command that is to be compiled
 *	into a sequence of tests. This is the generic handle-everything mode
 *	that inherently has performance that is (on average) linear in the
 *	number of tests. It is the only mode that can handle -glob and -regexp
 *	matches, or anything that is case-insensitive. It does not handle the
 *	wild-and-wooly end of regexp matching (i.e., capture of match results)
 *	so that's when we spill to the interpreted version.
 *
 *----------------------------------------------------------------------
 */

func _IssueSwitchChainedTests(tls *libc.TLS, interp uintptr, envPtr2 uintptr, mode int32, noCase int32, numBodyTokens TTcl_Size, bodyToken uintptr, bodyLines uintptr, bodyContLines uintptr) {
	bp := tls.Alloc(256)
	defer tls.Free(256) /* Array of continuation line info. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, cflags, contFixCount, contFixIndex, delta1, fixupCount, foundDefault, i1, j, j1, nextArmFixupIndex, simple, v100, v105, v109, v115, v12, v127, v16, v28, v34, v36, v41, v53, v59, v71, v83, v85, v90, v94 int32
	var fixupArray, fixupTargetArray, v10, v101, v103, v104, v106, v107, v108, v11, v110, v111, v112, v113, v114, v116, v117, v118, v119, v120, v121, v122, v123, v124, v125, v126, v128, v13, v14, v15, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v29, v30, v31, v32, v33, v35, v37, v38, v39, v40, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v54, v55, v56, v57, v58, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v70, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v82, v84, v86, v87, v88, v89, v91, v92, v93, v95, v96, v97, v98, v99 uintptr
	var _ /* ds at bp+8 */ TTcl_DString
	var _ /* exact at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, cflags, contFixCount, contFixIndex, delta1, fixupArray, fixupCount, fixupTargetArray, foundDefault, i1, j, j1, nextArmFixupIndex, simple, v10, v100, v101, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v123, v124, v125, v126, v127, v128, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99
	/*
	 * Generate a test for each arm.
	 */
	contFixIndex = -int32(1)
	contFixCount = 0
	fixupArray = XTclStackAlloc(tls, interp, uint64(16)*libc.Uint64FromInt64(numBodyTokens))
	fixupTargetArray = XTclStackAlloc(tls, interp, uint64(4)*libc.Uint64FromInt64(numBodyTokens))
	libc.Xmemset(tls, fixupTargetArray, 0, libc.Uint64FromInt64(numBodyTokens)*uint64(4))
	fixupCount = 0
	foundDefault = 0
	i1 = 0
	for {
		if !(int64(i1) < numBodyTokens) {
			break
		}
		nextArmFixupIndex = -int32(1)
		if int64(i1) != numBodyTokens-int64(2) || (*TTcl_Token)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bodyToken + uintptr(numBodyTokens-int64(2))*8)))).Fsize != int64(7) || libc.Xmemcmp(tls, (*TTcl_Token)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bodyToken + uintptr(numBodyTokens-int64(2))*8)))).Fstart, __ccgo_ts+16043, uint64(7)) != 0 {
			/*
			 * Generate the test for the arm.
			 */
			switch mode {
			case 0:
				goto _2
			case 1:
				goto _3
			case 2:
				goto _4
			default:
				goto _5
			}
			goto _6
		_2:
			;
		_9:
			;
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v11 = envPtr2 + 152
			v10 = *(*uintptr)(unsafe.Pointer(v11))
			*(*uintptr)(unsafe.Pointer(v11))++
			*(*uint8)(unsafe.Pointer(v10)) = libc.Uint8FromInt32(int32(INST_DUP))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_DUP)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v12 = delta1
				v13 = envPtr2
				if v12 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v13)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v13)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v13)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v13)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v13 + 64)) += int64(v12)
			}
			goto _8
		_8:
			;
			if 0 != 0 {
				goto _9
			}
			goto _7
		_7:
			;
			XTclCompileTokens(tls, interp, *(*uintptr)(unsafe.Pointer(bodyToken + uintptr(i1)*8)), uint64(1), envPtr2)
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v15 = envPtr2 + 152
			v14 = *(*uintptr)(unsafe.Pointer(v15))
			*(*uintptr)(unsafe.Pointer(v15))++
			*(*uint8)(unsafe.Pointer(v14)) = libc.Uint8FromInt32(int32(INST_STR_EQ))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STR_EQ)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v16 = delta1
				v17 = envPtr2
				if v16 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v17)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v17)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v17)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v17)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v17 + 64)) += int64(v16)
			}
			goto _6
		_3:
			;
			XTclCompileTokens(tls, interp, *(*uintptr)(unsafe.Pointer(bodyToken + uintptr(i1)*8)), uint64(1), envPtr2)
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v19 = envPtr2 + 152
			v18 = *(*uintptr)(unsafe.Pointer(v19))
			*(*uintptr)(unsafe.Pointer(v19))++
			*(*uint8)(unsafe.Pointer(v18)) = libc.Uint8FromInt32(int32(INST_OVER))
			v21 = envPtr2 + 152
			v20 = *(*uintptr)(unsafe.Pointer(v21))
			*(*uintptr)(unsafe.Pointer(v21))++
			*(*uint8)(unsafe.Pointer(v20)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(24))
			v23 = envPtr2 + 152
			v22 = *(*uintptr)(unsafe.Pointer(v23))
			*(*uintptr)(unsafe.Pointer(v23))++
			*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(16))
			v25 = envPtr2 + 152
			v24 = *(*uintptr)(unsafe.Pointer(v25))
			*(*uintptr)(unsafe.Pointer(v25))++
			*(*uint8)(unsafe.Pointer(v24)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(8))
			v27 = envPtr2 + 152
			v26 = *(*uintptr)(unsafe.Pointer(v27))
			*(*uintptr)(unsafe.Pointer(v27))++
			*(*uint8)(unsafe.Pointer(v26)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_OVER)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - int32(1)
				}
				v28 = delta1
				v29 = envPtr2
				if v28 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v29)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v29)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v29)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v29)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v29 + 64)) += int64(v28)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v31 = envPtr2 + 152
			v30 = *(*uintptr)(unsafe.Pointer(v31))
			*(*uintptr)(unsafe.Pointer(v31))++
			*(*uint8)(unsafe.Pointer(v30)) = libc.Uint8FromInt32(int32(INST_STR_MATCH))
			v33 = envPtr2 + 152
			v32 = *(*uintptr)(unsafe.Pointer(v33))
			*(*uintptr)(unsafe.Pointer(v33))++
			*(*uint8)(unsafe.Pointer(v32)) = uint8(libc.Uint32FromInt32(noCase))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STR_MATCH)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - noCase
				}
				v34 = delta1
				v35 = envPtr2
				if v34 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v35)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v35)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v35)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v35)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v35 + 64)) += int64(v34)
			}
			goto _6
		_4:
			;
			v36 = libc.Int32FromInt32(0)
			*(*int32)(unsafe.Pointer(bp)) = v36
			simple = v36
			/*
			 * Keep in sync with TclCompileRegexpCmd.
			 */
			if (*TTcl_Token)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bodyToken + uintptr(i1)*8)))).Ftype1 == int32(TCL_TOKEN_TEXT) {
				if (*TTcl_Token)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bodyToken + uintptr(i1)*8)))).Fsize == 0 {
					/*
					 * The semantics of regexps are that they always match
					 * when the RE == "".
					 */
					_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+21397, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
					if _objIndexCopy <= int32(255) {
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
							XTclExpandCodeArray(tls, envPtr2)
						}
						v38 = envPtr2 + 152
						v37 = *(*uintptr)(unsafe.Pointer(v38))
						*(*uintptr)(unsafe.Pointer(v38))++
						*(*uint8)(unsafe.Pointer(v37)) = libc.Uint8FromInt32(int32(INST_PUSH1))
						v40 = envPtr2 + 152
						v39 = *(*uintptr)(unsafe.Pointer(v40))
						*(*uintptr)(unsafe.Pointer(v40))++
						*(*uint8)(unsafe.Pointer(v39)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
							(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
						}
						delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
						if delta1 != 0 {
							if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
								delta1 = int32(1) - _objIndexCopy
							}
							v41 = delta1
							v42 = envPtr2
							if v41 < libc.Int32FromInt32(0) {
								if int32((*TCompileEnv)(unsafe.Pointer(v42)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v42)).FcurrStackDepth) {
									(*TCompileEnv)(unsafe.Pointer(v42)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v42)).FcurrStackDepth
								}
							}
							*(*TTcl_Size)(unsafe.Pointer(v42 + 64)) += int64(v41)
						}
					} else {
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
							XTclExpandCodeArray(tls, envPtr2)
						}
						v44 = envPtr2 + 152
						v43 = *(*uintptr)(unsafe.Pointer(v44))
						*(*uintptr)(unsafe.Pointer(v44))++
						*(*uint8)(unsafe.Pointer(v43)) = libc.Uint8FromInt32(int32(INST_PUSH4))
						v46 = envPtr2 + 152
						v45 = *(*uintptr)(unsafe.Pointer(v46))
						*(*uintptr)(unsafe.Pointer(v46))++
						*(*uint8)(unsafe.Pointer(v45)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
						v48 = envPtr2 + 152
						v47 = *(*uintptr)(unsafe.Pointer(v48))
						*(*uintptr)(unsafe.Pointer(v48))++
						*(*uint8)(unsafe.Pointer(v47)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
						v50 = envPtr2 + 152
						v49 = *(*uintptr)(unsafe.Pointer(v50))
						*(*uintptr)(unsafe.Pointer(v50))++
						*(*uint8)(unsafe.Pointer(v49)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
						v52 = envPtr2 + 152
						v51 = *(*uintptr)(unsafe.Pointer(v52))
						*(*uintptr)(unsafe.Pointer(v52))++
						*(*uint8)(unsafe.Pointer(v51)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
							(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
						}
						delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
						if delta1 != 0 {
							if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
								delta1 = int32(1) - _objIndexCopy
							}
							v53 = delta1
							v54 = envPtr2
							if v53 < libc.Int32FromInt32(0) {
								if int32((*TCompileEnv)(unsafe.Pointer(v54)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v54)).FcurrStackDepth) {
									(*TCompileEnv)(unsafe.Pointer(v54)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v54)).FcurrStackDepth
								}
							}
							*(*TTcl_Size)(unsafe.Pointer(v54 + 64)) += int64(v53)
						}
					}
					goto _6
				}
				/*
				 * Attempt to convert pattern to glob. If successful, push
				 * the converted pattern.
				 */
				if XTclReToGlob(tls, libc.UintptrFromInt32(0), (*TTcl_Token)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bodyToken + uintptr(i1)*8)))).Fstart, (*TTcl_Token)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bodyToken + uintptr(i1)*8)))).Fsize, bp+8, bp, libc.UintptrFromInt32(0)) == TCL_OK {
					simple = int32(1)
					_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, (*TTcl_DString)(unsafe.Pointer(bp+8)).Fstring1, (*TTcl_DString)(unsafe.Pointer(bp+8)).Flength, 0)
					if _objIndexCopy1 <= int32(255) {
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
							XTclExpandCodeArray(tls, envPtr2)
						}
						v56 = envPtr2 + 152
						v55 = *(*uintptr)(unsafe.Pointer(v56))
						*(*uintptr)(unsafe.Pointer(v56))++
						*(*uint8)(unsafe.Pointer(v55)) = libc.Uint8FromInt32(int32(INST_PUSH1))
						v58 = envPtr2 + 152
						v57 = *(*uintptr)(unsafe.Pointer(v58))
						*(*uintptr)(unsafe.Pointer(v58))++
						*(*uint8)(unsafe.Pointer(v57)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
							(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
						}
						delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
						if delta1 != 0 {
							if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
								delta1 = int32(1) - _objIndexCopy1
							}
							v59 = delta1
							v60 = envPtr2
							if v59 < libc.Int32FromInt32(0) {
								if int32((*TCompileEnv)(unsafe.Pointer(v60)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v60)).FcurrStackDepth) {
									(*TCompileEnv)(unsafe.Pointer(v60)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v60)).FcurrStackDepth
								}
							}
							*(*TTcl_Size)(unsafe.Pointer(v60 + 64)) += int64(v59)
						}
					} else {
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
							XTclExpandCodeArray(tls, envPtr2)
						}
						v62 = envPtr2 + 152
						v61 = *(*uintptr)(unsafe.Pointer(v62))
						*(*uintptr)(unsafe.Pointer(v62))++
						*(*uint8)(unsafe.Pointer(v61)) = libc.Uint8FromInt32(int32(INST_PUSH4))
						v64 = envPtr2 + 152
						v63 = *(*uintptr)(unsafe.Pointer(v64))
						*(*uintptr)(unsafe.Pointer(v64))++
						*(*uint8)(unsafe.Pointer(v63)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
						v66 = envPtr2 + 152
						v65 = *(*uintptr)(unsafe.Pointer(v66))
						*(*uintptr)(unsafe.Pointer(v66))++
						*(*uint8)(unsafe.Pointer(v65)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
						v68 = envPtr2 + 152
						v67 = *(*uintptr)(unsafe.Pointer(v68))
						*(*uintptr)(unsafe.Pointer(v68))++
						*(*uint8)(unsafe.Pointer(v67)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
						v70 = envPtr2 + 152
						v69 = *(*uintptr)(unsafe.Pointer(v70))
						*(*uintptr)(unsafe.Pointer(v70))++
						*(*uint8)(unsafe.Pointer(v69)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
							(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
						}
						delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
						if delta1 != 0 {
							if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
								delta1 = int32(1) - _objIndexCopy1
							}
							v71 = delta1
							v72 = envPtr2
							if v71 < libc.Int32FromInt32(0) {
								if int32((*TCompileEnv)(unsafe.Pointer(v72)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v72)).FcurrStackDepth) {
									(*TCompileEnv)(unsafe.Pointer(v72)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v72)).FcurrStackDepth
								}
							}
							*(*TTcl_Size)(unsafe.Pointer(v72 + 64)) += int64(v71)
						}
					}
					XTcl_DStringFree(tls, bp+8)
				}
			}
			if !(simple != 0) {
				XTclCompileTokens(tls, interp, *(*uintptr)(unsafe.Pointer(bodyToken + uintptr(i1)*8)), uint64(1), envPtr2)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v74 = envPtr2 + 152
			v73 = *(*uintptr)(unsafe.Pointer(v74))
			*(*uintptr)(unsafe.Pointer(v74))++
			*(*uint8)(unsafe.Pointer(v73)) = libc.Uint8FromInt32(int32(INST_OVER))
			v76 = envPtr2 + 152
			v75 = *(*uintptr)(unsafe.Pointer(v76))
			*(*uintptr)(unsafe.Pointer(v76))++
			*(*uint8)(unsafe.Pointer(v75)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(24))
			v78 = envPtr2 + 152
			v77 = *(*uintptr)(unsafe.Pointer(v78))
			*(*uintptr)(unsafe.Pointer(v78))++
			*(*uint8)(unsafe.Pointer(v77)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(16))
			v80 = envPtr2 + 152
			v79 = *(*uintptr)(unsafe.Pointer(v80))
			*(*uintptr)(unsafe.Pointer(v80))++
			*(*uint8)(unsafe.Pointer(v79)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(8))
			v82 = envPtr2 + 152
			v81 = *(*uintptr)(unsafe.Pointer(v82))
			*(*uintptr)(unsafe.Pointer(v82))++
			*(*uint8)(unsafe.Pointer(v81)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_OVER)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - int32(1)
				}
				v83 = delta1
				v84 = envPtr2
				if v83 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v84)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v84)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v84)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v84)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v84 + 64)) += int64(v83)
			}
			if !(simple != 0) {
				if noCase != 0 {
					v85 = int32(TCL_REG_NOCASE)
				} else {
					v85 = 0
				}
				/*
				 * Pass correct RE compile flags. We use only Int1
				 * (8-bit), but that handles all the flags we want to
				 * pass. Don't use TCL_REG_NOSUB as we may have backrefs
				 * or capture vars.
				 */
				cflags = int32(TCL_REG_ADVANCED) | v85
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v87 = envPtr2 + 152
				v86 = *(*uintptr)(unsafe.Pointer(v87))
				*(*uintptr)(unsafe.Pointer(v87))++
				*(*uint8)(unsafe.Pointer(v86)) = libc.Uint8FromInt32(int32(INST_REGEXP))
				v89 = envPtr2 + 152
				v88 = *(*uintptr)(unsafe.Pointer(v89))
				*(*uintptr)(unsafe.Pointer(v89))++
				*(*uint8)(unsafe.Pointer(v88)) = uint8(libc.Uint32FromInt32(cflags))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_REGEXP)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - cflags
					}
					v90 = delta1
					v91 = envPtr2
					if v90 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v91)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v91)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v91)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v91)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v91 + 64)) += int64(v90)
				}
			} else {
				if *(*int32)(unsafe.Pointer(bp)) != 0 && !(noCase != 0) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v93 = envPtr2 + 152
					v92 = *(*uintptr)(unsafe.Pointer(v93))
					*(*uintptr)(unsafe.Pointer(v93))++
					*(*uint8)(unsafe.Pointer(v92)) = libc.Uint8FromInt32(int32(INST_STR_EQ))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_STR_EQ)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - 0
						}
						v94 = delta1
						v95 = envPtr2
						if v94 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v95)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v95)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v95)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v95)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v95 + 64)) += int64(v94)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v97 = envPtr2 + 152
					v96 = *(*uintptr)(unsafe.Pointer(v97))
					*(*uintptr)(unsafe.Pointer(v97))++
					*(*uint8)(unsafe.Pointer(v96)) = libc.Uint8FromInt32(int32(INST_STR_MATCH))
					v99 = envPtr2 + 152
					v98 = *(*uintptr)(unsafe.Pointer(v99))
					*(*uintptr)(unsafe.Pointer(v99))++
					*(*uint8)(unsafe.Pointer(v98)) = uint8(libc.Uint32FromInt32(noCase))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_STR_MATCH)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - noCase
						}
						v100 = delta1
						v101 = envPtr2
						if v100 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v101)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v101)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v101)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v101)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v101 + 64)) += int64(v100)
					}
				}
			}
			goto _6
		_5:
			;
			XTcl_Panic(tls, __ccgo_ts+22259, libc.VaList(bp+240, mode))
		_6:
			;
			/*
			 * In a fall-through case, we will jump on _true_ to the place
			 * where the body starts (generated later, with guarantee of this
			 * ensured earlier; the final body is never a fall-through).
			 */
			if (*TTcl_Token)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bodyToken + uintptr(i1+int32(1))*8)))).Fsize == int64(1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_Token)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bodyToken + uintptr(i1+int32(1))*8)))).Fstart))) == int32('-') {
				if contFixIndex == -int32(1) {
					contFixIndex = fixupCount
					contFixCount = 0
				}
				XTclEmitForwardJump(tls, envPtr2, int32(TCL_TRUE_JUMP), fixupArray+uintptr(contFixIndex+contFixCount)*16)
				fixupCount++
				contFixCount++
				goto _1
			}
			XTclEmitForwardJump(tls, envPtr2, int32(TCL_FALSE_JUMP), fixupArray+uintptr(fixupCount)*16)
			nextArmFixupIndex = fixupCount
			fixupCount++
		} else {
			/*
			 * Got a default clause; set a flag to inhibit the generation of
			 * the jump after the body and the cleanup of the intermediate
			 * value that we are switching against.
			 *
			 * Note that default clauses (which are always terminal clauses)
			 * cannot be fall-through clauses as well, since the last clause
			 * is never a fall-through clause (which we have already
			 * verified).
			 */
			foundDefault = int32(1)
		}
		/*
		 * Generate the body for the arm. This is guaranteed not to be a
		 * fall-through case, but it might have preceding fall-through cases,
		 * so we must process those first.
		 */
		if contFixIndex != -int32(1) {
			j = 0
			for {
				if !(j < contFixCount) {
					break
				}
				*(*uint32)(unsafe.Pointer(fixupTargetArray + uintptr(contFixIndex+j)*4)) = libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
				goto _102
			_102:
				;
				j++
			}
			contFixIndex = -int32(1)
		}
		/*
		 * Now do the actual compilation. Note that we do not use BODY()
		 * because we may have synthesized the tokens in a non-standard
		 * pattern.
		 */
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v104 = envPtr2 + 152
		v103 = *(*uintptr)(unsafe.Pointer(v104))
		*(*uintptr)(unsafe.Pointer(v104))++
		*(*uint8)(unsafe.Pointer(v103)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v105 = delta1
			v106 = envPtr2
			if v105 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v106)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v106)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v106)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v106)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v106 + 64)) += int64(v105)
		}
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer(bodyLines + uintptr(i1+int32(1))*8))     /* TIP #280 */
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer(bodyContLines + uintptr(i1+int32(1))*8)) /* TIP #280 */
		XTclCompileCmdWord(tls, interp, *(*uintptr)(unsafe.Pointer(bodyToken + uintptr(i1+int32(1))*8)), uint64(1), envPtr2)
		if !(foundDefault != 0) {
			XTclEmitForwardJump(tls, envPtr2, int32(TCL_UNCONDITIONAL_JUMP), fixupArray+uintptr(fixupCount)*16)
			fixupCount++
			*(*uint32)(unsafe.Pointer(fixupTargetArray + uintptr(nextArmFixupIndex)*4)) = libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
		}
		goto _1
	_1:
		;
		i1 += int32(2)
	}
	/*
	 * Discard the value we are matching against unless we've had a default
	 * clause (in which case it will already be gone due to the code at the
	 * start of processing an arm, guaranteed) and make the result of the
	 * command an empty string.
	 */
	if !(foundDefault != 0) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v108 = envPtr2 + 152
		v107 = *(*uintptr)(unsafe.Pointer(v108))
		*(*uintptr)(unsafe.Pointer(v108))++
		*(*uint8)(unsafe.Pointer(v107)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v109 = delta1
			v110 = envPtr2
			if v109 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v110)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v110)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v110)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v110)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v110 + 64)) += int64(v109)
		}
		_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy2 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v112 = envPtr2 + 152
			v111 = *(*uintptr)(unsafe.Pointer(v112))
			*(*uintptr)(unsafe.Pointer(v112))++
			*(*uint8)(unsafe.Pointer(v111)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v114 = envPtr2 + 152
			v113 = *(*uintptr)(unsafe.Pointer(v114))
			*(*uintptr)(unsafe.Pointer(v114))++
			*(*uint8)(unsafe.Pointer(v113)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v115 = delta1
				v116 = envPtr2
				if v115 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v116)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v116)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v116)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v116)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v116 + 64)) += int64(v115)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v118 = envPtr2 + 152
			v117 = *(*uintptr)(unsafe.Pointer(v118))
			*(*uintptr)(unsafe.Pointer(v118))++
			*(*uint8)(unsafe.Pointer(v117)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v120 = envPtr2 + 152
			v119 = *(*uintptr)(unsafe.Pointer(v120))
			*(*uintptr)(unsafe.Pointer(v120))++
			*(*uint8)(unsafe.Pointer(v119)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
			v122 = envPtr2 + 152
			v121 = *(*uintptr)(unsafe.Pointer(v122))
			*(*uintptr)(unsafe.Pointer(v122))++
			*(*uint8)(unsafe.Pointer(v121)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
			v124 = envPtr2 + 152
			v123 = *(*uintptr)(unsafe.Pointer(v124))
			*(*uintptr)(unsafe.Pointer(v124))++
			*(*uint8)(unsafe.Pointer(v123)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
			v126 = envPtr2 + 152
			v125 = *(*uintptr)(unsafe.Pointer(v126))
			*(*uintptr)(unsafe.Pointer(v126))++
			*(*uint8)(unsafe.Pointer(v125)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v127 = delta1
				v128 = envPtr2
				if v127 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v128)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v128)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v128)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v128)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v128 + 64)) += int64(v127)
			}
		}
	}
	/*
	 * Do jump fixups for arms that were executed. First, fill in the jumps of
	 * all jumps that don't point elsewhere to point to here.
	 */
	i1 = 0
	for {
		if !(i1 < fixupCount) {
			break
		}
		if *(*uint32)(unsafe.Pointer(fixupTargetArray + uintptr(i1)*4)) == uint32(0) {
			*(*uint32)(unsafe.Pointer(fixupTargetArray + uintptr(i1)*4)) = libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
		}
		goto _129
	_129:
		;
		i1++
	}
	/*
	 * Now scan backwards over all the jumps (all of which are forward jumps)
	 * doing each one. When we do one and there is a size changes, we must
	 * scan back over all the previous ones and see if they need adjusting
	 * before proceeding with further jump fixups (the interleaved nature of
	 * all the jumps makes this impossible to do without nested loops).
	 */
	i1 = fixupCount - int32(1)
	for {
		if !(i1 >= 0) {
			break
		}
		if XTclFixupForwardJump(tls, envPtr2, fixupArray+uintptr(i1)*16, libc.Int32FromUint32(*(*uint32)(unsafe.Pointer(fixupTargetArray + uintptr(i1)*4))-(*(*TJumpFixup)(unsafe.Pointer(fixupArray + uintptr(i1)*16))).FcodeOffset), int32(127)) != 0 {
			j1 = i1 - int32(1)
			for {
				if !(j1 >= 0) {
					break
				}
				if *(*uint32)(unsafe.Pointer(fixupTargetArray + uintptr(j1)*4)) > (*(*TJumpFixup)(unsafe.Pointer(fixupArray + uintptr(i1)*16))).FcodeOffset {
					*(*uint32)(unsafe.Pointer(fixupTargetArray + uintptr(j1)*4)) += uint32(3)
				}
				goto _131
			_131:
				;
				j1--
			}
		}
		goto _130
	_130:
		;
		i1--
	}
	XTclStackFree(tls, interp, fixupTargetArray)
	XTclStackFree(tls, interp, fixupArray)
}

/*
 *----------------------------------------------------------------------
 *
 * IssueSwitchJumpTable --
 *
 *	Generate instructions for a [switch] command that is to be compiled
 *	into a jump table. This only handles the case where case-sensitive,
 *	exact matching is used, but this is actually the most common case in
 *	real code.
 *
 *----------------------------------------------------------------------
 */

func _IssueSwitchJumpTable(tls *libc.TLS, interp uintptr, envPtr2 uintptr, numBodyTokens int32, bodyToken uintptr, bodyLines uintptr, bodyContLines uintptr) {
	bp := tls.Alloc(240)
	defer tls.Free(240) /* Array of continuation line info. */
	var _objIndexCopy, delta1, foundDefault, i1, infoIndex, jumpLocation, jumpToDefault, mustGenerate, numRealBodies, v11, v23, v26, v37, v39, v45, v57 int32
	var finalFixups, hPtr, jtPtr, v1, v10, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v24, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v38, v4, v40, v41, v42, v43, v44, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v58, v6, v7, v8, v9 uintptr
	var _ /* buffer at bp+8 */ TTcl_DString
	var _ /* isNew at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, finalFixups, foundDefault, hPtr, i1, infoIndex, jtPtr, jumpLocation, jumpToDefault, mustGenerate, numRealBodies, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v6, v7, v8, v9
	numRealBodies = 0
	/*
	 * Compile the switch by using a jump table, which is basically a
	 * hashtable that maps from literal values to match against to the offset
	 * (relative to the INST_JUMP_TABLE instruction) to jump to. The jump
	 * table itself is independent of any invocation of the bytecode, and as
	 * such is stored in an auxData block.
	 *
	 * Start by allocating the jump table itself, plus some workspace.
	 */
	jtPtr = XTcl_Alloc(tls, uint64(104))
	XTcl_InitHashTable(tls, jtPtr, TCL_STRING_KEYS)
	infoIndex = int32(XTclCreateAuxData(tls, jtPtr, uintptr(unsafe.Pointer(&XtclJumptableInfoType)), envPtr2))
	finalFixups = XTclStackAlloc(tls, interp, uint64(4)*libc.Uint64FromInt32(numBodyTokens/libc.Int32FromInt32(2)))
	foundDefault = 0
	mustGenerate = int32(1)
	/*
	 * Next, issue the instruction to do the jump, together with what we want
	 * to do if things do not work out (jump to either the default clause or
	 * the "default" default, which just sets the result to empty). Note that
	 * we will come back and rewrite the jump's offset parameter when we know
	 * what it should be, and that all jumps we issue are of the wide kind
	 * because that makes the code much easier to debug!
	 */
	jumpLocation = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v2 = envPtr2 + 152
	v1 = *(*uintptr)(unsafe.Pointer(v2))
	*(*uintptr)(unsafe.Pointer(v2))++
	*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_JUMP_TABLE))
	v4 = envPtr2 + 152
	v3 = *(*uintptr)(unsafe.Pointer(v4))
	*(*uintptr)(unsafe.Pointer(v4))++
	*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(24))
	v6 = envPtr2 + 152
	v5 = *(*uintptr)(unsafe.Pointer(v6))
	*(*uintptr)(unsafe.Pointer(v6))++
	*(*uint8)(unsafe.Pointer(v5)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(16))
	v8 = envPtr2 + 152
	v7 = *(*uintptr)(unsafe.Pointer(v8))
	*(*uintptr)(unsafe.Pointer(v8))++
	*(*uint8)(unsafe.Pointer(v7)) = uint8(libc.Uint32FromInt32(infoIndex) >> libc.Int32FromInt32(8))
	v10 = envPtr2 + 152
	v9 = *(*uintptr)(unsafe.Pointer(v10))
	*(*uintptr)(unsafe.Pointer(v10))++
	*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(infoIndex))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_JUMP_TABLE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - infoIndex
		}
		v11 = delta1
		v12 = envPtr2
		if v11 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v12)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v12)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v12)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v12)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v12 + 64)) += int64(v11)
	}
	jumpToDefault = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v14 = envPtr2 + 152
	v13 = *(*uintptr)(unsafe.Pointer(v14))
	*(*uintptr)(unsafe.Pointer(v14))++
	*(*uint8)(unsafe.Pointer(v13)) = libc.Uint8FromInt32(int32(INST_JUMP4))
	v16 = envPtr2 + 152
	v15 = *(*uintptr)(unsafe.Pointer(v16))
	*(*uintptr)(unsafe.Pointer(v16))++
	*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
	v18 = envPtr2 + 152
	v17 = *(*uintptr)(unsafe.Pointer(v18))
	*(*uintptr)(unsafe.Pointer(v18))++
	*(*uint8)(unsafe.Pointer(v17)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
	v20 = envPtr2 + 152
	v19 = *(*uintptr)(unsafe.Pointer(v20))
	*(*uintptr)(unsafe.Pointer(v20))++
	*(*uint8)(unsafe.Pointer(v19)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
	v22 = envPtr2 + 152
	v21 = *(*uintptr)(unsafe.Pointer(v22))
	*(*uintptr)(unsafe.Pointer(v22))++
	*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_JUMP4)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v23 = delta1
		v24 = envPtr2
		if v23 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v24 + 64)) += int64(v23)
	}
	i1 = 0
	for {
		if !(i1 < numBodyTokens) {
			break
		}
		/*
		 * For each arm, we must first work out what to do with the match
		 * term.
		 */
		if i1 != numBodyTokens-int32(2) || (*TTcl_Token)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bodyToken + uintptr(numBodyTokens-int32(2))*8)))).Fsize != int64(7) || libc.Xmemcmp(tls, (*TTcl_Token)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bodyToken + uintptr(numBodyTokens-int32(2))*8)))).Fstart, __ccgo_ts+16043, uint64(7)) != 0 {
			/*
			 * This is not a default clause, so insert the current location as
			 * a target in the jump table (assuming it isn't already there,
			 * which would indicate that this clause is probably masked by an
			 * earlier one). Note that we use a Tcl_DString here simply
			 * because the hash API does not let us specify the string length.
			 */
			XTcl_DStringInit(tls, bp+8)
			XTcl_DStringAppend(tls, bp+8, (*TTcl_Token)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bodyToken + uintptr(i1)*8)))).Fstart, (*TTcl_Token)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bodyToken + uintptr(i1)*8)))).Fsize)
			hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(jtPtr)).FcreateProc})))(tls, jtPtr, (*TTcl_DString)(unsafe.Pointer(bp+8)).Fstring1, bp)
			if *(*int32)(unsafe.Pointer(bp)) != 0 {
				/*
				 * First time we've encountered this match clause, so it must
				 * point to here.
				 */
				(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = uintptr(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(jumpLocation))
			}
			XTcl_DStringFree(tls, bp+8)
		} else {
			/*
			 * This is a default clause, so patch up the fallthrough from the
			 * INST_JUMP_TABLE instruction to here.
			 */
			foundDefault = int32(1)
			*(*int32)(unsafe.Pointer(bp)) = int32(1)
			*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(jumpToDefault) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(jumpToDefault)) >> libc.Int32FromInt32(24))
			*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(jumpToDefault) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(jumpToDefault)) >> libc.Int32FromInt32(16))
			*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(jumpToDefault) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(jumpToDefault)) >> libc.Int32FromInt32(8))
			*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(jumpToDefault) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(jumpToDefault)))
		}
		/*
		 * Now, for each arm we must deal with the body of the clause.
		 *
		 * If this is a continuation body (never true of a final clause,
		 * whether default or not) we're done because the next jump target
		 * will also point here, so we advance to the next clause.
		 */
		if (*TTcl_Token)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bodyToken + uintptr(i1+int32(1))*8)))).Fsize == int64(1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_Token)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bodyToken + uintptr(i1+int32(1))*8)))).Fstart))) == int32('-') {
			mustGenerate = int32(1)
			goto _25
		}
		/*
		 * Also skip this arm if its only match clause is masked. (We could
		 * probably be more aggressive about this, but that would be much more
		 * difficult to get right.)
		 */
		if !(*(*int32)(unsafe.Pointer(bp)) != 0) && !(mustGenerate != 0) {
			goto _25
		}
		mustGenerate = 0
		/*
		 * Compile the body of the arm.
		 */
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer(bodyLines + uintptr(i1+int32(1))*8))     /* TIP #280 */
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer(bodyContLines + uintptr(i1+int32(1))*8)) /* TIP #280 */
		XTclCompileCmdWord(tls, interp, *(*uintptr)(unsafe.Pointer(bodyToken + uintptr(i1+int32(1))*8)), uint64(1), envPtr2)
		/*
		 * Compile a jump in to the end of the command if this body is
		 * anything other than a user-supplied default arm (to either skip
		 * over the remaining bodies or the code that generates an empty
		 * result).
		 */
		if i1+int32(2) < numBodyTokens || !(foundDefault != 0) {
			v26 = numRealBodies
			numRealBodies++
			*(*int32)(unsafe.Pointer(finalFixups + uintptr(v26)*4)) = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
			/*
			 * Easier by far to issue this jump as a fixed-width jump, since
			 * otherwise we'd need to do a lot more (and more awkward)
			 * rewriting when we fixed this all up.
			 */
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v28 = envPtr2 + 152
			v27 = *(*uintptr)(unsafe.Pointer(v28))
			*(*uintptr)(unsafe.Pointer(v28))++
			*(*uint8)(unsafe.Pointer(v27)) = libc.Uint8FromInt32(int32(INST_JUMP4))
			v30 = envPtr2 + 152
			v29 = *(*uintptr)(unsafe.Pointer(v30))
			*(*uintptr)(unsafe.Pointer(v30))++
			*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
			v32 = envPtr2 + 152
			v31 = *(*uintptr)(unsafe.Pointer(v32))
			*(*uintptr)(unsafe.Pointer(v32))++
			*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
			v34 = envPtr2 + 152
			v33 = *(*uintptr)(unsafe.Pointer(v34))
			*(*uintptr)(unsafe.Pointer(v34))++
			*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
			v36 = envPtr2 + 152
			v35 = *(*uintptr)(unsafe.Pointer(v36))
			*(*uintptr)(unsafe.Pointer(v36))++
			*(*uint8)(unsafe.Pointer(v35)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_JUMP4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v37 = delta1
				v38 = envPtr2
				if v37 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v38)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v38)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v38)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v38)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v38 + 64)) += int64(v37)
			}
			v39 = -int32(1)
			v40 = envPtr2
			if v39 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v40 + 64)) += int64(v39)
		}
		goto _25
	_25:
		;
		i1 += int32(2)
	}
	/*
	 * We're at the end. If we've not already done so through the processing
	 * of a user-supplied default clause, add in a "default" default clause
	 * now.
	 */
	if !(foundDefault != 0) {
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(jumpToDefault) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(jumpToDefault)) >> libc.Int32FromInt32(24))
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(jumpToDefault) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(jumpToDefault)) >> libc.Int32FromInt32(16))
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(jumpToDefault) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(jumpToDefault)) >> libc.Int32FromInt32(8))
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(jumpToDefault) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(jumpToDefault)))
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v42 = envPtr2 + 152
			v41 = *(*uintptr)(unsafe.Pointer(v42))
			*(*uintptr)(unsafe.Pointer(v42))++
			*(*uint8)(unsafe.Pointer(v41)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v44 = envPtr2 + 152
			v43 = *(*uintptr)(unsafe.Pointer(v44))
			*(*uintptr)(unsafe.Pointer(v44))++
			*(*uint8)(unsafe.Pointer(v43)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v45 = delta1
				v46 = envPtr2
				if v45 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v46)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v46)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v46)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v46)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v46 + 64)) += int64(v45)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v48 = envPtr2 + 152
			v47 = *(*uintptr)(unsafe.Pointer(v48))
			*(*uintptr)(unsafe.Pointer(v48))++
			*(*uint8)(unsafe.Pointer(v47)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v50 = envPtr2 + 152
			v49 = *(*uintptr)(unsafe.Pointer(v50))
			*(*uintptr)(unsafe.Pointer(v50))++
			*(*uint8)(unsafe.Pointer(v49)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v52 = envPtr2 + 152
			v51 = *(*uintptr)(unsafe.Pointer(v52))
			*(*uintptr)(unsafe.Pointer(v52))++
			*(*uint8)(unsafe.Pointer(v51)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v54 = envPtr2 + 152
			v53 = *(*uintptr)(unsafe.Pointer(v54))
			*(*uintptr)(unsafe.Pointer(v54))++
			*(*uint8)(unsafe.Pointer(v53)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v56 = envPtr2 + 152
			v55 = *(*uintptr)(unsafe.Pointer(v56))
			*(*uintptr)(unsafe.Pointer(v56))++
			*(*uint8)(unsafe.Pointer(v55)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v57 = delta1
				v58 = envPtr2
				if v57 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v58)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v58)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v58)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v58)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v58 + 64)) += int64(v57)
			}
		}
	}
	/*
	 * No more instructions to be issued; everything that needs to jump to the
	 * end of the command is fixed up at this point.
	 */
	i1 = 0
	for {
		if !(i1 < numRealBodies) {
			break
		}
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(*(*int32)(unsafe.Pointer(finalFixups + uintptr(i1)*4))) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(*(*int32)(unsafe.Pointer(finalFixups + uintptr(i1)*4)))) >> libc.Int32FromInt32(24))
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(*(*int32)(unsafe.Pointer(finalFixups + uintptr(i1)*4))) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(*(*int32)(unsafe.Pointer(finalFixups + uintptr(i1)*4)))) >> libc.Int32FromInt32(16))
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(*(*int32)(unsafe.Pointer(finalFixups + uintptr(i1)*4))) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(*(*int32)(unsafe.Pointer(finalFixups + uintptr(i1)*4)))) >> libc.Int32FromInt32(8))
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(*(*int32)(unsafe.Pointer(finalFixups + uintptr(i1)*4))) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(*(*int32)(unsafe.Pointer(finalFixups + uintptr(i1)*4)))))
		goto _59
	_59:
		;
		i1++
	}
	/*
	 * Clean up all our temporary space and return.
	 */
	XTclStackFree(tls, interp, finalFixups)
}

/*
 *----------------------------------------------------------------------
 *
 * DupJumptableInfo, FreeJumptableInfo --
 *
 *	Functions to duplicate, release and print a jump-table created for use
 *	with the INST_JUMP_TABLE instruction.
 *
 * Results:
 *	DupJumptableInfo: a copy of the jump-table
 *	FreeJumptableInfo: none
 *	PrintJumptableInfo: none
 *	DisassembleJumptableInfo: none
 *
 * Side effects:
 *	DupJumptableInfo: allocates memory
 *	FreeJumptableInfo: releases memory
 *	PrintJumptableInfo: none
 *	DisassembleJumptableInfo: none
 *
 *----------------------------------------------------------------------
 */

func _DupJumptableInfo(tls *libc.TLS, clientData uintptr) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var hPtr, jtPtr, newHPtr, newJtPtr, v2 uintptr
	var _ /* isNew at bp+24 */ int32
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _, _ = hPtr, jtPtr, newHPtr, newJtPtr, v2
	jtPtr = clientData
	newJtPtr = XTcl_Alloc(tls, uint64(104))
	XTcl_InitHashTable(tls, newJtPtr, TCL_STRING_KEYS)
	hPtr = XTcl_FirstHashEntry(tls, jtPtr, bp)
	for {
		if !(hPtr != 0) {
			break
		}
		if (*TTcl_HashTable)(unsafe.Pointer(jtPtr)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(jtPtr)).FkeyType == -int32(1) {
			v2 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
		} else {
			v2 = hPtr + 32
		}
		newHPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(newJtPtr)).FcreateProc})))(tls, newJtPtr, v2, bp+24)
		(*TTcl_HashEntry)(unsafe.Pointer(newHPtr)).FclientData = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		goto _1
	_1:
		;
		hPtr = XTcl_NextHashEntry(tls, bp)
	}
	return newJtPtr
}

func _FreeJumptableInfo(tls *libc.TLS, clientData uintptr) {
	var jtPtr uintptr
	_ = jtPtr
	jtPtr = clientData
	XTcl_DeleteHashTable(tls, jtPtr)
	XTclpFree(tls, jtPtr)
}

func _PrintJumptableInfo(tls *libc.TLS, clientData uintptr, appendObj uintptr, dummy2587 uintptr, pcOffset Tsize_t) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var hPtr, jtPtr, keyPtr, v2 uintptr
	var i, offset, v3 Tsize_t
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _, _ = hPtr, i, jtPtr, keyPtr, offset, v2, v3
	jtPtr = clientData
	i = uint64(0)
	hPtr = XTcl_FirstHashEntry(tls, jtPtr, bp)
	for {
		if !(hPtr != 0) {
			break
		}
		if (*TTcl_HashTable)(unsafe.Pointer(jtPtr)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(jtPtr)).FkeyType == -int32(1) {
			v2 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
		} else {
			v2 = hPtr + 32
		}
		keyPtr = v2
		offset = libc.Uint64FromInt64(int64((*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData))
		v3 = i
		i++
		if v3 != 0 {
			XTcl_AppendToObj(tls, appendObj, __ccgo_ts+21617, int64(-int32(1)))
			if i%uint64(4) == uint64(0) {
				XTcl_AppendToObj(tls, appendObj, __ccgo_ts+22283, int64(-int32(1)))
			}
		}
		XTcl_AppendPrintfToObj(tls, appendObj, __ccgo_ts+22287, libc.VaList(bp+32, keyPtr, pcOffset+offset))
		goto _1
	_1:
		;
		hPtr = XTcl_NextHashEntry(tls, bp)
	}
}

func _DisassembleJumptableInfo(tls *libc.TLS, clientData uintptr, dictObj uintptr, dummy2616 uintptr, dummy2617 Tsize_t) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var cachePtr, hPtr, jtPtr, keyPtr, mapping, v3 uintptr
	var offset Tsize_t
	var v1 bool
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _, _, _ = cachePtr, hPtr, jtPtr, keyPtr, mapping, offset, v1, v3
	jtPtr = clientData
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		mapping = XTclThreadAllocObj(tls)
	} else {
		mapping = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(mapping + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(mapping)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(mapping)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(mapping)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(mapping)).FtypePtr = libc.UintptrFromInt32(0)
	hPtr = XTcl_FirstHashEntry(tls, jtPtr, bp)
	for {
		if !(hPtr != 0) {
			break
		}
		if (*TTcl_HashTable)(unsafe.Pointer(jtPtr)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(jtPtr)).FkeyType == -int32(1) {
			v3 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
		} else {
			v3 = hPtr + 32
		}
		keyPtr = v3
		offset = libc.Uint64FromInt64(int64((*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData))
		XTclDictPut(tls, libc.UintptrFromInt32(0), mapping, keyPtr, XTcl_NewWideIntObj(tls, libc.Int64FromUint64(offset)))
		goto _2
	_2:
		;
		hPtr = XTcl_NextHashEntry(tls, bp)
	}
	XTclDictPut(tls, libc.UintptrFromInt32(0), dictObj, __ccgo_ts+22300, mapping)
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileTailcallCmd --
 *
 *	Procedure called to compile the "tailcall" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "tailcall" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileTailcallCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy2659 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, delta1, i1, v17, v24, v36, v42, v5 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v2, v20, v21, v22, v23, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v37, v38, v39, v4, v40, v41, v43, v6, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, delta1, eclIndex, i1, mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1) /* TIP #280 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords < int64(2) || (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords >= int64(256) || (*TCompileEnv)(unsafe.Pointer(envPtr2)).FprocPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/* make room for the nsObjPtr */
	/* TODO: Doesn't this have to be a known value? */
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	i1 = int32(1)
	for {
		if !(i1 < int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)) {
			break
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy1 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v21 = envPtr2 + 152
				v20 = *(*uintptr)(unsafe.Pointer(v21))
				*(*uintptr)(unsafe.Pointer(v21))++
				*(*uint8)(unsafe.Pointer(v20)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v23 = envPtr2 + 152
				v22 = *(*uintptr)(unsafe.Pointer(v23))
				*(*uintptr)(unsafe.Pointer(v23))++
				*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v24 = delta1
					v25 = envPtr2
					if v24 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v25 + 64)) += int64(v24)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v27 = envPtr2 + 152
				v26 = *(*uintptr)(unsafe.Pointer(v27))
				*(*uintptr)(unsafe.Pointer(v27))++
				*(*uint8)(unsafe.Pointer(v26)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v29 = envPtr2 + 152
				v28 = *(*uintptr)(unsafe.Pointer(v29))
				*(*uintptr)(unsafe.Pointer(v29))++
				*(*uint8)(unsafe.Pointer(v28)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
				v31 = envPtr2 + 152
				v30 = *(*uintptr)(unsafe.Pointer(v31))
				*(*uintptr)(unsafe.Pointer(v31))++
				*(*uint8)(unsafe.Pointer(v30)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
				v33 = envPtr2 + 152
				v32 = *(*uintptr)(unsafe.Pointer(v33))
				*(*uintptr)(unsafe.Pointer(v33))++
				*(*uint8)(unsafe.Pointer(v32)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
				v35 = envPtr2 + 152
				v34 = *(*uintptr)(unsafe.Pointer(v35))
				*(*uintptr)(unsafe.Pointer(v35))++
				*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v36 = delta1
					v37 = envPtr2
					if v36 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v37 + 64)) += int64(v36)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
		}
		goto _19
	_19:
		;
		i1++
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v39 = envPtr2 + 152
	v38 = *(*uintptr)(unsafe.Pointer(v39))
	*(*uintptr)(unsafe.Pointer(v39))++
	*(*uint8)(unsafe.Pointer(v38)) = libc.Uint8FromInt32(int32(INST_TAILCALL))
	v41 = envPtr2 + 152
	v40 = *(*uintptr)(unsafe.Pointer(v41))
	*(*uintptr)(unsafe.Pointer(v41))++
	*(*uint8)(unsafe.Pointer(v40)) = uint8(libc.Uint32FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_TAILCALL)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)
		}
		v42 = delta1
		v43 = envPtr2
		if v42 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v43)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v43)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v43)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v43)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v43 + 64)) += int64(v42)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileThrowCmd --
 *
 *	Procedure called to compile the "throw" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "throw" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileThrowCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy2705 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, _objIndexCopy4, _objIndexCopy5, codeIsList, codeIsValid, codeKnown, delta1, numWords, v100, v104, v110, v122, v134, v144, v148, v152, v156, v162, v174, v18, v180, v192, v204, v24, v36, v42, v54, v56, v6, v64, v76, v83, v96 int32
	var cachePtr, cachePtr1, cachePtr2, codeToken, dictPtr, mapPtr, msgToken, objPtr, v10, v101, v102, v103, v105, v106, v107, v108, v109, v11, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v123, v124, v125, v126, v127, v128, v129, v13, v130, v131, v132, v133, v135, v136, v137, v138, v139, v14, v140, v141, v142, v143, v145, v146, v147, v149, v15, v150, v151, v153, v154, v155, v157, v158, v159, v16, v160, v161, v163, v164, v165, v166, v167, v168, v169, v17, v170, v171, v172, v173, v175, v176, v177, v178, v179, v181, v182, v183, v184, v185, v186, v187, v188, v189, v19, v190, v191, v193, v194, v195, v196, v197, v198, v199, v2, v20, v200, v201, v202, v203, v205, v206, v207, v208, v209, v21, v210, v211, v212, v213, v22, v23, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v37, v38, v39, v4, v40, v41, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v55, v60, v61, v62, v63, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v77, v79, v8, v81, v82, v84, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v95, v97, v98, v99 uintptr
	var eclIndex, v78 TTcl_Size
	var v1, v58, v59, v80 bool
	var v57 int64
	var _ /* len at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, _objIndexCopy4, _objIndexCopy5, cachePtr, cachePtr1, cachePtr2, codeIsList, codeIsValid, codeKnown, codeToken, delta1, dictPtr, eclIndex, mapPtr, msgToken, numWords, objPtr, v1, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v123, v124, v125, v126, v127, v128, v129, v13, v130, v131, v132, v133, v134, v135, v136, v137, v138, v139, v14, v140, v141, v142, v143, v144, v145, v146, v147, v148, v149, v15, v150, v151, v152, v153, v154, v155, v156, v157, v158, v159, v16, v160, v161, v162, v163, v164, v165, v166, v167, v168, v169, v17, v170, v171, v172, v173, v174, v175, v176, v177, v178, v179, v18, v180, v181, v182, v183, v184, v185, v186, v187, v188, v189, v19, v190, v191, v192, v193, v194, v195, v196, v197, v198, v199, v2, v20, v200, v201, v202, v203, v204, v205, v206, v207, v208, v209, v21, v210, v211, v212, v213, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1) /* TIP #280 */
	numWords = int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)
	if numWords != int32(3) {
		return int32(TCL_ERROR)
	}
	codeToken = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	msgToken = codeToken + uintptr((*TTcl_Token)(unsafe.Pointer(codeToken)).FnumComponents+libc.Int64FromInt32(1))*32
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount++
	codeKnown = XTclWordKnownAtCompileTime(tls, codeToken, objPtr)
	/*
	 * First we must emit the code to substitute the arguments.  This
	 * must come first in case substitution raises errors.
	 */
	if !(codeKnown != 0) {
		if (*TTcl_Token)(unsafe.Pointer(codeToken)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(codeToken + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(codeToken + 1*32))).Fsize, 0)
			if _objIndexCopy <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v3 = envPtr2 + 152
				v2 = *(*uintptr)(unsafe.Pointer(v3))
				*(*uintptr)(unsafe.Pointer(v3))++
				*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v5 = envPtr2 + 152
				v4 = *(*uintptr)(unsafe.Pointer(v5))
				*(*uintptr)(unsafe.Pointer(v5))++
				*(*uint8)(unsafe.Pointer(v4)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v6 = delta1
					v7 = envPtr2
					if v6 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v7 + 64)) += int64(v6)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v9 = envPtr2 + 152
				v8 = *(*uintptr)(unsafe.Pointer(v9))
				*(*uintptr)(unsafe.Pointer(v9))++
				*(*uint8)(unsafe.Pointer(v8)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v11 = envPtr2 + 152
				v10 = *(*uintptr)(unsafe.Pointer(v11))
				*(*uintptr)(unsafe.Pointer(v11))++
				*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
				v13 = envPtr2 + 152
				v12 = *(*uintptr)(unsafe.Pointer(v13))
				*(*uintptr)(unsafe.Pointer(v13))++
				*(*uint8)(unsafe.Pointer(v12)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
				v15 = envPtr2 + 152
				v14 = *(*uintptr)(unsafe.Pointer(v15))
				*(*uintptr)(unsafe.Pointer(v15))++
				*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
				v17 = envPtr2 + 152
				v16 = *(*uintptr)(unsafe.Pointer(v17))
				*(*uintptr)(unsafe.Pointer(v17))++
				*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v18 = delta1
					v19 = envPtr2
					if v18 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v19 + 64)) += int64(v18)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
			XTclCompileTokens(tls, interp, codeToken+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(codeToken)).FnumComponents), envPtr2)
		}
		_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+15231, libc.Int64FromUint64(libc.Uint64FromInt64(11)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy1 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v21 = envPtr2 + 152
			v20 = *(*uintptr)(unsafe.Pointer(v21))
			*(*uintptr)(unsafe.Pointer(v21))++
			*(*uint8)(unsafe.Pointer(v20)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v23 = envPtr2 + 152
			v22 = *(*uintptr)(unsafe.Pointer(v23))
			*(*uintptr)(unsafe.Pointer(v23))++
			*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v24 = delta1
				v25 = envPtr2
				if v24 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v25 + 64)) += int64(v24)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v27 = envPtr2 + 152
			v26 = *(*uintptr)(unsafe.Pointer(v27))
			*(*uintptr)(unsafe.Pointer(v27))++
			*(*uint8)(unsafe.Pointer(v26)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v29 = envPtr2 + 152
			v28 = *(*uintptr)(unsafe.Pointer(v29))
			*(*uintptr)(unsafe.Pointer(v29))++
			*(*uint8)(unsafe.Pointer(v28)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
			v31 = envPtr2 + 152
			v30 = *(*uintptr)(unsafe.Pointer(v31))
			*(*uintptr)(unsafe.Pointer(v31))++
			*(*uint8)(unsafe.Pointer(v30)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
			v33 = envPtr2 + 152
			v32 = *(*uintptr)(unsafe.Pointer(v33))
			*(*uintptr)(unsafe.Pointer(v33))++
			*(*uint8)(unsafe.Pointer(v32)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
			v35 = envPtr2 + 152
			v34 = *(*uintptr)(unsafe.Pointer(v35))
			*(*uintptr)(unsafe.Pointer(v35))++
			*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v36 = delta1
				v37 = envPtr2
				if v36 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v37 + 64)) += int64(v36)
			}
		}
	}
	if (*TTcl_Token)(unsafe.Pointer(msgToken)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(msgToken + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(msgToken + 1*32))).Fsize, 0)
		if _objIndexCopy2 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v39 = envPtr2 + 152
			v38 = *(*uintptr)(unsafe.Pointer(v39))
			*(*uintptr)(unsafe.Pointer(v39))++
			*(*uint8)(unsafe.Pointer(v38)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v41 = envPtr2 + 152
			v40 = *(*uintptr)(unsafe.Pointer(v41))
			*(*uintptr)(unsafe.Pointer(v41))++
			*(*uint8)(unsafe.Pointer(v40)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v42 = delta1
				v43 = envPtr2
				if v42 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v43)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v43)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v43)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v43)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v43 + 64)) += int64(v42)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v45 = envPtr2 + 152
			v44 = *(*uintptr)(unsafe.Pointer(v45))
			*(*uintptr)(unsafe.Pointer(v45))++
			*(*uint8)(unsafe.Pointer(v44)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v47 = envPtr2 + 152
			v46 = *(*uintptr)(unsafe.Pointer(v47))
			*(*uintptr)(unsafe.Pointer(v47))++
			*(*uint8)(unsafe.Pointer(v46)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
			v49 = envPtr2 + 152
			v48 = *(*uintptr)(unsafe.Pointer(v49))
			*(*uintptr)(unsafe.Pointer(v49))++
			*(*uint8)(unsafe.Pointer(v48)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
			v51 = envPtr2 + 152
			v50 = *(*uintptr)(unsafe.Pointer(v51))
			*(*uintptr)(unsafe.Pointer(v51))++
			*(*uint8)(unsafe.Pointer(v50)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
			v53 = envPtr2 + 152
			v52 = *(*uintptr)(unsafe.Pointer(v53))
			*(*uintptr)(unsafe.Pointer(v53))++
			*(*uint8)(unsafe.Pointer(v52)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v54 = delta1
				v55 = envPtr2
				if v54 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v55)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v55)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v55)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v55)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v55 + 64)) += int64(v54)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
		XTclCompileTokens(tls, interp, msgToken+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(msgToken)).FnumComponents), envPtr2)
	}
	if v58 = codeKnown != 0; v58 {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr2 != 0 {
				v57 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr2)).FspanLength
			} else {
				v57 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp)) = v57
			v56 = libc.Int32FromInt32(TCL_OK)
		} else {
			v56 = XTcl_ListObjLength(tls, interp, objPtr, bp)
		}
	}
	codeIsList = libc.BoolInt32(v58 && TCL_OK == v56)
	codeIsValid = libc.BoolInt32(codeIsList != 0 && *(*TTcl_Size)(unsafe.Pointer(bp)) != 0)
	if codeIsValid != 0 {
		if v59 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v59 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v59 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			dictPtr = XTclThreadAllocObj(tls)
		} else {
			dictPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(dictPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr = libc.UintptrFromInt32(0)
		XTclDictPut(tls, libc.UintptrFromInt32(0), dictPtr, __ccgo_ts+15231, objPtr)
		_objIndexCopy3 = XTclAddLiteralObj(tls, envPtr2, dictPtr, libc.UintptrFromInt32(0))
		if _objIndexCopy3 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v61 = envPtr2 + 152
			v60 = *(*uintptr)(unsafe.Pointer(v61))
			*(*uintptr)(unsafe.Pointer(v61))++
			*(*uint8)(unsafe.Pointer(v60)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v63 = envPtr2 + 152
			v62 = *(*uintptr)(unsafe.Pointer(v63))
			*(*uintptr)(unsafe.Pointer(v63))++
			*(*uint8)(unsafe.Pointer(v62)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy3
				}
				v64 = delta1
				v65 = envPtr2
				if v64 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v65)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v65)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v65)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v65)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v65 + 64)) += int64(v64)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v67 = envPtr2 + 152
			v66 = *(*uintptr)(unsafe.Pointer(v67))
			*(*uintptr)(unsafe.Pointer(v67))++
			*(*uint8)(unsafe.Pointer(v66)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v69 = envPtr2 + 152
			v68 = *(*uintptr)(unsafe.Pointer(v69))
			*(*uintptr)(unsafe.Pointer(v69))++
			*(*uint8)(unsafe.Pointer(v68)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(24))
			v71 = envPtr2 + 152
			v70 = *(*uintptr)(unsafe.Pointer(v71))
			*(*uintptr)(unsafe.Pointer(v71))++
			*(*uint8)(unsafe.Pointer(v70)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(16))
			v73 = envPtr2 + 152
			v72 = *(*uintptr)(unsafe.Pointer(v73))
			*(*uintptr)(unsafe.Pointer(v73))++
			*(*uint8)(unsafe.Pointer(v72)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(8))
			v75 = envPtr2 + 152
			v74 = *(*uintptr)(unsafe.Pointer(v75))
			*(*uintptr)(unsafe.Pointer(v75))++
			*(*uint8)(unsafe.Pointer(v74)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy3
				}
				v76 = delta1
				v77 = envPtr2
				if v76 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v77)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v77)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v77)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v77)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v77 + 64)) += int64(v76)
			}
		}
	}
	v79 = objPtr
	v78 = *(*TTcl_Size)(unsafe.Pointer(v79))
	*(*TTcl_Size)(unsafe.Pointer(v79))--
	if !(v78 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(-libc.Int32FromInt32(1))
			if v80 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v80 {
				cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v80 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, objPtr)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = objPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, objPtr)
		}
	}
	/*
	 * Simpler bytecodes when we detect invalid arguments at compile time.
	 */
	if codeKnown != 0 && !(codeIsValid != 0) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v82 = envPtr2 + 152
		v81 = *(*uintptr)(unsafe.Pointer(v82))
		*(*uintptr)(unsafe.Pointer(v82))++
		*(*uint8)(unsafe.Pointer(v81)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v83 = delta1
			v84 = envPtr2
			if v83 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v84)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v84)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v84)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v84)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v84 + 64)) += int64(v83)
		}
		if codeIsList != 0 {
			/* Must be an empty list */
			goto issueErrorForEmptyCode
		}
		XTclCompileSyntaxError(tls, interp, envPtr2)
		return TCL_OK
	}
	if !!(codeKnown != 0) {
		goto _85
	}
	/*
	 * Argument validity checking has to be done by bytecode at
	 * run time.
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v87 = envPtr2 + 152
	v86 = *(*uintptr)(unsafe.Pointer(v87))
	*(*uintptr)(unsafe.Pointer(v87))++
	*(*uint8)(unsafe.Pointer(v86)) = libc.Uint8FromInt32(int32(INST_REVERSE))
	v89 = envPtr2 + 152
	v88 = *(*uintptr)(unsafe.Pointer(v89))
	*(*uintptr)(unsafe.Pointer(v89))++
	*(*uint8)(unsafe.Pointer(v88)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)) >> libc.Int32FromInt32(24))
	v91 = envPtr2 + 152
	v90 = *(*uintptr)(unsafe.Pointer(v91))
	*(*uintptr)(unsafe.Pointer(v91))++
	*(*uint8)(unsafe.Pointer(v90)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)) >> libc.Int32FromInt32(16))
	v93 = envPtr2 + 152
	v92 = *(*uintptr)(unsafe.Pointer(v93))
	*(*uintptr)(unsafe.Pointer(v93))++
	*(*uint8)(unsafe.Pointer(v92)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)) >> libc.Int32FromInt32(8))
	v95 = envPtr2 + 152
	v94 = *(*uintptr)(unsafe.Pointer(v95))
	*(*uintptr)(unsafe.Pointer(v95))++
	*(*uint8)(unsafe.Pointer(v94)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32(3)
		}
		v96 = delta1
		v97 = envPtr2
		if v96 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v97)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v97)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v97)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v97)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v97 + 64)) += int64(v96)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v99 = envPtr2 + 152
	v98 = *(*uintptr)(unsafe.Pointer(v99))
	*(*uintptr)(unsafe.Pointer(v99))++
	*(*uint8)(unsafe.Pointer(v98)) = libc.Uint8FromInt32(int32(INST_DUP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_DUP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v100 = delta1
		v101 = envPtr2
		if v100 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v101)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v101)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v101)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v101)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v101 + 64)) += int64(v100)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v103 = envPtr2 + 152
	v102 = *(*uintptr)(unsafe.Pointer(v103))
	*(*uintptr)(unsafe.Pointer(v103))++
	*(*uint8)(unsafe.Pointer(v102)) = libc.Uint8FromInt32(int32(INST_LIST_LENGTH))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_LIST_LENGTH)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v104 = delta1
		v105 = envPtr2
		if v104 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v105)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v105)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v105)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v105)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v105 + 64)) += int64(v104)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v107 = envPtr2 + 152
	v106 = *(*uintptr)(unsafe.Pointer(v107))
	*(*uintptr)(unsafe.Pointer(v107))++
	*(*uint8)(unsafe.Pointer(v106)) = libc.Uint8FromInt32(int32(INST_JUMP_FALSE1))
	v109 = envPtr2 + 152
	v108 = *(*uintptr)(unsafe.Pointer(v109))
	*(*uintptr)(unsafe.Pointer(v109))++
	*(*uint8)(unsafe.Pointer(v108)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(16)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_JUMP_FALSE1)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32(16)
		}
		v110 = delta1
		v111 = envPtr2
		if v110 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v111)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v111)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v111)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v111)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v111 + 64)) += int64(v110)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v113 = envPtr2 + 152
	v112 = *(*uintptr)(unsafe.Pointer(v113))
	*(*uintptr)(unsafe.Pointer(v113))++
	*(*uint8)(unsafe.Pointer(v112)) = libc.Uint8FromInt32(int32(INST_LIST))
	v115 = envPtr2 + 152
	v114 = *(*uintptr)(unsafe.Pointer(v115))
	*(*uintptr)(unsafe.Pointer(v115))++
	*(*uint8)(unsafe.Pointer(v114)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
	v117 = envPtr2 + 152
	v116 = *(*uintptr)(unsafe.Pointer(v117))
	*(*uintptr)(unsafe.Pointer(v117))++
	*(*uint8)(unsafe.Pointer(v116)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
	v119 = envPtr2 + 152
	v118 = *(*uintptr)(unsafe.Pointer(v119))
	*(*uintptr)(unsafe.Pointer(v119))++
	*(*uint8)(unsafe.Pointer(v118)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
	v121 = envPtr2 + 152
	v120 = *(*uintptr)(unsafe.Pointer(v121))
	*(*uintptr)(unsafe.Pointer(v121))++
	*(*uint8)(unsafe.Pointer(v120)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_LIST)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32(2)
		}
		v122 = delta1
		v123 = envPtr2
		if v122 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v123)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v123)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v123)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v123)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v123 + 64)) += int64(v122)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v125 = envPtr2 + 152
	v124 = *(*uintptr)(unsafe.Pointer(v125))
	*(*uintptr)(unsafe.Pointer(v125))++
	*(*uint8)(unsafe.Pointer(v124)) = libc.Uint8FromInt32(int32(INST_RETURN_IMM))
	v127 = envPtr2 + 152
	v126 = *(*uintptr)(unsafe.Pointer(v127))
	*(*uintptr)(unsafe.Pointer(v127))++
	*(*uint8)(unsafe.Pointer(v126)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(TCL_ERROR)) >> libc.Int32FromInt32(24))
	v129 = envPtr2 + 152
	v128 = *(*uintptr)(unsafe.Pointer(v129))
	*(*uintptr)(unsafe.Pointer(v129))++
	*(*uint8)(unsafe.Pointer(v128)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(TCL_ERROR)) >> libc.Int32FromInt32(16))
	v131 = envPtr2 + 152
	v130 = *(*uintptr)(unsafe.Pointer(v131))
	*(*uintptr)(unsafe.Pointer(v131))++
	*(*uint8)(unsafe.Pointer(v130)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(TCL_ERROR)) >> libc.Int32FromInt32(8))
	v133 = envPtr2 + 152
	v132 = *(*uintptr)(unsafe.Pointer(v133))
	*(*uintptr)(unsafe.Pointer(v133))++
	*(*uint8)(unsafe.Pointer(v132)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(TCL_ERROR)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_RETURN_IMM)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32(TCL_ERROR)
		}
		v134 = delta1
		v135 = envPtr2
		if v134 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v135)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v135)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v135)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v135)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v135 + 64)) += int64(v134)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v137 = envPtr2 + 152
	v136 = *(*uintptr)(unsafe.Pointer(v137))
	*(*uintptr)(unsafe.Pointer(v137))++
	*(*uint8)(unsafe.Pointer(v136)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
	v139 = envPtr2 + 152
	v138 = *(*uintptr)(unsafe.Pointer(v139))
	*(*uintptr)(unsafe.Pointer(v139))++
	*(*uint8)(unsafe.Pointer(v138)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
	v141 = envPtr2 + 152
	v140 = *(*uintptr)(unsafe.Pointer(v141))
	*(*uintptr)(unsafe.Pointer(v141))++
	*(*uint8)(unsafe.Pointer(v140)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
	v143 = envPtr2 + 152
	v142 = *(*uintptr)(unsafe.Pointer(v143))
	*(*uintptr)(unsafe.Pointer(v143))++
	*(*uint8)(unsafe.Pointer(v142)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
	v144 = int32(2)
	v145 = envPtr2
	if v144 < libc.Int32FromInt32(0) {
		if int32((*TCompileEnv)(unsafe.Pointer(v145)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v145)).FcurrStackDepth) {
			(*TCompileEnv)(unsafe.Pointer(v145)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v145)).FcurrStackDepth
		}
	}
	*(*TTcl_Size)(unsafe.Pointer(v145 + 64)) += int64(v144)
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v147 = envPtr2 + 152
	v146 = *(*uintptr)(unsafe.Pointer(v147))
	*(*uintptr)(unsafe.Pointer(v147))++
	*(*uint8)(unsafe.Pointer(v146)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v148 = delta1
		v149 = envPtr2
		if v148 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v149)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v149)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v149)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v149)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v149 + 64)) += int64(v148)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v151 = envPtr2 + 152
	v150 = *(*uintptr)(unsafe.Pointer(v151))
	*(*uintptr)(unsafe.Pointer(v151))++
	*(*uint8)(unsafe.Pointer(v150)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v152 = delta1
		v153 = envPtr2
		if v152 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v153)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v153)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v153)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v153)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v153 + 64)) += int64(v152)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v155 = envPtr2 + 152
	v154 = *(*uintptr)(unsafe.Pointer(v155))
	*(*uintptr)(unsafe.Pointer(v155))++
	*(*uint8)(unsafe.Pointer(v154)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v156 = delta1
		v157 = envPtr2
		if v156 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v157)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v157)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v157)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v157)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v157 + 64)) += int64(v156)
	}
	goto issueErrorForEmptyCode
issueErrorForEmptyCode:
	;
	_objIndexCopy4 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+20541, libc.Int64FromUint64(libc.Uint64FromInt64(28)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy4 <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v159 = envPtr2 + 152
		v158 = *(*uintptr)(unsafe.Pointer(v159))
		*(*uintptr)(unsafe.Pointer(v159))++
		*(*uint8)(unsafe.Pointer(v158)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v161 = envPtr2 + 152
		v160 = *(*uintptr)(unsafe.Pointer(v161))
		*(*uintptr)(unsafe.Pointer(v161))++
		*(*uint8)(unsafe.Pointer(v160)) = uint8(libc.Uint32FromInt32(_objIndexCopy4))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy4
			}
			v162 = delta1
			v163 = envPtr2
			if v162 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v163)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v163)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v163)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v163)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v163 + 64)) += int64(v162)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v165 = envPtr2 + 152
		v164 = *(*uintptr)(unsafe.Pointer(v165))
		*(*uintptr)(unsafe.Pointer(v165))++
		*(*uint8)(unsafe.Pointer(v164)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v167 = envPtr2 + 152
		v166 = *(*uintptr)(unsafe.Pointer(v167))
		*(*uintptr)(unsafe.Pointer(v167))++
		*(*uint8)(unsafe.Pointer(v166)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(24))
		v169 = envPtr2 + 152
		v168 = *(*uintptr)(unsafe.Pointer(v169))
		*(*uintptr)(unsafe.Pointer(v169))++
		*(*uint8)(unsafe.Pointer(v168)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(16))
		v171 = envPtr2 + 152
		v170 = *(*uintptr)(unsafe.Pointer(v171))
		*(*uintptr)(unsafe.Pointer(v171))++
		*(*uint8)(unsafe.Pointer(v170)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(8))
		v173 = envPtr2 + 152
		v172 = *(*uintptr)(unsafe.Pointer(v173))
		*(*uintptr)(unsafe.Pointer(v173))++
		*(*uint8)(unsafe.Pointer(v172)) = uint8(libc.Uint32FromInt32(_objIndexCopy4))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy4
			}
			v174 = delta1
			v175 = envPtr2
			if v174 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v175)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v175)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v175)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v175)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v175 + 64)) += int64(v174)
		}
	}
	_objIndexCopy5 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+22308, libc.Int64FromUint64(libc.Uint64FromInt64(46)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy5 <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v177 = envPtr2 + 152
		v176 = *(*uintptr)(unsafe.Pointer(v177))
		*(*uintptr)(unsafe.Pointer(v177))++
		*(*uint8)(unsafe.Pointer(v176)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v179 = envPtr2 + 152
		v178 = *(*uintptr)(unsafe.Pointer(v179))
		*(*uintptr)(unsafe.Pointer(v179))++
		*(*uint8)(unsafe.Pointer(v178)) = uint8(libc.Uint32FromInt32(_objIndexCopy5))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy5
			}
			v180 = delta1
			v181 = envPtr2
			if v180 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v181)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v181)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v181)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v181)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v181 + 64)) += int64(v180)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v183 = envPtr2 + 152
		v182 = *(*uintptr)(unsafe.Pointer(v183))
		*(*uintptr)(unsafe.Pointer(v183))++
		*(*uint8)(unsafe.Pointer(v182)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v185 = envPtr2 + 152
		v184 = *(*uintptr)(unsafe.Pointer(v185))
		*(*uintptr)(unsafe.Pointer(v185))++
		*(*uint8)(unsafe.Pointer(v184)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(24))
		v187 = envPtr2 + 152
		v186 = *(*uintptr)(unsafe.Pointer(v187))
		*(*uintptr)(unsafe.Pointer(v187))++
		*(*uint8)(unsafe.Pointer(v186)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(16))
		v189 = envPtr2 + 152
		v188 = *(*uintptr)(unsafe.Pointer(v189))
		*(*uintptr)(unsafe.Pointer(v189))++
		*(*uint8)(unsafe.Pointer(v188)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(8))
		v191 = envPtr2 + 152
		v190 = *(*uintptr)(unsafe.Pointer(v191))
		*(*uintptr)(unsafe.Pointer(v191))++
		*(*uint8)(unsafe.Pointer(v190)) = uint8(libc.Uint32FromInt32(_objIndexCopy5))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy5
			}
			v192 = delta1
			v193 = envPtr2
			if v192 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v193)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v193)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v193)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v193)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v193 + 64)) += int64(v192)
		}
	}
_85:
	;
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v195 = envPtr2 + 152
	v194 = *(*uintptr)(unsafe.Pointer(v195))
	*(*uintptr)(unsafe.Pointer(v195))++
	*(*uint8)(unsafe.Pointer(v194)) = libc.Uint8FromInt32(int32(INST_RETURN_IMM))
	v197 = envPtr2 + 152
	v196 = *(*uintptr)(unsafe.Pointer(v197))
	*(*uintptr)(unsafe.Pointer(v197))++
	*(*uint8)(unsafe.Pointer(v196)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(TCL_ERROR)) >> libc.Int32FromInt32(24))
	v199 = envPtr2 + 152
	v198 = *(*uintptr)(unsafe.Pointer(v199))
	*(*uintptr)(unsafe.Pointer(v199))++
	*(*uint8)(unsafe.Pointer(v198)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(TCL_ERROR)) >> libc.Int32FromInt32(16))
	v201 = envPtr2 + 152
	v200 = *(*uintptr)(unsafe.Pointer(v201))
	*(*uintptr)(unsafe.Pointer(v201))++
	*(*uint8)(unsafe.Pointer(v200)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(TCL_ERROR)) >> libc.Int32FromInt32(8))
	v203 = envPtr2 + 152
	v202 = *(*uintptr)(unsafe.Pointer(v203))
	*(*uintptr)(unsafe.Pointer(v203))++
	*(*uint8)(unsafe.Pointer(v202)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(TCL_ERROR)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_RETURN_IMM)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32(TCL_ERROR)
		}
		v204 = delta1
		v205 = envPtr2
		if v204 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v205)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v205)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v205)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v205)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v205 + 64)) += int64(v204)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v207 = envPtr2 + 152
	v206 = *(*uintptr)(unsafe.Pointer(v207))
	*(*uintptr)(unsafe.Pointer(v207))++
	*(*uint8)(unsafe.Pointer(v206)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
	v209 = envPtr2 + 152
	v208 = *(*uintptr)(unsafe.Pointer(v209))
	*(*uintptr)(unsafe.Pointer(v209))++
	*(*uint8)(unsafe.Pointer(v208)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
	v211 = envPtr2 + 152
	v210 = *(*uintptr)(unsafe.Pointer(v211))
	*(*uintptr)(unsafe.Pointer(v211))++
	*(*uint8)(unsafe.Pointer(v210)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
	v213 = envPtr2 + 152
	v212 = *(*uintptr)(unsafe.Pointer(v213))
	*(*uintptr)(unsafe.Pointer(v213))++
	*(*uint8)(unsafe.Pointer(v212)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileTryCmd --
 *
 *	Procedure called to compile the "try" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "try" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileTryCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy2808 uintptr, envPtr uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Holds resulting instructions. */
	var bodyToken, cachePtr, cachePtr1, cachePtr10, cachePtr11, cachePtr12, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cachePtr8, cachePtr9, finallyToken, handlerTokens, mapPtr, matchClauses, matchCodes, optionVarIndices, resultVarIndices, tmpObj, tokenPtr, varname, varname1, v11, v14, v17, v21, v27, v29, v31, v33, v35, v38, v42, v7 uintptr
	var eclIndex, v10, v13, v16, v20, v26, v30, v34, v37, v41, v6 TTcl_Size
	var i, numHandlers, numWords, result, v23, v3 int32
	var v12, v15, v18, v19, v2, v22, v28, v32, v36, v39, v43, v5, v8, v9 bool
	var v24, v25, v4 int64
	var _ /* code at bp+16 */ int32
	var _ /* len at bp+24 */ TTcl_Size
	var _ /* len at bp+32 */ TTcl_Size
	var _ /* objc at bp+8 */ TTcl_Size
	var _ /* objv at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bodyToken, cachePtr, cachePtr1, cachePtr10, cachePtr11, cachePtr12, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cachePtr8, cachePtr9, eclIndex, finallyToken, handlerTokens, i, mapPtr, matchClauses, matchCodes, numHandlers, numWords, optionVarIndices, result, resultVarIndices, tmpObj, tokenPtr, varname, varname1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v41, v42, v43, v5, v6, v7, v8, v9
	numWords = int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)
	result = int32(TCL_ERROR)
	handlerTokens = libc.UintptrFromInt32(0)
	matchClauses = libc.UintptrFromInt32(0)
	matchCodes = libc.UintptrFromInt32(0)
	resultVarIndices = libc.UintptrFromInt32(0)
	optionVarIndices = libc.UintptrFromInt32(0)
	if numWords < int32(2) {
		return int32(TCL_ERROR)
	}
	bodyToken = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if numWords == int32(2) {
		/*
		 * No handlers or finally; do nothing beyond evaluating the body.
		 */
		mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr
		eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1) /* TIP #280 */
		(*TCompileEnv)(unsafe.Pointer(envPtr)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileCmdWord(tls, interp, bodyToken+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(bodyToken)).FnumComponents), envPtr)
		return TCL_OK
	}
	numWords -= int32(2)
	tokenPtr = bodyToken + uintptr((*TTcl_Token)(unsafe.Pointer(bodyToken)).FnumComponents+libc.Int64FromInt32(1))*32
	/*
	 * Extract information about what handlers there are.
	 */
	numHandlers = numWords >> int32(2)
	numWords -= numHandlers * int32(4)
	if numHandlers > 0 {
		handlerTokens = XTclStackAlloc(tls, interp, uint64(8)*libc.Uint64FromInt32(numHandlers))
		matchClauses = XTclStackAlloc(tls, interp, uint64(8)*libc.Uint64FromInt32(numHandlers))
		libc.Xmemset(tls, matchClauses, 0, uint64(8)*libc.Uint64FromInt32(numHandlers))
		matchCodes = XTclStackAlloc(tls, interp, uint64(4)*libc.Uint64FromInt32(numHandlers))
		resultVarIndices = XTclStackAlloc(tls, interp, uint64(4)*libc.Uint64FromInt32(numHandlers))
		optionVarIndices = XTclStackAlloc(tls, interp, uint64(4)*libc.Uint64FromInt32(numHandlers))
		i = 0
		for {
			if !(i < numHandlers) {
				break
			}
			if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) {
				goto failedToCompile
			}
			if (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize == int64(4) && !(libc.Xstrncmp(tls, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, __ccgo_ts+20805, uint64(4)) != 0) {
				/*
				 * Parse the list of errorCode words to match against.
				 */
				*(*int32)(unsafe.Pointer(matchCodes + uintptr(i)*4)) = int32(TCL_ERROR)
				tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
				if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
					tmpObj = XTclThreadAllocObj(tls)
				} else {
					tmpObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(tmpObj + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = 0
				(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr = libc.UintptrFromInt32(0)
				(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FrefCount++
				if v5 = !(XTclWordKnownAtCompileTime(tls, tokenPtr, tmpObj) != 0); !v5 {
					if (*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
						if (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(tmpObj + 32))).Fptr2 != 0 {
							v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(tmpObj + 32))).Fptr2)).FspanLength
						} else {
							v4 = (*TListStore)(unsafe.Pointer((*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(tmpObj + 32))).Fptr1)).FnumUsed
						}
						*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v4
						v3 = libc.Int32FromInt32(TCL_OK)
					} else {
						v3 = XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), tmpObj, bp+8)
					}
				}
				if v5 || v3 != TCL_OK || *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == 0 {
					v7 = tmpObj
					v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
					*(*TTcl_Size)(unsafe.Pointer(v7))--
					if !(v6 > int64(1)) {
						if !((*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr)).FfreeIntRepProc != 0) {
							if (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
								XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes)
							}
							(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = int64(-libc.Int32FromInt32(1))
							if v8 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v8 {
								cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
							}
							if v8 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
								XTclThreadFreeObj(tls, tmpObj)
							} else {
								(*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer(tmpObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
								(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = tmpObj
								(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
							}
						} else {
							XTclFreeObj(tls, tmpObj)
						}
					}
					goto failedToCompile
				}
				XTcl_ListObjReplace(tls, libc.UintptrFromInt32(0), tmpObj, 0, 0, 0, libc.UintptrFromInt32(0))
				*(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i)*8)) = tmpObj
			} else {
				if (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize == int64(2) && !(libc.Xstrncmp(tls, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, __ccgo_ts+20802, uint64(2)) != 0) {
					/*
					 * Parse the result code to look for.
					 */
					tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
					if v9 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v9 {
						cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v9 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
						tmpObj = XTclThreadAllocObj(tls)
					} else {
						tmpObj = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(tmpObj + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FrefCount = 0
					(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = 0
					(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr = libc.UintptrFromInt32(0)
					(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FrefCount++
					if !(XTclWordKnownAtCompileTime(tls, tokenPtr, tmpObj) != 0) {
						v11 = tmpObj
						v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
						*(*TTcl_Size)(unsafe.Pointer(v11))--
						if !(v10 > int64(1)) {
							if !((*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr)).FfreeIntRepProc != 0) {
								if (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
									XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes)
								}
								(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = int64(-libc.Int32FromInt32(1))
								if v12 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v12 {
									cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
								}
								if v12 || ((*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
									XTclThreadFreeObj(tls, tmpObj)
								} else {
									(*(*struct {
										Fptr1 uintptr
										Fptr2 uintptr
									})(unsafe.Pointer(tmpObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
									(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = tmpObj
									(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects++
								}
							} else {
								XTclFreeObj(tls, tmpObj)
							}
						}
						goto failedToCompile
					}
					if int32(TCL_ERROR) == XTclGetCompletionCodeFromObj(tls, libc.UintptrFromInt32(0), tmpObj, bp+16) {
						v14 = tmpObj
						v13 = *(*TTcl_Size)(unsafe.Pointer(v14))
						*(*TTcl_Size)(unsafe.Pointer(v14))--
						if !(v13 > int64(1)) {
							if !((*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr)).FfreeIntRepProc != 0) {
								if (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
									XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes)
								}
								(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = int64(-libc.Int32FromInt32(1))
								if v15 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v15 {
									cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
								}
								if v15 || ((*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
									XTclThreadFreeObj(tls, tmpObj)
								} else {
									(*(*struct {
										Fptr1 uintptr
										Fptr2 uintptr
									})(unsafe.Pointer(tmpObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
									(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = tmpObj
									(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects++
								}
							} else {
								XTclFreeObj(tls, tmpObj)
							}
						}
						goto failedToCompile
					}
					*(*int32)(unsafe.Pointer(matchCodes + uintptr(i)*4)) = *(*int32)(unsafe.Pointer(bp + 16))
					v17 = tmpObj
					v16 = *(*TTcl_Size)(unsafe.Pointer(v17))
					*(*TTcl_Size)(unsafe.Pointer(v17))--
					if !(v16 > int64(1)) {
						if !((*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr)).FfreeIntRepProc != 0) {
							if (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
								XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes)
							}
							(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = int64(-libc.Int32FromInt32(1))
							if v18 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v18 {
								cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
							}
							if v18 || ((*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
								XTclThreadFreeObj(tls, tmpObj)
							} else {
								(*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer(tmpObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
								(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = tmpObj
								(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects++
							}
						} else {
							XTclFreeObj(tls, tmpObj)
						}
					}
				} else {
					goto failedToCompile
				}
			}
			/*
			 * Parse the variable binding.
			 */
			tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
			if v19 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v19 {
				cachePtr6 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v19 || (*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects == libc.Uint64FromInt32(0) {
				tmpObj = XTclThreadAllocObj(tls)
			} else {
				tmpObj = (*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(tmpObj + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr = libc.UintptrFromInt32(0)
			(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FrefCount++
			if !(XTclWordKnownAtCompileTime(tls, tokenPtr, tmpObj) != 0) {
				v21 = tmpObj
				v20 = *(*TTcl_Size)(unsafe.Pointer(v21))
				*(*TTcl_Size)(unsafe.Pointer(v21))--
				if !(v20 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = int64(-libc.Int32FromInt32(1))
						if v22 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v22 {
							cachePtr7 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v22 || ((*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, tmpObj)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(tmpObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr = tmpObj
							(*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, tmpObj)
					}
				}
				goto failedToCompile
			}
			if (*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(tmpObj + 32))).Fptr2 != 0 {
					v24 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(tmpObj + 32))).Fptr2)).FspanStart
				} else {
					v24 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(tmpObj + 32))).Fptr1)).FfirstUsed
				}
				*(*uintptr)(unsafe.Pointer(bp)) = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(tmpObj + 32))).Fptr1 + 40 + uintptr(v24)*8
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(tmpObj + 32))).Fptr2 != 0 {
					v25 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(tmpObj + 32))).Fptr2)).FspanLength
				} else {
					v25 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(tmpObj + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v25
				v23 = libc.Int32FromInt32(TCL_OK)
			} else {
				v23 = XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), tmpObj, bp+8, bp)
			}
			if v23 != TCL_OK || *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > int64(2) {
				v27 = tmpObj
				v26 = *(*TTcl_Size)(unsafe.Pointer(v27))
				*(*TTcl_Size)(unsafe.Pointer(v27))--
				if !(v26 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = int64(-libc.Int32FromInt32(1))
						if v28 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v28 {
							cachePtr8 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v28 || ((*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, tmpObj)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(tmpObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr8)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr8)).FfirstObjPtr = tmpObj
							(*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, tmpObj)
					}
				}
				goto failedToCompile
			}
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > 0 {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))).Fbytes != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))).Flength
					v29 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))).Fbytes
				} else {
					v29 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))), bp+24)
				}
				varname = v29
				*(*int32)(unsafe.Pointer(resultVarIndices + uintptr(i)*4)) = libc.Int32FromUint64(XTclLocalScalar(tls, varname, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 24))), envPtr))
				if *(*int32)(unsafe.Pointer(resultVarIndices + uintptr(i)*4)) < 0 {
					v31 = tmpObj
					v30 = *(*TTcl_Size)(unsafe.Pointer(v31))
					*(*TTcl_Size)(unsafe.Pointer(v31))--
					if !(v30 > int64(1)) {
						if !((*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr)).FfreeIntRepProc != 0) {
							if (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
								XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes)
							}
							(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = int64(-libc.Int32FromInt32(1))
							if v32 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v32 {
								cachePtr9 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
							}
							if v32 || ((*TAllocCache)(unsafe.Pointer(cachePtr9)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr9)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
								XTclThreadFreeObj(tls, tmpObj)
							} else {
								(*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer(tmpObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr9)).FfirstObjPtr
								(*TAllocCache)(unsafe.Pointer(cachePtr9)).FfirstObjPtr = tmpObj
								(*TAllocCache)(unsafe.Pointer(cachePtr9)).FnumObjects++
							}
						} else {
							XTclFreeObj(tls, tmpObj)
						}
					}
					goto failedToCompile
				}
			} else {
				*(*int32)(unsafe.Pointer(resultVarIndices + uintptr(i)*4)) = -int32(1)
			}
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(2) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1*8)))).Fbytes != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1*8)))).Flength
					v33 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1*8)))).Fbytes
				} else {
					v33 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1*8)), bp+32)
				}
				varname1 = v33
				*(*int32)(unsafe.Pointer(optionVarIndices + uintptr(i)*4)) = libc.Int32FromUint64(XTclLocalScalar(tls, varname1, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 32))), envPtr))
				if *(*int32)(unsafe.Pointer(optionVarIndices + uintptr(i)*4)) < 0 {
					v35 = tmpObj
					v34 = *(*TTcl_Size)(unsafe.Pointer(v35))
					*(*TTcl_Size)(unsafe.Pointer(v35))--
					if !(v34 > int64(1)) {
						if !((*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr)).FfreeIntRepProc != 0) {
							if (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
								XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes)
							}
							(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = int64(-libc.Int32FromInt32(1))
							if v36 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v36 {
								cachePtr10 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
							}
							if v36 || ((*TAllocCache)(unsafe.Pointer(cachePtr10)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr10)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
								XTclThreadFreeObj(tls, tmpObj)
							} else {
								(*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer(tmpObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr10)).FfirstObjPtr
								(*TAllocCache)(unsafe.Pointer(cachePtr10)).FfirstObjPtr = tmpObj
								(*TAllocCache)(unsafe.Pointer(cachePtr10)).FnumObjects++
							}
						} else {
							XTclFreeObj(tls, tmpObj)
						}
					}
					goto failedToCompile
				}
			} else {
				*(*int32)(unsafe.Pointer(optionVarIndices + uintptr(i)*4)) = -int32(1)
			}
			v38 = tmpObj
			v37 = *(*TTcl_Size)(unsafe.Pointer(v38))
			*(*TTcl_Size)(unsafe.Pointer(v38))--
			if !(v37 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = int64(-libc.Int32FromInt32(1))
					if v39 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v39 {
						cachePtr11 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v39 || ((*TAllocCache)(unsafe.Pointer(cachePtr11)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr11)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, tmpObj)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(tmpObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr11)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr11)).FfirstObjPtr = tmpObj
						(*TAllocCache)(unsafe.Pointer(cachePtr11)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, tmpObj)
				}
			}
			/*
			 * Extract the body for this handler.
			 */
			tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
			if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) {
				goto failedToCompile
			}
			if (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize == int64(1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart))) == int32('-') {
				*(*uintptr)(unsafe.Pointer(handlerTokens + uintptr(i)*8)) = libc.UintptrFromInt32(0)
			} else {
				*(*uintptr)(unsafe.Pointer(handlerTokens + uintptr(i)*8)) = tokenPtr
			}
			tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
			goto _1
		_1:
			;
			i++
		}
		if *(*uintptr)(unsafe.Pointer(handlerTokens + uintptr(numHandlers-int32(1))*8)) == libc.UintptrFromInt32(0) {
			goto failedToCompile
		}
	}
	/*
	 * Parse the finally clause
	 */
	if numWords == 0 {
		finallyToken = libc.UintptrFromInt32(0)
	} else {
		if numWords == int32(2) {
			if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) || (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize != int64(7) || libc.Xstrncmp(tls, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, __ccgo_ts+20794, uint64(7)) != 0 {
				goto failedToCompile
			}
			finallyToken = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
			if (*TTcl_Token)(unsafe.Pointer(finallyToken)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) {
				goto failedToCompile
			}
		} else {
			goto failedToCompile
		}
	}
	/*
	 * Issue the bytecode.
	 */
	if !(finallyToken != 0) {
		result = _IssueTryClausesInstructions(tls, interp, envPtr, bodyToken, numHandlers, matchCodes, matchClauses, resultVarIndices, optionVarIndices, handlerTokens)
	} else {
		if numHandlers == 0 {
			result = _IssueTryFinallyInstructions(tls, interp, envPtr, bodyToken, finallyToken)
		} else {
			result = _IssueTryClausesFinallyInstructions(tls, interp, envPtr, bodyToken, numHandlers, matchCodes, matchClauses, resultVarIndices, optionVarIndices, handlerTokens, finallyToken)
		}
	}
	/*
	 * Delete any temporary state and finish off.
	 */
	goto failedToCompile
failedToCompile:
	;
	if numHandlers > 0 {
		i = 0
		for {
			if !(i < numHandlers) {
				break
			}
			if *(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i)*8)) != 0 {
				v42 = *(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i)*8))
				v41 = *(*TTcl_Size)(unsafe.Pointer(v42))
				*(*TTcl_Size)(unsafe.Pointer(v42))--
				if !(v41 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i)*8)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i)*8)))).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i)*8)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i)*8)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i)*8)))).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i)*8)))).Flength = int64(-libc.Int32FromInt32(1))
						if v43 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v43 {
							cachePtr12 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v43 || ((*TAllocCache)(unsafe.Pointer(cachePtr12)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr12)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i)*8)))
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i)*8)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr12)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr12)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i)*8))
							(*TAllocCache)(unsafe.Pointer(cachePtr12)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i)*8)))
					}
				}
			}
			goto _40
		_40:
			;
			i++
		}
		XTclStackFree(tls, interp, optionVarIndices)
		XTclStackFree(tls, interp, resultVarIndices)
		XTclStackFree(tls, interp, matchCodes)
		XTclStackFree(tls, interp, matchClauses)
		XTclStackFree(tls, interp, handlerTokens)
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * IssueTryClausesInstructions, IssueTryClausesFinallyInstructions,
 * IssueTryFinallyInstructions --
 *
 *	The code generators for [try]. Split from the parsing engine for
 *	reasons of developer sanity, and also split between no-finally,
 *	just-finally and with-finally cases because so many of the details of
 *	generation vary between the three.
 *
 *	The macros below make the instruction issuing easier to follow.
 *
 *----------------------------------------------------------------------
 */

func _IssueTryClausesInstructions(tls *libc.TLS, interp uintptr, envPtr2 uintptr, bodyToken uintptr, numHandlers int32, matchCodes uintptr, matchClauses uintptr, resultVars uintptr, optionVars uintptr, handlerTokens uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, _objIndexCopy4, _objIndexCopy5, afterBody, delta1, dontChangeOptions, forwardsNeedFixing, i1, j, notCodeJumpSource, notECJumpSource, optionsVar, range1, resultVar, trapZero, v103, v107, v113, v12, v125, v129, v134, v140, v152, v156, v168, v17, v176, v188, v194, v206, v218, v220, v232, v247, v259, v263, v275, v279, v285, v29, v297, v303, v31, v315, v319, v325, v337, v343, v355, v359, v37, v371, v373, v386, v391, v403, v405, v409, v413, v417, v421, v427, v439, v443, v449, v455, v467, v479, v485, v49, v497, v501, v507, v519, v531, v543, v553, v565, v577, v581, v587, v599, v605, v61, v617, v67, v69, v73, v77, v81, v85, v91 int32
	var addrsToFix, forwardsToFix, mapPtr, noError, p, v10, v100, v101, v102, v104, v105, v106, v108, v109, v11, v110, v111, v112, v114, v115, v116, v117, v118, v119, v120, v121, v122, v123, v124, v126, v127, v128, v13, v130, v132, v133, v135, v136, v137, v138, v139, v141, v142, v143, v144, v145, v146, v147, v148, v149, v15, v150, v151, v153, v154, v155, v157, v158, v159, v16, v160, v161, v162, v163, v164, v165, v166, v167, v169, v172, v173, v174, v175, v177, v178, v179, v18, v180, v181, v182, v183, v184, v185, v186, v187, v189, v19, v190, v191, v192, v193, v195, v196, v197, v198, v199, v2, v20, v200, v201, v202, v203, v204, v205, v207, v208, v209, v21, v210, v211, v212, v213, v214, v215, v216, v217, v219, v22, v221, v222, v223, v224, v225, v226, v227, v228, v229, v23, v230, v231, v233, v234, v235, v236, v237, v238, v239, v24, v240, v241, v242, v243, v244, v245, v246, v248, v249, v25, v250, v251, v252, v253, v254, v255, v256, v257, v258, v26, v260, v261, v262, v264, v265, v266, v267, v268, v269, v27, v270, v271, v272, v273, v274, v276, v277, v278, v28, v280, v281, v282, v283, v284, v286, v287, v288, v289, v290, v291, v292, v293, v294, v295, v296, v298, v299, v3, v30, v300, v301, v302, v304, v305, v306, v307, v308, v309, v310, v311, v312, v313, v314, v316, v317, v318, v32, v320, v321, v322, v323, v324, v326, v327, v328, v329, v33, v330, v331, v332, v333, v334, v335, v336, v338, v339, v34, v340, v341, v342, v344, v345, v346, v347, v348, v349, v35, v350, v351, v352, v353, v354, v356, v357, v358, v36, v360, v361, v362, v363, v364, v365, v366, v367, v368, v369, v370, v372, v374, v376, v377, v378, v379, v38, v380, v381, v382, v383, v384, v385, v387, v389, v39, v390, v392, v393, v394, v395, v396, v397, v398, v399, v4, v40, v400, v401, v402, v404, v406, v407, v408, v41, v410, v411, v412, v414, v415, v416, v418, v419, v42, v420, v422, v423, v424, v425, v426, v428, v429, v43, v430, v431, v432, v433, v434, v435, v436, v437, v438, v44, v440, v441, v442, v444, v445, v446, v447, v448, v45, v450, v451, v452, v453, v454, v456, v457, v458, v459, v46, v460, v461, v462, v463, v464, v465, v466, v468, v469, v47, v470, v471, v472, v473, v474, v475, v476, v477, v478, v48, v480, v481, v482, v483, v484, v486, v487, v488, v489, v490, v491, v492, v493, v494, v495, v496, v498, v499, v5, v50, v500, v502, v503, v504, v505, v506, v508, v509, v51, v510, v511, v512, v513, v514, v515, v516, v517, v518, v52, v520, v521, v522, v523, v524, v525, v526, v527, v528, v529, v53, v530, v532, v533, v534, v535, v536, v537, v538, v539, v54, v540, v541, v542, v544, v545, v546, v547, v548, v549, v55, v550, v551, v552, v554, v555, v556, v557, v558, v559, v56, v560, v561, v562, v563, v564, v566, v567, v568, v569, v57, v570, v571, v572, v573, v574, v575, v576, v578, v579, v58, v580, v582, v583, v584, v585, v586, v588, v589, v59, v590, v591, v592, v593, v594, v595, v596, v597, v598, v6, v60, v600, v601, v602, v603, v604, v606, v607, v608, v609, v610, v611, v612, v613, v614, v615, v616, v618, v62, v63, v64, v65, v66, v68, v7, v70, v71, v72, v74, v75, v76, v78, v79, v8, v80, v82, v83, v84, v86, v87, v88, v89, v9, v90, v92, v93, v94, v95, v96, v97, v98, v99 uintptr
	var eclIndex TTcl_Size
	var v14, v171, v388 int64
	var _ /* buf at bp+16 */ [24]uint8
	var _ /* len at bp+8 */ TTcl_Size
	var _ /* slen at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, _objIndexCopy4, _objIndexCopy5, addrsToFix, afterBody, delta1, dontChangeOptions, eclIndex, forwardsNeedFixing, forwardsToFix, i1, j, mapPtr, noError, notCodeJumpSource, notECJumpSource, optionsVar, p, range1, resultVar, trapZero, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v123, v124, v125, v126, v127, v128, v129, v13, v130, v132, v133, v134, v135, v136, v137, v138, v139, v14, v140, v141, v142, v143, v144, v145, v146, v147, v148, v149, v15, v150, v151, v152, v153, v154, v155, v156, v157, v158, v159, v16, v160, v161, v162, v163, v164, v165, v166, v167, v168, v169, v17, v171, v172, v173, v174, v175, v176, v177, v178, v179, v18, v180, v181, v182, v183, v184, v185, v186, v187, v188, v189, v19, v190, v191, v192, v193, v194, v195, v196, v197, v198, v199, v2, v20, v200, v201, v202, v203, v204, v205, v206, v207, v208, v209, v21, v210, v211, v212, v213, v214, v215, v216, v217, v218, v219, v22, v220, v221, v222, v223, v224, v225, v226, v227, v228, v229, v23, v230, v231, v232, v233, v234, v235, v236, v237, v238, v239, v24, v240, v241, v242, v243, v244, v245, v246, v247, v248, v249, v25, v250, v251, v252, v253, v254, v255, v256, v257, v258, v259, v26, v260, v261, v262, v263, v264, v265, v266, v267, v268, v269, v27, v270, v271, v272, v273, v274, v275, v276, v277, v278, v279, v28, v280, v281, v282, v283, v284, v285, v286, v287, v288, v289, v29, v290, v291, v292, v293, v294, v295, v296, v297, v298, v299, v3, v30, v300, v301, v302, v303, v304, v305, v306, v307, v308, v309, v31, v310, v311, v312, v313, v314, v315, v316, v317, v318, v319, v32, v320, v321, v322, v323, v324, v325, v326, v327, v328, v329, v33, v330, v331, v332, v333, v334, v335, v336, v337, v338, v339, v34, v340, v341, v342, v343, v344, v345, v346, v347, v348, v349, v35, v350, v351, v352, v353, v354, v355, v356, v357, v358, v359, v36, v360, v361, v362, v363, v364, v365, v366, v367, v368, v369, v37, v370, v371, v372, v373, v374, v376, v377, v378, v379, v38, v380, v381, v382, v383, v384, v385, v386, v387, v388, v389, v39, v390, v391, v392, v393, v394, v395, v396, v397, v398, v399, v4, v40, v400, v401, v402, v403, v404, v405, v406, v407, v408, v409, v41, v410, v411, v412, v413, v414, v415, v416, v417, v418, v419, v42, v420, v421, v422, v423, v424, v425, v426, v427, v428, v429, v43, v430, v431, v432, v433, v434, v435, v436, v437, v438, v439, v44, v440, v441, v442, v443, v444, v445, v446, v447, v448, v449, v45, v450, v451, v452, v453, v454, v455, v456, v457, v458, v459, v46, v460, v461, v462, v463, v464, v465, v466, v467, v468, v469, v47, v470, v471, v472, v473, v474, v475, v476, v477, v478, v479, v48, v480, v481, v482, v483, v484, v485, v486, v487, v488, v489, v49, v490, v491, v492, v493, v494, v495, v496, v497, v498, v499, v5, v50, v500, v501, v502, v503, v504, v505, v506, v507, v508, v509, v51, v510, v511, v512, v513, v514, v515, v516, v517, v518, v519, v52, v520, v521, v522, v523, v524, v525, v526, v527, v528, v529, v53, v530, v531, v532, v533, v534, v535, v536, v537, v538, v539, v54, v540, v541, v542, v543, v544, v545, v546, v547, v548, v549, v55, v550, v551, v552, v553, v554, v555, v556, v557, v558, v559, v56, v560, v561, v562, v563, v564, v565, v566, v567, v568, v569, v57, v570, v571, v572, v573, v574, v575, v576, v577, v578, v579, v58, v580, v581, v582, v583, v584, v585, v586, v587, v588, v589, v59, v590, v591, v592, v593, v594, v595, v596, v597, v598, v599, v6, v60, v600, v601, v602, v603, v604, v605, v606, v607, v608, v609, v61, v610, v611, v612, v613, v614, v615, v616, v617, v618, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	forwardsNeedFixing = 0
	trapZero = 0
	afterBody = 0
	resultVar = int32(XTclFindCompiledLocal(tls, libc.UintptrFromInt32(0), 0, int32(1), envPtr2))
	optionsVar = int32(XTclFindCompiledLocal(tls, libc.UintptrFromInt32(0), 0, int32(1), envPtr2))
	if resultVar < 0 || optionsVar < 0 {
		return int32(TCL_ERROR)
	}
	/*
	 * Check if we're supposed to trap a normal TCL_OK completion of the body.
	 * If not, we can handle that case much more efficiently.
	 */
	i1 = 0
	for {
		if !(i1 < numHandlers) {
			break
		}
		if *(*int32)(unsafe.Pointer(matchCodes + uintptr(i1)*4)) == 0 {
			trapZero = int32(1)
			break
		}
		goto _1
	_1:
		;
		i1++
	}
	/*
	 * Compile the body, trapping any error in it so that we can trap on it
	 * and/or run a finally clause. Note that there must be at least one
	 * on/trap clause; when none is present, this whole function is not called
	 * (and it's never called when there's a finally clause).
	 */
	range1 = int32(XTclCreateExceptRange(tls, int32(CATCH_EXCEPTION_RANGE), envPtr2))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v3 = envPtr2 + 152
	v2 = *(*uintptr)(unsafe.Pointer(v3))
	*(*uintptr)(unsafe.Pointer(v3))++
	*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32(INST_BEGIN_CATCH4))
	v5 = envPtr2 + 152
	v4 = *(*uintptr)(unsafe.Pointer(v5))
	*(*uintptr)(unsafe.Pointer(v5))++
	*(*uint8)(unsafe.Pointer(v4)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(24))
	v7 = envPtr2 + 152
	v6 = *(*uintptr)(unsafe.Pointer(v7))
	*(*uintptr)(unsafe.Pointer(v7))++
	*(*uint8)(unsafe.Pointer(v6)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(16))
	v9 = envPtr2 + 152
	v8 = *(*uintptr)(unsafe.Pointer(v9))
	*(*uintptr)(unsafe.Pointer(v9))++
	*(*uint8)(unsafe.Pointer(v8)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(8))
	v11 = envPtr2 + 152
	v10 = *(*uintptr)(unsafe.Pointer(v11))
	*(*uintptr)(unsafe.Pointer(v11))++
	*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt32(range1))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_BEGIN_CATCH4)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - range1
		}
		v12 = delta1
		v13 = envPtr2
		if v12 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v13)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v13)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v13)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v13)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v13 + 64)) += int64(v12)
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth++
	if libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth)+uint64(1) > libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth)+uint64(1) {
		v14 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth
	} else {
		v14 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth = v14
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
	XTclCompileCmdWord(tls, interp, bodyToken+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(bodyToken)).FnumComponents), envPtr2)
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth--
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FnumCodeBytes = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(int32((*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset))
	if !(trapZero != 0) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v16 = envPtr2 + 152
		v15 = *(*uintptr)(unsafe.Pointer(v16))
		*(*uintptr)(unsafe.Pointer(v16))++
		*(*uint8)(unsafe.Pointer(v15)) = libc.Uint8FromInt32(int32(INST_END_CATCH))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_END_CATCH)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v17 = delta1
			v18 = envPtr2
			if v17 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
		}
		afterBody = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v20 = envPtr2 + 152
		v19 = *(*uintptr)(unsafe.Pointer(v20))
		*(*uintptr)(unsafe.Pointer(v20))++
		*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_JUMP4))
		v22 = envPtr2 + 152
		v21 = *(*uintptr)(unsafe.Pointer(v22))
		*(*uintptr)(unsafe.Pointer(v22))++
		*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
		v24 = envPtr2 + 152
		v23 = *(*uintptr)(unsafe.Pointer(v24))
		*(*uintptr)(unsafe.Pointer(v24))++
		*(*uint8)(unsafe.Pointer(v23)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
		v26 = envPtr2 + 152
		v25 = *(*uintptr)(unsafe.Pointer(v26))
		*(*uintptr)(unsafe.Pointer(v26))++
		*(*uint8)(unsafe.Pointer(v25)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
		v28 = envPtr2 + 152
		v27 = *(*uintptr)(unsafe.Pointer(v28))
		*(*uintptr)(unsafe.Pointer(v28))++
		*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v29 = delta1
			v30 = envPtr2
			if v29 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v30)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v30)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v30)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v30)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v30 + 64)) += int64(v29)
		}
		v31 = -int32(1)
		v32 = envPtr2
		if v31 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v32)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v32)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v32)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v32)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v32 + 64)) += int64(v31)
	} else {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+14828, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v34 = envPtr2 + 152
			v33 = *(*uintptr)(unsafe.Pointer(v34))
			*(*uintptr)(unsafe.Pointer(v34))++
			*(*uint8)(unsafe.Pointer(v33)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v36 = envPtr2 + 152
			v35 = *(*uintptr)(unsafe.Pointer(v36))
			*(*uintptr)(unsafe.Pointer(v36))++
			*(*uint8)(unsafe.Pointer(v35)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v37 = delta1
				v38 = envPtr2
				if v37 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v38)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v38)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v38)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v38)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v38 + 64)) += int64(v37)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v40 = envPtr2 + 152
			v39 = *(*uintptr)(unsafe.Pointer(v40))
			*(*uintptr)(unsafe.Pointer(v40))++
			*(*uint8)(unsafe.Pointer(v39)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v42 = envPtr2 + 152
			v41 = *(*uintptr)(unsafe.Pointer(v42))
			*(*uintptr)(unsafe.Pointer(v42))++
			*(*uint8)(unsafe.Pointer(v41)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v44 = envPtr2 + 152
			v43 = *(*uintptr)(unsafe.Pointer(v44))
			*(*uintptr)(unsafe.Pointer(v44))++
			*(*uint8)(unsafe.Pointer(v43)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v46 = envPtr2 + 152
			v45 = *(*uintptr)(unsafe.Pointer(v46))
			*(*uintptr)(unsafe.Pointer(v46))++
			*(*uint8)(unsafe.Pointer(v45)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v48 = envPtr2 + 152
			v47 = *(*uintptr)(unsafe.Pointer(v48))
			*(*uintptr)(unsafe.Pointer(v48))++
			*(*uint8)(unsafe.Pointer(v47)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v49 = delta1
				v50 = envPtr2
				if v49 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v50)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v50)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v50)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v50)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v50 + 64)) += int64(v49)
			}
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v52 = envPtr2 + 152
		v51 = *(*uintptr)(unsafe.Pointer(v52))
		*(*uintptr)(unsafe.Pointer(v52))++
		*(*uint8)(unsafe.Pointer(v51)) = libc.Uint8FromInt32(int32(INST_REVERSE))
		v54 = envPtr2 + 152
		v53 = *(*uintptr)(unsafe.Pointer(v54))
		*(*uintptr)(unsafe.Pointer(v54))++
		*(*uint8)(unsafe.Pointer(v53)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
		v56 = envPtr2 + 152
		v55 = *(*uintptr)(unsafe.Pointer(v56))
		*(*uintptr)(unsafe.Pointer(v56))++
		*(*uint8)(unsafe.Pointer(v55)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
		v58 = envPtr2 + 152
		v57 = *(*uintptr)(unsafe.Pointer(v58))
		*(*uintptr)(unsafe.Pointer(v58))++
		*(*uint8)(unsafe.Pointer(v57)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
		v60 = envPtr2 + 152
		v59 = *(*uintptr)(unsafe.Pointer(v60))
		*(*uintptr)(unsafe.Pointer(v60))++
		*(*uint8)(unsafe.Pointer(v59)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(2)
			}
			v61 = delta1
			v62 = envPtr2
			if v61 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v62)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v62)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v62)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v62)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v62 + 64)) += int64(v61)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v64 = envPtr2 + 152
		v63 = *(*uintptr)(unsafe.Pointer(v64))
		*(*uintptr)(unsafe.Pointer(v64))++
		*(*uint8)(unsafe.Pointer(v63)) = libc.Uint8FromInt32(int32(INST_JUMP1))
		v66 = envPtr2 + 152
		v65 = *(*uintptr)(unsafe.Pointer(v66))
		*(*uintptr)(unsafe.Pointer(v66))++
		*(*uint8)(unsafe.Pointer(v65)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(4)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(4)
			}
			v67 = delta1
			v68 = envPtr2
			if v67 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v68)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v68)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v68)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v68)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v68 + 64)) += int64(v67)
		}
		v69 = -int32(2)
		v70 = envPtr2
		if v69 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v70 + 64)) += int64(v69)
	}
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcatchOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v72 = envPtr2 + 152
	v71 = *(*uintptr)(unsafe.Pointer(v72))
	*(*uintptr)(unsafe.Pointer(v72))++
	*(*uint8)(unsafe.Pointer(v71)) = libc.Uint8FromInt32(int32(INST_PUSH_RETURN_CODE))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_PUSH_RETURN_CODE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v73 = delta1
		v74 = envPtr2
		if v73 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v74)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v74)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v74)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v74)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v74 + 64)) += int64(v73)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v76 = envPtr2 + 152
	v75 = *(*uintptr)(unsafe.Pointer(v76))
	*(*uintptr)(unsafe.Pointer(v76))++
	*(*uint8)(unsafe.Pointer(v75)) = libc.Uint8FromInt32(int32(INST_PUSH_RESULT))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_PUSH_RESULT)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v77 = delta1
		v78 = envPtr2
		if v77 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v78)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v78)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v78)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v78)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v78 + 64)) += int64(v77)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v80 = envPtr2 + 152
	v79 = *(*uintptr)(unsafe.Pointer(v80))
	*(*uintptr)(unsafe.Pointer(v80))++
	*(*uint8)(unsafe.Pointer(v79)) = libc.Uint8FromInt32(int32(INST_PUSH_RETURN_OPTIONS))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_PUSH_RETURN_OPTIONS)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v81 = delta1
		v82 = envPtr2
		if v81 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v82)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v82)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v82)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v82)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v82 + 64)) += int64(v81)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v84 = envPtr2 + 152
	v83 = *(*uintptr)(unsafe.Pointer(v84))
	*(*uintptr)(unsafe.Pointer(v84))++
	*(*uint8)(unsafe.Pointer(v83)) = libc.Uint8FromInt32(int32(INST_END_CATCH))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_END_CATCH)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v85 = delta1
		v86 = envPtr2
		if v85 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v86)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v86)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v86)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v86)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v86 + 64)) += int64(v85)
	}
	if optionsVar < int32(256) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v88 = envPtr2 + 152
		v87 = *(*uintptr)(unsafe.Pointer(v88))
		*(*uintptr)(unsafe.Pointer(v88))++
		*(*uint8)(unsafe.Pointer(v87)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
		v90 = envPtr2 + 152
		v89 = *(*uintptr)(unsafe.Pointer(v90))
		*(*uintptr)(unsafe.Pointer(v90))++
		*(*uint8)(unsafe.Pointer(v89)) = uint8(libc.Uint32FromInt32(optionsVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - optionsVar
			}
			v91 = delta1
			v92 = envPtr2
			if v91 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v92)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v92)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v92)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v92)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v92 + 64)) += int64(v91)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v94 = envPtr2 + 152
		v93 = *(*uintptr)(unsafe.Pointer(v94))
		*(*uintptr)(unsafe.Pointer(v94))++
		*(*uint8)(unsafe.Pointer(v93)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
		v96 = envPtr2 + 152
		v95 = *(*uintptr)(unsafe.Pointer(v96))
		*(*uintptr)(unsafe.Pointer(v96))++
		*(*uint8)(unsafe.Pointer(v95)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(24))
		v98 = envPtr2 + 152
		v97 = *(*uintptr)(unsafe.Pointer(v98))
		*(*uintptr)(unsafe.Pointer(v98))++
		*(*uint8)(unsafe.Pointer(v97)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(16))
		v100 = envPtr2 + 152
		v99 = *(*uintptr)(unsafe.Pointer(v100))
		*(*uintptr)(unsafe.Pointer(v100))++
		*(*uint8)(unsafe.Pointer(v99)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(8))
		v102 = envPtr2 + 152
		v101 = *(*uintptr)(unsafe.Pointer(v102))
		*(*uintptr)(unsafe.Pointer(v102))++
		*(*uint8)(unsafe.Pointer(v101)) = uint8(libc.Uint32FromInt32(optionsVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - optionsVar
			}
			v103 = delta1
			v104 = envPtr2
			if v103 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v104)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v104)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v104)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v104)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v104 + 64)) += int64(v103)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v106 = envPtr2 + 152
	v105 = *(*uintptr)(unsafe.Pointer(v106))
	*(*uintptr)(unsafe.Pointer(v106))++
	*(*uint8)(unsafe.Pointer(v105)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v107 = delta1
		v108 = envPtr2
		if v107 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v108)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v108)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v108)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v108)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v108 + 64)) += int64(v107)
	}
	if resultVar < int32(256) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v110 = envPtr2 + 152
		v109 = *(*uintptr)(unsafe.Pointer(v110))
		*(*uintptr)(unsafe.Pointer(v110))++
		*(*uint8)(unsafe.Pointer(v109)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
		v112 = envPtr2 + 152
		v111 = *(*uintptr)(unsafe.Pointer(v112))
		*(*uintptr)(unsafe.Pointer(v112))++
		*(*uint8)(unsafe.Pointer(v111)) = uint8(libc.Uint32FromInt32(resultVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - resultVar
			}
			v113 = delta1
			v114 = envPtr2
			if v113 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v114)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v114)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v114)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v114)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v114 + 64)) += int64(v113)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v116 = envPtr2 + 152
		v115 = *(*uintptr)(unsafe.Pointer(v116))
		*(*uintptr)(unsafe.Pointer(v116))++
		*(*uint8)(unsafe.Pointer(v115)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
		v118 = envPtr2 + 152
		v117 = *(*uintptr)(unsafe.Pointer(v118))
		*(*uintptr)(unsafe.Pointer(v118))++
		*(*uint8)(unsafe.Pointer(v117)) = uint8(libc.Uint32FromInt32(resultVar) >> libc.Int32FromInt32(24))
		v120 = envPtr2 + 152
		v119 = *(*uintptr)(unsafe.Pointer(v120))
		*(*uintptr)(unsafe.Pointer(v120))++
		*(*uint8)(unsafe.Pointer(v119)) = uint8(libc.Uint32FromInt32(resultVar) >> libc.Int32FromInt32(16))
		v122 = envPtr2 + 152
		v121 = *(*uintptr)(unsafe.Pointer(v122))
		*(*uintptr)(unsafe.Pointer(v122))++
		*(*uint8)(unsafe.Pointer(v121)) = uint8(libc.Uint32FromInt32(resultVar) >> libc.Int32FromInt32(8))
		v124 = envPtr2 + 152
		v123 = *(*uintptr)(unsafe.Pointer(v124))
		*(*uintptr)(unsafe.Pointer(v124))++
		*(*uint8)(unsafe.Pointer(v123)) = uint8(libc.Uint32FromInt32(resultVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - resultVar
			}
			v125 = delta1
			v126 = envPtr2
			if v125 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v126)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v126)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v126)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v126)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v126 + 64)) += int64(v125)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v128 = envPtr2 + 152
	v127 = *(*uintptr)(unsafe.Pointer(v128))
	*(*uintptr)(unsafe.Pointer(v128))++
	*(*uint8)(unsafe.Pointer(v127)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v129 = delta1
		v130 = envPtr2
		if v129 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v130)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v130)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v130)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v130)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v130 + 64)) += int64(v129)
	}
	/*
	 * Now we handle all the registered 'on' and 'trap' handlers in order.
	 * For us to be here, there must be at least one handler.
	 *
	 * Slight overallocation, but reduces size of this function.
	 */
	addrsToFix = XTclStackAlloc(tls, interp, uint64(4)*libc.Uint64FromInt32(numHandlers))
	forwardsToFix = XTclStackAlloc(tls, interp, uint64(4)*libc.Uint64FromInt32(numHandlers))
	noError = XTclStackAlloc(tls, interp, uint64(4)*libc.Uint64FromInt32(numHandlers))
	i1 = 0
	for {
		if !(i1 < numHandlers) {
			break
		}
		*(*int32)(unsafe.Pointer(noError + uintptr(i1)*4)) = -int32(1)
		libc.X__builtin_snprintf(tls, bp+16, uint64(24), __ccgo_ts+260, libc.VaList(bp+48, *(*int32)(unsafe.Pointer(matchCodes + uintptr(i1)*4))))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v133 = envPtr2 + 152
		v132 = *(*uintptr)(unsafe.Pointer(v133))
		*(*uintptr)(unsafe.Pointer(v133))++
		*(*uint8)(unsafe.Pointer(v132)) = libc.Uint8FromInt32(int32(INST_DUP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_DUP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v134 = delta1
			v135 = envPtr2
			if v134 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v135)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v135)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v135)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v135)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v135 + 64)) += int64(v134)
		}
		_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, bp+16, libc.Int64FromUint64(libc.Xstrlen(tls, bp+16)), 0)
		if _objIndexCopy1 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v137 = envPtr2 + 152
			v136 = *(*uintptr)(unsafe.Pointer(v137))
			*(*uintptr)(unsafe.Pointer(v137))++
			*(*uint8)(unsafe.Pointer(v136)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v139 = envPtr2 + 152
			v138 = *(*uintptr)(unsafe.Pointer(v139))
			*(*uintptr)(unsafe.Pointer(v139))++
			*(*uint8)(unsafe.Pointer(v138)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v140 = delta1
				v141 = envPtr2
				if v140 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v141)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v141)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v141)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v141)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v141 + 64)) += int64(v140)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v143 = envPtr2 + 152
			v142 = *(*uintptr)(unsafe.Pointer(v143))
			*(*uintptr)(unsafe.Pointer(v143))++
			*(*uint8)(unsafe.Pointer(v142)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v145 = envPtr2 + 152
			v144 = *(*uintptr)(unsafe.Pointer(v145))
			*(*uintptr)(unsafe.Pointer(v145))++
			*(*uint8)(unsafe.Pointer(v144)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
			v147 = envPtr2 + 152
			v146 = *(*uintptr)(unsafe.Pointer(v147))
			*(*uintptr)(unsafe.Pointer(v147))++
			*(*uint8)(unsafe.Pointer(v146)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
			v149 = envPtr2 + 152
			v148 = *(*uintptr)(unsafe.Pointer(v149))
			*(*uintptr)(unsafe.Pointer(v149))++
			*(*uint8)(unsafe.Pointer(v148)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
			v151 = envPtr2 + 152
			v150 = *(*uintptr)(unsafe.Pointer(v151))
			*(*uintptr)(unsafe.Pointer(v151))++
			*(*uint8)(unsafe.Pointer(v150)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v152 = delta1
				v153 = envPtr2
				if v152 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v153)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v153)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v153)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v153)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v153 + 64)) += int64(v152)
			}
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v155 = envPtr2 + 152
		v154 = *(*uintptr)(unsafe.Pointer(v155))
		*(*uintptr)(unsafe.Pointer(v155))++
		*(*uint8)(unsafe.Pointer(v154)) = libc.Uint8FromInt32(int32(INST_EQ))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_EQ)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v156 = delta1
			v157 = envPtr2
			if v156 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v157)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v157)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v157)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v157)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v157 + 64)) += int64(v156)
		}
		notCodeJumpSource = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v159 = envPtr2 + 152
		v158 = *(*uintptr)(unsafe.Pointer(v159))
		*(*uintptr)(unsafe.Pointer(v159))++
		*(*uint8)(unsafe.Pointer(v158)) = libc.Uint8FromInt32(int32(INST_JUMP_FALSE4))
		v161 = envPtr2 + 152
		v160 = *(*uintptr)(unsafe.Pointer(v161))
		*(*uintptr)(unsafe.Pointer(v161))++
		*(*uint8)(unsafe.Pointer(v160)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
		v163 = envPtr2 + 152
		v162 = *(*uintptr)(unsafe.Pointer(v163))
		*(*uintptr)(unsafe.Pointer(v163))++
		*(*uint8)(unsafe.Pointer(v162)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
		v165 = envPtr2 + 152
		v164 = *(*uintptr)(unsafe.Pointer(v165))
		*(*uintptr)(unsafe.Pointer(v165))++
		*(*uint8)(unsafe.Pointer(v164)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
		v167 = envPtr2 + 152
		v166 = *(*uintptr)(unsafe.Pointer(v167))
		*(*uintptr)(unsafe.Pointer(v167))++
		*(*uint8)(unsafe.Pointer(v166)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP_FALSE4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v168 = delta1
			v169 = envPtr2
			if v168 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v169)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v169)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v169)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v169)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v169 + 64)) += int64(v168)
		}
		if *(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i1)*8)) != 0 {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i1)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i1)*8)) + 32))).Fptr2 != 0 {
					v171 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i1)*8)) + 32))).Fptr2)).FspanLength
				} else {
					v171 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i1)*8)) + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v171
				_ = libc.Int32FromInt32(TCL_OK)
			} else {
				XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i1)*8)), bp+8)
			}
			/*
			 * Match the errorcode according to try/trap rules.
			 */
			if optionsVar < int32(256) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v173 = envPtr2 + 152
				v172 = *(*uintptr)(unsafe.Pointer(v173))
				*(*uintptr)(unsafe.Pointer(v173))++
				*(*uint8)(unsafe.Pointer(v172)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
				v175 = envPtr2 + 152
				v174 = *(*uintptr)(unsafe.Pointer(v175))
				*(*uintptr)(unsafe.Pointer(v175))++
				*(*uint8)(unsafe.Pointer(v174)) = uint8(libc.Uint32FromInt32(optionsVar))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - optionsVar
					}
					v176 = delta1
					v177 = envPtr2
					if v176 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v177)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v177)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v177)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v177)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v177 + 64)) += int64(v176)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v179 = envPtr2 + 152
				v178 = *(*uintptr)(unsafe.Pointer(v179))
				*(*uintptr)(unsafe.Pointer(v179))++
				*(*uint8)(unsafe.Pointer(v178)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
				v181 = envPtr2 + 152
				v180 = *(*uintptr)(unsafe.Pointer(v181))
				*(*uintptr)(unsafe.Pointer(v181))++
				*(*uint8)(unsafe.Pointer(v180)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(24))
				v183 = envPtr2 + 152
				v182 = *(*uintptr)(unsafe.Pointer(v183))
				*(*uintptr)(unsafe.Pointer(v183))++
				*(*uint8)(unsafe.Pointer(v182)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(16))
				v185 = envPtr2 + 152
				v184 = *(*uintptr)(unsafe.Pointer(v185))
				*(*uintptr)(unsafe.Pointer(v185))++
				*(*uint8)(unsafe.Pointer(v184)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(8))
				v187 = envPtr2 + 152
				v186 = *(*uintptr)(unsafe.Pointer(v187))
				*(*uintptr)(unsafe.Pointer(v187))++
				*(*uint8)(unsafe.Pointer(v186)) = uint8(libc.Uint32FromInt32(optionsVar))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - optionsVar
					}
					v188 = delta1
					v189 = envPtr2
					if v188 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v189)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v189)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v189)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v189)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v189 + 64)) += int64(v188)
				}
			}
			_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+15231, libc.Int64FromUint64(libc.Uint64FromInt64(11)-libc.Uint64FromInt32(1)), 0)
			if _objIndexCopy2 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v191 = envPtr2 + 152
				v190 = *(*uintptr)(unsafe.Pointer(v191))
				*(*uintptr)(unsafe.Pointer(v191))++
				*(*uint8)(unsafe.Pointer(v190)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v193 = envPtr2 + 152
				v192 = *(*uintptr)(unsafe.Pointer(v193))
				*(*uintptr)(unsafe.Pointer(v193))++
				*(*uint8)(unsafe.Pointer(v192)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy2
					}
					v194 = delta1
					v195 = envPtr2
					if v194 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v195)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v195)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v195)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v195)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v195 + 64)) += int64(v194)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v197 = envPtr2 + 152
				v196 = *(*uintptr)(unsafe.Pointer(v197))
				*(*uintptr)(unsafe.Pointer(v197))++
				*(*uint8)(unsafe.Pointer(v196)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v199 = envPtr2 + 152
				v198 = *(*uintptr)(unsafe.Pointer(v199))
				*(*uintptr)(unsafe.Pointer(v199))++
				*(*uint8)(unsafe.Pointer(v198)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
				v201 = envPtr2 + 152
				v200 = *(*uintptr)(unsafe.Pointer(v201))
				*(*uintptr)(unsafe.Pointer(v201))++
				*(*uint8)(unsafe.Pointer(v200)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
				v203 = envPtr2 + 152
				v202 = *(*uintptr)(unsafe.Pointer(v203))
				*(*uintptr)(unsafe.Pointer(v203))++
				*(*uint8)(unsafe.Pointer(v202)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
				v205 = envPtr2 + 152
				v204 = *(*uintptr)(unsafe.Pointer(v205))
				*(*uintptr)(unsafe.Pointer(v205))++
				*(*uint8)(unsafe.Pointer(v204)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy2
					}
					v206 = delta1
					v207 = envPtr2
					if v206 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v207)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v207)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v207)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v207)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v207 + 64)) += int64(v206)
				}
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v209 = envPtr2 + 152
			v208 = *(*uintptr)(unsafe.Pointer(v209))
			*(*uintptr)(unsafe.Pointer(v209))++
			*(*uint8)(unsafe.Pointer(v208)) = libc.Uint8FromInt32(int32(INST_DICT_GET))
			v211 = envPtr2 + 152
			v210 = *(*uintptr)(unsafe.Pointer(v211))
			*(*uintptr)(unsafe.Pointer(v211))++
			*(*uint8)(unsafe.Pointer(v210)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(24))
			v213 = envPtr2 + 152
			v212 = *(*uintptr)(unsafe.Pointer(v213))
			*(*uintptr)(unsafe.Pointer(v213))++
			*(*uint8)(unsafe.Pointer(v212)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(16))
			v215 = envPtr2 + 152
			v214 = *(*uintptr)(unsafe.Pointer(v215))
			*(*uintptr)(unsafe.Pointer(v215))++
			*(*uint8)(unsafe.Pointer(v214)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(8))
			v217 = envPtr2 + 152
			v216 = *(*uintptr)(unsafe.Pointer(v217))
			*(*uintptr)(unsafe.Pointer(v217))++
			*(*uint8)(unsafe.Pointer(v216)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_DICT_GET)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - int32(1)
				}
				v218 = delta1
				v219 = envPtr2
				if v218 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v219)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v219)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v219)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v219)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v219 + 64)) += int64(v218)
			}
			v220 = -int32(1)
			v221 = envPtr2
			if v220 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v221)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v221)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v221)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v221)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v221 + 64)) += int64(v220)
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v223 = envPtr2 + 152
			v222 = *(*uintptr)(unsafe.Pointer(v223))
			*(*uintptr)(unsafe.Pointer(v223))++
			*(*uint8)(unsafe.Pointer(v222)) = libc.Uint8FromInt32(int32(INST_LIST_RANGE_IMM))
			v225 = envPtr2 + 152
			v224 = *(*uintptr)(unsafe.Pointer(v225))
			*(*uintptr)(unsafe.Pointer(v225))++
			*(*uint8)(unsafe.Pointer(v224)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
			v227 = envPtr2 + 152
			v226 = *(*uintptr)(unsafe.Pointer(v227))
			*(*uintptr)(unsafe.Pointer(v227))++
			*(*uint8)(unsafe.Pointer(v226)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
			v229 = envPtr2 + 152
			v228 = *(*uintptr)(unsafe.Pointer(v229))
			*(*uintptr)(unsafe.Pointer(v229))++
			*(*uint8)(unsafe.Pointer(v228)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
			v231 = envPtr2 + 152
			v230 = *(*uintptr)(unsafe.Pointer(v231))
			*(*uintptr)(unsafe.Pointer(v231))++
			*(*uint8)(unsafe.Pointer(v230)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LIST_RANGE_IMM)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v232 = delta1
				v233 = envPtr2
				if v232 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v233)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v233)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v233)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v233)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v233 + 64)) += int64(v232)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v235 = envPtr2 + 152
			v234 = *(*uintptr)(unsafe.Pointer(v235))
			*(*uintptr)(unsafe.Pointer(v235))++
			*(*uint8)(unsafe.Pointer(v234)) = uint8(libc.Uint32FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8))-libc.Int64FromInt32(1)) >> libc.Int32FromInt32(24))
			v237 = envPtr2 + 152
			v236 = *(*uintptr)(unsafe.Pointer(v237))
			*(*uintptr)(unsafe.Pointer(v237))++
			*(*uint8)(unsafe.Pointer(v236)) = uint8(libc.Uint32FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8))-libc.Int64FromInt32(1)) >> libc.Int32FromInt32(16))
			v239 = envPtr2 + 152
			v238 = *(*uintptr)(unsafe.Pointer(v239))
			*(*uintptr)(unsafe.Pointer(v239))++
			*(*uint8)(unsafe.Pointer(v238)) = uint8(libc.Uint32FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8))-libc.Int64FromInt32(1)) >> libc.Int32FromInt32(8))
			v241 = envPtr2 + 152
			v240 = *(*uintptr)(unsafe.Pointer(v241))
			*(*uintptr)(unsafe.Pointer(v241))++
			*(*uint8)(unsafe.Pointer(v240)) = uint8(libc.Uint32FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8)) - libc.Int64FromInt32(1)))
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i1)*8)))).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i1)*8)))).Flength
				v242 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i1)*8)))).Fbytes
			} else {
				v242 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i1)*8)), bp)
			}
			p = v242
			_objIndexCopy3 = XTclRegisterLiteral(tls, envPtr2, p, *(*TTcl_Size)(unsafe.Pointer(bp)), 0)
			if _objIndexCopy3 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v244 = envPtr2 + 152
				v243 = *(*uintptr)(unsafe.Pointer(v244))
				*(*uintptr)(unsafe.Pointer(v244))++
				*(*uint8)(unsafe.Pointer(v243)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v246 = envPtr2 + 152
				v245 = *(*uintptr)(unsafe.Pointer(v246))
				*(*uintptr)(unsafe.Pointer(v246))++
				*(*uint8)(unsafe.Pointer(v245)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy3
					}
					v247 = delta1
					v248 = envPtr2
					if v247 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v248)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v248)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v248)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v248)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v248 + 64)) += int64(v247)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v250 = envPtr2 + 152
				v249 = *(*uintptr)(unsafe.Pointer(v250))
				*(*uintptr)(unsafe.Pointer(v250))++
				*(*uint8)(unsafe.Pointer(v249)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v252 = envPtr2 + 152
				v251 = *(*uintptr)(unsafe.Pointer(v252))
				*(*uintptr)(unsafe.Pointer(v252))++
				*(*uint8)(unsafe.Pointer(v251)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(24))
				v254 = envPtr2 + 152
				v253 = *(*uintptr)(unsafe.Pointer(v254))
				*(*uintptr)(unsafe.Pointer(v254))++
				*(*uint8)(unsafe.Pointer(v253)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(16))
				v256 = envPtr2 + 152
				v255 = *(*uintptr)(unsafe.Pointer(v256))
				*(*uintptr)(unsafe.Pointer(v256))++
				*(*uint8)(unsafe.Pointer(v255)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(8))
				v258 = envPtr2 + 152
				v257 = *(*uintptr)(unsafe.Pointer(v258))
				*(*uintptr)(unsafe.Pointer(v258))++
				*(*uint8)(unsafe.Pointer(v257)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy3
					}
					v259 = delta1
					v260 = envPtr2
					if v259 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v260)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v260)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v260)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v260)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v260 + 64)) += int64(v259)
				}
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v262 = envPtr2 + 152
			v261 = *(*uintptr)(unsafe.Pointer(v262))
			*(*uintptr)(unsafe.Pointer(v262))++
			*(*uint8)(unsafe.Pointer(v261)) = libc.Uint8FromInt32(int32(INST_STR_EQ))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STR_EQ)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v263 = delta1
				v264 = envPtr2
				if v263 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v264)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v264)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v264)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v264)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v264 + 64)) += int64(v263)
			}
			notECJumpSource = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v266 = envPtr2 + 152
			v265 = *(*uintptr)(unsafe.Pointer(v266))
			*(*uintptr)(unsafe.Pointer(v266))++
			*(*uint8)(unsafe.Pointer(v265)) = libc.Uint8FromInt32(int32(INST_JUMP_FALSE4))
			v268 = envPtr2 + 152
			v267 = *(*uintptr)(unsafe.Pointer(v268))
			*(*uintptr)(unsafe.Pointer(v268))++
			*(*uint8)(unsafe.Pointer(v267)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
			v270 = envPtr2 + 152
			v269 = *(*uintptr)(unsafe.Pointer(v270))
			*(*uintptr)(unsafe.Pointer(v270))++
			*(*uint8)(unsafe.Pointer(v269)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
			v272 = envPtr2 + 152
			v271 = *(*uintptr)(unsafe.Pointer(v272))
			*(*uintptr)(unsafe.Pointer(v272))++
			*(*uint8)(unsafe.Pointer(v271)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
			v274 = envPtr2 + 152
			v273 = *(*uintptr)(unsafe.Pointer(v274))
			*(*uintptr)(unsafe.Pointer(v274))++
			*(*uint8)(unsafe.Pointer(v273)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_JUMP_FALSE4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v275 = delta1
				v276 = envPtr2
				if v275 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v276)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v276)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v276)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v276)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v276 + 64)) += int64(v275)
			}
		} else {
			notECJumpSource = -int32(1)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v278 = envPtr2 + 152
		v277 = *(*uintptr)(unsafe.Pointer(v278))
		*(*uintptr)(unsafe.Pointer(v278))++
		*(*uint8)(unsafe.Pointer(v277)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v279 = delta1
			v280 = envPtr2
			if v279 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v280)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v280)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v280)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v280)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v280 + 64)) += int64(v279)
		}
		/*
		 * There is no finally clause, so we can avoid wrapping a catch
		 * context around the handler. That simplifies what instructions need
		 * to be issued a lot since we can let errors just fall through.
		 */
		if *(*int32)(unsafe.Pointer(resultVars + uintptr(i1)*4)) >= 0 {
			if resultVar < int32(256) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v282 = envPtr2 + 152
				v281 = *(*uintptr)(unsafe.Pointer(v282))
				*(*uintptr)(unsafe.Pointer(v282))++
				*(*uint8)(unsafe.Pointer(v281)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
				v284 = envPtr2 + 152
				v283 = *(*uintptr)(unsafe.Pointer(v284))
				*(*uintptr)(unsafe.Pointer(v284))++
				*(*uint8)(unsafe.Pointer(v283)) = uint8(libc.Uint32FromInt32(resultVar))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - resultVar
					}
					v285 = delta1
					v286 = envPtr2
					if v285 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v286)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v286)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v286)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v286)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v286 + 64)) += int64(v285)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v288 = envPtr2 + 152
				v287 = *(*uintptr)(unsafe.Pointer(v288))
				*(*uintptr)(unsafe.Pointer(v288))++
				*(*uint8)(unsafe.Pointer(v287)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
				v290 = envPtr2 + 152
				v289 = *(*uintptr)(unsafe.Pointer(v290))
				*(*uintptr)(unsafe.Pointer(v290))++
				*(*uint8)(unsafe.Pointer(v289)) = uint8(libc.Uint32FromInt32(resultVar) >> libc.Int32FromInt32(24))
				v292 = envPtr2 + 152
				v291 = *(*uintptr)(unsafe.Pointer(v292))
				*(*uintptr)(unsafe.Pointer(v292))++
				*(*uint8)(unsafe.Pointer(v291)) = uint8(libc.Uint32FromInt32(resultVar) >> libc.Int32FromInt32(16))
				v294 = envPtr2 + 152
				v293 = *(*uintptr)(unsafe.Pointer(v294))
				*(*uintptr)(unsafe.Pointer(v294))++
				*(*uint8)(unsafe.Pointer(v293)) = uint8(libc.Uint32FromInt32(resultVar) >> libc.Int32FromInt32(8))
				v296 = envPtr2 + 152
				v295 = *(*uintptr)(unsafe.Pointer(v296))
				*(*uintptr)(unsafe.Pointer(v296))++
				*(*uint8)(unsafe.Pointer(v295)) = uint8(libc.Uint32FromInt32(resultVar))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - resultVar
					}
					v297 = delta1
					v298 = envPtr2
					if v297 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v298)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v298)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v298)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v298)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v298 + 64)) += int64(v297)
				}
			}
			if *(*int32)(unsafe.Pointer(resultVars + uintptr(i1)*4)) < int32(256) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v300 = envPtr2 + 152
				v299 = *(*uintptr)(unsafe.Pointer(v300))
				*(*uintptr)(unsafe.Pointer(v300))++
				*(*uint8)(unsafe.Pointer(v299)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
				v302 = envPtr2 + 152
				v301 = *(*uintptr)(unsafe.Pointer(v302))
				*(*uintptr)(unsafe.Pointer(v302))++
				*(*uint8)(unsafe.Pointer(v301)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(resultVars + uintptr(i1)*4))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - *(*int32)(unsafe.Pointer(resultVars + uintptr(i1)*4))
					}
					v303 = delta1
					v304 = envPtr2
					if v303 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v304)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v304)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v304)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v304)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v304 + 64)) += int64(v303)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v306 = envPtr2 + 152
				v305 = *(*uintptr)(unsafe.Pointer(v306))
				*(*uintptr)(unsafe.Pointer(v306))++
				*(*uint8)(unsafe.Pointer(v305)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
				v308 = envPtr2 + 152
				v307 = *(*uintptr)(unsafe.Pointer(v308))
				*(*uintptr)(unsafe.Pointer(v308))++
				*(*uint8)(unsafe.Pointer(v307)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(resultVars + uintptr(i1)*4))) >> libc.Int32FromInt32(24))
				v310 = envPtr2 + 152
				v309 = *(*uintptr)(unsafe.Pointer(v310))
				*(*uintptr)(unsafe.Pointer(v310))++
				*(*uint8)(unsafe.Pointer(v309)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(resultVars + uintptr(i1)*4))) >> libc.Int32FromInt32(16))
				v312 = envPtr2 + 152
				v311 = *(*uintptr)(unsafe.Pointer(v312))
				*(*uintptr)(unsafe.Pointer(v312))++
				*(*uint8)(unsafe.Pointer(v311)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(resultVars + uintptr(i1)*4))) >> libc.Int32FromInt32(8))
				v314 = envPtr2 + 152
				v313 = *(*uintptr)(unsafe.Pointer(v314))
				*(*uintptr)(unsafe.Pointer(v314))++
				*(*uint8)(unsafe.Pointer(v313)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(resultVars + uintptr(i1)*4))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - *(*int32)(unsafe.Pointer(resultVars + uintptr(i1)*4))
					}
					v315 = delta1
					v316 = envPtr2
					if v315 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v316)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v316)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v316)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v316)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v316 + 64)) += int64(v315)
				}
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v318 = envPtr2 + 152
			v317 = *(*uintptr)(unsafe.Pointer(v318))
			*(*uintptr)(unsafe.Pointer(v318))++
			*(*uint8)(unsafe.Pointer(v317)) = libc.Uint8FromInt32(int32(INST_POP))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v319 = delta1
				v320 = envPtr2
				if v319 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v320)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v320)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v320)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v320)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v320 + 64)) += int64(v319)
			}
			if *(*int32)(unsafe.Pointer(optionVars + uintptr(i1)*4)) >= 0 {
				if optionsVar < int32(256) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v322 = envPtr2 + 152
					v321 = *(*uintptr)(unsafe.Pointer(v322))
					*(*uintptr)(unsafe.Pointer(v322))++
					*(*uint8)(unsafe.Pointer(v321)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
					v324 = envPtr2 + 152
					v323 = *(*uintptr)(unsafe.Pointer(v324))
					*(*uintptr)(unsafe.Pointer(v324))++
					*(*uint8)(unsafe.Pointer(v323)) = uint8(libc.Uint32FromInt32(optionsVar))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - optionsVar
						}
						v325 = delta1
						v326 = envPtr2
						if v325 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v326)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v326)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v326)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v326)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v326 + 64)) += int64(v325)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v328 = envPtr2 + 152
					v327 = *(*uintptr)(unsafe.Pointer(v328))
					*(*uintptr)(unsafe.Pointer(v328))++
					*(*uint8)(unsafe.Pointer(v327)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
					v330 = envPtr2 + 152
					v329 = *(*uintptr)(unsafe.Pointer(v330))
					*(*uintptr)(unsafe.Pointer(v330))++
					*(*uint8)(unsafe.Pointer(v329)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(24))
					v332 = envPtr2 + 152
					v331 = *(*uintptr)(unsafe.Pointer(v332))
					*(*uintptr)(unsafe.Pointer(v332))++
					*(*uint8)(unsafe.Pointer(v331)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(16))
					v334 = envPtr2 + 152
					v333 = *(*uintptr)(unsafe.Pointer(v334))
					*(*uintptr)(unsafe.Pointer(v334))++
					*(*uint8)(unsafe.Pointer(v333)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(8))
					v336 = envPtr2 + 152
					v335 = *(*uintptr)(unsafe.Pointer(v336))
					*(*uintptr)(unsafe.Pointer(v336))++
					*(*uint8)(unsafe.Pointer(v335)) = uint8(libc.Uint32FromInt32(optionsVar))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - optionsVar
						}
						v337 = delta1
						v338 = envPtr2
						if v337 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v338)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v338)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v338)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v338)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v338 + 64)) += int64(v337)
					}
				}
				if *(*int32)(unsafe.Pointer(optionVars + uintptr(i1)*4)) < int32(256) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v340 = envPtr2 + 152
					v339 = *(*uintptr)(unsafe.Pointer(v340))
					*(*uintptr)(unsafe.Pointer(v340))++
					*(*uint8)(unsafe.Pointer(v339)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
					v342 = envPtr2 + 152
					v341 = *(*uintptr)(unsafe.Pointer(v342))
					*(*uintptr)(unsafe.Pointer(v342))++
					*(*uint8)(unsafe.Pointer(v341)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(optionVars + uintptr(i1)*4))))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - *(*int32)(unsafe.Pointer(optionVars + uintptr(i1)*4))
						}
						v343 = delta1
						v344 = envPtr2
						if v343 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v344)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v344)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v344)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v344)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v344 + 64)) += int64(v343)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v346 = envPtr2 + 152
					v345 = *(*uintptr)(unsafe.Pointer(v346))
					*(*uintptr)(unsafe.Pointer(v346))++
					*(*uint8)(unsafe.Pointer(v345)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
					v348 = envPtr2 + 152
					v347 = *(*uintptr)(unsafe.Pointer(v348))
					*(*uintptr)(unsafe.Pointer(v348))++
					*(*uint8)(unsafe.Pointer(v347)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(optionVars + uintptr(i1)*4))) >> libc.Int32FromInt32(24))
					v350 = envPtr2 + 152
					v349 = *(*uintptr)(unsafe.Pointer(v350))
					*(*uintptr)(unsafe.Pointer(v350))++
					*(*uint8)(unsafe.Pointer(v349)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(optionVars + uintptr(i1)*4))) >> libc.Int32FromInt32(16))
					v352 = envPtr2 + 152
					v351 = *(*uintptr)(unsafe.Pointer(v352))
					*(*uintptr)(unsafe.Pointer(v352))++
					*(*uint8)(unsafe.Pointer(v351)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(optionVars + uintptr(i1)*4))) >> libc.Int32FromInt32(8))
					v354 = envPtr2 + 152
					v353 = *(*uintptr)(unsafe.Pointer(v354))
					*(*uintptr)(unsafe.Pointer(v354))++
					*(*uint8)(unsafe.Pointer(v353)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(optionVars + uintptr(i1)*4))))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - *(*int32)(unsafe.Pointer(optionVars + uintptr(i1)*4))
						}
						v355 = delta1
						v356 = envPtr2
						if v355 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v356)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v356)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v356)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v356)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v356 + 64)) += int64(v355)
					}
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v358 = envPtr2 + 152
				v357 = *(*uintptr)(unsafe.Pointer(v358))
				*(*uintptr)(unsafe.Pointer(v358))++
				*(*uint8)(unsafe.Pointer(v357)) = libc.Uint8FromInt32(int32(INST_POP))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v359 = delta1
					v360 = envPtr2
					if v359 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v360)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v360)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v360)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v360)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v360 + 64)) += int64(v359)
				}
			}
		}
		if !(*(*uintptr)(unsafe.Pointer(handlerTokens + uintptr(i1)*8)) != 0) {
			forwardsNeedFixing = int32(1)
			*(*int32)(unsafe.Pointer(forwardsToFix + uintptr(i1)*4)) = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v362 = envPtr2 + 152
			v361 = *(*uintptr)(unsafe.Pointer(v362))
			*(*uintptr)(unsafe.Pointer(v362))++
			*(*uint8)(unsafe.Pointer(v361)) = libc.Uint8FromInt32(int32(INST_JUMP4))
			v364 = envPtr2 + 152
			v363 = *(*uintptr)(unsafe.Pointer(v364))
			*(*uintptr)(unsafe.Pointer(v364))++
			*(*uint8)(unsafe.Pointer(v363)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
			v366 = envPtr2 + 152
			v365 = *(*uintptr)(unsafe.Pointer(v366))
			*(*uintptr)(unsafe.Pointer(v366))++
			*(*uint8)(unsafe.Pointer(v365)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
			v368 = envPtr2 + 152
			v367 = *(*uintptr)(unsafe.Pointer(v368))
			*(*uintptr)(unsafe.Pointer(v368))++
			*(*uint8)(unsafe.Pointer(v367)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
			v370 = envPtr2 + 152
			v369 = *(*uintptr)(unsafe.Pointer(v370))
			*(*uintptr)(unsafe.Pointer(v370))++
			*(*uint8)(unsafe.Pointer(v369)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_JUMP4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v371 = delta1
				v372 = envPtr2
				if v371 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v372)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v372)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v372)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v372)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v372 + 64)) += int64(v371)
			}
			v373 = int32(1)
			v374 = envPtr2
			if v373 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v374)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v374)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v374)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v374)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v374 + 64)) += int64(v373)
		} else {
			*(*int32)(unsafe.Pointer(forwardsToFix + uintptr(i1)*4)) = -int32(1)
			if forwardsNeedFixing != 0 {
				forwardsNeedFixing = 0
				j = 0
				for {
					if !(j < i1) {
						break
					}
					if *(*int32)(unsafe.Pointer(forwardsToFix + uintptr(j)*4)) == -int32(1) {
						goto _375
					}
					*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(*(*int32)(unsafe.Pointer(forwardsToFix + uintptr(j)*4))) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(*(*int32)(unsafe.Pointer(forwardsToFix + uintptr(j)*4)))) >> libc.Int32FromInt32(24))
					*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(*(*int32)(unsafe.Pointer(forwardsToFix + uintptr(j)*4))) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(*(*int32)(unsafe.Pointer(forwardsToFix + uintptr(j)*4)))) >> libc.Int32FromInt32(16))
					*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(*(*int32)(unsafe.Pointer(forwardsToFix + uintptr(j)*4))) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(*(*int32)(unsafe.Pointer(forwardsToFix + uintptr(j)*4)))) >> libc.Int32FromInt32(8))
					*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(*(*int32)(unsafe.Pointer(forwardsToFix + uintptr(j)*4))) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(*(*int32)(unsafe.Pointer(forwardsToFix + uintptr(j)*4)))))
					*(*int32)(unsafe.Pointer(forwardsToFix + uintptr(j)*4)) = -int32(1)
					goto _375
				_375:
					;
					j++
				}
			}
			range1 = int32(XTclCreateExceptRange(tls, int32(CATCH_EXCEPTION_RANGE), envPtr2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v377 = envPtr2 + 152
			v376 = *(*uintptr)(unsafe.Pointer(v377))
			*(*uintptr)(unsafe.Pointer(v377))++
			*(*uint8)(unsafe.Pointer(v376)) = libc.Uint8FromInt32(int32(INST_BEGIN_CATCH4))
			v379 = envPtr2 + 152
			v378 = *(*uintptr)(unsafe.Pointer(v379))
			*(*uintptr)(unsafe.Pointer(v379))++
			*(*uint8)(unsafe.Pointer(v378)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(24))
			v381 = envPtr2 + 152
			v380 = *(*uintptr)(unsafe.Pointer(v381))
			*(*uintptr)(unsafe.Pointer(v381))++
			*(*uint8)(unsafe.Pointer(v380)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(16))
			v383 = envPtr2 + 152
			v382 = *(*uintptr)(unsafe.Pointer(v383))
			*(*uintptr)(unsafe.Pointer(v383))++
			*(*uint8)(unsafe.Pointer(v382)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(8))
			v385 = envPtr2 + 152
			v384 = *(*uintptr)(unsafe.Pointer(v385))
			*(*uintptr)(unsafe.Pointer(v385))++
			*(*uint8)(unsafe.Pointer(v384)) = uint8(libc.Uint32FromInt32(range1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_BEGIN_CATCH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - range1
				}
				v386 = delta1
				v387 = envPtr2
				if v386 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v387)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v387)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v387)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v387)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v387 + 64)) += int64(v386)
			}
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth++
			if libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth)+uint64(1) > libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth)+uint64(1) {
				v388 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth
			} else {
				v388 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth
			}
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth = v388
			(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(libc.Int32FromInt32(5)+i1*libc.Int32FromInt32(4))*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(libc.Int32FromInt32(5)+i1*libc.Int32FromInt32(4))*8))
			XTclCompileCmdWord(tls, interp, *(*uintptr)(unsafe.Pointer(handlerTokens + uintptr(i1)*8))+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(handlerTokens + uintptr(i1)*8)))).FnumComponents), envPtr2)
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth--
			(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FnumCodeBytes = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(int32((*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v390 = envPtr2 + 152
			v389 = *(*uintptr)(unsafe.Pointer(v390))
			*(*uintptr)(unsafe.Pointer(v390))++
			*(*uint8)(unsafe.Pointer(v389)) = libc.Uint8FromInt32(int32(INST_END_CATCH))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_END_CATCH)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v391 = delta1
				v392 = envPtr2
				if v391 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v392)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v392)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v392)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v392)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v392 + 64)) += int64(v391)
			}
			*(*int32)(unsafe.Pointer(noError + uintptr(i1)*4)) = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v394 = envPtr2 + 152
			v393 = *(*uintptr)(unsafe.Pointer(v394))
			*(*uintptr)(unsafe.Pointer(v394))++
			*(*uint8)(unsafe.Pointer(v393)) = libc.Uint8FromInt32(int32(INST_JUMP4))
			v396 = envPtr2 + 152
			v395 = *(*uintptr)(unsafe.Pointer(v396))
			*(*uintptr)(unsafe.Pointer(v396))++
			*(*uint8)(unsafe.Pointer(v395)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
			v398 = envPtr2 + 152
			v397 = *(*uintptr)(unsafe.Pointer(v398))
			*(*uintptr)(unsafe.Pointer(v398))++
			*(*uint8)(unsafe.Pointer(v397)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
			v400 = envPtr2 + 152
			v399 = *(*uintptr)(unsafe.Pointer(v400))
			*(*uintptr)(unsafe.Pointer(v400))++
			*(*uint8)(unsafe.Pointer(v399)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
			v402 = envPtr2 + 152
			v401 = *(*uintptr)(unsafe.Pointer(v402))
			*(*uintptr)(unsafe.Pointer(v402))++
			*(*uint8)(unsafe.Pointer(v401)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_JUMP4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v403 = delta1
				v404 = envPtr2
				if v403 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v404)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v404)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v404)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v404)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v404 + 64)) += int64(v403)
			}
			(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcatchOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
			v405 = -int32(1)
			v406 = envPtr2
			if v405 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v406)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v406)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v406)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v406)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v406 + 64)) += int64(v405)
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v408 = envPtr2 + 152
			v407 = *(*uintptr)(unsafe.Pointer(v408))
			*(*uintptr)(unsafe.Pointer(v408))++
			*(*uint8)(unsafe.Pointer(v407)) = libc.Uint8FromInt32(int32(INST_PUSH_RESULT))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH_RESULT)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v409 = delta1
				v410 = envPtr2
				if v409 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v410)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v410)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v410)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v410)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v410 + 64)) += int64(v409)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v412 = envPtr2 + 152
			v411 = *(*uintptr)(unsafe.Pointer(v412))
			*(*uintptr)(unsafe.Pointer(v412))++
			*(*uint8)(unsafe.Pointer(v411)) = libc.Uint8FromInt32(int32(INST_PUSH_RETURN_OPTIONS))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH_RETURN_OPTIONS)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v413 = delta1
				v414 = envPtr2
				if v413 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v414)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v414)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v414)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v414)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v414 + 64)) += int64(v413)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v416 = envPtr2 + 152
			v415 = *(*uintptr)(unsafe.Pointer(v416))
			*(*uintptr)(unsafe.Pointer(v416))++
			*(*uint8)(unsafe.Pointer(v415)) = libc.Uint8FromInt32(int32(INST_PUSH_RETURN_CODE))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH_RETURN_CODE)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v417 = delta1
				v418 = envPtr2
				if v417 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v418)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v418)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v418)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v418)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v418 + 64)) += int64(v417)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v420 = envPtr2 + 152
			v419 = *(*uintptr)(unsafe.Pointer(v420))
			*(*uintptr)(unsafe.Pointer(v420))++
			*(*uint8)(unsafe.Pointer(v419)) = libc.Uint8FromInt32(int32(INST_END_CATCH))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_END_CATCH)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v421 = delta1
				v422 = envPtr2
				if v421 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v422)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v422)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v422)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v422)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v422 + 64)) += int64(v421)
			}
			_objIndexCopy4 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+21397, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
			if _objIndexCopy4 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v424 = envPtr2 + 152
				v423 = *(*uintptr)(unsafe.Pointer(v424))
				*(*uintptr)(unsafe.Pointer(v424))++
				*(*uint8)(unsafe.Pointer(v423)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v426 = envPtr2 + 152
				v425 = *(*uintptr)(unsafe.Pointer(v426))
				*(*uintptr)(unsafe.Pointer(v426))++
				*(*uint8)(unsafe.Pointer(v425)) = uint8(libc.Uint32FromInt32(_objIndexCopy4))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy4
					}
					v427 = delta1
					v428 = envPtr2
					if v427 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v428)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v428)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v428)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v428)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v428 + 64)) += int64(v427)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v430 = envPtr2 + 152
				v429 = *(*uintptr)(unsafe.Pointer(v430))
				*(*uintptr)(unsafe.Pointer(v430))++
				*(*uint8)(unsafe.Pointer(v429)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v432 = envPtr2 + 152
				v431 = *(*uintptr)(unsafe.Pointer(v432))
				*(*uintptr)(unsafe.Pointer(v432))++
				*(*uint8)(unsafe.Pointer(v431)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(24))
				v434 = envPtr2 + 152
				v433 = *(*uintptr)(unsafe.Pointer(v434))
				*(*uintptr)(unsafe.Pointer(v434))++
				*(*uint8)(unsafe.Pointer(v433)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(16))
				v436 = envPtr2 + 152
				v435 = *(*uintptr)(unsafe.Pointer(v436))
				*(*uintptr)(unsafe.Pointer(v436))++
				*(*uint8)(unsafe.Pointer(v435)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(8))
				v438 = envPtr2 + 152
				v437 = *(*uintptr)(unsafe.Pointer(v438))
				*(*uintptr)(unsafe.Pointer(v438))++
				*(*uint8)(unsafe.Pointer(v437)) = uint8(libc.Uint32FromInt32(_objIndexCopy4))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy4
					}
					v439 = delta1
					v440 = envPtr2
					if v439 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v440)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v440)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v440)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v440)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v440 + 64)) += int64(v439)
				}
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v442 = envPtr2 + 152
			v441 = *(*uintptr)(unsafe.Pointer(v442))
			*(*uintptr)(unsafe.Pointer(v442))++
			*(*uint8)(unsafe.Pointer(v441)) = libc.Uint8FromInt32(int32(INST_EQ))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_EQ)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v443 = delta1
				v444 = envPtr2
				if v443 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v444)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v444)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v444)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v444)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v444 + 64)) += int64(v443)
			}
			dontChangeOptions = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v446 = envPtr2 + 152
			v445 = *(*uintptr)(unsafe.Pointer(v446))
			*(*uintptr)(unsafe.Pointer(v446))++
			*(*uint8)(unsafe.Pointer(v445)) = libc.Uint8FromInt32(int32(INST_JUMP_FALSE1))
			v448 = envPtr2 + 152
			v447 = *(*uintptr)(unsafe.Pointer(v448))
			*(*uintptr)(unsafe.Pointer(v448))++
			*(*uint8)(unsafe.Pointer(v447)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_JUMP_FALSE1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v449 = delta1
				v450 = envPtr2
				if v449 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v450)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v450)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v450)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v450)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v450 + 64)) += int64(v449)
			}
			if optionsVar < int32(256) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v452 = envPtr2 + 152
				v451 = *(*uintptr)(unsafe.Pointer(v452))
				*(*uintptr)(unsafe.Pointer(v452))++
				*(*uint8)(unsafe.Pointer(v451)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
				v454 = envPtr2 + 152
				v453 = *(*uintptr)(unsafe.Pointer(v454))
				*(*uintptr)(unsafe.Pointer(v454))++
				*(*uint8)(unsafe.Pointer(v453)) = uint8(libc.Uint32FromInt32(optionsVar))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - optionsVar
					}
					v455 = delta1
					v456 = envPtr2
					if v455 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v456)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v456)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v456)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v456)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v456 + 64)) += int64(v455)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v458 = envPtr2 + 152
				v457 = *(*uintptr)(unsafe.Pointer(v458))
				*(*uintptr)(unsafe.Pointer(v458))++
				*(*uint8)(unsafe.Pointer(v457)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
				v460 = envPtr2 + 152
				v459 = *(*uintptr)(unsafe.Pointer(v460))
				*(*uintptr)(unsafe.Pointer(v460))++
				*(*uint8)(unsafe.Pointer(v459)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(24))
				v462 = envPtr2 + 152
				v461 = *(*uintptr)(unsafe.Pointer(v462))
				*(*uintptr)(unsafe.Pointer(v462))++
				*(*uint8)(unsafe.Pointer(v461)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(16))
				v464 = envPtr2 + 152
				v463 = *(*uintptr)(unsafe.Pointer(v464))
				*(*uintptr)(unsafe.Pointer(v464))++
				*(*uint8)(unsafe.Pointer(v463)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(8))
				v466 = envPtr2 + 152
				v465 = *(*uintptr)(unsafe.Pointer(v466))
				*(*uintptr)(unsafe.Pointer(v466))++
				*(*uint8)(unsafe.Pointer(v465)) = uint8(libc.Uint32FromInt32(optionsVar))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - optionsVar
					}
					v467 = delta1
					v468 = envPtr2
					if v467 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v468)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v468)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v468)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v468)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v468 + 64)) += int64(v467)
				}
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v470 = envPtr2 + 152
			v469 = *(*uintptr)(unsafe.Pointer(v470))
			*(*uintptr)(unsafe.Pointer(v470))++
			*(*uint8)(unsafe.Pointer(v469)) = libc.Uint8FromInt32(int32(INST_REVERSE))
			v472 = envPtr2 + 152
			v471 = *(*uintptr)(unsafe.Pointer(v472))
			*(*uintptr)(unsafe.Pointer(v472))++
			*(*uint8)(unsafe.Pointer(v471)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
			v474 = envPtr2 + 152
			v473 = *(*uintptr)(unsafe.Pointer(v474))
			*(*uintptr)(unsafe.Pointer(v474))++
			*(*uint8)(unsafe.Pointer(v473)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
			v476 = envPtr2 + 152
			v475 = *(*uintptr)(unsafe.Pointer(v476))
			*(*uintptr)(unsafe.Pointer(v476))++
			*(*uint8)(unsafe.Pointer(v475)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
			v478 = envPtr2 + 152
			v477 = *(*uintptr)(unsafe.Pointer(v478))
			*(*uintptr)(unsafe.Pointer(v478))++
			*(*uint8)(unsafe.Pointer(v477)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - int32(2)
				}
				v479 = delta1
				v480 = envPtr2
				if v479 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v480)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v480)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v480)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v480)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v480 + 64)) += int64(v479)
			}
			if optionsVar < int32(256) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v482 = envPtr2 + 152
				v481 = *(*uintptr)(unsafe.Pointer(v482))
				*(*uintptr)(unsafe.Pointer(v482))++
				*(*uint8)(unsafe.Pointer(v481)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
				v484 = envPtr2 + 152
				v483 = *(*uintptr)(unsafe.Pointer(v484))
				*(*uintptr)(unsafe.Pointer(v484))++
				*(*uint8)(unsafe.Pointer(v483)) = uint8(libc.Uint32FromInt32(optionsVar))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - optionsVar
					}
					v485 = delta1
					v486 = envPtr2
					if v485 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v486)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v486)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v486)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v486)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v486 + 64)) += int64(v485)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v488 = envPtr2 + 152
				v487 = *(*uintptr)(unsafe.Pointer(v488))
				*(*uintptr)(unsafe.Pointer(v488))++
				*(*uint8)(unsafe.Pointer(v487)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
				v490 = envPtr2 + 152
				v489 = *(*uintptr)(unsafe.Pointer(v490))
				*(*uintptr)(unsafe.Pointer(v490))++
				*(*uint8)(unsafe.Pointer(v489)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(24))
				v492 = envPtr2 + 152
				v491 = *(*uintptr)(unsafe.Pointer(v492))
				*(*uintptr)(unsafe.Pointer(v492))++
				*(*uint8)(unsafe.Pointer(v491)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(16))
				v494 = envPtr2 + 152
				v493 = *(*uintptr)(unsafe.Pointer(v494))
				*(*uintptr)(unsafe.Pointer(v494))++
				*(*uint8)(unsafe.Pointer(v493)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(8))
				v496 = envPtr2 + 152
				v495 = *(*uintptr)(unsafe.Pointer(v496))
				*(*uintptr)(unsafe.Pointer(v496))++
				*(*uint8)(unsafe.Pointer(v495)) = uint8(libc.Uint32FromInt32(optionsVar))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - optionsVar
					}
					v497 = delta1
					v498 = envPtr2
					if v497 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v498)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v498)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v498)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v498)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v498 + 64)) += int64(v497)
				}
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v500 = envPtr2 + 152
			v499 = *(*uintptr)(unsafe.Pointer(v500))
			*(*uintptr)(unsafe.Pointer(v500))++
			*(*uint8)(unsafe.Pointer(v499)) = libc.Uint8FromInt32(int32(INST_POP))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v501 = delta1
				v502 = envPtr2
				if v501 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v502)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v502)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v502)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v502)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v502 + 64)) += int64(v501)
			}
			_objIndexCopy5 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+21234, libc.Int64FromUint64(libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)), 0)
			if _objIndexCopy5 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v504 = envPtr2 + 152
				v503 = *(*uintptr)(unsafe.Pointer(v504))
				*(*uintptr)(unsafe.Pointer(v504))++
				*(*uint8)(unsafe.Pointer(v503)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v506 = envPtr2 + 152
				v505 = *(*uintptr)(unsafe.Pointer(v506))
				*(*uintptr)(unsafe.Pointer(v506))++
				*(*uint8)(unsafe.Pointer(v505)) = uint8(libc.Uint32FromInt32(_objIndexCopy5))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy5
					}
					v507 = delta1
					v508 = envPtr2
					if v507 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v508)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v508)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v508)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v508)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v508 + 64)) += int64(v507)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v510 = envPtr2 + 152
				v509 = *(*uintptr)(unsafe.Pointer(v510))
				*(*uintptr)(unsafe.Pointer(v510))++
				*(*uint8)(unsafe.Pointer(v509)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v512 = envPtr2 + 152
				v511 = *(*uintptr)(unsafe.Pointer(v512))
				*(*uintptr)(unsafe.Pointer(v512))++
				*(*uint8)(unsafe.Pointer(v511)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(24))
				v514 = envPtr2 + 152
				v513 = *(*uintptr)(unsafe.Pointer(v514))
				*(*uintptr)(unsafe.Pointer(v514))++
				*(*uint8)(unsafe.Pointer(v513)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(16))
				v516 = envPtr2 + 152
				v515 = *(*uintptr)(unsafe.Pointer(v516))
				*(*uintptr)(unsafe.Pointer(v516))++
				*(*uint8)(unsafe.Pointer(v515)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(8))
				v518 = envPtr2 + 152
				v517 = *(*uintptr)(unsafe.Pointer(v518))
				*(*uintptr)(unsafe.Pointer(v518))++
				*(*uint8)(unsafe.Pointer(v517)) = uint8(libc.Uint32FromInt32(_objIndexCopy5))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy5
					}
					v519 = delta1
					v520 = envPtr2
					if v519 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v520)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v520)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v520)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v520)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v520 + 64)) += int64(v519)
				}
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v522 = envPtr2 + 152
			v521 = *(*uintptr)(unsafe.Pointer(v522))
			*(*uintptr)(unsafe.Pointer(v522))++
			*(*uint8)(unsafe.Pointer(v521)) = libc.Uint8FromInt32(int32(INST_REVERSE))
			v524 = envPtr2 + 152
			v523 = *(*uintptr)(unsafe.Pointer(v524))
			*(*uintptr)(unsafe.Pointer(v524))++
			*(*uint8)(unsafe.Pointer(v523)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
			v526 = envPtr2 + 152
			v525 = *(*uintptr)(unsafe.Pointer(v526))
			*(*uintptr)(unsafe.Pointer(v526))++
			*(*uint8)(unsafe.Pointer(v525)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
			v528 = envPtr2 + 152
			v527 = *(*uintptr)(unsafe.Pointer(v528))
			*(*uintptr)(unsafe.Pointer(v528))++
			*(*uint8)(unsafe.Pointer(v527)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
			v530 = envPtr2 + 152
			v529 = *(*uintptr)(unsafe.Pointer(v530))
			*(*uintptr)(unsafe.Pointer(v530))++
			*(*uint8)(unsafe.Pointer(v529)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - int32(2)
				}
				v531 = delta1
				v532 = envPtr2
				if v531 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v532)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v532)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v532)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v532)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v532 + 64)) += int64(v531)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v534 = envPtr2 + 152
			v533 = *(*uintptr)(unsafe.Pointer(v534))
			*(*uintptr)(unsafe.Pointer(v534))++
			*(*uint8)(unsafe.Pointer(v533)) = libc.Uint8FromInt32(int32(INST_DICT_SET))
			v536 = envPtr2 + 152
			v535 = *(*uintptr)(unsafe.Pointer(v536))
			*(*uintptr)(unsafe.Pointer(v536))++
			*(*uint8)(unsafe.Pointer(v535)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(24))
			v538 = envPtr2 + 152
			v537 = *(*uintptr)(unsafe.Pointer(v538))
			*(*uintptr)(unsafe.Pointer(v538))++
			*(*uint8)(unsafe.Pointer(v537)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(16))
			v540 = envPtr2 + 152
			v539 = *(*uintptr)(unsafe.Pointer(v540))
			*(*uintptr)(unsafe.Pointer(v540))++
			*(*uint8)(unsafe.Pointer(v539)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(8))
			v542 = envPtr2 + 152
			v541 = *(*uintptr)(unsafe.Pointer(v542))
			*(*uintptr)(unsafe.Pointer(v542))++
			*(*uint8)(unsafe.Pointer(v541)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_DICT_SET)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - int32(1)
				}
				v543 = delta1
				v544 = envPtr2
				if v543 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v544)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v544)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v544)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v544)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v544 + 64)) += int64(v543)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v546 = envPtr2 + 152
			v545 = *(*uintptr)(unsafe.Pointer(v546))
			*(*uintptr)(unsafe.Pointer(v546))++
			*(*uint8)(unsafe.Pointer(v545)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(24))
			v548 = envPtr2 + 152
			v547 = *(*uintptr)(unsafe.Pointer(v548))
			*(*uintptr)(unsafe.Pointer(v548))++
			*(*uint8)(unsafe.Pointer(v547)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(16))
			v550 = envPtr2 + 152
			v549 = *(*uintptr)(unsafe.Pointer(v550))
			*(*uintptr)(unsafe.Pointer(v550))++
			*(*uint8)(unsafe.Pointer(v549)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(8))
			v552 = envPtr2 + 152
			v551 = *(*uintptr)(unsafe.Pointer(v552))
			*(*uintptr)(unsafe.Pointer(v552))++
			*(*uint8)(unsafe.Pointer(v551)) = uint8(libc.Uint32FromInt32(optionsVar))
			v553 = -int32(1)
			v554 = envPtr2
			if v553 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v554)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v554)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v554)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v554)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v554 + 64)) += int64(v553)
			*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(dontChangeOptions) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(dontChangeOptions)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v556 = envPtr2 + 152
			v555 = *(*uintptr)(unsafe.Pointer(v556))
			*(*uintptr)(unsafe.Pointer(v556))++
			*(*uint8)(unsafe.Pointer(v555)) = libc.Uint8FromInt32(int32(INST_REVERSE))
			v558 = envPtr2 + 152
			v557 = *(*uintptr)(unsafe.Pointer(v558))
			*(*uintptr)(unsafe.Pointer(v558))++
			*(*uint8)(unsafe.Pointer(v557)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
			v560 = envPtr2 + 152
			v559 = *(*uintptr)(unsafe.Pointer(v560))
			*(*uintptr)(unsafe.Pointer(v560))++
			*(*uint8)(unsafe.Pointer(v559)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
			v562 = envPtr2 + 152
			v561 = *(*uintptr)(unsafe.Pointer(v562))
			*(*uintptr)(unsafe.Pointer(v562))++
			*(*uint8)(unsafe.Pointer(v561)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
			v564 = envPtr2 + 152
			v563 = *(*uintptr)(unsafe.Pointer(v564))
			*(*uintptr)(unsafe.Pointer(v564))++
			*(*uint8)(unsafe.Pointer(v563)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - int32(2)
				}
				v565 = delta1
				v566 = envPtr2
				if v565 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v566)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v566)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v566)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v566)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v566 + 64)) += int64(v565)
			}
			XTclEmitInvoke(tls, envPtr2, int32(INST_RETURN_STK), 0)
		}
		*(*int32)(unsafe.Pointer(addrsToFix + uintptr(i1)*4)) = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v568 = envPtr2 + 152
		v567 = *(*uintptr)(unsafe.Pointer(v568))
		*(*uintptr)(unsafe.Pointer(v568))++
		*(*uint8)(unsafe.Pointer(v567)) = libc.Uint8FromInt32(int32(INST_JUMP4))
		v570 = envPtr2 + 152
		v569 = *(*uintptr)(unsafe.Pointer(v570))
		*(*uintptr)(unsafe.Pointer(v570))++
		*(*uint8)(unsafe.Pointer(v569)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
		v572 = envPtr2 + 152
		v571 = *(*uintptr)(unsafe.Pointer(v572))
		*(*uintptr)(unsafe.Pointer(v572))++
		*(*uint8)(unsafe.Pointer(v571)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
		v574 = envPtr2 + 152
		v573 = *(*uintptr)(unsafe.Pointer(v574))
		*(*uintptr)(unsafe.Pointer(v574))++
		*(*uint8)(unsafe.Pointer(v573)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
		v576 = envPtr2 + 152
		v575 = *(*uintptr)(unsafe.Pointer(v576))
		*(*uintptr)(unsafe.Pointer(v576))++
		*(*uint8)(unsafe.Pointer(v575)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v577 = delta1
			v578 = envPtr2
			if v577 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v578)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v578)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v578)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v578)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v578 + 64)) += int64(v577)
		}
		if *(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i1)*8)) != 0 {
			*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(notECJumpSource) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(notECJumpSource)) >> libc.Int32FromInt32(24))
			*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(notECJumpSource) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(notECJumpSource)) >> libc.Int32FromInt32(16))
			*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(notECJumpSource) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(notECJumpSource)) >> libc.Int32FromInt32(8))
			*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(notECJumpSource) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(notECJumpSource)))
		}
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(notCodeJumpSource) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(notCodeJumpSource)) >> libc.Int32FromInt32(24))
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(notCodeJumpSource) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(notCodeJumpSource)) >> libc.Int32FromInt32(16))
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(notCodeJumpSource) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(notCodeJumpSource)) >> libc.Int32FromInt32(8))
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(notCodeJumpSource) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(notCodeJumpSource)))
		goto _131
	_131:
		;
		i1++
	}
	/*
	 * Drop the result code since it didn't match any clause, and reissue the
	 * exception. Note also that INST_RETURN_STK can proceed to the next
	 * instruction.
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v580 = envPtr2 + 152
	v579 = *(*uintptr)(unsafe.Pointer(v580))
	*(*uintptr)(unsafe.Pointer(v580))++
	*(*uint8)(unsafe.Pointer(v579)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v581 = delta1
		v582 = envPtr2
		if v581 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v582)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v582)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v582)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v582)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v582 + 64)) += int64(v581)
	}
	if optionsVar < int32(256) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v584 = envPtr2 + 152
		v583 = *(*uintptr)(unsafe.Pointer(v584))
		*(*uintptr)(unsafe.Pointer(v584))++
		*(*uint8)(unsafe.Pointer(v583)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
		v586 = envPtr2 + 152
		v585 = *(*uintptr)(unsafe.Pointer(v586))
		*(*uintptr)(unsafe.Pointer(v586))++
		*(*uint8)(unsafe.Pointer(v585)) = uint8(libc.Uint32FromInt32(optionsVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - optionsVar
			}
			v587 = delta1
			v588 = envPtr2
			if v587 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v588)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v588)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v588)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v588)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v588 + 64)) += int64(v587)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v590 = envPtr2 + 152
		v589 = *(*uintptr)(unsafe.Pointer(v590))
		*(*uintptr)(unsafe.Pointer(v590))++
		*(*uint8)(unsafe.Pointer(v589)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
		v592 = envPtr2 + 152
		v591 = *(*uintptr)(unsafe.Pointer(v592))
		*(*uintptr)(unsafe.Pointer(v592))++
		*(*uint8)(unsafe.Pointer(v591)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(24))
		v594 = envPtr2 + 152
		v593 = *(*uintptr)(unsafe.Pointer(v594))
		*(*uintptr)(unsafe.Pointer(v594))++
		*(*uint8)(unsafe.Pointer(v593)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(16))
		v596 = envPtr2 + 152
		v595 = *(*uintptr)(unsafe.Pointer(v596))
		*(*uintptr)(unsafe.Pointer(v596))++
		*(*uint8)(unsafe.Pointer(v595)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(8))
		v598 = envPtr2 + 152
		v597 = *(*uintptr)(unsafe.Pointer(v598))
		*(*uintptr)(unsafe.Pointer(v598))++
		*(*uint8)(unsafe.Pointer(v597)) = uint8(libc.Uint32FromInt32(optionsVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - optionsVar
			}
			v599 = delta1
			v600 = envPtr2
			if v599 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v600)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v600)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v600)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v600)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v600 + 64)) += int64(v599)
		}
	}
	if resultVar < int32(256) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v602 = envPtr2 + 152
		v601 = *(*uintptr)(unsafe.Pointer(v602))
		*(*uintptr)(unsafe.Pointer(v602))++
		*(*uint8)(unsafe.Pointer(v601)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
		v604 = envPtr2 + 152
		v603 = *(*uintptr)(unsafe.Pointer(v604))
		*(*uintptr)(unsafe.Pointer(v604))++
		*(*uint8)(unsafe.Pointer(v603)) = uint8(libc.Uint32FromInt32(resultVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - resultVar
			}
			v605 = delta1
			v606 = envPtr2
			if v605 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v606)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v606)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v606)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v606)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v606 + 64)) += int64(v605)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v608 = envPtr2 + 152
		v607 = *(*uintptr)(unsafe.Pointer(v608))
		*(*uintptr)(unsafe.Pointer(v608))++
		*(*uint8)(unsafe.Pointer(v607)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
		v610 = envPtr2 + 152
		v609 = *(*uintptr)(unsafe.Pointer(v610))
		*(*uintptr)(unsafe.Pointer(v610))++
		*(*uint8)(unsafe.Pointer(v609)) = uint8(libc.Uint32FromInt32(resultVar) >> libc.Int32FromInt32(24))
		v612 = envPtr2 + 152
		v611 = *(*uintptr)(unsafe.Pointer(v612))
		*(*uintptr)(unsafe.Pointer(v612))++
		*(*uint8)(unsafe.Pointer(v611)) = uint8(libc.Uint32FromInt32(resultVar) >> libc.Int32FromInt32(16))
		v614 = envPtr2 + 152
		v613 = *(*uintptr)(unsafe.Pointer(v614))
		*(*uintptr)(unsafe.Pointer(v614))++
		*(*uint8)(unsafe.Pointer(v613)) = uint8(libc.Uint32FromInt32(resultVar) >> libc.Int32FromInt32(8))
		v616 = envPtr2 + 152
		v615 = *(*uintptr)(unsafe.Pointer(v616))
		*(*uintptr)(unsafe.Pointer(v616))++
		*(*uint8)(unsafe.Pointer(v615)) = uint8(libc.Uint32FromInt32(resultVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - resultVar
			}
			v617 = delta1
			v618 = envPtr2
			if v617 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v618)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v618)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v618)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v618)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v618 + 64)) += int64(v617)
		}
	}
	XTclEmitInvoke(tls, envPtr2, int32(INST_RETURN_STK), 0)
	/*
	 * Fix all the jumps from taken clauses to here (which is the end of the
	 * [try]).
	 */
	if !(trapZero != 0) {
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(afterBody) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(afterBody)) >> libc.Int32FromInt32(24))
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(afterBody) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(afterBody)) >> libc.Int32FromInt32(16))
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(afterBody) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(afterBody)) >> libc.Int32FromInt32(8))
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(afterBody) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(afterBody)))
	}
	i1 = 0
	for {
		if !(i1 < numHandlers) {
			break
		}
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(*(*int32)(unsafe.Pointer(addrsToFix + uintptr(i1)*4))) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(*(*int32)(unsafe.Pointer(addrsToFix + uintptr(i1)*4)))) >> libc.Int32FromInt32(24))
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(*(*int32)(unsafe.Pointer(addrsToFix + uintptr(i1)*4))) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(*(*int32)(unsafe.Pointer(addrsToFix + uintptr(i1)*4)))) >> libc.Int32FromInt32(16))
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(*(*int32)(unsafe.Pointer(addrsToFix + uintptr(i1)*4))) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(*(*int32)(unsafe.Pointer(addrsToFix + uintptr(i1)*4)))) >> libc.Int32FromInt32(8))
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(*(*int32)(unsafe.Pointer(addrsToFix + uintptr(i1)*4))) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(*(*int32)(unsafe.Pointer(addrsToFix + uintptr(i1)*4)))))
		if *(*int32)(unsafe.Pointer(noError + uintptr(i1)*4)) != -int32(1) {
			*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(*(*int32)(unsafe.Pointer(noError + uintptr(i1)*4))) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(*(*int32)(unsafe.Pointer(noError + uintptr(i1)*4)))) >> libc.Int32FromInt32(24))
			*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(*(*int32)(unsafe.Pointer(noError + uintptr(i1)*4))) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(*(*int32)(unsafe.Pointer(noError + uintptr(i1)*4)))) >> libc.Int32FromInt32(16))
			*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(*(*int32)(unsafe.Pointer(noError + uintptr(i1)*4))) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(*(*int32)(unsafe.Pointer(noError + uintptr(i1)*4)))) >> libc.Int32FromInt32(8))
			*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(*(*int32)(unsafe.Pointer(noError + uintptr(i1)*4))) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(*(*int32)(unsafe.Pointer(noError + uintptr(i1)*4)))))
		}
		goto _619
	_619:
		;
		i1++
	}
	XTclStackFree(tls, interp, noError)
	XTclStackFree(tls, interp, forwardsToFix)
	XTclStackFree(tls, interp, addrsToFix)
	return TCL_OK
}

func _IssueTryClausesFinallyInstructions(tls *libc.TLS, interp uintptr, envPtr2 uintptr, bodyToken uintptr, numHandlers int32, matchCodes uintptr, matchClauses uintptr, resultVars uintptr, optionVars uintptr, handlerTokens uintptr, finallyToken uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Not NULL */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, _objIndexCopy4, _objIndexCopy5, _objIndexCopy6, _objIndexCopy7, _objIndexCopy8, _objIndexCopy9, afterBody, delta1, finalError, finalOK, forwardsNeedFixing, i1, j, noFinalError, noTrapError, notCodeJumpSource, notECJumpSource, optionsVar, range1, resultVar, trapError, trapZero, v109, v12, v121, v127, v129, v133, v137, v141, v145, v151, v163, v167, v17, v173, v185, v189, v194, v200, v212, v216, v228, v23, v236, v248, v254, v266, v278, v280, v292, v307, v319, v323, v335, v339, v35, v351, v358, v370, v376, v388, v39, v392, v398, v410, v416, v428, v432, v436, v448, v45, v460, v466, v479, v485, v497, v501, v513, v519, v521, v525, v529, v533, v537, v543, v555, v559, v565, v57, v577, v581, v587, v593, v605, v611, v623, v63, v635, v641, v653, v657, v669, v679, v685, v691, v703, v707, v719, v721, v725, v738, v743, v747, v75, v753, v757, v761, v765, v769, v775, v787, v79, v791, v797, v803, v815, v821, v833, v845, v851, v863, v867, v879, v889, v893, v899, v901, v907, v91, v919, v923, v929, v941, v945, v951, v963, v969, v97, v981 int32
	var addrsToFix, forwardsToFix, mapPtr, p, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v120, v122, v123, v124, v125, v126, v128, v13, v130, v131, v132, v134, v135, v136, v138, v139, v140, v142, v143, v144, v146, v147, v148, v149, v15, v150, v152, v153, v154, v155, v156, v157, v158, v159, v16, v160, v161, v162, v164, v165, v166, v168, v169, v170, v171, v172, v174, v175, v176, v177, v178, v179, v18, v180, v181, v182, v183, v184, v186, v187, v188, v19, v190, v192, v193, v195, v196, v197, v198, v199, v2, v20, v201, v202, v203, v204, v205, v206, v207, v208, v209, v21, v210, v211, v213, v214, v215, v217, v218, v219, v22, v220, v221, v222, v223, v224, v225, v226, v227, v229, v232, v233, v234, v235, v237, v238, v239, v24, v240, v241, v242, v243, v244, v245, v246, v247, v249, v25, v250, v251, v252, v253, v255, v256, v257, v258, v259, v26, v260, v261, v262, v263, v264, v265, v267, v268, v269, v27, v270, v271, v272, v273, v274, v275, v276, v277, v279, v28, v281, v282, v283, v284, v285, v286, v287, v288, v289, v29, v290, v291, v293, v294, v295, v296, v297, v298, v299, v3, v30, v300, v301, v302, v303, v304, v305, v306, v308, v309, v31, v310, v311, v312, v313, v314, v315, v316, v317, v318, v32, v320, v321, v322, v324, v325, v326, v327, v328, v329, v33, v330, v331, v332, v333, v334, v336, v337, v338, v34, v340, v341, v342, v343, v344, v345, v346, v347, v348, v349, v350, v352, v354, v355, v356, v357, v359, v36, v360, v361, v362, v363, v364, v365, v366, v367, v368, v369, v37, v371, v372, v373, v374, v375, v377, v378, v379, v38, v380, v381, v382, v383, v384, v385, v386, v387, v389, v390, v391, v393, v394, v395, v396, v397, v399, v4, v40, v400, v401, v402, v403, v404, v405, v406, v407, v408, v409, v41, v411, v412, v413, v414, v415, v417, v418, v419, v42, v420, v421, v422, v423, v424, v425, v426, v427, v429, v43, v430, v431, v433, v434, v435, v437, v438, v439, v44, v440, v441, v442, v443, v444, v445, v446, v447, v449, v450, v451, v452, v453, v454, v455, v456, v457, v458, v459, v46, v461, v462, v463, v464, v465, v467, v469, v47, v470, v471, v472, v473, v474, v475, v476, v477, v478, v48, v480, v481, v482, v483, v484, v486, v487, v488, v489, v49, v490, v491, v492, v493, v494, v495, v496, v498, v499, v5, v50, v500, v502, v503, v504, v505, v506, v507, v508, v509, v51, v510, v511, v512, v514, v515, v516, v517, v518, v52, v520, v522, v523, v524, v526, v527, v528, v53, v530, v531, v532, v534, v535, v536, v538, v539, v54, v540, v541, v542, v544, v545, v546, v547, v548, v549, v55, v550, v551, v552, v553, v554, v556, v557, v558, v56, v560, v561, v562, v563, v564, v566, v567, v568, v569, v570, v571, v572, v573, v574, v575, v576, v578, v579, v58, v580, v582, v583, v584, v585, v586, v588, v589, v59, v590, v591, v592, v594, v595, v596, v597, v598, v599, v6, v60, v600, v601, v602, v603, v604, v606, v607, v608, v609, v61, v610, v612, v613, v614, v615, v616, v617, v618, v619, v62, v620, v621, v622, v624, v625, v626, v627, v628, v629, v630, v631, v632, v633, v634, v636, v637, v638, v639, v64, v640, v642, v643, v644, v645, v646, v647, v648, v649, v65, v650, v651, v652, v654, v655, v656, v658, v659, v66, v660, v661, v662, v663, v664, v665, v666, v667, v668, v67, v670, v671, v672, v673, v674, v675, v676, v677, v678, v68, v680, v681, v682, v683, v684, v686, v687, v688, v689, v69, v690, v692, v693, v694, v695, v696, v697, v698, v699, v7, v70, v700, v701, v702, v704, v705, v706, v708, v709, v71, v710, v711, v712, v713, v714, v715, v716, v717, v718, v72, v720, v722, v723, v724, v726, v728, v729, v73, v730, v731, v732, v733, v734, v735, v736, v737, v739, v74, v741, v742, v744, v745, v746, v748, v749, v750, v751, v752, v754, v755, v756, v758, v759, v76, v760, v762, v763, v764, v766, v767, v768, v77, v770, v771, v772, v773, v774, v776, v777, v778, v779, v78, v780, v781, v782, v783, v784, v785, v786, v788, v789, v790, v792, v793, v794, v795, v796, v798, v799, v8, v80, v800, v801, v802, v804, v805, v806, v807, v808, v809, v81, v810, v811, v812, v813, v814, v816, v817, v818, v819, v82, v820, v822, v823, v824, v825, v826, v827, v828, v829, v83, v830, v831, v832, v834, v835, v836, v837, v838, v839, v84, v840, v841, v842, v843, v844, v846, v847, v848, v849, v85, v850, v852, v853, v854, v855, v856, v857, v858, v859, v86, v860, v861, v862, v864, v865, v866, v868, v869, v87, v870, v871, v872, v873, v874, v875, v876, v877, v878, v88, v880, v881, v882, v883, v884, v885, v886, v887, v888, v89, v890, v891, v892, v894, v895, v896, v897, v898, v9, v90, v900, v902, v903, v904, v905, v906, v908, v909, v910, v911, v912, v913, v914, v915, v916, v917, v918, v92, v920, v921, v922, v924, v925, v926, v927, v928, v93, v930, v931, v932, v933, v934, v935, v936, v937, v938, v939, v94, v940, v942, v943, v944, v946, v947, v948, v949, v95, v950, v952, v953, v954, v955, v956, v957, v958, v959, v96, v960, v961, v962, v964, v965, v966, v967, v968, v970, v971, v972, v973, v974, v975, v976, v977, v978, v979, v98, v980, v982, v99 uintptr
	var eclIndex TTcl_Size
	var v14, v231, v353, v740 int64
	var _ /* buf at bp+0 */ [24]uint8
	var _ /* len at bp+32 */ TTcl_Size
	var _ /* slen at bp+24 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, _objIndexCopy4, _objIndexCopy5, _objIndexCopy6, _objIndexCopy7, _objIndexCopy8, _objIndexCopy9, addrsToFix, afterBody, delta1, eclIndex, finalError, finalOK, forwardsNeedFixing, forwardsToFix, i1, j, mapPtr, noFinalError, noTrapError, notCodeJumpSource, notECJumpSource, optionsVar, p, range1, resultVar, trapError, trapZero, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v123, v124, v125, v126, v127, v128, v129, v13, v130, v131, v132, v133, v134, v135, v136, v137, v138, v139, v14, v140, v141, v142, v143, v144, v145, v146, v147, v148, v149, v15, v150, v151, v152, v153, v154, v155, v156, v157, v158, v159, v16, v160, v161, v162, v163, v164, v165, v166, v167, v168, v169, v17, v170, v171, v172, v173, v174, v175, v176, v177, v178, v179, v18, v180, v181, v182, v183, v184, v185, v186, v187, v188, v189, v19, v190, v192, v193, v194, v195, v196, v197, v198, v199, v2, v20, v200, v201, v202, v203, v204, v205, v206, v207, v208, v209, v21, v210, v211, v212, v213, v214, v215, v216, v217, v218, v219, v22, v220, v221, v222, v223, v224, v225, v226, v227, v228, v229, v23, v231, v232, v233, v234, v235, v236, v237, v238, v239, v24, v240, v241, v242, v243, v244, v245, v246, v247, v248, v249, v25, v250, v251, v252, v253, v254, v255, v256, v257, v258, v259, v26, v260, v261, v262, v263, v264, v265, v266, v267, v268, v269, v27, v270, v271, v272, v273, v274, v275, v276, v277, v278, v279, v28, v280, v281, v282, v283, v284, v285, v286, v287, v288, v289, v29, v290, v291, v292, v293, v294, v295, v296, v297, v298, v299, v3, v30, v300, v301, v302, v303, v304, v305, v306, v307, v308, v309, v31, v310, v311, v312, v313, v314, v315, v316, v317, v318, v319, v32, v320, v321, v322, v323, v324, v325, v326, v327, v328, v329, v33, v330, v331, v332, v333, v334, v335, v336, v337, v338, v339, v34, v340, v341, v342, v343, v344, v345, v346, v347, v348, v349, v35, v350, v351, v352, v353, v354, v355, v356, v357, v358, v359, v36, v360, v361, v362, v363, v364, v365, v366, v367, v368, v369, v37, v370, v371, v372, v373, v374, v375, v376, v377, v378, v379, v38, v380, v381, v382, v383, v384, v385, v386, v387, v388, v389, v39, v390, v391, v392, v393, v394, v395, v396, v397, v398, v399, v4, v40, v400, v401, v402, v403, v404, v405, v406, v407, v408, v409, v41, v410, v411, v412, v413, v414, v415, v416, v417, v418, v419, v42, v420, v421, v422, v423, v424, v425, v426, v427, v428, v429, v43, v430, v431, v432, v433, v434, v435, v436, v437, v438, v439, v44, v440, v441, v442, v443, v444, v445, v446, v447, v448, v449, v45, v450, v451, v452, v453, v454, v455, v456, v457, v458, v459, v46, v460, v461, v462, v463, v464, v465, v466, v467, v469, v47, v470, v471, v472, v473, v474, v475, v476, v477, v478, v479, v48, v480, v481, v482, v483, v484, v485, v486, v487, v488, v489, v49, v490, v491, v492, v493, v494, v495, v496, v497, v498, v499, v5, v50, v500, v501, v502, v503, v504, v505, v506, v507, v508, v509, v51, v510, v511, v512, v513, v514, v515, v516, v517, v518, v519, v52, v520, v521, v522, v523, v524, v525, v526, v527, v528, v529, v53, v530, v531, v532, v533, v534, v535, v536, v537, v538, v539, v54, v540, v541, v542, v543, v544, v545, v546, v547, v548, v549, v55, v550, v551, v552, v553, v554, v555, v556, v557, v558, v559, v56, v560, v561, v562, v563, v564, v565, v566, v567, v568, v569, v57, v570, v571, v572, v573, v574, v575, v576, v577, v578, v579, v58, v580, v581, v582, v583, v584, v585, v586, v587, v588, v589, v59, v590, v591, v592, v593, v594, v595, v596, v597, v598, v599, v6, v60, v600, v601, v602, v603, v604, v605, v606, v607, v608, v609, v61, v610, v611, v612, v613, v614, v615, v616, v617, v618, v619, v62, v620, v621, v622, v623, v624, v625, v626, v627, v628, v629, v63, v630, v631, v632, v633, v634, v635, v636, v637, v638, v639, v64, v640, v641, v642, v643, v644, v645, v646, v647, v648, v649, v65, v650, v651, v652, v653, v654, v655, v656, v657, v658, v659, v66, v660, v661, v662, v663, v664, v665, v666, v667, v668, v669, v67, v670, v671, v672, v673, v674, v675, v676, v677, v678, v679, v68, v680, v681, v682, v683, v684, v685, v686, v687, v688, v689, v69, v690, v691, v692, v693, v694, v695, v696, v697, v698, v699, v7, v70, v700, v701, v702, v703, v704, v705, v706, v707, v708, v709, v71, v710, v711, v712, v713, v714, v715, v716, v717, v718, v719, v72, v720, v721, v722, v723, v724, v725, v726, v728, v729, v73, v730, v731, v732, v733, v734, v735, v736, v737, v738, v739, v74, v740, v741, v742, v743, v744, v745, v746, v747, v748, v749, v75, v750, v751, v752, v753, v754, v755, v756, v757, v758, v759, v76, v760, v761, v762, v763, v764, v765, v766, v767, v768, v769, v77, v770, v771, v772, v773, v774, v775, v776, v777, v778, v779, v78, v780, v781, v782, v783, v784, v785, v786, v787, v788, v789, v79, v790, v791, v792, v793, v794, v795, v796, v797, v798, v799, v8, v80, v800, v801, v802, v803, v804, v805, v806, v807, v808, v809, v81, v810, v811, v812, v813, v814, v815, v816, v817, v818, v819, v82, v820, v821, v822, v823, v824, v825, v826, v827, v828, v829, v83, v830, v831, v832, v833, v834, v835, v836, v837, v838, v839, v84, v840, v841, v842, v843, v844, v845, v846, v847, v848, v849, v85, v850, v851, v852, v853, v854, v855, v856, v857, v858, v859, v86, v860, v861, v862, v863, v864, v865, v866, v867, v868, v869, v87, v870, v871, v872, v873, v874, v875, v876, v877, v878, v879, v88, v880, v881, v882, v883, v884, v885, v886, v887, v888, v889, v89, v890, v891, v892, v893, v894, v895, v896, v897, v898, v899, v9, v90, v900, v901, v902, v903, v904, v905, v906, v907, v908, v909, v91, v910, v911, v912, v913, v914, v915, v916, v917, v918, v919, v92, v920, v921, v922, v923, v924, v925, v926, v927, v928, v929, v93, v930, v931, v932, v933, v934, v935, v936, v937, v938, v939, v94, v940, v941, v942, v943, v944, v945, v946, v947, v948, v949, v95, v950, v951, v952, v953, v954, v955, v956, v957, v958, v959, v96, v960, v961, v962, v963, v964, v965, v966, v967, v968, v969, v97, v970, v971, v972, v973, v974, v975, v976, v977, v978, v979, v98, v980, v981, v982, v99
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	forwardsNeedFixing = 0
	trapZero = 0
	afterBody = 0
	resultVar = int32(XTclFindCompiledLocal(tls, libc.UintptrFromInt32(0), 0, int32(1), envPtr2))
	optionsVar = int32(XTclFindCompiledLocal(tls, libc.UintptrFromInt32(0), 0, int32(1), envPtr2))
	if resultVar < 0 || optionsVar < 0 {
		return int32(TCL_ERROR)
	}
	/*
	 * Check if we're supposed to trap a normal TCL_OK completion of the body.
	 * If not, we can handle that case much more efficiently.
	 */
	i1 = 0
	for {
		if !(i1 < numHandlers) {
			break
		}
		if *(*int32)(unsafe.Pointer(matchCodes + uintptr(i1)*4)) == 0 {
			trapZero = int32(1)
			break
		}
		goto _1
	_1:
		;
		i1++
	}
	/*
	 * Compile the body, trapping any error in it so that we can trap on it
	 * (if any trap matches) and run a finally clause.
	 */
	range1 = int32(XTclCreateExceptRange(tls, int32(CATCH_EXCEPTION_RANGE), envPtr2))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v3 = envPtr2 + 152
	v2 = *(*uintptr)(unsafe.Pointer(v3))
	*(*uintptr)(unsafe.Pointer(v3))++
	*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32(INST_BEGIN_CATCH4))
	v5 = envPtr2 + 152
	v4 = *(*uintptr)(unsafe.Pointer(v5))
	*(*uintptr)(unsafe.Pointer(v5))++
	*(*uint8)(unsafe.Pointer(v4)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(24))
	v7 = envPtr2 + 152
	v6 = *(*uintptr)(unsafe.Pointer(v7))
	*(*uintptr)(unsafe.Pointer(v7))++
	*(*uint8)(unsafe.Pointer(v6)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(16))
	v9 = envPtr2 + 152
	v8 = *(*uintptr)(unsafe.Pointer(v9))
	*(*uintptr)(unsafe.Pointer(v9))++
	*(*uint8)(unsafe.Pointer(v8)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(8))
	v11 = envPtr2 + 152
	v10 = *(*uintptr)(unsafe.Pointer(v11))
	*(*uintptr)(unsafe.Pointer(v11))++
	*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt32(range1))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_BEGIN_CATCH4)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - range1
		}
		v12 = delta1
		v13 = envPtr2
		if v12 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v13)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v13)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v13)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v13)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v13 + 64)) += int64(v12)
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth++
	if libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth)+uint64(1) > libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth)+uint64(1) {
		v14 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth
	} else {
		v14 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth = v14
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
	XTclCompileCmdWord(tls, interp, bodyToken+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(bodyToken)).FnumComponents), envPtr2)
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth--
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FnumCodeBytes = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(int32((*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset))
	if !(trapZero != 0) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v16 = envPtr2 + 152
		v15 = *(*uintptr)(unsafe.Pointer(v16))
		*(*uintptr)(unsafe.Pointer(v16))++
		*(*uint8)(unsafe.Pointer(v15)) = libc.Uint8FromInt32(int32(INST_END_CATCH))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_END_CATCH)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v17 = delta1
			v18 = envPtr2
			if v17 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
		}
		if resultVar < int32(256) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v20 = envPtr2 + 152
			v19 = *(*uintptr)(unsafe.Pointer(v20))
			*(*uintptr)(unsafe.Pointer(v20))++
			*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
			v22 = envPtr2 + 152
			v21 = *(*uintptr)(unsafe.Pointer(v22))
			*(*uintptr)(unsafe.Pointer(v22))++
			*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(resultVar))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - resultVar
				}
				v23 = delta1
				v24 = envPtr2
				if v23 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v24 + 64)) += int64(v23)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v26 = envPtr2 + 152
			v25 = *(*uintptr)(unsafe.Pointer(v26))
			*(*uintptr)(unsafe.Pointer(v26))++
			*(*uint8)(unsafe.Pointer(v25)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
			v28 = envPtr2 + 152
			v27 = *(*uintptr)(unsafe.Pointer(v28))
			*(*uintptr)(unsafe.Pointer(v28))++
			*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(resultVar) >> libc.Int32FromInt32(24))
			v30 = envPtr2 + 152
			v29 = *(*uintptr)(unsafe.Pointer(v30))
			*(*uintptr)(unsafe.Pointer(v30))++
			*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(resultVar) >> libc.Int32FromInt32(16))
			v32 = envPtr2 + 152
			v31 = *(*uintptr)(unsafe.Pointer(v32))
			*(*uintptr)(unsafe.Pointer(v32))++
			*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(resultVar) >> libc.Int32FromInt32(8))
			v34 = envPtr2 + 152
			v33 = *(*uintptr)(unsafe.Pointer(v34))
			*(*uintptr)(unsafe.Pointer(v34))++
			*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(resultVar))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - resultVar
				}
				v35 = delta1
				v36 = envPtr2
				if v35 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v36 + 64)) += int64(v35)
			}
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v38 = envPtr2 + 152
		v37 = *(*uintptr)(unsafe.Pointer(v38))
		*(*uintptr)(unsafe.Pointer(v38))++
		*(*uint8)(unsafe.Pointer(v37)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v39 = delta1
			v40 = envPtr2
			if v39 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v40 + 64)) += int64(v39)
		}
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+22354, libc.Int64FromUint64(libc.Uint64FromInt64(17)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v42 = envPtr2 + 152
			v41 = *(*uintptr)(unsafe.Pointer(v42))
			*(*uintptr)(unsafe.Pointer(v42))++
			*(*uint8)(unsafe.Pointer(v41)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v44 = envPtr2 + 152
			v43 = *(*uintptr)(unsafe.Pointer(v44))
			*(*uintptr)(unsafe.Pointer(v44))++
			*(*uint8)(unsafe.Pointer(v43)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v45 = delta1
				v46 = envPtr2
				if v45 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v46)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v46)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v46)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v46)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v46 + 64)) += int64(v45)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v48 = envPtr2 + 152
			v47 = *(*uintptr)(unsafe.Pointer(v48))
			*(*uintptr)(unsafe.Pointer(v48))++
			*(*uint8)(unsafe.Pointer(v47)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v50 = envPtr2 + 152
			v49 = *(*uintptr)(unsafe.Pointer(v50))
			*(*uintptr)(unsafe.Pointer(v50))++
			*(*uint8)(unsafe.Pointer(v49)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v52 = envPtr2 + 152
			v51 = *(*uintptr)(unsafe.Pointer(v52))
			*(*uintptr)(unsafe.Pointer(v52))++
			*(*uint8)(unsafe.Pointer(v51)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v54 = envPtr2 + 152
			v53 = *(*uintptr)(unsafe.Pointer(v54))
			*(*uintptr)(unsafe.Pointer(v54))++
			*(*uint8)(unsafe.Pointer(v53)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v56 = envPtr2 + 152
			v55 = *(*uintptr)(unsafe.Pointer(v56))
			*(*uintptr)(unsafe.Pointer(v56))++
			*(*uint8)(unsafe.Pointer(v55)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v57 = delta1
				v58 = envPtr2
				if v57 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v58)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v58)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v58)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v58)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v58 + 64)) += int64(v57)
			}
		}
		if optionsVar < int32(256) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v60 = envPtr2 + 152
			v59 = *(*uintptr)(unsafe.Pointer(v60))
			*(*uintptr)(unsafe.Pointer(v60))++
			*(*uint8)(unsafe.Pointer(v59)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
			v62 = envPtr2 + 152
			v61 = *(*uintptr)(unsafe.Pointer(v62))
			*(*uintptr)(unsafe.Pointer(v62))++
			*(*uint8)(unsafe.Pointer(v61)) = uint8(libc.Uint32FromInt32(optionsVar))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - optionsVar
				}
				v63 = delta1
				v64 = envPtr2
				if v63 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v64)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v64)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v64)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v64)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v64 + 64)) += int64(v63)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v66 = envPtr2 + 152
			v65 = *(*uintptr)(unsafe.Pointer(v66))
			*(*uintptr)(unsafe.Pointer(v66))++
			*(*uint8)(unsafe.Pointer(v65)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
			v68 = envPtr2 + 152
			v67 = *(*uintptr)(unsafe.Pointer(v68))
			*(*uintptr)(unsafe.Pointer(v68))++
			*(*uint8)(unsafe.Pointer(v67)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(24))
			v70 = envPtr2 + 152
			v69 = *(*uintptr)(unsafe.Pointer(v70))
			*(*uintptr)(unsafe.Pointer(v70))++
			*(*uint8)(unsafe.Pointer(v69)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(16))
			v72 = envPtr2 + 152
			v71 = *(*uintptr)(unsafe.Pointer(v72))
			*(*uintptr)(unsafe.Pointer(v72))++
			*(*uint8)(unsafe.Pointer(v71)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(8))
			v74 = envPtr2 + 152
			v73 = *(*uintptr)(unsafe.Pointer(v74))
			*(*uintptr)(unsafe.Pointer(v74))++
			*(*uint8)(unsafe.Pointer(v73)) = uint8(libc.Uint32FromInt32(optionsVar))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - optionsVar
				}
				v75 = delta1
				v76 = envPtr2
				if v75 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v76)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v76)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v76)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v76)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v76 + 64)) += int64(v75)
			}
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v78 = envPtr2 + 152
		v77 = *(*uintptr)(unsafe.Pointer(v78))
		*(*uintptr)(unsafe.Pointer(v78))++
		*(*uint8)(unsafe.Pointer(v77)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v79 = delta1
			v80 = envPtr2
			if v79 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v80)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v80)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v80)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v80)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v80 + 64)) += int64(v79)
		}
		afterBody = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v82 = envPtr2 + 152
		v81 = *(*uintptr)(unsafe.Pointer(v82))
		*(*uintptr)(unsafe.Pointer(v82))++
		*(*uint8)(unsafe.Pointer(v81)) = libc.Uint8FromInt32(int32(INST_JUMP4))
		v84 = envPtr2 + 152
		v83 = *(*uintptr)(unsafe.Pointer(v84))
		*(*uintptr)(unsafe.Pointer(v84))++
		*(*uint8)(unsafe.Pointer(v83)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
		v86 = envPtr2 + 152
		v85 = *(*uintptr)(unsafe.Pointer(v86))
		*(*uintptr)(unsafe.Pointer(v86))++
		*(*uint8)(unsafe.Pointer(v85)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
		v88 = envPtr2 + 152
		v87 = *(*uintptr)(unsafe.Pointer(v88))
		*(*uintptr)(unsafe.Pointer(v88))++
		*(*uint8)(unsafe.Pointer(v87)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
		v90 = envPtr2 + 152
		v89 = *(*uintptr)(unsafe.Pointer(v90))
		*(*uintptr)(unsafe.Pointer(v90))++
		*(*uint8)(unsafe.Pointer(v89)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v91 = delta1
			v92 = envPtr2
			if v91 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v92)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v92)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v92)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v92)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v92 + 64)) += int64(v91)
		}
	} else {
		_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+14828, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy1 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v94 = envPtr2 + 152
			v93 = *(*uintptr)(unsafe.Pointer(v94))
			*(*uintptr)(unsafe.Pointer(v94))++
			*(*uint8)(unsafe.Pointer(v93)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v96 = envPtr2 + 152
			v95 = *(*uintptr)(unsafe.Pointer(v96))
			*(*uintptr)(unsafe.Pointer(v96))++
			*(*uint8)(unsafe.Pointer(v95)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v97 = delta1
				v98 = envPtr2
				if v97 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v98)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v98)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v98)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v98)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v98 + 64)) += int64(v97)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v100 = envPtr2 + 152
			v99 = *(*uintptr)(unsafe.Pointer(v100))
			*(*uintptr)(unsafe.Pointer(v100))++
			*(*uint8)(unsafe.Pointer(v99)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v102 = envPtr2 + 152
			v101 = *(*uintptr)(unsafe.Pointer(v102))
			*(*uintptr)(unsafe.Pointer(v102))++
			*(*uint8)(unsafe.Pointer(v101)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
			v104 = envPtr2 + 152
			v103 = *(*uintptr)(unsafe.Pointer(v104))
			*(*uintptr)(unsafe.Pointer(v104))++
			*(*uint8)(unsafe.Pointer(v103)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
			v106 = envPtr2 + 152
			v105 = *(*uintptr)(unsafe.Pointer(v106))
			*(*uintptr)(unsafe.Pointer(v106))++
			*(*uint8)(unsafe.Pointer(v105)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
			v108 = envPtr2 + 152
			v107 = *(*uintptr)(unsafe.Pointer(v108))
			*(*uintptr)(unsafe.Pointer(v108))++
			*(*uint8)(unsafe.Pointer(v107)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v109 = delta1
				v110 = envPtr2
				if v109 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v110)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v110)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v110)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v110)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v110 + 64)) += int64(v109)
			}
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v112 = envPtr2 + 152
		v111 = *(*uintptr)(unsafe.Pointer(v112))
		*(*uintptr)(unsafe.Pointer(v112))++
		*(*uint8)(unsafe.Pointer(v111)) = libc.Uint8FromInt32(int32(INST_REVERSE))
		v114 = envPtr2 + 152
		v113 = *(*uintptr)(unsafe.Pointer(v114))
		*(*uintptr)(unsafe.Pointer(v114))++
		*(*uint8)(unsafe.Pointer(v113)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
		v116 = envPtr2 + 152
		v115 = *(*uintptr)(unsafe.Pointer(v116))
		*(*uintptr)(unsafe.Pointer(v116))++
		*(*uint8)(unsafe.Pointer(v115)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
		v118 = envPtr2 + 152
		v117 = *(*uintptr)(unsafe.Pointer(v118))
		*(*uintptr)(unsafe.Pointer(v118))++
		*(*uint8)(unsafe.Pointer(v117)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
		v120 = envPtr2 + 152
		v119 = *(*uintptr)(unsafe.Pointer(v120))
		*(*uintptr)(unsafe.Pointer(v120))++
		*(*uint8)(unsafe.Pointer(v119)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(2)
			}
			v121 = delta1
			v122 = envPtr2
			if v121 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v122)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v122)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v122)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v122)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v122 + 64)) += int64(v121)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v124 = envPtr2 + 152
		v123 = *(*uintptr)(unsafe.Pointer(v124))
		*(*uintptr)(unsafe.Pointer(v124))++
		*(*uint8)(unsafe.Pointer(v123)) = libc.Uint8FromInt32(int32(INST_JUMP1))
		v126 = envPtr2 + 152
		v125 = *(*uintptr)(unsafe.Pointer(v126))
		*(*uintptr)(unsafe.Pointer(v126))++
		*(*uint8)(unsafe.Pointer(v125)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(4)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(4)
			}
			v127 = delta1
			v128 = envPtr2
			if v127 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v128)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v128)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v128)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v128)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v128 + 64)) += int64(v127)
		}
		v129 = -int32(2)
		v130 = envPtr2
		if v129 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v130)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v130)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v130)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v130)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v130 + 64)) += int64(v129)
	}
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcatchOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v132 = envPtr2 + 152
	v131 = *(*uintptr)(unsafe.Pointer(v132))
	*(*uintptr)(unsafe.Pointer(v132))++
	*(*uint8)(unsafe.Pointer(v131)) = libc.Uint8FromInt32(int32(INST_PUSH_RETURN_CODE))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_PUSH_RETURN_CODE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v133 = delta1
		v134 = envPtr2
		if v133 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v134)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v134)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v134)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v134)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v134 + 64)) += int64(v133)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v136 = envPtr2 + 152
	v135 = *(*uintptr)(unsafe.Pointer(v136))
	*(*uintptr)(unsafe.Pointer(v136))++
	*(*uint8)(unsafe.Pointer(v135)) = libc.Uint8FromInt32(int32(INST_PUSH_RESULT))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_PUSH_RESULT)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v137 = delta1
		v138 = envPtr2
		if v137 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v138)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v138)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v138)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v138)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v138 + 64)) += int64(v137)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v140 = envPtr2 + 152
	v139 = *(*uintptr)(unsafe.Pointer(v140))
	*(*uintptr)(unsafe.Pointer(v140))++
	*(*uint8)(unsafe.Pointer(v139)) = libc.Uint8FromInt32(int32(INST_PUSH_RETURN_OPTIONS))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_PUSH_RETURN_OPTIONS)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v141 = delta1
		v142 = envPtr2
		if v141 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v142)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v142)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v142)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v142)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v142 + 64)) += int64(v141)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v144 = envPtr2 + 152
	v143 = *(*uintptr)(unsafe.Pointer(v144))
	*(*uintptr)(unsafe.Pointer(v144))++
	*(*uint8)(unsafe.Pointer(v143)) = libc.Uint8FromInt32(int32(INST_END_CATCH))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_END_CATCH)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v145 = delta1
		v146 = envPtr2
		if v145 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v146)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v146)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v146)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v146)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v146 + 64)) += int64(v145)
	}
	if optionsVar < int32(256) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v148 = envPtr2 + 152
		v147 = *(*uintptr)(unsafe.Pointer(v148))
		*(*uintptr)(unsafe.Pointer(v148))++
		*(*uint8)(unsafe.Pointer(v147)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
		v150 = envPtr2 + 152
		v149 = *(*uintptr)(unsafe.Pointer(v150))
		*(*uintptr)(unsafe.Pointer(v150))++
		*(*uint8)(unsafe.Pointer(v149)) = uint8(libc.Uint32FromInt32(optionsVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - optionsVar
			}
			v151 = delta1
			v152 = envPtr2
			if v151 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v152)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v152)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v152)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v152)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v152 + 64)) += int64(v151)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v154 = envPtr2 + 152
		v153 = *(*uintptr)(unsafe.Pointer(v154))
		*(*uintptr)(unsafe.Pointer(v154))++
		*(*uint8)(unsafe.Pointer(v153)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
		v156 = envPtr2 + 152
		v155 = *(*uintptr)(unsafe.Pointer(v156))
		*(*uintptr)(unsafe.Pointer(v156))++
		*(*uint8)(unsafe.Pointer(v155)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(24))
		v158 = envPtr2 + 152
		v157 = *(*uintptr)(unsafe.Pointer(v158))
		*(*uintptr)(unsafe.Pointer(v158))++
		*(*uint8)(unsafe.Pointer(v157)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(16))
		v160 = envPtr2 + 152
		v159 = *(*uintptr)(unsafe.Pointer(v160))
		*(*uintptr)(unsafe.Pointer(v160))++
		*(*uint8)(unsafe.Pointer(v159)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(8))
		v162 = envPtr2 + 152
		v161 = *(*uintptr)(unsafe.Pointer(v162))
		*(*uintptr)(unsafe.Pointer(v162))++
		*(*uint8)(unsafe.Pointer(v161)) = uint8(libc.Uint32FromInt32(optionsVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - optionsVar
			}
			v163 = delta1
			v164 = envPtr2
			if v163 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v164)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v164)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v164)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v164)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v164 + 64)) += int64(v163)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v166 = envPtr2 + 152
	v165 = *(*uintptr)(unsafe.Pointer(v166))
	*(*uintptr)(unsafe.Pointer(v166))++
	*(*uint8)(unsafe.Pointer(v165)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v167 = delta1
		v168 = envPtr2
		if v167 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v168)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v168)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v168)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v168)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v168 + 64)) += int64(v167)
	}
	if resultVar < int32(256) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v170 = envPtr2 + 152
		v169 = *(*uintptr)(unsafe.Pointer(v170))
		*(*uintptr)(unsafe.Pointer(v170))++
		*(*uint8)(unsafe.Pointer(v169)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
		v172 = envPtr2 + 152
		v171 = *(*uintptr)(unsafe.Pointer(v172))
		*(*uintptr)(unsafe.Pointer(v172))++
		*(*uint8)(unsafe.Pointer(v171)) = uint8(libc.Uint32FromInt32(resultVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - resultVar
			}
			v173 = delta1
			v174 = envPtr2
			if v173 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v174)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v174)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v174)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v174)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v174 + 64)) += int64(v173)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v176 = envPtr2 + 152
		v175 = *(*uintptr)(unsafe.Pointer(v176))
		*(*uintptr)(unsafe.Pointer(v176))++
		*(*uint8)(unsafe.Pointer(v175)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
		v178 = envPtr2 + 152
		v177 = *(*uintptr)(unsafe.Pointer(v178))
		*(*uintptr)(unsafe.Pointer(v178))++
		*(*uint8)(unsafe.Pointer(v177)) = uint8(libc.Uint32FromInt32(resultVar) >> libc.Int32FromInt32(24))
		v180 = envPtr2 + 152
		v179 = *(*uintptr)(unsafe.Pointer(v180))
		*(*uintptr)(unsafe.Pointer(v180))++
		*(*uint8)(unsafe.Pointer(v179)) = uint8(libc.Uint32FromInt32(resultVar) >> libc.Int32FromInt32(16))
		v182 = envPtr2 + 152
		v181 = *(*uintptr)(unsafe.Pointer(v182))
		*(*uintptr)(unsafe.Pointer(v182))++
		*(*uint8)(unsafe.Pointer(v181)) = uint8(libc.Uint32FromInt32(resultVar) >> libc.Int32FromInt32(8))
		v184 = envPtr2 + 152
		v183 = *(*uintptr)(unsafe.Pointer(v184))
		*(*uintptr)(unsafe.Pointer(v184))++
		*(*uint8)(unsafe.Pointer(v183)) = uint8(libc.Uint32FromInt32(resultVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - resultVar
			}
			v185 = delta1
			v186 = envPtr2
			if v185 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v186)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v186)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v186)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v186)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v186 + 64)) += int64(v185)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v188 = envPtr2 + 152
	v187 = *(*uintptr)(unsafe.Pointer(v188))
	*(*uintptr)(unsafe.Pointer(v188))++
	*(*uint8)(unsafe.Pointer(v187)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v189 = delta1
		v190 = envPtr2
		if v189 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v190)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v190)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v190)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v190)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v190 + 64)) += int64(v189)
	}
	/*
	 * Now we handle all the registered 'on' and 'trap' handlers in order.
	 *
	 * Slight overallocation, but reduces size of this function.
	 */
	addrsToFix = XTclStackAlloc(tls, interp, uint64(4)*libc.Uint64FromInt32(numHandlers))
	forwardsToFix = XTclStackAlloc(tls, interp, uint64(4)*libc.Uint64FromInt32(numHandlers))
	i1 = 0
	for {
		if !(i1 < numHandlers) {
			break
		}
		libc.X__builtin_snprintf(tls, bp, uint64(24), __ccgo_ts+260, libc.VaList(bp+48, *(*int32)(unsafe.Pointer(matchCodes + uintptr(i1)*4))))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v193 = envPtr2 + 152
		v192 = *(*uintptr)(unsafe.Pointer(v193))
		*(*uintptr)(unsafe.Pointer(v193))++
		*(*uint8)(unsafe.Pointer(v192)) = libc.Uint8FromInt32(int32(INST_DUP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_DUP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v194 = delta1
			v195 = envPtr2
			if v194 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v195)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v195)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v195)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v195)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v195 + 64)) += int64(v194)
		}
		_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, bp, libc.Int64FromUint64(libc.Xstrlen(tls, bp)), 0)
		if _objIndexCopy2 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v197 = envPtr2 + 152
			v196 = *(*uintptr)(unsafe.Pointer(v197))
			*(*uintptr)(unsafe.Pointer(v197))++
			*(*uint8)(unsafe.Pointer(v196)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v199 = envPtr2 + 152
			v198 = *(*uintptr)(unsafe.Pointer(v199))
			*(*uintptr)(unsafe.Pointer(v199))++
			*(*uint8)(unsafe.Pointer(v198)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v200 = delta1
				v201 = envPtr2
				if v200 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v201)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v201)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v201)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v201)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v201 + 64)) += int64(v200)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v203 = envPtr2 + 152
			v202 = *(*uintptr)(unsafe.Pointer(v203))
			*(*uintptr)(unsafe.Pointer(v203))++
			*(*uint8)(unsafe.Pointer(v202)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v205 = envPtr2 + 152
			v204 = *(*uintptr)(unsafe.Pointer(v205))
			*(*uintptr)(unsafe.Pointer(v205))++
			*(*uint8)(unsafe.Pointer(v204)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
			v207 = envPtr2 + 152
			v206 = *(*uintptr)(unsafe.Pointer(v207))
			*(*uintptr)(unsafe.Pointer(v207))++
			*(*uint8)(unsafe.Pointer(v206)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
			v209 = envPtr2 + 152
			v208 = *(*uintptr)(unsafe.Pointer(v209))
			*(*uintptr)(unsafe.Pointer(v209))++
			*(*uint8)(unsafe.Pointer(v208)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
			v211 = envPtr2 + 152
			v210 = *(*uintptr)(unsafe.Pointer(v211))
			*(*uintptr)(unsafe.Pointer(v211))++
			*(*uint8)(unsafe.Pointer(v210)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v212 = delta1
				v213 = envPtr2
				if v212 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v213)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v213)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v213)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v213)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v213 + 64)) += int64(v212)
			}
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v215 = envPtr2 + 152
		v214 = *(*uintptr)(unsafe.Pointer(v215))
		*(*uintptr)(unsafe.Pointer(v215))++
		*(*uint8)(unsafe.Pointer(v214)) = libc.Uint8FromInt32(int32(INST_EQ))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_EQ)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v216 = delta1
			v217 = envPtr2
			if v216 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v217)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v217)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v217)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v217)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v217 + 64)) += int64(v216)
		}
		notCodeJumpSource = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v219 = envPtr2 + 152
		v218 = *(*uintptr)(unsafe.Pointer(v219))
		*(*uintptr)(unsafe.Pointer(v219))++
		*(*uint8)(unsafe.Pointer(v218)) = libc.Uint8FromInt32(int32(INST_JUMP_FALSE4))
		v221 = envPtr2 + 152
		v220 = *(*uintptr)(unsafe.Pointer(v221))
		*(*uintptr)(unsafe.Pointer(v221))++
		*(*uint8)(unsafe.Pointer(v220)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
		v223 = envPtr2 + 152
		v222 = *(*uintptr)(unsafe.Pointer(v223))
		*(*uintptr)(unsafe.Pointer(v223))++
		*(*uint8)(unsafe.Pointer(v222)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
		v225 = envPtr2 + 152
		v224 = *(*uintptr)(unsafe.Pointer(v225))
		*(*uintptr)(unsafe.Pointer(v225))++
		*(*uint8)(unsafe.Pointer(v224)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
		v227 = envPtr2 + 152
		v226 = *(*uintptr)(unsafe.Pointer(v227))
		*(*uintptr)(unsafe.Pointer(v227))++
		*(*uint8)(unsafe.Pointer(v226)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP_FALSE4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v228 = delta1
			v229 = envPtr2
			if v228 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v229)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v229)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v229)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v229)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v229 + 64)) += int64(v228)
		}
		if *(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i1)*8)) != 0 {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i1)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i1)*8)) + 32))).Fptr2 != 0 {
					v231 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i1)*8)) + 32))).Fptr2)).FspanLength
				} else {
					v231 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i1)*8)) + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = v231
				_ = libc.Int32FromInt32(TCL_OK)
			} else {
				XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i1)*8)), bp+32)
			}
			/*
			 * Match the errorcode according to try/trap rules.
			 */
			if optionsVar < int32(256) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v233 = envPtr2 + 152
				v232 = *(*uintptr)(unsafe.Pointer(v233))
				*(*uintptr)(unsafe.Pointer(v233))++
				*(*uint8)(unsafe.Pointer(v232)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
				v235 = envPtr2 + 152
				v234 = *(*uintptr)(unsafe.Pointer(v235))
				*(*uintptr)(unsafe.Pointer(v235))++
				*(*uint8)(unsafe.Pointer(v234)) = uint8(libc.Uint32FromInt32(optionsVar))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - optionsVar
					}
					v236 = delta1
					v237 = envPtr2
					if v236 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v237)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v237)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v237)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v237)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v237 + 64)) += int64(v236)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v239 = envPtr2 + 152
				v238 = *(*uintptr)(unsafe.Pointer(v239))
				*(*uintptr)(unsafe.Pointer(v239))++
				*(*uint8)(unsafe.Pointer(v238)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
				v241 = envPtr2 + 152
				v240 = *(*uintptr)(unsafe.Pointer(v241))
				*(*uintptr)(unsafe.Pointer(v241))++
				*(*uint8)(unsafe.Pointer(v240)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(24))
				v243 = envPtr2 + 152
				v242 = *(*uintptr)(unsafe.Pointer(v243))
				*(*uintptr)(unsafe.Pointer(v243))++
				*(*uint8)(unsafe.Pointer(v242)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(16))
				v245 = envPtr2 + 152
				v244 = *(*uintptr)(unsafe.Pointer(v245))
				*(*uintptr)(unsafe.Pointer(v245))++
				*(*uint8)(unsafe.Pointer(v244)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(8))
				v247 = envPtr2 + 152
				v246 = *(*uintptr)(unsafe.Pointer(v247))
				*(*uintptr)(unsafe.Pointer(v247))++
				*(*uint8)(unsafe.Pointer(v246)) = uint8(libc.Uint32FromInt32(optionsVar))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - optionsVar
					}
					v248 = delta1
					v249 = envPtr2
					if v248 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v249)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v249)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v249)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v249)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v249 + 64)) += int64(v248)
				}
			}
			_objIndexCopy3 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+15231, libc.Int64FromUint64(libc.Uint64FromInt64(11)-libc.Uint64FromInt32(1)), 0)
			if _objIndexCopy3 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v251 = envPtr2 + 152
				v250 = *(*uintptr)(unsafe.Pointer(v251))
				*(*uintptr)(unsafe.Pointer(v251))++
				*(*uint8)(unsafe.Pointer(v250)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v253 = envPtr2 + 152
				v252 = *(*uintptr)(unsafe.Pointer(v253))
				*(*uintptr)(unsafe.Pointer(v253))++
				*(*uint8)(unsafe.Pointer(v252)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy3
					}
					v254 = delta1
					v255 = envPtr2
					if v254 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v255)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v255)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v255)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v255)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v255 + 64)) += int64(v254)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v257 = envPtr2 + 152
				v256 = *(*uintptr)(unsafe.Pointer(v257))
				*(*uintptr)(unsafe.Pointer(v257))++
				*(*uint8)(unsafe.Pointer(v256)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v259 = envPtr2 + 152
				v258 = *(*uintptr)(unsafe.Pointer(v259))
				*(*uintptr)(unsafe.Pointer(v259))++
				*(*uint8)(unsafe.Pointer(v258)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(24))
				v261 = envPtr2 + 152
				v260 = *(*uintptr)(unsafe.Pointer(v261))
				*(*uintptr)(unsafe.Pointer(v261))++
				*(*uint8)(unsafe.Pointer(v260)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(16))
				v263 = envPtr2 + 152
				v262 = *(*uintptr)(unsafe.Pointer(v263))
				*(*uintptr)(unsafe.Pointer(v263))++
				*(*uint8)(unsafe.Pointer(v262)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(8))
				v265 = envPtr2 + 152
				v264 = *(*uintptr)(unsafe.Pointer(v265))
				*(*uintptr)(unsafe.Pointer(v265))++
				*(*uint8)(unsafe.Pointer(v264)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy3
					}
					v266 = delta1
					v267 = envPtr2
					if v266 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v267)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v267)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v267)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v267)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v267 + 64)) += int64(v266)
				}
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v269 = envPtr2 + 152
			v268 = *(*uintptr)(unsafe.Pointer(v269))
			*(*uintptr)(unsafe.Pointer(v269))++
			*(*uint8)(unsafe.Pointer(v268)) = libc.Uint8FromInt32(int32(INST_DICT_GET))
			v271 = envPtr2 + 152
			v270 = *(*uintptr)(unsafe.Pointer(v271))
			*(*uintptr)(unsafe.Pointer(v271))++
			*(*uint8)(unsafe.Pointer(v270)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(24))
			v273 = envPtr2 + 152
			v272 = *(*uintptr)(unsafe.Pointer(v273))
			*(*uintptr)(unsafe.Pointer(v273))++
			*(*uint8)(unsafe.Pointer(v272)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(16))
			v275 = envPtr2 + 152
			v274 = *(*uintptr)(unsafe.Pointer(v275))
			*(*uintptr)(unsafe.Pointer(v275))++
			*(*uint8)(unsafe.Pointer(v274)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(8))
			v277 = envPtr2 + 152
			v276 = *(*uintptr)(unsafe.Pointer(v277))
			*(*uintptr)(unsafe.Pointer(v277))++
			*(*uint8)(unsafe.Pointer(v276)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_DICT_GET)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - int32(1)
				}
				v278 = delta1
				v279 = envPtr2
				if v278 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v279)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v279)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v279)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v279)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v279 + 64)) += int64(v278)
			}
			v280 = -int32(1)
			v281 = envPtr2
			if v280 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v281)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v281)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v281)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v281)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v281 + 64)) += int64(v280)
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v283 = envPtr2 + 152
			v282 = *(*uintptr)(unsafe.Pointer(v283))
			*(*uintptr)(unsafe.Pointer(v283))++
			*(*uint8)(unsafe.Pointer(v282)) = libc.Uint8FromInt32(int32(INST_LIST_RANGE_IMM))
			v285 = envPtr2 + 152
			v284 = *(*uintptr)(unsafe.Pointer(v285))
			*(*uintptr)(unsafe.Pointer(v285))++
			*(*uint8)(unsafe.Pointer(v284)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
			v287 = envPtr2 + 152
			v286 = *(*uintptr)(unsafe.Pointer(v287))
			*(*uintptr)(unsafe.Pointer(v287))++
			*(*uint8)(unsafe.Pointer(v286)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
			v289 = envPtr2 + 152
			v288 = *(*uintptr)(unsafe.Pointer(v289))
			*(*uintptr)(unsafe.Pointer(v289))++
			*(*uint8)(unsafe.Pointer(v288)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
			v291 = envPtr2 + 152
			v290 = *(*uintptr)(unsafe.Pointer(v291))
			*(*uintptr)(unsafe.Pointer(v291))++
			*(*uint8)(unsafe.Pointer(v290)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LIST_RANGE_IMM)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v292 = delta1
				v293 = envPtr2
				if v292 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v293)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v293)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v293)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v293)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v293 + 64)) += int64(v292)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v295 = envPtr2 + 152
			v294 = *(*uintptr)(unsafe.Pointer(v295))
			*(*uintptr)(unsafe.Pointer(v295))++
			*(*uint8)(unsafe.Pointer(v294)) = uint8(libc.Uint32FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 32))-libc.Int64FromInt32(1)) >> libc.Int32FromInt32(24))
			v297 = envPtr2 + 152
			v296 = *(*uintptr)(unsafe.Pointer(v297))
			*(*uintptr)(unsafe.Pointer(v297))++
			*(*uint8)(unsafe.Pointer(v296)) = uint8(libc.Uint32FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 32))-libc.Int64FromInt32(1)) >> libc.Int32FromInt32(16))
			v299 = envPtr2 + 152
			v298 = *(*uintptr)(unsafe.Pointer(v299))
			*(*uintptr)(unsafe.Pointer(v299))++
			*(*uint8)(unsafe.Pointer(v298)) = uint8(libc.Uint32FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 32))-libc.Int64FromInt32(1)) >> libc.Int32FromInt32(8))
			v301 = envPtr2 + 152
			v300 = *(*uintptr)(unsafe.Pointer(v301))
			*(*uintptr)(unsafe.Pointer(v301))++
			*(*uint8)(unsafe.Pointer(v300)) = uint8(libc.Uint32FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 32)) - libc.Int64FromInt32(1)))
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i1)*8)))).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i1)*8)))).Flength
				v302 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i1)*8)))).Fbytes
			} else {
				v302 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i1)*8)), bp+24)
			}
			p = v302
			_objIndexCopy4 = XTclRegisterLiteral(tls, envPtr2, p, *(*TTcl_Size)(unsafe.Pointer(bp + 24)), 0)
			if _objIndexCopy4 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v304 = envPtr2 + 152
				v303 = *(*uintptr)(unsafe.Pointer(v304))
				*(*uintptr)(unsafe.Pointer(v304))++
				*(*uint8)(unsafe.Pointer(v303)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v306 = envPtr2 + 152
				v305 = *(*uintptr)(unsafe.Pointer(v306))
				*(*uintptr)(unsafe.Pointer(v306))++
				*(*uint8)(unsafe.Pointer(v305)) = uint8(libc.Uint32FromInt32(_objIndexCopy4))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy4
					}
					v307 = delta1
					v308 = envPtr2
					if v307 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v308)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v308)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v308)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v308)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v308 + 64)) += int64(v307)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v310 = envPtr2 + 152
				v309 = *(*uintptr)(unsafe.Pointer(v310))
				*(*uintptr)(unsafe.Pointer(v310))++
				*(*uint8)(unsafe.Pointer(v309)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v312 = envPtr2 + 152
				v311 = *(*uintptr)(unsafe.Pointer(v312))
				*(*uintptr)(unsafe.Pointer(v312))++
				*(*uint8)(unsafe.Pointer(v311)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(24))
				v314 = envPtr2 + 152
				v313 = *(*uintptr)(unsafe.Pointer(v314))
				*(*uintptr)(unsafe.Pointer(v314))++
				*(*uint8)(unsafe.Pointer(v313)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(16))
				v316 = envPtr2 + 152
				v315 = *(*uintptr)(unsafe.Pointer(v316))
				*(*uintptr)(unsafe.Pointer(v316))++
				*(*uint8)(unsafe.Pointer(v315)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(8))
				v318 = envPtr2 + 152
				v317 = *(*uintptr)(unsafe.Pointer(v318))
				*(*uintptr)(unsafe.Pointer(v318))++
				*(*uint8)(unsafe.Pointer(v317)) = uint8(libc.Uint32FromInt32(_objIndexCopy4))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy4
					}
					v319 = delta1
					v320 = envPtr2
					if v319 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v320)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v320)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v320)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v320)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v320 + 64)) += int64(v319)
				}
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v322 = envPtr2 + 152
			v321 = *(*uintptr)(unsafe.Pointer(v322))
			*(*uintptr)(unsafe.Pointer(v322))++
			*(*uint8)(unsafe.Pointer(v321)) = libc.Uint8FromInt32(int32(INST_STR_EQ))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STR_EQ)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v323 = delta1
				v324 = envPtr2
				if v323 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v324)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v324)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v324)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v324)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v324 + 64)) += int64(v323)
			}
			notECJumpSource = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v326 = envPtr2 + 152
			v325 = *(*uintptr)(unsafe.Pointer(v326))
			*(*uintptr)(unsafe.Pointer(v326))++
			*(*uint8)(unsafe.Pointer(v325)) = libc.Uint8FromInt32(int32(INST_JUMP_FALSE4))
			v328 = envPtr2 + 152
			v327 = *(*uintptr)(unsafe.Pointer(v328))
			*(*uintptr)(unsafe.Pointer(v328))++
			*(*uint8)(unsafe.Pointer(v327)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
			v330 = envPtr2 + 152
			v329 = *(*uintptr)(unsafe.Pointer(v330))
			*(*uintptr)(unsafe.Pointer(v330))++
			*(*uint8)(unsafe.Pointer(v329)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
			v332 = envPtr2 + 152
			v331 = *(*uintptr)(unsafe.Pointer(v332))
			*(*uintptr)(unsafe.Pointer(v332))++
			*(*uint8)(unsafe.Pointer(v331)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
			v334 = envPtr2 + 152
			v333 = *(*uintptr)(unsafe.Pointer(v334))
			*(*uintptr)(unsafe.Pointer(v334))++
			*(*uint8)(unsafe.Pointer(v333)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_JUMP_FALSE4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v335 = delta1
				v336 = envPtr2
				if v335 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v336)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v336)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v336)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v336)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v336 + 64)) += int64(v335)
			}
		} else {
			notECJumpSource = -int32(1)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v338 = envPtr2 + 152
		v337 = *(*uintptr)(unsafe.Pointer(v338))
		*(*uintptr)(unsafe.Pointer(v338))++
		*(*uint8)(unsafe.Pointer(v337)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v339 = delta1
			v340 = envPtr2
			if v339 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v340)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v340)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v340)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v340)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v340 + 64)) += int64(v339)
		}
		/*
		 * There is a finally clause, so we need a fairly complex sequence of
		 * instructions to deal with an on/trap handler because we must call
		 * the finally handler *and* we need to substitute the result from a
		 * failed trap for the result from the main script.
		 */
		if *(*int32)(unsafe.Pointer(resultVars + uintptr(i1)*4)) >= 0 || *(*uintptr)(unsafe.Pointer(handlerTokens + uintptr(i1)*8)) != 0 {
			range1 = int32(XTclCreateExceptRange(tls, int32(CATCH_EXCEPTION_RANGE), envPtr2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v342 = envPtr2 + 152
			v341 = *(*uintptr)(unsafe.Pointer(v342))
			*(*uintptr)(unsafe.Pointer(v342))++
			*(*uint8)(unsafe.Pointer(v341)) = libc.Uint8FromInt32(int32(INST_BEGIN_CATCH4))
			v344 = envPtr2 + 152
			v343 = *(*uintptr)(unsafe.Pointer(v344))
			*(*uintptr)(unsafe.Pointer(v344))++
			*(*uint8)(unsafe.Pointer(v343)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(24))
			v346 = envPtr2 + 152
			v345 = *(*uintptr)(unsafe.Pointer(v346))
			*(*uintptr)(unsafe.Pointer(v346))++
			*(*uint8)(unsafe.Pointer(v345)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(16))
			v348 = envPtr2 + 152
			v347 = *(*uintptr)(unsafe.Pointer(v348))
			*(*uintptr)(unsafe.Pointer(v348))++
			*(*uint8)(unsafe.Pointer(v347)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(8))
			v350 = envPtr2 + 152
			v349 = *(*uintptr)(unsafe.Pointer(v350))
			*(*uintptr)(unsafe.Pointer(v350))++
			*(*uint8)(unsafe.Pointer(v349)) = uint8(libc.Uint32FromInt32(range1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_BEGIN_CATCH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - range1
				}
				v351 = delta1
				v352 = envPtr2
				if v351 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v352)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v352)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v352)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v352)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v352 + 64)) += int64(v351)
			}
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth++
			if libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth)+uint64(1) > libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth)+uint64(1) {
				v353 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth
			} else {
				v353 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth
			}
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth = v353
			(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
		}
		if *(*int32)(unsafe.Pointer(resultVars + uintptr(i1)*4)) >= 0 {
			if resultVar < int32(256) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v355 = envPtr2 + 152
				v354 = *(*uintptr)(unsafe.Pointer(v355))
				*(*uintptr)(unsafe.Pointer(v355))++
				*(*uint8)(unsafe.Pointer(v354)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
				v357 = envPtr2 + 152
				v356 = *(*uintptr)(unsafe.Pointer(v357))
				*(*uintptr)(unsafe.Pointer(v357))++
				*(*uint8)(unsafe.Pointer(v356)) = uint8(libc.Uint32FromInt32(resultVar))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - resultVar
					}
					v358 = delta1
					v359 = envPtr2
					if v358 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v359)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v359)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v359)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v359)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v359 + 64)) += int64(v358)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v361 = envPtr2 + 152
				v360 = *(*uintptr)(unsafe.Pointer(v361))
				*(*uintptr)(unsafe.Pointer(v361))++
				*(*uint8)(unsafe.Pointer(v360)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
				v363 = envPtr2 + 152
				v362 = *(*uintptr)(unsafe.Pointer(v363))
				*(*uintptr)(unsafe.Pointer(v363))++
				*(*uint8)(unsafe.Pointer(v362)) = uint8(libc.Uint32FromInt32(resultVar) >> libc.Int32FromInt32(24))
				v365 = envPtr2 + 152
				v364 = *(*uintptr)(unsafe.Pointer(v365))
				*(*uintptr)(unsafe.Pointer(v365))++
				*(*uint8)(unsafe.Pointer(v364)) = uint8(libc.Uint32FromInt32(resultVar) >> libc.Int32FromInt32(16))
				v367 = envPtr2 + 152
				v366 = *(*uintptr)(unsafe.Pointer(v367))
				*(*uintptr)(unsafe.Pointer(v367))++
				*(*uint8)(unsafe.Pointer(v366)) = uint8(libc.Uint32FromInt32(resultVar) >> libc.Int32FromInt32(8))
				v369 = envPtr2 + 152
				v368 = *(*uintptr)(unsafe.Pointer(v369))
				*(*uintptr)(unsafe.Pointer(v369))++
				*(*uint8)(unsafe.Pointer(v368)) = uint8(libc.Uint32FromInt32(resultVar))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - resultVar
					}
					v370 = delta1
					v371 = envPtr2
					if v370 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v371)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v371)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v371)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v371)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v371 + 64)) += int64(v370)
				}
			}
			if *(*int32)(unsafe.Pointer(resultVars + uintptr(i1)*4)) < int32(256) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v373 = envPtr2 + 152
				v372 = *(*uintptr)(unsafe.Pointer(v373))
				*(*uintptr)(unsafe.Pointer(v373))++
				*(*uint8)(unsafe.Pointer(v372)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
				v375 = envPtr2 + 152
				v374 = *(*uintptr)(unsafe.Pointer(v375))
				*(*uintptr)(unsafe.Pointer(v375))++
				*(*uint8)(unsafe.Pointer(v374)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(resultVars + uintptr(i1)*4))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - *(*int32)(unsafe.Pointer(resultVars + uintptr(i1)*4))
					}
					v376 = delta1
					v377 = envPtr2
					if v376 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v377)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v377)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v377)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v377)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v377 + 64)) += int64(v376)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v379 = envPtr2 + 152
				v378 = *(*uintptr)(unsafe.Pointer(v379))
				*(*uintptr)(unsafe.Pointer(v379))++
				*(*uint8)(unsafe.Pointer(v378)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
				v381 = envPtr2 + 152
				v380 = *(*uintptr)(unsafe.Pointer(v381))
				*(*uintptr)(unsafe.Pointer(v381))++
				*(*uint8)(unsafe.Pointer(v380)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(resultVars + uintptr(i1)*4))) >> libc.Int32FromInt32(24))
				v383 = envPtr2 + 152
				v382 = *(*uintptr)(unsafe.Pointer(v383))
				*(*uintptr)(unsafe.Pointer(v383))++
				*(*uint8)(unsafe.Pointer(v382)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(resultVars + uintptr(i1)*4))) >> libc.Int32FromInt32(16))
				v385 = envPtr2 + 152
				v384 = *(*uintptr)(unsafe.Pointer(v385))
				*(*uintptr)(unsafe.Pointer(v385))++
				*(*uint8)(unsafe.Pointer(v384)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(resultVars + uintptr(i1)*4))) >> libc.Int32FromInt32(8))
				v387 = envPtr2 + 152
				v386 = *(*uintptr)(unsafe.Pointer(v387))
				*(*uintptr)(unsafe.Pointer(v387))++
				*(*uint8)(unsafe.Pointer(v386)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(resultVars + uintptr(i1)*4))))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - *(*int32)(unsafe.Pointer(resultVars + uintptr(i1)*4))
					}
					v388 = delta1
					v389 = envPtr2
					if v388 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v389)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v389)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v389)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v389)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v389 + 64)) += int64(v388)
				}
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v391 = envPtr2 + 152
			v390 = *(*uintptr)(unsafe.Pointer(v391))
			*(*uintptr)(unsafe.Pointer(v391))++
			*(*uint8)(unsafe.Pointer(v390)) = libc.Uint8FromInt32(int32(INST_POP))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v392 = delta1
				v393 = envPtr2
				if v392 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v393)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v393)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v393)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v393)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v393 + 64)) += int64(v392)
			}
			if *(*int32)(unsafe.Pointer(optionVars + uintptr(i1)*4)) >= 0 {
				if optionsVar < int32(256) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v395 = envPtr2 + 152
					v394 = *(*uintptr)(unsafe.Pointer(v395))
					*(*uintptr)(unsafe.Pointer(v395))++
					*(*uint8)(unsafe.Pointer(v394)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
					v397 = envPtr2 + 152
					v396 = *(*uintptr)(unsafe.Pointer(v397))
					*(*uintptr)(unsafe.Pointer(v397))++
					*(*uint8)(unsafe.Pointer(v396)) = uint8(libc.Uint32FromInt32(optionsVar))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - optionsVar
						}
						v398 = delta1
						v399 = envPtr2
						if v398 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v399)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v399)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v399)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v399)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v399 + 64)) += int64(v398)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v401 = envPtr2 + 152
					v400 = *(*uintptr)(unsafe.Pointer(v401))
					*(*uintptr)(unsafe.Pointer(v401))++
					*(*uint8)(unsafe.Pointer(v400)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
					v403 = envPtr2 + 152
					v402 = *(*uintptr)(unsafe.Pointer(v403))
					*(*uintptr)(unsafe.Pointer(v403))++
					*(*uint8)(unsafe.Pointer(v402)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(24))
					v405 = envPtr2 + 152
					v404 = *(*uintptr)(unsafe.Pointer(v405))
					*(*uintptr)(unsafe.Pointer(v405))++
					*(*uint8)(unsafe.Pointer(v404)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(16))
					v407 = envPtr2 + 152
					v406 = *(*uintptr)(unsafe.Pointer(v407))
					*(*uintptr)(unsafe.Pointer(v407))++
					*(*uint8)(unsafe.Pointer(v406)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(8))
					v409 = envPtr2 + 152
					v408 = *(*uintptr)(unsafe.Pointer(v409))
					*(*uintptr)(unsafe.Pointer(v409))++
					*(*uint8)(unsafe.Pointer(v408)) = uint8(libc.Uint32FromInt32(optionsVar))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - optionsVar
						}
						v410 = delta1
						v411 = envPtr2
						if v410 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v411)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v411)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v411)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v411)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v411 + 64)) += int64(v410)
					}
				}
				if *(*int32)(unsafe.Pointer(optionVars + uintptr(i1)*4)) < int32(256) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v413 = envPtr2 + 152
					v412 = *(*uintptr)(unsafe.Pointer(v413))
					*(*uintptr)(unsafe.Pointer(v413))++
					*(*uint8)(unsafe.Pointer(v412)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
					v415 = envPtr2 + 152
					v414 = *(*uintptr)(unsafe.Pointer(v415))
					*(*uintptr)(unsafe.Pointer(v415))++
					*(*uint8)(unsafe.Pointer(v414)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(optionVars + uintptr(i1)*4))))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - *(*int32)(unsafe.Pointer(optionVars + uintptr(i1)*4))
						}
						v416 = delta1
						v417 = envPtr2
						if v416 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v417)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v417)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v417)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v417)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v417 + 64)) += int64(v416)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v419 = envPtr2 + 152
					v418 = *(*uintptr)(unsafe.Pointer(v419))
					*(*uintptr)(unsafe.Pointer(v419))++
					*(*uint8)(unsafe.Pointer(v418)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
					v421 = envPtr2 + 152
					v420 = *(*uintptr)(unsafe.Pointer(v421))
					*(*uintptr)(unsafe.Pointer(v421))++
					*(*uint8)(unsafe.Pointer(v420)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(optionVars + uintptr(i1)*4))) >> libc.Int32FromInt32(24))
					v423 = envPtr2 + 152
					v422 = *(*uintptr)(unsafe.Pointer(v423))
					*(*uintptr)(unsafe.Pointer(v423))++
					*(*uint8)(unsafe.Pointer(v422)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(optionVars + uintptr(i1)*4))) >> libc.Int32FromInt32(16))
					v425 = envPtr2 + 152
					v424 = *(*uintptr)(unsafe.Pointer(v425))
					*(*uintptr)(unsafe.Pointer(v425))++
					*(*uint8)(unsafe.Pointer(v424)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(optionVars + uintptr(i1)*4))) >> libc.Int32FromInt32(8))
					v427 = envPtr2 + 152
					v426 = *(*uintptr)(unsafe.Pointer(v427))
					*(*uintptr)(unsafe.Pointer(v427))++
					*(*uint8)(unsafe.Pointer(v426)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(optionVars + uintptr(i1)*4))))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - *(*int32)(unsafe.Pointer(optionVars + uintptr(i1)*4))
						}
						v428 = delta1
						v429 = envPtr2
						if v428 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v429)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v429)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v429)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v429)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v429 + 64)) += int64(v428)
					}
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v431 = envPtr2 + 152
				v430 = *(*uintptr)(unsafe.Pointer(v431))
				*(*uintptr)(unsafe.Pointer(v431))++
				*(*uint8)(unsafe.Pointer(v430)) = libc.Uint8FromInt32(int32(INST_POP))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v432 = delta1
					v433 = envPtr2
					if v432 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v433)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v433)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v433)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v433)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v433 + 64)) += int64(v432)
				}
			}
			if !(*(*uintptr)(unsafe.Pointer(handlerTokens + uintptr(i1)*8)) != 0) {
				/*
				 * No handler. Will not be the last handler (that is a
				 * condition that is checked by the caller). Chain to the next
				 * one.
				 */
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth--
				(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FnumCodeBytes = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(int32((*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v435 = envPtr2 + 152
				v434 = *(*uintptr)(unsafe.Pointer(v435))
				*(*uintptr)(unsafe.Pointer(v435))++
				*(*uint8)(unsafe.Pointer(v434)) = libc.Uint8FromInt32(int32(INST_END_CATCH))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_END_CATCH)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v436 = delta1
					v437 = envPtr2
					if v436 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v437)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v437)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v437)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v437)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v437 + 64)) += int64(v436)
				}
				forwardsNeedFixing = int32(1)
				*(*int32)(unsafe.Pointer(forwardsToFix + uintptr(i1)*4)) = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v439 = envPtr2 + 152
				v438 = *(*uintptr)(unsafe.Pointer(v439))
				*(*uintptr)(unsafe.Pointer(v439))++
				*(*uint8)(unsafe.Pointer(v438)) = libc.Uint8FromInt32(int32(INST_JUMP4))
				v441 = envPtr2 + 152
				v440 = *(*uintptr)(unsafe.Pointer(v441))
				*(*uintptr)(unsafe.Pointer(v441))++
				*(*uint8)(unsafe.Pointer(v440)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
				v443 = envPtr2 + 152
				v442 = *(*uintptr)(unsafe.Pointer(v443))
				*(*uintptr)(unsafe.Pointer(v443))++
				*(*uint8)(unsafe.Pointer(v442)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
				v445 = envPtr2 + 152
				v444 = *(*uintptr)(unsafe.Pointer(v445))
				*(*uintptr)(unsafe.Pointer(v445))++
				*(*uint8)(unsafe.Pointer(v444)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
				v447 = envPtr2 + 152
				v446 = *(*uintptr)(unsafe.Pointer(v447))
				*(*uintptr)(unsafe.Pointer(v447))++
				*(*uint8)(unsafe.Pointer(v446)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_JUMP4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v448 = delta1
					v449 = envPtr2
					if v448 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v449)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v449)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v449)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v449)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v449 + 64)) += int64(v448)
				}
				goto finishTrapCatchHandling
			}
		} else {
			if !(*(*uintptr)(unsafe.Pointer(handlerTokens + uintptr(i1)*8)) != 0) {
				/*
				 * No handler. Will not be the last handler (that condition is
				 * checked by the caller). Chain to the next one.
				 */
				forwardsNeedFixing = int32(1)
				*(*int32)(unsafe.Pointer(forwardsToFix + uintptr(i1)*4)) = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v451 = envPtr2 + 152
				v450 = *(*uintptr)(unsafe.Pointer(v451))
				*(*uintptr)(unsafe.Pointer(v451))++
				*(*uint8)(unsafe.Pointer(v450)) = libc.Uint8FromInt32(int32(INST_JUMP4))
				v453 = envPtr2 + 152
				v452 = *(*uintptr)(unsafe.Pointer(v453))
				*(*uintptr)(unsafe.Pointer(v453))++
				*(*uint8)(unsafe.Pointer(v452)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
				v455 = envPtr2 + 152
				v454 = *(*uintptr)(unsafe.Pointer(v455))
				*(*uintptr)(unsafe.Pointer(v455))++
				*(*uint8)(unsafe.Pointer(v454)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
				v457 = envPtr2 + 152
				v456 = *(*uintptr)(unsafe.Pointer(v457))
				*(*uintptr)(unsafe.Pointer(v457))++
				*(*uint8)(unsafe.Pointer(v456)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
				v459 = envPtr2 + 152
				v458 = *(*uintptr)(unsafe.Pointer(v459))
				*(*uintptr)(unsafe.Pointer(v459))++
				*(*uint8)(unsafe.Pointer(v458)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_JUMP4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v460 = delta1
					v461 = envPtr2
					if v460 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v461)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v461)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v461)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v461)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v461 + 64)) += int64(v460)
				}
				goto endOfThisArm
			}
		}
		/*
		 * Got a handler. Make sure that any pending patch-up actions from
		 * previous unprocessed handlers are dealt with now that we know where
		 * they are to jump to.
		 */
		if forwardsNeedFixing != 0 {
			forwardsNeedFixing = 0
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v463 = envPtr2 + 152
			v462 = *(*uintptr)(unsafe.Pointer(v463))
			*(*uintptr)(unsafe.Pointer(v463))++
			*(*uint8)(unsafe.Pointer(v462)) = libc.Uint8FromInt32(int32(INST_JUMP1))
			v465 = envPtr2 + 152
			v464 = *(*uintptr)(unsafe.Pointer(v465))
			*(*uintptr)(unsafe.Pointer(v465))++
			*(*uint8)(unsafe.Pointer(v464)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(7)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_JUMP1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - int32(7)
				}
				v466 = delta1
				v467 = envPtr2
				if v466 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v467)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v467)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v467)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v467)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v467 + 64)) += int64(v466)
			}
			j = 0
			for {
				if !(j < i1) {
					break
				}
				if *(*int32)(unsafe.Pointer(forwardsToFix + uintptr(j)*4)) == -int32(1) {
					goto _468
				}
				*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(*(*int32)(unsafe.Pointer(forwardsToFix + uintptr(j)*4))) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(*(*int32)(unsafe.Pointer(forwardsToFix + uintptr(j)*4)))) >> libc.Int32FromInt32(24))
				*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(*(*int32)(unsafe.Pointer(forwardsToFix + uintptr(j)*4))) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(*(*int32)(unsafe.Pointer(forwardsToFix + uintptr(j)*4)))) >> libc.Int32FromInt32(16))
				*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(*(*int32)(unsafe.Pointer(forwardsToFix + uintptr(j)*4))) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(*(*int32)(unsafe.Pointer(forwardsToFix + uintptr(j)*4)))) >> libc.Int32FromInt32(8))
				*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(*(*int32)(unsafe.Pointer(forwardsToFix + uintptr(j)*4))) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(*(*int32)(unsafe.Pointer(forwardsToFix + uintptr(j)*4)))))
				*(*int32)(unsafe.Pointer(forwardsToFix + uintptr(j)*4)) = -int32(1)
				goto _468
			_468:
				;
				j++
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v470 = envPtr2 + 152
			v469 = *(*uintptr)(unsafe.Pointer(v470))
			*(*uintptr)(unsafe.Pointer(v470))++
			*(*uint8)(unsafe.Pointer(v469)) = libc.Uint8FromInt32(int32(INST_BEGIN_CATCH4))
			v472 = envPtr2 + 152
			v471 = *(*uintptr)(unsafe.Pointer(v472))
			*(*uintptr)(unsafe.Pointer(v472))++
			*(*uint8)(unsafe.Pointer(v471)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(24))
			v474 = envPtr2 + 152
			v473 = *(*uintptr)(unsafe.Pointer(v474))
			*(*uintptr)(unsafe.Pointer(v474))++
			*(*uint8)(unsafe.Pointer(v473)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(16))
			v476 = envPtr2 + 152
			v475 = *(*uintptr)(unsafe.Pointer(v476))
			*(*uintptr)(unsafe.Pointer(v476))++
			*(*uint8)(unsafe.Pointer(v475)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(8))
			v478 = envPtr2 + 152
			v477 = *(*uintptr)(unsafe.Pointer(v478))
			*(*uintptr)(unsafe.Pointer(v478))++
			*(*uint8)(unsafe.Pointer(v477)) = uint8(libc.Uint32FromInt32(range1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_BEGIN_CATCH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - range1
				}
				v479 = delta1
				v480 = envPtr2
				if v479 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v480)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v480)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v480)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v480)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v480 + 64)) += int64(v479)
			}
		}
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(libc.Int32FromInt32(5)+i1*libc.Int32FromInt32(4))*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(libc.Int32FromInt32(5)+i1*libc.Int32FromInt32(4))*8))
		XTclCompileCmdWord(tls, interp, *(*uintptr)(unsafe.Pointer(handlerTokens + uintptr(i1)*8))+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(handlerTokens + uintptr(i1)*8)))).FnumComponents), envPtr2)
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth--
		(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FnumCodeBytes = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(int32((*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset))
		_objIndexCopy5 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+14828, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy5 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v482 = envPtr2 + 152
			v481 = *(*uintptr)(unsafe.Pointer(v482))
			*(*uintptr)(unsafe.Pointer(v482))++
			*(*uint8)(unsafe.Pointer(v481)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v484 = envPtr2 + 152
			v483 = *(*uintptr)(unsafe.Pointer(v484))
			*(*uintptr)(unsafe.Pointer(v484))++
			*(*uint8)(unsafe.Pointer(v483)) = uint8(libc.Uint32FromInt32(_objIndexCopy5))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy5
				}
				v485 = delta1
				v486 = envPtr2
				if v485 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v486)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v486)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v486)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v486)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v486 + 64)) += int64(v485)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v488 = envPtr2 + 152
			v487 = *(*uintptr)(unsafe.Pointer(v488))
			*(*uintptr)(unsafe.Pointer(v488))++
			*(*uint8)(unsafe.Pointer(v487)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v490 = envPtr2 + 152
			v489 = *(*uintptr)(unsafe.Pointer(v490))
			*(*uintptr)(unsafe.Pointer(v490))++
			*(*uint8)(unsafe.Pointer(v489)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(24))
			v492 = envPtr2 + 152
			v491 = *(*uintptr)(unsafe.Pointer(v492))
			*(*uintptr)(unsafe.Pointer(v492))++
			*(*uint8)(unsafe.Pointer(v491)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(16))
			v494 = envPtr2 + 152
			v493 = *(*uintptr)(unsafe.Pointer(v494))
			*(*uintptr)(unsafe.Pointer(v494))++
			*(*uint8)(unsafe.Pointer(v493)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(8))
			v496 = envPtr2 + 152
			v495 = *(*uintptr)(unsafe.Pointer(v496))
			*(*uintptr)(unsafe.Pointer(v496))++
			*(*uint8)(unsafe.Pointer(v495)) = uint8(libc.Uint32FromInt32(_objIndexCopy5))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy5
				}
				v497 = delta1
				v498 = envPtr2
				if v497 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v498)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v498)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v498)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v498)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v498 + 64)) += int64(v497)
			}
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v500 = envPtr2 + 152
		v499 = *(*uintptr)(unsafe.Pointer(v500))
		*(*uintptr)(unsafe.Pointer(v500))++
		*(*uint8)(unsafe.Pointer(v499)) = libc.Uint8FromInt32(int32(INST_PUSH_RETURN_OPTIONS))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH_RETURN_OPTIONS)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v501 = delta1
			v502 = envPtr2
			if v501 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v502)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v502)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v502)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v502)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v502 + 64)) += int64(v501)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v504 = envPtr2 + 152
		v503 = *(*uintptr)(unsafe.Pointer(v504))
		*(*uintptr)(unsafe.Pointer(v504))++
		*(*uint8)(unsafe.Pointer(v503)) = libc.Uint8FromInt32(int32(INST_REVERSE))
		v506 = envPtr2 + 152
		v505 = *(*uintptr)(unsafe.Pointer(v506))
		*(*uintptr)(unsafe.Pointer(v506))++
		*(*uint8)(unsafe.Pointer(v505)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)) >> libc.Int32FromInt32(24))
		v508 = envPtr2 + 152
		v507 = *(*uintptr)(unsafe.Pointer(v508))
		*(*uintptr)(unsafe.Pointer(v508))++
		*(*uint8)(unsafe.Pointer(v507)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)) >> libc.Int32FromInt32(16))
		v510 = envPtr2 + 152
		v509 = *(*uintptr)(unsafe.Pointer(v510))
		*(*uintptr)(unsafe.Pointer(v510))++
		*(*uint8)(unsafe.Pointer(v509)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)) >> libc.Int32FromInt32(8))
		v512 = envPtr2 + 152
		v511 = *(*uintptr)(unsafe.Pointer(v512))
		*(*uintptr)(unsafe.Pointer(v512))++
		*(*uint8)(unsafe.Pointer(v511)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(3)
			}
			v513 = delta1
			v514 = envPtr2
			if v513 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v514)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v514)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v514)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v514)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v514 + 64)) += int64(v513)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v516 = envPtr2 + 152
		v515 = *(*uintptr)(unsafe.Pointer(v516))
		*(*uintptr)(unsafe.Pointer(v516))++
		*(*uint8)(unsafe.Pointer(v515)) = libc.Uint8FromInt32(int32(INST_JUMP1))
		v518 = envPtr2 + 152
		v517 = *(*uintptr)(unsafe.Pointer(v518))
		*(*uintptr)(unsafe.Pointer(v518))++
		*(*uint8)(unsafe.Pointer(v517)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(5)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(5)
			}
			v519 = delta1
			v520 = envPtr2
			if v519 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v520)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v520)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v520)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v520)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v520 + 64)) += int64(v519)
		}
		v521 = -int32(3)
		v522 = envPtr2
		if v521 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v522)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v522)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v522)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v522)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v522 + 64)) += int64(v521)
		*(*int32)(unsafe.Pointer(forwardsToFix + uintptr(i1)*4)) = -int32(1)
		/*
		 * Error in handler or setting of variables; replace the stored
		 * exception with the new one. Note that we only push this if we have
		 * either a body or some variable setting here. Otherwise this code is
		 * unreachable.
		 */
		goto finishTrapCatchHandling
	finishTrapCatchHandling:
		;
		(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcatchOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v524 = envPtr2 + 152
		v523 = *(*uintptr)(unsafe.Pointer(v524))
		*(*uintptr)(unsafe.Pointer(v524))++
		*(*uint8)(unsafe.Pointer(v523)) = libc.Uint8FromInt32(int32(INST_PUSH_RETURN_OPTIONS))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH_RETURN_OPTIONS)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v525 = delta1
			v526 = envPtr2
			if v525 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v526)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v526)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v526)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v526)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v526 + 64)) += int64(v525)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v528 = envPtr2 + 152
		v527 = *(*uintptr)(unsafe.Pointer(v528))
		*(*uintptr)(unsafe.Pointer(v528))++
		*(*uint8)(unsafe.Pointer(v527)) = libc.Uint8FromInt32(int32(INST_PUSH_RETURN_CODE))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH_RETURN_CODE)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v529 = delta1
			v530 = envPtr2
			if v529 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v530)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v530)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v530)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v530)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v530 + 64)) += int64(v529)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v532 = envPtr2 + 152
		v531 = *(*uintptr)(unsafe.Pointer(v532))
		*(*uintptr)(unsafe.Pointer(v532))++
		*(*uint8)(unsafe.Pointer(v531)) = libc.Uint8FromInt32(int32(INST_PUSH_RESULT))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH_RESULT)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v533 = delta1
			v534 = envPtr2
			if v533 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v534)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v534)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v534)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v534)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v534 + 64)) += int64(v533)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v536 = envPtr2 + 152
		v535 = *(*uintptr)(unsafe.Pointer(v536))
		*(*uintptr)(unsafe.Pointer(v536))++
		*(*uint8)(unsafe.Pointer(v535)) = libc.Uint8FromInt32(int32(INST_END_CATCH))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_END_CATCH)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v537 = delta1
			v538 = envPtr2
			if v537 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v538)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v538)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v538)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v538)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v538 + 64)) += int64(v537)
		}
		if resultVar < int32(256) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v540 = envPtr2 + 152
			v539 = *(*uintptr)(unsafe.Pointer(v540))
			*(*uintptr)(unsafe.Pointer(v540))++
			*(*uint8)(unsafe.Pointer(v539)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
			v542 = envPtr2 + 152
			v541 = *(*uintptr)(unsafe.Pointer(v542))
			*(*uintptr)(unsafe.Pointer(v542))++
			*(*uint8)(unsafe.Pointer(v541)) = uint8(libc.Uint32FromInt32(resultVar))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - resultVar
				}
				v543 = delta1
				v544 = envPtr2
				if v543 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v544)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v544)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v544)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v544)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v544 + 64)) += int64(v543)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v546 = envPtr2 + 152
			v545 = *(*uintptr)(unsafe.Pointer(v546))
			*(*uintptr)(unsafe.Pointer(v546))++
			*(*uint8)(unsafe.Pointer(v545)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
			v548 = envPtr2 + 152
			v547 = *(*uintptr)(unsafe.Pointer(v548))
			*(*uintptr)(unsafe.Pointer(v548))++
			*(*uint8)(unsafe.Pointer(v547)) = uint8(libc.Uint32FromInt32(resultVar) >> libc.Int32FromInt32(24))
			v550 = envPtr2 + 152
			v549 = *(*uintptr)(unsafe.Pointer(v550))
			*(*uintptr)(unsafe.Pointer(v550))++
			*(*uint8)(unsafe.Pointer(v549)) = uint8(libc.Uint32FromInt32(resultVar) >> libc.Int32FromInt32(16))
			v552 = envPtr2 + 152
			v551 = *(*uintptr)(unsafe.Pointer(v552))
			*(*uintptr)(unsafe.Pointer(v552))++
			*(*uint8)(unsafe.Pointer(v551)) = uint8(libc.Uint32FromInt32(resultVar) >> libc.Int32FromInt32(8))
			v554 = envPtr2 + 152
			v553 = *(*uintptr)(unsafe.Pointer(v554))
			*(*uintptr)(unsafe.Pointer(v554))++
			*(*uint8)(unsafe.Pointer(v553)) = uint8(libc.Uint32FromInt32(resultVar))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - resultVar
				}
				v555 = delta1
				v556 = envPtr2
				if v555 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v556)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v556)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v556)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v556)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v556 + 64)) += int64(v555)
			}
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v558 = envPtr2 + 152
		v557 = *(*uintptr)(unsafe.Pointer(v558))
		*(*uintptr)(unsafe.Pointer(v558))++
		*(*uint8)(unsafe.Pointer(v557)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v559 = delta1
			v560 = envPtr2
			if v559 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v560)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v560)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v560)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v560)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v560 + 64)) += int64(v559)
		}
		_objIndexCopy6 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+21397, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy6 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v562 = envPtr2 + 152
			v561 = *(*uintptr)(unsafe.Pointer(v562))
			*(*uintptr)(unsafe.Pointer(v562))++
			*(*uint8)(unsafe.Pointer(v561)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v564 = envPtr2 + 152
			v563 = *(*uintptr)(unsafe.Pointer(v564))
			*(*uintptr)(unsafe.Pointer(v564))++
			*(*uint8)(unsafe.Pointer(v563)) = uint8(libc.Uint32FromInt32(_objIndexCopy6))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy6
				}
				v565 = delta1
				v566 = envPtr2
				if v565 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v566)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v566)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v566)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v566)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v566 + 64)) += int64(v565)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v568 = envPtr2 + 152
			v567 = *(*uintptr)(unsafe.Pointer(v568))
			*(*uintptr)(unsafe.Pointer(v568))++
			*(*uint8)(unsafe.Pointer(v567)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v570 = envPtr2 + 152
			v569 = *(*uintptr)(unsafe.Pointer(v570))
			*(*uintptr)(unsafe.Pointer(v570))++
			*(*uint8)(unsafe.Pointer(v569)) = uint8(libc.Uint32FromInt32(_objIndexCopy6) >> libc.Int32FromInt32(24))
			v572 = envPtr2 + 152
			v571 = *(*uintptr)(unsafe.Pointer(v572))
			*(*uintptr)(unsafe.Pointer(v572))++
			*(*uint8)(unsafe.Pointer(v571)) = uint8(libc.Uint32FromInt32(_objIndexCopy6) >> libc.Int32FromInt32(16))
			v574 = envPtr2 + 152
			v573 = *(*uintptr)(unsafe.Pointer(v574))
			*(*uintptr)(unsafe.Pointer(v574))++
			*(*uint8)(unsafe.Pointer(v573)) = uint8(libc.Uint32FromInt32(_objIndexCopy6) >> libc.Int32FromInt32(8))
			v576 = envPtr2 + 152
			v575 = *(*uintptr)(unsafe.Pointer(v576))
			*(*uintptr)(unsafe.Pointer(v576))++
			*(*uint8)(unsafe.Pointer(v575)) = uint8(libc.Uint32FromInt32(_objIndexCopy6))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy6
				}
				v577 = delta1
				v578 = envPtr2
				if v577 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v578)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v578)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v578)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v578)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v578 + 64)) += int64(v577)
			}
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v580 = envPtr2 + 152
		v579 = *(*uintptr)(unsafe.Pointer(v580))
		*(*uintptr)(unsafe.Pointer(v580))++
		*(*uint8)(unsafe.Pointer(v579)) = libc.Uint8FromInt32(int32(INST_EQ))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_EQ)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v581 = delta1
			v582 = envPtr2
			if v581 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v582)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v582)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v582)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v582)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v582 + 64)) += int64(v581)
		}
		noTrapError = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v584 = envPtr2 + 152
		v583 = *(*uintptr)(unsafe.Pointer(v584))
		*(*uintptr)(unsafe.Pointer(v584))++
		*(*uint8)(unsafe.Pointer(v583)) = libc.Uint8FromInt32(int32(INST_JUMP_FALSE1))
		v586 = envPtr2 + 152
		v585 = *(*uintptr)(unsafe.Pointer(v586))
		*(*uintptr)(unsafe.Pointer(v586))++
		*(*uint8)(unsafe.Pointer(v585)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP_FALSE1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v587 = delta1
			v588 = envPtr2
			if v587 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v588)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v588)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v588)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v588)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v588 + 64)) += int64(v587)
		}
		if optionsVar < int32(256) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v590 = envPtr2 + 152
			v589 = *(*uintptr)(unsafe.Pointer(v590))
			*(*uintptr)(unsafe.Pointer(v590))++
			*(*uint8)(unsafe.Pointer(v589)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
			v592 = envPtr2 + 152
			v591 = *(*uintptr)(unsafe.Pointer(v592))
			*(*uintptr)(unsafe.Pointer(v592))++
			*(*uint8)(unsafe.Pointer(v591)) = uint8(libc.Uint32FromInt32(optionsVar))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - optionsVar
				}
				v593 = delta1
				v594 = envPtr2
				if v593 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v594)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v594)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v594)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v594)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v594 + 64)) += int64(v593)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v596 = envPtr2 + 152
			v595 = *(*uintptr)(unsafe.Pointer(v596))
			*(*uintptr)(unsafe.Pointer(v596))++
			*(*uint8)(unsafe.Pointer(v595)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
			v598 = envPtr2 + 152
			v597 = *(*uintptr)(unsafe.Pointer(v598))
			*(*uintptr)(unsafe.Pointer(v598))++
			*(*uint8)(unsafe.Pointer(v597)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(24))
			v600 = envPtr2 + 152
			v599 = *(*uintptr)(unsafe.Pointer(v600))
			*(*uintptr)(unsafe.Pointer(v600))++
			*(*uint8)(unsafe.Pointer(v599)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(16))
			v602 = envPtr2 + 152
			v601 = *(*uintptr)(unsafe.Pointer(v602))
			*(*uintptr)(unsafe.Pointer(v602))++
			*(*uint8)(unsafe.Pointer(v601)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(8))
			v604 = envPtr2 + 152
			v603 = *(*uintptr)(unsafe.Pointer(v604))
			*(*uintptr)(unsafe.Pointer(v604))++
			*(*uint8)(unsafe.Pointer(v603)) = uint8(libc.Uint32FromInt32(optionsVar))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - optionsVar
				}
				v605 = delta1
				v606 = envPtr2
				if v605 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v606)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v606)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v606)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v606)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v606 + 64)) += int64(v605)
			}
		}
		_objIndexCopy7 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+21234, libc.Int64FromUint64(libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy7 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v608 = envPtr2 + 152
			v607 = *(*uintptr)(unsafe.Pointer(v608))
			*(*uintptr)(unsafe.Pointer(v608))++
			*(*uint8)(unsafe.Pointer(v607)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v610 = envPtr2 + 152
			v609 = *(*uintptr)(unsafe.Pointer(v610))
			*(*uintptr)(unsafe.Pointer(v610))++
			*(*uint8)(unsafe.Pointer(v609)) = uint8(libc.Uint32FromInt32(_objIndexCopy7))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy7
				}
				v611 = delta1
				v612 = envPtr2
				if v611 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v612)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v612)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v612)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v612)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v612 + 64)) += int64(v611)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v614 = envPtr2 + 152
			v613 = *(*uintptr)(unsafe.Pointer(v614))
			*(*uintptr)(unsafe.Pointer(v614))++
			*(*uint8)(unsafe.Pointer(v613)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v616 = envPtr2 + 152
			v615 = *(*uintptr)(unsafe.Pointer(v616))
			*(*uintptr)(unsafe.Pointer(v616))++
			*(*uint8)(unsafe.Pointer(v615)) = uint8(libc.Uint32FromInt32(_objIndexCopy7) >> libc.Int32FromInt32(24))
			v618 = envPtr2 + 152
			v617 = *(*uintptr)(unsafe.Pointer(v618))
			*(*uintptr)(unsafe.Pointer(v618))++
			*(*uint8)(unsafe.Pointer(v617)) = uint8(libc.Uint32FromInt32(_objIndexCopy7) >> libc.Int32FromInt32(16))
			v620 = envPtr2 + 152
			v619 = *(*uintptr)(unsafe.Pointer(v620))
			*(*uintptr)(unsafe.Pointer(v620))++
			*(*uint8)(unsafe.Pointer(v619)) = uint8(libc.Uint32FromInt32(_objIndexCopy7) >> libc.Int32FromInt32(8))
			v622 = envPtr2 + 152
			v621 = *(*uintptr)(unsafe.Pointer(v622))
			*(*uintptr)(unsafe.Pointer(v622))++
			*(*uint8)(unsafe.Pointer(v621)) = uint8(libc.Uint32FromInt32(_objIndexCopy7))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy7
				}
				v623 = delta1
				v624 = envPtr2
				if v623 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v624)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v624)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v624)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v624)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v624 + 64)) += int64(v623)
			}
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v626 = envPtr2 + 152
		v625 = *(*uintptr)(unsafe.Pointer(v626))
		*(*uintptr)(unsafe.Pointer(v626))++
		*(*uint8)(unsafe.Pointer(v625)) = libc.Uint8FromInt32(int32(INST_REVERSE))
		v628 = envPtr2 + 152
		v627 = *(*uintptr)(unsafe.Pointer(v628))
		*(*uintptr)(unsafe.Pointer(v628))++
		*(*uint8)(unsafe.Pointer(v627)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)) >> libc.Int32FromInt32(24))
		v630 = envPtr2 + 152
		v629 = *(*uintptr)(unsafe.Pointer(v630))
		*(*uintptr)(unsafe.Pointer(v630))++
		*(*uint8)(unsafe.Pointer(v629)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)) >> libc.Int32FromInt32(16))
		v632 = envPtr2 + 152
		v631 = *(*uintptr)(unsafe.Pointer(v632))
		*(*uintptr)(unsafe.Pointer(v632))++
		*(*uint8)(unsafe.Pointer(v631)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)) >> libc.Int32FromInt32(8))
		v634 = envPtr2 + 152
		v633 = *(*uintptr)(unsafe.Pointer(v634))
		*(*uintptr)(unsafe.Pointer(v634))++
		*(*uint8)(unsafe.Pointer(v633)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(3)
			}
			v635 = delta1
			v636 = envPtr2
			if v635 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v636)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v636)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v636)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v636)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v636 + 64)) += int64(v635)
		}
		if optionsVar < int32(256) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v638 = envPtr2 + 152
			v637 = *(*uintptr)(unsafe.Pointer(v638))
			*(*uintptr)(unsafe.Pointer(v638))++
			*(*uint8)(unsafe.Pointer(v637)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
			v640 = envPtr2 + 152
			v639 = *(*uintptr)(unsafe.Pointer(v640))
			*(*uintptr)(unsafe.Pointer(v640))++
			*(*uint8)(unsafe.Pointer(v639)) = uint8(libc.Uint32FromInt32(optionsVar))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - optionsVar
				}
				v641 = delta1
				v642 = envPtr2
				if v641 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v642)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v642)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v642)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v642)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v642 + 64)) += int64(v641)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v644 = envPtr2 + 152
			v643 = *(*uintptr)(unsafe.Pointer(v644))
			*(*uintptr)(unsafe.Pointer(v644))++
			*(*uint8)(unsafe.Pointer(v643)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
			v646 = envPtr2 + 152
			v645 = *(*uintptr)(unsafe.Pointer(v646))
			*(*uintptr)(unsafe.Pointer(v646))++
			*(*uint8)(unsafe.Pointer(v645)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(24))
			v648 = envPtr2 + 152
			v647 = *(*uintptr)(unsafe.Pointer(v648))
			*(*uintptr)(unsafe.Pointer(v648))++
			*(*uint8)(unsafe.Pointer(v647)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(16))
			v650 = envPtr2 + 152
			v649 = *(*uintptr)(unsafe.Pointer(v650))
			*(*uintptr)(unsafe.Pointer(v650))++
			*(*uint8)(unsafe.Pointer(v649)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(8))
			v652 = envPtr2 + 152
			v651 = *(*uintptr)(unsafe.Pointer(v652))
			*(*uintptr)(unsafe.Pointer(v652))++
			*(*uint8)(unsafe.Pointer(v651)) = uint8(libc.Uint32FromInt32(optionsVar))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - optionsVar
				}
				v653 = delta1
				v654 = envPtr2
				if v653 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v654)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v654)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v654)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v654)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v654 + 64)) += int64(v653)
			}
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v656 = envPtr2 + 152
		v655 = *(*uintptr)(unsafe.Pointer(v656))
		*(*uintptr)(unsafe.Pointer(v656))++
		*(*uint8)(unsafe.Pointer(v655)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v657 = delta1
			v658 = envPtr2
			if v657 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v658)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v658)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v658)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v658)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v658 + 64)) += int64(v657)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v660 = envPtr2 + 152
		v659 = *(*uintptr)(unsafe.Pointer(v660))
		*(*uintptr)(unsafe.Pointer(v660))++
		*(*uint8)(unsafe.Pointer(v659)) = libc.Uint8FromInt32(int32(INST_DICT_SET))
		v662 = envPtr2 + 152
		v661 = *(*uintptr)(unsafe.Pointer(v662))
		*(*uintptr)(unsafe.Pointer(v662))++
		*(*uint8)(unsafe.Pointer(v661)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(24))
		v664 = envPtr2 + 152
		v663 = *(*uintptr)(unsafe.Pointer(v664))
		*(*uintptr)(unsafe.Pointer(v664))++
		*(*uint8)(unsafe.Pointer(v663)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(16))
		v666 = envPtr2 + 152
		v665 = *(*uintptr)(unsafe.Pointer(v666))
		*(*uintptr)(unsafe.Pointer(v666))++
		*(*uint8)(unsafe.Pointer(v665)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(8))
		v668 = envPtr2 + 152
		v667 = *(*uintptr)(unsafe.Pointer(v668))
		*(*uintptr)(unsafe.Pointer(v668))++
		*(*uint8)(unsafe.Pointer(v667)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_DICT_SET)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(1)
			}
			v669 = delta1
			v670 = envPtr2
			if v669 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v670)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v670)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v670)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v670)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v670 + 64)) += int64(v669)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v672 = envPtr2 + 152
		v671 = *(*uintptr)(unsafe.Pointer(v672))
		*(*uintptr)(unsafe.Pointer(v672))++
		*(*uint8)(unsafe.Pointer(v671)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(24))
		v674 = envPtr2 + 152
		v673 = *(*uintptr)(unsafe.Pointer(v674))
		*(*uintptr)(unsafe.Pointer(v674))++
		*(*uint8)(unsafe.Pointer(v673)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(16))
		v676 = envPtr2 + 152
		v675 = *(*uintptr)(unsafe.Pointer(v676))
		*(*uintptr)(unsafe.Pointer(v676))++
		*(*uint8)(unsafe.Pointer(v675)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(8))
		v678 = envPtr2 + 152
		v677 = *(*uintptr)(unsafe.Pointer(v678))
		*(*uintptr)(unsafe.Pointer(v678))++
		*(*uint8)(unsafe.Pointer(v677)) = uint8(libc.Uint32FromInt32(optionsVar))
		v679 = -int32(1)
		v680 = envPtr2
		if v679 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v680)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v680)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v680)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v680)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v680 + 64)) += int64(v679)
		trapError = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v682 = envPtr2 + 152
		v681 = *(*uintptr)(unsafe.Pointer(v682))
		*(*uintptr)(unsafe.Pointer(v682))++
		*(*uint8)(unsafe.Pointer(v681)) = libc.Uint8FromInt32(int32(INST_JUMP1))
		v684 = envPtr2 + 152
		v683 = *(*uintptr)(unsafe.Pointer(v684))
		*(*uintptr)(unsafe.Pointer(v684))++
		*(*uint8)(unsafe.Pointer(v683)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_JUMP1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v685 = delta1
			v686 = envPtr2
			if v685 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v686)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v686)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v686)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v686)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v686 + 64)) += int64(v685)
		}
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(noTrapError) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(noTrapError)))
		if optionsVar < int32(256) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v688 = envPtr2 + 152
			v687 = *(*uintptr)(unsafe.Pointer(v688))
			*(*uintptr)(unsafe.Pointer(v688))++
			*(*uint8)(unsafe.Pointer(v687)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
			v690 = envPtr2 + 152
			v689 = *(*uintptr)(unsafe.Pointer(v690))
			*(*uintptr)(unsafe.Pointer(v690))++
			*(*uint8)(unsafe.Pointer(v689)) = uint8(libc.Uint32FromInt32(optionsVar))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - optionsVar
				}
				v691 = delta1
				v692 = envPtr2
				if v691 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v692)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v692)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v692)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v692)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v692 + 64)) += int64(v691)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v694 = envPtr2 + 152
			v693 = *(*uintptr)(unsafe.Pointer(v694))
			*(*uintptr)(unsafe.Pointer(v694))++
			*(*uint8)(unsafe.Pointer(v693)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
			v696 = envPtr2 + 152
			v695 = *(*uintptr)(unsafe.Pointer(v696))
			*(*uintptr)(unsafe.Pointer(v696))++
			*(*uint8)(unsafe.Pointer(v695)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(24))
			v698 = envPtr2 + 152
			v697 = *(*uintptr)(unsafe.Pointer(v698))
			*(*uintptr)(unsafe.Pointer(v698))++
			*(*uint8)(unsafe.Pointer(v697)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(16))
			v700 = envPtr2 + 152
			v699 = *(*uintptr)(unsafe.Pointer(v700))
			*(*uintptr)(unsafe.Pointer(v700))++
			*(*uint8)(unsafe.Pointer(v699)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(8))
			v702 = envPtr2 + 152
			v701 = *(*uintptr)(unsafe.Pointer(v702))
			*(*uintptr)(unsafe.Pointer(v702))++
			*(*uint8)(unsafe.Pointer(v701)) = uint8(libc.Uint32FromInt32(optionsVar))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - optionsVar
				}
				v703 = delta1
				v704 = envPtr2
				if v703 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v704)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v704)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v704)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v704)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v704 + 64)) += int64(v703)
			}
		}
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(trapError) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(trapError)))
		/* Skip POP at end; can clean up with subsequent POP */
		if i1+int32(1) < numHandlers {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v706 = envPtr2 + 152
			v705 = *(*uintptr)(unsafe.Pointer(v706))
			*(*uintptr)(unsafe.Pointer(v706))++
			*(*uint8)(unsafe.Pointer(v705)) = libc.Uint8FromInt32(int32(INST_POP))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v707 = delta1
				v708 = envPtr2
				if v707 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v708)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v708)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v708)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v708)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v708 + 64)) += int64(v707)
			}
		}
		goto endOfThisArm
	endOfThisArm:
		;
		if i1+int32(1) < numHandlers {
			*(*int32)(unsafe.Pointer(addrsToFix + uintptr(i1)*4)) = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v710 = envPtr2 + 152
			v709 = *(*uintptr)(unsafe.Pointer(v710))
			*(*uintptr)(unsafe.Pointer(v710))++
			*(*uint8)(unsafe.Pointer(v709)) = libc.Uint8FromInt32(int32(INST_JUMP4))
			v712 = envPtr2 + 152
			v711 = *(*uintptr)(unsafe.Pointer(v712))
			*(*uintptr)(unsafe.Pointer(v712))++
			*(*uint8)(unsafe.Pointer(v711)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
			v714 = envPtr2 + 152
			v713 = *(*uintptr)(unsafe.Pointer(v714))
			*(*uintptr)(unsafe.Pointer(v714))++
			*(*uint8)(unsafe.Pointer(v713)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
			v716 = envPtr2 + 152
			v715 = *(*uintptr)(unsafe.Pointer(v716))
			*(*uintptr)(unsafe.Pointer(v716))++
			*(*uint8)(unsafe.Pointer(v715)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
			v718 = envPtr2 + 152
			v717 = *(*uintptr)(unsafe.Pointer(v718))
			*(*uintptr)(unsafe.Pointer(v718))++
			*(*uint8)(unsafe.Pointer(v717)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_JUMP4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v719 = delta1
				v720 = envPtr2
				if v719 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v720)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v720)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v720)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v720)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v720 + 64)) += int64(v719)
			}
			v721 = int32(1)
			v722 = envPtr2
			if v721 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v722)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v722)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v722)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v722)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v722 + 64)) += int64(v721)
		}
		if *(*uintptr)(unsafe.Pointer(matchClauses + uintptr(i1)*8)) != 0 {
			*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(notECJumpSource) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(notECJumpSource)) >> libc.Int32FromInt32(24))
			*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(notECJumpSource) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(notECJumpSource)) >> libc.Int32FromInt32(16))
			*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(notECJumpSource) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(notECJumpSource)) >> libc.Int32FromInt32(8))
			*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(notECJumpSource) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(notECJumpSource)))
		}
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(notCodeJumpSource) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(notCodeJumpSource)) >> libc.Int32FromInt32(24))
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(notCodeJumpSource) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(notCodeJumpSource)) >> libc.Int32FromInt32(16))
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(notCodeJumpSource) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(notCodeJumpSource)) >> libc.Int32FromInt32(8))
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(notCodeJumpSource) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(notCodeJumpSource)))
		goto _191
	_191:
		;
		i1++
	}
	/*
	 * Drop the result code, and fix all the jumps from taken clauses - which
	 * drop the result code as their first action - to point straight after
	 * (i.e., to the start of the finally clause).
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v724 = envPtr2 + 152
	v723 = *(*uintptr)(unsafe.Pointer(v724))
	*(*uintptr)(unsafe.Pointer(v724))++
	*(*uint8)(unsafe.Pointer(v723)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v725 = delta1
		v726 = envPtr2
		if v725 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v726)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v726)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v726)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v726)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v726 + 64)) += int64(v725)
	}
	i1 = 0
	for {
		if !(i1 < numHandlers-int32(1)) {
			break
		}
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(*(*int32)(unsafe.Pointer(addrsToFix + uintptr(i1)*4))) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(*(*int32)(unsafe.Pointer(addrsToFix + uintptr(i1)*4)))) >> libc.Int32FromInt32(24))
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(*(*int32)(unsafe.Pointer(addrsToFix + uintptr(i1)*4))) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(*(*int32)(unsafe.Pointer(addrsToFix + uintptr(i1)*4)))) >> libc.Int32FromInt32(16))
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(*(*int32)(unsafe.Pointer(addrsToFix + uintptr(i1)*4))) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(*(*int32)(unsafe.Pointer(addrsToFix + uintptr(i1)*4)))) >> libc.Int32FromInt32(8))
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(*(*int32)(unsafe.Pointer(addrsToFix + uintptr(i1)*4))) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(*(*int32)(unsafe.Pointer(addrsToFix + uintptr(i1)*4)))))
		goto _727
	_727:
		;
		i1++
	}
	XTclStackFree(tls, interp, forwardsToFix)
	XTclStackFree(tls, interp, addrsToFix)
	/*
	 * Process the finally clause (at last!) Note that we do not wrap this in
	 * error handlers because we would just rethrow immediately anyway. Then
	 * (on normal success) we reissue the exception. Note also that
	 * INST_RETURN_STK can proceed to the next instruction; that'll be the
	 * next command (or some inter-command manipulation).
	 */
	if !(trapZero != 0) {
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(afterBody) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(afterBody)) >> libc.Int32FromInt32(24))
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(afterBody) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(afterBody)) >> libc.Int32FromInt32(16))
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(afterBody) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(afterBody)) >> libc.Int32FromInt32(8))
		*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(afterBody) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(afterBody)))
	}
	range1 = int32(XTclCreateExceptRange(tls, int32(CATCH_EXCEPTION_RANGE), envPtr2))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v729 = envPtr2 + 152
	v728 = *(*uintptr)(unsafe.Pointer(v729))
	*(*uintptr)(unsafe.Pointer(v729))++
	*(*uint8)(unsafe.Pointer(v728)) = libc.Uint8FromInt32(int32(INST_BEGIN_CATCH4))
	v731 = envPtr2 + 152
	v730 = *(*uintptr)(unsafe.Pointer(v731))
	*(*uintptr)(unsafe.Pointer(v731))++
	*(*uint8)(unsafe.Pointer(v730)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(24))
	v733 = envPtr2 + 152
	v732 = *(*uintptr)(unsafe.Pointer(v733))
	*(*uintptr)(unsafe.Pointer(v733))++
	*(*uint8)(unsafe.Pointer(v732)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(16))
	v735 = envPtr2 + 152
	v734 = *(*uintptr)(unsafe.Pointer(v735))
	*(*uintptr)(unsafe.Pointer(v735))++
	*(*uint8)(unsafe.Pointer(v734)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(8))
	v737 = envPtr2 + 152
	v736 = *(*uintptr)(unsafe.Pointer(v737))
	*(*uintptr)(unsafe.Pointer(v737))++
	*(*uint8)(unsafe.Pointer(v736)) = uint8(libc.Uint32FromInt32(range1))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_BEGIN_CATCH4)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - range1
		}
		v738 = delta1
		v739 = envPtr2
		if v738 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v739)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v739)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v739)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v739)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v739 + 64)) += int64(v738)
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth++
	if libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth)+uint64(1) > libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth)+uint64(1) {
		v740 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth
	} else {
		v740 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth = v740
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(4)*numHandlers)*8))
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(4)*numHandlers)*8))
	XTclCompileCmdWord(tls, interp, finallyToken+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(finallyToken)).FnumComponents), envPtr2)
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth--
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FnumCodeBytes = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(int32((*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v742 = envPtr2 + 152
	v741 = *(*uintptr)(unsafe.Pointer(v742))
	*(*uintptr)(unsafe.Pointer(v742))++
	*(*uint8)(unsafe.Pointer(v741)) = libc.Uint8FromInt32(int32(INST_END_CATCH))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_END_CATCH)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v743 = delta1
		v744 = envPtr2
		if v743 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v744)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v744)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v744)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v744)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v744 + 64)) += int64(v743)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v746 = envPtr2 + 152
	v745 = *(*uintptr)(unsafe.Pointer(v746))
	*(*uintptr)(unsafe.Pointer(v746))++
	*(*uint8)(unsafe.Pointer(v745)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v747 = delta1
		v748 = envPtr2
		if v747 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v748)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v748)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v748)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v748)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v748 + 64)) += int64(v747)
	}
	finalOK = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v750 = envPtr2 + 152
	v749 = *(*uintptr)(unsafe.Pointer(v750))
	*(*uintptr)(unsafe.Pointer(v750))++
	*(*uint8)(unsafe.Pointer(v749)) = libc.Uint8FromInt32(int32(INST_JUMP1))
	v752 = envPtr2 + 152
	v751 = *(*uintptr)(unsafe.Pointer(v752))
	*(*uintptr)(unsafe.Pointer(v752))++
	*(*uint8)(unsafe.Pointer(v751)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_JUMP1)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v753 = delta1
		v754 = envPtr2
		if v753 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v754)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v754)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v754)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v754)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v754 + 64)) += int64(v753)
	}
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcatchOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v756 = envPtr2 + 152
	v755 = *(*uintptr)(unsafe.Pointer(v756))
	*(*uintptr)(unsafe.Pointer(v756))++
	*(*uint8)(unsafe.Pointer(v755)) = libc.Uint8FromInt32(int32(INST_PUSH_RESULT))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_PUSH_RESULT)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v757 = delta1
		v758 = envPtr2
		if v757 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v758)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v758)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v758)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v758)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v758 + 64)) += int64(v757)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v760 = envPtr2 + 152
	v759 = *(*uintptr)(unsafe.Pointer(v760))
	*(*uintptr)(unsafe.Pointer(v760))++
	*(*uint8)(unsafe.Pointer(v759)) = libc.Uint8FromInt32(int32(INST_PUSH_RETURN_OPTIONS))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_PUSH_RETURN_OPTIONS)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v761 = delta1
		v762 = envPtr2
		if v761 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v762)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v762)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v762)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v762)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v762 + 64)) += int64(v761)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v764 = envPtr2 + 152
	v763 = *(*uintptr)(unsafe.Pointer(v764))
	*(*uintptr)(unsafe.Pointer(v764))++
	*(*uint8)(unsafe.Pointer(v763)) = libc.Uint8FromInt32(int32(INST_PUSH_RETURN_CODE))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_PUSH_RETURN_CODE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v765 = delta1
		v766 = envPtr2
		if v765 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v766)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v766)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v766)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v766)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v766 + 64)) += int64(v765)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v768 = envPtr2 + 152
	v767 = *(*uintptr)(unsafe.Pointer(v768))
	*(*uintptr)(unsafe.Pointer(v768))++
	*(*uint8)(unsafe.Pointer(v767)) = libc.Uint8FromInt32(int32(INST_END_CATCH))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_END_CATCH)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v769 = delta1
		v770 = envPtr2
		if v769 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v770)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v770)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v770)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v770)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v770 + 64)) += int64(v769)
	}
	_objIndexCopy8 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+21397, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy8 <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v772 = envPtr2 + 152
		v771 = *(*uintptr)(unsafe.Pointer(v772))
		*(*uintptr)(unsafe.Pointer(v772))++
		*(*uint8)(unsafe.Pointer(v771)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v774 = envPtr2 + 152
		v773 = *(*uintptr)(unsafe.Pointer(v774))
		*(*uintptr)(unsafe.Pointer(v774))++
		*(*uint8)(unsafe.Pointer(v773)) = uint8(libc.Uint32FromInt32(_objIndexCopy8))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy8
			}
			v775 = delta1
			v776 = envPtr2
			if v775 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v776)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v776)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v776)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v776)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v776 + 64)) += int64(v775)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v778 = envPtr2 + 152
		v777 = *(*uintptr)(unsafe.Pointer(v778))
		*(*uintptr)(unsafe.Pointer(v778))++
		*(*uint8)(unsafe.Pointer(v777)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v780 = envPtr2 + 152
		v779 = *(*uintptr)(unsafe.Pointer(v780))
		*(*uintptr)(unsafe.Pointer(v780))++
		*(*uint8)(unsafe.Pointer(v779)) = uint8(libc.Uint32FromInt32(_objIndexCopy8) >> libc.Int32FromInt32(24))
		v782 = envPtr2 + 152
		v781 = *(*uintptr)(unsafe.Pointer(v782))
		*(*uintptr)(unsafe.Pointer(v782))++
		*(*uint8)(unsafe.Pointer(v781)) = uint8(libc.Uint32FromInt32(_objIndexCopy8) >> libc.Int32FromInt32(16))
		v784 = envPtr2 + 152
		v783 = *(*uintptr)(unsafe.Pointer(v784))
		*(*uintptr)(unsafe.Pointer(v784))++
		*(*uint8)(unsafe.Pointer(v783)) = uint8(libc.Uint32FromInt32(_objIndexCopy8) >> libc.Int32FromInt32(8))
		v786 = envPtr2 + 152
		v785 = *(*uintptr)(unsafe.Pointer(v786))
		*(*uintptr)(unsafe.Pointer(v786))++
		*(*uint8)(unsafe.Pointer(v785)) = uint8(libc.Uint32FromInt32(_objIndexCopy8))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy8
			}
			v787 = delta1
			v788 = envPtr2
			if v787 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v788)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v788)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v788)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v788)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v788 + 64)) += int64(v787)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v790 = envPtr2 + 152
	v789 = *(*uintptr)(unsafe.Pointer(v790))
	*(*uintptr)(unsafe.Pointer(v790))++
	*(*uint8)(unsafe.Pointer(v789)) = libc.Uint8FromInt32(int32(INST_EQ))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_EQ)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v791 = delta1
		v792 = envPtr2
		if v791 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v792)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v792)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v792)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v792)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v792 + 64)) += int64(v791)
	}
	noFinalError = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v794 = envPtr2 + 152
	v793 = *(*uintptr)(unsafe.Pointer(v794))
	*(*uintptr)(unsafe.Pointer(v794))++
	*(*uint8)(unsafe.Pointer(v793)) = libc.Uint8FromInt32(int32(INST_JUMP_FALSE1))
	v796 = envPtr2 + 152
	v795 = *(*uintptr)(unsafe.Pointer(v796))
	*(*uintptr)(unsafe.Pointer(v796))++
	*(*uint8)(unsafe.Pointer(v795)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_JUMP_FALSE1)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v797 = delta1
		v798 = envPtr2
		if v797 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v798)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v798)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v798)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v798)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v798 + 64)) += int64(v797)
	}
	if optionsVar < int32(256) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v800 = envPtr2 + 152
		v799 = *(*uintptr)(unsafe.Pointer(v800))
		*(*uintptr)(unsafe.Pointer(v800))++
		*(*uint8)(unsafe.Pointer(v799)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
		v802 = envPtr2 + 152
		v801 = *(*uintptr)(unsafe.Pointer(v802))
		*(*uintptr)(unsafe.Pointer(v802))++
		*(*uint8)(unsafe.Pointer(v801)) = uint8(libc.Uint32FromInt32(optionsVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - optionsVar
			}
			v803 = delta1
			v804 = envPtr2
			if v803 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v804)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v804)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v804)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v804)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v804 + 64)) += int64(v803)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v806 = envPtr2 + 152
		v805 = *(*uintptr)(unsafe.Pointer(v806))
		*(*uintptr)(unsafe.Pointer(v806))++
		*(*uint8)(unsafe.Pointer(v805)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
		v808 = envPtr2 + 152
		v807 = *(*uintptr)(unsafe.Pointer(v808))
		*(*uintptr)(unsafe.Pointer(v808))++
		*(*uint8)(unsafe.Pointer(v807)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(24))
		v810 = envPtr2 + 152
		v809 = *(*uintptr)(unsafe.Pointer(v810))
		*(*uintptr)(unsafe.Pointer(v810))++
		*(*uint8)(unsafe.Pointer(v809)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(16))
		v812 = envPtr2 + 152
		v811 = *(*uintptr)(unsafe.Pointer(v812))
		*(*uintptr)(unsafe.Pointer(v812))++
		*(*uint8)(unsafe.Pointer(v811)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(8))
		v814 = envPtr2 + 152
		v813 = *(*uintptr)(unsafe.Pointer(v814))
		*(*uintptr)(unsafe.Pointer(v814))++
		*(*uint8)(unsafe.Pointer(v813)) = uint8(libc.Uint32FromInt32(optionsVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - optionsVar
			}
			v815 = delta1
			v816 = envPtr2
			if v815 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v816)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v816)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v816)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v816)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v816 + 64)) += int64(v815)
		}
	}
	_objIndexCopy9 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+21234, libc.Int64FromUint64(libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy9 <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v818 = envPtr2 + 152
		v817 = *(*uintptr)(unsafe.Pointer(v818))
		*(*uintptr)(unsafe.Pointer(v818))++
		*(*uint8)(unsafe.Pointer(v817)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v820 = envPtr2 + 152
		v819 = *(*uintptr)(unsafe.Pointer(v820))
		*(*uintptr)(unsafe.Pointer(v820))++
		*(*uint8)(unsafe.Pointer(v819)) = uint8(libc.Uint32FromInt32(_objIndexCopy9))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy9
			}
			v821 = delta1
			v822 = envPtr2
			if v821 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v822)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v822)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v822)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v822)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v822 + 64)) += int64(v821)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v824 = envPtr2 + 152
		v823 = *(*uintptr)(unsafe.Pointer(v824))
		*(*uintptr)(unsafe.Pointer(v824))++
		*(*uint8)(unsafe.Pointer(v823)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v826 = envPtr2 + 152
		v825 = *(*uintptr)(unsafe.Pointer(v826))
		*(*uintptr)(unsafe.Pointer(v826))++
		*(*uint8)(unsafe.Pointer(v825)) = uint8(libc.Uint32FromInt32(_objIndexCopy9) >> libc.Int32FromInt32(24))
		v828 = envPtr2 + 152
		v827 = *(*uintptr)(unsafe.Pointer(v828))
		*(*uintptr)(unsafe.Pointer(v828))++
		*(*uint8)(unsafe.Pointer(v827)) = uint8(libc.Uint32FromInt32(_objIndexCopy9) >> libc.Int32FromInt32(16))
		v830 = envPtr2 + 152
		v829 = *(*uintptr)(unsafe.Pointer(v830))
		*(*uintptr)(unsafe.Pointer(v830))++
		*(*uint8)(unsafe.Pointer(v829)) = uint8(libc.Uint32FromInt32(_objIndexCopy9) >> libc.Int32FromInt32(8))
		v832 = envPtr2 + 152
		v831 = *(*uintptr)(unsafe.Pointer(v832))
		*(*uintptr)(unsafe.Pointer(v832))++
		*(*uint8)(unsafe.Pointer(v831)) = uint8(libc.Uint32FromInt32(_objIndexCopy9))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy9
			}
			v833 = delta1
			v834 = envPtr2
			if v833 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v834)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v834)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v834)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v834)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v834 + 64)) += int64(v833)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v836 = envPtr2 + 152
	v835 = *(*uintptr)(unsafe.Pointer(v836))
	*(*uintptr)(unsafe.Pointer(v836))++
	*(*uint8)(unsafe.Pointer(v835)) = libc.Uint8FromInt32(int32(INST_REVERSE))
	v838 = envPtr2 + 152
	v837 = *(*uintptr)(unsafe.Pointer(v838))
	*(*uintptr)(unsafe.Pointer(v838))++
	*(*uint8)(unsafe.Pointer(v837)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)) >> libc.Int32FromInt32(24))
	v840 = envPtr2 + 152
	v839 = *(*uintptr)(unsafe.Pointer(v840))
	*(*uintptr)(unsafe.Pointer(v840))++
	*(*uint8)(unsafe.Pointer(v839)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)) >> libc.Int32FromInt32(16))
	v842 = envPtr2 + 152
	v841 = *(*uintptr)(unsafe.Pointer(v842))
	*(*uintptr)(unsafe.Pointer(v842))++
	*(*uint8)(unsafe.Pointer(v841)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)) >> libc.Int32FromInt32(8))
	v844 = envPtr2 + 152
	v843 = *(*uintptr)(unsafe.Pointer(v844))
	*(*uintptr)(unsafe.Pointer(v844))++
	*(*uint8)(unsafe.Pointer(v843)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32(3)
		}
		v845 = delta1
		v846 = envPtr2
		if v845 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v846)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v846)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v846)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v846)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v846 + 64)) += int64(v845)
	}
	if optionsVar < int32(256) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v848 = envPtr2 + 152
		v847 = *(*uintptr)(unsafe.Pointer(v848))
		*(*uintptr)(unsafe.Pointer(v848))++
		*(*uint8)(unsafe.Pointer(v847)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
		v850 = envPtr2 + 152
		v849 = *(*uintptr)(unsafe.Pointer(v850))
		*(*uintptr)(unsafe.Pointer(v850))++
		*(*uint8)(unsafe.Pointer(v849)) = uint8(libc.Uint32FromInt32(optionsVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - optionsVar
			}
			v851 = delta1
			v852 = envPtr2
			if v851 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v852)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v852)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v852)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v852)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v852 + 64)) += int64(v851)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v854 = envPtr2 + 152
		v853 = *(*uintptr)(unsafe.Pointer(v854))
		*(*uintptr)(unsafe.Pointer(v854))++
		*(*uint8)(unsafe.Pointer(v853)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
		v856 = envPtr2 + 152
		v855 = *(*uintptr)(unsafe.Pointer(v856))
		*(*uintptr)(unsafe.Pointer(v856))++
		*(*uint8)(unsafe.Pointer(v855)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(24))
		v858 = envPtr2 + 152
		v857 = *(*uintptr)(unsafe.Pointer(v858))
		*(*uintptr)(unsafe.Pointer(v858))++
		*(*uint8)(unsafe.Pointer(v857)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(16))
		v860 = envPtr2 + 152
		v859 = *(*uintptr)(unsafe.Pointer(v860))
		*(*uintptr)(unsafe.Pointer(v860))++
		*(*uint8)(unsafe.Pointer(v859)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(8))
		v862 = envPtr2 + 152
		v861 = *(*uintptr)(unsafe.Pointer(v862))
		*(*uintptr)(unsafe.Pointer(v862))++
		*(*uint8)(unsafe.Pointer(v861)) = uint8(libc.Uint32FromInt32(optionsVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - optionsVar
			}
			v863 = delta1
			v864 = envPtr2
			if v863 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v864)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v864)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v864)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v864)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v864 + 64)) += int64(v863)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v866 = envPtr2 + 152
	v865 = *(*uintptr)(unsafe.Pointer(v866))
	*(*uintptr)(unsafe.Pointer(v866))++
	*(*uint8)(unsafe.Pointer(v865)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v867 = delta1
		v868 = envPtr2
		if v867 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v868)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v868)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v868)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v868)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v868 + 64)) += int64(v867)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v870 = envPtr2 + 152
	v869 = *(*uintptr)(unsafe.Pointer(v870))
	*(*uintptr)(unsafe.Pointer(v870))++
	*(*uint8)(unsafe.Pointer(v869)) = libc.Uint8FromInt32(int32(INST_DICT_SET))
	v872 = envPtr2 + 152
	v871 = *(*uintptr)(unsafe.Pointer(v872))
	*(*uintptr)(unsafe.Pointer(v872))++
	*(*uint8)(unsafe.Pointer(v871)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(24))
	v874 = envPtr2 + 152
	v873 = *(*uintptr)(unsafe.Pointer(v874))
	*(*uintptr)(unsafe.Pointer(v874))++
	*(*uint8)(unsafe.Pointer(v873)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(16))
	v876 = envPtr2 + 152
	v875 = *(*uintptr)(unsafe.Pointer(v876))
	*(*uintptr)(unsafe.Pointer(v876))++
	*(*uint8)(unsafe.Pointer(v875)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)) >> libc.Int32FromInt32(8))
	v878 = envPtr2 + 152
	v877 = *(*uintptr)(unsafe.Pointer(v878))
	*(*uintptr)(unsafe.Pointer(v878))++
	*(*uint8)(unsafe.Pointer(v877)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(1)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_DICT_SET)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32(1)
		}
		v879 = delta1
		v880 = envPtr2
		if v879 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v880)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v880)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v880)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v880)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v880 + 64)) += int64(v879)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v882 = envPtr2 + 152
	v881 = *(*uintptr)(unsafe.Pointer(v882))
	*(*uintptr)(unsafe.Pointer(v882))++
	*(*uint8)(unsafe.Pointer(v881)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(24))
	v884 = envPtr2 + 152
	v883 = *(*uintptr)(unsafe.Pointer(v884))
	*(*uintptr)(unsafe.Pointer(v884))++
	*(*uint8)(unsafe.Pointer(v883)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(16))
	v886 = envPtr2 + 152
	v885 = *(*uintptr)(unsafe.Pointer(v886))
	*(*uintptr)(unsafe.Pointer(v886))++
	*(*uint8)(unsafe.Pointer(v885)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(8))
	v888 = envPtr2 + 152
	v887 = *(*uintptr)(unsafe.Pointer(v888))
	*(*uintptr)(unsafe.Pointer(v888))++
	*(*uint8)(unsafe.Pointer(v887)) = uint8(libc.Uint32FromInt32(optionsVar))
	v889 = -int32(1)
	v890 = envPtr2
	if v889 < libc.Int32FromInt32(0) {
		if int32((*TCompileEnv)(unsafe.Pointer(v890)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v890)).FcurrStackDepth) {
			(*TCompileEnv)(unsafe.Pointer(v890)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v890)).FcurrStackDepth
		}
	}
	*(*TTcl_Size)(unsafe.Pointer(v890 + 64)) += int64(v889)
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v892 = envPtr2 + 152
	v891 = *(*uintptr)(unsafe.Pointer(v892))
	*(*uintptr)(unsafe.Pointer(v892))++
	*(*uint8)(unsafe.Pointer(v891)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v893 = delta1
		v894 = envPtr2
		if v893 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v894)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v894)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v894)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v894)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v894 + 64)) += int64(v893)
	}
	finalError = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v896 = envPtr2 + 152
	v895 = *(*uintptr)(unsafe.Pointer(v896))
	*(*uintptr)(unsafe.Pointer(v896))++
	*(*uint8)(unsafe.Pointer(v895)) = libc.Uint8FromInt32(int32(INST_JUMP1))
	v898 = envPtr2 + 152
	v897 = *(*uintptr)(unsafe.Pointer(v898))
	*(*uintptr)(unsafe.Pointer(v898))++
	*(*uint8)(unsafe.Pointer(v897)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_JUMP1)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v899 = delta1
		v900 = envPtr2
		if v899 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v900)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v900)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v900)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v900)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v900 + 64)) += int64(v899)
	}
	v901 = int32(1)
	v902 = envPtr2
	if v901 < libc.Int32FromInt32(0) {
		if int32((*TCompileEnv)(unsafe.Pointer(v902)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v902)).FcurrStackDepth) {
			(*TCompileEnv)(unsafe.Pointer(v902)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v902)).FcurrStackDepth
		}
	}
	*(*TTcl_Size)(unsafe.Pointer(v902 + 64)) += int64(v901)
	*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(noFinalError) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(noFinalError)))
	if optionsVar < int32(256) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v904 = envPtr2 + 152
		v903 = *(*uintptr)(unsafe.Pointer(v904))
		*(*uintptr)(unsafe.Pointer(v904))++
		*(*uint8)(unsafe.Pointer(v903)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
		v906 = envPtr2 + 152
		v905 = *(*uintptr)(unsafe.Pointer(v906))
		*(*uintptr)(unsafe.Pointer(v906))++
		*(*uint8)(unsafe.Pointer(v905)) = uint8(libc.Uint32FromInt32(optionsVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - optionsVar
			}
			v907 = delta1
			v908 = envPtr2
			if v907 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v908)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v908)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v908)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v908)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v908 + 64)) += int64(v907)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v910 = envPtr2 + 152
		v909 = *(*uintptr)(unsafe.Pointer(v910))
		*(*uintptr)(unsafe.Pointer(v910))++
		*(*uint8)(unsafe.Pointer(v909)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
		v912 = envPtr2 + 152
		v911 = *(*uintptr)(unsafe.Pointer(v912))
		*(*uintptr)(unsafe.Pointer(v912))++
		*(*uint8)(unsafe.Pointer(v911)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(24))
		v914 = envPtr2 + 152
		v913 = *(*uintptr)(unsafe.Pointer(v914))
		*(*uintptr)(unsafe.Pointer(v914))++
		*(*uint8)(unsafe.Pointer(v913)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(16))
		v916 = envPtr2 + 152
		v915 = *(*uintptr)(unsafe.Pointer(v916))
		*(*uintptr)(unsafe.Pointer(v916))++
		*(*uint8)(unsafe.Pointer(v915)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(8))
		v918 = envPtr2 + 152
		v917 = *(*uintptr)(unsafe.Pointer(v918))
		*(*uintptr)(unsafe.Pointer(v918))++
		*(*uint8)(unsafe.Pointer(v917)) = uint8(libc.Uint32FromInt32(optionsVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - optionsVar
			}
			v919 = delta1
			v920 = envPtr2
			if v919 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v920)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v920)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v920)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v920)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v920 + 64)) += int64(v919)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v922 = envPtr2 + 152
	v921 = *(*uintptr)(unsafe.Pointer(v922))
	*(*uintptr)(unsafe.Pointer(v922))++
	*(*uint8)(unsafe.Pointer(v921)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v923 = delta1
		v924 = envPtr2
		if v923 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v924)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v924)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v924)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v924)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v924 + 64)) += int64(v923)
	}
	*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(finalError) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(finalError)))
	if resultVar < int32(256) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v926 = envPtr2 + 152
		v925 = *(*uintptr)(unsafe.Pointer(v926))
		*(*uintptr)(unsafe.Pointer(v926))++
		*(*uint8)(unsafe.Pointer(v925)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
		v928 = envPtr2 + 152
		v927 = *(*uintptr)(unsafe.Pointer(v928))
		*(*uintptr)(unsafe.Pointer(v928))++
		*(*uint8)(unsafe.Pointer(v927)) = uint8(libc.Uint32FromInt32(resultVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - resultVar
			}
			v929 = delta1
			v930 = envPtr2
			if v929 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v930)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v930)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v930)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v930)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v930 + 64)) += int64(v929)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v932 = envPtr2 + 152
		v931 = *(*uintptr)(unsafe.Pointer(v932))
		*(*uintptr)(unsafe.Pointer(v932))++
		*(*uint8)(unsafe.Pointer(v931)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
		v934 = envPtr2 + 152
		v933 = *(*uintptr)(unsafe.Pointer(v934))
		*(*uintptr)(unsafe.Pointer(v934))++
		*(*uint8)(unsafe.Pointer(v933)) = uint8(libc.Uint32FromInt32(resultVar) >> libc.Int32FromInt32(24))
		v936 = envPtr2 + 152
		v935 = *(*uintptr)(unsafe.Pointer(v936))
		*(*uintptr)(unsafe.Pointer(v936))++
		*(*uint8)(unsafe.Pointer(v935)) = uint8(libc.Uint32FromInt32(resultVar) >> libc.Int32FromInt32(16))
		v938 = envPtr2 + 152
		v937 = *(*uintptr)(unsafe.Pointer(v938))
		*(*uintptr)(unsafe.Pointer(v938))++
		*(*uint8)(unsafe.Pointer(v937)) = uint8(libc.Uint32FromInt32(resultVar) >> libc.Int32FromInt32(8))
		v940 = envPtr2 + 152
		v939 = *(*uintptr)(unsafe.Pointer(v940))
		*(*uintptr)(unsafe.Pointer(v940))++
		*(*uint8)(unsafe.Pointer(v939)) = uint8(libc.Uint32FromInt32(resultVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - resultVar
			}
			v941 = delta1
			v942 = envPtr2
			if v941 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v942)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v942)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v942)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v942)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v942 + 64)) += int64(v941)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v944 = envPtr2 + 152
	v943 = *(*uintptr)(unsafe.Pointer(v944))
	*(*uintptr)(unsafe.Pointer(v944))++
	*(*uint8)(unsafe.Pointer(v943)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v945 = delta1
		v946 = envPtr2
		if v945 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v946)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v946)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v946)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v946)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v946 + 64)) += int64(v945)
	}
	*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(finalOK) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(finalOK)))
	if optionsVar < int32(256) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v948 = envPtr2 + 152
		v947 = *(*uintptr)(unsafe.Pointer(v948))
		*(*uintptr)(unsafe.Pointer(v948))++
		*(*uint8)(unsafe.Pointer(v947)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
		v950 = envPtr2 + 152
		v949 = *(*uintptr)(unsafe.Pointer(v950))
		*(*uintptr)(unsafe.Pointer(v950))++
		*(*uint8)(unsafe.Pointer(v949)) = uint8(libc.Uint32FromInt32(optionsVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - optionsVar
			}
			v951 = delta1
			v952 = envPtr2
			if v951 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v952)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v952)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v952)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v952)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v952 + 64)) += int64(v951)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v954 = envPtr2 + 152
		v953 = *(*uintptr)(unsafe.Pointer(v954))
		*(*uintptr)(unsafe.Pointer(v954))++
		*(*uint8)(unsafe.Pointer(v953)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
		v956 = envPtr2 + 152
		v955 = *(*uintptr)(unsafe.Pointer(v956))
		*(*uintptr)(unsafe.Pointer(v956))++
		*(*uint8)(unsafe.Pointer(v955)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(24))
		v958 = envPtr2 + 152
		v957 = *(*uintptr)(unsafe.Pointer(v958))
		*(*uintptr)(unsafe.Pointer(v958))++
		*(*uint8)(unsafe.Pointer(v957)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(16))
		v960 = envPtr2 + 152
		v959 = *(*uintptr)(unsafe.Pointer(v960))
		*(*uintptr)(unsafe.Pointer(v960))++
		*(*uint8)(unsafe.Pointer(v959)) = uint8(libc.Uint32FromInt32(optionsVar) >> libc.Int32FromInt32(8))
		v962 = envPtr2 + 152
		v961 = *(*uintptr)(unsafe.Pointer(v962))
		*(*uintptr)(unsafe.Pointer(v962))++
		*(*uint8)(unsafe.Pointer(v961)) = uint8(libc.Uint32FromInt32(optionsVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - optionsVar
			}
			v963 = delta1
			v964 = envPtr2
			if v963 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v964)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v964)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v964)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v964)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v964 + 64)) += int64(v963)
		}
	}
	if resultVar < int32(256) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v966 = envPtr2 + 152
		v965 = *(*uintptr)(unsafe.Pointer(v966))
		*(*uintptr)(unsafe.Pointer(v966))++
		*(*uint8)(unsafe.Pointer(v965)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
		v968 = envPtr2 + 152
		v967 = *(*uintptr)(unsafe.Pointer(v968))
		*(*uintptr)(unsafe.Pointer(v968))++
		*(*uint8)(unsafe.Pointer(v967)) = uint8(libc.Uint32FromInt32(resultVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - resultVar
			}
			v969 = delta1
			v970 = envPtr2
			if v969 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v970)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v970)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v970)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v970)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v970 + 64)) += int64(v969)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v972 = envPtr2 + 152
		v971 = *(*uintptr)(unsafe.Pointer(v972))
		*(*uintptr)(unsafe.Pointer(v972))++
		*(*uint8)(unsafe.Pointer(v971)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
		v974 = envPtr2 + 152
		v973 = *(*uintptr)(unsafe.Pointer(v974))
		*(*uintptr)(unsafe.Pointer(v974))++
		*(*uint8)(unsafe.Pointer(v973)) = uint8(libc.Uint32FromInt32(resultVar) >> libc.Int32FromInt32(24))
		v976 = envPtr2 + 152
		v975 = *(*uintptr)(unsafe.Pointer(v976))
		*(*uintptr)(unsafe.Pointer(v976))++
		*(*uint8)(unsafe.Pointer(v975)) = uint8(libc.Uint32FromInt32(resultVar) >> libc.Int32FromInt32(16))
		v978 = envPtr2 + 152
		v977 = *(*uintptr)(unsafe.Pointer(v978))
		*(*uintptr)(unsafe.Pointer(v978))++
		*(*uint8)(unsafe.Pointer(v977)) = uint8(libc.Uint32FromInt32(resultVar) >> libc.Int32FromInt32(8))
		v980 = envPtr2 + 152
		v979 = *(*uintptr)(unsafe.Pointer(v980))
		*(*uintptr)(unsafe.Pointer(v980))++
		*(*uint8)(unsafe.Pointer(v979)) = uint8(libc.Uint32FromInt32(resultVar))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - resultVar
			}
			v981 = delta1
			v982 = envPtr2
			if v981 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v982)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v982)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v982)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v982)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v982 + 64)) += int64(v981)
		}
	}
	XTclEmitInvoke(tls, envPtr2, int32(INST_RETURN_STK), 0)
	return TCL_OK
}

func _IssueTryFinallyInstructions(tls *libc.TLS, interp uintptr, envPtr2 uintptr, bodyToken uintptr, finallyToken uintptr) (r int32) {
	var _objIndexCopy, _objIndexCopy1, delta1, jumpOK, jumpSplice, range1, v103, v109, v11, v121, v133, v145, v149, v161, v165, v169, v175, v18, v187, v20, v24, v28, v32, v44, v49, v53, v59, v63, v67, v71, v75, v81, v93, v97 int32
	var eclIndex TTcl_Size
	var mapPtr, v1, v10, v100, v101, v102, v104, v105, v106, v107, v108, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v122, v123, v124, v125, v126, v127, v128, v129, v130, v131, v132, v134, v135, v136, v137, v138, v139, v14, v140, v141, v142, v143, v144, v146, v147, v148, v15, v150, v151, v152, v153, v154, v155, v156, v157, v158, v159, v16, v160, v162, v163, v164, v166, v167, v168, v17, v170, v171, v172, v173, v174, v176, v177, v178, v179, v180, v181, v182, v183, v184, v185, v186, v188, v19, v2, v21, v22, v23, v25, v26, v27, v29, v3, v30, v31, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v45, v47, v48, v5, v50, v51, v52, v54, v55, v56, v57, v58, v6, v60, v61, v62, v64, v65, v66, v68, v69, v7, v70, v72, v73, v74, v76, v77, v78, v79, v8, v80, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v94, v95, v96, v98, v99 uintptr
	var v13, v46 int64
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, delta1, eclIndex, jumpOK, jumpSplice, mapPtr, range1, v1, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v123, v124, v125, v126, v127, v128, v129, v13, v130, v131, v132, v133, v134, v135, v136, v137, v138, v139, v14, v140, v141, v142, v143, v144, v145, v146, v147, v148, v149, v15, v150, v151, v152, v153, v154, v155, v156, v157, v158, v159, v16, v160, v161, v162, v163, v164, v165, v166, v167, v168, v169, v17, v170, v171, v172, v173, v174, v175, v176, v177, v178, v179, v18, v180, v181, v182, v183, v184, v185, v186, v187, v188, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	/*
	 * Note that this one is simple enough that we can issue it without
	 * needing a local variable table, making it a universal compilation.
	 */
	range1 = int32(XTclCreateExceptRange(tls, int32(CATCH_EXCEPTION_RANGE), envPtr2))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v2 = envPtr2 + 152
	v1 = *(*uintptr)(unsafe.Pointer(v2))
	*(*uintptr)(unsafe.Pointer(v2))++
	*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_BEGIN_CATCH4))
	v4 = envPtr2 + 152
	v3 = *(*uintptr)(unsafe.Pointer(v4))
	*(*uintptr)(unsafe.Pointer(v4))++
	*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(24))
	v6 = envPtr2 + 152
	v5 = *(*uintptr)(unsafe.Pointer(v6))
	*(*uintptr)(unsafe.Pointer(v6))++
	*(*uint8)(unsafe.Pointer(v5)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(16))
	v8 = envPtr2 + 152
	v7 = *(*uintptr)(unsafe.Pointer(v8))
	*(*uintptr)(unsafe.Pointer(v8))++
	*(*uint8)(unsafe.Pointer(v7)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(8))
	v10 = envPtr2 + 152
	v9 = *(*uintptr)(unsafe.Pointer(v10))
	*(*uintptr)(unsafe.Pointer(v10))++
	*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(range1))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_BEGIN_CATCH4)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - range1
		}
		v11 = delta1
		v12 = envPtr2
		if v11 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v12)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v12)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v12)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v12)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v12 + 64)) += int64(v11)
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth++
	if libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth)+uint64(1) > libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth)+uint64(1) {
		v13 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth
	} else {
		v13 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth = v13
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
	XTclCompileCmdWord(tls, interp, bodyToken+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(bodyToken)).FnumComponents), envPtr2)
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth--
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FnumCodeBytes = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(int32((*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v15 = envPtr2 + 152
	v14 = *(*uintptr)(unsafe.Pointer(v15))
	*(*uintptr)(unsafe.Pointer(v15))++
	*(*uint8)(unsafe.Pointer(v14)) = libc.Uint8FromInt32(int32(INST_JUMP1))
	v17 = envPtr2 + 152
	v16 = *(*uintptr)(unsafe.Pointer(v17))
	*(*uintptr)(unsafe.Pointer(v17))++
	*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_JUMP1)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32(3)
		}
		v18 = delta1
		v19 = envPtr2
		if v18 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v19 + 64)) += int64(v18)
	}
	v20 = -int32(1)
	v21 = envPtr2
	if v20 < libc.Int32FromInt32(0) {
		if int32((*TCompileEnv)(unsafe.Pointer(v21)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v21)).FcurrStackDepth) {
			(*TCompileEnv)(unsafe.Pointer(v21)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v21)).FcurrStackDepth
		}
	}
	*(*TTcl_Size)(unsafe.Pointer(v21 + 64)) += int64(v20)
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcatchOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v23 = envPtr2 + 152
	v22 = *(*uintptr)(unsafe.Pointer(v23))
	*(*uintptr)(unsafe.Pointer(v23))++
	*(*uint8)(unsafe.Pointer(v22)) = libc.Uint8FromInt32(int32(INST_PUSH_RESULT))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_PUSH_RESULT)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v24 = delta1
		v25 = envPtr2
		if v24 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v25 + 64)) += int64(v24)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v27 = envPtr2 + 152
	v26 = *(*uintptr)(unsafe.Pointer(v27))
	*(*uintptr)(unsafe.Pointer(v27))++
	*(*uint8)(unsafe.Pointer(v26)) = libc.Uint8FromInt32(int32(INST_PUSH_RETURN_OPTIONS))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_PUSH_RETURN_OPTIONS)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v28 = delta1
		v29 = envPtr2
		if v28 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v29)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v29)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v29)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v29)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v29 + 64)) += int64(v28)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v31 = envPtr2 + 152
	v30 = *(*uintptr)(unsafe.Pointer(v31))
	*(*uintptr)(unsafe.Pointer(v31))++
	*(*uint8)(unsafe.Pointer(v30)) = libc.Uint8FromInt32(int32(INST_END_CATCH))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_END_CATCH)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v32 = delta1
		v33 = envPtr2
		if v32 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v33)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v33)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v33)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v33)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v33 + 64)) += int64(v32)
	}
	range1 = int32(XTclCreateExceptRange(tls, int32(CATCH_EXCEPTION_RANGE), envPtr2))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v35 = envPtr2 + 152
	v34 = *(*uintptr)(unsafe.Pointer(v35))
	*(*uintptr)(unsafe.Pointer(v35))++
	*(*uint8)(unsafe.Pointer(v34)) = libc.Uint8FromInt32(int32(INST_BEGIN_CATCH4))
	v37 = envPtr2 + 152
	v36 = *(*uintptr)(unsafe.Pointer(v37))
	*(*uintptr)(unsafe.Pointer(v37))++
	*(*uint8)(unsafe.Pointer(v36)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(24))
	v39 = envPtr2 + 152
	v38 = *(*uintptr)(unsafe.Pointer(v39))
	*(*uintptr)(unsafe.Pointer(v39))++
	*(*uint8)(unsafe.Pointer(v38)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(16))
	v41 = envPtr2 + 152
	v40 = *(*uintptr)(unsafe.Pointer(v41))
	*(*uintptr)(unsafe.Pointer(v41))++
	*(*uint8)(unsafe.Pointer(v40)) = uint8(libc.Uint32FromInt32(range1) >> libc.Int32FromInt32(8))
	v43 = envPtr2 + 152
	v42 = *(*uintptr)(unsafe.Pointer(v43))
	*(*uintptr)(unsafe.Pointer(v43))++
	*(*uint8)(unsafe.Pointer(v42)) = uint8(libc.Uint32FromInt32(range1))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_BEGIN_CATCH4)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - range1
		}
		v44 = delta1
		v45 = envPtr2
		if v44 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v45)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v45)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v45)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v45)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v45 + 64)) += int64(v44)
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth++
	if libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth)+uint64(1) > libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth)+uint64(1) {
		v46 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth
	} else {
		v46 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth = v46
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 3*8))
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 3*8))
	XTclCompileCmdWord(tls, interp, finallyToken+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(finallyToken)).FnumComponents), envPtr2)
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth--
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FnumCodeBytes = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(int32((*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v48 = envPtr2 + 152
	v47 = *(*uintptr)(unsafe.Pointer(v48))
	*(*uintptr)(unsafe.Pointer(v48))++
	*(*uint8)(unsafe.Pointer(v47)) = libc.Uint8FromInt32(int32(INST_END_CATCH))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_END_CATCH)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v49 = delta1
		v50 = envPtr2
		if v49 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v50)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v50)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v50)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v50)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v50 + 64)) += int64(v49)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v52 = envPtr2 + 152
	v51 = *(*uintptr)(unsafe.Pointer(v52))
	*(*uintptr)(unsafe.Pointer(v52))++
	*(*uint8)(unsafe.Pointer(v51)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v53 = delta1
		v54 = envPtr2
		if v53 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v54)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v54)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v54)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v54)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v54 + 64)) += int64(v53)
	}
	jumpOK = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v56 = envPtr2 + 152
	v55 = *(*uintptr)(unsafe.Pointer(v56))
	*(*uintptr)(unsafe.Pointer(v56))++
	*(*uint8)(unsafe.Pointer(v55)) = libc.Uint8FromInt32(int32(INST_JUMP1))
	v58 = envPtr2 + 152
	v57 = *(*uintptr)(unsafe.Pointer(v58))
	*(*uintptr)(unsafe.Pointer(v58))++
	*(*uint8)(unsafe.Pointer(v57)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_JUMP1)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v59 = delta1
		v60 = envPtr2
		if v59 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v60)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v60)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v60)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v60)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v60 + 64)) += int64(v59)
	}
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcatchOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v62 = envPtr2 + 152
	v61 = *(*uintptr)(unsafe.Pointer(v62))
	*(*uintptr)(unsafe.Pointer(v62))++
	*(*uint8)(unsafe.Pointer(v61)) = libc.Uint8FromInt32(int32(INST_PUSH_RESULT))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_PUSH_RESULT)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v63 = delta1
		v64 = envPtr2
		if v63 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v64)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v64)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v64)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v64)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v64 + 64)) += int64(v63)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v66 = envPtr2 + 152
	v65 = *(*uintptr)(unsafe.Pointer(v66))
	*(*uintptr)(unsafe.Pointer(v66))++
	*(*uint8)(unsafe.Pointer(v65)) = libc.Uint8FromInt32(int32(INST_PUSH_RETURN_OPTIONS))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_PUSH_RETURN_OPTIONS)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v67 = delta1
		v68 = envPtr2
		if v67 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v68)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v68)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v68)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v68)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v68 + 64)) += int64(v67)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v70 = envPtr2 + 152
	v69 = *(*uintptr)(unsafe.Pointer(v70))
	*(*uintptr)(unsafe.Pointer(v70))++
	*(*uint8)(unsafe.Pointer(v69)) = libc.Uint8FromInt32(int32(INST_PUSH_RETURN_CODE))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_PUSH_RETURN_CODE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v71 = delta1
		v72 = envPtr2
		if v71 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v72)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v72)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v72)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v72)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v72 + 64)) += int64(v71)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v74 = envPtr2 + 152
	v73 = *(*uintptr)(unsafe.Pointer(v74))
	*(*uintptr)(unsafe.Pointer(v74))++
	*(*uint8)(unsafe.Pointer(v73)) = libc.Uint8FromInt32(int32(INST_END_CATCH))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_END_CATCH)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v75 = delta1
		v76 = envPtr2
		if v75 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v76)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v76)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v76)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v76)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v76 + 64)) += int64(v75)
	}
	_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+21397, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v78 = envPtr2 + 152
		v77 = *(*uintptr)(unsafe.Pointer(v78))
		*(*uintptr)(unsafe.Pointer(v78))++
		*(*uint8)(unsafe.Pointer(v77)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v80 = envPtr2 + 152
		v79 = *(*uintptr)(unsafe.Pointer(v80))
		*(*uintptr)(unsafe.Pointer(v80))++
		*(*uint8)(unsafe.Pointer(v79)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v81 = delta1
			v82 = envPtr2
			if v81 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v82)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v82)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v82)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v82)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v82 + 64)) += int64(v81)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v84 = envPtr2 + 152
		v83 = *(*uintptr)(unsafe.Pointer(v84))
		*(*uintptr)(unsafe.Pointer(v84))++
		*(*uint8)(unsafe.Pointer(v83)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v86 = envPtr2 + 152
		v85 = *(*uintptr)(unsafe.Pointer(v86))
		*(*uintptr)(unsafe.Pointer(v86))++
		*(*uint8)(unsafe.Pointer(v85)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
		v88 = envPtr2 + 152
		v87 = *(*uintptr)(unsafe.Pointer(v88))
		*(*uintptr)(unsafe.Pointer(v88))++
		*(*uint8)(unsafe.Pointer(v87)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
		v90 = envPtr2 + 152
		v89 = *(*uintptr)(unsafe.Pointer(v90))
		*(*uintptr)(unsafe.Pointer(v90))++
		*(*uint8)(unsafe.Pointer(v89)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
		v92 = envPtr2 + 152
		v91 = *(*uintptr)(unsafe.Pointer(v92))
		*(*uintptr)(unsafe.Pointer(v92))++
		*(*uint8)(unsafe.Pointer(v91)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v93 = delta1
			v94 = envPtr2
			if v93 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v94)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v94)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v94)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v94)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v94 + 64)) += int64(v93)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v96 = envPtr2 + 152
	v95 = *(*uintptr)(unsafe.Pointer(v96))
	*(*uintptr)(unsafe.Pointer(v96))++
	*(*uint8)(unsafe.Pointer(v95)) = libc.Uint8FromInt32(int32(INST_EQ))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_EQ)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v97 = delta1
		v98 = envPtr2
		if v97 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v98)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v98)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v98)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v98)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v98 + 64)) += int64(v97)
	}
	jumpSplice = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v100 = envPtr2 + 152
	v99 = *(*uintptr)(unsafe.Pointer(v100))
	*(*uintptr)(unsafe.Pointer(v100))++
	*(*uint8)(unsafe.Pointer(v99)) = libc.Uint8FromInt32(int32(INST_JUMP_FALSE1))
	v102 = envPtr2 + 152
	v101 = *(*uintptr)(unsafe.Pointer(v102))
	*(*uintptr)(unsafe.Pointer(v102))++
	*(*uint8)(unsafe.Pointer(v101)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_JUMP_FALSE1)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v103 = delta1
		v104 = envPtr2
		if v103 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v104)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v104)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v104)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v104)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v104 + 64)) += int64(v103)
	}
	_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+21234, libc.Int64FromUint64(libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy1 <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v106 = envPtr2 + 152
		v105 = *(*uintptr)(unsafe.Pointer(v106))
		*(*uintptr)(unsafe.Pointer(v106))++
		*(*uint8)(unsafe.Pointer(v105)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v108 = envPtr2 + 152
		v107 = *(*uintptr)(unsafe.Pointer(v108))
		*(*uintptr)(unsafe.Pointer(v108))++
		*(*uint8)(unsafe.Pointer(v107)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy1
			}
			v109 = delta1
			v110 = envPtr2
			if v109 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v110)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v110)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v110)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v110)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v110 + 64)) += int64(v109)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v112 = envPtr2 + 152
		v111 = *(*uintptr)(unsafe.Pointer(v112))
		*(*uintptr)(unsafe.Pointer(v112))++
		*(*uint8)(unsafe.Pointer(v111)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v114 = envPtr2 + 152
		v113 = *(*uintptr)(unsafe.Pointer(v114))
		*(*uintptr)(unsafe.Pointer(v114))++
		*(*uint8)(unsafe.Pointer(v113)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
		v116 = envPtr2 + 152
		v115 = *(*uintptr)(unsafe.Pointer(v116))
		*(*uintptr)(unsafe.Pointer(v116))++
		*(*uint8)(unsafe.Pointer(v115)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
		v118 = envPtr2 + 152
		v117 = *(*uintptr)(unsafe.Pointer(v118))
		*(*uintptr)(unsafe.Pointer(v118))++
		*(*uint8)(unsafe.Pointer(v117)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
		v120 = envPtr2 + 152
		v119 = *(*uintptr)(unsafe.Pointer(v120))
		*(*uintptr)(unsafe.Pointer(v120))++
		*(*uint8)(unsafe.Pointer(v119)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy1
			}
			v121 = delta1
			v122 = envPtr2
			if v121 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v122)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v122)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v122)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v122)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v122 + 64)) += int64(v121)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v124 = envPtr2 + 152
	v123 = *(*uintptr)(unsafe.Pointer(v124))
	*(*uintptr)(unsafe.Pointer(v124))++
	*(*uint8)(unsafe.Pointer(v123)) = libc.Uint8FromInt32(int32(INST_OVER))
	v126 = envPtr2 + 152
	v125 = *(*uintptr)(unsafe.Pointer(v126))
	*(*uintptr)(unsafe.Pointer(v126))++
	*(*uint8)(unsafe.Pointer(v125)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)) >> libc.Int32FromInt32(24))
	v128 = envPtr2 + 152
	v127 = *(*uintptr)(unsafe.Pointer(v128))
	*(*uintptr)(unsafe.Pointer(v128))++
	*(*uint8)(unsafe.Pointer(v127)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)) >> libc.Int32FromInt32(16))
	v130 = envPtr2 + 152
	v129 = *(*uintptr)(unsafe.Pointer(v130))
	*(*uintptr)(unsafe.Pointer(v130))++
	*(*uint8)(unsafe.Pointer(v129)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)) >> libc.Int32FromInt32(8))
	v132 = envPtr2 + 152
	v131 = *(*uintptr)(unsafe.Pointer(v132))
	*(*uintptr)(unsafe.Pointer(v132))++
	*(*uint8)(unsafe.Pointer(v131)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(3)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_OVER)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32(3)
		}
		v133 = delta1
		v134 = envPtr2
		if v133 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v134)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v134)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v134)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v134)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v134 + 64)) += int64(v133)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v136 = envPtr2 + 152
	v135 = *(*uintptr)(unsafe.Pointer(v136))
	*(*uintptr)(unsafe.Pointer(v136))++
	*(*uint8)(unsafe.Pointer(v135)) = libc.Uint8FromInt32(int32(INST_LIST))
	v138 = envPtr2 + 152
	v137 = *(*uintptr)(unsafe.Pointer(v138))
	*(*uintptr)(unsafe.Pointer(v138))++
	*(*uint8)(unsafe.Pointer(v137)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
	v140 = envPtr2 + 152
	v139 = *(*uintptr)(unsafe.Pointer(v140))
	*(*uintptr)(unsafe.Pointer(v140))++
	*(*uint8)(unsafe.Pointer(v139)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
	v142 = envPtr2 + 152
	v141 = *(*uintptr)(unsafe.Pointer(v142))
	*(*uintptr)(unsafe.Pointer(v142))++
	*(*uint8)(unsafe.Pointer(v141)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
	v144 = envPtr2 + 152
	v143 = *(*uintptr)(unsafe.Pointer(v144))
	*(*uintptr)(unsafe.Pointer(v144))++
	*(*uint8)(unsafe.Pointer(v143)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_LIST)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32(2)
		}
		v145 = delta1
		v146 = envPtr2
		if v145 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v146)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v146)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v146)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v146)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v146 + 64)) += int64(v145)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v148 = envPtr2 + 152
	v147 = *(*uintptr)(unsafe.Pointer(v148))
	*(*uintptr)(unsafe.Pointer(v148))++
	*(*uint8)(unsafe.Pointer(v147)) = libc.Uint8FromInt32(int32(INST_LIST_CONCAT))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_LIST_CONCAT)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v149 = delta1
		v150 = envPtr2
		if v149 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v150)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v150)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v150)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v150)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v150 + 64)) += int64(v149)
	}
	*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(jumpSplice) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(jumpSplice)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v152 = envPtr2 + 152
	v151 = *(*uintptr)(unsafe.Pointer(v152))
	*(*uintptr)(unsafe.Pointer(v152))++
	*(*uint8)(unsafe.Pointer(v151)) = libc.Uint8FromInt32(int32(INST_REVERSE))
	v154 = envPtr2 + 152
	v153 = *(*uintptr)(unsafe.Pointer(v154))
	*(*uintptr)(unsafe.Pointer(v154))++
	*(*uint8)(unsafe.Pointer(v153)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(4)) >> libc.Int32FromInt32(24))
	v156 = envPtr2 + 152
	v155 = *(*uintptr)(unsafe.Pointer(v156))
	*(*uintptr)(unsafe.Pointer(v156))++
	*(*uint8)(unsafe.Pointer(v155)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(4)) >> libc.Int32FromInt32(16))
	v158 = envPtr2 + 152
	v157 = *(*uintptr)(unsafe.Pointer(v158))
	*(*uintptr)(unsafe.Pointer(v158))++
	*(*uint8)(unsafe.Pointer(v157)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(4)) >> libc.Int32FromInt32(8))
	v160 = envPtr2 + 152
	v159 = *(*uintptr)(unsafe.Pointer(v160))
	*(*uintptr)(unsafe.Pointer(v160))++
	*(*uint8)(unsafe.Pointer(v159)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(4)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32(4)
		}
		v161 = delta1
		v162 = envPtr2
		if v161 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v162)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v162)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v162)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v162)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v162 + 64)) += int64(v161)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v164 = envPtr2 + 152
	v163 = *(*uintptr)(unsafe.Pointer(v164))
	*(*uintptr)(unsafe.Pointer(v164))++
	*(*uint8)(unsafe.Pointer(v163)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v165 = delta1
		v166 = envPtr2
		if v165 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v166)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v166)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v166)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v166)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v166 + 64)) += int64(v165)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v168 = envPtr2 + 152
	v167 = *(*uintptr)(unsafe.Pointer(v168))
	*(*uintptr)(unsafe.Pointer(v168))++
	*(*uint8)(unsafe.Pointer(v167)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v169 = delta1
		v170 = envPtr2
		if v169 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v170)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v170)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v170)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v170)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v170 + 64)) += int64(v169)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v172 = envPtr2 + 152
	v171 = *(*uintptr)(unsafe.Pointer(v172))
	*(*uintptr)(unsafe.Pointer(v172))++
	*(*uint8)(unsafe.Pointer(v171)) = libc.Uint8FromInt32(int32(INST_JUMP1))
	v174 = envPtr2 + 152
	v173 = *(*uintptr)(unsafe.Pointer(v174))
	*(*uintptr)(unsafe.Pointer(v174))++
	*(*uint8)(unsafe.Pointer(v173)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(7)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_JUMP1)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32(7)
		}
		v175 = delta1
		v176 = envPtr2
		if v175 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v176)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v176)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v176)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v176)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v176 + 64)) += int64(v175)
	}
	*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(jumpOK) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(jumpOK)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v178 = envPtr2 + 152
	v177 = *(*uintptr)(unsafe.Pointer(v178))
	*(*uintptr)(unsafe.Pointer(v178))++
	*(*uint8)(unsafe.Pointer(v177)) = libc.Uint8FromInt32(int32(INST_REVERSE))
	v180 = envPtr2 + 152
	v179 = *(*uintptr)(unsafe.Pointer(v180))
	*(*uintptr)(unsafe.Pointer(v180))++
	*(*uint8)(unsafe.Pointer(v179)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
	v182 = envPtr2 + 152
	v181 = *(*uintptr)(unsafe.Pointer(v182))
	*(*uintptr)(unsafe.Pointer(v182))++
	*(*uint8)(unsafe.Pointer(v181)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
	v184 = envPtr2 + 152
	v183 = *(*uintptr)(unsafe.Pointer(v184))
	*(*uintptr)(unsafe.Pointer(v184))++
	*(*uint8)(unsafe.Pointer(v183)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
	v186 = envPtr2 + 152
	v185 = *(*uintptr)(unsafe.Pointer(v186))
	*(*uintptr)(unsafe.Pointer(v186))++
	*(*uint8)(unsafe.Pointer(v185)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32(2)
		}
		v187 = delta1
		v188 = envPtr2
		if v187 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v188)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v188)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v188)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v188)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v188 + 64)) += int64(v187)
	}
	XTclEmitInvoke(tls, envPtr2, int32(INST_RETURN_STK), 0)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileUnsetCmd --
 *
 *	Procedure called to compile the "unset" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "unset" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileUnsetCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy3622 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Holds resulting instructions. */
	var _objIndexCopy, delta1, flags, haveFlags, i1, varCount, v16, v22, v36, v42, v56, v68 int32
	var bytes, cachePtr, cachePtr1, cachePtr2, leadingWord, mapPtr, varTokenPtr, v12, v13, v14, v15, v17, v18, v19, v20, v21, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v37, v38, v39, v4, v40, v41, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v69, v8 uintptr
	var eclIndex, v3, v7 TTcl_Size
	var v2, v5, v9 bool
	var _ /* isScalar at bp+0 */ int32
	var _ /* len at bp+8 */ TTcl_Size
	var _ /* localIndex at bp+4 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, bytes, cachePtr, cachePtr1, cachePtr2, delta1, eclIndex, flags, haveFlags, i1, leadingWord, mapPtr, varCount, varTokenPtr, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	flags = int32(1)
	varCount = 0
	haveFlags = 0
	/* TODO: Consider support for compiling expanded args. */
	/*
	 * Verify that all words - except the first non-option one - are known at
	 * compile time so that we can handle them without needing to do a nasty
	 * push/rotate. [Bug 3970f54c4e]
	 */
	i1 = int32(1)
	varTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
	for {
		if !(i1 < int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)) {
			break
		}
		if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			leadingWord = XTclThreadAllocObj(tls)
		} else {
			leadingWord = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(leadingWord + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(leadingWord)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(leadingWord)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(leadingWord)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(leadingWord)).FtypePtr = libc.UintptrFromInt32(0)
		varTokenPtr = varTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if !(XTclWordKnownAtCompileTime(tls, varTokenPtr, leadingWord) != 0) {
			v4 = leadingWord
			v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
			*(*TTcl_Size)(unsafe.Pointer(v4))--
			if !(v3 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(leadingWord)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(leadingWord)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(leadingWord)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(leadingWord)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(leadingWord)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(leadingWord)).Flength = int64(-libc.Int32FromInt32(1))
					if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
						cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v5 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, leadingWord)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(leadingWord + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = leadingWord
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, leadingWord)
				}
			}
			/*
			 * We can tolerate non-trivial substitutions in the first variable
			 * to be unset. If a '--' or '-nocomplain' was present, anything
			 * goes in that one place! (All subsequent variable names must be
			 * constants since we don't want to have to push them all first.)
			 */
			if varCount == 0 {
				if haveFlags != 0 {
					goto _1
				}
				/*
				 * In fact, we're OK as long as we're the first argument *and*
				 * we provably don't start with a '-'. If that is true, then
				 * even if everything else is varying, we still can't be a
				 * flag. Otherwise we'll spill to runtime to place a limit on
				 * the trickiness.
				 */
				if (*TTcl_Token)(unsafe.Pointer(varTokenPtr)).Ftype1 == int32(TCL_TOKEN_WORD) && (*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Ftype1 == int32(TCL_TOKEN_TEXT) && (*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Fsize > 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Fstart))) != int32('-') {
					goto _1
				}
			}
			return int32(TCL_ERROR)
		}
		if varCount == 0 {
			if (*TTcl_Obj)(unsafe.Pointer(leadingWord)).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(leadingWord)).Flength
				v6 = (*TTcl_Obj)(unsafe.Pointer(leadingWord)).Fbytes
			} else {
				v6 = XTcl_GetStringFromObj(tls, leadingWord, bp+8)
			}
			bytes = v6
			if i1 == int32(1) && *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(11) && !(libc.Xstrncmp(tls, __ccgo_ts+22371, bytes, uint64(11)) != 0) {
				flags = 0
				haveFlags++
			} else {
				if i1 == int32(2)-flags && *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(2) && !(libc.Xstrncmp(tls, __ccgo_ts+18684, bytes, uint64(2)) != 0) {
					haveFlags++
				} else {
					varCount++
				}
			}
		} else {
			varCount++
		}
		v8 = leadingWord
		v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
		*(*TTcl_Size)(unsafe.Pointer(v8))--
		if !(v7 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(leadingWord)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(leadingWord)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(leadingWord)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(leadingWord)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(leadingWord)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(leadingWord)).Flength = int64(-libc.Int32FromInt32(1))
				if v9 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v9 {
					cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v9 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, leadingWord)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(leadingWord + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = leadingWord
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, leadingWord)
			}
		}
		goto _1
	_1:
		;
		i1++
	}
	/*
	 * Issue instructions to unset each of the named variables.
	 */
	varTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	i1 = 0
	for {
		if !(i1 < haveFlags) {
			break
		}
		varTokenPtr = varTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		goto _10
	_10:
		;
		i1++
	}
	i1 = int32(1) + haveFlags
	for {
		if !(i1 < int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)) {
			break
		}
		/*
		 * Decide if we can use a frame slot for the var/array name or if we
		 * need to emit code to compute and push the name at runtime. We use a
		 * frame slot (entry in the array of local vars) if we are compiling a
		 * procedure body and if the name is simple text that does not include
		 * namespace qualifiers.
		 */
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
		XTclPushVarName(tls, interp, varTokenPtr, envPtr2, 0, bp+4, bp)
		/*
		 * Emit instructions to unset the variable.
		 */
		if *(*int32)(unsafe.Pointer(bp)) != 0 {
			if *(*int32)(unsafe.Pointer(bp + 4)) < 0 {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v13 = envPtr2 + 152
				v12 = *(*uintptr)(unsafe.Pointer(v13))
				*(*uintptr)(unsafe.Pointer(v13))++
				*(*uint8)(unsafe.Pointer(v12)) = libc.Uint8FromInt32(int32(INST_UNSET_STK))
				v15 = envPtr2 + 152
				v14 = *(*uintptr)(unsafe.Pointer(v15))
				*(*uintptr)(unsafe.Pointer(v15))++
				*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(flags))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_UNSET_STK)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - flags
					}
					v16 = delta1
					v17 = envPtr2
					if v16 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v17)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v17)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v17)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v17)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v17 + 64)) += int64(v16)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v19 = envPtr2 + 152
				v18 = *(*uintptr)(unsafe.Pointer(v19))
				*(*uintptr)(unsafe.Pointer(v19))++
				*(*uint8)(unsafe.Pointer(v18)) = libc.Uint8FromInt32(int32(INST_UNSET_SCALAR))
				v21 = envPtr2 + 152
				v20 = *(*uintptr)(unsafe.Pointer(v21))
				*(*uintptr)(unsafe.Pointer(v21))++
				*(*uint8)(unsafe.Pointer(v20)) = uint8(libc.Uint32FromInt32(flags))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_UNSET_SCALAR)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - flags
					}
					v22 = delta1
					v23 = envPtr2
					if v22 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v23)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v23)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v23)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v23)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v23 + 64)) += int64(v22)
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v25 = envPtr2 + 152
				v24 = *(*uintptr)(unsafe.Pointer(v25))
				*(*uintptr)(unsafe.Pointer(v25))++
				*(*uint8)(unsafe.Pointer(v24)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(24))
				v27 = envPtr2 + 152
				v26 = *(*uintptr)(unsafe.Pointer(v27))
				*(*uintptr)(unsafe.Pointer(v27))++
				*(*uint8)(unsafe.Pointer(v26)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(16))
				v29 = envPtr2 + 152
				v28 = *(*uintptr)(unsafe.Pointer(v29))
				*(*uintptr)(unsafe.Pointer(v29))++
				*(*uint8)(unsafe.Pointer(v28)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(8))
				v31 = envPtr2 + 152
				v30 = *(*uintptr)(unsafe.Pointer(v31))
				*(*uintptr)(unsafe.Pointer(v31))++
				*(*uint8)(unsafe.Pointer(v30)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 4)) < 0 {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v33 = envPtr2 + 152
				v32 = *(*uintptr)(unsafe.Pointer(v33))
				*(*uintptr)(unsafe.Pointer(v33))++
				*(*uint8)(unsafe.Pointer(v32)) = libc.Uint8FromInt32(int32(INST_UNSET_ARRAY_STK))
				v35 = envPtr2 + 152
				v34 = *(*uintptr)(unsafe.Pointer(v35))
				*(*uintptr)(unsafe.Pointer(v35))++
				*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt32(flags))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_UNSET_ARRAY_STK)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - flags
					}
					v36 = delta1
					v37 = envPtr2
					if v36 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v37 + 64)) += int64(v36)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v39 = envPtr2 + 152
				v38 = *(*uintptr)(unsafe.Pointer(v39))
				*(*uintptr)(unsafe.Pointer(v39))++
				*(*uint8)(unsafe.Pointer(v38)) = libc.Uint8FromInt32(int32(INST_UNSET_ARRAY))
				v41 = envPtr2 + 152
				v40 = *(*uintptr)(unsafe.Pointer(v41))
				*(*uintptr)(unsafe.Pointer(v41))++
				*(*uint8)(unsafe.Pointer(v40)) = uint8(libc.Uint32FromInt32(flags))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_UNSET_ARRAY)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - flags
					}
					v42 = delta1
					v43 = envPtr2
					if v42 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v43)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v43)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v43)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v43)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v43 + 64)) += int64(v42)
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v45 = envPtr2 + 152
				v44 = *(*uintptr)(unsafe.Pointer(v45))
				*(*uintptr)(unsafe.Pointer(v45))++
				*(*uint8)(unsafe.Pointer(v44)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(24))
				v47 = envPtr2 + 152
				v46 = *(*uintptr)(unsafe.Pointer(v47))
				*(*uintptr)(unsafe.Pointer(v47))++
				*(*uint8)(unsafe.Pointer(v46)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(16))
				v49 = envPtr2 + 152
				v48 = *(*uintptr)(unsafe.Pointer(v49))
				*(*uintptr)(unsafe.Pointer(v49))++
				*(*uint8)(unsafe.Pointer(v48)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))) >> libc.Int32FromInt32(8))
				v51 = envPtr2 + 152
				v50 = *(*uintptr)(unsafe.Pointer(v51))
				*(*uintptr)(unsafe.Pointer(v51))++
				*(*uint8)(unsafe.Pointer(v50)) = uint8(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
			}
		}
		varTokenPtr = varTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(varTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		goto _11
	_11:
		;
		i1++
	}
	_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v53 = envPtr2 + 152
		v52 = *(*uintptr)(unsafe.Pointer(v53))
		*(*uintptr)(unsafe.Pointer(v53))++
		*(*uint8)(unsafe.Pointer(v52)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v55 = envPtr2 + 152
		v54 = *(*uintptr)(unsafe.Pointer(v55))
		*(*uintptr)(unsafe.Pointer(v55))++
		*(*uint8)(unsafe.Pointer(v54)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v56 = delta1
			v57 = envPtr2
			if v56 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v57)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v57)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v57)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v57)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v57 + 64)) += int64(v56)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v59 = envPtr2 + 152
		v58 = *(*uintptr)(unsafe.Pointer(v59))
		*(*uintptr)(unsafe.Pointer(v59))++
		*(*uint8)(unsafe.Pointer(v58)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v61 = envPtr2 + 152
		v60 = *(*uintptr)(unsafe.Pointer(v61))
		*(*uintptr)(unsafe.Pointer(v61))++
		*(*uint8)(unsafe.Pointer(v60)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
		v63 = envPtr2 + 152
		v62 = *(*uintptr)(unsafe.Pointer(v63))
		*(*uintptr)(unsafe.Pointer(v63))++
		*(*uint8)(unsafe.Pointer(v62)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
		v65 = envPtr2 + 152
		v64 = *(*uintptr)(unsafe.Pointer(v65))
		*(*uintptr)(unsafe.Pointer(v65))++
		*(*uint8)(unsafe.Pointer(v64)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
		v67 = envPtr2 + 152
		v66 = *(*uintptr)(unsafe.Pointer(v67))
		*(*uintptr)(unsafe.Pointer(v67))++
		*(*uint8)(unsafe.Pointer(v66)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v68 = delta1
			v69 = envPtr2
			if v68 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v69)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v69)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v69)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v69)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v69 + 64)) += int64(v68)
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileWhileCmd --
 *
 *	Procedure called to compile the "while" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "while" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileWhileCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy3760 uintptr, envPtr2 uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Holds resulting instructions. */
	var _objIndexCopy, bodyCodeOffset, code, delta1, jumpDist, loopMayEnd, range1, testCodeOffset, v20, v26, v38, v44, v50, v62, v8 int32
	var bodyTokenPtr, boolObj, cachePtr, mapPtr, testTokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v21, v22, v23, v24, v25, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v39, v40, v41, v42, v43, v45, v46, v47, v48, v49, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v63, v7, v9 uintptr
	var eclIndex, v1, v5 TTcl_Size
	var v3 bool
	var v4 int64
	var _ /* boolVal at bp+16 */ int32
	var _ /* jumpEvalCondFixup at bp+0 */ TJumpFixup
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, bodyCodeOffset, bodyTokenPtr, boolObj, cachePtr, code, delta1, eclIndex, jumpDist, loopMayEnd, mapPtr, range1, testCodeOffset, testTokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	loopMayEnd = int32(1)
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(3) {
		return int32(TCL_ERROR)
	}
	/*
	 * If the test expression requires substitutions, don't compile the while
	 * command inline. E.g., the expression might cause the loop to never
	 * execute or execute forever, as in "while "$x < 5" {}".
	 *
	 * Bail out also if the body expression requires substitutions in order to
	 * insure correct behaviour [Bug 219166]
	 */
	testTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	bodyTokenPtr = testTokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(testTokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(testTokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) || (*TTcl_Token)(unsafe.Pointer(bodyTokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) {
		return int32(TCL_ERROR)
	}
	/*
	 * Find out if the condition is a constant.
	 */
	boolObj = XTcl_NewStringObj(tls, (*(*TTcl_Token)(unsafe.Pointer(testTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(testTokenPtr + 1*32))).Fsize)
	(*TTcl_Obj)(unsafe.Pointer(boolObj)).FrefCount++
	code = XTcl_GetBoolFromObj(tls, libc.UintptrFromInt32(0), boolObj, (libc.Int32FromInt32(TCL_NULL_OK)-libc.Int32FromInt32(2))&libc.Int32FromInt64(4), bp+16)
	v2 = boolObj
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if !(v1 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(boolObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(boolObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(boolObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(boolObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(boolObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(boolObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, boolObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(boolObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = boolObj
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, boolObj)
		}
	}
	if code == TCL_OK {
		if *(*int32)(unsafe.Pointer(bp + 16)) != 0 {
			/*
			 * It is an infinite loop; flag it so that we generate a more
			 * efficient body.
			 */
			loopMayEnd = 0
		} else {
			/*
			 * This is an empty loop: "while 0 {...}" or such. Compile no
			 * bytecodes.
			 */
			goto pushResult
		}
	}
	/*
	 * Create a ExceptionRange record for the loop body. This is used to
	 * implement break and continue.
	 */
	range1 = int32(XTclCreateExceptRange(tls, int32(LOOP_EXCEPTION_RANGE), envPtr2))
	/*
	 * Jump to the evaluation of the condition. This code uses the "loop
	 * rotation" optimisation (which eliminates one branch from the loop).
	 * "while cond body" produces then:
	 *       goto A
	 *    B: body                : bodyCodeOffset
	 *    A: cond -> result      : testCodeOffset, continueOffset
	 *       if (result) goto B
	 *
	 * The infinite loop "while 1 body" produces:
	 *    B: body                : all three offsets here
	 *       goto B
	 */
	if loopMayEnd != 0 {
		XTclEmitForwardJump(tls, envPtr2, int32(TCL_UNCONDITIONAL_JUMP), bp)
		testCodeOffset = 0 /* Avoid compiler warning. */
	} else {
		/*
		 * Make sure that the first command in the body is preceded by an
		 * INST_START_CMD, and hence counted properly. [Bug 1752146]
		 */
		*(*int32)(unsafe.Pointer(envPtr2 + 4520)) &= ^libc.Int32FromInt32(1)
		testCodeOffset = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
	}
	/*
	 * Compile the loop body.
	 */
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth++
	if libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth)+uint64(1) > libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth)+uint64(1) {
		v4 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth
	} else {
		v4 = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FmaxExceptDepth = v4
	v5 = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset = v5
	bodyCodeOffset = int32(v5)
	if !(loopMayEnd != 0) {
		(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcontinueOffset = int64(testCodeOffset)
		(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset = int64(bodyCodeOffset)
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
	XTclCompileCmdWord(tls, interp, bodyTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(bodyTokenPtr)).FnumComponents), envPtr2)
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptDepth--
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FnumCodeBytes = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(int32((*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v7 = envPtr2 + 152
	v6 = *(*uintptr)(unsafe.Pointer(v7))
	*(*uintptr)(unsafe.Pointer(v7))++
	*(*uint8)(unsafe.Pointer(v6)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v8 = delta1
		v9 = envPtr2
		if v8 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v9)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v9)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v9)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v9)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v9 + 64)) += int64(v8)
	}
	/*
	 * Compile the test expression then emit the conditional jump that
	 * terminates the while. We already know it's a simple word.
	 */
	if loopMayEnd != 0 {
		testCodeOffset = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
		jumpDist = libc.Int32FromUint32(libc.Uint32FromInt32(testCodeOffset) - (*(*TJumpFixup)(unsafe.Pointer(bp))).FcodeOffset)
		if XTclFixupForwardJump(tls, envPtr2, bp, jumpDist, int32(127)) != 0 {
			bodyCodeOffset += int32(3)
			testCodeOffset += int32(3)
		}
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileExprWords(tls, interp, testTokenPtr, uint64(1), envPtr2)
		jumpDist = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(bodyCodeOffset))
		if jumpDist > int32(127) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v11 = envPtr2 + 152
			v10 = *(*uintptr)(unsafe.Pointer(v11))
			*(*uintptr)(unsafe.Pointer(v11))++
			*(*uint8)(unsafe.Pointer(v10)) = libc.Uint8FromInt32(int32(INST_JUMP_TRUE4))
			v13 = envPtr2 + 152
			v12 = *(*uintptr)(unsafe.Pointer(v13))
			*(*uintptr)(unsafe.Pointer(v13))++
			*(*uint8)(unsafe.Pointer(v12)) = uint8(libc.Uint32FromInt32(-jumpDist) >> libc.Int32FromInt32(24))
			v15 = envPtr2 + 152
			v14 = *(*uintptr)(unsafe.Pointer(v15))
			*(*uintptr)(unsafe.Pointer(v15))++
			*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(-jumpDist) >> libc.Int32FromInt32(16))
			v17 = envPtr2 + 152
			v16 = *(*uintptr)(unsafe.Pointer(v17))
			*(*uintptr)(unsafe.Pointer(v17))++
			*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(-jumpDist) >> libc.Int32FromInt32(8))
			v19 = envPtr2 + 152
			v18 = *(*uintptr)(unsafe.Pointer(v19))
			*(*uintptr)(unsafe.Pointer(v19))++
			*(*uint8)(unsafe.Pointer(v18)) = uint8(libc.Uint32FromInt32(-jumpDist))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_JUMP_TRUE4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - -jumpDist
				}
				v20 = delta1
				v21 = envPtr2
				if v20 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v21)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v21)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v21)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v21)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v21 + 64)) += int64(v20)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v23 = envPtr2 + 152
			v22 = *(*uintptr)(unsafe.Pointer(v23))
			*(*uintptr)(unsafe.Pointer(v23))++
			*(*uint8)(unsafe.Pointer(v22)) = libc.Uint8FromInt32(int32(INST_JUMP_TRUE1))
			v25 = envPtr2 + 152
			v24 = *(*uintptr)(unsafe.Pointer(v25))
			*(*uintptr)(unsafe.Pointer(v25))++
			*(*uint8)(unsafe.Pointer(v24)) = uint8(libc.Uint32FromInt32(-jumpDist))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_JUMP_TRUE1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - -jumpDist
				}
				v26 = delta1
				v27 = envPtr2
				if v26 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v27)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v27)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v27)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v27)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v27 + 64)) += int64(v26)
			}
		}
	} else {
		jumpDist = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(bodyCodeOffset))
		if jumpDist > int32(127) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v29 = envPtr2 + 152
			v28 = *(*uintptr)(unsafe.Pointer(v29))
			*(*uintptr)(unsafe.Pointer(v29))++
			*(*uint8)(unsafe.Pointer(v28)) = libc.Uint8FromInt32(int32(INST_JUMP4))
			v31 = envPtr2 + 152
			v30 = *(*uintptr)(unsafe.Pointer(v31))
			*(*uintptr)(unsafe.Pointer(v31))++
			*(*uint8)(unsafe.Pointer(v30)) = uint8(libc.Uint32FromInt32(-jumpDist) >> libc.Int32FromInt32(24))
			v33 = envPtr2 + 152
			v32 = *(*uintptr)(unsafe.Pointer(v33))
			*(*uintptr)(unsafe.Pointer(v33))++
			*(*uint8)(unsafe.Pointer(v32)) = uint8(libc.Uint32FromInt32(-jumpDist) >> libc.Int32FromInt32(16))
			v35 = envPtr2 + 152
			v34 = *(*uintptr)(unsafe.Pointer(v35))
			*(*uintptr)(unsafe.Pointer(v35))++
			*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt32(-jumpDist) >> libc.Int32FromInt32(8))
			v37 = envPtr2 + 152
			v36 = *(*uintptr)(unsafe.Pointer(v37))
			*(*uintptr)(unsafe.Pointer(v37))++
			*(*uint8)(unsafe.Pointer(v36)) = uint8(libc.Uint32FromInt32(-jumpDist))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_JUMP4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - -jumpDist
				}
				v38 = delta1
				v39 = envPtr2
				if v38 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v39)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v39)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v39)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v39)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v39 + 64)) += int64(v38)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v41 = envPtr2 + 152
			v40 = *(*uintptr)(unsafe.Pointer(v41))
			*(*uintptr)(unsafe.Pointer(v41))++
			*(*uint8)(unsafe.Pointer(v40)) = libc.Uint8FromInt32(int32(INST_JUMP1))
			v43 = envPtr2 + 152
			v42 = *(*uintptr)(unsafe.Pointer(v43))
			*(*uintptr)(unsafe.Pointer(v43))++
			*(*uint8)(unsafe.Pointer(v42)) = uint8(libc.Uint32FromInt32(-jumpDist))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_JUMP1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - -jumpDist
				}
				v44 = delta1
				v45 = envPtr2
				if v44 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v45)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v45)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v45)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v45)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v45 + 64)) += int64(v44)
			}
		}
	}
	/*
	 * Set the loop's body, continue and break offsets.
	 */
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcontinueOffset = int64(testCodeOffset)
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FcodeOffset = int64(bodyCodeOffset)
	(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).FbreakOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)
	XTclFinalizeLoopExceptionRange(tls, envPtr2, range1)
	/*
	 * The while command's result is an empty string.
	 */
	goto pushResult
pushResult:
	;
	_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v47 = envPtr2 + 152
		v46 = *(*uintptr)(unsafe.Pointer(v47))
		*(*uintptr)(unsafe.Pointer(v47))++
		*(*uint8)(unsafe.Pointer(v46)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v49 = envPtr2 + 152
		v48 = *(*uintptr)(unsafe.Pointer(v49))
		*(*uintptr)(unsafe.Pointer(v49))++
		*(*uint8)(unsafe.Pointer(v48)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v50 = delta1
			v51 = envPtr2
			if v50 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v51)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v51)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v51)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v51)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v51 + 64)) += int64(v50)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v53 = envPtr2 + 152
		v52 = *(*uintptr)(unsafe.Pointer(v53))
		*(*uintptr)(unsafe.Pointer(v53))++
		*(*uint8)(unsafe.Pointer(v52)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v55 = envPtr2 + 152
		v54 = *(*uintptr)(unsafe.Pointer(v55))
		*(*uintptr)(unsafe.Pointer(v55))++
		*(*uint8)(unsafe.Pointer(v54)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
		v57 = envPtr2 + 152
		v56 = *(*uintptr)(unsafe.Pointer(v57))
		*(*uintptr)(unsafe.Pointer(v57))++
		*(*uint8)(unsafe.Pointer(v56)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
		v59 = envPtr2 + 152
		v58 = *(*uintptr)(unsafe.Pointer(v59))
		*(*uintptr)(unsafe.Pointer(v59))++
		*(*uint8)(unsafe.Pointer(v58)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
		v61 = envPtr2 + 152
		v60 = *(*uintptr)(unsafe.Pointer(v61))
		*(*uintptr)(unsafe.Pointer(v61))++
		*(*uint8)(unsafe.Pointer(v60)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v62 = delta1
			v63 = envPtr2
			if v62 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v63)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v63)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v63)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v63)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v63 + 64)) += int64(v62)
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileYieldCmd --
 *
 *	Procedure called to compile the "yield" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "yield" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileYieldCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy3937 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, delta1, v17, v23, v35, v39, v5 int32
	var eclIndex TTcl_Size
	var mapPtr, valueTokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v36, v37, v38, v4, v40, v6, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, delta1, eclIndex, mapPtr, valueTokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v5, v6, v7, v8, v9
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords < int64(1) || (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords > int64(2) {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(1) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
		eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1) /* TIP #280 */
		valueTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if (*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(valueTokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(valueTokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy1 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v20 = envPtr2 + 152
				v19 = *(*uintptr)(unsafe.Pointer(v20))
				*(*uintptr)(unsafe.Pointer(v20))++
				*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v22 = envPtr2 + 152
				v21 = *(*uintptr)(unsafe.Pointer(v22))
				*(*uintptr)(unsafe.Pointer(v22))++
				*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v23 = delta1
					v24 = envPtr2
					if v23 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v24 + 64)) += int64(v23)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v26 = envPtr2 + 152
				v25 = *(*uintptr)(unsafe.Pointer(v26))
				*(*uintptr)(unsafe.Pointer(v26))++
				*(*uint8)(unsafe.Pointer(v25)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v28 = envPtr2 + 152
				v27 = *(*uintptr)(unsafe.Pointer(v28))
				*(*uintptr)(unsafe.Pointer(v28))++
				*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
				v30 = envPtr2 + 152
				v29 = *(*uintptr)(unsafe.Pointer(v30))
				*(*uintptr)(unsafe.Pointer(v30))++
				*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
				v32 = envPtr2 + 152
				v31 = *(*uintptr)(unsafe.Pointer(v32))
				*(*uintptr)(unsafe.Pointer(v32))++
				*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
				v34 = envPtr2 + 152
				v33 = *(*uintptr)(unsafe.Pointer(v34))
				*(*uintptr)(unsafe.Pointer(v34))++
				*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v35 = delta1
					v36 = envPtr2
					if v35 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v36 + 64)) += int64(v35)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
			XTclCompileTokens(tls, interp, valueTokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(valueTokenPtr)).FnumComponents), envPtr2)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v38 = envPtr2 + 152
	v37 = *(*uintptr)(unsafe.Pointer(v38))
	*(*uintptr)(unsafe.Pointer(v38))++
	*(*uint8)(unsafe.Pointer(v37)) = libc.Uint8FromInt32(int32(INST_YIELD))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_YIELD)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v39 = delta1
		v40 = envPtr2
		if v39 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v40)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v40)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v40 + 64)) += int64(v39)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileYieldToCmd --
 *
 *	Procedure called to compile the "yieldto" command.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the "yieldto" command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileYieldToCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy3979 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, delta1, i1, v10, v22, v3, v34, v38 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v35, v36, v37, v39, v4, v6, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, eclIndex, i1, mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1) /* TIP #280 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) < int32(2) {
		return int32(TCL_ERROR)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v2 = envPtr2 + 152
	v1 = *(*uintptr)(unsafe.Pointer(v2))
	*(*uintptr)(unsafe.Pointer(v2))++
	*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_NS_CURRENT))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_NS_CURRENT)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v3 = delta1
		v4 = envPtr2
		if v3 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v4)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v4)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v4)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v4)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v4 + 64)) += int64(v3)
	}
	i1 = int32(1)
	for {
		if !(i1 < int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)) {
			break
		}
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v7 = envPtr2 + 152
				v6 = *(*uintptr)(unsafe.Pointer(v7))
				*(*uintptr)(unsafe.Pointer(v7))++
				*(*uint8)(unsafe.Pointer(v6)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v9 = envPtr2 + 152
				v8 = *(*uintptr)(unsafe.Pointer(v9))
				*(*uintptr)(unsafe.Pointer(v9))++
				*(*uint8)(unsafe.Pointer(v8)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v10 = delta1
					v11 = envPtr2
					if v10 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v11)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v11)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v11)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v11)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v11 + 64)) += int64(v10)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v13 = envPtr2 + 152
				v12 = *(*uintptr)(unsafe.Pointer(v13))
				*(*uintptr)(unsafe.Pointer(v13))++
				*(*uint8)(unsafe.Pointer(v12)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v15 = envPtr2 + 152
				v14 = *(*uintptr)(unsafe.Pointer(v15))
				*(*uintptr)(unsafe.Pointer(v15))++
				*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
				v17 = envPtr2 + 152
				v16 = *(*uintptr)(unsafe.Pointer(v17))
				*(*uintptr)(unsafe.Pointer(v17))++
				*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
				v19 = envPtr2 + 152
				v18 = *(*uintptr)(unsafe.Pointer(v19))
				*(*uintptr)(unsafe.Pointer(v19))++
				*(*uint8)(unsafe.Pointer(v18)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
				v21 = envPtr2 + 152
				v20 = *(*uintptr)(unsafe.Pointer(v21))
				*(*uintptr)(unsafe.Pointer(v21))++
				*(*uint8)(unsafe.Pointer(v20)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v22 = delta1
					v23 = envPtr2
					if v22 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v23)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v23)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v23)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v23)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v23 + 64)) += int64(v22)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		goto _5
	_5:
		;
		i1++
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v25 = envPtr2 + 152
	v24 = *(*uintptr)(unsafe.Pointer(v25))
	*(*uintptr)(unsafe.Pointer(v25))++
	*(*uint8)(unsafe.Pointer(v24)) = libc.Uint8FromInt32(int32(INST_LIST))
	v27 = envPtr2 + 152
	v26 = *(*uintptr)(unsafe.Pointer(v27))
	*(*uintptr)(unsafe.Pointer(v27))++
	*(*uint8)(unsafe.Pointer(v26)) = uint8(libc.Uint32FromInt32(i1) >> libc.Int32FromInt32(24))
	v29 = envPtr2 + 152
	v28 = *(*uintptr)(unsafe.Pointer(v29))
	*(*uintptr)(unsafe.Pointer(v29))++
	*(*uint8)(unsafe.Pointer(v28)) = uint8(libc.Uint32FromInt32(i1) >> libc.Int32FromInt32(16))
	v31 = envPtr2 + 152
	v30 = *(*uintptr)(unsafe.Pointer(v31))
	*(*uintptr)(unsafe.Pointer(v31))++
	*(*uint8)(unsafe.Pointer(v30)) = uint8(libc.Uint32FromInt32(i1) >> libc.Int32FromInt32(8))
	v33 = envPtr2 + 152
	v32 = *(*uintptr)(unsafe.Pointer(v33))
	*(*uintptr)(unsafe.Pointer(v33))++
	*(*uint8)(unsafe.Pointer(v32)) = uint8(libc.Uint32FromInt32(i1))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_LIST)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - i1
		}
		v34 = delta1
		v35 = envPtr2
		if v34 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v35)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v35)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v35)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v35)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v35 + 64)) += int64(v34)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v37 = envPtr2 + 152
	v36 = *(*uintptr)(unsafe.Pointer(v37))
	*(*uintptr)(unsafe.Pointer(v37))++
	*(*uint8)(unsafe.Pointer(v36)) = libc.Uint8FromInt32(int32(INST_YIELD_TO_INVOKE))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_YIELD_TO_INVOKE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v38 = delta1
		v39 = envPtr2
		if v38 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v39)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v39)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v39)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v39)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v39 + 64)) += int64(v38)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * CompileUnaryOpCmd --
 *
 *	Utility routine to compile the unary operator commands.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the compiled command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func _CompileUnaryOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, instruction int32, envPtr2 uintptr) (r int32) {
	var _objIndexCopy, delta1, v17, v21, v22, v5 int32
	var eclIndex TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v23, v3, v4, v6, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, eclIndex, mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v3, v4, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
		return int32(TCL_ERROR)
	}
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v20 = envPtr2 + 152
	v19 = *(*uintptr)(unsafe.Pointer(v20))
	*(*uintptr)(unsafe.Pointer(v20))++
	*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(instruction)
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		if instruction == int32(INST_START_CMD) {
			v21 = int32(1)
		} else {
			v21 = 0
		}
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = v21
	}
	delta1 = XtclInstructionTable[libc.Uint8FromInt32(instruction)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v22 = delta1
		v23 = envPtr2
		if v22 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v23)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v23)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v23)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v23)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v23 + 64)) += int64(v22)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * CompileAssociativeBinaryOpCmd --
 *
 *	Utility routine to compile the binary operator commands that accept an
 *	arbitrary number of arguments, and that are associative operations.
 *	Because of the associativity, we may combine operations from right to
 *	left, saving us any effort of re-ordering the arguments on the stack
 *	after substitutions are completed.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the compiled command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func _CompileAssociativeBinaryOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, identity uintptr, instruction int32, envPtr2 uintptr) (r int32) {
	var _objIndexCopy, _objIndexCopy1, delta1, v18, v24, v36, v48, v53, v54, v6 int32
	var eclIndex, words, v50 TTcl_Size
	var mapPtr, tokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v19, v2, v20, v21, v22, v23, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v49, v5, v51, v52, v55, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, delta1, eclIndex, mapPtr, tokenPtr, words, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1) /* TIP #280 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
	/* TODO: Consider support for compiling expanded args. */
	words = int64(1)
	for {
		if !(words < (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) {
			break
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v3 = envPtr2 + 152
				v2 = *(*uintptr)(unsafe.Pointer(v3))
				*(*uintptr)(unsafe.Pointer(v3))++
				*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v5 = envPtr2 + 152
				v4 = *(*uintptr)(unsafe.Pointer(v5))
				*(*uintptr)(unsafe.Pointer(v5))++
				*(*uint8)(unsafe.Pointer(v4)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v6 = delta1
					v7 = envPtr2
					if v6 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v7 + 64)) += int64(v6)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v9 = envPtr2 + 152
				v8 = *(*uintptr)(unsafe.Pointer(v9))
				*(*uintptr)(unsafe.Pointer(v9))++
				*(*uint8)(unsafe.Pointer(v8)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v11 = envPtr2 + 152
				v10 = *(*uintptr)(unsafe.Pointer(v11))
				*(*uintptr)(unsafe.Pointer(v11))++
				*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
				v13 = envPtr2 + 152
				v12 = *(*uintptr)(unsafe.Pointer(v13))
				*(*uintptr)(unsafe.Pointer(v13))++
				*(*uint8)(unsafe.Pointer(v12)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
				v15 = envPtr2 + 152
				v14 = *(*uintptr)(unsafe.Pointer(v15))
				*(*uintptr)(unsafe.Pointer(v15))++
				*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
				v17 = envPtr2 + 152
				v16 = *(*uintptr)(unsafe.Pointer(v17))
				*(*uintptr)(unsafe.Pointer(v17))++
				*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v18 = delta1
					v19 = envPtr2
					if v18 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v19 + 64)) += int64(v18)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(words)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(words)*8))
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
		}
		goto _1
	_1:
		;
		words++
	}
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords <= int64(2) {
		_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, identity, int64(-libc.Int32FromInt32(1)), 0)
		if _objIndexCopy1 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v21 = envPtr2 + 152
			v20 = *(*uintptr)(unsafe.Pointer(v21))
			*(*uintptr)(unsafe.Pointer(v21))++
			*(*uint8)(unsafe.Pointer(v20)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v23 = envPtr2 + 152
			v22 = *(*uintptr)(unsafe.Pointer(v23))
			*(*uintptr)(unsafe.Pointer(v23))++
			*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v24 = delta1
				v25 = envPtr2
				if v24 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v25 + 64)) += int64(v24)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v27 = envPtr2 + 152
			v26 = *(*uintptr)(unsafe.Pointer(v27))
			*(*uintptr)(unsafe.Pointer(v27))++
			*(*uint8)(unsafe.Pointer(v26)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v29 = envPtr2 + 152
			v28 = *(*uintptr)(unsafe.Pointer(v29))
			*(*uintptr)(unsafe.Pointer(v29))++
			*(*uint8)(unsafe.Pointer(v28)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
			v31 = envPtr2 + 152
			v30 = *(*uintptr)(unsafe.Pointer(v31))
			*(*uintptr)(unsafe.Pointer(v31))++
			*(*uint8)(unsafe.Pointer(v30)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
			v33 = envPtr2 + 152
			v32 = *(*uintptr)(unsafe.Pointer(v33))
			*(*uintptr)(unsafe.Pointer(v33))++
			*(*uint8)(unsafe.Pointer(v32)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
			v35 = envPtr2 + 152
			v34 = *(*uintptr)(unsafe.Pointer(v35))
			*(*uintptr)(unsafe.Pointer(v35))++
			*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v36 = delta1
				v37 = envPtr2
				if v36 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v37 + 64)) += int64(v36)
			}
		}
		words++
	}
	if words > int64(3) {
		/*
		 * Reverse order of arguments to get precise agreement with [expr] in
		 * calculations, including roundoff errors.
		 */
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v39 = envPtr2 + 152
		v38 = *(*uintptr)(unsafe.Pointer(v39))
		*(*uintptr)(unsafe.Pointer(v39))++
		*(*uint8)(unsafe.Pointer(v38)) = libc.Uint8FromInt32(int32(INST_REVERSE))
		v41 = envPtr2 + 152
		v40 = *(*uintptr)(unsafe.Pointer(v41))
		*(*uintptr)(unsafe.Pointer(v41))++
		*(*uint8)(unsafe.Pointer(v40)) = uint8(libc.Uint32FromInt64(words-libc.Int64FromInt32(1)) >> libc.Int32FromInt32(24))
		v43 = envPtr2 + 152
		v42 = *(*uintptr)(unsafe.Pointer(v43))
		*(*uintptr)(unsafe.Pointer(v43))++
		*(*uint8)(unsafe.Pointer(v42)) = uint8(libc.Uint32FromInt64(words-libc.Int64FromInt32(1)) >> libc.Int32FromInt32(16))
		v45 = envPtr2 + 152
		v44 = *(*uintptr)(unsafe.Pointer(v45))
		*(*uintptr)(unsafe.Pointer(v45))++
		*(*uint8)(unsafe.Pointer(v44)) = uint8(libc.Uint32FromInt64(words-libc.Int64FromInt32(1)) >> libc.Int32FromInt32(8))
		v47 = envPtr2 + 152
		v46 = *(*uintptr)(unsafe.Pointer(v47))
		*(*uintptr)(unsafe.Pointer(v47))++
		*(*uint8)(unsafe.Pointer(v46)) = uint8(libc.Uint32FromInt64(words - libc.Int64FromInt32(1)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(words-libc.Int64FromInt32(1))
			}
			v48 = delta1
			v49 = envPtr2
			if v48 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v49)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v49)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v49)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v49)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v49 + 64)) += int64(v48)
		}
	}
	for {
		words--
		v50 = words
		if !(v50 > int64(1)) {
			break
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v52 = envPtr2 + 152
		v51 = *(*uintptr)(unsafe.Pointer(v52))
		*(*uintptr)(unsafe.Pointer(v52))++
		*(*uint8)(unsafe.Pointer(v51)) = libc.Uint8FromInt32(instruction)
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			if instruction == int32(INST_START_CMD) {
				v53 = int32(1)
			} else {
				v53 = 0
			}
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = v53
		}
		delta1 = XtclInstructionTable[libc.Uint8FromInt32(instruction)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v54 = delta1
			v55 = envPtr2
			if v54 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v55)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v55)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v55)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v55)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v55 + 64)) += int64(v54)
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * CompileStrictlyBinaryOpCmd --
 *
 *	Utility routine to compile the binary operator commands, that strictly
 *	accept exactly two arguments.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the compiled command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func _CompileStrictlyBinaryOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, instruction int32, envPtr uintptr) (r int32) {
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(3) {
		return int32(TCL_ERROR)
	}
	return _CompileAssociativeBinaryOpCmd(tls, interp, parsePtr, libc.UintptrFromInt32(0), instruction, envPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * CompileComparisonOpCmd --
 *
 *	Utility routine to compile the n-ary comparison operator commands.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the compiled command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func _CompileComparisonOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, instruction int32, envPtr2 uintptr) (r int32) {
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, _objIndexCopy4, _objIndexCopy5, delta1, tmpIndex, v100, v112, v116, v117, v124, v136, v142, v154, v161, v17, v173, v177, v178, v183, v189, v23, v35, v41, v5, v53, v57, v58, v64, v76, v82, v94 int32
	var eclIndex, words, v156 TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v113, v114, v115, v118, v12, v120, v121, v122, v123, v125, v126, v127, v128, v129, v13, v130, v131, v132, v133, v134, v135, v137, v138, v139, v14, v140, v141, v143, v144, v145, v146, v147, v148, v149, v15, v150, v151, v152, v153, v155, v157, v158, v159, v16, v160, v162, v163, v164, v165, v166, v167, v168, v169, v170, v171, v172, v174, v175, v176, v179, v18, v181, v182, v184, v185, v186, v187, v188, v19, v190, v191, v192, v193, v194, v195, v196, v197, v198, v2, v20, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v36, v37, v38, v39, v4, v40, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v54, v55, v56, v59, v6, v60, v61, v62, v63, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v77, v78, v79, v8, v80, v81, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v95, v96, v97, v98, v99 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, _objIndexCopy4, _objIndexCopy5, delta1, eclIndex, mapPtr, tmpIndex, tokenPtr, words, v1, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v12, v120, v121, v122, v123, v124, v125, v126, v127, v128, v129, v13, v130, v131, v132, v133, v134, v135, v136, v137, v138, v139, v14, v140, v141, v142, v143, v144, v145, v146, v147, v148, v149, v15, v150, v151, v152, v153, v154, v155, v156, v157, v158, v159, v16, v160, v161, v162, v163, v164, v165, v166, v167, v168, v169, v17, v170, v171, v172, v173, v174, v175, v176, v177, v178, v179, v18, v181, v182, v183, v184, v185, v186, v187, v188, v189, v19, v190, v191, v192, v193, v194, v195, v196, v197, v198, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	/* TODO: Consider support for compiling expanded args. */
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) < int32(3) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+21397, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(3) {
			tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
			if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
				_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
				if _objIndexCopy1 <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v20 = envPtr2 + 152
					v19 = *(*uintptr)(unsafe.Pointer(v20))
					*(*uintptr)(unsafe.Pointer(v20))++
					*(*uint8)(unsafe.Pointer(v19)) = libc.Uint8FromInt32(int32(INST_PUSH1))
					v22 = envPtr2 + 152
					v21 = *(*uintptr)(unsafe.Pointer(v22))
					*(*uintptr)(unsafe.Pointer(v22))++
					*(*uint8)(unsafe.Pointer(v21)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy1
						}
						v23 = delta1
						v24 = envPtr2
						if v23 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v24)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v24)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v24 + 64)) += int64(v23)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v26 = envPtr2 + 152
					v25 = *(*uintptr)(unsafe.Pointer(v26))
					*(*uintptr)(unsafe.Pointer(v26))++
					*(*uint8)(unsafe.Pointer(v25)) = libc.Uint8FromInt32(int32(INST_PUSH4))
					v28 = envPtr2 + 152
					v27 = *(*uintptr)(unsafe.Pointer(v28))
					*(*uintptr)(unsafe.Pointer(v28))++
					*(*uint8)(unsafe.Pointer(v27)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
					v30 = envPtr2 + 152
					v29 = *(*uintptr)(unsafe.Pointer(v30))
					*(*uintptr)(unsafe.Pointer(v30))++
					*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
					v32 = envPtr2 + 152
					v31 = *(*uintptr)(unsafe.Pointer(v32))
					*(*uintptr)(unsafe.Pointer(v32))++
					*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
					v34 = envPtr2 + 152
					v33 = *(*uintptr)(unsafe.Pointer(v34))
					*(*uintptr)(unsafe.Pointer(v34))++
					*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy1
						}
						v35 = delta1
						v36 = envPtr2
						if v35 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v36 + 64)) += int64(v35)
					}
				}
			} else {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
				XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
			}
			tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
			if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
				_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
				if _objIndexCopy2 <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v38 = envPtr2 + 152
					v37 = *(*uintptr)(unsafe.Pointer(v38))
					*(*uintptr)(unsafe.Pointer(v38))++
					*(*uint8)(unsafe.Pointer(v37)) = libc.Uint8FromInt32(int32(INST_PUSH1))
					v40 = envPtr2 + 152
					v39 = *(*uintptr)(unsafe.Pointer(v40))
					*(*uintptr)(unsafe.Pointer(v40))++
					*(*uint8)(unsafe.Pointer(v39)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy2
						}
						v41 = delta1
						v42 = envPtr2
						if v41 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v42)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v42)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v42)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v42)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v42 + 64)) += int64(v41)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v44 = envPtr2 + 152
					v43 = *(*uintptr)(unsafe.Pointer(v44))
					*(*uintptr)(unsafe.Pointer(v44))++
					*(*uint8)(unsafe.Pointer(v43)) = libc.Uint8FromInt32(int32(INST_PUSH4))
					v46 = envPtr2 + 152
					v45 = *(*uintptr)(unsafe.Pointer(v46))
					*(*uintptr)(unsafe.Pointer(v46))++
					*(*uint8)(unsafe.Pointer(v45)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
					v48 = envPtr2 + 152
					v47 = *(*uintptr)(unsafe.Pointer(v48))
					*(*uintptr)(unsafe.Pointer(v48))++
					*(*uint8)(unsafe.Pointer(v47)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
					v50 = envPtr2 + 152
					v49 = *(*uintptr)(unsafe.Pointer(v50))
					*(*uintptr)(unsafe.Pointer(v50))++
					*(*uint8)(unsafe.Pointer(v49)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
					v52 = envPtr2 + 152
					v51 = *(*uintptr)(unsafe.Pointer(v52))
					*(*uintptr)(unsafe.Pointer(v52))++
					*(*uint8)(unsafe.Pointer(v51)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy2
						}
						v53 = delta1
						v54 = envPtr2
						if v53 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v54)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v54)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v54)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v54)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v54 + 64)) += int64(v53)
					}
				}
			} else {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
				XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v56 = envPtr2 + 152
			v55 = *(*uintptr)(unsafe.Pointer(v56))
			*(*uintptr)(unsafe.Pointer(v56))++
			*(*uint8)(unsafe.Pointer(v55)) = libc.Uint8FromInt32(instruction)
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				if instruction == int32(INST_START_CMD) {
					v57 = int32(1)
				} else {
					v57 = 0
				}
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = v57
			}
			delta1 = XtclInstructionTable[libc.Uint8FromInt32(instruction)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v58 = delta1
				v59 = envPtr2
				if v58 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v59)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v59)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v59)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v59)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v59 + 64)) += int64(v58)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FprocPtr == libc.UintptrFromInt32(0) {
				/*
				 * No local variable space!
				 */
				return int32(TCL_ERROR)
			} else {
				tmpIndex = int32(XTclFindCompiledLocal(tls, libc.UintptrFromInt32(0), 0, int32(1), envPtr2))
				tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
				if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
					_objIndexCopy3 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
					if _objIndexCopy3 <= int32(255) {
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
							XTclExpandCodeArray(tls, envPtr2)
						}
						v61 = envPtr2 + 152
						v60 = *(*uintptr)(unsafe.Pointer(v61))
						*(*uintptr)(unsafe.Pointer(v61))++
						*(*uint8)(unsafe.Pointer(v60)) = libc.Uint8FromInt32(int32(INST_PUSH1))
						v63 = envPtr2 + 152
						v62 = *(*uintptr)(unsafe.Pointer(v63))
						*(*uintptr)(unsafe.Pointer(v63))++
						*(*uint8)(unsafe.Pointer(v62)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
							(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
						}
						delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
						if delta1 != 0 {
							if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
								delta1 = int32(1) - _objIndexCopy3
							}
							v64 = delta1
							v65 = envPtr2
							if v64 < libc.Int32FromInt32(0) {
								if int32((*TCompileEnv)(unsafe.Pointer(v65)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v65)).FcurrStackDepth) {
									(*TCompileEnv)(unsafe.Pointer(v65)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v65)).FcurrStackDepth
								}
							}
							*(*TTcl_Size)(unsafe.Pointer(v65 + 64)) += int64(v64)
						}
					} else {
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
							XTclExpandCodeArray(tls, envPtr2)
						}
						v67 = envPtr2 + 152
						v66 = *(*uintptr)(unsafe.Pointer(v67))
						*(*uintptr)(unsafe.Pointer(v67))++
						*(*uint8)(unsafe.Pointer(v66)) = libc.Uint8FromInt32(int32(INST_PUSH4))
						v69 = envPtr2 + 152
						v68 = *(*uintptr)(unsafe.Pointer(v69))
						*(*uintptr)(unsafe.Pointer(v69))++
						*(*uint8)(unsafe.Pointer(v68)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(24))
						v71 = envPtr2 + 152
						v70 = *(*uintptr)(unsafe.Pointer(v71))
						*(*uintptr)(unsafe.Pointer(v71))++
						*(*uint8)(unsafe.Pointer(v70)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(16))
						v73 = envPtr2 + 152
						v72 = *(*uintptr)(unsafe.Pointer(v73))
						*(*uintptr)(unsafe.Pointer(v73))++
						*(*uint8)(unsafe.Pointer(v72)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(8))
						v75 = envPtr2 + 152
						v74 = *(*uintptr)(unsafe.Pointer(v75))
						*(*uintptr)(unsafe.Pointer(v75))++
						*(*uint8)(unsafe.Pointer(v74)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
							(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
						}
						delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
						if delta1 != 0 {
							if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
								delta1 = int32(1) - _objIndexCopy3
							}
							v76 = delta1
							v77 = envPtr2
							if v76 < libc.Int32FromInt32(0) {
								if int32((*TCompileEnv)(unsafe.Pointer(v77)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v77)).FcurrStackDepth) {
									(*TCompileEnv)(unsafe.Pointer(v77)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v77)).FcurrStackDepth
								}
							}
							*(*TTcl_Size)(unsafe.Pointer(v77 + 64)) += int64(v76)
						}
					}
				} else {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 1*8))
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 1*8))
					XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
				}
				tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
				if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
					_objIndexCopy4 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
					if _objIndexCopy4 <= int32(255) {
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
							XTclExpandCodeArray(tls, envPtr2)
						}
						v79 = envPtr2 + 152
						v78 = *(*uintptr)(unsafe.Pointer(v79))
						*(*uintptr)(unsafe.Pointer(v79))++
						*(*uint8)(unsafe.Pointer(v78)) = libc.Uint8FromInt32(int32(INST_PUSH1))
						v81 = envPtr2 + 152
						v80 = *(*uintptr)(unsafe.Pointer(v81))
						*(*uintptr)(unsafe.Pointer(v81))++
						*(*uint8)(unsafe.Pointer(v80)) = uint8(libc.Uint32FromInt32(_objIndexCopy4))
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
							(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
						}
						delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
						if delta1 != 0 {
							if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
								delta1 = int32(1) - _objIndexCopy4
							}
							v82 = delta1
							v83 = envPtr2
							if v82 < libc.Int32FromInt32(0) {
								if int32((*TCompileEnv)(unsafe.Pointer(v83)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v83)).FcurrStackDepth) {
									(*TCompileEnv)(unsafe.Pointer(v83)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v83)).FcurrStackDepth
								}
							}
							*(*TTcl_Size)(unsafe.Pointer(v83 + 64)) += int64(v82)
						}
					} else {
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
							XTclExpandCodeArray(tls, envPtr2)
						}
						v85 = envPtr2 + 152
						v84 = *(*uintptr)(unsafe.Pointer(v85))
						*(*uintptr)(unsafe.Pointer(v85))++
						*(*uint8)(unsafe.Pointer(v84)) = libc.Uint8FromInt32(int32(INST_PUSH4))
						v87 = envPtr2 + 152
						v86 = *(*uintptr)(unsafe.Pointer(v87))
						*(*uintptr)(unsafe.Pointer(v87))++
						*(*uint8)(unsafe.Pointer(v86)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(24))
						v89 = envPtr2 + 152
						v88 = *(*uintptr)(unsafe.Pointer(v89))
						*(*uintptr)(unsafe.Pointer(v89))++
						*(*uint8)(unsafe.Pointer(v88)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(16))
						v91 = envPtr2 + 152
						v90 = *(*uintptr)(unsafe.Pointer(v91))
						*(*uintptr)(unsafe.Pointer(v91))++
						*(*uint8)(unsafe.Pointer(v90)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(8))
						v93 = envPtr2 + 152
						v92 = *(*uintptr)(unsafe.Pointer(v93))
						*(*uintptr)(unsafe.Pointer(v93))++
						*(*uint8)(unsafe.Pointer(v92)) = uint8(libc.Uint32FromInt32(_objIndexCopy4))
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
							(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
						}
						delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
						if delta1 != 0 {
							if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
								delta1 = int32(1) - _objIndexCopy4
							}
							v94 = delta1
							v95 = envPtr2
							if v94 < libc.Int32FromInt32(0) {
								if int32((*TCompileEnv)(unsafe.Pointer(v95)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v95)).FcurrStackDepth) {
									(*TCompileEnv)(unsafe.Pointer(v95)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v95)).FcurrStackDepth
								}
							}
							*(*TTcl_Size)(unsafe.Pointer(v95 + 64)) += int64(v94)
						}
					}
				} else {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + 2*8))
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + 2*8))
					XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
				}
				if tmpIndex < int32(256) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v97 = envPtr2 + 152
					v96 = *(*uintptr)(unsafe.Pointer(v97))
					*(*uintptr)(unsafe.Pointer(v97))++
					*(*uint8)(unsafe.Pointer(v96)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
					v99 = envPtr2 + 152
					v98 = *(*uintptr)(unsafe.Pointer(v99))
					*(*uintptr)(unsafe.Pointer(v99))++
					*(*uint8)(unsafe.Pointer(v98)) = uint8(libc.Uint32FromInt32(tmpIndex))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - tmpIndex
						}
						v100 = delta1
						v101 = envPtr2
						if v100 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v101)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v101)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v101)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v101)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v101 + 64)) += int64(v100)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v103 = envPtr2 + 152
					v102 = *(*uintptr)(unsafe.Pointer(v103))
					*(*uintptr)(unsafe.Pointer(v103))++
					*(*uint8)(unsafe.Pointer(v102)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
					v105 = envPtr2 + 152
					v104 = *(*uintptr)(unsafe.Pointer(v105))
					*(*uintptr)(unsafe.Pointer(v105))++
					*(*uint8)(unsafe.Pointer(v104)) = uint8(libc.Uint32FromInt32(tmpIndex) >> libc.Int32FromInt32(24))
					v107 = envPtr2 + 152
					v106 = *(*uintptr)(unsafe.Pointer(v107))
					*(*uintptr)(unsafe.Pointer(v107))++
					*(*uint8)(unsafe.Pointer(v106)) = uint8(libc.Uint32FromInt32(tmpIndex) >> libc.Int32FromInt32(16))
					v109 = envPtr2 + 152
					v108 = *(*uintptr)(unsafe.Pointer(v109))
					*(*uintptr)(unsafe.Pointer(v109))++
					*(*uint8)(unsafe.Pointer(v108)) = uint8(libc.Uint32FromInt32(tmpIndex) >> libc.Int32FromInt32(8))
					v111 = envPtr2 + 152
					v110 = *(*uintptr)(unsafe.Pointer(v111))
					*(*uintptr)(unsafe.Pointer(v111))++
					*(*uint8)(unsafe.Pointer(v110)) = uint8(libc.Uint32FromInt32(tmpIndex))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - tmpIndex
						}
						v112 = delta1
						v113 = envPtr2
						if v112 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v113)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v113)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v113)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v113)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v113 + 64)) += int64(v112)
					}
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v115 = envPtr2 + 152
				v114 = *(*uintptr)(unsafe.Pointer(v115))
				*(*uintptr)(unsafe.Pointer(v115))++
				*(*uint8)(unsafe.Pointer(v114)) = libc.Uint8FromInt32(instruction)
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					if instruction == int32(INST_START_CMD) {
						v116 = int32(1)
					} else {
						v116 = 0
					}
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = v116
				}
				delta1 = XtclInstructionTable[libc.Uint8FromInt32(instruction)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v117 = delta1
					v118 = envPtr2
					if v117 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v118)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v118)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v118)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v118)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v118 + 64)) += int64(v117)
				}
				words = int64(3)
				for {
					if !(words < (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) {
						break
					}
					if tmpIndex < int32(256) {
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
							XTclExpandCodeArray(tls, envPtr2)
						}
						v121 = envPtr2 + 152
						v120 = *(*uintptr)(unsafe.Pointer(v121))
						*(*uintptr)(unsafe.Pointer(v121))++
						*(*uint8)(unsafe.Pointer(v120)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
						v123 = envPtr2 + 152
						v122 = *(*uintptr)(unsafe.Pointer(v123))
						*(*uintptr)(unsafe.Pointer(v123))++
						*(*uint8)(unsafe.Pointer(v122)) = uint8(libc.Uint32FromInt32(tmpIndex))
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
							(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
						}
						delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
						if delta1 != 0 {
							if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
								delta1 = int32(1) - tmpIndex
							}
							v124 = delta1
							v125 = envPtr2
							if v124 < libc.Int32FromInt32(0) {
								if int32((*TCompileEnv)(unsafe.Pointer(v125)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v125)).FcurrStackDepth) {
									(*TCompileEnv)(unsafe.Pointer(v125)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v125)).FcurrStackDepth
								}
							}
							*(*TTcl_Size)(unsafe.Pointer(v125 + 64)) += int64(v124)
						}
					} else {
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
							XTclExpandCodeArray(tls, envPtr2)
						}
						v127 = envPtr2 + 152
						v126 = *(*uintptr)(unsafe.Pointer(v127))
						*(*uintptr)(unsafe.Pointer(v127))++
						*(*uint8)(unsafe.Pointer(v126)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
						v129 = envPtr2 + 152
						v128 = *(*uintptr)(unsafe.Pointer(v129))
						*(*uintptr)(unsafe.Pointer(v129))++
						*(*uint8)(unsafe.Pointer(v128)) = uint8(libc.Uint32FromInt32(tmpIndex) >> libc.Int32FromInt32(24))
						v131 = envPtr2 + 152
						v130 = *(*uintptr)(unsafe.Pointer(v131))
						*(*uintptr)(unsafe.Pointer(v131))++
						*(*uint8)(unsafe.Pointer(v130)) = uint8(libc.Uint32FromInt32(tmpIndex) >> libc.Int32FromInt32(16))
						v133 = envPtr2 + 152
						v132 = *(*uintptr)(unsafe.Pointer(v133))
						*(*uintptr)(unsafe.Pointer(v133))++
						*(*uint8)(unsafe.Pointer(v132)) = uint8(libc.Uint32FromInt32(tmpIndex) >> libc.Int32FromInt32(8))
						v135 = envPtr2 + 152
						v134 = *(*uintptr)(unsafe.Pointer(v135))
						*(*uintptr)(unsafe.Pointer(v135))++
						*(*uint8)(unsafe.Pointer(v134)) = uint8(libc.Uint32FromInt32(tmpIndex))
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
							(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
						}
						delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
						if delta1 != 0 {
							if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
								delta1 = int32(1) - tmpIndex
							}
							v136 = delta1
							v137 = envPtr2
							if v136 < libc.Int32FromInt32(0) {
								if int32((*TCompileEnv)(unsafe.Pointer(v137)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v137)).FcurrStackDepth) {
									(*TCompileEnv)(unsafe.Pointer(v137)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v137)).FcurrStackDepth
								}
							}
							*(*TTcl_Size)(unsafe.Pointer(v137 + 64)) += int64(v136)
						}
					}
					tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
					if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
						_objIndexCopy5 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
						if _objIndexCopy5 <= int32(255) {
							if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
								XTclExpandCodeArray(tls, envPtr2)
							}
							v139 = envPtr2 + 152
							v138 = *(*uintptr)(unsafe.Pointer(v139))
							*(*uintptr)(unsafe.Pointer(v139))++
							*(*uint8)(unsafe.Pointer(v138)) = libc.Uint8FromInt32(int32(INST_PUSH1))
							v141 = envPtr2 + 152
							v140 = *(*uintptr)(unsafe.Pointer(v141))
							*(*uintptr)(unsafe.Pointer(v141))++
							*(*uint8)(unsafe.Pointer(v140)) = uint8(libc.Uint32FromInt32(_objIndexCopy5))
							if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
								(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
							}
							delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
							if delta1 != 0 {
								if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
									delta1 = int32(1) - _objIndexCopy5
								}
								v142 = delta1
								v143 = envPtr2
								if v142 < libc.Int32FromInt32(0) {
									if int32((*TCompileEnv)(unsafe.Pointer(v143)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v143)).FcurrStackDepth) {
										(*TCompileEnv)(unsafe.Pointer(v143)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v143)).FcurrStackDepth
									}
								}
								*(*TTcl_Size)(unsafe.Pointer(v143 + 64)) += int64(v142)
							}
						} else {
							if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
								XTclExpandCodeArray(tls, envPtr2)
							}
							v145 = envPtr2 + 152
							v144 = *(*uintptr)(unsafe.Pointer(v145))
							*(*uintptr)(unsafe.Pointer(v145))++
							*(*uint8)(unsafe.Pointer(v144)) = libc.Uint8FromInt32(int32(INST_PUSH4))
							v147 = envPtr2 + 152
							v146 = *(*uintptr)(unsafe.Pointer(v147))
							*(*uintptr)(unsafe.Pointer(v147))++
							*(*uint8)(unsafe.Pointer(v146)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(24))
							v149 = envPtr2 + 152
							v148 = *(*uintptr)(unsafe.Pointer(v149))
							*(*uintptr)(unsafe.Pointer(v149))++
							*(*uint8)(unsafe.Pointer(v148)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(16))
							v151 = envPtr2 + 152
							v150 = *(*uintptr)(unsafe.Pointer(v151))
							*(*uintptr)(unsafe.Pointer(v151))++
							*(*uint8)(unsafe.Pointer(v150)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(8))
							v153 = envPtr2 + 152
							v152 = *(*uintptr)(unsafe.Pointer(v153))
							*(*uintptr)(unsafe.Pointer(v153))++
							*(*uint8)(unsafe.Pointer(v152)) = uint8(libc.Uint32FromInt32(_objIndexCopy5))
							if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
								(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
							}
							delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
							if delta1 != 0 {
								if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
									delta1 = int32(1) - _objIndexCopy5
								}
								v154 = delta1
								v155 = envPtr2
								if v154 < libc.Int32FromInt32(0) {
									if int32((*TCompileEnv)(unsafe.Pointer(v155)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v155)).FcurrStackDepth) {
										(*TCompileEnv)(unsafe.Pointer(v155)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v155)).FcurrStackDepth
									}
								}
								*(*TTcl_Size)(unsafe.Pointer(v155 + 64)) += int64(v154)
							}
						}
					} else {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(words)*8))
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(words)*8))
						XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
					}
					words++
					v156 = words
					if v156 < (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords {
						if tmpIndex < int32(256) {
							if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
								XTclExpandCodeArray(tls, envPtr2)
							}
							v158 = envPtr2 + 152
							v157 = *(*uintptr)(unsafe.Pointer(v158))
							*(*uintptr)(unsafe.Pointer(v158))++
							*(*uint8)(unsafe.Pointer(v157)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR1))
							v160 = envPtr2 + 152
							v159 = *(*uintptr)(unsafe.Pointer(v160))
							*(*uintptr)(unsafe.Pointer(v160))++
							*(*uint8)(unsafe.Pointer(v159)) = uint8(libc.Uint32FromInt32(tmpIndex))
							if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
								(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
							}
							delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR1)].FstackEffect
							if delta1 != 0 {
								if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
									delta1 = int32(1) - tmpIndex
								}
								v161 = delta1
								v162 = envPtr2
								if v161 < libc.Int32FromInt32(0) {
									if int32((*TCompileEnv)(unsafe.Pointer(v162)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v162)).FcurrStackDepth) {
										(*TCompileEnv)(unsafe.Pointer(v162)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v162)).FcurrStackDepth
									}
								}
								*(*TTcl_Size)(unsafe.Pointer(v162 + 64)) += int64(v161)
							}
						} else {
							if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
								XTclExpandCodeArray(tls, envPtr2)
							}
							v164 = envPtr2 + 152
							v163 = *(*uintptr)(unsafe.Pointer(v164))
							*(*uintptr)(unsafe.Pointer(v164))++
							*(*uint8)(unsafe.Pointer(v163)) = libc.Uint8FromInt32(int32(INST_STORE_SCALAR4))
							v166 = envPtr2 + 152
							v165 = *(*uintptr)(unsafe.Pointer(v166))
							*(*uintptr)(unsafe.Pointer(v166))++
							*(*uint8)(unsafe.Pointer(v165)) = uint8(libc.Uint32FromInt32(tmpIndex) >> libc.Int32FromInt32(24))
							v168 = envPtr2 + 152
							v167 = *(*uintptr)(unsafe.Pointer(v168))
							*(*uintptr)(unsafe.Pointer(v168))++
							*(*uint8)(unsafe.Pointer(v167)) = uint8(libc.Uint32FromInt32(tmpIndex) >> libc.Int32FromInt32(16))
							v170 = envPtr2 + 152
							v169 = *(*uintptr)(unsafe.Pointer(v170))
							*(*uintptr)(unsafe.Pointer(v170))++
							*(*uint8)(unsafe.Pointer(v169)) = uint8(libc.Uint32FromInt32(tmpIndex) >> libc.Int32FromInt32(8))
							v172 = envPtr2 + 152
							v171 = *(*uintptr)(unsafe.Pointer(v172))
							*(*uintptr)(unsafe.Pointer(v172))++
							*(*uint8)(unsafe.Pointer(v171)) = uint8(libc.Uint32FromInt32(tmpIndex))
							if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
								(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
							}
							delta1 = XtclInstructionTable[uint8(INST_STORE_SCALAR4)].FstackEffect
							if delta1 != 0 {
								if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
									delta1 = int32(1) - tmpIndex
								}
								v173 = delta1
								v174 = envPtr2
								if v173 < libc.Int32FromInt32(0) {
									if int32((*TCompileEnv)(unsafe.Pointer(v174)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v174)).FcurrStackDepth) {
										(*TCompileEnv)(unsafe.Pointer(v174)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v174)).FcurrStackDepth
									}
								}
								*(*TTcl_Size)(unsafe.Pointer(v174 + 64)) += int64(v173)
							}
						}
					}
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v176 = envPtr2 + 152
					v175 = *(*uintptr)(unsafe.Pointer(v176))
					*(*uintptr)(unsafe.Pointer(v176))++
					*(*uint8)(unsafe.Pointer(v175)) = libc.Uint8FromInt32(instruction)
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						if instruction == int32(INST_START_CMD) {
							v177 = int32(1)
						} else {
							v177 = 0
						}
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = v177
					}
					delta1 = XtclInstructionTable[libc.Uint8FromInt32(instruction)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - 0
						}
						v178 = delta1
						v179 = envPtr2
						if v178 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v179)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v179)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v179)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v179)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v179 + 64)) += int64(v178)
					}
					goto _119
				_119:
				}
				for {
					if !(words > int64(3)) {
						break
					}
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v182 = envPtr2 + 152
					v181 = *(*uintptr)(unsafe.Pointer(v182))
					*(*uintptr)(unsafe.Pointer(v182))++
					*(*uint8)(unsafe.Pointer(v181)) = libc.Uint8FromInt32(int32(INST_BITAND))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_BITAND)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - 0
						}
						v183 = delta1
						v184 = envPtr2
						if v183 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v184)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v184)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v184)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v184)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v184 + 64)) += int64(v183)
					}
					goto _180
				_180:
					;
					words--
				}
				/*
				 * Drop the value from the temp variable; retaining that reference
				 * might be expensive elsewhere.
				 */
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v186 = envPtr2 + 152
				v185 = *(*uintptr)(unsafe.Pointer(v186))
				*(*uintptr)(unsafe.Pointer(v186))++
				*(*uint8)(unsafe.Pointer(v185)) = libc.Uint8FromInt32(int32(INST_UNSET_SCALAR))
				v188 = envPtr2 + 152
				v187 = *(*uintptr)(unsafe.Pointer(v188))
				*(*uintptr)(unsafe.Pointer(v188))++
				*(*uint8)(unsafe.Pointer(v187)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_UNSET_SCALAR)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v189 = delta1
					v190 = envPtr2
					if v189 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v190)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v190)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v190)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v190)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v190 + 64)) += int64(v189)
				}
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v192 = envPtr2 + 152
				v191 = *(*uintptr)(unsafe.Pointer(v192))
				*(*uintptr)(unsafe.Pointer(v192))++
				*(*uint8)(unsafe.Pointer(v191)) = uint8(libc.Uint32FromInt32(tmpIndex) >> libc.Int32FromInt32(24))
				v194 = envPtr2 + 152
				v193 = *(*uintptr)(unsafe.Pointer(v194))
				*(*uintptr)(unsafe.Pointer(v194))++
				*(*uint8)(unsafe.Pointer(v193)) = uint8(libc.Uint32FromInt32(tmpIndex) >> libc.Int32FromInt32(16))
				v196 = envPtr2 + 152
				v195 = *(*uintptr)(unsafe.Pointer(v196))
				*(*uintptr)(unsafe.Pointer(v196))++
				*(*uint8)(unsafe.Pointer(v195)) = uint8(libc.Uint32FromInt32(tmpIndex) >> libc.Int32FromInt32(8))
				v198 = envPtr2 + 152
				v197 = *(*uintptr)(unsafe.Pointer(v198))
				*(*uintptr)(unsafe.Pointer(v198))++
				*(*uint8)(unsafe.Pointer(v197)) = uint8(libc.Uint32FromInt32(tmpIndex))
			}
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompile*OpCmd --
 *
 *	Procedures called to compile the corresponding "::tcl::mathop::*"
 *	commands. These are all wrappers around the utility operator command
 *	compiler functions, except for the compilers for subtraction and
 *	division, which are special.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the compiled command at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileInvertOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy4228 uintptr, envPtr uintptr) (r int32) {
	return _CompileUnaryOpCmd(tls, interp, parsePtr, int32(INST_BITNOT), envPtr)
}

func XTclCompileNotOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy4238 uintptr, envPtr uintptr) (r int32) {
	return _CompileUnaryOpCmd(tls, interp, parsePtr, int32(INST_LNOT), envPtr)
}

func XTclCompileAddOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy4248 uintptr, envPtr uintptr) (r int32) {
	return _CompileAssociativeBinaryOpCmd(tls, interp, parsePtr, __ccgo_ts+14828, int32(INST_ADD), envPtr)
}

func XTclCompileMulOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy4259 uintptr, envPtr uintptr) (r int32) {
	return _CompileAssociativeBinaryOpCmd(tls, interp, parsePtr, __ccgo_ts+21397, int32(INST_MULT), envPtr)
}

func XTclCompileAndOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy4270 uintptr, envPtr uintptr) (r int32) {
	return _CompileAssociativeBinaryOpCmd(tls, interp, parsePtr, __ccgo_ts+22383, int32(INST_BITAND), envPtr)
}

func XTclCompileOrOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy4281 uintptr, envPtr uintptr) (r int32) {
	return _CompileAssociativeBinaryOpCmd(tls, interp, parsePtr, __ccgo_ts+14828, int32(INST_BITOR), envPtr)
}

func XTclCompileXorOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy4292 uintptr, envPtr uintptr) (r int32) {
	return _CompileAssociativeBinaryOpCmd(tls, interp, parsePtr, __ccgo_ts+14828, int32(INST_BITXOR), envPtr)
}

func XTclCompilePowOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy4303 uintptr, envPtr2 uintptr) (r int32) {
	var _objIndexCopy, _objIndexCopy1, delta1, v18, v24, v36, v41, v6 int32
	var eclIndex, words, v38 TTcl_Size
	var mapPtr, tokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v19, v2, v20, v21, v22, v23, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v37, v39, v4, v40, v42, v5, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, delta1, eclIndex, mapPtr, tokenPtr, words, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1) /* TIP #280 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
	/*
	 * This one has its own implementation because the ** operator is the only
	 * one with right associativity.
	 */
	words = int64(1)
	for {
		if !(words < (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) {
			break
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v3 = envPtr2 + 152
				v2 = *(*uintptr)(unsafe.Pointer(v3))
				*(*uintptr)(unsafe.Pointer(v3))++
				*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v5 = envPtr2 + 152
				v4 = *(*uintptr)(unsafe.Pointer(v5))
				*(*uintptr)(unsafe.Pointer(v5))++
				*(*uint8)(unsafe.Pointer(v4)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v6 = delta1
					v7 = envPtr2
					if v6 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v7 + 64)) += int64(v6)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v9 = envPtr2 + 152
				v8 = *(*uintptr)(unsafe.Pointer(v9))
				*(*uintptr)(unsafe.Pointer(v9))++
				*(*uint8)(unsafe.Pointer(v8)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v11 = envPtr2 + 152
				v10 = *(*uintptr)(unsafe.Pointer(v11))
				*(*uintptr)(unsafe.Pointer(v11))++
				*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
				v13 = envPtr2 + 152
				v12 = *(*uintptr)(unsafe.Pointer(v13))
				*(*uintptr)(unsafe.Pointer(v13))++
				*(*uint8)(unsafe.Pointer(v12)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
				v15 = envPtr2 + 152
				v14 = *(*uintptr)(unsafe.Pointer(v15))
				*(*uintptr)(unsafe.Pointer(v15))++
				*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
				v17 = envPtr2 + 152
				v16 = *(*uintptr)(unsafe.Pointer(v17))
				*(*uintptr)(unsafe.Pointer(v17))++
				*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v18 = delta1
					v19 = envPtr2
					if v18 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v19 + 64)) += int64(v18)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(words)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(words)*8))
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
		}
		goto _1
	_1:
		;
		words++
	}
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords <= int64(2) {
		_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+21397, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy1 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v21 = envPtr2 + 152
			v20 = *(*uintptr)(unsafe.Pointer(v21))
			*(*uintptr)(unsafe.Pointer(v21))++
			*(*uint8)(unsafe.Pointer(v20)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v23 = envPtr2 + 152
			v22 = *(*uintptr)(unsafe.Pointer(v23))
			*(*uintptr)(unsafe.Pointer(v23))++
			*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v24 = delta1
				v25 = envPtr2
				if v24 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v25 + 64)) += int64(v24)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v27 = envPtr2 + 152
			v26 = *(*uintptr)(unsafe.Pointer(v27))
			*(*uintptr)(unsafe.Pointer(v27))++
			*(*uint8)(unsafe.Pointer(v26)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v29 = envPtr2 + 152
			v28 = *(*uintptr)(unsafe.Pointer(v29))
			*(*uintptr)(unsafe.Pointer(v29))++
			*(*uint8)(unsafe.Pointer(v28)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
			v31 = envPtr2 + 152
			v30 = *(*uintptr)(unsafe.Pointer(v31))
			*(*uintptr)(unsafe.Pointer(v31))++
			*(*uint8)(unsafe.Pointer(v30)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
			v33 = envPtr2 + 152
			v32 = *(*uintptr)(unsafe.Pointer(v33))
			*(*uintptr)(unsafe.Pointer(v33))++
			*(*uint8)(unsafe.Pointer(v32)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
			v35 = envPtr2 + 152
			v34 = *(*uintptr)(unsafe.Pointer(v35))
			*(*uintptr)(unsafe.Pointer(v35))++
			*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy1
				}
				v36 = delta1
				v37 = envPtr2
				if v36 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v37 + 64)) += int64(v36)
			}
		}
		words++
	}
	for {
		words--
		v38 = words
		if !(v38 > int64(1)) {
			break
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v40 = envPtr2 + 152
		v39 = *(*uintptr)(unsafe.Pointer(v40))
		*(*uintptr)(unsafe.Pointer(v40))++
		*(*uint8)(unsafe.Pointer(v39)) = libc.Uint8FromInt32(int32(INST_EXPON))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_EXPON)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v41 = delta1
			v42 = envPtr2
			if v41 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v42)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v42)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v42)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v42)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v42 + 64)) += int64(v41)
		}
	}
	return TCL_OK
}

func XTclCompileLshiftOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy4333 uintptr, envPtr uintptr) (r int32) {
	return _CompileStrictlyBinaryOpCmd(tls, interp, parsePtr, int32(INST_LSHIFT), envPtr)
}

func XTclCompileRshiftOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy4343 uintptr, envPtr uintptr) (r int32) {
	return _CompileStrictlyBinaryOpCmd(tls, interp, parsePtr, int32(INST_RSHIFT), envPtr)
}

func XTclCompileModOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy4353 uintptr, envPtr uintptr) (r int32) {
	return _CompileStrictlyBinaryOpCmd(tls, interp, parsePtr, int32(INST_MOD), envPtr)
}

func XTclCompileNeqOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy4363 uintptr, envPtr uintptr) (r int32) {
	return _CompileStrictlyBinaryOpCmd(tls, interp, parsePtr, int32(INST_NEQ), envPtr)
}

func XTclCompileStrneqOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy4373 uintptr, envPtr uintptr) (r int32) {
	return _CompileStrictlyBinaryOpCmd(tls, interp, parsePtr, int32(INST_STR_NEQ), envPtr)
}

func XTclCompileInOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy4383 uintptr, envPtr uintptr) (r int32) {
	return _CompileStrictlyBinaryOpCmd(tls, interp, parsePtr, int32(INST_LIST_IN), envPtr)
}

func XTclCompileNiOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy4393 uintptr, envPtr uintptr) (r int32) {
	return _CompileStrictlyBinaryOpCmd(tls, interp, parsePtr, int32(INST_LIST_NOT_IN), envPtr)
}

func XTclCompileLessOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy4404 uintptr, envPtr uintptr) (r int32) {
	return _CompileComparisonOpCmd(tls, interp, parsePtr, int32(INST_LT), envPtr)
}

func XTclCompileLeqOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy4414 uintptr, envPtr uintptr) (r int32) {
	return _CompileComparisonOpCmd(tls, interp, parsePtr, int32(INST_LE), envPtr)
}

func XTclCompileGreaterOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy4424 uintptr, envPtr uintptr) (r int32) {
	return _CompileComparisonOpCmd(tls, interp, parsePtr, int32(INST_GT), envPtr)
}

func XTclCompileGeqOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy4434 uintptr, envPtr uintptr) (r int32) {
	return _CompileComparisonOpCmd(tls, interp, parsePtr, int32(INST_GE), envPtr)
}

func XTclCompileEqOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy4444 uintptr, envPtr uintptr) (r int32) {
	return _CompileComparisonOpCmd(tls, interp, parsePtr, int32(INST_EQ), envPtr)
}

func XTclCompileStreqOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy4454 uintptr, envPtr uintptr) (r int32) {
	return _CompileComparisonOpCmd(tls, interp, parsePtr, int32(INST_STR_EQ), envPtr)
}

func XTclCompileStrLtOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy4464 uintptr, envPtr uintptr) (r int32) {
	return _CompileComparisonOpCmd(tls, interp, parsePtr, int32(INST_STR_LT), envPtr)
}

func XTclCompileStrLeOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy4474 uintptr, envPtr uintptr) (r int32) {
	return _CompileComparisonOpCmd(tls, interp, parsePtr, int32(INST_STR_LE), envPtr)
}

func XTclCompileStrGtOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy4484 uintptr, envPtr uintptr) (r int32) {
	return _CompileComparisonOpCmd(tls, interp, parsePtr, int32(INST_STR_GT), envPtr)
}

func XTclCompileStrGeOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy4494 uintptr, envPtr uintptr) (r int32) {
	return _CompileComparisonOpCmd(tls, interp, parsePtr, int32(INST_STR_GE), envPtr)
}

func XTclCompileMinusOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy4504 uintptr, envPtr2 uintptr) (r int32) {
	var _objIndexCopy, delta1, v18, v22, v26, v38, v51, v55, v6 int32
	var eclIndex, words, v40 TTcl_Size
	var mapPtr, tokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v19, v2, v20, v21, v23, v24, v25, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v39, v4, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v52, v53, v54, v56, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, eclIndex, mapPtr, tokenPtr, words, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1) /* TIP #280 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
	/* TODO: Consider support for compiling expanded args. */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(1) {
		/*
		 * Fallback to direct eval to report syntax error.
		 */
		return int32(TCL_ERROR)
	}
	words = int64(1)
	for {
		if !(words < (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) {
			break
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v3 = envPtr2 + 152
				v2 = *(*uintptr)(unsafe.Pointer(v3))
				*(*uintptr)(unsafe.Pointer(v3))++
				*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v5 = envPtr2 + 152
				v4 = *(*uintptr)(unsafe.Pointer(v5))
				*(*uintptr)(unsafe.Pointer(v5))++
				*(*uint8)(unsafe.Pointer(v4)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v6 = delta1
					v7 = envPtr2
					if v6 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v7 + 64)) += int64(v6)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v9 = envPtr2 + 152
				v8 = *(*uintptr)(unsafe.Pointer(v9))
				*(*uintptr)(unsafe.Pointer(v9))++
				*(*uint8)(unsafe.Pointer(v8)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v11 = envPtr2 + 152
				v10 = *(*uintptr)(unsafe.Pointer(v11))
				*(*uintptr)(unsafe.Pointer(v11))++
				*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
				v13 = envPtr2 + 152
				v12 = *(*uintptr)(unsafe.Pointer(v13))
				*(*uintptr)(unsafe.Pointer(v13))++
				*(*uint8)(unsafe.Pointer(v12)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
				v15 = envPtr2 + 152
				v14 = *(*uintptr)(unsafe.Pointer(v15))
				*(*uintptr)(unsafe.Pointer(v15))++
				*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
				v17 = envPtr2 + 152
				v16 = *(*uintptr)(unsafe.Pointer(v17))
				*(*uintptr)(unsafe.Pointer(v17))++
				*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v18 = delta1
					v19 = envPtr2
					if v18 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v19 + 64)) += int64(v18)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(words)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(words)*8))
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
		}
		goto _1
	_1:
		;
		words++
	}
	if words == int64(2) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v21 = envPtr2 + 152
		v20 = *(*uintptr)(unsafe.Pointer(v21))
		*(*uintptr)(unsafe.Pointer(v21))++
		*(*uint8)(unsafe.Pointer(v20)) = libc.Uint8FromInt32(int32(INST_UMINUS))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_UMINUS)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v22 = delta1
			v23 = envPtr2
			if v22 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v23)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v23)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v23)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v23)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v23 + 64)) += int64(v22)
		}
		return TCL_OK
	}
	if words == int64(3) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v25 = envPtr2 + 152
		v24 = *(*uintptr)(unsafe.Pointer(v25))
		*(*uintptr)(unsafe.Pointer(v25))++
		*(*uint8)(unsafe.Pointer(v24)) = libc.Uint8FromInt32(int32(INST_SUB))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_SUB)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v26 = delta1
			v27 = envPtr2
			if v26 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v27)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v27)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v27)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v27)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v27 + 64)) += int64(v26)
		}
		return TCL_OK
	}
	/*
	 * Reverse order of arguments to get precise agreement with [expr] in
	 * calculations, including roundoff errors.
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v29 = envPtr2 + 152
	v28 = *(*uintptr)(unsafe.Pointer(v29))
	*(*uintptr)(unsafe.Pointer(v29))++
	*(*uint8)(unsafe.Pointer(v28)) = libc.Uint8FromInt32(int32(INST_REVERSE))
	v31 = envPtr2 + 152
	v30 = *(*uintptr)(unsafe.Pointer(v31))
	*(*uintptr)(unsafe.Pointer(v31))++
	*(*uint8)(unsafe.Pointer(v30)) = uint8(libc.Uint32FromInt64(words-libc.Int64FromInt32(1)) >> libc.Int32FromInt32(24))
	v33 = envPtr2 + 152
	v32 = *(*uintptr)(unsafe.Pointer(v33))
	*(*uintptr)(unsafe.Pointer(v33))++
	*(*uint8)(unsafe.Pointer(v32)) = uint8(libc.Uint32FromInt64(words-libc.Int64FromInt32(1)) >> libc.Int32FromInt32(16))
	v35 = envPtr2 + 152
	v34 = *(*uintptr)(unsafe.Pointer(v35))
	*(*uintptr)(unsafe.Pointer(v35))++
	*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt64(words-libc.Int64FromInt32(1)) >> libc.Int32FromInt32(8))
	v37 = envPtr2 + 152
	v36 = *(*uintptr)(unsafe.Pointer(v37))
	*(*uintptr)(unsafe.Pointer(v37))++
	*(*uint8)(unsafe.Pointer(v36)) = uint8(libc.Uint32FromInt64(words - libc.Int64FromInt32(1)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32(words-int64(1))
		}
		v38 = delta1
		v39 = envPtr2
		if v38 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v39)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v39)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v39)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v39)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v39 + 64)) += int64(v38)
	}
	for {
		words--
		v40 = words
		if !(v40 > int64(1)) {
			break
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v42 = envPtr2 + 152
		v41 = *(*uintptr)(unsafe.Pointer(v42))
		*(*uintptr)(unsafe.Pointer(v42))++
		*(*uint8)(unsafe.Pointer(v41)) = libc.Uint8FromInt32(int32(INST_REVERSE))
		v44 = envPtr2 + 152
		v43 = *(*uintptr)(unsafe.Pointer(v44))
		*(*uintptr)(unsafe.Pointer(v44))++
		*(*uint8)(unsafe.Pointer(v43)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
		v46 = envPtr2 + 152
		v45 = *(*uintptr)(unsafe.Pointer(v46))
		*(*uintptr)(unsafe.Pointer(v46))++
		*(*uint8)(unsafe.Pointer(v45)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
		v48 = envPtr2 + 152
		v47 = *(*uintptr)(unsafe.Pointer(v48))
		*(*uintptr)(unsafe.Pointer(v48))++
		*(*uint8)(unsafe.Pointer(v47)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
		v50 = envPtr2 + 152
		v49 = *(*uintptr)(unsafe.Pointer(v50))
		*(*uintptr)(unsafe.Pointer(v50))++
		*(*uint8)(unsafe.Pointer(v49)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(2)
			}
			v51 = delta1
			v52 = envPtr2
			if v51 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v52)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v52)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v52)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v52)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v52 + 64)) += int64(v51)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v54 = envPtr2 + 152
		v53 = *(*uintptr)(unsafe.Pointer(v54))
		*(*uintptr)(unsafe.Pointer(v54))++
		*(*uint8)(unsafe.Pointer(v53)) = libc.Uint8FromInt32(int32(INST_SUB))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_SUB)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v55 = delta1
			v56 = envPtr2
			if v55 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v56)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v56)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v56)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v56)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v56 + 64)) += int64(v55)
		}
	}
	return TCL_OK
}

func XTclCompileDivOpCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy4549 uintptr, envPtr2 uintptr) (r int32) {
	var _objIndexCopy, _objIndexCopy1, delta1, v17, v24, v36, v40, v5, v52, v65, v69 int32
	var eclIndex, words, v54 TTcl_Size
	var mapPtr, tokenPtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v2, v20, v21, v22, v23, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v37, v38, v39, v4, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v53, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v66, v67, v68, v7, v70, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, delta1, eclIndex, mapPtr, tokenPtr, words, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1) /* TIP #280 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
	/* TODO: Consider support for compiling expanded args. */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(1) {
		/*
		 * Fallback to direct eval to report syntax error.
		 */
		return int32(TCL_ERROR)
	}
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == int64(2) {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+22386, libc.Int64FromUint64(libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v2 = envPtr2 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr2 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr2
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v8 = envPtr2 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr2 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr2 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr2 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr2 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr2
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	}
	words = int64(1)
	for {
		if !(words < (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) {
			break
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
			if _objIndexCopy1 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v21 = envPtr2 + 152
				v20 = *(*uintptr)(unsafe.Pointer(v21))
				*(*uintptr)(unsafe.Pointer(v21))++
				*(*uint8)(unsafe.Pointer(v20)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v23 = envPtr2 + 152
				v22 = *(*uintptr)(unsafe.Pointer(v23))
				*(*uintptr)(unsafe.Pointer(v23))++
				*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v24 = delta1
					v25 = envPtr2
					if v24 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v25 + 64)) += int64(v24)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v27 = envPtr2 + 152
				v26 = *(*uintptr)(unsafe.Pointer(v27))
				*(*uintptr)(unsafe.Pointer(v27))++
				*(*uint8)(unsafe.Pointer(v26)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v29 = envPtr2 + 152
				v28 = *(*uintptr)(unsafe.Pointer(v29))
				*(*uintptr)(unsafe.Pointer(v29))++
				*(*uint8)(unsafe.Pointer(v28)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
				v31 = envPtr2 + 152
				v30 = *(*uintptr)(unsafe.Pointer(v31))
				*(*uintptr)(unsafe.Pointer(v31))++
				*(*uint8)(unsafe.Pointer(v30)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
				v33 = envPtr2 + 152
				v32 = *(*uintptr)(unsafe.Pointer(v33))
				*(*uintptr)(unsafe.Pointer(v33))++
				*(*uint8)(unsafe.Pointer(v32)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
				v35 = envPtr2 + 152
				v34 = *(*uintptr)(unsafe.Pointer(v35))
				*(*uintptr)(unsafe.Pointer(v35))++
				*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v36 = delta1
					v37 = envPtr2
					if v36 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v37)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v37)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v37 + 64)) += int64(v36)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(words)*8))
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(words)*8))
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
		}
		goto _19
	_19:
		;
		words++
	}
	if words <= int64(3) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v39 = envPtr2 + 152
		v38 = *(*uintptr)(unsafe.Pointer(v39))
		*(*uintptr)(unsafe.Pointer(v39))++
		*(*uint8)(unsafe.Pointer(v38)) = libc.Uint8FromInt32(int32(INST_DIV))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_DIV)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v40 = delta1
			v41 = envPtr2
			if v40 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v41)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v41)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v41)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v41)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v41 + 64)) += int64(v40)
		}
		return TCL_OK
	}
	/*
	 * Reverse order of arguments to get precise agreement with [expr] in
	 * calculations, including roundoff errors.
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v43 = envPtr2 + 152
	v42 = *(*uintptr)(unsafe.Pointer(v43))
	*(*uintptr)(unsafe.Pointer(v43))++
	*(*uint8)(unsafe.Pointer(v42)) = libc.Uint8FromInt32(int32(INST_REVERSE))
	v45 = envPtr2 + 152
	v44 = *(*uintptr)(unsafe.Pointer(v45))
	*(*uintptr)(unsafe.Pointer(v45))++
	*(*uint8)(unsafe.Pointer(v44)) = uint8(libc.Uint32FromInt64(words-libc.Int64FromInt32(1)) >> libc.Int32FromInt32(24))
	v47 = envPtr2 + 152
	v46 = *(*uintptr)(unsafe.Pointer(v47))
	*(*uintptr)(unsafe.Pointer(v47))++
	*(*uint8)(unsafe.Pointer(v46)) = uint8(libc.Uint32FromInt64(words-libc.Int64FromInt32(1)) >> libc.Int32FromInt32(16))
	v49 = envPtr2 + 152
	v48 = *(*uintptr)(unsafe.Pointer(v49))
	*(*uintptr)(unsafe.Pointer(v49))++
	*(*uint8)(unsafe.Pointer(v48)) = uint8(libc.Uint32FromInt64(words-libc.Int64FromInt32(1)) >> libc.Int32FromInt32(8))
	v51 = envPtr2 + 152
	v50 = *(*uintptr)(unsafe.Pointer(v51))
	*(*uintptr)(unsafe.Pointer(v51))++
	*(*uint8)(unsafe.Pointer(v50)) = uint8(libc.Uint32FromInt64(words - libc.Int64FromInt32(1)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - int32(words-int64(1))
		}
		v52 = delta1
		v53 = envPtr2
		if v52 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v53)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v53)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v53)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v53)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v53 + 64)) += int64(v52)
	}
	for {
		words--
		v54 = words
		if !(v54 > int64(1)) {
			break
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v56 = envPtr2 + 152
		v55 = *(*uintptr)(unsafe.Pointer(v56))
		*(*uintptr)(unsafe.Pointer(v56))++
		*(*uint8)(unsafe.Pointer(v55)) = libc.Uint8FromInt32(int32(INST_REVERSE))
		v58 = envPtr2 + 152
		v57 = *(*uintptr)(unsafe.Pointer(v58))
		*(*uintptr)(unsafe.Pointer(v58))++
		*(*uint8)(unsafe.Pointer(v57)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(24))
		v60 = envPtr2 + 152
		v59 = *(*uintptr)(unsafe.Pointer(v60))
		*(*uintptr)(unsafe.Pointer(v60))++
		*(*uint8)(unsafe.Pointer(v59)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(16))
		v62 = envPtr2 + 152
		v61 = *(*uintptr)(unsafe.Pointer(v62))
		*(*uintptr)(unsafe.Pointer(v62))++
		*(*uint8)(unsafe.Pointer(v61)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)) >> libc.Int32FromInt32(8))
		v64 = envPtr2 + 152
		v63 = *(*uintptr)(unsafe.Pointer(v64))
		*(*uintptr)(unsafe.Pointer(v64))++
		*(*uint8)(unsafe.Pointer(v63)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(2)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_REVERSE)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(2)
			}
			v65 = delta1
			v66 = envPtr2
			if v65 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v66)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v66)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v66)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v66)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v66 + 64)) += int64(v65)
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v68 = envPtr2 + 152
		v67 = *(*uintptr)(unsafe.Pointer(v68))
		*(*uintptr)(unsafe.Pointer(v68))++
		*(*uint8)(unsafe.Pointer(v67)) = libc.Uint8FromInt32(int32(INST_DIV))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_DIV)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v69 = delta1
			v70 = envPtr2
			if v69 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v70)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v70)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v70 + 64)) += int64(v69)
		}
	}
	return TCL_OK
}

/*
 * Macros used to update the flag that indicates if we are at the start of a
 * command, based on whether the opcode is INST_START_COMMAND.
 *
 * void TclUpdateAtCmdStart(unsigned char op, CompileEnv *envPtr);
 */

/*
 * Macro to emit an opcode byte into a CompileEnv's code array. The ANSI C
 * "prototype" for this macro is:
 *
 * void TclEmitOpcode(unsigned char op, CompileEnv *envPtr);
 */

/*
 * Macros to emit an integer operand. The ANSI C "prototype" for these macros
 * are:
 *
 * void TclEmitInt1(int i, CompileEnv *envPtr);
 * void TclEmitInt4(int i, CompileEnv *envPtr);
 */

/*
 * Macros to emit an instruction with signed or unsigned integer operands.
 * Four byte integers are stored in "big-endian" order with the high order
 * byte stored at the lowest address. The ANSI C "prototypes" for these macros
 * are:
 *
 * void TclEmitInstInt1(unsigned char op, int i, CompileEnv *envPtr);
 * void TclEmitInstInt4(unsigned char op, int i, CompileEnv *envPtr);
 */

/*
 * Macro to push a Tcl object onto the Tcl evaluation stack. It emits the
 * object's one or four byte array index into the CompileEnv's code array.
 * These support, respectively, a maximum of 256 (2**8) and 2**32 objects in a
 * CompileEnv. The ANSI C "prototype" for this macro is:
 *
 * void	TclEmitPush(int objIndex, CompileEnv *envPtr);
 */

/*
 * Macros to update a (signed or unsigned) integer starting at a pointer. The
 * two variants depend on the number of bytes. The ANSI C "prototypes" for
 * these macros are:
 *
 * void TclStoreInt1AtPtr(int i, unsigned char *p);
 * void TclStoreInt4AtPtr(int i, unsigned char *p);
 */

/*
 * Macros to update instructions at a particular pc with a new op code and a
 * (signed or unsigned) int operand. The ANSI C "prototypes" for these macros
 * are:
 *
 * void TclUpdateInstInt1AtPc(unsigned char op, int i, unsigned char *pc);
 * void TclUpdateInstInt4AtPc(unsigned char op, int i, unsigned char *pc);
 */

/*
 * Macro to fix up a forward jump to point to the current code-generation
 * position in the bytecode being created (the most common case). The ANSI C
 * "prototypes" for this macro is:
 *
 * int TclFixupForwardJumpToHere(CompileEnv *envPtr, JumpFixup *fixupPtr,
 *				 int threshold);
 */

/*
 * Macros to get a signed integer (GET_INT{1,2}) or an unsigned int
 * (GET_UINT{1,2}) from a pointer. There are two variants for each return type
 * that depend on the number of bytes fetched. The ANSI C "prototypes" for
 * these macros are:
 *
 * int TclGetInt1AtPtr(unsigned char *p);
 * int TclGetInt4AtPtr(unsigned char *p);
 * unsigned int TclGetUInt1AtPtr(unsigned char *p);
 * unsigned int TclGetUInt4AtPtr(unsigned char *p);
 */

/*
 * The TclGetInt1AtPtr macro is tricky because we want to do sign extension on
 * the 1-byte value. Unfortunately the "char" type isn't signed on all
 * platforms so sign-extension doesn't always happen automatically. Sometimes
 * we can explicitly declare the pointer to be signed, but other times we have
 * to explicitly sign-extend the value in software.
 */

/*
 * Macros used to compute the minimum and maximum of two values. The ANSI C
 * "prototypes" for these macros are:
 *
 * size_t TclMin(size_t i, size_t j);
 * size_t TclMax(size_t i, size_t j);
 */

/*
 * Convenience macros for use when compiling bodies of commands. The ANSI C
 * "prototype" for these macros are:
 *
 * static void		BODY(Tcl_Token *tokenPtr, int word);
 */

/*
 * Convenience macro for use when compiling tokens to be pushed. The ANSI C
 * "prototype" for this macro is:
 *
 * static void		CompileTokens(CompileEnv *envPtr, Tcl_Token *tokenPtr,
 *			    Tcl_Interp *interp);
 */

/*
 * Convenience macros for use when pushing literals. The ANSI C "prototype" for
 * these macros are:
 *
 * static void		PushLiteral(CompileEnv *envPtr,
 *			    const char *string, Tcl_Size length);
 * static void		PushStringLiteral(CompileEnv *envPtr,
 *			    const char *string);
 */

/*
 * Macro to advance to the next token; it is more mnemonic than the address
 * arithmetic that it replaces. The ANSI C "prototype" for this macro is:
 *
 * static Tcl_Token *	TokenAfter(Tcl_Token *tokenPtr);
 */

/*
 * Macro to get the offset to the next instruction to be issued. The ANSI C
 * "prototype" for this macro is:
 *
 * static ptrdiff_t	CurrentOffset(CompileEnv *envPtr);
 */

/*
 * Note: the exceptDepth is a bit of a misnomer: TEBC only needs the
 * maximal depth of nested CATCH ranges in order to alloc runtime
 * memory. These macros should compute precisely that? OTOH, the nesting depth
 * of LOOP ranges is an interesting datum for debugging purposes, and that is
 * what we compute now.
 *
 * static int	ExceptionRangeStarts(CompileEnv *envPtr, Tcl_Size index);
 * static void	ExceptionRangeEnds(CompileEnv *envPtr, Tcl_Size index);
 * static void	ExceptionRangeTarget(CompileEnv *envPtr, Tcl_Size index, LABEL);
 */

/*
 * Check if there is an LVT for compiled locals
 */

/*
 * Macros for making it easier to deal with tokens and DStrings.
 */

/*
 * Macro that encapsulates an efficiency trick that avoids a function call for
 * the simplest of compiles. The ANSI C "prototype" for this macro is:
 *
 * static void		CompileWord(CompileEnv *envPtr, Tcl_Token *tokenPtr,
 *			    Tcl_Interp *interp, int word);
 */

/*
 * TIP #280: Remember the per-word line information of the current command. An
 * index is used instead of a pointer as recursive compilation may reallocate,
 * i.e. move, the array. This is also the reason to save the nuloc now, it may
 * change during the course of the function.
 *
 * Macro to encapsulate the variable definition and setup.
 */

/*
 * Often want to issue one of two versions of an instruction based on whether
 * the argument will fit in a single byte or not. This makes it much clearer.
 */

/*
 * How to get an anonymous local variable (used for holding temporary values
 * off the stack) or a local simple scalar.
 */

/*
 * Flags bits used by TclPushVarName.
 */

/*
 * Flags bits used by lreplace4 instruction
 */

/*
 * DTrace probe macros (NOPs if DTrace support is not enabled).
 */

/*
 * Define the following macros to enable debug logging of the DTrace proc,
 * cmd, and inst probes. Note that this does _not_ require a platform with
 * DTrace, it simply logs all probe output to /tmp/tclDTraceDebug-[pid].log.
 *
 * If the second macro is defined, logging to file starts immediately,
 * otherwise only after the first call to [tcl::dtrace]. Note that the debug
 * probe data is always computed, even when it is not logged to file.
 *
 * Defining the third macro enables debug logging of inst probes (disabled
 * by default due to the significant performance impact).
 */

/*
#define TCL_DTRACE_DEBUG 1
#define TCL_DTRACE_DEBUG_LOG_ENABLED 1
#define TCL_DTRACE_DEBUG_INST_PROBES 1
*/

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * Expression parsing takes place in the routine ParseExpr(). It takes a
 * string as input, parses that string, and generates a representation of the
 * expression in the form of a tree of operators, a list of literals, a list
 * of function names, and an array of Tcl_Token's within a Tcl_Parse struct.
 * The tree is composed of OpNodes.
 */

type TOpNode = struct {
	Fleft  int32
	Fright int32
	Fp     struct {
		Fprev   [0]int32
		Fparent int32
	}
	Flexeme     uint8
	Fprecedence uint8
	Fmark       uint8
	Fconstant   uint8
}

/*
 * The storage for the tree is dynamically allocated array of OpNodes. The
 * array is grown as parsing needs dictate according to a scheme similar to
 * Tcl's string growth algorithm, so that the resizing costs are O(N) and so
 * that we use at least half the memory allocated as expressions get large.
 *
 * Each OpNode in the tree represents an operator in the expression, either
 * unary or binary. When parsing is completed successfully, a binary operator
 * OpNode will have its left and right fields filled with "pointers" to its
 * left and right operands. A unary operator OpNode will have its right field
 * filled with a pointer to its single operand. When an operand is a
 * subexpression the "pointer" takes the form of the index -- a non-negative
 * integer -- into the OpNode storage array where the root of that
 * subexpression parse tree is found.
 *
 * Non-operator elements of the expression do not get stored in the OpNode
 * tree. They are stored in the other structures according to their type.
 * Literal values get appended to the literal list. Elements that denote forms
 * of quoting or substitution known to the Tcl parser get stored as
 * Tcl_Tokens. These non-operator elements of the expression are the leaves of
 * the completed parse tree. When an operand of an OpNode is one of these leaf
 * elements, the following negative integer codes are used to indicate which
 * kind of elements it is.
 */

type OperandTypes = int32

const OT_LITERAL = -3
const /* Operand is a literal in the literal list */
OT_TOKENS = -2
const /* Operand is sequence of Tcl_Tokens */
OT_EMPTY = -1

/*
 * Readable macros to test whether a "pointer" value points to an operator.
 * They operate on the "non-negative integer -> operator; negative integer ->
 * a non-operator OperandType" distinction.
 */

/*
 * Note that it is sufficient to store in the tree just the type of leaf
 * operand, without any explicit pointer to which leaf. This is true because
 * the traversals of the completed tree we perform are known to visit the
 * leaves in the same order as the original parse.
 *
 * In a completed parse tree, those OpNodes that are themselves (roots of
 * subexpression trees that are) operands of some operator store in their
 * p.parent field a "pointer" to the OpNode of that operator. The p.parent
 * field permits a traversal of the tree within a non-recursive routine
 * (ConvertTreeToTokens() and CompileExprTree()). This means that even
 * expression trees of great depth pose no risk of blowing the C stack.
 *
 * While the parse tree is being constructed, the same memory space is used to
 * hold the p.prev field which chains together a stack of incomplete trees
 * awaiting their right operands.
 *
 * The lexeme field is filled in with the lexeme of the operator that is
 * returned by the ParseLexeme() routine. Only lexemes for unary and binary
 * operators get stored in an OpNode. Other lexmes get different treatment.
 *
 * The precedence field provides a place to store the precedence of the
 * operator, so it need not be looked up again and again.
 *
 * The mark field is use to control the traversal of the tree, so that it can
 * be done non-recursively. The mark values are:
 */

type Marks = int32

const MARK_LEFT = 0
const /* Next step of traversal is to visit left subtree */
MARK_RIGHT = 1
const /* Next step of traversal is to visit right subtree */
MARK_PARENT = 2

/*
 * The constant field is a boolean flag marking which subexpressions are
 * completely known at compile time, and are eligible for computing then
 * rather than waiting until run time.
 */

/*
 * The four category values are LEAF, UNARY, and BINARY, explained below, and
 * "uncategorized", which is used either temporarily, until context determines
 * which of the other three categories is correct, or for lexemes like
 * INVALID, which aren't really lexemes at all, but indicators of a parsing
 * error. Note that the codes must be distinct to distinguish categories, but
 * need not take the form of a bit array.
 */
type LexemeTypes = int32

const
/*
 * Each lexeme belongs to one of four categories, which determine its place
 * in the parse tree. We use the two high bits of the (unsigned char) value
 * to store a NODE_TYPE code.
 */
NODE_TYPE = 192
const BINARY = 64
const /* This lexeme is a binary operator. An OpNode
 * representing it should go into the parse
 * tree, and two operands should be parsed for
 * it in the expression. */
UNARY = 128
const /* This lexeme is a unary operator. An OpNode
 * representing it should go into the parse
 * tree, and one operand should be parsed for
 * it in the expression. */
LEAF = 192

type LexemeCodes = int32

const
/* Uncategorized lexemes */

PLUS = 1
const /* Ambiguous. Resolves to UNARY_PLUS or
 * BINARY_PLUS according to context. */
MINUS = 2
const /* Ambiguous. Resolves to UNARY_MINUS or
 * BINARY_MINUS according to context. */
BAREWORD = 3
const /* Ambiguous. Resolves to BOOL_LIT or to
 * FUNCTION or a parse error according to
 * context and value. */
INCOMPLETE = 4
const /* A parse error. Used only when the single
 * "=" is encountered.  */
INVALID = 5
const /* A parse error. Used when any punctuation
 * appears that's not a supported operator. */
COMMENT = 6
const /* Comment. Lasts to end of line or end of
 * expression, whichever comes first. */

/* Leaf lexemes */

NUMBER = 193
const /* For literal numbers */
SCRIPT = 194
const /* Script substitution; [foo] */
BOOL_LIT = 195
const /* For literal booleans */
BRACED = 196
const /* Braced string; {foo bar} */
VARIABLE = 197
const /* Variable substitution; $x */
QUOTED = 198
const /* Quoted string; "foo $bar [soom]" */
EMPTY1 = 199
const /* Used only for an empty argument list to a
 * function. Represents the empty string
 * within parens in the expression: rand() */

/* Unary operator lexemes */

UNARY_PLUS = 129
const UNARY_MINUS = 130
const FUNCTION = 131
const
/* This is a bit of "creative interpretation"
 * on the part of the parser. A function call
 * is parsed into the parse tree according to
 * the perspective that the function name is a
 * unary operator and its argument list,
 * enclosed in parens, is its operand. The
 * additional requirements not implied
 * generally by treatment as a unary operator
 * -- for example, the requirement that the
 * operand be enclosed in parens -- are hard
 * coded in the relevant portions of
 * ParseExpr(). We trade off the need to
 * include such exceptional handling in the
 * code against the need we would otherwise
 * have for more lexeme categories. */
START = 132
const /* This lexeme isn't parsed from the
 * expression text at all. It represents the
 * start of the expression and sits at the
 * root of the parse tree where it serves as
 * the start/end point of traversals. */
OPEN_PAREN = 133
const /* Another bit of creative interpretation,
 * where we treat "(" as a unary operator with
 * the sub-expression between it and its
 * matching ")" as its operand. See
 * CLOSE_PAREN below. */
NOT = 134
const BIT_NOT = 135
const

/* Binary operator lexemes */

BINARY_PLUS = 65
const BINARY_MINUS = 66
const COMMA = 67
const /* The "," operator is a low precedence binary
 * operator that separates the arguments in a
 * function call. The additional constraint
 * that this operator can only legally appear
 * at the right places within a function call
 * argument list are hard coded within
 * ParseExpr().  */
MULT = 68
const DIVIDE = 69
const MOD = 70
const LESS = 71
const GREATER = 72
const BIT_AND = 73
const BIT_XOR = 74
const BIT_OR = 75
const QUESTION = 76
const /* These two lexemes make up the */
COLON = 77
const /* ternary conditional operator, $x ? $y : $z.
 * We treat them as two binary operators to
 * avoid another lexeme category, and code the
 * additional constraints directly in
 * ParseExpr(). For instance, the right
 * operand of a "?" operator must be a ":"
 * operator. */
LEFT_SHIFT = 78
const RIGHT_SHIFT = 79
const LEQ = 80
const GEQ = 81
const EQUAL = 82
const NEQ = 83
const AND = 84
const OR = 85
const STREQ = 86
const STRNEQ = 87
const EXPON = 88
const /* Unlike the other binary operators, EXPON is
 * right associative and this distinction is
 * coded directly in ParseExpr(). */
IN_LIST = 89
const NOT_IN_LIST = 90
const CLOSE_PAREN = 91
const /* By categorizing the CLOSE_PAREN lexeme as a
 * BINARY operator, the normal parsing rules
 * for binary operators assure that a close
 * paren will not directly follow another
 * operator, and the machinery already in
 * place to connect operands to operators
 * according to precedence performs most of
 * the work of matching open and close parens
 * for us. In the end though, a close paren is
 * not really a binary operator, and some
 * special coding in ParseExpr() make sure we
 * never put an actual CLOSE_PAREN node in the
 * parse tree. The sub-expression between
 * parens becomes the single argument of the
 * matching OPEN_PAREN unary operator. */
STR_LT = 92
const STR_GT = 93
const STR_LEQ = 94
const STR_GEQ = 95
const END1 = 96

/*
 * When ParseExpr() builds the parse tree it must choose which operands to
 * connect to which operators.  This is done according to operator precedence.
 * The greater an operator's precedence the greater claim it has to link to an
 * available operand.  The Precedence enumeration lists the precedence values
 * used by Tcl expression operators, from lowest to highest claim.  Each
 * precedence level is commented with the operators that hold that precedence.
 */

type Precedence = int32

const PREC_END = 1
const /* END */
PREC_START = 2
const /* START */
PREC_CLOSE_PAREN = 3
const /* ")" */
PREC_OPEN_PAREN = 4
const /* "(" */
PREC_COMMA = 5
const /* "," */
PREC_CONDITIONAL = 6
const /* "?", ":" */
PREC_OR = 7
const /* "||" */
PREC_AND = 8
const /* "&&" */
PREC_BIT_OR = 9
const /* "|" */
PREC_BIT_XOR = 10
const /* "^" */
PREC_BIT_AND = 11
const /* "&" */
PREC_EQUAL = 12
const /* "==", "!=", "eq", "ne", "in", "ni" */
PREC_COMPARE = 13
const /* "<", ">", "<=", ">=" */
PREC_SHIFT = 14
const /* "<<", ">>" */
PREC_ADD = 15
const /* "+", "-" */
PREC_MULT = 16
const /* "*", "/", "%" */
PREC_EXPON = 17
const /* "**" */
PREC_UNARY = 18

/*
 * Here the same information contained in the comments above is stored in
 * inverted form, so that given a lexeme, one can quickly look up its
 * precedence value.
 */

var _prec = [136]uint8{
	65:  uint8(PREC_ADD),
	66:  uint8(PREC_ADD),
	67:  uint8(PREC_COMMA),
	68:  uint8(PREC_MULT),
	69:  uint8(PREC_MULT),
	70:  uint8(PREC_MULT),
	71:  uint8(PREC_COMPARE),
	72:  uint8(PREC_COMPARE),
	73:  uint8(PREC_BIT_AND),
	74:  uint8(PREC_BIT_XOR),
	75:  uint8(PREC_BIT_OR),
	76:  uint8(PREC_CONDITIONAL),
	77:  uint8(PREC_CONDITIONAL),
	78:  uint8(PREC_SHIFT),
	79:  uint8(PREC_SHIFT),
	80:  uint8(PREC_COMPARE),
	81:  uint8(PREC_COMPARE),
	82:  uint8(PREC_EQUAL),
	83:  uint8(PREC_EQUAL),
	84:  uint8(PREC_AND),
	85:  uint8(PREC_OR),
	86:  uint8(PREC_EQUAL),
	87:  uint8(PREC_EQUAL),
	88:  uint8(PREC_EXPON),
	89:  uint8(PREC_EQUAL),
	90:  uint8(PREC_EQUAL),
	91:  uint8(PREC_CLOSE_PAREN),
	92:  uint8(PREC_COMPARE),
	93:  uint8(PREC_COMPARE),
	94:  uint8(PREC_COMPARE),
	95:  uint8(PREC_COMPARE),
	96:  uint8(PREC_END),
	129: uint8(PREC_UNARY),
	130: uint8(PREC_UNARY),
	131: uint8(PREC_UNARY),
	132: uint8(PREC_START),
	133: uint8(PREC_OPEN_PAREN),
	134: uint8(PREC_UNARY),
	135: uint8(PREC_UNARY),
}

/*
 * A table mapping lexemes to bytecode instructions, used by CompileExprTree().
 */

var _instruction = [136]uint8{
	65:  uint8(INST_ADD),
	66:  uint8(INST_SUB),
	68:  uint8(INST_MULT),
	69:  uint8(INST_DIV),
	70:  uint8(INST_MOD),
	71:  uint8(INST_LT),
	72:  uint8(INST_GT),
	73:  uint8(INST_BITAND),
	74:  uint8(INST_BITXOR),
	75:  uint8(INST_BITOR),
	78:  uint8(INST_LSHIFT),
	79:  uint8(INST_RSHIFT),
	80:  uint8(INST_LE),
	81:  uint8(INST_GE),
	82:  uint8(INST_EQ),
	83:  uint8(INST_NEQ),
	86:  uint8(INST_STR_EQ),
	87:  uint8(INST_STR_NEQ),
	88:  uint8(INST_EXPON),
	89:  uint8(INST_LIST_IN),
	90:  uint8(INST_LIST_NOT_IN),
	92:  uint8(INST_STR_LT),
	93:  uint8(INST_STR_GT),
	94:  uint8(INST_STR_LE),
	95:  uint8(INST_STR_GE),
	129: uint8(INST_UPLUS),
	130: uint8(INST_UMINUS),
	134: uint8(INST_LNOT),
	135: uint8(INST_BITNOT),
}

/*
 * A table mapping a byte value to the corresponding lexeme for use by
 * ParseLexeme().
 */

var _Lexeme = [128]uint8{
	0:   uint8(INVALID),
	1:   uint8(INVALID),
	2:   uint8(INVALID),
	3:   uint8(INVALID),
	4:   uint8(INVALID),
	5:   uint8(INVALID),
	6:   uint8(INVALID),
	7:   uint8(INVALID),
	8:   uint8(INVALID),
	9:   uint8(INVALID),
	10:  uint8(INVALID),
	11:  uint8(INVALID),
	12:  uint8(INVALID),
	13:  uint8(INVALID),
	14:  uint8(INVALID),
	15:  uint8(INVALID),
	16:  uint8(INVALID),
	17:  uint8(INVALID),
	18:  uint8(INVALID),
	19:  uint8(INVALID),
	20:  uint8(INVALID),
	21:  uint8(INVALID),
	22:  uint8(INVALID),
	23:  uint8(INVALID),
	24:  uint8(INVALID),
	25:  uint8(INVALID),
	26:  uint8(INVALID),
	27:  uint8(INVALID),
	28:  uint8(INVALID),
	29:  uint8(INVALID),
	30:  uint8(INVALID),
	31:  uint8(INVALID),
	32:  uint8(INVALID),
	34:  uint8(QUOTED),
	36:  uint8(VARIABLE),
	37:  uint8(MOD),
	39:  uint8(INVALID),
	40:  uint8(OPEN_PAREN),
	41:  uint8(CLOSE_PAREN),
	43:  uint8(PLUS),
	44:  uint8(COMMA),
	45:  uint8(MINUS),
	47:  uint8(DIVIDE),
	58:  uint8(COLON),
	59:  uint8(INVALID),
	63:  uint8(QUESTION),
	64:  uint8(INVALID),
	91:  uint8(SCRIPT),
	92:  uint8(INVALID),
	93:  uint8(INVALID),
	94:  uint8(BIT_XOR),
	95:  uint8(INVALID),
	96:  uint8(INVALID),
	123: uint8(BRACED),
	125: uint8(INVALID),
	126: uint8(BIT_NOT),
	127: uint8(INVALID),
}

/*
 * The JumpList struct is used to create a stack of data needed for the
 * TclEmitForwardJump() and TclFixupForwardJump() calls that are performed
 * when compiling the short-circuiting operators QUESTION/COLON, AND, and OR.
 * Keeping a stack permits the CompileExprTree() routine to be non-recursive.
 */

type TJumpList = struct {
	Fjump TJumpFixup
	Fnext uintptr
}

/*
 *----------------------------------------------------------------------
 *
 * ParseExpr --
 *
 *	Given a string, the numBytes bytes starting at start, this function
 *	parses it as a Tcl expression and constructs a tree representing the
 *	structure of the expression. The caller must pass in empty lists as
 *	the funcList and litList arguments. The elements of the parsed
 *	expression are returned to the caller as that tree, a list of literal
 *	values, a list of function names, and in Tcl_Tokens added to a
 *	Tcl_Parse struct passed in by the caller.
 *
 * Results:
 *	If the string is successfully parsed as a valid Tcl expression, TCL_OK
 *	is returned, and data about the expression structure is written to the
 *	last four arguments. If the string cannot be parsed as a valid Tcl
 *	expression, TCL_ERROR is returned, and if interp is non-NULL, an error
 *	message is written to interp.
 *
 * Side effects:
 *	Memory will be allocated. If TCL_OK is returned, the caller must clean
 *	up the returned data structures. The (OpNode *) value written to
 *	opTreePtr should be passed to Tcl_Free() and the parsePtr argument
 *	should be passed to Tcl_FreeParse(). The elements appended to the
 *	litList and funcList will automatically be freed whenever the refcount
 *	on those lists indicates they can be freed.
 *
 *----------------------------------------------------------------------
 */

func _ParseExpr(tls *libc.TLS, interp uintptr, start uintptr, numBytes TTcl_Size, opTreePtr uintptr, litList uintptr, funcList uintptr, parsePtr uintptr, parseOnly int32) (r int32) {
	bp := tls.Alloc(128)
	defer tls.Free(128) /* A boolean indicating whether the caller's
	 * aim is just a parse, or whether it will go
	 * on to compile the expression. Different
	 * optimizations are appropriate for the two
	 * scenarios. */
	var _needed, allocated, scanned, v16, v23, v37, v47, v6 TTcl_Size
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, cachePtr, cachePtr1, cachePtr10, cachePtr11, cachePtr12, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cachePtr8, cachePtr9, errCode, incompletePtr, mark, msg, nestedPtr, newPtr, newPtr1, nodePtr, nodes, oldPtr, post, subErrCode, tokenPtr, v11, v13, v15, v17, v24, v38, v39, v41, v43, v44, v46, v48, v50, v7, v9 uintptr
	var code, complete, incomplete, insertMark, lastParsed, limit, scanned2, wordIndex, v18, v2, v22, v25, v26, v27, v36, v40, v42, v45, v49 int32
	var nodesAvailable, nodesUsed, size uint32
	var precedence uint8
	var v1, v19, v20, v21, v28, v29, v3, v30, v31, v32, v33, v34, v35, v5 bool
	var v10, v12, v14, v8 int64
	var _ /* b at bp+16 */ int32
	var _ /* end at bp+32 */ uintptr
	var _ /* lexeme at bp+0 */ uint8
	var _ /* literal at bp+8 */ uintptr
	var _ /* stop at bp+24 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _needed, _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, allocated, cachePtr, cachePtr1, cachePtr10, cachePtr11, cachePtr12, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cachePtr8, cachePtr9, code, complete, errCode, incomplete, incompletePtr, insertMark, lastParsed, limit, mark, msg, nestedPtr, newPtr, newPtr1, nodePtr, nodes, nodesAvailable, nodesUsed, oldPtr, post, precedence, scanned, scanned2, size, subErrCode, tokenPtr, wordIndex, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v6, v7, v8, v9
	nodes = libc.UintptrFromInt32(0) /* Pointer to the OpNode storage array where
	 * we build the parse tree. */
	nodesAvailable = uint32(64) /* Initial size of the storage array. This
	 * value establishes a minimum tree memory
	 * cost of only about 1 kilobyte, and is large
	 * enough for most expressions to parse with
	 * no need for array growth and
	 * reallocation. */
	nodesUsed = uint32(0) /* Number of OpNodes filled. */
	scanned = 0           /* Index of the most recent incomplete tree in
	 * the OpNode array. Heads a stack of
	 * incomplete trees linked by p.prev. */
	complete = int32(OT_EMPTY) /* "Index" of the complete tree (that is, a
	 * complete subexpression) determined at the
	 * moment. OT_EMPTY is a nonsense value used
	 * only to silence compiler warnings. During a
	 * parse, complete will always hold an index
	 * or an OperandTypes value pointing to an
	 * actual leaf at the time the complete tree
	 * is needed. */
	/*
	 * These variables control generation of the error message.
	 */
	msg = libc.UintptrFromInt32(0)  /* The error message. */
	post = libc.UintptrFromInt32(0) /* In a few cases, an additional postscript
	 * for the error message, supplying more
	 * information after the error msg and
	 * location have been reported. */
	errCode = libc.UintptrFromInt32(0) /* The detail word of the errorCode list, or
	 * NULL to indicate that no changes to the
	 * errorCode are to be done. */
	subErrCode = libc.UintptrFromInt32(0)
	/* Extra information for use in generating the
	 * errorCode. */
	mark = __ccgo_ts + 22390 /* In the portion of the complete error
	 * message where the error location is
	 * reported, this "mark" substring is inserted
	 * into the string being parsed to aid in
	 * pinpointing the location of the syntax
	 * error in the expression. */
	insertMark = 0 /* A boolean controlling whether the "mark"
	 * should be inserted. */
	limit = int32(25) /* Portions of the error message are
	 * constructed out of substrings of the
	 * original expression. In order to keep the
	 * error message readable, we impose this
	 * limit on the substring size we extract. */
	XTclParseInit(tls, interp, start, numBytes, parsePtr)
	nodes = XTclpAlloc(tls, uint64(nodesAvailable)*uint64(16))
	if nodes == libc.UintptrFromInt32(0) {
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			msg = XTclThreadAllocObj(tls)
		} else {
			msg = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(msg + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(msg)).FrefCount = 0
		if libc.Uint64FromInt64(38)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(msg)).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(38)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes, __ccgo_ts+22394, libc.Uint64FromInt64(38)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes + uintptr(libc.Uint64FromInt64(38)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(msg)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(38) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer(msg)).FtypePtr = libc.UintptrFromInt32(0)
		errCode = __ccgo_ts + 22432
		goto error
	}
	/*
	 * Initialize the parse tree with the special "START" node.
	 */
	(*TOpNode)(unsafe.Pointer(nodes)).Flexeme = uint8(START)
	(*TOpNode)(unsafe.Pointer(nodes)).Fprecedence = _prec[int32(START)]
	(*TOpNode)(unsafe.Pointer(nodes)).Fmark = uint8(MARK_RIGHT)
	(*TOpNode)(unsafe.Pointer(nodes)).Fconstant = uint8(1)
	v2 = libc.Int32FromUint32(nodesUsed)
	lastParsed = v2
	incomplete = v2
	nodesUsed++
	/*
	 * Main parsing loop parses one lexeme per iteration. We exit the loop
	 * only when there's a syntax error with a "goto error" which takes us to
	 * the error handling code following the loop, or when we've successfully
	 * completed the parse and we return to the caller.
	 */
	for int32(1) != 0 { /* Filled by the ParseLexeme() call when a
		 * literal is parsed that has a Tcl_Obj rep
		 * worth preserving. */
		/*
		 * Each pass through this loop adds up to one more OpNode. Allocate
		 * space for one if required.
		 */
		if nodesUsed >= nodesAvailable {
			size = nodesUsed * uint32(2)
			newPtr = libc.UintptrFromInt32(0)
			for {
				if uint64(size) <= libc.Uint64FromUint32(0xffffffff)/libc.Uint64FromInt64(16) {
					newPtr = XTclpRealloc(tls, nodes, uint64(size)*uint64(16))
				}
				goto _4
			_4:
				;
				if v3 = newPtr == libc.UintptrFromInt32(0); v3 {
					size -= (size - nodesUsed) / uint32(2)
				}
				if !(v3 && size > nodesUsed) {
					break
				}
			}
			if newPtr == libc.UintptrFromInt32(0) {
				if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
					cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v5 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
					msg = XTclThreadAllocObj(tls)
				} else {
					msg = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(msg + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(msg)).FrefCount = 0
				if libc.Uint64FromInt64(38)-libc.Uint64FromInt32(1) == uint64(0) {
					(*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(msg)).Flength = int64(libc.Int32FromInt32(0))
				} else {
					(*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(38)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
					libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes, __ccgo_ts+22394, libc.Uint64FromInt64(38)-libc.Uint64FromInt32(1))
					*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes + uintptr(libc.Uint64FromInt64(38)-libc.Uint64FromInt32(1)))) = uint8('\000')
					(*TTcl_Obj)(unsafe.Pointer(msg)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(38) - libc.Uint64FromInt32(1))
				}
				(*TTcl_Obj)(unsafe.Pointer(msg)).FtypePtr = libc.UintptrFromInt32(0)
				errCode = __ccgo_ts + 22432
				goto error
			}
			nodesAvailable = size
			nodes = newPtr
		}
		nodePtr = nodes + uintptr(nodesUsed)*16
		/*
		 * Skip white space between lexemes.
		 */
		scanned = XTclParseAllWhiteSpace(tls, start, numBytes)
		start += uintptr(scanned)
		numBytes -= scanned
		scanned = _ParseLexeme(tls, start, numBytes, bp, bp+8)
		/*
		 * Use context to categorize the lexemes that are ambiguous.
		 */
		if int32(NODE_TYPE)&libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == 0 {
			switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) {
			case int32(COMMENT):
				start += uintptr(scanned)
				numBytes -= scanned
				continue
			case int32(INVALID):
				msg = XTcl_ObjPrintf(tls, __ccgo_ts+22438, libc.VaList(bp+48, int32(scanned), start))
				errCode = __ccgo_ts + 22463
				goto error
			case int32(INCOMPLETE):
				msg = XTcl_ObjPrintf(tls, __ccgo_ts+22471, libc.VaList(bp+48, int32(scanned), start))
				errCode = __ccgo_ts + 22498
				goto error
			case int32(BAREWORD):
				/*
				 * Most barewords in an expression are a syntax error. The
				 * exceptions are that when a bareword is followed by an open
				 * paren, it might be a function call, and when the bareword
				 * is a legal literal boolean value, we accept that as well.
				 */
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start + uintptr(scanned+XTclParseAllWhiteSpace(tls, start+uintptr(scanned), numBytes-scanned))))) == int32('(') {
					*(*uint8)(unsafe.Pointer(bp)) = uint8(FUNCTION)
					/*
					 * When we compile the expression we'll need the function
					 * name, and there's no place in the parse tree to store
					 * it, so we keep a separate list of all the function
					 * names we've parsed in the order we found them.
					 */
					XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), funcList, *(*uintptr)(unsafe.Pointer(bp + 8)))
				} else {
					if XTcl_GetBoolFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 8)), (libc.Int32FromInt32(TCL_NULL_OK)-libc.Int32FromInt32(2))&libc.Int32FromInt64(4), bp+16) == TCL_OK {
						*(*uint8)(unsafe.Pointer(bp)) = uint8(BOOL_LIT)
					} else {
						/*
						 * Tricky case: see test expr-62.10
						 */
						scanned2 = int32(scanned)
						for cond := true; cond; cond = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32(COMMENT) {
							scanned2 = int32(int64(scanned2) + XTclParseAllWhiteSpace(tls, start+uintptr(scanned2), numBytes-int64(scanned2)))
							scanned2 = int32(int64(scanned2) + _ParseLexeme(tls, start+uintptr(scanned2), numBytes-int64(scanned2), bp, libc.UintptrFromInt32(0)))
						}
						if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32(OPEN_PAREN) {
							/*
							 * Actually a function call, but with obscuring
							 * comments.  Skip to the start of the parentheses.
							 * Note that we assume that open parentheses are one
							 * byte long.
							 */
							*(*uint8)(unsafe.Pointer(bp)) = uint8(FUNCTION)
							XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), funcList, *(*uintptr)(unsafe.Pointer(bp + 8)))
							scanned = int64(scanned2 - int32(1))
							break
						}
						_objPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
						v7 = _objPtr
						v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
						*(*TTcl_Size)(unsafe.Pointer(v7))--
						if v6 <= int64(1) {
							XTclFreeObj(tls, _objPtr)
						}
						if scanned < int64(limit) {
							v8 = scanned
						} else {
							v8 = int64(limit - int32(3))
						}
						if scanned < int64(limit) {
							v9 = __ccgo_ts + 1945
						} else {
							v9 = __ccgo_ts + 8560
						}
						msg = XTcl_ObjPrintf(tls, __ccgo_ts+22505, libc.VaList(bp+48, int32(v8), start, v9))
						if scanned < int64(limit) {
							v10 = scanned
						} else {
							v10 = int64(limit - int32(3))
						}
						if scanned < int64(limit) {
							v11 = __ccgo_ts + 1945
						} else {
							v11 = __ccgo_ts + 8560
						}
						if scanned < int64(limit) {
							v12 = scanned
						} else {
							v12 = int64(limit - int32(3))
						}
						if scanned < int64(limit) {
							v13 = __ccgo_ts + 1945
						} else {
							v13 = __ccgo_ts + 8560
						}
						post = XTcl_ObjPrintf(tls, __ccgo_ts+22531, libc.VaList(bp+48, int32(v10), start, v11, int32(v12), start, v13))
						if scanned < int64(limit) {
							v14 = scanned
						} else {
							v14 = int64(limit - int32(3))
						}
						if scanned < int64(limit) {
							v15 = __ccgo_ts + 1945
						} else {
							v15 = __ccgo_ts + 8560
						}
						XTcl_AppendPrintfToObj(tls, post, __ccgo_ts+22565, libc.VaList(bp+48, int32(v14), start, v15))
						errCode = __ccgo_ts + 22590
						if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start))) == int32('0') {
							XTclParseNumber(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), start, scanned, bp+24, int32(TCL_PARSE_NO_WHITESPACE))
							if libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))))-uint32('0') < uint32(10)) != 0 || *(*uintptr)(unsafe.Pointer(bp + 24)) == start+uintptr(1) {
								switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start + 1))) {
								case int32('b'):
									XTcl_AppendToObj(tls, post, __ccgo_ts+22599, int64(-int32(1)))
									(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FerrorType = int32(TCL_PARSE_BAD_NUMBER)
									errCode = __ccgo_ts + 22625
									subErrCode = __ccgo_ts + 11120
								case int32('o'):
									XTcl_AppendToObj(tls, post, __ccgo_ts+22635, int64(-int32(1)))
									(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FerrorType = int32(TCL_PARSE_BAD_NUMBER)
									errCode = __ccgo_ts + 22625
									subErrCode = __ccgo_ts + 22660
								default:
									if libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(start + 1)))-uint32('0') < uint32(10)) != 0 {
										XTcl_AppendToObj(tls, post, __ccgo_ts+22635, int64(-int32(1)))
										(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FerrorType = int32(TCL_PARSE_BAD_NUMBER)
										errCode = __ccgo_ts + 22625
										subErrCode = __ccgo_ts + 22660
									}
									break
								}
							}
						}
						goto error
					}
				}
			case int32(PLUS):
				fallthrough
			case int32(MINUS):
				if lastParsed >= 0 {
					/*
					 * A "+" or "-" coming just after another operator must be
					 * interpreted as a unary operator.
					 */
					*(*uint8)(unsafe.Pointer(bp)) = uint8(int32(*(*uint8)(unsafe.Pointer(bp))) | int32(UNARY))
				} else {
					*(*uint8)(unsafe.Pointer(bp)) = uint8(int32(*(*uint8)(unsafe.Pointer(bp))) | int32(BINARY))
				}
			}
		} /* Uncategorized lexemes */
		/*
		 * Handle lexeme based on its category.
		 */
		switch int32(NODE_TYPE) & libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) {
		case int32(LEAF):
			*(*uintptr)(unsafe.Pointer(bp + 32)) = start
			code = TCL_OK
			/*
			 * A leaf operand appearing just after something that's not an
			 * operator is a syntax error.
			 */
			if lastParsed < 0 {
				msg = XTcl_ObjPrintf(tls, __ccgo_ts+22666, libc.VaList(bp+48, mark))
				errCode = __ccgo_ts + 17673
				scanned = 0
				insertMark = int32(1)
				/*
				 * Free any literal to avoid a memleak.
				 */
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32(NUMBER) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32(BOOL_LIT) {
					_objPtr1 = *(*uintptr)(unsafe.Pointer(bp + 8))
					v17 = _objPtr1
					v16 = *(*TTcl_Size)(unsafe.Pointer(v17))
					*(*TTcl_Size)(unsafe.Pointer(v17))--
					if v16 <= int64(1) {
						XTclFreeObj(tls, _objPtr1)
					}
				}
				goto error
			}
			switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) {
			case int32(NUMBER):
				fallthrough
			case int32(BOOL_LIT):
				/*
				 * TODO: Consider using a dict or hash to collapse all
				 * duplicate literals into a single representative value.
				 * (Like what is done with [split $s {}]).
				 * Pro:	~75% memory saving on expressions like
				 *	{1+1+1+1+1+.....+1} (Convert "pointer + Tcl_Obj" cost
				 *	to "pointer" cost only)
				 * Con:	Cost of the dict store/retrieve on every literal in
				 *	every expression when expressions like the above tend
				 *	to be uncommon.
				 *	The memory savings is temporary; Compiling to bytecode
				 *	will collapse things as literals are registered
				 *	anyway, so the savings applies only to the time
				 *	between parsing and compiling. Possibly important due
				 *	to high-water mark nature of memory allocation.
				 */
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), litList, *(*uintptr)(unsafe.Pointer(bp + 8)))
				v18 = int32(OT_LITERAL)
				lastParsed = v18
				complete = v18
				start += uintptr(scanned)
				numBytes -= scanned
				continue
			default:
				break
			}
			/*
			 * Remaining LEAF cases may involve filling Tcl_Tokens, so make
			 * room for at least 2 more tokens.
			 */
			_needed = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens + int64(libc.Int32FromInt32(2))
			if _needed > (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokensAvailable {
				allocated = int64(2) * _needed
				oldPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
				if oldPtr == parsePtr+104 {
					oldPtr = libc.UintptrFromInt32(0)
				}
				newPtr1 = XTclpRealloc(tls, oldPtr, libc.Uint64FromInt64(allocated)*uint64(32))
				if newPtr1 == libc.UintptrFromInt32(0) {
					allocated = libc.Int64FromUint64(libc.Uint64FromInt64(_needed+int64(libc.Int32FromInt32(2))) + libc.Uint64FromInt32(TCL_MIN_GROWTH)/libc.Uint64FromInt64(32))
					newPtr1 = XTcl_Realloc(tls, oldPtr, libc.Uint64FromInt64(allocated)*uint64(32))
				}
				(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokensAvailable = allocated
				if oldPtr == libc.UintptrFromInt32(0) {
					libc.Xmemcpy(tls, newPtr1, parsePtr+104, libc.Uint64FromInt64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens)*uint64(32))
				}
				(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr = newPtr1
			}
			wordIndex = int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens)
			tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr(wordIndex)*32
			(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 = int32(TCL_TOKEN_WORD)
			(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart = start
			(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens++
			switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) {
			case int32(QUOTED):
				code = XTcl_ParseQuotedString(tls, libc.UintptrFromInt32(0), start, numBytes, parsePtr, int32(1), bp+32)
				scanned = int64(*(*uintptr)(unsafe.Pointer(bp + 32))) - int64(start)
			case int32(BRACED):
				code = XTcl_ParseBraces(tls, libc.UintptrFromInt32(0), start, numBytes, parsePtr, int32(1), bp+32)
				scanned = int64(*(*uintptr)(unsafe.Pointer(bp + 32))) - int64(start)
			case int32(VARIABLE):
				code = XTcl_ParseVarName(tls, libc.UintptrFromInt32(0), start, numBytes, parsePtr, int32(1))
				/*
				 * Handle the quirk that Tcl_ParseVarName reports a successful
				 * parse even when it gets only a "$" with no variable name.
				 */
				tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr(wordIndex)*32 + uintptr(1)*32
				if code == TCL_OK && (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 != int32(TCL_TOKEN_VARIABLE) {
					if v19 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v19 {
						cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v19 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
						msg = XTclThreadAllocObj(tls)
					} else {
						msg = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(msg + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer(msg)).FrefCount = 0
					if libc.Uint64FromInt64(22)-libc.Uint64FromInt32(1) == uint64(0) {
						(*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
						(*TTcl_Obj)(unsafe.Pointer(msg)).Flength = int64(libc.Int32FromInt32(0))
					} else {
						(*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(22)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
						libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes, __ccgo_ts+22689, libc.Uint64FromInt64(22)-libc.Uint64FromInt32(1))
						*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes + uintptr(libc.Uint64FromInt64(22)-libc.Uint64FromInt32(1)))) = uint8('\000')
						(*TTcl_Obj)(unsafe.Pointer(msg)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(22) - libc.Uint64FromInt32(1))
					}
					(*TTcl_Obj)(unsafe.Pointer(msg)).FtypePtr = libc.UintptrFromInt32(0)
					errCode = __ccgo_ts + 22463
					goto error
				}
				scanned = (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize
			case int32(SCRIPT):
				nestedPtr = XTclStackAlloc(tls, interp, uint64(744))
				tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens)*32
				(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 = int32(TCL_TOKEN_COMMAND)
				(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart = start
				(*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents = 0
				*(*uintptr)(unsafe.Pointer(bp + 32)) = start + uintptr(numBytes)
				start++
				for int32(1) != 0 {
					code = XTcl_ParseCommand(tls, interp, start, int64(*(*uintptr)(unsafe.Pointer(bp + 32)))-int64(start), int32(1), nestedPtr)
					if code != TCL_OK {
						(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm = (*TTcl_Parse)(unsafe.Pointer(nestedPtr)).Fterm
						(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FerrorType = (*TTcl_Parse)(unsafe.Pointer(nestedPtr)).FerrorType
						(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fincomplete = (*TTcl_Parse)(unsafe.Pointer(nestedPtr)).Fincomplete
						break
					}
					start = (*TTcl_Parse)(unsafe.Pointer(nestedPtr)).FcommandStart + uintptr((*TTcl_Parse)(unsafe.Pointer(nestedPtr)).FcommandSize)
					XTcl_FreeParse(tls, nestedPtr)
					if (*TTcl_Parse)(unsafe.Pointer(nestedPtr)).Fterm < *(*uintptr)(unsafe.Pointer(bp + 32)) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(nestedPtr)).Fterm))) == int32(']') && !((*TTcl_Parse)(unsafe.Pointer(nestedPtr)).Fincomplete != 0) {
						break
					}
					if start == *(*uintptr)(unsafe.Pointer(bp + 32)) {
						if v20 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v20 {
							cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v20 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
							msg = XTclThreadAllocObj(tls)
						} else {
							msg = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(msg + 32))).Fptr1
							(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
						}
						(*TTcl_Obj)(unsafe.Pointer(msg)).FrefCount = 0
						if libc.Uint64FromInt64(22)-libc.Uint64FromInt32(1) == uint64(0) {
							(*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
							(*TTcl_Obj)(unsafe.Pointer(msg)).Flength = int64(libc.Int32FromInt32(0))
						} else {
							(*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(22)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
							libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes, __ccgo_ts+22711, libc.Uint64FromInt64(22)-libc.Uint64FromInt32(1))
							*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes + uintptr(libc.Uint64FromInt64(22)-libc.Uint64FromInt32(1)))) = uint8('\000')
							(*TTcl_Obj)(unsafe.Pointer(msg)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(22) - libc.Uint64FromInt32(1))
						}
						(*TTcl_Obj)(unsafe.Pointer(msg)).FtypePtr = libc.UintptrFromInt32(0)
						(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm = (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart
						(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FerrorType = int32(TCL_PARSE_MISSING_BRACKET)
						(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fincomplete = int32(1)
						code = int32(TCL_ERROR)
						errCode = __ccgo_ts + 19420
						break
					}
				}
				XTclStackFree(tls, interp, nestedPtr)
				*(*uintptr)(unsafe.Pointer(bp + 32)) = start
				start = (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart
				scanned = int64(*(*uintptr)(unsafe.Pointer(bp + 32))) - int64(start)
				(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize = scanned
				(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens++
				break
				/* SCRIPT case */
			}
			if code != TCL_OK {
				/*
				 * Here we handle all the syntax errors generated by the
				 * Tcl_Token generating parsing routines called in the switch
				 * just above. If the value of parsePtr->incomplete is 1, then
				 * the error was an unbalanced '[', '(', '{', or '"' and
				 * parsePtr->term is pointing to that unbalanced character. If
				 * the value of parsePtr->incomplete is 0, then the error is
				 * one of lacking whitespace following a quoted word, for
				 * example: expr {[an error {foo}bar]}, and parsePtr->term
				 * points to where the whitespace is missing. We reset our
				 * values of start and scanned so that when our error message
				 * is constructed, the location of the syntax error is sure to
				 * appear in it, even if the quoted expression is truncated.
				 */
				start = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm
				scanned = int64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fincomplete)
				if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fincomplete != 0 {
					errCode = __ccgo_ts + 19420
				}
				goto error
			}
			tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr(wordIndex)*32
			(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize = scanned
			(*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens - int64(wordIndex) - int64(1)
			if !(parseOnly != 0) && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32(QUOTED) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32(BRACED)) {
				/*
				 * When this expression is destined to be compiled, and a
				 * braced or quoted word within an expression is known at
				 * compile time (no runtime substitutions in it), we can store
				 * it as a literal rather than in its tokenized form. This is
				 * an advantage since the compiled bytecode is going to need
				 * the argument in Tcl_Obj form eventually, so it's just as
				 * well to get there now. Another advantage is that with this
				 * conversion, larger constant expressions might be grown and
				 * optimized.
				 *
				 * On the contrary, if the end goal of this parse is to fill a
				 * Tcl_Parse for a caller of Tcl_ParseExpr(), then it's
				 * wasteful to convert to a literal only to convert back again
				 * later.
				 */
				if v21 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v21 {
					cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v21 || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == libc.Uint64FromInt32(0) {
					*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
				} else {
					*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = 0
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = libc.UintptrFromInt32(0)
				if XTclWordKnownAtCompileTime(tls, tokenPtr, *(*uintptr)(unsafe.Pointer(bp + 8))) != 0 {
					XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), litList, *(*uintptr)(unsafe.Pointer(bp + 8)))
					v22 = int32(OT_LITERAL)
					lastParsed = v22
					complete = v22
					(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens = int64(wordIndex)
					break
				}
				_objPtr2 = *(*uintptr)(unsafe.Pointer(bp + 8))
				v24 = _objPtr2
				v23 = *(*TTcl_Size)(unsafe.Pointer(v24))
				*(*TTcl_Size)(unsafe.Pointer(v24))--
				if v23 <= int64(1) {
					XTclFreeObj(tls, _objPtr2)
				}
			}
			v25 = int32(OT_TOKENS)
			lastParsed = v25
			complete = v25
			break
			/* case LEAF */
			fallthrough
		case int32(UNARY):
			/*
			 * A unary operator appearing just after something that's not an
			 * operator is a syntax error -- something trying to be the left
			 * operand of an operator that doesn't take one.
			 */
			if lastParsed < 0 {
				msg = XTcl_ObjPrintf(tls, __ccgo_ts+22666, libc.VaList(bp+48, mark))
				scanned = 0
				insertMark = int32(1)
				errCode = __ccgo_ts + 17673
				goto error
			}
			/*
			 * Create an OpNode for the unary operator.
			 */
			(*TOpNode)(unsafe.Pointer(nodePtr)).Flexeme = *(*uint8)(unsafe.Pointer(bp))
			(*TOpNode)(unsafe.Pointer(nodePtr)).Fprecedence = _prec[*(*uint8)(unsafe.Pointer(bp))]
			(*TOpNode)(unsafe.Pointer(nodePtr)).Fmark = uint8(MARK_RIGHT)
			/*
			 * A FUNCTION cannot be a constant expression, because Tcl allows
			 * functions to return variable results with the same arguments;
			 * for example, rand(). Other unary operators can root a constant
			 * expression, so long as the argument is a constant expression.
			 */
			(*TOpNode)(unsafe.Pointer(nodePtr)).Fconstant = libc.BoolUint8(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) != int32(FUNCTION))
			/*
			 * This unary operator is a new incomplete tree, so push it onto
			 * our stack of incomplete trees. Also remember it as the last
			 * lexeme we parsed.
			 */
			*(*int32)(unsafe.Pointer(nodePtr + 8)) = incomplete
			v26 = libc.Int32FromUint32(nodesUsed)
			lastParsed = v26
			incomplete = v26
			nodesUsed++
		case int32(BINARY):
			precedence = _prec[*(*uint8)(unsafe.Pointer(bp))]
			/*
			 * A binary operator appearing just after another operator is a
			 * syntax error -- one of the two operators is missing an operand.
			 */
			if lastParsed >= 0 {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32(CLOSE_PAREN) && libc.Int32FromUint8((*(*TOpNode)(unsafe.Pointer(nodePtr + uintptr(-libc.Int32FromInt32(1))*16))).Flexeme) == int32(OPEN_PAREN) {
					if libc.Int32FromUint8((*(*TOpNode)(unsafe.Pointer(nodePtr + uintptr(-libc.Int32FromInt32(2))*16))).Flexeme) == int32(FUNCTION) {
						/*
						 * Normally, "()" is a syntax error, but as a special
						 * case accept it as an argument list for a function.
						 * Treat this as a special LEAF lexeme, and restart
						 * the parsing loop with zero characters scanned. We
						 * will parse the ")" again the next time through, but
						 * with the OT_EMPTY leaf as the subexpression between
						 * the parens.
						 */
						scanned = 0
						v27 = int32(OT_EMPTY)
						lastParsed = v27
						complete = v27
						break
					}
					msg = XTcl_ObjPrintf(tls, __ccgo_ts+22733, libc.VaList(bp+48, mark))
					scanned = 0
					insertMark = int32(1)
					errCode = __ccgo_ts + 22759
					goto error
				}
				if libc.Int32FromUint8((*(*TOpNode)(unsafe.Pointer(nodePtr + uintptr(-libc.Int32FromInt32(1))*16))).Fprecedence) > libc.Int32FromUint8(precedence) {
					if libc.Int32FromUint8((*(*TOpNode)(unsafe.Pointer(nodePtr + uintptr(-libc.Int32FromInt32(1))*16))).Flexeme) == int32(OPEN_PAREN) {
						if v28 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v28 {
							cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v28 || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == libc.Uint64FromInt32(0) {
							msg = XTclThreadAllocObj(tls)
						} else {
							msg = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = (*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(msg + 32))).Fptr1
							(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects--
						}
						(*TTcl_Obj)(unsafe.Pointer(msg)).FrefCount = 0
						if libc.Uint64FromInt64(22)-libc.Uint64FromInt32(1) == uint64(0) {
							(*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
							(*TTcl_Obj)(unsafe.Pointer(msg)).Flength = int64(libc.Int32FromInt32(0))
						} else {
							(*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(22)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
							libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes, __ccgo_ts+22765, libc.Uint64FromInt64(22)-libc.Uint64FromInt32(1))
							*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes + uintptr(libc.Uint64FromInt64(22)-libc.Uint64FromInt32(1)))) = uint8('\000')
							(*TTcl_Obj)(unsafe.Pointer(msg)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(22) - libc.Uint64FromInt32(1))
						}
						(*TTcl_Obj)(unsafe.Pointer(msg)).FtypePtr = libc.UintptrFromInt32(0)
						(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FerrorType = int32(TCL_PARSE_MISSING_PAREN)
						errCode = __ccgo_ts + 19420
					} else {
						if libc.Int32FromUint8((*(*TOpNode)(unsafe.Pointer(nodePtr + uintptr(-libc.Int32FromInt32(1))*16))).Flexeme) == int32(COMMA) {
							msg = XTcl_ObjPrintf(tls, __ccgo_ts+22787, libc.VaList(bp+48, mark))
							scanned = 0
							insertMark = int32(1)
							errCode = __ccgo_ts + 17673
						} else {
							if libc.Int32FromUint8((*(*TOpNode)(unsafe.Pointer(nodePtr + uintptr(-libc.Int32FromInt32(1))*16))).Flexeme) == int32(START) {
								if v29 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v29 {
									cachePtr6 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
								}
								if v29 || (*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects == libc.Uint64FromInt32(0) {
									msg = XTclThreadAllocObj(tls)
								} else {
									msg = (*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr
									(*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr = (*(*struct {
										Fptr1 uintptr
										Fptr2 uintptr
									})(unsafe.Pointer(msg + 32))).Fptr1
									(*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects--
								}
								(*TTcl_Obj)(unsafe.Pointer(msg)).FrefCount = 0
								if libc.Uint64FromInt64(17)-libc.Uint64FromInt32(1) == uint64(0) {
									(*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
									(*TTcl_Obj)(unsafe.Pointer(msg)).Flength = int64(libc.Int32FromInt32(0))
								} else {
									(*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(17)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
									libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes, __ccgo_ts+22819, libc.Uint64FromInt64(17)-libc.Uint64FromInt32(1))
									*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes + uintptr(libc.Uint64FromInt64(17)-libc.Uint64FromInt32(1)))) = uint8('\000')
									(*TTcl_Obj)(unsafe.Pointer(msg)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(17) - libc.Uint64FromInt32(1))
								}
								(*TTcl_Obj)(unsafe.Pointer(msg)).FtypePtr = libc.UintptrFromInt32(0)
								errCode = __ccgo_ts + 22759
							}
						}
					}
				} else {
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32(CLOSE_PAREN) {
						if v30 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v30 {
							cachePtr7 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v30 || (*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects == libc.Uint64FromInt32(0) {
							msg = XTclThreadAllocObj(tls)
						} else {
							msg = (*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr = (*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(msg + 32))).Fptr1
							(*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects--
						}
						(*TTcl_Obj)(unsafe.Pointer(msg)).FrefCount = 0
						if libc.Uint64FromInt64(23)-libc.Uint64FromInt32(1) == uint64(0) {
							(*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
							(*TTcl_Obj)(unsafe.Pointer(msg)).Flength = int64(libc.Int32FromInt32(0))
						} else {
							(*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(23)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
							libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes, __ccgo_ts+22836, libc.Uint64FromInt64(23)-libc.Uint64FromInt32(1))
							*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes + uintptr(libc.Uint64FromInt64(23)-libc.Uint64FromInt32(1)))) = uint8('\000')
							(*TTcl_Obj)(unsafe.Pointer(msg)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(23) - libc.Uint64FromInt32(1))
						}
						(*TTcl_Obj)(unsafe.Pointer(msg)).FtypePtr = libc.UintptrFromInt32(0)
						errCode = __ccgo_ts + 19420
					} else {
						if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32(COMMA) && libc.Int32FromUint8((*(*TOpNode)(unsafe.Pointer(nodePtr + uintptr(-libc.Int32FromInt32(1))*16))).Flexeme) == int32(OPEN_PAREN) && libc.Int32FromUint8((*(*TOpNode)(unsafe.Pointer(nodePtr + uintptr(-libc.Int32FromInt32(2))*16))).Flexeme) == int32(FUNCTION) {
							msg = XTcl_ObjPrintf(tls, __ccgo_ts+22787, libc.VaList(bp+48, mark))
							scanned = 0
							insertMark = int32(1)
							errCode = __ccgo_ts + 19420
						}
					}
				}
				if msg == libc.UintptrFromInt32(0) {
					msg = XTcl_ObjPrintf(tls, __ccgo_ts+22859, libc.VaList(bp+48, mark))
					scanned = 0
					insertMark = int32(1)
					errCode = __ccgo_ts + 17673
				}
				goto error
			}
			/*
			 * Here is where the tree comes together. At this point, we have a
			 * stack of incomplete trees corresponding to substrings that are
			 * incomplete expressions, followed by a complete tree
			 * corresponding to a substring that is itself a complete
			 * expression, followed by the binary operator we have just
			 * parsed. The incomplete trees can each be completed by adding a
			 * right operand.
			 *
			 * To illustrate with an example, when we parse the expression
			 * "1+2*3-4" and we reach this point having just parsed the "-"
			 * operator, we have these incomplete trees: START, "1+", and
			 * "2*". Next we have the complete subexpression "3". Last is the
			 * "-" we've just parsed.
			 *
			 * The next step is to join our complete tree to an operator. The
			 * choice is governed by the precedence and associativity of the
			 * competing operators. If we connect it as the right operand of
			 * our most recent incomplete tree, we get a new complete tree,
			 * and we can repeat the process. The while loop following repeats
			 * this until precedence indicates it is time to join the complete
			 * tree as the left operand of the just parsed binary operator.
			 *
			 * Continuing the example, the first pass through the loop will
			 * join "3" to "2*"; the next pass will join "2*3" to "1+". Then
			 * we'll exit the loop and join "1+2*3" to "-". When we return to
			 * parse another lexeme, our stack of incomplete trees is START
			 * and "1+2*3-".
			 */
			for int32(1) != 0 {
				incompletePtr = nodes + uintptr(incomplete)*16
				if libc.Int32FromUint8((*TOpNode)(unsafe.Pointer(incompletePtr)).Fprecedence) < libc.Int32FromUint8(precedence) {
					break
				}
				if libc.Int32FromUint8((*TOpNode)(unsafe.Pointer(incompletePtr)).Fprecedence) == libc.Int32FromUint8(precedence) {
					/*
					 * Right association rules for exponentiation.
					 */
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32(EXPON) {
						break
					}
					/*
					 * Special association rules for the conditional
					 * operators. The "?" and ":" operators have equal
					 * precedence, but must be linked up in sensible pairs.
					 */
					if libc.Int32FromUint8((*TOpNode)(unsafe.Pointer(incompletePtr)).Flexeme) == int32(QUESTION) && (complete < 0 || libc.Int32FromUint8((*(*TOpNode)(unsafe.Pointer(nodes + uintptr(complete)*16))).Flexeme) != int32(COLON)) {
						break
					}
					if libc.Int32FromUint8((*TOpNode)(unsafe.Pointer(incompletePtr)).Flexeme) == int32(COLON) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32(QUESTION) {
						break
					}
				}
				/*
				 * Some special syntax checks...
				 */
				/* Parens must balance */
				if libc.Int32FromUint8((*TOpNode)(unsafe.Pointer(incompletePtr)).Flexeme) == int32(OPEN_PAREN) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) != int32(CLOSE_PAREN) {
					if v31 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v31 {
						cachePtr8 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v31 || (*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects == libc.Uint64FromInt32(0) {
						msg = XTclThreadAllocObj(tls)
					} else {
						msg = (*TAllocCache)(unsafe.Pointer(cachePtr8)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr8)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(msg + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer(msg)).FrefCount = 0
					if libc.Uint64FromInt64(22)-libc.Uint64FromInt32(1) == uint64(0) {
						(*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
						(*TTcl_Obj)(unsafe.Pointer(msg)).Flength = int64(libc.Int32FromInt32(0))
					} else {
						(*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(22)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
						libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes, __ccgo_ts+22765, libc.Uint64FromInt64(22)-libc.Uint64FromInt32(1))
						*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes + uintptr(libc.Uint64FromInt64(22)-libc.Uint64FromInt32(1)))) = uint8('\000')
						(*TTcl_Obj)(unsafe.Pointer(msg)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(22) - libc.Uint64FromInt32(1))
					}
					(*TTcl_Obj)(unsafe.Pointer(msg)).FtypePtr = libc.UintptrFromInt32(0)
					(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FerrorType = int32(TCL_PARSE_MISSING_PAREN)
					errCode = __ccgo_ts + 19420
					goto error
				}
				/* Right operand of "?" must be ":" */
				if libc.Int32FromUint8((*TOpNode)(unsafe.Pointer(incompletePtr)).Flexeme) == int32(QUESTION) && (complete < 0 || libc.Int32FromUint8((*(*TOpNode)(unsafe.Pointer(nodes + uintptr(complete)*16))).Flexeme) != int32(COLON)) {
					msg = XTcl_ObjPrintf(tls, __ccgo_ts+22881, libc.VaList(bp+48, mark))
					scanned = 0
					insertMark = int32(1)
					errCode = __ccgo_ts + 17673
					goto error
				}
				/* Operator ":" may only be right operand of "?" */
				if complete >= 0 && libc.Int32FromUint8((*(*TOpNode)(unsafe.Pointer(nodes + uintptr(complete)*16))).Flexeme) == int32(COLON) && libc.Int32FromUint8((*TOpNode)(unsafe.Pointer(incompletePtr)).Flexeme) != int32(QUESTION) {
					if v32 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v32 {
						cachePtr9 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v32 || (*TAllocCache)(unsafe.Pointer(cachePtr9)).FnumObjects == libc.Uint64FromInt32(0) {
						msg = XTclThreadAllocObj(tls)
					} else {
						msg = (*TAllocCache)(unsafe.Pointer(cachePtr9)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr9)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(msg + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr9)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer(msg)).FrefCount = 0
					if libc.Uint64FromInt64(46)-libc.Uint64FromInt32(1) == uint64(0) {
						(*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
						(*TTcl_Obj)(unsafe.Pointer(msg)).Flength = int64(libc.Int32FromInt32(0))
					} else {
						(*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(46)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
						libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes, __ccgo_ts+22908, libc.Uint64FromInt64(46)-libc.Uint64FromInt32(1))
						*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes + uintptr(libc.Uint64FromInt64(46)-libc.Uint64FromInt32(1)))) = uint8('\000')
						(*TTcl_Obj)(unsafe.Pointer(msg)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(46) - libc.Uint64FromInt32(1))
					}
					(*TTcl_Obj)(unsafe.Pointer(msg)).FtypePtr = libc.UintptrFromInt32(0)
					errCode = __ccgo_ts + 22954
					goto error
				}
				/*
				 * Attach complete tree as right operand of most recent
				 * incomplete tree.
				 */
				(*TOpNode)(unsafe.Pointer(incompletePtr)).Fright = complete
				if complete >= 0 {
					*(*int32)(unsafe.Pointer(nodes + uintptr(complete)*16 + 8)) = incomplete
					(*TOpNode)(unsafe.Pointer(incompletePtr)).Fconstant = libc.BoolUint8((*TOpNode)(unsafe.Pointer(incompletePtr)).Fconstant != 0 && (*(*TOpNode)(unsafe.Pointer(nodes + uintptr(complete)*16))).Fconstant != 0)
				} else {
					(*TOpNode)(unsafe.Pointer(incompletePtr)).Fconstant = libc.BoolUint8((*TOpNode)(unsafe.Pointer(incompletePtr)).Fconstant != 0 && complete == int32(OT_LITERAL))
				}
				/*
				 * The QUESTION/COLON and FUNCTION/OPEN_PAREN combinations
				 * each make up a single operator. Force them to agree whether
				 * they have a constant expression.
				 */
				if libc.Int32FromUint8((*TOpNode)(unsafe.Pointer(incompletePtr)).Flexeme) == int32(QUESTION) || libc.Int32FromUint8((*TOpNode)(unsafe.Pointer(incompletePtr)).Flexeme) == int32(FUNCTION) {
					(*(*TOpNode)(unsafe.Pointer(nodes + uintptr(complete)*16))).Fconstant = (*TOpNode)(unsafe.Pointer(incompletePtr)).Fconstant
				}
				if libc.Int32FromUint8((*TOpNode)(unsafe.Pointer(incompletePtr)).Flexeme) == int32(START) {
					/*
					 * Completing the START tree indicates we're done.
					 * Transfer the parse tree to the caller and return.
					 */
					*(*uintptr)(unsafe.Pointer(opTreePtr)) = nodes
					return TCL_OK
				}
				/*
				 * With a right operand attached, last incomplete tree has
				 * become the complete tree. Pop it from the incomplete tree
				 * stack.
				 */
				complete = incomplete
				incomplete = *(*int32)(unsafe.Pointer(incompletePtr + 8))
				/* CLOSE_PAREN can only close one OPEN_PAREN. */
				if libc.Int32FromUint8((*TOpNode)(unsafe.Pointer(incompletePtr)).Flexeme) == int32(OPEN_PAREN) {
					break
				}
			}
			/*
			 * More syntax checks...
			 */
			/* Parens must balance. */
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32(CLOSE_PAREN) {
				if libc.Int32FromUint8((*TOpNode)(unsafe.Pointer(incompletePtr)).Flexeme) != int32(OPEN_PAREN) {
					if v33 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v33 {
						cachePtr10 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v33 || (*TAllocCache)(unsafe.Pointer(cachePtr10)).FnumObjects == libc.Uint64FromInt32(0) {
						msg = XTclThreadAllocObj(tls)
					} else {
						msg = (*TAllocCache)(unsafe.Pointer(cachePtr10)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr10)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(msg + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr10)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer(msg)).FrefCount = 0
					if libc.Uint64FromInt64(23)-libc.Uint64FromInt32(1) == uint64(0) {
						(*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
						(*TTcl_Obj)(unsafe.Pointer(msg)).Flength = int64(libc.Int32FromInt32(0))
					} else {
						(*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(23)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
						libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes, __ccgo_ts+22836, libc.Uint64FromInt64(23)-libc.Uint64FromInt32(1))
						*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes + uintptr(libc.Uint64FromInt64(23)-libc.Uint64FromInt32(1)))) = uint8('\000')
						(*TTcl_Obj)(unsafe.Pointer(msg)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(23) - libc.Uint64FromInt32(1))
					}
					(*TTcl_Obj)(unsafe.Pointer(msg)).FtypePtr = libc.UintptrFromInt32(0)
					errCode = __ccgo_ts + 19420
					goto error
				}
			}
			/* Commas must appear only in function argument lists. */
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32(COMMA) {
				if libc.Int32FromUint8((*TOpNode)(unsafe.Pointer(incompletePtr)).Flexeme) != int32(OPEN_PAREN) || libc.Int32FromUint8((*(*TOpNode)(unsafe.Pointer(incompletePtr + uintptr(-libc.Int32FromInt32(1))*16))).Flexeme) != int32(FUNCTION) {
					if v34 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v34 {
						cachePtr11 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v34 || (*TAllocCache)(unsafe.Pointer(cachePtr11)).FnumObjects == libc.Uint64FromInt32(0) {
						msg = XTclThreadAllocObj(tls)
					} else {
						msg = (*TAllocCache)(unsafe.Pointer(cachePtr11)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr11)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(msg + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr11)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer(msg)).FrefCount = 0
					if libc.Uint64FromInt64(46)-libc.Uint64FromInt32(1) == uint64(0) {
						(*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
						(*TTcl_Obj)(unsafe.Pointer(msg)).Flength = int64(libc.Int32FromInt32(0))
					} else {
						(*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(46)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
						libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes, __ccgo_ts+22963, libc.Uint64FromInt64(46)-libc.Uint64FromInt32(1))
						*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes + uintptr(libc.Uint64FromInt64(46)-libc.Uint64FromInt32(1)))) = uint8('\000')
						(*TTcl_Obj)(unsafe.Pointer(msg)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(46) - libc.Uint64FromInt32(1))
					}
					(*TTcl_Obj)(unsafe.Pointer(msg)).FtypePtr = libc.UintptrFromInt32(0)
					errCode = __ccgo_ts + 22954
					goto error
				}
			}
			/* Operator ":" may only be right operand of "?" */
			if complete >= 0 && libc.Int32FromUint8((*(*TOpNode)(unsafe.Pointer(nodes + uintptr(complete)*16))).Flexeme) == int32(COLON) {
				if v35 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v35 {
					cachePtr12 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v35 || (*TAllocCache)(unsafe.Pointer(cachePtr12)).FnumObjects == libc.Uint64FromInt32(0) {
					msg = XTclThreadAllocObj(tls)
				} else {
					msg = (*TAllocCache)(unsafe.Pointer(cachePtr12)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr12)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(msg + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr12)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(msg)).FrefCount = 0
				if libc.Uint64FromInt64(46)-libc.Uint64FromInt32(1) == uint64(0) {
					(*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(msg)).Flength = int64(libc.Int32FromInt32(0))
				} else {
					(*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(46)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
					libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes, __ccgo_ts+22908, libc.Uint64FromInt64(46)-libc.Uint64FromInt32(1))
					*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes + uintptr(libc.Uint64FromInt64(46)-libc.Uint64FromInt32(1)))) = uint8('\000')
					(*TTcl_Obj)(unsafe.Pointer(msg)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(46) - libc.Uint64FromInt32(1))
				}
				(*TTcl_Obj)(unsafe.Pointer(msg)).FtypePtr = libc.UintptrFromInt32(0)
				errCode = __ccgo_ts + 22954
				goto error
			}
			/*
			 * Create no node for a CLOSE_PAREN lexeme.
			 */
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32(CLOSE_PAREN) {
				break
			}
			/*
			 * Link complete tree as left operand of new node.
			 */
			(*TOpNode)(unsafe.Pointer(nodePtr)).Flexeme = *(*uint8)(unsafe.Pointer(bp))
			(*TOpNode)(unsafe.Pointer(nodePtr)).Fprecedence = precedence
			(*TOpNode)(unsafe.Pointer(nodePtr)).Fmark = uint8(MARK_LEFT)
			(*TOpNode)(unsafe.Pointer(nodePtr)).Fleft = complete
			/*
			 * The COMMA operator cannot be optimized, since the function
			 * needs all of its arguments, and optimization would reduce the
			 * number. Other binary operators root constant expressions when
			 * both arguments are constant expressions.
			 */
			(*TOpNode)(unsafe.Pointer(nodePtr)).Fconstant = libc.BoolUint8(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) != int32(COMMA))
			if complete >= 0 {
				*(*int32)(unsafe.Pointer(nodes + uintptr(complete)*16 + 8)) = libc.Int32FromUint32(nodesUsed)
				(*TOpNode)(unsafe.Pointer(nodePtr)).Fconstant = libc.BoolUint8((*TOpNode)(unsafe.Pointer(nodePtr)).Fconstant != 0 && (*(*TOpNode)(unsafe.Pointer(nodes + uintptr(complete)*16))).Fconstant != 0)
			} else {
				(*TOpNode)(unsafe.Pointer(nodePtr)).Fconstant = libc.BoolUint8((*TOpNode)(unsafe.Pointer(nodePtr)).Fconstant != 0 && complete == int32(OT_LITERAL))
			}
			/*
			 * With a left operand attached and a right operand missing, the
			 * just-parsed binary operator is root of a new incomplete tree.
			 * Push it onto the stack of incomplete trees.
			 */
			*(*int32)(unsafe.Pointer(nodePtr + 8)) = incomplete
			v36 = libc.Int32FromUint32(nodesUsed)
			lastParsed = v36
			incomplete = v36
			nodesUsed++
			break
			/* case BINARY */
		} /* lexeme handler */
		/* Advance past the just-parsed lexeme */
		start += uintptr(scanned)
		numBytes -= scanned
	} /* main parsing loop */
	/*
	 * We only get here if there's been an error. Any errors that didn't get a
	 * suitable parsePtr->errorType, get recorded as syntax errors.
	 */
	goto error
error:
	;
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FerrorType == TCL_PARSE_SUCCESS {
		(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FerrorType = int32(TCL_PARSE_SYNTAX)
	}
	/*
	 * Free any partial parse tree we've built.
	 */
	if nodes != libc.UintptrFromInt32(0) {
		XTclpFree(tls, nodes)
	}
	if interp == libc.UintptrFromInt32(0) {
		/*
		 * Nowhere to report an error message, so just free it.
		 */
		if msg != 0 {
			_objPtr3 = msg
			v38 = _objPtr3
			v37 = *(*TTcl_Size)(unsafe.Pointer(v38))
			*(*TTcl_Size)(unsafe.Pointer(v38))--
			if v37 <= int64(1) {
				XTclFreeObj(tls, _objPtr3)
			}
		}
	} else {
		/*
		 * Construct the complete error message. Start with the simple error
		 * message, pulled from the interp result if necessary...
		 */
		if msg == libc.UintptrFromInt32(0) {
			msg = XTcl_GetObjResult(tls, interp)
		}
		/*
		 * Add a detailed quote from the bad expression, displaying and
		 * sometimes marking the precise location of the syntax error.
		 */
		if start-uintptr(limit) < (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fstring1 {
			v39 = __ccgo_ts + 1945
		} else {
			v39 = __ccgo_ts + 8560
		}
		if start-uintptr(limit) < (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fstring1 {
			v40 = int32(int64(start) - int64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fstring1))
		} else {
			v40 = limit - int32(3)
		}
		if start-uintptr(limit) < (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fstring1 {
			v41 = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fstring1
		} else {
			v41 = start - uintptr(limit) + uintptr(3)
		}
		if scanned < int64(limit) {
			v42 = int32(scanned)
		} else {
			v42 = limit - int32(3)
		}
		if scanned < int64(limit) {
			v43 = __ccgo_ts + 1945
		} else {
			v43 = __ccgo_ts + 8560
		}
		if insertMark != 0 {
			v44 = mark
		} else {
			v44 = __ccgo_ts + 1945
		}
		if start+uintptr(scanned)+uintptr(limit) > (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fend {
			v45 = int32(int64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fend)-int64(start)) - int32(scanned)
		} else {
			v45 = limit - int32(3)
		}
		if start+uintptr(scanned)+uintptr(limit) > (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fend {
			v46 = __ccgo_ts + 1945
		} else {
			v46 = __ccgo_ts + 8560
		}
		XTcl_AppendPrintfToObj(tls, msg, __ccgo_ts+23009, libc.VaList(bp+48, v39, v40, v41, v42, start, v43, v44, v45, start+uintptr(scanned), v46))
		/*
		 * Next, append any postscript message.
		 */
		if post != libc.UintptrFromInt32(0) {
			XTcl_AppendToObj(tls, msg, __ccgo_ts+23047, int64(-int32(1)))
			XTcl_AppendObjToObj(tls, msg, post)
			_objPtr4 = post
			v48 = _objPtr4
			v47 = *(*TTcl_Size)(unsafe.Pointer(v48))
			*(*TTcl_Size)(unsafe.Pointer(v48))--
			if v47 <= int64(1) {
				XTclFreeObj(tls, _objPtr4)
			}
		}
		XTcl_SetObjResult(tls, interp, msg)
		/*
		 * Finally, place context information in the errorInfo.
		 */
		numBytes = int64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fend) - int64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fstring1)
		if numBytes < int64(limit) {
			v49 = int32(numBytes)
		} else {
			v49 = limit - int32(3)
		}
		if numBytes < int64(limit) {
			v50 = __ccgo_ts + 1945
		} else {
			v50 = __ccgo_ts + 8560
		}
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+23050, libc.VaList(bp+48, v49, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fstring1, v50)))
		if errCode != 0 {
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+48, __ccgo_ts+2004, __ccgo_ts+23085, __ccgo_ts+23091, errCode, subErrCode, libc.UintptrFromInt32(0)))
		}
	}
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * ConvertTreeToTokens --
 *
 *	Given a string, the numBytes bytes starting at start, and an OpNode
 *	tree and Tcl_Token array created by passing that same string to
 *	ParseExpr(), this function writes into *parsePtr the sequence of
 *	Tcl_Tokens needed so to satisfy the historical interface provided by
 *	Tcl_ParseExpr(). Note that this routine exists only for the sake of
 *	the public Tcl_ParseExpr() routine. It is not used by Tcl itself at
 *	all.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The Tcl_Parse *parsePtr is filled with Tcl_Tokens representing the
 *	parsed expression.
 *
 *----------------------------------------------------------------------
 */

func _ConvertTreeToTokens(tls *libc.TLS, start uintptr, numBytes TTcl_Size, nodes uintptr, tokenPtr uintptr, parsePtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _needed, _needed1, _needed2, _needed3, allocated, allocated1, allocated2, allocated3 TTcl_Size
	var newPtr, newPtr1, newPtr2, newPtr3, nodePtr, oldPtr, oldPtr1, oldPtr2, oldPtr3, subExprTokenPtr uintptr
	var next, parentIdx, scanned, subExprTokenIdx, toCopy int32
	var _ /* lexeme at bp+0 */ uint8
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _needed, _needed1, _needed2, _needed3, allocated, allocated1, allocated2, allocated3, newPtr, newPtr1, newPtr2, newPtr3, next, nodePtr, oldPtr, oldPtr1, oldPtr2, oldPtr3, parentIdx, scanned, subExprTokenIdx, subExprTokenPtr, toCopy
	subExprTokenIdx = 0
	nodePtr = nodes
	next = (*TOpNode)(unsafe.Pointer(nodePtr)).Fright
	for int32(1) != 0 {
		/*
		 * Advance the mark so the next exit from this node won't retrace
		 * steps over ground already covered.
		 */
		(*TOpNode)(unsafe.Pointer(nodePtr)).Fmark++
		/*
		 * Handle next child node or leaf.
		 */
		switch next {
		case int32(OT_EMPTY):
			/* No tokens and no characters for the OT_EMPTY leaf. */
		case int32(OT_LITERAL):
			/*
			 * Skip any white space that comes before the literal.
			 */
			scanned = int32(XTclParseAllWhiteSpace(tls, start, numBytes))
			start += uintptr(scanned)
			numBytes -= int64(scanned)
			/*
			 * Reparse the literal to get pointers into source string.
			 */
			scanned = int32(_ParseLexeme(tls, start, numBytes, bp, libc.UintptrFromInt32(0)))
			_needed = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens + int64(libc.Int32FromInt32(2))
			if _needed > (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokensAvailable {
				allocated = int64(2) * _needed
				oldPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
				if oldPtr == parsePtr+104 {
					oldPtr = libc.UintptrFromInt32(0)
				}
				newPtr = XTclpRealloc(tls, oldPtr, libc.Uint64FromInt64(allocated)*uint64(32))
				if newPtr == libc.UintptrFromInt32(0) {
					allocated = libc.Int64FromUint64(libc.Uint64FromInt64(_needed+int64(libc.Int32FromInt32(2))) + libc.Uint64FromInt32(TCL_MIN_GROWTH)/libc.Uint64FromInt64(32))
					newPtr = XTcl_Realloc(tls, oldPtr, libc.Uint64FromInt64(allocated)*uint64(32))
				}
				(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokensAvailable = allocated
				if oldPtr == libc.UintptrFromInt32(0) {
					libc.Xmemcpy(tls, newPtr, parsePtr+104, libc.Uint64FromInt64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens)*uint64(32))
				}
				(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr = newPtr
			}
			subExprTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens)*32
			(*TTcl_Token)(unsafe.Pointer(subExprTokenPtr)).Ftype1 = int32(TCL_TOKEN_SUB_EXPR)
			(*TTcl_Token)(unsafe.Pointer(subExprTokenPtr)).Fstart = start
			(*TTcl_Token)(unsafe.Pointer(subExprTokenPtr)).Fsize = int64(scanned)
			(*TTcl_Token)(unsafe.Pointer(subExprTokenPtr)).FnumComponents = int64(1)
			(*(*TTcl_Token)(unsafe.Pointer(subExprTokenPtr + 1*32))).Ftype1 = int32(TCL_TOKEN_TEXT)
			(*(*TTcl_Token)(unsafe.Pointer(subExprTokenPtr + 1*32))).Fstart = start
			(*(*TTcl_Token)(unsafe.Pointer(subExprTokenPtr + 1*32))).Fsize = int64(scanned)
			(*(*TTcl_Token)(unsafe.Pointer(subExprTokenPtr + 1*32))).FnumComponents = 0
			*(*TTcl_Size)(unsafe.Pointer(parsePtr + 48)) += int64(2)
			start += uintptr(scanned)
			numBytes -= int64(scanned)
		case int32(OT_TOKENS):
			/*
			 * tokenPtr points to a token sequence that came from parsing a
			 * Tcl word. A Tcl word is made up of a sequence of one or more
			 * elements. When the word is only a single element, it's been the
			 * historical practice to replace the TCL_TOKEN_WORD token
			 * directly with a TCL_TOKEN_SUB_EXPR token. However, when the
			 * word has multiple elements, a TCL_TOKEN_WORD token is kept as a
			 * grouping device so that TCL_TOKEN_SUB_EXPR always has only one
			 * element. Wise or not, these are the rules the Tcl expr parser
			 * has followed, and for the sake of those few callers of
			 * Tcl_ParseExpr() we do not change them now. Internally, we can
			 * do better.
			 */
			toCopy = int32((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents + int64(1))
			if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents == (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).FnumComponents+int64(1) {
				/*
				 * Single element word. Copy tokens and convert the leading
				 * token to TCL_TOKEN_SUB_EXPR.
				 */
				_needed1 = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens + int64(toCopy)
				if _needed1 > (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokensAvailable {
					allocated1 = int64(2) * _needed1
					oldPtr1 = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
					if oldPtr1 == parsePtr+104 {
						oldPtr1 = libc.UintptrFromInt32(0)
					}
					newPtr1 = XTclpRealloc(tls, oldPtr1, libc.Uint64FromInt64(allocated1)*uint64(32))
					if newPtr1 == libc.UintptrFromInt32(0) {
						allocated1 = libc.Int64FromUint64(libc.Uint64FromInt64(_needed1+int64(toCopy)) + libc.Uint64FromInt32(TCL_MIN_GROWTH)/libc.Uint64FromInt64(32))
						newPtr1 = XTcl_Realloc(tls, oldPtr1, libc.Uint64FromInt64(allocated1)*uint64(32))
					}
					(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokensAvailable = allocated1
					if oldPtr1 == libc.UintptrFromInt32(0) {
						libc.Xmemcpy(tls, newPtr1, parsePtr+104, libc.Uint64FromInt64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens)*uint64(32))
					}
					(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr = newPtr1
				}
				subExprTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens)*32
				libc.Xmemcpy(tls, subExprTokenPtr, tokenPtr, libc.Uint64FromInt32(toCopy)*uint64(32))
				(*TTcl_Token)(unsafe.Pointer(subExprTokenPtr)).Ftype1 = int32(TCL_TOKEN_SUB_EXPR)
				*(*TTcl_Size)(unsafe.Pointer(parsePtr + 48)) += int64(toCopy)
			} else {
				/*
				 * Multiple element word. Create a TCL_TOKEN_SUB_EXPR token to
				 * lead, with fields initialized from the leading token, then
				 * copy entire set of word tokens.
				 */
				_needed2 = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens + int64(toCopy+libc.Int32FromInt32(1))
				if _needed2 > (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokensAvailable {
					allocated2 = int64(2) * _needed2
					oldPtr2 = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
					if oldPtr2 == parsePtr+104 {
						oldPtr2 = libc.UintptrFromInt32(0)
					}
					newPtr2 = XTclpRealloc(tls, oldPtr2, libc.Uint64FromInt64(allocated2)*uint64(32))
					if newPtr2 == libc.UintptrFromInt32(0) {
						allocated2 = libc.Int64FromUint64(libc.Uint64FromInt64(_needed2+int64(toCopy+libc.Int32FromInt32(1))) + libc.Uint64FromInt32(TCL_MIN_GROWTH)/libc.Uint64FromInt64(32))
						newPtr2 = XTcl_Realloc(tls, oldPtr2, libc.Uint64FromInt64(allocated2)*uint64(32))
					}
					(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokensAvailable = allocated2
					if oldPtr2 == libc.UintptrFromInt32(0) {
						libc.Xmemcpy(tls, newPtr2, parsePtr+104, libc.Uint64FromInt64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens)*uint64(32))
					}
					(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr = newPtr2
				}
				subExprTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens)*32
				*(*TTcl_Token)(unsafe.Pointer(subExprTokenPtr)) = *(*TTcl_Token)(unsafe.Pointer(tokenPtr))
				(*TTcl_Token)(unsafe.Pointer(subExprTokenPtr)).Ftype1 = int32(TCL_TOKEN_SUB_EXPR)
				(*TTcl_Token)(unsafe.Pointer(subExprTokenPtr)).FnumComponents++
				subExprTokenPtr += 32
				libc.Xmemcpy(tls, subExprTokenPtr, tokenPtr, libc.Uint64FromInt32(toCopy)*uint64(32))
				*(*TTcl_Size)(unsafe.Pointer(parsePtr + 48)) += int64(toCopy + int32(1))
			}
			scanned = int32(int64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart+uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize)) - int64(start))
			start += uintptr(scanned)
			numBytes -= int64(scanned)
			tokenPtr += uintptr(toCopy) * 32
		default:
			/*
			 * Advance to the child node, which is an operator.
			 */
			nodePtr = nodes + uintptr(next)*16
			/*
			 * Skip any white space that comes before the subexpression.
			 */
			scanned = int32(XTclParseAllWhiteSpace(tls, start, numBytes))
			start += uintptr(scanned)
			numBytes -= int64(scanned)
			/*
			 * Generate tokens for the operator / subexpression...
			 */
			switch libc.Int32FromUint8((*TOpNode)(unsafe.Pointer(nodePtr)).Flexeme) {
			case int32(OPEN_PAREN):
				fallthrough
			case int32(COMMA):
				fallthrough
			case int32(COLON):
				/*
				 * Historical practice has been to have no Tcl_Tokens for
				 * these operators.
				 */
			default:
				/*
				 * Remember the index of the last subexpression we were
				 * working on -- that of our parent. We'll stack it later.
				 */
				parentIdx = subExprTokenIdx
				/*
				 * Verify space for the two leading Tcl_Tokens representing
				 * the subexpression rooted by this operator. The first
				 * Tcl_Token will be of type TCL_TOKEN_SUB_EXPR; the second of
				 * type TCL_TOKEN_OPERATOR.
				 */
				_needed3 = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens + int64(libc.Int32FromInt32(2))
				if _needed3 > (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokensAvailable {
					allocated3 = int64(2) * _needed3
					oldPtr3 = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
					if oldPtr3 == parsePtr+104 {
						oldPtr3 = libc.UintptrFromInt32(0)
					}
					newPtr3 = XTclpRealloc(tls, oldPtr3, libc.Uint64FromInt64(allocated3)*uint64(32))
					if newPtr3 == libc.UintptrFromInt32(0) {
						allocated3 = libc.Int64FromUint64(libc.Uint64FromInt64(_needed3+int64(libc.Int32FromInt32(2))) + libc.Uint64FromInt32(TCL_MIN_GROWTH)/libc.Uint64FromInt64(32))
						newPtr3 = XTcl_Realloc(tls, oldPtr3, libc.Uint64FromInt64(allocated3)*uint64(32))
					}
					(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokensAvailable = allocated3
					if oldPtr3 == libc.UintptrFromInt32(0) {
						libc.Xmemcpy(tls, newPtr3, parsePtr+104, libc.Uint64FromInt64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens)*uint64(32))
					}
					(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr = newPtr3
				}
				subExprTokenIdx = int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens)
				subExprTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr(subExprTokenIdx)*32
				*(*TTcl_Size)(unsafe.Pointer(parsePtr + 48)) += int64(2)
				(*TTcl_Token)(unsafe.Pointer(subExprTokenPtr)).Ftype1 = int32(TCL_TOKEN_SUB_EXPR)
				(*(*TTcl_Token)(unsafe.Pointer(subExprTokenPtr + 1*32))).Ftype1 = int32(TCL_TOKEN_OPERATOR)
				/*
				 * Our current position scanning the string is the starting
				 * point for this subexpression.
				 */
				(*TTcl_Token)(unsafe.Pointer(subExprTokenPtr)).Fstart = start
				/*
				 * Eventually, we know that the numComponents field of the
				 * Tcl_Token of type TCL_TOKEN_OPERATOR will be 0. This means
				 * we can make other use of this field for now to track the
				 * stack of subexpressions we have pending.
				 */
				(*(*TTcl_Token)(unsafe.Pointer(subExprTokenPtr + 1*32))).FnumComponents = int64(parentIdx)
				break
			}
			break
		}
		/* Determine which way to exit the node on this pass. */
		goto router
	router:
		;
		switch libc.Int32FromUint8((*TOpNode)(unsafe.Pointer(nodePtr)).Fmark) {
		case int32(MARK_LEFT):
			next = (*TOpNode)(unsafe.Pointer(nodePtr)).Fleft
		case int32(MARK_RIGHT):
			next = (*TOpNode)(unsafe.Pointer(nodePtr)).Fright
			/*
			 * Skip any white space that comes before the operator.
			 */
			scanned = int32(XTclParseAllWhiteSpace(tls, start, numBytes))
			start += uintptr(scanned)
			numBytes -= int64(scanned)
			/*
			 * Here we scan from the string the operator corresponding to
			 * nodePtr->lexeme.
			 */
			scanned = int32(_ParseLexeme(tls, start, numBytes, bp, libc.UintptrFromInt32(0)))
			switch libc.Int32FromUint8((*TOpNode)(unsafe.Pointer(nodePtr)).Flexeme) {
			case int32(OPEN_PAREN):
				fallthrough
			case int32(COMMA):
				fallthrough
			case int32(COLON):
				/*
				 * No tokens for these lexemes -> nothing to do.
				 */
			default:
				/*
				 * Record in the TCL_TOKEN_OPERATOR token the pointers into
				 * the string marking where the operator is.
				 */
				subExprTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr(subExprTokenIdx)*32
				(*(*TTcl_Token)(unsafe.Pointer(subExprTokenPtr + 1*32))).Fstart = start
				(*(*TTcl_Token)(unsafe.Pointer(subExprTokenPtr + 1*32))).Fsize = int64(scanned)
				break
			}
			start += uintptr(scanned)
			numBytes -= int64(scanned)
		case int32(MARK_PARENT):
			switch libc.Int32FromUint8((*TOpNode)(unsafe.Pointer(nodePtr)).Flexeme) {
			case int32(START):
				/* When we get back to the START node, we're done. */
				return
			case int32(COMMA):
				fallthrough
			case int32(COLON):
				/* No tokens for these lexemes -> nothing to do. */
			case int32(OPEN_PAREN):
				/*
				 * Skip past matching close paren.
				 */
				scanned = int32(XTclParseAllWhiteSpace(tls, start, numBytes))
				start += uintptr(scanned)
				numBytes -= int64(scanned)
				scanned = int32(_ParseLexeme(tls, start, numBytes, bp, libc.UintptrFromInt32(0)))
				start += uintptr(scanned)
				numBytes -= int64(scanned)
			default:
				/*
				 * Before we leave this node/operator/subexpression for the
				 * last time, finish up its tokens....
				 *
				 * Our current position scanning the string is where the
				 * substring for the subexpression ends.
				 */
				subExprTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr(subExprTokenIdx)*32
				(*TTcl_Token)(unsafe.Pointer(subExprTokenPtr)).Fsize = int64(start) - int64((*TTcl_Token)(unsafe.Pointer(subExprTokenPtr)).Fstart)
				/*
				 * All the Tcl_Tokens allocated and filled belong to
				 * this subexpression. The first token is the leading
				 * TCL_TOKEN_SUB_EXPR token, and all the rest (one fewer)
				 * are its components.
				 */
				(*TTcl_Token)(unsafe.Pointer(subExprTokenPtr)).FnumComponents = int64(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens) - subExprTokenIdx - int32(1))
				/*
				 * Finally, as we return up the tree to our parent, pop the
				 * parent subexpression off our subexpression stack, and
				 * fill in the zero numComponents for the operator Tcl_Token.
				 */
				parentIdx = int32((*(*TTcl_Token)(unsafe.Pointer(subExprTokenPtr + 1*32))).FnumComponents)
				(*(*TTcl_Token)(unsafe.Pointer(subExprTokenPtr + 1*32))).FnumComponents = 0
				subExprTokenIdx = parentIdx
				break
			}
			/*
			 * Since we're returning to parent, skip child handling code.
			 */
			nodePtr = nodes + uintptr(*(*int32)(unsafe.Pointer(nodePtr + 8)))*16
			goto router
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ParseExpr --
 *
 *	Given a string, the numBytes bytes starting at start, this function
 *	parses it as a Tcl expression and stores information about the
 *	structure of the expression in the Tcl_Parse struct indicated by the
 *	caller.
 *
 * Results:
 *	If the string is successfully parsed as a valid Tcl expression, TCL_OK
 *	is returned, and data about the expression structure is written to
 *	*parsePtr. If the string cannot be parsed as a valid Tcl expression,
 *	TCL_ERROR is returned, and if interp is non-NULL, an error message is
 *	written to interp.
 *
 * Side effects:
 *	If there is insufficient space in parsePtr to hold all the information
 *	about the expression, then additional space is malloc-ed. If the
 *	function returns TCL_OK then the caller must eventually invoke
 *	Tcl_FreeParse to release any additional space that was allocated.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ParseExpr(tls *libc.TLS, interp uintptr, start uintptr, numBytes TTcl_Size, parsePtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Structure to fill with information about
	 * the parsed expression; any previous
	 * information in the structure is ignored. */
	var _objPtr, _objPtr1, cachePtr, cachePtr1, exprParsePtr, funcList, litList, v5, v7 uintptr
	var code int32
	var v1, v2 bool
	var v3 uint64
	var v4, v6 TTcl_Size
	var _ /* opTree at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, cachePtr1, code, exprParsePtr, funcList, litList, v1, v2, v3, v4, v5, v6, v7
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0) /* List to hold the functon names. */
	exprParsePtr = XTclStackAlloc(tls, interp, uint64(744))
	/* Holds the Tcl_Tokens of substitutions. */
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		litList = XTclThreadAllocObj(tls)
	} else {
		litList = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(litList + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(litList)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(litList)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(litList)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(litList)).FtypePtr = libc.UintptrFromInt32(0)
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		funcList = XTclThreadAllocObj(tls)
	} else {
		funcList = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(funcList + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(funcList)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(funcList)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(funcList)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(funcList)).FtypePtr = libc.UintptrFromInt32(0)
	if numBytes < 0 {
		if start != 0 {
			v3 = libc.Xstrlen(tls, start)
		} else {
			v3 = uint64(0)
		}
		numBytes = libc.Int64FromUint64(v3)
	}
	code = _ParseExpr(tls, interp, start, numBytes, bp, litList, funcList, exprParsePtr, int32(1))
	_objPtr = funcList
	v5 = _objPtr
	v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
	*(*TTcl_Size)(unsafe.Pointer(v5))--
	if v4 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	_objPtr1 = litList
	v7 = _objPtr1
	v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
	*(*TTcl_Size)(unsafe.Pointer(v7))--
	if v6 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	XTclParseInit(tls, interp, start, numBytes, parsePtr)
	if code == TCL_OK {
		_ConvertTreeToTokens(tls, start, numBytes, *(*uintptr)(unsafe.Pointer(bp)), (*TTcl_Parse)(unsafe.Pointer(exprParsePtr)).FtokenPtr, parsePtr)
	} else {
		(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm = (*TTcl_Parse)(unsafe.Pointer(exprParsePtr)).Fterm
		(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FerrorType = (*TTcl_Parse)(unsafe.Pointer(exprParsePtr)).FerrorType
	}
	XTcl_FreeParse(tls, exprParsePtr)
	XTclStackFree(tls, interp, exprParsePtr)
	XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp)))
	return code
}

/*
 *----------------------------------------------------------------------
 *
 * ParseLexeme --
 *
 *	Parse a single lexeme from the start of a string, scanning no more
 *	than numBytes bytes.
 *
 * Results:
 *	Returns the number of bytes scanned to produce the lexeme.
 *
 * Side effects:
 *	Code identifying lexeme parsed is written to *lexemePtr.
 *
 *----------------------------------------------------------------------
 */

func _ParseLexeme(tls *libc.TLS, start uintptr, numBytes TTcl_Size, lexemePtr uintptr, literalPtr uintptr) (r TTcl_Size) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Write corresponding literal value to this
	 * storage, if non-NULL. */
	var _objPtr, _objPtr1, _objPtr2, cachePtr, literal, p, v12, v14, v5, v7, v8 uintptr
	var byte1 uint8
	var scanned, size, v11, v13, v6 TTcl_Size
	var v10, v9 int64
	var v2 bool
	var _ /* ch at bp+8 */ int32
	var _ /* end at bp+0 */ uintptr
	var _ /* lexeme at bp+12 */ uint8
	var _ /* utfBytes at bp+16 */ [8]uint8
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, byte1, cachePtr, literal, p, scanned, size, v10, v11, v12, v13, v14, v2, v5, v6, v7, v8, v9
	literal = libc.UintptrFromInt32(0)
	if numBytes == 0 {
		*(*uint8)(unsafe.Pointer(lexemePtr)) = uint8(END1)
		return 0
	}
	byte1 = *(*uint8)(unsafe.Pointer(start))
	if uint64(byte1) < uint64(128) && libc.Int32FromUint8(_Lexeme[byte1]) != 0 {
		*(*uint8)(unsafe.Pointer(lexemePtr)) = _Lexeme[byte1]
		return int64(1)
	}
	switch libc.Int32FromUint8(byte1) {
	case int32('#'):
		size = 0
		for {
			if !(libc.Int32FromUint8(byte1) != int32('\n') && libc.Int32FromUint8(byte1) != 0 && size < numBytes) {
				break
			}
			byte1 = *(*uint8)(unsafe.Pointer(start + uintptr(size)))
			goto _1
		_1:
			;
			size++
		}
		*(*uint8)(unsafe.Pointer(lexemePtr)) = uint8(COMMENT)
		return size - libc.BoolInt64(libc.Int32FromUint8(byte1) == libc.Int32FromUint8('\n'))
	case int32('*'):
		if numBytes > int64(1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start + 1))) == int32('*') {
			*(*uint8)(unsafe.Pointer(lexemePtr)) = uint8(EXPON)
			return int64(2)
		}
		*(*uint8)(unsafe.Pointer(lexemePtr)) = uint8(MULT)
		return int64(1)
	case int32('='):
		if numBytes > int64(1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start + 1))) == int32('=') {
			*(*uint8)(unsafe.Pointer(lexemePtr)) = uint8(EQUAL)
			return int64(2)
		}
		*(*uint8)(unsafe.Pointer(lexemePtr)) = uint8(INCOMPLETE)
		return int64(1)
	case int32('!'):
		if numBytes > int64(1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start + 1))) == int32('=') {
			*(*uint8)(unsafe.Pointer(lexemePtr)) = uint8(NEQ)
			return int64(2)
		}
		*(*uint8)(unsafe.Pointer(lexemePtr)) = uint8(NOT)
		return int64(1)
	case int32('&'):
		if numBytes > int64(1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start + 1))) == int32('&') {
			*(*uint8)(unsafe.Pointer(lexemePtr)) = uint8(AND)
			return int64(2)
		}
		*(*uint8)(unsafe.Pointer(lexemePtr)) = uint8(BIT_AND)
		return int64(1)
	case int32('|'):
		if numBytes > int64(1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start + 1))) == int32('|') {
			*(*uint8)(unsafe.Pointer(lexemePtr)) = uint8(OR)
			return int64(2)
		}
		*(*uint8)(unsafe.Pointer(lexemePtr)) = uint8(BIT_OR)
		return int64(1)
	case int32('<'):
		if numBytes > int64(1) {
			switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start + 1))) {
			case int32('<'):
				*(*uint8)(unsafe.Pointer(lexemePtr)) = uint8(LEFT_SHIFT)
				return int64(2)
			case int32('='):
				*(*uint8)(unsafe.Pointer(lexemePtr)) = uint8(LEQ)
				return int64(2)
			}
		}
		*(*uint8)(unsafe.Pointer(lexemePtr)) = uint8(LESS)
		return int64(1)
	case int32('>'):
		if numBytes > int64(1) {
			switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start + 1))) {
			case int32('>'):
				*(*uint8)(unsafe.Pointer(lexemePtr)) = uint8(RIGHT_SHIFT)
				return int64(2)
			case int32('='):
				*(*uint8)(unsafe.Pointer(lexemePtr)) = uint8(GEQ)
				return int64(2)
			}
		}
		*(*uint8)(unsafe.Pointer(lexemePtr)) = uint8(GREATER)
		return int64(1)
	case int32('i'):
		if numBytes > int64(1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start + 1))) == int32('n') && (numBytes == int64(2) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start + 2)))&int32(0x80) != 0 || !(libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(start + 2)))|libc.Uint32FromInt32(32)-libc.Uint32FromUint8('a') < libc.Uint32FromInt32(26)) != 0)) {
			/*
			 * Must make this check so we can tell the difference between the
			 * "in" operator and the "int" function name and the "infinity"
			 * numeric value.
			 */
			*(*uint8)(unsafe.Pointer(lexemePtr)) = uint8(IN_LIST)
			return int64(2)
		}
	case int32('e'):
		if numBytes > int64(1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start + 1))) == int32('q') && (numBytes == int64(2) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start + 2)))&int32(0x80) != 0 || !(libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(start + 2)))|libc.Uint32FromInt32(32)-libc.Uint32FromUint8('a') < libc.Uint32FromInt32(26)) != 0)) {
			*(*uint8)(unsafe.Pointer(lexemePtr)) = uint8(STREQ)
			return int64(2)
		}
	case int32('n'):
		if numBytes > int64(1) && (numBytes == int64(2) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start + 2)))&int32(0x80) != 0 || !(libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(start + 2)))|libc.Uint32FromInt32(32)-libc.Uint32FromUint8('a') < libc.Uint32FromInt32(26)) != 0)) {
			switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start + 1))) {
			case int32('e'):
				*(*uint8)(unsafe.Pointer(lexemePtr)) = uint8(STRNEQ)
				return int64(2)
			case int32('i'):
				*(*uint8)(unsafe.Pointer(lexemePtr)) = uint8(NOT_IN_LIST)
				return int64(2)
			}
		}
	case int32('l'):
		if numBytes > int64(1) && (numBytes == int64(2) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start + 2)))&int32(0x80) != 0 || !(libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(start + 2)))|libc.Uint32FromInt32(32)-libc.Uint32FromUint8('a') < libc.Uint32FromInt32(26)) != 0)) {
			switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start + 1))) {
			case int32('t'):
				*(*uint8)(unsafe.Pointer(lexemePtr)) = uint8(STR_LT)
				return int64(2)
			case int32('e'):
				*(*uint8)(unsafe.Pointer(lexemePtr)) = uint8(STR_LEQ)
				return int64(2)
			}
		}
	case int32('g'):
		if numBytes > int64(1) && (numBytes == int64(2) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start + 2)))&int32(0x80) != 0 || !(libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(start + 2)))|libc.Uint32FromInt32(32)-libc.Uint32FromUint8('a') < libc.Uint32FromInt32(26)) != 0)) {
			switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start + 1))) {
			case int32('t'):
				*(*uint8)(unsafe.Pointer(lexemePtr)) = uint8(STR_GT)
				return int64(2)
			case int32('e'):
				*(*uint8)(unsafe.Pointer(lexemePtr)) = uint8(STR_GEQ)
				return int64(2)
			}
		}
		break
	}
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		literal = XTclThreadAllocObj(tls)
	} else {
		literal = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(literal + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(literal)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(literal)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(literal)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(literal)).FtypePtr = libc.UintptrFromInt32(0)
	if XTclParseNumber(tls, libc.UintptrFromInt32(0), literal, libc.UintptrFromInt32(0), start, numBytes, bp, int32(TCL_PARSE_NO_WHITESPACE)) == TCL_OK {
		if !(*(*uintptr)(unsafe.Pointer(bp)) < start+uintptr(numBytes) && !(XTclIsBareword(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))) != 0)) {
			goto _3
		}
		goto number
	number:
		;
		*(*uint8)(unsafe.Pointer(lexemePtr)) = uint8(NUMBER)
		if literalPtr != 0 {
			if int64(*(*uintptr)(unsafe.Pointer(bp)))-int64(start) == 0 {
				(*TTcl_Obj)(unsafe.Pointer(literal)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(literal)).Flength = int64(libc.Int32FromInt32(0))
			} else {
				(*TTcl_Obj)(unsafe.Pointer(literal)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(int64(*(*uintptr)(unsafe.Pointer(bp)))-int64(start)+libc.Int64FromUint32(1)))
				if start != 0 {
					v5 = start
				} else {
					v5 = uintptr(unsafe.Pointer(&XtclEmptyString))
				}
				libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(literal)).Fbytes, v5, libc.Uint64FromInt64(int64(*(*uintptr)(unsafe.Pointer(bp)))-int64(start)))
				*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(literal)).Fbytes + uintptr(int64(*(*uintptr)(unsafe.Pointer(bp)))-int64(start)))) = uint8('\000')
				(*TTcl_Obj)(unsafe.Pointer(literal)).Flength = int64(*(*uintptr)(unsafe.Pointer(bp))) - int64(start)
			}
			*(*uintptr)(unsafe.Pointer(literalPtr)) = literal
		} else {
			_objPtr = literal
			v7 = _objPtr
			v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
			*(*TTcl_Size)(unsafe.Pointer(v7))--
			if v6 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
		return int64(*(*uintptr)(unsafe.Pointer(bp))) - int64(start)
		goto _4
	_3:
		;
		/*
		 * We have a number followed directly by bareword characters
		 * (alpha, digit, underscore).  Is this a number followed by
		 * bareword syntax error?  Or should we join into one bareword?
		 * Example: Inf + luence + () becomes a valid function call.
		 * [Bug 3401704]
		 */
		if (*TTcl_Obj)(unsafe.Pointer(literal)).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
			p = start
			for p < *(*uintptr)(unsafe.Pointer(bp)) {
				v8 = p
				p++
				if !(XTclIsBareword(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v8)))) != 0) {
					/*
					 * The number has non-bareword characters, so we
					 * must treat it as a number.
					 */
					goto number
				}
			}
		}
		_ParseLexeme(tls, *(*uintptr)(unsafe.Pointer(bp)), numBytes-(int64(*(*uintptr)(unsafe.Pointer(bp)))-int64(start)), bp+12, libc.UintptrFromInt32(0))
		if int32(NODE_TYPE)&libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 12))) == int32(BINARY) {
			/*
			 * The bareword characters following the number take the
			 * form of an operator (eq, ne, in, ni, ...) so we treat
			 * as number + operator.
			 */
			goto number
		}
		/*
		 * Otherwise, fall through and parse the whole as a bareword.
		 */
	_4:
	}
	/*
	 * We reject leading underscores in bareword.  No sensible reason why.
	 * Might be inspired by reserved identifier rules in C, which of course
	 * have no direct relevance here.
	 */
	if !(XTclIsBareword(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start)))) != 0) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start))) == int32('_') {
		if XTcl_UtfCharComplete(tls, start, numBytes) != 0 {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start))) < int32(0x80) {
				*(*int32)(unsafe.Pointer(bp + 8)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start)))
				v9 = int64(libc.Int32FromInt32(1))
			} else {
				v9 = XTcl_UtfToUniChar(tls, start, bp+8)
			}
			scanned = v9
		} else {
			libc.Xmemcpy(tls, bp+16, start, libc.Uint64FromInt64(numBytes))
			(*(*[8]uint8)(unsafe.Pointer(bp + 16)))[numBytes] = uint8('\000')
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 16))) < int32(0x80) {
				*(*int32)(unsafe.Pointer(bp + 8)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 16)))
				v10 = int64(libc.Int32FromInt32(1))
			} else {
				v10 = XTcl_UtfToUniChar(tls, bp+16, bp+8)
			}
			scanned = v10
		}
		*(*uint8)(unsafe.Pointer(lexemePtr)) = uint8(INVALID)
		_objPtr1 = literal
		v12 = _objPtr1
		v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
		*(*TTcl_Size)(unsafe.Pointer(v12))--
		if v11 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		return scanned
	}
	*(*uintptr)(unsafe.Pointer(bp)) = start
	for numBytes != 0 && XTclIsBareword(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))) != 0 {
		*(*uintptr)(unsafe.Pointer(bp)) += uintptr(1)
		numBytes -= int64(1)
	}
	*(*uint8)(unsafe.Pointer(lexemePtr)) = uint8(BAREWORD)
	if literalPtr != 0 {
		XTcl_SetStringObj(tls, literal, start, int64(*(*uintptr)(unsafe.Pointer(bp)))-int64(start))
		*(*uintptr)(unsafe.Pointer(literalPtr)) = literal
	} else {
		_objPtr2 = literal
		v14 = _objPtr2
		v13 = *(*TTcl_Size)(unsafe.Pointer(v14))
		*(*TTcl_Size)(unsafe.Pointer(v14))--
		if v13 <= int64(1) {
			XTclFreeObj(tls, _objPtr2)
		}
	}
	return int64(*(*uintptr)(unsafe.Pointer(bp))) - int64(start)
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileExpr --
 *
 *	This procedure compiles a string containing a Tcl expression into Tcl
 *	bytecodes.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Adds instructions to envPtr to evaluate the expression at runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileExpr(tls *libc.TLS, interp uintptr, script uintptr, numBytes TTcl_Size, envPtr uintptr, optimize int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* 0 for one-off expressions. */
	var _objPtr, _objPtr1, cachePtr, cachePtr1, funcList, litList, parsePtr, v10, v12 uintptr
	var code int32
	var v1, v2 bool
	var v11, v9 TTcl_Size
	var v4, v5, v7, v8 int64
	var _ /* funcObjv at bp+24 */ uintptr
	var _ /* litObjv at bp+16 */ uintptr
	var _ /* objc at bp+8 */ TTcl_Size
	var _ /* opTree at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, cachePtr1, code, funcList, litList, parsePtr, v1, v10, v11, v12, v2, v4, v5, v7, v8, v9
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0) /* List to hold the functon names*/
	parsePtr = XTclStackAlloc(tls, interp, uint64(744))
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		litList = XTclThreadAllocObj(tls)
	} else {
		litList = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(litList + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(litList)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(litList)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(litList)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(litList)).FtypePtr = libc.UintptrFromInt32(0)
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		funcList = XTclThreadAllocObj(tls)
	} else {
		funcList = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(funcList + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(funcList)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(funcList)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(funcList)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(funcList)).FtypePtr = libc.UintptrFromInt32(0)
	code = _ParseExpr(tls, interp, script, numBytes, bp, litList, funcList, parsePtr, 0)
	if code == TCL_OK {
		/* TIP #280 : Track Lines within the expression */
		XTclAdvanceLines(tls, envPtr+4512, script, script+uintptr(XTclParseAllWhiteSpace(tls, script, numBytes)))
		if (*TTcl_Obj)(unsafe.Pointer(litList)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(litList + 32))).Fptr2 != 0 {
				v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(litList + 32))).Fptr2)).FspanStart
			} else {
				v4 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(litList + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 16)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(litList + 32))).Fptr1 + 40 + uintptr(v4)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(litList + 32))).Fptr2 != 0 {
				v5 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(litList + 32))).Fptr2)).FspanLength
			} else {
				v5 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(litList + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v5
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), litList, bp+8, bp+16)
		}
		if (*TTcl_Obj)(unsafe.Pointer(funcList)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(funcList + 32))).Fptr2 != 0 {
				v7 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(funcList + 32))).Fptr2)).FspanStart
			} else {
				v7 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(funcList + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 24)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(funcList + 32))).Fptr1 + 40 + uintptr(v7)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(funcList + 32))).Fptr2 != 0 {
				v8 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(funcList + 32))).Fptr2)).FspanLength
			} else {
				v8 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(funcList + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v8
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), funcList, bp+8, bp+24)
		}
		_CompileExprTree(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), 0, bp+16, *(*uintptr)(unsafe.Pointer(bp + 24)), (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr, envPtr, optimize)
	} else {
		XTclCompileSyntaxError(tls, interp, envPtr)
	}
	XTcl_FreeParse(tls, parsePtr)
	XTclStackFree(tls, interp, parsePtr)
	_objPtr = funcList
	v10 = _objPtr
	v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
	*(*TTcl_Size)(unsafe.Pointer(v10))--
	if v9 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	_objPtr1 = litList
	v12 = _objPtr1
	v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
	*(*TTcl_Size)(unsafe.Pointer(v12))--
	if v11 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp)))
}

/*
 *----------------------------------------------------------------------
 *
 * ExecConstantExprTree --
 *	Compiles and executes bytecode for the subexpression tree at index
 *	in the nodes array.  This subexpression must be constant, made up
 *	of only constant operators (not functions) and literals.
 *
 * Results:
 *	A standard Tcl return code and result left in interp.
 *
 * Side effects:
 *	Consumes subtree of nodes rooted at index.  Advances the pointer
 *	*litObjvPtr.
 *
 *----------------------------------------------------------------------
 */

func _ExecConstantExprTree(tls *libc.TLS, interp uintptr, nodes uintptr, index int32, litObjvPtr uintptr) (r int32) {
	var byteCodePtr, envPtr2, rootPtr, v1, v2, v4 uintptr
	var code, delta1, v3 int32
	_, _, _, _, _, _, _, _, _ = byteCodePtr, code, delta1, envPtr2, rootPtr, v1, v2, v3, v4
	rootPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	/*
	 * Note we are compiling an expression with literal arguments. This means
	 * there can be no [info frame] calls when we execute the resulting
	 * bytecode, so there's no need to tend to TIP 280 issues.
	 */
	envPtr2 = XTclStackAlloc(tls, interp, uint64(4544))
	XTclInitCompileEnv(tls, interp, envPtr2, libc.UintptrFromInt32(0), uint64(0), libc.UintptrFromInt32(0), 0)
	_CompileExprTree(tls, interp, nodes, index, litObjvPtr, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), envPtr2, 0)
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v2 = envPtr2 + 152
	v1 = *(*uintptr)(unsafe.Pointer(v2))
	*(*uintptr)(unsafe.Pointer(v2))++
	*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_DONE))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_DONE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v3 = delta1
		v4 = envPtr2
		if v3 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v4)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v4)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v4)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v4)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v4 + 64)) += int64(v3)
	}
	byteCodePtr = XTclInitByteCode(tls, envPtr2)
	XTclFreeCompileEnv(tls, envPtr2)
	XTclStackFree(tls, interp, envPtr2)
	XTclNRExecuteByteCode(tls, interp, byteCodePtr)
	code = XTclNRRunCallbacks(tls, interp, TCL_OK, rootPtr)
	XTclReleaseByteCode(tls, byteCodePtr)
	return code
}

/*
 *----------------------------------------------------------------------
 *
 * CompileExprTree --
 *
 *	Compiles and writes to envPtr instructions for the subexpression tree
 *	at index in the nodes array. (*litObjvPtr) must point to the proper
 *	location in a corresponding literals list. Likewise, when non-NULL,
 *	funcObjv and tokenPtr must point into matching arrays of function
 *	names and Tcl_Token's derived from earlier call to ParseExpr(). When
 *	optimize is true, any constant subexpressions will be precomputed.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Adds instructions to envPtr to evaluate the expression at runtime.
 *	Consumes subtree of nodes rooted at index. Advances the pointer
 *	*litObjvPtr.
 *
 *----------------------------------------------------------------------
 */

func _CompileExprTree(tls *libc.TLS, interp uintptr, nodes uintptr, index int32, litObjvPtr uintptr, funcObjv uintptr, tokenPtr uintptr, envPtr2 uintptr, optimize int32) {
	bp := tls.Alloc(272)
	defer tls.Free(272)
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, _objIndexCopy4, _objIndexCopy5, convert, delta1, idx, idx1, next, numWords, pc1, pc2, target, v106, v118, v124, v136, v143, v155, v18, v20, v22, v35, v39, v42, v43, v44, v45, v52, v6, v64, v70, v72, v79, v91, v98, v99 int32
	var bytes, bytes1, freePtr, jumpPtr, litObjv, literal, newJump, nodePtr, objPtr, objPtr1, p, rootPtr, tableValue, v1, v10, v100, v101, v102, v103, v104, v105, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v119, v12, v120, v121, v122, v123, v125, v126, v127, v128, v129, v13, v130, v131, v132, v133, v134, v135, v137, v138, v139, v14, v140, v141, v142, v144, v145, v146, v147, v148, v149, v15, v150, v151, v152, v153, v154, v156, v16, v17, v19, v2, v21, v3, v33, v34, v36, v37, v38, v4, v40, v41, v46, v47, v48, v49, v5, v50, v51, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63, v65, v66, v67, v68, v69, v7, v71, v73, v74, v75, v76, v77, v78, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v92, v96, v97 uintptr
	var save TTcl_InterpState
	var _ /* cmdName at bp+0 */ TTcl_DString
	var _ /* length at bp+224 */ TTcl_Size
	var _ /* length at bp+232 */ TTcl_Size
	var _ /* numBytes at bp+240 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, _objIndexCopy4, _objIndexCopy5, bytes, bytes1, convert, delta1, freePtr, idx, idx1, jumpPtr, litObjv, literal, newJump, next, nodePtr, numWords, objPtr, objPtr1, p, pc1, pc2, rootPtr, save, tableValue, target, v1, v10, v100, v101, v102, v103, v104, v105, v106, v107, v108, v109, v11, v110, v111, v112, v113, v114, v115, v116, v117, v118, v119, v12, v120, v121, v122, v123, v124, v125, v126, v127, v128, v129, v13, v130, v131, v132, v133, v134, v135, v136, v137, v138, v139, v14, v140, v141, v142, v143, v144, v145, v146, v147, v148, v149, v15, v150, v151, v152, v153, v154, v155, v156, v16, v17, v18, v19, v2, v20, v21, v22, v3, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v9, v90, v91, v92, v96, v97, v98, v99
	nodePtr = nodes + uintptr(index)*16
	rootPtr = nodePtr
	numWords = 0
	jumpPtr = libc.UintptrFromInt32(0)
	convert = int32(1)
	for int32(1) != 0 {
		if libc.Int32FromUint8((*TOpNode)(unsafe.Pointer(nodePtr)).Fmark) == int32(MARK_LEFT) {
			next = (*TOpNode)(unsafe.Pointer(nodePtr)).Fleft
			if libc.Int32FromUint8((*TOpNode)(unsafe.Pointer(nodePtr)).Flexeme) == int32(QUESTION) {
				convert = int32(1)
			}
		} else {
			if libc.Int32FromUint8((*TOpNode)(unsafe.Pointer(nodePtr)).Fmark) == int32(MARK_RIGHT) {
				next = (*TOpNode)(unsafe.Pointer(nodePtr)).Fright
				switch libc.Int32FromUint8((*TOpNode)(unsafe.Pointer(nodePtr)).Flexeme) {
				case int32(FUNCTION):
					XTcl_DStringInit(tls, bp)
					XTcl_DStringAppend(tls, bp, __ccgo_ts+23096, libc.Int64FromUint64(libc.Uint64FromInt64(16)-libc.Uint64FromInt32(1)))
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(funcObjv)))).Fbytes != 0 {
						*(*TTcl_Size)(unsafe.Pointer(bp + 224)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(funcObjv)))).Flength
						v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(funcObjv)))).Fbytes
					} else {
						v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(funcObjv)), bp+224)
					}
					p = v1
					funcObjv += 8
					XTcl_DStringAppend(tls, bp, p, *(*TTcl_Size)(unsafe.Pointer(bp + 224)))
					_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1, (*TTcl_DString)(unsafe.Pointer(bp)).Flength, int32(LITERAL_CMD_NAME))
					if _objIndexCopy <= int32(255) {
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
							XTclExpandCodeArray(tls, envPtr2)
						}
						v3 = envPtr2 + 152
						v2 = *(*uintptr)(unsafe.Pointer(v3))
						*(*uintptr)(unsafe.Pointer(v3))++
						*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32(INST_PUSH1))
						v5 = envPtr2 + 152
						v4 = *(*uintptr)(unsafe.Pointer(v5))
						*(*uintptr)(unsafe.Pointer(v5))++
						*(*uint8)(unsafe.Pointer(v4)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
							(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
						}
						delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
						if delta1 != 0 {
							if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
								delta1 = int32(1) - _objIndexCopy
							}
							v6 = delta1
							v7 = envPtr2
							if v6 < libc.Int32FromInt32(0) {
								if int32((*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth) {
									(*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth
								}
							}
							*(*TTcl_Size)(unsafe.Pointer(v7 + 64)) += int64(v6)
						}
					} else {
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
							XTclExpandCodeArray(tls, envPtr2)
						}
						v9 = envPtr2 + 152
						v8 = *(*uintptr)(unsafe.Pointer(v9))
						*(*uintptr)(unsafe.Pointer(v9))++
						*(*uint8)(unsafe.Pointer(v8)) = libc.Uint8FromInt32(int32(INST_PUSH4))
						v11 = envPtr2 + 152
						v10 = *(*uintptr)(unsafe.Pointer(v11))
						*(*uintptr)(unsafe.Pointer(v11))++
						*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
						v13 = envPtr2 + 152
						v12 = *(*uintptr)(unsafe.Pointer(v13))
						*(*uintptr)(unsafe.Pointer(v13))++
						*(*uint8)(unsafe.Pointer(v12)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
						v15 = envPtr2 + 152
						v14 = *(*uintptr)(unsafe.Pointer(v15))
						*(*uintptr)(unsafe.Pointer(v15))++
						*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
						v17 = envPtr2 + 152
						v16 = *(*uintptr)(unsafe.Pointer(v17))
						*(*uintptr)(unsafe.Pointer(v17))++
						*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
							(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
						}
						delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
						if delta1 != 0 {
							if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
								delta1 = int32(1) - _objIndexCopy
							}
							v18 = delta1
							v19 = envPtr2
							if v18 < libc.Int32FromInt32(0) {
								if int32((*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth) {
									(*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth
								}
							}
							*(*TTcl_Size)(unsafe.Pointer(v19 + 64)) += int64(v18)
						}
					}
					XTcl_DStringFree(tls, bp)
					/*
					 * Start a count of the number of words in this function
					 * command invocation. In case there's already a count in
					 * progress (nested functions), save it in our unused "left"
					 * field for restoring later.
					 */
					(*TOpNode)(unsafe.Pointer(nodePtr)).Fleft = numWords
					numWords = int32(2) /* Command plus one argument */
				case int32(QUESTION):
					newJump = XTclStackAlloc(tls, interp, uint64(24))
					(*TJumpList)(unsafe.Pointer(newJump)).Fnext = jumpPtr
					jumpPtr = newJump
					XTclEmitForwardJump(tls, envPtr2, int32(TCL_FALSE_JUMP), jumpPtr)
				case int32(COLON):
					newJump = XTclStackAlloc(tls, interp, uint64(24))
					(*TJumpList)(unsafe.Pointer(newJump)).Fnext = jumpPtr
					jumpPtr = newJump
					XTclEmitForwardJump(tls, envPtr2, int32(TCL_UNCONDITIONAL_JUMP), jumpPtr)
					v20 = -int32(1)
					v21 = envPtr2
					if v20 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v21)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v21)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v21)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v21)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v21 + 64)) += int64(v20)
					if convert != 0 {
						(*TJumpList)(unsafe.Pointer(jumpPtr)).Fjump.FjumpType = int32(TCL_TRUE_JUMP)
					}
					convert = int32(1)
				case int32(AND):
					fallthrough
				case int32(OR):
					newJump = XTclStackAlloc(tls, interp, uint64(24))
					(*TJumpList)(unsafe.Pointer(newJump)).Fnext = jumpPtr
					jumpPtr = newJump
					if libc.Int32FromUint8((*TOpNode)(unsafe.Pointer(nodePtr)).Flexeme) == int32(AND) {
						v22 = int32(TCL_FALSE_JUMP)
					} else {
						v22 = int32(TCL_TRUE_JUMP)
					}
					XTclEmitForwardJump(tls, envPtr2, v22, jumpPtr)
					break
				}
			} else {
				switch libc.Int32FromUint8((*TOpNode)(unsafe.Pointer(nodePtr)).Flexeme) {
				case int32(QUESTION):
					goto _23
				case int32(START):
					goto _24
				case int32(OPEN_PAREN):
					goto _25
				case int32(FUNCTION):
					goto _26
				case int32(COMMA):
					goto _27
				case int32(COLON):
					goto _28
				case int32(OR):
					goto _29
				case int32(AND):
					goto _30
				default:
					goto _31
				}
				goto _32
			_24:
				;
			_23:
				;
				if convert != 0 && nodePtr == rootPtr {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v34 = envPtr2 + 152
					v33 = *(*uintptr)(unsafe.Pointer(v34))
					*(*uintptr)(unsafe.Pointer(v34))++
					*(*uint8)(unsafe.Pointer(v33)) = libc.Uint8FromInt32(int32(INST_TRY_CVT_TO_NUMERIC))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_TRY_CVT_TO_NUMERIC)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - 0
						}
						v35 = delta1
						v36 = envPtr2
						if v35 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v36)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v36)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v36 + 64)) += int64(v35)
					}
				}
				goto _32
			_25:
				;
				/* do nothing */
				goto _32
			_26:
				;
				/*
				 * Use the numWords count we've kept to invoke the function
				 * command with the correct number of arguments.
				 */
				if numWords < int32(255) {
					XTclEmitInvoke(tls, envPtr2, int32(INST_INVOKE_STK1), libc.VaList(bp+256, numWords))
				} else {
					XTclEmitInvoke(tls, envPtr2, int32(INST_INVOKE_STK4), libc.VaList(bp+256, numWords))
				}
				/*
				 * Restore any saved numWords value.
				 */
				numWords = (*TOpNode)(unsafe.Pointer(nodePtr)).Fleft
				convert = int32(1)
				goto _32
			_27:
				;
				/*
				 * Each comma implies another function argument.
				 */
				numWords++
				goto _32
			_28:
				;
				if (*TJumpList)(unsafe.Pointer(jumpPtr)).Fjump.FjumpType == int32(TCL_TRUE_JUMP) {
					(*TJumpList)(unsafe.Pointer(jumpPtr)).Fjump.FjumpType = int32(TCL_UNCONDITIONAL_JUMP)
					convert = int32(1)
				}
				target = libc.Int32FromUint32((*TJumpList)(unsafe.Pointer(jumpPtr)).Fjump.FcodeOffset + uint32(2))
				if XTclFixupForwardJump(tls, envPtr2, jumpPtr, int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(libc.Int32FromUint32((*TJumpFixup)(unsafe.Pointer(jumpPtr)).FcodeOffset))), int32(127)) != 0 {
					target += int32(3)
				}
				freePtr = jumpPtr
				jumpPtr = (*TJumpList)(unsafe.Pointer(jumpPtr)).Fnext
				XTclStackFree(tls, interp, freePtr)
				XTclFixupForwardJump(tls, envPtr2, jumpPtr, libc.Int32FromUint32(libc.Uint32FromInt32(target)-(*TJumpList)(unsafe.Pointer(jumpPtr)).Fjump.FcodeOffset), int32(127))
				freePtr = jumpPtr
				jumpPtr = (*TJumpList)(unsafe.Pointer(jumpPtr)).Fnext
				XTclStackFree(tls, interp, freePtr)
				goto _32
			_30:
				;
			_29:
				;
				pc1 = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v38 = envPtr2 + 152
				v37 = *(*uintptr)(unsafe.Pointer(v38))
				*(*uintptr)(unsafe.Pointer(v38))++
				if libc.Int32FromUint8((*TOpNode)(unsafe.Pointer(nodePtr)).Flexeme) == int32(AND) {
					v39 = int32(INST_JUMP_FALSE1)
				} else {
					v39 = int32(INST_JUMP_TRUE1)
				}
				*(*uint8)(unsafe.Pointer(v37)) = libc.Uint8FromInt32(v39)
				v41 = envPtr2 + 152
				v40 = *(*uintptr)(unsafe.Pointer(v41))
				*(*uintptr)(unsafe.Pointer(v41))++
				*(*uint8)(unsafe.Pointer(v40)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					if libc.Int32FromUint8((*TOpNode)(unsafe.Pointer(nodePtr)).Flexeme) == int32(AND) {
						v43 = int32(INST_JUMP_FALSE1)
					} else {
						v43 = int32(INST_JUMP_TRUE1)
					}
					if v43 == int32(INST_START_CMD) {
						v42 = int32(1)
					} else {
						v42 = 0
					}
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = v42
				}
				if libc.Int32FromUint8((*TOpNode)(unsafe.Pointer(nodePtr)).Flexeme) == int32(AND) {
					v44 = int32(INST_JUMP_FALSE1)
				} else {
					v44 = int32(INST_JUMP_TRUE1)
				}
				delta1 = XtclInstructionTable[libc.Uint8FromInt32(v44)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v45 = delta1
					v46 = envPtr2
					if v45 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v46)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v46)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v46)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v46)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v46 + 64)) += int64(v45)
				}
				if libc.Int32FromUint8((*TOpNode)(unsafe.Pointer(nodePtr)).Flexeme) == int32(AND) {
					v47 = __ccgo_ts + 21397
				} else {
					v47 = __ccgo_ts + 14828
				}
				_objIndexCopy1 = XTclRegisterLiteral(tls, envPtr2, v47, int64(1), 0)
				if _objIndexCopy1 <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v49 = envPtr2 + 152
					v48 = *(*uintptr)(unsafe.Pointer(v49))
					*(*uintptr)(unsafe.Pointer(v49))++
					*(*uint8)(unsafe.Pointer(v48)) = libc.Uint8FromInt32(int32(INST_PUSH1))
					v51 = envPtr2 + 152
					v50 = *(*uintptr)(unsafe.Pointer(v51))
					*(*uintptr)(unsafe.Pointer(v51))++
					*(*uint8)(unsafe.Pointer(v50)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy1
						}
						v52 = delta1
						v53 = envPtr2
						if v52 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v53)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v53)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v53)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v53)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v53 + 64)) += int64(v52)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v55 = envPtr2 + 152
					v54 = *(*uintptr)(unsafe.Pointer(v55))
					*(*uintptr)(unsafe.Pointer(v55))++
					*(*uint8)(unsafe.Pointer(v54)) = libc.Uint8FromInt32(int32(INST_PUSH4))
					v57 = envPtr2 + 152
					v56 = *(*uintptr)(unsafe.Pointer(v57))
					*(*uintptr)(unsafe.Pointer(v57))++
					*(*uint8)(unsafe.Pointer(v56)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
					v59 = envPtr2 + 152
					v58 = *(*uintptr)(unsafe.Pointer(v59))
					*(*uintptr)(unsafe.Pointer(v59))++
					*(*uint8)(unsafe.Pointer(v58)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
					v61 = envPtr2 + 152
					v60 = *(*uintptr)(unsafe.Pointer(v61))
					*(*uintptr)(unsafe.Pointer(v61))++
					*(*uint8)(unsafe.Pointer(v60)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
					v63 = envPtr2 + 152
					v62 = *(*uintptr)(unsafe.Pointer(v63))
					*(*uintptr)(unsafe.Pointer(v63))++
					*(*uint8)(unsafe.Pointer(v62)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy1
						}
						v64 = delta1
						v65 = envPtr2
						if v64 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v65)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v65)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v65)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v65)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v65 + 64)) += int64(v64)
					}
				}
				pc2 = int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v67 = envPtr2 + 152
				v66 = *(*uintptr)(unsafe.Pointer(v67))
				*(*uintptr)(unsafe.Pointer(v67))++
				*(*uint8)(unsafe.Pointer(v66)) = libc.Uint8FromInt32(int32(INST_JUMP1))
				v69 = envPtr2 + 152
				v68 = *(*uintptr)(unsafe.Pointer(v69))
				*(*uintptr)(unsafe.Pointer(v69))++
				*(*uint8)(unsafe.Pointer(v68)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_JUMP1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v70 = delta1
					v71 = envPtr2
					if v70 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v71)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v71)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v71)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v71)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v71 + 64)) += int64(v70)
				}
				v72 = -int32(1)
				v73 = envPtr2
				if v72 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v73)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v73)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v73)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v73)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v73 + 64)) += int64(v72)
				*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(pc1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(pc1)))
				if XTclFixupForwardJump(tls, envPtr2, jumpPtr, int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart)-int64(libc.Int32FromUint32((*TJumpFixup)(unsafe.Pointer(jumpPtr)).FcodeOffset))), int32(127)) != 0 {
					pc2 += int32(3)
				}
				if libc.Int32FromUint8((*TOpNode)(unsafe.Pointer(nodePtr)).Flexeme) == int32(AND) {
					v74 = __ccgo_ts + 14828
				} else {
					v74 = __ccgo_ts + 21397
				}
				_objIndexCopy2 = XTclRegisterLiteral(tls, envPtr2, v74, int64(1), 0)
				if _objIndexCopy2 <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v76 = envPtr2 + 152
					v75 = *(*uintptr)(unsafe.Pointer(v76))
					*(*uintptr)(unsafe.Pointer(v76))++
					*(*uint8)(unsafe.Pointer(v75)) = libc.Uint8FromInt32(int32(INST_PUSH1))
					v78 = envPtr2 + 152
					v77 = *(*uintptr)(unsafe.Pointer(v78))
					*(*uintptr)(unsafe.Pointer(v78))++
					*(*uint8)(unsafe.Pointer(v77)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy2
						}
						v79 = delta1
						v80 = envPtr2
						if v79 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v80)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v80)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v80)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v80)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v80 + 64)) += int64(v79)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v82 = envPtr2 + 152
					v81 = *(*uintptr)(unsafe.Pointer(v82))
					*(*uintptr)(unsafe.Pointer(v82))++
					*(*uint8)(unsafe.Pointer(v81)) = libc.Uint8FromInt32(int32(INST_PUSH4))
					v84 = envPtr2 + 152
					v83 = *(*uintptr)(unsafe.Pointer(v84))
					*(*uintptr)(unsafe.Pointer(v84))++
					*(*uint8)(unsafe.Pointer(v83)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
					v86 = envPtr2 + 152
					v85 = *(*uintptr)(unsafe.Pointer(v86))
					*(*uintptr)(unsafe.Pointer(v86))++
					*(*uint8)(unsafe.Pointer(v85)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
					v88 = envPtr2 + 152
					v87 = *(*uintptr)(unsafe.Pointer(v88))
					*(*uintptr)(unsafe.Pointer(v88))++
					*(*uint8)(unsafe.Pointer(v87)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
					v90 = envPtr2 + 152
					v89 = *(*uintptr)(unsafe.Pointer(v90))
					*(*uintptr)(unsafe.Pointer(v90))++
					*(*uint8)(unsafe.Pointer(v89)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy2
						}
						v91 = delta1
						v92 = envPtr2
						if v91 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v92)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v92)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v92)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v92)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v92 + 64)) += int64(v91)
					}
				}
				*(*uint8)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart + uintptr(pc2) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) - int64(pc2)))
				convert = 0
				freePtr = jumpPtr
				jumpPtr = (*TJumpList)(unsafe.Pointer(jumpPtr)).Fnext
				XTclStackFree(tls, interp, freePtr)
				goto _32
			_31:
				;
			_95:
				;
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v97 = envPtr2 + 152
				v96 = *(*uintptr)(unsafe.Pointer(v97))
				*(*uintptr)(unsafe.Pointer(v97))++
				*(*uint8)(unsafe.Pointer(v96)) = _instruction[(*TOpNode)(unsafe.Pointer(nodePtr)).Flexeme]
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					if libc.Int32FromUint8(_instruction[(*TOpNode)(unsafe.Pointer(nodePtr)).Flexeme]) == int32(INST_START_CMD) {
						v98 = int32(1)
					} else {
						v98 = 0
					}
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = v98
				}
				delta1 = XtclInstructionTable[_instruction[(*TOpNode)(unsafe.Pointer(nodePtr)).Flexeme]].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - 0
					}
					v99 = delta1
					v100 = envPtr2
					if v99 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v100)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v100)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v100)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v100)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v100 + 64)) += int64(v99)
				}
				goto _94
			_94:
				;
				if 0 != 0 {
					goto _95
				}
				goto _93
			_93:
				;
				convert = 0
				goto _32
			_32:
				;
				if nodePtr == rootPtr {
					/* We're done */
					return
				}
				nodePtr = nodes + uintptr(*(*int32)(unsafe.Pointer(nodePtr + 8)))*16
				continue
			}
		}
		(*TOpNode)(unsafe.Pointer(nodePtr)).Fmark++
		switch next {
		case int32(OT_EMPTY):
			numWords = int32(1) /* No arguments, so just the command */
		case int32(OT_LITERAL):
			litObjv = *(*uintptr)(unsafe.Pointer(litObjvPtr))
			literal = *(*uintptr)(unsafe.Pointer(litObjv))
			if optimize != 0 {
				if (*TTcl_Obj)(unsafe.Pointer(literal)).Fbytes != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp + 232)) = (*TTcl_Obj)(unsafe.Pointer(literal)).Flength
					v101 = (*TTcl_Obj)(unsafe.Pointer(literal)).Fbytes
				} else {
					v101 = XTcl_GetStringFromObj(tls, literal, bp+232)
				}
				bytes = v101
				idx = XTclRegisterLiteral(tls, envPtr2, bytes, *(*TTcl_Size)(unsafe.Pointer(bp + 232)), 0)
				objPtr = XTclFetchLiteral(tls, envPtr2, int64(idx))
				if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == libc.UintptrFromInt32(0) && (*TTcl_Obj)(unsafe.Pointer(literal)).FtypePtr != libc.UintptrFromInt32(0) {
					/*
					 * Would like to do this:
					 *
					 * lePtr->objPtr = literal;
					 * Tcl_IncrRefCount(literal);
					 * Tcl_DecrRefCount(objPtr);
					 *
					 * However, the design of the "global" and "local"
					 * LiteralTable does not permit the value of lePtr->objPtr
					 * to change. So rather than replace lePtr->objPtr, we do
					 * surgery to transfer our desired internalrep into it.
					 */
					(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = (*TTcl_Obj)(unsafe.Pointer(literal)).FtypePtr
					(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep = (*TTcl_Obj)(unsafe.Pointer(literal)).FinternalRep
					(*TTcl_Obj)(unsafe.Pointer(literal)).FtypePtr = libc.UintptrFromInt32(0)
				}
				_objIndexCopy3 = idx
				if _objIndexCopy3 <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v103 = envPtr2 + 152
					v102 = *(*uintptr)(unsafe.Pointer(v103))
					*(*uintptr)(unsafe.Pointer(v103))++
					*(*uint8)(unsafe.Pointer(v102)) = libc.Uint8FromInt32(int32(INST_PUSH1))
					v105 = envPtr2 + 152
					v104 = *(*uintptr)(unsafe.Pointer(v105))
					*(*uintptr)(unsafe.Pointer(v105))++
					*(*uint8)(unsafe.Pointer(v104)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy3
						}
						v106 = delta1
						v107 = envPtr2
						if v106 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v107)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v107)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v107)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v107)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v107 + 64)) += int64(v106)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v109 = envPtr2 + 152
					v108 = *(*uintptr)(unsafe.Pointer(v109))
					*(*uintptr)(unsafe.Pointer(v109))++
					*(*uint8)(unsafe.Pointer(v108)) = libc.Uint8FromInt32(int32(INST_PUSH4))
					v111 = envPtr2 + 152
					v110 = *(*uintptr)(unsafe.Pointer(v111))
					*(*uintptr)(unsafe.Pointer(v111))++
					*(*uint8)(unsafe.Pointer(v110)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(24))
					v113 = envPtr2 + 152
					v112 = *(*uintptr)(unsafe.Pointer(v113))
					*(*uintptr)(unsafe.Pointer(v113))++
					*(*uint8)(unsafe.Pointer(v112)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(16))
					v115 = envPtr2 + 152
					v114 = *(*uintptr)(unsafe.Pointer(v115))
					*(*uintptr)(unsafe.Pointer(v115))++
					*(*uint8)(unsafe.Pointer(v114)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(8))
					v117 = envPtr2 + 152
					v116 = *(*uintptr)(unsafe.Pointer(v117))
					*(*uintptr)(unsafe.Pointer(v117))++
					*(*uint8)(unsafe.Pointer(v116)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy3
						}
						v118 = delta1
						v119 = envPtr2
						if v118 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v119)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v119)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v119)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v119)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v119 + 64)) += int64(v118)
					}
				}
			} else {
				/*
				 * When optimize==0, we know the expression is a one-off and
				 * there's nothing to be gained from sharing literals when
				 * they won't live long, and the copies we have already have
				 * an appropriate internalrep. In this case, skip literal
				 * registration that would enable sharing, and use the routine
				 * that preserves internalreps.
				 */
				_objIndexCopy4 = XTclAddLiteralObj(tls, envPtr2, literal, libc.UintptrFromInt32(0))
				if _objIndexCopy4 <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v121 = envPtr2 + 152
					v120 = *(*uintptr)(unsafe.Pointer(v121))
					*(*uintptr)(unsafe.Pointer(v121))++
					*(*uint8)(unsafe.Pointer(v120)) = libc.Uint8FromInt32(int32(INST_PUSH1))
					v123 = envPtr2 + 152
					v122 = *(*uintptr)(unsafe.Pointer(v123))
					*(*uintptr)(unsafe.Pointer(v123))++
					*(*uint8)(unsafe.Pointer(v122)) = uint8(libc.Uint32FromInt32(_objIndexCopy4))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy4
						}
						v124 = delta1
						v125 = envPtr2
						if v124 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v125)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v125)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v125)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v125)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v125 + 64)) += int64(v124)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr2)
					}
					v127 = envPtr2 + 152
					v126 = *(*uintptr)(unsafe.Pointer(v127))
					*(*uintptr)(unsafe.Pointer(v127))++
					*(*uint8)(unsafe.Pointer(v126)) = libc.Uint8FromInt32(int32(INST_PUSH4))
					v129 = envPtr2 + 152
					v128 = *(*uintptr)(unsafe.Pointer(v129))
					*(*uintptr)(unsafe.Pointer(v129))++
					*(*uint8)(unsafe.Pointer(v128)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(24))
					v131 = envPtr2 + 152
					v130 = *(*uintptr)(unsafe.Pointer(v131))
					*(*uintptr)(unsafe.Pointer(v131))++
					*(*uint8)(unsafe.Pointer(v130)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(16))
					v133 = envPtr2 + 152
					v132 = *(*uintptr)(unsafe.Pointer(v133))
					*(*uintptr)(unsafe.Pointer(v133))++
					*(*uint8)(unsafe.Pointer(v132)) = uint8(libc.Uint32FromInt32(_objIndexCopy4) >> libc.Int32FromInt32(8))
					v135 = envPtr2 + 152
					v134 = *(*uintptr)(unsafe.Pointer(v135))
					*(*uintptr)(unsafe.Pointer(v135))++
					*(*uint8)(unsafe.Pointer(v134)) = uint8(libc.Uint32FromInt32(_objIndexCopy4))
					if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy4
						}
						v136 = delta1
						v137 = envPtr2
						if v136 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v137)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v137)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v137)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v137)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v137 + 64)) += int64(v136)
					}
				}
			}
			*(*uintptr)(unsafe.Pointer(litObjvPtr)) += 8
		case int32(OT_TOKENS):
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
			tokenPtr += uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+int64(1)) * 32
		default:
			if optimize != 0 && (*(*TOpNode)(unsafe.Pointer(nodes + uintptr(next)*16))).Fconstant != 0 {
				save = XTcl_SaveInterpState(tls, interp, TCL_OK)
				if _ExecConstantExprTree(tls, interp, nodes, next, litObjvPtr) == TCL_OK {
					objPtr1 = XTcl_GetObjResult(tls, interp)
					/*
					 * Don't generate a string rep, but if we have one
					 * already, then use it to share via the literal table.
					 */
					if (*TTcl_Obj)(unsafe.Pointer(objPtr1)).Fbytes != libc.UintptrFromInt32(0) {
						if (*TTcl_Obj)(unsafe.Pointer(objPtr1)).Fbytes != 0 {
							*(*TTcl_Size)(unsafe.Pointer(bp + 240)) = (*TTcl_Obj)(unsafe.Pointer(objPtr1)).Flength
							v138 = (*TTcl_Obj)(unsafe.Pointer(objPtr1)).Fbytes
						} else {
							v138 = XTcl_GetStringFromObj(tls, objPtr1, bp+240)
						}
						bytes1 = v138
						idx1 = XTclRegisterLiteral(tls, envPtr2, bytes1, *(*TTcl_Size)(unsafe.Pointer(bp + 240)), 0)
						tableValue = XTclFetchLiteral(tls, envPtr2, int64(idx1))
						if (*TTcl_Obj)(unsafe.Pointer(tableValue)).FtypePtr == libc.UintptrFromInt32(0) && (*TTcl_Obj)(unsafe.Pointer(objPtr1)).FtypePtr != libc.UintptrFromInt32(0) {
							/*
							 * Same internalrep surgery as for OT_LITERAL.
							 */
							(*TTcl_Obj)(unsafe.Pointer(tableValue)).FtypePtr = (*TTcl_Obj)(unsafe.Pointer(objPtr1)).FtypePtr
							(*TTcl_Obj)(unsafe.Pointer(tableValue)).FinternalRep = (*TTcl_Obj)(unsafe.Pointer(objPtr1)).FinternalRep
							(*TTcl_Obj)(unsafe.Pointer(objPtr1)).FtypePtr = libc.UintptrFromInt32(0)
						}
					} else {
						idx1 = XTclAddLiteralObj(tls, envPtr2, objPtr1, libc.UintptrFromInt32(0))
					}
					_objIndexCopy5 = idx1
					if _objIndexCopy5 <= int32(255) {
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
							XTclExpandCodeArray(tls, envPtr2)
						}
						v140 = envPtr2 + 152
						v139 = *(*uintptr)(unsafe.Pointer(v140))
						*(*uintptr)(unsafe.Pointer(v140))++
						*(*uint8)(unsafe.Pointer(v139)) = libc.Uint8FromInt32(int32(INST_PUSH1))
						v142 = envPtr2 + 152
						v141 = *(*uintptr)(unsafe.Pointer(v142))
						*(*uintptr)(unsafe.Pointer(v142))++
						*(*uint8)(unsafe.Pointer(v141)) = uint8(libc.Uint32FromInt32(_objIndexCopy5))
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
							(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
						}
						delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
						if delta1 != 0 {
							if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
								delta1 = int32(1) - _objIndexCopy5
							}
							v143 = delta1
							v144 = envPtr2
							if v143 < libc.Int32FromInt32(0) {
								if int32((*TCompileEnv)(unsafe.Pointer(v144)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v144)).FcurrStackDepth) {
									(*TCompileEnv)(unsafe.Pointer(v144)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v144)).FcurrStackDepth
								}
							}
							*(*TTcl_Size)(unsafe.Pointer(v144 + 64)) += int64(v143)
						}
					} else {
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
							XTclExpandCodeArray(tls, envPtr2)
						}
						v146 = envPtr2 + 152
						v145 = *(*uintptr)(unsafe.Pointer(v146))
						*(*uintptr)(unsafe.Pointer(v146))++
						*(*uint8)(unsafe.Pointer(v145)) = libc.Uint8FromInt32(int32(INST_PUSH4))
						v148 = envPtr2 + 152
						v147 = *(*uintptr)(unsafe.Pointer(v148))
						*(*uintptr)(unsafe.Pointer(v148))++
						*(*uint8)(unsafe.Pointer(v147)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(24))
						v150 = envPtr2 + 152
						v149 = *(*uintptr)(unsafe.Pointer(v150))
						*(*uintptr)(unsafe.Pointer(v150))++
						*(*uint8)(unsafe.Pointer(v149)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(16))
						v152 = envPtr2 + 152
						v151 = *(*uintptr)(unsafe.Pointer(v152))
						*(*uintptr)(unsafe.Pointer(v152))++
						*(*uint8)(unsafe.Pointer(v151)) = uint8(libc.Uint32FromInt32(_objIndexCopy5) >> libc.Int32FromInt32(8))
						v154 = envPtr2 + 152
						v153 = *(*uintptr)(unsafe.Pointer(v154))
						*(*uintptr)(unsafe.Pointer(v154))++
						*(*uint8)(unsafe.Pointer(v153)) = uint8(libc.Uint32FromInt32(_objIndexCopy5))
						if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
							(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
						}
						delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
						if delta1 != 0 {
							if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
								delta1 = int32(1) - _objIndexCopy5
							}
							v155 = delta1
							v156 = envPtr2
							if v155 < libc.Int32FromInt32(0) {
								if int32((*TCompileEnv)(unsafe.Pointer(v156)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v156)).FcurrStackDepth) {
									(*TCompileEnv)(unsafe.Pointer(v156)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v156)).FcurrStackDepth
								}
							}
							*(*TTcl_Size)(unsafe.Pointer(v156 + 64)) += int64(v155)
						}
					}
				} else {
					XTclCompileSyntaxError(tls, interp, envPtr2)
				}
				XTcl_RestoreInterpState(tls, interp, save)
				convert = 0
			} else {
				nodePtr = nodes + uintptr(next)*16
			}
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclSingleOpCmd --
 *
 *	Implements the commands: ~, !, <<, >>, %, !=, ne, in, ni
 *	in the ::tcl::mathop namespace.  These commands have no
 *	extension to arbitrary arguments; they accept only exactly one
 *	or exactly two arguments as suitable for the operator.
 *
 * Results:
 *	A standard Tcl return code and result left in interp.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclSingleOpCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var occdPtr uintptr
	var _ /* lexeme at bp+0 */ uint8
	var _ /* litObjv at bp+40 */ uintptr
	var _ /* nodes at bp+4 */ [2]TOpNode
	_ = occdPtr
	occdPtr = clientData
	*(*uintptr)(unsafe.Pointer(bp + 40)) = objv + uintptr(1)*8
	if objc != int32(1)+*(*int32)(unsafe.Pointer(occdPtr + 16)) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, (*TTclOpCmdClientData)(unsafe.Pointer(occdPtr)).Fexpected)
		return int32(TCL_ERROR)
	}
	_ParseLexeme(tls, (*TTclOpCmdClientData)(unsafe.Pointer(occdPtr)).Fop, libc.Int64FromUint64(libc.Xstrlen(tls, (*TTclOpCmdClientData)(unsafe.Pointer(occdPtr)).Fop)), bp, libc.UintptrFromInt32(0))
	(*(*[2]TOpNode)(unsafe.Pointer(bp + 4)))[0].Flexeme = uint8(START)
	(*(*[2]TOpNode)(unsafe.Pointer(bp + 4)))[0].Fmark = uint8(MARK_RIGHT)
	(*(*[2]TOpNode)(unsafe.Pointer(bp + 4)))[0].Fright = int32(1)
	(*(*[2]TOpNode)(unsafe.Pointer(bp + 4)))[int32(1)].Flexeme = *(*uint8)(unsafe.Pointer(bp))
	if objc == int32(2) {
		(*(*[2]TOpNode)(unsafe.Pointer(bp + 4)))[int32(1)].Fmark = uint8(MARK_RIGHT)
	} else {
		(*(*[2]TOpNode)(unsafe.Pointer(bp + 4)))[int32(1)].Fmark = uint8(MARK_LEFT)
		(*(*[2]TOpNode)(unsafe.Pointer(bp + 4)))[int32(1)].Fleft = int32(OT_LITERAL)
	}
	(*(*[2]TOpNode)(unsafe.Pointer(bp + 4)))[int32(1)].Fright = int32(OT_LITERAL)
	*(*int32)(unsafe.Pointer(bp + 4 + 1*16 + 8)) = 0
	return _ExecConstantExprTree(tls, interp, bp+4, 0, bp+40)
}

/*
 *----------------------------------------------------------------------
 *
 * TclSortingOpCmd --
 *	Implements the commands:
 *		<, <=, >, >=, ==, eq, lt, le, gt, ge
 *	in the ::tcl::mathop namespace. These commands are defined for
 *	arbitrary number of arguments by computing the AND of the base
 *	operator applied to all neighbor argument pairs.
 *
 * Results:
 *	A standard Tcl return code and result left in interp.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclSortingOpCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var code, i, lastAnd int32
	var litObjv, nodes, occdPtr uintptr
	var _ /* lexeme at bp+0 */ uint8
	var _ /* litObjPtrPtr at bp+8 */ uintptr
	_, _, _, _, _, _ = code, i, lastAnd, litObjv, nodes, occdPtr
	code = TCL_OK
	if objc < int32(3) {
		XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(int32(1) != 0)))
	} else {
		occdPtr = clientData
		litObjv = XTclStackAlloc(tls, interp, libc.Uint64FromInt32(int32(2)*(objc-int32(2)))*uint64(8))
		nodes = XTclStackAlloc(tls, interp, libc.Uint64FromInt32(int32(2)*(objc-int32(2)))*uint64(16))
		lastAnd = int32(1)
		*(*uintptr)(unsafe.Pointer(bp + 8)) = litObjv
		_ParseLexeme(tls, (*TTclOpCmdClientData)(unsafe.Pointer(occdPtr)).Fop, libc.Int64FromUint64(libc.Xstrlen(tls, (*TTclOpCmdClientData)(unsafe.Pointer(occdPtr)).Fop)), bp, libc.UintptrFromInt32(0))
		*(*uintptr)(unsafe.Pointer(litObjv)) = *(*uintptr)(unsafe.Pointer(objv + 1*8))
		(*(*TOpNode)(unsafe.Pointer(nodes))).Flexeme = uint8(START)
		(*(*TOpNode)(unsafe.Pointer(nodes))).Fmark = uint8(MARK_RIGHT)
		i = int32(2)
		for {
			if !(i < objc-int32(1)) {
				break
			}
			*(*uintptr)(unsafe.Pointer(litObjv + uintptr(int32(2)*(i-int32(1))-int32(1))*8)) = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
			(*(*TOpNode)(unsafe.Pointer(nodes + uintptr(int32(2)*(i-int32(1))-int32(1))*16))).Flexeme = *(*uint8)(unsafe.Pointer(bp))
			(*(*TOpNode)(unsafe.Pointer(nodes + uintptr(int32(2)*(i-int32(1))-int32(1))*16))).Fmark = uint8(MARK_LEFT)
			(*(*TOpNode)(unsafe.Pointer(nodes + uintptr(int32(2)*(i-int32(1))-int32(1))*16))).Fleft = int32(OT_LITERAL)
			(*(*TOpNode)(unsafe.Pointer(nodes + uintptr(int32(2)*(i-int32(1))-int32(1))*16))).Fright = int32(OT_LITERAL)
			*(*uintptr)(unsafe.Pointer(litObjv + uintptr(int32(2)*(i-int32(1)))*8)) = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
			(*(*TOpNode)(unsafe.Pointer(nodes + uintptr(int32(2)*(i-int32(1)))*16))).Flexeme = uint8(AND)
			(*(*TOpNode)(unsafe.Pointer(nodes + uintptr(int32(2)*(i-int32(1)))*16))).Fmark = uint8(MARK_LEFT)
			(*(*TOpNode)(unsafe.Pointer(nodes + uintptr(int32(2)*(i-int32(1)))*16))).Fleft = lastAnd
			*(*int32)(unsafe.Pointer(nodes + uintptr(lastAnd)*16 + 8)) = int32(2) * (i - int32(1))
			(*(*TOpNode)(unsafe.Pointer(nodes + uintptr(int32(2)*(i-int32(1)))*16))).Fright = int32(2)*(i-int32(1)) + int32(1)
			*(*int32)(unsafe.Pointer(nodes + uintptr(int32(2)*(i-int32(1))+int32(1))*16 + 8)) = int32(2) * (i - int32(1))
			lastAnd = int32(2) * (i - int32(1))
			goto _1
		_1:
			;
			i++
		}
		*(*uintptr)(unsafe.Pointer(litObjv + uintptr(int32(2)*(objc-int32(2))-int32(1))*8)) = *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8))
		(*(*TOpNode)(unsafe.Pointer(nodes + uintptr(int32(2)*(objc-int32(2))-int32(1))*16))).Flexeme = *(*uint8)(unsafe.Pointer(bp))
		(*(*TOpNode)(unsafe.Pointer(nodes + uintptr(int32(2)*(objc-int32(2))-int32(1))*16))).Fmark = uint8(MARK_LEFT)
		(*(*TOpNode)(unsafe.Pointer(nodes + uintptr(int32(2)*(objc-int32(2))-int32(1))*16))).Fleft = int32(OT_LITERAL)
		(*(*TOpNode)(unsafe.Pointer(nodes + uintptr(int32(2)*(objc-int32(2))-int32(1))*16))).Fright = int32(OT_LITERAL)
		(*(*TOpNode)(unsafe.Pointer(nodes))).Fright = lastAnd
		*(*int32)(unsafe.Pointer(nodes + uintptr(lastAnd)*16 + 8)) = 0
		code = _ExecConstantExprTree(tls, interp, nodes, 0, bp+8)
		XTclStackFree(tls, interp, nodes)
		XTclStackFree(tls, interp, litObjv)
	}
	return code
}

/*
 *----------------------------------------------------------------------
 *
 * TclVariadicOpCmd --
 *	Implements the commands: +, *, &, |, ^, **
 *	in the ::tcl::mathop namespace. These commands are defined for
 *	arbitrary number of arguments by repeatedly applying the base
 *	operator with suitable associative rules. When fewer than two
 *	arguments are provided, suitable identity values are returned.
 *
 * Results:
 *	A standard Tcl return code and result left in interp.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclVariadicOpCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var _objPtr, cachePtr, cachePtr1, cachePtr2, nodes1, occdPtr, v5 uintptr
	var code, decrMe, i, lastOp int32
	var v1, v2, v3 bool
	var v4 TTcl_Size
	var _ /* lexeme at bp+0 */ uint8
	var _ /* litObjPtrPtr at bp+56 */ uintptr
	var _ /* litObjv at bp+64 */ uintptr
	var _ /* litObjv at bp+8 */ [2]uintptr
	var _ /* nodes at bp+24 */ [2]TOpNode
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, cachePtr1, cachePtr2, code, decrMe, i, lastOp, nodes1, occdPtr, v1, v2, v3, v4, v5
	occdPtr = clientData
	if objc < int32(2) {
		XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, int64(*(*int32)(unsafe.Pointer(occdPtr + 16)))))
		return TCL_OK
	}
	_ParseLexeme(tls, (*TTclOpCmdClientData)(unsafe.Pointer(occdPtr)).Fop, libc.Int64FromUint64(libc.Xstrlen(tls, (*TTclOpCmdClientData)(unsafe.Pointer(occdPtr)).Fop)), bp, libc.UintptrFromInt32(0))
	*(*uint8)(unsafe.Pointer(bp)) = uint8(int32(*(*uint8)(unsafe.Pointer(bp))) | int32(BINARY))
	if objc == int32(2) {
		decrMe = 0
		*(*uintptr)(unsafe.Pointer(bp + 56)) = bp + 8
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32(EXPON) {
			if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				(*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] = XTclThreadAllocObj(tls)
			} else {
				(*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).Fbytes = libc.UintptrFromInt32(0)
			*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).FinternalRep)) = int64(*(*int32)(unsafe.Pointer(occdPtr + 16)))
			(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
			(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).FrefCount++
			decrMe = int32(1)
			(*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0] = *(*uintptr)(unsafe.Pointer(objv + 1*8))
			(*(*[2]TOpNode)(unsafe.Pointer(bp + 24)))[0].Flexeme = uint8(START)
			(*(*[2]TOpNode)(unsafe.Pointer(bp + 24)))[0].Fmark = uint8(MARK_RIGHT)
			(*(*[2]TOpNode)(unsafe.Pointer(bp + 24)))[0].Fright = int32(1)
			(*(*[2]TOpNode)(unsafe.Pointer(bp + 24)))[int32(1)].Flexeme = *(*uint8)(unsafe.Pointer(bp))
			(*(*[2]TOpNode)(unsafe.Pointer(bp + 24)))[int32(1)].Fmark = uint8(MARK_LEFT)
			(*(*[2]TOpNode)(unsafe.Pointer(bp + 24)))[int32(1)].Fleft = int32(OT_LITERAL)
			(*(*[2]TOpNode)(unsafe.Pointer(bp + 24)))[int32(1)].Fright = int32(OT_LITERAL)
			*(*int32)(unsafe.Pointer(bp + 24 + 1*16 + 8)) = 0
		} else {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32(DIVIDE) {
				if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
					cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
					(*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0] = XTclThreadAllocObj(tls)
				} else {
					(*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0] = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0] + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0])).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0])).Fbytes = libc.UintptrFromInt32(0)
				*(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0])).FinternalRep)) = libc.Float64FromFloat64(1)
				(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0])).FtypePtr = uintptr(unsafe.Pointer(&XtclDoubleType))
			} else {
				if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
					cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
					(*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0] = XTclThreadAllocObj(tls)
				} else {
					(*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0] = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0] + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0])).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0])).Fbytes = libc.UintptrFromInt32(0)
				*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0])).FinternalRep)) = int64(*(*int32)(unsafe.Pointer(occdPtr + 16)))
				(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0])).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
			}
			(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0])).FrefCount++
			(*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] = *(*uintptr)(unsafe.Pointer(objv + 1*8))
			(*(*[2]TOpNode)(unsafe.Pointer(bp + 24)))[0].Flexeme = uint8(START)
			(*(*[2]TOpNode)(unsafe.Pointer(bp + 24)))[0].Fmark = uint8(MARK_RIGHT)
			(*(*[2]TOpNode)(unsafe.Pointer(bp + 24)))[0].Fright = int32(1)
			(*(*[2]TOpNode)(unsafe.Pointer(bp + 24)))[int32(1)].Flexeme = *(*uint8)(unsafe.Pointer(bp))
			(*(*[2]TOpNode)(unsafe.Pointer(bp + 24)))[int32(1)].Fmark = uint8(MARK_LEFT)
			(*(*[2]TOpNode)(unsafe.Pointer(bp + 24)))[int32(1)].Fleft = int32(OT_LITERAL)
			(*(*[2]TOpNode)(unsafe.Pointer(bp + 24)))[int32(1)].Fright = int32(OT_LITERAL)
			*(*int32)(unsafe.Pointer(bp + 24 + 1*16 + 8)) = 0
		}
		code = _ExecConstantExprTree(tls, interp, bp+24, 0, bp+56)
		_objPtr = (*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[decrMe]
		v5 = _objPtr
		v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
		*(*TTcl_Size)(unsafe.Pointer(v5))--
		if v4 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		return code
	} else {
		*(*uintptr)(unsafe.Pointer(bp + 64)) = objv + uintptr(1)*8
		nodes1 = XTclStackAlloc(tls, interp, libc.Uint64FromInt32(objc-libc.Int32FromInt32(1))*uint64(16))
		lastOp = int32(OT_LITERAL)
		(*(*TOpNode)(unsafe.Pointer(nodes1))).Flexeme = uint8(START)
		(*(*TOpNode)(unsafe.Pointer(nodes1))).Fmark = uint8(MARK_RIGHT)
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32(EXPON) {
			i = objc - int32(2)
			for {
				if !(i > 0) {
					break
				}
				(*(*TOpNode)(unsafe.Pointer(nodes1 + uintptr(i)*16))).Flexeme = *(*uint8)(unsafe.Pointer(bp))
				(*(*TOpNode)(unsafe.Pointer(nodes1 + uintptr(i)*16))).Fmark = uint8(MARK_LEFT)
				(*(*TOpNode)(unsafe.Pointer(nodes1 + uintptr(i)*16))).Fleft = int32(OT_LITERAL)
				(*(*TOpNode)(unsafe.Pointer(nodes1 + uintptr(i)*16))).Fright = lastOp
				if lastOp >= 0 {
					*(*int32)(unsafe.Pointer(nodes1 + uintptr(lastOp)*16 + 8)) = i
				}
				lastOp = i
				goto _6
			_6:
				;
				i--
			}
		} else {
			i = int32(1)
			for {
				if !(i < objc-int32(1)) {
					break
				}
				(*(*TOpNode)(unsafe.Pointer(nodes1 + uintptr(i)*16))).Flexeme = *(*uint8)(unsafe.Pointer(bp))
				(*(*TOpNode)(unsafe.Pointer(nodes1 + uintptr(i)*16))).Fmark = uint8(MARK_LEFT)
				(*(*TOpNode)(unsafe.Pointer(nodes1 + uintptr(i)*16))).Fleft = lastOp
				if lastOp >= 0 {
					*(*int32)(unsafe.Pointer(nodes1 + uintptr(lastOp)*16 + 8)) = i
				}
				(*(*TOpNode)(unsafe.Pointer(nodes1 + uintptr(i)*16))).Fright = int32(OT_LITERAL)
				lastOp = i
				goto _7
			_7:
				;
				i++
			}
		}
		(*(*TOpNode)(unsafe.Pointer(nodes1))).Fright = lastOp
		*(*int32)(unsafe.Pointer(nodes1 + uintptr(lastOp)*16 + 8)) = 0
		code = _ExecConstantExprTree(tls, interp, nodes1, 0, bp+64)
		XTclStackFree(tls, interp, nodes1)
		return code
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * TclNoIdentOpCmd --
 *	Implements the commands: -, /
 *	in the ::tcl::mathop namespace. These commands are defined for
 *	arbitrary non-zero number of arguments by repeatedly applying the base
 *	operator with suitable associative rules. When no arguments are
 *	provided, an error is raised.
 *
 * Results:
 *	A standard Tcl return code and result left in interp.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclNoIdentOpCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var occdPtr uintptr
	_ = occdPtr
	occdPtr = clientData
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, (*TTclOpCmdClientData)(unsafe.Pointer(occdPtr)).Fexpected)
		return int32(TCL_ERROR)
	}
	return XTclVariadicOpCmd(tls, clientData, interp, objc, objv)
}

const NUM_STATIC_POS = 20

func init() {
	p := unsafe.Pointer(&XtclByteCodeType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_FreeByteCodeInternalRep)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_DupByteCodeInternalRep)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_SetByteCodeFromAny)
}

/*
 * substCodeType provides the standard type management procedures for the
 * substcode type, which represents substitution within a Tcl value.
 */

var _substCodeType = TTcl_ObjType{
	Fname: __ccgo_ts + 23867,
}

func init() {
	p := unsafe.Pointer(&_substCodeType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_FreeSubstCodeInternalRep)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_DupByteCodeInternalRep)
}

/*
 * Helper macros.
 */

/*
 *----------------------------------------------------------------------
 *
 * TclSetByteCodeFromAny --
 *
 *	Part of the bytecode Tcl object type implementation. Attempts to
 *	compile the string representation of the objPtr into bytecode.  Accepts
 *	a hook routine that is invoked to perform any needed post-processing on
 *	the compilation results before generating byte codes.  interp is the
 *	compilation context and may not be NULL.
 *
 * Results:
 *	A standard Tcl object result. If an error occurs during compilation, an
 *	error message is left in the interpreter's result.
 *
 * Side effects:
 *	Frees the old internal representation. If no error occurs, then the
 *	compiled code is stored as "objPtr"s bytecode representation. Also, if
 *	debugging, initializes the "tcl_traceCompile" Tcl variable used to
 *	trace compilations.
 *
 *----------------------------------------------------------------------
 */

func XTclSetByteCodeFromAny(tls *libc.TLS, interp uintptr, objPtr uintptr, hookProc uintptr, clientData uintptr) (r int32) {
	bp := tls.Alloc(4576)
	defer tls.Free(4576) /* Hook procedure private data. */
	var clLocPtr, iPtr, procPtr, stringPtr, v1, v2, v3, v5, v6, v7, v9 uintptr
	var delta1, result, v4, v8 int32
	var _ /* compEnv at bp+0 */ TCompileEnv
	var _ /* length at bp+4544 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = clLocPtr, delta1, iPtr, procPtr, result, stringPtr, v1, v2, v3, v4, v5, v6, v7, v8, v9
	iPtr = interp
	result = TCL_OK
	procPtr = (*TInterp)(unsafe.Pointer(iPtr)).FcompiledProcPtr
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 4544)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, objPtr, bp+4544)
	}
	stringPtr = v1
	/*
	 * TIP #280: Pick up the CmdFrame in which the BC compiler was invoked, and
	 * use to initialize the tracking in the compiler. This information was
	 * stored by TclCompEvalObj and ProcCompileProc.
	 */
	XTclInitCompileEnv(tls, interp, bp, stringPtr, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 4544))), (*TInterp)(unsafe.Pointer(iPtr)).FinvokeCmdFramePtr, (*TInterp)(unsafe.Pointer(iPtr)).FinvokeWord)
	/*
	 * Make available to the compilation environment any data about invisible
	 * continuation lines for the script.
	 *
	 * It is not clear if the script Tcl_Obj* can be free'd while the compiler
	 * is using it, leading to the release of the associated ContLineLoc
	 * structure as well. To ensure that the latter doesn't happen set a lock
	 * on it, which is released in TclFreeCompileEnv().  The "lineCLPtr"
	 * hashtable tclObj.c.
	 */
	clLocPtr = XTclContinuationsGet(tls, objPtr)
	if clLocPtr != 0 {
		(*(*TCompileEnv)(unsafe.Pointer(bp))).FclNext = clLocPtr + 8
	}
	XTclCompileScript(tls, interp, stringPtr, *(*TTcl_Size)(unsafe.Pointer(bp + 4544)), bp)
	/*
	 * Compilation succeeded. Add a "done" instruction at the end.
	 */
	if (*TCompileEnv)(unsafe.Pointer(bp)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(bp)).FcodeEnd {
		XTclExpandCodeArray(tls, bp)
	}
	v3 = bp + 152
	v2 = *(*uintptr)(unsafe.Pointer(v3))
	*(*uintptr)(unsafe.Pointer(v3))++
	*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32(INST_DONE))
	if (*TCompileEnv)(unsafe.Pointer(bp)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(bp)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_DONE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v4 = delta1
		v5 = bp
		if v4 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v5)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v5)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v5)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v5)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v5 + 64)) += int64(v4)
	}
	/*
	 * Check for optimizations!
	 *
	 * If the generated code is free of most hazards, recompile with generation
	 * of INST_START_CMD disabled to produce code that more compact in many
	 * cases, and also sometimes more performant.
	 */
	if XTcl_GetParent(tls, interp) == libc.UintptrFromInt32(0) && !(XTcl_LimitTypeEnabled(tls, interp, libc.Int32FromInt32(TCL_LIMIT_COMMANDS)|libc.Int32FromInt32(TCL_LIMIT_TIME)) != 0) && _IsCompactibleCompileEnv(tls, bp) != 0 {
		XTclFreeCompileEnv(tls, bp)
		(*TInterp)(unsafe.Pointer(iPtr)).FcompiledProcPtr = procPtr
		XTclInitCompileEnv(tls, interp, bp, stringPtr, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 4544))), (*TInterp)(unsafe.Pointer(iPtr)).FinvokeCmdFramePtr, (*TInterp)(unsafe.Pointer(iPtr)).FinvokeWord)
		if clLocPtr != 0 {
			(*(*TCompileEnv)(unsafe.Pointer(bp))).FclNext = clLocPtr + 8
		}
		(*(*TCompileEnv)(unsafe.Pointer(bp))).FatCmdStart = int32(2) /* The disabling magic. */
		XTclCompileScript(tls, interp, stringPtr, *(*TTcl_Size)(unsafe.Pointer(bp + 4544)), bp)
		if (*TCompileEnv)(unsafe.Pointer(bp)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(bp)).FcodeEnd {
			XTclExpandCodeArray(tls, bp)
		}
		v7 = bp + 152
		v6 = *(*uintptr)(unsafe.Pointer(v7))
		*(*uintptr)(unsafe.Pointer(v7))++
		*(*uint8)(unsafe.Pointer(v6)) = libc.Uint8FromInt32(int32(INST_DONE))
		if (*TCompileEnv)(unsafe.Pointer(bp)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(bp)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_DONE)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v8 = delta1
			v9 = bp
			if v8 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v9)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v9)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v9)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v9)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v9 + 64)) += int64(v8)
		}
	}
	/*
	 * Apply some peephole optimizations that can cross specific/generic
	 * instruction generator boundaries.
	 */
	if (*TInterp)(unsafe.Pointer(iPtr)).Foptimizer != 0 {
		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TInterp)(unsafe.Pointer(iPtr)).Foptimizer})))(tls, bp)
	}
	/*
	 * Invoke the compilation hook procedure if there is one.
	 */
	if hookProc != 0 {
		result = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{hookProc})))(tls, interp, bp, clientData)
	}
	/*
	 * After optimization is all done, check that byte code length limits
	 * are not exceeded. Bug [27b3ce2997].
	 */
	if int64((*(*TCompileEnv)(unsafe.Pointer(bp))).FcodeNext)-int64((*(*TCompileEnv)(unsafe.Pointer(bp))).FcodeStart) > int64(INT_MAX) {
		/*
		 * Cannot just return TCL_ERROR as callers ignore return value.
		 * TODO - May be use TclCompileSyntaxError here?
		 */
		XTcl_Panic(tls, __ccgo_ts+23877, libc.VaList(bp+4560, int32(INT_MAX)))
	}
	/*
	 * Change the object into a ByteCode object. Ownership of the literal
	 * objects and aux data items passes to the ByteCode object.
	 */
	if result == TCL_OK {
		XTclInitByteCodeObj(tls, objPtr, uintptr(unsafe.Pointer(&XtclByteCodeType)), bp)
		_ = objPtr
	}
	XTclFreeCompileEnv(tls, bp)
	return result
}

/*
 *-----------------------------------------------------------------------
 *
 * SetByteCodeFromAny --
 *
 *	Part of the bytecode Tcl object type implementation. Attempts to
 *	generate an byte code internal form for the Tcl object "objPtr" by
 *	compiling its string representation.
 *
 * Results:
 *	A standard Tcl object result. If an error occurs during compilation and
 *	"interp" is not null, an error message is left in the interpreter's
 *	result.
 *
 * Side effects:
 *	Frees the old internal representation. If no error occurs then the
 *	compiled code is stored as "objPtr"s bytecode representation. Also, if
 *	debugging, initializes the "tcl_traceCompile" Tcl variable used to
 *	trace compilations.
 *
 *----------------------------------------------------------------------
 */

func _SetByteCodeFromAny(tls *libc.TLS, interp uintptr, objPtr uintptr) (r int32) {
	/* The object to compile to bytecode */
	if interp == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	return XTclSetByteCodeFromAny(tls, interp, objPtr, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
}

/*
 *----------------------------------------------------------------------
 *
 * DupByteCodeInternalRep --
 *
 *	Part of the bytecode Tcl object type implementation. However, it does
 *	not copy the internal representation of a bytecode Tcl_Obj, instead
 *	assigning NULL to the type pointer of the new object.  Code is compiled
 *	for the new object only if necessary.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _DupByteCodeInternalRep(tls *libc.TLS, dummy966 uintptr, dummy967 uintptr) {
	return
}

/*
 *----------------------------------------------------------------------
 *
 * FreeByteCodeInternalRep --
 *
 *	Part of the bytecode Tcl object type implementation. Frees the storage
 *	associated with a bytecode object's internal representation unless its
 *	code is actively being executed.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The bytecode object's internal rep is invalidated and its code is freed
 *	unless the code is actively being executed, in which case cleanup is
 *	delayed until the last execution of the code completes.
 *
 *----------------------------------------------------------------------
 */

func _FreeByteCodeInternalRep(tls *libc.TLS, objPtr uintptr) {
	/* Object whose internal rep to free. */
	var codePtr, irPtr, v1, v2 uintptr
	_, _, _, _ = codePtr, irPtr, v1, v2
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclByteCodeType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	codePtr = v2
	XTclReleaseByteCode(tls, codePtr)
}

/*
 *----------------------------------------------------------------------
 *
 * TclReleaseByteCode --
 *
 *	Does all the real work of freeing up a bytecode object's ByteCode
 *	structure. Called only when the structure's reference count
 *	is zero.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Frees objPtr's bytecode internal representation and sets its type to
 *	NULL.  Also releases its literals and frees its auxiliary data items.
 *
 *----------------------------------------------------------------------
 */

func XTclPreserveByteCode(tls *libc.TLS, codePtr uintptr) {
	(*TByteCode)(unsafe.Pointer(codePtr)).FrefCount++
}

func XTclReleaseByteCode(tls *libc.TLS, codePtr uintptr) {
	var v1 TTcl_Size
	var v2 uintptr
	_, _ = v1, v2
	v2 = codePtr + 32
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 > int64(1) {
		return
	}
	/* Just dropped to refcount==0.  Clean up. */
	_CleanupByteCode(tls, codePtr)
}

func _CleanupByteCode(tls *libc.TLS, codePtr uintptr) {
	/* Points to the ByteCode to free. */
	var _objPtr, auxDataPtr, hePtr, iPtr, interp, objArrayPtr, objPtr, v3, v5, v8 uintptr
	var i, numAuxDataItems, numLitObjects, v4 int32
	var v2, v7 TTcl_Size
	var v9 bool
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, auxDataPtr, hePtr, i, iPtr, interp, numAuxDataItems, numLitObjects, objArrayPtr, objPtr, v2, v3, v4, v5, v7, v8, v9
	interp = *(*uintptr)(unsafe.Pointer((*TByteCode)(unsafe.Pointer(codePtr)).FinterpHandle))
	iPtr = interp
	numLitObjects = int32((*TByteCode)(unsafe.Pointer(codePtr)).FnumLitObjects)
	numAuxDataItems = int32((*TByteCode)(unsafe.Pointer(codePtr)).FnumAuxDataItems)
	/*
	 * A single heap object holds the ByteCode structure and its code, object,
	 * command location, and auxiliary data arrays. This means we only need to
	 * 1) decrement the ref counts of each LiteralEntry in the literal array,
	 * 2) call the free procedures for the auxiliary data items, 3) free the
	 * localCache if it is unused, and finally 4) free the ByteCode
	 * structure's heap object.
	 *
	 * The case for TCL_BYTECODE_PRECOMPILED (precompiled ByteCodes, like
	 * those generated from tbcload) is special, as they doesn't make use of
	 * the global literal table. They instead maintain private references to
	 * their literals which must be decremented.
	 *
	 * In order to ensure proper and efficient cleanup of the literal array
	 * when it contains non-shared literals [Bug 983660], distinguish the case
	 * of an interpreter being deleted, which is signaled by interp == NULL.
	 * Also, as the interp deletion will remove the global literal table
	 * anyway, avoid the extra cost of updating it for each literal being
	 * released.
	 */
	if (*TByteCode)(unsafe.Pointer(codePtr)).Fflags&uint32(TCL_BYTECODE_PRECOMPILED) != 0 {
		objArrayPtr = (*TByteCode)(unsafe.Pointer(codePtr)).FobjArrayPtr
		i = 0
		for {
			if !(i < numLitObjects) {
				break
			}
			objPtr = *(*uintptr)(unsafe.Pointer(objArrayPtr))
			if objPtr != 0 {
				_objPtr = objPtr
				v3 = _objPtr
				v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
				*(*TTcl_Size)(unsafe.Pointer(v3))--
				if v2 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
			objArrayPtr += 8
			goto _1
		_1:
			;
			i++
		}
		(*TByteCode)(unsafe.Pointer(codePtr)).FnumLitObjects = 0
	} else {
		objArrayPtr = (*TByteCode)(unsafe.Pointer(codePtr)).FobjArrayPtr
		for {
			v4 = numLitObjects
			numLitObjects--
			if !(v4 != 0) {
				break
			}
			/* TclReleaseLiteral calls Tcl_DecrRefCount() for us */
			v5 = objArrayPtr
			objArrayPtr += 8
			XTclReleaseLiteral(tls, interp, *(*uintptr)(unsafe.Pointer(v5)))
		}
	}
	auxDataPtr = (*TByteCode)(unsafe.Pointer(codePtr)).FauxDataArrayPtr
	i = 0
	for {
		if !(i < numAuxDataItems) {
			break
		}
		if (*TAuxDataType)(unsafe.Pointer((*TAuxData)(unsafe.Pointer(auxDataPtr)).Ftype1)).FfreeProc != libc.UintptrFromInt32(0) {
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TAuxDataType)(unsafe.Pointer((*TAuxData)(unsafe.Pointer(auxDataPtr)).Ftype1)).FfreeProc})))(tls, (*TAuxData)(unsafe.Pointer(auxDataPtr)).FclientData)
		}
		auxDataPtr += 16
		goto _6
	_6:
		;
		i++
	}
	/*
	 * TIP #280. Release the location data associated with this bytecode
	 * structure, if any. The associated interp may be gone already, and the
	 * data with it.
	 *
	 * See also tclBasic.c, DeleteInterpProc
	 */
	if iPtr != 0 {
		hePtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FlineBCPtr)).FfindProc})))(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlineBCPtr, codePtr)
		if hePtr != 0 {
			_ReleaseCmdWordData(tls, (*TTcl_HashEntry)(unsafe.Pointer(hePtr)).FclientData)
			XTcl_DeleteHashEntry(tls, hePtr)
		}
	}
	if v9 = (*TByteCode)(unsafe.Pointer(codePtr)).FlocalCachePtr != 0; v9 {
		v8 = (*TByteCode)(unsafe.Pointer(codePtr)).FlocalCachePtr
		v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
		*(*TTcl_Size)(unsafe.Pointer(v8))--
	}
	if v9 && v7 <= int64(1) {
		XTclFreeLocalCache(tls, interp, (*TByteCode)(unsafe.Pointer(codePtr)).FlocalCachePtr)
	}
	XTclHandleRelease(tls, (*TByteCode)(unsafe.Pointer(codePtr)).FinterpHandle)
	XTclpFree(tls, codePtr)
}

/*
 * ---------------------------------------------------------------------
 *
 * IsCompactibleCompileEnv --
 *
 *	Determines whether some basic compaction optimizations may be applied
 *	to a piece of bytecode. Idempotent.
 *
 * ---------------------------------------------------------------------
 */

func _IsCompactibleCompileEnv(tls *libc.TLS, envPtr uintptr) (r int32) {
	var nsPtr, pc uintptr
	var size int32
	_, _, _ = nsPtr, pc, size
	/*
	 * Special: procedures in the '::tcl' namespace (or its children) are
	 * considered to be well-behaved, so compaction can be applied to them even
	 * if it would otherwise be invalid.
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr)).FprocPtr != libc.UintptrFromInt32(0) && (*TProc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FprocPtr)).FcmdPtr != libc.UintptrFromInt32(0) && (*TCommand1)(unsafe.Pointer((*TProc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FprocPtr)).FcmdPtr)).FnsPtr != libc.UintptrFromInt32(0) {
		nsPtr = (*TCommand1)(unsafe.Pointer((*TProc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FprocPtr)).FcmdPtr)).FnsPtr
		if libc.Xstrcmp(tls, (*TNamespace)(unsafe.Pointer(nsPtr)).FfullName, __ccgo_ts+23915) == 0 || libc.Xstrncmp(tls, (*TNamespace)(unsafe.Pointer(nsPtr)).FfullName, __ccgo_ts+23921, uint64(7)) == 0 {
			return int32(1)
		}
	}
	/*
	 * Go through and ensure that no operation involved can cause a desired
	 * change of bytecode sequence during its execution. This comes down to
	 * ensuring that there are no mapped variables (due to traces) or calls to
	 * external commands (traces, [uplevel] trickery). This is actually a very
	 * conservative check.  It turns down a lot of code that is OK in practice.
	 */
	pc = (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart
	for {
		if !(pc < (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext) {
			break
		}
		switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) {
		/* Invokes */
		case int32(INST_INVOKE_STK1):
			fallthrough
		case int32(INST_INVOKE_STK4):
			fallthrough
		case int32(INST_INVOKE_EXPANDED):
			fallthrough
		case int32(INST_INVOKE_REPLACE):
			return 0
			/* Runtime evals */
			fallthrough
		case int32(INST_EVAL_STK):
			fallthrough
		case int32(INST_EXPR_STK):
			fallthrough
		case int32(INST_YIELD):
			return 0
			/* Upvars */
			fallthrough
		case int32(INST_UPVAR):
			fallthrough
		case int32(INST_NSUPVAR):
			fallthrough
		case int32(INST_VARIABLE):
			return 0
		default:
			size = int32(XtclInstructionTable[*(*uint8)(unsafe.Pointer(pc))].FnumBytes)
			break
		}
		goto _1
	_1:
		;
		pc += uintptr(size)
	}
	return int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SubstObj --
 *
 *	Performs substitutions on the given string as described in the user
 *	documentation for "subst".
 *
 * Results:
 *	A Tcl_Obj* containing the substituted string, or NULL to indicate that
 *	an error occurred.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SubstObj(tls *libc.TLS, interp uintptr, objPtr uintptr, flags int32) (r uintptr) {
	/* What substitutions to do. */
	var rootPtr uintptr
	_ = rootPtr
	rootPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	if XTclNRRunCallbacks(tls, interp, XTcl_NRSubstObj(tls, interp, objPtr, flags), rootPtr) != TCL_OK {
		return libc.UintptrFromInt32(0)
	}
	return XTcl_GetObjResult(tls, interp)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_NRSubstObj --
 *
 *	Adds substitution within the value of objPtr to the NR execution stack.
 *
 * Results:
 *	TCL_OK.
 *
 * Side effects:
 *	Compiles objPtr into bytecode that performs the substitutions as
 *	governed by flags, adds a callback to the NR execution stack to execute
 *	the bytecode and store the result in the interp.
 *
 *----------------------------------------------------------------------
 */

func XTcl_NRSubstObj(tls *libc.TLS, interp uintptr, objPtr uintptr, flags int32) (r int32) {
	var codePtr uintptr
	_ = codePtr
	codePtr = _CompileSubstObj(tls, interp, objPtr, flags)
	/* TODO: Confirm we do not need this. */
	/* Tcl_ResetResult(interp); */
	return XTclNRExecuteByteCode(tls, interp, codePtr)
}

/*
 *----------------------------------------------------------------------
 *
 * CompileSubstObj --
 *
 *	Compiles a value into bytecode that performs substitution within the
 *	value, as governed by flags.
 *
 * Results:
 *	A (ByteCode *) is pointing to the resulting ByteCode.
 *
 * Side effects:
 *	The Tcl_ObjType of objPtr is changed to the "substcode" type, and the
 *	ByteCode and governing flags value are kept in the internal rep for
 *	faster operations the next time CompileSubstObj is called on the same
 *	value.
 *
 *----------------------------------------------------------------------
 */

func _CompileSubstObj(tls *libc.TLS, interp uintptr, objPtr uintptr, flags int32) (r uintptr) {
	bp := tls.Alloc(4560)
	defer tls.Free(4560)
	var bytes, codePtr, iPtr, irPtr, nsPtr, v1, v2, v3, v4, v5, v7 uintptr
	var delta1, v6 int32
	var _ /* compEnv at bp+0 */ TCompileEnv
	var _ /* numBytes at bp+4544 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _ = bytes, codePtr, delta1, iPtr, irPtr, nsPtr, v1, v2, v3, v4, v5, v6, v7
	iPtr = interp
	codePtr = libc.UintptrFromInt32(0)
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_substCodeType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	codePtr = v2
	if codePtr != libc.UintptrFromInt32(0) {
		nsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FnsPtr
		if int64(flags) != int64((*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr2) || *(*uintptr)(unsafe.Pointer((*TByteCode)(unsafe.Pointer(codePtr)).FinterpHandle)) != iPtr || (*TByteCode)(unsafe.Pointer(codePtr)).FcompileEpoch != (*TInterp)(unsafe.Pointer(iPtr)).FcompileEpoch || (*TByteCode)(unsafe.Pointer(codePtr)).FnsPtr != nsPtr || (*TByteCode)(unsafe.Pointer(codePtr)).FnsEpoch != (*TNamespace)(unsafe.Pointer(nsPtr)).FresolverEpoch || (*TByteCode)(unsafe.Pointer(codePtr)).FlocalCachePtr != (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FlocalCachePtr {
			XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&_substCodeType)), libc.UintptrFromInt32(0))
			codePtr = libc.UintptrFromInt32(0)
		}
	}
	if codePtr == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 4544)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
			v3 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, objPtr, bp+4544)
		}
		bytes = v3
		/* TODO: Check for more TIP 280 */
		XTclInitCompileEnv(tls, interp, bp, bytes, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 4544))), libc.UintptrFromInt32(0), 0)
		XTclSubstCompile(tls, interp, bytes, *(*TTcl_Size)(unsafe.Pointer(bp + 4544)), flags, int64(1), bp)
		if (*TCompileEnv)(unsafe.Pointer(bp)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(bp)).FcodeEnd {
			XTclExpandCodeArray(tls, bp)
		}
		v5 = bp + 152
		v4 = *(*uintptr)(unsafe.Pointer(v5))
		*(*uintptr)(unsafe.Pointer(v5))++
		*(*uint8)(unsafe.Pointer(v4)) = libc.Uint8FromInt32(int32(INST_DONE))
		if (*TCompileEnv)(unsafe.Pointer(bp)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(bp)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_DONE)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v6 = delta1
			v7 = bp
			if v6 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v7 + 64)) += int64(v6)
		}
		codePtr = XTclInitByteCodeObj(tls, objPtr, uintptr(unsafe.Pointer(&_substCodeType)), bp)
		XTclFreeCompileEnv(tls, bp)
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr2 = uintptr(int64(flags))
		if (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FlocalCachePtr != 0 {
			(*TByteCode)(unsafe.Pointer(codePtr)).FlocalCachePtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FlocalCachePtr
			(*TLocalCache)(unsafe.Pointer((*TByteCode)(unsafe.Pointer(codePtr)).FlocalCachePtr)).FrefCount++
		}
		_ = objPtr
	}
	return codePtr
}

/*
 *----------------------------------------------------------------------
 *
 * FreeSubstCodeInternalRep --
 *
 *	Part of the "substcode" Tcl object type implementation. Frees the
 *	storage associated with the substcode internal representation of a
 *	Tcl_Obj unless its code is actively being executed.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The substcode object's internal rep is marked invalid and its code
 *	gets freed unless the code is actively being executed. In that case
 *	the cleanup is delayed until the last execution of the code completes.
 *
 *----------------------------------------------------------------------
 */

func _FreeSubstCodeInternalRep(tls *libc.TLS, objPtr uintptr) {
	/* Object whose internal rep to free. */
	var codePtr, irPtr, v1, v2 uintptr
	_, _, _, _ = codePtr, irPtr, v1, v2
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_substCodeType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	codePtr = v2
	XTclReleaseByteCode(tls, codePtr)
}

func _ReleaseCmdWordData(tls *libc.TLS, eclPtr uintptr) {
	var _objPtr, v2 uintptr
	var i, v1 TTcl_Size
	_, _, _, _ = _objPtr, i, v1, v2
	if (*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Ftype1 == int32(TCL_LOCATION_SOURCE) {
		_objPtr = (*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Fpath
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	i = 0
	for {
		if !(i < (*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Fnuloc) {
			break
		}
		XTclpFree(tls, (*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Floc + uintptr(i)*32))).Fline)
		goto _3
	_3:
		;
		i++
	}
	if (*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Floc != libc.UintptrFromInt32(0) {
		XTclpFree(tls, (*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Floc)
	}
	XTclpFree(tls, eclPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * TclInitCompileEnv --
 *
 *	Initializes a CompileEnv compilation environment structure for the
 *	compilation of a string in an interpreter.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The CompileEnv structure is initialized.
 *
 *----------------------------------------------------------------------
 */

func XTclInitCompileEnv(tls *libc.TLS, interp uintptr, envPtr uintptr, stringPtr uintptr, numBytes Tsize_t, invoker uintptr, word int32) {
	/* Index of the word in that context getting
	 * compiled */
	var _objPtr, cachePtr, cachePtr1, ctxPtr, iPtr, norm, v6 uintptr
	var pc, v3, v4 int32
	var v1, v2 bool
	var v5 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, cachePtr1, ctxPtr, iPtr, norm, pc, v1, v2, v3, v4, v5, v6
	iPtr = interp
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr = iPtr
	(*TCompileEnv)(unsafe.Pointer(envPtr)).Fsource = stringPtr
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FnumSrcBytes = libc.Int64FromUint64(numBytes)
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FprocPtr = (*TInterp)(unsafe.Pointer(iPtr)).FcompiledProcPtr
	(*TInterp)(unsafe.Pointer(iPtr)).FcompiledProcPtr = libc.UintptrFromInt32(0)
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FnumCommands = 0
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptDepth = 0
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FmaxExceptDepth = 0
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FmaxStackDepth = 0
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FcurrStackDepth = 0
	XTclInitLiteralTable(tls, envPtr+72)
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart = envPtr + 288
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext = (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeEnd = (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr(COMPILEENV_INIT_CODE_BYTES)
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FmallocedCodeArray = 0
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FliteralArrayPtr = envPtr + 544
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FliteralArrayNext = 0
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FliteralArrayEnd = int64(COMPILEENV_INIT_NUM_OBJECTS)
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FmallocedLiteralArray = 0
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayPtr = envPtr + 2464
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptAuxArrayPtr = envPtr + 2744
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayNext = 0
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayEnd = int64(COMPILEENV_INIT_EXCEPT_RANGES)
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FmallocedExceptArray = 0
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FcmdMapPtr = envPtr + 3144
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FcmdMapEnd = int64(COMPILEENV_INIT_CMD_MAP_SIZE)
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FmallocedCmdMap = 0
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FatCmdStart = int32(1)
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FexpandCount = 0
	/*
	 * TIP #280: Set up the extended command location information, based on
	 * the context invoking the byte code compiler. This structure is used to
	 * keep the per-word line information for all compiled commands.
	 *
	 * See also tclBasic.c, TclEvalObjEx, for the equivalent code in the
	 * non-compiling evaluator
	 */
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr = XTcl_Alloc(tls, uint64(48))
	(*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Floc = libc.UintptrFromInt32(0)
	(*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fnloc = 0
	(*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fnuloc = 0
	(*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fpath = libc.UintptrFromInt32(0)
	if invoker == libc.UintptrFromInt32(0) {
		/*
		 * Initialize the compiler for relative counting in case of a
		 * dynamic context.
		 */
		(*TCompileEnv)(unsafe.Pointer(envPtr)).Fline = int64(1)
		if (*TInterp)(unsafe.Pointer(iPtr)).FevalFlags&int32(TCL_EVAL_FILE) != 0 {
			*(*int32)(unsafe.Pointer(iPtr + 256)) &= ^libc.Int32FromInt32(TCL_EVAL_FILE)
			(*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Ftype1 = int32(TCL_LOCATION_SOURCE)
			if (*TInterp)(unsafe.Pointer(iPtr)).FscriptFile != 0 {
				/*
				 * Normalization here, to have the correct pwd. Should have
				 * negligible impact on performance, as the norm should have
				 * been done already by the 'source' invoking us, and it
				 * caches the result.
				 */
				norm = XTcl_FSGetNormalizedPath(tls, interp, (*TInterp)(unsafe.Pointer(iPtr)).FscriptFile)
				if norm == libc.UintptrFromInt32(0) {
					/*
					 * Error message in the interp result. No place to put it.
					 * And no place to serve the error itself to either. Fake
					 * a path, empty string.
					 */
					if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
						cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
						(*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fpath = XTclThreadAllocObj(tls)
					} else {
						(*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fpath = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fpath + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fpath)).FrefCount = 0
					if libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1) == uint64(0) {
						(*TTcl_Obj)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fpath)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
						(*TTcl_Obj)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fpath)).Flength = int64(libc.Int32FromInt32(0))
					} else {
						(*TTcl_Obj)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fpath)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
						libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fpath)).Fbytes, __ccgo_ts+1945, libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1))
						*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fpath)).Fbytes + uintptr(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)))) = uint8('\000')
						(*TTcl_Obj)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fpath)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(1) - libc.Uint64FromInt32(1))
					}
					(*TTcl_Obj)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fpath)).FtypePtr = libc.UintptrFromInt32(0)
				} else {
					(*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fpath = norm
				}
			} else {
				if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
					cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
					(*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fpath = XTclThreadAllocObj(tls)
				} else {
					(*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fpath = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fpath + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fpath)).FrefCount = 0
				if libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1) == uint64(0) {
					(*TTcl_Obj)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fpath)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fpath)).Flength = int64(libc.Int32FromInt32(0))
				} else {
					(*TTcl_Obj)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fpath)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
					libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fpath)).Fbytes, __ccgo_ts+1945, libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1))
					*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fpath)).Fbytes + uintptr(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)))) = uint8('\000')
					(*TTcl_Obj)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fpath)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(1) - libc.Uint64FromInt32(1))
				}
				(*TTcl_Obj)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fpath)).FtypePtr = libc.UintptrFromInt32(0)
			}
			(*TTcl_Obj)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fpath)).FrefCount++
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr)).FprocPtr != 0 {
				v3 = int32(TCL_LOCATION_PROC)
			} else {
				v3 = int32(TCL_LOCATION_BC)
			}
			(*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Ftype1 = v3
		}
	} else {
		/*
		 * Initialize the compiler using the context, making counting absolute
		 * to that context. Note that the context can be byte code execution.
		 * In that case we have to fill out the missing pieces (line, path,
		 * ...) which may make change the type as well.
		 */
		ctxPtr = XTclStackAlloc(tls, interp, uint64(88))
		pc = 0
		*(*TCmdFrame)(unsafe.Pointer(ctxPtr)) = *(*TCmdFrame)(unsafe.Pointer(invoker))
		if (*TCmdFrame)(unsafe.Pointer(invoker)).Ftype1 == int32(TCL_LOCATION_BC) {
			/*
			 * Note: Type BC => ctx.data.eval.path    is not used.
			 *			ctx.data.tebc.codePtr is used instead.
			 */
			XTclGetSrcInfoForPc(tls, ctxPtr)
			pc = int32(1)
		}
		if (*TCmdFrame)(unsafe.Pointer(ctxPtr)).Fnline <= int64(word) || *(*TTcl_Size)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(ctxPtr)).Fline + uintptr(word)*8)) < 0 {
			/*
			 * Word is not a literal, relative counting.
			 */
			(*TCompileEnv)(unsafe.Pointer(envPtr)).Fline = int64(1)
			if (*TCompileEnv)(unsafe.Pointer(envPtr)).FprocPtr != 0 {
				v4 = int32(TCL_LOCATION_PROC)
			} else {
				v4 = int32(TCL_LOCATION_BC)
			}
			(*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Ftype1 = v4
			if pc != 0 && (*TCmdFrame)(unsafe.Pointer(ctxPtr)).Ftype1 == int32(TCL_LOCATION_SOURCE) {
				/*
				 * The reference made by 'TclGetSrcInfoForPc' is dead.
				 */
				_objPtr = (*TCmdFrame)(unsafe.Pointer(ctxPtr)).Fdata.Feval.Fpath
				v6 = _objPtr
				v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
				*(*TTcl_Size)(unsafe.Pointer(v6))--
				if v5 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
		} else {
			(*TCompileEnv)(unsafe.Pointer(envPtr)).Fline = *(*TTcl_Size)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(ctxPtr)).Fline + uintptr(word)*8))
			(*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Ftype1 = (*TCmdFrame)(unsafe.Pointer(ctxPtr)).Ftype1
			if (*TCmdFrame)(unsafe.Pointer(ctxPtr)).Ftype1 == int32(TCL_LOCATION_SOURCE) {
				(*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fpath = (*TCmdFrame)(unsafe.Pointer(ctxPtr)).Fdata.Feval.Fpath
				if pc != 0 {
					/*
					 * The reference 'TclGetSrcInfoForPc' made is transfered.
					 */
					(*TCmdFrame)(unsafe.Pointer(ctxPtr)).Fdata.Feval.Fpath = libc.UintptrFromInt32(0)
				} else {
					/*
					 * We have a new reference here.
					 */
					(*TTcl_Obj)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fpath)).FrefCount++
				}
			}
		}
		XTclStackFree(tls, interp, ctxPtr)
	}
	(*TExtCmdLoc)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)).Fstart = (*TCompileEnv)(unsafe.Pointer(envPtr)).Fline
	/*
	 * Initialize the data about invisible continuation lines as empty, i.e.
	 * not used. The caller (TclSetByteCodeFromAny) will set this up, if such
	 * data is available.
	 */
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FclNext = libc.UintptrFromInt32(0)
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FauxDataArrayPtr = envPtr + 4424
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FauxDataArrayNext = 0
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FauxDataArrayEnd = int64(COMPILEENV_INIT_AUX_DATA_SIZE)
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FmallocedAuxDataArray = 0
}

/*
 *----------------------------------------------------------------------
 *
 * TclFreeCompileEnv --
 *
 *	Frees the storage allocated in a CompileEnv compilation environment
 *	structure.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Allocated storage in the CompileEnv structure is freed, although its
 *	local literal table is not deleted and its literal objects are not
 *	released. In addition, storage referenced by its auxiliary data items
 *	is not freed. This is done so that, when compilation is successful,
 *	"ownership" of these objects and aux data items is handed over to the
 *	corresponding ByteCode structure.
 *
 *----------------------------------------------------------------------
 */

func XTclFreeCompileEnv(tls *libc.TLS, envPtr uintptr) {
	/* Points to the CompileEnv structure. */
	var auxDataPtr, entryPtr uintptr
	var i TTcl_Size
	_, _, _ = auxDataPtr, entryPtr, i
	if (*TCompileEnv)(unsafe.Pointer(envPtr)).FlocalLitTable.Fbuckets != envPtr+72+8 {
		XTclpFree(tls, (*TCompileEnv)(unsafe.Pointer(envPtr)).FlocalLitTable.Fbuckets)
		(*TCompileEnv)(unsafe.Pointer(envPtr)).FlocalLitTable.Fbuckets = envPtr + 72 + 8
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr != 0 {
		entryPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FliteralArrayPtr
		auxDataPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FauxDataArrayPtr
		i = 0
		for {
			if !(i < (*TCompileEnv)(unsafe.Pointer(envPtr)).FliteralArrayNext) {
				break
			}
			XTclReleaseLiteral(tls, (*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr, (*TLiteralEntry)(unsafe.Pointer(entryPtr)).FobjPtr)
			entryPtr += 32
			goto _1
		_1:
			;
			i++
		}
		i = 0
		for {
			if !(i < (*TCompileEnv)(unsafe.Pointer(envPtr)).FauxDataArrayNext) {
				break
			}
			if (*TAuxDataType)(unsafe.Pointer((*TAuxData)(unsafe.Pointer(auxDataPtr)).Ftype1)).FfreeProc != libc.UintptrFromInt32(0) {
				(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TAuxDataType)(unsafe.Pointer((*TAuxData)(unsafe.Pointer(auxDataPtr)).Ftype1)).FfreeProc})))(tls, (*TAuxData)(unsafe.Pointer(auxDataPtr)).FclientData)
			}
			auxDataPtr += 16
			goto _2
		_2:
			;
			i++
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr)).FmallocedCodeArray != 0 {
		XTclpFree(tls, (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr)).FmallocedLiteralArray != 0 {
		XTclpFree(tls, (*TCompileEnv)(unsafe.Pointer(envPtr)).FliteralArrayPtr)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr)).FmallocedExceptArray != 0 {
		XTclpFree(tls, (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayPtr)
		XTclpFree(tls, (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptAuxArrayPtr)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr)).FmallocedCmdMap != 0 {
		XTclpFree(tls, (*TCompileEnv)(unsafe.Pointer(envPtr)).FcmdMapPtr)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr)).FmallocedAuxDataArray != 0 {
		XTclpFree(tls, (*TCompileEnv)(unsafe.Pointer(envPtr)).FauxDataArrayPtr)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr != 0 {
		_ReleaseCmdWordData(tls, (*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr)
		(*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr = libc.UintptrFromInt32(0)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclWordKnownAtCompileTime --
 *
 *	Determines whether the value of a token is completely known at compile
 *	time.
 *
 * Results:
 *	True if the tokenPtr argument points to a word value that is
 *	completely known at compile time. Generally, values that are known at
 *	compile time can be compiled to their values, while values that cannot
 *	be known until substitution at runtime must be compiled to bytecode
 *	instructions that perform that substitution. For several commands,
 *	whether or not arguments are known at compile time determine whether
 *	it is worthwhile to compile at all.
 *
 * Side effects:
 *	When returning true, appends the known value of the word to the
 *	unshared Tcl_Obj (*valuePtr), unless valuePtr is NULL.
 *
 *----------------------------------------------------------------------
 */

func XTclWordKnownAtCompileTime(tls *libc.TLS, tokenPtr uintptr, valuePtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* If not NULL, points to an unshared Tcl_Obj
	 * to which we should append the known value
	 * of the word. */
	var _objPtr, _objPtr1, cachePtr, tempPtr, v4, v6 uintptr
	var length Tsize_t
	var numComponents, v2 int32
	var v1 bool
	var v3, v5 TTcl_Size
	var _ /* utfBuf at bp+0 */ [4]uint8
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, length, numComponents, tempPtr, v1, v2, v3, v4, v5, v6
	numComponents = int32((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents)
	tempPtr = libc.UintptrFromInt32(0)
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		if valuePtr != libc.UintptrFromInt32(0) {
			XTcl_AppendToObj(tls, valuePtr, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize)
		}
		return int32(1)
	}
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 != int32(TCL_TOKEN_WORD) {
		return 0
	}
	tokenPtr += 32
	if valuePtr != libc.UintptrFromInt32(0) {
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			tempPtr = XTclThreadAllocObj(tls)
		} else {
			tempPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(tempPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(tempPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(tempPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(tempPtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(tempPtr)).FtypePtr = libc.UintptrFromInt32(0)
		(*TTcl_Obj)(unsafe.Pointer(tempPtr)).FrefCount++
	}
	for {
		v2 = numComponents
		numComponents--
		if !(v2 != 0) {
			break
		}
		switch (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 {
		case int32(TCL_TOKEN_TEXT):
			if tempPtr != libc.UintptrFromInt32(0) {
				XTcl_AppendToObj(tls, tempPtr, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize)
			}
		case int32(TCL_TOKEN_BS):
			if tempPtr != libc.UintptrFromInt32(0) {
				*(*[4]uint8)(unsafe.Pointer(bp)) = [4]uint8{}
				length = libc.Uint64FromInt32(XTclParseBackslash(tls, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize, libc.UintptrFromInt32(0), bp))
				XTcl_AppendToObj(tls, tempPtr, bp, libc.Int64FromUint64(length))
			}
		default:
			if tempPtr != libc.UintptrFromInt32(0) {
				_objPtr = tempPtr
				v4 = _objPtr
				v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
				*(*TTcl_Size)(unsafe.Pointer(v4))--
				if v3 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
			return 0
		}
		tokenPtr += 32
	}
	if valuePtr != libc.UintptrFromInt32(0) {
		XTcl_AppendObjToObj(tls, valuePtr, tempPtr)
		_objPtr1 = tempPtr
		v6 = _objPtr1
		v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
		*(*TTcl_Size)(unsafe.Pointer(v6))--
		if v5 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
	return int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileScript --
 *
 *	Compiles a Tcl script in a string.
 *
 * Results:
 *
 *	A standard Tcl result. If an error occurs, an
 *	error message is left in the interpreter's result.
 *
 * Side effects:
 *	Adds instructions to envPtr to evaluate the script at runtime.
 *
 *----------------------------------------------------------------------
 */

func _ExpandRequested(tls *libc.TLS, tokenPtr uintptr, numWords Tsize_t) (r int32) {
	var v1 Tsize_t
	_ = v1
	/* Determine whether any words of the command require expansion */
	for {
		v1 = numWords
		numWords--
		if !(v1 != 0) {
			break
		}
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_EXPAND_WORD) {
			return int32(1)
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	}
	return 0
}

func _CompileCmdLiteral(tls *libc.TLS, interp uintptr, cmdObj uintptr, envPtr2 uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objIndexCopy, cmdLitIdx, delta1, extraLiteralFlags, v18, v6 int32
	var bytes, cmdPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v19, v2, v3, v4, v5, v7, v8, v9 uintptr
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, bytes, cmdLitIdx, cmdPtr, delta1, extraLiteralFlags, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v3, v4, v5, v6, v7, v8, v9
	extraLiteralFlags = int32(LITERAL_CMD_NAME)
	cmdPtr = XTcl_GetCommandFromObj(tls, interp, cmdObj)
	if cmdPtr != libc.UintptrFromInt32(0) && (*TCommand)(unsafe.Pointer(cmdPtr)).Fflags&int32(CMD_VIA_RESOLVER) != 0 {
		extraLiteralFlags |= int32(LITERAL_UNSHARED)
	}
	if (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, cmdObj, bp)
	}
	bytes = v1
	cmdLitIdx = XTclRegisterLiteral(tls, envPtr2, bytes, *(*TTcl_Size)(unsafe.Pointer(bp)), extraLiteralFlags)
	if cmdPtr != 0 && (*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr != libc.UintptrFromInt32(0) {
		XTclSetCmdNameObj(tls, interp, XTclFetchLiteral(tls, envPtr2, int64(cmdLitIdx)), cmdPtr)
	}
	_objIndexCopy = cmdLitIdx
	if _objIndexCopy <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v3 = envPtr2 + 152
		v2 = *(*uintptr)(unsafe.Pointer(v3))
		*(*uintptr)(unsafe.Pointer(v3))++
		*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v5 = envPtr2 + 152
		v4 = *(*uintptr)(unsafe.Pointer(v5))
		*(*uintptr)(unsafe.Pointer(v5))++
		*(*uint8)(unsafe.Pointer(v4)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v6 = delta1
			v7 = envPtr2
			if v6 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v7 + 64)) += int64(v6)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v9 = envPtr2 + 152
		v8 = *(*uintptr)(unsafe.Pointer(v9))
		*(*uintptr)(unsafe.Pointer(v9))++
		*(*uint8)(unsafe.Pointer(v8)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v11 = envPtr2 + 152
		v10 = *(*uintptr)(unsafe.Pointer(v11))
		*(*uintptr)(unsafe.Pointer(v11))++
		*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
		v13 = envPtr2 + 152
		v12 = *(*uintptr)(unsafe.Pointer(v13))
		*(*uintptr)(unsafe.Pointer(v13))++
		*(*uint8)(unsafe.Pointer(v12)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
		v15 = envPtr2 + 152
		v14 = *(*uintptr)(unsafe.Pointer(v15))
		*(*uintptr)(unsafe.Pointer(v15))++
		*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
		v17 = envPtr2 + 152
		v16 = *(*uintptr)(unsafe.Pointer(v17))
		*(*uintptr)(unsafe.Pointer(v17))++
		*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v18 = delta1
			v19 = envPtr2
			if v18 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v19 + 64)) += int64(v18)
		}
	}
}

func XTclCompileInvocation(tls *libc.TLS, interp uintptr, tokenPtr uintptr, cmdObj uintptr, numWords Tsize_t, envPtr3 uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _objIndexCopy, delta1, depth1, objIdx, v18, v6 int32
	var eclIndex TTcl_Size
	var mapPtr, v10, v11, v12, v13, v14, v15, v16, v17, v19, v2, v21, v3, v4, v5, v7, v8, v9 uintptr
	var wordIdx, v20 Tsize_t
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, depth1, eclIndex, mapPtr, objIdx, wordIdx, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v3, v4, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr3)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	wordIdx = uint64(0)
	depth1 = int32((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcurrStackDepth)
	if cmdObj != 0 {
		_CompileCmdLiteral(tls, interp, cmdObj, envPtr3)
		wordIdx = uint64(1)
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	}
	for {
		if !(wordIdx < numWords) {
			break
		}
		(*TCompileEnv)(unsafe.Pointer(envPtr3)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(wordIdx)*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr3)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(wordIdx)*8))
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) {
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr3)
			goto _1
		}
		objIdx = XTclRegisterLiteral(tls, envPtr3, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FclNext != 0 {
			XTclContinuationsEnterDerived(tls, XTclFetchLiteral(tls, envPtr3, int64(objIdx)), int64((*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart)-int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).Fsource), (*TCompileEnv)(unsafe.Pointer(envPtr3)).FclNext)
		}
		_objIndexCopy = objIdx
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr3)
			}
			v3 = envPtr3 + 152
			v2 = *(*uintptr)(unsafe.Pointer(v3))
			*(*uintptr)(unsafe.Pointer(v3))++
			*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v5 = envPtr3 + 152
			v4 = *(*uintptr)(unsafe.Pointer(v5))
			*(*uintptr)(unsafe.Pointer(v5))++
			*(*uint8)(unsafe.Pointer(v4)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v6 = delta1
				v7 = envPtr3
				if v6 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v7 + 64)) += int64(v6)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr3)
			}
			v9 = envPtr3 + 152
			v8 = *(*uintptr)(unsafe.Pointer(v9))
			*(*uintptr)(unsafe.Pointer(v9))++
			*(*uint8)(unsafe.Pointer(v8)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v11 = envPtr3 + 152
			v10 = *(*uintptr)(unsafe.Pointer(v11))
			*(*uintptr)(unsafe.Pointer(v11))++
			*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v13 = envPtr3 + 152
			v12 = *(*uintptr)(unsafe.Pointer(v13))
			*(*uintptr)(unsafe.Pointer(v13))++
			*(*uint8)(unsafe.Pointer(v12)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v15 = envPtr3 + 152
			v14 = *(*uintptr)(unsafe.Pointer(v15))
			*(*uintptr)(unsafe.Pointer(v15))++
			*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v17 = envPtr3 + 152
			v16 = *(*uintptr)(unsafe.Pointer(v17))
			*(*uintptr)(unsafe.Pointer(v17))++
			*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v18 = delta1
				v19 = envPtr3
				if v18 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v19 + 64)) += int64(v18)
			}
		}
		goto _1
	_1:
		;
		wordIdx++
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	}
	if wordIdx <= uint64(255) {
		XTclEmitInvoke(tls, envPtr3, int32(INST_INVOKE_STK1), libc.VaList(bp+8, wordIdx))
	} else {
		XTclEmitInvoke(tls, envPtr3, int32(INST_INVOKE_STK4), libc.VaList(bp+8, wordIdx))
	}
	v20 = libc.Uint64FromInt32(depth1 + int32(1))
	v21 = envPtr3
	if v20 != libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(v21)).FcurrStackDepth) {
		XTcl_Panic(tls, __ccgo_ts+21474, libc.VaList(bp+8, libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(v21)).FcurrStackDepth), v20))
	}
}

func _CompileExpanded(tls *libc.TLS, interp uintptr, tokenPtr uintptr, cmdObj uintptr, numWords int32, envPtr3 uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _objIndexCopy, delta1, depth1, objIdx, wordIdx, v12, v18, v30 int32
	var eclIndex TTcl_Size
	var mapPtr, v10, v11, v13, v14, v15, v16, v17, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v31, v33, v4, v5, v6, v7, v8, v9 uintptr
	var v32 Tsize_t
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, depth1, eclIndex, mapPtr, objIdx, wordIdx, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v4, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr3)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	wordIdx = 0
	depth1 = int32((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcurrStackDepth)
	_StartExpanding(tls, envPtr3)
	if cmdObj != 0 {
		_CompileCmdLiteral(tls, interp, cmdObj, envPtr3)
		wordIdx = int32(1)
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	}
	for {
		if !(wordIdx < numWords) {
			break
		}
		(*TCompileEnv)(unsafe.Pointer(envPtr3)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(wordIdx)*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr3)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(wordIdx)*8))
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) {
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr3)
			if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_EXPAND_WORD) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr3)
				}
				v3 = envPtr3 + 152
				v2 = *(*uintptr)(unsafe.Pointer(v3))
				*(*uintptr)(unsafe.Pointer(v3))++
				*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32(INST_EXPAND_STKTOP))
				v5 = envPtr3 + 152
				v4 = *(*uintptr)(unsafe.Pointer(v5))
				*(*uintptr)(unsafe.Pointer(v5))++
				*(*uint8)(unsafe.Pointer(v4)) = uint8(libc.Uint32FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcurrStackDepth) >> libc.Int32FromInt32(24))
				v7 = envPtr3 + 152
				v6 = *(*uintptr)(unsafe.Pointer(v7))
				*(*uintptr)(unsafe.Pointer(v7))++
				*(*uint8)(unsafe.Pointer(v6)) = uint8(libc.Uint32FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcurrStackDepth) >> libc.Int32FromInt32(16))
				v9 = envPtr3 + 152
				v8 = *(*uintptr)(unsafe.Pointer(v9))
				*(*uintptr)(unsafe.Pointer(v9))++
				*(*uint8)(unsafe.Pointer(v8)) = uint8(libc.Uint32FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcurrStackDepth) >> libc.Int32FromInt32(8))
				v11 = envPtr3 + 152
				v10 = *(*uintptr)(unsafe.Pointer(v11))
				*(*uintptr)(unsafe.Pointer(v11))++
				*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcurrStackDepth))
				if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_EXPAND_STKTOP)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - int32((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcurrStackDepth)
					}
					v12 = delta1
					v13 = envPtr3
					if v12 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v13)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v13)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v13)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v13)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v13 + 64)) += int64(v12)
				}
			}
			goto _1
		}
		objIdx = XTclRegisterLiteral(tls, envPtr3, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, 0)
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FclNext != 0 {
			XTclContinuationsEnterDerived(tls, XTclFetchLiteral(tls, envPtr3, int64(objIdx)), int64((*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart)-int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).Fsource), (*TCompileEnv)(unsafe.Pointer(envPtr3)).FclNext)
		}
		_objIndexCopy = objIdx
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr3)
			}
			v15 = envPtr3 + 152
			v14 = *(*uintptr)(unsafe.Pointer(v15))
			*(*uintptr)(unsafe.Pointer(v15))++
			*(*uint8)(unsafe.Pointer(v14)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v17 = envPtr3 + 152
			v16 = *(*uintptr)(unsafe.Pointer(v17))
			*(*uintptr)(unsafe.Pointer(v17))++
			*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v18 = delta1
				v19 = envPtr3
				if v18 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v19 + 64)) += int64(v18)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr3)
			}
			v21 = envPtr3 + 152
			v20 = *(*uintptr)(unsafe.Pointer(v21))
			*(*uintptr)(unsafe.Pointer(v21))++
			*(*uint8)(unsafe.Pointer(v20)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v23 = envPtr3 + 152
			v22 = *(*uintptr)(unsafe.Pointer(v23))
			*(*uintptr)(unsafe.Pointer(v23))++
			*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v25 = envPtr3 + 152
			v24 = *(*uintptr)(unsafe.Pointer(v25))
			*(*uintptr)(unsafe.Pointer(v25))++
			*(*uint8)(unsafe.Pointer(v24)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v27 = envPtr3 + 152
			v26 = *(*uintptr)(unsafe.Pointer(v27))
			*(*uintptr)(unsafe.Pointer(v27))++
			*(*uint8)(unsafe.Pointer(v26)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v29 = envPtr3 + 152
			v28 = *(*uintptr)(unsafe.Pointer(v29))
			*(*uintptr)(unsafe.Pointer(v29))++
			*(*uint8)(unsafe.Pointer(v28)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v30 = delta1
				v31 = envPtr3
				if v30 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v31)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v31)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v31)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v31)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v31 + 64)) += int64(v30)
			}
		}
		goto _1
	_1:
		;
		wordIdx++
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	}
	/*
	 * The stack depth during argument expansion can only be managed at
	 * runtime, as the number of elements in the expanded lists is not known
	 * at compile time.  Adjust the stack depth estimate here so that it is
	 * correct after the command with expanded arguments returns.
	 *
	 * The end effect of this command's invocation is that all the words of
	 * the command are popped from the stack and the result is pushed: The
	 * stack top changes by (1-wordIdx).
	 *
	 * The estimates are not correct while the command is being
	 * prepared and run, INST_EXPAND_STKTOP is not stack-neutral in general.
	 */
	XTclEmitInvoke(tls, envPtr3, int32(INST_INVOKE_EXPANDED), libc.VaList(bp+8, wordIdx))
	v32 = libc.Uint64FromInt32(depth1 + int32(1))
	v33 = envPtr3
	if v32 != libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(v33)).FcurrStackDepth) {
		XTcl_Panic(tls, __ccgo_ts+21474, libc.VaList(bp+8, libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(v33)).FcurrStackDepth), v32))
	}
}

func _CompileCmdCompileProc(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr3 uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var delta1, depth1, unwind, v11 int32
	var eclIndex, incrOffset TTcl_Size
	var incrPtr, mapPtr, startPtr, v1, v10, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v22, v3, v4, v5, v6, v7, v8, v9 uintptr
	var v21 Tsize_t
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = delta1, depth1, eclIndex, incrOffset, incrPtr, mapPtr, startPtr, unwind, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v3, v4, v5, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr3)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	unwind = 0
	incrOffset = int64(-int32(1))
	depth1 = int32((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcurrStackDepth)
	/*
	 * Emission of the INST_START_CMD instruction is controlled by the value of
	 * envPtr->atCmdStart:
	 *
	 * atCmdStart == 2	: Don't use the INST_START_CMD instruction.
	 * atCmdStart == 1	: INST_START_CMD was the last instruction emitted,
	 *			: so no need to emit another.  Instead
	 *			: increment the number of cmds started at it, except
	 *			: for the special case at the start of a script.
	 * atCmdStart == 0	: The last instruction was something else.
	 *			: Emit INST_START_CMD here.
	 */
	switch (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart {
	case 0:
		unwind = int32(XtclInstructionTable[int32(INST_START_CMD)].FnumBytes)
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr3)
		}
		v2 = envPtr3 + 152
		v1 = *(*uintptr)(unsafe.Pointer(v2))
		*(*uintptr)(unsafe.Pointer(v2))++
		*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_START_CMD))
		v4 = envPtr3 + 152
		v3 = *(*uintptr)(unsafe.Pointer(v4))
		*(*uintptr)(unsafe.Pointer(v4))++
		*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
		v6 = envPtr3 + 152
		v5 = *(*uintptr)(unsafe.Pointer(v6))
		*(*uintptr)(unsafe.Pointer(v6))++
		*(*uint8)(unsafe.Pointer(v5)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
		v8 = envPtr3 + 152
		v7 = *(*uintptr)(unsafe.Pointer(v8))
		*(*uintptr)(unsafe.Pointer(v8))++
		*(*uint8)(unsafe.Pointer(v7)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
		v10 = envPtr3 + 152
		v9 = *(*uintptr)(unsafe.Pointer(v10))
		*(*uintptr)(unsafe.Pointer(v10))++
		*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = int32(1)
		}
		delta1 = XtclInstructionTable[uint8(INST_START_CMD)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v11 = delta1
			v12 = envPtr3
			if v11 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v12)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v12)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v12)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v12)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v12 + 64)) += int64(v11)
		}
		incrOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeStart)
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(4) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr3)
		}
		v14 = envPtr3 + 152
		v13 = *(*uintptr)(unsafe.Pointer(v14))
		*(*uintptr)(unsafe.Pointer(v14))++
		*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
		v16 = envPtr3 + 152
		v15 = *(*uintptr)(unsafe.Pointer(v16))
		*(*uintptr)(unsafe.Pointer(v16))++
		*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
		v18 = envPtr3 + 152
		v17 = *(*uintptr)(unsafe.Pointer(v18))
		*(*uintptr)(unsafe.Pointer(v18))++
		*(*uint8)(unsafe.Pointer(v17)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
		v20 = envPtr3 + 152
		v19 = *(*uintptr)(unsafe.Pointer(v20))
		*(*uintptr)(unsafe.Pointer(v20))++
		*(*uint8)(unsafe.Pointer(v19)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
	case int32(1):
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeStart {
			incrOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext-uintptr(4)) - int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeStart)
		}
	case int32(2):
		/* Nothing to do */
	}
	if TCL_OK == XTclAttemptCompileProc(tls, interp, parsePtr, int64(1), cmdPtr, envPtr3) {
		if incrOffset >= 0 {
			/*
			 * Command compiled succesfully.  Increment the number of
			 * commands that start at the currently active INST_START_CMD.
			 */
			incrPtr = (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeStart + uintptr(incrOffset)
			startPtr = incrPtr - uintptr(5)
			*(*uint8)(unsafe.Pointer(incrPtr)) = uint8((libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(incrPtr)))<<libc.Int32FromInt32(24)|libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(incrPtr + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)|libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(incrPtr + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)|libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(incrPtr + libc.UintptrFromInt32(3))))) + libc.Uint32FromInt32(libc.Int32FromInt32(1))) >> libc.Int32FromInt32(24))
			*(*uint8)(unsafe.Pointer(incrPtr + libc.UintptrFromInt32(1))) = uint8((libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(incrPtr)))<<libc.Int32FromInt32(24)|libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(incrPtr + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)|libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(incrPtr + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)|libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(incrPtr + libc.UintptrFromInt32(3))))) + libc.Uint32FromInt32(libc.Int32FromInt32(1))) >> libc.Int32FromInt32(16))
			*(*uint8)(unsafe.Pointer(incrPtr + libc.UintptrFromInt32(2))) = uint8((libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(incrPtr)))<<libc.Int32FromInt32(24)|libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(incrPtr + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)|libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(incrPtr + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)|libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(incrPtr + libc.UintptrFromInt32(3))))) + libc.Uint32FromInt32(libc.Int32FromInt32(1))) >> libc.Int32FromInt32(8))
			*(*uint8)(unsafe.Pointer(incrPtr + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(incrPtr)))<<libc.Int32FromInt32(24)|libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(incrPtr + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)|libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(incrPtr + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)|libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(incrPtr + libc.UintptrFromInt32(3))))) + libc.Uint32FromInt32(libc.Int32FromInt32(1)))
			if unwind != 0 {
				/* We started the INST_START_CMD.  Record the code length. */
				*(*uint8)(unsafe.Pointer(startPtr + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext)-int64(startPtr)) >> libc.Int32FromInt32(24))
				*(*uint8)(unsafe.Pointer(startPtr + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext)-int64(startPtr)) >> libc.Int32FromInt32(16))
				*(*uint8)(unsafe.Pointer(startPtr + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext)-int64(startPtr)) >> libc.Int32FromInt32(8))
				*(*uint8)(unsafe.Pointer(startPtr + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext) - int64(startPtr)))
			}
		}
		v21 = libc.Uint64FromInt32(depth1 + int32(1))
		v22 = envPtr3
		if v21 != libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth) {
			XTcl_Panic(tls, __ccgo_ts+21474, libc.VaList(bp+8, libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(v22)).FcurrStackDepth), v21))
		}
		return TCL_OK
	}
	*(*uintptr)(unsafe.Pointer(envPtr3 + 152)) -= uintptr(unwind) /* Unwind INST_START_CMD */
	/*
	 * Throw out any line information generated by the failed compile attempt.
	 */
	for (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc-int64(1) > eclIndex {
		(*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc--
		XTclpFree(tls, (*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc)*32))).Fline)
		(*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc)*32))).Fline = libc.UintptrFromInt32(0)
	}
	/*
	 * Reset the index of next command.  Toss out any from failed nested
	 * partial compiles.
	 */
	(*TCompileEnv)(unsafe.Pointer(envPtr3)).FnumCommands = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc
	return int32(TCL_ERROR)
}

func _CompileCommandTokens(tls *libc.TLS, interp uintptr, parsePtr uintptr, envPtr3 uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _objPtr, cachePtr, clNext, cmdObj, cmdPtr, eclPtr, iPtr, tokenPtr, v11, v2, v3, v5, v6, v7, v9 uintptr
	var cmdIdx, cmdLine, startCodeOffset, wlineat, v4 TTcl_Size
	var cmdKnown, code, delta1, depth1, expand, v8 int32
	var v1 bool
	var v10 Tsize_t
	var _ /* wlines at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, clNext, cmdIdx, cmdKnown, cmdLine, cmdObj, cmdPtr, code, delta1, depth1, eclPtr, expand, iPtr, startCodeOffset, tokenPtr, wlineat, v1, v10, v11, v2, v3, v4, v5, v6, v7, v8, v9
	iPtr = interp
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
	eclPtr = (*TCompileEnv)(unsafe.Pointer(envPtr3)).FextCmdMapPtr
	cmdPtr = libc.UintptrFromInt32(0)
	code = int32(TCL_ERROR)
	expand = -int32(1)
	cmdLine = (*TCompileEnv)(unsafe.Pointer(envPtr3)).Fline
	clNext = (*TCompileEnv)(unsafe.Pointer(envPtr3)).FclNext
	cmdIdx = (*TCompileEnv)(unsafe.Pointer(envPtr3)).FnumCommands
	startCodeOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeStart)
	depth1 = int32((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcurrStackDepth)
	/* Precompile */
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		cmdObj = XTclThreadAllocObj(tls)
	} else {
		cmdObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(cmdObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(cmdObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(cmdObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(cmdObj)).FtypePtr = libc.UintptrFromInt32(0)
	(*TCompileEnv)(unsafe.Pointer(envPtr3)).FnumCommands++
	_EnterCmdStartData(tls, envPtr3, cmdIdx, int64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart)-int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).Fsource), startCodeOffset)
	/*
	 * TIP #280. Scan the words and compute the extended location information.
	 * At first the map first contains full per-word line information for use by the
	 * compiler. This is later replaced by a reduced form which signals
	 * non-literal words, stored in 'wlines'.
	 */
	_EnterCmdWordData(tls, eclPtr, int64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart)-int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).Fsource), (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords, cmdLine, clNext, bp, envPtr3)
	wlineat = (*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Fnuloc - int64(1)
	(*TCompileEnv)(unsafe.Pointer(envPtr3)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Floc + uintptr(wlineat)*32))).Fline))
	(*TCompileEnv)(unsafe.Pointer(envPtr3)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Floc + uintptr(wlineat)*32))).Fnext))
	/* Do we know the command word? */
	(*TTcl_Obj)(unsafe.Pointer(cmdObj)).FrefCount++
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
	cmdKnown = XTclWordKnownAtCompileTime(tls, tokenPtr, cmdObj)
	/* Is this a command we should (try to) compile with a compileProc ? */
	if cmdKnown != 0 && !((*TInterp)(unsafe.Pointer(iPtr)).Fflags&libc.Int32FromInt32(DONT_COMPILE_CMDS_INLINE) != 0) {
		cmdPtr = XTcl_GetCommandFromObj(tls, interp, cmdObj)
		if cmdPtr != 0 {
			/*
			 * Found a command.  Test the ways we can be told not to attempt
			 * to compile it.
			 */
			if (*TCommand)(unsafe.Pointer(cmdPtr)).FcompileProc == libc.UintptrFromInt32(0) || (*TNamespace)(unsafe.Pointer((*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr)).Fflags&int32(NS_SUPPRESS_COMPILATION) != 0 || (*TCommand)(unsafe.Pointer(cmdPtr)).Fflags&int32(CMD_HAS_EXEC_TRACES) != 0 {
				cmdPtr = libc.UintptrFromInt32(0)
			}
		}
		if cmdPtr != 0 && !((*TCommand)(unsafe.Pointer(cmdPtr)).Fflags&libc.Int32FromInt32(CMD_COMPILES_EXPANDED) != 0) {
			expand = _ExpandRequested(tls, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr, libc.Uint64FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)))
			if expand != 0 {
				/* We need to expand, but compileProc cannot. */
				cmdPtr = libc.UintptrFromInt32(0)
			}
		}
	}
	/* If cmdPtr != NULL, try to call cmdPtr->compileProc */
	if cmdPtr != 0 {
		code = _CompileCmdCompileProc(tls, interp, parsePtr, cmdPtr, envPtr3)
	}
	if code == int32(TCL_ERROR) {
		if expand < 0 {
			expand = _ExpandRequested(tls, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr, libc.Uint64FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)))
		}
		if expand != 0 {
			if cmdKnown != 0 {
				v2 = cmdObj
			} else {
				v2 = libc.UintptrFromInt32(0)
			}
			_CompileExpanded(tls, interp, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr, v2, int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords), envPtr3)
		} else {
			if cmdKnown != 0 {
				v3 = cmdObj
			} else {
				v3 = libc.UintptrFromInt32(0)
			}
			XTclCompileInvocation(tls, interp, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr, v3, libc.Uint64FromInt32(int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)), envPtr3)
		}
	}
	_objPtr = cmdObj
	v5 = _objPtr
	v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
	*(*TTcl_Size)(unsafe.Pointer(v5))--
	if v4 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr3)
	}
	v7 = envPtr3 + 152
	v6 = *(*uintptr)(unsafe.Pointer(v7))
	*(*uintptr)(unsafe.Pointer(v7))++
	*(*uint8)(unsafe.Pointer(v6)) = libc.Uint8FromInt32(int32(INST_POP))
	if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v8 = delta1
		v9 = envPtr3
		if v8 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v9)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v9)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v9)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v9)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v9 + 64)) += int64(v8)
	}
	_EnterCmdExtentData(tls, envPtr3, cmdIdx, int64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm)-int64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart), int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeStart)-startCodeOffset)
	/*
	 * TIP #280: Free the full form of per-word line data and insert the
	 * reduced form now.
	 */
	(*TCompileEnv)(unsafe.Pointer(envPtr3)).Fline = cmdLine
	(*TCompileEnv)(unsafe.Pointer(envPtr3)).FclNext = clNext
	XTclpFree(tls, (*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Floc + uintptr(wlineat)*32))).Fline)
	XTclpFree(tls, (*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Floc + uintptr(wlineat)*32))).Fnext)
	(*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Floc + uintptr(wlineat)*32))).Fline = *(*uintptr)(unsafe.Pointer(bp))
	(*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Floc + uintptr(wlineat)*32))).Fnext = libc.UintptrFromInt32(0)
	v10 = libc.Uint64FromInt32(depth1)
	v11 = envPtr3
	if v10 != libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(v11)).FcurrStackDepth) {
		XTcl_Panic(tls, __ccgo_ts+21474, libc.VaList(bp+16, libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(v11)).FcurrStackDepth), v10))
	}
	return int32(cmdIdx)
}

func XTclCompileScript(tls *libc.TLS, interp uintptr, script uintptr, numBytes TTcl_Size, envPtr3 uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Holds resulting instructions. */
	var _objIndexCopy, delta1, depth1, lastCmdIdx, v17, v5 int32
	var iPtr, next, p, parsePtr, v1, v10, v11, v12, v13, v14, v15, v16, v18, v2, v20, v3, v4, v6, v7, v8, v9 uintptr
	var v19 Tsize_t
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, depth1, iPtr, lastCmdIdx, next, p, parsePtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v3, v4, v5, v6, v7, v8, v9
	lastCmdIdx = -int32(1) /* Index into envPtr->cmdMapPtr of the last
	 * command this routine compiles into bytecode.
	 * Initial value of -1 indicates this routine
	 * has not yet generated any bytecode. */
	p = script /* Where we are in our compile. */
	depth1 = int32((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcurrStackDepth)
	iPtr = interp
	if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FiPtr == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+23929, 0)
	}
	/*
	 * Check depth to avoid overflow of the C execution stack by too many
	 * nested calls of TclCompileScript, considering interp recursionlimit.
	 * Use factor 5/4 (1.25) to avoid being too mistaken when recognizing the
	 * limit during "mixed" evaluation and compilation process (nested
	 * eval+compile) and is good enough for default recursionlimit (1000).
	 */
	if (*TInterp)(unsafe.Pointer(iPtr)).FnumLevels/int64(5) > (*TInterp)(unsafe.Pointer(iPtr)).FmaxNestingDepth/int64(4) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+23983, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+8338, __ccgo_ts+8344, libc.UintptrFromInt32(0)))
		XTclCompileSyntaxError(tls, interp, envPtr3)
		return
	}
	if numBytes < 0 {
		numBytes = libc.Int64FromUint64(libc.Xstrlen(tls, script))
	}
	/* Each iteration compiles one command from the script. */
	if numBytes > 0 {
		if numBytes >= int64(INT_MAX) {
			/*
			 * Note this gets -errorline as 1. Not worth figuring out which line
			 * crosses the limit to get -errorline for this error case.
			 */
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+24029, libc.VaList(bp+8, numBytes, libc.Int32FromInt32(INT_MAX)-libc.Int32FromInt32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+8338, __ccgo_ts+24080, libc.UintptrFromInt32(0)))
			XTclCompileSyntaxError(tls, interp, envPtr3)
			return
		}
		/*
		 * Don't use system stack (size of Tcl_Parse is ca. 400 bytes), so
		 * many nested compilations (body enclosed in body) can cause abnormal
		 * program termination with a stack overflow exception, bug [fec0c17d39].
		 */
		parsePtr = XTcl_Alloc(tls, uint64(744))
		for cond := true; cond; cond = numBytes > 0 {
			if TCL_OK != XTcl_ParseCommand(tls, interp, p, numBytes, 0, parsePtr) {
				/*
				* Compile bytecodes to report the parsePtr error at runtime.
				 */
				XTcl_LogCommandInfo(tls, interp, script, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart, int64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm+uintptr(1))-int64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart))
				XTclCompileSyntaxError(tls, interp, envPtr3)
				XTclpFree(tls, parsePtr)
				return
			}
			/*
			 * TIP #280: Count newlines before the command start.
			 * (See test info-30.33).
			 */
			XTclAdvanceLines(tls, envPtr3+4512, p, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart)
			XTclAdvanceContinuations(tls, envPtr3+4512, envPtr3+4536, int32(int64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart)-int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).Fsource)))
			/*
			 * Advance parser to the next command in the script.
			 */
			next = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart + uintptr((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandSize)
			numBytes -= int64(next) - int64(p)
			p = next
			if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords == 0 {
				/*
				 * The "command" parsed has no words.  In this case we can skip
				 * the rest of the loop body.  With no words, clearly
				 * CompileCommandTokens() has nothing to do.  Since the parser
				 * aggressively sucks up leading comment and white space,
				 * including newlines, parsePtr->commandStart must be pointing at
				 * either the end of script, or a command-terminating semi-colon.
				 * In either case, the TclAdvance*() calls have nothing to do.
				 * Finally, when no words are parsed, no tokens have been
				 * allocated at parsePtr->tokenPtr so there's also nothing for
				 * Tcl_FreeParse() to do.
				 *
				 * The advantage of this shortcut is that CompileCommandTokens()
				 * can be written with an assumption that (int)parsePtr->numWords > 0, with
				 * the implication the CCT() always generates bytecode.
				 */
				continue
			}
			/*
			 * Avoid stack exhaustion by too many nested calls of TclCompileScript
			 * (considering interp recursionlimit).
			 */
			(*TInterp)(unsafe.Pointer(iPtr)).FnumLevels++
			lastCmdIdx = _CompileCommandTokens(tls, interp, parsePtr, envPtr3)
			(*TInterp)(unsafe.Pointer(iPtr)).FnumLevels--
			/*
			 * TIP #280: Track lines in the just compiled command.
			 */
			XTclAdvanceLines(tls, envPtr3+4512, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart, p)
			XTclAdvanceContinuations(tls, envPtr3+4512, envPtr3+4536, int32(int64(p)-int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).Fsource)))
			XTcl_FreeParse(tls, parsePtr)
		}
		XTclpFree(tls, parsePtr)
	}
	if lastCmdIdx == -int32(1) {
		/*
		 * Compiling the script yielded no bytecode.  The script must be all
		 * whitespace, comments, and empty commands.  Such scripts are defined
		 * to successfully produce the empty string result, so we emit the
		 * simple bytecode that makes that happen.
		 */
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr3, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr3)
			}
			v2 = envPtr3 + 152
			v1 = *(*uintptr)(unsafe.Pointer(v2))
			*(*uintptr)(unsafe.Pointer(v2))++
			*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v4 = envPtr3 + 152
			v3 = *(*uintptr)(unsafe.Pointer(v4))
			*(*uintptr)(unsafe.Pointer(v4))++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v5 = delta1
				v6 = envPtr3
				if v5 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v6)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v6)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v6 + 64)) += int64(v5)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr3)
			}
			v8 = envPtr3 + 152
			v7 = *(*uintptr)(unsafe.Pointer(v8))
			*(*uintptr)(unsafe.Pointer(v8))++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v10 = envPtr3 + 152
			v9 = *(*uintptr)(unsafe.Pointer(v10))
			*(*uintptr)(unsafe.Pointer(v10))++
			*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v12 = envPtr3 + 152
			v11 = *(*uintptr)(unsafe.Pointer(v12))
			*(*uintptr)(unsafe.Pointer(v12))++
			*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v14 = envPtr3 + 152
			v13 = *(*uintptr)(unsafe.Pointer(v14))
			*(*uintptr)(unsafe.Pointer(v14))++
			*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v16 = envPtr3 + 152
			v15 = *(*uintptr)(unsafe.Pointer(v16))
			*(*uintptr)(unsafe.Pointer(v16))++
			*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v17 = delta1
				v18 = envPtr3
				if v17 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v18)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v18)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v18 + 64)) += int64(v17)
			}
		}
	} else {
		/*
		 * We compiled at least one command to bytecode.  The routine
		 * CompileCommandTokens() follows the bytecode of each compiled
		 * command with an INST_POP, so that stack balance is maintained when
		 * several commands are in sequence.  (The result of each command is
		 * thrown away before moving on to the next command).  For the last
		 * command compiled, we need to undo that INST_POP so that the result
		 * of the last command becomes the result of the script.  The code
		 * here removes that trailing INST_POP.
		 */
		(*(*TCmdLocation)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcmdMapPtr + uintptr(lastCmdIdx)*32))).FnumCodeBytes--
		(*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext--
		(*TCompileEnv)(unsafe.Pointer(envPtr3)).FcurrStackDepth++
	}
	v19 = libc.Uint64FromInt32(depth1 + int32(1))
	v20 = envPtr3
	if v19 != libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(v20)).FcurrStackDepth) {
		XTcl_Panic(tls, __ccgo_ts+21474, libc.VaList(bp+8, libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(v20)).FcurrStackDepth), v19))
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileTokens --
 *
 *	Given an array of tokens parsed from a Tcl command, e.g. the tokens
 *	that make up a word, emits instructions to evaluate the
 *	tokens and concatenate their values to form a single result value on
 *	the interpreter's runtime evaluation stack.
 *
 * Results:
 *	The return value is a standard Tcl result. If an error occurs, an
 *	error message is left in the interpreter's result.
 *
 * Side effects:
 *	Instructions are added to envPtr to push and evaluate the tokens at
 *	runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileVarSubst(tls *libc.TLS, interp uintptr, tokenPtr uintptr, envPtr2 uintptr) {
	var _objIndexCopy, delta1, localVarName, v18, v22, v28, v40, v44, v50, v6, v62 int32
	var i1, localVar, nameBytes TTcl_Size
	var name, p, v10, v11, v12, v13, v14, v15, v16, v17, v19, v2, v20, v21, v23, v24, v25, v26, v27, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v41, v42, v43, v45, v46, v47, v48, v49, v5, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v63, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, i1, localVar, localVarName, name, nameBytes, p, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v7, v8, v9
	name = (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart
	nameBytes = (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize
	localVarName = int32(1)
	/*
	 * Determine how the variable name should be handled: if it contains any
	 * namespace qualifiers it is not a local variable (localVarName=-1); if
	 * it looks like an array element and the token has a single component, it
	 * should not be created here [Bug 569438] (localVarName=0); otherwise,
	 * the local variable can safely be created (localVarName=1).
	 */
	i1 = 0
	p = name
	for {
		if !(i1 < nameBytes) {
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(':') && i1 < nameBytes-int64(1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32(':') {
			localVarName = -int32(1)
			break
		} else {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('(') && (*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents == int64(1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(nameBytes-int64(1))))) == int32(')') {
				localVarName = 0
				break
			}
		}
		goto _1
	_1:
		;
		i1++
		p++
	}
	/*
	 * Either push the variable's name, or find its index in the array
	 * of local variables in a procedure frame.
	 */
	localVar = int64(-int32(1))
	if localVarName != -int32(1) {
		localVar = XTclFindCompiledLocal(tls, name, nameBytes, localVarName, envPtr2)
	}
	if localVar < 0 {
		_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, name, nameBytes, 0)
		if _objIndexCopy <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v3 = envPtr2 + 152
			v2 = *(*uintptr)(unsafe.Pointer(v3))
			*(*uintptr)(unsafe.Pointer(v3))++
			*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v5 = envPtr2 + 152
			v4 = *(*uintptr)(unsafe.Pointer(v5))
			*(*uintptr)(unsafe.Pointer(v5))++
			*(*uint8)(unsafe.Pointer(v4)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v6 = delta1
				v7 = envPtr2
				if v6 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v7 + 64)) += int64(v6)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v9 = envPtr2 + 152
			v8 = *(*uintptr)(unsafe.Pointer(v9))
			*(*uintptr)(unsafe.Pointer(v9))++
			*(*uint8)(unsafe.Pointer(v8)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v11 = envPtr2 + 152
			v10 = *(*uintptr)(unsafe.Pointer(v11))
			*(*uintptr)(unsafe.Pointer(v11))++
			*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
			v13 = envPtr2 + 152
			v12 = *(*uintptr)(unsafe.Pointer(v13))
			*(*uintptr)(unsafe.Pointer(v13))++
			*(*uint8)(unsafe.Pointer(v12)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
			v15 = envPtr2 + 152
			v14 = *(*uintptr)(unsafe.Pointer(v15))
			*(*uintptr)(unsafe.Pointer(v15))++
			*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
			v17 = envPtr2 + 152
			v16 = *(*uintptr)(unsafe.Pointer(v17))
			*(*uintptr)(unsafe.Pointer(v17))++
			*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy
				}
				v18 = delta1
				v19 = envPtr2
				if v18 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v19 + 64)) += int64(v18)
			}
		}
	}
	/*
	 * Emit instructions to load the variable.
	 */
	XTclAdvanceLines(tls, envPtr2+4512, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart+uintptr((*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize))
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents == int64(1) {
		if localVar < 0 {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v21 = envPtr2 + 152
			v20 = *(*uintptr)(unsafe.Pointer(v21))
			*(*uintptr)(unsafe.Pointer(v21))++
			*(*uint8)(unsafe.Pointer(v20)) = libc.Uint8FromInt32(int32(INST_LOAD_STK))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LOAD_STK)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v22 = delta1
				v23 = envPtr2
				if v22 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v23)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v23)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v23)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v23)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v23 + 64)) += int64(v22)
			}
		} else {
			if localVar <= int64(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v25 = envPtr2 + 152
				v24 = *(*uintptr)(unsafe.Pointer(v25))
				*(*uintptr)(unsafe.Pointer(v25))++
				*(*uint8)(unsafe.Pointer(v24)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR1))
				v27 = envPtr2 + 152
				v26 = *(*uintptr)(unsafe.Pointer(v27))
				*(*uintptr)(unsafe.Pointer(v27))++
				*(*uint8)(unsafe.Pointer(v26)) = uint8(libc.Uint32FromInt64(localVar))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - int32(localVar)
					}
					v28 = delta1
					v29 = envPtr2
					if v28 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v29)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v29)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v29)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v29)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v29 + 64)) += int64(v28)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v31 = envPtr2 + 152
				v30 = *(*uintptr)(unsafe.Pointer(v31))
				*(*uintptr)(unsafe.Pointer(v31))++
				*(*uint8)(unsafe.Pointer(v30)) = libc.Uint8FromInt32(int32(INST_LOAD_SCALAR4))
				v33 = envPtr2 + 152
				v32 = *(*uintptr)(unsafe.Pointer(v33))
				*(*uintptr)(unsafe.Pointer(v33))++
				*(*uint8)(unsafe.Pointer(v32)) = uint8(libc.Uint32FromInt64(localVar) >> libc.Int32FromInt32(24))
				v35 = envPtr2 + 152
				v34 = *(*uintptr)(unsafe.Pointer(v35))
				*(*uintptr)(unsafe.Pointer(v35))++
				*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt64(localVar) >> libc.Int32FromInt32(16))
				v37 = envPtr2 + 152
				v36 = *(*uintptr)(unsafe.Pointer(v37))
				*(*uintptr)(unsafe.Pointer(v37))++
				*(*uint8)(unsafe.Pointer(v36)) = uint8(libc.Uint32FromInt64(localVar) >> libc.Int32FromInt32(8))
				v39 = envPtr2 + 152
				v38 = *(*uintptr)(unsafe.Pointer(v39))
				*(*uintptr)(unsafe.Pointer(v39))++
				*(*uint8)(unsafe.Pointer(v38)) = uint8(libc.Uint32FromInt64(localVar))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LOAD_SCALAR4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - int32(localVar)
					}
					v40 = delta1
					v41 = envPtr2
					if v40 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v41)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v41)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v41)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v41)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v41 + 64)) += int64(v40)
				}
			}
		}
	} else {
		XTclCompileTokens(tls, interp, tokenPtr+uintptr(2)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents-int64(1)), envPtr2)
		if localVar < 0 {
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v43 = envPtr2 + 152
			v42 = *(*uintptr)(unsafe.Pointer(v43))
			*(*uintptr)(unsafe.Pointer(v43))++
			*(*uint8)(unsafe.Pointer(v42)) = libc.Uint8FromInt32(int32(INST_LOAD_ARRAY_STK))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_LOAD_ARRAY_STK)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v44 = delta1
				v45 = envPtr2
				if v44 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v45)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v45)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v45)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v45)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v45 + 64)) += int64(v44)
			}
		} else {
			if localVar <= int64(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v47 = envPtr2 + 152
				v46 = *(*uintptr)(unsafe.Pointer(v47))
				*(*uintptr)(unsafe.Pointer(v47))++
				*(*uint8)(unsafe.Pointer(v46)) = libc.Uint8FromInt32(int32(INST_LOAD_ARRAY1))
				v49 = envPtr2 + 152
				v48 = *(*uintptr)(unsafe.Pointer(v49))
				*(*uintptr)(unsafe.Pointer(v49))++
				*(*uint8)(unsafe.Pointer(v48)) = uint8(libc.Uint32FromInt64(localVar))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LOAD_ARRAY1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - int32(localVar)
					}
					v50 = delta1
					v51 = envPtr2
					if v50 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v51)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v51)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v51)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v51)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v51 + 64)) += int64(v50)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v53 = envPtr2 + 152
				v52 = *(*uintptr)(unsafe.Pointer(v53))
				*(*uintptr)(unsafe.Pointer(v53))++
				*(*uint8)(unsafe.Pointer(v52)) = libc.Uint8FromInt32(int32(INST_LOAD_ARRAY4))
				v55 = envPtr2 + 152
				v54 = *(*uintptr)(unsafe.Pointer(v55))
				*(*uintptr)(unsafe.Pointer(v55))++
				*(*uint8)(unsafe.Pointer(v54)) = uint8(libc.Uint32FromInt64(localVar) >> libc.Int32FromInt32(24))
				v57 = envPtr2 + 152
				v56 = *(*uintptr)(unsafe.Pointer(v57))
				*(*uintptr)(unsafe.Pointer(v57))++
				*(*uint8)(unsafe.Pointer(v56)) = uint8(libc.Uint32FromInt64(localVar) >> libc.Int32FromInt32(16))
				v59 = envPtr2 + 152
				v58 = *(*uintptr)(unsafe.Pointer(v59))
				*(*uintptr)(unsafe.Pointer(v59))++
				*(*uint8)(unsafe.Pointer(v58)) = uint8(libc.Uint32FromInt64(localVar) >> libc.Int32FromInt32(8))
				v61 = envPtr2 + 152
				v60 = *(*uintptr)(unsafe.Pointer(v61))
				*(*uintptr)(unsafe.Pointer(v61))++
				*(*uint8)(unsafe.Pointer(v60)) = uint8(libc.Uint32FromInt64(localVar))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_LOAD_ARRAY4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - int32(localVar)
					}
					v62 = delta1
					v63 = envPtr2
					if v62 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v63)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v63)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v63)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v63)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v63 + 64)) += int64(v62)
				}
			}
		}
	}
}

func XTclCompileTokens(tls *libc.TLS, interp uintptr, tokenPtr uintptr, count1 Tsize_t, envPtr3 uintptr) {
	bp := tls.Alloc(272)
	defer tls.Free(272) /* Holds the resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, clPos, count, delta1, depth1, isLiteral, literal, literal1, literal2, v19, v25, v37, v43, v55, v61, v67, v7, v73, v85 int32
	var adjust, i1, maxNumCL, numCL, numObjsToConcat TTcl_Size
	var clPosition, entryCodeNext, v10, v11, v12, v13, v14, v15, v16, v17, v18, v20, v21, v22, v23, v24, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v38, v39, v4, v40, v41, v42, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v56, v57, v58, v59, v6, v60, v62, v63, v64, v65, v66, v68, v69, v70, v71, v72, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v86, v88, v9 uintptr
	var length, v87 Tsize_t
	var _ /* buffer at bp+224 */ [4]uint8
	var _ /* textBuffer at bp+0 */ TTcl_DString
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, _objIndexCopy3, adjust, clPos, clPosition, count, delta1, depth1, entryCodeNext, i1, isLiteral, length, literal, literal1, literal2, maxNumCL, numCL, numObjsToConcat, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v84, v85, v86, v87, v88, v9 /* Holds concatenated chars from adjacent
	 * TCL_TOKEN_TEXT, TCL_TOKEN_BS tokens. */
	*(*[4]uint8)(unsafe.Pointer(bp + 224)) = [4]uint8{}
	entryCodeNext = (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext
	clPosition = libc.UintptrFromInt32(0)
	depth1 = int32((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcurrStackDepth)
	count = libc.Int32FromUint64(count1)
	/*
	 * If this is actually a literal, handle continuation lines by
	 * preallocating a small table to store the locations of any continuation
	 * lines found in this literal.  The table is extended if needed.
	 *
	 * Note: In contrast with the analagous code in 'TclSubstTokens()' the
	 * 'adjust' variable seems unneeded here.  The code which merges
	 * continuation line information of multiple words which concat'd at
	 * runtime also seems unneeded. Either that or I have not managed to find a
	 * test case for these two possibilities yet.  It might be a difference
	 * between compile- versus run-time processing.
	 */
	numCL = 0
	maxNumCL = 0
	isLiteral = int32(1)
	i1 = 0
	for {
		if !(i1 < int64(count)) {
			break
		}
		if (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + uintptr(i1)*32))).Ftype1 != int32(TCL_TOKEN_TEXT) && (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + uintptr(i1)*32))).Ftype1 != int32(TCL_TOKEN_BS) {
			isLiteral = 0
			break
		}
		goto _1
	_1:
		;
		i1++
	}
	if isLiteral != 0 {
		maxNumCL = int64(NUM_STATIC_POS)
		clPosition = XTcl_Alloc(tls, libc.Uint64FromInt64(maxNumCL)*uint64(8))
	}
	adjust = 0
	XTcl_DStringInit(tls, bp)
	numObjsToConcat = 0
	for {
		if !(count > 0) {
			break
		}
		switch (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 {
		case int32(TCL_TOKEN_TEXT):
			XTcl_DStringAppend(tls, bp, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize)
			XTclAdvanceLines(tls, envPtr3+4512, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart+uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize))
		case int32(TCL_TOKEN_BS):
			length = libc.Uint64FromInt32(XTclParseBackslash(tls, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize, libc.UintptrFromInt32(0), bp+224))
			XTcl_DStringAppend(tls, bp, bp+224, libc.Int64FromUint64(length))
			/*
			 * If the identified backslash sequence is in a literal and
			 * represented a continuation line, compute and store its
			 * location (as char offset to the beginning of the _result_
			 * script). We may have to extend the table of locations.
			 *
			 * The continuation line information is relevant even if the word
			 * being processed is not a literal, as it can affect nested
			 * commands. See the branch below for TCL_TOKEN_COMMAND, where the
			 * adjustment being tracked here is taken into account. The good
			 * thing is a table of everything is not needed, just the number of
			 * lines to add as correction.
			 */
			if length == uint64(1) && libc.Int32FromUint8((*(*[4]uint8)(unsafe.Pointer(bp + 224)))[0]) == int32(' ') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart + 1))) == int32('\n') {
				if isLiteral != 0 {
					clPos = int32((*TTcl_DString)(unsafe.Pointer(bp)).Flength)
					if numCL >= maxNumCL {
						maxNumCL *= int64(2)
						clPosition = XTcl_Realloc(tls, clPosition, libc.Uint64FromInt64(maxNumCL)*uint64(8))
					}
					*(*TTcl_Size)(unsafe.Pointer(clPosition + uintptr(numCL)*8)) = int64(clPos)
					numCL++
				}
				adjust++
			}
		case int32(TCL_TOKEN_COMMAND):
			/*
			 * Push any accumulated chars appearing before the command.
			 */
			if (*TTcl_DString)(unsafe.Pointer(bp)).Flength > 0 {
				literal = XTclRegisterLiteral(tls, envPtr3, (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1, (*TTcl_DString)(unsafe.Pointer(bp)).Flength, 0)
				_objIndexCopy = literal
				if _objIndexCopy <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr3)
					}
					v4 = envPtr3 + 152
					v3 = *(*uintptr)(unsafe.Pointer(v4))
					*(*uintptr)(unsafe.Pointer(v4))++
					*(*uint8)(unsafe.Pointer(v3)) = libc.Uint8FromInt32(int32(INST_PUSH1))
					v6 = envPtr3 + 152
					v5 = *(*uintptr)(unsafe.Pointer(v6))
					*(*uintptr)(unsafe.Pointer(v6))++
					*(*uint8)(unsafe.Pointer(v5)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
					if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy
						}
						v7 = delta1
						v8 = envPtr3
						if v7 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v8)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v8)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v8)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v8)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v8 + 64)) += int64(v7)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr3)
					}
					v10 = envPtr3 + 152
					v9 = *(*uintptr)(unsafe.Pointer(v10))
					*(*uintptr)(unsafe.Pointer(v10))++
					*(*uint8)(unsafe.Pointer(v9)) = libc.Uint8FromInt32(int32(INST_PUSH4))
					v12 = envPtr3 + 152
					v11 = *(*uintptr)(unsafe.Pointer(v12))
					*(*uintptr)(unsafe.Pointer(v12))++
					*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
					v14 = envPtr3 + 152
					v13 = *(*uintptr)(unsafe.Pointer(v14))
					*(*uintptr)(unsafe.Pointer(v14))++
					*(*uint8)(unsafe.Pointer(v13)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
					v16 = envPtr3 + 152
					v15 = *(*uintptr)(unsafe.Pointer(v16))
					*(*uintptr)(unsafe.Pointer(v16))++
					*(*uint8)(unsafe.Pointer(v15)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
					v18 = envPtr3 + 152
					v17 = *(*uintptr)(unsafe.Pointer(v18))
					*(*uintptr)(unsafe.Pointer(v18))++
					*(*uint8)(unsafe.Pointer(v17)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
					if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy
						}
						v19 = delta1
						v20 = envPtr3
						if v19 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v20)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v20)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v20)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v20)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v20 + 64)) += int64(v19)
					}
				}
				numObjsToConcat++
				XTcl_DStringFree(tls, bp)
				if numCL != 0 {
					XTclContinuationsEnter(tls, XTclFetchLiteral(tls, envPtr3, int64(literal)), numCL, clPosition)
				}
				numCL = 0
			}
			*(*TTcl_Size)(unsafe.Pointer(envPtr3 + 4512)) += adjust
			XTclCompileScript(tls, interp, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart+uintptr(1), (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize-int64(2), envPtr3)
			*(*TTcl_Size)(unsafe.Pointer(envPtr3 + 4512)) -= adjust
			numObjsToConcat++
		case int32(TCL_TOKEN_VARIABLE):
			/*
			 * Push any accumulated chars appearing before the $<var>.
			 */
			if (*TTcl_DString)(unsafe.Pointer(bp)).Flength > 0 {
				literal1 = XTclRegisterLiteral(tls, envPtr3, (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1, (*TTcl_DString)(unsafe.Pointer(bp)).Flength, 0)
				_objIndexCopy1 = literal1
				if _objIndexCopy1 <= int32(255) {
					if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr3)
					}
					v22 = envPtr3 + 152
					v21 = *(*uintptr)(unsafe.Pointer(v22))
					*(*uintptr)(unsafe.Pointer(v22))++
					*(*uint8)(unsafe.Pointer(v21)) = libc.Uint8FromInt32(int32(INST_PUSH1))
					v24 = envPtr3 + 152
					v23 = *(*uintptr)(unsafe.Pointer(v24))
					*(*uintptr)(unsafe.Pointer(v24))++
					*(*uint8)(unsafe.Pointer(v23)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
					if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy1
						}
						v25 = delta1
						v26 = envPtr3
						if v25 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v26)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v26)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v26)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v26)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v26 + 64)) += int64(v25)
					}
				} else {
					if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
						XTclExpandCodeArray(tls, envPtr3)
					}
					v28 = envPtr3 + 152
					v27 = *(*uintptr)(unsafe.Pointer(v28))
					*(*uintptr)(unsafe.Pointer(v28))++
					*(*uint8)(unsafe.Pointer(v27)) = libc.Uint8FromInt32(int32(INST_PUSH4))
					v30 = envPtr3 + 152
					v29 = *(*uintptr)(unsafe.Pointer(v30))
					*(*uintptr)(unsafe.Pointer(v30))++
					*(*uint8)(unsafe.Pointer(v29)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
					v32 = envPtr3 + 152
					v31 = *(*uintptr)(unsafe.Pointer(v32))
					*(*uintptr)(unsafe.Pointer(v32))++
					*(*uint8)(unsafe.Pointer(v31)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
					v34 = envPtr3 + 152
					v33 = *(*uintptr)(unsafe.Pointer(v34))
					*(*uintptr)(unsafe.Pointer(v34))++
					*(*uint8)(unsafe.Pointer(v33)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
					v36 = envPtr3 + 152
					v35 = *(*uintptr)(unsafe.Pointer(v36))
					*(*uintptr)(unsafe.Pointer(v36))++
					*(*uint8)(unsafe.Pointer(v35)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
					if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
						(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
					}
					delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
					if delta1 != 0 {
						if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
							delta1 = int32(1) - _objIndexCopy1
						}
						v37 = delta1
						v38 = envPtr3
						if v37 < libc.Int32FromInt32(0) {
							if int32((*TCompileEnv)(unsafe.Pointer(v38)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v38)).FcurrStackDepth) {
								(*TCompileEnv)(unsafe.Pointer(v38)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v38)).FcurrStackDepth
							}
						}
						*(*TTcl_Size)(unsafe.Pointer(v38 + 64)) += int64(v37)
					}
				}
				numObjsToConcat++
				XTcl_DStringFree(tls, bp)
			}
			XTclCompileVarSubst(tls, interp, tokenPtr, envPtr3)
			numObjsToConcat++
			count = int32(int64(count) - (*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents)
			tokenPtr += uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents) * 32
		default:
			XTcl_Panic(tls, __ccgo_ts+24093, libc.VaList(bp+240, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1, int32((*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize), (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart))
		}
		goto _2
	_2:
		;
		count--
		tokenPtr += 32
	}
	/*
	 * Push any accumulated characters appearing at the end.
	 */
	if (*TTcl_DString)(unsafe.Pointer(bp)).Flength > 0 {
		literal2 = XTclRegisterLiteral(tls, envPtr3, (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1, (*TTcl_DString)(unsafe.Pointer(bp)).Flength, 0)
		_objIndexCopy2 = literal2
		if _objIndexCopy2 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr3)
			}
			v40 = envPtr3 + 152
			v39 = *(*uintptr)(unsafe.Pointer(v40))
			*(*uintptr)(unsafe.Pointer(v40))++
			*(*uint8)(unsafe.Pointer(v39)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v42 = envPtr3 + 152
			v41 = *(*uintptr)(unsafe.Pointer(v42))
			*(*uintptr)(unsafe.Pointer(v42))++
			*(*uint8)(unsafe.Pointer(v41)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v43 = delta1
				v44 = envPtr3
				if v43 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v44)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v44)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v44)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v44)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v44 + 64)) += int64(v43)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr3)
			}
			v46 = envPtr3 + 152
			v45 = *(*uintptr)(unsafe.Pointer(v46))
			*(*uintptr)(unsafe.Pointer(v46))++
			*(*uint8)(unsafe.Pointer(v45)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v48 = envPtr3 + 152
			v47 = *(*uintptr)(unsafe.Pointer(v48))
			*(*uintptr)(unsafe.Pointer(v48))++
			*(*uint8)(unsafe.Pointer(v47)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
			v50 = envPtr3 + 152
			v49 = *(*uintptr)(unsafe.Pointer(v50))
			*(*uintptr)(unsafe.Pointer(v50))++
			*(*uint8)(unsafe.Pointer(v49)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
			v52 = envPtr3 + 152
			v51 = *(*uintptr)(unsafe.Pointer(v52))
			*(*uintptr)(unsafe.Pointer(v52))++
			*(*uint8)(unsafe.Pointer(v51)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
			v54 = envPtr3 + 152
			v53 = *(*uintptr)(unsafe.Pointer(v54))
			*(*uintptr)(unsafe.Pointer(v54))++
			*(*uint8)(unsafe.Pointer(v53)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
			if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy2
				}
				v55 = delta1
				v56 = envPtr3
				if v55 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v56)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v56)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v56)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v56)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v56 + 64)) += int64(v55)
			}
		}
		numObjsToConcat++
		if numCL != 0 {
			XTclContinuationsEnter(tls, XTclFetchLiteral(tls, envPtr3, int64(literal2)), numCL, clPosition)
		}
		numCL = 0
	}
	/*
	 * If necessary, concatenate the parts of the word.
	 */
	for numObjsToConcat > int64(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr3)
		}
		v58 = envPtr3 + 152
		v57 = *(*uintptr)(unsafe.Pointer(v58))
		*(*uintptr)(unsafe.Pointer(v58))++
		*(*uint8)(unsafe.Pointer(v57)) = libc.Uint8FromInt32(int32(INST_STR_CONCAT1))
		v60 = envPtr3 + 152
		v59 = *(*uintptr)(unsafe.Pointer(v60))
		*(*uintptr)(unsafe.Pointer(v60))++
		*(*uint8)(unsafe.Pointer(v59)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(255)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STR_CONCAT1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(255)
			}
			v61 = delta1
			v62 = envPtr3
			if v61 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v62)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v62)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v62)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v62)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v62 + 64)) += int64(v61)
		}
		numObjsToConcat -= int64(254) /* concat pushes 1 obj, the result */
	}
	if numObjsToConcat > int64(1) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr3)
		}
		v64 = envPtr3 + 152
		v63 = *(*uintptr)(unsafe.Pointer(v64))
		*(*uintptr)(unsafe.Pointer(v64))++
		*(*uint8)(unsafe.Pointer(v63)) = libc.Uint8FromInt32(int32(INST_STR_CONCAT1))
		v66 = envPtr3 + 152
		v65 = *(*uintptr)(unsafe.Pointer(v66))
		*(*uintptr)(unsafe.Pointer(v66))++
		*(*uint8)(unsafe.Pointer(v65)) = uint8(libc.Uint32FromInt64(numObjsToConcat))
		if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STR_CONCAT1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(numObjsToConcat)
			}
			v67 = delta1
			v68 = envPtr3
			if v67 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v68)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v68)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v68)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v68)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v68 + 64)) += int64(v67)
		}
	}
	/*
	 * If the tokens yielded no instructions, push an empty string.
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext == entryCodeNext {
		_objIndexCopy3 = XTclRegisterLiteral(tls, envPtr3, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
		if _objIndexCopy3 <= int32(255) {
			if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr3)
			}
			v70 = envPtr3 + 152
			v69 = *(*uintptr)(unsafe.Pointer(v70))
			*(*uintptr)(unsafe.Pointer(v70))++
			*(*uint8)(unsafe.Pointer(v69)) = libc.Uint8FromInt32(int32(INST_PUSH1))
			v72 = envPtr3 + 152
			v71 = *(*uintptr)(unsafe.Pointer(v72))
			*(*uintptr)(unsafe.Pointer(v72))++
			*(*uint8)(unsafe.Pointer(v71)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
			if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy3
				}
				v73 = delta1
				v74 = envPtr3
				if v73 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v74)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v74)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v74)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v74)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v74 + 64)) += int64(v73)
			}
		} else {
			if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr3)
			}
			v76 = envPtr3 + 152
			v75 = *(*uintptr)(unsafe.Pointer(v76))
			*(*uintptr)(unsafe.Pointer(v76))++
			*(*uint8)(unsafe.Pointer(v75)) = libc.Uint8FromInt32(int32(INST_PUSH4))
			v78 = envPtr3 + 152
			v77 = *(*uintptr)(unsafe.Pointer(v78))
			*(*uintptr)(unsafe.Pointer(v78))++
			*(*uint8)(unsafe.Pointer(v77)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(24))
			v80 = envPtr3 + 152
			v79 = *(*uintptr)(unsafe.Pointer(v80))
			*(*uintptr)(unsafe.Pointer(v80))++
			*(*uint8)(unsafe.Pointer(v79)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(16))
			v82 = envPtr3 + 152
			v81 = *(*uintptr)(unsafe.Pointer(v82))
			*(*uintptr)(unsafe.Pointer(v82))++
			*(*uint8)(unsafe.Pointer(v81)) = uint8(libc.Uint32FromInt32(_objIndexCopy3) >> libc.Int32FromInt32(8))
			v84 = envPtr3 + 152
			v83 = *(*uintptr)(unsafe.Pointer(v84))
			*(*uintptr)(unsafe.Pointer(v84))++
			*(*uint8)(unsafe.Pointer(v83)) = uint8(libc.Uint32FromInt32(_objIndexCopy3))
			if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - _objIndexCopy3
				}
				v85 = delta1
				v86 = envPtr3
				if v85 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v86)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v86)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v86)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v86)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v86 + 64)) += int64(v85)
			}
		}
	}
	XTcl_DStringFree(tls, bp)
	/*
	 * Release the temp table we used to collect the locations of continuation
	 * lines, if any.
	 */
	if maxNumCL != 0 {
		XTclpFree(tls, clPosition)
	}
	v87 = libc.Uint64FromInt32(depth1 + int32(1))
	v88 = envPtr3
	if v87 != libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(v88)).FcurrStackDepth) {
		XTcl_Panic(tls, __ccgo_ts+21474, libc.VaList(bp+240, libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(v88)).FcurrStackDepth), v87))
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileCmdWord --
 *
 *	Given an array of parse tokens for a word containing one or more Tcl
 *	commands, emits inline instructions to execute them.  In contrast with
 *	TclCompileTokens, a simple word such as a loop body enclosed in braces
 *	is not just pushed as a string, but is itself parsed into tokens and
 *	compiled.
 *
 * Results:
 *	A standard Tcl result. If an error occurs, an
 *	error message is left in the interpreter's result.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the tokens at runtime.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileCmdWord(tls *libc.TLS, interp uintptr, tokenPtr uintptr, count1 Tsize_t, envPtr uintptr) {
	/* Holds the resulting instructions. */
	var count int32
	_ = count
	count = libc.Int32FromUint64(count1)
	if count == int32(1) && (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_TEXT) {
		/*
		 * The common case that there is a single text token. Compile it
		 * into an inline sequence of instructions.
		 */
		XTclCompileScript(tls, interp, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize, envPtr)
	} else {
		/*
		 * Either there are multiple tokens, or the single token involves
		 * substitutions. Emit instructions to invoke the eval command
		 * procedure at runtime on the result of evaluating the tokens.
		 */
		XTclCompileTokens(tls, interp, tokenPtr, libc.Uint64FromInt32(count), envPtr)
		XTclEmitInvoke(tls, envPtr, int32(INST_EVAL_STK), 0)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileExprWords --
 *
 *	Given an array of parse tokens representing one or more words that
 *	contain a Tcl expression, emits inline instructions to execute the
 *	expression. In contrast with TclCompileExpr, supports Tcl's two-level
 *	substitution semantics for an expression that appears as command words.
 *
 * Results:
 *	A standard Tcl result. If an error occurs, an
 *	error message is left in the interpreter's result.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the expression.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileExprWords(tls *libc.TLS, interp uintptr, tokenPtr uintptr, numWords1 Tsize_t, envPtr2 uintptr) {
	/* Holds the resulting instructions. */
	var _objIndexCopy, concatItems, delta1, i1, numWords, v18, v24, v30, v34, v6 int32
	var wordPtr, v10, v11, v12, v13, v14, v15, v16, v17, v19, v2, v20, v21, v22, v23, v25, v26, v27, v28, v29, v3, v31, v32, v33, v35, v4, v5, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, concatItems, delta1, i1, numWords, wordPtr, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v4, v5, v6, v7, v8, v9
	numWords = libc.Int32FromUint64(numWords1)
	/*
	 * If the expression is a single word that doesn't require substitutions,
	 * just compile its string into inline instructions.
	 */
	if numWords == int32(1) && (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
		XTclCompileExpr(tls, interp, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize, envPtr2, int32(1))
		return
	}
	/*
	 * Emit code to call the expr command proc at runtime. Concatenate the
	 * (already substituted once) expr tokens with a space between each.
	 */
	wordPtr = tokenPtr
	i1 = 0
	for {
		if !(i1 < numWords) {
			break
		}
		XTclCompileTokens(tls, interp, wordPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(wordPtr)).FnumComponents), envPtr2)
		if i1 < numWords-int32(1) {
			_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+14830, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)), 0)
			if _objIndexCopy <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v3 = envPtr2 + 152
				v2 = *(*uintptr)(unsafe.Pointer(v3))
				*(*uintptr)(unsafe.Pointer(v3))++
				*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v5 = envPtr2 + 152
				v4 = *(*uintptr)(unsafe.Pointer(v5))
				*(*uintptr)(unsafe.Pointer(v5))++
				*(*uint8)(unsafe.Pointer(v4)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v6 = delta1
					v7 = envPtr2
					if v6 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v7 + 64)) += int64(v6)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v9 = envPtr2 + 152
				v8 = *(*uintptr)(unsafe.Pointer(v9))
				*(*uintptr)(unsafe.Pointer(v9))++
				*(*uint8)(unsafe.Pointer(v8)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v11 = envPtr2 + 152
				v10 = *(*uintptr)(unsafe.Pointer(v11))
				*(*uintptr)(unsafe.Pointer(v11))++
				*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
				v13 = envPtr2 + 152
				v12 = *(*uintptr)(unsafe.Pointer(v13))
				*(*uintptr)(unsafe.Pointer(v13))++
				*(*uint8)(unsafe.Pointer(v12)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
				v15 = envPtr2 + 152
				v14 = *(*uintptr)(unsafe.Pointer(v15))
				*(*uintptr)(unsafe.Pointer(v15))++
				*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
				v17 = envPtr2 + 152
				v16 = *(*uintptr)(unsafe.Pointer(v17))
				*(*uintptr)(unsafe.Pointer(v17))++
				*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v18 = delta1
					v19 = envPtr2
					if v18 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v19 + 64)) += int64(v18)
				}
			}
		}
		wordPtr += uintptr((*TTcl_Token)(unsafe.Pointer(wordPtr)).FnumComponents+int64(1)) * 32
		goto _1
	_1:
		;
		i1++
	}
	concatItems = int32(2)*numWords - int32(1)
	for concatItems > int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v21 = envPtr2 + 152
		v20 = *(*uintptr)(unsafe.Pointer(v21))
		*(*uintptr)(unsafe.Pointer(v21))++
		*(*uint8)(unsafe.Pointer(v20)) = libc.Uint8FromInt32(int32(INST_STR_CONCAT1))
		v23 = envPtr2 + 152
		v22 = *(*uintptr)(unsafe.Pointer(v23))
		*(*uintptr)(unsafe.Pointer(v23))++
		*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(255)))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STR_CONCAT1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - int32(255)
			}
			v24 = delta1
			v25 = envPtr2
			if v24 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v25 + 64)) += int64(v24)
		}
		concatItems -= int32(254)
	}
	if concatItems > int32(1) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v27 = envPtr2 + 152
		v26 = *(*uintptr)(unsafe.Pointer(v27))
		*(*uintptr)(unsafe.Pointer(v27))++
		*(*uint8)(unsafe.Pointer(v26)) = libc.Uint8FromInt32(int32(INST_STR_CONCAT1))
		v29 = envPtr2 + 152
		v28 = *(*uintptr)(unsafe.Pointer(v29))
		*(*uintptr)(unsafe.Pointer(v29))++
		*(*uint8)(unsafe.Pointer(v28)) = uint8(libc.Uint32FromInt32(concatItems))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_STR_CONCAT1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - concatItems
			}
			v30 = delta1
			v31 = envPtr2
			if v30 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v31)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v31)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v31)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v31)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v31 + 64)) += int64(v30)
		}
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v33 = envPtr2 + 152
	v32 = *(*uintptr)(unsafe.Pointer(v33))
	*(*uintptr)(unsafe.Pointer(v33))++
	*(*uint8)(unsafe.Pointer(v32)) = libc.Uint8FromInt32(int32(INST_EXPR_STK))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_EXPR_STK)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v34 = delta1
		v35 = envPtr2
		if v34 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v35)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v35)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v35)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v35)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v35 + 64)) += int64(v34)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileNoOp --
 *
 *	Compiles no-op's
 *
 * Results:
 *	TCL_OK if completion was successful.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute a no-op at runtime. No
 *	result is pushed onto the stack: the compiler has to take care of this
 *	itself if the last compiled command is a NoOp.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileNoOp(tls *libc.TLS, interp uintptr, parsePtr uintptr, dummy2758 uintptr, envPtr2 uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objIndexCopy, delta1, i1, v10, v22, v4 int32
	var tokenPtr, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v23, v3, v5, v6, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, delta1, i1, tokenPtr, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v3, v4, v5, v6, v7, v8, v9
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
	i1 = int32(1)
	for {
		if !(i1 < int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords)) {
			break
		}
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents)*32 + uintptr(1)*32
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) {
			XTclCompileTokens(tls, interp, tokenPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents), envPtr2)
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v3 = envPtr2 + 152
			v2 = *(*uintptr)(unsafe.Pointer(v3))
			*(*uintptr)(unsafe.Pointer(v3))++
			*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32(INST_POP))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v4 = delta1
				v5 = envPtr2
				if v4 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v5)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v5)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v5)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v5)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v5 + 64)) += int64(v4)
			}
		}
		goto _1
	_1:
		;
		i1++
	}
	_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, __ccgo_ts+1945, libc.Int64FromUint64(libc.Uint64FromInt64(1)-libc.Uint64FromInt32(1)), 0)
	if _objIndexCopy <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v7 = envPtr2 + 152
		v6 = *(*uintptr)(unsafe.Pointer(v7))
		*(*uintptr)(unsafe.Pointer(v7))++
		*(*uint8)(unsafe.Pointer(v6)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v9 = envPtr2 + 152
		v8 = *(*uintptr)(unsafe.Pointer(v9))
		*(*uintptr)(unsafe.Pointer(v9))++
		*(*uint8)(unsafe.Pointer(v8)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v10 = delta1
			v11 = envPtr2
			if v10 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v11)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v11)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v11)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v11)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v11 + 64)) += int64(v10)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v13 = envPtr2 + 152
		v12 = *(*uintptr)(unsafe.Pointer(v13))
		*(*uintptr)(unsafe.Pointer(v13))++
		*(*uint8)(unsafe.Pointer(v12)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v15 = envPtr2 + 152
		v14 = *(*uintptr)(unsafe.Pointer(v15))
		*(*uintptr)(unsafe.Pointer(v15))++
		*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
		v17 = envPtr2 + 152
		v16 = *(*uintptr)(unsafe.Pointer(v17))
		*(*uintptr)(unsafe.Pointer(v17))++
		*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
		v19 = envPtr2 + 152
		v18 = *(*uintptr)(unsafe.Pointer(v19))
		*(*uintptr)(unsafe.Pointer(v19))++
		*(*uint8)(unsafe.Pointer(v18)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
		v21 = envPtr2 + 152
		v20 = *(*uintptr)(unsafe.Pointer(v21))
		*(*uintptr)(unsafe.Pointer(v21))++
		*(*uint8)(unsafe.Pointer(v20)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy
			}
			v22 = delta1
			v23 = envPtr2
			if v22 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v23)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v23)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v23)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v23)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v23 + 64)) += int64(v22)
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclInitByteCodeObj --
 *
 *	Creates a ByteCode structure and initializes it from a CompileEnv
 *	compilation environment structure. The ByteCode structure is smaller
 *	and contains just that information needed to execute the bytecode
 *	instructions resulting from compiling a Tcl script. The resulting
 *	structure is placed in the specified object.
 *
 * Results:
 *	A newly-constructed ByteCode object is stored in the internal
 *	representation of the objPtr.
 *
 * Side effects:
 *	A single heap object is allocated to hold the new ByteCode structure
 *	and its code, object, command location, and aux data arrays. Note that
 *	"ownership" (i.e., the pointers to) the Tcl objects and aux data items
 *	will be handed over to the new ByteCode structure from the CompileEnv
 *	structure.
 *
 *----------------------------------------------------------------------
 */

func _PreventCycle(tls *libc.TLS, objPtr uintptr, envPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var bytes, copyPtr, v2 uintptr
	var i TTcl_Size
	var _ /* numBytes at bp+0 */ TTcl_Size
	_, _, _, _ = bytes, copyPtr, i, v2
	i = 0
	for {
		if !(i < (*TCompileEnv)(unsafe.Pointer(envPtr)).FliteralArrayNext) {
			break
		}
		if objPtr == XTclFetchLiteral(tls, envPtr, i) {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
				v2 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, objPtr, bp)
			}
			bytes = v2
			copyPtr = XTcl_NewStringObj(tls, bytes, *(*TTcl_Size)(unsafe.Pointer(bp)))
			(*TTcl_Obj)(unsafe.Pointer(copyPtr)).FrefCount++
			XTclReleaseLiteral(tls, (*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr, objPtr)
			(*(*TLiteralEntry)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FliteralArrayPtr + uintptr(i)*32))).FobjPtr = copyPtr
		}
		goto _1
	_1:
		;
		i++
	}
}

func XTclInitByteCode(tls *libc.TLS, envPtr uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Points to the CompileEnv structure from
	 * which to create a ByteCode structure. */
	var auxDataArrayBytes, cmdLocBytes, codeBytes, exceptArrayBytes, objArrayBytes, structureSize Tsize_t
	var codePtr, iPtr, namespacePtr, p uintptr
	var i, numLitObjects int32
	var _ /* isNew at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _ = auxDataArrayBytes, cmdLocBytes, codeBytes, codePtr, exceptArrayBytes, i, iPtr, namespacePtr, numLitObjects, objArrayBytes, p, structureSize
	numLitObjects = int32((*TCompileEnv)(unsafe.Pointer(envPtr)).FliteralArrayNext)
	if (*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+24145, 0)
	}
	iPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr
	codeBytes = libc.Uint64FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart))
	objArrayBytes = libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr)).FliteralArrayNext) * uint64(8)
	exceptArrayBytes = libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayNext) * uint64(56)
	auxDataArrayBytes = libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr)).FauxDataArrayNext) * uint64(16)
	cmdLocBytes = libc.Uint64FromInt32(_GetCmdLocEncodingSize(tls, envPtr))
	/*
	 * Compute the total number of bytes needed for this bytecode.
	 *
	 * Note that code bytes need not be aligned but since later elements are we
	 * need to pad anyway, either directly after ByteCode or after codeBytes,
	 * and it's easier and more consistent to do the former.
	 */
	structureSize = (libc.Uint64FromInt64(216) + (uint64(libc.UintptrFromInt32(0)+8) - libc.Uint64FromInt32(1))) & ^(uint64(libc.UintptrFromInt32(0)+8) - libc.Uint64FromInt32(1)) /* align code bytes */
	structureSize += (codeBytes + (uint64(libc.UintptrFromInt32(0)+8) - libc.Uint64FromInt32(1))) & ^(uint64(libc.UintptrFromInt32(0)+8) - libc.Uint64FromInt32(1))                /* align object array */
	structureSize += (objArrayBytes + (uint64(libc.UintptrFromInt32(0)+8) - libc.Uint64FromInt32(1))) & ^(uint64(libc.UintptrFromInt32(0)+8) - libc.Uint64FromInt32(1))            /* align exc range arr */
	structureSize += (exceptArrayBytes + (uint64(libc.UintptrFromInt32(0)+8) - libc.Uint64FromInt32(1))) & ^(uint64(libc.UintptrFromInt32(0)+8) - libc.Uint64FromInt32(1))         /* align AuxData array */
	structureSize += auxDataArrayBytes
	structureSize += cmdLocBytes
	if (*TInterp)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr)).FvarFramePtr != libc.UintptrFromInt32(0) {
		namespacePtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr)).FvarFramePtr)).FnsPtr
	} else {
		namespacePtr = (*TInterp)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr)).FglobalNsPtr
	}
	p = XTcl_Alloc(tls, structureSize)
	codePtr = p
	(*TByteCode)(unsafe.Pointer(codePtr)).FinterpHandle = XTclHandlePreserve(tls, (*TInterp)(unsafe.Pointer(iPtr)).Fhandle)
	(*TByteCode)(unsafe.Pointer(codePtr)).FcompileEpoch = (*TInterp)(unsafe.Pointer(iPtr)).FcompileEpoch
	(*TByteCode)(unsafe.Pointer(codePtr)).FnsPtr = namespacePtr
	(*TByteCode)(unsafe.Pointer(codePtr)).FnsEpoch = (*TNamespace)(unsafe.Pointer(namespacePtr)).FresolverEpoch
	(*TByteCode)(unsafe.Pointer(codePtr)).FrefCount = 0
	XTclPreserveByteCode(tls, codePtr)
	if (*TNamespace)(unsafe.Pointer(namespacePtr)).FcompiledVarResProc != 0 || (*TInterp)(unsafe.Pointer(iPtr)).FresolverPtr != 0 {
		(*TByteCode)(unsafe.Pointer(codePtr)).Fflags = uint32(TCL_BYTECODE_RESOLVE_VARS)
	} else {
		(*TByteCode)(unsafe.Pointer(codePtr)).Fflags = uint32(0)
	}
	(*TByteCode)(unsafe.Pointer(codePtr)).Fsource = (*TCompileEnv)(unsafe.Pointer(envPtr)).Fsource
	(*TByteCode)(unsafe.Pointer(codePtr)).FprocPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FprocPtr
	(*TByteCode)(unsafe.Pointer(codePtr)).FnumCommands = (*TCompileEnv)(unsafe.Pointer(envPtr)).FnumCommands
	(*TByteCode)(unsafe.Pointer(codePtr)).FnumSrcBytes = (*TCompileEnv)(unsafe.Pointer(envPtr)).FnumSrcBytes
	(*TByteCode)(unsafe.Pointer(codePtr)).FnumCodeBytes = libc.Int64FromUint64(codeBytes)
	(*TByteCode)(unsafe.Pointer(codePtr)).FnumLitObjects = int64(numLitObjects)
	(*TByteCode)(unsafe.Pointer(codePtr)).FnumExceptRanges = (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayNext
	(*TByteCode)(unsafe.Pointer(codePtr)).FnumAuxDataItems = (*TCompileEnv)(unsafe.Pointer(envPtr)).FauxDataArrayNext
	(*TByteCode)(unsafe.Pointer(codePtr)).FnumCmdLocBytes = libc.Int64FromUint64(cmdLocBytes)
	(*TByteCode)(unsafe.Pointer(codePtr)).FmaxExceptDepth = (*TCompileEnv)(unsafe.Pointer(envPtr)).FmaxExceptDepth
	(*TByteCode)(unsafe.Pointer(codePtr)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(envPtr)).FmaxStackDepth
	p += uintptr((libc.Uint64FromInt64(216) + (uint64(libc.UintptrFromInt32(0)+8) - libc.Uint64FromInt32(1))) & ^(uint64(libc.UintptrFromInt32(0)+8) - libc.Uint64FromInt32(1))) /* align code bytes */
	(*TByteCode)(unsafe.Pointer(codePtr)).FcodeStart = p
	libc.Xmemcpy(tls, p, (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart, codeBytes)
	p += uintptr((codeBytes + (uint64(libc.UintptrFromInt32(0)+8) - libc.Uint64FromInt32(1))) & ^(uint64(libc.UintptrFromInt32(0)+8) - libc.Uint64FromInt32(1))) /* align object array */
	(*TByteCode)(unsafe.Pointer(codePtr)).FobjArrayPtr = p
	i = 0
	for {
		if !(i < numLitObjects) {
			break
		}
		*(*uintptr)(unsafe.Pointer((*TByteCode)(unsafe.Pointer(codePtr)).FobjArrayPtr + uintptr(i)*8)) = XTclFetchLiteral(tls, envPtr, int64(i))
		goto _1
	_1:
		;
		i++
	}
	p += uintptr((objArrayBytes + (uint64(libc.UintptrFromInt32(0)+8) - libc.Uint64FromInt32(1))) & ^(uint64(libc.UintptrFromInt32(0)+8) - libc.Uint64FromInt32(1))) /* align exception range array */
	if exceptArrayBytes > uint64(0) {
		(*TByteCode)(unsafe.Pointer(codePtr)).FexceptArrayPtr = p
		libc.Xmemcpy(tls, p, (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayPtr, exceptArrayBytes)
	} else {
		(*TByteCode)(unsafe.Pointer(codePtr)).FexceptArrayPtr = libc.UintptrFromInt32(0)
	}
	p += uintptr((exceptArrayBytes + (uint64(libc.UintptrFromInt32(0)+8) - libc.Uint64FromInt32(1))) & ^(uint64(libc.UintptrFromInt32(0)+8) - libc.Uint64FromInt32(1))) /* align AuxData array */
	if auxDataArrayBytes > uint64(0) {
		(*TByteCode)(unsafe.Pointer(codePtr)).FauxDataArrayPtr = p
		libc.Xmemcpy(tls, p, (*TCompileEnv)(unsafe.Pointer(envPtr)).FauxDataArrayPtr, auxDataArrayBytes)
	} else {
		(*TByteCode)(unsafe.Pointer(codePtr)).FauxDataArrayPtr = libc.UintptrFromInt32(0)
	}
	p += uintptr(auxDataArrayBytes)
	_EncodeCmdLocMap(tls, envPtr, codePtr, p)
	/*
	 * Record various compilation-related statistics about the new ByteCode
	 * structure. Don't include overhead for statistics-related fields.
	 */
	/*
	 * TIP #280. Associate the extended per-word line information with the
	 * byte code object (internal rep), for use with the bc compiler.
	 */
	(*TTcl_HashEntry)(unsafe.Pointer((*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FlineBCPtr)).FcreateProc})))(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlineBCPtr, codePtr, bp))).FclientData = (*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr = libc.UintptrFromInt32(0)
	/* We've used up the CompileEnv.  Mark as uninitialized. */
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr = libc.UintptrFromInt32(0)
	(*TByteCode)(unsafe.Pointer(codePtr)).FlocalCachePtr = libc.UintptrFromInt32(0)
	return codePtr
}

func XTclInitByteCodeObj(tls *libc.TLS, objPtr uintptr, typePtr uintptr, envPtr uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Points to the CompileEnv structure from
	 * which to create a ByteCode structure. */
	var codePtr uintptr
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_ = codePtr
	_PreventCycle(tls, objPtr, envPtr)
	codePtr = XTclInitByteCode(tls, envPtr)
	/*
	 * Free the old internal rep then convert the object to a bytecode object
	 * by making its internal rep point to the just compiled ByteCode.
	 */
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr1 = codePtr
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr2 = libc.UintptrFromInt32(0)
	XTcl_StoreInternalRep(tls, objPtr, typePtr, bp)
	return codePtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclFindCompiledLocal --
 *
 *	This procedure is called at compile time to look up and optionally
 *	allocate an entry ("slot") for a variable in a procedure's array of
 *	local variables. If the variable's name is NULL, a new temporary
 *	variable is always created. (Such temporary variables can only be
 *	referenced using their slot index.)
 *
 * Results:
 *	If create is 0 and the name is non-NULL, then if the variable is
 *	found, the index of its entry in the procedure's array of local
 *	variables is returned; otherwise -1 is returned. If name is NULL, the
 *	index of a new temporary variable is returned. Finally, if create is 1
 *	and name is non-NULL, the index of a new entry is returned.
 *
 * Side effects:
 *	Creates and registers a new local variable if create is 1 and the
 *	variable is unknown, or if the name is NULL.
 *
 *----------------------------------------------------------------------
 */

func XTclFindCompiledLocal(tls *libc.TLS, name uintptr, nameBytes TTcl_Size, create int32, envPtr uintptr) (r TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Points to the current compile environment*/
	var cachePtr, localName, localName1, localPtr, procPtr, varNamePtr, v2, v4 uintptr
	var i, localCt, localVar TTcl_Size
	var _ /* len at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _ = cachePtr, i, localCt, localName, localName1, localPtr, localVar, procPtr, varNamePtr, v2, v4
	localVar = int64(-libc.Int32FromInt32(1))
	/*
	 * If not creating a temporary, does a local variable of the specified
	 * name already exist?
	 */
	procPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FprocPtr
	if procPtr == libc.UintptrFromInt32(0) {
		/*
		 * Compiling a non-body script: give it read access to the LVT in the
		 * current localCache
		 */
		cachePtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr)).FvarFramePtr)).FlocalCachePtr
		if !(cachePtr != 0) || !(name != 0) {
			return int64(-libc.Int32FromInt32(1))
		}
		varNamePtr = cachePtr + 16
		i = 0
		for {
			if !(i < (*TLocalCache)(unsafe.Pointer(cachePtr)).FnumVars) {
				break
			}
			if *(*uintptr)(unsafe.Pointer(varNamePtr)) != 0 {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(varNamePtr)))).Fbytes != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(varNamePtr)))).Flength
					v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(varNamePtr)))).Fbytes
				} else {
					v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(varNamePtr)), bp)
				}
				localName = v2
				if *(*TTcl_Size)(unsafe.Pointer(bp)) == nameBytes && !(libc.Xstrncmp(tls, name, localName, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))) != 0) {
					return i
				}
			}
			goto _1
		_1:
			;
			varNamePtr += 8
			i++
		}
		return int64(-libc.Int32FromInt32(1))
	}
	if name != libc.UintptrFromInt32(0) {
		localCt = (*TProc)(unsafe.Pointer(procPtr)).FnumCompiledLocals
		localPtr = (*TProc)(unsafe.Pointer(procPtr)).FfirstLocalPtr
		i = 0
		for {
			if !(i < localCt) {
				break
			}
			if !((*TCompiledLocal)(unsafe.Pointer(localPtr)).Fflags&libc.Int32FromInt32(VAR_TEMPORARY) != 0) {
				localName1 = localPtr + 44
				if nameBytes == (*TCompiledLocal)(unsafe.Pointer(localPtr)).FnameLength && libc.Xstrncmp(tls, name, localName1, libc.Uint64FromInt64(nameBytes)) == 0 {
					return i
				}
			}
			localPtr = (*TCompiledLocal)(unsafe.Pointer(localPtr)).FnextPtr
			goto _3
		_3:
			;
			i++
		}
	}
	/*
	 * Create a new variable if appropriate.
	 */
	if create != 0 || name == libc.UintptrFromInt32(0) {
		localVar = (*TProc)(unsafe.Pointer(procPtr)).FnumCompiledLocals
		localPtr = XTcl_Alloc(tls, uint64(libc.UintptrFromInt32(0)+44)+libc.Uint64FromUint32(1)+libc.Uint64FromInt64(nameBytes))
		if (*TProc)(unsafe.Pointer(procPtr)).FfirstLocalPtr == libc.UintptrFromInt32(0) {
			v4 = localPtr
			(*TProc)(unsafe.Pointer(procPtr)).FlastLocalPtr = v4
			(*TProc)(unsafe.Pointer(procPtr)).FfirstLocalPtr = v4
		} else {
			(*TCompiledLocal)(unsafe.Pointer((*TProc)(unsafe.Pointer(procPtr)).FlastLocalPtr)).FnextPtr = localPtr
			(*TProc)(unsafe.Pointer(procPtr)).FlastLocalPtr = localPtr
		}
		(*TCompiledLocal)(unsafe.Pointer(localPtr)).FnextPtr = libc.UintptrFromInt32(0)
		(*TCompiledLocal)(unsafe.Pointer(localPtr)).FnameLength = nameBytes
		(*TCompiledLocal)(unsafe.Pointer(localPtr)).FframeIndex = localVar
		(*TCompiledLocal)(unsafe.Pointer(localPtr)).Fflags = 0
		if name == libc.UintptrFromInt32(0) {
			*(*int32)(unsafe.Pointer(localPtr + 40)) |= int32(VAR_TEMPORARY)
		}
		(*TCompiledLocal)(unsafe.Pointer(localPtr)).FdefValuePtr = libc.UintptrFromInt32(0)
		(*TCompiledLocal)(unsafe.Pointer(localPtr)).FresolveInfo = libc.UintptrFromInt32(0)
		if name != libc.UintptrFromInt32(0) {
			libc.Xmemcpy(tls, localPtr+44, name, libc.Uint64FromInt64(nameBytes))
		}
		*(*uint8)(unsafe.Pointer(localPtr + 44 + uintptr(nameBytes))) = uint8('\000')
		(*TProc)(unsafe.Pointer(procPtr)).FnumCompiledLocals++
	}
	return localVar
}

/*
 *----------------------------------------------------------------------
 *
 * TclExpandCodeArray --
 *
 *	Uses malloc to allocate more storage for a CompileEnv's code array.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The size of the bytecode array is doubled. If envPtr->mallocedCodeArray
 *	is non-zero the old array is freed. Byte codes are copied from the old
 *	array to the new one.
 *
 *----------------------------------------------------------------------
 */

func XTclExpandCodeArray(tls *libc.TLS, envArgPtr uintptr) {
	/* Points to the CompileEnv whose code array
	 * must be enlarged. */
	var currBytes, newBytes Tsize_t
	var envPtr, newPtr uintptr
	_, _, _, _ = currBytes, envPtr, newBytes, newPtr
	envPtr = envArgPtr
	/* The CompileEnv containing the code array to
	 * be doubled in size. */
	/*
	 * envPtr->codeNext is equal to envPtr->codeEnd. The currently defined
	 * code bytes are stored between envPtr->codeStart and envPtr->codeNext-1
	 * [inclusive].
	 */
	currBytes = libc.Uint64FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart))
	newBytes = libc.Uint64FromInt64(int64(2) * (int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeEnd) - int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr)).FmallocedCodeArray != 0 {
		(*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart = XTcl_Realloc(tls, (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart, newBytes)
	} else {
		/*
		 * envPtr->exceptArrayPtr isn't a Tcl_Alloc'd pointer, so
		 * perform the equivalent of Tcl_Realloc directly.
		 */
		newPtr = XTcl_Alloc(tls, newBytes)
		libc.Xmemcpy(tls, newPtr, (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart, currBytes)
		(*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart = newPtr
		(*TCompileEnv)(unsafe.Pointer(envPtr)).FmallocedCodeArray = int32(1)
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext = (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr(currBytes)
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeEnd = (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr(newBytes)
}

/*
 *----------------------------------------------------------------------
 *
 * EnterCmdStartData --
 *
 *	Registers the starting source and bytecode location of a command. This
 *	information is used at runtime to map between instruction pc and
 *	source locations.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Inserts source and code location information into the compilation
 *	environment envPtr for the command at index cmdIndex. The compilation
 *	environment's CmdLocation array is grown if necessary.
 *
 *----------------------------------------------------------------------
 */

func _EnterCmdStartData(tls *libc.TLS, envPtr uintptr, cmdIndex TTcl_Size, srcOffset TTcl_Size, codeOffset TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Offset of first byte of command code. */
	var cmdLocPtr, newPtr uintptr
	var currBytes, currElems, newBytes, newElems Tsize_t
	_, _, _, _, _, _ = cmdLocPtr, currBytes, currElems, newBytes, newElems, newPtr
	if cmdIndex < 0 || cmdIndex >= (*TCompileEnv)(unsafe.Pointer(envPtr)).FnumCommands {
		XTcl_Panic(tls, __ccgo_ts+24201, libc.VaList(bp+8, cmdIndex))
	}
	if cmdIndex >= (*TCompileEnv)(unsafe.Pointer(envPtr)).FcmdMapEnd {
		/*
		 * Expand the command location array by allocating more storage from
		 * the heap. The currently allocated CmdLocation entries are stored
		 * from cmdMapPtr[0] up to cmdMapPtr[envPtr->cmdMapEnd] (inclusive).
		 */
		currElems = libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcmdMapEnd)
		newElems = uint64(2) * currElems
		currBytes = currElems * uint64(32)
		newBytes = newElems * uint64(32)
		if (*TCompileEnv)(unsafe.Pointer(envPtr)).FmallocedCmdMap != 0 {
			(*TCompileEnv)(unsafe.Pointer(envPtr)).FcmdMapPtr = XTcl_Realloc(tls, (*TCompileEnv)(unsafe.Pointer(envPtr)).FcmdMapPtr, newBytes)
		} else {
			/*
			 * envPtr->cmdMapPtr isn't a Tcl_Alloc'd pointer, so we must code a
			 * Tcl_Realloc equivalent for ourselves.
			 */
			newPtr = XTcl_Alloc(tls, newBytes)
			libc.Xmemcpy(tls, newPtr, (*TCompileEnv)(unsafe.Pointer(envPtr)).FcmdMapPtr, currBytes)
			(*TCompileEnv)(unsafe.Pointer(envPtr)).FcmdMapPtr = newPtr
			(*TCompileEnv)(unsafe.Pointer(envPtr)).FmallocedCmdMap = int32(1)
		}
		(*TCompileEnv)(unsafe.Pointer(envPtr)).FcmdMapEnd = libc.Int64FromUint64(newElems)
	}
	if cmdIndex > 0 {
		if codeOffset < (*(*TCmdLocation)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FcmdMapPtr + uintptr(cmdIndex-int64(1))*32))).FcodeOffset {
			XTcl_Panic(tls, __ccgo_ts+24242, 0)
		}
	}
	cmdLocPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FcmdMapPtr + uintptr(cmdIndex)*32
	(*TCmdLocation)(unsafe.Pointer(cmdLocPtr)).FcodeOffset = codeOffset
	(*TCmdLocation)(unsafe.Pointer(cmdLocPtr)).FsrcOffset = srcOffset
	(*TCmdLocation)(unsafe.Pointer(cmdLocPtr)).FnumSrcBytes = int64(-libc.Int32FromInt32(1))
	(*TCmdLocation)(unsafe.Pointer(cmdLocPtr)).FnumCodeBytes = int64(-libc.Int32FromInt32(1))
}

/*
 *----------------------------------------------------------------------
 *
 * EnterCmdExtentData --
 *
 *	Registers the source and bytecode length for a command. This
 *	information is used at runtime to map between instruction pc and
 *	source locations.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Inserts source and code length information into the compilation
 *	environment envPtr for the command at index cmdIndex. Starting source
 *	and bytecode information for the command must already have been
 *	registered.
 *
 *----------------------------------------------------------------------
 */

func _EnterCmdExtentData(tls *libc.TLS, envPtr uintptr, cmdIndex TTcl_Size, numSrcBytes TTcl_Size, numCodeBytes TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Offset of last byte of command code. */
	var cmdLocPtr uintptr
	_ = cmdLocPtr
	if cmdIndex < 0 || cmdIndex >= (*TCompileEnv)(unsafe.Pointer(envPtr)).FnumCommands {
		XTcl_Panic(tls, __ccgo_ts+24295, libc.VaList(bp+8, cmdIndex))
	}
	if cmdIndex > (*TCompileEnv)(unsafe.Pointer(envPtr)).FcmdMapEnd {
		XTcl_Panic(tls, __ccgo_ts+24337, libc.VaList(bp+8, cmdIndex))
	}
	cmdLocPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FcmdMapPtr + uintptr(cmdIndex)*32
	(*TCmdLocation)(unsafe.Pointer(cmdLocPtr)).FnumSrcBytes = numSrcBytes
	(*TCmdLocation)(unsafe.Pointer(cmdLocPtr)).FnumCodeBytes = numCodeBytes
}

/*
 *----------------------------------------------------------------------
 * TIP #280
 *
 * EnterCmdWordData --
 *
 *	Registers the lines for the words of a command. This information is
 *	used at runtime by 'info frame'.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Inserts word location information into the compilation environment
 *	envPtr for the command at index cmdIndex. The compilation
 *	environment's ExtCmdLoc.ECL array is grown if necessary.
 *
 *----------------------------------------------------------------------
 */

func _EnterCmdWordData(tls *libc.TLS, eclPtr uintptr, srcOffset TTcl_Size, tokenPtr uintptr, cmd uintptr, numWords TTcl_Size, line TTcl_Size, clNext uintptr, wlines uintptr, envPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var currElems, newBytes, newElems Tsize_t
	var ePtr, last, wwlines uintptr
	var wordIdx TTcl_Size
	var v1 uint64
	var v3 int64
	var _ /* wordLine at bp+0 */ TTcl_Size
	var _ /* wordNext at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _ = currElems, ePtr, last, newBytes, newElems, wordIdx, wwlines, v1, v3
	if (*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Fnuloc >= (*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Fnloc {
		/*
		 * Expand the ECL array by allocating more storage from the heap. The
		 * currently allocated ECL entries are stored from eclPtr->loc[0] up
		 * to eclPtr->loc[eclPtr->nuloc-1] (inclusive).
		 */
		currElems = libc.Uint64FromInt64((*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Fnloc)
		if currElems != 0 {
			v1 = uint64(2) * currElems
		} else {
			v1 = uint64(1)
		}
		newElems = v1
		newBytes = newElems * uint64(32)
		(*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Floc = XTcl_Realloc(tls, (*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Floc, newBytes)
		(*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Fnloc = libc.Int64FromUint64(newElems)
	}
	ePtr = (*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Floc + uintptr((*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Fnuloc)*32
	(*TECL)(unsafe.Pointer(ePtr)).FsrcOffset = srcOffset
	(*TECL)(unsafe.Pointer(ePtr)).Fline = XTcl_Alloc(tls, libc.Uint64FromInt64(numWords)*uint64(8))
	(*TECL)(unsafe.Pointer(ePtr)).Fnext = XTcl_Alloc(tls, libc.Uint64FromInt64(numWords)*uint64(8))
	(*TECL)(unsafe.Pointer(ePtr)).Fnline = numWords
	wwlines = XTcl_Alloc(tls, libc.Uint64FromInt64(numWords)*uint64(8))
	last = cmd
	*(*TTcl_Size)(unsafe.Pointer(bp)) = line
	*(*uintptr)(unsafe.Pointer(bp + 8)) = clNext
	wordIdx = 0
	for {
		if !(wordIdx < numWords) {
			break
		}
		XTclAdvanceLines(tls, bp, last, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart)
		XTclAdvanceContinuations(tls, bp, bp+8, int32(int64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart)-int64((*TCompileEnv)(unsafe.Pointer(envPtr)).Fsource)))
		/* See Ticket 4b61afd660 */
		if wordIdx == 0 || XTclWordKnownAtCompileTime(tls, tokenPtr, libc.UintptrFromInt32(0)) != 0 {
			v3 = *(*TTcl_Size)(unsafe.Pointer(bp))
		} else {
			v3 = int64(-int32(1))
		}
		*(*TTcl_Size)(unsafe.Pointer(wwlines + uintptr(wordIdx)*8)) = v3
		*(*TTcl_Size)(unsafe.Pointer((*TECL)(unsafe.Pointer(ePtr)).Fline + uintptr(wordIdx)*8)) = *(*TTcl_Size)(unsafe.Pointer(bp))
		*(*uintptr)(unsafe.Pointer((*TECL)(unsafe.Pointer(ePtr)).Fnext + uintptr(wordIdx)*8)) = *(*uintptr)(unsafe.Pointer(bp + 8))
		last = (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart
		goto _2
	_2:
		;
		wordIdx++
		tokenPtr += uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+int64(1)) * 32
	}
	*(*uintptr)(unsafe.Pointer(wlines)) = wwlines
	(*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Fnuloc++
}

/*
 *----------------------------------------------------------------------
 *
 * TclCreateExceptRange --
 *
 *	Procedure that allocates and initializes a new ExceptionRange
 *	structure of the specified kind in a CompileEnv.
 *
 * Results:
 *	Returns the index for the newly created ExceptionRange.
 *
 * Side effects:
 *	If there is not enough room in the CompileEnv's ExceptionRange array,
 *	the array in expanded: a new array of double the size is allocated, if
 *	envPtr->mallocedExceptArray is non-zero the old array is freed, and
 *	ExceptionRange entries are copied from the old array to the new one.
 *
 *----------------------------------------------------------------------
 */

func XTclCreateExceptRange(tls *libc.TLS, type1 TExceptionRangeType, envPtr uintptr) (r TTcl_Size) {
	/* Points to CompileEnv for which to create a
	 * new ExceptionRange structure. */
	var auxPtr, newPtr, newPtr2, rangePtr uintptr
	var currBytes, currBytes2, newBytes, newBytes2, newElems Tsize_t
	var index TTcl_Size
	_, _, _, _, _, _, _, _, _, _ = auxPtr, currBytes, currBytes2, index, newBytes, newBytes2, newElems, newPtr, newPtr2, rangePtr
	index = (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayNext
	if index >= (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayEnd {
		/*
		 * Expand the ExceptionRange array. The currently allocated entries
		 * are stored between elements 0 and (envPtr->exceptArrayNext - 1)
		 * [inclusive].
		 */
		currBytes = libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayNext) * uint64(56)
		currBytes2 = libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayNext) * uint64(80)
		newElems = libc.Uint64FromInt64(int64(2) * (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayEnd)
		newBytes = newElems * uint64(56)
		newBytes2 = newElems * uint64(80)
		if (*TCompileEnv)(unsafe.Pointer(envPtr)).FmallocedExceptArray != 0 {
			(*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayPtr = XTcl_Realloc(tls, (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayPtr, newBytes)
			(*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptAuxArrayPtr = XTcl_Realloc(tls, (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptAuxArrayPtr, newBytes2)
		} else {
			/*
			 * envPtr->exceptArrayPtr isn't a Tcl_Alloc'd pointer, so we must
			 * code a Tcl_Realloc equivalent for ourselves.
			 */
			newPtr = XTcl_Alloc(tls, newBytes)
			newPtr2 = XTcl_Alloc(tls, newBytes2)
			libc.Xmemcpy(tls, newPtr, (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayPtr, currBytes)
			libc.Xmemcpy(tls, newPtr2, (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptAuxArrayPtr, currBytes2)
			(*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayPtr = newPtr
			(*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptAuxArrayPtr = newPtr2
			(*TCompileEnv)(unsafe.Pointer(envPtr)).FmallocedExceptArray = int32(1)
		}
		(*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayEnd = libc.Int64FromUint64(newElems)
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayNext++
	rangePtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayPtr + uintptr(index)*56
	(*TExceptionRange)(unsafe.Pointer(rangePtr)).Ftype1 = type1
	(*TExceptionRange)(unsafe.Pointer(rangePtr)).FnestingLevel = (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptDepth
	(*TExceptionRange)(unsafe.Pointer(rangePtr)).FcodeOffset = int64(-libc.Int32FromInt32(1))
	(*TExceptionRange)(unsafe.Pointer(rangePtr)).FnumCodeBytes = int64(-libc.Int32FromInt32(1))
	(*TExceptionRange)(unsafe.Pointer(rangePtr)).FbreakOffset = int64(-libc.Int32FromInt32(1))
	(*TExceptionRange)(unsafe.Pointer(rangePtr)).FcontinueOffset = int64(-libc.Int32FromInt32(1))
	(*TExceptionRange)(unsafe.Pointer(rangePtr)).FcatchOffset = int64(-libc.Int32FromInt32(1))
	auxPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptAuxArrayPtr + uintptr(index)*80
	(*TExceptionAux)(unsafe.Pointer(auxPtr)).FsupportsContinue = int32(1)
	(*TExceptionAux)(unsafe.Pointer(auxPtr)).FstackDepth = (*TCompileEnv)(unsafe.Pointer(envPtr)).FcurrStackDepth
	(*TExceptionAux)(unsafe.Pointer(auxPtr)).FexpandTarget = (*TCompileEnv)(unsafe.Pointer(envPtr)).FexpandCount
	(*TExceptionAux)(unsafe.Pointer(auxPtr)).FexpandTargetDepth = int64(-libc.Int32FromInt32(1))
	(*TExceptionAux)(unsafe.Pointer(auxPtr)).FnumBreakTargets = 0
	(*TExceptionAux)(unsafe.Pointer(auxPtr)).FbreakTargets = libc.UintptrFromInt32(0)
	(*TExceptionAux)(unsafe.Pointer(auxPtr)).FallocBreakTargets = 0
	(*TExceptionAux)(unsafe.Pointer(auxPtr)).FnumContinueTargets = 0
	(*TExceptionAux)(unsafe.Pointer(auxPtr)).FcontinueTargets = libc.UintptrFromInt32(0)
	(*TExceptionAux)(unsafe.Pointer(auxPtr)).FallocContinueTargets = 0
	return index
}

/*
 * ---------------------------------------------------------------------
 *
 * TclGetInnermostExceptionRange --
 *
 *	Returns the innermost exception range that covers the current code
 *	creation point, and optionally the stack depth that is expected at
 *	that point. Relies on the fact that the range has a numCodeBytes = -1
 *	when it is being populated and that inner ranges come after outer
 *	ranges.
 *
 * ---------------------------------------------------------------------
 */

func XTclGetInnermostExceptionRange(tls *libc.TLS, envPtr uintptr, returnCode int32, auxPtrPtr uintptr) (r uintptr) {
	var i Tsize_t
	var rangePtr uintptr
	_, _ = i, rangePtr
	i = libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayNext)
	rangePtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayPtr + uintptr(i)*56
	for i > uint64(0) {
		rangePtr -= 56
		i--
		if int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart) >= int64(int32((*TExceptionRange)(unsafe.Pointer(rangePtr)).FcodeOffset)) && ((*TExceptionRange)(unsafe.Pointer(rangePtr)).FnumCodeBytes == int64(-libc.Int32FromInt32(1)) || int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart) < int64(int32((*TExceptionRange)(unsafe.Pointer(rangePtr)).FcodeOffset)+int32((*TExceptionRange)(unsafe.Pointer(rangePtr)).FnumCodeBytes))) && (returnCode != int32(TCL_CONTINUE) || (*(*TExceptionAux)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptAuxArrayPtr + uintptr(i)*80))).FsupportsContinue != 0) {
			if auxPtrPtr != 0 {
				*(*uintptr)(unsafe.Pointer(auxPtrPtr)) = (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptAuxArrayPtr + uintptr(i)*80
			}
			return rangePtr
		}
	}
	return libc.UintptrFromInt32(0)
}

/*
 * ---------------------------------------------------------------------
 *
 * TclAddLoopBreakFixup, TclAddLoopContinueFixup --
 *
 *	Adds a place that wants to break/continue to the loop exception range
 *	tracking that will be fixed up once the loop can be finalized. These
 *	functions generate an INST_JUMP4 that is fixed up during the
 *	loop finalization.
 *
 * ---------------------------------------------------------------------
 */

func XTclAddLoopBreakFixup(tls *libc.TLS, envPtr2 uintptr, auxPtr uintptr) {
	var delta1, range1, v13 int32
	var v1 TTcl_Size
	var v10, v11, v12, v14, v2, v3, v4, v5, v6, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = delta1, range1, v1, v10, v11, v12, v13, v14, v2, v3, v4, v5, v6, v7, v8, v9
	range1 = int32((int64(auxPtr) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptAuxArrayPtr)) / 80)
	if (*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).Ftype1 != int32(LOOP_EXCEPTION_RANGE) {
		XTcl_Panic(tls, __ccgo_ts+24392, 0)
	}
	v2 = auxPtr + 32
	*(*TTcl_Size)(unsafe.Pointer(v2))++
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	if v1 > (*TExceptionAux)(unsafe.Pointer(auxPtr)).FallocBreakTargets {
		*(*TTcl_Size)(unsafe.Pointer(auxPtr + 48)) *= int64(2)
		*(*TTcl_Size)(unsafe.Pointer(auxPtr + 48)) += int64(2)
		if (*TExceptionAux)(unsafe.Pointer(auxPtr)).FbreakTargets != 0 {
			(*TExceptionAux)(unsafe.Pointer(auxPtr)).FbreakTargets = XTcl_Realloc(tls, (*TExceptionAux)(unsafe.Pointer(auxPtr)).FbreakTargets, uint64(8)*libc.Uint64FromInt64((*TExceptionAux)(unsafe.Pointer(auxPtr)).FallocBreakTargets))
		} else {
			(*TExceptionAux)(unsafe.Pointer(auxPtr)).FbreakTargets = XTcl_Alloc(tls, uint64(8)*libc.Uint64FromInt64((*TExceptionAux)(unsafe.Pointer(auxPtr)).FallocBreakTargets))
		}
	}
	*(*Tsize_t)(unsafe.Pointer((*TExceptionAux)(unsafe.Pointer(auxPtr)).FbreakTargets + uintptr((*TExceptionAux)(unsafe.Pointer(auxPtr)).FnumBreakTargets-int64(1))*8)) = libc.Uint64FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v4 = envPtr2 + 152
	v3 = *(*uintptr)(unsafe.Pointer(v4))
	*(*uintptr)(unsafe.Pointer(v4))++
	*(*uint8)(unsafe.Pointer(v3)) = libc.Uint8FromInt32(int32(INST_JUMP4))
	v6 = envPtr2 + 152
	v5 = *(*uintptr)(unsafe.Pointer(v6))
	*(*uintptr)(unsafe.Pointer(v6))++
	*(*uint8)(unsafe.Pointer(v5)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
	v8 = envPtr2 + 152
	v7 = *(*uintptr)(unsafe.Pointer(v8))
	*(*uintptr)(unsafe.Pointer(v8))++
	*(*uint8)(unsafe.Pointer(v7)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
	v10 = envPtr2 + 152
	v9 = *(*uintptr)(unsafe.Pointer(v10))
	*(*uintptr)(unsafe.Pointer(v10))++
	*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
	v12 = envPtr2 + 152
	v11 = *(*uintptr)(unsafe.Pointer(v12))
	*(*uintptr)(unsafe.Pointer(v12))++
	*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_JUMP4)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v13 = delta1
		v14 = envPtr2
		if v13 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v14)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v14)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v14)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v14)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v14 + 64)) += int64(v13)
	}
}

func XTclAddLoopContinueFixup(tls *libc.TLS, envPtr2 uintptr, auxPtr uintptr) {
	var delta1, range1, v13 int32
	var v1 TTcl_Size
	var v10, v11, v12, v14, v2, v3, v4, v5, v6, v7, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = delta1, range1, v1, v10, v11, v12, v13, v14, v2, v3, v4, v5, v6, v7, v8, v9
	range1 = int32((int64(auxPtr) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptAuxArrayPtr)) / 80)
	if (*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(range1)*56))).Ftype1 != int32(LOOP_EXCEPTION_RANGE) {
		XTcl_Panic(tls, __ccgo_ts+24444, 0)
	}
	v2 = auxPtr + 56
	*(*TTcl_Size)(unsafe.Pointer(v2))++
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	if v1 > (*TExceptionAux)(unsafe.Pointer(auxPtr)).FallocContinueTargets {
		*(*TTcl_Size)(unsafe.Pointer(auxPtr + 72)) *= int64(2)
		*(*TTcl_Size)(unsafe.Pointer(auxPtr + 72)) += int64(2)
		if (*TExceptionAux)(unsafe.Pointer(auxPtr)).FcontinueTargets != 0 {
			(*TExceptionAux)(unsafe.Pointer(auxPtr)).FcontinueTargets = XTcl_Realloc(tls, (*TExceptionAux)(unsafe.Pointer(auxPtr)).FcontinueTargets, uint64(8)*libc.Uint64FromInt64((*TExceptionAux)(unsafe.Pointer(auxPtr)).FallocContinueTargets))
		} else {
			(*TExceptionAux)(unsafe.Pointer(auxPtr)).FcontinueTargets = XTcl_Alloc(tls, uint64(8)*libc.Uint64FromInt64((*TExceptionAux)(unsafe.Pointer(auxPtr)).FallocContinueTargets))
		}
	}
	*(*Tsize_t)(unsafe.Pointer((*TExceptionAux)(unsafe.Pointer(auxPtr)).FcontinueTargets + uintptr((*TExceptionAux)(unsafe.Pointer(auxPtr)).FnumContinueTargets-int64(1))*8)) = libc.Uint64FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v4 = envPtr2 + 152
	v3 = *(*uintptr)(unsafe.Pointer(v4))
	*(*uintptr)(unsafe.Pointer(v4))++
	*(*uint8)(unsafe.Pointer(v3)) = libc.Uint8FromInt32(int32(INST_JUMP4))
	v6 = envPtr2 + 152
	v5 = *(*uintptr)(unsafe.Pointer(v6))
	*(*uintptr)(unsafe.Pointer(v6))++
	*(*uint8)(unsafe.Pointer(v5)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(24))
	v8 = envPtr2 + 152
	v7 = *(*uintptr)(unsafe.Pointer(v8))
	*(*uintptr)(unsafe.Pointer(v8))++
	*(*uint8)(unsafe.Pointer(v7)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(16))
	v10 = envPtr2 + 152
	v9 = *(*uintptr)(unsafe.Pointer(v10))
	*(*uintptr)(unsafe.Pointer(v10))++
	*(*uint8)(unsafe.Pointer(v9)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)) >> libc.Int32FromInt32(8))
	v12 = envPtr2 + 152
	v11 = *(*uintptr)(unsafe.Pointer(v12))
	*(*uintptr)(unsafe.Pointer(v12))++
	*(*uint8)(unsafe.Pointer(v11)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_JUMP4)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v13 = delta1
		v14 = envPtr2
		if v13 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v14)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v14)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v14)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v14)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v14 + 64)) += int64(v13)
	}
}

/*
 * ---------------------------------------------------------------------
 *
 * TclCleanupStackForBreakContinue --
 *
 *	Removes the extra elements from the auxiliary stack and the main stack.
 *	How this is done depends on whether there are any elements on
 *	the auxiliary stack to pop.
 *
 * ---------------------------------------------------------------------
 */

func XTclCleanupStackForBreakContinue(tls *libc.TLS, envPtr2 uintptr, auxPtr uintptr) {
	var delta1, toPop, v1, v11, v4, v6, v8 int32
	var savedStackDepth Tsize_t
	var v10, v12, v2, v3, v5, v7, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = delta1, savedStackDepth, toPop, v1, v10, v11, v12, v2, v3, v4, v5, v6, v7, v8, v9
	savedStackDepth = libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcurrStackDepth)
	toPop = int32((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexpandCount - (*TExceptionAux)(unsafe.Pointer(auxPtr)).FexpandTarget)
	if toPop > 0 {
		for {
			v1 = toPop
			toPop--
			if !(v1 > 0) {
				break
			}
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
				XTclExpandCodeArray(tls, envPtr2)
			}
			v3 = envPtr2 + 152
			v2 = *(*uintptr)(unsafe.Pointer(v3))
			*(*uintptr)(unsafe.Pointer(v3))++
			*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32(INST_EXPAND_DROP))
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
				(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
			}
			delta1 = XtclInstructionTable[uint8(INST_EXPAND_DROP)].FstackEffect
			if delta1 != 0 {
				if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
					delta1 = int32(1) - 0
				}
				v4 = delta1
				v5 = envPtr2
				if v4 < libc.Int32FromInt32(0) {
					if int32((*TCompileEnv)(unsafe.Pointer(v5)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v5)).FcurrStackDepth) {
						(*TCompileEnv)(unsafe.Pointer(v5)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v5)).FcurrStackDepth
					}
				}
				*(*TTcl_Size)(unsafe.Pointer(v5 + 64)) += int64(v4)
			}
		}
		v6 = int32((*TExceptionAux)(unsafe.Pointer(auxPtr)).FexpandTargetDepth - (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcurrStackDepth)
		v7 = envPtr2
		if v6 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v7)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v7)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v7 + 64)) += int64(v6)
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FcurrStackDepth = (*TExceptionAux)(unsafe.Pointer(auxPtr)).FexpandTargetDepth
	}
	toPop = int32((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcurrStackDepth - (*TExceptionAux)(unsafe.Pointer(auxPtr)).FstackDepth)
	for {
		v8 = toPop
		toPop--
		if !(v8 > 0) {
			break
		}
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v10 = envPtr2 + 152
		v9 = *(*uintptr)(unsafe.Pointer(v10))
		*(*uintptr)(unsafe.Pointer(v10))++
		*(*uint8)(unsafe.Pointer(v9)) = libc.Uint8FromInt32(int32(INST_POP))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_POP)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v11 = delta1
			v12 = envPtr2
			if v11 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v12)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v12)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v12)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v12)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v12 + 64)) += int64(v11)
		}
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FcurrStackDepth = libc.Int64FromUint64(savedStackDepth)
}

/*
 * ---------------------------------------------------------------------
 *
 * StartExpanding --
 *
 *	Pushes an INST_EXPAND_START and does some additional housekeeping so
 *	that the [break] and [continue] compilers can use an exception-free
 *	issue to discard it.
 *
 * ---------------------------------------------------------------------
 */

func _StartExpanding(tls *libc.TLS, envPtr2 uintptr) {
	var auxPtr, rangePtr, v1, v2, v4 uintptr
	var delta1, i1, v3 int32
	_, _, _, _, _, _, _, _ = auxPtr, delta1, i1, rangePtr, v1, v2, v3, v4
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v2 = envPtr2 + 152
	v1 = *(*uintptr)(unsafe.Pointer(v2))
	*(*uintptr)(unsafe.Pointer(v2))++
	*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32(INST_EXPAND_START))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_EXPAND_START)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v3 = delta1
		v4 = envPtr2
		if v3 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v4)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v4)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v4)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v4)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v4 + 64)) += int64(v3)
	}
	/*
	 * Update inner exception ranges with information about the environment
	 * where this expansion started.
	 */
	i1 = 0
	for {
		if !(i1 < int32((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayNext)) {
			break
		}
		rangePtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayPtr + uintptr(i1)*56
		auxPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptAuxArrayPtr + uintptr(i1)*80
		/*
		 * Ignore loops unless they're still being built.
		 */
		if int64(int32((*TExceptionRange)(unsafe.Pointer(rangePtr)).FcodeOffset)) > int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart) {
			goto _5
		}
		if (*TExceptionRange)(unsafe.Pointer(rangePtr)).FnumCodeBytes != int64(-libc.Int32FromInt32(1)) {
			goto _5
		}
		/*
		 * Adequate condition: loops further out and exceptions further in
		 * don't actually need this information.
		 */
		if (*TExceptionAux)(unsafe.Pointer(auxPtr)).FexpandTarget == (*TCompileEnv)(unsafe.Pointer(envPtr2)).FexpandCount {
			(*TExceptionAux)(unsafe.Pointer(auxPtr)).FexpandTargetDepth = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcurrStackDepth
		}
		goto _5
	_5:
		;
		i1++
	}
	/*
	 * One more expansion is now being processed on the auxiliary stack.
	 */
	(*TCompileEnv)(unsafe.Pointer(envPtr2)).FexpandCount++
}

/*
 * ---------------------------------------------------------------------
 *
 * TclFinalizeLoopExceptionRange --
 *
 *	Finalizes a loop exception range, binding the registered [break] and
 *	[continue] implementations so that they jump to the correct place.
 *	This must be called only after *all* the exception range
 *	target offsets have been set.
 *
 * ---------------------------------------------------------------------
 */

func XTclFinalizeLoopExceptionRange(tls *libc.TLS, envPtr uintptr, range1 int32) {
	var auxPtr, rangePtr, site, v4 uintptr
	var i, j, offset int32
	_, _, _, _, _, _, _ = auxPtr, i, j, offset, rangePtr, site, v4
	rangePtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayPtr + uintptr(range1)*56
	auxPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptAuxArrayPtr + uintptr(range1)*80
	if (*TExceptionRange)(unsafe.Pointer(rangePtr)).Ftype1 != int32(LOOP_EXCEPTION_RANGE) {
		XTcl_Panic(tls, __ccgo_ts+24499, 0)
	}
	/*
	 * Do the jump fixups. Note that these are always issued as INST_JUMP4 so
	 * there is no need to fuss around with updating code offsets.
	 */
	i = 0
	for {
		if !(i < int32((*TExceptionAux)(unsafe.Pointer(auxPtr)).FnumBreakTargets)) {
			break
		}
		site = (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr(*(*Tsize_t)(unsafe.Pointer((*TExceptionAux)(unsafe.Pointer(auxPtr)).FbreakTargets + uintptr(i)*8)))
		offset = libc.Int32FromUint64(libc.Uint64FromInt64((*TExceptionRange)(unsafe.Pointer(rangePtr)).FbreakOffset) - *(*Tsize_t)(unsafe.Pointer((*TExceptionAux)(unsafe.Pointer(auxPtr)).FbreakTargets + uintptr(i)*8)))
		*(*uint8)(unsafe.Pointer(site)) = libc.Uint8FromInt32(int32(INST_JUMP4))
		*(*uint8)(unsafe.Pointer(site + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(offset) >> libc.Int32FromInt32(24))
		*(*uint8)(unsafe.Pointer(site + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(offset) >> libc.Int32FromInt32(16))
		*(*uint8)(unsafe.Pointer(site + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt32(offset) >> libc.Int32FromInt32(8))
		*(*uint8)(unsafe.Pointer(site + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt32(offset))
		goto _1
	_1:
		;
		i++
	}
	i = 0
	for {
		if !(i < int32((*TExceptionAux)(unsafe.Pointer(auxPtr)).FnumContinueTargets)) {
			break
		}
		site = (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr(*(*Tsize_t)(unsafe.Pointer((*TExceptionAux)(unsafe.Pointer(auxPtr)).FcontinueTargets + uintptr(i)*8)))
		if (*TExceptionRange)(unsafe.Pointer(rangePtr)).FcontinueOffset == int64(-libc.Int32FromInt32(1)) {
			/*
			 * WTF? Can't bind, so revert to an INST_CONTINUE. Not enough
			 * space to do anything else.
			 */
			*(*uint8)(unsafe.Pointer(site)) = uint8(INST_CONTINUE)
			j = 0
			for {
				if !(j < int32(4)) {
					break
				}
				site++
				v4 = site
				*(*uint8)(unsafe.Pointer(v4)) = uint8(INST_NOP)
				goto _3
			_3:
				;
				j++
			}
		} else {
			offset = libc.Int32FromUint64(libc.Uint64FromInt64((*TExceptionRange)(unsafe.Pointer(rangePtr)).FcontinueOffset) - *(*Tsize_t)(unsafe.Pointer((*TExceptionAux)(unsafe.Pointer(auxPtr)).FcontinueTargets + uintptr(i)*8)))
			*(*uint8)(unsafe.Pointer(site)) = libc.Uint8FromInt32(int32(INST_JUMP4))
			*(*uint8)(unsafe.Pointer(site + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(offset) >> libc.Int32FromInt32(24))
			*(*uint8)(unsafe.Pointer(site + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(offset) >> libc.Int32FromInt32(16))
			*(*uint8)(unsafe.Pointer(site + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt32(offset) >> libc.Int32FromInt32(8))
			*(*uint8)(unsafe.Pointer(site + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt32(offset))
		}
		goto _2
	_2:
		;
		i++
	}
	/*
	 * Drop the arrays we were holding the only reference to.
	 */
	if (*TExceptionAux)(unsafe.Pointer(auxPtr)).FbreakTargets != 0 {
		XTclpFree(tls, (*TExceptionAux)(unsafe.Pointer(auxPtr)).FbreakTargets)
		(*TExceptionAux)(unsafe.Pointer(auxPtr)).FbreakTargets = libc.UintptrFromInt32(0)
		(*TExceptionAux)(unsafe.Pointer(auxPtr)).FnumBreakTargets = 0
	}
	if (*TExceptionAux)(unsafe.Pointer(auxPtr)).FcontinueTargets != 0 {
		XTclpFree(tls, (*TExceptionAux)(unsafe.Pointer(auxPtr)).FcontinueTargets)
		(*TExceptionAux)(unsafe.Pointer(auxPtr)).FcontinueTargets = libc.UintptrFromInt32(0)
		(*TExceptionAux)(unsafe.Pointer(auxPtr)).FnumContinueTargets = 0
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclCreateAuxData --
 *
 *	Allocates and initializes a new AuxData structure in a
 *	CompileEnv's array of compilation auxiliary data records. These
 *	AuxData records hold information created during compilation by
 *	CompileProcs and used by instructions during execution.
 *
 * Results:
 *	The index of the newly-created AuxData structure in the array.
 *
 * Side effects:
 *	If there is not enough room in the CompileEnv's AuxData array, its size
 *	is doubled.
 *----------------------------------------------------------------------
 */

func XTclCreateAuxData(tls *libc.TLS, clientData uintptr, typePtr uintptr, envPtr uintptr) (r TTcl_Size) {
	/* Points to the CompileEnv for which a new
	 * aux data structure is to be allocated. */
	var auxDataPtr, newPtr uintptr
	var currBytes, newBytes, newElems Tsize_t
	var index TTcl_Size
	_, _, _, _, _, _ = auxDataPtr, currBytes, index, newBytes, newElems, newPtr
	/* Points to the new AuxData structure */
	index = (*TCompileEnv)(unsafe.Pointer(envPtr)).FauxDataArrayNext
	if index >= (*TCompileEnv)(unsafe.Pointer(envPtr)).FauxDataArrayEnd {
		/*
		 * Expand the AuxData array. The currently allocated entries are
		 * stored between elements 0 and (envPtr->auxDataArrayNext - 1)
		 * [inclusive].
		 */
		currBytes = libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr)).FauxDataArrayNext) * uint64(16)
		newElems = libc.Uint64FromInt64(int64(2) * (*TCompileEnv)(unsafe.Pointer(envPtr)).FauxDataArrayEnd)
		newBytes = newElems * uint64(16)
		if (*TCompileEnv)(unsafe.Pointer(envPtr)).FmallocedAuxDataArray != 0 {
			(*TCompileEnv)(unsafe.Pointer(envPtr)).FauxDataArrayPtr = XTcl_Realloc(tls, (*TCompileEnv)(unsafe.Pointer(envPtr)).FauxDataArrayPtr, newBytes)
		} else {
			/*
			 * envPtr->auxDataArrayPtr isn't a Tcl_Alloc'd pointer, so we must
			 * code a Tcl_Realloc equivalent for ourselves.
			 */
			newPtr = XTcl_Alloc(tls, newBytes)
			libc.Xmemcpy(tls, newPtr, (*TCompileEnv)(unsafe.Pointer(envPtr)).FauxDataArrayPtr, currBytes)
			(*TCompileEnv)(unsafe.Pointer(envPtr)).FauxDataArrayPtr = newPtr
			(*TCompileEnv)(unsafe.Pointer(envPtr)).FmallocedAuxDataArray = int32(1)
		}
		(*TCompileEnv)(unsafe.Pointer(envPtr)).FauxDataArrayEnd = libc.Int64FromUint64(newElems)
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FauxDataArrayNext++
	auxDataPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FauxDataArrayPtr + uintptr(index)*16
	(*TAuxData)(unsafe.Pointer(auxDataPtr)).FclientData = clientData
	(*TAuxData)(unsafe.Pointer(auxDataPtr)).Ftype1 = typePtr
	return index
}

/*
 *----------------------------------------------------------------------
 *
 * TclInitJumpFixupArray --
 *
 *	Initializes a JumpFixupArray structure to hold some number of jump
 *	fixup entries.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The JumpFixupArray structure is initialized.
 *
 *----------------------------------------------------------------------
 */

func XTclInitJumpFixupArray(tls *libc.TLS, fixupArrayPtr uintptr) {
	/* Points to the JumpFixupArray structure to
	 * initialize. */
	(*TJumpFixupArray)(unsafe.Pointer(fixupArrayPtr)).Ffixup = fixupArrayPtr + 28
	(*TJumpFixupArray)(unsafe.Pointer(fixupArrayPtr)).Fnext = 0
	(*TJumpFixupArray)(unsafe.Pointer(fixupArrayPtr)).Fend = int64(libc.Int32FromInt32(JUMPFIXUP_INIT_ENTRIES) - libc.Int32FromInt32(1))
	(*TJumpFixupArray)(unsafe.Pointer(fixupArrayPtr)).FmallocedArray = 0
}

/*
 *----------------------------------------------------------------------
 *
 * TclExpandJumpFixupArray --
 *
 *	Uses malloc to allocate more storage for a jump fixup array.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The jump fixup array in *fixupArrayPtr is reallocated to a new array
 *	of double the size, and if fixupArrayPtr->mallocedArray is non-zero
 *	the old array is freed. Jump fixup structures are copied from the old
 *	array to the new one.
 *
 *----------------------------------------------------------------------
 */

func XTclExpandJumpFixupArray(tls *libc.TLS, fixupArrayPtr uintptr) {
	/* Points to the JumpFixupArray structure to
	 * enlarge. */
	var currBytes, newBytes, newElems Tsize_t
	var newPtr uintptr
	_, _, _, _ = currBytes, newBytes, newElems, newPtr
	/*
	 * The currently allocated jump fixup entries are stored from fixup[0] up
	 * to fixup[fixupArrayPtr->fixupNext] (*not* inclusive). We assume
	 * fixupArrayPtr->fixupNext is equal to fixupArrayPtr->fixupEnd.
	 */
	currBytes = libc.Uint64FromInt64((*TJumpFixupArray)(unsafe.Pointer(fixupArrayPtr)).Fnext) * uint64(16)
	newElems = libc.Uint64FromInt64(int64(2) * ((*TJumpFixupArray)(unsafe.Pointer(fixupArrayPtr)).Fend + int64(1)))
	newBytes = newElems * uint64(16)
	if (*TJumpFixupArray)(unsafe.Pointer(fixupArrayPtr)).FmallocedArray != 0 {
		(*TJumpFixupArray)(unsafe.Pointer(fixupArrayPtr)).Ffixup = XTcl_Realloc(tls, (*TJumpFixupArray)(unsafe.Pointer(fixupArrayPtr)).Ffixup, newBytes)
	} else {
		/*
		 * fixupArrayPtr->fixup isn't a Tcl_Alloc'd pointer, so we must code a
		 * Tcl_Realloc equivalent for ourselves.
		 */
		newPtr = XTcl_Alloc(tls, newBytes)
		libc.Xmemcpy(tls, newPtr, (*TJumpFixupArray)(unsafe.Pointer(fixupArrayPtr)).Ffixup, currBytes)
		(*TJumpFixupArray)(unsafe.Pointer(fixupArrayPtr)).Ffixup = newPtr
		(*TJumpFixupArray)(unsafe.Pointer(fixupArrayPtr)).FmallocedArray = int32(1)
	}
	(*TJumpFixupArray)(unsafe.Pointer(fixupArrayPtr)).Fend = libc.Int64FromUint64(newElems)
}

/*
 *----------------------------------------------------------------------
 *
 * TclFreeJumpFixupArray --
 *
 *	Free any storage allocated in a jump fixup array structure.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Allocated storage in the JumpFixupArray structure is freed.
 *
 *----------------------------------------------------------------------
 */

func XTclFreeJumpFixupArray(tls *libc.TLS, fixupArrayPtr uintptr) {
	/* Points to the JumpFixupArray structure to
	 * free. */
	if (*TJumpFixupArray)(unsafe.Pointer(fixupArrayPtr)).FmallocedArray != 0 {
		XTclpFree(tls, (*TJumpFixupArray)(unsafe.Pointer(fixupArrayPtr)).Ffixup)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclEmitForwardJump --
 *
 *	Emits a two-byte forward jump of kind "jumpType".  Also initializes a
 *	JumpFixup record with information about the jump.  Since may later be
 *	necessary to increase the size of the jump instruction to five bytes if
 *	the jump target is more than, say, 127 bytes away.
 *
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The JumpFixup record pointed to by "jumpFixupPtr" is initialized with
 *	information needed later if the jump is to be grown. Also, a two byte
 *	jump of the designated type is emitted at the current point in the
 *	bytecode stream.
 *
 *----------------------------------------------------------------------
 */

func XTclEmitForwardJump(tls *libc.TLS, envPtr2 uintptr, jumpType TTclJumpType, jumpFixupPtr uintptr) {
	/* Points to the JumpFixup structure to
	 * initialize with information about this
	 * forward jump. */
	var delta1, v12, v18, v24 int32
	var v10, v11, v13, v14, v15, v16, v17, v19, v20, v21, v22, v23, v25, v8, v9 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = delta1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v8, v9
	/*
	 * Initialize the JumpFixup structure:
	 *    - codeOffset is offset of first byte of jump below
	 *    - cmdIndex is index of the command after the current one
	 *    - exceptIndex is the index of the first ExceptionRange after the
	 *	    current one.
	 */
	(*TJumpFixup)(unsafe.Pointer(jumpFixupPtr)).FjumpType = jumpType
	(*TJumpFixup)(unsafe.Pointer(jumpFixupPtr)).FcodeOffset = libc.Uint32FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeStart))
	(*TJumpFixup)(unsafe.Pointer(jumpFixupPtr)).FcmdIndex = int32((*TCompileEnv)(unsafe.Pointer(envPtr2)).FnumCommands)
	(*TJumpFixup)(unsafe.Pointer(jumpFixupPtr)).FexceptIndex = int32((*TCompileEnv)(unsafe.Pointer(envPtr2)).FexceptArrayNext)
	switch jumpType {
	case int32(TCL_UNCONDITIONAL_JUMP):
		goto _1
	case int32(TCL_TRUE_JUMP):
		goto _2
	default:
		goto _3
	}
	goto _4
_1:
	;
_7:
	;
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v9 = envPtr2 + 152
	v8 = *(*uintptr)(unsafe.Pointer(v9))
	*(*uintptr)(unsafe.Pointer(v9))++
	*(*uint8)(unsafe.Pointer(v8)) = libc.Uint8FromInt32(int32(INST_JUMP1))
	v11 = envPtr2 + 152
	v10 = *(*uintptr)(unsafe.Pointer(v11))
	*(*uintptr)(unsafe.Pointer(v11))++
	*(*uint8)(unsafe.Pointer(v10)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_JUMP1)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v12 = delta1
		v13 = envPtr2
		if v12 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v13)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v13)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v13)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v13)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v13 + 64)) += int64(v12)
	}
	goto _6
_6:
	;
	if 0 != 0 {
		goto _7
	}
	goto _5
_5:
	;
	goto _4
_2:
	;
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v15 = envPtr2 + 152
	v14 = *(*uintptr)(unsafe.Pointer(v15))
	*(*uintptr)(unsafe.Pointer(v15))++
	*(*uint8)(unsafe.Pointer(v14)) = libc.Uint8FromInt32(int32(INST_JUMP_TRUE1))
	v17 = envPtr2 + 152
	v16 = *(*uintptr)(unsafe.Pointer(v17))
	*(*uintptr)(unsafe.Pointer(v17))++
	*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_JUMP_TRUE1)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v18 = delta1
		v19 = envPtr2
		if v18 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v19)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v19)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v19 + 64)) += int64(v18)
	}
	goto _4
_3:
	;
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr2)
	}
	v21 = envPtr2 + 152
	v20 = *(*uintptr)(unsafe.Pointer(v21))
	*(*uintptr)(unsafe.Pointer(v21))++
	*(*uint8)(unsafe.Pointer(v20)) = libc.Uint8FromInt32(int32(INST_JUMP_FALSE1))
	v23 = envPtr2 + 152
	v22 = *(*uintptr)(unsafe.Pointer(v23))
	*(*uintptr)(unsafe.Pointer(v23))++
	*(*uint8)(unsafe.Pointer(v22)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0)))
	if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_JUMP_FALSE1)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v24 = delta1
		v25 = envPtr2
		if v24 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v25 + 64)) += int64(v24)
	}
	goto _4
_4:
}

/*
 *----------------------------------------------------------------------
 *
 * TclFixupForwardJump --
 *
 *	Modifies a previously-emitted forward jump to jump a specified number
 *	of bytes, "jumpDist". If necessary, the size of the jump instruction is
 *	increased from two to five bytes.  This is done if the jump distance is
 *	greater than "distThreshold" (normally 127 bytes). The jump is
 *	described by a JumpFixup record previously initialized by
 *	TclEmitForwardJump.
 *
 * Results:
 *	1 if the jump was grown and subsequent instructions had to be moved, or
 *	0 otherwsie. This allows callers to update any additional code offsets
 *	they may hold.
 *
 * Side effects:
 *	The jump may be grown and subsequent instructions moved. If this
 *	happens, the code offsets for any commands and any ExceptionRange
 *	records between the jump and the current code address will be updated
 *	to reflect the moved code. Also, the bytecode instruction array in the
 *	CompileEnv structure may be grown and reallocated.
 *
 *----------------------------------------------------------------------
 */

func XTclFixupForwardJump(tls *libc.TLS, envPtr uintptr, jumpFixupPtr uintptr, jumpDist int32, distThreshold int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Maximum distance before the two byte jump
	 * is grown to five bytes. */
	var auxPtr, jumpPc, p, rangePtr uintptr
	var firstCmd, firstRange, i, k, lastCmd, lastRange int32
	var numBytes Tsize_t
	_, _, _, _, _, _, _, _, _, _, _ = auxPtr, firstCmd, firstRange, i, jumpPc, k, lastCmd, lastRange, numBytes, p, rangePtr
	if jumpDist <= distThreshold {
		jumpPc = (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr((*TJumpFixup)(unsafe.Pointer(jumpFixupPtr)).FcodeOffset)
		switch (*TJumpFixup)(unsafe.Pointer(jumpFixupPtr)).FjumpType {
		case int32(TCL_UNCONDITIONAL_JUMP):
			goto _1
		case int32(TCL_TRUE_JUMP):
			goto _2
		default:
			goto _3
		}
		goto _4
	_1:
		;
	_7:
		;
		*(*uint8)(unsafe.Pointer(jumpPc)) = libc.Uint8FromInt32(int32(INST_JUMP1))
		*(*uint8)(unsafe.Pointer(jumpPc + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(jumpDist))
		goto _6
	_6:
		;
		if 0 != 0 {
			goto _7
		}
		goto _5
	_5:
		;
		goto _4
	_2:
		;
		*(*uint8)(unsafe.Pointer(jumpPc)) = libc.Uint8FromInt32(int32(INST_JUMP_TRUE1))
		*(*uint8)(unsafe.Pointer(jumpPc + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(jumpDist))
		goto _4
	_3:
		;
		*(*uint8)(unsafe.Pointer(jumpPc)) = libc.Uint8FromInt32(int32(INST_JUMP_FALSE1))
		*(*uint8)(unsafe.Pointer(jumpPc + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(jumpDist))
		goto _4
	_4:
		;
		return 0
	}
	/*
	 * Increase the size of the jump instruction, and then move subsequent
	 * instructions down.  Expanding the space for generated instructions means
	 * that code addresses might change.  Be careful about updating any of
	 * these addresses held in variables.
	 */
	if (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext+uintptr(3) > (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr)
	}
	jumpPc = (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr((*TJumpFixup)(unsafe.Pointer(jumpFixupPtr)).FcodeOffset)
	numBytes = libc.Uint64FromInt64(int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext) - int64(jumpPc) - int64(2))
	p = jumpPc + uintptr(2)
	libc.Xmemmove(tls, p+uintptr(3), p, numBytes)
	*(*uintptr)(unsafe.Pointer(envPtr + 152)) += uintptr(3)
	jumpDist += int32(3)
	switch (*TJumpFixup)(unsafe.Pointer(jumpFixupPtr)).FjumpType {
	case int32(TCL_UNCONDITIONAL_JUMP):
		goto _8
	case int32(TCL_TRUE_JUMP):
		goto _9
	default:
		goto _10
	}
	goto _11
_8:
	;
_14:
	;
	*(*uint8)(unsafe.Pointer(jumpPc)) = libc.Uint8FromInt32(int32(INST_JUMP4))
	*(*uint8)(unsafe.Pointer(jumpPc + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(jumpDist) >> libc.Int32FromInt32(24))
	*(*uint8)(unsafe.Pointer(jumpPc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(jumpDist) >> libc.Int32FromInt32(16))
	*(*uint8)(unsafe.Pointer(jumpPc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt32(jumpDist) >> libc.Int32FromInt32(8))
	*(*uint8)(unsafe.Pointer(jumpPc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt32(jumpDist))
	goto _13
_13:
	;
	if 0 != 0 {
		goto _14
	}
	goto _12
_12:
	;
	goto _11
_9:
	;
	*(*uint8)(unsafe.Pointer(jumpPc)) = libc.Uint8FromInt32(int32(INST_JUMP_TRUE4))
	*(*uint8)(unsafe.Pointer(jumpPc + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(jumpDist) >> libc.Int32FromInt32(24))
	*(*uint8)(unsafe.Pointer(jumpPc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(jumpDist) >> libc.Int32FromInt32(16))
	*(*uint8)(unsafe.Pointer(jumpPc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt32(jumpDist) >> libc.Int32FromInt32(8))
	*(*uint8)(unsafe.Pointer(jumpPc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt32(jumpDist))
	goto _11
_10:
	;
	*(*uint8)(unsafe.Pointer(jumpPc)) = libc.Uint8FromInt32(int32(INST_JUMP_FALSE4))
	*(*uint8)(unsafe.Pointer(jumpPc + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(jumpDist) >> libc.Int32FromInt32(24))
	*(*uint8)(unsafe.Pointer(jumpPc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(jumpDist) >> libc.Int32FromInt32(16))
	*(*uint8)(unsafe.Pointer(jumpPc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt32(jumpDist) >> libc.Int32FromInt32(8))
	*(*uint8)(unsafe.Pointer(jumpPc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt32(jumpDist))
	goto _11
_11:
	;
	/*
	 * Adjust the code offsets for any commands and any ExceptionRange records
	 * between the jump and the current code address.
	 */
	firstCmd = (*TJumpFixup)(unsafe.Pointer(jumpFixupPtr)).FcmdIndex
	lastCmd = int32((*TCompileEnv)(unsafe.Pointer(envPtr)).FnumCommands - int64(1))
	if firstCmd < lastCmd {
		k = firstCmd
		for {
			if !(k <= lastCmd) {
				break
			}
			(*(*TCmdLocation)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FcmdMapPtr + uintptr(k)*32))).FcodeOffset += int64(3)
			goto _15
		_15:
			;
			k++
		}
	}
	firstRange = (*TJumpFixup)(unsafe.Pointer(jumpFixupPtr)).FexceptIndex
	lastRange = int32((*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayNext - int64(1))
	k = firstRange
	for {
		if !(k <= lastRange) {
			break
		}
		rangePtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayPtr + uintptr(k)*56
		*(*TTcl_Size)(unsafe.Pointer(rangePtr + 16)) += int64(3)
		switch (*TExceptionRange)(unsafe.Pointer(rangePtr)).Ftype1 {
		case int32(LOOP_EXCEPTION_RANGE):
			*(*TTcl_Size)(unsafe.Pointer(rangePtr + 32)) += int64(3)
			if (*TExceptionRange)(unsafe.Pointer(rangePtr)).FcontinueOffset != int64(-libc.Int32FromInt32(1)) {
				*(*TTcl_Size)(unsafe.Pointer(rangePtr + 40)) += int64(3)
			}
		case int32(CATCH_EXCEPTION_RANGE):
			*(*TTcl_Size)(unsafe.Pointer(rangePtr + 48)) += int64(3)
		default:
			XTcl_Panic(tls, __ccgo_ts+24541, libc.VaList(bp+8, (*TExceptionRange)(unsafe.Pointer(rangePtr)).Ftype1))
		}
		goto _16
	_16:
		;
		k++
	}
	k = 0
	for {
		if !(k < int32((*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayNext)) {
			break
		}
		auxPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptAuxArrayPtr + uintptr(k)*80
		i = 0
		for {
			if !(i < int32((*TExceptionAux)(unsafe.Pointer(auxPtr)).FnumBreakTargets)) {
				break
			}
			if uint64((*TJumpFixup)(unsafe.Pointer(jumpFixupPtr)).FcodeOffset) < *(*Tsize_t)(unsafe.Pointer((*TExceptionAux)(unsafe.Pointer(auxPtr)).FbreakTargets + uintptr(i)*8)) {
				*(*Tsize_t)(unsafe.Pointer((*TExceptionAux)(unsafe.Pointer(auxPtr)).FbreakTargets + uintptr(i)*8)) += uint64(3)
			}
			goto _18
		_18:
			;
			i++
		}
		i = 0
		for {
			if !(i < int32((*TExceptionAux)(unsafe.Pointer(auxPtr)).FnumContinueTargets)) {
				break
			}
			if uint64((*TJumpFixup)(unsafe.Pointer(jumpFixupPtr)).FcodeOffset) < *(*Tsize_t)(unsafe.Pointer((*TExceptionAux)(unsafe.Pointer(auxPtr)).FcontinueTargets + uintptr(i)*8)) {
				*(*Tsize_t)(unsafe.Pointer((*TExceptionAux)(unsafe.Pointer(auxPtr)).FcontinueTargets + uintptr(i)*8)) += uint64(3)
			}
			goto _19
		_19:
			;
			i++
		}
		goto _17
	_17:
		;
		k++
	}
	return int32(1) /* the jump was grown */
}

/*
 *----------------------------------------------------------------------
 *
 * TclEmitInvoke --
 *
 *	Emits one of the invoke-related instructions, wrapping it if necessary
 *	in code that ensures that any break or continue operation passing
 *	through it gets the stack unwinding correct, converting it into an
 *	internal jump if in an appropriate context.
 *
 * Results:
 *	None
 *
 * Side effects:
 *	Issues the jump with all correct stack management. May create another
 *	loop exception range.  Pointers to ExceptionRange and ExceptionAux
 *	structures should not be held across this call.
 *
 *----------------------------------------------------------------------
 */

func XTclEmitInvoke(tls *libc.TLS, envPtr3 uintptr, opcode int32, va uintptr) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var arg1, arg2, breakRange, cleanup, continueRange, delta1, depth1, expandCount, loopRange, wordCount, v1, v10, v2, v26, v3, v38, v4, v42, v44, v48, v5, v52, v6, v64, v68, v7, v70, v72, v74, v76, v8, v9 int32
	var argList Tva_list
	var rangePtr, v22, v23, v24, v25, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v39, v40, v41, v43, v45, v46, v47, v49, v50, v51, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63, v65, v66, v67, v69, v71, v73, v75, v77, v79 uintptr
	var savedExpandCount, savedStackDepth, v78 Tsize_t
	var v11 int64
	var _ /* auxBreakPtr at bp+0 */ uintptr
	var _ /* auxContinuePtr at bp+8 */ uintptr
	var _ /* nonTrapFixup at bp+16 */ TJumpFixup
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = arg1, arg2, argList, breakRange, cleanup, continueRange, delta1, depth1, expandCount, loopRange, rangePtr, savedExpandCount, savedStackDepth, wordCount, v1, v10, v11, v2, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v9
	wordCount = 0
	expandCount = 0
	loopRange = 0
	breakRange = 0
	continueRange = 0
	depth1 = int32((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcurrStackDepth)
	/*
	 * Parse the arguments.
	 */
	argList = va
	switch opcode {
	case int32(INST_INVOKE_STK1):
		v2 = libc.VaInt32(&argList)
		cleanup = v2
		v1 = v2
		arg1 = v1
		wordCount = v1
		arg2 = 0
	case int32(INST_INVOKE_STK4):
		v4 = libc.VaInt32(&argList)
		cleanup = v4
		v3 = v4
		arg1 = v3
		wordCount = v3
		arg2 = 0
	case int32(INST_INVOKE_REPLACE):
		arg1 = libc.VaInt32(&argList)
		arg2 = libc.VaInt32(&argList)
		wordCount = arg1 + arg2 - int32(1)
		cleanup = arg1 + int32(1)
	default:
		XTcl_Panic(tls, __ccgo_ts+24589, 0)
		fallthrough
	case int32(INST_EVAL_STK):
		v5 = libc.Int32FromInt32(1)
		cleanup = v5
		wordCount = v5
		v6 = libc.Int32FromInt32(0)
		arg2 = v6
		arg1 = v6
	case int32(INST_RETURN_STK):
		v7 = libc.Int32FromInt32(2)
		cleanup = v7
		wordCount = v7
		v8 = libc.Int32FromInt32(0)
		arg2 = v8
		arg1 = v8
	case int32(INST_INVOKE_EXPANDED):
		v10 = libc.VaInt32(&argList)
		cleanup = v10
		v9 = v10
		arg1 = v9
		wordCount = v9
		arg2 = 0
		expandCount = int32(1)
		break
	}
	_ = argList
	/*
	 * If the exceptions is for break or continue handle it with special
	 * handling exception range so the stack may be correctly unwound.
	 *
	 * These must be done separately since they can be different, especially
	 * for calls from inside a [for] increment clause.
	 */
	rangePtr = XTclGetInnermostExceptionRange(tls, envPtr3, int32(TCL_CONTINUE), bp+8)
	if rangePtr == libc.UintptrFromInt32(0) || (*TExceptionRange)(unsafe.Pointer(rangePtr)).Ftype1 != int32(LOOP_EXCEPTION_RANGE) {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = libc.UintptrFromInt32(0)
	} else {
		if (*TExceptionAux)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FstackDepth == (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcurrStackDepth-int64(wordCount) && (*TExceptionAux)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FexpandTarget+int64(expandCount) == (*TCompileEnv)(unsafe.Pointer(envPtr3)).FexpandCount {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = libc.UintptrFromInt32(0)
		} else {
			continueRange = int32((int64(*(*uintptr)(unsafe.Pointer(bp + 8))) - int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FexceptAuxArrayPtr)) / 80)
		}
	}
	rangePtr = XTclGetInnermostExceptionRange(tls, envPtr3, int32(TCL_BREAK), bp)
	if rangePtr == libc.UintptrFromInt32(0) || (*TExceptionRange)(unsafe.Pointer(rangePtr)).Ftype1 != int32(LOOP_EXCEPTION_RANGE) {
		*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	} else {
		if *(*uintptr)(unsafe.Pointer(bp + 8)) == libc.UintptrFromInt32(0) && (*TExceptionAux)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FstackDepth+int64(wordCount) == (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcurrStackDepth && (*TExceptionAux)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FexpandTarget+int64(expandCount) == (*TCompileEnv)(unsafe.Pointer(envPtr3)).FexpandCount {
			*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
		} else {
			breakRange = int32((int64(*(*uintptr)(unsafe.Pointer(bp))) - int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FexceptAuxArrayPtr)) / 80)
		}
	}
	if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) || *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) {
		loopRange = int32(XTclCreateExceptRange(tls, int32(LOOP_EXCEPTION_RANGE), envPtr3))
		(*TCompileEnv)(unsafe.Pointer(envPtr3)).FexceptDepth++
		if libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FexceptDepth)+uint64(1) > libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FmaxExceptDepth)+uint64(1) {
			v11 = (*TCompileEnv)(unsafe.Pointer(envPtr3)).FexceptDepth
		} else {
			v11 = (*TCompileEnv)(unsafe.Pointer(envPtr3)).FmaxExceptDepth
		}
		(*TCompileEnv)(unsafe.Pointer(envPtr3)).FmaxExceptDepth = v11
		(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr3)).FexceptArrayPtr + uintptr(loopRange)*56))).FcodeOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeStart)
	}
	/*
	 * Issue the invoke itself.
	 */
	switch opcode {
	case int32(INST_INVOKE_STK1):
		goto _12
	case int32(INST_INVOKE_STK4):
		goto _13
	case int32(INST_INVOKE_EXPANDED):
		goto _14
	case int32(INST_EVAL_STK):
		goto _15
	case int32(INST_RETURN_STK):
		goto _16
	case int32(INST_INVOKE_REPLACE):
		goto _17
	}
	goto _18
_12:
	;
_21:
	;
	if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr3)
	}
	v23 = envPtr3 + 152
	v22 = *(*uintptr)(unsafe.Pointer(v23))
	*(*uintptr)(unsafe.Pointer(v23))++
	*(*uint8)(unsafe.Pointer(v22)) = libc.Uint8FromInt32(int32(INST_INVOKE_STK1))
	v25 = envPtr3 + 152
	v24 = *(*uintptr)(unsafe.Pointer(v25))
	*(*uintptr)(unsafe.Pointer(v25))++
	*(*uint8)(unsafe.Pointer(v24)) = uint8(libc.Uint32FromInt32(arg1))
	if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_INVOKE_STK1)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - arg1
		}
		v26 = delta1
		v27 = envPtr3
		if v26 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v27)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v27)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v27)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v27)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v27 + 64)) += int64(v26)
	}
	goto _20
_20:
	;
	if 0 != 0 {
		goto _21
	}
	goto _19
_19:
	;
	goto _18
_13:
	;
	if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr3)
	}
	v29 = envPtr3 + 152
	v28 = *(*uintptr)(unsafe.Pointer(v29))
	*(*uintptr)(unsafe.Pointer(v29))++
	*(*uint8)(unsafe.Pointer(v28)) = libc.Uint8FromInt32(int32(INST_INVOKE_STK4))
	v31 = envPtr3 + 152
	v30 = *(*uintptr)(unsafe.Pointer(v31))
	*(*uintptr)(unsafe.Pointer(v31))++
	*(*uint8)(unsafe.Pointer(v30)) = uint8(libc.Uint32FromInt32(arg1) >> libc.Int32FromInt32(24))
	v33 = envPtr3 + 152
	v32 = *(*uintptr)(unsafe.Pointer(v33))
	*(*uintptr)(unsafe.Pointer(v33))++
	*(*uint8)(unsafe.Pointer(v32)) = uint8(libc.Uint32FromInt32(arg1) >> libc.Int32FromInt32(16))
	v35 = envPtr3 + 152
	v34 = *(*uintptr)(unsafe.Pointer(v35))
	*(*uintptr)(unsafe.Pointer(v35))++
	*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt32(arg1) >> libc.Int32FromInt32(8))
	v37 = envPtr3 + 152
	v36 = *(*uintptr)(unsafe.Pointer(v37))
	*(*uintptr)(unsafe.Pointer(v37))++
	*(*uint8)(unsafe.Pointer(v36)) = uint8(libc.Uint32FromInt32(arg1))
	if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_INVOKE_STK4)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - arg1
		}
		v38 = delta1
		v39 = envPtr3
		if v38 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v39)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v39)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v39)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v39)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v39 + 64)) += int64(v38)
	}
	goto _18
_14:
	;
	if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr3)
	}
	v41 = envPtr3 + 152
	v40 = *(*uintptr)(unsafe.Pointer(v41))
	*(*uintptr)(unsafe.Pointer(v41))++
	*(*uint8)(unsafe.Pointer(v40)) = libc.Uint8FromInt32(int32(INST_INVOKE_EXPANDED))
	if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_INVOKE_EXPANDED)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v42 = delta1
		v43 = envPtr3
		if v42 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v43)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v43)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v43)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v43)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v43 + 64)) += int64(v42)
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr3)).FexpandCount--
	v44 = int32(1) - arg1
	v45 = envPtr3
	if v44 < libc.Int32FromInt32(0) {
		if int32((*TCompileEnv)(unsafe.Pointer(v45)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v45)).FcurrStackDepth) {
			(*TCompileEnv)(unsafe.Pointer(v45)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v45)).FcurrStackDepth
		}
	}
	*(*TTcl_Size)(unsafe.Pointer(v45 + 64)) += int64(v44)
	goto _18
_15:
	;
	if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr3)
	}
	v47 = envPtr3 + 152
	v46 = *(*uintptr)(unsafe.Pointer(v47))
	*(*uintptr)(unsafe.Pointer(v47))++
	*(*uint8)(unsafe.Pointer(v46)) = libc.Uint8FromInt32(int32(INST_EVAL_STK))
	if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_EVAL_STK)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v48 = delta1
		v49 = envPtr3
		if v48 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v49)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v49)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v49)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v49)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v49 + 64)) += int64(v48)
	}
	goto _18
_16:
	;
	if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr3)
	}
	v51 = envPtr3 + 152
	v50 = *(*uintptr)(unsafe.Pointer(v51))
	*(*uintptr)(unsafe.Pointer(v51))++
	*(*uint8)(unsafe.Pointer(v50)) = libc.Uint8FromInt32(int32(INST_RETURN_STK))
	if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_RETURN_STK)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - 0
		}
		v52 = delta1
		v53 = envPtr3
		if v52 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v53)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v53)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v53)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v53)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v53 + 64)) += int64(v52)
	}
	goto _18
_17:
	;
	if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr3)
	}
	v55 = envPtr3 + 152
	v54 = *(*uintptr)(unsafe.Pointer(v55))
	*(*uintptr)(unsafe.Pointer(v55))++
	*(*uint8)(unsafe.Pointer(v54)) = libc.Uint8FromInt32(int32(INST_INVOKE_REPLACE))
	v57 = envPtr3 + 152
	v56 = *(*uintptr)(unsafe.Pointer(v57))
	*(*uintptr)(unsafe.Pointer(v57))++
	*(*uint8)(unsafe.Pointer(v56)) = uint8(libc.Uint32FromInt32(arg1) >> libc.Int32FromInt32(24))
	v59 = envPtr3 + 152
	v58 = *(*uintptr)(unsafe.Pointer(v59))
	*(*uintptr)(unsafe.Pointer(v59))++
	*(*uint8)(unsafe.Pointer(v58)) = uint8(libc.Uint32FromInt32(arg1) >> libc.Int32FromInt32(16))
	v61 = envPtr3 + 152
	v60 = *(*uintptr)(unsafe.Pointer(v61))
	*(*uintptr)(unsafe.Pointer(v61))++
	*(*uint8)(unsafe.Pointer(v60)) = uint8(libc.Uint32FromInt32(arg1) >> libc.Int32FromInt32(8))
	v63 = envPtr3 + 152
	v62 = *(*uintptr)(unsafe.Pointer(v63))
	*(*uintptr)(unsafe.Pointer(v63))++
	*(*uint8)(unsafe.Pointer(v62)) = uint8(libc.Uint32FromInt32(arg1))
	if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart < int32(2) {
		(*TCompileEnv)(unsafe.Pointer(envPtr3)).FatCmdStart = 0
	}
	delta1 = XtclInstructionTable[uint8(INST_INVOKE_REPLACE)].FstackEffect
	if delta1 != 0 {
		if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
			delta1 = int32(1) - arg1
		}
		v64 = delta1
		v65 = envPtr3
		if v64 < libc.Int32FromInt32(0) {
			if int32((*TCompileEnv)(unsafe.Pointer(v65)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v65)).FcurrStackDepth) {
				(*TCompileEnv)(unsafe.Pointer(v65)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v65)).FcurrStackDepth
			}
		}
		*(*TTcl_Size)(unsafe.Pointer(v65 + 64)) += int64(v64)
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeEnd {
		XTclExpandCodeArray(tls, envPtr3)
	}
	v67 = envPtr3 + 152
	v66 = *(*uintptr)(unsafe.Pointer(v67))
	*(*uintptr)(unsafe.Pointer(v67))++
	*(*uint8)(unsafe.Pointer(v66)) = uint8(libc.Uint32FromInt32(arg2))
	v68 = -int32(1)
	v69 = envPtr3
	if v68 < libc.Int32FromInt32(0) {
		if int32((*TCompileEnv)(unsafe.Pointer(v69)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v69)).FcurrStackDepth) {
			(*TCompileEnv)(unsafe.Pointer(v69)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v69)).FcurrStackDepth
		}
	}
	*(*TTcl_Size)(unsafe.Pointer(v69 + 64)) += int64(v68) /* Correction to stack depth calcs */
	goto _18
_18:
	;
	/*
	 * If we're generating a special wrapper exception range, we need to
	 * finish that up now.
	 */
	if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) || *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) {
		savedStackDepth = libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcurrStackDepth)
		savedExpandCount = libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FexpandCount)
		if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
			*(*uintptr)(unsafe.Pointer(bp)) = (*TCompileEnv)(unsafe.Pointer(envPtr3)).FexceptAuxArrayPtr + uintptr(breakRange)*80
		}
		if *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TCompileEnv)(unsafe.Pointer(envPtr3)).FexceptAuxArrayPtr + uintptr(continueRange)*80
		}
		(*TCompileEnv)(unsafe.Pointer(envPtr3)).FexceptDepth--
		(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr3)).FexceptArrayPtr + uintptr(loopRange)*56))).FnumCodeBytes = int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeStart) - int64(int32((*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr3)).FexceptArrayPtr + uintptr(loopRange)*56))).FcodeOffset))
		XTclEmitForwardJump(tls, envPtr3, int32(TCL_UNCONDITIONAL_JUMP), bp+16)
		/*
		 * Careful! When generating these stack unwinding sequences, the depth
		 * of stack in the cases where they are taken is not the same as if
		 * the exception is not taken.
		 */
		if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
			v70 = -int32(1)
			v71 = envPtr3
			if v70 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v71)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v71)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v71)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v71)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v71 + 64)) += int64(v70)
			(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr3)).FexceptArrayPtr + uintptr(loopRange)*56))).FbreakOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeStart)
			XTclCleanupStackForBreakContinue(tls, envPtr3, *(*uintptr)(unsafe.Pointer(bp)))
			XTclAddLoopBreakFixup(tls, envPtr3, *(*uintptr)(unsafe.Pointer(bp)))
			v72 = int32(1)
			v73 = envPtr3
			if v72 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v73)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v73)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v73)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v73)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v73 + 64)) += int64(v72)
			(*TCompileEnv)(unsafe.Pointer(envPtr3)).FcurrStackDepth = libc.Int64FromUint64(savedStackDepth)
			(*TCompileEnv)(unsafe.Pointer(envPtr3)).FexpandCount = libc.Int64FromUint64(savedExpandCount)
		}
		if *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) {
			v74 = -int32(1)
			v75 = envPtr3
			if v74 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v75)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v75)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v75)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v75)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v75 + 64)) += int64(v74)
			(*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr3)).FexceptArrayPtr + uintptr(loopRange)*56))).FcontinueOffset = int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeStart)
			XTclCleanupStackForBreakContinue(tls, envPtr3, *(*uintptr)(unsafe.Pointer(bp + 8)))
			XTclAddLoopContinueFixup(tls, envPtr3, *(*uintptr)(unsafe.Pointer(bp + 8)))
			v76 = int32(1)
			v77 = envPtr3
			if v76 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v77)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v77)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v77)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v77)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v77 + 64)) += int64(v76)
			(*TCompileEnv)(unsafe.Pointer(envPtr3)).FcurrStackDepth = libc.Int64FromUint64(savedStackDepth)
			(*TCompileEnv)(unsafe.Pointer(envPtr3)).FexpandCount = libc.Int64FromUint64(savedExpandCount)
		}
		XTclFinalizeLoopExceptionRange(tls, envPtr3, loopRange)
		XTclFixupForwardJump(tls, envPtr3, bp+16, int32(int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeNext)-int64((*TCompileEnv)(unsafe.Pointer(envPtr3)).FcodeStart)-int64(libc.Int32FromUint32((*TJumpFixup)(unsafe.Pointer(bp+16)).FcodeOffset))), int32(127))
	}
	v78 = libc.Uint64FromInt32(depth1 + int32(1) - cleanup)
	v79 = envPtr3
	if v78 != libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(v79)).FcurrStackDepth) {
		XTcl_Panic(tls, __ccgo_ts+21474, libc.VaList(bp+40, libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(v79)).FcurrStackDepth), v78))
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclGetInstructionTable --
 *
 *	Returns a pointer to the table describing Tcl bytecode instructions.
 *	This procedure is defined so that clients can access the pointer from
 *	outside the TCL DLLs.
 *
 * Results:
 *	Returns a pointer to the global instruction table, same as the
 *	expression (&tclInstructionTable[0]).
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclGetInstructionTable(tls *libc.TLS) (r uintptr) {
	return uintptr(unsafe.Pointer(&XtclInstructionTable))
}

/*
 *----------------------------------------------------------------------
 *
 * GetCmdLocEncodingSize --
 *
 *	Computes the total number of bytes needed to encode the command
 *	location information for some compiled code.
 *
 * Results:
 *	The byte count needed to encode the compiled location information.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _GetCmdLocEncodingSize(tls *libc.TLS, envPtr uintptr) (r int32) {
	/* Points to compilation environment structure
	 * containing the CmdLocation structure to
	 * encode. */
	var codeDelta, codeDeltaNext, codeLen, codeLengthNext, i, numCmds, prevCodeOffset, prevSrcOffset, srcDelta, srcDeltaNext, srcLen, srcLengthNext, v1, v2, v3, v4 int32
	var mapPtr uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = codeDelta, codeDeltaNext, codeLen, codeLengthNext, i, mapPtr, numCmds, prevCodeOffset, prevSrcOffset, srcDelta, srcDeltaNext, srcLen, srcLengthNext, v1, v2, v3, v4
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FcmdMapPtr
	numCmds = int32((*TCompileEnv)(unsafe.Pointer(envPtr)).FnumCommands)
	v3 = libc.Int32FromInt32(0)
	srcLengthNext = v3
	v2 = v3
	srcDeltaNext = v2
	v1 = v2
	codeLengthNext = v1
	codeDeltaNext = v1
	v4 = libc.Int32FromInt32(0)
	prevSrcOffset = v4
	prevCodeOffset = v4
	i = 0
	for {
		if !(i < numCmds) {
			break
		}
		codeDelta = int32((*(*TCmdLocation)(unsafe.Pointer(mapPtr + uintptr(i)*32))).FcodeOffset - int64(prevCodeOffset))
		if codeDelta < 0 {
			XTcl_Panic(tls, __ccgo_ts+24607, 0)
		} else {
			if codeDelta <= int32(127) {
				codeDeltaNext++
			} else {
				codeDeltaNext += int32(5) /* 1 byte for 0xFF, 4 for positive delta */
			}
		}
		prevCodeOffset = int32((*(*TCmdLocation)(unsafe.Pointer(mapPtr + uintptr(i)*32))).FcodeOffset)
		codeLen = int32((*(*TCmdLocation)(unsafe.Pointer(mapPtr + uintptr(i)*32))).FnumCodeBytes)
		if codeLen < 0 {
			XTcl_Panic(tls, __ccgo_ts+24646, 0)
		} else {
			if codeLen <= int32(127) {
				codeLengthNext++
			} else {
				codeLengthNext += int32(5) /* 1 byte for 0xFF, 4 for length */
			}
		}
		srcDelta = int32((*(*TCmdLocation)(unsafe.Pointer(mapPtr + uintptr(i)*32))).FsrcOffset - int64(prevSrcOffset))
		if -int32(127) <= srcDelta && srcDelta <= int32(127) && srcDelta != -int32(1) {
			srcDeltaNext++
		} else {
			srcDeltaNext += int32(5) /* 1 byte for 0xFF, 4 for delta */
		}
		prevSrcOffset = int32((*(*TCmdLocation)(unsafe.Pointer(mapPtr + uintptr(i)*32))).FsrcOffset)
		srcLen = int32((*(*TCmdLocation)(unsafe.Pointer(mapPtr + uintptr(i)*32))).FnumSrcBytes)
		if srcLen < 0 {
			XTcl_Panic(tls, __ccgo_ts+24685, 0)
		} else {
			if srcLen <= int32(127) {
				srcLengthNext++
			} else {
				srcLengthNext += int32(5) /* 1 byte for 0xFF, 4 for length */
			}
		}
		goto _5
	_5:
		;
		i++
	}
	return codeDeltaNext + codeLengthNext + srcDeltaNext + srcLengthNext
}

/*
 *----------------------------------------------------------------------
 *
 * EncodeCmdLocMap --
 *
 *	Encodes the command location information for some compiled code into a
 *	ByteCode structure. The encoded command location map is stored as
 *	three-adjacent-byte sequences.
 *
 * Results:
 *	A pointer to the first byte after the encoded command location
 *	information.
 *
 * Side effects:
 *	Stores encoded information into the block of memory headed by
 *	codePtr. Also records pointers to the start of the four byte sequences
 *	in fields in codePtr's ByteCode header structure.
 *
 *----------------------------------------------------------------------
 */

func _EncodeCmdLocMap(tls *libc.TLS, envPtr uintptr, codePtr uintptr, startPtr uintptr) (r uintptr) {
	/* Points to the first byte in codePtr's
	 * memory block where the location information
	 * is to be stored. */
	var codeDelta, codeLen, i, numCmds, prevOffset, srcLen TTcl_Size
	var mapPtr, p uintptr
	var srcDelta int32
	_, _, _, _, _, _, _, _, _ = codeDelta, codeLen, i, mapPtr, numCmds, p, prevOffset, srcDelta, srcLen
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FcmdMapPtr
	numCmds = (*TCompileEnv)(unsafe.Pointer(envPtr)).FnumCommands
	p = startPtr
	/*
	 * Encode the code offset for each command as a sequence of deltas.
	 */
	(*TByteCode)(unsafe.Pointer(codePtr)).FcodeDeltaStart = p
	prevOffset = 0
	i = 0
	for {
		if !(i < numCmds) {
			break
		}
		codeDelta = (*(*TCmdLocation)(unsafe.Pointer(mapPtr + uintptr(i)*32))).FcodeOffset - prevOffset
		if codeDelta < 0 {
			XTcl_Panic(tls, __ccgo_ts+24726, 0)
		} else {
			if codeDelta <= int64(127) {
				*(*uint8)(unsafe.Pointer(p)) = uint8(libc.Uint32FromInt64(codeDelta))
				p++
			} else {
				*(*uint8)(unsafe.Pointer(p)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0xFF)))
				p++
				*(*uint8)(unsafe.Pointer(p)) = uint8(libc.Uint32FromInt64(codeDelta) >> libc.Int32FromInt32(24))
				*(*uint8)(unsafe.Pointer(p + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(codeDelta) >> libc.Int32FromInt32(16))
				*(*uint8)(unsafe.Pointer(p + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt64(codeDelta) >> libc.Int32FromInt32(8))
				*(*uint8)(unsafe.Pointer(p + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt64(codeDelta))
				p += uintptr(4)
			}
		}
		prevOffset = (*(*TCmdLocation)(unsafe.Pointer(mapPtr + uintptr(i)*32))).FcodeOffset
		goto _1
	_1:
		;
		i++
	}
	/*
	 * Encode the code length for each command.
	 */
	(*TByteCode)(unsafe.Pointer(codePtr)).FcodeLengthStart = p
	i = 0
	for {
		if !(i < numCmds) {
			break
		}
		codeLen = (*(*TCmdLocation)(unsafe.Pointer(mapPtr + uintptr(i)*32))).FnumCodeBytes
		if codeLen < 0 {
			XTcl_Panic(tls, __ccgo_ts+24759, 0)
		} else {
			if codeLen <= int64(127) {
				*(*uint8)(unsafe.Pointer(p)) = uint8(libc.Uint32FromInt64(codeLen))
				p++
			} else {
				*(*uint8)(unsafe.Pointer(p)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0xFF)))
				p++
				*(*uint8)(unsafe.Pointer(p)) = uint8(libc.Uint32FromInt64(codeLen) >> libc.Int32FromInt32(24))
				*(*uint8)(unsafe.Pointer(p + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(codeLen) >> libc.Int32FromInt32(16))
				*(*uint8)(unsafe.Pointer(p + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt64(codeLen) >> libc.Int32FromInt32(8))
				*(*uint8)(unsafe.Pointer(p + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt64(codeLen))
				p += uintptr(4)
			}
		}
		goto _2
	_2:
		;
		i++
	}
	/*
	 * Encode the source offset for each command as a sequence of deltas.
	 */
	(*TByteCode)(unsafe.Pointer(codePtr)).FsrcDeltaStart = p
	prevOffset = 0
	i = 0
	for {
		if !(i < numCmds) {
			break
		}
		srcDelta = int32((*(*TCmdLocation)(unsafe.Pointer(mapPtr + uintptr(i)*32))).FsrcOffset - prevOffset)
		if -int32(127) <= srcDelta && srcDelta <= int32(127) && srcDelta != -int32(1) {
			*(*uint8)(unsafe.Pointer(p)) = uint8(libc.Uint32FromInt32(srcDelta))
			p++
		} else {
			*(*uint8)(unsafe.Pointer(p)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0xFF)))
			p++
			*(*uint8)(unsafe.Pointer(p)) = uint8(libc.Uint32FromInt32(srcDelta) >> libc.Int32FromInt32(24))
			*(*uint8)(unsafe.Pointer(p + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(srcDelta) >> libc.Int32FromInt32(16))
			*(*uint8)(unsafe.Pointer(p + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt32(srcDelta) >> libc.Int32FromInt32(8))
			*(*uint8)(unsafe.Pointer(p + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt32(srcDelta))
			p += uintptr(4)
		}
		prevOffset = (*(*TCmdLocation)(unsafe.Pointer(mapPtr + uintptr(i)*32))).FsrcOffset
		goto _3
	_3:
		;
		i++
	}
	/*
	 * Encode the source length for each command.
	 */
	(*TByteCode)(unsafe.Pointer(codePtr)).FsrcLengthStart = p
	i = 0
	for {
		if !(i < numCmds) {
			break
		}
		srcLen = (*(*TCmdLocation)(unsafe.Pointer(mapPtr + uintptr(i)*32))).FnumSrcBytes
		if srcLen < 0 {
			XTcl_Panic(tls, __ccgo_ts+24792, 0)
		} else {
			if srcLen <= int64(127) {
				*(*uint8)(unsafe.Pointer(p)) = uint8(libc.Uint32FromInt64(srcLen))
				p++
			} else {
				*(*uint8)(unsafe.Pointer(p)) = uint8(libc.Uint32FromInt32(libc.Int32FromInt32(0xFF)))
				p++
				*(*uint8)(unsafe.Pointer(p)) = uint8(libc.Uint32FromInt64(srcLen) >> libc.Int32FromInt32(24))
				*(*uint8)(unsafe.Pointer(p + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt64(srcLen) >> libc.Int32FromInt32(16))
				*(*uint8)(unsafe.Pointer(p + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt64(srcLen) >> libc.Int32FromInt32(8))
				*(*uint8)(unsafe.Pointer(p + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt64(srcLen))
				p += uintptr(4)
			}
		}
		goto _4
	_4:
		;
		i++
	}
	return p
}

const ASSOC_KEY = "tclPackageAboutDict"

/* Epoch of the tcl environment
 * (if changed with tcl-env). */

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * Internal structure to hold embedded configuration information.
 *
 * Our structure is a two-level dictionary associated with the 'interp'. The
 * first level is keyed with the package name and maps to the dictionary for
 * that package. The package dictionary is keyed with metadata keys and maps
 * to the metadata value for that key. This is package specific. The metadata
 * values are in UTF-8, converted from the external representation given to us
 * by the caller.
 */

/*
 * A ClientData struct for the QueryConfig command.  Store the three bits
 * of data we need; the package name for which we store a config dict,
 * the (Tcl_Interp *) in which it is stored, and the encoding.
 */

type TQCCD = struct {
	Fpkg      uintptr
	Finterp   uintptr
	Fencoding uintptr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_RegisterConfig --
 *
 *	See TIP#59 for details on what this function does.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Creates namespace and cfg query command in it as per TIP #59.
 *
 *----------------------------------------------------------------------
 */

func XTcl_RegisterConfig(tls *libc.TLS, interp uintptr, pkgName uintptr, configuration uintptr, valEncoding uintptr) {
	bp := tls.Alloc(272)
	defer tls.Free(272) /* Name of the encoding used to store the
	 * configuration values, ASCII, thus UTF-8. */
	var cdPtr, cfg, pDB uintptr
	var _ /* cmdName at bp+8 */ TTcl_DString
	var _ /* pkgDict at bp+0 */ uintptr
	_, _, _ = cdPtr, cfg, pDB
	cdPtr = XTcl_Alloc(tls, uint64(24))
	(*TQCCD)(unsafe.Pointer(cdPtr)).Finterp = interp
	if valEncoding != 0 {
		(*TQCCD)(unsafe.Pointer(cdPtr)).Fencoding = XTcl_Alloc(tls, libc.Xstrlen(tls, valEncoding)+uint64(1))
		libc.Xstrcpy(tls, (*TQCCD)(unsafe.Pointer(cdPtr)).Fencoding, valEncoding)
	} else {
		(*TQCCD)(unsafe.Pointer(cdPtr)).Fencoding = libc.UintptrFromInt32(0)
	}
	(*TQCCD)(unsafe.Pointer(cdPtr)).Fpkg = XTcl_NewStringObj(tls, pkgName, int64(-int32(1)))
	/*
	 * Phase I: Adding the provided information to the internal database of
	 * package meta data.
	 *
	 * Phase II: Create a command for querying this database, specific to the
	 * package registering its configuration. This is the approved interface
	 * in TIP 59. In the future a more general interface should be done, as
	 * follow-up to TIP 59. Simply because our database is now general across
	 * packages, and not a structure tied to one package.
	 *
	 * Note, the created command will have a reference through its clientdata.
	 */
	(*TTcl_Obj)(unsafe.Pointer((*TQCCD)(unsafe.Pointer(cdPtr)).Fpkg)).FrefCount++
	/*
	 * For venc == NULL aka bogus encoding we skip the step setting up the
	 * dictionaries visible at Tcl level. I.e. they are not filled
	 */
	pDB = _GetConfigDict(tls, interp)
	/*
	 * Retrieve package specific configuration...
	 */
	if XTcl_DictObjGet(tls, interp, pDB, (*TQCCD)(unsafe.Pointer(cdPtr)).Fpkg, bp) != TCL_OK || *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
		*(*uintptr)(unsafe.Pointer(bp)) = XTcl_NewDictObj(tls)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FrefCount > int64(1) {
			*(*uintptr)(unsafe.Pointer(bp)) = XTcl_DuplicateObj(tls, *(*uintptr)(unsafe.Pointer(bp)))
		}
	}
	/*
	 * Extend the package configuration...
	 * We cannot assume that the encodings are initialized, therefore
	 * store the value as-is in a byte array. See Bug [9b2e636361].
	 */
	cfg = configuration
	for {
		if !((*TTcl_Config)(unsafe.Pointer(cfg)).Fkey != libc.UintptrFromInt32(0) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_Config)(unsafe.Pointer(cfg)).Fkey))) != int32('\000')) {
			break
		}
		XTclDictPut(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), (*TTcl_Config)(unsafe.Pointer(cfg)).Fkey, XTcl_NewByteArrayObj(tls, (*TTcl_Config)(unsafe.Pointer(cfg)).Fvalue, libc.Int64FromUint64(libc.Xstrlen(tls, (*TTcl_Config)(unsafe.Pointer(cfg)).Fvalue))))
		goto _1
	_1:
		;
		cfg += 16
	}
	/*
	 * Write the changes back into the overall database.
	 */
	XTcl_DictObjPut(tls, interp, pDB, (*TQCCD)(unsafe.Pointer(cdPtr)).Fpkg, *(*uintptr)(unsafe.Pointer(bp)))
	/*
	 * Now create the interface command for retrieval of the package
	 * information.
	 */
	XTcl_DStringInit(tls, bp+8)
	XTcl_DStringAppend(tls, bp+8, __ccgo_ts+7650, libc.Int64FromUint64(libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)))
	XTcl_DStringAppend(tls, bp+8, pkgName, int64(-int32(1)))
	/*
	 * The incomplete command name is the name of the namespace to place it
	 * in.
	 */
	if XTcl_FindNamespace(tls, interp, (*TTcl_DString)(unsafe.Pointer(bp+8)).Fstring1, libc.UintptrFromInt32(0), int32(TCL_GLOBAL_ONLY)) == libc.UintptrFromInt32(0) {
		if XTcl_CreateNamespace(tls, interp, (*TTcl_DString)(unsafe.Pointer(bp+8)).Fstring1, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0)) == libc.UintptrFromInt32(0) {
			XTcl_Panic(tls, __ccgo_ts+24827, libc.VaList(bp+240, XTcl_GetStringFromObj(tls, XTcl_GetObjResult(tls, interp), libc.UintptrFromInt32(0)), __ccgo_ts+24838, __ccgo_ts+24857))
		}
	}
	XTcl_DStringAppend(tls, bp+8, __ccgo_ts+24911, libc.Int64FromUint64(libc.Uint64FromInt64(12)-libc.Uint64FromInt32(1)))
	if XTcl_CreateObjCommand(tls, interp, (*TTcl_DString)(unsafe.Pointer(bp+8)).Fstring1, __ccgo_fp(_QueryConfigObjCmd), cdPtr, __ccgo_fp(_QueryConfigDelete)) == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+24923, libc.VaList(bp+240, __ccgo_ts+24838, __ccgo_ts+24930))
	}
	XTcl_DStringFree(tls, bp+8)
}

/*
 *----------------------------------------------------------------------
 *
 * QueryConfigObjCmd --
 *
 *	Implementation of "::<package>::pkgconfig", the command to query
 *	configuration information embedded into a library.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the manual for what this command does.
 *
 *----------------------------------------------------------------------
 */

func _QueryConfigObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(352)
	defer tls.Free(352)
	var cdPtr, listPtr, pDB, pkgName, value, v1, v2 uintptr
	var venc TTcl_Encoding
	var _ /* conv at bp+40 */ TTcl_DString
	var _ /* done at bp+296 */ int32
	var _ /* index at bp+32 */ int32
	var _ /* key at bp+288 */ uintptr
	var _ /* m at bp+16 */ TTcl_Size
	var _ /* n at bp+24 */ TTcl_Size
	var _ /* pkgDict at bp+0 */ uintptr
	var _ /* s at bp+264 */ TTcl_DictSearch
	var _ /* val at bp+8 */ uintptr
	_, _, _, _, _, _, _, _ = cdPtr, listPtr, pDB, pkgName, value, venc, v1, v2
	cdPtr = clientData
	pkgName = (*TQCCD)(unsafe.Pointer(cdPtr)).Fpkg
	*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = 0
	venc = libc.UintptrFromInt32(0)
	if objc < int32(2) || objc > int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+24991)
		return int32(TCL_ERROR)
	}
	if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), uintptr(unsafe.Pointer(&_subcmdStrings)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+25008, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+32) != TCL_OK {
		return int32(TCL_ERROR)
	}
	pDB = _GetConfigDict(tls, interp)
	if XTcl_DictObjGet(tls, interp, pDB, pkgName, bp) != TCL_OK || *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
		/*
		 * Maybe a Tcl_Panic is better, because the package data has to be
		 * present.
		 */
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+25019, int64(-int32(1))))
		if (*TTcl_Obj)(unsafe.Pointer(pkgName)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(pkgName)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, pkgName, libc.UintptrFromInt32(0))
		}
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+312, __ccgo_ts+2004, __ccgo_ts+25037, __ccgo_ts+25043, v1, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	switch *(*int32)(unsafe.Pointer(bp + 32)) {
	case 0:
		if objc != int32(3) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+25055)
			return int32(TCL_ERROR)
		}
		if XTcl_DictObjGet(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp+8) != TCL_OK || *(*uintptr)(unsafe.Pointer(bp + 8)) == libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+25059, int64(-int32(1))))
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
				v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
			}
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+312, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+25073, v2, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		if (*TQCCD)(unsafe.Pointer(cdPtr)).Fencoding != 0 {
			venc = XTcl_GetEncoding(tls, interp, (*TQCCD)(unsafe.Pointer(cdPtr)).Fencoding)
			if !(venc != 0) {
				return int32(TCL_ERROR)
			}
		}
		/*
		 * Value is stored as-is in a byte array, see Bug [9b2e636361],
		 * so we have to decode it first.
		 */
		value = XTcl_GetBytesFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 8)), bp+24)
		if value == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
		value = XTcl_ExternalToUtfDString(tls, venc, value, *(*TTcl_Size)(unsafe.Pointer(bp + 24)), bp+40)
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, value, (*TTcl_DString)(unsafe.Pointer(bp+40)).Flength))
		XTcl_DStringFree(tls, bp+40)
		return TCL_OK
	case 1:
		if objc != int32(2) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, libc.UintptrFromInt32(0))
			return int32(TCL_ERROR)
		}
		XTcl_DictObjSize(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), bp+16)
		listPtr = XTcl_NewListObj(tls, *(*TTcl_Size)(unsafe.Pointer(bp + 16)), libc.UintptrFromInt32(0))
		if !(listPtr != 0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+25080, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+312, __ccgo_ts+2004, __ccgo_ts+2008, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) != 0 {
			XTcl_DictObjFirst(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), bp+264, bp+288, libc.UintptrFromInt32(0), bp+296)
			for {
				if !!(*(*int32)(unsafe.Pointer(bp + 296)) != 0) {
					break
				}
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listPtr, *(*uintptr)(unsafe.Pointer(bp + 288)))
				goto _3
			_3:
				;
				XTcl_DictObjNext(tls, bp+264, bp+288, libc.UintptrFromInt32(0), bp+296)
			}
		}
		XTcl_SetObjResult(tls, interp, listPtr)
		return TCL_OK
	default:
		XTcl_Panic(tls, __ccgo_ts+25115, 0)
		break
	}
	return int32(TCL_ERROR)
}

var _subcmdStrings = [3]uintptr{
	0: __ccgo_ts + 24987,
	1: __ccgo_ts + 2860,
	2: libc.UintptrFromInt32(0),
}

/*
 *-------------------------------------------------------------------------
 *
 * QueryConfigDelete --
 *
 *	Command delete function. Cleans up after the configuration query
 *	command when it is deleted by the user or during finalization.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Deallocates all non-transient memory allocated by Tcl_RegisterConfig.
 *
 *-------------------------------------------------------------------------
 */

func _QueryConfigDelete(tls *libc.TLS, clientData uintptr) {
	var _objPtr, cdPtr, pDB, pkgName, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _, _, _ = _objPtr, cdPtr, pDB, pkgName, v1, v2
	cdPtr = clientData
	pkgName = (*TQCCD)(unsafe.Pointer(cdPtr)).Fpkg
	pDB = _GetConfigDict(tls, (*TQCCD)(unsafe.Pointer(cdPtr)).Finterp)
	XTcl_DictObjRemove(tls, libc.UintptrFromInt32(0), pDB, pkgName)
	_objPtr = pkgName
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	if (*TQCCD)(unsafe.Pointer(cdPtr)).Fencoding != 0 {
		XTclpFree(tls, (*TQCCD)(unsafe.Pointer(cdPtr)).Fencoding)
	}
	XTclpFree(tls, cdPtr)
}

/*
 *-------------------------------------------------------------------------
 *
 * GetConfigDict --
 *
 *	Retrieve the package metadata database from the interpreter.
 *	Initializes it, if not present yet.
 *
 * Results:
 *	A Tcl_Obj reference
 *
 * Side effects:
 *	May allocate a Tcl_Obj.
 *
 *-------------------------------------------------------------------------
 */

func _GetConfigDict(tls *libc.TLS, interp uintptr) (r uintptr) {
	var pDB uintptr
	_ = pDB
	pDB = XTcl_GetAssocData(tls, interp, __ccgo_ts+25187, libc.UintptrFromInt32(0))
	if pDB == libc.UintptrFromInt32(0) {
		pDB = XTcl_NewDictObj(tls)
		(*TTcl_Obj)(unsafe.Pointer(pDB)).FrefCount++
		XTcl_SetAssocData(tls, interp, __ccgo_ts+25187, __ccgo_fp(_ConfigDictDeleteProc), pDB)
	}
	return pDB
}

/*
 *----------------------------------------------------------------------
 *
 * ConfigDictDeleteProc --
 *
 *	This function is associated with the "Package About dict" assoc data
 *	for an interpreter; it is invoked when the interpreter is deleted in
 *	order to free the information associated with any pending error
 *	reports.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The package metadata database is freed.
 *
 *----------------------------------------------------------------------
 */

func _ConfigDictDeleteProc(tls *libc.TLS, clientData uintptr, dummy395 uintptr) {
	var _objPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _ = _objPtr, v1, v2
	_objPtr = clientData
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
}

const END_OF_TIME = 2037
const EPOCH = 1970
const START_OF_TIME = 1902
const TM_YEAR_BASE = 1900
const YYBISON = 30802
const YYBISON_VERSION = "3.8.2"
const YYCOPY_NEEDED = 1
const YYDEBUG = 0
const YYERRCODE = 0
const YYFINAL = 2
const YYINITDEPTH = 200
const YYLAST = 98
const YYLTYPE_IS_DECLARED = 1
const YYLTYPE_IS_TRIVIAL = 1
const YYMALLOC = 0
const YYMAXDEPTH = 10000
const YYMAXUTOK = 278
const YYNNTS = 23
const YYNRULES = 72
const YYNSTATES = 103
const YYNTOKENS = 31
const YYPACT_NINF = -21
const YYPTRDIFF_MAXIMUM = 9223372036854775807
const YYPTRDIFF_T = "__PTRDIFF_TYPE__"
const YYPULL = 1
const YYPURE = 1
const YYPUSH = 0
const YYSIZE_T = "__SIZE_TYPE__"
const YYSKELETON_NAME = "yacc.c"
const YYSTACK_ALLOC = 0
const YYSTACK_ALLOC_MAXIMUM = "YYSIZE_MAXIMUM"
const YYSTACK_FREE = 0
const YYSTYPE_IS_DECLARED = 1
const YYSTYPE_IS_TRIVIAL = 1
const YYTABLE_NINF = -68
const YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN = 0
const YY_IGNORE_MAYBE_UNINITIALIZED_END = 0
const yydebug = 0
const yyerror = 0
const yylex = 0
const yynerrs = 0
const yyparse = 0

/*
 * The offset of tm_year of struct tm returned by localtime, gmtime, etc.
 * Posix requires 1900.
 */

/*
 * An entry in the lexical lookup table.
 */

type TTABLE = struct {
	Fname  uintptr
	Ftype1 int32
	Fvalue int32
}

/*
 * Daylight-savings mode: on, off, or not yet known.
 */

type TDSTMODE = int32

/*
 * Daylight-savings mode: on, off, or not yet known.
 */

type _DSTMODE = int32

const DSTon = 0
const DSToff = 1
const DSTmaybe = 2

/* Debug traces.  */

/* Token kinds.  */
type yytokentype = int32

const YYEMPTY = -2
const YYEOF = 0
const /* "end of file"  */
YYerror = 256
const /* error  */
YYUNDEF = 257
const /* "invalid token"  */
tAGO = 258
const /* tAGO  */
tDAY = 259
const /* tDAY  */
tDAYZONE = 260
const /* tDAYZONE  */
tID = 261
const /* tID  */
tMERIDIAN = 262
const /* tMERIDIAN  */
tMONTH = 263
const /* tMONTH  */
tMONTH_UNIT = 264
const /* tMONTH_UNIT  */
tSTARDATE = 265
const /* tSTARDATE  */
tSEC_UNIT = 266
const /* tSEC_UNIT  */
tUNUMBER = 267
const /* tUNUMBER  */
tZONE = 268
const /* tZONE  */
tZONEwO4 = 269
const /* tZONEwO4  */
tZONEwO2 = 270
const /* tZONEwO2  */
tEPOCH = 271
const /* tEPOCH  */
tDST = 272
const /* tDST  */
tISOBAS8 = 273
const /* tISOBAS8  */
tISOBAS6 = 274
const /* tISOBAS6  */
tISOBASL = 275
const /* tISOBASL  */
tDAY_UNIT = 276
const /* tDAY_UNIT  */
tNEXT = 277
const /* tNEXT  */
SP = 278

type Tyytoken_kind_t = int32

/* Value type.  */
type TYYSTYPE1 = struct {
	FMeridian [0]_MERIDIAN
	FNumber   TTcl_WideInt
}

type TYYSTYPE = struct {
	FMeridian [0]_MERIDIAN
	FNumber   TTcl_WideInt
}

// C documentation
//
//	/* Location type.  */
type TYYLTYPE = struct {
	Ffirst_line   int32
	Ffirst_column int32
	Flast_line    int32
	Flast_column  int32
}

type TYYLTYPE1 = struct {
	Ffirst_line   int32
	Ffirst_column int32
	Flast_line    int32
	Flast_column  int32
}

/* Symbol kind.  */
type yysymbol_kind_t = int32

const YYSYMBOL_YYEMPTY = -2
const YYSYMBOL_YYEOF = 0
const /* "end of file"  */
YYSYMBOL_YYerror = 1
const /* error  */
YYSYMBOL_YYUNDEF = 2
const /* "invalid token"  */
YYSYMBOL_tAGO = 3
const /* tAGO  */
YYSYMBOL_tDAY = 4
const /* tDAY  */
YYSYMBOL_tDAYZONE = 5
const /* tDAYZONE  */
YYSYMBOL_tID = 6
const /* tID  */
YYSYMBOL_tMERIDIAN = 7
const /* tMERIDIAN  */
YYSYMBOL_tMONTH = 8
const /* tMONTH  */
YYSYMBOL_tMONTH_UNIT = 9
const /* tMONTH_UNIT  */
YYSYMBOL_tSTARDATE = 10
const /* tSTARDATE  */
YYSYMBOL_tSEC_UNIT = 11
const /* tSEC_UNIT  */
YYSYMBOL_tUNUMBER = 12
const /* tUNUMBER  */
YYSYMBOL_tZONE = 13
const /* tZONE  */
YYSYMBOL_tZONEwO4 = 14
const /* tZONEwO4  */
YYSYMBOL_tZONEwO2 = 15
const /* tZONEwO2  */
YYSYMBOL_tEPOCH = 16
const /* tEPOCH  */
YYSYMBOL_tDST = 17
const /* tDST  */
YYSYMBOL_tISOBAS8 = 18
const /* tISOBAS8  */
YYSYMBOL_tISOBAS6 = 19
const /* tISOBAS6  */
YYSYMBOL_tISOBASL = 20
const /* tISOBASL  */
YYSYMBOL_tDAY_UNIT = 21
const /* tDAY_UNIT  */
YYSYMBOL_tNEXT = 22
const /* tNEXT  */
YYSYMBOL_SP = 23
const /* SP  */
YYSYMBOL_24_ = 24
const /* ':'  */
YYSYMBOL_25_ = 25
const /* ','  */
YYSYMBOL_26_ = 26
const /* '-'  */
YYSYMBOL_27_ = 27
const /* '/'  */
YYSYMBOL_28_T_ = 28
const /* 'T'  */
YYSYMBOL_29_ = 29
const /* '.'  */
YYSYMBOL_30_ = 30
const /* '+'  */
YYSYMBOL_YYACCEPT = 31
const /* $accept  */
YYSYMBOL_spec = 32
const /* spec  */
YYSYMBOL_item = 33
const /* item  */
YYSYMBOL_iextime = 34
const /* iextime  */
YYSYMBOL_time = 35
const /* time  */
YYSYMBOL_zone = 36
const /* zone  */
YYSYMBOL_comma = 37
const /* comma  */
YYSYMBOL_day = 38
const /* day  */
YYSYMBOL_iexdate = 39
const /* iexdate  */
YYSYMBOL_date = 40
const /* date  */
YYSYMBOL_ordMonth = 41
const /* ordMonth  */
YYSYMBOL_isosep = 42
const /* isosep  */
YYSYMBOL_isodate = 43
const /* isodate  */
YYSYMBOL_isotime = 44
const /* isotime  */
YYSYMBOL_iso = 45
const /* iso  */
YYSYMBOL_trek = 46
const /* trek  */
YYSYMBOL_relspec = 47
const /* relspec  */
YYSYMBOL_relunits = 48
const /* relunits  */
YYSYMBOL_sign = 49
const /* sign  */
YYSYMBOL_unit = 50
const /* unit  */
YYSYMBOL_INTNUM = 51
const /* INTNUM  */
YYSYMBOL_numitem = 52
const /* numitem  */
YYSYMBOL_o_merid = 53

type Tyysymbol_kind_t = int32

/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
   <limits.h> and (if available) <stdint.h> are included
   so that the code can choose integer types of a good width.  */

/* Narrow types that promote to a signed type and that can represent a
   signed or unsigned integer of at least N bits.  In tables they can
   save space and decrease cache pressure.  Promoting to a signed type
   helps avoid bugs in integer arithmetic.  */

type Tyytype_int8 = int8

type Tyytype_int16 = int16

/* Work around bug in HP-UX 11.23, which defines these macros
   incorrectly for preprocessor constants.  This workaround can likely
   be removed in 2023, as HPE has promised support for HP-UX 11.23
   (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of
   <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>.  */

type Tyytype_uint8 = uint8

type Tyytype_uint16 = uint16

// C documentation
//
//	/* Stored state numbers (used for stacks). */
type Tyy_state_t = int8

// C documentation
//
//	/* State numbers in computations.  */
type Tyy_state_fast_t = int32

/* Suppress unused-variable warnings by "using" E.  */

/* Suppress an incorrect diagnostic about yylval being uninitialized.  */

/* The parser invokes alloca or malloc; define the necessary symbols.  */

/* A type that is properly aligned for any stack member.  */
type Tyyalloc = struct {
	Fyyvs_alloc  [0]TYYSTYPE
	Fyyls_alloc  [0]TYYLTYPE
	Fyyss_alloc  Tyy_state_t
	F__ccgo_pad3 [15]byte
}

/* The size of the maximum gap between one aligned stack and the next.  */

/* The size of an array large to enough to hold all stacks, each with
   N elements.  */

/* Relocate STACK from its old location to the new one.  The
   local variables YYSIZE and YYSTACKSIZE give the old and new number of
   elements in the stack, and YYPTR gives the new location of the
   stack.  Advance YYPTR to a properly aligned location for the next
   stack.  */

/* Copy COUNT objects from SRC to DST.  The source and destination do
   not overlap.  */

/* YYFINAL -- State number of the termination state.  */
/* YYLAST -- Last index in YYTABLE.  */

/* YYNTOKENS -- Number of terminals.  */
/* YYNNTS -- Number of nonterminals.  */
/* YYNRULES -- Number of rules.  */
/* YYNSTATES -- Number of states.  */

/* YYMAXUTOK -- Last valid token kind.  */

/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
   as returned by yylex, with out-of-bounds checking.  */

// C documentation
//
//	/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
//	   as returned by yylex.  */
var _yytranslate = [279]Tyytype_int8{
	1:   int8(2),
	2:   int8(2),
	3:   int8(2),
	4:   int8(2),
	5:   int8(2),
	6:   int8(2),
	7:   int8(2),
	8:   int8(2),
	9:   int8(2),
	10:  int8(2),
	11:  int8(2),
	12:  int8(2),
	13:  int8(2),
	14:  int8(2),
	15:  int8(2),
	16:  int8(2),
	17:  int8(2),
	18:  int8(2),
	19:  int8(2),
	20:  int8(2),
	21:  int8(2),
	22:  int8(2),
	23:  int8(2),
	24:  int8(2),
	25:  int8(2),
	26:  int8(2),
	27:  int8(2),
	28:  int8(2),
	29:  int8(2),
	30:  int8(2),
	31:  int8(2),
	32:  int8(2),
	33:  int8(2),
	34:  int8(2),
	35:  int8(2),
	36:  int8(2),
	37:  int8(2),
	38:  int8(2),
	39:  int8(2),
	40:  int8(2),
	41:  int8(2),
	42:  int8(2),
	43:  int8(30),
	44:  int8(25),
	45:  int8(26),
	46:  int8(29),
	47:  int8(27),
	48:  int8(2),
	49:  int8(2),
	50:  int8(2),
	51:  int8(2),
	52:  int8(2),
	53:  int8(2),
	54:  int8(2),
	55:  int8(2),
	56:  int8(2),
	57:  int8(2),
	58:  int8(24),
	59:  int8(2),
	60:  int8(2),
	61:  int8(2),
	62:  int8(2),
	63:  int8(2),
	64:  int8(2),
	65:  int8(2),
	66:  int8(2),
	67:  int8(2),
	68:  int8(2),
	69:  int8(2),
	70:  int8(2),
	71:  int8(2),
	72:  int8(2),
	73:  int8(2),
	74:  int8(2),
	75:  int8(2),
	76:  int8(2),
	77:  int8(2),
	78:  int8(2),
	79:  int8(2),
	80:  int8(2),
	81:  int8(2),
	82:  int8(2),
	83:  int8(2),
	84:  int8(28),
	85:  int8(2),
	86:  int8(2),
	87:  int8(2),
	88:  int8(2),
	89:  int8(2),
	90:  int8(2),
	91:  int8(2),
	92:  int8(2),
	93:  int8(2),
	94:  int8(2),
	95:  int8(2),
	96:  int8(2),
	97:  int8(2),
	98:  int8(2),
	99:  int8(2),
	100: int8(2),
	101: int8(2),
	102: int8(2),
	103: int8(2),
	104: int8(2),
	105: int8(2),
	106: int8(2),
	107: int8(2),
	108: int8(2),
	109: int8(2),
	110: int8(2),
	111: int8(2),
	112: int8(2),
	113: int8(2),
	114: int8(2),
	115: int8(2),
	116: int8(2),
	117: int8(2),
	118: int8(2),
	119: int8(2),
	120: int8(2),
	121: int8(2),
	122: int8(2),
	123: int8(2),
	124: int8(2),
	125: int8(2),
	126: int8(2),
	127: int8(2),
	128: int8(2),
	129: int8(2),
	130: int8(2),
	131: int8(2),
	132: int8(2),
	133: int8(2),
	134: int8(2),
	135: int8(2),
	136: int8(2),
	137: int8(2),
	138: int8(2),
	139: int8(2),
	140: int8(2),
	141: int8(2),
	142: int8(2),
	143: int8(2),
	144: int8(2),
	145: int8(2),
	146: int8(2),
	147: int8(2),
	148: int8(2),
	149: int8(2),
	150: int8(2),
	151: int8(2),
	152: int8(2),
	153: int8(2),
	154: int8(2),
	155: int8(2),
	156: int8(2),
	157: int8(2),
	158: int8(2),
	159: int8(2),
	160: int8(2),
	161: int8(2),
	162: int8(2),
	163: int8(2),
	164: int8(2),
	165: int8(2),
	166: int8(2),
	167: int8(2),
	168: int8(2),
	169: int8(2),
	170: int8(2),
	171: int8(2),
	172: int8(2),
	173: int8(2),
	174: int8(2),
	175: int8(2),
	176: int8(2),
	177: int8(2),
	178: int8(2),
	179: int8(2),
	180: int8(2),
	181: int8(2),
	182: int8(2),
	183: int8(2),
	184: int8(2),
	185: int8(2),
	186: int8(2),
	187: int8(2),
	188: int8(2),
	189: int8(2),
	190: int8(2),
	191: int8(2),
	192: int8(2),
	193: int8(2),
	194: int8(2),
	195: int8(2),
	196: int8(2),
	197: int8(2),
	198: int8(2),
	199: int8(2),
	200: int8(2),
	201: int8(2),
	202: int8(2),
	203: int8(2),
	204: int8(2),
	205: int8(2),
	206: int8(2),
	207: int8(2),
	208: int8(2),
	209: int8(2),
	210: int8(2),
	211: int8(2),
	212: int8(2),
	213: int8(2),
	214: int8(2),
	215: int8(2),
	216: int8(2),
	217: int8(2),
	218: int8(2),
	219: int8(2),
	220: int8(2),
	221: int8(2),
	222: int8(2),
	223: int8(2),
	224: int8(2),
	225: int8(2),
	226: int8(2),
	227: int8(2),
	228: int8(2),
	229: int8(2),
	230: int8(2),
	231: int8(2),
	232: int8(2),
	233: int8(2),
	234: int8(2),
	235: int8(2),
	236: int8(2),
	237: int8(2),
	238: int8(2),
	239: int8(2),
	240: int8(2),
	241: int8(2),
	242: int8(2),
	243: int8(2),
	244: int8(2),
	245: int8(2),
	246: int8(2),
	247: int8(2),
	248: int8(2),
	249: int8(2),
	250: int8(2),
	251: int8(2),
	252: int8(2),
	253: int8(2),
	254: int8(2),
	255: int8(2),
	256: int8(1),
	257: int8(2),
	258: int8(3),
	259: int8(4),
	260: int8(5),
	261: int8(6),
	262: int8(7),
	263: int8(8),
	264: int8(9),
	265: int8(10),
	266: int8(11),
	267: int8(12),
	268: int8(13),
	269: int8(14),
	270: int8(15),
	271: int8(16),
	272: int8(17),
	273: int8(18),
	274: int8(19),
	275: int8(20),
	276: int8(21),
	277: int8(22),
	278: int8(23),
}

/** Accessing symbol of state STATE.  */

// C documentation
//
//	/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
//	   STATE-NUM.  */
var _yypact = [103]Tyytype_int8{
	0:   int8(-int32(21)),
	1:   int8(11),
	2:   int8(-int32(21)),
	3:   int8(-int32(20)),
	4:   int8(-int32(21)),
	5:   int8(5),
	6:   int8(-int32(21)),
	7:   int8(-int32(9)),
	8:   int8(-int32(21)),
	9:   int8(46),
	10:  int8(17),
	11:  int8(9),
	12:  int8(9),
	13:  int8(-int32(21)),
	14:  int8(-int32(21)),
	15:  int8(-int32(21)),
	16:  int8(24),
	17:  int8(-int32(21)),
	18:  int8(57),
	19:  int8(-int32(21)),
	20:  int8(-int32(21)),
	21:  int8(-int32(21)),
	22:  int8(33),
	23:  int8(-int32(21)),
	24:  int8(-int32(21)),
	25:  int8(-int32(21)),
	26:  int8(-int32(21)),
	27:  int8(-int32(21)),
	28:  int8(-int32(21)),
	29:  int8(-int32(15)),
	30:  int8(-int32(21)),
	31:  int8(-int32(21)),
	32:  int8(-int32(21)),
	33:  int8(45),
	34:  int8(26),
	35:  int8(-int32(21)),
	36:  int8(-int32(7)),
	37:  int8(-int32(21)),
	38:  int8(51),
	39:  int8(-int32(21)),
	40:  int8(-int32(20)),
	41:  int8(-int32(21)),
	42:  int8(-int32(21)),
	43:  int8(-int32(21)),
	44:  int8(48),
	45:  int8(-int32(21)),
	46:  int8(-int32(21)),
	47:  int8(67),
	48:  int8(68),
	49:  int8(52),
	50:  int8(69),
	51:  int8(-int32(21)),
	52:  int8(-int32(9)),
	53:  int8(-int32(9)),
	54:  int8(-int32(21)),
	55:  int8(-int32(21)),
	56:  int8(-int32(21)),
	57:  int8(-int32(21)),
	58:  int8(74),
	59:  int8(-int32(21)),
	60:  int8(-int32(7)),
	61:  int8(-int32(21)),
	62:  int8(-int32(21)),
	63:  int8(-int32(21)),
	64:  int8(-int32(21)),
	65:  int8(44),
	66:  int8(-int32(21)),
	67:  int8(79),
	68:  int8(40),
	69:  int8(-int32(7)),
	70:  int8(-int32(21)),
	71:  int8(-int32(21)),
	72:  int8(72),
	73:  int8(73),
	74:  int8(-int32(21)),
	75:  int8(62),
	76:  int8(61),
	77:  int8(63),
	78:  int8(64),
	79:  int8(-int32(21)),
	80:  int8(-int32(21)),
	81:  int8(-int32(21)),
	82:  int8(-int32(21)),
	83:  int8(66),
	84:  int8(-int32(21)),
	85:  int8(-int32(21)),
	86:  int8(-int32(21)),
	87:  int8(-int32(21)),
	88:  int8(84),
	89:  int8(-int32(7)),
	90:  int8(-int32(21)),
	91:  int8(-int32(21)),
	92:  int8(-int32(21)),
	93:  int8(80),
	94:  int8(81),
	95:  int8(82),
	96:  int8(83),
	97:  int8(-int32(21)),
	98:  int8(-int32(21)),
	99:  int8(-int32(21)),
	100: int8(-int32(21)),
	101: int8(-int32(21)),
	102: int8(-int32(21)),
}

// C documentation
//
//	/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
//	   Performed when YYTABLE does not specify something else to do.  Zero
//	   means the default is an error.  */
var _yydefact = [103]Tyytype_int8{
	0:   int8(2),
	2:   int8(1),
	3:   int8(25),
	4:   int8(19),
	6:   int8(66),
	8:   int8(64),
	9:   int8(70),
	10:  int8(18),
	13:  int8(39),
	14:  int8(45),
	15:  int8(46),
	17:  int8(65),
	19:  int8(62),
	20:  int8(63),
	21:  int8(3),
	22:  int8(71),
	23:  int8(4),
	24:  int8(5),
	25:  int8(8),
	26:  int8(47),
	27:  int8(6),
	28:  int8(7),
	29:  int8(34),
	30:  int8(10),
	31:  int8(11),
	32:  int8(9),
	33:  int8(55),
	35:  int8(61),
	37:  int8(12),
	38:  int8(23),
	39:  int8(26),
	40:  int8(36),
	41:  int8(67),
	42:  int8(69),
	43:  int8(68),
	45:  int8(27),
	46:  int8(15),
	47:  int8(38),
	51:  int8(17),
	54:  int8(52),
	55:  int8(51),
	56:  int8(30),
	57:  int8(41),
	58:  int8(67),
	59:  int8(59),
	61:  int8(72),
	62:  int8(16),
	63:  int8(44),
	64:  int8(43),
	66:  int8(54),
	67:  int8(67),
	69:  int8(22),
	70:  int8(58),
	71:  int8(24),
	74:  int8(40),
	75:  int8(14),
	78:  int8(32),
	79:  int8(20),
	80:  int8(21),
	81:  int8(42),
	82:  int8(60),
	84:  int8(48),
	85:  int8(49),
	86:  int8(50),
	87:  int8(29),
	88:  int8(67),
	90:  int8(57),
	91:  int8(37),
	92:  int8(53),
	97:  int8(28),
	98:  int8(56),
	99:  int8(13),
	100: int8(35),
	101: int8(31),
	102: int8(33),
}

// C documentation
//
//	/* YYPGOTO[NTERM-NUM].  */
var _yypgoto = [23]Tyytype_int8{
	0:  int8(-int32(21)),
	1:  int8(-int32(21)),
	2:  int8(-int32(21)),
	3:  int8(31),
	4:  int8(-int32(21)),
	5:  int8(-int32(21)),
	6:  int8(58),
	7:  int8(-int32(21)),
	8:  int8(-int32(21)),
	9:  int8(-int32(21)),
	10: int8(-int32(21)),
	11: int8(-int32(21)),
	12: int8(-int32(21)),
	13: int8(-int32(21)),
	14: int8(-int32(21)),
	15: int8(-int32(21)),
	16: int8(-int32(21)),
	17: int8(-int32(21)),
	18: int8(-int32(5)),
	19: int8(-int32(18)),
	20: int8(-int32(6)),
	21: int8(-int32(21)),
	22: int8(-int32(21)),
}

// C documentation
//
//	/* YYDEFGOTO[NTERM-NUM].  */
var _yydefgoto = [23]Tyytype_int8{
	1:  int8(1),
	2:  int8(21),
	3:  int8(22),
	4:  int8(23),
	5:  int8(24),
	6:  int8(39),
	7:  int8(25),
	8:  int8(26),
	9:  int8(27),
	10: int8(28),
	11: int8(65),
	12: int8(29),
	13: int8(86),
	14: int8(30),
	15: int8(31),
	16: int8(32),
	17: int8(33),
	18: int8(34),
	19: int8(35),
	20: int8(36),
	21: int8(37),
	22: int8(62),
}

// C documentation
//
//	/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
//	   positive, shift that token.  If negative, reduce the rule whose
//	   number is the opposite.  If YYTABLE_NINF, syntax error.  */
var _yytable = [99]Tyytype_int8{
	0:  int8(59),
	1:  int8(44),
	2:  int8(6),
	3:  int8(41),
	4:  int8(8),
	5:  int8(38),
	6:  int8(52),
	7:  int8(53),
	8:  int8(63),
	9:  int8(42),
	10: int8(43),
	11: int8(2),
	12: int8(60),
	13: int8(64),
	14: int8(17),
	15: int8(3),
	16: int8(4),
	17: int8(40),
	18: int8(70),
	19: int8(5),
	20: int8(6),
	21: int8(7),
	22: int8(8),
	23: int8(9),
	24: int8(10),
	25: int8(11),
	26: int8(12),
	27: int8(13),
	28: int8(69),
	29: int8(14),
	30: int8(15),
	31: int8(16),
	32: int8(17),
	33: int8(18),
	34: int8(51),
	35: int8(19),
	36: int8(54),
	37: int8(19),
	38: int8(67),
	39: int8(20),
	40: int8(61),
	41: int8(20),
	42: int8(82),
	43: int8(55),
	44: int8(42),
	45: int8(43),
	46: int8(79),
	47: int8(80),
	48: int8(66),
	49: int8(68),
	50: int8(45),
	51: int8(90),
	52: int8(88),
	53: int8(46),
	54: int8(47),
	55: int8(-int32(67)),
	56: int8(83),
	57: int8(-int32(67)),
	58: int8(42),
	59: int8(43),
	60: int8(76),
	61: int8(56),
	62: int8(89),
	63: int8(84),
	64: int8(77),
	65: int8(57),
	66: int8(6),
	67: int8(-int32(67)),
	68: int8(8),
	69: int8(58),
	70: int8(48),
	71: int8(98),
	72: int8(49),
	73: int8(50),
	74: int8(71),
	75: int8(42),
	76: int8(43),
	77: int8(73),
	78: int8(17),
	79: int8(74),
	80: int8(75),
	81: int8(78),
	82: int8(81),
	83: int8(87),
	84: int8(91),
	85: int8(92),
	86: int8(93),
	87: int8(94),
	88: int8(97),
	89: int8(95),
	90: int8(48),
	91: int8(96),
	92: int8(99),
	93: int8(100),
	94: int8(101),
	95: int8(102),
	96: int8(85),
	98: int8(72),
}

var _yycheck = [99]Tyytype_int8{
	0:  int8(18),
	1:  int8(7),
	2:  int8(9),
	3:  int8(12),
	4:  int8(11),
	5:  int8(25),
	6:  int8(11),
	7:  int8(12),
	8:  int8(23),
	9:  int8(18),
	10: int8(19),
	12: int8(18),
	13: int8(28),
	14: int8(21),
	15: int8(4),
	16: int8(5),
	17: int8(12),
	18: int8(36),
	19: int8(8),
	20: int8(9),
	21: int8(10),
	22: int8(11),
	23: int8(12),
	24: int8(13),
	25: int8(14),
	26: int8(15),
	27: int8(16),
	28: int8(34),
	29: int8(18),
	30: int8(19),
	31: int8(20),
	32: int8(21),
	33: int8(22),
	34: int8(17),
	35: int8(26),
	36: int8(12),
	37: int8(26),
	38: int8(12),
	39: int8(30),
	40: int8(7),
	41: int8(30),
	42: int8(60),
	43: int8(19),
	44: int8(18),
	45: int8(19),
	46: int8(52),
	47: int8(53),
	48: int8(3),
	49: int8(23),
	50: int8(4),
	51: int8(69),
	52: int8(12),
	53: int8(7),
	54: int8(8),
	55: int8(9),
	56: int8(12),
	57: int8(11),
	58: int8(18),
	59: int8(19),
	60: int8(8),
	61: int8(4),
	62: int8(68),
	63: int8(19),
	64: int8(12),
	65: int8(8),
	66: int8(9),
	67: int8(21),
	68: int8(11),
	69: int8(12),
	70: int8(24),
	71: int8(89),
	72: int8(26),
	73: int8(27),
	74: int8(23),
	75: int8(18),
	76: int8(19),
	77: int8(29),
	78: int8(21),
	79: int8(12),
	80: int8(12),
	81: int8(12),
	82: int8(8),
	83: int8(4),
	84: int8(12),
	85: int8(12),
	86: int8(24),
	87: int8(26),
	88: int8(4),
	89: int8(26),
	90: int8(24),
	91: int8(27),
	92: int8(12),
	93: int8(12),
	94: int8(12),
	95: int8(12),
	96: int8(65),
	97: int8(-int32(1)),
	98: int8(40),
}

// C documentation
//
//	/* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of
//	   state STATE-NUM.  */
var _yystos = [103]Tyytype_int8{
	1:   int8(32),
	3:   int8(4),
	4:   int8(5),
	5:   int8(8),
	6:   int8(9),
	7:   int8(10),
	8:   int8(11),
	9:   int8(12),
	10:  int8(13),
	11:  int8(14),
	12:  int8(15),
	13:  int8(16),
	14:  int8(18),
	15:  int8(19),
	16:  int8(20),
	17:  int8(21),
	18:  int8(22),
	19:  int8(26),
	20:  int8(30),
	21:  int8(33),
	22:  int8(34),
	23:  int8(35),
	24:  int8(36),
	25:  int8(38),
	26:  int8(39),
	27:  int8(40),
	28:  int8(41),
	29:  int8(43),
	30:  int8(45),
	31:  int8(46),
	32:  int8(47),
	33:  int8(48),
	34:  int8(49),
	35:  int8(50),
	36:  int8(51),
	37:  int8(52),
	38:  int8(25),
	39:  int8(37),
	40:  int8(12),
	41:  int8(12),
	42:  int8(18),
	43:  int8(19),
	44:  int8(51),
	45:  int8(4),
	46:  int8(7),
	47:  int8(8),
	48:  int8(24),
	49:  int8(26),
	50:  int8(27),
	51:  int8(17),
	52:  int8(49),
	53:  int8(49),
	54:  int8(12),
	55:  int8(19),
	56:  int8(4),
	57:  int8(8),
	58:  int8(12),
	59:  int8(50),
	60:  int8(51),
	61:  int8(7),
	62:  int8(53),
	63:  int8(23),
	64:  int8(28),
	65:  int8(42),
	66:  int8(3),
	67:  int8(12),
	68:  int8(23),
	69:  int8(51),
	70:  int8(50),
	71:  int8(23),
	72:  int8(37),
	73:  int8(29),
	74:  int8(12),
	75:  int8(12),
	76:  int8(8),
	77:  int8(12),
	78:  int8(12),
	79:  int8(51),
	80:  int8(51),
	81:  int8(8),
	82:  int8(50),
	83:  int8(12),
	84:  int8(19),
	85:  int8(34),
	86:  int8(44),
	87:  int8(4),
	88:  int8(12),
	89:  int8(51),
	90:  int8(50),
	91:  int8(12),
	92:  int8(12),
	93:  int8(24),
	94:  int8(26),
	95:  int8(26),
	96:  int8(27),
	97:  int8(4),
	98:  int8(50),
	99:  int8(12),
	100: int8(12),
	101: int8(12),
	102: int8(12),
}

// C documentation
//
//	/* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM.  */
var _yyr1 = [73]Tyytype_int8{
	1:  int8(31),
	2:  int8(32),
	3:  int8(32),
	4:  int8(33),
	5:  int8(33),
	6:  int8(33),
	7:  int8(33),
	8:  int8(33),
	9:  int8(33),
	10: int8(33),
	11: int8(33),
	12: int8(33),
	13: int8(34),
	14: int8(34),
	15: int8(35),
	16: int8(35),
	17: int8(36),
	18: int8(36),
	19: int8(36),
	20: int8(36),
	21: int8(36),
	22: int8(36),
	23: int8(37),
	24: int8(37),
	25: int8(38),
	26: int8(38),
	27: int8(38),
	28: int8(38),
	29: int8(38),
	30: int8(38),
	31: int8(39),
	32: int8(40),
	33: int8(40),
	34: int8(40),
	35: int8(40),
	36: int8(40),
	37: int8(40),
	38: int8(40),
	39: int8(40),
	40: int8(40),
	41: int8(41),
	42: int8(41),
	43: int8(42),
	44: int8(42),
	45: int8(43),
	46: int8(43),
	47: int8(43),
	48: int8(44),
	49: int8(44),
	50: int8(45),
	51: int8(45),
	52: int8(45),
	53: int8(46),
	54: int8(47),
	55: int8(47),
	56: int8(48),
	57: int8(48),
	58: int8(48),
	59: int8(48),
	60: int8(48),
	61: int8(48),
	62: int8(49),
	63: int8(49),
	64: int8(50),
	65: int8(50),
	66: int8(50),
	67: int8(51),
	68: int8(51),
	69: int8(51),
	70: int8(52),
	71: int8(53),
	72: int8(53),
}

// C documentation
//
//	/* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM.  */
var _yyr2 = [73]Tyytype_int8{
	1:  int8(2),
	3:  int8(2),
	4:  int8(1),
	5:  int8(1),
	6:  int8(1),
	7:  int8(1),
	8:  int8(1),
	9:  int8(1),
	10: int8(1),
	11: int8(1),
	12: int8(1),
	13: int8(5),
	14: int8(3),
	15: int8(2),
	16: int8(2),
	17: int8(2),
	18: int8(1),
	19: int8(1),
	20: int8(3),
	21: int8(3),
	22: int8(2),
	23: int8(1),
	24: int8(2),
	25: int8(1),
	26: int8(2),
	27: int8(2),
	28: int8(4),
	29: int8(3),
	30: int8(2),
	31: int8(5),
	32: int8(3),
	33: int8(5),
	34: int8(1),
	35: int8(5),
	36: int8(2),
	37: int8(4),
	38: int8(2),
	39: int8(1),
	40: int8(3),
	41: int8(2),
	42: int8(3),
	43: int8(1),
	44: int8(1),
	45: int8(1),
	46: int8(1),
	47: int8(1),
	48: int8(1),
	49: int8(1),
	50: int8(3),
	51: int8(2),
	52: int8(2),
	53: int8(4),
	54: int8(2),
	55: int8(1),
	56: int8(4),
	57: int8(3),
	58: int8(2),
	59: int8(2),
	60: int8(3),
	61: int8(1),
	62: int8(1),
	63: int8(1),
	64: int8(1),
	65: int8(1),
	66: int8(1),
	67: int8(1),
	68: int8(1),
	69: int8(1),
	70: int8(1),
	72: int8(1),
}

const YYENOMEM = -2

/* Backward compatibility with an undocumented macro.
   Use YYerror or YYUNDEF. */

/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
   If N is 0, then set CURRENT to the empty location which ends
   the previous symbol: RHS[0] (always defined).  */

/* Enable debugging if requested.  */

/* YYINITDEPTH -- initial size of the parser's stacks.  */

/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
   if the built-in stack extension method is used).

   Do not make this value too large; the results are undefined if
   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
   evaluated with infinite-precision integer arithmetic.  */

/*-----------------------------------------------.
| Release the memory associated to this symbol.  |
`-----------------------------------------------*/

func _yydestruct(tls *libc.TLS, yymsg uintptr, yykind Tyysymbol_kind_t, yyvaluep uintptr, yylocationp uintptr, info uintptr) {
	_ = yyvaluep
	_ = yylocationp
	_ = info
	if !(yymsg != 0) {
		yymsg = __ccgo_ts + 25207
	}
	_ = yykind
}

/*----------.
| yyparse.  |
`----------*/

func XTclDateparse(tls *libc.TLS, info uintptr) (r int32) {
	bp := tls.Alloc(5040)
	defer tls.Free(5040)
	var TclDatenerrs, yychar, yyerrstatus, yyi, yylen, yylhs, yyn, yyresult, v1, v10, v13, v14, v15, v4, v5, v8, v9 int32
	var yyerror_range [3]TYYLTYPE
	var yyloc TYYLTYPE
	var yyls, yylsp, yyptr, yyss, yyss1, yyssp, yyvs, yyvsp, v12, v2, v3, v6, v7 uintptr
	var yynewbytes, yynewbytes1, yynewbytes2, yysize, yystacksize int64
	var yystate Tyy_state_fast_t
	var yytoken Tyysymbol_kind_t
	var _ /* yylloc at bp+8 */ TYYLTYPE
	var _ /* yylsa at bp+1824 */ [200]TYYLTYPE
	var _ /* yylval at bp+0 */ TYYSTYPE
	var _ /* yyssa at bp+24 */ [200]Tyy_state_t
	var _ /* yyval at bp+5024 */ TYYSTYPE
	var _ /* yyvsa at bp+224 */ [200]TYYSTYPE
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = TclDatenerrs, yychar, yyerror_range, yyerrstatus, yyi, yylen, yylhs, yyloc, yyls, yylsp, yyn, yynewbytes, yynewbytes1, yynewbytes2, yyptr, yyresult, yysize, yyss, yyss1, yyssp, yystacksize, yystate, yytoken, yyvs, yyvsp, v1, v10, v12, v13, v14, v15, v2, v3, v4, v5, v6, v7, v8, v9
	*(*TYYLTYPE)(unsafe.Pointer(bp + 8)) = _yyloc_default
	/* Number of syntax errors so far.  */
	TclDatenerrs = 0
	yystate = 0
	/* Number of tokens to shift before error messages enabled.  */
	yyerrstatus = 0
	/* Refer to the stacks through separate pointers, to allow yyoverflow
	   to reallocate them elsewhere.  */
	/* Their size.  */
	yystacksize = int64(YYINITDEPTH)
	yyss = bp + 24
	yyssp = yyss
	yyvs = bp + 224
	yyvsp = yyvs
	yyls = bp + 1824
	yylsp = yyls
	/* Lookahead symbol kind.  */
	yytoken = int32(YYSYMBOL_YYEMPTY)
	/* The number of symbols on the RHS of the reduced rule.
	   Keep to zero when no symbol should be popped.  */
	yylen = 0
	yychar = int32(YYEMPTY) /* Cause a token to be read.  */
	*(*TYYLTYPE)(unsafe.Pointer(yylsp)) = *(*TYYLTYPE)(unsafe.Pointer(bp + 8))
	goto yysetstate
	/*
	   ------------------------------------------------------------.
	   | yynewstate -- push a new state, which is found in yystate.  |
	   `------------------------------------------------------------
	*/
	goto yynewstate
yynewstate:
	;
	/* In all cases, when you get here, the value and location stacks
	   have just been pushed.  So pushing a state here evens the stacks.  */
	yyssp++
	/*
	   --------------------------------------------------------------------.
	   | yysetstate -- set current state (the top of the stack) to yystate.  |
	   `--------------------------------------------------------------------
	*/
	goto yysetstate
yysetstate:
	;
	_ = libc.Bool(0 != 0) && (0 <= yystate && yystate < int32(YYNSTATES))
	*(*Tyy_state_t)(unsafe.Pointer(yyssp)) = int8(yystate)
	if yyss+uintptr(yystacksize)-uintptr(1) <= yyssp {
		/* Get the current used size of the three stacks, in elements.  */
		yysize = int64(yyssp) - int64(yyss) + int64(1)
		/* Extend the stack our own way.  */
		if int64(YYMAXDEPTH) <= yystacksize {
			goto yyexhaustedlab
		}
		yystacksize *= int64(2)
		if int64(YYMAXDEPTH) < yystacksize {
			yystacksize = int64(YYMAXDEPTH)
		}
		yyss1 = yyss
		yyptr = XTcl_Alloc(tls, libc.Uint64FromInt64(yystacksize*(libc.Int64FromUint64(libc.Uint64FromInt64(1))+libc.Int64FromUint64(libc.Uint64FromInt64(8))+libc.Int64FromUint64(libc.Uint64FromInt64(16)))+libc.Int64FromInt32(2)*(libc.Int64FromUint64(libc.Uint64FromInt64(16))-libc.Int64FromInt32(1))))
		if !(yyptr != 0) {
			goto yyexhaustedlab
		}
		libc.X__builtin_memcpy(tls, yyptr, yyss, libc.Uint64FromInt64(yysize)*uint64(1))
		yyss = yyptr
		yynewbytes = yystacksize*libc.Int64FromUint64(libc.Uint64FromInt64(1)) + (libc.Int64FromUint64(libc.Uint64FromInt64(16)) - libc.Int64FromInt32(1))
		yyptr += uintptr(yynewbytes/libc.Int64FromUint64(libc.Uint64FromInt64(16))) * 16
		libc.X__builtin_memcpy(tls, yyptr, yyvs, libc.Uint64FromInt64(yysize)*uint64(8))
		yyvs = yyptr
		yynewbytes1 = yystacksize*libc.Int64FromUint64(libc.Uint64FromInt64(8)) + (libc.Int64FromUint64(libc.Uint64FromInt64(16)) - libc.Int64FromInt32(1))
		yyptr += uintptr(yynewbytes1/libc.Int64FromUint64(libc.Uint64FromInt64(16))) * 16
		libc.X__builtin_memcpy(tls, yyptr, yyls, libc.Uint64FromInt64(yysize)*uint64(16))
		yyls = yyptr
		yynewbytes2 = yystacksize*libc.Int64FromUint64(libc.Uint64FromInt64(16)) + (libc.Int64FromUint64(libc.Uint64FromInt64(16)) - libc.Int64FromInt32(1))
		yyptr += uintptr(yynewbytes2/libc.Int64FromUint64(libc.Uint64FromInt64(16))) * 16
		if yyss1 != bp+24 {
			XTclpFree(tls, yyss1)
		}
		yyssp = yyss + uintptr(yysize) - uintptr(1)
		yyvsp = yyvs + uintptr(yysize)*8 - uintptr(1)*8
		yylsp = yyls + uintptr(yysize)*16 - uintptr(1)*16
		if yyss+uintptr(yystacksize)-uintptr(1) <= yyssp {
			goto yyabortlab
		}
	}
	if yystate == int32(YYFINAL) {
		goto yyacceptlab
	}
	goto yybackup
	/*
	   -----------.
	   | yybackup.  |
	   `-----------
	*/
	goto yybackup
yybackup:
	;
	/* Do appropriate processing given the current state.  Read a
	   lookahead token if we need one and don't already have one.  */
	/* First try to decide what to do without reference to lookahead token.  */
	yyn = int32(_yypact[yystate])
	if yyn == -int32(21) {
		goto yydefault
	}
	/* Not known => get a lookahead token if don't already have one.  */
	/* YYCHAR is either empty, or end-of-input, or a valid lookahead.  */
	if yychar == int32(YYEMPTY) {
		yychar = _TclDatelex(tls, bp, bp+8, info)
	}
	if yychar <= int32(YYEOF) {
		yychar = int32(YYEOF)
		yytoken = int32(YYSYMBOL_YYEOF)
	} else {
		if yychar == int32(YYerror) {
			/* The scanner already issued an error message, process directly
			   to error recovery.  But do not keep the error token as
			   lookahead, it is too special and may lead us to an endless
			   loop in error recovery. */
			yychar = int32(YYUNDEF)
			yytoken = int32(YYSYMBOL_YYerror)
			yyerror_range[int32(1)] = *(*TYYLTYPE)(unsafe.Pointer(bp + 8))
			goto yyerrlab1
		} else {
			if 0 <= yychar && yychar <= int32(YYMAXUTOK) {
				v1 = int32(_yytranslate[yychar])
			} else {
				v1 = int32(YYSYMBOL_YYUNDEF)
			}
			yytoken = v1
		}
	}
	/* If the proper action on seeing token YYTOKEN is to reduce or to
	   detect an error, take that action.  */
	yyn += yytoken
	if yyn < 0 || int32(YYLAST) < yyn || int32(_yycheck[yyn]) != yytoken {
		goto yydefault
	}
	yyn = int32(_yytable[yyn])
	if yyn <= 0 {
		if 0 != 0 {
			goto yyerrlab
		}
		yyn = -yyn
		goto yyreduce
	}
	/* Count tokens shifted since error; after three, turn off error
	   status.  */
	if yyerrstatus != 0 {
		yyerrstatus--
	}
	/* Shift the lookahead token.  */
	yystate = yyn
	yyvsp += 8
	v2 = yyvsp
	*(*TYYSTYPE)(unsafe.Pointer(v2)) = *(*TYYSTYPE)(unsafe.Pointer(bp))
	yylsp += 16
	v3 = yylsp
	*(*TYYLTYPE)(unsafe.Pointer(v3)) = *(*TYYLTYPE)(unsafe.Pointer(bp + 8))
	/* Discard the shifted token.  */
	yychar = int32(YYEMPTY)
	goto yynewstate
	/*
	   -----------------------------------------------------------.
	   | yydefault -- do the default action for the current state.  |
	   `-----------------------------------------------------------
	*/
	goto yydefault
yydefault:
	;
	yyn = int32(_yydefact[yystate])
	if yyn == 0 {
		goto yyerrlab
	}
	goto yyreduce
	/*
	   -----------------------------.
	   | yyreduce -- do a reduction.  |
	   `-----------------------------
	*/
	goto yyreduce
yyreduce:
	;
	/* yyn is the number of a rule to reduce with.  */
	yylen = int32(_yyr2[yyn])
	/* If YYLEN is nonzero, implement the default value of the action:
	   '$$ = $1'.
	   Otherwise, the following line sets YYVAL to garbage.
	   This behavior is undocumented and Bison
	   users should not rely upon it.  Assigning to YYVAL
	   unconditionally makes the parser a bit smaller, and it avoids a
	   GCC warning that YYVAL may be used uninitialized.  */
	*(*TYYSTYPE)(unsafe.Pointer(bp + 5024)) = *(*TYYSTYPE)(unsafe.Pointer(yyvsp + uintptr(int32(1)-yylen)*8))
	/* Default location. */
	if yylen != 0 {
		yyloc.Ffirst_line = (*(*TYYLTYPE)(unsafe.Pointer(yylsp - uintptr(yylen)*16 + 1*16))).Ffirst_line
		yyloc.Ffirst_column = (*(*TYYLTYPE)(unsafe.Pointer(yylsp - uintptr(yylen)*16 + 1*16))).Ffirst_column
		yyloc.Flast_line = (*(*TYYLTYPE)(unsafe.Pointer(yylsp - uintptr(yylen)*16 + uintptr(yylen)*16))).Flast_line
		yyloc.Flast_column = (*(*TYYLTYPE)(unsafe.Pointer(yylsp - uintptr(yylen)*16 + uintptr(yylen)*16))).Flast_column
	} else {
		v4 = (*(*TYYLTYPE)(unsafe.Pointer(yylsp - uintptr(yylen)*16))).Flast_line
		yyloc.Flast_line = v4
		yyloc.Ffirst_line = v4
		v5 = (*(*TYYLTYPE)(unsafe.Pointer(yylsp - uintptr(yylen)*16))).Flast_column
		yyloc.Flast_column = v5
		yyloc.Ffirst_column = v5
	}
	yyerror_range[int32(1)] = yyloc
	switch yyn {
	case int32(4): /* item: time  */
		*(*int32)(unsafe.Pointer(info + 140)) |= (*TDateInfo)(unsafe.Pointer(info)).Fflags & int32(CLF_TIME)
		if (*TDateInfo)(unsafe.Pointer(info)).FerrFlags != 0 {
			goto yyabortlab
		}
		*(*int32)(unsafe.Pointer(info + 136)) |= int32(CLF_TIME)
	case int32(5): /* item: zone  */
		*(*int32)(unsafe.Pointer(info + 140)) |= (*TDateInfo)(unsafe.Pointer(info)).Fflags & int32(CLF_ZONE)
		if (*TDateInfo)(unsafe.Pointer(info)).FerrFlags != 0 {
			goto yyabortlab
		}
		*(*int32)(unsafe.Pointer(info + 136)) |= int32(CLF_ZONE)
	case int32(6): /* item: date  */
		*(*int32)(unsafe.Pointer(info + 140)) |= (*TDateInfo)(unsafe.Pointer(info)).Fflags & int32(CLF_HAVEDATE)
		if (*TDateInfo)(unsafe.Pointer(info)).FerrFlags != 0 {
			goto yyabortlab
		}
		*(*int32)(unsafe.Pointer(info + 136)) |= int32(CLF_HAVEDATE)
	case int32(7): /* item: ordMonth  */
		*(*int32)(unsafe.Pointer(info + 140)) |= (*TDateInfo)(unsafe.Pointer(info)).Fflags & int32(CLF_ORDINALMONTH)
		if (*TDateInfo)(unsafe.Pointer(info)).FerrFlags != 0 {
			goto yyabortlab
		}
		*(*int32)(unsafe.Pointer(info + 136)) |= int32(CLF_ORDINALMONTH)
	case int32(8): /* item: day  */
		*(*int32)(unsafe.Pointer(info + 140)) |= (*TDateInfo)(unsafe.Pointer(info)).Fflags & int32(CLF_DAYOFWEEK)
		if (*TDateInfo)(unsafe.Pointer(info)).FerrFlags != 0 {
			goto yyabortlab
		}
		*(*int32)(unsafe.Pointer(info + 136)) |= int32(CLF_DAYOFWEEK)
	case int32(9): /* item: relspec  */
		*(*int32)(unsafe.Pointer(info + 136)) |= int32(CLF_RELCONV)
	case int32(10): /* item: iso  */
		*(*int32)(unsafe.Pointer(info + 140)) |= (*TDateInfo)(unsafe.Pointer(info)).Fflags & (int32(CLF_TIME) | int32(CLF_HAVEDATE))
		if (*TDateInfo)(unsafe.Pointer(info)).FerrFlags != 0 {
			goto yyabortlab
		}
		*(*int32)(unsafe.Pointer(info + 136)) |= int32(CLF_TIME) | int32(CLF_HAVEDATE)
	case int32(11): /* item: trek  */
		*(*int32)(unsafe.Pointer(info + 140)) |= (*TDateInfo)(unsafe.Pointer(info)).Fflags & (int32(CLF_TIME) | int32(CLF_HAVEDATE))
		if (*TDateInfo)(unsafe.Pointer(info)).FerrFlags != 0 {
			goto yyabortlab
		}
		*(*int32)(unsafe.Pointer(info + 136)) |= int32(CLF_TIME) | int32(CLF_HAVEDATE)
		*(*int32)(unsafe.Pointer(info + 136)) |= int32(CLF_RELCONV)
	case int32(13): /* iextime: tUNUMBER ':' tUNUMBER ':' tUNUMBER  */
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fhour = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(4))*8)))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fminutes = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(2))*8)))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FsecondOfMin = *(*TTcl_WideInt)(unsafe.Pointer(yyvsp))
	case int32(14): /* iextime: tUNUMBER ':' tUNUMBER  */
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fhour = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(2))*8)))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fminutes = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FsecondOfMin = 0
	case int32(15): /* time: tUNUMBER tMERIDIAN  */
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fhour = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(1))*8)))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fminutes = 0
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FsecondOfMin = 0
		(*TDateInfo)(unsafe.Pointer(info)).FdateMeridian = *(*_MERIDIAN)(unsafe.Pointer(&*(*TYYSTYPE)(unsafe.Pointer(yyvsp))))
	case int32(16): /* time: iextime o_merid  */
		(*TDateInfo)(unsafe.Pointer(info)).FdateMeridian = *(*_MERIDIAN)(unsafe.Pointer(&*(*TYYSTYPE)(unsafe.Pointer(yyvsp))))
	case int32(17): /* zone: tZONE tDST  */
		(*TDateInfo)(unsafe.Pointer(info)).FdateTimezone = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(1))*8)))
		(*TDateInfo)(unsafe.Pointer(info)).FdateDSTmode = int32(DSTon)
	case int32(18): /* zone: tZONE  */
		(*TDateInfo)(unsafe.Pointer(info)).FdateTimezone = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)))
		(*TDateInfo)(unsafe.Pointer(info)).FdateDSTmode = int32(DSToff)
	case int32(19): /* zone: tDAYZONE  */
		(*TDateInfo)(unsafe.Pointer(info)).FdateTimezone = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)))
		(*TDateInfo)(unsafe.Pointer(info)).FdateDSTmode = int32(DSTon)
	case int32(20): /* zone: tZONEwO4 sign INTNUM  */
		/* GMT+0100, GMT-1000, etc. */
		(*TDateInfo)(unsafe.Pointer(info)).FdateTimezone = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(2))*8)) - *(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(1))*8))*(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp))%int64(100)+*(*TTcl_WideInt)(unsafe.Pointer(yyvsp))/int64(100)*int64(60)))
		(*TDateInfo)(unsafe.Pointer(info)).FdateDSTmode = int32(DSToff)
	case int32(21): /* zone: tZONEwO2 sign INTNUM  */
		/* GMT+1, GMT-10, etc. */
		(*TDateInfo)(unsafe.Pointer(info)).FdateTimezone = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(2))*8)) - *(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(1))*8))*(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp))*int64(60)))
		(*TDateInfo)(unsafe.Pointer(info)).FdateDSTmode = int32(DSToff)
	case int32(22): /* zone: sign INTNUM  */
		/* +0100, -0100 */
		(*TDateInfo)(unsafe.Pointer(info)).FdateTimezone = int32(-*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(1))*8)) * (*(*TTcl_WideInt)(unsafe.Pointer(yyvsp))%int64(100) + *(*TTcl_WideInt)(unsafe.Pointer(yyvsp))/int64(100)*int64(60)))
		(*TDateInfo)(unsafe.Pointer(info)).FdateDSTmode = int32(DSToff)
	case int32(25): /* day: tDAY  */
		(*TDateInfo)(unsafe.Pointer(info)).FdateDayOrdinal = int32(1)
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfWeek = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)))
	case int32(26): /* day: tDAY comma  */
		(*TDateInfo)(unsafe.Pointer(info)).FdateDayOrdinal = int32(1)
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfWeek = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(1))*8)))
	case int32(27): /* day: tUNUMBER tDAY  */
		(*TDateInfo)(unsafe.Pointer(info)).FdateDayOrdinal = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(1))*8)))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfWeek = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)))
	case int32(28): /* day: sign SP tUNUMBER tDAY  */
		(*TDateInfo)(unsafe.Pointer(info)).FdateDayOrdinal = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(3))*8)) * *(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(1))*8)))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfWeek = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)))
	case int32(29): /* day: sign tUNUMBER tDAY  */
		(*TDateInfo)(unsafe.Pointer(info)).FdateDayOrdinal = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(2))*8)) * *(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(1))*8)))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfWeek = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)))
	case int32(30): /* day: tNEXT tDAY  */
		(*TDateInfo)(unsafe.Pointer(info)).FdateDayOrdinal = int32(2)
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfWeek = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)))
	case int32(31): /* iexdate: tUNUMBER '-' tUNUMBER '-' tUNUMBER  */
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fmonth = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(2))*8)))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfMonth = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fyear = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(4))*8)))
	case int32(32): /* date: tUNUMBER '/' tUNUMBER  */
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fmonth = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(2))*8)))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfMonth = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)))
	case int32(33): /* date: tUNUMBER '/' tUNUMBER '/' tUNUMBER  */
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fmonth = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(4))*8)))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfMonth = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(2))*8)))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fyear = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)))
	case int32(35): /* date: tUNUMBER '-' tMONTH '-' tUNUMBER  */
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfMonth = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(4))*8)))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fmonth = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(2))*8)))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fyear = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)))
	case int32(36): /* date: tMONTH tUNUMBER  */
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fmonth = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(1))*8)))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfMonth = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)))
	case int32(37): /* date: tMONTH tUNUMBER comma tUNUMBER  */
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fmonth = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(3))*8)))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfMonth = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(2))*8)))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fyear = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)))
	case int32(38): /* date: tUNUMBER tMONTH  */
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fmonth = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfMonth = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(1))*8)))
	case int32(39): /* date: tEPOCH  */
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fmonth = int32(1)
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfMonth = int32(1)
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fyear = int32(EPOCH)
	case int32(40): /* date: tUNUMBER tMONTH tUNUMBER  */
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fmonth = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(1))*8)))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfMonth = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(2))*8)))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fyear = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)))
	case int32(41): /* ordMonth: tNEXT tMONTH  */
		(*TDateInfo)(unsafe.Pointer(info)).FdateMonthOrdinalIncr = int32(1)
		(*TDateInfo)(unsafe.Pointer(info)).FdateMonthOrdinal = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)))
	case int32(42): /* ordMonth: tNEXT tUNUMBER tMONTH  */
		(*TDateInfo)(unsafe.Pointer(info)).FdateMonthOrdinalIncr = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(1))*8)))
		(*TDateInfo)(unsafe.Pointer(info)).FdateMonthOrdinal = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)))
	case int32(45): /* isodate: tISOBAS8  */
		/* YYYYMMDD */
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fyear = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)) / int64(10000))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fmonth = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)) % int64(10000) / int64(100))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfMonth = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)) % int64(100))
	case int32(46): /* isodate: tISOBAS6  */
		/* YYMMDD */
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fyear = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)) / int64(10000))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fmonth = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)) % int64(10000) / int64(100))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfMonth = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)) % int64(100))
	case int32(48): /* isotime: tISOBAS6  */
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fhour = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)) / int64(10000))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fminutes = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)) % int64(10000) / int64(100))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FsecondOfMin = *(*TTcl_WideInt)(unsafe.Pointer(yyvsp)) % int64(100)
	case int32(51): /* iso: tISOBASL tISOBAS6  */
		/* YYYYMMDDhhmmss */
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fyear = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(1))*8)) / int64(10000))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fmonth = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(1))*8)) % int64(10000) / int64(100))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfMonth = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(1))*8)) % int64(100))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fhour = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)) / int64(10000))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fminutes = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)) % int64(10000) / int64(100))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FsecondOfMin = *(*TTcl_WideInt)(unsafe.Pointer(yyvsp)) % int64(100)
	case int32(52): /* iso: tISOBASL tUNUMBER  */
		/* YYYYMMDDhhmm */
		if (*TDateInfo)(unsafe.Pointer(info)).FdateDigitCount != int32(4) {
			goto yyabortlab
		} /* normally unreached */
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fyear = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(1))*8)) / int64(10000))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fmonth = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(1))*8)) % int64(10000) / int64(100))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfMonth = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(1))*8)) % int64(100))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fhour = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)) / int64(100))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fminutes = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)) % libc.Int64FromInt32(100))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FsecondOfMin = 0
	case int32(53): /* trek: tSTARDATE INTNUM '.' tUNUMBER  */
		/*
		 * Offset computed year by -377 so that the returned years will be
		 * in a range accessible with a 32 bit clock seconds value.
		 */
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fyear = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(2))*8))/int64(1000) + int64(2323) - int64(377))
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.FdayOfMonth = int32(1)
		(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fmonth = int32(1)
		*(*TTcl_WideInt)(unsafe.Pointer(info + 168)) += *(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(2))*8)) % int64(1000) * int64(libc.Int32FromInt32(365)+libc.BoolInt32((*TDateInfo)(unsafe.Pointer(info)).Fdate.Fyear%int32(4) == 0 && ((*TDateInfo)(unsafe.Pointer(info)).Fdate.Fyear%int32(100) != 0 || (*TDateInfo)(unsafe.Pointer(info)).Fdate.Fyear%int32(400) == 0))) / int64(1000)
		*(*TTcl_WideInt)(unsafe.Pointer(info + 176)) += *(*TTcl_WideInt)(unsafe.Pointer(yyvsp)) * (libc.Int64FromInt64(144) * libc.Int64FromInt64(60))
	case int32(54): /* relspec: relunits tAGO  */
		*(*TTcl_WideInt)(unsafe.Pointer(info + 176)) *= int64(-int32(1))
		*(*TTcl_WideInt)(unsafe.Pointer(info + 160)) *= int64(-int32(1))
		*(*TTcl_WideInt)(unsafe.Pointer(info + 168)) *= int64(-int32(1))
	case int32(56): /* relunits: sign SP INTNUM unit  */
		*(*TTcl_WideInt)(unsafe.Pointer((*TDateInfo)(unsafe.Pointer(info)).FdateRelPointer)) += *(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(3))*8)) * *(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(1))*8)) * *(*TTcl_WideInt)(unsafe.Pointer(yyvsp))
	case int32(57): /* relunits: sign INTNUM unit  */
		*(*TTcl_WideInt)(unsafe.Pointer((*TDateInfo)(unsafe.Pointer(info)).FdateRelPointer)) += *(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(2))*8)) * *(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(1))*8)) * *(*TTcl_WideInt)(unsafe.Pointer(yyvsp))
	case int32(58): /* relunits: INTNUM unit  */
		*(*TTcl_WideInt)(unsafe.Pointer((*TDateInfo)(unsafe.Pointer(info)).FdateRelPointer)) += *(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(1))*8)) * *(*TTcl_WideInt)(unsafe.Pointer(yyvsp))
	case int32(59): /* relunits: tNEXT unit  */
		*(*TTcl_WideInt)(unsafe.Pointer((*TDateInfo)(unsafe.Pointer(info)).FdateRelPointer)) += *(*TTcl_WideInt)(unsafe.Pointer(yyvsp))
	case int32(60): /* relunits: tNEXT INTNUM unit  */
		*(*TTcl_WideInt)(unsafe.Pointer((*TDateInfo)(unsafe.Pointer(info)).FdateRelPointer)) += *(*TTcl_WideInt)(unsafe.Pointer(yyvsp + uintptr(-libc.Int32FromInt32(1))*8)) * *(*TTcl_WideInt)(unsafe.Pointer(yyvsp))
	case int32(61): /* relunits: unit  */
		*(*TTcl_WideInt)(unsafe.Pointer((*TDateInfo)(unsafe.Pointer(info)).FdateRelPointer)) += *(*TTcl_WideInt)(unsafe.Pointer(yyvsp))
	case int32(62): /* sign: '-'  */
		*(*TTcl_WideInt)(unsafe.Pointer(bp + 5024)) = int64(-int32(1))
	case int32(63): /* sign: '+'  */
		*(*TTcl_WideInt)(unsafe.Pointer(bp + 5024)) = int64(1)
	case int32(64): /* unit: tSEC_UNIT  */
		*(*TTcl_WideInt)(unsafe.Pointer(bp + 5024)) = *(*TTcl_WideInt)(unsafe.Pointer(yyvsp))
		(*TDateInfo)(unsafe.Pointer(info)).FdateRelPointer = info + 176
	case int32(65): /* unit: tDAY_UNIT  */
		*(*TTcl_WideInt)(unsafe.Pointer(bp + 5024)) = *(*TTcl_WideInt)(unsafe.Pointer(yyvsp))
		(*TDateInfo)(unsafe.Pointer(info)).FdateRelPointer = info + 168
	case int32(66): /* unit: tMONTH_UNIT  */
		*(*TTcl_WideInt)(unsafe.Pointer(bp + 5024)) = *(*TTcl_WideInt)(unsafe.Pointer(yyvsp))
		(*TDateInfo)(unsafe.Pointer(info)).FdateRelPointer = info + 160
	case int32(67): /* INTNUM: tUNUMBER  */
		*(*TTcl_WideInt)(unsafe.Pointer(bp + 5024)) = *(*TTcl_WideInt)(unsafe.Pointer(yyvsp))
	case int32(68): /* INTNUM: tISOBAS6  */
		*(*TTcl_WideInt)(unsafe.Pointer(bp + 5024)) = *(*TTcl_WideInt)(unsafe.Pointer(yyvsp))
	case int32(69): /* INTNUM: tISOBAS8  */
		*(*TTcl_WideInt)(unsafe.Pointer(bp + 5024)) = *(*TTcl_WideInt)(unsafe.Pointer(yyvsp))
	case int32(70): /* numitem: tUNUMBER  */
		if (*TDateInfo)(unsafe.Pointer(info)).Fflags&(int32(CLF_TIME)|int32(CLF_HAVEDATE)|int32(CLF_RELCONV)) == int32(CLF_TIME)|int32(CLF_HAVEDATE) {
			(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fyear = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)))
		} else {
			*(*int32)(unsafe.Pointer(info + 140)) |= (*TDateInfo)(unsafe.Pointer(info)).Fflags & int32(CLF_TIME)
			if (*TDateInfo)(unsafe.Pointer(info)).FerrFlags != 0 {
				goto yyabortlab
			}
			*(*int32)(unsafe.Pointer(info + 136)) |= int32(CLF_TIME)
			if (*TDateInfo)(unsafe.Pointer(info)).FdateDigitCount <= int32(2) {
				(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fhour = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)))
				(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fminutes = 0
			} else {
				(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fhour = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)) / int64(100))
				(*TDateInfo)(unsafe.Pointer(info)).Fdate.Fminutes = int32(*(*TTcl_WideInt)(unsafe.Pointer(yyvsp)) % int64(100))
			}
			(*TDateInfo)(unsafe.Pointer(info)).Fdate.FsecondOfMin = 0
			(*TDateInfo)(unsafe.Pointer(info)).FdateMeridian = int32(MER24)
		}
	case int32(71): /* o_merid: %empty  */
		*(*_MERIDIAN)(unsafe.Pointer(&*(*TYYSTYPE)(unsafe.Pointer(bp + 5024)))) = int32(MER24)
	case int32(72): /* o_merid: tMERIDIAN  */
		*(*_MERIDIAN)(unsafe.Pointer(&*(*TYYSTYPE)(unsafe.Pointer(bp + 5024)))) = *(*_MERIDIAN)(unsafe.Pointer(&*(*TYYSTYPE)(unsafe.Pointer(yyvsp))))
	default:
		break
	}
	/* User semantic actions sometimes alter yychar, and that requires
	   that yytoken be updated with the new translation.  We take the
	   approach of translating immediately before every use of yytoken.
	   One alternative is translating here after every semantic action,
	   but that translation would be missed if the semantic action invokes
	   YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
	   if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
	   incorrect destructor might then be invoked immediately.  In the
	   case of YYERROR or YYBACKUP, subsequent parser actions might lead
	   to an incorrect destructor call or verbose syntax error message
	   before the lookahead is translated.  */
	yyvsp -= uintptr(yylen) * 8
	yyssp -= uintptr(yylen)
	yylsp -= uintptr(yylen) * 16
	yylen = 0
	yyvsp += 8
	v6 = yyvsp
	*(*TYYSTYPE)(unsafe.Pointer(v6)) = *(*TYYSTYPE)(unsafe.Pointer(bp + 5024))
	yylsp += 16
	v7 = yylsp
	*(*TYYLTYPE)(unsafe.Pointer(v7)) = yyloc
	/* Now 'shift' the result of the reduction.  Determine what state
	   that goes to, based on the state we popped back to and the rule
	   number reduced by.  */
	yylhs = int32(_yyr1[yyn]) - int32(YYNTOKENS)
	yyi = int32(_yypgoto[yylhs]) + int32(*(*Tyy_state_t)(unsafe.Pointer(yyssp)))
	if 0 <= yyi && yyi <= int32(YYLAST) && int32(_yycheck[yyi]) == int32(*(*Tyy_state_t)(unsafe.Pointer(yyssp))) {
		v8 = int32(_yytable[yyi])
	} else {
		v8 = int32(_yydefgoto[yylhs])
	}
	yystate = v8
	goto yynewstate
	/*
	   --------------------------------------.
	   | yyerrlab -- here on detecting error.  |
	   `--------------------------------------
	*/
	goto yyerrlab
yyerrlab:
	;
	/* Make sure we have latest lookahead translation.  See comments at
	   user semantic actions for why this is necessary.  */
	if yychar == int32(YYEMPTY) {
		v9 = int32(YYSYMBOL_YYEMPTY)
	} else {
		if 0 <= yychar && yychar <= int32(YYMAXUTOK) {
			v10 = int32(_yytranslate[yychar])
		} else {
			v10 = int32(YYSYMBOL_YYUNDEF)
		}
		v9 = v10
	}
	yytoken = v9
	/* If not already recovering from an error, report this error.  */
	if !(yyerrstatus != 0) {
		TclDatenerrs++
		_TclDateerror(tls, bp+8, info, __ccgo_ts+25216)
	}
	yyerror_range[int32(1)] = *(*TYYLTYPE)(unsafe.Pointer(bp + 8))
	if yyerrstatus == int32(3) {
		/* If just tried and failed to reuse lookahead token after an
		   error, discard it.  */
		if yychar <= int32(YYEOF) {
			/* Return failure if at end of input.  */
			if yychar == int32(YYEOF) {
				goto yyabortlab
			}
		} else {
			_yydestruct(tls, __ccgo_ts+25229, yytoken, bp, bp+8, info)
			yychar = int32(YYEMPTY)
		}
	}
	/* Else will try to reuse lookahead token after shifting the error
	   token.  */
	goto yyerrlab1
	/*
	   ---------------------------------------------------.
	   | yyerrorlab -- error raised explicitly by YYERROR.  |
	   `---------------------------------------------------
	*/
	goto yyerrorlab
yyerrorlab:
	;
	/* Pacify compilers when the user code never invokes YYERROR and the
	   label yyerrorlab therefore never appears in user code.  */
	if 0 != 0 {
		goto yyerrorlab
	}
	TclDatenerrs++
	/* Do not reclaim the symbols of the rule whose action triggered
	   this YYERROR.  */
	yyvsp -= uintptr(yylen) * 8
	yyssp -= uintptr(yylen)
	yylsp -= uintptr(yylen) * 16
	yylen = 0
	yystate = int32(*(*Tyy_state_t)(unsafe.Pointer(yyssp)))
	goto yyerrlab1
	/*
	   -------------------------------------------------------------.
	   | yyerrlab1 -- common code for both syntax error and YYERROR.  |
	   `-------------------------------------------------------------
	*/
	goto yyerrlab1
yyerrlab1:
	;
	yyerrstatus = int32(3) /* Each real token shifted decrements this.  */
	/* Pop stack until we find a state that shifts the error token.  */
	for {
		yyn = int32(_yypact[yystate])
		if !(yyn == -libc.Int32FromInt32(21)) {
			yyn += int32(YYSYMBOL_YYerror)
			if 0 <= yyn && yyn <= int32(YYLAST) && int32(_yycheck[yyn]) == int32(YYSYMBOL_YYerror) {
				yyn = int32(_yytable[yyn])
				if 0 < yyn {
					break
				}
			}
		}
		/* Pop the current state because it cannot handle the error token.  */
		if yyssp == yyss {
			goto yyabortlab
		}
		yyerror_range[int32(1)] = *(*TYYLTYPE)(unsafe.Pointer(yylsp))
		_yydestruct(tls, __ccgo_ts+25247, int32(_yystos[yystate]), yyvsp, yylsp, info)
		yyvsp -= uintptr(libc.Int32FromInt32(1)) * 8
		yyssp -= uintptr(libc.Int32FromInt32(1))
		yylsp -= uintptr(libc.Int32FromInt32(1)) * 16
		yystate = int32(*(*Tyy_state_t)(unsafe.Pointer(yyssp)))
		goto _11
	_11:
	}
	yyvsp += 8
	v12 = yyvsp
	*(*TYYSTYPE)(unsafe.Pointer(v12)) = *(*TYYSTYPE)(unsafe.Pointer(bp))
	yyerror_range[int32(2)] = *(*TYYLTYPE)(unsafe.Pointer(bp + 8))
	yylsp += 16
	if int32(2) != 0 {
		(*TYYLTYPE)(unsafe.Pointer(yylsp)).Ffirst_line = yyerror_range[int32(1)].Ffirst_line
		(*TYYLTYPE)(unsafe.Pointer(yylsp)).Ffirst_column = yyerror_range[int32(1)].Ffirst_column
		(*TYYLTYPE)(unsafe.Pointer(yylsp)).Flast_line = yyerror_range[int32(2)].Flast_line
		(*TYYLTYPE)(unsafe.Pointer(yylsp)).Flast_column = yyerror_range[int32(2)].Flast_column
	} else {
		v13 = yyerror_range[0].Flast_line
		(*TYYLTYPE)(unsafe.Pointer(yylsp)).Flast_line = v13
		(*TYYLTYPE)(unsafe.Pointer(yylsp)).Ffirst_line = v13
		v14 = yyerror_range[0].Flast_column
		(*TYYLTYPE)(unsafe.Pointer(yylsp)).Flast_column = v14
		(*TYYLTYPE)(unsafe.Pointer(yylsp)).Ffirst_column = v14
	}
	/* Shift the error token.  */
	yystate = yyn
	goto yynewstate
	/*
	   -------------------------------------.
	   | yyacceptlab -- YYACCEPT comes here.  |
	   `-------------------------------------
	*/
	goto yyacceptlab
yyacceptlab:
	;
	yyresult = 0
	goto yyreturnlab
	/*
	   -----------------------------------.
	   | yyabortlab -- YYABORT comes here.  |
	   `-----------------------------------
	*/
	goto yyabortlab
yyabortlab:
	;
	yyresult = int32(1)
	goto yyreturnlab
	/*
	   -----------------------------------------------------------.
	   | yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here.  |
	   `-----------------------------------------------------------
	*/
	goto yyexhaustedlab
yyexhaustedlab:
	;
	_TclDateerror(tls, bp+8, info, __ccgo_ts+25262)
	yyresult = int32(2)
	goto yyreturnlab
	/*
	   ----------------------------------------------------------.
	   | yyreturnlab -- parsing is finished, clean up and return.  |
	   `----------------------------------------------------------
	*/
	goto yyreturnlab
yyreturnlab:
	;
	if yychar != int32(YYEMPTY) {
		/* Make sure we have latest lookahead translation.  See comments at
		   user semantic actions for why this is necessary.  */
		if 0 <= yychar && yychar <= int32(YYMAXUTOK) {
			v15 = int32(_yytranslate[yychar])
		} else {
			v15 = int32(YYSYMBOL_YYUNDEF)
		}
		yytoken = v15
		_yydestruct(tls, __ccgo_ts+25279, yytoken, bp, bp+8, info)
	}
	/* Do not reclaim the symbols of the rule whose action triggered
	   this YYABORT or YYACCEPT.  */
	yyvsp -= uintptr(yylen) * 8
	yyssp -= uintptr(yylen)
	yylsp -= uintptr(yylen) * 16
	for yyssp != yyss {
		_yydestruct(tls, __ccgo_ts+25309, int32(_yystos[+int32(*(*Tyy_state_t)(unsafe.Pointer(yyssp)))]), yyvsp, yylsp, info)
		yyvsp -= uintptr(libc.Int32FromInt32(1)) * 8
		yyssp -= uintptr(libc.Int32FromInt32(1))
		yylsp -= uintptr(libc.Int32FromInt32(1)) * 16
	}
	if yyss != bp+24 {
		XTclpFree(tls, yyss)
	}
	return yyresult
}

/* Location data for the lookahead symbol.  */
var _yyloc_default = TYYLTYPE{
	Ffirst_line:   int32(1),
	Ffirst_column: int32(1),
	Flast_line:    int32(1),
	Flast_column:  int32(1),
}

/*
 * Month and day table.
 */

var _MonthDayTable = [25]TTABLE{
	0: {
		Fname:  __ccgo_ts + 25326,
		Ftype1: int32(tMONTH),
		Fvalue: int32(1),
	},
	1: {
		Fname:  __ccgo_ts + 25334,
		Ftype1: int32(tMONTH),
		Fvalue: int32(2),
	},
	2: {
		Fname:  __ccgo_ts + 25343,
		Ftype1: int32(tMONTH),
		Fvalue: int32(3),
	},
	3: {
		Fname:  __ccgo_ts + 25349,
		Ftype1: int32(tMONTH),
		Fvalue: int32(4),
	},
	4: {
		Fname:  __ccgo_ts + 25355,
		Ftype1: int32(tMONTH),
		Fvalue: int32(5),
	},
	5: {
		Fname:  __ccgo_ts + 25359,
		Ftype1: int32(tMONTH),
		Fvalue: int32(6),
	},
	6: {
		Fname:  __ccgo_ts + 25364,
		Ftype1: int32(tMONTH),
		Fvalue: int32(7),
	},
	7: {
		Fname:  __ccgo_ts + 25369,
		Ftype1: int32(tMONTH),
		Fvalue: int32(8),
	},
	8: {
		Fname:  __ccgo_ts + 25376,
		Ftype1: int32(tMONTH),
		Fvalue: int32(9),
	},
	9: {
		Fname:  __ccgo_ts + 25386,
		Ftype1: int32(tMONTH),
		Fvalue: int32(9),
	},
	10: {
		Fname:  __ccgo_ts + 25391,
		Ftype1: int32(tMONTH),
		Fvalue: int32(10),
	},
	11: {
		Fname:  __ccgo_ts + 25399,
		Ftype1: int32(tMONTH),
		Fvalue: int32(11),
	},
	12: {
		Fname:  __ccgo_ts + 25408,
		Ftype1: int32(tMONTH),
		Fvalue: int32(12),
	},
	13: {
		Fname:  __ccgo_ts + 25417,
		Ftype1: int32(tDAY),
		Fvalue: int32(7),
	},
	14: {
		Fname:  __ccgo_ts + 25424,
		Ftype1: int32(tDAY),
		Fvalue: int32(1),
	},
	15: {
		Fname:  __ccgo_ts + 25431,
		Ftype1: int32(tDAY),
		Fvalue: int32(2),
	},
	16: {
		Fname:  __ccgo_ts + 25439,
		Ftype1: int32(tDAY),
		Fvalue: int32(2),
	},
	17: {
		Fname:  __ccgo_ts + 25444,
		Ftype1: int32(tDAY),
		Fvalue: int32(3),
	},
	18: {
		Fname:  __ccgo_ts + 25454,
		Ftype1: int32(tDAY),
		Fvalue: int32(3),
	},
	19: {
		Fname:  __ccgo_ts + 25461,
		Ftype1: int32(tDAY),
		Fvalue: int32(4),
	},
	20: {
		Fname:  __ccgo_ts + 25470,
		Ftype1: int32(tDAY),
		Fvalue: int32(4),
	},
	21: {
		Fname:  __ccgo_ts + 25475,
		Ftype1: int32(tDAY),
		Fvalue: int32(4),
	},
	22: {
		Fname:  __ccgo_ts + 25481,
		Ftype1: int32(tDAY),
		Fvalue: int32(5),
	},
	23: {
		Fname:  __ccgo_ts + 25488,
		Ftype1: int32(tDAY),
		Fvalue: int32(6),
	},
	24: {},
}

/*
 * Time units table.
 */

var _UnitsTable = [11]TTABLE{
	0: {
		Fname:  __ccgo_ts + 11851,
		Ftype1: int32(tMONTH_UNIT),
		Fvalue: int32(12),
	},
	1: {
		Fname:  __ccgo_ts + 11821,
		Ftype1: int32(tMONTH_UNIT),
		Fvalue: int32(1),
	},
	2: {
		Fname:  __ccgo_ts + 25497,
		Ftype1: int32(tDAY_UNIT),
		Fvalue: int32(14),
	},
	3: {
		Fname:  __ccgo_ts + 14447,
		Ftype1: int32(tDAY_UNIT),
		Fvalue: int32(7),
	},
	4: {
		Fname:  __ccgo_ts + 14045,
		Ftype1: int32(tDAY_UNIT),
		Fvalue: int32(1),
	},
	5: {
		Fname:  __ccgo_ts + 14128,
		Ftype1: int32(tSEC_UNIT),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(60),
	},
	6: {
		Fname:  __ccgo_ts + 25507,
		Ftype1: int32(tSEC_UNIT),
		Fvalue: int32(60),
	},
	7: {
		Fname:  __ccgo_ts + 6168,
		Ftype1: int32(tSEC_UNIT),
		Fvalue: int32(60),
	},
	8: {
		Fname:  __ccgo_ts + 25514,
		Ftype1: int32(tSEC_UNIT),
		Fvalue: int32(1),
	},
	9: {
		Fname:  __ccgo_ts + 25521,
		Ftype1: int32(tSEC_UNIT),
		Fvalue: int32(1),
	},
	10: {},
}

/*
 * Assorted relative-time words.
 */

var _OtherTable = [11]TTABLE{
	0: {
		Fname:  __ccgo_ts + 25525,
		Ftype1: int32(tDAY_UNIT),
		Fvalue: int32(1),
	},
	1: {
		Fname:  __ccgo_ts + 25534,
		Ftype1: int32(tDAY_UNIT),
		Fvalue: -int32(1),
	},
	2: {
		Fname:  __ccgo_ts + 25544,
		Ftype1: int32(tDAY_UNIT),
	},
	3: {
		Fname:  __ccgo_ts + 13454,
		Ftype1: int32(tSEC_UNIT),
	},
	4: {
		Fname:  __ccgo_ts + 19703,
		Ftype1: int32(tUNUMBER),
		Fvalue: -int32(1),
	},
	5: {
		Fname:  __ccgo_ts + 25550,
		Ftype1: int32(tSEC_UNIT),
	},
	6: {
		Fname:  __ccgo_ts + 25555,
		Ftype1: int32(tNEXT),
		Fvalue: int32(1),
	},
	7: {
		Fname:  __ccgo_ts + 25560,
		Ftype1: int32(tAGO),
		Fvalue: int32(1),
	},
	8: {
		Fname:  __ccgo_ts + 25564,
		Ftype1: int32(tEPOCH),
	},
	9: {
		Fname:  __ccgo_ts + 25570,
		Ftype1: int32(tSTARDATE),
	},
	10: {},
}

/*
 * The timezone table. (Note: This table was modified to not use any floating
 * point constants to work around an SGI compiler bug).
 */

var _TimezoneTable = [66]TTABLE{
	0: {
		Fname:  __ccgo_ts + 25579,
		Ftype1: int32(tZONE),
	},
	1: {
		Fname:  __ccgo_ts + 25583,
		Ftype1: int32(tZONE),
	},
	2: {
		Fname:  __ccgo_ts + 25586,
		Ftype1: int32(tZONE),
	},
	3: {
		Fname:  __ccgo_ts + 25590,
		Ftype1: int32(tZONE),
	},
	4: {
		Fname:  __ccgo_ts + 25594,
		Ftype1: int32(tZONE),
	},
	5: {
		Fname:  __ccgo_ts + 25598,
		Ftype1: int32(tDAYZONE),
	},
	6: {
		Fname:  __ccgo_ts + 25602,
		Ftype1: int32(tZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(1),
	},
	7: {
		Fname:  __ccgo_ts + 25606,
		Ftype1: int32(tZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(2),
	},
	8: {
		Fname:  __ccgo_ts + 25609,
		Ftype1: int32(tZONE),
		Fvalue: libc.Int32FromInt32(60) * (libc.Int32FromInt32(7) / libc.Int32FromInt32(2)),
	},
	9: {
		Fname:  __ccgo_ts + 25613,
		Ftype1: int32(tZONE),
		Fvalue: libc.Int32FromInt32(60) * (libc.Int32FromInt32(7) / libc.Int32FromInt32(2)),
	},
	10: {
		Fname:  __ccgo_ts + 25617,
		Ftype1: int32(tDAYZONE),
		Fvalue: libc.Int32FromInt32(60) * (libc.Int32FromInt32(7) / libc.Int32FromInt32(2)),
	},
	11: {
		Fname:  __ccgo_ts + 25621,
		Ftype1: int32(tZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(4),
	},
	12: {
		Fname:  __ccgo_ts + 25625,
		Ftype1: int32(tDAYZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(4),
	},
	13: {
		Fname:  __ccgo_ts + 25629,
		Ftype1: int32(tZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(5),
	},
	14: {
		Fname:  __ccgo_ts + 25633,
		Ftype1: int32(tDAYZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(5),
	},
	15: {
		Fname:  __ccgo_ts + 25637,
		Ftype1: int32(tZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(6),
	},
	16: {
		Fname:  __ccgo_ts + 25641,
		Ftype1: int32(tDAYZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(6),
	},
	17: {
		Fname:  __ccgo_ts + 25645,
		Ftype1: int32(tZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(7),
	},
	18: {
		Fname:  __ccgo_ts + 25649,
		Ftype1: int32(tDAYZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(7),
	},
	19: {
		Fname:  __ccgo_ts + 25653,
		Ftype1: int32(tZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(8),
	},
	20: {
		Fname:  __ccgo_ts + 25657,
		Ftype1: int32(tDAYZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(8),
	},
	21: {
		Fname:  __ccgo_ts + 25661,
		Ftype1: int32(tZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(9),
	},
	22: {
		Fname:  __ccgo_ts + 25665,
		Ftype1: int32(tDAYZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(9),
	},
	23: {
		Fname:  __ccgo_ts + 25669,
		Ftype1: int32(tZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(9),
	},
	24: {
		Fname:  __ccgo_ts + 25674,
		Ftype1: int32(tDAYZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(9),
	},
	25: {
		Fname:  __ccgo_ts + 25679,
		Ftype1: int32(tZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(10),
	},
	26: {
		Fname:  __ccgo_ts + 25683,
		Ftype1: int32(tDAYZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(10),
	},
	27: {
		Fname:  __ccgo_ts + 19663,
		Ftype1: int32(tZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(10),
	},
	28: {
		Fname:  __ccgo_ts + 25687,
		Ftype1: int32(tZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(10),
	},
	29: {
		Fname:  __ccgo_ts + 25692,
		Ftype1: int32(tZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(11),
	},
	30: {
		Fname:  __ccgo_ts + 25695,
		Ftype1: int32(tZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(12),
	},
	31: {
		Fname:  __ccgo_ts + 25700,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(1)),
	},
	32: {
		Fname:  __ccgo_ts + 25704,
		Ftype1: int32(tDAYZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(1)),
	},
	33: {
		Fname:  __ccgo_ts + 25709,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(1)),
	},
	34: {
		Fname:  __ccgo_ts + 25713,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(1)),
	},
	35: {
		Fname:  __ccgo_ts + 25718,
		Ftype1: int32(tDAYZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(1)),
	},
	36: {
		Fname:  __ccgo_ts + 25723,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(1)),
	},
	37: {
		Fname:  __ccgo_ts + 25727,
		Ftype1: int32(tDAYZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(1)),
	},
	38: {
		Fname:  __ccgo_ts + 25731,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(1)),
	},
	39: {
		Fname:  __ccgo_ts + 25735,
		Ftype1: int32(tDAYZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(1)),
	},
	40: {
		Fname:  __ccgo_ts + 25739,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(2)),
	},
	41: {
		Fname:  __ccgo_ts + 25743,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(3)),
	},
	42: {
		Fname:  __ccgo_ts + 25746,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * (libc.Int32FromInt32(7) / libc.Int32FromInt32(2))),
	},
	43: {
		Fname:  __ccgo_ts + 25749,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(4)),
	},
	44: {
		Fname:  __ccgo_ts + 25753,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(5)),
	},
	45: {
		Fname:  __ccgo_ts + 25757,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * (libc.Int32FromInt32(11) / libc.Int32FromInt32(2))),
	},
	46: {
		Fname:  __ccgo_ts + 25761,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(6)),
	},
	47: {
		Fname:  __ccgo_ts + 25765,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(7)),
	},
	48: {
		Fname:  __ccgo_ts + 25770,
		Ftype1: int32(tDAYZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(7)),
	},
	49: {
		Fname:  __ccgo_ts + 25775,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * (libc.Int32FromInt32(15) / libc.Int32FromInt32(2))),
	},
	50: {
		Fname:  __ccgo_ts + 25778,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(8)),
	},
	51: {
		Fname:  __ccgo_ts + 25782,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(9)),
	},
	52: {
		Fname:  __ccgo_ts + 25786,
		Ftype1: int32(tDAYZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(9)),
	},
	53: {
		Fname:  __ccgo_ts + 25790,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(9)),
	},
	54: {
		Fname:  __ccgo_ts + 25794,
		Ftype1: int32(tDAYZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(9)),
	},
	55: {
		Fname:  __ccgo_ts + 25798,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * (libc.Int32FromInt32(19) / libc.Int32FromInt32(2))),
	},
	56: {
		Fname:  __ccgo_ts + 25803,
		Ftype1: int32(tDAYZONE),
		Fvalue: -(libc.Int32FromInt32(60) * (libc.Int32FromInt32(19) / libc.Int32FromInt32(2))),
	},
	57: {
		Fname:  __ccgo_ts + 25808,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(10)),
	},
	58: {
		Fname:  __ccgo_ts + 25813,
		Ftype1: int32(tDAYZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(10)),
	},
	59: {
		Fname:  __ccgo_ts + 25818,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(10)),
	},
	60: {
		Fname:  __ccgo_ts + 25822,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(12)),
	},
	61: {
		Fname:  __ccgo_ts + 25826,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(12)),
	},
	62: {
		Fname:  __ccgo_ts + 25831,
		Ftype1: int32(tDAYZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(12)),
	},
	63: {
		Fname:  __ccgo_ts + 25836,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(12)),
	},
	64: {
		Fname:  __ccgo_ts + 25841,
		Ftype1: int32(tDST),
	},
	65: {},
}

/*
 * Military timezone table.
 */

var _MilitaryTable = [26]TTABLE{
	0: {
		Fname:  __ccgo_ts + 25845,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(1)),
	},
	1: {
		Fname:  __ccgo_ts + 25847,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(2)),
	},
	2: {
		Fname:  __ccgo_ts + 25849,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(3)),
	},
	3: {
		Fname:  __ccgo_ts + 25851,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(4)),
	},
	4: {
		Fname:  __ccgo_ts + 25853,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(5)),
	},
	5: {
		Fname:  __ccgo_ts + 25855,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(6)),
	},
	6: {
		Fname:  __ccgo_ts + 25857,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(7)),
	},
	7: {
		Fname:  __ccgo_ts + 25859,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(8)),
	},
	8: {
		Fname:  __ccgo_ts + 25861,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(9)),
	},
	9: {
		Fname:  __ccgo_ts + 25863,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(10)),
	},
	10: {
		Fname:  __ccgo_ts + 25865,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(11)),
	},
	11: {
		Fname:  __ccgo_ts + 25867,
		Ftype1: int32(tZONE),
		Fvalue: -(libc.Int32FromInt32(60) * libc.Int32FromInt32(12)),
	},
	12: {
		Fname:  __ccgo_ts + 25869,
		Ftype1: int32(tZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(1),
	},
	13: {
		Fname:  __ccgo_ts + 25871,
		Ftype1: int32(tZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(2),
	},
	14: {
		Fname:  __ccgo_ts + 25873,
		Ftype1: int32(tZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(3),
	},
	15: {
		Fname:  __ccgo_ts + 25875,
		Ftype1: int32(tZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(4),
	},
	16: {
		Fname:  __ccgo_ts + 25877,
		Ftype1: int32(tZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(5),
	},
	17: {
		Fname:  __ccgo_ts + 25879,
		Ftype1: int32(tZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(6),
	},
	18: {
		Fname:  __ccgo_ts + 25881,
		Ftype1: int32(tZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(7),
	},
	19: {
		Fname:  __ccgo_ts + 25883,
		Ftype1: int32(tZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(8),
	},
	20: {
		Fname:  __ccgo_ts + 25885,
		Ftype1: int32(tZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(9),
	},
	21: {
		Fname:  __ccgo_ts + 25887,
		Ftype1: int32(tZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(10),
	},
	22: {
		Fname:  __ccgo_ts + 25889,
		Ftype1: int32(tZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(11),
	},
	23: {
		Fname:  __ccgo_ts + 14842,
		Ftype1: int32(tZONE),
		Fvalue: libc.Int32FromInt32(60) * libc.Int32FromInt32(12),
	},
	24: {
		Fname:  __ccgo_ts + 25891,
		Ftype1: int32(tZONE),
	},
	25: {},
}

func _bypassSpaces(tls *libc.TLS, s uintptr) (r uintptr) {
	for XTclIsSpaceProc(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))) != 0 {
		s++
	}
	return s
}

/*
 * Dump error messages in the bit bucket.
 */

func _TclDateerror(tls *libc.TLS, location uintptr, infoPtr uintptr, s uintptr) {
	var _objPtr, _objPtr1, cachePtr, cachePtr1, cachePtr2, t, v4, v7 uintptr
	var v1, v2, v5 bool
	var v3, v6 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, cachePtr1, cachePtr2, t, v1, v2, v3, v4, v5, v6, v7
	if !((*TDateInfo)(unsafe.Pointer(infoPtr)).Fmessages != 0) {
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			(*TDateInfo)(unsafe.Pointer(infoPtr)).Fmessages = XTclThreadAllocObj(tls)
		} else {
			(*TDateInfo)(unsafe.Pointer(infoPtr)).Fmessages = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer((*TDateInfo)(unsafe.Pointer(infoPtr)).Fmessages + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer((*TDateInfo)(unsafe.Pointer(infoPtr)).Fmessages)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer((*TDateInfo)(unsafe.Pointer(infoPtr)).Fmessages)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer((*TDateInfo)(unsafe.Pointer(infoPtr)).Fmessages)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer((*TDateInfo)(unsafe.Pointer(infoPtr)).Fmessages)).FtypePtr = libc.UintptrFromInt32(0)
	}
	XTcl_AppendToObj(tls, (*TDateInfo)(unsafe.Pointer(infoPtr)).Fmessages, (*TDateInfo)(unsafe.Pointer(infoPtr)).Fseparatrix, int64(-int32(1)))
	XTcl_AppendToObj(tls, (*TDateInfo)(unsafe.Pointer(infoPtr)).Fmessages, s, int64(-int32(1)))
	XTcl_AppendToObj(tls, (*TDateInfo)(unsafe.Pointer(infoPtr)).Fmessages, __ccgo_ts+25893, int64(-int32(1)))
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		t = XTclThreadAllocObj(tls)
	} else {
		t = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(t + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(t)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(t)).Fbytes = libc.UintptrFromInt32(0)
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(t)).FinternalRep)) = int64((*TYYLTYPE)(unsafe.Pointer(location)).Ffirst_column)
	(*TTcl_Obj)(unsafe.Pointer(t)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	(*TTcl_Obj)(unsafe.Pointer(t)).FrefCount++
	XTcl_AppendObjToObj(tls, (*TDateInfo)(unsafe.Pointer(infoPtr)).Fmessages, t)
	_objPtr = t
	v4 = _objPtr
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	if v3 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	XTcl_AppendToObj(tls, (*TDateInfo)(unsafe.Pointer(infoPtr)).Fmessages, __ccgo_ts+6319, int64(-int32(1)))
	if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
		cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v5 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
		t = XTclThreadAllocObj(tls)
	} else {
		t = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(t + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(t)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(t)).Fbytes = libc.UintptrFromInt32(0)
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(t)).FinternalRep)) = int64((*TYYLTYPE)(unsafe.Pointer(location)).Flast_column)
	(*TTcl_Obj)(unsafe.Pointer(t)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	(*TTcl_Obj)(unsafe.Pointer(t)).FrefCount++
	XTcl_AppendObjToObj(tls, (*TDateInfo)(unsafe.Pointer(infoPtr)).Fmessages, t)
	_objPtr1 = t
	v7 = _objPtr1
	v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
	*(*TTcl_Size)(unsafe.Pointer(v7))--
	if v6 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	XTcl_AppendToObj(tls, (*TDateInfo)(unsafe.Pointer(infoPtr)).Fmessages, __ccgo_ts+3563, int64(-int32(1)))
	(*TDateInfo)(unsafe.Pointer(infoPtr)).Fseparatrix = __ccgo_ts + 286
}

func XToSeconds(tls *libc.TLS, Hours int32, Minutes int32, Seconds int32, Meridian TMERIDIAN) (r int32) {
	switch Meridian {
	case int32(MER24):
		return (Hours*int32(60)+Minutes)*int32(60) + Seconds
	case int32(MERam):
		return ((Hours/int32(24)*int32(24)+Hours%int32(12))*int32(60)+Minutes)*int32(60) + Seconds
	case int32(MERpm):
		return ((Hours/int32(24)*int32(24)+Hours%int32(12)+int32(12))*int32(60)+Minutes)*int32(60) + Seconds
	}
	return -int32(1) /* Should never be reached */
}

func _LookupWord(tls *libc.TLS, yylvalPtr uintptr, buff uintptr) (r int32) {
	var abbrev, i int32
	var p, q, tp, v8, v9 uintptr
	_, _, _, _, _, _, _ = abbrev, i, p, q, tp, v8, v9
	/*
	 * Make it lowercase.
	 */
	XTcl_UtfToLower(tls, buff)
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(buff))) == int32('a') && (libc.Xstrcmp(tls, buff, __ccgo_ts+25907) == 0 || libc.Xstrcmp(tls, buff, __ccgo_ts+25910) == 0) {
		*(*_MERIDIAN)(unsafe.Pointer(yylvalPtr)) = int32(MERam)
		return int32(tMERIDIAN)
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(buff))) == int32('p') && (libc.Xstrcmp(tls, buff, __ccgo_ts+25915) == 0 || libc.Xstrcmp(tls, buff, __ccgo_ts+25918) == 0) {
		*(*_MERIDIAN)(unsafe.Pointer(yylvalPtr)) = int32(MERpm)
		return int32(tMERIDIAN)
	}
	/*
	 * See if we have an abbreviation for a month.
	 */
	if libc.Xstrlen(tls, buff) == uint64(3) {
		abbrev = int32(1)
	} else {
		if libc.Xstrlen(tls, buff) == uint64(4) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(buff + 3))) == int32('.') {
			abbrev = int32(1)
			*(*uint8)(unsafe.Pointer(buff + 3)) = uint8('\000')
		} else {
			abbrev = 0
		}
	}
	tp = uintptr(unsafe.Pointer(&_MonthDayTable))
	for {
		if !((*TTABLE)(unsafe.Pointer(tp)).Fname != 0) {
			break
		}
		if abbrev != 0 {
			if libc.Xstrncmp(tls, buff, (*TTABLE)(unsafe.Pointer(tp)).Fname, uint64(3)) == 0 {
				(*TYYSTYPE)(unsafe.Pointer(yylvalPtr)).FNumber = int64((*TTABLE)(unsafe.Pointer(tp)).Fvalue)
				return (*TTABLE)(unsafe.Pointer(tp)).Ftype1
			}
		} else {
			if libc.Xstrcmp(tls, buff, (*TTABLE)(unsafe.Pointer(tp)).Fname) == 0 {
				(*TYYSTYPE)(unsafe.Pointer(yylvalPtr)).FNumber = int64((*TTABLE)(unsafe.Pointer(tp)).Fvalue)
				return (*TTABLE)(unsafe.Pointer(tp)).Ftype1
			}
		}
		goto _1
	_1:
		;
		tp += 16
	}
	tp = uintptr(unsafe.Pointer(&_TimezoneTable))
	for {
		if !((*TTABLE)(unsafe.Pointer(tp)).Fname != 0) {
			break
		}
		if libc.Xstrcmp(tls, buff, (*TTABLE)(unsafe.Pointer(tp)).Fname) == 0 {
			(*TYYSTYPE)(unsafe.Pointer(yylvalPtr)).FNumber = int64((*TTABLE)(unsafe.Pointer(tp)).Fvalue)
			return (*TTABLE)(unsafe.Pointer(tp)).Ftype1
		}
		goto _2
	_2:
		;
		tp += 16
	}
	tp = uintptr(unsafe.Pointer(&_UnitsTable))
	for {
		if !((*TTABLE)(unsafe.Pointer(tp)).Fname != 0) {
			break
		}
		if libc.Xstrcmp(tls, buff, (*TTABLE)(unsafe.Pointer(tp)).Fname) == 0 {
			(*TYYSTYPE)(unsafe.Pointer(yylvalPtr)).FNumber = int64((*TTABLE)(unsafe.Pointer(tp)).Fvalue)
			return (*TTABLE)(unsafe.Pointer(tp)).Ftype1
		}
		goto _3
	_3:
		;
		tp += 16
	}
	/*
	 * Strip off any plural and try the units table again.
	 */
	i = libc.Int32FromUint64(libc.Xstrlen(tls, buff) - uint64(1))
	if i > 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(buff + uintptr(i)))) == int32('s') {
		*(*uint8)(unsafe.Pointer(buff + uintptr(i))) = uint8('\000')
		tp = uintptr(unsafe.Pointer(&_UnitsTable))
		for {
			if !((*TTABLE)(unsafe.Pointer(tp)).Fname != 0) {
				break
			}
			if libc.Xstrcmp(tls, buff, (*TTABLE)(unsafe.Pointer(tp)).Fname) == 0 {
				(*TYYSTYPE)(unsafe.Pointer(yylvalPtr)).FNumber = int64((*TTABLE)(unsafe.Pointer(tp)).Fvalue)
				return (*TTABLE)(unsafe.Pointer(tp)).Ftype1
			}
			goto _4
		_4:
			;
			tp += 16
		}
	}
	tp = uintptr(unsafe.Pointer(&_OtherTable))
	for {
		if !((*TTABLE)(unsafe.Pointer(tp)).Fname != 0) {
			break
		}
		if libc.Xstrcmp(tls, buff, (*TTABLE)(unsafe.Pointer(tp)).Fname) == 0 {
			(*TYYSTYPE)(unsafe.Pointer(yylvalPtr)).FNumber = int64((*TTABLE)(unsafe.Pointer(tp)).Fvalue)
			return (*TTABLE)(unsafe.Pointer(tp)).Ftype1
		}
		goto _5
	_5:
		;
		tp += 16
	}
	/*
	 * Military timezones.
	 */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(buff + 1))) == int32('\000') && !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(buff)))&libc.Int32FromInt32(0x80) != 0) && libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(buff)))|uint32(32)-uint32('a') < uint32(26)) != 0 { /* INTL: ISO only */
		tp = uintptr(unsafe.Pointer(&_MilitaryTable))
		for {
			if !((*TTABLE)(unsafe.Pointer(tp)).Fname != 0) {
				break
			}
			if libc.Xstrcmp(tls, buff, (*TTABLE)(unsafe.Pointer(tp)).Fname) == 0 {
				(*TYYSTYPE)(unsafe.Pointer(yylvalPtr)).FNumber = int64((*TTABLE)(unsafe.Pointer(tp)).Fvalue)
				return (*TTABLE)(unsafe.Pointer(tp)).Ftype1
			}
			goto _6
		_6:
			;
			tp += 16
		}
	}
	/*
	 * Drop out any periods and try the timezone table again.
	 */
	i = 0
	v8 = buff
	q = v8
	p = v8
	for {
		if !(*(*uint8)(unsafe.Pointer(q)) != 0) {
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(q))) != int32('.') {
			v9 = p
			p++
			*(*uint8)(unsafe.Pointer(v9)) = *(*uint8)(unsafe.Pointer(q))
		} else {
			i++
		}
		goto _7
	_7:
		;
		q++
	}
	*(*uint8)(unsafe.Pointer(p)) = uint8('\000')
	if i != 0 {
		tp = uintptr(unsafe.Pointer(&_TimezoneTable))
		for {
			if !((*TTABLE)(unsafe.Pointer(tp)).Fname != 0) {
				break
			}
			if libc.Xstrcmp(tls, buff, (*TTABLE)(unsafe.Pointer(tp)).Fname) == 0 {
				(*TYYSTYPE)(unsafe.Pointer(yylvalPtr)).FNumber = int64((*TTABLE)(unsafe.Pointer(tp)).Fvalue)
				return (*TTABLE)(unsafe.Pointer(tp)).Ftype1
			}
			goto _10
		_10:
			;
			tp += 16
		}
	}
	return int32(tID)
}

func _TclDatelex(tls *libc.TLS, yylvalPtr uintptr, location uintptr, info uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var Count, ret, v2, v3 int32
	var c, v5, v8 uint8
	var p, tokStart, v10, v11, v12, v13, v14, v15, v16, v17, v6, v9 uintptr
	var _ /* buff at bp+0 */ [20]uint8
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = Count, c, p, ret, tokStart, v10, v11, v12, v13, v14, v15, v16, v17, v2, v3, v5, v6, v8, v9
	(*TYYLTYPE)(unsafe.Pointer(location)).Ffirst_column = int32(int64((*TDateInfo)(unsafe.Pointer(info)).FdateInput) - int64((*TDateInfo)(unsafe.Pointer(info)).FdateStart))
	for {
		v2 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TDateInfo)(unsafe.Pointer(info)).FdateInput)))
		v3 = libc.BoolInt32(v2 == int32(' ') || libc.Uint32FromInt32(v2)-uint32('\t') < uint32(5))
		goto _4
	_4:
		if v3 != 0 {
			(*TDateInfo)(unsafe.Pointer(info)).FdateInput = _bypassSpaces(tls, (*TDateInfo)(unsafe.Pointer(info)).FdateInput)
			/* ignore space at end of text and before some words */
			c = *(*uint8)(unsafe.Pointer((*TDateInfo)(unsafe.Pointer(info)).FdateInput))
			if libc.Int32FromUint8(c) != int32('\000') && !(libc.BoolInt32(uint32(c)|libc.Uint32FromInt32(32)-libc.Uint32FromUint8('a') < libc.Uint32FromInt32(26)) != 0) {
				return int32(SP)
			}
		}
		tokStart = (*TDateInfo)(unsafe.Pointer(info)).FdateInput
		v5 = *(*uint8)(unsafe.Pointer((*TDateInfo)(unsafe.Pointer(info)).FdateInput))
		c = v5
		if libc.BoolInt32(uint32(v5)-uint32('0') < uint32(10)) != 0 { /* INTL: digit */
			/*
			 * Count the number of digits.
			 */
			p = (*TDateInfo)(unsafe.Pointer(info)).FdateInput
			for {
				p++
				v6 = p
				if !(libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(v6)))-uint32('0') < uint32(10)) != 0) {
					break
				}
			}
			(*TDateInfo)(unsafe.Pointer(info)).FdateDigitCount = int32(int64(p) - int64((*TDateInfo)(unsafe.Pointer(info)).FdateInput))
			/*
			 * A number with 12 or 14 digits is considered an ISO 8601 date.
			 */
			if (*TDateInfo)(unsafe.Pointer(info)).FdateDigitCount == int32(14) || (*TDateInfo)(unsafe.Pointer(info)).FdateDigitCount == int32(12) {
				/* long form of ISO 8601 (without separator), either
				 * YYYYMMDDhhmmss or YYYYMMDDhhmm, so reduce to date
				 * (8 chars is isodate) */
				p = (*TDateInfo)(unsafe.Pointer(info)).FdateInput + uintptr(8)
				if XTclAtoWIe(tls, yylvalPtr, (*TDateInfo)(unsafe.Pointer(info)).FdateInput, p, int32(1)) != TCL_OK {
					return int32(tID) /* overflow*/
				}
				(*TDateInfo)(unsafe.Pointer(info)).FdateDigitCount = int32(8)
				(*TDateInfo)(unsafe.Pointer(info)).FdateInput = p
				(*TYYLTYPE)(unsafe.Pointer(location)).Flast_column = int32(int64((*TDateInfo)(unsafe.Pointer(info)).FdateInput) - int64((*TDateInfo)(unsafe.Pointer(info)).FdateStart) - int64(1))
				return int32(tISOBASL)
			}
			/*
			 * Convert the string into a number
			 */
			if XTclAtoWIe(tls, yylvalPtr, (*TDateInfo)(unsafe.Pointer(info)).FdateInput, p, int32(1)) != TCL_OK {
				return int32(tID) /* overflow*/
			}
			(*TDateInfo)(unsafe.Pointer(info)).FdateInput = p
			/*
			 * A number with 6 or more digits is considered an ISO 8601 base.
			 */
			(*TYYLTYPE)(unsafe.Pointer(location)).Flast_column = int32(int64((*TDateInfo)(unsafe.Pointer(info)).FdateInput) - int64((*TDateInfo)(unsafe.Pointer(info)).FdateStart) - int64(1))
			if (*TDateInfo)(unsafe.Pointer(info)).FdateDigitCount >= int32(6) {
				if (*TDateInfo)(unsafe.Pointer(info)).FdateDigitCount == int32(8) {
					return int32(tISOBAS8)
				}
				if (*TDateInfo)(unsafe.Pointer(info)).FdateDigitCount == int32(6) {
					return int32(tISOBAS6)
				}
			}
			/* ignore spaces after digits (optional) */
			(*TDateInfo)(unsafe.Pointer(info)).FdateInput = _bypassSpaces(tls, (*TDateInfo)(unsafe.Pointer(info)).FdateInput)
			return int32(tUNUMBER)
		}
		if !(libc.Int32FromUint8(c)&libc.Int32FromInt32(0x80) != 0) && libc.BoolInt32(uint32(c)|uint32(32)-uint32('a') < uint32(26)) != 0 {
			p = bp
			for {
				v10 = info + 8
				v9 = *(*uintptr)(unsafe.Pointer(v10))
				*(*uintptr)(unsafe.Pointer(v10))++
				v8 = *(*uint8)(unsafe.Pointer(v9))
				c = v8
				if !(libc.BoolInt32(uint32(v8)|uint32(32)-uint32('a') < uint32(26)) != 0 || libc.Int32FromUint8(c) == int32('.')) {
					break
				}
				if p < bp+uintptr(libc.Uint64FromInt64(20)-libc.Uint64FromInt32(1)) {
					v11 = p
					p++
					*(*uint8)(unsafe.Pointer(v11)) = c
				}
				goto _7
			_7:
			}
			*(*uint8)(unsafe.Pointer(p)) = uint8('\000')
			(*TDateInfo)(unsafe.Pointer(info)).FdateInput--
			(*TYYLTYPE)(unsafe.Pointer(location)).Flast_column = int32(int64((*TDateInfo)(unsafe.Pointer(info)).FdateInput) - int64((*TDateInfo)(unsafe.Pointer(info)).FdateStart) - int64(1))
			ret = _LookupWord(tls, yylvalPtr, bp)
			/*
			 * lookahead:
			 *	for spaces to consider word boundaries (for instance
			 *	literal T in isodateTisotimeZ is not a TZ, but Z is UTC);
			 *	for +/- digit, to differentiate between "GMT+1000 day" and "GMT +1000 day";
			 * bypass spaces after token (but ignore by TZ+OFFS), because should
			 * recognize next SP token, if TZ only.
			 */
			if ret == int32(tZONE) || ret == int32(tDAYZONE) {
				c = *(*uint8)(unsafe.Pointer((*TDateInfo)(unsafe.Pointer(info)).FdateInput))
				if libc.BoolInt32(uint32(c)-uint32('0') < uint32(10)) != 0 { /* literal not a TZ  */
					(*TDateInfo)(unsafe.Pointer(info)).FdateInput = tokStart
					v13 = info + 8
					v12 = *(*uintptr)(unsafe.Pointer(v13))
					*(*uintptr)(unsafe.Pointer(v13))++
					return libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v12)))
				}
				if (libc.Int32FromUint8(c) == int32('+') || libc.Int32FromUint8(c) == int32('-')) && libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer((*TDateInfo)(unsafe.Pointer(info)).FdateInput + libc.UintptrFromInt32(1))))-uint32('0') < uint32(10)) != 0 {
					if !(libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer((*TDateInfo)(unsafe.Pointer(info)).FdateInput + libc.UintptrFromInt32(2))))-libc.Uint32FromUint8('0') < libc.Uint32FromInt32(10)) != 0) || !(libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer((*TDateInfo)(unsafe.Pointer(info)).FdateInput + libc.UintptrFromInt32(3))))-libc.Uint32FromUint8('0') < libc.Uint32FromInt32(10)) != 0) {
						/* GMT+1, GMT-10, etc. */
						return int32(tZONEwO2)
					}
					if libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer((*TDateInfo)(unsafe.Pointer(info)).FdateInput + libc.UintptrFromInt32(4))))-uint32('0') < uint32(10)) != 0 && !(libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer((*TDateInfo)(unsafe.Pointer(info)).FdateInput + libc.UintptrFromInt32(5))))-libc.Uint32FromUint8('0') < libc.Uint32FromInt32(10)) != 0) {
						/* GMT+1000, etc. */
						return int32(tZONEwO4)
					}
				}
			}
			(*TDateInfo)(unsafe.Pointer(info)).FdateInput = _bypassSpaces(tls, (*TDateInfo)(unsafe.Pointer(info)).FdateInput)
			return ret
		}
		if libc.Int32FromUint8(c) != int32('(') {
			(*TYYLTYPE)(unsafe.Pointer(location)).Flast_column = int32(int64((*TDateInfo)(unsafe.Pointer(info)).FdateInput) - int64((*TDateInfo)(unsafe.Pointer(info)).FdateStart))
			v15 = info + 8
			v14 = *(*uintptr)(unsafe.Pointer(v15))
			*(*uintptr)(unsafe.Pointer(v15))++
			return libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v14)))
		}
		Count = 0
		for cond := true; cond; cond = Count > 0 {
			v17 = info + 8
			v16 = *(*uintptr)(unsafe.Pointer(v17))
			*(*uintptr)(unsafe.Pointer(v17))++
			c = *(*uint8)(unsafe.Pointer(v16))
			if libc.Int32FromUint8(c) == int32('\000') {
				(*TYYLTYPE)(unsafe.Pointer(location)).Flast_column = int32(int64((*TDateInfo)(unsafe.Pointer(info)).FdateInput) - int64((*TDateInfo)(unsafe.Pointer(info)).FdateStart) - int64(1))
				return libc.Int32FromUint8(c)
			} else {
				if libc.Int32FromUint8(c) == int32('(') {
					Count++
				} else {
					if libc.Int32FromUint8(c) == int32(')') {
						Count--
					}
				}
			}
		}
		goto _1
	_1:
	}
	return r
}

func XTclClockFreeScan(tls *libc.TLS, interp uintptr, info uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Input and result parameters */
	var _objPtr, msg, v1, v3 uintptr
	var status int32
	var v2 TTcl_Size
	_, _, _, _, _, _ = _objPtr, msg, status, v1, v2, v3
	/*
	 * yyInput = stringToParse;
	 *
	 * ClockInitDateInfo(info) should be executed to pre-init info;
	 */
	(*TDateInfo)(unsafe.Pointer(info)).FdateDSTmode = int32(DSTmaybe)
	(*TDateInfo)(unsafe.Pointer(info)).Fseparatrix = __ccgo_ts + 1945
	(*TDateInfo)(unsafe.Pointer(info)).FdateStart = (*TDateInfo)(unsafe.Pointer(info)).FdateInput
	/* ignore spaces at begin */
	(*TDateInfo)(unsafe.Pointer(info)).FdateInput = _bypassSpaces(tls, (*TDateInfo)(unsafe.Pointer(info)).FdateInput)
	/* parse */
	status = XTclDateparse(tls, info)
	if status == int32(1) {
		msg = libc.UintptrFromInt32(0)
		if (*TDateInfo)(unsafe.Pointer(info)).FerrFlags&int32(CLF_HAVEDATE) != 0 {
			msg = __ccgo_ts + 25923
		} else {
			if (*TDateInfo)(unsafe.Pointer(info)).FerrFlags&int32(CLF_TIME) != 0 {
				msg = __ccgo_ts + 25952
			} else {
				if (*TDateInfo)(unsafe.Pointer(info)).FerrFlags&int32(CLF_ZONE) != 0 {
					msg = __ccgo_ts + 25988
				} else {
					if (*TDateInfo)(unsafe.Pointer(info)).FerrFlags&int32(CLF_DAYOFWEEK) != 0 {
						msg = __ccgo_ts + 26022
					} else {
						if (*TDateInfo)(unsafe.Pointer(info)).FerrFlags&int32(CLF_ORDINALMONTH) != 0 {
							msg = __ccgo_ts + 26054
						}
					}
				}
			}
		}
		if msg != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, msg, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+26092, __ccgo_ts+26097, libc.UintptrFromInt32(0)))
		} else {
			if (*TDateInfo)(unsafe.Pointer(info)).Fmessages != 0 {
				v1 = (*TDateInfo)(unsafe.Pointer(info)).Fmessages
			} else {
				v1 = XTcl_NewObj(tls)
			}
			XTcl_SetObjResult(tls, interp, v1)
			(*TDateInfo)(unsafe.Pointer(info)).Fmessages = libc.UintptrFromInt32(0)
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+26092, __ccgo_ts+23085, libc.UintptrFromInt32(0)))
		}
		status = int32(TCL_ERROR)
	} else {
		if status == int32(2) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+25262, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+2008, libc.UintptrFromInt32(0)))
			status = int32(TCL_ERROR)
		} else {
			if status != 0 {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+26106, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+26190, libc.UintptrFromInt32(0)))
				status = int32(TCL_ERROR)
			}
		}
	}
	if (*TDateInfo)(unsafe.Pointer(info)).Fmessages != 0 {
		_objPtr = (*TDateInfo)(unsafe.Pointer(info)).Fmessages
		v3 = _objPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	return status
}

const LOCAL_SIZE = 64

/*
 * Forward declaration.
 */
type TDict1 = struct {
	Ftable          TTcl_HashTable
	FentryChainHead uintptr
	FentryChainTail uintptr
	Fepoch          Tsize_t
	FrefCount       Tsize_t
	Fchain          uintptr
}

/*
 * Table of dict subcommand names and implementations.
 */

var _implementationMap = [23]TEnsembleImplMap{
	0: {
		Fname: __ccgo_ts + 2125,
	},
	1: {
		Fname: __ccgo_ts + 26194,
	},
	2: {
		Fname: __ccgo_ts + 5689,
	},
	3: {
		Fname: __ccgo_ts + 26201,
	},
	4: {
		Fname: __ccgo_ts + 5187,
	},
	5: {
		Fname: __ccgo_ts + 24987,
	},
	6: {
		Fname: __ccgo_ts + 26208,
	},
	7: {
		Fname: __ccgo_ts + 26215,
	},
	8: {
		Fname: __ccgo_ts + 2542,
	},
	9: {
		Fname: __ccgo_ts + 5873,
	},
	10: {
		Fname: __ccgo_ts + 26230,
	},
	11: {
		Fname: __ccgo_ts + 2733,
	},
	12: {
		Fname: __ccgo_ts + 19715,
	},
	13: {
		Fname: __ccgo_ts + 26235,
	},
	14: {
		Fname: __ccgo_ts + 26241,
	},
	15: {
		Fname: __ccgo_ts + 19738,
	},
	16: {
		Fname: __ccgo_ts + 5383,
	},
	17: {
		Fname: __ccgo_ts + 5807,
	},
	18: {
		Fname: __ccgo_ts + 3450,
	},
	19: {
		Fname: __ccgo_ts + 5602,
	},
	20: {
		Fname: __ccgo_ts + 26248,
	},
	21: {
		Fname: __ccgo_ts + 26255,
	},
	22: {},
}

func init() {
	p := unsafe.Pointer(&_implementationMap)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_DictAppendCmd)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(XTclCompileDictAppendCmd)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(_DictCreateCmd)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(XTclCompileDictCreateCmd)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(_DictExistsCmd)
	*(*uintptr)(unsafe.Add(p, 112)) = __ccgo_fp(XTclCompileDictExistsCmd)
	*(*uintptr)(unsafe.Add(p, 152)) = __ccgo_fp(_DictFilterCmd)
	*(*uintptr)(unsafe.Add(p, 208)) = __ccgo_fp(XTclCompileDictForCmd)
	*(*uintptr)(unsafe.Add(p, 216)) = __ccgo_fp(_DictForNRCmd)
	*(*uintptr)(unsafe.Add(p, 248)) = __ccgo_fp(_DictGetCmd)
	*(*uintptr)(unsafe.Add(p, 256)) = __ccgo_fp(XTclCompileDictGetCmd)
	*(*uintptr)(unsafe.Add(p, 296)) = __ccgo_fp(_DictGetDefCmd)
	*(*uintptr)(unsafe.Add(p, 304)) = __ccgo_fp(XTclCompileDictGetWithDefaultCmd)
	*(*uintptr)(unsafe.Add(p, 344)) = __ccgo_fp(_DictGetDefCmd)
	*(*uintptr)(unsafe.Add(p, 352)) = __ccgo_fp(XTclCompileDictGetWithDefaultCmd)
	*(*uintptr)(unsafe.Add(p, 392)) = __ccgo_fp(_DictIncrCmd)
	*(*uintptr)(unsafe.Add(p, 400)) = __ccgo_fp(XTclCompileDictIncrCmd)
	*(*uintptr)(unsafe.Add(p, 440)) = __ccgo_fp(_DictInfoCmd)
	*(*uintptr)(unsafe.Add(p, 448)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 488)) = __ccgo_fp(_DictKeysCmd)
	*(*uintptr)(unsafe.Add(p, 496)) = __ccgo_fp(XTclCompileBasic1Or2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 536)) = __ccgo_fp(_DictLappendCmd)
	*(*uintptr)(unsafe.Add(p, 544)) = __ccgo_fp(XTclCompileDictLappendCmd)
	*(*uintptr)(unsafe.Add(p, 592)) = __ccgo_fp(XTclCompileDictMapCmd)
	*(*uintptr)(unsafe.Add(p, 600)) = __ccgo_fp(_DictMapNRCmd)
	*(*uintptr)(unsafe.Add(p, 632)) = __ccgo_fp(_DictMergeCmd)
	*(*uintptr)(unsafe.Add(p, 640)) = __ccgo_fp(XTclCompileDictMergeCmd)
	*(*uintptr)(unsafe.Add(p, 680)) = __ccgo_fp(_DictRemoveCmd)
	*(*uintptr)(unsafe.Add(p, 688)) = __ccgo_fp(XTclCompileBasicMin1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 728)) = __ccgo_fp(_DictReplaceCmd)
	*(*uintptr)(unsafe.Add(p, 776)) = __ccgo_fp(_DictSetCmd)
	*(*uintptr)(unsafe.Add(p, 784)) = __ccgo_fp(XTclCompileDictSetCmd)
	*(*uintptr)(unsafe.Add(p, 824)) = __ccgo_fp(_DictSizeCmd)
	*(*uintptr)(unsafe.Add(p, 832)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 872)) = __ccgo_fp(_DictUnsetCmd)
	*(*uintptr)(unsafe.Add(p, 880)) = __ccgo_fp(XTclCompileDictUnsetCmd)
	*(*uintptr)(unsafe.Add(p, 920)) = __ccgo_fp(_DictUpdateCmd)
	*(*uintptr)(unsafe.Add(p, 928)) = __ccgo_fp(XTclCompileDictUpdateCmd)
	*(*uintptr)(unsafe.Add(p, 968)) = __ccgo_fp(_DictValuesCmd)
	*(*uintptr)(unsafe.Add(p, 976)) = __ccgo_fp(XTclCompileBasic1Or2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 1016)) = __ccgo_fp(_DictWithCmd)
	*(*uintptr)(unsafe.Add(p, 1024)) = __ccgo_fp(XTclCompileDictWithCmd)
}

/*
 * Internal representation of the entries in the hash table that backs a
 * dictionary.
 */

type TChainEntry = struct {
	Fentry   TTcl_HashEntry
	FprevPtr uintptr
	FnextPtr uintptr
}

/*
 * Internal representation of a dictionary.
 *
 * The internal representation of a dictionary object is a hash table (with
 * Tcl_Objs for both keys and values), a reference count and epoch number for
 * detecting concurrent modifications of the dictionary, and a pointer to the
 * parent object (used when invalidating string reps of pathed dictionary
 * trees) which is NULL in normal use. The fact that hash tables know (with
 * appropriate initialisation) already about objects makes key management /so/
 * much easier!
 *
 * Reference counts are used to enable safe iteration across hashes while
 * allowing the type of the containing object to be modified.
 */

type TDict = struct {
	Ftable          TTcl_HashTable
	FentryChainHead uintptr
	FentryChainTail uintptr
	Fepoch          Tsize_t
	FrefCount       Tsize_t
	Fchain          uintptr
}

func init() {
	p := unsafe.Pointer(&XtclDictType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_FreeDictInternalRep)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_DupDictInternalRep)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_UpdateStringOfDict)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_SetDictFromAny)
}

/*
 * The type of the specially adapted version of the Tcl_Obj*-containing hash
 * table defined in the tclObj.c code. This version differs in that it
 * allocates a bit more space in each hash entry in order to hold the pointers
 * used to keep the hash entries in a linked list.
 *
 * Note that this type of hash table is *only* suitable for direct use in
 * *this* file. Everything else should use the dict iterator API.
 */

var _chainHashType = TTcl_HashKeyType{
	Fversion: int32(TCL_HASH_KEY_TYPE_VERSION),
	Fflags:   int32(TCL_HASH_KEY_DIRECT_COMPARE),
}

func init() {
	p := unsafe.Pointer(&_chainHashType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(XTclHashObjKey)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(XTclCompareObjKeys)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_AllocChainEntry)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(XTclFreeObjEntry)
}

/*
 * Structure used in implementation of 'dict map' to hold the state that gets
 * passed between parts of the implementation.
 */

type TDictMapStorage = struct {
	FkeyVarObj      uintptr
	FvalueVarObj    uintptr
	Fsearch         TTcl_DictSearch
	FscriptObj      uintptr
	FaccumulatorObj uintptr
}

/***** START OF FUNCTIONS IMPLEMENTING DICT CORE API *****/

/*
 *----------------------------------------------------------------------
 *
 * AllocChainEntry --
 *
 *	Allocate space for a Tcl_HashEntry containing the Tcl_Obj * key, and
 *	which has a bit of extra space afterwards for storing pointers to the
 *	rest of the chain of entries (the extra pointers are left NULL).
 *
 * Results:
 *	The return value is a pointer to the created entry.
 *
 * Side effects:
 *	Increments the reference count on the object.
 *
 *----------------------------------------------------------------------
 */

func _AllocChainEntry(tls *libc.TLS, dummy226 uintptr, keyPtr uintptr) (r uintptr) {
	var cPtr, objPtr, v1 uintptr
	_, _, _ = cPtr, objPtr, v1
	objPtr = keyPtr
	cPtr = XTcl_Alloc(tls, uint64(56))
	*(*uintptr)(unsafe.Pointer(cPtr + 32)) = objPtr
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount++
	(*TTcl_HashEntry)(unsafe.Pointer(cPtr)).FclientData = libc.UintptrFromInt32(0)
	v1 = libc.UintptrFromInt32(0)
	(*TChainEntry)(unsafe.Pointer(cPtr)).FnextPtr = v1
	(*TChainEntry)(unsafe.Pointer(cPtr)).FprevPtr = v1
	return cPtr
}

/*
 * Helper functions that disguise most of the details relating to how the
 * linked list of hash entries is managed. In particular, these manage the
 * creation of the table and initializing of the chain, the deletion of the
 * table and chain, the adding of an entry to the chain, and the removal of an
 * entry from the chain.
 */

func _InitChainTable(tls *libc.TLS, dict uintptr) {
	var v1 uintptr
	_ = v1
	XTcl_InitCustomHashTable(tls, dict, -int32(1), uintptr(unsafe.Pointer(&_chainHashType)))
	v1 = libc.UintptrFromInt32(0)
	(*TDict)(unsafe.Pointer(dict)).FentryChainTail = v1
	(*TDict)(unsafe.Pointer(dict)).FentryChainHead = v1
}

func _DeleteChainTable(tls *libc.TLS, dict uintptr) {
	var cPtr, cachePtr, valuePtr, v3 uintptr
	var v2 TTcl_Size
	var v4 bool
	_, _, _, _, _, _ = cPtr, cachePtr, valuePtr, v2, v3, v4
	cPtr = (*TDict)(unsafe.Pointer(dict)).FentryChainHead
	for {
		if !(cPtr != libc.UintptrFromInt32(0)) {
			break
		}
		valuePtr = (*TTcl_HashEntry)(unsafe.Pointer(cPtr)).FclientData
		v3 = valuePtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if !(v2 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(valuePtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(valuePtr)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(valuePtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(valuePtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(valuePtr)).Flength = int64(-libc.Int32FromInt32(1))
				if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v4 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, valuePtr)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(valuePtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = valuePtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, valuePtr)
			}
		}
		goto _1
	_1:
		;
		cPtr = (*TChainEntry)(unsafe.Pointer(cPtr)).FnextPtr
	}
	XTcl_DeleteHashTable(tls, dict)
}

func _CreateChainEntry(tls *libc.TLS, dict uintptr, keyPtr uintptr, newPtr uintptr) (r uintptr) {
	var cPtr uintptr
	_ = cPtr
	cPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(dict)).FcreateProc})))(tls, dict, keyPtr, newPtr)
	/*
	 * If this is a new entry in the hash table, stitch it into the chain.
	 */
	if *(*int32)(unsafe.Pointer(newPtr)) != 0 {
		(*TChainEntry)(unsafe.Pointer(cPtr)).FnextPtr = libc.UintptrFromInt32(0)
		if (*TDict)(unsafe.Pointer(dict)).FentryChainHead == libc.UintptrFromInt32(0) {
			(*TChainEntry)(unsafe.Pointer(cPtr)).FprevPtr = libc.UintptrFromInt32(0)
			(*TDict)(unsafe.Pointer(dict)).FentryChainHead = cPtr
			(*TDict)(unsafe.Pointer(dict)).FentryChainTail = cPtr
		} else {
			(*TChainEntry)(unsafe.Pointer(cPtr)).FprevPtr = (*TDict)(unsafe.Pointer(dict)).FentryChainTail
			(*TChainEntry)(unsafe.Pointer((*TDict)(unsafe.Pointer(dict)).FentryChainTail)).FnextPtr = cPtr
			(*TDict)(unsafe.Pointer(dict)).FentryChainTail = cPtr
		}
	}
	return cPtr
}

func _DeleteChainEntry(tls *libc.TLS, dict uintptr, keyPtr uintptr) (r int32) {
	var cPtr, cachePtr, valuePtr, v2 uintptr
	var v1 TTcl_Size
	var v3 bool
	_, _, _, _, _, _ = cPtr, cachePtr, valuePtr, v1, v2, v3
	cPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(dict)).FfindProc})))(tls, dict, keyPtr)
	if cPtr == libc.UintptrFromInt32(0) {
		return 0
	} else {
		valuePtr = (*TTcl_HashEntry)(unsafe.Pointer(cPtr)).FclientData
		v2 = valuePtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if !(v1 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(valuePtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(valuePtr)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(valuePtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(valuePtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(valuePtr)).Flength = int64(-libc.Int32FromInt32(1))
				if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, valuePtr)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(valuePtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = valuePtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, valuePtr)
			}
		}
	}
	/*
	 * Unstitch from the chain.
	 */
	if (*TChainEntry)(unsafe.Pointer(cPtr)).FnextPtr != 0 {
		(*TChainEntry1)(unsafe.Pointer((*TChainEntry)(unsafe.Pointer(cPtr)).FnextPtr)).FprevPtr = (*TChainEntry)(unsafe.Pointer(cPtr)).FprevPtr
	} else {
		(*TDict)(unsafe.Pointer(dict)).FentryChainTail = (*TChainEntry)(unsafe.Pointer(cPtr)).FprevPtr
	}
	if (*TChainEntry)(unsafe.Pointer(cPtr)).FprevPtr != 0 {
		(*TChainEntry1)(unsafe.Pointer((*TChainEntry)(unsafe.Pointer(cPtr)).FprevPtr)).FnextPtr = (*TChainEntry)(unsafe.Pointer(cPtr)).FnextPtr
	} else {
		(*TDict)(unsafe.Pointer(dict)).FentryChainHead = (*TChainEntry)(unsafe.Pointer(cPtr)).FnextPtr
	}
	XTcl_DeleteHashEntry(tls, cPtr)
	return int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * DupDictInternalRep --
 *
 *	Initialize the internal representation of a dictionary Tcl_Obj to a
 *	copy of the internal representation of an existing dictionary object.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	"srcPtr"s dictionary internal rep pointer should not be NULL and we
 *	assume it is not NULL. We set "copyPtr"s internal rep to a pointer to
 *	a newly allocated dictionary rep that, in turn, points to "srcPtr"s
 *	key and value objects. Those objects are not actually copied but are
 *	shared between "srcPtr" and "copyPtr". The ref count of each key and
 *	value object is incremented.
 *
 *----------------------------------------------------------------------
 */

func _DupDictInternalRep(tls *libc.TLS, srcPtr uintptr, copyPtr uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var cPtr, hPtr, irPtr, key, newDict, oldDict, valuePtr, v1, v2, v4 uintptr
	var _ /* ir at bp+8 */ TTcl_ObjInternalRep
	var _ /* n at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _ = cPtr, hPtr, irPtr, key, newDict, oldDict, valuePtr, v1, v2, v4
	newDict = XTcl_Alloc(tls, uint64(144))
	if (*TTcl_Obj)(unsafe.Pointer(srcPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDictType)) {
		v1 = srcPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	oldDict = v2
	/*
	 * Copy values across from the old hash table.
	 */
	_InitChainTable(tls, newDict)
	cPtr = (*TDict)(unsafe.Pointer(oldDict)).FentryChainHead
	for {
		if !(cPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TTcl_HashTable)(unsafe.Pointer(oldDict)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(oldDict)).FkeyType == -int32(1) {
			v4 = *(*uintptr)(unsafe.Pointer(cPtr + 32))
		} else {
			v4 = cPtr + 32
		}
		key = v4
		valuePtr = (*TTcl_HashEntry)(unsafe.Pointer(cPtr)).FclientData
		hPtr = _CreateChainEntry(tls, newDict, key, bp)
		/*
		 * Fill in the contents.
		 */
		(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = valuePtr
		(*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount++
		goto _3
	_3:
		;
		cPtr = (*TChainEntry)(unsafe.Pointer(cPtr)).FnextPtr
	}
	/*
	 * Initialise other fields.
	 */
	(*TDict)(unsafe.Pointer(newDict)).Fepoch = uint64(1)
	(*TDict)(unsafe.Pointer(newDict)).Fchain = libc.UintptrFromInt32(0)
	(*TDict)(unsafe.Pointer(newDict)).FrefCount = uint64(1)
	/*
	 * Store in the object.
	 */
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp + 8))).Fptr1 = newDict
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp + 8))).Fptr2 = libc.UintptrFromInt32(0)
	XTcl_StoreInternalRep(tls, copyPtr, uintptr(unsafe.Pointer(&XtclDictType)), bp+8)
}

/*
 *----------------------------------------------------------------------
 *
 * FreeDictInternalRep --
 *
 *	Deallocate the storage associated with a dictionary object's internal
 *	representation.
 *
 * Results:
 *	None
 *
 * Side effects:
 *	Frees the memory holding the dictionary's internal hash table unless
 *	it is locked by an iteration going over it.
 *
 *----------------------------------------------------------------------
 */

func _FreeDictInternalRep(tls *libc.TLS, dictPtr uintptr) {
	var dict, irPtr, v1, v2, v4 uintptr
	var v3 Tsize_t
	_, _, _, _, _, _ = dict, irPtr, v1, v2, v3, v4
	if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDictType)) {
		v1 = dictPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	dict = v2
	v4 = dict + 128
	v3 = *(*Tsize_t)(unsafe.Pointer(v4))
	*(*Tsize_t)(unsafe.Pointer(v4))--
	if v3 <= uint64(1) {
		_DeleteDict(tls, dict)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * DeleteDict --
 *
 *	Delete the structure that is used to implement a dictionary's internal
 *	representation. Called when either the dictionary object loses its
 *	internal representation or when the last iteration over the dictionary
 *	completes.
 *
 * Results:
 *	None
 *
 * Side effects:
 *	Decrements the reference count of all key and value objects in the
 *	dictionary, which may free them.
 *
 *----------------------------------------------------------------------
 */

func _DeleteDict(tls *libc.TLS, dict uintptr) {
	_DeleteChainTable(tls, dict)
	XTclpFree(tls, dict)
}

/*
 *----------------------------------------------------------------------
 *
 * UpdateStringOfDict --
 *
 *	Update the string representation for a dictionary object. Note: This
 *	function does not invalidate an existing old string rep so storage
 *	will be lost if this has not already been done. This code is based on
 *	UpdateStringOfList in tclListObj.c
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The object's string is set to a valid string that results from the
 *	dict-to-string conversion. This string will be empty if the dictionary
 *	has no key/value pairs. The dictionary internal representation should
 *	not be NULL and we assume it is not NULL.
 *
 *----------------------------------------------------------------------
 */

func _UpdateStringOfDict(tls *libc.TLS, dictPtr uintptr) {
	bp := tls.Alloc(96)
	defer tls.Free(96)
	var bytesNeeded Tsize_t
	var cPtr, dict, dst, elem, flagPtr, irPtr, keyPtr, valuePtr, v1, v13, v14, v15, v17, v18, v2, v5, v6, v7, p11, p16 uintptr
	var i, numElems TTcl_Size
	var v12, v4 int32
	var v8, v9 bool
	var _ /* length at bp+64 */ TTcl_Size
	var _ /* localFlags at bp+0 */ [64]uint8
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bytesNeeded, cPtr, dict, dst, elem, flagPtr, i, irPtr, keyPtr, numElems, valuePtr, v1, v12, v13, v14, v15, v17, v18, v2, v4, v5, v6, v7, v8, v9, p11, p16
	flagPtr = libc.UintptrFromInt32(0)
	bytesNeeded = uint64(0)
	if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDictType)) {
		v1 = dictPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	dict = v2
	numElems = (*TDict)(unsafe.Pointer(dict)).Ftable.FnumEntries * int64(2)
	/* Handle empty list case first, simplifies what follows */
	if numElems == 0 {
		XTcl_InitStringRep(tls, dictPtr, libc.UintptrFromInt32(0), uint64(0))
		return
	}
	/*
	 * Pass 1: estimate space, gather flags.
	 */
	if numElems <= int64(LOCAL_SIZE) {
		flagPtr = bp
	} else {
		flagPtr = XTcl_Alloc(tls, libc.Uint64FromInt64(numElems))
	}
	i = 0
	cPtr = (*TDict)(unsafe.Pointer(dict)).FentryChainHead
	for {
		if !(i < numElems) {
			break
		}
		/*
		 * Assume that cPtr is never NULL since we know the number of array
		 * elements already.
		 */
		if i != 0 {
			v4 = int32(TCL_DONT_QUOTE_HASH)
		} else {
			v4 = 0
		}
		*(*uint8)(unsafe.Pointer(flagPtr + uintptr(i))) = libc.Uint8FromInt32(v4)
		if (*TTcl_HashTable)(unsafe.Pointer(dict)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(dict)).FkeyType == -int32(1) {
			v5 = *(*uintptr)(unsafe.Pointer(cPtr + 32))
		} else {
			v5 = cPtr + 32
		}
		keyPtr = v5
		if (*TTcl_Obj)(unsafe.Pointer(keyPtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 64)) = (*TTcl_Obj)(unsafe.Pointer(keyPtr)).Flength
			v6 = (*TTcl_Obj)(unsafe.Pointer(keyPtr)).Fbytes
		} else {
			v6 = XTcl_GetStringFromObj(tls, keyPtr, bp+64)
		}
		elem = v6
		bytesNeeded += libc.Uint64FromInt64(XTclScanElement(tls, elem, *(*TTcl_Size)(unsafe.Pointer(bp + 64)), flagPtr+uintptr(i)))
		*(*uint8)(unsafe.Pointer(flagPtr + uintptr(i+int64(1)))) = uint8(TCL_DONT_QUOTE_HASH)
		valuePtr = (*TTcl_HashEntry)(unsafe.Pointer(cPtr)).FclientData
		if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 64)) = (*TTcl_Obj)(unsafe.Pointer(valuePtr)).Flength
			v7 = (*TTcl_Obj)(unsafe.Pointer(valuePtr)).Fbytes
		} else {
			v7 = XTcl_GetStringFromObj(tls, valuePtr, bp+64)
		}
		elem = v7
		bytesNeeded += libc.Uint64FromInt64(XTclScanElement(tls, elem, *(*TTcl_Size)(unsafe.Pointer(bp + 64)), flagPtr+uintptr(i)+uintptr(1)))
		goto _3
	_3:
		;
		i += int64(2)
		cPtr = (*TChainEntry)(unsafe.Pointer(cPtr)).FnextPtr
	}
	bytesNeeded += libc.Uint64FromInt64(numElems)
	/*
	 * Pass 2: copy into string rep buffer.
	 */
	dst = XTcl_InitStringRep(tls, dictPtr, libc.UintptrFromInt32(0), bytesNeeded-uint64(1))
	if v9 = bytesNeeded != 0; v9 {
		if v8 = dst != 0; !v8 {
			XTcl_Panic(tls, __ccgo_ts+10479, libc.VaList(bp+80, bytesNeeded))
		}
	}
	_ = v9 && (v8 || libc.Bool(libc.Int32FromInt32(1) != 0))
	i = 0
	cPtr = (*TDict)(unsafe.Pointer(dict)).FentryChainHead
	for {
		if !(i < numElems) {
			break
		}
		p11 = flagPtr + uintptr(i)
		if i != 0 {
			v12 = int32(TCL_DONT_QUOTE_HASH)
		} else {
			v12 = 0
		}
		*(*uint8)(unsafe.Pointer(p11)) = uint8(int32(*(*uint8)(unsafe.Pointer(p11))) | v12)
		if (*TTcl_HashTable)(unsafe.Pointer(dict)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(dict)).FkeyType == -int32(1) {
			v13 = *(*uintptr)(unsafe.Pointer(cPtr + 32))
		} else {
			v13 = cPtr + 32
		}
		keyPtr = v13
		if (*TTcl_Obj)(unsafe.Pointer(keyPtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 64)) = (*TTcl_Obj)(unsafe.Pointer(keyPtr)).Flength
			v14 = (*TTcl_Obj)(unsafe.Pointer(keyPtr)).Fbytes
		} else {
			v14 = XTcl_GetStringFromObj(tls, keyPtr, bp+64)
		}
		elem = v14
		dst += uintptr(XTclConvertElement(tls, elem, *(*TTcl_Size)(unsafe.Pointer(bp + 64)), dst, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(flagPtr + uintptr(i))))))
		v15 = dst
		dst++
		*(*uint8)(unsafe.Pointer(v15)) = uint8(' ')
		p16 = flagPtr + uintptr(i+int64(1))
		*(*uint8)(unsafe.Pointer(p16)) = uint8(int32(*(*uint8)(unsafe.Pointer(p16))) | libc.Int32FromInt32(TCL_DONT_QUOTE_HASH))
		valuePtr = (*TTcl_HashEntry)(unsafe.Pointer(cPtr)).FclientData
		if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 64)) = (*TTcl_Obj)(unsafe.Pointer(valuePtr)).Flength
			v17 = (*TTcl_Obj)(unsafe.Pointer(valuePtr)).Fbytes
		} else {
			v17 = XTcl_GetStringFromObj(tls, valuePtr, bp+64)
		}
		elem = v17
		dst += uintptr(XTclConvertElement(tls, elem, *(*TTcl_Size)(unsafe.Pointer(bp + 64)), dst, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(flagPtr + uintptr(i+int64(1)))))))
		v18 = dst
		dst++
		*(*uint8)(unsafe.Pointer(v18)) = uint8(' ')
		goto _10
	_10:
		;
		i += int64(2)
		cPtr = (*TChainEntry)(unsafe.Pointer(cPtr)).FnextPtr
	}
	/* Last space overwrote the terminating NUL; cal T_ISR again to restore */
	XTcl_InitStringRep(tls, dictPtr, libc.UintptrFromInt32(0), bytesNeeded-uint64(1))
	if flagPtr != bp {
		XTclpFree(tls, flagPtr)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * SetDictFromAny --
 *
 *	Convert a non-dictionary object into a dictionary object. This code is
 *	very closely related to SetListFromAny in tclListObj.c but does not
 *	actually guarantee that a dictionary object will have a string rep (as
 *	conversions from lists are handled with a special case.)
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	If the string can be converted, it loses any old internal
 *	representation that it had and gains a dictionary's internalRep.
 *
 *----------------------------------------------------------------------
 */

func _SetDictFromAny(tls *libc.TLS, interp uintptr, objPtr uintptr) (r int32) {
	bp := tls.Alloc(128)
	defer tls.Free(128)
	var cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, dict, discardedValue, discardedValue1, dst, dst1, hPtr, keyPtr, limit, valuePtr, v11, v16, v19, v24, v27, v7, v9 uintptr
	var i, v15, v23, v26, v6 TTcl_Size
	var v10, v12, v13, v14, v17, v18, v20, v21, v22, v25, v28, v8 bool
	var v2, v3 int64
	var _ /* elemSize at bp+48 */ TTcl_Size
	var _ /* elemStart at bp+40 */ uintptr
	var _ /* ir at bp+64 */ TTcl_ObjInternalRep
	var _ /* isNew at bp+0 */ int32
	var _ /* length at bp+24 */ TTcl_Size
	var _ /* literal at bp+56 */ int32
	var _ /* nextElem at bp+32 */ uintptr
	var _ /* objc at bp+8 */ TTcl_Size
	var _ /* objv at bp+16 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, dict, discardedValue, discardedValue1, dst, dst1, hPtr, i, keyPtr, limit, valuePtr, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v3, v6, v7, v8, v9
	dict = XTcl_Alloc(tls, uint64(144))
	_InitChainTable(tls, dict)
	/*
	 * Since lists and dictionaries have very closely-related string
	 * representations (i.e. the same parsing code) we can safely special-case
	 * the conversion from lists to dictionaries.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		/* Cannot fail, we already know the Tcl_ObjType is "list". */
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr2 != 0 {
				v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr2)).FspanStart
			} else {
				v2 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 16)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr1 + 40 + uintptr(v2)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr2 != 0 {
				v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr2)).FspanLength
			} else {
				v3 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v3
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), objPtr, bp+8, bp+16)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8))&int64(1) != 0 {
			goto missingValue
		}
		i = 0
		for {
			if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) {
				break
			}
			/* Store key and value in the hash table we're building. */
			hPtr = _CreateChainEntry(tls, dict, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i)*8)), bp)
			if !(*(*int32)(unsafe.Pointer(bp)) != 0) {
				discardedValue = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
				/*
				 * Not really a well-formed dictionary as there are duplicate
				 * keys, so better get the string rep here so that we can
				 * convert back.
				 */
				if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
					_ = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
				} else {
					XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
				}
				v7 = discardedValue
				v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
				*(*TTcl_Size)(unsafe.Pointer(v7))--
				if !(v6 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(discardedValue)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(discardedValue)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(discardedValue)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(discardedValue)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(discardedValue)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(discardedValue)).Flength = int64(-libc.Int32FromInt32(1))
						if v8 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v8 {
							cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v8 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, discardedValue)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(discardedValue + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = discardedValue
							(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, discardedValue)
					}
				}
			}
			(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i+int64(1))*8))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i+int64(1))*8)))).FrefCount++ /* Since hash now holds ref to it */
			goto _4
		_4:
			;
			i += int64(2)
		}
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
			v9 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		} else {
			v9 = XTcl_GetStringFromObj(tls, objPtr, bp+24)
		}
		*(*uintptr)(unsafe.Pointer(bp + 32)) = v9
		limit = *(*uintptr)(unsafe.Pointer(bp + 32)) + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 24)))
		for *(*uintptr)(unsafe.Pointer(bp + 32)) < limit {
			if XTclFindDictElement(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 32)), int64(limit)-int64(*(*uintptr)(unsafe.Pointer(bp + 32))), bp+40, bp+32, bp+48, bp+56) != TCL_OK {
				goto errorInFindDictElement
			}
			if *(*uintptr)(unsafe.Pointer(bp + 40)) == limit {
				break
			}
			if *(*uintptr)(unsafe.Pointer(bp + 32)) == limit {
				goto missingValue
			}
			if *(*int32)(unsafe.Pointer(bp + 56)) != 0 {
				if v10 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v10 {
					cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v10 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
					keyPtr = XTclThreadAllocObj(tls)
				} else {
					keyPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(keyPtr + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(keyPtr)).FrefCount = 0
				if *(*TTcl_Size)(unsafe.Pointer(bp + 48)) == 0 {
					(*TTcl_Obj)(unsafe.Pointer(keyPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(keyPtr)).Flength = int64(libc.Int32FromInt32(0))
				} else {
					(*TTcl_Obj)(unsafe.Pointer(keyPtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 48))+libc.Int64FromUint32(1)))
					if *(*uintptr)(unsafe.Pointer(bp + 40)) != 0 {
						v11 = *(*uintptr)(unsafe.Pointer(bp + 40))
					} else {
						v11 = uintptr(unsafe.Pointer(&XtclEmptyString))
					}
					libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(keyPtr)).Fbytes, v11, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 48))))
					*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(keyPtr)).Fbytes + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 48))))) = uint8('\000')
					(*TTcl_Obj)(unsafe.Pointer(keyPtr)).Flength = *(*TTcl_Size)(unsafe.Pointer(bp + 48))
				}
				(*TTcl_Obj)(unsafe.Pointer(keyPtr)).FtypePtr = libc.UintptrFromInt32(0)
			} else {
				if v12 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v12 {
					cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v12 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
					keyPtr = XTclThreadAllocObj(tls)
				} else {
					keyPtr = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(keyPtr + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(keyPtr)).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer(keyPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(keyPtr)).Flength = 0
				(*TTcl_Obj)(unsafe.Pointer(keyPtr)).FtypePtr = libc.UintptrFromInt32(0)
				XTcl_InvalidateStringRep(tls, keyPtr)
				dst = XTcl_InitStringRep(tls, keyPtr, libc.UintptrFromInt32(0), libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 48))))
				if v14 = *(*TTcl_Size)(unsafe.Pointer(bp + 48)) != 0; v14 {
					if v13 = dst != 0; !v13 {
						XTcl_Panic(tls, __ccgo_ts+10479, libc.VaList(bp+88, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 48)))))
					}
				}
				_ = v14 && (v13 || libc.Bool(libc.Int32FromInt32(1) != 0)) /* Consider error */
				XTcl_InitStringRep(tls, keyPtr, libc.UintptrFromInt32(0), libc.Uint64FromInt64(XTclCopyAndCollapse(tls, *(*TTcl_Size)(unsafe.Pointer(bp + 48)), *(*uintptr)(unsafe.Pointer(bp + 40)), dst)))
			}
			if XTclFindDictElement(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 32)), int64(limit)-int64(*(*uintptr)(unsafe.Pointer(bp + 32))), bp+40, bp+32, bp+48, bp+56) != TCL_OK {
				v16 = keyPtr
				v15 = *(*TTcl_Size)(unsafe.Pointer(v16))
				*(*TTcl_Size)(unsafe.Pointer(v16))--
				if !(v15 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(keyPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(keyPtr)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(keyPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(keyPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(keyPtr)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(keyPtr)).Flength = int64(-libc.Int32FromInt32(1))
						if v17 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v17 {
							cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v17 || ((*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, keyPtr)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(keyPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = keyPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, keyPtr)
					}
				}
				goto errorInFindDictElement
			}
			if *(*int32)(unsafe.Pointer(bp + 56)) != 0 {
				if v18 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v18 {
					cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v18 || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == libc.Uint64FromInt32(0) {
					valuePtr = XTclThreadAllocObj(tls)
				} else {
					valuePtr = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(valuePtr + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount = 0
				if *(*TTcl_Size)(unsafe.Pointer(bp + 48)) == 0 {
					(*TTcl_Obj)(unsafe.Pointer(valuePtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(valuePtr)).Flength = int64(libc.Int32FromInt32(0))
				} else {
					(*TTcl_Obj)(unsafe.Pointer(valuePtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 48))+libc.Int64FromUint32(1)))
					if *(*uintptr)(unsafe.Pointer(bp + 40)) != 0 {
						v19 = *(*uintptr)(unsafe.Pointer(bp + 40))
					} else {
						v19 = uintptr(unsafe.Pointer(&XtclEmptyString))
					}
					libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(valuePtr)).Fbytes, v19, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 48))))
					*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(valuePtr)).Fbytes + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 48))))) = uint8('\000')
					(*TTcl_Obj)(unsafe.Pointer(valuePtr)).Flength = *(*TTcl_Size)(unsafe.Pointer(bp + 48))
				}
				(*TTcl_Obj)(unsafe.Pointer(valuePtr)).FtypePtr = libc.UintptrFromInt32(0)
			} else {
				if v20 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v20 {
					cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v20 || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == libc.Uint64FromInt32(0) {
					valuePtr = XTclThreadAllocObj(tls)
				} else {
					valuePtr = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(valuePtr + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer(valuePtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(valuePtr)).Flength = 0
				(*TTcl_Obj)(unsafe.Pointer(valuePtr)).FtypePtr = libc.UintptrFromInt32(0)
				XTcl_InvalidateStringRep(tls, valuePtr)
				dst1 = XTcl_InitStringRep(tls, valuePtr, libc.UintptrFromInt32(0), libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 48))))
				if v22 = *(*TTcl_Size)(unsafe.Pointer(bp + 48)) != 0; v22 {
					if v21 = dst1 != 0; !v21 {
						XTcl_Panic(tls, __ccgo_ts+10479, libc.VaList(bp+88, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 48)))))
					}
				}
				_ = v22 && (v21 || libc.Bool(libc.Int32FromInt32(1) != 0)) /* Consider error */
				XTcl_InitStringRep(tls, valuePtr, libc.UintptrFromInt32(0), libc.Uint64FromInt64(XTclCopyAndCollapse(tls, *(*TTcl_Size)(unsafe.Pointer(bp + 48)), *(*uintptr)(unsafe.Pointer(bp + 40)), dst1)))
			}
			/* Store key and value in the hash table we're building. */
			hPtr = _CreateChainEntry(tls, dict, keyPtr, bp)
			if !(*(*int32)(unsafe.Pointer(bp)) != 0) {
				discardedValue1 = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
				v24 = keyPtr
				v23 = *(*TTcl_Size)(unsafe.Pointer(v24))
				*(*TTcl_Size)(unsafe.Pointer(v24))--
				if !(v23 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(keyPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(keyPtr)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(keyPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(keyPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(keyPtr)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(keyPtr)).Flength = int64(-libc.Int32FromInt32(1))
						if v25 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v25 {
							cachePtr6 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v25 || ((*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, keyPtr)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(keyPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr = keyPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, keyPtr)
					}
				}
				v27 = discardedValue1
				v26 = *(*TTcl_Size)(unsafe.Pointer(v27))
				*(*TTcl_Size)(unsafe.Pointer(v27))--
				if !(v26 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(discardedValue1)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(discardedValue1)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(discardedValue1)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(discardedValue1)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(discardedValue1)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(discardedValue1)).Flength = int64(-libc.Int32FromInt32(1))
						if v28 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v28 {
							cachePtr7 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v28 || ((*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, discardedValue1)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(discardedValue1 + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr = discardedValue1
							(*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, discardedValue1)
					}
				}
			}
			(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = valuePtr
			(*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount++ /* since hash now holds ref to it */
		}
	}
	/*
	 * Free the old internalRep before setting the new one. We do this as late
	 * as possible to allow the conversion code, in particular
	 * Tcl_GetStringFromObj, to use that old internalRep.
	 */
	(*TDict)(unsafe.Pointer(dict)).Fepoch = uint64(1)
	(*TDict)(unsafe.Pointer(dict)).Fchain = libc.UintptrFromInt32(0)
	(*TDict)(unsafe.Pointer(dict)).FrefCount = uint64(1)
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp + 64))).Fptr1 = dict
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp + 64))).Fptr2 = libc.UintptrFromInt32(0)
	XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&XtclDictType)), bp+64)
	return TCL_OK
	goto missingValue
missingValue:
	;
	if interp != libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+26260, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+88, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+26289, libc.UintptrFromInt32(0)))
	}
	goto errorInFindDictElement
errorInFindDictElement:
	;
	_DeleteChainTable(tls, dict)
	XTclpFree(tls, dict)
	return int32(TCL_ERROR)
}

func _GetDictFromObj(tls *libc.TLS, interp uintptr, dictPtr uintptr) (r uintptr) {
	var dict, irPtr, irPtr1, v1, v2, v3, v4 uintptr
	_, _, _, _, _, _, _ = dict, irPtr, irPtr1, v1, v2, v3, v4
	if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDictType)) {
		v1 = dictPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	dict = v2
	if dict == libc.UintptrFromInt32(0) {
		if _SetDictFromAny(tls, interp, dictPtr) != TCL_OK {
			return libc.UintptrFromInt32(0)
		}
		if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDictType)) {
			v3 = dictPtr + 32
		} else {
			v3 = libc.UintptrFromInt32(0)
		}
		irPtr1 = v3
		if irPtr1 != 0 {
			v4 = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(irPtr1))).Fptr1
		} else {
			v4 = libc.UintptrFromInt32(0)
		}
		dict = v4
	}
	return dict
}

/*
 *----------------------------------------------------------------------
 *
 * TclTraceDictPath --
 *
 *	Trace through a tree of dictionaries using the array of keys given. If
 *	the flags argument has the DICT_PATH_UPDATE flag is set, a
 *	backward-pointing chain of dictionaries is also built (in the Dict's
 *	chain field) and the chained dictionaries are made into unshared
 *	dictionaries (if they aren't already.)
 *
 * Results:
 *	The object at the end of the path, or NULL if there was an error. Note
 *	that this it is an error for an intermediate dictionary on the path to
 *	not exist. If the flags argument has the DICT_PATH_EXISTS set, a
 *	non-existent path gives a DICT_PATH_NON_EXISTENT result.
 *
 * Side effects:
 *	If the flags argument is zero or DICT_PATH_EXISTS, there are no side
 *	effects (other than potential conversion of objects to dictionaries.)
 *	If the flags argument is DICT_PATH_UPDATE, the following additional
 *	side effects occur. Shared dictionaries along the path are converted
 *	into unshared objects, and a backward-pointing chain is built using
 *	the chain fields of the dictionaries (for easy invalidation of string
 *	representations using InvalidateDictChain). If the flags argument has
 *	the DICT_PATH_CREATE bits set (and not the DICT_PATH_EXISTS bit),
 *	non-extant keys will be inserted with a value of an empty
 *	dictionary, resulting in the path being built.
 *
 *----------------------------------------------------------------------
 */

func XTclTraceDictPath(tls *libc.TLS, interp uintptr, dictPtr uintptr, keyc TTcl_Size, keyv uintptr, flags int32) (r uintptr) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var cachePtr, dict, hPtr, irPtr, irPtr1, irPtr2, irPtr3, irPtr4, newDict, tmpObj, v1, v10, v11, v13, v15, v16, v2, v3, v4, v6, v7, v8, v9 uintptr
	var i, v12 TTcl_Size
	var v14 bool
	var _ /* isNew at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, dict, hPtr, i, irPtr, irPtr1, irPtr2, irPtr3, irPtr4, newDict, tmpObj, v1, v10, v11, v12, v13, v14, v15, v16, v2, v3, v4, v6, v7, v8, v9
	if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDictType)) {
		v1 = dictPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	dict = v2
	if dict == libc.UintptrFromInt32(0) {
		if _SetDictFromAny(tls, interp, dictPtr) != TCL_OK {
			return libc.UintptrFromInt32(0)
		}
		if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDictType)) {
			v3 = dictPtr + 32
		} else {
			v3 = libc.UintptrFromInt32(0)
		}
		irPtr1 = v3
		if irPtr1 != 0 {
			v4 = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(irPtr1))).Fptr1
		} else {
			v4 = libc.UintptrFromInt32(0)
		}
		dict = v4
	}
	if flags&int32(DICT_PATH_UPDATE) != 0 {
		(*TDict)(unsafe.Pointer(dict)).Fchain = libc.UintptrFromInt32(0)
	}
	i = 0
	for {
		if !(i < keyc) {
			break
		}
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(dict)).FfindProc})))(tls, dict, *(*uintptr)(unsafe.Pointer(keyv + uintptr(i)*8)))
		if hPtr == libc.UintptrFromInt32(0) { /* Dummy */
			if flags&int32(DICT_PATH_EXISTS) != 0 {
				return libc.UintptrFromInt32(1)
			}
			if flags&int32(DICT_PATH_CREATE) != int32(DICT_PATH_CREATE) {
				if interp != libc.UintptrFromInt32(0) {
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keyv + uintptr(i)*8)))).Fbytes != 0 {
						v6 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keyv + uintptr(i)*8)))).Fbytes
					} else {
						v6 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(keyv + uintptr(i)*8)), libc.UintptrFromInt32(0))
					}
					XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+26300, libc.VaList(bp+16, v6)))
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keyv + uintptr(i)*8)))).Fbytes != 0 {
						v7 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keyv + uintptr(i)*8)))).Fbytes
					} else {
						v7 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(keyv + uintptr(i)*8)), libc.UintptrFromInt32(0))
					}
					XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+26333, v7, libc.UintptrFromInt32(0)))
				}
				return libc.UintptrFromInt32(0)
			}
			/*
			 * The next line should always set isNew to 1.
			 */
			hPtr = _CreateChainEntry(tls, dict, *(*uintptr)(unsafe.Pointer(keyv + uintptr(i)*8)), bp)
			tmpObj = XTcl_NewDictObj(tls)
			(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FrefCount++
			(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = tmpObj
		} else {
			tmpObj = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
			if (*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclDictType)) {
				v8 = tmpObj + 32
			} else {
				v8 = libc.UintptrFromInt32(0)
			}
			irPtr2 = v8
			if irPtr2 != 0 {
				v9 = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(irPtr2))).Fptr1
			} else {
				v9 = libc.UintptrFromInt32(0)
			}
			newDict = v9
			if newDict == libc.UintptrFromInt32(0) {
				if _SetDictFromAny(tls, interp, tmpObj) != TCL_OK {
					return libc.UintptrFromInt32(0)
				}
			}
		}
		if (*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclDictType)) {
			v10 = tmpObj + 32
		} else {
			v10 = libc.UintptrFromInt32(0)
		}
		irPtr3 = v10
		if irPtr3 != 0 {
			v11 = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(irPtr3))).Fptr1
		} else {
			v11 = libc.UintptrFromInt32(0)
		}
		newDict = v11
		if flags&int32(DICT_PATH_UPDATE) != 0 {
			if (*TTcl_Obj)(unsafe.Pointer(tmpObj)).FrefCount > int64(1) {
				v13 = tmpObj
				v12 = *(*TTcl_Size)(unsafe.Pointer(v13))
				*(*TTcl_Size)(unsafe.Pointer(v13))--
				if !(v12 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = int64(-libc.Int32FromInt32(1))
						if v14 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v14 {
							cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v14 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, tmpObj)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(tmpObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = tmpObj
							(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, tmpObj)
					}
				}
				tmpObj = XTcl_DuplicateObj(tls, tmpObj)
				(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FrefCount++
				(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = tmpObj
				(*TDict)(unsafe.Pointer(dict)).Fepoch++
				if (*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclDictType)) {
					v15 = tmpObj + 32
				} else {
					v15 = libc.UintptrFromInt32(0)
				}
				irPtr4 = v15
				if irPtr4 != 0 {
					v16 = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(irPtr4))).Fptr1
				} else {
					v16 = libc.UintptrFromInt32(0)
				}
				newDict = v16
			}
			(*TDict)(unsafe.Pointer(newDict)).Fchain = dictPtr
		}
		dict = newDict
		dictPtr = tmpObj
		goto _5
	_5:
		;
		i++
	}
	return dictPtr
}

/*
 *----------------------------------------------------------------------
 *
 * InvalidateDictChain --
 *
 *	Go through a dictionary chain (built by an updating invocation of
 *	TclTraceDictPath) and invalidate the string representations of all the
 *	dictionaries on the chain.
 *
 * Results:
 *	None
 *
 * Side effects:
 *	String reps are invalidated and epoch counters (for detecting illegal
 *	concurrent modifications) are updated through the chain of updated
 *	dictionaries.
 *
 *----------------------------------------------------------------------
 */

func _InvalidateDictChain(tls *libc.TLS, dictObj uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _isobjPtr, dict, irPtr, irPtr1, v1, v2, v3, v4 uintptr
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_, _, _, _, _, _, _, _ = _isobjPtr, dict, irPtr, irPtr1, v1, v2, v3, v4
	if (*TTcl_Obj)(unsafe.Pointer(dictObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclDictType)) {
		v1 = dictObj + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	dict = v2
	for cond := true; cond; cond = dict != libc.UintptrFromInt32(0) {
		(*TDict)(unsafe.Pointer(dict)).FrefCount++
		_isobjPtr = dictObj
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
		}
		if (*TTcl_Obj)(unsafe.Pointer(dictObj)).FtypePtr != libc.UintptrFromInt32(0) {
			if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dictObj)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
				(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dictObj)).FtypePtr)).FfreeIntRepProc})))(tls, dictObj)
			}
			(*TTcl_Obj)(unsafe.Pointer(dictObj)).FtypePtr = libc.UintptrFromInt32(0)
		}
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(bp))).Fptr1 = dict
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(bp))).Fptr2 = libc.UintptrFromInt32(0)
		XTcl_StoreInternalRep(tls, dictObj, uintptr(unsafe.Pointer(&XtclDictType)), bp)
		(*TDict)(unsafe.Pointer(dict)).Fepoch++
		dictObj = (*TDict)(unsafe.Pointer(dict)).Fchain
		if dictObj == libc.UintptrFromInt32(0) {
			break
		}
		(*TDict)(unsafe.Pointer(dict)).Fchain = libc.UintptrFromInt32(0)
		if (*TTcl_Obj)(unsafe.Pointer(dictObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclDictType)) {
			v3 = dictObj + 32
		} else {
			v3 = libc.UintptrFromInt32(0)
		}
		irPtr1 = v3
		if irPtr1 != 0 {
			v4 = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(irPtr1))).Fptr1
		} else {
			v4 = libc.UintptrFromInt32(0)
		}
		dict = v4
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DictObjPut --
 *
 *	Add a key,value pair to a dictionary, or update the value for a key if
 *	that key already has a mapping in the dictionary.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	The object pointed to by dictPtr is converted to a dictionary if it is
 *	not already one, and any string representation that it has is
 *	invalidated.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DictObjPut(tls *libc.TLS, interp uintptr, dictPtr uintptr, keyPtr uintptr, valuePtr uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var _isobjPtr, cachePtr, dict, hPtr, oldValuePtr, v2 uintptr
	var v1 TTcl_Size
	var v3 bool
	var _ /* ir at bp+8 */ TTcl_ObjInternalRep
	var _ /* isNew at bp+0 */ int32
	_, _, _, _, _, _, _, _ = _isobjPtr, cachePtr, dict, hPtr, oldValuePtr, v1, v2, v3
	if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+10229, libc.VaList(bp+32, __ccgo_ts+26338))
	}
	dict = _GetDictFromObj(tls, interp, dictPtr)
	if dict == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	_isobjPtr = dictPtr
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
	hPtr = _CreateChainEntry(tls, dict, keyPtr, bp)
	(*TDict)(unsafe.Pointer(dict)).FrefCount++
	if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr != libc.UintptrFromInt32(0) {
		if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr)).FfreeIntRepProc})))(tls, dictPtr)
		}
		(*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr = libc.UintptrFromInt32(0)
	}
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp + 8))).Fptr1 = dict
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp + 8))).Fptr2 = libc.UintptrFromInt32(0)
	XTcl_StoreInternalRep(tls, dictPtr, uintptr(unsafe.Pointer(&XtclDictType)), bp+8)
	(*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount++
	if !(*(*int32)(unsafe.Pointer(bp)) != 0) {
		oldValuePtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		v2 = oldValuePtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if !(v1 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).Flength = int64(-libc.Int32FromInt32(1))
				if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, oldValuePtr)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(oldValuePtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = oldValuePtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, oldValuePtr)
			}
		}
	}
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = valuePtr
	(*TDict)(unsafe.Pointer(dict)).Fepoch++
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DictObjGet --
 *
 *	Given a key, get its value from the dictionary (or NULL if key is not
 *	found in dictionary.)
 *
 * Results:
 *	A standard Tcl result. The variable pointed to by valuePtrPtr is
 *	updated with the value for the key. Note that it is not an error for
 *	the key to have no mapping in the dictionary.
 *
 * Side effects:
 *	The object pointed to by dictPtr is converted to a dictionary if it is
 *	not already one.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DictObjGet(tls *libc.TLS, interp uintptr, dictPtr uintptr, keyPtr uintptr, valuePtrPtr uintptr) (r int32) {
	var dict, hPtr uintptr
	_, _ = dict, hPtr
	dict = _GetDictFromObj(tls, interp, dictPtr)
	if dict == libc.UintptrFromInt32(0) {
		*(*uintptr)(unsafe.Pointer(valuePtrPtr)) = libc.UintptrFromInt32(0)
		return int32(TCL_ERROR)
	}
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(dict)).FfindProc})))(tls, dict, keyPtr)
	if hPtr == libc.UintptrFromInt32(0) {
		*(*uintptr)(unsafe.Pointer(valuePtrPtr)) = libc.UintptrFromInt32(0)
	} else {
		*(*uintptr)(unsafe.Pointer(valuePtrPtr)) = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DictObjRemove --
 *
 *	Remove the key,value pair with the given key from the dictionary; the
 *	key does not need to be present in the dictionary.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	The object pointed to by dictPtr is converted to a dictionary if it is
 *	not already one, and any string representation that it has is
 *	invalidated.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DictObjRemove(tls *libc.TLS, interp uintptr, dictPtr uintptr, keyPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _isobjPtr, dict uintptr
	_, _ = _isobjPtr, dict
	if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+10229, libc.VaList(bp+8, __ccgo_ts+26353))
	}
	dict = _GetDictFromObj(tls, interp, dictPtr)
	if dict == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if _DeleteChainEntry(tls, dict, keyPtr) != 0 {
		_isobjPtr = dictPtr
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
		}
		(*TDict)(unsafe.Pointer(dict)).Fepoch++
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DictGetSize
 *
 *	Returns the size of dictPtr.  Caller must ensure that dictPtr has type
 *	'tclDicttype'.
 *
 *
 *----------------------------------------------------------------------
 */

func XTclDictGetSize(tls *libc.TLS, dictPtr uintptr) (r TTcl_Size) {
	var dict, irPtr, v1, v2 uintptr
	_, _, _, _ = dict, irPtr, v1, v2
	if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDictType)) {
		v1 = dictPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	dict = v2
	return (*TDict)(unsafe.Pointer(dict)).Ftable.FnumEntries
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DictObjSize --
 *
 *	How many key,value pairs are there in the dictionary?
 *
 * Results:
 *	A standard Tcl result. Updates the variable pointed to by sizePtr with
 *	the number of key,value pairs in the dictionary.
 *
 * Side effects:
 *	The dictPtr object is converted to a dictionary type if it is not a
 *	dictionary already.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DictObjSize(tls *libc.TLS, interp uintptr, dictPtr uintptr, sizePtr uintptr) (r int32) {
	var dict uintptr
	_ = dict
	dict = _GetDictFromObj(tls, interp, dictPtr)
	if dict == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	*(*TTcl_Size)(unsafe.Pointer(sizePtr)) = (*TDict)(unsafe.Pointer(dict)).Ftable.FnumEntries
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DictObjFirst --
 *
 *	Start a traversal of the dictionary. Caller must supply the search
 *	context, pointers for returning key and value, and a pointer to allow
 *	indication of whether the dictionary has been traversed (i.e. the
 *	dictionary is empty). The order of traversal is undefined.
 *
 * Results:
 *	A standard Tcl result. Updates the variables pointed to by keyPtrPtr,
 *	valuePtrPtr and donePtr. Either of keyPtrPtr and valuePtrPtr may be
 *	NULL, in which case the key/value is not made available to the caller.
 *
 * Side effects:
 *	The dictPtr object is converted to a dictionary type if it is not a
 *	dictionary already. The search context is initialised if the search
 *	has not finished. The dictionary's internal rep is Tcl_Preserve()d if
 *	the dictionary has at least one element.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DictObjFirst(tls *libc.TLS, interp uintptr, dictPtr uintptr, searchPtr uintptr, keyPtrPtr uintptr, valuePtrPtr uintptr, donePtr uintptr) (r int32) {
	/* Pointer to a variable which will have a 1
	 * written into when there are no further
	 * values in the dictionary, or a 0
	 * otherwise. */
	var cPtr, dict, v1 uintptr
	_, _, _ = cPtr, dict, v1
	dict = _GetDictFromObj(tls, interp, dictPtr)
	if dict == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	cPtr = (*TDict)(unsafe.Pointer(dict)).FentryChainHead
	if cPtr == libc.UintptrFromInt32(0) {
		(*TTcl_DictSearch)(unsafe.Pointer(searchPtr)).Fepoch = uint64(0)
		*(*int32)(unsafe.Pointer(donePtr)) = int32(1)
	} else {
		*(*int32)(unsafe.Pointer(donePtr)) = 0
		(*TTcl_DictSearch)(unsafe.Pointer(searchPtr)).FdictionaryPtr = dict
		(*TTcl_DictSearch)(unsafe.Pointer(searchPtr)).Fepoch = (*TDict)(unsafe.Pointer(dict)).Fepoch
		(*TTcl_DictSearch)(unsafe.Pointer(searchPtr)).Fnext = (*TChainEntry)(unsafe.Pointer(cPtr)).FnextPtr
		(*TDict)(unsafe.Pointer(dict)).FrefCount++
		if keyPtrPtr != libc.UintptrFromInt32(0) {
			if (*TTcl_HashTable)(unsafe.Pointer(dict)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(dict)).FkeyType == -int32(1) {
				v1 = *(*uintptr)(unsafe.Pointer(cPtr + 32))
			} else {
				v1 = cPtr + 32
			}
			*(*uintptr)(unsafe.Pointer(keyPtrPtr)) = v1
		}
		if valuePtrPtr != libc.UintptrFromInt32(0) {
			*(*uintptr)(unsafe.Pointer(valuePtrPtr)) = (*TTcl_HashEntry)(unsafe.Pointer(cPtr)).FclientData
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DictObjNext --
 *
 *	Continue a traversal of a dictionary previously started with
 *	Tcl_DictObjFirst. This function is safe against concurrent
 *	modification of the underlying object (including type shimmering),
 *	treating such situations as if the search has terminated, though it is
 *	up to the caller to ensure that the object itself is not disposed
 *	until the search has finished. It is _not_ safe against modifications
 *	from other threads.
 *
 * Results:
 *	Updates the variables pointed to by keyPtrPtr, valuePtrPtr and
 *	donePtr. Either of keyPtrPtr and valuePtrPtr may be NULL, in which
 *	case the key/value is not made available to the caller.
 *
 * Side effects:
 *	Removes a reference to the dictionary's internal rep if the search
 *	terminates.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DictObjNext(tls *libc.TLS, searchPtr uintptr, keyPtrPtr uintptr, valuePtrPtr uintptr, donePtr uintptr) {
	/* Pointer to a variable which will have a 1
	 * written into when there are no further
	 * values in the dictionary, or a 0
	 * otherwise. */
	var cPtr, v1 uintptr
	_, _ = cPtr, v1
	/*
	 * If the search is done; we do no work.
	 */
	if !((*TTcl_DictSearch)(unsafe.Pointer(searchPtr)).Fepoch != 0) {
		*(*int32)(unsafe.Pointer(donePtr)) = int32(1)
		return
	}
	/*
	 * Bail out if the dictionary has had any elements added, modified or
	 * removed. This *shouldn't* happen, but...
	 */
	if (*TDict)(unsafe.Pointer((*TTcl_DictSearch)(unsafe.Pointer(searchPtr)).FdictionaryPtr)).Fepoch != (*TTcl_DictSearch)(unsafe.Pointer(searchPtr)).Fepoch {
		XTcl_Panic(tls, __ccgo_ts+26371, 0)
	}
	cPtr = (*TTcl_DictSearch)(unsafe.Pointer(searchPtr)).Fnext
	if cPtr == libc.UintptrFromInt32(0) {
		XTcl_DictObjDone(tls, searchPtr)
		*(*int32)(unsafe.Pointer(donePtr)) = int32(1)
		return
	}
	(*TTcl_DictSearch)(unsafe.Pointer(searchPtr)).Fnext = (*TChainEntry)(unsafe.Pointer(cPtr)).FnextPtr
	*(*int32)(unsafe.Pointer(donePtr)) = 0
	if keyPtrPtr != libc.UintptrFromInt32(0) {
		if (*TTcl_HashTable)(unsafe.Pointer((*TTcl_DictSearch)(unsafe.Pointer(searchPtr)).FdictionaryPtr)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer((*TTcl_DictSearch)(unsafe.Pointer(searchPtr)).FdictionaryPtr)).FkeyType == -int32(1) {
			v1 = *(*uintptr)(unsafe.Pointer(cPtr + 32))
		} else {
			v1 = cPtr + 32
		}
		*(*uintptr)(unsafe.Pointer(keyPtrPtr)) = v1
	}
	if valuePtrPtr != libc.UintptrFromInt32(0) {
		*(*uintptr)(unsafe.Pointer(valuePtrPtr)) = (*TTcl_HashEntry)(unsafe.Pointer(cPtr)).FclientData
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DictObjDone --
 *
 *	Call this if you want to stop a search before you reach the end of the
 *	dictionary (e.g. because of abnormal termination of the search). It
 *	need not be used if the search reaches its natural end (i.e. if either
 *	Tcl_DictObjFirst or Tcl_DictObjNext sets its donePtr variable to 1).
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Removes a reference to the dictionary's internal rep.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DictObjDone(tls *libc.TLS, searchPtr uintptr) {
	/* Pointer to a hash search context. */
	var dict, v2 uintptr
	var v1 Tsize_t
	_, _, _ = dict, v1, v2
	if (*TTcl_DictSearch)(unsafe.Pointer(searchPtr)).Fepoch != 0 {
		(*TTcl_DictSearch)(unsafe.Pointer(searchPtr)).Fepoch = uint64(0)
		dict = (*TTcl_DictSearch)(unsafe.Pointer(searchPtr)).FdictionaryPtr
		v2 = dict + 128
		v1 = *(*Tsize_t)(unsafe.Pointer(v2))
		*(*Tsize_t)(unsafe.Pointer(v2))--
		if v1 <= uint64(1) {
			_DeleteDict(tls, dict)
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DictObjPutKeyList --
 *
 *	Add a key...key,value pair to a dictionary tree. The main dictionary
 *	value must not be shared, though sub-dictionaries may be. All
 *	intermediate dictionaries on the path must exist.
 *
 * Results:
 *	A standard Tcl result. Note that in the error case, a message is left
 *	in interp unless that is NULL.
 *
 * Side effects:
 *	If the dictionary and any of its sub-dictionaries on the path have
 *	string representations, these are invalidated.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DictObjPutKeyList(tls *libc.TLS, interp uintptr, dictPtr uintptr, keyc TTcl_Size, keyv uintptr, valuePtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var cachePtr, dict, hPtr, irPtr, oldValuePtr, v1, v2, v4 uintptr
	var v3 TTcl_Size
	var v5 bool
	var _ /* isNew at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _ = cachePtr, dict, hPtr, irPtr, oldValuePtr, v1, v2, v3, v4, v5
	if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+10229, libc.VaList(bp+16, __ccgo_ts+26417))
	}
	if keyc < int64(1) {
		XTcl_Panic(tls, __ccgo_ts+26439, libc.VaList(bp+16, __ccgo_ts+26417))
	}
	dictPtr = XTclTraceDictPath(tls, interp, dictPtr, keyc-int64(1), keyv, int32(DICT_PATH_CREATE))
	if dictPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDictType)) {
		v1 = dictPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	dict = v2
	hPtr = _CreateChainEntry(tls, dict, *(*uintptr)(unsafe.Pointer(keyv + uintptr(keyc-int64(1))*8)), bp)
	(*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount++
	if !(*(*int32)(unsafe.Pointer(bp)) != 0) {
		oldValuePtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		v4 = oldValuePtr
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if !(v3 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).Flength = int64(-libc.Int32FromInt32(1))
				if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v5 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, oldValuePtr)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(oldValuePtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = oldValuePtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, oldValuePtr)
			}
		}
	}
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = valuePtr
	_InvalidateDictChain(tls, dictPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DictObjRemoveKeyList --
 *
 *	Remove a key...key,value pair from a dictionary tree (the value
 *	removed is implicit in the key path). The main dictionary value must
 *	not be shared, though sub-dictionaries may be. It is not an error if
 *	there is no value associated with the given key list, but all
 *	intermediate dictionaries on the key path must exist.
 *
 * Results:
 *	A standard Tcl result. Note that in the error case, a message is left
 *	in interp unless that is NULL.
 *
 * Side effects:
 *	If the dictionary and any of its sub-dictionaries on the key path have
 *	string representations, these are invalidated.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DictObjRemoveKeyList(tls *libc.TLS, interp uintptr, dictPtr uintptr, keyc TTcl_Size, keyv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var dict, irPtr, v1, v2 uintptr
	_, _, _, _ = dict, irPtr, v1, v2
	if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+10229, libc.VaList(bp+8, __ccgo_ts+26469))
	}
	if keyc < int64(1) {
		XTcl_Panic(tls, __ccgo_ts+26439, libc.VaList(bp+8, __ccgo_ts+26469))
	}
	dictPtr = XTclTraceDictPath(tls, interp, dictPtr, keyc-int64(1), keyv, int32(DICT_PATH_UPDATE))
	if dictPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDictType)) {
		v1 = dictPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	dict = v2
	_DeleteChainEntry(tls, dict, *(*uintptr)(unsafe.Pointer(keyv + uintptr(keyc-int64(1))*8)))
	_InvalidateDictChain(tls, dictPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_NewDictObj --
 *
 *	This function is normally called when not debugging: i.e., when
 *	TCL_MEM_DEBUG is not defined. It creates a new dict object without any
 *	content.
 *
 *	When TCL_MEM_DEBUG is defined, this function just returns the result
 *	of calling the debugging version Tcl_DbNewDictObj.
 *
 * Results:
 *	A new dict object is returned; it has no keys defined in it. The new
 *	object's string representation is left NULL, and the ref count of the
 *	object is 0.
 *
 * Side Effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_NewDictObj(tls *libc.TLS) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _isobjPtr, cachePtr, dict, dictPtr uintptr
	var v1 bool
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_, _, _, _, _ = _isobjPtr, cachePtr, dict, dictPtr, v1
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		dictPtr = XTclThreadAllocObj(tls)
	} else {
		dictPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(dictPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr = libc.UintptrFromInt32(0)
	_isobjPtr = dictPtr
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
	dict = XTcl_Alloc(tls, uint64(144))
	_InitChainTable(tls, dict)
	(*TDict)(unsafe.Pointer(dict)).Fepoch = uint64(1)
	(*TDict)(unsafe.Pointer(dict)).Fchain = libc.UintptrFromInt32(0)
	(*TDict)(unsafe.Pointer(dict)).FrefCount = uint64(1)
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr1 = dict
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr2 = libc.UintptrFromInt32(0)
	XTcl_StoreInternalRep(tls, dictPtr, uintptr(unsafe.Pointer(&XtclDictType)), bp)
	return dictPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DbNewDictObj --
 *
 *	This function is normally called when debugging: i.e., when
 *	TCL_MEM_DEBUG is defined. It creates new dict objects. It is the same
 *	as the Tcl_NewDictObj function above except that it calls
 *	Tcl_DbCkalloc directly with the file name and line number from its
 *	caller. This simplifies debugging since then the [memory active]
 *	command will report the correct file name and line number when
 *	reporting objects that haven't been freed.
 *
 *	When TCL_MEM_DEBUG is not defined, this function just returns the
 *	result of calling Tcl_NewDictObj.
 *
 * Results:
 *	A new dict object is returned; it has no keys defined in it. The new
 *	object's string representation is left NULL, and the ref count of the
 *	object is 0.
 *
 * Side Effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DbNewDictObj(tls *libc.TLS, dummy1484 uintptr, dummy1485 int32) (r uintptr) {
	return XTcl_NewDictObj(tls)
}

/***** START OF FUNCTIONS ACTING AS HELPERS *****/

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * TclDictGet --
//	 *
//	 *	Given a key, get its value from the dictionary (or NULL if key is not
//	 *	found in dictionary.)
//	 *
//	 * Results:
//	 *	A standard Tcl result. The variable pointed to by valuePtrPtr is
//	 *	updated with the value for the key. Note that it is not an error for
//	 *	the key to have no mapping in the dictionary.
//	 *
//	 * Side effects:
//	 *	The object pointed to by dictPtr is converted to a dictionary if it is
//	 *	not already one.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func XTclDictGet(tls *libc.TLS, interp uintptr, dictPtr uintptr, key uintptr, valuePtrPtr uintptr) (r int32) {
	/* Where to write the value. */
	var _objPtr, keyPtr, v2 uintptr
	var code int32
	var v1 TTcl_Size
	_, _, _, _, _ = _objPtr, code, keyPtr, v1, v2
	keyPtr = XTcl_NewStringObj(tls, key, int64(-int32(1)))
	(*TTcl_Obj)(unsafe.Pointer(keyPtr)).FrefCount++
	code = XTcl_DictObjGet(tls, interp, dictPtr, keyPtr, valuePtrPtr)
	_objPtr = keyPtr
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return code
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * TclDictPut --
//	 *
//	 *	Add a key,value pair to a dictionary, or update the value for a key if
//	 *	that key already has a mapping in the dictionary.
//	 *
//	 *	If valuePtr is a zero-count object and is not written into the
//	 *	dictionary because of an error, it is freed by this routine. The caller
//	 *	does NOT need to do reference count management.
//	 *
//	 * Results:
//	 *	A standard Tcl result.
//	 *
//	 * Side effects:
//	 *	The object pointed to by dictPtr is converted to a dictionary if it is
//	 *	not already one, and any string representation that it has is
//	 *	invalidated.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func XTclDictPut(tls *libc.TLS, interp uintptr, dictPtr uintptr, key uintptr, valuePtr uintptr) (r int32) {
	/* The value to write in. */
	var _objPtr, _objPtr1, keyPtr, v2, v4 uintptr
	var code int32
	var v1, v3 TTcl_Size
	_, _, _, _, _, _, _, _ = _objPtr, _objPtr1, code, keyPtr, v1, v2, v3, v4
	keyPtr = XTcl_NewStringObj(tls, key, int64(-int32(1)))
	(*TTcl_Obj)(unsafe.Pointer(keyPtr)).FrefCount++
	(*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount++
	code = XTcl_DictObjPut(tls, interp, dictPtr, keyPtr, valuePtr)
	_objPtr = keyPtr
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	_objPtr1 = valuePtr
	v4 = _objPtr1
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	if v3 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	return code
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * TclDictPutString --
//	 *
//	 *	Add a key,value pair to a dictionary, or update the value for a key if
//	 *	that key already has a mapping in the dictionary.
//	 *
//	 * Results:
//	 *	A standard Tcl result.
//	 *
//	 * Side effects:
//	 *	The object pointed to by dictPtr is converted to a dictionary if it is
//	 *	not already one, and any string representation that it has is
//	 *	invalidated.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func XTclDictPutString(tls *libc.TLS, interp uintptr, dictPtr uintptr, key uintptr, value uintptr) (r int32) {
	/* The value in a C string. */
	var _objPtr, _objPtr1, keyPtr, valuePtr, v2, v4 uintptr
	var code int32
	var v1, v3 TTcl_Size
	_, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, code, keyPtr, valuePtr, v1, v2, v3, v4
	keyPtr = XTcl_NewStringObj(tls, key, int64(-int32(1)))
	valuePtr = XTcl_NewStringObj(tls, value, int64(-int32(1)))
	(*TTcl_Obj)(unsafe.Pointer(keyPtr)).FrefCount++
	(*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount++
	code = XTcl_DictObjPut(tls, interp, dictPtr, keyPtr, valuePtr)
	_objPtr = keyPtr
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	_objPtr1 = valuePtr
	v4 = _objPtr1
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	if v3 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	return code
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * TclDictRemove --
//	 *
//	 *	Remove the key,value pair with the given key from the dictionary; the
//	 *	key does not need to be present in the dictionary.
//	 *
//	 * Results:
//	 *	A standard Tcl result.
//	 *
//	 * Side effects:
//	 *	The object pointed to by dictPtr is converted to a dictionary if it is
//	 *	not already one, and any string representation that it has is
//	 *	invalidated.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func XTclDictRemove(tls *libc.TLS, interp uintptr, dictPtr uintptr, key uintptr) (r int32) {
	/* The key in a C string. */
	var _objPtr, keyPtr, v2 uintptr
	var code int32
	var v1 TTcl_Size
	_, _, _, _, _ = _objPtr, code, keyPtr, v1, v2
	keyPtr = XTcl_NewStringObj(tls, key, int64(-int32(1)))
	(*TTcl_Obj)(unsafe.Pointer(keyPtr)).FrefCount++
	code = XTcl_DictObjRemove(tls, interp, dictPtr, keyPtr)
	_objPtr = keyPtr
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return code
}

/***** START OF FUNCTIONS IMPLEMENTING TCL COMMANDS *****/

/*
 *----------------------------------------------------------------------
 *
 * DictCreateCmd --
 *
 *	This function implements the "dict create" Tcl command. See the user
 *	documentation for details on what it does, and TIP#111 for the formal
 *	specification.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _DictCreateCmd(tls *libc.TLS, dummy1660 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var dictObj uintptr
	var i int32
	_, _ = dictObj, i
	/*
	 * Must have an even number of arguments; note that number of preceding
	 * arguments (i.e. "dict create" is also even, which makes this much
	 * easier.)
	 */
	if objc&int32(1) == 0 {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+26494)
		return int32(TCL_ERROR)
	}
	dictObj = XTcl_NewDictObj(tls)
	i = int32(1)
	for {
		if !(i < objc) {
			break
		}
		/*
		 * The next command is assumed to never fail...
		 */
		XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dictObj, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)))
		goto _1
	_1:
		;
		i += int32(2)
	}
	XTcl_SetObjResult(tls, interp, dictObj)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * DictGetCmd --
 *
 *	This function implements the "dict get" Tcl command. See the user
 *	documentation for details on what it does, and TIP#111 for the formal
 *	specification.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _DictGetCmd(tls *libc.TLS, dummy1710 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(96)
	defer tls.Free(96)
	var dictPtr, listPtr, v1, v2 uintptr
	var result int32
	var _ /* done at bp+40 */ int32
	var _ /* keyPtr at bp+8 */ uintptr
	var _ /* search at bp+16 */ TTcl_DictSearch
	var _ /* valuePtr at bp+0 */ uintptr
	_, _, _, _, _ = dictPtr, listPtr, result, v1, v2
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+26510)
		return int32(TCL_ERROR)
	}
	/*
	 * Test for the special case of no keys, which returns a *list* of all
	 * key,value pairs. We produce a copy here because that makes subsequent
	 * list handling more efficient.
	 */
	if objc == int32(2) {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = libc.UintptrFromInt32(0)
		result = XTcl_DictObjFirst(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+16, bp+8, bp, bp+40)
		if result != TCL_OK {
			return result
		}
		listPtr = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
		for !(*(*int32)(unsafe.Pointer(bp + 40)) != 0) {
			/*
			 * Assume these won't fail as we have complete control over the
			 * types of things here.
			 */
			XTcl_ListObjAppendElement(tls, interp, listPtr, *(*uintptr)(unsafe.Pointer(bp + 8)))
			XTcl_ListObjAppendElement(tls, interp, listPtr, *(*uintptr)(unsafe.Pointer(bp)))
			XTcl_DictObjNext(tls, bp+16, bp+8, bp, bp+40)
		}
		XTcl_SetObjResult(tls, interp, listPtr)
		return TCL_OK
	}
	/*
	 * Loop through the list of keys, looking up the key at the current index
	 * in the current dictionary each time. Once we've done the lookup, we set
	 * the current dictionary to be the value we looked up (in case the value
	 * was not the last one and we are going through a chain of searches.)
	 * Note that this loop always executes at least once.
	 */
	dictPtr = XTclTraceDictPath(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), int64(objc-int32(3)), objv+uintptr(2)*8, DICT_PATH_READ)
	if dictPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	result = XTcl_DictObjGet(tls, interp, dictPtr, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), bp)
	if result != TCL_OK {
		return result
	}
	if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+26300, libc.VaList(bp+56, v1)))
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+56, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+26333, v2, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(bp)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * DictGetDefCmd --
 *
 *	This function implements the "dict getdef" and "dict getwithdefault"
 *	Tcl commands. See the user documentation for details on what it does,
 *	and TIP#342 for the formal specification.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _DictGetDefCmd(tls *libc.TLS, dummy1803 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var defaultPtr, dictPtr, keyPath, keyPtr uintptr
	var numKeys int32
	var _ /* valuePtr at bp+0 */ uintptr
	_, _, _, _, _ = defaultPtr, dictPtr, keyPath, keyPtr, numKeys
	if objc < int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+26531)
		return int32(TCL_ERROR)
	}
	/*
	 * Give the bits of arguments names for clarity.
	 */
	dictPtr = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	keyPath = objv + 2*8
	numKeys = objc - int32(4) /* Number of keys in keyPath; there's always
	 * one extra key afterwards too. */
	keyPtr = *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8))
	defaultPtr = *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8))
	/*
	 * Implement the getting-with-default operation.
	 */
	dictPtr = XTclTraceDictPath(tls, interp, dictPtr, int64(numKeys), keyPath, int32(DICT_PATH_EXISTS))
	if dictPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	} else {
		if dictPtr == libc.UintptrFromInt32(1) {
			XTcl_SetObjResult(tls, interp, defaultPtr)
		} else {
			if XTcl_DictObjGet(tls, interp, dictPtr, keyPtr, bp) != TCL_OK {
				return int32(TCL_ERROR)
			} else {
				if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
					XTcl_SetObjResult(tls, interp, defaultPtr)
				} else {
					XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(bp)))
				}
			}
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * DictReplaceCmd --
 *
 *	This function implements the "dict replace" Tcl command. See the user
 *	documentation for details on what it does, and TIP#111 for the formal
 *	specification.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _DictReplaceCmd(tls *libc.TLS, dummy1868 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var _isobjPtr, dictPtr uintptr
	var i int32
	_, _, _ = _isobjPtr, dictPtr, i
	if objc < int32(2) || objc&int32(1) != 0 {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+26564)
		return int32(TCL_ERROR)
	}
	dictPtr = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	if _GetDictFromObj(tls, interp, dictPtr) == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount > int64(1) {
		dictPtr = XTcl_DuplicateObj(tls, dictPtr)
	}
	_isobjPtr = dictPtr
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
	i = int32(2)
	for {
		if !(i < objc) {
			break
		}
		XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dictPtr, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)))
		goto _1
	_1:
		;
		i += int32(2)
	}
	XTcl_SetObjResult(tls, interp, dictPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * DictRemoveCmd --
 *
 *	This function implements the "dict remove" Tcl command. See the user
 *	documentation for details on what it does, and TIP#111 for the formal
 *	specification.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _DictRemoveCmd(tls *libc.TLS, dummy1916 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var _isobjPtr, dictPtr uintptr
	var i int32
	_, _, _ = _isobjPtr, dictPtr, i
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+26510)
		return int32(TCL_ERROR)
	}
	dictPtr = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	if _GetDictFromObj(tls, interp, dictPtr) == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount > int64(1) {
		dictPtr = XTcl_DuplicateObj(tls, dictPtr)
	}
	_isobjPtr = dictPtr
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
	i = int32(2)
	for {
		if !(i < objc) {
			break
		}
		XTcl_DictObjRemove(tls, libc.UintptrFromInt32(0), dictPtr, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))
		goto _1
	_1:
		;
		i++
	}
	XTcl_SetObjResult(tls, interp, dictPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * DictMergeCmd --
 *
 *	This function implements the "dict merge" Tcl command. See the user
 *	documentation for details on what it does, and TIP#163 for the formal
 *	specification.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _DictMergeCmd(tls *libc.TLS, dummy1964 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var allocatedDict, i int32
	var cachePtr, targetObj, v3 uintptr
	var v2 TTcl_Size
	var v4 bool
	var _ /* done at bp+16 */ int32
	var _ /* keyObj at bp+0 */ uintptr
	var _ /* search at bp+24 */ TTcl_DictSearch
	var _ /* valueObj at bp+8 */ uintptr
	_, _, _, _, _, _, _ = allocatedDict, cachePtr, i, targetObj, v2, v3, v4
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(bp + 8)) = libc.UintptrFromInt32(0)
	allocatedDict = 0
	if objc == int32(1) {
		/*
		 * No dictionary arguments; return default (empty value).
		 */
		return TCL_OK
	}
	/*
	 * Make sure first argument is a dictionary.
	 */
	targetObj = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	if _GetDictFromObj(tls, interp, targetObj) == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if objc == int32(2) {
		/*
		 * Single argument, return it.
		 */
		XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
		return TCL_OK
	}
	/*
	 * Normal behaviour: combining two (or more) dictionaries.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(targetObj)).FrefCount > int64(1) {
		targetObj = XTcl_DuplicateObj(tls, targetObj)
		allocatedDict = int32(1)
	}
	i = int32(2)
	for {
		if !(i < objc) {
			break
		}
		if XTcl_DictObjFirst(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp+24, bp, bp+8, bp+16) != TCL_OK {
			if allocatedDict != 0 {
				v3 = targetObj
				v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
				*(*TTcl_Size)(unsafe.Pointer(v3))--
				if !(v2 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(targetObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(targetObj)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(targetObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(targetObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(targetObj)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(targetObj)).Flength = int64(-libc.Int32FromInt32(1))
						if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
							cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v4 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, targetObj)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(targetObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = targetObj
							(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, targetObj)
					}
				}
			}
			return int32(TCL_ERROR)
		}
		for !(*(*int32)(unsafe.Pointer(bp + 16)) != 0) {
			/*
			 * Next line can't fail; already know we have a dictionary in
			 * targetObj.
			 */
			XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), targetObj, *(*uintptr)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 8)))
			XTcl_DictObjNext(tls, bp+24, bp, bp+8, bp+16)
		}
		XTcl_DictObjDone(tls, bp+24)
		goto _1
	_1:
		;
		i++
	}
	XTcl_SetObjResult(tls, interp, targetObj)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * DictKeysCmd --
 *
 *	This function implements the "dict keys" Tcl command. See the user
 *	documentation for details on what it does, and TIP#111 for the formal
 *	specification.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _DictKeysCmd(tls *libc.TLS, dummy2051 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var listPtr, pattern, v1, v3 uintptr
	var v4 bool
	var _ /* done at bp+40 */ int32
	var _ /* keyPtr at bp+32 */ uintptr
	var _ /* search at bp+8 */ TTcl_DictSearch
	var _ /* valuePtr at bp+0 */ uintptr
	_, _, _, _, _ = listPtr, pattern, v1, v3, v4
	pattern = libc.UintptrFromInt32(0)
	if objc != int32(2) && objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+26591)
		return int32(TCL_ERROR)
	}
	/*
	 * A direct check that we have a dictionary. We don't start the iteration
	 * yet because that might allocate memory or set locks that we do not
	 * need. [Bug 1705778, leak K04]
	 */
	if _GetDictFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8))) == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if objc == int32(3) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		pattern = v1
	}
	listPtr = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
	if pattern != libc.UintptrFromInt32(0) && libc.Xstrpbrk(tls, pattern, __ccgo_ts+16411) == libc.UintptrFromInt32(0) {
		*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
		XTcl_DictObjGet(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp)
		if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listPtr, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
		}
	} else {
		*(*uintptr)(unsafe.Pointer(bp + 32)) = libc.UintptrFromInt32(0)
		*(*int32)(unsafe.Pointer(bp + 40)) = 0
		/*
		 * At this point, we know we have a dictionary (or at least something
		 * that can be represented; it could theoretically have shimmered away
		 * when the pattern was fetched, but that shouldn't be damaging) so we
		 * can start the iteration process without checking for failures.
		 */
		XTcl_DictObjFirst(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+8, bp+32, libc.UintptrFromInt32(0), bp+40)
		for {
			if !!(*(*int32)(unsafe.Pointer(bp + 40)) != 0) {
				break
			}
			if v4 = !(pattern != 0); !v4 {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))).Fbytes != 0 {
					v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))).Fbytes
				} else {
					v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 32)), libc.UintptrFromInt32(0))
				}
			}
			if v4 || XTcl_StringCaseMatch(tls, v3, pattern, 0) != 0 {
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listPtr, *(*uintptr)(unsafe.Pointer(bp + 32)))
			}
			goto _2
		_2:
			;
			XTcl_DictObjNext(tls, bp+8, bp+32, libc.UintptrFromInt32(0), bp+40)
		}
		XTcl_DictObjDone(tls, bp+8)
	}
	XTcl_SetObjResult(tls, interp, listPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * DictValuesCmd --
 *
 *	This function implements the "dict values" Tcl command. See the user
 *	documentation for details on what it does, and TIP#111 for the formal
 *	specification.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _DictValuesCmd(tls *libc.TLS, dummy2130 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var listPtr, pattern, v1, v3 uintptr
	var v4 bool
	var _ /* done at bp+32 */ int32
	var _ /* search at bp+8 */ TTcl_DictSearch
	var _ /* valuePtr at bp+0 */ uintptr
	_, _, _, _, _ = listPtr, pattern, v1, v3, v4
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	if objc != int32(2) && objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+26591)
		return int32(TCL_ERROR)
	}
	if XTcl_DictObjFirst(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+8, libc.UintptrFromInt32(0), bp, bp+32) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if objc == int32(3) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		pattern = v1
	} else {
		pattern = libc.UintptrFromInt32(0)
	}
	listPtr = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
	for {
		if !!(*(*int32)(unsafe.Pointer(bp + 32)) != 0) {
			break
		}
		if v4 = pattern == libc.UintptrFromInt32(0); !v4 {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes != 0 {
				v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes
			} else {
				v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp)), libc.UintptrFromInt32(0))
			}
		}
		if v4 || XTcl_StringCaseMatch(tls, v3, pattern, 0) != 0 {
			/*
			 * Assume this operation always succeeds.
			 */
			XTcl_ListObjAppendElement(tls, interp, listPtr, *(*uintptr)(unsafe.Pointer(bp)))
		}
		goto _2
	_2:
		;
		XTcl_DictObjNext(tls, bp+8, libc.UintptrFromInt32(0), bp, bp+32)
	}
	XTcl_DictObjDone(tls, bp+8)
	XTcl_SetObjResult(tls, interp, listPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * DictSizeCmd --
 *
 *	This function implements the "dict size" Tcl command. See the user
 *	documentation for details on what it does, and TIP#111 for the formal
 *	specification.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _DictSizeCmd(tls *libc.TLS, dummy2190 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var result int32
	var _ /* size at bp+0 */ TTcl_Size
	_ = result
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+26612)
		return int32(TCL_ERROR)
	}
	result = XTcl_DictObjSize(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
	if result == TCL_OK {
		XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, *(*TTcl_Size)(unsafe.Pointer(bp))))
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * TclDictObjSmartRef --
 *
 *	This function returns new tcl-object with the smart reference to
 *	dictionary object.
 *
 *	Object returned with this function is a smart reference (pointer),
 *	so new object of type tclDictType, that directly references given
 *	dictionary object (with internally increased refCount).
 *
 *	The usage of such pointer objects allows to hold more as one
 *	reference to the same real dictionary object, allows to make a pointer
 *	to part of another dictionary, allows to change the dictionary without
 *	regarding of the "shared" state of the dictionary object.
 *
 *	Prevents "called with shared object" exception if object is multiple
 *	referenced.
 *
 * Results:
 *	The newly create object (contains smart reference) is returned.
 *	The returned object has a ref count of 0.
 *
 * Side effects:
 *	Increases ref count of the referenced dictionary.
 *
 *----------------------------------------------------------------------
 */

func XTclDictObjSmartRef(tls *libc.TLS, interp uintptr, dictPtr uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var dict, irPtr, result, v1, v2 uintptr
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_, _, _, _, _ = dict, irPtr, result, v1, v2
	if !((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDictType))) && _SetDictFromAny(tls, interp, dictPtr) != TCL_OK {
		return libc.UintptrFromInt32(0)
	}
	if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDictType)) {
		v1 = dictPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	dict = v2
	result = XTcl_NewObj(tls)
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr1 = dict
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr2 = libc.UintptrFromInt32(0)
	XTcl_StoreInternalRep(tls, result, uintptr(unsafe.Pointer(&XtclDictType)), bp)
	(*TDict)(unsafe.Pointer(dict)).FrefCount++
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(result + 32))).Fptr2 = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(result)).FtypePtr = uintptr(unsafe.Pointer(&XtclDictType))
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * DictExistsCmd --
 *
 *	This function implements the "dict exists" Tcl command. See the user
 *	documentation for details on what it does, and TIP#111 for the formal
 *	specification.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _DictExistsCmd(tls *libc.TLS, dummy2283 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var dictPtr uintptr
	var _ /* valuePtr at bp+0 */ uintptr
	_ = dictPtr
	if objc < int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+26623)
		return int32(TCL_ERROR)
	}
	dictPtr = XTclTraceDictPath(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + 1*8)), int64(objc-int32(3)), objv+uintptr(2)*8, int32(DICT_PATH_EXISTS))
	if dictPtr == libc.UintptrFromInt32(0) || dictPtr == libc.UintptrFromInt32(1) || XTcl_DictObjGet(tls, libc.UintptrFromInt32(0), dictPtr, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), bp) != TCL_OK {
		XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(0 != 0)))
	} else {
		XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(libc.BoolInt32(*(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0)) != 0)))
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * DictInfoCmd --
 *
 *	This function implements the "dict info" Tcl command. See the user
 *	documentation for details on what it does, and TIP#111 for the formal
 *	specification.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _DictInfoCmd(tls *libc.TLS, dummy2325 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var dict, statsStr uintptr
	_, _ = dict, statsStr
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+26612)
		return int32(TCL_ERROR)
	}
	dict = _GetDictFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if dict == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	statsStr = XTcl_HashStats(tls, dict)
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, statsStr, int64(-int32(1))))
	XTclpFree(tls, statsStr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * DictIncrCmd --
 *
 *	This function implements the "dict incr" Tcl command. See the user
 *	documentation for details on what it does, and TIP#111 for the formal
 *	specification.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _DictIncrCmd(tls *libc.TLS, dummy2369 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _isobjPtr, _isobjPtr1, cachePtr, cachePtr1, cachePtr2, cachePtr3, dictPtr, incrPtr, oldPtr, v4, v7 uintptr
	var code int32
	var v1, v2, v5, v8 bool
	var v3, v6 TTcl_Size
	var _ /* increment at bp+8 */ Tmp_int
	var _ /* valuePtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _isobjPtr, _isobjPtr1, cachePtr, cachePtr1, cachePtr2, cachePtr3, code, dictPtr, incrPtr, oldPtr, v1, v2, v3, v4, v5, v6, v7, v8
	code = TCL_OK
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	if objc < int32(3) || objc > int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+26648)
		return int32(TCL_ERROR)
	}
	dictPtr = XTcl_ObjGetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), 0)
	if dictPtr == libc.UintptrFromInt32(0) {
		/*
		 * Variable didn't yet exist. Create new dictionary value.
		 */
		dictPtr = XTcl_NewDictObj(tls)
	} else {
		if XTcl_DictObjGet(tls, interp, dictPtr, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp) != TCL_OK {
			/*
			 * Variable contents are not a dict, report error.
			 */
			return int32(TCL_ERROR)
		}
	}
	if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount > int64(1) {
		/*
		 * A little internals surgery to avoid copying a string rep that will
		 * soon be no good.
		 */
		oldPtr = dictPtr
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			dictPtr = XTclThreadAllocObj(tls)
		} else {
			dictPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(dictPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr = libc.UintptrFromInt32(0)
		_isobjPtr = dictPtr
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
		}
		_DupDictInternalRep(tls, oldPtr, dictPtr)
	}
	if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
		/*
		 * Key not in dictionary. Create new key with increment as value.
		 */
		if objc == int32(4) {
			code = XTcl_GetBignumFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)), bp+8)
			if code != TCL_OK {
				XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+26676, int64(-int32(1))))
			} else {
				/*
				 * Remember to dispose with the bignum as we're not actually
				 * using it directly. [Bug 2874678]
				 */
				XTclBN_mp_clear(tls, bp+8)
				XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dictPtr, *(*uintptr)(unsafe.Pointer(objv + 2*8)), *(*uintptr)(unsafe.Pointer(objv + 3*8)))
			}
		} else {
			XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dictPtr, *(*uintptr)(unsafe.Pointer(objv + 2*8)), XTcl_NewWideIntObj(tls, int64(1)))
		}
	} else {
		/*
		 * Key in dictionary. Increment its value with minimum dup.
		 */
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FrefCount > int64(1) {
			*(*uintptr)(unsafe.Pointer(bp)) = XTcl_DuplicateObj(tls, *(*uintptr)(unsafe.Pointer(bp)))
			XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dictPtr, *(*uintptr)(unsafe.Pointer(objv + 2*8)), *(*uintptr)(unsafe.Pointer(bp)))
		}
		if objc == int32(4) {
			code = XTclIncrObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(objv + 3*8)))
		} else {
			if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
				incrPtr = XTclThreadAllocObj(tls)
			} else {
				incrPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(incrPtr + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(incrPtr)).Fbytes = libc.UintptrFromInt32(0)
			*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FinternalRep)) = int64(libc.Int32FromInt32(1))
			(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
			(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FrefCount++
			code = XTclIncrObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), incrPtr)
			v4 = incrPtr
			v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
			*(*TTcl_Size)(unsafe.Pointer(v4))--
			if !(v3 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(incrPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(incrPtr)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(incrPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(incrPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(incrPtr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(incrPtr)).Flength = int64(-libc.Int32FromInt32(1))
					if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
						cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v5 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, incrPtr)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(incrPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = incrPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, incrPtr)
				}
			}
		}
	}
	if code == TCL_OK {
		_isobjPtr1 = dictPtr
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes = libc.UintptrFromInt32(0)
		}
		*(*uintptr)(unsafe.Pointer(bp)) = XTcl_ObjSetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), dictPtr, int32(TCL_LEAVE_ERR_MSG))
		if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
			code = int32(TCL_ERROR)
		} else {
			XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(bp)))
		}
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount == 0 {
			v7 = dictPtr
			v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
			*(*TTcl_Size)(unsafe.Pointer(v7))--
			if !(v6 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Flength = int64(-libc.Int32FromInt32(1))
					if v8 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v8 {
						cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v8 || ((*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, dictPtr)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(dictPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = dictPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, dictPtr)
				}
			}
		}
	}
	return code
}

/*
 *----------------------------------------------------------------------
 *
 * DictLappendCmd --
 *
 *	This function implements the "dict lappend" Tcl command. See the user
 *	documentation for details on what it does, and TIP#111 for the formal
 *	specification.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _DictLappendCmd(tls *libc.TLS, dummy2490 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _isobjPtr, cachePtr, cachePtr1, cachePtr2, dictPtr, resultPtr, v2, v6, v9 uintptr
	var allocatedDict, allocatedValue, i int32
	var v1, v5, v8 TTcl_Size
	var v10, v3, v7 bool
	var _ /* valuePtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _isobjPtr, allocatedDict, allocatedValue, cachePtr, cachePtr1, cachePtr2, dictPtr, i, resultPtr, v1, v10, v2, v3, v5, v6, v7, v8, v9
	allocatedDict = 0
	allocatedValue = 0
	if objc < int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+26701)
		return int32(TCL_ERROR)
	}
	dictPtr = XTcl_ObjGetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), 0)
	if dictPtr == libc.UintptrFromInt32(0) {
		allocatedDict = int32(1)
		dictPtr = XTcl_NewDictObj(tls)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount > int64(1) {
			allocatedDict = int32(1)
			dictPtr = XTcl_DuplicateObj(tls, dictPtr)
		}
	}
	if XTcl_DictObjGet(tls, interp, dictPtr, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp) != TCL_OK {
		if allocatedDict != 0 {
			v2 = dictPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if !(v1 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Flength = int64(-libc.Int32FromInt32(1))
					if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
						cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, dictPtr)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(dictPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = dictPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, dictPtr)
				}
			}
		}
		return int32(TCL_ERROR)
	}
	if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
		*(*uintptr)(unsafe.Pointer(bp)) = XTcl_NewListObj(tls, int64(objc-int32(3)), objv+uintptr(3)*8)
		allocatedValue = int32(1)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FrefCount > int64(1) {
			allocatedValue = int32(1)
			*(*uintptr)(unsafe.Pointer(bp)) = XTcl_DuplicateObj(tls, *(*uintptr)(unsafe.Pointer(bp)))
		}
		i = int32(3)
		for {
			if !(i < objc) {
				break
			}
			if XTcl_ListObjAppendElement(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))) != TCL_OK {
				if allocatedValue != 0 {
					v6 = *(*uintptr)(unsafe.Pointer(bp))
					v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
					*(*TTcl_Size)(unsafe.Pointer(v6))--
					if !(v5 > int64(1)) {
						if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr)).FfreeIntRepProc != 0) {
							if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
								XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes)
							}
							(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Flength = int64(-libc.Int32FromInt32(1))
							if v7 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v7 {
								cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
							}
							if v7 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
								XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp)))
							} else {
								(*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
								(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp))
								(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
							}
						} else {
							XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp)))
						}
					}
				}
				if allocatedDict != 0 {
					v9 = dictPtr
					v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
					*(*TTcl_Size)(unsafe.Pointer(v9))--
					if !(v8 > int64(1)) {
						if !((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr)).FfreeIntRepProc != 0) {
							if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
								XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes)
							}
							(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Flength = int64(-libc.Int32FromInt32(1))
							if v10 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v10 {
								cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
							}
							if v10 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
								XTclThreadFreeObj(tls, dictPtr)
							} else {
								(*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer(dictPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
								(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = dictPtr
								(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
							}
						} else {
							XTclFreeObj(tls, dictPtr)
						}
					}
				}
				return int32(TCL_ERROR)
			}
			goto _4
		_4:
			;
			i++
		}
	}
	if allocatedValue != 0 {
		XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dictPtr, *(*uintptr)(unsafe.Pointer(objv + 2*8)), *(*uintptr)(unsafe.Pointer(bp)))
	} else {
		_isobjPtr = dictPtr
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
		}
	}
	resultPtr = XTcl_ObjSetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), dictPtr, int32(TCL_LEAVE_ERR_MSG))
	if resultPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, resultPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * DictAppendCmd --
 *
 *	This function implements the "dict append" Tcl command. See the user
 *	documentation for details on what it does, and TIP#111 for the formal
 *	specification.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _DictAppendCmd(tls *libc.TLS, dummy2577 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, appendObjPtr, cachePtr, cachePtr1, dictPtr, resultPtr, v2, v6 uintptr
	var allocatedDict int32
	var v1, v5 TTcl_Size
	var v3, v4 bool
	var _ /* valuePtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, allocatedDict, appendObjPtr, cachePtr, cachePtr1, dictPtr, resultPtr, v1, v2, v3, v4, v5, v6
	allocatedDict = 0
	if objc < int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+26701)
		return int32(TCL_ERROR)
	}
	dictPtr = XTcl_ObjGetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), 0)
	if dictPtr == libc.UintptrFromInt32(0) {
		allocatedDict = int32(1)
		dictPtr = XTcl_NewDictObj(tls)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount > int64(1) {
			allocatedDict = int32(1)
			dictPtr = XTcl_DuplicateObj(tls, dictPtr)
		}
	}
	if XTcl_DictObjGet(tls, interp, dictPtr, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp) != TCL_OK {
		if allocatedDict != 0 {
			v2 = dictPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if !(v1 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Flength = int64(-libc.Int32FromInt32(1))
					if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
						cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, dictPtr)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(dictPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = dictPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, dictPtr)
				}
			}
		}
		return int32(TCL_ERROR)
	}
	if objc > int32(3) || *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
		/* Only go through append activites when something will change. */
		appendObjPtr = libc.UintptrFromInt32(0)
		if objc > int32(3) {
			/* Something to append */
			if objc == int32(4) {
				appendObjPtr = *(*uintptr)(unsafe.Pointer(objv + 3*8))
			} else {
				appendObjPtr = XTclStringCat(tls, interp, int64(objc-int32(3)), objv+uintptr(3)*8, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1))
				if appendObjPtr == libc.UintptrFromInt32(0) {
					return int32(TCL_ERROR)
				}
			}
		}
		if appendObjPtr == libc.UintptrFromInt32(0) {
			/* => (objc == 3) => (valuePtr == NULL) */
			if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
				*(*uintptr)(unsafe.Pointer(bp)) = XTclThreadAllocObj(tls)
			} else {
				*(*uintptr)(unsafe.Pointer(bp)) = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr = libc.UintptrFromInt32(0)
		} else {
			if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
				*(*uintptr)(unsafe.Pointer(bp)) = appendObjPtr
				appendObjPtr = libc.UintptrFromInt32(0)
			}
		}
		if appendObjPtr != 0 {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FrefCount > int64(1) {
				*(*uintptr)(unsafe.Pointer(bp)) = XTcl_DuplicateObj(tls, *(*uintptr)(unsafe.Pointer(bp)))
			}
			(*TTcl_Obj)(unsafe.Pointer(appendObjPtr)).FrefCount++
			XTcl_AppendObjToObj(tls, *(*uintptr)(unsafe.Pointer(bp)), appendObjPtr)
			_objPtr = appendObjPtr
			v6 = _objPtr
			v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
			*(*TTcl_Size)(unsafe.Pointer(v6))--
			if v5 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
		XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dictPtr, *(*uintptr)(unsafe.Pointer(objv + 2*8)), *(*uintptr)(unsafe.Pointer(bp)))
	}
	/*
	 * Even if nothing changed, we still overwrite so that variable
	 * trace expectations are met.
	 */
	resultPtr = XTcl_ObjSetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), dictPtr, int32(TCL_LEAVE_ERR_MSG))
	if resultPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, resultPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * DictForNRCmd --
 *
 *	These functions implement the "dict for" Tcl command.  See the user
 *	documentation for details on what it does, and TIP#111 for the formal
 *	specification.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _DictForNRCmd(tls *libc.TLS, dummy2679 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(96)
	defer tls.Free(96)
	var _objPtr, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, iPtr, keyVarObj, scriptObj, searchPtr, valueVarObj, v11, v15, v18, v21, v8 uintptr
	var v1 int32
	var v10, v14, v17, v20, v7 TTcl_Size
	var v12, v13, v16, v19, v22, v9 bool
	var v2, v3, v5, v6 int64
	var _ /* _callbackPtr at bp+40 */ uintptr
	var _ /* done at bp+32 */ int32
	var _ /* keyObj at bp+8 */ uintptr
	var _ /* valueObj at bp+16 */ uintptr
	var _ /* varc at bp+24 */ TTcl_Size
	var _ /* varv at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, iPtr, keyVarObj, scriptObj, searchPtr, valueVarObj, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v3, v5, v6, v7, v8, v9
	iPtr = interp
	if objc != int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+26729)
		return int32(TCL_ERROR)
	}
	/*
	 * Parse arguments.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanStart
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1 + 40 + uintptr(v2)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanLength
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = v3
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+24, bp)
	}
	if v1 != TCL_OK {
		return int32(TCL_ERROR)
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp + 24)) != int64(2) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+26773, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+56, __ccgo_ts+2004, __ccgo_ts+26810, __ccgo_ts+19222, __ccgo_ts+5187, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	searchPtr = XTclStackAlloc(tls, interp, uint64(24))
	if XTcl_DictObjFirst(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), searchPtr, bp+8, bp+16, bp+32) != TCL_OK {
		XTclStackFree(tls, interp, searchPtr)
		return int32(TCL_ERROR)
	}
	if *(*int32)(unsafe.Pointer(bp + 32)) != 0 {
		XTclStackFree(tls, interp, searchPtr)
		return TCL_OK
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
			v5 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanStart
		} else {
			v5 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1 + 40 + uintptr(v5)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
			v6 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanLength
		} else {
			v6 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = v6
		_ = libc.Int32FromInt32(TCL_OK)
	} else {
		XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+24, bp)
	}
	keyVarObj = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))
	valueVarObj = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1*8))
	scriptObj = *(*uintptr)(unsafe.Pointer(objv + 3*8))
	/*
	 * Make sure that these objects (which we need throughout the body of the
	 * loop) don't vanish. Note that the dictionary internal rep is locked
	 * internally so that updates, shimmering, etc are not a problem.
	 */
	(*TTcl_Obj)(unsafe.Pointer(keyVarObj)).FrefCount++
	(*TTcl_Obj)(unsafe.Pointer(valueVarObj)).FrefCount++
	(*TTcl_Obj)(unsafe.Pointer(scriptObj)).FrefCount++
	/*
	 * Stop the value from getting hit in any way by any traces on the key
	 * variable.
	 */
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount++
	if XTcl_ObjSetVar2(tls, interp, keyVarObj, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 8)), int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
		v8 = *(*uintptr)(unsafe.Pointer(bp + 16))
		v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
		*(*TTcl_Size)(unsafe.Pointer(v8))--
		if !(v7 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength = int64(-libc.Int32FromInt32(1))
				if v9 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v9 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v9 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp + 16))
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
			}
		}
		goto error
	}
	v11 = *(*uintptr)(unsafe.Pointer(bp + 16))
	v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
	*(*TTcl_Size)(unsafe.Pointer(v11))--
	if !(v10 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength = int64(-libc.Int32FromInt32(1))
			if v12 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v12 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v12 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp + 16))
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
		}
	}
	if XTcl_ObjSetVar2(tls, interp, valueVarObj, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 16)), int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
		goto error
	}
	/*
	 * Run the script.
	 */
	if v13 = interp == libc.UintptrFromInt32(0); !v13 {
		cachePtr2 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v13 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 40)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).FprocPtr = __ccgo_fp(_DictForLoopCallback)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 8)) = searchPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 8 + 1*8)) = keyVarObj
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 8 + 2*8)) = valueVarObj
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 8 + 3*8)) = scriptObj
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 40))
	return XTclNREvalObjEx(tls, interp, scriptObj, 0, (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr, int32(3))
	/*
	 * For unwinding everything on error.
	 */
	goto error
error:
	;
	v15 = keyVarObj
	v14 = *(*TTcl_Size)(unsafe.Pointer(v15))
	*(*TTcl_Size)(unsafe.Pointer(v15))--
	if !(v14 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(keyVarObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(keyVarObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(keyVarObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(keyVarObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(keyVarObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(keyVarObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v16 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v16 {
				cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v16 || ((*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, keyVarObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(keyVarObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = keyVarObj
				(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, keyVarObj)
		}
	}
	v18 = valueVarObj
	v17 = *(*TTcl_Size)(unsafe.Pointer(v18))
	*(*TTcl_Size)(unsafe.Pointer(v18))--
	if !(v17 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(valueVarObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(valueVarObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(valueVarObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(valueVarObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(valueVarObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(valueVarObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v19 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v19 {
				cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v19 || ((*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, valueVarObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(valueVarObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = valueVarObj
				(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, valueVarObj)
		}
	}
	v21 = scriptObj
	v20 = *(*TTcl_Size)(unsafe.Pointer(v21))
	*(*TTcl_Size)(unsafe.Pointer(v21))--
	if !(v20 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(scriptObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(scriptObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(scriptObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(scriptObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(scriptObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(scriptObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v22 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v22 {
				cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v22 || ((*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, scriptObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(scriptObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = scriptObj
				(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, scriptObj)
		}
	}
	XTcl_DictObjDone(tls, searchPtr)
	XTclStackFree(tls, interp, searchPtr)
	return int32(TCL_ERROR)
}

func _DictForLoopCallback(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var _objPtr, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, iPtr, keyVarObj, scriptObj, searchPtr, valueVarObj, v12, v15, v2, v5, v9 uintptr
	var v1, v11, v14, v4, v8 TTcl_Size
	var v10, v13, v16, v3, v6, v7 bool
	var _ /* _callbackPtr at bp+24 */ uintptr
	var _ /* done at bp+16 */ int32
	var _ /* keyObj at bp+0 */ uintptr
	var _ /* valueObj at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, iPtr, keyVarObj, scriptObj, searchPtr, valueVarObj, v1, v10, v11, v12, v13, v14, v15, v16, v2, v3, v4, v5, v6, v7, v8, v9
	iPtr = interp
	searchPtr = *(*uintptr)(unsafe.Pointer(data))
	keyVarObj = *(*uintptr)(unsafe.Pointer(data + 1*8))
	valueVarObj = *(*uintptr)(unsafe.Pointer(data + 2*8))
	scriptObj = *(*uintptr)(unsafe.Pointer(data + 3*8))
	/*
	 * Process the result from the previous execution of the script body.
	 */
	if result == int32(TCL_CONTINUE) {
		result = TCL_OK
	} else {
		if result != TCL_OK {
			if result == int32(TCL_BREAK) {
				XTcl_ResetResult(tls, interp)
				result = TCL_OK
			} else {
				if result == int32(TCL_ERROR) {
					XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+26817, libc.VaList(bp+40, XTcl_GetErrorLine(tls, interp))))
				}
			}
			goto done
		}
	}
	/*
	 * Get the next mapping from the dictionary.
	 */
	XTcl_DictObjNext(tls, searchPtr, bp, bp+8, bp+16)
	if *(*int32)(unsafe.Pointer(bp + 16)) != 0 {
		XTcl_ResetResult(tls, interp)
		goto done
	}
	/*
	 * Stop the value from getting hit in any way by any traces on the key
	 * variable.
	 */
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
	if XTcl_ObjSetVar2(tls, interp, keyVarObj, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
		v2 = *(*uintptr)(unsafe.Pointer(bp + 8))
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if !(v1 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = int64(-libc.Int32FromInt32(1))
				if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
			}
		}
		result = int32(TCL_ERROR)
		goto done
	}
	v5 = *(*uintptr)(unsafe.Pointer(bp + 8))
	v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
	*(*TTcl_Size)(unsafe.Pointer(v5))--
	if !(v4 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = int64(-libc.Int32FromInt32(1))
			if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v6 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
		}
	}
	if XTcl_ObjSetVar2(tls, interp, valueVarObj, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 8)), int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
		result = int32(TCL_ERROR)
		goto done
	}
	/*
	 * Run the script.
	 */
	if v7 = interp == libc.UintptrFromInt32(0); !v7 {
		cachePtr2 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v7 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 24)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).FprocPtr = __ccgo_fp(_DictForLoopCallback)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 8)) = searchPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 8 + 1*8)) = keyVarObj
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 8 + 2*8)) = valueVarObj
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 8 + 3*8)) = scriptObj
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 24))
	return XTclNREvalObjEx(tls, interp, scriptObj, 0, (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr, int32(3))
	/*
	 * For unwinding everything once the iterating is done.
	 */
	goto done
done:
	;
	v9 = keyVarObj
	v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
	*(*TTcl_Size)(unsafe.Pointer(v9))--
	if !(v8 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(keyVarObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(keyVarObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(keyVarObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(keyVarObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(keyVarObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(keyVarObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v10 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v10 {
				cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v10 || ((*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, keyVarObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(keyVarObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = keyVarObj
				(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, keyVarObj)
		}
	}
	v12 = valueVarObj
	v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
	*(*TTcl_Size)(unsafe.Pointer(v12))--
	if !(v11 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(valueVarObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(valueVarObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(valueVarObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(valueVarObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(valueVarObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(valueVarObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v13 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v13 {
				cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v13 || ((*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, valueVarObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(valueVarObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = valueVarObj
				(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, valueVarObj)
		}
	}
	v15 = scriptObj
	v14 = *(*TTcl_Size)(unsafe.Pointer(v15))
	*(*TTcl_Size)(unsafe.Pointer(v15))--
	if !(v14 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(scriptObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(scriptObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(scriptObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(scriptObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(scriptObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(scriptObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v16 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v16 {
				cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v16 || ((*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, scriptObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(scriptObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = scriptObj
				(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, scriptObj)
		}
	}
	XTcl_DictObjDone(tls, searchPtr)
	XTclStackFree(tls, interp, searchPtr)
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * DictMapNRCmd --
 *
 *	These functions implement the "dict map" Tcl command.  See the user
 *	documentation for details on what it does, and TIP#405 for the formal
 *	specification.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _DictMapNRCmd(tls *libc.TLS, dummy2875 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(96)
	defer tls.Free(96)
	var _objPtr, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cachePtr8, iPtr, storagePtr, v12, v15, v19, v22, v25, v28, v9 uintptr
	var v1 int32
	var v10, v13, v16, v17, v20, v23, v26, v29, v4 bool
	var v11, v14, v18, v21, v24, v27, v8 TTcl_Size
	var v2, v3, v6, v7 int64
	var _ /* _callbackPtr at bp+40 */ uintptr
	var _ /* done at bp+32 */ int32
	var _ /* keyObj at bp+8 */ uintptr
	var _ /* valueObj at bp+16 */ uintptr
	var _ /* varc at bp+24 */ TTcl_Size
	var _ /* varv at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cachePtr8, iPtr, storagePtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v4, v6, v7, v8, v9
	iPtr = interp
	if objc != int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+26729)
		return int32(TCL_ERROR)
	}
	/*
	 * Parse arguments.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanStart
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1 + 40 + uintptr(v2)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanLength
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = v3
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+24, bp)
	}
	if v1 != TCL_OK {
		return int32(TCL_ERROR)
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp + 24)) != int64(2) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+26773, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+56, __ccgo_ts+2004, __ccgo_ts+26810, __ccgo_ts+19222, __ccgo_ts+19715, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	storagePtr = XTclStackAlloc(tls, interp, uint64(56))
	if XTcl_DictObjFirst(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), storagePtr+16, bp+8, bp+16, bp+32) != TCL_OK {
		XTclStackFree(tls, interp, storagePtr)
		return int32(TCL_ERROR)
	}
	if *(*int32)(unsafe.Pointer(bp + 32)) != 0 {
		/*
		 * Note that this exit leaves an empty value in the result (due to
		 * command calling conventions) but that is OK since an empty value is
		 * an empty dictionary.
		 */
		XTclStackFree(tls, interp, storagePtr)
		return TCL_OK
	}
	if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		(*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj = XTclThreadAllocObj(tls)
	} else {
		(*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj)).FtypePtr = libc.UintptrFromInt32(0)
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
			v6 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanStart
		} else {
			v6 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1 + 40 + uintptr(v6)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
			v7 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanLength
		} else {
			v7 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = v7
		_ = libc.Int32FromInt32(TCL_OK)
	} else {
		XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+24, bp)
	}
	(*TDictMapStorage)(unsafe.Pointer(storagePtr)).FkeyVarObj = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))
	(*TDictMapStorage)(unsafe.Pointer(storagePtr)).FvalueVarObj = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1*8))
	(*TDictMapStorage)(unsafe.Pointer(storagePtr)).FscriptObj = *(*uintptr)(unsafe.Pointer(objv + 3*8))
	/*
	 * Make sure that these objects (which we need throughout the body of the
	 * loop) don't vanish. Note that the dictionary internal rep is locked
	 * internally so that updates, shimmering, etc are not a problem.
	 */
	(*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj)).FrefCount++
	(*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FkeyVarObj)).FrefCount++
	(*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FvalueVarObj)).FrefCount++
	(*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FscriptObj)).FrefCount++
	/*
	 * Stop the value from getting hit in any way by any traces on the key
	 * variable.
	 */
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount++
	if XTcl_ObjSetVar2(tls, interp, (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FkeyVarObj, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 8)), int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
		v9 = *(*uintptr)(unsafe.Pointer(bp + 16))
		v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
		*(*TTcl_Size)(unsafe.Pointer(v9))--
		if !(v8 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength = int64(-libc.Int32FromInt32(1))
				if v10 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v10 {
					cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v10 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp + 16))
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
			}
		}
		goto error
	}
	if XTcl_ObjSetVar2(tls, interp, (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FvalueVarObj, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 16)), int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
		v12 = *(*uintptr)(unsafe.Pointer(bp + 16))
		v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
		*(*TTcl_Size)(unsafe.Pointer(v12))--
		if !(v11 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength = int64(-libc.Int32FromInt32(1))
				if v13 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v13 {
					cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v13 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp + 16))
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
			}
		}
		goto error
	}
	v15 = *(*uintptr)(unsafe.Pointer(bp + 16))
	v14 = *(*TTcl_Size)(unsafe.Pointer(v15))
	*(*TTcl_Size)(unsafe.Pointer(v15))--
	if !(v14 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength = int64(-libc.Int32FromInt32(1))
			if v16 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v16 {
				cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v16 || ((*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp + 16))
				(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
		}
	}
	/*
	 * Run the script.
	 */
	if v17 = interp == libc.UintptrFromInt32(0); !v17 {
		cachePtr4 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v17 || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 40)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).FprocPtr = __ccgo_fp(_DictMapLoopCallback)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 8)) = storagePtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 40))
	return XTclNREvalObjEx(tls, interp, (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FscriptObj, 0, (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr, int32(3))
	/*
	 * For unwinding everything on error.
	 */
	goto error
error:
	;
	v19 = (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FkeyVarObj
	v18 = *(*TTcl_Size)(unsafe.Pointer(v19))
	*(*TTcl_Size)(unsafe.Pointer(v19))--
	if !(v18 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FkeyVarObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FkeyVarObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FkeyVarObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FkeyVarObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FkeyVarObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FkeyVarObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v20 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v20 {
				cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v20 || ((*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FkeyVarObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FkeyVarObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FkeyVarObj
				(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FkeyVarObj)
		}
	}
	v22 = (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FvalueVarObj
	v21 = *(*TTcl_Size)(unsafe.Pointer(v22))
	*(*TTcl_Size)(unsafe.Pointer(v22))--
	if !(v21 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FvalueVarObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FvalueVarObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FvalueVarObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FvalueVarObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FvalueVarObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FvalueVarObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v23 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v23 {
				cachePtr6 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v23 || ((*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FvalueVarObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FvalueVarObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr = (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FvalueVarObj
				(*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FvalueVarObj)
		}
	}
	v25 = (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FscriptObj
	v24 = *(*TTcl_Size)(unsafe.Pointer(v25))
	*(*TTcl_Size)(unsafe.Pointer(v25))--
	if !(v24 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FscriptObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FscriptObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FscriptObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FscriptObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FscriptObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FscriptObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v26 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v26 {
				cachePtr7 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v26 || ((*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FscriptObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FscriptObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr = (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FscriptObj
				(*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FscriptObj)
		}
	}
	v28 = (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj
	v27 = *(*TTcl_Size)(unsafe.Pointer(v28))
	*(*TTcl_Size)(unsafe.Pointer(v28))--
	if !(v27 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v29 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v29 {
				cachePtr8 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v29 || ((*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr8)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr8)).FfirstObjPtr = (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj
				(*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj)
		}
	}
	XTcl_DictObjDone(tls, storagePtr+16)
	XTclStackFree(tls, interp, storagePtr)
	return int32(TCL_ERROR)
}

func _DictMapLoopCallback(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var _objPtr, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, iPtr, storagePtr, v12, v15, v18, v2, v21, v5, v8 uintptr
	var v1, v11, v14, v17, v20, v4, v7 TTcl_Size
	var v10, v13, v16, v19, v22, v3, v6, v9 bool
	var _ /* _callbackPtr at bp+24 */ uintptr
	var _ /* done at bp+16 */ int32
	var _ /* keyObj at bp+0 */ uintptr
	var _ /* valueObj at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, iPtr, storagePtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v3, v4, v5, v6, v7, v8, v9
	iPtr = interp
	storagePtr = *(*uintptr)(unsafe.Pointer(data))
	/*
	 * Process the result from the previous execution of the script body.
	 */
	if result == int32(TCL_CONTINUE) {
		result = TCL_OK
	} else {
		if result != TCL_OK {
			if result == int32(TCL_BREAK) {
				XTcl_ResetResult(tls, interp)
				result = TCL_OK
			} else {
				if result == int32(TCL_ERROR) {
					XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+26848, libc.VaList(bp+40, XTcl_GetErrorLine(tls, interp))))
				}
			}
			goto done
		} else {
			*(*uintptr)(unsafe.Pointer(bp)) = XTcl_ObjGetVar2(tls, interp, (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FkeyVarObj, libc.UintptrFromInt32(0), int32(TCL_LEAVE_ERR_MSG))
			if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
				result = int32(TCL_ERROR)
				goto done
			}
			XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj, *(*uintptr)(unsafe.Pointer(bp)), XTcl_GetObjResult(tls, interp))
		}
	}
	/*
	 * Get the next mapping from the dictionary.
	 */
	XTcl_DictObjNext(tls, storagePtr+16, bp, bp+8, bp+16)
	if *(*int32)(unsafe.Pointer(bp + 16)) != 0 {
		XTcl_SetObjResult(tls, interp, (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj)
		goto done
	}
	/*
	 * Stop the value from getting hit in any way by any traces on the key
	 * variable.
	 */
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
	if XTcl_ObjSetVar2(tls, interp, (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FkeyVarObj, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
		v2 = *(*uintptr)(unsafe.Pointer(bp + 8))
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if !(v1 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = int64(-libc.Int32FromInt32(1))
				if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
			}
		}
		result = int32(TCL_ERROR)
		goto done
	}
	if XTcl_ObjSetVar2(tls, interp, (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FvalueVarObj, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 8)), int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
		v5 = *(*uintptr)(unsafe.Pointer(bp + 8))
		v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
		*(*TTcl_Size)(unsafe.Pointer(v5))--
		if !(v4 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = int64(-libc.Int32FromInt32(1))
				if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
					cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v6 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
			}
		}
		result = int32(TCL_ERROR)
		goto done
	}
	v8 = *(*uintptr)(unsafe.Pointer(bp + 8))
	v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
	*(*TTcl_Size)(unsafe.Pointer(v8))--
	if !(v7 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = int64(-libc.Int32FromInt32(1))
			if v9 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v9 {
				cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v9 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
		}
	}
	/*
	 * Run the script.
	 */
	if v10 = interp == libc.UintptrFromInt32(0); !v10 {
		cachePtr3 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v10 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 24)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).FprocPtr = __ccgo_fp(_DictMapLoopCallback)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 8)) = storagePtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 24))
	return XTclNREvalObjEx(tls, interp, (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FscriptObj, 0, (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr, int32(3))
	/*
	 * For unwinding everything once the iterating is done.
	 */
	goto done
done:
	;
	v12 = (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FkeyVarObj
	v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
	*(*TTcl_Size)(unsafe.Pointer(v12))--
	if !(v11 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FkeyVarObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FkeyVarObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FkeyVarObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FkeyVarObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FkeyVarObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FkeyVarObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v13 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v13 {
				cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v13 || ((*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FkeyVarObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FkeyVarObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FkeyVarObj
				(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FkeyVarObj)
		}
	}
	v15 = (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FvalueVarObj
	v14 = *(*TTcl_Size)(unsafe.Pointer(v15))
	*(*TTcl_Size)(unsafe.Pointer(v15))--
	if !(v14 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FvalueVarObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FvalueVarObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FvalueVarObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FvalueVarObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FvalueVarObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FvalueVarObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v16 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v16 {
				cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v16 || ((*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FvalueVarObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FvalueVarObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FvalueVarObj
				(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FvalueVarObj)
		}
	}
	v18 = (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FscriptObj
	v17 = *(*TTcl_Size)(unsafe.Pointer(v18))
	*(*TTcl_Size)(unsafe.Pointer(v18))--
	if !(v17 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FscriptObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FscriptObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FscriptObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FscriptObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FscriptObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FscriptObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v19 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v19 {
				cachePtr6 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v19 || ((*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FscriptObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FscriptObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr = (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FscriptObj
				(*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FscriptObj)
		}
	}
	v21 = (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj
	v20 = *(*TTcl_Size)(unsafe.Pointer(v21))
	*(*TTcl_Size)(unsafe.Pointer(v21))--
	if !(v20 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v22 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v22 {
				cachePtr7 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v22 || ((*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr = (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj
				(*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, (*TDictMapStorage)(unsafe.Pointer(storagePtr)).FaccumulatorObj)
		}
	}
	XTcl_DictObjDone(tls, storagePtr+16)
	XTclStackFree(tls, interp, storagePtr)
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * DictSetCmd --
 *
 *	This function implements the "dict set" Tcl command. See the user
 *	documentation for details on what it does, and TIP#111 for the formal
 *	specification.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _DictSetCmd(tls *libc.TLS, dummy3088 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var allocatedDict, result int32
	var cachePtr, dictPtr, resultPtr, v2 uintptr
	var v1 TTcl_Size
	var v3 bool
	_, _, _, _, _, _, _, _ = allocatedDict, cachePtr, dictPtr, result, resultPtr, v1, v2, v3
	allocatedDict = 0
	if objc < int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+26879)
		return int32(TCL_ERROR)
	}
	dictPtr = XTcl_ObjGetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), 0)
	if dictPtr == libc.UintptrFromInt32(0) {
		allocatedDict = int32(1)
		dictPtr = XTcl_NewDictObj(tls)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount > int64(1) {
			allocatedDict = int32(1)
			dictPtr = XTcl_DuplicateObj(tls, dictPtr)
		}
	}
	result = XTcl_DictObjPutKeyList(tls, interp, dictPtr, int64(objc-int32(3)), objv+uintptr(2)*8, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))
	if result != TCL_OK {
		if allocatedDict != 0 {
			v2 = dictPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if !(v1 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Flength = int64(-libc.Int32FromInt32(1))
					if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
						cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, dictPtr)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(dictPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = dictPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, dictPtr)
				}
			}
		}
		return int32(TCL_ERROR)
	}
	resultPtr = XTcl_ObjSetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), dictPtr, int32(TCL_LEAVE_ERR_MSG))
	if resultPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, resultPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * DictUnsetCmd --
 *
 *	This function implements the "dict unset" Tcl command. See the user
 *	documentation for details on what it does, and TIP#111 for the formal
 *	specification.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _DictUnsetCmd(tls *libc.TLS, dummy3148 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var allocatedDict, result int32
	var cachePtr, dictPtr, resultPtr, v2 uintptr
	var v1 TTcl_Size
	var v3 bool
	_, _, _, _, _, _, _, _ = allocatedDict, cachePtr, dictPtr, result, resultPtr, v1, v2, v3
	allocatedDict = 0
	if objc < int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+26911)
		return int32(TCL_ERROR)
	}
	dictPtr = XTcl_ObjGetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), 0)
	if dictPtr == libc.UintptrFromInt32(0) {
		allocatedDict = int32(1)
		dictPtr = XTcl_NewDictObj(tls)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount > int64(1) {
			allocatedDict = int32(1)
			dictPtr = XTcl_DuplicateObj(tls, dictPtr)
		}
	}
	result = XTcl_DictObjRemoveKeyList(tls, interp, dictPtr, int64(objc-int32(2)), objv+uintptr(2)*8)
	if result != TCL_OK {
		if allocatedDict != 0 {
			v2 = dictPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if !(v1 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Flength = int64(-libc.Int32FromInt32(1))
					if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
						cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, dictPtr)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(dictPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = dictPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, dictPtr)
				}
			}
		}
		return int32(TCL_ERROR)
	}
	resultPtr = XTcl_ObjSetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), dictPtr, int32(TCL_LEAVE_ERR_MSG))
	if resultPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, resultPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * DictFilterCmd --
 *
 *	This function implements the "dict filter" Tcl command. See the user
 *	documentation for details on what it does, and TIP#111 for the formal
 *	specification.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _DictFilterCmd(tls *libc.TLS, dummy3207 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(128)
	defer tls.Free(128)
	var boolObj, cachePtr, cachePtr1, cachePtr10, cachePtr11, cachePtr12, cachePtr13, cachePtr14, cachePtr15, cachePtr16, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cachePtr8, cachePtr9, iPtr, keyVarObj, pattern, resultObj, scriptObj, valueVarObj, v11, v12, v17, v20, v23, v26, v29, v32, v35, v38, v41, v44, v47, v5, v50, v53, v56, v59, v6, v62, v65, v8, v9 uintptr
	var i, i1, result, v13 int32
	var v14, v15 int64
	var v16, v19, v22, v25, v28, v31, v34, v37, v40, v43, v46, v49, v52, v55, v58, v61, v64 TTcl_Size
	var v18, v21, v24, v27, v30, v33, v36, v39, v42, v45, v48, v51, v54, v57, v60, v63, v66 bool
	var _ /* done at bp+56 */ int32
	var _ /* index at bp+0 */ int32
	var _ /* keyObj at bp+16 */ uintptr
	var _ /* satisfied at bp+60 */ int32
	var _ /* search at bp+32 */ TTcl_DictSearch
	var _ /* valueObj at bp+24 */ uintptr
	var _ /* varc at bp+64 */ TTcl_Size
	var _ /* varv at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = boolObj, cachePtr, cachePtr1, cachePtr10, cachePtr11, cachePtr12, cachePtr13, cachePtr14, cachePtr15, cachePtr16, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cachePtr8, cachePtr9, i, i1, iPtr, keyVarObj, pattern, result, resultObj, scriptObj, valueVarObj, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v8, v9
	iPtr = interp
	*(*uintptr)(unsafe.Pointer(bp + 16)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(bp + 24)) = libc.UintptrFromInt32(0)
	if objc < int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+26937)
		return int32(TCL_ERROR)
	}
	if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), uintptr(unsafe.Pointer(&_filters)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+26969, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	switch *(*int32)(unsafe.Pointer(bp)) {
	case 0:
		goto _1
	case 2:
		goto _2
	case 1:
		goto _3
	}
	goto _4
_1:
	;
	/*
	 * Create a dictionary whose keys all match a certain pattern.
	 */
	if XTcl_DictObjFirst(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+32, bp+16, bp+24, bp+56) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if objc == int32(3) {
		/*
		 * Nothing to match, so return nothing (== empty dictionary).
		 */
		XTcl_DictObjDone(tls, bp+32)
		return TCL_OK
	} else {
		if objc == int32(4) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes != 0 {
				v5 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes
			} else {
				v5 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0))
			}
			pattern = v5
			resultObj = XTcl_NewDictObj(tls)
			if libc.Xstrpbrk(tls, pattern, __ccgo_ts+16411) == libc.UintptrFromInt32(0) {
				/*
				 * Must release the search lock here to prevent a memory leak
				 * since we are not exhausing the search. [Bug 1705778, leak
				 * K05]
				 */
				XTcl_DictObjDone(tls, bp+32)
				XTcl_DictObjGet(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), *(*uintptr)(unsafe.Pointer(objv + 3*8)), bp+24)
				if *(*uintptr)(unsafe.Pointer(bp + 24)) != libc.UintptrFromInt32(0) {
					XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), resultObj, *(*uintptr)(unsafe.Pointer(objv + 3*8)), *(*uintptr)(unsafe.Pointer(bp + 24)))
				}
			} else {
				for !(*(*int32)(unsafe.Pointer(bp + 56)) != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 {
						v6 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes
					} else {
						v6 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), libc.UintptrFromInt32(0))
					}
					if XTcl_StringCaseMatch(tls, v6, pattern, 0) != 0 {
						XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), resultObj, *(*uintptr)(unsafe.Pointer(bp + 16)), *(*uintptr)(unsafe.Pointer(bp + 24)))
					}
					XTcl_DictObjNext(tls, bp+32, bp+16, bp+24, bp+56)
				}
			}
		} else {
			/*
			 * Can't optimize this match for trivial globbing: would disturb
			 * order.
			 */
			resultObj = XTcl_NewDictObj(tls)
			for !(*(*int32)(unsafe.Pointer(bp + 56)) != 0) {
				i = int32(3)
				for {
					if !(i < objc) {
						break
					}
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
						v8 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
					} else {
						v8 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
					}
					pattern = v8
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 {
						v9 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes
					} else {
						v9 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), libc.UintptrFromInt32(0))
					}
					if XTcl_StringCaseMatch(tls, v9, pattern, 0) != 0 {
						XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), resultObj, *(*uintptr)(unsafe.Pointer(bp + 16)), *(*uintptr)(unsafe.Pointer(bp + 24)))
						break /* stop inner loop */
					}
					goto _7
				_7:
					;
					i++
				}
				XTcl_DictObjNext(tls, bp+32, bp+16, bp+24, bp+56)
			}
		}
	}
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
_2:
	;
	/*
	 * Create a dictionary whose values all match a certain pattern.
	 */
	if XTcl_DictObjFirst(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+32, bp+16, bp+24, bp+56) != TCL_OK {
		return int32(TCL_ERROR)
	}
	resultObj = XTcl_NewDictObj(tls)
	for !(*(*int32)(unsafe.Pointer(bp + 56)) != 0) {
		i1 = int32(3)
		for {
			if !(i1 < objc) {
				break
			}
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i1)*8)))).Fbytes != 0 {
				v11 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i1)*8)))).Fbytes
			} else {
				v11 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i1)*8)), libc.UintptrFromInt32(0))
			}
			pattern = v11
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Fbytes != 0 {
				v12 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Fbytes
			} else {
				v12 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 24)), libc.UintptrFromInt32(0))
			}
			if XTcl_StringCaseMatch(tls, v12, pattern, 0) != 0 {
				XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), resultObj, *(*uintptr)(unsafe.Pointer(bp + 16)), *(*uintptr)(unsafe.Pointer(bp + 24)))
				break /* stop inner loop */
			}
			goto _10
		_10:
			;
			i1++
		}
		XTcl_DictObjNext(tls, bp+32, bp+16, bp+24, bp+56)
	}
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
_3:
	;
	if objc != int32(5) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+26980)
		return int32(TCL_ERROR)
	}
	/*
	 * Create a dictionary whose key,value pairs all satisfy a script
	 * (i.e. get a true boolean result from its evaluation). Massive
	 * copying from the "dict for" implementation has occurred!
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)) + 32))).Fptr2 != 0 {
			v14 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)) + 32))).Fptr2)).FspanStart
		} else {
			v14 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)) + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)) + 32))).Fptr1 + 40 + uintptr(v14)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)) + 32))).Fptr2 != 0 {
			v15 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)) + 32))).Fptr2)).FspanLength
		} else {
			v15 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 64)) = v15
		v13 = libc.Int32FromInt32(TCL_OK)
	} else {
		v13 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)), bp+64, bp+8)
	}
	if v13 != TCL_OK {
		return int32(TCL_ERROR)
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp + 64)) != int64(2) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+26773, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+80, __ccgo_ts+2004, __ccgo_ts+26810, __ccgo_ts+19222, __ccgo_ts+26201, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	keyVarObj = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))
	valueVarObj = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*8))
	scriptObj = *(*uintptr)(unsafe.Pointer(objv + 4*8))
	/*
	 * Make sure that these objects (which we need throughout the body of
	 * the loop) don't vanish. Note that the dictionary internal rep is
	 * locked internally so that updates, shimmering, etc are not a
	 * problem.
	 */
	(*TTcl_Obj)(unsafe.Pointer(keyVarObj)).FrefCount++
	(*TTcl_Obj)(unsafe.Pointer(valueVarObj)).FrefCount++
	(*TTcl_Obj)(unsafe.Pointer(scriptObj)).FrefCount++
	result = XTcl_DictObjFirst(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+32, bp+16, bp+24, bp+56)
	if result != TCL_OK {
		v17 = keyVarObj
		v16 = *(*TTcl_Size)(unsafe.Pointer(v17))
		*(*TTcl_Size)(unsafe.Pointer(v17))--
		if !(v16 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(keyVarObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(keyVarObj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(keyVarObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(keyVarObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(keyVarObj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(keyVarObj)).Flength = int64(-libc.Int32FromInt32(1))
				if v18 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v18 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v18 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, keyVarObj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(keyVarObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = keyVarObj
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, keyVarObj)
			}
		}
		v20 = valueVarObj
		v19 = *(*TTcl_Size)(unsafe.Pointer(v20))
		*(*TTcl_Size)(unsafe.Pointer(v20))--
		if !(v19 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(valueVarObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(valueVarObj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(valueVarObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(valueVarObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(valueVarObj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(valueVarObj)).Flength = int64(-libc.Int32FromInt32(1))
				if v21 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v21 {
					cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v21 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, valueVarObj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(valueVarObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = valueVarObj
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, valueVarObj)
			}
		}
		v23 = scriptObj
		v22 = *(*TTcl_Size)(unsafe.Pointer(v23))
		*(*TTcl_Size)(unsafe.Pointer(v23))--
		if !(v22 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(scriptObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(scriptObj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(scriptObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(scriptObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(scriptObj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(scriptObj)).Flength = int64(-libc.Int32FromInt32(1))
				if v24 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v24 {
					cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v24 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, scriptObj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(scriptObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = scriptObj
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, scriptObj)
			}
		}
		return int32(TCL_ERROR)
	}
	resultObj = XTcl_NewDictObj(tls)
	for !(*(*int32)(unsafe.Pointer(bp + 56)) != 0) {
		/*
		 * Stop the value from getting hit in any way by any traces on the
		 * key variable.
		 */
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount++
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).FrefCount++
		if XTcl_ObjSetVar2(tls, interp, keyVarObj, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 16)), int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
			XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+27037, int64(-int32(1))))
			result = int32(TCL_ERROR)
			goto abnormalResult
		}
		if XTcl_ObjSetVar2(tls, interp, valueVarObj, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 24)), int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
			XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+27085, int64(-int32(1))))
			result = int32(TCL_ERROR)
			goto abnormalResult
		}
		/*
		 * TIP #280. Make invoking context available to loop body.
		 */
		result = XTclEvalObjEx(tls, interp, scriptObj, 0, (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr, int32(4))
		switch result {
		case TCL_OK:
			boolObj = XTcl_GetObjResult(tls, interp)
			(*TTcl_Obj)(unsafe.Pointer(boolObj)).FrefCount++
			XTcl_ResetResult(tls, interp)
			if XTcl_GetBoolFromObj(tls, interp, boolObj, (libc.Int32FromInt32(TCL_NULL_OK)-libc.Int32FromInt32(2))&libc.Int32FromInt64(4), bp+60) != TCL_OK {
				v26 = boolObj
				v25 = *(*TTcl_Size)(unsafe.Pointer(v26))
				*(*TTcl_Size)(unsafe.Pointer(v26))--
				if !(v25 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(boolObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(boolObj)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(boolObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(boolObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(boolObj)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(boolObj)).Flength = int64(-libc.Int32FromInt32(1))
						if v27 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v27 {
							cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v27 || ((*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, boolObj)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(boolObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = boolObj
							(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, boolObj)
					}
				}
				result = int32(TCL_ERROR)
				goto abnormalResult
			}
			v29 = boolObj
			v28 = *(*TTcl_Size)(unsafe.Pointer(v29))
			*(*TTcl_Size)(unsafe.Pointer(v29))--
			if !(v28 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(boolObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(boolObj)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(boolObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(boolObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(boolObj)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(boolObj)).Flength = int64(-libc.Int32FromInt32(1))
					if v30 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v30 {
						cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v30 || ((*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, boolObj)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(boolObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = boolObj
						(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, boolObj)
				}
			}
			if *(*int32)(unsafe.Pointer(bp + 60)) != 0 {
				XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), resultObj, *(*uintptr)(unsafe.Pointer(bp + 16)), *(*uintptr)(unsafe.Pointer(bp + 24)))
			}
		case int32(TCL_BREAK):
			/*
			 * Force loop termination by calling Tcl_DictObjDone; this
			 * makes the next Tcl_DictObjNext say there is nothing more to
			 * do.
			 */
			XTcl_ResetResult(tls, interp)
			XTcl_DictObjDone(tls, bp+32)
			/* FALLTHRU */
			fallthrough
		case int32(TCL_CONTINUE):
			result = TCL_OK
		case int32(TCL_ERROR):
			XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+27135, libc.VaList(bp+80, XTcl_GetErrorLine(tls, interp))))
			fallthrough
		default:
			goto abnormalResult
		}
		v32 = *(*uintptr)(unsafe.Pointer(bp + 16))
		v31 = *(*TTcl_Size)(unsafe.Pointer(v32))
		*(*TTcl_Size)(unsafe.Pointer(v32))--
		if !(v31 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength = int64(-libc.Int32FromInt32(1))
				if v33 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v33 {
					cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v33 || ((*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp + 16))
					(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
			}
		}
		v35 = *(*uintptr)(unsafe.Pointer(bp + 24))
		v34 = *(*TTcl_Size)(unsafe.Pointer(v35))
		*(*TTcl_Size)(unsafe.Pointer(v35))--
		if !(v34 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Flength = int64(-libc.Int32FromInt32(1))
				if v36 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v36 {
					cachePtr6 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v36 || ((*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 24)))
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp + 24))
					(*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 24)))
			}
		}
		XTcl_DictObjNext(tls, bp+32, bp+16, bp+24, bp+56)
	}
	/*
	 * Stop holding a reference to these objects.
	 */
	v38 = keyVarObj
	v37 = *(*TTcl_Size)(unsafe.Pointer(v38))
	*(*TTcl_Size)(unsafe.Pointer(v38))--
	if !(v37 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(keyVarObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(keyVarObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(keyVarObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(keyVarObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(keyVarObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(keyVarObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v39 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v39 {
				cachePtr7 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v39 || ((*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, keyVarObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(keyVarObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr = keyVarObj
				(*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, keyVarObj)
		}
	}
	v41 = valueVarObj
	v40 = *(*TTcl_Size)(unsafe.Pointer(v41))
	*(*TTcl_Size)(unsafe.Pointer(v41))--
	if !(v40 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(valueVarObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(valueVarObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(valueVarObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(valueVarObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(valueVarObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(valueVarObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v42 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v42 {
				cachePtr8 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v42 || ((*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, valueVarObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(valueVarObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr8)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr8)).FfirstObjPtr = valueVarObj
				(*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, valueVarObj)
		}
	}
	v44 = scriptObj
	v43 = *(*TTcl_Size)(unsafe.Pointer(v44))
	*(*TTcl_Size)(unsafe.Pointer(v44))--
	if !(v43 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(scriptObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(scriptObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(scriptObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(scriptObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(scriptObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(scriptObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v45 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v45 {
				cachePtr9 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v45 || ((*TAllocCache)(unsafe.Pointer(cachePtr9)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr9)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, scriptObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(scriptObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr9)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr9)).FfirstObjPtr = scriptObj
				(*TAllocCache)(unsafe.Pointer(cachePtr9)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, scriptObj)
		}
	}
	XTcl_DictObjDone(tls, bp+32)
	if result == TCL_OK {
		XTcl_SetObjResult(tls, interp, resultObj)
	} else {
		v47 = resultObj
		v46 = *(*TTcl_Size)(unsafe.Pointer(v47))
		*(*TTcl_Size)(unsafe.Pointer(v47))--
		if !(v46 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = int64(-libc.Int32FromInt32(1))
				if v48 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v48 {
					cachePtr10 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v48 || ((*TAllocCache)(unsafe.Pointer(cachePtr10)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr10)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, resultObj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(resultObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr10)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr10)).FfirstObjPtr = resultObj
					(*TAllocCache)(unsafe.Pointer(cachePtr10)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, resultObj)
			}
		}
	}
	return result
	goto abnormalResult
abnormalResult:
	;
	XTcl_DictObjDone(tls, bp+32)
	v50 = *(*uintptr)(unsafe.Pointer(bp + 16))
	v49 = *(*TTcl_Size)(unsafe.Pointer(v50))
	*(*TTcl_Size)(unsafe.Pointer(v50))--
	if !(v49 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength = int64(-libc.Int32FromInt32(1))
			if v51 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v51 {
				cachePtr11 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v51 || ((*TAllocCache)(unsafe.Pointer(cachePtr11)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr11)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr11)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr11)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp + 16))
				(*TAllocCache)(unsafe.Pointer(cachePtr11)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
		}
	}
	v53 = *(*uintptr)(unsafe.Pointer(bp + 24))
	v52 = *(*TTcl_Size)(unsafe.Pointer(v53))
	*(*TTcl_Size)(unsafe.Pointer(v53))--
	if !(v52 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Flength = int64(-libc.Int32FromInt32(1))
			if v54 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v54 {
				cachePtr12 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v54 || ((*TAllocCache)(unsafe.Pointer(cachePtr12)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr12)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 24)))
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr12)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr12)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp + 24))
				(*TAllocCache)(unsafe.Pointer(cachePtr12)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 24)))
		}
	}
	v56 = keyVarObj
	v55 = *(*TTcl_Size)(unsafe.Pointer(v56))
	*(*TTcl_Size)(unsafe.Pointer(v56))--
	if !(v55 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(keyVarObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(keyVarObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(keyVarObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(keyVarObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(keyVarObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(keyVarObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v57 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v57 {
				cachePtr13 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v57 || ((*TAllocCache)(unsafe.Pointer(cachePtr13)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr13)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, keyVarObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(keyVarObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr13)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr13)).FfirstObjPtr = keyVarObj
				(*TAllocCache)(unsafe.Pointer(cachePtr13)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, keyVarObj)
		}
	}
	v59 = valueVarObj
	v58 = *(*TTcl_Size)(unsafe.Pointer(v59))
	*(*TTcl_Size)(unsafe.Pointer(v59))--
	if !(v58 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(valueVarObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(valueVarObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(valueVarObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(valueVarObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(valueVarObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(valueVarObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v60 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v60 {
				cachePtr14 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v60 || ((*TAllocCache)(unsafe.Pointer(cachePtr14)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr14)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, valueVarObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(valueVarObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr14)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr14)).FfirstObjPtr = valueVarObj
				(*TAllocCache)(unsafe.Pointer(cachePtr14)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, valueVarObj)
		}
	}
	v62 = scriptObj
	v61 = *(*TTcl_Size)(unsafe.Pointer(v62))
	*(*TTcl_Size)(unsafe.Pointer(v62))--
	if !(v61 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(scriptObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(scriptObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(scriptObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(scriptObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(scriptObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(scriptObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v63 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v63 {
				cachePtr15 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v63 || ((*TAllocCache)(unsafe.Pointer(cachePtr15)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr15)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, scriptObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(scriptObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr15)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr15)).FfirstObjPtr = scriptObj
				(*TAllocCache)(unsafe.Pointer(cachePtr15)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, scriptObj)
		}
	}
	v65 = resultObj
	v64 = *(*TTcl_Size)(unsafe.Pointer(v65))
	*(*TTcl_Size)(unsafe.Pointer(v65))--
	if !(v64 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v66 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v66 {
				cachePtr16 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v66 || ((*TAllocCache)(unsafe.Pointer(cachePtr16)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr16)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, resultObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(resultObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr16)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr16)).FfirstObjPtr = resultObj
				(*TAllocCache)(unsafe.Pointer(cachePtr16)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, resultObj)
		}
	}
	return result
_4:
	;
	XTcl_Panic(tls, __ccgo_ts+11006, 0)
	/* Control never reaches this point. */
	return int32(TCL_ERROR)
}

var _filters = [4]uintptr{
	0: __ccgo_ts + 25055,
	1: __ccgo_ts + 3702,
	2: __ccgo_ts + 3605,
	3: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * DictUpdateCmd --
 *
 *	This function implements the "dict update" Tcl command. See the user
 *	documentation for details on what it does, and TIP#212 for the formal
 *	specification.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _DictUpdateCmd(tls *libc.TLS, dummy3493 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _objPtr, cachePtr, cachePtr1, cachePtr2, cachePtr3, dictPtr, iPtr, v10, v3, v5, v7 uintptr
	var i int32
	var v11, v12, v4, v8 bool
	var v2, v6, v9 TTcl_Size
	var _ /* _callbackPtr at bp+16 */ uintptr
	var _ /* dummy at bp+8 */ TTcl_Size
	var _ /* objPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, cachePtr1, cachePtr2, cachePtr3, dictPtr, i, iPtr, v10, v11, v12, v2, v3, v4, v5, v6, v7, v8, v9
	iPtr = interp
	if objc < int32(5) || !(objc&libc.Int32FromInt32(1) != 0) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+27171)
		return int32(TCL_ERROR)
	}
	dictPtr = XTcl_ObjGetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), int32(TCL_LEAVE_ERR_MSG))
	if dictPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if XTcl_DictObjSize(tls, interp, dictPtr, bp+8) != TCL_OK {
		return int32(TCL_ERROR)
	}
	(*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount++
	i = int32(2)
	for {
		if !(i+int32(2) < objc) {
			break
		}
		if XTcl_DictObjGet(tls, interp, dictPtr, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp) != TCL_OK {
			v3 = dictPtr
			v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
			*(*TTcl_Size)(unsafe.Pointer(v3))--
			if !(v2 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Flength = int64(-libc.Int32FromInt32(1))
					if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
						cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v4 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, dictPtr)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(dictPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = dictPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, dictPtr)
				}
			}
			return int32(TCL_ERROR)
		}
		if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
			/* ??? */
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)))).Fbytes != 0 {
				v5 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)))).Fbytes
			} else {
				v5 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)), libc.UintptrFromInt32(0))
			}
			XTcl_UnsetVar2(tls, interp, v5, libc.UintptrFromInt32(0), 0)
		} else {
			if XTcl_ObjSetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)), libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
				v7 = dictPtr
				v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
				*(*TTcl_Size)(unsafe.Pointer(v7))--
				if !(v6 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Flength = int64(-libc.Int32FromInt32(1))
						if v8 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v8 {
							cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v8 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, dictPtr)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(dictPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = dictPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, dictPtr)
					}
				}
				return int32(TCL_ERROR)
			}
		}
		goto _1
	_1:
		;
		i += int32(2)
	}
	v10 = dictPtr
	v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
	*(*TTcl_Size)(unsafe.Pointer(v10))--
	if !(v9 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Flength = int64(-libc.Int32FromInt32(1))
			if v11 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v11 {
				cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v11 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, dictPtr)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(dictPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = dictPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, dictPtr)
		}
	}
	/*
	 * Execute the body after setting up the NRE handler to process the
	 * results.
	 */
	*(*uintptr)(unsafe.Pointer(bp)) = XTcl_NewListObj(tls, int64(objc-int32(3)), objv+uintptr(2)*8)
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FrefCount++
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FrefCount++
	if v12 = interp == libc.UintptrFromInt32(0); !v12 {
		cachePtr3 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v12 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 16)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FprocPtr = __ccgo_fp(_FinalizeDictUpdate)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8)) = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 1*8)) = *(*uintptr)(unsafe.Pointer(bp))
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 16))
	return XTclNREvalObjEx(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), 0, (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr, objc-int32(1))
}

func _FinalizeDictUpdate(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var argsObj, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, dictPtr, objPtr, varName, v11, v18, v2, v21, v24, v5, v8 uintptr
	var i, v1, v10, v17, v20, v23, v4, v7 TTcl_Size
	var state TTcl_InterpState
	var v12, v19, v22, v25, v3, v6, v9 bool
	var v14, v15 int64
	var _ /* objc at bp+8 */ TTcl_Size
	var _ /* objv at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = argsObj, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, dictPtr, i, objPtr, state, varName, v1, v10, v11, v12, v14, v15, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v3, v4, v5, v6, v7, v8, v9
	varName = *(*uintptr)(unsafe.Pointer(data))
	argsObj = *(*uintptr)(unsafe.Pointer(data + 1*8))
	/*
	 * ErrorInfo handling.
	 */
	if result == int32(TCL_ERROR) {
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+27220, int64(-int32(1))))
	}
	/*
	 * If the dictionary variable doesn't exist, drop everything silently.
	 */
	dictPtr = XTcl_ObjGetVar2(tls, interp, varName, libc.UintptrFromInt32(0), 0)
	if dictPtr == libc.UintptrFromInt32(0) {
		v2 = varName
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if !(v1 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(varName)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(varName)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(varName)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(varName)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(varName)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(varName)).Flength = int64(-libc.Int32FromInt32(1))
				if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, varName)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(varName + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = varName
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, varName)
			}
		}
		v5 = argsObj
		v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
		*(*TTcl_Size)(unsafe.Pointer(v5))--
		if !(v4 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(argsObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(argsObj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(argsObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(argsObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(argsObj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(argsObj)).Flength = int64(-libc.Int32FromInt32(1))
				if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
					cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v6 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, argsObj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(argsObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = argsObj
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, argsObj)
			}
		}
		return result
	}
	/*
	 * Double-check that it is still a dictionary.
	 */
	state = XTcl_SaveInterpState(tls, interp, result)
	if XTcl_DictObjSize(tls, interp, dictPtr, bp+8) != TCL_OK {
		XTcl_DiscardInterpState(tls, state)
		v8 = varName
		v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
		*(*TTcl_Size)(unsafe.Pointer(v8))--
		if !(v7 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(varName)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(varName)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(varName)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(varName)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(varName)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(varName)).Flength = int64(-libc.Int32FromInt32(1))
				if v9 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v9 {
					cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v9 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, varName)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(varName + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = varName
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, varName)
			}
		}
		v11 = argsObj
		v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
		*(*TTcl_Size)(unsafe.Pointer(v11))--
		if !(v10 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(argsObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(argsObj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(argsObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(argsObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(argsObj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(argsObj)).Flength = int64(-libc.Int32FromInt32(1))
				if v12 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v12 {
					cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v12 || ((*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, argsObj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(argsObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = argsObj
					(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, argsObj)
			}
		}
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount > int64(1) {
		dictPtr = XTcl_DuplicateObj(tls, dictPtr)
	}
	/*
	 * Write back the values from the variables, treating failure to read as
	 * an instruction to remove the key.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(argsObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(argsObj + 32))).Fptr2 != 0 {
			v14 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(argsObj + 32))).Fptr2)).FspanStart
		} else {
			v14 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(argsObj + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(argsObj + 32))).Fptr1 + 40 + uintptr(v14)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(argsObj + 32))).Fptr2 != 0 {
			v15 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(argsObj + 32))).Fptr2)).FspanLength
		} else {
			v15 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(argsObj + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v15
		_ = libc.Int32FromInt32(TCL_OK)
	} else {
		XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), argsObj, bp+8, bp)
	}
	i = 0
	for {
		if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) {
			break
		}
		objPtr = XTcl_ObjGetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(i+int64(1))*8)), libc.UintptrFromInt32(0), 0)
		if objPtr == libc.UintptrFromInt32(0) {
			XTcl_DictObjRemove(tls, libc.UintptrFromInt32(0), dictPtr, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(i)*8)))
		} else {
			if objPtr == dictPtr {
				/*
				 * Someone is messing us around, trying to build a recursive
				 * structure. [Bug 1786481]
				 */
				XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dictPtr, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(i)*8)), XTcl_DuplicateObj(tls, objPtr))
			} else {
				/* Shouldn't fail */
				XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dictPtr, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(i)*8)), objPtr)
			}
		}
		goto _16
	_16:
		;
		i += int64(2)
	}
	v18 = argsObj
	v17 = *(*TTcl_Size)(unsafe.Pointer(v18))
	*(*TTcl_Size)(unsafe.Pointer(v18))--
	if !(v17 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(argsObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(argsObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(argsObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(argsObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(argsObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(argsObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v19 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v19 {
				cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v19 || ((*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, argsObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(argsObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = argsObj
				(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, argsObj)
		}
	}
	/*
	 * Write the dictionary back to its variable.
	 */
	if XTcl_ObjSetVar2(tls, interp, varName, libc.UintptrFromInt32(0), dictPtr, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
		XTcl_DiscardInterpState(tls, state)
		v21 = varName
		v20 = *(*TTcl_Size)(unsafe.Pointer(v21))
		*(*TTcl_Size)(unsafe.Pointer(v21))--
		if !(v20 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(varName)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(varName)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(varName)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(varName)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(varName)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(varName)).Flength = int64(-libc.Int32FromInt32(1))
				if v22 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v22 {
					cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v22 || ((*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, varName)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(varName + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = varName
					(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, varName)
			}
		}
		return int32(TCL_ERROR)
	}
	v24 = varName
	v23 = *(*TTcl_Size)(unsafe.Pointer(v24))
	*(*TTcl_Size)(unsafe.Pointer(v24))--
	if !(v23 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(varName)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(varName)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(varName)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(varName)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(varName)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(varName)).Flength = int64(-libc.Int32FromInt32(1))
			if v25 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v25 {
				cachePtr6 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v25 || ((*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, varName)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(varName + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr = varName
				(*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, varName)
		}
	}
	return XTcl_RestoreInterpState(tls, interp, state)
}

/*
 *----------------------------------------------------------------------
 *
 * DictWithCmd --
 *
 *	This function implements the "dict with" Tcl command. See the user
 *	documentation for details on what it does, and TIP#212 for the formal
 *	specification.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _DictWithCmd(tls *libc.TLS, dummy3652 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, cachePtr, dictPtr, iPtr, keysPtr, pathPtr uintptr
	var v1 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _ = _objPtr, cachePtr, dictPtr, iPtr, keysPtr, pathPtr, v1
	iPtr = interp
	if objc < int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+27249)
		return int32(TCL_ERROR)
	}
	/*
	 * Get the dictionary to open out.
	 */
	dictPtr = XTcl_ObjGetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), int32(TCL_LEAVE_ERR_MSG))
	if dictPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	keysPtr = XTclDictWithInit(tls, interp, dictPtr, int64(objc-int32(3)), objv+uintptr(2)*8)
	if keysPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	(*TTcl_Obj)(unsafe.Pointer(keysPtr)).FrefCount++
	/*
	 * Execute the body, while making the invoking context available to the
	 * loop body (TIP#280) and postponing the cleanup until later (NRE).
	 */
	pathPtr = libc.UintptrFromInt32(0)
	if objc > int32(3) {
		pathPtr = XTcl_NewListObj(tls, int64(objc-int32(3)), objv+uintptr(2)*8)
		(*TTcl_Obj)(unsafe.Pointer(pathPtr)).FrefCount++
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FrefCount++
	if v1 = interp == libc.UintptrFromInt32(0); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(_FinalizeDictWith)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = keysPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = pathPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
	return XTclNREvalObjEx(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), 0, (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr, objc-int32(1))
}

func _FinalizeDictWith(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var cachePtr, cachePtr1, cachePtr2, keysPtr, pathPtr, varName, varPtr, v11, v5, v8 uintptr
	var state TTcl_InterpState
	var v10, v4, v7 TTcl_Size
	var v12, v6, v9 bool
	var v2, v3 int64
	var _ /* arrayPtr at bp+16 */ uintptr
	var _ /* pathc at bp+8 */ TTcl_Size
	var _ /* pathv at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, keysPtr, pathPtr, state, varName, varPtr, v10, v11, v12, v2, v3, v4, v5, v6, v7, v8, v9
	varName = *(*uintptr)(unsafe.Pointer(data))
	keysPtr = *(*uintptr)(unsafe.Pointer(data + 1*8))
	pathPtr = *(*uintptr)(unsafe.Pointer(data + 2*8))
	if result == int32(TCL_ERROR) {
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+27278, int64(-int32(1))))
	}
	/*
	 * Save the result state; TDWF doesn't guarantee to not modify that on
	 * TCL_OK result.
	 */
	state = XTcl_SaveInterpState(tls, interp, result)
	if pathPtr != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(pathPtr + 32))).Fptr2 != 0 {
				v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(pathPtr + 32))).Fptr2)).FspanStart
			} else {
				v2 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(pathPtr + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(pathPtr + 32))).Fptr1 + 40 + uintptr(v2)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(pathPtr + 32))).Fptr2 != 0 {
				v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(pathPtr + 32))).Fptr2)).FspanLength
			} else {
				v3 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(pathPtr + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v3
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), pathPtr, bp+8, bp)
		}
	} else {
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0
		*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	}
	/*
	 * Pack from local variables back into the dictionary.
	 */
	varPtr = XTclObjLookupVarEx(tls, interp, varName, libc.UintptrFromInt32(0), int32(TCL_LEAVE_ERR_MSG), __ccgo_ts+5383, int32(1), int32(1), bp+16)
	if varPtr == libc.UintptrFromInt32(0) {
		result = int32(TCL_ERROR)
	} else {
		result = XTclDictWithFinish(tls, interp, varPtr, *(*uintptr)(unsafe.Pointer(bp + 16)), varName, libc.UintptrFromInt32(0), -int32(1), int32(*(*TTcl_Size)(unsafe.Pointer(bp + 8))), *(*uintptr)(unsafe.Pointer(bp)), keysPtr)
	}
	/*
	 * Tidy up and return the real result (unless we had an error).
	 */
	v5 = varName
	v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
	*(*TTcl_Size)(unsafe.Pointer(v5))--
	if !(v4 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(varName)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(varName)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(varName)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(varName)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(varName)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(varName)).Flength = int64(-libc.Int32FromInt32(1))
			if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v6 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, varName)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(varName + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = varName
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, varName)
		}
	}
	v8 = keysPtr
	v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
	*(*TTcl_Size)(unsafe.Pointer(v8))--
	if !(v7 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(keysPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(keysPtr)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(keysPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(keysPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(keysPtr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(keysPtr)).Flength = int64(-libc.Int32FromInt32(1))
			if v9 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v9 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v9 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, keysPtr)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(keysPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = keysPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, keysPtr)
		}
	}
	if pathPtr != libc.UintptrFromInt32(0) {
		v11 = pathPtr
		v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
		*(*TTcl_Size)(unsafe.Pointer(v11))--
		if !(v10 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(pathPtr)).Flength = int64(-libc.Int32FromInt32(1))
				if v12 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v12 {
					cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v12 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, pathPtr)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(pathPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = pathPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, pathPtr)
			}
		}
	}
	if result != TCL_OK {
		XTcl_DiscardInterpState(tls, state)
		return int32(TCL_ERROR)
	}
	return XTcl_RestoreInterpState(tls, interp, state)
}

/*
 *----------------------------------------------------------------------
 *
 * TclDictWithInit --
 *
 *	Part of the core of [dict with]. Pokes into a dictionary and converts
 *	the mappings there into assignments to (presumably) local variables.
 *	Returns a list of all the names that were mapped so that removal of
 *	either the variable or the dictionary entry won't surprise us when we
 *	come to stuffing everything back.
 *
 * Result:
 *	List of mapped names, or NULL if there was an error.
 *
 * Side effects:
 *	Assigns to variables, so potentially legion due to traces.
 *
 *----------------------------------------------------------------------
 */

func XTclDictWithInit(tls *libc.TLS, interp uintptr, dictPtr uintptr, pathc TTcl_Size, pathv uintptr) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var cachePtr, cachePtr1, keysPtr, v4 uintptr
	var v1, v5 bool
	var v3 TTcl_Size
	var _ /* done at bp+40 */ int32
	var _ /* keyPtr at bp+24 */ uintptr
	var _ /* s at bp+0 */ TTcl_DictSearch
	var _ /* valPtr at bp+32 */ uintptr
	_, _, _, _, _, _, _ = cachePtr, cachePtr1, keysPtr, v1, v3, v4, v5
	if pathc > 0 {
		dictPtr = XTclTraceDictPath(tls, interp, dictPtr, pathc, pathv, DICT_PATH_READ)
		if dictPtr == libc.UintptrFromInt32(0) {
			return libc.UintptrFromInt32(0)
		}
	}
	/*
	 * Go over the list of keys and write each corresponding value to a
	 * variable in the current context with the same name. Also keep a copy of
	 * the keys so we can write back properly later on even if the dictionary
	 * has been structurally modified.
	 */
	if XTcl_DictObjFirst(tls, interp, dictPtr, bp, bp+24, bp+32, bp+40) != TCL_OK {
		return libc.UintptrFromInt32(0)
	}
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		keysPtr = XTclThreadAllocObj(tls)
	} else {
		keysPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(keysPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(keysPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(keysPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(keysPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(keysPtr)).FtypePtr = libc.UintptrFromInt32(0)
	for {
		if !!(*(*int32)(unsafe.Pointer(bp + 40)) != 0) {
			break
		}
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), keysPtr, *(*uintptr)(unsafe.Pointer(bp + 24)))
		if XTcl_ObjSetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 24)), libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 32)), int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
			v4 = keysPtr
			v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
			*(*TTcl_Size)(unsafe.Pointer(v4))--
			if !(v3 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(keysPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(keysPtr)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(keysPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(keysPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(keysPtr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(keysPtr)).Flength = int64(-libc.Int32FromInt32(1))
					if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
						cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v5 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, keysPtr)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(keysPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = keysPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, keysPtr)
				}
			}
			XTcl_DictObjDone(tls, bp)
			return libc.UintptrFromInt32(0)
		}
		goto _2
	_2:
		;
		XTcl_DictObjNext(tls, bp, bp+24, bp+32, bp+40)
	}
	return keysPtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclDictWithFinish --
 *
 *	Part of the core of [dict with]. Reassembles the piece of the dict (in
 *	varName, location given by pathc/pathv) from the variables named in
 *	the keysPtr argument. NB, does not try to preserve errors or manage
 *	argument lifetimes.
 *
 * Result:
 *	TCL_OK if we succeeded, or TCL_ERROR if we failed.
 *
 * Side effects:
 *	Assigns to a variable, so potentially legion due to traces. Updates
 *	the dictionary in the named variable.
 *
 *----------------------------------------------------------------------
 */

func XTclDictWithFinish(tls *libc.TLS, interp uintptr, varPtr uintptr, arrayPtr uintptr, part1Ptr uintptr, part2Ptr uintptr, index int32, pathc int32, pathv uintptr, keysPtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* List of keys to be synchronized. This is
	 * the result value from TclDictWithInit. */
	var allocdict, v1, v11, v4 TTcl_Size
	var cachePtr, cachePtr1, cachePtr2, dictPtr, leafPtr, valPtr, v12, v2, v5 uintptr
	var v13, v3, v6 bool
	var v8, v9 int64
	var _ /* i at bp+0 */ TTcl_Size
	var _ /* keyc at bp+8 */ TTcl_Size
	var _ /* keyv at bp+16 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = allocdict, cachePtr, cachePtr1, cachePtr2, dictPtr, leafPtr, valPtr, v1, v11, v12, v13, v2, v3, v4, v5, v6, v8, v9
	/*
	 * If the dictionary variable doesn't exist, drop everything silently.
	 */
	dictPtr = XTclPtrGetVarIdx(tls, interp, varPtr, arrayPtr, part1Ptr, part2Ptr, int32(TCL_LEAVE_ERR_MSG), index)
	if dictPtr == libc.UintptrFromInt32(0) {
		return TCL_OK
	}
	/*
	 * Double-check that it is still a dictionary.
	 */
	if XTcl_DictObjSize(tls, interp, dictPtr, bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount > int64(1) {
		dictPtr = XTcl_DuplicateObj(tls, dictPtr)
		allocdict = int64(1)
	} else {
		allocdict = 0
	}
	if pathc > 0 {
		/*
		 * Want to get to the dictionary which we will update; need to do
		 * prepare-for-update unsharing along the path *but* avoid generating
		 * an error on a non-extant path (we'll treat that the same as a
		 * non-extant variable. Luckily, the unsharing operation isn't
		 * deeply damaging if we don't go on to update; it's just less than
		 * perfectly efficient (but no memory should be leaked).
		 */
		leafPtr = XTclTraceDictPath(tls, interp, dictPtr, int64(pathc), pathv, libc.Int32FromInt32(DICT_PATH_EXISTS)|libc.Int32FromInt32(DICT_PATH_UPDATE))
		if leafPtr == libc.UintptrFromInt32(0) {
			if allocdict != 0 {
				v2 = dictPtr
				v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
				*(*TTcl_Size)(unsafe.Pointer(v2))--
				if !(v1 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Flength = int64(-libc.Int32FromInt32(1))
						if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
							cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, dictPtr)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(dictPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = dictPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, dictPtr)
					}
				}
			}
			return int32(TCL_ERROR)
		}
		if leafPtr == libc.UintptrFromInt32(1) {
			if allocdict != 0 {
				v5 = dictPtr
				v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
				*(*TTcl_Size)(unsafe.Pointer(v5))--
				if !(v4 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Flength = int64(-libc.Int32FromInt32(1))
						if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
							cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v6 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, dictPtr)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(dictPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = dictPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, dictPtr)
					}
				}
			}
			return TCL_OK
		}
	} else {
		leafPtr = dictPtr
	}
	/*
	 * Now process our updates on the leaf dictionary.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(keysPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(keysPtr + 32))).Fptr2 != 0 {
			v8 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(keysPtr + 32))).Fptr2)).FspanStart
		} else {
			v8 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(keysPtr + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 16)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(keysPtr + 32))).Fptr1 + 40 + uintptr(v8)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(keysPtr + 32))).Fptr2 != 0 {
			v9 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(keysPtr + 32))).Fptr2)).FspanLength
		} else {
			v9 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(keysPtr + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v9
		_ = libc.Int32FromInt32(TCL_OK)
	} else {
		XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), keysPtr, bp+8, bp+16)
	}
	*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	for {
		if !(*(*TTcl_Size)(unsafe.Pointer(bp)) < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) {
			break
		}
		valPtr = XTcl_ObjGetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))*8)), libc.UintptrFromInt32(0), 0)
		if valPtr == libc.UintptrFromInt32(0) {
			XTcl_DictObjRemove(tls, libc.UintptrFromInt32(0), leafPtr, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))*8)))
		} else {
			if leafPtr == valPtr {
				/*
				 * Someone is messing us around, trying to build a recursive
				 * structure. [Bug 1786481]
				 */
				XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), leafPtr, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))*8)), XTcl_DuplicateObj(tls, valPtr))
			} else {
				XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), leafPtr, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))*8)), valPtr)
			}
		}
		goto _10
	_10:
		;
		*(*TTcl_Size)(unsafe.Pointer(bp))++
	}
	/*
	 * Ensure that none of the dictionaries in the chain still have a string
	 * rep.
	 */
	if pathc > 0 {
		_InvalidateDictChain(tls, leafPtr)
	}
	/*
	 * Write back the outermost dictionary to the variable.
	 */
	if XTclPtrSetVarIdx(tls, interp, varPtr, arrayPtr, part1Ptr, part2Ptr, dictPtr, int32(TCL_LEAVE_ERR_MSG), index) == libc.UintptrFromInt32(0) {
		if allocdict != 0 {
			v12 = dictPtr
			v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
			*(*TTcl_Size)(unsafe.Pointer(v12))--
			if !(v11 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Flength = int64(-libc.Int32FromInt32(1))
					if v13 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v13 {
						cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v13 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, dictPtr)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(dictPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = dictPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, dictPtr)
				}
			}
		}
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclInitDictCmd --
 *
 *	This function is create the "dict" Tcl command. See the user
 *	documentation for details on what it does, and TIP#111 for the formal
 *	specification.
 *
 * Results:
 *	A Tcl command handle.
 *
 * Side effects:
 *	May advance compilation epoch.
 *
 *----------------------------------------------------------------------
 */

func XTclInitDictCmd(tls *libc.TLS, interp uintptr) (r TTcl_Command) {
	return XTclMakeEnsemble(tls, interp, __ccgo_ts+19222, uintptr(unsafe.Pointer(&_implementationMap)))
}

type TChainEntry1 = struct {
	Fentry   TTcl_HashEntry
	FprevPtr uintptr
	FnextPtr uintptr
}

/*
 * The structure below defines an instruction name Tcl object to allow
 * reporting of inner contexts in errorstack without string allocation.
 */

var _instNameType = TTcl_ObjType{
	Fname: __ccgo_ts + 27305,
}

func init() {
	p := unsafe.Pointer(&_instNameType)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_UpdateStringOfInstName)
}

/*
 *----------------------------------------------------------------------
 *
 * GetLocationInformation --
 *
 *	This procedure looks up the information about where a procedure was
 *	originally declared.
 *
 * Results:
 *	Writes to the variables pointed at by fileObjPtr and linePtr.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _GetLocationInformation(tls *libc.TLS, procPtr uintptr, fileObjPtr uintptr, linePtr uintptr) {
	/* Where to write the information about what
	 * line number represented the start of the
	 * code in question. Will be written to,
	 * either with the line number or with -1 if
	 * the information is not available. */
	var cfPtr uintptr
	_ = cfPtr
	cfPtr = XTclGetCmdFrameForProcedure(tls, procPtr)
	*(*uintptr)(unsafe.Pointer(fileObjPtr)) = libc.UintptrFromInt32(0)
	*(*int32)(unsafe.Pointer(linePtr)) = -int32(1)
	if cfPtr == libc.UintptrFromInt32(0) {
		return
	}
	/*
	 * Get the source location data out of the CmdFrame.
	 */
	*(*int32)(unsafe.Pointer(linePtr)) = int32(*(*TTcl_Size)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(cfPtr)).Fline)))
	if (*TCmdFrame)(unsafe.Pointer(cfPtr)).Ftype1 == int32(TCL_LOCATION_SOURCE) {
		*(*uintptr)(unsafe.Pointer(fileObjPtr)) = (*TCmdFrame)(unsafe.Pointer(cfPtr)).Fdata.Feval.Fpath
	}
}

/*
 *----------------------------------------------------------------------
 *
 * DisassembleByteCodeObj --
 *
 *	Given an object which is of bytecode type, return a disassembled
 *	version of the bytecode (in a new refcount 0 object). No guarantees
 *	are made about the details of the contents of the result.
 *
 *----------------------------------------------------------------------
 */

func _DisassembleByteCodeObj(tls *libc.TLS, objPtr uintptr) (r uintptr) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* The bytecode object to disassemble. */
	var bufferObj, cachePtr, codeDeltaNext, codeLengthNext, codeLimit, codePtr, codeStart, iPtr, irPtr, localPtr, pc, procPtr, rangePtr, srcDeltaNext, srcLengthNext, v1, v10, v11, v12, v14, v17, v2, v5, v7, v8, v9 uintptr
	var codeLen, codeOffset, delta, numCmds, srcLen, srcOffset, v15, v18, v20 int32
	var i, numCompiledLocals TTcl_Size
	var v3 bool
	var v4 int64
	var _ /* fileObj at bp+8 */ uintptr
	var _ /* line at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bufferObj, cachePtr, codeDeltaNext, codeLen, codeLengthNext, codeLimit, codeOffset, codePtr, codeStart, delta, i, iPtr, irPtr, localPtr, numCmds, numCompiledLocals, pc, procPtr, rangePtr, srcDeltaNext, srcLen, srcLengthNext, srcOffset, v1, v10, v11, v12, v14, v15, v17, v18, v2, v20, v3, v4, v5, v7, v8, v9
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclByteCodeType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	codePtr = v2
	iPtr = *(*uintptr)(unsafe.Pointer((*TByteCode)(unsafe.Pointer(codePtr)).FinterpHandle))
	if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		bufferObj = XTclThreadAllocObj(tls)
	} else {
		bufferObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(bufferObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(bufferObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(bufferObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(bufferObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(bufferObj)).FtypePtr = libc.UintptrFromInt32(0)
	if !((*TByteCode)(unsafe.Pointer(codePtr)).FrefCount != 0) {
		return bufferObj /* Already freed. */
	}
	codeStart = (*TByteCode)(unsafe.Pointer(codePtr)).FcodeStart
	codeLimit = codeStart + uintptr((*TByteCode)(unsafe.Pointer(codePtr)).FnumCodeBytes)
	numCmds = int32((*TByteCode)(unsafe.Pointer(codePtr)).FnumCommands)
	/*
	 * Print header lines describing the ByteCode.
	 */
	XTcl_AppendPrintfToObj(tls, bufferObj, __ccgo_ts+27314, libc.VaList(bp+24, codePtr, (*TByteCode)(unsafe.Pointer(codePtr)).FrefCount, (*TByteCode)(unsafe.Pointer(codePtr)).FcompileEpoch, iPtr, (*TInterp)(unsafe.Pointer(iPtr)).FcompileEpoch))
	XTcl_AppendToObj(tls, bufferObj, __ccgo_ts+27372, int64(-int32(1)))
	if libc.Uint64FromInt64((*TByteCode)(unsafe.Pointer(codePtr)).FnumSrcBytes)+uint64(1) < libc.Uint64FromInt32(55)+libc.Uint64FromInt32(1) {
		v4 = (*TByteCode)(unsafe.Pointer(codePtr)).FnumSrcBytes
	} else {
		v4 = int64(libc.Int32FromInt32(55))
	}
	_PrintSourceToObj(tls, bufferObj, (*TByteCode)(unsafe.Pointer(codePtr)).Fsource, v4)
	_GetLocationInformation(tls, (*TByteCode)(unsafe.Pointer(codePtr)).FprocPtr, bp+8, bp)
	if *(*int32)(unsafe.Pointer(bp)) >= 0 && *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != 0 {
			v5 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes
		} else {
			v5 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), libc.UintptrFromInt32(0))
		}
		XTcl_AppendPrintfToObj(tls, bufferObj, __ccgo_ts+27382, libc.VaList(bp+24, v5, *(*int32)(unsafe.Pointer(bp))))
	}
	XTcl_AppendPrintfToObj(tls, bufferObj, __ccgo_ts+27403, libc.VaList(bp+24, numCmds, (*TByteCode)(unsafe.Pointer(codePtr)).FnumSrcBytes, (*TByteCode)(unsafe.Pointer(codePtr)).FnumCodeBytes, (*TByteCode)(unsafe.Pointer(codePtr)).FnumLitObjects, (*TByteCode)(unsafe.Pointer(codePtr)).FnumAuxDataItems, (*TByteCode)(unsafe.Pointer(codePtr)).FmaxStackDepth, float64(0)))
	/*
	 * If the ByteCode is the compiled body of a Tcl procedure, print
	 * information about that procedure. Note that we don't know the
	 * procedure's name since ByteCode's can be shared among procedures.
	 */
	if (*TByteCode)(unsafe.Pointer(codePtr)).FprocPtr != libc.UintptrFromInt32(0) {
		procPtr = (*TByteCode)(unsafe.Pointer(codePtr)).FprocPtr
		numCompiledLocals = (*TProc)(unsafe.Pointer(procPtr)).FnumCompiledLocals
		XTcl_AppendPrintfToObj(tls, bufferObj, __ccgo_ts+27485, libc.VaList(bp+24, procPtr, (*TProc)(unsafe.Pointer(procPtr)).FrefCount, (*TProc)(unsafe.Pointer(procPtr)).FnumArgs, numCompiledLocals))
		if numCompiledLocals > 0 {
			localPtr = (*TProc)(unsafe.Pointer(procPtr)).FfirstLocalPtr
			i = 0
			for {
				if !(i < numCompiledLocals) {
					break
				}
				if (*TCompiledLocal)(unsafe.Pointer(localPtr)).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)) != 0 {
					v7 = __ccgo_ts + 1945
				} else {
					v7 = __ccgo_ts + 27538
				}
				if (*TCompiledLocal)(unsafe.Pointer(localPtr)).Fflags&int32(VAR_ARRAY) != 0 {
					v8 = __ccgo_ts + 27547
				} else {
					v8 = __ccgo_ts + 1945
				}
				if (*TCompiledLocal)(unsafe.Pointer(localPtr)).Fflags&int32(VAR_LINK) != 0 {
					v9 = __ccgo_ts + 27555
				} else {
					v9 = __ccgo_ts + 1945
				}
				if (*TCompiledLocal)(unsafe.Pointer(localPtr)).Fflags&int32(VAR_ARGUMENT) != 0 {
					v10 = __ccgo_ts + 27562
				} else {
					v10 = __ccgo_ts + 1945
				}
				if (*TCompiledLocal)(unsafe.Pointer(localPtr)).Fflags&int32(VAR_TEMPORARY) != 0 {
					v11 = __ccgo_ts + 27568
				} else {
					v11 = __ccgo_ts + 1945
				}
				if (*TCompiledLocal)(unsafe.Pointer(localPtr)).Fflags&int32(VAR_RESOLVED) != 0 {
					v12 = __ccgo_ts + 27575
				} else {
					v12 = __ccgo_ts + 1945
				}
				XTcl_AppendPrintfToObj(tls, bufferObj, __ccgo_ts+27586, libc.VaList(bp+24, i, v7, v8, v9, v10, v11, v12))
				if (*TCompiledLocal)(unsafe.Pointer(localPtr)).Fflags&int32(VAR_TEMPORARY) != 0 {
					XTcl_AppendToObj(tls, bufferObj, __ccgo_ts+286, int64(-int32(1)))
				} else {
					XTcl_AppendPrintfToObj(tls, bufferObj, __ccgo_ts+27613, libc.VaList(bp+24, localPtr+44))
				}
				localPtr = (*TCompiledLocal)(unsafe.Pointer(localPtr)).FnextPtr
				goto _6
			_6:
				;
				i++
			}
		}
	}
	/*
	 * Print the ExceptionRange array.
	 */
	if int32((*TByteCode)(unsafe.Pointer(codePtr)).FnumExceptRanges) > 0 {
		XTcl_AppendPrintfToObj(tls, bufferObj, __ccgo_ts+27621, libc.VaList(bp+24, (*TByteCode)(unsafe.Pointer(codePtr)).FnumExceptRanges, (*TByteCode)(unsafe.Pointer(codePtr)).FmaxExceptDepth))
		i = 0
		for {
			if !(i < int64(int32((*TByteCode)(unsafe.Pointer(codePtr)).FnumExceptRanges))) {
				break
			}
			rangePtr = (*TByteCode)(unsafe.Pointer(codePtr)).FexceptArrayPtr + uintptr(i)*56
			if (*TExceptionRange)(unsafe.Pointer(rangePtr)).Ftype1 == int32(LOOP_EXCEPTION_RANGE) {
				v14 = __ccgo_ts + 21703
			} else {
				v14 = __ccgo_ts + 5129
			}
			XTcl_AppendPrintfToObj(tls, bufferObj, __ccgo_ts+27657, libc.VaList(bp+24, i, (*TExceptionRange)(unsafe.Pointer(rangePtr)).FnestingLevel, v14, (*TExceptionRange)(unsafe.Pointer(rangePtr)).FcodeOffset, (*TExceptionRange)(unsafe.Pointer(rangePtr)).FcodeOffset+(*TExceptionRange)(unsafe.Pointer(rangePtr)).FnumCodeBytes-int64(1)))
			switch (*TExceptionRange)(unsafe.Pointer(rangePtr)).Ftype1 {
			case int32(LOOP_EXCEPTION_RANGE):
				XTcl_AppendPrintfToObj(tls, bufferObj, __ccgo_ts+27696, libc.VaList(bp+24, (*TExceptionRange)(unsafe.Pointer(rangePtr)).FcontinueOffset, (*TExceptionRange)(unsafe.Pointer(rangePtr)).FbreakOffset))
			case int32(CATCH_EXCEPTION_RANGE):
				XTcl_AppendPrintfToObj(tls, bufferObj, __ccgo_ts+27721, libc.VaList(bp+24, (*TExceptionRange)(unsafe.Pointer(rangePtr)).FcatchOffset))
			default:
				XTcl_Panic(tls, __ccgo_ts+27732, libc.VaList(bp+24, (*TExceptionRange)(unsafe.Pointer(rangePtr)).Ftype1))
			}
			goto _13
		_13:
			;
			i++
		}
	}
	/*
	 * If there were no commands (e.g., an expression or an empty string was
	 * compiled), just print all instructions and return.
	 */
	if numCmds == 0 {
		pc = codeStart
		for pc < codeLimit {
			XTcl_AppendToObj(tls, bufferObj, __ccgo_ts+27783, int64(-int32(1)))
			pc += uintptr(_FormatInstruction(tls, codePtr, pc, bufferObj))
		}
		return bufferObj
	}
	/*
	 * Print table showing the code offset, source offset, and source length
	 * for each command. These are encoded as a sequence of bytes.
	 */
	XTcl_AppendPrintfToObj(tls, bufferObj, __ccgo_ts+27788, libc.VaList(bp+24, numCmds))
	codeDeltaNext = (*TByteCode)(unsafe.Pointer(codePtr)).FcodeDeltaStart
	codeLengthNext = (*TByteCode)(unsafe.Pointer(codePtr)).FcodeLengthStart
	srcDeltaNext = (*TByteCode)(unsafe.Pointer(codePtr)).FsrcDeltaStart
	srcLengthNext = (*TByteCode)(unsafe.Pointer(codePtr)).FsrcLengthStart
	v15 = libc.Int32FromInt32(0)
	srcOffset = v15
	codeOffset = v15
	i = 0
	for {
		if !(i < int64(numCmds)) {
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(codeDeltaNext))) == int32(0xFF) {
			codeDeltaNext++
			delta = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(codeDeltaNext)))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(codeDeltaNext + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(codeDeltaNext + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(codeDeltaNext + libc.UintptrFromInt32(3)))))
			codeDeltaNext += uintptr(4)
		} else {
			delta = int32(*(*int8)(unsafe.Pointer(codeDeltaNext)))
			codeDeltaNext++
		}
		codeOffset += delta
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(codeLengthNext))) == int32(0xFF) {
			codeLengthNext++
			codeLen = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(codeLengthNext)))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(codeLengthNext + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(codeLengthNext + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(codeLengthNext + libc.UintptrFromInt32(3)))))
			codeLengthNext += uintptr(4)
		} else {
			codeLen = int32(*(*int8)(unsafe.Pointer(codeLengthNext)))
			codeLengthNext++
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(srcDeltaNext))) == int32(0xFF) {
			srcDeltaNext++
			delta = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(srcDeltaNext)))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(srcDeltaNext + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(srcDeltaNext + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(srcDeltaNext + libc.UintptrFromInt32(3)))))
			srcDeltaNext += uintptr(4)
		} else {
			delta = int32(*(*int8)(unsafe.Pointer(srcDeltaNext)))
			srcDeltaNext++
		}
		srcOffset += delta
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(srcLengthNext))) == int32(0xFF) {
			srcLengthNext++
			srcLen = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(srcLengthNext)))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(srcLengthNext + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(srcLengthNext + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(srcLengthNext + libc.UintptrFromInt32(3)))))
			srcLengthNext += uintptr(4)
		} else {
			srcLen = int32(*(*int8)(unsafe.Pointer(srcLengthNext)))
			srcLengthNext++
		}
		if i%int64(2) != 0 {
			v17 = __ccgo_ts + 27803
		} else {
			v17 = __ccgo_ts + 27809
		}
		XTcl_AppendPrintfToObj(tls, bufferObj, __ccgo_ts+27814, libc.VaList(bp+24, v17, i+int64(1), codeOffset, codeOffset+codeLen-int32(1), srcOffset, srcOffset+srcLen-int32(1)))
		goto _16
	_16:
		;
		i++
	}
	if numCmds > 0 {
		XTcl_AppendToObj(tls, bufferObj, __ccgo_ts+286, int64(-int32(1)))
	}
	/*
	 * Print each instruction. If the instruction corresponds to the start of
	 * a command, print the command's source. Note that we don't need the code
	 * length here.
	 */
	codeDeltaNext = (*TByteCode)(unsafe.Pointer(codePtr)).FcodeDeltaStart
	srcDeltaNext = (*TByteCode)(unsafe.Pointer(codePtr)).FsrcDeltaStart
	srcLengthNext = (*TByteCode)(unsafe.Pointer(codePtr)).FsrcLengthStart
	v18 = libc.Int32FromInt32(0)
	srcOffset = v18
	codeOffset = v18
	pc = codeStart
	i = 0
	for {
		if !(i < int64(numCmds)) {
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(codeDeltaNext))) == int32(0xFF) {
			codeDeltaNext++
			delta = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(codeDeltaNext)))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(codeDeltaNext + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(codeDeltaNext + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(codeDeltaNext + libc.UintptrFromInt32(3)))))
			codeDeltaNext += uintptr(4)
		} else {
			delta = int32(*(*int8)(unsafe.Pointer(codeDeltaNext)))
			codeDeltaNext++
		}
		codeOffset += delta
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(srcDeltaNext))) == int32(0xFF) {
			srcDeltaNext++
			delta = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(srcDeltaNext)))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(srcDeltaNext + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(srcDeltaNext + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(srcDeltaNext + libc.UintptrFromInt32(3)))))
			srcDeltaNext += uintptr(4)
		} else {
			delta = int32(*(*int8)(unsafe.Pointer(srcDeltaNext)))
			srcDeltaNext++
		}
		srcOffset += delta
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(srcLengthNext))) == int32(0xFF) {
			srcLengthNext++
			srcLen = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(srcLengthNext)))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(srcLengthNext + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(srcLengthNext + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(srcLengthNext + libc.UintptrFromInt32(3)))))
			srcLengthNext += uintptr(4)
		} else {
			srcLen = int32(*(*int8)(unsafe.Pointer(srcLengthNext)))
			srcLengthNext++
		}
		/*
		 * Print instructions before command i.
		 */
		for int64(pc)-int64(codeStart) < int64(codeOffset) {
			XTcl_AppendToObj(tls, bufferObj, __ccgo_ts+27783, int64(-int32(1)))
			pc += uintptr(_FormatInstruction(tls, codePtr, pc, bufferObj))
		}
		XTcl_AppendPrintfToObj(tls, bufferObj, __ccgo_ts+27842, libc.VaList(bp+24, i+int64(1)))
		if libc.Uint64FromInt32(srcLen)+uint64(1) < libc.Uint64FromInt32(55)+libc.Uint64FromInt32(1) {
			v20 = srcLen
		} else {
			v20 = int32(55)
		}
		_PrintSourceToObj(tls, bufferObj, (*TByteCode)(unsafe.Pointer(codePtr)).Fsource+uintptr(srcOffset), int64(v20))
		XTcl_AppendToObj(tls, bufferObj, __ccgo_ts+286, int64(-int32(1)))
		goto _19
	_19:
		;
		i++
	}
	if pc < codeLimit {
		/*
		 * Print instructions after the last command.
		 */
		for pc < codeLimit {
			XTcl_AppendToObj(tls, bufferObj, __ccgo_ts+27783, int64(-int32(1)))
			pc += uintptr(_FormatInstruction(tls, codePtr, pc, bufferObj))
		}
	}
	return bufferObj
}

/*
 *----------------------------------------------------------------------
 *
 * FormatInstruction --
 *
 *	Appends a representation of a bytecode instruction to a Tcl_Obj.
 *
 *----------------------------------------------------------------------
 */

func _FormatInstruction(tls *libc.TLS, codePtr uintptr, pc uintptr, bufferObj uintptr) (r int32) {
	bp := tls.Alloc(160)
	defer tls.Free(160) /* Object to append instruction info to. */
	var auxPtr, bytes, codeStart, instDesc, localPtr, procPtr, suffixObj, suffixSrc, v2, v21 uintptr
	var i, j, numBytes, opnd int32
	var localCt TTcl_Size
	var opCode uint8
	var pcOffset uint32
	var v1, v22 int64
	var _ /* length at bp+128 */ TTcl_Size
	var _ /* suffixBuffer at bp+0 */ [128]uint8
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = auxPtr, bytes, codeStart, i, instDesc, j, localCt, localPtr, numBytes, opCode, opnd, pcOffset, procPtr, suffixObj, suffixSrc, v1, v2, v21, v22
	procPtr = (*TByteCode)(unsafe.Pointer(codePtr)).FprocPtr
	opCode = *(*uint8)(unsafe.Pointer(pc))
	instDesc = uintptr(unsafe.Pointer(&XtclInstructionTable)) + uintptr(opCode)*32
	codeStart = (*TByteCode)(unsafe.Pointer(codePtr)).FcodeStart
	pcOffset = libc.Uint32FromInt64(int64(pc) - int64(codeStart))
	opnd = 0
	numBytes = int32(1)
	if procPtr != 0 {
		v1 = (*TProc)(unsafe.Pointer(procPtr)).FnumCompiledLocals
	} else {
		v1 = 0
	}
	localCt = v1
	if procPtr != 0 {
		v2 = (*TProc)(unsafe.Pointer(procPtr)).FfirstLocalPtr
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	localPtr = v2 /* Additional info to print after main opcode
	 * and immediates. */
	suffixSrc = libc.UintptrFromInt32(0)
	suffixObj = libc.UintptrFromInt32(0)
	auxPtr = libc.UintptrFromInt32(0)
	(*(*[128]uint8)(unsafe.Pointer(bp)))[0] = uint8('\000')
	XTcl_AppendPrintfToObj(tls, bufferObj, __ccgo_ts+27858, libc.VaList(bp+144, pcOffset, (*TInstructionDesc)(unsafe.Pointer(instDesc)).Fname))
	i = 0
	for {
		if !(i < (*TInstructionDesc)(unsafe.Pointer(instDesc)).FnumOperands) {
			break
		}
		switch *(*TInstOperandType)(unsafe.Pointer(instDesc + 24 + uintptr(i)*4)) {
		case int32(OPERAND_INT1):
			goto _4
		case int32(OPERAND_INT4):
			goto _5
		case int32(OPERAND_UINT1):
			goto _6
		case int32(OPERAND_UINT4):
			goto _7
		case int32(OPERAND_OFFSET1):
			goto _8
		case int32(OPERAND_OFFSET4):
			goto _9
		case int32(OPERAND_LIT1):
			goto _10
		case int32(OPERAND_LIT4):
			goto _11
		case int32(OPERAND_AUX4):
			goto _12
		case int32(OPERAND_IDX4):
			goto _13
		case int32(OPERAND_LVT1):
			goto _14
		case int32(OPERAND_LVT4):
			goto _15
		case int32(OPERAND_SCLS1):
			goto _16
		default:
			goto _17
		case int32(OPERAND_NONE):
			goto _18
		}
		goto _19
	_4:
		;
		opnd = int32(*(*int8)(unsafe.Pointer(pc + uintptr(numBytes))))
		numBytes++
		XTcl_AppendPrintfToObj(tls, bufferObj, __ccgo_ts+27867, libc.VaList(bp+144, opnd))
		goto _19
	_5:
		;
		opnd = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes) + libc.UintptrFromInt32(3)))))
		numBytes += int32(4)
		XTcl_AppendPrintfToObj(tls, bufferObj, __ccgo_ts+27867, libc.VaList(bp+144, opnd))
		goto _19
	_6:
		;
		opnd = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes)))))
		numBytes++
		XTcl_AppendPrintfToObj(tls, bufferObj, __ccgo_ts+27872, libc.VaList(bp+144, opnd))
		goto _19
	_7:
		;
		opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes) + libc.UintptrFromInt32(3))))))
		numBytes += int32(4)
		if libc.Int32FromUint8(opCode) == int32(INST_START_CMD) {
			libc.X__builtin_snprintf(tls, bp+uintptr(libc.Xstrlen(tls, bp)), uint64(128)-libc.Xstrlen(tls, bp), __ccgo_ts+27876, libc.VaList(bp+144, opnd))
		}
		XTcl_AppendPrintfToObj(tls, bufferObj, __ccgo_ts+27872, libc.VaList(bp+144, opnd))
		goto _19
	_8:
		;
		opnd = int32(*(*int8)(unsafe.Pointer(pc + uintptr(numBytes))))
		numBytes++
		libc.X__builtin_snprintf(tls, bp, uint64(128), __ccgo_ts+27897, libc.VaList(bp+144, pcOffset+libc.Uint32FromInt32(opnd)))
		XTcl_AppendPrintfToObj(tls, bufferObj, __ccgo_ts+27867, libc.VaList(bp+144, opnd))
		goto _19
	_9:
		;
		opnd = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes) + libc.UintptrFromInt32(3)))))
		numBytes += int32(4)
		if libc.Int32FromUint8(opCode) == int32(INST_START_CMD) {
			libc.X__builtin_snprintf(tls, bp, uint64(128), __ccgo_ts+27903, libc.VaList(bp+144, pcOffset+libc.Uint32FromInt32(opnd)))
		} else {
			libc.X__builtin_snprintf(tls, bp, uint64(128), __ccgo_ts+27897, libc.VaList(bp+144, pcOffset+libc.Uint32FromInt32(opnd)))
		}
		XTcl_AppendPrintfToObj(tls, bufferObj, __ccgo_ts+27867, libc.VaList(bp+144, opnd))
		goto _19
	_10:
		;
		opnd = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes)))))
		numBytes++
		suffixObj = *(*uintptr)(unsafe.Pointer((*TByteCode)(unsafe.Pointer(codePtr)).FobjArrayPtr + uintptr(opnd)*8))
		XTcl_AppendPrintfToObj(tls, bufferObj, __ccgo_ts+27872, libc.VaList(bp+144, opnd))
		goto _19
	_11:
		;
		opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes) + libc.UintptrFromInt32(3))))))
		numBytes += int32(4)
		suffixObj = *(*uintptr)(unsafe.Pointer((*TByteCode)(unsafe.Pointer(codePtr)).FobjArrayPtr + uintptr(opnd)*8))
		XTcl_AppendPrintfToObj(tls, bufferObj, __ccgo_ts+27872, libc.VaList(bp+144, opnd))
		goto _19
	_12:
		;
		opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes) + libc.UintptrFromInt32(3))))))
		numBytes += int32(4)
		XTcl_AppendPrintfToObj(tls, bufferObj, __ccgo_ts+27872, libc.VaList(bp+144, opnd))
		auxPtr = (*TByteCode)(unsafe.Pointer(codePtr)).FauxDataArrayPtr + uintptr(opnd)*16
		goto _19
	_13:
		;
		opnd = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes) + libc.UintptrFromInt32(3)))))
		numBytes += int32(4)
		if opnd >= -int32(1) {
			XTcl_AppendPrintfToObj(tls, bufferObj, __ccgo_ts+27921, libc.VaList(bp+144, opnd))
		} else {
			if opnd == -int32(2) {
				XTcl_AppendPrintfToObj(tls, bufferObj, __ccgo_ts+27925, 0)
			} else {
				XTcl_AppendPrintfToObj(tls, bufferObj, __ccgo_ts+27930, libc.VaList(bp+144, -int32(2)-opnd))
			}
		}
		goto _19
	_14:
		;
		opnd = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes)))))
		numBytes++
		goto printLVTindex
	_15:
		;
		opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes) + libc.UintptrFromInt32(3))))))
		numBytes += int32(4)
		goto printLVTindex
	printLVTindex:
		;
		if localPtr != libc.UintptrFromInt32(0) {
			if int64(opnd) >= localCt {
				XTcl_Panic(tls, __ccgo_ts+27938, libc.VaList(bp+144, opnd, localCt))
			}
			j = 0
			for {
				if !(j < opnd) {
					break
				}
				localPtr = (*TCompiledLocal)(unsafe.Pointer(localPtr)).FnextPtr
				goto _20
			_20:
				;
				j++
			}
			if (*TCompiledLocal)(unsafe.Pointer(localPtr)).Fflags&int32(VAR_TEMPORARY) != 0 {
				libc.X__builtin_snprintf(tls, bp, uint64(128), __ccgo_ts+27993, libc.VaList(bp+144, opnd))
			} else {
				libc.X__builtin_snprintf(tls, bp, uint64(128), __ccgo_ts+28005, 0)
				suffixSrc = localPtr + 44
			}
		}
		XTcl_AppendPrintfToObj(tls, bufferObj, __ccgo_ts+28010, libc.VaList(bp+144, opnd))
		goto _19
	_16:
		;
		opnd = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + uintptr(numBytes)))))
		numBytes++
		XTcl_AppendPrintfToObj(tls, bufferObj, __ccgo_ts+28017, libc.VaList(bp+144, uintptr(unsafe.Pointer(&XtclStringClassTable))+uintptr(opnd)*16))
		goto _19
	_18:
		;
	_17:
		;
		goto _19
	_19:
		;
		goto _3
	_3:
		;
		i++
	}
	if suffixObj != 0 {
		XTcl_AppendToObj(tls, bufferObj, __ccgo_ts+28021, int64(-int32(1)))
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TByteCode)(unsafe.Pointer(codePtr)).FobjArrayPtr + uintptr(opnd)*8)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 128)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TByteCode)(unsafe.Pointer(codePtr)).FobjArrayPtr + uintptr(opnd)*8)))).Flength
			v21 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TByteCode)(unsafe.Pointer(codePtr)).FobjArrayPtr + uintptr(opnd)*8)))).Fbytes
		} else {
			v21 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer((*TByteCode)(unsafe.Pointer(codePtr)).FobjArrayPtr + uintptr(opnd)*8)), bp+128)
		}
		bytes = v21
		if libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 128)))+uint64(1) < libc.Uint64FromInt32(40)+libc.Uint64FromInt32(1) {
			v22 = *(*TTcl_Size)(unsafe.Pointer(bp + 128))
		} else {
			v22 = int64(libc.Int32FromInt32(40))
		}
		_PrintSourceToObj(tls, bufferObj, bytes, v22)
	} else {
		if (*(*[128]uint8)(unsafe.Pointer(bp)))[0] != 0 {
			XTcl_AppendPrintfToObj(tls, bufferObj, __ccgo_ts+28025, libc.VaList(bp+144, bp))
			if suffixSrc != 0 {
				_PrintSourceToObj(tls, bufferObj, suffixSrc, int64(40))
			}
		}
	}
	XTcl_AppendToObj(tls, bufferObj, __ccgo_ts+286, int64(-int32(1)))
	if auxPtr != 0 && (*TAuxDataType)(unsafe.Pointer((*TAuxData)(unsafe.Pointer(auxPtr)).Ftype1)).FprintProc != 0 {
		XTcl_AppendToObj(tls, bufferObj, __ccgo_ts+28031, int64(-int32(1)))
		(*(*func(*libc.TLS, uintptr, uintptr, uintptr, Tsize_t))(unsafe.Pointer(&struct{ uintptr }{(*TAuxDataType)(unsafe.Pointer((*TAuxData)(unsafe.Pointer(auxPtr)).Ftype1)).FprintProc})))(tls, (*TAuxData)(unsafe.Pointer(auxPtr)).FclientData, bufferObj, codePtr, uint64(pcOffset))
		XTcl_AppendToObj(tls, bufferObj, __ccgo_ts+28035, int64(-int32(1)))
	}
	return numBytes
}

/*
 *----------------------------------------------------------------------
 *
 * TclGetInnerContext --
 *
 *	If possible, returns a list capturing the inner context. Otherwise
 *	return NULL.
 *
 *----------------------------------------------------------------------
 */

func XTclGetInnerContext(tls *libc.TLS, interp uintptr, pc uintptr, tosPtr uintptr) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _objPtr, iPtr, objPtr, result, v2, v3 uintptr
	var objc, v1 TTcl_Size
	var v5 int64
	var _ /* len at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _ = _objPtr, iPtr, objPtr, objc, result, v1, v2, v3, v5
	objc = 0
	iPtr = interp
	switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) {
	case int32(INST_STR_LEN):
		fallthrough
	case int32(INST_LNOT):
		fallthrough
	case int32(INST_BITNOT):
		fallthrough
	case int32(INST_UMINUS):
		fallthrough
	case int32(INST_UPLUS):
		fallthrough
	case int32(INST_TRY_CVT_TO_NUMERIC):
		fallthrough
	case int32(INST_EXPAND_STKTOP):
		fallthrough
	case int32(INST_EXPR_STK):
		objc = int64(1)
	case int32(INST_LIST_IN):
		fallthrough
	case int32(INST_LIST_NOT_IN): /* Basic list containment operators. */
		fallthrough
	case int32(INST_STR_EQ):
		fallthrough
	case int32(INST_STR_NEQ): /* String (in)equality check */
		fallthrough
	case int32(INST_STR_CMP): /* String compare. */
		fallthrough
	case int32(INST_STR_INDEX):
		fallthrough
	case int32(INST_STR_MATCH):
		fallthrough
	case int32(INST_REGEXP):
		fallthrough
	case int32(INST_EQ):
		fallthrough
	case int32(INST_NEQ):
		fallthrough
	case int32(INST_LT):
		fallthrough
	case int32(INST_GT):
		fallthrough
	case int32(INST_LE):
		fallthrough
	case int32(INST_GE):
		fallthrough
	case int32(INST_MOD):
		fallthrough
	case int32(INST_LSHIFT):
		fallthrough
	case int32(INST_RSHIFT):
		fallthrough
	case int32(INST_BITOR):
		fallthrough
	case int32(INST_BITXOR):
		fallthrough
	case int32(INST_BITAND):
		fallthrough
	case int32(INST_EXPON):
		fallthrough
	case int32(INST_ADD):
		fallthrough
	case int32(INST_SUB):
		fallthrough
	case int32(INST_DIV):
		fallthrough
	case int32(INST_MULT):
		objc = int64(2)
	case int32(INST_RETURN_STK):
		/* early pop. TODO: dig out opt dict too :/ */
		objc = int64(1)
	case int32(INST_SYNTAX):
		fallthrough
	case int32(INST_RETURN_IMM):
		objc = int64(2)
	case int32(INST_INVOKE_STK4):
		objc = libc.Int64FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	case int32(INST_INVOKE_STK1):
		objc = libc.Int64FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1)))))
		break
	}
	result = (*TInterp)(unsafe.Pointer(iPtr)).FinnerContext
	if (*TTcl_Obj)(unsafe.Pointer(result)).FrefCount > int64(1) {
		_objPtr = result
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		v3 = XTcl_NewListObj(tls, objc+int64(1), libc.UintptrFromInt32(0))
		result = v3
		(*TInterp)(unsafe.Pointer(iPtr)).FinnerContext = v3
		(*TTcl_Obj)(unsafe.Pointer(result)).FrefCount++
	} else {
		/*
		 * Reset while keeping the list internalrep as much as possible.
		 */
		if (*TTcl_Obj)(unsafe.Pointer(result)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(result + 32))).Fptr2 != 0 {
				v5 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(result + 32))).Fptr2)).FspanLength
			} else {
				v5 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(result + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp)) = v5
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_ListObjLength(tls, interp, result, bp)
		}
		XTcl_ListObjReplace(tls, interp, result, 0, *(*TTcl_Size)(unsafe.Pointer(bp)), 0, libc.UintptrFromInt32(0))
	}
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), result, XTclNewInstNameObj(tls, *(*uint8)(unsafe.Pointer(pc))))
	for {
		if !(objc > 0) {
			break
		}
		objPtr = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(int64(1)-objc)*8))
		if !(objPtr != 0) {
			XTcl_Panic(tls, __ccgo_ts+28038, 0)
		}
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount <= 0 {
			XTcl_Panic(tls, __ccgo_ts+28085, libc.VaList(bp+16, objPtr))
		}
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), result, objPtr)
		goto _6
	_6:
		;
		objc--
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * TclNewInstNameObj --
 *
 *	Creates a new InstName Tcl_Obj based on the given instruction
 *
 *----------------------------------------------------------------------
 */

func XTclNewInstNameObj(tls *libc.TLS, inst uint8) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _isobjPtr, cachePtr, objPtr uintptr
	var v1 bool
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_, _, _, _ = _isobjPtr, cachePtr, objPtr, v1
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	_isobjPtr = objPtr
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
	*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp)))) = libc.Int64FromUint8(inst)
	XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&_instNameType)), bp)
	return objPtr
}

/*
 *----------------------------------------------------------------------
 *
 * UpdateStringOfInstName --
 *
 *	Update the string representation for an instruction name object.
 *
 *----------------------------------------------------------------------
 */

func _UpdateStringOfInstName(tls *libc.TLS, objPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var dst, irPtr, s, v1 uintptr
	var inst, len1 Tsize_t
	var v2, v3, v4, v5 bool
	_, _, _, _, _, _, _, _, _, _ = dst, inst, irPtr, len1, s, v1, v2, v3, v4, v5
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_instNameType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	inst = libc.Uint64FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(irPtr)))
	if inst >= uint64(LAST_INST_OPCODE) {
		dst = XTcl_InitStringRep(tls, objPtr, libc.UintptrFromInt32(0), libc.Uint64FromInt32(libc.Int32FromInt32(3)*libc.Int32FromInt64(8)+libc.Int32FromInt32(5)))
		if v3 = libc.Bool(libc.Int32FromInt32(3)*libc.Int32FromInt64(8)+libc.Int32FromInt32(5) != 0); v3 {
			if v2 = dst != 0; !v2 {
				XTcl_Panic(tls, __ccgo_ts+10479, libc.VaList(bp+8, libc.Uint64FromInt32(libc.Int32FromInt32(3)*libc.Int32FromInt64(8)+libc.Int32FromInt32(5))))
			}
		}
		_ = v3 && (v2 || libc.Bool(libc.Int32FromInt32(1) != 0))
		libc.X__builtin_snprintf(tls, dst, libc.Uint64FromInt32(libc.Int32FromInt32(3)*libc.Int32FromInt64(8)+libc.Int32FromInt32(5)), __ccgo_ts+28136, libc.VaList(bp+8, inst))
		XTcl_InitStringRep(tls, objPtr, libc.UintptrFromInt32(0), libc.Xstrlen(tls, dst))
	} else {
		s = XtclInstructionTable[inst].Fname
		len1 = libc.Xstrlen(tls, s)
		dst = XTcl_InitStringRep(tls, objPtr, s, len1)
		if v5 = len1 != 0; v5 {
			if v4 = dst != 0; !v4 {
				XTcl_Panic(tls, __ccgo_ts+10479, libc.VaList(bp+8, len1))
			}
		}
		_ = v5 && (v4 || libc.Bool(libc.Int32FromInt32(1) != 0))
	}
}

/*
 *----------------------------------------------------------------------
 *
 * PrintSourceToObj --
 *
 *	Appends a quoted representation of a string to a Tcl_Obj.
 *
 *----------------------------------------------------------------------
 */

func _PrintSourceToObj(tls *libc.TLS, appendObj uintptr, stringPtr uintptr, maxChars TTcl_Size) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Maximum number of chars to print. */
	var i, len1 TTcl_Size
	var p uintptr
	var v2 int64
	var _ /* ucs4 at bp+0 */ int32
	_, _, _, _ = i, len1, p, v2
	i = 0
	if stringPtr == libc.UintptrFromInt32(0) {
		XTcl_AppendToObj(tls, appendObj, __ccgo_ts+28145, int64(-int32(1)))
		return
	}
	XTcl_AppendToObj(tls, appendObj, __ccgo_ts+14586, int64(-int32(1)))
	p = stringPtr
	for {
		if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('\000') && i < maxChars) {
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) < int32(0x80) {
			*(*int32)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))
			v2 = int64(libc.Int32FromInt32(1))
		} else {
			v2 = XTcl_UtfToUniChar(tls, p, bp)
		}
		len1 = v2
		switch *(*int32)(unsafe.Pointer(bp)) {
		case int32('"'):
			XTcl_AppendToObj(tls, appendObj, __ccgo_ts+28148, int64(-int32(1)))
			i += int64(2)
			goto _1
		case int32('\f'):
			XTcl_AppendToObj(tls, appendObj, __ccgo_ts+28151, int64(-int32(1)))
			i += int64(2)
			goto _1
		case int32('\n'):
			XTcl_AppendToObj(tls, appendObj, __ccgo_ts+28154, int64(-int32(1)))
			i += int64(2)
			goto _1
		case int32('\r'):
			XTcl_AppendToObj(tls, appendObj, __ccgo_ts+28157, int64(-int32(1)))
			i += int64(2)
			goto _1
		case int32('\t'):
			XTcl_AppendToObj(tls, appendObj, __ccgo_ts+28160, int64(-int32(1)))
			i += int64(2)
			goto _1
		case int32('\v'):
			XTcl_AppendToObj(tls, appendObj, __ccgo_ts+28163, int64(-int32(1)))
			i += int64(2)
			goto _1
		default:
			if *(*int32)(unsafe.Pointer(bp)) > int32(0xFFFF) {
				XTcl_AppendPrintfToObj(tls, appendObj, __ccgo_ts+28166, libc.VaList(bp+16, *(*int32)(unsafe.Pointer(bp))))
				i += int64(10)
			} else {
				if *(*int32)(unsafe.Pointer(bp)) < int32(0x20) || *(*int32)(unsafe.Pointer(bp)) >= int32(0x7F) {
					XTcl_AppendPrintfToObj(tls, appendObj, __ccgo_ts+28173, libc.VaList(bp+16, *(*int32)(unsafe.Pointer(bp))))
					i += int64(6)
				} else {
					XTcl_AppendPrintfToObj(tls, appendObj, __ccgo_ts+28180, libc.VaList(bp+16, *(*int32)(unsafe.Pointer(bp))))
					i++
				}
			}
			goto _1
		}
		goto _1
	_1:
		;
		p += uintptr(len1)
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('\000') {
		XTcl_AppendToObj(tls, appendObj, __ccgo_ts+8560, int64(-int32(1)))
	}
	XTcl_AppendToObj(tls, appendObj, __ccgo_ts+14586, int64(-int32(1)))
}

/*
 *----------------------------------------------------------------------
 *
 * DisassembleByteCodeAsDicts --
 *
 *	Given an object which is of bytecode type, return a disassembled
 *	version of the bytecode (in a new refcount 0 object) in a dictionary.
 *	No guarantees are made about the details of the contents of the
 *	result, but it is intended to be more readable than the old output
 *	format.
 *
 *----------------------------------------------------------------------
 */

func _DisassembleByteCodeAsDicts(tls *libc.TLS, objPtr uintptr) (r uintptr) {
	bp := tls.Alloc(96)
	defer tls.Free(96) /* The bytecode-holding value to take apart */
	var address, codeLength, codeOffset, sourceLength, sourceOffset, val, v34, v36, v37, v38, v39 int32
	var aux, auxData, auxDesc, cachePtr, cachePtr1, cachePtr10, cachePtr11, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cachePtr8, cachePtr9, cmd, codeLenPtr, codeOffPtr, codePtr, commands, desc, desc1, description, exn, inst, instDesc, instructions, irPtr, literals, localPtr, opnd, pc, rangePtr, srcLenPtr, srcOffPtr, variables, v1, v2 uintptr
	var i, localCount TTcl_Size
	var v10, v27, v29, v3, v30, v31, v33, v40, v41, v5, v7, v8 bool
	var _ /* descriptor at bp+16 */ [2]uintptr
	var _ /* file at bp+0 */ uintptr
	var _ /* line at bp+8 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = address, aux, auxData, auxDesc, cachePtr, cachePtr1, cachePtr10, cachePtr11, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cachePtr8, cachePtr9, cmd, codeLenPtr, codeLength, codeOffPtr, codeOffset, codePtr, commands, desc, desc1, description, exn, i, inst, instDesc, instructions, irPtr, literals, localCount, localPtr, opnd, pc, rangePtr, sourceLength, sourceOffset, srcLenPtr, srcOffPtr, val, variables, v1, v10, v2, v27, v29, v3, v30, v31, v33, v34, v36, v37, v38, v39, v40, v41, v5, v7, v8
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclByteCodeType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	codePtr = v2
	/*
	 * Get the literals from the bytecode.
	 */
	if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		literals = XTclThreadAllocObj(tls)
	} else {
		literals = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(literals + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(literals)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(literals)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(literals)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(literals)).FtypePtr = libc.UintptrFromInt32(0)
	i = 0
	for {
		if !(i < (*TByteCode)(unsafe.Pointer(codePtr)).FnumLitObjects) {
			break
		}
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), literals, *(*uintptr)(unsafe.Pointer((*TByteCode)(unsafe.Pointer(codePtr)).FobjArrayPtr + uintptr(i)*8)))
		goto _4
	_4:
		;
		i++
	}
	/*
	 * Get the variables from the bytecode.
	 */
	if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v5 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		variables = XTclThreadAllocObj(tls)
	} else {
		variables = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(variables + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(variables)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(variables)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(variables)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(variables)).FtypePtr = libc.UintptrFromInt32(0)
	if (*TByteCode)(unsafe.Pointer(codePtr)).FprocPtr != 0 {
		localCount = (*TProc)(unsafe.Pointer((*TByteCode)(unsafe.Pointer(codePtr)).FprocPtr)).FnumCompiledLocals
		localPtr = (*TProc)(unsafe.Pointer((*TByteCode)(unsafe.Pointer(codePtr)).FprocPtr)).FfirstLocalPtr
		i = 0
		for {
			if !(i < localCount) {
				break
			}
			if v7 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v7 {
				cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v7 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
				(*(*[2]uintptr)(unsafe.Pointer(bp + 16)))[0] = XTclThreadAllocObj(tls)
			} else {
				(*(*[2]uintptr)(unsafe.Pointer(bp + 16)))[0] = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 16)))[0] + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 16)))[0])).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 16)))[0])).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 16)))[0])).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 16)))[0])).FtypePtr = libc.UintptrFromInt32(0)
			if !((*TCompiledLocal)(unsafe.Pointer(localPtr)).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)) != 0) {
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), (*(*[2]uintptr)(unsafe.Pointer(bp + 16)))[0], XTcl_NewStringObj(tls, __ccgo_ts+28183, int64(-int32(1))))
			}
			if (*TCompiledLocal)(unsafe.Pointer(localPtr)).Fflags&int32(VAR_ARRAY) != 0 {
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), (*(*[2]uintptr)(unsafe.Pointer(bp + 16)))[0], XTcl_NewStringObj(tls, __ccgo_ts+28190, int64(-int32(1))))
			}
			if (*TCompiledLocal)(unsafe.Pointer(localPtr)).Fflags&int32(VAR_LINK) != 0 {
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), (*(*[2]uintptr)(unsafe.Pointer(bp + 16)))[0], XTcl_NewStringObj(tls, __ccgo_ts+5730, int64(-int32(1))))
			}
			if (*TCompiledLocal)(unsafe.Pointer(localPtr)).Fflags&int32(VAR_ARGUMENT) != 0 {
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), (*(*[2]uintptr)(unsafe.Pointer(bp + 16)))[0], XTcl_NewStringObj(tls, __ccgo_ts+28196, int64(-int32(1))))
			}
			if (*TCompiledLocal)(unsafe.Pointer(localPtr)).Fflags&int32(VAR_TEMPORARY) != 0 {
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), (*(*[2]uintptr)(unsafe.Pointer(bp + 16)))[0], XTcl_NewStringObj(tls, __ccgo_ts+28200, int64(-int32(1))))
			}
			if (*TCompiledLocal)(unsafe.Pointer(localPtr)).Fflags&int32(VAR_RESOLVED) != 0 {
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), (*(*[2]uintptr)(unsafe.Pointer(bp + 16)))[0], XTcl_NewStringObj(tls, __ccgo_ts+28205, int64(-int32(1))))
			}
			if (*TCompiledLocal)(unsafe.Pointer(localPtr)).Fflags&int32(VAR_TEMPORARY) != 0 {
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), variables, XTcl_NewListObj(tls, int64(1), bp+16))
			} else {
				(*(*[2]uintptr)(unsafe.Pointer(bp + 16)))[int32(1)] = XTcl_NewStringObj(tls, localPtr+44, int64(-int32(1)))
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), variables, XTcl_NewListObj(tls, int64(2), bp+16))
			}
			goto _6
		_6:
			;
			i++
			localPtr = (*TCompiledLocal)(unsafe.Pointer(localPtr)).FnextPtr
		}
	}
	/*
	 * Get the instructions from the bytecode.
	 */
	if v8 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v8 {
		cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v8 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
		instructions = XTclThreadAllocObj(tls)
	} else {
		instructions = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(instructions + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(instructions)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(instructions)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(instructions)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(instructions)).FtypePtr = libc.UintptrFromInt32(0)
	pc = (*TByteCode)(unsafe.Pointer(codePtr)).FcodeStart
	for {
		if !(pc < (*TByteCode)(unsafe.Pointer(codePtr)).FcodeStart+uintptr((*TByteCode)(unsafe.Pointer(codePtr)).FnumCodeBytes)) {
			break
		}
		instDesc = uintptr(unsafe.Pointer(&XtclInstructionTable)) + uintptr(*(*uint8)(unsafe.Pointer(pc)))*32
		address = int32(int64(pc) - int64((*TByteCode)(unsafe.Pointer(codePtr)).FcodeStart))
		if v10 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v10 {
			cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v10 || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == libc.Uint64FromInt32(0) {
			inst = XTclThreadAllocObj(tls)
		} else {
			inst = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(inst + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(inst)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(inst)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(inst)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(inst)).FtypePtr = libc.UintptrFromInt32(0)
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), inst, XTcl_NewStringObj(tls, (*TInstructionDesc)(unsafe.Pointer(instDesc)).Fname, int64(-int32(1))))
		opnd = pc + uintptr(1)
		i = 0
		for {
			if !(i < int64((*TInstructionDesc)(unsafe.Pointer(instDesc)).FnumOperands)) {
				break
			}
			switch *(*TInstOperandType)(unsafe.Pointer(instDesc + 24 + uintptr(i)*4)) {
			case int32(OPERAND_INT1):
				goto _12
			case int32(OPERAND_UINT1):
				goto _13
			case int32(OPERAND_INT4):
				goto _14
			case int32(OPERAND_UINT4):
				goto _15
			case int32(OPERAND_OFFSET1):
				goto _16
			case int32(OPERAND_OFFSET4):
				goto _17
			case int32(OPERAND_LIT1):
				goto _18
			case int32(OPERAND_LIT4):
				goto _19
			case int32(OPERAND_LVT1):
				goto _20
			case int32(OPERAND_LVT4):
				goto _21
			case int32(OPERAND_IDX4):
				goto _22
			case int32(OPERAND_AUX4):
				goto _23
			case int32(OPERAND_SCLS1):
				goto _24
			case int32(OPERAND_NONE):
				goto _25
			}
			goto _26
		_12:
			;
			val = int32(*(*int8)(unsafe.Pointer(opnd)))
			opnd += uintptr(1)
			goto formatNumber
		_13:
			;
			val = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(opnd))))
			opnd += uintptr(1)
			goto formatNumber
		_14:
			;
			val = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(opnd)))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(opnd + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(opnd + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(opnd + libc.UintptrFromInt32(3)))))
			opnd += uintptr(4)
			goto formatNumber
		_15:
			;
			val = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(opnd)))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(opnd + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(opnd + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(opnd + libc.UintptrFromInt32(3))))))
			opnd += uintptr(4)
			goto formatNumber
		formatNumber:
			;
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), inst, XTcl_NewWideIntObj(tls, int64(val)))
			goto _26
		_16:
			;
			val = int32(*(*int8)(unsafe.Pointer(opnd)))
			opnd += uintptr(1)
			goto formatAddress
		_17:
			;
			val = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(opnd)))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(opnd + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(opnd + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(opnd + libc.UintptrFromInt32(3)))))
			opnd += uintptr(4)
			goto formatAddress
		formatAddress:
			;
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), inst, XTcl_ObjPrintf(tls, __ccgo_ts+28214, libc.VaList(bp+40, address+val)))
			goto _26
		_18:
			;
			val = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(opnd))))
			opnd += uintptr(1)
			goto formatLiteral
		_19:
			;
			val = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(opnd)))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(opnd + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(opnd + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(opnd + libc.UintptrFromInt32(3))))))
			opnd += uintptr(4)
			goto formatLiteral
		formatLiteral:
			;
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), inst, XTcl_ObjPrintf(tls, __ccgo_ts+28220, libc.VaList(bp+40, val)))
			goto _26
		_20:
			;
			val = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(opnd))))
			opnd += uintptr(1)
			goto formatVariable
		_21:
			;
			val = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(opnd)))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(opnd + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(opnd + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(opnd + libc.UintptrFromInt32(3))))))
			opnd += uintptr(4)
			goto formatVariable
		formatVariable:
			;
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), inst, XTcl_ObjPrintf(tls, __ccgo_ts+28224, libc.VaList(bp+40, val)))
			goto _26
		_22:
			;
			val = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(opnd)))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(opnd + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(opnd + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(opnd + libc.UintptrFromInt32(3)))))
			opnd += uintptr(4)
			if val >= -int32(1) {
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), inst, XTcl_ObjPrintf(tls, __ccgo_ts+28229, libc.VaList(bp+40, val)))
			} else {
				if val == -int32(2) {
					XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), inst, XTcl_NewStringObj(tls, __ccgo_ts+28233, int64(-int32(1))))
				} else {
					XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), inst, XTcl_ObjPrintf(tls, __ccgo_ts+28238, libc.VaList(bp+40, -int32(2)-val)))
				}
			}
			goto _26
		_23:
			;
			val = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(opnd)))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(opnd + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(opnd + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(opnd + libc.UintptrFromInt32(3)))))
			opnd += uintptr(4)
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), inst, XTcl_ObjPrintf(tls, __ccgo_ts+28246, libc.VaList(bp+40, val)))
			goto _26
		_24:
			;
			val = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(opnd))))
			opnd++
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), inst, XTcl_ObjPrintf(tls, __ccgo_ts+28250, libc.VaList(bp+40, uintptr(unsafe.Pointer(&XtclStringClassTable))+uintptr(val)*16)))
			goto _26
		_25:
			;
			XTcl_Panic(tls, __ccgo_ts+28254, libc.VaList(bp+40, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc)))))
		_26:
			;
			goto _11
		_11:
			;
			i++
		}
		XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), instructions, XTcl_NewWideIntObj(tls, int64(address)), inst)
		pc += uintptr((*TInstructionDesc)(unsafe.Pointer(instDesc)).FnumBytes)
		goto _9
	_9:
	}
	/*
	 * Get the auxiliary data from the bytecode.
	 */
	if v27 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v27 {
		cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v27 || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == libc.Uint64FromInt32(0) {
		aux = XTclThreadAllocObj(tls)
	} else {
		aux = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(aux + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(aux)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(aux)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(aux)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(aux)).FtypePtr = libc.UintptrFromInt32(0)
	i = 0
	for {
		if !(i < int64(int32((*TByteCode)(unsafe.Pointer(codePtr)).FnumAuxDataItems))) {
			break
		}
		auxData = (*TByteCode)(unsafe.Pointer(codePtr)).FauxDataArrayPtr + uintptr(i)*16
		auxDesc = XTcl_NewStringObj(tls, (*TAuxDataType)(unsafe.Pointer((*TAuxData)(unsafe.Pointer(auxData)).Ftype1)).Fname, int64(-int32(1)))
		if (*TAuxDataType)(unsafe.Pointer((*TAuxData)(unsafe.Pointer(auxData)).Ftype1)).FdisassembleProc != 0 {
			if v29 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v29 {
				cachePtr6 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v29 || (*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects == libc.Uint64FromInt32(0) {
				desc = XTclThreadAllocObj(tls)
			} else {
				desc = (*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(desc + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(desc)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(desc)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(desc)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(desc)).FtypePtr = libc.UintptrFromInt32(0)
			XTclDictPut(tls, libc.UintptrFromInt32(0), desc, __ccgo_ts+3726, auxDesc)
			auxDesc = desc
			(*(*func(*libc.TLS, uintptr, uintptr, uintptr, Tsize_t))(unsafe.Pointer(&struct{ uintptr }{(*TAuxDataType)(unsafe.Pointer((*TAuxData)(unsafe.Pointer(auxData)).Ftype1)).FdisassembleProc})))(tls, (*TAuxData)(unsafe.Pointer(auxData)).FclientData, auxDesc, codePtr, uint64(0))
		} else {
			if (*TAuxDataType)(unsafe.Pointer((*TAuxData)(unsafe.Pointer(auxData)).Ftype1)).FprintProc != 0 {
				if v30 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v30 {
					cachePtr7 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v30 || (*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects == libc.Uint64FromInt32(0) {
					desc1 = XTclThreadAllocObj(tls)
				} else {
					desc1 = (*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(desc1 + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(desc1)).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer(desc1)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(desc1)).Flength = 0
				(*TTcl_Obj)(unsafe.Pointer(desc1)).FtypePtr = libc.UintptrFromInt32(0)
				(*(*func(*libc.TLS, uintptr, uintptr, uintptr, Tsize_t))(unsafe.Pointer(&struct{ uintptr }{(*TAuxDataType)(unsafe.Pointer((*TAuxData)(unsafe.Pointer(auxData)).Ftype1)).FprintProc})))(tls, (*TAuxData)(unsafe.Pointer(auxData)).FclientData, desc1, codePtr, uint64(0))
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), auxDesc, desc1)
			}
		}
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), aux, auxDesc)
		goto _28
	_28:
		;
		i++
	}
	/*
	 * Get the exception ranges from the bytecode.
	 */
	if v31 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v31 {
		cachePtr8 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v31 || (*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects == libc.Uint64FromInt32(0) {
		exn = XTclThreadAllocObj(tls)
	} else {
		exn = (*TAllocCache)(unsafe.Pointer(cachePtr8)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr8)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(exn + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(exn)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(exn)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(exn)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(exn)).FtypePtr = libc.UintptrFromInt32(0)
	i = 0
	for {
		if !(i < int64(int32((*TByteCode)(unsafe.Pointer(codePtr)).FnumExceptRanges))) {
			break
		}
		rangePtr = (*TByteCode)(unsafe.Pointer(codePtr)).FexceptArrayPtr + uintptr(i)*56
		switch (*TExceptionRange)(unsafe.Pointer(rangePtr)).Ftype1 {
		case int32(LOOP_EXCEPTION_RANGE):
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), exn, XTcl_ObjPrintf(tls, __ccgo_ts+28298, libc.VaList(bp+40, __ccgo_ts+21703, (*TExceptionRange)(unsafe.Pointer(rangePtr)).FnestingLevel, (*TExceptionRange)(unsafe.Pointer(rangePtr)).FcodeOffset, (*TExceptionRange)(unsafe.Pointer(rangePtr)).FcodeOffset+(*TExceptionRange)(unsafe.Pointer(rangePtr)).FnumCodeBytes-int64(1), (*TExceptionRange)(unsafe.Pointer(rangePtr)).FbreakOffset, (*TExceptionRange)(unsafe.Pointer(rangePtr)).FcontinueOffset)))
		case int32(CATCH_EXCEPTION_RANGE):
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), exn, XTcl_ObjPrintf(tls, __ccgo_ts+28355, libc.VaList(bp+40, __ccgo_ts+5129, (*TExceptionRange)(unsafe.Pointer(rangePtr)).FnestingLevel, (*TExceptionRange)(unsafe.Pointer(rangePtr)).FcodeOffset, (*TExceptionRange)(unsafe.Pointer(rangePtr)).FcodeOffset+(*TExceptionRange)(unsafe.Pointer(rangePtr)).FnumCodeBytes-int64(1), (*TExceptionRange)(unsafe.Pointer(rangePtr)).FcatchOffset)))
			break
		}
		goto _32
	_32:
		;
		i++
	}
	/*
	 * Get the command information from the bytecode.
	 *
	 * The way these are encoded in the bytecode is non-trivial; the Decode
	 * macro (which updates its argument and returns the next decoded value)
	 * handles this so that the rest of the code does not.
	 */
	if v33 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v33 {
		cachePtr9 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v33 || (*TAllocCache)(unsafe.Pointer(cachePtr9)).FnumObjects == libc.Uint64FromInt32(0) {
		commands = XTclThreadAllocObj(tls)
	} else {
		commands = (*TAllocCache)(unsafe.Pointer(cachePtr9)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr9)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(commands + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr9)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(commands)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(commands)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(commands)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(commands)).FtypePtr = libc.UintptrFromInt32(0)
	codeOffPtr = (*TByteCode)(unsafe.Pointer(codePtr)).FcodeDeltaStart
	codeLenPtr = (*TByteCode)(unsafe.Pointer(codePtr)).FcodeLengthStart
	srcOffPtr = (*TByteCode)(unsafe.Pointer(codePtr)).FsrcDeltaStart
	srcLenPtr = (*TByteCode)(unsafe.Pointer(codePtr)).FsrcLengthStart
	v34 = libc.Int32FromInt32(0)
	sourceOffset = v34
	codeOffset = v34
	i = 0
	for {
		if !(i < int64(int32((*TByteCode)(unsafe.Pointer(codePtr)).FnumCommands))) {
			break
		}
		if uint32(*(*uint8)(unsafe.Pointer(codeOffPtr))) == uint32(0xFF) {
			codeOffPtr += uintptr(5)
			v36 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(codeOffPtr - libc.UintptrFromInt32(4))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(codeOffPtr - libc.UintptrFromInt32(4) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(codeOffPtr - libc.UintptrFromInt32(4) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(codeOffPtr - libc.UintptrFromInt32(4) + libc.UintptrFromInt32(3)))))
		} else {
			codeOffPtr += uintptr(1)
			v36 = int32(*(*int8)(unsafe.Pointer(codeOffPtr - libc.UintptrFromInt32(1))))
		}
		codeOffset += v36
		if uint32(*(*uint8)(unsafe.Pointer(codeLenPtr))) == uint32(0xFF) {
			codeLenPtr += uintptr(5)
			v37 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(codeLenPtr - libc.UintptrFromInt32(4))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(codeLenPtr - libc.UintptrFromInt32(4) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(codeLenPtr - libc.UintptrFromInt32(4) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(codeLenPtr - libc.UintptrFromInt32(4) + libc.UintptrFromInt32(3)))))
		} else {
			codeLenPtr += uintptr(1)
			v37 = int32(*(*int8)(unsafe.Pointer(codeLenPtr - libc.UintptrFromInt32(1))))
		}
		codeLength = v37
		if uint32(*(*uint8)(unsafe.Pointer(srcOffPtr))) == uint32(0xFF) {
			srcOffPtr += uintptr(5)
			v38 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(srcOffPtr - libc.UintptrFromInt32(4))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(srcOffPtr - libc.UintptrFromInt32(4) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(srcOffPtr - libc.UintptrFromInt32(4) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(srcOffPtr - libc.UintptrFromInt32(4) + libc.UintptrFromInt32(3)))))
		} else {
			srcOffPtr += uintptr(1)
			v38 = int32(*(*int8)(unsafe.Pointer(srcOffPtr - libc.UintptrFromInt32(1))))
		}
		sourceOffset += v38
		if uint32(*(*uint8)(unsafe.Pointer(srcLenPtr))) == uint32(0xFF) {
			srcLenPtr += uintptr(5)
			v39 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(srcLenPtr - libc.UintptrFromInt32(4))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(srcLenPtr - libc.UintptrFromInt32(4) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(srcLenPtr - libc.UintptrFromInt32(4) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(srcLenPtr - libc.UintptrFromInt32(4) + libc.UintptrFromInt32(3)))))
		} else {
			srcLenPtr += uintptr(1)
			v39 = int32(*(*int8)(unsafe.Pointer(srcLenPtr - libc.UintptrFromInt32(1))))
		}
		sourceLength = v39
		if v40 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v40 {
			cachePtr10 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v40 || (*TAllocCache)(unsafe.Pointer(cachePtr10)).FnumObjects == libc.Uint64FromInt32(0) {
			cmd = XTclThreadAllocObj(tls)
		} else {
			cmd = (*TAllocCache)(unsafe.Pointer(cachePtr10)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr10)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(cmd + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr10)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(cmd)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(cmd)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(cmd)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(cmd)).FtypePtr = libc.UintptrFromInt32(0)
		XTclDictPut(tls, libc.UintptrFromInt32(0), cmd, __ccgo_ts+28399, XTcl_NewWideIntObj(tls, int64(codeOffset)))
		XTclDictPut(tls, libc.UintptrFromInt32(0), cmd, __ccgo_ts+28408, XTcl_NewWideIntObj(tls, int64(codeOffset+codeLength-int32(1))))
		/*
		 * Convert byte offsets to character offsets; important if multibyte
		 * characters are present in the source!
		 */
		XTclDictPut(tls, libc.UintptrFromInt32(0), cmd, __ccgo_ts+28415, XTcl_NewWideIntObj(tls, XTcl_NumUtfChars(tls, (*TByteCode)(unsafe.Pointer(codePtr)).Fsource, int64(sourceOffset))))
		XTclDictPut(tls, libc.UintptrFromInt32(0), cmd, __ccgo_ts+28426, XTcl_NewWideIntObj(tls, XTcl_NumUtfChars(tls, (*TByteCode)(unsafe.Pointer(codePtr)).Fsource, int64(sourceOffset+sourceLength-int32(1)))))
		XTclDictPut(tls, libc.UintptrFromInt32(0), cmd, __ccgo_ts+3702, XTcl_NewStringObj(tls, (*TByteCode)(unsafe.Pointer(codePtr)).Fsource+uintptr(sourceOffset), int64(sourceLength)))
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), commands, cmd)
		goto _35
	_35:
		;
		i++
	}
	/*
	 * Get the source file and line number information from the CmdFrame
	 * system if it is available.
	 */
	_GetLocationInformation(tls, (*TByteCode)(unsafe.Pointer(codePtr)).FprocPtr, bp, bp+8)
	/*
	 * Build the overall result.
	 */
	if v41 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v41 {
		cachePtr11 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v41 || (*TAllocCache)(unsafe.Pointer(cachePtr11)).FnumObjects == libc.Uint64FromInt32(0) {
		description = XTclThreadAllocObj(tls)
	} else {
		description = (*TAllocCache)(unsafe.Pointer(cachePtr11)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr11)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(description + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr11)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(description)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(description)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(description)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(description)).FtypePtr = libc.UintptrFromInt32(0)
	XTclDictPut(tls, libc.UintptrFromInt32(0), description, __ccgo_ts+28435, literals)
	XTclDictPut(tls, libc.UintptrFromInt32(0), description, __ccgo_ts+21627, variables)
	XTclDictPut(tls, libc.UintptrFromInt32(0), description, __ccgo_ts+28444, exn)
	XTclDictPut(tls, libc.UintptrFromInt32(0), description, __ccgo_ts+28454, instructions)
	XTclDictPut(tls, libc.UintptrFromInt32(0), description, __ccgo_ts+28467, aux)
	XTclDictPut(tls, libc.UintptrFromInt32(0), description, __ccgo_ts+16009, commands)
	XTclDictPut(tls, libc.UintptrFromInt32(0), description, __ccgo_ts+3702, XTcl_NewStringObj(tls, (*TByteCode)(unsafe.Pointer(codePtr)).Fsource, (*TByteCode)(unsafe.Pointer(codePtr)).FnumSrcBytes))
	XTclDictPut(tls, libc.UintptrFromInt32(0), description, __ccgo_ts+21846, XTclNewNamespaceObj(tls, (*TByteCode)(unsafe.Pointer(codePtr)).FnsPtr))
	XTclDictPut(tls, libc.UintptrFromInt32(0), description, __ccgo_ts+28477, XTcl_NewWideIntObj(tls, (*TByteCode)(unsafe.Pointer(codePtr)).FmaxStackDepth))
	XTclDictPut(tls, libc.UintptrFromInt32(0), description, __ccgo_ts+28488, XTcl_NewWideIntObj(tls, (*TByteCode)(unsafe.Pointer(codePtr)).FmaxExceptDepth))
	if *(*int32)(unsafe.Pointer(bp + 8)) >= 0 {
		XTclDictPut(tls, libc.UintptrFromInt32(0), description, __ccgo_ts+28500, XTcl_NewWideIntObj(tls, int64(*(*int32)(unsafe.Pointer(bp + 8)))))
	}
	if *(*uintptr)(unsafe.Pointer(bp)) != 0 {
		XTclDictPut(tls, libc.UintptrFromInt32(0), description, __ccgo_ts+28518, *(*uintptr)(unsafe.Pointer(bp)))
	}
	return description
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DisassembleObjCmd --
 *
 *	Implementation of the "::tcl::unsupported::disassemble" command. This
 *	command is not documented, but will disassemble procedures, lambda
 *	terms and general scripts. Note that will compile terms if necessary
 *	in order to disassemble them.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DisassembleObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(560)
	defer tls.Free(560) /* Argument objects. */
	var codeObjPtr, codePtr, hPtr, irPtr, methodPtr, oPtr, procPtr, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v24, v25, v26, v27, v28 uintptr
	var result int32
	var _ /* cmd at bp+144 */ TCommand
	var _ /* cmd at bp+264 */ TCommand
	var _ /* cmd at bp+384 */ TCommand
	var _ /* cmd at bp+8 */ TCommand
	var _ /* idx at bp+0 */ int32
	var _ /* nsObjPtr at bp+128 */ uintptr
	var _ /* nsPtr at bp+136 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = codeObjPtr, codePtr, hPtr, irPtr, methodPtr, oPtr, procPtr, result, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v24, v25, v26, v27, v28
	codeObjPtr = libc.UintptrFromInt32(0)
	procPtr = libc.UintptrFromInt32(0)
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+28576)
		return int32(TCL_ERROR)
	}
	if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), uintptr(unsafe.Pointer(&_types)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+5851, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	switch *(*int32)(unsafe.Pointer(bp)) {
	case 2:
		goto _1
	case 5:
		goto _2
	case 6:
		goto _3
	case 0:
		goto _4
	case 1:
		goto _5
	case 3:
		goto _6
	case 4:
		goto _7
	default:
		goto _8
	}
	goto _9
_1:
	;
	/*
	 * Compile (if uncompiled) and disassemble a lambda term.
	 */
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+28585)
		return int32(TCL_ERROR)
	}
	procPtr = XTclGetLambdaFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp+128)
	if procPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	libc.Xmemset(tls, bp+8, 0, uint64(120))
	result = XTclGetNamespaceFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 128)), bp+136)
	if result != TCL_OK {
		return result
	}
	(*(*TCommand)(unsafe.Pointer(bp + 8))).FnsPtr = *(*uintptr)(unsafe.Pointer(bp + 136))
	(*TProc)(unsafe.Pointer(procPtr)).FcmdPtr = bp + 8
	result = XTclPushProcCallFrame(tls, procPtr, interp, int64(objc), objv, int32(1))
	if result != TCL_OK {
		return result
	}
	XTclPopStackFrame(tls, interp)
	codeObjPtr = (*TProc)(unsafe.Pointer(procPtr)).FbodyPtr
	goto _9
_2:
	;
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+28596)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
		v10 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
	} else {
		v10 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
	}
	procPtr = XTclFindProc(tls, interp, v10)
	if procPtr == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v11 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v11 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+16368, libc.VaList(bp+512, v11)))
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v12 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v12 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+512, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+28605, v12, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Compile (if uncompiled) and disassemble a procedure.
	 */
	result = XTclPushProcCallFrame(tls, procPtr, interp, int64(2), objv+uintptr(1)*8, int32(1))
	if result != TCL_OK {
		return result
	}
	XTclPopStackFrame(tls, interp)
	codeObjPtr = (*TProc)(unsafe.Pointer(procPtr)).FbodyPtr
	goto _9
_3:
	;
	/*
	 * Compile and disassemble a script.
	 */
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+3702)
		return int32(TCL_ERROR)
	}
	if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclByteCodeType))) && TCL_OK != XTclSetByteCodeFromAny(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0)) {
		return int32(TCL_ERROR)
	}
	codeObjPtr = *(*uintptr)(unsafe.Pointer(objv + 2*8))
	goto _9
_4:
	;
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+28610)
		return int32(TCL_ERROR)
	}
	/*
	 * Look up the body of a constructor.
	 */
	oPtr = XTcl_GetObjectFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if (*TObject)(unsafe.Pointer(oPtr)).FclassPtr == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v13 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v13 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+28620, libc.VaList(bp+512, v13)))
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v14 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v14 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+512, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+28640, v14, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	methodPtr = (*TClass)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FclassPtr)).FconstructorPtr
	if methodPtr == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v15 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v15 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+28646, libc.VaList(bp+512, v15)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+512, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+28678, __ccgo_ts+28690, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	procPtr = XTclOOGetProcFromMethod(tls, methodPtr)
	if procPtr == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+28701, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+512, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+28678, __ccgo_ts+28749, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Compile if necessary.
	 */
	if !((*TTcl_Obj)(unsafe.Pointer((*TProc)(unsafe.Pointer(procPtr)).FbodyPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclByteCodeType))) {
		/*
		 * Yes, this is ugly, but we need to pass the namespace in to the
		 * compiler in two places.
		 */
		(*(*TCommand)(unsafe.Pointer(bp + 144))).FnsPtr = (*TObject)(unsafe.Pointer(oPtr)).FnamespacePtr
		(*TProc)(unsafe.Pointer(procPtr)).FcmdPtr = bp + 144
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v16 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v16 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		result = XTclProcCompileProc(tls, interp, procPtr, (*TProc)(unsafe.Pointer(procPtr)).FbodyPtr, (*TObject)(unsafe.Pointer(oPtr)).FnamespacePtr, __ccgo_ts+28760, v16)
		(*TProc)(unsafe.Pointer(procPtr)).FcmdPtr = libc.UintptrFromInt32(0)
		if result != TCL_OK {
			return result
		}
	}
	codeObjPtr = (*TProc)(unsafe.Pointer(procPtr)).FbodyPtr
	goto _9
_5:
	;
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+28610)
		return int32(TCL_ERROR)
	}
	/*
	 * Look up the body of a destructor.
	 */
	oPtr = XTcl_GetObjectFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if (*TObject)(unsafe.Pointer(oPtr)).FclassPtr == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v17 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v17 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+28620, libc.VaList(bp+512, v17)))
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v18 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v18 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+512, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+28640, v18, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	methodPtr = (*TClass)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FclassPtr)).FdestructorPtr
	if methodPtr == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v19 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v19 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+28780, libc.VaList(bp+512, v19)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+512, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+28678, __ccgo_ts+28811, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	procPtr = XTclOOGetProcFromMethod(tls, methodPtr)
	if procPtr == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+28821, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+512, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+28678, __ccgo_ts+28749, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Compile if necessary.
	 */
	if !((*TTcl_Obj)(unsafe.Pointer((*TProc)(unsafe.Pointer(procPtr)).FbodyPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclByteCodeType))) {
		/*
		 * Yes, this is ugly, but we need to pass the namespace in to the
		 * compiler in two places.
		 */
		(*(*TCommand)(unsafe.Pointer(bp + 264))).FnsPtr = (*TObject)(unsafe.Pointer(oPtr)).FnamespacePtr
		(*TProc)(unsafe.Pointer(procPtr)).FcmdPtr = bp + 264
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v20 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v20 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		result = XTclProcCompileProc(tls, interp, procPtr, (*TProc)(unsafe.Pointer(procPtr)).FbodyPtr, (*TObject)(unsafe.Pointer(oPtr)).FnamespacePtr, __ccgo_ts+28868, v20)
		(*TProc)(unsafe.Pointer(procPtr)).FcmdPtr = libc.UintptrFromInt32(0)
		if result != TCL_OK {
			return result
		}
	}
	codeObjPtr = (*TProc)(unsafe.Pointer(procPtr)).FbodyPtr
	goto _9
_6:
	;
	if objc != int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+28887)
		return int32(TCL_ERROR)
	}
	/*
	 * Look up the body of a class method.
	 */
	oPtr = XTcl_GetObjectFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if (*TObject)(unsafe.Pointer(oPtr)).FclassPtr == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v21 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v21 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+28620, libc.VaList(bp+512, v21)))
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v22 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v22 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+512, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+28640, v22, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FclassPtr + 136)).FfindProc})))(tls, (*TObject)(unsafe.Pointer(oPtr)).FclassPtr+136, *(*uintptr)(unsafe.Pointer(objv + 3*8)))
	goto methodBody
_7:
	;
	if objc != int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+28908)
		return int32(TCL_ERROR)
	}
	/*
	 * Look up the body of an instance method.
	 */
	oPtr = XTcl_GetObjectFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr == libc.UintptrFromInt32(0) {
		goto unknownMethod
	}
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr)).FfindProc})))(tls, (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr, *(*uintptr)(unsafe.Pointer(objv + 3*8)))
	/*
	 * Compile (if necessary) and disassemble a method body.
	 */
	goto methodBody
methodBody:
	;
	if !(hPtr == libc.UintptrFromInt32(0)) {
		goto _23
	}
	goto unknownMethod
unknownMethod:
	;
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes != 0 {
		v24 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes
	} else {
		v24 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0))
	}
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+28930, libc.VaList(bp+512, v24)))
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes != 0 {
		v25 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes
	} else {
		v25 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0))
	}
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+512, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+28950, v25, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
_23:
	;
	procPtr = XTclOOGetProcFromMethod(tls, (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData)
	if procPtr == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+28957, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+512, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+28678, __ccgo_ts+28749, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if !((*TTcl_Obj)(unsafe.Pointer((*TProc)(unsafe.Pointer(procPtr)).FbodyPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclByteCodeType))) {
		/*
		 * Yes, this is ugly, but we need to pass the namespace in to the
		 * compiler in two places.
		 */
		(*(*TCommand)(unsafe.Pointer(bp + 384))).FnsPtr = (*TObject)(unsafe.Pointer(oPtr)).FnamespacePtr
		(*TProc)(unsafe.Pointer(procPtr)).FcmdPtr = bp + 384
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes != 0 {
			v26 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes
		} else {
			v26 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0))
		}
		result = XTclProcCompileProc(tls, interp, procPtr, (*TProc)(unsafe.Pointer(procPtr)).FbodyPtr, (*TObject)(unsafe.Pointer(oPtr)).FnamespacePtr, __ccgo_ts+29000, v26)
		(*TProc)(unsafe.Pointer(procPtr)).FcmdPtr = libc.UintptrFromInt32(0)
		if result != TCL_OK {
			return result
		}
	}
	codeObjPtr = (*TProc)(unsafe.Pointer(procPtr)).FbodyPtr
	goto _9
_8:
	;
_9:
	;
	/*
	 * Do the actual disassembly.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(codeObjPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclByteCodeType)) {
		v27 = codeObjPtr + 32
	} else {
		v27 = libc.UintptrFromInt32(0)
	}
	irPtr = v27
	if irPtr != 0 {
		v28 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v28 = libc.UintptrFromInt32(0)
	}
	codePtr = v28
	if (*TByteCode)(unsafe.Pointer(codePtr)).Fflags&uint32(TCL_BYTECODE_PRECOMPILED) != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+29015, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+512, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+28678, __ccgo_ts+29053, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if clientData != 0 {
		XTcl_SetObjResult(tls, interp, _DisassembleByteCodeAsDicts(tls, codeObjPtr))
	} else {
		XTcl_SetObjResult(tls, interp, _DisassembleByteCodeObj(tls, codeObjPtr))
	}
	return TCL_OK
}

var _types = [8]uintptr{
	0: __ccgo_ts + 28529,
	1: __ccgo_ts + 28541,
	2: __ccgo_ts + 28552,
	3: __ccgo_ts + 28559,
	4: __ccgo_ts + 28566,
	5: __ccgo_ts + 5352,
	6: __ccgo_ts + 3702,
	7: libc.UintptrFromInt32(0),
}

const PAGE_SIZE1 = 0
const UNICODE_REPLACE_CHAR = 65533

/*
 * The following data structure represents an encoding, which describes how to
 * convert between various character sets and UTF-8.
 */

type TEncoding = struct {
	Fname        uintptr
	FtoUtfProc   uintptr
	FfromUtfProc uintptr
	FfreeProc    uintptr
	FclientData  uintptr
	FnullSize    TTcl_Size
	FlengthProc  uintptr
	FrefCount    Tsize_t
	FhPtr        uintptr
}

/*
 * The following structure is the clientData for a dynamically-loaded,
 * table-driven encoding created by LoadTableEncoding(). It maps between
 * Unicode and a single-byte, double-byte, or multibyte (1 or 2 bytes only)
 * encoding.
 */

type TTableEncodingData = struct {
	Ffallback    int32
	FprefixBytes [256]uint8
	FtoUnicode   uintptr
	FfromUnicode uintptr
}

/*
 * Each of the following structures is the clientData for a dynamically-loaded
 * escape-driven encoding that is itself comprised of other simpler encodings.
 * An example is "iso-2022-jp", which uses escape sequences to switch between
 * ascii, jis0208, jis0212, gb2312, and ksc5601. Note that "escape-driven"
 * does not necessarily mean that the ESCAPE character is the character used
 * for switching character sets.
 */

type TEscapeSubTable = struct {
	FsequenceLen uint32
	Fsequence    [16]uint8
	Fname        [32]uint8
	FencodingPtr uintptr
}

type TEscapeEncodingData = struct {
	F__ccgo_align [0]uint64
	Ffallback     int32
	FinitLen      uint32
	Finit1        [16]uint8
	FfinalLen     uint32
	Ffinal        [16]uint8
	FprefixBytes  [256]uint8
	FnumSubTables int32
}

/*
 * Values used when loading an encoding file to identify the type of the
 * file.
 */
type EncodingTypes = int32

const ENCODING_SINGLEBYTE = 0
const /* Encoding is single byte per character. */
ENCODING_DOUBLEBYTE = 1
const /* Encoding is two bytes per character. */
ENCODING_MULTIBYTE = 2
const /* Encoding is variable bytes per character. */
ENCODING_ESCAPE = 3

var _encodingSearchPath = TProcessGlobalValue{}

func init() {
	p := unsafe.Pointer(&_encodingSearchPath)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_InitializeEncodingSearchPath)
}

/*
 * A map from encoding names to the directories in which their data files have
 * been seen. The string value of the map is shared by all threads. Access to
 * the shared string is governed by a mutex lock.
 */

var _encodingFileMap = TProcessGlobalValue{}

/*
 * A list of directories making up the "library path". Historically this
 * search path has served many uses, but the only one remaining is a base for
 * the encodingSearchPath above. If the application does not explicitly set
 * the encodingSearchPath, then it is initialized by appending /encoding
 * to each directory in this "libraryPath".
 */

var _libraryPath = TProcessGlobalValue{}

func init() {
	p := unsafe.Pointer(&_libraryPath)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(XTclpInitLibraryPath)
}

var _encodingsInitialized = int32(0)

/*
 * Hash table that keeps track of all loaded Encodings. Keys are the string
 * names that represent the encoding, values are (Encoding *).
 */

var _encodingTable TTcl_HashTable

var _encodingMutex TTcl_Mutex

/*
 * The following are used to hold the default and current system encodings.
 * If NULL is passed to one of the conversion routines, the current setting of
 * the system encoding is used to perform the conversion.
 */

var _defaultEncoding = libc.UintptrFromInt32(0)
var _systemEncoding = libc.UintptrFromInt32(0)

// C documentation
//
//	/*
//	 * Names of encoding profiles and corresponding integer values.
//	 * Keep alphabetical order for error messages.
//	 */
type TTclEncodingProfiles = struct {
	Fname  uintptr
	Fvalue int32
}

// C documentation
//
//	/*
//	 * Names of encoding profiles and corresponding integer values.
//	 * Keep alphabetical order for error messages.
//	 */
var _encodingProfiles = [3]TTclEncodingProfiles{
	0: {
		Fname:  __ccgo_ts + 19738,
		Fvalue: int32(TCL_ENCODING_PROFILE_REPLACE),
	},
	1: {
		Fname: __ccgo_ts + 29062,
	},
	2: {
		Fname:  __ccgo_ts + 29069,
		Fvalue: int32(TCL_ENCODING_PROFILE_TCL8),
	},
}

/*
 * The following variable is used in the sparse matrix code for a
 * TableEncoding to represent a page in the table that has no entries.
 */

var _emptyPage [256]uint16

/*
 * A Tcl_ObjType for holding a cached Tcl_Encoding in the twoPtrValue.ptr1
 * field of the internalrep. This should help the lifetime of encodings be more
 * useful. See concerns raised in [Bug 1077262].
 */

var _encodingType = TTcl_ObjType{
	Fname: __ccgo_ts + 5615,
}

func init() {
	p := unsafe.Pointer(&_encodingType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_FreeEncodingInternalRep)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_DupEncodingInternalRep)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetEncodingFromObj --
 *
 *	Writes to (*encodingPtr) the Tcl_Encoding value of (*objPtr), if
 *	possible, and returns TCL_OK. If no such encoding exists, TCL_ERROR is
 *	returned, and if interp is non-NULL, an error message is written
 *	there.
 *
 * Results:
 *	Standard Tcl return code.
 *
 * Side effects:
 *	Caches the Tcl_Encoding value as the internal rep of (*objPtr).
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetEncodingFromObj(tls *libc.TLS, interp uintptr, objPtr uintptr, encodingPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var encoding, v3 TTcl_Encoding
	var irPtr, name, v1, v2 uintptr
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_, _, _, _, _, _ = encoding, irPtr, name, v1, v2, v3
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
	}
	name = v1
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_encodingType)) {
		v2 = objPtr + 32
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	irPtr = v2
	if irPtr != 0 {
		v3 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v3 = libc.UintptrFromInt32(0)
	}
	encoding = v3
	if encoding == libc.UintptrFromInt32(0) {
		encoding = XTcl_GetEncoding(tls, interp, name)
		if encoding == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(bp))).Fptr1 = encoding
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(bp))).Fptr2 = libc.UintptrFromInt32(0)
		XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&_encodingType)), bp)
	}
	*(*TTcl_Encoding)(unsafe.Pointer(encodingPtr)) = XTcl_GetEncoding(tls, libc.UintptrFromInt32(0), name)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * FreeEncodingInternalRep --
 *
 *	The Tcl_FreeInternalRepProc for the "encoding" Tcl_ObjType.
 *
 *----------------------------------------------------------------------
 */

func _FreeEncodingInternalRep(tls *libc.TLS, objPtr uintptr) {
	var encoding, v2 TTcl_Encoding
	var irPtr, v1 uintptr
	_, _, _, _ = encoding, irPtr, v1, v2
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_encodingType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	encoding = v2
	XTcl_FreeEncoding(tls, encoding)
}

/*
 *----------------------------------------------------------------------
 *
 * DupEncodingInternalRep --
 *
 *	The Tcl_DupInternalRepProc for the "encoding" Tcl_ObjType.
 *
 *----------------------------------------------------------------------
 */

func _DupEncodingInternalRep(tls *libc.TLS, srcPtr uintptr, dupPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var encoding TTcl_Encoding
	var v1 uintptr
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_, _ = encoding, v1
	if (*TTcl_Obj)(unsafe.Pointer(srcPtr)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(srcPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, srcPtr, libc.UintptrFromInt32(0))
	}
	encoding = XTcl_GetEncoding(tls, libc.UintptrFromInt32(0), v1)
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr1 = encoding
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr2 = libc.UintptrFromInt32(0)
	XTcl_StoreInternalRep(tls, dupPtr, uintptr(unsafe.Pointer(&_encodingType)), bp)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetEncodingSearchPath --
 *
 *	Keeps the per-thread copy of the encoding search path current with
 *	changes to the global copy.
 *
 * Results:
 *	Returns a "list" (Tcl_Obj *) that contains the encoding search path.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetEncodingSearchPath(tls *libc.TLS) (r uintptr) {
	return XTclGetProcessGlobalValue(tls, uintptr(unsafe.Pointer(&_encodingSearchPath)))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetEncodingSearchPath --
 *
 *	Keeps the per-thread copy of the encoding search path current with
 *	changes to the global copy.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetEncodingSearchPath(tls *libc.TLS, searchPath uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var v1 int32
	var v2 int64
	var _ /* dummy at bp+0 */ TTcl_Size
	_, _ = v1, v2
	if (*TTcl_Obj)(unsafe.Pointer(searchPath)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(searchPath + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(searchPath + 32))).Fptr2)).FspanLength
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(searchPath + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v2
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), searchPath, bp)
	}
	if int32(TCL_ERROR) == v1 {
		return int32(TCL_ERROR)
	}
	XTclSetProcessGlobalValue(tls, uintptr(unsafe.Pointer(&_encodingSearchPath)), searchPath)
	return TCL_OK
}

/*
 *---------------------------------------------------------------------------
 *
 * FillEncodingFileMap --
 *
 *	Called to update the encoding file map with the current value
 *	of the encoding search path.
 *
 *	Finds *.end files in the directories on the encoding search path and
 *	stores the found pathnames in a map associated with the encoding name.
 *
 *	If $dir is on the encoding search path and the file $dir/foo.enc is
 *	found, stores a "foo" -> $dir entry in the map.  if the "foo" encoding
 *	is needed later, the $dir/foo.enc name can be quickly constructed in
 *	order to read the encoding data.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Entries are added to the encoding file map.
 *
 *---------------------------------------------------------------------------
 */

func _FillEncodingFileMap(tls *libc.TLS) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, cachePtr, encoding, fileObj, map1, matchFileList, searchPath, v10, v12, v14, v16, v18, v20 uintptr
	var i, j, v11, v13, v15, v17, v19, v9 TTcl_Size
	var v2, v6, v7 int64
	var v4 bool
	var _ /* directory at bp+16 */ uintptr
	var _ /* filev at bp+24 */ uintptr
	var _ /* numDirs at bp+0 */ TTcl_Size
	var _ /* numFiles at bp+8 */ TTcl_Size
	var _ /* readableFiles at bp+32 */ TTcl_GlobTypeData
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, cachePtr, encoding, fileObj, i, j, map1, matchFileList, searchPath, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v4, v6, v7, v9
	*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	searchPath = XTcl_GetEncodingSearchPath(tls)
	(*TTcl_Obj)(unsafe.Pointer(searchPath)).FrefCount++
	if (*TTcl_Obj)(unsafe.Pointer(searchPath)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(searchPath + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(searchPath + 32))).Fptr2)).FspanLength
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(searchPath + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v2
		_ = libc.Int32FromInt32(TCL_OK)
	} else {
		XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), searchPath, bp)
	}
	map1 = XTcl_NewDictObj(tls)
	(*TTcl_Obj)(unsafe.Pointer(map1)).FrefCount++
	i = *(*TTcl_Size)(unsafe.Pointer(bp)) - int64(1)
	for {
		if !(i != int64(-libc.Int32FromInt32(1))) {
			break
		}
		*(*TTcl_GlobTypeData)(unsafe.Pointer(bp + 32)) = TTcl_GlobTypeData{
			Ftype1: libc.Int32FromInt32(1) << libc.Int32FromInt32(4),
			Fperm:  libc.Int32FromInt32(1) << libc.Int32FromInt32(2),
		}
		if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			matchFileList = XTclThreadAllocObj(tls)
		} else {
			matchFileList = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(matchFileList + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(matchFileList)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(matchFileList)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(matchFileList)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(matchFileList)).FtypePtr = libc.UintptrFromInt32(0)
		XTcl_ListObjIndex(tls, libc.UintptrFromInt32(0), searchPath, i, bp+16)
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount++
		(*TTcl_Obj)(unsafe.Pointer(matchFileList)).FrefCount++
		XTcl_FSMatchInDirectory(tls, libc.UintptrFromInt32(0), matchFileList, *(*uintptr)(unsafe.Pointer(bp + 16)), __ccgo_ts+29074, bp+32)
		if (*TTcl_Obj)(unsafe.Pointer(matchFileList)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(matchFileList + 32))).Fptr2 != 0 {
				v6 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(matchFileList + 32))).Fptr2)).FspanStart
			} else {
				v6 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(matchFileList + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 24)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(matchFileList + 32))).Fptr1 + 40 + uintptr(v6)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(matchFileList + 32))).Fptr2 != 0 {
				v7 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(matchFileList + 32))).Fptr2)).FspanLength
			} else {
				v7 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(matchFileList + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v7
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), matchFileList, bp+8, bp+24)
		}
		j = 0
		for {
			if !(j < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) {
				break
			}
			fileObj = XTclPathPart(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + uintptr(j)*8)), int32(TCL_PATH_TAIL))
			encoding = XTclPathPart(tls, libc.UintptrFromInt32(0), fileObj, int32(TCL_PATH_ROOT))
			XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), map1, encoding, *(*uintptr)(unsafe.Pointer(bp + 16)))
			_objPtr = fileObj
			v10 = _objPtr
			v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
			*(*TTcl_Size)(unsafe.Pointer(v10))--
			if v9 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			_objPtr1 = encoding
			v12 = _objPtr1
			v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
			*(*TTcl_Size)(unsafe.Pointer(v12))--
			if v11 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
			goto _8
		_8:
			;
			j++
		}
		_objPtr2 = matchFileList
		v14 = _objPtr2
		v13 = *(*TTcl_Size)(unsafe.Pointer(v14))
		*(*TTcl_Size)(unsafe.Pointer(v14))--
		if v13 <= int64(1) {
			XTclFreeObj(tls, _objPtr2)
		}
		_objPtr3 = *(*uintptr)(unsafe.Pointer(bp + 16))
		v16 = _objPtr3
		v15 = *(*TTcl_Size)(unsafe.Pointer(v16))
		*(*TTcl_Size)(unsafe.Pointer(v16))--
		if v15 <= int64(1) {
			XTclFreeObj(tls, _objPtr3)
		}
		goto _3
	_3:
		;
		i--
	}
	_objPtr4 = searchPath
	v18 = _objPtr4
	v17 = *(*TTcl_Size)(unsafe.Pointer(v18))
	*(*TTcl_Size)(unsafe.Pointer(v18))--
	if v17 <= int64(1) {
		XTclFreeObj(tls, _objPtr4)
	}
	XTclSetProcessGlobalValue(tls, uintptr(unsafe.Pointer(&_encodingFileMap)), map1)
	_objPtr5 = map1
	v20 = _objPtr5
	v19 = *(*TTcl_Size)(unsafe.Pointer(v20))
	*(*TTcl_Size)(unsafe.Pointer(v20))--
	if v19 <= int64(1) {
		XTclFreeObj(tls, _objPtr5)
	}
}

/*
 *---------------------------------------------------------------------------
 *
 * TclInitEncodingSubsystem --
 *
 *	Initialize all resources used by this subsystem on a per-process
 *	basis.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Depends on the memory, object, and IO subsystems.
 *
 *---------------------------------------------------------------------------
 */

/*
 * NOTE: THESE BIT DEFINITIONS SHOULD NOT OVERLAP WITH INTERNAL USE BITS
 * DEFINED IN tcl.h (TCL_ENCODING_* et al). Be cognizant of this
 * when adding bits. TODO - should really be defined in a single file.
 *
 * To prevent conflicting bits, only define bits within 0xff00 mask here.
 */
type InternalEncodingFlags = int32

const TCL_ENCODING_LE = 256
const /* Used to distinguish LE/BE variants */
ENCODING_UTF = 512
const /* For UTF-8 encoding, allow 4-byte output
 * sequences */
ENCODING_INPUT = 1024

func XTclInitEncodingSubsystem(tls *libc.TLS) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var dataPtr uintptr
	var i uint16
	var leFlags, v1 int32
	var size uint32
	var _ /* isLe at bp+48 */ struct {
		Fs           [0]int16
		Fc           uint8
		F__ccgo_pad2 [1]byte
	}
	var _ /* type at bp+0 */ TTcl_EncodingType
	_, _, _, _, _ = dataPtr, i, leFlags, size, v1
	if _encodingsInitialized != 0 {
		return
	}
	/* Note: This DEPENDS on TCL_ENCODING_LE being defined in least sig byte */
	*(*int16)(unsafe.Pointer(bp + 48)) = int16(1)
	if (*(*struct {
		Fs           [0]int16
		Fc           uint8
		F__ccgo_pad2 [1]byte
	})(unsafe.Pointer(bp + 48))).Fc != 0 {
		v1 = int32(TCL_ENCODING_LE)
	} else {
		v1 = 0
	}
	leFlags = v1
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_encodingMutex)))
	XTcl_InitHashTable(tls, uintptr(unsafe.Pointer(&_encodingTable)), TCL_STRING_KEYS)
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_encodingMutex)))
	/*
	 * Create a few initial encodings.  UTF-8 to UTF-8 translation is not a
	 * no-op because it turns a stream of improperly formed UTF-8 into a
	 * properly formed stream.
	 */
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FencodingName = libc.UintptrFromInt32(0)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FtoUtfProc = __ccgo_fp(_BinaryProc)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FfromUtfProc = __ccgo_fp(_BinaryProc)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FfreeProc = libc.UintptrFromInt32(0)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FnullSize = int64(1)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FclientData = libc.UintptrFromInt32(0)
	XtclIdentityEncoding = XTcl_CreateEncoding(tls, bp)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FencodingName = __ccgo_ts + 29080
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FtoUtfProc = __ccgo_fp(_UtfToUtfProc)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FfromUtfProc = __ccgo_fp(_UtfToUtfProc)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FfreeProc = libc.UintptrFromInt32(0)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FnullSize = int64(1)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FclientData = uintptr(int64(int32(ENCODING_UTF)))
	XtclUtf8Encoding = XTcl_CreateEncoding(tls, bp)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FclientData = libc.UintptrFromInt32(0)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FencodingName = __ccgo_ts + 29086
	XTcl_CreateEncoding(tls, bp)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FtoUtfProc = __ccgo_fp(_Utf16ToUtfProc)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FfromUtfProc = __ccgo_fp(_UtfToUcs2Proc)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FfreeProc = libc.UintptrFromInt32(0)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FnullSize = int64(2)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FencodingName = __ccgo_ts + 29093
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FclientData = uintptr(int64(int32(TCL_ENCODING_LE)))
	XTcl_CreateEncoding(tls, bp)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FencodingName = __ccgo_ts + 29101
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FclientData = libc.UintptrFromInt32(0)
	XTcl_CreateEncoding(tls, bp)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FencodingName = __ccgo_ts + 29109
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FclientData = uintptr(int64(leFlags))
	XTcl_CreateEncoding(tls, bp)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FtoUtfProc = __ccgo_fp(_Utf32ToUtfProc)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FfromUtfProc = __ccgo_fp(_UtfToUtf32Proc)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FfreeProc = libc.UintptrFromInt32(0)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FnullSize = int64(4)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FencodingName = __ccgo_ts + 29115
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FclientData = uintptr(int64(int32(TCL_ENCODING_LE)))
	XTcl_CreateEncoding(tls, bp)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FencodingName = __ccgo_ts + 29124
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FclientData = libc.UintptrFromInt32(0)
	XTcl_CreateEncoding(tls, bp)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FencodingName = __ccgo_ts + 29133
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FclientData = uintptr(int64(leFlags))
	XTcl_CreateEncoding(tls, bp)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FtoUtfProc = __ccgo_fp(_Utf16ToUtfProc)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FfromUtfProc = __ccgo_fp(_UtfToUtf16Proc)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FfreeProc = libc.UintptrFromInt32(0)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FnullSize = int64(2)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FencodingName = __ccgo_ts + 29140
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FclientData = uintptr(int64(int32(TCL_ENCODING_LE)))
	XTcl_CreateEncoding(tls, bp)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FencodingName = __ccgo_ts + 29149
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FclientData = libc.UintptrFromInt32(0)
	XTcl_CreateEncoding(tls, bp)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FencodingName = __ccgo_ts + 29158
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FclientData = uintptr(int64(leFlags))
	XTcl_CreateEncoding(tls, bp)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FencodingName = __ccgo_ts + 29165
	XTcl_CreateEncoding(tls, bp)
	/*
	 * Need the iso8859-1 encoding in order to process binary data, so force
	 * it to always be embedded. Note that this encoding *must* be a proper
	 * table encoding or some of the escape encodings crash! Hence the ugly
	 * code to duplicate the structure of a table encoding here.
	 */
	dataPtr = XTcl_Alloc(tls, uint64(280))
	libc.Xmemset(tls, dataPtr, 0, uint64(280))
	(*TTableEncodingData)(unsafe.Pointer(dataPtr)).Ffallback = int32('?')
	size = uint32(libc.Uint64FromInt32(256) * (libc.Uint64FromInt64(8) + libc.Uint64FromInt64(2)))
	(*TTableEncodingData)(unsafe.Pointer(dataPtr)).FtoUnicode = XTcl_Alloc(tls, uint64(size))
	libc.Xmemset(tls, (*TTableEncodingData)(unsafe.Pointer(dataPtr)).FtoUnicode, 0, uint64(size))
	(*TTableEncodingData)(unsafe.Pointer(dataPtr)).FfromUnicode = XTcl_Alloc(tls, uint64(size))
	libc.Xmemset(tls, (*TTableEncodingData)(unsafe.Pointer(dataPtr)).FfromUnicode, 0, uint64(size))
	*(*uintptr)(unsafe.Pointer((*TTableEncodingData)(unsafe.Pointer(dataPtr)).FtoUnicode)) = (*TTableEncodingData)(unsafe.Pointer(dataPtr)).FtoUnicode + libc.UintptrFromInt32(256)*8
	*(*uintptr)(unsafe.Pointer((*TTableEncodingData)(unsafe.Pointer(dataPtr)).FfromUnicode)) = (*TTableEncodingData)(unsafe.Pointer(dataPtr)).FfromUnicode + libc.UintptrFromInt32(256)*8
	i = uint16(1)
	for {
		if !(libc.Int32FromUint16(i) < int32(256)) {
			break
		}
		*(*uintptr)(unsafe.Pointer((*TTableEncodingData)(unsafe.Pointer(dataPtr)).FtoUnicode + uintptr(i)*8)) = uintptr(unsafe.Pointer(&_emptyPage))
		*(*uintptr)(unsafe.Pointer((*TTableEncodingData)(unsafe.Pointer(dataPtr)).FfromUnicode + uintptr(i)*8)) = uintptr(unsafe.Pointer(&_emptyPage))
		goto _2
	_2:
		;
		i++
	}
	i = uint16(0)
	for {
		if !(libc.Int32FromUint16(i) < int32(256)) {
			break
		}
		*(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TTableEncodingData)(unsafe.Pointer(dataPtr)).FtoUnicode)) + uintptr(i)*2)) = i
		*(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TTableEncodingData)(unsafe.Pointer(dataPtr)).FfromUnicode)) + uintptr(i)*2)) = i
		goto _3
	_3:
		;
		i++
	}
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FencodingName = __ccgo_ts + 29173
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FtoUtfProc = __ccgo_fp(_Iso88591ToUtfProc)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FfromUtfProc = __ccgo_fp(_Iso88591FromUtfProc)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FfreeProc = __ccgo_fp(_TableFreeProc)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FnullSize = int64(1)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FclientData = dataPtr
	_defaultEncoding = XTcl_CreateEncoding(tls, bp)
	_systemEncoding = XTcl_GetEncoding(tls, libc.UintptrFromInt32(0), (*(*TTcl_EncodingType)(unsafe.Pointer(bp))).FencodingName)
	_encodingsInitialized = int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * TclFinalizeEncodingSubsystem --
 *
 *	Release the state associated with the encoding subsystem.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Frees all of the encodings.
 *
 *----------------------------------------------------------------------
 */

func XTclFinalizeEncodingSubsystem(tls *libc.TLS) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var hPtr uintptr
	var _ /* search at bp+0 */ TTcl_HashSearch
	_ = hPtr
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_encodingMutex)))
	_encodingsInitialized = 0
	_FreeEncoding(tls, _systemEncoding)
	_systemEncoding = libc.UintptrFromInt32(0)
	_defaultEncoding = libc.UintptrFromInt32(0)
	_FreeEncoding(tls, XtclIdentityEncoding)
	XtclIdentityEncoding = libc.UintptrFromInt32(0)
	_FreeEncoding(tls, XtclUtf8Encoding)
	XtclUtf8Encoding = libc.UintptrFromInt32(0)
	hPtr = XTcl_FirstHashEntry(tls, uintptr(unsafe.Pointer(&_encodingTable)), bp)
	for hPtr != libc.UintptrFromInt32(0) {
		/*
		 * Call FreeEncoding instead of doing it directly to handle refcounts
		 * like escape encodings use. [Bug 524674] Make sure to call
		 * Tcl_FirstHashEntry repeatedly so that all encodings are eventually
		 * cleaned up.
		 */
		_FreeEncoding(tls, (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData)
		hPtr = XTcl_FirstHashEntry(tls, uintptr(unsafe.Pointer(&_encodingTable)), bp)
	}
	XTcl_DeleteHashTable(tls, uintptr(unsafe.Pointer(&_encodingTable)))
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_encodingMutex)))
}

/*
 *-------------------------------------------------------------------------
 *
 * Tcl_GetEncoding --
 *
 *	Given the name of a encoding, find the corresponding Tcl_Encoding
 *	token. If the encoding did not already exist, Tcl attempts to
 *	dynamically load an encoding by that name.
 *
 * Results:
 *	Returns a token that represents the encoding. If the name didn't refer
 *	to any known or loadable encoding, NULL is returned. If NULL was
 *	returned, an error message is left in interp's result object, unless
 *	interp was NULL.
 *
 * Side effects:
 *	LoadEncodingFile is called if necessary.
 *
 *-------------------------------------------------------------------------
 */

func XTcl_GetEncoding(tls *libc.TLS, interp uintptr, name uintptr) (r TTcl_Encoding) {
	/* The name of the desired encoding. */
	var encodingPtr, hPtr uintptr
	_, _ = encodingPtr, hPtr
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_encodingMutex)))
	if name == libc.UintptrFromInt32(0) {
		encodingPtr = _systemEncoding
		(*TEncoding)(unsafe.Pointer(encodingPtr)).FrefCount++
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_encodingMutex)))
		return _systemEncoding
	}
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_encodingTable)))).FfindProc})))(tls, uintptr(unsafe.Pointer(&_encodingTable)), name)
	if hPtr != libc.UintptrFromInt32(0) {
		encodingPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		(*TEncoding)(unsafe.Pointer(encodingPtr)).FrefCount++
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_encodingMutex)))
		return encodingPtr
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_encodingMutex)))
	return _LoadEncodingFile(tls, interp, name)
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_FreeEncoding --
 *
 *	Releases an encoding allocated by Tcl_CreateEncoding() or
 *	Tcl_GetEncoding().
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The reference count associated with the encoding is decremented and
 *	the encoding is deleted if nothing is using it anymore.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_FreeEncoding(tls *libc.TLS, encoding TTcl_Encoding) {
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_encodingMutex)))
	_FreeEncoding(tls, encoding)
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_encodingMutex)))
}

/*
 *----------------------------------------------------------------------
 *
 * FreeEncoding --
 *
 *	Decrements the reference count of an encoding.  The caller must hold
 *	encodingMutes.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Releases the resource for an encoding if it is now unused.
 *	The reference count associated with the encoding is decremented and
 *	the encoding may be deleted if nothing is using it anymore.
 *
 *----------------------------------------------------------------------
 */

func _FreeEncoding(tls *libc.TLS, encoding TTcl_Encoding) {
	var encodingPtr, v2 uintptr
	var v1 Tsize_t
	_, _, _ = encodingPtr, v1, v2
	encodingPtr = encoding
	if encodingPtr == libc.UintptrFromInt32(0) {
		return
	}
	v2 = encodingPtr + 56
	v1 = *(*Tsize_t)(unsafe.Pointer(v2))
	*(*Tsize_t)(unsafe.Pointer(v2))--
	if v1 <= uint64(1) {
		if (*TEncoding)(unsafe.Pointer(encodingPtr)).FfreeProc != libc.UintptrFromInt32(0) {
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TEncoding)(unsafe.Pointer(encodingPtr)).FfreeProc})))(tls, (*TEncoding)(unsafe.Pointer(encodingPtr)).FclientData)
		}
		if (*TEncoding)(unsafe.Pointer(encodingPtr)).FhPtr != libc.UintptrFromInt32(0) {
			XTcl_DeleteHashEntry(tls, (*TEncoding)(unsafe.Pointer(encodingPtr)).FhPtr)
		}
		if (*TEncoding)(unsafe.Pointer(encodingPtr)).Fname != 0 {
			XTclpFree(tls, (*TEncoding)(unsafe.Pointer(encodingPtr)).Fname)
		}
		XTclpFree(tls, encodingPtr)
	}
}

/*
 *-------------------------------------------------------------------------
 *
 * Tcl_GetEncodingName --
 *
 *	Given an encoding, return the name that was used to construct the
 *	encoding.
 *
 * Results:
 *	The name of the encoding.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_GetEncodingName(tls *libc.TLS, encoding TTcl_Encoding) (r uintptr) {
	/* The encoding whose name to fetch. */
	if encoding == libc.UintptrFromInt32(0) {
		encoding = _systemEncoding
	}
	return (*TEncoding)(unsafe.Pointer(encoding)).Fname
}

/*
 *-------------------------------------------------------------------------
 *
 * Tcl_GetEncodingNames --
 *
 *	Get the list of all known encodings, including the ones stored as
 *	files on disk in the encoding path.
 *
 * Results:
 *	Modifies interp's result object to hold a list of all the available
 *	encodings.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func XTcl_GetEncodingNames(tls *libc.TLS, interp uintptr) {
	bp := tls.Alloc(176)
	defer tls.Free(176) /* Interp to hold result. */
	var cachePtr, encodingPtr, hPtr, map1, result, v5 uintptr
	var v1 bool
	var _ /* done at bp+164 */ int32
	var _ /* dummy at bp+160 */ int32
	var _ /* mapSearch at bp+136 */ TTcl_DictSearch
	var _ /* name at bp+128 */ uintptr
	var _ /* search at bp+104 */ TTcl_HashSearch
	var _ /* table at bp+0 */ TTcl_HashTable
	_, _, _, _, _, _, _ = cachePtr, encodingPtr, hPtr, map1, result, v1, v5
	*(*int32)(unsafe.Pointer(bp + 164)) = 0
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		result = XTclThreadAllocObj(tls)
	} else {
		result = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(result + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(result)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(result)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(result)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(result)).FtypePtr = libc.UintptrFromInt32(0)
	XTcl_InitObjHashTable(tls, bp)
	/*
	 * Copy encoding names from loaded encoding table to table.
	 */
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_encodingMutex)))
	hPtr = XTcl_FirstHashEntry(tls, uintptr(unsafe.Pointer(&_encodingTable)), bp+104)
	for {
		if !(hPtr != libc.UintptrFromInt32(0)) {
			break
		}
		encodingPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(bp)).FcreateProc})))(tls, bp, XTcl_NewStringObj(tls, (*TEncoding)(unsafe.Pointer(encodingPtr)).Fname, int64(-libc.Int32FromInt32(1))), bp+160)
		goto _2
	_2:
		;
		hPtr = XTcl_NextHashEntry(tls, bp+104)
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_encodingMutex)))
	_FillEncodingFileMap(tls)
	map1 = XTclGetProcessGlobalValue(tls, uintptr(unsafe.Pointer(&_encodingFileMap)))
	/*
	 * Copy encoding names from encoding file map to table.
	 */
	XTcl_DictObjFirst(tls, libc.UintptrFromInt32(0), map1, bp+136, bp+128, libc.UintptrFromInt32(0), bp+164)
	for {
		if !!(*(*int32)(unsafe.Pointer(bp + 164)) != 0) {
			break
		}
		(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(bp)).FcreateProc})))(tls, bp, *(*uintptr)(unsafe.Pointer(bp + 128)), bp+160)
		goto _3
	_3:
		;
		XTcl_DictObjNext(tls, bp+136, bp+128, libc.UintptrFromInt32(0), bp+164)
	}
	/*
	 * Pull all encoding names from table into the result list.
	 */
	hPtr = XTcl_FirstHashEntry(tls, bp, bp+104)
	for {
		if !(hPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TTcl_HashTable)(unsafe.Pointer(bp)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(bp)).FkeyType == -int32(1) {
			v5 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
		} else {
			v5 = hPtr + 32
		}
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), result, v5)
		goto _4
	_4:
		;
		hPtr = XTcl_NextHashEntry(tls, bp+104)
	}
	XTcl_SetObjResult(tls, interp, result)
	XTcl_DeleteHashTable(tls, bp)
}

// C documentation
//
//	/*
//	 *-------------------------------------------------------------------------
//	 *
//	 * Tcl_GetEncodingNulLength --
//	 *
//	 *	Given an encoding, return the number of nul bytes used for the
//	 *	string termination.
//	 *
//	 * Results:
//	 *	The number of nul bytes used for the string termination.
//	 *
//	 * Side effects:
//	 *	None.
//	 *
//	 *---------------------------------------------------------------------------
//	 */
func XTcl_GetEncodingNulLength(tls *libc.TLS, encoding TTcl_Encoding) (r TTcl_Size) {
	if encoding == libc.UintptrFromInt32(0) {
		encoding = _systemEncoding
	}
	return (*TEncoding)(unsafe.Pointer(encoding)).FnullSize
}

/*
 *------------------------------------------------------------------------
 *
 * Tcl_SetSystemEncoding --
 *
 *	Sets the default encoding that should be used whenever the user passes
 *	a NULL value in to one of the conversion routines. If the supplied
 *	name is NULL, the system encoding is reset to the default system
 *	encoding.
 *
 * Results:
 *	The return value is TCL_OK if the system encoding was successfully set
 *	to the encoding specified by name, TCL_ERROR otherwise. If TCL_ERROR
 *	is returned, an error message is left in interp's result object,
 *	unless interp was NULL.
 *
 * Side effects:
 *	The reference count of the new system encoding is incremented. The
 *	reference count of the old system encoding is decremented and it may
 *	be freed. All VFS cached information is invalidated.
 *
 *------------------------------------------------------------------------
 */

func XTcl_SetSystemEncoding(tls *libc.TLS, interp uintptr, name uintptr) (r int32) {
	/* The name of the desired encoding, or NULL/""
	 * to reset to default encoding. */
	var encoding TTcl_Encoding
	var encodingPtr uintptr
	_, _ = encoding, encodingPtr
	if !(name != 0) || !(*(*uint8)(unsafe.Pointer(name)) != 0) {
		XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_encodingMutex)))
		encoding = _defaultEncoding
		encodingPtr = encoding
		(*TEncoding)(unsafe.Pointer(encodingPtr)).FrefCount++
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_encodingMutex)))
	} else {
		encoding = XTcl_GetEncoding(tls, interp, name)
		if encoding == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
	}
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_encodingMutex)))
	_FreeEncoding(tls, _systemEncoding)
	_systemEncoding = encoding
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_encodingMutex)))
	XTcl_FSMountsChanged(tls, libc.UintptrFromInt32(0))
	return TCL_OK
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_CreateEncoding --
 *
 *	Defines a new encoding, along with the functions that are used to
 *	convert to and from Unicode.
 *
 * Results:
 *	Returns a token that represents the encoding. If an encoding with the
 *	same name already existed, the old encoding token remains valid and
 *	continues to behave as it used to, and is eventually garbage collected
 *	when the last reference to it goes away. Any subsequent calls to
 *	Tcl_GetEncoding with the specified name retrieve the most recent
 *	encoding token.
 *
 * Side effects:
 *	A new record having the name of the encoding is entered into a table of
 *	encodings visible to all interpreters.  For each call to this function,
 *	there should eventually be a call to Tcl_FreeEncoding, which cleans
 *	deletes the record in the table when an encoding is no longer needed.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_CreateEncoding(tls *libc.TLS, typePtr uintptr) (r TTcl_Encoding) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	/* The encoding type. */
	var encodingPtr, hPtr, name, replaceMe uintptr
	var _ /* isNew at bp+0 */ int32
	_, _, _, _ = encodingPtr, hPtr, name, replaceMe
	encodingPtr = XTcl_Alloc(tls, uint64(72))
	(*TEncoding)(unsafe.Pointer(encodingPtr)).Fname = libc.UintptrFromInt32(0)
	(*TEncoding)(unsafe.Pointer(encodingPtr)).FtoUtfProc = (*TTcl_EncodingType)(unsafe.Pointer(typePtr)).FtoUtfProc
	(*TEncoding)(unsafe.Pointer(encodingPtr)).FfromUtfProc = (*TTcl_EncodingType)(unsafe.Pointer(typePtr)).FfromUtfProc
	(*TEncoding)(unsafe.Pointer(encodingPtr)).FfreeProc = (*TTcl_EncodingType)(unsafe.Pointer(typePtr)).FfreeProc
	(*TEncoding)(unsafe.Pointer(encodingPtr)).FnullSize = (*TTcl_EncodingType)(unsafe.Pointer(typePtr)).FnullSize
	(*TEncoding)(unsafe.Pointer(encodingPtr)).FclientData = (*TTcl_EncodingType)(unsafe.Pointer(typePtr)).FclientData
	if (*TTcl_EncodingType)(unsafe.Pointer(typePtr)).FnullSize == int64(2) {
		(*TEncoding)(unsafe.Pointer(encodingPtr)).FlengthProc = __ccgo_fp(_unilen)
	} else {
		if (*TTcl_EncodingType)(unsafe.Pointer(typePtr)).FnullSize == int64(4) {
			(*TEncoding)(unsafe.Pointer(encodingPtr)).FlengthProc = __ccgo_fp(_unilen4)
		} else {
			(*TEncoding)(unsafe.Pointer(encodingPtr)).FlengthProc = __ccgo_fp(libc.Xstrlen)
		}
	}
	(*TEncoding)(unsafe.Pointer(encodingPtr)).FrefCount = uint64(1)
	(*TEncoding)(unsafe.Pointer(encodingPtr)).FhPtr = libc.UintptrFromInt32(0)
	if (*TTcl_EncodingType)(unsafe.Pointer(typePtr)).FencodingName != 0 {
		XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_encodingMutex)))
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_encodingTable)))).FcreateProc})))(tls, uintptr(unsafe.Pointer(&_encodingTable)), (*TTcl_EncodingType)(unsafe.Pointer(typePtr)).FencodingName, bp)
		if *(*int32)(unsafe.Pointer(bp)) == 0 {
			/*
			 * Remove old encoding from hash table, but don't delete it until last
			 * reference goes away.
			 */
			replaceMe = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
			(*TEncoding)(unsafe.Pointer(replaceMe)).FhPtr = libc.UintptrFromInt32(0)
		}
		name = XTcl_Alloc(tls, libc.Xstrlen(tls, (*TTcl_EncodingType)(unsafe.Pointer(typePtr)).FencodingName)+uint64(1))
		(*TEncoding)(unsafe.Pointer(encodingPtr)).Fname = libc.Xstrcpy(tls, name, (*TTcl_EncodingType)(unsafe.Pointer(typePtr)).FencodingName)
		(*TEncoding)(unsafe.Pointer(encodingPtr)).FhPtr = hPtr
		(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = encodingPtr
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_encodingMutex)))
	}
	return encodingPtr
}

/*
 *-------------------------------------------------------------------------
 *
 * Tcl_ExternalToUtfDString --
 *
 *	Convert a source buffer from the specified encoding into UTF-8. If any
 *	of the bytes in the source buffer are invalid or cannot be represented
 *	in the target encoding, a default fallback character will be
 *	substituted.
 *
 * Results:
 *	The converted bytes are stored in the DString, which is then NULL
 *	terminated. The return value is a pointer to the value stored in the
 *	DString.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func XTcl_ExternalToUtfDString(tls *libc.TLS, encoding TTcl_Encoding, src uintptr, srcLen TTcl_Size, dstPtr uintptr) (r uintptr) {
	/* Uninitialized or free DString in which the
	 * converted string is stored. */
	XTcl_ExternalToUtfDStringEx(tls, libc.UintptrFromInt32(0), encoding, src, srcLen, int32(TCL_ENCODING_PROFILE_TCL8), dstPtr, libc.UintptrFromInt32(0))
	return (*TTcl_DString)(unsafe.Pointer(dstPtr)).Fstring1
}

/*
 *-------------------------------------------------------------------------
 *
 * Tcl_ExternalToUtfDStringEx --
 *
 *	Convert a source buffer from the specified encoding into UTF-8.
 *	"flags" controls the behavior if any of the bytes in
 *	the source buffer are invalid or cannot be represented in utf-8.
 *	Possible flags values:
 *	target encoding. It should be composed by OR-ing the following:
 *	- *At most one* of TCL_ENCODING_PROFILE{DEFAULT,TCL8,STRICT}
 *
 * Results:
 *	The return value is one of
 *	  TCL_OK: success. Converted string in *dstPtr
 *	  TCL_ERROR: error in passed parameters. Error message in interp
 *	  TCL_CONVERT_MULTIBYTE: source ends in truncated multibyte sequence
 *	  TCL_CONVERT_SYNTAX: source is not conformant to encoding definition
 *	  TCL_CONVERT_UNKNOWN: source contained a character that could not
 *	      be represented in target encoding.
 *
 * Side effects:
 *	TCL_OK: The converted bytes are stored in the DString and NUL
 *	    terminated in an encoding-specific manner.
 *	TCL_ERROR: an error, message is stored in the interp if not NULL.
 *	TCL_CONVERT_*: if errorLocPtr is NULL, an error message is stored
 *	    in the interpreter (if not NULL). If errorLocPtr is not NULL,
 *	    no error message is stored as it is expected the caller is
 *	    interested in whatever is decoded so far and not treating this
 *	    as an error condition.
 *
 *	In addition, *dstPtr is always initialized and must be cleared
 *	by the caller irrespective of the return code.
 *
 *-------------------------------------------------------------------------
 */

func XTcl_ExternalToUtfDStringEx(tls *libc.TLS, interp uintptr, encoding TTcl_Encoding, src uintptr, srcLen TTcl_Size, flags int32, dstPtr uintptr, errorLocPtr uintptr) (r int32) {
	bp := tls.Alloc(96)
	defer tls.Free(96) /* Where to store the error location
	 * (or TCL_INDEX_NONE if no error). May
	 * be NULL. */
	var dst, encodingPtr, srcStart uintptr
	var dstChunkLen, result, srcChunkLen, v3 int32
	var dstLen, nBytesProcessed, soFar TTcl_Size
	var v1, v2 int64
	var _ /* buf at bp+20 */ [24]uint8
	var _ /* dstChunkChars at bp+16 */ int32
	var _ /* dstChunkWrote at bp+12 */ int32
	var _ /* srcChunkRead at bp+8 */ int32
	var _ /* state at bp+0 */ TTcl_EncodingState
	_, _, _, _, _, _, _, _, _, _, _, _ = dst, dstChunkLen, dstLen, encodingPtr, nBytesProcessed, result, soFar, srcChunkLen, srcStart, v1, v2, v3
	srcStart = src
	/* DO FIRST - Must always be initialized before returning */
	XTcl_DStringInit(tls, dstPtr)
	dst = (*TTcl_DString)(unsafe.Pointer(dstPtr)).Fstring1
	dstLen = (*TTcl_DString)(unsafe.Pointer(dstPtr)).FspaceAvl - int64(1)
	if encoding == libc.UintptrFromInt32(0) {
		encoding = _systemEncoding
	}
	encodingPtr = encoding
	if src == libc.UintptrFromInt32(0) {
		srcLen = 0
	} else {
		if srcLen == int64(-libc.Int32FromInt32(1)) {
			srcLen = libc.Int64FromUint64((*(*func(*libc.TLS, uintptr) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TEncoding)(unsafe.Pointer(encodingPtr)).FlengthProc})))(tls, src))
		}
	}
	flags &= ^libc.Int32FromInt32(TCL_ENCODING_END)
	flags |= int32(TCL_ENCODING_START)
	if (*TEncoding)(unsafe.Pointer(encodingPtr)).FtoUtfProc == __ccgo_fp(_UtfToUtfProc) {
		flags |= int32(ENCODING_INPUT)
	}
	for int32(1) != 0 {
		if srcLen > int64(INT_MAX) {
			srcChunkLen = int32(INT_MAX)
		} else {
			srcChunkLen = int32(srcLen)
			flags |= int32(TCL_ENCODING_END) /* Last chunk */
		}
		if dstLen > int64(INT_MAX) {
			v1 = int64(INT_MAX)
		} else {
			v1 = dstLen
		}
		dstChunkLen = int32(v1)
		result = (*(*func(*libc.TLS, uintptr, uintptr, int32, int32, uintptr, uintptr, int32, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TEncoding)(unsafe.Pointer(encodingPtr)).FtoUtfProc})))(tls, (*TEncoding)(unsafe.Pointer(encodingPtr)).FclientData, src, srcChunkLen, flags, bp, dst, dstChunkLen, bp+8, bp+12, bp+16)
		soFar = int64(dst+uintptr(*(*int32)(unsafe.Pointer(bp + 12)))) - int64((*TTcl_DString)(unsafe.Pointer(dstPtr)).Fstring1)
		src += uintptr(*(*int32)(unsafe.Pointer(bp + 8)))
		/*
		 * Keep looping in two case -
		 *   - our destination buffer did not have enough room
		 *   - we had not passed in all the data and error indicated fragment
		 *     of a multibyte character
		 * In both cases we have to grow buffer, move the input source pointer
		 * and loop. Otherwise, return the result we got.
		 */
		if result != -int32(4) && !(result == -int32(1) && flags&int32(TCL_ENCODING_END) != 0) {
			nBytesProcessed = int64(src) - int64(srcStart)
			XTcl_DStringSetLength(tls, dstPtr, soFar)
			if errorLocPtr != 0 {
				/*
				 * Do not write error message into interpreter if caller
				 * wants to know error location.
				 */
				if result == TCL_OK {
					v2 = int64(-libc.Int32FromInt32(1))
				} else {
					v2 = nBytesProcessed
				}
				*(*TTcl_Size)(unsafe.Pointer(errorLocPtr)) = v2
			} else {
				/* Caller wants error message on failure */
				if result != TCL_OK && interp != libc.UintptrFromInt32(0) {
					libc.X__builtin_snprintf(tls, bp+20, uint64(24), __ccgo_ts+29183, libc.VaList(bp+56, nBytesProcessed))
					XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+29187, libc.VaList(bp+56, nBytesProcessed, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(srcStart + uintptr(nBytesProcessed)))))))
					XTcl_SetErrorCode(tls, interp, libc.VaList(bp+56, __ccgo_ts+2004, __ccgo_ts+15139, __ccgo_ts+29244, bp+20, libc.UintptrFromInt32(0)))
				}
			}
			if result != TCL_OK {
				if result == -int32(4) {
					v3 = int32(ENOMEM)
				} else {
					v3 = int32(EILSEQ)
				}
				*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = v3
			}
			return result
		}
		/* Expand space and continue */
		flags &= ^libc.Int32FromInt32(TCL_ENCODING_START)
		srcLen -= int64(*(*int32)(unsafe.Pointer(bp + 8)))
		if (*TTcl_DString)(unsafe.Pointer(dstPtr)).Flength == 0 {
			XTcl_DStringSetLength(tls, dstPtr, dstLen)
		}
		XTcl_DStringSetLength(tls, dstPtr, int64(2)*(*TTcl_DString)(unsafe.Pointer(dstPtr)).Flength+int64(1))
		dst = (*TTcl_DString)(unsafe.Pointer(dstPtr)).Fstring1 + uintptr(soFar)
		dstLen = (*TTcl_DString)(unsafe.Pointer(dstPtr)).Flength - soFar - int64(1)
	}
	return r
}

/*
 *-------------------------------------------------------------------------
 *
 * Tcl_ExternalToUtf --
 *
 *	Convert a source buffer from the specified encoding into UTF-8.
 *
 * Results:
 *	The return value is one of TCL_OK, TCL_CONVERT_MULTIBYTE,
 *	TCL_CONVERT_SYNTAX, TCL_CONVERT_UNKNOWN, or TCL_CONVERT_NOSPACE, as
 *	documented in tcl.h.
 *
 * Side effects:
 *	The converted bytes are stored in the output buffer.
 *
 *-------------------------------------------------------------------------
 */

func XTcl_ExternalToUtf(tls *libc.TLS, dummy1295 uintptr, encoding TTcl_Encoding, src uintptr, srcLen TTcl_Size, flags int32, statePtr uintptr, dst uintptr, dstLen TTcl_Size, srcReadPtr uintptr, dstWrotePtr uintptr, dstCharsPtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Filled with the number of characters that
	 * correspond to the bytes stored in the
	 * output buffer. */
	var charLimited, maxChars, noTerminate, result int32
	var encodingPtr uintptr
	var savedState TTcl_EncodingState
	var _ /* dstChars at bp+8 */ int32
	var _ /* dstWrote at bp+4 */ int32
	var _ /* srcRead at bp+0 */ int32
	var _ /* state at bp+16 */ TTcl_EncodingState
	_, _, _, _, _, _ = charLimited, encodingPtr, maxChars, noTerminate, result, savedState
	*(*int32)(unsafe.Pointer(bp + 8)) = 0
	noTerminate = flags & int32(TCL_ENCODING_NO_TERMINATE)
	charLimited = libc.BoolInt32(flags&int32(TCL_ENCODING_CHAR_LIMIT) != 0 && dstCharsPtr != 0)
	maxChars = int32(INT_MAX)
	if encoding == libc.UintptrFromInt32(0) {
		encoding = _systemEncoding
	}
	encodingPtr = encoding
	if src == libc.UintptrFromInt32(0) {
		srcLen = 0
	} else {
		if srcLen == int64(-libc.Int32FromInt32(1)) {
			srcLen = libc.Int64FromUint64((*(*func(*libc.TLS, uintptr) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TEncoding)(unsafe.Pointer(encodingPtr)).FlengthProc})))(tls, src))
		}
	}
	if statePtr == libc.UintptrFromInt32(0) {
		flags |= libc.Int32FromInt32(TCL_ENCODING_START) | libc.Int32FromInt32(TCL_ENCODING_END)
		statePtr = bp + 16
	}
	if srcLen > int64(INT_MAX) {
		srcLen = int64(INT_MAX)
		flags &= ^libc.Int32FromInt32(TCL_ENCODING_END)
	}
	if dstLen > int64(INT_MAX) {
		dstLen = int64(INT_MAX)
	}
	if srcReadPtr == libc.UintptrFromInt32(0) {
		srcReadPtr = bp
	}
	if dstWrotePtr == libc.UintptrFromInt32(0) {
		dstWrotePtr = bp + 4
	}
	if dstCharsPtr == libc.UintptrFromInt32(0) {
		dstCharsPtr = bp + 8
		flags &= ^libc.Int32FromInt32(TCL_ENCODING_CHAR_LIMIT)
	} else {
		if charLimited != 0 {
			maxChars = *(*int32)(unsafe.Pointer(dstCharsPtr))
		}
	}
	if !(noTerminate != 0) {
		if dstLen < int64(1) {
			return -int32(4)
		}
		/*
		 * If there are any null characters in the middle of the buffer,
		 * they will converted to the UTF-8 null character (\xC0\x80). To get
		 * the actual \0 at the end of the destination buffer, we need to
		 * append it manually.  First make room for it...
		 */
		dstLen--
	} else {
		if dstLen <= 0 && srcLen > 0 {
			return -int32(4)
		}
	}
	if (*TEncoding)(unsafe.Pointer(encodingPtr)).FtoUtfProc == __ccgo_fp(_UtfToUtfProc) {
		flags |= int32(ENCODING_INPUT)
	}
	for cond := true; cond; cond = int32(1) != 0 {
		savedState = *(*TTcl_EncodingState)(unsafe.Pointer(statePtr))
		result = (*(*func(*libc.TLS, uintptr, uintptr, int32, int32, uintptr, uintptr, int32, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TEncoding)(unsafe.Pointer(encodingPtr)).FtoUtfProc})))(tls, (*TEncoding)(unsafe.Pointer(encodingPtr)).FclientData, src, int32(srcLen), flags, statePtr, dst, int32(dstLen), srcReadPtr, dstWrotePtr, dstCharsPtr)
		if *(*int32)(unsafe.Pointer(dstCharsPtr)) <= maxChars {
			break
		}
		dstLen = int64(XTcl_UtfAtIndex(tls, dst, int64(maxChars))) - int64(dst) + int64(libc.Int32FromInt32(TCL_UTF_MAX)-libc.Int32FromInt32(1))
		*(*TTcl_EncodingState)(unsafe.Pointer(statePtr)) = savedState
	}
	if !(noTerminate != 0) {
		/* ...and then append it */
		*(*uint8)(unsafe.Pointer(dst + uintptr(*(*int32)(unsafe.Pointer(dstWrotePtr))))) = uint8('\000')
	}
	return result
}

// C documentation
//
//	/*
//	 *-------------------------------------------------------------------------
//	 *
//	 * Tcl_UtfToExternalDString --
//	 *
//	 *	Convert a source buffer from UTF-8 to the specified encoding. If any
//	 *	of the bytes in the source buffer are invalid or cannot be represented
//	 *	in the target encoding, a default fallback character is substituted.
//	 *
//	 * Results:
//	 *	The converted bytes are stored in the DString, which is then NULL
//	 *	terminated in an encoding-specific manner. The return value is a
//	 *	pointer to the value stored in the DString.
//	 *
//	 * Side effects:
//	 *	None.
//	 *
//	 *-------------------------------------------------------------------------
//	 */
func XTcl_UtfToExternalDString(tls *libc.TLS, encoding TTcl_Encoding, src uintptr, srcLen TTcl_Size, dstPtr uintptr) (r uintptr) {
	/* Uninitialized or free DString in which the
	 * converted string is stored. */
	XTcl_UtfToExternalDStringEx(tls, libc.UintptrFromInt32(0), encoding, src, srcLen, int32(TCL_ENCODING_PROFILE_TCL8), dstPtr, libc.UintptrFromInt32(0))
	return (*TTcl_DString)(unsafe.Pointer(dstPtr)).Fstring1
}

/*
 *-------------------------------------------------------------------------
 *
 * Tcl_UtfToExternalDStringEx --
 *
 *	Convert a source buffer from UTF-8 to the specified encoding.
 *	The parameter flags controls the behavior, if any of the bytes in
 *	the source buffer are invalid or cannot be represented in the
 *	target encoding. It should be composed by OR-ing the following:
 *	- *At most one* of TCL_ENCODING_PROFILE_*
 *
 * Results:
 *	The return value is one of
 *	  TCL_OK: success. Converted string in *dstPtr
 *	  TCL_ERROR: error in passed parameters. Error message in interp
 *	  TCL_CONVERT_MULTIBYTE: source ends in truncated multibyte sequence
 *	  TCL_CONVERT_SYNTAX: source is not conformant to encoding definition
 *	  TCL_CONVERT_UNKNOWN: source contained a character that could not
 *	      be represented in target encoding.
 *
 * Side effects:
 *	TCL_OK: The converted bytes are stored in the DString and NUL
 *	    terminated in an encoding-specific manner
 *	TCL_ERROR: an error, message is stored in the interp if not NULL.
 *	TCL_CONVERT_*: if errorLocPtr is NULL, an error message is stored
 *	    in the interpreter (if not NULL). If errorLocPtr is not NULL,
 *	    no error message is stored as it is expected the caller is
 *	    interested in whatever is decoded so far and not treating this
 *	    as an error condition.
 *
 *	In addition, *dstPtr is always initialized and must be cleared
 *	by the caller irrespective of the return code.
 *
 *-------------------------------------------------------------------------
 */

func XTcl_UtfToExternalDStringEx(tls *libc.TLS, interp uintptr, encoding TTcl_Encoding, src uintptr, srcLen TTcl_Size, flags int32, dstPtr uintptr, errorLocPtr uintptr) (r int32) {
	bp := tls.Alloc(96)
	defer tls.Free(96) /* Where to store the error location
	 * (or TCL_INDEX_NONE if no error). May
	 * be NULL. */
	var dst, encodingPtr, srcStart uintptr
	var dstChunkLen, result, srcChunkLen, v5 int32
	var dstLen, i, nBytesProcessed, pos, soFar, v2 TTcl_Size
	var v1, v3 int64
	var _ /* buf at bp+24 */ [24]uint8
	var _ /* dstChunkChars at bp+16 */ int32
	var _ /* dstChunkWrote at bp+12 */ int32
	var _ /* srcChunkRead at bp+8 */ int32
	var _ /* state at bp+0 */ TTcl_EncodingState
	var _ /* ucs4 at bp+20 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = dst, dstChunkLen, dstLen, encodingPtr, i, nBytesProcessed, pos, result, soFar, srcChunkLen, srcStart, v1, v2, v3, v5
	srcStart = src
	/* DO FIRST - must always be initialized on return */
	XTcl_DStringInit(tls, dstPtr)
	dst = (*TTcl_DString)(unsafe.Pointer(dstPtr)).Fstring1
	dstLen = (*TTcl_DString)(unsafe.Pointer(dstPtr)).FspaceAvl - int64(1)
	if encoding == libc.UintptrFromInt32(0) {
		encoding = _systemEncoding
	}
	encodingPtr = encoding
	if src == libc.UintptrFromInt32(0) {
		srcLen = 0
	} else {
		if srcLen == int64(-libc.Int32FromInt32(1)) {
			srcLen = libc.Int64FromUint64(libc.Xstrlen(tls, src))
		}
	}
	flags &= ^libc.Int32FromInt32(TCL_ENCODING_END)
	flags |= int32(TCL_ENCODING_START)
	for int32(1) != 0 {
		if srcLen > int64(INT_MAX) {
			srcChunkLen = int32(INT_MAX)
		} else {
			srcChunkLen = int32(srcLen)
			flags |= int32(TCL_ENCODING_END) /* Last chunk */
		}
		if dstLen > int64(INT_MAX) {
			v1 = int64(INT_MAX)
		} else {
			v1 = dstLen
		}
		dstChunkLen = int32(v1)
		result = (*(*func(*libc.TLS, uintptr, uintptr, int32, int32, uintptr, uintptr, int32, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TEncoding)(unsafe.Pointer(encodingPtr)).FfromUtfProc})))(tls, (*TEncoding)(unsafe.Pointer(encodingPtr)).FclientData, src, srcChunkLen, flags, bp, dst, dstChunkLen, bp+8, bp+12, bp+16)
		soFar = int64(dst+uintptr(*(*int32)(unsafe.Pointer(bp + 12)))) - int64((*TTcl_DString)(unsafe.Pointer(dstPtr)).Fstring1)
		/* Move past the part processed in this go around */
		src += uintptr(*(*int32)(unsafe.Pointer(bp + 8)))
		/*
		 * Keep looping in two case -
		 *   - our destination buffer did not have enough room
		 *   - we had not passed in all the data and error indicated fragment
		 *     of a multibyte character
		 * In both cases we have to grow buffer, move the input source pointer
		 * and loop. Otherwise, return the result we got.
		 */
		if result != -int32(4) && !(result == -int32(1) && flags&int32(TCL_ENCODING_END) != 0) {
			nBytesProcessed = int64(src) - int64(srcStart)
			i = soFar + (*TEncoding)(unsafe.Pointer(encodingPtr)).FnullSize - int64(1)
			/* Loop as DStringSetLength only stores one nul byte at a time */
			for i >= soFar {
				v2 = i
				i--
				XTcl_DStringSetLength(tls, dstPtr, v2)
			}
			if errorLocPtr != 0 {
				/*
				 * Do not write error message into interpreter if caller
				 * wants to know error location.
				 */
				if result == TCL_OK {
					v3 = int64(-libc.Int32FromInt32(1))
				} else {
					v3 = nBytesProcessed
				}
				*(*TTcl_Size)(unsafe.Pointer(errorLocPtr)) = v3
			} else {
				/* Caller wants error message on failure */
				if result != TCL_OK && interp != libc.UintptrFromInt32(0) {
					pos = XTcl_NumUtfChars(tls, srcStart, nBytesProcessed)
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(srcStart + uintptr(nBytesProcessed)))) < int32(0x80) {
						*(*int32)(unsafe.Pointer(bp + 20)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(srcStart + uintptr(nBytesProcessed))))
						_ = libc.Int32FromInt32(1)
					} else {
						XTcl_UtfToUniChar(tls, srcStart+uintptr(nBytesProcessed), bp+20)
					}
					libc.X__builtin_snprintf(tls, bp+24, uint64(24), __ccgo_ts+29183, libc.VaList(bp+56, nBytesProcessed))
					XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+29260, libc.VaList(bp+56, pos, *(*int32)(unsafe.Pointer(bp + 20)))))
					XTcl_SetErrorCode(tls, interp, libc.VaList(bp+56, __ccgo_ts+2004, __ccgo_ts+15139, __ccgo_ts+29244, bp+24, libc.UintptrFromInt32(0)))
				}
			}
			if result != TCL_OK {
				if result == -int32(4) {
					v5 = int32(ENOMEM)
				} else {
					v5 = int32(EILSEQ)
				}
				*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = v5
			}
			return result
		}
		flags &= ^libc.Int32FromInt32(TCL_ENCODING_START)
		srcLen -= int64(*(*int32)(unsafe.Pointer(bp + 8)))
		if (*TTcl_DString)(unsafe.Pointer(dstPtr)).Flength == 0 {
			XTcl_DStringSetLength(tls, dstPtr, dstLen)
		}
		XTcl_DStringSetLength(tls, dstPtr, int64(2)*(*TTcl_DString)(unsafe.Pointer(dstPtr)).Flength+int64(1))
		dst = (*TTcl_DString)(unsafe.Pointer(dstPtr)).Fstring1 + uintptr(soFar)
		dstLen = (*TTcl_DString)(unsafe.Pointer(dstPtr)).Flength - soFar - int64(1)
	}
	return r
}

/*
 *-------------------------------------------------------------------------
 *
 * Tcl_UtfToExternal --
 *
 *	Convert a buffer from UTF-8 into the specified encoding.
 *
 * Results:
 *	The return value is one of TCL_OK, TCL_CONVERT_MULTIBYTE,
 *	TCL_CONVERT_SYNTAX, TCL_CONVERT_UNKNOWN, or TCL_CONVERT_NOSPACE, as
 *	documented in tcl.h.
 *
 * Side effects:
 *	The converted bytes are stored in the output buffer.
 *
 *-------------------------------------------------------------------------
 */

func XTcl_UtfToExternal(tls *libc.TLS, dummy1617 uintptr, encoding TTcl_Encoding, src uintptr, srcLen TTcl_Size, flags int32, statePtr uintptr, dst uintptr, dstLen TTcl_Size, srcReadPtr uintptr, dstWrotePtr uintptr, dstCharsPtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Filled with the number of characters that
	 * correspond to the bytes stored in the
	 * output buffer. */
	var encodingPtr uintptr
	var result int32
	var _ /* dstChars at bp+8 */ int32
	var _ /* dstWrote at bp+4 */ int32
	var _ /* srcRead at bp+0 */ int32
	var _ /* state at bp+16 */ TTcl_EncodingState
	_, _ = encodingPtr, result
	if encoding == libc.UintptrFromInt32(0) {
		encoding = _systemEncoding
	}
	encodingPtr = encoding
	if src == libc.UintptrFromInt32(0) {
		srcLen = 0
	} else {
		if srcLen == int64(-libc.Int32FromInt32(1)) {
			srcLen = libc.Int64FromUint64(libc.Xstrlen(tls, src))
		}
	}
	if statePtr == libc.UintptrFromInt32(0) {
		flags |= libc.Int32FromInt32(TCL_ENCODING_START) | libc.Int32FromInt32(TCL_ENCODING_END)
		statePtr = bp + 16
	}
	if srcLen > int64(INT_MAX) {
		srcLen = int64(INT_MAX)
		flags &= ^libc.Int32FromInt32(TCL_ENCODING_END)
	}
	if dstLen > int64(INT_MAX) {
		dstLen = int64(INT_MAX)
	}
	if srcReadPtr == libc.UintptrFromInt32(0) {
		srcReadPtr = bp
	}
	if dstWrotePtr == libc.UintptrFromInt32(0) {
		dstWrotePtr = bp + 4
	}
	if dstCharsPtr == libc.UintptrFromInt32(0) {
		dstCharsPtr = bp + 8
	}
	if dstLen < (*TEncoding)(unsafe.Pointer(encodingPtr)).FnullSize {
		return -int32(4)
	}
	dstLen -= (*TEncoding)(unsafe.Pointer(encodingPtr)).FnullSize
	result = (*(*func(*libc.TLS, uintptr, uintptr, int32, int32, uintptr, uintptr, int32, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TEncoding)(unsafe.Pointer(encodingPtr)).FfromUtfProc})))(tls, (*TEncoding)(unsafe.Pointer(encodingPtr)).FclientData, src, int32(srcLen), flags, statePtr, dst, int32(dstLen), srcReadPtr, dstWrotePtr, dstCharsPtr)
	/*
	 * Buffer is terminated irrespective of result. Not sure this is
	 * reasonable but keep for historical/compatibility reasons.
	 */
	libc.Xmemset(tls, dst+uintptr(*(*int32)(unsafe.Pointer(dstWrotePtr))), int32('\000'), libc.Uint64FromInt64((*TEncoding)(unsafe.Pointer(encodingPtr)).FnullSize))
	return result
}

// C documentation
//
//	/*
//	 *---------------------------------------------------------------------------
//	 *
//	 * Tcl_FindExecutable --
//	 *
//	 *	This function computes the absolute path name of the current
//	 *	application, given its argv[0] value.
//	 *
//	 * Results:
//	 *	None.
//	 *
//	 * Side effects:
//	 *	The absolute pathname for the application is computed and stored to be
//	 *	returned later by [info nameofexecutable].
//	 *
//	 *---------------------------------------------------------------------------
//	 */
func XTcl_FindExecutable(tls *libc.TLS, argv0 uintptr) (r uintptr) {
	/* The value of the application's argv[0]
	 * (native). */
	var version uintptr
	_ = version
	version = XTcl_InitSubsystems(tls)
	XTclpSetInitialEncodings(tls)
	XTclpFindExecutable(tls, argv0)
	return version
}

/*
 *---------------------------------------------------------------------------
 *
 * OpenEncodingFileChannel --
 *
 *	Open the file believed to hold data for the encoding, "name".
 *
 * Results:
 *	Returns the readable Tcl_Channel from opening the file, or NULL if the
 *	file could not be successfully opened. If NULL was returned, an error
 *	message is left in interp's result object, unless interp was NULL.
 *
 * Side effects:
 *	Channel may be opened. Information about the filesystem may be cached
 *	to speed later calls.
 *
 *---------------------------------------------------------------------------
 */

func _OpenEncodingFileChannel(tls *libc.TLS, interp uintptr, name uintptr) (r TTcl_Channel) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* The name of the encoding file on disk and
	 * also the name for new encoding. */
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, dirString, map1, path, searchPath, v11, v14, v16, v18, v5, v7, v9 uintptr
	var chan1 TTcl_Channel
	var i, v10, v13, v15, v17, v8 TTcl_Size
	var verified int32
	var v2, v3 int64
	var _ /* dir at bp+8 */ uintptr
	var _ /* directory at bp+16 */ uintptr
	var _ /* fileNameObj at bp+0 */ uintptr
	var _ /* numDirs at bp+24 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, chan1, dirString, i, map1, path, searchPath, verified, v10, v11, v13, v14, v15, v16, v17, v18, v2, v3, v5, v7, v8, v9
	*(*uintptr)(unsafe.Pointer(bp)) = XTcl_ObjPrintf(tls, __ccgo_ts+29304, libc.VaList(bp+40, name))
	searchPath = XTcl_DuplicateObj(tls, XTcl_GetEncodingSearchPath(tls))
	map1 = XTclGetProcessGlobalValue(tls, uintptr(unsafe.Pointer(&_encodingFileMap)))
	*(*uintptr)(unsafe.Pointer(bp + 16)) = libc.UintptrFromInt32(0)
	chan1 = libc.UintptrFromInt32(0)
	if (*TTcl_Obj)(unsafe.Pointer(searchPath)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(searchPath + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(searchPath + 32))).Fptr2)).FspanStart
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(searchPath + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(searchPath + 32))).Fptr1 + 40 + uintptr(v2)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(searchPath + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(searchPath + 32))).Fptr2)).FspanLength
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(searchPath + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = v3
		_ = libc.Int32FromInt32(TCL_OK)
	} else {
		XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), searchPath, bp+24, bp+8)
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FrefCount++
	XTclDictGet(tls, libc.UintptrFromInt32(0), map1, name, bp+16)
	/*
	 * Check that any cached directory is still on the encoding search path.
	 */
	if libc.UintptrFromInt32(0) != *(*uintptr)(unsafe.Pointer(bp + 16)) {
		verified = 0
		i = 0
		for {
			if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 24)) && !(verified != 0)) {
				break
			}
			if *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)) == *(*uintptr)(unsafe.Pointer(bp + 16)) {
				verified = int32(1)
			}
			goto _4
		_4:
			;
			i++
		}
		if !(verified != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 {
				v5 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes
			} else {
				v5 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), libc.UintptrFromInt32(0))
			}
			dirString = v5
			i = 0
			for {
				if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 24)) && !(verified != 0)) {
					break
				}
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)))).Fbytes != 0 {
					v7 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)))).Fbytes
				} else {
					v7 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)), libc.UintptrFromInt32(0))
				}
				if libc.Xstrcmp(tls, dirString, v7) == 0 {
					verified = int32(1)
				}
				goto _6
			_6:
				;
				i++
			}
		}
		if !(verified != 0) {
			/*
			 * Directory no longer on the search path. Remove from cache.
			 */
			map1 = XTcl_DuplicateObj(tls, map1)
			XTclDictRemove(tls, libc.UintptrFromInt32(0), map1, name)
			XTclSetProcessGlobalValue(tls, uintptr(unsafe.Pointer(&_encodingFileMap)), map1)
			*(*uintptr)(unsafe.Pointer(bp + 16)) = libc.UintptrFromInt32(0)
		}
	}
	if libc.UintptrFromInt32(0) != *(*uintptr)(unsafe.Pointer(bp + 16)) {
		/*
		 * Got a directory from the cache. Try to use it first.
		 */
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount++
		path = XTcl_FSJoinToPath(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), int64(1), bp)
		(*TTcl_Obj)(unsafe.Pointer(path)).FrefCount++
		_objPtr = *(*uintptr)(unsafe.Pointer(bp + 16))
		v9 = _objPtr
		v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
		*(*TTcl_Size)(unsafe.Pointer(v9))--
		if v8 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		chan1 = XTcl_FSOpenFileChannel(tls, libc.UintptrFromInt32(0), path, __ccgo_ts+25877, 0)
		_objPtr1 = path
		v11 = _objPtr1
		v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
		*(*TTcl_Size)(unsafe.Pointer(v11))--
		if v10 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
	/*
	 * Scan the search path until we find it.
	 */
	i = 0
	for {
		if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 24)) && chan1 == libc.UintptrFromInt32(0)) {
			break
		}
		path = XTcl_FSJoinToPath(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)), int64(1), bp)
		(*TTcl_Obj)(unsafe.Pointer(path)).FrefCount++
		chan1 = XTcl_FSOpenFileChannel(tls, libc.UintptrFromInt32(0), path, __ccgo_ts+25877, 0)
		_objPtr2 = path
		v14 = _objPtr2
		v13 = *(*TTcl_Size)(unsafe.Pointer(v14))
		*(*TTcl_Size)(unsafe.Pointer(v14))--
		if v13 <= int64(1) {
			XTclFreeObj(tls, _objPtr2)
		}
		if chan1 != libc.UintptrFromInt32(0) {
			/*
			 * Save directory in the cache.
			 */
			map1 = XTcl_DuplicateObj(tls, XTclGetProcessGlobalValue(tls, uintptr(unsafe.Pointer(&_encodingFileMap))))
			XTclDictPut(tls, libc.UintptrFromInt32(0), map1, name, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)))
			XTclSetProcessGlobalValue(tls, uintptr(unsafe.Pointer(&_encodingFileMap)), map1)
		}
		goto _12
	_12:
		;
		i++
	}
	if libc.UintptrFromInt32(0) == chan1 && interp != libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+29311, libc.VaList(bp+40, name)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+15139, name, libc.UintptrFromInt32(0)))
	}
	_objPtr3 = *(*uintptr)(unsafe.Pointer(bp))
	v16 = _objPtr3
	v15 = *(*TTcl_Size)(unsafe.Pointer(v16))
	*(*TTcl_Size)(unsafe.Pointer(v16))--
	if v15 <= int64(1) {
		XTclFreeObj(tls, _objPtr3)
	}
	_objPtr4 = searchPath
	v18 = _objPtr4
	v17 = *(*TTcl_Size)(unsafe.Pointer(v18))
	*(*TTcl_Size)(unsafe.Pointer(v18))--
	if v17 <= int64(1) {
		XTclFreeObj(tls, _objPtr4)
	}
	return chan1
}

/*
 *---------------------------------------------------------------------------
 *
 * LoadEncodingFile --
 *
 *	Read a file that describes an encoding and create a new Encoding from
 *	the data.
 *
 * Results:
 *	The return value is the newly loaded Tcl_Encoding or NULL if the file
 *	didn't exist or could not be processed. If NULL is returned and interp
 *	is not NULL, an error message is left in interp's result object.
 *
 * Side effects:
 *	A corresponding encoding file might be read from persistent storage, in
 *	which case LoadTableEncoding is called.
 *
 *---------------------------------------------------------------------------
 */

func _LoadEncodingFile(tls *libc.TLS, interp uintptr, name uintptr) (r TTcl_Encoding) {
	bp := tls.Alloc(272)
	defer tls.Free(272) /* The name of both the encoding file
	 * and the new encoding. */
	var ch int32
	var chan1 TTcl_Channel
	var encoding TTcl_Encoding
	var _ /* ds at bp+0 */ TTcl_DString
	_, _, _ = ch, chan1, encoding
	chan1 = libc.UintptrFromInt32(0)
	encoding = libc.UintptrFromInt32(0)
	chan1 = _OpenEncodingFileChannel(tls, interp, name)
	if chan1 == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	XTcl_SetChannelOption(tls, libc.UintptrFromInt32(0), chan1, __ccgo_ts+19036, __ccgo_ts+29080)
	for int32(1) != 0 {
		XTcl_DStringInit(tls, bp)
		XTcl_Gets(tls, chan1, bp)
		ch = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_DString)(unsafe.Pointer(bp)).Fstring1)))
		XTcl_DStringFree(tls, bp)
		if ch != int32('#') {
			break
		}
	}
	switch ch {
	case int32('S'):
		encoding = _LoadTableEncoding(tls, name, int32(ENCODING_SINGLEBYTE), chan1)
	case int32('D'):
		encoding = _LoadTableEncoding(tls, name, int32(ENCODING_DOUBLEBYTE), chan1)
	case int32('M'):
		encoding = _LoadTableEncoding(tls, name, int32(ENCODING_MULTIBYTE), chan1)
	case int32('E'):
		encoding = _LoadEscapeEncoding(tls, name, chan1)
		break
	}
	if encoding == libc.UintptrFromInt32(0) && interp != libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+29333, libc.VaList(bp+232, name)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+232, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+15139, name, libc.UintptrFromInt32(0)))
	}
	XTcl_CloseEx(tls, libc.UintptrFromInt32(0), chan1, 0)
	return encoding
}

/*
 *-------------------------------------------------------------------------
 *
 * LoadTableEncoding --
 *
 *	Helper function for LoadEncodingFile().  Creates a Tcl_EncodingType
 *	structure along with its corresponding TableEncodingData structure, and
 *	passes it to Tcl_Createncoding.
 *
 *	The file contains binary data but begins with a marker to indicate
 *	byte-ordering so a single binary file can be read on big or
 *	little-endian systems.
 *
 * Results:
 *	Returns the new Tcl_Encoding,  or NULL if it could
 *	not be created because the file contained invalid data.
 *
 * Side effects:
 *	See Tcl_CreateEncoding().
 *
 *-------------------------------------------------------------------------
 */

func _LoadTableEncoding(tls *libc.TLS, name uintptr, type1 int32, chan1 TTcl_Channel) (r TTcl_Encoding) {
	bp := tls.Alloc(544)
	defer tls.Free(544) /* File containing new encoding. */
	var cachePtr, cachePtr1, dataPtr, objPtr, p, p1, page, pageMemPtr, v3, v6 uintptr
	var ch, ch1, fallback, from, hi, i, len1, lo, numPages, symbol, to, v14, v16, v18 int32
	var expected, v5 TTcl_Size
	var size uint32
	var v1, v7 bool
	var _ /* encType at bp+488 */ TTcl_EncodingType
	var _ /* line at bp+224 */ uintptr
	var _ /* lineString at bp+0 */ TTcl_DString
	var _ /* used at bp+232 */ [256]uint8
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, ch, ch1, dataPtr, expected, fallback, from, hi, i, len1, lo, numPages, objPtr, p, p1, page, pageMemPtr, size, symbol, to, v1, v14, v16, v18, v3, v5, v6, v7
	XTcl_DStringInit(tls, bp)
	if XTcl_Gets(tls, chan1, bp) < 0 {
		return libc.UintptrFromInt32(0)
	}
	*(*uintptr)(unsafe.Pointer(bp + 224)) = (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1
	fallback = int32(libc.Xstrtol(tls, *(*uintptr)(unsafe.Pointer(bp + 224)), bp+224, int32(16)))
	symbol = int32(libc.Xstrtol(tls, *(*uintptr)(unsafe.Pointer(bp + 224)), bp+224, int32(10)))
	numPages = int32(libc.Xstrtol(tls, *(*uintptr)(unsafe.Pointer(bp + 224)), bp+224, int32(10)))
	XTcl_DStringFree(tls, bp)
	if numPages < 0 {
		numPages = 0
	} else {
		if numPages > int32(256) {
			numPages = int32(256)
		}
	}
	libc.Xmemset(tls, bp+232, 0, uint64(256))
	dataPtr = XTcl_Alloc(tls, uint64(280))
	libc.Xmemset(tls, dataPtr, 0, uint64(280))
	(*TTableEncodingData)(unsafe.Pointer(dataPtr)).Ffallback = fallback
	/*
	 * Read the table that maps characters to Unicode. Performs a single
	 * malloc to get the memory for the array and all the pages needed by the
	 * array.
	 */
	size = uint32(libc.Uint64FromInt32(256)*libc.Uint64FromInt64(8) + libc.Uint64FromInt32(numPages)*(libc.Uint64FromInt32(256)*libc.Uint64FromInt64(2)))
	(*TTableEncodingData)(unsafe.Pointer(dataPtr)).FtoUnicode = XTcl_Alloc(tls, uint64(size))
	libc.Xmemset(tls, (*TTableEncodingData)(unsafe.Pointer(dataPtr)).FtoUnicode, 0, uint64(size))
	pageMemPtr = (*TTableEncodingData)(unsafe.Pointer(dataPtr)).FtoUnicode + libc.UintptrFromInt32(256)*8
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount++
	i = 0
	for {
		if !(i < numPages) {
			break
		}
		expected = int64(libc.Int32FromInt32(3) + libc.Int32FromInt32(16)*(libc.Int32FromInt32(16)*libc.Int32FromInt32(4)+libc.Int32FromInt32(1)))
		if XTcl_ReadChars(tls, chan1, objPtr, expected, 0) != expected {
			return libc.UintptrFromInt32(0)
		}
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
			v3 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
		}
		p = v3
		hi = libc.Int32FromUint8(_staticHex[*(*uint8)(unsafe.Pointer(p))])<<int32(4) + libc.Int32FromUint8(_staticHex[*(*uint8)(unsafe.Pointer(p + 1))])
		*(*uintptr)(unsafe.Pointer((*TTableEncodingData)(unsafe.Pointer(dataPtr)).FtoUnicode + uintptr(hi)*8)) = pageMemPtr
		p += uintptr(2)
		lo = 0
		for {
			if !(lo < int32(256)) {
				break
			}
			if lo&int32(0x0F) == 0 {
				p++
			}
			ch = libc.Int32FromUint8(_staticHex[*(*uint8)(unsafe.Pointer(p))])<<int32(12) + libc.Int32FromUint8(_staticHex[*(*uint8)(unsafe.Pointer(p + 1))])<<int32(8) + libc.Int32FromUint8(_staticHex[*(*uint8)(unsafe.Pointer(p + 2))])<<int32(4) + libc.Int32FromUint8(_staticHex[*(*uint8)(unsafe.Pointer(p + 3))])
			if ch != 0 {
				(*(*[256]uint8)(unsafe.Pointer(bp + 232)))[ch>>int32(8)] = uint8(1)
			}
			*(*uint16)(unsafe.Pointer(pageMemPtr)) = libc.Uint16FromInt32(ch)
			pageMemPtr += 2
			p += uintptr(4)
			goto _4
		_4:
			;
			lo++
		}
		goto _2
	_2:
		;
		i++
	}
	v6 = objPtr
	v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
	*(*TTcl_Size)(unsafe.Pointer(v6))--
	if !(v5 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(-libc.Int32FromInt32(1))
			if v7 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v7 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v7 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, objPtr)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = objPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, objPtr)
		}
	}
	if type1 == int32(ENCODING_DOUBLEBYTE) {
		libc.Xmemset(tls, dataPtr+4, int32(1), uint64(256))
	} else {
		hi = int32(1)
		for {
			if !(hi < int32(256)) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TTableEncodingData)(unsafe.Pointer(dataPtr)).FtoUnicode + uintptr(hi)*8)) != libc.UintptrFromInt32(0) {
				*(*uint8)(unsafe.Pointer(dataPtr + 4 + uintptr(hi))) = uint8(1)
			}
			goto _8
		_8:
			;
			hi++
		}
	}
	/*
	 * Invert the toUnicode array to produce the fromUnicode array. Performs a
	 * single malloc to get the memory for the array and all the pages needed
	 * by the array. While reading in the toUnicode array remember what
	 * pages are needed for the fromUnicode array.
	 */
	if symbol != 0 {
		(*(*[256]uint8)(unsafe.Pointer(bp + 232)))[0] = uint8(1)
	}
	numPages = 0
	hi = 0
	for {
		if !(hi < int32(256)) {
			break
		}
		if (*(*[256]uint8)(unsafe.Pointer(bp + 232)))[hi] != 0 {
			numPages++
		}
		goto _9
	_9:
		;
		hi++
	}
	size = uint32(libc.Uint64FromInt32(256)*libc.Uint64FromInt64(8) + libc.Uint64FromInt32(numPages)*(libc.Uint64FromInt32(256)*libc.Uint64FromInt64(2)))
	(*TTableEncodingData)(unsafe.Pointer(dataPtr)).FfromUnicode = XTcl_Alloc(tls, uint64(size))
	libc.Xmemset(tls, (*TTableEncodingData)(unsafe.Pointer(dataPtr)).FfromUnicode, 0, uint64(size))
	pageMemPtr = (*TTableEncodingData)(unsafe.Pointer(dataPtr)).FfromUnicode + libc.UintptrFromInt32(256)*8
	hi = 0
	for {
		if !(hi < int32(256)) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TTableEncodingData)(unsafe.Pointer(dataPtr)).FtoUnicode + uintptr(hi)*8)) == libc.UintptrFromInt32(0) {
			*(*uintptr)(unsafe.Pointer((*TTableEncodingData)(unsafe.Pointer(dataPtr)).FtoUnicode + uintptr(hi)*8)) = uintptr(unsafe.Pointer(&_emptyPage))
			goto _10
		}
		lo = 0
		for {
			if !(lo < int32(256)) {
				break
			}
			ch1 = libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TTableEncodingData)(unsafe.Pointer(dataPtr)).FtoUnicode + uintptr(hi)*8)) + uintptr(lo)*2)))
			if ch1 != 0 {
				page = *(*uintptr)(unsafe.Pointer((*TTableEncodingData)(unsafe.Pointer(dataPtr)).FfromUnicode + uintptr(ch1>>int32(8))*8))
				if page == libc.UintptrFromInt32(0) {
					page = pageMemPtr
					pageMemPtr += uintptr(256) * 2
					*(*uintptr)(unsafe.Pointer((*TTableEncodingData)(unsafe.Pointer(dataPtr)).FfromUnicode + uintptr(ch1>>int32(8))*8)) = page
				}
				*(*uint16)(unsafe.Pointer(page + uintptr(ch1&int32(0xFF))*2)) = libc.Uint16FromInt32(hi<<libc.Int32FromInt32(8) + lo)
			}
			goto _11
		_11:
			;
			lo++
		}
		goto _10
	_10:
		;
		hi++
	}
	if type1 == int32(ENCODING_MULTIBYTE) {
		/*
		 * If multibyte encodings don't have a backslash character, define
		 * one. Otherwise, on Windows, native file names don't work because
		 * the backslash in the file name maps to the unknown character
		 * (question mark) when converting from UTF-8 to external encoding.
		 */
		if *(*uintptr)(unsafe.Pointer((*TTableEncodingData)(unsafe.Pointer(dataPtr)).FfromUnicode)) != libc.UintptrFromInt32(0) {
			if libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TTableEncodingData)(unsafe.Pointer(dataPtr)).FfromUnicode)) + uintptr(libc.Int32FromUint8('\\'))*2))) == int32('\000') {
				*(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TTableEncodingData)(unsafe.Pointer(dataPtr)).FfromUnicode)) + uintptr(libc.Int32FromUint8('\\'))*2)) = uint16('\\')
			}
		}
	}
	if symbol != 0 {
		/*
		 * Make a special symbol encoding that maps each symbol character from
		 * its Unicode code point down into page 0, and also ensure that each
		 * characters on page 0 maps to itself so that a symbol font can be
		 * used to display a simple string like "abcd" and have alpha, beta,
		 * chi, delta show up, rather than have "unknown" chars show up because
		 * strictly speaking the symbol font doesn't have glyphs for those low
		 * ASCII chars.
		 */
		page = *(*uintptr)(unsafe.Pointer((*TTableEncodingData)(unsafe.Pointer(dataPtr)).FfromUnicode))
		if page == libc.UintptrFromInt32(0) {
			page = pageMemPtr
			*(*uintptr)(unsafe.Pointer((*TTableEncodingData)(unsafe.Pointer(dataPtr)).FfromUnicode)) = page
		}
		lo = 0
		for {
			if !(lo < int32(256)) {
				break
			}
			if libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TTableEncodingData)(unsafe.Pointer(dataPtr)).FtoUnicode)) + uintptr(lo)*2))) != 0 {
				*(*uint16)(unsafe.Pointer(page + uintptr(lo)*2)) = libc.Uint16FromInt32(lo)
			}
			goto _12
		_12:
			;
			lo++
		}
	}
	hi = 0
	for {
		if !(hi < int32(256)) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TTableEncodingData)(unsafe.Pointer(dataPtr)).FfromUnicode + uintptr(hi)*8)) == libc.UintptrFromInt32(0) {
			*(*uintptr)(unsafe.Pointer((*TTableEncodingData)(unsafe.Pointer(dataPtr)).FfromUnicode + uintptr(hi)*8)) = uintptr(unsafe.Pointer(&_emptyPage))
		}
		goto _13
	_13:
		;
		hi++
	}
	/*
	 * For trailing 'R'everse encoding, see [Patch 689341]
	 */
	XTcl_DStringInit(tls, bp)
	/*
	 * Skip leading empty lines.
	 */
	for {
		v14 = int32(XTcl_Gets(tls, chan1, bp))
		len1 = v14
		if !(v14 == 0) {
			break
		}
		/* empty body */
	}
	if len1 < 0 {
		goto doneParse
	}
	/*
	 * Require that it starts with an 'R'.
	 */
	*(*uintptr)(unsafe.Pointer(bp + 224)) = (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 224))))) != int32('R') {
		goto doneParse
	}
	/*
	 * Read lines until EOF.
	 */
	XTcl_DStringSetLength(tls, bp, 0)
	for {
		v16 = int32(XTcl_Gets(tls, chan1, bp))
		len1 = v16
		if !(v16 != -int32(1)) {
			break
		}
		/*
		 * Skip short lines.
		 */
		if len1 < int32(5) {
			goto _15
		}
		/*
		 * Parse the line as a sequence of hex digits.
		 */
		p1 = (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1
		to = libc.Int32FromUint8(_staticHex[*(*uint8)(unsafe.Pointer(p1))])<<int32(12) + libc.Int32FromUint8(_staticHex[*(*uint8)(unsafe.Pointer(p1 + 1))])<<int32(8) + libc.Int32FromUint8(_staticHex[*(*uint8)(unsafe.Pointer(p1 + 2))])<<int32(4) + libc.Int32FromUint8(_staticHex[*(*uint8)(unsafe.Pointer(p1 + 3))])
		if to == 0 {
			goto _15
		}
		p1 += uintptr(5)
		len1 -= int32(5)
		for {
			if !(len1 >= 0 && *(*uint8)(unsafe.Pointer(p1)) != 0) {
				break
			}
			from = libc.Int32FromUint8(_staticHex[*(*uint8)(unsafe.Pointer(p1))])<<int32(12) + libc.Int32FromUint8(_staticHex[*(*uint8)(unsafe.Pointer(p1 + 1))])<<int32(8) + libc.Int32FromUint8(_staticHex[*(*uint8)(unsafe.Pointer(p1 + 2))])<<int32(4) + libc.Int32FromUint8(_staticHex[*(*uint8)(unsafe.Pointer(p1 + 3))])
			if from == 0 {
				goto _17
			}
			*(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TTableEncodingData)(unsafe.Pointer(dataPtr)).FfromUnicode + uintptr(from>>int32(8))*8)) + uintptr(from&int32(0xFF))*2)) = libc.Uint16FromInt32(to)
			goto _17
		_17:
			;
			p1 += uintptr(5)
			len1 -= int32(5)
		}
		goto _15
	_15:
		;
		XTcl_DStringSetLength(tls, bp, 0)
	}
	goto doneParse
doneParse:
	;
	XTcl_DStringFree(tls, bp)
	/*
	 * Package everything into an encoding structure.
	 */
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp + 488))).FencodingName = name
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp + 488))).FtoUtfProc = __ccgo_fp(_TableToUtfProc)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp + 488))).FfromUtfProc = __ccgo_fp(_TableFromUtfProc)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp + 488))).FfreeProc = __ccgo_fp(_TableFreeProc)
	if type1 == int32(ENCODING_DOUBLEBYTE) {
		v18 = int32(2)
	} else {
		v18 = int32(1)
	}
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp + 488))).FnullSize = int64(v18)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp + 488))).FclientData = dataPtr
	return XTcl_CreateEncoding(tls, bp+488)
}

/*
 * Speed over memory. Use a full 256 character table to decode hex
 * sequences in the encoding files.
 */

var _staticHex = [256]uint8{
	49:  uint8(1),
	50:  uint8(2),
	51:  uint8(3),
	52:  uint8(4),
	53:  uint8(5),
	54:  uint8(6),
	55:  uint8(7),
	56:  uint8(8),
	57:  uint8(9),
	65:  uint8(10),
	66:  uint8(11),
	67:  uint8(12),
	68:  uint8(13),
	69:  uint8(14),
	70:  uint8(15),
	97:  uint8(10),
	98:  uint8(11),
	99:  uint8(12),
	100: uint8(13),
	101: uint8(14),
	102: uint8(15),
	113: uint8(1),
	114: uint8(2),
	115: uint8(3),
	116: uint8(4),
	117: uint8(5),
	118: uint8(6),
	119: uint8(7),
	120: uint8(8),
	121: uint8(9),
}

/*
 *-------------------------------------------------------------------------
 *
 * LoadEscapeEncoding --
 *
 *	Helper function for LoadEncodingTable(). Loads a state machine that
 *	converts between Unicode and some other encoding.
 *
 *	File contains text data that describes the escape sequences that are
 *	used to choose an encoding and the associated names for the
 *	sub-encodings.
 *
 * Results:
 *	The return value is the new encoding, or NULL if the encoding could
 *	not be created (because the file contained invalid data).
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func _LoadEscapeEncoding(tls *libc.TLS, name uintptr, chan1 TTcl_Channel) (r TTcl_Encoding) {
	bp := tls.Alloc(608)
	defer tls.Free(608) /* File containing new encoding. */
	var dataPtr, e, line uintptr
	var i int32
	var size uint32
	var _ /* argc at bp+304 */ TTcl_Size
	var _ /* argv at bp+312 */ uintptr
	var _ /* escapeData at bp+0 */ TTcl_DString
	var _ /* est at bp+544 */ TEscapeSubTable
	var _ /* final at bp+240 */ [16]uint8
	var _ /* init at bp+224 */ [16]uint8
	var _ /* lineString at bp+320 */ TTcl_DString
	var _ /* type at bp+256 */ TTcl_EncodingType
	_, _, _, _, _ = dataPtr, e, i, line, size
	(*(*[16]uint8)(unsafe.Pointer(bp + 224)))[0] = uint8('\000')
	(*(*[16]uint8)(unsafe.Pointer(bp + 240)))[0] = uint8('\000')
	XTcl_DStringInit(tls, bp)
	for int32(1) != 0 {
		XTcl_DStringInit(tls, bp+320)
		if XTcl_Gets(tls, chan1, bp+320) < 0 {
			break
		}
		line = (*TTcl_DString)(unsafe.Pointer(bp + 320)).Fstring1
		if XTcl_SplitList(tls, libc.UintptrFromInt32(0), line, bp+304, bp+312) != TCL_OK {
			XTcl_DStringFree(tls, bp+320)
			continue
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 304)) >= int64(2) {
			if libc.Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 312)))), __ccgo_ts+3726) == 0 {
				/* do nothing */
			} else {
				if libc.Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 312)))), __ccgo_ts+29360) == 0 {
					libc.Xstrncpy(tls, bp+224, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 312)) + 1*8)), uint64(16))
					(*(*[16]uint8)(unsafe.Pointer(bp + 224)))[libc.Uint64FromInt64(16)-libc.Uint64FromInt32(1)] = uint8('\000')
				} else {
					if libc.Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 312)))), __ccgo_ts+29365) == 0 {
						libc.Xstrncpy(tls, bp+240, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 312)) + 1*8)), uint64(16))
						(*(*[16]uint8)(unsafe.Pointer(bp + 240)))[libc.Uint64FromInt64(16)-libc.Uint64FromInt32(1)] = uint8('\000')
					} else {
						libc.Xstrncpy(tls, bp+544+4, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 312)) + 1*8)), uint64(16))
						*(*uint8)(unsafe.Pointer(bp + 544 + 4 + uintptr(libc.Uint64FromInt64(16)-libc.Uint64FromInt32(1)))) = uint8('\000')
						(*(*TEscapeSubTable)(unsafe.Pointer(bp + 544))).FsequenceLen = uint32(libc.Xstrlen(tls, bp+544+4))
						libc.Xstrncpy(tls, bp+544+20, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 312)))), uint64(32))
						*(*uint8)(unsafe.Pointer(bp + 544 + 20 + uintptr(libc.Uint64FromInt64(32)-libc.Uint64FromInt32(1)))) = uint8('\000')
						/*
						 * To avoid infinite recursion in [encoding system iso2022-*]
						 */
						e = XTcl_GetEncoding(tls, libc.UintptrFromInt32(0), bp+544+20)
						if e != libc.UintptrFromInt32(0) && (*TEncoding)(unsafe.Pointer(e)).FtoUtfProc != __ccgo_fp(_TableToUtfProc) && (*TEncoding)(unsafe.Pointer(e)).FtoUtfProc != __ccgo_fp(_Iso88591ToUtfProc) {
							XTcl_FreeEncoding(tls, e)
							e = libc.UintptrFromInt32(0)
						}
						(*(*TEscapeSubTable)(unsafe.Pointer(bp + 544))).FencodingPtr = e
						XTcl_DStringAppend(tls, bp, bp+544, int64(64))
					}
				}
			}
		}
		XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 312)))
		XTcl_DStringFree(tls, bp+320)
	}
	size = uint32(uint64(libc.UintptrFromInt32(0)+304) + libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(bp)).Flength))
	dataPtr = XTcl_Alloc(tls, uint64(size))
	(*TEscapeEncodingData)(unsafe.Pointer(dataPtr)).FinitLen = uint32(libc.Xstrlen(tls, bp+224))
	libc.Xmemcpy(tls, dataPtr+8, bp+224, uint64((*TEscapeEncodingData)(unsafe.Pointer(dataPtr)).FinitLen+uint32(1)))
	(*TEscapeEncodingData)(unsafe.Pointer(dataPtr)).FfinalLen = uint32(libc.Xstrlen(tls, bp+240))
	libc.Xmemcpy(tls, dataPtr+28, bp+240, uint64((*TEscapeEncodingData)(unsafe.Pointer(dataPtr)).FfinalLen+uint32(1)))
	(*TEscapeEncodingData)(unsafe.Pointer(dataPtr)).FnumSubTables = libc.Int32FromUint64(libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(bp)).Flength) / uint64(64))
	libc.Xmemcpy(tls, dataPtr+304, (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1, libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(bp)).Flength))
	XTcl_DStringFree(tls, bp)
	libc.Xmemset(tls, dataPtr+44, 0, uint64(256))
	i = 0
	for {
		if !(i < (*TEscapeEncodingData)(unsafe.Pointer(dataPtr)).FnumSubTables) {
			break
		}
		*(*uint8)(unsafe.Pointer(dataPtr + 44 + uintptr(*(*uint8)(unsafe.Pointer(dataPtr + 304 + uintptr(i)*64 + 4))))) = uint8(1)
		goto _1
	_1:
		;
		i++
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dataPtr + 8))) != int32('\000') {
		*(*uint8)(unsafe.Pointer(dataPtr + 44 + uintptr(*(*uint8)(unsafe.Pointer(dataPtr + 8))))) = uint8(1)
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dataPtr + 28))) != int32('\000') {
		*(*uint8)(unsafe.Pointer(dataPtr + 44 + uintptr(*(*uint8)(unsafe.Pointer(dataPtr + 28))))) = uint8(1)
	}
	/*
	 * Package everything into an encoding structure.
	 */
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp + 256))).FencodingName = name
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp + 256))).FtoUtfProc = __ccgo_fp(_EscapeToUtfProc)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp + 256))).FfromUtfProc = __ccgo_fp(_EscapeFromUtfProc)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp + 256))).FfreeProc = __ccgo_fp(_EscapeFreeProc)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp + 256))).FnullSize = int64(1)
	(*(*TTcl_EncodingType)(unsafe.Pointer(bp + 256))).FclientData = dataPtr
	return XTcl_CreateEncoding(tls, bp+256)
}

/*
 *-------------------------------------------------------------------------
 *
 * BinaryProc --
 *
 *	The default conversion when no other conversion is specified. No
 *	translation is done; source bytes are copied directly to destination
 *	bytes.
 *
 * Results:
 *	Returns TCL_OK if conversion was successful.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func _BinaryProc(tls *libc.TLS, dummy2363 uintptr, src uintptr, srcLen int32, flags int32, dummy2367 uintptr, dst uintptr, dstLen int32, srcReadPtr uintptr, dstWrotePtr uintptr, dstCharsPtr uintptr) (r int32) {
	/* Filled with the number of characters that
	 * correspond to the bytes stored in the
	 * output buffer. */
	var result int32
	_ = result
	result = TCL_OK
	dstLen -= libc.Int32FromInt32(TCL_UTF_MAX) - libc.Int32FromInt32(1)
	if dstLen < 0 {
		dstLen = 0
	}
	if flags&int32(TCL_ENCODING_CHAR_LIMIT) != 0 && srcLen > *(*int32)(unsafe.Pointer(dstCharsPtr)) {
		srcLen = *(*int32)(unsafe.Pointer(dstCharsPtr))
	}
	if srcLen > dstLen {
		srcLen = dstLen
		result = -int32(4)
	}
	*(*int32)(unsafe.Pointer(srcReadPtr)) = srcLen
	*(*int32)(unsafe.Pointer(dstWrotePtr)) = srcLen
	*(*int32)(unsafe.Pointer(dstCharsPtr)) = srcLen
	libc.Xmemcpy(tls, dst, src, libc.Uint64FromInt32(srcLen))
	return result
}

/*
 *-------------------------------------------------------------------------
 *
 * UtfToUtfProc --
 *
 *	Converts from UTF-8 to UTF-8. Note that the UTF-8 to UTF-8 translation
 *	is not a no-op, because it turns a stream of improperly formed
 *	UTF-8 into a properly-formed stream.
 *
 * Results:
 *	Returns TCL_OK if conversion was successful.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func _UtfToUtfProc(tls *libc.TLS, clientData uintptr, src uintptr, srcLen int32, flags int32, statePtr uintptr, dst uintptr, dstLen int32, srcReadPtr uintptr, dstWrotePtr uintptr, dstCharsPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Filled with the number of characters that
	 * correspond to the bytes stored in the
	 * output buffer. */
	var charLimit, numChars, profile, result, v1, v16, v17, v18, v19, v6 int32
	var dstEnd, dstStart, saveSrc, srcClose, srcEnd, srcStart, v10, v11, v12, v13, v14, v15, v3, v4, v5, v7 uintptr
	var high, high1, high2, high3, savedSurrogate TTcl_UniChar
	var len1 Tsize_t
	var v9 int64
	var _ /* ch at bp+0 */ int32
	var _ /* chbuf at bp+4 */ [2]uint8
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = charLimit, dstEnd, dstStart, high, high1, high2, high3, len1, numChars, profile, result, saveSrc, savedSurrogate, srcClose, srcEnd, srcStart, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v3, v4, v5, v6, v7, v9
	charLimit = int32(INT_MAX)
	if flags&int32(TCL_ENCODING_START) != 0 {
		/* *statePtr will hold high surrogate in a split surrogate pair */
		*(*TTcl_EncodingState)(unsafe.Pointer(statePtr)) = uintptr(0)
	}
	result = TCL_OK
	srcStart = src
	srcEnd = src + uintptr(srcLen)
	srcClose = srcEnd
	if flags&int32(TCL_ENCODING_END) == 0 {
		srcClose -= uintptr(6)
	}
	if flags&int32(TCL_ENCODING_CHAR_LIMIT) != 0 {
		charLimit = *(*int32)(unsafe.Pointer(dstCharsPtr))
	}
	dstStart = dst
	flags = int32(int64(flags) | int64(clientData))
	/*
	 * If output is UTF-8 or encoding for Tcl's internal encoding,
	 * max space needed is TCL_UTF_MAX. Otherwise, need 6 bytes (CESU-8)
	 */
	if flags&(int32(ENCODING_INPUT)|int32(ENCODING_UTF)) != 0 {
		v1 = int32(TCL_UTF_MAX)
	} else {
		v1 = int32(6)
	}
	dstEnd = dst + uintptr(dstLen) - uintptr(v1)
	/*
	 * Macro to output an isolated high surrogate when it is not followed
	 * by a low surrogate. NOT to be called for strict profile since
	 * that should raise an error.
	 */
	/*
	 * Macro to check for isolated surrogate and either break with
	 * an error if profile is strict, or output an appropriate
	 * character for replace and tcl8 profiles and continue.
	 */
	profile = libc.Int32FromUint32(libc.Uint32FromInt32(flags) & libc.Uint32FromUint32(ENCODING_PROFILE_MASK))
	numChars = 0
	for {
		if !(src < srcEnd && numChars <= charLimit) {
			break
		}
		if src > srcClose && !(XTcl_UtfCharComplete(tls, src, int64(srcEnd)-int64(src)) != 0) {
			/*
			 * If there is more string to follow, this will ensure that the
			 * last UTF-8 character in the source buffer hasn't been cut off.
			 */
			result = -int32(1)
			break
		}
		if dst > dstEnd {
			result = -int32(4)
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) < int32(0x80) && !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) == 0 && flags&int32(ENCODING_INPUT) != 0) {
			if *(*TTcl_EncodingState)(unsafe.Pointer(statePtr)) != 0 {
				if !(libc.Uint32FromInt32(profile)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8)) && !(libc.Uint32FromInt32(profile)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_REPLACE)) {
					result = -int32(2)
					break
				}
				if libc.Uint32FromInt32(profile)&uint32(ENCODING_PROFILE_MASK) == uint32(TCL_ENCODING_PROFILE_REPLACE) {
					high = int32(UNICODE_REPLACE_CHAR)
				} else {
					high = int32(int64(*(*TTcl_EncodingState)(unsafe.Pointer(statePtr))))
				}
				dst += uintptr(XTcl_UniCharToUtf(tls, high, dst))
				*(*TTcl_EncodingState)(unsafe.Pointer(statePtr)) = uintptr(0) /* Reset state */
				goto _2                                                       /* Rerun loop so length checks etc. repeated */
			} else {
			}
			/*
			 * Copy 7bit characters, but skip null-bytes when we are in input
			 * mode, so that they get converted to \xC0\x80.
			 */
			v3 = dst
			dst++
			v4 = src
			src++
			*(*uint8)(unsafe.Pointer(v3)) = *(*uint8)(unsafe.Pointer(v4))
		} else {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) == int32(0xC0) && src+uintptr(1) < srcEnd && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1))) == int32(0x80) && (!(flags&int32(ENCODING_INPUT) != 0) || !(libc.Uint32FromInt32(profile)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8))) {
				/* Special sequence \xC0\x80 */
				if *(*TTcl_EncodingState)(unsafe.Pointer(statePtr)) != 0 {
					if !(libc.Uint32FromInt32(profile)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8)) && !(libc.Uint32FromInt32(profile)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_REPLACE)) {
						result = -int32(2)
						break
					}
					if libc.Uint32FromInt32(profile)&uint32(ENCODING_PROFILE_MASK) == uint32(TCL_ENCODING_PROFILE_REPLACE) {
						high1 = int32(UNICODE_REPLACE_CHAR)
					} else {
						high1 = int32(int64(*(*TTcl_EncodingState)(unsafe.Pointer(statePtr))))
					}
					dst += uintptr(XTcl_UniCharToUtf(tls, high1, dst))
					*(*TTcl_EncodingState)(unsafe.Pointer(statePtr)) = uintptr(0) /* Reset state */
					goto _2                                                       /* Rerun loop so length checks etc. repeated */
				} else {
				}
				if !(libc.Uint32FromInt32(profile)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8)) && flags&int32(ENCODING_INPUT) != 0 {
					if libc.Uint32FromInt32(profile)&uint32(ENCODING_PROFILE_MASK) == uint32(TCL_ENCODING_PROFILE_REPLACE) {
						dst += uintptr(XTcl_UniCharToUtf(tls, int32(UNICODE_REPLACE_CHAR), dst))
						src += uintptr(2)
					} else {
						/* PROFILE_STRICT */
						result = -int32(2)
						break
					}
				} else {
					/*
					 * Convert 0xC080 to real nulls when we are in output mode,
					 * irrespective of the profile.
					 */
					v5 = dst
					dst++
					*(*uint8)(unsafe.Pointer(v5)) = uint8(0)
					src += uintptr(2)
				}
			} else {
				if !(XTcl_UtfCharComplete(tls, src, int64(srcEnd)-int64(src)) != 0) {
					/*
					 * Incomplete byte sequence not because there are insufficient
					 * bytes in source buffer (have already checked that above) but
					 * because the UTF-8 sequence is truncated.
					 */
					if *(*TTcl_EncodingState)(unsafe.Pointer(statePtr)) != 0 {
						if !(libc.Uint32FromInt32(profile)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8)) && !(libc.Uint32FromInt32(profile)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_REPLACE)) {
							result = -int32(2)
							break
						}
						if libc.Uint32FromInt32(profile)&uint32(ENCODING_PROFILE_MASK) == uint32(TCL_ENCODING_PROFILE_REPLACE) {
							high2 = int32(UNICODE_REPLACE_CHAR)
						} else {
							high2 = int32(int64(*(*TTcl_EncodingState)(unsafe.Pointer(statePtr))))
						}
						dst += uintptr(XTcl_UniCharToUtf(tls, high2, dst))
						*(*TTcl_EncodingState)(unsafe.Pointer(statePtr)) = uintptr(0) /* Reset state */
						goto _2                                                       /* Rerun loop so length checks etc. repeated */
					} else {
					}
					if flags&int32(ENCODING_INPUT) != 0 {
						/* Incomplete bytes for modified UTF-8 target */
						if !(libc.Uint32FromInt32(profile)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8)) && !(libc.Uint32FromInt32(profile)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_REPLACE)) {
							if flags&int32(TCL_ENCODING_CHAR_LIMIT) != 0 {
								v6 = -int32(1)
							} else {
								v6 = -int32(2)
							}
							result = v6
							break
						}
					}
					if libc.Uint32FromInt32(profile)&uint32(ENCODING_PROFILE_MASK) == uint32(TCL_ENCODING_PROFILE_REPLACE) {
						*(*int32)(unsafe.Pointer(bp)) = int32(UNICODE_REPLACE_CHAR)
						src++
					} else {
						v7 = src
						src++
						(*(*[2]uint8)(unsafe.Pointer(bp + 4)))[0] = *(*uint8)(unsafe.Pointer(v7))
						(*(*[2]uint8)(unsafe.Pointer(bp + 4)))[int32(1)] = uint8(0)
						if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 4))) < int32(0x80) {
							*(*int32)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 4)))
							_ = libc.Int32FromInt32(1)
						} else {
							XTcl_UtfToUniChar(tls, bp+4, bp)
						}
					}
					dst += uintptr(XTcl_UniCharToUtf(tls, *(*int32)(unsafe.Pointer(bp)), dst))
				} else {
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) < int32(0x80) {
						*(*int32)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))
						v9 = int64(libc.Int32FromInt32(1))
					} else {
						v9 = XTcl_UtfToUniChar(tls, src, bp)
					}
					/* Have a complete character */
					len1 = libc.Uint64FromInt64(v9)
					savedSurrogate = int32(int64(*(*TTcl_EncodingState)(unsafe.Pointer(statePtr))))
					*(*TTcl_EncodingState)(unsafe.Pointer(statePtr)) = uintptr(0) /* Reset surrogate */
					if flags&int32(ENCODING_INPUT) != 0 {
						if len1 < uint64(2) && *(*int32)(unsafe.Pointer(bp)) != 0 || *(*int32)(unsafe.Pointer(bp)) > int32(0xFFFF) && !(flags&int32(ENCODING_UTF) != 0) {
							if !(libc.Uint32FromInt32(profile)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8)) && !(libc.Uint32FromInt32(profile)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_REPLACE)) {
								result = -int32(2)
								break
							} else {
								if libc.Uint32FromInt32(profile)&uint32(ENCODING_PROFILE_MASK) == uint32(TCL_ENCODING_PROFILE_REPLACE) {
									*(*int32)(unsafe.Pointer(bp)) = int32(UNICODE_REPLACE_CHAR)
								}
							}
						}
					}
					saveSrc = src
					src += uintptr(len1)
					if !(flags&int32(ENCODING_UTF) != 0) && !(flags&int32(ENCODING_INPUT) != 0) && *(*int32)(unsafe.Pointer(bp)) > int32(0x7FF) {
						/* Since this flag combo
						will never set *statePtr */
						if *(*int32)(unsafe.Pointer(bp)) > int32(0xFFFF) {
							/* CESU-8 6-byte sequence for chars > U+FFFF */
							*(*int32)(unsafe.Pointer(bp)) -= int32(0x10000)
							v10 = dst
							dst++
							*(*uint8)(unsafe.Pointer(v10)) = uint8(0xED)
							v11 = dst
							dst++
							*(*uint8)(unsafe.Pointer(v11)) = libc.Uint8FromInt32(*(*int32)(unsafe.Pointer(bp))>>libc.Int32FromInt32(16)&libc.Int32FromInt32(0x0F) | libc.Int32FromInt32(0xA0))
							v12 = dst
							dst++
							*(*uint8)(unsafe.Pointer(v12)) = libc.Uint8FromInt32(*(*int32)(unsafe.Pointer(bp))>>libc.Int32FromInt32(10)&libc.Int32FromInt32(0x3F) | libc.Int32FromInt32(0x80))
							*(*int32)(unsafe.Pointer(bp)) = *(*int32)(unsafe.Pointer(bp))&int32(0x03FF) | int32(0xDC00)
						}
						v13 = dst
						dst++
						*(*uint8)(unsafe.Pointer(v13)) = libc.Uint8FromInt32((*(*int32)(unsafe.Pointer(bp))>>libc.Int32FromInt32(12) | libc.Int32FromInt32(0xE0)) & libc.Int32FromInt32(0xEF))
						v14 = dst
						dst++
						*(*uint8)(unsafe.Pointer(v14)) = libc.Uint8FromInt32((*(*int32)(unsafe.Pointer(bp))>>libc.Int32FromInt32(6) | libc.Int32FromInt32(0x80)) & libc.Int32FromInt32(0xBF))
						v15 = dst
						dst++
						*(*uint8)(unsafe.Pointer(v15)) = libc.Uint8FromInt32((*(*int32)(unsafe.Pointer(bp)) | libc.Int32FromInt32(0x80)) & libc.Int32FromInt32(0xBF))
						goto _2
					} else {
						if *(*int32)(unsafe.Pointer(bp)) & ^libc.Int32FromInt32(0x7FF) == int32(0xD800) {
							if flags&int32(ENCODING_UTF) != 0 {
								/* UTF-8, not CESU-8, so surrogates should not appear */
								if !(libc.Uint32FromInt32(profile)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8)) && !(libc.Uint32FromInt32(profile)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_REPLACE)) {
									if flags&int32(ENCODING_INPUT) != 0 {
										v16 = -int32(2)
									} else {
										v16 = -int32(3)
									}
									result = v16
									src = saveSrc
									break
								} else {
									if libc.Uint32FromInt32(profile)&uint32(ENCODING_PROFILE_MASK) == uint32(TCL_ENCODING_PROFILE_REPLACE) {
										*(*int32)(unsafe.Pointer(bp)) = int32(UNICODE_REPLACE_CHAR)
									} else {
										/* PROFILE_TCL8 - output as is */
									}
								}
							} else {
								/* CESU-8 */
								if *(*int32)(unsafe.Pointer(bp)) & ^libc.Int32FromInt32(0x3FF) == int32(0xDC00) {
									if savedSurrogate != 0 {
										*(*int32)(unsafe.Pointer(bp)) = int32(0x10000) + (savedSurrogate-int32(0xd800))<<int32(10) + (*(*int32)(unsafe.Pointer(bp)) - int32(0xdc00))
									} else {
										/* Isolated low surrogate */
										if !(libc.Uint32FromInt32(profile)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8)) && !(libc.Uint32FromInt32(profile)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_REPLACE)) {
											if flags&int32(ENCODING_INPUT) != 0 {
												v17 = -int32(2)
											} else {
												v17 = -int32(3)
											}
											result = v17
											src = saveSrc
											break
										} else {
											if libc.Uint32FromInt32(profile)&uint32(ENCODING_PROFILE_MASK) == uint32(TCL_ENCODING_PROFILE_REPLACE) {
												*(*int32)(unsafe.Pointer(bp)) = int32(UNICODE_REPLACE_CHAR)
											} else {
												/* Tcl8 profile. Output low surrogate as is */
											}
										}
									}
								} else {
									/* Save the high surrogate */
									*(*TTcl_EncodingState)(unsafe.Pointer(statePtr)) = uintptr(int64(*(*int32)(unsafe.Pointer(bp))))
									if savedSurrogate != 0 {
										if !(libc.Uint32FromInt32(profile)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8)) && !(libc.Uint32FromInt32(profile)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_REPLACE)) {
											if flags&int32(ENCODING_INPUT) != 0 {
												v18 = -int32(2)
											} else {
												v18 = -int32(3)
											}
											result = v18
											src = saveSrc
											break
										} else {
											if libc.Uint32FromInt32(profile)&uint32(ENCODING_PROFILE_MASK) == uint32(TCL_ENCODING_PROFILE_REPLACE) {
												*(*int32)(unsafe.Pointer(bp)) = int32(UNICODE_REPLACE_CHAR)
											} else {
												/* Output the isolated high surrogate */
												*(*int32)(unsafe.Pointer(bp)) = savedSurrogate
											}
										}
									} else {
										/* High surrogate saved in *statePtr. Do not output anything just yet. */
										numChars-- /* Cancel the increment at end of loop */
										goto _2
									}
								}
							}
						} else {
							/* Normal character */
							if *(*TTcl_EncodingState)(unsafe.Pointer(statePtr)) != 0 {
								if !(libc.Uint32FromInt32(profile)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8)) && !(libc.Uint32FromInt32(profile)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_REPLACE)) {
									result = -int32(2)
									break
								}
								if libc.Uint32FromInt32(profile)&uint32(ENCODING_PROFILE_MASK) == uint32(TCL_ENCODING_PROFILE_REPLACE) {
									high3 = int32(UNICODE_REPLACE_CHAR)
								} else {
									high3 = int32(int64(*(*TTcl_EncodingState)(unsafe.Pointer(statePtr))))
								}
								dst += uintptr(XTcl_UniCharToUtf(tls, high3, dst))
								*(*TTcl_EncodingState)(unsafe.Pointer(statePtr)) = uintptr(0) /* Reset state */
								goto _2                                                       /* Rerun loop so length checks etc. repeated */
							} else {
							}
						}
					}
					dst += uintptr(XTcl_UniCharToUtf(tls, *(*int32)(unsafe.Pointer(bp)), dst))
				}
			}
		}
		goto _2
	_2:
		;
		numChars++
	}
	/* Check if an high surrogate left over */
	if *(*TTcl_EncodingState)(unsafe.Pointer(statePtr)) != 0 {
		/* CESU-8, Not UTF-8 */
		if !(flags&libc.Int32FromInt32(TCL_ENCODING_END) != 0) {
			/* More data coming */
		} else {
			/* No more data coming */
			if !(libc.Uint32FromInt32(profile)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8)) && !(libc.Uint32FromInt32(profile)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_REPLACE)) {
				if flags&int32(ENCODING_INPUT) != 0 {
					v19 = -int32(2)
				} else {
					v19 = -int32(3)
				}
				result = v19
			} else {
				if libc.Uint32FromInt32(profile)&uint32(ENCODING_PROFILE_MASK) == uint32(TCL_ENCODING_PROFILE_REPLACE) {
					*(*int32)(unsafe.Pointer(bp)) = int32(UNICODE_REPLACE_CHAR)
				} else {
					*(*int32)(unsafe.Pointer(bp)) = int32(int64(*(*TTcl_EncodingState)(unsafe.Pointer(statePtr))))
				}
				if dst < dstEnd {
					dst += uintptr(XTcl_UniCharToUtf(tls, *(*int32)(unsafe.Pointer(bp)), dst))
					numChars++
				} else {
					/* No room in destination */
					result = -int32(4)
				}
			}
		}
	}
	*(*int32)(unsafe.Pointer(srcReadPtr)) = int32(int64(src) - int64(srcStart))
	*(*int32)(unsafe.Pointer(dstWrotePtr)) = int32(int64(dst) - int64(dstStart))
	*(*int32)(unsafe.Pointer(dstCharsPtr)) = numChars
	return result
}

/*
 *-------------------------------------------------------------------------
 *
 * Utf32ToUtfProc --
 *
 *	Convert from UTF-32 to UTF-8.
 *
 * Results:
 *	Returns TCL_OK if conversion was successful.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func _Utf32ToUtfProc(tls *libc.TLS, clientData uintptr, src uintptr, srcLen int32, flags int32, dummy2747 uintptr, dst uintptr, dstLen int32, srcReadPtr uintptr, dstWrotePtr uintptr, dstCharsPtr uintptr) (r int32) {
	/* Filled with the number of characters that
	 * correspond to the bytes stored in the
	 * output buffer. */
	var bytesLeft, ch, charLimit, numChars, result int32
	var dstEnd, dstStart, srcEnd, srcStart, v2 uintptr
	_, _, _, _, _, _, _, _, _, _ = bytesLeft, ch, charLimit, dstEnd, dstStart, numChars, result, srcEnd, srcStart, v2
	charLimit = int32(INT_MAX)
	ch = 0
	bytesLeft = srcLen % int32(4)
	flags = int32(int64(flags) | int64(clientData))
	if flags&int32(TCL_ENCODING_CHAR_LIMIT) != 0 {
		charLimit = *(*int32)(unsafe.Pointer(dstCharsPtr))
	}
	result = TCL_OK
	/*
	 * Check alignment with utf-32 (4 == sizeof(UTF-32))
	 */
	if bytesLeft != 0 {
		/* We have a truncated code unit */
		result = -int32(1)
		srcLen -= bytesLeft
	}
	srcStart = src
	srcEnd = src + uintptr(srcLen)
	dstStart = dst
	dstEnd = dst + uintptr(dstLen) - uintptr(TCL_UTF_MAX)
	numChars = 0
	for {
		if !(src < srcEnd && numChars <= charLimit) {
			break
		}
		if dst > dstEnd {
			result = -int32(4)
			break
		}
		if flags&int32(TCL_ENCODING_LE) != 0 {
			ch = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 3)))&libc.Int32FromInt32(0xFF))<<int32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 2)))&int32(0xFF)<<int32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1)))&int32(0xFF)<<int32(8)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))&libc.Int32FromInt32(0xFF)))
		} else {
			ch = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))&libc.Int32FromInt32(0xFF))<<int32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1)))&int32(0xFF)<<int32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 2)))&int32(0xFF)<<int32(8)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 3)))&libc.Int32FromInt32(0xFF)))
		}
		if libc.Uint32FromInt32(ch) > uint32(0x10FFFF) {
			if !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8)) && !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_REPLACE)) {
				result = -int32(2)
				break
			}
			ch = int32(UNICODE_REPLACE_CHAR)
		} else {
			if ch & ^libc.Int32FromInt32(0x7FF) == int32(0xD800) {
				if !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8)) && !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_REPLACE)) {
					result = -int32(2)
					break
				}
				if libc.Uint32FromInt32(flags)&uint32(ENCODING_PROFILE_MASK) == uint32(TCL_ENCODING_PROFILE_REPLACE) {
					ch = int32(UNICODE_REPLACE_CHAR)
				}
			}
		}
		/*
		 * Special case for 1-byte utf chars for speed. Make sure we work with
		 * unsigned short-size data.
		 */
		if libc.Uint32FromInt32(ch)-uint32(1) < uint32(0x7F) {
			v2 = dst
			dst++
			*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(ch & libc.Int32FromInt32(0xFF))
		} else {
			dst += uintptr(XTcl_UniCharToUtf(tls, ch, dst))
		}
		src += uintptr(4)
		goto _1
	_1:
		;
		numChars++
	}
	if flags&int32(TCL_ENCODING_END) != 0 && result == -int32(1) {
		/* We have a code fragment left-over at the end */
		if dst > dstEnd {
			result = -int32(4)
		} else {
			/* destination is not full, so we really are at the end now */
			if !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8)) && !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_REPLACE)) {
				result = -int32(2)
			} else {
				/* PROFILE_REPLACE or PROFILE_TCL8 */
				result = TCL_OK
				dst += uintptr(XTcl_UniCharToUtf(tls, int32(UNICODE_REPLACE_CHAR), dst))
				numChars++
				src += uintptr(bytesLeft) /* Go past truncated code unit */
			}
		}
	}
	*(*int32)(unsafe.Pointer(srcReadPtr)) = int32(int64(src) - int64(srcStart))
	*(*int32)(unsafe.Pointer(dstWrotePtr)) = int32(int64(dst) - int64(dstStart))
	*(*int32)(unsafe.Pointer(dstCharsPtr)) = numChars
	return result
}

/*
 *-------------------------------------------------------------------------
 *
 * UtfToUtf32Proc --
 *
 *	Convert from UTF-8 to UTF-32.
 *
 * Results:
 *	Returns TCL_OK if conversion was successful.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func _UtfToUtf32Proc(tls *libc.TLS, clientData uintptr, src uintptr, srcLen int32, flags int32, dummy2878 uintptr, dst uintptr, dstLen int32, srcReadPtr uintptr, dstWrotePtr uintptr, dstCharsPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Filled with the number of characters that
	 * correspond to the bytes stored in the
	 * output buffer. */
	var dstEnd, dstStart, srcClose, srcEnd, srcStart, v10, v3, v4, v5, v6, v7, v8, v9 uintptr
	var len1, numChars, result int32
	var v2 int64
	var _ /* ch at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = dstEnd, dstStart, len1, numChars, result, srcClose, srcEnd, srcStart, v10, v2, v3, v4, v5, v6, v7, v8, v9
	srcStart = src
	srcEnd = src + uintptr(srcLen)
	srcClose = srcEnd
	if flags&int32(TCL_ENCODING_END) == 0 {
		srcClose -= uintptr(TCL_UTF_MAX)
	}
	dstStart = dst
	dstEnd = dst + uintptr(dstLen) - uintptr(4)
	flags = int32(int64(flags) | int64(clientData))
	result = TCL_OK
	numChars = 0
	for {
		if !(src < srcEnd) {
			break
		}
		if src > srcClose && !(XTcl_UtfCharComplete(tls, src, int64(srcEnd)-int64(src)) != 0) {
			/*
			 * If there is more string to follow, this will ensure that the
			 * last UTF-8 character in the source buffer hasn't been cut off.
			 */
			result = -int32(1)
			break
		}
		if dst > dstEnd {
			result = -int32(4)
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) < int32(0x80) {
			*(*int32)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))
			v2 = int64(libc.Int32FromInt32(1))
		} else {
			v2 = XTcl_UtfToUniChar(tls, src, bp)
		}
		len1 = int32(v2)
		if *(*int32)(unsafe.Pointer(bp)) & ^libc.Int32FromInt32(0x7FF) == int32(0xD800) {
			if !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8)) && !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_REPLACE)) {
				result = -int32(3)
				break
			}
			if libc.Uint32FromInt32(flags)&uint32(ENCODING_PROFILE_MASK) == uint32(TCL_ENCODING_PROFILE_REPLACE) {
				*(*int32)(unsafe.Pointer(bp)) = int32(UNICODE_REPLACE_CHAR)
			}
		}
		src += uintptr(len1)
		if flags&int32(TCL_ENCODING_LE) != 0 {
			v3 = dst
			dst++
			*(*uint8)(unsafe.Pointer(v3)) = libc.Uint8FromInt32(*(*int32)(unsafe.Pointer(bp)) & libc.Int32FromInt32(0xFF))
			v4 = dst
			dst++
			*(*uint8)(unsafe.Pointer(v4)) = libc.Uint8FromInt32(*(*int32)(unsafe.Pointer(bp)) >> libc.Int32FromInt32(8) & libc.Int32FromInt32(0xFF))
			v5 = dst
			dst++
			*(*uint8)(unsafe.Pointer(v5)) = libc.Uint8FromInt32(*(*int32)(unsafe.Pointer(bp)) >> libc.Int32FromInt32(16) & libc.Int32FromInt32(0xFF))
			v6 = dst
			dst++
			*(*uint8)(unsafe.Pointer(v6)) = libc.Uint8FromInt32(*(*int32)(unsafe.Pointer(bp)) >> libc.Int32FromInt32(24) & libc.Int32FromInt32(0xFF))
		} else {
			v7 = dst
			dst++
			*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32(*(*int32)(unsafe.Pointer(bp)) >> libc.Int32FromInt32(24) & libc.Int32FromInt32(0xFF))
			v8 = dst
			dst++
			*(*uint8)(unsafe.Pointer(v8)) = libc.Uint8FromInt32(*(*int32)(unsafe.Pointer(bp)) >> libc.Int32FromInt32(16) & libc.Int32FromInt32(0xFF))
			v9 = dst
			dst++
			*(*uint8)(unsafe.Pointer(v9)) = libc.Uint8FromInt32(*(*int32)(unsafe.Pointer(bp)) >> libc.Int32FromInt32(8) & libc.Int32FromInt32(0xFF))
			v10 = dst
			dst++
			*(*uint8)(unsafe.Pointer(v10)) = libc.Uint8FromInt32(*(*int32)(unsafe.Pointer(bp)) & libc.Int32FromInt32(0xFF))
		}
		goto _1
	_1:
		;
		numChars++
	}
	*(*int32)(unsafe.Pointer(srcReadPtr)) = int32(int64(src) - int64(srcStart))
	*(*int32)(unsafe.Pointer(dstWrotePtr)) = int32(int64(dst) - int64(dstStart))
	*(*int32)(unsafe.Pointer(dstCharsPtr)) = numChars
	return result
}

/*
 *-------------------------------------------------------------------------
 *
 * Utf16ToUtfProc --
 *
 *	Convert from UTF-16 to UTF-8.
 *
 * Results:
 *	Returns TCL_OK if conversion was successful.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func _Utf16ToUtfProc(tls *libc.TLS, clientData uintptr, src uintptr, srcLen int32, flags int32, dummy2977 uintptr, dst uintptr, dstLen int32, srcReadPtr uintptr, dstWrotePtr uintptr, dstCharsPtr uintptr) (r int32) {
	/* Filled with the number of characters that
	 * correspond to the bytes stored in the
	 * output buffer. */
	var ch, prev uint16
	var charLimit, numChars, result int32
	var dstEnd, dstStart, srcEnd, srcStart, v2 uintptr
	_, _, _, _, _, _, _, _, _, _ = ch, charLimit, dstEnd, dstStart, numChars, prev, result, srcEnd, srcStart, v2
	charLimit = int32(INT_MAX)
	ch = uint16(0)
	flags = int32(int64(flags) | int64(clientData))
	if flags&int32(TCL_ENCODING_CHAR_LIMIT) != 0 {
		charLimit = *(*int32)(unsafe.Pointer(dstCharsPtr))
	}
	result = TCL_OK
	/*
	 * Check alignment with utf-16 (2 == sizeof(UTF-16))
	 */
	if srcLen%int32(2) != 0 {
		result = -int32(1)
		srcLen--
	}
	srcStart = src
	srcEnd = src + uintptr(srcLen)
	dstStart = dst
	dstEnd = dst + uintptr(dstLen) - uintptr(TCL_UTF_MAX)
	numChars = 0
	for {
		if !(src < srcEnd && numChars <= charLimit) {
			break
		}
		if dst > dstEnd && !(libc.Int32FromUint16(ch) & ^libc.Int32FromInt32(0x3FF) == libc.Int32FromInt32(0xD800)) {
			result = -int32(4)
			break
		}
		prev = ch
		if flags&int32(TCL_ENCODING_LE) != 0 {
			ch = libc.Uint16FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1)))&int32(0xFF)<<int32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))&int32(0xFF))
		} else {
			ch = libc.Uint16FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))&int32(0xFF)<<int32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1)))&int32(0xFF))
		}
		if libc.Int32FromUint16(prev) & ^libc.Int32FromInt32(0x3FF) == int32(0xD800) {
			if libc.Int32FromUint16(ch) & ^libc.Int32FromInt32(0x3FF) == int32(0xDC00) {
				/*
				 * High surrogate was followed by a low surrogate.
				 * Tcl_UniCharToUtf would have stashed away the state in dst.
				 * Call it again to combine that state with the low surrogate.
				 * We also have to compensate the numChars as two UTF-16 units
				 * have been combined into one character.
				 */
				dst += uintptr(XTcl_UniCharToUtf(tls, libc.Int32FromUint16(ch)|int32(TCL_COMBINE), dst))
			} else {
				/* High surrogate was not followed by a low surrogate */
				if !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8)) && !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_REPLACE)) {
					result = -int32(2)
					src -= uintptr(2) /* Go back to beginning of high surrogate */
					dst--             /* Also undo writing a single byte too much */
					break
				}
				if libc.Uint32FromInt32(flags)&uint32(ENCODING_PROFILE_MASK) == uint32(TCL_ENCODING_PROFILE_REPLACE) {
					/*
					 * Previous loop wrote a single byte to mark the high surrogate.
					 * Replace it with the replacement character.
					 */
					ch = uint16(UNICODE_REPLACE_CHAR)
					dst--
					numChars++
					dst += uintptr(XTcl_UniCharToUtf(tls, libc.Int32FromUint16(ch), dst))
				} else {
					/*
					 * Bug [10c2c17c32]. If Hi surrogate not followed by Lo
					 * surrogate, finish 3-byte UTF-8
					 */
					dst += uintptr(XTcl_UniCharToUtf(tls, -int32(1), dst))
				}
				/* Loop around again so destination space and other checks are done */
				prev = uint16(0) /* Reset high surrogate tracker */
				src -= uintptr(2)
			}
		} else {
			/* Previous char was not a high surrogate */
			/*
			 * Special case for 1-byte utf chars for speed. Make sure we work with
			 * unsigned short-size data. Order checks based on expected frequency.
			 */
			if uint32(ch)-uint32(1) < uint32(0x7F) {
				/* ASCII except nul */
				v2 = dst
				dst++
				*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(libc.Int32FromUint16(ch) & libc.Int32FromInt32(0xFF))
			} else {
				if !(libc.Int32FromUint16(ch) & ^libc.Int32FromInt32(0x7FF) == libc.Int32FromInt32(0xD800)) {
					/* Not ASCII, not surrogate */
					dst += uintptr(XTcl_UniCharToUtf(tls, libc.Int32FromUint16(ch), dst))
				} else {
					if libc.Int32FromUint16(ch) & ^libc.Int32FromInt32(0x3FF) == int32(0xD800) {
						dst += uintptr(XTcl_UniCharToUtf(tls, libc.Int32FromUint16(ch)|int32(TCL_COMBINE), dst))
						/* Do not count this just yet. Compensate for numChars++ in loop counter */
						numChars--
					} else {
						if !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8)) && !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_REPLACE)) {
							result = -int32(2)
							break
						}
						if libc.Uint32FromInt32(flags)&uint32(ENCODING_PROFILE_MASK) == uint32(TCL_ENCODING_PROFILE_REPLACE) {
							ch = uint16(UNICODE_REPLACE_CHAR)
						}
						dst += uintptr(XTcl_UniCharToUtf(tls, libc.Int32FromUint16(ch), dst))
					}
				}
			}
		}
		goto _1
	_1:
		;
		src += uintptr(2)
		numChars++
	}
	/*
	 * When the above loop ends, result may have the following values:
	 * 1. TCL_OK - full source buffer was completely processed.
	 *    src, dst, numChars will hold values up to that point BUT
	 *    there may be a leftover high surrogate we need to deal with.
	 * 2. TCL_CONVERT_NOSPACE - Ran out of room in the destination buffer.
	 *    Same considerations as (1)
	 * 3. TCL_CONVERT_SYNTAX - decoding error.
	 * 4. TCL_CONVERT_MULTIBYTE - the buffer passed in was not fully
	 *    processed, because there was a trailing single byte. However,
	 *    we *may* have processed the requested number of characters already
	 *    in which case the trailing byte does not matter. We still
	 *    *may* still be a leftover high surrogate as in (1) and (2).
	 */
	switch result {
	case -int32(1): /* FALLTHRU */
		fallthrough
	case TCL_OK: /* FALLTHRU */
		fallthrough
	case -int32(4):
		if libc.Int32FromUint16(ch) & ^libc.Int32FromInt32(0x3FF) == int32(0xD800) {
			if flags&int32(TCL_ENCODING_END) != 0 {
				/*
				 * No more data expected. There will be space for output of
				 * one character (essentially overwriting the dst area holding
				 * high surrogate state)
				 */
				if !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8)) && !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_REPLACE)) {
					result = -int32(2)
					src -= uintptr(2)
					dst--
				} else {
					if libc.Uint32FromInt32(flags)&uint32(ENCODING_PROFILE_MASK) == uint32(TCL_ENCODING_PROFILE_REPLACE) {
						dst--
						numChars++
						dst += uintptr(XTcl_UniCharToUtf(tls, int32(UNICODE_REPLACE_CHAR), dst))
					} else {
						/* Bug [10c2c17c32]. If Hi surrogate, finish 3-byte UTF-8 */
						numChars++
						dst += uintptr(XTcl_UniCharToUtf(tls, -int32(1), dst))
					}
				}
			} else {
				/* More data is expected. Revert the surrogate state */
				src -= uintptr(2)
				dst--
				/* Note: leave result of TCL_CONVERT_NOSPACE as is */
				if result == TCL_OK {
					result = -int32(1)
				}
			}
		} else {
			if flags&int32(TCL_ENCODING_END) != 0 && result == -int32(1) {
				/*
				 * If we had a trailing byte at the end AND this is the last
				 * fragment AND profile is not "strict", stick FFFD in its place.
				 * Note in this case we DO need to check for room in dst.
				 */
				if dst > dstEnd {
					result = -int32(4)
				} else {
					if !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8)) && !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_REPLACE)) {
						result = -int32(2)
					} else {
						/* PROFILE_REPLACE or PROFILE_TCL8 */
						result = TCL_OK
						dst += uintptr(XTcl_UniCharToUtf(tls, int32(UNICODE_REPLACE_CHAR), dst))
						numChars++
						src++
					}
				}
			}
		}
	case -int32(2):
		break /* Nothing to do */
	}
	*(*int32)(unsafe.Pointer(srcReadPtr)) = int32(int64(src) - int64(srcStart))
	*(*int32)(unsafe.Pointer(dstWrotePtr)) = int32(int64(dst) - int64(dstStart))
	*(*int32)(unsafe.Pointer(dstCharsPtr)) = numChars
	return result
}

/*
 *-------------------------------------------------------------------------
 *
 * UtfToUtf16Proc --
 *
 *	Convert from UTF-8 to UTF-16.
 *
 * Results:
 *	Returns TCL_OK if conversion was successful.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func _UtfToUtf16Proc(tls *libc.TLS, clientData uintptr, src uintptr, srcLen int32, flags int32, dummy3215 uintptr, dst uintptr, dstLen int32, srcReadPtr uintptr, dstWrotePtr uintptr, dstCharsPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Filled with the number of characters that
	 * correspond to the bytes stored in the
	 * output buffer. */
	var dstEnd, dstStart, srcClose, srcEnd, srcStart, v10, v11, v12, v13, v14, v3, v4, v5, v6, v7, v8, v9 uintptr
	var len1, numChars, result int32
	var v2 int64
	var _ /* ch at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = dstEnd, dstStart, len1, numChars, result, srcClose, srcEnd, srcStart, v10, v11, v12, v13, v14, v2, v3, v4, v5, v6, v7, v8, v9
	srcStart = src
	srcEnd = src + uintptr(srcLen)
	srcClose = srcEnd
	if flags&int32(TCL_ENCODING_END) == 0 {
		srcClose -= uintptr(TCL_UTF_MAX)
	}
	dstStart = dst
	dstEnd = dst + uintptr(dstLen) - uintptr(2) /* 2 -> sizeof a UTF-16 code unit */
	flags = int32(int64(flags) | int64(clientData))
	result = TCL_OK
	numChars = 0
	for {
		if !(src < srcEnd) {
			break
		}
		if src > srcClose && !(XTcl_UtfCharComplete(tls, src, int64(srcEnd)-int64(src)) != 0) {
			/*
			 * If there is more string to follow, this will ensure that the
			 * last UTF-8 character in the source buffer hasn't been cut off.
			 */
			result = -int32(1)
			break
		}
		if dst > dstEnd {
			result = -int32(4)
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) < int32(0x80) {
			*(*int32)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))
			v2 = int64(libc.Int32FromInt32(1))
		} else {
			v2 = XTcl_UtfToUniChar(tls, src, bp)
		}
		len1 = int32(v2)
		if *(*int32)(unsafe.Pointer(bp)) & ^libc.Int32FromInt32(0x7FF) == int32(0xD800) {
			if !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8)) && !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_REPLACE)) {
				result = -int32(3)
				break
			}
			if libc.Uint32FromInt32(flags)&uint32(ENCODING_PROFILE_MASK) == uint32(TCL_ENCODING_PROFILE_REPLACE) {
				*(*int32)(unsafe.Pointer(bp)) = int32(UNICODE_REPLACE_CHAR)
			}
		}
		if *(*int32)(unsafe.Pointer(bp)) <= int32(0xFFFF) {
			if flags&int32(TCL_ENCODING_LE) != 0 {
				v3 = dst
				dst++
				*(*uint8)(unsafe.Pointer(v3)) = libc.Uint8FromInt32(*(*int32)(unsafe.Pointer(bp)) & libc.Int32FromInt32(0xFF))
				v4 = dst
				dst++
				*(*uint8)(unsafe.Pointer(v4)) = libc.Uint8FromInt32(*(*int32)(unsafe.Pointer(bp)) >> libc.Int32FromInt32(8))
			} else {
				v5 = dst
				dst++
				*(*uint8)(unsafe.Pointer(v5)) = libc.Uint8FromInt32(*(*int32)(unsafe.Pointer(bp)) >> libc.Int32FromInt32(8))
				v6 = dst
				dst++
				*(*uint8)(unsafe.Pointer(v6)) = libc.Uint8FromInt32(*(*int32)(unsafe.Pointer(bp)) & libc.Int32FromInt32(0xFF))
			}
		} else {
			if dst+uintptr(2) > dstEnd {
				/* Surrogates need 2 more bytes! Bug [66da4d4228] */
				result = -int32(4)
				break
			}
			if flags&int32(TCL_ENCODING_LE) != 0 {
				v7 = dst
				dst++
				*(*uint8)(unsafe.Pointer(v7)) = libc.Uint8FromInt32((*(*int32)(unsafe.Pointer(bp)) - libc.Int32FromInt32(0x10000)) >> libc.Int32FromInt32(10) & libc.Int32FromInt32(0xFF))
				v8 = dst
				dst++
				*(*uint8)(unsafe.Pointer(v8)) = libc.Uint8FromInt32((*(*int32)(unsafe.Pointer(bp))-int32(0x10000))>>int32(18)&int32(0x3) | int32(0xD8))
				v9 = dst
				dst++
				*(*uint8)(unsafe.Pointer(v9)) = libc.Uint8FromInt32(*(*int32)(unsafe.Pointer(bp)) & libc.Int32FromInt32(0xFF))
				v10 = dst
				dst++
				*(*uint8)(unsafe.Pointer(v10)) = libc.Uint8FromInt32(*(*int32)(unsafe.Pointer(bp))>>int32(8)&int32(0x3) | int32(0xDC))
			} else {
				v11 = dst
				dst++
				*(*uint8)(unsafe.Pointer(v11)) = libc.Uint8FromInt32((*(*int32)(unsafe.Pointer(bp))-int32(0x10000))>>int32(18)&int32(0x3) | int32(0xD8))
				v12 = dst
				dst++
				*(*uint8)(unsafe.Pointer(v12)) = libc.Uint8FromInt32((*(*int32)(unsafe.Pointer(bp)) - libc.Int32FromInt32(0x10000)) >> libc.Int32FromInt32(10) & libc.Int32FromInt32(0xFF))
				v13 = dst
				dst++
				*(*uint8)(unsafe.Pointer(v13)) = libc.Uint8FromInt32(*(*int32)(unsafe.Pointer(bp))>>int32(8)&int32(0x3) | int32(0xDC))
				v14 = dst
				dst++
				*(*uint8)(unsafe.Pointer(v14)) = libc.Uint8FromInt32(*(*int32)(unsafe.Pointer(bp)) & libc.Int32FromInt32(0xFF))
			}
		}
		src += uintptr(len1)
		goto _1
	_1:
		;
		numChars++
	}
	*(*int32)(unsafe.Pointer(srcReadPtr)) = int32(int64(src) - int64(srcStart))
	*(*int32)(unsafe.Pointer(dstWrotePtr)) = int32(int64(dst) - int64(dstStart))
	*(*int32)(unsafe.Pointer(dstCharsPtr)) = numChars
	return result
}

/*
 *-------------------------------------------------------------------------
 *
 * UtfToUcs2Proc --
 *
 *	Convert from UTF-8 to UCS-2.
 *
 * Results:
 *	Returns TCL_OK if conversion was successful.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func _UtfToUcs2Proc(tls *libc.TLS, clientData uintptr, src uintptr, srcLen int32, flags int32, dummy3328 uintptr, dst uintptr, dstLen int32, srcReadPtr uintptr, dstWrotePtr uintptr, dstCharsPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Filled with the number of characters that
	 * correspond to the bytes stored in the
	 * output buffer. */
	var dstEnd, dstStart, srcClose, srcEnd, srcStart, v3, v4, v5, v6 uintptr
	var len1, numChars, result int32
	var v2 int64
	var _ /* ch at bp+0 */ TTcl_UniChar
	_, _, _, _, _, _, _, _, _, _, _, _, _ = dstEnd, dstStart, len1, numChars, result, srcClose, srcEnd, srcStart, v2, v3, v4, v5, v6
	*(*TTcl_UniChar)(unsafe.Pointer(bp)) = 0
	flags = int32(int64(flags) | int64(clientData))
	srcStart = src
	srcEnd = src + uintptr(srcLen)
	srcClose = srcEnd
	if flags&int32(TCL_ENCODING_END) == 0 {
		srcClose -= uintptr(TCL_UTF_MAX)
	}
	dstStart = dst
	dstEnd = dst + uintptr(dstLen) - uintptr(2) /* 2 - size of UCS code unit */
	result = TCL_OK
	numChars = 0
	for {
		if !(src < srcEnd) {
			break
		}
		if src > srcClose && !(XTcl_UtfCharComplete(tls, src, int64(srcEnd)-int64(src)) != 0) {
			/*
			 * If there is more string to follow, this will ensure that the
			 * last UTF-8 character in the source buffer hasn't been cut off.
			 */
			result = -int32(1)
			break
		}
		if dst > dstEnd {
			result = -int32(4)
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))
			v2 = int64(libc.Int32FromInt32(1))
		} else {
			v2 = XTcl_UtfToUniChar(tls, src, bp)
		}
		len1 = int32(v2)
		if *(*TTcl_UniChar)(unsafe.Pointer(bp)) > int32(0xFFFF) {
			if !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8)) && !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_REPLACE)) {
				result = -int32(3)
				break
			}
			*(*TTcl_UniChar)(unsafe.Pointer(bp)) = int32(UNICODE_REPLACE_CHAR)
		}
		if !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8)) && !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_REPLACE)) && *(*TTcl_UniChar)(unsafe.Pointer(bp)) & ^libc.Int32FromInt32(0x7FF) == int32(0xD800) {
			result = -int32(2)
			break
		}
		src += uintptr(len1)
		/*
		 * Need to handle this in a way that won't cause misalignment by
		 * casting dst to a Tcl_UniChar. [Bug 1122671]
		 */
		if flags&int32(TCL_ENCODING_LE) != 0 {
			v3 = dst
			dst++
			*(*uint8)(unsafe.Pointer(v3)) = libc.Uint8FromInt32(*(*TTcl_UniChar)(unsafe.Pointer(bp)) & libc.Int32FromInt32(0xFF))
			v4 = dst
			dst++
			*(*uint8)(unsafe.Pointer(v4)) = libc.Uint8FromInt32(*(*TTcl_UniChar)(unsafe.Pointer(bp)) >> libc.Int32FromInt32(8))
		} else {
			v5 = dst
			dst++
			*(*uint8)(unsafe.Pointer(v5)) = libc.Uint8FromInt32(*(*TTcl_UniChar)(unsafe.Pointer(bp)) >> libc.Int32FromInt32(8))
			v6 = dst
			dst++
			*(*uint8)(unsafe.Pointer(v6)) = libc.Uint8FromInt32(*(*TTcl_UniChar)(unsafe.Pointer(bp)) & libc.Int32FromInt32(0xFF))
		}
		goto _1
	_1:
		;
		numChars++
	}
	*(*int32)(unsafe.Pointer(srcReadPtr)) = int32(int64(src) - int64(srcStart))
	*(*int32)(unsafe.Pointer(dstWrotePtr)) = int32(int64(dst) - int64(dstStart))
	*(*int32)(unsafe.Pointer(dstCharsPtr)) = numChars
	return result
}

/*
 *-------------------------------------------------------------------------
 *
 * TableToUtfProc --
 *
 *	Convert from the encoding specified by the TableEncodingData into
 *	UTF-8.
 *
 * Results:
 *	Returns TCL_OK if conversion was successful.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func _TableToUtfProc(tls *libc.TLS, clientData uintptr, src uintptr, srcLen int32, flags int32, dummy3433 uintptr, dst uintptr, dstLen int32, srcReadPtr uintptr, dstWrotePtr uintptr, dstCharsPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Filled with the number of characters that
	 * correspond to the bytes stored in the
	 * output buffer. */
	var byte1, charLimit, numChars, result int32
	var dataPtr, dstEnd, dstStart, pageZero, prefixBytes, srcEnd, srcStart, toUnicode, v2, v4 uintptr
	var _ /* ch at bp+0 */ TTcl_UniChar
	var _ /* chbuf at bp+4 */ [2]uint8
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = byte1, charLimit, dataPtr, dstEnd, dstStart, numChars, pageZero, prefixBytes, result, srcEnd, srcStart, toUnicode, v2, v4
	charLimit = int32(INT_MAX)
	*(*TTcl_UniChar)(unsafe.Pointer(bp)) = 0
	dataPtr = clientData
	if flags&int32(TCL_ENCODING_CHAR_LIMIT) != 0 {
		charLimit = *(*int32)(unsafe.Pointer(dstCharsPtr))
	}
	srcStart = src
	srcEnd = src + uintptr(srcLen)
	dstStart = dst
	dstEnd = dst + uintptr(dstLen) - uintptr(TCL_UTF_MAX)
	toUnicode = (*TTableEncodingData)(unsafe.Pointer(dataPtr)).FtoUnicode
	prefixBytes = dataPtr + 4
	pageZero = *(*uintptr)(unsafe.Pointer(toUnicode))
	result = TCL_OK
	numChars = 0
	for {
		if !(src < srcEnd && numChars <= charLimit) {
			break
		}
		if dst > dstEnd {
			result = -int32(4)
			break
		}
		byte1 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))
		if *(*uint8)(unsafe.Pointer(prefixBytes + uintptr(byte1))) != 0 {
			if src >= srcEnd-uintptr(1) {
				/* Prefix byte but nothing after it */
				if !(flags&libc.Int32FromInt32(TCL_ENCODING_END) != 0) {
					/* More data to come */
					result = -int32(1)
					break
				} else {
					if !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8)) && !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_REPLACE)) {
						result = -int32(2)
						break
					} else {
						if libc.Uint32FromInt32(flags)&uint32(ENCODING_PROFILE_MASK) == uint32(TCL_ENCODING_PROFILE_REPLACE) {
							*(*TTcl_UniChar)(unsafe.Pointer(bp)) = int32(UNICODE_REPLACE_CHAR)
						} else {
							/* For prefix bytes, we don't fallback to cp1252, see [1355b9a874] */
							*(*TTcl_UniChar)(unsafe.Pointer(bp)) = byte1
						}
					}
				}
			} else {
				src++
				v2 = src
				*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(toUnicode + uintptr(byte1)*8)) + uintptr(*(*uint8)(unsafe.Pointer(v2)))*2)))
			}
		} else {
			*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(pageZero + uintptr(byte1)*2)))
		}
		if *(*TTcl_UniChar)(unsafe.Pointer(bp)) == 0 && byte1 != 0 {
			/* Prefix+suffix pair is invalid */
			if !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8)) && !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_REPLACE)) {
				result = -int32(2)
				break
			}
			if *(*uint8)(unsafe.Pointer(prefixBytes + uintptr(byte1))) != 0 {
				src--
			}
			if libc.Uint32FromInt32(flags)&uint32(ENCODING_PROFILE_MASK) == uint32(TCL_ENCODING_PROFILE_REPLACE) {
				*(*TTcl_UniChar)(unsafe.Pointer(bp)) = int32(UNICODE_REPLACE_CHAR)
			} else {
				(*(*[2]uint8)(unsafe.Pointer(bp + 4)))[0] = libc.Uint8FromInt32(byte1)
				(*(*[2]uint8)(unsafe.Pointer(bp + 4)))[int32(1)] = uint8(0)
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 4))) < int32(0x80) {
					*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 4)))
					_ = libc.Int32FromInt32(1)
				} else {
					XTcl_UtfToUniChar(tls, bp+4, bp)
				}
			}
		}
		/*
		 * Special case for 1-byte Utf chars for speed.
		 */
		if libc.Uint32FromInt32(*(*TTcl_UniChar)(unsafe.Pointer(bp)))-uint32(1) < uint32(0x7F) {
			v4 = dst
			dst++
			*(*uint8)(unsafe.Pointer(v4)) = libc.Uint8FromInt32(*(*TTcl_UniChar)(unsafe.Pointer(bp)))
		} else {
			dst += uintptr(XTcl_UniCharToUtf(tls, *(*TTcl_UniChar)(unsafe.Pointer(bp)), dst))
		}
		src++
		goto _1
	_1:
		;
		numChars++
	}
	*(*int32)(unsafe.Pointer(srcReadPtr)) = int32(int64(src) - int64(srcStart))
	*(*int32)(unsafe.Pointer(dstWrotePtr)) = int32(int64(dst) - int64(dstStart))
	*(*int32)(unsafe.Pointer(dstCharsPtr)) = numChars
	return result
}

/*
 *-------------------------------------------------------------------------
 *
 * TableFromUtfProc --
 *
 *	Convert from UTF-8 into the encoding specified by the
 *	TableEncodingData.
 *
 * Results:
 *	Returns TCL_OK if conversion was successful.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func _TableFromUtfProc(tls *libc.TLS, clientData uintptr, src uintptr, srcLen int32, flags int32, dummy3561 uintptr, dst uintptr, dstLen int32, srcReadPtr uintptr, dstWrotePtr uintptr, dstCharsPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Filled with the number of characters that
	 * correspond to the bytes stored in the
	 * output buffer. */
	var dataPtr, dstEnd, dstStart, fromUnicode, prefixBytes, srcClose, srcEnd, srcStart uintptr
	var len1, numChars, result, word int32
	var v2 int64
	var _ /* ch at bp+0 */ TTcl_UniChar
	_, _, _, _, _, _, _, _, _, _, _, _, _ = dataPtr, dstEnd, dstStart, fromUnicode, len1, numChars, prefixBytes, result, srcClose, srcEnd, srcStart, word, v2
	*(*TTcl_UniChar)(unsafe.Pointer(bp)) = 0
	dataPtr = clientData
	result = TCL_OK
	prefixBytes = dataPtr + 4
	fromUnicode = (*TTableEncodingData)(unsafe.Pointer(dataPtr)).FfromUnicode
	srcStart = src
	srcEnd = src + uintptr(srcLen)
	srcClose = srcEnd
	if flags&int32(TCL_ENCODING_END) == 0 {
		srcClose -= uintptr(TCL_UTF_MAX)
	}
	dstStart = dst
	dstEnd = dst + uintptr(dstLen) - uintptr(1)
	numChars = 0
	for {
		if !(src < srcEnd) {
			break
		}
		if src > srcClose && !(XTcl_UtfCharComplete(tls, src, int64(srcEnd)-int64(src)) != 0) {
			/*
			 * If there is more string to follow, this will ensure that the
			 * last UTF-8 character in the source buffer hasn't been cut off.
			 */
			result = -int32(1)
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))
			v2 = int64(libc.Int32FromInt32(1))
		} else {
			v2 = XTcl_UtfToUniChar(tls, src, bp)
		}
		len1 = int32(v2)
		/* Unicode chars > +U0FFFF cannot be represented in any table encoding */
		if libc.Uint32FromInt32(*(*TTcl_UniChar)(unsafe.Pointer(bp)))&uint32(0xFFFF0000) != 0 {
			word = 0
		} else {
			word = libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(fromUnicode + uintptr(*(*TTcl_UniChar)(unsafe.Pointer(bp))>>libc.Int32FromInt32(8))*8)) + uintptr(*(*TTcl_UniChar)(unsafe.Pointer(bp))&int32(0xFF))*2)))
		}
		if word == 0 && *(*TTcl_UniChar)(unsafe.Pointer(bp)) != 0 {
			if !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8)) && !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_REPLACE)) {
				result = -int32(3)
				break
			}
			word = (*TTableEncodingData)(unsafe.Pointer(dataPtr)).Ffallback /* Both profiles REPLACE and TCL8 */
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(prefixBytes + uintptr(word>>libc.Int32FromInt32(8))))) != 0 {
			if dst+uintptr(1) > dstEnd {
				result = -int32(4)
				break
			}
			*(*uint8)(unsafe.Pointer(dst)) = libc.Uint8FromInt32(word >> libc.Int32FromInt32(8))
			*(*uint8)(unsafe.Pointer(dst + 1)) = libc.Uint8FromInt32(word)
			dst += uintptr(2)
		} else {
			if dst > dstEnd {
				result = -int32(4)
				break
			}
			*(*uint8)(unsafe.Pointer(dst)) = libc.Uint8FromInt32(word)
			dst++
		}
		src += uintptr(len1)
		goto _1
	_1:
		;
		numChars++
	}
	*(*int32)(unsafe.Pointer(srcReadPtr)) = int32(int64(src) - int64(srcStart))
	*(*int32)(unsafe.Pointer(dstWrotePtr)) = int32(int64(dst) - int64(dstStart))
	*(*int32)(unsafe.Pointer(dstCharsPtr)) = numChars
	return result
}

/*
 *-------------------------------------------------------------------------
 *
 * Iso88591ToUtfProc --
 *
 *	Convert from the "iso8859-1" encoding into UTF-8.
 *
 * Results:
 *	Returns TCL_OK if conversion was successful.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func _Iso88591ToUtfProc(tls *libc.TLS, dummy3669 uintptr, src uintptr, srcLen int32, flags int32, dummy3673 uintptr, dst uintptr, dstLen int32, srcReadPtr uintptr, dstWrotePtr uintptr, dstCharsPtr uintptr) (r int32) {
	/* Filled with the number of characters that
	 * correspond to the bytes stored in the
	 * output buffer. */
	var ch TTcl_UniChar
	var charLimit, numChars, result int32
	var dstEnd, dstStart, srcEnd, srcStart, v2 uintptr
	_, _, _, _, _, _, _, _, _ = ch, charLimit, dstEnd, dstStart, numChars, result, srcEnd, srcStart, v2
	charLimit = int32(INT_MAX)
	if flags&int32(TCL_ENCODING_CHAR_LIMIT) != 0 {
		charLimit = *(*int32)(unsafe.Pointer(dstCharsPtr))
	}
	srcStart = src
	srcEnd = src + uintptr(srcLen)
	dstStart = dst
	dstEnd = dst + uintptr(dstLen) - uintptr(TCL_UTF_MAX)
	result = TCL_OK
	numChars = 0
	for {
		if !(src < srcEnd && numChars <= charLimit) {
			break
		}
		ch = 0
		if dst > dstEnd {
			result = -int32(4)
			break
		}
		ch = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))
		/*
		 * Special case for 1-byte utf chars for speed.
		 */
		if libc.Uint32FromInt32(ch)-uint32(1) < uint32(0x7F) {
			v2 = dst
			dst++
			*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(ch)
		} else {
			dst += uintptr(XTcl_UniCharToUtf(tls, ch, dst))
		}
		src++
		goto _1
	_1:
		;
		numChars++
	}
	*(*int32)(unsafe.Pointer(srcReadPtr)) = int32(int64(src) - int64(srcStart))
	*(*int32)(unsafe.Pointer(dstWrotePtr)) = int32(int64(dst) - int64(dstStart))
	*(*int32)(unsafe.Pointer(dstCharsPtr)) = numChars
	return result
}

/*
 *-------------------------------------------------------------------------
 *
 * Iso88591FromUtfProc --
 *
 *	Convert from UTF-8 into the encoding "iso8859-1".
 *
 * Results:
 *	Returns TCL_OK if conversion was successful.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func _Iso88591FromUtfProc(tls *libc.TLS, dummy3749 uintptr, src uintptr, srcLen int32, flags int32, dummy3753 uintptr, dst uintptr, dstLen int32, srcReadPtr uintptr, dstWrotePtr uintptr, dstCharsPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Filled with the number of characters that
	 * correspond to the bytes stored in the
	 * output buffer. */
	var dstEnd, dstStart, srcClose, srcEnd, srcStart, v3 uintptr
	var len1, numChars, result int32
	var v2 int64
	var _ /* ch at bp+0 */ TTcl_UniChar
	_, _, _, _, _, _, _, _, _, _ = dstEnd, dstStart, len1, numChars, result, srcClose, srcEnd, srcStart, v2, v3
	result = TCL_OK
	*(*TTcl_UniChar)(unsafe.Pointer(bp)) = 0
	srcStart = src
	srcEnd = src + uintptr(srcLen)
	srcClose = srcEnd
	if flags&int32(TCL_ENCODING_END) == 0 {
		srcClose -= uintptr(TCL_UTF_MAX)
	}
	dstStart = dst
	dstEnd = dst + uintptr(dstLen) - uintptr(1)
	numChars = 0
	for {
		if !(src < srcEnd) {
			break
		}
		if src > srcClose && !(XTcl_UtfCharComplete(tls, src, int64(srcEnd)-int64(src)) != 0) {
			/*
			 * If there is more string to follow, this will ensure that the
			 * last UTF-8 character in the source buffer hasn't been cut off.
			 */
			result = -int32(1)
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))
			v2 = int64(libc.Int32FromInt32(1))
		} else {
			v2 = XTcl_UtfToUniChar(tls, src, bp)
		}
		len1 = int32(v2)
		/*
		 * Check for illegal characters.
		 */
		if *(*TTcl_UniChar)(unsafe.Pointer(bp)) > int32(0xFF) {
			if !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8)) && !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_REPLACE)) {
				result = -int32(3)
				break
			}
			/*
			 * Plunge on, using '?' as a fallback character.
			 */
			*(*TTcl_UniChar)(unsafe.Pointer(bp)) = int32('?') /* Profiles TCL8 and REPLACE */
		}
		if dst > dstEnd {
			result = -int32(4)
			break
		}
		v3 = dst
		dst++
		*(*uint8)(unsafe.Pointer(v3)) = libc.Uint8FromInt32(*(*TTcl_UniChar)(unsafe.Pointer(bp)))
		src += uintptr(len1)
		goto _1
	_1:
		;
		numChars++
	}
	*(*int32)(unsafe.Pointer(srcReadPtr)) = int32(int64(src) - int64(srcStart))
	*(*int32)(unsafe.Pointer(dstWrotePtr)) = int32(int64(dst) - int64(dstStart))
	*(*int32)(unsafe.Pointer(dstCharsPtr)) = numChars
	return result
}

/*
 *---------------------------------------------------------------------------
 *
 * TableFreeProc --
 *
 *	This function is invoked when an encoding is deleted. It deletes the
 *	memory used by the TableEncodingData.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Memory freed.
 *
 *---------------------------------------------------------------------------
 */

func _TableFreeProc(tls *libc.TLS, clientData uintptr) {
	/* TableEncodingData that specifies
	 * encoding. */
	var dataPtr uintptr
	_ = dataPtr
	dataPtr = clientData
	/*
	 * Make sure we aren't freeing twice on shutdown. [Bug 219314]
	 */
	XTclpFree(tls, (*TTableEncodingData)(unsafe.Pointer(dataPtr)).FtoUnicode)
	(*TTableEncodingData)(unsafe.Pointer(dataPtr)).FtoUnicode = libc.UintptrFromInt32(0)
	XTclpFree(tls, (*TTableEncodingData)(unsafe.Pointer(dataPtr)).FfromUnicode)
	(*TTableEncodingData)(unsafe.Pointer(dataPtr)).FfromUnicode = libc.UintptrFromInt32(0)
	XTclpFree(tls, dataPtr)
}

/*
 *-------------------------------------------------------------------------
 *
 * EscapeToUtfProc --
 *
 *	Convert from the encoding specified by the EscapeEncodingData into
 *	UTF-8.
 *
 * Results:
 *	Returns TCL_OK if conversion was successful.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func _EscapeToUtfProc(tls *libc.TLS, clientData uintptr, src uintptr, srcLen int32, flags int32, statePtr uintptr, dst uintptr, dstLen int32, srcReadPtr uintptr, dstWrotePtr uintptr, dstCharsPtr uintptr) (r int32) {
	/* Filled with the number of characters that
	 * correspond to the bytes stored in the
	 * output buffer. */
	var byte1, ch, charLimit, checked, hi, i, lo, numChars, result, state int32
	var dataPtr, dstEnd, dstStart, encodingPtr, prefixBytes, srcEnd, srcStart, subTablePtr, tableDataPtr, tablePrefixBytes, tableToUnicode uintptr
	var left, len1, longest, skip, v3 uint32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = byte1, ch, charLimit, checked, dataPtr, dstEnd, dstStart, encodingPtr, hi, i, left, len1, lo, longest, numChars, prefixBytes, result, skip, srcEnd, srcStart, state, subTablePtr, tableDataPtr, tablePrefixBytes, tableToUnicode, v3
	dataPtr = clientData
	charLimit = int32(INT_MAX)
	if flags&int32(TCL_ENCODING_CHAR_LIMIT) != 0 {
		charLimit = *(*int32)(unsafe.Pointer(dstCharsPtr))
	}
	result = TCL_OK
	tablePrefixBytes = libc.UintptrFromInt32(0)
	tableToUnicode = libc.UintptrFromInt32(0)
	prefixBytes = dataPtr + 44
	encodingPtr = libc.UintptrFromInt32(0)
	srcStart = src
	srcEnd = src + uintptr(srcLen)
	dstStart = dst
	dstEnd = dst + uintptr(dstLen) - uintptr(TCL_UTF_MAX)
	state = int32(int64(*(*TTcl_EncodingState)(unsafe.Pointer(statePtr))))
	if flags&int32(TCL_ENCODING_START) != 0 {
		state = 0
	}
	numChars = 0
	for {
		if !(src < srcEnd && numChars <= charLimit) {
			break
		}
		if dst > dstEnd {
			result = -int32(4)
			break
		}
		byte1 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))
		if *(*uint8)(unsafe.Pointer(prefixBytes + uintptr(byte1))) != 0 {
			/*
			 * Saw the beginning of an escape sequence.
			 */
			left = libc.Uint32FromInt64(int64(srcEnd) - int64(src))
			len1 = (*TEscapeEncodingData)(unsafe.Pointer(dataPtr)).FinitLen
			longest = len1
			checked = 0
			if len1 <= left {
				checked++
				if len1 > uint32(0) && libc.Xmemcmp(tls, src, dataPtr+8, uint64(len1)) == 0 {
					/*
					 * If we see initialization string, skip it, even if we're
					 * not at the beginning of the buffer.
					 */
					src += uintptr(len1)
					goto _1
				}
			}
			len1 = (*TEscapeEncodingData)(unsafe.Pointer(dataPtr)).FfinalLen
			if len1 > longest {
				longest = len1
			}
			if len1 <= left {
				checked++
				if len1 > uint32(0) && libc.Xmemcmp(tls, src, dataPtr+28, uint64(len1)) == 0 {
					/*
					 * If we see finalization string, skip it, even if we're
					 * not at the end of the buffer.
					 */
					src += uintptr(len1)
					goto _1
				}
			}
			subTablePtr = dataPtr + 304
			i = 0
			for {
				if !(i < (*TEscapeEncodingData)(unsafe.Pointer(dataPtr)).FnumSubTables) {
					break
				}
				len1 = (*TEscapeSubTable)(unsafe.Pointer(subTablePtr)).FsequenceLen
				if len1 > longest {
					longest = len1
				}
				if len1 <= left {
					checked++
					if len1 > uint32(0) && libc.Xmemcmp(tls, src, subTablePtr+4, uint64(len1)) == 0 {
						state = i
						encodingPtr = libc.UintptrFromInt32(0)
						subTablePtr = libc.UintptrFromInt32(0)
						src += uintptr(len1)
						break
					}
				}
				subTablePtr += 64
				goto _2
			_2:
				;
				i++
			}
			if subTablePtr == libc.UintptrFromInt32(0) {
				/*
				 * A match was found, the escape sequence was consumed, and
				 * the state was updated.
				 */
				goto _1
			}
			/*
			 * We have a split-up or unrecognized escape sequence. If we
			 * checked all the sequences, then it's a syntax error, otherwise
			 * we need more bytes to determine a match.
			 */
			if checked == (*TEscapeEncodingData)(unsafe.Pointer(dataPtr)).FnumSubTables+int32(2) || flags&int32(TCL_ENCODING_END) != 0 {
				if !(!(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8)) && !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_REPLACE))) {
					if longest > left {
						v3 = left
					} else {
						v3 = longest
					}
					skip = v3
					/* Unknown escape sequence */
					dst += uintptr(XTcl_UniCharToUtf(tls, int32(UNICODE_REPLACE_CHAR), dst))
					src += uintptr(skip)
					goto _1
				}
				result = -int32(2)
			} else {
				result = -int32(1)
			}
			break
		}
		if encodingPtr == libc.UintptrFromInt32(0) {
			encodingPtr = _GetTableEncoding(tls, dataPtr, state)
			tableDataPtr = (*TEncoding)(unsafe.Pointer(encodingPtr)).FclientData
			tablePrefixBytes = tableDataPtr + 4
			tableToUnicode = (*TTableEncodingData)(unsafe.Pointer(tableDataPtr)).FtoUnicode
		}
		if *(*uint8)(unsafe.Pointer(tablePrefixBytes + uintptr(byte1))) != 0 {
			src++
			if src >= srcEnd {
				src--
				result = -int32(1)
				break
			}
			hi = byte1
			lo = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))
		} else {
			hi = 0
			lo = byte1
		}
		ch = libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tableToUnicode + uintptr(hi)*8)) + uintptr(lo)*2)))
		dst += uintptr(XTcl_UniCharToUtf(tls, ch, dst))
		src++
		numChars++
		goto _1
	_1:
	}
	*(*TTcl_EncodingState)(unsafe.Pointer(statePtr)) = uintptr(int64(state))
	*(*int32)(unsafe.Pointer(srcReadPtr)) = int32(int64(src) - int64(srcStart))
	*(*int32)(unsafe.Pointer(dstWrotePtr)) = int32(int64(dst) - int64(dstStart))
	*(*int32)(unsafe.Pointer(dstCharsPtr)) = numChars
	return result
}

/*
 *-------------------------------------------------------------------------
 *
 * EscapeFromUtfProc --
 *
 *	Convert from UTF-8 into the encoding specified by the
 *	EscapeEncodingData.
 *
 * Results:
 *	Returns TCL_OK if conversion was successful.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func _EscapeFromUtfProc(tls *libc.TLS, clientData uintptr, src uintptr, srcLen int32, flags int32, statePtr uintptr, dst uintptr, dstLen int32, srcReadPtr uintptr, dstWrotePtr uintptr, dstCharsPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Filled with the number of characters that
	 * correspond to the bytes stored in the
	 * output buffer. */
	var dataPtr, dstEnd, dstStart, encodingPtr, srcClose, srcEnd, srcStart, subTablePtr, tableDataPtr, tableFromUnicode, tablePrefixBytes uintptr
	var len1, len11, v4 uint32
	var numChars, oldState, result, state, word int32
	var v2 int64
	var _ /* ch at bp+0 */ TTcl_UniChar
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = dataPtr, dstEnd, dstStart, encodingPtr, len1, len11, numChars, oldState, result, srcClose, srcEnd, srcStart, state, subTablePtr, tableDataPtr, tableFromUnicode, tablePrefixBytes, word, v2, v4
	dataPtr = clientData
	*(*TTcl_UniChar)(unsafe.Pointer(bp)) = 0
	result = TCL_OK
	srcStart = src
	srcEnd = src + uintptr(srcLen)
	srcClose = srcEnd
	if flags&int32(TCL_ENCODING_END) == 0 {
		srcClose -= uintptr(TCL_UTF_MAX)
	}
	dstStart = dst
	dstEnd = dst + uintptr(dstLen) - uintptr(1)
	/*
	 * RFC 1468 states that the text starts in ASCII, and switches to Japanese
	 * characters, and that the text must end in ASCII. [Patch 474358]
	 */
	if flags&int32(TCL_ENCODING_START) != 0 {
		state = 0
		if dst+uintptr((*TEscapeEncodingData)(unsafe.Pointer(dataPtr)).FinitLen) > dstEnd {
			*(*int32)(unsafe.Pointer(srcReadPtr)) = 0
			*(*int32)(unsafe.Pointer(dstWrotePtr)) = 0
			return -int32(4)
		}
		libc.Xmemcpy(tls, dst, dataPtr+8, uint64((*TEscapeEncodingData)(unsafe.Pointer(dataPtr)).FinitLen))
		dst += uintptr((*TEscapeEncodingData)(unsafe.Pointer(dataPtr)).FinitLen)
	} else {
		state = int32(int64(*(*TTcl_EncodingState)(unsafe.Pointer(statePtr))))
	}
	encodingPtr = _GetTableEncoding(tls, dataPtr, state)
	tableDataPtr = (*TEncoding)(unsafe.Pointer(encodingPtr)).FclientData
	tablePrefixBytes = tableDataPtr + 4
	tableFromUnicode = (*TTableEncodingData)(unsafe.Pointer(tableDataPtr)).FfromUnicode
	numChars = 0
	for {
		if !(src < srcEnd) {
			break
		}
		if src > srcClose && !(XTcl_UtfCharComplete(tls, src, int64(srcEnd)-int64(src)) != 0) {
			/*
			 * If there is more string to follow, this will ensure that the
			 * last UTF-8 character in the source buffer hasn't been cut off.
			 */
			result = -int32(1)
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))
			v2 = int64(libc.Int32FromInt32(1))
		} else {
			v2 = XTcl_UtfToUniChar(tls, src, bp)
		}
		len1 = libc.Uint32FromInt64(v2)
		if *(*TTcl_UniChar)(unsafe.Pointer(bp)) > int32(0xFFFF) {
			/* Bug 201c7a3aa6 crash - tables are 256x256 (64K) */
			if !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8)) && !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_REPLACE)) {
				result = -int32(2)
				break
			}
			/* Will be encoded as encoding specific replacement below */
			*(*TTcl_UniChar)(unsafe.Pointer(bp)) = int32(UNICODE_REPLACE_CHAR)
		}
		word = libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tableFromUnicode + uintptr(*(*TTcl_UniChar)(unsafe.Pointer(bp))>>libc.Int32FromInt32(8))*8)) + uintptr(*(*TTcl_UniChar)(unsafe.Pointer(bp))&int32(0xFF))*2)))
		if word == 0 && *(*TTcl_UniChar)(unsafe.Pointer(bp)) != 0 {
			oldState = state
			state = 0
			for {
				if !(state < (*TEscapeEncodingData)(unsafe.Pointer(dataPtr)).FnumSubTables) {
					break
				}
				encodingPtr = _GetTableEncoding(tls, dataPtr, state)
				tableDataPtr = (*TEncoding)(unsafe.Pointer(encodingPtr)).FclientData
				word = libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TTableEncodingData)(unsafe.Pointer(tableDataPtr)).FfromUnicode + uintptr(*(*TTcl_UniChar)(unsafe.Pointer(bp))>>libc.Int32FromInt32(8))*8)) + uintptr(*(*TTcl_UniChar)(unsafe.Pointer(bp))&int32(0xFF))*2)))
				if word != 0 {
					break
				}
				goto _3
			_3:
				;
				state++
			}
			if word == 0 {
				state = oldState
				if !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_TCL8)) && !(libc.Uint32FromInt32(flags)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK) == libc.Uint32FromInt32(TCL_ENCODING_PROFILE_REPLACE)) {
					result = -int32(3)
					break
				}
				encodingPtr = _GetTableEncoding(tls, dataPtr, state)
				tableDataPtr = (*TEncoding)(unsafe.Pointer(encodingPtr)).FclientData
				word = (*TTableEncodingData)(unsafe.Pointer(tableDataPtr)).Ffallback
			}
			tablePrefixBytes = tableDataPtr + 4
			tableFromUnicode = (*TTableEncodingData)(unsafe.Pointer(tableDataPtr)).FfromUnicode
			/*
			 * The state variable has the value of oldState when word is 0.
			 * In this case, the escape sequence should not be copied to dst
			 * because the current character set is not changed.
			 */
			if state != oldState {
				subTablePtr = dataPtr + 304 + uintptr(state)*64
				if dst+uintptr((*TEscapeSubTable)(unsafe.Pointer(subTablePtr)).FsequenceLen) > dstEnd {
					/*
					 * If there is no space to write the escape sequence, the
					 * state variable must be changed to the value of oldState
					 * variable because this escape sequence must be written
					 * in the next conversion.
					 */
					state = oldState
					result = -int32(4)
					break
				}
				libc.Xmemcpy(tls, dst, subTablePtr+4, uint64((*TEscapeSubTable)(unsafe.Pointer(subTablePtr)).FsequenceLen))
				dst += uintptr((*TEscapeSubTable)(unsafe.Pointer(subTablePtr)).FsequenceLen)
			}
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(tablePrefixBytes + uintptr(word>>libc.Int32FromInt32(8))))) != 0 {
			if dst+uintptr(1) > dstEnd {
				result = -int32(4)
				break
			}
			*(*uint8)(unsafe.Pointer(dst)) = libc.Uint8FromInt32(word >> libc.Int32FromInt32(8))
			*(*uint8)(unsafe.Pointer(dst + 1)) = libc.Uint8FromInt32(word)
			dst += uintptr(2)
		} else {
			if dst > dstEnd {
				result = -int32(4)
				break
			}
			*(*uint8)(unsafe.Pointer(dst)) = libc.Uint8FromInt32(word)
			dst++
		}
		src += uintptr(len1)
		goto _1
	_1:
		;
		numChars++
	}
	if result == TCL_OK && flags&int32(TCL_ENCODING_END) != 0 {
		len11 = (*(*TEscapeSubTable)(unsafe.Pointer(dataPtr + 304))).FsequenceLen
		/*
		 * Certain encodings like iso2022-jp need to write an escape sequence
		 * after all characters have been converted. This logic checks that
		 * enough room is available in the buffer for the escape bytes. The
		 * TCL_ENCODING_END flag is cleared after a final escape sequence has
		 * been added to the buffer so that another call to this method does
		 * not attempt to append escape bytes a second time.
		 */
		if state != 0 {
			v4 = len11
		} else {
			v4 = uint32(0)
		}
		if dst+uintptr((*TEscapeEncodingData)(unsafe.Pointer(dataPtr)).FfinalLen)+uintptr(v4) > dstEnd {
			result = -int32(4)
		} else {
			if state != 0 {
				libc.Xmemcpy(tls, dst, dataPtr+304+4, uint64(len11))
				dst += uintptr(len11)
			}
			libc.Xmemcpy(tls, dst, dataPtr+28, uint64((*TEscapeEncodingData)(unsafe.Pointer(dataPtr)).FfinalLen))
			dst += uintptr((*TEscapeEncodingData)(unsafe.Pointer(dataPtr)).FfinalLen)
			state &= ^libc.Int32FromInt32(TCL_ENCODING_END)
		}
	}
	*(*TTcl_EncodingState)(unsafe.Pointer(statePtr)) = uintptr(int64(state))
	*(*int32)(unsafe.Pointer(srcReadPtr)) = int32(int64(src) - int64(srcStart))
	*(*int32)(unsafe.Pointer(dstWrotePtr)) = int32(int64(dst) - int64(dstStart))
	*(*int32)(unsafe.Pointer(dstCharsPtr)) = numChars
	return result
}

/*
 *---------------------------------------------------------------------------
 *
 * EscapeFreeProc --
 *
 *	Frees resources used by the encoding.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Memory is freed.
 *
 *---------------------------------------------------------------------------
 */

func _EscapeFreeProc(tls *libc.TLS, clientData uintptr) {
	/* EscapeEncodingData that specifies
	 * encoding. */
	var dataPtr, subTablePtr uintptr
	var i int32
	_, _, _ = dataPtr, i, subTablePtr
	dataPtr = clientData
	if dataPtr == libc.UintptrFromInt32(0) {
		return
	}
	/*
	 * The subTables should be freed recursively in normal operation but not
	 * during TclFinalizeEncodingSubsystem because they are also present as a
	 * weak reference in the toplevel encodingTable (i.e., they don't have a
	 * +1 refcount for this), and unpredictable nuking order could remove them
	 * from under the following loop's feet. [Bug 2891556]
	 *
	 * The encodingsInitialized flag, being reset on entry to TFES, can serve
	 * as a "not in finalization" test.
	 */
	if _encodingsInitialized != 0 {
		subTablePtr = dataPtr + 304
		i = 0
		for {
			if !(i < (*TEscapeEncodingData)(unsafe.Pointer(dataPtr)).FnumSubTables) {
				break
			}
			_FreeEncoding(tls, (*TEscapeSubTable)(unsafe.Pointer(subTablePtr)).FencodingPtr)
			(*TEscapeSubTable)(unsafe.Pointer(subTablePtr)).FencodingPtr = libc.UintptrFromInt32(0)
			subTablePtr += 64
			goto _1
		_1:
			;
			i++
		}
	}
	XTclpFree(tls, dataPtr)
}

/*
 *---------------------------------------------------------------------------
 *
 * GetTableEncoding --
 *
 *	Helper function for the EscapeEncodingData conversions. Gets the
 *	encoding (of type TextEncodingData) that represents the specified
 *	state.
 *
 * Results:
 *	The return value is the encoding.
 *
 * Side effects:
 *	If the encoding that represents the specified state has not already
 *	been used by this EscapeEncoding, it will be loaded and cached in the
 *	dataPtr.
 *
 *---------------------------------------------------------------------------
 */

func _GetTableEncoding(tls *libc.TLS, dataPtr uintptr, state int32) (r uintptr) {
	/* Index in dataPtr of desired Encoding. */
	var encodingPtr, subTablePtr uintptr
	_, _ = encodingPtr, subTablePtr
	subTablePtr = dataPtr + 304 + uintptr(state)*64
	encodingPtr = (*TEscapeSubTable)(unsafe.Pointer(subTablePtr)).FencodingPtr
	if encodingPtr == libc.UintptrFromInt32(0) {
		encodingPtr = XTcl_GetEncoding(tls, libc.UintptrFromInt32(0), subTablePtr+20)
		if encodingPtr == libc.UintptrFromInt32(0) || (*TEncoding)(unsafe.Pointer(encodingPtr)).FtoUtfProc != __ccgo_fp(_TableToUtfProc) && (*TEncoding)(unsafe.Pointer(encodingPtr)).FtoUtfProc != __ccgo_fp(_Iso88591ToUtfProc) {
			XTcl_Panic(tls, __ccgo_ts+29371, 0)
		}
		(*TEscapeSubTable)(unsafe.Pointer(subTablePtr)).FencodingPtr = encodingPtr
	}
	return encodingPtr
}

/*
 *---------------------------------------------------------------------------
 *
 * unilen, unilen4 --
 *
 *	A helper function for the Tcl_ExternalToUtf functions. This function
 *	is similar to strlen for double-byte characters: it returns the number
 *	of bytes in a 0x0000 terminated string.
 *
 * Results:
 *	As above.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func _unilen(tls *libc.TLS, src uintptr) (r Tsize_t) {
	var p uintptr
	_ = p
	p = src
	for libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(p))) != 0x0000 {
		p += 2
	}
	return libc.Uint64FromInt64(int64(p) - int64(src))
}

func _unilen4(tls *libc.TLS, src uintptr) (r Tsize_t) {
	var p uintptr
	_ = p
	p = src
	for *(*uint32)(unsafe.Pointer(p)) != uint32(0x00000000) {
		p += 4
	}
	return libc.Uint64FromInt64(int64(p) - int64(src))
}

/*
 *-------------------------------------------------------------------------
 *
 * InitializeEncodingSearchPath	--
 *
 *	This is the fallback routine that sets the default value of the
 *	encoding search path if the application has not set one via a call to
 *	Tcl_SetEncodingSearchPath() by the first time the search path is needed
 *	to load encoding data.
 *
 *	The default encoding search path is produced by taking each directory
 *	in the library path, appending a subdirectory named "encoding", and if
 *	the resulting directory exists, adding it to the encoding search path.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Sets the encoding search path to an initial value.
 *
 *-------------------------------------------------------------------------
 */

func _InitializeEncodingSearchPath(tls *libc.TLS, valuePtr uintptr, lengthPtr uintptr, encodingPtr uintptr) {
	bp := tls.Alloc(176)
	defer tls.Free(176)
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, bytes, cachePtr, cachePtr1, libPathObj, pathObj, searchPathObj, v11, v12, v14, v7, v9 uintptr
	var i, v10, v13, v6, v8 TTcl_Size
	var v1, v2 bool
	var v4 int64
	var _ /* directoryObj at bp+24 */ uintptr
	var _ /* encodingObj at bp+16 */ uintptr
	var _ /* numBytes at bp+8 */ TTcl_Size
	var _ /* numDirs at bp+0 */ TTcl_Size
	var _ /* stat at bp+32 */ TTcl_StatBuf
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, bytes, cachePtr, cachePtr1, i, libPathObj, pathObj, searchPathObj, v1, v10, v11, v12, v13, v14, v2, v4, v6, v7, v8, v9
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		*(*uintptr)(unsafe.Pointer(bp + 16)) = XTclThreadAllocObj(tls)
	} else {
		*(*uintptr)(unsafe.Pointer(bp + 16)) = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount = 0
	if libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes, __ccgo_ts+5615, libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes + uintptr(libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(9) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr = libc.UintptrFromInt32(0)
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		searchPathObj = XTclThreadAllocObj(tls)
	} else {
		searchPathObj = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(searchPathObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(searchPathObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(searchPathObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(searchPathObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(searchPathObj)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount++
	(*TTcl_Obj)(unsafe.Pointer(searchPathObj)).FrefCount++
	libPathObj = XTclGetProcessGlobalValue(tls, uintptr(unsafe.Pointer(&_libraryPath)))
	(*TTcl_Obj)(unsafe.Pointer(libPathObj)).FrefCount++
	if (*TTcl_Obj)(unsafe.Pointer(libPathObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(libPathObj + 32))).Fptr2 != 0 {
			v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(libPathObj + 32))).Fptr2)).FspanLength
		} else {
			v4 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(libPathObj + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v4
		_ = libc.Int32FromInt32(TCL_OK)
	} else {
		XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), libPathObj, bp)
	}
	i = 0
	for {
		if !(i < *(*TTcl_Size)(unsafe.Pointer(bp))) {
			break
		}
		XTcl_ListObjIndex(tls, libc.UintptrFromInt32(0), libPathObj, i, bp+24)
		pathObj = XTcl_FSJoinToPath(tls, *(*uintptr)(unsafe.Pointer(bp + 24)), int64(1), bp+16)
		(*TTcl_Obj)(unsafe.Pointer(pathObj)).FrefCount++
		if 0 == XTcl_FSStat(tls, pathObj, bp+32) && (*(*TTcl_StatBuf)(unsafe.Pointer(bp + 32))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) {
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), searchPathObj, pathObj)
		}
		_objPtr = pathObj
		v7 = _objPtr
		v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
		*(*TTcl_Size)(unsafe.Pointer(v7))--
		if v6 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		goto _5
	_5:
		;
		i++
	}
	_objPtr1 = libPathObj
	v9 = _objPtr1
	v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
	*(*TTcl_Size)(unsafe.Pointer(v9))--
	if v8 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	_objPtr2 = *(*uintptr)(unsafe.Pointer(bp + 16))
	v11 = _objPtr2
	v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
	*(*TTcl_Size)(unsafe.Pointer(v11))--
	if v10 <= int64(1) {
		XTclFreeObj(tls, _objPtr2)
	}
	*(*TTcl_Encoding)(unsafe.Pointer(encodingPtr)) = _libraryPath.Fencoding
	if *(*TTcl_Encoding)(unsafe.Pointer(encodingPtr)) != 0 {
		(*TEncoding)(unsafe.Pointer(*(*TTcl_Encoding)(unsafe.Pointer(encodingPtr)))).FrefCount++
	}
	if (*TTcl_Obj)(unsafe.Pointer(searchPathObj)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(searchPathObj)).Flength
		v12 = (*TTcl_Obj)(unsafe.Pointer(searchPathObj)).Fbytes
	} else {
		v12 = XTcl_GetStringFromObj(tls, searchPathObj, bp+8)
	}
	bytes = v12
	*(*Tsize_t)(unsafe.Pointer(lengthPtr)) = libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
	*(*uintptr)(unsafe.Pointer(valuePtr)) = XTcl_Alloc(tls, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8))+int64(1)))
	libc.Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(valuePtr)), bytes, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8))+int64(1)))
	_objPtr3 = searchPathObj
	v14 = _objPtr3
	v13 = *(*TTcl_Size)(unsafe.Pointer(v14))
	*(*TTcl_Size)(unsafe.Pointer(v14))--
	if v13 <= int64(1) {
		XTclFreeObj(tls, _objPtr3)
	}
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * TclEncodingProfileParseName --
//	 *
//	 *	Maps an encoding profile name to its integer equivalent.
//	 *
//	 * Results:
//	 *	TCL_OK on success or TCL_ERROR on failure.
//	 *
//	 * Side effects:
//	 *	Returns the profile enum value in *profilePtr
//	 *
//	 *------------------------------------------------------------------------
//	 */
func XTclEncodingProfileNameToId(tls *libc.TLS, interp uintptr, profileName uintptr, profilePtr uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Output */
	var errorObj uintptr
	var i, numProfiles Tsize_t
	_, _, _ = errorObj, i, numProfiles
	numProfiles = libc.Uint64FromInt64(48) / libc.Uint64FromInt64(16)
	i = uint64(0)
	for {
		if !(i < numProfiles) {
			break
		}
		if !(libc.Xstrcmp(tls, profileName, _encodingProfiles[i].Fname) != 0) {
			*(*int32)(unsafe.Pointer(profilePtr)) = _encodingProfiles[i].Fvalue
			return TCL_OK
		}
		goto _1
	_1:
		;
		i++
	}
	if interp != 0 {
		/* This code assumes at least two profiles :-) */
		errorObj = XTcl_ObjPrintf(tls, __ccgo_ts+29406, libc.VaList(bp+8, profileName))
		i = uint64(0)
		for {
			if !(i < numProfiles-uint64(1)) {
				break
			}
			XTcl_AppendStringsToObj(tls, errorObj, libc.VaList(bp+8, __ccgo_ts+14830, _encodingProfiles[i].Fname, __ccgo_ts+21659, libc.UintptrFromInt32(0)))
			goto _2
		_2:
			;
			i++
		}
		XTcl_AppendStringsToObj(tls, errorObj, libc.VaList(bp+8, __ccgo_ts+29437, _encodingProfiles[numProfiles-uint64(1)].Fname, libc.UintptrFromInt32(0)))
		XTcl_SetObjResult(tls, interp, errorObj)
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+15139, __ccgo_ts+29442, profileName, libc.UintptrFromInt32(0)))
	}
	return int32(TCL_ERROR)
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * TclEncodingProfileValueToName --
//	 *
//	 *	Maps an encoding profile value to its name.
//	 *
//	 * Results:
//	 *	Pointer to the name or NULL on failure. Caller must not make
//	 *	not modify the string and must make a copy to hold on to it.
//	 *
//	 * Side effects:
//	 *	None.
//	 *------------------------------------------------------------------------
//	 */
func XTclEncodingProfileIdToName(tls *libc.TLS, interp uintptr, profileValue int32) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Profile #define value */
	var i Tsize_t
	_ = i
	i = uint64(0)
	for {
		if !(i < libc.Uint64FromInt64(48)/libc.Uint64FromInt64(16)) {
			break
		}
		if profileValue == _encodingProfiles[i].Fvalue {
			return _encodingProfiles[i].Fname
		}
		goto _1
	_1:
		;
		i++
	}
	if interp != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+29450, libc.VaList(bp+8, profileValue)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+15139, __ccgo_ts+29487, libc.UintptrFromInt32(0)))
	}
	return libc.UintptrFromInt32(0)
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * TclGetEncodingProfiles --
//	 *
//	 *	Get the list of supported encoding profiles.
//	 *
//	 * Results:
//	 *	None.
//	 *
//	 * Side effects:
//	 *	The list of profile names is stored in the interpreter result.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func XTclGetEncodingProfiles(tls *libc.TLS, interp uintptr) {
	var i, n Tsize_t
	var objPtr uintptr
	_, _, _ = i, n, objPtr
	n = libc.Uint64FromInt64(48) / libc.Uint64FromInt64(16)
	objPtr = XTcl_NewListObj(tls, libc.Int64FromUint64(n), libc.UintptrFromInt32(0))
	i = uint64(0)
	for {
		if !(i < n) {
			break
		}
		XTcl_ListObjAppendElement(tls, interp, objPtr, XTcl_NewStringObj(tls, _encodingProfiles[i].Fname, int64(-libc.Int32FromInt32(1))))
		goto _1
	_1:
		;
		i++
	}
	XTcl_SetObjResult(tls, interp, objPtr)
}

const PAGE_SIZE2 = 4096

/*
 * The lists of subcommands and options for the [namespace ensemble] command.
 */

var _ensembleSubcommands = [4]uintptr{
	0: __ccgo_ts + 29497,
	1: __ccgo_ts + 26194,
	2: __ccgo_ts + 5689,
	3: libc.UintptrFromInt32(0),
}

type EnsSubcmds = int32

const ENS_CONFIG = 0
const ENS_CREATE = 1
const ENS_EXISTS = 2

var _ensembleCreateOptions = [7]uintptr{
	0: __ccgo_ts + 18236,
	1: __ccgo_ts + 29507,
	2: __ccgo_ts + 29512,
	3: __ccgo_ts + 29524,
	4: __ccgo_ts + 29534,
	5: __ccgo_ts + 29547,
	6: libc.UintptrFromInt32(0),
}

type EnsCreateOpts = int32

const CRT_CMD = 0
const CRT_MAP = 1
const CRT_PARAM = 2
const CRT_PREFIX = 3
const CRT_SUBCMDS = 4
const CRT_UNKNOWN = 5

var _ensembleConfigOptions = [7]uintptr{
	0: __ccgo_ts + 29507,
	1: __ccgo_ts + 29556,
	2: __ccgo_ts + 29512,
	3: __ccgo_ts + 29524,
	4: __ccgo_ts + 29534,
	5: __ccgo_ts + 29547,
	6: libc.UintptrFromInt32(0),
}

type EnsConfigOpts = int32

const CONF_MAP = 0
const CONF_NAMESPACE = 1
const CONF_PARAM = 2
const CONF_PREFIX = 3
const CONF_SUBCMDS = 4
const CONF_UNKNOWN = 5

/*
 * ensembleCmdType is a Tcl object type that contains a reference to an
 * ensemble subcommand, e.g. the "length" in [string length ab]. It is used
 * to cache the mapping between the subcommand itself and the real command
 * that implements it.
 */

var _ensembleCmdType = TTcl_ObjType{
	Fname: __ccgo_ts + 29567,
}

func init() {
	p := unsafe.Pointer(&_ensembleCmdType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_FreeEnsembleCmdRep)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_DupEnsembleCmdRep)
}

/*
 * The internal rep for caching ensemble subcommand lookups and spelling
 * corrections.
 */

type TEnsembleCmdRep = struct {
	Fepoch TTcl_Size
	Ftoken uintptr
	Ffix   uintptr
	FhPtr  uintptr
}

/*
 *----------------------------------------------------------------------
 *
 * TclNamespaceEnsembleCmd --
 *
 *	Invoked to implement the "namespace ensemble" command that creates and
 *	manipulates ensembles built on top of namespaces. Handles the
 *	following syntax:
 *
 *	    namespace ensemble name ?dictionary?
 *
 * Results:
 *	Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
 *
 * Side effects:
 *	Creates the ensemble for the namespace if one did not previously
 *	exist. Alternatively, alters the way that the ensemble's subcommand =>
 *	implementation prefix is configured.
 *
 *----------------------------------------------------------------------
 */

func XTclNamespaceEnsembleCmd(tls *libc.TLS, dummy152 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var nsPtr uintptr
	var token TTcl_Command
	var _ /* index at bp+0 */ EnsSubcmds
	_, _ = nsPtr, token
	nsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FnsPtr
	if nsPtr == libc.UintptrFromInt32(0) || (*TNamespace)(unsafe.Pointer(nsPtr)).Fflags&int32(NS_DEAD) != 0 {
		if !(XTcl_InterpDeleted(tls, interp) != 0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+29583, int64(-libc.Int32FromInt32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+29633, __ccgo_ts+29642, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+29647)
		return int32(TCL_ERROR)
	} else {
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), uintptr(unsafe.Pointer(&_ensembleSubcommands)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+25008, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
			return int32(TCL_ERROR)
		}
	}
	switch *(*EnsSubcmds)(unsafe.Pointer(bp)) {
	case int32(ENS_CREATE):
		/*
		 * Check that we've got option-value pairs... [Bug 1558654]
		 */
		if objc&int32(1) != 0 {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+29668)
			return int32(TCL_ERROR)
		}
		token = _InitEnsembleFromOptions(tls, interp, objc-int32(2), objv+uintptr(2)*8)
		if token == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
		/*
		 * Tricky! Must ensure that the result is not shared (command delete
		 * traces could have corrupted the pristine object that we started
		 * with). [Snit test rename-1.5]
		 */
		XTcl_ResetResult(tls, interp)
		XTcl_GetCommandFullName(tls, interp, token, XTcl_GetObjResult(tls, interp))
		return TCL_OK
	case int32(ENS_EXISTS):
		if objc != int32(3) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+29687)
			return int32(TCL_ERROR)
		}
		XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(libc.BoolInt32(XTcl_FindEnsemble(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), 0) != libc.UintptrFromInt32(0)) != 0)))
		return TCL_OK
	case int32(ENS_CONFIG):
		if objc < int32(3) || objc != int32(4) && !(objc&libc.Int32FromInt32(1) != 0) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+29695)
			return int32(TCL_ERROR)
		}
		token = XTcl_FindEnsemble(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), int32(TCL_LEAVE_ERR_MSG))
		if token == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
		if objc == int32(4) {
			return _ReadOneEnsembleOption(tls, interp, token, *(*uintptr)(unsafe.Pointer(objv + 3*8)))
		} else {
			if objc == int32(3) {
				return _ReadAllEnsembleOptions(tls, interp, token)
			} else {
				return _SetEnsembleConfigOptions(tls, interp, token, objc-int32(3), objv+uintptr(3)*8)
			}
		}
		fallthrough
	default:
		XTcl_Panic(tls, __ccgo_ts+29733, 0)
	}
	return TCL_OK
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * InitEnsembleFromOptions --
//	 *
//	 *	Core of implementation of "namespace ensemble create".
//	 *
//	 * Results:
//	 *	Returns created ensemble's command token if successful, and NULL if
//	 *	anything goes wrong.
//	 *
//	 * Side effects:
//	 *	Creates the ensemble for the namespace if one did not previously
//	 *	exist.
//	 *
//	 * Note:
//	 *	Can't use SetEnsembleConfigOptions() here. Different (but overlapping)
//	 *	options are supported.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _InitEnsembleFromOptions(tls *libc.TLS, interp uintptr, objc int32, objv uintptr) (r TTcl_Command) {
	bp := tls.Alloc(160)
	defer tls.Free(160)
	var _objPtr, _objPtr1, _objPtr2, cmd, cxtPtr, mapObj, name, newList, nsPtr, paramObj, patchedDict, subcmdObj, unknownObj, v12, v15, v19, v21, v22, v24, v27, v30, v9 uintptr
	var allocatedMapFlag, v10, v13, v16, v25, v28 int32
	var token TTcl_Command
	var v11, v14, v17, v18, v26 int64
	var v20, v23, v29 TTcl_Size
	var _ /* actualCxtPtr at bp+8 */ uintptr
	var _ /* altFoundNsPtr at bp+0 */ uintptr
	var _ /* done at bp+96 */ int32
	var _ /* foundNsPtr at bp+32 */ uintptr
	var _ /* index at bp+24 */ EnsCreateOpts
	var _ /* len at bp+16 */ TTcl_Size
	var _ /* listObj at bp+64 */ uintptr
	var _ /* listv at bp+104 */ uintptr
	var _ /* newCmd at bp+112 */ uintptr
	var _ /* permitPrefix at bp+48 */ int32
	var _ /* search at bp+72 */ TTcl_DictSearch
	var _ /* simpleName at bp+40 */ uintptr
	var _ /* subcmdWordsObj at bp+56 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, allocatedMapFlag, cmd, cxtPtr, mapObj, name, newList, nsPtr, paramObj, patchedDict, subcmdObj, token, unknownObj, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v9
	nsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FnsPtr
	cxtPtr = (*TNamespace)(unsafe.Pointer(nsPtr)).FparentPtr
	name = (*TNamespace)(unsafe.Pointer(nsPtr)).Fname
	allocatedMapFlag = 0
	/*
	 * Defaults
	 */
	subcmdObj = libc.UintptrFromInt32(0)
	mapObj = libc.UintptrFromInt32(0)
	*(*int32)(unsafe.Pointer(bp + 48)) = int32(1)
	unknownObj = libc.UintptrFromInt32(0)
	paramObj = libc.UintptrFromInt32(0)
	/*
	 * Parse the option list, applying type checks as we go. Note that we are
	 * not incrementing any reference counts in the objects at this stage, so
	 * the presence of an option multiple times won't cause any memory leaks.
	 */
	for {
		if !(objc > int32(1)) {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv)), uintptr(unsafe.Pointer(&_ensembleCreateOptions)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+24) != TCL_OK {
			goto error
		}
		switch *(*EnsCreateOpts)(unsafe.Pointer(bp + 24)) {
		case int32(CRT_CMD):
			goto _2
		case int32(CRT_SUBCMDS):
			goto _3
		case int32(CRT_PARAM):
			goto _4
		case int32(CRT_MAP):
			goto _5
		case int32(CRT_PREFIX):
			goto _6
		case int32(CRT_UNKNOWN):
			goto _7
		}
		goto _8
	_2:
		;
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
			v9 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
		} else {
			v9 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
		}
		name = v9
		cxtPtr = nsPtr
		goto _1
	_3:
		;
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
				v11 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanLength
			} else {
				v11 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = v11
			v10 = libc.Int32FromInt32(TCL_OK)
		} else {
			v10 = XTcl_ListObjLength(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+16)
		}
		if v10 != TCL_OK {
			goto error
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) > 0 {
			v12 = *(*uintptr)(unsafe.Pointer(objv + 1*8))
		} else {
			v12 = libc.UintptrFromInt32(0)
		}
		subcmdObj = v12
		goto _1
	_4:
		;
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
				v14 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanLength
			} else {
				v14 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = v14
			v13 = libc.Int32FromInt32(TCL_OK)
		} else {
			v13 = XTcl_ListObjLength(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+16)
		}
		if v13 != TCL_OK {
			goto error
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) > 0 {
			v15 = *(*uintptr)(unsafe.Pointer(objv + 1*8))
		} else {
			v15 = libc.UintptrFromInt32(0)
		}
		paramObj = v15
		goto _1
	_5:
		;
		patchedDict = libc.UintptrFromInt32(0)
		/*
		 * Verify that the map is sensible.
		 */
		if XTcl_DictObjFirst(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+72, bp+56, bp+64, bp+96) != TCL_OK {
			goto error
		} else {
			if *(*int32)(unsafe.Pointer(bp + 96)) != 0 {
				mapObj = libc.UintptrFromInt32(0)
				goto _1
			}
		}
		for cond := true; cond; cond = !(*(*int32)(unsafe.Pointer(bp + 96)) != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 64)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 64)) + 32))).Fptr2 != 0 {
					v17 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 64)) + 32))).Fptr2)).FspanStart
				} else {
					v17 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 64)) + 32))).Fptr1)).FfirstUsed
				}
				*(*uintptr)(unsafe.Pointer(bp + 104)) = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 64)) + 32))).Fptr1 + 40 + uintptr(v17)*8
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 64)) + 32))).Fptr2 != 0 {
					v18 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 64)) + 32))).Fptr2)).FspanLength
				} else {
					v18 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 64)) + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = v18
				v16 = libc.Int32FromInt32(TCL_OK)
			} else {
				v16 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 64)), bp+16, bp+104)
			}
			if v16 != TCL_OK {
				goto mapError
			}
			if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) < int64(1) {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+29761, int64(-libc.Int32FromInt32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+128, __ccgo_ts+2004, __ccgo_ts+29633, __ccgo_ts+29821, libc.UintptrFromInt32(0)))
				goto mapError
			}
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 104)))))).Fbytes != 0 {
				v19 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 104)))))).Fbytes
			} else {
				v19 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 104)))), libc.UintptrFromInt32(0))
			}
			cmd = v19
			if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cmd))) == int32(':') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cmd + 1))) == int32(':')) {
				newList = XTcl_NewListObj(tls, *(*TTcl_Size)(unsafe.Pointer(bp + 16)), *(*uintptr)(unsafe.Pointer(bp + 104)))
				*(*uintptr)(unsafe.Pointer(bp + 112)) = XTclNewNamespaceObj(tls, nsPtr)
				if (*TNamespace)(unsafe.Pointer(nsPtr)).FparentPtr != 0 {
					XTcl_AppendStringsToObj(tls, *(*uintptr)(unsafe.Pointer(bp + 112)), libc.VaList(bp+128, __ccgo_ts+7650, libc.UintptrFromInt32(0)))
				}
				XTcl_AppendObjToObj(tls, *(*uintptr)(unsafe.Pointer(bp + 112)), *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 104)))))
				XTcl_ListObjReplace(tls, libc.UintptrFromInt32(0), newList, 0, int64(1), int64(1), bp+112)
				if patchedDict == libc.UintptrFromInt32(0) {
					patchedDict = XTcl_DuplicateObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
				}
				XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), patchedDict, *(*uintptr)(unsafe.Pointer(bp + 56)), newList)
			}
			XTcl_DictObjNext(tls, bp+72, bp+56, bp+64, bp+96)
		}
		if allocatedMapFlag != 0 {
			_objPtr = mapObj
			v21 = _objPtr
			v20 = *(*TTcl_Size)(unsafe.Pointer(v21))
			*(*TTcl_Size)(unsafe.Pointer(v21))--
			if v20 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
		if patchedDict != 0 {
			v22 = patchedDict
		} else {
			v22 = *(*uintptr)(unsafe.Pointer(objv + 1*8))
		}
		mapObj = v22
		if patchedDict != 0 {
			allocatedMapFlag = int32(1)
		}
		goto _1
		goto mapError
	mapError:
		;
		XTcl_DictObjDone(tls, bp+72)
		if patchedDict != 0 {
			_objPtr1 = patchedDict
			v24 = _objPtr1
			v23 = *(*TTcl_Size)(unsafe.Pointer(v24))
			*(*TTcl_Size)(unsafe.Pointer(v24))--
			if v23 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
		}
		goto error
	_6:
		;
		if XTcl_GetBoolFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), (libc.Int32FromInt32(TCL_NULL_OK)-libc.Int32FromInt32(2))&libc.Int32FromInt64(4), bp+48) != TCL_OK {
			goto error
		}
		goto _1
	_7:
		;
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
				v26 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanLength
			} else {
				v26 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = v26
			v25 = libc.Int32FromInt32(TCL_OK)
		} else {
			v25 = XTcl_ListObjLength(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+16)
		}
		if v25 != TCL_OK {
			goto error
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) > 0 {
			v27 = *(*uintptr)(unsafe.Pointer(objv + 1*8))
		} else {
			v27 = libc.UintptrFromInt32(0)
		}
		unknownObj = v27
		goto _1
	_8:
		;
		goto _1
	_1:
		;
		objc -= int32(2)
		objv += uintptr(2) * 8
	}
	XTclGetNamespaceForQualName(tls, interp, name, cxtPtr, int32(TCL_CREATE_NS_IF_UNKNOWN), bp+32, bp, bp+8, bp+40)
	/*
	 * Create the ensemble. Note that this might delete another ensemble
	 * linked to the same namespace, so we must be careful. However, we
	 * should be OK because we only link the namespace into the list once
	 * we've created it (and after any deletions have occurred.)
	 */
	if *(*int32)(unsafe.Pointer(bp + 48)) != 0 {
		v28 = int32(TCL_ENSEMBLE_PREFIX)
	} else {
		v28 = 0
	}
	token = XTclCreateEnsembleInNs(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 40)), *(*uintptr)(unsafe.Pointer(bp + 32)), nsPtr, v28)
	XTcl_SetEnsembleSubcommandList(tls, interp, token, subcmdObj)
	XTcl_SetEnsembleMappingDict(tls, interp, token, mapObj)
	XTcl_SetEnsembleUnknownHandler(tls, interp, token, unknownObj)
	XTcl_SetEnsembleParameterList(tls, interp, token, paramObj)
	return token
	goto error
error:
	;
	if allocatedMapFlag != 0 {
		_objPtr2 = mapObj
		v30 = _objPtr2
		v29 = *(*TTcl_Size)(unsafe.Pointer(v30))
		*(*TTcl_Size)(unsafe.Pointer(v30))--
		if v29 <= int64(1) {
			XTclFreeObj(tls, _objPtr2)
		}
	}
	return libc.UintptrFromInt32(0)
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * ReadOneEnsembleOption --
//	 *
//	 *	Core of implementation of "namespace ensemble configure" with just a
//	 *	single option name.
//	 *
//	 * Results:
//	 *	Tcl result code. Modifies the interpreter result.
//	 *
//	 * Side effects:
//	 *	None.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _ReadOneEnsembleOption(tls *libc.TLS, interp uintptr, token TTcl_Command, optionObj uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* The name of the option to read. */
	var _ /* flags at bp+24 */ int32
	var _ /* index at bp+8 */ EnsConfigOpts
	var _ /* namespacePtr at bp+16 */ uintptr
	var _ /* resultObj at bp+0 */ uintptr
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	if XTcl_GetIndexFromObjStruct(tls, interp, optionObj, uintptr(unsafe.Pointer(&_ensembleConfigOptions)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+8) != TCL_OK {
		return int32(TCL_ERROR)
	}
	switch *(*EnsConfigOpts)(unsafe.Pointer(bp + 8)) {
	case int32(CONF_SUBCMDS):
		XTcl_GetEnsembleSubcommandList(tls, libc.UintptrFromInt32(0), token, bp)
		if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(bp)))
		}
	case int32(CONF_PARAM):
		XTcl_GetEnsembleParameterList(tls, libc.UintptrFromInt32(0), token, bp)
		if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(bp)))
		}
	case int32(CONF_MAP):
		XTcl_GetEnsembleMappingDict(tls, libc.UintptrFromInt32(0), token, bp)
		if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(bp)))
		}
	case int32(CONF_NAMESPACE):
		*(*uintptr)(unsafe.Pointer(bp + 16)) = libc.UintptrFromInt32(0) /* silence gcc 4 warning */
		XTcl_GetEnsembleNamespace(tls, libc.UintptrFromInt32(0), token, bp+16)
		XTcl_SetObjResult(tls, interp, XTclNewNamespaceObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16))))
	case int32(CONF_PREFIX):
		*(*int32)(unsafe.Pointer(bp + 24)) = 0 /* silence gcc 4 warning */
		XTcl_GetEnsembleFlags(tls, libc.UintptrFromInt32(0), token, bp+24)
		XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(*(*int32)(unsafe.Pointer(bp + 24))&int32(TCL_ENSEMBLE_PREFIX) != 0)))
	case int32(CONF_UNKNOWN):
		XTcl_GetEnsembleUnknownHandler(tls, libc.UintptrFromInt32(0), token, bp)
		if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(bp)))
		}
		break
	}
	return TCL_OK
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * ReadAllEnsembleOptions --
//	 *
//	 *	Core of implementation of "namespace ensemble configure" without
//	 *	option names.
//	 *
//	 * Results:
//	 *	Tcl result code. Modifies the interpreter result.
//	 *
//	 * Side effects:
//	 *	None.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _ReadAllEnsembleOptions(tls *libc.TLS, interp uintptr, token TTcl_Command) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* The ensemble to read from. */
	var cachePtr, resultObj, v2, v3, v4, v5 uintptr
	var v1 bool
	var _ /* flags at bp+8 */ int32
	var _ /* namespacePtr at bp+16 */ uintptr
	var _ /* tmpObj at bp+0 */ uintptr
	_, _, _, _, _, _, _ = cachePtr, resultObj, v1, v2, v3, v4, v5
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)      /* silence gcc 4 warning */
	*(*int32)(unsafe.Pointer(bp + 8)) = 0                           /* silence gcc 4 warning */
	*(*uintptr)(unsafe.Pointer(bp + 16)) = libc.UintptrFromInt32(0) /* silence gcc 4 warning */
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	/* -map option */
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, XTcl_NewStringObj(tls, _ensembleConfigOptions[int32(CONF_MAP)], int64(-libc.Int32FromInt32(1))))
	XTcl_GetEnsembleMappingDict(tls, libc.UintptrFromInt32(0), token, bp)
	if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
		v2 = *(*uintptr)(unsafe.Pointer(bp))
	} else {
		v2 = XTcl_NewObj(tls)
	}
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, v2)
	/* -namespace option */
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, XTcl_NewStringObj(tls, _ensembleConfigOptions[int32(CONF_NAMESPACE)], int64(-libc.Int32FromInt32(1))))
	XTcl_GetEnsembleNamespace(tls, libc.UintptrFromInt32(0), token, bp+16)
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, XTclNewNamespaceObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16))))
	/* -parameters option */
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, XTcl_NewStringObj(tls, _ensembleConfigOptions[int32(CONF_PARAM)], int64(-libc.Int32FromInt32(1))))
	XTcl_GetEnsembleParameterList(tls, libc.UintptrFromInt32(0), token, bp)
	if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
		v3 = *(*uintptr)(unsafe.Pointer(bp))
	} else {
		v3 = XTcl_NewObj(tls)
	}
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, v3)
	/* -prefix option */
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, XTcl_NewStringObj(tls, _ensembleConfigOptions[int32(CONF_PREFIX)], int64(-libc.Int32FromInt32(1))))
	XTcl_GetEnsembleFlags(tls, libc.UintptrFromInt32(0), token, bp+8)
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, XTcl_NewWideIntObj(tls, libc.BoolInt64(*(*int32)(unsafe.Pointer(bp + 8))&int32(TCL_ENSEMBLE_PREFIX) != 0)))
	/* -subcommands option */
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, XTcl_NewStringObj(tls, _ensembleConfigOptions[int32(CONF_SUBCMDS)], int64(-libc.Int32FromInt32(1))))
	XTcl_GetEnsembleSubcommandList(tls, libc.UintptrFromInt32(0), token, bp)
	if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
		v4 = *(*uintptr)(unsafe.Pointer(bp))
	} else {
		v4 = XTcl_NewObj(tls)
	}
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, v4)
	/* -unknown option */
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, XTcl_NewStringObj(tls, _ensembleConfigOptions[int32(CONF_UNKNOWN)], int64(-libc.Int32FromInt32(1))))
	XTcl_GetEnsembleUnknownHandler(tls, libc.UintptrFromInt32(0), token, bp)
	if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
		v5 = *(*uintptr)(unsafe.Pointer(bp))
	} else {
		v5 = XTcl_NewObj(tls)
	}
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, v5)
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * SetEnsembleConfigOptions --
//	 *
//	 *	Core of implementation of "namespace ensemble configure" with even
//	 *	number of arguments (where there is at least one pair).
//	 *
//	 * Results:
//	 *	Tcl result code. Modifies the interpreter result.
//	 *
//	 * Side effects:
//	 *	Modifies the ensemble's configuration.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _SetEnsembleConfigOptions(tls *libc.TLS, interp uintptr, token TTcl_Command, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(160)
	defer tls.Free(160) /* Option-related arguments. */
	var _objPtr, _objPtr1, _objPtr2, cmd, newList, nsPtr, patchedDict, v11, v14, v20, v22, v23, v25, v28, v31 uintptr
	var allocatedMapFlag, v12, v15, v17, v26, v29, v9 int32
	var v10, v13, v16, v18, v19, v27 int64
	var v21, v24, v30 TTcl_Size
	var _ /* done at bp+84 */ int32
	var _ /* flags at bp+76 */ int32
	var _ /* index at bp+80 */ EnsConfigOpts
	var _ /* len at bp+0 */ TTcl_Size
	var _ /* listObj at bp+40 */ uintptr
	var _ /* listv at bp+96 */ uintptr
	var _ /* mapObj at bp+16 */ uintptr
	var _ /* newCmd at bp+104 */ uintptr
	var _ /* paramObj at bp+24 */ uintptr
	var _ /* permitPrefix at bp+72 */ int32
	var _ /* search at bp+48 */ TTcl_DictSearch
	var _ /* subcmdObj at bp+8 */ uintptr
	var _ /* subcmdWordsObj at bp+88 */ uintptr
	var _ /* unknownObj at bp+32 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, allocatedMapFlag, cmd, newList, nsPtr, patchedDict, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v9
	allocatedMapFlag = 0
	*(*uintptr)(unsafe.Pointer(bp + 8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(bp + 16)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(bp + 24)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(bp + 32)) = libc.UintptrFromInt32(0)
	*(*int32)(unsafe.Pointer(bp + 76)) = 0
	XTcl_GetEnsembleSubcommandList(tls, libc.UintptrFromInt32(0), token, bp+8)
	XTcl_GetEnsembleMappingDict(tls, libc.UintptrFromInt32(0), token, bp+16)
	XTcl_GetEnsembleParameterList(tls, libc.UintptrFromInt32(0), token, bp+24)
	XTcl_GetEnsembleUnknownHandler(tls, libc.UintptrFromInt32(0), token, bp+32)
	XTcl_GetEnsembleFlags(tls, libc.UintptrFromInt32(0), token, bp+76)
	*(*int32)(unsafe.Pointer(bp + 72)) = libc.BoolInt32(*(*int32)(unsafe.Pointer(bp + 76))&int32(TCL_ENSEMBLE_PREFIX) != 0)
	/*
	 * Parse the option list, applying type checks as we go. Note that
	 * we are not incrementing any reference counts in the objects at
	 * this stage, so the presence of an option multiple times won't
	 * cause any memory leaks.
	 */
	for {
		if !(objc > 0) {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv)), uintptr(unsafe.Pointer(&_ensembleConfigOptions)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+80) != TCL_OK {
			goto freeMapAndError
		}
		switch *(*EnsConfigOpts)(unsafe.Pointer(bp + 80)) {
		case int32(CONF_SUBCMDS):
			goto _2
		case int32(CONF_PARAM):
			goto _3
		case int32(CONF_MAP):
			goto _4
		case int32(CONF_NAMESPACE):
			goto _5
		case int32(CONF_PREFIX):
			goto _6
		case int32(CONF_UNKNOWN):
			goto _7
		}
		goto _8
	_2:
		;
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
				v10 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanLength
			} else {
				v10 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp)) = v10
			v9 = libc.Int32FromInt32(TCL_OK)
		} else {
			v9 = XTcl_ListObjLength(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
		}
		if v9 != TCL_OK {
			goto freeMapAndError
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp)) > 0 {
			v11 = *(*uintptr)(unsafe.Pointer(objv + 1*8))
		} else {
			v11 = libc.UintptrFromInt32(0)
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = v11
		goto _1
	_3:
		;
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
				v13 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanLength
			} else {
				v13 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp)) = v13
			v12 = libc.Int32FromInt32(TCL_OK)
		} else {
			v12 = XTcl_ListObjLength(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
		}
		if v12 != TCL_OK {
			goto freeMapAndError
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp)) > 0 {
			v14 = *(*uintptr)(unsafe.Pointer(objv + 1*8))
		} else {
			v14 = libc.UintptrFromInt32(0)
		}
		*(*uintptr)(unsafe.Pointer(bp + 24)) = v14
		goto _1
	_4:
		;
		patchedDict = libc.UintptrFromInt32(0)
		nsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FnsPtr
		/*
		 * Verify that the map is sensible.
		 */
		if XTcl_DictObjFirst(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+48, bp+88, bp+40, bp+84) != TCL_OK {
			goto freeMapAndError
		} else {
			if *(*int32)(unsafe.Pointer(bp + 84)) != 0 {
				*(*uintptr)(unsafe.Pointer(bp + 16)) = libc.UintptrFromInt32(0)
				goto _1
			}
		}
		for cond := true; cond; cond = !(*(*int32)(unsafe.Pointer(bp + 84)) != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr2 != 0 {
					v16 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr2)).FspanLength
				} else {
					v16 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp)) = v16
				v15 = libc.Int32FromInt32(TCL_OK)
			} else {
				v15 = XTcl_ListObjLength(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 40)), bp)
			}
			if v15 != TCL_OK {
				goto finishSearchAndError
			}
			if *(*TTcl_Size)(unsafe.Pointer(bp)) < int64(1) {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+29761, int64(-libc.Int32FromInt32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+120, __ccgo_ts+2004, __ccgo_ts+29633, __ccgo_ts+29821, libc.UintptrFromInt32(0)))
				goto finishSearchAndError
			}
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr2 != 0 {
					v18 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr2)).FspanStart
				} else {
					v18 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr1)).FfirstUsed
				}
				*(*uintptr)(unsafe.Pointer(bp + 96)) = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr1 + 40 + uintptr(v18)*8
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr2 != 0 {
					v19 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr2)).FspanLength
				} else {
					v19 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp)) = v19
				v17 = libc.Int32FromInt32(TCL_OK)
			} else {
				v17 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 40)), bp, bp+96)
			}
			if v17 != TCL_OK {
				goto finishSearchAndError
			}
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 96)))))).Fbytes != 0 {
				v20 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 96)))))).Fbytes
			} else {
				v20 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 96)))), libc.UintptrFromInt32(0))
			}
			cmd = v20
			if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cmd))) == int32(':') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cmd + 1))) == int32(':')) {
				newList = XTcl_DuplicateObj(tls, *(*uintptr)(unsafe.Pointer(bp + 40)))
				*(*uintptr)(unsafe.Pointer(bp + 104)) = XTclNewNamespaceObj(tls, nsPtr)
				if (*TNamespace)(unsafe.Pointer(nsPtr)).FparentPtr != 0 {
					XTcl_AppendStringsToObj(tls, *(*uintptr)(unsafe.Pointer(bp + 104)), libc.VaList(bp+120, __ccgo_ts+7650, libc.UintptrFromInt32(0)))
				}
				XTcl_AppendObjToObj(tls, *(*uintptr)(unsafe.Pointer(bp + 104)), *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 96)))))
				XTcl_ListObjReplace(tls, libc.UintptrFromInt32(0), newList, 0, int64(1), int64(1), bp+104)
				if patchedDict == libc.UintptrFromInt32(0) {
					patchedDict = XTcl_DuplicateObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
				}
				XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), patchedDict, *(*uintptr)(unsafe.Pointer(bp + 88)), newList)
			}
			XTcl_DictObjNext(tls, bp+48, bp+88, bp+40, bp+84)
		}
		if allocatedMapFlag != 0 {
			_objPtr = *(*uintptr)(unsafe.Pointer(bp + 16))
			v22 = _objPtr
			v21 = *(*TTcl_Size)(unsafe.Pointer(v22))
			*(*TTcl_Size)(unsafe.Pointer(v22))--
			if v21 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
		if patchedDict != 0 {
			v23 = patchedDict
		} else {
			v23 = *(*uintptr)(unsafe.Pointer(objv + 1*8))
		}
		*(*uintptr)(unsafe.Pointer(bp + 16)) = v23
		if patchedDict != 0 {
			allocatedMapFlag = int32(1)
		}
		goto _1
		goto finishSearchAndError
	finishSearchAndError:
		;
		XTcl_DictObjDone(tls, bp+48)
		if patchedDict != 0 {
			_objPtr1 = patchedDict
			v25 = _objPtr1
			v24 = *(*TTcl_Size)(unsafe.Pointer(v25))
			*(*TTcl_Size)(unsafe.Pointer(v25))--
			if v24 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
		}
		goto freeMapAndError
	_5:
		;
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+29834, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+120, __ccgo_ts+2004, __ccgo_ts+29633, __ccgo_ts+29865, libc.UintptrFromInt32(0)))
		goto freeMapAndError
	_6:
		;
		if XTcl_GetBoolFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), (libc.Int32FromInt32(TCL_NULL_OK)-libc.Int32FromInt32(2))&libc.Int32FromInt64(4), bp+72) != TCL_OK {
			goto freeMapAndError
		}
		goto _1
	_7:
		;
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
				v27 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanLength
			} else {
				v27 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp)) = v27
			v26 = libc.Int32FromInt32(TCL_OK)
		} else {
			v26 = XTcl_ListObjLength(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
		}
		if v26 != TCL_OK {
			goto freeMapAndError
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp)) > 0 {
			v28 = *(*uintptr)(unsafe.Pointer(objv + 1*8))
		} else {
			v28 = libc.UintptrFromInt32(0)
		}
		*(*uintptr)(unsafe.Pointer(bp + 32)) = v28
		goto _1
	_8:
		;
		goto _1
	_1:
		;
		objc -= int32(2)
		objv += uintptr(2) * 8
	}
	/*
	 * Update the namespace now that we've finished the parsing stage.
	 */
	if *(*int32)(unsafe.Pointer(bp + 72)) != 0 {
		v29 = *(*int32)(unsafe.Pointer(bp + 76)) | int32(TCL_ENSEMBLE_PREFIX)
	} else {
		v29 = *(*int32)(unsafe.Pointer(bp + 76)) & ^libc.Int32FromInt32(TCL_ENSEMBLE_PREFIX)
	}
	*(*int32)(unsafe.Pointer(bp + 76)) = v29
	XTcl_SetEnsembleSubcommandList(tls, interp, token, *(*uintptr)(unsafe.Pointer(bp + 8)))
	XTcl_SetEnsembleMappingDict(tls, interp, token, *(*uintptr)(unsafe.Pointer(bp + 16)))
	XTcl_SetEnsembleParameterList(tls, interp, token, *(*uintptr)(unsafe.Pointer(bp + 24)))
	XTcl_SetEnsembleUnknownHandler(tls, interp, token, *(*uintptr)(unsafe.Pointer(bp + 32)))
	XTcl_SetEnsembleFlags(tls, interp, token, *(*int32)(unsafe.Pointer(bp + 76)))
	return TCL_OK
	goto freeMapAndError
freeMapAndError:
	;
	if allocatedMapFlag != 0 {
		_objPtr2 = *(*uintptr)(unsafe.Pointer(bp + 16))
		v31 = _objPtr2
		v30 = *(*TTcl_Size)(unsafe.Pointer(v31))
		*(*TTcl_Size)(unsafe.Pointer(v31))--
		if v30 <= int64(1) {
			XTclFreeObj(tls, _objPtr2)
		}
	}
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * TclCreateEnsembleInNs --
 *
 *	Like Tcl_CreateEnsemble, but additionally accepts as an argument the
 *	name of the namespace to create the command in.
 *
 *----------------------------------------------------------------------
 */

func XTclCreateEnsembleInNs(tls *libc.TLS, interp uintptr, name uintptr, nameNsPtr uintptr, ensembleNsPtr uintptr, flags int32) (r TTcl_Command) {
	/* Whether we need exact matching and whether
	 * we bytecode-compile the ensemble's uses. */
	var ensemblePtr, nsPtr uintptr
	var token TTcl_Command
	_, _, _ = ensemblePtr, nsPtr, token
	nsPtr = ensembleNsPtr
	ensemblePtr = XTcl_Alloc(tls, uint64(192))
	token = XTclNRCreateCommandInNs(tls, interp, name, nameNsPtr, __ccgo_fp(XTclEnsembleImplementationCmd), __ccgo_fp(_NsEnsembleImplementationCmdNR), ensemblePtr, __ccgo_fp(_DeleteEnsembleConfig))
	if token == libc.UintptrFromInt32(0) {
		XTclpFree(tls, ensemblePtr)
		return libc.UintptrFromInt32(0)
	}
	(*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FnsPtr = nsPtr
	(*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).Fepoch = 0
	XTcl_InitHashTable(tls, ensemblePtr+32, TCL_STRING_KEYS)
	(*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcommandArrayPtr = libc.UintptrFromInt32(0)
	(*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcmdList = libc.UintptrFromInt32(0)
	(*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcommandDict = libc.UintptrFromInt32(0)
	(*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).Fflags = flags
	(*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FnumParameters = 0
	(*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FparameterList = libc.UintptrFromInt32(0)
	(*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FunknownHandler = libc.UintptrFromInt32(0)
	(*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).Ftoken = token
	(*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).Fnext = (*TNamespace)(unsafe.Pointer(nsPtr)).Fensembles
	(*TNamespace)(unsafe.Pointer(nsPtr)).Fensembles = ensemblePtr
	/*
	 * Trigger an eventual recomputation of the ensemble command set. Note
	 * that this is slightly tricky, as it means that we are not actually
	 * counting the number of namespace export actions, but it is the simplest
	 * way to go!
	 */
	(*TNamespace)(unsafe.Pointer(nsPtr)).FexportLookupEpoch++
	if flags&int32(ENSEMBLE_COMPILE) != 0 {
		(*TCommand)(unsafe.Pointer((*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).Ftoken)).FcompileProc = __ccgo_fp(XTclCompileEnsemble)
	}
	return (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).Ftoken
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_CreateEnsemble
 *
 *	Create a simple ensemble attached to the given namespace. Deprecated
 *	(internally) by TclCreateEnsembleInNs.
 *
 * Value
 *
 *	The token for the command created.
 *
 * Effect
 *	The ensemble is created and marked for compilation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_CreateEnsemble(tls *libc.TLS, interp uintptr, name uintptr, namespacePtr uintptr, flags int32) (r TTcl_Command) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Whether we need exact matching and whether
	 * we bytecode-compile the ensemble's uses. */
	var nsPtr uintptr
	var _ /* actualNsPtr at bp+16 */ uintptr
	var _ /* altNsPtr at bp+8 */ uintptr
	var _ /* foundNsPtr at bp+0 */ uintptr
	var _ /* simpleName at bp+24 */ uintptr
	_ = nsPtr
	nsPtr = namespacePtr
	if nsPtr == libc.UintptrFromInt32(0) {
		nsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FnsPtr
	}
	XTclGetNamespaceForQualName(tls, interp, name, nsPtr, int32(TCL_CREATE_NS_IF_UNKNOWN), bp, bp+8, bp+16, bp+24)
	return XTclCreateEnsembleInNs(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 24)), *(*uintptr)(unsafe.Pointer(bp)), nsPtr, flags)
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * GetEnsembleFromCommand --
//	 *
//	 *	Standard check to see if a command is an ensemble.
//	 *
//	 * Results:
//	 *	The ensemble implementation if the command is an ensemble. NULL if it
//	 *	isn't.
//	 *
//	 * Side effects:
//	 *	Reports an error in the interpreter (if non-NULL) if the command is
//	 *	not an ensemble.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _GetEnsembleFromCommand(tls *libc.TLS, interp uintptr, token TTcl_Command) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* What to check for ensemble-ness. */
	var cmdPtr uintptr
	_ = cmdPtr
	cmdPtr = token
	if (*TCommand)(unsafe.Pointer(cmdPtr)).FobjProc != __ccgo_fp(XTclEnsembleImplementationCmd) {
		if interp != libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+29875, int64(-libc.Int32FromInt32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+29633, __ccgo_ts+29902, libc.UintptrFromInt32(0)))
		}
		return libc.UintptrFromInt32(0)
	}
	return (*TCommand)(unsafe.Pointer(cmdPtr)).FobjClientData
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * BumpEpochIfNecessary --
//	 *
//	 *	Increments the compilation epoch if the (ensemble) command is one where
//	 *	changes would be seen by the compiler in some cases.
//	 *
//	 * Results:
//	 *	None.
//	 *
//	 * Side effects:
//	 *	May trigger later bytecode recompilations.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _BumpEpochIfNecessary(tls *libc.TLS, interp uintptr, token TTcl_Command) {
	/* The ensemble command to check. */
	/*
	 * Special hack to make compiling of [info exists] work when the
	 * dictionary is modified.
	 */
	if (*TCommand)(unsafe.Pointer(token)).FcompileProc != libc.UintptrFromInt32(0) {
		(*TInterp)(unsafe.Pointer(interp)).FcompileEpoch++
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetEnsembleSubcommandList --
 *
 *	Set the subcommand list for a particular ensemble.
 *
 * Results:
 *	Tcl result code (error if command token does not indicate an ensemble
 *	or the subcommand list - if non-NULL - is not a list).
 *
 * Side effects:
 *	The ensemble is updated and marked for recompilation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetEnsembleSubcommandList(tls *libc.TLS, interp uintptr, token TTcl_Command, subcmdList uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var cachePtr, ensemblePtr, oldList, v4 uintptr
	var v1 int32
	var v2 int64
	var v3 TTcl_Size
	var v5 bool
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _ = cachePtr, ensemblePtr, oldList, v1, v2, v3, v4, v5
	ensemblePtr = _GetEnsembleFromCommand(tls, interp, token)
	if ensemblePtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if subcmdList != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(subcmdList)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(subcmdList + 32))).Fptr2 != 0 {
				v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(subcmdList + 32))).Fptr2)).FspanLength
			} else {
				v2 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(subcmdList + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp)) = v2
			v1 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1 = XTcl_ListObjLength(tls, interp, subcmdList, bp)
		}
		if v1 != TCL_OK {
			return int32(TCL_ERROR)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp)) < int64(1) {
			subcmdList = libc.UintptrFromInt32(0)
		}
	}
	oldList = (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcmdList
	(*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcmdList = subcmdList
	if subcmdList != libc.UintptrFromInt32(0) {
		(*TTcl_Obj)(unsafe.Pointer(subcmdList)).FrefCount++
	}
	if oldList != libc.UintptrFromInt32(0) {
		v4 = oldList
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if !(v3 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(oldList)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(oldList)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(oldList)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(oldList)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(oldList)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(oldList)).Flength = int64(-libc.Int32FromInt32(1))
				if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v5 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, oldList)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(oldList + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = oldList
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, oldList)
			}
		}
	}
	/*
	 * Trigger an eventual recomputation of the ensemble command set. Note
	 * that this is slightly tricky, as it means that we are not actually
	 * counting the number of namespace export actions, but it is the simplest
	 * way to go!
	 */
	(*TNamespace)(unsafe.Pointer((*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FnsPtr)).FexportLookupEpoch++
	_BumpEpochIfNecessary(tls, interp, token)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetEnsembleParameterList --
 *
 *	Set the parameter list for a particular ensemble.
 *
 * Results:
 *	Tcl result code (error if command token does not indicate an ensemble
 *	or the parameter list - if non-NULL - is not a list).
 *
 * Side effects:
 *	The ensemble is updated and marked for recompilation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetEnsembleParameterList(tls *libc.TLS, interp uintptr, token TTcl_Command, paramList uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var cachePtr, ensemblePtr, oldList, v4 uintptr
	var v1 int32
	var v2 int64
	var v3 TTcl_Size
	var v5 bool
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _ = cachePtr, ensemblePtr, oldList, v1, v2, v3, v4, v5
	ensemblePtr = _GetEnsembleFromCommand(tls, interp, token)
	if ensemblePtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if paramList == libc.UintptrFromInt32(0) {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(paramList)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(paramList + 32))).Fptr2 != 0 {
				v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(paramList + 32))).Fptr2)).FspanLength
			} else {
				v2 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(paramList + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp)) = v2
			v1 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1 = XTcl_ListObjLength(tls, interp, paramList, bp)
		}
		if v1 != TCL_OK {
			return int32(TCL_ERROR)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp)) < int64(1) {
			paramList = libc.UintptrFromInt32(0)
		}
	}
	oldList = (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FparameterList
	(*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FparameterList = paramList
	if paramList != libc.UintptrFromInt32(0) {
		(*TTcl_Obj)(unsafe.Pointer(paramList)).FrefCount++
	}
	if oldList != libc.UintptrFromInt32(0) {
		v4 = oldList
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if !(v3 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(oldList)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(oldList)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(oldList)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(oldList)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(oldList)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(oldList)).Flength = int64(-libc.Int32FromInt32(1))
				if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v5 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, oldList)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(oldList + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = oldList
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, oldList)
			}
		}
	}
	(*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FnumParameters = *(*TTcl_Size)(unsafe.Pointer(bp))
	/*
	 * Trigger an eventual recomputation of the ensemble command set. Note
	 * that this is slightly tricky, as it means that we are not actually
	 * counting the number of namespace export actions, but it is the simplest
	 * way to go!
	 */
	(*TNamespace)(unsafe.Pointer((*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FnsPtr)).FexportLookupEpoch++
	_BumpEpochIfNecessary(tls, interp, token)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetEnsembleMappingDict --
 *
 *	Set the mapping dictionary for a particular ensemble.
 *
 * Results:
 *	Tcl result code (error if command token does not indicate an ensemble
 *	or the mapping - if non-NULL - is not a dict).
 *
 * Side effects:
 *	The ensemble is updated and marked for recompilation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetEnsembleMappingDict(tls *libc.TLS, interp uintptr, token TTcl_Command, mapDict uintptr) (r int32) {
	bp := tls.Alloc(96)
	defer tls.Free(96)
	var bytes, cachePtr, ensemblePtr, oldDict, v2, v4 uintptr
	var v3 TTcl_Size
	var v5 bool
	var _ /* cmdObjPtr at bp+48 */ uintptr
	var _ /* done at bp+8 */ int32
	var _ /* search at bp+16 */ TTcl_DictSearch
	var _ /* size at bp+0 */ TTcl_Size
	var _ /* valuePtr at bp+40 */ uintptr
	_, _, _, _, _, _, _, _ = bytes, cachePtr, ensemblePtr, oldDict, v2, v3, v4, v5
	ensemblePtr = _GetEnsembleFromCommand(tls, interp, token)
	if ensemblePtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if mapDict != libc.UintptrFromInt32(0) {
		if XTcl_DictObjSize(tls, interp, mapDict, bp) != TCL_OK {
			return int32(TCL_ERROR)
		}
		XTcl_DictObjFirst(tls, libc.UintptrFromInt32(0), mapDict, bp+16, libc.UintptrFromInt32(0), bp+40, bp+8)
		for {
			if !!(*(*int32)(unsafe.Pointer(bp + 8)) != 0) {
				break
			}
			if XTcl_ListObjIndex(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 40)), 0, bp+48) != TCL_OK {
				XTcl_DictObjDone(tls, bp+16)
				return int32(TCL_ERROR)
			}
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fbytes != 0 {
				v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 48)), libc.UintptrFromInt32(0))
			}
			bytes = v2
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes))) != int32(':') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes + 1))) != int32(':') {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+29915, int64(-libc.Int32FromInt32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+64, __ccgo_ts+2004, __ccgo_ts+29633, __ccgo_ts+29964, libc.UintptrFromInt32(0)))
				XTcl_DictObjDone(tls, bp+16)
				return int32(TCL_ERROR)
			}
			goto _1
		_1:
			;
			XTcl_DictObjNext(tls, bp+16, libc.UintptrFromInt32(0), bp+40, bp+8)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp)) < int64(1) {
			mapDict = libc.UintptrFromInt32(0)
		}
	}
	oldDict = (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcommandDict
	(*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcommandDict = mapDict
	if mapDict != libc.UintptrFromInt32(0) {
		(*TTcl_Obj)(unsafe.Pointer(mapDict)).FrefCount++
	}
	if oldDict != libc.UintptrFromInt32(0) {
		v4 = oldDict
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if !(v3 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(oldDict)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(oldDict)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(oldDict)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(oldDict)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(oldDict)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(oldDict)).Flength = int64(-libc.Int32FromInt32(1))
				if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v5 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, oldDict)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(oldDict + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = oldDict
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, oldDict)
			}
		}
	}
	/*
	 * Trigger an eventual recomputation of the ensemble command set. Note
	 * that this is slightly tricky, as it means that we are not actually
	 * counting the number of namespace export actions, but it is the simplest
	 * way to go!
	 */
	(*TNamespace)(unsafe.Pointer((*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FnsPtr)).FexportLookupEpoch++
	_BumpEpochIfNecessary(tls, interp, token)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetEnsembleUnknownHandler --
 *
 *	Set the unknown handler for a particular ensemble.
 *
 * Results:
 *	Tcl result code (error if command token does not indicate an ensemble
 *	or the unknown handler - if non-NULL - is not a list).
 *
 * Side effects:
 *	The ensemble is updated and marked for recompilation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetEnsembleUnknownHandler(tls *libc.TLS, interp uintptr, token TTcl_Command, unknownList uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var cachePtr, ensemblePtr, oldList, v4 uintptr
	var v1 int32
	var v2 int64
	var v3 TTcl_Size
	var v5 bool
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _ = cachePtr, ensemblePtr, oldList, v1, v2, v3, v4, v5
	ensemblePtr = _GetEnsembleFromCommand(tls, interp, token)
	if ensemblePtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if unknownList != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(unknownList)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(unknownList + 32))).Fptr2 != 0 {
				v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(unknownList + 32))).Fptr2)).FspanLength
			} else {
				v2 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(unknownList + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp)) = v2
			v1 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1 = XTcl_ListObjLength(tls, interp, unknownList, bp)
		}
		if v1 != TCL_OK {
			return int32(TCL_ERROR)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp)) < int64(1) {
			unknownList = libc.UintptrFromInt32(0)
		}
	}
	oldList = (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FunknownHandler
	(*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FunknownHandler = unknownList
	if unknownList != libc.UintptrFromInt32(0) {
		(*TTcl_Obj)(unsafe.Pointer(unknownList)).FrefCount++
	}
	if oldList != libc.UintptrFromInt32(0) {
		v4 = oldList
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if !(v3 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(oldList)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(oldList)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(oldList)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(oldList)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(oldList)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(oldList)).Flength = int64(-libc.Int32FromInt32(1))
				if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v5 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, oldList)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(oldList + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = oldList
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, oldList)
			}
		}
	}
	/*
	 * Trigger an eventual recomputation of the ensemble command set. Note
	 * that this is slightly tricky, as it means that we are not actually
	 * counting the number of namespace export actions, but it is the simplest
	 * way to go!
	 */
	(*TNamespace)(unsafe.Pointer((*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FnsPtr)).FexportLookupEpoch++
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetEnsembleFlags --
 *
 *	Set the flags for a particular ensemble.
 *
 * Results:
 *	Tcl result code (error if command token does not indicate an
 *	ensemble).
 *
 * Side effects:
 *	The ensemble is updated and marked for recompilation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetEnsembleFlags(tls *libc.TLS, interp uintptr, token TTcl_Command, flags int32) (r int32) {
	var changedFlags int32
	var ensemblePtr, v1 uintptr
	_, _, _ = changedFlags, ensemblePtr, v1
	ensemblePtr = _GetEnsembleFromCommand(tls, interp, token)
	changedFlags = flags ^ (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).Fflags
	if ensemblePtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * This API refuses to set the ENSEMBLE_DEAD flag...
	 */
	*(*int32)(unsafe.Pointer(ensemblePtr + 144)) &= int32(ENSEMBLE_DEAD)
	*(*int32)(unsafe.Pointer(ensemblePtr + 144)) |= flags & ^libc.Int32FromInt32(ENSEMBLE_DEAD)
	/*
	 * Trigger an eventual recomputation of the ensemble command set. Note
	 * that this is slightly tricky, as it means that we are not actually
	 * counting the number of namespace export actions, but it is the simplest
	 * way to go!
	 */
	(*TNamespace)(unsafe.Pointer((*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FnsPtr)).FexportLookupEpoch++
	/*
	 * If the ENSEMBLE_COMPILE flag status was changed, install or remove the
	 * compiler function and bump the interpreter's compilation epoch so that
	 * bytecode gets regenerated.
	 */
	if changedFlags&int32(ENSEMBLE_COMPILE) != 0 {
		if flags&int32(ENSEMBLE_COMPILE) != 0 {
			v1 = __ccgo_fp(XTclCompileEnsemble)
		} else {
			v1 = libc.UintptrFromInt32(0)
		}
		(*TCommand)(unsafe.Pointer((*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).Ftoken)).FcompileProc = v1
		(*TInterp)(unsafe.Pointer(interp)).FcompileEpoch++
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetEnsembleSubcommandList --
 *
 *	Get the list of subcommands associated with a particular ensemble.
 *
 * Results:
 *	Tcl result code (error if command token does not indicate an
 *	ensemble). The list of subcommands is returned by updating the
 *	variable pointed to by the last parameter (NULL if this is to be
 *	derived from the mapping dictionary or the associated namespace's
 *	exported commands).
 *
 * Side effects:
 *	None
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetEnsembleSubcommandList(tls *libc.TLS, interp uintptr, token TTcl_Command, subcmdListPtr uintptr) (r int32) {
	var ensemblePtr uintptr
	_ = ensemblePtr
	ensemblePtr = _GetEnsembleFromCommand(tls, interp, token)
	if ensemblePtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	*(*uintptr)(unsafe.Pointer(subcmdListPtr)) = (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcmdList
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetEnsembleParameterList --
 *
 *	Get the list of parameters associated with a particular ensemble.
 *
 * Results:
 *	Tcl result code (error if command token does not indicate an
 *	ensemble). The list of parameters is returned by updating the
 *	variable pointed to by the last parameter (NULL if there are
 *	no parameters).
 *
 * Side effects:
 *	None
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetEnsembleParameterList(tls *libc.TLS, interp uintptr, token TTcl_Command, paramListPtr uintptr) (r int32) {
	var ensemblePtr uintptr
	_ = ensemblePtr
	ensemblePtr = _GetEnsembleFromCommand(tls, interp, token)
	if ensemblePtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	*(*uintptr)(unsafe.Pointer(paramListPtr)) = (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FparameterList
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetEnsembleMappingDict --
 *
 *	Get the command mapping dictionary associated with a particular
 *	ensemble.
 *
 * Results:
 *	Tcl result code (error if command token does not indicate an
 *	ensemble). The mapping dict is returned by updating the variable
 *	pointed to by the last parameter (NULL if none is installed).
 *
 * Side effects:
 *	None
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetEnsembleMappingDict(tls *libc.TLS, interp uintptr, token TTcl_Command, mapDictPtr uintptr) (r int32) {
	var ensemblePtr uintptr
	_ = ensemblePtr
	ensemblePtr = _GetEnsembleFromCommand(tls, interp, token)
	if ensemblePtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	*(*uintptr)(unsafe.Pointer(mapDictPtr)) = (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcommandDict
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetEnsembleUnknownHandler --
 *
 *	Get the unknown handler associated with a particular ensemble.
 *
 * Results:
 *	Tcl result code (error if command token does not indicate an
 *	ensemble). The unknown handler is returned by updating the variable
 *	pointed to by the last parameter (NULL if no handler is installed).
 *
 * Side effects:
 *	None
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetEnsembleUnknownHandler(tls *libc.TLS, interp uintptr, token TTcl_Command, unknownListPtr uintptr) (r int32) {
	var ensemblePtr uintptr
	_ = ensemblePtr
	ensemblePtr = _GetEnsembleFromCommand(tls, interp, token)
	if ensemblePtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	*(*uintptr)(unsafe.Pointer(unknownListPtr)) = (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FunknownHandler
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetEnsembleFlags --
 *
 *	Get the flags for a particular ensemble.
 *
 * Results:
 *	Tcl result code (error if command token does not indicate an
 *	ensemble). The flags are returned by updating the variable pointed to
 *	by the last parameter.
 *
 * Side effects:
 *	None
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetEnsembleFlags(tls *libc.TLS, interp uintptr, token TTcl_Command, flagsPtr uintptr) (r int32) {
	var ensemblePtr uintptr
	_ = ensemblePtr
	ensemblePtr = _GetEnsembleFromCommand(tls, interp, token)
	if ensemblePtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	*(*int32)(unsafe.Pointer(flagsPtr)) = (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).Fflags
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetEnsembleNamespace --
 *
 *	Get the namespace associated with a particular ensemble.
 *
 * Results:
 *	Tcl result code (error if command token does not indicate an
 *	ensemble). Namespace is returned by updating the variable pointed to
 *	by the last parameter.
 *
 * Side effects:
 *	None
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetEnsembleNamespace(tls *libc.TLS, interp uintptr, token TTcl_Command, namespacePtrPtr uintptr) (r int32) {
	var ensemblePtr uintptr
	_ = ensemblePtr
	ensemblePtr = _GetEnsembleFromCommand(tls, interp, token)
	if ensemblePtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	*(*uintptr)(unsafe.Pointer(namespacePtrPtr)) = (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FnsPtr
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FindEnsemble --
 *
 *	Given a command name, get the ensemble token for it, allowing for
 *	[namespace import]s. [Bug 1017022]
 *
 * Results:
 *	The token for the ensemble command with the given name, or NULL if the
 *	command either does not exist or is not an ensemble (when an error
 *	message will be written into the interp if thats non-NULL).
 *
 * Side effects:
 *	None
 *
 *----------------------------------------------------------------------
 */

func XTcl_FindEnsemble(tls *libc.TLS, interp uintptr, cmdNameObj uintptr, flags int32) (r TTcl_Command) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Either 0 or TCL_LEAVE_ERR_MSG; other flags
	 * are probably not useful. */
	var token TTcl_Command
	var v1, v2, v3 uintptr
	_, _, _, _ = token, v1, v2, v3
	if (*TTcl_Obj)(unsafe.Pointer(cmdNameObj)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(cmdNameObj)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, cmdNameObj, libc.UintptrFromInt32(0))
	}
	token = XTcl_FindCommand(tls, interp, v1, libc.UintptrFromInt32(0), flags)
	if token == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	if (*TCommand)(unsafe.Pointer(token)).FobjProc != __ccgo_fp(XTclEnsembleImplementationCmd) {
		/*
		 * Reuse existing infrastructure for following import link chains
		 * rather than duplicating it.
		 */
		token = XTclGetOriginalCommand(tls, token)
		if token == libc.UintptrFromInt32(0) || (*TCommand)(unsafe.Pointer(token)).FobjProc != __ccgo_fp(XTclEnsembleImplementationCmd) {
			if flags&int32(TCL_LEAVE_ERR_MSG) != 0 {
				if (*TTcl_Obj)(unsafe.Pointer(cmdNameObj)).Fbytes != 0 {
					v2 = (*TTcl_Obj)(unsafe.Pointer(cmdNameObj)).Fbytes
				} else {
					v2 = XTcl_GetStringFromObj(tls, cmdNameObj, libc.UintptrFromInt32(0))
				}
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+29983, libc.VaList(bp+8, v2)))
				if (*TTcl_Obj)(unsafe.Pointer(cmdNameObj)).Fbytes != 0 {
					v3 = (*TTcl_Obj)(unsafe.Pointer(cmdNameObj)).Fbytes
				} else {
					v3 = XTcl_GetStringFromObj(tls, cmdNameObj, libc.UintptrFromInt32(0))
				}
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+29633, v3, libc.UintptrFromInt32(0)))
			}
			return libc.UintptrFromInt32(0)
		}
	}
	return token
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_IsEnsemble --
 *
 *	Simple test for ensemble-hood that takes into account imported
 *	ensemble commands as well.
 *
 * Results:
 *	Boolean value
 *
 * Side effects:
 *	None
 *
 *----------------------------------------------------------------------
 */

func XTcl_IsEnsemble(tls *libc.TLS, token TTcl_Command) (r int32) {
	/* The command to check. */
	var cmdPtr uintptr
	_ = cmdPtr
	cmdPtr = token
	if (*TCommand)(unsafe.Pointer(cmdPtr)).FobjProc == __ccgo_fp(XTclEnsembleImplementationCmd) {
		return int32(1)
	}
	cmdPtr = XTclGetOriginalCommand(tls, cmdPtr)
	if cmdPtr == libc.UintptrFromInt32(0) || (*TCommand)(unsafe.Pointer(cmdPtr)).FobjProc != __ccgo_fp(XTclEnsembleImplementationCmd) {
		return 0
	}
	return int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * TclMakeEnsemble --
 *
 *	Create an ensemble from a table of implementation commands. The
 *	ensemble will be subject to (limited) compilation if any of the
 *	implementation commands are compilable.
 *
 *	The 'name' parameter may be a single command name or a list if
 *	creating an ensemble subcommand (see the binary implementation).
 *
 *	Currently, the TCL_ENSEMBLE_PREFIX ensemble flag is only used on
 *	top-level ensemble commands.
 *
 *	This code is not safe to run in Safe interpreter after user code has
 *	executed. That's OK right now because it's just used to set up Tcl,
 *	but it means we mustn't expose it at all, not even to Tk (until we can
 *	hide commands in namespaces directly).
 *
 * Results:
 *	Handle for the new ensemble, or NULL on failure.
 *
 * Side effects:
 *	May advance the bytecode compilation epoch.
 *
 *----------------------------------------------------------------------
 */

func XTclMakeEnsemble(tls *libc.TLS, interp uintptr, name uintptr, map1 uintptr) (r TTcl_Command) {
	bp := tls.Alloc(480)
	defer tls.Free(480) /* The subcommands to create */
	var cachePtr, cachePtr1, cmdName, cmdPtr, mapDict, ns, toObj, v5, v6 uintptr
	var ensemble TTcl_Command
	var ensembleFlags, hiddenLen int32
	var i TTcl_Size
	var v2, v4 bool
	var _ /* buf at bp+0 */ TTcl_DString
	var _ /* hiddenBuf at bp+224 */ TTcl_DString
	var _ /* nameCount at bp+456 */ TTcl_Size
	var _ /* nameParts at bp+448 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cmdName, cmdPtr, ensemble, ensembleFlags, hiddenLen, i, mapDict, ns, toObj, v2, v4, v5, v6
	*(*uintptr)(unsafe.Pointer(bp + 448)) = libc.UintptrFromInt32(0)
	cmdName = libc.UintptrFromInt32(0)
	*(*TTcl_Size)(unsafe.Pointer(bp + 456)) = 0
	ensembleFlags = 0
	/*
	 * Construct the path for the ensemble namespace and create it.
	 */
	XTcl_DStringInit(tls, bp)
	XTcl_DStringInit(tls, bp+224)
	XTcl_DStringAppend(tls, bp+224, __ccgo_ts+30015, libc.Int64FromUint64(libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)))
	XTcl_DStringAppend(tls, bp+224, name, int64(-libc.Int32FromInt32(1)))
	XTcl_DStringAppend(tls, bp+224, __ccgo_ts+21829, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))
	hiddenLen = int32((*TTcl_DString)(unsafe.Pointer(bp + 224)).Flength)
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32(':') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name + 1))) == int32(':') {
		/*
		 * An absolute name, so use it directly.
		 */
		cmdName = name
		XTcl_DStringAppend(tls, bp, name, int64(-libc.Int32FromInt32(1)))
		ensembleFlags = int32(TCL_ENSEMBLE_PREFIX)
	} else {
		/*
		 * Not an absolute name, so do munging of it. Note that this treats a
		 * multi-word list differently to a single word.
		 */
		XTcl_DStringAppend(tls, bp, __ccgo_ts+23915, libc.Int64FromUint64(libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)))
		if XTcl_SplitList(tls, libc.UintptrFromInt32(0), name, bp+456, bp+448) != TCL_OK {
			XTcl_Panic(tls, __ccgo_ts+30020, libc.VaList(bp+472, name))
		}
		i = 0
		for {
			if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 456))) {
				break
			}
			XTcl_DStringAppend(tls, bp, __ccgo_ts+7650, libc.Int64FromUint64(libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)))
			XTcl_DStringAppend(tls, bp, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 448)) + uintptr(i)*8)), int64(-libc.Int32FromInt32(1)))
			goto _1
		_1:
			;
			i++
		}
	}
	ns = XTcl_FindNamespace(tls, interp, (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1, libc.UintptrFromInt32(0), int32(TCL_CREATE_NS_IF_UNKNOWN))
	if !(ns != 0) {
		XTcl_Panic(tls, __ccgo_ts+30047, libc.VaList(bp+472, (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1))
	}
	/*
	 * Create the named ensemble in the correct namespace
	 */
	if cmdName == libc.UintptrFromInt32(0) {
		if *(*TTcl_Size)(unsafe.Pointer(bp + 456)) == int64(1) {
			ensembleFlags = int32(TCL_ENSEMBLE_PREFIX)
			cmdName = (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1 + uintptr(5)
		} else {
			ns = (*TTcl_Namespace)(unsafe.Pointer(ns)).FparentPtr
			cmdName = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 448)) + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 456))-int64(1))*8))
		}
	}
	/*
	 * Switch on compilation always for core ensembles now that we can do
	 * nice bytecode things with them.  Do it now.  Waiting until later will
	 * just cause pointless epoch bumps.
	 */
	ensembleFlags |= int32(ENSEMBLE_COMPILE)
	ensemble = XTcl_CreateEnsemble(tls, interp, cmdName, ns, ensembleFlags)
	/*
	 * Create the ensemble mapping dictionary and the ensemble command procs.
	 */
	if ensemble != libc.UintptrFromInt32(0) {
		XTcl_DStringAppend(tls, bp, __ccgo_ts+7650, libc.Int64FromUint64(libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)))
		if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			mapDict = XTclThreadAllocObj(tls)
		} else {
			mapDict = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(mapDict + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(mapDict)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(mapDict)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(mapDict)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(mapDict)).FtypePtr = libc.UintptrFromInt32(0)
		i = 0
		for {
			if !((*(*TEnsembleImplMap)(unsafe.Pointer(map1 + uintptr(i)*48))).Fname != libc.UintptrFromInt32(0)) {
				break
			}
			if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
				toObj = XTclThreadAllocObj(tls)
			} else {
				toObj = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(toObj + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(toObj)).FrefCount = 0
			if (*TTcl_DString)(unsafe.Pointer(bp)).Flength == 0 {
				(*TTcl_Obj)(unsafe.Pointer(toObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(toObj)).Flength = int64(libc.Int32FromInt32(0))
			} else {
				(*TTcl_Obj)(unsafe.Pointer(toObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(bp)).Flength+libc.Int64FromUint32(1)))
				if (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1 != 0 {
					v5 = (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1
				} else {
					v5 = uintptr(unsafe.Pointer(&XtclEmptyString))
				}
				libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(toObj)).Fbytes, v5, libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(bp)).Flength))
				*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(toObj)).Fbytes + uintptr((*TTcl_DString)(unsafe.Pointer(bp)).Flength))) = uint8('\000')
				(*TTcl_Obj)(unsafe.Pointer(toObj)).Flength = (*TTcl_DString)(unsafe.Pointer(bp)).Flength
			}
			(*TTcl_Obj)(unsafe.Pointer(toObj)).FtypePtr = libc.UintptrFromInt32(0)
			XTcl_AppendToObj(tls, toObj, (*(*TEnsembleImplMap)(unsafe.Pointer(map1 + uintptr(i)*48))).Fname, int64(-libc.Int32FromInt32(1)))
			XTclDictPut(tls, libc.UintptrFromInt32(0), mapDict, (*(*TEnsembleImplMap)(unsafe.Pointer(map1 + uintptr(i)*48))).Fname, toObj)
			if (*(*TEnsembleImplMap)(unsafe.Pointer(map1 + uintptr(i)*48))).Fproc != 0 || (*(*TEnsembleImplMap)(unsafe.Pointer(map1 + uintptr(i)*48))).FnreProc != 0 {
				/*
				 * If the command is unsafe, hide it when we're in a safe
				 * interpreter. The code to do this is really hokey! It also
				 * doesn't work properly yet; this function is always
				 * currently called before the safe-interp flag is set so the
				 * Tcl_IsSafe check fails.
				 */
				if (*(*TEnsembleImplMap)(unsafe.Pointer(map1 + uintptr(i)*48))).Funsafe != 0 && XTcl_IsSafe(tls, interp) != 0 {
					cmdPtr = XTcl_NRCreateCommand(tls, interp, __ccgo_ts+7297, (*(*TEnsembleImplMap)(unsafe.Pointer(map1 + uintptr(i)*48))).Fproc, (*(*TEnsembleImplMap)(unsafe.Pointer(map1 + uintptr(i)*48))).FnreProc, (*(*TEnsembleImplMap)(unsafe.Pointer(map1 + uintptr(i)*48))).FclientData, libc.UintptrFromInt32(0))
					XTcl_DStringSetLength(tls, bp+224, int64(hiddenLen))
					if XTcl_HideCommand(tls, interp, __ccgo_ts+7297, XTcl_DStringAppend(tls, bp+224, (*(*TEnsembleImplMap)(unsafe.Pointer(map1 + uintptr(i)*48))).Fname, int64(-libc.Int32FromInt32(1)))) != 0 {
						XTcl_Panic(tls, __ccgo_ts+7263, libc.VaList(bp+472, XTcl_GetStringFromObj(tls, XTcl_GetObjResult(tls, interp), libc.UintptrFromInt32(0))))
					}
					/* don't compile unsafe subcommands in safe interp */
					(*TCommand)(unsafe.Pointer(cmdPtr)).FcompileProc = libc.UintptrFromInt32(0)
				} else {
					/*
					 * Not hidden, so just create it. Yay!
					 */
					if (*TTcl_Obj)(unsafe.Pointer(toObj)).Fbytes != 0 {
						v6 = (*TTcl_Obj)(unsafe.Pointer(toObj)).Fbytes
					} else {
						v6 = XTcl_GetStringFromObj(tls, toObj, libc.UintptrFromInt32(0))
					}
					cmdPtr = XTcl_NRCreateCommand(tls, interp, v6, (*(*TEnsembleImplMap)(unsafe.Pointer(map1 + uintptr(i)*48))).Fproc, (*(*TEnsembleImplMap)(unsafe.Pointer(map1 + uintptr(i)*48))).FnreProc, (*(*TEnsembleImplMap)(unsafe.Pointer(map1 + uintptr(i)*48))).FclientData, libc.UintptrFromInt32(0))
					(*TCommand)(unsafe.Pointer(cmdPtr)).FcompileProc = (*(*TEnsembleImplMap)(unsafe.Pointer(map1 + uintptr(i)*48))).FcompileProc
				}
			}
			goto _3
		_3:
			;
			i++
		}
		XTcl_SetEnsembleMappingDict(tls, interp, ensemble, mapDict)
	}
	XTcl_DStringFree(tls, bp)
	XTcl_DStringFree(tls, bp+224)
	if *(*uintptr)(unsafe.Pointer(bp + 448)) != libc.UintptrFromInt32(0) {
		XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 448)))
	}
	return ensemble
}

/*
 *----------------------------------------------------------------------
 *
 * TclEnsembleImplementationCmd --
 *
 *	Implements an ensemble of commands (being those exported by a
 *	namespace other than the global namespace) as a command with the same
 *	(short) name as the namespace in the parent namespace.
 *
 * Results:
 *	A standard Tcl result code. Will be TCL_ERROR if the command is not an
 *	unambiguous prefix of any command exported by the ensemble's
 *	namespace.
 *
 * Side effects:
 *	Depends on the command within the namespace that gets executed. If the
 *	ensemble itself returns TCL_ERROR, a descriptive error message will be
 *	placed in the interpreter's result.
 *
 *----------------------------------------------------------------------
 */

func XTclEnsembleImplementationCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	return XTcl_NRCallObjProc(tls, interp, __ccgo_fp(_NsEnsembleImplementationCmdNR), clientData, int64(objc), objv)
}

func _NsEnsembleImplementationCmdNR(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(336)
	defer tls.Free(336)
	var _objPtr, _objPtr1, cachePtr, cachePtr1, cachePtr2, copyPtr, ensembleCmd, ensemblePtr, errorObj, fix, fullName, hPtr, irPtr, subObj, subcmdName, v1, v10, v18, v19, v2, v20, v21, v3, v4 uintptr
	var cmp, reparseCount, v16 int32
	var i, i1, subIdx, tableLength, v9 TTcl_Size
	var v11, v12, v17, v8 bool
	var v14, v15, v7 int64
	var _ /* _callbackPtr at bp+264 */ uintptr
	var _ /* _callbackPtr at bp+272 */ uintptr
	var _ /* buf at bp+8 */ TTcl_DString
	var _ /* copyObjc at bp+248 */ TTcl_Size
	var _ /* copyObjv at bp+240 */ uintptr
	var _ /* prefixObj at bp+0 */ uintptr
	var _ /* prefixObjc at bp+256 */ TTcl_Size
	var _ /* stringLength at bp+232 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, cachePtr1, cachePtr2, cmp, copyPtr, ensembleCmd, ensemblePtr, errorObj, fix, fullName, hPtr, i, i1, irPtr, reparseCount, subIdx, subObj, subcmdName, tableLength, v1, v10, v11, v12, v14, v15, v16, v17, v18, v19, v2, v20, v21, v3, v4, v7, v8, v9
	ensemblePtr = clientData /* Used for efficient lookup of fully
	 * specified but not yet cached command
	 * names. */
	reparseCount = 0
	/*
	 * Must recheck objc since numParameters might have changed. See test
	 * namespace-53.9.
	 */
	goto restartEnsembleParse
restartEnsembleParse:
	;
	subIdx = int64(1) + (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FnumParameters
	if int64(objc) < subIdx+int64(1) { /* Message being built */
		XTcl_DStringInit(tls, bp+8)
		if (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FparameterList != 0 {
			XTclDStringAppendObj(tls, bp+8, (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FparameterList)
			XTcl_DStringAppend(tls, bp+8, __ccgo_ts+14830, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))
		}
		XTcl_DStringAppend(tls, bp+8, __ccgo_ts+29647, libc.Int64FromUint64(libc.Uint64FromInt64(21)-libc.Uint64FromInt32(1)))
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, (*TTcl_DString)(unsafe.Pointer(bp+8)).Fstring1)
		XTcl_DStringFree(tls, bp+8)
		return int32(TCL_ERROR)
	}
	if (*TNamespace)(unsafe.Pointer((*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FnsPtr)).Fflags&int32(NS_DEAD) != 0 {
		/*
		 * Don't know how we got here, but make things give up quickly.
		 */
		if !(XTcl_InterpDeleted(tls, interp) != 0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+30086, int64(-libc.Int32FromInt32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+288, __ccgo_ts+2004, __ccgo_ts+29633, __ccgo_ts+29642, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	/*
	 * If the table of subcommands is valid just lookup up the command there
	 * and go to dispatch.
	 */
	subObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(subIdx)*8))
	if (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).Fepoch == (*TNamespace)(unsafe.Pointer((*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FnsPtr)).FexportLookupEpoch {
		if (*TTcl_Obj)(unsafe.Pointer(subObj)).FtypePtr == uintptr(unsafe.Pointer(&_ensembleCmdType)) {
			v1 = subObj + 32
		} else {
			v1 = libc.UintptrFromInt32(0)
		}
		irPtr = v1
		if irPtr != 0 {
			v2 = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(irPtr))).Fptr1
		} else {
			v2 = libc.UintptrFromInt32(0)
		}
		ensembleCmd = v2
		if ensembleCmd != 0 {
			if (*TEnsembleCmdRep)(unsafe.Pointer(ensembleCmd)).Fepoch == (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).Fepoch && (*TEnsembleCmdRep)(unsafe.Pointer(ensembleCmd)).Ftoken == (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).Ftoken {
				*(*uintptr)(unsafe.Pointer(bp)) = (*TTcl_HashEntry)(unsafe.Pointer((*TEnsembleCmdRep)(unsafe.Pointer(ensembleCmd)).FhPtr)).FclientData
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FrefCount++
				if (*TEnsembleCmdRep)(unsafe.Pointer(ensembleCmd)).Ffix != 0 {
					XTclSpellFix(tls, interp, objv, int64(objc), subIdx, subObj, (*TEnsembleCmdRep)(unsafe.Pointer(ensembleCmd)).Ffix)
				}
				goto runResultingSubcommand
			}
		}
	} else {
		_BuildEnsembleConfig(tls, ensemblePtr)
		(*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).Fepoch = (*TNamespace)(unsafe.Pointer((*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FnsPtr)).FexportLookupEpoch
	}
	/*
	 * Look in the hashtable for the named subcommand.  This is the fastest
	 * path if there is no cache in operation.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(subObj)).Fbytes != 0 {
		v3 = (*TTcl_Obj)(unsafe.Pointer(subObj)).Fbytes
	} else {
		v3 = XTcl_GetStringFromObj(tls, subObj, libc.UintptrFromInt32(0))
	}
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(ensemblePtr + 32)).FfindProc})))(tls, ensemblePtr+32, v3)
	if hPtr != libc.UintptrFromInt32(0) {
		/*
		 * Cache ensemble in the subcommand object for later.
		 */
		_MakeCachedEnsembleCommand(tls, subObj, ensemblePtr, hPtr, libc.UintptrFromInt32(0))
	} else {
		if !((*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).Fflags&libc.Int32FromInt32(TCL_ENSEMBLE_PREFIX) != 0) {
			/*
			 * Could not map.  No prefixing.  Go to unknown/error handling.
			 */
			goto unknownOrAmbiguousSubcommand
		} else { /* Name of the subcommand or unique prefix of
			 * it (a non-unique prefix produces an error). */
			fullName = libc.UintptrFromInt32(0)
			tableLength = (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcommandTable.FnumEntries
			if (*TTcl_Obj)(unsafe.Pointer(subObj)).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 232)) = (*TTcl_Obj)(unsafe.Pointer(subObj)).Flength
				v4 = (*TTcl_Obj)(unsafe.Pointer(subObj)).Fbytes
			} else {
				v4 = XTcl_GetStringFromObj(tls, subObj, bp+232)
			}
			subcmdName = v4
			i = 0
			for {
				if !(i < tableLength) {
					break
				}
				cmp = libc.Xstrncmp(tls, subcmdName, *(*uintptr)(unsafe.Pointer((*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcommandArrayPtr + uintptr(i)*8)), libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 232))))
				if cmp == 0 {
					if fullName != libc.UintptrFromInt32(0) {
						/*
						 * Hash search filters out the exact-match case, so getting
						 * here indicates that the subcommand is an ambiguous
						 * prefix of at least two exported subcommands, which is an
						 * error case.
						 */
						goto unknownOrAmbiguousSubcommand
					}
					fullName = *(*uintptr)(unsafe.Pointer((*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcommandArrayPtr + uintptr(i)*8))
				} else {
					if cmp < 0 {
						/*
						 * The table is sorted so stop searching because a match would
						 * have been found already.
						 */
						break
					}
				}
				goto _5
			_5:
				;
				i++
			}
			if fullName == libc.UintptrFromInt32(0) {
				/*
				 * The subcommand is not a prefix of anything. Bail out!
				 */
				goto unknownOrAmbiguousSubcommand
			}
			hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(ensemblePtr + 32)).FfindProc})))(tls, ensemblePtr+32, fullName)
			if hPtr == libc.UintptrFromInt32(0) {
				XTcl_Panic(tls, __ccgo_ts+30127, libc.VaList(bp+288, fullName))
			}
			/*
			 * Record the spelling correction for usage message.
			 */
			fix = XTcl_NewStringObj(tls, fullName, int64(-libc.Int32FromInt32(1)))
			/*
			 * Cache for later in the subcommand object.
			 */
			_MakeCachedEnsembleCommand(tls, subObj, ensemblePtr, hPtr, fix)
			XTclSpellFix(tls, interp, objv, int64(objc), subIdx, subObj, fix)
		}
	}
	*(*uintptr)(unsafe.Pointer(bp)) = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FrefCount++
	goto runResultingSubcommand
runResultingSubcommand:
	;
	/*
	 * Execute the subcommand by populating an array of objects, which might
	 * not be the same length as the number of arguments to this ensemble
	 * command, and then handing it to the main command-lookup engine. In
	 * theory, the command could be looked up right here using the namespace in
	 * which it is guaranteed to exist,
	 *
	 *   ((Q: That's not true if the -map option is used, is it?))
	 *
	 * but don't do that because caching of the command object should help.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr2 != 0 {
			v7 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr2)).FspanLength
		} else {
			v7 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 256)) = v7
		_ = libc.Int32FromInt32(TCL_OK)
	} else {
		XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), bp+256)
	}
	if objc == int32(2) {
		copyPtr = XTclListObjCopy(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)))
	} else {
		copyPtr = XTcl_NewListObj(tls, int64(objc-int32(2))+*(*TTcl_Size)(unsafe.Pointer(bp + 256)), libc.UintptrFromInt32(0))
		XTcl_ListObjAppendList(tls, libc.UintptrFromInt32(0), copyPtr, *(*uintptr)(unsafe.Pointer(bp)))
		XTcl_ListObjReplace(tls, libc.UintptrFromInt32(0), copyPtr, libc.Int64FromUint64((libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))-uint64(libc.UintptrFromInt32(0)+40))/libc.Uint64FromInt64(8)), 0, (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FnumParameters, objv+uintptr(1)*8)
		XTcl_ListObjReplace(tls, libc.UintptrFromInt32(0), copyPtr, libc.Int64FromUint64((libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))-uint64(libc.UintptrFromInt32(0)+40))/libc.Uint64FromInt64(8)), 0, int64(objc-int32(2))-(*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FnumParameters, objv+uintptr(2)*8+uintptr((*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FnumParameters)*8)
	}
	(*TTcl_Obj)(unsafe.Pointer(copyPtr)).FrefCount++
	if v8 = interp == libc.UintptrFromInt32(0); !v8 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v8 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 264)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 264)))).FprocPtr = __ccgo_fp(XTclNRReleaseValues)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 264)) + 8)) = copyPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 264)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 264)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 264)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 264)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 264))
	v10 = *(*uintptr)(unsafe.Pointer(bp))
	v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
	*(*TTcl_Size)(unsafe.Pointer(v10))--
	if !(v9 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Flength = int64(-libc.Int32FromInt32(1))
			if v11 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v11 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v11 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp)))
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp))
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp)))
		}
	}
	/*
	 * Record the words of the command as given so that routines like
	 * Tcl_WrongNumArgs can produce the correct error message. Parameters
	 * count both as inserted and removed arguments.
	 */
	if XTclInitRewriteEnsemble(tls, interp, int64(2)+(*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FnumParameters, *(*TTcl_Size)(unsafe.Pointer(bp + 256))+(*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FnumParameters, objv) != 0 {
		if v12 = interp == libc.UintptrFromInt32(0); !v12 {
			cachePtr2 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
		}
		if v12 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
			_objPtr1 = XTclThreadAllocObj(tls)
		} else {
			_objPtr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(_objPtr1 + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
		}
		*(*uintptr)(unsafe.Pointer(bp + 272)) = _objPtr1
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 272)))).FprocPtr = __ccgo_fp(XTclClearRootEnsemble)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 272)) + 8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 272)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 272)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 272)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 272)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
		(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 272))
	}
	/*
	 * Hand off to the target command.
	 */
	XTclSkipTailcall(tls, interp)
	if (*TTcl_Obj)(unsafe.Pointer(copyPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(copyPtr + 32))).Fptr2 != 0 {
			v14 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(copyPtr + 32))).Fptr2)).FspanStart
		} else {
			v14 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(copyPtr + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 240)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(copyPtr + 32))).Fptr1 + 40 + uintptr(v14)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(copyPtr + 32))).Fptr2 != 0 {
			v15 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(copyPtr + 32))).Fptr2)).FspanLength
		} else {
			v15 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(copyPtr + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 248)) = v15
		_ = libc.Int32FromInt32(TCL_OK)
	} else {
		XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), copyPtr, bp+248, bp+240)
	}
	(*TInterp)(unsafe.Pointer(interp)).FlookupNsPtr = (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FnsPtr
	return XTclNREvalObjv(tls, interp, *(*TTcl_Size)(unsafe.Pointer(bp + 248)), *(*uintptr)(unsafe.Pointer(bp + 240)), int32(TCL_EVAL_INVOKE), libc.UintptrFromInt32(0))
	goto unknownOrAmbiguousSubcommand
unknownOrAmbiguousSubcommand:
	;
	/*
	 * The named subcommand did not match any exported command. If there is a
	 * handler registered unknown subcommands, call it, but not more than once
	 * for this call.
	 */
	if v17 = (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FunknownHandler != libc.UintptrFromInt32(0); v17 {
		v16 = reparseCount
		reparseCount++
	}
	if v17 && v16 < int32(1) {
		switch _EnsembleUnknownCallback(tls, interp, ensemblePtr, objc, objv, bp) {
		case TCL_OK:
			goto runResultingSubcommand
		case int32(TCL_ERROR):
			return int32(TCL_ERROR)
		case int32(TCL_CONTINUE):
			goto restartEnsembleParse
		}
	}
	/*
	 * Could not find a routine for the named subcommand so generate a standard
	 * failure message.  The one odd case compared with a standard
	 * ensemble-like command is where a namespace has no exported commands at
	 * all...
	 */
	XTcl_ResetResult(tls, interp)
	if (*TTcl_Obj)(unsafe.Pointer(subObj)).Fbytes != 0 {
		v18 = (*TTcl_Obj)(unsafe.Pointer(subObj)).Fbytes
	} else {
		v18 = XTcl_GetStringFromObj(tls, subObj, libc.UintptrFromInt32(0))
	}
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+288, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+7412, v18, libc.UintptrFromInt32(0)))
	if (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcommandTable.FnumEntries == 0 {
		if (*TTcl_Obj)(unsafe.Pointer(subObj)).Fbytes != 0 {
			v19 = (*TTcl_Obj)(unsafe.Pointer(subObj)).Fbytes
		} else {
			v19 = XTcl_GetStringFromObj(tls, subObj, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+30182, libc.VaList(bp+288, v19, (*TNamespace)(unsafe.Pointer((*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FnsPtr)).FfullName)))
		return int32(TCL_ERROR)
	}
	if (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).Fflags&int32(TCL_ENSEMBLE_PREFIX) != 0 {
		v20 = __ccgo_ts + 30249
	} else {
		v20 = __ccgo_ts + 1945
	}
	if (*TTcl_Obj)(unsafe.Pointer(subObj)).Fbytes != 0 {
		v21 = (*TTcl_Obj)(unsafe.Pointer(subObj)).Fbytes
	} else {
		v21 = XTcl_GetStringFromObj(tls, subObj, libc.UintptrFromInt32(0))
	}
	errorObj = XTcl_ObjPrintf(tls, __ccgo_ts+30263, libc.VaList(bp+288, v20, v21))
	if (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcommandTable.FnumEntries == int64(1) {
		XTcl_AppendToObj(tls, errorObj, *(*uintptr)(unsafe.Pointer((*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcommandArrayPtr)), int64(-libc.Int32FromInt32(1)))
	} else {
		i1 = 0
		for {
			if !(i1 < (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcommandTable.FnumEntries-int64(1)) {
				break
			}
			XTcl_AppendToObj(tls, errorObj, *(*uintptr)(unsafe.Pointer((*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcommandArrayPtr + uintptr(i1)*8)), int64(-libc.Int32FromInt32(1)))
			XTcl_AppendToObj(tls, errorObj, __ccgo_ts+21617, int64(2))
			goto _22
		_22:
			;
			i1++
		}
		XTcl_AppendPrintfToObj(tls, errorObj, __ccgo_ts+30299, libc.VaList(bp+288, *(*uintptr)(unsafe.Pointer((*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcommandArrayPtr + uintptr(i1)*8))))
	}
	XTcl_SetObjResult(tls, interp, errorObj)
	return int32(TCL_ERROR)
}

func XTclClearRootEnsemble(tls *libc.TLS, dummy2040 uintptr, interp uintptr, result int32) (r int32) {
	XTclResetRewriteEnsemble(tls, interp, int32(1))
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * TclInitRewriteEnsemble --
 *
 *	Applies a rewrite of arguments so that an ensemble subcommand
 *	correctly reports any error messages for the overall command.
 *
 * Results:
 *	Whether this is the first rewrite applied, a value which must be
 *	passed to TclResetRewriteEnsemble when undoing this command's
 *	behaviour.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclInitRewriteEnsemble(tls *libc.TLS, interp uintptr, numRemoved TTcl_Size, numInserted TTcl_Size, objv uintptr) (r int32) {
	var iPtr uintptr
	var isRootEnsemble int32
	var numIns TTcl_Size
	_, _, _ = iPtr, isRootEnsemble, numIns
	iPtr = interp
	isRootEnsemble = libc.BoolInt32((*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FsourceObjs == libc.UintptrFromInt32(0))
	if isRootEnsemble != 0 {
		(*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FsourceObjs = objv
		(*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FnumRemovedObjs = numRemoved
		(*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FnumInsertedObjs = numInserted
	} else {
		numIns = (*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FnumInsertedObjs
		if numIns < numRemoved {
			(*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FnumRemovedObjs += numRemoved - numIns
			(*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FnumInsertedObjs = numInserted
		} else {
			(*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FnumInsertedObjs += numInserted - numRemoved
		}
	}
	return isRootEnsemble
}

/*
 *----------------------------------------------------------------------
 *
 * TclResetRewriteEnsemble --
 *
 *	Removes any rewrites applied to support proper reporting of error
 *	messages used in ensembles. Should be paired with
 *	TclInitRewriteEnsemble.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclResetRewriteEnsemble(tls *libc.TLS, interp uintptr, isRootEnsemble int32) {
	var iPtr uintptr
	_ = iPtr
	iPtr = interp
	if isRootEnsemble != 0 {
		(*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FsourceObjs = libc.UintptrFromInt32(0)
		(*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FnumRemovedObjs = 0
		(*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FnumInsertedObjs = 0
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclSpellFix --
 *
 *	Records a spelling correction that needs making in the generation of
 *	the WrongNumArgs usage message.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Can create an alternative ensemble rewrite structure.
 *
 *----------------------------------------------------------------------
 */

func _FreeER(tls *libc.TLS, data uintptr, dummy2147 uintptr, result int32) (r int32) {
	var store, tmp uintptr
	_, _ = store, tmp
	tmp = *(*uintptr)(unsafe.Pointer(data))
	store = *(*uintptr)(unsafe.Pointer(data + 1*8))
	XTclpFree(tls, store)
	XTclpFree(tls, tmp)
	return result
}

func XTclSpellFix(tls *libc.TLS, interp uintptr, objv uintptr, objc TTcl_Size, badIdx TTcl_Size, bad uintptr, fix uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, _objPtr1, cachePtr, cachePtr1, iPtr, search, store, tmp uintptr
	var idx, size TTcl_Size
	var v1, v2 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	var _ /* _callbackPtr at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, cachePtr1, iPtr, idx, search, size, store, tmp, v1, v2
	iPtr = interp
	if (*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FsourceObjs == libc.UintptrFromInt32(0) {
		(*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FsourceObjs = objv
		(*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FnumRemovedObjs = 0
		(*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FnumInsertedObjs = 0
	}
	/*
	 * Compute the valid length of the ensemble root.
	 */
	size = (*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FnumRemovedObjs + objc - (*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FnumInsertedObjs
	search = (*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FsourceObjs
	if *(*uintptr)(unsafe.Pointer(search)) == libc.UintptrFromInt32(0) {
		/*
		 * Awful casting abuse here!
		 */
		search = *(*uintptr)(unsafe.Pointer(search + 1*8))
	}
	if badIdx < (*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FnumInsertedObjs {
		/*
		 * Misspelled value was inserted. Cannot directly jump to the bad
		 * value.  Must search.
		 */
		idx = int64(1)
		for idx < size {
			if *(*uintptr)(unsafe.Pointer(search + uintptr(idx)*8)) == bad {
				break
			}
			idx++
		}
		if idx == size {
			return
		}
	} else {
		/*
		 * Jump to the misspelled value.
		 */
		idx = (*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FnumRemovedObjs + badIdx - (*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FnumInsertedObjs
		/* Verify */
		if *(*uintptr)(unsafe.Pointer(search + uintptr(idx)*8)) != bad {
			XTcl_Panic(tls, __ccgo_ts+30305, 0)
		}
	}
	search = (*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FsourceObjs
	if *(*uintptr)(unsafe.Pointer(search)) == libc.UintptrFromInt32(0) {
		store = *(*uintptr)(unsafe.Pointer(search + 2*8))
	} else {
		tmp = XTcl_Alloc(tls, libc.Uint64FromInt32(3)*libc.Uint64FromInt64(8))
		store = XTcl_Alloc(tls, libc.Uint64FromInt64(size)*uint64(8))
		libc.Xmemcpy(tls, store, (*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FsourceObjs, libc.Uint64FromInt64(size)*uint64(8))
		/*
		 * Awful casting abuse here! Note that the NULL in the first element
		 * indicates that the initial objects are a raw array in the second
		 * element and the rewritten ones are a raw array in the third.
		 */
		*(*uintptr)(unsafe.Pointer(tmp)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(tmp + 1*8)) = (*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FsourceObjs
		*(*uintptr)(unsafe.Pointer(tmp + 2*8)) = store
		(*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FsourceObjs = tmp
		if v1 = interp == libc.UintptrFromInt32(0); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			_objPtr = XTclThreadAllocObj(tls)
		} else {
			_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(_objPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(_FreeER)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = tmp
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = store
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
		(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
	}
	*(*uintptr)(unsafe.Pointer(store + uintptr(idx)*8)) = fix
	(*TTcl_Obj)(unsafe.Pointer(fix)).FrefCount++
	if v2 = interp == libc.UintptrFromInt32(0); !v2 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr1 = XTclThreadAllocObj(tls)
	} else {
		_objPtr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr1 + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 8)) = _objPtr1
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FprocPtr = __ccgo_fp(XTclNRReleaseValues)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8)) = fix
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * TclEnsembleGetRewriteValues --
//	 *
//	 *	Get the original arguments to the current command before any rewrite
//	 *	rules (from aliases, ensembles, and method forwards) were applied.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func XTclEnsembleGetRewriteValues(tls *libc.TLS, interp uintptr) (r uintptr) {
	/* Current interpreter. */
	var iPtr, origObjv uintptr
	_, _ = iPtr, origObjv
	iPtr = interp
	origObjv = (*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FsourceObjs
	if *(*uintptr)(unsafe.Pointer(origObjv)) == libc.UintptrFromInt32(0) {
		origObjv = *(*uintptr)(unsafe.Pointer(origObjv + 2*8))
	}
	return origObjv
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * TclFetchEnsembleRoot --
//	 *
//	 *	Returns the root of ensemble rewriting, if any.
//	 *	If no root exists, returns objv instead.
//	 *
//	 * Results:
//	 *	None.
//	 *
//	 * Side effects:
//	 *	None.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func XTclFetchEnsembleRoot(tls *libc.TLS, interp uintptr, objv uintptr, objc TTcl_Size, objcPtr uintptr) (r uintptr) {
	var iPtr, sourceObjs uintptr
	_, _ = iPtr, sourceObjs
	iPtr = interp
	if (*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FsourceObjs != 0 {
		*(*TTcl_Size)(unsafe.Pointer(objcPtr)) = objc + (*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FnumRemovedObjs - (*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FnumInsertedObjs
		if *(*uintptr)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FsourceObjs)) == libc.UintptrFromInt32(0) {
			sourceObjs = *(*uintptr)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FsourceObjs + 1*8))
		} else {
			sourceObjs = (*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FsourceObjs
		}
		return sourceObjs
	}
	*(*TTcl_Size)(unsafe.Pointer(objcPtr)) = objc
	return objv
}

/*
 * ----------------------------------------------------------------------
 *
 * EnsembleUnknownCallback --
 *
 *	Helper for the ensemble engine.  Calls the routine registered for
 *	"ensemble unknown" case.  See the user documentation of the
 *	ensemble unknown handler for details.  Only called when such a
 *	function is defined, and is only called once per ensemble dispatch.
 *	I.e. even if a reparse still fails, this isn't called again.
 *
 * Results:
 *	TCL_OK -	*prefixObjPtr contains the command words to dispatch
 *			to.
 *	TCL_CONTINUE -	Need to reparse, i.e. *prefixObjPtr is invalid
 *	TCL_ERROR -	Something went wrong. Error message in interpreter.
 *
 * Side effects:
 *	Arbitrary, due to evaluation of script provided by client.
 *
 * ----------------------------------------------------------------------
 */

func _EnsembleUnknownCallback(tls *libc.TLS, interp uintptr, ensemblePtr uintptr, objc int32, objv uintptr, prefixObjPtr uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Where to write the prefix suggested by the
	 * unknown callback. Must not be NULL. Only has
	 * a meaningful value on TCL_OK. */
	var cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, ensObj, unknownCmd, v12, v15, v18, v7 uintptr
	var i, v11, v14, v17, v6 TTcl_Size
	var result, v9 int32
	var v1, v13, v16, v19, v8 bool
	var v10, v4, v5 int64
	var _ /* paramc at bp+0 */ TTcl_Size
	var _ /* paramv at bp+16 */ uintptr
	var _ /* prefixObjc at bp+8 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, ensObj, i, result, unknownCmd, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v4, v5, v6, v7, v8, v9
	/*
	 * Create the "unknown" command callback to determine what to do.
	 */
	unknownCmd = XTcl_DuplicateObj(tls, (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FunknownHandler)
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		ensObj = XTclThreadAllocObj(tls)
	} else {
		ensObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(ensObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(ensObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(ensObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(ensObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(ensObj)).FtypePtr = libc.UintptrFromInt32(0)
	XTcl_GetCommandFullName(tls, interp, (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).Ftoken, ensObj)
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), unknownCmd, ensObj)
	i = int64(1)
	for {
		if !(i < int64(objc)) {
			break
		}
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), unknownCmd, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))
		goto _2
	_2:
		;
		i++
	}
	if (*TTcl_Obj)(unsafe.Pointer(unknownCmd)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(unknownCmd + 32))).Fptr2 != 0 {
			v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(unknownCmd + 32))).Fptr2)).FspanStart
		} else {
			v4 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(unknownCmd + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 16)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(unknownCmd + 32))).Fptr1 + 40 + uintptr(v4)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(unknownCmd + 32))).Fptr2 != 0 {
			v5 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(unknownCmd + 32))).Fptr2)).FspanLength
		} else {
			v5 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(unknownCmd + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v5
		_ = libc.Int32FromInt32(TCL_OK)
	} else {
		XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), unknownCmd, bp, bp+16)
	}
	(*TTcl_Obj)(unsafe.Pointer(unknownCmd)).FrefCount++
	/*
	 * Call the "unknown" handler.  No attempt to NRE-enable this as deep
	 * recursion through unknown handlers is perverse. It is always an error
	 * for an unknown handler to delete its ensemble. Don't do that.
	 */
	XTcl_Preserve(tls, ensemblePtr)
	XTclSkipTailcall(tls, interp)
	result = XTcl_EvalObjv(tls, interp, *(*TTcl_Size)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 16)), 0)
	if result == TCL_OK && (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).Fflags&int32(ENSEMBLE_DEAD) != 0 {
		if !(XTcl_InterpDeleted(tls, interp) != 0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+30333, int64(-libc.Int32FromInt32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+32, __ccgo_ts+2004, __ccgo_ts+29633, __ccgo_ts+30381, libc.UintptrFromInt32(0)))
		}
		result = int32(TCL_ERROR)
	}
	XTcl_Release(tls, ensemblePtr)
	/*
	 * On success the result is a list of words that form the command to be
	 * executed.  If the list is empty, the ensemble should have been updated,
	 * so ask the ensemble engine to reparse the original command.
	 */
	if result == TCL_OK {
		*(*uintptr)(unsafe.Pointer(prefixObjPtr)) = XTcl_GetObjResult(tls, interp)
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(prefixObjPtr)))).FrefCount++
		v7 = unknownCmd
		v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
		*(*TTcl_Size)(unsafe.Pointer(v7))--
		if !(v6 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(unknownCmd)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(unknownCmd)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(unknownCmd)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(unknownCmd)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(unknownCmd)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(unknownCmd)).Flength = int64(-libc.Int32FromInt32(1))
				if v8 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v8 {
					cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v8 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, unknownCmd)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(unknownCmd + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = unknownCmd
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, unknownCmd)
			}
		}
		XTcl_ResetResult(tls, interp)
		/* A non-empty list is the replacement command. */
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(prefixObjPtr)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(prefixObjPtr)) + 32))).Fptr2 != 0 {
				v10 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(prefixObjPtr)) + 32))).Fptr2)).FspanLength
			} else {
				v10 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(prefixObjPtr)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v10
			v9 = libc.Int32FromInt32(TCL_OK)
		} else {
			v9 = XTcl_ListObjLength(tls, interp, *(*uintptr)(unsafe.Pointer(prefixObjPtr)), bp+8)
		}
		if v9 != TCL_OK {
			v12 = *(*uintptr)(unsafe.Pointer(prefixObjPtr))
			v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
			*(*TTcl_Size)(unsafe.Pointer(v12))--
			if !(v11 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(prefixObjPtr)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(prefixObjPtr)))).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(prefixObjPtr)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(prefixObjPtr)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(prefixObjPtr)))).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(prefixObjPtr)))).Flength = int64(-libc.Int32FromInt32(1))
					if v13 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v13 {
						cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v13 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(prefixObjPtr)))
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(prefixObjPtr)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(prefixObjPtr))
						(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(prefixObjPtr)))
				}
			}
			XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+30397, int64(-int32(1))))
			return int32(TCL_ERROR)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > 0 {
			return TCL_OK
		}
		/*
		 * Empty result => reparse.
		 */
		v15 = *(*uintptr)(unsafe.Pointer(prefixObjPtr))
		v14 = *(*TTcl_Size)(unsafe.Pointer(v15))
		*(*TTcl_Size)(unsafe.Pointer(v15))--
		if !(v14 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(prefixObjPtr)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(prefixObjPtr)))).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(prefixObjPtr)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(prefixObjPtr)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(prefixObjPtr)))).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(prefixObjPtr)))).Flength = int64(-libc.Int32FromInt32(1))
				if v16 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v16 {
					cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v16 || ((*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(prefixObjPtr)))
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(prefixObjPtr)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(prefixObjPtr))
					(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(prefixObjPtr)))
			}
		}
		return int32(TCL_CONTINUE)
	}
	/*
	 * Convert exceptional result to an error.
	 */
	if !(XTcl_InterpDeleted(tls, interp) != 0) {
		if result != int32(TCL_ERROR) {
			XTcl_ResetResult(tls, interp)
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+30462, int64(-libc.Int32FromInt32(1))))
			switch result {
			case int32(TCL_RETURN):
				XTcl_AppendToObj(tls, XTcl_GetObjResult(tls, interp), __ccgo_ts+5371, int64(-libc.Int32FromInt32(1)))
			case int32(TCL_BREAK):
				XTcl_AppendToObj(tls, XTcl_GetObjResult(tls, interp), __ccgo_ts+5123, int64(-libc.Int32FromInt32(1)))
			case int32(TCL_CONTINUE):
				XTcl_AppendToObj(tls, XTcl_GetObjResult(tls, interp), __ccgo_ts+5141, int64(-libc.Int32FromInt32(1)))
			default:
				XTcl_AppendPrintfToObj(tls, XTcl_GetObjResult(tls, interp), __ccgo_ts+260, libc.VaList(bp+32, result))
			}
			XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+30509, int64(-int32(1))))
			XTcl_AppendObjToErrorInfo(tls, interp, unknownCmd)
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+32, __ccgo_ts+2004, __ccgo_ts+29633, __ccgo_ts+30562, libc.UintptrFromInt32(0)))
		} else {
			XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+30577, int64(-int32(1))))
		}
	}
	v18 = unknownCmd
	v17 = *(*TTcl_Size)(unsafe.Pointer(v18))
	*(*TTcl_Size)(unsafe.Pointer(v18))--
	if !(v17 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(unknownCmd)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(unknownCmd)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(unknownCmd)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(unknownCmd)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(unknownCmd)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(unknownCmd)).Flength = int64(-libc.Int32FromInt32(1))
			if v19 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v19 {
				cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v19 || ((*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, unknownCmd)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(unknownCmd + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = unknownCmd
				(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, unknownCmd)
		}
	}
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * MakeCachedEnsembleCommand --
 *
 *	Caches what has been computed so far to minimize string copying.
 *	Starts by deleting any existing representation but reusing the existing
 *	structure if it is an ensembleCmd.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Converts the internal representation of the given object to an
 *	ensembleCmd.
 *
 *----------------------------------------------------------------------
 */

func _MakeCachedEnsembleCommand(tls *libc.TLS, objPtr uintptr, ensemblePtr uintptr, hPtr uintptr, fix uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Spelling correction for later error, or NULL
	 * if no correction. */
	var _objPtr, ensembleCmd, irPtr, v1, v2, v4, v6 uintptr
	var v3, v5 TTcl_Size
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_, _, _, _, _, _, _, _, _ = _objPtr, ensembleCmd, irPtr, v1, v2, v3, v4, v5, v6
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_ensembleCmdType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	ensembleCmd = v2
	if ensembleCmd != 0 {
		v4 = (*TEnsembleCmdRep)(unsafe.Pointer(ensembleCmd)).Ftoken + 16
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclpFree(tls, (*TEnsembleCmdRep)(unsafe.Pointer(ensembleCmd)).Ftoken)
		}
		if (*TEnsembleCmdRep)(unsafe.Pointer(ensembleCmd)).Ffix != 0 {
			_objPtr = (*TEnsembleCmdRep)(unsafe.Pointer(ensembleCmd)).Ffix
			v6 = _objPtr
			v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
			*(*TTcl_Size)(unsafe.Pointer(v6))--
			if v5 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
	} else {
		/*
		 * Replace any old internal representation with a new one.
		 */
		ensembleCmd = XTcl_Alloc(tls, uint64(32))
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(bp))).Fptr1 = ensembleCmd
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(bp))).Fptr2 = libc.UintptrFromInt32(0)
		XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&_ensembleCmdType)), bp)
	}
	/*
	 * Populate the internal rep.
	 */
	(*TEnsembleCmdRep)(unsafe.Pointer(ensembleCmd)).Fepoch = (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).Fepoch
	(*TEnsembleCmdRep)(unsafe.Pointer(ensembleCmd)).Ftoken = (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).Ftoken
	(*TCommand)(unsafe.Pointer((*TEnsembleCmdRep)(unsafe.Pointer(ensembleCmd)).Ftoken)).FrefCount++
	if fix != 0 {
		(*TTcl_Obj)(unsafe.Pointer(fix)).FrefCount++
	}
	(*TEnsembleCmdRep)(unsafe.Pointer(ensembleCmd)).Ffix = fix
	(*TEnsembleCmdRep)(unsafe.Pointer(ensembleCmd)).FhPtr = hPtr
}

/*
 *----------------------------------------------------------------------
 *
 * DeleteEnsembleConfig --
 *
 *	Destroys the data structure used to represent an ensemble.  Called when
 *	the procedure for the ensemble is deleted, which happens automatically
 *	if the namespace for the ensemble is deleted.  Deleting the procedure
 *	for an ensemble is the right way to initiate cleanup.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Memory is eventually deallocated.
 *
 *----------------------------------------------------------------------
 */

func _ClearTable(tls *libc.TLS, ensemblePtr uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Ensemble to clear table of. */
	var _objPtr, hPtr, hash, prefixObj, v2 uintptr
	var v1 TTcl_Size
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _ = _objPtr, hPtr, hash, prefixObj, v1, v2
	hash = ensemblePtr + 32
	if (*TTcl_HashTable)(unsafe.Pointer(hash)).FnumEntries != 0 {
		hPtr = XTcl_FirstHashEntry(tls, hash, bp)
		for hPtr != libc.UintptrFromInt32(0) {
			prefixObj = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
			_objPtr = prefixObj
			v2 = _objPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if v1 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			hPtr = XTcl_NextHashEntry(tls, bp)
		}
		XTclpFree(tls, (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcommandArrayPtr)
	}
	XTcl_DeleteHashTable(tls, hash)
}

func _DeleteEnsembleConfig(tls *libc.TLS, clientData uintptr) {
	/* Ensemble to delete. */
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, ensPtr, ensemblePtr, nsPtr, v2, v4, v6, v8 uintptr
	var v1, v3, v5, v7 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, ensPtr, ensemblePtr, nsPtr, v1, v2, v3, v4, v5, v6, v7, v8
	ensemblePtr = clientData
	nsPtr = (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FnsPtr
	/* Unlink from the ensemble chain if it not already marked as unlinked. */
	if (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).Fnext != ensemblePtr {
		ensPtr = (*TNamespace)(unsafe.Pointer(nsPtr)).Fensembles
		if ensPtr == ensemblePtr {
			(*TNamespace)(unsafe.Pointer(nsPtr)).Fensembles = (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).Fnext
		} else {
			for ensPtr != libc.UintptrFromInt32(0) {
				if (*TEnsembleConfig)(unsafe.Pointer(ensPtr)).Fnext == ensemblePtr {
					(*TEnsembleConfig)(unsafe.Pointer(ensPtr)).Fnext = (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).Fnext
					break
				}
				ensPtr = (*TEnsembleConfig)(unsafe.Pointer(ensPtr)).Fnext
			}
		}
	}
	/*
	 * Mark the namespace as dead so code that uses Tcl_Preserve() can tell
	 * whether disaster happened anyway.
	 */
	*(*int32)(unsafe.Pointer(ensemblePtr + 144)) |= int32(ENSEMBLE_DEAD)
	/*
	 * Release the fields that contain pointers.
	 */
	_ClearTable(tls, ensemblePtr)
	if (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcmdList != libc.UintptrFromInt32(0) {
		_objPtr = (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcmdList
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	if (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FparameterList != libc.UintptrFromInt32(0) {
		_objPtr1 = (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FparameterList
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
	if (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcommandDict != libc.UintptrFromInt32(0) {
		_objPtr2 = (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcommandDict
		v6 = _objPtr2
		v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
		*(*TTcl_Size)(unsafe.Pointer(v6))--
		if v5 <= int64(1) {
			XTclFreeObj(tls, _objPtr2)
		}
	}
	if (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FunknownHandler != libc.UintptrFromInt32(0) {
		_objPtr3 = (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FunknownHandler
		v8 = _objPtr3
		v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
		*(*TTcl_Size)(unsafe.Pointer(v8))--
		if v7 <= int64(1) {
			XTclFreeObj(tls, _objPtr3)
		}
	}
	/*
	 * Arrange for the structure to be reclaimed. This is complex because it is
	 * necessary to react sensibly when an ensemble is deleted during its
	 * initialisation, particularly in the case of an unknown callback.
	 */
	XTcl_EventuallyFree(tls, ensemblePtr, libc.UintptrFromInt32(3))
}

/*
 *----------------------------------------------------------------------
 *
 * BuildEnsembleConfig --
 *
 *	Creates the internal data structures that describe how an ensemble
 *	looks.  The structures are a hash map from the full command name to the
 *	Tcl list that describes the implementation prefix words, and a sorted
 *	array of all the full command names to allow for reasonably efficient
 *	handling of an unambiguous prefix.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Reallocates and rebuilds the hash table and array stored at the
 *	ensemblePtr argument. For large ensembles or large namespaces, this is
 *	may be an expensive operation.
 *
 *----------------------------------------------------------------------
 */

func _BuildEnsembleConfig(tls *libc.TLS, ensemblePtr uintptr) {
	bp := tls.Alloc(160)
	defer tls.Free(160) /* Ensemble to set up. */
	var _objPtr, cachePtr, cmdPrefixObj, cmdPrefixObj1, hPtr, hash, mapDict, name, name1, nsCmdName, subList, v10, v11, v13, v16, v18, v20, v5, v7, v8 uintptr
	var i, j, v17, v19, v6 TTcl_Size
	var v15 bool
	var v2, v3 int64
	var _ /* cmdObj at bp+112 */ uintptr
	var _ /* cmdObj at bp+56 */ uintptr
	var _ /* dictSearch at bp+64 */ TTcl_DictSearch
	var _ /* done at bp+104 */ int32
	var _ /* isNew at bp+24 */ int32
	var _ /* keyObj at bp+88 */ uintptr
	var _ /* search at bp+0 */ TTcl_HashSearch
	var _ /* subc at bp+32 */ TTcl_Size
	var _ /* subv at bp+40 */ uintptr
	var _ /* target at bp+48 */ uintptr
	var _ /* valueObj at bp+96 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, cmdPrefixObj, cmdPrefixObj1, hPtr, hash, i, j, mapDict, name, name1, nsCmdName, subList, v10, v11, v13, v15, v16, v17, v18, v19, v2, v20, v3, v5, v6, v7, v8
	hash = ensemblePtr + 32
	mapDict = (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcommandDict
	subList = (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcmdList
	_ClearTable(tls, ensemblePtr)
	XTcl_InitHashTable(tls, hash, TCL_STRING_KEYS)
	if subList != 0 {
		/*
		 * There is a list of exactly what subcommands go in the table.
		 * Determine the target for each.
		 */
		if (*TTcl_Obj)(unsafe.Pointer(subList)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(subList + 32))).Fptr2 != 0 {
				v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(subList + 32))).Fptr2)).FspanStart
			} else {
				v2 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(subList + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 40)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(subList + 32))).Fptr1 + 40 + uintptr(v2)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(subList + 32))).Fptr2 != 0 {
				v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(subList + 32))).Fptr2)).FspanLength
			} else {
				v3 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(subList + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = v3
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), subList, bp+32, bp+40)
		}
		if subList == mapDict {
			/*
			 * Unusual case where explicit list of subcommands is same value
			 * as the dict mapping to targets.
			 */
			i = 0
			for {
				if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 32))) {
					break
				}
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + uintptr(i)*8)))).Fbytes != 0 {
					v5 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + uintptr(i)*8)))).Fbytes
				} else {
					v5 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + uintptr(i)*8)), libc.UintptrFromInt32(0))
				}
				name = v5
				hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(hash)).FcreateProc})))(tls, hash, name, bp+24)
				if !(*(*int32)(unsafe.Pointer(bp + 24)) != 0) {
					*(*uintptr)(unsafe.Pointer(bp + 56)) = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
					_objPtr = *(*uintptr)(unsafe.Pointer(bp + 56))
					v7 = _objPtr
					v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
					*(*TTcl_Size)(unsafe.Pointer(v7))--
					if v6 <= int64(1) {
						XTclFreeObj(tls, _objPtr)
					}
				}
				(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + uintptr(i+int64(1))*8))
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + uintptr(i+int64(1))*8)))).FrefCount++
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + uintptr(i+int64(1))*8)))).Fbytes != 0 {
					v8 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + uintptr(i+int64(1))*8)))).Fbytes
				} else {
					v8 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + uintptr(i+int64(1))*8)), libc.UintptrFromInt32(0))
				}
				name = v8
				hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(hash)).FcreateProc})))(tls, hash, name, bp+24)
				if *(*int32)(unsafe.Pointer(bp + 24)) != 0 {
					*(*uintptr)(unsafe.Pointer(bp + 56)) = XTcl_NewStringObj(tls, name, int64(-libc.Int32FromInt32(1)))
					cmdPrefixObj = XTcl_NewListObj(tls, int64(1), bp+56)
					(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = cmdPrefixObj
					(*TTcl_Obj)(unsafe.Pointer(cmdPrefixObj)).FrefCount++
				}
				goto _4
			_4:
				;
				i += int64(2)
			}
		} else {
			/*
			 * Usual case where we can freely act on the list and dict.
			 */
			i = 0
			for {
				if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 32))) {
					break
				}
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + uintptr(i)*8)))).Fbytes != 0 {
					v10 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + uintptr(i)*8)))).Fbytes
				} else {
					v10 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + uintptr(i)*8)), libc.UintptrFromInt32(0))
				}
				name = v10
				hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(hash)).FcreateProc})))(tls, hash, name, bp+24)
				if !(*(*int32)(unsafe.Pointer(bp + 24)) != 0) {
					goto _9
				}
				/*
				 * Lookup target in the dictionary.
				 */
				if mapDict != 0 {
					XTcl_DictObjGet(tls, libc.UintptrFromInt32(0), mapDict, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + uintptr(i)*8)), bp+48)
					if *(*uintptr)(unsafe.Pointer(bp + 48)) != 0 {
						(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = *(*uintptr)(unsafe.Pointer(bp + 48))
						(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).FrefCount++
						goto _9
					}
				}
				/*
				 * Target was not in the dictionary.  Map onto the namespace.
				 * In this case there is no guarantee that the command is
				 * actually there.  It is the responsibility of the programmer
				 * (or [::unknown] of course) to provide the procedure.
				 */
				*(*uintptr)(unsafe.Pointer(bp + 56)) = XTcl_NewStringObj(tls, name, int64(-libc.Int32FromInt32(1)))
				cmdPrefixObj = XTcl_NewListObj(tls, int64(1), bp+56)
				(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = cmdPrefixObj
				(*TTcl_Obj)(unsafe.Pointer(cmdPrefixObj)).FrefCount++
				goto _9
			_9:
				;
				i++
			}
		}
	} else {
		if mapDict != 0 {
			XTcl_DictObjFirst(tls, libc.UintptrFromInt32(0), (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcommandDict, bp+64, bp+88, bp+96, bp+104)
			for !(*(*int32)(unsafe.Pointer(bp + 104)) != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 88)))).Fbytes != 0 {
					v11 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 88)))).Fbytes
				} else {
					v11 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 88)), libc.UintptrFromInt32(0))
				}
				name1 = v11
				hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(hash)).FcreateProc})))(tls, hash, name1, bp+24)
				(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = *(*uintptr)(unsafe.Pointer(bp + 96))
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 96)))).FrefCount++
				XTcl_DictObjNext(tls, bp+64, bp+88, bp+96, bp+104)
			}
		} else {
			/*
			 * Use the array of patterns and the hash table whose keys are the
			 * commands exported by the namespace.  The corresponding values do not
			 * matter here.  Filter the commands in the namespace against the
			 * patterns in the export list to find out what commands are actually
			 * exported. Use an intermediate hash table to make memory management
			 * easier and to make exact matching much easier.
			 *
			 * Suggestion for future enhancement: Compute the unique prefixes and
			 * place them in the hash too for even faster matching.
			 */
			hPtr = XTcl_FirstHashEntry(tls, (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FnsPtr+184, bp)
			for {
				if !(hPtr != libc.UintptrFromInt32(0)) {
					break
				}
				if (*TTcl_HashTable)(unsafe.Pointer((*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FnsPtr+184)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer((*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FnsPtr+184)).FkeyType == -int32(1) {
					v13 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
				} else {
					v13 = hPtr + 32
				}
				nsCmdName = v13
				i = 0
				for {
					if !(i < (*TNamespace)(unsafe.Pointer((*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FnsPtr)).FnumExportPatterns) {
						break
					}
					if XTcl_StringCaseMatch(tls, nsCmdName, *(*uintptr)(unsafe.Pointer((*TNamespace)(unsafe.Pointer((*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FnsPtr)).FexportArrayPtr + uintptr(i)*8)), 0) != 0 {
						hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(hash)).FcreateProc})))(tls, hash, nsCmdName, bp+24)
						/*
						 * Remember, hash entries have a full reference to the
						 * substituted part of the command (as a list) as their
						 * content!
						 */
						if *(*int32)(unsafe.Pointer(bp + 24)) != 0 {
							if v15 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v15 {
								cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
							}
							if v15 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
								*(*uintptr)(unsafe.Pointer(bp + 112)) = XTclThreadAllocObj(tls)
							} else {
								*(*uintptr)(unsafe.Pointer(bp + 112)) = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
								(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112)) + 32))).Fptr1
								(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
							}
							(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112)))).FrefCount = 0
							(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
							(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112)))).Flength = 0
							(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112)))).FtypePtr = libc.UintptrFromInt32(0)
							if (*TNamespace)(unsafe.Pointer((*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FnsPtr)).FparentPtr != 0 {
								v16 = __ccgo_ts + 7650
							} else {
								v16 = __ccgo_ts + 1945
							}
							XTcl_AppendStringsToObj(tls, *(*uintptr)(unsafe.Pointer(bp + 112)), libc.VaList(bp+128, (*TNamespace)(unsafe.Pointer((*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FnsPtr)).FfullName, v16, nsCmdName, libc.UintptrFromInt32(0)))
							cmdPrefixObj1 = XTcl_NewListObj(tls, int64(1), bp+112)
							(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = cmdPrefixObj1
							(*TTcl_Obj)(unsafe.Pointer(cmdPrefixObj1)).FrefCount++
						}
						break
					}
					goto _14
				_14:
					;
					i++
				}
				goto _12
			_12:
				;
				hPtr = XTcl_NextHashEntry(tls, bp)
			}
		}
	}
	if (*TTcl_HashTable)(unsafe.Pointer(hash)).FnumEntries == 0 {
		(*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcommandArrayPtr = libc.UintptrFromInt32(0)
		return
	}
	/*
	 * Create a sorted array of all subcommands in the ensemble.  Hash tables
	 * are all very well for a quick look for an exact match, but they can't
	 * determine things like whether a string is a prefix of another, at least
	 * not without a lot of preparation, and they're not useful for generating
	 * the error message either.
	 *
	 * Do this by filling an array with the names:  Use the hash keys
	 * directly to save a copy since any time we change the array we change
	 * the hash too, and vice versa, and run quicksort over the array.
	 */
	(*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcommandArrayPtr = XTcl_Alloc(tls, uint64(8)*libc.Uint64FromInt64((*TTcl_HashTable)(unsafe.Pointer(hash)).FnumEntries))
	/*
	 * Fill the array from both ends as this reduces the likelihood of
	 * performance problems in qsort(). This makes this code much more opaque,
	 * but the naive alternatve:
	 *
	 * for (hPtr=Tcl_FirstHashEntry(hash,&search),i=0 ;
	 *	       hPtr!=NULL ; hPtr=Tcl_NextHashEntry(&search),i++) {
	 *     ensemblePtr->subcommandArrayPtr[i] = Tcl_GetHashKey(hash, &hPtr);
	 * }
	 *
	 * can produce long runs of precisely ordered table entries when the
	 * commands in the namespace are declared in a sorted fashion,  which is an
	 * ordering some people like, and the hashing functions or the command
	 * names themselves are fairly unfortunate. Filling from both ends means
	 * that it requires active malice, and probably a debugger, to get qsort()
	 * to have awful runtime behaviour.
	 */
	i = 0
	j = (*TTcl_HashTable)(unsafe.Pointer(hash)).FnumEntries
	hPtr = XTcl_FirstHashEntry(tls, hash, bp)
	for hPtr != libc.UintptrFromInt32(0) {
		v17 = i
		i++
		if (*TTcl_HashTable)(unsafe.Pointer(hash)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(hash)).FkeyType == -int32(1) {
			v18 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
		} else {
			v18 = hPtr + 32
		}
		*(*uintptr)(unsafe.Pointer((*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcommandArrayPtr + uintptr(v17)*8)) = v18
		hPtr = XTcl_NextHashEntry(tls, bp)
		if hPtr == libc.UintptrFromInt32(0) {
			break
		}
		j--
		v19 = j
		if (*TTcl_HashTable)(unsafe.Pointer(hash)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(hash)).FkeyType == -int32(1) {
			v20 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
		} else {
			v20 = hPtr + 32
		}
		*(*uintptr)(unsafe.Pointer((*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcommandArrayPtr + uintptr(v19)*8)) = v20
		hPtr = XTcl_NextHashEntry(tls, bp)
	}
	if (*TTcl_HashTable)(unsafe.Pointer(hash)).FnumEntries > int64(1) {
		libc.Xqsort(tls, (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).FsubcommandArrayPtr, libc.Uint64FromInt64((*TTcl_HashTable)(unsafe.Pointer(hash)).FnumEntries), uint64(8), __ccgo_fp(_NsEnsembleStringOrder))
	}
}

/*
 *----------------------------------------------------------------------
 *
 * NsEnsembleStringOrder --
 *
 *	Helper to for use with qsort() that compares two array entries that
 *	contain string pointers.
 *
 * Results:
 *	-1 if the first string is smaller, 1 if the second string is smaller,
 *	and 0 if they are equal.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _NsEnsembleStringOrder(tls *libc.TLS, strPtr1 uintptr, strPtr2 uintptr) (r int32) {
	/* Points to second array entry */
	return libc.Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(strPtr1)), *(*uintptr)(unsafe.Pointer(strPtr2)))
}

/*
 *----------------------------------------------------------------------
 *
 * FreeEnsembleCmdRep --
 *
 *	Destroys the internal representation of a Tcl_Obj that has been
 *	holding information about a command in an ensemble.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Memory is deallocated. If this held the last reference to a
 *	namespace's main structure, that main structure will also be
 *	destroyed.
 *
 *----------------------------------------------------------------------
 */

func _FreeEnsembleCmdRep(tls *libc.TLS, objPtr uintptr) {
	var _objPtr, ensembleCmd, irPtr, v1, v2, v4, v6 uintptr
	var v3, v5 TTcl_Size
	_, _, _, _, _, _, _, _, _ = _objPtr, ensembleCmd, irPtr, v1, v2, v3, v4, v5, v6
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_ensembleCmdType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	ensembleCmd = v2
	v4 = (*TEnsembleCmdRep)(unsafe.Pointer(ensembleCmd)).Ftoken + 16
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	if v3 <= int64(1) {
		XTclpFree(tls, (*TEnsembleCmdRep)(unsafe.Pointer(ensembleCmd)).Ftoken)
	}
	if (*TEnsembleCmdRep)(unsafe.Pointer(ensembleCmd)).Ffix != 0 {
		_objPtr = (*TEnsembleCmdRep)(unsafe.Pointer(ensembleCmd)).Ffix
		v6 = _objPtr
		v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
		*(*TTcl_Size)(unsafe.Pointer(v6))--
		if v5 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	XTclpFree(tls, ensembleCmd)
}

/*
 *----------------------------------------------------------------------
 *
 * DupEnsembleCmdRep --
 *
 *	Makes one Tcl_Obj into a copy of another that is a subcommand of an
 *	ensemble.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Memory is allocated, and the namespace that the ensemble is built on
 *	top of gains another reference.
 *
 *----------------------------------------------------------------------
 */

func _DupEnsembleCmdRep(tls *libc.TLS, objPtr uintptr, copyPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var ensembleCmd, ensembleCopy, irPtr, v1, v2 uintptr
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_, _, _, _, _ = ensembleCmd, ensembleCopy, irPtr, v1, v2
	ensembleCopy = XTcl_Alloc(tls, uint64(32))
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_ensembleCmdType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	ensembleCmd = v2
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr1 = ensembleCopy
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr2 = libc.UintptrFromInt32(0)
	XTcl_StoreInternalRep(tls, copyPtr, uintptr(unsafe.Pointer(&_ensembleCmdType)), bp)
	(*TEnsembleCmdRep)(unsafe.Pointer(ensembleCopy)).Fepoch = (*TEnsembleCmdRep)(unsafe.Pointer(ensembleCmd)).Fepoch
	(*TEnsembleCmdRep)(unsafe.Pointer(ensembleCopy)).Ftoken = (*TEnsembleCmdRep)(unsafe.Pointer(ensembleCmd)).Ftoken
	(*TCommand)(unsafe.Pointer((*TEnsembleCmdRep)(unsafe.Pointer(ensembleCopy)).Ftoken)).FrefCount++
	(*TEnsembleCmdRep)(unsafe.Pointer(ensembleCopy)).Ffix = (*TEnsembleCmdRep)(unsafe.Pointer(ensembleCmd)).Ffix
	if (*TEnsembleCmdRep)(unsafe.Pointer(ensembleCopy)).Ffix != 0 {
		(*TTcl_Obj)(unsafe.Pointer((*TEnsembleCmdRep)(unsafe.Pointer(ensembleCopy)).Ffix)).FrefCount++
	}
	(*TEnsembleCmdRep)(unsafe.Pointer(ensembleCopy)).FhPtr = (*TEnsembleCmdRep)(unsafe.Pointer(ensembleCmd)).FhPtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileEnsemble --
 *
 *	Procedure called to compile an ensemble command. Note that most
 *	ensembles are not compiled, since modifying a compiled ensemble causes
 *	a invalidation of all existing bytecode (expensive!) which is not
 *	normally warranted.
 *
 * Results:
 *	Returns TCL_OK for a successful compile. Returns TCL_ERROR to defer
 *	evaluation to runtime.
 *
 * Side effects:
 *	Instructions are added to envPtr to execute the subcommands of the
 *	ensemble at runtime if a compile-time mapping is possible.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileEnsemble(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr uintptr) (r int32) {
	bp := tls.Alloc(112)
	defer tls.Free(112) /* Holds resulting instructions. */
	var _objPtr, cachePtr, cachePtr1, cachePtr2, cachePtr3, mapPtr, matchObj, newCmdPtr, oldCmdPtr, replaced, replacement, str, tokenPtr, word, v10, v12, v18, v21, v6, v8 uintptr
	var depth, invokeAnyway, matched, ourResult, result, v13, v14, v2 int32
	var eclIndex, i, numBytes, v17, v20, v9 TTcl_Size
	var ensemble TTcl_Command
	var v1, v11, v19, v7 bool
	var v15, v16, v3, v4 int64
	var _ /* done at bp+88 */ int32
	var _ /* elems at bp+32 */ uintptr
	var _ /* flags at bp+40 */ int32
	var _ /* len at bp+48 */ TTcl_Size
	var _ /* listObj at bp+24 */ uintptr
	var _ /* mapObj at bp+0 */ uintptr
	var _ /* s at bp+64 */ TTcl_DictSearch
	var _ /* sclen at bp+56 */ TTcl_Size
	var _ /* subcmdObj at bp+8 */ uintptr
	var _ /* targetCmdObj at bp+16 */ uintptr
	var _ /* tmpObj at bp+96 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, cachePtr1, cachePtr2, cachePtr3, depth, eclIndex, ensemble, i, invokeAnyway, mapPtr, matchObj, matched, newCmdPtr, numBytes, oldCmdPtr, ourResult, replaced, replacement, result, str, tokenPtr, word, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v3, v4, v6, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	ensemble = cmdPtr
	oldCmdPtr = cmdPtr
	*(*int32)(unsafe.Pointer(bp + 40)) = 0
	depth = int32(1)
	invokeAnyway = 0
	ourResult = int32(TCL_ERROR)
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		replaced = XTclThreadAllocObj(tls)
	} else {
		replaced = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(replaced + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(replaced)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(replaced)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(replaced)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(replaced)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(replaced)).FrefCount++
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords <= int64(depth) {
		goto tryCompileToInv
	}
	if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) {
		/*
		 * Too hard.
		 */
		goto tryCompileToInv
	}
	/*
	 * This is where we return to if we are parsing multiple nested compiled
	 * ensembles. [info object] is such a beast.
	 */
	goto checkNextWord
checkNextWord:
	;
	word = (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart
	numBytes = (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize
	/*
	 * There's a sporting chance we'll be able to compile this. But now we
	 * must check properly. To do that, check that we're compiling an ensemble
	 * that has a compilable command as its appropriate subcommand.
	 */
	if XTcl_GetEnsembleMappingDict(tls, libc.UintptrFromInt32(0), ensemble, bp) != TCL_OK || *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
		/*
		 * Either not an ensemble or a mapping isn't installed. Crud. Too hard
		 * to proceed.
		 */
		goto tryCompileToInv
	}
	/*
	 * Also refuse to compile anything that uses a formal parameter list for
	 * now, on the grounds that it is too complex.
	 */
	if XTcl_GetEnsembleParameterList(tls, libc.UintptrFromInt32(0), ensemble, bp+24) != TCL_OK || *(*uintptr)(unsafe.Pointer(bp + 24)) != libc.UintptrFromInt32(0) {
		/*
		 * Figuring out how to compile this has become too much. Bail out.
		 */
		goto tryCompileToInv
	}
	/*
	 * Next, get the flags. We need them on several code paths so that we can
	 * know whether we're to do prefix matching.
	 */
	XTcl_GetEnsembleFlags(tls, libc.UintptrFromInt32(0), ensemble, bp+40)
	/*
	 * Check to see if there's also a subcommand list; must check to see if
	 * the subcommand we are calling is in that list if it exists, since that
	 * list filters the entries in the map.
	 */
	XTcl_GetEnsembleSubcommandList(tls, libc.UintptrFromInt32(0), ensemble, bp+24)
	if *(*uintptr)(unsafe.Pointer(bp + 24)) != libc.UintptrFromInt32(0) {
		matchObj = libc.UintptrFromInt32(0)
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 32))).Fptr2 != 0 {
				v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 32))).Fptr2)).FspanStart
			} else {
				v3 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 32)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 32))).Fptr1 + 40 + uintptr(v3)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 32))).Fptr2 != 0 {
				v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 32))).Fptr2)).FspanLength
			} else {
				v4 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 48)) = v4
			v2 = libc.Int32FromInt32(TCL_OK)
		} else {
			v2 = XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 24)), bp+48, bp+32)
		}
		if v2 != TCL_OK {
			goto tryCompileToInv
		}
		i = 0
		for {
			if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 48))) {
				break
			}
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)) + uintptr(i)*8)))).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 56)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)) + uintptr(i)*8)))).Flength
				v6 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)) + uintptr(i)*8)))).Fbytes
			} else {
				v6 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)) + uintptr(i)*8)), bp+56)
			}
			str = v6
			if *(*TTcl_Size)(unsafe.Pointer(bp + 56)) == numBytes && !(libc.Xmemcmp(tls, word, str, libc.Uint64FromInt64(numBytes)) != 0) {
				/*
				 * Exact match! Excellent!
				 */
				result = XTcl_DictObjGet(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)) + uintptr(i)*8)), bp+16)
				if result != TCL_OK || *(*uintptr)(unsafe.Pointer(bp + 16)) == libc.UintptrFromInt32(0) {
					goto tryCompileToInv
				}
				replacement = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)) + uintptr(i)*8))
				goto doneMapLookup
			}
			/*
			 * Check to see if we've got a prefix match. A single prefix match
			 * is fine, and allows us to refine our dictionary lookup, but
			 * multiple prefix matches is a Bad Thing and will prevent us from
			 * making progress. Note that we cannot do the lookup immediately
			 * in the prefix case; might be another entry later in the list
			 * that causes things to fail.
			 */
			if *(*int32)(unsafe.Pointer(bp + 40))&int32(TCL_ENSEMBLE_PREFIX) != 0 && libc.Xstrncmp(tls, word, str, libc.Uint64FromInt64(numBytes)) == 0 {
				if matchObj != libc.UintptrFromInt32(0) {
					goto tryCompileToInv
				}
				matchObj = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)) + uintptr(i)*8))
			}
			goto _5
		_5:
			;
			i++
		}
		if matchObj == libc.UintptrFromInt32(0) {
			goto tryCompileToInv
		}
		result = XTcl_DictObjGet(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), matchObj, bp+16)
		if result != TCL_OK || *(*uintptr)(unsafe.Pointer(bp + 16)) == libc.UintptrFromInt32(0) {
			goto tryCompileToInv
		}
		replacement = matchObj
	} else {
		/*
		 * No map, so check the dictionary directly.
		 */
		if v7 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v7 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v7 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
		if numBytes == 0 {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(numBytes+libc.Int64FromUint32(1)))
			if word != 0 {
				v8 = word
			} else {
				v8 = uintptr(unsafe.Pointer(&XtclEmptyString))
			}
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes, v8, libc.Uint64FromInt64(numBytes))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes + uintptr(numBytes))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = numBytes
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = libc.UintptrFromInt32(0)
		result = XTcl_DictObjGet(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 8)), bp+16)
		if result == TCL_OK && *(*uintptr)(unsafe.Pointer(bp + 16)) != libc.UintptrFromInt32(0) {
			/*
			 * Got it. Skip the fiddling around with prefixes.
			 */
			replacement = *(*uintptr)(unsafe.Pointer(bp + 8))
			goto doneMapLookup
		}
		v10 = *(*uintptr)(unsafe.Pointer(bp + 8))
		v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
		*(*TTcl_Size)(unsafe.Pointer(v10))--
		if !(v9 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = int64(-libc.Int32FromInt32(1))
				if v11 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v11 {
					cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v11 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
			}
		}
		/*
		 * We've not literally got a valid subcommand. But maybe we have a
		 * prefix. Check if prefix matches are allowed.
		 */
		if !(*(*int32)(unsafe.Pointer(bp + 40))&libc.Int32FromInt32(TCL_ENSEMBLE_PREFIX) != 0) {
			goto tryCompileToInv
		}
		/*
		 * Iterate over the keys in the dictionary, checking to see if we're a
		 * prefix.
		 */
		XTcl_DictObjFirst(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), bp+64, bp+8, bp+96, bp+88)
		matched = 0
		replacement = libc.UintptrFromInt32(0) /* Silence, fool compiler! */
		for !(*(*int32)(unsafe.Pointer(bp + 88)) != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != 0 {
				v12 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes
			} else {
				v12 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), libc.UintptrFromInt32(0))
			}
			if libc.Xstrncmp(tls, v12, word, libc.Uint64FromInt64(numBytes)) == 0 {
				v13 = matched
				matched++
				if v13 != 0 {
					/*
					 * Must have matched twice! Not unique, so no point
					 * looking further.
					 */
					break
				}
				replacement = *(*uintptr)(unsafe.Pointer(bp + 8))
				*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(bp + 96))
			}
			XTcl_DictObjNext(tls, bp+64, bp+8, bp+96, bp+88)
		}
		XTcl_DictObjDone(tls, bp+64)
		/*
		 * If we have anything other than a single match, we've failed the
		 * unique prefix check.
		 */
		if matched != int32(1) {
			invokeAnyway = int32(1)
			goto tryCompileToInv
		}
	}
	/*
	 * OK, we definitely map to something. But what?
	 *
	 * The command we map to is the first word out of the map element. Note
	 * that we also reject dealing with multi-element rewrites if we are in a
	 * safe interpreter, as there is otherwise a (highly gnarly!) way to make
	 * Tcl crash open to exploit.
	 */
	goto doneMapLookup
doneMapLookup:
	;
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), replaced, replacement)
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr2 != 0 {
			v15 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr2)).FspanStart
		} else {
			v15 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 32)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1 + 40 + uintptr(v15)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr2 != 0 {
			v16 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr2)).FspanLength
		} else {
			v16 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 48)) = v16
		v14 = libc.Int32FromInt32(TCL_OK)
	} else {
		v14 = XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 16)), bp+48, bp+32)
	}
	if v14 != TCL_OK {
		goto tryCompileToInv
	} else {
		if *(*TTcl_Size)(unsafe.Pointer(bp + 48)) != int64(1) {
			/*
			 * Note that at this point we know we can't issue any special
			 * instruction sequence as the mapping isn't one that we support at
			 * the compiled level.
			 */
			goto cleanup
		}
	}
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32))))
	oldCmdPtr = cmdPtr
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount++
	newCmdPtr = XTcl_GetCommandFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 16)))
	v18 = *(*uintptr)(unsafe.Pointer(bp + 16))
	v17 = *(*TTcl_Size)(unsafe.Pointer(v18))
	*(*TTcl_Size)(unsafe.Pointer(v18))--
	if !(v17 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength = int64(-libc.Int32FromInt32(1))
			if v19 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v19 {
				cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v19 || ((*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp + 16))
				(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
		}
	}
	if newCmdPtr == libc.UintptrFromInt32(0) || XTcl_IsSafe(tls, interp) != 0 && !((*TCommand)(unsafe.Pointer(cmdPtr)).FcompileProc != 0) || (*TNamespace)(unsafe.Pointer((*TCommand)(unsafe.Pointer(newCmdPtr)).FnsPtr)).Fflags&int32(NS_SUPPRESS_COMPILATION) != 0 || (*TCommand)(unsafe.Pointer(newCmdPtr)).Fflags&int32(CMD_HAS_EXEC_TRACES) != 0 || (*TInterp)(unsafe.Pointer(interp)).Fflags&int32(DONT_COMPILE_CMDS_INLINE) != 0 {
		/*
		 * Maps to an undefined command or a command without a compiler.
		 * Cannot compile.
		 */
		goto cleanup
	}
	cmdPtr = newCmdPtr
	depth++
	/*
	 * See whether we have a nested ensemble. If we do, we can go round the
	 * mulberry bush again, consuming the next word.
	 */
	if (*TCommand)(unsafe.Pointer(cmdPtr)).FcompileProc == __ccgo_fp(XTclCompileEnsemble) {
		tokenPtr = tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) < depth+int32(1) || (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 != int32(TCL_TOKEN_SIMPLE_WORD) {
			/*
			 * Too hard because the user has done something unpleasant like
			 * omitting the sub-ensemble's command name or used a non-constant
			 * name for a sub-ensemble's command name; we respond by bailing
			 * out completely (this is a rare case). [Bug 6d2f249a01]
			 */
			goto cleanup
		}
		ensemble = cmdPtr
		goto checkNextWord
	}
	/*
	 * Now that the mapping process is done we actually try to compile.
	 * If there is a subcommand compiler and that successfully produces code,
	 * we'll use that. Otherwise, we fall back to generating opcodes to do the
	 * invoke at runtime.
	 */
	invokeAnyway = int32(1)
	if TCL_OK == XTclAttemptCompileProc(tls, interp, parsePtr, int64(depth), cmdPtr, envPtr) {
		ourResult = TCL_OK
		goto cleanup
	}
	/*
	 * Throw out any line information generated by the failed compile attempt.
	 */
	for (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc > eclIndex+int64(1) {
		(*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc--
		XTclpFree(tls, (*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc)*32))).Fline)
		(*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc)*32))).Fline = libc.UintptrFromInt32(0)
	}
	/*
	 * Reset the index of next command.  Toss out any from failed nested
	 * partial compiles.
	 */
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FnumCommands = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc
	/*
	 * Failed to do a full compile for some reason. Try to do a direct invoke
	 * instead of going through the ensemble lookup process again.
	 */
	goto tryCompileToInv
tryCompileToInv:
	;
	if depth < int32(250) {
		if depth > int32(1) {
			if !(invokeAnyway != 0) {
				cmdPtr = oldCmdPtr
				depth--
			}
		}
		/*
		 * The length of the "replaced" list must be depth-1.  Trim back
		 * any extra elements that might have been appended by failing
		 * pathways above.
		 */
		XTcl_ListObjReplace(tls, libc.UintptrFromInt32(0), replaced, int64(depth-int32(1)), libc.Int64FromUint64((libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))-uint64(libc.UintptrFromInt32(0)+40))/libc.Uint64FromInt64(8)), 0, libc.UintptrFromInt32(0))
		/*
		 * TODO: Reconsider whether we ought to call CompileToInvokedCommand()
		 * when depth==1.  In that case we are choosing to emit the
		 * INST_INVOKE_REPLACE bytecode when there is in fact no replacing
		 * to be done.  It would be equally functional and presumably more
		 * performant to fall through to cleanup below, return TCL_ERROR,
		 * and let the compiler harness emit the INST_INVOKE_STK
		 * implementation for us.
		 */
		_CompileToInvokedCommand(tls, interp, parsePtr, replaced, cmdPtr, envPtr)
		ourResult = TCL_OK
	}
	/*
	 * Release the memory we allocated. If we've got here, we've either done
	 * something useful or we're in a case that we can't compile at all and
	 * we're just giving up.
	 */
	goto cleanup
cleanup:
	;
	_objPtr = replaced
	v21 = _objPtr
	v20 = *(*TTcl_Size)(unsafe.Pointer(v21))
	*(*TTcl_Size)(unsafe.Pointer(v21))--
	if v20 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return ourResult
}

func XTclAttemptCompileProc(tls *libc.TLS, interp uintptr, parsePtr uintptr, depth TTcl_Size, cmdPtr uintptr, envPtr uintptr) (r int32) {
	/* Holds resulting instructions. */
	var auxDataEnd, auxDataPtr, auxPtr, mapPtr, saveTokenPtr uintptr
	var eclIndex, i, savedAuxDataArrayNext, savedCodeNext, savedExceptArrayNext, savedStackDepth TTcl_Size
	var result int32
	_, _, _, _, _, _, _, _, _, _, _, _ = auxDataEnd, auxDataPtr, auxPtr, eclIndex, i, mapPtr, result, saveTokenPtr, savedAuxDataArrayNext, savedCodeNext, savedExceptArrayNext, savedStackDepth
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	saveTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
	savedStackDepth = (*TCompileEnv)(unsafe.Pointer(envPtr)).FcurrStackDepth
	savedCodeNext = int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext) - int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart)
	savedAuxDataArrayNext = (*TCompileEnv)(unsafe.Pointer(envPtr)).FauxDataArrayNext
	savedExceptArrayNext = (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayNext
	if (*TCommand)(unsafe.Pointer(cmdPtr)).FcompileProc == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Advance parsePtr->tokenPtr so that it points at the last subcommand.
	 * This will be wrong but it will not matter, and it will put the
	 * tokens for the arguments in the right place without the need to
	 * allocate a synthetic Tcl_Parse struct or copy tokens around.
	 */
	i = 0
	for {
		if !(i < depth-int64(1)) {
			break
		}
		(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).FnumComponents+libc.Int64FromInt32(1))*32
		goto _1
	_1:
		;
		i++
	}
	*(*TTcl_Size)(unsafe.Pointer(parsePtr + 32)) -= depth - int64(1)
	/*
	 * Shift the line information arrays to account for different word
	 * index values.
	 */
	(*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline += uintptr(depth-libc.Int64FromInt32(1)) * 8
	(*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext += uintptr(depth-libc.Int64FromInt32(1)) * 8
	/*
	 * Hand off compilation to the subcommand compiler. At last!
	 */
	result = (*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TCommand)(unsafe.Pointer(cmdPtr)).FcompileProc})))(tls, interp, parsePtr, cmdPtr, envPtr)
	/*
	 * Undo the shift.
	 */
	(*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline -= uintptr(depth-libc.Int64FromInt32(1)) * 8
	(*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext -= uintptr(depth-libc.Int64FromInt32(1)) * 8
	*(*TTcl_Size)(unsafe.Pointer(parsePtr + 32)) += depth - int64(1)
	(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr = saveTokenPtr
	/*
	 * If our target failed to compile, revert any data from failed partial
	 * compiles.  Note that envPtr->numCommands need not be checked because
	 * we avoid compiling subcommands that recursively call TclCompileScript().
	 */
	if result != TCL_OK {
		auxPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptAuxArrayPtr
		i = 0
		for {
			if !(i < savedExceptArrayNext) {
				break
			}
			for (*TExceptionAux)(unsafe.Pointer(auxPtr)).FnumBreakTargets > 0 && libc.Int64FromUint64(*(*Tsize_t)(unsafe.Pointer((*TExceptionAux)(unsafe.Pointer(auxPtr)).FbreakTargets + uintptr((*TExceptionAux)(unsafe.Pointer(auxPtr)).FnumBreakTargets-int64(1))*8))) >= savedCodeNext {
				(*TExceptionAux)(unsafe.Pointer(auxPtr)).FnumBreakTargets--
			}
			for (*TExceptionAux)(unsafe.Pointer(auxPtr)).FnumContinueTargets > 0 && libc.Int64FromUint64(*(*Tsize_t)(unsafe.Pointer((*TExceptionAux)(unsafe.Pointer(auxPtr)).FcontinueTargets + uintptr((*TExceptionAux)(unsafe.Pointer(auxPtr)).FnumContinueTargets-int64(1))*8))) >= savedCodeNext {
				(*TExceptionAux)(unsafe.Pointer(auxPtr)).FnumContinueTargets--
			}
			auxPtr += 80
			goto _2
		_2:
			;
			i++
		}
		(*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayNext = savedExceptArrayNext
		if savedAuxDataArrayNext != (*TCompileEnv)(unsafe.Pointer(envPtr)).FauxDataArrayNext {
			auxDataPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FauxDataArrayPtr
			auxDataEnd = auxDataPtr
			auxDataPtr += uintptr(savedAuxDataArrayNext) * 16
			auxDataEnd += uintptr((*TCompileEnv)(unsafe.Pointer(envPtr)).FauxDataArrayNext) * 16
			for auxDataPtr < auxDataEnd {
				if (*TAuxDataType)(unsafe.Pointer((*TAuxData)(unsafe.Pointer(auxDataPtr)).Ftype1)).FfreeProc != libc.UintptrFromInt32(0) {
					(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TAuxDataType)(unsafe.Pointer((*TAuxData)(unsafe.Pointer(auxDataPtr)).Ftype1)).FfreeProc})))(tls, (*TAuxData)(unsafe.Pointer(auxDataPtr)).FclientData)
				}
				auxDataPtr += 16
			}
			(*TCompileEnv)(unsafe.Pointer(envPtr)).FauxDataArrayNext = savedAuxDataArrayNext
		}
		(*TCompileEnv)(unsafe.Pointer(envPtr)).FcurrStackDepth = savedStackDepth
		(*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext = (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr(savedCodeNext)
	}
	return result
}

/*
 * How to compile a subcommand to a _replacing_ invoke of its implementation
 * command.
 */

func _CompileToInvokedCommand(tls *libc.TLS, interp uintptr, parsePtr uintptr, replacements uintptr, cmdPtr uintptr, envPtr2 uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Holds resulting instructions. */
	var _objIndexCopy, _objIndexCopy1, _objIndexCopy2, cmdLit, delta1, extraLiteralFlags, literal, v10, v22, v28, v40, v48, v60 int32
	var bytes, cachePtr, cachePtr1, mapPtr, objPtr, tokPtr, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v23, v24, v25, v26, v27, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v41, v43, v44, v45, v46, v47, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v61, v63, v7, v8, v9 uintptr
	var eclIndex, i1, v62 TTcl_Size
	var v2, v3 int64
	var v42, v64 bool
	var _ /* length at bp+16 */ TTcl_Size
	var _ /* numWords at bp+8 */ TTcl_Size
	var _ /* words at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, _objIndexCopy1, _objIndexCopy2, bytes, cachePtr, cachePtr1, cmdLit, delta1, eclIndex, extraLiteralFlags, i1, literal, mapPtr, objPtr, tokPtr, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v7, v8, v9
	mapPtr = (*TCompileEnv)(unsafe.Pointer(envPtr2)).FextCmdMapPtr
	eclIndex = (*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Fnuloc - int64(1)
	extraLiteralFlags = int32(LITERAL_CMD_NAME)
	/*
	 * Push the words of the command. Take care; the command words may be
	 * scripts that have backslashes in them, and [info frame 0] can see the
	 * difference. Hence the call to TclContinuationsEnterDerived...
	 */
	if (*TTcl_Obj)(unsafe.Pointer(replacements)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(replacements + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(replacements + 32))).Fptr2)).FspanStart
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(replacements + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(replacements + 32))).Fptr1 + 40 + uintptr(v2)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(replacements + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(replacements + 32))).Fptr2)).FspanLength
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(replacements + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v3
		_ = libc.Int32FromInt32(TCL_OK)
	} else {
		XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), replacements, bp+8, bp)
	}
	i1 = 0
	tokPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
	for {
		if !(i1 < (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) {
			break
		}
		if i1 > 0 && i1 <= *(*TTcl_Size)(unsafe.Pointer(bp + 8)) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(i1-int64(1))*8)))).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(i1-int64(1))*8)))).Flength
				v5 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(i1-int64(1))*8)))).Fbytes
			} else {
				v5 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(i1-int64(1))*8)), bp+16)
			}
			bytes = v5
			_objIndexCopy = XTclRegisterLiteral(tls, envPtr2, bytes, *(*TTcl_Size)(unsafe.Pointer(bp + 16)), 0)
			if _objIndexCopy <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v7 = envPtr2 + 152
				v6 = *(*uintptr)(unsafe.Pointer(v7))
				*(*uintptr)(unsafe.Pointer(v7))++
				*(*uint8)(unsafe.Pointer(v6)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v9 = envPtr2 + 152
				v8 = *(*uintptr)(unsafe.Pointer(v9))
				*(*uintptr)(unsafe.Pointer(v9))++
				*(*uint8)(unsafe.Pointer(v8)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v10 = delta1
					v11 = envPtr2
					if v10 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v11)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v11)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v11)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v11)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v11 + 64)) += int64(v10)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v13 = envPtr2 + 152
				v12 = *(*uintptr)(unsafe.Pointer(v13))
				*(*uintptr)(unsafe.Pointer(v13))++
				*(*uint8)(unsafe.Pointer(v12)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v15 = envPtr2 + 152
				v14 = *(*uintptr)(unsafe.Pointer(v15))
				*(*uintptr)(unsafe.Pointer(v15))++
				*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
				v17 = envPtr2 + 152
				v16 = *(*uintptr)(unsafe.Pointer(v17))
				*(*uintptr)(unsafe.Pointer(v17))++
				*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
				v19 = envPtr2 + 152
				v18 = *(*uintptr)(unsafe.Pointer(v19))
				*(*uintptr)(unsafe.Pointer(v19))++
				*(*uint8)(unsafe.Pointer(v18)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
				v21 = envPtr2 + 152
				v20 = *(*uintptr)(unsafe.Pointer(v21))
				*(*uintptr)(unsafe.Pointer(v21))++
				*(*uint8)(unsafe.Pointer(v20)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v22 = delta1
					v23 = envPtr2
					if v22 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v23)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v23)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v23)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v23)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v23 + 64)) += int64(v22)
				}
			}
			goto _4
		}
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).Fline = *(*TTcl_Size)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fline + uintptr(i1)*8))
		(*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext = *(*uintptr)(unsafe.Pointer((*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(mapPtr)).Floc + uintptr(eclIndex)*32))).Fnext + uintptr(i1)*8))
		if (*TTcl_Token)(unsafe.Pointer(tokPtr)).Ftype1 == int32(TCL_TOKEN_SIMPLE_WORD) {
			literal = XTclRegisterLiteral(tls, envPtr2, (*(*TTcl_Token)(unsafe.Pointer(tokPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokPtr + 1*32))).Fsize, 0)
			if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext != 0 {
				XTclContinuationsEnterDerived(tls, XTclFetchLiteral(tls, envPtr2, int64(literal)), int64((*(*TTcl_Token)(unsafe.Pointer(tokPtr + 1*32))).Fstart)-int64((*TCompileEnv)(unsafe.Pointer(envPtr2)).Fsource), (*TCompileEnv)(unsafe.Pointer(envPtr2)).FclNext)
			}
			_objIndexCopy1 = literal
			if _objIndexCopy1 <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v25 = envPtr2 + 152
				v24 = *(*uintptr)(unsafe.Pointer(v25))
				*(*uintptr)(unsafe.Pointer(v25))++
				*(*uint8)(unsafe.Pointer(v24)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v27 = envPtr2 + 152
				v26 = *(*uintptr)(unsafe.Pointer(v27))
				*(*uintptr)(unsafe.Pointer(v27))++
				*(*uint8)(unsafe.Pointer(v26)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v28 = delta1
					v29 = envPtr2
					if v28 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v29)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v29)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v29)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v29)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v29 + 64)) += int64(v28)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
					XTclExpandCodeArray(tls, envPtr2)
				}
				v31 = envPtr2 + 152
				v30 = *(*uintptr)(unsafe.Pointer(v31))
				*(*uintptr)(unsafe.Pointer(v31))++
				*(*uint8)(unsafe.Pointer(v30)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v33 = envPtr2 + 152
				v32 = *(*uintptr)(unsafe.Pointer(v33))
				*(*uintptr)(unsafe.Pointer(v33))++
				*(*uint8)(unsafe.Pointer(v32)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(24))
				v35 = envPtr2 + 152
				v34 = *(*uintptr)(unsafe.Pointer(v35))
				*(*uintptr)(unsafe.Pointer(v35))++
				*(*uint8)(unsafe.Pointer(v34)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(16))
				v37 = envPtr2 + 152
				v36 = *(*uintptr)(unsafe.Pointer(v37))
				*(*uintptr)(unsafe.Pointer(v37))++
				*(*uint8)(unsafe.Pointer(v36)) = uint8(libc.Uint32FromInt32(_objIndexCopy1) >> libc.Int32FromInt32(8))
				v39 = envPtr2 + 152
				v38 = *(*uintptr)(unsafe.Pointer(v39))
				*(*uintptr)(unsafe.Pointer(v39))++
				*(*uint8)(unsafe.Pointer(v38)) = uint8(libc.Uint32FromInt32(_objIndexCopy1))
				if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy1
					}
					v40 = delta1
					v41 = envPtr2
					if v40 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v41)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v41)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v41)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v41)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v41 + 64)) += int64(v40)
				}
			}
		} else {
			XTclCompileTokens(tls, interp, tokPtr+uintptr(1)*32, libc.Uint64FromInt64((*TTcl_Token)(unsafe.Pointer(tokPtr)).FnumComponents), envPtr2)
		}
		goto _4
	_4:
		;
		i1++
		tokPtr = tokPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokPtr)).FnumComponents+libc.Int64FromInt32(1))*32
	}
	/*
	 * Push the name of the command we're actually dispatching to as part of
	 * the implementation.
	 */
	if v42 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v42 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v42 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	XTcl_GetCommandFullName(tls, interp, cmdPtr, objPtr)
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
		v43 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		v43 = XTcl_GetStringFromObj(tls, objPtr, bp+16)
	}
	bytes = v43
	if cmdPtr != libc.UintptrFromInt32(0) && (*TCommand)(unsafe.Pointer(cmdPtr)).Fflags&int32(CMD_VIA_RESOLVER) != 0 {
		extraLiteralFlags |= int32(LITERAL_UNSHARED)
	}
	cmdLit = XTclRegisterLiteral(tls, envPtr2, bytes, *(*TTcl_Size)(unsafe.Pointer(bp + 16)), extraLiteralFlags)
	XTclSetCmdNameObj(tls, interp, XTclFetchLiteral(tls, envPtr2, int64(cmdLit)), cmdPtr)
	_objIndexCopy2 = cmdLit
	if _objIndexCopy2 <= int32(255) {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v45 = envPtr2 + 152
		v44 = *(*uintptr)(unsafe.Pointer(v45))
		*(*uintptr)(unsafe.Pointer(v45))++
		*(*uint8)(unsafe.Pointer(v44)) = libc.Uint8FromInt32(int32(INST_PUSH1))
		v47 = envPtr2 + 152
		v46 = *(*uintptr)(unsafe.Pointer(v47))
		*(*uintptr)(unsafe.Pointer(v47))++
		*(*uint8)(unsafe.Pointer(v46)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy2
			}
			v48 = delta1
			v49 = envPtr2
			if v48 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v49)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v49)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v49)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v49)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v49 + 64)) += int64(v48)
		}
	} else {
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(envPtr2)).FcodeEnd {
			XTclExpandCodeArray(tls, envPtr2)
		}
		v51 = envPtr2 + 152
		v50 = *(*uintptr)(unsafe.Pointer(v51))
		*(*uintptr)(unsafe.Pointer(v51))++
		*(*uint8)(unsafe.Pointer(v50)) = libc.Uint8FromInt32(int32(INST_PUSH4))
		v53 = envPtr2 + 152
		v52 = *(*uintptr)(unsafe.Pointer(v53))
		*(*uintptr)(unsafe.Pointer(v53))++
		*(*uint8)(unsafe.Pointer(v52)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(24))
		v55 = envPtr2 + 152
		v54 = *(*uintptr)(unsafe.Pointer(v55))
		*(*uintptr)(unsafe.Pointer(v55))++
		*(*uint8)(unsafe.Pointer(v54)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(16))
		v57 = envPtr2 + 152
		v56 = *(*uintptr)(unsafe.Pointer(v57))
		*(*uintptr)(unsafe.Pointer(v57))++
		*(*uint8)(unsafe.Pointer(v56)) = uint8(libc.Uint32FromInt32(_objIndexCopy2) >> libc.Int32FromInt32(8))
		v59 = envPtr2 + 152
		v58 = *(*uintptr)(unsafe.Pointer(v59))
		*(*uintptr)(unsafe.Pointer(v59))++
		*(*uint8)(unsafe.Pointer(v58)) = uint8(libc.Uint32FromInt32(_objIndexCopy2))
		if (*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(envPtr2)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - _objIndexCopy2
			}
			v60 = delta1
			v61 = envPtr2
			if v60 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v61)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v61)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v61)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v61)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v61 + 64)) += int64(v60)
		}
	}
	v63 = objPtr
	v62 = *(*TTcl_Size)(unsafe.Pointer(v63))
	*(*TTcl_Size)(unsafe.Pointer(v63))--
	if !(v62 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(-libc.Int32FromInt32(1))
			if v64 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v64 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v64 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, objPtr)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = objPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, objPtr)
		}
	}
	/*
	 * Do the replacing dispatch.
	 */
	XTclEmitInvoke(tls, envPtr2, int32(INST_INVOKE_REPLACE), libc.VaList(bp+32, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords, *(*TTcl_Size)(unsafe.Pointer(bp + 8))+int64(1)))
}

/*
 * Helpers that do issuing of instructions for commands that "don't have
 * compilers" (well, they do; these). They all work by just generating base
 * code to invoke the command; they're intended for ensemble subcommands so
 * that the costs of INST_INVOKE_REPLACE can be avoided where we can work out
 * that they're not needed.
 *
 * Note that these are NOT suitable for commands where there's an argument
 * that is a script, as an [info level] or [info frame] in the inner context
 * can see the difference.
 */

func _CompileBasicNArgCommand(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr uintptr) (r int32) {
	/* Holds resulting instructions. */
	var _objPtr, cachePtr, objPtr, v3 uintptr
	var v1 bool
	var v2 TTcl_Size
	_, _, _, _, _, _ = _objPtr, cachePtr, objPtr, v1, v2, v3
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount++
	XTcl_GetCommandFullName(tls, interp, cmdPtr, objPtr)
	XTclCompileInvocation(tls, interp, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr, objPtr, libc.Uint64FromInt64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords), envPtr)
	_objPtr = objPtr
	v3 = _objPtr
	v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
	*(*TTcl_Size)(unsafe.Pointer(v3))--
	if v2 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return TCL_OK
}

func XTclCompileBasic0ArgCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr uintptr) (r int32) {
	/* Holds resulting instructions. */
	/*
	 * Verify that the number of arguments is correct; that's the only case
	 * that we know will avoid the call to Tcl_WrongNumArgs() at invoke time,
	 * which is the only code that sees the shenanigans of ensemble dispatch.
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(1) {
		return int32(TCL_ERROR)
	}
	return _CompileBasicNArgCommand(tls, interp, parsePtr, cmdPtr, envPtr)
}

func XTclCompileBasic1ArgCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr uintptr) (r int32) {
	/* Holds resulting instructions. */
	/*
	 * Verify that the number of arguments is correct; that's the only case
	 * that we know will avoid the call to Tcl_WrongNumArgs() at invoke time,
	 * which is the only code that sees the shenanigans of ensemble dispatch.
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
		return int32(TCL_ERROR)
	}
	return _CompileBasicNArgCommand(tls, interp, parsePtr, cmdPtr, envPtr)
}

func XTclCompileBasic2ArgCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr uintptr) (r int32) {
	/* Holds resulting instructions. */
	/*
	 * Verify that the number of arguments is correct; that's the only case
	 * that we know will avoid the call to Tcl_WrongNumArgs() at invoke time,
	 * which is the only code that sees the shenanigans of ensemble dispatch.
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(3) {
		return int32(TCL_ERROR)
	}
	return _CompileBasicNArgCommand(tls, interp, parsePtr, cmdPtr, envPtr)
}

func XTclCompileBasic3ArgCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr uintptr) (r int32) {
	/* Holds resulting instructions. */
	/*
	 * Verify that the number of arguments is correct; that's the only case
	 * that we know will avoid the call to Tcl_WrongNumArgs() at invoke time,
	 * which is the only code that sees the shenanigans of ensemble dispatch.
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(4) {
		return int32(TCL_ERROR)
	}
	return _CompileBasicNArgCommand(tls, interp, parsePtr, cmdPtr, envPtr)
}

func XTclCompileBasic0Or1ArgCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr uintptr) (r int32) {
	/* Holds resulting instructions. */
	/*
	 * Verify that the number of arguments is correct; that's the only case
	 * that we know will avoid the call to Tcl_WrongNumArgs() at invoke time,
	 * which is the only code that sees the shenanigans of ensemble dispatch.
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(1) && (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) {
		return int32(TCL_ERROR)
	}
	return _CompileBasicNArgCommand(tls, interp, parsePtr, cmdPtr, envPtr)
}

func XTclCompileBasic1Or2ArgCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr uintptr) (r int32) {
	/* Holds resulting instructions. */
	/*
	 * Verify that the number of arguments is correct; that's the only case
	 * that we know will avoid the call to Tcl_WrongNumArgs() at invoke time,
	 * which is the only code that sees the shenanigans of ensemble dispatch.
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(2) && (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(3) {
		return int32(TCL_ERROR)
	}
	return _CompileBasicNArgCommand(tls, interp, parsePtr, cmdPtr, envPtr)
}

func XTclCompileBasic2Or3ArgCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr uintptr) (r int32) {
	/* Holds resulting instructions. */
	/*
	 * Verify that the number of arguments is correct; that's the only case
	 * that we know will avoid the call to Tcl_WrongNumArgs() at invoke time,
	 * which is the only code that sees the shenanigans of ensemble dispatch.
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(3) && (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords != int64(4) {
		return int32(TCL_ERROR)
	}
	return _CompileBasicNArgCommand(tls, interp, parsePtr, cmdPtr, envPtr)
}

func XTclCompileBasic0To2ArgCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr uintptr) (r int32) {
	/* Holds resulting instructions. */
	/*
	 * Verify that the number of arguments is correct; that's the only case
	 * that we know will avoid the call to Tcl_WrongNumArgs() at invoke time,
	 * which is the only code that sees the shenanigans of ensemble dispatch.
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords < int64(1) || (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords > int64(3) {
		return int32(TCL_ERROR)
	}
	return _CompileBasicNArgCommand(tls, interp, parsePtr, cmdPtr, envPtr)
}

func XTclCompileBasic1To3ArgCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr uintptr) (r int32) {
	/* Holds resulting instructions. */
	/*
	 * Verify that the number of arguments is correct; that's the only case
	 * that we know will avoid the call to Tcl_WrongNumArgs() at invoke time,
	 * which is the only code that sees the shenanigans of ensemble dispatch.
	 */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords < int64(2) || (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords > int64(4) {
		return int32(TCL_ERROR)
	}
	return _CompileBasicNArgCommand(tls, interp, parsePtr, cmdPtr, envPtr)
}

func XTclCompileBasicMin0ArgCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr uintptr) (r int32) {
	/* Holds resulting instructions. */
	/*
	 * Verify that the number of arguments is correct; that's the only case
	 * that we know will avoid the call to Tcl_WrongNumArgs() at invoke time,
	 * which is the only code that sees the shenanigans of ensemble dispatch.
	 */
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) < int32(1) {
		return int32(TCL_ERROR)
	}
	return _CompileBasicNArgCommand(tls, interp, parsePtr, cmdPtr, envPtr)
}

func XTclCompileBasicMin1ArgCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr uintptr) (r int32) {
	/* Holds resulting instructions. */
	/*
	 * Verify that the number of arguments is correct; that's the only case
	 * that we know will avoid the call to Tcl_WrongNumArgs() at invoke time,
	 * which is the only code that sees the shenanigans of ensemble dispatch.
	 */
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) < int32(2) {
		return int32(TCL_ERROR)
	}
	return _CompileBasicNArgCommand(tls, interp, parsePtr, cmdPtr, envPtr)
}

func XTclCompileBasicMin2ArgCmd(tls *libc.TLS, interp uintptr, parsePtr uintptr, cmdPtr uintptr, envPtr uintptr) (r int32) {
	/* Holds resulting instructions. */
	/*
	 * Verify that the number of arguments is correct; that's the only case
	 * that we know will avoid the call to Tcl_WrongNumArgs() at invoke time,
	 * which is the only code that sees the shenanigans of ensemble dispatch.
	 */
	if int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords) < int32(3) {
		return int32(TCL_ERROR)
	}
	return _CompileBasicNArgCommand(tls, interp, parsePtr, cmdPtr, envPtr)
}

const tNTL = 0
const techar = 0
const tenviron = 0

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */
var _envMutex TTcl_Mutex /* To serialize access to environ. */

var _env struct {
	FcacheSize      TTcl_Size
	Fcache          uintptr
	FourEnviron     uintptr
	FourEnvironSize TTcl_Size
}

/*
 *----------------------------------------------------------------------
 *
 * TclSetupEnv --
 *
 *	This function is invoked for an interpreter to make environment
 *	variables accessible from that interpreter via the "env" associative
 *	array.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The interpreter is added to a list of interpreters managed by us, so
 *	that its view of envariables can be kept consistent with the view in
 *	other interpreters. If this is the first call to TclSetupEnv, then
 *	additional initialization happens, such as copying the environment to
 *	dynamically-allocated space for ease of management.
 *
 *----------------------------------------------------------------------
 */

func XTclSetupEnv(tls *libc.TLS, interp uintptr) {
	bp := tls.Alloc(368)
	defer tls.Free(368) /* Interpreter whose "env" array is to be
	 * managed. */
	var _objPtr, _objPtr1, _objPtr2, cachePtr, elemName, hPtr, obj1, obj2, p1, p2, varNamePtr, varPtr, v4, v6, v9 uintptr
	var i int32
	var v1 bool
	var v3, v5, v8 TTcl_Size
	var _ /* arrayPtr at bp+0 */ uintptr
	var _ /* envString at bp+8 */ TTcl_DString
	var _ /* namesHash at bp+232 */ TTcl_HashTable
	var _ /* search at bp+336 */ TTcl_HashSearch
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, cachePtr, elemName, hPtr, i, obj1, obj2, p1, p2, varNamePtr, varPtr, v1, v3, v4, v5, v6, v8, v9
	/*
	 * Synchronize the values in the environ array with the contents of the
	 * Tcl "env" variable. To do this:
	 *    1) Remove the trace that fires when the "env" var is updated.
	 *    2) Find the existing contents of the "env", storing in a hash table.
	 *    3) Create/update elements for each environ variable, removing
	 *	     elements from the hash table as we go.
	 *    4) Remove the elements for each remaining entry in the hash table,
	 *	     which must have existed before yet have no analog in the environ
	 *	     variable.
	 *    5) Add a trace that synchronizes the "env" array.
	 */
	XTcl_UntraceVar2(tls, interp, __ccgo_ts+30620, libc.UintptrFromInt32(0), libc.Int32FromInt32(TCL_GLOBAL_ONLY)|libc.Int32FromInt32(TCL_TRACE_WRITES)|libc.Int32FromInt32(TCL_TRACE_UNSETS)|libc.Int32FromInt32(TCL_TRACE_READS)|libc.Int32FromInt32(TCL_TRACE_ARRAY), __ccgo_fp(_EnvTraceProc), libc.UintptrFromInt32(0))
	/*
	 * Find out what elements are currently in the global env array.
	 */
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		varNamePtr = XTclThreadAllocObj(tls)
	} else {
		varNamePtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(varNamePtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(varNamePtr)).FrefCount = 0
	if libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(varNamePtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(varNamePtr)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(varNamePtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(varNamePtr)).Fbytes, __ccgo_ts+30620, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(varNamePtr)).Fbytes + uintptr(libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(varNamePtr)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(4) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(varNamePtr)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(varNamePtr)).FrefCount++
	XTcl_InitObjHashTable(tls, bp+232)
	varPtr = XTclObjLookupVarEx(tls, interp, varNamePtr, libc.UintptrFromInt32(0), int32(TCL_GLOBAL_ONLY), uintptr(0), 0, 0, bp)
	XTclFindArrayPtrElements(tls, varPtr, bp+232)
	/*
	 * Go through the environment array and transfer its values into Tcl. At
	 * the same time, remove those elements we add/update from the hash table
	 * of existing elements, so that after this part processes, that table
	 * will hold just the parts to remove.
	 */
	if *(*uintptr)(unsafe.Pointer(libc.Xenviron)) != libc.UintptrFromInt32(0) {
		XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_envMutex)))
		i = 0
		for {
			if !(*(*uintptr)(unsafe.Pointer(libc.Xenviron + uintptr(i)*8)) != libc.UintptrFromInt32(0)) {
				break
			}
			p1 = XTcl_ExternalToUtfDString(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(libc.Xenviron + uintptr(i)*8)), int64(-int32(1)), bp+8)
			if p1 == libc.UintptrFromInt32(0) {
				/* Ignore what cannot be decoded (should not happen) */
				goto _2
			}
			p2 = libc.Xstrchr(tls, p1, int32('='))
			if p2 == libc.UintptrFromInt32(0) {
				/*
				 * This condition seem to happen occasionally under some
				 * versions of Solaris, or when encoding accidents swallow the
				 * '='; ignore the entry.
				 */
				XTcl_DStringFree(tls, bp+8)
				goto _2
			}
			p2++
			*(*uint8)(unsafe.Pointer(p2 + uintptr(-libc.Int32FromInt32(1)))) = uint8('\000')
			obj1 = XTcl_NewStringObj(tls, p1, int64(-int32(1)))
			obj2 = XTcl_NewStringObj(tls, p2, int64(-int32(1)))
			XTcl_DStringFree(tls, bp+8)
			(*TTcl_Obj)(unsafe.Pointer(obj1)).FrefCount++
			(*TTcl_Obj)(unsafe.Pointer(obj2)).FrefCount++
			XTcl_ObjSetVar2(tls, interp, varNamePtr, obj1, obj2, int32(TCL_GLOBAL_ONLY))
			hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(bp + 232)).FfindProc})))(tls, bp+232, obj1)
			if hPtr != libc.UintptrFromInt32(0) {
				XTcl_DeleteHashEntry(tls, hPtr)
			}
			_objPtr = obj1
			v4 = _objPtr
			v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
			*(*TTcl_Size)(unsafe.Pointer(v4))--
			if v3 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			_objPtr1 = obj2
			v6 = _objPtr1
			v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
			*(*TTcl_Size)(unsafe.Pointer(v6))--
			if v5 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
			goto _2
		_2:
			;
			i++
		}
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_envMutex)))
	}
	/*
	 * Delete those elements that existed in the array but which had no
	 * counterparts in the environment array.
	 */
	hPtr = XTcl_FirstHashEntry(tls, bp+232, bp+336)
	for {
		if !(hPtr != libc.UintptrFromInt32(0)) {
			break
		}
		elemName = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		XTclObjUnsetVar2(tls, interp, varNamePtr, elemName, int32(TCL_GLOBAL_ONLY))
		goto _7
	_7:
		;
		hPtr = XTcl_NextHashEntry(tls, bp+336)
	}
	XTcl_DeleteHashTable(tls, bp+232)
	_objPtr2 = varNamePtr
	v9 = _objPtr2
	v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
	*(*TTcl_Size)(unsafe.Pointer(v9))--
	if v8 <= int64(1) {
		XTclFreeObj(tls, _objPtr2)
	}
	/*
	 * Re-establish the trace.
	 */
	XTcl_TraceVar2(tls, interp, __ccgo_ts+30620, libc.UintptrFromInt32(0), libc.Int32FromInt32(TCL_GLOBAL_ONLY)|libc.Int32FromInt32(TCL_TRACE_WRITES)|libc.Int32FromInt32(TCL_TRACE_UNSETS)|libc.Int32FromInt32(TCL_TRACE_READS)|libc.Int32FromInt32(TCL_TRACE_ARRAY), __ccgo_fp(_EnvTraceProc), libc.UintptrFromInt32(0))
}

/*
 *----------------------------------------------------------------------
 *
 * TclSetEnv --
 *
 *	Set an environment variable, replacing an existing value or creating a
 *	new variable if there doesn't exist a variable by the given name. This
 *	function is intended to be a stand-in for the UNIX "setenv" function
 *	so that applications using that function will interface properly to
 *	Tcl. To make it a stand-in, the Makefile must define "TclSetEnv" to
 *	"setenv".
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The environ array gets updated.
 *
 *----------------------------------------------------------------------
 */

func XTclSetEnv(tls *libc.TLS, name uintptr, value uintptr) {
	bp := tls.Alloc(240)
	defer tls.Free(240) /* New value for variable (UTF-8). */
	var index, nameLength, valueLength TTcl_Size
	var newEnviron, oldEnv, oldValue, p, p2, v1 uintptr
	var _ /* envString at bp+0 */ TTcl_DString
	var _ /* length at bp+224 */ TTcl_Size
	_, _, _, _, _, _, _, _, _ = index, nameLength, newEnviron, oldEnv, oldValue, p, p2, valueLength, v1
	/*
	 * Figure out where the entry is going to go. If the name doesn't already
	 * exist, enlarge the array if necessary to make room. If the name exists,
	 * free its old entry.
	 */
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_envMutex)))
	index = XTclpFindVariable(tls, name, bp+224)
	if index == int64(-libc.Int32FromInt32(1)) {
		/*
		 * We need to handle the case where the environment may be changed
		 * outside our control. ourEnvironSize is only valid if the current
		 * environment is the one we allocated. [Bug 979640]
		 */
		if _env.FourEnviron != libc.Xenviron || *(*TTcl_Size)(unsafe.Pointer(bp + 224))+int64(2) > _env.FourEnvironSize {
			newEnviron = XTcl_Alloc(tls, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 224))+libc.Int64FromInt32(5))*uint64(8))
			libc.Xmemcpy(tls, newEnviron, libc.Xenviron, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 224)))*uint64(8))
			if _env.FourEnvironSize != 0 && _env.FourEnviron != libc.UintptrFromInt32(0) {
				XTclpFree(tls, _env.FourEnviron)
			}
			v1 = newEnviron
			_env.FourEnviron = v1
			libc.Xenviron = v1
			_env.FourEnvironSize = *(*TTcl_Size)(unsafe.Pointer(bp + 224)) + int64(5)
		}
		index = *(*TTcl_Size)(unsafe.Pointer(bp + 224))
		*(*uintptr)(unsafe.Pointer(libc.Xenviron + uintptr(index+int64(1))*8)) = libc.UintptrFromInt32(0)
		oldValue = libc.UintptrFromInt32(0)
		nameLength = libc.Int64FromUint64(libc.Xstrlen(tls, name))
	} else {
		/*
		 * Compare the new value to the existing value. If they're the same
		 * then quit immediately (e.g. don't rewrite the value or propagate it
		 * to other interpreters). Otherwise, when there are N interpreters
		 * there will be N! propagations of the same value among the
		 * interpreters.
		 */
		oldEnv = XTcl_ExternalToUtfDString(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(libc.Xenviron + uintptr(index)*8)), int64(-int32(1)), bp)
		if oldEnv == libc.UintptrFromInt32(0) || libc.Xstrcmp(tls, value, oldEnv+uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 224))+libc.Int64FromInt32(1))) == 0 {
			XTcl_DStringFree(tls, bp) /* OK even if oldEnv is NULL */
			XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_envMutex)))
			return
		}
		XTcl_DStringFree(tls, bp)
		oldValue = *(*uintptr)(unsafe.Pointer(libc.Xenviron + uintptr(index)*8))
		nameLength = *(*TTcl_Size)(unsafe.Pointer(bp + 224))
	}
	/*
	 * Create a new entry. Build a complete UTF string that contains a
	 * "name=value" pattern. Then convert the string to the native encoding,
	 * and set the environ array value.
	 */
	valueLength = libc.Int64FromUint64(libc.Xstrlen(tls, value))
	p = XTcl_Alloc(tls, libc.Uint64FromInt64(nameLength+valueLength+int64(2)))
	libc.Xmemcpy(tls, p, name, libc.Uint64FromInt64(nameLength))
	*(*uint8)(unsafe.Pointer(p + uintptr(nameLength))) = uint8('=')
	libc.Xmemcpy(tls, p+uintptr(nameLength)+uintptr(1), value, libc.Uint64FromInt64(valueLength+int64(1)))
	p2 = XTcl_UtfToExternalDString(tls, libc.UintptrFromInt32(0), p, int64(-int32(1)), bp)
	if p2 == libc.UintptrFromInt32(0) {
		/* No way to signal error from here :-( but should not happen */
		XTclpFree(tls, p)
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_envMutex)))
		return
	}
	/*
	 * Copy the native string to heap memory.
	 */
	p = XTcl_Realloc(tls, p, libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(bp)).Flength)+uint64(1))
	libc.Xmemcpy(tls, p, p2, libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(bp)).Flength)+uint64(1))
	XTcl_DStringFree(tls, bp)
	*(*uintptr)(unsafe.Pointer(libc.Xenviron + uintptr(index)*8)) = p
	/*
	 * Watch out for versions of putenv that copy the string (e.g. VC++). In
	 * this case we need to free the string immediately. Otherwise update the
	 * string in the cache.
	 */
	if index != int64(-libc.Int32FromInt32(1)) && *(*uintptr)(unsafe.Pointer(libc.Xenviron + uintptr(index)*8)) == p {
		_ReplaceString(tls, oldValue, p)
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_envMutex)))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_PutEnv --
 *
 *	Set an environment variable. Similar to setenv except that the
 *	information is passed in a single string of the form NAME=value,
 *	rather than as separate name strings. This function is intended to be
 *	a stand-in for the UNIX "putenv" function so that applications using
 *	that function will interface properly to Tcl. To make it a stand-in,
 *	the Makefile will define "Tcl_PutEnv" to "putenv".
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The environ array gets updated, as do all of the interpreters that we
 *	manage.
 *
 *----------------------------------------------------------------------
 */

func XTcl_PutEnv(tls *libc.TLS, assignment uintptr) (r int32) {
	bp := tls.Alloc(224)
	defer tls.Free(224) /* Info about environment variable in the form
	 * NAME=value. (native) */
	var name, value uintptr
	var _ /* nameString at bp+0 */ TTcl_DString
	_, _ = name, value
	if assignment == libc.UintptrFromInt32(0) {
		return 0
	}
	/*
	 * First convert the native string to Utf. Then separate the string into
	 * name and value parts, and call TclSetEnv to do all of the real work.
	 */
	name = XTcl_ExternalToUtfDString(tls, libc.UintptrFromInt32(0), assignment, int64(-libc.Int32FromInt32(1)), bp)
	value = libc.Xstrchr(tls, name, int32('='))
	if value != libc.UintptrFromInt32(0) && value != name {
		*(*uint8)(unsafe.Pointer(value)) = uint8('\000')
		XTclSetEnv(tls, name, value+uintptr(1))
	}
	XTclEnvEpoch++
	XTcl_DStringFree(tls, bp)
	return 0
}

/*
 *----------------------------------------------------------------------
 *
 * TclUnsetEnv --
 *
 *	Remove an environment variable, updating the "env" arrays in all
 *	interpreters managed by us. This function is intended to replace the
 *	UNIX "unsetenv" function (but to do this the Makefile must be modified
 *	to redefine "TclUnsetEnv" to "unsetenv".
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Interpreters are updated, as is environ.
 *
 *----------------------------------------------------------------------
 */

func XTclUnsetEnv(tls *libc.TLS, name uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Name of variable to remove (UTF-8). */
	var envPtr, oldValue uintptr
	var index TTcl_Size
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _ = envPtr, index, oldValue
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_envMutex)))
	index = XTclpFindVariable(tls, name, bp)
	/*
	 * First make sure that the environment variable exists to avoid doing
	 * needless work and to avoid recursion on the unset.
	 */
	if index == int64(-int32(1)) {
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_envMutex)))
		return
	}
	/*
	 * Remember the old value so we can free it if Tcl created the string.
	 */
	oldValue = *(*uintptr)(unsafe.Pointer(libc.Xenviron + uintptr(index)*8))
	/*
	 * Update the system environment. This must be done before we update the
	 * interpreters or we will recurse.
	 */
	envPtr = libc.Xenviron + uintptr(index)*8 + libc.UintptrFromInt32(1)*8
	for {
		*(*uintptr)(unsafe.Pointer(envPtr + uintptr(-libc.Int32FromInt32(1))*8)) = *(*uintptr)(unsafe.Pointer(envPtr))
		if *(*uintptr)(unsafe.Pointer(envPtr)) == libc.UintptrFromInt32(0) {
			break
		}
		goto _1
	_1:
		;
		envPtr += 8
	}
	_ReplaceString(tls, oldValue, libc.UintptrFromInt32(0))
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_envMutex)))
}

/*
 *---------------------------------------------------------------------------
 *
 * TclGetEnv --
 *
 *	Retrieve the value of an environment variable.
 *
 * Results:
 *	The result is a pointer to a string specifying the value of the
 *	environment variable, or NULL if that environment variable does not
 *	exist. Storage for the result string is allocated in valuePtr; the
 *	caller must call Tcl_DStringFree() when the result is no longer
 *	needed.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclGetEnv(tls *libc.TLS, name uintptr, valuePtr uintptr) (r uintptr) {
	bp := tls.Alloc(240)
	defer tls.Free(240) /* Uninitialized or free DString in which the
	 * value of the environment variable is
	 * stored. */
	var index TTcl_Size
	var result uintptr
	var _ /* envStr at bp+8 */ TTcl_DString
	var _ /* length at bp+0 */ TTcl_Size
	_, _ = index, result
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_envMutex)))
	index = XTclpFindVariable(tls, name, bp)
	result = libc.UintptrFromInt32(0)
	if index != int64(-int32(1)) {
		result = XTcl_ExternalToUtfDString(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(libc.Xenviron + uintptr(index)*8)), int64(-int32(1)), bp+8)
		if result != 0 {
			result += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(result))) == int32('=') {
				result++
				XTcl_DStringInit(tls, valuePtr)
				XTcl_DStringAppend(tls, valuePtr, result, int64(-int32(1)))
				result = (*TTcl_DString)(unsafe.Pointer(valuePtr)).Fstring1
			} else {
				result = libc.UintptrFromInt32(0)
			}
			XTcl_DStringFree(tls, bp+8)
		}
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_envMutex)))
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * EnvTraceProc --
 *
 *	This function is invoked whenever an environment variable is read,
 *	modified or deleted. It propagates the change to the global "environ"
 *	array.
 *
 * Results:
 *	Returns NULL to indicate success, or an error-message if the array
 *	element being handled doesn't exist.
 *
 * Side effects:
 *	Environment variable changes get propagated. If the whole "env" array
 *	is deleted, then we stop managing things for this interpreter (usually
 *	this happens because the whole interpreter is being deleted).
 *
 *----------------------------------------------------------------------
 */

func _EnvTraceProc(tls *libc.TLS, dummy634 uintptr, interp uintptr, name1 uintptr, name2 uintptr, flags int32) (r uintptr) {
	bp := tls.Alloc(448)
	defer tls.Free(448) /* Indicates what's happening. */
	var value, value1 uintptr
	var _ /* ds at bp+0 */ TTcl_DString
	var _ /* valueString at bp+224 */ TTcl_DString
	_, _ = value, value1
	/*
	 * For array traces, let TclSetupEnv do all the work.
	 */
	if flags&int32(TCL_TRACE_ARRAY) != 0 {
		XTclSetupEnv(tls, interp)
		XTclEnvEpoch++
		return libc.UintptrFromInt32(0)
	}
	/*
	 * If name2 is NULL, then return and do nothing.
	 */
	if name2 == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	/*
	 * If a value is being set, call TclSetEnv to do all of the work.
	 */
	if flags&int32(TCL_TRACE_WRITES) != 0 {
		value = XTcl_GetVar2(tls, interp, __ccgo_ts+30620, name2, int32(TCL_GLOBAL_ONLY))
		XTcl_DStringInit(tls, bp)
		if XTcl_UtfToExternalDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), name2, int64(-int32(1)), 0, bp, libc.UintptrFromInt32(0)) != TCL_OK {
			XTcl_DStringFree(tls, bp)
			return __ccgo_ts + 30624
		}
		if XTcl_UtfToExternalDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), value, int64(-int32(1)), 0, bp, libc.UintptrFromInt32(0)) != TCL_OK {
			XTcl_DStringFree(tls, bp)
			return __ccgo_ts + 30624
		}
		XTcl_DStringFree(tls, bp)
		XTclSetEnv(tls, name2, value)
		XTclEnvEpoch++
	}
	/*
	 * If a value is being read, call TclGetEnv to do all of the work.
	 */
	if flags&int32(TCL_TRACE_READS) != 0 {
		value1 = XTclGetEnv(tls, name2, bp+224)
		if value1 == libc.UintptrFromInt32(0) {
			return __ccgo_ts + 30639
		}
		XTcl_SetVar2(tls, interp, name1, name2, value1, 0)
		XTcl_DStringFree(tls, bp+224)
	}
	/*
	 * For unset traces, let TclUnsetEnv do all the work.
	 */
	if flags&int32(TCL_TRACE_UNSETS) != 0 {
		XTclUnsetEnv(tls, name2)
		XTclEnvEpoch++
	}
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * ReplaceString --
 *
 *	Replace one string with another in the environment variable cache. The
 *	cache keeps track of all of the environment variables that Tcl has
 *	modified so they can be freed later.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	May free the old string.
 *
 *----------------------------------------------------------------------
 */

func _ReplaceString(tls *libc.TLS, oldStr uintptr, newStr uintptr) {
	/* New environment string. */
	var growth int32
	var i TTcl_Size
	_, _ = growth, i
	/*
	 * Check to see if the old value was allocated by Tcl. If so, it needs to
	 * be deallocated to avoid memory leaks. Note that this algorithm is O(n),
	 * not O(1). This will result in n-squared behavior if lots of environment
	 * changes are being made.
	 */
	i = 0
	for {
		if !(i < _env.FcacheSize) {
			break
		}
		if *(*uintptr)(unsafe.Pointer(_env.Fcache + uintptr(i)*8)) == oldStr || *(*uintptr)(unsafe.Pointer(_env.Fcache + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			break
		}
		goto _1
	_1:
		;
		i++
	}
	if i < _env.FcacheSize {
		/*
		 * Replace or delete the old value.
		 */
		if *(*uintptr)(unsafe.Pointer(_env.Fcache + uintptr(i)*8)) != 0 {
			XTclpFree(tls, *(*uintptr)(unsafe.Pointer(_env.Fcache + uintptr(i)*8)))
		}
		if newStr != 0 {
			*(*uintptr)(unsafe.Pointer(_env.Fcache + uintptr(i)*8)) = newStr
		} else {
			for {
				if !(i < _env.FcacheSize-int64(1)) {
					break
				}
				*(*uintptr)(unsafe.Pointer(_env.Fcache + uintptr(i)*8)) = *(*uintptr)(unsafe.Pointer(_env.Fcache + uintptr(i+int64(1))*8))
				goto _2
			_2:
				;
				i++
			}
			*(*uintptr)(unsafe.Pointer(_env.Fcache + uintptr(_env.FcacheSize-int64(1))*8)) = libc.UintptrFromInt32(0)
		}
	} else {
		/*
		 * We need to grow the cache in order to hold the new string.
		 */
		growth = int32(5)
		_env.Fcache = XTcl_Realloc(tls, _env.Fcache, libc.Uint64FromInt64(_env.FcacheSize+int64(growth))*uint64(8))
		*(*uintptr)(unsafe.Pointer(_env.Fcache + uintptr(_env.FcacheSize)*8)) = newStr
		libc.Xmemset(tls, _env.Fcache+uintptr(_env.FcacheSize)*8+uintptr(1)*8, 0, libc.Uint64FromInt32(growth-libc.Int32FromInt32(1))*uint64(8))
		_env.FcacheSize += int64(growth)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclFinalizeEnvironment --
 *
 *	This function releases any storage allocated by this module that isn't
 *	still in use by the global environment. Any strings that are still in
 *	the environment will be leaked.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	May deallocate storage.
 *
 *----------------------------------------------------------------------
 */

func XTclFinalizeEnvironment(tls *libc.TLS) {
	/*
	 * For now we just deallocate the cache array and none of the environment
	 * strings. This may leak more memory that strictly necessary, since some
	 * of the strings may no longer be in the environment. However,
	 * determining which ones are ok to delete is n-squared, and is pretty
	 * unlikely, so we don't bother.  However, in the case of DPURIFY, just
	 * free all strings in the cache.
	 */
	if _env.Fcache != 0 {
		XTclpFree(tls, _env.Fcache)
		_env.Fcache = libc.UintptrFromInt32(0)
		_env.FcacheSize = 0
		if _env.FourEnviron != libc.UintptrFromInt32(0) {
			XTclpFree(tls, _env.FourEnviron)
			_env.FourEnviron = libc.UintptrFromInt32(0)
		}
		_env.FourEnvironSize = 0
	}
}

const TCL_PATCH_LEVEL1 = "9.0.1+10a450bde9d304cbb6a4c2fa54ceaeea7de025dae402aff4c2884a2cce2ce595.gcc-1002.static.tommath-0103"
const TCL_VERSION_UUID = 0

/* Epoch of the tcl environment
 * (if changed with tcl-env). */

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * The data structure below is used to report background errors. One such
 * structure is allocated for each error; it holds information about the
 * interpreter and the error until an idle handler command can be invoked.
 */

type TBgError = struct {
	FerrorMsg   uintptr
	FreturnOpts uintptr
	FnextPtr    uintptr
}

/*
 * One of the structures below is associated with the "tclBgError" assoc data
 * for each interpreter. It keeps track of the head and tail of the list of
 * pending background errors for the interpreter.
 */

type TErrAssocData = struct {
	Finterp     uintptr
	FcmdPrefix  uintptr
	FfirstBgPtr uintptr
	FlastBgPtr  uintptr
}

/*
 * For each "vwait" event source a structure of the following type
 * is used:
 */

type TVwaitItem = struct {
	FdonePtr   uintptr
	Fsequence  int32
	Fmask      int32
	FsourceObj uintptr
}

/*
 * For each exit handler created with a call to Tcl_Create(Late)ExitHandler
 * there is a structure of the following type:
 */

type TExitHandler = struct {
	Fproc       uintptr
	FclientData uintptr
	FnextPtr    uintptr
}

/*
 * There is both per-process and per-thread exit handlers. The first list is
 * controlled by a mutex. The other is in thread local storage.
 */

var _firstExitPtr = libc.UintptrFromInt32(0)

// C documentation
//
//	/* First in list of all exit handlers for
//					 * application. */
var _firstLateExitPtr = libc.UintptrFromInt32(0)

// C documentation
//
//	/* First in list of all late exit handlers for
//					 * application. */
var _exitMutex TTcl_Mutex

/*
 * This variable is set to 1 when Tcl_Exit is called. The variable is checked
 * by TclInExit() to allow different behavior for exit-time processing, e.g.,
 * in closing of files and pipes.
 */

var _inExit = int32(0)

var _subsystemsInitialized = int32(0)

var _ENCODING_ERROR = [29]uint8{10, 9, '(', 'e', 'n', 'c', 'o', 'd', 'i', 'n', 'g', ' ', 'e', 'r', 'r', 'o', 'r', ' ', 'i', 'n', ' ', 's', 't', 'd', 'e', 'r', 'r', ')'}

/*
 * This variable contains the application wide exit handler. It will be called
 * by Tcl_Exit instead of the C-runtime exit if this variable is set to a
 * non-NULL value.
 */

var _appExitPtr = uintptr(0)

func init() {
	p := unsafe.Pointer(&_appExitPtr)
	*(*uintptr)(unsafe.Add(p, 0)) = libc.UintptrFromInt32(0)
}

type TThreadSpecificData2 = struct {
	FfirstExitPtr uintptr
	FinExit       int32
}

var _dataKey1 TTcl_ThreadDataKey

type TThreadClientData = struct {
	Fproc       uintptr
	FclientData uintptr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_BackgroundException --
 *
 *	This function is invoked to handle errors that occur in Tcl commands
 *	that are invoked in "background" (e.g. from event or timer bindings).
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	A handler command is invoked later as an idle handler to process the
 *	error, passing it the interp result and return options.
 *
 *----------------------------------------------------------------------
 */

func XTcl_BackgroundException(tls *libc.TLS, interp uintptr, code int32) {
	/* The exception code value */
	var assocPtr, errPtr uintptr
	_, _ = assocPtr, errPtr
	if code == TCL_OK {
		return
	}
	errPtr = XTcl_Alloc(tls, uint64(24))
	(*TBgError)(unsafe.Pointer(errPtr)).FerrorMsg = XTcl_GetObjResult(tls, interp)
	(*TTcl_Obj)(unsafe.Pointer((*TBgError)(unsafe.Pointer(errPtr)).FerrorMsg)).FrefCount++
	(*TBgError)(unsafe.Pointer(errPtr)).FreturnOpts = XTcl_GetReturnOptions(tls, interp, code)
	(*TTcl_Obj)(unsafe.Pointer((*TBgError)(unsafe.Pointer(errPtr)).FreturnOpts)).FrefCount++
	(*TBgError)(unsafe.Pointer(errPtr)).FnextPtr = libc.UintptrFromInt32(0)
	XTclGetBgErrorHandler(tls, interp)
	assocPtr = XTcl_GetAssocData(tls, interp, __ccgo_ts+30656, libc.UintptrFromInt32(0))
	if (*TErrAssocData)(unsafe.Pointer(assocPtr)).FfirstBgPtr == libc.UintptrFromInt32(0) {
		(*TErrAssocData)(unsafe.Pointer(assocPtr)).FfirstBgPtr = errPtr
		XTcl_DoWhenIdle(tls, __ccgo_fp(_HandleBgErrors), assocPtr)
	} else {
		(*TBgError)(unsafe.Pointer((*TErrAssocData)(unsafe.Pointer(assocPtr)).FlastBgPtr)).FnextPtr = errPtr
	}
	(*TErrAssocData)(unsafe.Pointer(assocPtr)).FlastBgPtr = errPtr
	XTcl_ResetResult(tls, interp)
}

/*
 *----------------------------------------------------------------------
 *
 * HandleBgErrors --
 *
 *	This function is invoked as an idle handler to process all of the
 *	accumulated background errors.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Depends on what actions the handler command takes for the errors.
 *
 *----------------------------------------------------------------------
 */

func _HandleBgErrors(tls *libc.TLS, clientData uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Pointer to ErrAssocData structure. */
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, assocPtr, copyObj, errPtr, interp, options, tempObjv, v11, v13, v15, v5, v7, v9 uintptr
	var code int32
	var errChannel TTcl_Channel
	var v10, v12, v14, v4, v6, v8 TTcl_Size
	var v2, v3 int64
	var _ /* prefixObjc at bp+0 */ TTcl_Size
	var _ /* prefixObjv at bp+8 */ uintptr
	var _ /* valuePtr at bp+16 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, assocPtr, code, copyObj, errChannel, errPtr, interp, options, tempObjv, v10, v11, v12, v13, v14, v15, v2, v3, v4, v5, v6, v7, v8, v9
	assocPtr = clientData
	interp = (*TErrAssocData)(unsafe.Pointer(assocPtr)).Finterp
	/*
	 * Not bothering to save/restore the interp state. Assume that any code
	 * that has interp state it needs to keep will make its own
	 * Tcl_SaveInterpState call before calling something like Tcl_DoOneEvent()
	 * that could lead us here.
	 */
	XTcl_Preserve(tls, assocPtr)
	XTcl_Preserve(tls, interp)
	for (*TErrAssocData)(unsafe.Pointer(assocPtr)).FfirstBgPtr != libc.UintptrFromInt32(0) {
		/*
		 * Note we copy the handler command prefix each pass through, so we do
		 * support one handler setting another handler.
		 */
		copyObj = XTclListObjCopy(tls, libc.UintptrFromInt32(0), (*TErrAssocData)(unsafe.Pointer(assocPtr)).FcmdPrefix)
		errPtr = (*TErrAssocData)(unsafe.Pointer(assocPtr)).FfirstBgPtr
		if (*TTcl_Obj)(unsafe.Pointer(copyObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(copyObj + 32))).Fptr2 != 0 {
				v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(copyObj + 32))).Fptr2)).FspanStart
			} else {
				v2 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(copyObj + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(copyObj + 32))).Fptr1 + 40 + uintptr(v2)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(copyObj + 32))).Fptr2 != 0 {
				v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(copyObj + 32))).Fptr2)).FspanLength
			} else {
				v3 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(copyObj + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp)) = v3
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), copyObj, bp, bp+8)
		}
		tempObjv = XTcl_Alloc(tls, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))+libc.Int64FromInt32(2))*uint64(8))
		libc.Xmemcpy(tls, tempObjv, *(*uintptr)(unsafe.Pointer(bp + 8)), libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))*uint64(8))
		*(*uintptr)(unsafe.Pointer(tempObjv + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))*8)) = (*TBgError)(unsafe.Pointer(errPtr)).FerrorMsg
		*(*uintptr)(unsafe.Pointer(tempObjv + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp))+int64(1))*8)) = (*TBgError)(unsafe.Pointer(errPtr)).FreturnOpts
		XTcl_AllowExceptions(tls, interp)
		code = XTcl_EvalObjv(tls, interp, *(*TTcl_Size)(unsafe.Pointer(bp))+int64(2), tempObjv, int32(TCL_EVAL_GLOBAL))
		/*
		 * Discard the command and the information about the error report.
		 */
		_objPtr = copyObj
		v5 = _objPtr
		v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
		*(*TTcl_Size)(unsafe.Pointer(v5))--
		if v4 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		_objPtr1 = (*TBgError)(unsafe.Pointer(errPtr)).FerrorMsg
		v7 = _objPtr1
		v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
		*(*TTcl_Size)(unsafe.Pointer(v7))--
		if v6 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		_objPtr2 = (*TBgError)(unsafe.Pointer(errPtr)).FreturnOpts
		v9 = _objPtr2
		v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
		*(*TTcl_Size)(unsafe.Pointer(v9))--
		if v8 <= int64(1) {
			XTclFreeObj(tls, _objPtr2)
		}
		(*TErrAssocData)(unsafe.Pointer(assocPtr)).FfirstBgPtr = (*TBgError)(unsafe.Pointer(errPtr)).FnextPtr
		XTclpFree(tls, errPtr)
		XTclpFree(tls, tempObjv)
		if code == int32(TCL_BREAK) {
			/*
			 * Break means cancel any remaining error reports for this
			 * interpreter.
			 */
			for (*TErrAssocData)(unsafe.Pointer(assocPtr)).FfirstBgPtr != libc.UintptrFromInt32(0) {
				errPtr = (*TErrAssocData)(unsafe.Pointer(assocPtr)).FfirstBgPtr
				(*TErrAssocData)(unsafe.Pointer(assocPtr)).FfirstBgPtr = (*TBgError)(unsafe.Pointer(errPtr)).FnextPtr
				_objPtr3 = (*TBgError)(unsafe.Pointer(errPtr)).FerrorMsg
				v11 = _objPtr3
				v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
				*(*TTcl_Size)(unsafe.Pointer(v11))--
				if v10 <= int64(1) {
					XTclFreeObj(tls, _objPtr3)
				}
				_objPtr4 = (*TBgError)(unsafe.Pointer(errPtr)).FreturnOpts
				v13 = _objPtr4
				v12 = *(*TTcl_Size)(unsafe.Pointer(v13))
				*(*TTcl_Size)(unsafe.Pointer(v13))--
				if v12 <= int64(1) {
					XTclFreeObj(tls, _objPtr4)
				}
				XTclpFree(tls, errPtr)
			}
		} else {
			if code == int32(TCL_ERROR) && !(XTcl_IsSafe(tls, interp) != 0) {
				errChannel = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(3))
				if errChannel != libc.UintptrFromInt32(0) {
					options = XTcl_GetReturnOptions(tls, interp, code)
					*(*uintptr)(unsafe.Pointer(bp + 16)) = libc.UintptrFromInt32(0)
					XTclDictGet(tls, libc.UintptrFromInt32(0), options, __ccgo_ts+15220, bp+16)
					XTcl_WriteChars(tls, errChannel, __ccgo_ts+30667, int64(-int32(1)))
					if *(*uintptr)(unsafe.Pointer(bp + 16)) != 0 {
						if XTcl_WriteObj(tls, errChannel, *(*uintptr)(unsafe.Pointer(bp + 16))) < 0 {
							XTcl_WriteChars(tls, errChannel, uintptr(unsafe.Pointer(&_ENCODING_ERROR)), int64(-int32(1)))
						}
					} else {
						if XTcl_WriteObj(tls, errChannel, XTcl_GetObjResult(tls, interp)) < 0 {
							XTcl_WriteChars(tls, errChannel, uintptr(unsafe.Pointer(&_ENCODING_ERROR)), int64(-int32(1)))
						}
					}
					XTcl_WriteChars(tls, errChannel, __ccgo_ts+286, int64(1))
					XTcl_Flush(tls, errChannel)
					_objPtr5 = options
					v15 = _objPtr5
					v14 = *(*TTcl_Size)(unsafe.Pointer(v15))
					*(*TTcl_Size)(unsafe.Pointer(v15))--
					if v14 <= int64(1) {
						XTclFreeObj(tls, _objPtr5)
					}
				}
			}
		}
	}
	(*TErrAssocData)(unsafe.Pointer(assocPtr)).FlastBgPtr = libc.UintptrFromInt32(0)
	XTcl_Release(tls, interp)
	XTcl_Release(tls, assocPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * TclDefaultBgErrorHandlerObjCmd --
 *
 *	This function is invoked to process the "::tcl::Bgerror" Tcl command.
 *	It is the default handler command registered with [interp bgerror] for
 *	the sake of compatibility with older Tcl releases.
 *
 * Results:
 *	A standard Tcl object result.
 *
 * Side effects:
 *	Depends on what actions the "bgerror" command takes for the errors.
 *
 *----------------------------------------------------------------------
 */

func XTclDefaultBgErrorHandlerObjCmd(tls *libc.TLS, dummy326 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* Argument objects. */
	var _objPtr, _objPtr1, _objPtr2, cachePtr, cachePtr1, cachePtr2, resultPtr, v13, v15, v17 uintptr
	var errChannel TTcl_Channel
	var result int32
	var saved TTcl_InterpState
	var v1, v10, v11 bool
	var v12, v14, v16 TTcl_Size
	var _ /* code at bp+24 */ int32
	var _ /* level at bp+28 */ int32
	var _ /* tempObjv at bp+8 */ [2]uintptr
	var _ /* valuePtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, cachePtr, cachePtr1, cachePtr2, errChannel, result, resultPtr, saved, v1, v10, v11, v12, v13, v14, v15, v16, v17
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+30703)
		return int32(TCL_ERROR)
	}
	/*
	 * Check for a valid return options dictionary.
	 */
	result = XTclDictGet(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + 2*8)), __ccgo_ts+30715, bp)
	if result != TCL_OK || *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+30722, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+16490, __ccgo_ts+17673, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), bp+28) == int32(TCL_ERROR) {
		return int32(TCL_ERROR)
	}
	result = XTclDictGet(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + 2*8)), __ccgo_ts+30753, bp)
	if result != TCL_OK || *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+30759, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+16490, __ccgo_ts+17673, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), bp+24) == int32(TCL_ERROR) {
		return int32(TCL_ERROR)
	}
	if *(*int32)(unsafe.Pointer(bp + 28)) != 0 {
		/*
		 * We're handling a TCL_RETURN exception.
		 */
		*(*int32)(unsafe.Pointer(bp + 24)) = int32(TCL_RETURN)
	}
	if *(*int32)(unsafe.Pointer(bp + 24)) == TCL_OK {
		/*
		 * Somehow we got to exception handling with no exception. (Pass
		 * TCL_OK to Tcl_BackgroundException()?) Just return without doing
		 * anything.
		 */
		return TCL_OK
	}
	/*
	 * Construct the bgerror command.
	 */
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		(*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0] = XTclThreadAllocObj(tls)
	} else {
		(*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0] = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0] + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0])).FrefCount = 0
	if libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0])).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0])).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0])).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0])).Fbytes, __ccgo_ts+30789, libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0])).Fbytes + uintptr(libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0])).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(8) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0])).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0])).FrefCount++
	/*
	 * Determine error message argument.  Check the return options in case
	 * a non-error exception brought us here.
	 */
	switch *(*int32)(unsafe.Pointer(bp + 24)) {
	case int32(TCL_ERROR):
		goto _2
	case int32(TCL_BREAK):
		goto _3
	case int32(TCL_CONTINUE):
		goto _4
	default:
		goto _5
	}
	goto _6
_2:
	;
	(*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	goto _6
_3:
	;
_9:
	;
	if v10 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v10 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v10 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		(*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] = XTclThreadAllocObj(tls)
	} else {
		(*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).FrefCount = 0
	if libc.Uint64FromInt64(34)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(34)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).Fbytes, __ccgo_ts+8653, libc.Uint64FromInt64(34)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).Fbytes + uintptr(libc.Uint64FromInt64(34)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(34) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).FtypePtr = libc.UintptrFromInt32(0)
	goto _8
_8:
	;
	if 0 != 0 {
		goto _9
	}
	goto _7
_7:
	;
	goto _6
_4:
	;
	if v11 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v11 {
		cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v11 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
		(*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] = XTclThreadAllocObj(tls)
	} else {
		(*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).FrefCount = 0
	if libc.Uint64FromInt64(37)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(37)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).Fbytes, __ccgo_ts+8687, libc.Uint64FromInt64(37)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).Fbytes + uintptr(libc.Uint64FromInt64(37)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(37) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).FtypePtr = libc.UintptrFromInt32(0)
	goto _6
_5:
	;
	(*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] = XTcl_ObjPrintf(tls, __ccgo_ts+8724, libc.VaList(bp+40, *(*int32)(unsafe.Pointer(bp + 24))))
	goto _6
_6:
	;
	(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).FrefCount++
	if *(*int32)(unsafe.Pointer(bp + 24)) != int32(TCL_ERROR) {
		XTcl_SetObjResult(tls, interp, (*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])
	}
	result = XTclDictGet(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + 2*8)), __ccgo_ts+15231, bp)
	if result == TCL_OK && *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
		XTcl_SetObjErrorCode(tls, interp, *(*uintptr)(unsafe.Pointer(bp)))
	}
	result = XTclDictGet(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + 2*8)), __ccgo_ts+15220, bp)
	if result == TCL_OK && *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
		XTcl_AppendObjToErrorInfo(tls, interp, *(*uintptr)(unsafe.Pointer(bp)))
	}
	if *(*int32)(unsafe.Pointer(bp + 24)) == int32(TCL_ERROR) {
		XTcl_SetObjResult(tls, interp, (*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])
	}
	/*
	 * Save interpreter state so we can restore it if multiple handler
	 * attempts are needed.
	 */
	saved = XTcl_SaveInterpState(tls, interp, *(*int32)(unsafe.Pointer(bp + 24)))
	/*
	 * Invoke the bgerror command.
	 */
	XTcl_AllowExceptions(tls, interp)
	*(*int32)(unsafe.Pointer(bp + 24)) = XTcl_EvalObjv(tls, interp, int64(2), bp+8, int32(TCL_EVAL_GLOBAL))
	if *(*int32)(unsafe.Pointer(bp + 24)) == int32(TCL_ERROR) {
		/*
		 * If the interpreter is safe, we look for a hidden command named
		 * "bgerror" and call that with the error information. Otherwise,
		 * simply ignore the error. The rationale is that this could be an
		 * error caused by a malicious applet trying to cause an infinite
		 * barrage of error messages. The hidden "bgerror" command can be used
		 * by a security policy to interpose on such attacks and e.g. kill the
		 * applet after a few attempts.
		 */
		if XTcl_IsSafe(tls, interp) != 0 {
			XTcl_RestoreInterpState(tls, interp, saved)
			XTclObjInvoke(tls, interp, int64(2), bp+8, libc.Int32FromInt32(1)<<libc.Int32FromInt32(0))
		} else {
			errChannel = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(3))
			if errChannel != libc.UintptrFromInt32(0) {
				resultPtr = XTcl_GetObjResult(tls, interp)
				(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount++
				if XTcl_FindCommand(tls, interp, __ccgo_ts+30789, libc.UintptrFromInt32(0), int32(TCL_GLOBAL_ONLY)) == libc.UintptrFromInt32(0) {
					XTcl_RestoreInterpState(tls, interp, saved)
					if XTcl_WriteObj(tls, errChannel, XTcl_GetVar2Ex(tls, interp, __ccgo_ts+30797, libc.UintptrFromInt32(0), int32(TCL_GLOBAL_ONLY))) < 0 {
						XTcl_WriteChars(tls, errChannel, uintptr(unsafe.Pointer(&_ENCODING_ERROR)), int64(-int32(1)))
					}
					XTcl_WriteChars(tls, errChannel, __ccgo_ts+286, int64(-int32(1)))
				} else {
					XTcl_DiscardInterpState(tls, saved)
					XTcl_WriteChars(tls, errChannel, __ccgo_ts+30807, int64(-int32(1)))
					if XTcl_WriteObj(tls, errChannel, (*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)]) < 0 {
						XTcl_WriteChars(tls, errChannel, uintptr(unsafe.Pointer(&_ENCODING_ERROR)), int64(-int32(1)))
					}
					XTcl_WriteChars(tls, errChannel, __ccgo_ts+30871, int64(-int32(1)))
					if XTcl_WriteObj(tls, errChannel, resultPtr) < 0 {
						XTcl_WriteChars(tls, errChannel, uintptr(unsafe.Pointer(&_ENCODING_ERROR)), int64(-int32(1)))
					}
					XTcl_WriteChars(tls, errChannel, __ccgo_ts+286, int64(-int32(1)))
				}
				_objPtr = resultPtr
				v13 = _objPtr
				v12 = *(*TTcl_Size)(unsafe.Pointer(v13))
				*(*TTcl_Size)(unsafe.Pointer(v13))--
				if v12 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
				XTcl_Flush(tls, errChannel)
			} else {
				XTcl_DiscardInterpState(tls, saved)
			}
		}
		*(*int32)(unsafe.Pointer(bp + 24)) = TCL_OK
	} else {
		XTcl_DiscardInterpState(tls, saved)
	}
	_objPtr1 = (*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0]
	v15 = _objPtr1
	v14 = *(*TTcl_Size)(unsafe.Pointer(v15))
	*(*TTcl_Size)(unsafe.Pointer(v15))--
	if v14 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	_objPtr2 = (*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)]
	v17 = _objPtr2
	v16 = *(*TTcl_Size)(unsafe.Pointer(v17))
	*(*TTcl_Size)(unsafe.Pointer(v17))--
	if v16 <= int64(1) {
		XTclFreeObj(tls, _objPtr2)
	}
	XTcl_ResetResult(tls, interp)
	return *(*int32)(unsafe.Pointer(bp + 24))
}

/*
 *----------------------------------------------------------------------
 *
 * TclSetBgErrorHandler --
 *
 *	This function sets the command prefix to be used to handle background
 *	errors in interp.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Error handler is registered.
 *
 *----------------------------------------------------------------------
 */

func XTclSetBgErrorHandler(tls *libc.TLS, interp uintptr, cmdPrefix uintptr) {
	var _objPtr, assocPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _ = _objPtr, assocPtr, v1, v2
	assocPtr = XTcl_GetAssocData(tls, interp, __ccgo_ts+30656, libc.UintptrFromInt32(0))
	if cmdPrefix == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+30895, 0)
	}
	if assocPtr == libc.UintptrFromInt32(0) {
		/*
		 * First access: initialize.
		 */
		assocPtr = XTcl_Alloc(tls, uint64(32))
		(*TErrAssocData)(unsafe.Pointer(assocPtr)).Finterp = interp
		(*TErrAssocData)(unsafe.Pointer(assocPtr)).FcmdPrefix = libc.UintptrFromInt32(0)
		(*TErrAssocData)(unsafe.Pointer(assocPtr)).FfirstBgPtr = libc.UintptrFromInt32(0)
		(*TErrAssocData)(unsafe.Pointer(assocPtr)).FlastBgPtr = libc.UintptrFromInt32(0)
		XTcl_SetAssocData(tls, interp, __ccgo_ts+30656, __ccgo_fp(_BgErrorDeleteProc), assocPtr)
	}
	if (*TErrAssocData)(unsafe.Pointer(assocPtr)).FcmdPrefix != 0 {
		_objPtr = (*TErrAssocData)(unsafe.Pointer(assocPtr)).FcmdPrefix
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	(*TErrAssocData)(unsafe.Pointer(assocPtr)).FcmdPrefix = cmdPrefix
	(*TTcl_Obj)(unsafe.Pointer((*TErrAssocData)(unsafe.Pointer(assocPtr)).FcmdPrefix)).FrefCount++
}

/*
 *----------------------------------------------------------------------
 *
 * TclGetBgErrorHandler --
 *
 *	This function retrieves the command prefix currently used to handle
 *	background errors in interp.
 *
 * Results:
 *	A (Tcl_Obj *) to a list of words (command prefix).
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclGetBgErrorHandler(tls *libc.TLS, interp uintptr) (r uintptr) {
	var assocPtr, bgerrorObj, cachePtr uintptr
	var v1 bool
	_, _, _, _ = assocPtr, bgerrorObj, cachePtr, v1
	assocPtr = XTcl_GetAssocData(tls, interp, __ccgo_ts+30656, libc.UintptrFromInt32(0))
	if assocPtr == libc.UintptrFromInt32(0) {
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			bgerrorObj = XTclThreadAllocObj(tls)
		} else {
			bgerrorObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(bgerrorObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(bgerrorObj)).FrefCount = 0
		if libc.Uint64FromInt64(15)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer(bgerrorObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(bgerrorObj)).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(bgerrorObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(15)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(bgerrorObj)).Fbytes, __ccgo_ts+6734, libc.Uint64FromInt64(15)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(bgerrorObj)).Fbytes + uintptr(libc.Uint64FromInt64(15)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(bgerrorObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(15) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer(bgerrorObj)).FtypePtr = libc.UintptrFromInt32(0)
		XTclSetBgErrorHandler(tls, interp, bgerrorObj)
		assocPtr = XTcl_GetAssocData(tls, interp, __ccgo_ts+30656, libc.UintptrFromInt32(0))
	}
	return (*TErrAssocData)(unsafe.Pointer(assocPtr)).FcmdPrefix
}

/*
 *----------------------------------------------------------------------
 *
 * BgErrorDeleteProc --
 *
 *	This function is associated with the "tclBgError" assoc data for an
 *	interpreter; it is invoked when the interpreter is deleted in order to
 *	free the information associated with any pending error reports.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Background error information is freed: if there were any pending error
 *	reports, they are canceled.
 *
 *----------------------------------------------------------------------
 */

func _BgErrorDeleteProc(tls *libc.TLS, clientData uintptr, dummy604 uintptr) {
	var _objPtr, _objPtr1, _objPtr2, assocPtr, errPtr, v2, v4, v6 uintptr
	var v1, v3, v5 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, assocPtr, errPtr, v1, v2, v3, v4, v5, v6
	assocPtr = clientData
	for (*TErrAssocData)(unsafe.Pointer(assocPtr)).FfirstBgPtr != libc.UintptrFromInt32(0) {
		errPtr = (*TErrAssocData)(unsafe.Pointer(assocPtr)).FfirstBgPtr
		(*TErrAssocData)(unsafe.Pointer(assocPtr)).FfirstBgPtr = (*TBgError)(unsafe.Pointer(errPtr)).FnextPtr
		_objPtr = (*TBgError)(unsafe.Pointer(errPtr)).FerrorMsg
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		_objPtr1 = (*TBgError)(unsafe.Pointer(errPtr)).FreturnOpts
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		XTclpFree(tls, errPtr)
	}
	XTcl_CancelIdleCall(tls, __ccgo_fp(_HandleBgErrors), assocPtr)
	_objPtr2 = (*TErrAssocData)(unsafe.Pointer(assocPtr)).FcmdPrefix
	v6 = _objPtr2
	v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
	*(*TTcl_Size)(unsafe.Pointer(v6))--
	if v5 <= int64(1) {
		XTclFreeObj(tls, _objPtr2)
	}
	XTcl_EventuallyFree(tls, assocPtr, libc.UintptrFromInt32(3))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_CreateExitHandler --
 *
 *	Arrange for a given function to be invoked just before the application
 *	exits.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Proc will be invoked with clientData as argument when the application
 *	exits.
 *
 *----------------------------------------------------------------------
 */

func XTcl_CreateExitHandler(tls *libc.TLS, proc uintptr, clientData uintptr) {
	/* Arbitrary value to pass to proc. */
	var exitPtr uintptr
	_ = exitPtr
	exitPtr = XTcl_Alloc(tls, uint64(24))
	(*TExitHandler)(unsafe.Pointer(exitPtr)).Fproc = proc
	(*TExitHandler)(unsafe.Pointer(exitPtr)).FclientData = clientData
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_exitMutex)))
	(*TExitHandler)(unsafe.Pointer(exitPtr)).FnextPtr = _firstExitPtr
	_firstExitPtr = exitPtr
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_exitMutex)))
}

/*
 *----------------------------------------------------------------------
 *
 * TclCreateLateExitHandler --
 *
 *	Arrange for a given function to be invoked after all pre-thread
 *	cleanups.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Proc will be invoked with clientData as argument when the application
 *	exits.
 *
 *----------------------------------------------------------------------
 */

func XTclCreateLateExitHandler(tls *libc.TLS, proc uintptr, clientData uintptr) {
	/* Arbitrary value to pass to proc. */
	var exitPtr uintptr
	_ = exitPtr
	exitPtr = XTcl_Alloc(tls, uint64(24))
	(*TExitHandler)(unsafe.Pointer(exitPtr)).Fproc = proc
	(*TExitHandler)(unsafe.Pointer(exitPtr)).FclientData = clientData
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_exitMutex)))
	(*TExitHandler)(unsafe.Pointer(exitPtr)).FnextPtr = _firstLateExitPtr
	_firstLateExitPtr = exitPtr
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_exitMutex)))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DeleteExitHandler --
 *
 *	This function cancels an existing exit handler matching proc and
 *	clientData, if such a handler exits.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	If there is an exit handler corresponding to proc and clientData then
 *	it is canceled; if no such handler exists then nothing happens.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DeleteExitHandler(tls *libc.TLS, proc uintptr, clientData uintptr) {
	/* Arbitrary value to pass to proc. */
	var exitPtr, prevPtr uintptr
	_, _ = exitPtr, prevPtr
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_exitMutex)))
	prevPtr = libc.UintptrFromInt32(0)
	exitPtr = _firstExitPtr
	for {
		if !(exitPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TExitHandler)(unsafe.Pointer(exitPtr)).Fproc == proc && (*TExitHandler)(unsafe.Pointer(exitPtr)).FclientData == clientData {
			if prevPtr == libc.UintptrFromInt32(0) {
				_firstExitPtr = (*TExitHandler)(unsafe.Pointer(exitPtr)).FnextPtr
			} else {
				(*TExitHandler)(unsafe.Pointer(prevPtr)).FnextPtr = (*TExitHandler)(unsafe.Pointer(exitPtr)).FnextPtr
			}
			XTclpFree(tls, exitPtr)
			break
		}
		goto _1
	_1:
		;
		prevPtr = exitPtr
		exitPtr = (*TExitHandler)(unsafe.Pointer(exitPtr)).FnextPtr
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_exitMutex)))
	return
}

/*
 *----------------------------------------------------------------------
 *
 * TclDeleteLateExitHandler --
 *
 *	This function cancels an existing late exit handler matching proc and
 *	clientData, if such a handler exits.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	If there is a late exit handler corresponding to proc and clientData
 *	then it is canceled; if no such handler exists then nothing happens.
 *
 *----------------------------------------------------------------------
 */

func XTclDeleteLateExitHandler(tls *libc.TLS, proc uintptr, clientData uintptr) {
	/* Arbitrary value to pass to proc. */
	var exitPtr, prevPtr uintptr
	_, _ = exitPtr, prevPtr
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_exitMutex)))
	prevPtr = libc.UintptrFromInt32(0)
	exitPtr = _firstLateExitPtr
	for {
		if !(exitPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TExitHandler)(unsafe.Pointer(exitPtr)).Fproc == proc && (*TExitHandler)(unsafe.Pointer(exitPtr)).FclientData == clientData {
			if prevPtr == libc.UintptrFromInt32(0) {
				_firstLateExitPtr = (*TExitHandler)(unsafe.Pointer(exitPtr)).FnextPtr
			} else {
				(*TExitHandler)(unsafe.Pointer(prevPtr)).FnextPtr = (*TExitHandler)(unsafe.Pointer(exitPtr)).FnextPtr
			}
			XTclpFree(tls, exitPtr)
			break
		}
		goto _1
	_1:
		;
		prevPtr = exitPtr
		exitPtr = (*TExitHandler)(unsafe.Pointer(exitPtr)).FnextPtr
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_exitMutex)))
	return
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_CreateThreadExitHandler --
 *
 *	Arrange for a given function to be invoked just before the current
 *	thread exits.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Proc will be invoked with clientData as argument when the application
 *	exits.
 *
 *----------------------------------------------------------------------
 */

func XTcl_CreateThreadExitHandler(tls *libc.TLS, proc uintptr, clientData uintptr) {
	/* Arbitrary value to pass to proc. */
	var exitPtr, tsdPtr uintptr
	_, _ = exitPtr, tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey1)), int64(16))
	exitPtr = XTcl_Alloc(tls, uint64(24))
	(*TExitHandler)(unsafe.Pointer(exitPtr)).Fproc = proc
	(*TExitHandler)(unsafe.Pointer(exitPtr)).FclientData = clientData
	(*TExitHandler)(unsafe.Pointer(exitPtr)).FnextPtr = (*TThreadSpecificData2)(unsafe.Pointer(tsdPtr)).FfirstExitPtr
	(*TThreadSpecificData2)(unsafe.Pointer(tsdPtr)).FfirstExitPtr = exitPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DeleteThreadExitHandler --
 *
 *	This function cancels an existing exit handler matching proc and
 *	clientData, if such a handler exits.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	If there is an exit handler corresponding to proc and clientData then
 *	it is canceled; if no such handler exists then nothing happens.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DeleteThreadExitHandler(tls *libc.TLS, proc uintptr, clientData uintptr) {
	/* Arbitrary value to pass to proc. */
	var exitPtr, prevPtr, tsdPtr uintptr
	_, _, _ = exitPtr, prevPtr, tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey1)), int64(16))
	prevPtr = libc.UintptrFromInt32(0)
	exitPtr = (*TThreadSpecificData2)(unsafe.Pointer(tsdPtr)).FfirstExitPtr
	for {
		if !(exitPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TExitHandler)(unsafe.Pointer(exitPtr)).Fproc == proc && (*TExitHandler)(unsafe.Pointer(exitPtr)).FclientData == clientData {
			if prevPtr == libc.UintptrFromInt32(0) {
				(*TThreadSpecificData2)(unsafe.Pointer(tsdPtr)).FfirstExitPtr = (*TExitHandler)(unsafe.Pointer(exitPtr)).FnextPtr
			} else {
				(*TExitHandler)(unsafe.Pointer(prevPtr)).FnextPtr = (*TExitHandler)(unsafe.Pointer(exitPtr)).FnextPtr
			}
			XTclpFree(tls, exitPtr)
			return
		}
		goto _1
	_1:
		;
		prevPtr = exitPtr
		exitPtr = (*TExitHandler)(unsafe.Pointer(exitPtr)).FnextPtr
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetExitProc --
 *
 *	This function sets the application wide exit handler that will be
 *	called by Tcl_Exit in place of the C-runtime exit. If the application
 *	wide exit handler is NULL, the C-runtime exit will be used instead.
 *
 * Results:
 *	The previously set application wide exit handler.
 *
 * Side effects:
 *	Sets the application wide exit handler to the specified value.
 *
 *----------------------------------------------------------------------
 */
func XTcl_SetExitProc(tls *libc.TLS, proc uintptr) (r uintptr) {
	/* New exit handler for app or NULL */
	var prevExitProc uintptr
	_ = prevExitProc
	/*
	 * Swap the old exit proc for the new one, saving the old one for our
	 * return value.
	 */
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_exitMutex)))
	prevExitProc = _appExitPtr
	_appExitPtr = proc
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_exitMutex)))
	return prevExitProc
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * InvokeExitHandlers --
//	 *
//	 *      Call the registered exit handlers.
//	 *
//	 * Results:
//	 *	None.
//	 *
//	 * Side effects:
//	 *	The exit handlers are invoked, and the ExitHandler struct is
//	 *      freed.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _InvokeExitHandlers(tls *libc.TLS) {
	var exitPtr uintptr
	_ = exitPtr
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_exitMutex)))
	_inExit = int32(1)
	exitPtr = _firstExitPtr
	for {
		if !(exitPtr != libc.UintptrFromInt32(0)) {
			break
		}
		/*
		 * Be careful to remove the handler from the list before invoking its
		 * callback. This protects us against double-freeing if the callback
		 * should call Tcl_DeleteExitHandler on itself.
		 */
		_firstExitPtr = (*TExitHandler)(unsafe.Pointer(exitPtr)).FnextPtr
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_exitMutex)))
		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TExitHandler)(unsafe.Pointer(exitPtr)).Fproc})))(tls, (*TExitHandler)(unsafe.Pointer(exitPtr)).FclientData)
		XTclpFree(tls, exitPtr)
		XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_exitMutex)))
		goto _1
	_1:
		;
		exitPtr = _firstExitPtr
	}
	_firstExitPtr = libc.UintptrFromInt32(0)
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_exitMutex)))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_Exit --
 *
 *	This function is called to terminate the application.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	All existing exit handlers are invoked, then the application ends.
 *
 *----------------------------------------------------------------------
 */
func XTcl_Exit(tls *libc.TLS, status int32) {
	/* Exit status for application; typically 0
	 * for normal return, 1 for error return. */
	var currentAppExitPtr uintptr
	_ = currentAppExitPtr
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_exitMutex)))
	currentAppExitPtr = _appExitPtr
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_exitMutex)))
	/*
	 * Warning: this function SHOULD NOT return, as there is code that depends
	 * on Tcl_Exit never returning. In fact, we will Tcl_Panic if anyone
	 * returns, so critical is this dependency.
	 *
	 * If subsystems are not (yet) initialized, proper Tcl-finalization is
	 * impossible, so fallback to system exit, see bug-[f8a33ce3db5d8cc2].
	 */
	if currentAppExitPtr != 0 {
		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{currentAppExitPtr})))(tls, uintptr(int64(status)))
	} else {
		if _subsystemsInitialized != 0 {
			if XTclFullFinalizationRequested(tls) != 0 {
				/*
				 * Thorough finalization for Valgrind et al.
				 */
				XTcl_Finalize(tls)
			} else {
				/*
				 * Fast and deterministic exit (default behavior)
				 */
				_InvokeExitHandlers(tls)
				/*
				 * Ensure the thread-specific data is initialised as it is used in
				 * Tcl_FinalizeThread()
				 */
				XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey1)), int64(16))
				/*
				 * Now finalize the calling thread only (others are not safely
				 * reachable).  Among other things, this triggers a flush of the
				 * Tcl_Channels that may have data enqueued.
				 */
				_FinalizeThread(tls, int32(1))
			}
		}
	}
	libc.Xexit(tls, status)
}

var _stubInfo = struct {
	Fstubs   uintptr
	Fversion [256]uint8
}{
	Fstubs:   uintptr(unsafe.Pointer(&XtclStubs)),
	Fversion: [256]uint8{'9', '.', '0', '.', '1', '+', '1', '0', 'a', '4', '5', '0', 'b', 'd', 'e', '9', 'd', '3', '0', '4', 'c', 'b', 'b', '6', 'a', '4', 'c', '2', 'f', 'a', '5', '4', 'c', 'e', 'a', 'e', 'e', 'a', '7', 'd', 'e', '0', '2', '5', 'd', 'a', 'e', '4', '0', '2', 'a', 'f', 'f', '4', 'c', '2', '8', '8', '4', 'a', '2', 'c', 'c', 'e', '2', 'c', 'e', '5', '9', '5', '.', 'g', 'c', 'c', '-', '1', '0', '0', '2', '.', 's', 't', 'a', 't', 'i', 'c', '.', 't', 'o', 'm', 'm', 'a', 't', 'h', '-', '0', '1', '0', '3'},
}

func XTcl_InitSubsystems(tls *libc.TLS) (r uintptr) {
	if _inExit != 0 {
		XTcl_Panic(tls, __ccgo_ts+30941, 0)
	}
	if _subsystemsInitialized == 0 {
		/*
		 * Double check inside the mutex. There are definitely calls back into
		 * this routine from some of the functions below.
		 */
		XTclpInitLock(tls)
		if _subsystemsInitialized == 0 {
			/*
			 * Initialize locks used by the memory allocators before anything
			 * interesting happens so we can use the allocators in the
			 * implementation of self-initializing locks.
			 */
			XTclInitThreadStorage(tls) /* Creates hash table for
			 * thread local storage */
			XTclInitThreadAlloc(tls)      /* Setup thread allocator caches */
			XTclpInitPlatform(tls)        /* Creates signal handler(s) */
			XTclInitDoubleConversion(tls) /* Initializes constants for
			 * converting to/from double. */
			XTclInitObjSubsystem(tls) /* Register obj types, create
			 * mutexes. */
			XTclInitIOSubsystem(tls)        /* Inits a tsd key (noop). */
			XTclInitEncodingSubsystem(tls)  /* Process wide encoding init. */
			XTclInitNamespaceSubsystem(tls) /* Register ns obj type (mutexed). */
			_subsystemsInitialized = int32(1)
		}
		XTclpInitUnlock(tls)
	}
	XTclInitNotifier(tls)
	return uintptr(unsafe.Pointer(&_stubInfo)) + 8
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_Finalize --
 *
 *	Shut down Tcl. First calls registered exit handlers, then carefully
 *	shuts down various subsystems.  Should be invoked by user before the
 *	Tcl shared library is being unloaded in an embedded context.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Varied, see the respective finalization routines.
 *
 *----------------------------------------------------------------------
 */

func XTcl_Finalize(tls *libc.TLS) {
	var exitPtr uintptr
	_ = exitPtr
	/*
	 * Invoke exit handlers first.
	 */
	_InvokeExitHandlers(tls)
	XTclpInitLock(tls)
	if _subsystemsInitialized == 0 {
		goto alreadyFinalized
	}
	_subsystemsInitialized = 0
	/*
	 * Ensure the thread-specific data is initialised as it is used in
	 * Tcl_FinalizeThread()
	 */
	XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey1)), int64(16))
	/*
	 * Clean up after the current thread now, after exit handlers. In
	 * particular, the testexithandler command sets up something that writes
	 * to standard output, which gets closed. Note that there is no
	 * thread-local storage or IO subsystem after this call.
	 */
	XTcl_FinalizeThread(tls)
	/*
	 * Now invoke late (process-wide) exit handlers.
	 */
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_exitMutex)))
	exitPtr = _firstLateExitPtr
	for {
		if !(exitPtr != libc.UintptrFromInt32(0)) {
			break
		}
		/*
		 * Be careful to remove the handler from the list before invoking its
		 * callback. This protects us against double-freeing if the callback
		 * should call Tcl_DeleteLateExitHandler on itself.
		 */
		_firstLateExitPtr = (*TExitHandler)(unsafe.Pointer(exitPtr)).FnextPtr
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_exitMutex)))
		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TExitHandler)(unsafe.Pointer(exitPtr)).Fproc})))(tls, (*TExitHandler)(unsafe.Pointer(exitPtr)).FclientData)
		XTclpFree(tls, exitPtr)
		XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_exitMutex)))
		goto _1
	_1:
		;
		exitPtr = _firstLateExitPtr
	}
	_firstLateExitPtr = libc.UintptrFromInt32(0)
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_exitMutex)))
	/*
	 * Now finalize the Tcl execution environment. Note that this must be done
	 * after the exit handlers, because there are order dependencies.
	 */
	XTclFinalizeEvaluation(tls)
	XTclFinalizeExecution(tls)
	XTclFinalizeEnvironment(tls)
	/*
	 * Finalizing the filesystem must come after anything which might
	 * conceivably interact with the 'Tcl_FS' API.
	 */
	XTclFinalizeFilesystem(tls)
	/*
	 * Undo all Tcl_ObjType registrations, and reset the global list of free
	 * Tcl_Obj's. After this returns, no more Tcl_Obj's should be allocated or
	 * freed.
	 *
	 * Note in particular that TclFinalizeObjects() must follow
	 * TclFinalizeFilesystem() because TclFinalizeFilesystem free's the
	 * Tcl_Obj that holds the path of the current working directory.
	 */
	XTclFinalizeObjects(tls)
	/*
	 * We must be sure the encoding finalization doesn't need to examine the
	 * filesystem in any way. Since it only needs to clean up internal data
	 * structures, this is fine.
	 */
	XTclFinalizeEncodingSubsystem(tls)
	/*
	 * Repeat finalization of the thread local storage once more. Although
	 * this step is already done by the Tcl_FinalizeThread call above, series
	 * of events happening afterwards may re-initialize TSD slots. Those need
	 * to be finalized again, otherwise we're leaking memory chunks. Very
	 * important to note is that things happening afterwards should not
	 * reference anything which may re-initialize TSD's. This includes freeing
	 * Tcl_Objs's, among other things.
	 *
	 * This fixes the Tcl Bug #990552.
	 */
	XTclFinalizeThreadData(tls, 0)
	/*
	 * Now we can free constants for conversions to/from double.
	 */
	XTclFinalizeDoubleConversion(tls)
	/*
	 * There have been several bugs in the past that cause exit handlers to be
	 * established during Tcl_Finalize processing. Such exit handlers leave
	 * malloc'ed memory, and Tcl_FinalizeMemorySubsystem or
	 * Tcl_FinalizeThreadAlloc will result in a corrupted heap. The result can
	 * be a mysterious crash on process exit. Check here that nobody's done
	 * this.
	 */
	if _firstExitPtr != libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+30981, 0)
	}
	XTclFinalizePreserve(tls)
	/*
	 * Free synchronization objects. There really should only be one thread
	 * alive at this moment.
	 */
	XTclFinalizeSynchronization(tls)
	/*
	 * Close down the thread-specific object allocator.
	 */
	XTclFinalizeThreadAlloc(tls)
	/*
	 * We defer unloading of packages until very late to avoid memory access
	 * issues. Both exit callbacks and synchronization variables may be stored
	 * in packages.
	 *
	 * Note that TclFinalizeLoad unloads packages in the reverse of the order
	 * they were loaded in (i.e. last to be loaded is the first to be
	 * unloaded). This can be important for correct unloading when
	 * dependencies exist.
	 *
	 * Once load has been finalized, we will have deleted any temporary copies
	 * of shared libraries and can therefore reset the filesystem to its
	 * original state.
	 */
	XTclFinalizeLoad(tls)
	XTclResetFilesystem(tls)
	/*
	 * At this point, there should no longer be any Tcl_Alloc'ed memory.
	 */
	XTclFinalizeMemorySubsystem(tls)
	goto alreadyFinalized
alreadyFinalized:
	;
	XTclFinalizeLock(tls)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FinalizeThread --
 *
 *	Runs the exit handlers to allow Tcl to clean up its state about a
 *	particular thread.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Varied, see the respective finalization routines.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FinalizeThread(tls *libc.TLS) {
	_FinalizeThread(tls, 0)
}

func _FinalizeThread(tls *libc.TLS, quick int32) {
	var exitPtr, tsdPtr uintptr
	_, _ = exitPtr, tsdPtr
	/*
	 * We use TclThreadDataKeyGet here, rather than Tcl_GetThreadData, because
	 * we don't want to initialize the data block if it hasn't been
	 * initialized already.
	 */
	tsdPtr = XTclThreadDataKeyGet(tls, uintptr(unsafe.Pointer(&_dataKey1)))
	if tsdPtr != libc.UintptrFromInt32(0) {
		(*TThreadSpecificData2)(unsafe.Pointer(tsdPtr)).FinExit = int32(1)
		exitPtr = (*TThreadSpecificData2)(unsafe.Pointer(tsdPtr)).FfirstExitPtr
		for {
			if !(exitPtr != libc.UintptrFromInt32(0)) {
				break
			}
			/*
			 * Be careful to remove the handler from the list before invoking
			 * its callback. This protects us against double-freeing if the
			 * callback should call Tcl_DeleteThreadExitHandler on itself.
			 */
			(*TThreadSpecificData2)(unsafe.Pointer(tsdPtr)).FfirstExitPtr = (*TExitHandler)(unsafe.Pointer(exitPtr)).FnextPtr
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TExitHandler)(unsafe.Pointer(exitPtr)).Fproc})))(tls, (*TExitHandler)(unsafe.Pointer(exitPtr)).FclientData)
			XTclpFree(tls, exitPtr)
			goto _1
		_1:
			;
			exitPtr = (*TThreadSpecificData2)(unsafe.Pointer(tsdPtr)).FfirstExitPtr
		}
		XTclFinalizeIOSubsystem(tls)
		XTclFinalizeNotifier(tls)
		XTclFinalizeAsync(tls)
		XTclFinalizeThreadObjects(tls)
	}
	/*
	 * Blow away all thread local storage blocks.
	 *
	 * Note that Tcl API allows creation of threads which do not use any Tcl
	 * interp or other Tcl subsytems. Those threads might, however, use thread
	 * local storage, so we must unconditionally finalize it.
	 *
	 * Fix [Bug #571002]
	 */
	XTclFinalizeThreadData(tls, quick)
}

/*
 *----------------------------------------------------------------------
 *
 * TclInExit --
 *
 *	Determines if we are in the middle of exit-time cleanup.
 *
 * Results:
 *	If we are in the middle of exiting, 1, otherwise 0.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclInExit(tls *libc.TLS) (r int32) {
	return _inExit
}

/*
 *----------------------------------------------------------------------
 *
 * TclInThreadExit --
 *
 *	Determines if we are in the middle of thread exit-time cleanup.
 *
 * Results:
 *	If we are in the middle of exiting this thread, 1, otherwise 0.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclInThreadExit(tls *libc.TLS) (r int32) {
	var tsdPtr uintptr
	_ = tsdPtr
	tsdPtr = XTclThreadDataKeyGet(tls, uintptr(unsafe.Pointer(&_dataKey1)))
	if tsdPtr == libc.UintptrFromInt32(0) {
		return 0
	}
	return (*TThreadSpecificData2)(unsafe.Pointer(tsdPtr)).FinExit
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_VwaitObjCmd --
 *
 *	This function is invoked to process the "vwait" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_VwaitObjCmd(tls *libc.TLS, dummy1496 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(880)
	defer tls.Free(880) /* Argument objects. */
	var any1, extended, foundEvent, i, k, mask, numItems, result, v16, v17, v19, v21 int32
	var cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, keyObj, listObj, name, vwaitItems, v18, v2, v20, v22, v24, v26, v28 uintptr
	var diff TTcl_WideInt
	var saved TTcl_InterpState
	var timer TTcl_TimerToken
	var v29, v32, v33, v34, v35 bool
	var _ /* after at bp+32 */ TTcl_Time
	var _ /* before at bp+16 */ TTcl_Time
	var _ /* chan at bp+48 */ TTcl_Channel
	var _ /* done at bp+0 */ int32
	var _ /* index at bp+824 */ int32
	var _ /* localItems at bp+56 */ [32]TVwaitItem
	var _ /* mode at bp+12 */ int32
	var _ /* timedOut at bp+4 */ int32
	var _ /* timeout at bp+8 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = any1, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, diff, extended, foundEvent, i, k, keyObj, listObj, mask, name, numItems, result, saved, timer, vwaitItems, v16, v17, v18, v19, v2, v20, v21, v22, v24, v26, v28, v29, v32, v33, v34, v35
	*(*int32)(unsafe.Pointer(bp)) = 0
	*(*int32)(unsafe.Pointer(bp + 4)) = 0
	any1 = int32(1)
	*(*int32)(unsafe.Pointer(bp + 8)) = 0
	numItems = 0
	extended = 0
	mask = ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(1))
	saved = libc.UintptrFromInt32(0)
	timer = libc.UintptrFromInt32(0)
	diff = int64(-int32(1))
	vwaitItems = bp + 56
	if objc == int32(2) && libc.Xstrcmp(tls, XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0)), __ccgo_ts+18684) != 0 {
		/*
		 * Legacy "vwait" syntax, skip option handling.
		 */
		i = int32(1)
		goto endOfOptionLoop
	}
	if uint64(libc.Uint32FromInt32(objc)-uint32(1)) > libc.Uint64FromInt64(768)/libc.Uint64FromInt64(24) {
		vwaitItems = XTcl_Alloc(tls, uint64(24)*libc.Uint64FromInt32(objc-libc.Int32FromInt32(1)))
	}
	i = int32(1)
	for {
		if !(i < objc) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		name = v2
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) != int32('-') {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_vWaitOptionStrings)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+824) != TCL_OK {
			result = int32(TCL_ERROR)
			goto done
		}
		switch *(*int32)(unsafe.Pointer(bp + 824)) {
		case 0:
			goto _3
		case 1:
			goto _4
		case 2:
			goto _5
		case 3:
			goto _6
		case 4:
			goto _7
		case 5:
			goto _8
		case 7:
			goto _9
		case 10:
			goto _10
		case 8:
			goto _11
		case 6:
			goto _12
		case 9:
			goto _13
		}
		goto _14
	_3:
		;
		any1 = 0
		goto _14
	_4:
		;
		extended = int32(1)
		goto _14
	_5:
		;
		mask &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(3))
		goto _14
	_6:
		;
		mask &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(5))
		goto _14
	_7:
		;
		mask &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(4))
		goto _14
	_8:
		;
		mask &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(2))
		goto _14
	_9:
		;
		i++
		v16 = i
		if !(v16 >= objc) {
			goto _15
		}
		goto needArg
	needArg:
		;
		XTcl_ResetResult(tls, interp)
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+31136, libc.VaList(bp+840, _vWaitOptionStrings[*(*int32)(unsafe.Pointer(bp + 824))])))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+840, __ccgo_ts+2004, __ccgo_ts+31163, __ccgo_ts+16490, libc.UintptrFromInt32(0)))
		result = int32(TCL_ERROR)
		goto done
	_15:
		;
		if XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp+8) != TCL_OK {
			result = int32(TCL_ERROR)
			goto done
		}
		if *(*int32)(unsafe.Pointer(bp + 8)) < 0 {
			XTcl_ResetResult(tls, interp)
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+31169, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+840, __ccgo_ts+2004, __ccgo_ts+31163, __ccgo_ts+31194, libc.UintptrFromInt32(0)))
			result = int32(TCL_ERROR)
			goto done
		}
		goto _14
	_10:
		;
		i++
		goto endOfOptionLoop
	_11:
		;
		i++
		v17 = i
		if v17 >= objc {
			goto needArg
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
			v18 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
		} else {
			v18 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		result = XTcl_TraceVar2(tls, interp, v18, libc.UintptrFromInt32(0), libc.Int32FromInt32(TCL_GLOBAL_ONLY)|libc.Int32FromInt32(TCL_TRACE_WRITES)|libc.Int32FromInt32(TCL_TRACE_UNSETS), __ccgo_fp(_VwaitVarProc), vwaitItems+uintptr(numItems)*24)
		if result != TCL_OK {
			goto done
		}
		(*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(numItems)*24))).FdonePtr = bp
		(*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(numItems)*24))).Fsequence = -int32(1)
		(*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(numItems)*24))).Fmask = 0
		(*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(numItems)*24))).FsourceObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
		numItems++
		goto _14
	_12:
		;
		i++
		v19 = i
		if v19 >= objc {
			goto needArg
		}
		if XTclGetChannelFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp+48, bp+12, 0) != TCL_OK {
			result = int32(TCL_ERROR)
			goto done
		}
		if !(*(*int32)(unsafe.Pointer(bp + 12))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
				v20 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
			} else {
				v20 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+31202, libc.VaList(bp+840, v20)))
			result = int32(TCL_ERROR)
			goto done
		}
		XTcl_CreateChannelHandler(tls, *(*TTcl_Channel)(unsafe.Pointer(bp + 48)), libc.Int32FromInt32(1)<<libc.Int32FromInt32(1), __ccgo_fp(_VwaitChannelReadProc), vwaitItems+uintptr(numItems)*24)
		(*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(numItems)*24))).FdonePtr = bp
		(*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(numItems)*24))).Fsequence = -int32(1)
		(*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(numItems)*24))).Fmask = libc.Int32FromInt32(1) << libc.Int32FromInt32(1)
		(*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(numItems)*24))).FsourceObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
		numItems++
		goto _14
	_13:
		;
		i++
		v21 = i
		if v21 >= objc {
			goto needArg
		}
		if XTclGetChannelFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp+48, bp+12, 0) != TCL_OK {
			result = int32(TCL_ERROR)
			goto done
		}
		if !(*(*int32)(unsafe.Pointer(bp + 12))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
				v22 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
			} else {
				v22 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+31239, libc.VaList(bp+840, v22)))
			result = int32(TCL_ERROR)
			goto done
		}
		XTcl_CreateChannelHandler(tls, *(*TTcl_Channel)(unsafe.Pointer(bp + 48)), libc.Int32FromInt32(1)<<libc.Int32FromInt32(2), __ccgo_fp(_VwaitChannelWriteProc), vwaitItems+uintptr(numItems)*24)
		(*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(numItems)*24))).FdonePtr = bp
		(*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(numItems)*24))).Fsequence = -int32(1)
		(*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(numItems)*24))).Fmask = libc.Int32FromInt32(1) << libc.Int32FromInt32(2)
		(*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(numItems)*24))).FsourceObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
		numItems++
		goto _14
	_14:
		;
		goto _1
	_1:
		;
		i++
	}
	goto endOfOptionLoop
endOfOptionLoop:
	;
	if mask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(3)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(5)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(4)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) == 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+31276, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+840, __ccgo_ts+2004, __ccgo_ts+31163, __ccgo_ts+31308, libc.UintptrFromInt32(0)))
		result = int32(TCL_ERROR)
		goto done
	}
	if *(*int32)(unsafe.Pointer(bp + 8)) > 0 && mask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(4)) == 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+31319, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+840, __ccgo_ts+2004, __ccgo_ts+31163, __ccgo_ts+31364, libc.UintptrFromInt32(0)))
		result = int32(TCL_ERROR)
		goto done
	}
	result = TCL_OK
	for {
		if !(i < objc) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
			v24 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
		} else {
			v24 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		result = XTcl_TraceVar2(tls, interp, v24, libc.UintptrFromInt32(0), libc.Int32FromInt32(TCL_GLOBAL_ONLY)|libc.Int32FromInt32(TCL_TRACE_WRITES)|libc.Int32FromInt32(TCL_TRACE_UNSETS), __ccgo_fp(_VwaitVarProc), vwaitItems+uintptr(numItems)*24)
		if result != TCL_OK {
			break
		}
		(*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(numItems)*24))).FdonePtr = bp
		(*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(numItems)*24))).Fsequence = -int32(1)
		(*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(numItems)*24))).Fmask = 0
		(*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(numItems)*24))).FsourceObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
		numItems++
		goto _23
	_23:
		;
		i++
	}
	if result != TCL_OK {
		result = int32(TCL_ERROR)
		goto done
	}
	if !(mask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(3)) != 0) {
		i = 0
		for {
			if !(i < numItems) {
				break
			}
			if (*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(i)*24))).Fmask != 0 {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+31372, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+840, __ccgo_ts+2004, __ccgo_ts+31163, __ccgo_ts+31419, libc.UintptrFromInt32(0)))
				result = int32(TCL_ERROR)
				goto done
			}
			goto _25
		_25:
			;
			i++
		}
	}
	if *(*int32)(unsafe.Pointer(bp + 8)) > 0 {
		(*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(numItems)*24))).FdonePtr = bp + 4
		(*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(numItems)*24))).Fsequence = -int32(1)
		(*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(numItems)*24))).Fmask = 0
		(*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(numItems)*24))).FsourceObj = libc.UintptrFromInt32(0)
		timer = XTcl_CreateTimerHandler(tls, *(*int32)(unsafe.Pointer(bp + 8)), __ccgo_fp(_VwaitTimeoutProc), vwaitItems+uintptr(numItems)*24)
		XTcl_GetTime(tls, bp+16)
	} else {
		*(*int32)(unsafe.Pointer(bp + 8)) = 0
	}
	if numItems == 0 && *(*int32)(unsafe.Pointer(bp + 8)) == 0 {
		/*
		 * "vwait" is equivalent to "update",
		 * "vwait -nofileevents -notimerevents -nowindowevents"
		 * is equivalent to "update idletasks"
		 */
		any1 = int32(1)
		mask |= libc.Int32FromInt32(1) << libc.Int32FromInt32(1)
	}
	foundEvent = int32(1)
	for !(*(*int32)(unsafe.Pointer(bp + 4)) != 0) && foundEvent != 0 && (!(any1 != 0) && *(*int32)(unsafe.Pointer(bp)) < numItems || any1 != 0 && !(*(*int32)(unsafe.Pointer(bp)) != 0)) {
		foundEvent = XTcl_DoOneEvent(tls, mask)
		if XTcl_Canceled(tls, interp, int32(TCL_LEAVE_ERR_MSG)) == int32(TCL_ERROR) {
			break
		}
		if XTcl_LimitExceeded(tls, interp) != 0 {
			XTcl_ResetResult(tls, interp)
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+31433, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+840, __ccgo_ts+2004, __ccgo_ts+31163, __ccgo_ts+8338, libc.UintptrFromInt32(0)))
			break
		}
		if numItems == 0 && *(*int32)(unsafe.Pointer(bp + 8)) == 0 {
			/*
			 * Behavior like "update": clear interpreter's result because
			 * event handlers could have executed commands.
			 */
			XTcl_ResetResult(tls, interp)
			result = TCL_OK
			goto done
		}
	}
	if !(foundEvent != 0) {
		XTcl_ResetResult(tls, interp)
		if numItems == 0 {
			v26 = __ccgo_ts + 31448
		} else {
			v26 = __ccgo_ts + 31479
		}
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, v26, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+840, __ccgo_ts+2004, __ccgo_ts+31163, __ccgo_ts+31308, libc.UintptrFromInt32(0)))
		result = int32(TCL_ERROR)
		goto done
	}
	if !(*(*int32)(unsafe.Pointer(bp)) != 0) && !(*(*int32)(unsafe.Pointer(bp + 4)) != 0) {
		/*
		 * The interpreter's result was already set to the right error message
		 * prior to exiting the loop above.
		 */
		result = int32(TCL_ERROR)
		goto done
	}
	result = TCL_OK
	if *(*int32)(unsafe.Pointer(bp + 8)) <= 0 {
		/*
		 * Clear out the interpreter's result, since it may have been set
		 * by event handlers.
		 */
		XTcl_ResetResult(tls, interp)
		goto done
	}
	/*
	 * When timeout was specified, report milliseconds left or -1 on timeout.
	 */
	if *(*int32)(unsafe.Pointer(bp + 4)) != 0 {
		diff = int64(-int32(1))
	} else {
		XTcl_GetTime(tls, bp+32)
		diff = (*(*TTcl_Time)(unsafe.Pointer(bp + 32))).Fsec*int64(1000) + (*(*TTcl_Time)(unsafe.Pointer(bp + 32))).Fusec/int64(1000)
		diff -= (*(*TTcl_Time)(unsafe.Pointer(bp + 16))).Fsec*int64(1000) + (*(*TTcl_Time)(unsafe.Pointer(bp + 16))).Fusec/int64(1000)
		diff = int64(*(*int32)(unsafe.Pointer(bp + 8))) - diff
		if diff < 0 {
			diff = 0
		}
	}
	goto done
done:
	;
	if *(*int32)(unsafe.Pointer(bp + 8)) > 0 && timer != libc.UintptrFromInt32(0) {
		XTcl_DeleteTimerHandler(tls, timer)
	}
	if result != TCL_OK {
		saved = XTcl_SaveInterpState(tls, interp, result)
	}
	i = 0
	for {
		if !(i < numItems) {
			break
		}
		if (*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(i)*24))).Fmask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
			if XTclGetChannelFromObj(tls, interp, (*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(i)*24))).FsourceObj, bp+48, bp+12, 0) == TCL_OK {
				XTcl_DeleteChannelHandler(tls, *(*TTcl_Channel)(unsafe.Pointer(bp + 48)), __ccgo_fp(_VwaitChannelReadProc), vwaitItems+uintptr(i)*24)
			}
		} else {
			if (*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(i)*24))).Fmask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
				if XTclGetChannelFromObj(tls, interp, (*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(i)*24))).FsourceObj, bp+48, bp+12, 0) == TCL_OK {
					XTcl_DeleteChannelHandler(tls, *(*TTcl_Channel)(unsafe.Pointer(bp + 48)), __ccgo_fp(_VwaitChannelWriteProc), vwaitItems+uintptr(i)*24)
				}
			} else {
				if (*TTcl_Obj)(unsafe.Pointer((*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(i)*24))).FsourceObj)).Fbytes != 0 {
					v28 = (*TTcl_Obj)(unsafe.Pointer((*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(i)*24))).FsourceObj)).Fbytes
				} else {
					v28 = XTcl_GetStringFromObj(tls, (*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(i)*24))).FsourceObj, libc.UintptrFromInt32(0))
				}
				XTcl_UntraceVar2(tls, interp, v28, libc.UintptrFromInt32(0), libc.Int32FromInt32(TCL_GLOBAL_ONLY)|libc.Int32FromInt32(TCL_TRACE_WRITES)|libc.Int32FromInt32(TCL_TRACE_UNSETS), __ccgo_fp(_VwaitVarProc), vwaitItems+uintptr(i)*24)
			}
		}
		goto _27
	_27:
		;
		i++
	}
	if result == TCL_OK {
		if extended != 0 {
			if v29 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v29 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v29 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				listObj = XTclThreadAllocObj(tls)
			} else {
				listObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(listObj)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(listObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(listObj)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr = libc.UintptrFromInt32(0)
			k = 0
			for {
				if !(k < *(*int32)(unsafe.Pointer(bp))) {
					break
				}
				i = 0
				for {
					if !(i < numItems) {
						break
					}
					if (*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(i)*24))).Fsequence != k {
						goto _31
					}
					if (*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(i)*24))).Fmask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
						if v32 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v32 {
							cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v32 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
							keyObj = XTclThreadAllocObj(tls)
						} else {
							keyObj = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(keyObj + 32))).Fptr1
							(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
						}
						(*TTcl_Obj)(unsafe.Pointer(keyObj)).FrefCount = 0
						if libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1) == uint64(0) {
							(*TTcl_Obj)(unsafe.Pointer(keyObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
							(*TTcl_Obj)(unsafe.Pointer(keyObj)).Flength = int64(libc.Int32FromInt32(0))
						} else {
							(*TTcl_Obj)(unsafe.Pointer(keyObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
							libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(keyObj)).Fbytes, __ccgo_ts+5780, libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1))
							*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(keyObj)).Fbytes + uintptr(libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1)))) = uint8('\000')
							(*TTcl_Obj)(unsafe.Pointer(keyObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(9) - libc.Uint64FromInt32(1))
						}
						(*TTcl_Obj)(unsafe.Pointer(keyObj)).FtypePtr = libc.UintptrFromInt32(0)
					} else {
						if (*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(i)*24))).Fmask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
							if v33 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v33 {
								cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
							}
							if v33 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
								keyObj = XTclThreadAllocObj(tls)
							} else {
								keyObj = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
								(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer(keyObj + 32))).Fptr1
								(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
							}
							(*TTcl_Obj)(unsafe.Pointer(keyObj)).FrefCount = 0
							if libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1) == uint64(0) {
								(*TTcl_Obj)(unsafe.Pointer(keyObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
								(*TTcl_Obj)(unsafe.Pointer(keyObj)).Flength = int64(libc.Int32FromInt32(0))
							} else {
								(*TTcl_Obj)(unsafe.Pointer(keyObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
								libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(keyObj)).Fbytes, __ccgo_ts+5864, libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1))
								*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(keyObj)).Fbytes + uintptr(libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1)))) = uint8('\000')
								(*TTcl_Obj)(unsafe.Pointer(keyObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(9) - libc.Uint64FromInt32(1))
							}
							(*TTcl_Obj)(unsafe.Pointer(keyObj)).FtypePtr = libc.UintptrFromInt32(0)
						} else {
							if v34 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v34 {
								cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
							}
							if v34 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
								keyObj = XTclThreadAllocObj(tls)
							} else {
								keyObj = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
								(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer(keyObj + 32))).Fptr1
								(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
							}
							(*TTcl_Obj)(unsafe.Pointer(keyObj)).FrefCount = 0
							if libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1) == uint64(0) {
								(*TTcl_Obj)(unsafe.Pointer(keyObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
								(*TTcl_Obj)(unsafe.Pointer(keyObj)).Flength = int64(libc.Int32FromInt32(0))
							} else {
								(*TTcl_Obj)(unsafe.Pointer(keyObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
								libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(keyObj)).Fbytes, __ccgo_ts+3502, libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1))
								*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(keyObj)).Fbytes + uintptr(libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1)))) = uint8('\000')
								(*TTcl_Obj)(unsafe.Pointer(keyObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(9) - libc.Uint64FromInt32(1))
							}
							(*TTcl_Obj)(unsafe.Pointer(keyObj)).FtypePtr = libc.UintptrFromInt32(0)
						}
					}
					XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listObj, keyObj)
					XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listObj, (*(*TVwaitItem)(unsafe.Pointer(vwaitItems + uintptr(i)*24))).FsourceObj)
					goto _31
				_31:
					;
					i++
				}
				goto _30
			_30:
				;
				k++
			}
			if *(*int32)(unsafe.Pointer(bp + 8)) > 0 {
				if v35 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v35 {
					cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v35 || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == libc.Uint64FromInt32(0) {
					keyObj = XTclThreadAllocObj(tls)
				} else {
					keyObj = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(keyObj + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(keyObj)).FrefCount = 0
				if libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1) == uint64(0) {
					(*TTcl_Obj)(unsafe.Pointer(keyObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(keyObj)).Flength = int64(libc.Int32FromInt32(0))
				} else {
					(*TTcl_Obj)(unsafe.Pointer(keyObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
					libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(keyObj)).Fbytes, __ccgo_ts+31537, libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1))
					*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(keyObj)).Fbytes + uintptr(libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1)))) = uint8('\000')
					(*TTcl_Obj)(unsafe.Pointer(keyObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(9) - libc.Uint64FromInt32(1))
				}
				(*TTcl_Obj)(unsafe.Pointer(keyObj)).FtypePtr = libc.UintptrFromInt32(0)
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listObj, keyObj)
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listObj, XTcl_NewWideIntObj(tls, diff))
			}
			XTcl_SetObjResult(tls, interp, listObj)
		} else {
			if *(*int32)(unsafe.Pointer(bp + 8)) > 0 {
				XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, diff))
			}
		}
	} else {
		result = XTcl_RestoreInterpState(tls, interp, saved)
	}
	if vwaitItems != bp+56 {
		XTclpFree(tls, vwaitItems)
	}
	return result
}

var _vWaitOptionStrings = [12]uintptr{
	0:  __ccgo_ts + 17462,
	1:  __ccgo_ts + 31028,
	2:  __ccgo_ts + 31038,
	3:  __ccgo_ts + 31052,
	4:  __ccgo_ts + 31066,
	5:  __ccgo_ts + 31081,
	6:  __ccgo_ts + 31097,
	7:  __ccgo_ts + 31107,
	8:  __ccgo_ts + 31116,
	9:  __ccgo_ts + 31126,
	10: __ccgo_ts + 18684,
	11: libc.UintptrFromInt32(0),
}

func _VwaitChannelReadProc(tls *libc.TLS, clientData uintptr, mask int32) {
	/* Event mask, must be TCL_READABLE. */
	var itemPtr uintptr
	_ = itemPtr
	itemPtr = clientData
	if !(mask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0) {
		return
	}
	if (*TVwaitItem)(unsafe.Pointer(itemPtr)).FdonePtr != libc.UintptrFromInt32(0) {
		(*TVwaitItem)(unsafe.Pointer(itemPtr)).Fsequence = *(*int32)(unsafe.Pointer((*TVwaitItem)(unsafe.Pointer(itemPtr)).FdonePtr))
		*(*int32)(unsafe.Pointer((*TVwaitItem)(unsafe.Pointer(itemPtr)).FdonePtr)) += int32(1)
		(*TVwaitItem)(unsafe.Pointer(itemPtr)).FdonePtr = libc.UintptrFromInt32(0)
	}
}

func _VwaitChannelWriteProc(tls *libc.TLS, clientData uintptr, mask int32) {
	/* Event mask, must be TCL_WRITABLE. */
	var itemPtr uintptr
	_ = itemPtr
	itemPtr = clientData
	if !(mask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0) {
		return
	}
	if (*TVwaitItem)(unsafe.Pointer(itemPtr)).FdonePtr != libc.UintptrFromInt32(0) {
		(*TVwaitItem)(unsafe.Pointer(itemPtr)).Fsequence = *(*int32)(unsafe.Pointer((*TVwaitItem)(unsafe.Pointer(itemPtr)).FdonePtr))
		*(*int32)(unsafe.Pointer((*TVwaitItem)(unsafe.Pointer(itemPtr)).FdonePtr)) += int32(1)
		(*TVwaitItem)(unsafe.Pointer(itemPtr)).FdonePtr = libc.UintptrFromInt32(0)
	}
}

func _VwaitTimeoutProc(tls *libc.TLS, clientData uintptr) {
	/* Pointer to vwait info record. */
	var itemPtr uintptr
	_ = itemPtr
	itemPtr = clientData
	if (*TVwaitItem)(unsafe.Pointer(itemPtr)).FdonePtr != libc.UintptrFromInt32(0) {
		*(*int32)(unsafe.Pointer((*TVwaitItem)(unsafe.Pointer(itemPtr)).FdonePtr)) = int32(1)
		(*TVwaitItem)(unsafe.Pointer(itemPtr)).FdonePtr = libc.UintptrFromInt32(0)
	}
}

func _VwaitVarProc(tls *libc.TLS, clientData uintptr, interp uintptr, name1 uintptr, name2 uintptr, dummy1916 int32) (r uintptr) {
	/* Information about what happened. */
	var itemPtr uintptr
	_ = itemPtr
	itemPtr = clientData
	if (*TVwaitItem)(unsafe.Pointer(itemPtr)).FdonePtr != libc.UintptrFromInt32(0) {
		(*TVwaitItem)(unsafe.Pointer(itemPtr)).Fsequence = *(*int32)(unsafe.Pointer((*TVwaitItem)(unsafe.Pointer(itemPtr)).FdonePtr))
		*(*int32)(unsafe.Pointer((*TVwaitItem)(unsafe.Pointer(itemPtr)).FdonePtr)) += int32(1)
		(*TVwaitItem)(unsafe.Pointer(itemPtr)).FdonePtr = libc.UintptrFromInt32(0)
	}
	XTcl_UntraceVar2(tls, interp, name1, name2, libc.Int32FromInt32(TCL_TRACE_WRITES)|libc.Int32FromInt32(TCL_TRACE_UNSETS), __ccgo_fp(_VwaitVarProc), clientData)
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UpdateObjCmd --
 *
 *	This function is invoked to process the "update" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UpdateObjCmd(tls *libc.TLS, dummy1949 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var flags int32
	var _ /* optionIndex at bp+0 */ int32
	_ = flags
	flags = 0 /* Initialized to avoid compiler warning. */
	if objc == int32(1) {
		flags = ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(1)) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)
	} else {
		if objc == int32(2) {
			if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), uintptr(unsafe.Pointer(&_updateOptions)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
				return int32(TCL_ERROR)
			}
			switch *(*int32)(unsafe.Pointer(bp)) {
			case 0:
				flags = libc.Int32FromInt32(1)<<libc.Int32FromInt32(5) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)
			default:
				XTcl_Panic(tls, __ccgo_ts+31556, 0)
			}
		} else {
			XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+31608)
			return int32(TCL_ERROR)
		}
	}
	for XTcl_DoOneEvent(tls, flags) != 0 {
		if XTcl_Canceled(tls, interp, int32(TCL_LEAVE_ERR_MSG)) == int32(TCL_ERROR) {
			return int32(TCL_ERROR)
		}
		if XTcl_LimitExceeded(tls, interp) != 0 {
			XTcl_ResetResult(tls, interp)
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+31433, int64(-int32(1))))
			return int32(TCL_ERROR)
		}
	}
	/*
	 * Must clear the interpreter's result because event handlers could have
	 * executed commands.
	 */
	XTcl_ResetResult(tls, interp)
	return TCL_OK
}

var _updateOptions = [2]uintptr{
	0: __ccgo_ts + 31546,
	1: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * NewThreadProc --
 *
 *	Bootstrap function of a new Tcl thread.
 *
 * Results:
 *	None.
 *
 * Side Effects:
 *	Initializes Tcl notifier for the current thread.
 *
 *----------------------------------------------------------------------
 */

func _NewThreadProc(tls *libc.TLS, clientData uintptr) {
	var cdPtr, threadClientData, threadProc uintptr
	_, _, _ = cdPtr, threadClientData, threadProc
	cdPtr = clientData
	threadProc = (*TThreadClientData)(unsafe.Pointer(cdPtr)).Fproc
	threadClientData = (*TThreadClientData)(unsafe.Pointer(cdPtr)).FclientData
	XTclpFree(tls, clientData) /* Allocated in Tcl_CreateThread() */
	(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{threadProc})))(tls, threadClientData)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_CreateThread --
 *
 *	This function creates a new thread. This actually belongs to the
 *	tclThread.c file but since we use some private data structures local
 *	to this file, it is placed here.
 *
 * Results:
 *	TCL_OK if the thread could be created. The thread ID is returned in a
 *	parameter.
 *
 * Side effects:
 *	A new thread is created.
 *
 *----------------------------------------------------------------------
 */

func XTcl_CreateThread(tls *libc.TLS, idPtr uintptr, proc uintptr, clientData uintptr, stackSize Tsize_t, flags int32) (r int32) {
	/* Flags controlling behaviour of the new
	 * thread. */
	var cdPtr uintptr
	var result int32
	_, _ = cdPtr, result
	cdPtr = XTcl_Alloc(tls, uint64(16))
	(*TThreadClientData)(unsafe.Pointer(cdPtr)).Fproc = proc
	(*TThreadClientData)(unsafe.Pointer(cdPtr)).FclientData = clientData
	result = XTclpThreadCreate(tls, idPtr, __ccgo_fp(_NewThreadProc), cdPtr, stackSize, flags)
	if result != TCL_OK {
		XTclpFree(tls, cdPtr)
	}
	return result
}

const ASYNC_CHECK_COUNT = 64
const CURR_DEPTH = 0
const DIVIDED_BY_ZERO = -1
const EXPONENT_OF_ZERO = -2
const GENERAL_ARITHMETIC_ERROR = -3
const OBJ_AT_TOS = 0
const OUT_OF_MEMORY = -4
const TCL_PATCH_LEVEL2 = "9.0.1"
const WALLOCALIGN = 0

/*
 * Hack to determine whether we may expect IEEE floating point. The hack is
 * formally incorrect in that non-IEEE platforms might have the same precision
 * and range, but VAX, IBM, and Cray do not; are there any other floating
 * point units that we might care about?
 */

/*
 * A counter that is used to work out when the bytecode engine should call
 * Tcl_AsyncReady() to see whether there is a signal that needs handling, and
 * other expensive periodic operations.
 */

/*
 * Boolean flag indicating whether the Tcl bytecode interpreter has been
 * initialized.
 */

var _execInitialized = int32(0)

var _execMutex TTcl_Mutex

var _cachedInExit = int32(0)

/*
 * Mapping from expression instruction opcodes to strings; used for error
 * messages. Note that these entries must match the order and number of the
 * expression opcodes (e.g., INST_LOR) in tclCompile.h.
 *
 * Does not include the string for INST_EXPON (and beyond), as that is
 * disjoint for backward-compatibility reasons.
 */

var _operatorStrings = [20]uintptr{
	0:  __ccgo_ts + 6239,
	1:  __ccgo_ts + 6241,
	2:  __ccgo_ts + 6237,
	3:  __ccgo_ts + 6351,
	4:  __ccgo_ts + 6284,
	5:  __ccgo_ts + 6341,
	6:  __ccgo_ts + 6346,
	7:  __ccgo_ts + 6343,
	8:  __ccgo_ts + 6348,
	9:  __ccgo_ts + 6246,
	10: __ccgo_ts + 6263,
	11: __ccgo_ts + 6233,
	12: __ccgo_ts + 6319,
	13: __ccgo_ts + 6235,
	14: __ccgo_ts + 6339,
	15: __ccgo_ts + 6266,
	16: __ccgo_ts + 6233,
	17: __ccgo_ts + 6319,
	18: __ccgo_ts + 6221,
	19: __ccgo_ts + 6231,
}

/*
 * Mapping from Tcl result codes to strings; used for error and debugging
 * messages.
 */

/*
 * These are used by evalstats to monitor object usage in Tcl.
 */

/*
 * NR_TEBC
 * Helpers for NR - non-recursive calls to TEBC
 * Minimal data required to fully reconstruct the execution state.
 */

type TTEBCdata = struct {
	FcodePtr    uintptr
	FcatchTop   uintptr
	FauxObjList uintptr
	FcmdFrame   TCmdFrame
	Fstack      [1]uintptr
}

/*
 * These variable-access macros have to coincide with those in tclVar.c
 */

func _VarHashCreateVar(tls *libc.TLS, tablePtr uintptr, key uintptr, newPtr uintptr) (r uintptr) {
	var hPtr uintptr
	_ = hPtr
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FcreateProc})))(tls, tablePtr, key, newPtr)
	if !(hPtr != 0) {
		return libc.UintptrFromInt32(0)
	}
	return hPtr - uintptr(uint64(libc.UintptrFromInt32(0)+24))
}

/*
 * The new macro for ending an instruction; note that a reasonable C-optimiser
 * will resolve all branches at compile time. (result) is always a constant;
 * the macro NEXT_INST_F handles constant (nCleanup), NEXT_INST_V is resolved
 * at runtime for variable (nCleanup).
 *
 * ARGUMENTS:
 *    pcAdjustment: how much to increment pc
 *    nCleanup: how many objects to remove from the stack
 *    resultHandling: 0 indicates no object should be pushed on the stack;
 *	otherwise, push objResultPtr. If (result < 0), objResultPtr already
 *	has the correct reference count.
 *
 * We use the new compile-time assertions to check that nCleanup is constant
 * and within range.
 */

/* Verify the stack depth, only when no expansion is in progress */

/*
 * Macros used to cache often-referenced Tcl evaluation stack information
 * in local variables. Note that a DECACHE_STACK_INFO()-CACHE_STACK_INFO()
 * pair must surround any call inside TclNRExecuteByteCode (and a few other
 * procedures that use this scheme) that could result in a recursive call
 * to TclNRExecuteByteCode.
 */

/*
 * Macros used to access items on the Tcl evaluation stack. PUSH_OBJECT
 * increments the object's ref count since it makes the stack have another
 * reference pointing to the object. However, POP_OBJECT does not decrement
 * the ref count. This is because the stack may hold the only reference to the
 * object, so the object would be destroyed if its ref count were decremented
 * before the caller had a chance to, e.g., store it in a variable. It is the
 * caller's responsibility to decrement the ref count when it is finished with
 * an object.
 *
 * WARNING! It is essential that objPtr only appear once in the PUSH_OBJECT
 * macro. The actual parameter might be an expression with side effects, and
 * this ensures that it will be executed only once.
 */

/*
 * Macros used to trace instruction execution. The macros TRACE,
 * TRACE_WITH_OBJ, and O2S are only used inside TclNRExecuteByteCode. O2S is
 * only used in TRACE* calls to get a string from an object.
 */

/*
 * DTrace instruction probe macros.
 */

/*
 * Macro used in this file to save a function call for common uses of
 * Tcl_GetNumberFromObj(). The ANSI C "prototype" is:
 *
 * MODULE_SCOPE int GetNumberFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
 *			void **ptrPtr, int *tPtr);
 */

/*
 * Macro used to make the check for type overflow more mnemonic. This works by
 * comparing sign bits; the rest of the word is irrelevant. The ANSI C
 * "prototype" (where inttype_t is any integer type) is:
 *
 * MODULE_SCOPE int Overflowing(inttype_t a, inttype_t b, inttype_t sum);
 *
 * Check first the condition most likely to fail in usual code (at least for
 * usage in [incr]: do the first summand and the sum have != signs?
 */

/*
 * Macro for checking whether the type is NaN, used when we're thinking about
 * throwing an error for supplying a non-number number.
 */

/*
 * Auxiliary tables used to compute powers of small integers.
 */

/*
 * Maximum base that, when raised to powers 2, 3, ..., 16, fits in a
 * Tcl_WideInt.
 */

var _MaxBase64 = [15]TTcl_WideInt{
	0:  libc.Int64FromInt32(46340)*libc.Int64FromInt32(65536) + libc.Int64FromInt32(62259),
	1:  libc.Int64FromInt32(2097151),
	2:  libc.Int64FromInt32(55108),
	3:  libc.Int64FromInt32(6208),
	4:  libc.Int64FromInt32(1448),
	5:  libc.Int64FromInt32(511),
	6:  libc.Int64FromInt32(234),
	7:  libc.Int64FromInt32(127),
	8:  libc.Int64FromInt32(78),
	9:  libc.Int64FromInt32(52),
	10: libc.Int64FromInt32(38),
	11: libc.Int64FromInt32(28),
	12: libc.Int64FromInt32(22),
	13: libc.Int64FromInt32(18),
	14: libc.Int64FromInt32(15),
}
var _MaxBase64Size = libc.Uint64FromInt64(120) / libc.Uint64FromInt64(8)

/*
 * Table giving 3, 4, ..., 13 raised to powers greater than 16 when the
 * results fit in a 64-bit signed integer.
 */

var _Exp64Index = [12]uint16{
	1:  uint16(23),
	2:  uint16(38),
	3:  uint16(49),
	4:  uint16(57),
	5:  uint16(63),
	6:  uint16(67),
	7:  uint16(70),
	8:  uint16(72),
	9:  uint16(74),
	10: uint16(75),
	11: uint16(76),
}
var _Exp64IndexSize = libc.Uint64FromInt64(24) / libc.Uint64FromInt64(2)
var _Exp64Value = [76]TTcl_WideInt{
	0:  libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3),
	1:  libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3),
	2:  libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3),
	3:  libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243),
	4:  libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(3),
	5:  libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3),
	6:  libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3),
	7:  libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3),
	8:  libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243),
	9:  libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(3),
	10: libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3),
	11: libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3),
	12: libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3),
	13: libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243),
	14: libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(3),
	15: libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3),
	16: libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3),
	17: libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3),
	18: libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243),
	19: libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(3),
	20: libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3),
	21: libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3),
	22: libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(243) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3) * libc.Int64FromInt32(3),
	23: libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(4) * libc.Int64FromInt32(4),
	24: libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(4) * libc.Int64FromInt32(4) * libc.Int64FromInt32(4),
	25: libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(4) * libc.Int64FromInt32(4) * libc.Int64FromInt32(4) * libc.Int64FromInt32(4),
	26: libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024),
	27: libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(4),
	28: libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(4) * libc.Int64FromInt32(4),
	29: libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(4) * libc.Int64FromInt32(4) * libc.Int64FromInt32(4),
	30: libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(4) * libc.Int64FromInt32(4) * libc.Int64FromInt32(4) * libc.Int64FromInt32(4),
	31: libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024),
	32: libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(4),
	33: libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(4) * libc.Int64FromInt32(4),
	34: libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(4) * libc.Int64FromInt32(4) * libc.Int64FromInt32(4),
	35: libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(4) * libc.Int64FromInt32(4) * libc.Int64FromInt32(4) * libc.Int64FromInt32(4),
	36: libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024),
	37: libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(1024) * libc.Int64FromInt32(4),
	38: libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(5) * libc.Int64FromInt32(5),
	39: libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(5) * libc.Int64FromInt32(5) * libc.Int64FromInt32(5),
	40: libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(5) * libc.Int64FromInt32(5) * libc.Int64FromInt32(5) * libc.Int64FromInt32(5),
	41: libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125),
	42: libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(5),
	43: libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(5) * libc.Int64FromInt32(5),
	44: libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(5) * libc.Int64FromInt32(5) * libc.Int64FromInt32(5),
	45: libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(5) * libc.Int64FromInt32(5) * libc.Int64FromInt32(5) * libc.Int64FromInt32(5),
	46: libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125),
	47: libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(5),
	48: libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(3125) * libc.Int64FromInt32(5) * libc.Int64FromInt32(5),
	49: libc.Int64FromInt32(7776) * libc.Int64FromInt32(7776) * libc.Int64FromInt32(7776) * libc.Int64FromInt32(6) * libc.Int64FromInt32(6),
	50: libc.Int64FromInt32(7776) * libc.Int64FromInt32(7776) * libc.Int64FromInt32(7776) * libc.Int64FromInt32(6) * libc.Int64FromInt32(6) * libc.Int64FromInt32(6),
	51: libc.Int64FromInt32(7776) * libc.Int64FromInt32(7776) * libc.Int64FromInt32(7776) * libc.Int64FromInt32(6) * libc.Int64FromInt32(6) * libc.Int64FromInt32(6) * libc.Int64FromInt32(6),
	52: libc.Int64FromInt32(7776) * libc.Int64FromInt32(7776) * libc.Int64FromInt32(7776) * libc.Int64FromInt32(7776),
	53: libc.Int64FromInt32(7776) * libc.Int64FromInt32(7776) * libc.Int64FromInt32(7776) * libc.Int64FromInt32(7776) * libc.Int64FromInt32(6),
	54: libc.Int64FromInt32(7776) * libc.Int64FromInt32(7776) * libc.Int64FromInt32(7776) * libc.Int64FromInt32(7776) * libc.Int64FromInt32(6) * libc.Int64FromInt32(6),
	55: libc.Int64FromInt32(7776) * libc.Int64FromInt32(7776) * libc.Int64FromInt32(7776) * libc.Int64FromInt32(7776) * libc.Int64FromInt32(6) * libc.Int64FromInt32(6) * libc.Int64FromInt32(6),
	56: libc.Int64FromInt32(7776) * libc.Int64FromInt32(7776) * libc.Int64FromInt32(7776) * libc.Int64FromInt32(7776) * libc.Int64FromInt32(6) * libc.Int64FromInt32(6) * libc.Int64FromInt32(6) * libc.Int64FromInt32(6),
	57: libc.Int64FromInt32(16807) * libc.Int64FromInt32(16807) * libc.Int64FromInt32(16807) * libc.Int64FromInt32(7) * libc.Int64FromInt32(7),
	58: libc.Int64FromInt32(16807) * libc.Int64FromInt32(16807) * libc.Int64FromInt32(16807) * libc.Int64FromInt32(7) * libc.Int64FromInt32(7) * libc.Int64FromInt32(7),
	59: libc.Int64FromInt32(16807) * libc.Int64FromInt32(16807) * libc.Int64FromInt32(16807) * libc.Int64FromInt32(7) * libc.Int64FromInt32(7) * libc.Int64FromInt32(7) * libc.Int64FromInt32(7),
	60: libc.Int64FromInt32(16807) * libc.Int64FromInt32(16807) * libc.Int64FromInt32(16807) * libc.Int64FromInt32(16807),
	61: libc.Int64FromInt32(16807) * libc.Int64FromInt32(16807) * libc.Int64FromInt32(16807) * libc.Int64FromInt32(16807) * libc.Int64FromInt32(7),
	62: libc.Int64FromInt32(16807) * libc.Int64FromInt32(16807) * libc.Int64FromInt32(16807) * libc.Int64FromInt32(16807) * libc.Int64FromInt32(7) * libc.Int64FromInt32(7),
	63: libc.Int64FromInt32(32768) * libc.Int64FromInt32(32768) * libc.Int64FromInt32(32768) * libc.Int64FromInt32(8) * libc.Int64FromInt32(8),
	64: libc.Int64FromInt32(32768) * libc.Int64FromInt32(32768) * libc.Int64FromInt32(32768) * libc.Int64FromInt32(8) * libc.Int64FromInt32(8) * libc.Int64FromInt32(8),
	65: libc.Int64FromInt32(32768) * libc.Int64FromInt32(32768) * libc.Int64FromInt32(32768) * libc.Int64FromInt32(8) * libc.Int64FromInt32(8) * libc.Int64FromInt32(8) * libc.Int64FromInt32(8),
	66: libc.Int64FromInt32(32768) * libc.Int64FromInt32(32768) * libc.Int64FromInt32(32768) * libc.Int64FromInt32(32768),
	67: libc.Int64FromInt32(59049) * libc.Int64FromInt32(59049) * libc.Int64FromInt32(59049) * libc.Int64FromInt32(9) * libc.Int64FromInt32(9),
	68: libc.Int64FromInt32(59049) * libc.Int64FromInt32(59049) * libc.Int64FromInt32(59049) * libc.Int64FromInt32(9) * libc.Int64FromInt32(9) * libc.Int64FromInt32(9),
	69: libc.Int64FromInt32(59049) * libc.Int64FromInt32(59049) * libc.Int64FromInt32(59049) * libc.Int64FromInt32(9) * libc.Int64FromInt32(9) * libc.Int64FromInt32(9) * libc.Int64FromInt32(9),
	70: libc.Int64FromInt32(100000) * libc.Int64FromInt32(100000) * libc.Int64FromInt32(100000) * libc.Int64FromInt32(10) * libc.Int64FromInt32(10),
	71: libc.Int64FromInt32(100000) * libc.Int64FromInt32(100000) * libc.Int64FromInt32(100000) * libc.Int64FromInt32(10) * libc.Int64FromInt32(10) * libc.Int64FromInt32(10),
	72: libc.Int64FromInt32(161051) * libc.Int64FromInt32(161051) * libc.Int64FromInt32(161051) * libc.Int64FromInt32(11) * libc.Int64FromInt32(11),
	73: libc.Int64FromInt32(161051) * libc.Int64FromInt32(161051) * libc.Int64FromInt32(161051) * libc.Int64FromInt32(11) * libc.Int64FromInt32(11) * libc.Int64FromInt32(11),
	74: libc.Int64FromInt32(248832) * libc.Int64FromInt32(248832) * libc.Int64FromInt32(248832) * libc.Int64FromInt32(12) * libc.Int64FromInt32(12),
	75: libc.Int64FromInt32(371293) * libc.Int64FromInt32(371293) * libc.Int64FromInt32(371293) * libc.Int64FromInt32(13) * libc.Int64FromInt32(13),
}
var _Exp64ValueSize = libc.Uint64FromInt64(608) / libc.Uint64FromInt64(8)

func init() {
	p := unsafe.Pointer(&XtclExprCodeType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_FreeExprCodeInternalRep)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_DupExprCodeInternalRep)
}

/*
 * Custom object type only used in this file; values of its type should never
 * be seen by user scripts.
 */

var _dictIteratorType = TTcl_ObjType{
	Fname: __ccgo_ts + 31629,
}

func init() {
	p := unsafe.Pointer(&_dictIteratorType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_ReleaseDictIterator)
}

/*
 *----------------------------------------------------------------------
 *
 * ReleaseDictIterator --
 *
 *	This takes apart a dictionary iterator that is stored in the given Tcl
 *	object.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Deallocates memory, marks the object as being untyped.
 *
 *----------------------------------------------------------------------
 */

func _ReleaseDictIterator(tls *libc.TLS, objPtr uintptr) {
	var cachePtr, dictPtr, irPtr, searchPtr, v1, v3 uintptr
	var v2 TTcl_Size
	var v4 bool
	_, _, _, _, _, _, _, _ = cachePtr, dictPtr, irPtr, searchPtr, v1, v2, v3, v4
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_dictIteratorType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	/*
	 * First kill the search, and then release the reference to the dictionary
	 * that we were holding.
	 */
	searchPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(irPtr))).Fptr1
	XTcl_DictObjDone(tls, searchPtr)
	XTclpFree(tls, searchPtr)
	dictPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(irPtr))).Fptr2
	v3 = dictPtr
	v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
	*(*TTcl_Size)(unsafe.Pointer(v3))--
	if !(v2 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Flength = int64(-libc.Int32FromInt32(1))
			if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v4 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, dictPtr)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(dictPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = dictPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, dictPtr)
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * InitByteCodeExecution --
 *
 *	This procedure is called once to initialize the Tcl bytecode
 *	interpreter.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	This procedure initializes the array of instruction names. If
 *	compiling with the TCL_COMPILE_STATS flag, it initializes the array
 *	that counts the executions of each instruction and it creates the
 *	"evalstats" command. It also establishes the link between the Tcl
 *	"tcl_traceExec" and C "tclTraceExec" variables.
 *
 *----------------------------------------------------------------------
 */

func _InitByteCodeExecution(tls *libc.TLS, dummy767 uintptr) {
}

/*
 *----------------------------------------------------------------------
 *
 * TclCreateExecEnv --
 *
 *	This procedure creates a new execution environment for Tcl bytecode
 *	execution. An ExecEnv points to a Tcl evaluation stack. An ExecEnv is
 *	typically created once for each Tcl interpreter (Interp structure) and
 *	recursively passed to TclNRExecuteByteCode to execute ByteCode sequences
 *	for nested commands.
 *
 * Results:
 *	A newly allocated ExecEnv is returned. This points to an empty
 *	evaluation stack of the standard initial size.
 *
 * Side effects:
 *	The bytecode interpreter is also initialized here, as this procedure
 *	will be called before any call to TclNRExecuteByteCode.
 *
 *----------------------------------------------------------------------
 */

func XTclCreateExecEnv(tls *libc.TLS, interp uintptr, size Tsize_t) (r uintptr) {
	/* The initial stack size, in number of words
	 * [sizeof(Tcl_Obj*)] */
	var cachePtr, cachePtr1, eePtr, esPtr uintptr
	var v1, v2 bool
	_, _, _, _, _, _ = cachePtr, cachePtr1, eePtr, esPtr, v1, v2
	eePtr = XTcl_Alloc(tls, uint64(56))
	esPtr = XTcl_Alloc(tls, uint64(libc.UintptrFromInt32(0)+40)+size*uint64(8))
	(*TExecEnv)(unsafe.Pointer(eePtr)).FexecStackPtr = esPtr
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		*(*uintptr)(unsafe.Pointer(eePtr + 8)) = XTclThreadAllocObj(tls)
	} else {
		*(*uintptr)(unsafe.Pointer(eePtr + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(eePtr + 8)) + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(eePtr + 8)))).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(eePtr + 8)))).Fbytes = libc.UintptrFromInt32(0)
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(eePtr + 8)))).FinternalRep)) = int64(libc.Int32FromInt32(0))
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(eePtr + 8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(eePtr + 8)))).FrefCount++
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		*(*uintptr)(unsafe.Pointer(eePtr + 8 + 1*8)) = XTclThreadAllocObj(tls)
	} else {
		*(*uintptr)(unsafe.Pointer(eePtr + 8 + 1*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(eePtr + 8 + 1*8)) + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(eePtr + 8 + 1*8)))).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(eePtr + 8 + 1*8)))).Fbytes = libc.UintptrFromInt32(0)
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(eePtr + 8 + 1*8)))).FinternalRep)) = int64(libc.Int32FromInt32(1))
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(eePtr + 8 + 1*8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(eePtr + 8 + 1*8)))).FrefCount++
	(*TExecEnv)(unsafe.Pointer(eePtr)).Finterp = interp
	(*TExecEnv)(unsafe.Pointer(eePtr)).FcallbackPtr = libc.UintptrFromInt32(0)
	(*TExecEnv)(unsafe.Pointer(eePtr)).FcorPtr = libc.UintptrFromInt32(0)
	(*TExecEnv)(unsafe.Pointer(eePtr)).Frewind = 0
	(*TExecStack)(unsafe.Pointer(esPtr)).FprevPtr = libc.UintptrFromInt32(0)
	(*TExecStack)(unsafe.Pointer(esPtr)).FnextPtr = libc.UintptrFromInt32(0)
	(*TExecStack)(unsafe.Pointer(esPtr)).FmarkerPtr = libc.UintptrFromInt32(0)
	(*TExecStack)(unsafe.Pointer(esPtr)).FendPtr = esPtr + 40 + uintptr(size-uint64(1))*8
	(*TExecStack)(unsafe.Pointer(esPtr)).FtosPtr = esPtr + 40 - libc.UintptrFromInt32(1)*8
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_execMutex)))
	if !(_execInitialized != 0) {
		_InitByteCodeExecution(tls, interp)
		_execInitialized = int32(1)
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_execMutex)))
	return eePtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclDeleteExecEnv --
 *
 *	Frees the storage for an ExecEnv.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Storage for an ExecEnv and its contained storage (e.g. the evaluation
 *	stack) is freed.
 *
 *----------------------------------------------------------------------
 */

func _DeleteExecStack(tls *libc.TLS, esPtr uintptr) {
	if (*TExecStack)(unsafe.Pointer(esPtr)).FmarkerPtr != 0 && !(_cachedInExit != 0) {
		XTcl_Panic(tls, __ccgo_ts+31642, 0)
	}
	if (*TExecStack)(unsafe.Pointer(esPtr)).FprevPtr != 0 {
		(*TExecStack1)(unsafe.Pointer((*TExecStack)(unsafe.Pointer(esPtr)).FprevPtr)).FnextPtr = (*TExecStack)(unsafe.Pointer(esPtr)).FnextPtr
	}
	if (*TExecStack)(unsafe.Pointer(esPtr)).FnextPtr != 0 {
		(*TExecStack1)(unsafe.Pointer((*TExecStack)(unsafe.Pointer(esPtr)).FnextPtr)).FprevPtr = (*TExecStack)(unsafe.Pointer(esPtr)).FprevPtr
	}
	XTclpFree(tls, esPtr)
}

func XTclDeleteExecEnv(tls *libc.TLS, eePtr uintptr) {
	/* Execution environment to free. */
	var cachePtr, cachePtr1, esPtr, tmpPtr, v2, v5 uintptr
	var v1, v4 TTcl_Size
	var v3, v6 bool
	_, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, esPtr, tmpPtr, v1, v2, v3, v4, v5, v6
	esPtr = (*TExecEnv)(unsafe.Pointer(eePtr)).FexecStackPtr
	_cachedInExit = XTclInExit(tls)
	/*
	 * Delete all stacks in this exec env.
	 */
	for (*TExecStack)(unsafe.Pointer(esPtr)).FnextPtr != 0 {
		esPtr = (*TExecStack)(unsafe.Pointer(esPtr)).FnextPtr
	}
	for esPtr != 0 {
		tmpPtr = esPtr
		esPtr = (*TExecStack)(unsafe.Pointer(tmpPtr)).FprevPtr
		_DeleteExecStack(tls, tmpPtr)
	}
	v2 = *(*uintptr)(unsafe.Pointer(eePtr + 8))
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if !(v1 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(eePtr + 8)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(eePtr + 8)))).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(eePtr + 8)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(eePtr + 8)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(eePtr + 8)))).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(eePtr + 8)))).Flength = int64(-libc.Int32FromInt32(1))
			if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(eePtr + 8)))
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(eePtr + 8)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(eePtr + 8))
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(eePtr + 8)))
		}
	}
	v5 = *(*uintptr)(unsafe.Pointer(eePtr + 8 + 1*8))
	v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
	*(*TTcl_Size)(unsafe.Pointer(v5))--
	if !(v4 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(eePtr + 8 + 1*8)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(eePtr + 8 + 1*8)))).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(eePtr + 8 + 1*8)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(eePtr + 8 + 1*8)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(eePtr + 8 + 1*8)))).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(eePtr + 8 + 1*8)))).Flength = int64(-libc.Int32FromInt32(1))
			if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v6 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(eePtr + 8 + 1*8)))
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(eePtr + 8 + 1*8)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(eePtr + 8 + 1*8))
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(eePtr + 8 + 1*8)))
		}
	}
	if (*TExecEnv)(unsafe.Pointer(eePtr)).FcallbackPtr != 0 && !(_cachedInExit != 0) {
		XTcl_Panic(tls, __ccgo_ts+31685, 0)
	}
	if (*TExecEnv)(unsafe.Pointer(eePtr)).FcorPtr != 0 && !(_cachedInExit != 0) {
		XTcl_Panic(tls, __ccgo_ts+31731, 0)
	}
	XTclpFree(tls, eePtr)
}

/*
 *----------------------------------------------------------------------
 *
 * TclFinalizeExecution --
 *
 *	Finalizes the execution environment setup so that it can be later
 *	reinitialized.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	After this call, the next time TclCreateExecEnv will be called it will
 *	call InitByteCodeExecution.
 *
 *----------------------------------------------------------------------
 */

func XTclFinalizeExecution(tls *libc.TLS) {
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_execMutex)))
	_execInitialized = 0
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_execMutex)))
}

/*
 * Auxiliary code to insure that GrowEvaluationStack always returns correctly
 * aligned memory.
 *
 * WALLOCALIGN represents the alignment reqs in words, just as TCL_ALLOCALIGN
 * represents the reqs in bytes. This assumes that TCL_ALLOCALIGN is a
 * multiple of the wordsize 'sizeof(Tcl_Obj *)'.
 */

/*
 * wordSkip computes how many words have to be skipped until the next aligned
 * word. Note that we are only interested in the low order bits of ptr, so
 * that any possible information loss in PTR2INT is of no consequence.
 */

func _wordSkip(tls *libc.TLS, ptr uintptr) (r int32) {
	var base, mask int32
	_, _ = base, mask
	mask = libc.Int32FromUint64(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8) - libc.Uint64FromInt32(1))
	base = int32(int64(ptr) & int64(mask))
	return libc.Int32FromUint64((libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8) - libc.Uint64FromInt32(base)) / uint64(8))
}

/*
 * Given a marker, compute where the following aligned memory starts.
 */

/*
 *----------------------------------------------------------------------
 *
 * GrowEvaluationStack --
 *
 *	This procedure grows a Tcl evaluation stack stored in an ExecEnv,
 *	copying over the words since the last mark if so requested. A mark is
 *	set at the beginning of the new area when no copying is requested.
 *
 * Results:
 *	Returns a pointer to the first usable word in the (possibly) grown
 *	stack.
 *
 * Side effects:
 *	The size of the evaluation stack may be grown, a marker is set
 *
 *----------------------------------------------------------------------
 */

func _GrowEvaluationStack(tls *libc.TLS, eePtr uintptr, growth1 Tsize_t, move int32) (r uintptr) {
	/* 1 if move words since last marker. */
	var currElems, growth, moveWords, needed, newElems TTcl_Size
	var esPtr, markerPtr, memStart, oldPtr, tmpMarkerPtr uintptr
	var newBytes Tsize_t
	var offset int32
	_, _, _, _, _, _, _, _, _, _, _, _ = currElems, esPtr, growth, markerPtr, memStart, moveWords, needed, newBytes, newElems, offset, oldPtr, tmpMarkerPtr
	esPtr = (*TExecEnv)(unsafe.Pointer(eePtr)).FexecStackPtr
	oldPtr = libc.UintptrFromInt32(0)
	growth = libc.Int64FromUint64(growth1)
	needed = growth - (int64((*TExecStack)(unsafe.Pointer(esPtr)).FendPtr)-int64((*TExecStack)(unsafe.Pointer(esPtr)).FtosPtr))/8
	markerPtr = (*TExecStack)(unsafe.Pointer(esPtr)).FmarkerPtr
	moveWords = 0
	if move != 0 {
		if !(markerPtr != 0) {
			XTcl_Panic(tls, __ccgo_ts+31772, 0)
		}
		if needed <= 0 {
			return markerPtr + uintptr(_wordSkip(tls, markerPtr))*8
		}
	} else {
		tmpMarkerPtr = (*TExecStack)(unsafe.Pointer(esPtr)).FtosPtr + uintptr(1)*8
		offset = _wordSkip(tls, tmpMarkerPtr)
		if needed+int64(offset) < 0 {
			/*
			 * Put a marker pointing to the previous marker in this stack, and
			 * store it in esPtr as the current marker. Return a pointer to
			 * the start of aligned memory.
			 */
			(*TExecStack)(unsafe.Pointer(esPtr)).FmarkerPtr = tmpMarkerPtr
			memStart = tmpMarkerPtr + uintptr(offset)*8
			(*TExecStack)(unsafe.Pointer(esPtr)).FtosPtr = memStart - uintptr(1)*8
			*(*uintptr)(unsafe.Pointer((*TExecStack)(unsafe.Pointer(esPtr)).FmarkerPtr)) = markerPtr
			return memStart
		}
	}
	/*
	 * Reset move to hold the number of words to be moved to new stack (if
	 * any) and growth to hold the complete stack requirements: add one for
	 * the marker, (WALLOCALIGN-1) for the maximal possible offset.
	 */
	if move != 0 {
		moveWords = (int64((*TExecStack)(unsafe.Pointer(esPtr)).FtosPtr)-int64(markerPtr+uintptr(_wordSkip(tls, markerPtr))*8))/8 + int64(1)
	}
	needed = libc.Int64FromUint64(libc.Uint64FromInt64(growth+moveWords) + libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)/libc.Uint64FromInt64(8))
	/*
	 * Check if there is enough room in the next stack (if there is one, it
	 * should be both empty and the last one!)
	 */
	if (*TExecStack)(unsafe.Pointer(esPtr)).FnextPtr != 0 {
		oldPtr = esPtr
		esPtr = (*TExecStack)(unsafe.Pointer(oldPtr)).FnextPtr
		currElems = (int64((*TExecStack)(unsafe.Pointer(esPtr)).FendPtr) - int64(esPtr+40-libc.UintptrFromInt32(1)*8)) / 8
		if (*TExecStack)(unsafe.Pointer(esPtr)).FmarkerPtr != 0 || (*TExecStack)(unsafe.Pointer(esPtr)).FtosPtr != esPtr+40-libc.UintptrFromInt32(1)*8 {
			XTcl_Panic(tls, __ccgo_ts+31815, 0)
		}
		if (*TExecStack)(unsafe.Pointer(esPtr)).FnextPtr != 0 {
			XTcl_Panic(tls, __ccgo_ts+31852, 0)
		}
		if needed <= currElems {
			goto newStackReady
		}
		_DeleteExecStack(tls, esPtr)
		esPtr = oldPtr
	} else {
		currElems = (int64((*TExecStack)(unsafe.Pointer(esPtr)).FendPtr) - int64(esPtr+40-libc.UintptrFromInt32(1)*8)) / 8
	}
	/*
	 * We need to allocate a new stack! It needs to store 'growth' words,
	 * including the elements to be copied over and the new marker.
	 */
	newElems = int64(2) * currElems
	for needed > newElems {
		newElems *= int64(2)
	}
	newBytes = uint64(libc.UintptrFromInt32(0)+40) + libc.Uint64FromInt64(newElems)*uint64(8)
	oldPtr = esPtr
	esPtr = XTcl_Alloc(tls, newBytes)
	(*TExecStack)(unsafe.Pointer(oldPtr)).FnextPtr = esPtr
	(*TExecStack)(unsafe.Pointer(esPtr)).FprevPtr = oldPtr
	(*TExecStack)(unsafe.Pointer(esPtr)).FnextPtr = libc.UintptrFromInt32(0)
	(*TExecStack)(unsafe.Pointer(esPtr)).FendPtr = esPtr + 40 + uintptr(newElems-int64(1))*8
	goto newStackReady
newStackReady:
	;
	(*TExecEnv)(unsafe.Pointer(eePtr)).FexecStackPtr = esPtr
	/*
	 * Store a NULL marker at the beginning of the stack, to indicate that
	 * this is the first marker in this stack and that rewinding to here
	 * should actually be a return to the previous stack.
	 */
	*(*uintptr)(unsafe.Pointer(esPtr + 40)) = libc.UintptrFromInt32(0)
	(*TExecStack)(unsafe.Pointer(esPtr)).FmarkerPtr = esPtr + 40
	memStart = (*TExecStack)(unsafe.Pointer(esPtr)).FmarkerPtr + uintptr(_wordSkip(tls, (*TExecStack)(unsafe.Pointer(esPtr)).FmarkerPtr))*8
	(*TExecStack)(unsafe.Pointer(esPtr)).FtosPtr = memStart - uintptr(1)*8
	if move != 0 {
		libc.Xmemcpy(tls, memStart, markerPtr+uintptr(_wordSkip(tls, markerPtr))*8, libc.Uint64FromInt64(moveWords)*uint64(8))
		*(*uintptr)(unsafe.Pointer(esPtr + 32)) += uintptr(moveWords) * 8
		(*TExecStack)(unsafe.Pointer(oldPtr)).FmarkerPtr = *(*uintptr)(unsafe.Pointer(markerPtr))
		(*TExecStack)(unsafe.Pointer(oldPtr)).FtosPtr = markerPtr - uintptr(1)*8
	}
	/*
	 * Free the old stack if it is now unused.
	 */
	if !((*TExecStack)(unsafe.Pointer(oldPtr)).FmarkerPtr != 0) {
		_DeleteExecStack(tls, oldPtr)
	}
	return memStart
}

/*
 *--------------------------------------------------------------
 *
 * TclStackAlloc, TclStackRealloc, TclStackFree --
 *
 *	Allocate memory from the execution stack; it has to be returned later
 *	with a call to TclStackFree.
 *
 * Results:
 *	A pointer to the first byte allocated, or panics if the allocation did
 *	not succeed.
 *
 * Side effects:
 *	The execution stack may be grown.
 *
 *--------------------------------------------------------------
 */

func _StackAllocWords(tls *libc.TLS, interp uintptr, numWords Tsize_t) (r uintptr) {
	var eePtr, iPtr, resPtr uintptr
	_, _, _ = eePtr, iPtr, resPtr
	/*
	 * Note that GrowEvaluationStack sets a marker in the stack. This marker
	 * is read when rewinding, e.g., by TclStackFree.
	 */
	iPtr = interp
	eePtr = (*TInterp)(unsafe.Pointer(iPtr)).FexecEnvPtr
	resPtr = _GrowEvaluationStack(tls, eePtr, numWords, 0)
	*(*uintptr)(unsafe.Pointer((*TExecEnv)(unsafe.Pointer(eePtr)).FexecStackPtr + 32)) += uintptr(numWords) * 8
	return resPtr
}

func _StackReallocWords(tls *libc.TLS, interp uintptr, numWords Tsize_t) (r uintptr) {
	var eePtr, iPtr, resPtr uintptr
	_, _, _ = eePtr, iPtr, resPtr
	iPtr = interp
	eePtr = (*TInterp)(unsafe.Pointer(iPtr)).FexecEnvPtr
	resPtr = _GrowEvaluationStack(tls, eePtr, numWords, int32(1))
	*(*uintptr)(unsafe.Pointer((*TExecEnv)(unsafe.Pointer(eePtr)).FexecStackPtr + 32)) += uintptr(numWords) * 8
	return resPtr
}

func XTclStackFree(tls *libc.TLS, interp uintptr, freePtr uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var eePtr, esPtr, iPtr, marker, markerPtr, tmpPtr uintptr
	_, _, _, _, _, _ = eePtr, esPtr, iPtr, marker, markerPtr, tmpPtr
	iPtr = interp
	if iPtr == libc.UintptrFromInt32(0) || (*TInterp)(unsafe.Pointer(iPtr)).FexecEnvPtr == libc.UintptrFromInt32(0) {
		XTclpFree(tls, freePtr)
		return
	}
	/*
	 * Rewind the stack to the previous marker position. The current marker,
	 * as set in the last call to GrowEvaluationStack, contains a pointer to
	 * the previous marker.
	 */
	eePtr = (*TInterp)(unsafe.Pointer(iPtr)).FexecEnvPtr
	esPtr = (*TExecEnv)(unsafe.Pointer(eePtr)).FexecStackPtr
	markerPtr = (*TExecStack)(unsafe.Pointer(esPtr)).FmarkerPtr
	marker = *(*uintptr)(unsafe.Pointer(markerPtr))
	if freePtr != libc.UintptrFromInt32(0) && markerPtr+uintptr(_wordSkip(tls, markerPtr))*8 != freePtr {
		XTcl_Panic(tls, __ccgo_ts+31891, libc.VaList(bp+8, freePtr, markerPtr+uintptr(_wordSkip(tls, markerPtr))*8))
	}
	(*TExecStack)(unsafe.Pointer(esPtr)).FtosPtr = markerPtr - uintptr(1)*8
	(*TExecStack)(unsafe.Pointer(esPtr)).FmarkerPtr = marker
	if marker != 0 {
		return
	}
	/*
	 * Return to previous active stack. Note that repeated expansions or
	 * reallocs could have generated several unused intervening stacks: free
	 * them too.
	 */
	for (*TExecStack)(unsafe.Pointer(esPtr)).FnextPtr != 0 {
		esPtr = (*TExecStack)(unsafe.Pointer(esPtr)).FnextPtr
	}
	(*TExecStack)(unsafe.Pointer(esPtr)).FtosPtr = esPtr + 40 - libc.UintptrFromInt32(1)*8
	for (*TExecStack)(unsafe.Pointer(esPtr)).FprevPtr != 0 {
		tmpPtr = (*TExecStack)(unsafe.Pointer(esPtr)).FprevPtr
		if (*TExecStack)(unsafe.Pointer(tmpPtr)).FtosPtr == tmpPtr+40-libc.UintptrFromInt32(1)*8 {
			_DeleteExecStack(tls, tmpPtr)
		} else {
			break
		}
	}
	if (*TExecStack)(unsafe.Pointer(esPtr)).FprevPtr != 0 {
		(*TExecEnv)(unsafe.Pointer(eePtr)).FexecStackPtr = (*TExecStack)(unsafe.Pointer(esPtr)).FprevPtr
	} else {
		(*TExecEnv)(unsafe.Pointer(eePtr)).FexecStackPtr = esPtr
	}
}

func XTclStackAlloc(tls *libc.TLS, interp uintptr, numBytes Tsize_t) (r uintptr) {
	var iPtr uintptr
	var numWords Tsize_t
	_, _ = iPtr, numWords
	iPtr = interp
	if iPtr == libc.UintptrFromInt32(0) || (*TInterp)(unsafe.Pointer(iPtr)).FexecEnvPtr == libc.UintptrFromInt32(0) {
		return XTcl_Alloc(tls, numBytes)
	}
	numWords = (numBytes + (libc.Uint64FromInt64(8) - libc.Uint64FromInt32(1))) / uint64(8)
	return _StackAllocWords(tls, interp, numWords)
}

func XTclStackRealloc(tls *libc.TLS, interp uintptr, ptr uintptr, numBytes Tsize_t) (r uintptr) {
	var eePtr, esPtr, iPtr, markerPtr uintptr
	var numWords Tsize_t
	_, _, _, _, _ = eePtr, esPtr, iPtr, markerPtr, numWords
	iPtr = interp
	if iPtr == libc.UintptrFromInt32(0) || (*TInterp)(unsafe.Pointer(iPtr)).FexecEnvPtr == libc.UintptrFromInt32(0) {
		return XTcl_Realloc(tls, ptr, numBytes)
	}
	eePtr = (*TInterp)(unsafe.Pointer(iPtr)).FexecEnvPtr
	esPtr = (*TExecEnv)(unsafe.Pointer(eePtr)).FexecStackPtr
	markerPtr = (*TExecStack)(unsafe.Pointer(esPtr)).FmarkerPtr
	if markerPtr+uintptr(_wordSkip(tls, markerPtr))*8 != ptr {
		XTcl_Panic(tls, __ccgo_ts+31957, 0)
	}
	numWords = (numBytes + (libc.Uint64FromInt64(8) - libc.Uint64FromInt32(1))) / uint64(8)
	return _StackReallocWords(tls, interp, numWords)
}

/*
 *--------------------------------------------------------------
 *
 * Tcl_ExprObj --
 *
 *	Evaluate an expression in a Tcl_Obj.
 *
 * Results:
 *	A standard Tcl object result. If the result is other than TCL_OK, then
 *	the interpreter's result contains an error message. If the result is
 *	TCL_OK, then a pointer to the expression's result value object is
 *	stored in resultPtrPtr. In that case, the object's ref count is
 *	incremented to reflect the reference returned to the caller; the
 *	caller is then responsible for the resulting object and must, for
 *	example, decrement the ref count when it is finished with the object.
 *
 * Side effects:
 *	Any side effects caused by subcommands in the expression, if any. The
 *	interpreter result is not modified unless there is an error.
 *
 *--------------------------------------------------------------
 */

func XTcl_ExprObj(tls *libc.TLS, interp uintptr, objPtr uintptr, resultPtrPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Where the Tcl_Obj* that is the expression
	 * result is stored if no errors occur. */
	var _objPtr, cachePtr, cachePtr1, resultPtr, rootPtr uintptr
	var v1, v2 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _ = _objPtr, cachePtr, cachePtr1, resultPtr, rootPtr, v1, v2
	rootPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultPtr = XTclThreadAllocObj(tls)
	} else {
		resultPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FtypePtr = libc.UintptrFromInt32(0)
	if v2 = interp == libc.UintptrFromInt32(0); !v2 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(_CopyCallback)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = resultPtrPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = resultPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
	XTcl_NRExprObj(tls, interp, objPtr, resultPtr)
	return XTclNRRunCallbacks(tls, interp, TCL_OK, rootPtr)
}

func _CopyCallback(tls *libc.TLS, data uintptr, dummy1313 uintptr, result int32) (r int32) {
	var _objPtr, resultPtr, resultPtrPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _, _ = _objPtr, resultPtr, resultPtrPtr, v1, v2
	resultPtrPtr = *(*uintptr)(unsafe.Pointer(data))
	resultPtr = *(*uintptr)(unsafe.Pointer(data + 1*8))
	if result == TCL_OK {
		*(*uintptr)(unsafe.Pointer(resultPtrPtr)) = resultPtr
		(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount++
	} else {
		_objPtr = resultPtr
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	return result
}

/*
 *--------------------------------------------------------------
 *
 * Tcl_NRExprObj --
 *
 *	Request evaluation of the expression in a Tcl_Obj by the NR stack.
 *
 * Results:
 *	Returns TCL_OK.
 *
 * Side effects:
 *	Compiles objPtr as a Tcl expression and places callbacks on the
 *	NR stack to execute the bytecode and store the result in resultPtr.
 *	If bytecode execution raises an exception, nothing is written
 *	to resultPtr, and the exceptional return code flows up the NR
 *	stack.  If the exception is TCL_ERROR, an error message is left
 *	in the interp result and the interp's return options dictionary
 *	holds additional error information too.  Execution of the bytecode
 *	may have other side effects, depending on the expression.
 *
 *--------------------------------------------------------------
 */

func XTcl_NRExprObj(tls *libc.TLS, interp uintptr, objPtr uintptr, resultPtr uintptr) (r int32) {
	var codePtr uintptr
	var state TTcl_InterpState
	_, _ = codePtr, state
	state = XTcl_SaveInterpState(tls, interp, TCL_OK)
	XTcl_ResetResult(tls, interp)
	codePtr = _CompileExprObj(tls, interp, objPtr)
	XTcl_NRAddCallback(tls, interp, __ccgo_fp(_ExprObjCallback), state, resultPtr, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	return XTclNRExecuteByteCode(tls, interp, codePtr)
}

func _ExprObjCallback(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	var resultPtr uintptr
	var state TTcl_InterpState
	_, _ = resultPtr, state
	state = *(*uintptr)(unsafe.Pointer(data))
	resultPtr = *(*uintptr)(unsafe.Pointer(data + 1*8))
	if result == TCL_OK {
		XTclSetDuplicateObj(tls, resultPtr, XTcl_GetObjResult(tls, interp))
		XTcl_RestoreInterpState(tls, interp, state)
	} else {
		XTcl_DiscardInterpState(tls, state)
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * CompileExprObj --
 *	Compile a Tcl expression value into ByteCode.
 *
 * Results:
 *	A (ByteCode *) is returned pointing to the resulting ByteCode.
 *
 * Side effects:
 *	The Tcl_ObjType of objPtr is changed to the "exprcode" type,
 *	and the ByteCode is kept in the internal rep (along with context
 *	data for checking validity) for faster operations the next time
 *	CompileExprObj is called on the same value.
 *
 *----------------------------------------------------------------------
 */

func _CompileExprObj(tls *libc.TLS, interp uintptr, objPtr uintptr) (r uintptr) {
	bp := tls.Alloc(4560)
	defer tls.Free(4560)
	var _objIndexCopy, delta1, v20, v24, v8 int32
	var codePtr, iPtr, irPtr, namespacePtr, string1, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v21, v22, v23, v25, v3, v4, v5, v6, v7, v9 uintptr
	var _ /* compEnv at bp+0 */ TCompileEnv
	var _ /* length at bp+4544 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objIndexCopy, codePtr, delta1, iPtr, irPtr, namespacePtr, string1, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v3, v4, v5, v6, v7, v8, v9
	iPtr = interp /* Compilation environment structure allocated
	 * in frame. */
	codePtr = libc.UintptrFromInt32(0) /* Tcl Internal type of bytecode. Initialized
	 * to avoid compiler warning. */
	/*
	 * Get the expression ByteCode from the object. If it exists, make sure it
	 * is valid in the current context.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclExprCodeType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	codePtr = v2
	if codePtr != libc.UintptrFromInt32(0) {
		namespacePtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FnsPtr
		if *(*uintptr)(unsafe.Pointer((*TByteCode)(unsafe.Pointer(codePtr)).FinterpHandle)) != iPtr || (*TByteCode)(unsafe.Pointer(codePtr)).FcompileEpoch != (*TInterp)(unsafe.Pointer(iPtr)).FcompileEpoch || (*TByteCode)(unsafe.Pointer(codePtr)).FnsPtr != namespacePtr || (*TByteCode)(unsafe.Pointer(codePtr)).FnsEpoch != (*TNamespace)(unsafe.Pointer(namespacePtr)).FresolverEpoch || (*TByteCode)(unsafe.Pointer(codePtr)).FlocalCachePtr != (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FlocalCachePtr {
			XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&XtclExprCodeType)), libc.UintptrFromInt32(0))
			codePtr = libc.UintptrFromInt32(0)
		}
	}
	if codePtr == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 4544)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
			v3 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, objPtr, bp+4544)
		}
		string1 = v3
		XTclInitCompileEnv(tls, interp, bp, string1, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 4544))), libc.UintptrFromInt32(0), 0)
		XTclCompileExpr(tls, interp, string1, *(*TTcl_Size)(unsafe.Pointer(bp + 4544)), bp, 0)
		/*
		 * Successful compilation. If the expression yielded no instructions,
		 * push an zero object as the expression's result.
		 */
		if (*(*TCompileEnv)(unsafe.Pointer(bp))).FcodeNext == (*(*TCompileEnv)(unsafe.Pointer(bp))).FcodeStart {
			_objIndexCopy = XTclRegisterLiteral(tls, bp, __ccgo_ts+14828, int64(1), 0)
			if _objIndexCopy <= int32(255) {
				if (*TCompileEnv)(unsafe.Pointer(bp)).FcodeNext+uintptr(2) > (*TCompileEnv)(unsafe.Pointer(bp)).FcodeEnd {
					XTclExpandCodeArray(tls, bp)
				}
				v5 = bp + 152
				v4 = *(*uintptr)(unsafe.Pointer(v5))
				*(*uintptr)(unsafe.Pointer(v5))++
				*(*uint8)(unsafe.Pointer(v4)) = libc.Uint8FromInt32(int32(INST_PUSH1))
				v7 = bp + 152
				v6 = *(*uintptr)(unsafe.Pointer(v7))
				*(*uintptr)(unsafe.Pointer(v7))++
				*(*uint8)(unsafe.Pointer(v6)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(bp)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(bp)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH1)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v8 = delta1
					v9 = bp
					if v8 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v9)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v9)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v9)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v9)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v9 + 64)) += int64(v8)
				}
			} else {
				if (*TCompileEnv)(unsafe.Pointer(bp)).FcodeNext+uintptr(5) > (*TCompileEnv)(unsafe.Pointer(bp)).FcodeEnd {
					XTclExpandCodeArray(tls, bp)
				}
				v11 = bp + 152
				v10 = *(*uintptr)(unsafe.Pointer(v11))
				*(*uintptr)(unsafe.Pointer(v11))++
				*(*uint8)(unsafe.Pointer(v10)) = libc.Uint8FromInt32(int32(INST_PUSH4))
				v13 = bp + 152
				v12 = *(*uintptr)(unsafe.Pointer(v13))
				*(*uintptr)(unsafe.Pointer(v13))++
				*(*uint8)(unsafe.Pointer(v12)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(24))
				v15 = bp + 152
				v14 = *(*uintptr)(unsafe.Pointer(v15))
				*(*uintptr)(unsafe.Pointer(v15))++
				*(*uint8)(unsafe.Pointer(v14)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(16))
				v17 = bp + 152
				v16 = *(*uintptr)(unsafe.Pointer(v17))
				*(*uintptr)(unsafe.Pointer(v17))++
				*(*uint8)(unsafe.Pointer(v16)) = uint8(libc.Uint32FromInt32(_objIndexCopy) >> libc.Int32FromInt32(8))
				v19 = bp + 152
				v18 = *(*uintptr)(unsafe.Pointer(v19))
				*(*uintptr)(unsafe.Pointer(v19))++
				*(*uint8)(unsafe.Pointer(v18)) = uint8(libc.Uint32FromInt32(_objIndexCopy))
				if (*TCompileEnv)(unsafe.Pointer(bp)).FatCmdStart < int32(2) {
					(*TCompileEnv)(unsafe.Pointer(bp)).FatCmdStart = 0
				}
				delta1 = XtclInstructionTable[uint8(INST_PUSH4)].FstackEffect
				if delta1 != 0 {
					if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
						delta1 = int32(1) - _objIndexCopy
					}
					v20 = delta1
					v21 = bp
					if v20 < libc.Int32FromInt32(0) {
						if int32((*TCompileEnv)(unsafe.Pointer(v21)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v21)).FcurrStackDepth) {
							(*TCompileEnv)(unsafe.Pointer(v21)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v21)).FcurrStackDepth
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(v21 + 64)) += int64(v20)
				}
			}
		}
		/*
		 * Add a "done" instruction as the last instruction and change the
		 * object into a ByteCode object. Ownership of the literal objects and
		 * aux data items is given to the ByteCode object.
		 */
		if (*TCompileEnv)(unsafe.Pointer(bp)).FcodeNext == (*TCompileEnv)(unsafe.Pointer(bp)).FcodeEnd {
			XTclExpandCodeArray(tls, bp)
		}
		v23 = bp + 152
		v22 = *(*uintptr)(unsafe.Pointer(v23))
		*(*uintptr)(unsafe.Pointer(v23))++
		*(*uint8)(unsafe.Pointer(v22)) = libc.Uint8FromInt32(int32(INST_DONE))
		if (*TCompileEnv)(unsafe.Pointer(bp)).FatCmdStart < int32(2) {
			(*TCompileEnv)(unsafe.Pointer(bp)).FatCmdStart = 0
		}
		delta1 = XtclInstructionTable[uint8(INST_DONE)].FstackEffect
		if delta1 != 0 {
			if delta1 == -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff) {
				delta1 = int32(1) - 0
			}
			v24 = delta1
			v25 = bp
			if v24 < libc.Int32FromInt32(0) {
				if int32((*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth) < int32((*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth) {
					(*TCompileEnv)(unsafe.Pointer(v25)).FmaxStackDepth = (*TCompileEnv)(unsafe.Pointer(v25)).FcurrStackDepth
				}
			}
			*(*TTcl_Size)(unsafe.Pointer(v25 + 64)) += int64(v24)
		}
		codePtr = XTclInitByteCodeObj(tls, objPtr, uintptr(unsafe.Pointer(&XtclExprCodeType)), bp)
		XTclFreeCompileEnv(tls, bp)
		if (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FlocalCachePtr != 0 {
			(*TByteCode)(unsafe.Pointer(codePtr)).FlocalCachePtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FlocalCachePtr
			(*TLocalCache)(unsafe.Pointer((*TByteCode)(unsafe.Pointer(codePtr)).FlocalCachePtr)).FrefCount++
		}
		_ = objPtr
	}
	return codePtr
}

/*
 *----------------------------------------------------------------------
 *
 * DupExprCodeInternalRep --
 *
 *	Part of the Tcl object type implementation for Tcl expression
 *	bytecode. We do not copy the bytecode internalrep. Instead, we return
 *	without setting copyPtr->typePtr, so the copy is a plain string copy
 *	of the expression value, and if it is to be used as a compiled
 *	expression, it will just need a recompile.
 *
 *	This makes sense, because with Tcl's copy-on-write practices, the
 *	usual (only?) time Tcl_DuplicateObj() will be called is when the copy
 *	is about to be modified, which would invalidate any copied bytecode
 *	anyway. The only reason it might make sense to copy the bytecode is if
 *	we had some modifying routines that operated directly on the internalrep,
 *	like we do for lists and dicts.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _DupExprCodeInternalRep(tls *libc.TLS, dummy1503 uintptr, dummy1504 uintptr) {
	return
}

/*
 *----------------------------------------------------------------------
 *
 * FreeExprCodeInternalRep --
 *
 *	Part of the Tcl object type implementation for Tcl expression
 *	bytecode. Frees the storage allocated to hold the internal rep, unless
 *	ref counts indicate bytecode execution is still in progress.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	May free allocated memory. Leaves objPtr untyped.
 *
 *----------------------------------------------------------------------
 */

func _FreeExprCodeInternalRep(tls *libc.TLS, objPtr uintptr) {
	var codePtr, irPtr, v1, v2 uintptr
	_, _, _, _ = codePtr, irPtr, v1, v2
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclExprCodeType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	codePtr = v2
	XTclReleaseByteCode(tls, codePtr)
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompileObj --
 *
 *	This procedure compiles the script contained in a Tcl_Obj.
 *
 * Results:
 *	A pointer to the corresponding ByteCode, never NULL.
 *
 * Side effects:
 *	The object is shimmered to bytecode type.
 *
 *----------------------------------------------------------------------
 */

func XTclCompileObj(tls *libc.TLS, interp uintptr, objPtr uintptr, invoker uintptr, word int32) (r uintptr) {
	var _objPtr, codePtr, ctxCopyPtr, eclPtr, hePtr, iPtr, irPtr, irPtr1, namespacePtr, v1, v2, v4, v5, v6 uintptr
	var redo int32
	var v3 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, codePtr, ctxCopyPtr, eclPtr, hePtr, iPtr, irPtr, irPtr1, namespacePtr, redo, v1, v2, v3, v4, v5, v6
	iPtr = interp /* Tcl Internal type of bytecode. */
	namespacePtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FnsPtr
	/*
	 * If the object is not already of tclByteCodeType, compile it (and reset
	 * the compilation flags in the interpreter; this should be done after any
	 * compilation). Otherwise, check that it is "fresh" enough.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclByteCodeType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	codePtr = v2
	if codePtr != libc.UintptrFromInt32(0) {
		/*
		 * Make sure the Bytecode hasn't been invalidated by, e.g., someone
		 * redefining a command with a compile procedure (this might make the
		 * compiled code wrong). The object needs to be recompiled if it was
		 * compiled in/for a different interpreter, or for a different
		 * namespace, or for the same namespace but with different name
		 * resolution rules. Precompiled objects, however, are immutable and
		 * therefore they are not recompiled, even if the epoch has changed.
		 *
		 * To be pedantically correct, we should also check that the
		 * originating procPtr is the same as the current context procPtr
		 * (assuming one exists at all - none for global level). This code is
		 * #def'ed out because [info body] was changed to never return a
		 * bytecode type object, which should obviate us from the extra checks
		 * here.
		 */
		if *(*uintptr)(unsafe.Pointer((*TByteCode)(unsafe.Pointer(codePtr)).FinterpHandle)) != iPtr || (*TByteCode)(unsafe.Pointer(codePtr)).FcompileEpoch != (*TInterp)(unsafe.Pointer(iPtr)).FcompileEpoch || (*TByteCode)(unsafe.Pointer(codePtr)).FnsPtr != namespacePtr || (*TByteCode)(unsafe.Pointer(codePtr)).FnsEpoch != (*TNamespace)(unsafe.Pointer(namespacePtr)).FresolverEpoch {
			if !((*TByteCode)(unsafe.Pointer(codePtr)).Fflags&libc.Uint32FromInt32(TCL_BYTECODE_PRECOMPILED) != 0) {
				goto recompileObj
			}
			if *(*uintptr)(unsafe.Pointer((*TByteCode)(unsafe.Pointer(codePtr)).FinterpHandle)) != iPtr {
				XTcl_Panic(tls, __ccgo_ts+32011, 0)
			}
			(*TByteCode)(unsafe.Pointer(codePtr)).FcompileEpoch = (*TInterp)(unsafe.Pointer(iPtr)).FcompileEpoch
		}
		/*
		 * Check that any compiled locals do refer to the current proc
		 * environment! If not, recompile.
		 */
		if !((*TByteCode)(unsafe.Pointer(codePtr)).Fflags&libc.Uint32FromInt32(TCL_BYTECODE_PRECOMPILED) != 0) && (*TByteCode)(unsafe.Pointer(codePtr)).FprocPtr == libc.UintptrFromInt32(0) && (*TByteCode)(unsafe.Pointer(codePtr)).FlocalCachePtr != (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FlocalCachePtr {
			goto recompileObj
		}
		/*
		 * #280.
		 * Literal sharing fix. This part of the fix is not required by 8.4
		 * nor 8.5, because they eval-direct any literals, so just saving the
		 * argument locations per command in bytecode is enough, embedded
		 * 'eval' commands, etc. get the correct information.
		 *
		 * But in 8.6 all the embedded script are compiled, and the resulting
		 * bytecode stored in the literal. Now the shared literal has bytecode
		 * with location data for _one_ particular location this literal is
		 * found at. If we get executed from a different location the bytecode
		 * has to be recompiled to get the correct locations. Not doing this
		 * will execute the saved bytecode with data for a different location,
		 * causing 'info frame' to point to the wrong place in the sources.
		 *
		 * Future optimizations ...
		 * (1) Save the location data (ExtCmdLoc) keyed by start line. In that
		 *     case we recompile once per location of the literal, but not
		 *     continuously, because the moment we have all locations we do not
		 *     need to recompile any longer.
		 *
		 * (2) Alternative: Do not recompile, tell the execution engine the
		 *     offset between saved starting line and actual one. Then modify
		 *     the users to adjust the locations they have by this offset.
		 *
		 * (3) Alternative 2: Do not fully recompile, adjust just the location
		 *     information.
		 */
		if invoker == libc.UintptrFromInt32(0) {
			return codePtr
		} else {
			hePtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FlineBCPtr)).FfindProc})))(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlineBCPtr, codePtr)
			if !(hePtr != 0) {
				return codePtr
			}
			eclPtr = (*TTcl_HashEntry)(unsafe.Pointer(hePtr)).FclientData
			redo = 0
			ctxCopyPtr = XTclStackAlloc(tls, interp, uint64(88))
			*(*TCmdFrame)(unsafe.Pointer(ctxCopyPtr)) = *(*TCmdFrame)(unsafe.Pointer(invoker))
			if (*TCmdFrame)(unsafe.Pointer(invoker)).Ftype1 == int32(TCL_LOCATION_BC) {
				/*
				 * Note: Type BC => ctx.data.eval.path    is not used.
				 *		    ctx.data.tebc.codePtr used instead
				 */
				XTclGetSrcInfoForPc(tls, ctxCopyPtr)
				if (*TCmdFrame)(unsafe.Pointer(ctxCopyPtr)).Ftype1 == int32(TCL_LOCATION_SOURCE) {
					/*
					 * The reference made by 'TclGetSrcInfoForPc' is dead.
					 */
					_objPtr = (*TCmdFrame)(unsafe.Pointer(ctxCopyPtr)).Fdata.Feval.Fpath
					v4 = _objPtr
					v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
					*(*TTcl_Size)(unsafe.Pointer(v4))--
					if v3 <= int64(1) {
						XTclFreeObj(tls, _objPtr)
					}
					(*TCmdFrame)(unsafe.Pointer(ctxCopyPtr)).Fdata.Feval.Fpath = libc.UintptrFromInt32(0)
				}
			}
			if int64(word) < (*TCmdFrame)(unsafe.Pointer(ctxCopyPtr)).Fnline {
				/*
				 * Note: We do not care if the line[word] is -1. This is a
				 * difference and requires a recompile (location changed from
				 * absolute to relative, literal is used fixed and through
				 * variable)
				 *
				 * Example:
				 * test info-32.0 using literal of info-24.8
				 *     (dict with ... vs           set body ...).
				 */
				redo = libc.BoolInt32((*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Ftype1 == int32(TCL_LOCATION_SOURCE) && (*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Fstart != *(*TTcl_Size)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(ctxCopyPtr)).Fline + uintptr(word)*8)) || (*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Ftype1 == int32(TCL_LOCATION_BC) && (*TCmdFrame)(unsafe.Pointer(ctxCopyPtr)).Ftype1 == int32(TCL_LOCATION_SOURCE))
			}
			XTclStackFree(tls, interp, ctxCopyPtr)
			if !(redo != 0) {
				return codePtr
			}
		}
	}
	goto recompileObj
recompileObj:
	;
	(*TInterp)(unsafe.Pointer(iPtr)).FerrorLine = int32(1)
	/*
	 * TIP #280. Remember the invoker for a moment in the interpreter
	 * structures so that the byte code compiler can pick it up when
	 * initializing the compilation environment, i.e. the extended location
	 * information.
	 */
	(*TInterp)(unsafe.Pointer(iPtr)).FinvokeCmdFramePtr = invoker
	(*TInterp)(unsafe.Pointer(iPtr)).FinvokeWord = word
	XTclSetByteCodeFromAny(tls, interp, objPtr, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	(*TInterp)(unsafe.Pointer(iPtr)).FinvokeCmdFramePtr = libc.UintptrFromInt32(0)
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclByteCodeType)) {
		v5 = objPtr + 32
	} else {
		v5 = libc.UintptrFromInt32(0)
	}
	irPtr1 = v5
	if irPtr1 != 0 {
		v6 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr1))).Fptr1
	} else {
		v6 = libc.UintptrFromInt32(0)
	}
	codePtr = v6
	if (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FlocalCachePtr != 0 {
		(*TByteCode)(unsafe.Pointer(codePtr)).FlocalCachePtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FlocalCachePtr
		(*TLocalCache)(unsafe.Pointer((*TByteCode)(unsafe.Pointer(codePtr)).FlocalCachePtr)).FrefCount++
	}
	return codePtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclIncrObj --
 *
 *	Increment an integral value in a Tcl_Obj by an integral value held
 *	in another Tcl_Obj. Caller is responsible for making sure we can
 *	update the first object.
 *
 * Results:
 *	TCL_ERROR if either object is non-integer, and TCL_OK otherwise. On
 *	error, an error message is left in the interpreter (if it is not NULL,
 *	of course).
 *
 * Side effects:
 *	valuePtr gets the new incremented value.
 *
 *----------------------------------------------------------------------
 */

func XTclIncrObj(tls *libc.TLS, interp uintptr, valuePtr uintptr, incrPtr uintptr) (r int32) {
	bp := tls.Alloc(112)
	defer tls.Free(112)
	var _isobjPtr uintptr
	var err Tmp_err
	var sum, w1, w2 TTcl_WideInt
	var v1, v13, v15, v2, v6, v7, v8, v9 int32
	var v11, v4 uint64
	var _ /* __u at bp+0 */ struct {
		F__i [0]uint64
		F__f float64
	}
	var _ /* incr at bp+56 */ Tmp_int
	var _ /* ir at bp+80 */ TTcl_ObjInternalRep
	var _ /* ptr1 at bp+8 */ uintptr
	var _ /* ptr2 at bp+16 */ uintptr
	var _ /* type1 at bp+24 */ int32
	var _ /* type2 at bp+28 */ int32
	var _ /* value at bp+32 */ Tmp_int
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _isobjPtr, err, sum, w1, w2, v1, v11, v13, v15, v2, v4, v6, v7, v8, v9
	if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+10229, libc.VaList(bp+104, __ccgo_ts+32055))
	}
	if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*int32)(unsafe.Pointer(bp + 24)) = int32(TCL_NUMBER_INT)
		*(*uintptr)(unsafe.Pointer(bp + 8)) = valuePtr + 32
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
			*(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(valuePtr)).FinternalRep))
			v4 = *(*uint64)(unsafe.Pointer(bp))
			goto _5
		_5:
			if libc.BoolInt32(v4&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) > libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
				*(*int32)(unsafe.Pointer(bp + 24)) = int32(TCL_NUMBER_NAN)
			} else {
				*(*int32)(unsafe.Pointer(bp + 24)) = int32(TCL_NUMBER_DOUBLE)
			}
			*(*uintptr)(unsafe.Pointer(bp + 8)) = valuePtr + 32
			v2 = libc.Int32FromInt32(TCL_OK)
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).Fbytes != libc.UintptrFromInt32(0) && (*TTcl_Obj)(unsafe.Pointer(valuePtr)).Flength == 0 {
				v6 = int32(TCL_ERROR)
			} else {
				v6 = XTcl_GetNumberFromObj(tls, libc.UintptrFromInt32(0), valuePtr, bp+8, bp+24)
			}
			v2 = v6
		}
		v1 = v2
	}
	if v1 != TCL_OK {
		/*
		 * Produce error message (reparse?!)
		 */
		if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(valuePtr)).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(valuePtr)).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
			*(*int32)(unsafe.Pointer(bp + 24)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(valuePtr)).FinternalRep)))
			v7 = libc.Int32FromInt32(TCL_OK)
		} else {
			v7 = XTcl_GetIntFromObj(tls, interp, valuePtr, bp+24)
		}
		return v7
	}
	if (*TTcl_Obj)(unsafe.Pointer(incrPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*int32)(unsafe.Pointer(bp + 28)) = int32(TCL_NUMBER_INT)
		*(*uintptr)(unsafe.Pointer(bp + 16)) = incrPtr + 32
		v8 = libc.Int32FromInt32(TCL_OK)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(incrPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
			*(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FinternalRep))
			v11 = *(*uint64)(unsafe.Pointer(bp))
			goto _12
		_12:
			if libc.BoolInt32(v11&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) > libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
				*(*int32)(unsafe.Pointer(bp + 28)) = int32(TCL_NUMBER_NAN)
			} else {
				*(*int32)(unsafe.Pointer(bp + 28)) = int32(TCL_NUMBER_DOUBLE)
			}
			*(*uintptr)(unsafe.Pointer(bp + 16)) = incrPtr + 32
			v9 = libc.Int32FromInt32(TCL_OK)
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(incrPtr)).Fbytes != libc.UintptrFromInt32(0) && (*TTcl_Obj)(unsafe.Pointer(incrPtr)).Flength == 0 {
				v13 = int32(TCL_ERROR)
			} else {
				v13 = XTcl_GetNumberFromObj(tls, libc.UintptrFromInt32(0), incrPtr, bp+16, bp+28)
			}
			v9 = v13
		}
		v8 = v9
	}
	if v8 != TCL_OK {
		/*
		 * Produce error message (reparse?!)
		 */
		if (*TTcl_Obj)(unsafe.Pointer(incrPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
			*(*int32)(unsafe.Pointer(bp + 24)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FinternalRep)))
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_GetIntFromObj(tls, interp, incrPtr, bp+24)
		}
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+26676, int64(-int32(1))))
		return int32(TCL_ERROR)
	}
	if *(*int32)(unsafe.Pointer(bp + 24)) == int32(TCL_NUMBER_DOUBLE) || *(*int32)(unsafe.Pointer(bp + 24)) == int32(TCL_NUMBER_NAN) {
		/*
		 * Produce error message (reparse?!)
		 */
		if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(valuePtr)).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(valuePtr)).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
			*(*int32)(unsafe.Pointer(bp + 24)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(valuePtr)).FinternalRep)))
			v15 = libc.Int32FromInt32(TCL_OK)
		} else {
			v15 = XTcl_GetIntFromObj(tls, interp, valuePtr, bp+24)
		}
		return v15
	}
	if *(*int32)(unsafe.Pointer(bp + 28)) == int32(TCL_NUMBER_DOUBLE) || *(*int32)(unsafe.Pointer(bp + 28)) == int32(TCL_NUMBER_NAN) {
		/*
		 * Produce error message (reparse?!)
		 */
		if (*TTcl_Obj)(unsafe.Pointer(incrPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
			*(*int32)(unsafe.Pointer(bp + 24)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FinternalRep)))
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_GetIntFromObj(tls, interp, incrPtr, bp+24)
		}
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+26676, int64(-int32(1))))
		return int32(TCL_ERROR)
	}
	if *(*int32)(unsafe.Pointer(bp + 24)) == int32(TCL_NUMBER_INT) && *(*int32)(unsafe.Pointer(bp + 28)) == int32(TCL_NUMBER_INT) {
		w1 = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))
		w2 = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16))))
		sum = libc.Int64FromUint64(libc.Uint64FromInt64(w1) + libc.Uint64FromInt64(w2))
		/*
		 * Check for overflow.
		 */
		if !(w1^sum < 0 && w1^w2 >= 0) {
			*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 80)))) = sum
			_isobjPtr = valuePtr
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
				if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
			}
			XTcl_StoreInternalRep(tls, valuePtr, uintptr(unsafe.Pointer(&XtclIntType)), bp+80)
			return TCL_OK
		}
	}
	XTcl_TakeBignumFromObj(tls, interp, valuePtr, bp+32)
	XTcl_GetBignumFromObj(tls, interp, incrPtr, bp+56)
	err = XTclBN_mp_add(tls, bp+32, bp+56, bp+32)
	XTclBN_mp_clear(tls, bp+56)
	if err != MP_OKAY {
		return int32(TCL_ERROR)
	}
	XTcl_SetBignumObj(tls, valuePtr, bp+32)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * ArgumentBCEnter --
 *
 *	This is a helper for TclNRExecuteByteCode/TEBCresume that encapsulates
 *	a code sequence that is fairly common in the code but *not* commonly
 *	called.
 *
 * Results:
 *	None
 *
 * Side effects:
 *	May register information about the bytecode in the command frame.
 *
 *----------------------------------------------------------------------
 */

func _ArgumentBCEnter(tls *libc.TLS, interp uintptr, codePtr uintptr, tdPtr uintptr, pc uintptr, objc TTcl_Size, objv uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _ /* cmd at bp+0 */ TTcl_Size
	if _GetSrcInfoForPc(tls, pc, codePtr, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), bp) != 0 {
		XTclArgumentBCEnter(tls, interp, objv, objc, codePtr, tdPtr+24, *(*TTcl_Size)(unsafe.Pointer(bp)), int64(pc)-int64((*TByteCode)(unsafe.Pointer(codePtr)).FcodeStart))
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclNRExecuteByteCode --
 *
 *	This procedure executes the instructions of a ByteCode structure. It
 *	returns when a "done" instruction is executed or an error occurs.
 *
 * Results:
 *	The return value is one of the return codes defined in tcl.h (such as
 *	TCL_OK), and interp->objResultPtr refers to a Tcl object that either
 *	contains the result of executing the code or an error message.
 *
 * Side effects:
 *	Almost certainly, depending on the ByteCode's instructions.
 *
 *----------------------------------------------------------------------
 */

func XTclNRExecuteByteCode(tls *libc.TLS, interp uintptr, codePtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The bytecode sequence to interpret. */
	var TD, _objPtr, cachePtr, iPtr uintptr
	var numWords, size Tsize_t
	var v1, v2 int32
	var v3 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _ = TD, _objPtr, cachePtr, iPtr, numWords, size, v1, v2, v3
	iPtr = interp
	size = libc.Uint64FromInt64(120) - libc.Uint64FromInt32(1) + libc.Uint64FromInt64((*TByteCode)(unsafe.Pointer(codePtr)).FmaxStackDepth+(*TByteCode)(unsafe.Pointer(codePtr)).FmaxExceptDepth)*uint64(8)
	numWords = (size + uint64(8) - uint64(1)) / uint64(8)
	XTclPreserveByteCode(tls, codePtr)
	/*
	 * Reserve the stack, setup the TEBCdataPtr (TD) and CallFrame
	 *
	 * The execution uses a unified stack: first a TEBCdata, immediately
	 * above it a CmdFrame, then the catch stack, then the execution stack.
	 *
	 * Make sure the catch stack is large enough to hold the maximum number of
	 * catch commands that could ever be executing at the same time (this will
	 * be no more than the exception range array's depth). Make sure the
	 * execution stack is large enough to execute this ByteCode.
	 */
	TD = _GrowEvaluationStack(tls, (*TInterp)(unsafe.Pointer(iPtr)).FexecEnvPtr, numWords, 0)
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = TD + 112 - libc.UintptrFromInt32(1)*8 + uintptr((*TByteCode)(unsafe.Pointer(codePtr)).FmaxExceptDepth)*8
	(*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr = codePtr
	(*TTEBCdata)(unsafe.Pointer(TD)).FcatchTop = TD + 112 - libc.UintptrFromInt32(1)*8
	(*TTEBCdata)(unsafe.Pointer(TD)).FauxObjList = libc.UintptrFromInt32(0)
	/*
	 * TIP #280: Initialize the frame. Do not push it yet: it will be pushed
	 * every time that we call out from this TD, popped when we return to it.
	 */
	if (*TByteCode)(unsafe.Pointer(codePtr)).Fflags&uint32(TCL_BYTECODE_PRECOMPILED) != 0 {
		v1 = int32(TCL_LOCATION_PREBC)
	} else {
		v1 = int32(TCL_LOCATION_BC)
	}
	(*TCmdFrame)(unsafe.Pointer(TD + 24)).Ftype1 = v1
	if (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr != 0 {
		v2 = (*TCmdFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr)).Flevel + int32(1)
	} else {
		v2 = int32(1)
	}
	(*TCmdFrame)(unsafe.Pointer(TD + 24)).Flevel = v2
	(*TCmdFrame)(unsafe.Pointer(TD + 24)).FframePtr = (*TInterp)(unsafe.Pointer(iPtr)).FframePtr
	(*TCmdFrame)(unsafe.Pointer(TD + 24)).FnextPtr = (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr
	(*TCmdFrame)(unsafe.Pointer(TD + 24)).Fnline = 0
	(*TCmdFrame)(unsafe.Pointer(TD + 24)).Fline = libc.UintptrFromInt32(0)
	(*TCmdFrame)(unsafe.Pointer(TD + 24)).Flitarg = libc.UintptrFromInt32(0)
	(*(*struct {
		FcodePtr uintptr
		Fpc      uintptr
	})(unsafe.Pointer(TD + 24 + 40))).FcodePtr = codePtr
	(*(*struct {
		FcodePtr uintptr
		Fpc      uintptr
	})(unsafe.Pointer(TD + 24 + 40))).Fpc = libc.UintptrFromInt32(0)
	(*TCmdFrame)(unsafe.Pointer(TD + 24)).FcmdObj = libc.UintptrFromInt32(0)
	(*TCmdFrame)(unsafe.Pointer(TD + 24)).Fcmd = libc.UintptrFromInt32(0)
	(*TCmdFrame)(unsafe.Pointer(TD + 24)).Flen1 = 0
	/*
	 * Test namespace-50.9 demonstrates the need for this call.
	 * Use a --enable-symbols=mem bug to see.
	 */
	XTclResetRewriteEnsemble(tls, interp, int32(1))
	/*
	 * Push the callback for bytecode execution
	 */
	if v3 = interp == libc.UintptrFromInt32(0); !v3 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(_TEBCresume)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = TD
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = uintptr(int64((*TInterp)(unsafe.Pointer(iPtr)).FevalFlags))
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
	/*
	 * Reset discard result flag - because it is applicable for this call only,
	 * and should not affect all the nested invocations may return result.
	 */
	*(*int32)(unsafe.Pointer(iPtr + 256)) &= ^libc.Int32FromInt32(TCL_EVAL_DISCARD_RESULT)
	return TCL_OK
}

func _TEBCresume(tls *libc.TLS, data uintptr, interp4 uintptr, result int32) (r int32) {
	bp := tls.Alloc(592)
	defer tls.Free(592)
	var TD, _isobjPtr, _isobjPtr1, _isobjPtr2, _isobjPtr3, _isobjPtr4, _isobjPtr5, _isobjPtr6, _isobjPtr7, _isobjPtr8, _isobjPtr9, _objPtr, _objPtr1, _objPtr10, _objPtr11, _objPtr12, _objPtr13, _objPtr14, _objPtr15, _objPtr16, _objPtr17, _objPtr18, _objPtr19, _objPtr2, _objPtr20, _objPtr21, _objPtr22, _objPtr23, _objPtr24, _objPtr25, _objPtr26, _objPtr27, _objPtr28, _objPtr29, _objPtr3, _objPtr30, _objPtr31, _objPtr32, _objPtr33, _objPtr34, _objPtr35, _objPtr36, _objPtr37, _objPtr38, _objPtr39, _objPtr4, _objPtr40, _objPtr5, _objPtr6, _objPtr7, _objPtr8, _objPtr9, a, b, bytes, bytes1, bytes11, bytes2, cachePtr, cachePtr1, cachePtr10, cachePtr100, cachePtr101, cachePtr102, cachePtr103, cachePtr104, cachePtr105, cachePtr106, cachePtr107, cachePtr11, cachePtr12, cachePtr13, cachePtr14, cachePtr15, cachePtr16, cachePtr17, cachePtr18, cachePtr19, cachePtr2, cachePtr20, cachePtr21, cachePtr22, cachePtr23, cachePtr24, cachePtr25, cachePtr26, cachePtr27, cachePtr28, cachePtr29, cachePtr3, cachePtr30, cachePtr31, cachePtr32, cachePtr33, cachePtr34, cachePtr35, cachePtr36, cachePtr37, cachePtr38, cachePtr39, cachePtr4, cachePtr40, cachePtr41, cachePtr42, cachePtr43, cachePtr44, cachePtr45, cachePtr46, cachePtr47, cachePtr48, cachePtr49, cachePtr5, cachePtr50, cachePtr51, cachePtr52, cachePtr53, cachePtr54, cachePtr55, cachePtr56, cachePtr57, cachePtr58, cachePtr59, cachePtr6, cachePtr60, cachePtr61, cachePtr62, cachePtr63, cachePtr64, cachePtr65, cachePtr66, cachePtr67, cachePtr68, cachePtr69, cachePtr7, cachePtr70, cachePtr71, cachePtr72, cachePtr73, cachePtr74, cachePtr75, cachePtr76, cachePtr77, cachePtr78, cachePtr79, cachePtr8, cachePtr80, cachePtr81, cachePtr82, cachePtr83, cachePtr84, cachePtr85, cachePtr86, cachePtr87, cachePtr88, cachePtr89, cachePtr9, cachePtr90, cachePtr91, cachePtr92, cachePtr93, cachePtr94, cachePtr95, cachePtr96, cachePtr97, cachePtr98, cachePtr99, classPtr, compiledLocals, constants, contextPtr, copyPtr, corPtr, corPtr1, curInstName, dictPtr, duiPtr, emptyPtr, end, framePtr1, framePtr2, fromIdxObj, hPtr, incrPtr, indexListPtr, infoPtr, irPtr, jtPtr, keysPtr, linkPtr, listPtr, listPtr1, listPtr2, mPtr, methodType, methodType1, miPtr, msgPart, newCodePtr, newTD, newValue, oPtr, objPtr5, otherPtr, p, part1Ptr, part2Ptr, pc, proc, proc1, proc2, proc3, proc4, rangePtr, resPtr, rootFramePtr, s1, s2, savedFramePtr, savedNsPtr, savedString, searchPtr, statePtr, string1, string2, tmpPtr, toIdxObj, tosPtr, ustring1, ustring11, ustring2, ustring21, ustring3, value2Ptr, value3Ptr, valueToAssign, var2Ptr, varListPtr, varNamePtr, yieldParameter, v1000, v1001, v1007, v1008, v1009, v1015, v1016, v1017, v1023, v1024, v1025, v1032, v1033, v1034, v1035, v1036, v1037, v1038, v1039, v1040, v1043, v1044, v1045, v1048, v1049, v1050, v1062, v1063, v1064, v1070, v1071, v1072, v1078, v1079, v1080, v1086, v1087, v1088, v1095, v1096, v1097, v1107, v1108, v1109, v1136, v1137, v1138, v1144, v1145, v1146, v1152, v1153, v1154, v1160, v1161, v1162, v1169, v1170, v1171, v1186, v1187, v1188, v1191, v1192, v1193, v1196, v1197, v1198, v1202, v1203, v1204, v1207, v1208, v1209, v1214, v1215, v1216, v1219, v1220, v1221, v1243, v1244, v1245, v1248, v1249, v1250, v1253, v1254, v1255, v1258, v1259, v1260, v1264, v1265, v1266, v1276, v1277, v1278, v1281, v1282, v1283, v1286, v1287, v1288, v1291, v1292, v1293, v1302, v1303, v1304, v1308, v1309, v1310, v1313, v1314, v1315, v1318, v1319, v1320, v1323, v1324, v1325, v1334, v1335, v1336, v1339, v1340, v1341, v1344, v1345, v1346, v1349, v1350, v1351, v1354, v1355, v1356, v1361, v1363, v1364, v1366, v1367, v1369, v1377, v1381, v1382, v1383, v1386, v1387, v1388, v1389, v1390, v1393, v1394, v1395, v1398, v1399, v1400, v1404, v1405, v1406, v1410, v1411, v1412, v1415, v1416, v1417, v1421, v1422, v1423, v1426, v1427, v1428, v1437, v1438, v1445, v1448, v1451, v1454, v1458, v1461, v1464, v1467, v1470, v1473, v1477, v1478, v1479, v1482, v1483, v1484, v1485, v1487, v1490, v1492, v1493, v1496, v1497, v1498, v1499, v1500, v1501, v1502, v1503, v1515, v1516, v1517, v1523, v1524, v1525, v1531, v1532, v1533, v1539, v1540, v1541, v1548, v1549, v1550, v1556, v1558, v1560, v1564, v1565, v1566, v1569, v1570, v1571, v1578, v1581, v1585, v1586, v1587, v1593, v1594, v1595, v1596, v16, v1601, v1604, v1607, v1611, v1612, v1613, v1619, v1620, v1621, v1625, v1626, v1627, v1629, v1631, v1635, v1636, v1637, v1640, v1641, v1642, v1645, v1646, v1648, v1652, v1653, v1654, v1656, v1657, v1659, v1660, v1661, v18, v2, v20, v22, v24, v246, v247, v248, v249, v251, v254, v255, v256, v258, v260, v264, v265, v267, v269, v27, v272, v273, v274, v275, v277, v281, v282, v283, v286, v287, v288, v291, v292, v293, v296, v297, v298, v302, v303, v304, v306, v310, v312, v313, v315, v318, v319, v320, v324, v328, v329, v330, v332, v334, v343, v344, v345, v346, v349, v35, v350, v351, v352, v355, v356, v357, v359, v361, v365, v366, v367, v37, v370, v371, v372, v374, v378, v385, v387, v39, v394, v397, v400, v404, v41, v415, v417, v419, v421, v423, v425, v43, v435, v439, v440, v441, v444, v445, v446, v449, v45, v453, v454, v455, v458, v459, v460, v463, v464, v465, v470, v471, v472, v475, v476, v477, v480, v481, v482, v485, v486, v487, v491, v492, v493, v494, v497, v498, v499, v502, v503, v504, v507, v508, v509, v51, v513, v514, v515, v519, v52, v520, v521, v524, v525, v528, v529, v53, v530, v534, v535, v536, v540, v541, v542, v545, v546, v547, v550, v551, v552, v553, v556, v557, v564, v565, v566, v569, v570, v571, v574, v575, v576, v582, v583, v584, v585, v586, v587, v591, v592, v6, v604, v607, v610, v611, v612, v613, v614, v615, v618, v619, v629, v630, v631, v632, v634, v635, v636, v637, v638, v640, v642, v645, v646, v647, v652, v653, v654, v657, v658, v659, v664, v665, v666, v667, v668, v669, v674, v675, v676, v677, v678, v679, v680, v685, v686, v687, v690, v691, v693, v705, v706, v707, v713, v714, v715, v721, v722, v723, v729, v730, v731, v738, v739, v740, v742, v746, v747, v748, v751, v752, v753, v754, v758, v770, v771, v772, v778, v779, v780, v786, v787, v788, v794, v795, v796, v803, v804, v805, v809, v810, v811, v812, v814, v815, v818, v819, v820, v821, v824, v825, v826, v827, v829, v830, v833, v834, v835, v836, v839, v840, v841, v842, v844, v845, v848, v849, v850, v851, v854, v855, v856, v862, v863, v864, v870, v871, v872, v876, v877, v878, v879, v884, v887, v889, v891, v893, v895, v899, v9, v900, v901, v903, v907, v908, v909, v911, v915, v916, v917, v919, v923, v924, v925, v929, v930, v931, v934, v935, v936, v938, v950, v951, v952, v958, v959, v960, v966, v967, v968, v974, v975, v976, v983, v984, v985, v986, v987, v999 uintptr
	var allocateDict, allocdict, cflags, ch, ch1, checkEq, checkInterp, cleanup, code, code1, compare, createdNewObj, end_indicator, flags, flags1, found, found1, hasAbstractList, haveSecondIndex, iResult, isAbstractList, jumpOffset, level, nocase, numIndices, opnd, opnd2, pcAdjustment, res, shift, status, status1, storeFlags, v1002, v1003, v1004, v1010, v1011, v1012, v1018, v1019, v1020, v1026, v1027, v1028, v1065, v1066, v1067, v1073, v1074, v1075, v1081, v1082, v1083, v1089, v1090, v1091, v1098, v1099, v1103, v1110, v1111, v1115, v1116, v1117, v1121, v1123, v1124, v1139, v1140, v1141, v1147, v1148, v1149, v1155, v1156, v1157, v1163, v1164, v1165, v1172, v1173, v1177, v1178, v1179, v1183, v1222, v1223, v1227, v1228, v1229, v1233, v1261, v1267, v1268, v1272, v1294, v1295, v1299, v1326, v1327, v1331, v1358, v1370, v1418, v1429, v1432, v1433, v1434, v1435, v1518, v1519, v1520, v1526, v1527, v1528, v1534, v1535, v1536, v1542, v1543, v1544, v1551, v1572, v1588, v1597, v1614, v1628, v17, v307, v34, v373, v375, v379, v382, v388, v391, v401, v405, v406, v410, v428, v429, v430, v431, v433, v447, v466, v467, v48, v488, v49, v50, v522, v561, v577, v590, v593, v596, v599, v602, v620, v623, v648, v670, v681, v683, v688, v708, v709, v710, v716, v717, v718, v724, v725, v726, v732, v733, v734, v755, v756, v773, v774, v775, v781, v782, v783, v789, v790, v791, v797, v798, v799, v857, v865, v866, v880, v881, v953, v954, v955, v961, v962, v963, v969, v970, v971, v977, v978, v979 int32
	var augend, sum, w, w1, w2, wResult, wval TTcl_WideInt
	var cmd, origCmd TTcl_Command
	var i, i1, i2, i3, i4, iterMax, iterNum, iterTmp, j, listTmpDepth, newDepth, numLists, numVars, oldCatchTopOff, oldTosPtrOff, skip, trim1, valIndex, varIndex, v1, v1360, v1376, v1444, v1447, v1450, v1453, v1457, v1460, v1463, v1466, v1469, v1472, v1486, v1489, v1555, v1557, v1559, v1577, v1580, v1600, v1603, v1606, v1630, v1644, v1647, v1655, v1658, v19, v23, v250, v257, v259, v26, v263, v266, v276, v305, v314, v323, v333, v358, v36, v360, v384, v393, v399, v40, v403, v414, v416, v420, v422, v424, v434, v44, v448, v5, v539, v588, v603, v606, v616, v633, v641, v692, v741, v757, v8, v883, v886, v890, v894, v902, v910, v918 TTcl_Size
	var increment, v1210, v1359, v1371, v1372, v1552, v1553, v1573, v1574, v1589, v1590, v1598, v1599, v1615, v1616, v1643, v308, v309, v338, v339, v376, v377, v380, v381, v383, v389, v390, v392, v578, v597, v598, v624, v625, v649, v684 int64
	var inst uint8
	var interruptCounter, v47 uint32
	var jmpOffset [2]int32
	var numNewElems, numToDelete Tsize_t
	var regExpr TTcl_RegExp
	var v10, v1029, v1092, v1104, v1122, v1166, v1199, v1211, v1240, v1273, v1305, v1362, v1365, v1374, v1375, v1378, v1401, v1407, v1436, v1442, v1443, v1446, v1449, v1452, v1455, v1456, v1459, v1462, v1465, v1468, v1471, v1474, v1488, v1491, v1494, v1495, v1545, v1561, v1575, v1579, v1582, v1602, v1605, v1608, v1622, v1632, v1649, v21, v25, v261, v262, v268, v278, v28, v299, v3, v321, v322, v325, v331, v335, v336, v340, v362, v38, v386, v395, v398, v4, v402, v411, v412, v413, v418, v42, v432, v436, v450, v46, v510, v516, v531, v537, v558, v559, v560, v579, v595, v600, v601, v605, v622, v626, v661, v7, v735, v743, v800, v806, v813, v828, v843, v858, v859, v867, v873, v882, v885, v888, v892, v896, v904, v912, v920, v980 bool
	var v1101, v1113, v1119, v1175, v1181, v1225, v1231, v1270, v1297, v1329, v408 uint64
	var _ /* __u at bp+0 */ struct {
		F__i [0]uint64
		F__f float64
	}
	var _ /* _callbackPtr at bp+104 */ uintptr
	var _ /* _callbackPtr at bp+112 */ uintptr
	var _ /* _callbackPtr at bp+120 */ uintptr
	var _ /* _callbackPtr at bp+208 */ uintptr
	var _ /* _callbackPtr at bp+216 */ uintptr
	var _ /* _callbackPtr at bp+224 */ uintptr
	var _ /* _callbackPtr at bp+64 */ uintptr
	var _ /* _callbackPtr at bp+72 */ uintptr
	var _ /* _callbackPtr at bp+80 */ uintptr
	var _ /* _callbackPtr at bp+88 */ uintptr
	var _ /* _callbackPtr at bp+96 */ uintptr
	var _ /* arrayPtr at bp+56 */ uintptr
	var _ /* b at bp+200 */ int32
	var _ /* b at bp+392 */ int32
	var _ /* buf at bp+312 */ [4]uint8
	var _ /* code at bp+448 */ int32
	var _ /* done at bp+452 */ int32
	var _ /* elements at bp+432 */ uintptr
	var _ /* framePtr at bp+184 */ uintptr
	var _ /* fromIdx at bp+256 */ TTcl_Size
	var _ /* index at bp+272 */ TTcl_Size
	var _ /* ir at bp+152 */ TTcl_ObjInternalRep
	var _ /* ir at bp+168 */ TTcl_ObjInternalRep
	var _ /* ir at bp+376 */ TTcl_ObjInternalRep
	var _ /* ir at bp+400 */ TTcl_ObjInternalRep
	var _ /* ir at bp+416 */ TTcl_ObjInternalRep
	var _ /* ir at bp+480 */ TTcl_ObjInternalRep
	var _ /* keyPtr at bp+456 */ uintptr
	var _ /* keyPtrPtr at bp+464 */ uintptr
	var _ /* len at bp+128 */ TTcl_Size
	var _ /* length at bp+32 */ TTcl_Size
	var _ /* length2 at bp+248 */ TTcl_Size
	var _ /* length3 at bp+320 */ TTcl_Size
	var _ /* level at bp+204 */ int32
	var _ /* listLen at bp+440 */ TTcl_Size
	var _ /* match at bp+232 */ int32
	var _ /* now at bp+496 */ TTcl_Time
	var _ /* nsPtr at bp+192 */ uintptr
	var _ /* o at bp+304 */ uintptr
	var _ /* objResultPtr at bp+8 */ uintptr
	var _ /* objc at bp+40 */ TTcl_Size
	var _ /* objv at bp+24 */ uintptr
	var _ /* pcBeg at bp+512 */ uintptr
	var _ /* ptr at bp+136 */ uintptr
	var _ /* ptr1 at bp+352 */ uintptr
	var _ /* ptr2 at bp+360 */ uintptr
	var _ /* s1len at bp+280 */ TTcl_Size
	var _ /* s2len at bp+288 */ TTcl_Size
	var _ /* size at bp+472 */ TTcl_Size
	var _ /* slength at bp+240 */ TTcl_Size
	var _ /* toIdx at bp+264 */ TTcl_Size
	var _ /* trim2 at bp+344 */ TTcl_Size
	var _ /* type at bp+144 */ int32
	var _ /* type1 at bp+368 */ int32
	var _ /* type2 at bp+372 */ int32
	var _ /* value2Length at bp+296 */ TTcl_Size
	var _ /* valuePtr at bp+16 */ uintptr
	var _ /* varPtr at bp+48 */ uintptr
	var _ /* wlen1 at bp+328 */ TTcl_Size
	var _ /* wlen2 at bp+336 */ TTcl_Size
	var _ /* xxx1length at bp+520 */ TTcl_Size
	var _ /* xxx1length at bp+528 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = TD, _isobjPtr, _isobjPtr1, _isobjPtr2, _isobjPtr3, _isobjPtr4, _isobjPtr5, _isobjPtr6, _isobjPtr7, _isobjPtr8, _isobjPtr9, _objPtr, _objPtr1, _objPtr10, _objPtr11, _objPtr12, _objPtr13, _objPtr14, _objPtr15, _objPtr16, _objPtr17, _objPtr18, _objPtr19, _objPtr2, _objPtr20, _objPtr21, _objPtr22, _objPtr23, _objPtr24, _objPtr25, _objPtr26, _objPtr27, _objPtr28, _objPtr29, _objPtr3, _objPtr30, _objPtr31, _objPtr32, _objPtr33, _objPtr34, _objPtr35, _objPtr36, _objPtr37, _objPtr38, _objPtr39, _objPtr4, _objPtr40, _objPtr5, _objPtr6, _objPtr7, _objPtr8, _objPtr9, a, allocateDict, allocdict, augend, b, bytes, bytes1, bytes11, bytes2, cachePtr, cachePtr1, cachePtr10, cachePtr100, cachePtr101, cachePtr102, cachePtr103, cachePtr104, cachePtr105, cachePtr106, cachePtr107, cachePtr11, cachePtr12, cachePtr13, cachePtr14, cachePtr15, cachePtr16, cachePtr17, cachePtr18, cachePtr19, cachePtr2, cachePtr20, cachePtr21, cachePtr22, cachePtr23, cachePtr24, cachePtr25, cachePtr26, cachePtr27, cachePtr28, cachePtr29, cachePtr3, cachePtr30, cachePtr31, cachePtr32, cachePtr33, cachePtr34, cachePtr35, cachePtr36, cachePtr37, cachePtr38, cachePtr39, cachePtr4, cachePtr40, cachePtr41, cachePtr42, cachePtr43, cachePtr44, cachePtr45, cachePtr46, cachePtr47, cachePtr48, cachePtr49, cachePtr5, cachePtr50, cachePtr51, cachePtr52, cachePtr53, cachePtr54, cachePtr55, cachePtr56, cachePtr57, cachePtr58, cachePtr59, cachePtr6, cachePtr60, cachePtr61, cachePtr62, cachePtr63, cachePtr64, cachePtr65, cachePtr66, cachePtr67, cachePtr68, cachePtr69, cachePtr7, cachePtr70, cachePtr71, cachePtr72, cachePtr73, cachePtr74, cachePtr75, cachePtr76, cachePtr77, cachePtr78, cachePtr79, cachePtr8, cachePtr80, cachePtr81, cachePtr82, cachePtr83, cachePtr84, cachePtr85, cachePtr86, cachePtr87, cachePtr88, cachePtr89, cachePtr9, cachePtr90, cachePtr91, cachePtr92, cachePtr93, cachePtr94, cachePtr95, cachePtr96, cachePtr97, cachePtr98, cachePtr99, cflags, ch, ch1, checkEq, checkInterp, classPtr, cleanup, cmd, code, code1, compare, compiledLocals, constants, contextPtr, copyPtr, corPtr, corPtr1, createdNewObj, curInstName, dictPtr, duiPtr, emptyPtr, end, end_indicator, flags, flags1, found, found1, framePtr1, framePtr2, fromIdxObj, hPtr, hasAbstractList, haveSecondIndex, i, i1, i2, i3, i4, iResult, incrPtr, increment, indexListPtr, infoPtr, inst, interruptCounter, irPtr, isAbstractList, iterMax, iterNum, iterTmp, j, jmpOffset, jtPtr, jumpOffset, keysPtr, level, linkPtr, listPtr, listPtr1, listPtr2, listTmpDepth, mPtr, methodType, methodType1, miPtr, msgPart, newCodePtr, newDepth, newTD, newValue, nocase, numIndices, numLists, numNewElems, numToDelete, numVars, oPtr, objPtr5, oldCatchTopOff, oldTosPtrOff, opnd, opnd2, origCmd, otherPtr, p, part1Ptr, part2Ptr, pc, pcAdjustment, proc, proc1, proc2, proc3, proc4, rangePtr, regExpr, res, resPtr, rootFramePtr, s1, s2, savedFramePtr, savedNsPtr, savedString, searchPtr, shift, skip, statePtr, status, status1, storeFlags, string1, string2, sum, tmpPtr, toIdxObj, tosPtr, trim1, ustring1, ustring11, ustring2, ustring21, ustring3, valIndex, value2Ptr, value3Ptr, valueToAssign, var2Ptr, varIndex, varListPtr, varNamePtr, w, w1, w2, wResult, wval, yieldParameter, v1, v10, v1000, v1001, v1002, v1003, v1004, v1007, v1008, v1009, v1010, v1011, v1012, v1015, v1016, v1017, v1018, v1019, v1020, v1023, v1024, v1025, v1026, v1027, v1028, v1029, v1032, v1033, v1034, v1035, v1036, v1037, v1038, v1039, v1040, v1043, v1044, v1045, v1048, v1049, v1050, v1062, v1063, v1064, v1065, v1066, v1067, v1070, v1071, v1072, v1073, v1074, v1075, v1078, v1079, v1080, v1081, v1082, v1083, v1086, v1087, v1088, v1089, v1090, v1091, v1092, v1095, v1096, v1097, v1098, v1099, v1101, v1103, v1104, v1107, v1108, v1109, v1110, v1111, v1113, v1115, v1116, v1117, v1119, v1121, v1122, v1123, v1124, v1136, v1137, v1138, v1139, v1140, v1141, v1144, v1145, v1146, v1147, v1148, v1149, v1152, v1153, v1154, v1155, v1156, v1157, v1160, v1161, v1162, v1163, v1164, v1165, v1166, v1169, v1170, v1171, v1172, v1173, v1175, v1177, v1178, v1179, v1181, v1183, v1186, v1187, v1188, v1191, v1192, v1193, v1196, v1197, v1198, v1199, v1202, v1203, v1204, v1207, v1208, v1209, v1210, v1211, v1214, v1215, v1216, v1219, v1220, v1221, v1222, v1223, v1225, v1227, v1228, v1229, v1231, v1233, v1240, v1243, v1244, v1245, v1248, v1249, v1250, v1253, v1254, v1255, v1258, v1259, v1260, v1261, v1264, v1265, v1266, v1267, v1268, v1270, v1272, v1273, v1276, v1277, v1278, v1281, v1282, v1283, v1286, v1287, v1288, v1291, v1292, v1293, v1294, v1295, v1297, v1299, v1302, v1303, v1304, v1305, v1308, v1309, v1310, v1313, v1314, v1315, v1318, v1319, v1320, v1323, v1324, v1325, v1326, v1327, v1329, v1331, v1334, v1335, v1336, v1339, v1340, v1341, v1344, v1345, v1346, v1349, v1350, v1351, v1354, v1355, v1356, v1358, v1359, v1360, v1361, v1362, v1363, v1364, v1365, v1366, v1367, v1369, v1370, v1371, v1372, v1374, v1375, v1376, v1377, v1378, v1381, v1382, v1383, v1386, v1387, v1388, v1389, v1390, v1393, v1394, v1395, v1398, v1399, v1400, v1401, v1404, v1405, v1406, v1407, v1410, v1411, v1412, v1415, v1416, v1417, v1418, v1421, v1422, v1423, v1426, v1427, v1428, v1429, v1432, v1433, v1434, v1435, v1436, v1437, v1438, v1442, v1443, v1444, v1445, v1446, v1447, v1448, v1449, v1450, v1451, v1452, v1453, v1454, v1455, v1456, v1457, v1458, v1459, v1460, v1461, v1462, v1463, v1464, v1465, v1466, v1467, v1468, v1469, v1470, v1471, v1472, v1473, v1474, v1477, v1478, v1479, v1482, v1483, v1484, v1485, v1486, v1487, v1488, v1489, v1490, v1491, v1492, v1493, v1494, v1495, v1496, v1497, v1498, v1499, v1500, v1501, v1502, v1503, v1515, v1516, v1517, v1518, v1519, v1520, v1523, v1524, v1525, v1526, v1527, v1528, v1531, v1532, v1533, v1534, v1535, v1536, v1539, v1540, v1541, v1542, v1543, v1544, v1545, v1548, v1549, v1550, v1551, v1552, v1553, v1555, v1556, v1557, v1558, v1559, v1560, v1561, v1564, v1565, v1566, v1569, v1570, v1571, v1572, v1573, v1574, v1575, v1577, v1578, v1579, v1580, v1581, v1582, v1585, v1586, v1587, v1588, v1589, v1590, v1593, v1594, v1595, v1596, v1597, v1598, v1599, v16, v1600, v1601, v1602, v1603, v1604, v1605, v1606, v1607, v1608, v1611, v1612, v1613, v1614, v1615, v1616, v1619, v1620, v1621, v1622, v1625, v1626, v1627, v1628, v1629, v1630, v1631, v1632, v1635, v1636, v1637, v1640, v1641, v1642, v1643, v1644, v1645, v1646, v1647, v1648, v1649, v1652, v1653, v1654, v1655, v1656, v1657, v1658, v1659, v1660, v1661, v17, v18, v19, v2, v20, v21, v22, v23, v24, v246, v247, v248, v249, v25, v250, v251, v254, v255, v256, v257, v258, v259, v26, v260, v261, v262, v263, v264, v265, v266, v267, v268, v269, v27, v272, v273, v274, v275, v276, v277, v278, v28, v281, v282, v283, v286, v287, v288, v291, v292, v293, v296, v297, v298, v299, v3, v302, v303, v304, v305, v306, v307, v308, v309, v310, v312, v313, v314, v315, v318, v319, v320, v321, v322, v323, v324, v325, v328, v329, v330, v331, v332, v333, v334, v335, v336, v338, v339, v34, v340, v343, v344, v345, v346, v349, v35, v350, v351, v352, v355, v356, v357, v358, v359, v36, v360, v361, v362, v365, v366, v367, v37, v370, v371, v372, v373, v374, v375, v376, v377, v378, v379, v38, v380, v381, v382, v383, v384, v385, v386, v387, v388, v389, v39, v390, v391, v392, v393, v394, v395, v397, v398, v399, v4, v40, v400, v401, v402, v403, v404, v405, v406, v408, v41, v410, v411, v412, v413, v414, v415, v416, v417, v418, v419, v42, v420, v421, v422, v423, v424, v425, v428, v429, v43, v430, v431, v432, v433, v434, v435, v436, v439, v44, v440, v441, v444, v445, v446, v447, v448, v449, v45, v450, v453, v454, v455, v458, v459, v46, v460, v463, v464, v465, v466, v467, v47, v470, v471, v472, v475, v476, v477, v48, v480, v481, v482, v485, v486, v487, v488, v49, v491, v492, v493, v494, v497, v498, v499, v5, v50, v502, v503, v504, v507, v508, v509, v51, v510, v513, v514, v515, v516, v519, v52, v520, v521, v522, v524, v525, v528, v529, v53, v530, v531, v534, v535, v536, v537, v539, v540, v541, v542, v545, v546, v547, v550, v551, v552, v553, v556, v557, v558, v559, v560, v561, v564, v565, v566, v569, v570, v571, v574, v575, v576, v577, v578, v579, v582, v583, v584, v585, v586, v587, v588, v590, v591, v592, v593, v595, v596, v597, v598, v599, v6, v600, v601, v602, v603, v604, v605, v606, v607, v610, v611, v612, v613, v614, v615, v616, v618, v619, v620, v622, v623, v624, v625, v626, v629, v630, v631, v632, v633, v634, v635, v636, v637, v638, v640, v641, v642, v645, v646, v647, v648, v649, v652, v653, v654, v657, v658, v659, v661, v664, v665, v666, v667, v668, v669, v670, v674, v675, v676, v677, v678, v679, v680, v681, v683, v684, v685, v686, v687, v688, v690, v691, v692, v693, v7, v705, v706, v707, v708, v709, v710, v713, v714, v715, v716, v717, v718, v721, v722, v723, v724, v725, v726, v729, v730, v731, v732, v733, v734, v735, v738, v739, v740, v741, v742, v743, v746, v747, v748, v751, v752, v753, v754, v755, v756, v757, v758, v770, v771, v772, v773, v774, v775, v778, v779, v780, v781, v782, v783, v786, v787, v788, v789, v790, v791, v794, v795, v796, v797, v798, v799, v8, v800, v803, v804, v805, v806, v809, v810, v811, v812, v813, v814, v815, v818, v819, v820, v821, v824, v825, v826, v827, v828, v829, v830, v833, v834, v835, v836, v839, v840, v841, v842, v843, v844, v845, v848, v849, v850, v851, v854, v855, v856, v857, v858, v859, v862, v863, v864, v865, v866, v867, v870, v871, v872, v873, v876, v877, v878, v879, v880, v881, v882, v883, v884, v885, v886, v887, v888, v889, v890, v891, v892, v893, v894, v895, v896, v899, v9, v900, v901, v902, v903, v904, v907, v908, v909, v910, v911, v912, v915, v916, v917, v918, v919, v920, v923, v924, v925, v929, v930, v931, v934, v935, v936, v938, v950, v951, v952, v953, v954, v955, v958, v959, v960, v961, v962, v963, v966, v967, v968, v969, v970, v971, v974, v975, v976, v977, v978, v979, v980, v983, v984, v985, v986, v987, v999
	/*
	 * Compiler cast directive - not a real variable.
	 *	   Interp *iPtr = (Interp *) interp;
	 */
	/*
	 * Check just the read-traced/write-traced bit of a variable.
	 */
	/*
	 * Bottom of allocated stack holds the NR data
	 */
	/*
	 * Constants: variables that do not change during the execution, used
	 * sporadically: no special need for speed.
	 */
	interruptCounter = uint32(1)
	compiledLocals = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FvarFramePtr)).FcompiledLocals
	constants = (*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr + 8
	/*
	 * These macros are just meant to save some global variables that are not
	 * used too frequently
	 */
	TD = *(*uintptr)(unsafe.Pointer(data)) /* Cached pointer to top of evaluation
	 * stack. */
	pc = *(*uintptr)(unsafe.Pointer(data + 1*8)) /* The currently running instruction */
	/*
	 * Transfer variables - needed only between opcodes, but not while
	 * executing an instruction.
	 */
	cleanup = int32(int64(*(*uintptr)(unsafe.Pointer(data + 2*8))))
	checkInterp = 0
	*(*uintptr)(unsafe.Pointer(bp + 24)) = libc.UintptrFromInt32(0)
	*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = 0
	tosPtr = (*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr
	if !(pc != 0) {
		/* bytecode is starting from scratch */
		pc = (*TByteCode)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)).FcodeStart
		/*
		 * Reset the interp's result to avoid possible duplications of large
		 * objects [3c6e47363e], [781585], [804681], This can happen by start
		 * also in nested compiled blocks (enclosed in parent cycle).
		 * See else branch below for opposite handling by continuation/resume.
		 */
		objPtr5 = (*TInterp)(unsafe.Pointer(interp4)).FobjResultPtr
		if (*TTcl_Obj)(unsafe.Pointer(objPtr5)).FrefCount > int64(1) {
			v2 = objPtr5
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if !(v1 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(objPtr5)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr5)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(objPtr5)).Flength = int64(-libc.Int32FromInt32(1))
					if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
						cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, objPtr5)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(objPtr5 + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = objPtr5
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, objPtr5)
				}
			}
			if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
				objPtr5 = XTclThreadAllocObj(tls)
			} else {
				objPtr5 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr5 + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(objPtr5)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(objPtr5)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(objPtr5)).FtypePtr = libc.UintptrFromInt32(0)
			(*TTcl_Obj)(unsafe.Pointer(objPtr5)).FrefCount++
			(*TInterp)(unsafe.Pointer(interp4)).FobjResultPtr = objPtr5
		}
		goto cleanup0
	} else {
		/* resume from invocation */
		checkInterp = int32(1)
		if (*TCmdFrame)(unsafe.Pointer(TD+24)).FcmdObj != 0 {
			_objPtr1 = (*TCmdFrame)(unsafe.Pointer(TD + 24)).FcmdObj
			v6 = _objPtr1
			v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
			*(*TTcl_Size)(unsafe.Pointer(v6))--
			if v5 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
			(*TCmdFrame)(unsafe.Pointer(TD + 24)).FcmdObj = libc.UintptrFromInt32(0)
			(*TCmdFrame)(unsafe.Pointer(TD + 24)).Fcmd = libc.UintptrFromInt32(0)
		}
		(*TInterp)(unsafe.Pointer(interp4)).FcmdFramePtr = (*TCmdFrame)(unsafe.Pointer(TD + 24)).FnextPtr
		if (*TInterp)(unsafe.Pointer(interp4)).Fflags&int32(INTERP_DEBUG_FRAME) != 0 {
			XTclArgumentBCRelease(tls, interp4, TD+24)
		}
		if (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).Frewind != 0 {
			result = int32(TCL_ERROR)
			goto abnormalReturn
		}
		if (*TByteCode)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)).Fflags&uint32(TCL_BYTECODE_RECOMPILE) != 0 {
			*(*uint32)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr + 40)) &= libc.Uint32FromInt32(^libc.Int32FromInt32(TCL_BYTECODE_RECOMPILE))
			checkInterp = int32(1)
			*(*int32)(unsafe.Pointer(interp4 + 368)) |= int32(ERR_ALREADY_LOGGED)
		}
		if result != TCL_OK {
			pc--
			goto processExceptionReturn
		}
		/*
		 * Push the call's object result and continue execution with the next
		 * instruction.
		 */
		/*
		 * Obtain and reset interp's result to avoid possible duplications of
		 * objects [Bug 781585]. We do not call Tcl_ResetResult to avoid any
		 * side effects caused by the resetting of errorInfo and errorCode
		 * [Bug 804681], which are not needed here. We chose instead to
		 * manipulate the interp's object result directly.
		 *
		 * Note that the result object is now in objResultPtr, it keeps the
		 * refCount it had in its role of iPtr->objResultPtr.
		 */
		*(*uintptr)(unsafe.Pointer(bp + 8)) = XTcl_GetObjResult(tls, interp4)
		if v7 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v7 {
			cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v7 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
			objPtr5 = XTclThreadAllocObj(tls)
		} else {
			objPtr5 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr5 + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(objPtr5)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(objPtr5)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(objPtr5)).FtypePtr = libc.UintptrFromInt32(0)
		(*TTcl_Obj)(unsafe.Pointer(objPtr5)).FrefCount++
		(*TInterp)(unsafe.Pointer(interp4)).FobjResultPtr = objPtr5
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) == int32(INST_POP) {
			v9 = *(*uintptr)(unsafe.Pointer(bp + 8))
			v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
			*(*TTcl_Size)(unsafe.Pointer(v9))--
			if !(v8 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = int64(-libc.Int32FromInt32(1))
					if v10 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v10 {
						cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v10 || ((*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
						(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
				}
			}
			pc += uintptr(libc.Int32FromInt32(1))
			cleanup = cleanup
			if 0 != 0 {
				if 0 > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				goto cleanupV_pushObjResultPtr
			} else {
				goto cleanupV
			}
		}
		pc += uintptr(libc.Int32FromInt32(0))
		cleanup = cleanup
		if -int32(1) != 0 {
			if -int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			goto cleanupV_pushObjResultPtr
		} else {
			goto cleanupV
		}
	}
	/*
	 * Targets for standard instruction endings; unrolled for speed in the
	 * most frequent cases (instructions that consume up to two stack
	 * elements).
	 *
	 * This used to be a "for(;;)" loop, with each instruction doing its own
	 * cleanup.
	 */
	goto cleanupV_pushObjResultPtr
cleanupV_pushObjResultPtr:
	;
	switch cleanup {
	case 0:
		goto _11
	default:
		goto _12
	case int32(2):
		goto _13
	case int32(1):
		goto _14
	}
	goto _15
_11:
	;
	tosPtr += 8
	v16 = tosPtr
	*(*uintptr)(unsafe.Pointer(v16)) = *(*uintptr)(unsafe.Pointer(bp + 8))
	goto cleanup0
_12:
	;
	cleanup -= int32(2)
	for {
		v17 = cleanup
		cleanup--
		if !(v17 != 0) {
			break
		}
		v18 = tosPtr
		tosPtr -= 8
		objPtr5 = *(*uintptr)(unsafe.Pointer(v18))
		v20 = objPtr5
		v19 = *(*TTcl_Size)(unsafe.Pointer(v20))
		*(*TTcl_Size)(unsafe.Pointer(v20))--
		if !(v19 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(objPtr5)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr5)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(objPtr5)).Flength = int64(-libc.Int32FromInt32(1))
				if v21 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v21 {
					cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v21 || ((*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, objPtr5)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(objPtr5 + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = objPtr5
					(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, objPtr5)
			}
		}
	}
	/* FALLTHRU */
_13:
	;
	goto cleanup2_pushObjResultPtr
cleanup2_pushObjResultPtr:
	;
	v22 = tosPtr
	tosPtr -= 8
	objPtr5 = *(*uintptr)(unsafe.Pointer(v22))
	v24 = objPtr5
	v23 = *(*TTcl_Size)(unsafe.Pointer(v24))
	*(*TTcl_Size)(unsafe.Pointer(v24))--
	if !(v23 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(objPtr5)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr5)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(objPtr5)).Flength = int64(-libc.Int32FromInt32(1))
			if v25 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v25 {
				cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v25 || ((*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, objPtr5)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr5 + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = objPtr5
				(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, objPtr5)
		}
	}
	/* FALLTHRU */
_14:
	;
	goto cleanup1_pushObjResultPtr
cleanup1_pushObjResultPtr:
	;
	objPtr5 = *(*uintptr)(unsafe.Pointer(tosPtr))
	v27 = objPtr5
	v26 = *(*TTcl_Size)(unsafe.Pointer(v27))
	*(*TTcl_Size)(unsafe.Pointer(v27))--
	if !(v26 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(objPtr5)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr5)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(objPtr5)).Flength = int64(-libc.Int32FromInt32(1))
			if v28 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v28 {
				cachePtr6 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v28 || ((*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, objPtr5)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr5 + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr = objPtr5
				(*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, objPtr5)
		}
	}
_15:
	;
	*(*uintptr)(unsafe.Pointer(tosPtr)) = *(*uintptr)(unsafe.Pointer(bp + 8))
	goto cleanup0
	goto cleanupV
cleanupV:
	;
	switch cleanup {
	default:
		goto _29
	case int32(2):
		goto _30
	case int32(1):
		goto _31
	case 0:
		goto _32
	}
	goto _33
_29:
	;
	cleanup -= int32(2)
	for {
		v34 = cleanup
		cleanup--
		if !(v34 != 0) {
			break
		}
		v35 = tosPtr
		tosPtr -= 8
		objPtr5 = *(*uintptr)(unsafe.Pointer(v35))
		v37 = objPtr5
		v36 = *(*TTcl_Size)(unsafe.Pointer(v37))
		*(*TTcl_Size)(unsafe.Pointer(v37))--
		if !(v36 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(objPtr5)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr5)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(objPtr5)).Flength = int64(-libc.Int32FromInt32(1))
				if v38 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v38 {
					cachePtr7 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v38 || ((*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, objPtr5)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(objPtr5 + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr = objPtr5
					(*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, objPtr5)
			}
		}
	}
	/* FALLTHRU */
_30:
	;
	goto cleanup2
cleanup2:
	;
	v39 = tosPtr
	tosPtr -= 8
	objPtr5 = *(*uintptr)(unsafe.Pointer(v39))
	v41 = objPtr5
	v40 = *(*TTcl_Size)(unsafe.Pointer(v41))
	*(*TTcl_Size)(unsafe.Pointer(v41))--
	if !(v40 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(objPtr5)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr5)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(objPtr5)).Flength = int64(-libc.Int32FromInt32(1))
			if v42 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v42 {
				cachePtr8 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v42 || ((*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, objPtr5)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr5 + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr8)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr8)).FfirstObjPtr = objPtr5
				(*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, objPtr5)
		}
	}
	/* FALLTHRU */
_31:
	;
	goto cleanup1
cleanup1:
	;
	v43 = tosPtr
	tosPtr -= 8
	objPtr5 = *(*uintptr)(unsafe.Pointer(v43))
	v45 = objPtr5
	v44 = *(*TTcl_Size)(unsafe.Pointer(v45))
	*(*TTcl_Size)(unsafe.Pointer(v45))--
	if !(v44 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(objPtr5)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr5)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(objPtr5)).Flength = int64(-libc.Int32FromInt32(1))
			if v46 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v46 {
				cachePtr9 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v46 || ((*TAllocCache)(unsafe.Pointer(cachePtr9)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr9)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, objPtr5)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr5 + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr9)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr9)).FfirstObjPtr = objPtr5
				(*TAllocCache)(unsafe.Pointer(cachePtr9)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, objPtr5)
		}
	}
	/* FALLTHRU */
_32:
	;
	/*
	 * We really want to do nothing now, but this is needed for some
	 * compilers (SunPro CC).
	 */
	goto _33
_33:
	;
	goto cleanup0
cleanup0:
	;
	/*
	 * Check for asynchronous handlers [Bug 746722]; we do the check every
	 * ASYNC_CHECK_COUNT instructions.
	 */
	interruptCounter--
	v47 = interruptCounter
	if v47 == uint32(0) {
		interruptCounter = uint32(ASYNC_CHECK_COUNT)
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		if *(*int32)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FasyncReadyPtr)) != 0 {
			result = XTcl_AsyncInvoke(tls, interp4, result)
			if result == int32(TCL_ERROR) {
				checkInterp = int32(1)
				goto gotError
			}
		}
		if (*TInterp)(unsafe.Pointer(interp4)).Fflags&int32(CANCELED) != 0 || (*TInterp)(unsafe.Pointer(interp4)).Fflags&int32(TCL_CANCEL_UNWIND) != 0 {
			if XTcl_Canceled(tls, interp4, int32(TCL_LEAVE_ERR_MSG)) == int32(TCL_ERROR) {
				checkInterp = int32(1)
				goto gotError
			}
		}
		if (*TInterp)(unsafe.Pointer(interp4)).Flimit.Factive == 0 {
			v48 = 0
		} else {
			(*TInterp)(unsafe.Pointer(interp4)).Flimit.FgranularityTicker++
			if (*TInterp)(unsafe.Pointer(interp4)).Flimit.Factive&int32(TCL_LIMIT_COMMANDS) != 0 && ((*TInterp)(unsafe.Pointer(interp4)).Flimit.FcmdGranularity == int32(1) || (*TInterp)(unsafe.Pointer(interp4)).Flimit.FgranularityTicker%(*TInterp)(unsafe.Pointer(interp4)).Flimit.FcmdGranularity == 0) {
				v49 = int32(1)
			} else {
				if (*TInterp)(unsafe.Pointer(interp4)).Flimit.Factive&int32(TCL_LIMIT_TIME) != 0 && ((*TInterp)(unsafe.Pointer(interp4)).Flimit.FtimeGranularity == int32(1) || (*TInterp)(unsafe.Pointer(interp4)).Flimit.FgranularityTicker%(*TInterp)(unsafe.Pointer(interp4)).Flimit.FtimeGranularity == 0) {
					v50 = int32(1)
				} else {
					v50 = 0
				}
				v49 = v50
			}
			v48 = v49
		}
		if v48 != 0 {
			if XTcl_LimitCheck(tls, interp4) == int32(TCL_ERROR) {
				checkInterp = int32(1)
				goto gotError
			}
		}
		checkInterp = int32(1)
	}
	/*
	 * These two instructions account for 26% of all instructions (according
	 * to measurements on tclbench by Ben Vitale
	 * [http://www.cs.toronto.edu/syslab/pubs/tcl2005-vitale-zaleski.pdf]
	 * Resolving them before the switch reduces the cost of branch
	 * mispredictions, seems to improve runtime by 5% to 15%, and (amazingly!)
	 * reduces total obj size.
	 */
	inst = *(*uint8)(unsafe.Pointer(pc))
	goto peepholeStart
peepholeStart:
	;
	if 0 != 0 {
		if curInstName != 0 {
		}
		curInstName = XtclInstructionTable[*(*uint8)(unsafe.Pointer(pc))].Fname
		if 0 != 0 {
		}
	} else {
		if 0 != 0 {
		}
	}
	if libc.Int32FromUint8(inst) == int32(INST_LOAD_SCALAR1) {
		goto instLoadScalar1
	} else {
		if libc.Int32FromUint8(inst) == int32(INST_PUSH1) {
			v51 = *(*uintptr)(unsafe.Pointer((*TByteCode)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)).FobjArrayPtr + uintptr(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1)))))*8))
			tosPtr += 8
			v52 = tosPtr
			*(*uintptr)(unsafe.Pointer(v52)) = v51
			(*TTcl_Obj)(unsafe.Pointer(v51)).FrefCount++
			pc += uintptr(2)
			inst = *(*uint8)(unsafe.Pointer(pc))
			goto peepholeStart
		} else {
			if libc.Int32FromUint8(inst) == int32(INST_START_CMD) {
				/*
				 * Peephole: do not run INST_START_CMD, just skip it
				 */
				*(*TTcl_Size)(unsafe.Pointer(interp4 + 248)) += libc.Int64FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5) + libc.UintptrFromInt32(3))))))
				if checkInterp != 0 {
					if ((*TByteCode)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)).FcompileEpoch != (*TInterp)(unsafe.Pointer(interp4)).FcompileEpoch || (*TByteCode)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)).FnsEpoch != (*TNamespace)(unsafe.Pointer((*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FvarFramePtr)).FnsPtr)).FresolverEpoch) && !((*TByteCode)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)).Fflags&libc.Uint32FromInt32(TCL_BYTECODE_PRECOMPILED) != 0) {
						goto instStartCmdFailed
					}
					checkInterp = 0
				}
				pc += uintptr(9)
				inst = *(*uint8)(unsafe.Pointer(pc))
				goto peepholeStart
			} else {
				if libc.Int32FromUint8(inst) == int32(INST_NOP) {
					for libc.Int32FromUint8(inst) == int32(INST_NOP) {
						pc++
						v53 = pc
						inst = *(*uint8)(unsafe.Pointer(v53))
					}
					goto peepholeStart
				}
			}
		}
	}
	switch libc.Int32FromUint8(inst) {
	case int32(INST_RETURN_IMM):
		goto _54
	case int32(INST_SYNTAX):
		goto _55
	case int32(INST_RETURN_STK):
		goto _56
	case int32(INST_YIELD):
		goto _57
	case int32(INST_YIELD_TO_INVOKE):
		goto _58
	case int32(INST_TAILCALL):
		goto _59
	case int32(INST_DONE):
		goto _60
	case int32(INST_PUSH4):
		goto _61
	case int32(INST_POP):
		goto _62
	case int32(INST_DUP):
		goto _63
	case int32(INST_OVER):
		goto _64
	case int32(INST_REVERSE):
		goto _65
	case int32(INST_STR_CONCAT1):
		goto _66
	case int32(INST_CONCAT_STK):
		goto _67
	case int32(INST_EXPAND_START):
		goto _68
	case int32(INST_EXPAND_DROP):
		goto _69
	case int32(INST_EXPAND_STKTOP):
		goto _70
	case int32(INST_EXPR_STK):
		goto _71
	case int32(INST_EVAL_STK):
		goto _72
	case int32(INST_INVOKE_EXPANDED):
		goto _73
	case int32(INST_INVOKE_STK4):
		goto _74
	case int32(INST_INVOKE_STK1):
		goto _75
	case int32(INST_INVOKE_REPLACE):
		goto _76
	case int32(INST_LOAD_SCALAR1):
		goto _77
	case int32(INST_LOAD_SCALAR4):
		goto _78
	case int32(INST_LOAD_ARRAY4):
		goto _79
	case int32(INST_LOAD_ARRAY1):
		goto _80
	case int32(INST_LOAD_ARRAY_STK):
		goto _81
	case int32(INST_LOAD_SCALAR_STK):
		goto _82
	case int32(INST_LOAD_STK):
		goto _83
	case int32(INST_STORE_ARRAY4):
		goto _84
	case int32(INST_STORE_ARRAY1):
		goto _85
	case int32(INST_STORE_SCALAR4):
		goto _86
	case int32(INST_STORE_SCALAR1):
		goto _87
	case int32(INST_LAPPEND_STK):
		goto _88
	case int32(INST_LAPPEND_ARRAY_STK):
		goto _89
	case int32(INST_APPEND_STK):
		goto _90
	case int32(INST_APPEND_ARRAY_STK):
		goto _91
	case int32(INST_STORE_ARRAY_STK):
		goto _92
	case int32(INST_STORE_SCALAR_STK):
		goto _93
	case int32(INST_STORE_STK):
		goto _94
	case int32(INST_LAPPEND_ARRAY4):
		goto _95
	case int32(INST_LAPPEND_ARRAY1):
		goto _96
	case int32(INST_APPEND_ARRAY4):
		goto _97
	case int32(INST_APPEND_ARRAY1):
		goto _98
	case int32(INST_LAPPEND_SCALAR4):
		goto _99
	case int32(INST_LAPPEND_SCALAR1):
		goto _100
	case int32(INST_APPEND_SCALAR4):
		goto _101
	case int32(INST_APPEND_SCALAR1):
		goto _102
	case int32(INST_LAPPEND_LIST):
		goto _103
	case int32(INST_LAPPEND_LIST_ARRAY):
		goto _104
	case int32(INST_LAPPEND_LIST_ARRAY_STK):
		goto _105
	case int32(INST_LAPPEND_LIST_STK):
		goto _106
	case int32(INST_INCR_STK):
		goto _107
	case int32(INST_INCR_SCALAR_STK):
		goto _108
	case int32(INST_INCR_ARRAY_STK):
		goto _109
	case int32(INST_INCR_ARRAY1):
		goto _110
	case int32(INST_INCR_SCALAR1):
		goto _111
	case int32(INST_INCR_STK_IMM):
		goto _112
	case int32(INST_INCR_SCALAR_STK_IMM):
		goto _113
	case int32(INST_INCR_ARRAY_STK_IMM):
		goto _114
	case int32(INST_INCR_ARRAY1_IMM):
		goto _115
	case int32(INST_INCR_SCALAR1_IMM):
		goto _116
	case int32(INST_EXIST_SCALAR):
		goto _117
	case int32(INST_EXIST_ARRAY):
		goto _118
	case int32(INST_EXIST_ARRAY_STK):
		goto _119
	case int32(INST_EXIST_STK):
		goto _120
	case int32(INST_UNSET_SCALAR):
		goto _121
	case int32(INST_UNSET_ARRAY):
		goto _122
	case int32(INST_UNSET_ARRAY_STK):
		goto _123
	case int32(INST_UNSET_STK):
		goto _124
	case int32(INST_CONST_IMM):
		goto _125
	case int32(INST_CONST_STK):
		goto _126
	case int32(INST_ARRAY_EXISTS_IMM):
		goto _127
	case int32(INST_ARRAY_EXISTS_STK):
		goto _128
	case int32(INST_ARRAY_MAKE_IMM):
		goto _129
	case int32(INST_ARRAY_MAKE_STK):
		goto _130
	case int32(INST_UPVAR):
		goto _131
	case int32(INST_NSUPVAR):
		goto _132
	case int32(INST_VARIABLE):
		goto _133
	case int32(INST_JUMP1):
		goto _134
	case int32(INST_JUMP4):
		goto _135
	case int32(INST_JUMP_FALSE4):
		goto _136
	case int32(INST_JUMP_TRUE4):
		goto _137
	case int32(INST_JUMP_FALSE1):
		goto _138
	case int32(INST_JUMP_TRUE1):
		goto _139
	case int32(INST_JUMP_TABLE):
		goto _140
	case int32(INST_NS_CURRENT):
		goto _141
	case int32(INST_COROUTINE_NAME):
		goto _142
	case int32(INST_INFO_LEVEL_NUM):
		goto _143
	case int32(INST_INFO_LEVEL_ARGS):
		goto _144
	case int32(INST_RESOLVE_COMMAND):
		goto _145
	case int32(INST_ORIGIN_COMMAND):
		goto _146
	case int32(INST_TCLOO_SELF):
		goto _147
	case int32(INST_TCLOO_NEXT_CLASS):
		goto _148
	case int32(INST_TCLOO_NEXT):
		goto _149
	case int32(INST_TCLOO_IS_OBJECT):
		goto _150
	case int32(INST_TCLOO_CLASS):
		goto _151
	case int32(INST_TCLOO_NS):
		goto _152
	case int32(INST_LIST):
		goto _153
	case int32(INST_LIST_LENGTH):
		goto _154
	case int32(INST_LIST_INDEX):
		goto _155
	case int32(INST_LIST_INDEX_IMM):
		goto _156
	case int32(INST_LIST_INDEX_MULTI):
		goto _157
	case int32(INST_LSET_FLAT):
		goto _158
	case int32(INST_LSET_LIST):
		goto _159
	case int32(INST_LIST_RANGE_IMM):
		goto _160
	case int32(INST_LIST_NOT_IN):
		goto _161
	case int32(INST_LIST_IN):
		goto _162
	case int32(INST_LIST_CONCAT):
		goto _163
	case int32(INST_LREPLACE4):
		goto _164
	case int32(INST_STR_GE):
		goto _165
	case int32(INST_STR_LE):
		goto _166
	case int32(INST_STR_GT):
		goto _167
	case int32(INST_STR_LT):
		goto _168
	case int32(INST_STR_CMP):
		goto _169
	case int32(INST_STR_NEQ):
		goto _170
	case int32(INST_STR_EQ):
		goto _171
	case int32(INST_STR_LEN):
		goto _172
	case int32(INST_STR_UPPER):
		goto _173
	case int32(INST_STR_LOWER):
		goto _174
	case int32(INST_STR_TITLE):
		goto _175
	case int32(INST_STR_INDEX):
		goto _176
	case int32(INST_STR_RANGE):
		goto _177
	case int32(INST_STR_RANGE_IMM):
		goto _178
	case int32(INST_STR_REPLACE):
		goto _179
	case int32(INST_STR_MAP):
		goto _180
	case int32(INST_STR_FIND):
		goto _181
	case int32(INST_STR_FIND_LAST):
		goto _182
	case int32(INST_STR_CLASS):
		goto _183
	case int32(INST_STR_MATCH):
		goto _184
	case int32(INST_STR_TRIM_LEFT):
		goto _185
	case int32(INST_STR_TRIM_RIGHT):
		goto _186
	case int32(INST_STR_TRIM):
		goto _187
	case int32(INST_REGEXP):
		goto _188
	case int32(INST_NUM_TYPE):
		goto _189
	case int32(INST_GE):
		goto _190
	case int32(INST_LE):
		goto _191
	case int32(INST_GT):
		goto _192
	case int32(INST_LT):
		goto _193
	case int32(INST_NEQ):
		goto _194
	case int32(INST_EQ):
		goto _195
	case int32(INST_BITAND):
		goto _196
	case int32(INST_BITXOR):
		goto _197
	case int32(INST_BITOR):
		goto _198
	case int32(INST_RSHIFT):
		goto _199
	case int32(INST_LSHIFT):
		goto _200
	case int32(INST_MOD):
		goto _201
	case int32(INST_MULT):
		goto _202
	case int32(INST_DIV):
		goto _203
	case int32(INST_SUB):
		goto _204
	case int32(INST_ADD):
		goto _205
	case int32(INST_EXPON):
		goto _206
	case int32(INST_LNOT):
		goto _207
	case int32(INST_BITNOT):
		goto _208
	case int32(INST_UMINUS):
		goto _209
	case int32(INST_TRY_CVT_TO_NUMERIC):
		goto _210
	case int32(INST_UPLUS):
		goto _211
	case int32(INST_TRY_CVT_TO_BOOLEAN):
		goto _212
	case int32(INST_BREAK):
		goto _213
	case int32(INST_CONTINUE):
		goto _214
	case int32(INST_FOREACH_START):
		goto _215
	case int32(INST_FOREACH_STEP):
		goto _216
	case int32(INST_FOREACH_END):
		goto _217
	case int32(INST_LMAP_COLLECT):
		goto _218
	case int32(INST_BEGIN_CATCH4):
		goto _219
	case int32(INST_END_CATCH):
		goto _220
	case int32(INST_PUSH_RESULT):
		goto _221
	case int32(INST_PUSH_RETURN_CODE):
		goto _222
	case int32(INST_PUSH_RETURN_OPTIONS):
		goto _223
	case int32(INST_RETURN_CODE_BRANCH):
		goto _224
	case int32(INST_DICT_VERIFY):
		goto _225
	case int32(INST_DICT_EXISTS):
		goto _226
	case int32(INST_DICT_GET):
		goto _227
	case int32(INST_DICT_GET_DEF):
		goto _228
	case int32(INST_DICT_INCR_IMM):
		goto _229
	case int32(INST_DICT_UNSET):
		goto _230
	case int32(INST_DICT_SET):
		goto _231
	case int32(INST_DICT_LAPPEND):
		goto _232
	case int32(INST_DICT_APPEND):
		goto _233
	case int32(INST_DICT_FIRST):
		goto _234
	case int32(INST_DICT_NEXT):
		goto _235
	case int32(INST_DICT_UPDATE_START):
		goto _236
	case int32(INST_DICT_UPDATE_END):
		goto _237
	case int32(INST_DICT_EXPAND):
		goto _238
	case int32(INST_DICT_RECOMBINE_STK):
		goto _239
	case int32(INST_DICT_RECOMBINE_IMM):
		goto _240
	case int32(INST_CLOCK_READ):
		goto _241
	default:
		goto _242
	}
	goto _243
_55:
	;
_54:
	;
	code = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
	level = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5) + libc.UintptrFromInt32(3))))))
	/*
	 * OBJ_AT_TOS is returnOpts, OBJ_UNDER_TOS is resultObjPtr.
	 */
	result = XTclProcessReturn(tls, interp4, code, level, *(*uintptr)(unsafe.Pointer(tosPtr)))
	if result == TCL_OK {
		if false {
			if 0 != 0 {
				if 0 > 0 {
					v246 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v247 = tosPtr
					*(*uintptr)(unsafe.Pointer(v247)) = v246
					(*TTcl_Obj)(unsafe.Pointer(v246)).FrefCount++
				} else {
					tosPtr += 8
					v248 = tosPtr
					*(*uintptr)(unsafe.Pointer(v248)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(9))
			goto cleanup0
		} else {
			if 0 != 0 {
				if 0 > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(9))
				switch libc.Int32FromInt32(1) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(9))
				switch libc.Int32FromInt32(1) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _245
	_245:
		;
		goto _244
	_244: /**/ //
	}
	XTcl_SetObjResult(tls, interp4, *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)))
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) == int32(INST_SYNTAX) {
		*(*int32)(unsafe.Pointer(interp4 + 368)) &= ^libc.Int32FromInt32(ERR_ALREADY_LOGGED)
	}
	cleanup = int32(2)
	goto processExceptionReturn
_56:
	;
	v249 = tosPtr
	tosPtr -= 8
	*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(v249))
	result = XTcl_SetReturnOptions(tls, interp4, *(*uintptr)(unsafe.Pointer(tosPtr)))
	if result == TCL_OK {
		_objPtr2 = *(*uintptr)(unsafe.Pointer(tosPtr))
		v251 = _objPtr2
		v250 = *(*TTcl_Size)(unsafe.Pointer(v251))
		*(*TTcl_Size)(unsafe.Pointer(v251))--
		if v250 <= int64(1) {
			XTclFreeObj(tls, _objPtr2)
		}
		*(*uintptr)(unsafe.Pointer(tosPtr)) = *(*uintptr)(unsafe.Pointer(bp + 8))
		if true {
			if 0 != 0 {
				if 0 > 0 {
					v254 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v255 = tosPtr
					*(*uintptr)(unsafe.Pointer(v255)) = v254
					(*TTcl_Obj)(unsafe.Pointer(v254)).FrefCount++
				} else {
					tosPtr += 8
					v256 = tosPtr
					*(*uintptr)(unsafe.Pointer(v256)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(1))
			goto cleanup0
		} else {
			if 0 != 0 {
				if 0 > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _253
	_253:
		;
		goto _252
	_252: /**/
		//
	} else {
		if result == int32(TCL_ERROR) {
			/*
			 * BEWARE! Must do this in this order, because an error in the
			 * option dictionary overrides the result (and can be verified by
			 * test).
			 */
			XTcl_SetObjResult(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 8)))
			XTcl_SetReturnOptions(tls, interp4, *(*uintptr)(unsafe.Pointer(tosPtr)))
			_objPtr3 = *(*uintptr)(unsafe.Pointer(tosPtr))
			v258 = _objPtr3
			v257 = *(*TTcl_Size)(unsafe.Pointer(v258))
			*(*TTcl_Size)(unsafe.Pointer(v258))--
			if v257 <= int64(1) {
				XTclFreeObj(tls, _objPtr3)
			}
			*(*uintptr)(unsafe.Pointer(tosPtr)) = *(*uintptr)(unsafe.Pointer(bp + 8))
		} else {
			_objPtr4 = *(*uintptr)(unsafe.Pointer(tosPtr))
			v260 = _objPtr4
			v259 = *(*TTcl_Size)(unsafe.Pointer(v260))
			*(*TTcl_Size)(unsafe.Pointer(v260))--
			if v259 <= int64(1) {
				XTclFreeObj(tls, _objPtr4)
			}
			*(*uintptr)(unsafe.Pointer(tosPtr)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			XTcl_SetObjResult(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 8)))
		}
	}
	cleanup = int32(1)
	goto processExceptionReturn
_57:
	;
	corPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FcorPtr
	if !(corPtr != 0) {
		XTcl_SetObjResult(tls, interp4, XTcl_NewStringObj(tls, __ccgo_ts+9331, int64(-int32(1))))
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		XTcl_SetErrorCode(tls, interp4, libc.VaList(bp+544, __ccgo_ts+2004, __ccgo_ts+9371, __ccgo_ts+9381, libc.UintptrFromInt32(0)))
		checkInterp = int32(1)
		goto gotError
	}
	yieldParameter = libc.UintptrFromInt32(0) /*==CORO_ACTIVATE_YIELD*/
	XTcl_SetObjResult(tls, interp4, *(*uintptr)(unsafe.Pointer(tosPtr)))
	goto doYield
_58:
	;
	corPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FcorPtr
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr))
	if !(corPtr != 0) {
		XTcl_SetObjResult(tls, interp4, XTcl_NewStringObj(tls, __ccgo_ts+9413, int64(-int32(1))))
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		XTcl_SetErrorCode(tls, interp4, libc.VaList(bp+544, __ccgo_ts+2004, __ccgo_ts+9371, __ccgo_ts+9381, libc.UintptrFromInt32(0)))
		checkInterp = int32(1)
		goto gotError
	}
	if (*TNamespace)(unsafe.Pointer((*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FvarFramePtr)).FnsPtr)).Fflags&int32(NS_DYING) != 0 {
		XTcl_SetObjResult(tls, interp4, XTcl_NewStringObj(tls, __ccgo_ts+9455, int64(-int32(1))))
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		XTcl_SetErrorCode(tls, interp4, libc.VaList(bp+544, __ccgo_ts+2004, __ccgo_ts+9371, __ccgo_ts+9491, libc.UintptrFromInt32(0)))
		checkInterp = int32(1)
		goto gotError
	}
	/*
	 * Install a tailcall record in the caller and continue with the
	 * yield. The yield is switched into multi-return mode (via the
	 * 'yieldParameter').
	 */
	(*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).FcallerEEPtr
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount++
	XTclSetTailcall(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 16)))
	(*TCoroutineData)(unsafe.Pointer(corPtr)).FyieldPtr = *(*uintptr)(unsafe.Pointer(bp + 16))
	(*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr = (*TCoroutineData)(unsafe.Pointer(corPtr)).FeePtr
	yieldParameter = uintptr(int64(libc.Int32FromInt32(1))) /*==CORO_ACTIVATE_YIELDM*/
	goto doYield
doYield:
	;
	/* TIP #280: Record the last piece of info needed by
	 * 'TclGetSrcInfoForPc', and push the frame.
	 */
	(*(*struct {
		FcodePtr uintptr
		Fpc      uintptr
	})(unsafe.Pointer(TD + 24 + 40))).Fpc = pc
	(*TInterp)(unsafe.Pointer(interp4)).FcmdFramePtr = TD + 24
	if (*TInterp)(unsafe.Pointer(interp4)).Fflags&int32(INTERP_DEBUG_FRAME) != 0 {
		_ArgumentBCEnter(tls, interp4, (*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr, TD, pc, *(*TTcl_Size)(unsafe.Pointer(bp + 40)), *(*uintptr)(unsafe.Pointer(bp + 24)))
	}
	pc++
	cleanup = int32(1)
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	if v261 = interp4 == libc.UintptrFromInt32(0); !v261 {
		cachePtr10 = (*TInterp)(unsafe.Pointer(interp4)).FallocCache
	}
	if v261 || (*TAllocCache)(unsafe.Pointer(cachePtr10)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr5 = XTclThreadAllocObj(tls)
	} else {
		_objPtr5 = (*TAllocCache)(unsafe.Pointer(cachePtr10)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr10)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr5 + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr10)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 64)) = _objPtr5
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 64)))).FprocPtr = __ccgo_fp(_TEBCresume)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 64)) + 8)) = TD
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 64)) + 8 + 1*8)) = pc
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 64)) + 8 + 2*8)) = uintptr(int64(cleanup))
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 64)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 64)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 64))
	if v262 = interp4 == libc.UintptrFromInt32(0); !v262 {
		cachePtr11 = (*TInterp)(unsafe.Pointer(interp4)).FallocCache
	}
	if v262 || (*TAllocCache)(unsafe.Pointer(cachePtr11)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr6 = XTclThreadAllocObj(tls)
	} else {
		_objPtr6 = (*TAllocCache)(unsafe.Pointer(cachePtr11)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr11)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr6 + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr11)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 72)) = _objPtr6
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)))).FprocPtr = __ccgo_fp(XTclNRCoroutineActivateCallback)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)) + 8)) = corPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)) + 8 + 1*8)) = yieldParameter
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 72))
	return TCL_OK
_59:
	;
	opnd = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1)))))
	if !((*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FvarFramePtr)).FisProcCallFrame&libc.Int32FromInt32(1) != 0) {
		XTcl_SetObjResult(tls, interp4, XTcl_NewStringObj(tls, __ccgo_ts+32066, int64(-int32(1))))
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		XTcl_SetErrorCode(tls, interp4, libc.VaList(bp+544, __ccgo_ts+2004, __ccgo_ts+9261, __ccgo_ts+9270, libc.UintptrFromInt32(0)))
		checkInterp = int32(1)
		goto gotError
	}
	/*
	 * Push the evaluation of the called command into the NR callback
	 * stack.
	 */
	listPtr = XTcl_NewListObj(tls, int64(opnd), tosPtr+uintptr(-(opnd-libc.Int32FromInt32(1)))*8)
	XTclListObjSetElement(tls, libc.UintptrFromInt32(0), listPtr, 0, XTclNewNamespaceObj(tls, (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FvarFramePtr)).FnsPtr))
	if (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FvarFramePtr)).FtailcallPtr != 0 {
		_objPtr7 = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FvarFramePtr)).FtailcallPtr
		v264 = _objPtr7
		v263 = *(*TTcl_Size)(unsafe.Pointer(v264))
		*(*TTcl_Size)(unsafe.Pointer(v264))--
		if v263 <= int64(1) {
			XTclFreeObj(tls, _objPtr7)
		}
	}
	(*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FvarFramePtr)).FtailcallPtr = listPtr
	result = int32(TCL_RETURN)
	cleanup = opnd
	goto processExceptionReturn
_60:
	;
	if tosPtr > TD+112-libc.UintptrFromInt32(1)*8+uintptr((*TByteCode)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)).FmaxExceptDepth)*8 {
		if int64(*(*uintptr)(unsafe.Pointer(data + 3*8)))&int64(TCL_EVAL_DISCARD_RESULT) != 0 && result == TCL_OK {
			/* simulate pop & fast done (like it does continue in loop) */
			v265 = tosPtr
			tosPtr -= 8
			objPtr5 = *(*uintptr)(unsafe.Pointer(v265))
			v267 = objPtr5
			v266 = *(*TTcl_Size)(unsafe.Pointer(v267))
			*(*TTcl_Size)(unsafe.Pointer(v267))--
			if !(v266 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(objPtr5)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr5)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(objPtr5)).Flength = int64(-libc.Int32FromInt32(1))
					if v268 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v268 {
						cachePtr12 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v268 || ((*TAllocCache)(unsafe.Pointer(cachePtr12)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr12)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, objPtr5)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(objPtr5 + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr12)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr12)).FfirstObjPtr = objPtr5
						(*TAllocCache)(unsafe.Pointer(cachePtr12)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, objPtr5)
				}
			}
			goto abnormalReturn
		}
		/*
		 * Set the interpreter's object result to point to the topmost
		 * object from the stack, and check for a possible [catch]. The
		 * stackTop's level and refCount will be handled by "processCatch"
		 * or "abnormalReturn".
		 */
		XTcl_SetObjResult(tls, interp4, *(*uintptr)(unsafe.Pointer(tosPtr)))
		goto checkForCatch
	}
	v269 = tosPtr
	tosPtr -= 8
	_ = *(*uintptr)(unsafe.Pointer(v269))
	goto abnormalReturn
_61:
	;
	*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer((*TByteCode)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)).FobjArrayPtr + uintptr(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24)|libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)|libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)|libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))*8))
	if true {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v272 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v273 = tosPtr
				*(*uintptr)(unsafe.Pointer(v273)) = v272
				(*TTcl_Obj)(unsafe.Pointer(v272)).FrefCount++
			} else {
				tosPtr += 8
				v274 = tosPtr
				*(*uintptr)(unsafe.Pointer(v274)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(5))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(5))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(5))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _271
_271:
	;
	goto _270
_270: /**/
	; //
	goto _243
_62:
	;
	v275 = tosPtr
	tosPtr -= 8
	objPtr5 = *(*uintptr)(unsafe.Pointer(v275))
	v277 = objPtr5
	v276 = *(*TTcl_Size)(unsafe.Pointer(v277))
	*(*TTcl_Size)(unsafe.Pointer(v277))--
	if !(v276 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(objPtr5)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr5)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(objPtr5)).Flength = int64(-libc.Int32FromInt32(1))
			if v278 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v278 {
				cachePtr13 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v278 || ((*TAllocCache)(unsafe.Pointer(cachePtr13)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr13)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, objPtr5)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr5 + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr13)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr13)).FfirstObjPtr = objPtr5
				(*TAllocCache)(unsafe.Pointer(cachePtr13)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, objPtr5)
		}
	}
	if true {
		if 0 != 0 {
			if 0 > 0 {
				v281 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v282 = tosPtr
				*(*uintptr)(unsafe.Pointer(v282)) = v281
				(*TTcl_Obj)(unsafe.Pointer(v281)).FrefCount++
			} else {
				tosPtr += 8
				v283 = tosPtr
				*(*uintptr)(unsafe.Pointer(v283)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _280
_280:
	;
	goto _279
_279: /**/
	; //
	goto _243
_63:
	;
	*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(tosPtr))
	if true {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v286 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v287 = tosPtr
				*(*uintptr)(unsafe.Pointer(v287)) = v286
				(*TTcl_Obj)(unsafe.Pointer(v286)).FrefCount++
			} else {
				tosPtr += 8
				v288 = tosPtr
				*(*uintptr)(unsafe.Pointer(v288)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _285
_285:
	;
	goto _284
_284: /**/
	; //
	goto _243
_64:
	;
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-opnd)*8))
	if true {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v291 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v292 = tosPtr
				*(*uintptr)(unsafe.Pointer(v292)) = v291
				(*TTcl_Obj)(unsafe.Pointer(v291)).FrefCount++
			} else {
				tosPtr += 8
				v293 = tosPtr
				*(*uintptr)(unsafe.Pointer(v293)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(5))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(5))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(5))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _290
_290:
	;
	goto _289
_289: /**/
	; //
	goto _243
_65:
	;
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	a = tosPtr - uintptr(opnd-libc.Int32FromInt32(1))*8
	b = tosPtr
	for a < b {
		tmpPtr = *(*uintptr)(unsafe.Pointer(a))
		*(*uintptr)(unsafe.Pointer(a)) = *(*uintptr)(unsafe.Pointer(b))
		*(*uintptr)(unsafe.Pointer(b)) = tmpPtr
		a += 8
		b -= 8
	}
	if true {
		if 0 != 0 {
			if 0 > 0 {
				v296 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v297 = tosPtr
				*(*uintptr)(unsafe.Pointer(v297)) = v296
				(*TTcl_Obj)(unsafe.Pointer(v296)).FrefCount++
			} else {
				tosPtr += 8
				v298 = tosPtr
				*(*uintptr)(unsafe.Pointer(v298)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(5))
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(5))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(5))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _295
_295:
	;
	goto _294
_294: /**/
	; //
	goto _243
_66:
	;
	opnd = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1)))))
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclStringCat(tls, interp4, int64(opnd), tosPtr+uintptr(-(opnd-libc.Int32FromInt32(1)))*8, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1))
	if *(*uintptr)(unsafe.Pointer(bp + 8)) == libc.UintptrFromInt32(0) {
		checkInterp = int32(1)
		goto gotError
	}
	checkInterp = int32(1)
	pc += uintptr(libc.Int32FromInt32(2))
	cleanup = opnd
	if int32(1) != 0 {
		if int32(1) > 0 {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
		}
		goto cleanupV_pushObjResultPtr
	} else {
		goto cleanupV
	}
	goto _243
_67:
	;
	/*
	 * Pop the opnd (objc) top stack elements, run through Tcl_ConcatObj,
	 * and then decrement their ref counts.
	 */
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	*(*uintptr)(unsafe.Pointer(bp + 8)) = XTcl_ConcatObj(tls, int64(opnd), tosPtr+uintptr(-(opnd-libc.Int32FromInt32(1)))*8)
	pc += uintptr(libc.Int32FromInt32(5))
	cleanup = opnd
	if int32(1) != 0 {
		if int32(1) > 0 {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
		}
		goto cleanupV_pushObjResultPtr
	} else {
		goto cleanupV
	}
	goto _243
_68:
	;
	/*
	 * Push an element to the auxObjList. This records the current
	 * stack depth - i.e., the point in the stack where the expanded
	 * command starts.
	 *
	 * Use a Tcl_Obj as linked list element; slight mem waste, but faster
	 * allocation than Tcl_Alloc. This also abuses the Tcl_Obj structure, as
	 * we do not define a special tclObjType for it. It is not dangerous
	 * as the obj is never passed anywhere, so that all manipulations are
	 * performed here and in INST_INVOKE_EXPANDED (in case of an expansion
	 * error, also in INST_EXPAND_STKTOP).
	 */
	if v299 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v299 {
		cachePtr14 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v299 || (*TAllocCache)(unsafe.Pointer(cachePtr14)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr5 = XTclThreadAllocObj(tls)
	} else {
		objPtr5 = (*TAllocCache)(unsafe.Pointer(cachePtr14)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr14)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr5 + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr14)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr5)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(objPtr5)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr5)).FtypePtr = libc.UintptrFromInt32(0)
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr5 + 32))).Fptr2 = uintptr((int64(tosPtr) - int64(TD+112-libc.UintptrFromInt32(1)*8+uintptr((*TByteCode)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)).FmaxExceptDepth)*8)) / 8)
	(*TTcl_Obj)(unsafe.Pointer(objPtr5)).Flength = 0
	if (*TTEBCdata)(unsafe.Pointer(TD)).FauxObjList != 0 {
		*(*TTcl_Size)(unsafe.Pointer(objPtr5 + 16)) += (*TTcl_Obj)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FauxObjList)).Flength
	}
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr5 + 32))).Fptr1 = (*TTEBCdata)(unsafe.Pointer(TD)).FauxObjList
	(*TTEBCdata)(unsafe.Pointer(TD)).FauxObjList = objPtr5
	if true {
		if 0 != 0 {
			if 0 > 0 {
				v302 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v303 = tosPtr
				*(*uintptr)(unsafe.Pointer(v303)) = v302
				(*TTcl_Obj)(unsafe.Pointer(v302)).FrefCount++
			} else {
				tosPtr += 8
				v304 = tosPtr
				*(*uintptr)(unsafe.Pointer(v304)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _301
_301:
	;
	goto _300
_300: /**/
	; //
	goto _243
_69:
	;
	/*
	 * Drops an element of the auxObjList, popping stack elements to
	 * restore the stack to the state before the point where the aux
	 * element was created.
	 */
	*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = (int64(tosPtr)-int64(TD+112-libc.UintptrFromInt32(1)*8+uintptr((*TByteCode)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)).FmaxExceptDepth)*8))/8 - int64((*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FauxObjList + 32))).Fptr2)
	tmpPtr = (*TTEBCdata)(unsafe.Pointer(TD)).FauxObjList
	(*TTEBCdata)(unsafe.Pointer(TD)).FauxObjList = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(tmpPtr + 32))).Fptr1
	_objPtr8 = tmpPtr
	v306 = _objPtr8
	v305 = *(*TTcl_Size)(unsafe.Pointer(v306))
	*(*TTcl_Size)(unsafe.Pointer(v306))--
	if v305 <= int64(1) {
		XTclFreeObj(tls, _objPtr8)
	}
	pc += uintptr(libc.Int32FromInt32(1))
	cleanup = int32(*(*TTcl_Size)(unsafe.Pointer(bp + 40)))
	if 0 != 0 {
		if 0 > 0 {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
		}
		goto cleanupV_pushObjResultPtr
	} else {
		goto cleanupV
	}
_70:
	;
	/*
	 * Make sure that the element at stackTop is a list; if not, just
	 * leave with an error. Note that the element from the expand list
	 * will be removed at checkForCatch.
	 */
	objPtr5 = *(*uintptr)(unsafe.Pointer(tosPtr))
	if (*TTcl_Obj)(unsafe.Pointer(objPtr5)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr5 + 32))).Fptr2 != 0 {
			v308 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr5 + 32))).Fptr2)).FspanStart
		} else {
			v308 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr5 + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 24)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr5 + 32))).Fptr1 + 40 + uintptr(v308)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr5 + 32))).Fptr2 != 0 {
			v309 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr5 + 32))).Fptr2)).FspanLength
		} else {
			v309 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr5 + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = v309
		v307 = libc.Int32FromInt32(TCL_OK)
	} else {
		v307 = XTcl_ListObjGetElements(tls, interp4, objPtr5, bp+40, bp+24)
	}
	if v307 != TCL_OK {
		goto gotError
	}
	v310 = tosPtr
	tosPtr -= 8
	_ = *(*uintptr)(unsafe.Pointer(v310))
	/*
	 * Make sure there is enough room in the stack to expand this list
	 * *and* process the rest of the command (at least up to the next
	 * argument expansion or command end). The operand is the current
	 * stack depth, as seen by the compiler.
	 */
	*(*TTcl_Size)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FauxObjList + 16)) += *(*TTcl_Size)(unsafe.Pointer(bp + 40)) - int64(1)
	if *(*TTcl_Size)(unsafe.Pointer(bp + 40)) > int64(1) && (*TTcl_Obj)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FauxObjList)).Flength > 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = (*TTcl_Obj)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FauxObjList)).Flength + (*TByteCode)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)).FmaxStackDepth - (int64(tosPtr)-int64(TD+112-libc.UintptrFromInt32(1)*8+uintptr((*TByteCode)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)).FmaxExceptDepth)*8))/8 /* Relative to where we are */
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		oldCatchTopOff = (int64((*TTEBCdata)(unsafe.Pointer(TD)).FcatchTop) - int64(TD+112-libc.UintptrFromInt32(1)*8)) / 8
		oldTosPtrOff = (int64(tosPtr) - int64(TD+112-libc.UintptrFromInt32(1)*8+uintptr((*TByteCode)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)).FmaxExceptDepth)*8)) / 8
		newTD = _GrowEvaluationStack(tls, (*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 32))), int32(1))
		if newTD != TD {
			/*
			 * Change the global data to point to the new stack: move the
			 * TEBCdataPtr TD, recompute the position of every other
			 * stack-allocated parameter, update the stack pointers.
			 */
			TD = newTD
			(*TTEBCdata)(unsafe.Pointer(TD)).FcatchTop = TD + 112 - uintptr(1)*8 + uintptr(oldCatchTopOff)*8
			tosPtr = TD + 112 - uintptr(1)*8 + uintptr((*TByteCode)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)).FmaxExceptDepth)*8 + uintptr(oldTosPtrOff)*8
		}
	}
	/*
	 * Expand the list at stacktop onto the stack; free the list. Knowing
	 * that it has a freeIntRepProc we use Tcl_DecrRefCount().
	 */
	i = 0
	for {
		if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 40))) {
			break
		}
		v312 = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + uintptr(i)*8))
		tosPtr += 8
		v313 = tosPtr
		*(*uintptr)(unsafe.Pointer(v313)) = v312
		(*TTcl_Obj)(unsafe.Pointer(v312)).FrefCount++
		goto _311
	_311:
		;
		i++
	}
	_objPtr9 = objPtr5
	v315 = _objPtr9
	v314 = *(*TTcl_Size)(unsafe.Pointer(v315))
	*(*TTcl_Size)(unsafe.Pointer(v315))--
	if v314 <= int64(1) {
		XTclFreeObj(tls, _objPtr9)
	}
	if true {
		if 0 != 0 {
			if 0 > 0 {
				v318 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v319 = tosPtr
				*(*uintptr)(unsafe.Pointer(v319)) = v318
				(*TTcl_Obj)(unsafe.Pointer(v318)).FrefCount++
			} else {
				tosPtr += 8
				v320 = tosPtr
				*(*uintptr)(unsafe.Pointer(v320)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(5))
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(5))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(5))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _317
_317:
	;
	goto _316
_316: /**/
	; //
	goto _243
_71:
	;
	(*(*struct {
		FcodePtr uintptr
		Fpc      uintptr
	})(unsafe.Pointer(TD + 24 + 40))).Fpc = pc
	(*TInterp)(unsafe.Pointer(interp4)).FcmdFramePtr = TD + 24
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	newCodePtr = _CompileExprObj(tls, interp4, *(*uintptr)(unsafe.Pointer(tosPtr)))
	checkInterp = int32(1)
	cleanup = int32(1)
	pc++
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	if v321 = interp4 == libc.UintptrFromInt32(0); !v321 {
		cachePtr15 = (*TInterp)(unsafe.Pointer(interp4)).FallocCache
	}
	if v321 || (*TAllocCache)(unsafe.Pointer(cachePtr15)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr10 = XTclThreadAllocObj(tls)
	} else {
		_objPtr10 = (*TAllocCache)(unsafe.Pointer(cachePtr15)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr15)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr10 + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr15)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 80)) = _objPtr10
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 80)))).FprocPtr = __ccgo_fp(_TEBCresume)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 80)) + 8)) = TD
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 80)) + 8 + 1*8)) = pc
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 80)) + 8 + 2*8)) = uintptr(int64(cleanup))
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 80)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 80)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 80))
	return XTclNRExecuteByteCode(tls, interp4, newCodePtr)
	/*
	 * INVOCATION BLOCK
	 */
_72:
	;
	goto instEvalStk
instEvalStk:
	;
	(*(*struct {
		FcodePtr uintptr
		Fpc      uintptr
	})(unsafe.Pointer(TD + 24 + 40))).Fpc = pc
	(*TInterp)(unsafe.Pointer(interp4)).FcmdFramePtr = TD + 24
	cleanup = int32(1)
	pc += uintptr(1)
	/* yield next instruction */
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	if v322 = interp4 == libc.UintptrFromInt32(0); !v322 {
		cachePtr16 = (*TInterp)(unsafe.Pointer(interp4)).FallocCache
	}
	if v322 || (*TAllocCache)(unsafe.Pointer(cachePtr16)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr11 = XTclThreadAllocObj(tls)
	} else {
		_objPtr11 = (*TAllocCache)(unsafe.Pointer(cachePtr16)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr16)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr11 + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr16)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 88)) = _objPtr11
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 88)))).FprocPtr = __ccgo_fp(_TEBCresume)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 88)) + 8)) = TD
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 88)) + 8 + 1*8)) = pc
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 88)) + 8 + 2*8)) = uintptr(int64(cleanup))
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 88)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 88)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 88))
	/* add TEBCResume for object at top of stack */
	return XTclNRExecuteByteCode(tls, interp4, XTclCompileObj(tls, interp4, *(*uintptr)(unsafe.Pointer(tosPtr)), libc.UintptrFromInt32(0), 0))
_73:
	;
	*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = (int64(tosPtr)-int64(TD+112-libc.UintptrFromInt32(1)*8+uintptr((*TByteCode)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)).FmaxExceptDepth)*8))/8 - int64((*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FauxObjList + 32))).Fptr2)
	tmpPtr = (*TTEBCdata)(unsafe.Pointer(TD)).FauxObjList
	(*TTEBCdata)(unsafe.Pointer(TD)).FauxObjList = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(tmpPtr + 32))).Fptr1
	_objPtr12 = tmpPtr
	v324 = _objPtr12
	v323 = *(*TTcl_Size)(unsafe.Pointer(v324))
	*(*TTcl_Size)(unsafe.Pointer(v324))--
	if v323 <= int64(1) {
		XTclFreeObj(tls, _objPtr12)
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp + 40)) != 0 {
		pcAdjustment = int32(1)
		goto doInvocation
	}
	/*
	 * Nothing was expanded, return {}.
	 */
	if v325 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v325 {
		cachePtr17 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v325 || (*TAllocCache)(unsafe.Pointer(cachePtr17)).FnumObjects == libc.Uint64FromInt32(0) {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
	} else {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr17)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr17)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr17)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = libc.UintptrFromInt32(0)
	if true {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v328 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v329 = tosPtr
				*(*uintptr)(unsafe.Pointer(v329)) = v328
				(*TTcl_Obj)(unsafe.Pointer(v328)).FrefCount++
			} else {
				tosPtr += 8
				v330 = tosPtr
				*(*uintptr)(unsafe.Pointer(v330)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _327
_327:
	;
	goto _326
_326: /**/
	; //
	goto _243
_74:
	;
	*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = libc.Int64FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	pcAdjustment = int32(5)
	goto doInvocation
_75:
	;
	*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = libc.Int64FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1)))))
	pcAdjustment = int32(2)
	goto doInvocation
doInvocation:
	;
	*(*uintptr)(unsafe.Pointer(bp + 24)) = tosPtr + uintptr(-(*(*TTcl_Size)(unsafe.Pointer(bp + 40))-libc.Int64FromInt32(1)))*8
	cleanup = int32(*(*TTcl_Size)(unsafe.Pointer(bp + 40)))
	/*
	 * Finally, let TclEvalObjv handle the command.
	 *
	 * TIP #280: Record the last piece of info needed by
	 * 'TclGetSrcInfoForPc', and push the frame.
	 */
	(*(*struct {
		FcodePtr uintptr
		Fpc      uintptr
	})(unsafe.Pointer(TD + 24 + 40))).Fpc = pc
	(*TInterp)(unsafe.Pointer(interp4)).FcmdFramePtr = TD + 24
	if (*TInterp)(unsafe.Pointer(interp4)).Fflags&int32(INTERP_DEBUG_FRAME) != 0 {
		_ArgumentBCEnter(tls, interp4, (*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr, TD, pc, *(*TTcl_Size)(unsafe.Pointer(bp + 40)), *(*uintptr)(unsafe.Pointer(bp + 24)))
	}
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	pc += uintptr(pcAdjustment)
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	if v331 = interp4 == libc.UintptrFromInt32(0); !v331 {
		cachePtr18 = (*TInterp)(unsafe.Pointer(interp4)).FallocCache
	}
	if v331 || (*TAllocCache)(unsafe.Pointer(cachePtr18)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr13 = XTclThreadAllocObj(tls)
	} else {
		_objPtr13 = (*TAllocCache)(unsafe.Pointer(cachePtr18)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr18)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr13 + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr18)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 96)) = _objPtr13
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 96)))).FprocPtr = __ccgo_fp(_TEBCresume)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 96)) + 8)) = TD
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 96)) + 8 + 1*8)) = pc
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 96)) + 8 + 2*8)) = uintptr(int64(cleanup))
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 96)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 96)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 96))
	if *(*TTcl_Size)(unsafe.Pointer(bp + 40)) > int64(INT_MAX) {
		return XTclCommandWordLimitError(tls, interp4, *(*TTcl_Size)(unsafe.Pointer(bp + 40)))
	} else {
		return XTclNREvalObjv(tls, interp4, *(*TTcl_Size)(unsafe.Pointer(bp + 40)), *(*uintptr)(unsafe.Pointer(bp + 24)), libc.Int32FromInt32(TCL_EVAL_NOERR)|libc.Int32FromInt32(TCL_EVAL_SOURCE_IN_FRAME), libc.UintptrFromInt32(0))
	}
_76:
	;
	*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = libc.Int64FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	opnd = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5)))))
	v332 = tosPtr
	tosPtr -= 8
	objPtr5 = *(*uintptr)(unsafe.Pointer(v332))
	*(*uintptr)(unsafe.Pointer(bp + 24)) = tosPtr + uintptr(-(*(*TTcl_Size)(unsafe.Pointer(bp + 40))-libc.Int64FromInt32(1)))*8
	cleanup = int32(*(*TTcl_Size)(unsafe.Pointer(bp + 40)))
	(*(*struct {
		FcodePtr uintptr
		Fpc      uintptr
	})(unsafe.Pointer(TD + 24 + 40))).Fpc = pc
	(*TInterp)(unsafe.Pointer(interp4)).FcmdFramePtr = TD + 24
	if (*TInterp)(unsafe.Pointer(interp4)).Fflags&int32(INTERP_DEBUG_FRAME) != 0 {
		_ArgumentBCEnter(tls, interp4, (*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr, TD, pc, *(*TTcl_Size)(unsafe.Pointer(bp + 40)), *(*uintptr)(unsafe.Pointer(bp + 24)))
	}
	XTclInitRewriteEnsemble(tls, interp4, int64(opnd), int64(1), *(*uintptr)(unsafe.Pointer(bp + 24)))
	copyPtr = XTcl_NewListObj(tls, *(*TTcl_Size)(unsafe.Pointer(bp + 40))-int64(opnd)+int64(1), libc.UintptrFromInt32(0))
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), copyPtr, objPtr5)
	XTcl_ListObjReplace(tls, libc.UintptrFromInt32(0), copyPtr, libc.Int64FromUint64((libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))-uint64(libc.UintptrFromInt32(0)+40))/libc.Uint64FromInt64(8)), 0, *(*TTcl_Size)(unsafe.Pointer(bp + 40))-int64(opnd), *(*uintptr)(unsafe.Pointer(bp + 24))+uintptr(opnd)*8)
	_objPtr14 = objPtr5
	v334 = _objPtr14
	v333 = *(*TTcl_Size)(unsafe.Pointer(v334))
	*(*TTcl_Size)(unsafe.Pointer(v334))--
	if v333 <= int64(1) {
		XTclFreeObj(tls, _objPtr14)
	}
	objPtr5 = copyPtr
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	pc += uintptr(6)
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	if v335 = interp4 == libc.UintptrFromInt32(0); !v335 {
		cachePtr19 = (*TInterp)(unsafe.Pointer(interp4)).FallocCache
	}
	if v335 || (*TAllocCache)(unsafe.Pointer(cachePtr19)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr15 = XTclThreadAllocObj(tls)
	} else {
		_objPtr15 = (*TAllocCache)(unsafe.Pointer(cachePtr19)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr19)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr15 + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr19)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 104)) = _objPtr15
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 104)))).FprocPtr = __ccgo_fp(_TEBCresume)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 104)) + 8)) = TD
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 104)) + 8 + 1*8)) = pc
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 104)) + 8 + 2*8)) = uintptr(int64(cleanup))
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 104)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 104)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 104))
	XTclMarkTailcall(tls, interp4)
	if v336 = interp4 == libc.UintptrFromInt32(0); !v336 {
		cachePtr20 = (*TInterp)(unsafe.Pointer(interp4)).FallocCache
	}
	if v336 || (*TAllocCache)(unsafe.Pointer(cachePtr20)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr16 = XTclThreadAllocObj(tls)
	} else {
		_objPtr16 = (*TAllocCache)(unsafe.Pointer(cachePtr20)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr20)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr16 + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr20)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 112)) = _objPtr16
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112)))).FprocPtr = __ccgo_fp(XTclClearRootEnsemble)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112)) + 8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 112))
	if (*TTcl_Obj)(unsafe.Pointer(objPtr5)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr5 + 32))).Fptr2 != 0 {
			v338 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr5 + 32))).Fptr2)).FspanStart
		} else {
			v338 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr5 + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 24)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr5 + 32))).Fptr1 + 40 + uintptr(v338)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr5 + 32))).Fptr2 != 0 {
			v339 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr5 + 32))).Fptr2)).FspanLength
		} else {
			v339 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr5 + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = v339
		_ = libc.Int32FromInt32(TCL_OK)
	} else {
		XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), objPtr5, bp+40, bp+24)
	}
	if v340 = interp4 == libc.UintptrFromInt32(0); !v340 {
		cachePtr21 = (*TInterp)(unsafe.Pointer(interp4)).FallocCache
	}
	if v340 || (*TAllocCache)(unsafe.Pointer(cachePtr21)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr17 = XTclThreadAllocObj(tls)
	} else {
		_objPtr17 = (*TAllocCache)(unsafe.Pointer(cachePtr21)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr21)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr17 + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr21)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 120)) = _objPtr17
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 120)))).FprocPtr = __ccgo_fp(XTclNRReleaseValues)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 120)) + 8)) = objPtr5
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 120)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 120)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 120)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 120)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 120))
	return XTclNREvalObjv(tls, interp4, *(*TTcl_Size)(unsafe.Pointer(bp + 40)), *(*uintptr)(unsafe.Pointer(bp + 24)), int32(TCL_EVAL_INVOKE), libc.UintptrFromInt32(0))
	/*
	 * -----------------------------------------------------------------
	 *	   Start of INST_LOAD instructions.
	 *
	 * WARNING: more 'goto' here than your doctor recommended! The different
	 * instructions set the value of some variables and then jump to some
	 * common execution code.
	 */
_77:
	;
	goto instLoadScalar1
instLoadScalar1:
	;
	opnd = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1)))))
	*(*uintptr)(unsafe.Pointer(bp + 48)) = compiledLocals + uintptr(opnd)*16
	for (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_LINK) != 0 {
		*(*uintptr)(unsafe.Pointer(bp + 48)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
	}
	if !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)|libc.Int32FromInt32(VAR_TRACED_READ)) != 0 || (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 && (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr != libc.UintptrFromInt32(0) && (*TVar1)(unsafe.Pointer((*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr)).Fflags&int32(VAR_TRACED_READ) != 0) && *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) != 0 {
		/*
		 * No errors, no traces: just get the value.
		 */
		*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
		if true {
			if int32(1) != 0 {
				if int32(1) > 0 {
					v343 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v344 = tosPtr
					*(*uintptr)(unsafe.Pointer(v344)) = v343
					(*TTcl_Obj)(unsafe.Pointer(v343)).FrefCount++
				} else {
					tosPtr += 8
					v345 = tosPtr
					*(*uintptr)(unsafe.Pointer(v345)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(2))
			goto cleanup0
		} else {
			if int32(1) != 0 {
				if int32(1) > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(2))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(2))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _342
	_342:
		;
		goto _341
	_341: /**/
		//
	}
	pcAdjustment = int32(2)
	cleanup = 0
	*(*uintptr)(unsafe.Pointer(bp + 56)) = libc.UintptrFromInt32(0)
	v346 = libc.UintptrFromInt32(0)
	part2Ptr = v346
	part1Ptr = v346
	goto doCallPtrGetVar
_78:
	;
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	*(*uintptr)(unsafe.Pointer(bp + 48)) = compiledLocals + uintptr(opnd)*16
	for (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_LINK) != 0 {
		*(*uintptr)(unsafe.Pointer(bp + 48)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
	}
	if !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)|libc.Int32FromInt32(VAR_TRACED_READ)) != 0 || (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 && (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr != libc.UintptrFromInt32(0) && (*TVar1)(unsafe.Pointer((*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr)).Fflags&int32(VAR_TRACED_READ) != 0) && *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) != 0 {
		/*
		 * No errors, no traces: just get the value.
		 */
		*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
		if true {
			if int32(1) != 0 {
				if int32(1) > 0 {
					v349 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v350 = tosPtr
					*(*uintptr)(unsafe.Pointer(v350)) = v349
					(*TTcl_Obj)(unsafe.Pointer(v349)).FrefCount++
				} else {
					tosPtr += 8
					v351 = tosPtr
					*(*uintptr)(unsafe.Pointer(v351)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(5))
			goto cleanup0
		} else {
			if int32(1) != 0 {
				if int32(1) > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(5))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(5))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _348
	_348:
		;
		goto _347
	_347: /**/
		//
	}
	pcAdjustment = int32(5)
	cleanup = 0
	*(*uintptr)(unsafe.Pointer(bp + 56)) = libc.UintptrFromInt32(0)
	v352 = libc.UintptrFromInt32(0)
	part2Ptr = v352
	part1Ptr = v352
	goto doCallPtrGetVar
_79:
	;
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	pcAdjustment = int32(5)
	goto doLoadArray
_80:
	;
	opnd = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1)))))
	pcAdjustment = int32(2)
	goto doLoadArray
doLoadArray:
	;
	part1Ptr = libc.UintptrFromInt32(0)
	part2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr))
	*(*uintptr)(unsafe.Pointer(bp + 56)) = compiledLocals + uintptr(opnd)*16
	for (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)))).Fflags&int32(VAR_LINK) != 0 {
		*(*uintptr)(unsafe.Pointer(bp + 56)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)) + 8))
	}
	if (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)))).Fflags&int32(VAR_ARRAY) != 0 && !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)))).Fflags&libc.Int32FromInt32(VAR_TRACED_READ) != 0) {
		*(*uintptr)(unsafe.Pointer(bp + 48)) = _VarHashCreateVar(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)) + 8)), part2Ptr, libc.UintptrFromInt32(0))
		if *(*uintptr)(unsafe.Pointer(bp + 48)) != 0 && (!((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)|libc.Int32FromInt32(VAR_TRACED_READ)) != 0 || (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 && (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr != libc.UintptrFromInt32(0) && (*TVar1)(unsafe.Pointer((*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr)).Fflags&int32(VAR_TRACED_READ) != 0) && *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) != 0) {
			/*
			 * No errors, no traces: just get the value.
			 */
			*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
			if false {
				if int32(1) != 0 {
					if int32(1) > 0 {
						v355 = *(*uintptr)(unsafe.Pointer(bp + 8))
						tosPtr += 8
						v356 = tosPtr
						*(*uintptr)(unsafe.Pointer(v356)) = v355
						(*TTcl_Obj)(unsafe.Pointer(v355)).FrefCount++
					} else {
						tosPtr += 8
						v357 = tosPtr
						*(*uintptr)(unsafe.Pointer(v357)) = *(*uintptr)(unsafe.Pointer(bp + 8))
					}
				}
				pc += uintptr(pcAdjustment)
				goto cleanup0
			} else {
				if int32(1) != 0 {
					if int32(1) > 0 {
						(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
					}
					pc += uintptr(pcAdjustment)
					switch libc.Int32FromInt32(1) {
					case int32(1):
						goto cleanup1_pushObjResultPtr
					case int32(2):
						goto cleanup2_pushObjResultPtr
					case 0:
						break
					}
				} else {
					pc += uintptr(pcAdjustment)
					switch libc.Int32FromInt32(1) {
					case int32(1):
						goto cleanup1
					case int32(2):
						goto cleanup2
					case 0:
						break
					}
				}
			}
			goto _354
		_354:
			;
			goto _353
		_353: /**/
			//
		}
	}
	*(*uintptr)(unsafe.Pointer(bp + 48)) = XTclLookupArrayElement(tls, interp4, part1Ptr, part2Ptr, int32(TCL_LEAVE_ERR_MSG), __ccgo_ts+5552, 0, int32(1), *(*uintptr)(unsafe.Pointer(bp + 56)), opnd)
	if *(*uintptr)(unsafe.Pointer(bp + 48)) == libc.UintptrFromInt32(0) {
		goto gotError
	}
	cleanup = int32(1)
	goto doCallPtrGetVar
_81:
	;
	cleanup = int32(2)
	part2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr))                                     /* element name */
	objPtr5 = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)) /* array name */
	goto doLoadStk
_83:
	;
_82:
	;
	cleanup = int32(1)
	part2Ptr = libc.UintptrFromInt32(0)
	objPtr5 = *(*uintptr)(unsafe.Pointer(tosPtr)) /* variable name */
	goto doLoadStk
doLoadStk:
	;
	part1Ptr = objPtr5
	*(*uintptr)(unsafe.Pointer(bp + 48)) = XTclObjLookupVarEx(tls, interp4, part1Ptr, part2Ptr, int32(TCL_LEAVE_ERR_MSG), __ccgo_ts+5552, 0, int32(1), bp+56)
	if !(*(*uintptr)(unsafe.Pointer(bp + 48)) != 0) {
		goto gotError
	}
	if !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)|libc.Int32FromInt32(VAR_TRACED_READ)) != 0 || (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 && (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr != libc.UintptrFromInt32(0) && (*TVar1)(unsafe.Pointer((*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr)).Fflags&int32(VAR_TRACED_READ) != 0) && *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) != 0 && (!(*(*uintptr)(unsafe.Pointer(bp + 56)) != 0) || !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)))).Fflags&libc.Int32FromInt32(VAR_TRACED_READ) != 0)) {
		/*
		 * No errors, no traces: just get the value.
		 */
		*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
		pc += uintptr(libc.Int32FromInt32(1))
		cleanup = cleanup
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			goto cleanupV_pushObjResultPtr
		} else {
			goto cleanupV
		}
	}
	pcAdjustment = int32(1)
	opnd = -int32(1)
	goto doCallPtrGetVar
doCallPtrGetVar:
	;
	/*
	 * There are either errors or the variable is traced: call
	 * TclPtrGetVar to process fully.
	 */
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclPtrGetVarIdx(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 48)), *(*uintptr)(unsafe.Pointer(bp + 56)), part1Ptr, part2Ptr, int32(TCL_LEAVE_ERR_MSG), opnd)
	checkInterp = int32(1)
	if !(*(*uintptr)(unsafe.Pointer(bp + 8)) != 0) {
		goto gotError
	}
	pc += uintptr(pcAdjustment)
	cleanup = cleanup
	if int32(1) != 0 {
		if int32(1) > 0 {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
		}
		goto cleanupV_pushObjResultPtr
	} else {
		goto cleanupV
	}
	/*
	 *	   End of INST_LOAD instructions.
	 * -----------------------------------------------------------------
	 *	   Start of INST_STORE and related instructions.
	 *
	 * WARNING: more 'goto' here than your doctor recommended! The different
	 * instructions set the value of some variables and then jump to somme
	 * common execution code.
	 */
_84:
	;
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	pcAdjustment = int32(5)
	goto doStoreArrayDirect
_85:
	;
	opnd = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1)))))
	pcAdjustment = int32(2)
	goto doStoreArrayDirect
doStoreArrayDirect:
	;
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr))
	part2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8))
	*(*uintptr)(unsafe.Pointer(bp + 56)) = compiledLocals + uintptr(opnd)*16
	for (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)))).Fflags&int32(VAR_LINK) != 0 {
		*(*uintptr)(unsafe.Pointer(bp + 56)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)) + 8))
	}
	if (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)))).Fflags&int32(VAR_ARRAY) != 0 && !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)))).Fflags&libc.Int32FromInt32(VAR_TRACED_WRITE) != 0) {
		*(*uintptr)(unsafe.Pointer(bp + 48)) = _VarHashCreateVar(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)) + 8)), part2Ptr, libc.UintptrFromInt32(0))
		if *(*uintptr)(unsafe.Pointer(bp + 48)) != 0 && !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_DEAD_HASH)|libc.Int32FromInt32(VAR_CONSTANT)) != 0 || (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 && (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr != libc.UintptrFromInt32(0) && (*TVar1)(unsafe.Pointer((*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr)).Fflags&(libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_DEAD_HASH)|libc.Int32FromInt32(VAR_CONSTANT)) != 0) {
			tosPtr -= 8
			_objPtr18 = *(*uintptr)(unsafe.Pointer(tosPtr))
			v359 = _objPtr18
			v358 = *(*TTcl_Size)(unsafe.Pointer(v359))
			*(*TTcl_Size)(unsafe.Pointer(v359))--
			if v358 <= int64(1) {
				XTclFreeObj(tls, _objPtr18)
			}
			*(*uintptr)(unsafe.Pointer(tosPtr)) = *(*uintptr)(unsafe.Pointer(bp + 16))
			goto doStoreVarDirect
		}
	}
	cleanup = int32(2)
	storeFlags = int32(TCL_LEAVE_ERR_MSG)
	part1Ptr = libc.UintptrFromInt32(0)
	goto doStoreArrayDirectFailed
_86:
	;
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	pcAdjustment = int32(5)
	goto doStoreScalarDirect
_87:
	;
	opnd = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1)))))
	pcAdjustment = int32(2)
	goto doStoreScalarDirect
doStoreScalarDirect:
	;
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr))
	*(*uintptr)(unsafe.Pointer(bp + 48)) = compiledLocals + uintptr(opnd)*16
	for (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_LINK) != 0 {
		*(*uintptr)(unsafe.Pointer(bp + 48)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
	}
	if !!((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_DEAD_HASH)|libc.Int32FromInt32(VAR_CONSTANT)) != 0 || (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 && (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr != libc.UintptrFromInt32(0) && (*TVar1)(unsafe.Pointer((*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr)).Fflags&(libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_DEAD_HASH)|libc.Int32FromInt32(VAR_CONSTANT)) != 0) {
		storeFlags = int32(TCL_LEAVE_ERR_MSG)
		part1Ptr = libc.UintptrFromInt32(0)
		goto doStoreScalar
	}
	/*
	 * No traces, no errors, plain 'set': we can safely inline. The value
	 * *will* be set to what's requested, so that the stack top remains
	 * pointing to the same Tcl_Obj.
	 */
	goto doStoreVarDirect
doStoreVarDirect:
	;
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
	if *(*uintptr)(unsafe.Pointer(bp + 16)) != libc.UintptrFromInt32(0) {
		v361 = *(*uintptr)(unsafe.Pointer(bp + 16))
		v360 = *(*TTcl_Size)(unsafe.Pointer(v361))
		*(*TTcl_Size)(unsafe.Pointer(v361))--
		if !(v360 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength = int64(-libc.Int32FromInt32(1))
				if v362 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v362 {
					cachePtr22 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v362 || ((*TAllocCache)(unsafe.Pointer(cachePtr22)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr22)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr22)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr22)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp + 16))
					(*TAllocCache)(unsafe.Pointer(cachePtr22)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
			}
		}
	}
	*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(tosPtr))
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8))
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + uintptr(pcAdjustment)))) == int32(INST_POP) {
		tosPtr -= 8
		if true {
			if 0 != 0 {
				if 0 > 0 {
					v365 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v366 = tosPtr
					*(*uintptr)(unsafe.Pointer(v366)) = v365
					(*TTcl_Obj)(unsafe.Pointer(v365)).FrefCount++
				} else {
					tosPtr += 8
					v367 = tosPtr
					*(*uintptr)(unsafe.Pointer(v367)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(pcAdjustment + libc.Int32FromInt32(1))
			goto cleanup0
		} else {
			if 0 != 0 {
				if 0 > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(pcAdjustment + libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(pcAdjustment + libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _364
	_364:
		;
		goto _363
	_363: /**/ //
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
	if true {
		if 0 != 0 {
			if 0 > 0 {
				v370 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v371 = tosPtr
				*(*uintptr)(unsafe.Pointer(v371)) = v370
				(*TTcl_Obj)(unsafe.Pointer(v370)).FrefCount++
			} else {
				tosPtr += 8
				v372 = tosPtr
				*(*uintptr)(unsafe.Pointer(v372)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(pcAdjustment)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(pcAdjustment)
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(pcAdjustment)
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _369
_369:
	;
	goto _368
_368: /**/
	; //
_88:
	;
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr)) /* value to append */
	part2Ptr = libc.UintptrFromInt32(0)
	storeFlags = libc.Int32FromInt32(TCL_LEAVE_ERR_MSG) | libc.Int32FromInt32(TCL_APPEND_VALUE) | libc.Int32FromInt32(TCL_LIST_ELEMENT)
	goto doStoreStk
_89:
	;
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr)) /* value to append */
	part2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8))
	storeFlags = libc.Int32FromInt32(TCL_LEAVE_ERR_MSG) | libc.Int32FromInt32(TCL_APPEND_VALUE) | libc.Int32FromInt32(TCL_LIST_ELEMENT)
	goto doStoreStk
_90:
	;
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr)) /* value to append */
	part2Ptr = libc.UintptrFromInt32(0)
	storeFlags = libc.Int32FromInt32(TCL_LEAVE_ERR_MSG) | libc.Int32FromInt32(TCL_APPEND_VALUE)
	goto doStoreStk
_91:
	;
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr)) /* value to append */
	part2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8))
	storeFlags = libc.Int32FromInt32(TCL_LEAVE_ERR_MSG) | libc.Int32FromInt32(TCL_APPEND_VALUE)
	goto doStoreStk
_92:
	;
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr))
	part2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8))
	storeFlags = int32(TCL_LEAVE_ERR_MSG)
	goto doStoreStk
_94:
	;
_93:
	;
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr))
	part2Ptr = libc.UintptrFromInt32(0)
	storeFlags = int32(TCL_LEAVE_ERR_MSG)
	goto doStoreStk
doStoreStk:
	;
	objPtr5 = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-(libc.Int32FromInt32(1)+libc.BoolInt32(part2Ptr != libc.UintptrFromInt32(0))))*8)) /* variable name */
	part1Ptr = objPtr5
	*(*uintptr)(unsafe.Pointer(bp + 48)) = XTclObjLookupVarEx(tls, interp4, objPtr5, part2Ptr, int32(TCL_LEAVE_ERR_MSG), __ccgo_ts+5383, int32(1), int32(1), bp+56)
	if !(*(*uintptr)(unsafe.Pointer(bp + 48)) != 0) {
		goto gotError
	}
	if part2Ptr == libc.UintptrFromInt32(0) {
		v373 = int32(2)
	} else {
		v373 = int32(3)
	}
	cleanup = v373
	pcAdjustment = int32(1)
	opnd = -int32(1)
	goto doCallPtrSetVar
_95:
	;
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	pcAdjustment = int32(5)
	storeFlags = libc.Int32FromInt32(TCL_LEAVE_ERR_MSG) | libc.Int32FromInt32(TCL_APPEND_VALUE) | libc.Int32FromInt32(TCL_LIST_ELEMENT)
	goto doStoreArray
_96:
	;
	opnd = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1)))))
	pcAdjustment = int32(2)
	storeFlags = libc.Int32FromInt32(TCL_LEAVE_ERR_MSG) | libc.Int32FromInt32(TCL_APPEND_VALUE) | libc.Int32FromInt32(TCL_LIST_ELEMENT)
	goto doStoreArray
_97:
	;
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	pcAdjustment = int32(5)
	storeFlags = libc.Int32FromInt32(TCL_LEAVE_ERR_MSG) | libc.Int32FromInt32(TCL_APPEND_VALUE)
	goto doStoreArray
_98:
	;
	opnd = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1)))))
	pcAdjustment = int32(2)
	storeFlags = libc.Int32FromInt32(TCL_LEAVE_ERR_MSG) | libc.Int32FromInt32(TCL_APPEND_VALUE)
	goto doStoreArray
	goto doStoreArray
doStoreArray:
	;
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr))
	part2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8))
	*(*uintptr)(unsafe.Pointer(bp + 56)) = compiledLocals + uintptr(opnd)*16
	for (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)))).Fflags&int32(VAR_LINK) != 0 {
		*(*uintptr)(unsafe.Pointer(bp + 56)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)) + 8))
	}
	cleanup = int32(2)
	part1Ptr = libc.UintptrFromInt32(0)
	goto doStoreArrayDirectFailed
doStoreArrayDirectFailed:
	;
	*(*uintptr)(unsafe.Pointer(bp + 48)) = XTclLookupArrayElement(tls, interp4, part1Ptr, part2Ptr, int32(TCL_LEAVE_ERR_MSG), __ccgo_ts+5383, int32(1), int32(1), *(*uintptr)(unsafe.Pointer(bp + 56)), opnd)
	if !(*(*uintptr)(unsafe.Pointer(bp + 48)) != 0) {
		goto gotError
	}
	goto doCallPtrSetVar
_99:
	;
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	pcAdjustment = int32(5)
	storeFlags = libc.Int32FromInt32(TCL_LEAVE_ERR_MSG) | libc.Int32FromInt32(TCL_APPEND_VALUE) | libc.Int32FromInt32(TCL_LIST_ELEMENT)
	goto doStoreScalar
_100:
	;
	opnd = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1)))))
	pcAdjustment = int32(2)
	storeFlags = libc.Int32FromInt32(TCL_LEAVE_ERR_MSG) | libc.Int32FromInt32(TCL_APPEND_VALUE) | libc.Int32FromInt32(TCL_LIST_ELEMENT)
	goto doStoreScalar
_101:
	;
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	pcAdjustment = int32(5)
	storeFlags = libc.Int32FromInt32(TCL_LEAVE_ERR_MSG) | libc.Int32FromInt32(TCL_APPEND_VALUE)
	goto doStoreScalar
_102:
	;
	opnd = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1)))))
	pcAdjustment = int32(2)
	storeFlags = libc.Int32FromInt32(TCL_LEAVE_ERR_MSG) | libc.Int32FromInt32(TCL_APPEND_VALUE)
	goto doStoreScalar
	goto doStoreScalar
doStoreScalar:
	;
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr))
	*(*uintptr)(unsafe.Pointer(bp + 48)) = compiledLocals + uintptr(opnd)*16
	for (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_LINK) != 0 {
		*(*uintptr)(unsafe.Pointer(bp + 48)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
	}
	cleanup = int32(1)
	*(*uintptr)(unsafe.Pointer(bp + 56)) = libc.UintptrFromInt32(0)
	v374 = libc.UintptrFromInt32(0)
	part2Ptr = v374
	part1Ptr = v374
	goto doCallPtrSetVar
doCallPtrSetVar:
	;
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclPtrSetVarIdx(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 48)), *(*uintptr)(unsafe.Pointer(bp + 56)), part1Ptr, part2Ptr, *(*uintptr)(unsafe.Pointer(bp + 16)), storeFlags, opnd)
	checkInterp = int32(1)
	if !(*(*uintptr)(unsafe.Pointer(bp + 8)) != 0) {
		goto gotError
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + uintptr(pcAdjustment)))) == int32(INST_POP) {
		pc += uintptr(pcAdjustment + libc.Int32FromInt32(1))
		cleanup = cleanup
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			goto cleanupV_pushObjResultPtr
		} else {
			goto cleanupV
		}
	}
	pc += uintptr(pcAdjustment)
	cleanup = cleanup
	if int32(1) != 0 {
		if int32(1) > 0 {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
		}
		goto cleanupV_pushObjResultPtr
	} else {
		goto cleanupV
	}
_103:
	;
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr))
	*(*uintptr)(unsafe.Pointer(bp + 48)) = compiledLocals + uintptr(opnd)*16
	cleanup = int32(1)
	pcAdjustment = int32(5)
	for (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_LINK) != 0 {
		*(*uintptr)(unsafe.Pointer(bp + 48)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr2 != 0 {
			v376 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr2)).FspanStart
		} else {
			v376 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 24)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1 + 40 + uintptr(v376)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr2 != 0 {
			v377 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr2)).FspanLength
		} else {
			v377 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = v377
		v375 = libc.Int32FromInt32(TCL_OK)
	} else {
		v375 = XTcl_ListObjGetElements(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 16)), bp+40, bp+24)
	}
	if v375 != TCL_OK {
		goto gotError
	}
	if !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)|libc.Int32FromInt32(VAR_TRACED_READ)) != 0 || (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 && (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr != libc.UintptrFromInt32(0) && (*TVar1)(unsafe.Pointer((*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr)).Fflags&int32(VAR_TRACED_READ) != 0) && *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) != 0 && !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_DEAD_HASH)|libc.Int32FromInt32(VAR_CONSTANT)) != 0 || (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 && (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr != libc.UintptrFromInt32(0) && (*TVar1)(unsafe.Pointer((*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr)).Fflags&(libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_DEAD_HASH)|libc.Int32FromInt32(VAR_CONSTANT)) != 0) {
		goto lappendListDirect
	}
	*(*uintptr)(unsafe.Pointer(bp + 56)) = libc.UintptrFromInt32(0)
	v378 = libc.UintptrFromInt32(0)
	part2Ptr = v378
	part1Ptr = v378
	goto lappendListPtr
_104:
	;
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr))
	part1Ptr = libc.UintptrFromInt32(0)
	part2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8))
	*(*uintptr)(unsafe.Pointer(bp + 56)) = compiledLocals + uintptr(opnd)*16
	cleanup = int32(2)
	pcAdjustment = int32(5)
	for (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)))).Fflags&int32(VAR_LINK) != 0 {
		*(*uintptr)(unsafe.Pointer(bp + 56)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)) + 8))
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr2 != 0 {
			v380 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr2)).FspanStart
		} else {
			v380 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 24)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1 + 40 + uintptr(v380)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr2 != 0 {
			v381 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr2)).FspanLength
		} else {
			v381 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = v381
		v379 = libc.Int32FromInt32(TCL_OK)
	} else {
		v379 = XTcl_ListObjGetElements(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 16)), bp+40, bp+24)
	}
	if v379 != TCL_OK {
		goto gotError
	}
	if (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)))).Fflags&int32(VAR_ARRAY) != 0 && !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)))).Fflags&libc.Int32FromInt32(VAR_TRACED_READ) != 0) && !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)))).Fflags&libc.Int32FromInt32(VAR_TRACED_WRITE) != 0) {
		*(*uintptr)(unsafe.Pointer(bp + 48)) = _VarHashCreateVar(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)) + 8)), part2Ptr, libc.UintptrFromInt32(0))
		if *(*uintptr)(unsafe.Pointer(bp + 48)) != 0 && (!((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)|libc.Int32FromInt32(VAR_TRACED_READ)) != 0 || (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 && (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr != libc.UintptrFromInt32(0) && (*TVar1)(unsafe.Pointer((*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr)).Fflags&int32(VAR_TRACED_READ) != 0) && *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) != 0) && !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_DEAD_HASH)|libc.Int32FromInt32(VAR_CONSTANT)) != 0 || (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 && (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr != libc.UintptrFromInt32(0) && (*TVar1)(unsafe.Pointer((*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr)).Fflags&(libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_DEAD_HASH)|libc.Int32FromInt32(VAR_CONSTANT)) != 0) {
			goto lappendListDirect
		}
	}
	*(*uintptr)(unsafe.Pointer(bp + 48)) = XTclLookupArrayElement(tls, interp4, part1Ptr, part2Ptr, int32(TCL_LEAVE_ERR_MSG), __ccgo_ts+5383, int32(1), int32(1), *(*uintptr)(unsafe.Pointer(bp + 56)), opnd)
	if *(*uintptr)(unsafe.Pointer(bp + 48)) == libc.UintptrFromInt32(0) {
		goto gotError
	}
	goto lappendListPtr
_105:
	;
	pcAdjustment = int32(1)
	cleanup = int32(3)
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr))
	part2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)) /* element name */
	part1Ptr = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(2))*8)) /* array name */
	goto lappendList
_106:
	;
	pcAdjustment = int32(1)
	cleanup = int32(2)
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr))
	part2Ptr = libc.UintptrFromInt32(0)
	part1Ptr = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)) /* variable name */
	goto lappendList
	goto lappendListDirect
lappendListDirect:
	;
	*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr2 != 0 {
			v383 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr2)).FspanLength
		} else {
			v383 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 128)) = v383
		v382 = libc.Int32FromInt32(TCL_OK)
	} else {
		v382 = XTcl_ListObjLength(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 8)), bp+128)
	}
	if v382 != TCL_OK {
		goto gotError
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount > int64(1) {
		newValue = XTcl_DuplicateObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
		v385 = *(*uintptr)(unsafe.Pointer(bp + 8))
		v384 = *(*TTcl_Size)(unsafe.Pointer(v385))
		*(*TTcl_Size)(unsafe.Pointer(v385))--
		if !(v384 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = int64(-libc.Int32FromInt32(1))
				if v386 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v386 {
					cachePtr23 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v386 || ((*TAllocCache)(unsafe.Pointer(cachePtr23)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr23)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr23)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr23)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
					(*TAllocCache)(unsafe.Pointer(cachePtr23)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
			}
		}
		v387 = newValue
		*(*uintptr)(unsafe.Pointer(bp + 8)) = v387
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) = v387
		(*TTcl_Obj)(unsafe.Pointer(newValue)).FrefCount++
	}
	if XTclListObjAppendElements(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 8)), *(*TTcl_Size)(unsafe.Pointer(bp + 40)), *(*uintptr)(unsafe.Pointer(bp + 24))) != TCL_OK {
		goto gotError
	}
	pc += uintptr(pcAdjustment)
	cleanup = cleanup
	if int32(1) != 0 {
		if int32(1) > 0 {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
		}
		goto cleanupV_pushObjResultPtr
	} else {
		goto cleanupV
	}
	goto lappendList
lappendList:
	;
	opnd = -int32(1)
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr2 != 0 {
			v389 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr2)).FspanStart
		} else {
			v389 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 24)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1 + 40 + uintptr(v389)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr2 != 0 {
			v390 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr2)).FspanLength
		} else {
			v390 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = v390
		v388 = libc.Int32FromInt32(TCL_OK)
	} else {
		v388 = XTcl_ListObjGetElements(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 16)), bp+40, bp+24)
	}
	if v388 != TCL_OK {
		goto gotError
	}
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	*(*uintptr)(unsafe.Pointer(bp + 48)) = XTclObjLookupVarEx(tls, interp4, part1Ptr, part2Ptr, int32(TCL_LEAVE_ERR_MSG), __ccgo_ts+5383, int32(1), int32(1), bp+56)
	checkInterp = int32(1)
	if !(*(*uintptr)(unsafe.Pointer(bp + 48)) != 0) {
		goto gotError
	}
	goto lappendListPtr
lappendListPtr:
	;
	if (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
		(*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).FrefCount++
	}
	if *(*uintptr)(unsafe.Pointer(bp + 56)) != 0 && (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
		(*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)))).FrefCount++
	}
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclPtrGetVarIdx(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 48)), *(*uintptr)(unsafe.Pointer(bp + 56)), part1Ptr, part2Ptr, int32(TCL_LEAVE_ERR_MSG), opnd)
	checkInterp = int32(1)
	if (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
		(*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).FrefCount--
	}
	if *(*uintptr)(unsafe.Pointer(bp + 56)) != 0 && (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
		(*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)))).FrefCount--
	}
	createdNewObj = 0
	if !(*(*uintptr)(unsafe.Pointer(bp + 8)) != 0) {
		valueToAssign = *(*uintptr)(unsafe.Pointer(bp + 16))
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr2 != 0 {
				v392 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr2)).FspanLength
			} else {
				v392 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 128)) = v392
			v391 = libc.Int32FromInt32(TCL_OK)
		} else {
			v391 = XTcl_ListObjLength(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 8)), bp+128)
		}
		if v391 != TCL_OK {
			goto gotError
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount > int64(1) {
				valueToAssign = XTcl_DuplicateObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
				createdNewObj = int32(1)
			} else {
				valueToAssign = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
			if XTclListObjAppendElements(tls, interp4, valueToAssign, *(*TTcl_Size)(unsafe.Pointer(bp + 40)), *(*uintptr)(unsafe.Pointer(bp + 24))) != TCL_OK {
				if createdNewObj != 0 {
					v394 = valueToAssign
					v393 = *(*TTcl_Size)(unsafe.Pointer(v394))
					*(*TTcl_Size)(unsafe.Pointer(v394))--
					if !(v393 > int64(1)) {
						if !((*TTcl_Obj)(unsafe.Pointer(valueToAssign)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(valueToAssign)).FtypePtr)).FfreeIntRepProc != 0) {
							if (*TTcl_Obj)(unsafe.Pointer(valueToAssign)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(valueToAssign)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
								XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(valueToAssign)).Fbytes)
							}
							(*TTcl_Obj)(unsafe.Pointer(valueToAssign)).Flength = int64(-libc.Int32FromInt32(1))
							if v395 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v395 {
								cachePtr24 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
							}
							if v395 || ((*TAllocCache)(unsafe.Pointer(cachePtr24)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr24)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
								XTclThreadFreeObj(tls, valueToAssign)
							} else {
								(*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer(valueToAssign + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr24)).FfirstObjPtr
								(*TAllocCache)(unsafe.Pointer(cachePtr24)).FfirstObjPtr = valueToAssign
								(*TAllocCache)(unsafe.Pointer(cachePtr24)).FnumObjects++
							}
						} else {
							XTclFreeObj(tls, valueToAssign)
						}
					}
				}
				goto errorInLappendListPtr
			}
		}
	}
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclPtrSetVarIdx(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 48)), *(*uintptr)(unsafe.Pointer(bp + 56)), part1Ptr, part2Ptr, valueToAssign, int32(TCL_LEAVE_ERR_MSG), opnd)
	checkInterp = int32(1)
	if !!(*(*uintptr)(unsafe.Pointer(bp + 8)) != 0) {
		goto _396
	}
	goto errorInLappendListPtr
errorInLappendListPtr:
	;
	goto gotError
_396:
	;
	pc += uintptr(pcAdjustment)
	cleanup = cleanup
	if int32(1) != 0 {
		if int32(1) > 0 {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
		}
		goto cleanupV_pushObjResultPtr
	} else {
		goto cleanupV
	}
	/*
	 *	   End of INST_STORE and related instructions.
	 * -----------------------------------------------------------------
	 *	   Start of INST_INCR instructions.
	 *
	 * WARNING: more 'goto' here than your doctor recommended! The different
	 * instructions set the value of some variables and then jump to some
	 * common execution code.
	 */
	/*TODO: Consider more untangling here; merge with LOAD and STORE ? */
_111:
	;
_110:
	;
_109:
	;
_108:
	;
_107:
	;
	opnd = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1)))))
	v397 = tosPtr
	tosPtr -= 8
	incrPtr = *(*uintptr)(unsafe.Pointer(v397))
	switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) {
	case int32(INST_INCR_SCALAR1):
		pcAdjustment = int32(2)
		goto doIncrScalar
	case int32(INST_INCR_ARRAY1):
		pcAdjustment = int32(2)
		goto doIncrArray
	default:
		pcAdjustment = int32(1)
		goto doIncrStk
	}
_114:
	;
_113:
	;
_112:
	;
	increment = int64(int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1)))))
	if v398 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v398 {
		cachePtr25 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v398 || (*TAllocCache)(unsafe.Pointer(cachePtr25)).FnumObjects == libc.Uint64FromInt32(0) {
		incrPtr = XTclThreadAllocObj(tls)
	} else {
		incrPtr = (*TAllocCache)(unsafe.Pointer(cachePtr25)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr25)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(incrPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr25)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(incrPtr)).Fbytes = libc.UintptrFromInt32(0)
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FinternalRep)) = increment
	(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FrefCount++
	pcAdjustment = int32(2)
	goto doIncrStk
doIncrStk:
	;
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) == int32(INST_INCR_ARRAY_STK_IMM) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) == int32(INST_INCR_ARRAY_STK) {
		part2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr))
		objPtr5 = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8))
	} else {
		part2Ptr = libc.UintptrFromInt32(0)
		objPtr5 = *(*uintptr)(unsafe.Pointer(tosPtr))
	}
	part1Ptr = objPtr5
	opnd = -int32(1)
	*(*uintptr)(unsafe.Pointer(bp + 48)) = XTclObjLookupVarEx(tls, interp4, objPtr5, part2Ptr, int32(TCL_LEAVE_ERR_MSG), __ccgo_ts+5552, int32(1), int32(1), bp+56)
	if !(*(*uintptr)(unsafe.Pointer(bp + 48)) != 0) {
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		XTcl_AppendObjToErrorInfo(tls, interp4, XTcl_NewStringObj(tls, __ccgo_ts+32116, int64(-int32(1))))
		checkInterp = int32(1)
		_objPtr19 = incrPtr
		v400 = _objPtr19
		v399 = *(*TTcl_Size)(unsafe.Pointer(v400))
		*(*TTcl_Size)(unsafe.Pointer(v400))--
		if v399 <= int64(1) {
			XTclFreeObj(tls, _objPtr19)
		}
		goto gotError
	}
	if part2Ptr == libc.UintptrFromInt32(0) {
		v401 = int32(1)
	} else {
		v401 = int32(2)
	}
	cleanup = v401
	goto doIncrVar
_115:
	;
	opnd = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1)))))
	increment = int64(int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(2)))))
	if v402 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v402 {
		cachePtr26 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v402 || (*TAllocCache)(unsafe.Pointer(cachePtr26)).FnumObjects == libc.Uint64FromInt32(0) {
		incrPtr = XTclThreadAllocObj(tls)
	} else {
		incrPtr = (*TAllocCache)(unsafe.Pointer(cachePtr26)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr26)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(incrPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr26)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(incrPtr)).Fbytes = libc.UintptrFromInt32(0)
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FinternalRep)) = increment
	(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FrefCount++
	pcAdjustment = int32(3)
	goto doIncrArray
doIncrArray:
	;
	part1Ptr = libc.UintptrFromInt32(0)
	part2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr))
	*(*uintptr)(unsafe.Pointer(bp + 56)) = compiledLocals + uintptr(opnd)*16
	cleanup = int32(1)
	for (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)))).Fflags&int32(VAR_LINK) != 0 {
		*(*uintptr)(unsafe.Pointer(bp + 56)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)) + 8))
	}
	*(*uintptr)(unsafe.Pointer(bp + 48)) = XTclLookupArrayElement(tls, interp4, part1Ptr, part2Ptr, int32(TCL_LEAVE_ERR_MSG), __ccgo_ts+5552, int32(1), int32(1), *(*uintptr)(unsafe.Pointer(bp + 56)), opnd)
	if !(*(*uintptr)(unsafe.Pointer(bp + 48)) != 0) {
		_objPtr20 = incrPtr
		v404 = _objPtr20
		v403 = *(*TTcl_Size)(unsafe.Pointer(v404))
		*(*TTcl_Size)(unsafe.Pointer(v404))--
		if v403 <= int64(1) {
			XTclFreeObj(tls, _objPtr20)
		}
		goto gotError
	}
	goto doIncrVar
_116:
	;
	opnd = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1)))))
	increment = int64(int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(2)))))
	pcAdjustment = int32(3)
	cleanup = 0
	*(*uintptr)(unsafe.Pointer(bp + 48)) = compiledLocals + uintptr(opnd)*16
	for (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_LINK) != 0 {
		*(*uintptr)(unsafe.Pointer(bp + 48)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
	}
	if !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)|libc.Int32FromInt32(VAR_TRACED_READ)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_CONSTANT)) != 0 || (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 && (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr != libc.UintptrFromInt32(0) && (*TVar1)(unsafe.Pointer((*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr)).Fflags&(libc.Int32FromInt32(VAR_TRACED_READ)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_CONSTANT)) != 0) && *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) != 0 {
		objPtr5 = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
		if (*TTcl_Obj)(unsafe.Pointer(objPtr5)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
			*(*int32)(unsafe.Pointer(bp + 144)) = int32(TCL_NUMBER_INT)
			*(*uintptr)(unsafe.Pointer(bp + 136)) = objPtr5 + 32
			v405 = libc.Int32FromInt32(TCL_OK)
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr5)).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
				*(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr5)).FinternalRep))
				v408 = *(*uint64)(unsafe.Pointer(bp))
				goto _409
			_409:
				if libc.BoolInt32(v408&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) > libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
					*(*int32)(unsafe.Pointer(bp + 144)) = int32(TCL_NUMBER_NAN)
				} else {
					*(*int32)(unsafe.Pointer(bp + 144)) = int32(TCL_NUMBER_DOUBLE)
				}
				*(*uintptr)(unsafe.Pointer(bp + 136)) = objPtr5 + 32
				v406 = libc.Int32FromInt32(TCL_OK)
			} else {
				if (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes != libc.UintptrFromInt32(0) && (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Flength == 0 {
					v410 = int32(TCL_ERROR)
				} else {
					v410 = XTcl_GetNumberFromObj(tls, libc.UintptrFromInt32(0), objPtr5, bp+136, bp+144)
				}
				v406 = v410
			}
			v405 = v406
		}
		if v405 == TCL_OK {
			if *(*int32)(unsafe.Pointer(bp + 144)) == int32(TCL_NUMBER_INT) {
				augend = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 136))))
				sum = libc.Int64FromUint64(libc.Uint64FromInt64(augend) + libc.Uint64FromInt64(increment))
				/*
				 * Overflow when (augend and sum have different sign) and
				 * (augend and increment have the same sign). This is
				 * encapsulated in the Overflowing macro.
				 */
				if !(augend^sum < 0 && augend^increment >= 0) {
					if (*TTcl_Obj)(unsafe.Pointer(objPtr5)).FrefCount > int64(1) {
						(*TTcl_Obj)(unsafe.Pointer(objPtr5)).FrefCount-- /* We know it's shared. */
						if v411 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v411 {
							cachePtr27 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v411 || (*TAllocCache)(unsafe.Pointer(cachePtr27)).FnumObjects == libc.Uint64FromInt32(0) {
							*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
						} else {
							*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr27)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr27)).FfirstObjPtr = (*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
							(*TAllocCache)(unsafe.Pointer(cachePtr27)).FnumObjects--
						}
						(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
						(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = libc.UintptrFromInt32(0)
						*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FinternalRep)) = sum
						(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
						(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
						*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8))
					} else {
						*(*uintptr)(unsafe.Pointer(bp + 8)) = objPtr5
						*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 152)))) = sum
						_isobjPtr = objPtr5
						if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
							if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
								XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
							}
							(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
						}
						XTcl_StoreInternalRep(tls, objPtr5, uintptr(unsafe.Pointer(&XtclIntType)), bp+152)
					}
					goto doneIncr
				}
				w = augend
				if (*TTcl_Obj)(unsafe.Pointer(objPtr5)).FrefCount > int64(1) {
					(*TTcl_Obj)(unsafe.Pointer(objPtr5)).FrefCount-- /* We know it's shared. */
					if v412 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v412 {
						cachePtr28 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v412 || (*TAllocCache)(unsafe.Pointer(cachePtr28)).FnumObjects == libc.Uint64FromInt32(0) {
						*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
					} else {
						*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr28)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr28)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr28)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = libc.UintptrFromInt32(0)
					*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FinternalRep)) = w + increment
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
					*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				} else {
					*(*uintptr)(unsafe.Pointer(bp + 8)) = objPtr5
					/*
					 * We know the sum value is outside the Tcl_WideInt range;
					 * use macro form that doesn't range test again.
					 */
					*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 168)))) = w + increment
					_isobjPtr1 = objPtr5
					if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes != libc.UintptrFromInt32(0) {
						if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes = libc.UintptrFromInt32(0)
					}
					XTcl_StoreInternalRep(tls, objPtr5, uintptr(unsafe.Pointer(&XtclIntType)), bp+168)
				}
				goto doneIncr
			} /* end if (type == TCL_NUMBER_INT) */
		}
		if (*TTcl_Obj)(unsafe.Pointer(objPtr5)).FrefCount > int64(1) {
			(*TTcl_Obj)(unsafe.Pointer(objPtr5)).FrefCount-- /* We know it's shared */
			*(*uintptr)(unsafe.Pointer(bp + 8)) = XTcl_DuplicateObj(tls, objPtr5)
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8))
		} else {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = objPtr5
		}
		if v413 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v413 {
			cachePtr29 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v413 || (*TAllocCache)(unsafe.Pointer(cachePtr29)).FnumObjects == libc.Uint64FromInt32(0) {
			incrPtr = XTclThreadAllocObj(tls)
		} else {
			incrPtr = (*TAllocCache)(unsafe.Pointer(cachePtr29)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr29)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(incrPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr29)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(incrPtr)).Fbytes = libc.UintptrFromInt32(0)
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FinternalRep)) = increment
		(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
		if XTclIncrObj(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 8)), incrPtr) != TCL_OK {
			_objPtr21 = incrPtr
			v415 = _objPtr21
			v414 = *(*TTcl_Size)(unsafe.Pointer(v415))
			*(*TTcl_Size)(unsafe.Pointer(v415))--
			if v414 <= int64(1) {
				XTclFreeObj(tls, _objPtr21)
			}
			goto gotError
		}
		_objPtr22 = incrPtr
		v417 = _objPtr22
		v416 = *(*TTcl_Size)(unsafe.Pointer(v417))
		*(*TTcl_Size)(unsafe.Pointer(v417))--
		if v416 <= int64(1) {
			XTclFreeObj(tls, _objPtr22)
		}
		goto doneIncr
	}
	/*
	 * All other cases, flow through to generic handling.
	 */
	if v418 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v418 {
		cachePtr30 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v418 || (*TAllocCache)(unsafe.Pointer(cachePtr30)).FnumObjects == libc.Uint64FromInt32(0) {
		incrPtr = XTclThreadAllocObj(tls)
	} else {
		incrPtr = (*TAllocCache)(unsafe.Pointer(cachePtr30)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr30)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(incrPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr30)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(incrPtr)).Fbytes = libc.UintptrFromInt32(0)
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FinternalRep)) = increment
	(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	(*TTcl_Obj)(unsafe.Pointer(incrPtr)).FrefCount++
	goto doIncrScalar
doIncrScalar:
	;
	*(*uintptr)(unsafe.Pointer(bp + 48)) = compiledLocals + uintptr(opnd)*16
	for (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_LINK) != 0 {
		*(*uintptr)(unsafe.Pointer(bp + 48)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
	}
	*(*uintptr)(unsafe.Pointer(bp + 56)) = libc.UintptrFromInt32(0)
	v419 = libc.UintptrFromInt32(0)
	part2Ptr = v419
	part1Ptr = v419
	cleanup = 0
	goto doIncrVar
doIncrVar:
	;
	if !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)|libc.Int32FromInt32(VAR_TRACED_READ)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_CONSTANT)) != 0 || (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 && (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr != libc.UintptrFromInt32(0) && (*TVar1)(unsafe.Pointer((*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr)).Fflags&(libc.Int32FromInt32(VAR_TRACED_READ)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_CONSTANT)) != 0) && *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) != 0 && (!(*(*uintptr)(unsafe.Pointer(bp + 56)) != 0) || !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)))).Fflags&(libc.Int32FromInt32(VAR_TRACED_READ)|libc.Int32FromInt32(VAR_TRACED_WRITE)) != 0)) {
		objPtr5 = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
		if (*TTcl_Obj)(unsafe.Pointer(objPtr5)).FrefCount > int64(1) {
			(*TTcl_Obj)(unsafe.Pointer(objPtr5)).FrefCount-- /* We know it's shared */
			*(*uintptr)(unsafe.Pointer(bp + 8)) = XTcl_DuplicateObj(tls, objPtr5)
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8))
		} else {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = objPtr5
		}
		if XTclIncrObj(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 8)), incrPtr) != TCL_OK {
			_objPtr23 = incrPtr
			v421 = _objPtr23
			v420 = *(*TTcl_Size)(unsafe.Pointer(v421))
			*(*TTcl_Size)(unsafe.Pointer(v421))--
			if v420 <= int64(1) {
				XTclFreeObj(tls, _objPtr23)
			}
			goto gotError
		}
		_objPtr24 = incrPtr
		v423 = _objPtr24
		v422 = *(*TTcl_Size)(unsafe.Pointer(v423))
		*(*TTcl_Size)(unsafe.Pointer(v423))--
		if v422 <= int64(1) {
			XTclFreeObj(tls, _objPtr24)
		}
	} else {
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclPtrIncrObjVarIdx(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 48)), *(*uintptr)(unsafe.Pointer(bp + 56)), part1Ptr, part2Ptr, incrPtr, int32(TCL_LEAVE_ERR_MSG), opnd)
		checkInterp = int32(1)
		_objPtr25 = incrPtr
		v425 = _objPtr25
		v424 = *(*TTcl_Size)(unsafe.Pointer(v425))
		*(*TTcl_Size)(unsafe.Pointer(v425))--
		if v424 <= int64(1) {
			XTclFreeObj(tls, _objPtr25)
		}
		if *(*uintptr)(unsafe.Pointer(bp + 8)) == libc.UintptrFromInt32(0) {
			goto gotError
		}
	}
	goto doneIncr
doneIncr:
	;
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + uintptr(pcAdjustment)))) == int32(INST_POP) {
		pc += uintptr(pcAdjustment + libc.Int32FromInt32(1))
		cleanup = cleanup
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			goto cleanupV_pushObjResultPtr
		} else {
			goto cleanupV
		}
	}
	pc += uintptr(pcAdjustment)
	cleanup = cleanup
	if int32(1) != 0 {
		if int32(1) > 0 {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
		}
		goto cleanupV_pushObjResultPtr
	} else {
		goto cleanupV
	}
	/*
	 *	   End of INST_INCR instructions.
	 * -----------------------------------------------------------------
	 *	   Start of INST_EXIST instructions.
	 */
_117:
	;
	cleanup = 0
	pcAdjustment = int32(5)
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	*(*uintptr)(unsafe.Pointer(bp + 48)) = compiledLocals + uintptr(opnd)*16
	for (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_LINK) != 0 {
		*(*uintptr)(unsafe.Pointer(bp + 48)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
	}
	if (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_TRACED_READ) != 0 {
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		XTclObjCallVarTraces(tls, interp4, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 48)), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), int32(TCL_TRACE_READS), 0, opnd)
		checkInterp = int32(1)
		if *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) == libc.UintptrFromInt32(0) {
			XTclCleanupVar(tls, *(*uintptr)(unsafe.Pointer(bp + 48)), libc.UintptrFromInt32(0))
			*(*uintptr)(unsafe.Pointer(bp + 48)) = libc.UintptrFromInt32(0)
		}
	}
	goto afterExistsPeephole
_118:
	;
	cleanup = int32(1)
	pcAdjustment = int32(5)
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	part2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr))
	*(*uintptr)(unsafe.Pointer(bp + 56)) = compiledLocals + uintptr(opnd)*16
	for (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)))).Fflags&int32(VAR_LINK) != 0 {
		*(*uintptr)(unsafe.Pointer(bp + 56)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)) + 8))
	}
	if (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)))).Fflags&int32(VAR_ARRAY) != 0 && !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)))).Fflags&libc.Int32FromInt32(VAR_TRACED_READ) != 0) {
		*(*uintptr)(unsafe.Pointer(bp + 48)) = _VarHashCreateVar(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)) + 8)), part2Ptr, libc.UintptrFromInt32(0))
		if !(*(*uintptr)(unsafe.Pointer(bp + 48)) != 0) || !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&libc.Int32FromInt32(VAR_TRACED_READ) != 0) {
			goto afterExistsPeephole
		}
	}
	*(*uintptr)(unsafe.Pointer(bp + 48)) = XTclLookupArrayElement(tls, interp4, libc.UintptrFromInt32(0), part2Ptr, 0, __ccgo_ts+32162, 0, int32(1), *(*uintptr)(unsafe.Pointer(bp + 56)), opnd)
	if *(*uintptr)(unsafe.Pointer(bp + 48)) != 0 {
		if (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_TRACED_READ) != 0 || *(*uintptr)(unsafe.Pointer(bp + 56)) != 0 && (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)))).Fflags&int32(VAR_TRACED_READ) != 0 {
			(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
			XTclObjCallVarTraces(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 56)), *(*uintptr)(unsafe.Pointer(bp + 48)), libc.UintptrFromInt32(0), part2Ptr, int32(TCL_TRACE_READS), 0, opnd)
			checkInterp = int32(1)
		}
		if *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) == libc.UintptrFromInt32(0) {
			XTclCleanupVar(tls, *(*uintptr)(unsafe.Pointer(bp + 48)), *(*uintptr)(unsafe.Pointer(bp + 56)))
			*(*uintptr)(unsafe.Pointer(bp + 48)) = libc.UintptrFromInt32(0)
		}
	}
	goto afterExistsPeephole
_119:
	;
	cleanup = int32(2)
	pcAdjustment = int32(1)
	part2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr))                                      /* element name */
	part1Ptr = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)) /* array name */
	goto doExistStk
_120:
	;
	cleanup = int32(1)
	pcAdjustment = int32(1)
	part2Ptr = libc.UintptrFromInt32(0)
	part1Ptr = *(*uintptr)(unsafe.Pointer(tosPtr)) /* variable name */
	goto doExistStk
doExistStk:
	;
	*(*uintptr)(unsafe.Pointer(bp + 48)) = XTclObjLookupVarEx(tls, interp4, part1Ptr, part2Ptr, 0, __ccgo_ts+32162, 0, int32(1), bp+56)
	if *(*uintptr)(unsafe.Pointer(bp + 48)) != 0 {
		if (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_TRACED_READ) != 0 || *(*uintptr)(unsafe.Pointer(bp + 56)) != 0 && (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)))).Fflags&int32(VAR_TRACED_READ) != 0 {
			(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
			XTclObjCallVarTraces(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 56)), *(*uintptr)(unsafe.Pointer(bp + 48)), part1Ptr, part2Ptr, int32(TCL_TRACE_READS), 0, -int32(1))
			checkInterp = int32(1)
		}
		if *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) == libc.UintptrFromInt32(0) {
			XTclCleanupVar(tls, *(*uintptr)(unsafe.Pointer(bp + 48)), *(*uintptr)(unsafe.Pointer(bp + 56)))
			*(*uintptr)(unsafe.Pointer(bp + 48)) = libc.UintptrFromInt32(0)
		}
	}
	/*
	 * Peep-hole optimisation: if you're about to jump, do jump from here.
	 */
	goto afterExistsPeephole
afterExistsPeephole:
	;
	found = libc.BoolInt32(*(*uintptr)(unsafe.Pointer(bp + 48)) != 0 && !(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) == libc.UintptrFromInt32(0)))
	pc += uintptr(pcAdjustment)
	switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) {
	case int32(INST_JUMP_FALSE1):
		if found != 0 {
			v428 = int32(2)
		} else {
			v428 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
		}
		pc += uintptr(v428)
		cleanup = cleanup
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			goto cleanupV_pushObjResultPtr
		} else {
			goto cleanupV
		}
	case int32(INST_JUMP_TRUE1):
		if found != 0 {
			v429 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
		} else {
			v429 = int32(2)
		}
		pc += uintptr(v429)
		cleanup = cleanup
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			goto cleanupV_pushObjResultPtr
		} else {
			goto cleanupV
		}
	case int32(INST_JUMP_FALSE4):
		if found != 0 {
			v430 = int32(5)
		} else {
			v430 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
		}
		pc += uintptr(v430)
		cleanup = cleanup
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			goto cleanupV_pushObjResultPtr
		} else {
			goto cleanupV
		}
	case int32(INST_JUMP_TRUE4):
		if found != 0 {
			v431 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
		} else {
			v431 = int32(5)
		}
		pc += uintptr(v431)
		cleanup = cleanup
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			goto cleanupV_pushObjResultPtr
		} else {
			goto cleanupV
		}
	default:
		if found < 0 {
			if v432 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v432 {
				cachePtr31 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v432 || (*TAllocCache)(unsafe.Pointer(cachePtr31)).FnumObjects == libc.Uint64FromInt32(0) {
				*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
			} else {
				*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr31)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr31)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr31)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = libc.UintptrFromInt32(0)
			*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FinternalRep)) = int64(-libc.Int32FromInt32(1))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
		} else {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(constants + libc.BoolUintptr(found > libc.Int32FromInt32(0))*8))
		}
		pc += uintptr(libc.Int32FromInt32(0))
		cleanup = cleanup
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			goto cleanupV_pushObjResultPtr
		} else {
			goto cleanupV
		}
		break
	}
	goto _427
_427:
	;
	goto _426
_426: /**/
	; //
	/*
	 *	   End of INST_EXIST instructions.
	 * -----------------------------------------------------------------
	 *	   Start of INST_UNSET instructions.
	 */
_121:
	;
	if uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1)))) != 0 {
		v433 = int32(TCL_LEAVE_ERR_MSG)
	} else {
		v433 = 0
	}
	flags = v433
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(2) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(2) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(2) + libc.UintptrFromInt32(3))))))
	*(*uintptr)(unsafe.Pointer(bp + 48)) = compiledLocals + uintptr(opnd)*16
	for (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_LINK) != 0 {
		*(*uintptr)(unsafe.Pointer(bp + 48)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
	}
	if !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)|libc.Int32FromInt32(VAR_TRACED_READ)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_TRACED_UNSET)|libc.Int32FromInt32(VAR_DEAD_HASH)|libc.Int32FromInt32(VAR_CONSTANT)) != 0 || (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 && (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr != libc.UintptrFromInt32(0) && (*TVar1)(unsafe.Pointer((*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr)).Fflags&(libc.Int32FromInt32(VAR_TRACED_READ)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_TRACED_UNSET)|libc.Int32FromInt32(VAR_DEAD_HASH)|libc.Int32FromInt32(VAR_CONSTANT)) != 0) && !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&libc.Int32FromInt32(VAR_IN_HASHTABLE) != 0) {
		/*
		 * No errors, no traces, no searches: just make the variable cease
		 * to exist.
		 */
		if !(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) == libc.UintptrFromInt32(0)) {
			v435 = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
			v434 = *(*TTcl_Size)(unsafe.Pointer(v435))
			*(*TTcl_Size)(unsafe.Pointer(v435))--
			if !(v434 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))).Flength = int64(-libc.Int32FromInt32(1))
					if v436 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v436 {
						cachePtr32 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v436 || ((*TAllocCache)(unsafe.Pointer(cachePtr32)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr32)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr32)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr32)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
						(*TAllocCache)(unsafe.Pointer(cachePtr32)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))
				}
			}
		} else {
			if flags&int32(TCL_LEAVE_ERR_MSG) != 0 {
				goto slowUnsetScalar
			}
		}
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) = libc.UintptrFromInt32(0)
		if true {
			if 0 != 0 {
				if 0 > 0 {
					v439 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v440 = tosPtr
					*(*uintptr)(unsafe.Pointer(v440)) = v439
					(*TTcl_Obj)(unsafe.Pointer(v439)).FrefCount++
				} else {
					tosPtr += 8
					v441 = tosPtr
					*(*uintptr)(unsafe.Pointer(v441)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(6))
			goto cleanup0
		} else {
			if 0 != 0 {
				if 0 > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(6))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(6))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _438
	_438:
		;
		goto _437
	_437: /**/
		//
	}
	goto slowUnsetScalar
slowUnsetScalar:
	;
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	if XTclPtrUnsetVarIdx(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 48)), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), flags, opnd) != TCL_OK && flags != 0 {
		goto errorInUnset
	}
	checkInterp = int32(1)
	if true {
		if 0 != 0 {
			if 0 > 0 {
				v444 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v445 = tosPtr
				*(*uintptr)(unsafe.Pointer(v445)) = v444
				(*TTcl_Obj)(unsafe.Pointer(v444)).FrefCount++
			} else {
				tosPtr += 8
				v446 = tosPtr
				*(*uintptr)(unsafe.Pointer(v446)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(6))
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(6))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(6))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _443
_443:
	;
	goto _442
_442: /**/
	; //
_122:
	;
	if uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1)))) != 0 {
		v447 = int32(TCL_LEAVE_ERR_MSG)
	} else {
		v447 = 0
	}
	flags = v447
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(2) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(2) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(2) + libc.UintptrFromInt32(3))))))
	part2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr))
	*(*uintptr)(unsafe.Pointer(bp + 56)) = compiledLocals + uintptr(opnd)*16
	for (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)))).Fflags&int32(VAR_LINK) != 0 {
		*(*uintptr)(unsafe.Pointer(bp + 56)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)) + 8))
	}
	if (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)))).Fflags&int32(VAR_ARRAY) != 0 && !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)))).Fflags&libc.Int32FromInt32(VAR_TRACED_UNSET) != 0) && !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)))).Fflags&libc.Int32FromInt32(VAR_SEARCH_ACTIVE) != 0) {
		*(*uintptr)(unsafe.Pointer(bp + 48)) = _VarHashCreateVar(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 56)) + 8)), part2Ptr, libc.UintptrFromInt32(0))
		if *(*uintptr)(unsafe.Pointer(bp + 48)) != 0 && !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)|libc.Int32FromInt32(VAR_TRACED_READ)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_TRACED_UNSET)|libc.Int32FromInt32(VAR_DEAD_HASH)|libc.Int32FromInt32(VAR_CONSTANT)) != 0 || (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 && (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr != libc.UintptrFromInt32(0) && (*TVar1)(unsafe.Pointer((*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr)).Fflags&(libc.Int32FromInt32(VAR_TRACED_READ)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_TRACED_UNSET)|libc.Int32FromInt32(VAR_DEAD_HASH)|libc.Int32FromInt32(VAR_CONSTANT)) != 0) {
			/*
			 * No nasty traces and element exists, so we can proceed to
			 * unset it. Might still not exist though...
			 */
			if !(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) == libc.UintptrFromInt32(0)) {
				v449 = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
				v448 = *(*TTcl_Size)(unsafe.Pointer(v449))
				*(*TTcl_Size)(unsafe.Pointer(v449))--
				if !(v448 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))).Flength = int64(-libc.Int32FromInt32(1))
						if v450 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v450 {
							cachePtr33 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v450 || ((*TAllocCache)(unsafe.Pointer(cachePtr33)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr33)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr33)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr33)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
							(*TAllocCache)(unsafe.Pointer(cachePtr33)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))
					}
				}
				*(*int32)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))) &= ^(libc.Int32FromInt32(VAR_ARRAY) | libc.Int32FromInt32(VAR_LINK) | libc.Int32FromInt32(VAR_CONSTANT))
				*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) = libc.UintptrFromInt32(0)
				if (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_NAMESPACE_VAR) != 0 {
					*(*int32)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))) &= ^libc.Int32FromInt32(VAR_NAMESPACE_VAR)
					if (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
						(*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).FrefCount--
					}
				}
				XTclCleanupVar(tls, *(*uintptr)(unsafe.Pointer(bp + 48)), *(*uintptr)(unsafe.Pointer(bp + 56)))
			} else {
				if flags&int32(TCL_LEAVE_ERR_MSG) != 0 {
					goto slowUnsetArray
				}
			}
			if false {
				if 0 != 0 {
					if 0 > 0 {
						v453 = *(*uintptr)(unsafe.Pointer(bp + 8))
						tosPtr += 8
						v454 = tosPtr
						*(*uintptr)(unsafe.Pointer(v454)) = v453
						(*TTcl_Obj)(unsafe.Pointer(v453)).FrefCount++
					} else {
						tosPtr += 8
						v455 = tosPtr
						*(*uintptr)(unsafe.Pointer(v455)) = *(*uintptr)(unsafe.Pointer(bp + 8))
					}
				}
				pc += uintptr(libc.Int32FromInt32(6))
				goto cleanup0
			} else {
				if 0 != 0 {
					if 0 > 0 {
						(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
					}
					pc += uintptr(libc.Int32FromInt32(6))
					switch libc.Int32FromInt32(1) {
					case int32(1):
						goto cleanup1_pushObjResultPtr
					case int32(2):
						goto cleanup2_pushObjResultPtr
					case 0:
						break
					}
				} else {
					pc += uintptr(libc.Int32FromInt32(6))
					switch libc.Int32FromInt32(1) {
					case int32(1):
						goto cleanup1
					case int32(2):
						goto cleanup2
					case 0:
						break
					}
				}
			}
			goto _452
		_452:
			;
			goto _451
		_451: /**/ //
		} else {
			if !(*(*uintptr)(unsafe.Pointer(bp + 48)) != 0) && !(flags&libc.Int32FromInt32(TCL_LEAVE_ERR_MSG) != 0) {
				/*
				 * Don't need to do anything here.
				 */
				if false {
					if 0 != 0 {
						if 0 > 0 {
							v458 = *(*uintptr)(unsafe.Pointer(bp + 8))
							tosPtr += 8
							v459 = tosPtr
							*(*uintptr)(unsafe.Pointer(v459)) = v458
							(*TTcl_Obj)(unsafe.Pointer(v458)).FrefCount++
						} else {
							tosPtr += 8
							v460 = tosPtr
							*(*uintptr)(unsafe.Pointer(v460)) = *(*uintptr)(unsafe.Pointer(bp + 8))
						}
					}
					pc += uintptr(libc.Int32FromInt32(6))
					goto cleanup0
				} else {
					if 0 != 0 {
						if 0 > 0 {
							(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
						}
						pc += uintptr(libc.Int32FromInt32(6))
						switch libc.Int32FromInt32(1) {
						case int32(1):
							goto cleanup1_pushObjResultPtr
						case int32(2):
							goto cleanup2_pushObjResultPtr
						case 0:
							break
						}
					} else {
						pc += uintptr(libc.Int32FromInt32(6))
						switch libc.Int32FromInt32(1) {
						case int32(1):
							goto cleanup1
						case int32(2):
							goto cleanup2
						case 0:
							break
						}
					}
				}
				goto _457
			_457:
				;
				goto _456
			_456: /**/ //
			}
		}
	}
	goto slowUnsetArray
slowUnsetArray:
	;
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	*(*uintptr)(unsafe.Pointer(bp + 48)) = XTclLookupArrayElement(tls, interp4, libc.UintptrFromInt32(0), part2Ptr, flags, __ccgo_ts+3450, 0, 0, *(*uintptr)(unsafe.Pointer(bp + 56)), opnd)
	if !(*(*uintptr)(unsafe.Pointer(bp + 48)) != 0) {
		if flags&int32(TCL_LEAVE_ERR_MSG) != 0 {
			goto errorInUnset
		}
	} else {
		if XTclPtrUnsetVarIdx(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 48)), *(*uintptr)(unsafe.Pointer(bp + 56)), libc.UintptrFromInt32(0), part2Ptr, flags, opnd) != TCL_OK && flags&int32(TCL_LEAVE_ERR_MSG) != 0 {
			goto errorInUnset
		}
	}
	checkInterp = int32(1)
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v463 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v464 = tosPtr
				*(*uintptr)(unsafe.Pointer(v464)) = v463
				(*TTcl_Obj)(unsafe.Pointer(v463)).FrefCount++
			} else {
				tosPtr += 8
				v465 = tosPtr
				*(*uintptr)(unsafe.Pointer(v465)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(6))
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(6))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(6))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _462
_462:
	;
	goto _461
_461: /**/
	; //
_123:
	;
	if uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1)))) != 0 {
		v466 = int32(TCL_LEAVE_ERR_MSG)
	} else {
		v466 = 0
	}
	flags = v466
	cleanup = int32(2)
	part2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr))                                      /* element name */
	part1Ptr = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)) /* array name */
	goto doUnsetStk
_124:
	;
	if uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1)))) != 0 {
		v467 = int32(TCL_LEAVE_ERR_MSG)
	} else {
		v467 = 0
	}
	flags = v467
	cleanup = int32(1)
	part2Ptr = libc.UintptrFromInt32(0)
	part1Ptr = *(*uintptr)(unsafe.Pointer(tosPtr)) /* variable name */
	goto doUnsetStk
doUnsetStk:
	;
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	if XTclObjUnsetVar2(tls, interp4, part1Ptr, part2Ptr, flags) != TCL_OK && flags&int32(TCL_LEAVE_ERR_MSG) != 0 {
		goto errorInUnset
	}
	checkInterp = int32(1)
	pc += uintptr(libc.Int32FromInt32(2))
	cleanup = cleanup
	if 0 != 0 {
		if 0 > 0 {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
		}
		goto cleanupV_pushObjResultPtr
	} else {
		goto cleanupV
	}
	goto errorInUnset
errorInUnset:
	;
	checkInterp = int32(1)
	goto gotError
	goto _243
	/*
	 *	   End of INST_UNSET instructions.
	 * -----------------------------------------------------------------
	 *	   Start of INST_CONST instructions.
	 */
_125:
	;
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	pcAdjustment = int32(5)
	cleanup = int32(1)
	part1Ptr = libc.UintptrFromInt32(0)
	objPtr5 = *(*uintptr)(unsafe.Pointer(tosPtr))
	*(*uintptr)(unsafe.Pointer(bp + 48)) = compiledLocals + uintptr(opnd)*16
	*(*uintptr)(unsafe.Pointer(bp + 56)) = libc.UintptrFromInt32(0)
	for (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_LINK) != 0 {
		*(*uintptr)(unsafe.Pointer(bp + 48)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
	}
	goto doConst
_126:
	;
	opnd = -int32(1)
	pcAdjustment = int32(1)
	cleanup = int32(2)
	part1Ptr = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8))
	objPtr5 = *(*uintptr)(unsafe.Pointer(tosPtr))
	*(*uintptr)(unsafe.Pointer(bp + 48)) = XTclObjLookupVarEx(tls, interp4, part1Ptr, libc.UintptrFromInt32(0), 0, libc.UintptrFromInt32(0), int32(1), 0, bp+56)
	goto doConst
doConst:
	;
	if (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_CONSTANT) != 0 {
		pc += uintptr(pcAdjustment)
		cleanup = cleanup
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			goto cleanupV_pushObjResultPtr
		} else {
			goto cleanupV
		}
	}
	if (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_ARRAY) != 0 {
		msgPart = __ccgo_ts + 32169
		goto constError
	} else {
		if (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_ARRAY_ELEMENT) != 0 {
			msgPart = __ccgo_ts + 32187
			goto constError
		} else {
			if !(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) == libc.UintptrFromInt32(0)) {
				msgPart = __ccgo_ts + 32225
				goto constError
			}
		}
	}
	if !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)|libc.Int32FromInt32(VAR_TRACED_READ)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_CONSTANT)) != 0 || (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 && (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr != libc.UintptrFromInt32(0) && (*TVar1)(unsafe.Pointer((*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr)).Fflags&(libc.Int32FromInt32(VAR_TRACED_READ)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_CONSTANT)) != 0) && *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) != 0 {
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) = objPtr5
		(*TTcl_Obj)(unsafe.Pointer(objPtr5)).FrefCount++
	} else {
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		resPtr = XTclPtrSetVarIdx(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 48)), *(*uintptr)(unsafe.Pointer(bp + 56)), part1Ptr, libc.UintptrFromInt32(0), objPtr5, int32(TCL_LEAVE_ERR_MSG), opnd)
		checkInterp = int32(1)
		if resPtr == libc.UintptrFromInt32(0) {
			goto gotError
		}
	}
	(*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags = (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags & ^(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)) | int32(VAR_CONSTANT)
	pc += uintptr(pcAdjustment)
	cleanup = cleanup
	if 0 != 0 {
		if 0 > 0 {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
		}
		goto cleanupV_pushObjResultPtr
	} else {
		goto cleanupV
	}
	goto constError
constError:
	;
	XTclObjVarErrMsg(tls, interp4, part1Ptr, libc.UintptrFromInt32(0), __ccgo_ts+32249, msgPart, opnd)
	XTcl_SetErrorCode(tls, interp4, libc.VaList(bp+544, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+32263, libc.UintptrFromInt32(0)))
	goto gotError
	/*
	 *	   End of INST_CONST instructions.
	 * -----------------------------------------------------------------
	 *	   Start of INST_ARRAY instructions.
	 */
_127:
	;
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	pcAdjustment = int32(5)
	cleanup = 0
	part1Ptr = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(bp + 56)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(bp + 48)) = compiledLocals + uintptr(opnd)*16
	for (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_LINK) != 0 {
		*(*uintptr)(unsafe.Pointer(bp + 48)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
	}
	goto doArrayExists
_128:
	;
	opnd = -int32(1)
	pcAdjustment = int32(1)
	cleanup = int32(1)
	part1Ptr = *(*uintptr)(unsafe.Pointer(tosPtr))
	*(*uintptr)(unsafe.Pointer(bp + 48)) = XTclObjLookupVarEx(tls, interp4, part1Ptr, libc.UintptrFromInt32(0), 0, libc.UintptrFromInt32(0), 0, 0, bp+56)
	goto doArrayExists
doArrayExists:
	;
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	result = XTclCheckArrayTraces(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 48)), *(*uintptr)(unsafe.Pointer(bp + 56)), part1Ptr, opnd)
	checkInterp = int32(1)
	if result == int32(TCL_ERROR) {
		goto gotError
	}
	if *(*uintptr)(unsafe.Pointer(bp + 48)) != 0 && (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_ARRAY) != 0 && !(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) == libc.UintptrFromInt32(0)) {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(constants + 1*8))
	} else {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(constants))
	}
	pc += uintptr(pcAdjustment)
	cleanup = cleanup
	if int32(1) != 0 {
		if int32(1) > 0 {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
		}
		goto cleanupV_pushObjResultPtr
	} else {
		goto cleanupV
	}
_129:
	;
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	pcAdjustment = int32(5)
	cleanup = 0
	part1Ptr = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(bp + 56)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(bp + 48)) = compiledLocals + uintptr(opnd)*16
	for (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_LINK) != 0 {
		*(*uintptr)(unsafe.Pointer(bp + 48)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
	}
	goto doArrayMake
_130:
	;
	opnd = -int32(1)
	pcAdjustment = int32(1)
	cleanup = int32(1)
	part1Ptr = *(*uintptr)(unsafe.Pointer(tosPtr))
	*(*uintptr)(unsafe.Pointer(bp + 48)) = XTclObjLookupVarEx(tls, interp4, part1Ptr, libc.UintptrFromInt32(0), int32(TCL_LEAVE_ERR_MSG), __ccgo_ts+5383, int32(1), 0, bp+56)
	if *(*uintptr)(unsafe.Pointer(bp + 48)) == libc.UintptrFromInt32(0) {
		goto gotError
	}
	goto doArrayMake
doArrayMake:
	;
	if *(*uintptr)(unsafe.Pointer(bp + 48)) != 0 && !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&libc.Int32FromInt32(VAR_ARRAY) != 0) {
		if (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_ARRAY_ELEMENT) != 0 || !(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) == libc.UintptrFromInt32(0)) {
			/*
			 * Either an array element, or a scalar: lose!
			 */
			XTclObjVarErrMsg(tls, interp4, part1Ptr, libc.UintptrFromInt32(0), __ccgo_ts+32269, __ccgo_ts+32279, opnd)
			(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
			XTcl_SetErrorCode(tls, interp4, libc.VaList(bp+544, __ccgo_ts+2004, __ccgo_ts+32300, __ccgo_ts+32306, libc.UintptrFromInt32(0)))
			checkInterp = int32(1)
			goto gotError
		}
		XTclInitArrayVar(tls, *(*uintptr)(unsafe.Pointer(bp + 48)))
	}
	pc += uintptr(pcAdjustment)
	cleanup = cleanup
	if 0 != 0 {
		if 0 > 0 {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
		}
		goto cleanupV_pushObjResultPtr
	} else {
		goto cleanupV
	}
	/*
	 *	   End of INST_ARRAY instructions.
	 * -----------------------------------------------------------------
	 *	   Start of variable linking instructions.
	 */
_131:
	;
	if XTclObjGetFrame(tls, interp4, *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)), bp+184) == -int32(1) {
		goto gotError
	}
	/*
	 * Locate the other variable.
	 */
	savedFramePtr = (*TInterp)(unsafe.Pointer(interp4)).FvarFramePtr
	(*TInterp)(unsafe.Pointer(interp4)).FvarFramePtr = *(*uintptr)(unsafe.Pointer(bp + 184))
	otherPtr = XTclObjLookupVarEx(tls, interp4, *(*uintptr)(unsafe.Pointer(tosPtr)), libc.UintptrFromInt32(0), int32(TCL_LEAVE_ERR_MSG), __ccgo_ts+32162, int32(1), int32(1), bp+48)
	(*TInterp)(unsafe.Pointer(interp4)).FvarFramePtr = savedFramePtr
	if !(otherPtr != 0) {
		goto gotError
	}
	goto doLinkVars
_132:
	;
	if XTclGetNamespaceFromObj(tls, interp4, *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)), bp+192) != TCL_OK {
		goto gotError
	}
	/*
	 * Locate the other variable.
	 */
	savedNsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FvarFramePtr)).FnsPtr
	(*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FvarFramePtr)).FnsPtr = *(*uintptr)(unsafe.Pointer(bp + 192))
	otherPtr = XTclObjLookupVarEx(tls, interp4, *(*uintptr)(unsafe.Pointer(tosPtr)), libc.UintptrFromInt32(0), libc.Int32FromInt32(TCL_NAMESPACE_ONLY)|libc.Int32FromInt32(TCL_LEAVE_ERR_MSG)|libc.Int32FromInt32(TCL_AVOID_RESOLVERS), __ccgo_ts+32162, int32(1), int32(1), bp+48)
	(*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FvarFramePtr)).FnsPtr = savedNsPtr
	if !(otherPtr != 0) {
		goto gotError
	}
	goto doLinkVars
_133:
	;
	otherPtr = XTclObjLookupVarEx(tls, interp4, *(*uintptr)(unsafe.Pointer(tosPtr)), libc.UintptrFromInt32(0), libc.Int32FromInt32(TCL_NAMESPACE_ONLY)|libc.Int32FromInt32(TCL_LEAVE_ERR_MSG), __ccgo_ts+32162, int32(1), int32(1), bp+48)
	if !(otherPtr != 0) {
		goto gotError
	}
	/*
	 * Do the [variable] magic.
	 */
	if !((*TVar)(unsafe.Pointer(otherPtr)).Fflags&libc.Int32FromInt32(VAR_NAMESPACE_VAR) != 0) {
		*(*int32)(unsafe.Pointer(otherPtr)) |= int32(VAR_NAMESPACE_VAR)
		if (*TVar)(unsafe.Pointer(otherPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
			(*TVarInHash)(unsafe.Pointer(otherPtr)).FrefCount++
		}
	}
	goto doLinkVars
doLinkVars:
	;
	/*
	 * If we are here, the local variable has already been created: do the
	 * little work of TclPtrMakeUpvar that remains to be done right here
	 * if there are no errors; otherwise, let it handle the case.
	 */
	opnd = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
	*(*uintptr)(unsafe.Pointer(bp + 48)) = compiledLocals + uintptr(opnd)*16
	if *(*uintptr)(unsafe.Pointer(bp + 48)) != otherPtr && !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&(libc.Int32FromInt32(VAR_TRACED_READ)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_TRACED_ARRAY)|libc.Int32FromInt32(VAR_TRACED_UNSET)) != 0) && (*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) == libc.UintptrFromInt32(0) || (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_LINK) != 0) {
		if !(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) == libc.UintptrFromInt32(0)) {
			/*
			 * Then it is a defined link.
			 */
			linkPtr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
			if linkPtr == otherPtr {
				if false {
					if 0 != 0 {
						if 0 > 0 {
							v470 = *(*uintptr)(unsafe.Pointer(bp + 8))
							tosPtr += 8
							v471 = tosPtr
							*(*uintptr)(unsafe.Pointer(v471)) = v470
							(*TTcl_Obj)(unsafe.Pointer(v470)).FrefCount++
						} else {
							tosPtr += 8
							v472 = tosPtr
							*(*uintptr)(unsafe.Pointer(v472)) = *(*uintptr)(unsafe.Pointer(bp + 8))
						}
					}
					pc += uintptr(libc.Int32FromInt32(5))
					goto cleanup0
				} else {
					if 0 != 0 {
						if 0 > 0 {
							(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
						}
						pc += uintptr(libc.Int32FromInt32(5))
						switch libc.Int32FromInt32(1) {
						case int32(1):
							goto cleanup1_pushObjResultPtr
						case int32(2):
							goto cleanup2_pushObjResultPtr
						case 0:
							break
						}
					} else {
						pc += uintptr(libc.Int32FromInt32(5))
						switch libc.Int32FromInt32(1) {
						case int32(1):
							goto cleanup1
						case int32(2):
							goto cleanup2
						case 0:
							break
						}
					}
				}
				goto _469
			_469:
				;
				goto _468
			_468: /**/ //
			}
			if (*TVar)(unsafe.Pointer(linkPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
				(*TVarInHash)(unsafe.Pointer(linkPtr)).FrefCount--
				if *(*uintptr)(unsafe.Pointer(linkPtr + 8)) == libc.UintptrFromInt32(0) {
					XTclCleanupVar(tls, linkPtr, libc.UintptrFromInt32(0))
				}
			}
		}
		(*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags = (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags & ^libc.Int32FromInt32(VAR_ARRAY) | int32(VAR_LINK)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) = otherPtr
		if (*TVar)(unsafe.Pointer(otherPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
			(*TVarInHash)(unsafe.Pointer(otherPtr)).FrefCount++
		}
	} else {
		if XTclPtrObjMakeUpvarIdx(tls, interp4, otherPtr, libc.UintptrFromInt32(0), 0, opnd) != TCL_OK {
			goto gotError
		}
	}
	/*
	 * Do not pop the namespace or frame index, it may be needed for other
	 * variables - and [variable] did not push it at all.
	 */
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v475 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v476 = tosPtr
				*(*uintptr)(unsafe.Pointer(v476)) = v475
				(*TTcl_Obj)(unsafe.Pointer(v475)).FrefCount++
			} else {
				tosPtr += 8
				v477 = tosPtr
				*(*uintptr)(unsafe.Pointer(v477)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(5))
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(5))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(5))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _474
_474:
	;
	goto _473
_473: /**/
	; //
	goto _243
	/*
	 *	   End of variable linking instructions.
	 * -----------------------------------------------------------------
	 */
_134:
	;
	opnd = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
	if true {
		if 0 != 0 {
			if 0 > 0 {
				v480 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v481 = tosPtr
				*(*uintptr)(unsafe.Pointer(v481)) = v480
				(*TTcl_Obj)(unsafe.Pointer(v480)).FrefCount++
			} else {
				tosPtr += 8
				v482 = tosPtr
				*(*uintptr)(unsafe.Pointer(v482)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(opnd)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(opnd)
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(opnd)
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _479
_479:
	;
	goto _478
_478: /**/
	; //
	goto _243
_135:
	;
	opnd = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
	if true {
		if 0 != 0 {
			if 0 > 0 {
				v485 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v486 = tosPtr
				*(*uintptr)(unsafe.Pointer(v486)) = v485
				(*TTcl_Obj)(unsafe.Pointer(v485)).FrefCount++
			} else {
				tosPtr += 8
				v487 = tosPtr
				*(*uintptr)(unsafe.Pointer(v487)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(opnd)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(opnd)
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(opnd)
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _484
_484:
	;
	goto _483
_483: /**/
	; //
	/* TODO: consider rewrite so we don't compute the offset we're not
	 * going to take. */
_136:
	;
	jmpOffset[0] = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))) /* FALSE offset */
	jmpOffset[int32(1)] = int32(5)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /* TRUE offset */
	goto doCondJump
_137:
	;
	jmpOffset[0] = int32(5)
	jmpOffset[int32(1)] = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
	goto doCondJump
_138:
	;
	jmpOffset[0] = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
	jmpOffset[int32(1)] = int32(2)
	goto doCondJump
_139:
	;
	jmpOffset[0] = int32(2)
	jmpOffset[int32(1)] = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
	goto doCondJump
doCondJump:
	;
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr))
	/* TODO - check claim that taking address of b harms performance */
	/* TODO - consider optimization search for constants */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) || (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr == uintptr(unsafe.Pointer(&XtclBooleanType)) {
		*(*int32)(unsafe.Pointer(bp + 200)) = libc.BoolInt32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FinternalRep)) != 0)
		v488 = libc.Int32FromInt32(TCL_OK)
	} else {
		v488 = XTcl_GetBoolFromObj(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 16)), (libc.Int32FromInt32(TCL_NULL_OK)-libc.Int32FromInt32(2))&libc.Int32FromInt64(4), bp+200)
	}
	if v488 != TCL_OK {
		goto gotError
	}
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v491 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v492 = tosPtr
				*(*uintptr)(unsafe.Pointer(v492)) = v491
				(*TTcl_Obj)(unsafe.Pointer(v491)).FrefCount++
			} else {
				tosPtr += 8
				v493 = tosPtr
				*(*uintptr)(unsafe.Pointer(v493)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(jmpOffset[*(*int32)(unsafe.Pointer(bp + 200))])
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(jmpOffset[*(*int32)(unsafe.Pointer(bp + 200))])
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(jmpOffset[*(*int32)(unsafe.Pointer(bp + 200))])
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _490
_490:
	;
	goto _489
_489: /**/
	; //
	goto _243
_140:
	;
	/*
	 * Jump to location looked up in a hashtable; fall through to next
	 * instr if lookup fails.
	 */
	opnd = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
	jtPtr = (*(*TAuxData)(unsafe.Pointer((*TByteCode)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)).FauxDataArrayPtr + uintptr(opnd)*16))).FclientData
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Fbytes != 0 {
		v494 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Fbytes
	} else {
		v494 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(tosPtr)), libc.UintptrFromInt32(0))
	}
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(jtPtr)).FfindProc})))(tls, jtPtr, v494)
	if hPtr != libc.UintptrFromInt32(0) {
		jumpOffset = int32(int64((*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData))
		if false {
			if 0 != 0 {
				if 0 > 0 {
					v497 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v498 = tosPtr
					*(*uintptr)(unsafe.Pointer(v498)) = v497
					(*TTcl_Obj)(unsafe.Pointer(v497)).FrefCount++
				} else {
					tosPtr += 8
					v499 = tosPtr
					*(*uintptr)(unsafe.Pointer(v499)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(jumpOffset)
			goto cleanup0
		} else {
			if 0 != 0 {
				if 0 > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(jumpOffset)
				switch libc.Int32FromInt32(1) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(jumpOffset)
				switch libc.Int32FromInt32(1) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _496
	_496:
		;
		goto _495
	_495: /**/ //
	} else {
		if false {
			if 0 != 0 {
				if 0 > 0 {
					v502 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v503 = tosPtr
					*(*uintptr)(unsafe.Pointer(v503)) = v502
					(*TTcl_Obj)(unsafe.Pointer(v502)).FrefCount++
				} else {
					tosPtr += 8
					v504 = tosPtr
					*(*uintptr)(unsafe.Pointer(v504)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(5))
			goto cleanup0
		} else {
			if 0 != 0 {
				if 0 > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(5))
				switch libc.Int32FromInt32(1) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(5))
				switch libc.Int32FromInt32(1) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _501
	_501:
		;
		goto _500
	_500: /**/ //
	}
	goto _243
	/*
	 * -----------------------------------------------------------------
	 *	   Start of general introspector instructions.
	 */
_141:
	;
	*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclNewNamespaceObj(tls, (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FvarFramePtr)).FnsPtr)
	if true {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v507 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v508 = tosPtr
				*(*uintptr)(unsafe.Pointer(v508)) = v507
				(*TTcl_Obj)(unsafe.Pointer(v507)).FrefCount++
			} else {
				tosPtr += 8
				v509 = tosPtr
				*(*uintptr)(unsafe.Pointer(v509)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _506
_506:
	;
	goto _505
_505: /**/
	; //
	goto _243
_142:
	;
	corPtr1 = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FcorPtr
	if v510 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v510 {
		cachePtr34 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v510 || (*TAllocCache)(unsafe.Pointer(cachePtr34)).FnumObjects == libc.Uint64FromInt32(0) {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
	} else {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr34)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr34)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr34)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = libc.UintptrFromInt32(0)
	if corPtr1 != 0 && !((*TCommand1)(unsafe.Pointer((*TCoroutineData)(unsafe.Pointer(corPtr1)).FcmdPtr)).Fflags&libc.Int32FromInt32(CMD_DYING) != 0) {
		XTcl_GetCommandFullName(tls, interp4, (*TCoroutineData)(unsafe.Pointer(corPtr1)).FcmdPtr, *(*uintptr)(unsafe.Pointer(bp + 8)))
	}
	if true {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v513 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v514 = tosPtr
				*(*uintptr)(unsafe.Pointer(v514)) = v513
				(*TTcl_Obj)(unsafe.Pointer(v513)).FrefCount++
			} else {
				tosPtr += 8
				v515 = tosPtr
				*(*uintptr)(unsafe.Pointer(v515)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _512
_512:
	;
	goto _511
_511: /**/
	; //
	goto _243
_143:
	;
	if v516 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v516 {
		cachePtr35 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v516 || (*TAllocCache)(unsafe.Pointer(cachePtr35)).FnumObjects == libc.Uint64FromInt32(0) {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
	} else {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr35)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr35)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr35)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = libc.UintptrFromInt32(0)
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FinternalRep)) = int64(int32((*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FvarFramePtr)).Flevel))
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	if true {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v519 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v520 = tosPtr
				*(*uintptr)(unsafe.Pointer(v520)) = v519
				(*TTcl_Obj)(unsafe.Pointer(v519)).FrefCount++
			} else {
				tosPtr += 8
				v521 = tosPtr
				*(*uintptr)(unsafe.Pointer(v521)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _518
_518:
	;
	goto _517
_517: /**/
	; //
	goto _243
_144:
	;
	framePtr1 = (*TInterp)(unsafe.Pointer(interp4)).FvarFramePtr
	rootFramePtr = (*TInterp)(unsafe.Pointer(interp4)).FrootFramePtr
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
		*(*int32)(unsafe.Pointer(bp + 204)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FinternalRep)))
		v522 = libc.Int32FromInt32(TCL_OK)
	} else {
		v522 = XTcl_GetIntFromObj(tls, interp4, *(*uintptr)(unsafe.Pointer(tosPtr)), bp+204)
	}
	if v522 != TCL_OK {
		goto gotError
	}
	if *(*int32)(unsafe.Pointer(bp + 204)) <= 0 {
		*(*int32)(unsafe.Pointer(bp + 204)) = int32(int64(*(*int32)(unsafe.Pointer(bp + 204))) + (*TCallFrame)(unsafe.Pointer(framePtr1)).Flevel)
	}
	for {
		if !(int32((*TCallFrame)(unsafe.Pointer(framePtr1)).Flevel) != *(*int32)(unsafe.Pointer(bp + 204)) && framePtr1 != rootFramePtr) {
			break
		}
		/* Empty loop body */
		goto _523
	_523:
		;
		framePtr1 = (*TCallFrame)(unsafe.Pointer(framePtr1)).FcallerVarPtr
	}
	if framePtr1 == rootFramePtr {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Fbytes != 0 {
			v524 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Fbytes
		} else {
			v524 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(tosPtr)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp4, XTcl_ObjPrintf(tls, __ccgo_ts+16556, libc.VaList(bp+544, v524)))
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Fbytes != 0 {
			v525 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Fbytes
		} else {
			v525 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(tosPtr)), libc.UintptrFromInt32(0))
		}
		XTcl_SetErrorCode(tls, interp4, libc.VaList(bp+544, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+32312, v525, libc.UintptrFromInt32(0)))
		checkInterp = int32(1)
		goto gotError
	}
	*(*uintptr)(unsafe.Pointer(bp + 8)) = XTcl_NewListObj(tls, (*TCallFrame)(unsafe.Pointer(framePtr1)).Fobjc, (*TCallFrame)(unsafe.Pointer(framePtr1)).Fobjv)
	if false {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v528 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v529 = tosPtr
				*(*uintptr)(unsafe.Pointer(v529)) = v528
				(*TTcl_Obj)(unsafe.Pointer(v528)).FrefCount++
			} else {
				tosPtr += 8
				v530 = tosPtr
				*(*uintptr)(unsafe.Pointer(v530)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _527
_527:
	;
	goto _526
_526: /**/
	; //
_145:
	;
	cmd = XTcl_GetCommandFromObj(tls, interp4, *(*uintptr)(unsafe.Pointer(tosPtr)))
	if v531 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v531 {
		cachePtr36 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v531 || (*TAllocCache)(unsafe.Pointer(cachePtr36)).FnumObjects == libc.Uint64FromInt32(0) {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
	} else {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr36)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr36)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr36)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = libc.UintptrFromInt32(0)
	if cmd != libc.UintptrFromInt32(0) {
		XTcl_GetCommandFullName(tls, interp4, cmd, *(*uintptr)(unsafe.Pointer(bp + 8)))
	}
	if false {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v534 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v535 = tosPtr
				*(*uintptr)(unsafe.Pointer(v535)) = v534
				(*TTcl_Obj)(unsafe.Pointer(v534)).FrefCount++
			} else {
				tosPtr += 8
				v536 = tosPtr
				*(*uintptr)(unsafe.Pointer(v536)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _533
_533:
	;
	goto _532
_532: /**/
	; //
_146:
	;
	cmd = XTcl_GetCommandFromObj(tls, interp4, *(*uintptr)(unsafe.Pointer(tosPtr)))
	if cmd == libc.UintptrFromInt32(0) {
		goto instOriginError
	}
	origCmd = XTclGetOriginalCommand(tls, cmd)
	if origCmd == libc.UintptrFromInt32(0) {
		origCmd = cmd
	}
	if v537 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v537 {
		cachePtr37 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v537 || (*TAllocCache)(unsafe.Pointer(cachePtr37)).FnumObjects == libc.Uint64FromInt32(0) {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
	} else {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr37)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr37)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr37)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = libc.UintptrFromInt32(0)
	XTcl_GetCommandFullName(tls, interp4, origCmd, *(*uintptr)(unsafe.Pointer(bp + 8)))
	if !(XTclCheckEmptyString(tls, *(*uintptr)(unsafe.Pointer(bp + 8))) == int32(TCL_EMPTYSTRING_YES)) {
		goto _538
	}
	_objPtr26 = *(*uintptr)(unsafe.Pointer(bp + 8))
	v540 = _objPtr26
	v539 = *(*TTcl_Size)(unsafe.Pointer(v540))
	*(*TTcl_Size)(unsafe.Pointer(v540))--
	if v539 <= int64(1) {
		XTclFreeObj(tls, _objPtr26)
	}
	goto instOriginError
instOriginError:
	;
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Fbytes != 0 {
		v541 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Fbytes
	} else {
		v541 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(tosPtr)), libc.UintptrFromInt32(0))
	}
	XTcl_SetObjResult(tls, interp4, XTcl_ObjPrintf(tls, __ccgo_ts+8511, libc.VaList(bp+544, v541)))
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Fbytes != 0 {
		v542 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Fbytes
	} else {
		v542 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(tosPtr)), libc.UintptrFromInt32(0))
	}
	XTcl_SetErrorCode(tls, interp4, libc.VaList(bp+544, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+8118, v542, libc.UintptrFromInt32(0)))
	checkInterp = int32(1)
	goto gotError
_538:
	;
	if false {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v545 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v546 = tosPtr
				*(*uintptr)(unsafe.Pointer(v546)) = v545
				(*TTcl_Obj)(unsafe.Pointer(v545)).FrefCount++
			} else {
				tosPtr += 8
				v547 = tosPtr
				*(*uintptr)(unsafe.Pointer(v547)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _544
_544:
	;
	goto _543
_543: /**/
	; //
	/*
	 * -----------------------------------------------------------------
	 *	   Start of TclOO support instructions.
	 */
_147:
	;
	framePtr2 = (*TInterp)(unsafe.Pointer(interp4)).FvarFramePtr
	if framePtr2 == libc.UintptrFromInt32(0) || !((*TCallFrame)(unsafe.Pointer(framePtr2)).FisProcCallFrame&libc.Int32FromInt32(FRAME_IS_METHOD) != 0) {
		XTcl_SetObjResult(tls, interp4, XTcl_NewStringObj(tls, __ccgo_ts+32324, int64(-int32(1))))
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		XTcl_SetErrorCode(tls, interp4, libc.VaList(bp+544, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+32372, libc.UintptrFromInt32(0)))
		checkInterp = int32(1)
		goto gotError
	}
	contextPtr = (*TCallFrame)(unsafe.Pointer(framePtr2)).FclientData
	/*
	 * Call out to get the name; it's expensive to compute but cached.
	 */
	*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclOOObjectName(tls, interp4, (*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr)
	if true {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v550 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v551 = tosPtr
				*(*uintptr)(unsafe.Pointer(v551)) = v550
				(*TTcl_Obj)(unsafe.Pointer(v550)).FrefCount++
			} else {
				tosPtr += 8
				v552 = tosPtr
				*(*uintptr)(unsafe.Pointer(v552)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _549
_549:
	;
	goto _548
_548: /**/
	; //
_148:
	;
	opnd = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1)))))
	framePtr2 = (*TInterp)(unsafe.Pointer(interp4)).FvarFramePtr
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-(opnd-libc.Int32FromInt32(2)))*8))
	*(*uintptr)(unsafe.Pointer(bp + 24)) = tosPtr + uintptr(-(opnd-libc.Int32FromInt32(1)))*8
	skip = int64(2)
	if framePtr2 == libc.UintptrFromInt32(0) || !((*TCallFrame)(unsafe.Pointer(framePtr2)).FisProcCallFrame&libc.Int32FromInt32(FRAME_IS_METHOD) != 0) {
		XTcl_SetObjResult(tls, interp4, XTcl_NewStringObj(tls, __ccgo_ts+32389, int64(-int32(1))))
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		XTcl_SetErrorCode(tls, interp4, libc.VaList(bp+544, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+32372, libc.UintptrFromInt32(0)))
		checkInterp = int32(1)
		goto gotError
	}
	contextPtr = (*TCallFrame)(unsafe.Pointer(framePtr2)).FclientData
	oPtr = XTcl_GetObjectFromObj(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 16)))
	if oPtr == libc.UintptrFromInt32(0) {
		goto gotError
	} else {
		classPtr = (*TObject)(unsafe.Pointer(oPtr)).FclassPtr
		if classPtr == libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 {
				v553 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes
			} else {
				v553 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp4, XTcl_ObjPrintf(tls, __ccgo_ts+28620, libc.VaList(bp+544, v553)))
			(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
			XTcl_SetErrorCode(tls, interp4, libc.VaList(bp+544, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+32436, libc.UintptrFromInt32(0)))
			checkInterp = int32(1)
			goto gotError
		}
		i1 = (*TCallContext)(unsafe.Pointer(contextPtr)).Findex + int64(1)
		for {
			if !(i1 < (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).FnumChain) {
				break
			}
			miPtr = (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr(i1)*24
			if !((*TMInvoke1)(unsafe.Pointer(miPtr)).FisFilter != 0) && (*TMethod)(unsafe.Pointer((*TMInvoke1)(unsafe.Pointer(miPtr)).FmPtr)).FdeclaringClassPtr == classPtr {
				newDepth = i1
				goto doInvokeNext
			}
			goto _554
		_554:
			;
			i1++
		}
		if (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fflags&int32(CONSTRUCTOR) != 0 {
			methodType = __ccgo_ts + 28529
		} else {
			if (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fflags&int32(DESTRUCTOR) != 0 {
				methodType = __ccgo_ts + 28541
			} else {
				methodType = __ccgo_ts + 28559
			}
		}
		i1 = (*TCallContext)(unsafe.Pointer(contextPtr)).Findex
		for {
			if !(i1 != int64(-libc.Int32FromInt32(1))) {
				break
			}
			miPtr = (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr(i1)*24
			if (*TMInvoke1)(unsafe.Pointer(miPtr)).FisFilter != 0 || (*TMethod)(unsafe.Pointer((*TMInvoke1)(unsafe.Pointer(miPtr)).FmPtr)).FdeclaringClassPtr != classPtr {
				goto _555
			}
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 {
				v556 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes
			} else {
				v556 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp4, XTcl_ObjPrintf(tls, __ccgo_ts+32451, libc.VaList(bp+544, methodType, v556)))
			(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
			XTcl_SetErrorCode(tls, interp4, libc.VaList(bp+544, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+32501, libc.UintptrFromInt32(0)))
			checkInterp = int32(1)
			goto gotError
			goto _555
		_555:
			;
			i1--
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 {
			v557 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes
		} else {
			v557 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp4, XTcl_ObjPrintf(tls, __ccgo_ts+32521, libc.VaList(bp+544, methodType, v557)))
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		XTcl_SetErrorCode(tls, interp4, libc.VaList(bp+544, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+32565, libc.UintptrFromInt32(0)))
		checkInterp = int32(1)
		goto gotError
	}
_149:
	;
	opnd = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1)))))
	*(*uintptr)(unsafe.Pointer(bp + 24)) = tosPtr + uintptr(-(opnd-libc.Int32FromInt32(1)))*8
	framePtr2 = (*TInterp)(unsafe.Pointer(interp4)).FvarFramePtr
	skip = int64(1)
	if framePtr2 == libc.UintptrFromInt32(0) || !((*TCallFrame)(unsafe.Pointer(framePtr2)).FisProcCallFrame&libc.Int32FromInt32(FRAME_IS_METHOD) != 0) {
		XTcl_SetObjResult(tls, interp4, XTcl_NewStringObj(tls, __ccgo_ts+32581, int64(-int32(1))))
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		XTcl_SetErrorCode(tls, interp4, libc.VaList(bp+544, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+32372, libc.UintptrFromInt32(0)))
		checkInterp = int32(1)
		goto gotError
	}
	contextPtr = (*TCallFrame)(unsafe.Pointer(framePtr2)).FclientData
	newDepth = (*TCallContext)(unsafe.Pointer(contextPtr)).Findex + int64(1)
	if newDepth >= (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).FnumChain {
		if (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fflags&int32(CONSTRUCTOR) != 0 {
			methodType1 = __ccgo_ts + 28529
		} else {
			if (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fflags&int32(DESTRUCTOR) != 0 {
				methodType1 = __ccgo_ts + 28541
			} else {
				methodType1 = __ccgo_ts + 28559
			}
		}
		XTcl_SetObjResult(tls, interp4, XTcl_ObjPrintf(tls, __ccgo_ts+32626, libc.VaList(bp+544, methodType1)))
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		XTcl_SetErrorCode(tls, interp4, libc.VaList(bp+544, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+32652, libc.UintptrFromInt32(0)))
		checkInterp = int32(1)
		goto gotError
	}
	goto doInvokeNext
doInvokeNext:
	;
	(*(*struct {
		FcodePtr uintptr
		Fpc      uintptr
	})(unsafe.Pointer(TD + 24 + 40))).Fpc = pc
	(*TInterp)(unsafe.Pointer(interp4)).FcmdFramePtr = TD + 24
	if (*TInterp)(unsafe.Pointer(interp4)).Fflags&int32(INTERP_DEBUG_FRAME) != 0 {
		_ArgumentBCEnter(tls, interp4, (*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr, TD, pc, int64(opnd), *(*uintptr)(unsafe.Pointer(bp + 24)))
	}
	pcAdjustment = int32(2)
	cleanup = opnd
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	(*TInterp)(unsafe.Pointer(interp4)).FvarFramePtr = (*TCallFrame)(unsafe.Pointer(framePtr2)).FcallerVarPtr
	pc += uintptr(pcAdjustment)
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	if v558 = interp4 == libc.UintptrFromInt32(0); !v558 {
		cachePtr38 = (*TInterp)(unsafe.Pointer(interp4)).FallocCache
	}
	if v558 || (*TAllocCache)(unsafe.Pointer(cachePtr38)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr27 = XTclThreadAllocObj(tls)
	} else {
		_objPtr27 = (*TAllocCache)(unsafe.Pointer(cachePtr38)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr38)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr27 + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr38)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 208)) = _objPtr27
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 208)))).FprocPtr = __ccgo_fp(_TEBCresume)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 208)) + 8)) = TD
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 208)) + 8 + 1*8)) = pc
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 208)) + 8 + 2*8)) = uintptr(int64(cleanup))
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 208)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 208)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 208))
	XTclPushTailcallPoint(tls, interp4)
	oPtr = (*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr
	if (*TObject)(unsafe.Pointer(oPtr)).Fflags&int32(FILTER_HANDLING) != 0 {
		if v559 = interp4 == libc.UintptrFromInt32(0); !v559 {
			cachePtr39 = (*TInterp)(unsafe.Pointer(interp4)).FallocCache
		}
		if v559 || (*TAllocCache)(unsafe.Pointer(cachePtr39)).FnumObjects == libc.Uint64FromInt32(0) {
			_objPtr28 = XTclThreadAllocObj(tls)
		} else {
			_objPtr28 = (*TAllocCache)(unsafe.Pointer(cachePtr39)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr39)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(_objPtr28 + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr39)).FnumObjects--
		}
		*(*uintptr)(unsafe.Pointer(bp + 216)) = _objPtr28
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 216)))).FprocPtr = __ccgo_fp(_FinalizeOONextFilter)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 216)) + 8)) = framePtr2
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 216)) + 8 + 1*8)) = contextPtr
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 216)) + 8 + 2*8)) = uintptr((*TCallContext)(unsafe.Pointer(contextPtr)).Findex)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 216)) + 8 + 3*8)) = uintptr((*TCallContext)(unsafe.Pointer(contextPtr)).Fskip)
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 216)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FcallbackPtr
		(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 216))
	} else {
		if v560 = interp4 == libc.UintptrFromInt32(0); !v560 {
			cachePtr40 = (*TInterp)(unsafe.Pointer(interp4)).FallocCache
		}
		if v560 || (*TAllocCache)(unsafe.Pointer(cachePtr40)).FnumObjects == libc.Uint64FromInt32(0) {
			_objPtr29 = XTclThreadAllocObj(tls)
		} else {
			_objPtr29 = (*TAllocCache)(unsafe.Pointer(cachePtr40)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr40)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(_objPtr29 + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr40)).FnumObjects--
		}
		*(*uintptr)(unsafe.Pointer(bp + 224)) = _objPtr29
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 224)))).FprocPtr = __ccgo_fp(_FinalizeOONext)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 224)) + 8)) = framePtr2
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 224)) + 8 + 1*8)) = contextPtr
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 224)) + 8 + 2*8)) = uintptr((*TCallContext)(unsafe.Pointer(contextPtr)).Findex)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 224)) + 8 + 3*8)) = uintptr((*TCallContext)(unsafe.Pointer(contextPtr)).Fskip)
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 224)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FcallbackPtr
		(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 224))
	}
	(*TCallContext)(unsafe.Pointer(contextPtr)).Fskip = skip
	(*TCallContext)(unsafe.Pointer(contextPtr)).Findex = newDepth
	if (*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr(newDepth)*24))).FisFilter != 0 || (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fflags&int32(FILTER_HANDLING) != 0 {
		*(*int32)(unsafe.Pointer(oPtr + 96)) |= int32(FILTER_HANDLING)
	} else {
		*(*int32)(unsafe.Pointer(oPtr + 96)) &= ^int32(FILTER_HANDLING)
	}
	mPtr = (*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr(newDepth)*24))).FmPtr
	if (*TTcl_MethodType)(unsafe.Pointer((*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr)).Fversion < int32(TCL_OO_METHOD_VERSION_2) {
		return (*(*func(*libc.TLS, uintptr, uintptr, TTcl_ObjectContext, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_MethodType)(unsafe.Pointer((*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr)).FcallProc})))(tls, (*TMethod)(unsafe.Pointer(mPtr)).FclientData, interp4, contextPtr, opnd, *(*uintptr)(unsafe.Pointer(bp + 24)))
	}
	return (*(*func(*libc.TLS, uintptr, uintptr, TTcl_ObjectContext, TTcl_Size, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_MethodType)(unsafe.Pointer((*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr)).FcallProc})))(tls, (*TMethod)(unsafe.Pointer(mPtr)).FclientData, interp4, contextPtr, int64(opnd), *(*uintptr)(unsafe.Pointer(bp + 24)))
_150:
	;
	oPtr = XTcl_GetObjectFromObj(tls, interp4, *(*uintptr)(unsafe.Pointer(tosPtr)))
	if oPtr != libc.UintptrFromInt32(0) {
		v561 = int32(1)
	} else {
		v561 = 0
	}
	*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(constants + uintptr(v561)*8))
	if false {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v564 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v565 = tosPtr
				*(*uintptr)(unsafe.Pointer(v565)) = v564
				(*TTcl_Obj)(unsafe.Pointer(v564)).FrefCount++
			} else {
				tosPtr += 8
				v566 = tosPtr
				*(*uintptr)(unsafe.Pointer(v566)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _563
_563:
	;
	goto _562
_562: /**/
	; //
_151:
	;
	oPtr = XTcl_GetObjectFromObj(tls, interp4, *(*uintptr)(unsafe.Pointer(tosPtr)))
	if oPtr == libc.UintptrFromInt32(0) {
		goto gotError
	}
	*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclOOObjectName(tls, interp4, (*TClass)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FselfCls)).FthisPtr)
	if false {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v569 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v570 = tosPtr
				*(*uintptr)(unsafe.Pointer(v570)) = v569
				(*TTcl_Obj)(unsafe.Pointer(v569)).FrefCount++
			} else {
				tosPtr += 8
				v571 = tosPtr
				*(*uintptr)(unsafe.Pointer(v571)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _568
_568:
	;
	goto _567
_567: /**/
	; //
_152:
	;
	oPtr = XTcl_GetObjectFromObj(tls, interp4, *(*uintptr)(unsafe.Pointer(tosPtr)))
	if oPtr == libc.UintptrFromInt32(0) {
		goto gotError
	}
	*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclNewNamespaceObj(tls, (*TObject)(unsafe.Pointer(oPtr)).FnamespacePtr)
	if false {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v574 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v575 = tosPtr
				*(*uintptr)(unsafe.Pointer(v575)) = v574
				(*TTcl_Obj)(unsafe.Pointer(v574)).FrefCount++
			} else {
				tosPtr += 8
				v576 = tosPtr
				*(*uintptr)(unsafe.Pointer(v576)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _573
_573:
	;
	goto _572
_572: /**/
	; //
	/*
	 *	   End of TclOO support instructions.
	 * -----------------------------------------------------------------
	 *	   Start of INST_LIST and related instructions.
	 */
_153:
	;
	/*
	 * Pop the opnd (objc) top stack elements into a new list obj and then
	 * decrement their ref counts.
	 */
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	*(*uintptr)(unsafe.Pointer(bp + 8)) = XTcl_NewListObj(tls, int64(opnd), tosPtr+uintptr(-(opnd-libc.Int32FromInt32(1)))*8)
	pc += uintptr(libc.Int32FromInt32(5))
	cleanup = opnd
	if int32(1) != 0 {
		if int32(1) > 0 {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
		}
		goto cleanupV_pushObjResultPtr
	} else {
		goto cleanupV
	}
_154:
	;
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)) + 32))).Fptr2 != 0 {
			v578 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)) + 32))).Fptr2)).FspanLength
		} else {
			v578 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = v578
		v577 = libc.Int32FromInt32(TCL_OK)
	} else {
		v577 = XTcl_ListObjLength(tls, interp4, *(*uintptr)(unsafe.Pointer(tosPtr)), bp+32)
	}
	if v577 != TCL_OK {
		goto gotError
	}
	if v579 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v579 {
		cachePtr41 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v579 || (*TAllocCache)(unsafe.Pointer(cachePtr41)).FnumObjects == libc.Uint64FromInt32(0) {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
	} else {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr41)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr41)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr41)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = libc.UintptrFromInt32(0)
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FinternalRep)) = *(*TTcl_Size)(unsafe.Pointer(bp + 32))
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	if false {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v582 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v583 = tosPtr
				*(*uintptr)(unsafe.Pointer(v583)) = v582
				(*TTcl_Obj)(unsafe.Pointer(v582)).FrefCount++
			} else {
				tosPtr += 8
				v584 = tosPtr
				*(*uintptr)(unsafe.Pointer(v584)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _581
_581:
	;
	goto _580
_580: /**/
	; //
_155:
	; /* lindex with objc == 3 */
	value2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr))
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8))
	/* special case for AbstractList */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+56) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+56) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr)).Fversion) {
		v585 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr)).FindexProc
	} else {
		v585 = libc.UintptrFromInt32(0)
	}
	if v585 != 0 {
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		v586 = *(*uintptr)(unsafe.Pointer(bp + 16))
		if (*TTcl_Obj)(unsafe.Pointer(v586)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+48) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+48) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v586)).FtypePtr)).Fversion) {
			v587 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v586)).FtypePtr)).FlengthProc
		} else {
			v587 = libc.UintptrFromInt32(0)
		}
		proc = v587
		v588 = (*(*func(*libc.TLS, uintptr) TTcl_Size)(unsafe.Pointer(&struct{ uintptr }{proc})))(tls, v586)
		goto _589
	_589:
		*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = v588
		if (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FinternalRep)) <= *(*TTcl_Size)(unsafe.Pointer(bp + 32))-int64(1) {
			*(*TTcl_Size)(unsafe.Pointer(bp + 272)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FinternalRep))
			v590 = libc.Int32FromInt32(TCL_OK)
		} else {
			v590 = XTcl_GetIntForIndex(tls, interp4, value2Ptr, *(*TTcl_Size)(unsafe.Pointer(bp + 32))-libc.Int64FromInt32(1), bp+272)
		}
		if v590 != TCL_OK {
			checkInterp = int32(1)
			goto gotError
		}
		v591 = *(*uintptr)(unsafe.Pointer(bp + 16))
		if (*TTcl_Obj)(unsafe.Pointer(v591)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+56) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+56) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v591)).FtypePtr)).Fversion) {
			v592 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v591)).FtypePtr)).FindexProc
		} else {
			v592 = libc.UintptrFromInt32(0)
		}
		proc1 = v592
		v593 = (*(*func(*libc.TLS, uintptr, uintptr, TTcl_Size, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{proc1})))(tls, interp4, v591, *(*TTcl_Size)(unsafe.Pointer(bp + 272)), bp+8)
		goto _594
	_594:
		if v593 != TCL_OK {
			checkInterp = int32(1)
			goto gotError
		}
		checkInterp = int32(1)
		if *(*uintptr)(unsafe.Pointer(bp + 8)) == libc.UintptrFromInt32(0) {
			/* Index is out of range, return empty result. */
			if v595 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v595 {
				cachePtr42 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v595 || (*TAllocCache)(unsafe.Pointer(cachePtr42)).FnumObjects == libc.Uint64FromInt32(0) {
				*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
			} else {
				*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr42)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr42)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr42)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = libc.UintptrFromInt32(0)
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++ // reference held here
		goto lindexDone
	}
	/*
	 * Extract the desired list element.
	 */
	indexListPtr = value2Ptr
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr2 != 0 {
			v597 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr2)).FspanStart
		} else {
			v597 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 24)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1 + 40 + uintptr(v597)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr2 != 0 {
			v598 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr2)).FspanLength
		} else {
			v598 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = v598
		v596 = libc.Int32FromInt32(TCL_OK)
	} else {
		v596 = XTcl_ListObjGetElements(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 16)), bp+40, bp+24)
	}
	if v601 = v596 == TCL_OK; v601 {
		if v600 = !((*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType))); !v600 {
			XTcl_ListObjLength(tls, interp4, value2Ptr, bp+296)
			if *(*TTcl_Size)(unsafe.Pointer(bp + 296)) == int64(1) {
				indexListPtr = XTclListObjGetElement(tls, value2Ptr, 0)
				v599 = libc.Int32FromInt32(1)
			} else {
				v599 = 0
			}
		}
	}
	if v601 && (v600 || v599 != 0) {
		/* increment the refCount of value2Ptr because TclListObjGetElement may
		 * have just extracted it from a list in the condition for this block.
		 */
		(*TTcl_Obj)(unsafe.Pointer(indexListPtr)).FrefCount++
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		if (*TTcl_Obj)(unsafe.Pointer(indexListPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(indexListPtr)).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(indexListPtr)).FinternalRep)) <= *(*TTcl_Size)(unsafe.Pointer(bp + 40))-int64(1) {
			*(*TTcl_Size)(unsafe.Pointer(bp + 272)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(indexListPtr)).FinternalRep))
			v602 = libc.Int32FromInt32(TCL_OK)
		} else {
			v602 = XTcl_GetIntForIndex(tls, interp4, indexListPtr, *(*TTcl_Size)(unsafe.Pointer(bp + 40))-libc.Int64FromInt32(1), bp+272)
		}
		code1 = v602
		v604 = indexListPtr
		v603 = *(*TTcl_Size)(unsafe.Pointer(v604))
		*(*TTcl_Size)(unsafe.Pointer(v604))--
		if !(v603 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(indexListPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(indexListPtr)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(indexListPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(indexListPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(indexListPtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(indexListPtr)).Flength = int64(-libc.Int32FromInt32(1))
				if v605 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v605 {
					cachePtr43 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v605 || ((*TAllocCache)(unsafe.Pointer(cachePtr43)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr43)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, indexListPtr)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(indexListPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr43)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr43)).FfirstObjPtr = indexListPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr43)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, indexListPtr)
			}
		}
		checkInterp = int32(1)
		if code1 == TCL_OK {
			_objPtr30 = value2Ptr
			v607 = _objPtr30
			v606 = *(*TTcl_Size)(unsafe.Pointer(v607))
			*(*TTcl_Size)(unsafe.Pointer(v607))--
			if v606 <= int64(1) {
				XTclFreeObj(tls, _objPtr30)
			}
			tosPtr -= 8
			pcAdjustment = int32(1)
			goto lindexFastPath
		}
		XTcl_ResetResult(tls, interp4)
	}
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclLindexList(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 16)), value2Ptr)
	checkInterp = int32(1)
	goto lindexDone
lindexDone:
	;
	if !(*(*uintptr)(unsafe.Pointer(bp + 8)) != 0) {
		goto gotError
	}
	/*
	 * Stash the list element on the stack.
	 */
	if false {
		if -int32(1) != 0 {
			if -int32(1) > 0 {
				v610 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v611 = tosPtr
				*(*uintptr)(unsafe.Pointer(v611)) = v610
				(*TTcl_Obj)(unsafe.Pointer(v610)).FrefCount++
			} else {
				tosPtr += 8
				v612 = tosPtr
				*(*uintptr)(unsafe.Pointer(v612)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if -int32(1) != 0 {
			if -int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _609
_609:
	;
	goto _608
_608: /**/
	; //
	/* Already has the correct refCount */
_156:
	; /* lindex with objc==3 and index in bytecode
	 * stream */
	/*
	 * Pop the list and get the index.
	 */
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr))
	opnd = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
	/*
	 * Get the contents of the list, making sure that it really is a list
	 * in the process.
	 */
	/* special case for AbstractList */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+56) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+56) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr)).Fversion) {
		v613 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr)).FindexProc
	} else {
		v613 = libc.UintptrFromInt32(0)
	}
	if v613 != 0 {
		v614 = *(*uintptr)(unsafe.Pointer(bp + 16))
		if (*TTcl_Obj)(unsafe.Pointer(v614)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+48) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+48) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v614)).FtypePtr)).Fversion) {
			v615 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v614)).FtypePtr)).FlengthProc
		} else {
			v615 = libc.UintptrFromInt32(0)
		}
		proc = v615
		v616 = (*(*func(*libc.TLS, uintptr) TTcl_Size)(unsafe.Pointer(&struct{ uintptr }{proc})))(tls, v614)
		goto _617
	_617:
		*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = v616
		/* Decode end-offset index values. */
		*(*TTcl_Size)(unsafe.Pointer(bp + 272)) = XTclIndexDecode(tls, opnd, *(*TTcl_Size)(unsafe.Pointer(bp + 32))-int64(1))
		if *(*TTcl_Size)(unsafe.Pointer(bp + 272)) >= 0 && *(*TTcl_Size)(unsafe.Pointer(bp + 272)) < *(*TTcl_Size)(unsafe.Pointer(bp + 32)) {
			/* Compute value @ index */
			(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
			v618 = *(*uintptr)(unsafe.Pointer(bp + 16))
			if (*TTcl_Obj)(unsafe.Pointer(v618)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+56) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+56) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v618)).FtypePtr)).Fversion) {
				v619 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v618)).FtypePtr)).FindexProc
			} else {
				v619 = libc.UintptrFromInt32(0)
			}
			proc1 = v619
			v620 = (*(*func(*libc.TLS, uintptr, uintptr, TTcl_Size, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{proc1})))(tls, interp4, v618, *(*TTcl_Size)(unsafe.Pointer(bp + 272)), bp+8)
			goto _621
		_621:
			if v620 != TCL_OK {
				checkInterp = int32(1)
				goto gotError
			}
			checkInterp = int32(1)
		} else {
			if v622 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v622 {
				cachePtr44 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v622 || (*TAllocCache)(unsafe.Pointer(cachePtr44)).FnumObjects == libc.Uint64FromInt32(0) {
				*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
			} else {
				*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr44)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr44)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr44)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = libc.UintptrFromInt32(0)
		}
		pcAdjustment = int32(5)
		goto lindexFastPath2
	}
	/* List case */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr2 != 0 {
			v624 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr2)).FspanStart
		} else {
			v624 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 24)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1 + 40 + uintptr(v624)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr2 != 0 {
			v625 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr2)).FspanLength
		} else {
			v625 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = v625
		v623 = libc.Int32FromInt32(TCL_OK)
	} else {
		v623 = XTcl_ListObjGetElements(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 16)), bp+40, bp+24)
	}
	if v623 != TCL_OK {
		goto gotError
	}
	/* Decode end-offset index values. */
	*(*TTcl_Size)(unsafe.Pointer(bp + 272)) = XTclIndexDecode(tls, opnd, *(*TTcl_Size)(unsafe.Pointer(bp + 40))-int64(1))
	pcAdjustment = int32(5)
	goto lindexFastPath
lindexFastPath:
	;
	if *(*TTcl_Size)(unsafe.Pointer(bp + 272)) >= 0 && *(*TTcl_Size)(unsafe.Pointer(bp + 272)) < *(*TTcl_Size)(unsafe.Pointer(bp + 40)) {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 272)))*8))
	} else {
		if v626 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v626 {
			cachePtr45 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v626 || (*TAllocCache)(unsafe.Pointer(cachePtr45)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr45)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr45)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr45)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = libc.UintptrFromInt32(0)
	}
	goto lindexFastPath2
lindexFastPath2:
	;
	if false {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v629 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v630 = tosPtr
				*(*uintptr)(unsafe.Pointer(v630)) = v629
				(*TTcl_Obj)(unsafe.Pointer(v629)).FrefCount++
			} else {
				tosPtr += 8
				v631 = tosPtr
				*(*uintptr)(unsafe.Pointer(v631)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(pcAdjustment)
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(pcAdjustment)
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(pcAdjustment)
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _628
_628:
	;
	goto _627
_627: /**/
	; //
_157:
	; /* 'lindex' with multiple index args */
	/*
	 * Determine the count of index args.
	 */
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	numIndices = opnd - int32(1)
	/*
	 * Do the 'lindex' operation.
	 */
	*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclLindexFlat(tls, interp4, *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-numIndices)*8)), int64(numIndices), tosPtr+uintptr(-(numIndices-libc.Int32FromInt32(1)))*8)
	if !(*(*uintptr)(unsafe.Pointer(bp + 8)) != 0) {
		goto gotError
	}
	/*
	 * Set result.
	 */
	pc += uintptr(libc.Int32FromInt32(5))
	cleanup = opnd
	if -int32(1) != 0 {
		if -int32(1) > 0 {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
		}
		goto cleanupV_pushObjResultPtr
	} else {
		goto cleanupV
	}
_158:
	;
	/*
	 * Lset with 3, 5, or more args. Get the number of index args.
	 */
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	numIndices = opnd - int32(2)
	/*
	 * Get the old value of variable, and remove the stack ref. This is
	 * safe because the variable still references the object; the ref
	 * count will never go zero here - we can use the smaller macro
	 * Tcl_DecrRefCount.
	 */
	v632 = tosPtr
	tosPtr -= 8
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(v632))
	_objPtr31 = *(*uintptr)(unsafe.Pointer(bp + 16))
	v634 = _objPtr31
	v633 = *(*TTcl_Size)(unsafe.Pointer(v634))
	*(*TTcl_Size)(unsafe.Pointer(v634))--
	if v633 <= int64(1) {
		XTclFreeObj(tls, _objPtr31)
	} /* This one should be done here */
	/*
	 * Compute the new variable value.
	 */
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+88) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+88) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr)).Fversion) {
		v635 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr)).FsetElementProc
	} else {
		v635 = libc.UintptrFromInt32(0)
	}
	if v635 != 0 {
		v636 = *(*uintptr)(unsafe.Pointer(bp + 16))
		if (*TTcl_Obj)(unsafe.Pointer(v636)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+88) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+88) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v636)).FtypePtr)).Fversion) {
			v637 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v636)).FtypePtr)).FsetElementProc
		} else {
			v637 = libc.UintptrFromInt32(0)
		}
		proc3 = v637
		v638 = (*(*func(*libc.TLS, uintptr, uintptr, TTcl_Size, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{proc3})))(tls, interp4, v636, int64(numIndices), tosPtr+uintptr(-numIndices)*8, *(*uintptr)(unsafe.Pointer(tosPtr)))
		goto _639
	_639:
		*(*uintptr)(unsafe.Pointer(bp + 8)) = v638
	} else {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclLsetFlat(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 16)), int64(numIndices), tosPtr+uintptr(-numIndices)*8, *(*uintptr)(unsafe.Pointer(tosPtr)))
	}
	if !(*(*uintptr)(unsafe.Pointer(bp + 8)) != 0) {
		checkInterp = int32(1)
		goto gotError
	}
	/*
	 * Set result.
	 */
	checkInterp = int32(1)
	pc += uintptr(libc.Int32FromInt32(5))
	cleanup = numIndices + int32(1)
	if -int32(1) != 0 {
		if -int32(1) > 0 {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
		}
		goto cleanupV_pushObjResultPtr
	} else {
		goto cleanupV
	}
_159:
	; /* 'lset' with 4 args */
	/*
	 * Get the old value of variable, and remove the stack ref. This is
	 * safe because the variable still references the object; the ref
	 * count will never go zero here - we can use the smaller macro
	 * Tcl_DecrRefCount.
	 */
	v640 = tosPtr
	tosPtr -= 8
	objPtr5 = *(*uintptr)(unsafe.Pointer(v640))
	_objPtr32 = objPtr5
	v642 = _objPtr32
	v641 = *(*TTcl_Size)(unsafe.Pointer(v642))
	*(*TTcl_Size)(unsafe.Pointer(v642))--
	if v641 <= int64(1) {
		XTclFreeObj(tls, _objPtr32)
	} /* This one should be done here. */
	/*
	 * Get the new element value, and the index list.
	 */
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr))
	value2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8))
	/*
	 * Compute the new variable value.
	 */
	*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclLsetList(tls, interp4, objPtr5, value2Ptr, *(*uintptr)(unsafe.Pointer(bp + 16)))
	if !(*(*uintptr)(unsafe.Pointer(bp + 8)) != 0) {
		goto gotError
	}
	/*
	 * Set result.
	 */
	if false {
		if -int32(1) != 0 {
			if -int32(1) > 0 {
				v645 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v646 = tosPtr
				*(*uintptr)(unsafe.Pointer(v646)) = v645
				(*TTcl_Obj)(unsafe.Pointer(v645)).FrefCount++
			} else {
				tosPtr += 8
				v647 = tosPtr
				*(*uintptr)(unsafe.Pointer(v647)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if -int32(1) != 0 {
			if -int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _644
_644:
	;
	goto _643
_643: /**/
	; //
_160:
	; /* lrange with objc==4 and both indices in
	 * bytecode stream */
	/*
	 * Pop the list and get the indices.
	 */
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr))
	*(*TTcl_Size)(unsafe.Pointer(bp + 256)) = int64(libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	*(*TTcl_Size)(unsafe.Pointer(bp + 264)) = int64(libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5) + libc.UintptrFromInt32(3))))))
	/*
	 * Get the length of the list, making sure that it really is a list
	 * in the process.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr2 != 0 {
			v649 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr2)).FspanLength
		} else {
			v649 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = v649
		v648 = libc.Int32FromInt32(TCL_OK)
	} else {
		v648 = XTcl_ListObjLength(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 16)), bp+40)
	}
	if v648 != TCL_OK {
		goto gotError
	}
	/*
	 * Skip a lot of work if we're about to throw the result away (common
	 * with uses of [lassign]).
	 */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + 9))) == int32(INST_POP) {
		if false {
			if 0 != 0 {
				if 0 > 0 {
					v652 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v653 = tosPtr
					*(*uintptr)(unsafe.Pointer(v653)) = v652
					(*TTcl_Obj)(unsafe.Pointer(v652)).FrefCount++
				} else {
					tosPtr += 8
					v654 = tosPtr
					*(*uintptr)(unsafe.Pointer(v654)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(10))
			goto cleanup0
		} else {
			if 0 != 0 {
				if 0 > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(10))
				switch libc.Int32FromInt32(1) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(10))
				switch libc.Int32FromInt32(1) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _651
	_651:
		;
		goto _650
	_650: /**/ //
	}
	/* Every range of an empty list is an empty list */
	if *(*TTcl_Size)(unsafe.Pointer(bp + 40)) == 0 {
		/* avoid return of not canonical list (e. g. spaces in string repr.) */
		if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0) || !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength != 0) {
			if true {
				if 0 != 0 {
					if 0 > 0 {
						v657 = *(*uintptr)(unsafe.Pointer(bp + 8))
						tosPtr += 8
						v658 = tosPtr
						*(*uintptr)(unsafe.Pointer(v658)) = v657
						(*TTcl_Obj)(unsafe.Pointer(v657)).FrefCount++
					} else {
						tosPtr += 8
						v659 = tosPtr
						*(*uintptr)(unsafe.Pointer(v659)) = *(*uintptr)(unsafe.Pointer(bp + 8))
					}
				}
				pc += uintptr(libc.Int32FromInt32(9))
				goto cleanup0
			} else {
				if 0 != 0 {
					if 0 > 0 {
						(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
					}
					pc += uintptr(libc.Int32FromInt32(9))
					switch libc.Int32FromInt32(0) {
					case int32(1):
						goto cleanup1_pushObjResultPtr
					case int32(2):
						goto cleanup2_pushObjResultPtr
					case 0:
						break
					}
				} else {
					pc += uintptr(libc.Int32FromInt32(9))
					switch libc.Int32FromInt32(0) {
					case int32(1):
						goto cleanup1
					case int32(2):
						goto cleanup2
					case 0:
						break
					}
				}
			}
			goto _656
		_656:
			;
			goto _655
		_655: /**/ //
		}
		goto emptyList
	}
	/* Decode index value operands. */
	if !(*(*TTcl_Size)(unsafe.Pointer(bp + 264)) == int64(-libc.Int32FromInt32(1))) {
		goto _660
	}
	goto emptyList
emptyList:
	;
	if v661 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v661 {
		cachePtr46 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v661 || (*TAllocCache)(unsafe.Pointer(cachePtr46)).FnumObjects == libc.Uint64FromInt32(0) {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
	} else {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr46)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr46)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr46)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = libc.UintptrFromInt32(0)
	if false {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v664 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v665 = tosPtr
				*(*uintptr)(unsafe.Pointer(v665)) = v664
				(*TTcl_Obj)(unsafe.Pointer(v664)).FrefCount++
			} else {
				tosPtr += 8
				v666 = tosPtr
				*(*uintptr)(unsafe.Pointer(v666)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(9))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(9))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(9))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _663
_663:
	;
	goto _662
_662: /**/
	; //
_660:
	;
	*(*TTcl_Size)(unsafe.Pointer(bp + 264)) = XTclIndexDecode(tls, int32(*(*TTcl_Size)(unsafe.Pointer(bp + 264))), *(*TTcl_Size)(unsafe.Pointer(bp + 40))-int64(1))
	if *(*TTcl_Size)(unsafe.Pointer(bp + 264)) == int64(-libc.Int32FromInt32(1)) {
		goto emptyList
	} else {
		if *(*TTcl_Size)(unsafe.Pointer(bp + 264)) >= *(*TTcl_Size)(unsafe.Pointer(bp + 40)) {
			*(*TTcl_Size)(unsafe.Pointer(bp + 264)) = *(*TTcl_Size)(unsafe.Pointer(bp + 40)) - int64(1)
		}
	}
	/*
		assert ( fromIdx != TCL_INDEX_NONE );
		 *
		 * Extra safety for legacy bytecodes:
	*/
	if *(*TTcl_Size)(unsafe.Pointer(bp + 256)) == int64(-libc.Int32FromInt32(1)) {
		*(*TTcl_Size)(unsafe.Pointer(bp + 256)) = libc.Int64FromInt32(0)
	}
	*(*TTcl_Size)(unsafe.Pointer(bp + 256)) = XTclIndexDecode(tls, int32(*(*TTcl_Size)(unsafe.Pointer(bp + 256))), *(*TTcl_Size)(unsafe.Pointer(bp + 40))-int64(1))
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+64) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+64) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr)).Fversion) {
		v667 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr)).FsliceProc
	} else {
		v667 = libc.UintptrFromInt32(0)
	}
	if v667 != 0 {
		v668 = *(*uintptr)(unsafe.Pointer(bp + 16))
		if (*TTcl_Obj)(unsafe.Pointer(v668)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+64) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+64) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v668)).FtypePtr)).Fversion) {
			v669 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v668)).FtypePtr)).FsliceProc
		} else {
			v669 = libc.UintptrFromInt32(0)
		}
		proc2 = v669
		v670 = (*(*func(*libc.TLS, uintptr, uintptr, TTcl_Size, TTcl_Size, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{proc2})))(tls, interp4, v668, *(*TTcl_Size)(unsafe.Pointer(bp + 256)), *(*TTcl_Size)(unsafe.Pointer(bp + 264)), bp+8)
		goto _671
	_671:
		if v670 != TCL_OK {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = libc.UintptrFromInt32(0)
		}
	} else {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclListObjRange(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 16)), *(*TTcl_Size)(unsafe.Pointer(bp + 256)), *(*TTcl_Size)(unsafe.Pointer(bp + 264)))
	}
	if *(*uintptr)(unsafe.Pointer(bp + 8)) == libc.UintptrFromInt32(0) {
		checkInterp = int32(1)
		goto gotError
	}
	checkInterp = int32(1)
	if false {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v674 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v675 = tosPtr
				*(*uintptr)(unsafe.Pointer(v675)) = v674
				(*TTcl_Obj)(unsafe.Pointer(v674)).FrefCount++
			} else {
				tosPtr += 8
				v676 = tosPtr
				*(*uintptr)(unsafe.Pointer(v676)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(9))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(9))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(9))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _673
_673:
	;
	goto _672
_672: /**/
	; //
_162:
	;
_161:
	; /* Basic list containment operators. */
	value2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr))
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8))
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 280)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength
		v677 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes
	} else {
		v677 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), bp+280)
	}
	s1 = v677
	if (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+104) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+104) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr)).Fversion) {
		v678 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr)).FinOperProc
	} else {
		v678 = libc.UintptrFromInt32(0)
	}
	if v678 != libc.UintptrFromInt32(0) {
		v679 = value2Ptr
		if (*TTcl_Obj)(unsafe.Pointer(v679)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+104) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+104) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v679)).FtypePtr)).Fversion) {
			v680 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v679)).FtypePtr)).FinOperProc
		} else {
			v680 = libc.UintptrFromInt32(0)
		}
		proc4 = v680
		v681 = (*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{proc4})))(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 16)), v679, bp+232)
		goto _682
	_682:
		status = v681
		if status != TCL_OK {
			goto gotError
		}
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(value2Ptr + 32))).Fptr2 != 0 {
				v684 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(value2Ptr + 32))).Fptr2)).FspanLength
			} else {
				v684 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(value2Ptr + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = v684
			v683 = libc.Int32FromInt32(TCL_OK)
		} else {
			v683 = XTcl_ListObjLength(tls, interp4, value2Ptr, bp+32)
		}
		if v683 != TCL_OK {
			goto gotError
		}
		*(*int32)(unsafe.Pointer(bp + 232)) = 0
		if *(*TTcl_Size)(unsafe.Pointer(bp + 32)) > 0 {
			i2 = 0
			if (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+56) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+56) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr)).Fversion) {
				v685 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr)).FindexProc
			} else {
				v685 = libc.UintptrFromInt32(0)
			}
			isAbstractList = libc.BoolInt32(v685 != libc.UintptrFromInt32(0))
			/*
			 * An empty list doesn't match anything.
			 */
			for cond := true; cond; cond = i2 < *(*TTcl_Size)(unsafe.Pointer(bp + 32)) && *(*int32)(unsafe.Pointer(bp + 232)) == 0 {
				if isAbstractList != 0 {
					(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
					v686 = value2Ptr
					if (*TTcl_Obj)(unsafe.Pointer(v686)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+56) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+56) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v686)).FtypePtr)).Fversion) {
						v687 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v686)).FtypePtr)).FindexProc
					} else {
						v687 = libc.UintptrFromInt32(0)
					}
					proc1 = v687
					v688 = (*(*func(*libc.TLS, uintptr, uintptr, TTcl_Size, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{proc1})))(tls, interp4, v686, i2, bp+304)
					goto _689
				_689:
					if v688 != TCL_OK {
						checkInterp = int32(1)
						goto gotError
					}
					checkInterp = int32(1)
				} else {
					XTcl_ListObjIndex(tls, libc.UintptrFromInt32(0), value2Ptr, i2, bp+304)
				}
				if *(*uintptr)(unsafe.Pointer(bp + 304)) != libc.UintptrFromInt32(0) {
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 304)))).Fbytes != 0 {
						*(*TTcl_Size)(unsafe.Pointer(bp + 288)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 304)))).Flength
						v690 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 304)))).Fbytes
					} else {
						v690 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 304)), bp+288)
					}
					s2 = v690
				} else {
					s2 = __ccgo_ts + 1945
					*(*TTcl_Size)(unsafe.Pointer(bp + 288)) = 0
				}
				if *(*TTcl_Size)(unsafe.Pointer(bp + 280)) == *(*TTcl_Size)(unsafe.Pointer(bp + 288)) {
					*(*int32)(unsafe.Pointer(bp + 232)) = libc.BoolInt32(libc.Xmemcmp(tls, s1, s2, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 280)))) == 0)
				}
				/* Could be an ephemeral abstract obj */
				v691 = *(*uintptr)(unsafe.Pointer(bp + 304))
				if v691 != 0 {
					if (*TTcl_Obj)(unsafe.Pointer(v691)).FrefCount == libc.Int64FromInt32(0) {
						_objPtr = v691
						v693 = _objPtr
						v692 = *(*TTcl_Size)(unsafe.Pointer(v693))
						*(*TTcl_Size)(unsafe.Pointer(v693))--
						if v692 <= libc.Int64FromInt32(1) {
							XTclFreeObj(tls, _objPtr)
						}
					}
				}
				i2++
			}
		}
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) == int32(INST_LIST_NOT_IN) {
		*(*int32)(unsafe.Pointer(bp + 232)) = libc.BoolInt32(!(*(*int32)(unsafe.Pointer(bp + 232)) != 0))
	}
	/*
	 * Peep-hole optimisation: if you're about to jump, do jump from here.
	 * We're saving the effort of pushing a boolean value only to pop it
	 * for branching.
	 */
	pc += uintptr(libc.Int32FromInt32(1))
	switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) {
	case int32(INST_JUMP_FALSE1):
		goto _696
	case int32(INST_JUMP_TRUE1):
		goto _697
	case int32(INST_JUMP_FALSE4):
		goto _698
	case int32(INST_JUMP_TRUE4):
		goto _699
	default:
		goto _700
	}
	goto _701
_696:
	;
_704:
	;
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v705 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v706 = tosPtr
				*(*uintptr)(unsafe.Pointer(v706)) = v705
				(*TTcl_Obj)(unsafe.Pointer(v705)).FrefCount++
			} else {
				tosPtr += 8
				v707 = tosPtr
				*(*uintptr)(unsafe.Pointer(v707)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
			v708 = int32(2)
		} else {
			v708 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
		}
		pc += uintptr(v708)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v709 = int32(2)
			} else {
				v709 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
			}
			pc += uintptr(v709)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v710 = int32(2)
			} else {
				v710 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
			}
			pc += uintptr(v710)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _703
_703:
	;
	if 0 != 0 {
		goto _704
	}
	goto _702
_702:
	;
	goto _701
_697:
	;
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v713 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v714 = tosPtr
				*(*uintptr)(unsafe.Pointer(v714)) = v713
				(*TTcl_Obj)(unsafe.Pointer(v713)).FrefCount++
			} else {
				tosPtr += 8
				v715 = tosPtr
				*(*uintptr)(unsafe.Pointer(v715)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
			v716 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
		} else {
			v716 = int32(2)
		}
		pc += uintptr(v716)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v717 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
			} else {
				v717 = int32(2)
			}
			pc += uintptr(v717)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v718 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
			} else {
				v718 = int32(2)
			}
			pc += uintptr(v718)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _712
_712:
	;
	goto _711
_711: /**/
	; //
	goto _701
_698:
	;
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v721 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v722 = tosPtr
				*(*uintptr)(unsafe.Pointer(v722)) = v721
				(*TTcl_Obj)(unsafe.Pointer(v721)).FrefCount++
			} else {
				tosPtr += 8
				v723 = tosPtr
				*(*uintptr)(unsafe.Pointer(v723)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
			v724 = int32(5)
		} else {
			v724 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
		}
		pc += uintptr(v724)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v725 = int32(5)
			} else {
				v725 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
			}
			pc += uintptr(v725)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v726 = int32(5)
			} else {
				v726 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
			}
			pc += uintptr(v726)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _720
_720:
	;
	goto _719
_719: /**/
	; //
	goto _701
_699:
	;
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v729 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v730 = tosPtr
				*(*uintptr)(unsafe.Pointer(v730)) = v729
				(*TTcl_Obj)(unsafe.Pointer(v729)).FrefCount++
			} else {
				tosPtr += 8
				v731 = tosPtr
				*(*uintptr)(unsafe.Pointer(v731)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
			v732 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
		} else {
			v732 = int32(5)
		}
		pc += uintptr(v732)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v733 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
			} else {
				v733 = int32(5)
			}
			pc += uintptr(v733)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v734 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
			} else {
				v734 = int32(5)
			}
			pc += uintptr(v734)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _728
_728:
	;
	goto _727
_727: /**/
	; //
	goto _701
_700:
	;
	if *(*int32)(unsafe.Pointer(bp + 232)) < 0 {
		if v735 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v735 {
			cachePtr47 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v735 || (*TAllocCache)(unsafe.Pointer(cachePtr47)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr47)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr47)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr47)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = libc.UintptrFromInt32(0)
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FinternalRep)) = int64(-libc.Int32FromInt32(1))
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	} else {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(constants + libc.BoolUintptr(*(*int32)(unsafe.Pointer(bp + 232)) > libc.Int32FromInt32(0))*8))
	}
	if false {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v738 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v739 = tosPtr
				*(*uintptr)(unsafe.Pointer(v739)) = v738
				(*TTcl_Obj)(unsafe.Pointer(v738)).FrefCount++
			} else {
				tosPtr += 8
				v740 = tosPtr
				*(*uintptr)(unsafe.Pointer(v740)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(0))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(0))
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(0))
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _737
_737:
	;
	goto _736
_736: /**/
	; //
	goto _701
_701:
	;
	goto _695
_695:
	;
	goto _694
_694: /**/
	; //
_163:
	;
	value2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr))
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8))
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount > int64(1) {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = XTcl_DuplicateObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
		if XTcl_ListObjAppendList(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 8)), value2Ptr) != TCL_OK {
			v742 = *(*uintptr)(unsafe.Pointer(bp + 8))
			v741 = *(*TTcl_Size)(unsafe.Pointer(v742))
			*(*TTcl_Size)(unsafe.Pointer(v742))--
			if !(v741 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = int64(-libc.Int32FromInt32(1))
					if v743 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v743 {
						cachePtr48 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v743 || ((*TAllocCache)(unsafe.Pointer(cachePtr48)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr48)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr48)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr48)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
						(*TAllocCache)(unsafe.Pointer(cachePtr48)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
				}
			}
			goto gotError
		}
		if false {
			if int32(1) != 0 {
				if int32(1) > 0 {
					v746 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v747 = tosPtr
					*(*uintptr)(unsafe.Pointer(v747)) = v746
					(*TTcl_Obj)(unsafe.Pointer(v746)).FrefCount++
				} else {
					tosPtr += 8
					v748 = tosPtr
					*(*uintptr)(unsafe.Pointer(v748)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(1))
			goto cleanup0
		} else {
			if int32(1) != 0 {
				if int32(1) > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(2) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(2) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _745
	_745:
		;
		goto _744
	_744: /**/
		//
	} else {
		if XTcl_ListObjAppendList(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 16)), value2Ptr) != TCL_OK {
			goto gotError
		}
		if false {
			if 0 != 0 {
				if 0 > 0 {
					v751 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v752 = tosPtr
					*(*uintptr)(unsafe.Pointer(v752)) = v751
					(*TTcl_Obj)(unsafe.Pointer(v751)).FrefCount++
				} else {
					tosPtr += 8
					v753 = tosPtr
					*(*uintptr)(unsafe.Pointer(v753)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(1))
			goto cleanup0
		} else {
			if 0 != 0 {
				if 0 > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(1) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(1) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _750
	_750:
		;
		goto _749
	_749: /**/ //
	}
_164:
	;
	opnd = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
	flags1 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5))))
	/* Stack: ... listobj index1 ?index2? new1 ... newN */
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-(opnd-libc.Int32FromInt32(1)))*8))
	/* haveSecondIndex==0 => pure insert */
	haveSecondIndex = libc.BoolInt32(flags1&int32(TCL_LREPLACE4_SINGLE_INDEX) == 0)
	numNewElems = libc.Uint64FromInt32(opnd - int32(2) - haveSecondIndex)
	/* end_indicator==1 => "end" is last element's index, 0=>index beyond */
	end_indicator = libc.BoolInt32(flags1&int32(TCL_LREPLACE4_END_IS_LAST) != 0)
	fromIdxObj = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-(opnd-libc.Int32FromInt32(2)))*8))
	if haveSecondIndex != 0 {
		v754 = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-(opnd-libc.Int32FromInt32(3)))*8))
	} else {
		v754 = libc.UintptrFromInt32(0)
	}
	toIdxObj = v754
	if XTcl_ListObjLength(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 16)), bp+32) != TCL_OK {
		goto gotError
	}
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	if (*TTcl_Obj)(unsafe.Pointer(fromIdxObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(fromIdxObj)).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(fromIdxObj)).FinternalRep)) <= *(*TTcl_Size)(unsafe.Pointer(bp + 32))-int64(end_indicator) {
		*(*TTcl_Size)(unsafe.Pointer(bp + 256)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(fromIdxObj)).FinternalRep))
		v755 = libc.Int32FromInt32(TCL_OK)
	} else {
		v755 = XTcl_GetIntForIndex(tls, interp4, fromIdxObj, *(*TTcl_Size)(unsafe.Pointer(bp + 32))-int64(end_indicator), bp+256)
	}
	if v755 != TCL_OK {
		checkInterp = int32(1)
		goto gotError
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp + 256)) == int64(-libc.Int32FromInt32(1)) {
		*(*TTcl_Size)(unsafe.Pointer(bp + 256)) = 0
	} else {
		if *(*TTcl_Size)(unsafe.Pointer(bp + 256)) > *(*TTcl_Size)(unsafe.Pointer(bp + 32)) {
			*(*TTcl_Size)(unsafe.Pointer(bp + 256)) = *(*TTcl_Size)(unsafe.Pointer(bp + 32))
		}
	}
	numToDelete = uint64(0)
	if toIdxObj != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(toIdxObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(toIdxObj)).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(toIdxObj)).FinternalRep)) <= *(*TTcl_Size)(unsafe.Pointer(bp + 32))-int64(end_indicator) {
			*(*TTcl_Size)(unsafe.Pointer(bp + 264)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(toIdxObj)).FinternalRep))
			v756 = libc.Int32FromInt32(TCL_OK)
		} else {
			v756 = XTcl_GetIntForIndex(tls, interp4, toIdxObj, *(*TTcl_Size)(unsafe.Pointer(bp + 32))-int64(end_indicator), bp+264)
		}
		if v756 != TCL_OK {
			checkInterp = int32(1)
			goto gotError
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 264)) != int64(-libc.Int32FromInt32(1)) {
			if *(*TTcl_Size)(unsafe.Pointer(bp + 264)) > *(*TTcl_Size)(unsafe.Pointer(bp + 32)) {
				*(*TTcl_Size)(unsafe.Pointer(bp + 264)) = *(*TTcl_Size)(unsafe.Pointer(bp + 32))
			}
			if *(*TTcl_Size)(unsafe.Pointer(bp + 264)) >= *(*TTcl_Size)(unsafe.Pointer(bp + 256)) {
				numToDelete = libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 264))) - libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 256))) + uint64(1)
			}
		}
	}
	checkInterp = int32(1)
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount > int64(1) {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = XTcl_DuplicateObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
		if XTcl_ListObjReplace(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 8)), *(*TTcl_Size)(unsafe.Pointer(bp + 256)), libc.Int64FromUint64(numToDelete), libc.Int64FromUint64(numNewElems), tosPtr+uintptr(-(numNewElems-libc.Uint64FromInt32(1)))*8) != TCL_OK {
			_objPtr33 = *(*uintptr)(unsafe.Pointer(bp + 8))
			v758 = _objPtr33
			v757 = *(*TTcl_Size)(unsafe.Pointer(v758))
			*(*TTcl_Size)(unsafe.Pointer(v758))--
			if v757 <= int64(1) {
				XTclFreeObj(tls, _objPtr33)
			}
			goto gotError
		}
		pc += uintptr(libc.Int32FromInt32(6))
		cleanup = opnd
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			goto cleanupV_pushObjResultPtr
		} else {
			goto cleanupV
		}
	} else {
		if XTcl_ListObjReplace(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 16)), *(*TTcl_Size)(unsafe.Pointer(bp + 256)), libc.Int64FromUint64(numToDelete), libc.Int64FromUint64(numNewElems), tosPtr+uintptr(-(numNewElems-libc.Uint64FromInt32(1)))*8) != TCL_OK {
			goto gotError
		}
		pc += uintptr(libc.Int32FromInt32(6))
		cleanup = opnd - int32(1)
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			goto cleanupV_pushObjResultPtr
		} else {
			goto cleanupV
		}
	}
	/*
	 *	   End of INST_LIST and related instructions.
	 * -----------------------------------------------------------------
	 *	   Start of string-related instructions.
	 */
_171:
	;
_170:
	; /* String (in)equality check */
_169:
	; /* String compare. */
_168:
	;
_167:
	;
_166:
	;
_165:
	;
	goto stringCompare
stringCompare:
	;
	value2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr))
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8))
	checkEq = libc.BoolInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) == int32(INST_EQ) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) == int32(INST_NEQ) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) == int32(INST_STR_EQ) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) == int32(INST_STR_NEQ))
	*(*int32)(unsafe.Pointer(bp + 232)) = XTclStringCmp(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), value2Ptr, checkEq, 0, int64(-int32(1)))
	/*
	 * Make sure only -1,0,1 is returned
	 * TODO: consider peephole opt.
	 */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) != int32(INST_STR_CMP) {
		/*
		 * Take care of the opcodes that goto'ed into here.
		 */
		switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) {
		case int32(INST_STR_EQ):
			fallthrough
		case int32(INST_EQ):
			*(*int32)(unsafe.Pointer(bp + 232)) = libc.BoolInt32(*(*int32)(unsafe.Pointer(bp + 232)) == 0)
		case int32(INST_STR_NEQ):
			fallthrough
		case int32(INST_NEQ):
			*(*int32)(unsafe.Pointer(bp + 232)) = libc.BoolInt32(*(*int32)(unsafe.Pointer(bp + 232)) != 0)
		case int32(INST_LT):
			fallthrough
		case int32(INST_STR_LT):
			*(*int32)(unsafe.Pointer(bp + 232)) = libc.BoolInt32(*(*int32)(unsafe.Pointer(bp + 232)) < 0)
		case int32(INST_GT):
			fallthrough
		case int32(INST_STR_GT):
			*(*int32)(unsafe.Pointer(bp + 232)) = libc.BoolInt32(*(*int32)(unsafe.Pointer(bp + 232)) > 0)
		case int32(INST_LE):
			fallthrough
		case int32(INST_STR_LE):
			*(*int32)(unsafe.Pointer(bp + 232)) = libc.BoolInt32(*(*int32)(unsafe.Pointer(bp + 232)) <= 0)
		case int32(INST_GE):
			fallthrough
		case int32(INST_STR_GE):
			*(*int32)(unsafe.Pointer(bp + 232)) = libc.BoolInt32(*(*int32)(unsafe.Pointer(bp + 232)) >= 0)
			break
		}
	}
	pc += uintptr(libc.Int32FromInt32(1))
	switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) {
	case int32(INST_JUMP_FALSE1):
		goto _761
	case int32(INST_JUMP_TRUE1):
		goto _762
	case int32(INST_JUMP_FALSE4):
		goto _763
	case int32(INST_JUMP_TRUE4):
		goto _764
	default:
		goto _765
	}
	goto _766
_761:
	;
_769:
	;
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v770 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v771 = tosPtr
				*(*uintptr)(unsafe.Pointer(v771)) = v770
				(*TTcl_Obj)(unsafe.Pointer(v770)).FrefCount++
			} else {
				tosPtr += 8
				v772 = tosPtr
				*(*uintptr)(unsafe.Pointer(v772)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
			v773 = int32(2)
		} else {
			v773 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
		}
		pc += uintptr(v773)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v774 = int32(2)
			} else {
				v774 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
			}
			pc += uintptr(v774)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v775 = int32(2)
			} else {
				v775 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
			}
			pc += uintptr(v775)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _768
_768:
	;
	if 0 != 0 {
		goto _769
	}
	goto _767
_767:
	;
	goto _766
_762:
	;
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v778 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v779 = tosPtr
				*(*uintptr)(unsafe.Pointer(v779)) = v778
				(*TTcl_Obj)(unsafe.Pointer(v778)).FrefCount++
			} else {
				tosPtr += 8
				v780 = tosPtr
				*(*uintptr)(unsafe.Pointer(v780)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
			v781 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
		} else {
			v781 = int32(2)
		}
		pc += uintptr(v781)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v782 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
			} else {
				v782 = int32(2)
			}
			pc += uintptr(v782)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v783 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
			} else {
				v783 = int32(2)
			}
			pc += uintptr(v783)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _777
_777:
	;
	goto _776
_776: /**/
	; //
	goto _766
_763:
	;
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v786 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v787 = tosPtr
				*(*uintptr)(unsafe.Pointer(v787)) = v786
				(*TTcl_Obj)(unsafe.Pointer(v786)).FrefCount++
			} else {
				tosPtr += 8
				v788 = tosPtr
				*(*uintptr)(unsafe.Pointer(v788)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
			v789 = int32(5)
		} else {
			v789 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
		}
		pc += uintptr(v789)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v790 = int32(5)
			} else {
				v790 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
			}
			pc += uintptr(v790)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v791 = int32(5)
			} else {
				v791 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
			}
			pc += uintptr(v791)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _785
_785:
	;
	goto _784
_784: /**/
	; //
	goto _766
_764:
	;
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v794 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v795 = tosPtr
				*(*uintptr)(unsafe.Pointer(v795)) = v794
				(*TTcl_Obj)(unsafe.Pointer(v794)).FrefCount++
			} else {
				tosPtr += 8
				v796 = tosPtr
				*(*uintptr)(unsafe.Pointer(v796)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
			v797 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
		} else {
			v797 = int32(5)
		}
		pc += uintptr(v797)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v798 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
			} else {
				v798 = int32(5)
			}
			pc += uintptr(v798)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v799 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
			} else {
				v799 = int32(5)
			}
			pc += uintptr(v799)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _793
_793:
	;
	goto _792
_792: /**/
	; //
	goto _766
_765:
	;
	if *(*int32)(unsafe.Pointer(bp + 232)) < 0 {
		if v800 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v800 {
			cachePtr49 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v800 || (*TAllocCache)(unsafe.Pointer(cachePtr49)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr49)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr49)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr49)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = libc.UintptrFromInt32(0)
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FinternalRep)) = int64(-libc.Int32FromInt32(1))
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	} else {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(constants + libc.BoolUintptr(*(*int32)(unsafe.Pointer(bp + 232)) > libc.Int32FromInt32(0))*8))
	}
	if false {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v803 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v804 = tosPtr
				*(*uintptr)(unsafe.Pointer(v804)) = v803
				(*TTcl_Obj)(unsafe.Pointer(v803)).FrefCount++
			} else {
				tosPtr += 8
				v805 = tosPtr
				*(*uintptr)(unsafe.Pointer(v805)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(0))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(0))
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(0))
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _802
_802:
	;
	goto _801
_801: /**/
	; //
	goto _766
_766:
	;
	goto _760
_760:
	;
	goto _759
_759: /**/
	; //
_172:
	;
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr))
	*(*TTcl_Size)(unsafe.Pointer(bp + 240)) = XTcl_GetCharLength(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
	if v806 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v806 {
		cachePtr50 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v806 || (*TAllocCache)(unsafe.Pointer(cachePtr50)).FnumObjects == libc.Uint64FromInt32(0) {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
	} else {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr50)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr50)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr50)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = libc.UintptrFromInt32(0)
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FinternalRep)) = *(*TTcl_Size)(unsafe.Pointer(bp + 240))
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	if false {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v809 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v810 = tosPtr
				*(*uintptr)(unsafe.Pointer(v810)) = v809
				(*TTcl_Obj)(unsafe.Pointer(v809)).FrefCount++
			} else {
				tosPtr += 8
				v811 = tosPtr
				*(*uintptr)(unsafe.Pointer(v811)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _808
_808:
	;
	goto _807
_807: /**/
	; //
_173:
	;
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr))
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount > int64(1) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 240)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength
			v812 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes
		} else {
			v812 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), bp+240)
		}
		s1 = v812
		if v813 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v813 {
			cachePtr51 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v813 || (*TAllocCache)(unsafe.Pointer(cachePtr51)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr51)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr51)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr51)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
		if *(*TTcl_Size)(unsafe.Pointer(bp + 240)) == 0 {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 240))+libc.Int64FromUint32(1)))
			if s1 != 0 {
				v814 = s1
			} else {
				v814 = uintptr(unsafe.Pointer(&XtclEmptyString))
			}
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes, v814, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 240))))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 240))))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = *(*TTcl_Size)(unsafe.Pointer(bp + 240))
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = libc.UintptrFromInt32(0)
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != 0 {
			v815 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes
		} else {
			v815 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), libc.UintptrFromInt32(0))
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 240)) = XTcl_UtfToUpper(tls, v815)
		XTcl_SetObjLength(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), *(*TTcl_Size)(unsafe.Pointer(bp + 240)))
		if false {
			if int32(1) != 0 {
				if int32(1) > 0 {
					v818 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v819 = tosPtr
					*(*uintptr)(unsafe.Pointer(v819)) = v818
					(*TTcl_Obj)(unsafe.Pointer(v818)).FrefCount++
				} else {
					tosPtr += 8
					v820 = tosPtr
					*(*uintptr)(unsafe.Pointer(v820)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(1))
			goto cleanup0
		} else {
			if int32(1) != 0 {
				if int32(1) > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(1) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(1) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _817
	_817:
		;
		goto _816
	_816: /**/
		//
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 {
			v821 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes
		} else {
			v821 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), libc.UintptrFromInt32(0))
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 240)) = XTcl_UtfToUpper(tls, v821)
		XTcl_SetObjLength(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), *(*TTcl_Size)(unsafe.Pointer(bp + 240)))
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr != libc.UintptrFromInt32(0) {
			if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
				(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr)).FfreeIntRepProc})))(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr = libc.UintptrFromInt32(0)
		}
		if true {
			if 0 != 0 {
				if 0 > 0 {
					v824 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v825 = tosPtr
					*(*uintptr)(unsafe.Pointer(v825)) = v824
					(*TTcl_Obj)(unsafe.Pointer(v824)).FrefCount++
				} else {
					tosPtr += 8
					v826 = tosPtr
					*(*uintptr)(unsafe.Pointer(v826)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(1))
			goto cleanup0
		} else {
			if 0 != 0 {
				if 0 > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _823
	_823:
		;
		goto _822
	_822: /**/
		//
	}
_174:
	;
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr))
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount > int64(1) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 240)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength
			v827 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes
		} else {
			v827 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), bp+240)
		}
		s1 = v827
		if v828 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v828 {
			cachePtr52 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v828 || (*TAllocCache)(unsafe.Pointer(cachePtr52)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr52)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr52)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr52)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
		if *(*TTcl_Size)(unsafe.Pointer(bp + 240)) == 0 {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 240))+libc.Int64FromUint32(1)))
			if s1 != 0 {
				v829 = s1
			} else {
				v829 = uintptr(unsafe.Pointer(&XtclEmptyString))
			}
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes, v829, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 240))))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 240))))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = *(*TTcl_Size)(unsafe.Pointer(bp + 240))
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = libc.UintptrFromInt32(0)
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != 0 {
			v830 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes
		} else {
			v830 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), libc.UintptrFromInt32(0))
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 240)) = XTcl_UtfToLower(tls, v830)
		XTcl_SetObjLength(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), *(*TTcl_Size)(unsafe.Pointer(bp + 240)))
		if false {
			if int32(1) != 0 {
				if int32(1) > 0 {
					v833 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v834 = tosPtr
					*(*uintptr)(unsafe.Pointer(v834)) = v833
					(*TTcl_Obj)(unsafe.Pointer(v833)).FrefCount++
				} else {
					tosPtr += 8
					v835 = tosPtr
					*(*uintptr)(unsafe.Pointer(v835)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(1))
			goto cleanup0
		} else {
			if int32(1) != 0 {
				if int32(1) > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(1) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(1) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _832
	_832:
		;
		goto _831
	_831: /**/
		//
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 {
			v836 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes
		} else {
			v836 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), libc.UintptrFromInt32(0))
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 240)) = XTcl_UtfToLower(tls, v836)
		XTcl_SetObjLength(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), *(*TTcl_Size)(unsafe.Pointer(bp + 240)))
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr != libc.UintptrFromInt32(0) {
			if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
				(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr)).FfreeIntRepProc})))(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr = libc.UintptrFromInt32(0)
		}
		if true {
			if 0 != 0 {
				if 0 > 0 {
					v839 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v840 = tosPtr
					*(*uintptr)(unsafe.Pointer(v840)) = v839
					(*TTcl_Obj)(unsafe.Pointer(v839)).FrefCount++
				} else {
					tosPtr += 8
					v841 = tosPtr
					*(*uintptr)(unsafe.Pointer(v841)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(1))
			goto cleanup0
		} else {
			if 0 != 0 {
				if 0 > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _838
	_838:
		;
		goto _837
	_837: /**/
		//
	}
_175:
	;
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr))
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount > int64(1) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 240)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength
			v842 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes
		} else {
			v842 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), bp+240)
		}
		s1 = v842
		if v843 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v843 {
			cachePtr53 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v843 || (*TAllocCache)(unsafe.Pointer(cachePtr53)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr53)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr53)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr53)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
		if *(*TTcl_Size)(unsafe.Pointer(bp + 240)) == 0 {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 240))+libc.Int64FromUint32(1)))
			if s1 != 0 {
				v844 = s1
			} else {
				v844 = uintptr(unsafe.Pointer(&XtclEmptyString))
			}
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes, v844, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 240))))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 240))))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = *(*TTcl_Size)(unsafe.Pointer(bp + 240))
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = libc.UintptrFromInt32(0)
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != 0 {
			v845 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes
		} else {
			v845 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), libc.UintptrFromInt32(0))
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 240)) = XTcl_UtfToTitle(tls, v845)
		XTcl_SetObjLength(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), *(*TTcl_Size)(unsafe.Pointer(bp + 240)))
		if false {
			if int32(1) != 0 {
				if int32(1) > 0 {
					v848 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v849 = tosPtr
					*(*uintptr)(unsafe.Pointer(v849)) = v848
					(*TTcl_Obj)(unsafe.Pointer(v848)).FrefCount++
				} else {
					tosPtr += 8
					v850 = tosPtr
					*(*uintptr)(unsafe.Pointer(v850)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(1))
			goto cleanup0
		} else {
			if int32(1) != 0 {
				if int32(1) > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(1) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(1) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _847
	_847:
		;
		goto _846
	_846: /**/
		//
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 {
			v851 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes
		} else {
			v851 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), libc.UintptrFromInt32(0))
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 240)) = XTcl_UtfToTitle(tls, v851)
		XTcl_SetObjLength(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), *(*TTcl_Size)(unsafe.Pointer(bp + 240)))
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr != libc.UintptrFromInt32(0) {
			if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
				(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr)).FfreeIntRepProc})))(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr = libc.UintptrFromInt32(0)
		}
		if true {
			if 0 != 0 {
				if 0 > 0 {
					v854 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v855 = tosPtr
					*(*uintptr)(unsafe.Pointer(v855)) = v854
					(*TTcl_Obj)(unsafe.Pointer(v854)).FrefCount++
				} else {
					tosPtr += 8
					v856 = tosPtr
					*(*uintptr)(unsafe.Pointer(v856)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(1))
			goto cleanup0
		} else {
			if 0 != 0 {
				if 0 > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _853
	_853:
		;
		goto _852
	_852: /**/
		//
	}
_176:
	;
	value2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr))
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8))
	/*
	 * Get char length to calculate what 'end' means.
	 */
	*(*TTcl_Size)(unsafe.Pointer(bp + 240)) = XTcl_GetCharLength(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	if (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FinternalRep)) <= *(*TTcl_Size)(unsafe.Pointer(bp + 240))-int64(1) {
		*(*TTcl_Size)(unsafe.Pointer(bp + 272)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FinternalRep))
		v857 = libc.Int32FromInt32(TCL_OK)
	} else {
		v857 = XTcl_GetIntForIndex(tls, interp4, value2Ptr, *(*TTcl_Size)(unsafe.Pointer(bp + 240))-libc.Int64FromInt32(1), bp+272)
	}
	if v857 != TCL_OK {
		checkInterp = int32(1)
		goto gotError
	}
	checkInterp = int32(1)
	if *(*TTcl_Size)(unsafe.Pointer(bp + 272)) < 0 || *(*TTcl_Size)(unsafe.Pointer(bp + 272)) >= *(*TTcl_Size)(unsafe.Pointer(bp + 240)) {
		if v858 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v858 {
			cachePtr54 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v858 || (*TAllocCache)(unsafe.Pointer(cachePtr54)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr54)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr54)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr54)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = libc.UintptrFromInt32(0)
	} else {
		if XTclIsPureByteArray(tls, *(*uintptr)(unsafe.Pointer(bp + 16))) != 0 {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = XTcl_NewByteArrayObj(tls, XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 16)), libc.UintptrFromInt32(0))+uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 272))), int64(1))
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 && *(*TTcl_Size)(unsafe.Pointer(bp + 240)) == (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength {
				*(*uintptr)(unsafe.Pointer(bp + 8)) = XTcl_NewStringObj(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes+uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 272))), int64(1))
			} else {
				*(*[4]uint8)(unsafe.Pointer(bp + 312)) = [4]uint8{}
				ch = XTcl_GetUniChar(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), *(*TTcl_Size)(unsafe.Pointer(bp + 272)))
				/*
				 * This could be: Tcl_NewUnicodeObj((const Tcl_UniChar *)&ch, 1)
				 * but creating the object as a string seems to be faster in
				 * practical use.
				 */
				if ch == -int32(1) {
					if v859 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v859 {
						cachePtr55 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v859 || (*TAllocCache)(unsafe.Pointer(cachePtr55)).FnumObjects == libc.Uint64FromInt32(0) {
						*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
					} else {
						*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr55)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr55)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr55)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = 0
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = libc.UintptrFromInt32(0)
				} else {
					*(*TTcl_Size)(unsafe.Pointer(bp + 240)) = XTcl_UniCharToUtf(tls, ch, bp+312)
					*(*uintptr)(unsafe.Pointer(bp + 8)) = XTcl_NewStringObj(tls, bp+312, *(*TTcl_Size)(unsafe.Pointer(bp + 240)))
				}
			}
		}
	}
	if false {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v862 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v863 = tosPtr
				*(*uintptr)(unsafe.Pointer(v863)) = v862
				(*TTcl_Obj)(unsafe.Pointer(v862)).FrefCount++
			} else {
				tosPtr += 8
				v864 = tosPtr
				*(*uintptr)(unsafe.Pointer(v864)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _861
_861:
	;
	goto _860
_860: /**/
	; //
_177:
	;
	*(*TTcl_Size)(unsafe.Pointer(bp + 240)) = XTcl_GetCharLength(tls, *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(2))*8))) - int64(1)
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)))).FinternalRep)) <= *(*TTcl_Size)(unsafe.Pointer(bp + 240)) {
		*(*TTcl_Size)(unsafe.Pointer(bp + 256)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)))).FinternalRep))
		v865 = libc.Int32FromInt32(TCL_OK)
	} else {
		v865 = XTcl_GetIntForIndex(tls, interp4, *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)), *(*TTcl_Size)(unsafe.Pointer(bp + 240)), bp+256)
	}
	if v865 != TCL_OK {
		checkInterp = int32(1)
		goto gotError
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FinternalRep)) <= *(*TTcl_Size)(unsafe.Pointer(bp + 240)) {
		*(*TTcl_Size)(unsafe.Pointer(bp + 264)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FinternalRep))
		v866 = libc.Int32FromInt32(TCL_OK)
	} else {
		v866 = XTcl_GetIntForIndex(tls, interp4, *(*uintptr)(unsafe.Pointer(tosPtr)), *(*TTcl_Size)(unsafe.Pointer(bp + 240)), bp+264)
	}
	if v866 != TCL_OK {
		checkInterp = int32(1)
		goto gotError
	}
	checkInterp = int32(1)
	if *(*TTcl_Size)(unsafe.Pointer(bp + 264)) == int64(-libc.Int32FromInt32(1)) {
		if v867 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v867 {
			cachePtr56 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v867 || (*TAllocCache)(unsafe.Pointer(cachePtr56)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr56)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr56)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr56)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = libc.UintptrFromInt32(0)
	} else {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = XTcl_GetRange(tls, *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(2))*8)), *(*TTcl_Size)(unsafe.Pointer(bp + 256)), *(*TTcl_Size)(unsafe.Pointer(bp + 264)))
	}
	pc += uintptr(libc.Int32FromInt32(1))
	cleanup = int32(3)
	if int32(1) != 0 {
		if int32(1) > 0 {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
		}
		goto cleanupV_pushObjResultPtr
	} else {
		goto cleanupV
	}
_178:
	;
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr))
	*(*TTcl_Size)(unsafe.Pointer(bp + 256)) = int64(libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	*(*TTcl_Size)(unsafe.Pointer(bp + 264)) = int64(libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5) + libc.UintptrFromInt32(3))))))
	*(*TTcl_Size)(unsafe.Pointer(bp + 240)) = XTcl_GetCharLength(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
	/* Every range of an empty value is an empty value */
	if *(*TTcl_Size)(unsafe.Pointer(bp + 240)) == 0 {
		if true {
			if 0 != 0 {
				if 0 > 0 {
					v870 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v871 = tosPtr
					*(*uintptr)(unsafe.Pointer(v871)) = v870
					(*TTcl_Obj)(unsafe.Pointer(v870)).FrefCount++
				} else {
					tosPtr += 8
					v872 = tosPtr
					*(*uintptr)(unsafe.Pointer(v872)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(9))
			goto cleanup0
		} else {
			if 0 != 0 {
				if 0 > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(9))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(9))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _869
	_869:
		;
		goto _868
	_868: /**/ //
	}
	/* Decode index operands. */
	*(*TTcl_Size)(unsafe.Pointer(bp + 264)) = XTclIndexDecode(tls, int32(*(*TTcl_Size)(unsafe.Pointer(bp + 264))), *(*TTcl_Size)(unsafe.Pointer(bp + 240))-int64(1))
	*(*TTcl_Size)(unsafe.Pointer(bp + 256)) = XTclIndexDecode(tls, int32(*(*TTcl_Size)(unsafe.Pointer(bp + 256))), *(*TTcl_Size)(unsafe.Pointer(bp + 240))-int64(1))
	if *(*TTcl_Size)(unsafe.Pointer(bp + 264)) == int64(-libc.Int32FromInt32(1)) {
		if v873 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v873 {
			cachePtr57 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v873 || (*TAllocCache)(unsafe.Pointer(cachePtr57)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr57)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr57)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr57)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = libc.UintptrFromInt32(0)
	} else {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = XTcl_GetRange(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), *(*TTcl_Size)(unsafe.Pointer(bp + 256)), *(*TTcl_Size)(unsafe.Pointer(bp + 264)))
	}
	if false {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v876 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v877 = tosPtr
				*(*uintptr)(unsafe.Pointer(v877)) = v876
				(*TTcl_Obj)(unsafe.Pointer(v876)).FrefCount++
			} else {
				tosPtr += 8
				v878 = tosPtr
				*(*uintptr)(unsafe.Pointer(v878)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(9))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(9))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(9))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _875
_875:
	;
	goto _874
_874: /**/
	; //
_179:
	;
	v879 = tosPtr
	tosPtr -= 8
	value3Ptr = *(*uintptr)(unsafe.Pointer(v879))
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(2))*8))
	*(*TTcl_Size)(unsafe.Pointer(bp + 240)) = XTcl_GetCharLength(tls, *(*uintptr)(unsafe.Pointer(bp + 16))) - int64(1)
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)))).FinternalRep)) <= *(*TTcl_Size)(unsafe.Pointer(bp + 240)) {
		*(*TTcl_Size)(unsafe.Pointer(bp + 256)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)))).FinternalRep))
		v880 = libc.Int32FromInt32(TCL_OK)
	} else {
		v880 = XTcl_GetIntForIndex(tls, interp4, *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)), *(*TTcl_Size)(unsafe.Pointer(bp + 240)), bp+256)
	}
	if v882 = v880 != TCL_OK; !v882 {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FinternalRep)) <= *(*TTcl_Size)(unsafe.Pointer(bp + 240)) {
			*(*TTcl_Size)(unsafe.Pointer(bp + 264)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FinternalRep))
			v881 = libc.Int32FromInt32(TCL_OK)
		} else {
			v881 = XTcl_GetIntForIndex(tls, interp4, *(*uintptr)(unsafe.Pointer(tosPtr)), *(*TTcl_Size)(unsafe.Pointer(bp + 240)), bp+264)
		}
	}
	if v882 || v881 != TCL_OK {
		checkInterp = int32(1)
		v884 = value3Ptr
		v883 = *(*TTcl_Size)(unsafe.Pointer(v884))
		*(*TTcl_Size)(unsafe.Pointer(v884))--
		if !(v883 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(value3Ptr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(value3Ptr)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(value3Ptr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(value3Ptr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(value3Ptr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(value3Ptr)).Flength = int64(-libc.Int32FromInt32(1))
				if v885 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v885 {
					cachePtr58 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v885 || ((*TAllocCache)(unsafe.Pointer(cachePtr58)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr58)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, value3Ptr)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(value3Ptr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr58)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr58)).FfirstObjPtr = value3Ptr
					(*TAllocCache)(unsafe.Pointer(cachePtr58)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, value3Ptr)
			}
		}
		goto gotError
	}
	checkInterp = int32(1)
	v887 = *(*uintptr)(unsafe.Pointer(tosPtr))
	v886 = *(*TTcl_Size)(unsafe.Pointer(v887))
	*(*TTcl_Size)(unsafe.Pointer(v887))--
	if !(v886 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Flength = int64(-libc.Int32FromInt32(1))
			if v888 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v888 {
				cachePtr59 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v888 || ((*TAllocCache)(unsafe.Pointer(cachePtr59)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr59)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(tosPtr)))
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr59)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr59)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(tosPtr))
				(*TAllocCache)(unsafe.Pointer(cachePtr59)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(tosPtr)))
		}
	}
	v889 = tosPtr
	tosPtr -= 8
	_ = *(*uintptr)(unsafe.Pointer(v889))
	v891 = *(*uintptr)(unsafe.Pointer(tosPtr))
	v890 = *(*TTcl_Size)(unsafe.Pointer(v891))
	*(*TTcl_Size)(unsafe.Pointer(v891))--
	if !(v890 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Flength = int64(-libc.Int32FromInt32(1))
			if v892 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v892 {
				cachePtr60 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v892 || ((*TAllocCache)(unsafe.Pointer(cachePtr60)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr60)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(tosPtr)))
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr60)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr60)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(tosPtr))
				(*TAllocCache)(unsafe.Pointer(cachePtr60)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(tosPtr)))
		}
	}
	v893 = tosPtr
	tosPtr -= 8
	_ = *(*uintptr)(unsafe.Pointer(v893))
	if *(*TTcl_Size)(unsafe.Pointer(bp + 264)) < 0 || *(*TTcl_Size)(unsafe.Pointer(bp + 256)) > *(*TTcl_Size)(unsafe.Pointer(bp + 240)) || *(*TTcl_Size)(unsafe.Pointer(bp + 264)) < *(*TTcl_Size)(unsafe.Pointer(bp + 256)) {
		v895 = value3Ptr
		v894 = *(*TTcl_Size)(unsafe.Pointer(v895))
		*(*TTcl_Size)(unsafe.Pointer(v895))--
		if !(v894 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(value3Ptr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(value3Ptr)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(value3Ptr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(value3Ptr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(value3Ptr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(value3Ptr)).Flength = int64(-libc.Int32FromInt32(1))
				if v896 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v896 {
					cachePtr61 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v896 || ((*TAllocCache)(unsafe.Pointer(cachePtr61)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr61)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, value3Ptr)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(value3Ptr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr61)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr61)).FfirstObjPtr = value3Ptr
					(*TAllocCache)(unsafe.Pointer(cachePtr61)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, value3Ptr)
			}
		}
		if true {
			if 0 != 0 {
				if 0 > 0 {
					v899 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v900 = tosPtr
					*(*uintptr)(unsafe.Pointer(v900)) = v899
					(*TTcl_Obj)(unsafe.Pointer(v899)).FrefCount++
				} else {
					tosPtr += 8
					v901 = tosPtr
					*(*uintptr)(unsafe.Pointer(v901)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(1))
			goto cleanup0
		} else {
			if 0 != 0 {
				if 0 > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _898
	_898:
		;
		goto _897
	_897: /**/ //
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp + 256)) < 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 256)) = 0
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp + 264)) > *(*TTcl_Size)(unsafe.Pointer(bp + 240)) {
		*(*TTcl_Size)(unsafe.Pointer(bp + 264)) = *(*TTcl_Size)(unsafe.Pointer(bp + 240))
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp + 256)) == 0 && *(*TTcl_Size)(unsafe.Pointer(bp + 264)) == *(*TTcl_Size)(unsafe.Pointer(bp + 240)) {
		v903 = *(*uintptr)(unsafe.Pointer(tosPtr))
		v902 = *(*TTcl_Size)(unsafe.Pointer(v903))
		*(*TTcl_Size)(unsafe.Pointer(v903))--
		if !(v902 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Flength = int64(-libc.Int32FromInt32(1))
				if v904 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v904 {
					cachePtr62 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v904 || ((*TAllocCache)(unsafe.Pointer(cachePtr62)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr62)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(tosPtr)))
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr62)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr62)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(tosPtr))
					(*TAllocCache)(unsafe.Pointer(cachePtr62)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(tosPtr)))
			}
		}
		*(*uintptr)(unsafe.Pointer(tosPtr)) = value3Ptr
		if true {
			if 0 != 0 {
				if 0 > 0 {
					v907 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v908 = tosPtr
					*(*uintptr)(unsafe.Pointer(v908)) = v907
					(*TTcl_Obj)(unsafe.Pointer(v907)).FrefCount++
				} else {
					tosPtr += 8
					v909 = tosPtr
					*(*uintptr)(unsafe.Pointer(v909)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(1))
			goto cleanup0
		} else {
			if 0 != 0 {
				if 0 > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _906
	_906:
		;
		goto _905
	_905: /**/
		//
	}
	*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclStringReplace(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 16)), *(*TTcl_Size)(unsafe.Pointer(bp + 256)), *(*TTcl_Size)(unsafe.Pointer(bp + 264))-*(*TTcl_Size)(unsafe.Pointer(bp + 256))+int64(1), value3Ptr, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1))
	if *(*uintptr)(unsafe.Pointer(bp + 8)) == value3Ptr {
		/* See [Bug 82e7f67325] */
		v911 = *(*uintptr)(unsafe.Pointer(tosPtr))
		v910 = *(*TTcl_Size)(unsafe.Pointer(v911))
		*(*TTcl_Size)(unsafe.Pointer(v911))--
		if !(v910 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Flength = int64(-libc.Int32FromInt32(1))
				if v912 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v912 {
					cachePtr63 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v912 || ((*TAllocCache)(unsafe.Pointer(cachePtr63)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr63)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(tosPtr)))
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr63)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr63)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(tosPtr))
					(*TAllocCache)(unsafe.Pointer(cachePtr63)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(tosPtr)))
			}
		}
		*(*uintptr)(unsafe.Pointer(tosPtr)) = value3Ptr
		if true {
			if 0 != 0 {
				if 0 > 0 {
					v915 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v916 = tosPtr
					*(*uintptr)(unsafe.Pointer(v916)) = v915
					(*TTcl_Obj)(unsafe.Pointer(v915)).FrefCount++
				} else {
					tosPtr += 8
					v917 = tosPtr
					*(*uintptr)(unsafe.Pointer(v917)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(1))
			goto cleanup0
		} else {
			if 0 != 0 {
				if 0 > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _914
	_914:
		;
		goto _913
	_913: /**/
		//
	}
	v919 = value3Ptr
	v918 = *(*TTcl_Size)(unsafe.Pointer(v919))
	*(*TTcl_Size)(unsafe.Pointer(v919))--
	if !(v918 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(value3Ptr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(value3Ptr)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(value3Ptr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(value3Ptr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(value3Ptr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(value3Ptr)).Flength = int64(-libc.Int32FromInt32(1))
			if v920 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v920 {
				cachePtr64 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v920 || ((*TAllocCache)(unsafe.Pointer(cachePtr64)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr64)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, value3Ptr)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(value3Ptr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr64)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr64)).FfirstObjPtr = value3Ptr
				(*TAllocCache)(unsafe.Pointer(cachePtr64)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, value3Ptr)
		}
	}
	if false {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v923 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v924 = tosPtr
				*(*uintptr)(unsafe.Pointer(v924)) = v923
				(*TTcl_Obj)(unsafe.Pointer(v923)).FrefCount++
			} else {
				tosPtr += 8
				v925 = tosPtr
				*(*uintptr)(unsafe.Pointer(v925)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _922
_922:
	;
	goto _921
_921: /**/
	; //
_180:
	;
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr))           /* "Main" string. */
	value3Ptr = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)) /* "Target" string. */
	value2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(2))*8)) /* "Source" string. */
	if value3Ptr == value2Ptr {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 16))
		goto doneStringMap
	} else {
		if *(*uintptr)(unsafe.Pointer(bp + 16)) == value2Ptr {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = value3Ptr
			goto doneStringMap
		}
	}
	ustring1 = XTcl_GetUnicodeFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), bp+240)
	if *(*TTcl_Size)(unsafe.Pointer(bp + 240)) == 0 {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 16))
		goto doneStringMap
	}
	ustring2 = XTcl_GetUnicodeFromObj(tls, value2Ptr, bp+248)
	if *(*TTcl_Size)(unsafe.Pointer(bp + 248)) > *(*TTcl_Size)(unsafe.Pointer(bp + 240)) || *(*TTcl_Size)(unsafe.Pointer(bp + 248)) == 0 {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 16))
		goto doneStringMap
	} else {
		if *(*TTcl_Size)(unsafe.Pointer(bp + 248)) == *(*TTcl_Size)(unsafe.Pointer(bp + 240)) {
			if libc.Xmemcmp(tls, ustring1, ustring2, uint64(4)*libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 240)))) != 0 {
				*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 16))
			} else {
				*(*uintptr)(unsafe.Pointer(bp + 8)) = value3Ptr
			}
			goto doneStringMap
		}
	}
	ustring3 = XTcl_GetUnicodeFromObj(tls, value3Ptr, bp+320)
	*(*uintptr)(unsafe.Pointer(bp + 8)) = XTcl_NewUnicodeObj(tls, ustring1, 0)
	p = ustring1
	end = ustring1 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 240)))*4
	for {
		if !(ustring1 < end) {
			break
		}
		if *(*TTcl_UniChar)(unsafe.Pointer(ustring1)) == *(*TTcl_UniChar)(unsafe.Pointer(ustring2)) && (int64(end)-int64(ustring1))/4 >= *(*TTcl_Size)(unsafe.Pointer(bp + 248)) && (*(*TTcl_Size)(unsafe.Pointer(bp + 248)) == int64(1) || libc.Xmemcmp(tls, ustring1, ustring2, uint64(4)*libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 248)))) == 0) {
			if p != ustring1 {
				XTcl_AppendUnicodeToObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), p, (int64(ustring1)-int64(p))/4)
				p = ustring1 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 248)))*4
			} else {
				p += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 248))) * 4
			}
			ustring1 = p - uintptr(1)*4
			XTcl_AppendUnicodeToObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), ustring3, *(*TTcl_Size)(unsafe.Pointer(bp + 320)))
		}
		goto _926
	_926:
		;
		ustring1 += 4
	}
	if p != ustring1 {
		/*
		 * Put the rest of the unmapped chars onto result.
		 */
		XTcl_AppendUnicodeToObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), p, (int64(ustring1)-int64(p))/4)
	}
	goto doneStringMap
doneStringMap:
	;
	pc += uintptr(libc.Int32FromInt32(1))
	cleanup = int32(3)
	if int32(1) != 0 {
		if int32(1) > 0 {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
		}
		goto cleanupV_pushObjResultPtr
	} else {
		goto cleanupV
	}
_181:
	;
	*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclStringFirst(tls, *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)), *(*uintptr)(unsafe.Pointer(tosPtr)), 0)
	if false {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v929 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v930 = tosPtr
				*(*uintptr)(unsafe.Pointer(v930)) = v929
				(*TTcl_Obj)(unsafe.Pointer(v929)).FrefCount++
			} else {
				tosPtr += 8
				v931 = tosPtr
				*(*uintptr)(unsafe.Pointer(v931)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _928
_928:
	;
	goto _927
_927: /**/
	; //
_182:
	;
	*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclStringLast(tls, *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)), *(*uintptr)(unsafe.Pointer(tosPtr)), libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))-libc.Int64FromInt32(1))
	if false {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v934 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v935 = tosPtr
				*(*uintptr)(unsafe.Pointer(v935)) = v934
				(*TTcl_Obj)(unsafe.Pointer(v934)).FrefCount++
			} else {
				tosPtr += 8
				v936 = tosPtr
				*(*uintptr)(unsafe.Pointer(v936)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _933
_933:
	;
	goto _932
_932: /**/
	; //
_183:
	;
	opnd = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr))
	ustring1 = XTcl_GetUnicodeFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), bp+240)
	*(*int32)(unsafe.Pointer(bp + 232)) = int32(1)
	if *(*TTcl_Size)(unsafe.Pointer(bp + 240)) > 0 {
		end = ustring1 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 240)))*4
		p = ustring1
		for {
			if !(p < end) {
				break
			}
			v938 = p
			p += 4
			ch1 = *(*TTcl_UniChar)(unsafe.Pointer(v938))
			if !((*(*func(*libc.TLS, int32) int32)(unsafe.Pointer(&struct{ uintptr }{XtclStringClassTable[opnd].Fcomparator})))(tls, ch1) != 0) {
				*(*int32)(unsafe.Pointer(bp + 232)) = 0
				break
			}
			goto _937
		_937:
		}
	}
	pc += uintptr(libc.Int32FromInt32(2))
	switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) {
	case int32(INST_JUMP_FALSE1):
		goto _941
	case int32(INST_JUMP_TRUE1):
		goto _942
	case int32(INST_JUMP_FALSE4):
		goto _943
	case int32(INST_JUMP_TRUE4):
		goto _944
	default:
		goto _945
	}
	goto _946
_941:
	;
_949:
	;
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v950 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v951 = tosPtr
				*(*uintptr)(unsafe.Pointer(v951)) = v950
				(*TTcl_Obj)(unsafe.Pointer(v950)).FrefCount++
			} else {
				tosPtr += 8
				v952 = tosPtr
				*(*uintptr)(unsafe.Pointer(v952)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
			v953 = int32(2)
		} else {
			v953 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
		}
		pc += uintptr(v953)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v954 = int32(2)
			} else {
				v954 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
			}
			pc += uintptr(v954)
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v955 = int32(2)
			} else {
				v955 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
			}
			pc += uintptr(v955)
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _948
_948:
	;
	if 0 != 0 {
		goto _949
	}
	goto _947
_947:
	;
	goto _946
_942:
	;
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v958 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v959 = tosPtr
				*(*uintptr)(unsafe.Pointer(v959)) = v958
				(*TTcl_Obj)(unsafe.Pointer(v958)).FrefCount++
			} else {
				tosPtr += 8
				v960 = tosPtr
				*(*uintptr)(unsafe.Pointer(v960)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
			v961 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
		} else {
			v961 = int32(2)
		}
		pc += uintptr(v961)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v962 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
			} else {
				v962 = int32(2)
			}
			pc += uintptr(v962)
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v963 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
			} else {
				v963 = int32(2)
			}
			pc += uintptr(v963)
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _957
_957:
	;
	goto _956
_956: /**/
	; //
	goto _946
_943:
	;
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v966 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v967 = tosPtr
				*(*uintptr)(unsafe.Pointer(v967)) = v966
				(*TTcl_Obj)(unsafe.Pointer(v966)).FrefCount++
			} else {
				tosPtr += 8
				v968 = tosPtr
				*(*uintptr)(unsafe.Pointer(v968)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
			v969 = int32(5)
		} else {
			v969 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
		}
		pc += uintptr(v969)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v970 = int32(5)
			} else {
				v970 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
			}
			pc += uintptr(v970)
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v971 = int32(5)
			} else {
				v971 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
			}
			pc += uintptr(v971)
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _965
_965:
	;
	goto _964
_964: /**/
	; //
	goto _946
_944:
	;
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v974 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v975 = tosPtr
				*(*uintptr)(unsafe.Pointer(v975)) = v974
				(*TTcl_Obj)(unsafe.Pointer(v974)).FrefCount++
			} else {
				tosPtr += 8
				v976 = tosPtr
				*(*uintptr)(unsafe.Pointer(v976)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
			v977 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
		} else {
			v977 = int32(5)
		}
		pc += uintptr(v977)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v978 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
			} else {
				v978 = int32(5)
			}
			pc += uintptr(v978)
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v979 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
			} else {
				v979 = int32(5)
			}
			pc += uintptr(v979)
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _973
_973:
	;
	goto _972
_972: /**/
	; //
	goto _946
_945:
	;
	if *(*int32)(unsafe.Pointer(bp + 232)) < 0 {
		if v980 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v980 {
			cachePtr65 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v980 || (*TAllocCache)(unsafe.Pointer(cachePtr65)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr65)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr65)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr65)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = libc.UintptrFromInt32(0)
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FinternalRep)) = int64(-libc.Int32FromInt32(1))
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	} else {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(constants + libc.BoolUintptr(*(*int32)(unsafe.Pointer(bp + 232)) > libc.Int32FromInt32(0))*8))
	}
	if false {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v983 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v984 = tosPtr
				*(*uintptr)(unsafe.Pointer(v984)) = v983
				(*TTcl_Obj)(unsafe.Pointer(v983)).FrefCount++
			} else {
				tosPtr += 8
				v985 = tosPtr
				*(*uintptr)(unsafe.Pointer(v985)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(0))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(0))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(0))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _982
_982:
	;
	goto _981
_981: /**/
	; //
	goto _946
_946:
	;
	goto _940
_940:
	;
	goto _939
_939: /**/
	; //
_184:
	;
	nocase = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr))           /* String */
	value2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)) /* Pattern */
	/*
	 * Check that at least one of the objects is Unicode before promoting
	 * both.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr == uintptr(unsafe.Pointer(&XtclStringType)) || (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr == uintptr(unsafe.Pointer(&XtclStringType)) {
		ustring11 = XTcl_GetUnicodeFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), bp+240)
		ustring21 = XTcl_GetUnicodeFromObj(tls, value2Ptr, bp+248)
		*(*int32)(unsafe.Pointer(bp + 232)) = XTclUniCharMatch(tls, ustring11, *(*TTcl_Size)(unsafe.Pointer(bp + 240)), ustring21, *(*TTcl_Size)(unsafe.Pointer(bp + 248)), nocase)
	} else {
		if XTclIsPureByteArray(tls, *(*uintptr)(unsafe.Pointer(bp + 16))) != 0 && XTclIsPureByteArray(tls, value2Ptr) != 0 && !(nocase != 0) {
			*(*TTcl_Size)(unsafe.Pointer(bp + 328)) = 0
			*(*TTcl_Size)(unsafe.Pointer(bp + 336)) = 0
			bytes11 = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 16)), bp+328)
			bytes2 = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), value2Ptr, bp+336)
			*(*int32)(unsafe.Pointer(bp + 232)) = XTclByteArrayMatch(tls, bytes11, *(*TTcl_Size)(unsafe.Pointer(bp + 328)), bytes2, *(*TTcl_Size)(unsafe.Pointer(bp + 336)), 0)
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 {
				v986 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes
			} else {
				v986 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), libc.UintptrFromInt32(0))
			}
			if (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes != 0 {
				v987 = (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes
			} else {
				v987 = XTcl_GetStringFromObj(tls, value2Ptr, libc.UintptrFromInt32(0))
			}
			*(*int32)(unsafe.Pointer(bp + 232)) = XTcl_StringCaseMatch(tls, v986, v987, nocase)
		}
	}
	/*
	 * Reuse value2Ptr object already on stack if possible. Adjustment is
	 * 2 due to the nocase byte
	 */
	/*
	 * Peep-hole optimisation: if you're about to jump, do jump from here.
	 */
	pc += uintptr(libc.Int32FromInt32(2))
	switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) {
	case int32(INST_JUMP_FALSE1):
		goto _990
	case int32(INST_JUMP_TRUE1):
		goto _991
	case int32(INST_JUMP_FALSE4):
		goto _992
	case int32(INST_JUMP_TRUE4):
		goto _993
	default:
		goto _994
	}
	goto _995
_990:
	;
_998:
	;
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v999 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1000 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1000)) = v999
				(*TTcl_Obj)(unsafe.Pointer(v999)).FrefCount++
			} else {
				tosPtr += 8
				v1001 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1001)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
			v1002 = int32(2)
		} else {
			v1002 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
		}
		pc += uintptr(v1002)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v1003 = int32(2)
			} else {
				v1003 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
			}
			pc += uintptr(v1003)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v1004 = int32(2)
			} else {
				v1004 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
			}
			pc += uintptr(v1004)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _997
_997:
	;
	if 0 != 0 {
		goto _998
	}
	goto _996
_996:
	;
	goto _995
_991:
	;
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v1007 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1008 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1008)) = v1007
				(*TTcl_Obj)(unsafe.Pointer(v1007)).FrefCount++
			} else {
				tosPtr += 8
				v1009 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1009)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
			v1010 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
		} else {
			v1010 = int32(2)
		}
		pc += uintptr(v1010)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v1011 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
			} else {
				v1011 = int32(2)
			}
			pc += uintptr(v1011)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v1012 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
			} else {
				v1012 = int32(2)
			}
			pc += uintptr(v1012)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1006
_1006:
	;
	goto _1005
_1005: /**/
	; //
	goto _995
_992:
	;
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v1015 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1016 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1016)) = v1015
				(*TTcl_Obj)(unsafe.Pointer(v1015)).FrefCount++
			} else {
				tosPtr += 8
				v1017 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1017)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
			v1018 = int32(5)
		} else {
			v1018 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
		}
		pc += uintptr(v1018)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v1019 = int32(5)
			} else {
				v1019 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
			}
			pc += uintptr(v1019)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v1020 = int32(5)
			} else {
				v1020 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
			}
			pc += uintptr(v1020)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1014
_1014:
	;
	goto _1013
_1013: /**/
	; //
	goto _995
_993:
	;
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v1023 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1024 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1024)) = v1023
				(*TTcl_Obj)(unsafe.Pointer(v1023)).FrefCount++
			} else {
				tosPtr += 8
				v1025 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1025)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
			v1026 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
		} else {
			v1026 = int32(5)
		}
		pc += uintptr(v1026)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v1027 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
			} else {
				v1027 = int32(5)
			}
			pc += uintptr(v1027)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v1028 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
			} else {
				v1028 = int32(5)
			}
			pc += uintptr(v1028)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1022
_1022:
	;
	goto _1021
_1021: /**/
	; //
	goto _995
_994:
	;
	if *(*int32)(unsafe.Pointer(bp + 232)) < 0 {
		if v1029 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1029 {
			cachePtr66 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1029 || (*TAllocCache)(unsafe.Pointer(cachePtr66)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr66)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr66)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr66)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = libc.UintptrFromInt32(0)
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FinternalRep)) = int64(-libc.Int32FromInt32(1))
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	} else {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(constants + libc.BoolUintptr(*(*int32)(unsafe.Pointer(bp + 232)) > libc.Int32FromInt32(0))*8))
	}
	if false {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v1032 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1033 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1033)) = v1032
				(*TTcl_Obj)(unsafe.Pointer(v1032)).FrefCount++
			} else {
				tosPtr += 8
				v1034 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1034)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(0))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(0))
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(0))
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1031
_1031:
	;
	goto _1030
_1030: /**/
	; //
	goto _995
_995:
	;
	goto _989
_989:
	;
	goto _988
_988: /**/
	; //
_185:
	;
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)) /* String */
	value2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr))                                                                 /* TrimSet */
	if (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 248)) = (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Flength
		v1035 = (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes
	} else {
		v1035 = XTcl_GetStringFromObj(tls, value2Ptr, bp+248)
	}
	string2 = v1035
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 240)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength
		v1036 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes
	} else {
		v1036 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), bp+240)
	}
	string1 = v1036
	trim1 = XTclTrimLeft(tls, string1, *(*TTcl_Size)(unsafe.Pointer(bp + 240)), string2, *(*TTcl_Size)(unsafe.Pointer(bp + 248)))
	*(*TTcl_Size)(unsafe.Pointer(bp + 344)) = 0
	goto createTrimmedString
_186:
	;
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)) /* String */
	value2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr))                                                                 /* TrimSet */
	if (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 248)) = (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Flength
		v1037 = (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes
	} else {
		v1037 = XTcl_GetStringFromObj(tls, value2Ptr, bp+248)
	}
	string2 = v1037
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 240)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength
		v1038 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes
	} else {
		v1038 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), bp+240)
	}
	string1 = v1038
	*(*TTcl_Size)(unsafe.Pointer(bp + 344)) = XTclTrimRight(tls, string1, *(*TTcl_Size)(unsafe.Pointer(bp + 240)), string2, *(*TTcl_Size)(unsafe.Pointer(bp + 248)))
	trim1 = 0
	goto createTrimmedString
_187:
	;
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)) /* String */
	value2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr))                                                                 /* TrimSet */
	if (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 248)) = (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Flength
		v1039 = (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes
	} else {
		v1039 = XTcl_GetStringFromObj(tls, value2Ptr, bp+248)
	}
	string2 = v1039
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 240)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength
		v1040 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes
	} else {
		v1040 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), bp+240)
	}
	string1 = v1040
	trim1 = XTclTrim(tls, string1, *(*TTcl_Size)(unsafe.Pointer(bp + 240)), string2, *(*TTcl_Size)(unsafe.Pointer(bp + 248)), bp+344)
	goto createTrimmedString
createTrimmedString:
	;
	/*
	 * Careful here; trim set often contains non-ASCII characters so we
	 * take care when printing. [Bug 971cb4f1db]
	 */
	if trim1 == 0 && *(*TTcl_Size)(unsafe.Pointer(bp + 344)) == 0 {
		if false {
			if 0 != 0 {
				if 0 > 0 {
					v1043 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v1044 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1044)) = v1043
					(*TTcl_Obj)(unsafe.Pointer(v1043)).FrefCount++
				} else {
					tosPtr += 8
					v1045 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1045)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(1))
			goto cleanup0
		} else {
			if 0 != 0 {
				if 0 > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(1) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(1) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _1042
	_1042:
		;
		goto _1041
	_1041: /**/ //
	} else {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = XTcl_NewStringObj(tls, string1+uintptr(trim1), *(*TTcl_Size)(unsafe.Pointer(bp + 240))-trim1-*(*TTcl_Size)(unsafe.Pointer(bp + 344)))
		if false {
			if int32(1) != 0 {
				if int32(1) > 0 {
					v1048 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v1049 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1049)) = v1048
					(*TTcl_Obj)(unsafe.Pointer(v1048)).FrefCount++
				} else {
					tosPtr += 8
					v1050 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1050)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(1))
			goto cleanup0
		} else {
			if int32(1) != 0 {
				if int32(1) > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(2) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(2) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _1047
	_1047:
		;
		goto _1046
	_1046: /**/
		//
	}
_188:
	;
	cflags = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))              /* RE compile flages like NOCASE */
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr))           /* String */
	value2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)) /* Pattern */
	/*
	 * Compile and match the regular expression.
	 */
	regExpr = XTcl_GetRegExpFromObj(tls, interp4, value2Ptr, cflags)
	if regExpr == libc.UintptrFromInt32(0) {
		goto gotError
	}
	*(*int32)(unsafe.Pointer(bp + 232)) = XTcl_RegExpExecObj(tls, interp4, regExpr, *(*uintptr)(unsafe.Pointer(bp + 16)), 0, 0, 0)
	if *(*int32)(unsafe.Pointer(bp + 232)) < 0 {
		goto gotError
	}
	/*
	 * Peep-hole optimisation: if you're about to jump, do jump from here.
	 * Adjustment is 2 due to the nocase byte.
	 */
	pc += uintptr(libc.Int32FromInt32(2))
	switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) {
	case int32(INST_JUMP_FALSE1):
		goto _1053
	case int32(INST_JUMP_TRUE1):
		goto _1054
	case int32(INST_JUMP_FALSE4):
		goto _1055
	case int32(INST_JUMP_TRUE4):
		goto _1056
	default:
		goto _1057
	}
	goto _1058
_1053:
	;
_1061:
	;
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v1062 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1063 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1063)) = v1062
				(*TTcl_Obj)(unsafe.Pointer(v1062)).FrefCount++
			} else {
				tosPtr += 8
				v1064 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1064)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
			v1065 = int32(2)
		} else {
			v1065 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
		}
		pc += uintptr(v1065)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v1066 = int32(2)
			} else {
				v1066 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
			}
			pc += uintptr(v1066)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v1067 = int32(2)
			} else {
				v1067 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
			}
			pc += uintptr(v1067)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1060
_1060:
	;
	if 0 != 0 {
		goto _1061
	}
	goto _1059
_1059:
	;
	goto _1058
_1054:
	;
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v1070 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1071 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1071)) = v1070
				(*TTcl_Obj)(unsafe.Pointer(v1070)).FrefCount++
			} else {
				tosPtr += 8
				v1072 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1072)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
			v1073 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
		} else {
			v1073 = int32(2)
		}
		pc += uintptr(v1073)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v1074 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
			} else {
				v1074 = int32(2)
			}
			pc += uintptr(v1074)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v1075 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
			} else {
				v1075 = int32(2)
			}
			pc += uintptr(v1075)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1069
_1069:
	;
	goto _1068
_1068: /**/
	; //
	goto _1058
_1055:
	;
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v1078 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1079 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1079)) = v1078
				(*TTcl_Obj)(unsafe.Pointer(v1078)).FrefCount++
			} else {
				tosPtr += 8
				v1080 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1080)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
			v1081 = int32(5)
		} else {
			v1081 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
		}
		pc += uintptr(v1081)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v1082 = int32(5)
			} else {
				v1082 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
			}
			pc += uintptr(v1082)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v1083 = int32(5)
			} else {
				v1083 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
			}
			pc += uintptr(v1083)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1077
_1077:
	;
	goto _1076
_1076: /**/
	; //
	goto _1058
_1056:
	;
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v1086 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1087 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1087)) = v1086
				(*TTcl_Obj)(unsafe.Pointer(v1086)).FrefCount++
			} else {
				tosPtr += 8
				v1088 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1088)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
			v1089 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
		} else {
			v1089 = int32(5)
		}
		pc += uintptr(v1089)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v1090 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
			} else {
				v1090 = int32(5)
			}
			pc += uintptr(v1090)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 232)) != 0 {
				v1091 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
			} else {
				v1091 = int32(5)
			}
			pc += uintptr(v1091)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1085
_1085:
	;
	goto _1084
_1084: /**/
	; //
	goto _1058
_1057:
	;
	if *(*int32)(unsafe.Pointer(bp + 232)) < 0 {
		if v1092 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1092 {
			cachePtr67 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1092 || (*TAllocCache)(unsafe.Pointer(cachePtr67)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr67)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr67)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr67)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = libc.UintptrFromInt32(0)
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FinternalRep)) = int64(-libc.Int32FromInt32(1))
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	} else {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(constants + libc.BoolUintptr(*(*int32)(unsafe.Pointer(bp + 232)) > libc.Int32FromInt32(0))*8))
	}
	if false {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v1095 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1096 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1096)) = v1095
				(*TTcl_Obj)(unsafe.Pointer(v1095)).FrefCount++
			} else {
				tosPtr += 8
				v1097 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1097)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(0))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(0))
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(0))
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1094
_1094:
	;
	goto _1093
_1093: /**/
	; //
	goto _1058
_1058:
	;
	goto _1052
_1052:
	;
	goto _1051
_1051: /**/
	; //
	/*
	 *	   End of string-related instructions.
	 * -----------------------------------------------------------------
	 *	   Start of numeric operator instructions.
	 */
_189:
	;
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*int32)(unsafe.Pointer(bp + 368)) = int32(TCL_NUMBER_INT)
		*(*uintptr)(unsafe.Pointer(bp + 352)) = *(*uintptr)(unsafe.Pointer(tosPtr)) + 32
		v1098 = libc.Int32FromInt32(TCL_OK)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
			*(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FinternalRep))
			v1101 = *(*uint64)(unsafe.Pointer(bp))
			goto _1102
		_1102:
			if libc.BoolInt32(v1101&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) > libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
				*(*int32)(unsafe.Pointer(bp + 368)) = int32(TCL_NUMBER_NAN)
			} else {
				*(*int32)(unsafe.Pointer(bp + 368)) = int32(TCL_NUMBER_DOUBLE)
			}
			*(*uintptr)(unsafe.Pointer(bp + 352)) = *(*uintptr)(unsafe.Pointer(tosPtr)) + 32
			v1099 = libc.Int32FromInt32(TCL_OK)
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Fbytes != libc.UintptrFromInt32(0) && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Flength == 0 {
				v1103 = int32(TCL_ERROR)
			} else {
				v1103 = XTcl_GetNumberFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(tosPtr)), bp+352, bp+368)
			}
			v1099 = v1103
		}
		v1098 = v1099
	}
	if v1098 != TCL_OK {
		*(*int32)(unsafe.Pointer(bp + 368)) = 0
	}
	if v1104 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1104 {
		cachePtr68 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1104 || (*TAllocCache)(unsafe.Pointer(cachePtr68)).FnumObjects == libc.Uint64FromInt32(0) {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
	} else {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr68)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr68)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr68)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = libc.UintptrFromInt32(0)
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FinternalRep)) = int64(*(*int32)(unsafe.Pointer(bp + 368)))
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	if false {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v1107 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1108 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1108)) = v1107
				(*TTcl_Obj)(unsafe.Pointer(v1107)).FrefCount++
			} else {
				tosPtr += 8
				v1109 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1109)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1106
_1106:
	;
	goto _1105
_1105: /**/
	; //
_195:
	;
_194:
	;
_193:
	;
_192:
	;
_191:
	;
_190:
	;
	iResult = 0
	compare = 0
	value2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr))
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8))
	/*
	   Try to determine, without triggering generation of a string
	   representation, whether one value is not a number.
	*/
	if XTclCheckEmptyString(tls, *(*uintptr)(unsafe.Pointer(bp + 16))) > 0 || XTclCheckEmptyString(tls, value2Ptr) > 0 {
		goto stringCompare
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*int32)(unsafe.Pointer(bp + 368)) = int32(TCL_NUMBER_INT)
		*(*uintptr)(unsafe.Pointer(bp + 352)) = *(*uintptr)(unsafe.Pointer(bp + 16)) + 32
		v1110 = libc.Int32FromInt32(TCL_OK)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
			*(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FinternalRep))
			v1113 = *(*uint64)(unsafe.Pointer(bp))
			goto _1114
		_1114:
			if libc.BoolInt32(v1113&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) > libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
				*(*int32)(unsafe.Pointer(bp + 368)) = int32(TCL_NUMBER_NAN)
			} else {
				*(*int32)(unsafe.Pointer(bp + 368)) = int32(TCL_NUMBER_DOUBLE)
			}
			*(*uintptr)(unsafe.Pointer(bp + 352)) = *(*uintptr)(unsafe.Pointer(bp + 16)) + 32
			v1111 = libc.Int32FromInt32(TCL_OK)
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != libc.UintptrFromInt32(0) && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength == 0 {
				v1115 = int32(TCL_ERROR)
			} else {
				v1115 = XTcl_GetNumberFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 16)), bp+352, bp+368)
			}
			v1111 = v1115
		}
		v1110 = v1111
	}
	if v1122 = v1110 != TCL_OK; !v1122 {
		if (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
			*(*int32)(unsafe.Pointer(bp + 372)) = int32(TCL_NUMBER_INT)
			*(*uintptr)(unsafe.Pointer(bp + 360)) = value2Ptr + 32
			v1116 = libc.Int32FromInt32(TCL_OK)
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
				*(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FinternalRep))
				v1119 = *(*uint64)(unsafe.Pointer(bp))
				goto _1120
			_1120:
				if libc.BoolInt32(v1119&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) > libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
					*(*int32)(unsafe.Pointer(bp + 372)) = int32(TCL_NUMBER_NAN)
				} else {
					*(*int32)(unsafe.Pointer(bp + 372)) = int32(TCL_NUMBER_DOUBLE)
				}
				*(*uintptr)(unsafe.Pointer(bp + 360)) = value2Ptr + 32
				v1117 = libc.Int32FromInt32(TCL_OK)
			} else {
				if (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes != libc.UintptrFromInt32(0) && (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Flength == 0 {
					v1121 = int32(TCL_ERROR)
				} else {
					v1121 = XTcl_GetNumberFromObj(tls, libc.UintptrFromInt32(0), value2Ptr, bp+360, bp+372)
				}
				v1117 = v1121
			}
			v1116 = v1117
		}
	}
	if v1122 || v1116 != TCL_OK {
		/*
		 * At least one non-numeric argument - compare as strings.
		 */
		goto stringCompare
	}
	if *(*int32)(unsafe.Pointer(bp + 368)) == int32(TCL_NUMBER_NAN) || *(*int32)(unsafe.Pointer(bp + 372)) == int32(TCL_NUMBER_NAN) {
		/*
		 * NaN arg: NaN != to everything, other compares are false.
		 */
		iResult = libc.BoolInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) == int32(INST_NEQ))
		goto foundResult
	}
	if *(*uintptr)(unsafe.Pointer(bp + 16)) == value2Ptr {
		compare = MP_EQ
		goto convertComparison
	}
	if *(*int32)(unsafe.Pointer(bp + 368)) == int32(TCL_NUMBER_INT) && *(*int32)(unsafe.Pointer(bp + 372)) == int32(TCL_NUMBER_INT) {
		w1 = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 352))))
		w2 = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 360))))
		if w1 < w2 {
			v1123 = -int32(1)
		} else {
			if w1 > w2 {
				v1124 = int32(MP_GT)
			} else {
				v1124 = MP_EQ
			}
			v1123 = v1124
		}
		compare = v1123
	} else {
		compare = XTclCompareTwoNumbers(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), value2Ptr)
	}
	/*
	 * Turn comparison outcome into appropriate result for opcode.
	 */
	goto convertComparison
convertComparison:
	;
	switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) {
	case int32(INST_EQ):
		iResult = libc.BoolInt32(compare == MP_EQ)
	case int32(INST_NEQ):
		iResult = libc.BoolInt32(compare != MP_EQ)
	case int32(INST_LT):
		iResult = libc.BoolInt32(compare == -int32(1))
	case int32(INST_GT):
		iResult = libc.BoolInt32(compare == int32(MP_GT))
	case int32(INST_LE):
		iResult = libc.BoolInt32(compare != int32(MP_GT))
	case int32(INST_GE):
		iResult = libc.BoolInt32(compare != -int32(1))
		break
	}
	/*
	 * Peep-hole optimisation: if you're about to jump, do jump from here.
	 */
	goto foundResult
foundResult:
	;
	pc += uintptr(libc.Int32FromInt32(1))
	switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) {
	case int32(INST_JUMP_FALSE1):
		goto _1127
	case int32(INST_JUMP_TRUE1):
		goto _1128
	case int32(INST_JUMP_FALSE4):
		goto _1129
	case int32(INST_JUMP_TRUE4):
		goto _1130
	default:
		goto _1131
	}
	goto _1132
_1127:
	;
_1135:
	;
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v1136 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1137 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1137)) = v1136
				(*TTcl_Obj)(unsafe.Pointer(v1136)).FrefCount++
			} else {
				tosPtr += 8
				v1138 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1138)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		if iResult != 0 {
			v1139 = int32(2)
		} else {
			v1139 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
		}
		pc += uintptr(v1139)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			if iResult != 0 {
				v1140 = int32(2)
			} else {
				v1140 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
			}
			pc += uintptr(v1140)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			if iResult != 0 {
				v1141 = int32(2)
			} else {
				v1141 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
			}
			pc += uintptr(v1141)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1134
_1134:
	;
	if 0 != 0 {
		goto _1135
	}
	goto _1133
_1133:
	;
	goto _1132
_1128:
	;
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v1144 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1145 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1145)) = v1144
				(*TTcl_Obj)(unsafe.Pointer(v1144)).FrefCount++
			} else {
				tosPtr += 8
				v1146 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1146)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		if iResult != 0 {
			v1147 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
		} else {
			v1147 = int32(2)
		}
		pc += uintptr(v1147)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			if iResult != 0 {
				v1148 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
			} else {
				v1148 = int32(2)
			}
			pc += uintptr(v1148)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			if iResult != 0 {
				v1149 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
			} else {
				v1149 = int32(2)
			}
			pc += uintptr(v1149)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1143
_1143:
	;
	goto _1142
_1142: /**/
	; //
	goto _1132
_1129:
	;
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v1152 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1153 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1153)) = v1152
				(*TTcl_Obj)(unsafe.Pointer(v1152)).FrefCount++
			} else {
				tosPtr += 8
				v1154 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1154)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		if iResult != 0 {
			v1155 = int32(5)
		} else {
			v1155 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
		}
		pc += uintptr(v1155)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			if iResult != 0 {
				v1156 = int32(5)
			} else {
				v1156 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
			}
			pc += uintptr(v1156)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			if iResult != 0 {
				v1157 = int32(5)
			} else {
				v1157 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
			}
			pc += uintptr(v1157)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1151
_1151:
	;
	goto _1150
_1150: /**/
	; //
	goto _1132
_1130:
	;
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v1160 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1161 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1161)) = v1160
				(*TTcl_Obj)(unsafe.Pointer(v1160)).FrefCount++
			} else {
				tosPtr += 8
				v1162 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1162)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		if iResult != 0 {
			v1163 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
		} else {
			v1163 = int32(5)
		}
		pc += uintptr(v1163)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			if iResult != 0 {
				v1164 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
			} else {
				v1164 = int32(5)
			}
			pc += uintptr(v1164)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			if iResult != 0 {
				v1165 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
			} else {
				v1165 = int32(5)
			}
			pc += uintptr(v1165)
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1159
_1159:
	;
	goto _1158
_1158: /**/
	; //
	goto _1132
_1131:
	;
	if iResult < 0 {
		if v1166 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1166 {
			cachePtr69 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1166 || (*TAllocCache)(unsafe.Pointer(cachePtr69)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr69)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr69)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr69)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = libc.UintptrFromInt32(0)
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FinternalRep)) = int64(-libc.Int32FromInt32(1))
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	} else {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(constants + libc.BoolUintptr(iResult > libc.Int32FromInt32(0))*8))
	}
	if false {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v1169 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1170 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1170)) = v1169
				(*TTcl_Obj)(unsafe.Pointer(v1169)).FrefCount++
			} else {
				tosPtr += 8
				v1171 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1171)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(0))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(0))
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(0))
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1168
_1168:
	;
	goto _1167
_1167: /**/
	; //
	goto _1132
_1132:
	;
	goto _1126
_1126:
	;
	goto _1125
_1125: /**/
	; //
_201:
	;
_200:
	;
_199:
	;
_198:
	;
_197:
	;
_196:
	;
	value2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr))
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8))
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*int32)(unsafe.Pointer(bp + 368)) = int32(TCL_NUMBER_INT)
		*(*uintptr)(unsafe.Pointer(bp + 352)) = *(*uintptr)(unsafe.Pointer(bp + 16)) + 32
		v1172 = libc.Int32FromInt32(TCL_OK)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
			*(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FinternalRep))
			v1175 = *(*uint64)(unsafe.Pointer(bp))
			goto _1176
		_1176:
			if libc.BoolInt32(v1175&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) > libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
				*(*int32)(unsafe.Pointer(bp + 368)) = int32(TCL_NUMBER_NAN)
			} else {
				*(*int32)(unsafe.Pointer(bp + 368)) = int32(TCL_NUMBER_DOUBLE)
			}
			*(*uintptr)(unsafe.Pointer(bp + 352)) = *(*uintptr)(unsafe.Pointer(bp + 16)) + 32
			v1173 = libc.Int32FromInt32(TCL_OK)
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != libc.UintptrFromInt32(0) && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength == 0 {
				v1177 = int32(TCL_ERROR)
			} else {
				v1177 = XTcl_GetNumberFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 16)), bp+352, bp+368)
			}
			v1173 = v1177
		}
		v1172 = v1173
	}
	if v1172 != TCL_OK || *(*int32)(unsafe.Pointer(bp + 368)) == int32(TCL_NUMBER_DOUBLE) || *(*int32)(unsafe.Pointer(bp + 368)) == int32(TCL_NUMBER_NAN) {
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		_IllegalExprOperandType(tls, interp4, __ccgo_ts+32665, pc, *(*uintptr)(unsafe.Pointer(bp + 16)))
		checkInterp = int32(1)
		goto gotError
	}
	if (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*int32)(unsafe.Pointer(bp + 372)) = int32(TCL_NUMBER_INT)
		*(*uintptr)(unsafe.Pointer(bp + 360)) = value2Ptr + 32
		v1178 = libc.Int32FromInt32(TCL_OK)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
			*(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FinternalRep))
			v1181 = *(*uint64)(unsafe.Pointer(bp))
			goto _1182
		_1182:
			if libc.BoolInt32(v1181&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) > libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
				*(*int32)(unsafe.Pointer(bp + 372)) = int32(TCL_NUMBER_NAN)
			} else {
				*(*int32)(unsafe.Pointer(bp + 372)) = int32(TCL_NUMBER_DOUBLE)
			}
			*(*uintptr)(unsafe.Pointer(bp + 360)) = value2Ptr + 32
			v1179 = libc.Int32FromInt32(TCL_OK)
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes != libc.UintptrFromInt32(0) && (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Flength == 0 {
				v1183 = int32(TCL_ERROR)
			} else {
				v1183 = XTcl_GetNumberFromObj(tls, libc.UintptrFromInt32(0), value2Ptr, bp+360, bp+372)
			}
			v1179 = v1183
		}
		v1178 = v1179
	}
	if v1178 != TCL_OK || *(*int32)(unsafe.Pointer(bp + 372)) == int32(TCL_NUMBER_DOUBLE) || *(*int32)(unsafe.Pointer(bp + 372)) == int32(TCL_NUMBER_NAN) {
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		_IllegalExprOperandType(tls, interp4, __ccgo_ts+32671, pc, value2Ptr)
		checkInterp = int32(1)
		goto gotError
	}
	/*
	 * Check for common, simple case.
	 */
	if *(*int32)(unsafe.Pointer(bp + 368)) == int32(TCL_NUMBER_INT) && *(*int32)(unsafe.Pointer(bp + 372)) == int32(TCL_NUMBER_INT) {
		w1 = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 352))))
		w2 = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 360))))
		switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) {
		case int32(INST_MOD):
			if w2 == 0 {
				goto divideByZero
			} else {
				if w2 == int64(1) || w2 == int64(-int32(1)) {
					/*
					 * Div. by |1| always yields remainder of 0.
					 */
					*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(constants))
					if false {
						if int32(1) != 0 {
							if int32(1) > 0 {
								v1186 = *(*uintptr)(unsafe.Pointer(bp + 8))
								tosPtr += 8
								v1187 = tosPtr
								*(*uintptr)(unsafe.Pointer(v1187)) = v1186
								(*TTcl_Obj)(unsafe.Pointer(v1186)).FrefCount++
							} else {
								tosPtr += 8
								v1188 = tosPtr
								*(*uintptr)(unsafe.Pointer(v1188)) = *(*uintptr)(unsafe.Pointer(bp + 8))
							}
						}
						pc += uintptr(libc.Int32FromInt32(1))
						goto cleanup0
					} else {
						if int32(1) != 0 {
							if int32(1) > 0 {
								(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
							}
							pc += uintptr(libc.Int32FromInt32(1))
							switch libc.Int32FromInt32(2) {
							case int32(1):
								goto cleanup1_pushObjResultPtr
							case int32(2):
								goto cleanup2_pushObjResultPtr
							case 0:
								break
							}
						} else {
							pc += uintptr(libc.Int32FromInt32(1))
							switch libc.Int32FromInt32(2) {
							case int32(1):
								goto cleanup1
							case int32(2):
								goto cleanup2
							case 0:
								break
							}
						}
					}
					goto _1185
				_1185:
					;
					goto _1184
				_1184: /**/
					//
				} else {
					if w1 == 0 {
						/*
						 * 0 % (non-zero) always yields remainder of 0.
						 */
						*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(constants))
						if false {
							if int32(1) != 0 {
								if int32(1) > 0 {
									v1191 = *(*uintptr)(unsafe.Pointer(bp + 8))
									tosPtr += 8
									v1192 = tosPtr
									*(*uintptr)(unsafe.Pointer(v1192)) = v1191
									(*TTcl_Obj)(unsafe.Pointer(v1191)).FrefCount++
								} else {
									tosPtr += 8
									v1193 = tosPtr
									*(*uintptr)(unsafe.Pointer(v1193)) = *(*uintptr)(unsafe.Pointer(bp + 8))
								}
							}
							pc += uintptr(libc.Int32FromInt32(1))
							goto cleanup0
						} else {
							if int32(1) != 0 {
								if int32(1) > 0 {
									(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
								}
								pc += uintptr(libc.Int32FromInt32(1))
								switch libc.Int32FromInt32(2) {
								case int32(1):
									goto cleanup1_pushObjResultPtr
								case int32(2):
									goto cleanup2_pushObjResultPtr
								case 0:
									break
								}
							} else {
								pc += uintptr(libc.Int32FromInt32(1))
								switch libc.Int32FromInt32(2) {
								case int32(1):
									goto cleanup1
								case int32(2):
									goto cleanup2
								case 0:
									break
								}
							}
						}
						goto _1190
					_1190:
						;
						goto _1189
					_1189: /**/
						//
					} else {
						wResult = w1 / w2
						/*
						 * Force Tcl's integer division rules.
						 * TODO: examine for logic simplification
						 */
						if (wResult < 0 || wResult == 0 && (w1 < 0 && w2 > 0 || w1 > 0 && w2 < 0)) && wResult*w2 != w1 {
							wResult -= int64(1)
						}
						wResult = libc.Int64FromUint64(libc.Uint64FromInt64(w1) - libc.Uint64FromInt64(w2)*libc.Uint64FromInt64(wResult))
						goto wideResultOfArithmetic
					}
				}
			}
		case int32(INST_RSHIFT):
			if w2 < 0 {
				XTcl_SetObjResult(tls, interp4, XTcl_NewStringObj(tls, __ccgo_ts+32678, int64(-int32(1))))
				goto gotError
			} else {
				if w1 == 0 {
					*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(constants))
					if false {
						if int32(1) != 0 {
							if int32(1) > 0 {
								v1196 = *(*uintptr)(unsafe.Pointer(bp + 8))
								tosPtr += 8
								v1197 = tosPtr
								*(*uintptr)(unsafe.Pointer(v1197)) = v1196
								(*TTcl_Obj)(unsafe.Pointer(v1196)).FrefCount++
							} else {
								tosPtr += 8
								v1198 = tosPtr
								*(*uintptr)(unsafe.Pointer(v1198)) = *(*uintptr)(unsafe.Pointer(bp + 8))
							}
						}
						pc += uintptr(libc.Int32FromInt32(1))
						goto cleanup0
					} else {
						if int32(1) != 0 {
							if int32(1) > 0 {
								(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
							}
							pc += uintptr(libc.Int32FromInt32(1))
							switch libc.Int32FromInt32(2) {
							case int32(1):
								goto cleanup1_pushObjResultPtr
							case int32(2):
								goto cleanup2_pushObjResultPtr
							case 0:
								break
							}
						} else {
							pc += uintptr(libc.Int32FromInt32(1))
							switch libc.Int32FromInt32(2) {
							case int32(1):
								goto cleanup1
							case int32(2):
								goto cleanup2
							case 0:
								break
							}
						}
					}
					goto _1195
				_1195:
					;
					goto _1194
				_1194: /**/
					//
				} else {
					/*
					 * Quickly force large right shifts to 0 or -1.
					 */
					if w2 >= libc.Int64FromUint64(libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8)) {
						/*
						 * We assume that INT_MAX is much larger than the
						 * number of bits in a Tcl_WideInt. This is a pretty safe
						 * assumption, given that the former is usually around
						 * 4e9 and the latter 64...
						 */
						if w1 > 0 {
							*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(constants))
						} else {
							if v1199 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1199 {
								cachePtr70 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
							}
							if v1199 || (*TAllocCache)(unsafe.Pointer(cachePtr70)).FnumObjects == libc.Uint64FromInt32(0) {
								*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
							} else {
								*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr70)).FfirstObjPtr
								(*TAllocCache)(unsafe.Pointer(cachePtr70)).FfirstObjPtr = (*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
								(*TAllocCache)(unsafe.Pointer(cachePtr70)).FnumObjects--
							}
							(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
							(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = libc.UintptrFromInt32(0)
							*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FinternalRep)) = int64(-libc.Int32FromInt32(1))
							(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
						}
						if false {
							if int32(1) != 0 {
								if int32(1) > 0 {
									v1202 = *(*uintptr)(unsafe.Pointer(bp + 8))
									tosPtr += 8
									v1203 = tosPtr
									*(*uintptr)(unsafe.Pointer(v1203)) = v1202
									(*TTcl_Obj)(unsafe.Pointer(v1202)).FrefCount++
								} else {
									tosPtr += 8
									v1204 = tosPtr
									*(*uintptr)(unsafe.Pointer(v1204)) = *(*uintptr)(unsafe.Pointer(bp + 8))
								}
							}
							pc += uintptr(libc.Int32FromInt32(1))
							goto cleanup0
						} else {
							if int32(1) != 0 {
								if int32(1) > 0 {
									(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
								}
								pc += uintptr(libc.Int32FromInt32(1))
								switch libc.Int32FromInt32(2) {
								case int32(1):
									goto cleanup1_pushObjResultPtr
								case int32(2):
									goto cleanup2_pushObjResultPtr
								case 0:
									break
								}
							} else {
								pc += uintptr(libc.Int32FromInt32(1))
								switch libc.Int32FromInt32(2) {
								case int32(1):
									goto cleanup1
								case int32(2):
									goto cleanup2
								case 0:
									break
								}
							}
						}
						goto _1201
					_1201:
						;
						goto _1200
					_1200: /**/ //
					}
					/*
					 * Handle shifts within the native Tcl_WideInt range.
					 */
					wResult = w1 >> int32(w2)
					goto wideResultOfArithmetic
				}
			}
		case int32(INST_LSHIFT):
			if w2 < 0 {
				XTcl_SetObjResult(tls, interp4, XTcl_NewStringObj(tls, __ccgo_ts+32678, int64(-int32(1))))
				goto gotError
			} else {
				if w1 == 0 {
					*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(constants))
					if false {
						if int32(1) != 0 {
							if int32(1) > 0 {
								v1207 = *(*uintptr)(unsafe.Pointer(bp + 8))
								tosPtr += 8
								v1208 = tosPtr
								*(*uintptr)(unsafe.Pointer(v1208)) = v1207
								(*TTcl_Obj)(unsafe.Pointer(v1207)).FrefCount++
							} else {
								tosPtr += 8
								v1209 = tosPtr
								*(*uintptr)(unsafe.Pointer(v1209)) = *(*uintptr)(unsafe.Pointer(bp + 8))
							}
						}
						pc += uintptr(libc.Int32FromInt32(1))
						goto cleanup0
					} else {
						if int32(1) != 0 {
							if int32(1) > 0 {
								(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
							}
							pc += uintptr(libc.Int32FromInt32(1))
							switch libc.Int32FromInt32(2) {
							case int32(1):
								goto cleanup1_pushObjResultPtr
							case int32(2):
								goto cleanup2_pushObjResultPtr
							case 0:
								break
							}
						} else {
							pc += uintptr(libc.Int32FromInt32(1))
							switch libc.Int32FromInt32(2) {
							case int32(1):
								goto cleanup1
							case int32(2):
								goto cleanup2
							case 0:
								break
							}
						}
					}
					goto _1206
				_1206:
					;
					goto _1205
				_1205: /**/
					//
				} else {
					if w2 > int64(INT_MAX) {
						/*
						 * Technically, we could hold the value (1 << (INT_MAX+1))
						 * in an mp_int, but since we're using mp_mul_2d() to do
						 * the work, and it takes only an int argument, that's a
						 * good place to draw the line.
						 */
						XTcl_SetObjResult(tls, interp4, XTcl_NewStringObj(tls, __ccgo_ts+11737, int64(-int32(1))))
						goto gotError
					} else {
						shift = int32(w2)
						/*
						 * Handle shifts within the native Tcl_WideInt range.
						 */
						if v1211 = libc.Uint64FromInt32(shift) < libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8); v1211 {
							if w1 > 0 {
								v1210 = w1
							} else {
								v1210 = ^w1
							}
						}
						if v1211 && !(libc.Uint64FromInt64(v1210)&-(libc.Uint64FromInt32(1)<<(libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)-libc.Uint64FromInt32(shift))) != 0) {
							wResult = libc.Int64FromUint64(libc.Uint64FromInt64(w1) << shift)
							goto wideResultOfArithmetic
						}
					}
				}
			}
			/*
			 * Too large; need to use the broken-out function.
			 */
		case int32(INST_BITAND):
			wResult = w1 & w2
			goto wideResultOfArithmetic
		case int32(INST_BITOR):
			wResult = w1 | w2
			goto wideResultOfArithmetic
		case int32(INST_BITXOR):
			wResult = w1 ^ w2
			goto wideResultOfArithmetic
		}
	}
	/*
	 * DO NOT MERGE THIS WITH THE EQUIVALENT SECTION LATER! That would
	 * encourage the compiler to inline ExecuteExtendedBinaryMathOp, which
	 * is highly undesirable due to the overall impact on size.
	 */
	*(*uintptr)(unsafe.Pointer(bp + 8)) = _ExecuteExtendedBinaryMathOp(tls, interp4, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))), constants, *(*uintptr)(unsafe.Pointer(bp + 16)), value2Ptr)
	if *(*uintptr)(unsafe.Pointer(bp + 8)) == uintptr(-libc.Int32FromInt32(1)) {
		goto divideByZero
	} else {
		if *(*uintptr)(unsafe.Pointer(bp + 8)) == uintptr(-libc.Int32FromInt32(3)) {
			goto gotError
		} else {
			if *(*uintptr)(unsafe.Pointer(bp + 8)) == libc.UintptrFromInt32(0) {
				if false {
					if 0 != 0 {
						if 0 > 0 {
							v1214 = *(*uintptr)(unsafe.Pointer(bp + 8))
							tosPtr += 8
							v1215 = tosPtr
							*(*uintptr)(unsafe.Pointer(v1215)) = v1214
							(*TTcl_Obj)(unsafe.Pointer(v1214)).FrefCount++
						} else {
							tosPtr += 8
							v1216 = tosPtr
							*(*uintptr)(unsafe.Pointer(v1216)) = *(*uintptr)(unsafe.Pointer(bp + 8))
						}
					}
					pc += uintptr(libc.Int32FromInt32(1))
					goto cleanup0
				} else {
					if 0 != 0 {
						if 0 > 0 {
							(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
						}
						pc += uintptr(libc.Int32FromInt32(1))
						switch libc.Int32FromInt32(1) {
						case int32(1):
							goto cleanup1_pushObjResultPtr
						case int32(2):
							goto cleanup2_pushObjResultPtr
						case 0:
							break
						}
					} else {
						pc += uintptr(libc.Int32FromInt32(1))
						switch libc.Int32FromInt32(1) {
						case int32(1):
							goto cleanup1
						case int32(2):
							goto cleanup2
						case 0:
							break
						}
					}
				}
				goto _1213
			_1213:
				;
				goto _1212
			_1212: /**/ //
			} else {
				if false {
					if int32(1) != 0 {
						if int32(1) > 0 {
							v1219 = *(*uintptr)(unsafe.Pointer(bp + 8))
							tosPtr += 8
							v1220 = tosPtr
							*(*uintptr)(unsafe.Pointer(v1220)) = v1219
							(*TTcl_Obj)(unsafe.Pointer(v1219)).FrefCount++
						} else {
							tosPtr += 8
							v1221 = tosPtr
							*(*uintptr)(unsafe.Pointer(v1221)) = *(*uintptr)(unsafe.Pointer(bp + 8))
						}
					}
					pc += uintptr(libc.Int32FromInt32(1))
					goto cleanup0
				} else {
					if int32(1) != 0 {
						if int32(1) > 0 {
							(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
						}
						pc += uintptr(libc.Int32FromInt32(1))
						switch libc.Int32FromInt32(2) {
						case int32(1):
							goto cleanup1_pushObjResultPtr
						case int32(2):
							goto cleanup2_pushObjResultPtr
						case 0:
							break
						}
					} else {
						pc += uintptr(libc.Int32FromInt32(1))
						switch libc.Int32FromInt32(2) {
						case int32(1):
							goto cleanup1
						case int32(2):
							goto cleanup2
						case 0:
							break
						}
					}
				}
				goto _1218
			_1218:
				;
				goto _1217
			_1217: /**/ //
			}
		}
	}
_206:
	;
_205:
	;
_204:
	;
_203:
	;
_202:
	;
	value2Ptr = *(*uintptr)(unsafe.Pointer(tosPtr))
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8))
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*int32)(unsafe.Pointer(bp + 368)) = int32(TCL_NUMBER_INT)
		*(*uintptr)(unsafe.Pointer(bp + 352)) = *(*uintptr)(unsafe.Pointer(bp + 16)) + 32
		v1222 = libc.Int32FromInt32(TCL_OK)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
			*(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FinternalRep))
			v1225 = *(*uint64)(unsafe.Pointer(bp))
			goto _1226
		_1226:
			if libc.BoolInt32(v1225&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) > libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
				*(*int32)(unsafe.Pointer(bp + 368)) = int32(TCL_NUMBER_NAN)
			} else {
				*(*int32)(unsafe.Pointer(bp + 368)) = int32(TCL_NUMBER_DOUBLE)
			}
			*(*uintptr)(unsafe.Pointer(bp + 352)) = *(*uintptr)(unsafe.Pointer(bp + 16)) + 32
			v1223 = libc.Int32FromInt32(TCL_OK)
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != libc.UintptrFromInt32(0) && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength == 0 {
				v1227 = int32(TCL_ERROR)
			} else {
				v1227 = XTcl_GetNumberFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 16)), bp+352, bp+368)
			}
			v1223 = v1227
		}
		v1222 = v1223
	}
	if v1222 != TCL_OK || *(*int32)(unsafe.Pointer(bp + 368)) == int32(TCL_NUMBER_NAN) {
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		_IllegalExprOperandType(tls, interp4, __ccgo_ts+32665, pc, *(*uintptr)(unsafe.Pointer(bp + 16)))
		checkInterp = int32(1)
		goto gotError
	}
	if (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*int32)(unsafe.Pointer(bp + 372)) = int32(TCL_NUMBER_INT)
		*(*uintptr)(unsafe.Pointer(bp + 360)) = value2Ptr + 32
		v1228 = libc.Int32FromInt32(TCL_OK)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
			*(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FinternalRep))
			v1231 = *(*uint64)(unsafe.Pointer(bp))
			goto _1232
		_1232:
			if libc.BoolInt32(v1231&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) > libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
				*(*int32)(unsafe.Pointer(bp + 372)) = int32(TCL_NUMBER_NAN)
			} else {
				*(*int32)(unsafe.Pointer(bp + 372)) = int32(TCL_NUMBER_DOUBLE)
			}
			*(*uintptr)(unsafe.Pointer(bp + 360)) = value2Ptr + 32
			v1229 = libc.Int32FromInt32(TCL_OK)
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes != libc.UintptrFromInt32(0) && (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Flength == 0 {
				v1233 = int32(TCL_ERROR)
			} else {
				v1233 = XTcl_GetNumberFromObj(tls, libc.UintptrFromInt32(0), value2Ptr, bp+360, bp+372)
			}
			v1229 = v1233
		}
		v1228 = v1229
	}
	if v1228 != TCL_OK || *(*int32)(unsafe.Pointer(bp + 372)) == int32(TCL_NUMBER_NAN) {
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		_IllegalExprOperandType(tls, interp4, __ccgo_ts+32671, pc, value2Ptr)
		checkInterp = int32(1)
		goto gotError
	}
	/*
	 * Handle Tcl_WideInt arithmetic as best we can without going out to
	 * an external function.
	 */
	if !(*(*int32)(unsafe.Pointer(bp + 368)) == int32(TCL_NUMBER_INT) && *(*int32)(unsafe.Pointer(bp + 372)) == int32(TCL_NUMBER_INT)) {
		goto _1234
	}
	w1 = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 352))))
	w2 = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 360))))
	switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) {
	case int32(INST_ADD):
		goto _1235
	case int32(INST_SUB):
		goto _1236
	case int32(INST_DIV):
		goto _1237
	case int32(INST_MULT):
		goto _1238
	}
	goto _1239
_1235:
	;
	wResult = libc.Int64FromUint64(libc.Uint64FromInt64(w1) + libc.Uint64FromInt64(w2))
	/*
	 * Check for overflow.
	 */
	if w1^wResult < 0 && w1^w2 >= 0 {
		goto overflow
	}
	goto wideResultOfArithmetic
_1236:
	;
	wResult = libc.Int64FromUint64(libc.Uint64FromInt64(w1) - libc.Uint64FromInt64(w2))
	/*
	 * Must check for overflow. The macro tests for overflows in
	 * sums by looking at the sign bits. As we have a subtraction
	 * here, we are adding -w2. As -w2 could in turn overflow, we
	 * test with ~w2 instead: it has the opposite sign bit to w2
	 * so it does the job. Note that the only "bad" case (w2==0)
	 * is irrelevant for this macro, as in that case w1 and
	 * wResult have the same sign and there is no overflow anyway.
	 */
	if w1^wResult < 0 && w1^^w2 >= 0 {
		goto overflow
	}
	goto wideResultOfArithmetic
wideResultOfArithmetic:
	;
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount > int64(1) {
		if v1240 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1240 {
			cachePtr71 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1240 || (*TAllocCache)(unsafe.Pointer(cachePtr71)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr71)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr71)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr71)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = libc.UintptrFromInt32(0)
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FinternalRep)) = wResult
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
		if false {
			if int32(1) != 0 {
				if int32(1) > 0 {
					v1243 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v1244 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1244)) = v1243
					(*TTcl_Obj)(unsafe.Pointer(v1243)).FrefCount++
				} else {
					tosPtr += 8
					v1245 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1245)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(1))
			goto cleanup0
		} else {
			if int32(1) != 0 {
				if int32(1) > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(2) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(2) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _1242
	_1242:
		;
		goto _1241
	_1241: /**/
		//
	}
	*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 376)))) = wResult
	_isobjPtr2 = *(*uintptr)(unsafe.Pointer(bp + 16))
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr2)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr2)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr2)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr2)).Fbytes = libc.UintptrFromInt32(0)
	}
	XTcl_StoreInternalRep(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), uintptr(unsafe.Pointer(&XtclIntType)), bp+376)
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v1248 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1249 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1249)) = v1248
				(*TTcl_Obj)(unsafe.Pointer(v1248)).FrefCount++
			} else {
				tosPtr += 8
				v1250 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1250)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1247
_1247:
	;
	goto _1246
_1246: /**/
	; //
	goto _1239
_1237:
	;
	if w2 == 0 {
		goto divideByZero
	} else {
		if w1 == libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))+libc.Uint64FromInt32(1)) && w2 == int64(-int32(1)) {
			/*
			 * Can't represent (-WIDE_MIN) as a Tcl_WideInt.
			 */
			goto overflow
		}
	}
	wResult = w1 / w2
	/*
	 * Force Tcl's integer division rules.
	 * TODO: examine for logic simplification
	 */
	if (wResult < 0 || wResult == 0 && (w1 < 0 && w2 > 0 || w1 > 0 && w2 < 0)) && wResult*w2 != w1 {
		wResult -= int64(1)
	}
	goto wideResultOfArithmetic
_1238:
	;
	if libc.Bool(uint64(8) >= libc.Uint64FromInt32(2)*libc.Uint64FromInt64(4)) && w1 <= int64(INT_MAX) && w1 >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && w2 <= int64(INT_MAX) && w2 >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) || libc.Bool(uint64(8) >= libc.Uint64FromInt32(2)*libc.Uint64FromInt64(2)) && w1 <= int64(SHRT_MAX) && w1 >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fff)) && w2 <= int64(SHRT_MAX) && w2 >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fff)) {
		wResult = w1 * w2
		goto wideResultOfArithmetic
	}
_1239:
	;
	/*
	 * Fall through with INST_EXPON, INST_DIV and large multiplies.
	 */
_1234:
	;
	goto overflow
overflow:
	;
	*(*uintptr)(unsafe.Pointer(bp + 8)) = _ExecuteExtendedBinaryMathOp(tls, interp4, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))), constants, *(*uintptr)(unsafe.Pointer(bp + 16)), value2Ptr)
	if *(*uintptr)(unsafe.Pointer(bp + 8)) == uintptr(-libc.Int32FromInt32(1)) {
		goto divideByZero
	} else {
		if *(*uintptr)(unsafe.Pointer(bp + 8)) == uintptr(-libc.Int32FromInt32(2)) {
			goto exponOfZero
		} else {
			if *(*uintptr)(unsafe.Pointer(bp + 8)) == uintptr(-libc.Int32FromInt32(3)) {
				goto gotError
			} else {
				if *(*uintptr)(unsafe.Pointer(bp + 8)) == uintptr(-libc.Int32FromInt32(4)) {
					goto outOfMemory
				} else {
					if *(*uintptr)(unsafe.Pointer(bp + 8)) == libc.UintptrFromInt32(0) {
						if false {
							if 0 != 0 {
								if 0 > 0 {
									v1253 = *(*uintptr)(unsafe.Pointer(bp + 8))
									tosPtr += 8
									v1254 = tosPtr
									*(*uintptr)(unsafe.Pointer(v1254)) = v1253
									(*TTcl_Obj)(unsafe.Pointer(v1253)).FrefCount++
								} else {
									tosPtr += 8
									v1255 = tosPtr
									*(*uintptr)(unsafe.Pointer(v1255)) = *(*uintptr)(unsafe.Pointer(bp + 8))
								}
							}
							pc += uintptr(libc.Int32FromInt32(1))
							goto cleanup0
						} else {
							if 0 != 0 {
								if 0 > 0 {
									(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
								}
								pc += uintptr(libc.Int32FromInt32(1))
								switch libc.Int32FromInt32(1) {
								case int32(1):
									goto cleanup1_pushObjResultPtr
								case int32(2):
									goto cleanup2_pushObjResultPtr
								case 0:
									break
								}
							} else {
								pc += uintptr(libc.Int32FromInt32(1))
								switch libc.Int32FromInt32(1) {
								case int32(1):
									goto cleanup1
								case int32(2):
									goto cleanup2
								case 0:
									break
								}
							}
						}
						goto _1252
					_1252:
						;
						goto _1251
					_1251: /**/ //
					} else {
						if false {
							if int32(1) != 0 {
								if int32(1) > 0 {
									v1258 = *(*uintptr)(unsafe.Pointer(bp + 8))
									tosPtr += 8
									v1259 = tosPtr
									*(*uintptr)(unsafe.Pointer(v1259)) = v1258
									(*TTcl_Obj)(unsafe.Pointer(v1258)).FrefCount++
								} else {
									tosPtr += 8
									v1260 = tosPtr
									*(*uintptr)(unsafe.Pointer(v1260)) = *(*uintptr)(unsafe.Pointer(bp + 8))
								}
							}
							pc += uintptr(libc.Int32FromInt32(1))
							goto cleanup0
						} else {
							if int32(1) != 0 {
								if int32(1) > 0 {
									(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
								}
								pc += uintptr(libc.Int32FromInt32(1))
								switch libc.Int32FromInt32(2) {
								case int32(1):
									goto cleanup1_pushObjResultPtr
								case int32(2):
									goto cleanup2_pushObjResultPtr
								case 0:
									break
								}
							} else {
								pc += uintptr(libc.Int32FromInt32(1))
								switch libc.Int32FromInt32(2) {
								case int32(1):
									goto cleanup1
								case int32(2):
									goto cleanup2
								case 0:
									break
								}
							}
						}
						goto _1257
					_1257:
						;
						goto _1256
					_1256: /**/ //
					}
				}
			}
		}
	}
_207:
	;
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr))
	/* TODO - check claim that taking address of b harms performance */
	/* TODO - consider optimization search for constants */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) || (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr == uintptr(unsafe.Pointer(&XtclBooleanType)) {
		*(*int32)(unsafe.Pointer(bp + 392)) = libc.BoolInt32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FinternalRep)) != 0)
		v1261 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1261 = XTcl_GetBoolFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 16)), (libc.Int32FromInt32(TCL_NULL_OK)-libc.Int32FromInt32(2))&libc.Int32FromInt64(4), bp+392)
	}
	if v1261 != TCL_OK {
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		_IllegalExprOperandType(tls, interp4, __ccgo_ts+1945, pc, *(*uintptr)(unsafe.Pointer(bp + 16)))
		checkInterp = int32(1)
		goto gotError
	}
	/* TODO: Consider peephole opt. */
	*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(constants + libc.BoolUintptr(!(*(*int32)(unsafe.Pointer(bp + 392)) != 0))*8))
	if false {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v1264 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1265 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1265)) = v1264
				(*TTcl_Obj)(unsafe.Pointer(v1264)).FrefCount++
			} else {
				tosPtr += 8
				v1266 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1266)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1263
_1263:
	;
	goto _1262
_1262: /**/
	; //
_208:
	;
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr))
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*int32)(unsafe.Pointer(bp + 368)) = int32(TCL_NUMBER_INT)
		*(*uintptr)(unsafe.Pointer(bp + 352)) = *(*uintptr)(unsafe.Pointer(bp + 16)) + 32
		v1267 = libc.Int32FromInt32(TCL_OK)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
			*(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FinternalRep))
			v1270 = *(*uint64)(unsafe.Pointer(bp))
			goto _1271
		_1271:
			if libc.BoolInt32(v1270&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) > libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
				*(*int32)(unsafe.Pointer(bp + 368)) = int32(TCL_NUMBER_NAN)
			} else {
				*(*int32)(unsafe.Pointer(bp + 368)) = int32(TCL_NUMBER_DOUBLE)
			}
			*(*uintptr)(unsafe.Pointer(bp + 352)) = *(*uintptr)(unsafe.Pointer(bp + 16)) + 32
			v1268 = libc.Int32FromInt32(TCL_OK)
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != libc.UintptrFromInt32(0) && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength == 0 {
				v1272 = int32(TCL_ERROR)
			} else {
				v1272 = XTcl_GetNumberFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 16)), bp+352, bp+368)
			}
			v1268 = v1272
		}
		v1267 = v1268
	}
	if v1267 != TCL_OK || *(*int32)(unsafe.Pointer(bp + 368)) == int32(TCL_NUMBER_NAN) || *(*int32)(unsafe.Pointer(bp + 368)) == int32(TCL_NUMBER_DOUBLE) {
		/*
		 * ... ~$NonInteger => raise an error.
		 */
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		_IllegalExprOperandType(tls, interp4, __ccgo_ts+1945, pc, *(*uintptr)(unsafe.Pointer(bp + 16)))
		checkInterp = int32(1)
		goto gotError
	}
	if *(*int32)(unsafe.Pointer(bp + 368)) == int32(TCL_NUMBER_INT) {
		w1 = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 352))))
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount > int64(1) {
			if v1273 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1273 {
				cachePtr72 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v1273 || (*TAllocCache)(unsafe.Pointer(cachePtr72)).FnumObjects == libc.Uint64FromInt32(0) {
				*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
			} else {
				*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr72)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr72)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr72)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = libc.UintptrFromInt32(0)
			*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FinternalRep)) = ^w1
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
			if false {
				if int32(1) != 0 {
					if int32(1) > 0 {
						v1276 = *(*uintptr)(unsafe.Pointer(bp + 8))
						tosPtr += 8
						v1277 = tosPtr
						*(*uintptr)(unsafe.Pointer(v1277)) = v1276
						(*TTcl_Obj)(unsafe.Pointer(v1276)).FrefCount++
					} else {
						tosPtr += 8
						v1278 = tosPtr
						*(*uintptr)(unsafe.Pointer(v1278)) = *(*uintptr)(unsafe.Pointer(bp + 8))
					}
				}
				pc += uintptr(libc.Int32FromInt32(1))
				goto cleanup0
			} else {
				if int32(1) != 0 {
					if int32(1) > 0 {
						(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
					}
					pc += uintptr(libc.Int32FromInt32(1))
					switch libc.Int32FromInt32(1) {
					case int32(1):
						goto cleanup1_pushObjResultPtr
					case int32(2):
						goto cleanup2_pushObjResultPtr
					case 0:
						break
					}
				} else {
					pc += uintptr(libc.Int32FromInt32(1))
					switch libc.Int32FromInt32(1) {
					case int32(1):
						goto cleanup1
					case int32(2):
						goto cleanup2
					case 0:
						break
					}
				}
			}
			goto _1275
		_1275:
			;
			goto _1274
		_1274: /**/
			//
		}
		*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 400)))) = ^w1
		_isobjPtr3 = *(*uintptr)(unsafe.Pointer(bp + 16))
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr3)).Fbytes != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr3)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr3)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(_isobjPtr3)).Fbytes = libc.UintptrFromInt32(0)
		}
		XTcl_StoreInternalRep(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), uintptr(unsafe.Pointer(&XtclIntType)), bp+400)
		if true {
			if 0 != 0 {
				if 0 > 0 {
					v1281 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v1282 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1282)) = v1281
					(*TTcl_Obj)(unsafe.Pointer(v1281)).FrefCount++
				} else {
					tosPtr += 8
					v1283 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1283)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(1))
			goto cleanup0
		} else {
			if 0 != 0 {
				if 0 > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _1280
	_1280:
		;
		goto _1279
	_1279: /**/
		//
	}
	*(*uintptr)(unsafe.Pointer(bp + 8)) = _ExecuteExtendedUnaryMathOp(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))), *(*uintptr)(unsafe.Pointer(bp + 16)))
	if *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) {
		if false {
			if int32(1) != 0 {
				if int32(1) > 0 {
					v1286 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v1287 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1287)) = v1286
					(*TTcl_Obj)(unsafe.Pointer(v1286)).FrefCount++
				} else {
					tosPtr += 8
					v1288 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1288)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(1))
			goto cleanup0
		} else {
			if int32(1) != 0 {
				if int32(1) > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(1) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(1) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _1285
	_1285:
		;
		goto _1284
	_1284: /**/ //
	} else {
		if true {
			if 0 != 0 {
				if 0 > 0 {
					v1291 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v1292 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1292)) = v1291
					(*TTcl_Obj)(unsafe.Pointer(v1291)).FrefCount++
				} else {
					tosPtr += 8
					v1293 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1293)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(1))
			goto cleanup0
		} else {
			if 0 != 0 {
				if 0 > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _1290
	_1290:
		;
		goto _1289
	_1289: /**/ //
	}
_209:
	;
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr))
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*int32)(unsafe.Pointer(bp + 368)) = int32(TCL_NUMBER_INT)
		*(*uintptr)(unsafe.Pointer(bp + 352)) = *(*uintptr)(unsafe.Pointer(bp + 16)) + 32
		v1294 = libc.Int32FromInt32(TCL_OK)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
			*(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FinternalRep))
			v1297 = *(*uint64)(unsafe.Pointer(bp))
			goto _1298
		_1298:
			if libc.BoolInt32(v1297&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) > libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
				*(*int32)(unsafe.Pointer(bp + 368)) = int32(TCL_NUMBER_NAN)
			} else {
				*(*int32)(unsafe.Pointer(bp + 368)) = int32(TCL_NUMBER_DOUBLE)
			}
			*(*uintptr)(unsafe.Pointer(bp + 352)) = *(*uintptr)(unsafe.Pointer(bp + 16)) + 32
			v1295 = libc.Int32FromInt32(TCL_OK)
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != libc.UintptrFromInt32(0) && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength == 0 {
				v1299 = int32(TCL_ERROR)
			} else {
				v1299 = XTcl_GetNumberFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 16)), bp+352, bp+368)
			}
			v1295 = v1299
		}
		v1294 = v1295
	}
	if v1294 != TCL_OK || *(*int32)(unsafe.Pointer(bp + 368)) == int32(TCL_NUMBER_NAN) {
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		_IllegalExprOperandType(tls, interp4, __ccgo_ts+1945, pc, *(*uintptr)(unsafe.Pointer(bp + 16)))
		checkInterp = int32(1)
		goto gotError
	}
	switch *(*int32)(unsafe.Pointer(bp + 368)) {
	case int32(TCL_NUMBER_NAN):
		/* -NaN => NaN */
		if true {
			if 0 != 0 {
				if 0 > 0 {
					v1302 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v1303 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1303)) = v1302
					(*TTcl_Obj)(unsafe.Pointer(v1302)).FrefCount++
				} else {
					tosPtr += 8
					v1304 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1304)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(1))
			goto cleanup0
		} else {
			if 0 != 0 {
				if 0 > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _1301
	_1301:
		;
		goto _1300
	_1300: /**/
		; //
	case int32(TCL_NUMBER_INT):
		w1 = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 352))))
		if w1 != libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))+libc.Uint64FromInt32(1)) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount > int64(1) {
				if v1305 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1305 {
					cachePtr73 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v1305 || (*TAllocCache)(unsafe.Pointer(cachePtr73)).FnumObjects == libc.Uint64FromInt32(0) {
					*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
				} else {
					*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr73)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr73)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr73)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = libc.UintptrFromInt32(0)
				*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FinternalRep)) = -w1
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
				if false {
					if int32(1) != 0 {
						if int32(1) > 0 {
							v1308 = *(*uintptr)(unsafe.Pointer(bp + 8))
							tosPtr += 8
							v1309 = tosPtr
							*(*uintptr)(unsafe.Pointer(v1309)) = v1308
							(*TTcl_Obj)(unsafe.Pointer(v1308)).FrefCount++
						} else {
							tosPtr += 8
							v1310 = tosPtr
							*(*uintptr)(unsafe.Pointer(v1310)) = *(*uintptr)(unsafe.Pointer(bp + 8))
						}
					}
					pc += uintptr(libc.Int32FromInt32(1))
					goto cleanup0
				} else {
					if int32(1) != 0 {
						if int32(1) > 0 {
							(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
						}
						pc += uintptr(libc.Int32FromInt32(1))
						switch libc.Int32FromInt32(1) {
						case int32(1):
							goto cleanup1_pushObjResultPtr
						case int32(2):
							goto cleanup2_pushObjResultPtr
						case 0:
							break
						}
					} else {
						pc += uintptr(libc.Int32FromInt32(1))
						switch libc.Int32FromInt32(1) {
						case int32(1):
							goto cleanup1
						case int32(2):
							goto cleanup2
						case 0:
							break
						}
					}
				}
				goto _1307
			_1307:
				;
				goto _1306
			_1306: /**/
				//
			}
			*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 416)))) = -w1
			_isobjPtr4 = *(*uintptr)(unsafe.Pointer(bp + 16))
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr4)).Fbytes != libc.UintptrFromInt32(0) {
				if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr4)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr4)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(_isobjPtr4)).Fbytes = libc.UintptrFromInt32(0)
			}
			XTcl_StoreInternalRep(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), uintptr(unsafe.Pointer(&XtclIntType)), bp+416)
			if true {
				if 0 != 0 {
					if 0 > 0 {
						v1313 = *(*uintptr)(unsafe.Pointer(bp + 8))
						tosPtr += 8
						v1314 = tosPtr
						*(*uintptr)(unsafe.Pointer(v1314)) = v1313
						(*TTcl_Obj)(unsafe.Pointer(v1313)).FrefCount++
					} else {
						tosPtr += 8
						v1315 = tosPtr
						*(*uintptr)(unsafe.Pointer(v1315)) = *(*uintptr)(unsafe.Pointer(bp + 8))
					}
				}
				pc += uintptr(libc.Int32FromInt32(1))
				goto cleanup0
			} else {
				if 0 != 0 {
					if 0 > 0 {
						(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
					}
					pc += uintptr(libc.Int32FromInt32(1))
					switch libc.Int32FromInt32(0) {
					case int32(1):
						goto cleanup1_pushObjResultPtr
					case int32(2):
						goto cleanup2_pushObjResultPtr
					case 0:
						break
					}
				} else {
					pc += uintptr(libc.Int32FromInt32(1))
					switch libc.Int32FromInt32(0) {
					case int32(1):
						goto cleanup1
					case int32(2):
						goto cleanup2
					case 0:
						break
					}
				}
			}
			goto _1312
		_1312:
			;
			goto _1311
		_1311: /**/
			//
		}
		/* FALLTHROUGH */
	}
	*(*uintptr)(unsafe.Pointer(bp + 8)) = _ExecuteExtendedUnaryMathOp(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))), *(*uintptr)(unsafe.Pointer(bp + 16)))
	if *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) {
		if false {
			if int32(1) != 0 {
				if int32(1) > 0 {
					v1318 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v1319 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1319)) = v1318
					(*TTcl_Obj)(unsafe.Pointer(v1318)).FrefCount++
				} else {
					tosPtr += 8
					v1320 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1320)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(1))
			goto cleanup0
		} else {
			if int32(1) != 0 {
				if int32(1) > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(1) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(1) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _1317
	_1317:
		;
		goto _1316
	_1316: /**/ //
	} else {
		if true {
			if 0 != 0 {
				if 0 > 0 {
					v1323 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v1324 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1324)) = v1323
					(*TTcl_Obj)(unsafe.Pointer(v1323)).FrefCount++
				} else {
					tosPtr += 8
					v1325 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1325)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(1))
			goto cleanup0
		} else {
			if 0 != 0 {
				if 0 > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _1322
	_1322:
		;
		goto _1321
	_1321: /**/ //
	}
_211:
	;
_210:
	;
	/*
	 * Try to convert the topmost stack object to numeric object. This is
	 * done in order to support [expr]'s policy of interpreting operands
	 * if at all possible as numbers first, then strings.
	 */
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr))
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*int32)(unsafe.Pointer(bp + 368)) = int32(TCL_NUMBER_INT)
		*(*uintptr)(unsafe.Pointer(bp + 352)) = *(*uintptr)(unsafe.Pointer(bp + 16)) + 32
		v1326 = libc.Int32FromInt32(TCL_OK)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
			*(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FinternalRep))
			v1329 = *(*uint64)(unsafe.Pointer(bp))
			goto _1330
		_1330:
			if libc.BoolInt32(v1329&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) > libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
				*(*int32)(unsafe.Pointer(bp + 368)) = int32(TCL_NUMBER_NAN)
			} else {
				*(*int32)(unsafe.Pointer(bp + 368)) = int32(TCL_NUMBER_DOUBLE)
			}
			*(*uintptr)(unsafe.Pointer(bp + 352)) = *(*uintptr)(unsafe.Pointer(bp + 16)) + 32
			v1327 = libc.Int32FromInt32(TCL_OK)
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != libc.UintptrFromInt32(0) && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength == 0 {
				v1331 = int32(TCL_ERROR)
			} else {
				v1331 = XTcl_GetNumberFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 16)), bp+352, bp+368)
			}
			v1327 = v1331
		}
		v1326 = v1327
	}
	if v1326 != TCL_OK {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) == int32(INST_UPLUS) {
			/*
			 * ... +$NonNumeric => raise an error.
			 */
			(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
			_IllegalExprOperandType(tls, interp4, __ccgo_ts+1945, pc, *(*uintptr)(unsafe.Pointer(bp + 16)))
			checkInterp = int32(1)
			goto gotError
		}
		/* ... TryConvertToNumeric($NonNumeric) is acceptable */
		if true {
			if 0 != 0 {
				if 0 > 0 {
					v1334 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v1335 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1335)) = v1334
					(*TTcl_Obj)(unsafe.Pointer(v1334)).FrefCount++
				} else {
					tosPtr += 8
					v1336 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1336)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(1))
			goto cleanup0
		} else {
			if 0 != 0 {
				if 0 > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _1333
	_1333:
		;
		goto _1332
	_1332: /**/ //
	}
	if *(*int32)(unsafe.Pointer(bp + 368)) == int32(TCL_NUMBER_NAN) {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) == int32(INST_UPLUS) {
			/*
			 * ... +$NonNumeric => raise an error.
			 */
			(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
			_IllegalExprOperandType(tls, interp4, __ccgo_ts+1945, pc, *(*uintptr)(unsafe.Pointer(bp + 16)))
			checkInterp = int32(1)
		} else {
			/*
			 * Numeric conversion of NaN -> error.
			 */
			(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
			XTclExprFloatError(tls, interp4, *(*float64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 352)))))
			checkInterp = int32(1)
		}
		goto gotError
	}
	/*
	 * Ensure that the numeric value has a string rep the same as the
	 * formatted version of its internal rep. This is used, e.g., to make
	 * sure that "expr {0001}" yields "1", not "0001". We implement this
	 * by _discarding_ the string rep since we know it will be
	 * regenerated, if needed later, by formatting the internal rep's
	 * value.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes == libc.UintptrFromInt32(0) {
		if true {
			if 0 != 0 {
				if 0 > 0 {
					v1339 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v1340 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1340)) = v1339
					(*TTcl_Obj)(unsafe.Pointer(v1339)).FrefCount++
				} else {
					tosPtr += 8
					v1341 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1341)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(1))
			goto cleanup0
		} else {
			if 0 != 0 {
				if 0 > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _1338
	_1338:
		;
		goto _1337
	_1337: /**/ //
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount > int64(1) {
		/*
		 * Here we do some surgery within the Tcl_Obj internals. We want
		 * to copy the internalrep, but not the string, so we temporarily hide
		 * the string so we do not copy it.
		 */
		savedString = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(bp + 8)) = XTcl_DuplicateObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes = savedString
		if false {
			if int32(1) != 0 {
				if int32(1) > 0 {
					v1344 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v1345 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1345)) = v1344
					(*TTcl_Obj)(unsafe.Pointer(v1344)).FrefCount++
				} else {
					tosPtr += 8
					v1346 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1346)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(1))
			goto cleanup0
		} else {
			if int32(1) != 0 {
				if int32(1) > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(1) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(1))
				switch libc.Int32FromInt32(1) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _1343
	_1343:
		;
		goto _1342
	_1342: /**/
		//
	}
	_isobjPtr5 = *(*uintptr)(unsafe.Pointer(bp + 16))
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr5)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr5)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr5)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr5)).Fbytes = libc.UintptrFromInt32(0)
	}
	if true {
		if 0 != 0 {
			if 0 > 0 {
				v1349 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1350 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1350)) = v1349
				(*TTcl_Obj)(unsafe.Pointer(v1349)).FrefCount++
			} else {
				tosPtr += 8
				v1351 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1351)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1348
_1348:
	;
	goto _1347
_1347: /**/
	; //
	goto _243
	/*
	 *	   End of numeric operator instructions.
	 * -----------------------------------------------------------------
	 */
_212:
	;
	*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(tosPtr))
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr == uintptr(unsafe.Pointer(&XtclBooleanType)) {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(constants + 1*8))
	} else {
		res = libc.BoolInt32(XTclSetBooleanFromAny(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 16))) == TCL_OK)
		*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(constants + uintptr(res)*8))
	}
	if true {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v1354 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1355 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1355)) = v1354
				(*TTcl_Obj)(unsafe.Pointer(v1354)).FrefCount++
			} else {
				tosPtr += 8
				v1356 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1356)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1353
_1353:
	;
	goto _1352
_1352: /**/
	; //
	goto _243
_213:
	;
	/*
		DECACHE_STACK_INFO();
		Tcl_ResetResult(interp);
		CACHE_STACK_INFO();
	*/
	result = int32(TCL_BREAK)
	cleanup = 0
	goto processExceptionReturn
_214:
	;
	/*
		DECACHE_STACK_INFO();
		Tcl_ResetResult(interp);
		CACHE_STACK_INFO();
	*/
	result = int32(TCL_CONTINUE)
	cleanup = 0
	goto processExceptionReturn
_215:
	;
	/*
	 * Initialize the data for the looping construct, pushing the
	 * corresponding Tcl_Objs to the stack.
	 */
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	infoPtr = (*(*TAuxData)(unsafe.Pointer((*TByteCode)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)).FauxDataArrayPtr + uintptr(opnd)*16))).FclientData
	numLists = (*TForeachInfo)(unsafe.Pointer(infoPtr)).FnumLists
	/*
	 * Compute the number of iterations that will be run: iterMax
	 */
	iterMax = 0
	listTmpDepth = numLists - int64(1)
	i3 = 0
	for {
		if !(i3 < numLists) {
			break
		}
		varListPtr = *(*uintptr)(unsafe.Pointer(infoPtr + 24 + uintptr(i3)*8))
		numVars = (*TForeachVarList)(unsafe.Pointer(varListPtr)).FnumVars
		listPtr1 = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-listTmpDepth)*8))
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		if (*TTcl_Obj)(unsafe.Pointer(listPtr1)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr1 + 32))).Fptr2 != 0 {
				v1359 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listPtr1 + 32))).Fptr2)).FspanLength
			} else {
				v1359 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listPtr1 + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 440)) = v1359
			v1358 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1358 = XTcl_ListObjLength(tls, interp4, listPtr1, bp+440)
		}
		if v1358 != TCL_OK {
			checkInterp = int32(1)
			goto gotError
		}
		if (*TTcl_Obj)(unsafe.Pointer(listPtr1)).FrefCount > int64(1) {
			objPtr5 = XTclListObjCopy(tls, libc.UintptrFromInt32(0), listPtr1)
			(*TTcl_Obj)(unsafe.Pointer(objPtr5)).FrefCount++
			_objPtr34 = listPtr1
			v1361 = _objPtr34
			v1360 = *(*TTcl_Size)(unsafe.Pointer(v1361))
			*(*TTcl_Size)(unsafe.Pointer(v1361))--
			if v1360 <= int64(1) {
				XTclFreeObj(tls, _objPtr34)
			}
			*(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-listTmpDepth)*8)) = objPtr5
		}
		iterTmp = (*(*TTcl_Size)(unsafe.Pointer(bp + 440)) + (numVars - int64(1))) / numVars
		if iterTmp > iterMax {
			iterMax = iterTmp
		}
		listTmpDepth--
		goto _1357
	_1357:
		;
		i3++
	}
	/*
	 * Store the iterNum and iterMax in a single Tcl_Obj; we keep a
	 * nul-string obj with the pointer stored in the ptrValue so that the
	 * thing is properly garbage collected. THIS OBJ MAKES NO SENSE, but
	 * it will never leave this scope and is read-only.
	 */
	if v1362 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1362 {
		cachePtr74 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1362 || (*TAllocCache)(unsafe.Pointer(cachePtr74)).FnumObjects == libc.Uint64FromInt32(0) {
		tmpPtr = XTclThreadAllocObj(tls)
	} else {
		tmpPtr = (*TAllocCache)(unsafe.Pointer(cachePtr74)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr74)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(tmpPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr74)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(tmpPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(tmpPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(tmpPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(tmpPtr)).FtypePtr = libc.UintptrFromInt32(0)
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(tmpPtr + 32))).Fptr1 = libc.UintptrFromInt32(0)
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(tmpPtr + 32))).Fptr2 = uintptr(iterMax)
	v1363 = tmpPtr
	tosPtr += 8
	v1364 = tosPtr
	*(*uintptr)(unsafe.Pointer(v1364)) = v1363
	(*TTcl_Obj)(unsafe.Pointer(v1363)).FrefCount++ /* iterCounts object */
	/*
	 * Store a pointer to the ForeachInfo struct; same dirty trick
	 * as above
	 */
	if v1365 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1365 {
		cachePtr75 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1365 || (*TAllocCache)(unsafe.Pointer(cachePtr75)).FnumObjects == libc.Uint64FromInt32(0) {
		tmpPtr = XTclThreadAllocObj(tls)
	} else {
		tmpPtr = (*TAllocCache)(unsafe.Pointer(cachePtr75)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr75)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(tmpPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr75)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(tmpPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(tmpPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(tmpPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(tmpPtr)).FtypePtr = libc.UintptrFromInt32(0)
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(tmpPtr + 32))).Fptr1 = infoPtr
	v1366 = tmpPtr
	tosPtr += 8
	v1367 = tosPtr
	*(*uintptr)(unsafe.Pointer(v1367)) = v1366
	(*TTcl_Obj)(unsafe.Pointer(v1366)).FrefCount++ /* infoPtr object */
	/*
	 * Jump directly to the INST_FOREACH_STEP instruction; the C code just
	 * falls through.
	 */
	pc += uintptr(int64(5) - (*TForeachInfo)(unsafe.Pointer(infoPtr)).FloopCtTemp)
_216:
	; /* TODO: address abstract list indexing here! */
	/*
	 * "Step" a foreach loop (i.e., begin its next iteration) by assigning
	 * the next value list element to each loop var.
	 */
	tmpPtr = *(*uintptr)(unsafe.Pointer(tosPtr))
	infoPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(tmpPtr + 32))).Fptr1
	numLists = (*TForeachInfo)(unsafe.Pointer(infoPtr)).FnumLists
	tmpPtr = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8))
	iterNum = libc.Int64FromUint64(uint64((*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(tmpPtr + 32))).Fptr1))
	iterMax = libc.Int64FromUint64(uint64((*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(tmpPtr + 32))).Fptr2))
	/*
	 * If some list still has a remaining list element iterate one more
	 * time. Assign to var the next element from its value list.
	 */
	if iterNum < iterMax {
		/*
		 * Set the variables and jump back to run the body
		 */
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(tmpPtr + 32))).Fptr1 = uintptr(iterNum + libc.Int64FromInt32(1))
		listTmpDepth = numLists + int64(1)
		i3 = 0
		for {
			if !(i3 < numLists) {
				break
			}
			varListPtr = *(*uintptr)(unsafe.Pointer(infoPtr + 24 + uintptr(i3)*8))
			numVars = (*TForeachVarList)(unsafe.Pointer(varListPtr)).FnumVars
			listPtr1 = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-listTmpDepth)*8))
			if (*TTcl_Obj)(unsafe.Pointer(listPtr1)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+56) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+56) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listPtr1)).FtypePtr)).Fversion) {
				v1369 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listPtr1)).FtypePtr)).FindexProc
			} else {
				v1369 = libc.UintptrFromInt32(0)
			}
			hasAbstractList = libc.BoolInt32(v1369 != uintptr(0))
			(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
			if hasAbstractList != 0 {
				status1 = XTcl_ListObjLength(tls, interp4, listPtr1, bp+440)
				*(*uintptr)(unsafe.Pointer(bp + 432)) = libc.UintptrFromInt32(0)
			} else {
				if (*TTcl_Obj)(unsafe.Pointer(listPtr1)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
					if (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(listPtr1 + 32))).Fptr2 != 0 {
						v1371 = (*TListSpan)(unsafe.Pointer((*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(listPtr1 + 32))).Fptr2)).FspanStart
					} else {
						v1371 = (*TListStore)(unsafe.Pointer((*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(listPtr1 + 32))).Fptr1)).FfirstUsed
					}
					*(*uintptr)(unsafe.Pointer(bp + 432)) = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(listPtr1 + 32))).Fptr1 + 40 + uintptr(v1371)*8
					if (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(listPtr1 + 32))).Fptr2 != 0 {
						v1372 = (*TListSpan)(unsafe.Pointer((*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(listPtr1 + 32))).Fptr2)).FspanLength
					} else {
						v1372 = (*TListStore)(unsafe.Pointer((*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(listPtr1 + 32))).Fptr1)).FnumUsed
					}
					*(*TTcl_Size)(unsafe.Pointer(bp + 440)) = v1372
					v1370 = libc.Int32FromInt32(TCL_OK)
				} else {
					v1370 = XTcl_ListObjGetElements(tls, interp4, listPtr1, bp+440, bp+432)
				}
				status1 = v1370
			}
			if status1 != TCL_OK {
				checkInterp = int32(1)
				goto gotError
			}
			checkInterp = int32(1)
			valIndex = iterNum * numVars
			j = 0
			for {
				if !(j < numVars) {
					break
				}
				if valIndex >= *(*TTcl_Size)(unsafe.Pointer(bp + 440)) {
					if v1374 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1374 {
						cachePtr76 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v1374 || (*TAllocCache)(unsafe.Pointer(cachePtr76)).FnumObjects == libc.Uint64FromInt32(0) {
						*(*uintptr)(unsafe.Pointer(bp + 16)) = XTclThreadAllocObj(tls)
					} else {
						*(*uintptr)(unsafe.Pointer(bp + 16)) = (*TAllocCache)(unsafe.Pointer(cachePtr76)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr76)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr76)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount = 0
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength = 0
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr = libc.UintptrFromInt32(0)
				} else {
					(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
					if *(*uintptr)(unsafe.Pointer(bp + 432)) != 0 {
						*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 432)) + uintptr(valIndex)*8))
					} else {
						status1 = XTcl_ListObjIndex(tls, interp4, listPtr1, valIndex, bp+16)
						if status1 != TCL_OK {
							/* Could happen for abstract lists */
							checkInterp = int32(1)
							goto gotError
						}
						if *(*uintptr)(unsafe.Pointer(bp + 16)) == libc.UintptrFromInt32(0) {
							/* Permitted for Tcl_LOI to return NULL */
							if v1375 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1375 {
								cachePtr77 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
							}
							if v1375 || (*TAllocCache)(unsafe.Pointer(cachePtr77)).FnumObjects == libc.Uint64FromInt32(0) {
								*(*uintptr)(unsafe.Pointer(bp + 16)) = XTclThreadAllocObj(tls)
							} else {
								*(*uintptr)(unsafe.Pointer(bp + 16)) = (*TAllocCache)(unsafe.Pointer(cachePtr77)).FfirstObjPtr
								(*TAllocCache)(unsafe.Pointer(cachePtr77)).FfirstObjPtr = (*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1
								(*TAllocCache)(unsafe.Pointer(cachePtr77)).FnumObjects--
							}
							(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount = 0
							(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
							(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength = 0
							(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr = libc.UintptrFromInt32(0)
						}
					}
					checkInterp = int32(1)
				}
				varIndex = *(*TTcl_Size)(unsafe.Pointer(varListPtr + 8 + uintptr(j)*8))
				*(*uintptr)(unsafe.Pointer(bp + 48)) = compiledLocals + uintptr(varIndex)*16
				for (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_LINK) != 0 {
					*(*uintptr)(unsafe.Pointer(bp + 48)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
				}
				if !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_DEAD_HASH)|libc.Int32FromInt32(VAR_CONSTANT)) != 0 || (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 && (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr != libc.UintptrFromInt32(0) && (*TVar1)(unsafe.Pointer((*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr)).Fflags&(libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_DEAD_HASH)|libc.Int32FromInt32(VAR_CONSTANT)) != 0) {
					value2Ptr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
					if *(*uintptr)(unsafe.Pointer(bp + 16)) != value2Ptr {
						if value2Ptr != libc.UintptrFromInt32(0) {
							v1377 = value2Ptr
							v1376 = *(*TTcl_Size)(unsafe.Pointer(v1377))
							*(*TTcl_Size)(unsafe.Pointer(v1377))--
							if !(v1376 > int64(1)) {
								if !((*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr)).FfreeIntRepProc != 0) {
									if (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
										XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes)
									}
									(*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Flength = int64(-libc.Int32FromInt32(1))
									if v1378 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1378 {
										cachePtr78 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
									}
									if v1378 || ((*TAllocCache)(unsafe.Pointer(cachePtr78)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr78)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
										XTclThreadFreeObj(tls, value2Ptr)
									} else {
										(*(*struct {
											Fptr1 uintptr
											Fptr2 uintptr
										})(unsafe.Pointer(value2Ptr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr78)).FfirstObjPtr
										(*TAllocCache)(unsafe.Pointer(cachePtr78)).FfirstObjPtr = value2Ptr
										(*TAllocCache)(unsafe.Pointer(cachePtr78)).FnumObjects++
									}
								} else {
									XTclFreeObj(tls, value2Ptr)
								}
							}
						}
						*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) = *(*uintptr)(unsafe.Pointer(bp + 16))
						(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount++
					}
				} else {
					(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
					if XTclPtrSetVarIdx(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 48)), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 16)), int32(TCL_LEAVE_ERR_MSG), int32(varIndex)) == libc.UintptrFromInt32(0) {
						checkInterp = int32(1)
						goto gotError
					}
					checkInterp = int32(1)
				}
				valIndex++
				goto _1373
			_1373:
				;
				j++
			}
			listTmpDepth--
			goto _1368
		_1368:
			;
			i3++
		}
		/* loopCtTemp being 'misused' for storing the jump size */
		if true {
			if 0 != 0 {
				if 0 > 0 {
					v1381 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v1382 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1382)) = v1381
					(*TTcl_Obj)(unsafe.Pointer(v1381)).FrefCount++
				} else {
					tosPtr += 8
					v1383 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1383)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr((*TForeachInfo)(unsafe.Pointer(infoPtr)).FloopCtTemp)
			goto cleanup0
		} else {
			if 0 != 0 {
				if 0 > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr((*TForeachInfo)(unsafe.Pointer(infoPtr)).FloopCtTemp)
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr((*TForeachInfo)(unsafe.Pointer(infoPtr)).FloopCtTemp)
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _1380
	_1380:
		;
		goto _1379
	_1379: /**/
		//
	}
	/*
	 * FALL THROUGH
	 */
	pc++
_217:
	;
	/* THIS INSTRUCTION IS ONLY CALLED AS A BREAK TARGET */
	tmpPtr = *(*uintptr)(unsafe.Pointer(tosPtr))
	infoPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(tmpPtr + 32))).Fptr1
	numLists = (*TForeachInfo)(unsafe.Pointer(infoPtr)).FnumLists
	pc += uintptr(libc.Int32FromInt32(1))
	cleanup = int32(numLists + libc.Int64FromInt32(2))
	if 0 != 0 {
		if 0 > 0 {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
		}
		goto cleanupV_pushObjResultPtr
	} else {
		goto cleanupV
	}
_218:
	;
	/*
	 * This instruction is only issued by lmap. The stack is:
	 *   - result
	 *   - infoPtr
	 *   - loop counters
	 *   - valLists
	 *   - collecting obj (unshared)
	 * The instruction lappends the result to the collecting obj.
	 */
	tmpPtr = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8))
	infoPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(tmpPtr + 32))).Fptr1
	numLists = (*TForeachInfo)(unsafe.Pointer(infoPtr)).FnumLists
	objPtr5 = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-(libc.Int64FromInt32(3)+numLists))*8))
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), objPtr5, *(*uintptr)(unsafe.Pointer(tosPtr)))
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v1386 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1387 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1387)) = v1386
				(*TTcl_Obj)(unsafe.Pointer(v1386)).FrefCount++
			} else {
				tosPtr += 8
				v1388 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1388)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1385
_1385:
	;
	goto _1384
_1384: /**/
	; //
	goto _243
_219:
	;
	/*
	 * Record start of the catch command with exception range index equal
	 * to the operand. Push the current stack depth onto the special catch
	 * stack.
	 */
	v1390 = TD + 8
	*(*uintptr)(unsafe.Pointer(v1390)) += 8
	v1389 = *(*uintptr)(unsafe.Pointer(v1390))
	*(*uintptr)(unsafe.Pointer(v1389)) = uintptr((int64(tosPtr) - int64(TD+112-libc.UintptrFromInt32(1)*8+uintptr((*TByteCode)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)).FmaxExceptDepth)*8)) / 8)
	if true {
		if 0 != 0 {
			if 0 > 0 {
				v1393 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1394 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1394)) = v1393
				(*TTcl_Obj)(unsafe.Pointer(v1393)).FrefCount++
			} else {
				tosPtr += 8
				v1395 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1395)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(5))
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(5))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(5))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1392
_1392:
	;
	goto _1391
_1391: /**/
	; //
	goto _243
_220:
	;
	(*TTEBCdata)(unsafe.Pointer(TD)).FcatchTop -= 8
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	XTcl_ResetResult(tls, interp4)
	checkInterp = int32(1)
	result = TCL_OK
	if true {
		if 0 != 0 {
			if 0 > 0 {
				v1398 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1399 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1399)) = v1398
				(*TTcl_Obj)(unsafe.Pointer(v1398)).FrefCount++
			} else {
				tosPtr += 8
				v1400 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1400)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1397
_1397:
	;
	goto _1396
_1396: /**/
	; //
	goto _243
_221:
	;
	*(*uintptr)(unsafe.Pointer(bp + 8)) = XTcl_GetObjResult(tls, interp4)
	/*
	 * See the comments at INST_INVOKE_STK
	 */
	if v1401 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1401 {
		cachePtr79 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1401 || (*TAllocCache)(unsafe.Pointer(cachePtr79)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr5 = XTclThreadAllocObj(tls)
	} else {
		objPtr5 = (*TAllocCache)(unsafe.Pointer(cachePtr79)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr79)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr5 + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr79)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr5)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(objPtr5)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr5)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(objPtr5)).FrefCount++
	(*TInterp)(unsafe.Pointer(interp4)).FobjResultPtr = objPtr5
	if true {
		if -int32(1) != 0 {
			if -int32(1) > 0 {
				v1404 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1405 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1405)) = v1404
				(*TTcl_Obj)(unsafe.Pointer(v1404)).FrefCount++
			} else {
				tosPtr += 8
				v1406 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1406)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if -int32(1) != 0 {
			if -int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1403
_1403:
	;
	goto _1402
_1402: /**/
	; //
	goto _243
_222:
	;
	if v1407 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1407 {
		cachePtr80 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1407 || (*TAllocCache)(unsafe.Pointer(cachePtr80)).FnumObjects == libc.Uint64FromInt32(0) {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
	} else {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr80)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr80)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr80)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = libc.UintptrFromInt32(0)
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FinternalRep)) = int64(result)
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	if true {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v1410 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1411 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1411)) = v1410
				(*TTcl_Obj)(unsafe.Pointer(v1410)).FrefCount++
			} else {
				tosPtr += 8
				v1412 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1412)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1409
_1409:
	;
	goto _1408
_1408: /**/
	; //
	goto _243
_223:
	;
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	*(*uintptr)(unsafe.Pointer(bp + 8)) = XTcl_GetReturnOptions(tls, interp4, result)
	checkInterp = int32(1)
	if true {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v1415 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1416 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1416)) = v1415
				(*TTcl_Obj)(unsafe.Pointer(v1415)).FrefCount++
			} else {
				tosPtr += 8
				v1417 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1417)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1414
_1414:
	;
	goto _1413
_1413: /**/
	; //
	goto _243
_224:
	;
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
		*(*int32)(unsafe.Pointer(bp + 448)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FinternalRep)))
		v1418 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1418 = XTcl_GetIntFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(tosPtr)), bp+448)
	}
	if v1418 != TCL_OK {
		XTcl_Panic(tls, __ccgo_ts+32702, 0)
	}
	if *(*int32)(unsafe.Pointer(bp + 448)) == TCL_OK {
		XTcl_Panic(tls, __ccgo_ts+32750, 0)
	}
	if *(*int32)(unsafe.Pointer(bp + 448)) < int32(TCL_ERROR) || *(*int32)(unsafe.Pointer(bp + 448)) > int32(TCL_CONTINUE) {
		*(*int32)(unsafe.Pointer(bp + 448)) = libc.Int32FromInt32(TCL_CONTINUE) + libc.Int32FromInt32(1)
	}
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v1421 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1422 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1422)) = v1421
				(*TTcl_Obj)(unsafe.Pointer(v1421)).FrefCount++
			} else {
				tosPtr += 8
				v1423 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1423)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(2)**(*int32)(unsafe.Pointer(bp + 448)) - libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(2)**(*int32)(unsafe.Pointer(bp + 448)) - libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(2)**(*int32)(unsafe.Pointer(bp + 448)) - libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1420
_1420:
	;
	goto _1419
_1419: /**/
	; //
	/*
	 * -----------------------------------------------------------------
	 *	   Start of dictionary-related instructions.
	 */
_225:
	;
	dictPtr = *(*uintptr)(unsafe.Pointer(tosPtr))
	if XTcl_DictObjSize(tls, interp4, dictPtr, bp+472) != TCL_OK {
		goto gotError
	}
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v1426 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1427 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1427)) = v1426
				(*TTcl_Obj)(unsafe.Pointer(v1426)).FrefCount++
			} else {
				tosPtr += 8
				v1428 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1428)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1425
_1425:
	;
	goto _1424
_1424: /**/
	; //
	goto _243
_226:
	;
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	dictPtr = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-opnd)*8))
	if opnd > int32(1) {
		dictPtr = XTclTraceDictPath(tls, libc.UintptrFromInt32(0), dictPtr, int64(opnd-int32(1)), tosPtr+uintptr(-(opnd-libc.Int32FromInt32(1)))*8, int32(DICT_PATH_EXISTS))
		if dictPtr == libc.UintptrFromInt32(0) || dictPtr == libc.UintptrFromInt32(1) {
			found1 = 0
			goto afterDictExists
		}
	}
	if XTcl_DictObjGet(tls, libc.UintptrFromInt32(0), dictPtr, *(*uintptr)(unsafe.Pointer(tosPtr)), bp+8) == TCL_OK {
		if *(*uintptr)(unsafe.Pointer(bp + 8)) != 0 {
			v1429 = int32(1)
		} else {
			v1429 = 0
		}
		found1 = v1429
	} else {
		found1 = 0
	}
	goto afterDictExists
afterDictExists:
	;
	/*
	 * The INST_DICT_EXISTS instruction is usually followed by a
	 * conditional jump, so we can take advantage of this to do some
	 * peephole optimization (note that we're careful to not close out
	 * someone doing something else).
	 */
	pc += uintptr(libc.Int32FromInt32(5))
	switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) {
	case int32(INST_JUMP_FALSE1):
		if found1 != 0 {
			v1432 = int32(2)
		} else {
			v1432 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
		}
		pc += uintptr(v1432)
		cleanup = opnd + int32(1)
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			goto cleanupV_pushObjResultPtr
		} else {
			goto cleanupV
		}
	case int32(INST_JUMP_TRUE1):
		if found1 != 0 {
			v1433 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
		} else {
			v1433 = int32(2)
		}
		pc += uintptr(v1433)
		cleanup = opnd + int32(1)
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			goto cleanupV_pushObjResultPtr
		} else {
			goto cleanupV
		}
	case int32(INST_JUMP_FALSE4):
		if found1 != 0 {
			v1434 = int32(5)
		} else {
			v1434 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
		}
		pc += uintptr(v1434)
		cleanup = opnd + int32(1)
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			goto cleanupV_pushObjResultPtr
		} else {
			goto cleanupV
		}
	case int32(INST_JUMP_TRUE4):
		if found1 != 0 {
			v1435 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
		} else {
			v1435 = int32(5)
		}
		pc += uintptr(v1435)
		cleanup = opnd + int32(1)
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			goto cleanupV_pushObjResultPtr
		} else {
			goto cleanupV
		}
	default:
		if found1 < 0 {
			if v1436 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1436 {
				cachePtr81 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v1436 || (*TAllocCache)(unsafe.Pointer(cachePtr81)).FnumObjects == libc.Uint64FromInt32(0) {
				*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
			} else {
				*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr81)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr81)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr81)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = libc.UintptrFromInt32(0)
			*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FinternalRep)) = int64(-libc.Int32FromInt32(1))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
		} else {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(constants + libc.BoolUintptr(found1 > libc.Int32FromInt32(0))*8))
		}
		pc += uintptr(libc.Int32FromInt32(0))
		cleanup = opnd + int32(1)
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			goto cleanupV_pushObjResultPtr
		} else {
			goto cleanupV
		}
		break
	}
	goto _1431
_1431:
	;
	goto _1430
_1430: /**/
	; //
_227:
	;
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	dictPtr = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-opnd)*8))
	if opnd > int32(1) {
		dictPtr = XTclTraceDictPath(tls, interp4, dictPtr, int64(opnd-int32(1)), tosPtr+uintptr(-(opnd-libc.Int32FromInt32(1)))*8, DICT_PATH_READ)
		if dictPtr == libc.UintptrFromInt32(0) {
			goto gotError
		}
	}
	if XTcl_DictObjGet(tls, interp4, dictPtr, *(*uintptr)(unsafe.Pointer(tosPtr)), bp+8) != TCL_OK {
		goto gotError
	}
	if !(*(*uintptr)(unsafe.Pointer(bp + 8)) != 0) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Fbytes != 0 {
			v1437 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Fbytes
		} else {
			v1437 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(tosPtr)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp4, XTcl_ObjPrintf(tls, __ccgo_ts+26300, libc.VaList(bp+544, v1437)))
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Fbytes != 0 {
			v1438 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).Fbytes
		} else {
			v1438 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(tosPtr)), libc.UintptrFromInt32(0))
		}
		XTcl_SetErrorCode(tls, interp4, libc.VaList(bp+544, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+26333, v1438, libc.UintptrFromInt32(0)))
		checkInterp = int32(1)
		goto gotError
	}
	pc += uintptr(libc.Int32FromInt32(5))
	cleanup = opnd + int32(1)
	if int32(1) != 0 {
		if int32(1) > 0 {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
		}
		goto cleanupV_pushObjResultPtr
	} else {
		goto cleanupV
	}
_228:
	;
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	dictPtr = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-(opnd+libc.Int32FromInt32(1)))*8))
	if opnd > int32(1) {
		dictPtr = XTclTraceDictPath(tls, interp4, dictPtr, int64(opnd-int32(1)), tosPtr+uintptr(-opnd)*8, int32(DICT_PATH_EXISTS))
		if dictPtr == libc.UintptrFromInt32(0) {
			goto gotError
		} else {
			if dictPtr == libc.UintptrFromInt32(1) {
				goto dictGetDefUseDefault
			}
		}
	}
	if !(XTcl_DictObjGet(tls, interp4, dictPtr, *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)), bp+8) != TCL_OK) {
		goto _1439
	}
	goto gotError
	goto _1440
_1439:
	;
	if !!(*(*uintptr)(unsafe.Pointer(bp + 8)) != 0) {
		goto _1441
	}
	goto dictGetDefUseDefault
dictGetDefUseDefault:
	;
	*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(tosPtr))
_1441:
	;
_1440:
	;
	pc += uintptr(libc.Int32FromInt32(5))
	cleanup = opnd + int32(2)
	if int32(1) != 0 {
		if int32(1) > 0 {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
		}
		goto cleanupV_pushObjResultPtr
	} else {
		goto cleanupV
	}
_231:
	;
_230:
	;
_229:
	;
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	opnd2 = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5) + libc.UintptrFromInt32(3))))))
	*(*uintptr)(unsafe.Pointer(bp + 48)) = compiledLocals + uintptr(opnd2)*16
	for (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_LINK) != 0 {
		*(*uintptr)(unsafe.Pointer(bp + 48)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
	}
	if !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)|libc.Int32FromInt32(VAR_TRACED_READ)) != 0 || (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 && (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr != libc.UintptrFromInt32(0) && (*TVar1)(unsafe.Pointer((*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr)).Fflags&int32(VAR_TRACED_READ) != 0) && *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) != 0 {
		dictPtr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
	} else {
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		dictPtr = XTclPtrGetVarIdx(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 48)), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), 0, opnd2)
		checkInterp = int32(1)
	}
	if dictPtr == libc.UintptrFromInt32(0) {
		if v1442 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1442 {
			cachePtr82 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1442 || (*TAllocCache)(unsafe.Pointer(cachePtr82)).FnumObjects == libc.Uint64FromInt32(0) {
			dictPtr = XTclThreadAllocObj(tls)
		} else {
			dictPtr = (*TAllocCache)(unsafe.Pointer(cachePtr82)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr82)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(dictPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr82)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr = libc.UintptrFromInt32(0)
		allocateDict = int32(1)
	} else {
		allocateDict = libc.BoolInt32((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount > int64(1))
		if allocateDict != 0 {
			dictPtr = XTcl_DuplicateObj(tls, dictPtr)
		}
	}
	switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) {
	case int32(INST_DICT_SET):
		cleanup = opnd + int32(1)
		result = XTcl_DictObjPutKeyList(tls, interp4, dictPtr, int64(opnd), tosPtr+uintptr(-opnd)*8, *(*uintptr)(unsafe.Pointer(tosPtr)))
	case int32(INST_DICT_INCR_IMM):
		cleanup = int32(1)
		opnd = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
		result = XTcl_DictObjGet(tls, interp4, dictPtr, *(*uintptr)(unsafe.Pointer(tosPtr)), bp+16)
		if result != TCL_OK {
			break
		}
		if *(*uintptr)(unsafe.Pointer(bp + 16)) == libc.UintptrFromInt32(0) {
			XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dictPtr, *(*uintptr)(unsafe.Pointer(tosPtr)), XTcl_NewWideIntObj(tls, int64(opnd)))
		} else {
			if v1443 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1443 {
				cachePtr83 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v1443 || (*TAllocCache)(unsafe.Pointer(cachePtr83)).FnumObjects == libc.Uint64FromInt32(0) {
				value2Ptr = XTclThreadAllocObj(tls)
			} else {
				value2Ptr = (*TAllocCache)(unsafe.Pointer(cachePtr83)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr83)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(value2Ptr + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr83)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes = libc.UintptrFromInt32(0)
			*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FinternalRep)) = int64(opnd)
			(*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
			(*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FrefCount++
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount > int64(1) {
				*(*uintptr)(unsafe.Pointer(bp + 16)) = XTcl_DuplicateObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
				XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dictPtr, *(*uintptr)(unsafe.Pointer(tosPtr)), *(*uintptr)(unsafe.Pointer(bp + 16)))
			}
			result = XTclIncrObj(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 16)), value2Ptr)
			if result == TCL_OK {
				_isobjPtr6 = dictPtr
				if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr6)).Fbytes != libc.UintptrFromInt32(0) {
					if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr6)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr6)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(_isobjPtr6)).Fbytes = libc.UintptrFromInt32(0)
				}
			}
			v1445 = value2Ptr
			v1444 = *(*TTcl_Size)(unsafe.Pointer(v1445))
			*(*TTcl_Size)(unsafe.Pointer(v1445))--
			if !(v1444 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Flength = int64(-libc.Int32FromInt32(1))
					if v1446 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1446 {
						cachePtr84 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v1446 || ((*TAllocCache)(unsafe.Pointer(cachePtr84)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr84)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, value2Ptr)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(value2Ptr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr84)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr84)).FfirstObjPtr = value2Ptr
						(*TAllocCache)(unsafe.Pointer(cachePtr84)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, value2Ptr)
				}
			}
		}
	case int32(INST_DICT_UNSET):
		cleanup = opnd
		result = XTcl_DictObjRemoveKeyList(tls, interp4, dictPtr, int64(opnd), tosPtr+uintptr(-(opnd-libc.Int32FromInt32(1)))*8)
	default:
		cleanup = 0 /* stop compiler warning */
		XTcl_Panic(tls, __ccgo_ts+32790, 0)
	}
	if result != TCL_OK {
		if allocateDict != 0 {
			v1448 = dictPtr
			v1447 = *(*TTcl_Size)(unsafe.Pointer(v1448))
			*(*TTcl_Size)(unsafe.Pointer(v1448))--
			if !(v1447 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Flength = int64(-libc.Int32FromInt32(1))
					if v1449 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1449 {
						cachePtr85 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v1449 || ((*TAllocCache)(unsafe.Pointer(cachePtr85)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr85)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, dictPtr)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(dictPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr85)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr85)).FfirstObjPtr = dictPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr85)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, dictPtr)
				}
			}
		}
		goto checkForCatch
	}
	if !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_DEAD_HASH)|libc.Int32FromInt32(VAR_CONSTANT)) != 0 || (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 && (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr != libc.UintptrFromInt32(0) && (*TVar1)(unsafe.Pointer((*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr)).Fflags&(libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_DEAD_HASH)|libc.Int32FromInt32(VAR_CONSTANT)) != 0) {
		if allocateDict != 0 {
			value2Ptr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
			(*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount++
			if value2Ptr != libc.UintptrFromInt32(0) {
				v1451 = value2Ptr
				v1450 = *(*TTcl_Size)(unsafe.Pointer(v1451))
				*(*TTcl_Size)(unsafe.Pointer(v1451))--
				if !(v1450 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Flength = int64(-libc.Int32FromInt32(1))
						if v1452 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1452 {
							cachePtr86 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v1452 || ((*TAllocCache)(unsafe.Pointer(cachePtr86)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr86)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, value2Ptr)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(value2Ptr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr86)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr86)).FfirstObjPtr = value2Ptr
							(*TAllocCache)(unsafe.Pointer(cachePtr86)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, value2Ptr)
					}
				}
			}
			*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) = dictPtr
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = dictPtr
	} else {
		(*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount++
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclPtrSetVarIdx(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 48)), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), dictPtr, int32(TCL_LEAVE_ERR_MSG), opnd2)
		checkInterp = int32(1)
		v1454 = dictPtr
		v1453 = *(*TTcl_Size)(unsafe.Pointer(v1454))
		*(*TTcl_Size)(unsafe.Pointer(v1454))--
		if !(v1453 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Flength = int64(-libc.Int32FromInt32(1))
				if v1455 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1455 {
					cachePtr87 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v1455 || ((*TAllocCache)(unsafe.Pointer(cachePtr87)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr87)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, dictPtr)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(dictPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr87)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr87)).FfirstObjPtr = dictPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr87)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, dictPtr)
			}
		}
		if *(*uintptr)(unsafe.Pointer(bp + 8)) == libc.UintptrFromInt32(0) {
			goto gotError
		}
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + 9))) == int32(INST_POP) {
		pc += uintptr(libc.Int32FromInt32(10))
		cleanup = cleanup
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			goto cleanupV_pushObjResultPtr
		} else {
			goto cleanupV
		}
	}
	pc += uintptr(libc.Int32FromInt32(9))
	cleanup = cleanup
	if int32(1) != 0 {
		if int32(1) > 0 {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
		}
		goto cleanupV_pushObjResultPtr
	} else {
		goto cleanupV
	}
_233:
	;
_232:
	;
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	*(*uintptr)(unsafe.Pointer(bp + 48)) = compiledLocals + uintptr(opnd)*16
	for (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_LINK) != 0 {
		*(*uintptr)(unsafe.Pointer(bp + 48)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
	}
	if !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)|libc.Int32FromInt32(VAR_TRACED_READ)) != 0 || (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 && (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr != libc.UintptrFromInt32(0) && (*TVar1)(unsafe.Pointer((*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr)).Fflags&int32(VAR_TRACED_READ) != 0) && *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) != 0 {
		dictPtr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
	} else {
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		dictPtr = XTclPtrGetVarIdx(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 48)), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), 0, opnd)
		checkInterp = int32(1)
	}
	if dictPtr == libc.UintptrFromInt32(0) {
		if v1456 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1456 {
			cachePtr88 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1456 || (*TAllocCache)(unsafe.Pointer(cachePtr88)).FnumObjects == libc.Uint64FromInt32(0) {
			dictPtr = XTclThreadAllocObj(tls)
		} else {
			dictPtr = (*TAllocCache)(unsafe.Pointer(cachePtr88)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr88)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(dictPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr88)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr = libc.UintptrFromInt32(0)
		allocateDict = int32(1)
	} else {
		allocateDict = libc.BoolInt32((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount > int64(1))
		if allocateDict != 0 {
			dictPtr = XTcl_DuplicateObj(tls, dictPtr)
		}
	}
	if XTcl_DictObjGet(tls, interp4, dictPtr, *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)), bp+16) != TCL_OK {
		if allocateDict != 0 {
			v1458 = dictPtr
			v1457 = *(*TTcl_Size)(unsafe.Pointer(v1458))
			*(*TTcl_Size)(unsafe.Pointer(v1458))--
			if !(v1457 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Flength = int64(-libc.Int32FromInt32(1))
					if v1459 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1459 {
						cachePtr89 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v1459 || ((*TAllocCache)(unsafe.Pointer(cachePtr89)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr89)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, dictPtr)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(dictPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr89)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr89)).FfirstObjPtr = dictPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr89)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, dictPtr)
				}
			}
		}
		goto gotError
	}
	/*
	 * Note that a non-existent key results in a NULL valuePtr, which is a
	 * case handled separately below. What we *can* say at this point is
	 * that the write-back will always succeed.
	 */
	switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) {
	case int32(INST_DICT_APPEND):
		if *(*uintptr)(unsafe.Pointer(bp + 16)) == libc.UintptrFromInt32(0) {
			XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dictPtr, *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)), *(*uintptr)(unsafe.Pointer(tosPtr)))
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount > int64(1) {
				*(*uintptr)(unsafe.Pointer(bp + 16)) = XTcl_DuplicateObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
				XTcl_AppendObjToObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), *(*uintptr)(unsafe.Pointer(tosPtr)))
				XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dictPtr, *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)), *(*uintptr)(unsafe.Pointer(bp + 16)))
			} else {
				XTcl_AppendObjToObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), *(*uintptr)(unsafe.Pointer(tosPtr)))
				/*
				 * Must invalidate the string representation of dictionary
				 * here because we have directly updated the internal
				 * representation; if we don't, callers could see the wrong
				 * string rep despite the internal version of the dictionary
				 * having the correct value. [Bug 3079830]
				 */
				_isobjPtr7 = dictPtr
				if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr7)).Fbytes != libc.UintptrFromInt32(0) {
					if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr7)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr7)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(_isobjPtr7)).Fbytes = libc.UintptrFromInt32(0)
				}
			}
		}
	case int32(INST_DICT_LAPPEND):
		/*
		 * More complex because list-append can fail.
		 */
		if *(*uintptr)(unsafe.Pointer(bp + 16)) == libc.UintptrFromInt32(0) {
			XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dictPtr, *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)), XTcl_NewListObj(tls, int64(1), tosPtr))
			break
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount > int64(1) {
				*(*uintptr)(unsafe.Pointer(bp + 16)) = XTcl_DuplicateObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
				if XTcl_ListObjAppendElement(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 16)), *(*uintptr)(unsafe.Pointer(tosPtr))) != TCL_OK {
					v1461 = *(*uintptr)(unsafe.Pointer(bp + 16))
					v1460 = *(*TTcl_Size)(unsafe.Pointer(v1461))
					*(*TTcl_Size)(unsafe.Pointer(v1461))--
					if !(v1460 > int64(1)) {
						if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr)).FfreeIntRepProc != 0) {
							if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
								XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes)
							}
							(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength = int64(-libc.Int32FromInt32(1))
							if v1462 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1462 {
								cachePtr90 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
							}
							if v1462 || ((*TAllocCache)(unsafe.Pointer(cachePtr90)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr90)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
								XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
							} else {
								(*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr90)).FfirstObjPtr
								(*TAllocCache)(unsafe.Pointer(cachePtr90)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp + 16))
								(*TAllocCache)(unsafe.Pointer(cachePtr90)).FnumObjects++
							}
						} else {
							XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
						}
					}
					if allocateDict != 0 {
						v1464 = dictPtr
						v1463 = *(*TTcl_Size)(unsafe.Pointer(v1464))
						*(*TTcl_Size)(unsafe.Pointer(v1464))--
						if !(v1463 > int64(1)) {
							if !((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr)).FfreeIntRepProc != 0) {
								if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
									XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes)
								}
								(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Flength = int64(-libc.Int32FromInt32(1))
								if v1465 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1465 {
									cachePtr91 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
								}
								if v1465 || ((*TAllocCache)(unsafe.Pointer(cachePtr91)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr91)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
									XTclThreadFreeObj(tls, dictPtr)
								} else {
									(*(*struct {
										Fptr1 uintptr
										Fptr2 uintptr
									})(unsafe.Pointer(dictPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr91)).FfirstObjPtr
									(*TAllocCache)(unsafe.Pointer(cachePtr91)).FfirstObjPtr = dictPtr
									(*TAllocCache)(unsafe.Pointer(cachePtr91)).FnumObjects++
								}
							} else {
								XTclFreeObj(tls, dictPtr)
							}
						}
					}
					goto gotError
				}
				XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dictPtr, *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8)), *(*uintptr)(unsafe.Pointer(bp + 16)))
			} else {
				if XTcl_ListObjAppendElement(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 16)), *(*uintptr)(unsafe.Pointer(tosPtr))) != TCL_OK {
					if allocateDict != 0 {
						v1467 = dictPtr
						v1466 = *(*TTcl_Size)(unsafe.Pointer(v1467))
						*(*TTcl_Size)(unsafe.Pointer(v1467))--
						if !(v1466 > int64(1)) {
							if !((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr)).FfreeIntRepProc != 0) {
								if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
									XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes)
								}
								(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Flength = int64(-libc.Int32FromInt32(1))
								if v1468 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1468 {
									cachePtr92 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
								}
								if v1468 || ((*TAllocCache)(unsafe.Pointer(cachePtr92)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr92)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
									XTclThreadFreeObj(tls, dictPtr)
								} else {
									(*(*struct {
										Fptr1 uintptr
										Fptr2 uintptr
									})(unsafe.Pointer(dictPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr92)).FfirstObjPtr
									(*TAllocCache)(unsafe.Pointer(cachePtr92)).FfirstObjPtr = dictPtr
									(*TAllocCache)(unsafe.Pointer(cachePtr92)).FnumObjects++
								}
							} else {
								XTclFreeObj(tls, dictPtr)
							}
						}
					}
					goto gotError
				}
				/*
				 * Must invalidate the string representation of dictionary
				 * here because we have directly updated the internal
				 * representation; if we don't, callers could see the wrong
				 * string rep despite the internal version of the dictionary
				 * having the correct value. [Bug 3079830]
				 */
				_isobjPtr8 = dictPtr
				if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr8)).Fbytes != libc.UintptrFromInt32(0) {
					if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr8)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr8)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(_isobjPtr8)).Fbytes = libc.UintptrFromInt32(0)
				}
			}
		}
	default:
		XTcl_Panic(tls, __ccgo_ts+32790, 0)
	}
	if !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_DEAD_HASH)|libc.Int32FromInt32(VAR_CONSTANT)) != 0 || (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 && (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr != libc.UintptrFromInt32(0) && (*TVar1)(unsafe.Pointer((*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr)).Fflags&(libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_DEAD_HASH)|libc.Int32FromInt32(VAR_CONSTANT)) != 0) {
		if allocateDict != 0 {
			value2Ptr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
			(*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount++
			if value2Ptr != libc.UintptrFromInt32(0) {
				v1470 = value2Ptr
				v1469 = *(*TTcl_Size)(unsafe.Pointer(v1470))
				*(*TTcl_Size)(unsafe.Pointer(v1470))--
				if !(v1469 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Flength = int64(-libc.Int32FromInt32(1))
						if v1471 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1471 {
							cachePtr93 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v1471 || ((*TAllocCache)(unsafe.Pointer(cachePtr93)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr93)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, value2Ptr)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(value2Ptr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr93)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr93)).FfirstObjPtr = value2Ptr
							(*TAllocCache)(unsafe.Pointer(cachePtr93)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, value2Ptr)
					}
				}
			}
			*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) = dictPtr
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = dictPtr
	} else {
		(*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount++
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclPtrSetVarIdx(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 48)), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), dictPtr, int32(TCL_LEAVE_ERR_MSG), opnd)
		checkInterp = int32(1)
		v1473 = dictPtr
		v1472 = *(*TTcl_Size)(unsafe.Pointer(v1473))
		*(*TTcl_Size)(unsafe.Pointer(v1473))--
		if !(v1472 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Flength = int64(-libc.Int32FromInt32(1))
				if v1474 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1474 {
					cachePtr94 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v1474 || ((*TAllocCache)(unsafe.Pointer(cachePtr94)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr94)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, dictPtr)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(dictPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr94)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr94)).FfirstObjPtr = dictPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr94)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, dictPtr)
			}
		}
		if *(*uintptr)(unsafe.Pointer(bp + 8)) == libc.UintptrFromInt32(0) {
			goto gotError
		}
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + 5))) == int32(INST_POP) {
		if false {
			if 0 != 0 {
				if 0 > 0 {
					v1477 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v1478 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1478)) = v1477
					(*TTcl_Obj)(unsafe.Pointer(v1477)).FrefCount++
				} else {
					tosPtr += 8
					v1479 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1479)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(6))
			goto cleanup0
		} else {
			if 0 != 0 {
				if 0 > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(6))
				switch libc.Int32FromInt32(2) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(6))
				switch libc.Int32FromInt32(2) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _1476
	_1476:
		;
		goto _1475
	_1475: /**/ //
	}
	if false {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v1482 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1483 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1483)) = v1482
				(*TTcl_Obj)(unsafe.Pointer(v1482)).FrefCount++
			} else {
				tosPtr += 8
				v1484 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1484)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(5))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(5))
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(5))
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1481
_1481:
	;
	goto _1480
_1480: /**/
	; //
_234:
	;
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	v1485 = tosPtr
	tosPtr -= 8
	dictPtr = *(*uintptr)(unsafe.Pointer(v1485))
	searchPtr = XTcl_Alloc(tls, uint64(24))
	if XTcl_DictObjFirst(tls, interp4, dictPtr, searchPtr, bp+456, bp+16, bp+452) != TCL_OK {
		/*
		 * dictPtr is no longer on the stack, and we're not
		 * moving it into the internalrep of an iterator.  We need
		 * to drop the refcount [Tcl Bug 9b352768e6].
		 */
		_objPtr35 = dictPtr
		v1487 = _objPtr35
		v1486 = *(*TTcl_Size)(unsafe.Pointer(v1487))
		*(*TTcl_Size)(unsafe.Pointer(v1487))--
		if v1486 <= int64(1) {
			XTclFreeObj(tls, _objPtr35)
		}
		XTclpFree(tls, searchPtr)
		goto gotError
	}
	if v1488 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1488 {
		cachePtr95 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1488 || (*TAllocCache)(unsafe.Pointer(cachePtr95)).FnumObjects == libc.Uint64FromInt32(0) {
		statePtr = XTclThreadAllocObj(tls)
	} else {
		statePtr = (*TAllocCache)(unsafe.Pointer(cachePtr95)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr95)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(statePtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr95)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(statePtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(statePtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(statePtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(statePtr)).FtypePtr = libc.UintptrFromInt32(0)
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp + 480))).Fptr1 = searchPtr
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp + 480))).Fptr2 = dictPtr
	XTcl_StoreInternalRep(tls, statePtr, uintptr(unsafe.Pointer(&_dictIteratorType)), bp+480)
	*(*uintptr)(unsafe.Pointer(bp + 48)) = compiledLocals + uintptr(opnd)*16
	if *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))).FtypePtr == uintptr(unsafe.Pointer(&_dictIteratorType)) {
			XTcl_Panic(tls, __ccgo_ts+32809, 0)
		}
		v1490 = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
		v1489 = *(*TTcl_Size)(unsafe.Pointer(v1490))
		*(*TTcl_Size)(unsafe.Pointer(v1490))--
		if !(v1489 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))).Flength = int64(-libc.Int32FromInt32(1))
				if v1491 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1491 {
					cachePtr96 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v1491 || ((*TAllocCache)(unsafe.Pointer(cachePtr96)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr96)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr96)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr96)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
					(*TAllocCache)(unsafe.Pointer(cachePtr96)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))
			}
		}
	}
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) = statePtr
	(*TTcl_Obj)(unsafe.Pointer(statePtr)).FrefCount++
	goto pushDictIteratorResult
_235:
	;
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	statePtr = *(*uintptr)(unsafe.Pointer(compiledLocals + uintptr(opnd)*16 + 8))
	if v1494 = statePtr != 0; v1494 {
		if (*TTcl_Obj)(unsafe.Pointer(statePtr)).FtypePtr == uintptr(unsafe.Pointer(&_dictIteratorType)) {
			v1493 = statePtr + 32
		} else {
			v1493 = libc.UintptrFromInt32(0)
		}
		v1492 = v1493
		irPtr = v1492
	}
	if v1494 && v1492 != 0 {
		searchPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
		XTcl_DictObjNext(tls, searchPtr, bp+456, bp+16, bp+452)
	} else {
		XTcl_Panic(tls, __ccgo_ts+32831, 0)
	}
	goto pushDictIteratorResult
pushDictIteratorResult:
	;
	if *(*int32)(unsafe.Pointer(bp + 452)) != 0 {
		if v1495 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1495 {
			cachePtr97 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1495 || (*TAllocCache)(unsafe.Pointer(cachePtr97)).FnumObjects == libc.Uint64FromInt32(0) {
			emptyPtr = XTclThreadAllocObj(tls)
		} else {
			emptyPtr = (*TAllocCache)(unsafe.Pointer(cachePtr97)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr97)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(emptyPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr97)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(emptyPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(emptyPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(emptyPtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(emptyPtr)).FtypePtr = libc.UintptrFromInt32(0)
		v1496 = emptyPtr
		tosPtr += 8
		v1497 = tosPtr
		*(*uintptr)(unsafe.Pointer(v1497)) = v1496
		(*TTcl_Obj)(unsafe.Pointer(v1496)).FrefCount++
		v1498 = emptyPtr
		tosPtr += 8
		v1499 = tosPtr
		*(*uintptr)(unsafe.Pointer(v1499)) = v1498
		(*TTcl_Obj)(unsafe.Pointer(v1498)).FrefCount++
	} else {
		v1500 = *(*uintptr)(unsafe.Pointer(bp + 16))
		tosPtr += 8
		v1501 = tosPtr
		*(*uintptr)(unsafe.Pointer(v1501)) = v1500
		(*TTcl_Obj)(unsafe.Pointer(v1500)).FrefCount++
		v1502 = *(*uintptr)(unsafe.Pointer(bp + 456))
		tosPtr += 8
		v1503 = tosPtr
		*(*uintptr)(unsafe.Pointer(v1503)) = v1502
		(*TTcl_Obj)(unsafe.Pointer(v1502)).FrefCount++
	}
	/*
	 * The INST_DICT_FIRST and INST_DICT_NEXT instructions are always
	 * followed by a conditional jump, so we can take advantage of this to
	 * do some peephole optimization (note that we're careful to not close
	 * out someone doing something else).
	 */
	pc += uintptr(libc.Int32FromInt32(5))
	switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc))) {
	case int32(INST_JUMP_FALSE1):
		goto _1506
	case int32(INST_JUMP_TRUE1):
		goto _1507
	case int32(INST_JUMP_FALSE4):
		goto _1508
	case int32(INST_JUMP_TRUE4):
		goto _1509
	default:
		goto _1510
	}
	goto _1511
_1506:
	;
_1514:
	;
	if true {
		if 0 != 0 {
			if 0 > 0 {
				v1515 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1516 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1516)) = v1515
				(*TTcl_Obj)(unsafe.Pointer(v1515)).FrefCount++
			} else {
				tosPtr += 8
				v1517 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1517)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		if *(*int32)(unsafe.Pointer(bp + 452)) != 0 {
			v1518 = int32(2)
		} else {
			v1518 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
		}
		pc += uintptr(v1518)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			if *(*int32)(unsafe.Pointer(bp + 452)) != 0 {
				v1519 = int32(2)
			} else {
				v1519 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
			}
			pc += uintptr(v1519)
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 452)) != 0 {
				v1520 = int32(2)
			} else {
				v1520 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
			}
			pc += uintptr(v1520)
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1513
_1513:
	;
	if 0 != 0 {
		goto _1514
	}
	goto _1512
_1512:
	;
	goto _1511
_1507:
	;
	if true {
		if 0 != 0 {
			if 0 > 0 {
				v1523 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1524 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1524)) = v1523
				(*TTcl_Obj)(unsafe.Pointer(v1523)).FrefCount++
			} else {
				tosPtr += 8
				v1525 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1525)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		if *(*int32)(unsafe.Pointer(bp + 452)) != 0 {
			v1526 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
		} else {
			v1526 = int32(2)
		}
		pc += uintptr(v1526)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			if *(*int32)(unsafe.Pointer(bp + 452)) != 0 {
				v1527 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
			} else {
				v1527 = int32(2)
			}
			pc += uintptr(v1527)
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 452)) != 0 {
				v1528 = int32(*(*int8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))
			} else {
				v1528 = int32(2)
			}
			pc += uintptr(v1528)
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1522
_1522:
	;
	goto _1521
_1521: /**/
	; //
	goto _1511
_1508:
	;
	if true {
		if 0 != 0 {
			if 0 > 0 {
				v1531 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1532 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1532)) = v1531
				(*TTcl_Obj)(unsafe.Pointer(v1531)).FrefCount++
			} else {
				tosPtr += 8
				v1533 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1533)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		if *(*int32)(unsafe.Pointer(bp + 452)) != 0 {
			v1534 = int32(5)
		} else {
			v1534 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
		}
		pc += uintptr(v1534)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			if *(*int32)(unsafe.Pointer(bp + 452)) != 0 {
				v1535 = int32(5)
			} else {
				v1535 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
			}
			pc += uintptr(v1535)
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 452)) != 0 {
				v1536 = int32(5)
			} else {
				v1536 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
			}
			pc += uintptr(v1536)
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1530
_1530:
	;
	goto _1529
_1529: /**/
	; //
	goto _1511
_1509:
	;
	if true {
		if 0 != 0 {
			if 0 > 0 {
				v1539 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1540 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1540)) = v1539
				(*TTcl_Obj)(unsafe.Pointer(v1539)).FrefCount++
			} else {
				tosPtr += 8
				v1541 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1541)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		if *(*int32)(unsafe.Pointer(bp + 452)) != 0 {
			v1542 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
		} else {
			v1542 = int32(5)
		}
		pc += uintptr(v1542)
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			if *(*int32)(unsafe.Pointer(bp + 452)) != 0 {
				v1543 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
			} else {
				v1543 = int32(5)
			}
			pc += uintptr(v1543)
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp + 452)) != 0 {
				v1544 = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
			} else {
				v1544 = int32(5)
			}
			pc += uintptr(v1544)
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1538
_1538:
	;
	goto _1537
_1537: /**/
	; //
	goto _1511
_1510:
	;
	if *(*int32)(unsafe.Pointer(bp + 452)) < 0 {
		if v1545 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1545 {
			cachePtr98 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1545 || (*TAllocCache)(unsafe.Pointer(cachePtr98)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr98)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr98)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr98)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = libc.UintptrFromInt32(0)
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FinternalRep)) = int64(-libc.Int32FromInt32(1))
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	} else {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(constants + libc.BoolUintptr(*(*int32)(unsafe.Pointer(bp + 452)) > libc.Int32FromInt32(0))*8))
	}
	if true {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v1548 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1549 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1549)) = v1548
				(*TTcl_Obj)(unsafe.Pointer(v1548)).FrefCount++
			} else {
				tosPtr += 8
				v1550 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1550)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(0))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(0))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(0))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1547
_1547:
	;
	goto _1546
_1546: /**/
	; //
	goto _1511
_1511:
	;
	goto _1505
_1505:
	;
	goto _1504
_1504: /**/
	; //
_236:
	;
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	opnd2 = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5) + libc.UintptrFromInt32(3))))))
	*(*uintptr)(unsafe.Pointer(bp + 48)) = compiledLocals + uintptr(opnd)*16
	duiPtr = (*(*TAuxData)(unsafe.Pointer((*TByteCode)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)).FauxDataArrayPtr + uintptr(opnd2)*16))).FclientData
	for (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_LINK) != 0 {
		*(*uintptr)(unsafe.Pointer(bp + 48)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
	}
	if !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)|libc.Int32FromInt32(VAR_TRACED_READ)) != 0 || (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 && (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr != libc.UintptrFromInt32(0) && (*TVar1)(unsafe.Pointer((*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr)).Fflags&int32(VAR_TRACED_READ) != 0) && *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) != 0 {
		dictPtr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
	} else {
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		dictPtr = XTclPtrGetVarIdx(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 48)), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), int32(TCL_LEAVE_ERR_MSG), opnd)
		checkInterp = int32(1)
		if dictPtr == libc.UintptrFromInt32(0) {
			goto gotError
		}
	}
	(*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount++
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)) + 32))).Fptr2 != 0 {
			v1552 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)) + 32))).Fptr2)).FspanStart
		} else {
			v1552 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)) + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 464)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)) + 32))).Fptr1 + 40 + uintptr(v1552)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)) + 32))).Fptr2 != 0 {
			v1553 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)) + 32))).Fptr2)).FspanLength
		} else {
			v1553 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = v1553
		v1551 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1551 = XTcl_ListObjGetElements(tls, interp4, *(*uintptr)(unsafe.Pointer(tosPtr)), bp+32, bp+464)
	}
	if v1551 != TCL_OK {
		goto gotError
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp + 32)) != (*TDictUpdateInfo)(unsafe.Pointer(duiPtr)).Flength {
		XTcl_Panic(tls, __ccgo_ts+32852, 0)
	}
	i4 = 0
	for {
		if !(i4 < *(*TTcl_Size)(unsafe.Pointer(bp + 32))) {
			break
		}
		if XTcl_DictObjGet(tls, interp4, dictPtr, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 464)) + uintptr(i4)*8)), bp+16) != TCL_OK {
			_objPtr36 = dictPtr
			v1556 = _objPtr36
			v1555 = *(*TTcl_Size)(unsafe.Pointer(v1556))
			*(*TTcl_Size)(unsafe.Pointer(v1556))--
			if v1555 <= int64(1) {
				XTclFreeObj(tls, _objPtr36)
			}
			goto gotError
		}
		*(*uintptr)(unsafe.Pointer(bp + 48)) = compiledLocals + uintptr(*(*TTcl_Size)(unsafe.Pointer(duiPtr + 8 + uintptr(i4)*8)))*16
		for (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_LINK) != 0 {
			*(*uintptr)(unsafe.Pointer(bp + 48)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
		}
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		if *(*uintptr)(unsafe.Pointer(bp + 16)) == libc.UintptrFromInt32(0) {
			XTclObjUnsetVar2(tls, interp4, *(*uintptr)(unsafe.Pointer((*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FvarFramePtr)).FlocalCachePtr + 16 + uintptr(*(*TTcl_Size)(unsafe.Pointer(duiPtr + 8 + uintptr(i4)*8)))*8)), libc.UintptrFromInt32(0), 0)
		} else {
			if XTclPtrSetVarIdx(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 48)), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 16)), int32(TCL_LEAVE_ERR_MSG), int32(*(*TTcl_Size)(unsafe.Pointer(duiPtr + 8 + uintptr(i4)*8)))) == libc.UintptrFromInt32(0) {
				checkInterp = int32(1)
				_objPtr37 = dictPtr
				v1558 = _objPtr37
				v1557 = *(*TTcl_Size)(unsafe.Pointer(v1558))
				*(*TTcl_Size)(unsafe.Pointer(v1558))--
				if v1557 <= int64(1) {
					XTclFreeObj(tls, _objPtr37)
				}
				goto gotError
			}
		}
		checkInterp = int32(1)
		goto _1554
	_1554:
		;
		i4++
	}
	v1560 = dictPtr
	v1559 = *(*TTcl_Size)(unsafe.Pointer(v1560))
	*(*TTcl_Size)(unsafe.Pointer(v1560))--
	if !(v1559 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Flength = int64(-libc.Int32FromInt32(1))
			if v1561 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1561 {
				cachePtr99 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v1561 || ((*TAllocCache)(unsafe.Pointer(cachePtr99)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr99)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, dictPtr)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(dictPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr99)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr99)).FfirstObjPtr = dictPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr99)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, dictPtr)
		}
	}
	if true {
		if 0 != 0 {
			if 0 > 0 {
				v1564 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1565 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1565)) = v1564
				(*TTcl_Obj)(unsafe.Pointer(v1564)).FrefCount++
			} else {
				tosPtr += 8
				v1566 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1566)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(9))
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(9))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(9))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1563
_1563:
	;
	goto _1562
_1562: /**/
	; //
_237:
	;
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	opnd2 = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(5) + libc.UintptrFromInt32(3))))))
	*(*uintptr)(unsafe.Pointer(bp + 48)) = compiledLocals + uintptr(opnd)*16
	duiPtr = (*(*TAuxData)(unsafe.Pointer((*TByteCode)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)).FauxDataArrayPtr + uintptr(opnd2)*16))).FclientData
	for (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_LINK) != 0 {
		*(*uintptr)(unsafe.Pointer(bp + 48)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
	}
	if !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)|libc.Int32FromInt32(VAR_TRACED_READ)) != 0 || (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 && (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr != libc.UintptrFromInt32(0) && (*TVar1)(unsafe.Pointer((*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr)).Fflags&int32(VAR_TRACED_READ) != 0) && *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) != 0 {
		dictPtr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
	} else {
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		dictPtr = XTclPtrGetVarIdx(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 48)), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), 0, opnd)
		checkInterp = int32(1)
	}
	if dictPtr == libc.UintptrFromInt32(0) {
		if false {
			if 0 != 0 {
				if 0 > 0 {
					v1569 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v1570 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1570)) = v1569
					(*TTcl_Obj)(unsafe.Pointer(v1569)).FrefCount++
				} else {
					tosPtr += 8
					v1571 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1571)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(9))
			goto cleanup0
		} else {
			if 0 != 0 {
				if 0 > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(9))
				switch libc.Int32FromInt32(1) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(9))
				switch libc.Int32FromInt32(1) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _1568
	_1568:
		;
		goto _1567
	_1567: /**/ //
	}
	if v1575 = XTcl_DictObjSize(tls, interp4, dictPtr, bp+32) != TCL_OK; !v1575 {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)) + 32))).Fptr2 != 0 {
				v1573 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)) + 32))).Fptr2)).FspanStart
			} else {
				v1573 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)) + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 464)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)) + 32))).Fptr1 + 40 + uintptr(v1573)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)) + 32))).Fptr2 != 0 {
				v1574 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)) + 32))).Fptr2)).FspanLength
			} else {
				v1574 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tosPtr)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = v1574
			v1572 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1572 = XTcl_ListObjGetElements(tls, interp4, *(*uintptr)(unsafe.Pointer(tosPtr)), bp+32, bp+464)
		}
	}
	if v1575 || v1572 != TCL_OK {
		goto gotError
	}
	allocdict = libc.BoolInt32((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount > int64(1))
	if allocdict != 0 {
		dictPtr = XTcl_DuplicateObj(tls, dictPtr)
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp + 32)) > 0 {
		_isobjPtr9 = dictPtr
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr9)).Fbytes != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr9)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr9)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(_isobjPtr9)).Fbytes = libc.UintptrFromInt32(0)
		}
	}
	i4 = 0
	for {
		if !(i4 < *(*TTcl_Size)(unsafe.Pointer(bp + 32))) {
			break
		}
		var2Ptr = compiledLocals + uintptr(*(*TTcl_Size)(unsafe.Pointer(duiPtr + 8 + uintptr(i4)*8)))*16
		for (*TVar)(unsafe.Pointer(var2Ptr)).Fflags&int32(VAR_LINK) != 0 {
			var2Ptr = *(*uintptr)(unsafe.Pointer(var2Ptr + 8))
		}
		if !((*TVar)(unsafe.Pointer(var2Ptr)).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)|libc.Int32FromInt32(VAR_TRACED_READ)) != 0 || (*TVar)(unsafe.Pointer(var2Ptr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 && (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(var2Ptr)).Fentry.FtablePtr)).FarrayPtr != libc.UintptrFromInt32(0) && (*TVar1)(unsafe.Pointer((*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(var2Ptr)).Fentry.FtablePtr)).FarrayPtr)).Fflags&int32(VAR_TRACED_READ) != 0) && *(*uintptr)(unsafe.Pointer(var2Ptr + 8)) != 0 {
			*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(var2Ptr + 8))
		} else {
			(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
			*(*uintptr)(unsafe.Pointer(bp + 16)) = XTclPtrGetVarIdx(tls, interp4, var2Ptr, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), 0, int32(*(*TTcl_Size)(unsafe.Pointer(duiPtr + 8 + uintptr(i4)*8))))
			checkInterp = int32(1)
		}
		if *(*uintptr)(unsafe.Pointer(bp + 16)) == libc.UintptrFromInt32(0) {
			XTcl_DictObjRemove(tls, interp4, dictPtr, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 464)) + uintptr(i4)*8)))
		} else {
			if dictPtr == *(*uintptr)(unsafe.Pointer(bp + 16)) {
				XTcl_DictObjPut(tls, interp4, dictPtr, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 464)) + uintptr(i4)*8)), XTcl_DuplicateObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16))))
			} else {
				XTcl_DictObjPut(tls, interp4, dictPtr, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 464)) + uintptr(i4)*8)), *(*uintptr)(unsafe.Pointer(bp + 16)))
			}
		}
		goto _1576
	_1576:
		;
		i4++
	}
	if !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_DEAD_HASH)|libc.Int32FromInt32(VAR_CONSTANT)) != 0 || (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 && (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr != libc.UintptrFromInt32(0) && (*TVar1)(unsafe.Pointer((*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fentry.FtablePtr)).FarrayPtr)).Fflags&(libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_DEAD_HASH)|libc.Int32FromInt32(VAR_CONSTANT)) != 0) {
		(*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount++
		v1578 = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
		v1577 = *(*TTcl_Size)(unsafe.Pointer(v1578))
		*(*TTcl_Size)(unsafe.Pointer(v1578))--
		if !(v1577 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))).Flength = int64(-libc.Int32FromInt32(1))
				if v1579 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1579 {
					cachePtr100 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v1579 || ((*TAllocCache)(unsafe.Pointer(cachePtr100)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr100)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr100)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr100)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
					(*TAllocCache)(unsafe.Pointer(cachePtr100)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)))
			}
		}
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8)) = dictPtr
	} else {
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclPtrSetVarIdx(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 48)), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), dictPtr, int32(TCL_LEAVE_ERR_MSG), opnd)
		checkInterp = int32(1)
		if *(*uintptr)(unsafe.Pointer(bp + 8)) == libc.UintptrFromInt32(0) {
			if allocdict != 0 {
				v1581 = dictPtr
				v1580 = *(*TTcl_Size)(unsafe.Pointer(v1581))
				*(*TTcl_Size)(unsafe.Pointer(v1581))--
				if !(v1580 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Flength = int64(-libc.Int32FromInt32(1))
						if v1582 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1582 {
							cachePtr101 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v1582 || ((*TAllocCache)(unsafe.Pointer(cachePtr101)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr101)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, dictPtr)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(dictPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr101)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr101)).FfirstObjPtr = dictPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr101)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, dictPtr)
					}
				}
			}
			goto gotError
		}
	}
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v1585 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1586 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1586)) = v1585
				(*TTcl_Obj)(unsafe.Pointer(v1585)).FrefCount++
			} else {
				tosPtr += 8
				v1587 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1587)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(9))
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(9))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(9))
			switch libc.Int32FromInt32(1) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1584
_1584:
	;
	goto _1583
_1583: /**/
	; //
_238:
	;
	dictPtr = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8))
	listPtr2 = *(*uintptr)(unsafe.Pointer(tosPtr))
	if (*TTcl_Obj)(unsafe.Pointer(listPtr2)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listPtr2 + 32))).Fptr2 != 0 {
			v1589 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr2 + 32))).Fptr2)).FspanStart
		} else {
			v1589 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr2 + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 24)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listPtr2 + 32))).Fptr1 + 40 + uintptr(v1589)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listPtr2 + 32))).Fptr2 != 0 {
			v1590 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr2 + 32))).Fptr2)).FspanLength
		} else {
			v1590 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr2 + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = v1590
		v1588 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1588 = XTcl_ListObjGetElements(tls, interp4, listPtr2, bp+40, bp+24)
	}
	if v1588 != TCL_OK {
		goto gotError
	}
	*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclDictWithInit(tls, interp4, dictPtr, *(*TTcl_Size)(unsafe.Pointer(bp + 40)), *(*uintptr)(unsafe.Pointer(bp + 24)))
	if *(*uintptr)(unsafe.Pointer(bp + 8)) == libc.UintptrFromInt32(0) {
		goto gotError
	}
	if false {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v1593 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1594 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1594)) = v1593
				(*TTcl_Obj)(unsafe.Pointer(v1593)).FrefCount++
			} else {
				tosPtr += 8
				v1595 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1595)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1592
_1592:
	;
	goto _1591
_1591: /**/
	; //
_239:
	;
	v1596 = tosPtr
	tosPtr -= 8
	keysPtr = *(*uintptr)(unsafe.Pointer(v1596))
	varNamePtr = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8))
	listPtr2 = *(*uintptr)(unsafe.Pointer(tosPtr))
	if (*TTcl_Obj)(unsafe.Pointer(listPtr2)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listPtr2 + 32))).Fptr2 != 0 {
			v1598 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr2 + 32))).Fptr2)).FspanStart
		} else {
			v1598 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr2 + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 24)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listPtr2 + 32))).Fptr1 + 40 + uintptr(v1598)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listPtr2 + 32))).Fptr2 != 0 {
			v1599 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr2 + 32))).Fptr2)).FspanLength
		} else {
			v1599 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr2 + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = v1599
		v1597 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1597 = XTcl_ListObjGetElements(tls, interp4, listPtr2, bp+40, bp+24)
	}
	if v1597 != TCL_OK {
		v1601 = keysPtr
		v1600 = *(*TTcl_Size)(unsafe.Pointer(v1601))
		*(*TTcl_Size)(unsafe.Pointer(v1601))--
		if !(v1600 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(keysPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(keysPtr)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(keysPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(keysPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(keysPtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(keysPtr)).Flength = int64(-libc.Int32FromInt32(1))
				if v1602 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1602 {
					cachePtr102 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v1602 || ((*TAllocCache)(unsafe.Pointer(cachePtr102)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr102)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, keysPtr)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(keysPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr102)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr102)).FfirstObjPtr = keysPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr102)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, keysPtr)
			}
		}
		goto gotError
	}
	*(*uintptr)(unsafe.Pointer(bp + 48)) = XTclObjLookupVarEx(tls, interp4, varNamePtr, libc.UintptrFromInt32(0), int32(TCL_LEAVE_ERR_MSG), __ccgo_ts+5383, int32(1), int32(1), bp+56)
	if *(*uintptr)(unsafe.Pointer(bp + 48)) == libc.UintptrFromInt32(0) {
		v1604 = keysPtr
		v1603 = *(*TTcl_Size)(unsafe.Pointer(v1604))
		*(*TTcl_Size)(unsafe.Pointer(v1604))--
		if !(v1603 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(keysPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(keysPtr)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(keysPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(keysPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(keysPtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(keysPtr)).Flength = int64(-libc.Int32FromInt32(1))
				if v1605 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1605 {
					cachePtr103 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v1605 || ((*TAllocCache)(unsafe.Pointer(cachePtr103)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr103)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, keysPtr)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(keysPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr103)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr103)).FfirstObjPtr = keysPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr103)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, keysPtr)
			}
		}
		goto gotError
	}
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	result = XTclDictWithFinish(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 48)), *(*uintptr)(unsafe.Pointer(bp + 56)), varNamePtr, libc.UintptrFromInt32(0), -int32(1), int32(*(*TTcl_Size)(unsafe.Pointer(bp + 40))), *(*uintptr)(unsafe.Pointer(bp + 24)), keysPtr)
	checkInterp = int32(1)
	v1607 = keysPtr
	v1606 = *(*TTcl_Size)(unsafe.Pointer(v1607))
	*(*TTcl_Size)(unsafe.Pointer(v1607))--
	if !(v1606 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(keysPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(keysPtr)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(keysPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(keysPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(keysPtr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(keysPtr)).Flength = int64(-libc.Int32FromInt32(1))
			if v1608 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1608 {
				cachePtr104 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v1608 || ((*TAllocCache)(unsafe.Pointer(cachePtr104)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr104)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, keysPtr)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(keysPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr104)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr104)).FfirstObjPtr = keysPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr104)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, keysPtr)
		}
	}
	if result != TCL_OK {
		goto gotError
	}
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v1611 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1612 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1612)) = v1611
				(*TTcl_Obj)(unsafe.Pointer(v1611)).FrefCount++
			} else {
				tosPtr += 8
				v1613 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1613)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(1))
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(1))
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1610
_1610:
	;
	goto _1609
_1609: /**/
	; //
_240:
	;
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	listPtr2 = *(*uintptr)(unsafe.Pointer(tosPtr + uintptr(-libc.Int32FromInt32(1))*8))
	keysPtr = *(*uintptr)(unsafe.Pointer(tosPtr))
	*(*uintptr)(unsafe.Pointer(bp + 48)) = compiledLocals + uintptr(opnd)*16
	if (*TTcl_Obj)(unsafe.Pointer(listPtr2)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listPtr2 + 32))).Fptr2 != 0 {
			v1615 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr2 + 32))).Fptr2)).FspanStart
		} else {
			v1615 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr2 + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 24)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listPtr2 + 32))).Fptr1 + 40 + uintptr(v1615)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listPtr2 + 32))).Fptr2 != 0 {
			v1616 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr2 + 32))).Fptr2)).FspanLength
		} else {
			v1616 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr2 + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = v1616
		v1614 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1614 = XTcl_ListObjGetElements(tls, interp4, listPtr2, bp+40, bp+24)
	}
	if v1614 != TCL_OK {
		goto gotError
	}
	for (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)))).Fflags&int32(VAR_LINK) != 0 {
		*(*uintptr)(unsafe.Pointer(bp + 48)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + 8))
	}
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	result = XTclDictWithFinish(tls, interp4, *(*uintptr)(unsafe.Pointer(bp + 48)), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), opnd, int32(*(*TTcl_Size)(unsafe.Pointer(bp + 40))), *(*uintptr)(unsafe.Pointer(bp + 24)), keysPtr)
	checkInterp = int32(1)
	if result != TCL_OK {
		goto gotError
	}
	if false {
		if 0 != 0 {
			if 0 > 0 {
				v1619 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1620 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1620)) = v1619
				(*TTcl_Obj)(unsafe.Pointer(v1619)).FrefCount++
			} else {
				tosPtr += 8
				v1621 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1621)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(5))
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(5))
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(5))
			switch libc.Int32FromInt32(2) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1618
_1618:
	;
	goto _1617
_1617: /**/
	; //
	goto _243
	/*
	 *	   End of dictionary-related instructions.
	 * -----------------------------------------------------------------
	 */
_241:
	;
	switch uint32(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1)))) {
	case uint32(0): /* clicks */
		wval = libc.Int64FromUint64(XTclpGetClicks(tls))
	case uint32(1): /* microseconds */
		XTcl_GetTime(tls, bp+496)
		wval = (*(*TTcl_Time)(unsafe.Pointer(bp + 496))).Fsec*int64(1000000) + (*(*TTcl_Time)(unsafe.Pointer(bp + 496))).Fusec
	case uint32(2): /* milliseconds */
		XTcl_GetTime(tls, bp+496)
		wval = (*(*TTcl_Time)(unsafe.Pointer(bp + 496))).Fsec*int64(1000) + (*(*TTcl_Time)(unsafe.Pointer(bp + 496))).Fusec/int64(1000)
	case uint32(3): /* seconds */
		XTcl_GetTime(tls, bp+496)
		wval = (*(*TTcl_Time)(unsafe.Pointer(bp + 496))).Fsec
	default:
		XTcl_Panic(tls, __ccgo_ts+32893, 0)
		break
	}
	if v1622 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1622 {
		cachePtr105 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1622 || (*TAllocCache)(unsafe.Pointer(cachePtr105)).FnumObjects == libc.Uint64FromInt32(0) {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
	} else {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr105)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr105)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr105)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = libc.UintptrFromInt32(0)
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FinternalRep)) = wval
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	if true {
		if int32(1) != 0 {
			if int32(1) > 0 {
				v1625 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1626 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1626)) = v1625
				(*TTcl_Obj)(unsafe.Pointer(v1625)).FrefCount++
			} else {
				tosPtr += 8
				v1627 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1627)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(2))
		goto cleanup0
	} else {
		if int32(1) != 0 {
			if int32(1) > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(2))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(2))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1624
_1624:
	;
	goto _1623
_1623: /**/
	; //
	goto _243
_242:
	;
	XTcl_Panic(tls, __ccgo_ts+32935, libc.VaList(bp+544, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc)))))
_243:
	; /* end of switch on opCode */
	/*
	 * Block for variables needed to process exception returns.
	 */
	/*
	 * An external evaluation (INST_INVOKE or INST_EVAL) returned
	 * something different from TCL_OK, or else INST_BREAK or
	 * INST_CONTINUE were called.
	 */
	goto processExceptionReturn
processExceptionReturn:
	;
	if result == int32(TCL_CONTINUE) || result == int32(TCL_BREAK) {
		rangePtr = _GetExceptRangeForPc(tls, pc, result, (*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)
		if rangePtr == libc.UintptrFromInt32(0) {
			goto abnormalReturn
		}
		if (*TExceptionRange)(unsafe.Pointer(rangePtr)).Ftype1 == int32(CATCH_EXCEPTION_RANGE) {
			goto processCatch
		}
		for {
			v1628 = cleanup
			cleanup--
			if !(v1628 != 0) {
				break
			}
			v1629 = tosPtr
			tosPtr -= 8
			*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(v1629))
			v1631 = *(*uintptr)(unsafe.Pointer(bp + 16))
			v1630 = *(*TTcl_Size)(unsafe.Pointer(v1631))
			*(*TTcl_Size)(unsafe.Pointer(v1631))--
			if !(v1630 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength = int64(-libc.Int32FromInt32(1))
					if v1632 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1632 {
						cachePtr106 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v1632 || ((*TAllocCache)(unsafe.Pointer(cachePtr106)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr106)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr106)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr106)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp + 16))
						(*TAllocCache)(unsafe.Pointer(cachePtr106)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
				}
			}
		}
		if result == int32(TCL_BREAK) {
			result = TCL_OK
			pc = (*TByteCode)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)).FcodeStart + uintptr((*TExceptionRange)(unsafe.Pointer(rangePtr)).FbreakOffset)
			if true {
				if 0 != 0 {
					if 0 > 0 {
						v1635 = *(*uintptr)(unsafe.Pointer(bp + 8))
						tosPtr += 8
						v1636 = tosPtr
						*(*uintptr)(unsafe.Pointer(v1636)) = v1635
						(*TTcl_Obj)(unsafe.Pointer(v1635)).FrefCount++
					} else {
						tosPtr += 8
						v1637 = tosPtr
						*(*uintptr)(unsafe.Pointer(v1637)) = *(*uintptr)(unsafe.Pointer(bp + 8))
					}
				}
				pc += uintptr(libc.Int32FromInt32(0))
				goto cleanup0
			} else {
				if 0 != 0 {
					if 0 > 0 {
						(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
					}
					pc += uintptr(libc.Int32FromInt32(0))
					switch libc.Int32FromInt32(0) {
					case int32(1):
						goto cleanup1_pushObjResultPtr
					case int32(2):
						goto cleanup2_pushObjResultPtr
					case 0:
						break
					}
				} else {
					pc += uintptr(libc.Int32FromInt32(0))
					switch libc.Int32FromInt32(0) {
					case int32(1):
						goto cleanup1
					case int32(2):
						goto cleanup2
					case 0:
						break
					}
				}
			}
			goto _1634
		_1634:
			;
			goto _1633
		_1633: /**/
			//
		}
		if (*TExceptionRange)(unsafe.Pointer(rangePtr)).FcontinueOffset == int64(-libc.Int32FromInt32(1)) {
			goto checkForCatch
		}
		result = TCL_OK
		pc = (*TByteCode)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)).FcodeStart + uintptr((*TExceptionRange)(unsafe.Pointer(rangePtr)).FcontinueOffset)
		if true {
			if 0 != 0 {
				if 0 > 0 {
					v1640 = *(*uintptr)(unsafe.Pointer(bp + 8))
					tosPtr += 8
					v1641 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1641)) = v1640
					(*TTcl_Obj)(unsafe.Pointer(v1640)).FrefCount++
				} else {
					tosPtr += 8
					v1642 = tosPtr
					*(*uintptr)(unsafe.Pointer(v1642)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
			pc += uintptr(libc.Int32FromInt32(0))
			goto cleanup0
		} else {
			if 0 != 0 {
				if 0 > 0 {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
				}
				pc += uintptr(libc.Int32FromInt32(0))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1_pushObjResultPtr
				case int32(2):
					goto cleanup2_pushObjResultPtr
				case 0:
					break
				}
			} else {
				pc += uintptr(libc.Int32FromInt32(0))
				switch libc.Int32FromInt32(0) {
				case int32(1):
					goto cleanup1
				case int32(2):
					goto cleanup2
				case 0:
					break
				}
			}
		}
		goto _1639
	_1639:
		;
		goto _1638
	_1638: /**/
		//
	}
	goto checkForCatch
	/*
	 * Division by zero in an expression. Control only reaches this point
	 * by "goto divideByZero".
	 */
	goto divideByZero
divideByZero:
	;
	XTcl_SetObjResult(tls, interp4, XTcl_NewStringObj(tls, __ccgo_ts+32980, int64(-int32(1))))
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	XTcl_SetErrorCode(tls, interp4, libc.VaList(bp+544, __ccgo_ts+8919, __ccgo_ts+32995, __ccgo_ts+32980, libc.UintptrFromInt32(0)))
	checkInterp = int32(1)
	goto gotError
	goto outOfMemory
outOfMemory:
	;
	XTcl_SetObjResult(tls, interp4, XTcl_NewStringObj(tls, __ccgo_ts+1638, int64(-int32(1))))
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	XTcl_SetErrorCode(tls, interp4, libc.VaList(bp+544, __ccgo_ts+8919, __ccgo_ts+33003, __ccgo_ts+1638, libc.UintptrFromInt32(0)))
	checkInterp = int32(1)
	goto gotError
	/*
	 * Exponentiation of zero by negative number in an expression. Control
	 * only reaches this point by "goto exponOfZero".
	 */
	goto exponOfZero
exponOfZero:
	;
	XTcl_SetObjResult(tls, interp4, XTcl_NewStringObj(tls, __ccgo_ts+33015, int64(-int32(1))))
	(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
	XTcl_SetErrorCode(tls, interp4, libc.VaList(bp+544, __ccgo_ts+8919, __ccgo_ts+8925, __ccgo_ts+33015, libc.UintptrFromInt32(0)))
	checkInterp = int32(1)
	/*
	 * Almost all error paths feed through here rather than assigning to
	 * result themselves (for a small but consistent saving).
	 */
	goto gotError
gotError:
	;
	result = int32(TCL_ERROR)
	/*
	 * Execution has generated an "exception" such as TCL_ERROR. If the
	 * exception is an error, record information about what was being
	 * executed when the error occurred. Find the closest enclosing catch
	 * range, if any. If no enclosing catch range is found, stop execution
	 * and return the "exception" code.
	 */
	goto checkForCatch
checkForCatch:
	;
	if (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).Frewind != 0 {
		goto abnormalReturn
	}
	if result == int32(TCL_ERROR) && !((*TInterp)(unsafe.Pointer(interp4)).Fflags&libc.Int32FromInt32(ERR_ALREADY_LOGGED) != 0) {
		bytes = _GetSrcInfoForPc(tls, pc, (*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr, bp+520, bp+512, libc.UintptrFromInt32(0))
		(*TExecStack)(unsafe.Pointer((*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp4)).FexecEnvPtr)).FexecStackPtr)).FtosPtr = tosPtr
		if bytes != 0 {
			v1643 = *(*TTcl_Size)(unsafe.Pointer(bp + 520))
		} else {
			v1643 = 0
		}
		XTclLogCommandInfo(tls, interp4, (*TByteCode)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)).Fsource, bytes, v1643, *(*uintptr)(unsafe.Pointer(bp + 512)), tosPtr)
		checkInterp = int32(1)
	}
	*(*int32)(unsafe.Pointer(interp4 + 368)) &= ^libc.Int32FromInt32(ERR_ALREADY_LOGGED)
	/*
	 * Clear all expansions that may have started after the last
	 * INST_BEGIN_CATCH.
	 */
	for (*TTEBCdata)(unsafe.Pointer(TD)).FauxObjList != 0 {
		if (*TTEBCdata)(unsafe.Pointer(TD)).FcatchTop != TD+112-libc.UintptrFromInt32(1)*8 && int64(*(*uintptr)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcatchTop))) > int64((*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FauxObjList + 32))).Fptr2) {
			break
		}
		tmpPtr = (*TTEBCdata)(unsafe.Pointer(TD)).FauxObjList
		(*TTEBCdata)(unsafe.Pointer(TD)).FauxObjList = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(tmpPtr + 32))).Fptr1
		_objPtr38 = tmpPtr
		v1645 = _objPtr38
		v1644 = *(*TTcl_Size)(unsafe.Pointer(v1645))
		*(*TTcl_Size)(unsafe.Pointer(v1645))--
		if v1644 <= int64(1) {
			XTclFreeObj(tls, _objPtr38)
		}
	}
	/*
	 * We must not catch if the script in progress has been canceled with
	 * the TCL_CANCEL_UNWIND flag. Instead, it blows outwards until we
	 * either hit another interpreter (presumably where the script in
	 * progress has not been canceled) or we get to the top-level. We do
	 * NOT modify the interpreter result here because we know it will
	 * already be set prior to vectoring down to this point in the code.
	 */
	if ((*TInterp)(unsafe.Pointer(interp4)).Fflags&int32(CANCELED) != 0 || (*TInterp)(unsafe.Pointer(interp4)).Fflags&int32(TCL_CANCEL_UNWIND) != 0) && XTcl_Canceled(tls, interp4, 0) == int32(TCL_ERROR) {
		goto abnormalReturn
	}
	/*
	 * We must not catch an exceeded limit. Instead, it blows outwards
	 * until we either hit another interpreter (presumably where the limit
	 * is not exceeded) or we get to the top-level.
	 */
	if (*TInterp)(unsafe.Pointer(interp4)).Flimit.Fexceeded != 0 {
		goto abnormalReturn
	}
	if (*TTEBCdata)(unsafe.Pointer(TD)).FcatchTop == TD+112-libc.UintptrFromInt32(1)*8 {
		goto abnormalReturn
	}
	rangePtr = _GetExceptRangeForPc(tls, pc, int32(TCL_ERROR), (*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)
	if rangePtr == libc.UintptrFromInt32(0) {
		/*
		 * This is only possible when compiling a [catch] that sends its
		 * script to INST_EVAL. Cannot correct the compiler without
		 * breaking compat with previous .tbc compiled scripts.
		 */
		goto abnormalReturn
	}
	/*
	 * A catch exception range (rangePtr) was found to handle an
	 * "exception". It was found either by checkForCatch just above or by
	 * an instruction during break, continue, or error processing. Jump to
	 * its catchOffset after unwinding the operand stack to the depth it
	 * had when starting to execute the range's catch command.
	 */
	goto processCatch
processCatch:
	;
	for (int64(tosPtr)-int64(TD+112-libc.UintptrFromInt32(1)*8+uintptr((*TByteCode)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)).FmaxExceptDepth)*8))/8 > int64(*(*uintptr)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcatchTop))) {
		v1646 = tosPtr
		tosPtr -= 8
		*(*uintptr)(unsafe.Pointer(bp + 16)) = *(*uintptr)(unsafe.Pointer(v1646))
		v1648 = *(*uintptr)(unsafe.Pointer(bp + 16))
		v1647 = *(*TTcl_Size)(unsafe.Pointer(v1648))
		*(*TTcl_Size)(unsafe.Pointer(v1648))--
		if !(v1647 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength = int64(-libc.Int32FromInt32(1))
				if v1649 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1649 {
					cachePtr107 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v1649 || ((*TAllocCache)(unsafe.Pointer(cachePtr107)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr107)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr107)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr107)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp + 16))
					(*TAllocCache)(unsafe.Pointer(cachePtr107)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
			}
		}
	}
	pc = (*TByteCode)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)).FcodeStart + uintptr((*TExceptionRange)(unsafe.Pointer(rangePtr)).FcatchOffset)
	if true {
		if 0 != 0 {
			if 0 > 0 {
				v1652 = *(*uintptr)(unsafe.Pointer(bp + 8))
				tosPtr += 8
				v1653 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1653)) = v1652
				(*TTcl_Obj)(unsafe.Pointer(v1652)).FrefCount++
			} else {
				tosPtr += 8
				v1654 = tosPtr
				*(*uintptr)(unsafe.Pointer(v1654)) = *(*uintptr)(unsafe.Pointer(bp + 8))
			}
		}
		pc += uintptr(libc.Int32FromInt32(0))
		goto cleanup0
	} else {
		if 0 != 0 {
			if 0 > 0 {
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
			}
			pc += uintptr(libc.Int32FromInt32(0))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1_pushObjResultPtr
			case int32(2):
				goto cleanup2_pushObjResultPtr
			case 0:
				break
			}
		} else {
			pc += uintptr(libc.Int32FromInt32(0))
			switch libc.Int32FromInt32(0) {
			case int32(1):
				goto cleanup1
			case int32(2):
				goto cleanup2
			case 0:
				break
			}
		}
	}
	goto _1651
_1651:
	;
	goto _1650
_1650: /**/
	; //
	/* Restart the execution loop at pc. */
	/*
	 * end of infinite loop dispatching on instructions.
	 */
	/*
	 * Done or abnormal return code. Restore the stack to state it had when
	 * starting to execute the ByteCode. Panic if the stack is below the
	 * initial level.
	 */
	goto abnormalReturn
abnormalReturn:
	;
	if libc.Bool(0 != 0) && curInstName != 0 {
	}
	/*
	 * Clear all expansions and same-level NR calls.
	 *
	 * Note that expansion markers have a NULL type; avoid removing other
	 * markers.
	 */
	for (*TTEBCdata)(unsafe.Pointer(TD)).FauxObjList != 0 {
		tmpPtr = (*TTEBCdata)(unsafe.Pointer(TD)).FauxObjList
		(*TTEBCdata)(unsafe.Pointer(TD)).FauxObjList = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(tmpPtr + 32))).Fptr1
		_objPtr39 = tmpPtr
		v1656 = _objPtr39
		v1655 = *(*TTcl_Size)(unsafe.Pointer(v1656))
		*(*TTcl_Size)(unsafe.Pointer(v1656))--
		if v1655 <= int64(1) {
			XTclFreeObj(tls, _objPtr39)
		}
	}
	for tosPtr > TD+112-libc.UintptrFromInt32(1)*8+uintptr((*TByteCode)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)).FmaxExceptDepth)*8 {
		v1657 = tosPtr
		tosPtr -= 8
		objPtr5 = *(*uintptr)(unsafe.Pointer(v1657))
		_objPtr40 = objPtr5
		v1659 = _objPtr40
		v1658 = *(*TTcl_Size)(unsafe.Pointer(v1659))
		*(*TTcl_Size)(unsafe.Pointer(v1659))--
		if v1658 <= int64(1) {
			XTclFreeObj(tls, _objPtr40)
		}
	}
	if tosPtr < TD+112-libc.UintptrFromInt32(1)*8+uintptr((*TByteCode)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)).FmaxExceptDepth)*8 {
		libc.Xfprintf(tls, libc.Xstderr, __ccgo_ts+33056, libc.VaList(bp+544, int64(pc)-int64((*TByteCode)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)).FcodeStart), (int64(tosPtr)-int64(TD+112-libc.UintptrFromInt32(1)*8+uintptr((*TByteCode)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)).FmaxExceptDepth)*8))/8, 0))
		XTcl_Panic(tls, __ccgo_ts+33142, 0)
	}
	(*TInterp)(unsafe.Pointer(interp4)).FcmdFramePtr = (*TCmdFrame)(unsafe.Pointer(TD + 24)).FnextPtr
	XTclReleaseByteCode(tls, (*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr)
	XTclStackFree(tls, interp4, TD) /* free my stack */
	return result
	/*
	 * INST_START_CMD failure case removed where it doesn't bother that much
	 *
	 * Remark that if the interpreter is marked for deletion its
	 * compileEpoch is modified, so that the epoch check also verifies
	 * that the interp is not deleted. If no outside call has been made
	 * since the last check, it is safe to omit the check.
	 * case INST_START_CMD:
	 */
	goto instStartCmdFailed
instStartCmdFailed:
	;
	*(*TTcl_Size)(unsafe.Pointer(bp + 528)) = 0
	if XTclInterpReady(tls, interp4) == int32(TCL_ERROR) {
		goto gotError
	}
	/*
	 * We used to switch to direct eval; for NRE-awareness we now
	 * compile and eval the command so that this evaluation does not
	 * add a new TEBC instance. Bug [2910748], bug [fa6bf38d07]
	 *
	 * TODO: recompile, search this command and eval a code starting from,
	 * so that this evaluation does not add a new TEBC instance without
	 * NRE-trampoline.
	 */
	*(*uint32)(unsafe.Pointer((*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr + 40)) |= uint32(TCL_BYTECODE_RECOMPILE)
	bytes1 = _GetSrcInfoForPc(tls, pc, (*TTEBCdata)(unsafe.Pointer(TD)).FcodePtr, bp+528, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	opnd = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pc + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
	pc += uintptr(opnd - libc.Int32FromInt32(1))
	v1660 = XTcl_NewStringObj(tls, bytes1, *(*TTcl_Size)(unsafe.Pointer(bp + 528)))
	tosPtr += 8
	v1661 = tosPtr
	*(*uintptr)(unsafe.Pointer(v1661)) = v1660
	(*TTcl_Obj)(unsafe.Pointer(v1660)).FrefCount++
	goto instEvalStk
	return r
}

func _FinalizeOONext(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	var contextPtr, iPtr uintptr
	_, _ = contextPtr, iPtr
	iPtr = interp
	contextPtr = *(*uintptr)(unsafe.Pointer(data + 1*8))
	/*
	 * Reset the variable lookup frame.
	 */
	(*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr = *(*uintptr)(unsafe.Pointer(data))
	/*
	 * Restore the call chain context index as we've finished the inner invoke
	 * and want to operate in the outer context again.
	 */
	(*TCallContext)(unsafe.Pointer(contextPtr)).Findex = int64(*(*uintptr)(unsafe.Pointer(data + 2*8)))
	(*TCallContext)(unsafe.Pointer(contextPtr)).Fskip = int64(*(*uintptr)(unsafe.Pointer(data + 3*8)))
	*(*int32)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr + 96)) &= ^int32(FILTER_HANDLING)
	return result
}

func _FinalizeOONextFilter(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	var contextPtr, iPtr uintptr
	_, _ = contextPtr, iPtr
	iPtr = interp
	contextPtr = *(*uintptr)(unsafe.Pointer(data + 1*8))
	/*
	 * Reset the variable lookup frame.
	 */
	(*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr = *(*uintptr)(unsafe.Pointer(data))
	/*
	 * Restore the call chain context index as we've finished the inner invoke
	 * and want to operate in the outer context again.
	 */
	(*TCallContext)(unsafe.Pointer(contextPtr)).Findex = int64(*(*uintptr)(unsafe.Pointer(data + 2*8)))
	(*TCallContext)(unsafe.Pointer(contextPtr)).Fskip = int64(*(*uintptr)(unsafe.Pointer(data + 3*8)))
	*(*int32)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr + 96)) |= int32(FILTER_HANDLING)
	return result
}

// C documentation
//
//	/*
//	 * WidePwrSmallExpon --
//	 *
//	 * Helper to calculate small powers of integers whose result is wide.
//	 */
func _WidePwrSmallExpon(tls *libc.TLS, w1 TTcl_WideInt, exponent int64) (r TTcl_WideInt) {
	var wResult TTcl_WideInt
	_ = wResult
	wResult = w1 * w1 /* b**2 */
	switch exponent {
	case int64(2):
	case int64(3):
		wResult *= w1 /* b**3 */
	case int64(4):
		wResult *= wResult /* b**4 */
	case int64(5):
		wResult *= wResult /* b**4 */
		wResult *= w1      /* b**5 */
	case int64(6):
		wResult *= w1      /* b**3 */
		wResult *= wResult /* b**6 */
	case int64(7):
		wResult *= w1      /* b**3 */
		wResult *= wResult /* b**6 */
		wResult *= w1      /* b**7 */
	case int64(8):
		wResult *= wResult /* b**4 */
		wResult *= wResult /* b**8 */
	case int64(9):
		wResult *= wResult /* b**4 */
		wResult *= wResult /* b**8 */
		wResult *= w1      /* b**9 */
	case int64(10):
		wResult *= wResult /* b**4 */
		wResult *= w1      /* b**5 */
		wResult *= wResult /* b**10 */
	case int64(11):
		wResult *= wResult /* b**4 */
		wResult *= w1      /* b**5 */
		wResult *= wResult /* b**10 */
		wResult *= w1      /* b**11 */
	case int64(12):
		wResult *= w1      /* b**3 */
		wResult *= wResult /* b**6 */
		wResult *= wResult /* b**12 */
	case int64(13):
		wResult *= w1      /* b**3 */
		wResult *= wResult /* b**6 */
		wResult *= wResult /* b**12 */
		wResult *= w1      /* b**13 */
	case int64(14):
		wResult *= w1      /* b**3 */
		wResult *= wResult /* b**6 */
		wResult *= w1      /* b**7 */
		wResult *= wResult /* b**14 */
	case int64(15):
		wResult *= w1      /* b**3 */
		wResult *= wResult /* b**6 */
		wResult *= w1      /* b**7 */
		wResult *= wResult /* b**14 */
		wResult *= w1      /* b**15 */
	case int64(16):
		wResult *= wResult /* b**4 */
		wResult *= wResult /* b**8 */
		wResult *= wResult /* b**16 */
		break
	}
	return wResult
}

/*
 *----------------------------------------------------------------------
 *
 * ExecuteExtendedBinaryMathOp, ExecuteExtendedUnaryMathOp --
 *
 *	These functions do advanced math for binary and unary operators
 *	respectively, so that the main TEBC code does not bear the cost of
 *	them.
 *
 * Results:
 *	A Tcl_Obj* result, or a NULL (in which case valuePtr is updated to
 *	hold the result value), or one of the special flag values
 *	GENERAL_ARITHMETIC_ERROR, EXPONENT_OF_ZERO or DIVIDED_BY_ZERO. The
 *	latter two signify a zero value raised to a negative power or a value
 *	divided by zero, respectively. With GENERAL_ARITHMETIC_ERROR, all
 *	error information will have already been reported in the interpreter
 *	result.
 *
 * Side effects:
 *	May update the Tcl_Obj indicated valuePtr if it is unshared. Will
 *	return a NULL when that happens.
 *
 *----------------------------------------------------------------------
 */

func _ExecuteExtendedBinaryMathOp(tls *libc.TLS, interp uintptr, opcode int32, constants uintptr, valuePtr uintptr, value2Ptr uintptr) (r uintptr) {
	bp := tls.Alloc(400)
	defer tls.Free(400) /* The second operand on the stack. */
	var _isobjPtr, _isobjPtr1, _isobjPtr10, _isobjPtr11, _isobjPtr12, _isobjPtr13, _isobjPtr2, _isobjPtr3, _isobjPtr4, _isobjPtr5, _isobjPtr6, _isobjPtr7, _isobjPtr8, _isobjPtr9, cachePtr, objResultPtr uintptr
	var base uint16
	var dResult float64
	var err Tmp_err
	var invalid, negativeExponent, oddExponent, shift, signum, zero, v25, v26, v28, v30, v32, v33, v35, v37, v42, v43 int32
	var w1, wQuotient, wRemainder, wResult, v31 TTcl_WideInt
	var v10, v39, v4 uint64
	var v27, v34, v41 bool
	var v29, v36 int64
	var _ /* __u at bp+0 */ struct {
		F__i [0]uint64
		F__f float64
	}
	var _ /* big1 at bp+56 */ Tmp_int
	var _ /* big2 at bp+80 */ Tmp_int
	var _ /* bigRemainder at bp+128 */ Tmp_int
	var _ /* bigResult at bp+104 */ Tmp_int
	var _ /* d1 at bp+32 */ float64
	var _ /* d2 at bp+40 */ float64
	var _ /* ir at bp+152 */ TTcl_ObjInternalRep
	var _ /* ir at bp+168 */ TTcl_ObjInternalRep
	var _ /* ir at bp+184 */ TTcl_ObjInternalRep
	var _ /* ir at bp+200 */ TTcl_ObjInternalRep
	var _ /* ir at bp+216 */ TTcl_ObjInternalRep
	var _ /* ir at bp+232 */ TTcl_ObjInternalRep
	var _ /* ir at bp+248 */ TTcl_ObjInternalRep
	var _ /* ir at bp+264 */ TTcl_ObjInternalRep
	var _ /* ir at bp+280 */ TTcl_ObjInternalRep
	var _ /* ir at bp+296 */ TTcl_ObjInternalRep
	var _ /* ir at bp+312 */ TTcl_ObjInternalRep
	var _ /* ir at bp+328 */ TTcl_ObjInternalRep
	var _ /* ir at bp+344 */ TTcl_ObjInternalRep
	var _ /* ir at bp+360 */ TTcl_ObjInternalRep
	var _ /* ptr1 at bp+16 */ uintptr
	var _ /* ptr2 at bp+24 */ uintptr
	var _ /* type1 at bp+8 */ int32
	var _ /* type2 at bp+12 */ int32
	var _ /* w2 at bp+48 */ TTcl_WideInt
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _isobjPtr, _isobjPtr1, _isobjPtr10, _isobjPtr11, _isobjPtr12, _isobjPtr13, _isobjPtr2, _isobjPtr3, _isobjPtr4, _isobjPtr5, _isobjPtr6, _isobjPtr7, _isobjPtr8, _isobjPtr9, base, cachePtr, dResult, err, invalid, negativeExponent, objResultPtr, oddExponent, shift, signum, w1, wQuotient, wRemainder, wResult, zero, v10, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v39, v4, v41, v42, v43
	if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*int32)(unsafe.Pointer(bp + 8)) = int32(TCL_NUMBER_INT)
		*(*uintptr)(unsafe.Pointer(bp + 16)) = valuePtr + 32
		_ = libc.Int32FromInt32(TCL_OK)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
			*(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(valuePtr)).FinternalRep))
			v4 = *(*uint64)(unsafe.Pointer(bp))
			goto _5
		_5:
			if libc.BoolInt32(v4&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) > libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
				*(*int32)(unsafe.Pointer(bp + 8)) = int32(TCL_NUMBER_NAN)
			} else {
				*(*int32)(unsafe.Pointer(bp + 8)) = int32(TCL_NUMBER_DOUBLE)
			}
			*(*uintptr)(unsafe.Pointer(bp + 16)) = valuePtr + 32
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			if !((*TTcl_Obj)(unsafe.Pointer(valuePtr)).Fbytes != libc.UintptrFromInt32(0) && (*TTcl_Obj)(unsafe.Pointer(valuePtr)).Flength == 0) {
				XTcl_GetNumberFromObj(tls, libc.UintptrFromInt32(0), valuePtr, bp+16, bp+8)
			}
		}
	}
	if (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*int32)(unsafe.Pointer(bp + 12)) = int32(TCL_NUMBER_INT)
		*(*uintptr)(unsafe.Pointer(bp + 24)) = value2Ptr + 32
		_ = libc.Int32FromInt32(TCL_OK)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
			*(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FinternalRep))
			v10 = *(*uint64)(unsafe.Pointer(bp))
			goto _11
		_11:
			if libc.BoolInt32(v10&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) > libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
				*(*int32)(unsafe.Pointer(bp + 12)) = int32(TCL_NUMBER_NAN)
			} else {
				*(*int32)(unsafe.Pointer(bp + 12)) = int32(TCL_NUMBER_DOUBLE)
			}
			*(*uintptr)(unsafe.Pointer(bp + 24)) = value2Ptr + 32
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			if !((*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes != libc.UintptrFromInt32(0) && (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Flength == 0) {
				XTcl_GetNumberFromObj(tls, libc.UintptrFromInt32(0), value2Ptr, bp+24, bp+12)
			}
		}
	}
	switch opcode {
	case int32(INST_MOD):
		goto _13
	case int32(INST_RSHIFT):
		goto _14
	case int32(INST_LSHIFT):
		goto _15
	case int32(INST_BITAND):
		goto _16
	case int32(INST_BITXOR):
		goto _17
	case int32(INST_BITOR):
		goto _18
	case int32(INST_EXPON):
		goto _19
	case int32(INST_DIV):
		goto _20
	case int32(INST_MULT):
		goto _21
	case int32(INST_SUB):
		goto _22
	case int32(INST_ADD):
		goto _23
	}
	goto _24
_13:
	;
	/* TODO: Attempts to re-use unshared operands on stack */
	*(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) = 0 /* silence gcc warning */
	if *(*int32)(unsafe.Pointer(bp + 12)) == int32(TCL_NUMBER_INT) {
		*(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24))))
		if *(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) == 0 {
			return uintptr(-libc.Int32FromInt32(1))
		}
		if *(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) == int64(1) || *(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) == int64(-int32(1)) {
			/*
			 * Div. by |1| always yields remainder of 0.
			 */
			return *(*uintptr)(unsafe.Pointer(constants))
		}
	}
	if *(*int32)(unsafe.Pointer(bp + 8)) == int32(TCL_NUMBER_INT) {
		w1 = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16))))
		if w1 == 0 {
			/*
			 * 0 % (non-zero) always yields remainder of 0.
			 */
			return *(*uintptr)(unsafe.Pointer(constants))
		}
		if *(*int32)(unsafe.Pointer(bp + 12)) == int32(TCL_NUMBER_INT) {
			*(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24))))
			wQuotient = w1 / *(*TTcl_WideInt)(unsafe.Pointer(bp + 48))
			/*
			 * Force Tcl's integer division rules.
			 * TODO: examine for logic simplification
			 */
			if (wQuotient < 0 || wQuotient == 0 && (w1 < 0 && *(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) > 0 || w1 > 0 && *(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) < 0)) && wQuotient**(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) != w1 {
				wQuotient -= int64(1)
			}
			wRemainder = libc.Int64FromUint64(libc.Uint64FromInt64(w1) - libc.Uint64FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 48)))*libc.Uint64FromInt64(wQuotient))
			if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount > int64(1) {
				return XTcl_NewWideIntObj(tls, wRemainder)
			} else {
				*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 152)))) = wRemainder
				_isobjPtr = valuePtr
				if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
					if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
				}
				XTcl_StoreInternalRep(tls, valuePtr, uintptr(unsafe.Pointer(&XtclIntType)), bp+152)
				return libc.UintptrFromInt32(0)
			}
		}
		XTcl_TakeBignumFromObj(tls, libc.UintptrFromInt32(0), value2Ptr, bp+80)
		/* TODO: internals intrusion */
		if (*Tmp_int)(unsafe.Pointer(bp+80)).Fsign != MP_ZPOS {
			v25 = int32(MP_YES)
		} else {
			v25 = MP_NO
		}
		if libc.BoolInt32(w1 > libc.Int64FromInt32(0))^libc.BoolInt32(!(v25 != 0)) != 0 {
			/*
			 * Arguments are opposite sign; remainder is sum.
			 */
			err = XTclBN_mp_init_i64(tls, bp+56, w1)
			if err == MP_OKAY {
				err = XTclBN_mp_add(tls, bp+80, bp+56, bp+80)
				XTclBN_mp_clear(tls, bp+56)
			}
			if err != MP_OKAY {
				return uintptr(-libc.Int32FromInt32(4))
			}
			if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount > int64(1) {
				return XTcl_NewBignumObj(tls, bp+80)
			} else {
				XTcl_SetBignumObj(tls, valuePtr, bp+80)
				return libc.UintptrFromInt32(0)
			}
		}
		/*
		 * Arguments are same sign; remainder is first operand.
		 */
		XTclBN_mp_clear(tls, bp+80)
		return libc.UintptrFromInt32(0)
	}
	XTcl_GetBignumFromObj(tls, libc.UintptrFromInt32(0), valuePtr, bp+56)
	XTcl_GetBignumFromObj(tls, libc.UintptrFromInt32(0), value2Ptr, bp+80)
	err = XTclBN_mp_init_multi(tls, bp+104, libc.VaList(bp+384, bp+128, libc.UintptrFromInt32(0)))
	if err == MP_OKAY {
		err = XTclBN_mp_div(tls, bp+56, bp+80, bp+104, bp+128)
	}
	if v27 = err == MP_OKAY; v27 {
		if (*Tmp_int)(unsafe.Pointer(bp+128)).Fused == 0 {
			v26 = int32(MP_YES)
		} else {
			v26 = MP_NO
		}
	}
	if v27 && !(v26 != 0) && (*(*Tmp_int)(unsafe.Pointer(bp + 128))).Fsign != (*(*Tmp_int)(unsafe.Pointer(bp + 80))).Fsign {
		/*
		 * Convert to Tcl's integer division rules.
		 */
		if XTclBN_mp_sub_d(tls, bp+104, uint32(1), bp+104) != MP_OKAY || XTclBN_mp_add(tls, bp+128, bp+80, bp+128) != MP_OKAY {
			return uintptr(-libc.Int32FromInt32(4))
		}
	}
	err = XTclBN_mp_copy(tls, bp+128, bp+104)
	XTclBN_mp_clear(tls, bp+128)
	XTclBN_mp_clear(tls, bp+56)
	XTclBN_mp_clear(tls, bp+80)
	if err != MP_OKAY {
		return uintptr(-libc.Int32FromInt32(4))
	}
	if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount > int64(1) {
		return XTcl_NewBignumObj(tls, bp+104)
	} else {
		XTcl_SetBignumObj(tls, valuePtr, bp+104)
		return libc.UintptrFromInt32(0)
	}
_15:
	;
_14:
	;
	/*
	 * Reject negative shift argument.
	 */
	switch *(*int32)(unsafe.Pointer(bp + 12)) {
	case int32(TCL_NUMBER_INT):
		invalid = libc.BoolInt32(*(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))) < 0)
	case int32(TCL_NUMBER_BIG):
		XTcl_TakeBignumFromObj(tls, libc.UintptrFromInt32(0), value2Ptr, bp+80)
		if (*Tmp_int)(unsafe.Pointer(bp+80)).Fsign != MP_ZPOS {
			v28 = int32(MP_YES)
		} else {
			v28 = MP_NO
		}
		invalid = v28
		XTclBN_mp_clear(tls, bp+80)
	default:
		/* Unused, here to silence compiler warning */
		invalid = 0
	}
	if invalid != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+32678, int64(-int32(1))))
		return uintptr(-libc.Int32FromInt32(3))
	}
	/*
	 * Zero shifted any number of bits is still zero.
	 */
	if *(*int32)(unsafe.Pointer(bp + 8)) == int32(TCL_NUMBER_INT) && *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) == 0 {
		return *(*uintptr)(unsafe.Pointer(constants))
	}
	if opcode == int32(INST_LSHIFT) {
		/*
		 * Large left shifts create integer overflow.
		 *
		 * BEWARE! Can't use Tcl_GetIntFromObj() here because that
		 * converts values in the (unsigned) range to their signed int
		 * counterparts, leading to incorrect results.
		 */
		if *(*int32)(unsafe.Pointer(bp + 12)) != int32(TCL_NUMBER_INT) || *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))) > int64(INT_MAX) {
			/*
			 * Technically, we could hold the value (1 << (INT_MAX+1)) in
			 * an mp_int, but since we're using mp_mul_2d() to do the
			 * work, and it takes only an int argument, that's a good
			 * place to draw the line.
			 */
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+11737, int64(-int32(1))))
			return uintptr(-libc.Int32FromInt32(3))
		}
		shift = int32(*(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))))
		/*
		 * Handle shifts within the native wide range.
		 */
		if *(*int32)(unsafe.Pointer(bp + 8)) == int32(TCL_NUMBER_INT) && libc.Uint64FromInt32(shift) < libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8) {
			w1 = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16))))
			if w1 > 0 {
				v29 = w1
			} else {
				v29 = ^w1
			}
			if !(libc.Uint64FromInt64(v29)&-(libc.Uint64FromInt32(1)<<(libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)-libc.Uint64FromInt32(shift))) != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount > int64(1) {
					return XTcl_NewWideIntObj(tls, libc.Int64FromUint64(libc.Uint64FromInt64(w1)<<shift))
				} else {
					*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 168)))) = libc.Int64FromUint64(libc.Uint64FromInt64(w1) << shift)
					_isobjPtr1 = valuePtr
					if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes != libc.UintptrFromInt32(0) {
						if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes = libc.UintptrFromInt32(0)
					}
					XTcl_StoreInternalRep(tls, valuePtr, uintptr(unsafe.Pointer(&XtclIntType)), bp+168)
					return libc.UintptrFromInt32(0)
				}
			}
		}
	} else {
		/*
		 * Quickly force large right shifts to 0 or -1.
		 */
		if *(*int32)(unsafe.Pointer(bp + 12)) != int32(TCL_NUMBER_INT) || *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))) > int64(INT_MAX) {
			/*
			 * Again, technically, the value to be shifted could be an
			 * mp_int so huge that a right shift by (INT_MAX+1) bits could
			 * not take us to the result of 0 or -1, but since we're using
			 * mp_div_2d to do the work, and it takes only an int
			 * argument, we draw the line there.
			 */
			switch *(*int32)(unsafe.Pointer(bp + 8)) {
			case int32(TCL_NUMBER_INT):
				zero = libc.BoolInt32(*(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))) > 0)
			case int32(TCL_NUMBER_BIG):
				XTcl_TakeBignumFromObj(tls, libc.UintptrFromInt32(0), valuePtr, bp+56)
				if (*Tmp_int)(unsafe.Pointer(bp+56)).Fsign != MP_ZPOS {
					v30 = int32(MP_YES)
				} else {
					v30 = MP_NO
				}
				zero = libc.BoolInt32(!(v30 != 0))
				XTclBN_mp_clear(tls, bp+56)
			default:
				/* Unused, here to silence compiler warning. */
				zero = 0
			}
			if zero != 0 {
				return *(*uintptr)(unsafe.Pointer(constants))
			}
			if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount > int64(1) {
				return XTcl_NewWideIntObj(tls, int64(-int32(1)))
			} else {
				*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 184)))) = int64(-libc.Int32FromInt32(1))
				_isobjPtr2 = valuePtr
				if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr2)).Fbytes != libc.UintptrFromInt32(0) {
					if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr2)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr2)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(_isobjPtr2)).Fbytes = libc.UintptrFromInt32(0)
				}
				XTcl_StoreInternalRep(tls, valuePtr, uintptr(unsafe.Pointer(&XtclIntType)), bp+184)
				return libc.UintptrFromInt32(0)
			}
		}
		shift = int32(*(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))))
		/*
		 * Handle shifts within the native wide range.
		 */
		if *(*int32)(unsafe.Pointer(bp + 8)) == int32(TCL_NUMBER_INT) {
			w1 = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16))))
			if libc.Uint64FromInt32(shift) >= libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8) {
				if w1 >= 0 {
					return *(*uintptr)(unsafe.Pointer(constants))
				}
				if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount > int64(1) {
					return XTcl_NewWideIntObj(tls, int64(-int32(1)))
				} else {
					*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 200)))) = int64(-libc.Int32FromInt32(1))
					_isobjPtr3 = valuePtr
					if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr3)).Fbytes != libc.UintptrFromInt32(0) {
						if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr3)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr3)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(_isobjPtr3)).Fbytes = libc.UintptrFromInt32(0)
					}
					XTcl_StoreInternalRep(tls, valuePtr, uintptr(unsafe.Pointer(&XtclIntType)), bp+200)
					return libc.UintptrFromInt32(0)
				}
			}
			if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount > int64(1) {
				return XTcl_NewWideIntObj(tls, w1>>shift)
			} else {
				*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 216)))) = w1 >> shift
				_isobjPtr4 = valuePtr
				if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr4)).Fbytes != libc.UintptrFromInt32(0) {
					if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr4)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr4)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(_isobjPtr4)).Fbytes = libc.UintptrFromInt32(0)
				}
				XTcl_StoreInternalRep(tls, valuePtr, uintptr(unsafe.Pointer(&XtclIntType)), bp+216)
				return libc.UintptrFromInt32(0)
			}
		}
	}
	XTcl_TakeBignumFromObj(tls, libc.UintptrFromInt32(0), valuePtr, bp+56)
	err = XTclBN_mp_init(tls, bp+104)
	if err == MP_OKAY {
		if opcode == int32(INST_LSHIFT) {
			err = XTclBN_mp_mul_2d(tls, bp+56, shift, bp+104)
		} else {
			err = XTclBN_mp_signed_rsh(tls, bp+56, shift, bp+104)
		}
	}
	if err != MP_OKAY {
		return uintptr(-libc.Int32FromInt32(4))
	}
	XTclBN_mp_clear(tls, bp+56)
	if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount > int64(1) {
		return XTcl_NewBignumObj(tls, bp+104)
	} else {
		XTcl_SetBignumObj(tls, valuePtr, bp+104)
		return libc.UintptrFromInt32(0)
	}
_18:
	;
_17:
	;
_16:
	;
	if *(*int32)(unsafe.Pointer(bp + 8)) != int32(TCL_NUMBER_INT) || *(*int32)(unsafe.Pointer(bp + 12)) != int32(TCL_NUMBER_INT) {
		XTcl_TakeBignumFromObj(tls, libc.UintptrFromInt32(0), valuePtr, bp+56)
		XTcl_TakeBignumFromObj(tls, libc.UintptrFromInt32(0), value2Ptr, bp+80)
		err = XTclBN_mp_init(tls, bp+104)
		if err == MP_OKAY {
			switch opcode {
			case int32(INST_BITAND):
				err = XTclBN_mp_and(tls, bp+56, bp+80, bp+104)
			case int32(INST_BITOR):
				err = XTclBN_mp_or(tls, bp+56, bp+80, bp+104)
			case int32(INST_BITXOR):
				err = XTclBN_mp_xor(tls, bp+56, bp+80, bp+104)
				break
			}
		}
		if err != MP_OKAY {
			return uintptr(-libc.Int32FromInt32(4))
		}
		XTclBN_mp_clear(tls, bp+56)
		XTclBN_mp_clear(tls, bp+80)
		if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount > int64(1) {
			return XTcl_NewBignumObj(tls, bp+104)
		} else {
			XTcl_SetBignumObj(tls, valuePtr, bp+104)
			return libc.UintptrFromInt32(0)
		}
	}
	w1 = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16))))
	*(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24))))
	switch opcode {
	case int32(INST_BITAND):
		wResult = w1 & *(*TTcl_WideInt)(unsafe.Pointer(bp + 48))
	case int32(INST_BITOR):
		wResult = w1 | *(*TTcl_WideInt)(unsafe.Pointer(bp + 48))
	case int32(INST_BITXOR):
		wResult = w1 ^ *(*TTcl_WideInt)(unsafe.Pointer(bp + 48))
	default:
		/* Unused, here to silence compiler warning. */
		wResult = 0
	}
	if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount > int64(1) {
		return XTcl_NewWideIntObj(tls, wResult)
	} else {
		*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 232)))) = wResult
		_isobjPtr5 = valuePtr
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr5)).Fbytes != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr5)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr5)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(_isobjPtr5)).Fbytes = libc.UintptrFromInt32(0)
		}
		XTcl_StoreInternalRep(tls, valuePtr, uintptr(unsafe.Pointer(&XtclIntType)), bp+232)
		return libc.UintptrFromInt32(0)
	}
_19:
	;
	oddExponent = 0
	negativeExponent = 0
	if *(*int32)(unsafe.Pointer(bp + 8)) == int32(TCL_NUMBER_DOUBLE) || *(*int32)(unsafe.Pointer(bp + 12)) == int32(TCL_NUMBER_DOUBLE) {
		XTcl_GetDoubleFromObj(tls, libc.UintptrFromInt32(0), valuePtr, bp+32)
		XTcl_GetDoubleFromObj(tls, libc.UintptrFromInt32(0), value2Ptr, bp+40)
		if *(*float64)(unsafe.Pointer(bp + 32)) == float64(0) && *(*float64)(unsafe.Pointer(bp + 40)) < float64(0) {
			return uintptr(-libc.Int32FromInt32(2))
		}
		dResult = libc.Xpow(tls, *(*float64)(unsafe.Pointer(bp + 32)), *(*float64)(unsafe.Pointer(bp + 40)))
		goto doubleResult
	}
	v31 = libc.Int64FromInt32(0)
	*(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) = v31
	w1 = v31 /* to silence compiler warning (maybe-uninitialized) */
	if *(*int32)(unsafe.Pointer(bp + 12)) == int32(TCL_NUMBER_INT) {
		*(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24))))
		if *(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) == 0 {
			/*
			 * Anything to the zero power is 1.
			 */
			return *(*uintptr)(unsafe.Pointer(constants + 1*8))
		} else {
			if *(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) == int64(1) {
				/*
				 * Anything to the first power is itself
				 */
				return libc.UintptrFromInt32(0)
			}
		}
		negativeExponent = libc.BoolInt32(*(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) < 0)
		oddExponent = int32(*(*TTcl_WideInt)(unsafe.Pointer(bp + 48))) & int32(1)
	} else {
		XTcl_TakeBignumFromObj(tls, libc.UintptrFromInt32(0), value2Ptr, bp+80)
		if (*Tmp_int)(unsafe.Pointer(bp+80)).Fsign != MP_ZPOS {
			v32 = int32(MP_YES)
		} else {
			v32 = MP_NO
		}
		negativeExponent = v32
		err = XTclBN_mp_mod_2d(tls, bp+80, int32(1), bp+80)
		if v34 = err == MP_OKAY; v34 {
			if (*Tmp_int)(unsafe.Pointer(bp+80)).Fused == 0 {
				v33 = int32(MP_YES)
			} else {
				v33 = MP_NO
			}
		}
		oddExponent = libc.BoolInt32(v34 && !(v33 != 0))
		XTclBN_mp_clear(tls, bp+80)
	}
	if *(*int32)(unsafe.Pointer(bp + 8)) == int32(TCL_NUMBER_INT) {
		w1 = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16))))
		if negativeExponent != 0 {
			switch w1 {
			case 0:
				/*
				 * Zero to a negative power is div by zero error.
				 */
				return uintptr(-libc.Int32FromInt32(2))
			case int64(-int32(1)):
				if oddExponent != 0 {
					if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount > int64(1) {
						return XTcl_NewWideIntObj(tls, int64(-int32(1)))
					} else {
						*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 248)))) = int64(-libc.Int32FromInt32(1))
						_isobjPtr6 = valuePtr
						if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr6)).Fbytes != libc.UintptrFromInt32(0) {
							if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr6)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
								XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr6)).Fbytes)
							}
							(*TTcl_Obj)(unsafe.Pointer(_isobjPtr6)).Fbytes = libc.UintptrFromInt32(0)
						}
						XTcl_StoreInternalRep(tls, valuePtr, uintptr(unsafe.Pointer(&XtclIntType)), bp+248)
						return libc.UintptrFromInt32(0)
					}
				}
				/* fallthrough */
				fallthrough
			case int64(1):
				/*
				 * 1 to any power is 1.
				 */
				return *(*uintptr)(unsafe.Pointer(constants + 1*8))
			}
		}
	}
	if negativeExponent != 0 {
		/*
		 * Integers with magnitude greater than 1 raise to a negative
		 * power yield the answer zero (see TIP 123).
		 */
		return *(*uintptr)(unsafe.Pointer(constants))
	}
	if *(*int32)(unsafe.Pointer(bp + 8)) != int32(TCL_NUMBER_INT) {
		goto overflowExpon
	}
	switch w1 {
	case 0:
		/*
		 * Zero to a positive power is zero.
		 */
		return *(*uintptr)(unsafe.Pointer(constants))
	case int64(1):
		/*
		 * 1 to any power is 1.
		 */
		return *(*uintptr)(unsafe.Pointer(constants + 1*8))
	case int64(-int32(1)):
		if !(oddExponent != 0) {
			return *(*uintptr)(unsafe.Pointer(constants + 1*8))
		}
		if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount > int64(1) {
			return XTcl_NewWideIntObj(tls, int64(-int32(1)))
		} else {
			*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 264)))) = int64(-libc.Int32FromInt32(1))
			_isobjPtr7 = valuePtr
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr7)).Fbytes != libc.UintptrFromInt32(0) {
				if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr7)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr7)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(_isobjPtr7)).Fbytes = libc.UintptrFromInt32(0)
			}
			XTcl_StoreInternalRep(tls, valuePtr, uintptr(unsafe.Pointer(&XtclIntType)), bp+264)
			return libc.UintptrFromInt32(0)
		}
	}
	/*
	 * We refuse to accept exponent arguments that exceed one mp_digit
	 * which means the max exponent value is 2**28-1 = 0x0FFFFFFF =
	 * 268435455, which fits into a signed 32 bit int which is within the
	 * range of the Tcl_WideInt type. This means any numeric Tcl_Obj value
	 * not using TCL_NUMBER_INT type must hold a value larger than we
	 * accept.
	 */
	if *(*int32)(unsafe.Pointer(bp + 12)) != int32(TCL_NUMBER_INT) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+33214, int64(-int32(1))))
		return uintptr(-libc.Int32FromInt32(3))
	}
	/* From here (up to overflowExpon) w1 and exponent w2 are wide-int's. */
	if w1 == int64(2) {
		/*
		 * Reduce small powers of 2 to shifts.
		 */
		if libc.Uint64FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 48))) < libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1) {
			if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount > int64(1) {
				return XTcl_NewWideIntObj(tls, libc.Int64FromInt32(1)<<int32(*(*TTcl_WideInt)(unsafe.Pointer(bp + 48))))
			} else {
				*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 280)))) = libc.Int64FromInt32(1) << int32(*(*TTcl_WideInt)(unsafe.Pointer(bp + 48)))
				_isobjPtr8 = valuePtr
				if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr8)).Fbytes != libc.UintptrFromInt32(0) {
					if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr8)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr8)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(_isobjPtr8)).Fbytes = libc.UintptrFromInt32(0)
				}
				XTcl_StoreInternalRep(tls, valuePtr, uintptr(unsafe.Pointer(&XtclIntType)), bp+280)
				return libc.UintptrFromInt32(0)
			}
		}
		goto overflowExpon
	}
	if w1 == int64(-int32(2)) {
		if oddExponent != 0 {
			v35 = -int32(1)
		} else {
			v35 = int32(1)
		}
		signum = v35
		/*
		 * Reduce small powers of 2 to shifts.
		 */
		if libc.Uint64FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 48))) < uint64(libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)) {
			if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount > int64(1) {
				return XTcl_NewWideIntObj(tls, int64(signum)*(libc.Int64FromInt32(1)<<int32(*(*TTcl_WideInt)(unsafe.Pointer(bp + 48)))))
			} else {
				*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 296)))) = int64(signum) * (libc.Int64FromInt32(1) << int32(*(*TTcl_WideInt)(unsafe.Pointer(bp + 48))))
				_isobjPtr9 = valuePtr
				if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr9)).Fbytes != libc.UintptrFromInt32(0) {
					if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr9)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr9)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(_isobjPtr9)).Fbytes = libc.UintptrFromInt32(0)
				}
				XTcl_StoreInternalRep(tls, valuePtr, uintptr(unsafe.Pointer(&XtclIntType)), bp+296)
				return libc.UintptrFromInt32(0)
			}
		}
		goto overflowExpon
	}
	if *(*TTcl_WideInt)(unsafe.Pointer(bp + 48))-int64(2) < int64(libc.Int64FromUint64(_MaxBase64Size)) && w1 <= _MaxBase64[*(*TTcl_WideInt)(unsafe.Pointer(bp + 48))-int64(2)] && w1 >= -_MaxBase64[*(*TTcl_WideInt)(unsafe.Pointer(bp + 48))-int64(2)] {
		/*
		 * Small powers of integers whose result is wide.
		 */
		wResult = _WidePwrSmallExpon(tls, w1, *(*TTcl_WideInt)(unsafe.Pointer(bp + 48)))
		if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount > int64(1) {
			return XTcl_NewWideIntObj(tls, wResult)
		} else {
			*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 312)))) = wResult
			_isobjPtr10 = valuePtr
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr10)).Fbytes != libc.UintptrFromInt32(0) {
				if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr10)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr10)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(_isobjPtr10)).Fbytes = libc.UintptrFromInt32(0)
			}
			XTcl_StoreInternalRep(tls, valuePtr, uintptr(unsafe.Pointer(&XtclIntType)), bp+312)
			return libc.UintptrFromInt32(0)
		}
	}
	/*
	 * Handle cases of powers > 16 that still fit in a 64-bit word by
	 * doing table lookup.
	 */
	if w1-int64(3) >= 0 && w1-int64(2) < int64(libc.Int64FromUint64(_Exp64IndexSize)) && *(*TTcl_WideInt)(unsafe.Pointer(bp + 48))-int64(2) < int64(libc.Int64FromUint64(_Exp64ValueSize+_MaxBase64Size)) {
		base = libc.Uint16FromInt32(libc.Int32FromUint16(_Exp64Index[w1-int64(3)]) + libc.Int32FromUint16(uint16(libc.Uint64FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 48))-libc.Int64FromInt32(2))-uint64(_MaxBase64Size))))
		if libc.Int32FromUint16(base) < libc.Int32FromUint16(_Exp64Index[w1-int64(2)]) {
			/*
			 * 64-bit number raised to intermediate power, done by
			 * table lookup.
			 */
			if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount > int64(1) {
				return XTcl_NewWideIntObj(tls, _Exp64Value[base])
			} else {
				*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 328)))) = _Exp64Value[base]
				_isobjPtr11 = valuePtr
				if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr11)).Fbytes != libc.UintptrFromInt32(0) {
					if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr11)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr11)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(_isobjPtr11)).Fbytes = libc.UintptrFromInt32(0)
				}
				XTcl_StoreInternalRep(tls, valuePtr, uintptr(unsafe.Pointer(&XtclIntType)), bp+328)
				return libc.UintptrFromInt32(0)
			}
		}
	}
	if -w1-int64(3) >= 0 && -w1-int64(2) < int64(libc.Int64FromUint64(_Exp64IndexSize)) && *(*TTcl_WideInt)(unsafe.Pointer(bp + 48))-int64(2) < int64(libc.Int64FromUint64(_Exp64ValueSize+_MaxBase64Size)) {
		base = libc.Uint16FromInt32(libc.Int32FromUint16(_Exp64Index[-w1-int64(3)]) + libc.Int32FromUint16(uint16(libc.Uint64FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 48))-libc.Int64FromInt32(2))-uint64(_MaxBase64Size))))
		if libc.Int32FromUint16(base) < libc.Int32FromUint16(_Exp64Index[-w1-int64(2)]) {
			/*
			 * 64-bit number raised to intermediate power, done by
			 * table lookup.
			 */
			if oddExponent != 0 {
				v36 = -_Exp64Value[base]
			} else {
				v36 = _Exp64Value[base]
			}
			wResult = v36
			if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount > int64(1) {
				return XTcl_NewWideIntObj(tls, wResult)
			} else {
				*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 344)))) = wResult
				_isobjPtr12 = valuePtr
				if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr12)).Fbytes != libc.UintptrFromInt32(0) {
					if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr12)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr12)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(_isobjPtr12)).Fbytes = libc.UintptrFromInt32(0)
				}
				XTcl_StoreInternalRep(tls, valuePtr, uintptr(unsafe.Pointer(&XtclIntType)), bp+344)
				return libc.UintptrFromInt32(0)
			}
		}
	}
	goto overflowExpon
overflowExpon:
	;
	if (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FinternalRep))
		v37 = libc.Int32FromInt32(TCL_OK)
	} else {
		v37 = XTcl_GetWideIntFromObj(tls, libc.UintptrFromInt32(0), value2Ptr, bp+48)
	}
	if v37 != TCL_OK || !((*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType))) || libc.Uint64FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 48))) >= libc.Uint64FromInt32(libc.Int32FromInt32(1)<<libc.Int32FromInt32(28)) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+33214, int64(-int32(1))))
		return uintptr(-libc.Int32FromInt32(3))
	}
	XTcl_TakeBignumFromObj(tls, libc.UintptrFromInt32(0), valuePtr, bp+56)
	err = XTclBN_mp_init(tls, bp+104)
	if err == MP_OKAY {
		/* Don't use "mp_expt_n" directly here, it doesn't exist in libtommath 1.2 */
		err = XTclBN_mp_expt_n(tls, bp+56, int32(*(*TTcl_WideInt)(unsafe.Pointer(bp + 48))), bp+104)
	}
	if err != MP_OKAY {
		return uintptr(-libc.Int32FromInt32(4))
	}
	XTclBN_mp_clear(tls, bp+56)
	if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount > int64(1) {
		return XTcl_NewBignumObj(tls, bp+104)
	} else {
		XTcl_SetBignumObj(tls, valuePtr, bp+104)
		return libc.UintptrFromInt32(0)
	}
_23:
	;
_22:
	;
_21:
	;
_20:
	;
	if !(*(*int32)(unsafe.Pointer(bp + 8)) == int32(TCL_NUMBER_DOUBLE) || *(*int32)(unsafe.Pointer(bp + 12)) == int32(TCL_NUMBER_DOUBLE)) {
		goto _38
	}
	/*
	 * At least one of the values is floating-point, so perform
	 * floating point calculations.
	 */
	XTcl_GetDoubleFromObj(tls, libc.UintptrFromInt32(0), valuePtr, bp+32)
	XTcl_GetDoubleFromObj(tls, libc.UintptrFromInt32(0), value2Ptr, bp+40)
	switch opcode {
	case int32(INST_ADD):
		dResult = *(*float64)(unsafe.Pointer(bp + 32)) + *(*float64)(unsafe.Pointer(bp + 40))
	case int32(INST_SUB):
		dResult = *(*float64)(unsafe.Pointer(bp + 32)) - *(*float64)(unsafe.Pointer(bp + 40))
	case int32(INST_MULT):
		dResult = float64(*(*float64)(unsafe.Pointer(bp + 32)) * *(*float64)(unsafe.Pointer(bp + 40)))
	case int32(INST_DIV):
		/*
		 * We presume that we are running with zero-divide unmasked if
		 * we're on an IEEE box. Otherwise, this statement might cause
		 * demons to fly out our noses.
		 */
		dResult = *(*float64)(unsafe.Pointer(bp + 32)) / *(*float64)(unsafe.Pointer(bp + 40))
	default:
		/* Unused, here to silence compiler warning. */
		dResult = libc.Float64FromInt32(0)
	}
	goto doubleResult
doubleResult:
	;
	/*
	 * Check now for IEEE floating-point error.
	 */
	*(*float64)(unsafe.Pointer(bp)) = dResult
	v39 = *(*uint64)(unsafe.Pointer(bp))
	goto _40
_40:
	if libc.BoolInt32(v39&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) > libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
		XTclExprFloatError(tls, interp, dResult)
		return uintptr(-libc.Int32FromInt32(3))
	}
	if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount > int64(1) {
		if v41 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v41 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v41 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			objResultPtr = XTclThreadAllocObj(tls)
		} else {
			objResultPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objResultPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(objResultPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(objResultPtr)).Fbytes = libc.UintptrFromInt32(0)
		*(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objResultPtr)).FinternalRep)) = dResult
		(*TTcl_Obj)(unsafe.Pointer(objResultPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclDoubleType))
		return objResultPtr
	} else {
		XTcl_SetDoubleObj(tls, valuePtr, dResult)
		return libc.UintptrFromInt32(0)
	}
_38:
	;
	if *(*int32)(unsafe.Pointer(bp + 8)) == int32(TCL_NUMBER_INT) && *(*int32)(unsafe.Pointer(bp + 12)) == int32(TCL_NUMBER_INT) {
		w1 = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16))))
		*(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24))))
		switch opcode {
		case int32(INST_ADD):
			wResult = libc.Int64FromUint64(libc.Uint64FromInt64(w1) + libc.Uint64FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 48))))
			if *(*int32)(unsafe.Pointer(bp + 8)) == int32(TCL_NUMBER_INT) || *(*int32)(unsafe.Pointer(bp + 12)) == int32(TCL_NUMBER_INT) {
				/*
				 * Check for overflow.
				 */
				if w1^wResult < 0 && w1^*(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) >= 0 {
					goto overflowBasic
				}
			}
		case int32(INST_SUB):
			wResult = libc.Int64FromUint64(libc.Uint64FromInt64(w1) - libc.Uint64FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 48))))
			if *(*int32)(unsafe.Pointer(bp + 8)) == int32(TCL_NUMBER_INT) || *(*int32)(unsafe.Pointer(bp + 12)) == int32(TCL_NUMBER_INT) {
				/*
				 * Must check for overflow. The macro tests for overflows
				 * in sums by looking at the sign bits. As we have a
				 * subtraction here, we are adding -w2. As -w2 could in
				 * turn overflow, we test with ~w2 instead: it has the
				 * opposite sign bit to w2 so it does the job. Note that
				 * the only "bad" case (w2==0) is irrelevant for this
				 * macro, as in that case w1 and wResult have the same
				 * sign and there is no overflow anyway.
				 */
				if w1^wResult < 0 && w1^^*(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) >= 0 {
					goto overflowBasic
				}
			}
		case int32(INST_MULT):
			if w1 < int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) || w1 > int64(INT_MAX) || *(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) < int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) || *(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) > int64(INT_MAX) {
				goto overflowBasic
			}
			wResult = w1 * *(*TTcl_WideInt)(unsafe.Pointer(bp + 48))
		case int32(INST_DIV):
			if *(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) == 0 {
				return uintptr(-libc.Int32FromInt32(1))
			}
			/*
			 * Need a bignum to represent (WIDE_MIN / -1)
			 */
			if w1 == libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))+libc.Uint64FromInt32(1)) && *(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) == int64(-int32(1)) {
				goto overflowBasic
			}
			wResult = w1 / *(*TTcl_WideInt)(unsafe.Pointer(bp + 48))
			/*
			 * Force Tcl's integer division rules.
			 * TODO: examine for logic simplification
			 */
			if (wResult < 0 || wResult == 0 && (w1 < 0 && *(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) > 0 || w1 > 0 && *(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) < 0)) && wResult**(*TTcl_WideInt)(unsafe.Pointer(bp + 48)) != w1 {
				wResult -= int64(1)
			}
		default:
			/*
			 * Unused, here to silence compiler warning.
			 */
			wResult = 0
		}
		if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount > int64(1) {
			return XTcl_NewWideIntObj(tls, wResult)
		} else {
			*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 360)))) = wResult
			_isobjPtr13 = valuePtr
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr13)).Fbytes != libc.UintptrFromInt32(0) {
				if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr13)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr13)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(_isobjPtr13)).Fbytes = libc.UintptrFromInt32(0)
			}
			XTcl_StoreInternalRep(tls, valuePtr, uintptr(unsafe.Pointer(&XtclIntType)), bp+360)
			return libc.UintptrFromInt32(0)
		}
	}
	goto overflowBasic
overflowBasic:
	;
	XTcl_TakeBignumFromObj(tls, libc.UintptrFromInt32(0), valuePtr, bp+56)
	XTcl_TakeBignumFromObj(tls, libc.UintptrFromInt32(0), value2Ptr, bp+80)
	err = XTclBN_mp_init(tls, bp+104)
	if err == MP_OKAY {
		switch opcode {
		case int32(INST_ADD):
			err = XTclBN_mp_add(tls, bp+56, bp+80, bp+104)
		case int32(INST_SUB):
			err = XTclBN_mp_sub(tls, bp+56, bp+80, bp+104)
		case int32(INST_MULT):
			err = XTclBN_mp_mul(tls, bp+56, bp+80, bp+104)
		case int32(INST_DIV):
			if (*Tmp_int)(unsafe.Pointer(bp+80)).Fused == 0 {
				v42 = int32(MP_YES)
			} else {
				v42 = MP_NO
			}
			if v42 != 0 {
				XTclBN_mp_clear(tls, bp+56)
				XTclBN_mp_clear(tls, bp+80)
				XTclBN_mp_clear(tls, bp+104)
				return uintptr(-libc.Int32FromInt32(1))
			}
			err = XTclBN_mp_init(tls, bp+128)
			if err == MP_OKAY {
				err = XTclBN_mp_div(tls, bp+56, bp+80, bp+104, bp+128)
			}
			/* TODO: internals intrusion */
			if (*Tmp_int)(unsafe.Pointer(bp+128)).Fused == 0 {
				v43 = int32(MP_YES)
			} else {
				v43 = MP_NO
			}
			if !(v43 != 0) && (*(*Tmp_int)(unsafe.Pointer(bp + 128))).Fsign != (*(*Tmp_int)(unsafe.Pointer(bp + 80))).Fsign {
				/*
				 * Convert to Tcl's integer division rules.
				 */
				err = XTclBN_mp_sub_d(tls, bp+104, uint32(1), bp+104)
				if err == MP_OKAY {
					err = XTclBN_mp_add(tls, bp+128, bp+80, bp+128)
				}
			}
			XTclBN_mp_clear(tls, bp+128)
			break
		}
	}
	XTclBN_mp_clear(tls, bp+56)
	XTclBN_mp_clear(tls, bp+80)
	if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount > int64(1) {
		return XTcl_NewBignumObj(tls, bp+104)
	} else {
		XTcl_SetBignumObj(tls, valuePtr, bp+104)
		return libc.UintptrFromInt32(0)
	}
_24:
	;
	XTcl_Panic(tls, __ccgo_ts+24589, 0)
	return libc.UintptrFromInt32(0)
}

func _ExecuteExtendedUnaryMathOp(tls *libc.TLS, opcode int32, valuePtr uintptr) (r uintptr) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* The operand on the stack. */
	var _isobjPtr, _isobjPtr1, cachePtr, objResultPtr uintptr
	var err Tmp_err
	var w TTcl_WideInt
	var v4 uint64
	var v7 bool
	var _ /* __u at bp+0 */ struct {
		F__i [0]uint64
		F__f float64
	}
	var _ /* big at bp+24 */ Tmp_int
	var _ /* ir at bp+48 */ TTcl_ObjInternalRep
	var _ /* ir at bp+64 */ TTcl_ObjInternalRep
	var _ /* ptr at bp+8 */ uintptr
	var _ /* type at bp+16 */ int32
	_, _, _, _, _, _, _, _ = _isobjPtr, _isobjPtr1, cachePtr, err, objResultPtr, w, v4, v7
	*(*uintptr)(unsafe.Pointer(bp + 8)) = libc.UintptrFromInt32(0)
	err = MP_OKAY
	if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*int32)(unsafe.Pointer(bp + 16)) = int32(TCL_NUMBER_INT)
		*(*uintptr)(unsafe.Pointer(bp + 8)) = valuePtr + 32
		_ = libc.Int32FromInt32(TCL_OK)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
			*(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(valuePtr)).FinternalRep))
			v4 = *(*uint64)(unsafe.Pointer(bp))
			goto _5
		_5:
			if libc.BoolInt32(v4&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) > libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
				*(*int32)(unsafe.Pointer(bp + 16)) = int32(TCL_NUMBER_NAN)
			} else {
				*(*int32)(unsafe.Pointer(bp + 16)) = int32(TCL_NUMBER_DOUBLE)
			}
			*(*uintptr)(unsafe.Pointer(bp + 8)) = valuePtr + 32
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			if !((*TTcl_Obj)(unsafe.Pointer(valuePtr)).Fbytes != libc.UintptrFromInt32(0) && (*TTcl_Obj)(unsafe.Pointer(valuePtr)).Flength == 0) {
				XTcl_GetNumberFromObj(tls, libc.UintptrFromInt32(0), valuePtr, bp+8, bp+16)
			}
		}
	}
	switch opcode {
	case int32(INST_BITNOT):
		if *(*int32)(unsafe.Pointer(bp + 16)) == int32(TCL_NUMBER_INT) {
			w = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))
			if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount > int64(1) {
				return XTcl_NewWideIntObj(tls, ^w)
			} else {
				*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 48)))) = ^w
				_isobjPtr = valuePtr
				if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
					if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
				}
				XTcl_StoreInternalRep(tls, valuePtr, uintptr(unsafe.Pointer(&XtclIntType)), bp+48)
				return libc.UintptrFromInt32(0)
			}
		}
		XTcl_TakeBignumFromObj(tls, libc.UintptrFromInt32(0), valuePtr, bp+24)
		/* ~a = - a - 1 */
		err = XTclBN_mp_neg(tls, bp+24, bp+24)
		if err == MP_OKAY {
			err = XTclBN_mp_sub_d(tls, bp+24, uint32(1), bp+24)
		}
		if err != MP_OKAY {
			return uintptr(-libc.Int32FromInt32(4))
		}
		if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount > int64(1) {
			return XTcl_NewBignumObj(tls, bp+24)
		} else {
			XTcl_SetBignumObj(tls, valuePtr, bp+24)
			return libc.UintptrFromInt32(0)
		}
		fallthrough
	case int32(INST_UMINUS):
		switch *(*int32)(unsafe.Pointer(bp + 16)) {
		case int32(TCL_NUMBER_DOUBLE):
			if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount > int64(1) {
				if v7 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v7 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v7 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
					objResultPtr = XTclThreadAllocObj(tls)
				} else {
					objResultPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(objResultPtr + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(objResultPtr)).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer(objResultPtr)).Fbytes = libc.UintptrFromInt32(0)
				*(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objResultPtr)).FinternalRep)) = -*(*float64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))
				(*TTcl_Obj)(unsafe.Pointer(objResultPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclDoubleType))
				return objResultPtr
			} else {
				XTcl_SetDoubleObj(tls, valuePtr, -*(*float64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))))
				return libc.UintptrFromInt32(0)
			}
			fallthrough
		case int32(TCL_NUMBER_INT):
			w = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))
			if w != libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))+libc.Uint64FromInt32(1)) {
				if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount > int64(1) {
					return XTcl_NewWideIntObj(tls, -w)
				} else {
					*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 64)))) = -w
					_isobjPtr1 = valuePtr
					if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes != libc.UintptrFromInt32(0) {
						if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes = libc.UintptrFromInt32(0)
					}
					XTcl_StoreInternalRep(tls, valuePtr, uintptr(unsafe.Pointer(&XtclIntType)), bp+64)
					return libc.UintptrFromInt32(0)
				}
			}
			err = XTclBN_mp_init_i64(tls, bp+24, w)
			if err != MP_OKAY {
				return uintptr(-libc.Int32FromInt32(4))
			}
		default:
			XTcl_TakeBignumFromObj(tls, libc.UintptrFromInt32(0), valuePtr, bp+24)
		}
		err = XTclBN_mp_neg(tls, bp+24, bp+24)
		if err != MP_OKAY {
			return uintptr(-libc.Int32FromInt32(4))
		}
		if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount > int64(1) {
			return XTcl_NewBignumObj(tls, bp+24)
		} else {
			XTcl_SetBignumObj(tls, valuePtr, bp+24)
			return libc.UintptrFromInt32(0)
		}
	}
	XTcl_Panic(tls, __ccgo_ts+24589, 0)
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * CompareTwoNumbers --
 *
 *	This function compares a pair of numbers in Tcl_Objs. Each argument
 *	must already be known to be numeric and not NaN.
 *
 * Results:
 *	One of MP_LT, MP_EQ or MP_GT, depending on whether valuePtr is less
 *	than, equal to, or greater than value2Ptr (respectively).
 *
 * Side effects:
 *	None, provided both values are numeric.
 *
 *----------------------------------------------------------------------
 */

func XTclCompareTwoNumbers(tls *libc.TLS, valuePtr uintptr, value2Ptr uintptr) (r int32) {
	bp := tls.Alloc(96)
	defer tls.Free(96)
	var compare, v22, v23, v24, v29, v30, v33, v34, v41 int32
	var d1, d2 float64
	var w1, w2 TTcl_WideInt
	var v10, v31, v39, v4 uint64
	var _ /* __u at bp+0 */ struct {
		F__i [0]uint64
		F__f float64
	}
	var _ /* big1 at bp+32 */ Tmp_int
	var _ /* big2 at bp+56 */ Tmp_int
	var _ /* ptr1 at bp+16 */ uintptr
	var _ /* ptr2 at bp+24 */ uintptr
	var _ /* tmp at bp+80 */ float64
	var _ /* type1 at bp+8 */ int32
	var _ /* type2 at bp+12 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = compare, d1, d2, w1, w2, v10, v22, v23, v24, v29, v30, v31, v33, v34, v39, v4, v41
	*(*int32)(unsafe.Pointer(bp + 8)) = int32(TCL_NUMBER_NAN)
	*(*int32)(unsafe.Pointer(bp + 12)) = int32(TCL_NUMBER_NAN)
	if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*int32)(unsafe.Pointer(bp + 8)) = int32(TCL_NUMBER_INT)
		*(*uintptr)(unsafe.Pointer(bp + 16)) = valuePtr + 32
		_ = libc.Int32FromInt32(TCL_OK)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(valuePtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
			*(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(valuePtr)).FinternalRep))
			v4 = *(*uint64)(unsafe.Pointer(bp))
			goto _5
		_5:
			if libc.BoolInt32(v4&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) > libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
				*(*int32)(unsafe.Pointer(bp + 8)) = int32(TCL_NUMBER_NAN)
			} else {
				*(*int32)(unsafe.Pointer(bp + 8)) = int32(TCL_NUMBER_DOUBLE)
			}
			*(*uintptr)(unsafe.Pointer(bp + 16)) = valuePtr + 32
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			if !((*TTcl_Obj)(unsafe.Pointer(valuePtr)).Fbytes != libc.UintptrFromInt32(0) && (*TTcl_Obj)(unsafe.Pointer(valuePtr)).Flength == 0) {
				XTcl_GetNumberFromObj(tls, libc.UintptrFromInt32(0), valuePtr, bp+16, bp+8)
			}
		}
	}
	if (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*int32)(unsafe.Pointer(bp + 12)) = int32(TCL_NUMBER_INT)
		*(*uintptr)(unsafe.Pointer(bp + 24)) = value2Ptr + 32
		_ = libc.Int32FromInt32(TCL_OK)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
			*(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FinternalRep))
			v10 = *(*uint64)(unsafe.Pointer(bp))
			goto _11
		_11:
			if libc.BoolInt32(v10&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) > libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
				*(*int32)(unsafe.Pointer(bp + 12)) = int32(TCL_NUMBER_NAN)
			} else {
				*(*int32)(unsafe.Pointer(bp + 12)) = int32(TCL_NUMBER_DOUBLE)
			}
			*(*uintptr)(unsafe.Pointer(bp + 24)) = value2Ptr + 32
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			if !((*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes != libc.UintptrFromInt32(0) && (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Flength == 0) {
				XTcl_GetNumberFromObj(tls, libc.UintptrFromInt32(0), value2Ptr, bp+24, bp+12)
			}
		}
	}
	switch *(*int32)(unsafe.Pointer(bp + 8)) {
	case int32(TCL_NUMBER_INT):
		goto _13
	case int32(TCL_NUMBER_DOUBLE):
		goto _14
	case int32(TCL_NUMBER_BIG):
		goto _15
	default:
		goto _16
	}
	goto _17
_13:
	;
	w1 = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16))))
	switch *(*int32)(unsafe.Pointer(bp + 12)) {
	case int32(TCL_NUMBER_INT):
		goto _18
	case int32(TCL_NUMBER_DOUBLE):
		goto _19
	case int32(TCL_NUMBER_BIG):
		goto _20
	}
	goto _21
_18:
	;
	w2 = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24))))
	goto wideCompare
wideCompare:
	;
	if w1 < w2 {
		v22 = -int32(1)
	} else {
		if w1 > w2 {
			v23 = int32(MP_GT)
		} else {
			v23 = MP_EQ
		}
		v22 = v23
	}
	return v22
_19:
	;
	d2 = *(*float64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24))))
	d1 = float64(w1)
	/*
	 * If the double has a fractional part, or if the Tcl_WideInt can be
	 * converted to double without loss of precision, then compare as
	 * doubles.
	 */
	if libc.Bool(uint64(DBL_MANT_DIG) > libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8)) || w1 == int64(d1) || libc.Xmodf(tls, d2, bp+80) != float64(0) {
		goto doubleCompare
	}
	/*
	 * Otherwise, to make comparision based on full precision, need to
	 * convert the double to a suitably sized integer.
	 *
	 * Need this to get comparsions like
	 *	  expr 20000000000000003 < 20000000000000004.0
	 * right. Converting the first argument to double will yield two
	 * double values that are equivalent within double precision.
	 * Converting the double to an integer gets done exactly, then
	 * integer comparison can tell the difference.
	 */
	if d2 < float64(libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))+libc.Uint64FromInt32(1))) {
		return int32(MP_GT)
	}
	if d2 > float64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) {
		return -int32(1)
	}
	w2 = int64(d2)
	goto wideCompare
_20:
	;
	XTcl_TakeBignumFromObj(tls, libc.UintptrFromInt32(0), value2Ptr, bp+56)
	if (*Tmp_int)(unsafe.Pointer(bp+56)).Fsign != MP_ZPOS {
		v24 = int32(MP_YES)
	} else {
		v24 = MP_NO
	}
	if v24 != 0 {
		compare = int32(MP_GT)
	} else {
		compare = -int32(1)
	}
	XTclBN_mp_clear(tls, bp+56)
	return compare
_21:
	;
	goto _17
_14:
	;
	d1 = *(*float64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16))))
	switch *(*int32)(unsafe.Pointer(bp + 12)) {
	case int32(TCL_NUMBER_DOUBLE):
		goto _25
	case int32(TCL_NUMBER_INT):
		goto _26
	case int32(TCL_NUMBER_BIG):
		goto _27
	}
	goto _28
_25:
	;
	d2 = *(*float64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24))))
	goto doubleCompare
doubleCompare:
	;
	if d1 < d2 {
		v29 = -int32(1)
	} else {
		if d1 > d2 {
			v30 = int32(MP_GT)
		} else {
			v30 = MP_EQ
		}
		v29 = v30
	}
	return v29
_26:
	;
	w2 = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24))))
	d2 = float64(w2)
	if libc.Bool(uint64(DBL_MANT_DIG) > libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8)) || w2 == int64(d2) || libc.Xmodf(tls, d1, bp+80) != float64(0) {
		goto doubleCompare
	}
	if d1 < float64(libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))+libc.Uint64FromInt32(1))) {
		return -int32(1)
	}
	if d1 > float64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) {
		return int32(MP_GT)
	}
	w1 = int64(d1)
	goto wideCompare
_27:
	;
	*(*float64)(unsafe.Pointer(bp)) = d1
	v31 = *(*uint64)(unsafe.Pointer(bp))
	goto _32
_32:
	if libc.BoolInt32(v31&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) == libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
		if d1 > float64(0) {
			v33 = int32(MP_GT)
		} else {
			v33 = -int32(1)
		}
		return v33
	}
	XTcl_TakeBignumFromObj(tls, libc.UintptrFromInt32(0), value2Ptr, bp+56)
	if d1 < float64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) && d1 > float64(libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))+libc.Uint64FromInt32(1))) {
		if (*Tmp_int)(unsafe.Pointer(bp+56)).Fsign != MP_ZPOS {
			v34 = int32(MP_YES)
		} else {
			v34 = MP_NO
		}
		if v34 != 0 {
			compare = int32(MP_GT)
		} else {
			compare = -int32(1)
		}
		XTclBN_mp_clear(tls, bp+56)
		return compare
	}
	if libc.Bool(uint64(DBL_MANT_DIG) > libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8)) && libc.Xmodf(tls, d1, bp+80) != float64(0) {
		d2 = XTclBignumToDouble(tls, bp+56)
		XTclBN_mp_clear(tls, bp+56)
		goto doubleCompare
	}
	XTcl_InitBignumFromDouble(tls, libc.UintptrFromInt32(0), d1, bp+32)
	goto bigCompare
_28:
	;
	goto _17
_15:
	;
	XTcl_TakeBignumFromObj(tls, libc.UintptrFromInt32(0), valuePtr, bp+32)
	switch *(*int32)(unsafe.Pointer(bp + 12)) {
	case int32(TCL_NUMBER_INT):
		goto _35
	case int32(TCL_NUMBER_DOUBLE):
		goto _36
	case int32(TCL_NUMBER_BIG):
		goto _37
	}
	goto _38
_35:
	;
	compare = XTclBN_mp_cmp_d(tls, bp+32, uint32(0))
	XTclBN_mp_clear(tls, bp+32)
	return compare
_36:
	;
	d2 = *(*float64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24))))
	*(*float64)(unsafe.Pointer(bp)) = d2
	v39 = *(*uint64)(unsafe.Pointer(bp))
	goto _40
_40:
	if libc.BoolInt32(v39&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) == libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
		if d2 > float64(0) {
			v41 = -int32(1)
		} else {
			v41 = int32(MP_GT)
		}
		compare = v41
		XTclBN_mp_clear(tls, bp+32)
		return compare
	}
	if d2 < float64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) && d2 > float64(libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))+libc.Uint64FromInt32(1))) {
		compare = XTclBN_mp_cmp_d(tls, bp+32, uint32(0))
		XTclBN_mp_clear(tls, bp+32)
		return compare
	}
	if libc.Bool(uint64(DBL_MANT_DIG) > libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8)) && libc.Xmodf(tls, d2, bp+80) != float64(0) {
		d1 = XTclBignumToDouble(tls, bp+32)
		XTclBN_mp_clear(tls, bp+32)
		goto doubleCompare
	}
	XTcl_InitBignumFromDouble(tls, libc.UintptrFromInt32(0), d2, bp+56)
	goto bigCompare
_37:
	;
	XTcl_TakeBignumFromObj(tls, libc.UintptrFromInt32(0), value2Ptr, bp+56)
	goto bigCompare
bigCompare:
	;
	compare = XTclBN_mp_cmp(tls, bp+32, bp+56)
	XTclBN_mp_clear(tls, bp+32)
	XTclBN_mp_clear(tls, bp+56)
	return compare
_38:
	;
	goto _17
_16:
	;
	XTcl_Panic(tls, __ccgo_ts+33233, 0)
_17:
	;
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * ValidatePcAndStackTop --
 *
 *	This procedure is called by TclNRExecuteByteCode when debugging to
 *	verify that the program counter and stack top are valid during
 *	execution.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Prints a message to stderr and panics if either the pc or stack top
 *	are invalid.
 *
 *----------------------------------------------------------------------
 */

/*
 *----------------------------------------------------------------------
 *
 * IllegalExprOperandType --
 *
 *	Used by TclNRExecuteByteCode to append an error message to the interp
 *	result when an illegal operand type is detected by an expression
 *	instruction. The argument opndPtr holds the operand object in error.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	An error message is appended to the interp result.
 *
 *----------------------------------------------------------------------
 */

func _IllegalExprOperandType(tls *libc.TLS, interp uintptr, ord uintptr, pc uintptr, opndPtr uintptr) {
	bp := tls.Alloc(96)
	defer tls.Free(96) /* Points to the operand holding the value
	 * with the illegal type. */
	var description, lengthProc, op, v11, v12, v14 uintptr
	var opcode uint8
	var v13 bool
	var v3, v4, v8 int32
	var v6 uint64
	var _ /* __u at bp+0 */ struct {
		F__i [0]uint64
		F__f float64
	}
	var _ /* length at bp+24 */ TTcl_Size
	var _ /* objcPtr at bp+32 */ TTcl_Size
	var _ /* objvPtr at bp+40 */ uintptr
	var _ /* ptr at bp+8 */ uintptr
	var _ /* type at bp+16 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _ = description, lengthProc, op, opcode, v11, v12, v13, v14, v3, v4, v6, v8
	opcode = *(*uint8)(unsafe.Pointer(pc))
	op = __ccgo_ts + 15720
	if libc.Int32FromUint8(opcode) == int32(INST_EXPON) {
		op = __ccgo_ts + 6243
	} else {
		if libc.Int32FromUint8(opcode) <= int32(INST_LNOT) {
			op = _operatorStrings[libc.Int32FromUint8(opcode)-int32(INST_BITOR)]
		}
	}
	if (*TTcl_Obj)(unsafe.Pointer(opndPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*int32)(unsafe.Pointer(bp + 16)) = int32(TCL_NUMBER_INT)
		*(*uintptr)(unsafe.Pointer(bp + 8)) = opndPtr + 32
		v3 = libc.Int32FromInt32(TCL_OK)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(opndPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
			*(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(opndPtr)).FinternalRep))
			v6 = *(*uint64)(unsafe.Pointer(bp))
			goto _7
		_7:
			if libc.BoolInt32(v6&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) > libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
				*(*int32)(unsafe.Pointer(bp + 16)) = int32(TCL_NUMBER_NAN)
			} else {
				*(*int32)(unsafe.Pointer(bp + 16)) = int32(TCL_NUMBER_DOUBLE)
			}
			*(*uintptr)(unsafe.Pointer(bp + 8)) = opndPtr + 32
			v4 = libc.Int32FromInt32(TCL_OK)
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(opndPtr)).Fbytes != libc.UintptrFromInt32(0) && (*TTcl_Obj)(unsafe.Pointer(opndPtr)).Flength == 0 {
				v8 = int32(TCL_ERROR)
			} else {
				v8 = XTcl_GetNumberFromObj(tls, libc.UintptrFromInt32(0), opndPtr, bp+8, bp+16)
			}
			v4 = v8
		}
		v3 = v4
	}
	if !(v3 != TCL_OK) {
		goto _1
	}
	if !((*TTcl_Obj)(unsafe.Pointer(opndPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDictType))) {
		goto _9
	}
	XTcl_DictObjSize(tls, libc.UintptrFromInt32(0), opndPtr, bp+24)
	if !(*(*TTcl_Size)(unsafe.Pointer(bp + 24)) > 0) {
		goto _10
	}
	goto listRep
listRep:
	;
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+33256, libc.VaList(bp+56, ord, op)))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+56, __ccgo_ts+8919, __ccgo_ts+8925, __ccgo_ts+2860, libc.UintptrFromInt32(0)))
	return
_10:
	;
_9:
	;
	if (*TTcl_Obj)(unsafe.Pointer(opndPtr)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+48) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+48) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(opndPtr)).FtypePtr)).Fversion) {
		v11 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(opndPtr)).FtypePtr)).FlengthProc
	} else {
		v11 = libc.UintptrFromInt32(0)
	}
	lengthProc = v11
	if v13 = lengthProc != 0 && (*(*func(*libc.TLS, uintptr) TTcl_Size)(unsafe.Pointer(&struct{ uintptr }{lengthProc})))(tls, opndPtr) > int64(1); !v13 {
		if (*TTcl_Obj)(unsafe.Pointer(opndPtr)).Fbytes != 0 {
			v12 = (*TTcl_Obj)(unsafe.Pointer(opndPtr)).Fbytes
		} else {
			v12 = XTcl_GetStringFromObj(tls, opndPtr, libc.UintptrFromInt32(0))
		}
	}
	if v13 || XTclMaxListLength(tls, v12, int64(-libc.Int32FromInt32(1)), libc.UintptrFromInt32(0)) > int64(1) && XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), opndPtr, bp+32, bp+40) == TCL_OK {
		goto listRep
	}
	description = __ccgo_ts + 33295
	goto _2
_1:
	;
	if *(*int32)(unsafe.Pointer(bp + 16)) == int32(TCL_NUMBER_NAN) {
		description = __ccgo_ts + 33314
	} else {
		if *(*int32)(unsafe.Pointer(bp + 16)) == int32(TCL_NUMBER_DOUBLE) {
			description = __ccgo_ts + 33347
		} else {
			/* TODO: No caller needs this. Eliminate? */
			description = __ccgo_ts + 33368
		}
	}
_2:
	;
	if (*TTcl_Obj)(unsafe.Pointer(opndPtr)).Fbytes != 0 {
		v14 = (*TTcl_Obj)(unsafe.Pointer(opndPtr)).Fbytes
	} else {
		v14 = XTcl_GetStringFromObj(tls, opndPtr, libc.UintptrFromInt32(0))
	}
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+33382, libc.VaList(bp+56, description, v14, ord, op)))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+56, __ccgo_ts+8919, __ccgo_ts+8925, description, libc.UintptrFromInt32(0)))
}

/*
 *----------------------------------------------------------------------
 *
 * TclGetSrcInfoForPc, GetSrcInfoForPc, TclGetSourceFromFrame --
 *
 *	Given a program counter value, finds the closest command in the
 *	bytecode code unit's CmdLocation array and returns information about
 *	that command's source: a pointer to its first byte and the number of
 *	characters.
 *
 * Results:
 *	If a command is found that encloses the program counter value, a
 *	pointer to the command's source is returned and the length of the
 *	source is stored at *lengthPtr. If multiple commands resulted in code
 *	at pc, information about the closest enclosing command is returned. If
 *	no matching command is found, NULL is returned and *lengthPtr is
 *	unchanged.
 *
 * Side effects:
 *	The CmdFrame at *cfPtr is updated.
 *
 *----------------------------------------------------------------------
 */

func XTclGetSourceFromFrame(tls *libc.TLS, cfPtr uintptr, objc TTcl_Size, objv uintptr) (r uintptr) {
	var codePtr uintptr
	_ = codePtr
	if cfPtr == libc.UintptrFromInt32(0) {
		return XTcl_NewListObj(tls, objc, objv)
	}
	if (*TCmdFrame)(unsafe.Pointer(cfPtr)).FcmdObj == libc.UintptrFromInt32(0) {
		if (*TCmdFrame)(unsafe.Pointer(cfPtr)).Fcmd == libc.UintptrFromInt32(0) {
			codePtr = (*(*struct {
				FcodePtr uintptr
				Fpc      uintptr
			})(unsafe.Pointer(cfPtr + 40))).FcodePtr
			(*TCmdFrame)(unsafe.Pointer(cfPtr)).Fcmd = _GetSrcInfoForPc(tls, (*(*struct {
				FcodePtr uintptr
				Fpc      uintptr
			})(unsafe.Pointer(cfPtr + 40))).Fpc, codePtr, cfPtr+72, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
		}
		if (*TCmdFrame)(unsafe.Pointer(cfPtr)).Fcmd != 0 {
			(*TCmdFrame)(unsafe.Pointer(cfPtr)).FcmdObj = XTcl_NewStringObj(tls, (*TCmdFrame)(unsafe.Pointer(cfPtr)).Fcmd, (*TCmdFrame)(unsafe.Pointer(cfPtr)).Flen1)
		} else {
			(*TCmdFrame)(unsafe.Pointer(cfPtr)).FcmdObj = XTcl_NewListObj(tls, objc, objv)
		}
		(*TTcl_Obj)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(cfPtr)).FcmdObj)).FrefCount++
	}
	return (*TCmdFrame)(unsafe.Pointer(cfPtr)).FcmdObj
}

func XTclGetSrcInfoForPc(tls *libc.TLS, cfPtr uintptr) {
	var codePtr, eclPtr, hePtr, iPtr, locPtr uintptr
	var i, srcOffset TTcl_Size
	_, _, _, _, _, _, _ = codePtr, eclPtr, hePtr, i, iPtr, locPtr, srcOffset
	codePtr = (*(*struct {
		FcodePtr uintptr
		Fpc      uintptr
	})(unsafe.Pointer(cfPtr + 40))).FcodePtr
	if (*TCmdFrame)(unsafe.Pointer(cfPtr)).Fcmd == libc.UintptrFromInt32(0) {
		(*TCmdFrame)(unsafe.Pointer(cfPtr)).Fcmd = _GetSrcInfoForPc(tls, (*(*struct {
			FcodePtr uintptr
			Fpc      uintptr
		})(unsafe.Pointer(cfPtr + 40))).Fpc, codePtr, cfPtr+72, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	}
	if (*TCmdFrame)(unsafe.Pointer(cfPtr)).Fcmd != libc.UintptrFromInt32(0) {
		locPtr = libc.UintptrFromInt32(0)
		iPtr = *(*uintptr)(unsafe.Pointer((*TByteCode)(unsafe.Pointer(codePtr)).FinterpHandle))
		hePtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FlineBCPtr)).FfindProc})))(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlineBCPtr, codePtr)
		if !(hePtr != 0) {
			return
		}
		srcOffset = int64((*TCmdFrame)(unsafe.Pointer(cfPtr)).Fcmd) - int64((*TByteCode)(unsafe.Pointer(codePtr)).Fsource)
		eclPtr = (*TTcl_HashEntry)(unsafe.Pointer(hePtr)).FclientData
		i = 0
		for {
			if !(i < (*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Fnuloc) {
				break
			}
			if (*(*TECL)(unsafe.Pointer((*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Floc + uintptr(i)*32))).FsrcOffset == srcOffset {
				locPtr = (*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Floc + uintptr(i)*32
				break
			}
			goto _1
		_1:
			;
			i++
		}
		if locPtr == libc.UintptrFromInt32(0) {
			XTcl_Panic(tls, __ccgo_ts+33422, 0)
		}
		(*TCmdFrame)(unsafe.Pointer(cfPtr)).Fline = (*TECL)(unsafe.Pointer(locPtr)).Fline
		(*TCmdFrame)(unsafe.Pointer(cfPtr)).Fnline = (*TECL)(unsafe.Pointer(locPtr)).Fnline
		(*TCmdFrame)(unsafe.Pointer(cfPtr)).Ftype1 = (*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Ftype1
		if (*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Ftype1 == int32(TCL_LOCATION_SOURCE) {
			(*TCmdFrame)(unsafe.Pointer(cfPtr)).Fdata.Feval.Fpath = (*TExtCmdLoc)(unsafe.Pointer(eclPtr)).Fpath
			(*TTcl_Obj)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(cfPtr)).Fdata.Feval.Fpath)).FrefCount++
		}
		/*
		 * Do not set cfPtr->data.eval.path NULL for non-SOURCE. Needed for
		 * cfPtr->data.tebc.codePtr.
		 */
	}
}

func _GetSrcInfoForPc(tls *libc.TLS, pc uintptr, codePtr uintptr, lengthPtr uintptr, pcBeg uintptr, cmdIdxPtr uintptr) (r uintptr) {
	/* If non-NULL, the location where the index
	 * of the command containing the pc should
	 * be stored. */
	var bestCmdIdx, bestDist, bestSrcLength, bestSrcOffset, codeEnd, codeLen, codeOffset, delta, i, numCmds, pcOffset, srcLen, srcOffset, v1 TTcl_Size
	var codeDeltaNext, codeLengthNext, curr, prev, srcDeltaNext, srcLengthNext, v3 uintptr
	var dist int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bestCmdIdx, bestDist, bestSrcLength, bestSrcOffset, codeDeltaNext, codeEnd, codeLen, codeLengthNext, codeOffset, curr, delta, dist, i, numCmds, pcOffset, prev, srcDeltaNext, srcLen, srcLengthNext, srcOffset, v1, v3
	pcOffset = int64(pc) - int64((*TByteCode)(unsafe.Pointer(codePtr)).FcodeStart)
	numCmds = (*TByteCode)(unsafe.Pointer(codePtr)).FnumCommands
	bestDist = libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1)) /* Distance of pc to best cmd's start pc. */
	bestSrcOffset = int64(-int32(1))                                                                         /* Initialized to avoid compiler warning. */
	bestSrcLength = int64(-int32(1))                                                                         /* Initialized to avoid compiler warning. */
	bestCmdIdx = int64(-int32(1))
	/* The pc must point within the bytecode */
	/*
	 * Decode the code and source offset and length for each command. The
	 * closest enclosing command is the last one whose code started before
	 * pcOffset.
	 */
	codeDeltaNext = (*TByteCode)(unsafe.Pointer(codePtr)).FcodeDeltaStart
	codeLengthNext = (*TByteCode)(unsafe.Pointer(codePtr)).FcodeLengthStart
	srcDeltaNext = (*TByteCode)(unsafe.Pointer(codePtr)).FsrcDeltaStart
	srcLengthNext = (*TByteCode)(unsafe.Pointer(codePtr)).FsrcLengthStart
	v1 = libc.Int64FromInt32(0)
	srcOffset = v1
	codeOffset = v1
	i = 0
	for {
		if !(i < numCmds) {
			break
		}
		if uint32(*(*uint8)(unsafe.Pointer(codeDeltaNext))) == libc.Uint32FromInt32(0xFF) {
			codeDeltaNext++
			delta = int64(libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(codeDeltaNext)))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(codeDeltaNext + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(codeDeltaNext + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(codeDeltaNext + libc.UintptrFromInt32(3))))))
			codeDeltaNext += uintptr(4)
		} else {
			delta = int64(int32(*(*int8)(unsafe.Pointer(codeDeltaNext))))
			codeDeltaNext++
		}
		codeOffset += delta
		if uint32(*(*uint8)(unsafe.Pointer(codeLengthNext))) == libc.Uint32FromInt32(0xFF) {
			codeLengthNext++
			codeLen = int64(libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(codeLengthNext)))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(codeLengthNext + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(codeLengthNext + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(codeLengthNext + libc.UintptrFromInt32(3))))))
			codeLengthNext += uintptr(4)
		} else {
			codeLen = int64(int32(*(*int8)(unsafe.Pointer(codeLengthNext))))
			codeLengthNext++
		}
		codeEnd = codeOffset + codeLen - libc.Int64FromInt32(1)
		if uint32(*(*uint8)(unsafe.Pointer(srcDeltaNext))) == libc.Uint32FromInt32(0xFF) {
			srcDeltaNext++
			delta = int64(libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(srcDeltaNext)))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(srcDeltaNext + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(srcDeltaNext + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(srcDeltaNext + libc.UintptrFromInt32(3))))))
			srcDeltaNext += uintptr(4)
		} else {
			delta = int64(int32(*(*int8)(unsafe.Pointer(srcDeltaNext))))
			srcDeltaNext++
		}
		srcOffset += delta
		if uint32(*(*uint8)(unsafe.Pointer(srcLengthNext))) == libc.Uint32FromInt32(0xFF) {
			srcLengthNext++
			srcLen = int64(libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(srcLengthNext)))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(srcLengthNext + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(srcLengthNext + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(srcLengthNext + libc.UintptrFromInt32(3))))))
			srcLengthNext += uintptr(4)
		} else {
			srcLen = int64(int32(*(*int8)(unsafe.Pointer(srcLengthNext))))
			srcLengthNext++
		}
		if codeOffset > pcOffset { /* Best cmd already found */
			break
		}
		if pcOffset <= codeEnd { /* This cmd's code encloses pc */
			dist = int32(pcOffset - codeOffset)
			if int64(dist) <= bestDist {
				bestDist = int64(dist)
				bestSrcOffset = srcOffset
				bestSrcLength = srcLen
				bestCmdIdx = i
			}
		}
		goto _2
	_2:
		;
		i++
	}
	if pcBeg != libc.UintptrFromInt32(0) {
		/*
		 * Walk from beginning of command or BC to pc, by complete
		 * instructions. Stop when crossing pc; keep previous.
		 */
		if bestDist == libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)) {
			v3 = (*TByteCode)(unsafe.Pointer(codePtr)).FcodeStart
		} else {
			v3 = pc - uintptr(bestDist)
		}
		curr = v3
		prev = curr
		for curr <= pc {
			prev = curr
			curr += uintptr(XtclInstructionTable[*(*uint8)(unsafe.Pointer(curr))].FnumBytes)
		}
		*(*uintptr)(unsafe.Pointer(pcBeg)) = prev
	}
	if bestDist == libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)) {
		return libc.UintptrFromInt32(0)
	}
	if lengthPtr != libc.UintptrFromInt32(0) {
		*(*TTcl_Size)(unsafe.Pointer(lengthPtr)) = bestSrcLength
	}
	if cmdIdxPtr != libc.UintptrFromInt32(0) {
		*(*TTcl_Size)(unsafe.Pointer(cmdIdxPtr)) = bestCmdIdx
	}
	return (*TByteCode)(unsafe.Pointer(codePtr)).Fsource + uintptr(bestSrcOffset)
}

/*
 *----------------------------------------------------------------------
 *
 * GetExceptRangeForPc --
 *
 *	Given a program counter value, return the closest enclosing
 *	ExceptionRange.
 *
 * Results:
 *	If the searchMode is TCL_ERROR, this procedure ignores loop exception
 *	ranges and returns a pointer to the closest catch range. If the
 *	searchMode is TCL_BREAK, this procedure returns a pointer to the most
 *	closely enclosing ExceptionRange regardless of whether it is a loop or
 *	catch exception range. If the searchMode is TCL_CONTINUE, this
 *	procedure returns a pointer to the most closely enclosing
 *	ExceptionRange (of any type) skipping only loop exception ranges if
 *	they don't have a sensible continueOffset defined. If no matching
 *	ExceptionRange is found that encloses pc, a NULL is returned.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _GetExceptRangeForPc(tls *libc.TLS, pc uintptr, searchMode int32, codePtr uintptr) (r uintptr) {
	/* Points to the ByteCode in which to search
	 * for the enclosing ExceptionRange. */
	var numRanges, pcOffset, start Tsize_t
	var rangeArrayPtr, rangePtr, v1 uintptr
	_, _, _, _, _, _ = numRanges, pcOffset, rangeArrayPtr, rangePtr, start, v1
	numRanges = libc.Uint64FromInt64((*TByteCode)(unsafe.Pointer(codePtr)).FnumExceptRanges)
	pcOffset = libc.Uint64FromInt64(int64(pc) - int64((*TByteCode)(unsafe.Pointer(codePtr)).FcodeStart))
	if numRanges == uint64(0) {
		return libc.UintptrFromInt32(0)
	}
	/*
	 * This exploits peculiarities of our compiler: nested ranges are always
	 * *after* their containing ranges, so that by scanning backwards we are
	 * sure that the first matching range is indeed the deepest.
	 */
	rangeArrayPtr = (*TByteCode)(unsafe.Pointer(codePtr)).FexceptArrayPtr
	rangePtr = rangeArrayPtr + uintptr(numRanges)*56
	for {
		rangePtr -= 56
		v1 = rangePtr
		if !(v1 >= rangeArrayPtr) {
			break
		}
		start = libc.Uint64FromInt64((*TExceptionRange)(unsafe.Pointer(rangePtr)).FcodeOffset)
		if start <= pcOffset && pcOffset < start+libc.Uint64FromInt64((*TExceptionRange)(unsafe.Pointer(rangePtr)).FnumCodeBytes) {
			if (*TExceptionRange)(unsafe.Pointer(rangePtr)).Ftype1 == int32(CATCH_EXCEPTION_RANGE) {
				return rangePtr
			}
			if searchMode == int32(TCL_BREAK) {
				return rangePtr
			}
			if searchMode == int32(TCL_CONTINUE) && (*TExceptionRange)(unsafe.Pointer(rangePtr)).FcontinueOffset != int64(-libc.Int32FromInt32(1)) {
				return rangePtr
			}
		}
	}
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * GetOpcodeName --
 *
 *	This procedure is called by the TRACE and TRACE_WITH_OBJ macros used
 *	in TclNRExecuteByteCode when debugging. It returns the name of the
 *	bytecode instruction at a specified instruction pc.
 *
 * Results:
 *	A character string for the instruction.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

/*
 *----------------------------------------------------------------------
 *
 * TclExprFloatError --
 *
 *	This procedure is called when an error occurs during a floating-point
 *	operation. It reads errno and sets interp->objResultPtr accordingly.
 *
 * Results:
 *	interp->objResultPtr is set to hold an error message.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclExprFloatError(tls *libc.TLS, interp uintptr, value float64) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Value returned after error; used to
	 * distinguish underflows from overflows. */
	var objPtr, s, v7 uintptr
	var v1, v4 uint64
	var v3, v6 bool
	var _ /* __u at bp+0 */ struct {
		F__i [0]uint64
		F__f float64
	}
	_, _, _, _, _, _, _ = objPtr, s, v1, v3, v4, v6, v7
	if v3 = *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(EDOM); !v3 {
		*(*float64)(unsafe.Pointer(bp)) = value
		v1 = *(*uint64)(unsafe.Pointer(bp))
		goto _2
	_2:
	}
	if v3 || libc.BoolInt32(v1&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) > libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
		s = __ccgo_ts + 8932
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, s, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+8919, __ccgo_ts+8925, s, libc.UintptrFromInt32(0)))
	} else {
		if v6 = *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(ERANGE); !v6 {
			*(*float64)(unsafe.Pointer(bp)) = value
			v4 = *(*uint64)(unsafe.Pointer(bp))
			goto _5
		_5:
		}
		if v6 || libc.BoolInt32(v4&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) == libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
			if value == float64(0) {
				s = __ccgo_ts + 33440
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, s, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+8919, __ccgo_ts+33484, s, libc.UintptrFromInt32(0)))
			} else {
				s = __ccgo_ts + 33494
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, s, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+8919, __ccgo_ts+33538, s, libc.UintptrFromInt32(0)))
			}
		} else {
			objPtr = XTcl_ObjPrintf(tls, __ccgo_ts+33547, libc.VaList(bp+16, *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))))
			if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
				v7 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
			} else {
				v7 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
			}
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+8919, __ccgo_ts+2095, v7, libc.UintptrFromInt32(0)))
			XTcl_SetObjResult(tls, interp, objPtr)
		}
	}
}

type TExecStack1 = struct {
	FprevPtr   uintptr
	FnextPtr   uintptr
	FmarkerPtr uintptr
	FendPtr    uintptr
	FtosPtr    uintptr
}

type TVar1 = struct {
	Fflags int32
	Fvalue struct {
		FtablePtr [0]uintptr
		FlinkPtr  [0]uintptr
		FobjPtr   uintptr
	}
}

/*
 *---------------------------------------------------------------------------
 *
 * TclFileRenameCmd
 *
 *	This function implements the "rename" subcommand of the "file"
 *	command. Filename arguments need to be translated to native format
 *	before being passed to platform-specific code that implements rename
 *	functionality.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *---------------------------------------------------------------------------
 */

func XTclFileRenameCmd(tls *libc.TLS, dummy50 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument strings passed to Tcl_FileCmd. */
	return _FileCopyRename(tls, interp, objc, objv, 0)
}

/*
 *---------------------------------------------------------------------------
 *
 * TclFileCopyCmd
 *
 *	This function implements the "copy" subcommand of the "file" command.
 *	Filename arguments need to be translated to native format before being
 *	passed to platform-specific code that implements copy functionality.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *---------------------------------------------------------------------------
 */

func XTclFileCopyCmd(tls *libc.TLS, dummy79 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument strings passed to Tcl_FileCmd. */
	return _FileCopyRename(tls, interp, objc, objv, int32(1))
}

/*
 *---------------------------------------------------------------------------
 *
 * FileCopyRename --
 *
 *	Performs the work of TclFileRenameCmd and TclFileCopyCmd. See
 *	comments for those functions.
 *
 * Results:
 *	See above.
 *
 * Side effects:
 *	See above.
 *
 *---------------------------------------------------------------------------
 */

func _FileCopyRename(tls *libc.TLS, interp uintptr, objc int32, objv uintptr, copyFlag int32) (r int32) {
	bp := tls.Alloc(416)
	defer tls.Free(416) /* If non-zero, copy source(s). Otherwise,
	 * rename them. */
	var _objPtr, _objPtr1, newFileName, source, target, v1, v2, v3, v6, v8 uintptr
	var i, result int32
	var v5, v7 TTcl_Size
	var _ /* ds at bp+152 */ TTcl_DString
	var _ /* force at bp+0 */ int32
	var _ /* jargv at bp+376 */ [2]uintptr
	var _ /* statBuf at bp+8 */ TTcl_StatBuf
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, i, newFileName, result, source, target, v1, v2, v3, v5, v6, v7, v8
	i = _FileForceOption(tls, interp, objc-int32(1), objv+uintptr(1)*8, bp)
	if i < 0 {
		return int32(TCL_ERROR)
	}
	i++
	if objc-i < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+33588)
		return int32(TCL_ERROR)
	}
	/*
	 * If target doesn't exist or isn't a directory, try the copy/rename. More
	 * than 2 arguments is only valid if the target is an existing directory.
	 */
	target = *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8))
	if XTcl_FSConvertToPathType(tls, interp, target) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(target)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(target)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, target, libc.UintptrFromInt32(0))
	}
	if XTcl_UtfToExternalDStringEx(tls, interp, libc.UintptrFromInt32(0), v1, int64(-libc.Int32FromInt32(1)), 0, bp+152, libc.UintptrFromInt32(0)) != TCL_OK {
		XTcl_DStringFree(tls, bp+152)
		return int32(TCL_ERROR)
	}
	XTcl_DStringFree(tls, bp+152)
	result = TCL_OK
	/*
	 * Call Tcl_FSStat() so that if target is a symlink that points to a
	 * directory we will put the sources in that directory instead of
	 * overwriting the symlink.
	 */
	if XTcl_FSStat(tls, target, bp+8) != 0 || !((*(*TTcl_StatBuf)(unsafe.Pointer(bp + 8))).Fst_mode&libc.Uint32FromInt32(S_IFMT) == libc.Uint32FromInt32(S_IFDIR)) {
		if objc-i > int32(2) {
			*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = int32(ENOTDIR)
			XTcl_PosixError(tls, interp)
			if copyFlag != 0 {
				v2 = __ccgo_ts + 33635
			} else {
				v2 = __ccgo_ts + 33643
			}
			if (*TTcl_Obj)(unsafe.Pointer(target)).Fbytes != 0 {
				v3 = (*TTcl_Obj)(unsafe.Pointer(target)).Fbytes
			} else {
				v3 = XTcl_GetStringFromObj(tls, target, libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+33652, libc.VaList(bp+400, v2, v3)))
			result = int32(TCL_ERROR)
		} else {
			/*
			 * Even though already have target == translated(objv[i+1]), pass
			 * the original argument down, so if there's an error, the error
			 * message will reflect the original arguments.
			 */
			result = _CopyRenameOneFile(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)), copyFlag, *(*int32)(unsafe.Pointer(bp)))
		}
		return result
	}
	/*
	 * Move each source file into target directory. Extract the basename from
	 * each source, and append it to the end of the target path.
	 */
	for {
		if !(i < objc-int32(1)) {
			break
		}
		source = _FileBasename(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))
		if source == libc.UintptrFromInt32(0) {
			result = int32(TCL_ERROR)
			break
		}
		(*(*[2]uintptr)(unsafe.Pointer(bp + 376)))[0] = *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8))
		(*(*[2]uintptr)(unsafe.Pointer(bp + 376)))[int32(1)] = source
		newFileName = XTclJoinPath(tls, int64(2), bp+376, int32(1))
		(*TTcl_Obj)(unsafe.Pointer(newFileName)).FrefCount++
		result = _CopyRenameOneFile(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), newFileName, copyFlag, *(*int32)(unsafe.Pointer(bp)))
		_objPtr = newFileName
		v6 = _objPtr
		v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
		*(*TTcl_Size)(unsafe.Pointer(v6))--
		if v5 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		_objPtr1 = source
		v8 = _objPtr1
		v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
		*(*TTcl_Size)(unsafe.Pointer(v8))--
		if v7 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		if result == int32(TCL_ERROR) {
			break
		}
		goto _4
	_4:
		;
		i++
	}
	return result
}

/*
 *---------------------------------------------------------------------------
 *
 * TclFileMakeDirsCmd
 *
 *	This function implements the "mkdir" subcommand of the "file" command.
 *	Filename arguments need to be translated to native format before being
 *	passed to platform-specific code that implements mkdir functionality.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTclFileMakeDirsCmd(tls *libc.TLS, dummy224 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(400)
	defer tls.Free(400) /* Argument strings passed to Tcl_FileCmd. */
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, errfile, split, target, v11, v13, v2, v6, v8, v9 uintptr
	var errCount, i, result, v4 int32
	var j, v10, v12, v5, v7 TTcl_Size
	var _ /* ds at bp+152 */ TTcl_DString
	var _ /* pobjc at bp+0 */ TTcl_Size
	var _ /* statBuf at bp+8 */ TTcl_StatBuf
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, errCount, errfile, i, j, result, split, target, v10, v11, v12, v13, v2, v4, v5, v6, v7, v8, v9
	errfile = libc.UintptrFromInt32(0)
	split = libc.UintptrFromInt32(0)
	target = libc.UintptrFromInt32(0)
	result = TCL_OK
	i = int32(1)
	for {
		if !(i < objc) {
			break
		}
		if XTcl_FSConvertToPathType(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))) != TCL_OK {
			result = int32(TCL_ERROR)
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		if XTcl_UtfToExternalDStringEx(tls, interp, libc.UintptrFromInt32(0), v2, int64(-libc.Int32FromInt32(1)), 0, bp+152, libc.UintptrFromInt32(0)) != TCL_OK {
			XTcl_DStringFree(tls, bp+152)
			result = int32(TCL_ERROR)
			break
		}
		XTcl_DStringFree(tls, bp+152)
		split = XTcl_FSSplitPath(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp)
		(*TTcl_Obj)(unsafe.Pointer(split)).FrefCount++
		if *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
			*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = int32(ENOENT)
			errfile = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
			break
		}
		j = 0
		for {
			if !(j < *(*TTcl_Size)(unsafe.Pointer(bp))) {
				break
			}
			errCount = int32(2)
			target = XTcl_FSJoinPath(tls, split, j+int64(1))
			(*TTcl_Obj)(unsafe.Pointer(target)).FrefCount++
			goto createDir
		createDir:
			;
			/*
			 * Call Tcl_FSStat() so that if target is a symlink that points to
			 * a directory we will create subdirectories in that directory.
			 */
			if XTcl_FSStat(tls, target, bp+8) == 0 {
				if !((*(*TTcl_StatBuf)(unsafe.Pointer(bp + 8))).Fst_mode&libc.Uint32FromInt32(S_IFMT) == libc.Uint32FromInt32(S_IFDIR)) {
					*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = int32(EEXIST)
					errfile = target
					goto done
				}
			} else {
				if *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) != int32(ENOENT) {
					/*
					 * If Tcl_FSStat() failed and the error is anything other than
					 * non-existence of the target, throw the error.
					 */
					errfile = target
					goto done
				} else {
					if XTcl_FSCreateDirectory(tls, target) != TCL_OK {
						/*
						 * Create might have failed because of being in a race
						 * condition with another process trying to create the same
						 * subdirectory.
						 */
						if *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(EEXIST) {
							/* Be aware other workers could delete it immediately after
							 * creation, so give this worker still one chance (repeat once),
							 * see [270f78ca95] for description of the race-condition.
							 * Don't repeat the create always (to avoid endless loop). */
							errCount--
							v4 = errCount
							if v4 > 0 {
								goto createDir
							}
							/* Already tried, with delete in-between directly after
							 * creation, so just continue (assume created successful). */
							goto nextPart
						}
						/* return with error */
						errfile = target
						goto done
					}
				}
			}
			goto nextPart
		nextPart:
			;
			/*
			 * Forget about this sub-path.
			 */
			_objPtr = target
			v6 = _objPtr
			v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
			*(*TTcl_Size)(unsafe.Pointer(v6))--
			if v5 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			target = libc.UintptrFromInt32(0)
			goto _3
		_3:
			;
			j++
		}
		_objPtr1 = split
		v8 = _objPtr1
		v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
		*(*TTcl_Size)(unsafe.Pointer(v8))--
		if v7 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		split = libc.UintptrFromInt32(0)
		goto _1
	_1:
		;
		i++
	}
	goto done
done:
	;
	if errfile != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(errfile)).Fbytes != 0 {
			v9 = (*TTcl_Obj)(unsafe.Pointer(errfile)).Fbytes
		} else {
			v9 = XTcl_GetStringFromObj(tls, errfile, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+33693, libc.VaList(bp+384, v9, XTcl_PosixError(tls, interp))))
		result = int32(TCL_ERROR)
	}
	if split != libc.UintptrFromInt32(0) {
		_objPtr2 = split
		v11 = _objPtr2
		v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
		*(*TTcl_Size)(unsafe.Pointer(v11))--
		if v10 <= int64(1) {
			XTclFreeObj(tls, _objPtr2)
		}
	}
	if target != libc.UintptrFromInt32(0) {
		_objPtr3 = target
		v13 = _objPtr3
		v12 = *(*TTcl_Size)(unsafe.Pointer(v13))
		*(*TTcl_Size)(unsafe.Pointer(v13))--
		if v12 <= int64(1) {
			XTclFreeObj(tls, _objPtr3)
		}
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * TclFileDeleteCmd
 *
 *	This function implements the "delete" subcommand of the "file"
 *	command.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTclFileDeleteCmd(tls *libc.TLS, dummy357 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(416)
	defer tls.Free(416) /* Argument strings passed to Tcl_FileCmd. */
	var _objPtr, errfile, v2, v3, v4, v6 uintptr
	var i, result int32
	var v5 TTcl_Size
	var _ /* ds at bp+16 */ TTcl_DString
	var _ /* errorBuffer at bp+8 */ uintptr
	var _ /* force at bp+0 */ int32
	var _ /* statBuf at bp+240 */ TTcl_StatBuf
	_, _, _, _, _, _, _, _, _ = _objPtr, errfile, i, result, v2, v3, v4, v5, v6
	*(*uintptr)(unsafe.Pointer(bp + 8)) = libc.UintptrFromInt32(0)
	i = _FileForceOption(tls, interp, objc-int32(1), objv+uintptr(1)*8, bp)
	if i < 0 {
		return int32(TCL_ERROR)
	}
	errfile = libc.UintptrFromInt32(0)
	result = TCL_OK
	i++
	for {
		if !(i < objc) {
			break
		}
		errfile = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
		if XTcl_FSConvertToPathType(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))) != TCL_OK {
			result = int32(TCL_ERROR)
			goto done
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		if XTcl_UtfToExternalDStringEx(tls, interp, libc.UintptrFromInt32(0), v2, int64(-libc.Int32FromInt32(1)), 0, bp+16, libc.UintptrFromInt32(0)) != TCL_OK {
			XTcl_DStringFree(tls, bp+16)
			result = int32(TCL_ERROR)
			goto done
		}
		XTcl_DStringFree(tls, bp+16)
		/*
		 * Call lstat() to get info so can delete symbolic link itself.
		 */
		if XTcl_FSLstat(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp+240) != 0 {
			result = int32(TCL_ERROR)
		} else {
			if (*(*TTcl_StatBuf)(unsafe.Pointer(bp + 240))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) {
				/*
				 * We own a reference count on errorBuffer, if it was set as a
				 * result of this call.
				 */
				result = XTcl_FSRemoveDirectory(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), *(*int32)(unsafe.Pointer(bp)), bp+8)
				if result != TCL_OK {
					if *(*int32)(unsafe.Pointer(bp)) == 0 && *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(EEXIST) {
						if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
							v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
						} else {
							v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
						}
						XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+33725, libc.VaList(bp+392, v3)))
						XTcl_PosixError(tls, interp)
						goto done
					}
					/*
					 * If possible, use the untranslated name for the file.
					 */
					errfile = *(*uintptr)(unsafe.Pointer(bp + 8))
					/*
					 * FS supposed to check between translated objv and errfile.
					 */
					if XTcl_FSEqualPaths(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), errfile) != 0 {
						errfile = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
					}
				}
			} else {
				result = XTcl_FSDeleteFile(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))
			}
		}
		if result != TCL_OK {
			/*
			 * Avoid possible race condition (file/directory deleted after call
			 * of lstat), so bypass ENOENT because not an error, just a no-op
			 */
			if *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(ENOENT) {
				result = TCL_OK
				goto _1
			}
			/*
			 * It is important that we break on error, otherwise we might end
			 * up owning reference counts on numerous errorBuffers.
			 */
			result = int32(TCL_ERROR)
			break
		}
		goto _1
	_1:
		;
		i++
	}
	if result != TCL_OK {
		if errfile == libc.UintptrFromInt32(0) {
			/*
			 * We try to accommodate poor error results from our Tcl_FS calls.
			 */
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+33766, libc.VaList(bp+392, XTcl_PosixError(tls, interp))))
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(errfile)).Fbytes != 0 {
				v4 = (*TTcl_Obj)(unsafe.Pointer(errfile)).Fbytes
			} else {
				v4 = XTcl_GetStringFromObj(tls, errfile, libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+33798, libc.VaList(bp+392, v4, XTcl_PosixError(tls, interp))))
		}
	}
	goto done
done:
	;
	if *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) {
		_objPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
		v6 = _objPtr
		v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
		*(*TTcl_Size)(unsafe.Pointer(v6))--
		if v5 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	return result
}

/*
 *---------------------------------------------------------------------------
 *
 * CopyRenameOneFile
 *
 *	Copies or renames specified source file or directory hierarchy to the
 *	specified target.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Target is overwritten if the force flag is set. Attempting to
 *	copy/rename a file onto a directory or a directory onto a file will
 *	always result in an error.
 *
 *----------------------------------------------------------------------
 */

func _CopyRenameOneFile(tls *libc.TLS, interp uintptr, source uintptr, target uintptr, copyFlag int32, force int32) (r int32) {
	bp := tls.Alloc(560)
	defer tls.Free(560) /* If non-zero, overwrite target file if it
	 * exists. Otherwise, error if target already
	 * exists. */
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, actualSource, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cmdObj, copyCommand, errfile, errorMsg, opObj, perm, v1, v10, v11, v17, v18, v19, v2, v20, v21, v22, v24, v26, v3, v4, v5, v6, v9 uintptr
	var result int32
	var v12, v13, v14, v15, v7 bool
	var v16, v23, v25, v8 TTcl_Size
	var _ /* ds at bp+296 */ TTcl_DString
	var _ /* errorBuffer at bp+0 */ uintptr
	var _ /* index at bp+520 */ int32
	var _ /* sourceStatBuf at bp+8 */ TTcl_StatBuf
	var _ /* targetStatBuf at bp+152 */ TTcl_StatBuf
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, actualSource, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cmdObj, copyCommand, errfile, errorMsg, opObj, perm, result, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v3, v4, v5, v6, v7, v8, v9
	actualSource = libc.UintptrFromInt32(0)
	if XTcl_FSConvertToPathType(tls, interp, source) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(source)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(source)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, source, libc.UintptrFromInt32(0))
	}
	if XTcl_UtfToExternalDStringEx(tls, interp, libc.UintptrFromInt32(0), v1, int64(-libc.Int32FromInt32(1)), 0, bp+296, libc.UintptrFromInt32(0)) != TCL_OK {
		XTcl_DStringFree(tls, bp+296)
		return int32(TCL_ERROR)
	}
	XTcl_DStringFree(tls, bp+296)
	if XTcl_FSConvertToPathType(tls, interp, target) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(target)).Fbytes != 0 {
		v2 = (*TTcl_Obj)(unsafe.Pointer(target)).Fbytes
	} else {
		v2 = XTcl_GetStringFromObj(tls, target, libc.UintptrFromInt32(0))
	}
	if XTcl_UtfToExternalDStringEx(tls, interp, libc.UintptrFromInt32(0), v2, int64(-libc.Int32FromInt32(1)), 0, bp+296, libc.UintptrFromInt32(0)) != TCL_OK {
		XTcl_DStringFree(tls, bp+296)
		return int32(TCL_ERROR)
	}
	XTcl_DStringFree(tls, bp+296)
	errfile = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	result = int32(TCL_ERROR)
	/*
	 * We want to copy/rename links and not the files they point to, so we use
	 * lstat(). If target is a link, we also want to replace the link and not
	 * the file it points to, so we also use lstat() on the target.
	 */
	if XTcl_FSLstat(tls, source, bp+8) != 0 {
		errfile = source
		goto done
	}
	if XTcl_FSLstat(tls, target, bp+152) != 0 {
		if *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) != int32(ENOENT) {
			errfile = target
			goto done
		}
	} else {
		if force == 0 {
			*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = int32(EEXIST)
			errfile = target
			goto done
		}
		/*
		 * Prevent copying or renaming a file onto itself. On Windows since
		 * 8.5 we do get an inode number, however the unsigned short field is
		 * insufficient to accept the Win32 API file id so it is truncated to
		 * 16 bits and we get collisions. See bug #2015723.
		 */
		if (*(*TTcl_StatBuf)(unsafe.Pointer(bp + 8))).Fst_ino != uint64(0) && (*(*TTcl_StatBuf)(unsafe.Pointer(bp + 152))).Fst_ino != uint64(0) {
			if (*(*TTcl_StatBuf)(unsafe.Pointer(bp + 8))).Fst_ino == (*(*TTcl_StatBuf)(unsafe.Pointer(bp + 152))).Fst_ino && (*(*TTcl_StatBuf)(unsafe.Pointer(bp + 8))).Fst_dev == (*(*TTcl_StatBuf)(unsafe.Pointer(bp + 152))).Fst_dev {
				result = TCL_OK
				goto done
			}
		}
		/*
		 * Prevent copying/renaming a file onto a directory and vice-versa.
		 * This is a policy decision based on the fact that existing
		 * implementations of copy and rename on all platforms also prevent
		 * this.
		 */
		if (*(*TTcl_StatBuf)(unsafe.Pointer(bp + 8))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) && !((*(*TTcl_StatBuf)(unsafe.Pointer(bp + 152))).Fst_mode&libc.Uint32FromInt32(S_IFMT) == libc.Uint32FromInt32(S_IFDIR)) {
			*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = int32(EISDIR)
			if (*TTcl_Obj)(unsafe.Pointer(target)).Fbytes != 0 {
				v3 = (*TTcl_Obj)(unsafe.Pointer(target)).Fbytes
			} else {
				v3 = XTcl_GetStringFromObj(tls, target, libc.UintptrFromInt32(0))
			}
			if (*TTcl_Obj)(unsafe.Pointer(source)).Fbytes != 0 {
				v4 = (*TTcl_Obj)(unsafe.Pointer(source)).Fbytes
			} else {
				v4 = XTcl_GetStringFromObj(tls, source, libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+33822, libc.VaList(bp+536, v3, v4)))
			goto done
		}
		if !((*(*TTcl_StatBuf)(unsafe.Pointer(bp + 8))).Fst_mode&libc.Uint32FromInt32(S_IFMT) == libc.Uint32FromInt32(S_IFDIR)) && (*(*TTcl_StatBuf)(unsafe.Pointer(bp + 152))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) {
			*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = int32(EISDIR)
			if (*TTcl_Obj)(unsafe.Pointer(target)).Fbytes != 0 {
				v5 = (*TTcl_Obj)(unsafe.Pointer(target)).Fbytes
			} else {
				v5 = XTcl_GetStringFromObj(tls, target, libc.UintptrFromInt32(0))
			}
			if (*TTcl_Obj)(unsafe.Pointer(source)).Fbytes != 0 {
				v6 = (*TTcl_Obj)(unsafe.Pointer(source)).Fbytes
			} else {
				v6 = XTcl_GetStringFromObj(tls, source, libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+33868, libc.VaList(bp+536, v5, v6)))
			goto done
		}
		/*
		 * The destination exists, but appears to be ok to over-write, and
		 * -force is given. We now try to adjust permissions to ensure the
		 * operation succeeds. If we can't adjust permissions, we'll let the
		 * actual copy/rename return an error later.
		 */
		if v7 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v7 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v7 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			perm = XTclThreadAllocObj(tls)
		} else {
			perm = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(perm + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(perm)).FrefCount = 0
		if libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer(perm)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(perm)).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(perm)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(perm)).Fbytes, __ccgo_ts+33914, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(perm)).Fbytes + uintptr(libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(perm)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(4) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer(perm)).FtypePtr = libc.UintptrFromInt32(0)
		(*TTcl_Obj)(unsafe.Pointer(perm)).FrefCount++
		if XTclFSFileAttrIndex(tls, target, __ccgo_ts+33918, bp+520) == TCL_OK {
			XTcl_FSFileAttrsSet(tls, libc.UintptrFromInt32(0), *(*int32)(unsafe.Pointer(bp + 520)), target, perm)
		}
		_objPtr = perm
		v9 = _objPtr
		v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
		*(*TTcl_Size)(unsafe.Pointer(v9))--
		if v8 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	if copyFlag == 0 {
		result = XTcl_FSRenameFile(tls, source, target)
		if result == TCL_OK {
			goto done
		}
		if *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(EINVAL) {
			if (*TTcl_Obj)(unsafe.Pointer(source)).Fbytes != 0 {
				v10 = (*TTcl_Obj)(unsafe.Pointer(source)).Fbytes
			} else {
				v10 = XTcl_GetStringFromObj(tls, source, libc.UintptrFromInt32(0))
			}
			if (*TTcl_Obj)(unsafe.Pointer(target)).Fbytes != 0 {
				v11 = (*TTcl_Obj)(unsafe.Pointer(target)).Fbytes
			} else {
				v11 = XTcl_GetStringFromObj(tls, target, libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+33931, libc.VaList(bp+536, v10, v11)))
			goto done
		} else {
			if *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) != int32(EXDEV) {
				errfile = target
				goto done
			}
		}
		/*
		 * The rename failed because the move was across file systems. Fall
		 * through to copy file and then remove original. Note that the
		 * low-level Tcl_FSRenameFileProc in the filesystem is allowed to
		 * implement cross-filesystem moves itself, if it desires.
		 */
	}
	actualSource = source
	(*TTcl_Obj)(unsafe.Pointer(actualSource)).FrefCount++
	/*
	 * Activate the following block to copy files instead of links. However
	 * Tcl's semantics currently say we should copy links, so any such change
	 * should be the subject of careful study on the consequences.
	 *
	 * Perhaps there could be an optional flag to 'file copy' to dictate which
	 * approach to use, with the default being _not_ to have this block
	 * active.
	 */
	if (*(*TTcl_StatBuf)(unsafe.Pointer(bp + 8))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) {
		result = XTcl_FSCopyDirectory(tls, actualSource, target, bp)
		if result != TCL_OK {
			if *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(EXDEV) {
				if v12 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v12 {
					cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v12 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
					copyCommand = XTclThreadAllocObj(tls)
				} else {
					copyCommand = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(copyCommand + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(copyCommand)).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer(copyCommand)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(copyCommand)).Flength = 0
				(*TTcl_Obj)(unsafe.Pointer(copyCommand)).FtypePtr = libc.UintptrFromInt32(0)
				if v13 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v13 {
					cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v13 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
					cmdObj = XTclThreadAllocObj(tls)
				} else {
					cmdObj = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(cmdObj + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(cmdObj)).FrefCount = 0
				if libc.Uint64FromInt64(21)-libc.Uint64FromInt32(1) == uint64(0) {
					(*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(cmdObj)).Flength = int64(libc.Int32FromInt32(0))
				} else {
					(*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(21)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
					libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes, __ccgo_ts+34018, libc.Uint64FromInt64(21)-libc.Uint64FromInt32(1))
					*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes + uintptr(libc.Uint64FromInt64(21)-libc.Uint64FromInt32(1)))) = uint8('\000')
					(*TTcl_Obj)(unsafe.Pointer(cmdObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(21) - libc.Uint64FromInt32(1))
				}
				(*TTcl_Obj)(unsafe.Pointer(cmdObj)).FtypePtr = libc.UintptrFromInt32(0)
				XTcl_ListObjAppendElement(tls, interp, copyCommand, cmdObj)
				if copyFlag != 0 {
					if v14 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v14 {
						cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v14 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
						opObj = XTclThreadAllocObj(tls)
					} else {
						opObj = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(opObj + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer(opObj)).FrefCount = 0
					if libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1) == uint64(0) {
						(*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
						(*TTcl_Obj)(unsafe.Pointer(opObj)).Flength = int64(libc.Int32FromInt32(0))
					} else {
						(*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
						libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes, __ccgo_ts+33635, libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1))
						*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes + uintptr(libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)))) = uint8('\000')
						(*TTcl_Obj)(unsafe.Pointer(opObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(8) - libc.Uint64FromInt32(1))
					}
					(*TTcl_Obj)(unsafe.Pointer(opObj)).FtypePtr = libc.UintptrFromInt32(0)
				} else {
					if v15 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v15 {
						cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v15 || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == libc.Uint64FromInt32(0) {
						opObj = XTclThreadAllocObj(tls)
					} else {
						opObj = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(opObj + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer(opObj)).FrefCount = 0
					if libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1) == uint64(0) {
						(*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
						(*TTcl_Obj)(unsafe.Pointer(opObj)).Flength = int64(libc.Int32FromInt32(0))
					} else {
						(*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
						libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes, __ccgo_ts+33643, libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1))
						*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes + uintptr(libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1)))) = uint8('\000')
						(*TTcl_Obj)(unsafe.Pointer(opObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(9) - libc.Uint64FromInt32(1))
					}
					(*TTcl_Obj)(unsafe.Pointer(opObj)).FtypePtr = libc.UintptrFromInt32(0)
				}
				XTcl_ListObjAppendElement(tls, interp, copyCommand, opObj)
				XTcl_ListObjAppendElement(tls, interp, copyCommand, source)
				XTcl_ListObjAppendElement(tls, interp, copyCommand, target)
				(*TTcl_Obj)(unsafe.Pointer(copyCommand)).FrefCount++
				result = XTcl_EvalObjEx(tls, interp, copyCommand, libc.Int32FromInt32(TCL_EVAL_GLOBAL)|libc.Int32FromInt32(TCL_EVAL_DIRECT))
				_objPtr1 = copyCommand
				v17 = _objPtr1
				v16 = *(*TTcl_Size)(unsafe.Pointer(v17))
				*(*TTcl_Size)(unsafe.Pointer(v17))--
				if v16 <= int64(1) {
					XTclFreeObj(tls, _objPtr1)
				}
				if result != TCL_OK {
					/*
					 * There was an error in the Tcl-level copy. We will pass
					 * on the Tcl error message and can ensure this by setting
					 * errfile to NULL
					 */
					errfile = libc.UintptrFromInt32(0)
				}
			} else {
				errfile = *(*uintptr)(unsafe.Pointer(bp))
				if XTcl_FSEqualPaths(tls, errfile, source) != 0 {
					errfile = source
				} else {
					if XTcl_FSEqualPaths(tls, errfile, target) != 0 {
						errfile = target
					}
				}
			}
		}
	} else {
		result = XTcl_FSCopyFile(tls, actualSource, target)
		if result != TCL_OK && *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(EXDEV) {
			result = XTclCrossFilesystemCopy(tls, interp, source, target)
		}
		if result != TCL_OK {
			/*
			 * We could examine 'errno' to double-check if the problem was
			 * with the target, but we checked the source above, so it should
			 * be quite clear
			 */
			errfile = target
		}
		/*
		 * We now need to reset the result, because the above call,
		 * may have left set it.  (Ideally we would prefer not to pass
		 * an interpreter in above, but the channel IO code used by
		 * TclCrossFilesystemCopy currently requires one)
		 */
		XTcl_ResetResult(tls, interp)
	}
	if copyFlag == 0 && result == TCL_OK {
		if (*(*TTcl_StatBuf)(unsafe.Pointer(bp + 8))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) {
			result = XTcl_FSRemoveDirectory(tls, source, int32(1), bp)
			if result != TCL_OK {
				errfile = *(*uintptr)(unsafe.Pointer(bp))
				if XTcl_FSEqualPaths(tls, errfile, source) == 0 {
					errfile = source
				}
			}
		} else {
			result = XTcl_FSDeleteFile(tls, source)
			if result != TCL_OK {
				errfile = source
			}
		}
		if result != TCL_OK {
			if (*TTcl_Obj)(unsafe.Pointer(errfile)).Fbytes != 0 {
				v18 = (*TTcl_Obj)(unsafe.Pointer(errfile)).Fbytes
			} else {
				v18 = XTcl_GetStringFromObj(tls, errfile, libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+34039, libc.VaList(bp+536, v18, XTcl_PosixError(tls, interp))))
			errfile = libc.UintptrFromInt32(0)
		}
	}
	goto done
done:
	;
	if errfile != libc.UintptrFromInt32(0) {
		if copyFlag != 0 {
			v19 = __ccgo_ts + 33635
		} else {
			v19 = __ccgo_ts + 33643
		}
		if (*TTcl_Obj)(unsafe.Pointer(source)).Fbytes != 0 {
			v20 = (*TTcl_Obj)(unsafe.Pointer(source)).Fbytes
		} else {
			v20 = XTcl_GetStringFromObj(tls, source, libc.UintptrFromInt32(0))
		}
		errorMsg = XTcl_ObjPrintf(tls, __ccgo_ts+34061, libc.VaList(bp+536, v19, v20))
		if errfile != source {
			if (*TTcl_Obj)(unsafe.Pointer(target)).Fbytes != 0 {
				v21 = (*TTcl_Obj)(unsafe.Pointer(target)).Fbytes
			} else {
				v21 = XTcl_GetStringFromObj(tls, target, libc.UintptrFromInt32(0))
			}
			XTcl_AppendPrintfToObj(tls, errorMsg, __ccgo_ts+34075, libc.VaList(bp+536, v21))
			if errfile != target {
				if (*TTcl_Obj)(unsafe.Pointer(errfile)).Fbytes != 0 {
					v22 = (*TTcl_Obj)(unsafe.Pointer(errfile)).Fbytes
				} else {
					v22 = XTcl_GetStringFromObj(tls, errfile, libc.UintptrFromInt32(0))
				}
				XTcl_AppendPrintfToObj(tls, errorMsg, __ccgo_ts+34084, libc.VaList(bp+536, v22))
			}
		}
		XTcl_AppendPrintfToObj(tls, errorMsg, __ccgo_ts+34091, libc.VaList(bp+536, XTcl_PosixError(tls, interp)))
		XTcl_SetObjResult(tls, interp, errorMsg)
	}
	if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
		_objPtr2 = *(*uintptr)(unsafe.Pointer(bp))
		v24 = _objPtr2
		v23 = *(*TTcl_Size)(unsafe.Pointer(v24))
		*(*TTcl_Size)(unsafe.Pointer(v24))--
		if v23 <= int64(1) {
			XTclFreeObj(tls, _objPtr2)
		}
	}
	if actualSource != libc.UintptrFromInt32(0) {
		_objPtr3 = actualSource
		v26 = _objPtr3
		v25 = *(*TTcl_Size)(unsafe.Pointer(v26))
		*(*TTcl_Size)(unsafe.Pointer(v26))--
		if v25 <= int64(1) {
			XTclFreeObj(tls, _objPtr3)
		}
	}
	return result
}

/*
 *---------------------------------------------------------------------------
 *
 * FileForceOption --
 *
 *	Helps parse command line options for file commands that take the
 *	"-force" and "--" options.
 *
 * Results:
 *	The return value is how many arguments from argv were consumed by this
 *	function, or -1 if there was an error parsing the options. If an error
 *	occurred, an error message is left in the interp's result.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func _FileForceOption(tls *libc.TLS, interp uintptr, objc int32, objv uintptr, forcePtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* If the "-force" was specified, *forcePtr is
	 * filled with 1, otherwise with 0. */
	var force, i int32
	var v2 uintptr
	var _ /* idx at bp+0 */ int32
	_, _, _ = force, i, v2
	force = 0
	i = 0
	for {
		if !(i < objc) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) != int32('-') {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_options9)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(TCL_EXACT)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
			return -int32(1)
		}
		if *(*int32)(unsafe.Pointer(bp)) == 0 {
			force = int32(1)
		} else { /* -- */
			i++
			break
		}
		goto _1
	_1:
		;
		i++
	}
	*(*int32)(unsafe.Pointer(forcePtr)) = force
	return i
}

var _options9 = [3]uintptr{
	0: __ccgo_ts + 34096,
	1: __ccgo_ts + 18684,
	2: libc.UintptrFromInt32(0),
}

/*
 *---------------------------------------------------------------------------
 *
 * FileBasename --
 *
 *	Given a path in either tcl format (with / separators), or in the
 *	platform-specific format for the current platform, return all the
 *	characters in the path after the last directory separator. But, if
 *	path is the root directory, returns no characters.
 *
 * Results:
 *	Returns the string object that represents the basename. If there is an
 *	error, an error message is left in interp, and NULL is returned.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func _FileBasename(tls *libc.TLS, dummy910 uintptr, pathPtr uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Path whose basename to extract. */
	var _objPtr, cachePtr, splitPtr, v3 uintptr
	var v1 bool
	var v2 TTcl_Size
	var _ /* objc at bp+0 */ TTcl_Size
	var _ /* resultPtr at bp+8 */ uintptr
	_, _, _, _, _, _ = _objPtr, cachePtr, splitPtr, v1, v2, v3
	*(*uintptr)(unsafe.Pointer(bp + 8)) = libc.UintptrFromInt32(0)
	splitPtr = XTcl_FSSplitPath(tls, pathPtr, bp)
	(*TTcl_Obj)(unsafe.Pointer(splitPtr)).FrefCount++
	if *(*TTcl_Size)(unsafe.Pointer(bp)) != 0 {
		/*
		 * Return the last component, unless it is the only component, and it
		 * is the root of an absolute path.
		 */
		if *(*TTcl_Size)(unsafe.Pointer(bp)) > 0 {
			XTcl_ListObjIndex(tls, libc.UintptrFromInt32(0), splitPtr, *(*TTcl_Size)(unsafe.Pointer(bp))-int64(1), bp+8)
			if *(*TTcl_Size)(unsafe.Pointer(bp)) == int64(1) && XTcl_FSGetPathType(tls, *(*uintptr)(unsafe.Pointer(bp + 8))) != int32(TCL_PATH_RELATIVE) {
				*(*uintptr)(unsafe.Pointer(bp + 8)) = libc.UintptrFromInt32(0)
			}
		}
	}
	if *(*uintptr)(unsafe.Pointer(bp + 8)) == libc.UintptrFromInt32(0) {
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr = libc.UintptrFromInt32(0)
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
	_objPtr = splitPtr
	v3 = _objPtr
	v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
	*(*TTcl_Size)(unsafe.Pointer(v3))--
	if v2 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return *(*uintptr)(unsafe.Pointer(bp + 8))
}

/*
 *----------------------------------------------------------------------
 *
 * TclFileAttrsCmd --
 *
 *	Sets or gets the platform-specific attributes of a file. The objc-objv
 *	points to the file name with the rest of the command line following.
 *	This routine uses platform-specific tables of option strings and
 *	callbacks. The callback to get the attributes take three parameters:
 *	    Tcl_Interp *interp;	    The interp to report errors with. Since
 *				    this is an object-based API, the object
 *				    form of the result should be used.
 *	    const char *fileName;   This is extracted using
 *				    Tcl_TranslateFileName.
 *	    TclObj **attrObjPtrPtr; A new object to hold the attribute is
 *				    allocated and put here.
 *	The first two parameters of the callback used to write out the
 *	attributes are the same. The third parameter is:
 *	    const *attrObjPtr;	    A pointer to the object that has the new
 *				    attribute.
 *	They both return standard TCL errors; if the routine to get an
 *	attribute fails, no object is allocated and *attrObjPtrPtr is
 *	unchanged.
 *
 * Results:
 *	Standard TCL error.
 *
 * Side effects:
 *	May set file attributes for the file name.
 *
 *----------------------------------------------------------------------
 */

func XTclFileAttrsCmd(tls *libc.TLS, dummy977 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(336)
	defer tls.Free(336) /* The command line objects. */
	var _objPtr, _objPtr1, attributeStrings, attributeStringsAllocated, filePtr, listPtr, objPtr1, v1, v10, v11, v13, v15, v2, v6, v9 uintptr
	var i, index1, nbAtts, res, result, v3 int32
	var index, v14, v8 TTcl_Size
	var v4 int64
	var _ /* ds at bp+16 */ TTcl_DString
	var _ /* index at bp+256 */ int32
	var _ /* index at bp+272 */ int32
	var _ /* numObjStrings at bp+8 */ TTcl_Size
	var _ /* objPtr at bp+240 */ uintptr
	var _ /* objPtr at bp+264 */ uintptr
	var _ /* objPtrAttr at bp+248 */ uintptr
	var _ /* objStrings at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, attributeStrings, attributeStringsAllocated, filePtr, i, index, index1, listPtr, nbAtts, objPtr1, res, result, v1, v10, v11, v13, v14, v15, v2, v3, v4, v6, v8, v9
	attributeStringsAllocated = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = int64(-libc.Int32FromInt32(1))
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+34103)
		return int32(TCL_ERROR)
	}
	filePtr = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	if XTcl_FSConvertToPathType(tls, interp, filePtr) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(filePtr)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(filePtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, filePtr, libc.UintptrFromInt32(0))
	}
	if XTcl_UtfToExternalDStringEx(tls, interp, libc.UintptrFromInt32(0), v1, int64(-libc.Int32FromInt32(1)), 0, bp+16, libc.UintptrFromInt32(0)) != TCL_OK {
		XTcl_DStringFree(tls, bp+16)
		return int32(TCL_ERROR)
	}
	XTcl_DStringFree(tls, bp+16)
	objc -= int32(2)
	objv += uintptr(2) * 8
	result = int32(TCL_ERROR)
	XTcl_SetErrno(tls, 0)
	/*
	 * Get the set of attribute names from the filesystem.
	 */
	attributeStrings = XTcl_FSFileAttrStrings(tls, filePtr, bp)
	if attributeStrings == libc.UintptrFromInt32(0) {
		if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
			if XTcl_GetErrno(tls) != 0 {
				/*
				 * There was an error, probably that the filePtr is not
				 * accepted by any filesystem
				 */
				if (*TTcl_Obj)(unsafe.Pointer(filePtr)).Fbytes != 0 {
					v2 = (*TTcl_Obj)(unsafe.Pointer(filePtr)).Fbytes
				} else {
					v2 = XTcl_GetStringFromObj(tls, filePtr, libc.UintptrFromInt32(0))
				}
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+15598, libc.VaList(bp+288, v2, XTcl_PosixError(tls, interp))))
			}
			return int32(TCL_ERROR)
		}
		/*
		 * We own the object now.
		 */
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FrefCount++
		/*
		 * Use objStrings as a list object.
		 */
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr2 != 0 {
				v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr2)).FspanLength
			} else {
				v4 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v4
			v3 = libc.Int32FromInt32(TCL_OK)
		} else {
			v3 = XTcl_ListObjLength(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), bp+8)
		}
		if v3 != TCL_OK {
			goto end
		}
		attributeStringsAllocated = XTclStackAlloc(tls, interp, libc.Uint64FromInt64(libc.Int64FromInt32(1)+*(*TTcl_Size)(unsafe.Pointer(bp + 8)))*uint64(8))
		index = 0
		for {
			if !(index < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) {
				break
			}
			XTcl_ListObjIndex(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), index, bp+240)
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 240)))).Fbytes != 0 {
				v6 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 240)))).Fbytes
			} else {
				v6 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 240)), libc.UintptrFromInt32(0))
			}
			*(*uintptr)(unsafe.Pointer(attributeStringsAllocated + uintptr(index)*8)) = v6
			goto _5
		_5:
			;
			index++
		}
		*(*uintptr)(unsafe.Pointer(attributeStringsAllocated + uintptr(index)*8)) = libc.UintptrFromInt32(0)
		attributeStrings = attributeStringsAllocated
	} else {
		if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
			XTcl_Panic(tls, __ccgo_ts+34128, 0)
		}
	}
	/*
	 * Process the attributes to produce a list of all of them, the value of a
	 * particular attribute, or to set one or more attributes (depending on
	 * the number of arguments).
	 */
	if objc == 0 {
		res = TCL_OK
		nbAtts = 0
		listPtr = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
		index1 = 0
		for {
			if !(*(*uintptr)(unsafe.Pointer(attributeStrings + uintptr(index1)*8)) != libc.UintptrFromInt32(0)) {
				break
			}
			if res != TCL_OK {
				/*
				 * Clear the error from the last iteration.
				 */
				XTcl_ResetResult(tls, interp)
			}
			res = XTcl_FSFileAttrsGet(tls, interp, index1, filePtr, bp+248)
			if res == TCL_OK {
				objPtr1 = XTcl_NewStringObj(tls, *(*uintptr)(unsafe.Pointer(attributeStrings + uintptr(index1)*8)), int64(-int32(1)))
				XTcl_ListObjAppendElement(tls, interp, listPtr, objPtr1)
				XTcl_ListObjAppendElement(tls, interp, listPtr, *(*uintptr)(unsafe.Pointer(bp + 248)))
				nbAtts++
			}
			goto _7
		_7:
			;
			index1++
		}
		if index1 > 0 && nbAtts == 0 {
			/*
			 * Error: no valid attributes found.
			 */
			_objPtr = listPtr
			v9 = _objPtr
			v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
			*(*TTcl_Size)(unsafe.Pointer(v9))--
			if v8 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			goto end
		}
		XTcl_SetObjResult(tls, interp, listPtr)
	} else {
		if objc == int32(1) {
			*(*uintptr)(unsafe.Pointer(bp + 264)) = libc.UintptrFromInt32(0)
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == 0 {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes != 0 {
					v10 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes
				} else {
					v10 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv)), libc.UintptrFromInt32(0))
				}
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+34185, libc.VaList(bp+288, v10)))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+288, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+34250, __ccgo_ts+8881, libc.UintptrFromInt32(0)))
				goto end
			}
			if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv)), attributeStrings, libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(TCL_INDEX_TEMP_TABLE)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+256) != TCL_OK {
				goto end
			}
			if XTcl_FSFileAttrsGet(tls, interp, *(*int32)(unsafe.Pointer(bp + 256)), filePtr, bp+264) != TCL_OK {
				goto end
			}
			XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 264)))
		} else {
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == 0 {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes != 0 {
					v11 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes
				} else {
					v11 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv)), libc.UintptrFromInt32(0))
				}
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+34185, libc.VaList(bp+288, v11)))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+288, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+34250, __ccgo_ts+8881, libc.UintptrFromInt32(0)))
				goto end
			}
			i = 0
			for {
				if !(i < objc) {
					break
				}
				if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), attributeStrings, libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(TCL_INDEX_TEMP_TABLE)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+272) != TCL_OK {
					goto end
				}
				if i+int32(1) == objc {
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
						v13 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
					} else {
						v13 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
					}
					XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+34256, libc.VaList(bp+288, v13)))
					XTcl_SetErrorCode(tls, interp, libc.VaList(bp+288, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+34250, __ccgo_ts+34279, libc.UintptrFromInt32(0)))
					goto end
				}
				if XTcl_FSFileAttrsSet(tls, interp, *(*int32)(unsafe.Pointer(bp + 272)), filePtr, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8))) != TCL_OK {
					goto end
				}
				goto _12
			_12:
				;
				i += int32(2)
			}
		}
	}
	result = TCL_OK
	/*
	 * Free up the array we allocated and drop our reference to any list of
	 * attribute names issued by the filesystem.
	 */
	goto end
end:
	;
	if attributeStringsAllocated != libc.UintptrFromInt32(0) {
		XTclStackFree(tls, interp, attributeStringsAllocated)
	}
	if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
		_objPtr1 = *(*uintptr)(unsafe.Pointer(bp))
		v15 = _objPtr1
		v14 = *(*TTcl_Size)(unsafe.Pointer(v15))
		*(*TTcl_Size)(unsafe.Pointer(v15))--
		if v14 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * TclFileLinkCmd --
 *
 *	This function is invoked to process the "file link" Tcl command. See
 *	the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	May create a new link.
 *
 *----------------------------------------------------------------------
 */

func XTclFileLinkCmd(tls *libc.TLS, dummy1200 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(272)
	defer tls.Free(272)
	var _objPtr, _objPtr1, contents, dirPtr, v1, v10, v11, v13, v2, v4, v5, v6, v7, v8, v9 uintptr
	var access, index int32
	var v12, v3 TTcl_Size
	var _ /* ds at bp+0 */ TTcl_DString
	var _ /* linkAction at bp+224 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, access, contents, dirPtr, index, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9
	if objc < int32(2) || objc > int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+34287)
		return int32(TCL_ERROR)
	}
	/*
	 * Index of the 'source' argument.
	 */
	if objc == int32(4) {
		index = int32(2)
	} else {
		index = int32(1)
	}
	if objc > int32(2) {
		if objc == int32(4) {
			if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), uintptr(unsafe.Pointer(&_linkTypes)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+224) != TCL_OK {
				return int32(TCL_ERROR)
			}
			if *(*int32)(unsafe.Pointer(bp + 224)) == 0 {
				*(*int32)(unsafe.Pointer(bp + 224)) = int32(TCL_CREATE_SYMBOLIC_LINK)
			} else {
				*(*int32)(unsafe.Pointer(bp + 224)) = int32(TCL_CREATE_HARD_LINK)
			}
		} else {
			*(*int32)(unsafe.Pointer(bp + 224)) = libc.Int32FromInt32(TCL_CREATE_SYMBOLIC_LINK) | libc.Int32FromInt32(TCL_CREATE_HARD_LINK)
		}
		if XTcl_FSConvertToPathType(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(index)*8))) != TCL_OK {
			return int32(TCL_ERROR)
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(index)*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(index)*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(index)*8)), libc.UintptrFromInt32(0))
		}
		if XTcl_UtfToExternalDStringEx(tls, interp, libc.UintptrFromInt32(0), v1, int64(-libc.Int32FromInt32(1)), 0, bp, libc.UintptrFromInt32(0)) != TCL_OK {
			XTcl_DStringFree(tls, bp)
			return int32(TCL_ERROR)
		}
		XTcl_DStringFree(tls, bp)
		/*
		 * Create link from source to target.
		 */
		contents = XTcl_FSLink(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(index)*8)), *(*uintptr)(unsafe.Pointer(objv + uintptr(index+int32(1))*8)), *(*int32)(unsafe.Pointer(bp + 224)))
		if contents == libc.UintptrFromInt32(0) {
			/*
			 * We handle three common error cases specially, and for all other
			 * errors, we use the standard Posix error message.
			 */
			if *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(EEXIST) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(index)*8)))).Fbytes != 0 {
					v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(index)*8)))).Fbytes
				} else {
					v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(index)*8)), libc.UintptrFromInt32(0))
				}
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+34333, libc.VaList(bp+240, v2)))
				XTcl_PosixError(tls, interp)
			} else {
				if *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(ENOENT) {
					dirPtr = XTclPathPart(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(index)*8)), int32(TCL_PATH_DIRNAME))
					if dirPtr == libc.UintptrFromInt32(0) {
						return int32(TCL_ERROR)
					}
					access = XTcl_FSAccess(tls, dirPtr, F_OK)
					_objPtr = dirPtr
					v4 = _objPtr
					v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
					*(*TTcl_Size)(unsafe.Pointer(v4))--
					if v3 <= int64(1) {
						XTclFreeObj(tls, _objPtr)
					}
					if access != 0 {
						if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(index)*8)))).Fbytes != 0 {
							v5 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(index)*8)))).Fbytes
						} else {
							v5 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(index)*8)), libc.UintptrFromInt32(0))
						}
						XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+34390, libc.VaList(bp+240, v5)))
						XTcl_PosixError(tls, interp)
					} else {
						if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(index)*8)))).Fbytes != 0 {
							v6 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(index)*8)))).Fbytes
						} else {
							v6 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(index)*8)), libc.UintptrFromInt32(0))
						}
						if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(index+int32(1))*8)))).Fbytes != 0 {
							v7 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(index+int32(1))*8)))).Fbytes
						} else {
							v7 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(index+int32(1))*8)), libc.UintptrFromInt32(0))
						}
						XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+34448, libc.VaList(bp+240, v6, v7)))
						*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = int32(ENOENT)
						XTcl_PosixError(tls, interp)
					}
				} else {
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(index)*8)))).Fbytes != 0 {
						v8 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(index)*8)))).Fbytes
					} else {
						v8 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(index)*8)), libc.UintptrFromInt32(0))
					}
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(index+int32(1))*8)))).Fbytes != 0 {
						v9 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(index+int32(1))*8)))).Fbytes
					} else {
						v9 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(index+int32(1))*8)), libc.UintptrFromInt32(0))
					}
					XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+34506, libc.VaList(bp+240, v8, v9, XTcl_PosixError(tls, interp))))
				}
			}
			return int32(TCL_ERROR)
		}
	} else {
		if XTcl_FSConvertToPathType(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(index)*8))) != TCL_OK {
			return int32(TCL_ERROR)
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(index)*8)))).Fbytes != 0 {
			v10 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(index)*8)))).Fbytes
		} else {
			v10 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(index)*8)), libc.UintptrFromInt32(0))
		}
		if XTcl_UtfToExternalDStringEx(tls, interp, libc.UintptrFromInt32(0), v10, int64(-libc.Int32FromInt32(1)), 0, bp, libc.UintptrFromInt32(0)) != TCL_OK {
			XTcl_DStringFree(tls, bp)
			return int32(TCL_ERROR)
		}
		XTcl_DStringFree(tls, bp)
		/*
		 * Read link
		 */
		contents = XTcl_FSLink(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(index)*8)), libc.UintptrFromInt32(0), 0)
		if contents == libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(index)*8)))).Fbytes != 0 {
				v11 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(index)*8)))).Fbytes
			} else {
				v11 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(index)*8)), libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+34558, libc.VaList(bp+240, v11, XTcl_PosixError(tls, interp))))
			return int32(TCL_ERROR)
		}
	}
	XTcl_SetObjResult(tls, interp, contents)
	if objc == int32(2) {
		/*
		 * If we are reading a link, we need to free this result refCount. If
		 * we are creating a link, this will just be objv[index+1], and so we
		 * don't own it.
		 */
		_objPtr1 = contents
		v13 = _objPtr1
		v12 = *(*TTcl_Size)(unsafe.Pointer(v13))
		*(*TTcl_Size)(unsafe.Pointer(v13))--
		if v12 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
	return TCL_OK
}

/*
 * We have a '-linktype' argument.
 */

var _linkTypes = [3]uintptr{
	0: __ccgo_ts + 34317,
	1: __ccgo_ts + 34327,
	2: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * TclFileReadLinkCmd --
 *
 *	This function is invoked to process the "file readlink" Tcl command.
 *	See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclFileReadLinkCmd(tls *libc.TLS, dummy1364 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(256)
	defer tls.Free(256)
	var _objPtr, contents, v1, v2, v4 uintptr
	var v3 TTcl_Size
	var _ /* ds at bp+0 */ TTcl_DString
	_, _, _, _, _, _ = _objPtr, contents, v1, v2, v3, v4
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+3726)
		return int32(TCL_ERROR)
	}
	if XTcl_FSConvertToPathType(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8))) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	if XTcl_UtfToExternalDStringEx(tls, interp, libc.UintptrFromInt32(0), v1, int64(-libc.Int32FromInt32(1)), 0, bp, libc.UintptrFromInt32(0)) != TCL_OK {
		XTcl_DStringFree(tls, bp)
		return int32(TCL_ERROR)
	}
	XTcl_DStringFree(tls, bp)
	contents = XTcl_FSLink(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), 0)
	if contents == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+34558, libc.VaList(bp+232, v2, XTcl_PosixError(tls, interp))))
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, contents)
	_objPtr = contents
	v4 = _objPtr
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	if v3 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return TCL_OK
}

/*
 *---------------------------------------------------------------------------
 *
 * TclFileTemporaryCmd --
 *
 *	This function implements the "tempfile" subcommand of the "file"
 *	command.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	Creates a temporary file. Opens a channel to that file and puts the
 *	name of that channel in the result. *Might* register suitable exit
 *	handlers to ensure that the temporary file gets deleted. Might write
 *	to a variable, so reentrancy is a potential issue.
 *
 *---------------------------------------------------------------------------
 */

func XTclFileTemporaryCmd(tls *libc.TLS, dummy1422 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cachePtr8, cachePtr9, nameObj, nameVarObj, string1, tailObj, tempBaseObj, tempDirObj, tempExtObj, templateObj, v12, v14, v17, v19, v2, v22, v25, v28, v31, v34, v4, v7, v9 uintptr
	var chan1 TTcl_Channel
	var v1, v10, v13, v15, v18, v20, v23, v26, v29, v32, v35, v5, v8 bool
	var v11, v16, v21, v24, v27, v3, v30, v33, v6 TTcl_Size
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cachePtr8, cachePtr9, chan1, nameObj, nameVarObj, string1, tailObj, tempBaseObj, tempDirObj, tempExtObj, templateObj, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v4, v5, v6, v7, v8, v9
	nameVarObj = libc.UintptrFromInt32(0) /* Variable to store the name of the temporary
	 * file in. */
	nameObj = libc.UintptrFromInt32(0) /* The channel opened (RDWR) on the temporary
	 * file, or NULL if there's an error. */
	tempDirObj = libc.UintptrFromInt32(0)
	tempBaseObj = libc.UintptrFromInt32(0)
	tempExtObj = libc.UintptrFromInt32(0)
	/* Pieces of template. Each piece is NULL if
	 * it is omitted. The platform temporary file
	 * engine might ignore some pieces. */
	if objc < int32(1) || objc > int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+34587)
		return int32(TCL_ERROR)
	}
	if objc > int32(1) {
		nameVarObj = *(*uintptr)(unsafe.Pointer(objv + 1*8))
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			nameObj = XTclThreadAllocObj(tls)
		} else {
			nameObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(nameObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(nameObj)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(nameObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(nameObj)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(nameObj)).FtypePtr = libc.UintptrFromInt32(0)
	}
	if objc > int32(2) {
		templateObj = *(*uintptr)(unsafe.Pointer(objv + 2*8))
		if (*TTcl_Obj)(unsafe.Pointer(templateObj)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(templateObj)).Flength
			v2 = (*TTcl_Obj)(unsafe.Pointer(templateObj)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, templateObj, bp)
		}
		string1 = v2
		/*
		 * Treat an empty string as if it wasn't there.
		 */
		if *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
			goto makeTemporary
		}
		/*
		 * The template only gives a directory if there is a directory
		 * separator in it.
		 */
		if libc.Xstrchr(tls, string1, int32('/')) != libc.UintptrFromInt32(0) || XtclPlatform == int32(TCL_PLATFORM_WINDOWS) && libc.Xstrchr(tls, string1, int32('\\')) != libc.UintptrFromInt32(0) {
			tempDirObj = XTclPathPart(tls, interp, templateObj, int32(TCL_PATH_DIRNAME))
			/*
			 * Only allow creation of temporary files in the native filesystem
			 * since they are frequently used for integration with external
			 * tools or system libraries. [Bug 2388866]
			 */
			if tempDirObj != libc.UintptrFromInt32(0) && XTcl_FSGetFileSystemForPath(tls, tempDirObj) != uintptr(unsafe.Pointer(&XtclNativeFilesystem)) {
				v4 = tempDirObj
				v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
				*(*TTcl_Size)(unsafe.Pointer(v4))--
				if !(v3 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(tempDirObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tempDirObj)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(tempDirObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(tempDirObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(tempDirObj)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(tempDirObj)).Flength = int64(-libc.Int32FromInt32(1))
						if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
							cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v5 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, tempDirObj)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(tempDirObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = tempDirObj
							(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, tempDirObj)
					}
				}
				tempDirObj = libc.UintptrFromInt32(0)
			}
		}
		/*
		 * The template only gives the filename if the last character isn't a
		 * directory separator.
		 */
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp))-int64(1))))) != int32('/') && (XtclPlatform != int32(TCL_PLATFORM_WINDOWS) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp))-int64(1))))) != int32('\\')) {
			tailObj = XTclPathPart(tls, interp, templateObj, int32(TCL_PATH_TAIL))
			if tailObj != libc.UintptrFromInt32(0) {
				tempBaseObj = XTclPathPart(tls, interp, tailObj, int32(TCL_PATH_ROOT))
				tempExtObj = XTclPathPart(tls, interp, tailObj, int32(TCL_PATH_EXTENSION))
				v7 = tailObj
				v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
				*(*TTcl_Size)(unsafe.Pointer(v7))--
				if !(v6 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(tailObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tailObj)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(tailObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(tailObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(tailObj)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(tailObj)).Flength = int64(-libc.Int32FromInt32(1))
						if v8 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v8 {
							cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v8 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, tailObj)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(tailObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = tailObj
							(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, tailObj)
					}
				}
			}
		}
	}
	/*
	 * Convert empty parts of the template into unspecified parts.
	 */
	if v10 = tempDirObj != 0; v10 {
		if (*TTcl_Obj)(unsafe.Pointer(tempDirObj)).Fbytes != 0 {
			v9 = (*TTcl_Obj)(unsafe.Pointer(tempDirObj)).Fbytes
		} else {
			v9 = XTcl_GetStringFromObj(tls, tempDirObj, libc.UintptrFromInt32(0))
		}
	}
	if v10 && !(*(*uint8)(unsafe.Pointer(v9)) != 0) {
		v12 = tempDirObj
		v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
		*(*TTcl_Size)(unsafe.Pointer(v12))--
		if !(v11 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(tempDirObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tempDirObj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(tempDirObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(tempDirObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(tempDirObj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(tempDirObj)).Flength = int64(-libc.Int32FromInt32(1))
				if v13 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v13 {
					cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v13 || ((*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, tempDirObj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(tempDirObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = tempDirObj
					(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, tempDirObj)
			}
		}
		tempDirObj = libc.UintptrFromInt32(0)
	}
	if v15 = tempBaseObj != 0; v15 {
		if (*TTcl_Obj)(unsafe.Pointer(tempBaseObj)).Fbytes != 0 {
			v14 = (*TTcl_Obj)(unsafe.Pointer(tempBaseObj)).Fbytes
		} else {
			v14 = XTcl_GetStringFromObj(tls, tempBaseObj, libc.UintptrFromInt32(0))
		}
	}
	if v15 && !(*(*uint8)(unsafe.Pointer(v14)) != 0) {
		v17 = tempBaseObj
		v16 = *(*TTcl_Size)(unsafe.Pointer(v17))
		*(*TTcl_Size)(unsafe.Pointer(v17))--
		if !(v16 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(tempBaseObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tempBaseObj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(tempBaseObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(tempBaseObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(tempBaseObj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(tempBaseObj)).Flength = int64(-libc.Int32FromInt32(1))
				if v18 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v18 {
					cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v18 || ((*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, tempBaseObj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(tempBaseObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = tempBaseObj
					(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, tempBaseObj)
			}
		}
		tempBaseObj = libc.UintptrFromInt32(0)
	}
	if v20 = tempExtObj != 0; v20 {
		if (*TTcl_Obj)(unsafe.Pointer(tempExtObj)).Fbytes != 0 {
			v19 = (*TTcl_Obj)(unsafe.Pointer(tempExtObj)).Fbytes
		} else {
			v19 = XTcl_GetStringFromObj(tls, tempExtObj, libc.UintptrFromInt32(0))
		}
	}
	if v20 && !(*(*uint8)(unsafe.Pointer(v19)) != 0) {
		v22 = tempExtObj
		v21 = *(*TTcl_Size)(unsafe.Pointer(v22))
		*(*TTcl_Size)(unsafe.Pointer(v22))--
		if !(v21 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(tempExtObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tempExtObj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(tempExtObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(tempExtObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(tempExtObj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(tempExtObj)).Flength = int64(-libc.Int32FromInt32(1))
				if v23 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v23 {
					cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v23 || ((*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, tempExtObj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(tempExtObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = tempExtObj
					(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, tempExtObj)
			}
		}
		tempExtObj = libc.UintptrFromInt32(0)
	}
	/*
	 * Create and open the temporary file.
	 */
	goto makeTemporary
makeTemporary:
	;
	chan1 = XTclpOpenTemporaryFile(tls, tempDirObj, tempBaseObj, tempExtObj, nameObj)
	/*
	 * If we created pieces of template, get rid of them now.
	 */
	if tempDirObj != 0 {
		v25 = tempDirObj
		v24 = *(*TTcl_Size)(unsafe.Pointer(v25))
		*(*TTcl_Size)(unsafe.Pointer(v25))--
		if !(v24 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(tempDirObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tempDirObj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(tempDirObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(tempDirObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(tempDirObj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(tempDirObj)).Flength = int64(-libc.Int32FromInt32(1))
				if v26 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v26 {
					cachePtr6 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v26 || ((*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, tempDirObj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(tempDirObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr = tempDirObj
					(*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, tempDirObj)
			}
		}
	}
	if tempBaseObj != 0 {
		v28 = tempBaseObj
		v27 = *(*TTcl_Size)(unsafe.Pointer(v28))
		*(*TTcl_Size)(unsafe.Pointer(v28))--
		if !(v27 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(tempBaseObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tempBaseObj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(tempBaseObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(tempBaseObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(tempBaseObj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(tempBaseObj)).Flength = int64(-libc.Int32FromInt32(1))
				if v29 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v29 {
					cachePtr7 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v29 || ((*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, tempBaseObj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(tempBaseObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr = tempBaseObj
					(*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, tempBaseObj)
			}
		}
	}
	if tempExtObj != 0 {
		v31 = tempExtObj
		v30 = *(*TTcl_Size)(unsafe.Pointer(v31))
		*(*TTcl_Size)(unsafe.Pointer(v31))--
		if !(v30 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(tempExtObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tempExtObj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(tempExtObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(tempExtObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(tempExtObj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(tempExtObj)).Flength = int64(-libc.Int32FromInt32(1))
				if v32 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v32 {
					cachePtr8 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v32 || ((*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, tempExtObj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(tempExtObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr8)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr8)).FfirstObjPtr = tempExtObj
					(*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, tempExtObj)
			}
		}
	}
	/*
	 * Deal with results.
	 */
	if chan1 == libc.UintptrFromInt32(0) {
		if nameVarObj != 0 {
			v34 = nameObj
			v33 = *(*TTcl_Size)(unsafe.Pointer(v34))
			*(*TTcl_Size)(unsafe.Pointer(v34))--
			if !(v33 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(nameObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(nameObj)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(nameObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(nameObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(nameObj)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(nameObj)).Flength = int64(-libc.Int32FromInt32(1))
					if v35 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v35 {
						cachePtr9 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v35 || ((*TAllocCache)(unsafe.Pointer(cachePtr9)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr9)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, nameObj)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(nameObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr9)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr9)).FfirstObjPtr = nameObj
						(*TAllocCache)(unsafe.Pointer(cachePtr9)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, nameObj)
				}
			}
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+34608, libc.VaList(bp+16, XTcl_PosixError(tls, interp))))
		return int32(TCL_ERROR)
	}
	XTcl_RegisterChannel(tls, interp, chan1)
	if nameVarObj != libc.UintptrFromInt32(0) {
		if XTcl_ObjSetVar2(tls, interp, nameVarObj, libc.UintptrFromInt32(0), nameObj, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
			XTcl_UnregisterChannel(tls, interp, chan1)
			return int32(TCL_ERROR)
		}
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, XTcl_GetChannelName(tls, chan1), int64(-int32(1))))
	return TCL_OK
}

/*
 *---------------------------------------------------------------------------
 *
 * TclFileTempDirCmd --
 *
 *	This function implements the "tempdir" subcommand of the "file"
 *	command.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	Creates a temporary directory.
 *
 *---------------------------------------------------------------------------
 */

func XTclFileTempDirCmd(tls *libc.TLS, dummy1581 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var baseDirObj, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, dirNameObj, nameBaseObj, string1, templateObj, v1, v10, v13, v16, v19, v3, v5, v8 uintptr
	var onWindows int32
	var v11, v14, v17, v20, v4, v6, v9 bool
	var v12, v15, v18, v2, v7 TTcl_Size
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = baseDirObj, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, dirNameObj, nameBaseObj, onWindows, string1, templateObj, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v3, v4, v5, v6, v7, v8, v9 /* Object that will contain the directory
	 * name. */
	baseDirObj = libc.UintptrFromInt32(0)
	nameBaseObj = libc.UintptrFromInt32(0)
	/* Pieces of template. Each piece is NULL if
	 * it is omitted. The platform temporary file
	 * engine might ignore some pieces. */
	if objc < int32(1) || objc > int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+34640)
		return int32(TCL_ERROR)
	}
	if objc > int32(1) {
		templateObj = *(*uintptr)(unsafe.Pointer(objv + 1*8))
		if (*TTcl_Obj)(unsafe.Pointer(templateObj)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(templateObj)).Flength
			v1 = (*TTcl_Obj)(unsafe.Pointer(templateObj)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, templateObj, bp)
		}
		string1 = v1
		onWindows = libc.BoolInt32(XtclPlatform == int32(TCL_PLATFORM_WINDOWS))
		/*
		 * Treat an empty string as if it wasn't there.
		 */
		if *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
			goto makeTemporary
		}
		/*
		 * The template only gives a directory if there is a directory
		 * separator in it, and only gives a base name if there's at least one
		 * character after the last directory separator.
		 */
		if libc.Xstrchr(tls, string1, int32('/')) == libc.UintptrFromInt32(0) && (!(onWindows != 0) || libc.Xstrchr(tls, string1, int32('\\')) == libc.UintptrFromInt32(0)) {
			/*
			 * No directory separator, so just assume we have a file name.
			 * This is a bit wrong on Windows where we could have problems
			 * with disk name prefixes... but those are much less common in
			 * naked form so we just pass through and let the OS figure it out
			 * instead.
			 */
			nameBaseObj = templateObj
			(*TTcl_Obj)(unsafe.Pointer(nameBaseObj)).FrefCount++
		} else {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp))-int64(1))))) != int32('/') && (!(onWindows != 0) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp))-int64(1))))) != int32('\\')) {
				/*
				 * If the template has a non-terminal directory separator, split
				 * into dirname and tail.
				 */
				baseDirObj = XTclPathPart(tls, interp, templateObj, int32(TCL_PATH_DIRNAME))
				nameBaseObj = XTclPathPart(tls, interp, templateObj, int32(TCL_PATH_TAIL))
			} else {
				/*
				 * Otherwise, there must be a terminal directory separator, so
				 * just the directory is given.
				 */
				baseDirObj = templateObj
				(*TTcl_Obj)(unsafe.Pointer(baseDirObj)).FrefCount++
			}
		}
		/*
		 * Only allow creation of temporary directories in the native
		 * filesystem since they are frequently used for integration with
		 * external tools or system libraries.
		 */
		if baseDirObj != libc.UintptrFromInt32(0) && XTcl_FSGetFileSystemForPath(tls, baseDirObj) != uintptr(unsafe.Pointer(&XtclNativeFilesystem)) {
			v3 = baseDirObj
			v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
			*(*TTcl_Size)(unsafe.Pointer(v3))--
			if !(v2 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(baseDirObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(baseDirObj)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(baseDirObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(baseDirObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(baseDirObj)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(baseDirObj)).Flength = int64(-libc.Int32FromInt32(1))
					if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
						cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v4 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, baseDirObj)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(baseDirObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = baseDirObj
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, baseDirObj)
				}
			}
			baseDirObj = libc.UintptrFromInt32(0)
		}
	}
	/*
	 * Convert empty parts of the template into unspecified parts.
	 */
	if v6 = baseDirObj != 0; v6 {
		if (*TTcl_Obj)(unsafe.Pointer(baseDirObj)).Fbytes != 0 {
			v5 = (*TTcl_Obj)(unsafe.Pointer(baseDirObj)).Fbytes
		} else {
			v5 = XTcl_GetStringFromObj(tls, baseDirObj, libc.UintptrFromInt32(0))
		}
	}
	if v6 && !(*(*uint8)(unsafe.Pointer(v5)) != 0) {
		v8 = baseDirObj
		v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
		*(*TTcl_Size)(unsafe.Pointer(v8))--
		if !(v7 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(baseDirObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(baseDirObj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(baseDirObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(baseDirObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(baseDirObj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(baseDirObj)).Flength = int64(-libc.Int32FromInt32(1))
				if v9 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v9 {
					cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v9 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, baseDirObj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(baseDirObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = baseDirObj
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, baseDirObj)
			}
		}
		baseDirObj = libc.UintptrFromInt32(0)
	}
	if v11 = nameBaseObj != 0; v11 {
		if (*TTcl_Obj)(unsafe.Pointer(nameBaseObj)).Fbytes != 0 {
			v10 = (*TTcl_Obj)(unsafe.Pointer(nameBaseObj)).Fbytes
		} else {
			v10 = XTcl_GetStringFromObj(tls, nameBaseObj, libc.UintptrFromInt32(0))
		}
	}
	if v11 && !(*(*uint8)(unsafe.Pointer(v10)) != 0) {
		v13 = nameBaseObj
		v12 = *(*TTcl_Size)(unsafe.Pointer(v13))
		*(*TTcl_Size)(unsafe.Pointer(v13))--
		if !(v12 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(nameBaseObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(nameBaseObj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(nameBaseObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(nameBaseObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(nameBaseObj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(nameBaseObj)).Flength = int64(-libc.Int32FromInt32(1))
				if v14 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v14 {
					cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v14 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, nameBaseObj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(nameBaseObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = nameBaseObj
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, nameBaseObj)
			}
		}
		nameBaseObj = libc.UintptrFromInt32(0)
	}
	/*
	 * Create and open the temporary file.
	 */
	goto makeTemporary
makeTemporary:
	;
	dirNameObj = XTclpCreateTemporaryDirectory(tls, baseDirObj, nameBaseObj)
	/*
	 * If we created pieces of template, get rid of them now.
	 */
	if baseDirObj != 0 {
		v16 = baseDirObj
		v15 = *(*TTcl_Size)(unsafe.Pointer(v16))
		*(*TTcl_Size)(unsafe.Pointer(v16))--
		if !(v15 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(baseDirObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(baseDirObj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(baseDirObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(baseDirObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(baseDirObj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(baseDirObj)).Flength = int64(-libc.Int32FromInt32(1))
				if v17 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v17 {
					cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v17 || ((*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, baseDirObj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(baseDirObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = baseDirObj
					(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, baseDirObj)
			}
		}
	}
	if nameBaseObj != 0 {
		v19 = nameBaseObj
		v18 = *(*TTcl_Size)(unsafe.Pointer(v19))
		*(*TTcl_Size)(unsafe.Pointer(v19))--
		if !(v18 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(nameBaseObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(nameBaseObj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(nameBaseObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(nameBaseObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(nameBaseObj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(nameBaseObj)).Flength = int64(-libc.Int32FromInt32(1))
				if v20 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v20 {
					cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v20 || ((*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, nameBaseObj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(nameBaseObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = nameBaseObj
					(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, nameBaseObj)
			}
		}
	}
	/*
	 * Deal with results.
	 */
	if dirNameObj == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+34651, libc.VaList(bp+16, XTcl_PosixError(tls, interp))))
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, dirNameObj)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclFileHomeCmd --
 *
 *	This function is invoked to process the "file home" Tcl command.
 *	See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclFileHomeCmd(tls *libc.TLS, dummy1726 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var homeDirObj, v1 uintptr
	_, _ = homeDirObj, v1
	if objc != int32(1) && objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+34688)
		return int32(TCL_ERROR)
	}
	if objc == int32(1) {
		v1 = libc.UintptrFromInt32(0)
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	homeDirObj = XTclGetHomeDirObj(tls, interp, v1)
	if homeDirObj == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, homeDirObj)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclFileTildeExpandCmd --
 *
 *	This function is invoked to process the "file tildeexpand" Tcl command.
 *	See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclFileTildeExpandCmd(tls *libc.TLS, dummy1764 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var expandedPathObj uintptr
	_ = expandedPathObj
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+34695)
		return int32(TCL_ERROR)
	}
	expandedPathObj = XTclResolveTildePath(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if expandedPathObj == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, expandedPathObj)
	return TCL_OK
}

const TCL_GLOBMODE_DIR = 4
const TCL_GLOBMODE_TAILS = 8

/* Flag values used by TclGlob() */

/*
 * When there is no support for getting the block size of a file in a stat()
 * call, use this as a guess. Allow it to be overridden in the platform-
 * specific files.
 */

/*
 *----------------------------------------------------------------------
 *
 * SetResultLength --
 *
 *	Resets the result DString for ExtractWinRoot to accommodate
 *	any NT extended path prefixes.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	May modify the Tcl_DString.
 *----------------------------------------------------------------------
 */

func _SetResultLength(tls *libc.TLS, resultPtr uintptr, offset int32, extended int32) {
	XTcl_DStringSetLength(tls, resultPtr, int64(offset))
	if extended == int32(2) {
		XTcl_DStringAppend(tls, resultPtr, __ccgo_ts+34700, libc.Int64FromUint64(libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1)))
	} else {
		if extended == int32(1) {
			XTcl_DStringAppend(tls, resultPtr, __ccgo_ts+34709, libc.Int64FromUint64(libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)))
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * ExtractWinRoot --
 *
 *	Matches the root portion of a Windows path and appends it to the
 *	specified Tcl_DString.
 *
 * Results:
 *	Returns the position in the path immediately after the root including
 *	any trailing slashes. Appends a cleaned up version of the root to the
 *	Tcl_DString at the specified offset.
 *
 * Side effects:
 *	Modifies the specified Tcl_DString.
 *
 *----------------------------------------------------------------------
 */

func _ExtractWinRoot(tls *libc.TLS, path uintptr, resultPtr uintptr, offset int32, typePtr uintptr) (r uintptr) {
	/* Where to store pathType result */
	var abs, extended, hlen, slen int32
	var host, share, tail, tail1 uintptr
	_, _, _, _, _, _, _, _ = abs, extended, hlen, host, share, slen, tail, tail1
	extended = 0
	if (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('/') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('\\')) && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 1))) == int32('/') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 1))) == int32('\\')) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 2))) == int32('?') && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 3))) == int32('/') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 3))) == int32('\\')) {
		extended = int32(1)
		path = path + uintptr(4)
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('U') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 1))) == int32('N') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 2))) == int32('C') && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 3))) == int32('/') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 3))) == int32('\\')) {
			extended = int32(2)
			path = path + uintptr(4)
		}
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('/') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('\\') {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 1))) != int32('/') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 1))) != int32('\\') {
			_SetResultLength(tls, resultPtr, offset, extended)
			*(*TTcl_PathType)(unsafe.Pointer(typePtr)) = int32(TCL_PATH_VOLUME_RELATIVE)
			XTcl_DStringAppend(tls, resultPtr, __ccgo_ts+6339, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))
			return path + 1
		}
		host = path + 2
		/*
		 * Skip separators.
		 */
		for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(host))) == int32('/') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(host))) == int32('\\') {
			host++
		}
		hlen = 0
		for {
			if !(*(*uint8)(unsafe.Pointer(host + uintptr(hlen))) != 0) {
				break
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(host + uintptr(hlen)))) == int32('/') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(host + uintptr(hlen)))) == int32('\\') {
				break
			}
			goto _1
		_1:
			;
			hlen++
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(host + uintptr(hlen)))) == 0 || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(host + uintptr(hlen+int32(1))))) == 0 {
			/*
			 * The path given is simply of the form '/foo', '//foo',
			 * '/////foo' or the same with backslashes. If there is exactly
			 * one leading '/' the path is volume relative (see filename man
			 * page). If there are more than one, we are simply assuming they
			 * are superfluous and we trim them away. (An alternative
			 * interpretation would be that it is a host name, but we have
			 * been documented that that is not the case).
			 */
			*(*TTcl_PathType)(unsafe.Pointer(typePtr)) = int32(TCL_PATH_VOLUME_RELATIVE)
			XTcl_DStringAppend(tls, resultPtr, __ccgo_ts+6339, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))
			return path + 2
		}
		_SetResultLength(tls, resultPtr, offset, extended)
		share = host + uintptr(hlen)
		/*
		 * Skip separators.
		 */
		for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(share))) == int32('/') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(share))) == int32('\\') {
			share++
		}
		slen = 0
		for {
			if !(*(*uint8)(unsafe.Pointer(share + uintptr(slen))) != 0) {
				break
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(share + uintptr(slen)))) == int32('/') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(share + uintptr(slen)))) == int32('\\') {
				break
			}
			goto _2
		_2:
			;
			slen++
		}
		XTcl_DStringAppend(tls, resultPtr, __ccgo_ts+34714, libc.Int64FromUint64(libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)))
		XTcl_DStringAppend(tls, resultPtr, host, int64(hlen))
		XTcl_DStringAppend(tls, resultPtr, __ccgo_ts+6339, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))
		XTcl_DStringAppend(tls, resultPtr, share, int64(slen))
		tail = share + uintptr(slen)
		/*
		 * Skip separators.
		 */
		for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(tail))) == int32('/') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(tail))) == int32('\\') {
			tail++
		}
		*(*TTcl_PathType)(unsafe.Pointer(typePtr)) = int32(TCL_PATH_ABSOLUTE)
		return tail
	} else {
		if *(*uint8)(unsafe.Pointer(path)) != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 1))) == int32(':') {
			/*
			 * Might be a drive separator.
			 */
			_SetResultLength(tls, resultPtr, offset, extended)
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 2))) != int32('/') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 2))) != int32('\\') {
				*(*TTcl_PathType)(unsafe.Pointer(typePtr)) = int32(TCL_PATH_VOLUME_RELATIVE)
				XTcl_DStringAppend(tls, resultPtr, path, int64(2))
				return path + 2
			} else {
				tail1 = path + 3
				/*
				 * Skip separators.
				 */
				for *(*uint8)(unsafe.Pointer(tail1)) != 0 && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(tail1))) == int32('/') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(tail1))) == int32('\\')) {
					tail1++
				}
				*(*TTcl_PathType)(unsafe.Pointer(typePtr)) = int32(TCL_PATH_ABSOLUTE)
				XTcl_DStringAppend(tls, resultPtr, path, int64(2))
				XTcl_DStringAppend(tls, resultPtr, __ccgo_ts+6339, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))
				return tail1
			}
		} else {
			abs = 0
			/*
			 * Check for Windows devices.
			 */
			if (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('c') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('C')) && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 1))) == int32('o') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 1))) == int32('O')) {
				if (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 2))) == int32('m') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 2))) == int32('M')) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 3))) >= int32('1') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 3))) <= int32('9') {
					/*
					 * May have match for 'com[1-9]:?', which is a serial port.
					 */
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 4))) == int32('\000') {
						abs = int32(4)
					} else {
						if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 4))) == int32(':') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 5))) == int32('\000') {
							abs = int32(5)
						}
					}
				} else {
					if (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 2))) == int32('n') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 2))) == int32('N')) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 3))) == int32('\000') {
						/*
						 * Have match for 'con'.
						 */
						abs = int32(3)
					}
				}
			} else {
				if (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('l') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('L')) && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 1))) == int32('p') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 1))) == int32('P')) && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 2))) == int32('t') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 2))) == int32('T')) {
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 3))) >= int32('1') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 3))) <= int32('9') {
						/*
						 * May have match for 'lpt[1-9]:?'
						 */
						if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 4))) == int32('\000') {
							abs = int32(4)
						} else {
							if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 4))) == int32(':') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 5))) == int32('\000') {
								abs = int32(5)
							}
						}
					}
				} else {
					if (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('p') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('P')) && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 1))) == int32('r') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 1))) == int32('R')) && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 2))) == int32('n') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 2))) == int32('N')) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 3))) == int32('\000') {
						/*
						 * Have match for 'prn'.
						 */
						abs = int32(3)
					} else {
						if (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('n') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('N')) && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 1))) == int32('u') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 1))) == int32('U')) && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 2))) == int32('l') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 2))) == int32('L')) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 3))) == int32('\000') {
							/*
							 * Have match for 'nul'.
							 */
							abs = int32(3)
						} else {
							if (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('a') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('A')) && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 1))) == int32('u') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 1))) == int32('U')) && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 2))) == int32('x') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 2))) == int32('X')) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 3))) == int32('\000') {
								/*
								 * Have match for 'aux'.
								 */
								abs = int32(3)
							}
						}
					}
				}
			}
			if abs != 0 {
				*(*TTcl_PathType)(unsafe.Pointer(typePtr)) = int32(TCL_PATH_ABSOLUTE)
				_SetResultLength(tls, resultPtr, offset, extended)
				XTcl_DStringAppend(tls, resultPtr, path, int64(abs))
				return path + uintptr(abs)
			}
		}
	}
	/*
	 * Anything else is treated as relative.
	 */
	*(*TTcl_PathType)(unsafe.Pointer(typePtr)) = int32(TCL_PATH_RELATIVE)
	return path
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetPathType --
 *
 *	Determines whether a given path is relative to the current directory,
 *	relative to the current volume, or absolute.
 *
 *	The objectified Tcl_FSGetPathType should be used in preference to this
 *	function (as you can see below, this is just a wrapper around that
 *	other function).
 *
 * Results:
 *	Returns one of TCL_PATH_ABSOLUTE, TCL_PATH_RELATIVE, or
 *	TCL_PATH_VOLUME_RELATIVE.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetPathType(tls *libc.TLS, path uintptr) (r TTcl_PathType) {
	var _objPtr, tempObj, v2 uintptr
	var type1 TTcl_PathType
	var v1 TTcl_Size
	_, _, _, _, _ = _objPtr, tempObj, type1, v1, v2
	tempObj = XTcl_NewStringObj(tls, path, int64(-int32(1)))
	(*TTcl_Obj)(unsafe.Pointer(tempObj)).FrefCount++
	type1 = XTcl_FSGetPathType(tls, tempObj)
	_objPtr = tempObj
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return type1
}

/*
 *----------------------------------------------------------------------
 *
 * TclpGetNativePathType --
 *
 *	Determines whether a given path is relative to the current directory,
 *	relative to the current volume, or absolute, but ONLY FOR THE NATIVE
 *	FILESYSTEM. This function is called from tclIOUtil.c (but needs to be
 *	here due to its dependence on static variables/functions in this
 *	file). The exported function Tcl_FSGetPathType should be used by
 *	extensions.
 *
 * Results:
 *	Returns one of TCL_PATH_ABSOLUTE, TCL_PATH_RELATIVE, or
 *	TCL_PATH_VOLUME_RELATIVE.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclpGetNativePathType(tls *libc.TLS, pathPtr uintptr, driveNameLengthPtr uintptr, driveNameRef uintptr) (r TTcl_PathType) {
	bp := tls.Alloc(240)
	defer tls.Free(240)
	var origPath, path, rootEnd, v1 uintptr
	var _ /* ds at bp+8 */ TTcl_DString
	var _ /* type at bp+0 */ TTcl_PathType
	_, _, _, _ = origPath, path, rootEnd, v1
	*(*TTcl_PathType)(unsafe.Pointer(bp)) = int32(TCL_PATH_ABSOLUTE)
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
	}
	path = v1
	switch XtclPlatform {
	case int32(TCL_PLATFORM_UNIX):
		origPath = path
		/*
		 * Paths that begin with / are absolute.
		 */
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('/') {
			path++
			/*
			 * Check for "//" network path prefix
			 */
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('/') && *(*uint8)(unsafe.Pointer(path + 1)) != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 1))) != int32('/') {
				path += uintptr(2)
				for *(*uint8)(unsafe.Pointer(path)) != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) != int32('/') {
					path++
				}
			}
			if driveNameLengthPtr != libc.UintptrFromInt32(0) {
				/*
				 * We need this addition in case the "//" code was used.
				 */
				*(*TTcl_Size)(unsafe.Pointer(driveNameLengthPtr)) = int64(path) - int64(origPath)
			}
		} else {
			*(*TTcl_PathType)(unsafe.Pointer(bp)) = int32(TCL_PATH_RELATIVE)
		}
	case int32(TCL_PLATFORM_WINDOWS):
		XTcl_DStringInit(tls, bp+8)
		rootEnd = _ExtractWinRoot(tls, path, bp+8, 0, bp)
		if rootEnd != path && driveNameLengthPtr != libc.UintptrFromInt32(0) {
			*(*TTcl_Size)(unsafe.Pointer(driveNameLengthPtr)) = int64(rootEnd) - int64(path)
			if driveNameRef != libc.UintptrFromInt32(0) {
				*(*uintptr)(unsafe.Pointer(driveNameRef)) = XTcl_DStringToObj(tls, bp+8)
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(driveNameRef)))).FrefCount++
			}
		}
		XTcl_DStringFree(tls, bp+8)
		break
	}
	return *(*TTcl_PathType)(unsafe.Pointer(bp))
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpNativeSplitPath --
 *
 *	This function takes the given Tcl_Obj, which should be a valid path,
 *	and returns a Tcl List object containing each segment of that path as
 *	an element.
 *
 *	Note this function currently calls the older Split(Plat)Path
 *	functions, which require more memory allocation than is desirable.
 *
 * Results:
 *	Returns list object with refCount of zero. If the passed in lenPtr is
 *	non-NULL, we use it to return the number of elements in the returned
 *	list.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTclpNativeSplitPath(tls *libc.TLS, pathPtr uintptr, lenPtr uintptr) (r uintptr) {
	/* int to store number of path elements. */
	var resultPtr, v1, v2 uintptr
	var v4 int64
	_, _, _, _ = resultPtr, v1, v2, v4
	resultPtr = libc.UintptrFromInt32(0) /* Needed only to prevent gcc warnings. */
	/*
	 * Perform platform specific splitting.
	 */
	switch XtclPlatform {
	case int32(TCL_PLATFORM_UNIX):
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
		}
		resultPtr = _SplitUnixPath(tls, v1)
	case int32(TCL_PLATFORM_WINDOWS):
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
		}
		resultPtr = _SplitWinPath(tls, v2)
		break
	}
	/*
	 * Compute the number of elements in the result.
	 */
	if lenPtr != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(resultPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(resultPtr + 32))).Fptr2 != 0 {
				v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(resultPtr + 32))).Fptr2)).FspanLength
			} else {
				v4 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(resultPtr + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(lenPtr)) = v4
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), resultPtr, lenPtr)
		}
	}
	return resultPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SplitPath --
 *
 *	Split a path into a list of path components. The first element of the
 *	list will have the same path type as the original path.
 *
 * Results:
 *	Returns a standard Tcl result. The interpreter result contains a list
 *	of path components. *argvPtr will be filled in with the address of an
 *	array whose elements point to the elements of path, in order.
 *	*argcPtr will get filled in with the number of valid elements in the
 *	array. A single block of memory is dynamically allocated to hold both
 *	the argv array and a copy of the path elements. The caller must
 *	eventually free this memory by calling Tcl_Free() on *argvPtr. Note:
 *	*argvPtr and *argcPtr are only modified if the procedure returns
 *	normally.
 *
 * Side effects:
 *	Allocates memory.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SplitPath(tls *libc.TLS, path uintptr, argcPtr uintptr, argvPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Pointer to place to store pointer to array
	 * of pointers to path elements. */
	var _objPtr, _objPtr1, p, resultPtr, str, tmpPtr, v10, v2, v6, v8 uintptr
	var i, size, v1, v9 TTcl_Size
	var _ /* eltPtr at bp+0 */ uintptr
	var _ /* len at bp+8 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, i, p, resultPtr, size, str, tmpPtr, v1, v10, v2, v6, v8, v9
	resultPtr = libc.UintptrFromInt32(0)
	/*
	 * Perform the splitting, using objectified, vfs-aware code.
	 */
	tmpPtr = XTcl_NewStringObj(tls, path, int64(-int32(1)))
	(*TTcl_Obj)(unsafe.Pointer(tmpPtr)).FrefCount++
	resultPtr = XTcl_FSSplitPath(tls, tmpPtr, argcPtr)
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount++
	_objPtr = tmpPtr
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	/*
	 * Calculate space required for the result.
	 */
	size = int64(1)
	i = 0
	for {
		if !(i < *(*TTcl_Size)(unsafe.Pointer(argcPtr))) {
			break
		}
		XTcl_ListObjIndex(tls, libc.UintptrFromInt32(0), resultPtr, i, bp)
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Flength
			_ = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes
		} else {
			XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+8)
		}
		size += *(*TTcl_Size)(unsafe.Pointer(bp + 8)) + int64(1)
		goto _3
	_3:
		;
		i++
	}
	/*
	 * Allocate a buffer large enough to hold the contents of all of the list
	 * plus the argv pointers and the terminating NULL pointer.
	 */
	*(*uintptr)(unsafe.Pointer(argvPtr)) = XTcl_Alloc(tls, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(argcPtr))+libc.Int64FromInt32(1))*libc.Uint64FromInt64(8)+libc.Uint64FromInt64(size))
	/*
	 * Position p after the last argv pointer and copy the contents of the
	 * list in, piece by piece.
	 */
	p = *(*uintptr)(unsafe.Pointer(argvPtr)) + uintptr(*(*TTcl_Size)(unsafe.Pointer(argcPtr))+int64(1))*8
	i = 0
	for {
		if !(i < *(*TTcl_Size)(unsafe.Pointer(argcPtr))) {
			break
		}
		XTcl_ListObjIndex(tls, libc.UintptrFromInt32(0), resultPtr, i, bp)
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Flength
			v6 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes
		} else {
			v6 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+8)
		}
		str = v6
		libc.Xmemcpy(tls, p, str, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8))+int64(1)))
		p += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)) + int64(1))
		goto _5
	_5:
		;
		i++
	}
	/*
	 * Now set up the argv pointers.
	 */
	p = *(*uintptr)(unsafe.Pointer(argvPtr)) + uintptr(*(*TTcl_Size)(unsafe.Pointer(argcPtr))+int64(1))*8
	i = 0
	for {
		if !(i < *(*TTcl_Size)(unsafe.Pointer(argcPtr))) {
			break
		}
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argvPtr)) + uintptr(i)*8)) = p
		for {
			v8 = p
			p++
			if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v8))) != int32('\000')) {
				break
			}
		}
		goto _7
	_7:
		;
		i++
	}
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argvPtr)) + uintptr(i)*8)) = libc.UintptrFromInt32(0)
	/*
	 * Free the result ptr given to us by Tcl_FSSplitPath
	 */
	_objPtr1 = resultPtr
	v10 = _objPtr1
	v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
	*(*TTcl_Size)(unsafe.Pointer(v10))--
	if v9 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * SplitUnixPath --
 *
 *	This routine is used by Tcl_(FS)SplitPath to handle splitting Unix
 *	paths.
 *
 * Results:
 *	Returns a newly allocated Tcl list object.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _SplitUnixPath(tls *libc.TLS, path uintptr) (r uintptr) {
	/* Pointer to string containing a path. */
	var cachePtr, elementStart, nextElt, origPath, result, rootElt, v3 uintptr
	var length Tsize_t
	var v1 bool
	_, _, _, _, _, _, _, _, _ = cachePtr, elementStart, length, nextElt, origPath, result, rootElt, v1, v3
	origPath = path
	/*
	 * Deal with the root directory as a special case.
	 */
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		result = XTclThreadAllocObj(tls)
	} else {
		result = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(result + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(result)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(result)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(result)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(result)).FtypePtr = libc.UintptrFromInt32(0)
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('/') {
		path++
		/*
		 * Check for "//" network path prefix
		 */
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('/') && *(*uint8)(unsafe.Pointer(path + 1)) != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 1))) != int32('/') {
			path += uintptr(2)
			for *(*uint8)(unsafe.Pointer(path)) != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) != int32('/') {
				path++
			}
		}
		rootElt = XTcl_NewStringObj(tls, origPath, int64(path)-int64(origPath))
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), result, rootElt)
		for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('/') {
			path++
		}
	}
	/*
	 * Split on slashes.
	 */
	for {
		elementStart = path
		for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) != int32('\000') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) != int32('/') {
			path++
		}
		length = libc.Uint64FromInt64(int64(path) - int64(elementStart))
		if length > uint64(0) {
			nextElt = XTcl_NewStringObj(tls, elementStart, libc.Int64FromUint64(length))
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), result, nextElt)
		}
		v3 = path
		path++
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) == int32('\000') {
			break
		}
		goto _2
	_2:
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * SplitWinPath --
 *
 *	This routine is used by Tcl_(FS)SplitPath to handle splitting Windows
 *	paths.
 *
 * Results:
 *	Returns a newly allocated Tcl list object.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _SplitWinPath(tls *libc.TLS, path uintptr) (r uintptr) {
	bp := tls.Alloc(240)
	defer tls.Free(240) /* Pointer to string containing a path. */
	var cachePtr, cachePtr1, elementStart, nextElt, p, result, v2 uintptr
	var length Tsize_t
	var v1, v4 bool
	var _ /* buf at bp+8 */ TTcl_DString
	var _ /* type at bp+0 */ TTcl_PathType
	_, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, elementStart, length, nextElt, p, result, v1, v2, v4
	*(*TTcl_PathType)(unsafe.Pointer(bp)) = int32(TCL_PATH_ABSOLUTE)
	XTcl_DStringInit(tls, bp+8)
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		result = XTclThreadAllocObj(tls)
	} else {
		result = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(result + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(result)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(result)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(result)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(result)).FtypePtr = libc.UintptrFromInt32(0)
	p = _ExtractWinRoot(tls, path, bp+8, 0, bp)
	/*
	 * Terminate the root portion, if we matched something.
	 */
	if p != path {
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), result, XTcl_DStringToObj(tls, bp+8))
	}
	XTcl_DStringFree(tls, bp+8)
	/*
	 * Split on slashes.
	 */
	for {
		elementStart = p
		for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('\000') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('/') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('\\') {
			p++
		}
		length = libc.Uint64FromInt64(int64(p) - int64(elementStart))
		if length > uint64(0) {
			if elementStart != path && libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(elementStart)))|uint32(32)-uint32('a') < uint32(26)) != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(elementStart + 1))) == int32(':') {
				if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
					cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
					nextElt = XTclThreadAllocObj(tls)
				} else {
					nextElt = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(nextElt + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(nextElt)).FrefCount = 0
				if libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1) == uint64(0) {
					(*TTcl_Obj)(unsafe.Pointer(nextElt)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(nextElt)).Flength = int64(libc.Int32FromInt32(0))
				} else {
					(*TTcl_Obj)(unsafe.Pointer(nextElt)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
					libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(nextElt)).Fbytes, __ccgo_ts+34717, libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1))
					*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(nextElt)).Fbytes + uintptr(libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)))) = uint8('\000')
					(*TTcl_Obj)(unsafe.Pointer(nextElt)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(3) - libc.Uint64FromInt32(1))
				}
				(*TTcl_Obj)(unsafe.Pointer(nextElt)).FtypePtr = libc.UintptrFromInt32(0)
				XTcl_AppendToObj(tls, nextElt, elementStart, libc.Int64FromUint64(length))
			} else {
				nextElt = XTcl_NewStringObj(tls, elementStart, libc.Int64FromUint64(length))
			}
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), result, nextElt)
		}
		goto _3
	_3:
		;
		v2 = p
		p++
		if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) != int32('\000')) {
			break
		}
	}
	return result
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_FSJoinToPath --
 *
 *	This function takes the given object, which should usually be a valid
 *	path or NULL, and joins onto it the array of paths segments given.
 *
 *	The objects in the array given will temporarily have their refCount
 *	increased by one, and then decreased by one when this function exits
 *	(which means if they had zero refCount when we were called, they will
 *	be freed).
 *
 * Results:
 *	Returns object owned by the caller (which should increment its
 *	refCount) - typically an object with refCount of zero.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_FSJoinToPath(tls *libc.TLS, _pathPtr uintptr, objc TTcl_Size, objv uintptr) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	*(*uintptr)(unsafe.Pointer(bp)) = _pathPtr /* Path elements to join. */
	var elemc TTcl_Size
	var elemv, ret uintptr
	var _ /* pair at bp+8 */ [2]uintptr
	_, _, _ = elemc, elemv, ret
	if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
		return XTclJoinPath(tls, objc, objv, 0)
	}
	if objc == 0 {
		return XTclJoinPath(tls, int64(1), bp, 0)
	}
	if objc == int64(1) {
		(*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[0] = *(*uintptr)(unsafe.Pointer(bp))
		(*(*[2]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] = *(*uintptr)(unsafe.Pointer(objv))
		return XTclJoinPath(tls, int64(2), bp+8, 0)
	} else {
		elemc = objc + int64(1)
		elemv = XTcl_Alloc(tls, libc.Uint64FromInt64(elemc)*uint64(8))
		*(*uintptr)(unsafe.Pointer(elemv)) = *(*uintptr)(unsafe.Pointer(bp))
		libc.Xmemcpy(tls, elemv+uintptr(1)*8, objv, libc.Uint64FromInt64(objc)*uint64(8))
		ret = XTclJoinPath(tls, elemc, elemv, 0)
		XTclpFree(tls, elemv)
		return ret
	}
	return r
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpNativeJoinPath --
 *
 *	'prefix' is absolute, 'joining' is relative to prefix.
 *
 * Results:
 *	modifies prefix
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTclpNativeJoinPath(tls *libc.TLS, prefix uintptr, joining uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var dest, p, start, v1, v11, v12, v13, v3, v5, v6, v7, v9 uintptr
	var needsSep int32
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _ = dest, needsSep, p, start, v1, v11, v12, v13, v3, v5, v6, v7, v9
	if (*TTcl_Obj)(unsafe.Pointer(prefix)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(prefix)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(prefix)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, prefix, bp)
	}
	start = v1
	/*
	 * Remove the ./ from drive-letter prefixed
	 * elements on Windows, unless it is the first component.
	 */
	p = joining
	if *(*TTcl_Size)(unsafe.Pointer(bp)) != 0 {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('.') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('/') && XtclPlatform == int32(TCL_PLATFORM_WINDOWS) && libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 2)))|uint32(32)-uint32('a') < uint32(26)) != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 3))) == int32(':') {
			p += uintptr(2)
		}
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('\000') {
		return
	}
	switch XtclPlatform {
	case int32(TCL_PLATFORM_UNIX):
		/*
		 * Append a separator if needed.
		 */
		if *(*TTcl_Size)(unsafe.Pointer(bp)) > 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp))-int64(1))))) != int32('/') {
			XTcl_AppendToObj(tls, prefix, __ccgo_ts+6339, int64(1))
			if (*TTcl_Obj)(unsafe.Pointer(prefix)).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(prefix)).Flength
				_ = (*TTcl_Obj)(unsafe.Pointer(prefix)).Fbytes
			} else {
				XTcl_GetStringFromObj(tls, prefix, bp)
			}
		}
		needsSep = 0
		/*
		 * Append the element, eliminating duplicate and trailing slashes.
		 */
		XTcl_SetObjLength(tls, prefix, libc.Int64FromUint64(libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))+libc.Xstrlen(tls, p)))
		if (*TTcl_Obj)(unsafe.Pointer(prefix)).Fbytes != 0 {
			v3 = (*TTcl_Obj)(unsafe.Pointer(prefix)).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, prefix, libc.UintptrFromInt32(0))
		}
		dest = v3 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))
		for {
			if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('\000')) {
				break
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('/') {
				for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('/') {
					p++
				}
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) != int32('\000') && needsSep != 0 {
					v5 = dest
					dest++
					*(*uint8)(unsafe.Pointer(v5)) = uint8('/')
				}
			} else {
				v6 = dest
				dest++
				*(*uint8)(unsafe.Pointer(v6)) = *(*uint8)(unsafe.Pointer(p))
				needsSep = int32(1)
			}
			goto _4
		_4:
			;
			p++
		}
		if (*TTcl_Obj)(unsafe.Pointer(prefix)).Fbytes != 0 {
			v7 = (*TTcl_Obj)(unsafe.Pointer(prefix)).Fbytes
		} else {
			v7 = XTcl_GetStringFromObj(tls, prefix, libc.UintptrFromInt32(0))
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = int64(dest) - int64(v7)
		XTcl_SetObjLength(tls, prefix, *(*TTcl_Size)(unsafe.Pointer(bp)))
	case int32(TCL_PLATFORM_WINDOWS):
		/*
		 * Check to see if we need to append a separator.
		 */
		if *(*TTcl_Size)(unsafe.Pointer(bp)) > 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp))-int64(1))))) != int32('/') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp))-int64(1))))) != int32(':') {
			XTcl_AppendToObj(tls, prefix, __ccgo_ts+6339, int64(1))
			if (*TTcl_Obj)(unsafe.Pointer(prefix)).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(prefix)).Flength
				_ = (*TTcl_Obj)(unsafe.Pointer(prefix)).Fbytes
			} else {
				XTcl_GetStringFromObj(tls, prefix, bp)
			}
		}
		needsSep = 0
		/*
		 * Append the element, eliminating duplicate and trailing slashes.
		 */
		XTcl_SetObjLength(tls, prefix, *(*TTcl_Size)(unsafe.Pointer(bp))+int64(libc.Int32FromUint64(libc.Xstrlen(tls, p))))
		if (*TTcl_Obj)(unsafe.Pointer(prefix)).Fbytes != 0 {
			v9 = (*TTcl_Obj)(unsafe.Pointer(prefix)).Fbytes
		} else {
			v9 = XTcl_GetStringFromObj(tls, prefix, libc.UintptrFromInt32(0))
		}
		dest = v9 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))
		for {
			if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('\000')) {
				break
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('/') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('\\') {
				for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('/') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('\\') {
					p++
				}
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) != int32('\000') && needsSep != 0 {
					v11 = dest
					dest++
					*(*uint8)(unsafe.Pointer(v11)) = uint8('/')
				}
			} else {
				v12 = dest
				dest++
				*(*uint8)(unsafe.Pointer(v12)) = *(*uint8)(unsafe.Pointer(p))
				needsSep = int32(1)
			}
			goto _10
		_10:
			;
			p++
		}
		if (*TTcl_Obj)(unsafe.Pointer(prefix)).Fbytes != 0 {
			v13 = (*TTcl_Obj)(unsafe.Pointer(prefix)).Fbytes
		} else {
			v13 = XTcl_GetStringFromObj(tls, prefix, libc.UintptrFromInt32(0))
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = int64(dest) - int64(v13)
		XTcl_SetObjLength(tls, prefix, *(*TTcl_Size)(unsafe.Pointer(bp)))
		break
	}
	return
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_JoinPath --
 *
 *	Combine a list of paths in a platform specific manner. The function
 *	'Tcl_FSJoinPath' should be used in preference where possible.
 *
 * Results:
 *	Appends the joined path to the end of the specified Tcl_DString
 *	returning a pointer to the resulting string. Note that the
 *	Tcl_DString must already be initialized.
 *
 * Side effects:
 *	Modifies the Tcl_DString.
 *
 *----------------------------------------------------------------------
 */

func XTcl_JoinPath(tls *libc.TLS, argc TTcl_Size, argv uintptr, resultPtr uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Pointer to previously initialized DString */
	var _objPtr, _objPtr1, cachePtr, listObj, resultObj, resultStr, v4, v5, v7 uintptr
	var i, v3, v6 TTcl_Size
	var v1 bool
	var _ /* len at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, i, listObj, resultObj, resultStr, v1, v3, v4, v5, v6, v7
	/*
	 * Build the list of paths.
	 */
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		listObj = XTclThreadAllocObj(tls)
	} else {
		listObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(listObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(listObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(listObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr = libc.UintptrFromInt32(0)
	i = 0
	for {
		if !(i < argc) {
			break
		}
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listObj, XTcl_NewStringObj(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)), int64(-int32(1))))
		goto _2
	_2:
		;
		i++
	}
	/*
	 * Ask the objectified code to join the paths.
	 */
	(*TTcl_Obj)(unsafe.Pointer(listObj)).FrefCount++
	resultObj = XTcl_FSJoinPath(tls, listObj, argc)
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount++
	_objPtr = listObj
	v4 = _objPtr
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	if v3 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	/*
	 * Store the result.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength
		v5 = (*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes
	} else {
		v5 = XTcl_GetStringFromObj(tls, resultObj, bp)
	}
	resultStr = v5
	XTcl_DStringAppend(tls, resultPtr, resultStr, *(*TTcl_Size)(unsafe.Pointer(bp)))
	_objPtr1 = resultObj
	v7 = _objPtr1
	v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
	*(*TTcl_Size)(unsafe.Pointer(v7))--
	if v6 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	/*
	 * Return a pointer to the result.
	 */
	return (*TTcl_DString)(unsafe.Pointer(resultPtr)).Fstring1
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_TranslateFileName --
 *
 *	Converts a file name into a form usable by the native system
 *	interfaces.
 *
 * Results:
 *	The return value is a pointer to a string containing the name.
 *      This may either be the name pointer passed in or space allocated in
 *      bufferPtr. In all cases, if the return value is not NULL, the caller
 *	must call Tcl_DStringFree() to free the space. If there was an
 *	error in processing the name, then an error message is left in the
 *	interp's result (if interp was not NULL) and the return value is NULL.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_TranslateFileName(tls *libc.TLS, interp uintptr, name uintptr, bufferPtr uintptr) (r uintptr) {
	/* Uninitialized or free DString filled with
	 * name. */
	var _objPtr, _objPtr1, _objPtr2, p, path, transPtr, v2, v4, v6 uintptr
	var v1, v3, v5 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, p, path, transPtr, v1, v2, v3, v4, v5, v6
	path = XTcl_NewStringObj(tls, name, int64(-int32(1)))
	(*TTcl_Obj)(unsafe.Pointer(path)).FrefCount++
	transPtr = XTcl_FSGetTranslatedPath(tls, interp, path)
	if transPtr == libc.UintptrFromInt32(0) {
		_objPtr = path
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		return libc.UintptrFromInt32(0)
	}
	XTcl_DStringInit(tls, bufferPtr)
	XTclDStringAppendObj(tls, bufferPtr, transPtr)
	_objPtr1 = path
	v4 = _objPtr1
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	if v3 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	_objPtr2 = transPtr
	v6 = _objPtr2
	v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
	*(*TTcl_Size)(unsafe.Pointer(v6))--
	if v5 <= int64(1) {
		XTclFreeObj(tls, _objPtr2)
	}
	/*
	 * Convert forward slashes to backslashes in Windows paths because some
	 * system interfaces don't accept forward slashes.
	 */
	if XtclPlatform == int32(TCL_PLATFORM_WINDOWS) {
		p = (*TTcl_DString)(unsafe.Pointer(bufferPtr)).Fstring1
		for {
			if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('\000')) {
				break
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('/') {
				*(*uint8)(unsafe.Pointer(p)) = uint8('\\')
			}
			goto _7
		_7:
			;
			p++
		}
	}
	return (*TTcl_DString)(unsafe.Pointer(bufferPtr)).Fstring1
}

/*
 *----------------------------------------------------------------------
 *
 * TclGetExtension --
 *
 *	This function returns a pointer to the beginning of the extension part
 *	of a file name.
 *
 * Results:
 *	Returns a pointer into name which indicates where the extension
 *	starts. If there is no extension, returns NULL.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclGetExtension(tls *libc.TLS, name uintptr) (r uintptr) {
	/* File name to parse. */
	var lastSep, p uintptr
	_, _ = lastSep, p
	/*
	 * First find the last directory separator.
	 */
	lastSep = libc.UintptrFromInt32(0) /* Needed only to prevent gcc warnings. */
	switch XtclPlatform {
	case int32(TCL_PLATFORM_UNIX):
		lastSep = libc.Xstrrchr(tls, name, int32('/'))
	case int32(TCL_PLATFORM_WINDOWS):
		lastSep = libc.UintptrFromInt32(0)
		p = name
		for {
			if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('\000')) {
				break
			}
			if libc.Xstrchr(tls, __ccgo_ts+34720, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))) != libc.UintptrFromInt32(0) {
				lastSep = p
			}
			goto _1
		_1:
			;
			p++
		}
		break
	}
	p = libc.Xstrrchr(tls, name, int32('.'))
	if p != libc.UintptrFromInt32(0) && lastSep != libc.UintptrFromInt32(0) && lastSep > p {
		p = libc.UintptrFromInt32(0)
	}
	/*
	 * In earlier versions, we used to back up to the first period in a series
	 * so that "foo..o" would be split into "foo" and "..o". This is a
	 * confusing and usually incorrect behavior, so now we split at the last
	 * period in the name.
	 */
	return p
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GlobObjCmd --
 *
 *	This procedure is invoked to process the "glob" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GlobObjCmd(tls *libc.TLS, dummy1115 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(784)
	defer tls.Free(784) /* Argument objects. */
	var _objPtr, _objPtr1, _objPtr2, find, first, globTypes, last, pathOrDir, search, separators, str, string1, temp, typePtr, v10, v14, v2, v21, v22, v23, v24, v28, v3, v30, v32, v34, v4, v7, v9 uintptr
	var dir, globFlags, i, join, result, v19, v5 int32
	var v12, v20, v6 int64
	var v13, v29, v31, v33 TTcl_Size
	var _ /* index at bp+240 */ int32
	var _ /* item at bp+488 */ uintptr
	var _ /* len at bp+480 */ TTcl_Size
	var _ /* length at bp+0 */ TTcl_Size
	var _ /* llen at bp+496 */ TTcl_Size
	var _ /* look at bp+8 */ uintptr
	var _ /* pathlength at bp+248 */ TTcl_Size
	var _ /* pref at bp+256 */ TTcl_DString
	var _ /* prefix at bp+16 */ TTcl_DString
	var _ /* str at bp+504 */ TTcl_DString
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, dir, find, first, globFlags, globTypes, i, join, last, pathOrDir, result, search, separators, str, string1, temp, typePtr, v10, v12, v13, v14, v19, v2, v20, v21, v22, v23, v24, v28, v29, v3, v30, v31, v32, v33, v34, v4, v5, v6, v7, v9
	pathOrDir = libc.UintptrFromInt32(0)
	globTypes = libc.UintptrFromInt32(0)
	globFlags = 0
	join = 0
	dir = -1
	typePtr = libc.UintptrFromInt32(0)
	i = int32(1)
	for {
		if !(i < objc) {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_options10)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+240) != TCL_OK {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
				v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
			}
			string1 = v2
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1))) == int32('-') {
				/*
				 * It looks like the command contains an option so signal an
				 * error.
				 */
				return int32(TCL_ERROR)
			} else {
				/*
				 * This clearly isn't an option; assume it's the first glob
				 * pattern. We must clear the error.
				 */
				XTcl_ResetResult(tls, interp)
				break
			}
		}
		switch *(*int32)(unsafe.Pointer(bp + 240)) {
		case 2: /* -nocomplain */
			/*
			 * Do nothing; This is normal operations in Tcl 9.
			 * Keep accepting as a no-op option to accommodate old scripts.
			 */
		case 0: /* -dir */
			if i == objc-int32(1) {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+34761, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+736, __ccgo_ts+2004, __ccgo_ts+16490, __ccgo_ts+17673, libc.UintptrFromInt32(0)))
				return int32(TCL_ERROR)
			}
			if dir != -1 {
				if dir == 1 {
					v3 = __ccgo_ts + 34794
				} else {
					v3 = __ccgo_ts + 34829
				}
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, v3, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+736, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+34870, __ccgo_ts+34875, libc.UintptrFromInt32(0)))
				return int32(TCL_ERROR)
			}
			dir = 1
			globFlags |= int32(TCL_GLOBMODE_DIR)
			pathOrDir = *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8))
			i++
		case 1: /* -join */
			join = int32(1)
		case 4: /* -tails */
			globFlags |= int32(TCL_GLOBMODE_TAILS)
		case 3: /* -path */
			if i == objc-int32(1) {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+34896, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+736, __ccgo_ts+2004, __ccgo_ts+16490, __ccgo_ts+17673, libc.UintptrFromInt32(0)))
				return int32(TCL_ERROR)
			}
			if dir != -1 {
				if dir == 0 {
					v4 = __ccgo_ts + 34924
				} else {
					v4 = __ccgo_ts + 34954
				}
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, v4, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+736, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+34870, __ccgo_ts+34875, libc.UintptrFromInt32(0)))
				return int32(TCL_ERROR)
			}
			dir = 0
			pathOrDir = *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8))
			i++
		case 5: /* -types */
			if i == objc-int32(1) {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+34996, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+736, __ccgo_ts+2004, __ccgo_ts+16490, __ccgo_ts+17673, libc.UintptrFromInt32(0)))
				return int32(TCL_ERROR)
			}
			typePtr = *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8))
			if (*TTcl_Obj)(unsafe.Pointer(typePtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(typePtr + 32))).Fptr2 != 0 {
					v6 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(typePtr + 32))).Fptr2)).FspanLength
				} else {
					v6 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(typePtr + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp)) = v6
				v5 = libc.Int32FromInt32(TCL_OK)
			} else {
				v5 = XTcl_ListObjLength(tls, interp, typePtr, bp)
			}
			if v5 != TCL_OK {
				return int32(TCL_ERROR)
			}
			i++
		case 6: /* -- */
			i++
			goto endOfForLoop
		}
		goto _1
	_1:
		;
		i++
	}
	goto endOfForLoop
endOfForLoop:
	;
	if globFlags&int32(TCL_GLOBMODE_TAILS) != 0 && pathOrDir == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+35025, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+736, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+34870, __ccgo_ts+34875, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	separators = libc.UintptrFromInt32(0)
	switch XtclPlatform {
	case int32(TCL_PLATFORM_UNIX):
		separators = __ccgo_ts + 6339
	case int32(TCL_PLATFORM_WINDOWS):
		separators = __ccgo_ts + 34720
		break
	}
	if dir == 0 {
		if (*TTcl_Obj)(unsafe.Pointer(pathOrDir)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 248)) = (*TTcl_Obj)(unsafe.Pointer(pathOrDir)).Flength
			v7 = (*TTcl_Obj)(unsafe.Pointer(pathOrDir)).Fbytes
		} else {
			v7 = XTcl_GetStringFromObj(tls, pathOrDir, bp+248)
		}
		first = v7
		/*
		 * Find the last path separator in the path
		 */
		last = first + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 248)))
		for {
			if !(last != first) {
				break
			}
			if libc.Xstrchr(tls, separators, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(last + uintptr(-libc.Int32FromInt32(1)))))) != libc.UintptrFromInt32(0) {
				break
			}
			goto _8
		_8:
			;
			last--
		}
		if last == first+uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 248))) {
			/*
			 * It's really a directory.
			 */
			dir = 1
		} else {
			XTcl_DStringInit(tls, bp+256)
			if last == first {
				/*
				 * The whole thing is a prefix. This means we must remove any
				 * 'tails' flag too, since it is irrelevant now (the same
				 * effect will happen without it), but in particular its use
				 * in TclGlob requires a non-NULL pathOrDir.
				 */
				XTcl_DStringAppend(tls, bp+256, first, int64(-int32(1)))
				globFlags &= ^libc.Int32FromInt32(TCL_GLOBMODE_TAILS)
				pathOrDir = libc.UintptrFromInt32(0)
			} else {
				/*
				 * Have to split off the end.
				 */
				XTcl_DStringAppend(tls, bp+256, last, int64(first+uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 248))))-int64(last))
				pathOrDir = XTcl_NewStringObj(tls, first, int64(last)-int64(first)-int64(1))
				if (*TTcl_Obj)(unsafe.Pointer(pathOrDir)).Fbytes != 0 {
					v9 = (*TTcl_Obj)(unsafe.Pointer(pathOrDir)).Fbytes
				} else {
					v9 = XTcl_GetStringFromObj(tls, pathOrDir, libc.UintptrFromInt32(0))
				}
				/*
				 * We must ensure that we haven't cut off too much, and turned
				 * a valid path like '/' or 'C:/' into an incorrect path like
				 * '' or 'C:'. The way we do this is to add a separator if
				 * there are none presently in the prefix. Similar treatment
				 * for the zipfs volume.
				 */
				temp = v9
				if libc.Xstrpbrk(tls, temp, __ccgo_ts+35083) == libc.UintptrFromInt32(0) {
					XTcl_AppendToObj(tls, pathOrDir, last-uintptr(1), int64(1))
				} else {
					if !(libc.Xstrcmp(tls, temp, __ccgo_ts+35086) != 0) {
						XTcl_AppendToObj(tls, pathOrDir, __ccgo_ts+6339, int64(1))
					}
				}
			}
			/*
			 * Need to quote 'prefix'.
			 */
			XTcl_DStringInit(tls, bp+16)
			search = (*TTcl_DString)(unsafe.Pointer(bp + 256)).Fstring1
			for {
				v10 = libc.Xstrpbrk(tls, search, __ccgo_ts+35095)
				find = v10
				if !(v10 != libc.UintptrFromInt32(0)) {
					break
				}
				XTcl_DStringAppend(tls, bp+16, search, int64(find)-int64(search))
				XTcl_DStringAppend(tls, bp+16, __ccgo_ts+15596, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))
				XTcl_DStringAppend(tls, bp+16, find, int64(1))
				search = find + uintptr(1)
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(search))) == int32('\000') {
					break
				}
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(search))) != int32('\000') {
				XTcl_DStringAppend(tls, bp+16, search, int64(-int32(1)))
			}
			XTcl_DStringFree(tls, bp+256)
		}
	}
	if pathOrDir != libc.UintptrFromInt32(0) {
		(*TTcl_Obj)(unsafe.Pointer(pathOrDir)).FrefCount++
	}
	if typePtr != libc.UintptrFromInt32(0) {
		/*
		 * The rest of the possible type arguments (except 'd') are platform
		 * specific. We don't complain when they are used on an incompatible
		 * platform.
		 */
		if (*TTcl_Obj)(unsafe.Pointer(typePtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(typePtr + 32))).Fptr2 != 0 {
				v12 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(typePtr + 32))).Fptr2)).FspanLength
			} else {
				v12 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(typePtr + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp)) = v12
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_ListObjLength(tls, interp, typePtr, bp)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
			goto skipTypes
		}
		globTypes = XTclStackAlloc(tls, interp, uint64(24))
		(*TTcl_GlobTypeData)(unsafe.Pointer(globTypes)).Ftype1 = 0
		(*TTcl_GlobTypeData)(unsafe.Pointer(globTypes)).Fperm = 0
		(*TTcl_GlobTypeData)(unsafe.Pointer(globTypes)).FmacType = libc.UintptrFromInt32(0)
		(*TTcl_GlobTypeData)(unsafe.Pointer(globTypes)).FmacCreator = libc.UintptrFromInt32(0)
		for {
			v13 = *(*TTcl_Size)(unsafe.Pointer(bp))
			*(*TTcl_Size)(unsafe.Pointer(bp))--
			if !(v13 > 0) {
				break
			}
			XTcl_ListObjIndex(tls, interp, typePtr, *(*TTcl_Size)(unsafe.Pointer(bp)), bp+8)
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 480)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength
				v14 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes
			} else {
				v14 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), bp+480)
			}
			str = v14
			if libc.Xstrcmp(tls, __ccgo_ts+35103, str) == 0 {
				*(*int32)(unsafe.Pointer(globTypes + 4)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(0)
			} else {
				if libc.Xstrcmp(tls, __ccgo_ts+35112, str) == 0 {
					*(*int32)(unsafe.Pointer(globTypes + 4)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(1)
				} else {
					if !(*(*TTcl_Size)(unsafe.Pointer(bp + 480)) == int64(1)) {
						goto _15
					}
					switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) {
					case int32('r'):
						*(*int32)(unsafe.Pointer(globTypes + 4)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(2)
					case int32('w'):
						*(*int32)(unsafe.Pointer(globTypes + 4)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(3)
					case int32('x'):
						*(*int32)(unsafe.Pointer(globTypes + 4)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(4)
					case int32('b'):
						*(*int32)(unsafe.Pointer(globTypes)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(0)
					case int32('c'):
						*(*int32)(unsafe.Pointer(globTypes)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(1)
					case int32('d'):
						*(*int32)(unsafe.Pointer(globTypes)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(2)
					case int32('p'):
						*(*int32)(unsafe.Pointer(globTypes)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(3)
					case int32('f'):
						*(*int32)(unsafe.Pointer(globTypes)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(4)
					case int32('l'):
						*(*int32)(unsafe.Pointer(globTypes)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(5)
					case int32('s'):
						*(*int32)(unsafe.Pointer(globTypes)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(6)
					default:
						goto badTypesArg
					}
					goto _16
				_15:
					;
					if !(*(*TTcl_Size)(unsafe.Pointer(bp + 480)) == int64(4)) {
						goto _17
					}
					/*
					 * This is assumed to be a MacOS file type.
					 */
					if (*TTcl_GlobTypeData)(unsafe.Pointer(globTypes)).FmacType != libc.UintptrFromInt32(0) {
						goto badMacTypesArg
					}
					(*TTcl_GlobTypeData)(unsafe.Pointer(globTypes)).FmacType = *(*uintptr)(unsafe.Pointer(bp + 8))
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
					goto _18
				_17:
					;
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
						if (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr2 != 0 {
							v20 = (*TListSpan)(unsafe.Pointer((*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr2)).FspanLength
						} else {
							v20 = (*TListStore)(unsafe.Pointer((*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1)).FnumUsed
						}
						*(*TTcl_Size)(unsafe.Pointer(bp + 496)) = v20
						v19 = libc.Int32FromInt32(TCL_OK)
					} else {
						v19 = XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 8)), bp+496)
					}
					if v19 == TCL_OK && *(*TTcl_Size)(unsafe.Pointer(bp + 496)) == int64(3) {
						XTcl_ListObjIndex(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 8)), 0, bp+488)
						if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 488)))).Fbytes != 0 {
							v21 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 488)))).Fbytes
						} else {
							v21 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 488)), libc.UintptrFromInt32(0))
						}
						if !(libc.Xstrcmp(tls, __ccgo_ts+35119, v21) != 0) {
							XTcl_ListObjIndex(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 8)), int64(1), bp+488)
							if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 488)))).Fbytes != 0 {
								v22 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 488)))).Fbytes
							} else {
								v22 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 488)), libc.UintptrFromInt32(0))
							}
							if !(libc.Xstrcmp(tls, __ccgo_ts+5851, v22) != 0) {
								XTcl_ListObjIndex(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 8)), int64(2), bp+488)
								if (*TTcl_GlobTypeData)(unsafe.Pointer(globTypes)).FmacType != libc.UintptrFromInt32(0) {
									goto badMacTypesArg
								}
								(*TTcl_GlobTypeData)(unsafe.Pointer(globTypes)).FmacType = *(*uintptr)(unsafe.Pointer(bp + 488))
								(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 488)))).FrefCount++
								continue
							} else {
								if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 488)))).Fbytes != 0 {
									v23 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 488)))).Fbytes
								} else {
									v23 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 488)), libc.UintptrFromInt32(0))
								}
								if !(libc.Xstrcmp(tls, __ccgo_ts+35129, v23) != 0) {
									XTcl_ListObjIndex(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 8)), int64(2), bp+488)
									if (*TTcl_GlobTypeData)(unsafe.Pointer(globTypes)).FmacCreator != libc.UintptrFromInt32(0) {
										goto badMacTypesArg
									}
									(*TTcl_GlobTypeData)(unsafe.Pointer(globTypes)).FmacCreator = *(*uintptr)(unsafe.Pointer(bp + 488))
									(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 488)))).FrefCount++
									continue
								}
							}
						}
					}
					/*
					 * Error cases. We reset the 'join' flag to zero, since we
					 * haven't yet made use of it.
					 */
					goto badTypesArg
				badTypesArg:
					;
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != 0 {
						v24 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes
					} else {
						v24 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), libc.UintptrFromInt32(0))
					}
					XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+35137, libc.VaList(bp+736, v24)))
					XTcl_SetErrorCode(tls, interp, libc.VaList(bp+736, __ccgo_ts+2004, __ccgo_ts+16490, __ccgo_ts+35166, libc.UintptrFromInt32(0)))
					result = int32(TCL_ERROR)
					join = 0
					goto endOfGlob
					goto badMacTypesArg
				badMacTypesArg:
					;
					XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+35170, int64(-int32(1))))
					result = int32(TCL_ERROR)
					XTcl_SetErrorCode(tls, interp, libc.VaList(bp+736, __ccgo_ts+2004, __ccgo_ts+16490, __ccgo_ts+35166, libc.UintptrFromInt32(0)))
					join = 0
					goto endOfGlob
				_18:
					;
				_16:
				}
			}
		}
	}
	goto skipTypes
skipTypes:
	;
	/*
	 * Now we perform the actual glob below. This may involve joining together
	 * the pattern arguments, dealing with particular file types etc. We use a
	 * 'goto' to ensure we free any memory allocated along the way.
	 */
	objc -= i
	objv += uintptr(i) * 8
	result = TCL_OK
	if join != 0 {
		if dir != 0 {
			XTcl_DStringInit(tls, bp+16)
		}
		i = 0
		for {
			if !(i < objc) {
				break
			}
			XTclDStringAppendObj(tls, bp+16, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))
			if i != objc-int32(1) {
				XTcl_DStringAppend(tls, bp+16, separators, int64(1))
			}
			goto _25
		_25:
			;
			i++
		}
		if _TclGlob(tls, interp, (*TTcl_DString)(unsafe.Pointer(bp+16)).Fstring1, pathOrDir, globFlags, globTypes) != TCL_OK {
			result = int32(TCL_ERROR)
			goto endOfGlob
		}
	} else {
		if dir == 0 {
			XTcl_DStringInit(tls, bp+504)
			i = 0
			for {
				if !(i < objc) {
					break
				}
				XTcl_DStringSetLength(tls, bp+504, 0)
				if dir == 0 {
					XTclDStringAppendDString(tls, bp+504, bp+16)
				}
				XTclDStringAppendObj(tls, bp+504, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))
				if _TclGlob(tls, interp, (*TTcl_DString)(unsafe.Pointer(bp+504)).Fstring1, pathOrDir, globFlags, globTypes) != TCL_OK {
					result = int32(TCL_ERROR)
					XTcl_DStringFree(tls, bp+504)
					goto endOfGlob
				}
				goto _26
			_26:
				;
				i++
			}
			XTcl_DStringFree(tls, bp+504)
		} else {
			i = 0
			for {
				if !(i < objc) {
					break
				}
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
					v28 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
				} else {
					v28 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
				}
				string1 = v28
				if _TclGlob(tls, interp, string1, pathOrDir, globFlags, globTypes) != TCL_OK {
					result = int32(TCL_ERROR)
					goto endOfGlob
				}
				goto _27
			_27:
				;
				i++
			}
		}
	}
	goto endOfGlob
endOfGlob:
	;
	if join != 0 || dir == 0 {
		XTcl_DStringFree(tls, bp+16)
	}
	if pathOrDir != libc.UintptrFromInt32(0) {
		_objPtr = pathOrDir
		v30 = _objPtr
		v29 = *(*TTcl_Size)(unsafe.Pointer(v30))
		*(*TTcl_Size)(unsafe.Pointer(v30))--
		if v29 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	if globTypes != libc.UintptrFromInt32(0) {
		if (*TTcl_GlobTypeData)(unsafe.Pointer(globTypes)).FmacType != libc.UintptrFromInt32(0) {
			_objPtr1 = (*TTcl_GlobTypeData)(unsafe.Pointer(globTypes)).FmacType
			v32 = _objPtr1
			v31 = *(*TTcl_Size)(unsafe.Pointer(v32))
			*(*TTcl_Size)(unsafe.Pointer(v32))--
			if v31 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
		}
		if (*TTcl_GlobTypeData)(unsafe.Pointer(globTypes)).FmacCreator != libc.UintptrFromInt32(0) {
			_objPtr2 = (*TTcl_GlobTypeData)(unsafe.Pointer(globTypes)).FmacCreator
			v34 = _objPtr2
			v33 = *(*TTcl_Size)(unsafe.Pointer(v34))
			*(*TTcl_Size)(unsafe.Pointer(v34))--
			if v33 <= int64(1) {
				XTclFreeObj(tls, _objPtr2)
			}
		}
		XTclStackFree(tls, interp, globTypes)
	}
	return result
}

var _options10 = [8]uintptr{
	0: __ccgo_ts + 34724,
	1: __ccgo_ts + 34735,
	2: __ccgo_ts + 22371,
	3: __ccgo_ts + 34741,
	4: __ccgo_ts + 34747,
	5: __ccgo_ts + 34754,
	6: __ccgo_ts + 18684,
	7: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * TclGlob --
 *
 *	Sets the separator string based on the platform	and calls DoGlob.
 *
 *	The interpreter's result, on entry to this function, must be a valid
 *	Tcl list (e.g. it could be empty), since we will lappend any new
 *	results to that list. If it is not a valid list, this function will
 *	fail to do anything very meaningful.
 *
 *	Note that if globFlags contains 'TCL_GLOBMODE_TAILS' then pathPrefix
 *	cannot be NULL (it is only allowed with -dir or -path).
 *
 * Results:
 *	The return value is a standard Tcl result indicating whether an error
 *	occurred in globbing. After a normal return the result in interp (set
 *	by DoGlob) holds all of the file names given by the pattern and
 *	pathPrefix arguments. After an error the result in interp will hold
 *	an error message.
 *
 * Side effects:
 *	The 'pattern' is written to.
 *
 *----------------------------------------------------------------------
 */

func _TclGlob(tls *libc.TLS, interp uintptr, pattern uintptr, pathPrefix uintptr, globFlags int32, types uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* Struct containing acceptable types. May be
	 * NULL. */
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cwd, filenamesObj, oldStr, p, pre, savedResultObj, separators, tail, temp, v10, v13, v16, v17, v2, v22, v26, v29, v3, v32, v35, v5, v7 uintptr
	var i, v1, v12, v15, v25, v28, v31, v34, v4, v6, v9 TTcl_Size
	var result int32
	var v11, v14, v23, v24, v27, v30, v33, v8 bool
	var v19, v20 int64
	var _ /* c at bp+0 */ uint8
	var _ /* driveName at bp+16 */ uintptr
	var _ /* driveName at bp+32 */ uintptr
	var _ /* driveNameLen at bp+24 */ TTcl_Size
	var _ /* driveNameLen at bp+8 */ TTcl_Size
	var _ /* elem at bp+72 */ uintptr
	var _ /* len at bp+64 */ TTcl_Size
	var _ /* objc at bp+40 */ TTcl_Size
	var _ /* objv at bp+48 */ uintptr
	var _ /* prefixLen at bp+56 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cwd, filenamesObj, i, oldStr, p, pre, result, savedResultObj, separators, tail, temp, v1, v10, v11, v12, v13, v14, v15, v16, v17, v19, v2, v20, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v4, v5, v6, v7, v8, v9
	separators = libc.UintptrFromInt32(0)
	switch XtclPlatform {
	case int32(TCL_PLATFORM_UNIX):
		separators = __ccgo_ts + 6339
	case int32(TCL_PLATFORM_WINDOWS):
		separators = __ccgo_ts + 34720
		break
	}
	if pathPrefix != libc.UintptrFromInt32(0) {
		(*TTcl_Obj)(unsafe.Pointer(pathPrefix)).FrefCount++
	}
	tail = pattern
	/*
	 * Handling empty path prefixes with glob patterns like 'C:' or
	 * 'c:////////' is a pain on Windows if we leave it too late, since these
	 * aren't really patterns at all! We therefore check the head of the
	 * pattern now for such cases, if we don't have an unquoted prefix yet.
	 *
	 * Similarly on Unix with '/' at the head of the pattern -- it just
	 * indicates the root volume, so we treat it as such.
	 */
	if XtclPlatform == int32(TCL_PLATFORM_WINDOWS) {
		if pathPrefix == libc.UintptrFromInt32(0) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(tail))) != int32('\000') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(tail + 1))) == int32(':') {
			p = tail + uintptr(1)
			pathPrefix = XTcl_NewStringObj(tls, tail, int64(1))
			for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('\000') {
				*(*uint8)(unsafe.Pointer(bp)) = *(*uint8)(unsafe.Pointer(p + 1))
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('\\') {
					if libc.Xstrchr(tls, separators, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp)))) != libc.UintptrFromInt32(0) {
						if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) == int32('\\') {
							*(*uint8)(unsafe.Pointer(bp)) = uint8('/')
						}
						XTcl_AppendToObj(tls, pathPrefix, bp, int64(1))
						p++
					} else {
						break
					}
				} else {
					if libc.Xstrchr(tls, separators, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))) != libc.UintptrFromInt32(0) {
						XTcl_AppendToObj(tls, pathPrefix, p, int64(1))
					} else {
						break
					}
				}
				p++
			}
			tail = p
			(*TTcl_Obj)(unsafe.Pointer(pathPrefix)).FrefCount++
		} else {
			if pathPrefix == libc.UintptrFromInt32(0) && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(tail))) == int32('/') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(tail))) == int32('\\') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(tail + 1))) == int32('\\')) {
				temp = XTcl_NewStringObj(tls, tail, int64(-int32(1)))
				(*TTcl_Obj)(unsafe.Pointer(temp)).FrefCount++
				switch XTclGetPathType(tls, temp, libc.UintptrFromInt32(0), bp+8, bp+16) {
				case int32(TCL_PATH_VOLUME_RELATIVE):
					/*
					 * Volume relative path which is equivalent to a path in the
					 * root of the cwd's volume. We will actually return
					 * non-volume-relative paths here. i.e. 'glob /foo*' will
					 * return 'C:/foobar'. This is much the same as globbing for a
					 * path with '\\' will return one with '/' on Windows.
					 */
					cwd = XTcl_FSGetCwd(tls, interp)
					if cwd == libc.UintptrFromInt32(0) {
						_objPtr = temp
						v2 = _objPtr
						v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
						*(*TTcl_Size)(unsafe.Pointer(v2))--
						if v1 <= int64(1) {
							XTclFreeObj(tls, _objPtr)
						}
						return int32(TCL_ERROR)
					}
					if (*TTcl_Obj)(unsafe.Pointer(cwd)).Fbytes != 0 {
						v3 = (*TTcl_Obj)(unsafe.Pointer(cwd)).Fbytes
					} else {
						v3 = XTcl_GetStringFromObj(tls, cwd, libc.UintptrFromInt32(0))
					}
					pathPrefix = XTcl_NewStringObj(tls, v3, int64(3))
					_objPtr1 = cwd
					v5 = _objPtr1
					v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
					*(*TTcl_Size)(unsafe.Pointer(v5))--
					if v4 <= int64(1) {
						XTclFreeObj(tls, _objPtr1)
					}
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(tail))) == int32('/') {
						tail++
					} else {
						tail += uintptr(2)
					}
					(*TTcl_Obj)(unsafe.Pointer(pathPrefix)).FrefCount++
				case int32(TCL_PATH_ABSOLUTE):
					/*
					 * Absolute, possibly network path //Machine/Share. Use that
					 * as the path prefix (it already has a refCount).
					 */
					pathPrefix = *(*uintptr)(unsafe.Pointer(bp + 16))
					tail += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
				case int32(TCL_PATH_RELATIVE):
					/* Do nothing */
					break
				}
				_objPtr2 = temp
				v7 = _objPtr2
				v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
				*(*TTcl_Size)(unsafe.Pointer(v7))--
				if v6 <= int64(1) {
					XTclFreeObj(tls, _objPtr2)
				}
			}
		}
		/*
		 * ':' no longer needed as a separator. It is only relevant to the
		 * beginning of the path.
		 */
		separators = __ccgo_ts + 35230
	} else {
		if XtclPlatform == int32(TCL_PLATFORM_UNIX) {
			if pathPrefix == libc.UintptrFromInt32(0) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(tail))) == int32('/') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(tail + 1))) != int32('/') {
				pathPrefix = XTcl_NewStringObj(tls, tail, int64(1))
				tail++
				(*TTcl_Obj)(unsafe.Pointer(pathPrefix)).FrefCount++
			}
		}
	}
	/*
	 * Finally if we still haven't managed to generate a path prefix, check if
	 * the path starts with a current volume.
	 */
	if pathPrefix == libc.UintptrFromInt32(0) {
		if XTclFSNonnativePathType(tls, tail, libc.Int64FromUint64(libc.Xstrlen(tls, tail)), libc.UintptrFromInt32(0), bp+24, bp+32) == int32(TCL_PATH_ABSOLUTE) {
			pathPrefix = *(*uintptr)(unsafe.Pointer(bp + 32))
			tail += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 24)))
		}
	}
	/*
	 * To process a [glob] invocation, this function may be called multiple
	 * times. Each time, the previously discovered filenames are in the
	 * interpreter result. We stash that away here so the result is free for
	 * error messages.
	 */
	savedResultObj = XTcl_GetObjResult(tls, interp)
	(*TTcl_Obj)(unsafe.Pointer(savedResultObj)).FrefCount++
	XTcl_ResetResult(tls, interp)
	if v8 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v8 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v8 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		filenamesObj = XTclThreadAllocObj(tls)
	} else {
		filenamesObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(filenamesObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(filenamesObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(filenamesObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(filenamesObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(filenamesObj)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(filenamesObj)).FrefCount++
	/*
	 * Now we do the actual globbing, adding filenames as we go to buffer in
	 * filenamesObj
	 */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(tail))) == int32('\000') && pathPrefix != libc.UintptrFromInt32(0) {
		/*
		 * An empty pattern. This means 'pathPrefix' is actually a full path
		 * of a file/directory we want to simply check for existence and type.
		 */
		if types == libc.UintptrFromInt32(0) {
			/*
			 * We just want to check for existence. In this case we make it
			 * easy on Tcl_FSMatchInDirectory and its sub-implementations by
			 * not bothering them (even though they should support this
			 * situation) and we just use the simple existence check with
			 * Tcl_FSAccess.
			 */
			if XTcl_FSAccess(tls, pathPrefix, F_OK) == 0 {
				XTcl_ListObjAppendElement(tls, interp, filenamesObj, pathPrefix)
			}
			result = TCL_OK
		} else {
			/*
			 * We want to check for the correct type. Tcl_FSMatchInDirectory
			 * is documented to do this for us, if we give it a NULL pattern.
			 */
			result = XTcl_FSMatchInDirectory(tls, interp, filenamesObj, pathPrefix, libc.UintptrFromInt32(0), types)
		}
	} else {
		result = _DoGlob(tls, interp, filenamesObj, separators, pathPrefix, globFlags&int32(TCL_GLOBMODE_DIR), tail, types)
	}
	/*
	 * Check for errors...
	 */
	if result != TCL_OK {
		v10 = filenamesObj
		v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
		*(*TTcl_Size)(unsafe.Pointer(v10))--
		if !(v9 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(filenamesObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(filenamesObj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(filenamesObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(filenamesObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(filenamesObj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(filenamesObj)).Flength = int64(-libc.Int32FromInt32(1))
				if v11 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v11 {
					cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v11 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, filenamesObj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(filenamesObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = filenamesObj
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, filenamesObj)
			}
		}
		v13 = savedResultObj
		v12 = *(*TTcl_Size)(unsafe.Pointer(v13))
		*(*TTcl_Size)(unsafe.Pointer(v13))--
		if !(v12 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(savedResultObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(savedResultObj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(savedResultObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(savedResultObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(savedResultObj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(savedResultObj)).Flength = int64(-libc.Int32FromInt32(1))
				if v14 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v14 {
					cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v14 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, savedResultObj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(savedResultObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = savedResultObj
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, savedResultObj)
			}
		}
		if pathPrefix != libc.UintptrFromInt32(0) {
			_objPtr3 = pathPrefix
			v16 = _objPtr3
			v15 = *(*TTcl_Size)(unsafe.Pointer(v16))
			*(*TTcl_Size)(unsafe.Pointer(v16))--
			if v15 <= int64(1) {
				XTclFreeObj(tls, _objPtr3)
			}
		}
		return result
	}
	/*
	 * If we only want the tails, we must strip off the prefix now. It may
	 * seem more efficient to pass the tails flag down into DoGlob,
	 * Tcl_FSMatchInDirectory, but those functions are continually adjusting
	 * the prefix as the various pieces of the pattern are assimilated, so
	 * that would add a lot of complexity to the code. This way is a little
	 * slower (when the -tails flag is given), but much simpler to code.
	 *
	 * We do it by rewriting the result list in-place.
	 */
	if globFlags&int32(TCL_GLOBMODE_TAILS) != 0 {
		/*
		 * If this length has never been set, set it here.
		 */
		if pathPrefix == libc.UintptrFromInt32(0) {
			XTcl_Panic(tls, __ccgo_ts+35233, 0)
		}
		if (*TTcl_Obj)(unsafe.Pointer(pathPrefix)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 56)) = (*TTcl_Obj)(unsafe.Pointer(pathPrefix)).Flength
			v17 = (*TTcl_Obj)(unsafe.Pointer(pathPrefix)).Fbytes
		} else {
			v17 = XTcl_GetStringFromObj(tls, pathPrefix, bp+56)
		}
		pre = v17
		if *(*TTcl_Size)(unsafe.Pointer(bp + 56)) > 0 && libc.Xstrchr(tls, separators, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pre + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 56))-int64(1)))))) == libc.UintptrFromInt32(0) {
			/*
			 * If we're on Windows and the prefix is a volume relative one
			 * like 'C:', then there won't be a path separator in between, so
			 * no need to skip it here.
			 */
			if XtclPlatform != int32(TCL_PLATFORM_WINDOWS) || *(*TTcl_Size)(unsafe.Pointer(bp + 56)) != int64(2) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pre + 1))) != int32(':') {
				*(*TTcl_Size)(unsafe.Pointer(bp + 56))++
			}
		}
		if (*TTcl_Obj)(unsafe.Pointer(filenamesObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(filenamesObj + 32))).Fptr2 != 0 {
				v19 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(filenamesObj + 32))).Fptr2)).FspanStart
			} else {
				v19 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(filenamesObj + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 48)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(filenamesObj + 32))).Fptr1 + 40 + uintptr(v19)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(filenamesObj + 32))).Fptr2 != 0 {
				v20 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(filenamesObj + 32))).Fptr2)).FspanLength
			} else {
				v20 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(filenamesObj + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = v20
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), filenamesObj, bp+40, bp+48)
		}
		i = 0
		for {
			if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 40))) {
				break
			}
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + uintptr(i)*8)))).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 64)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + uintptr(i)*8)))).Flength
				v22 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + uintptr(i)*8)))).Fbytes
			} else {
				v22 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + uintptr(i)*8)), bp+64)
			}
			oldStr = v22
			if *(*TTcl_Size)(unsafe.Pointer(bp + 64)) == *(*TTcl_Size)(unsafe.Pointer(bp + 56)) {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) == int32('\000') || libc.Xstrchr(tls, separators, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern)))) == libc.UintptrFromInt32(0) {
					if v23 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v23 {
						cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v23 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
						*(*uintptr)(unsafe.Pointer(bp + 72)) = XTclThreadAllocObj(tls)
					} else {
						*(*uintptr)(unsafe.Pointer(bp + 72)) = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)) + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)))).FrefCount = 0
					if libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1) == uint64(0) {
						(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
						(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)))).Flength = int64(libc.Int32FromInt32(0))
					} else {
						(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)))).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
						libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)))).Fbytes, __ccgo_ts+35293, libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1))
						*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)))).Fbytes + uintptr(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))) = uint8('\000')
						(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)))).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(2) - libc.Uint64FromInt32(1))
					}
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)))).FtypePtr = libc.UintptrFromInt32(0)
				} else {
					if v24 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v24 {
						cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v24 || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == libc.Uint64FromInt32(0) {
						*(*uintptr)(unsafe.Pointer(bp + 72)) = XTclThreadAllocObj(tls)
					} else {
						*(*uintptr)(unsafe.Pointer(bp + 72)) = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)) + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)))).FrefCount = 0
					if libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1) == uint64(0) {
						(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
						(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)))).Flength = int64(libc.Int32FromInt32(0))
					} else {
						(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)))).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
						libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)))).Fbytes, __ccgo_ts+6339, libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1))
						*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)))).Fbytes + uintptr(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))) = uint8('\000')
						(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)))).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(2) - libc.Uint64FromInt32(1))
					}
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)))).FtypePtr = libc.UintptrFromInt32(0)
				}
			} else {
				*(*uintptr)(unsafe.Pointer(bp + 72)) = XTcl_NewStringObj(tls, oldStr+uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 56))), *(*TTcl_Size)(unsafe.Pointer(bp + 64))-*(*TTcl_Size)(unsafe.Pointer(bp + 56)))
			}
			XTcl_ListObjReplace(tls, interp, filenamesObj, i, int64(1), int64(1), bp+72)
			goto _21
		_21:
			;
			i++
		}
	}
	/*
	 * Now we have a list of discovered filenames in filenamesObj and a list
	 * of previously discovered (saved earlier from the interpreter result) in
	 * savedResultObj. Merge them and put them back in the interpreter result.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(savedResultObj)).FrefCount > int64(1) {
		v26 = savedResultObj
		v25 = *(*TTcl_Size)(unsafe.Pointer(v26))
		*(*TTcl_Size)(unsafe.Pointer(v26))--
		if !(v25 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(savedResultObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(savedResultObj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(savedResultObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(savedResultObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(savedResultObj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(savedResultObj)).Flength = int64(-libc.Int32FromInt32(1))
				if v27 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v27 {
					cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v27 || ((*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, savedResultObj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(savedResultObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = savedResultObj
					(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, savedResultObj)
			}
		}
		savedResultObj = XTcl_DuplicateObj(tls, savedResultObj)
		(*TTcl_Obj)(unsafe.Pointer(savedResultObj)).FrefCount++
	}
	if XTcl_ListObjAppendList(tls, interp, savedResultObj, filenamesObj) != TCL_OK {
		result = int32(TCL_ERROR)
	} else {
		XTcl_SetObjResult(tls, interp, savedResultObj)
	}
	v29 = savedResultObj
	v28 = *(*TTcl_Size)(unsafe.Pointer(v29))
	*(*TTcl_Size)(unsafe.Pointer(v29))--
	if !(v28 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(savedResultObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(savedResultObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(savedResultObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(savedResultObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(savedResultObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(savedResultObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v30 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v30 {
				cachePtr6 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v30 || ((*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, savedResultObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(savedResultObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr = savedResultObj
				(*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, savedResultObj)
		}
	}
	v32 = filenamesObj
	v31 = *(*TTcl_Size)(unsafe.Pointer(v32))
	*(*TTcl_Size)(unsafe.Pointer(v32))--
	if !(v31 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(filenamesObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(filenamesObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(filenamesObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(filenamesObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(filenamesObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(filenamesObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v33 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v33 {
				cachePtr7 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v33 || ((*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, filenamesObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(filenamesObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr = filenamesObj
				(*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, filenamesObj)
		}
	}
	if pathPrefix != libc.UintptrFromInt32(0) {
		_objPtr4 = pathPrefix
		v35 = _objPtr4
		v34 = *(*TTcl_Size)(unsafe.Pointer(v35))
		*(*TTcl_Size)(unsafe.Pointer(v35))--
		if v34 <= int64(1) {
			XTclFreeObj(tls, _objPtr4)
		}
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * SkipToChar --
 *
 *	This function traverses a glob pattern looking for the next unquoted
 *	occurrence of the specified character at the same braces nesting level.
 *
 * Results:
 *	Updates stringPtr to point to the matching character, or to the end of
 *	the string if nothing matched. The return value is 1 if a match was
 *	found at the top level, otherwise it is 0.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _SkipToChar(tls *libc.TLS, stringPtr uintptr, match int32) (r int32) {
	/* Character to find. */
	var level, quoted int32
	var p uintptr
	_, _, _ = level, p, quoted
	quoted = 0
	level = 0
	p = *(*uintptr)(unsafe.Pointer(stringPtr))
	for {
		if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('\000')) {
			break
		}
		if quoted != 0 {
			quoted = 0
			goto _1
		}
		if level == 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == match {
			*(*uintptr)(unsafe.Pointer(stringPtr)) = p
			return int32(1)
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('{') {
			level++
		} else {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('}') {
				level--
			} else {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('\\') {
					quoted = int32(1)
				}
			}
		}
		goto _1
	_1:
		;
		p++
	}
	*(*uintptr)(unsafe.Pointer(stringPtr)) = p
	return 0
}

/*
 *----------------------------------------------------------------------
 *
 * DoGlob --
 *
 *	This recursive procedure forms the heart of the globbing code. It
 *	performs a depth-first traversal of the tree given by the path name to
 *	be globbed and the pattern. The directory and remainder are assumed to
 *	be native format paths. The prefix contained in 'pathPtr' is either a
 *	directory or path from which to start the search (or NULL). If pathPtr
 *	is NULL, then the pattern must not start with an absolute path
 *	specification (that case should be handled by moving the absolute path
 *	prefix into pathPtr before calling DoGlob).
 *
 * Results:
 *	The return value is a standard Tcl result indicating whether an error
 *	occurred in globbing. After a normal return the result in interp will
 *	be set to hold all of the file names given by the dir and remaining
 *	arguments. After an error the result in interp will hold an error
 *	message.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _DoGlob(tls *libc.TLS, interp uintptr, matchesObj uintptr, separators uintptr, pathPtr uintptr, flags int32, pattern uintptr, types uintptr) (r int32) {
	bp := tls.Alloc(576)
	defer tls.Free(576) /* List object containing list of acceptable
	 * types. May be NULL. */
	var _objPtr, _objPtr1, _objPtr2, bytes, cachePtr, cachePtr1, closeBrace, copy1, element, firstSpecialChar, joined, joined1, joinedPtr, name, openBrace, subdirsPtr, v11, v14, v16, v19, v2, v21, v22, v24 uintptr
	var baseLength, quoted, result, v6 int32
	var i, repair, v10, v15, v20, v23 TTcl_Size
	var save, savedChar uint8
	var v13, v7, v8 int64
	var v17, v5 bool
	var _ /* append at bp+288 */ TTcl_DString
	var _ /* end at bp+248 */ TTcl_Size
	var _ /* fixme at bp+264 */ uintptr
	var _ /* len at bp+512 */ TTcl_Size
	var _ /* len at bp+520 */ TTcl_Size
	var _ /* length at bp+280 */ TTcl_Size
	var _ /* newName at bp+8 */ TTcl_DString
	var _ /* newObj at bp+272 */ uintptr
	var _ /* numBytes at bp+256 */ TTcl_Size
	var _ /* p at bp+0 */ uintptr
	var _ /* subdirc at bp+232 */ TTcl_Size
	var _ /* subdirv at bp+240 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, baseLength, bytes, cachePtr, cachePtr1, closeBrace, copy1, element, firstSpecialChar, i, joined, joined1, joinedPtr, name, openBrace, quoted, repair, result, save, savedChar, subdirsPtr, v10, v11, v13, v14, v15, v16, v17, v19, v2, v20, v21, v22, v23, v24, v5, v6, v7, v8
	result = TCL_OK
	/*
	 * Consume any leading directory separators, leaving pattern pointing just
	 * past the last initial separator.
	 */
	name = pattern
	for {
		if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) != int32('\000')) {
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) == int32('\\') {
			/*
			 * If the first character is escaped, either we have a directory
			 * separator, or we have any other character. In the latter case
			 * the rest is a pattern, and we must break from the loop. This
			 * is particularly important on Windows where '\' is both the
			 * escaping character and a directory separator.
			 */
			if libc.Xstrchr(tls, separators, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern + 1)))) != libc.UintptrFromInt32(0) {
				pattern++
			} else {
				break
			}
		} else {
			if libc.Xstrchr(tls, separators, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern)))) == libc.UintptrFromInt32(0) {
				break
			}
		}
		goto _1
	_1:
		;
		pattern++
	}
	/*
	 * Look for the first matching pair of braces or the first directory
	 * separator that is not inside a pair of braces.
	 */
	v2 = libc.UintptrFromInt32(0)
	closeBrace = v2
	openBrace = v2
	quoted = 0
	*(*uintptr)(unsafe.Pointer(bp)) = pattern
	for {
		if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32('\000')) {
			break
		}
		if quoted != 0 {
			quoted = 0
		} else {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('\\') {
				quoted = int32(1)
				if libc.Xstrchr(tls, separators, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))) != libc.UintptrFromInt32(0) {
					/*
					 * Quoted directory separator.
					 */
					break
				}
			} else {
				if libc.Xstrchr(tls, separators, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))) != libc.UintptrFromInt32(0) {
					/*
					 * Unquoted directory separator.
					 */
					break
				} else {
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('{') {
						openBrace = *(*uintptr)(unsafe.Pointer(bp))
						*(*uintptr)(unsafe.Pointer(bp))++
						if _SkipToChar(tls, bp, int32('}')) != 0 {
							/*
							 * Balanced braces.
							 */
							closeBrace = *(*uintptr)(unsafe.Pointer(bp))
							break
						}
						XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+35295, int64(-int32(1))))
						XTcl_SetErrorCode(tls, interp, libc.VaList(bp+536, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+34870, __ccgo_ts+35329, libc.UintptrFromInt32(0)))
						return int32(TCL_ERROR)
					} else {
						if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('}') {
							XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+35337, int64(-int32(1))))
							XTcl_SetErrorCode(tls, interp, libc.VaList(bp+536, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+34870, __ccgo_ts+35329, libc.UintptrFromInt32(0)))
							return int32(TCL_ERROR)
						}
					}
				}
			}
		}
		goto _3
	_3:
		;
		*(*uintptr)(unsafe.Pointer(bp))++
	}
	/*
	 * Substitute the alternate patterns from the braces and recurse.
	 */
	if openBrace != libc.UintptrFromInt32(0) {
		XTcl_DStringInit(tls, bp+8)
		/*
		 * For each element within in the outermost pair of braces, append the
		 * element and the remainder to the fixed portion before the first
		 * brace and recursively call DoGlob.
		 */
		XTcl_DStringAppend(tls, bp+8, pattern, int64(openBrace)-int64(pattern))
		baseLength = int32((*TTcl_DString)(unsafe.Pointer(bp + 8)).Flength)
		*(*uint8)(unsafe.Pointer(closeBrace)) = uint8('\000')
		*(*uintptr)(unsafe.Pointer(bp)) = openBrace
		for {
			if !(*(*uintptr)(unsafe.Pointer(bp)) != closeBrace) {
				break
			}
			*(*uintptr)(unsafe.Pointer(bp))++
			element = *(*uintptr)(unsafe.Pointer(bp))
			_SkipToChar(tls, bp, int32(','))
			XTcl_DStringSetLength(tls, bp+8, int64(baseLength))
			XTcl_DStringAppend(tls, bp+8, element, int64(*(*uintptr)(unsafe.Pointer(bp)))-int64(element))
			XTcl_DStringAppend(tls, bp+8, closeBrace+uintptr(1), int64(-int32(1)))
			result = _DoGlob(tls, interp, matchesObj, separators, pathPtr, flags, (*TTcl_DString)(unsafe.Pointer(bp+8)).Fstring1, types)
			if result != TCL_OK {
				break
			}
			goto _4
		_4:
		}
		*(*uint8)(unsafe.Pointer(closeBrace)) = uint8('}')
		XTcl_DStringFree(tls, bp+8)
		return result
	}
	/*
	 * At this point, there are no more brace substitutions to perform on this
	 * path component. The variable p is pointing at a quoted or unquoted
	 * directory separator or the end of the string. So we need to check for
	 * special globbing characters in the current pattern. We avoid modifying
	 * pattern if p is pointing at the end of the string.
	 *
	 * If we find any globbing characters, then we must call
	 * Tcl_FSMatchInDirectory. If we're at the end of the string, then that's
	 * all we need to do. If we're not at the end of the string, then we must
	 * recurse, so we do that below.
	 *
	 * Alternatively, if there are no globbing characters then again there are
	 * two cases. If we're at the end of the string, we just need to check for
	 * the given path's existence and type. If we're not at the end of the
	 * string, we recurse.
	 */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32('\000') {
		savedChar = *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))
		/*
		 * Note that we are modifying the string in place. This won't work if
		 * the string is a static.
		 */
		*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) = uint8('\000')
		firstSpecialChar = libc.Xstrpbrk(tls, pattern, __ccgo_ts+35372)
		*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) = savedChar
	} else {
		firstSpecialChar = libc.Xstrpbrk(tls, pattern, __ccgo_ts+35372)
	}
	if firstSpecialChar != libc.UintptrFromInt32(0) {
		save = *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('\000') {
			return XTcl_FSMatchInDirectory(tls, interp, matchesObj, pathPtr, pattern, types)
		}
		/*
		 * We do the recursion ourselves. This makes implementing
		 * Tcl_FSMatchInDirectory for each filesystem much easier.
		 */
		*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) = uint8('\000')
		if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v5 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			subdirsPtr = XTclThreadAllocObj(tls)
		} else {
			subdirsPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(subdirsPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(subdirsPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(subdirsPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(subdirsPtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(subdirsPtr)).FtypePtr = libc.UintptrFromInt32(0)
		(*TTcl_Obj)(unsafe.Pointer(subdirsPtr)).FrefCount++
		result = XTcl_FSMatchInDirectory(tls, interp, subdirsPtr, pathPtr, pattern, uintptr(unsafe.Pointer(&_dirOnly)))
		*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) = save
		if result == TCL_OK {
			repair = int64(-int32(1))
			if (*TTcl_Obj)(unsafe.Pointer(subdirsPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(subdirsPtr + 32))).Fptr2 != 0 {
					v7 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(subdirsPtr + 32))).Fptr2)).FspanStart
				} else {
					v7 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(subdirsPtr + 32))).Fptr1)).FfirstUsed
				}
				*(*uintptr)(unsafe.Pointer(bp + 240)) = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(subdirsPtr + 32))).Fptr1 + 40 + uintptr(v7)*8
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(subdirsPtr + 32))).Fptr2 != 0 {
					v8 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(subdirsPtr + 32))).Fptr2)).FspanLength
				} else {
					v8 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(subdirsPtr + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp + 232)) = v8
				v6 = libc.Int32FromInt32(TCL_OK)
			} else {
				v6 = XTcl_ListObjGetElements(tls, interp, subdirsPtr, bp+232, bp+240)
			}
			result = v6
			i = 0
			for {
				if !(result == TCL_OK && i < *(*TTcl_Size)(unsafe.Pointer(bp + 232))) {
					break
				}
				copy1 = libc.UintptrFromInt32(0)
				result = _DoGlob(tls, interp, matchesObj, separators, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 240)) + uintptr(i)*8)), int32(1), *(*uintptr)(unsafe.Pointer(bp))+uintptr(1), types)
				if copy1 != 0 {
					_objPtr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 240)) + uintptr(i)*8))
					v11 = _objPtr
					v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
					*(*TTcl_Size)(unsafe.Pointer(v11))--
					if v10 <= int64(1) {
						XTclFreeObj(tls, _objPtr)
					}
					*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 240)) + uintptr(i)*8)) = copy1
					if (*TTcl_Obj)(unsafe.Pointer(matchesObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
						if (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(matchesObj + 32))).Fptr2 != 0 {
							v13 = (*TListSpan)(unsafe.Pointer((*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(matchesObj + 32))).Fptr2)).FspanLength
						} else {
							v13 = (*TListStore)(unsafe.Pointer((*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(matchesObj + 32))).Fptr1)).FnumUsed
						}
						*(*TTcl_Size)(unsafe.Pointer(bp + 248)) = v13
						_ = libc.Int32FromInt32(TCL_OK)
					} else {
						XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), matchesObj, bp+248)
					}
					for repair < *(*TTcl_Size)(unsafe.Pointer(bp + 248)) {
						XTcl_ListObjIndex(tls, libc.UintptrFromInt32(0), matchesObj, repair, bp+264)
						if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 264)))).Fbytes != 0 {
							*(*TTcl_Size)(unsafe.Pointer(bp + 256)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 264)))).Flength
							v14 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 264)))).Fbytes
						} else {
							v14 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 264)), bp+256)
						}
						bytes = v14
						*(*uintptr)(unsafe.Pointer(bp + 272)) = XTcl_NewStringObj(tls, bytes+uintptr(2), *(*TTcl_Size)(unsafe.Pointer(bp + 256))-int64(2))
						XTcl_ListObjReplace(tls, libc.UintptrFromInt32(0), matchesObj, repair, int64(1), int64(1), bp+272)
						repair++
					}
					repair = int64(-libc.Int32FromInt32(1))
				}
				goto _9
			_9:
				;
				i++
			}
		}
		v16 = subdirsPtr
		v15 = *(*TTcl_Size)(unsafe.Pointer(v16))
		*(*TTcl_Size)(unsafe.Pointer(v16))--
		if !(v15 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(subdirsPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(subdirsPtr)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(subdirsPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(subdirsPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(subdirsPtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(subdirsPtr)).Flength = int64(-libc.Int32FromInt32(1))
				if v17 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v17 {
					cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v17 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, subdirsPtr)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(subdirsPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = subdirsPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, subdirsPtr)
			}
		}
		return result
	}
	/*
	 * We reach here with no pattern char in current section
	 */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('\000') {
		/*
		 * This is the code path reached by a command like 'glob foo'.
		 *
		 * There are no more wildcards in the pattern and no more unprocessed
		 * characters in the pattern, so now we can construct the path, and
		 * pass it to Tcl_FSMatchInDirectory with an empty pattern to verify
		 * the existence of the file and check it is of the correct type (if a
		 * 'types' flag it given -- if no such flag was given, we could just
		 * use 'Tcl_FSLStat', but for simplicity we keep to a common
		 * approach).
		 */
		XTcl_DStringInit(tls, bp+288)
		XTcl_DStringAppend(tls, bp+288, pattern, int64(*(*uintptr)(unsafe.Pointer(bp)))-int64(pattern))
		if pathPtr != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 280)) = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Flength
				_ = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
			} else {
				XTcl_GetStringFromObj(tls, pathPtr, bp+280)
			}
		} else {
			*(*TTcl_Size)(unsafe.Pointer(bp + 280)) = 0
		}
		switch XtclPlatform {
		case int32(TCL_PLATFORM_WINDOWS):
			if *(*TTcl_Size)(unsafe.Pointer(bp + 280)) == 0 && (*TTcl_DString)(unsafe.Pointer(bp+288)).Flength == 0 {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32('\\') && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name + 1))) == int32('/') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name + 1))) == int32('\\')) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32('/') {
					XTcl_DStringAppend(tls, bp+288, __ccgo_ts+6339, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))
				} else {
					XTcl_DStringAppend(tls, bp+288, __ccgo_ts+35293, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))
				}
			}
		case int32(TCL_PLATFORM_UNIX):
			if *(*TTcl_Size)(unsafe.Pointer(bp + 280)) == 0 && (*TTcl_DString)(unsafe.Pointer(bp+288)).Flength == 0 {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32('\\') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name + 1))) == int32('/') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32('/') {
					XTcl_DStringAppend(tls, bp+288, __ccgo_ts+6339, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))
				} else {
					XTcl_DStringAppend(tls, bp+288, __ccgo_ts+35293, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))
				}
			}
			break
		}
		/*
		 * Common for all platforms.
		 */
		if pathPtr == libc.UintptrFromInt32(0) {
			joinedPtr = XTcl_DStringToObj(tls, bp+288)
		} else {
			if flags != 0 {
				joinedPtr = XTclNewFSPathObj(tls, pathPtr, (*TTcl_DString)(unsafe.Pointer(bp+288)).Fstring1, (*TTcl_DString)(unsafe.Pointer(bp+288)).Flength)
			} else {
				joinedPtr = XTcl_DuplicateObj(tls, pathPtr)
				if libc.Xstrchr(tls, separators, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_DString)(unsafe.Pointer(bp + 288)).Fstring1)))) == libc.UintptrFromInt32(0) {
					if (*TTcl_Obj)(unsafe.Pointer(joinedPtr)).Fbytes != 0 {
						*(*TTcl_Size)(unsafe.Pointer(bp + 512)) = (*TTcl_Obj)(unsafe.Pointer(joinedPtr)).Flength
						v19 = (*TTcl_Obj)(unsafe.Pointer(joinedPtr)).Fbytes
					} else {
						v19 = XTcl_GetStringFromObj(tls, joinedPtr, bp+512)
					}
					joined = v19
					if *(*TTcl_Size)(unsafe.Pointer(bp + 512)) > 0 && libc.Xstrchr(tls, separators, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(joined + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 512))-int64(1)))))) == libc.UintptrFromInt32(0) {
						XTcl_AppendToObj(tls, joinedPtr, __ccgo_ts+6339, int64(1))
					}
				}
				XTcl_AppendToObj(tls, joinedPtr, (*TTcl_DString)(unsafe.Pointer(bp+288)).Fstring1, (*TTcl_DString)(unsafe.Pointer(bp+288)).Flength)
			}
		}
		(*TTcl_Obj)(unsafe.Pointer(joinedPtr)).FrefCount++
		XTcl_DStringFree(tls, bp+288)
		result = XTcl_FSMatchInDirectory(tls, interp, matchesObj, joinedPtr, libc.UintptrFromInt32(0), types)
		_objPtr1 = joinedPtr
		v21 = _objPtr1
		v20 = *(*TTcl_Size)(unsafe.Pointer(v21))
		*(*TTcl_Size)(unsafe.Pointer(v21))--
		if v20 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		return result
	}
	/*
	 * If it's not the end of the string, we must recurse
	 */
	if pathPtr == libc.UintptrFromInt32(0) {
		joinedPtr = XTcl_NewStringObj(tls, pattern, int64(*(*uintptr)(unsafe.Pointer(bp)))-int64(pattern))
	} else {
		if flags != 0 {
			joinedPtr = XTclNewFSPathObj(tls, pathPtr, pattern, int64(*(*uintptr)(unsafe.Pointer(bp)))-int64(pattern))
		} else {
			joinedPtr = XTcl_DuplicateObj(tls, pathPtr)
			if libc.Xstrchr(tls, separators, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern)))) == libc.UintptrFromInt32(0) {
				if (*TTcl_Obj)(unsafe.Pointer(joinedPtr)).Fbytes != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp + 520)) = (*TTcl_Obj)(unsafe.Pointer(joinedPtr)).Flength
					v22 = (*TTcl_Obj)(unsafe.Pointer(joinedPtr)).Fbytes
				} else {
					v22 = XTcl_GetStringFromObj(tls, joinedPtr, bp+520)
				}
				joined1 = v22
				if *(*TTcl_Size)(unsafe.Pointer(bp + 520)) > 0 && libc.Xstrchr(tls, separators, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(joined1 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 520))-int64(1)))))) == libc.UintptrFromInt32(0) {
					if XTcl_FSGetPathType(tls, pathPtr) != int32(TCL_PATH_VOLUME_RELATIVE) {
						XTcl_AppendToObj(tls, joinedPtr, __ccgo_ts+6339, int64(1))
					}
				}
			}
			XTcl_AppendToObj(tls, joinedPtr, pattern, int64(*(*uintptr)(unsafe.Pointer(bp)))-int64(pattern))
		}
	}
	(*TTcl_Obj)(unsafe.Pointer(joinedPtr)).FrefCount++
	result = _DoGlob(tls, interp, matchesObj, separators, joinedPtr, int32(1), *(*uintptr)(unsafe.Pointer(bp)), types)
	_objPtr2 = joinedPtr
	v24 = _objPtr2
	v23 = *(*TTcl_Size)(unsafe.Pointer(v24))
	*(*TTcl_Size)(unsafe.Pointer(v24))--
	if v23 <= int64(1) {
		XTclFreeObj(tls, _objPtr2)
	}
	return result
}

/*
 * Look for matching files in the given directory. The implementation
 * of this function is filesystem specific. For each file that
 * matches, it will add the match onto the resultPtr given.
 */

var _dirOnly = TTcl_GlobTypeData{
	Ftype1: libc.Int32FromInt32(1) << libc.Int32FromInt32(2),
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_AllocStatBuf --
 *
 *	This procedure allocates a Tcl_StatBuf on the heap. It exists so that
 *	extensions may be used unchanged on systems where largefile support is
 *	optional.
 *
 * Results:
 *	A pointer to a Tcl_StatBuf which may be deallocated by being passed to
 *	Tcl_Free().
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_AllocStatBuf(tls *libc.TLS) (r uintptr) {
	return XTcl_Alloc(tls, uint64(144))
}

/*
 *---------------------------------------------------------------------------
 *
 * Access functions for Tcl_StatBuf --
 *
 *	These functions provide portable read-only access to the portable
 *	fields of the Tcl_StatBuf structure (really a 'struct stat'
 *	or something else related). [TIP #316]
 *
 * Results:
 *	The value from the field being retrieved.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_GetFSDeviceFromStat(tls *libc.TLS, statPtr uintptr) (r uint32) {
	return uint32((*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_dev)
}

func XTcl_GetFSInodeFromStat(tls *libc.TLS, statPtr uintptr) (r uint32) {
	return uint32((*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_ino)
}

func XTcl_GetModeFromStat(tls *libc.TLS, statPtr uintptr) (r uint32) {
	return (*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_mode
}

func XTcl_GetLinkCountFromStat(tls *libc.TLS, statPtr uintptr) (r int32) {
	return libc.Int32FromUint64((*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_nlink)
}

func XTcl_GetUserIdFromStat(tls *libc.TLS, statPtr uintptr) (r int32) {
	return libc.Int32FromUint32((*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_uid)
}

func XTcl_GetGroupIdFromStat(tls *libc.TLS, statPtr uintptr) (r int32) {
	return libc.Int32FromUint32((*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_gid)
}

func XTcl_GetDeviceTypeFromStat(tls *libc.TLS, statPtr uintptr) (r int32) {
	return libc.Int32FromUint64((*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_rdev)
}

func XTcl_GetAccessTimeFromStat(tls *libc.TLS, statPtr uintptr) (r int64) {
	return (*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_atim.Ftv_sec
}

func XTcl_GetModificationTimeFromStat(tls *libc.TLS, statPtr uintptr) (r int64) {
	return (*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_mtim.Ftv_sec
}

func XTcl_GetChangeTimeFromStat(tls *libc.TLS, statPtr uintptr) (r int64) {
	return (*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_ctim.Ftv_sec
}

func XTcl_GetSizeFromStat(tls *libc.TLS, statPtr uintptr) (r uint64) {
	return libc.Uint64FromInt64((*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_size)
}

func XTcl_GetBlocksFromStat(tls *libc.TLS, statPtr uintptr) (r uint64) {
	return libc.Uint64FromInt64((*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_blocks)
}

func XTcl_GetBlockSizeFromStat(tls *libc.TLS, statPtr uintptr) (r uint32) {
	return libc.Uint32FromInt64((*TTcl_StatBuf)(unsafe.Pointer(statPtr)).Fst_blksize)
}

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetInt --
 *
 *	Given a string, produce the corresponding integer value.
 *
 * Results:
 *	The return value is normally TCL_OK; in this case *intPtr will be set
 *	to the integer value equivalent to src.  If src is improperly formed
 *	then TCL_ERROR is returned and an error message will be left in the
 *	interp's result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetInt(tls *libc.TLS, interp uintptr, src uintptr, intPtr uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Place to store converted result. */
	var code int32
	var _ /* obj at bp+0 */ TTcl_Obj
	_ = code
	(*(*TTcl_Obj)(unsafe.Pointer(bp))).FrefCount = int64(1)
	(*(*TTcl_Obj)(unsafe.Pointer(bp))).Fbytes = src
	(*(*TTcl_Obj)(unsafe.Pointer(bp))).Flength = libc.Int64FromUint64(libc.Xstrlen(tls, src))
	(*(*TTcl_Obj)(unsafe.Pointer(bp))).FtypePtr = libc.UintptrFromInt32(0)
	code = XTcl_GetIntFromObj(tls, interp, bp, intPtr)
	if (*(*TTcl_Obj)(unsafe.Pointer(bp))).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+35378, 0)
	}
	if (*TTcl_Obj)(unsafe.Pointer(bp)).FtypePtr != libc.UintptrFromInt32(0) {
		if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(bp)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(bp)).FtypePtr)).FfreeIntRepProc})))(tls, bp)
		}
		(*TTcl_Obj)(unsafe.Pointer(bp)).FtypePtr = libc.UintptrFromInt32(0)
	}
	return code
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetDouble --
 *
 *	Given a string, produce the corresponding double-precision
 *	floating-point value.
 *
 * Results:
 *	The return value is normally TCL_OK; in this case *doublePtr will be
 *	set to the double-precision value equivalent to src. If src is
 *	improperly formed then TCL_ERROR is returned and an error message will
 *	be left in the interp's result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetDouble(tls *libc.TLS, interp uintptr, src uintptr, doublePtr uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Place to store converted result. */
	var code int32
	var _ /* obj at bp+0 */ TTcl_Obj
	_ = code
	(*(*TTcl_Obj)(unsafe.Pointer(bp))).FrefCount = int64(1)
	(*(*TTcl_Obj)(unsafe.Pointer(bp))).Fbytes = src
	(*(*TTcl_Obj)(unsafe.Pointer(bp))).Flength = libc.Int64FromUint64(libc.Xstrlen(tls, src))
	(*(*TTcl_Obj)(unsafe.Pointer(bp))).FtypePtr = libc.UintptrFromInt32(0)
	code = XTcl_GetDoubleFromObj(tls, interp, bp, doublePtr)
	if (*(*TTcl_Obj)(unsafe.Pointer(bp))).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+35378, 0)
	}
	if (*TTcl_Obj)(unsafe.Pointer(bp)).FtypePtr != libc.UintptrFromInt32(0) {
		if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(bp)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(bp)).FtypePtr)).FfreeIntRepProc})))(tls, bp)
		}
		(*TTcl_Obj)(unsafe.Pointer(bp)).FtypePtr = libc.UintptrFromInt32(0)
	}
	return code
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetBoolean --
 *
 *	Given a string, return a 0/1 boolean value corresponding to the
 *	string.
 *
 * Results:
 *	The return value is normally TCL_OK; in this case *charPtr will be set
 *	to the 0/1 value equivalent to src. If src is improperly formed then
 *	TCL_ERROR is returned and an error message will be left in the
 *	interp's result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetBool(tls *libc.TLS, interp uintptr, src uintptr, flags int32, charPtr uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Place to store converted result, which will
	 * be 0 or 1. */
	var code int32
	var _ /* obj at bp+0 */ TTcl_Obj
	_ = code
	if src == libc.UintptrFromInt32(0) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) == int32('\000') {
		return XTcl_GetBoolFromObj(tls, interp, libc.UintptrFromInt32(0), flags, charPtr)
	}
	(*(*TTcl_Obj)(unsafe.Pointer(bp))).FrefCount = int64(1)
	(*(*TTcl_Obj)(unsafe.Pointer(bp))).Fbytes = src
	(*(*TTcl_Obj)(unsafe.Pointer(bp))).Flength = libc.Int64FromUint64(libc.Xstrlen(tls, src))
	(*(*TTcl_Obj)(unsafe.Pointer(bp))).FtypePtr = libc.UintptrFromInt32(0)
	code = XTclSetBooleanFromAny(tls, interp, bp)
	if (*(*TTcl_Obj)(unsafe.Pointer(bp))).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+35378, 0)
	}
	if code == TCL_OK {
		XTcl_GetBoolFromObj(tls, libc.UintptrFromInt32(0), bp, flags, charPtr)
	}
	return code
}

func XTcl_GetBoolean(tls *libc.TLS, interp uintptr, src uintptr, intPtr uintptr) (r int32) {
	/* Place to store converted result, which will
	 * be 0 or 1. */
	return XTcl_GetBool(tls, interp, src, (libc.Int32FromInt32(TCL_NULL_OK)-libc.Int32FromInt32(2))&libc.Int32FromInt64(4), intPtr)
}

const NUM_COUNTERS = 10
const REBUILD_MULTIPLIER = 3

func init() {
	p := unsafe.Pointer(&XtclArrayHashKeyType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_HashArrayKey)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_CompareArrayKeys)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_AllocArrayEntry)
}

func init() {
	p := unsafe.Pointer(&XtclStringHashKeyType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(XTclHashStringKey)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(XTclCompareStringKeys)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_AllocStringEntry)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_InitHashTable --
 *
 *	Given storage for a hash table, set up the fields to prepare the hash
 *	table for use.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	TablePtr is now ready to be passed to Tcl_FindHashEntry and
 *	Tcl_CreateHashEntry.
 *
 *----------------------------------------------------------------------
 */

func XTcl_InitHashTable(tls *libc.TLS, tablePtr uintptr, keyType int32) {
	/* Type of keys to use in table:
	 * TCL_STRING_KEYS, TCL_ONE_WORD_KEYS, or an
	 * integer >= 2. */
	/*
	 * Use a special value to inform the extended version that it must not
	 * access any of the new fields in the Tcl_HashTable. If an extension is
	 * rebuilt then any calls to this function will be redirected to the
	 * extended version by a macro.
	 */
	XTcl_InitCustomHashTable(tls, tablePtr, keyType, uintptr(-libc.Int32FromInt32(1)))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_InitCustomHashTable --
 *
 *	Given storage for a hash table, set up the fields to prepare the hash
 *	table for use. This is an extended version of Tcl_InitHashTable which
 *	supports user defined keys.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	TablePtr is now ready to be passed to Tcl_FindHashEntry and
 *	Tcl_CreateHashEntry.
 *
 *----------------------------------------------------------------------
 */

func XTcl_InitCustomHashTable(tls *libc.TLS, tablePtr uintptr, keyType int32, typePtr uintptr) {
	/* Pointer to structure which defines the
	 * behaviour of this table. */
	var v1, v2 uintptr
	_, _ = v1, v2
	(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).Fbuckets = tablePtr + 8
	v1 = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(tablePtr + 8 + 1*8)) = v1
	*(*uintptr)(unsafe.Pointer(tablePtr + 8)) = v1
	v2 = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(tablePtr + 8 + 3*8)) = v2
	*(*uintptr)(unsafe.Pointer(tablePtr + 8 + 2*8)) = v2
	(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FnumBuckets = int64(TCL_SMALL_HASH_TABLE)
	(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FnumEntries = 0
	(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FrebuildSize = int64(libc.Int32FromInt32(TCL_SMALL_HASH_TABLE) * libc.Int32FromInt32(REBUILD_MULTIPLIER))
	(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FdownShift = int32(28)
	(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).Fmask = uint64(3)
	(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FkeyType = keyType
	(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FfindProc = __ccgo_fp(_FindHashEntry)
	(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FcreateProc = __ccgo_fp(_CreateHashEntry)
	if typePtr == libc.UintptrFromInt32(0) {
		/*
		 * The caller has been rebuilt so the hash table is an extended
		 * version.
		 */
	} else {
		if typePtr != uintptr(-libc.Int32FromInt32(1)) {
			/*
			 * The caller is requesting a customized hash table so it must be an
			 * extended version.
			 */
			(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FtypePtr = typePtr
		} else {
			/*
			 * The caller has not been rebuilt so the hash table is not extended.
			 */
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * FindHashEntry --
 *
 *	Given a hash table find the entry with a matching key.
 *
 * Results:
 *	The return value is a token for the matching entry in the hash table,
 *	or NULL if there was no matching entry.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _FindHashEntry(tls *libc.TLS, tablePtr uintptr, key uintptr) (r uintptr) {
	/* Key to use to find matching entry. */
	return _CreateHashEntry(tls, tablePtr, key, libc.UintptrFromInt32(0))
}

/*
 *----------------------------------------------------------------------
 *
 * CreateHashEntry --
 *
 *	Given a hash table with string keys, and a string key, find the entry
 *	with a matching key. If there is no matching entry, then create a new
 *	entry that does match.
 *
 * Results:
 *	The return value is a pointer to the matching entry. If this is a
 *	newly-created entry, then *newPtr will be set to a non-zero value;
 *	otherwise *newPtr will be set to 0. If this is a new entry the value
 *	stored in the entry will initially be 0.
 *
 * Side effects:
 *	A new entry may be added to the hash table.
 *
 *----------------------------------------------------------------------
 */

func _CreateHashEntry(tls *libc.TLS, tablePtr uintptr, key uintptr, newPtr uintptr) (r uintptr) {
	/* Store info here telling whether a new entry
	 * was created. */
	var compareKeysProc, hPtr, typePtr uintptr
	var hash, index Tsize_t
	_, _, _, _, _ = compareKeysProc, hPtr, hash, index, typePtr
	if (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FkeyType == TCL_STRING_KEYS {
		typePtr = uintptr(unsafe.Pointer(&XtclStringHashKeyType))
	} else {
		if (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FkeyType == int32(TCL_ONE_WORD_KEYS) {
			typePtr = uintptr(unsafe.Pointer(&XtclOneWordHashKeyType))
		} else {
			if (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FkeyType == -int32(2) || (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FkeyType == -int32(1) {
				typePtr = (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FtypePtr
			} else {
				typePtr = uintptr(unsafe.Pointer(&XtclArrayHashKeyType))
			}
		}
	}
	if (*TTcl_HashKeyType)(unsafe.Pointer(typePtr)).FhashKeyProc != 0 {
		hash = (*(*func(*libc.TLS, uintptr, uintptr) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashKeyType)(unsafe.Pointer(typePtr)).FhashKeyProc})))(tls, tablePtr, key)
		if (*TTcl_HashKeyType)(unsafe.Pointer(typePtr)).Fflags&int32(TCL_HASH_KEY_RANDOMIZE_HASH) != 0 {
			index = hash * libc.Uint64FromInt32(1103515245) >> (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FdownShift & (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).Fmask
		} else {
			index = hash & (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).Fmask
		}
	} else {
		hash = uint64(key)
		index = hash * libc.Uint64FromInt32(1103515245) >> (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FdownShift & (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).Fmask
	}
	/*
	 * Search all of the entries in the appropriate bucket.
	 */
	if (*TTcl_HashKeyType)(unsafe.Pointer(typePtr)).FcompareKeysProc != 0 {
		compareKeysProc = (*TTcl_HashKeyType)(unsafe.Pointer(typePtr)).FcompareKeysProc
		if (*TTcl_HashKeyType)(unsafe.Pointer(typePtr)).Fflags&int32(TCL_HASH_KEY_DIRECT_COMPARE) != 0 {
			hPtr = *(*uintptr)(unsafe.Pointer((*TTcl_HashTable)(unsafe.Pointer(tablePtr)).Fbuckets + uintptr(index)*8))
			for {
				if !(hPtr != libc.UintptrFromInt32(0)) {
					break
				}
				if hash != (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).Fhash {
					goto _1
				}
				/* if keys pointers or values are equal */
				if key == *(*uintptr)(unsafe.Pointer(hPtr + 32)) || (*(*func(*libc.TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{compareKeysProc})))(tls, key, hPtr) != 0 {
					if newPtr != 0 {
						*(*int32)(unsafe.Pointer(newPtr)) = 0
					}
					return hPtr
				}
				goto _1
			_1:
				;
				hPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FnextPtr
			}
		} else { /* no direct compare - compare key addresses only */
			hPtr = *(*uintptr)(unsafe.Pointer((*TTcl_HashTable)(unsafe.Pointer(tablePtr)).Fbuckets + uintptr(index)*8))
			for {
				if !(hPtr != libc.UintptrFromInt32(0)) {
					break
				}
				if hash != (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).Fhash {
					goto _2
				}
				/* if needle pointer equals content pointer or values equal */
				if key == hPtr+32 || (*(*func(*libc.TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{compareKeysProc})))(tls, key, hPtr) != 0 {
					if newPtr != 0 {
						*(*int32)(unsafe.Pointer(newPtr)) = 0
					}
					return hPtr
				}
				goto _2
			_2:
				;
				hPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FnextPtr
			}
		}
	} else {
		hPtr = *(*uintptr)(unsafe.Pointer((*TTcl_HashTable)(unsafe.Pointer(tablePtr)).Fbuckets + uintptr(index)*8))
		for {
			if !(hPtr != libc.UintptrFromInt32(0)) {
				break
			}
			if hash != (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).Fhash {
				goto _3
			}
			if key == *(*uintptr)(unsafe.Pointer(hPtr + 32)) {
				if newPtr != 0 {
					*(*int32)(unsafe.Pointer(newPtr)) = 0
				}
				return hPtr
			}
			goto _3
		_3:
			;
			hPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FnextPtr
		}
	}
	if !(newPtr != 0) {
		return libc.UintptrFromInt32(0)
	}
	/*
	 * Entry not found. Add a new one to the bucket.
	 */
	*(*int32)(unsafe.Pointer(newPtr)) = int32(1)
	if (*TTcl_HashKeyType)(unsafe.Pointer(typePtr)).FallocEntryProc != 0 {
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashKeyType)(unsafe.Pointer(typePtr)).FallocEntryProc})))(tls, tablePtr, key)
	} else {
		hPtr = XTcl_Alloc(tls, uint64(40))
		*(*uintptr)(unsafe.Pointer(hPtr + 32)) = key
		(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = libc.UintptrFromInt32(0)
	}
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FtablePtr = tablePtr
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).Fhash = hash
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FnextPtr = *(*uintptr)(unsafe.Pointer((*TTcl_HashTable)(unsafe.Pointer(tablePtr)).Fbuckets + uintptr(index)*8))
	*(*uintptr)(unsafe.Pointer((*TTcl_HashTable)(unsafe.Pointer(tablePtr)).Fbuckets + uintptr(index)*8)) = hPtr
	(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FnumEntries++
	/*
	 * If the table has exceeded a decent size, rebuild it with many more
	 * buckets.
	 */
	if (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FnumEntries >= (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FrebuildSize {
		_RebuildTable(tls, tablePtr)
	}
	return hPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DeleteHashEntry --
 *
 *	Remove a single entry from a hash table.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The entry given by entryPtr is deleted from its table and should never
 *	again be used by the caller. It is up to the caller to free the
 *	clientData field of the entry, if that is relevant.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DeleteHashEntry(tls *libc.TLS, entryPtr uintptr) {
	var bucketPtr, prevPtr, tablePtr, typePtr uintptr
	var index Tsize_t
	_, _, _, _, _ = bucketPtr, index, prevPtr, tablePtr, typePtr
	tablePtr = (*TTcl_HashEntry)(unsafe.Pointer(entryPtr)).FtablePtr
	if (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FkeyType == TCL_STRING_KEYS {
		typePtr = uintptr(unsafe.Pointer(&XtclStringHashKeyType))
	} else {
		if (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FkeyType == int32(TCL_ONE_WORD_KEYS) {
			typePtr = uintptr(unsafe.Pointer(&XtclOneWordHashKeyType))
		} else {
			if (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FkeyType == -int32(2) || (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FkeyType == -int32(1) {
				typePtr = (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FtypePtr
			} else {
				typePtr = uintptr(unsafe.Pointer(&XtclArrayHashKeyType))
			}
		}
	}
	if (*TTcl_HashKeyType)(unsafe.Pointer(typePtr)).FhashKeyProc == libc.UintptrFromInt32(0) || (*TTcl_HashKeyType)(unsafe.Pointer(typePtr)).Fflags&int32(TCL_HASH_KEY_RANDOMIZE_HASH) != 0 {
		index = (*TTcl_HashEntry)(unsafe.Pointer(entryPtr)).Fhash * libc.Uint64FromInt32(1103515245) >> (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FdownShift & (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).Fmask
	} else {
		index = (*TTcl_HashEntry)(unsafe.Pointer(entryPtr)).Fhash & (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).Fmask
	}
	bucketPtr = (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).Fbuckets + uintptr(index)*8
	if *(*uintptr)(unsafe.Pointer(bucketPtr)) == entryPtr {
		*(*uintptr)(unsafe.Pointer(bucketPtr)) = (*TTcl_HashEntry)(unsafe.Pointer(entryPtr)).FnextPtr
	} else {
		prevPtr = *(*uintptr)(unsafe.Pointer(bucketPtr))
		for {
			if prevPtr == libc.UintptrFromInt32(0) {
				XTcl_Panic(tls, __ccgo_ts+35416, 0)
			}
			if (*TTcl_HashEntry)(unsafe.Pointer(prevPtr)).FnextPtr == entryPtr {
				(*TTcl_HashEntry)(unsafe.Pointer(prevPtr)).FnextPtr = (*TTcl_HashEntry)(unsafe.Pointer(entryPtr)).FnextPtr
				break
			}
			goto _1
		_1:
			;
			prevPtr = (*TTcl_HashEntry)(unsafe.Pointer(prevPtr)).FnextPtr
		}
	}
	(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FnumEntries--
	if (*TTcl_HashKeyType)(unsafe.Pointer(typePtr)).FfreeEntryProc != 0 {
		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashKeyType)(unsafe.Pointer(typePtr)).FfreeEntryProc})))(tls, entryPtr)
	} else {
		XTclpFree(tls, entryPtr)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DeleteHashTable --
 *
 *	Free up everything associated with a hash table except for the record
 *	for the table itself.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The hash table is no longer useable.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DeleteHashTable(tls *libc.TLS, tablePtr uintptr) {
	/* Table to delete. */
	var hPtr, nextPtr, typePtr uintptr
	var i TTcl_Size
	_, _, _, _ = hPtr, i, nextPtr, typePtr
	if (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FkeyType == TCL_STRING_KEYS {
		typePtr = uintptr(unsafe.Pointer(&XtclStringHashKeyType))
	} else {
		if (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FkeyType == int32(TCL_ONE_WORD_KEYS) {
			typePtr = uintptr(unsafe.Pointer(&XtclOneWordHashKeyType))
		} else {
			if (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FkeyType == -int32(2) || (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FkeyType == -int32(1) {
				typePtr = (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FtypePtr
			} else {
				typePtr = uintptr(unsafe.Pointer(&XtclArrayHashKeyType))
			}
		}
	}
	/*
	 * Free up all the entries in the table.
	 */
	i = 0
	for {
		if !(i < (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FnumBuckets) {
			break
		}
		hPtr = *(*uintptr)(unsafe.Pointer((*TTcl_HashTable)(unsafe.Pointer(tablePtr)).Fbuckets + uintptr(i)*8))
		for hPtr != libc.UintptrFromInt32(0) {
			nextPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FnextPtr
			if (*TTcl_HashKeyType)(unsafe.Pointer(typePtr)).FfreeEntryProc != 0 {
				(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashKeyType)(unsafe.Pointer(typePtr)).FfreeEntryProc})))(tls, hPtr)
			} else {
				XTclpFree(tls, hPtr)
			}
			hPtr = nextPtr
		}
		goto _1
	_1:
		;
		i++
	}
	/*
	 * Free up the bucket array, if it was dynamically allocated.
	 */
	if (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).Fbuckets != tablePtr+8 {
		if (*TTcl_HashKeyType)(unsafe.Pointer(typePtr)).Fflags&int32(TCL_HASH_KEY_SYSTEM_HASH) != 0 {
			libc.Xfree(tls, (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).Fbuckets)
		} else {
			XTclpFree(tls, (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).Fbuckets)
		}
	}
	/*
	 * Arrange for panics if the table is used again without
	 * re-initialization.
	 */
	(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FfindProc = __ccgo_fp(_BogusFind)
	(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FcreateProc = __ccgo_fp(_BogusCreate)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FirstHashEntry --
 *
 *	Locate the first entry in a hash table and set up a record that can be
 *	used to step through all the remaining entries of the table.
 *
 * Results:
 *	The return value is a pointer to the first entry in tablePtr, or NULL
 *	if tablePtr has no entries in it. The memory at *searchPtr is
 *	initialized so that subsequent calls to Tcl_NextHashEntry will return
 *	all of the entries in the table, one at a time.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FirstHashEntry(tls *libc.TLS, tablePtr uintptr, searchPtr uintptr) (r uintptr) {
	/* Place to store information about progress
	 * through the table. */
	(*TTcl_HashSearch)(unsafe.Pointer(searchPtr)).FtablePtr = tablePtr
	(*TTcl_HashSearch)(unsafe.Pointer(searchPtr)).FnextIndex = 0
	(*TTcl_HashSearch)(unsafe.Pointer(searchPtr)).FnextEntryPtr = libc.UintptrFromInt32(0)
	return XTcl_NextHashEntry(tls, searchPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_NextHashEntry --
 *
 *	Once a hash table enumeration has been initiated by calling
 *	Tcl_FirstHashEntry, this function may be called to return successive
 *	elements of the table.
 *
 * Results:
 *	The return value is the next entry in the hash table being enumerated,
 *	or NULL if the end of the table is reached.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_NextHashEntry(tls *libc.TLS, searchPtr uintptr) (r uintptr) {
	/* Place to store information about progress
	 * through the table. Must have been
	 * initialized by calling
	 * Tcl_FirstHashEntry. */
	var hPtr, tablePtr uintptr
	_, _ = hPtr, tablePtr
	tablePtr = (*TTcl_HashSearch)(unsafe.Pointer(searchPtr)).FtablePtr
	for (*TTcl_HashSearch)(unsafe.Pointer(searchPtr)).FnextEntryPtr == libc.UintptrFromInt32(0) {
		if (*TTcl_HashSearch)(unsafe.Pointer(searchPtr)).FnextIndex >= (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FnumBuckets {
			return libc.UintptrFromInt32(0)
		}
		(*TTcl_HashSearch)(unsafe.Pointer(searchPtr)).FnextEntryPtr = *(*uintptr)(unsafe.Pointer((*TTcl_HashTable)(unsafe.Pointer(tablePtr)).Fbuckets + uintptr((*TTcl_HashSearch)(unsafe.Pointer(searchPtr)).FnextIndex)*8))
		(*TTcl_HashSearch)(unsafe.Pointer(searchPtr)).FnextIndex++
	}
	hPtr = (*TTcl_HashSearch)(unsafe.Pointer(searchPtr)).FnextEntryPtr
	(*TTcl_HashSearch)(unsafe.Pointer(searchPtr)).FnextEntryPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FnextPtr
	return hPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_HashStats --
 *
 *	Return statistics describing the layout of the hash table in its hash
 *	buckets.
 *
 * Results:
 *	The return value is a malloc-ed string containing information about
 *	tablePtr. It is the caller's responsibility to free this string.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_HashStats(tls *libc.TLS, tablePtr uintptr) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Table for which to produce stats. */
	var average, tmp float64
	var count [10]Tsize_t
	var hPtr, p, result uintptr
	var i TTcl_Size
	var j, overflow Tsize_t
	_, _, _, _, _, _, _, _, _ = average, count, hPtr, i, j, overflow, p, result, tmp
	/*
	 * Compute a histogram of bucket usage.
	 */
	i = 0
	for {
		if !(i < int64(NUM_COUNTERS)) {
			break
		}
		count[i] = uint64(0)
		goto _1
	_1:
		;
		i++
	}
	overflow = uint64(0)
	average = float64(0)
	i = 0
	for {
		if !(i < (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FnumBuckets) {
			break
		}
		j = uint64(0)
		hPtr = *(*uintptr)(unsafe.Pointer((*TTcl_HashTable)(unsafe.Pointer(tablePtr)).Fbuckets + uintptr(i)*8))
		for {
			if !(hPtr != libc.UintptrFromInt32(0)) {
				break
			}
			j++
			goto _3
		_3:
			;
			hPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FnextPtr
		}
		if j < uint64(NUM_COUNTERS) {
			count[j]++
		} else {
			overflow++
		}
		tmp = float64(j)
		if (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FnumEntries != 0 {
			average += float64((tmp+float64(1))*(tmp/float64((*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FnumEntries))) / float64(2)
		}
		goto _2
	_2:
		;
		i++
	}
	/*
	 * Print out the histogram and a few other pieces of information.
	 */
	result = XTcl_Alloc(tls, libc.Uint64FromInt32(libc.Int32FromInt32(NUM_COUNTERS)*libc.Int32FromInt32(60)+libc.Int32FromInt32(300)))
	libc.X__builtin_snprintf(tls, result, uint64(60), __ccgo_ts+35462, libc.VaList(bp+8, (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FnumEntries, (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FnumBuckets))
	p = result + uintptr(libc.Xstrlen(tls, result))
	i = 0
	for {
		if !(i < int64(NUM_COUNTERS)) {
			break
		}
		libc.X__builtin_snprintf(tls, p, uint64(60), __ccgo_ts+35497, libc.VaList(bp+8, i, count[i]))
		p += uintptr(libc.Xstrlen(tls, p))
		goto _4
	_4:
		;
		i++
	}
	libc.X__builtin_snprintf(tls, p, uint64(60), __ccgo_ts+35538, libc.VaList(bp+8, int32(NUM_COUNTERS), overflow))
	p += uintptr(libc.Xstrlen(tls, p))
	libc.X__builtin_snprintf(tls, p, uint64(60), __ccgo_ts+35586, libc.VaList(bp+8, average))
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * AllocArrayEntry --
 *
 *	Allocate space for a Tcl_HashEntry containing the array key.
 *
 * Results:
 *	The return value is a pointer to the created entry.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _AllocArrayEntry(tls *libc.TLS, tablePtr uintptr, keyPtr uintptr) (r uintptr) {
	/* Key to store in the hash table entry. */
	var count, size Tsize_t
	var hPtr uintptr
	_, _, _ = count, hPtr, size
	count = libc.Uint64FromInt32((*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FkeyType) * uint64(4)
	size = uint64(libc.UintptrFromInt32(0)+32) + count
	if size < uint64(40) {
		size = uint64(40)
	}
	hPtr = XTcl_Alloc(tls, size)
	libc.Xmemcpy(tls, hPtr+32, keyPtr, count)
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = libc.UintptrFromInt32(0)
	return hPtr
}

/*
 *----------------------------------------------------------------------
 *
 * CompareArrayKeys --
 *
 *	Compares two array keys.
 *
 * Results:
 *	The return value is 0 if they are different and 1 if they are the
 *	same.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _CompareArrayKeys(tls *libc.TLS, keyPtr uintptr, hPtr uintptr) (r int32) {
	/* Existing key to compare. */
	var count Tsize_t
	_ = count
	count = libc.Uint64FromInt32((*TTcl_HashTable)(unsafe.Pointer((*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FtablePtr)).FkeyType) * uint64(4)
	return libc.BoolInt32(!(libc.Xmemcmp(tls, keyPtr, hPtr+32, count) != 0))
}

/*
 *----------------------------------------------------------------------
 *
 * HashArrayKey --
 *
 *	Compute a one-word summary of an array, which can be used to generate
 *	a hash index.
 *
 * Results:
 *	The return value is a one-word summary of the information in
 *	string.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _HashArrayKey(tls *libc.TLS, tablePtr uintptr, keyPtr uintptr) (r Tsize_t) {
	/* Key from which to compute hash value. */
	var array uintptr
	var count int32
	var result Tsize_t
	_, _, _ = array, count, result
	array = keyPtr
	result = uint64(0)
	count = (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FkeyType
	for {
		if !(count > 0) {
			break
		}
		result += libc.Uint64FromInt32(*(*int32)(unsafe.Pointer(array)))
		goto _1
	_1:
		;
		count--
		array += 4
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * AllocStringEntry --
 *
 *	Allocate space for a Tcl_HashEntry containing the string key.
 *
 * Results:
 *	The return value is a pointer to the created entry.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _AllocStringEntry(tls *libc.TLS, dummy767 uintptr, keyPtr uintptr) (r uintptr) {
	/* Key to store in the hash table entry. */
	var allocsize, size, v1 Tsize_t
	var hPtr, string1 uintptr
	_, _, _, _, _ = allocsize, hPtr, size, string1, v1
	string1 = keyPtr
	v1 = libc.Xstrlen(tls, string1) + libc.Uint64FromInt32(1)
	size = v1
	allocsize = v1
	if size < uint64(8) {
		allocsize = uint64(8)
	}
	hPtr = XTcl_Alloc(tls, uint64(libc.UintptrFromInt32(0)+32)+allocsize)
	libc.Xmemset(tls, hPtr, 0, uint64(libc.UintptrFromInt32(0)+32)+allocsize)
	libc.Xmemcpy(tls, hPtr+32, string1, size)
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = libc.UintptrFromInt32(0)
	return hPtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompareStringKeys --
 *
 *	Compares two string keys.
 *
 * Results:
 *	The return value is 0 if they are different and 1 if they are the
 *	same.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclCompareStringKeys(tls *libc.TLS, keyPtr uintptr, hPtr uintptr) (r int32) {
	/* Existing key to compare. */
	return libc.BoolInt32(!(libc.Xstrcmp(tls, keyPtr, hPtr+32) != 0))
}

/*
 *----------------------------------------------------------------------
 *
 * TclHashStringKey --
 *
 *	Compute a one-word summary of a text string, which can be used to
 *	generate a hash index.
 *
 * Results:
 *	The return value is a one-word summary of the information in string.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclHashStringKey(tls *libc.TLS, dummy829 uintptr, keyPtr uintptr) (r Tsize_t) {
	/* Key from which to compute hash value. */
	var c, v2 uint8
	var result, v1 Tsize_t
	var string1, v3 uintptr
	_, _, _, _, _, _ = c, result, string1, v1, v2, v3
	string1 = keyPtr
	/*
	 * I tried a zillion different hash functions and asked many other people
	 * for advice. Many people had their own favorite functions, all
	 * different, but no-one had much idea why they were good ones. I chose
	 * the one below (multiply by 9 and add new character) because of the
	 * following reasons:
	 *
	 * 1. Multiplying by 10 is perfect for keys that are decimal strings, and
	 *    multiplying by 9 is just about as good.
	 * 2. Times-9 is (shift-left-3) plus (old). This means that each
	 *    character's bits hang around in the low-order bits of the hash value
	 *    for ever, plus they spread fairly rapidly up to the high-order bits
	 *    to fill out the hash value. This seems works well both for decimal
	 *    and non-decimal strings, but isn't strong against maliciously-chosen
	 *    keys.
	 *
	 * Note that this function is very weak against malicious strings; it's
	 * very easy to generate multiple keys that have the same hashcode. On the
	 * other hand, that hardly ever actually occurs and this function *is*
	 * very cheap, even by comparison with industry-standard hashes like FNV.
	 * If real strength of hash is required though, use a custom hash based on
	 * Bob Jenkins's lookup3(), but be aware that it's significantly slower.
	 * Since Tcl command and namespace names are usually reasonably-named (the
	 * main use for string hashes in modern Tcl) speed is far more important
	 * than strength.
	 *
	 * See also HashString in tclLiteral.c.
	 * See also TclObjHashKey in tclObj.c.
	 *
	 * See [tcl-Feature Request #2958832]
	 */
	v1 = uint64(*(*uint8)(unsafe.Pointer(string1)))
	result = v1
	if v1 != uint64(0) {
		for {
			string1++
			v3 = string1
			v2 = *(*uint8)(unsafe.Pointer(v3))
			c = v2
			if !(libc.Int32FromUint8(v2) != 0) {
				break
			}
			result += result<<libc.Int32FromInt32(3) + uint64(c)
		}
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * BogusFind --
 *
 *	This function is invoked when Tcl_FindHashEntry is called on a
 *	table that has been deleted.
 *
 * Results:
 *	If Tcl_Panic returns (which it shouldn't) this function returns NULL.
 *
 * Side effects:
 *	Generates a panic.
 *
 *----------------------------------------------------------------------
 */

func _BogusFind(tls *libc.TLS, dummy895 uintptr, dummy896 uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	XTcl_Panic(tls, __ccgo_ts+35626, libc.VaList(bp+8, __ccgo_ts+35653))
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * BogusCreate --
 *
 *	This function is invoked when Tcl_CreateHashEntry is called on a
 *	table that has been deleted.
 *
 * Results:
 *	If panic returns (which it shouldn't) this function returns NULL.
 *
 * Side effects:
 *	Generates a panic.
 *
 *----------------------------------------------------------------------
 */

func _BogusCreate(tls *libc.TLS, dummy921 uintptr, dummy922 uintptr, dummy923 uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	XTcl_Panic(tls, __ccgo_ts+35626, libc.VaList(bp+8, __ccgo_ts+35671))
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * RebuildTable --
 *
 *	This function is invoked when the ratio of entries to hash buckets
 *	becomes too large. It creates a new table with a larger bucket array
 *	and moves all of the entries into the new table.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Memory gets reallocated and entries get re-hashed to new buckets.
 *
 *----------------------------------------------------------------------
 */

func _RebuildTable(tls *libc.TLS, tablePtr uintptr) {
	/* Table to enlarge. */
	var count, index, oldSize Tsize_t
	var hPtr, newChainPtr, oldBuckets, oldChainPtr, typePtr uintptr
	_, _, _, _, _, _, _, _ = count, hPtr, index, newChainPtr, oldBuckets, oldChainPtr, oldSize, typePtr
	oldSize = libc.Uint64FromInt64((*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FnumBuckets)
	oldBuckets = (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).Fbuckets
	/* Avoid outgrowing capability of the memory allocators */
	if oldSize > libc.Uint64FromUint32(0xffffffff)/(libc.Uint64FromInt32(4)*libc.Uint64FromInt64(8)) {
		(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FrebuildSize = int64(INT_MAX)
		return
	}
	if (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FkeyType == TCL_STRING_KEYS {
		typePtr = uintptr(unsafe.Pointer(&XtclStringHashKeyType))
	} else {
		if (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FkeyType == int32(TCL_ONE_WORD_KEYS) {
			typePtr = uintptr(unsafe.Pointer(&XtclOneWordHashKeyType))
		} else {
			if (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FkeyType == -int32(2) || (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FkeyType == -int32(1) {
				typePtr = (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FtypePtr
			} else {
				typePtr = uintptr(unsafe.Pointer(&XtclArrayHashKeyType))
			}
		}
	}
	/*
	 * Allocate and initialize the new bucket array, and set up hashing
	 * constants for new array size.
	 */
	*(*TTcl_Size)(unsafe.Pointer(tablePtr + 40)) *= int64(4)
	if (*TTcl_HashKeyType)(unsafe.Pointer(typePtr)).Fflags&int32(TCL_HASH_KEY_SYSTEM_HASH) != 0 {
		(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).Fbuckets = libc.Xmalloc(tls, libc.Uint64FromInt64((*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FnumBuckets)*uint64(8))
	} else {
		(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).Fbuckets = XTcl_Alloc(tls, libc.Uint64FromInt64((*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FnumBuckets)*uint64(8))
	}
	count = libc.Uint64FromInt64((*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FnumBuckets)
	newChainPtr = (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).Fbuckets
	for {
		if !(count > uint64(0)) {
			break
		}
		*(*uintptr)(unsafe.Pointer(newChainPtr)) = libc.UintptrFromInt32(0)
		goto _1
	_1:
		;
		count--
		newChainPtr += 8
	}
	*(*TTcl_Size)(unsafe.Pointer(tablePtr + 56)) *= int64(4)
	if (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FdownShift > int32(1) {
		*(*int32)(unsafe.Pointer(tablePtr + 72)) -= int32(2)
	}
	(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).Fmask = (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).Fmask<<libc.Int32FromInt32(2) + uint64(3)
	/*
	 * Rehash all of the existing entries into the new bucket array.
	 */
	oldChainPtr = oldBuckets
	for {
		if !(oldSize > uint64(0)) {
			break
		}
		hPtr = *(*uintptr)(unsafe.Pointer(oldChainPtr))
		for {
			if !(hPtr != libc.UintptrFromInt32(0)) {
				break
			}
			*(*uintptr)(unsafe.Pointer(oldChainPtr)) = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FnextPtr
			if (*TTcl_HashKeyType)(unsafe.Pointer(typePtr)).FhashKeyProc == libc.UintptrFromInt32(0) || (*TTcl_HashKeyType)(unsafe.Pointer(typePtr)).Fflags&int32(TCL_HASH_KEY_RANDOMIZE_HASH) != 0 {
				index = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).Fhash * libc.Uint64FromInt32(1103515245) >> (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FdownShift & (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).Fmask
			} else {
				index = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).Fhash & (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).Fmask
			}
			(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FnextPtr = *(*uintptr)(unsafe.Pointer((*TTcl_HashTable)(unsafe.Pointer(tablePtr)).Fbuckets + uintptr(index)*8))
			*(*uintptr)(unsafe.Pointer((*TTcl_HashTable)(unsafe.Pointer(tablePtr)).Fbuckets + uintptr(index)*8)) = hPtr
			goto _3
		_3:
			;
			hPtr = *(*uintptr)(unsafe.Pointer(oldChainPtr))
		}
		goto _2
	_2:
		;
		oldSize--
		oldChainPtr += 8
	}
	/*
	 * Free up the old bucket array, if it was dynamically allocated.
	 */
	if oldBuckets != tablePtr+8 {
		if (*TTcl_HashKeyType)(unsafe.Pointer(typePtr)).Fflags&int32(TCL_HASH_KEY_SYSTEM_HASH) != 0 {
			libc.Xfree(tls, oldBuckets)
		} else {
			XTclpFree(tls, oldBuckets)
		}
	}
}

const HISTORY_OBJS_KEY = "::tcl::HistoryObjs"

/* Epoch of the tcl environment
 * (if changed with tcl-env). */

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * Type of the assocData structure used to hold the reference to the [history
 * add] subcommand, used in Tcl_RecordAndEvalObj.
 */

type THistoryObjs = struct {
	FhistoryObj uintptr
	FaddObj     uintptr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_RecordAndEval --
 *
 *	This procedure adds its command argument to the current list of
 *	recorded events and then executes the command by calling Tcl_Eval.
 *
 * Results:
 *	The return value is a standard Tcl return value, the result of
 *	executing cmd.
 *
 * Side effects:
 *	The command is recorded and executed.
 *
 *----------------------------------------------------------------------
 */

func XTcl_RecordAndEval(tls *libc.TLS, interp uintptr, cmd uintptr, flags int32) (r int32) {
	/* Additional flags. TCL_NO_EVAL means only
	 * record: don't execute command.
	 * TCL_EVAL_GLOBAL means use Tcl_GlobalEval
	 * instead of Tcl_Eval. */
	var _objPtr, cmdPtr, v2 uintptr
	var result int32
	var v1 TTcl_Size
	_, _, _, _, _ = _objPtr, cmdPtr, result, v1, v2
	if *(*uint8)(unsafe.Pointer(cmd)) != 0 {
		/*
		 * Call Tcl_RecordAndEvalObj to do the actual work.
		 */
		cmdPtr = XTcl_NewStringObj(tls, cmd, int64(-int32(1)))
		(*TTcl_Obj)(unsafe.Pointer(cmdPtr)).FrefCount++
		result = XTcl_RecordAndEvalObj(tls, interp, cmdPtr, flags)
		/*
		 * Discard the Tcl object created to hold the command.
		 */
		_objPtr = cmdPtr
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	} else {
		/*
		 * An empty string. Just reset the interpreter's result.
		 */
		XTcl_ResetResult(tls, interp)
		result = TCL_OK
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_RecordAndEvalObj --
 *
 *	This procedure adds the command held in its argument object to the
 *	current list of recorded events and then executes the command by
 *	calling Tcl_EvalObj.
 *
 * Results:
 *	The return value is a standard Tcl return value, the result of
 *	executing the command.
 *
 * Side effects:
 *	The command is recorded and executed.
 *
 *----------------------------------------------------------------------
 */

func XTcl_RecordAndEvalObj(tls *libc.TLS, interp uintptr, cmdPtr uintptr, flags int32) (r int32) {
	bp := tls.Alloc(112)
	defer tls.Free(112) /* Additional flags. TCL_NO_EVAL means record
	 * only: don't execute the command.
	 * TCL_EVAL_GLOBAL means evaluate the script
	 * in global variable context instead of the
	 * current procedure. */
	var _objPtr, cachePtr, cachePtr1, histObjsPtr, procPtr, v4 uintptr
	var call, result int32
	var v1, v2 bool
	var v3 TTcl_Size
	var _ /* info at bp+0 */ TTcl_CmdInfo
	var _ /* list at bp+80 */ [3]uintptr
	_, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, cachePtr1, call, histObjsPtr, procPtr, result, v1, v2, v3, v4
	call = int32(1)
	histObjsPtr = XTcl_GetAssocData(tls, interp, __ccgo_ts+35691, libc.UintptrFromInt32(0))
	/*
	 * Create the references to the [::history add] command if necessary.
	 */
	if histObjsPtr == libc.UintptrFromInt32(0) {
		histObjsPtr = XTcl_Alloc(tls, uint64(16))
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			(*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FhistoryObj = XTclThreadAllocObj(tls)
		} else {
			(*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FhistoryObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FhistoryObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FhistoryObj)).FrefCount = 0
		if libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FhistoryObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FhistoryObj)).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FhistoryObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FhistoryObj)).Fbytes, __ccgo_ts+35710, libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FhistoryObj)).Fbytes + uintptr(libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FhistoryObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(10) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FhistoryObj)).FtypePtr = libc.UintptrFromInt32(0)
		if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			(*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FaddObj = XTclThreadAllocObj(tls)
		} else {
			(*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FaddObj = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FaddObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FaddObj)).FrefCount = 0
		if libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FaddObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FaddObj)).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FaddObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FaddObj)).Fbytes, __ccgo_ts+2121, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FaddObj)).Fbytes + uintptr(libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FaddObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(4) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FaddObj)).FtypePtr = libc.UintptrFromInt32(0)
		(*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FhistoryObj)).FrefCount++
		(*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FaddObj)).FrefCount++
		XTcl_SetAssocData(tls, interp, __ccgo_ts+35691, __ccgo_fp(_DeleteHistoryObjs), histObjsPtr)
	}
	/*
	 * Do not call [history] if it has been replaced by an empty proc
	 */
	result = XTcl_GetCommandInfo(tls, interp, __ccgo_ts+35710, bp)
	if result != 0 && (*(*TTcl_CmdInfo)(unsafe.Pointer(bp))).FdeleteProc == __ccgo_fp(XTclProcDeleteProc) {
		procPtr = (*(*TTcl_CmdInfo)(unsafe.Pointer(bp))).FobjClientData
		call = libc.BoolInt32((*TCommand1)(unsafe.Pointer((*TProc)(unsafe.Pointer(procPtr)).FcmdPtr)).FcompileProc != __ccgo_fp(XTclCompileNoOp))
	}
	if call != 0 {
		/*
		 * Do recording by eval'ing a tcl history command: history add $cmd.
		 */
		(*(*[3]uintptr)(unsafe.Pointer(bp + 80)))[0] = (*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FhistoryObj
		(*(*[3]uintptr)(unsafe.Pointer(bp + 80)))[int32(1)] = (*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FaddObj
		(*(*[3]uintptr)(unsafe.Pointer(bp + 80)))[int32(2)] = cmdPtr
		(*TTcl_Obj)(unsafe.Pointer(cmdPtr)).FrefCount++
		XTcl_EvalObjv(tls, interp, int64(3), bp+80, int32(TCL_EVAL_GLOBAL))
		_objPtr = cmdPtr
		v4 = _objPtr
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		/*
		 * One possible failure mode above: exceeding a resource limit.
		 */
		if XTcl_LimitExceeded(tls, interp) != 0 {
			return int32(TCL_ERROR)
		}
	}
	/*
	 * Execute the command.
	 */
	result = TCL_OK
	if !(flags&libc.Int32FromInt32(TCL_NO_EVAL) != 0) {
		result = XTcl_EvalObjEx(tls, interp, cmdPtr, flags&int32(TCL_EVAL_GLOBAL))
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * DeleteHistoryObjs --
 *
 *	Called to delete the references to the constant words used when adding
 *	to the history.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The constant words may be deleted.
 *
 *----------------------------------------------------------------------
 */

func _DeleteHistoryObjs(tls *libc.TLS, clientData uintptr, dummy207 uintptr) {
	var cachePtr, cachePtr1, histObjsPtr, v2, v5 uintptr
	var v1, v4 TTcl_Size
	var v3, v6 bool
	_, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, histObjsPtr, v1, v2, v3, v4, v5, v6
	histObjsPtr = clientData
	v2 = (*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FhistoryObj
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if !(v1 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FhistoryObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FhistoryObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FhistoryObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FhistoryObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FhistoryObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FhistoryObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, (*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FhistoryObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FhistoryObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FhistoryObj
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, (*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FhistoryObj)
		}
	}
	v5 = (*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FaddObj
	v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
	*(*TTcl_Size)(unsafe.Pointer(v5))--
	if !(v4 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FaddObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FaddObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FaddObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FaddObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FaddObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FaddObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v6 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, (*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FaddObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FaddObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FaddObj
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, (*THistoryObjs)(unsafe.Pointer(histObjsPtr)).FaddObj)
		}
	}
	XTclpFree(tls, histObjsPtr)
}

const DLLNAME = "libicu%s.so.%s"

/* Epoch of the tcl environment
 * (if changed with tcl-env). */

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

type TUCharx = uint16

type TUChar32x = uint32

// C documentation
//
//	/*
//	 * Runtime linking of libicu.
//	 */
type TUBreakIteratorTypex = int32

// C documentation
//
//	/*
//	 * Runtime linking of libicu.
//	 */
type UBreakIteratorTypex = int32

const UBRK_CHARACTERX = 0
const UBRK_WORDX = 1

type TUErrorCodex = int32

type UErrorCodex = int32

const U_STRING_NOT_TERMINATED_WARNING = -124
const U_AMBIGUOUS_ALIAS_WARNING = -122
const U_ZERO_ERRORZ = 0
const /**< No error, no warning. */
U_BUFFER_OVERFLOW_ERROR = 15

type TUConverterCallbackReasonx = int32

const UCNV_UNASSIGNED = 0
const UCNV_ILLEGAL = 1
const UCNV_IRREGULAR = 2
const UCNV_RESET = 3
const UCNV_CLOSE = 4
const UCNV_CLONE = 5

type TUNormalizationCheckResultx = int32

type UNormalizationCheckResultx = int32

const UNORM_NO = 0
const UNORM_YES = 1
const UNORM_MAYBE = 2

type TUConverterFromUCallback = uintptr

type TUConverterToUCallback = uintptr

// C documentation
//
//	/*
//	 * Prototypes for ICU functions sorted by category.
//	 */
type Tfn_u_cleanup = uintptr

type Tfn_u_errorName = uintptr

type Tfn_u_strFromUTF32 = uintptr

type Tfn_u_strFromUTF32WithSub = uintptr

type Tfn_u_strToUTF32 = uintptr

type Tfn_u_strToUTF32WithSub = uintptr

type Tfn_ucnv_close = uintptr

type Tfn_ucnv_countAliases = uintptr

type Tfn_ucnv_countAvailable = uintptr

type Tfn_ucnv_fromUChars = uintptr

type Tfn_ucnv_getAlias = uintptr

type Tfn_ucnv_getAvailableName = uintptr

type Tfn_ucnv_open = uintptr

type Tfn_ucnv_setFromUCallBack = uintptr

type Tfn_ucnv_setToUCallBack = uintptr

type Tfn_ucnv_toUChars = uintptr

type Tfn_UCNV_FROM_U_CALLBACK_STOP = uintptr

type Tfn_UCNV_TO_U_CALLBACK_STOP = uintptr

type Tfn_ubrk_open = uintptr

type Tfn_ubrk_close = uintptr

type Tfn_ubrk_preceding = uintptr

type Tfn_ubrk_following = uintptr

type Tfn_ubrk_previous = uintptr

type Tfn_ubrk_next = uintptr

type Tfn_ubrk_setText = uintptr

type Tfn_ucsdet_open = uintptr

type Tfn_ucsdet_close = uintptr

type Tfn_ucsdet_setText = uintptr

type Tfn_ucsdet_getName = uintptr

type Tfn_ucsdet_getAllDetectableCharsets = uintptr

type Tfn_ucsdet_detect = uintptr

type Tfn_ucsdet_detectAll = uintptr

type Tfn_uenum_close = uintptr

type Tfn_uenum_count = uintptr

type Tfn_uenum_next = uintptr

type Tfn_unorm2_getNFCInstance = uintptr

type Tfn_unorm2_getNFDInstance = uintptr

type Tfn_unorm2_getNFKCInstance = uintptr

type Tfn_unorm2_getNFKDInstance = uintptr

type Tfn_unorm2_normalize = uintptr

var _icu_fns = struct {
	Fnopen                            Tsize_t
	Flibs                             [2]TTcl_LoadHandle
	F_u_cleanup                       Tfn_u_cleanup
	F_u_errorName                     Tfn_u_errorName
	F_u_strFromUTF32                  Tfn_u_strFromUTF32
	F_u_strFromUTF32WithSub           Tfn_u_strFromUTF32WithSub
	F_u_strToUTF32                    Tfn_u_strToUTF32
	F_u_strToUTF32WithSub             Tfn_u_strToUTF32WithSub
	F_ubrk_open                       Tfn_ubrk_open
	F_ubrk_close                      Tfn_ubrk_close
	F_ubrk_preceding                  Tfn_ubrk_preceding
	F_ubrk_following                  Tfn_ubrk_following
	F_ubrk_previous                   Tfn_ubrk_previous
	F_ubrk_next                       Tfn_ubrk_next
	F_ubrk_setText                    Tfn_ubrk_setText
	F_ucnv_close                      Tfn_ucnv_close
	F_ucnv_countAliases               Tfn_ucnv_countAliases
	F_ucnv_countAvailable             Tfn_ucnv_countAvailable
	F_ucnv_fromUChars                 Tfn_ucnv_fromUChars
	F_ucnv_getAlias                   Tfn_ucnv_getAlias
	F_ucnv_getAvailableName           Tfn_ucnv_getAvailableName
	F_ucnv_open                       Tfn_ucnv_open
	F_ucnv_setFromUCallBack           Tfn_ucnv_setFromUCallBack
	F_ucnv_setToUCallBack             Tfn_ucnv_setToUCallBack
	F_ucnv_toUChars                   Tfn_ucnv_toUChars
	F_UCNV_FROM_U_CALLBACK_STOP       Tfn_UCNV_FROM_U_CALLBACK_STOP
	F_UCNV_TO_U_CALLBACK_STOP         Tfn_UCNV_TO_U_CALLBACK_STOP
	F_ucsdet_close                    Tfn_ucsdet_close
	F_ucsdet_detect                   Tfn_ucsdet_detect
	F_ucsdet_detectAll                Tfn_ucsdet_detectAll
	F_ucsdet_getAllDetectableCharsets Tfn_ucsdet_getAllDetectableCharsets
	F_ucsdet_getName                  Tfn_ucsdet_getName
	F_ucsdet_open                     Tfn_ucsdet_open
	F_ucsdet_setText                  Tfn_ucsdet_setText
	F_uenum_close                     Tfn_uenum_close
	F_uenum_count                     Tfn_uenum_count
	F_uenum_next                      Tfn_uenum_next
	F_unorm2_getNFCInstance           Tfn_unorm2_getNFCInstance
	F_unorm2_getNFDInstance           Tfn_unorm2_getNFDInstance
	F_unorm2_getNFKCInstance          Tfn_unorm2_getNFKCInstance
	F_unorm2_getNFKDInstance          Tfn_unorm2_getNFKDInstance
	F_unorm2_normalize                Tfn_unorm2_normalize
}{}

var _icu_mutex TTcl_Mutex

// C documentation
//
//	/* Options used by multiple normalization functions */
var _normalizationForms = [5]uintptr{
	0: __ccgo_ts + 35720,
	1: __ccgo_ts + 35724,
	2: __ccgo_ts + 35728,
	3: __ccgo_ts + 35733,
	4: libc.UintptrFromInt32(0),
}

type TNormalizationMode = int32

const MODE_NFC = 0
const MODE_NFD = 1
const MODE_NFKC = 2
const MODE_NFKD = 3

/* Error handlers. */

func _FunctionNotAvailableError(tls *libc.TLS, interp uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	if interp != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+35738, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+35765, __ccgo_ts+35769, libc.UintptrFromInt32(0)))
	}
	return int32(TCL_ERROR)
}

func _IcuError(tls *libc.TLS, interp uintptr, message uintptr, code TUErrorCodex) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var codeMessage, v1, v2, v3 uintptr
	_, _, _, _ = codeMessage, v1, v2, v3
	if interp != 0 {
		codeMessage = libc.UintptrFromInt32(0)
		if _icu_fns.F_u_errorName != 0 {
			codeMessage = (*(*func(*libc.TLS, TUErrorCodex) uintptr)(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_u_errorName})))(tls, code)
		}
		if message != 0 {
			v1 = message
		} else {
			v1 = __ccgo_ts + 1945
		}
		if message != 0 {
			v2 = __ccgo_ts + 35784
		} else {
			v2 = __ccgo_ts + 1945
		}
		if codeMessage != 0 {
			v3 = codeMessage
		} else {
			v3 = __ccgo_ts + 1945
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+35787, libc.VaList(bp+8, v1, v2, code, v3)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+35765, codeMessage, libc.UintptrFromInt32(0)))
	}
	return int32(TCL_ERROR)
}

// C documentation
//
//	/*
//	 * Detect the likely encoding of the string encoded in the given byte array.
//	 */
func _DetectEncoding(tls *libc.TLS, interp uintptr, objPtr uintptr, all int32) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var bytes, csd, matches, name, resultObj uintptr
	var i, ret, v1 int32
	var _ /* len at bp+0 */ TTcl_Size
	var _ /* match at bp+8 */ uintptr
	var _ /* nmatches at bp+16 */ int32
	var _ /* status at bp+20 */ TUErrorCodex
	_, _, _, _, _, _, _, _ = bytes, csd, i, matches, name, resultObj, ret, v1
	// Confirm we have the profile of functions we need.
	if _icu_fns.F_ucsdet_open == libc.UintptrFromInt32(0) || _icu_fns.F_ucsdet_setText == libc.UintptrFromInt32(0) || _icu_fns.F_ucsdet_detect == libc.UintptrFromInt32(0) || _icu_fns.F_ucsdet_detectAll == libc.UintptrFromInt32(0) || _icu_fns.F_ucsdet_getName == libc.UintptrFromInt32(0) || _icu_fns.F_ucsdet_close == libc.UintptrFromInt32(0) {
		return _FunctionNotAvailableError(tls, interp)
	}
	bytes = XTcl_GetBytesFromObj(tls, interp, objPtr, bp)
	if bytes == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	*(*TUErrorCodex)(unsafe.Pointer(bp + 20)) = int32(U_ZERO_ERRORZ)
	csd = (*(*func(*libc.TLS, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_ucsdet_open})))(tls, bp+20)
	if *(*TUErrorCodex)(unsafe.Pointer(bp + 20)) > int32(U_ZERO_ERRORZ) {
		return _IcuError(tls, interp, __ccgo_ts+35810, *(*TUErrorCodex)(unsafe.Pointer(bp + 20)))
	}
	(*(*func(*libc.TLS, uintptr, uintptr, Tint32_t, uintptr))(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_ucsdet_setText})))(tls, csd, bytes, int32(*(*TTcl_Size)(unsafe.Pointer(bp))), bp+20)
	if *(*TUErrorCodex)(unsafe.Pointer(bp + 20)) > int32(U_ZERO_ERRORZ) {
		_IcuError(tls, interp, __ccgo_ts+35842, *(*TUErrorCodex)(unsafe.Pointer(bp + 20)))
		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_ucsdet_close})))(tls, csd)
		return int32(TCL_ERROR)
	}
	if all != 0 {
		matches = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_ucsdet_detectAll})))(tls, csd, bp+16, bp+20)
	} else {
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_ucsdet_detect})))(tls, csd, bp+20)
		matches = bp + 8
		if *(*uintptr)(unsafe.Pointer(bp + 8)) != 0 {
			v1 = int32(1)
		} else {
			v1 = 0
		}
		*(*int32)(unsafe.Pointer(bp + 16)) = v1
	}
	if *(*TUErrorCodex)(unsafe.Pointer(bp + 20)) > int32(U_ZERO_ERRORZ) || *(*int32)(unsafe.Pointer(bp + 16)) == 0 {
		ret = _IcuError(tls, interp, __ccgo_ts+35871, *(*TUErrorCodex)(unsafe.Pointer(bp + 20)))
	} else {
		resultObj = XTcl_NewListObj(tls, int64(*(*int32)(unsafe.Pointer(bp + 16))), libc.UintptrFromInt32(0))
		i = 0
		for {
			if !(i < *(*int32)(unsafe.Pointer(bp + 16))) {
				break
			}
			name = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_ucsdet_getName})))(tls, *(*uintptr)(unsafe.Pointer(matches + uintptr(i)*8)), bp+20)
			if *(*TUErrorCodex)(unsafe.Pointer(bp + 20)) > int32(U_ZERO_ERRORZ) || name == libc.UintptrFromInt32(0) {
				name = __ccgo_ts + 15720
				*(*TUErrorCodex)(unsafe.Pointer(bp + 20)) = int32(U_ZERO_ERRORZ) /* Reset on failure */
			}
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, XTcl_NewStringObj(tls, name, int64(-libc.Int32FromInt32(1))))
			goto _2
		_2:
			;
			i++
		}
		XTcl_SetObjResult(tls, interp, resultObj)
		ret = TCL_OK
	}
	(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_ucsdet_close})))(tls, csd)
	return ret
}

func _DetectableEncodings(tls *libc.TLS, interp uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var count Tint32_t
	var csd, enumerator, name, resultObj uintptr
	var i, ret int32
	var _ /* len at bp+4 */ Tint32_t
	var _ /* status at bp+0 */ TUErrorCodex
	_, _, _, _, _, _, _ = count, csd, enumerator, i, name, resultObj, ret
	// Confirm we have the profile of functions we need.
	if _icu_fns.F_ucsdet_open == libc.UintptrFromInt32(0) || _icu_fns.F_ucsdet_getAllDetectableCharsets == libc.UintptrFromInt32(0) || _icu_fns.F_ucsdet_close == libc.UintptrFromInt32(0) || _icu_fns.F_uenum_next == libc.UintptrFromInt32(0) || _icu_fns.F_uenum_count == libc.UintptrFromInt32(0) || _icu_fns.F_uenum_close == libc.UintptrFromInt32(0) {
		return _FunctionNotAvailableError(tls, interp)
	}
	*(*TUErrorCodex)(unsafe.Pointer(bp)) = int32(U_ZERO_ERRORZ)
	csd = (*(*func(*libc.TLS, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_ucsdet_open})))(tls, bp)
	if *(*TUErrorCodex)(unsafe.Pointer(bp)) > int32(U_ZERO_ERRORZ) {
		return _IcuError(tls, interp, __ccgo_ts+35810, *(*TUErrorCodex)(unsafe.Pointer(bp)))
	}
	enumerator = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_ucsdet_getAllDetectableCharsets})))(tls, csd, bp)
	if *(*TUErrorCodex)(unsafe.Pointer(bp)) > int32(U_ZERO_ERRORZ) || enumerator == libc.UintptrFromInt32(0) {
		_IcuError(tls, interp, __ccgo_ts+35902, *(*TUErrorCodex)(unsafe.Pointer(bp)))
		ret = int32(TCL_ERROR)
	} else {
		count = (*(*func(*libc.TLS, uintptr, uintptr) Tint32_t)(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_uenum_count})))(tls, enumerator, bp)
		if *(*TUErrorCodex)(unsafe.Pointer(bp)) > int32(U_ZERO_ERRORZ) {
			_IcuError(tls, interp, __ccgo_ts+35945, *(*TUErrorCodex)(unsafe.Pointer(bp)))
			ret = int32(TCL_ERROR)
		} else {
			resultObj = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
			i = 0
			for {
				if !(i < count) {
					break
				}
				name = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_uenum_next})))(tls, enumerator, bp+4, bp)
				if name == libc.UintptrFromInt32(0) || *(*TUErrorCodex)(unsafe.Pointer(bp)) > int32(U_ZERO_ERRORZ) {
					name = __ccgo_ts + 15720
					*(*Tint32_t)(unsafe.Pointer(bp + 4)) = int32(7)
					*(*TUErrorCodex)(unsafe.Pointer(bp)) = int32(U_ZERO_ERRORZ) /* Reset on error */
				}
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, XTcl_NewStringObj(tls, name, int64(*(*Tint32_t)(unsafe.Pointer(bp + 4)))))
				goto _1
			_1:
				;
				i++
			}
			XTcl_SetObjResult(tls, interp, resultObj)
			ret = TCL_OK
		}
		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_uenum_close})))(tls, enumerator)
	}
	(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_ucsdet_close})))(tls, csd)
	return ret
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * IcuObjToUCharDString --
//	 *
//	 *    Encodes a Tcl_Obj value in ICU UChars and stores in dsPtr.
//	 *
//	 * Results:
//	 *    Return TCL_OK / TCL_ERROR.
//	 *
//	 * Side effects:
//	 *    *dsPtr should be cleared by caller only if return code is TCL_OK.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _IcuObjToUCharDString(tls *libc.TLS, interp uintptr, objPtr uintptr, strict int32, dsPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var encoding TTcl_Encoding
	var result, v1 int32
	var s uintptr
	var _ /* len at bp+0 */ TTcl_Size
	_, _, _, _ = encoding, result, s, v1
	/*
	 * TODO - not the most efficient to get an encoding every time.
	 * However, we cannot use Tcl_UtfToChar16DString as that blithely
	 * ignores invalid or ill-formed UTF8 strings.
	 */
	encoding = XTcl_GetEncoding(tls, interp, __ccgo_ts+29158)
	if encoding == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	s = XTcl_GetStringFromObj(tls, objPtr, bp)
	if strict != 0 {
		v1 = TCL_ENCODING_STOPONERROR
	} else {
		v1 = int32(TCL_ENCODING_PROFILE_REPLACE)
	}
	result = XTcl_UtfToExternalDStringEx(tls, interp, encoding, s, *(*TTcl_Size)(unsafe.Pointer(bp)), v1, dsPtr, libc.UintptrFromInt32(0))
	if result != TCL_OK {
		XTcl_DStringFree(tls, dsPtr) /* Must be done on error */
		/* TCL_CONVER_* errors -> TCL_ERROR */
		result = int32(TCL_ERROR)
	}
	XTcl_FreeEncoding(tls, encoding)
	return result
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * IcuObjFromUCharDString --
//	 *
//	 *    Stores a Tcl_Obj value by decoding ICU UChars in dsPtr.
//	 *
//	 * Results:
//	 *    Return Tcl_Obj or NULL on error.
//	 *
//	 * Side effects:
//	 *    None.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _IcuObjFromUCharDString(tls *libc.TLS, interp uintptr, dsPtr uintptr, strict int32) (r uintptr) {
	bp := tls.Alloc(224)
	defer tls.Free(224)
	var encoding TTcl_Encoding
	var len1 TTcl_Size
	var objPtr, s uintptr
	var result, v1 int32
	var _ /* dsOut at bp+0 */ TTcl_DString
	_, _, _, _, _, _ = encoding, len1, objPtr, result, s, v1
	/*
	 * TODO - not the most efficient to get an encoding every time.
	 * However, we cannot use Tcl_UtfToChar16DString as that blithely
	 * ignores invalid or ill-formed UTF8 strings.
	 */
	encoding = XTcl_GetEncoding(tls, interp, __ccgo_ts+29158)
	if encoding == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	objPtr = libc.UintptrFromInt32(0)
	s = (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1
	len1 = (*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength
	if strict != 0 {
		v1 = TCL_ENCODING_STOPONERROR
	} else {
		v1 = int32(TCL_ENCODING_PROFILE_REPLACE)
	}
	result = XTcl_ExternalToUtfDStringEx(tls, interp, encoding, s, len1, v1, bp, libc.UintptrFromInt32(0))
	if result == TCL_OK {
		objPtr = XTcl_DStringToObj(tls, bp) /* Clears dsPtr! */
	}
	XTcl_FreeEncoding(tls, encoding)
	return objPtr
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * EncodingDetectObjCmd --
//	 *
//	 *	Implements the Tcl command EncodingDetect.
//	 *	  encdetect - returns names of all detectable encodings
//	 *	  encdetect BYTES ?-all? - return detected encoding(s)
//	 *
//	 * Results:
//	 *	TCL_OK    - Success.
//	 *	TCL_ERROR - Error.
//	 *
//	 * Side effects:
//	 *	Interpreter result holds result or error message.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _IcuDetectObjCmd(tls *libc.TLS, dummy589 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var all int32
	_ = all
	if objc > int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+35984)
		return int32(TCL_ERROR)
	}
	if objc == int32(1) {
		return _DetectableEncodings(tls, interp)
	}
	all = 0
	if objc == int32(3) {
		if libc.Xstrcmp(tls, __ccgo_ts+17462, XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))) != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+35999, libc.VaList(bp+8, XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0)))))
			return int32(TCL_ERROR)
		}
		all = int32(1)
	}
	return _DetectEncoding(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), all)
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * IcuConverterNamesObjCmd --
//	 *
//	 *	Sets interp result to list of available ICU converters.
//	 *
//	 * Results:
//	 *	TCL_OK    - Success.
//	 *	TCL_ERROR - Error.
//	 *
//	 * Side effects:
//	 *	Interpreter result holds list of converter names.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _IcuConverterNamesObjCmd(tls *libc.TLS, dummy635 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var count, i Tint32_t
	var name, resultObj uintptr
	_, _, _, _ = count, i, name, resultObj
	if objc != int32(1) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+1945)
		return int32(TCL_ERROR)
	}
	if _icu_fns.F_ucnv_countAvailable == libc.UintptrFromInt32(0) || _icu_fns.F_ucnv_getAvailableName == libc.UintptrFromInt32(0) {
		return _FunctionNotAvailableError(tls, interp)
	}
	count = (*(*func(*libc.TLS) Tint32_t)(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_ucnv_countAvailable})))(tls)
	if count <= 0 {
		return TCL_OK
	}
	resultObj = XTcl_NewListObj(tls, int64(count), libc.UintptrFromInt32(0))
	i = 0
	for {
		if !(i < count) {
			break
		}
		name = (*(*func(*libc.TLS, Tint32_t) uintptr)(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_ucnv_getAvailableName})))(tls, i)
		if name != 0 {
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, XTcl_NewStringObj(tls, name, int64(-libc.Int32FromInt32(1))))
		}
		goto _1
	_1:
		;
		i++
	}
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * IcuConverterAliasesObjCmd --
//	 *
//	 *	Sets interp result to list of available ICU converters.
//	 *
//	 * Results:
//	 *	TCL_OK    - Success.
//	 *	TCL_ERROR - Error.
//	 *
//	 * Side effects:
//	 *	Interpreter result holds list of converter names.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _IcuConverterAliasesObjCmd(tls *libc.TLS, dummy685 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var aliasName, name, resultObj uintptr
	var count, i Tuint16_t
	var _ /* status at bp+0 */ TUErrorCodex
	_, _, _, _, _ = aliasName, count, i, name, resultObj
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+36033)
		return int32(TCL_ERROR)
	}
	if _icu_fns.F_ucnv_countAliases == libc.UintptrFromInt32(0) || _icu_fns.F_ucnv_getAlias == libc.UintptrFromInt32(0) {
		return _FunctionNotAvailableError(tls, interp)
	}
	name = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	*(*TUErrorCodex)(unsafe.Pointer(bp)) = int32(U_ZERO_ERRORZ)
	count = (*(*func(*libc.TLS, uintptr, uintptr) Tuint16_t)(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_ucnv_countAliases})))(tls, name, bp)
	if *(*TUErrorCodex)(unsafe.Pointer(bp)) != int32(U_AMBIGUOUS_ALIAS_WARNING) && *(*TUErrorCodex)(unsafe.Pointer(bp)) > int32(U_ZERO_ERRORZ) {
		return _IcuError(tls, interp, __ccgo_ts+36047, *(*TUErrorCodex)(unsafe.Pointer(bp)))
	}
	if libc.Int32FromUint16(count) <= 0 {
		return TCL_OK
	}
	resultObj = XTcl_NewListObj(tls, libc.Int64FromUint16(count), libc.UintptrFromInt32(0))
	i = uint16(0)
	for {
		if !(libc.Int32FromUint16(i) < libc.Int32FromUint16(count)) {
			break
		}
		*(*TUErrorCodex)(unsafe.Pointer(bp)) = int32(U_ZERO_ERRORZ) /* Reset in case U_AMBIGUOUS_ALIAS_WARNING */
		aliasName = (*(*func(*libc.TLS, uintptr, Tuint16_t, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_ucnv_getAlias})))(tls, name, i, bp)
		if *(*TUErrorCodex)(unsafe.Pointer(bp)) != int32(U_AMBIGUOUS_ALIAS_WARNING) && *(*TUErrorCodex)(unsafe.Pointer(bp)) > int32(U_ZERO_ERRORZ) {
			*(*TUErrorCodex)(unsafe.Pointer(bp)) = int32(U_ZERO_ERRORZ) /* Reset error for next iteration */
			goto _1
		}
		if aliasName != 0 {
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, XTcl_NewStringObj(tls, aliasName, int64(-libc.Int32FromInt32(1))))
		}
		goto _1
	_1:
		;
		i++
	}
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * IcuConverttoDString --
//	 *
//	 *    Converts a string in ICU default encoding to the specified encoding.
//	 *
//	 * Results:
//	 *    TCL_OK / TCL_ERROR
//	 *
//	 * Side effects:
//	 *    On success, encoded string is stored in output dsOutPtr
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _IcuConverttoDString(tls *libc.TLS, interp uintptr, dsInPtr uintptr, icuEncName uintptr, strict int32, dsOutPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Output encoded string. */
	var dstCapacity, dstLen, utf16len TTcl_Size
	var ucnvPtr, utf16 uintptr
	var _ /* status at bp+0 */ TUErrorCodex
	_, _, _, _, _ = dstCapacity, dstLen, ucnvPtr, utf16, utf16len
	if _icu_fns.F_ucnv_open == libc.UintptrFromInt32(0) || _icu_fns.F_ucnv_close == libc.UintptrFromInt32(0) || _icu_fns.F_ucnv_fromUChars == libc.UintptrFromInt32(0) || _icu_fns.F_UCNV_FROM_U_CALLBACK_STOP == libc.UintptrFromInt32(0) {
		return _FunctionNotAvailableError(tls, interp)
	}
	*(*TUErrorCodex)(unsafe.Pointer(bp)) = int32(U_ZERO_ERRORZ)
	ucnvPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_ucnv_open})))(tls, icuEncName, bp)
	if ucnvPtr == libc.UintptrFromInt32(0) {
		return _IcuError(tls, interp, __ccgo_ts+36069, *(*TUErrorCodex)(unsafe.Pointer(bp)))
	}
	if strict != 0 {
		(*(*func(*libc.TLS, uintptr, TUConverterFromUCallback, uintptr, uintptr, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_ucnv_setFromUCallBack})))(tls, ucnvPtr, _icu_fns.F_UCNV_FROM_U_CALLBACK_STOP, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), bp)
		if *(*TUErrorCodex)(unsafe.Pointer(bp)) > int32(U_ZERO_ERRORZ) {
			/* TODO - use ucnv_getInvalidUChars to retrieve failing chars */
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_ucnv_close})))(tls, ucnvPtr)
			return _IcuError(tls, interp, __ccgo_ts+36102, *(*TUErrorCodex)(unsafe.Pointer(bp)))
		}
	}
	utf16 = (*TTcl_DString)(unsafe.Pointer(dsInPtr)).Fstring1
	utf16len = libc.Int64FromUint64(libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(dsInPtr)).Flength) / uint64(2))
	if utf16len > int64(INT_MAX) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+36136, int64(-libc.Int32FromInt32(1))))
		return int32(TCL_ERROR)
	}
	dstCapacity = utf16len
	XTcl_DStringInit(tls, dsOutPtr)
	XTcl_DStringSetLength(tls, dsOutPtr, dstCapacity)
	dstLen = int64((*(*func(*libc.TLS, uintptr, uintptr, Tint32_t, uintptr, Tint32_t, uintptr) Tint32_t)(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_ucnv_fromUChars})))(tls, ucnvPtr, (*TTcl_DString)(unsafe.Pointer(dsOutPtr)).Fstring1, int32(dstCapacity), utf16, int32(utf16len), bp))
	if *(*TUErrorCodex)(unsafe.Pointer(bp)) > int32(U_ZERO_ERRORZ) {
		switch *(*TUErrorCodex)(unsafe.Pointer(bp)) {
		case int32(U_STRING_NOT_TERMINATED_WARNING):
		case int32(U_BUFFER_OVERFLOW_ERROR):
			XTcl_DStringSetLength(tls, dsOutPtr, dstLen)
			*(*TUErrorCodex)(unsafe.Pointer(bp)) = int32(U_ZERO_ERRORZ) /* Reset before call */
			dstLen = int64((*(*func(*libc.TLS, uintptr, uintptr, Tint32_t, uintptr, Tint32_t, uintptr) Tint32_t)(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_ucnv_fromUChars})))(tls, ucnvPtr, (*TTcl_DString)(unsafe.Pointer(dsOutPtr)).Fstring1, int32(dstLen), utf16, int32(utf16len), bp))
			if *(*TUErrorCodex)(unsafe.Pointer(bp)) <= int32(U_ZERO_ERRORZ) {
				break
			}
			/* FALLTHRU */
			fallthrough
		default:
			XTcl_DStringFree(tls, dsOutPtr)
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_ucnv_close})))(tls, ucnvPtr)
			return _IcuError(tls, interp, __ccgo_ts+36174, *(*TUErrorCodex)(unsafe.Pointer(bp)))
		}
	}
	XTcl_DStringSetLength(tls, dsOutPtr, dstLen)
	(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_ucnv_close})))(tls, ucnvPtr)
	return TCL_OK
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * IcuBytesToUCharDString --
//	 *
//	 *    Converts encoded bytes to ICU UChars in a Tcl_DString
//	 *
//	 * Results:
//	 *    TCL_OK / TCL_ERROR
//	 *
//	 * Side effects:
//	 *    On success, encoded string is stored in output dsOutPtr
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _IcuBytesToUCharDString(tls *libc.TLS, interp uintptr, bytes uintptr, nbytes TTcl_Size, icuEncName uintptr, strict int32, dsOutPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Output UChar string. */
	var dstCapacity, dstLen int32
	var ucnvPtr uintptr
	var _ /* status at bp+0 */ TUErrorCodex
	_, _, _ = dstCapacity, dstLen, ucnvPtr
	if _icu_fns.F_ucnv_open == libc.UintptrFromInt32(0) || _icu_fns.F_ucnv_close == libc.UintptrFromInt32(0) || _icu_fns.F_ucnv_toUChars == libc.UintptrFromInt32(0) || _icu_fns.F_UCNV_TO_U_CALLBACK_STOP == libc.UintptrFromInt32(0) {
		return _FunctionNotAvailableError(tls, interp)
	}
	if nbytes > int64(INT_MAX) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+36136, int64(-libc.Int32FromInt32(1))))
		return int32(TCL_ERROR)
	}
	*(*TUErrorCodex)(unsafe.Pointer(bp)) = int32(U_ZERO_ERRORZ)
	ucnvPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_ucnv_open})))(tls, icuEncName, bp)
	if ucnvPtr == libc.UintptrFromInt32(0) {
		return _IcuError(tls, interp, __ccgo_ts+36069, *(*TUErrorCodex)(unsafe.Pointer(bp)))
	}
	if strict != 0 {
		(*(*func(*libc.TLS, uintptr, TUConverterToUCallback, uintptr, uintptr, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_ucnv_setToUCallBack})))(tls, ucnvPtr, _icu_fns.F_UCNV_TO_U_CALLBACK_STOP, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), bp)
		if *(*TUErrorCodex)(unsafe.Pointer(bp)) > int32(U_ZERO_ERRORZ) {
			/* TODO - use ucnv_getInvalidUChars to retrieve failing chars */
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_ucnv_close})))(tls, ucnvPtr)
			return _IcuError(tls, interp, __ccgo_ts+36102, *(*TUErrorCodex)(unsafe.Pointer(bp)))
		}
	}
	dstCapacity = int32(nbytes) /* In UChar's  */
	XTcl_DStringInit(tls, dsOutPtr)
	XTcl_DStringSetLength(tls, dsOutPtr, int64(dstCapacity))
	dstLen = (*(*func(*libc.TLS, uintptr, uintptr, Tint32_t, uintptr, Tint32_t, uintptr) Tint32_t)(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_ucnv_toUChars})))(tls, ucnvPtr, (*TTcl_DString)(unsafe.Pointer(dsOutPtr)).Fstring1, dstCapacity, bytes, int32(nbytes), bp)
	if *(*TUErrorCodex)(unsafe.Pointer(bp)) > int32(U_ZERO_ERRORZ) {
		switch *(*TUErrorCodex)(unsafe.Pointer(bp)) {
		case int32(U_STRING_NOT_TERMINATED_WARNING):
		case int32(U_BUFFER_OVERFLOW_ERROR):
			dstCapacity = libc.Int32FromUint64(uint64(2) * libc.Uint64FromInt32(dstLen))
			XTcl_DStringSetLength(tls, dsOutPtr, int64(dstCapacity))
			*(*TUErrorCodex)(unsafe.Pointer(bp)) = int32(U_ZERO_ERRORZ) /* Reset before call */
			dstLen = (*(*func(*libc.TLS, uintptr, uintptr, Tint32_t, uintptr, Tint32_t, uintptr) Tint32_t)(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_ucnv_toUChars})))(tls, ucnvPtr, (*TTcl_DString)(unsafe.Pointer(dsOutPtr)).Fstring1, dstCapacity, bytes, int32(nbytes), bp)
			if *(*TUErrorCodex)(unsafe.Pointer(bp)) <= int32(U_ZERO_ERRORZ) {
				break
			}
			/* FALLTHRU */
			fallthrough
		default:
			XTcl_DStringFree(tls, dsOutPtr)
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_ucnv_close})))(tls, ucnvPtr)
			return _IcuError(tls, interp, __ccgo_ts+36199, *(*TUErrorCodex)(unsafe.Pointer(bp)))
		}
	}
	XTcl_DStringSetLength(tls, dsOutPtr, libc.Int64FromUint64(uint64(2)*libc.Uint64FromInt32(dstLen)))
	(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_ucnv_close})))(tls, ucnvPtr)
	return TCL_OK
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * IcuNormalizeUCharDString --
//	 *
//	 *    Normalizes the UTF-16 encoded data
//	 *
//	 * Results:
//	 *    TCL_OK / TCL_ERROR
//	 *
//	 * Side effects:
//	 *    Normalized data is stored in dsOutPtr which should only be
//	 *    Tcl_DStringFree-ed if return code is TCL_OK.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _IcuNormalizeUCharDString(tls *libc.TLS, interp uintptr, dsInPtr uintptr, mode TNormalizationMode, dsOutPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Output normalized UTF16. */
	var fn, normPtr, normalizer, utf16 uintptr
	var normLen Tint32_t
	var utf16len TTcl_Size
	var _ /* status at bp+0 */ TUErrorCodex
	_, _, _, _, _, _ = fn, normLen, normPtr, normalizer, utf16, utf16len
	fn = libc.UintptrFromInt32(0)
	switch mode {
	case int32(MODE_NFC):
		fn = _icu_fns.F_unorm2_getNFCInstance
	case int32(MODE_NFD):
		fn = _icu_fns.F_unorm2_getNFDInstance
	case int32(MODE_NFKC):
		fn = _icu_fns.F_unorm2_getNFKCInstance
	case int32(MODE_NFKD):
		fn = _icu_fns.F_unorm2_getNFKDInstance
		break
	}
	if fn == libc.UintptrFromInt32(0) || _icu_fns.F_unorm2_normalize == libc.UintptrFromInt32(0) {
		return _FunctionNotAvailableError(tls, interp)
	}
	*(*TUErrorCodex)(unsafe.Pointer(bp)) = int32(U_ZERO_ERRORZ)
	normalizer = (*(*func(*libc.TLS, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{fn})))(tls, bp)
	if *(*TUErrorCodex)(unsafe.Pointer(bp)) > int32(U_ZERO_ERRORZ) {
		return _IcuError(tls, interp, __ccgo_ts+36224, *(*TUErrorCodex)(unsafe.Pointer(bp)))
	}
	utf16 = (*TTcl_DString)(unsafe.Pointer(dsInPtr)).Fstring1
	utf16len = libc.Int64FromUint64(libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(dsInPtr)).Flength) / uint64(2))
	if utf16len > int64(INT_MAX) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+36136, int64(-libc.Int32FromInt32(1))))
		return int32(TCL_ERROR)
	}
	XTcl_DStringInit(tls, dsOutPtr)
	XTcl_DStringSetLength(tls, dsOutPtr, libc.Int64FromUint64(libc.Uint64FromInt64(utf16len)*uint64(2)))
	normPtr = (*TTcl_DString)(unsafe.Pointer(dsOutPtr)).Fstring1
	normLen = (*(*func(*libc.TLS, uintptr, uintptr, Tint32_t, uintptr, Tint32_t, uintptr) Tint32_t)(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_unorm2_normalize})))(tls, normalizer, utf16, int32(utf16len), normPtr, int32(utf16len), bp)
	if *(*TUErrorCodex)(unsafe.Pointer(bp)) > int32(U_ZERO_ERRORZ) {
		switch *(*TUErrorCodex)(unsafe.Pointer(bp)) {
		case int32(U_STRING_NOT_TERMINATED_WARNING):
			/* No problem, don't need it terminated */
		case int32(U_BUFFER_OVERFLOW_ERROR):
			/* Expand buffer */
			XTcl_DStringSetLength(tls, dsOutPtr, libc.Int64FromUint64(libc.Uint64FromInt32(normLen)*uint64(2)))
			normPtr = (*TTcl_DString)(unsafe.Pointer(dsOutPtr)).Fstring1
			*(*TUErrorCodex)(unsafe.Pointer(bp)) = int32(U_ZERO_ERRORZ) /* Need to clear error! */
			normLen = (*(*func(*libc.TLS, uintptr, uintptr, Tint32_t, uintptr, Tint32_t, uintptr) Tint32_t)(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_unorm2_normalize})))(tls, normalizer, utf16, int32(utf16len), normPtr, normLen, bp)
			if *(*TUErrorCodex)(unsafe.Pointer(bp)) <= int32(U_ZERO_ERRORZ) {
				break
			}
			/* FALLTHRU */
			fallthrough
		default:
			XTcl_DStringFree(tls, dsOutPtr)
			return _IcuError(tls, interp, __ccgo_ts+36253, *(*TUErrorCodex)(unsafe.Pointer(bp)))
		}
	}
	XTcl_DStringSetLength(tls, dsOutPtr, libc.Int64FromUint64(libc.Uint64FromInt32(normLen)*uint64(2)))
	return TCL_OK
}

// C documentation
//
//	/*
//	 * Common function for parsing convert options.
//	 */
func _IcuParseConvertOptions(tls *libc.TLS, interp uintptr, objc int32, objv uintptr, strictPtr uintptr, failindexVarPtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var i, strict int32
	var s uintptr
	var _ /* opt at bp+0 */ int32
	_, _, _ = i, s, strict
	if objc < int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+36281)
		return int32(TCL_ERROR)
	}
	objc -= int32(2) /* truncate fixed arguments */
	strict = int32(1)
	i = int32(1)
	for {
		if !(i < objc) {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_optNames)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
			return int32(TCL_ERROR)
		}
		i++
		if i == objc {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+36318, libc.VaList(bp+16, XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i-int32(1))*8)), libc.UintptrFromInt32(0)))))
			return int32(TCL_ERROR)
		}
		s = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
		switch *(*int32)(unsafe.Pointer(bp)) {
		case 0:
			if !(libc.Xstrcmp(tls, s, __ccgo_ts+19738) != 0) {
				strict = 0
			} else {
				if libc.Xstrcmp(tls, s, __ccgo_ts+29062) != 0 {
					XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+36347, libc.VaList(bp+16, s)))
					return int32(TCL_ERROR)
				}
			}
		case 1:
			/* TBD */
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+36429, int64(-libc.Int32FromInt32(1))))
			return int32(TCL_ERROR)
		}
		goto _1
	_1:
		;
		i++
	}
	*(*int32)(unsafe.Pointer(strictPtr)) = strict
	*(*uintptr)(unsafe.Pointer(failindexVarPtr)) = libc.UintptrFromInt32(0)
	return TCL_OK
}

/* Use GetIndexFromObj for option parsing so -failindex can be added later */

var _optNames = [3]uintptr{
	0: __ccgo_ts + 15022,
	1: __ccgo_ts + 15031,
	2: libc.UintptrFromInt32(0),
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * IcuConvertfromObjCmd --
//	 *
//	 *    Implements the Tcl command "icu convertfrom"
//	 *        icu convertfrom ?-profile replace|strict? encoding string
//	 *
//	 * Results:
//	 *    TCL_OK    - Success.
//	 *    TCL_ERROR - Error.
//	 *
//	 * Side effects:
//	 *    Interpreter result holds result or error message.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _IcuConvertfromObjCmd(tls *libc.TLS, dummy1062 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(256)
	defer tls.Free(256) /* Argument objects. */
	var bytes, resultObj uintptr
	var _ /* ds at bp+24 */ TTcl_DString
	var _ /* failindexVar at bp+8 */ uintptr
	var _ /* nbytes at bp+16 */ TTcl_Size
	var _ /* strict at bp+0 */ int32
	_, _ = bytes, resultObj
	if _IcuParseConvertOptions(tls, interp, objc, objv, bp, bp+8) != TCL_OK {
		return int32(TCL_ERROR)
	}
	bytes = XTcl_GetBytesFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), bp+16)
	if bytes == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if _IcuBytesToUCharDString(tls, interp, bytes, *(*TTcl_Size)(unsafe.Pointer(bp + 16)), XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)), libc.UintptrFromInt32(0)), *(*int32)(unsafe.Pointer(bp)), bp+24) != TCL_OK {
		return int32(TCL_ERROR)
	}
	resultObj = _IcuObjFromUCharDString(tls, interp, bp+24, *(*int32)(unsafe.Pointer(bp)))
	if resultObj != 0 {
		XTcl_SetObjResult(tls, interp, resultObj)
		return TCL_OK
	} else {
		return int32(TCL_ERROR)
	}
	return r
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * IcuConverttoObjCmd --
//	 *
//	 *    Implements the Tcl command "icu convertto"
//	 *        icu convertto ?-profile replace|strict? encoding string
//	 *
//	 * Results:
//	 *    TCL_OK    - Success.
//	 *    TCL_ERROR - Error.
//	 *
//	 * Side effects:
//	 *    Interpreter result holds result or error message.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _IcuConverttoObjCmd(tls *libc.TLS, dummy1113 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(464)
	defer tls.Free(464) /* Argument objects. */
	var _ /* dsIn at bp+16 */ TTcl_DString
	var _ /* dsOut at bp+240 */ TTcl_DString
	var _ /* failindexVar at bp+8 */ uintptr
	var _ /* strict at bp+0 */ int32
	if _IcuParseConvertOptions(tls, interp, objc, objv, bp, bp+8) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if _IcuObjToUCharDString(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), *(*int32)(unsafe.Pointer(bp)), bp+16) != TCL_OK || _IcuConverttoDString(tls, interp, bp+16, XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)), libc.UintptrFromInt32(0)), *(*int32)(unsafe.Pointer(bp)), bp+240) != TCL_OK {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewByteArrayObj(tls, (*TTcl_DString)(unsafe.Pointer(bp+240)).Fstring1, (*TTcl_DString)(unsafe.Pointer(bp+240)).Flength))
	XTcl_DStringFree(tls, bp+240)
	return TCL_OK
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * IcuNormalizeObjCmd --
//	 *
//	 *    Implements the Tcl command "icu normalize"
//	 *        icu normalize ?-profile replace|strict? ?-mode nfc|nfd|nfkc|nfkd? string
//	 *
//	 * Results:
//	 *    TCL_OK    - Success.
//	 *    TCL_ERROR - Error.
//	 *
//	 * Side effects:
//	 *    Interpreter result holds result or error message.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _IcuNormalizeObjCmd(tls *libc.TLS, dummy1158 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(480)
	defer tls.Free(480) /* Argument objects. */
	var i, strict int32
	var objPtr, s uintptr
	var _ /* dsIn at bp+8 */ TTcl_DString
	var _ /* dsNorm at bp+232 */ TTcl_DString
	var _ /* mode at bp+4 */ TNormalizationMode
	var _ /* opt at bp+0 */ int32
	_, _, _, _ = i, objPtr, s, strict
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+36470)
		return int32(TCL_ERROR)
	}
	strict = int32(1)
	*(*TNormalizationMode)(unsafe.Pointer(bp + 4)) = int32(MODE_NFC)
	i = int32(1)
	for {
		if !(i < objc-int32(1)) {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_optNames1)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
			return int32(TCL_ERROR)
		}
		i++
		if i == objc-int32(1) {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+36318, libc.VaList(bp+464, XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i-int32(1))*8)), libc.UintptrFromInt32(0)))))
			return int32(TCL_ERROR)
		}
		s = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
		switch *(*int32)(unsafe.Pointer(bp)) {
		case 0:
			if !(libc.Xstrcmp(tls, s, __ccgo_ts+19738) != 0) {
				strict = 0
			} else {
				if libc.Xstrcmp(tls, s, __ccgo_ts+29062) != 0 {
					XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+36347, libc.VaList(bp+464, s)))
					return int32(TCL_ERROR)
				}
			}
		case 1:
			if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_normalizationForms)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+36509, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+4) != TCL_OK {
				return int32(TCL_ERROR)
			}
			break
		}
		goto _1
	_1:
		;
		i++
	}
	if _IcuObjToUCharDString(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), strict, bp+8) != TCL_OK || _IcuNormalizeUCharDString(tls, interp, bp+8, *(*TNormalizationMode)(unsafe.Pointer(bp + 4)), bp+232) != TCL_OK {
		return int32(TCL_ERROR)
	}
	XTcl_DStringFree(tls, bp+8)
	objPtr = _IcuObjFromUCharDString(tls, interp, bp+232, strict)
	XTcl_DStringFree(tls, bp+232)
	if objPtr != 0 {
		XTcl_SetObjResult(tls, interp, objPtr)
		return TCL_OK
	} else {
		return int32(TCL_ERROR)
	}
	return r
}

var _optNames1 = [3]uintptr{
	0: __ccgo_ts + 15022,
	1: __ccgo_ts + 36464,
	2: libc.UintptrFromInt32(0),
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * TclIcuCleanup --
//	 *
//	 *	Called whenever a command referencing the ICU function table is
//	 *	deleted. When the reference count drops to zero, the table is released
//	 *	and the ICU shared libraries are unloaded.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _TclIcuCleanup(tls *libc.TLS, dummy1239 uintptr) {
	var i int32
	var v1 Tsize_t
	var v2 uintptr
	_, _, _ = i, v1, v2
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_icu_mutex)))
	v2 = uintptr(unsafe.Pointer(&_icu_fns))
	v1 = *(*Tsize_t)(unsafe.Pointer(v2))
	*(*Tsize_t)(unsafe.Pointer(v2))--
	if v1 <= uint64(1) {
		if _icu_fns.F_u_cleanup != libc.UintptrFromInt32(0) {
			(*(*func(*libc.TLS))(unsafe.Pointer(&struct{ uintptr }{_icu_fns.F_u_cleanup})))(tls)
		}
		i = 0
		for {
			if !(i < libc.Int32FromUint64(libc.Uint64FromInt64(16)/libc.Uint64FromInt64(8))) {
				break
			}
			if *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8 + uintptr(i)*8)) != libc.UintptrFromInt32(0) {
				XTcl_FSUnloadFile(tls, libc.UintptrFromInt32(0), *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8 + uintptr(i)*8)))
			}
			goto _3
		_3:
			;
			i++
		}
		libc.Xmemset(tls, uintptr(unsafe.Pointer(&_icu_fns)), 0, uint64(344))
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_icu_mutex)))
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * IcuFindSymbol --
//	 *
//	 *	Finds an ICU symbol in a shared library and returns its value.
//	 *
//	 *      Caller must be holding icu_mutex lock.
//	 *
//	 * Results:
//	 *	Returns the symbol value or NULL if not found.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _IcuFindSymbol(tls *libc.TLS, loadH TTcl_LoadHandle, name uintptr, suffix uintptr) (r uintptr) {
	bp := tls.Alloc(256)
	defer tls.Free(256)
	var value uintptr
	var _ /* symbol at bp+0 */ [256]uint8
	_ = value
	value = libc.UintptrFromInt32(0)
	/* Note we only update suffixConvention on a positive result */
	libc.Xstrcpy(tls, bp, name)
	if _suffixConvention <= 0 {
		/* Either don't need suffix or don't know if we do */
		value = XTcl_FindSymbol(tls, libc.UintptrFromInt32(0), loadH, bp)
		if value != 0 {
			_suffixConvention = -int32(1) /* Remember that no suffixes present */
			return value
		}
	}
	if _suffixConvention >= 0 {
		/* Either need suffix or don't know if we do */
		libc.Xstrcat(tls, bp, suffix)
		value = XTcl_FindSymbol(tls, libc.UintptrFromInt32(0), loadH, bp)
		if value != 0 {
			_suffixConvention = int32(1)
		}
	}
	return value
}

/*
 * ICU symbols may have a version suffix depending on how it was built.
 * Rather than try both forms every time, suffixConvention remembers if a
 * suffix is needed (all functions will have it, or none will)
 * 0 - don't know, 1 - have suffix, -1 - no suffix
 */
var _suffixConvention int32

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * TclIcuInit --
//	 *
//	 *	Load the ICU commands into the given interpreter. If the ICU
//	 *	commands have never previously been loaded, the ICU libraries are
//	 *	loaded first.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _TclIcuInit(tls *libc.TLS, interp uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _objPtr, _objPtr1, _objPtr2, nameStr, nameobj, p, v2, v4, v6, v8 uintptr
	var i int32
	var v1 uint8
	var v3, v5, v7 TTcl_Size
	var _ /* icuversion at bp+0 */ [4]uint8
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, i, nameStr, nameobj, p, v1, v2, v3, v4, v5, v6, v7, v8
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_icu_mutex)))
	*(*[4]uint8)(unsafe.Pointer(bp)) = [4]uint8{'_', '8', '0'} /* Highest ICU version + 1 */
	/*
	 * The initialization below clones the one from Tk. May need revisiting.
	 * ICU shared library names as well as function names *may* be versioned.
	 * See https://unicode-org.github.io/icu/userguide/icu4c/packaging.html
	 * for the gory details.
	 */
	if _icu_fns.Fnopen == uint64(0) {
		i = 0
		/* Going back down to ICU version 60 */
		for *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)) == libc.UintptrFromInt32(0) && libc.Int32FromUint8((*(*[4]uint8)(unsafe.Pointer(bp)))[int32(1)]) >= int32('6') {
			v2 = bp + 2
			*(*uint8)(unsafe.Pointer(v2))--
			v1 = *(*uint8)(unsafe.Pointer(v2))
			if libc.Int32FromUint8(v1) < int32('0') {
				(*(*[4]uint8)(unsafe.Pointer(bp)))[int32(1)]--
				(*(*[4]uint8)(unsafe.Pointer(bp)))[int32(2)] = uint8('9')
			}
			i = 0
			for _iculibs[i] != libc.UintptrFromInt32(0) {
				XTcl_ResetResult(tls, interp)
				nameobj = XTcl_NewStringObj(tls, _iculibs[i], int64(-libc.Int32FromInt32(1)))
				nameStr = XTcl_GetStringFromObj(tls, nameobj, libc.UintptrFromInt32(0))
				p = libc.Xstrchr(tls, nameStr, int32('?'))
				if p != libc.UintptrFromInt32(0) {
					libc.Xmemcpy(tls, p, bp+uintptr(1), uint64(2))
				}
				(*TTcl_Obj)(unsafe.Pointer(nameobj)).FrefCount++
				if XTcl_LoadFile(tls, interp, nameobj, libc.UintptrFromInt32(0), 0, libc.UintptrFromInt32(0), uintptr(unsafe.Pointer(&_icu_fns))+8) == TCL_OK {
					if p == libc.UintptrFromInt32(0) {
						(*(*[4]uint8)(unsafe.Pointer(bp)))[0] = uint8('\000')
					}
					_objPtr = nameobj
					v4 = _objPtr
					v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
					*(*TTcl_Size)(unsafe.Pointer(v4))--
					if v3 <= int64(1) {
						XTclFreeObj(tls, _objPtr)
					}
					break
				}
				_objPtr1 = nameobj
				v6 = _objPtr1
				v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
				*(*TTcl_Size)(unsafe.Pointer(v6))--
				if v5 <= int64(1) {
					XTclFreeObj(tls, _objPtr1)
				}
				i++
			}
		}
		if *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)) != libc.UintptrFromInt32(0) {
			/* Loaded icuuc, load others with the same version */
			nameobj = XTcl_ObjPrintf(tls, __ccgo_ts+36543, libc.VaList(bp+16, __ccgo_ts+36558, bp+uintptr(1)))
			(*TTcl_Obj)(unsafe.Pointer(nameobj)).FrefCount++
			/* Ignore errors. Calls to contained functions will fail. */
			XTcl_LoadFile(tls, interp, nameobj, libc.UintptrFromInt32(0), 0, libc.UintptrFromInt32(0), uintptr(unsafe.Pointer(&_icu_fns))+8+1*8)
			_objPtr2 = nameobj
			v8 = _objPtr2
			v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
			*(*TTcl_Size)(unsafe.Pointer(v8))--
			if v7 <= int64(1) {
				XTclFreeObj(tls, _objPtr2)
			}
		}
		/* Symbol may have version (Windows, FreeBSD), or not (Linux) */
		if *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)) != libc.UintptrFromInt32(0) {
			_icu_fns.F_u_cleanup = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+36563, bp)
			_icu_fns.F_u_errorName = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+36573, bp)
			_icu_fns.F_u_strFromUTF32 = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+36585, bp)
			_icu_fns.F_u_strFromUTF32WithSub = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+36600, bp)
			_icu_fns.F_u_strToUTF32 = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+36622, bp)
			_icu_fns.F_u_strToUTF32WithSub = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+36635, bp)
			_icu_fns.F_ucnv_close = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+36655, bp)
			_icu_fns.F_ucnv_countAliases = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+36666, bp)
			_icu_fns.F_ucnv_countAvailable = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+36684, bp)
			_icu_fns.F_ucnv_fromUChars = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+36704, bp)
			_icu_fns.F_ucnv_getAlias = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+36720, bp)
			_icu_fns.F_ucnv_getAvailableName = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+36734, bp)
			_icu_fns.F_ucnv_open = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+36756, bp)
			_icu_fns.F_ucnv_setFromUCallBack = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+36766, bp)
			_icu_fns.F_ucnv_setToUCallBack = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+36788, bp)
			_icu_fns.F_ucnv_toUChars = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+36808, bp)
			_icu_fns.F_UCNV_FROM_U_CALLBACK_STOP = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+36822, bp)
			_icu_fns.F_UCNV_TO_U_CALLBACK_STOP = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+36848, bp)
			_icu_fns.F_ubrk_open = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+36872, bp)
			_icu_fns.F_ubrk_close = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+36882, bp)
			_icu_fns.F_ubrk_preceding = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+36893, bp)
			_icu_fns.F_ubrk_following = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+36908, bp)
			_icu_fns.F_ubrk_previous = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+36923, bp)
			_icu_fns.F_ubrk_next = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+36937, bp)
			_icu_fns.F_ubrk_setText = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+36947, bp)
			_icu_fns.F_uenum_close = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+36960, bp)
			_icu_fns.F_uenum_count = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+36972, bp)
			_icu_fns.F_uenum_next = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+36984, bp)
			_icu_fns.F_unorm2_getNFCInstance = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+36995, bp)
			_icu_fns.F_unorm2_getNFDInstance = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+37017, bp)
			_icu_fns.F_unorm2_getNFKCInstance = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+37039, bp)
			_icu_fns.F_unorm2_getNFKDInstance = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+37062, bp)
			_icu_fns.F_unorm2_normalize = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)), __ccgo_ts+37085, bp)
		}
		if *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8 + 1*8)) != libc.UintptrFromInt32(0) {
			_icu_fns.F_ucsdet_close = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8 + 1*8)), __ccgo_ts+37102, bp)
			_icu_fns.F_ucsdet_detect = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8 + 1*8)), __ccgo_ts+37115, bp)
			_icu_fns.F_ucsdet_detectAll = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8 + 1*8)), __ccgo_ts+37129, bp)
			_icu_fns.F_ucsdet_getName = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8 + 1*8)), __ccgo_ts+37146, bp)
			_icu_fns.F_ucsdet_getAllDetectableCharsets = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8 + 1*8)), __ccgo_ts+37161, bp)
			_icu_fns.F_ucsdet_open = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8 + 1*8)), __ccgo_ts+37193, bp)
			_icu_fns.F_ucsdet_setText = _IcuFindSymbol(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8 + 1*8)), __ccgo_ts+37205, bp)
		}
	}
	if *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8)) != libc.UintptrFromInt32(0) {
		/*
		 * Note refcounts updated BEFORE command definition to protect
		 * against self redefinition.
		 */
		if *(*TTcl_LoadHandle)(unsafe.Pointer(uintptr(unsafe.Pointer(&_icu_fns)) + 8 + 1*8)) != libc.UintptrFromInt32(0) {
			/* Commands needing both libraries */
			/* Ref count number of commands */
			_icu_fns.Fnopen += uint64(3)
			XTcl_CreateObjCommand(tls, interp, __ccgo_ts+37220, __ccgo_fp(_IcuConverttoObjCmd), uintptr(0), __ccgo_fp(_TclIcuCleanup))
			XTcl_CreateObjCommand(tls, interp, __ccgo_ts+37255, __ccgo_fp(_IcuConvertfromObjCmd), uintptr(0), __ccgo_fp(_TclIcuCleanup))
			XTcl_CreateObjCommand(tls, interp, __ccgo_ts+37292, __ccgo_fp(_IcuDetectObjCmd), uintptr(0), __ccgo_fp(_TclIcuCleanup))
		}
		/* Commands needing only libs[0] (icuuc) */
		/* Ref count number of commands */
		_icu_fns.Fnopen += uint64(3) /* UPDATE AS CMDS ADDED/DELETED BELOW */
		XTcl_CreateObjCommand(tls, interp, __ccgo_ts+37324, __ccgo_fp(_IcuConverterNamesObjCmd), uintptr(0), __ccgo_fp(_TclIcuCleanup))
		XTcl_CreateObjCommand(tls, interp, __ccgo_ts+37360, __ccgo_fp(_IcuConverterAliasesObjCmd), uintptr(0), __ccgo_fp(_TclIcuCleanup))
		XTcl_CreateObjCommand(tls, interp, __ccgo_ts+37393, __ccgo_fp(_IcuNormalizeObjCmd), uintptr(0), __ccgo_fp(_TclIcuCleanup))
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_icu_mutex)))
}

var _iculibs = [2]uintptr{
	0: __ccgo_ts + 36528,
	1: libc.UintptrFromInt32(0),
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * TclLoadIcuObjCmd --
//	 *
//	 *	Loads and initializes ICU
//	 *
//	 * Results:
//	 *	TCL_OK    - Success.
//	 *	TCL_ERROR - Error.
//	 *
//	 * Side effects:
//	 *	Interpreter result holds result or error message.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func XTclLoadIcuObjCmd(tls *libc.TLS, dummy1555 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	if objc != int32(1) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+1945)
		return int32(TCL_ERROR)
	}
	_TclIcuInit(tls, interp)
	return TCL_OK
}

const NUM_SPACES = 20

func init() {
	p := unsafe.Pointer(&XtclIndexType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_FreeIndex)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_DupIndex)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_UpdateStringOfIndex)
}

/*
 * The definition of the internal representation of the "index" object; The
 * internalRep.twoPtrValue.ptr1 field of an object of "index" type will be a
 * pointer to one of these structures.
 *
 * Keep this structure declaration in sync with tclTestObj.c
 */

type TIndexRep = struct {
	FtablePtr uintptr
	Foffset   TTcl_Size
	Findex    TTcl_Size
}

/*
 * The following macros greatly simplify moving through a table...
 */

/*
 *----------------------------------------------------------------------
 *
 * GetIndexFromObjList --
 *
 *	This procedure looks up an object's value in a table of strings and
 *	returns the index of the matching string, if any.
 *
 * Results:
 *	If the value of objPtr is identical to or a unique abbreviation for
 *	one of the entries in tableObjPtr, then the return value is TCL_OK and
 *	the index of the matching entry is stored at *indexPtr. If there isn't
 *	a proper match, then TCL_ERROR is returned and an error message is
 *	left in interp's result (unless interp is NULL). The msg argument is
 *	used in the error message; for example, if msg has the value "option"
 *	then the error message will say something flag 'bad option "foo": must
 *	be ...'
 *
 * Side effects:
 *	Removes any internal representation that the object might have. (TODO:
 *	find a way to cache the lookup.)
 *
 *----------------------------------------------------------------------
 */

func _GetIndexFromObjList(tls *libc.TLS, interp uintptr, objPtr uintptr, tableObjPtr uintptr, msg uintptr, flags int32, indexPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Place to store resulting index. */
	var result, v1 int32
	var t TTcl_Size
	var tablePtr, v5 uintptr
	var v2, v3 int64
	var _ /* objc at bp+0 */ TTcl_Size
	var _ /* objv at bp+8 */ uintptr
	_, _, _, _, _, _, _ = result, t, tablePtr, v1, v2, v3, v5
	/*
	 * Use Tcl_GetIndexFromObjStruct to do the work to avoid duplicating most
	 * of the code there. This is a bit inefficient but simpler.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(tableObjPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(tableObjPtr + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(tableObjPtr + 32))).Fptr2)).FspanStart
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(tableObjPtr + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(tableObjPtr + 32))).Fptr1 + 40 + uintptr(v2)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(tableObjPtr + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(tableObjPtr + 32))).Fptr2)).FspanLength
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(tableObjPtr + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v3
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjGetElements(tls, interp, tableObjPtr, bp, bp+8)
	}
	result = v1
	if result != TCL_OK {
		return result
	}
	/*
	 * Build a string table from the list.
	 */
	tablePtr = XTcl_Alloc(tls, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))+libc.Int64FromInt32(1))*uint64(8))
	t = 0
	for {
		if !(t < *(*TTcl_Size)(unsafe.Pointer(bp))) {
			break
		}
		if *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(t)*8)) == objPtr {
			/*
			 * An exact match is always chosen, so we can stop here.
			 */
			XTclpFree(tls, tablePtr)
			*(*TTcl_Size)(unsafe.Pointer(indexPtr)) = t
			return TCL_OK
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(t)*8)))).Fbytes != 0 {
			v5 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(t)*8)))).Fbytes
		} else {
			v5 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(t)*8)), libc.UintptrFromInt32(0))
		}
		*(*uintptr)(unsafe.Pointer(tablePtr + uintptr(t)*8)) = v5
		goto _4
	_4:
		;
		t++
	}
	*(*uintptr)(unsafe.Pointer(tablePtr + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))*8)) = libc.UintptrFromInt32(0)
	result = XTcl_GetIndexFromObjStruct(tls, interp, objPtr, tablePtr, libc.Int64FromUint64(libc.Uint64FromInt64(8)), msg, flags|int32(TCL_INDEX_TEMP_TABLE)|libc.Int32FromUint64(libc.Uint64FromInt64(8)<<libc.Int32FromInt32(1)), indexPtr)
	XTclpFree(tls, tablePtr)
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetIndexFromObjStruct --
 *
 *	This function looks up an object's value given a starting string and
 *	an offset for the amount of space between strings. This is useful when
 *	the strings are embedded in some other kind of array.
 *
 * Results:
 *	If the value of objPtr is identical to or a unique abbreviation for
 *	one of the entries in tablePtr, then the return value is TCL_OK and
 *	the index of the matching entry is stored at *indexPtr
 *	(unless indexPtr is NULL). If there isn't a proper match, then
 *	TCL_ERROR is returned and an error message is left in interp's
 *	result (unless interp is NULL). The msg argument is used in the
 *	error message; for example, if msg has the value "option" then
 *	the error message will say something like 'bad option "foo": must
 *	be ...'
 *
 * Side effects:
 *	The result of the lookup is cached as the internal rep of objPtr, so
 *	that repeated lookups can be done quickly.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetIndexFromObjStruct(tls *libc.TLS, interp uintptr, objPtr uintptr, tablePtr uintptr, offset TTcl_Size, msg uintptr, flags int32, indexPtr uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* Place to store resulting index. */
	var cachePtr, entryPtr, indexRep, irPtr, key, p1, p2, resultPtr, v1, v2, v3, v6, v8, v9 uintptr
	var count int32
	var idx, index, numAbbrev TTcl_Size
	var v7 bool
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, count, entryPtr, idx, index, indexRep, irPtr, key, numAbbrev, p1, p2, resultPtr, v1, v2, v3, v6, v7, v8, v9
	if offset < libc.Int64FromInt64(8) {
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+37428, libc.VaList(bp+24, __ccgo_ts+37450, offset)))
		}
		return int32(TCL_ERROR)
	}
	/*
	 * See if there is a valid cached result from a previous lookup.
	 */
	if objPtr != 0 && !(flags&libc.Int32FromInt32(TCL_INDEX_TEMP_TABLE) != 0) {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIndexType)) {
			v1 = objPtr + 32
		} else {
			v1 = libc.UintptrFromInt32(0)
		}
		irPtr = v1
		if irPtr != 0 {
			indexRep = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(irPtr))).Fptr1
			if (*TIndexRep)(unsafe.Pointer(indexRep)).FtablePtr == tablePtr && (*TIndexRep)(unsafe.Pointer(indexRep)).Foffset == offset && (*TIndexRep)(unsafe.Pointer(indexRep)).Findex != int64(-libc.Int32FromInt32(1)) {
				index = (*TIndexRep)(unsafe.Pointer(indexRep)).Findex
				goto uncachedDone
			}
		}
	}
	/*
	 * Lookup the value of the object in the table. Accept unique
	 * abbreviations unless TCL_EXACT is set in flags.
	 */
	if objPtr != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
			v3 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
		}
		v2 = v3
	} else {
		v2 = __ccgo_ts + 1945
	}
	key = v2
	index = int64(-libc.Int32FromInt32(1))
	numAbbrev = 0
	if !(*(*uint8)(unsafe.Pointer(key)) != 0) && flags&int32(TCL_NULL_OK) != 0 {
		goto uncachedDone
	}
	/*
	 * Scan the table looking for one of:
	 *  - An exact match (always preferred)
	 *  - A single abbreviation (allowed depending on flags)
	 *  - Several abbreviations (never allowed, but overridden by exact match)
	 */
	entryPtr = tablePtr
	idx = libc.Int64FromInt32(0)
	for {
		if !(*(*uintptr)(unsafe.Pointer(entryPtr)) != libc.UintptrFromInt32(0)) {
			break
		}
		p1 = key
		p2 = *(*uintptr)(unsafe.Pointer(entryPtr))
		for {
			if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p1))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p2)))) {
				break
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p1))) == int32('\000') {
				index = idx
				goto done
			}
			goto _5
		_5:
			;
			p1++
			p2++
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p1))) == int32('\000') {
			/*
			 * The value is an abbreviation for this entry. Continue checking
			 * other entries to make sure it's unique. If we get more than one
			 * unique abbreviation, keep searching to see if there is an exact
			 * match, but remember the number of unique abbreviations and
			 * don't allow either.
			 */
			numAbbrev++
			index = idx
		}
		goto _4
	_4:
		;
		entryPtr = entryPtr + uintptr(offset)
		idx++
	}
	/*
	 * Check if we were instructed to disallow abbreviations.
	 */
	if flags&int32(TCL_EXACT) != 0 || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(key))) == int32('\000') || numAbbrev != int64(1) {
		goto error
	}
	goto done
done:
	;
	/*
	 * Cache the found representation. Note that we want to avoid allocating a
	 * new internal-rep if at all possible since that is potentially a slow
	 * operation.
	 */
	if objPtr != 0 && index != int64(-libc.Int32FromInt32(1)) && !(flags&libc.Int32FromInt32(TCL_INDEX_TEMP_TABLE) != 0) {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIndexType)) {
			v6 = objPtr + 32
		} else {
			v6 = libc.UintptrFromInt32(0)
		}
		irPtr = v6
		if irPtr != 0 {
			indexRep = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(irPtr))).Fptr1
		} else {
			indexRep = XTcl_Alloc(tls, uint64(24))
			(*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(bp))).Fptr1 = indexRep
			XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&XtclIndexType)), bp)
		}
		(*TIndexRep)(unsafe.Pointer(indexRep)).FtablePtr = tablePtr
		(*TIndexRep)(unsafe.Pointer(indexRep)).Foffset = offset
		(*TIndexRep)(unsafe.Pointer(indexRep)).Findex = index
	}
	goto uncachedDone
uncachedDone:
	;
	if indexPtr != libc.UintptrFromInt32(0) {
		flags &= libc.Int32FromInt32(30) - libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1))
		if flags != 0 {
			if libc.Uint64FromInt32(flags) == libc.Uint64FromInt64(2)<<libc.Int32FromInt32(1) {
				*(*Tuint16_t)(unsafe.Pointer(indexPtr)) = libc.Uint16FromInt64(index)
				return TCL_OK
			} else {
				if flags == libc.Int32FromUint64(libc.Uint64FromInt64(1)<<libc.Int32FromInt32(1)) {
					*(*Tuint8_t)(unsafe.Pointer(indexPtr)) = libc.Uint8FromInt64(index)
					return TCL_OK
				} else {
					if flags == libc.Int32FromUint64(libc.Uint64FromInt64(8)<<libc.Int32FromInt32(1)) {
						*(*Tint64_t)(unsafe.Pointer(indexPtr)) = index
						return TCL_OK
					} else {
						if flags == libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)) {
							*(*Tint32_t)(unsafe.Pointer(indexPtr)) = int32(index)
							return TCL_OK
						}
					}
				}
			}
		}
		*(*int32)(unsafe.Pointer(indexPtr)) = int32(index)
	}
	return TCL_OK
	goto error
error:
	;
	if interp != libc.UintptrFromInt32(0) {
		/*
		 * Produce a fancy error message.
		 */
		count = 0
		if v7 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v7 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v7 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			resultPtr = XTclThreadAllocObj(tls)
		} else {
			resultPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(resultPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FtypePtr = libc.UintptrFromInt32(0)
		entryPtr = tablePtr
		for *(*uintptr)(unsafe.Pointer(entryPtr)) != libc.UintptrFromInt32(0) && !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(entryPtr)))) != 0) {
			entryPtr = entryPtr + uintptr(offset)
		}
		if numAbbrev > int64(1) && !(flags&libc.Int32FromInt32(TCL_EXACT) != 0) {
			v8 = __ccgo_ts + 37464
		} else {
			v8 = __ccgo_ts + 37475
		}
		XTcl_AppendStringsToObj(tls, resultPtr, libc.VaList(bp+24, v8, msg, __ccgo_ts+37480, key, libc.UintptrFromInt32(0)))
		if *(*uintptr)(unsafe.Pointer(entryPtr)) == libc.UintptrFromInt32(0) {
			XTcl_AppendStringsToObj(tls, resultPtr, libc.VaList(bp+24, __ccgo_ts+37483, libc.UintptrFromInt32(0)))
		} else {
			XTcl_AppendStringsToObj(tls, resultPtr, libc.VaList(bp+24, __ccgo_ts+37503, *(*uintptr)(unsafe.Pointer(entryPtr)), libc.UintptrFromInt32(0)))
			entryPtr = entryPtr + uintptr(offset)
			for *(*uintptr)(unsafe.Pointer(entryPtr)) != libc.UintptrFromInt32(0) {
				if *(*uintptr)(unsafe.Pointer(entryPtr + uintptr(offset))) == libc.UintptrFromInt32(0) && !(flags&libc.Int32FromInt32(TCL_NULL_OK) != 0) {
					if count > 0 {
						v9 = __ccgo_ts + 21659
					} else {
						v9 = __ccgo_ts + 1945
					}
					XTcl_AppendStringsToObj(tls, resultPtr, libc.VaList(bp+24, v9, __ccgo_ts+29437, *(*uintptr)(unsafe.Pointer(entryPtr)), libc.UintptrFromInt32(0)))
				} else {
					if *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(entryPtr)))) != 0 {
						XTcl_AppendStringsToObj(tls, resultPtr, libc.VaList(bp+24, __ccgo_ts+21617, *(*uintptr)(unsafe.Pointer(entryPtr)), libc.UintptrFromInt32(0)))
						count++
					}
				}
				entryPtr = entryPtr + uintptr(offset)
			}
			if flags&int32(TCL_NULL_OK) != 0 {
				XTcl_AppendStringsToObj(tls, resultPtr, libc.VaList(bp+24, __ccgo_ts+37515, libc.UintptrFromInt32(0)))
			}
		}
		XTcl_SetObjResult(tls, interp, resultPtr)
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+17278, msg, key, libc.UintptrFromInt32(0)))
	}
	return int32(TCL_ERROR)
}

/* #define again, needed below */

/*
 *----------------------------------------------------------------------
 *
 * UpdateStringOfIndex --
 *
 *	This function is called to convert a Tcl object from index internal
 *	form to its string form. No abbreviation is ever generated.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The string representation of the object is updated.
 *
 *----------------------------------------------------------------------
 */

func _UpdateStringOfIndex(tls *libc.TLS, objPtr uintptr) {
	var indexRep, indexStr, v1, v2 uintptr
	_, _, _, _ = indexRep, indexStr, v1, v2
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIndexType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	indexRep = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(v1))).Fptr1
	if (*TIndexRep)(unsafe.Pointer(indexRep)).Findex != int64(-libc.Int32FromInt32(1)) {
		v2 = *(*uintptr)(unsafe.Pointer((*TIndexRep)(unsafe.Pointer(indexRep)).FtablePtr + uintptr((*TIndexRep)(unsafe.Pointer(indexRep)).Foffset*(*TIndexRep)(unsafe.Pointer(indexRep)).Findex)))
	} else {
		v2 = __ccgo_ts + 1945
	}
	indexStr = v2
	XTcl_InitStringRep(tls, objPtr, indexStr, libc.Xstrlen(tls, indexStr))
}

/*
 *----------------------------------------------------------------------
 *
 * DupIndex --
 *
 *	This function is called to copy the internal rep of an index Tcl
 *	object from to another object.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The internal representation of the target object is updated and the
 *	type is set.
 *
 *----------------------------------------------------------------------
 */

func _DupIndex(tls *libc.TLS, srcPtr uintptr, dupPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var dupIndexRep, v1 uintptr
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_, _ = dupIndexRep, v1
	dupIndexRep = XTcl_Alloc(tls, uint64(24))
	if (*TTcl_Obj)(unsafe.Pointer(srcPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIndexType)) {
		v1 = srcPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	libc.Xmemcpy(tls, dupIndexRep, (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(v1))).Fptr1, uint64(24))
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr1 = dupIndexRep
	XTcl_StoreInternalRep(tls, dupPtr, uintptr(unsafe.Pointer(&XtclIndexType)), bp)
}

/*
 *----------------------------------------------------------------------
 *
 * FreeIndex --
 *
 *	This function is called to delete the internal rep of an index Tcl
 *	object.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The internal representation of the target object is deleted.
 *
 *----------------------------------------------------------------------
 */

func _FreeIndex(tls *libc.TLS, objPtr uintptr) {
	var v1 uintptr
	_ = v1
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIndexType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	XTclpFree(tls, (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(v1))).Fptr1)
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * TclInitPrefixCmd --
 *
 *	This procedure creates the "prefix" Tcl command. See the user
 *	documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTclInitPrefixCmd(tls *libc.TLS, interp uintptr) (r TTcl_Command) {
	/* Current interpreter. */
	var prefixCmd TTcl_Command
	_ = prefixCmd
	prefixCmd = XTclMakeEnsemble(tls, interp, __ccgo_ts+37535, uintptr(unsafe.Pointer(&_prefixImplMap)))
	XTcl_Export(tls, interp, XTcl_FindNamespace(tls, interp, __ccgo_ts+23915, libc.UintptrFromInt32(0), 0), __ccgo_ts+37549, 0)
	return prefixCmd
}

var _prefixImplMap = [4]TEnsembleImplMap{
	0: {
		Fname: __ccgo_ts + 37523,
	},
	1: {
		Fname: __ccgo_ts + 37527,
	},
	2: {
		Fname: __ccgo_ts + 19719,
	},
	3: {},
}

func init() {
	p := unsafe.Pointer(&_prefixImplMap)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_PrefixAllObjCmd)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(XTclCompileBasic2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(_PrefixLongestObjCmd)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(XTclCompileBasic2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(_PrefixMatchObjCmd)
	*(*uintptr)(unsafe.Add(p, 112)) = __ccgo_fp(XTclCompileBasicMin2ArgCmd)
}

/*----------------------------------------------------------------------
 *
 * PrefixMatchObjCmd --
 *
 *	This function implements the 'prefix match' Tcl command. Refer to the
 *	user documentation for details on what it does.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _PrefixMatchObjCmd(tls *libc.TLS, dummy506 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* Argument objects. */
	var errorPtr, message, objPtr, tablePtr, v2 uintptr
	var flags, result, v3, v5 int32
	var v4, v6 int64
	var _ /* errorLength at bp+0 */ TTcl_Size
	var _ /* i at bp+8 */ TTcl_Size
	var _ /* index at bp+24 */ int32
	var _ /* resultPtr at bp+16 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _ = errorPtr, flags, message, objPtr, result, tablePtr, v2, v3, v4, v5, v6
	flags = 0
	errorPtr = libc.UintptrFromInt32(0)
	message = __ccgo_ts + 11057
	if objc < int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+37572)
		return int32(TCL_ERROR)
	}
	*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = int64(1)
	for {
		if !(*(*TTcl_Size)(unsafe.Pointer(bp + 8)) < int64(objc-libc.Int32FromInt32(2))) {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))*8)), uintptr(unsafe.Pointer(&_matchOptions)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+24) != TCL_OK {
			return int32(TCL_ERROR)
		}
		switch *(*int32)(unsafe.Pointer(bp + 24)) {
		case 1:
			flags |= int32(TCL_EXACT)
		case 2:
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > int64(objc-int32(4)) {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+37595, int64(-libc.Int32FromInt32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+37622, libc.UintptrFromInt32(0)))
				return int32(TCL_ERROR)
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 8))++
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))*8)))).Fbytes != 0 {
				v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))*8)))).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))*8)), libc.UintptrFromInt32(0))
			}
			message = v2
		case 0:
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > int64(objc-int32(4)) {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+37628, int64(-libc.Int32FromInt32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+37622, libc.UintptrFromInt32(0)))
				return int32(TCL_ERROR)
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 8))++
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))*8)) + 32))).Fptr2 != 0 {
					v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))*8)) + 32))).Fptr2)).FspanLength
				} else {
					v4 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))*8)) + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp)) = v4
				v3 = libc.Int32FromInt32(TCL_OK)
			} else {
				v3 = XTcl_ListObjLength(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))*8)), bp)
			}
			result = v3
			if result != TCL_OK {
				return int32(TCL_ERROR)
			}
			if *(*TTcl_Size)(unsafe.Pointer(bp))%int64(2) != 0 {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+37653, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+26289, libc.UintptrFromInt32(0)))
				return int32(TCL_ERROR)
			}
			errorPtr = *(*uintptr)(unsafe.Pointer(objv + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))*8))
			break
		}
		goto _1
	_1:
		;
		*(*TTcl_Size)(unsafe.Pointer(bp + 8))++
	}
	tablePtr = *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8))
	objPtr = *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8))
	/*
	 * Check that table is a valid list first, since we want to handle that
	 * error case regardless of level.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(tablePtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(tablePtr + 32))).Fptr2 != 0 {
			v6 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(tablePtr + 32))).Fptr2)).FspanLength
		} else {
			v6 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(tablePtr + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v6
		v5 = libc.Int32FromInt32(TCL_OK)
	} else {
		v5 = XTcl_ListObjLength(tls, interp, tablePtr, bp+8)
	}
	result = v5
	if result != TCL_OK {
		return result
	}
	result = _GetIndexFromObjList(tls, interp, objPtr, tablePtr, message, flags, bp+8)
	if result != TCL_OK {
		if errorPtr != libc.UintptrFromInt32(0) && *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
			XTcl_ResetResult(tls, interp)
			return TCL_OK
		} else {
			if errorPtr == libc.UintptrFromInt32(0) {
				return int32(TCL_ERROR)
			}
		}
		if (*TTcl_Obj)(unsafe.Pointer(errorPtr)).FrefCount > int64(1) {
			errorPtr = XTcl_DuplicateObj(tls, errorPtr)
		}
		XTcl_ListObjAppendElement(tls, interp, errorPtr, XTcl_NewStringObj(tls, __ccgo_ts+30753, int64(5)))
		XTcl_ListObjAppendElement(tls, interp, errorPtr, XTcl_NewWideIntObj(tls, int64(result)))
		return XTcl_SetReturnOptions(tls, interp, errorPtr)
	}
	result = XTcl_ListObjIndex(tls, interp, tablePtr, *(*TTcl_Size)(unsafe.Pointer(bp + 8)), bp+16)
	if result != TCL_OK {
		return result
	}
	XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 16)))
	return TCL_OK
}

var _matchOptions = [4]uintptr{
	0: __ccgo_ts + 37556,
	1: __ccgo_ts + 17506,
	2: __ccgo_ts + 37563,
	3: libc.UintptrFromInt32(0),
}

/*----------------------------------------------------------------------
 *
 * PrefixAllObjCmd --
 *
 *	This function implements the 'prefix all' Tcl command. Refer to the
 *	user documentation for details on what it does.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _PrefixAllObjCmd(tls *libc.TLS, dummy630 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Argument objects. */
	var elemString, resultPtr, string1, v4, v6 uintptr
	var result, v1 int32
	var t TTcl_Size
	var v2, v3 int64
	var _ /* elemLength at bp+8 */ TTcl_Size
	var _ /* length at bp+0 */ TTcl_Size
	var _ /* tableObjc at bp+16 */ TTcl_Size
	var _ /* tableObjv at bp+24 */ uintptr
	_, _, _, _, _, _, _, _, _, _ = elemString, result, resultPtr, string1, t, v1, v2, v3, v4, v6
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+37704)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanStart
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 24)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1 + 40 + uintptr(v2)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanLength
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = v3
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+16, bp+24)
	}
	result = v1
	if result != TCL_OK {
		return result
	}
	resultPtr = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Flength
		v4 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
	} else {
		v4 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp)
	}
	string1 = v4
	t = 0
	for {
		if !(t < *(*TTcl_Size)(unsafe.Pointer(bp + 16))) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + uintptr(t)*8)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + uintptr(t)*8)))).Flength
			v6 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + uintptr(t)*8)))).Fbytes
		} else {
			v6 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + uintptr(t)*8)), bp+8)
		}
		elemString = v6
		/*
		 * A prefix cannot match if it is longest.
		 */
		if *(*TTcl_Size)(unsafe.Pointer(bp)) <= *(*TTcl_Size)(unsafe.Pointer(bp + 8)) {
			if XTclpUtfNcmp2(tls, elemString, string1, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))) == 0 {
				XTcl_ListObjAppendElement(tls, interp, resultPtr, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + uintptr(t)*8)))
			}
		}
		goto _5
	_5:
		;
		t++
	}
	XTcl_SetObjResult(tls, interp, resultPtr)
	return TCL_OK
}

/*----------------------------------------------------------------------
 *
 * PrefixLongestObjCmd --
 *
 *	This function implements the 'prefix longest' Tcl command. Refer to
 *	the user documentation for details on what it does.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _PrefixLongestObjCmd(tls *libc.TLS, dummy688 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Argument objects. */
	var elemString, resultString, string1, v4, v6 uintptr
	var i, resultLength, t TTcl_Size
	var result, v1 int32
	var v2, v3 int64
	var _ /* elemLength at bp+8 */ TTcl_Size
	var _ /* length at bp+0 */ TTcl_Size
	var _ /* tableObjc at bp+16 */ TTcl_Size
	var _ /* tableObjv at bp+24 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _ = elemString, i, result, resultLength, resultString, string1, t, v1, v2, v3, v4, v6
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+37704)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanStart
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 24)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1 + 40 + uintptr(v2)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanLength
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = v3
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+16, bp+24)
	}
	result = v1
	if result != TCL_OK {
		return result
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Flength
		v4 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
	} else {
		v4 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp)
	}
	string1 = v4
	resultString = libc.UintptrFromInt32(0)
	resultLength = 0
	t = 0
	for {
		if !(t < *(*TTcl_Size)(unsafe.Pointer(bp + 16))) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + uintptr(t)*8)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + uintptr(t)*8)))).Flength
			v6 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + uintptr(t)*8)))).Fbytes
		} else {
			v6 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + uintptr(t)*8)), bp+8)
		}
		elemString = v6
		/*
		 * First check if the prefix string matches the element. A prefix
		 * cannot match if it is longest.
		 */
		if *(*TTcl_Size)(unsafe.Pointer(bp)) > *(*TTcl_Size)(unsafe.Pointer(bp + 8)) || XTclpUtfNcmp2(tls, elemString, string1, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))) != 0 {
			goto _5
		}
		if resultString == libc.UintptrFromInt32(0) {
			/*
			 * If this is the first match, the longest common substring this
			 * far is the complete string. The result is part of this string
			 * so we only need to adjust the length later.
			 */
			resultString = elemString
			resultLength = *(*TTcl_Size)(unsafe.Pointer(bp + 8))
		} else {
			/*
			 * Longest common substring cannot be longer than shortest string.
			 */
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) < resultLength {
				resultLength = *(*TTcl_Size)(unsafe.Pointer(bp + 8))
			}
			/*
			 * Compare strings.
			 */
			i = 0
			for {
				if !(i < resultLength) {
					break
				}
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(resultString + uintptr(i)))) != libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(elemString + uintptr(i)))) {
					/*
					 * Adjust in case we stopped in the middle of a UTF char.
					 */
					resultLength = int64(XTcl_UtfPrev(tls, resultString+uintptr(i+int64(1)), resultString)) - int64(resultString)
					break
				}
				goto _7
			_7:
				;
				i++
			}
		}
		goto _5
	_5:
		;
		t++
	}
	if resultLength > 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, resultString, resultLength))
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_WrongNumArgs --
 *
 *	This function generates a "wrong # args" error message in an
 *	interpreter. It is used as a utility function by many command
 *	functions, including the function that implements procedures.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	An error message is generated in interp's result object to indicate
 *	that a command was invoked with the wrong number of arguments. The
 *	message has the form
 *		wrong # args: should be "foo bar additional stuff"
 *	where "foo" and "bar" are the initial objects in objv (objc determines
 *	how many of these are printed) and "additional stuff" is the contents
 *	of the message argument.
 *
 *	The message printed is modified somewhat if the command is wrapped
 *	inside an ensemble. In that case, the error message generated is
 *	rewritten in such a way that it appears to be generated from the
 *	user-visible command and not how that command is actually implemented,
 *	giving a better overall user experience.
 *
 *	Internally, the Tcl core may set the flag INTERP_ALTERNATE_WRONG_ARGS
 *	in the interpreter to generate complex multi-part messages by calling
 *	this function repeatedly. This allows the code that knows how to
 *	handle ensemble-related error messages to be kept here while still
 *	generating suitable error messages for commands like [read] and
 *	[socket]. Ideally, this would be done through an extra flags argument,
 *	but that wouldn't be source-compatible with the existing API and it's
 *	a fairly rare requirement anyway.
 *
 *----------------------------------------------------------------------
 */

func XTcl_WrongNumArgs(tls *libc.TLS, interp uintptr, objc TTcl_Size, objv uintptr, message uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Error message to print after the leading
	 * objects in objv. The message may be
	 * NULL. */
	var cachePtr, elementStr, iPtr, indexRep, indexRep1, irPtr, irPtr1, objPtr, origObjv, quotedElementStr, quotedElementStr1, v10, v11, v3, v4, v5, v6, v8, v9 uintptr
	var i, len1, toPrint, toSkip TTcl_Size
	var v1 bool
	var _ /* elemLen at bp+0 */ TTcl_Size
	var _ /* flags at bp+8 */ uint8
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, elementStr, i, iPtr, indexRep, indexRep1, irPtr, irPtr1, len1, objPtr, origObjv, quotedElementStr, quotedElementStr1, toPrint, toSkip, v1, v10, v11, v3, v4, v5, v6, v8, v9
	iPtr = interp
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	if (*TInterp)(unsafe.Pointer(iPtr)).Fflags&int32(INTERP_ALTERNATE_WRONG_ARGS) != 0 {
		*(*int32)(unsafe.Pointer(iPtr + 368)) &= ^libc.Int32FromInt32(INTERP_ALTERNATE_WRONG_ARGS)
		XTcl_AppendObjToObj(tls, objPtr, XTcl_GetObjResult(tls, interp))
		XTcl_AppendToObj(tls, objPtr, __ccgo_ts+37717, int64(-libc.Int32FromInt32(1)))
	} else {
		XTcl_AppendToObj(tls, objPtr, __ccgo_ts+37723, int64(-libc.Int32FromInt32(1)))
	}
	/*
	 * If processing an ensemble implementation, rewrite the results in
	 * terms of how the ensemble was invoked.
	 */
	if (*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FsourceObjs != libc.UintptrFromInt32(0) {
		toSkip = (*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FnumInsertedObjs
		toPrint = (*TInterp)(unsafe.Pointer(iPtr)).FensembleRewrite.FnumRemovedObjs
		origObjv = XTclEnsembleGetRewriteValues(tls, interp)
		/*
		 * Only do rewrite the command if all the replaced objects are
		 * actually arguments (in objv) to this function. Otherwise it just
		 * gets too complicated and it's to just give a slightly
		 * confusing error message...
		 */
		if objc < toSkip {
			goto addNormalArgumentsToMessage
		}
		/*
		 * Strip out the actual arguments that the ensemble inserted.
		 */
		objv += uintptr(toSkip) * 8
		objc -= toSkip
		/*
		 * Assume no object is of index type.
		 */
		i = 0
		for {
			if !(i < toPrint) {
				break
			}
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(origObjv + uintptr(i)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIndexType)) {
				v4 = *(*uintptr)(unsafe.Pointer(origObjv + uintptr(i)*8)) + 32
			} else {
				v4 = libc.UintptrFromInt32(0)
			}
			v3 = v4
			irPtr = v3
			if v3 != 0 {
				indexRep = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(irPtr))).Fptr1
				if (*TIndexRep)(unsafe.Pointer(indexRep)).Findex != int64(-libc.Int32FromInt32(1)) {
					v5 = *(*uintptr)(unsafe.Pointer((*TIndexRep)(unsafe.Pointer(indexRep)).FtablePtr + uintptr((*TIndexRep)(unsafe.Pointer(indexRep)).Foffset*(*TIndexRep)(unsafe.Pointer(indexRep)).Findex)))
				} else {
					v5 = __ccgo_ts + 1945
				}
				elementStr = v5
				*(*TTcl_Size)(unsafe.Pointer(bp)) = libc.Int64FromUint64(libc.Xstrlen(tls, elementStr))
			} else {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(origObjv + uintptr(i)*8)))).Fbytes != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(origObjv + uintptr(i)*8)))).Flength
					v6 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(origObjv + uintptr(i)*8)))).Fbytes
				} else {
					v6 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(origObjv + uintptr(i)*8)), bp)
				}
				elementStr = v6
			}
			*(*uint8)(unsafe.Pointer(bp + 8)) = uint8(0)
			len1 = XTclScanElement(tls, elementStr, *(*TTcl_Size)(unsafe.Pointer(bp)), bp+8)
			if len1 != *(*TTcl_Size)(unsafe.Pointer(bp)) {
				quotedElementStr = XTclStackAlloc(tls, interp, libc.Uint64FromInt64(len1+int64(1)))
				len1 = XTclConvertElement(tls, elementStr, *(*TTcl_Size)(unsafe.Pointer(bp)), quotedElementStr, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 8))))
				XTcl_AppendToObj(tls, objPtr, quotedElementStr, len1)
				XTclStackFree(tls, interp, quotedElementStr)
			} else {
				XTcl_AppendToObj(tls, objPtr, elementStr, *(*TTcl_Size)(unsafe.Pointer(bp)))
			}
			/*
			 * Add a space if the word is not the last one (which has a
			 * moderately complex condition here).
			 */
			if i+int64(1) < toPrint || objc != 0 || message != libc.UintptrFromInt32(0) {
				XTcl_AppendStringsToObj(tls, objPtr, libc.VaList(bp+24, __ccgo_ts+14830, libc.UintptrFromInt32(0)))
			}
			goto _2
		_2:
			;
			i++
		}
	}
	/*
	 * Now add the arguments (other than those rewritten) that the caller took
	 * from its calling context.
	 */
	goto addNormalArgumentsToMessage
addNormalArgumentsToMessage:
	;
	i = 0
	for {
		if !(i < objc) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIndexType)) {
			v9 = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) + 32
		} else {
			v9 = libc.UintptrFromInt32(0)
		}
		v8 = v9
		irPtr1 = v8
		if v8 != 0 {
			indexRep1 = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(irPtr1))).Fptr1
			if (*TIndexRep)(unsafe.Pointer(indexRep1)).Findex != int64(-libc.Int32FromInt32(1)) {
				v10 = *(*uintptr)(unsafe.Pointer((*TIndexRep)(unsafe.Pointer(indexRep1)).FtablePtr + uintptr((*TIndexRep)(unsafe.Pointer(indexRep1)).Foffset*(*TIndexRep)(unsafe.Pointer(indexRep1)).Findex)))
			} else {
				v10 = __ccgo_ts + 1945
			}
			XTcl_AppendStringsToObj(tls, objPtr, libc.VaList(bp+24, v10, libc.UintptrFromInt32(0)))
		} else {
			/*
			 * Quote the argument if it contains spaces (Bug 942757).
			 */
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Flength
				v11 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
			} else {
				v11 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp)
			}
			elementStr = v11
			*(*uint8)(unsafe.Pointer(bp + 8)) = uint8(0)
			len1 = XTclScanElement(tls, elementStr, *(*TTcl_Size)(unsafe.Pointer(bp)), bp+8)
			if len1 != *(*TTcl_Size)(unsafe.Pointer(bp)) {
				quotedElementStr1 = XTclStackAlloc(tls, interp, libc.Uint64FromInt64(len1+int64(1)))
				len1 = XTclConvertElement(tls, elementStr, *(*TTcl_Size)(unsafe.Pointer(bp)), quotedElementStr1, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 8))))
				XTcl_AppendToObj(tls, objPtr, quotedElementStr1, len1)
				XTclStackFree(tls, interp, quotedElementStr1)
			} else {
				XTcl_AppendToObj(tls, objPtr, elementStr, *(*TTcl_Size)(unsafe.Pointer(bp)))
			}
		}
		/*
		 * Append a space character (" ") if there is more text to follow
		 * (either another element from objv, or the message string).
		 */
		if i+int64(1) < objc || message != libc.UintptrFromInt32(0) {
			XTcl_AppendStringsToObj(tls, objPtr, libc.VaList(bp+24, __ccgo_ts+14830, libc.UintptrFromInt32(0)))
		}
		goto _7
	_7:
		;
		i++
	}
	/*
	 * Add any trailing message bits and set the resulting string as the
	 * interpreter result. Caller is responsible for reporting this as an
	 * actual error.
	 */
	if message != libc.UintptrFromInt32(0) {
		XTcl_AppendStringsToObj(tls, objPtr, libc.VaList(bp+24, message, libc.UintptrFromInt32(0)))
	}
	XTcl_AppendStringsToObj(tls, objPtr, libc.VaList(bp+24, __ccgo_ts+14586, libc.UintptrFromInt32(0)))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+9101, libc.UintptrFromInt32(0)))
	XTcl_SetObjResult(tls, interp, objPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ParseArgsObjv --
 *
 *	Process an objv array according to a table of expected command-line
 *	options. See the manual page for more details.
 *
 * Results:
 *	The return value is a standard Tcl return value. If an error occurs
 *	then an error message is left in the interp's result. Under normal
 *	conditions, both *objcPtr and *objv are modified to return the
 *	arguments that couldn't be processed here (they didn't match the
 *	option table, or followed an TCL_ARGV_REST argument).
 *
 * Side effects:
 *	Variables may be modified, or procedures may be called. It all depends
 *	on the arguments and their entries in argTable. See the user
 *	documentation for details.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ParseArgsObjv(tls *libc.TLS, interp uintptr, argTable uintptr, objcPtr uintptr, objv uintptr, remObjv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Pointer to array of arguments that were not
	 * processed here. Should be NULL if no return
	 * of arguments is desired. */
	var argObj, curArg, handlerProc, handlerProc1, infoPtr, leftovers, matchPtr, str, v2, v5, v6, v7 uintptr
	var c uint8
	var dstIndex, gf_ret, nrem, objc, srcIndex, v1, v4, v8 TTcl_Size
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = argObj, c, curArg, dstIndex, gf_ret, handlerProc, handlerProc1, infoPtr, leftovers, matchPtr, nrem, objc, srcIndex, str, v1, v2, v4, v5, v6, v7, v8 /* Current argument */
	str = libc.UintptrFromInt32(0)                                                                                                                                                                                      /* Return value from Tcl_ArgvGenFuncProc*/
	if remObjv != libc.UintptrFromInt32(0) {
		/*
		 * Then we should copy the name of the command (0th argument). The
		 * upper bound on the number of elements is known, and (undocumented,
		 * but historically true) there should be a NULL argument after the
		 * last result. [Bug 3413857]
		 */
		nrem = int64(1)
		leftovers = XTcl_Alloc(tls, libc.Uint64FromInt64(libc.Int64FromInt32(1)+*(*TTcl_Size)(unsafe.Pointer(objcPtr)))*uint64(8))
		*(*uintptr)(unsafe.Pointer(leftovers)) = *(*uintptr)(unsafe.Pointer(objv))
	} else {
		nrem = 0
		leftovers = libc.UintptrFromInt32(0)
	}
	/*
	 * OK, now start processing from the second element (1st argument).
	 */
	v1 = libc.Int64FromInt32(1)
	dstIndex = v1
	srcIndex = v1
	objc = *(*TTcl_Size)(unsafe.Pointer(objcPtr)) - int64(1)
	for objc > 0 {
		curArg = *(*uintptr)(unsafe.Pointer(objv + uintptr(srcIndex)*8))
		srcIndex++
		objc--
		if (*TTcl_Obj)(unsafe.Pointer(curArg)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(curArg)).Flength
			v2 = (*TTcl_Obj)(unsafe.Pointer(curArg)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, curArg, bp)
		}
		str = v2
		if *(*TTcl_Size)(unsafe.Pointer(bp)) > 0 {
			c = *(*uint8)(unsafe.Pointer(str + 1))
		} else {
			c = uint8(0)
		}
		/*
		 * Loop through the argument descriptors searching for one with the
		 * matching key string. If found, leave a pointer to it in matchPtr.
		 */
		matchPtr = libc.UintptrFromInt32(0)
		infoPtr = argTable
		for {
			if !(infoPtr != libc.UintptrFromInt32(0) && (*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).Ftype1 != int32(TCL_ARGV_END)) {
				break
			}
			if (*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).FkeyStr == libc.UintptrFromInt32(0) {
				goto _3
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).FkeyStr + 1))) != libc.Int32FromUint8(c) || libc.Xstrncmp(tls, (*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).FkeyStr, str, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))) != 0 {
				goto _3
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).FkeyStr + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))))) == 0 {
				matchPtr = infoPtr
				goto gotMatch
			}
			if matchPtr != libc.UintptrFromInt32(0) {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+37749, libc.VaList(bp+16, str)))
				goto error
			}
			matchPtr = infoPtr
			goto _3
		_3:
			;
			infoPtr += 48
		}
		if matchPtr == libc.UintptrFromInt32(0) {
			/*
			 * Unrecognized argument. Just copy it down, unless the caller
			 * prefers an error to be registered.
			 */
			if remObjv == libc.UintptrFromInt32(0) {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+37771, libc.VaList(bp+16, str)))
				goto error
			}
			dstIndex++ /* This argument is now handled */
			v4 = nrem
			nrem++
			*(*uintptr)(unsafe.Pointer(leftovers + uintptr(v4)*8)) = curArg
			continue
		}
		/*
		 * Take the appropriate action based on the option type
		 */
		goto gotMatch
	gotMatch:
		;
		infoPtr = matchPtr
		switch (*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).Ftype1 {
		case int32(TCL_ARGV_CONSTANT):
			*(*int32)(unsafe.Pointer((*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).FdstPtr)) = int32(int64((*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).FsrcPtr))
		case int32(TCL_ARGV_INT):
			if objc == 0 {
				goto missingArg
			}
			if XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(srcIndex)*8)), (*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).FdstPtr) == int32(TCL_ERROR) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(srcIndex)*8)))).Fbytes != 0 {
					v5 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(srcIndex)*8)))).Fbytes
				} else {
					v5 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(srcIndex)*8)), libc.UintptrFromInt32(0))
				}
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+37798, libc.VaList(bp+16, (*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).FkeyStr, v5)))
				goto error
			}
			srcIndex++
			objc--
		case int32(TCL_ARGV_STRING):
			if objc == 0 {
				goto missingArg
			}
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(srcIndex)*8)))).Fbytes != 0 {
				v6 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(srcIndex)*8)))).Fbytes
			} else {
				v6 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(srcIndex)*8)), libc.UintptrFromInt32(0))
			}
			*(*uintptr)(unsafe.Pointer((*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).FdstPtr)) = v6
			srcIndex++
			objc--
		case int32(TCL_ARGV_REST):
			/*
			 * Only store the point where we got to if it's not to be written
			 * to NULL, so that TCL_ARGV_AUTO_REST works.
			 */
			if (*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).FdstPtr != libc.UintptrFromInt32(0) {
				*(*int32)(unsafe.Pointer((*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).FdstPtr)) = int32(dstIndex)
			}
			goto argsDone
		case int32(TCL_ARGV_FLOAT):
			if objc == 0 {
				goto missingArg
			}
			if XTcl_GetDoubleFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(srcIndex)*8)), (*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).FdstPtr) == int32(TCL_ERROR) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(srcIndex)*8)))).Fbytes != 0 {
					v7 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(srcIndex)*8)))).Fbytes
				} else {
					v7 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(srcIndex)*8)), libc.UintptrFromInt32(0))
				}
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+37846, libc.VaList(bp+16, (*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).FkeyStr, v7)))
				goto error
			}
			srcIndex++
			objc--
		case int32(TCL_ARGV_FUNC):
			handlerProc = (*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).FsrcPtr
			if objc == 0 {
				argObj = libc.UintptrFromInt32(0)
			} else {
				argObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(srcIndex)*8))
			}
			if (*(*func(*libc.TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{handlerProc})))(tls, (*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).FclientData, argObj, (*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).FdstPtr) != 0 {
				srcIndex++
				objc--
			}
		case int32(TCL_ARGV_GENFUNC):
			if objc > int64(INT_MAX) {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+37901, libc.VaList(bp+16, objc)))
				goto error
			}
			handlerProc1 = (*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).FsrcPtr
			gf_ret = (*(*func(*libc.TLS, uintptr, uintptr, TTcl_Size, uintptr, uintptr) TTcl_Size)(unsafe.Pointer(&struct{ uintptr }{handlerProc1})))(tls, (*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).FclientData, interp, objc, objv+uintptr(srcIndex)*8, (*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).FdstPtr)
			if gf_ret < 0 {
				goto error
			} else {
				srcIndex += gf_ret
				objc -= gf_ret
			}
		case int32(TCL_ARGV_HELP):
			_PrintUsage(tls, interp, argTable)
			goto error
		default:
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+37947, libc.VaList(bp+16, (*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).Ftype1)))
			goto error
		}
	}
	/*
	 * If we broke out of the loop because of an OPT_REST argument, copy the
	 * remaining arguments down. Note that there is always at least one
	 * argument left over - the command name - so we always have a result if
	 * our caller is willing to receive it. [Bug 3413857]
	 */
	goto argsDone
argsDone:
	;
	if remObjv == libc.UintptrFromInt32(0) {
		/*
		 * Nothing to do.
		 */
		return TCL_OK
	}
	if objc > 0 {
		libc.Xmemcpy(tls, leftovers+uintptr(nrem)*8, objv+uintptr(srcIndex)*8, libc.Uint64FromInt64(objc)*uint64(8))
		nrem += objc
	}
	*(*uintptr)(unsafe.Pointer(leftovers + uintptr(nrem)*8)) = libc.UintptrFromInt32(0)
	v8 = nrem
	nrem++
	*(*TTcl_Size)(unsafe.Pointer(objcPtr)) = v8
	*(*uintptr)(unsafe.Pointer(remObjv)) = XTcl_Realloc(tls, leftovers, libc.Uint64FromInt64(nrem)*uint64(8))
	return TCL_OK
	/*
	 * Make sure to handle freeing any temporary space we've allocated on the
	 * way to an error.
	 */
	goto missingArg
missingArg:
	;
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+37984, libc.VaList(bp+16, str)))
	goto error
error:
	;
	if leftovers != libc.UintptrFromInt32(0) {
		XTclpFree(tls, leftovers)
	}
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * PrintUsage --
 *
 *	Generate a help string describing command-line options.
 *
 * Results:
 *	The interp's result will be modified to hold a help string describing
 *	all the options in argTable.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _PrintUsage(tls *libc.TLS, interp uintptr, argTable uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	/* Array of command-specific argument
	 * descriptions. */
	var infoPtr, msg, string1 uintptr
	var length TTcl_Size
	var numSpaces, width int32
	_, _, _, _, _, _ = infoPtr, length, msg, numSpaces, string1, width
	/*
	 * First, compute the width of the widest option key, so that we can make
	 * everything line up.
	 */
	width = int32(4)
	infoPtr = argTable
	for {
		if !((*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).Ftype1 != int32(TCL_ARGV_END)) {
			break
		}
		if (*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).FkeyStr == libc.UintptrFromInt32(0) {
			goto _1
		}
		length = libc.Int64FromUint64(libc.Xstrlen(tls, (*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).FkeyStr))
		if length > int64(width) {
			width = int32(length)
		}
		goto _1
	_1:
		;
		infoPtr += 48
	}
	/*
	 * Now add the option information, with pretty-printing.
	 */
	msg = XTcl_NewStringObj(tls, __ccgo_ts+38028, int64(-libc.Int32FromInt32(1)))
	infoPtr = argTable
	for {
		if !((*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).Ftype1 != int32(TCL_ARGV_END)) {
			break
		}
		if (*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).Ftype1 == int32(TCL_ARGV_HELP) && (*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).FkeyStr == libc.UintptrFromInt32(0) {
			XTcl_AppendPrintfToObj(tls, msg, __ccgo_ts+38054, libc.VaList(bp+8, (*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).FhelpStr))
			goto _2
		}
		XTcl_AppendPrintfToObj(tls, msg, __ccgo_ts+38058, libc.VaList(bp+8, (*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).FkeyStr))
		numSpaces = libc.Int32FromUint64(libc.Uint64FromInt32(width+int32(1)) - libc.Xstrlen(tls, (*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).FkeyStr))
		for numSpaces > 0 {
			if numSpaces >= int32(NUM_SPACES) {
				XTcl_AppendToObj(tls, msg, uintptr(unsafe.Pointer(&_spaces)), int64(NUM_SPACES))
			} else {
				XTcl_AppendToObj(tls, msg, uintptr(unsafe.Pointer(&_spaces)), int64(numSpaces))
			}
			numSpaces -= int32(NUM_SPACES)
		}
		XTcl_AppendToObj(tls, msg, (*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).FhelpStr, int64(-libc.Int32FromInt32(1)))
		switch (*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).Ftype1 {
		case int32(TCL_ARGV_INT):
			XTcl_AppendPrintfToObj(tls, msg, __ccgo_ts+38064, libc.VaList(bp+8, *(*int32)(unsafe.Pointer((*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).FdstPtr))))
		case int32(TCL_ARGV_FLOAT):
			XTcl_AppendPrintfToObj(tls, msg, __ccgo_ts+38085, libc.VaList(bp+8, *(*float64)(unsafe.Pointer((*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).FdstPtr))))
		case int32(TCL_ARGV_STRING):
			string1 = *(*uintptr)(unsafe.Pointer((*TTcl_ArgvInfo)(unsafe.Pointer(infoPtr)).FdstPtr))
			if string1 != libc.UintptrFromInt32(0) {
				XTcl_AppendPrintfToObj(tls, msg, __ccgo_ts+38106, libc.VaList(bp+8, string1))
			}
		default:
			break
		}
		goto _2
	_2:
		;
		infoPtr += 48
	}
	XTcl_SetObjResult(tls, interp, msg)
}

var _spaces = [21]uint8{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '}

/*
 *----------------------------------------------------------------------
 *
 * TclGetCompletionCodeFromObj --
 *
 *	Parses Completion code Code
 *
 * Results:
 *	Returns TCL_ERROR if the value is an invalid completion code.
 *	Otherwise, returns TCL_OK, and writes the completion code to the
 *	pointer provided.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclGetCompletionCodeFromObj(tls *libc.TLS, interp uintptr, value uintptr, codePtr uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument objects. */
	var v1 int32
	var v2 bool
	var v3 uintptr
	_, _, _ = v1, v2, v3
	if v2 = !((*TTcl_Obj)(unsafe.Pointer(value)).FtypePtr == uintptr(unsafe.Pointer(&XtclIndexType))); v2 {
		if (*TTcl_Obj)(unsafe.Pointer(value)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(value)).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(value)).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
			*(*int32)(unsafe.Pointer(codePtr)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(value)).FinternalRep)))
			v1 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1 = XTcl_GetIntFromObj(tls, libc.UintptrFromInt32(0), value, codePtr)
		}
	}
	if v2 && v1 == TCL_OK {
		return TCL_OK
	}
	if XTcl_GetIndexFromObjStruct(tls, libc.UintptrFromInt32(0), value, uintptr(unsafe.Pointer(&_returnCodes)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), libc.UintptrFromInt32(0), libc.Int32FromInt32(TCL_EXACT)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), codePtr) == TCL_OK {
		return TCL_OK
	}
	/*
	 * Value is not a legal completion code.
	 */
	if interp != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(value)).Fbytes != 0 {
			v3 = (*TTcl_Obj)(unsafe.Pointer(value)).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, value, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+38132, libc.VaList(bp+8, v3)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+38216, __ccgo_ts+38223, libc.UintptrFromInt32(0)))
	}
	return int32(TCL_ERROR)
}

var _returnCodes = [6]uintptr{
	0: __ccgo_ts + 38129,
	1: __ccgo_ts + 5181,
	2: __ccgo_ts + 5371,
	3: __ccgo_ts + 5123,
	4: __ccgo_ts + 5141,
	5: libc.UintptrFromInt32(0),
}

type TLimitHandler = struct {
	Fflags       int32
	FhandlerProc uintptr
	FclientData  uintptr
	FdeleteProc  uintptr
	FprevPtr     uintptr
	FnextPtr     uintptr
}

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * A pointer to a string that holds an initialization script that if non-NULL
 * is evaluated in Tcl_Init() prior to the built-in initialization script
 * above. This variable can be modified by the function below.
 */

var _tclPreInitScript = libc.UintptrFromInt32(0)

/* Forward declaration */
type TTarget1 = struct {
	FchildCmd    TTcl_Command
	FchildInterp uintptr
	FnextPtr     uintptr
	FprevPtr     uintptr
}

/*
 * Alias:
 *
 * Stores information about an alias. Is stored in the child interpreter and
 * used by the source command to find the target command in the parent when
 * the source command is invoked.
 */

type TAlias = struct {
	Ftoken         uintptr
	FtargetInterp  uintptr
	FchildCmd      TTcl_Command
	FaliasEntryPtr uintptr
	FtargetPtr     uintptr
	Fobjc          TTcl_Size
	FobjPtr        uintptr
}

/*
 *
 * Child:
 *
 * Used by the "interp" command to record and find information about child
 * interpreters. Maps from a command name in the parent to information about a
 * child interpreter, e.g. what aliases are defined in it.
 */

type TChild = struct {
	FparentInterp  uintptr
	FchildEntryPtr uintptr
	FchildInterp   uintptr
	FinterpCmd     TTcl_Command
	FaliasTable    TTcl_HashTable
}

/*
 * struct Target:
 *
 * Maps from parent interpreter commands back to the source commands in child
 * interpreters. This is needed because aliases can be created between sibling
 * interpreters and must be deleted when the target interpreter is deleted. In
 * case they would not be deleted the source interpreter would be left with a
 * "dangling pointer". One such record is stored in the Parent record of the
 * parent interpreter with the parent for each alias which directs to a
 * command in the parent. These records are used to remove the source command
 * for an from a child if/when the parent is deleted. They are organized in a
 * doubly-linked list attached to the parent interpreter.
 */

type TTarget = struct {
	FchildCmd    TTcl_Command
	FchildInterp uintptr
	FnextPtr     uintptr
	FprevPtr     uintptr
}

/*
 * Parent:
 *
 * This record is used for two purposes: First, childTable (a hashtable) maps
 * from names of commands to child interpreters. This hashtable is used to
 * store information about child interpreters of this interpreter, to map over
 * all children, etc. The second purpose is to store information about all
 * aliases in children (or siblings) which direct to target commands in this
 * interpreter (using the targetsPtr doubly-linked list).
 *
 * NB: the flags field in the interp structure, used with SAFE_INTERP mask
 * denotes whether the interpreter is safe or not. Safe interpreters have
 * restricted functionality, can only create safe interpreters and can
 * only load safe extensions.
 */

type TParent = struct {
	FchildTable TTcl_HashTable
	FtargetsPtr uintptr
	FidIssuer   TTcl_Size
}

/*
 * The following structure keeps track of all the Parent and Child information
 * on a per-interp basis.
 */

type TInterpInfo = struct {
	Fparent TParent
	Fchild  TChild
}

/*
 * Limit callbacks handled by scripts are modelled as structures which are
 * stored in hashes indexed by a two-word key. Note that the type of the
 * 'type' field in the key is not int; this is to make sure that things are
 * likely to work properly on 64-bit architectures.
 */

type TScriptLimitCallback = struct {
	Finterp    uintptr
	FscriptObj uintptr
	Ftype1     int32
	FentryPtr  uintptr
}

type TScriptLimitCallbackKey = struct {
	Finterp uintptr
	Ftype1  int64
}

/*
 * TIP#143 limit handler internal representation.
 */

type TLimitHandler1 = struct {
	Fflags       int32
	FhandlerProc uintptr
	FclientData  uintptr
	FdeleteProc  uintptr
	FprevPtr     uintptr
	FnextPtr     uintptr
}

/*
 * Values for the LimitHandler flags field.
 */
type LimitHandlerFlags = int32

const LIMIT_HANDLER_ACTIVE = 1
const /* The handler is currently being processed;
 * handlers are never to be reentered. */
LIMIT_HANDLER_DELETED = 2

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetPreInitScript --
 *
 *	This routine is used to change the value of the internal variable,
 *	tclPreInitScript.
 *
 * Results:
 *	Returns the current value of tclPreInitScript.
 *
 * Side effects:
 *	Changes the way Tcl_Init() routine behaves.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetPreInitScript(tls *libc.TLS, string1 uintptr) (r uintptr) {
	/* Pointer to a script. */
	var prevString uintptr
	_ = prevString
	prevString = _tclPreInitScript
	_tclPreInitScript = string1
	return prevString
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_Init --
 *
 *	This function is typically invoked by Tcl_AppInit functions to find
 *	and source the "init.tcl" script, which should exist somewhere on the
 *	Tcl library path.
 *
 * Results:
 *	Returns a standard Tcl completion code and sets the interp's result if
 *	there is an error.
 *
 * Side effects:
 *	Depends on what's in the init.tcl script.
 *
 *----------------------------------------------------------------------
 */

func XTcl_Init(tls *libc.TLS, interp uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Interpreter to initialize. */
	var names uintptr
	var result int32
	var _ /* pkgName at bp+0 */ struct {
		FnextPtr uintptr
		Fname    [4]uint8
	}
	_, _ = names, result
	*(*struct {
		FnextPtr uintptr
		Fname    [4]uint8
	})(unsafe.Pointer(bp)) = struct {
		FnextPtr uintptr
		Fname    [4]uint8
	}{
		Fname: [4]uint8{'t', 'c', 'l'},
	}
	names = XTclInitPkgFiles(tls, interp)
	result = int32(TCL_ERROR)
	(*(*struct {
		FnextPtr uintptr
		Fname    [4]uint8
	})(unsafe.Pointer(bp))).FnextPtr = *(*uintptr)(unsafe.Pointer(names))
	*(*uintptr)(unsafe.Pointer(names)) = bp
	if _tclPreInitScript != libc.UintptrFromInt32(0) {
		if XTcl_EvalEx(tls, interp, _tclPreInitScript, int64(-libc.Int32FromInt32(1)), 0) == int32(TCL_ERROR) {
			goto end
		}
	}
	/*
	 * In order to find init.tcl during initialization, the following script
	 * is invoked by Tcl_Init(). It looks in several different directories:
	 *
	 *	$tcl_library		- can specify a primary location, if set, no
	 *				  other locations will be checked. This is the
	 *				  recommended way for a program that embeds
	 *				  Tcl to specifically tell Tcl where to find
	 *				  an init.tcl file.
	 *
	 *	$env(TCL_LIBRARY)	- highest priority so user can always override
	 *				  the search path unless the application has
	 *				  specified an exact directory above
	 *
	 *	$tclDefaultLibrary	- INTERNAL: This variable is set by Tcl on
	 *				  those platforms where it can determine at
	 *				  runtime the directory where it expects the
	 *				  init.tcl file to be. After [tclInit] reads
	 *				  and uses this value, it [unset]s it.
	 *				  External users of Tcl should not make use of
	 *				  the variable to customize [tclInit].
	 *
	 *	$tcl_libPath		- OBSOLETE: This variable is no longer set by
	 *				  Tcl itself, but [tclInit] examines it in
	 *				  case some program that embeds Tcl is
	 *				  customizing [tclInit] by setting this
	 *				  variable to a list of directories in which
	 *				  to search.
	 *
	 *	[tcl::pkgconfig get scriptdir,runtime]
	 *				- the directory determined by configure to be
	 *				  the place where Tcl's script library is to
	 *				  be installed.
	 *
	 * The first directory on this path that contains a valid init.tcl script
	 * will be set as the value of tcl_library.
	 *
	 * Note that this entire search mechanism can be bypassed by defining an
	 * alternate tclInit command before calling Tcl_Init().
	 */
	result = XTcl_EvalEx(tls, interp, __ccgo_ts+38236, int64(-libc.Int32FromInt32(1)), 0)
	XTclpSetInitialEncodings(tls)
	goto end
end:
	;
	*(*uintptr)(unsafe.Pointer(names)) = (*struct {
		FnextPtr uintptr
		Fname    [4]uint8
	})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(names)))).FnextPtr
	return result
}

/*
 *---------------------------------------------------------------------------
 *
 * TclInterpInit --
 *
 *	Initializes the invoking interpreter for using the parent, child and
 *	safe interp facilities. This is called from inside Tcl_CreateInterp().
 *
 * Results:
 *	Always returns TCL_OK for backwards compatibility.
 *
 * Side effects:
 *	Adds the "interp" command to an interpreter and initializes the
 *	interpInfoPtr field of the invoking interpreter.
 *
 *---------------------------------------------------------------------------
 */

func XTclInterpInit(tls *libc.TLS, interp uintptr) (r int32) {
	/* Interpreter to initialize. */
	var childPtr, interpInfoPtr, parentPtr uintptr
	_, _, _ = childPtr, interpInfoPtr, parentPtr
	interpInfoPtr = XTcl_Alloc(tls, uint64(256))
	(*TInterp)(unsafe.Pointer(interp)).FinterpInfo = interpInfoPtr
	parentPtr = interpInfoPtr
	XTcl_InitHashTable(tls, parentPtr, TCL_STRING_KEYS)
	(*TParent)(unsafe.Pointer(parentPtr)).FtargetsPtr = libc.UintptrFromInt32(0)
	(*TParent)(unsafe.Pointer(parentPtr)).FidIssuer = 0
	childPtr = interpInfoPtr + 120
	(*TChild)(unsafe.Pointer(childPtr)).FparentInterp = libc.UintptrFromInt32(0)
	(*TChild)(unsafe.Pointer(childPtr)).FchildEntryPtr = libc.UintptrFromInt32(0)
	(*TChild)(unsafe.Pointer(childPtr)).FchildInterp = interp
	(*TChild)(unsafe.Pointer(childPtr)).FinterpCmd = libc.UintptrFromInt32(0)
	XTcl_InitHashTable(tls, childPtr+32, TCL_STRING_KEYS)
	XTcl_NRCreateCommand(tls, interp, __ccgo_ts+6485, __ccgo_fp(XTcl_InterpObjCmd), __ccgo_fp(_NRInterpCmd), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	XTcl_CallWhenDeleted(tls, interp, __ccgo_fp(_InterpInfoDeleteProc), libc.UintptrFromInt32(0))
	return TCL_OK
}

/*
 *---------------------------------------------------------------------------
 *
 * InterpInfoDeleteProc --
 *
 *	Invoked when an interpreter is being deleted. It releases all storage
 *	used by the parent/child/safe interpreter facilities.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Cleans up storage. Sets the interpInfoPtr field of the interp to NULL.
 *
 *---------------------------------------------------------------------------
 */

func _InterpInfoDeleteProc(tls *libc.TLS, dummy542 uintptr, interp uintptr) {
	/* Interp being deleted. All commands for
	 * child interps should already be deleted. */
	var childPtr, interpInfoPtr, parentPtr, targetPtr, tmpPtr uintptr
	_, _, _, _, _ = childPtr, interpInfoPtr, parentPtr, targetPtr, tmpPtr
	interpInfoPtr = (*TInterp)(unsafe.Pointer(interp)).FinterpInfo
	/*
	 * There shouldn't be any commands left.
	 */
	parentPtr = interpInfoPtr
	if (*TParent)(unsafe.Pointer(parentPtr)).FchildTable.FnumEntries != 0 {
		XTcl_Panic(tls, __ccgo_ts+40426, 0)
	}
	XTcl_DeleteHashTable(tls, parentPtr)
	/*
	 * Tell any interps that have aliases to this interp that they should
	 * delete those aliases. If the other interp was already dead, it would
	 * have removed the target record already.
	 */
	targetPtr = (*TParent)(unsafe.Pointer(parentPtr)).FtargetsPtr
	for {
		if !(targetPtr != libc.UintptrFromInt32(0)) {
			break
		}
		tmpPtr = (*TTarget)(unsafe.Pointer(targetPtr)).FnextPtr
		XTcl_DeleteCommandFromToken(tls, (*TTarget)(unsafe.Pointer(targetPtr)).FchildInterp, (*TTarget)(unsafe.Pointer(targetPtr)).FchildCmd)
		targetPtr = tmpPtr
		goto _1
	_1:
	}
	childPtr = interpInfoPtr + 120
	if (*TChild)(unsafe.Pointer(childPtr)).FinterpCmd != libc.UintptrFromInt32(0) {
		/*
		 * Tcl_DeleteInterp() was called on this interpreter, rather "interp
		 * delete" or the equivalent deletion of the command in the parent.
		 * First ensure that the cleanup callback doesn't try to delete the
		 * interp again.
		 */
		(*TChild)(unsafe.Pointer(childPtr)).FchildInterp = libc.UintptrFromInt32(0)
		XTcl_DeleteCommandFromToken(tls, (*TChild)(unsafe.Pointer(childPtr)).FparentInterp, (*TChild)(unsafe.Pointer(childPtr)).FinterpCmd)
	}
	/*
	 * There shouldn't be any aliases left.
	 */
	if (*TChild)(unsafe.Pointer(childPtr)).FaliasTable.FnumEntries != 0 {
		XTcl_Panic(tls, __ccgo_ts+40469, 0)
	}
	XTcl_DeleteHashTable(tls, childPtr+32)
	XTclpFree(tls, interpInfoPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_InterpObjCmd --
 *
 *	This function is invoked to process the "interp" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_InterpObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	return XTcl_NRCallObjProc(tls, interp, __ccgo_fp(_NRInterpCmd), clientData, int64(objc), objv)
}

func _NRInterpCmd(tls *libc.TLS, dummy630 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(224)
	defer tls.Free(224) /* Argument objects. */
	var _objPtr, aliasName, aliasPtr, cachePtr, childInterp, childPtr, hPtr, hPtr1, iiPtr, iiPtr1, iiPtr2, namespaceName, parentInfo, parentInterp, parentInterp1, resultObjPtr, resultPtr, string1, v25, v28, v30, v33, v34, v36, v39, v41, v44, v45, v46, v47, v48 uintptr
	var chan1 TTcl_Channel
	var exists, flags, last, safe int32
	var i, v32, v35, v40 TTcl_Size
	var v26, v31, v42 bool
	var _ /* buf at bp+8 */ [40]uint8
	var _ /* cmdInfo at bp+56 */ TTcl_CmdInfo
	var _ /* hashSearch at bp+144 */ TTcl_HashSearch
	var _ /* idx at bp+136 */ int32
	var _ /* idx at bp+4 */ int32
	var _ /* idx at bp+48 */ int32
	var _ /* index at bp+0 */ int32
	var _ /* limitType at bp+140 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, aliasName, aliasPtr, cachePtr, chan1, childInterp, childPtr, exists, flags, hPtr, hPtr1, i, iiPtr, iiPtr1, iiPtr2, last, namespaceName, parentInfo, parentInterp, parentInterp1, resultObjPtr, resultPtr, safe, string1, v25, v26, v28, v30, v31, v32, v33, v34, v35, v36, v39, v40, v41, v42, v44, v45, v46, v47, v48
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+40635)
		return int32(TCL_ERROR)
	}
	if XTcl_GetIndexFromObjStruct(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + 1*8)), uintptr(unsafe.Pointer(&_options11)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), libc.UintptrFromInt32(0), libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
		/* Don't report the "slaves" option as possibility */
		XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), uintptr(unsafe.Pointer(&_optionsNoSlaves)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp)
		return int32(TCL_ERROR)
	}
	switch *(*int32)(unsafe.Pointer(bp)) {
	case 0:
		goto _1
	case 1:
		goto _2
	case 2:
		goto _3
	case 3:
		goto _4
	case 5:
		goto _5
	case 6:
		goto _6
	case 7:
		goto _7
	case 8:
		goto _8
	case 9:
		goto _9
	case 10:
		goto _10
	case 11:
		goto _11
	case 12:
		goto _12
	case 13:
		goto _13
	case 14:
		goto _14
	case 15:
		goto _15
	case 16:
		goto _16
	case 17:
		goto _17
	case 4:
		goto _18
	case 19:
		goto _19
	case 18:
		goto _20
	case 21:
		goto _21
	case 20:
		goto _22
	default:
		goto _23
	}
	goto _24
_1:
	;
	if objc < int32(4) {
		goto aliasArgs
	}
	childInterp = _GetInterp(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
	if childInterp == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if objc == int32(4) {
		return _AliasDescribe(tls, interp, childInterp, *(*uintptr)(unsafe.Pointer(objv + 3*8)))
	}
	if v26 = objc == int32(5); v26 {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)))).Fbytes != 0 {
			v25 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)))).Fbytes
		} else {
			v25 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 4*8)), libc.UintptrFromInt32(0))
		}
	}
	if v26 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v25))) == int32('\000') {
		return _AliasDelete(tls, interp, childInterp, *(*uintptr)(unsafe.Pointer(objv + 3*8)))
	}
	if objc > int32(5) {
		parentInterp = _GetInterp(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 4*8)))
		if parentInterp == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
		return _AliasCreate(tls, interp, childInterp, parentInterp, *(*uintptr)(unsafe.Pointer(objv + 3*8)), *(*uintptr)(unsafe.Pointer(objv + 5*8)), int64(objc-int32(6)), objv+uintptr(6)*8)
	}
	goto aliasArgs
aliasArgs:
	;
	XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+40649)
	return int32(TCL_ERROR)
_2:
	;
	childInterp = _GetInterp2(tls, interp, int64(objc), objv)
	if childInterp == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	return _AliasList(tls, interp, childInterp)
_3:
	;
	if objc != int32(3) && objc != int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+40701)
		return int32(TCL_ERROR)
	}
	childInterp = _GetInterp(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
	if childInterp == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	return _ChildBgerror(tls, interp, childInterp, int64(objc-int32(3)), objv+uintptr(3)*8)
_4:
	;
	flags = 0
	i = int64(2)
	for {
		if !(i < int64(objc)) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
			v28 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
		} else {
			v28 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v28))) != int32('-') {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_cancelOptions)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+4) != TCL_OK {
			return int32(TCL_ERROR)
		}
		switch *(*int32)(unsafe.Pointer(bp + 4)) {
		case 0:
			/*
			 * The evaluation stack in the target interp is to be unwound.
			 */
			flags |= int32(TCL_CANCEL_UNWIND)
		case 1:
			i++
			goto endOfForLoop
		}
		goto _27
	_27:
		;
		i++
	}
	goto endOfForLoop
endOfForLoop:
	;
	if i < int64(objc-int32(2)) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+40726)
		return int32(TCL_ERROR)
	}
	/*
	 * Did they specify a child interp to cancel the script in progress
	 * in?  If not, use the current interp.
	 */
	if i < int64(objc) {
		childInterp = _GetInterp(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))
		if childInterp == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
		i++
	} else {
		childInterp = interp
	}
	if i < int64(objc) {
		resultObjPtr = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
		/*
		 * Tcl_CancelEval removes this reference.
		 */
		(*TTcl_Obj)(unsafe.Pointer(resultObjPtr)).FrefCount++
		i++
	} else {
		resultObjPtr = libc.UintptrFromInt32(0)
	}
	return XTcl_CancelEval(tls, childInterp, resultObjPtr, uintptr(0), flags)
_5:
	;
	safe = XTcl_IsSafe(tls, interp)
	/*
	 * Weird historical rules: "-safe" is accepted at the end, too.
	 */
	childPtr = libc.UintptrFromInt32(0)
	last = 0
	i = int64(2)
	for {
		if !(i < int64(objc)) {
			break
		}
		if v31 = last == 0; v31 {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
				v30 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
			} else {
				v30 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
			}
		}
		if v31 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v30))) == int32('-') {
			if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_createOptions)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+48) != TCL_OK {
				return int32(TCL_ERROR)
			}
			if *(*int32)(unsafe.Pointer(bp + 48)) == 0 {
				safe = int32(1)
				goto _29
			}
			i++
			last = int32(1)
		}
		if childPtr != libc.UintptrFromInt32(0) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+40763)
			return int32(TCL_ERROR)
		}
		if i < int64(objc) {
			childPtr = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
		}
		goto _29
	_29:
		;
		i++
	}
	(*(*[40]uint8)(unsafe.Pointer(bp + 8)))[0] = uint8('\000')
	if childPtr == libc.UintptrFromInt32(0) {
		parentInfo = (*TInterp)(unsafe.Pointer(interp)).FinterpInfo
		/*
		 * Create an anonymous interpreter -- we choose its name and the
		 * name of the command. We check that the command name that we use
		 * for the interpreter does not collide with an existing command
		 * in the parent interpreter.
		 */
		for cond := true; cond; cond = XTcl_GetCommandInfo(tls, interp, bp+8, bp+56) != 0 {
			v33 = parentInfo + 112
			v32 = *(*TTcl_Size)(unsafe.Pointer(v33))
			*(*TTcl_Size)(unsafe.Pointer(v33))++
			libc.X__builtin_snprintf(tls, bp+8, uint64(40), __ccgo_ts+40783, libc.VaList(bp+176, v32))
		}
		childPtr = XTcl_NewStringObj(tls, bp+8, int64(-int32(1)))
	}
	if _ChildCreate(tls, interp, childPtr, safe) == libc.UintptrFromInt32(0) {
		v34 = childPtr
		if v34 != 0 {
			if (*TTcl_Obj)(unsafe.Pointer(v34)).FrefCount == libc.Int64FromInt32(0) {
				_objPtr = v34
				v36 = _objPtr
				v35 = *(*TTcl_Size)(unsafe.Pointer(v36))
				*(*TTcl_Size)(unsafe.Pointer(v36))--
				if v35 <= libc.Int64FromInt32(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
		}
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, childPtr)
	return TCL_OK
_6:
	; /* TIP #378 */
	/*
	 * Currently only -frame supported, otherwise ?-option ?value??
	 */
	if objc < int32(3) || objc > int32(5) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+40793)
		return int32(TCL_ERROR)
	}
	childInterp = _GetInterp(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
	if childInterp == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	return _ChildDebugCmd(tls, interp, childInterp, int64(objc-int32(3)), objv+uintptr(3)*8)
_7:
	;
	i = int64(2)
	for {
		if !(i < int64(objc)) {
			break
		}
		childInterp = _GetInterp(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))
		if childInterp == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		} else {
			if childInterp == interp {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+40814, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+176, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+40852, __ccgo_ts+40859, libc.UintptrFromInt32(0)))
				return int32(TCL_ERROR)
			}
		}
		iiPtr = (*TInterp)(unsafe.Pointer(childInterp)).FinterpInfo
		XTcl_DeleteCommandFromToken(tls, (*TInterpInfo)(unsafe.Pointer(iiPtr)).Fchild.FparentInterp, (*TInterpInfo)(unsafe.Pointer(iiPtr)).Fchild.FinterpCmd)
		goto _37
	_37:
		;
		i++
	}
	return TCL_OK
_8:
	;
	if objc < int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+40870)
		return int32(TCL_ERROR)
	}
	childInterp = _GetInterp(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
	if childInterp == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	return _ChildEval(tls, interp, childInterp, int64(objc-int32(3)), objv+uintptr(3)*8)
_9:
	;
	exists = int32(1)
	childInterp = _GetInterp2(tls, interp, int64(objc), objv)
	if childInterp == libc.UintptrFromInt32(0) {
		if objc > int32(3) {
			return int32(TCL_ERROR)
		}
		XTcl_ResetResult(tls, interp)
		exists = 0
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(exists != 0)))
	return TCL_OK
_10:
	;
	if objc < int32(4) || objc > int32(5) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+40889)
		return int32(TCL_ERROR)
	}
	childInterp = _GetInterp(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
	if childInterp == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	return _ChildExpose(tls, interp, childInterp, int64(objc-int32(3)), objv+uintptr(3)*8)
_11:
	;
	if objc < int32(4) || objc > int32(5) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+40918)
		return int32(TCL_ERROR)
	}
	childInterp = _GetInterp(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
	if childInterp == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	return _ChildHide(tls, interp, childInterp, int64(objc-int32(3)), objv+uintptr(3)*8)
_12:
	;
	childInterp = _GetInterp2(tls, interp, int64(objc), objv)
	if childInterp == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	return _ChildHidden(tls, interp, childInterp)
_13:
	;
	childInterp = _GetInterp2(tls, interp, int64(objc), objv)
	if childInterp == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(XTcl_IsSafe(tls, childInterp) != 0)))
	return TCL_OK
_14:
	;
	namespaceName = libc.UintptrFromInt32(0)
	i = int64(3)
	for {
		if !(i < int64(objc)) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
			v39 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
		} else {
			v39 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v39))) != int32('-') {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_hiddenOptions)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+136) != TCL_OK {
			return int32(TCL_ERROR)
		}
		if *(*int32)(unsafe.Pointer(bp + 136)) == 0 {
			namespaceName = __ccgo_ts + 7650
		} else {
			if *(*int32)(unsafe.Pointer(bp + 136)) == 1 {
				i++
				v40 = i
				if v40 == int64(objc) { /* There must be more arguments. */
					break
				} else {
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
						v41 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
					} else {
						v41 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
					}
					namespaceName = v41
				}
			} else {
				i++
				break
			}
		}
		goto _38
	_38:
		;
		i++
	}
	if int64(objc)-i < int64(1) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+40955)
		return int32(TCL_ERROR)
	}
	childInterp = _GetInterp(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
	if childInterp == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	return _ChildInvokeHidden(tls, interp, childInterp, namespaceName, int64(objc)-i, objv+uintptr(i)*8)
_15:
	;
	if objc < int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+41004)
		return int32(TCL_ERROR)
	}
	childInterp = _GetInterp(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
	if childInterp == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)), uintptr(unsafe.Pointer(&_limitTypes)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+41039, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+140) != TCL_OK {
		return int32(TCL_ERROR)
	}
	switch *(*int32)(unsafe.Pointer(bp + 140)) {
	case 0:
		return _ChildCommandLimitCmd(tls, interp, childInterp, int64(4), int64(objc), objv)
	case 1:
		return _ChildTimeLimitCmd(tls, interp, childInterp, int64(4), int64(objc), objv)
	default:
		XTcl_Panic(tls, __ccgo_ts+41050, 0)
		return int32(TCL_ERROR)
	}
_16:
	;
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+34695)
		return int32(TCL_ERROR)
	}
	childInterp = _GetInterp(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
	if childInterp == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	return _ChildMarkTrusted(tls, interp, childInterp)
_17:
	;
	if objc != int32(3) && objc != int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+41062)
		return int32(TCL_ERROR)
	}
	childInterp = _GetInterp(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
	if childInterp == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	return _ChildRecursionLimit(tls, interp, childInterp, int64(objc-int32(3)), objv+uintptr(3)*8)
_19:
	;
_18:
	;
	childInterp = _GetInterp2(tls, interp, int64(objc), objv)
	if childInterp == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	iiPtr1 = (*TInterp)(unsafe.Pointer(childInterp)).FinterpInfo
	if v42 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v42 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v42 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultPtr = XTclThreadAllocObj(tls)
	} else {
		resultPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FtypePtr = libc.UintptrFromInt32(0)
	hPtr = XTcl_FirstHashEntry(tls, iiPtr1, bp+144)
	for {
		if !(hPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TTcl_HashTable)(unsafe.Pointer(iiPtr1)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(iiPtr1)).FkeyType == -int32(1) {
			v44 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
		} else {
			v44 = hPtr + 32
		}
		string1 = v44
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultPtr, XTcl_NewStringObj(tls, string1, int64(-int32(1))))
		goto _43
	_43:
		;
		hPtr = XTcl_NextHashEntry(tls, bp+144)
	}
	XTcl_SetObjResult(tls, interp, resultPtr)
	return TCL_OK
_21:
	;
_20:
	;
	if objc != int32(5) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+41078)
		return int32(TCL_ERROR)
	}
	parentInterp1 = _GetInterp(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
	if parentInterp1 == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes != 0 {
		v45 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes
	} else {
		v45 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0))
	}
	chan1 = XTcl_GetChannel(tls, parentInterp1, v45, libc.UintptrFromInt32(0))
	if chan1 == libc.UintptrFromInt32(0) {
		XTcl_TransferResult(tls, parentInterp1, TCL_OK, interp)
		return int32(TCL_ERROR)
	}
	childInterp = _GetInterp(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 4*8)))
	if childInterp == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	XTcl_RegisterChannel(tls, childInterp, chan1)
	if *(*int32)(unsafe.Pointer(bp)) == 21 {
		/*
		 * When transferring, as opposed to sharing, we must unhitch the
		 * channel from the interpreter where it started.
		 */
		if XTcl_UnregisterChannel(tls, parentInterp1, chan1) != TCL_OK {
			XTcl_TransferResult(tls, parentInterp1, TCL_OK, interp)
			return int32(TCL_ERROR)
		}
	}
	return TCL_OK
_22:
	;
	if objc != int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+41103)
		return int32(TCL_ERROR)
	}
	childInterp = _GetInterp(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
	if childInterp == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes != 0 {
		v46 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes
	} else {
		v46 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0))
	}
	aliasName = v46
	iiPtr2 = (*TInterp)(unsafe.Pointer(childInterp)).FinterpInfo
	hPtr1 = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iiPtr2 + 120 + 32)).FfindProc})))(tls, iiPtr2+120+32, aliasName)
	if hPtr1 == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v47 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v47 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+41114, libc.VaList(bp+176, aliasName, v47)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+176, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+41148, aliasName, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	aliasPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr1)).FclientData
	if XTcl_GetInterpPath(tls, interp, (*TAlias)(unsafe.Pointer(aliasPtr)).FtargetInterp) != TCL_OK {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v48 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v48 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+41154, libc.VaList(bp+176, aliasName, v48)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+176, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+40852, __ccgo_ts+41222, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	return TCL_OK
_23:
	;
	XTcl_Panic(tls, __ccgo_ts+41050, 0)
	return int32(TCL_ERROR)
_24:
	;
	return r
}

var _options11 = [23]uintptr{
	0:  __ccgo_ts + 6479,
	1:  __ccgo_ts + 40511,
	2:  __ccgo_ts + 30789,
	3:  __ccgo_ts + 40519,
	4:  __ccgo_ts + 40526,
	5:  __ccgo_ts + 26194,
	6:  __ccgo_ts + 40535,
	7:  __ccgo_ts + 5663,
	8:  __ccgo_ts + 2464,
	9:  __ccgo_ts + 5689,
	10: __ccgo_ts + 40541,
	11: __ccgo_ts + 40548,
	12: __ccgo_ts + 35112,
	13: __ccgo_ts + 40553,
	14: __ccgo_ts + 40560,
	15: __ccgo_ts + 40573,
	16: __ccgo_ts + 40579,
	17: __ccgo_ts + 40591,
	18: __ccgo_ts + 40606,
	19: __ccgo_ts + 40612,
	20: __ccgo_ts + 40619,
	21: __ccgo_ts + 40626,
	22: libc.UintptrFromInt32(0),
}

var _optionsNoSlaves = [22]uintptr{
	0:  __ccgo_ts + 6479,
	1:  __ccgo_ts + 40511,
	2:  __ccgo_ts + 30789,
	3:  __ccgo_ts + 40519,
	4:  __ccgo_ts + 40526,
	5:  __ccgo_ts + 26194,
	6:  __ccgo_ts + 40535,
	7:  __ccgo_ts + 5663,
	8:  __ccgo_ts + 2464,
	9:  __ccgo_ts + 5689,
	10: __ccgo_ts + 40541,
	11: __ccgo_ts + 40548,
	12: __ccgo_ts + 35112,
	13: __ccgo_ts + 40553,
	14: __ccgo_ts + 40560,
	15: __ccgo_ts + 40573,
	16: __ccgo_ts + 40579,
	17: __ccgo_ts + 40591,
	18: __ccgo_ts + 40606,
	19: __ccgo_ts + 40619,
	20: __ccgo_ts + 40626,
	21: libc.UintptrFromInt32(0),
}

var _cancelOptions = [3]uintptr{
	0: __ccgo_ts + 40718,
	1: __ccgo_ts + 18684,
	2: libc.UintptrFromInt32(0),
}

var _createOptions = [3]uintptr{
	0: __ccgo_ts + 40757,
	1: __ccgo_ts + 18684,
	2: libc.UintptrFromInt32(0),
}

var _hiddenOptions = [4]uintptr{
	0: __ccgo_ts + 40947,
	1: __ccgo_ts + 29556,
	2: __ccgo_ts + 18684,
	3: libc.UintptrFromInt32(0),
}

var _limitTypes = [3]uintptr{
	0: __ccgo_ts + 16009,
	1: __ccgo_ts + 5581,
	2: libc.UintptrFromInt32(0),
}

/*
 *---------------------------------------------------------------------------
 *
 * GetInterp2 --
 *
 *	Helper function for Tcl_InterpObjCmd() to convert the interp name
 *	potentially specified on the command line to an Tcl_Interp.
 *
 * Results:
 *	The return value is the interp specified on the command line, or the
 *	interp argument itself if no interp was specified on the command line.
 *	If the interp could not be found or the wrong number of arguments was
 *	specified on the command line, the return value is NULL and an error
 *	message is left in the interp's result.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func _GetInterp2(tls *libc.TLS, interp uintptr, objc TTcl_Size, objv uintptr) (r uintptr) {
	/* Argument objects. */
	if objc == int64(2) {
		return interp
	} else {
		if objc == int64(3) {
			return _GetInterp(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
		} else {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+41237)
			return libc.UintptrFromInt32(0)
		}
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_CreateAlias --
 *
 *	Creates an alias between two interpreters.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Creates a new alias, manipulates the result field of childInterp.
 *
 *----------------------------------------------------------------------
 */

func XTcl_CreateAlias(tls *libc.TLS, childInterp uintptr, childCmd uintptr, targetInterp uintptr, targetCmd uintptr, argc TTcl_Size, argv uintptr) (r int32) {
	/* These are the additional args. */
	var _objPtr, _objPtr1, _objPtr2, childObjPtr, objv, targetObjPtr, v4, v6, v8 uintptr
	var i, v3, v5, v7 TTcl_Size
	var result int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, childObjPtr, i, objv, result, targetObjPtr, v3, v4, v5, v6, v7, v8
	objv = XTclStackAlloc(tls, childInterp, uint64(8)*libc.Uint64FromInt64(argc))
	i = 0
	for {
		if !(i < argc) {
			break
		}
		*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) = XTcl_NewStringObj(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)), int64(-int32(1)))
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FrefCount++
		goto _1
	_1:
		;
		i++
	}
	childObjPtr = XTcl_NewStringObj(tls, childCmd, int64(-int32(1)))
	(*TTcl_Obj)(unsafe.Pointer(childObjPtr)).FrefCount++
	targetObjPtr = XTcl_NewStringObj(tls, targetCmd, int64(-int32(1)))
	(*TTcl_Obj)(unsafe.Pointer(targetObjPtr)).FrefCount++
	result = _AliasCreate(tls, childInterp, childInterp, targetInterp, childObjPtr, targetObjPtr, argc, objv)
	i = 0
	for {
		if !(i < argc) {
			break
		}
		_objPtr = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
		v4 = _objPtr
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		goto _2
	_2:
		;
		i++
	}
	XTclStackFree(tls, childInterp, objv)
	_objPtr1 = targetObjPtr
	v6 = _objPtr1
	v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
	*(*TTcl_Size)(unsafe.Pointer(v6))--
	if v5 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	_objPtr2 = childObjPtr
	v8 = _objPtr2
	v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
	*(*TTcl_Size)(unsafe.Pointer(v8))--
	if v7 <= int64(1) {
		XTclFreeObj(tls, _objPtr2)
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_CreateAliasObj --
 *
 *	Object version: Creates an alias between two interpreters.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Creates a new alias.
 *
 *----------------------------------------------------------------------
 */

func XTcl_CreateAliasObj(tls *libc.TLS, childInterp uintptr, childCmd uintptr, targetInterp uintptr, targetCmd uintptr, objc TTcl_Size, objv uintptr) (r int32) {
	/* Argument vector. */
	var _objPtr, _objPtr1, childObjPtr, targetObjPtr, v2, v4 uintptr
	var result int32
	var v1, v3 TTcl_Size
	_, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, childObjPtr, result, targetObjPtr, v1, v2, v3, v4
	childObjPtr = XTcl_NewStringObj(tls, childCmd, int64(-int32(1)))
	(*TTcl_Obj)(unsafe.Pointer(childObjPtr)).FrefCount++
	targetObjPtr = XTcl_NewStringObj(tls, targetCmd, int64(-int32(1)))
	(*TTcl_Obj)(unsafe.Pointer(targetObjPtr)).FrefCount++
	result = _AliasCreate(tls, childInterp, childInterp, targetInterp, childObjPtr, targetObjPtr, objc, objv)
	_objPtr = childObjPtr
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	_objPtr1 = targetObjPtr
	v4 = _objPtr1
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	if v3 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetAliasObj --
 *
 *	Object version: Gets information about an alias.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetAliasObj(tls *libc.TLS, interp uintptr, aliasName uintptr, targetInterpPtr uintptr, targetCmdPtr uintptr, objcPtr uintptr, objvPtr uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* (Return) additional args. */
	var aliasPtr, hPtr, iiPtr, objv, v1 uintptr
	var objc TTcl_Size
	_, _, _, _, _, _ = aliasPtr, hPtr, iiPtr, objc, objv, v1
	iiPtr = (*TInterp)(unsafe.Pointer(interp)).FinterpInfo
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iiPtr + 120 + 32)).FfindProc})))(tls, iiPtr+120+32, aliasName)
	if hPtr == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+41244, libc.VaList(bp+8, aliasName)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+41148, aliasName, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	aliasPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
	objc = (*TAlias)(unsafe.Pointer(aliasPtr)).Fobjc
	objv = aliasPtr + 48
	if targetInterpPtr != libc.UintptrFromInt32(0) {
		*(*uintptr)(unsafe.Pointer(targetInterpPtr)) = (*TAlias)(unsafe.Pointer(aliasPtr)).FtargetInterp
	}
	if targetCmdPtr != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv)), libc.UintptrFromInt32(0))
		}
		*(*uintptr)(unsafe.Pointer(targetCmdPtr)) = v1
	}
	if objcPtr != libc.UintptrFromInt32(0) {
		*(*TTcl_Size)(unsafe.Pointer(objcPtr)) = objc - int64(1)
	}
	if objvPtr != libc.UintptrFromInt32(0) {
		*(*uintptr)(unsafe.Pointer(objvPtr)) = objv + uintptr(1)*8
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclPreventAliasLoop --
 *
 *	When defining an alias or renaming a command, prevent an alias loop
 *	from being formed.
 *
 * Results:
 *	A standard Tcl object result.
 *
 * Side effects:
 *	If TCL_ERROR is returned, the function also stores an error message in
 *	the interpreter's result object.
 *
 * NOTE:
 *	This function is public internal (instead of being static to this
 *	file) because it is also used from TclRenameCommand.
 *
 *----------------------------------------------------------------------
 */

func XTclPreventAliasLoop(tls *libc.TLS, interp uintptr, cmdInterp uintptr, cmd TTcl_Command) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Tcl command we are attempting to define. */
	var aliasCmd TTcl_Command
	var aliasCmdPtr, aliasPtr, cmdNamePtr, cmdPtr, nextAliasPtr, v1 uintptr
	_, _, _, _, _, _, _ = aliasCmd, aliasCmdPtr, aliasPtr, cmdNamePtr, cmdPtr, nextAliasPtr, v1
	cmdPtr = cmd
	/*
	 * If we are not creating or renaming an alias, then it is always OK to
	 * create or rename the command.
	 */
	if (*TCommand)(unsafe.Pointer(cmdPtr)).FobjProc != __ccgo_fp(XTclAliasObjCmd) && (*TCommand)(unsafe.Pointer(cmdPtr)).FobjProc != __ccgo_fp(XTclLocalAliasObjCmd) {
		return TCL_OK
	}
	/*
	 * OK, we are dealing with an alias, so traverse the chain of aliases. If
	 * we encounter the alias we are defining (or renaming to) any in the
	 * chain then we have a loop.
	 */
	aliasPtr = (*TCommand)(unsafe.Pointer(cmdPtr)).FobjClientData
	nextAliasPtr = aliasPtr
	for int32(1) != 0 {
		/*
		 * If the target of the next alias in the chain is the same as the
		 * source alias, we have a loop.
		 */
		if XTcl_InterpDeleted(tls, (*TAlias)(unsafe.Pointer(nextAliasPtr)).FtargetInterp) != 0 {
			/*
			 * The child interpreter can be deleted while creating the alias.
			 * [Bug #641195]
			 */
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+41265, libc.VaList(bp+8, XTcl_GetCommandName(tls, cmdInterp, cmd))))
			return int32(TCL_ERROR)
		}
		cmdNamePtr = (*TAlias)(unsafe.Pointer(nextAliasPtr)).FobjPtr
		if (*TTcl_Obj)(unsafe.Pointer(cmdNamePtr)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(cmdNamePtr)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, cmdNamePtr, libc.UintptrFromInt32(0))
		}
		aliasCmd = XTcl_FindCommand(tls, (*TAlias)(unsafe.Pointer(nextAliasPtr)).FtargetInterp, v1, XTcl_GetGlobalNamespace(tls, (*TAlias)(unsafe.Pointer(nextAliasPtr)).FtargetInterp), 0)
		if aliasCmd == libc.UintptrFromInt32(0) {
			return TCL_OK
		}
		aliasCmdPtr = aliasCmd
		if aliasCmdPtr == cmdPtr {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+41321, libc.VaList(bp+8, XTcl_GetCommandName(tls, cmdInterp, cmd))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+40852, __ccgo_ts+41377, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		/*
		 * Otherwise, follow the chain one step further. See if the target
		 * command is an alias - if so, follow the loop to its target command.
		 * Otherwise we do not have a loop.
		 */
		if (*TCommand)(unsafe.Pointer(aliasCmdPtr)).FobjProc != __ccgo_fp(XTclAliasObjCmd) && (*TCommand)(unsafe.Pointer(aliasCmdPtr)).FobjProc != __ccgo_fp(XTclLocalAliasObjCmd) {
			return TCL_OK
		}
		nextAliasPtr = (*TCommand)(unsafe.Pointer(aliasCmdPtr)).FobjClientData
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * AliasCreate --
 *
 *	Helper function to do the work to actually create an alias.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	An alias command is created and entered into the alias table for the
 *	child interpreter.
 *
 *----------------------------------------------------------------------
 */

func _AliasCreate(tls *libc.TLS, interp uintptr, childInterp uintptr, parentInterp uintptr, namePtr uintptr, targetCmdPtr uintptr, objc TTcl_Size, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* with alias. */
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, aliasPtr, cachePtr, childPtr, cmdPtr, hPtr, newToken, parentPtr, prefv, string1, targetPtr, v11, v12, v15, v2, v3, v4, v6, v8 uintptr
	var i, v10, v14, v5, v7 TTcl_Size
	var v13 bool
	var _ /* isNew at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, aliasPtr, cachePtr, childPtr, cmdPtr, hPtr, i, newToken, parentPtr, prefv, string1, targetPtr, v10, v11, v12, v13, v14, v15, v2, v3, v4, v5, v6, v7, v8
	aliasPtr = XTcl_Alloc(tls, uint64(56)+libc.Uint64FromInt64(objc)*uint64(8))
	(*TAlias)(unsafe.Pointer(aliasPtr)).Ftoken = namePtr
	(*TTcl_Obj)(unsafe.Pointer((*TAlias)(unsafe.Pointer(aliasPtr)).Ftoken)).FrefCount++
	(*TAlias)(unsafe.Pointer(aliasPtr)).FtargetInterp = parentInterp
	(*TAlias)(unsafe.Pointer(aliasPtr)).Fobjc = objc + int64(1)
	prefv = aliasPtr + 48
	*(*uintptr)(unsafe.Pointer(prefv)) = targetCmdPtr
	(*TTcl_Obj)(unsafe.Pointer(targetCmdPtr)).FrefCount++
	i = 0
	for {
		if !(i < objc) {
			break
		}
		prefv += 8
		v2 = prefv
		*(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FrefCount++
		goto _1
	_1:
		;
		i++
	}
	XTcl_Preserve(tls, childInterp)
	XTcl_Preserve(tls, parentInterp)
	if childInterp == parentInterp {
		if (*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes != 0 {
			v3 = (*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, namePtr, libc.UintptrFromInt32(0))
		}
		(*TAlias)(unsafe.Pointer(aliasPtr)).FchildCmd = XTcl_NRCreateCommand(tls, childInterp, v3, __ccgo_fp(XTclLocalAliasObjCmd), __ccgo_fp(_AliasNRCmd), aliasPtr, __ccgo_fp(_AliasObjCmdDeleteProc))
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes != 0 {
			v4 = (*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes
		} else {
			v4 = XTcl_GetStringFromObj(tls, namePtr, libc.UintptrFromInt32(0))
		}
		(*TAlias)(unsafe.Pointer(aliasPtr)).FchildCmd = XTcl_CreateObjCommand(tls, childInterp, v4, __ccgo_fp(XTclAliasObjCmd), aliasPtr, __ccgo_fp(_AliasObjCmdDeleteProc))
	}
	if XTclPreventAliasLoop(tls, interp, childInterp, (*TAlias)(unsafe.Pointer(aliasPtr)).FchildCmd) != TCL_OK {
		_objPtr = (*TAlias)(unsafe.Pointer(aliasPtr)).Ftoken
		v6 = _objPtr
		v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
		*(*TTcl_Size)(unsafe.Pointer(v6))--
		if v5 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		_objPtr1 = targetCmdPtr
		v8 = _objPtr1
		v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
		*(*TTcl_Size)(unsafe.Pointer(v8))--
		if v7 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		i = 0
		for {
			if !(i < objc) {
				break
			}
			_objPtr2 = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
			v11 = _objPtr2
			v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
			*(*TTcl_Size)(unsafe.Pointer(v11))--
			if v10 <= int64(1) {
				XTclFreeObj(tls, _objPtr2)
			}
			goto _9
		_9:
			;
			i++
		}
		cmdPtr = (*TAlias)(unsafe.Pointer(aliasPtr)).FchildCmd
		(*TCommand)(unsafe.Pointer(cmdPtr)).FclientData = libc.UintptrFromInt32(0)
		(*TCommand)(unsafe.Pointer(cmdPtr)).FdeleteProc = libc.UintptrFromInt32(0)
		(*TCommand)(unsafe.Pointer(cmdPtr)).FdeleteData = libc.UintptrFromInt32(0)
		XTcl_DeleteCommandFromToken(tls, childInterp, (*TAlias)(unsafe.Pointer(aliasPtr)).FchildCmd)
		XTclpFree(tls, aliasPtr)
		/*
		 * The result was already set by TclPreventAliasLoop.
		 */
		XTcl_Release(tls, childInterp)
		XTcl_Release(tls, parentInterp)
		return int32(TCL_ERROR)
	}
	/*
	 * Make an entry in the alias table. If it already exists, retry.
	 */
	childPtr = (*TInterp)(unsafe.Pointer(childInterp)).FinterpInfo + 120
	for int32(1) != 0 {
		if (*TTcl_Obj)(unsafe.Pointer((*TAlias)(unsafe.Pointer(aliasPtr)).Ftoken)).Fbytes != 0 {
			v12 = (*TTcl_Obj)(unsafe.Pointer((*TAlias)(unsafe.Pointer(aliasPtr)).Ftoken)).Fbytes
		} else {
			v12 = XTcl_GetStringFromObj(tls, (*TAlias)(unsafe.Pointer(aliasPtr)).Ftoken, libc.UintptrFromInt32(0))
		}
		string1 = v12
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(childPtr + 32)).FcreateProc})))(tls, childPtr+32, string1, bp)
		if *(*int32)(unsafe.Pointer(bp)) != 0 {
			break
		}
		/*
		 * The alias name cannot be used as unique token, it is already taken.
		 * We can produce a unique token by prepending "::" repeatedly. This
		 * algorithm is a stop-gap to try to maintain the command name as
		 * token for most use cases, fearful of possible backwards compat
		 * problems. A better algorithm would produce unique tokens that need
		 * not be related to the command name.
		 *
		 * ATTENTION: the tests in interp.test and possibly safe.test depend
		 * on the precise definition of these tokens.
		 */
		if v13 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v13 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v13 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			newToken = XTclThreadAllocObj(tls)
		} else {
			newToken = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(newToken + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(newToken)).FrefCount = 0
		if libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer(newToken)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(newToken)).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(newToken)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(newToken)).Fbytes, __ccgo_ts+7650, libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(newToken)).Fbytes + uintptr(libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(newToken)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(3) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer(newToken)).FtypePtr = libc.UintptrFromInt32(0)
		XTcl_AppendObjToObj(tls, newToken, (*TAlias)(unsafe.Pointer(aliasPtr)).Ftoken)
		_objPtr3 = (*TAlias)(unsafe.Pointer(aliasPtr)).Ftoken
		v15 = _objPtr3
		v14 = *(*TTcl_Size)(unsafe.Pointer(v15))
		*(*TTcl_Size)(unsafe.Pointer(v15))--
		if v14 <= int64(1) {
			XTclFreeObj(tls, _objPtr3)
		}
		(*TAlias)(unsafe.Pointer(aliasPtr)).Ftoken = newToken
		(*TTcl_Obj)(unsafe.Pointer((*TAlias)(unsafe.Pointer(aliasPtr)).Ftoken)).FrefCount++
	}
	(*TAlias)(unsafe.Pointer(aliasPtr)).FaliasEntryPtr = hPtr
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = aliasPtr
	/*
	 * Create the new command. We must do it after deleting any old command,
	 * because the alias may be pointing at a renamed alias, as in:
	 *
	 * interp alias {} foo {} bar		# Create an alias "foo"
	 * rename foo zop				# Now rename the alias
	 * interp alias {} foo {} zop		# Now recreate "foo"...
	 */
	targetPtr = XTcl_Alloc(tls, uint64(32))
	(*TTarget)(unsafe.Pointer(targetPtr)).FchildCmd = (*TAlias)(unsafe.Pointer(aliasPtr)).FchildCmd
	(*TTarget)(unsafe.Pointer(targetPtr)).FchildInterp = childInterp
	parentPtr = (*TInterp)(unsafe.Pointer(parentInterp)).FinterpInfo
	(*TTarget)(unsafe.Pointer(targetPtr)).FnextPtr = (*TParent)(unsafe.Pointer(parentPtr)).FtargetsPtr
	(*TTarget)(unsafe.Pointer(targetPtr)).FprevPtr = libc.UintptrFromInt32(0)
	if (*TParent)(unsafe.Pointer(parentPtr)).FtargetsPtr != libc.UintptrFromInt32(0) {
		(*TTarget)(unsafe.Pointer((*TParent)(unsafe.Pointer(parentPtr)).FtargetsPtr)).FprevPtr = targetPtr
	}
	(*TParent)(unsafe.Pointer(parentPtr)).FtargetsPtr = targetPtr
	(*TAlias)(unsafe.Pointer(aliasPtr)).FtargetPtr = targetPtr
	XTcl_SetObjResult(tls, interp, (*TAlias)(unsafe.Pointer(aliasPtr)).Ftoken)
	XTcl_Release(tls, childInterp)
	XTcl_Release(tls, parentInterp)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * AliasDelete --
 *
 *	Deletes the given alias from the child interpreter given.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Deletes the alias from the child interpreter.
 *
 *----------------------------------------------------------------------
 */

func _AliasDelete(tls *libc.TLS, interp uintptr, childInterp uintptr, namePtr uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Name of alias to delete. */
	var aliasPtr, childPtr, hPtr, v1, v2, v3 uintptr
	_, _, _, _, _, _ = aliasPtr, childPtr, hPtr, v1, v2, v3
	/*
	 * If the alias has been renamed in the child, the parent can still use
	 * the original name (with which it was created) to find the alias to
	 * delete it.
	 */
	childPtr = (*TInterp)(unsafe.Pointer(childInterp)).FinterpInfo + 120
	if (*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, namePtr, libc.UintptrFromInt32(0))
	}
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(childPtr + 32)).FfindProc})))(tls, childPtr+32, v1)
	if hPtr == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, namePtr, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+41244, libc.VaList(bp+8, v2)))
		if (*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes != 0 {
			v3 = (*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, namePtr, libc.UintptrFromInt32(0))
		}
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+41148, v3, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	aliasPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
	XTcl_DeleteCommandFromToken(tls, childInterp, (*TAlias)(unsafe.Pointer(aliasPtr)).FchildCmd)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * AliasDescribe --
 *
 *	Sets the interpreter's result object to a Tcl list describing the
 *	given alias in the given interpreter: its target command and the
 *	additional arguments to prepend to any invocation of the alias.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _AliasDescribe(tls *libc.TLS, interp uintptr, childInterp uintptr, namePtr uintptr) (r int32) {
	/* Name of alias to describe. */
	var aliasPtr, childPtr, hPtr, prefixPtr, v1 uintptr
	_, _, _, _, _ = aliasPtr, childPtr, hPtr, prefixPtr, v1
	/*
	 * If the alias has been renamed in the child, the parent can still use
	 * the original name (with which it was created) to find the alias to
	 * describe it.
	 */
	childPtr = (*TInterp)(unsafe.Pointer(childInterp)).FinterpInfo + 120
	if (*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, namePtr, libc.UintptrFromInt32(0))
	}
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(childPtr + 32)).FfindProc})))(tls, childPtr+32, v1)
	if hPtr == libc.UintptrFromInt32(0) {
		return TCL_OK
	}
	aliasPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
	prefixPtr = XTcl_NewListObj(tls, (*TAlias)(unsafe.Pointer(aliasPtr)).Fobjc, aliasPtr+48)
	XTcl_SetObjResult(tls, interp, prefixPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * AliasList --
 *
 *	Computes a list of aliases defined in a child interpreter.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _AliasList(tls *libc.TLS, interp uintptr, childInterp uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Interp whose aliases to compute. */
	var aliasPtr, cachePtr, childPtr, entryPtr, resultPtr uintptr
	var v1 bool
	var _ /* hashSearch at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _ = aliasPtr, cachePtr, childPtr, entryPtr, resultPtr, v1
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultPtr = XTclThreadAllocObj(tls)
	} else {
		resultPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FtypePtr = libc.UintptrFromInt32(0)
	childPtr = (*TInterp)(unsafe.Pointer(childInterp)).FinterpInfo + 120
	entryPtr = XTcl_FirstHashEntry(tls, childPtr+32, bp)
	for {
		if !(entryPtr != libc.UintptrFromInt32(0)) {
			break
		}
		aliasPtr = (*TTcl_HashEntry)(unsafe.Pointer(entryPtr)).FclientData
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultPtr, (*TAlias)(unsafe.Pointer(aliasPtr)).Ftoken)
		goto _2
	_2:
		;
		entryPtr = XTcl_NextHashEntry(tls, bp)
	}
	XTcl_SetObjResult(tls, interp, resultPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclAliasObjCmd, TclLocalAliasObjCmd --
 *
 *	This is the function that services invocations of aliases in a child
 *	interpreter. One such command exists for each alias. When invoked,
 *	this function redirects the invocation to the target command in the
 *	parent interpreter as designated by the Alias record associated with
 *	this command.
 *
 *	TclLocalAliasObjCmd is a stripped down version used when the source
 *	and target interpreters of the alias are the same. That lets a number
 *	of safety precautions be avoided: the state is much more precisely
 *	known.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Causes forwarding of the invocation; all possible side effects may
 *	occur as a result of invoking the command to which the invocation is
 *	forwarded.
 *
 *----------------------------------------------------------------------
 */

func _AliasNRCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Argument vector. */
	var _objPtr, aliasPtr, cachePtr, cmdv, listPtr, prefv uintptr
	var cmdc, i, prefc TTcl_Size
	var flags int32
	var v1 int64
	var v3 bool
	var _ /* _callbackPtr at bp+16 */ uintptr
	var _ /* listRep at bp+0 */ TListRep
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, aliasPtr, cachePtr, cmdc, cmdv, flags, i, listPtr, prefc, prefv, v1, v3
	aliasPtr = clientData
	flags = int32(TCL_EVAL_INVOKE)
	/*
	 * Append the arguments to the command prefix and invoke the command in
	 * the target interp's global namespace.
	 */
	prefc = (*TAlias)(unsafe.Pointer(aliasPtr)).Fobjc
	prefv = aliasPtr + 48
	cmdc = prefc + int64(objc) - int64(1)
	/* TODO - encapsulate this into tclListObj.c */
	listPtr = XTcl_NewListObj(tls, cmdc, libc.UintptrFromInt32(0))
	(*TListRep)(unsafe.Pointer(bp)).FstorePtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(listPtr + 32))).Fptr1
	(*TListRep)(unsafe.Pointer(bp)).FspanPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(listPtr + 32))).Fptr2
	if (*TListRep)(unsafe.Pointer(bp)).FspanPtr != 0 {
		v1 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FspanPtr)).FspanStart
	} else {
		v1 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FfirstUsed
	}
	cmdv = (*TListRep)(unsafe.Pointer(bp)).FstorePtr + 40 + uintptr(v1)*8
	(*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FnumUsed = cmdc
	if (*(*TListRep)(unsafe.Pointer(bp))).FspanPtr != 0 {
		(*TListSpan)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FspanPtr)).FspanStart = (*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FfirstUsed
		(*TListSpan)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FspanPtr)).FspanLength = (*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FnumUsed
	}
	prefv = aliasPtr + 48
	libc.Xmemcpy(tls, cmdv, prefv, libc.Uint64FromInt64(prefc)*uint64(8))
	libc.Xmemcpy(tls, cmdv+uintptr(prefc)*8, objv+uintptr(1)*8, libc.Uint64FromInt32(objc-libc.Int32FromInt32(1))*uint64(8))
	i = 0
	for {
		if !(i < cmdc) {
			break
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(cmdv + uintptr(i)*8)))).FrefCount++
		goto _2
	_2:
		;
		i++
	}
	/*
	 * Use the ensemble rewriting machinery to ensure correct error messages:
	 * only the source command should show, not the full target prefix.
	 */
	if XTclInitRewriteEnsemble(tls, interp, int64(1), prefc, objv) != 0 {
		if v3 = interp == libc.UintptrFromInt32(0); !v3 {
			cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
		}
		if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			_objPtr = XTclThreadAllocObj(tls)
		} else {
			_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(_objPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		*(*uintptr)(unsafe.Pointer(bp + 16)) = _objPtr
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FprocPtr = __ccgo_fp(XTclClearRootEnsemble)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
		(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 16))
	}
	XTclSkipTailcall(tls, interp)
	return XTcl_NREvalObj(tls, interp, listPtr, flags)
}

func XTclAliasObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* Argument vector. */
	var _objPtr, aliasPtr, cmdv, prefv, targetInterp, v4 uintptr
	var cmdc, i, prefc, v3 TTcl_Size
	var isRootEnsemble, result int32
	var _ /* cmdArr at bp+0 */ [10]uintptr
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, aliasPtr, cmdc, cmdv, i, isRootEnsemble, prefc, prefv, result, targetInterp, v3, v4
	aliasPtr = clientData
	targetInterp = (*TAlias)(unsafe.Pointer(aliasPtr)).FtargetInterp
	/*
	 * Append the arguments to the command prefix and invoke the command in
	 * the target interp's global namespace.
	 */
	prefc = (*TAlias)(unsafe.Pointer(aliasPtr)).Fobjc
	prefv = aliasPtr + 48
	cmdc = prefc + int64(objc) - int64(1)
	if cmdc <= int64(10) {
		cmdv = bp
	} else {
		cmdv = XTclStackAlloc(tls, interp, libc.Uint64FromInt64(cmdc)*uint64(8))
	}
	libc.Xmemcpy(tls, cmdv, prefv, libc.Uint64FromInt64(prefc)*uint64(8))
	libc.Xmemcpy(tls, cmdv+uintptr(prefc)*8, objv+uintptr(1)*8, libc.Uint64FromInt32(objc-libc.Int32FromInt32(1))*uint64(8))
	XTcl_ResetResult(tls, targetInterp)
	i = 0
	for {
		if !(i < cmdc) {
			break
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(cmdv + uintptr(i)*8)))).FrefCount++
		goto _1
	_1:
		;
		i++
	}
	/*
	 * Use the ensemble rewriting machinery to ensure correct error messages:
	 * only the source command should show, not the full target prefix.
	 */
	isRootEnsemble = XTclInitRewriteEnsemble(tls, targetInterp, int64(1), prefc, objv)
	/*
	 * Protect the target interpreter if it isn't the same as the source
	 * interpreter so that we can continue to work with it after the target
	 * command completes.
	 */
	if targetInterp != interp {
		XTcl_Preserve(tls, targetInterp)
	}
	/*
	 * Execute the target command in the target interpreter.
	 */
	result = XTcl_EvalObjv(tls, targetInterp, cmdc, cmdv, int32(TCL_EVAL_INVOKE))
	/*
	 * Clean up the ensemble rewrite info if we set it in the first place.
	 */
	if isRootEnsemble != 0 {
		XTclResetRewriteEnsemble(tls, targetInterp, int32(1))
	}
	/*
	 * If it was a cross-interpreter alias, we need to transfer the result
	 * back to the source interpreter and release the lock we previously set
	 * on the target interpreter.
	 */
	if targetInterp != interp {
		XTcl_TransferResult(tls, targetInterp, result, interp)
		XTcl_Release(tls, targetInterp)
	}
	i = 0
	for {
		if !(i < cmdc) {
			break
		}
		_objPtr = *(*uintptr)(unsafe.Pointer(cmdv + uintptr(i)*8))
		v4 = _objPtr
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		goto _2
	_2:
		;
		i++
	}
	if cmdv != bp {
		XTclStackFree(tls, interp, cmdv)
	}
	return result
}

func XTclLocalAliasObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* Argument vector. */
	var _objPtr, aliasPtr, cmdv, prefv, v4 uintptr
	var cmdc, i, prefc, v3 TTcl_Size
	var isRootEnsemble, result int32
	var _ /* cmdArr at bp+0 */ [10]uintptr
	_, _, _, _, _, _, _, _, _, _, _ = _objPtr, aliasPtr, cmdc, cmdv, i, isRootEnsemble, prefc, prefv, result, v3, v4
	aliasPtr = clientData
	/*
	 * Append the arguments to the command prefix and invoke the command in
	 * the global namespace.
	 */
	prefc = (*TAlias)(unsafe.Pointer(aliasPtr)).Fobjc
	prefv = aliasPtr + 48
	cmdc = prefc + int64(objc) - int64(1)
	if cmdc <= int64(10) {
		cmdv = bp
	} else {
		cmdv = XTclStackAlloc(tls, interp, libc.Uint64FromInt64(cmdc)*uint64(8))
	}
	libc.Xmemcpy(tls, cmdv, prefv, libc.Uint64FromInt64(prefc)*uint64(8))
	libc.Xmemcpy(tls, cmdv+uintptr(prefc)*8, objv+uintptr(1)*8, libc.Uint64FromInt32(objc-libc.Int32FromInt32(1))*uint64(8))
	i = 0
	for {
		if !(i < cmdc) {
			break
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(cmdv + uintptr(i)*8)))).FrefCount++
		goto _1
	_1:
		;
		i++
	}
	/*
	 * Use the ensemble rewriting machinery to ensure correct error messages:
	 * only the source command should show, not the full target prefix.
	 */
	isRootEnsemble = XTclInitRewriteEnsemble(tls, interp, int64(1), prefc, objv)
	/*
	 * Execute the target command in the target interpreter.
	 */
	result = XTcl_EvalObjv(tls, interp, cmdc, cmdv, int32(TCL_EVAL_INVOKE))
	/*
	 * Clean up the ensemble rewrite info if we set it in the first place.
	 */
	if isRootEnsemble != 0 {
		XTclResetRewriteEnsemble(tls, interp, int32(1))
	}
	i = 0
	for {
		if !(i < cmdc) {
			break
		}
		_objPtr = *(*uintptr)(unsafe.Pointer(cmdv + uintptr(i)*8))
		v4 = _objPtr
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		goto _2
	_2:
		;
		i++
	}
	if cmdv != bp {
		XTclStackFree(tls, interp, cmdv)
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * AliasObjCmdDeleteProc --
 *
 *	Is invoked when an alias command is deleted in a child. Cleans up all
 *	storage associated with this alias.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Deletes the alias record and its entry in the alias table for the
 *	interpreter.
 *
 *----------------------------------------------------------------------
 */

func _AliasObjCmdDeleteProc(tls *libc.TLS, clientData uintptr) {
	/* The alias record for this alias. */
	var _objPtr, _objPtr1, aliasPtr, objv, parentPtr, targetPtr, v2, v5 uintptr
	var i, v1, v4 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, aliasPtr, i, objv, parentPtr, targetPtr, v1, v2, v4, v5
	aliasPtr = clientData
	_objPtr = (*TAlias)(unsafe.Pointer(aliasPtr)).Ftoken
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	objv = aliasPtr + 48
	i = 0
	for {
		if !(i < (*TAlias)(unsafe.Pointer(aliasPtr)).Fobjc) {
			break
		}
		_objPtr1 = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
		v5 = _objPtr1
		v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
		*(*TTcl_Size)(unsafe.Pointer(v5))--
		if v4 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		goto _3
	_3:
		;
		i++
	}
	XTcl_DeleteHashEntry(tls, (*TAlias)(unsafe.Pointer(aliasPtr)).FaliasEntryPtr)
	/*
	 * Splice the target record out of the target interpreter's parent list.
	 */
	targetPtr = (*TAlias)(unsafe.Pointer(aliasPtr)).FtargetPtr
	if (*TTarget)(unsafe.Pointer(targetPtr)).FprevPtr != libc.UintptrFromInt32(0) {
		(*TTarget1)(unsafe.Pointer((*TTarget)(unsafe.Pointer(targetPtr)).FprevPtr)).FnextPtr = (*TTarget)(unsafe.Pointer(targetPtr)).FnextPtr
	} else {
		parentPtr = (*TInterp)(unsafe.Pointer((*TAlias)(unsafe.Pointer(aliasPtr)).FtargetInterp)).FinterpInfo
		(*TParent)(unsafe.Pointer(parentPtr)).FtargetsPtr = (*TTarget)(unsafe.Pointer(targetPtr)).FnextPtr
	}
	if (*TTarget)(unsafe.Pointer(targetPtr)).FnextPtr != libc.UintptrFromInt32(0) {
		(*TTarget1)(unsafe.Pointer((*TTarget)(unsafe.Pointer(targetPtr)).FnextPtr)).FprevPtr = (*TTarget)(unsafe.Pointer(targetPtr)).FprevPtr
	}
	XTclpFree(tls, targetPtr)
	XTclpFree(tls, aliasPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_CreateChild --
 *
 *	Creates a child interpreter. The childPath argument denotes the name
 *	of the new child relative to the current interpreter; the child is a
 *	direct descendant of the one-before-last component of the path,
 *	e.g. it is a descendant of the current interpreter if the childPath
 *	argument contains only one component. Optionally makes the child
 *	interpreter safe.
 *
 * Results:
 *	Returns the interpreter structure created, or NULL if an error
 *	occurred.
 *
 * Side effects:
 *	Creates a new interpreter and a new interpreter object command in the
 *	interpreter indicated by the childPath argument.
 *
 *----------------------------------------------------------------------
 */

func XTcl_CreateChild(tls *libc.TLS, interp uintptr, childPath uintptr, isSafe int32) (r uintptr) {
	/* Should new child be "safe" ? */
	var _objPtr, childInterp, pathPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _, _ = _objPtr, childInterp, pathPtr, v1, v2
	pathPtr = XTcl_NewStringObj(tls, childPath, int64(-int32(1)))
	childInterp = _ChildCreate(tls, interp, pathPtr, isSafe)
	_objPtr = pathPtr
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return childInterp
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetChild --
 *
 *	Finds a child interpreter by its path name.
 *
 * Results:
 *	Returns a Tcl_Interp * for the named interpreter or NULL if not found.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetChild(tls *libc.TLS, interp uintptr, childPath uintptr) (r uintptr) {
	/* Path of child to find. */
	var _objPtr, childInterp, pathPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _, _ = _objPtr, childInterp, pathPtr, v1, v2
	pathPtr = XTcl_NewStringObj(tls, childPath, int64(-int32(1)))
	childInterp = _GetInterp(tls, interp, pathPtr)
	_objPtr = pathPtr
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return childInterp
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetParent --
 *
 *	Finds the parent interpreter of a child interpreter.
 *
 * Results:
 *	Returns a Tcl_Interp * for the parent interpreter or NULL if none.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetParent(tls *libc.TLS, interp uintptr) (r uintptr) {
	/* Get the parent of this interpreter. */
	var childPtr uintptr
	_ = childPtr /* Child record of this interpreter. */
	if interp == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	childPtr = (*TInterp)(unsafe.Pointer(interp)).FinterpInfo + 120
	return (*TChild)(unsafe.Pointer(childPtr)).FparentInterp
}

/*
 *----------------------------------------------------------------------
 *
 * TclSetChildCancelFlags --
 *
 *	This function marks all child interpreters belonging to a given
 *	interpreter as being canceled or not canceled, depending on the
 *	provided flags.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclSetChildCancelFlags(tls *libc.TLS, interp uintptr, flags int32, force int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Non-zero to ignore numLevels for the purpose
	 * of resetting the cancellation flags. */
	var childPtr, hPtr, iPtr, parentPtr uintptr
	var _ /* hashSearch at bp+0 */ TTcl_HashSearch
	_, _, _, _ = childPtr, hPtr, iPtr, parentPtr
	if interp == libc.UintptrFromInt32(0) {
		return
	}
	flags &= libc.Int32FromInt32(CANCELED) | libc.Int32FromInt32(TCL_CANCEL_UNWIND)
	parentPtr = (*TInterp)(unsafe.Pointer(interp)).FinterpInfo
	hPtr = XTcl_FirstHashEntry(tls, parentPtr, bp)
	for {
		if !(hPtr != libc.UintptrFromInt32(0)) {
			break
		}
		childPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		iPtr = (*TChild)(unsafe.Pointer(childPtr)).FchildInterp
		if iPtr == libc.UintptrFromInt32(0) {
			goto _1
		}
		if flags == 0 {
			XTclResetCancellation(tls, iPtr, force)
		} else {
			*(*int32)(unsafe.Pointer(iPtr + 368)) |= int32(CANCELED)
			if flags&int32(TCL_CANCEL_UNWIND) != 0 {
				*(*int32)(unsafe.Pointer(iPtr + 368)) |= int32(TCL_CANCEL_UNWIND)
			}
		}
		/*
		 * Now, recursively handle this for the children of this child
		 * interpreter.
		 */
		XTclSetChildCancelFlags(tls, iPtr, flags, force)
		goto _1
	_1:
		;
		hPtr = XTcl_NextHashEntry(tls, bp)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetInterpPath --
 *
 *	Sets the result of the asking interpreter to a proper Tcl list
 *	containing the names of interpreters between the asking and target
 *	interpreters. The target interpreter must be either the same as the
 *	asking interpreter or one of its children (including recursively).
 *
 * Results:
 *	TCL_OK if the target interpreter is the same as, or a descendant of,
 *	the asking interpreter; TCL_ERROR else. This way one can distinguish
 *	between the case where the asking and target interps are the same (an
 *	empty list is the result, and TCL_OK is returned) and when the target
 *	is not a descendant of the asking interpreter (in which case the Tcl
 *	result is an error message and the function returns TCL_ERROR).
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetInterpPath(tls *libc.TLS, interp uintptr, targetInterp uintptr) (r int32) {
	/* Interpreter to find. */
	var iiPtr, v1 uintptr
	_, _ = iiPtr, v1
	if targetInterp == interp {
		XTcl_SetObjResult(tls, interp, XTcl_NewObj(tls))
		return TCL_OK
	}
	if targetInterp == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	iiPtr = (*TInterp)(unsafe.Pointer(targetInterp)).FinterpInfo
	if XTcl_GetInterpPath(tls, interp, (*TInterpInfo)(unsafe.Pointer(iiPtr)).Fchild.FparentInterp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if (*TTcl_HashTable)(unsafe.Pointer(iiPtr)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(iiPtr)).FkeyType == -int32(1) {
		v1 = *(*uintptr)(unsafe.Pointer((*TInterpInfo)(unsafe.Pointer(iiPtr)).Fchild.FchildEntryPtr + 32))
	} else {
		v1 = (*TInterpInfo)(unsafe.Pointer(iiPtr)).Fchild.FchildEntryPtr + 32
	}
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), XTcl_GetObjResult(tls, interp), XTcl_NewStringObj(tls, v1, int64(-int32(1))))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * GetInterp --
 *
 *	Helper function to find a child interpreter given a pathname.
 *
 * Results:
 *	Returns the child interpreter known by that name in the calling
 *	interpreter, or NULL if no interpreter known by that name exists.
 *
 * Side effects:
 *	Assigns to the pointer variable passed in, if not NULL.
 *
 *----------------------------------------------------------------------
 */

func _GetInterp(tls *libc.TLS, interp uintptr, pathPtr uintptr) (r uintptr) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* List object containing name of interp. to
	 * be found. */
	var childPtr, hPtr, parentInfoPtr, searchInterp, v5, v6, v7 uintptr
	var i TTcl_Size
	var v1 int32
	var v2, v3 int64
	var _ /* objc at bp+8 */ TTcl_Size
	var _ /* objv at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _ = childPtr, hPtr, i, parentInfoPtr, searchInterp, v1, v2, v3, v5, v6, v7
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(pathPtr + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(pathPtr + 32))).Fptr2)).FspanStart
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(pathPtr + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(pathPtr + 32))).Fptr1 + 40 + uintptr(v2)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(pathPtr + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(pathPtr + 32))).Fptr2)).FspanLength
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(pathPtr + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v3
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjGetElements(tls, interp, pathPtr, bp+8, bp)
	}
	if v1 != TCL_OK {
		return libc.UintptrFromInt32(0)
	}
	searchInterp = interp
	i = 0
	for {
		if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) {
			break
		}
		parentInfoPtr = (*TInterp)(unsafe.Pointer(searchInterp)).FinterpInfo
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(i)*8)))).Fbytes != 0 {
			v5 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(i)*8)))).Fbytes
		} else {
			v5 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(parentInfoPtr)).FfindProc})))(tls, parentInfoPtr, v5)
		if hPtr == libc.UintptrFromInt32(0) {
			searchInterp = libc.UintptrFromInt32(0)
			break
		}
		childPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		searchInterp = (*TChild)(unsafe.Pointer(childPtr)).FchildInterp
		if searchInterp == libc.UintptrFromInt32(0) {
			break
		}
		goto _4
	_4:
		;
		i++
	}
	if searchInterp == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
			v6 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
		} else {
			v6 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+41387, libc.VaList(bp+24, v6)))
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
			v7 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
		} else {
			v7 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
		}
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+40852, v7, libc.UintptrFromInt32(0)))
	}
	return searchInterp
}

/*
 *----------------------------------------------------------------------
 *
 * ChildBgerror --
 *
 *	Helper function to set/query the background error handling command
 *	prefix of an interp
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	When (objc == 1), childInterp will be set to a new background handler
 *	of objv[0].
 *
 *----------------------------------------------------------------------
 */

func _ChildBgerror(tls *libc.TLS, interp uintptr, childInterp uintptr, objc TTcl_Size, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Argument strings. */
	var v1 int32
	var v2 int64
	var _ /* length at bp+0 */ TTcl_Size
	_, _ = v1, v2
	if objc != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2 != 0 {
				v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2)).FspanLength
			} else {
				v2 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp)) = v2
			v1 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1 = XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv)), bp)
		}
		if int32(TCL_ERROR) == v1 || *(*TTcl_Size)(unsafe.Pointer(bp)) < int64(1) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+41419, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+40852, __ccgo_ts+41457, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		XTclSetBgErrorHandler(tls, childInterp, *(*uintptr)(unsafe.Pointer(objv)))
	}
	XTcl_SetObjResult(tls, interp, XTclGetBgErrorHandler(tls, childInterp))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * ChildCreate --
 *
 *	Helper function to do the actual work of creating a child interp and
 *	new object command. Also optionally makes the new child interpreter
 *	"safe".
 *
 * Results:
 *	Returns the new Tcl_Interp * if successful or NULL if not. If failed,
 *	the result of the invoking interpreter contains an error message.
 *
 * Side effects:
 *	Creates a new child interpreter and a new object command.
 *
 *----------------------------------------------------------------------
 */

func _ChildCreate(tls *libc.TLS, interp uintptr, pathPtr uintptr, safe int32) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Should we make it "safe"? */
	var _objPtr, _objPtr1, cachePtr, childInterp, childPtr, clockObj, hPtr, objPtr, parentInfoPtr, parentInterp, path, v10, v4, v6, v7 uintptr
	var status, v1 int32
	var v2, v3 int64
	var v5, v9 TTcl_Size
	var v8 bool
	var _ /* isNew at bp+0 */ int32
	var _ /* objc at bp+8 */ TTcl_Size
	var _ /* objv at bp+16 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, childInterp, childPtr, clockObj, hPtr, objPtr, parentInfoPtr, parentInterp, path, status, v1, v10, v2, v3, v4, v5, v6, v7, v8, v9
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(pathPtr + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(pathPtr + 32))).Fptr2)).FspanStart
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(pathPtr + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 16)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(pathPtr + 32))).Fptr1 + 40 + uintptr(v2)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(pathPtr + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(pathPtr + 32))).Fptr2)).FspanLength
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(pathPtr + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v3
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjGetElements(tls, interp, pathPtr, bp+8, bp+16)
	}
	if v1 != TCL_OK {
		return libc.UintptrFromInt32(0)
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) < int64(2) {
		parentInterp = interp
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
			v4 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
		} else {
			v4 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
		}
		path = v4
	} else {
		objPtr = XTcl_NewListObj(tls, *(*TTcl_Size)(unsafe.Pointer(bp + 8))-int64(1), *(*uintptr)(unsafe.Pointer(bp + 16)))
		parentInterp = _GetInterp(tls, interp, objPtr)
		_objPtr = objPtr
		v6 = _objPtr
		v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
		*(*TTcl_Size)(unsafe.Pointer(v6))--
		if v5 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		if parentInterp == libc.UintptrFromInt32(0) {
			return libc.UintptrFromInt32(0)
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8))-int64(1))*8)))).Fbytes != 0 {
			v7 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8))-int64(1))*8)))).Fbytes
		} else {
			v7 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8))-int64(1))*8)), libc.UintptrFromInt32(0))
		}
		path = v7
	}
	if safe == 0 {
		safe = XTcl_IsSafe(tls, parentInterp)
	}
	parentInfoPtr = (*TInterp)(unsafe.Pointer(parentInterp)).FinterpInfo
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(parentInfoPtr)).FcreateProc})))(tls, parentInfoPtr, path, bp)
	if *(*int32)(unsafe.Pointer(bp)) == 0 {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+41471, libc.VaList(bp+32, path)))
		return libc.UintptrFromInt32(0)
	}
	childInterp = XTcl_CreateInterp(tls)
	childPtr = (*TInterp)(unsafe.Pointer(childInterp)).FinterpInfo + 120
	(*TChild)(unsafe.Pointer(childPtr)).FparentInterp = parentInterp
	(*TChild)(unsafe.Pointer(childPtr)).FchildEntryPtr = hPtr
	(*TChild)(unsafe.Pointer(childPtr)).FchildInterp = childInterp
	(*TChild)(unsafe.Pointer(childPtr)).FinterpCmd = XTcl_NRCreateCommand(tls, parentInterp, path, __ccgo_fp(XTclChildObjCmd), __ccgo_fp(_NRChildCmd), childInterp, __ccgo_fp(_ChildObjCmdDeleteProc))
	XTcl_InitHashTable(tls, childPtr+32, TCL_STRING_KEYS)
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = childPtr
	XTcl_SetVar2(tls, childInterp, __ccgo_ts+41524, libc.UintptrFromInt32(0), __ccgo_ts+14828, int32(TCL_GLOBAL_ONLY))
	/*
	 * Inherit the recursion limit.
	 */
	(*TInterp)(unsafe.Pointer(childInterp)).FmaxNestingDepth = (*TInterp)(unsafe.Pointer(parentInterp)).FmaxNestingDepth
	if safe != 0 {
		_MakeSafe(tls, childInterp)
	} else {
		if XTcl_Init(tls, childInterp) == int32(TCL_ERROR) {
			goto error
		}
		/*
		 * This will create the "memory" command in child interpreters if we
		 * compiled with TCL_MEM_DEBUG, otherwise it does nothing.
		 */
	}
	/*
	 * Inherit the TIP#143 limits.
	 */
	_InheritLimitsFromParent(tls, childInterp, parentInterp)
	/*
	 * The [clock] command presents a safe API, but uses unsafe features in
	 * its implementation. This means it has to be implemented in safe interps
	 * as an alias to a version in the (trusted) parent.
	 */
	if safe != 0 {
		if v8 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v8 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v8 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			clockObj = XTclThreadAllocObj(tls)
		} else {
			clockObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(clockObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(clockObj)).FrefCount = 0
		if libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer(clockObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(clockObj)).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(clockObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(clockObj)).Fbytes, __ccgo_ts+41540, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(clockObj)).Fbytes + uintptr(libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(clockObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(6) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer(clockObj)).FtypePtr = libc.UintptrFromInt32(0)
		(*TTcl_Obj)(unsafe.Pointer(clockObj)).FrefCount++
		status = _AliasCreate(tls, interp, childInterp, parentInterp, clockObj, clockObj, 0, libc.UintptrFromInt32(0))
		_objPtr1 = clockObj
		v10 = _objPtr1
		v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
		*(*TTcl_Size)(unsafe.Pointer(v10))--
		if v9 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		if status != TCL_OK {
			goto error2
		}
	}
	return childInterp
	goto error
error:
	;
	XTcl_TransferResult(tls, childInterp, int32(TCL_ERROR), interp)
	goto error2
error2:
	;
	XTcl_DeleteInterp(tls, childInterp)
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * TclChildObjCmd --
 *
 *	Command to manipulate an interpreter, e.g. to send commands to it to
 *	be evaluated. One such command exists for each child interpreter.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See user documentation for details.
 *
 *----------------------------------------------------------------------
 */

func XTclChildObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	return XTcl_NRCallObjProc(tls, interp, __ccgo_fp(_NRChildCmd), clientData, int64(objc), objv)
}

func _NRChildCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var childInterp, namespaceName, v1, v3, v5 uintptr
	var i, v4 TTcl_Size
	var _ /* idx at bp+4 */ int32
	var _ /* index at bp+0 */ int32
	var _ /* limitType at bp+8 */ int32
	_, _, _, _, _, _, _ = childInterp, i, namespaceName, v1, v3, v4, v5
	childInterp = clientData
	if childInterp == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+41546, 0)
	}
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+40635)
		return int32(TCL_ERROR)
	}
	if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), uintptr(unsafe.Pointer(&_options12)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	switch *(*int32)(unsafe.Pointer(bp)) {
	case 0:
		if objc > int32(2) {
			if objc == int32(3) {
				return _AliasDescribe(tls, interp, childInterp, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
			}
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes != 0 {
				v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes
			} else {
				v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0))
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) == int32('\000') {
				if objc == int32(4) {
					return _AliasDelete(tls, interp, childInterp, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
				}
			} else {
				return _AliasCreate(tls, interp, childInterp, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), *(*uintptr)(unsafe.Pointer(objv + 3*8)), int64(objc-int32(4)), objv+uintptr(4)*8)
			}
		}
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+41591)
		return int32(TCL_ERROR)
	case 1:
		if objc != int32(2) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, libc.UintptrFromInt32(0))
			return int32(TCL_ERROR)
		}
		return _AliasList(tls, interp, childInterp)
	case 2:
		if objc != int32(2) && objc != int32(3) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+41624)
			return int32(TCL_ERROR)
		}
		return _ChildBgerror(tls, interp, childInterp, int64(objc-int32(2)), objv+uintptr(2)*8)
	case 3:
		/*
		 * TIP #378
		 * Currently only -frame supported, otherwise ?-option ?value? ...?
		 */
		if objc > int32(4) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+41636)
			return int32(TCL_ERROR)
		}
		return _ChildDebugCmd(tls, interp, childInterp, int64(objc-int32(2)), objv+uintptr(2)*8)
	case 4:
		if objc < int32(3) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+15269)
			return int32(TCL_ERROR)
		}
		return _ChildEval(tls, interp, childInterp, int64(objc-int32(2)), objv+uintptr(2)*8)
	case 5:
		if objc < int32(3) || objc > int32(4) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+41652)
			return int32(TCL_ERROR)
		}
		return _ChildExpose(tls, interp, childInterp, int64(objc-int32(2)), objv+uintptr(2)*8)
	case 6:
		if objc < int32(3) || objc > int32(4) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+41676)
			return int32(TCL_ERROR)
		}
		return _ChildHide(tls, interp, childInterp, int64(objc-int32(2)), objv+uintptr(2)*8)
	case 7:
		if objc != int32(2) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, libc.UintptrFromInt32(0))
			return int32(TCL_ERROR)
		}
		return _ChildHidden(tls, interp, childInterp)
	case 8:
		if objc != int32(2) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, libc.UintptrFromInt32(0))
			return int32(TCL_ERROR)
		}
		XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(XTcl_IsSafe(tls, childInterp) != 0)))
		return TCL_OK
	case 9:
		namespaceName = libc.UintptrFromInt32(0)
		i = int64(2)
		for {
			if !(i < int64(objc)) {
				break
			}
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
				v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
			} else {
				v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) != int32('-') {
				break
			}
			if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_hiddenOptions1)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+4) != TCL_OK {
				return int32(TCL_ERROR)
			}
			if *(*int32)(unsafe.Pointer(bp + 4)) == 0 {
				namespaceName = __ccgo_ts + 7650
			} else {
				if *(*int32)(unsafe.Pointer(bp + 4)) == 1 {
					i++
					v4 = i
					if v4 == int64(objc) { /* There must be more arguments. */
						break
					}
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
						v5 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
					} else {
						v5 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
					}
					namespaceName = v5
				} else {
					i++
					break
				}
			}
			goto _2
		_2:
			;
			i++
		}
		if int64(objc)-i < int64(1) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+41700)
			return int32(TCL_ERROR)
		}
		return _ChildInvokeHidden(tls, interp, childInterp, namespaceName, int64(objc)-i, objv+uintptr(i)*8)
	case 10:
		if objc < int32(3) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+41744)
			return int32(TCL_ERROR)
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), uintptr(unsafe.Pointer(&_limitTypes1)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+41039, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+8) != TCL_OK {
			return int32(TCL_ERROR)
		}
		switch *(*int32)(unsafe.Pointer(bp + 8)) {
		case 0:
			return _ChildCommandLimitCmd(tls, interp, childInterp, int64(3), int64(objc), objv)
		case 1:
			return _ChildTimeLimitCmd(tls, interp, childInterp, int64(3), int64(objc), objv)
		}
	case 11:
		if objc != int32(2) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, libc.UintptrFromInt32(0))
			return int32(TCL_ERROR)
		}
		return _ChildMarkTrusted(tls, interp, childInterp)
	case 12:
		if objc != int32(2) && objc != int32(3) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+41774)
			return int32(TCL_ERROR)
		}
		return _ChildRecursionLimit(tls, interp, childInterp, int64(objc-int32(2)), objv+uintptr(2)*8)
	}
	return int32(TCL_ERROR)
}

var _options12 = [14]uintptr{
	0:  __ccgo_ts + 6479,
	1:  __ccgo_ts + 40511,
	2:  __ccgo_ts + 30789,
	3:  __ccgo_ts + 40535,
	4:  __ccgo_ts + 2464,
	5:  __ccgo_ts + 40541,
	6:  __ccgo_ts + 40548,
	7:  __ccgo_ts + 35112,
	8:  __ccgo_ts + 40553,
	9:  __ccgo_ts + 40560,
	10: __ccgo_ts + 40573,
	11: __ccgo_ts + 40579,
	12: __ccgo_ts + 40591,
	13: libc.UintptrFromInt32(0),
}

var _hiddenOptions1 = [4]uintptr{
	0: __ccgo_ts + 40947,
	1: __ccgo_ts + 29556,
	2: __ccgo_ts + 18684,
	3: libc.UintptrFromInt32(0),
}

var _limitTypes1 = [3]uintptr{
	0: __ccgo_ts + 16009,
	1: __ccgo_ts + 5581,
	2: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * ChildObjCmdDeleteProc --
 *
 *	Invoked when an object command for a child interpreter is deleted;
 *	cleans up all state associated with the child interpreter and destroys
 *	the child interpreter.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Cleans up all state associated with the child interpreter and destroys
 *	the child interpreter.
 *
 *----------------------------------------------------------------------
 */

func _ChildObjCmdDeleteProc(tls *libc.TLS, clientData uintptr) {
	/* The ChildRecord for the command. */
	var childInterp, childPtr uintptr
	_, _ = childInterp, childPtr /* Interim storage for Child record. */
	childInterp = clientData
	/* And for a child interp. */
	childPtr = (*TInterp)(unsafe.Pointer(childInterp)).FinterpInfo + 120
	/*
	 * Unlink the child from its parent interpreter.
	 */
	XTcl_DeleteHashEntry(tls, (*TChild)(unsafe.Pointer(childPtr)).FchildEntryPtr)
	/*
	 * Set to NULL so that when the InterpInfo is cleaned up in the child it
	 * does not try to delete the command causing all sorts of grief. See
	 * ChildRecordDeleteProc().
	 */
	(*TChild)(unsafe.Pointer(childPtr)).FinterpCmd = libc.UintptrFromInt32(0)
	if (*TChild)(unsafe.Pointer(childPtr)).FchildInterp != libc.UintptrFromInt32(0) {
		XTcl_DeleteInterp(tls, (*TChild)(unsafe.Pointer(childPtr)).FchildInterp)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * ChildDebugCmd -- TIP #378
 *
 *	Helper function to handle 'debug' command in a child interpreter.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	May modify INTERP_DEBUG_FRAME flag in the child.
 *
 *----------------------------------------------------------------------
 */

func _ChildDebugCmd(tls *libc.TLS, interp uintptr, childInterp uintptr, objc TTcl_Size, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var cachePtr, iPtr, resultPtr uintptr
	var v1 bool
	var _ /* debugType at bp+0 */ int32
	_, _, _, _ = cachePtr, iPtr, resultPtr, v1
	iPtr = childInterp
	if objc == 0 {
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			resultPtr = XTclThreadAllocObj(tls)
		} else {
			resultPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(resultPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FtypePtr = libc.UintptrFromInt32(0)
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultPtr, XTcl_NewStringObj(tls, __ccgo_ts+41785, int64(-int32(1))))
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultPtr, XTcl_NewWideIntObj(tls, libc.BoolInt64((*TInterp)(unsafe.Pointer(iPtr)).Fflags&int32(INTERP_DEBUG_FRAME) != 0)))
		XTcl_SetObjResult(tls, interp, resultPtr)
	} else {
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv)), uintptr(unsafe.Pointer(&_debugTypes)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+41792, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
			return int32(TCL_ERROR)
		}
		if *(*int32)(unsafe.Pointer(bp)) == 0 {
			if objc == int64(2) { /* set */
				if XTcl_GetBoolFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), (libc.Int32FromInt32(TCL_NULL_OK)-libc.Int32FromInt32(2))&libc.Int32FromInt64(4), bp) != TCL_OK {
					return int32(TCL_ERROR)
				}
				/*
				 * Quietly ignore attempts to disable interp debugging.  This
				 * is a one-way switch as frame debug info is maintained in a
				 * stack that must be consistent once turned on.
				 */
				if *(*int32)(unsafe.Pointer(bp)) != 0 {
					*(*int32)(unsafe.Pointer(iPtr + 368)) |= int32(INTERP_DEBUG_FRAME)
				}
			}
			XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64((*TInterp)(unsafe.Pointer(iPtr)).Fflags&int32(INTERP_DEBUG_FRAME) != 0)))
		}
	}
	return TCL_OK
}

var _debugTypes = [2]uintptr{
	0: __ccgo_ts + 41785,
	1: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * ChildEval --
 *
 *	Helper function to evaluate a command in a child interpreter.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Whatever the command does.
 *
 *----------------------------------------------------------------------
 */

func _ChildEval(tls *libc.TLS, interp uintptr, childInterp uintptr, objc TTcl_Size, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var _objPtr, iPtr, objPtr, v2 uintptr
	var result int32
	var v1 TTcl_Size
	var _ /* invoker at bp+0 */ uintptr
	var _ /* word at bp+8 */ int32
	_, _, _, _, _, _ = _objPtr, iPtr, objPtr, result, v1, v2
	/*
	 * TIP #285: If necessary, reset the cancellation flags for the child
	 * interpreter now; otherwise, canceling a script in a parent interpreter
	 * can result in a situation where a child interpreter can no longer
	 * evaluate any scripts unless somebody calls the TclResetCancellation
	 * function for that particular Tcl_Interp.
	 */
	XTclSetChildCancelFlags(tls, childInterp, 0, 0)
	XTcl_Preserve(tls, childInterp)
	XTcl_AllowExceptions(tls, childInterp)
	if objc == int64(1) {
		/*
		 * TIP #280: Make actual argument location available to eval'd script.
		 */
		iPtr = interp
		*(*uintptr)(unsafe.Pointer(bp)) = (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr
		*(*int32)(unsafe.Pointer(bp + 8)) = 0
		XTclArgumentGet(tls, interp, *(*uintptr)(unsafe.Pointer(objv)), bp, bp+8)
		result = XTclEvalObjEx(tls, childInterp, *(*uintptr)(unsafe.Pointer(objv)), 0, *(*uintptr)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 8)))
	} else {
		objPtr = XTcl_ConcatObj(tls, objc, objv)
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount++
		result = XTcl_EvalObjEx(tls, childInterp, objPtr, 0)
		_objPtr = objPtr
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	XTcl_TransferResult(tls, childInterp, result, interp)
	XTcl_Release(tls, childInterp)
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * ChildExpose --
 *
 *	Helper function to expose a command in a child interpreter.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	After this call scripts in the child will be able to invoke the newly
 *	exposed command.
 *
 *----------------------------------------------------------------------
 */

func _ChildExpose(tls *libc.TLS, interp uintptr, childInterp uintptr, objc TTcl_Size, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument strings. */
	var name, v1, v5 uintptr
	var v2, v3, v4 int32
	_, _, _, _, _, _ = name, v1, v2, v3, v4, v5
	if XTcl_IsSafe(tls, interp) != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+41805, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+40852, __ccgo_ts+41864, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if objc == int64(1) {
		v2 = 0
	} else {
		v2 = int32(1)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(v2)*8)))).Fbytes != 0 {
		if objc == int64(1) {
			v3 = 0
		} else {
			v3 = int32(1)
		}
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(v3)*8)))).Fbytes
	} else {
		if objc == int64(1) {
			v4 = 0
		} else {
			v4 = int32(1)
		}
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(v4)*8)), libc.UintptrFromInt32(0))
	}
	name = v1
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes != 0 {
		v5 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes
	} else {
		v5 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv)), libc.UintptrFromInt32(0))
	}
	if XTcl_ExposeCommand(tls, childInterp, v5, name) != TCL_OK {
		XTcl_TransferResult(tls, childInterp, int32(TCL_ERROR), interp)
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * ChildRecursionLimit --
 *
 *	Helper function to set/query the Recursion limit of an interp
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	When (objc == 1), childInterp will be set to a new recursion limit of
 *	objv[0].
 *
 *----------------------------------------------------------------------
 */

func _ChildRecursionLimit(tls *libc.TLS, interp uintptr, childInterp uintptr, objc TTcl_Size, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Argument strings. */
	var iPtr uintptr
	var v1 int32
	var _ /* limit at bp+0 */ TTcl_WideInt
	_, _ = iPtr, v1
	if objc != 0 {
		if XTcl_IsSafe(tls, interp) != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+41871, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+40852, __ccgo_ts+41864, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
			*(*TTcl_WideInt)(unsafe.Pointer(bp)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).FinternalRep))
			v1 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1 = XTcl_GetWideIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv)), bp)
		}
		if v1 == int32(TCL_ERROR) {
			return int32(TCL_ERROR)
		}
		if *(*TTcl_WideInt)(unsafe.Pointer(bp)) <= 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+41938, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+40852, __ccgo_ts+41966, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		XTcl_SetRecursionLimit(tls, childInterp, *(*TTcl_WideInt)(unsafe.Pointer(bp)))
		iPtr = childInterp
		if interp == childInterp && (*TInterp)(unsafe.Pointer(iPtr)).FnumLevels > *(*TTcl_WideInt)(unsafe.Pointer(bp)) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+41975, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+42015, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(objv)))
		return TCL_OK
	} else {
		*(*TTcl_WideInt)(unsafe.Pointer(bp)) = XTcl_SetRecursionLimit(tls, childInterp, 0)
		XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, *(*TTcl_WideInt)(unsafe.Pointer(bp))))
		return TCL_OK
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * ChildHide --
 *
 *	Helper function to hide a command in a child interpreter.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	After this call scripts in the child will no longer be able to invoke
 *	the named command.
 *
 *----------------------------------------------------------------------
 */

func _ChildHide(tls *libc.TLS, interp uintptr, childInterp uintptr, objc TTcl_Size, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument strings. */
	var name, v1, v5 uintptr
	var v2, v3, v4 int32
	_, _, _, _, _, _ = name, v1, v2, v3, v4, v5
	if XTcl_IsSafe(tls, interp) != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+42025, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+40852, __ccgo_ts+41864, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if objc == int64(1) {
		v2 = 0
	} else {
		v2 = int32(1)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(v2)*8)))).Fbytes != 0 {
		if objc == int64(1) {
			v3 = 0
		} else {
			v3 = int32(1)
		}
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(v3)*8)))).Fbytes
	} else {
		if objc == int64(1) {
			v4 = 0
		} else {
			v4 = int32(1)
		}
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(v4)*8)), libc.UintptrFromInt32(0))
	}
	name = v1
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes != 0 {
		v5 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes
	} else {
		v5 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv)), libc.UintptrFromInt32(0))
	}
	if XTcl_HideCommand(tls, childInterp, v5, name) != TCL_OK {
		XTcl_TransferResult(tls, childInterp, int32(TCL_ERROR), interp)
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * ChildHidden --
 *
 *	Helper function to compute list of hidden commands in a child
 *	interpreter.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _ChildHidden(tls *libc.TLS, interp uintptr, childInterp uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Interp whose hidden commands to query. */
	var cachePtr, hPtr, hTblPtr, listObjPtr, v3 uintptr
	var v1 bool
	var _ /* hSearch at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _ = cachePtr, hPtr, hTblPtr, listObjPtr, v1, v3 /* For local searches. */
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		listObjPtr = XTclThreadAllocObj(tls)
	} else {
		listObjPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listObjPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(listObjPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(listObjPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(listObjPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(listObjPtr)).FtypePtr = libc.UintptrFromInt32(0)
	hTblPtr = (*TInterp)(unsafe.Pointer(childInterp)).FhiddenCmdTablePtr
	if hTblPtr != libc.UintptrFromInt32(0) {
		hPtr = XTcl_FirstHashEntry(tls, hTblPtr, bp)
		for {
			if !(hPtr != libc.UintptrFromInt32(0)) {
				break
			}
			if (*TTcl_HashTable)(unsafe.Pointer(hTblPtr)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(hTblPtr)).FkeyType == -int32(1) {
				v3 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
			} else {
				v3 = hPtr + 32
			}
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listObjPtr, XTcl_NewStringObj(tls, v3, int64(-int32(1))))
			goto _2
		_2:
			;
			hPtr = XTcl_NextHashEntry(tls, bp)
		}
	}
	XTcl_SetObjResult(tls, interp, listObjPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * ChildInvokeHidden --
 *
 *	Helper function to invoke a hidden command in a child interpreter.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Whatever the hidden command does.
 *
 *----------------------------------------------------------------------
 */

func _ChildInvokeHidden(tls *libc.TLS, interp uintptr, childInterp uintptr, namespaceName uintptr, objc TTcl_Size, objv uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* Argument objects. */
	var result int32
	var rootPtr uintptr
	var _ /* dummy1 at bp+8 */ uintptr
	var _ /* dummy2 at bp+16 */ uintptr
	var _ /* nsPtr at bp+0 */ uintptr
	var _ /* tail at bp+24 */ uintptr
	_, _ = result, rootPtr
	if XTcl_IsSafe(tls, interp) != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+42082, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+40852, __ccgo_ts+41864, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	XTcl_Preserve(tls, childInterp)
	XTcl_AllowExceptions(tls, childInterp)
	if namespaceName == libc.UintptrFromInt32(0) {
		rootPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(childInterp)).FexecEnvPtr)).FcallbackPtr
		XTcl_NRAddCallback(tls, interp, __ccgo_fp(_NRPostInvokeHidden), childInterp, rootPtr, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
		return XTclNRInvoke(tls, libc.UintptrFromInt32(0), childInterp, int32(objc), objv)
	} else {
		result = XTclGetNamespaceForQualName(tls, childInterp, namespaceName, libc.UintptrFromInt32(0), libc.Int32FromInt32(TCL_FIND_ONLY_NS)|libc.Int32FromInt32(TCL_GLOBAL_ONLY)|libc.Int32FromInt32(TCL_LEAVE_ERR_MSG)|libc.Int32FromInt32(TCL_CREATE_NS_IF_UNKNOWN), bp, bp+8, bp+16, bp+24)
		if result == TCL_OK {
			result = XTclObjInvokeNamespace(tls, childInterp, objc, objv, *(*uintptr)(unsafe.Pointer(bp)), libc.Int32FromInt32(1)<<libc.Int32FromInt32(0))
		}
	}
	XTcl_TransferResult(tls, childInterp, result, interp)
	XTcl_Release(tls, childInterp)
	return result
}

func _NRPostInvokeHidden(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	var childInterp, rootPtr uintptr
	_, _ = childInterp, rootPtr
	childInterp = *(*uintptr)(unsafe.Pointer(data))
	rootPtr = *(*uintptr)(unsafe.Pointer(data + 1*8))
	if interp != childInterp {
		result = XTclNRRunCallbacks(tls, childInterp, result, rootPtr)
		XTcl_TransferResult(tls, childInterp, result, interp)
	}
	XTcl_Release(tls, childInterp)
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * ChildMarkTrusted --
 *
 *	Helper function to mark a child interpreter as trusted (unsafe).
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	After this call the hard-wired security checks in the core no longer
 *	prevent the child from performing certain operations.
 *
 *----------------------------------------------------------------------
 */

func _ChildMarkTrusted(tls *libc.TLS, interp uintptr, childInterp uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* The child interpreter which will be marked
	 * trusted. */
	if XTcl_IsSafe(tls, interp) != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+42142, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+40852, __ccgo_ts+41864, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	*(*int32)(unsafe.Pointer(childInterp + 368)) &= ^libc.Int32FromInt32(SAFE_INTERP)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_IsSafe --
 *
 *	Determines whether an interpreter is safe
 *
 * Results:
 *	1 if it is safe, 0 if it is not.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_IsSafe(tls *libc.TLS, interp uintptr) (r int32) {
	/* Is this interpreter "safe" ? */
	var iPtr uintptr
	var v1 int32
	_, _ = iPtr, v1
	iPtr = interp
	if iPtr == libc.UintptrFromInt32(0) {
		return 0
	}
	if (*TInterp)(unsafe.Pointer(iPtr)).Fflags&int32(SAFE_INTERP) != 0 {
		v1 = int32(1)
	} else {
		v1 = 0
	}
	return v1
}

/*
 *----------------------------------------------------------------------
 *
 * MakeSafe --
 *
 *	Makes its argument interpreter contain only functionality that is
 *	defined to be part of Safe Tcl. Unsafe commands are hidden, the env
 *	array is unset, and the standard channels are removed.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Hides commands in its argument interpreter, and removes settings and
 *	channels.
 *
 *----------------------------------------------------------------------
 */

func _MakeSafe(tls *libc.TLS, interp uintptr) {
	/* Interpreter to be made safe. */
	var chan1 TTcl_Channel
	var iPtr, parent uintptr
	_, _, _ = chan1, iPtr, parent /* Channel to remove from safe interpreter. */
	iPtr = interp
	parent = (*TInterpInfo)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FinterpInfo)).Fchild.FparentInterp
	XTclHideUnsafeCommands(tls, interp)
	if parent != libc.UintptrFromInt32(0) {
		/*
		 * Alias these function implementations in the child to those in the
		 * parent; the overall implementations are safe, but they're normally
		 * defined by init.tcl which is not sourced by safe interpreters.
		 * Assume these functions all work. [Bug 2895741]
		 */
		XTcl_EvalEx(tls, interp, __ccgo_ts+42198, int64(-libc.Int32FromInt32(1)), 0)
	}
	*(*int32)(unsafe.Pointer(iPtr + 368)) |= int32(SAFE_INTERP)
	/*
	 * Unsetting variables : (which should not have been set in the first
	 * place, but...)
	 */
	/*
	 * No env array in a safe interpreter.
	 */
	XTcl_UnsetVar2(tls, interp, __ccgo_ts+30620, libc.UintptrFromInt32(0), int32(TCL_GLOBAL_ONLY))
	/*
	 * Remove unsafe parts of tcl_platform
	 */
	XTcl_UnsetVar2(tls, interp, __ccgo_ts+7126, __ccgo_ts+42248, int32(TCL_GLOBAL_ONLY))
	XTcl_UnsetVar2(tls, interp, __ccgo_ts+7126, __ccgo_ts+42251, int32(TCL_GLOBAL_ONLY))
	XTcl_UnsetVar2(tls, interp, __ccgo_ts+7126, __ccgo_ts+42261, int32(TCL_GLOBAL_ONLY))
	XTcl_UnsetVar2(tls, interp, __ccgo_ts+7126, __ccgo_ts+42269, int32(TCL_GLOBAL_ONLY))
	/*
	 * Unset path information variables (the only one remaining is [info
	 * nameofexecutable])
	 */
	XTcl_UnsetVar2(tls, interp, __ccgo_ts+42274, libc.UintptrFromInt32(0), int32(TCL_GLOBAL_ONLY))
	XTcl_UnsetVar2(tls, interp, __ccgo_ts+17058, libc.UintptrFromInt32(0), int32(TCL_GLOBAL_ONLY))
	XTcl_UnsetVar2(tls, interp, __ccgo_ts+42292, libc.UintptrFromInt32(0), int32(TCL_GLOBAL_ONLY))
	/*
	 * Remove the standard channels from the interpreter; safe interpreters do
	 * not ordinarily have access to stdin, stdout and stderr.
	 *
	 * NOTE: These channels are not added to the interpreter by the
	 * Tcl_CreateInterp call, but may be added later, by another I/O
	 * operation. We want to ensure that the interpreter does not have these
	 * channels even if it is being made safe after being used for some time..
	 */
	chan1 = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1))
	if chan1 != libc.UintptrFromInt32(0) {
		XTcl_UnregisterChannel(tls, interp, chan1)
	}
	chan1 = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2))
	if chan1 != libc.UintptrFromInt32(0) {
		XTcl_UnregisterChannel(tls, interp, chan1)
	}
	chan1 = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(3))
	if chan1 != libc.UintptrFromInt32(0) {
		XTcl_UnregisterChannel(tls, interp, chan1)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LimitExceeded --
 *
 *	Tests whether any limit has been exceeded in the given interpreter
 *	(i.e. whether the interpreter is currently unable to process further
 *	scripts).
 *
 * Results:
 *	A boolean value.
 *
 * Side effects:
 *	None.
 *
 * Notes:
 *	If you change this function, you MUST also update TclLimitExceeded() in
 *	tclInt.h.
 *----------------------------------------------------------------------
 */

func XTcl_LimitExceeded(tls *libc.TLS, interp uintptr) (r int32) {
	var iPtr uintptr
	_ = iPtr
	iPtr = interp
	return libc.BoolInt32((*TInterp)(unsafe.Pointer(iPtr)).Flimit.Fexceeded != 0)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LimitReady --
 *
 *	Find out whether any limit has been set on the interpreter, and if so
 *	check whether the granularity of that limit is such that the full
 *	limit check should be carried out.
 *
 * Results:
 *	A boolean value that indicates whether to call Tcl_LimitCheck.
 *
 * Side effects:
 *	Increments the limit granularity counter.
 *
 * Notes:
 *	If you change this function, you MUST also update TclLimitReady() in
 *	tclInt.h.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LimitReady(tls *libc.TLS, interp uintptr) (r int32) {
	var iPtr, v2 uintptr
	var ticker, v1 int32
	_, _, _, _ = iPtr, ticker, v1, v2
	iPtr = interp
	if (*TInterp)(unsafe.Pointer(iPtr)).Flimit.Factive != 0 {
		v2 = iPtr + 504 + 4
		*(*int32)(unsafe.Pointer(v2))++
		v1 = *(*int32)(unsafe.Pointer(v2))
		ticker = v1
		if (*TInterp)(unsafe.Pointer(iPtr)).Flimit.Factive&int32(TCL_LIMIT_COMMANDS) != 0 && ((*TInterp)(unsafe.Pointer(iPtr)).Flimit.FcmdGranularity == int32(1) || ticker%(*TInterp)(unsafe.Pointer(iPtr)).Flimit.FcmdGranularity == 0) {
			return int32(1)
		}
		if (*TInterp)(unsafe.Pointer(iPtr)).Flimit.Factive&int32(TCL_LIMIT_TIME) != 0 && ((*TInterp)(unsafe.Pointer(iPtr)).Flimit.FtimeGranularity == int32(1) || ticker%(*TInterp)(unsafe.Pointer(iPtr)).Flimit.FtimeGranularity == 0) {
			return int32(1)
		}
	}
	return 0
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LimitCheck --
 *
 *	Check all currently set limits in the interpreter (where permitted by
 *	granularity). If a limit is exceeded, call its callbacks and, if the
 *	limit is still exceeded after the callbacks have run, make the
 *	interpreter generate an error that cannot be caught within the limited
 *	interpreter.
 *
 * Results:
 *	A Tcl result value (TCL_OK if no limit is exceeded, and TCL_ERROR if a
 *	limit has been exceeded).
 *
 * Side effects:
 *	May invoke system calls. May invoke other interpreters. May be
 *	reentrant. May put the interpreter into a state where it can no longer
 *	execute commands without outside intervention.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LimitCheck(tls *libc.TLS, interp uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var iPtr uintptr
	var ticker int32
	var _ /* now at bp+0 */ TTcl_Time
	_, _ = iPtr, ticker
	iPtr = interp
	ticker = (*TInterp)(unsafe.Pointer(iPtr)).Flimit.FgranularityTicker
	if XTcl_InterpDeleted(tls, interp) != 0 {
		return TCL_OK
	}
	if (*TInterp)(unsafe.Pointer(iPtr)).Flimit.Factive&int32(TCL_LIMIT_COMMANDS) != 0 && ((*TInterp)(unsafe.Pointer(iPtr)).Flimit.FcmdGranularity == int32(1) || ticker%(*TInterp)(unsafe.Pointer(iPtr)).Flimit.FcmdGranularity == 0) && (*TInterp)(unsafe.Pointer(iPtr)).Flimit.FcmdCount < (*TInterp)(unsafe.Pointer(iPtr)).FcmdCount {
		(*TInterp)(unsafe.Pointer(iPtr)).Flimit.Fexceeded |= int32(TCL_LIMIT_COMMANDS)
		XTcl_Preserve(tls, interp)
		_RunLimitHandlers(tls, (*TInterp)(unsafe.Pointer(iPtr)).Flimit.FcmdHandlers, interp)
		if (*TInterp)(unsafe.Pointer(iPtr)).Flimit.FcmdCount >= (*TInterp)(unsafe.Pointer(iPtr)).FcmdCount {
			(*TInterp)(unsafe.Pointer(iPtr)).Flimit.Fexceeded &= ^libc.Int32FromInt32(TCL_LIMIT_COMMANDS)
		} else {
			if (*TInterp)(unsafe.Pointer(iPtr)).Flimit.Fexceeded&int32(TCL_LIMIT_COMMANDS) != 0 {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+42304, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+8338, __ccgo_ts+42333, libc.UintptrFromInt32(0)))
				XTcl_Release(tls, interp)
				return int32(TCL_ERROR)
			}
		}
		XTcl_Release(tls, interp)
	}
	if (*TInterp)(unsafe.Pointer(iPtr)).Flimit.Factive&int32(TCL_LIMIT_TIME) != 0 && ((*TInterp)(unsafe.Pointer(iPtr)).Flimit.FtimeGranularity == int32(1) || ticker%(*TInterp)(unsafe.Pointer(iPtr)).Flimit.FtimeGranularity == 0) {
		XTcl_GetTime(tls, bp)
		if (*TInterp)(unsafe.Pointer(iPtr)).Flimit.Ftime.Fsec < (*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec || (*TInterp)(unsafe.Pointer(iPtr)).Flimit.Ftime.Fsec == (*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec && (*TInterp)(unsafe.Pointer(iPtr)).Flimit.Ftime.Fusec < (*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec {
			(*TInterp)(unsafe.Pointer(iPtr)).Flimit.Fexceeded |= int32(TCL_LIMIT_TIME)
			XTcl_Preserve(tls, interp)
			_RunLimitHandlers(tls, (*TInterp)(unsafe.Pointer(iPtr)).Flimit.FtimeHandlers, interp)
			if (*TInterp)(unsafe.Pointer(iPtr)).Flimit.Ftime.Fsec > (*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec || (*TInterp)(unsafe.Pointer(iPtr)).Flimit.Ftime.Fsec == (*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec && (*TInterp)(unsafe.Pointer(iPtr)).Flimit.Ftime.Fusec >= (*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec {
				(*TInterp)(unsafe.Pointer(iPtr)).Flimit.Fexceeded &= ^libc.Int32FromInt32(TCL_LIMIT_TIME)
			} else {
				if (*TInterp)(unsafe.Pointer(iPtr)).Flimit.Fexceeded&int32(TCL_LIMIT_TIME) != 0 {
					XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+42342, int64(-int32(1))))
					XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+8338, __ccgo_ts+42362, libc.UintptrFromInt32(0)))
					XTcl_Release(tls, interp)
					return int32(TCL_ERROR)
				}
			}
			XTcl_Release(tls, interp)
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * RunLimitHandlers --
 *
 *	Invoke all the limit handlers in a list (for a particular limit).
 *	Note that no particular limit handler callback will be invoked
 *	reentrantly.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Depends on the limit handlers.
 *
 *----------------------------------------------------------------------
 */

func _RunLimitHandlers(tls *libc.TLS, handlerPtr uintptr, interp uintptr) {
	var nextPtr uintptr
	_ = nextPtr
	for {
		if !(handlerPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TLimitHandler)(unsafe.Pointer(handlerPtr)).Fflags&(int32(LIMIT_HANDLER_DELETED)|int32(LIMIT_HANDLER_ACTIVE)) != 0 {
			/*
			 * Reentrant call or something seriously strange in the delete
			 * code.
			 */
			nextPtr = (*TLimitHandler)(unsafe.Pointer(handlerPtr)).FnextPtr
			goto _1
		}
		/*
		 * Set the ACTIVE flag while running the limit handler itself so we
		 * cannot reentrantly call this handler and know to use the alternate
		 * method of deletion if necessary.
		 */
		*(*int32)(unsafe.Pointer(handlerPtr)) |= int32(LIMIT_HANDLER_ACTIVE)
		(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TLimitHandler)(unsafe.Pointer(handlerPtr)).FhandlerProc})))(tls, (*TLimitHandler)(unsafe.Pointer(handlerPtr)).FclientData, interp)
		*(*int32)(unsafe.Pointer(handlerPtr)) &= ^int32(LIMIT_HANDLER_ACTIVE)
		/*
		 * Rediscover this value; it might have changed during the processing
		 * of a limit handler. We have to record it here because we might
		 * delete the structure below, and reading a value out of a deleted
		 * structure is unsafe (even if actually legal with some
		 * malloc()/free() implementations.)
		 */
		nextPtr = (*TLimitHandler)(unsafe.Pointer(handlerPtr)).FnextPtr
		/*
		 * If we deleted the current handler while we were executing it, we
		 * will have spliced it out of the list and set the
		 * LIMIT_HANDLER_DELETED flag.
		 */
		if (*TLimitHandler)(unsafe.Pointer(handlerPtr)).Fflags&int32(LIMIT_HANDLER_DELETED) != 0 {
			if (*TLimitHandler)(unsafe.Pointer(handlerPtr)).FdeleteProc != libc.UintptrFromInt32(0) {
				(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TLimitHandler)(unsafe.Pointer(handlerPtr)).FdeleteProc})))(tls, (*TLimitHandler)(unsafe.Pointer(handlerPtr)).FclientData)
			}
			XTclpFree(tls, handlerPtr)
		}
		goto _1
	_1:
		;
		handlerPtr = nextPtr
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LimitAddHandler --
 *
 *	Add a callback handler for a particular resource limit.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Extends the internal linked list of handlers for a limit.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LimitAddHandler(tls *libc.TLS, interp uintptr, type1 int32, handlerProc uintptr, clientData uintptr, deleteProc uintptr) {
	var handlerPtr, iPtr uintptr
	_, _ = handlerPtr, iPtr
	iPtr = interp
	/*
	 * Convert everything into a real deletion callback.
	 */
	if deleteProc == libc.UintptrFromInt32(3) {
		deleteProc = __ccgo_fp(XTclpFree)
	}
	/*
	 * Allocate a handler record.
	 */
	handlerPtr = XTcl_Alloc(tls, uint64(48))
	(*TLimitHandler)(unsafe.Pointer(handlerPtr)).Fflags = 0
	(*TLimitHandler)(unsafe.Pointer(handlerPtr)).FhandlerProc = handlerProc
	(*TLimitHandler)(unsafe.Pointer(handlerPtr)).FclientData = clientData
	(*TLimitHandler)(unsafe.Pointer(handlerPtr)).FdeleteProc = deleteProc
	(*TLimitHandler)(unsafe.Pointer(handlerPtr)).FprevPtr = libc.UintptrFromInt32(0)
	/*
	 * Prepend onto the front of the correct linked list.
	 */
	switch type1 {
	case int32(TCL_LIMIT_COMMANDS):
		(*TLimitHandler)(unsafe.Pointer(handlerPtr)).FnextPtr = (*TInterp)(unsafe.Pointer(iPtr)).Flimit.FcmdHandlers
		if (*TLimitHandler)(unsafe.Pointer(handlerPtr)).FnextPtr != libc.UintptrFromInt32(0) {
			(*TLimitHandler)(unsafe.Pointer((*TLimitHandler)(unsafe.Pointer(handlerPtr)).FnextPtr)).FprevPtr = handlerPtr
		}
		(*TInterp)(unsafe.Pointer(iPtr)).Flimit.FcmdHandlers = handlerPtr
		return
	case int32(TCL_LIMIT_TIME):
		(*TLimitHandler)(unsafe.Pointer(handlerPtr)).FnextPtr = (*TInterp)(unsafe.Pointer(iPtr)).Flimit.FtimeHandlers
		if (*TLimitHandler)(unsafe.Pointer(handlerPtr)).FnextPtr != libc.UintptrFromInt32(0) {
			(*TLimitHandler)(unsafe.Pointer((*TLimitHandler)(unsafe.Pointer(handlerPtr)).FnextPtr)).FprevPtr = handlerPtr
		}
		(*TInterp)(unsafe.Pointer(iPtr)).Flimit.FtimeHandlers = handlerPtr
		return
	}
	XTcl_Panic(tls, __ccgo_ts+42367, 0)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LimitRemoveHandler --
 *
 *	Remove a callback handler for a particular resource limit.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The handler is spliced out of the internal linked list for the limit,
 *	and if not currently being invoked, deleted. Otherwise it is just
 *	marked for deletion and removed when the limit handler has finished
 *	executing.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LimitRemoveHandler(tls *libc.TLS, interp uintptr, type1 int32, handlerProc uintptr, clientData uintptr) {
	var handlerPtr, iPtr uintptr
	_, _ = handlerPtr, iPtr
	iPtr = interp
	switch type1 {
	case int32(TCL_LIMIT_COMMANDS):
		handlerPtr = (*TInterp)(unsafe.Pointer(iPtr)).Flimit.FcmdHandlers
	case int32(TCL_LIMIT_TIME):
		handlerPtr = (*TInterp)(unsafe.Pointer(iPtr)).Flimit.FtimeHandlers
	default:
		XTcl_Panic(tls, __ccgo_ts+42367, 0)
		return
	}
	for {
		if !(handlerPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TLimitHandler)(unsafe.Pointer(handlerPtr)).FhandlerProc != handlerProc || (*TLimitHandler)(unsafe.Pointer(handlerPtr)).FclientData != clientData {
			goto _1
		}
		/*
		 * We've found the handler to delete; mark it as doomed if not already
		 * so marked (which shouldn't actually happen).
		 */
		if (*TLimitHandler)(unsafe.Pointer(handlerPtr)).Fflags&int32(LIMIT_HANDLER_DELETED) != 0 {
			return
		}
		*(*int32)(unsafe.Pointer(handlerPtr)) |= int32(LIMIT_HANDLER_DELETED)
		/*
		 * Splice the handler out of the doubly-linked list.
		 */
		if (*TLimitHandler)(unsafe.Pointer(handlerPtr)).FprevPtr == libc.UintptrFromInt32(0) {
			switch type1 {
			case int32(TCL_LIMIT_COMMANDS):
				(*TInterp)(unsafe.Pointer(iPtr)).Flimit.FcmdHandlers = (*TLimitHandler)(unsafe.Pointer(handlerPtr)).FnextPtr
			case int32(TCL_LIMIT_TIME):
				(*TInterp)(unsafe.Pointer(iPtr)).Flimit.FtimeHandlers = (*TLimitHandler)(unsafe.Pointer(handlerPtr)).FnextPtr
				break
			}
		} else {
			(*TLimitHandler)(unsafe.Pointer((*TLimitHandler)(unsafe.Pointer(handlerPtr)).FprevPtr)).FnextPtr = (*TLimitHandler)(unsafe.Pointer(handlerPtr)).FnextPtr
		}
		if (*TLimitHandler)(unsafe.Pointer(handlerPtr)).FnextPtr != libc.UintptrFromInt32(0) {
			(*TLimitHandler)(unsafe.Pointer((*TLimitHandler)(unsafe.Pointer(handlerPtr)).FnextPtr)).FprevPtr = (*TLimitHandler)(unsafe.Pointer(handlerPtr)).FprevPtr
		}
		/*
		 * If nothing is currently executing the handler, delete its client
		 * data and the overall handler structure now. Otherwise it will all
		 * go away when the handler returns.
		 */
		if !((*TLimitHandler)(unsafe.Pointer(handlerPtr)).Fflags&int32(LIMIT_HANDLER_ACTIVE) != 0) {
			if (*TLimitHandler)(unsafe.Pointer(handlerPtr)).FdeleteProc != libc.UintptrFromInt32(0) {
				(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TLimitHandler)(unsafe.Pointer(handlerPtr)).FdeleteProc})))(tls, (*TLimitHandler)(unsafe.Pointer(handlerPtr)).FclientData)
			}
			XTclpFree(tls, handlerPtr)
		}
		return
		goto _1
	_1:
		;
		handlerPtr = (*TLimitHandler)(unsafe.Pointer(handlerPtr)).FnextPtr
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclLimitRemoveAllHandlers --
 *
 *	Remove all limit callback handlers for an interpreter. This is invoked
 *	as part of deleting the interpreter.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Limit handlers are deleted or marked for deletion (as with
 *	Tcl_LimitRemoveHandler).
 *
 *----------------------------------------------------------------------
 */

func XTclLimitRemoveAllHandlers(tls *libc.TLS, interp uintptr) {
	var handlerPtr, iPtr, nextHandlerPtr uintptr
	_, _, _ = handlerPtr, iPtr, nextHandlerPtr
	iPtr = interp
	/*
	 * Delete all command-limit handlers.
	 */
	handlerPtr = (*TInterp)(unsafe.Pointer(iPtr)).Flimit.FcmdHandlers
	(*TInterp)(unsafe.Pointer(iPtr)).Flimit.FcmdHandlers = libc.UintptrFromInt32(0)
	for {
		if !(handlerPtr != libc.UintptrFromInt32(0)) {
			break
		}
		nextHandlerPtr = (*TLimitHandler)(unsafe.Pointer(handlerPtr)).FnextPtr
		/*
		 * Do not delete here if it has already been marked for deletion.
		 */
		if (*TLimitHandler)(unsafe.Pointer(handlerPtr)).Fflags&int32(LIMIT_HANDLER_DELETED) != 0 {
			goto _1
		}
		*(*int32)(unsafe.Pointer(handlerPtr)) |= int32(LIMIT_HANDLER_DELETED)
		(*TLimitHandler)(unsafe.Pointer(handlerPtr)).FprevPtr = libc.UintptrFromInt32(0)
		(*TLimitHandler)(unsafe.Pointer(handlerPtr)).FnextPtr = libc.UintptrFromInt32(0)
		/*
		 * If nothing is currently executing the handler, delete its client
		 * data and the overall handler structure now. Otherwise it will all
		 * go away when the handler returns.
		 */
		if !((*TLimitHandler)(unsafe.Pointer(handlerPtr)).Fflags&int32(LIMIT_HANDLER_ACTIVE) != 0) {
			if (*TLimitHandler)(unsafe.Pointer(handlerPtr)).FdeleteProc != libc.UintptrFromInt32(0) {
				(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TLimitHandler)(unsafe.Pointer(handlerPtr)).FdeleteProc})))(tls, (*TLimitHandler)(unsafe.Pointer(handlerPtr)).FclientData)
			}
			XTclpFree(tls, handlerPtr)
		}
		goto _1
	_1:
		;
		handlerPtr = nextHandlerPtr
	}
	/*
	 * Delete all time-limit handlers.
	 */
	handlerPtr = (*TInterp)(unsafe.Pointer(iPtr)).Flimit.FtimeHandlers
	(*TInterp)(unsafe.Pointer(iPtr)).Flimit.FtimeHandlers = libc.UintptrFromInt32(0)
	for {
		if !(handlerPtr != libc.UintptrFromInt32(0)) {
			break
		}
		nextHandlerPtr = (*TLimitHandler)(unsafe.Pointer(handlerPtr)).FnextPtr
		/*
		 * Do not delete here if it has already been marked for deletion.
		 */
		if (*TLimitHandler)(unsafe.Pointer(handlerPtr)).Fflags&int32(LIMIT_HANDLER_DELETED) != 0 {
			goto _2
		}
		*(*int32)(unsafe.Pointer(handlerPtr)) |= int32(LIMIT_HANDLER_DELETED)
		(*TLimitHandler)(unsafe.Pointer(handlerPtr)).FprevPtr = libc.UintptrFromInt32(0)
		(*TLimitHandler)(unsafe.Pointer(handlerPtr)).FnextPtr = libc.UintptrFromInt32(0)
		/*
		 * If nothing is currently executing the handler, delete its client
		 * data and the overall handler structure now. Otherwise it will all
		 * go away when the handler returns.
		 */
		if !((*TLimitHandler)(unsafe.Pointer(handlerPtr)).Fflags&int32(LIMIT_HANDLER_ACTIVE) != 0) {
			if (*TLimitHandler)(unsafe.Pointer(handlerPtr)).FdeleteProc != libc.UintptrFromInt32(0) {
				(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TLimitHandler)(unsafe.Pointer(handlerPtr)).FdeleteProc})))(tls, (*TLimitHandler)(unsafe.Pointer(handlerPtr)).FclientData)
			}
			XTclpFree(tls, handlerPtr)
		}
		goto _2
	_2:
		;
		handlerPtr = nextHandlerPtr
	}
	/*
	 * Delete the timer callback that is used to trap limits that occur in
	 * [vwait]s...
	 */
	if (*TInterp)(unsafe.Pointer(iPtr)).Flimit.FtimeEvent != libc.UintptrFromInt32(0) {
		XTcl_DeleteTimerHandler(tls, (*TInterp)(unsafe.Pointer(iPtr)).Flimit.FtimeEvent)
		(*TInterp)(unsafe.Pointer(iPtr)).Flimit.FtimeEvent = libc.UintptrFromInt32(0)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LimitTypeEnabled --
 *
 *	Check whether a particular limit has been enabled for an interpreter.
 *
 * Results:
 *	A boolean value.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LimitTypeEnabled(tls *libc.TLS, interp uintptr, type1 int32) (r int32) {
	var iPtr uintptr
	_ = iPtr
	iPtr = interp
	return libc.BoolInt32((*TInterp)(unsafe.Pointer(iPtr)).Flimit.Factive&type1 != 0)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LimitTypeExceeded --
 *
 *	Check whether a particular limit has been exceeded for an interpreter.
 *
 * Results:
 *	A boolean value (note that Tcl_LimitExceeded will always return
 *	non-zero when this function returns non-zero).
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LimitTypeExceeded(tls *libc.TLS, interp uintptr, type1 int32) (r int32) {
	var iPtr uintptr
	_ = iPtr
	iPtr = interp
	return libc.BoolInt32((*TInterp)(unsafe.Pointer(iPtr)).Flimit.Fexceeded&type1 != 0)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LimitTypeSet --
 *
 *	Enable a particular limit for an interpreter.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The limit is turned on and will be checked in future at an interval
 *	determined by the frequency of calling of Tcl_LimitReady and the
 *	granularity of the limit in question.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LimitTypeSet(tls *libc.TLS, interp uintptr, type1 int32) {
	var iPtr uintptr
	_ = iPtr
	iPtr = interp
	(*TInterp)(unsafe.Pointer(iPtr)).Flimit.Factive |= type1
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LimitTypeReset --
 *
 *	Disable a particular limit for an interpreter.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The limit is disabled. If the limit was exceeded when this function
 *	was called, the limit will no longer be exceeded afterwards and the
 *	interpreter will be free to execute further scripts (assuming it isn't
 *	also deleted, of course).
 *
 *----------------------------------------------------------------------
 */

func XTcl_LimitTypeReset(tls *libc.TLS, interp uintptr, type1 int32) {
	var iPtr uintptr
	_ = iPtr
	iPtr = interp
	(*TInterp)(unsafe.Pointer(iPtr)).Flimit.Factive &= ^type1
	(*TInterp)(unsafe.Pointer(iPtr)).Flimit.Fexceeded &= ^type1
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LimitSetCommands --
 *
 *	Set the command limit for an interpreter.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Also resets whether the command limit was exceeded. This might permit
 *	a small amount of further execution in the interpreter even if the
 *	limit itself is theoretically exceeded.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LimitSetCommands(tls *libc.TLS, interp uintptr, commandLimit TTcl_Size) {
	var iPtr uintptr
	_ = iPtr
	iPtr = interp
	(*TInterp)(unsafe.Pointer(iPtr)).Flimit.FcmdCount = commandLimit
	(*TInterp)(unsafe.Pointer(iPtr)).Flimit.Fexceeded &= ^libc.Int32FromInt32(TCL_LIMIT_COMMANDS)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LimitGetCommands --
 *
 *	Get the number of commands that may be executed in the interpreter
 *	before the command-limit is reached.
 *
 * Results:
 *	An upper bound on the number of commands.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LimitGetCommands(tls *libc.TLS, interp uintptr) (r int32) {
	var iPtr uintptr
	_ = iPtr
	iPtr = interp
	return int32((*TInterp)(unsafe.Pointer(iPtr)).Flimit.FcmdCount)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LimitSetTime --
 *
 *	Set the time limit for an interpreter by copying it from the value
 *	pointed to by the timeLimitPtr argument.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Also resets whether the time limit was exceeded. This might permit a
 *	small amount of further execution in the interpreter even if the limit
 *	itself is theoretically exceeded.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LimitSetTime(tls *libc.TLS, interp uintptr, timeLimitPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var iPtr uintptr
	var _ /* nextMoment at bp+0 */ TTcl_Time
	_ = iPtr
	iPtr = interp
	libc.Xmemcpy(tls, iPtr+504+40, timeLimitPtr, uint64(16))
	if (*TInterp)(unsafe.Pointer(iPtr)).Flimit.FtimeEvent != libc.UintptrFromInt32(0) {
		XTcl_DeleteTimerHandler(tls, (*TInterp)(unsafe.Pointer(iPtr)).Flimit.FtimeEvent)
	}
	(*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec = (*TTcl_Time)(unsafe.Pointer(timeLimitPtr)).Fsec
	(*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec = (*TTcl_Time)(unsafe.Pointer(timeLimitPtr)).Fusec + int64(10)
	if (*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec >= int64(1000000) {
		(*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec++
		(*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec -= int64(1000000)
	}
	(*TInterp)(unsafe.Pointer(iPtr)).Flimit.FtimeEvent = XTclCreateAbsoluteTimerHandler(tls, bp, __ccgo_fp(_TimeLimitCallback), interp)
	(*TInterp)(unsafe.Pointer(iPtr)).Flimit.Fexceeded &= ^libc.Int32FromInt32(TCL_LIMIT_TIME)
}

/*
 *----------------------------------------------------------------------
 *
 * TimeLimitCallback --
 *
 *	Callback that allows time limits to be enforced even when doing a
 *	blocking wait for events.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	May put the interpreter into a state where it can no longer execute
 *	commands. May make callbacks into other interpreters.
 *
 *----------------------------------------------------------------------
 */

func _TimeLimitCallback(tls *libc.TLS, clientData uintptr) {
	var code int32
	var iPtr, interp uintptr
	_, _, _ = code, iPtr, interp
	interp = clientData
	iPtr = clientData
	XTcl_Preserve(tls, interp)
	(*TInterp)(unsafe.Pointer(iPtr)).Flimit.FtimeEvent = libc.UintptrFromInt32(0)
	/*
	 * Must reset the granularity ticker here to force an immediate full
	 * check. This is OK because we're swallowing the cost in the overall cost
	 * of the event loop. [Bug 2891362]
	 */
	(*TInterp)(unsafe.Pointer(iPtr)).Flimit.FgranularityTicker = 0
	code = XTcl_LimitCheck(tls, interp)
	if code != TCL_OK {
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+42398, int64(-int32(1))))
		XTcl_BackgroundException(tls, interp, code)
	}
	XTcl_Release(tls, interp)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LimitGetTime --
 *
 *	Get the current time limit.
 *
 * Results:
 *	The time limit (by it being copied into the variable pointed to by the
 *	timeLimitPtr).
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LimitGetTime(tls *libc.TLS, interp uintptr, timeLimitPtr uintptr) {
	var iPtr uintptr
	_ = iPtr
	iPtr = interp
	libc.Xmemcpy(tls, timeLimitPtr, iPtr+504+40, uint64(16))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LimitSetGranularity --
 *
 *	Set the granularity divisor (which must be positive) for a particular
 *	limit.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The granularity is updated.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LimitSetGranularity(tls *libc.TLS, interp uintptr, type1 int32, granularity int32) {
	var iPtr uintptr
	_ = iPtr
	iPtr = interp
	if granularity < int32(1) {
		XTcl_Panic(tls, __ccgo_ts+42429, 0)
	}
	switch type1 {
	case int32(TCL_LIMIT_COMMANDS):
		(*TInterp)(unsafe.Pointer(iPtr)).Flimit.FcmdGranularity = granularity
		return
	case int32(TCL_LIMIT_TIME):
		(*TInterp)(unsafe.Pointer(iPtr)).Flimit.FtimeGranularity = granularity
		return
	}
	XTcl_Panic(tls, __ccgo_ts+42367, 0)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LimitGetGranularity --
 *
 *	Get the granularity divisor for a particular limit.
 *
 * Results:
 *	The granularity divisor for the given limit.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LimitGetGranularity(tls *libc.TLS, interp uintptr, type1 int32) (r int32) {
	var iPtr uintptr
	_ = iPtr
	iPtr = interp
	switch type1 {
	case int32(TCL_LIMIT_COMMANDS):
		return (*TInterp)(unsafe.Pointer(iPtr)).Flimit.FcmdGranularity
	case int32(TCL_LIMIT_TIME):
		return (*TInterp)(unsafe.Pointer(iPtr)).Flimit.FtimeGranularity
	}
	XTcl_Panic(tls, __ccgo_ts+42367, 0)
	return -int32(1) /* NOT REACHED */
}

/*
 *----------------------------------------------------------------------
 *
 * DeleteScriptLimitCallback --
 *
 *	Callback for when a script limit (a limit callback implemented as a
 *	Tcl script in a parent interpreter, as set up from Tcl) is deleted.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The reference to the script callback from the controlling interpreter
 *	is removed.
 *
 *----------------------------------------------------------------------
 */

func _DeleteScriptLimitCallback(tls *libc.TLS, clientData uintptr) {
	var _objPtr, limitCBPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _ = _objPtr, limitCBPtr, v1, v2
	limitCBPtr = clientData
	_objPtr = (*TScriptLimitCallback)(unsafe.Pointer(limitCBPtr)).FscriptObj
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	if (*TScriptLimitCallback)(unsafe.Pointer(limitCBPtr)).FentryPtr != libc.UintptrFromInt32(0) {
		XTcl_DeleteHashEntry(tls, (*TScriptLimitCallback)(unsafe.Pointer(limitCBPtr)).FentryPtr)
	}
	XTclpFree(tls, limitCBPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * CallScriptLimitCallback --
 *
 *	Invoke a script limit callback. Used to implement limit callbacks set
 *	at the Tcl level on child interpreters.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Depends on the callback script. Errors are reported as background
 *	errors.
 *
 *----------------------------------------------------------------------
 */

func _CallScriptLimitCallback(tls *libc.TLS, clientData uintptr, dummy4212 uintptr) {
	var code int32
	var limitCBPtr uintptr
	_, _ = code, limitCBPtr
	limitCBPtr = clientData
	if XTcl_InterpDeleted(tls, (*TScriptLimitCallback)(unsafe.Pointer(limitCBPtr)).Finterp) != 0 {
		return
	}
	XTcl_Preserve(tls, (*TScriptLimitCallback)(unsafe.Pointer(limitCBPtr)).Finterp)
	code = XTcl_EvalObjEx(tls, (*TScriptLimitCallback)(unsafe.Pointer(limitCBPtr)).Finterp, (*TScriptLimitCallback)(unsafe.Pointer(limitCBPtr)).FscriptObj, int32(TCL_EVAL_GLOBAL))
	if code != TCL_OK && !(XTcl_InterpDeleted(tls, (*TScriptLimitCallback)(unsafe.Pointer(limitCBPtr)).Finterp) != 0) {
		XTcl_BackgroundException(tls, (*TScriptLimitCallback)(unsafe.Pointer(limitCBPtr)).Finterp, code)
	}
	XTcl_Release(tls, (*TScriptLimitCallback)(unsafe.Pointer(limitCBPtr)).Finterp)
}

/*
 *----------------------------------------------------------------------
 *
 * SetScriptLimitCallback --
 *
 *	Install (or remove, if scriptObj is NULL) a limit callback script that
 *	is called when the target interpreter exceeds the type of limit
 *	specified. Each interpreter may only have one callback set on another
 *	interpreter through this mechanism (though as many interpreters may be
 *	limited as the programmer chooses overall).
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	A limit callback implemented as an invocation of a Tcl script in
 *	another interpreter is either installed or removed.
 *
 *----------------------------------------------------------------------
 */

func _SetScriptLimitCallback(tls *libc.TLS, interp uintptr, type1 int32, targetInterp uintptr, scriptObj uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var hashPtr, iPtr, limitCBPtr uintptr
	var _ /* isNew at bp+0 */ int32
	var _ /* key at bp+8 */ TScriptLimitCallbackKey
	_, _, _ = hashPtr, iPtr, limitCBPtr
	iPtr = interp
	if interp == targetInterp {
		XTcl_Panic(tls, __ccgo_ts+42464, 0)
	}
	(*(*TScriptLimitCallbackKey)(unsafe.Pointer(bp + 8))).Finterp = targetInterp
	(*(*TScriptLimitCallbackKey)(unsafe.Pointer(bp + 8))).Ftype1 = int64(type1)
	if scriptObj == libc.UintptrFromInt32(0) {
		hashPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iPtr + 504 + 80)).FfindProc})))(tls, iPtr+504+80, bp+8)
		if hashPtr != libc.UintptrFromInt32(0) {
			XTcl_LimitRemoveHandler(tls, targetInterp, type1, __ccgo_fp(_CallScriptLimitCallback), (*TTcl_HashEntry)(unsafe.Pointer(hashPtr)).FclientData)
		}
		return
	}
	hashPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iPtr + 504 + 80)).FcreateProc})))(tls, iPtr+504+80, bp+8, bp)
	if !(*(*int32)(unsafe.Pointer(bp)) != 0) {
		limitCBPtr = (*TTcl_HashEntry)(unsafe.Pointer(hashPtr)).FclientData
		(*TScriptLimitCallback)(unsafe.Pointer(limitCBPtr)).FentryPtr = libc.UintptrFromInt32(0)
		XTcl_LimitRemoveHandler(tls, targetInterp, type1, __ccgo_fp(_CallScriptLimitCallback), limitCBPtr)
	}
	limitCBPtr = XTcl_Alloc(tls, uint64(32))
	(*TScriptLimitCallback)(unsafe.Pointer(limitCBPtr)).Finterp = interp
	(*TScriptLimitCallback)(unsafe.Pointer(limitCBPtr)).FscriptObj = scriptObj
	(*TScriptLimitCallback)(unsafe.Pointer(limitCBPtr)).FentryPtr = hashPtr
	(*TScriptLimitCallback)(unsafe.Pointer(limitCBPtr)).Ftype1 = type1
	(*TTcl_Obj)(unsafe.Pointer(scriptObj)).FrefCount++
	XTcl_LimitAddHandler(tls, targetInterp, type1, __ccgo_fp(_CallScriptLimitCallback), limitCBPtr, __ccgo_fp(_DeleteScriptLimitCallback))
	(*TTcl_HashEntry)(unsafe.Pointer(hashPtr)).FclientData = limitCBPtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclRemoveScriptLimitCallbacks --
 *
 *	Remove all script-implemented limit callbacks that make calls back
 *	into the given interpreter. This invoked as part of deleting an
 *	interpreter.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The script limit callbacks are removed or marked for later removal.
 *
 *----------------------------------------------------------------------
 */

func XTclRemoveScriptLimitCallbacks(tls *libc.TLS, interp uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var hashPtr, iPtr, keyPtr, v1 uintptr
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _ = hashPtr, iPtr, keyPtr, v1
	iPtr = interp
	hashPtr = XTcl_FirstHashEntry(tls, iPtr+504+80, bp)
	for hashPtr != libc.UintptrFromInt32(0) {
		if (*TTcl_HashTable)(unsafe.Pointer(iPtr+504+80)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(iPtr+504+80)).FkeyType == -int32(1) {
			v1 = *(*uintptr)(unsafe.Pointer(hashPtr + 32))
		} else {
			v1 = hashPtr + 32
		}
		keyPtr = v1
		XTcl_LimitRemoveHandler(tls, (*TScriptLimitCallbackKey)(unsafe.Pointer(keyPtr)).Finterp, int32((*TScriptLimitCallbackKey)(unsafe.Pointer(keyPtr)).Ftype1), __ccgo_fp(_CallScriptLimitCallback), (*TTcl_HashEntry)(unsafe.Pointer(hashPtr)).FclientData)
		hashPtr = XTcl_NextHashEntry(tls, bp)
	}
	XTcl_DeleteHashTable(tls, iPtr+504+80)
}

/*
 *----------------------------------------------------------------------
 *
 * TclInitLimitSupport --
 *
 *	Initialise all the parts of the interpreter relating to resource limit
 *	management. This allows an interpreter to both have limits set upon
 *	itself and set limits upon other interpreters.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The resource limit subsystem is initialised for the interpreter.
 *
 *----------------------------------------------------------------------
 */

func XTclInitLimitSupport(tls *libc.TLS, interp uintptr) {
	var iPtr uintptr
	_ = iPtr
	iPtr = interp
	(*TInterp)(unsafe.Pointer(iPtr)).Flimit.Factive = 0
	(*TInterp)(unsafe.Pointer(iPtr)).Flimit.FgranularityTicker = 0
	(*TInterp)(unsafe.Pointer(iPtr)).Flimit.Fexceeded = 0
	(*TInterp)(unsafe.Pointer(iPtr)).Flimit.FcmdCount = 0
	(*TInterp)(unsafe.Pointer(iPtr)).Flimit.FcmdHandlers = libc.UintptrFromInt32(0)
	(*TInterp)(unsafe.Pointer(iPtr)).Flimit.FcmdGranularity = int32(1)
	libc.Xmemset(tls, iPtr+504+40, 0, uint64(16))
	(*TInterp)(unsafe.Pointer(iPtr)).Flimit.FtimeHandlers = libc.UintptrFromInt32(0)
	(*TInterp)(unsafe.Pointer(iPtr)).Flimit.FtimeEvent = libc.UintptrFromInt32(0)
	(*TInterp)(unsafe.Pointer(iPtr)).Flimit.FtimeGranularity = int32(10)
	XTcl_InitHashTable(tls, iPtr+504+80, libc.Int32FromUint64(libc.Uint64FromInt64(16)/libc.Uint64FromInt64(4)))
}

/*
 *----------------------------------------------------------------------
 *
 * InheritLimitsFromParent --
 *
 *	Derive the interpreter limit configuration for a child interpreter
 *	from the limit config for the parent.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The child interpreter limits are set so that if the parent has a
 *	limit, it may not exceed it by handing off work to child interpreters.
 *	Note that this does not transfer limit callbacks from the parent to
 *	the child.
 *
 *----------------------------------------------------------------------
 */

func _InheritLimitsFromParent(tls *libc.TLS, childInterp uintptr, parentInterp uintptr) {
	var childPtr, parentPtr uintptr
	_, _ = childPtr, parentPtr
	childPtr = childInterp
	parentPtr = parentInterp
	if (*TInterp)(unsafe.Pointer(parentPtr)).Flimit.Factive&int32(TCL_LIMIT_COMMANDS) != 0 {
		(*TInterp)(unsafe.Pointer(childPtr)).Flimit.Factive |= int32(TCL_LIMIT_COMMANDS)
		(*TInterp)(unsafe.Pointer(childPtr)).Flimit.FcmdCount = 0
		(*TInterp)(unsafe.Pointer(childPtr)).Flimit.FcmdGranularity = (*TInterp)(unsafe.Pointer(parentPtr)).Flimit.FcmdGranularity
	}
	if (*TInterp)(unsafe.Pointer(parentPtr)).Flimit.Factive&int32(TCL_LIMIT_TIME) != 0 {
		(*TInterp)(unsafe.Pointer(childPtr)).Flimit.Factive |= int32(TCL_LIMIT_TIME)
		libc.Xmemcpy(tls, childPtr+504+40, parentPtr+504+40, uint64(16))
		(*TInterp)(unsafe.Pointer(childPtr)).Flimit.FtimeGranularity = (*TInterp)(unsafe.Pointer(parentPtr)).Flimit.FtimeGranularity
	}
}

/*
 *----------------------------------------------------------------------
 *
 * ChildCommandLimitCmd --
 *
 *	Implementation of the [interp limit $i commands] and [$i limit
 *	commands] subcommands. See the interp manual page for a full
 *	description.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Depends on the arguments.
 *
 *----------------------------------------------------------------------
 */

func _ChildCommandLimitCmd(tls *libc.TLS, interp uintptr, childInterp uintptr, consumedObjc TTcl_Size, objc TTcl_Size, objv uintptr) (r int32) {
	bp := tls.Alloc(96)
	defer tls.Free(96) /* Argument objects. */
	var cachePtr, cachePtr1, cachePtr2, dictPtr, empty, empty1, granObj, hPtr, iPtr, limitCBPtr, limitObj, scriptObj, v11 uintptr
	var i TTcl_Size
	var v1, v4, v5 bool
	var v10, v8 int32
	var _ /* gran at bp+40 */ int32
	var _ /* index at bp+0 */ int32
	var _ /* key at bp+8 */ TScriptLimitCallbackKey
	var _ /* limit at bp+44 */ int32
	var _ /* limitLen at bp+32 */ TTcl_Size
	var _ /* scriptLen at bp+24 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, dictPtr, empty, empty1, granObj, hPtr, i, iPtr, limitCBPtr, limitObj, scriptObj, v1, v10, v11, v4, v5, v8
	iPtr = interp
	/*
	 * First, ensure that we are not reading or writing the calling
	 * interpreter's limits; it may only manipulate its children. Note that
	 * the low level API enforces this with Tcl_Panic, which we want to
	 * avoid. [Bug 3398794]
	 */
	if interp == childInterp {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+42537, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+56, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+40852, __ccgo_ts+42580, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if objc == consumedObjc {
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			dictPtr = XTclThreadAllocObj(tls)
		} else {
			dictPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(dictPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr = libc.UintptrFromInt32(0)
		(*(*TScriptLimitCallbackKey)(unsafe.Pointer(bp + 8))).Finterp = childInterp
		(*(*TScriptLimitCallbackKey)(unsafe.Pointer(bp + 8))).Ftype1 = int64(TCL_LIMIT_COMMANDS)
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iPtr + 504 + 80)).FfindProc})))(tls, iPtr+504+80, bp+8)
		if !(hPtr != libc.UintptrFromInt32(0)) {
			goto _2
		}
		limitCBPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		if limitCBPtr != libc.UintptrFromInt32(0) && (*TScriptLimitCallback)(unsafe.Pointer(limitCBPtr)).FscriptObj != libc.UintptrFromInt32(0) {
			XTclDictPut(tls, libc.UintptrFromInt32(0), dictPtr, _options13[0], (*TScriptLimitCallback)(unsafe.Pointer(limitCBPtr)).FscriptObj)
		} else {
			goto putEmptyCommandInDict
		}
		goto _3
	_2:
		;
		goto putEmptyCommandInDict
	putEmptyCommandInDict:
		;
		if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			empty = XTclThreadAllocObj(tls)
		} else {
			empty = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(empty + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(empty)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(empty)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(empty)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(empty)).FtypePtr = libc.UintptrFromInt32(0)
		XTclDictPut(tls, libc.UintptrFromInt32(0), dictPtr, _options13[0], empty)
	_3:
		;
		XTclDictPut(tls, libc.UintptrFromInt32(0), dictPtr, _options13[int32(1)], XTcl_NewWideIntObj(tls, int64(XTcl_LimitGetGranularity(tls, childInterp, int32(TCL_LIMIT_COMMANDS)))))
		if XTcl_LimitTypeEnabled(tls, childInterp, int32(TCL_LIMIT_COMMANDS)) != 0 {
			XTclDictPut(tls, libc.UintptrFromInt32(0), dictPtr, _options13[int32(2)], XTcl_NewWideIntObj(tls, int64(XTcl_LimitGetCommands(tls, childInterp))))
		} else {
			if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
				cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v5 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
				empty1 = XTclThreadAllocObj(tls)
			} else {
				empty1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(empty1 + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(empty1)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(empty1)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(empty1)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(empty1)).FtypePtr = libc.UintptrFromInt32(0)
			XTclDictPut(tls, libc.UintptrFromInt32(0), dictPtr, _options13[int32(2)], empty1)
		}
		XTcl_SetObjResult(tls, interp, dictPtr)
		return TCL_OK
	} else {
		if objc == consumedObjc+int64(1) {
			if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(consumedObjc)*8)), uintptr(unsafe.Pointer(&_options13)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
				return int32(TCL_ERROR)
			}
			switch *(*int32)(unsafe.Pointer(bp)) {
			case 0:
				(*(*TScriptLimitCallbackKey)(unsafe.Pointer(bp + 8))).Finterp = childInterp
				(*(*TScriptLimitCallbackKey)(unsafe.Pointer(bp + 8))).Ftype1 = int64(TCL_LIMIT_COMMANDS)
				hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iPtr + 504 + 80)).FfindProc})))(tls, iPtr+504+80, bp+8)
				if hPtr != libc.UintptrFromInt32(0) {
					limitCBPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
					if limitCBPtr != libc.UintptrFromInt32(0) && (*TScriptLimitCallback)(unsafe.Pointer(limitCBPtr)).FscriptObj != libc.UintptrFromInt32(0) {
						XTcl_SetObjResult(tls, interp, (*TScriptLimitCallback)(unsafe.Pointer(limitCBPtr)).FscriptObj)
					}
				}
			case 1:
				XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, int64(XTcl_LimitGetGranularity(tls, childInterp, int32(TCL_LIMIT_COMMANDS)))))
			case 2:
				if XTcl_LimitTypeEnabled(tls, childInterp, int32(TCL_LIMIT_COMMANDS)) != 0 {
					XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, int64(XTcl_LimitGetCommands(tls, childInterp))))
				}
				break
			}
			return TCL_OK
		} else {
			if (objc-consumedObjc)&int64(1) != 0 {
				XTcl_WrongNumArgs(tls, interp, consumedObjc, objv, __ccgo_ts+42585)
				return int32(TCL_ERROR)
			} else {
				*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = 0
				*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = 0
				scriptObj = libc.UintptrFromInt32(0)
				granObj = libc.UintptrFromInt32(0)
				limitObj = libc.UintptrFromInt32(0)
				*(*int32)(unsafe.Pointer(bp + 40)) = 0
				*(*int32)(unsafe.Pointer(bp + 44)) = 0
				i = consumedObjc
				for {
					if !(i < objc) {
						break
					}
					if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_options13)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
						return int32(TCL_ERROR)
					}
					switch *(*int32)(unsafe.Pointer(bp)) {
					case 0:
						scriptObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8))
						if (*TTcl_Obj)(unsafe.Pointer(scriptObj)).Fbytes != 0 {
							*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = (*TTcl_Obj)(unsafe.Pointer(scriptObj)).Flength
							_ = (*TTcl_Obj)(unsafe.Pointer(scriptObj)).Fbytes
						} else {
							XTcl_GetStringFromObj(tls, scriptObj, bp+24)
						}
					case 1:
						granObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8))
						if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
							*(*int32)(unsafe.Pointer(bp + 40)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).FinternalRep)))
							v8 = libc.Int32FromInt32(TCL_OK)
						} else {
							v8 = XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)), bp+40)
						}
						if v8 != TCL_OK {
							return int32(TCL_ERROR)
						}
						if *(*int32)(unsafe.Pointer(bp + 40)) < int32(1) {
							XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+42605, int64(-int32(1))))
							XTcl_SetErrorCode(tls, interp, libc.VaList(bp+56, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+40852, __ccgo_ts+42636, libc.UintptrFromInt32(0)))
							return int32(TCL_ERROR)
						}
					case 2:
						limitObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8))
						if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).Fbytes != 0 {
							*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).Flength
							_ = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).Fbytes
						} else {
							XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)), bp+32)
						}
						if *(*TTcl_Size)(unsafe.Pointer(bp + 32)) == 0 {
							break
						}
						if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
							*(*int32)(unsafe.Pointer(bp + 44)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).FinternalRep)))
							v10 = libc.Int32FromInt32(TCL_OK)
						} else {
							v10 = XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)), bp+44)
						}
						if v10 != TCL_OK {
							return int32(TCL_ERROR)
						}
						if *(*int32)(unsafe.Pointer(bp + 44)) < 0 {
							XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+42645, int64(-int32(1))))
							XTcl_SetErrorCode(tls, interp, libc.VaList(bp+56, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+40852, __ccgo_ts+42636, libc.UintptrFromInt32(0)))
							return int32(TCL_ERROR)
						}
						break
					}
					goto _6
				_6:
					;
					i += int64(2)
				}
				if scriptObj != libc.UintptrFromInt32(0) {
					if *(*TTcl_Size)(unsafe.Pointer(bp + 24)) > 0 {
						v11 = scriptObj
					} else {
						v11 = libc.UintptrFromInt32(0)
					}
					_SetScriptLimitCallback(tls, interp, int32(TCL_LIMIT_COMMANDS), childInterp, v11)
				}
				if granObj != libc.UintptrFromInt32(0) {
					XTcl_LimitSetGranularity(tls, childInterp, int32(TCL_LIMIT_COMMANDS), *(*int32)(unsafe.Pointer(bp + 40)))
				}
				if limitObj != libc.UintptrFromInt32(0) {
					if *(*TTcl_Size)(unsafe.Pointer(bp + 32)) > 0 {
						XTcl_LimitSetCommands(tls, childInterp, int64(*(*int32)(unsafe.Pointer(bp + 44))))
						XTcl_LimitTypeSet(tls, childInterp, int32(TCL_LIMIT_COMMANDS))
					} else {
						XTcl_LimitTypeReset(tls, childInterp, int32(TCL_LIMIT_COMMANDS))
					}
				}
				return TCL_OK
			}
		}
	}
	return r
}

var _options13 = [4]uintptr{
	0: __ccgo_ts + 18236,
	1: __ccgo_ts + 42517,
	2: __ccgo_ts + 42530,
	3: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * ChildTimeLimitCmd --
 *
 *	Implementation of the [interp limit $i time] and [$i limit time]
 *	subcommands. See the interp manual page for a full description.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Depends on the arguments.
 *
 *----------------------------------------------------------------------
 */

func _ChildTimeLimitCmd(tls *libc.TLS, interp uintptr, childInterp uintptr, consumedObjc TTcl_Size, objc TTcl_Size, objv uintptr) (r int32) {
	bp := tls.Alloc(176)
	defer tls.Free(176) /* Argument objects. */
	var cachePtr, cachePtr1, cachePtr2, dictPtr, empty, empty1, granObj, hPtr, iPtr, limitCBPtr, milliObj, scriptObj, secObj, v13 uintptr
	var i TTcl_Size
	var v1, v4, v5 bool
	var v10, v12, v8 int32
	var _ /* gran at bp+96 */ int32
	var _ /* index at bp+0 */ int32
	var _ /* key at bp+8 */ TScriptLimitCallbackKey
	var _ /* limitMoment at bp+104 */ TTcl_Time
	var _ /* limitMoment at bp+24 */ TTcl_Time
	var _ /* limitMoment at bp+40 */ TTcl_Time
	var _ /* limitMoment at bp+56 */ TTcl_Time
	var _ /* milliLen at bp+80 */ TTcl_Size
	var _ /* scriptLen at bp+72 */ TTcl_Size
	var _ /* secLen at bp+88 */ TTcl_Size
	var _ /* tmp at bp+120 */ TTcl_WideInt
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, dictPtr, empty, empty1, granObj, hPtr, i, iPtr, limitCBPtr, milliObj, scriptObj, secObj, v1, v10, v12, v13, v4, v5, v8
	iPtr = interp
	/*
	 * First, ensure that we are not reading or writing the calling
	 * interpreter's limits; it may only manipulate its children. Note that
	 * the low level API enforces this with Tcl_Panic, which we want to
	 * avoid. [Bug 3398794]
	 */
	if interp == childInterp {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+42537, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+136, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+40852, __ccgo_ts+42580, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if objc == consumedObjc {
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			dictPtr = XTclThreadAllocObj(tls)
		} else {
			dictPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(dictPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(dictPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(dictPtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(dictPtr)).FtypePtr = libc.UintptrFromInt32(0)
		(*(*TScriptLimitCallbackKey)(unsafe.Pointer(bp + 8))).Finterp = childInterp
		(*(*TScriptLimitCallbackKey)(unsafe.Pointer(bp + 8))).Ftype1 = int64(TCL_LIMIT_TIME)
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iPtr + 504 + 80)).FfindProc})))(tls, iPtr+504+80, bp+8)
		if !(hPtr != libc.UintptrFromInt32(0)) {
			goto _2
		}
		limitCBPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		if limitCBPtr != libc.UintptrFromInt32(0) && (*TScriptLimitCallback)(unsafe.Pointer(limitCBPtr)).FscriptObj != libc.UintptrFromInt32(0) {
			XTclDictPut(tls, libc.UintptrFromInt32(0), dictPtr, _options14[0], (*TScriptLimitCallback)(unsafe.Pointer(limitCBPtr)).FscriptObj)
		} else {
			goto putEmptyCommandInDict
		}
		goto _3
	_2:
		;
		goto putEmptyCommandInDict
	putEmptyCommandInDict:
		;
		if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			empty = XTclThreadAllocObj(tls)
		} else {
			empty = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(empty + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(empty)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(empty)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(empty)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(empty)).FtypePtr = libc.UintptrFromInt32(0)
		XTclDictPut(tls, libc.UintptrFromInt32(0), dictPtr, _options14[0], empty)
	_3:
		;
		XTclDictPut(tls, libc.UintptrFromInt32(0), dictPtr, _options14[int32(1)], XTcl_NewWideIntObj(tls, int64(XTcl_LimitGetGranularity(tls, childInterp, int32(TCL_LIMIT_TIME)))))
		if XTcl_LimitTypeEnabled(tls, childInterp, int32(TCL_LIMIT_TIME)) != 0 {
			XTcl_LimitGetTime(tls, childInterp, bp+24)
			XTclDictPut(tls, libc.UintptrFromInt32(0), dictPtr, _options14[int32(2)], XTcl_NewWideIntObj(tls, (*(*TTcl_Time)(unsafe.Pointer(bp + 24))).Fusec/int64(1000)))
			XTclDictPut(tls, libc.UintptrFromInt32(0), dictPtr, _options14[int32(3)], XTcl_NewWideIntObj(tls, (*(*TTcl_Time)(unsafe.Pointer(bp + 24))).Fsec))
		} else {
			if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
				cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v5 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
				empty1 = XTclThreadAllocObj(tls)
			} else {
				empty1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(empty1 + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(empty1)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(empty1)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(empty1)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(empty1)).FtypePtr = libc.UintptrFromInt32(0)
			XTclDictPut(tls, libc.UintptrFromInt32(0), dictPtr, _options14[int32(2)], empty1)
			XTclDictPut(tls, libc.UintptrFromInt32(0), dictPtr, _options14[int32(3)], empty1)
		}
		XTcl_SetObjResult(tls, interp, dictPtr)
		return TCL_OK
	} else {
		if objc == consumedObjc+int64(1) {
			if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(consumedObjc)*8)), uintptr(unsafe.Pointer(&_options14)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
				return int32(TCL_ERROR)
			}
			switch *(*int32)(unsafe.Pointer(bp)) {
			case 0:
				(*(*TScriptLimitCallbackKey)(unsafe.Pointer(bp + 8))).Finterp = childInterp
				(*(*TScriptLimitCallbackKey)(unsafe.Pointer(bp + 8))).Ftype1 = int64(TCL_LIMIT_TIME)
				hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iPtr + 504 + 80)).FfindProc})))(tls, iPtr+504+80, bp+8)
				if hPtr != libc.UintptrFromInt32(0) {
					limitCBPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
					if limitCBPtr != libc.UintptrFromInt32(0) && (*TScriptLimitCallback)(unsafe.Pointer(limitCBPtr)).FscriptObj != libc.UintptrFromInt32(0) {
						XTcl_SetObjResult(tls, interp, (*TScriptLimitCallback)(unsafe.Pointer(limitCBPtr)).FscriptObj)
					}
				}
			case 1:
				XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, int64(XTcl_LimitGetGranularity(tls, childInterp, int32(TCL_LIMIT_TIME)))))
			case 2:
				if XTcl_LimitTypeEnabled(tls, childInterp, int32(TCL_LIMIT_TIME)) != 0 {
					XTcl_LimitGetTime(tls, childInterp, bp+40)
					XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, (*(*TTcl_Time)(unsafe.Pointer(bp + 40))).Fusec/int64(1000)))
				}
			case 3:
				if XTcl_LimitTypeEnabled(tls, childInterp, int32(TCL_LIMIT_TIME)) != 0 {
					XTcl_LimitGetTime(tls, childInterp, bp+56)
					XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, (*(*TTcl_Time)(unsafe.Pointer(bp + 56))).Fsec))
				}
				break
			}
			return TCL_OK
		} else {
			if (objc-consumedObjc)&int64(1) != 0 {
				XTcl_WrongNumArgs(tls, interp, consumedObjc, objv, __ccgo_ts+42585)
				return int32(TCL_ERROR)
			} else {
				*(*TTcl_Size)(unsafe.Pointer(bp + 72)) = 0
				*(*TTcl_Size)(unsafe.Pointer(bp + 80)) = 0
				*(*TTcl_Size)(unsafe.Pointer(bp + 88)) = 0
				scriptObj = libc.UintptrFromInt32(0)
				granObj = libc.UintptrFromInt32(0)
				milliObj = libc.UintptrFromInt32(0)
				secObj = libc.UintptrFromInt32(0)
				*(*int32)(unsafe.Pointer(bp + 96)) = 0
				XTcl_LimitGetTime(tls, childInterp, bp+104)
				i = consumedObjc
				for {
					if !(i < objc) {
						break
					}
					if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_options14)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
						return int32(TCL_ERROR)
					}
					switch *(*int32)(unsafe.Pointer(bp)) {
					case 0:
						scriptObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8))
						if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).Fbytes != 0 {
							*(*TTcl_Size)(unsafe.Pointer(bp + 72)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).Flength
							_ = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).Fbytes
						} else {
							XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)), bp+72)
						}
					case 1:
						granObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8))
						if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
							*(*int32)(unsafe.Pointer(bp + 96)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).FinternalRep)))
							v8 = libc.Int32FromInt32(TCL_OK)
						} else {
							v8 = XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)), bp+96)
						}
						if v8 != TCL_OK {
							return int32(TCL_ERROR)
						}
						if *(*int32)(unsafe.Pointer(bp + 96)) < int32(1) {
							XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+42605, int64(-int32(1))))
							XTcl_SetErrorCode(tls, interp, libc.VaList(bp+136, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+40852, __ccgo_ts+42636, libc.UintptrFromInt32(0)))
							return int32(TCL_ERROR)
						}
					case 2:
						milliObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8))
						if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).Fbytes != 0 {
							*(*TTcl_Size)(unsafe.Pointer(bp + 80)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).Flength
							_ = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).Fbytes
						} else {
							XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)), bp+80)
						}
						if *(*TTcl_Size)(unsafe.Pointer(bp + 80)) == 0 {
							break
						}
						if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
							*(*TTcl_WideInt)(unsafe.Pointer(bp + 120)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).FinternalRep))
							v10 = libc.Int32FromInt32(TCL_OK)
						} else {
							v10 = XTcl_GetWideIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)), bp+120)
						}
						if v10 != TCL_OK {
							return int32(TCL_ERROR)
						}
						if *(*TTcl_WideInt)(unsafe.Pointer(bp + 120)) < 0 {
							XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+42693, int64(-int32(1))))
							XTcl_SetErrorCode(tls, interp, libc.VaList(bp+136, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+40852, __ccgo_ts+42636, libc.UintptrFromInt32(0)))
							return int32(TCL_ERROR)
						}
						(*(*TTcl_Time)(unsafe.Pointer(bp + 104))).Fusec = *(*TTcl_WideInt)(unsafe.Pointer(bp + 120)) * int64(1000)
					case 3:
						secObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8))
						if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).Fbytes != 0 {
							*(*TTcl_Size)(unsafe.Pointer(bp + 88)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).Flength
							_ = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).Fbytes
						} else {
							XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)), bp+88)
						}
						if *(*TTcl_Size)(unsafe.Pointer(bp + 88)) == 0 {
							break
						}
						if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
							*(*TTcl_WideInt)(unsafe.Pointer(bp + 120)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))).FinternalRep))
							v12 = libc.Int32FromInt32(TCL_OK)
						} else {
							v12 = XTcl_GetWideIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)), bp+120)
						}
						if v12 != TCL_OK {
							return int32(TCL_ERROR)
						}
						if *(*TTcl_WideInt)(unsafe.Pointer(bp + 120)) < 0 {
							XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+42727, int64(-int32(1))))
							XTcl_SetErrorCode(tls, interp, libc.VaList(bp+136, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+40852, __ccgo_ts+42636, libc.UintptrFromInt32(0)))
							return int32(TCL_ERROR)
						}
						(*(*TTcl_Time)(unsafe.Pointer(bp + 104))).Fsec = *(*TTcl_WideInt)(unsafe.Pointer(bp + 120))
						break
					}
					goto _6
				_6:
					;
					i += int64(2)
				}
				if milliObj != libc.UintptrFromInt32(0) || secObj != libc.UintptrFromInt32(0) {
					if milliObj != libc.UintptrFromInt32(0) {
						/*
						 * Setting -milliseconds but clearing -seconds, or resetting
						 * -milliseconds but not resetting -seconds? Bad voodoo!
						 */
						if secObj != libc.UintptrFromInt32(0) && *(*TTcl_Size)(unsafe.Pointer(bp + 88)) == 0 && *(*TTcl_Size)(unsafe.Pointer(bp + 80)) > 0 {
							XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+42756, int64(-int32(1))))
							XTcl_SetErrorCode(tls, interp, libc.VaList(bp+136, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+40852, __ccgo_ts+42819, libc.UintptrFromInt32(0)))
							return int32(TCL_ERROR)
						}
						if *(*TTcl_Size)(unsafe.Pointer(bp + 80)) == 0 && (secObj == libc.UintptrFromInt32(0) || *(*TTcl_Size)(unsafe.Pointer(bp + 88)) > 0) {
							XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+42828, int64(-int32(1))))
							XTcl_SetErrorCode(tls, interp, libc.VaList(bp+136, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+40852, __ccgo_ts+42819, libc.UintptrFromInt32(0)))
							return int32(TCL_ERROR)
						}
					}
					if *(*TTcl_Size)(unsafe.Pointer(bp + 80)) > 0 || *(*TTcl_Size)(unsafe.Pointer(bp + 88)) > 0 {
						/*
						 * Force usec to be in range [0..1000000), possibly
						 * incrementing sec in the process. This makes it much easier
						 * for people to write scripts that do small time increments.
						 */
						(*(*TTcl_Time)(unsafe.Pointer(bp + 104))).Fsec += (*(*TTcl_Time)(unsafe.Pointer(bp + 104))).Fusec / int64(1000000)
						(*(*TTcl_Time)(unsafe.Pointer(bp + 104))).Fusec %= int64(1000000)
						XTcl_LimitSetTime(tls, childInterp, bp+104)
						XTcl_LimitTypeSet(tls, childInterp, int32(TCL_LIMIT_TIME))
					} else {
						XTcl_LimitTypeReset(tls, childInterp, int32(TCL_LIMIT_TIME))
					}
				}
				if scriptObj != libc.UintptrFromInt32(0) {
					if *(*TTcl_Size)(unsafe.Pointer(bp + 72)) > 0 {
						v13 = scriptObj
					} else {
						v13 = libc.UintptrFromInt32(0)
					}
					_SetScriptLimitCallback(tls, interp, int32(TCL_LIMIT_TIME), childInterp, v13)
				}
				if granObj != libc.UintptrFromInt32(0) {
					XTcl_LimitSetGranularity(tls, childInterp, int32(TCL_LIMIT_TIME), *(*int32)(unsafe.Pointer(bp + 96)))
				}
				return TCL_OK
			}
		}
	}
	return r
}

var _options14 = [5]uintptr{
	0: __ccgo_ts + 18236,
	1: __ccgo_ts + 42517,
	2: __ccgo_ts + 13203,
	3: __ccgo_ts + 42684,
	4: libc.UintptrFromInt32(0),
}

const ENCODING_LINESIZE = 20
const MAX_CHANNEL_BUFFER_SIZE = 1048576
const TCL_PLATFORM_TRANSLATION1 = 2
const UTF_EXPANSION_FACTOR = 1024

/*
 * For each channel handler registered in a call to Tcl_CreateChannelHandler,
 * there is one record of the following type. All of records for a specific
 * channel are chained together in a singly linked list which is stored in
 * the channel structure.
 */

type TChannelHandler = struct {
	FchanPtr    uintptr
	Fmask       int32
	Fproc       uintptr
	FclientData uintptr
	FnextPtr    uintptr
}

/*
 * This structure keeps track of the current ChannelHandler being invoked in
 * the current invocation of Tcl_NotifyChannel. There is a potential
 * problem if a ChannelHandler is deleted while it is the current one, since
 * Tcl_NotifyChannel needs to look at the nextPtr field. To handle this
 * problem, structures of the type below indicate the next handler to be
 * processed for any (recursively nested) dispatches in progress. The
 * nextHandlerPtr field is updated if the handler being pointed to is deleted.
 * The nestedHandlerPtr field is used to chain together all recursive
 * invocations, so that Tcl_DeleteChannelHandler can find all the recursively
 * nested invocations of Tcl_NotifyChannel and compare the handler being
 * deleted against the NEXT handler to be invoked in that invocation; when it
 * finds such a situation, Tcl_DeleteChannelHandler updates the nextHandlerPtr
 * field of the structure to the next handler.
 */

type TNextChannelHandler = struct {
	FnextHandlerPtr   uintptr
	FnestedHandlerPtr uintptr
}

/*
 * The following structure is used by Tcl_GetsObj() to encapsulates the
 * state for a "gets" operation.
 */

type TGetsState = struct {
	FobjPtr     uintptr
	FdstPtr     uintptr
	Fencoding   TTcl_Encoding
	FbufPtr     uintptr
	Fstate      TTcl_EncodingState
	FrawRead    int32
	FbytesWrote int32
	FcharsWrote int32
	FtotalChars int32
}

/*
 * The following structure encapsulates the state for a background channel
 * copy.  Note that the data buffer for the copy will be appended to this
 * structure.
 */

type TCopyState = struct {
	FreadPtr    uintptr
	FwritePtr   uintptr
	FrefCount   int32
	FreadFlags  int32
	FwriteFlags int32
	FtoRead     TTcl_WideInt
	Ftotal      TTcl_WideInt
	Finterp     uintptr
	FcmdPtr     uintptr
	FbufSize    TTcl_Size
}

/*
 * All static variables used in this file are collected into a single instance
 * of the following structure. For multi-threaded implementations, there is
 * one instance of this structure for each thread.
 *
 * Notice that different structures with the same name appear in other files.
 * The structure defined below is used in this file only.
 */

type TThreadSpecificData3 = struct {
	FnestedHandlerPtr  uintptr
	FfirstCSPtr        uintptr
	FstdinChannel      TTcl_Channel
	FstdoutChannel     TTcl_Channel
	FstderrChannel     TTcl_Channel
	FbinaryEncoding    TTcl_Encoding
	FstdinInitialized  int32
	FstdoutInitialized int32
	FstderrInitialized int32
}

var _dataKey2 TTcl_ThreadDataKey

/*
 * Structure to record a close callback. One such record exists for
 * each close callback registered for a channel.
 */

type TCloseCallback = struct {
	Fproc       uintptr
	FclientData uintptr
	FnextPtr    uintptr
}

/*
 * Simplifying helper macros. All may use their argument(s) multiple times.
 * The ANSI C "prototypes" for the macros are listed below, together with a
 * short description of what the macro does.
 *
 * --------------------------------------------------------------------------
 * Tcl_Size BytesLeft(ChannelBuffer *bufPtr)
 *
 *	Returns the number of bytes of data remaining in the buffer.
 *
 * Tcl_Size SpaceLeft(ChannelBuffer *bufPtr)
 *
 *	Returns the number of bytes of space remaining at the end of the
 *	buffer.
 *
 * int IsBufferReady(ChannelBuffer *bufPtr)
 *
 *	Returns whether a buffer has bytes available within it.
 *
 * int IsBufferEmpty(ChannelBuffer *bufPtr)
 *
 *	Returns whether a buffer is entirely empty. Note that this is not the
 *	inverse of the above operation; trying to merge the two seems to lead
 *	to occasional crashes...
 *
 * int IsBufferFull(ChannelBuffer *bufPtr)
 *
 *	Returns whether more data can be added to a buffer.
 *
 * int IsBufferOverflowing(ChannelBuffer *bufPtr)
 *
 *	Returns whether a buffer has more data in it than it should.
 *
 * char *InsertPoint(ChannelBuffer *bufPtr)
 *
 *	Returns a pointer to where characters should be added to the buffer.
 *
 * char *RemovePoint(ChannelBuffer *bufPtr)
 *
 *	Returns a pointer to where characters should be removed from the
 *	buffer.
 * --------------------------------------------------------------------------
 */

/*
 * For working with channel state flag bits.
 */

/*
 * Macro for testing whether a string (in optionName, length len) matches a
 * value (prefix matching rules). Arguments are the minimum length to match
 * and the value to match against. (Can't use Tcl_GetIndexFromObj as this is
 * used in a situation where no objects are available.)
 */

/*
 * The ChannelObjType type.  Used to store the result of looking up
 * a channel name in the context of an interp.  Saves the lookup
 * result and values needed to check its continued validity.
 */

type TResolvedChanName = struct {
	FstatePtr uintptr
	Finterp   uintptr
	Fepoch    TTcl_Size
	FrefCount Tsize_t
}

var _chanObjType = TTcl_ObjType{
	Fname: __ccgo_ts + 42889,
}

func init() {
	p := unsafe.Pointer(&_chanObjType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_FreeChannelInternalRep)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_DupChannelInternalRep)
}

/*
 *---------------------------------------------------------------------------
 *
 * ChanClose, ChanRead, ChanSeek, ChanThreadAction, ChanWatch, ChanWrite --
 *
 *	Simplify the access to selected channel driver "methods" that are used
 *	in multiple places in a stereotypical fashion. These are just thin
 *	wrappers around the driver functions.
 *
 *---------------------------------------------------------------------------
 */

func _ChanClose(tls *libc.TLS, chanPtr uintptr, interp uintptr) (r int32) {
	return (*(*func(*libc.TLS, uintptr, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ChannelType)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr)).Fclose2Proc})))(tls, (*TChannel)(unsafe.Pointer(chanPtr)).FinstanceData, interp, 0)
}

// C documentation
//
//	/*
//	 *---------------------------------------------------------------------------
//	 *
//	 * ChanRead --
//	 *
//	 *	Read up to dstSize bytes using the inputProc of chanPtr, store them at
//	 *	dst, and return the number of bytes stored.
//	 *
//	 * Results:
//	 *	The return value of the driver inputProc,
//	 *	  - number of bytes stored at dst, ot
//	 *	  - -1 on error, with a Posix error code available to the caller by
//	 *	    calling Tcl_GetErrno().
//	 *
//	 * Side effects:
//	 *	The CHANNEL_ENCODING_ERROR, CHANNEL_BLOCKED and CHANNEL_EOF flags
//	 *	of the channel state are set as appropriate.  On EOF, the
//	 *	inputEncodingFlags are set to perform ending operations on decoding.
//	 *
//	 *	TODO - Is this really the right place for that?
//	 *
//	 *---------------------------------------------------------------------------
//	 */
func _ChanRead(tls *libc.TLS, chanPtr uintptr, dst uintptr, dstSize int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var bytesRead int32
	var _ /* result at bp+0 */ int32
	_ = bytesRead
	/*
	 * If the caller asked for zero bytes, we'd force the inputProc to return
	 * zero bytes, and then misinterpret that as EOF.
	 */
	/*
	 * Each read op must set the blocked and eof states anew, not let
	 * the effect of prior reads leak through.
	 */
	if (*TChannelState1)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).Fstate)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(9)) != 0 {
		*(*int32)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).Fstate + 32)) |= int32(TCL_ENCODING_START)
	}
	*(*int32)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).Fstate + 8)) &= ^(libc.Int32FromInt32(1)<<libc.Int32FromInt32(11) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(9))
	*(*int32)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).Fstate + 32)) &= ^libc.Int32FromInt32(TCL_ENCODING_END)
	if _WillRead(tls, chanPtr) == -int32(1) {
		return -int32(1)
	}
	bytesRead = (*(*func(*libc.TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ChannelType)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr)).FinputProc})))(tls, (*TChannel)(unsafe.Pointer(chanPtr)).FinstanceData, dst, dstSize, bp)
	/*
	 * Stop any flag leakage through stacked channel levels.
	 */
	if (*TChannelState1)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).Fstate)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(9)) != 0 {
		*(*int32)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).Fstate + 32)) |= int32(TCL_ENCODING_START)
	}
	*(*int32)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).Fstate + 8)) &= ^(libc.Int32FromInt32(1)<<libc.Int32FromInt32(11) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(9))
	*(*int32)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).Fstate + 32)) &= ^libc.Int32FromInt32(TCL_ENCODING_END)
	if bytesRead == -int32(1) {
		if *(*int32)(unsafe.Pointer(bp)) == int32(EAGAIN) {
			*(*int32)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).Fstate + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(11)
			*(*int32)(unsafe.Pointer(bp)) = int32(EAGAIN)
		}
		XTcl_SetErrno(tls, *(*int32)(unsafe.Pointer(bp)))
	} else {
		if bytesRead == 0 {
			*(*int32)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).Fstate + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(9)
			*(*int32)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).Fstate + 32)) |= int32(TCL_ENCODING_END)
		} else {
			/*
			 * If we get a short read, signal up that we may be BLOCKED. We should
			 * avoid calling the driver because on some platforms we will block in
			 * the low level reading code even though the channel is set into
			 * nonblocking mode.
			 */
			if bytesRead < dstSize {
				*(*int32)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).Fstate + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(11)
			}
		}
	}
	return bytesRead
}

func _ChanSeek(tls *libc.TLS, chanPtr uintptr, offset TTcl_WideInt, mode int32, errnoPtr uintptr) (r TTcl_WideInt) {
	/*
	 * Note that we prefer the wideSeekProc if that field is available in the
	 * type and non-NULL.
	 */
	if XTcl_ChannelWideSeekProc(tls, (*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr) == libc.UintptrFromInt32(0) {
		*(*int32)(unsafe.Pointer(errnoPtr)) = int32(EINVAL)
		return int64(-libc.Int32FromInt32(1))
	}
	return (*(*func(*libc.TLS, uintptr, int64, int32, uintptr) int64)(unsafe.Pointer(&struct{ uintptr }{XTcl_ChannelWideSeekProc(tls, (*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr)})))(tls, (*TChannel)(unsafe.Pointer(chanPtr)).FinstanceData, offset, mode, errnoPtr)
}

func _ChanThreadAction(tls *libc.TLS, chanPtr uintptr, action int32) {
	var threadActionProc uintptr
	_ = threadActionProc
	threadActionProc = XTcl_ChannelThreadActionProc(tls, (*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr)
	if threadActionProc != libc.UintptrFromInt32(0) {
		(*(*func(*libc.TLS, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{threadActionProc})))(tls, (*TChannel)(unsafe.Pointer(chanPtr)).FinstanceData, action)
	}
}

func _ChanWatch(tls *libc.TLS, chanPtr uintptr, mask int32) {
	(*(*func(*libc.TLS, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ChannelType)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr)).FwatchProc})))(tls, (*TChannel)(unsafe.Pointer(chanPtr)).FinstanceData, mask)
}

func _ChanWrite(tls *libc.TLS, chanPtr uintptr, src uintptr, srcLen int32, errnoPtr uintptr) (r int32) {
	return (*(*func(*libc.TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ChannelType)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr)).FoutputProc})))(tls, (*TChannel)(unsafe.Pointer(chanPtr)).FinstanceData, src, srcLen, errnoPtr)
}

/*
 *---------------------------------------------------------------------------
 *
 * TclInitIOSubsystem --
 *
 *	Initialize all resources used by this subsystem on a per-process
 *	basis.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Depends on the memory subsystems.
 *
 *---------------------------------------------------------------------------
 */

func XTclInitIOSubsystem(tls *libc.TLS) {
	/*
	 * By fetching thread local storage we take care of allocating it for each
	 * thread.
	 */
	XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey2)), int64(64))
}

/*
 *-------------------------------------------------------------------------
 *
 * TclFinalizeIOSubsystem --
 *
 *	Releases all resources used by this subsystem on a per-process basis.
 *	Closes all extant channels that have not already been closed because
 *	they were not owned by any interp.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Depends on encoding and memory subsystems.
 *
 *-------------------------------------------------------------------------
 */

func XTclFinalizeIOSubsystem(tls *libc.TLS) {
	bp := tls.Alloc(224)
	defer tls.Free(224)
	var active, doflushnb int32
	var chanPtr, s, statePtr, tsdPtr uintptr
	var _ /* ds at bp+0 */ TTcl_DString
	_, _, _, _, _, _ = active, chanPtr, doflushnb, s, statePtr, tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey2)), int64(64))
	chanPtr = libc.UintptrFromInt32(0) /* State of channel stack */
	active = int32(1)
	/*
	 * Fetch the pre-TIP#398 compatibility flag.
	 */
	s = XTclGetEnv(tls, __ccgo_ts+42897, bp)
	doflushnb = libc.BoolInt32(s != libc.UintptrFromInt32(0) && libc.Xstrcmp(tls, s, __ccgo_ts+14828) != 0)
	if s != libc.UintptrFromInt32(0) {
		XTcl_DStringFree(tls, bp)
	}
	/*
	 * Walk all channel state structures known to this thread and close
	 * corresponding channels.
	 */
	for active != 0 {
		/*
		 * Iterate through the open channel list, and find the first channel
		 * that isn't dead. We start from the head of the list each time,
		 * because the close action on one channel can close others.
		 */
		active = 0
		statePtr = (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FfirstCSPtr
		for {
			if !(statePtr != libc.UintptrFromInt32(0)) {
				break
			}
			chanPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr
			if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(13)) != 0 {
				goto _1
			}
			if !((*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(19)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(8)) != 0) || (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(7)) != 0 {
				*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(7))
				active = int32(1)
				break
			}
			goto _1
		_1:
			;
			statePtr = (*TChannelState)(unsafe.Pointer(statePtr)).FnextCSPtr
		}
		/*
		 * We've found a live (or bg-closing) channel. Close it.
		 */
		if active != 0 {
			XTclChannelPreserve(tls, chanPtr)
			/*
			 * TIP #398: by default, we no longer set the channel back into
			 * blocking mode.  To restore the old blocking behavior, the
			 * environment variable TCL_FLUSH_NONBLOCKING_ON_EXIT must be set
			 * and not be "0".
			 */
			if doflushnb != 0 {
				/*
				 * Set the channel back into blocking mode to ensure that we
				 * wait for all data to flush out.
				 */
				XTcl_SetChannelOption(tls, libc.UintptrFromInt32(0), chanPtr, __ccgo_ts+42927, __ccgo_ts+20802)
			}
			if chanPtr == (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdinChannel || chanPtr == (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdoutChannel || chanPtr == (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstderrChannel {
				/*
				 * Decrement the refcount which was earlier artificially
				 * bumped up to keep the channel from being closed.
				 */
				(*TChannelState)(unsafe.Pointer(statePtr)).FrefCount--
			}
			if (*TChannelState)(unsafe.Pointer(statePtr)).FrefCount <= 0 {
				/*
				 * Close it only if the refcount indicates that the channel is
				 * not referenced from any interpreter. If it is, that
				 * interpreter will close the channel when it gets destroyed.
				 */
				XTcl_CloseEx(tls, libc.UintptrFromInt32(0), chanPtr, 0)
			} else {
				/*
				 * The refcount is greater than zero, so flush the channel.
				 */
				XTcl_Flush(tls, chanPtr)
				/*
				 * Call the device driver to actually close the underlying
				 * device for this channel.
				 */
				_ChanClose(tls, chanPtr, libc.UintptrFromInt32(0))
				/*
				 * Finally, we clean up the fields in the channel data
				 * structure since all of them have been deleted already. We
				 * mark the channel with CHANNEL_DEAD to prevent any further
				 * IO operations on it.
				 */
				(*TChannel)(unsafe.Pointer(chanPtr)).FinstanceData = libc.UintptrFromInt32(0)
				*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(13)
			}
			XTclChannelRelease(tls, chanPtr)
		}
	}
	_FreeBinaryEncoding(tls)
	XTclpFinalizeSockets(tls)
	XTclpFinalizePipes(tls)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetStdChannel --
 *
 *	This function is used to change the channels that are used for
 *	stdin/stdout/stderr in new interpreters.
 *
 * Results:
 *	None
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetStdChannel(tls *libc.TLS, channel TTcl_Channel, type1 int32) {
	/* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR. */
	var init1, v1 int32
	var tsdPtr, p2, p3, p4, p5 uintptr
	_, _, _, _, _, _, _ = init1, tsdPtr, v1, p2, p3, p4, p5
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey2)), int64(64))
	if channel != 0 {
		v1 = int32(1)
	} else {
		v1 = -int32(1)
	}
	init1 = v1
	switch type1 {
	case libc.Int32FromInt32(1) << libc.Int32FromInt32(1):
		(*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdinInitialized = init1
		(*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdinChannel = channel
	case libc.Int32FromInt32(1) << libc.Int32FromInt32(2):
		(*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdoutInitialized = init1
		(*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdoutChannel = channel
	case libc.Int32FromInt32(1) << libc.Int32FromInt32(3):
		(*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstderrInitialized = init1
		(*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstderrChannel = channel
		if channel != 0 {
			p2 = (*TChannel)(unsafe.Pointer(channel)).Fstate + 32
			*(*int32)(unsafe.Pointer(p2)) = int32(uint32(*(*int32)(unsafe.Pointer(p2))) & ^libc.Uint32FromUint32(ENCODING_PROFILE_MASK))
			p3 = (*TChannel)(unsafe.Pointer(channel)).Fstate + 32
			*(*int32)(unsafe.Pointer(p3)) = int32(uint32(*(*int32)(unsafe.Pointer(p3))) | libc.Uint32FromInt32(libc.Int32FromInt32(TCL_ENCODING_PROFILE_REPLACE))&libc.Uint32FromUint32(ENCODING_PROFILE_MASK))
			p4 = (*TChannel)(unsafe.Pointer(channel)).Fstate + 48
			*(*int32)(unsafe.Pointer(p4)) = int32(uint32(*(*int32)(unsafe.Pointer(p4))) & ^libc.Uint32FromUint32(ENCODING_PROFILE_MASK))
			p5 = (*TChannel)(unsafe.Pointer(channel)).Fstate + 48
			*(*int32)(unsafe.Pointer(p5)) = int32(uint32(*(*int32)(unsafe.Pointer(p5))) | libc.Uint32FromInt32(libc.Int32FromInt32(TCL_ENCODING_PROFILE_REPLACE))&libc.Uint32FromUint32(ENCODING_PROFILE_MASK))
		}
		break
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetStdChannel --
 *
 *	Returns the specified standard channel.
 *
 * Results:
 *	Returns the specified standard channel, or NULL.
 *
 * Side effects:
 *	May cause the creation of a standard channel and the underlying file.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetStdChannel(tls *libc.TLS, type1 int32) (r TTcl_Channel) {
	/* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR. */
	var channel TTcl_Channel
	var tsdPtr, p1, p2, p3, p4 uintptr
	_, _, _, _, _, _ = channel, tsdPtr, p1, p2, p3, p4
	channel = libc.UintptrFromInt32(0)
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey2)), int64(64))
	/*
	 * If the channels were not created yet, create them now and store them in
	 * the static variables.
	 */
	switch type1 {
	case libc.Int32FromInt32(1) << libc.Int32FromInt32(1):
		if !((*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdinInitialized != 0) {
			(*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdinInitialized = -int32(1)
			(*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdinChannel = XTclpGetDefaultStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1))
			/*
			 * Artificially bump the refcount to ensure that the channel is
			 * only closed on exit.
			 *
			 * NOTE: Must only do this if stdinChannel is not NULL. It can be
			 * NULL in situations where Tcl is unable to connect to the
			 * standard input.
			 */
			if (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdinChannel != libc.UintptrFromInt32(0) {
				(*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdinInitialized = int32(1)
				XTcl_RegisterChannel(tls, libc.UintptrFromInt32(0), (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdinChannel)
			}
		}
		channel = (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdinChannel
	case libc.Int32FromInt32(1) << libc.Int32FromInt32(2):
		if !((*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdoutInitialized != 0) {
			(*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdoutInitialized = -int32(1)
			(*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdoutChannel = XTclpGetDefaultStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2))
			if (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdoutChannel != libc.UintptrFromInt32(0) {
				(*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdoutInitialized = int32(1)
				XTcl_RegisterChannel(tls, libc.UintptrFromInt32(0), (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdoutChannel)
			}
		}
		channel = (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdoutChannel
	case libc.Int32FromInt32(1) << libc.Int32FromInt32(3):
		if !((*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstderrInitialized != 0) {
			(*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstderrInitialized = -int32(1)
			(*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstderrChannel = XTclpGetDefaultStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(3))
			if (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstderrChannel != libc.UintptrFromInt32(0) {
				p1 = (*TChannel)(unsafe.Pointer((*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstderrChannel)).Fstate + 32
				*(*int32)(unsafe.Pointer(p1)) = int32(uint32(*(*int32)(unsafe.Pointer(p1))) & ^libc.Uint32FromUint32(ENCODING_PROFILE_MASK))
				p2 = (*TChannel)(unsafe.Pointer((*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstderrChannel)).Fstate + 32
				*(*int32)(unsafe.Pointer(p2)) = int32(uint32(*(*int32)(unsafe.Pointer(p2))) | libc.Uint32FromInt32(libc.Int32FromInt32(TCL_ENCODING_PROFILE_REPLACE))&libc.Uint32FromUint32(ENCODING_PROFILE_MASK))
				p3 = (*TChannel)(unsafe.Pointer((*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstderrChannel)).Fstate + 48
				*(*int32)(unsafe.Pointer(p3)) = int32(uint32(*(*int32)(unsafe.Pointer(p3))) & ^libc.Uint32FromUint32(ENCODING_PROFILE_MASK))
				p4 = (*TChannel)(unsafe.Pointer((*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstderrChannel)).Fstate + 48
				*(*int32)(unsafe.Pointer(p4)) = int32(uint32(*(*int32)(unsafe.Pointer(p4))) | libc.Uint32FromInt32(libc.Int32FromInt32(TCL_ENCODING_PROFILE_REPLACE))&libc.Uint32FromUint32(ENCODING_PROFILE_MASK))
				(*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstderrInitialized = int32(1)
				XTcl_RegisterChannel(tls, libc.UintptrFromInt32(0), (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstderrChannel)
			}
		}
		channel = (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstderrChannel
		break
	}
	return channel
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_CreateCloseHandler
 *
 *	Creates a close callback which will be called when the channel is
 *	closed.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Causes the callback to be called in the future when the channel will
 *	be closed.
 *
 *----------------------------------------------------------------------
 */

func XTcl_CreateCloseHandler(tls *libc.TLS, chan1 TTcl_Channel, proc uintptr, clientData uintptr) {
	/* Arbitrary data to pass to the close
	 * callback. */
	var cbPtr, statePtr uintptr
	_, _ = cbPtr, statePtr
	statePtr = (*TChannel)(unsafe.Pointer(chan1)).Fstate
	cbPtr = XTcl_Alloc(tls, uint64(24))
	(*TCloseCallback)(unsafe.Pointer(cbPtr)).Fproc = proc
	(*TCloseCallback)(unsafe.Pointer(cbPtr)).FclientData = clientData
	(*TCloseCallback)(unsafe.Pointer(cbPtr)).FnextPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FcloseCbPtr
	(*TChannelState)(unsafe.Pointer(statePtr)).FcloseCbPtr = cbPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DeleteCloseHandler --
 *
 *	Removes a callback that would have been called on closing the channel.
 *	If there is no matching callback then this function has no effect.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The callback will not be called in the future when the channel is
 *	eventually closed.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DeleteCloseHandler(tls *libc.TLS, chan1 TTcl_Channel, proc uintptr, clientData uintptr) {
	/* The callback data for the callback to
	 * remove. */
	var cbPrevPtr, cbPtr, statePtr uintptr
	_, _, _ = cbPrevPtr, cbPtr, statePtr
	statePtr = (*TChannel)(unsafe.Pointer(chan1)).Fstate
	cbPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FcloseCbPtr
	cbPrevPtr = libc.UintptrFromInt32(0)
	for {
		if !(cbPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TCloseCallback)(unsafe.Pointer(cbPtr)).Fproc == proc && (*TCloseCallback)(unsafe.Pointer(cbPtr)).FclientData == clientData {
			if cbPrevPtr == libc.UintptrFromInt32(0) {
				(*TChannelState)(unsafe.Pointer(statePtr)).FcloseCbPtr = (*TCloseCallback)(unsafe.Pointer(cbPtr)).FnextPtr
			} else {
				(*TCloseCallback)(unsafe.Pointer(cbPrevPtr)).FnextPtr = (*TCloseCallback)(unsafe.Pointer(cbPtr)).FnextPtr
			}
			XTclpFree(tls, cbPtr)
			break
		}
		cbPrevPtr = cbPtr
		goto _1
	_1:
		;
		cbPtr = (*TCloseCallback)(unsafe.Pointer(cbPtr)).FnextPtr
	}
}

/*
 *----------------------------------------------------------------------
 *
 * GetChannelTable --
 *
 *	Gets and potentially initializes the channel table for an interpreter.
 *	If it is initializing the table it also inserts channels for stdin,
 *	stdout and stderr if the interpreter is trusted.
 *
 * Results:
 *	A pointer to the hash table created, for use by the caller.
 *
 * Side effects:
 *	Initializes the channel table for an interpreter. May create channels
 *	for stdin, stdout and stderr.
 *
 *----------------------------------------------------------------------
 */

func _GetChannelTable(tls *libc.TLS, interp uintptr) (r uintptr) {
	var hTblPtr uintptr
	var stderrChan, stdinChan, stdoutChan TTcl_Channel
	_, _, _, _ = hTblPtr, stderrChan, stdinChan, stdoutChan
	hTblPtr = XTcl_GetAssocData(tls, interp, __ccgo_ts+42937, libc.UintptrFromInt32(0))
	if hTblPtr == libc.UintptrFromInt32(0) {
		hTblPtr = XTcl_Alloc(tls, uint64(104))
		XTcl_InitHashTable(tls, hTblPtr, TCL_STRING_KEYS)
		XTcl_SetAssocData(tls, interp, __ccgo_ts+42937, __ccgo_fp(_DeleteChannelTable), hTblPtr)
		/*
		 * If the interpreter is trusted (not "safe"), insert channels for
		 * stdin, stdout and stderr (possibly creating them in the process).
		 */
		if XTcl_IsSafe(tls, interp) == 0 {
			stdinChan = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1))
			if stdinChan != libc.UintptrFromInt32(0) {
				XTcl_RegisterChannel(tls, interp, stdinChan)
			}
			stdoutChan = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2))
			if stdoutChan != libc.UintptrFromInt32(0) {
				XTcl_RegisterChannel(tls, interp, stdoutChan)
			}
			stderrChan = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(3))
			if stderrChan != libc.UintptrFromInt32(0) {
				XTcl_RegisterChannel(tls, interp, stderrChan)
			}
		}
	}
	return hTblPtr
}

/*
 *----------------------------------------------------------------------
 *
 * DeleteChannelTable --
 *
 *	Deletes the channel table for an interpreter, closing any open
 *	channels whose refcount reaches zero. This procedure is invoked when
 *	an interpreter is deleted, via the AssocData cleanup mechanism.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Deletes the hash table of channels. May close channels. May flush
 *	output on closed channels. Removes any channelEvent handlers that were
 *	registered in this interpreter.
 *
 *----------------------------------------------------------------------
 */

func _DeleteChannelTable(tls *libc.TLS, clientData uintptr, interp uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* The interpreter being deleted. */
	var cachePtr, chanPtr, hPtr, hTblPtr, nextPtr, prevPtr, sPtr, statePtr, v4, v7 uintptr
	var v3, v6 TTcl_Size
	var v5 bool
	var _ /* hSearch at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, chanPtr, hPtr, hTblPtr, nextPtr, prevPtr, sPtr, statePtr, v3, v4, v5, v6, v7
	/* Variables to loop over all channel events
	 * registered, to delete the ones that refer
	 * to the interpreter being deleted. */
	/*
	 * Delete all the registered channels - this will close channels whose
	 * refcount reaches zero.
	 */
	hTblPtr = clientData
	hPtr = XTcl_FirstHashEntry(tls, hTblPtr, bp)
	for {
		if !(hPtr != libc.UintptrFromInt32(0)) {
			break
		}
		chanPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
		/*
		 * Remove any file events registered in this interpreter.
		 */
		sPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FscriptRecordPtr
		prevPtr = libc.UintptrFromInt32(0)
		for {
			if !(sPtr != libc.UintptrFromInt32(0)) {
				break
			}
			nextPtr = (*TEventScriptRecord)(unsafe.Pointer(sPtr)).FnextPtr
			if (*TEventScriptRecord)(unsafe.Pointer(sPtr)).Finterp == interp {
				if prevPtr == libc.UintptrFromInt32(0) {
					(*TChannelState)(unsafe.Pointer(statePtr)).FscriptRecordPtr = nextPtr
				} else {
					(*TEventScriptRecord)(unsafe.Pointer(prevPtr)).FnextPtr = nextPtr
				}
				XTcl_DeleteChannelHandler(tls, chanPtr, __ccgo_fp(XTclChannelEventScriptInvoker), sPtr)
				v4 = (*TEventScriptRecord)(unsafe.Pointer(sPtr)).FscriptPtr
				v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
				*(*TTcl_Size)(unsafe.Pointer(v4))--
				if !(v3 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(sPtr)).FscriptPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(sPtr)).FscriptPtr)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(sPtr)).FscriptPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(sPtr)).FscriptPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(sPtr)).FscriptPtr)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(sPtr)).FscriptPtr)).Flength = int64(-libc.Int32FromInt32(1))
						if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
							cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v5 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, (*TEventScriptRecord)(unsafe.Pointer(sPtr)).FscriptPtr)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(sPtr)).FscriptPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*TEventScriptRecord)(unsafe.Pointer(sPtr)).FscriptPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, (*TEventScriptRecord)(unsafe.Pointer(sPtr)).FscriptPtr)
					}
				}
				XTclpFree(tls, sPtr)
			} else {
				prevPtr = sPtr
			}
			goto _2
		_2:
			;
			sPtr = nextPtr
		}
		/*
		 * Cannot call Tcl_UnregisterChannel because that procedure calls
		 * Tcl_GetAssocData to get the channel table, which might already be
		 * inaccessible from the interpreter structure. Instead, we emulate
		 * the behavior of Tcl_UnregisterChannel directly here.
		 */
		XTcl_DeleteHashEntry(tls, hPtr)
		(*TChannelState)(unsafe.Pointer(statePtr)).Fepoch++
		v7 = statePtr + 72
		v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
		*(*TTcl_Size)(unsafe.Pointer(v7))--
		if v6 <= int64(1) {
			if !((*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(7)) != 0) {
				XTcl_CloseEx(tls, interp, chanPtr, 0)
			}
		}
		goto _1
	_1:
		;
		hPtr = XTcl_FirstHashEntry(tls, hTblPtr, bp)
	}
	XTcl_DeleteHashTable(tls, hTblPtr)
	XTclpFree(tls, hTblPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * CheckForStdChannelsBeingClosed --
 *
 *	Perform special handling for standard channels being closed. When
 *	given a standard channel, if the refcount is now 1, it means that the
 *	last reference to the standard channel is being explicitly closed. Now
 *	bump the refcount artificially down to 0, to ensure the normal
 *	handling of channels being closed will occur. Also reset the static
 *	pointer to the channel to NULL, to avoid dangling references.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Manipulates the refcount on standard channels. May smash the global
 *	static pointer to a standard channel.
 *
 *----------------------------------------------------------------------
 */

func _CheckForStdChannelsBeingClosed(tls *libc.TLS, chan1 TTcl_Channel) {
	var statePtr, tsdPtr uintptr
	_, _ = statePtr, tsdPtr
	statePtr = (*TChannel)(unsafe.Pointer(chan1)).Fstate
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey2)), int64(64))
	if (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdinInitialized == int32(1) && (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdinChannel != libc.UintptrFromInt32(0) && statePtr == (*TChannel)(unsafe.Pointer((*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdinChannel)).Fstate {
		if (*TChannelState)(unsafe.Pointer(statePtr)).FrefCount < int64(2) {
			(*TChannelState)(unsafe.Pointer(statePtr)).FrefCount = 0
			(*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdinChannel = libc.UintptrFromInt32(0)
			return
		}
	} else {
		if (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdoutInitialized == int32(1) && (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdoutChannel != libc.UintptrFromInt32(0) && statePtr == (*TChannel)(unsafe.Pointer((*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdoutChannel)).Fstate {
			if (*TChannelState)(unsafe.Pointer(statePtr)).FrefCount < int64(2) {
				(*TChannelState)(unsafe.Pointer(statePtr)).FrefCount = 0
				(*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdoutChannel = libc.UintptrFromInt32(0)
				return
			}
		} else {
			if (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstderrInitialized == int32(1) && (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstderrChannel != libc.UintptrFromInt32(0) && statePtr == (*TChannel)(unsafe.Pointer((*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstderrChannel)).Fstate {
				if (*TChannelState)(unsafe.Pointer(statePtr)).FrefCount < int64(2) {
					(*TChannelState)(unsafe.Pointer(statePtr)).FrefCount = 0
					(*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstderrChannel = libc.UintptrFromInt32(0)
					return
				}
			}
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_IsStandardChannel --
 *
 *	Test if the given channel is a standard channel. No attempt is made to
 *	check if the channel or the standard channels are initialized or
 *	otherwise valid.
 *
 * Results:
 *	Returns 1 if true, 0 if false.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_IsStandardChannel(tls *libc.TLS, chan1 TTcl_Channel) (r int32) {
	/* Channel to check. */
	var tsdPtr uintptr
	_ = tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey2)), int64(64))
	if chan1 == (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdinChannel || chan1 == (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdoutChannel || chan1 == (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstderrChannel {
		return int32(1)
	} else {
		return 0
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_RegisterChannel --
 *
 *	Adds an already-open channel to the channel table of an interpreter.
 *	If the interpreter passed as argument is NULL, it only increments the
 *	channel refCount.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	May increment the reference count of a channel.
 *
 *----------------------------------------------------------------------
 */

func XTcl_RegisterChannel(tls *libc.TLS, interp uintptr, chan1 TTcl_Channel) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The channel to add to this interpreter
	 * channel table. */
	var chanPtr, hPtr, hTblPtr, statePtr uintptr
	var _ /* isNew at bp+0 */ int32
	_, _, _, _ = chanPtr, hPtr, hTblPtr, statePtr /* State of the actual channel. */
	/*
	 * Always (un)register bottom-most channel in the stack. This makes
	 * management of the channel list easier because no manipulation is
	 * necessary during (un)stack operation.
	 */
	chanPtr = (*TChannelState1)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chan1)).Fstate)).FbottomChanPtr
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	if (*TChannelState)(unsafe.Pointer(statePtr)).FchannelName == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+42943, 0)
	}
	if interp != libc.UintptrFromInt32(0) {
		hTblPtr = _GetChannelTable(tls, interp)
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(hTblPtr)).FcreateProc})))(tls, hTblPtr, (*TChannelState)(unsafe.Pointer(statePtr)).FchannelName, bp)
		if !(*(*int32)(unsafe.Pointer(bp)) != 0) {
			if chan1 == (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData {
				return
			}
			XTcl_Panic(tls, __ccgo_ts+42985, 0)
		}
		(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = chanPtr
	}
	(*TChannelState)(unsafe.Pointer(statePtr)).FrefCount++
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UnregisterChannel --
 *
 *	Deletes the hash entry for a channel associated with an interpreter.
 *	If the interpreter given as argument is NULL, it only decrements the
 *	reference count. (This all happens in the Tcl_DetachChannel helper
 *	function).
 *
 *	Finally, if the reference count of the channel drops to zero, it is
 *	deleted.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Calls Tcl_DetachChannel which deletes the hash entry for a channel
 *	associated with an interpreter.
 *
 *	May delete the channel, which can have a variety of consequences,
 *	especially if we are forced to close the channel.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UnregisterChannel(tls *libc.TLS, interp uintptr, chan1 TTcl_Channel) (r int32) {
	/* Channel to delete. */
	var statePtr uintptr
	_ = statePtr /* State of the real channel. */
	statePtr = (*TChannel)(unsafe.Pointer((*TChannelState1)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chan1)).Fstate)).FbottomChanPtr)).Fstate
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(19)) != 0 {
		if interp != libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+43030, int64(-int32(1))))
		}
		return int32(TCL_ERROR)
	}
	if _DetachChannel(tls, interp, chan1) != TCL_OK {
		return TCL_OK
	}
	statePtr = (*TChannel)(unsafe.Pointer((*TChannelState1)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chan1)).Fstate)).FbottomChanPtr)).Fstate
	/*
	 * Perform special handling for standard channels being closed. If the
	 * refCount is now 1 it means that the last reference to the standard
	 * channel is being explicitly closed, so bump the refCount down
	 * artificially to 0. This will ensure that the channel is actually
	 * closed, below. Also set the static pointer to NULL for the channel.
	 */
	_CheckForStdChannelsBeingClosed(tls, chan1)
	/*
	 * If the refCount reached zero, close the actual channel.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).FrefCount <= 0 {
		XTcl_Preserve(tls, statePtr)
		if !((*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(7)) != 0) {
			/*
			 * We don't want to re-enter Tcl_CloseEx().
			 */
			if !((*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(8)) != 0) {
				if XTcl_CloseEx(tls, interp, chan1, 0) != TCL_OK {
					*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(8)
					XTcl_Release(tls, statePtr)
					return int32(TCL_ERROR)
				}
			}
		}
		*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(8)
		XTcl_Release(tls, statePtr)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DetachChannel --
 *
 *	Deletes the hash entry for a channel associated with an interpreter.
 *	If the interpreter given as argument is NULL, it only decrements the
 *	reference count. Even if the ref count drops to zero, the channel is
 *	NOT closed or cleaned up. This allows a channel to be detached from an
 *	interpreter and left in the same state it was in when it was
 *	originally returned by 'Tcl_OpenFileChannel', for example.
 *
 *	This function cannot be used on the standard channels, and will return
 *	TCL_ERROR if that is attempted.
 *
 *	This function should only be necessary for special purposes in which
 *	you need to generate a pristine channel from one that has already been
 *	used. All ordinary purposes will almost always want to use
 *	Tcl_UnregisterChannel instead.
 *
 *	Provided the channel is not attached to any other interpreter, it can
 *	then be closed with Tcl_Close, rather than with Tcl_UnregisterChannel.
 *
 * Results:
 *	A standard Tcl result. If the channel is not currently registered with
 *	the given interpreter, TCL_ERROR is returned, otherwise TCL_OK.
 *	However no error messages are left in the interp's result.
 *
 * Side effects:
 *	Deletes the hash entry for a channel associated with an interpreter.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DetachChannel(tls *libc.TLS, interp uintptr, chan1 TTcl_Channel) (r int32) {
	/* Channel to delete. */
	if XTcl_IsStandardChannel(tls, chan1) != 0 {
		return int32(TCL_ERROR)
	}
	return _DetachChannel(tls, interp, chan1)
}

/*
 *----------------------------------------------------------------------
 *
 * DetachChannel --
 *
 *	Deletes the hash entry for a channel associated with an interpreter.
 *	If the interpreter given as argument is NULL, it only decrements the
 *	reference count. Even if the ref count drops to zero, the channel is
 *	NOT closed or cleaned up. This allows a channel to be detached from an
 *	interpreter and left in the same state it was in when it was
 *	originally returned by 'Tcl_OpenFileChannel', for example.
 *
 * Results:
 *	A standard Tcl result. If the channel is not currently registered with
 *	the given interpreter, TCL_ERROR is returned, otherwise TCL_OK.
 *	However no error messages are left in the interp's result.
 *
 * Side effects:
 *	Deletes the hash entry for a channel associated with an interpreter.
 *
 *----------------------------------------------------------------------
 */

func _DetachChannel(tls *libc.TLS, interp uintptr, chan1 TTcl_Channel) (r int32) {
	/* Channel to delete. */
	var chanPtr, hPtr, hTblPtr, statePtr uintptr
	_, _, _, _ = chanPtr, hPtr, hTblPtr, statePtr /* State of the real channel. */
	/*
	 * Always (un)register bottom-most channel in the stack. This makes
	 * management of the channel list easier because no manipulation is
	 * necessary during (un)stack operation.
	 */
	chanPtr = (*TChannelState1)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chan1)).Fstate)).FbottomChanPtr
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	if interp != libc.UintptrFromInt32(0) {
		hTblPtr = XTcl_GetAssocData(tls, interp, __ccgo_ts+42937, libc.UintptrFromInt32(0))
		if hTblPtr == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(hTblPtr)).FfindProc})))(tls, hTblPtr, (*TChannelState)(unsafe.Pointer(statePtr)).FchannelName)
		if hPtr == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
		if (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData != chanPtr {
			return int32(TCL_ERROR)
		}
		XTcl_DeleteHashEntry(tls, hPtr)
		(*TChannelState)(unsafe.Pointer(statePtr)).Fepoch++
		/*
		 * Remove channel handlers that refer to this interpreter, so that
		 * they will not be present if the actual close is delayed and more
		 * events happen on the channel. This may occur if the channel is
		 * shared between several interpreters, or if the channel has async
		 * flushing active.
		 */
		_CleanupChannelHandlers(tls, interp, chanPtr)
	}
	(*TChannelState)(unsafe.Pointer(statePtr)).FrefCount--
	return TCL_OK
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_GetChannel --
 *
 *	Finds an existing Tcl_Channel structure by name in a given
 *	interpreter. This function is public because it is used by
 *	channel-type-specific functions.
 *
 * Results:
 *	A Tcl_Channel or NULL on failure. If failed, interp's result object
 *	contains an error message. *modePtr is filled with the modes in which
 *	the channel was opened.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_GetChannel(tls *libc.TLS, interp uintptr, chanName uintptr, modePtr uintptr) (r TTcl_Channel) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Where to store the mode in which the
	 * channel was opened? Will contain an OR'ed
	 * combination of TCL_READABLE and
	 * TCL_WRITABLE, if non-NULL. */
	var chanPtr, hPtr, hTblPtr, name uintptr
	_, _, _, _ = chanPtr, hPtr, hTblPtr, name /* Translated name. */
	/*
	 * Substitute "stdin", etc. Note that even though we immediately find the
	 * channel using Tcl_GetStdChannel, we still need to look it up in the
	 * specified interpreter to ensure that it is present in the channel
	 * table. Otherwise, safe interpreters would always have access to the
	 * standard channels.
	 */
	name = chanName
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(chanName))) == int32('s') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(chanName + 1))) == int32('t') {
		chanPtr = libc.UintptrFromInt32(0)
		if libc.Xstrcmp(tls, chanName, __ccgo_ts+43095) == 0 {
			chanPtr = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1))
		} else {
			if libc.Xstrcmp(tls, chanName, __ccgo_ts+43101) == 0 {
				chanPtr = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2))
			} else {
				if libc.Xstrcmp(tls, chanName, __ccgo_ts+43108) == 0 {
					chanPtr = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(3))
				}
			}
		}
		if chanPtr != libc.UintptrFromInt32(0) {
			name = (*TChannelState1)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).Fstate)).FchannelName
		}
	}
	hTblPtr = _GetChannelTable(tls, interp)
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(hTblPtr)).FfindProc})))(tls, hTblPtr, name)
	if hPtr == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+43115, libc.VaList(bp+8, chanName)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+43147, chanName, libc.UintptrFromInt32(0)))
		return libc.UintptrFromInt32(0)
	}
	/*
	 * Always return bottom-most channel in the stack. This one lives the
	 * longest - other channels may go away unnoticed. The other APIs
	 * compensate where necessary to retrieve the topmost channel again.
	 */
	chanPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
	chanPtr = (*TChannelState1)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).Fstate)).FbottomChanPtr
	if modePtr != libc.UintptrFromInt32(0) {
		*(*int32)(unsafe.Pointer(modePtr)) = (*TChannelState1)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).Fstate)).Fflags & (libc.Int32FromInt32(1)<<libc.Int32FromInt32(1) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(2))
	}
	return chanPtr
}

/*
 *---------------------------------------------------------------------------
 *
 * TclGetChannelFromObj --
 *
 *	Finds an existing Tcl_Channel structure by name in a given
 *	interpreter. This function is public because it is used by
 *	channel-type-specific functions.
 *
 * Results:
 *	A Tcl_Channel or NULL on failure. If failed, interp's result object
 *	contains an error message. *modePtr is filled with the modes in which
 *	the channel was opened.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTclGetChannelFromObj(tls *libc.TLS, interp uintptr, objPtr uintptr, channelPtr uintptr, modePtr uintptr, dummy1517 int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var chan1 TTcl_Channel
	var irPtr, resPtr, statePtr, v1, v2, v3 uintptr
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_, _, _, _, _, _, _ = chan1, irPtr, resPtr, statePtr, v1, v2, v3
	resPtr = libc.UintptrFromInt32(0)
	if interp == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_chanObjType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	resPtr = v2
	if resPtr != 0 {
		/*
		 * Confirm validity of saved lookup results.
		 */
		statePtr = (*TResolvedChanName)(unsafe.Pointer(resPtr)).FstatePtr
		if (*TResolvedChanName)(unsafe.Pointer(resPtr)).Finterp == interp && (*TResolvedChanName)(unsafe.Pointer(resPtr)).Fepoch == (*TChannelState)(unsafe.Pointer(statePtr)).Fepoch {
			/*
			 * Have a valid saved lookup. Jump to end to return it.
			 */
			goto valid
		}
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		v3 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		v3 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
	}
	chan1 = XTcl_GetChannel(tls, interp, v3, libc.UintptrFromInt32(0))
	if chan1 == libc.UintptrFromInt32(0) {
		if resPtr != 0 {
			XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&_chanObjType)), libc.UintptrFromInt32(0))
		}
		return int32(TCL_ERROR)
	}
	if resPtr != 0 && (*TResolvedChanName)(unsafe.Pointer(resPtr)).FrefCount == uint64(1) {
		/* Re-use the ResolvedCmdName struct */
		XTcl_Release(tls, (*TResolvedChanName)(unsafe.Pointer(resPtr)).FstatePtr)
	} else {
		resPtr = XTcl_Alloc(tls, uint64(32))
		(*TResolvedChanName)(unsafe.Pointer(resPtr)).FrefCount = uint64(0)
		(*TResolvedChanName)(unsafe.Pointer(resPtr)).FrefCount++
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(bp))).Fptr1 = resPtr
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(bp))).Fptr2 = libc.UintptrFromInt32(0)
		XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&_chanObjType)), bp) /* Overwrites, if needed */
	}
	statePtr = (*TChannel)(unsafe.Pointer(chan1)).Fstate
	(*TResolvedChanName)(unsafe.Pointer(resPtr)).FstatePtr = statePtr
	XTcl_Preserve(tls, statePtr)
	(*TResolvedChanName)(unsafe.Pointer(resPtr)).Finterp = interp
	(*TResolvedChanName)(unsafe.Pointer(resPtr)).Fepoch = (*TChannelState)(unsafe.Pointer(statePtr)).Fepoch
	goto valid
valid:
	;
	*(*TTcl_Channel)(unsafe.Pointer(channelPtr)) = (*TChannelState)(unsafe.Pointer(statePtr)).FbottomChanPtr
	if modePtr != libc.UintptrFromInt32(0) {
		*(*int32)(unsafe.Pointer(modePtr)) = (*TChannelState)(unsafe.Pointer(statePtr)).Fflags & (libc.Int32FromInt32(1)<<libc.Int32FromInt32(1) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(2))
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_CreateChannel --
 *
 *	Creates a new entry in the hash table for a Tcl_Channel record.
 *
 * Results:
 *	Returns the new Tcl_Channel.
 *
 * Side effects:
 *	Creates a new Tcl_Channel instance and inserts it into the hash table.
 *
 *----------------------------------------------------------------------
 */

func XTcl_CreateChannel(tls *libc.TLS, typePtr uintptr, chanName uintptr, instanceData uintptr, mask int32) (r TTcl_Channel) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* TCL_READABLE & TCL_WRITABLE to indicate if
	 * the channel is readable, writable. */
	var chanPtr, name, statePtr, tmp, tsdPtr uintptr
	var len1, v1 uint32
	_, _, _, _, _, _, _ = chanPtr, len1, name, statePtr, tmp, tsdPtr, v1
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey2)), int64(64))
	if (*TTcl_ChannelType)(unsafe.Pointer(typePtr)).FtypeName == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+43155, 0)
	}
	if XTcl_ChannelVersion(tls, typePtr) != libc.UintptrFromInt32(0x5) {
		XTcl_Panic(tls, __ccgo_ts+43189, libc.VaList(bp+8, (*TTcl_ChannelType)(unsafe.Pointer(typePtr)).FtypeName))
	}
	if (*TTcl_ChannelType)(unsafe.Pointer(typePtr)).Fclose2Proc == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+43243, libc.VaList(bp+8, (*TTcl_ChannelType)(unsafe.Pointer(typePtr)).FtypeName))
	}
	if libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)&mask != 0 && libc.UintptrFromInt32(0) == (*TTcl_ChannelType)(unsafe.Pointer(typePtr)).FinputProc {
		XTcl_Panic(tls, __ccgo_ts+43282, libc.VaList(bp+8, (*TTcl_ChannelType)(unsafe.Pointer(typePtr)).FtypeName))
	}
	if libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)&mask != 0 && libc.UintptrFromInt32(0) == (*TTcl_ChannelType)(unsafe.Pointer(typePtr)).FoutputProc {
		XTcl_Panic(tls, __ccgo_ts+43349, libc.VaList(bp+8, (*TTcl_ChannelType)(unsafe.Pointer(typePtr)).FtypeName))
	}
	if libc.UintptrFromInt32(0) == (*TTcl_ChannelType)(unsafe.Pointer(typePtr)).FwatchProc {
		XTcl_Panic(tls, __ccgo_ts+43417, libc.VaList(bp+8, (*TTcl_ChannelType)(unsafe.Pointer(typePtr)).FtypeName))
	}
	/*
	 * JH: We could subsequently memset these to 0 to avoid the numerous
	 * assignments to 0/NULL below.
	 */
	chanPtr = XTcl_Alloc(tls, uint64(64))
	statePtr = XTcl_Alloc(tls, uint64(272))
	(*TChannel)(unsafe.Pointer(chanPtr)).Fstate = statePtr
	(*TChannel)(unsafe.Pointer(chanPtr)).FinstanceData = instanceData
	(*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr = typePtr
	/*
	 * Set all the bits that are part of the stack-independent state
	 * information for the channel.
	 */
	if chanName != libc.UintptrFromInt32(0) {
		len1 = uint32(libc.Xstrlen(tls, chanName) + uint64(1))
		/*
		 * Make sure we allocate at least 7 bytes, so it fits for "stdout"
		 * later.
		 */
		if len1 < uint32(7) {
			v1 = uint32(7)
		} else {
			v1 = len1
		}
		tmp = XTcl_Alloc(tls, uint64(v1))
		libc.Xstrcpy(tls, tmp, chanName)
	} else {
		tmp = XTcl_Alloc(tls, uint64(7))
		*(*uint8)(unsafe.Pointer(tmp)) = uint8('\000')
	}
	(*TChannelState)(unsafe.Pointer(statePtr)).FchannelName = tmp
	(*TChannelState)(unsafe.Pointer(statePtr)).Fflags = mask
	(*TChannelState)(unsafe.Pointer(statePtr)).FmaxPerms = mask /* Save max privileges for close callback */
	/*
	 * Set the channel to system default encoding.
	 */
	name = XTcl_GetEncodingName(tls, libc.UintptrFromInt32(0))
	(*TChannelState)(unsafe.Pointer(statePtr)).Fencoding = XTcl_GetEncoding(tls, libc.UintptrFromInt32(0), name)
	(*TChannelState)(unsafe.Pointer(statePtr)).FinputEncodingState = libc.UintptrFromInt32(0)
	(*TChannelState)(unsafe.Pointer(statePtr)).FinputEncodingFlags = int32(TCL_ENCODING_START)
	(*TChannelState)(unsafe.Pointer(statePtr)).FoutputEncodingState = libc.UintptrFromInt32(0)
	(*TChannelState)(unsafe.Pointer(statePtr)).FoutputEncodingFlags = int32(TCL_ENCODING_START)
	/*
	 * Set the channel up initially in AUTO input translation mode to accept
	 * "\n", "\r" and "\r\n". Output translation mode is set to a platform
	 * specific default value. The eofChar is set to 0 for both input and
	 * output, so that Tcl does not look for an in-file EOF indicator (e.g.,
	 * ^Z) and does not append an EOF indicator to files.
	 */
	(*TChannelState)(unsafe.Pointer(statePtr)).FinputTranslation = int32(TCL_TRANSLATE_AUTO)
	(*TChannelState)(unsafe.Pointer(statePtr)).FoutputTranslation = int32(TCL_TRANSLATE_LF)
	(*TChannelState)(unsafe.Pointer(statePtr)).FinEofChar = 0
	(*TChannelState)(unsafe.Pointer(statePtr)).FunreportedError = 0
	(*TChannelState)(unsafe.Pointer(statePtr)).FrefCount = 0
	(*TChannelState)(unsafe.Pointer(statePtr)).FcloseCbPtr = libc.UintptrFromInt32(0)
	(*TChannelState)(unsafe.Pointer(statePtr)).FcurOutPtr = libc.UintptrFromInt32(0)
	(*TChannelState)(unsafe.Pointer(statePtr)).FoutQueueHead = libc.UintptrFromInt32(0)
	(*TChannelState)(unsafe.Pointer(statePtr)).FoutQueueTail = libc.UintptrFromInt32(0)
	(*TChannelState)(unsafe.Pointer(statePtr)).FsaveInBufPtr = libc.UintptrFromInt32(0)
	(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead = libc.UintptrFromInt32(0)
	(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueTail = libc.UintptrFromInt32(0)
	(*TChannelState)(unsafe.Pointer(statePtr)).FchPtr = libc.UintptrFromInt32(0)
	(*TChannelState)(unsafe.Pointer(statePtr)).FinterestMask = 0
	(*TChannelState)(unsafe.Pointer(statePtr)).FscriptRecordPtr = libc.UintptrFromInt32(0)
	(*TChannelState)(unsafe.Pointer(statePtr)).FbufSize = int64(libc.Int32FromInt32(1024) * libc.Int32FromInt32(4))
	(*TChannelState)(unsafe.Pointer(statePtr)).Ftimer = libc.UintptrFromInt32(0)
	(*TChannelState)(unsafe.Pointer(statePtr)).FtimerChanPtr = libc.UintptrFromInt32(0)
	(*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrR = libc.UintptrFromInt32(0)
	(*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrW = libc.UintptrFromInt32(0)
	(*TChannelState)(unsafe.Pointer(statePtr)).FoutputStage = libc.UintptrFromInt32(0)
	/*
	 * As we are creating the channel, it is obviously the top for now.
	 */
	(*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr = chanPtr
	(*TChannelState)(unsafe.Pointer(statePtr)).FbottomChanPtr = chanPtr
	(*TChannel)(unsafe.Pointer(chanPtr)).FdownChanPtr = libc.UintptrFromInt32(0)
	(*TChannel)(unsafe.Pointer(chanPtr)).FupChanPtr = libc.UintptrFromInt32(0)
	(*TChannel)(unsafe.Pointer(chanPtr)).FinQueueHead = libc.UintptrFromInt32(0)
	(*TChannel)(unsafe.Pointer(chanPtr)).FinQueueTail = libc.UintptrFromInt32(0)
	(*TChannel)(unsafe.Pointer(chanPtr)).FrefCount = 0
	/*
	 * TIP #219, Tcl Channel Reflection API
	 */
	(*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg = libc.UintptrFromInt32(0)
	(*TChannelState)(unsafe.Pointer(statePtr)).FunreportedMsg = libc.UintptrFromInt32(0)
	(*TChannelState)(unsafe.Pointer(statePtr)).Fepoch = 0
	/*
	 * Link the channel into the list of all channels; create an on-exit
	 * handler if there is not one already, to close off all the channels in
	 * the list on exit.
	 *
	 * JH: Could call Tcl_SpliceChannel, but need to avoid NULL check.
	 *
	 * TIP #218.
	 * AK: Just initialize the field to NULL before invoking Tcl_SpliceChannel
	 *	   We need Tcl_SpliceChannel, for the threadAction calls. There is no
	 *	   real reason to duplicate all of this.
	 * NOTE: All drivers using thread actions now have to perform their TSD
	 *	     manipulation only in their thread action proc. Doing it when
	 *	     creating their instance structures will collide with the thread
	 *	     action activity and lead to damaged lists.
	 */
	(*TChannelState)(unsafe.Pointer(statePtr)).FnextCSPtr = libc.UintptrFromInt32(0)
	_SpliceChannel(tls, chanPtr)
	/*
	 * Install this channel in the first empty standard channel slot, if the
	 * channel was previously closed explicitly.
	 */
	if (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdinChannel == libc.UintptrFromInt32(0) && (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdinInitialized == int32(1) {
		libc.Xstrcpy(tls, tmp, __ccgo_ts+43095)
		XTcl_SetStdChannel(tls, chanPtr, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1))
		XTcl_RegisterChannel(tls, libc.UintptrFromInt32(0), chanPtr)
	} else {
		if (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdoutChannel == libc.UintptrFromInt32(0) && (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdoutInitialized == int32(1) {
			libc.Xstrcpy(tls, tmp, __ccgo_ts+43101)
			XTcl_SetStdChannel(tls, chanPtr, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2))
			XTcl_RegisterChannel(tls, libc.UintptrFromInt32(0), chanPtr)
		} else {
			if (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstderrChannel == libc.UintptrFromInt32(0) && (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstderrInitialized == int32(1) {
				libc.Xstrcpy(tls, tmp, __ccgo_ts+43108)
				XTcl_SetStdChannel(tls, chanPtr, libc.Int32FromInt32(1)<<libc.Int32FromInt32(3))
				XTcl_RegisterChannel(tls, libc.UintptrFromInt32(0), chanPtr)
			}
		}
	}
	return chanPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_StackChannel --
 *
 *	Replaces an entry in the hash table for a Tcl_Channel record. The
 *	replacement is a new channel with same name, it supercedes the
 *	replaced channel. Input and output of the superceded channel is now
 *	going through the newly created channel and allows the arbitrary
 *	filtering/manipulation of the dataflow.
 *
 *	Andreas Kupries <a.kupries@westend.com>, 12/13/1998 "Trf-Patch for
 *	filtering channels"
 *
 * Results:
 *	Returns the new Tcl_Channel, which actually contains the saved
 *	information about prevChan.
 *
 * Side effects:
 *	A new channel structure is allocated and linked below the existing
 *	channel. The channel operations and client data of the existing
 *	channel are copied down to the newly created channel, and the current
 *	channel has its operations replaced by the new typePtr.
 *
 *----------------------------------------------------------------------
 */

func XTcl_StackChannel(tls *libc.TLS, interp uintptr, typePtr uintptr, instanceData uintptr, mask int32, prevChan TTcl_Channel) (r TTcl_Channel) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The channel structure to replace */
	var chanPtr, csPtrR, csPtrW, prevChanPtr, statePtr, tsdPtr uintptr
	_, _, _, _, _, _ = chanPtr, csPtrR, csPtrW, prevChanPtr, statePtr, tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey2)), int64(64))
	/*
	 * Find the given channel (prevChan) in the list of all channels. If we do
	 * not find it, then it was never registered correctly.
	 *
	 * This operation should occur at the top of a channel stack.
	 */
	statePtr = (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FfirstCSPtr
	prevChanPtr = (*TChannelState1)(unsafe.Pointer((*TChannel)(unsafe.Pointer(prevChan)).Fstate)).FtopChanPtr
	for statePtr != libc.UintptrFromInt32(0) && (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr != prevChanPtr {
		statePtr = (*TChannelState)(unsafe.Pointer(statePtr)).FnextCSPtr
	}
	if statePtr == libc.UintptrFromInt32(0) {
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+43455, libc.VaList(bp+8, XTcl_GetChannelName(tls, prevChan))))
		}
		return libc.UintptrFromInt32(0)
	}
	/*
	 * Here we check if the given "mask" matches the "flags" of the already
	 * existing channel.
	 *
	 *	  | - | R | W | RW |
	 *	--+---+---+---+----+	<=>  0 != (chan->mask & prevChan->mask)
	 *	- |   |   |   |    |
	 *	R |   | + |   | +  |	The superceding channel is allowed to restrict
	 *	W |   |   | + | +  |	the capabilities of the superceded one!
	 *	RW|   | + | + | +  |
	 *	--+---+---+---+----+
	 */
	if mask&((*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(2))) == 0 {
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+43492, libc.VaList(bp+8, XTcl_GetChannelName(tls, prevChan))))
		}
		return libc.UintptrFromInt32(0)
	}
	/*
	 * Flush the buffers. This ensures that any data still in them at this
	 * time is not handled by the new transformation. Restrict this to
	 * writable channels. Take care to hide a possible bg-copy in progress
	 * from Tcl_Flush and the CheckForChannelErrors inside.
	 */
	if mask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
		csPtrR = (*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrR
		csPtrW = (*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrW
		(*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrR = libc.UintptrFromInt32(0)
		(*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrW = libc.UintptrFromInt32(0)
		/*
		 * TODO: Examine what can go wrong if Tcl_Flush() call disturbs
		 * the stacking state of this channel during its operations.
		 */
		if XTcl_Flush(tls, prevChanPtr) != TCL_OK {
			(*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrR = csPtrR
			(*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrW = csPtrW
			if interp != 0 {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+43545, libc.VaList(bp+8, XTcl_GetChannelName(tls, prevChan))))
			}
			return libc.UintptrFromInt32(0)
		}
		(*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrR = csPtrR
		(*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrW = csPtrW
	}
	/*
	 * Discard any input in the buffers. They are not yet read by the user of
	 * the channel, so they have to go through the new transformation before
	 * reading. As the buffers contain the untransformed form their contents
	 * are not only useless but actually distorts our view of the system.
	 *
	 * To preserve the information without having to read them again and to
	 * avoid problems with the location in the channel (seeking might be
	 * impossible) we move the buffers from the common state structure into
	 * the channel itself. We use the buffers in the channel below the new
	 * transformation to hold the data. In the future this allows us to write
	 * transformations which preread data and push the unused part back when
	 * they are going away.
	 */
	if mask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 && (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead != libc.UintptrFromInt32(0) {
		/*
		 * When statePtr->inQueueHead is not NULL, we know
		 * prevChanPtr->inQueueHead must be NULL.
		 */
		(*TChannel)(unsafe.Pointer(prevChanPtr)).FinQueueHead = (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead
		(*TChannel)(unsafe.Pointer(prevChanPtr)).FinQueueTail = (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueTail
		(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead = libc.UintptrFromInt32(0)
		(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueTail = libc.UintptrFromInt32(0)
	}
	chanPtr = XTcl_Alloc(tls, uint64(64))
	/*
	 * Save some of the current state into the new structure, reinitialize the
	 * parts which will stay with the transformation.
	 *
	 * Remarks:
	 */
	(*TChannel)(unsafe.Pointer(chanPtr)).Fstate = statePtr
	(*TChannel)(unsafe.Pointer(chanPtr)).FinstanceData = instanceData
	(*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr = typePtr
	(*TChannel)(unsafe.Pointer(chanPtr)).FdownChanPtr = prevChanPtr
	(*TChannel)(unsafe.Pointer(chanPtr)).FupChanPtr = libc.UintptrFromInt32(0)
	(*TChannel)(unsafe.Pointer(chanPtr)).FinQueueHead = libc.UintptrFromInt32(0)
	(*TChannel)(unsafe.Pointer(chanPtr)).FinQueueTail = libc.UintptrFromInt32(0)
	(*TChannel)(unsafe.Pointer(chanPtr)).FrefCount = 0
	/*
	 * Place new block at the head of a possibly existing list of previously
	 * stacked channels.
	 */
	(*TChannel)(unsafe.Pointer(prevChanPtr)).FupChanPtr = chanPtr
	(*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr = chanPtr
	/*
	 * TIP #218, Channel Thread Actions.
	 *
	 * We call the thread actions for the new channel directly. We _cannot_
	 * use SpliceChannel, because the (thread-)global list of all channels
	 * always contains the _ChannelState_ for a stack of channels, not the
	 * individual channels. And SpliceChannel would not only call the thread
	 * actions, but also add the shared ChannelState to this list a second
	 * time, mangling it.
	 */
	_ChanThreadAction(tls, chanPtr, TCL_CHANNEL_THREAD_INSERT)
	return chanPtr
}

func XTclChannelPreserve(tls *libc.TLS, chan1 TTcl_Channel) {
	(*TChannel)(unsafe.Pointer(chan1)).FrefCount++
}

func XTclChannelRelease(tls *libc.TLS, chan1 TTcl_Channel) {
	var chanPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _ = chanPtr, v1, v2
	chanPtr = chan1
	if (*TChannel)(unsafe.Pointer(chanPtr)).FrefCount == 0 {
		XTcl_Panic(tls, __ccgo_ts+43574, 0)
	}
	v2 = chanPtr + 56
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	if v1 != 0 {
		return
	}
	if (*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr == libc.UintptrFromInt32(0) {
		XTclpFree(tls, chanPtr)
	}
}

func _ChannelFree(tls *libc.TLS, chanPtr uintptr) {
	if (*TChannel)(unsafe.Pointer(chanPtr)).FrefCount == 0 {
		XTclpFree(tls, chanPtr)
		return
	}
	(*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr = libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UnstackChannel --
 *
 *	Unstacks an entry in the hash table for a Tcl_Channel record. This is
 *	the reverse to 'Tcl_StackChannel'.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	If TCL_ERROR is returned, the Posix error code will be set with
 *	Tcl_SetErrno. May leave a message in interp result as well.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UnstackChannel(tls *libc.TLS, interp uintptr, chan1 TTcl_Channel) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The channel to unstack */
	var chanPtr, csPtrR, csPtrW, downChanPtr, statePtr uintptr
	var result int32
	_, _, _, _, _, _ = chanPtr, csPtrR, csPtrW, downChanPtr, result, statePtr
	chanPtr = chan1
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	result = 0
	/*
	 * This operation should occur at the top of a channel stack.
	 */
	chanPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr
	if (*TChannel)(unsafe.Pointer(chanPtr)).FdownChanPtr != libc.UintptrFromInt32(0) {
		/*
		 * Instead of manipulating the per-thread / per-interp list/hash table
		 * of registered channels we wind down the state of the
		 * transformation, and then restore the state of underlying channel
		 * into the old structure.
		 *
		 * TODO: Figure out how to handle the situation where the chan
		 * operations called below by this unstacking operation cause
		 * another unstacking recursively.  In that case the downChanPtr
		 * value we're holding on to will not be the right thing.
		 */
		downChanPtr = (*TChannel)(unsafe.Pointer(chanPtr)).FdownChanPtr
		/*
		 * Flush the buffers. This ensures that any data still in them at this
		 * time _is_ handled by the transformation we are unstacking right
		 * now. Restrict this to writable channels. Take care to hide a
		 * possible bg-copy in progress from Tcl_Flush and the
		 * CheckForChannelErrors inside.
		 */
		if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
			csPtrR = (*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrR
			csPtrW = (*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrW
			(*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrR = libc.UintptrFromInt32(0)
			(*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrW = libc.UintptrFromInt32(0)
			if XTcl_Flush(tls, chanPtr) != TCL_OK {
				(*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrR = csPtrR
				(*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrW = csPtrW
				/*
				 * TIP #219, Tcl Channel Reflection API.
				 * Move error messages put by the driver into the chan/ip
				 * bypass area into the regular interpreter result. Fall back
				 * to the regular message if nothing was found in the
				 * bypasses.
				 */
				if !(XTclChanCaughtErrorBypass(tls, interp, chan1) != 0) && interp != 0 {
					XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+43545, libc.VaList(bp+8, XTcl_GetChannelName(tls, chanPtr))))
				}
				return int32(TCL_ERROR)
			}
			(*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrR = csPtrR
			(*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrW = csPtrW
		}
		/*
		 * Anything in the input queue and the push-back buffers of the
		 * transformation going away is transformed data, but not yet read. As
		 * unstacking means that the caller does not want to see transformed
		 * data any more we have to discard these bytes. To avoid writing an
		 * analogue to 'DiscardInputQueued' we move the information in the
		 * push back buffers to the input queue and then call
		 * 'DiscardInputQueued' on that.
		 */
		if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 && ((*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead != libc.UintptrFromInt32(0) || (*TChannel)(unsafe.Pointer(chanPtr)).FinQueueHead != libc.UintptrFromInt32(0)) {
			if (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead != libc.UintptrFromInt32(0) && (*TChannel)(unsafe.Pointer(chanPtr)).FinQueueHead != libc.UintptrFromInt32(0) {
				(*TChannelBuffer)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FinQueueTail)).FnextPtr = (*TChannel)(unsafe.Pointer(chanPtr)).FinQueueHead
				(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueTail = (*TChannel)(unsafe.Pointer(chanPtr)).FinQueueTail
				(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead = (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueTail
			} else {
				if (*TChannel)(unsafe.Pointer(chanPtr)).FinQueueHead != libc.UintptrFromInt32(0) {
					(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead = (*TChannel)(unsafe.Pointer(chanPtr)).FinQueueHead
					(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueTail = (*TChannel)(unsafe.Pointer(chanPtr)).FinQueueTail
				}
			}
			(*TChannel)(unsafe.Pointer(chanPtr)).FinQueueHead = libc.UintptrFromInt32(0)
			(*TChannel)(unsafe.Pointer(chanPtr)).FinQueueTail = libc.UintptrFromInt32(0)
			_DiscardInputQueued(tls, statePtr, 0)
		}
		/*
		 * TIP #218, Channel Thread Actions.
		 *
		 * We call the thread actions for the new channel directly. We
		 * _cannot_ use CutChannel, because the (thread-)global list of all
		 * channels always contains the _ChannelState_ for a stack of
		 * channels, not the individual channels. And SpliceChannel would not
		 * only call the thread actions, but also remove the shared
		 * ChannelState from this list despite there being more channels for
		 * the state which are still active.
		 */
		_ChanThreadAction(tls, chanPtr, int32(TCL_CHANNEL_THREAD_REMOVE))
		(*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr = downChanPtr
		(*TChannel)(unsafe.Pointer(downChanPtr)).FupChanPtr = libc.UintptrFromInt32(0)
		/*
		 * Leave this link intact for closeproc
		 *  chanPtr->downChanPtr = NULL;
		 */
		/*
		 * Close and free the channel driver state.
		 * TIP #220: This is done with maximum privileges (as created).
		 */
		*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(2))
		*(*int32)(unsafe.Pointer(statePtr + 8)) |= (*TChannelState)(unsafe.Pointer(statePtr)).FmaxPerms
		result = _ChanClose(tls, chanPtr, interp)
		_ChannelFree(tls, chanPtr)
		_UpdateInterest(tls, (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr)
		if result != 0 {
			XTcl_SetErrno(tls, result)
			/*
			 * TIP #219, Tcl Channel Reflection API.
			 * Move error messages put by the driver into the chan/ip bypass
			 * area into the regular interpreter result.
			 */
			XTclChanCaughtErrorBypass(tls, interp, chan1)
			return int32(TCL_ERROR)
		}
	} else {
		/*
		 * This channel does not cover another one. Simply do a close, if
		 * necessary.
		 */
		if (*TChannelState)(unsafe.Pointer(statePtr)).FrefCount <= 0 {
			if XTcl_CloseEx(tls, interp, chan1, 0) != TCL_OK {
				/*
				 * TIP #219, Tcl Channel Reflection API.
				 * "TclChanCaughtErrorBypass" is not required here, it was
				 * done already by "Tcl_Close".
				 */
				return int32(TCL_ERROR)
			}
		}
		/*
		 * TIP #218, Channel Thread Actions.
		 * Not required in this branch, this is done by Tcl_Close. If
		 * Tcl_Close is not called then the ChannelState is still active in
		 * the thread and no action has to be taken either.
		 */
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetStackedChannel --
 *
 *	Determines whether the specified channel is stacked upon another.
 *
 * Results:
 *	NULL if the channel is not stacked upon another one, or a reference to
 *	the channel it is stacked upon. This reference can be used in queries,
 *	but modification is not allowed.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetStackedChannel(tls *libc.TLS, chan1 TTcl_Channel) (r TTcl_Channel) {
	var chanPtr uintptr
	_ = chanPtr
	chanPtr = chan1
	/* The actual channel. */
	return (*TChannel)(unsafe.Pointer(chanPtr)).FdownChanPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetTopChannel --
 *
 *	Returns the top channel of a channel stack.
 *
 * Results:
 *	NULL if the channel is not stacked upon another one, or a reference to
 *	the channel it is stacked upon. This reference can be used in queries,
 *	but modification is not allowed.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetTopChannel(tls *libc.TLS, chan1 TTcl_Channel) (r TTcl_Channel) {
	var chanPtr uintptr
	_ = chanPtr
	chanPtr = chan1
	/* The actual channel. */
	return (*TChannelState1)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).Fstate)).FtopChanPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetChannelInstanceData --
 *
 *	Returns the client data associated with a channel.
 *
 * Results:
 *	The client data.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetChannelInstanceData(tls *libc.TLS, chan1 TTcl_Channel) (r uintptr) {
	/* Channel for which to return client data. */
	var chanPtr uintptr
	_ = chanPtr
	chanPtr = chan1
	/* The actual channel. */
	return (*TChannel)(unsafe.Pointer(chanPtr)).FinstanceData
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetChannelThread --
 *
 *	Given a channel structure, returns the thread managing it. TIP #10
 *
 * Results:
 *	Returns the id of the thread managing the channel.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetChannelThread(tls *libc.TLS, chan1 TTcl_Channel) (r TTcl_ThreadId) {
	/* The channel to return the managing thread
	 * for. */
	var chanPtr uintptr
	_ = chanPtr
	chanPtr = chan1
	/* The actual channel. */
	return (*TChannelState1)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).Fstate)).FmanagingThread
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetChannelType --
 *
 *	Given a channel structure, returns the channel type structure.
 *
 * Results:
 *	Returns a pointer to the channel type structure.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetChannelType(tls *libc.TLS, chan1 TTcl_Channel) (r uintptr) {
	/* The channel to return type for. */
	var chanPtr uintptr
	_ = chanPtr
	chanPtr = chan1
	/* The actual channel. */
	return (*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetChannelMode --
 *
 *	Computes a mask indicating whether the channel is open for reading and
 *	writing.
 *
 * Results:
 *	An OR-ed combination of TCL_READABLE and TCL_WRITABLE.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetChannelMode(tls *libc.TLS, chan1 TTcl_Channel) (r int32) {
	/* The channel for which the mode is being
	 * computed. */
	var statePtr uintptr
	_ = statePtr
	statePtr = (*TChannel)(unsafe.Pointer(chan1)).Fstate
	/* State of actual channel. */
	return (*TChannelState)(unsafe.Pointer(statePtr)).Fflags & (libc.Int32FromInt32(1)<<libc.Int32FromInt32(1) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(2))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetChannelName --
 *
 *	Returns the string identifying the channel name.
 *
 * Results:
 *	The string containing the channel name. This memory is owned by the
 *	generic layer and should not be modified by the caller.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetChannelName(tls *libc.TLS, chan1 TTcl_Channel) (r uintptr) {
	/* The channel for which to return the name. */
	var statePtr uintptr
	_ = statePtr
	statePtr = (*TChannel)(unsafe.Pointer(chan1)).Fstate
	/* State of actual channel. */
	return (*TChannelState)(unsafe.Pointer(statePtr)).FchannelName
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetChannelHandle --
 *
 *	Returns an OS handle associated with a channel.
 *
 * Results:
 *	Returns TCL_OK and places the handle in handlePtr, or returns
 *	TCL_ERROR on failure.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetChannelHandle(tls *libc.TLS, chan1 TTcl_Channel, direction int32, handlePtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Where to store handle */
	var chanPtr uintptr
	var result int32
	var _ /* handle at bp+0 */ uintptr
	_, _ = chanPtr, result
	chanPtr = (*TChannelState1)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chan1)).Fstate)).FbottomChanPtr
	if !((*TTcl_ChannelType)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr)).FgetHandleProc != 0) {
		XTcl_SetChannelError(tls, chan1, XTcl_ObjPrintf(tls, __ccgo_ts+43611, libc.VaList(bp+16, XTcl_GetChannelName(tls, chan1))))
		return int32(TCL_ERROR)
	}
	result = (*(*func(*libc.TLS, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ChannelType)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr)).FgetHandleProc})))(tls, (*TChannel)(unsafe.Pointer(chanPtr)).FinstanceData, direction, bp)
	if handlePtr != 0 {
		*(*uintptr)(unsafe.Pointer(handlePtr)) = *(*uintptr)(unsafe.Pointer(bp))
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_RemoveChannelMode --
 *
 *	Remove either read or write privileges from the channel.
 *
 * Results:
 *	A standard Tcl result code.
 *
 * Side effects:
 *	May change the access mode of the channel.
 *	May leave an error message in the interp.
 *
 *----------------------------------------------------------------------
 */

func XTcl_RemoveChannelMode(tls *libc.TLS, interp uintptr, chan1 TTcl_Channel, mode int32) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* The access mode to drop from the channel */
	var emsg, statePtr uintptr
	_, _ = emsg, statePtr
	statePtr = (*TChannel)(unsafe.Pointer(chan1)).Fstate
	/* State of actual channel. */
	if mode != libc.Int32FromInt32(1)<<libc.Int32FromInt32(1) && mode != libc.Int32FromInt32(1)<<libc.Int32FromInt32(2) {
		emsg = __ccgo_ts + 43652
		goto error
	}
	if 0 == (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) & ^mode {
		emsg = __ccgo_ts + 43672
		goto error
	}
	*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^mode
	return TCL_OK
	goto error
error:
	;
	if interp != libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+43713, libc.VaList(bp+8, emsg, XTcl_GetChannelName(tls, chan1))))
	}
	return int32(TCL_ERROR)
}

/*
 *---------------------------------------------------------------------------
 *
 * AllocChannelBuffer --
 *
 *	A channel buffer has BUFFER_PADDING bytes extra at beginning to hold
 *	any bytes of a native-encoding character that got split by the end of
 *	the previous buffer and need to be moved to the beginning of the next
 *	buffer to make a contiguous string so it can be converted to UTF-8.
 *
 *	A channel buffer has BUFFER_PADDING bytes extra at the end to hold any
 *	bytes of a native-encoding character (generated from a UTF-8
 *	character) that overflow past the end of the buffer and need to be
 *	moved to the next buffer.
 *
 * Results:
 *	A newly allocated channel buffer.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func _AllocChannelBuffer(tls *libc.TLS, length TTcl_Size) (r uintptr) {
	/* Desired length of channel buffer. */
	var bufPtr uintptr
	var n TTcl_Size
	_, _ = bufPtr, n
	n = libc.Int64FromUint64(libc.Uint64FromInt64(length) + uint64(libc.UintptrFromInt32(0)+40) + uint64(BUFFER_PADDING) + uint64(BUFFER_PADDING))
	bufPtr = XTcl_Alloc(tls, libc.Uint64FromInt64(n))
	(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded = int64(BUFFER_PADDING)
	(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved = int64(BUFFER_PADDING)
	(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FbufLength = length + int64(BUFFER_PADDING)
	(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr = libc.UintptrFromInt32(0)
	(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FrefCount = int64(1)
	return bufPtr
}

func _PreserveChannelBuffer(tls *libc.TLS, bufPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	if !((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FrefCount != 0) {
		XTcl_Panic(tls, __ccgo_ts+43760, libc.VaList(bp+8, bufPtr))
	}
	(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FrefCount++
}

func _ReleaseChannelBuffer(tls *libc.TLS, bufPtr uintptr) {
	var v1 TTcl_Size
	var v2 uintptr
	_, _ = v1, v2
	v2 = bufPtr
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	if v1 != 0 {
		return
	}
	XTclpFree(tls, bufPtr)
}

func _IsShared(tls *libc.TLS, bufPtr uintptr) (r int32) {
	return libc.BoolInt32((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FrefCount > int64(1))
}

/*
 *----------------------------------------------------------------------
 *
 * RecycleBuffer --
 *
 *	Helper function to recycle input and output buffers. Ensures that two
 *	input buffers are saved (one in the input queue and another in the
 *	saveInBufPtr field) and that curOutPtr is set to a buffer. Only if
 *	these conditions are met is the buffer freed to the OS.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	May free a buffer to the OS.
 *
 *----------------------------------------------------------------------
 */

func _RecycleBuffer(tls *libc.TLS, statePtr uintptr, bufPtr uintptr, mustDiscard int32) {
	/* If nonzero, free the buffer to the OS,
	 * always. */
	/*
	 * Do we have to free the buffer to the OS?
	 */
	if _IsShared(tls, bufPtr) != 0 {
		mustDiscard = int32(1)
	}
	if mustDiscard != 0 {
		_ReleaseChannelBuffer(tls, bufPtr)
		return
	}
	/*
	 * Only save buffers which have the requested buffer size for the channel.
	 * This is to honor dynamic changes of the buffe rsize made by the user.
	 */
	if (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FbufLength != (*TChannelState)(unsafe.Pointer(statePtr)).FbufSize+int64(BUFFER_PADDING) {
		_ReleaseChannelBuffer(tls, bufPtr)
		return
	}
	/*
	 * Only save buffers for the input queue if the channel is readable.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
		if (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead == libc.UintptrFromInt32(0) {
			(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead = bufPtr
			(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueTail = bufPtr
			goto keepBuffer
		}
		if (*TChannelState)(unsafe.Pointer(statePtr)).FsaveInBufPtr == libc.UintptrFromInt32(0) {
			(*TChannelState)(unsafe.Pointer(statePtr)).FsaveInBufPtr = bufPtr
			goto keepBuffer
		}
	}
	/*
	 * Only save buffers for the output queue if the channel is writable.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
		if (*TChannelState)(unsafe.Pointer(statePtr)).FcurOutPtr == libc.UintptrFromInt32(0) {
			(*TChannelState)(unsafe.Pointer(statePtr)).FcurOutPtr = bufPtr
			goto keepBuffer
		}
	}
	/*
	 * If we reached this code we return the buffer to the OS.
	 */
	_ReleaseChannelBuffer(tls, bufPtr)
	return
	goto keepBuffer
keepBuffer:
	;
	(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved = int64(BUFFER_PADDING)
	(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded = int64(BUFFER_PADDING)
	(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr = libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * DiscardOutputQueued --
 *
 *	Discards all output queued in the output queue of a channel.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Recycles buffers.
 *
 *----------------------------------------------------------------------
 */

func _DiscardOutputQueued(tls *libc.TLS, statePtr uintptr) {
	/* ChannelState for which to discard output. */
	var bufPtr uintptr
	_ = bufPtr
	for (*TChannelState)(unsafe.Pointer(statePtr)).FoutQueueHead != libc.UintptrFromInt32(0) {
		bufPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FoutQueueHead
		(*TChannelState)(unsafe.Pointer(statePtr)).FoutQueueHead = (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr
		_RecycleBuffer(tls, statePtr, bufPtr, 0)
	}
	(*TChannelState)(unsafe.Pointer(statePtr)).FoutQueueHead = libc.UintptrFromInt32(0)
	(*TChannelState)(unsafe.Pointer(statePtr)).FoutQueueTail = libc.UintptrFromInt32(0)
	bufPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FcurOutPtr
	if bufPtr != 0 && (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded-(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved != 0 {
		(*TChannelState)(unsafe.Pointer(statePtr)).FcurOutPtr = libc.UintptrFromInt32(0)
		_RecycleBuffer(tls, statePtr, bufPtr, 0)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * CheckForDeadChannel --
 *
 *	This function checks is a given channel is Dead (a channel that has
 *	been closed but not yet deallocated.)
 *
 * Results:
 *	True (1) if channel is Dead, False (0) if channel is Ok
 *
 * Side effects:
 *	None
 *
 *----------------------------------------------------------------------
 */

func _CheckForDeadChannel(tls *libc.TLS, interp uintptr, statePtr uintptr) (r int32) {
	/* The channel state to check. */
	if !((*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(13)) != 0) {
		return 0
	}
	XTcl_SetErrno(tls, int32(EINVAL))
	if interp != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+43787, int64(-int32(1))))
	}
	return int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * FlushChannel --
 *
 *	This function flushes as much of the queued output as is possible now.
 *	If calledFromAsyncFlush is nonzero, it is being called in an event
 *	handler to flush channel output asynchronously.
 *
 * Results:
 *	0 if successful, else the error code that was returned by the channel
 *	type operation. May leave a message in the interp result.
 *
 * Side effects:
 *	May produce output on a channel. May block indefinitely if the channel
 *	is synchronous. May schedule an async flush on the channel. May
 *	recycle memory for buffers in the output queue.
 *
 *----------------------------------------------------------------------
 */

func _FlushChannel(tls *libc.TLS, interp uintptr, chanPtr uintptr, calledFromAsyncFlush int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* If nonzero then we are being called from an
	 * asynchronous flush callback. */
	var bufExists, written, wroteSome int32
	var bufPtr, cachePtr, msg, statePtr, v2 uintptr
	var v1 TTcl_Size
	var v3 bool
	var _ /* errorCode at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _ = bufExists, bufPtr, cachePtr, msg, statePtr, written, wroteSome, v1, v2, v3
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate /* Amount of output data actually written in
	 * current round. */
	*(*int32)(unsafe.Pointer(bp)) = 0 /* Stores POSIX error codes from channel
	 * driver operations. */
	wroteSome = 0
	/*
	 * Prevent writing on a dead channel -- a channel that has been closed but
	 * not yet deallocated. This can occur if the exit handler for the channel
	 * deallocation runs before all channels are unregistered in all
	 * interpreters.
	 */
	if _CheckForDeadChannel(tls, interp, statePtr) != 0 {
		return -int32(1)
	}
	/*
	 * Should we shift the current output buffer over to the output queue?
	 * First check that there are bytes in it.  If so then...
	 *
	 * If the output queue is empty, then yes, trusting the caller called us
	 * only when written bytes ought to be flushed.
	 *
	 * If the current output buffer is full, then yes, so we can meet the
	 * post-condition that on a successful return to caller we've left space
	 * in the current output buffer for more writing (the flush call was to
	 * make new room).
	 *
	 * If the channel is blocking, then yes, so we guarantee that blocking
	 * flushes actually flush all pending data.
	 *
	 * Otherwise, no.  Keep the current output buffer where it is so more
	 * can be written to it, possibly filling it, to promote more efficient
	 * buffer usage.
	 */
	bufPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FcurOutPtr
	if bufPtr != 0 && (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded-(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved != 0 && ((*TChannelState)(unsafe.Pointer(statePtr)).FoutQueueHead == libc.UintptrFromInt32(0) || bufPtr != 0 && (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded >= (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FbufLength || !((*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(6)) != 0)) {
		if (*TChannelState)(unsafe.Pointer(statePtr)).FoutQueueHead == libc.UintptrFromInt32(0) {
			(*TChannelState)(unsafe.Pointer(statePtr)).FoutQueueHead = bufPtr
		} else {
			(*TChannelBuffer)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FoutQueueTail)).FnextPtr = bufPtr
		}
		(*TChannelState)(unsafe.Pointer(statePtr)).FoutQueueTail = bufPtr
		(*TChannelState)(unsafe.Pointer(statePtr)).FcurOutPtr = libc.UintptrFromInt32(0)
	}
	/*
	 * If we are not being called from an async flush and an async flush
	 * is active, we just return without producing any output.
	 */
	if !(calledFromAsyncFlush != 0) && (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(7)) != 0 {
		return 0
	}
	/*
	 * Loop over the queued buffers and attempt to flush as much as possible
	 * of the queued output to the channel.
	 */
	XTclChannelPreserve(tls, chanPtr)
	for (*TChannelState)(unsafe.Pointer(statePtr)).FoutQueueHead != 0 {
		bufPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FoutQueueHead
		/*
		 * Produce the output on the channel.
		 */
		_PreserveChannelBuffer(tls, bufPtr)
		written = _ChanWrite(tls, chanPtr, bufPtr+40+uintptr((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved), int32((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded-(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved), bp)
		/*
		 * If the write failed completely attempt to start the asynchronous
		 * flush mechanism and break out of this loop - do not attempt to
		 * write any more output at this time.
		 */
		if written < 0 {
			/*
			 * If the last attempt to write was interrupted, simply retry.
			 */
			if *(*int32)(unsafe.Pointer(bp)) == int32(EINTR) {
				*(*int32)(unsafe.Pointer(bp)) = 0
				_ReleaseChannelBuffer(tls, bufPtr)
				continue
			}
			/*
			 * If the channel is non-blocking and we would have blocked, start
			 * a background flushing handler and break out of the loop.
			 */
			if *(*int32)(unsafe.Pointer(bp)) == int32(EAGAIN) {
				/*
				 * This used to check for CHANNEL_NONBLOCKING, and panic if
				 * the channel was blocking. However, it appears that setting
				 * stdin to -blocking 0 has some effect on the stdout when
				 * it's a tty channel (dup'ed underneath)
				 */
				if !((*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(7)) != 0) && !(XTclInExit(tls) != 0) {
					*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(7)
					_UpdateInterest(tls, chanPtr)
				}
				*(*int32)(unsafe.Pointer(bp)) = 0
				_ReleaseChannelBuffer(tls, bufPtr)
				break
			}
			/*
			 * Decide whether to report the error upwards or defer it.
			 */
			if calledFromAsyncFlush != 0 {
				/*
				 * TIP #219, Tcl Channel Reflection API.
				 * When deferring the error copy a message from the bypass into
				 * the unreported area. Or discard it if the new error is to
				 * be ignored in favor of an earlier deferred error.
				 */
				msg = (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg
				if (*TChannelState)(unsafe.Pointer(statePtr)).FunreportedError == 0 {
					(*TChannelState)(unsafe.Pointer(statePtr)).FunreportedError = *(*int32)(unsafe.Pointer(bp))
					(*TChannelState)(unsafe.Pointer(statePtr)).FunreportedMsg = msg
					if msg != libc.UintptrFromInt32(0) {
						(*TTcl_Obj)(unsafe.Pointer(msg)).FrefCount++
					}
				} else {
					/*
					 * An old unreported error is kept, and this error thrown
					 * away.
					 */
					(*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg = libc.UintptrFromInt32(0)
					if msg != libc.UintptrFromInt32(0) {
						v2 = msg
						v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
						*(*TTcl_Size)(unsafe.Pointer(v2))--
						if !(v1 > int64(1)) {
							if !((*TTcl_Obj)(unsafe.Pointer(msg)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(msg)).FtypePtr)).FfreeIntRepProc != 0) {
								if (*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
									XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes)
								}
								(*TTcl_Obj)(unsafe.Pointer(msg)).Flength = int64(-libc.Int32FromInt32(1))
								if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
									cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
								}
								if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
									XTclThreadFreeObj(tls, msg)
								} else {
									(*(*struct {
										Fptr1 uintptr
										Fptr2 uintptr
									})(unsafe.Pointer(msg + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
									(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = msg
									(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
								}
							} else {
								XTclFreeObj(tls, msg)
							}
						}
					}
				}
			} else {
				/*
				 * TIP #219, Tcl Channel Reflection API.
				 * Move error messages put by the driver into the chan bypass
				 * area into the regular interpreter result. Fall back to the
				 * regular message if nothing was found in the bypasses.
				 */
				XTcl_SetErrno(tls, *(*int32)(unsafe.Pointer(bp)))
				if interp != libc.UintptrFromInt32(0) && !(XTclChanCaughtErrorBypass(tls, interp, chanPtr) != 0) {
					XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, XTcl_PosixError(tls, interp), int64(-int32(1))))
				}
				/*
				 * An unreportable bypassed message is kept, for the caller of
				 * Tcl_Seek, Tcl_Write, etc.
				 */
			}
			/*
			 * When we get an error we throw away all the output currently
			 * queued.
			 */
			_ReleaseChannelBuffer(tls, bufPtr)
			_DiscardOutputQueued(tls, statePtr)
			break
		} else {
			/*
			 * TODO: Consider detecting and reacting to short writes on
			 * blocking channels.  Ought not happen.  See iocmd-24.2.
			 */
			wroteSome = int32(1)
		}
		bufExists = libc.BoolInt32((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FrefCount > int64(1))
		_ReleaseChannelBuffer(tls, bufPtr)
		if bufExists != 0 {
			/* There is still a reference to this buffer other than the one
			 * this routine just released, meaning that final cleanup of the
			 * buffer hasn't been ordered by, e.g. by a reflected channel
			 * closing the channel from within one of its handler scripts (not
			 * something one would expecte, but it must be considered).  Normal
			 * operations on the buffer can proceed.
			 */
			*(*TTcl_Size)(unsafe.Pointer(bufPtr + 16)) += int64(written)
			/*
			 * If this buffer is now empty, recycle it.
			 */
			if (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded == (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved {
				(*TChannelState)(unsafe.Pointer(statePtr)).FoutQueueHead = (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr
				if (*TChannelState)(unsafe.Pointer(statePtr)).FoutQueueHead == libc.UintptrFromInt32(0) {
					(*TChannelState)(unsafe.Pointer(statePtr)).FoutQueueTail = libc.UintptrFromInt32(0)
				}
				_RecycleBuffer(tls, statePtr, bufPtr, 0)
			}
		}
	} /* Closes "while". */
	/*
	 * If we wrote some data while flushing in the background, we are done.
	 * We can't finish the background flush until we run out of data and the
	 * channel becomes writable again. This ensures that all of the pending
	 * data has been flushed at the system level.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(7)) != 0 {
		if wroteSome != 0 {
			goto done
		} else {
			if (*TChannelState)(unsafe.Pointer(statePtr)).FoutQueueHead == libc.UintptrFromInt32(0) {
				*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(7))
				_ChanWatch(tls, chanPtr, (*TChannelState)(unsafe.Pointer(statePtr)).FinterestMask)
			} else {
				/*
				    * When we are calledFromAsyncFlush, that means a writable
				    * state on the channel triggered the call, so we should be
				    * able to write something.  Either we did write something
				    * and wroteSome should be set, or there was nothing left to
				    * write in this call, and we've completed the BG flush.
				    * These are the two cases above.  If we get here, that means
				    * there is some kind failure in the writable event machinery.
				    *
				    * The tls extension indeed suffers from flaws in its channel
				    * event mgmt.  See https://core.tcl-lang.org/tcl/info/c31ca233ca.
				    * Until that patch is broadly distributed, disable the
				    * assertion checking here, so that programs using Tcl and
				    * tls can be debugged.
				   assert(!calledFromAsyncFlush);
				*/
			}
		}
	}
	/*
	 * If the channel is flagged as closed, delete it when the refCount drops
	 * to zero, the output queue is empty and there is no output in the
	 * current output buffer.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(8)) != 0 && (*TChannelState)(unsafe.Pointer(statePtr)).FrefCount <= 0 && (*TChannelState)(unsafe.Pointer(statePtr)).FoutQueueHead == libc.UintptrFromInt32(0) && ((*TChannelState)(unsafe.Pointer(statePtr)).FcurOutPtr == libc.UintptrFromInt32(0) || (*TChannelBuffer)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FcurOutPtr)).FnextAdded == (*TChannelBuffer)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FcurOutPtr)).FnextRemoved) {
		*(*int32)(unsafe.Pointer(bp)) = _CloseChannel(tls, interp, chanPtr, *(*int32)(unsafe.Pointer(bp)))
		goto done
	}
	/*
	 * If the write-side of the channel is flagged as closed, delete it when
	 * the output queue is empty and there is no output in the current output
	 * buffer.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(21)) != 0 && (*TChannelState)(unsafe.Pointer(statePtr)).FoutQueueHead == libc.UintptrFromInt32(0) && ((*TChannelState)(unsafe.Pointer(statePtr)).FcurOutPtr == libc.UintptrFromInt32(0) || (*TChannelBuffer)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FcurOutPtr)).FnextAdded == (*TChannelBuffer)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FcurOutPtr)).FnextRemoved) {
		*(*int32)(unsafe.Pointer(bp)) = _CloseChannelPart(tls, interp, chanPtr, *(*int32)(unsafe.Pointer(bp)), libc.Int32FromInt32(1)<<libc.Int32FromInt32(2))
		goto done
	}
	goto done
done:
	;
	XTclChannelRelease(tls, chanPtr)
	return *(*int32)(unsafe.Pointer(bp))
}

func _FreeChannelState(tls *libc.TLS, blockPtr uintptr) {
	/* Channel state to free. */
	var _objPtr, _objPtr1, statePtr, v2, v4 uintptr
	var v1, v3 TTcl_Size
	_, _, _, _, _, _, _ = _objPtr, _objPtr1, statePtr, v1, v2, v3, v4
	statePtr = blockPtr
	/*
	 * Even after close some members can be filled again (in events etc).
	 * Test in bug [79474c588] illustrates one leak (on remaining chanMsg).
	 * Possible other fields need freeing on some constellations.
	 */
	_DiscardInputQueued(tls, statePtr, int32(1))
	if (*TChannelState)(unsafe.Pointer(statePtr)).FcurOutPtr != libc.UintptrFromInt32(0) {
		_ReleaseChannelBuffer(tls, (*TChannelState)(unsafe.Pointer(statePtr)).FcurOutPtr)
	}
	_DiscardOutputQueued(tls, statePtr)
	_DeleteTimerHandler(tls, statePtr)
	if (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg != 0 {
		_objPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	if (*TChannelState)(unsafe.Pointer(statePtr)).FunreportedMsg != 0 {
		_objPtr1 = (*TChannelState)(unsafe.Pointer(statePtr)).FunreportedMsg
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
	XTclpFree(tls, statePtr)
}

/*
 *----------------------------------------------------------------------
 *
 * CloseChannel --
 *
 *	Utility procedure to close a channel and free associated resources.
 *
 *	If the channel was stacked, then the it will copy the necessary
 *	elements of the NEXT channel into the TOP channel, in essence
 *	unstacking the channel. The NEXT channel will then be freed.
 *
 *	If the channel was not stacked, then we will free all the bits for the
 *	TOP channel, including the data structure itself.
 *
 * Results:
 *	Error code from an unreported error or the driver close operation.
 *
 * Side effects:
 *	May close the actual channel, may free memory, may change the value of
 *	errno.
 *
 *----------------------------------------------------------------------
 */

func _CloseChannel(tls *libc.TLS, interp uintptr, chanPtr uintptr, errorCode int32) (r int32) {
	/* Status of operation so far. */
	var cachePtr, cachePtr1, downChanPtr, statePtr, tsdPtr, v2, v5 uintptr
	var result int32
	var v1, v4 TTcl_Size
	var v3, v6 bool
	_, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, downChanPtr, result, statePtr, tsdPtr, v1, v2, v3, v4, v5, v6
	result = 0 /* State of the channel stack. */
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey2)), int64(64))
	if chanPtr == libc.UintptrFromInt32(0) {
		return result
	}
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	/*
	 * No more input can be consumed so discard any leftover input.
	 */
	_DiscardInputQueued(tls, statePtr, int32(1))
	/*
	 * Discard a leftover buffer in the current output buffer field.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).FcurOutPtr != libc.UintptrFromInt32(0) {
		_ReleaseChannelBuffer(tls, (*TChannelState)(unsafe.Pointer(statePtr)).FcurOutPtr)
		(*TChannelState)(unsafe.Pointer(statePtr)).FcurOutPtr = libc.UintptrFromInt32(0)
	}
	/*
	 * The caller guarantees that there are no more buffers queued for output.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).FoutQueueHead != libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+43829, 0)
	}
	/*
	 * TIP #219, Tcl Channel Reflection API.
	 * Move a leftover error message in the channel bypass into the
	 * interpreter bypass. Just clear it if there is no interpreter.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg != libc.UintptrFromInt32(0) {
		if interp != libc.UintptrFromInt32(0) {
			XTcl_SetChannelErrorInterp(tls, interp, (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)
		}
		v2 = (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if !(v1 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).Flength = int64(-libc.Int32FromInt32(1))
				if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)
			}
		}
		(*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg = libc.UintptrFromInt32(0)
	}
	/*
	 * Remove this channel from of the list of all channels.
	 */
	_CutChannel(tls, chanPtr)
	/*
	 * Close and free the channel driver state.
	 * This may leave a TIP #219 error message in the interp.
	 */
	result = _ChanClose(tls, chanPtr, interp)
	/*
	 * Some resources can be cleared only if the bottom channel in a stack is
	 * closed. All the other channels in the stack are not allowed to remove.
	 */
	if chanPtr == (*TChannelState)(unsafe.Pointer(statePtr)).FbottomChanPtr {
		if (*TChannelState)(unsafe.Pointer(statePtr)).FchannelName != libc.UintptrFromInt32(0) {
			XTclpFree(tls, (*TChannelState)(unsafe.Pointer(statePtr)).FchannelName)
			(*TChannelState)(unsafe.Pointer(statePtr)).FchannelName = libc.UintptrFromInt32(0)
		}
		XTcl_FreeEncoding(tls, (*TChannelState)(unsafe.Pointer(statePtr)).Fencoding)
	}
	/*
	 * If we are being called synchronously, report either any latent error on
	 * the channel or the current error.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).FunreportedError != 0 {
		errorCode = (*TChannelState)(unsafe.Pointer(statePtr)).FunreportedError
		/*
		 * TIP #219, Tcl Channel Reflection API.
		 * Move an error message found in the unreported area into the regular
		 * bypass (interp). This kills any message in the channel bypass area.
		 */
		if (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg != libc.UintptrFromInt32(0) {
			v5 = (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg
			v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
			*(*TTcl_Size)(unsafe.Pointer(v5))--
			if !(v4 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).Flength = int64(-libc.Int32FromInt32(1))
					if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
						cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v6 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)
				}
			}
			(*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg = libc.UintptrFromInt32(0)
		}
		if interp != 0 {
			XTcl_SetChannelErrorInterp(tls, interp, (*TChannelState)(unsafe.Pointer(statePtr)).FunreportedMsg)
		}
	}
	if errorCode == 0 {
		errorCode = result
		if errorCode != 0 {
			XTcl_SetErrno(tls, errorCode)
		}
	}
	/*
	 * Cancel any outstanding timer.
	 */
	_DeleteTimerHandler(tls, statePtr)
	/*
	 * Mark the channel as deleted by clearing the type structure.
	 */
	if (*TChannel)(unsafe.Pointer(chanPtr)).FdownChanPtr != libc.UintptrFromInt32(0) {
		downChanPtr = (*TChannel)(unsafe.Pointer(chanPtr)).FdownChanPtr
		(*TChannelState)(unsafe.Pointer(statePtr)).FnextCSPtr = (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FfirstCSPtr
		(*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FfirstCSPtr = statePtr
		(*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr = downChanPtr
		(*TChannel)(unsafe.Pointer(downChanPtr)).FupChanPtr = libc.UintptrFromInt32(0)
		_ChannelFree(tls, chanPtr)
		return XTcl_CloseEx(tls, interp, downChanPtr, 0)
	}
	/*
	 * There is only the TOP Channel, so we free the remaining pointers we
	 * have and then ourselves. Since this is the last of the channels in the
	 * stack, make sure to free the ChannelState structure associated with it.
	 */
	_ChannelFree(tls, chanPtr)
	XTcl_EventuallyFree(tls, statePtr, __ccgo_fp(_FreeChannelState))
	return errorCode
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_CutChannel --
 * CutChannel --
 *
 *	Removes a channel from the (thread-)global list of all channels (in
 *	that thread). This is actually the statePtr for the stack of channel.
 *
 * Results:
 *	Nothing.
 *
 * Side effects:
 *	Resets the field 'nextCSPtr' of the specified channel state to NULL.
 *
 * NOTE:
 *	The channel to cut out of the list must not be referenced in any
 *	interpreter. This is something this procedure cannot check (despite
 *	the refcount) because the caller usually wants fiddle with the channel
 *	(like transferring it to a different thread) and thus keeps the
 *	refcount artificially high to prevent its destruction.
 *
 *----------------------------------------------------------------------
 */

func _CutChannel(tls *libc.TLS, chan1 TTcl_Channel) {
	/* The channel being removed. Must not be
	 * referenced in any interpreter. */
	var prevCSPtr, statePtr, tsdPtr uintptr
	_, _, _ = prevCSPtr, statePtr, tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey2)), int64(64)) /* Preceding channel state in list of all
	 * states - used to splice a channel out of
	 * the list on close. */
	statePtr = (*TChannel)(unsafe.Pointer(chan1)).Fstate
	/* State of the channel stack. */
	/*
	 * Remove this channel from of the list of all channels (in the current
	 * thread).
	 */
	if (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FfirstCSPtr != 0 && statePtr == (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FfirstCSPtr {
		(*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FfirstCSPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FnextCSPtr
	} else {
		prevCSPtr = (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FfirstCSPtr
		for {
			if !(prevCSPtr != 0 && (*TChannelState)(unsafe.Pointer(prevCSPtr)).FnextCSPtr != statePtr) {
				break
			}
			/* Empty loop body. */
			goto _1
		_1:
			;
			prevCSPtr = (*TChannelState)(unsafe.Pointer(prevCSPtr)).FnextCSPtr
		}
		if prevCSPtr == libc.UintptrFromInt32(0) {
			XTcl_Panic(tls, __ccgo_ts+43874, 0)
		}
		(*TChannelState)(unsafe.Pointer(prevCSPtr)).FnextCSPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FnextCSPtr
	}
	(*TChannelState)(unsafe.Pointer(statePtr)).FnextCSPtr = libc.UintptrFromInt32(0)
	/*
	 * TIP #218, Channel Thread Actions
	 */
	_ChanThreadAction(tls, chan1, int32(TCL_CHANNEL_THREAD_REMOVE))
	/* Channel is not managed by any thread */
	(*TChannelState)(unsafe.Pointer(statePtr)).FmanagingThread = libc.UintptrFromInt32(0)
}

func XTcl_CutChannel(tls *libc.TLS, chan1 TTcl_Channel) {
	/* The channel being added. Must not be
	 * referenced in any interpreter. */
	var chanPtr, prevCSPtr, statePtr, tsdPtr uintptr
	_, _, _, _ = chanPtr, prevCSPtr, statePtr, tsdPtr
	chanPtr = (*TChannelState1)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chan1)).Fstate)).FbottomChanPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey2)), int64(64)) /* Preceding channel state in list of all
	 * states - used to splice a channel out of
	 * the list on close. */
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	/* State of the channel stack. */
	/*
	 * Remove this channel from of the list of all channels (in the current
	 * thread).
	 */
	if (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FfirstCSPtr != 0 && statePtr == (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FfirstCSPtr {
		(*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FfirstCSPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FnextCSPtr
	} else {
		prevCSPtr = (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FfirstCSPtr
		for {
			if !(prevCSPtr != 0 && (*TChannelState)(unsafe.Pointer(prevCSPtr)).FnextCSPtr != statePtr) {
				break
			}
			/* Empty loop body. */
			goto _1
		_1:
			;
			prevCSPtr = (*TChannelState)(unsafe.Pointer(prevCSPtr)).FnextCSPtr
		}
		if prevCSPtr == libc.UintptrFromInt32(0) {
			XTcl_Panic(tls, __ccgo_ts+43874, 0)
		}
		(*TChannelState)(unsafe.Pointer(prevCSPtr)).FnextCSPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FnextCSPtr
	}
	(*TChannelState)(unsafe.Pointer(statePtr)).FnextCSPtr = libc.UintptrFromInt32(0)
	/*
	 * TIP #218, Channel Thread Actions
	 * For all transformations and the base channel.
	 */
	for {
		if !(chanPtr != libc.UintptrFromInt32(0)) {
			break
		}
		_ChanThreadAction(tls, chanPtr, int32(TCL_CHANNEL_THREAD_REMOVE))
		goto _2
	_2:
		;
		chanPtr = (*TChannel)(unsafe.Pointer(chanPtr)).FupChanPtr
	}
	/* Channel is not managed by any thread */
	(*TChannelState)(unsafe.Pointer(statePtr)).FmanagingThread = libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SpliceChannel --
 * SpliceChannel --
 *
 *	Adds a channel to the (thread-)global list of all channels (in that
 *	thread). Expects that the field 'nextChanPtr' in the channel is set to
 *	NULL.
 *
 * Results:
 *	Nothing.
 *
 * Side effects:
 *	Nothing.
 *
 * NOTE:
 *	The channel to splice into the list must not be referenced in any
 *	interpreter. This is something this procedure cannot check (despite
 *	the refcount) because the caller usually wants fiddle with the channel
 *	(like transferring it to a different thread) and thus keeps the
 *	refcount artificially high to prevent its destruction.
 *
 *----------------------------------------------------------------------
 */

func _SpliceChannel(tls *libc.TLS, chan1 TTcl_Channel) {
	/* The channel being added. Must not be
	 * referenced in any interpreter. */
	var statePtr, tsdPtr uintptr
	_, _ = statePtr, tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey2)), int64(64))
	statePtr = (*TChannel)(unsafe.Pointer(chan1)).Fstate
	if (*TChannelState)(unsafe.Pointer(statePtr)).FnextCSPtr != libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+43909, 0)
	}
	(*TChannelState)(unsafe.Pointer(statePtr)).FnextCSPtr = (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FfirstCSPtr
	(*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FfirstCSPtr = statePtr
	/*
	 * TIP #10. Mark the current thread as the new one managing this channel.
	 *		Note: 'Tcl_GetCurrentThread' returns sensible values even for
	 *		a non-threaded core.
	 */
	(*TChannelState)(unsafe.Pointer(statePtr)).FmanagingThread = XTcl_GetCurrentThread(tls)
	/*
	 * TIP #218, Channel Thread Actions
	 */
	_ChanThreadAction(tls, chan1, TCL_CHANNEL_THREAD_INSERT)
}

func XTcl_SpliceChannel(tls *libc.TLS, chan1 TTcl_Channel) {
	/* The channel being added. Must not be
	 * referenced in any interpreter. */
	var chanPtr, statePtr, tsdPtr uintptr
	_, _, _ = chanPtr, statePtr, tsdPtr
	chanPtr = (*TChannelState1)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chan1)).Fstate)).FbottomChanPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey2)), int64(64))
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	if (*TChannelState)(unsafe.Pointer(statePtr)).FnextCSPtr != libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+43909, 0)
	}
	(*TChannelState)(unsafe.Pointer(statePtr)).FnextCSPtr = (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FfirstCSPtr
	(*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FfirstCSPtr = statePtr
	/*
	 * TIP #10. Mark the current thread as the new one managing this channel.
	 *		Note: 'Tcl_GetCurrentThread' returns sensible values even for
	 *		a non-threaded core.
	 */
	(*TChannelState)(unsafe.Pointer(statePtr)).FmanagingThread = XTcl_GetCurrentThread(tls)
	/*
	 * TIP #218, Channel Thread Actions
	 * For all transformations and the base channel.
	 */
	for {
		if !(chanPtr != libc.UintptrFromInt32(0)) {
			break
		}
		_ChanThreadAction(tls, chanPtr, TCL_CHANNEL_THREAD_INSERT)
		goto _1
	_1:
		;
		chanPtr = (*TChannel)(unsafe.Pointer(chanPtr)).FupChanPtr
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_Close --
 *
 *	Closes a channel.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Closes the channel if this is the last reference.
 *
 * NOTE:
 *	Tcl_Close removes the channel as far as the user is concerned.
 *	However, it may continue to exist for a while longer if it has a
 *	background flush scheduled. The device itself is eventually closed and
 *	the channel record removed, in CloseChannel, above.
 *
 *----------------------------------------------------------------------
 */

func XTclClose(tls *libc.TLS, interp uintptr, chan1 TTcl_Channel) (r int32) {
	/* The channel being closed. Must not be
	 * referenced in any interpreter. May be NULL,
	 * in which case this is a no-op. */
	var cachePtr, cbPtr, chanPtr, statePtr, v2 uintptr
	var code, flushcode, result, stickyError int32
	var v1 TTcl_Size
	var v3 bool
	_, _, _, _, _, _, _, _, _, _, _ = cachePtr, cbPtr, chanPtr, code, flushcode, result, statePtr, stickyError, v1, v2, v3 /* State of real IO channel. */
	result = 0
	if chan1 == libc.UintptrFromInt32(0) {
		return TCL_OK
	}
	/*
	 * Perform special handling for standard channels being closed. If the
	 * refCount is now 1 it means that the last reference to the standard
	 * channel is being explicitly closed, so bump the refCount down
	 * artificially to 0. This will ensure that the channel is actually
	 * closed, below. Also set the static pointer to NULL for the channel.
	 */
	_CheckForStdChannelsBeingClosed(tls, chan1)
	/*
	 * This operation should occur at the top of a channel stack.
	 */
	chanPtr = chan1
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	chanPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr
	if (*TChannelState)(unsafe.Pointer(statePtr)).FrefCount > 0 {
		XTcl_Panic(tls, __ccgo_ts+43969, 0)
	}
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(19)) != 0 {
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+43030, int64(-int32(1))))
		}
		return int32(TCL_ERROR)
	}
	*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(19)
	/*
	 * When the channel has an escape sequence driven encoding such as
	 * iso2022, the terminated escape sequence must write to the buffer.
	 */
	stickyError = 0
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 && (*TChannelState)(unsafe.Pointer(statePtr)).Fencoding != _GetBinaryEncoding(tls) && !((*TChannelState)(unsafe.Pointer(statePtr)).FoutputEncodingFlags&libc.Int32FromInt32(TCL_ENCODING_START) != 0) {
		code = _CheckChannelErrors(tls, statePtr, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2))
		if code == 0 {
			*(*int32)(unsafe.Pointer(statePtr + 48)) |= int32(TCL_ENCODING_END)
			code = int32(_Write(tls, chanPtr, __ccgo_ts+1945, 0, (*TChannelState1)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).Fstate)).Fencoding))
			*(*int32)(unsafe.Pointer(statePtr + 48)) &= ^libc.Int32FromInt32(TCL_ENCODING_END)
			*(*int32)(unsafe.Pointer(statePtr + 48)) |= int32(TCL_ENCODING_START)
		}
		if code < 0 {
			stickyError = XTcl_GetErrno(tls)
		}
		/*
		 * TIP #219, Tcl Channel Reflection API.
		 * Move an error message found in the channel bypass into the
		 * interpreter bypass. Just clear it if there is no interpreter.
		 */
		if (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg != libc.UintptrFromInt32(0) {
			if interp != libc.UintptrFromInt32(0) {
				XTcl_SetChannelErrorInterp(tls, interp, (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)
			}
			v2 = (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if !(v1 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).Flength = int64(-libc.Int32FromInt32(1))
					if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
						cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)
				}
			}
			(*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg = libc.UintptrFromInt32(0)
		}
	}
	XTcl_ClearChannelHandlers(tls, chan1)
	/*
	 * Invoke the registered close callbacks and delete their records.
	 */
	for (*TChannelState)(unsafe.Pointer(statePtr)).FcloseCbPtr != libc.UintptrFromInt32(0) {
		cbPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FcloseCbPtr
		(*TChannelState)(unsafe.Pointer(statePtr)).FcloseCbPtr = (*TCloseCallback)(unsafe.Pointer(cbPtr)).FnextPtr
		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TCloseCallback)(unsafe.Pointer(cbPtr)).Fproc})))(tls, (*TCloseCallback)(unsafe.Pointer(cbPtr)).FclientData)
		XTclpFree(tls, cbPtr)
	}
	*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(19))
	/*
	 * If this channel supports it, close the read side, since we don't need
	 * it anymore and this will help avoid deadlocks on some channel types.
	 */
	result = (*(*func(*libc.TLS, uintptr, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ChannelType)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr)).Fclose2Proc})))(tls, (*TChannel)(unsafe.Pointer(chanPtr)).FinstanceData, interp, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1))
	if result == int32(EINVAL) || result == int32(ENOTCONN) {
		result = 0
	}
	/*
	 * The call to FlushChannel will flush any queued output and invoke the
	 * close function of the channel driver, or it will set up the channel to
	 * be flushed and closed asynchronously.
	 */
	*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(8)
	flushcode = _FlushChannel(tls, interp, chanPtr, 0)
	/*
	 * TIP #219.
	 * Capture error messages put by the driver into the bypass area and put
	 * them into the regular interpreter result.
	 *
	 * Notes: Due to the assertion of CHANNEL_CLOSED in the flags
	 * FlushChannel() has called CloseChannel() and thus freed all the channel
	 * structures. We must not try to access "chan" anymore, hence the NULL
	 * argument in the call below. The only place which may still contain a
	 * message is the interpreter itself, and "CloseChannel" made sure to lift
	 * any channel message it generated into it.
	 */
	if XTclChanCaughtErrorBypass(tls, interp, libc.UintptrFromInt32(0)) != 0 {
		result = int32(EINVAL)
	}
	if stickyError != 0 {
		XTcl_SetErrno(tls, stickyError)
		if interp != libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, XTcl_PosixError(tls, interp), int64(-int32(1))))
		}
		return int32(TCL_ERROR)
	}
	/*
	 * Bug 97069ea11a: set error message if a flush code is set and no error
	 * message set up to now.
	 */
	if flushcode != 0 {
		/* flushcode has precedence, if available */
		result = flushcode
	}
	if result != 0 && result != int32(TCL_ERROR) && interp != libc.UintptrFromInt32(0) && 0 == XTcl_GetCharLength(tls, XTcl_GetObjResult(tls, interp)) {
		XTcl_SetErrno(tls, result)
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, XTcl_PosixError(tls, interp), int64(-int32(1))))
	}
	if result != 0 {
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_CloseEx --
 *
 *	Closes one side of a channel, read or write, close all.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Closes one direction of the channel, or do a full close.
 *
 * NOTE:
 *	Tcl_CloseEx closes the specified direction of the channel as far as
 *	the user is concerned. If flags = 0, this is equivalent to Tcl_Close.
 *
 *----------------------------------------------------------------------
 */

func XTcl_CloseEx(tls *libc.TLS, interp uintptr, chan1 TTcl_Channel, flags int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Flags telling us which side to close. */
	var chanPtr, msg, statePtr uintptr
	_, _, _ = chanPtr, msg, statePtr /* State of real IO channel. */
	if chan1 == libc.UintptrFromInt32(0) {
		return TCL_OK
	}
	chanPtr = chan1
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) == 0 {
		return XTclClose(tls, interp, chan1)
	}
	if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) == libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(2) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+44015, libc.VaList(bp+8, (*TTcl_ChannelType)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr)).FtypeName)))
		return int32(TCL_ERROR)
	}
	/*
	 * Does the channel support half-close anyway? Error if not.
	 */
	if !((*TTcl_ChannelType)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr)).Fclose2Proc != 0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+44061, libc.VaList(bp+8, (*TTcl_ChannelType)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr)).FtypeName)))
		return int32(TCL_ERROR)
	}
	/*
	 * Is the channel unstacked ? If not we fail.
	 */
	if chanPtr != (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+44105, int64(-int32(1))))
		return int32(TCL_ERROR)
	}
	/*
	 * Check direction against channel mode. It is an error if we try to close
	 * a direction not supported by the channel (already closed, or never
	 * opened for that direction).
	 */
	if !((*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(2))&flags != 0) {
		if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
			msg = __ccgo_ts + 5552
		} else {
			msg = __ccgo_ts + 44159
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+44165, libc.VaList(bp+8, msg)))
		return int32(TCL_ERROR)
	}
	/*
	 * A user may try to call half-close from within a channel close handler.
	 * That won't do.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(19)) != 0 {
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+43030, int64(-int32(1))))
		}
		return int32(TCL_ERROR)
	}
	if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
		/*
		 * Call the finalization code directly. There are no events to handle,
		 * there cannot be for the read-side.
		 */
		return _CloseChannelPart(tls, interp, chanPtr, 0, flags)
	} else {
		if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
			XTcl_Preserve(tls, statePtr)
			if !((*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(7)) != 0) {
				/*
				 * We don't want to re-enter CloseWrite().
				 */
				if !((*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(21)) != 0) {
					if _CloseWrite(tls, interp, chanPtr) != TCL_OK {
						*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(21)
						XTcl_Release(tls, statePtr)
						return int32(TCL_ERROR)
					}
				}
			}
			*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(21)
			XTcl_Release(tls, statePtr)
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * CloseWrite --
 *
 *	Closes the write side a channel.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Closes the write side of the channel.
 *
 * NOTE:
 *	CloseWrite removes the channel as far as the user is concerned.
 *	However, the output data structures may continue to exist for a while
 *	longer if it has a background flush scheduled. The device itself is
 *	eventually closed and the channel structures modified, in
 *	CloseChannelPart, below.
 *
 *----------------------------------------------------------------------
 */

func _CloseWrite(tls *libc.TLS, interp uintptr, chanPtr uintptr) (r int32) {
	/* The channel whose write side is being
	 * closed. May still be used by some
	 * interpreter */
	var flushcode, result int32
	var statePtr uintptr
	_, _, _ = flushcode, result, statePtr
	/*
	 * Notes: clear-channel-handlers - write side only ? or keep around, just
	 * not called.
	 *
	 * No close callbacks are run - channel is still open (read side)
	 */
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	result = 0
	/*
	 * The call to FlushChannel will flush any queued output and invoke the
	 * close function of the channel driver, or it will set up the channel to
	 * be flushed and closed asynchronously.
	 */
	*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(21)
	flushcode = _FlushChannel(tls, interp, chanPtr, 0)
	/*
	 * TIP #219.
	 * Capture error messages put by the driver into the bypass area and put
	 * them into the regular interpreter result.
	 *
	 * Notes: Due to the assertion of CHANNEL_CLOSEDWRITE in the flags
	 * FlushChannel() has called CloseChannelPart(). While we can still access
	 * "chan" (no structures were freed), the only place which may still
	 * contain a message is the interpreter itself, and "CloseChannelPart"
	 * made sure to lift any channel message it generated into it. Hence the
	 * NULL argument in the call below.
	 */
	if XTclChanCaughtErrorBypass(tls, interp, libc.UintptrFromInt32(0)) != 0 {
		result = int32(EINVAL)
	}
	if flushcode != 0 || result != 0 {
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * CloseChannelPart --
 *
 *	Utility procedure to close a channel partially and free associated
 *	resources. If the channel was stacked it will never be run (The higher
 *	level forbid this). If the channel was not stacked, then we will free
 *	all the bits of the chosen side (read, or write) for the TOP channel.
 *
 * Results:
 *	Error code from an unreported error or the driver close2 operation.
 *
 * Side effects:
 *	May free memory, may change the value of errno.
 *
 *----------------------------------------------------------------------
 */

func _CloseChannelPart(tls *libc.TLS, interp uintptr, chanPtr uintptr, errorCode int32, flags int32) (r int32) {
	/* Flags telling us which side to close. */
	var cachePtr, cachePtr1, statePtr, v2, v5 uintptr
	var result int32
	var v1, v4 TTcl_Size
	var v3, v6 bool
	_, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, result, statePtr, v1, v2, v3, v4, v5, v6 /* Of calling the close2proc. */
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
		/*
		 * No more input can be consumed so discard any leftover input.
		 */
		_DiscardInputQueued(tls, statePtr, int32(1))
	} else {
		if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
			/*
			 * The caller guarantees that there are no more buffers queued for
			 * output.
			 */
			if (*TChannelState)(unsafe.Pointer(statePtr)).FoutQueueHead != libc.UintptrFromInt32(0) {
				XTcl_Panic(tls, __ccgo_ts+44235, 0)
			}
			/*
			 * TIP #219, Tcl Channel Reflection API.
			 * Move a leftover error message in the channel bypass into the
			 * interpreter bypass. Just clear it if there is no interpreter.
			 */
			if (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg != libc.UintptrFromInt32(0) {
				if interp != libc.UintptrFromInt32(0) {
					XTcl_SetChannelErrorInterp(tls, interp, (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)
				}
				v2 = (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg
				v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
				*(*TTcl_Size)(unsafe.Pointer(v2))--
				if !(v1 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).Flength = int64(-libc.Int32FromInt32(1))
						if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
							cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg
							(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)
					}
				}
				(*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg = libc.UintptrFromInt32(0)
			}
		}
	}
	/*
	 * Finally do what is asked of us. Close and free the channel driver state
	 * for the chosen side of the channel. This may leave a TIP #219 error
	 * message in the interp.
	 */
	result = (*(*func(*libc.TLS, uintptr, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ChannelType)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr)).Fclose2Proc})))(tls, (*TChannel)(unsafe.Pointer(chanPtr)).FinstanceData, libc.UintptrFromInt32(0), flags)
	/*
	 * If we are being called synchronously, report either any latent error on
	 * the channel or the current error.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).FunreportedError != 0 {
		errorCode = (*TChannelState)(unsafe.Pointer(statePtr)).FunreportedError
		/*
		 * TIP #219, Tcl Channel Reflection API.
		 * Move an error message found in the unreported area into the regular
		 * bypass (interp). This kills any message in the channel bypass area.
		 */
		if (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg != libc.UintptrFromInt32(0) {
			v5 = (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg
			v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
			*(*TTcl_Size)(unsafe.Pointer(v5))--
			if !(v4 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).Flength = int64(-libc.Int32FromInt32(1))
					if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
						cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v6 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)
				}
			}
			(*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg = libc.UintptrFromInt32(0)
		}
		if interp != 0 {
			XTcl_SetChannelErrorInterp(tls, interp, (*TChannelState)(unsafe.Pointer(statePtr)).FunreportedMsg)
		}
	}
	if errorCode == 0 {
		errorCode = result
		if errorCode != 0 {
			XTcl_SetErrno(tls, errorCode)
		}
	}
	/*
	 * TIP #219.
	 * Capture error messages put by the driver into the bypass area and put
	 * them into the regular interpreter result. See also the bottom of
	 * CloseWrite().
	 */
	if XTclChanCaughtErrorBypass(tls, interp, chanPtr) != 0 {
		result = int32(EINVAL)
	}
	if result != 0 {
		return int32(TCL_ERROR)
	}
	/*
	 * Remove the closed side from the channel mode/flags.
	 */
	*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(flags & (libc.Int32FromInt32(1)<<libc.Int32FromInt32(1) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ClearChannelHandlers --
 *
 *	Removes all channel handlers and event scripts from the channel,
 *	cancels all background copies involving the channel and any interest
 *	in events.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	See above. Deallocates memory.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ClearChannelHandlers(tls *libc.TLS, channel TTcl_Channel) {
	var cachePtr, chNext, chPtr, chanPtr, eNextPtr, ePtr, nhPtr, statePtr, tsdPtr, v5 uintptr
	var v4 TTcl_Size
	var v6 bool
	_, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, chNext, chPtr, chanPtr, eNextPtr, ePtr, nhPtr, statePtr, tsdPtr, v4, v5, v6 /* State of real IO channel. */
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey2)), int64(64))
	/*
	 * This operation should occur at the top of a channel stack.
	 */
	chanPtr = channel
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	chanPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr
	/*
	 * Cancel any outstanding timer.
	 */
	_DeleteTimerHandler(tls, statePtr)
	/*
	 * Remove any references to channel handlers for this channel that may be
	 * about to be invoked.
	 */
	nhPtr = (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FnestedHandlerPtr
	for {
		if !(nhPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TNextChannelHandler)(unsafe.Pointer(nhPtr)).FnextHandlerPtr != 0 && (*TChannelHandler)(unsafe.Pointer((*TNextChannelHandler)(unsafe.Pointer(nhPtr)).FnextHandlerPtr)).FchanPtr == chanPtr {
			(*TNextChannelHandler)(unsafe.Pointer(nhPtr)).FnextHandlerPtr = libc.UintptrFromInt32(0)
		}
		goto _1
	_1:
		;
		nhPtr = (*TNextChannelHandler)(unsafe.Pointer(nhPtr)).FnestedHandlerPtr
	}
	/*
	 * Remove all the channel handler records attached to the channel itself.
	 */
	chPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FchPtr
	for {
		if !(chPtr != libc.UintptrFromInt32(0)) {
			break
		}
		chNext = (*TChannelHandler)(unsafe.Pointer(chPtr)).FnextPtr
		XTclpFree(tls, chPtr)
		goto _2
	_2:
		;
		chPtr = chNext
	}
	(*TChannelState)(unsafe.Pointer(statePtr)).FchPtr = libc.UintptrFromInt32(0)
	/*
	 * Cancel any pending copy operation.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrR != 0 {
		_StopCopy(tls, (*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrR)
		(*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrR = libc.UintptrFromInt32(0)
	}
	if (*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrW != 0 {
		_StopCopy(tls, (*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrW)
		(*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrW = libc.UintptrFromInt32(0)
	}
	/*
	 * Must set the interest mask now to 0, otherwise infinite loops will
	 * occur if Tcl_DoOneEvent is called before the channel is finally deleted
	 * in FlushChannel. This can happen if the channel has a background flush
	 * active.
	 */
	(*TChannelState)(unsafe.Pointer(statePtr)).FinterestMask = 0
	/*
	 * Remove any EventScript records for this channel.
	 */
	ePtr = (*TChannelState)(unsafe.Pointer(statePtr)).FscriptRecordPtr
	for {
		if !(ePtr != libc.UintptrFromInt32(0)) {
			break
		}
		eNextPtr = (*TEventScriptRecord)(unsafe.Pointer(ePtr)).FnextPtr
		v5 = (*TEventScriptRecord)(unsafe.Pointer(ePtr)).FscriptPtr
		v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
		*(*TTcl_Size)(unsafe.Pointer(v5))--
		if !(v4 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(ePtr)).FscriptPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(ePtr)).FscriptPtr)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(ePtr)).FscriptPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(ePtr)).FscriptPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(ePtr)).FscriptPtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(ePtr)).FscriptPtr)).Flength = int64(-libc.Int32FromInt32(1))
				if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v6 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, (*TEventScriptRecord)(unsafe.Pointer(ePtr)).FscriptPtr)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(ePtr)).FscriptPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*TEventScriptRecord)(unsafe.Pointer(ePtr)).FscriptPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, (*TEventScriptRecord)(unsafe.Pointer(ePtr)).FscriptPtr)
			}
		}
		XTclpFree(tls, ePtr)
		goto _3
	_3:
		;
		ePtr = eNextPtr
	}
	(*TChannelState)(unsafe.Pointer(statePtr)).FscriptRecordPtr = libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_Write --
 *
 *	Puts a sequence of bytes into an output buffer, may queue the buffer
 *	for output if it gets full, and also remembers whether the current
 *	buffer is ready e.g. if it contains a newline and we are in line
 *	buffering mode. Compensates stacking, i.e. will redirect the data from
 *	the specified channel to the topmost channel in a stack.
 *
 *	No encoding conversions are applied to the bytes being read.
 *
 * Results:
 *	The number of bytes written or TCL_INDEX_NONE in case of error. If
 *	TCL_INDEX_NONE, Tcl_GetErrno will return the error code.
 *
 * Side effects:
 *	May buffer up output and may cause output to be produced on the
 *	channel.
 *
 *----------------------------------------------------------------------
 */

func XTcl_Write(tls *libc.TLS, chan1 TTcl_Channel, src uintptr, srcLen TTcl_Size) (r TTcl_Size) {
	/* Length of data in bytes, or TCL_INDEX_NONE for
	 * strlen(). */
	var chanPtr, statePtr uintptr
	_, _ = chanPtr, statePtr /* State info for channel */
	statePtr = (*TChannel)(unsafe.Pointer(chan1)).Fstate
	chanPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr
	if _CheckChannelErrors(tls, statePtr, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
		return int64(-libc.Int32FromInt32(1))
	}
	if srcLen == int64(-libc.Int32FromInt32(1)) {
		srcLen = libc.Int64FromUint64(libc.Xstrlen(tls, src))
	}
	if _Write(tls, chanPtr, src, srcLen, XtclIdentityEncoding) == int64(-int32(1)) {
		return int64(-libc.Int32FromInt32(1))
	}
	return srcLen
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_WriteRaw --
 *
 *	Puts a sequence of bytes into an output buffer, may queue the buffer
 *	for output if it gets full, and also remembers whether the current
 *	buffer is ready e.g. if it contains a newline and we are in line
 *	buffering mode. Writes directly to the driver of the channel, does not
 *	compensate for stacking.
 *
 *	No encoding conversions are applied to the bytes being read.
 *
 * Results:
 *	The number of bytes written or TCL_INDEX_NONE in case of error. If
 *	TCL_INDEX_NONE, Tcl_GetErrno will return the error code.
 *
 * Side effects:
 *	May buffer up output and may cause output to be produced on the
 *	channel.
 *
 *----------------------------------------------------------------------
 */

func XTcl_WriteRaw(tls *libc.TLS, chan1 TTcl_Channel, src uintptr, srcLen TTcl_Size) (r TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Length of data in bytes, or TCL_INDEX_NONE for
	 * strlen(). */
	var chanPtr, statePtr uintptr
	var written TTcl_Size
	var _ /* errorCode at bp+0 */ int32
	_, _, _ = chanPtr, statePtr, written
	chanPtr = chan1
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	if _CheckChannelErrors(tls, statePtr, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(16)) != 0 {
		return int64(-libc.Int32FromInt32(1))
	}
	if srcLen == int64(-libc.Int32FromInt32(1)) {
		srcLen = libc.Int64FromUint64(libc.Xstrlen(tls, src))
	}
	/*
	 * Go immediately to the driver, do all the error handling by ourselves.
	 * The code was stolen from 'FlushChannel'.
	 */
	written = int64(_ChanWrite(tls, chanPtr, src, int32(srcLen), bp))
	if written == int64(-libc.Int32FromInt32(1)) {
		XTcl_SetErrno(tls, *(*int32)(unsafe.Pointer(bp)))
	}
	return written
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_WriteChars --
 *
 *	Takes a sequence of UTF-8 characters and converts them for output
 *	using the channel's current encoding, may queue the buffer for output
 *	if it gets full, and also remembers whether the current buffer is
 *	ready e.g. if it contains a newline and we are in line buffering
 *	mode. Compensates stacking, i.e. will redirect the data from the
 *	specified channel to the topmost channel in a stack.
 *
 * Results:
 *	The number of bytes written or TCL_INDEX_NONE in case of error. If
 *	TCL_INDEX_NONE, Tcl_GetErrno will return the error code.
 *
 * Side effects:
 *	May buffer up output and may cause output to be produced on the
 *	channel.
 *
 *----------------------------------------------------------------------
 */

func XTcl_WriteChars(tls *libc.TLS, chan1 TTcl_Channel, src uintptr, _len TTcl_Size) (r TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	*(*TTcl_Size)(unsafe.Pointer(bp)) = _len /* Length of string in bytes, or TCL_INDEX_NONE for
	 * strlen(). */
	var cachePtr, chanPtr, objPtr, statePtr, v2 uintptr
	var result, v1 TTcl_Size
	var v3 bool
	_, _, _, _, _, _, _, _ = cachePtr, chanPtr, objPtr, result, statePtr, v1, v2, v3
	chanPtr = chan1
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	if _CheckChannelErrors(tls, statePtr, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
		return int64(-libc.Int32FromInt32(1))
	}
	chanPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr
	if *(*TTcl_Size)(unsafe.Pointer(bp)) == int64(-libc.Int32FromInt32(1)) {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = libc.Int64FromUint64(libc.Xstrlen(tls, src))
	}
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fencoding != 0 {
		return _Write(tls, chanPtr, src, *(*TTcl_Size)(unsafe.Pointer(bp)), (*TChannelState1)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).Fstate)).Fencoding)
	}
	/*
	 * Inefficient way to convert UTF-8 to byte-array, but the code
	 * parallels the way it is done for objects.  Special case for 1-byte
	 * (used by e.g. [puts] for the \n) could be extended to more efficient
	 * translation of the src string.
	 */
	if *(*TTcl_Size)(unsafe.Pointer(bp)) == int64(1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) < int32(0xC0) {
		return _Write(tls, chanPtr, src, *(*TTcl_Size)(unsafe.Pointer(bp)), XtclIdentityEncoding)
	}
	objPtr = XTcl_NewStringObj(tls, src, *(*TTcl_Size)(unsafe.Pointer(bp)))
	src = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), objPtr, bp)
	if src == libc.UintptrFromInt32(0) {
		XTcl_SetErrno(tls, int32(EILSEQ))
		result = int64(-libc.Int32FromInt32(1))
	} else {
		result = _Write(tls, chanPtr, src, *(*TTcl_Size)(unsafe.Pointer(bp)), XtclIdentityEncoding)
	}
	v2 = objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if !(v1 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(-libc.Int32FromInt32(1))
			if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, objPtr)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = objPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, objPtr)
		}
	}
	return result
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_WriteObj --
 *
 *	Takes the Tcl object and queues its contents for output. If the
 *	encoding of the channel is NULL, takes the byte-array representation
 *	of the object and queues those bytes for output. Otherwise, takes the
 *	characters in the UTF-8 (string) representation of the object and
 *	converts them for output using the channel's current encoding. May
 *	flush internal buffers to output if one becomes full or is ready for
 *	some other reason, e.g. if it contains a newline and the channel is in
 *	line buffering mode.
 *
 * Results:
 *	The number of bytes written or TCL_INDEX_NONE in case of error. If
 *	TCL_INDEX_NONE, Tcl_GetErrno() will return the error code.
 *
 * Side effects:
 *	May buffer up output and may cause output to be produced on the
 *	channel.
 *
 *----------------------------------------------------------------------
 */

func XTcl_WriteObj(tls *libc.TLS, chan1 TTcl_Channel, objPtr uintptr) (r TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The object to write. */
	var chanPtr, src, statePtr, v1 uintptr
	var result TTcl_Size
	var _ /* srcLen at bp+0 */ TTcl_Size
	_, _, _, _, _ = chanPtr, result, src, statePtr, v1
	*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	statePtr = (*TChannel)(unsafe.Pointer(chan1)).Fstate
	chanPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr
	if _CheckChannelErrors(tls, statePtr, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
		return int64(-libc.Int32FromInt32(1))
	}
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fencoding == libc.UintptrFromInt32(0) {
		src = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), objPtr, bp)
		if src == libc.UintptrFromInt32(0) {
			XTcl_SetErrno(tls, int32(EILSEQ))
			result = int64(-libc.Int32FromInt32(1))
		} else {
			result = _Write(tls, chanPtr, src, *(*TTcl_Size)(unsafe.Pointer(bp)), XtclIdentityEncoding)
		}
		return result
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
			v1 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, objPtr, bp)
		}
		src = v1
		return _Write(tls, chanPtr, src, *(*TTcl_Size)(unsafe.Pointer(bp)), (*TChannelState1)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).Fstate)).Fencoding)
	}
	return r
}

func _WillWrite(tls *libc.TLS, chanPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var inputBuffered, v1 int32
	var v2 bool
	var _ /* ignore at bp+0 */ int32
	_, _, _ = inputBuffered, v1, v2
	if v2 = XTcl_ChannelWideSeekProc(tls, (*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr) != libc.UintptrFromInt32(0); v2 {
		v1 = XTcl_InputBuffered(tls, chanPtr)
		inputBuffered = v1
	}
	if v2 && v1 > 0 {
		_DiscardInputQueued(tls, (*TChannel)(unsafe.Pointer(chanPtr)).Fstate, 0)
		_ChanSeek(tls, chanPtr, int64(-inputBuffered), int32(1), bp)
	}
}

func _WillRead(tls *libc.TLS, chanPtr uintptr) (r int32) {
	if (*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr == libc.UintptrFromInt32(0) {
		/*
		 * Prevent read attempts on a closed channel.
		 */
		_DiscardInputQueued(tls, (*TChannel)(unsafe.Pointer(chanPtr)).Fstate, 0)
		XTcl_SetErrno(tls, int32(EINVAL))
		return -int32(1)
	}
	if XTcl_ChannelWideSeekProc(tls, (*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr) != libc.UintptrFromInt32(0) && XTcl_OutputBuffered(tls, chanPtr) > 0 {
		/*
		 * CAVEAT - The assumption here is that FlushChannel() will push out
		 * the bytes of any writes that are in progress.  Since this is a
		 * seekable channel, we assume it is not one that can block and force
		 * bg flushing.  Channels we know that can do that - sockets, pipes -
		 * are not seekable. If the assumption is wrong, more drastic measures
		 * may be required here like temporarily setting the channel into
		 * blocking mode.
		 */
		if _FlushChannel(tls, libc.UintptrFromInt32(0), chanPtr, 0) != 0 {
			return -int32(1)
		}
	}
	return 0
}

/*
 *----------------------------------------------------------------------
 *
 * Write --
 *
 *	Convert srcLen bytes starting at src according to encoding and write
 *	produced bytes into an output buffer, may queue the buffer for output
 *	if it gets full, and also remembers whether the current buffer is
 *	ready e.g. if it contains a newline and we are in line buffering mode.
 *
 * Results:
 *	The number of bytes written or TCL_INDEX_NONE in case of error. If TCL_INDEX_NONE,
 *	Tcl_GetErrno will return the error code.
 *
 * Side effects:
 *	May buffer up output and may cause output to be produced on the
 *	channel.
 *
 *----------------------------------------------------------------------
 */

func _Write(tls *libc.TLS, chanPtr uintptr, src uintptr, srcLen TTcl_Size, encoding TTcl_Encoding) (r TTcl_Size) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var bufPtr, dst, nextNewLine, nl, statePtr uintptr
	var dstLen, encodingError, endEncoding, needNlFlush, nlLen, result int32
	var flushed, saved, srcLimit, total TTcl_Size
	var _ /* dstWrote at bp+20 */ int32
	var _ /* safe at bp+0 */ [16]uint8
	var _ /* srcRead at bp+16 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bufPtr, dst, dstLen, encodingError, endEncoding, flushed, needNlFlush, nextNewLine, nl, nlLen, result, saved, srcLimit, statePtr, total
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	/* State info for channel */
	nextNewLine = libc.UintptrFromInt32(0)
	needNlFlush = 0
	saved = 0
	total = 0
	flushed = 0
	encodingError = 0
	if srcLen != 0 {
		_WillWrite(tls, chanPtr)
	}
	/*
	 * Write the terminated escape sequence even if srcLen is 0.
	 */
	endEncoding = libc.BoolInt32((*TChannelState)(unsafe.Pointer(statePtr)).FoutputEncodingFlags&int32(TCL_ENCODING_END) != 0)
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(17)) != 0 || (*TChannelState)(unsafe.Pointer(statePtr)).FoutputTranslation != int32(TCL_TRANSLATE_LF) {
		nextNewLine = libc.Xmemchr(tls, src, int32('\n'), libc.Uint64FromInt64(srcLen))
	}
	for srcLen+saved+int64(endEncoding) > 0 && !(encodingError != 0) {
		srcLimit = srcLen
		if nextNewLine != 0 {
			srcLimit = int64(nextNewLine) - int64(src)
		}
		/* Get space to write into */
		bufPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FcurOutPtr
		if bufPtr == libc.UintptrFromInt32(0) {
			bufPtr = _AllocChannelBuffer(tls, (*TChannelState)(unsafe.Pointer(statePtr)).FbufSize)
			(*TChannelState)(unsafe.Pointer(statePtr)).FcurOutPtr = bufPtr
		}
		if saved != 0 {
			/*
			 * Here's some translated bytes left over from the last buffer
			 * that we need to stick at the beginning of this buffer.
			 */
			libc.Xmemcpy(tls, bufPtr+40+uintptr((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded), bp, libc.Uint64FromInt64(saved))
			*(*TTcl_Size)(unsafe.Pointer(bufPtr + 8)) += saved
			saved = 0
		}
		dst = bufPtr + 40 + uintptr((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded)
		dstLen = int32((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FbufLength - (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded)
		result = XTcl_UtfToExternal(tls, libc.UintptrFromInt32(0), encoding, src, srcLimit, (*TChannelState)(unsafe.Pointer(statePtr)).FoutputEncodingFlags, statePtr+40, dst, int64(dstLen+int32(BUFFER_PADDING)), bp+16, bp+20, libc.UintptrFromInt32(0))
		/*
		 * See chan-io-1.[89]. Tcl Bug 506297.
		 */
		*(*int32)(unsafe.Pointer(statePtr + 48)) &= ^libc.Int32FromInt32(TCL_ENCODING_START)
		/*
		 * See io-75.2, TCL bug 6978c01b65.
		 * Check, if an encoding error occured and should be reported to the
		 * script level.
		 * This happens, if a written character may not be represented by the
		 * current output encoding and strict encoding is active.
		 */
		if result == -int32(3) || result == -int32(2) || result != TCL_OK && *(*int32)(unsafe.Pointer(bp + 16))+*(*int32)(unsafe.Pointer(bp + 20)) == 0 {
			encodingError = int32(1)
			result = TCL_OK
		}
		*(*TTcl_Size)(unsafe.Pointer(bufPtr + 8)) += int64(*(*int32)(unsafe.Pointer(bp + 20)))
		src += uintptr(*(*int32)(unsafe.Pointer(bp + 16)))
		srcLen -= int64(*(*int32)(unsafe.Pointer(bp + 16)))
		total += int64(*(*int32)(unsafe.Pointer(bp + 20)))
		dst += uintptr(*(*int32)(unsafe.Pointer(bp + 20)))
		dstLen -= *(*int32)(unsafe.Pointer(bp + 20))
		if src == nextNewLine && dstLen > 0 {
			nl = libc.UintptrFromInt32(0)
			nlLen = 0
			switch (*TChannelState)(unsafe.Pointer(statePtr)).FoutputTranslation {
			case int32(TCL_TRANSLATE_LF):
				nl = uintptr(unsafe.Pointer(&_crln)) + uintptr(1)
				nlLen = int32(1)
			case int32(TCL_TRANSLATE_CR):
				nl = uintptr(unsafe.Pointer(&_crln))
				nlLen = int32(1)
			case int32(TCL_TRANSLATE_CRLF):
				nl = uintptr(unsafe.Pointer(&_crln))
				nlLen = int32(2)
			default:
				XTcl_Panic(tls, __ccgo_ts+44299, 0)
				break
			}
			result |= XTcl_UtfToExternal(tls, libc.UintptrFromInt32(0), encoding, nl, int64(nlLen), (*TChannelState)(unsafe.Pointer(statePtr)).FoutputEncodingFlags, statePtr+40, dst, int64(dstLen+int32(BUFFER_PADDING)), bp+16, bp+20, libc.UintptrFromInt32(0))
			*(*TTcl_Size)(unsafe.Pointer(bufPtr + 8)) += int64(*(*int32)(unsafe.Pointer(bp + 20)))
			src++
			srcLen--
			total += int64(*(*int32)(unsafe.Pointer(bp + 20)))
			dst += uintptr(*(*int32)(unsafe.Pointer(bp + 20)))
			dstLen -= *(*int32)(unsafe.Pointer(bp + 20))
			nextNewLine = libc.Xmemchr(tls, src, int32('\n'), libc.Uint64FromInt64(srcLen))
			needNlFlush = int32(1)
		}
		if (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded > (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FbufLength {
			/*
			 * When translating from UTF-8 to external encoding, we allowed
			 * the translation to produce a character that crossed the end of
			 * the output buffer, so that we would get a completely full
			 * buffer before flushing it. The extra bytes will be moved to the
			 * beginning of the next buffer.
			 */
			saved = -((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FbufLength - (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded)
			libc.Xmemcpy(tls, bp, dst+uintptr(dstLen), libc.Uint64FromInt64(saved))
			(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded = (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FbufLength
		}
		if srcLen+saved == 0 && result == TCL_OK {
			endEncoding = 0
		}
		if bufPtr != 0 && (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded >= (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FbufLength {
			if _FlushChannel(tls, libc.UintptrFromInt32(0), chanPtr, 0) != 0 {
				return int64(-int32(1))
			}
			flushed += (*TChannelState)(unsafe.Pointer(statePtr)).FbufSize
			/*
			 * We just flushed.  So if we have needNlFlush set to record that
			 * we need to flush because there is a (translated) newline in the
			 * buffer, that's likely not true any more.  But there is a tricky
			 * exception.  If we have saved bytes that did not really get
			 * flushed and those bytes came from a translation of a newline as
			 * the last thing taken from the src array, then needNlFlush needs
			 * to remain set to flag that the next buffer still needs a
			 * newline flush.
			 */
			if needNlFlush != 0 && (saved == 0 || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + uintptr(-libc.Int32FromInt32(1))))) != int32('\n')) {
				needNlFlush = 0
			}
		}
	}
	if flushed < total && (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(18)) != 0 || needNlFlush != 0 && (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(17)) != 0 {
		if _FlushChannel(tls, libc.UintptrFromInt32(0), chanPtr, 0) != 0 {
			return int64(-int32(1))
		}
	}
	_UpdateInterest(tls, chanPtr)
	if encodingError != 0 {
		XTcl_SetErrno(tls, int32(EILSEQ))
		return int64(-int32(1))
	}
	return total
}

var _crln = [3]uint8{13, 10}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_Gets --
 *
 *	Reads a complete line of input from the channel into a Tcl_DString.
 *
 * Results:
 *	Length of line read (in characters) or TCL_INDEX_NONE if error, EOF, or blocked.
 *	If TCL_INDEX_NONE, use Tcl_GetErrno() to retrieve the POSIX error code for the
 *	error or condition that occurred.
 *
 * Side effects:
 *	May flush output on the channel. May cause input to be consumed from
 *	the channel.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_Gets(tls *libc.TLS, chan1 TTcl_Channel, lineRead uintptr) (r TTcl_Size) {
	/* The line read will be appended to this
	 * DString as UTF-8 characters. The caller
	 * must have initialized it and is responsible
	 * for managing the storage. */
	var cachePtr, cachePtr1, objPtr, v3 uintptr
	var charsStored, v2 TTcl_Size
	var v1, v4 bool
	_, _, _, _, _, _, _, _ = cachePtr, cachePtr1, charsStored, objPtr, v1, v2, v3, v4
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	charsStored = XTcl_GetsObj(tls, chan1, objPtr)
	if charsStored > 0 {
		XTclDStringAppendObj(tls, lineRead, objPtr)
	}
	v3 = objPtr
	v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
	*(*TTcl_Size)(unsafe.Pointer(v3))--
	if !(v2 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(-libc.Int32FromInt32(1))
			if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v4 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, objPtr)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = objPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, objPtr)
		}
	}
	return charsStored
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_GetsObj --
 *
 *	Accumulate input from the input channel until end-of-line or
 *	end-of-file has been seen. Bytes read from the input channel are
 *	converted to UTF-8 using the encoding specified by the channel.
 *
 * Results:
 *	Number of characters accumulated in the object or TCL_INDEX_NONE if error,
 *	blocked, or EOF. If TCL_INDEX_NONE, use Tcl_GetErrno() to retrieve the POSIX error
 *	code for the error or condition that occurred.
 *
 * Side effects:
 *	Consumes input from the channel.
 *
 *	On reading EOF, leave channel pointing at EOF char. On reading EOL,
 *	leave channel pointing after EOL, but don't return EOL in dst buffer.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_GetsObj(tls *libc.TLS, chan1 TTcl_Channel, objPtr uintptr) (r TTcl_Size) {
	bp := tls.Alloc(96)
	defer tls.Free(96) /* The line read will be appended to this
	 * object as UTF-8 characters. */
	var bufPtr, chanPtr, eof, eol, statePtr uintptr
	var copiedTotal, inEofChar, offset1, oldFlags, oldRemoved, skip int32
	var encoding TTcl_Encoding
	var offset TTcl_Size
	var oldState TTcl_EncodingState
	var _ /* dst at bp+64 */ uintptr
	var _ /* dstEnd at bp+72 */ uintptr
	var _ /* gs at bp+0 */ TGetsState
	var _ /* oldLength at bp+56 */ TTcl_Size
	var _ /* rawRead at bp+80 */ int32
	var _ /* tmp at bp+84 */ [4]uint8
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = bufPtr, chanPtr, copiedTotal, encoding, eof, eol, inEofChar, offset, offset1, oldFlags, oldRemoved, oldState, skip, statePtr
	chanPtr = chan1
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(15)) != 0 {
		_UpdateInterest(tls, chanPtr)
		*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1)<<libc.Int32FromInt32(9) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(15))
		XTcl_SetErrno(tls, int32(EILSEQ))
		return int64(-libc.Int32FromInt32(1))
	}
	if _CheckChannelErrors(tls, statePtr, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
		return int64(-libc.Int32FromInt32(1))
	}
	/*
	 * If we're sitting ready to read the eofchar, there's no need to
	 * do it.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(10)) != 0 {
		*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(9)
		/* TODO: Do we need this? */
		_UpdateInterest(tls, chanPtr)
		return int64(-libc.Int32FromInt32(1))
	}
	/*
	 * A binary version of Tcl_GetsObj. This could also handle encodings that
	 * are ascii-7 pure (iso8859, utf-8, ...) with a final encoding conversion
	 * done on objPtr.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fencoding == _GetBinaryEncoding(tls) && ((*TChannelState)(unsafe.Pointer(statePtr)).FinputTranslation == int32(TCL_TRANSLATE_LF) || (*TChannelState)(unsafe.Pointer(statePtr)).FinputTranslation == int32(TCL_TRANSLATE_CR)) && XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), objPtr, libc.UintptrFromInt32(0)) != libc.UintptrFromInt32(0) {
		return int64(_TclGetsObjBinary(tls, chan1, objPtr))
	}
	/*
	 * This operation should occur at the top of a channel stack.
	 */
	chanPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr
	XTclChannelPreserve(tls, chanPtr)
	bufPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead
	encoding = (*TChannelState)(unsafe.Pointer(statePtr)).Fencoding
	/*
	 * Preserved so we can restore the channel's state in case we don't find a
	 * newline in the available input.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 56)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
		_ = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		XTcl_GetStringFromObj(tls, objPtr, bp+56)
	}
	oldFlags = (*TChannelState)(unsafe.Pointer(statePtr)).FinputEncodingFlags
	oldState = (*TChannelState)(unsafe.Pointer(statePtr)).FinputEncodingState
	oldRemoved = int32(BUFFER_PADDING)
	if bufPtr != libc.UintptrFromInt32(0) {
		oldRemoved = int32((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved)
	}
	/*
	 * Object used by FilterInputBytes to keep track of how much data has been
	 * consumed from the channel buffers.
	 */
	(*(*TGetsState)(unsafe.Pointer(bp))).FobjPtr = objPtr
	(*(*TGetsState)(unsafe.Pointer(bp))).FdstPtr = bp + 64
	(*(*TGetsState)(unsafe.Pointer(bp))).Fencoding = encoding
	(*(*TGetsState)(unsafe.Pointer(bp))).FbufPtr = bufPtr
	(*(*TGetsState)(unsafe.Pointer(bp))).Fstate = oldState
	(*(*TGetsState)(unsafe.Pointer(bp))).FrawRead = 0
	(*(*TGetsState)(unsafe.Pointer(bp))).FbytesWrote = 0
	(*(*TGetsState)(unsafe.Pointer(bp))).FcharsWrote = 0
	(*(*TGetsState)(unsafe.Pointer(bp))).FtotalChars = 0
	*(*uintptr)(unsafe.Pointer(bp + 64)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 56)))
	*(*uintptr)(unsafe.Pointer(bp + 72)) = *(*uintptr)(unsafe.Pointer(bp + 64))
	skip = 0
	eof = libc.UintptrFromInt32(0)
	inEofChar = (*TChannelState)(unsafe.Pointer(statePtr)).FinEofChar
	*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(11))
	for int32(1) != 0 {
		if *(*uintptr)(unsafe.Pointer(bp + 64)) >= *(*uintptr)(unsafe.Pointer(bp + 72)) {
			/*
			 * In case of encoding errors, state gets flag
			 * CHANNEL_ENCODING_ERROR set in the call below. First, the
			 * EOF/EOL condition is checked, as we may have valid data with
			 * EOF/EOL before the encoding error.
			 */
			if _FilterInputBytes(tls, chanPtr, bp) != 0 {
				goto restore
			}
			*(*uintptr)(unsafe.Pointer(bp + 72)) = *(*uintptr)(unsafe.Pointer(bp + 64)) + uintptr((*(*TGetsState)(unsafe.Pointer(bp))).FbytesWrote)
		}
		/*
		 * Remember if EOF char is seen, then look for EOL anyhow, because the
		 * EOL might be before the EOF char.
		 */
		if inEofChar != int32('\000') {
			eol = *(*uintptr)(unsafe.Pointer(bp + 64))
			for {
				if !(eol < *(*uintptr)(unsafe.Pointer(bp + 72))) {
					break
				}
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(eol))) == inEofChar {
					*(*uintptr)(unsafe.Pointer(bp + 72)) = eol
					eof = eol
					break
				}
				goto _2
			_2:
				;
				eol++
			}
		}
		/*
		 * On EOL, leave current file position pointing after the EOL, but
		 * don't store the EOL in the output string.
		 */
		switch (*TChannelState)(unsafe.Pointer(statePtr)).FinputTranslation {
		case int32(TCL_TRANSLATE_LF):
			goto _3
		case int32(TCL_TRANSLATE_CR):
			goto _4
		case int32(TCL_TRANSLATE_CRLF):
			goto _5
		case int32(TCL_TRANSLATE_AUTO):
			goto _6
		}
		goto _7
	_3:
		;
		eol = *(*uintptr)(unsafe.Pointer(bp + 64))
	_10:
		;
		if !(eol < *(*uintptr)(unsafe.Pointer(bp + 72))) {
			goto _8
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(eol))) == int32('\n') {
			skip = int32(1)
			goto gotEOL
		}
		goto _9
	_9:
		;
		eol++
		goto _10
		goto _8
	_8:
		;
		goto _7
	_4:
		;
		eol = *(*uintptr)(unsafe.Pointer(bp + 64))
		for {
			if !(eol < *(*uintptr)(unsafe.Pointer(bp + 72))) {
				break
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(eol))) == int32('\r') {
				skip = int32(1)
				goto gotEOL
			}
			goto _11
		_11:
			;
			eol++
		}
		goto _7
	_5:
		;
		eol = *(*uintptr)(unsafe.Pointer(bp + 64))
		for {
			if !(eol < *(*uintptr)(unsafe.Pointer(bp + 72))) {
				break
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(eol))) == int32('\r') {
				eol++
				/*
				 * If a CR is at the end of the buffer, then check for a
				 * LF at the beginning of the next buffer, unless EOF char
				 * was found already.
				 */
				if eol >= *(*uintptr)(unsafe.Pointer(bp + 72)) {
					if eol != eof {
						offset = int64(eol) - int64((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes)
						*(*uintptr)(unsafe.Pointer(bp + 64)) = *(*uintptr)(unsafe.Pointer(bp + 72))
						if _FilterInputBytes(tls, chanPtr, bp) != 0 {
							goto restore
						}
						*(*uintptr)(unsafe.Pointer(bp + 72)) = *(*uintptr)(unsafe.Pointer(bp + 64)) + uintptr((*(*TGetsState)(unsafe.Pointer(bp))).FbytesWrote)
						eol = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr(offset)
					}
					if eol >= *(*uintptr)(unsafe.Pointer(bp + 72)) {
						skip = 0
						goto gotEOL
					}
				}
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(eol))) == int32('\n') {
					eol--
					skip = int32(2)
					goto gotEOL
				}
			}
			goto _12
		_12:
			;
			eol++
		}
		goto _7
	_6:
		;
		eol = *(*uintptr)(unsafe.Pointer(bp + 64))
		skip = int32(1)
		if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(12)) != 0 {
			if eol < *(*uintptr)(unsafe.Pointer(bp + 72)) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(eol))) == int32('\n') {
				bufPtr = (*(*TGetsState)(unsafe.Pointer(bp))).FbufPtr
				XTcl_ExternalToUtf(tls, libc.UintptrFromInt32(0), (*(*TGetsState)(unsafe.Pointer(bp))).Fencoding, bufPtr+40+uintptr((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved), int64((*(*TGetsState)(unsafe.Pointer(bp))).FrawRead), (*TChannelState)(unsafe.Pointer(statePtr)).FinputEncodingFlags|int32(TCL_ENCODING_NO_TERMINATE), bp+32, bp+84, int64(4), bp+80, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
				*(*TTcl_Size)(unsafe.Pointer(bufPtr + 16)) += int64(*(*int32)(unsafe.Pointer(bp + 80)))
				(*(*TGetsState)(unsafe.Pointer(bp))).FrawRead -= *(*int32)(unsafe.Pointer(bp + 80))
				(*(*TGetsState)(unsafe.Pointer(bp))).FbytesWrote--
				(*(*TGetsState)(unsafe.Pointer(bp))).FcharsWrote--
				libc.Xmemmove(tls, *(*uintptr)(unsafe.Pointer(bp + 64)), *(*uintptr)(unsafe.Pointer(bp + 64))+uintptr(1), libc.Uint64FromInt64(int64(*(*uintptr)(unsafe.Pointer(bp + 72)))-int64(*(*uintptr)(unsafe.Pointer(bp + 64)))))
				*(*uintptr)(unsafe.Pointer(bp + 72))--
			}
		}
		eol = *(*uintptr)(unsafe.Pointer(bp + 64))
		for {
			if !(eol < *(*uintptr)(unsafe.Pointer(bp + 72))) {
				break
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(eol))) == int32('\r') {
				eol++
				if eol == *(*uintptr)(unsafe.Pointer(bp + 72)) {
					/*
					 * If buffer ended on \r, peek ahead to see if a \n is
					 * available, unless EOF char was found already.
					 */
					if eol != eof {
						offset1 = int32(int64(eol) - int64((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes))
						*(*uintptr)(unsafe.Pointer(bp + 64)) = *(*uintptr)(unsafe.Pointer(bp + 72))
						_PeekAhead(tls, chanPtr, bp+72, bp)
						eol = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr(offset1)
					}
					if eol >= *(*uintptr)(unsafe.Pointer(bp + 72)) {
						eol--
						*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(12)
						goto gotEOL
					}
				}
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(eol))) == int32('\n') {
					skip++
				}
				eol--
				*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(12))
				goto gotEOL
			} else {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(eol))) == int32('\n') {
					*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(12))
					goto gotEOL
				}
			}
			goto _13
		_13:
			;
			eol++
		}
	_7:
		;
		if eof != libc.UintptrFromInt32(0) {
			/*
			 * EOF character was seen. On EOF, leave current file position
			 * pointing at the EOF character, but don't store the EOF
			 * character in the output string.
			 */
			*(*uintptr)(unsafe.Pointer(bp + 72)) = eof
			*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1)<<libc.Int32FromInt32(9) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(10)
			*(*int32)(unsafe.Pointer(statePtr + 32)) |= int32(TCL_ENCODING_END)
			*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1)<<libc.Int32FromInt32(11) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(12))
		}
		if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(9)) != 0 {
			skip = 0
			eol = *(*uintptr)(unsafe.Pointer(bp + 72))
			if eol == (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes+uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 56))) {
				/*
				 * If we didn't append any bytes before encountering EOF,
				 * caller needs to see -1.
				 */
				XTcl_SetObjLength(tls, objPtr, *(*TTcl_Size)(unsafe.Pointer(bp + 56)))
				_CommonGetsCleanup(tls, chanPtr)
				copiedTotal = -int32(1)
				*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1)<<libc.Int32FromInt32(11) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(12))
				goto done
			}
			goto gotEOL
		} else {
			if (*(*TGetsState)(unsafe.Pointer(bp))).FbytesWrote == 0 && (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(15)) != 0 {
				/* Ticket c4eb46a1 Harald Oehlmann 2023-11-12 debugging session.
				 * In non blocking mode we loop indifenitly on a decoding error in
				 * this while-loop.
				 * Removed the following from the upper condition:
				 * "&& !GotFlag(statePtr, CHANNEL_NONBLOCKING)"
				 * In case of an encoding error with leading correct bytes, we pass here
				 * two times, as gs.bytesWrote is not 0 on the first pass. This feels
				 * once to much, as the data is anyway not used.
				 */
				/* Set eol to the position that caused the encoding error, and then
				 * continue to gotEOL, which stores the data that was decoded
				 * without error to objPtr.  This allows the caller to do something
				 * useful with the data decoded so far, and also results in the
				 * position of the file being the first byte that was not
				 * successfully decoded, allowing further processing at exactly that
				 * point, if desired.
				 */
				eol = *(*uintptr)(unsafe.Pointer(bp + 72))
				goto gotEOL
			}
		}
		*(*uintptr)(unsafe.Pointer(bp + 64)) = *(*uintptr)(unsafe.Pointer(bp + 72))
	}
	/*
	 * Found EOL or EOF, but the output buffer may now contain too many UTF-8
	 * characters. We need to know how many raw bytes correspond to the number
	 * of UTF-8 characters we want, plus how many raw bytes correspond to the
	 * character(s) making up EOL (if any), so we can remove the correct
	 * number of bytes from the channel buffer.
	 */
	goto gotEOL
gotEOL:
	;
	/*
	 * Regenerate the top channel, in case it was changed due to
	 * self-modifying reflected transforms.
	 */
	if chanPtr != (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr {
		XTclChannelRelease(tls, chanPtr)
		chanPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr
		XTclChannelPreserve(tls, chanPtr)
	}
	bufPtr = (*(*TGetsState)(unsafe.Pointer(bp))).FbufPtr
	if bufPtr == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+44336, 0)
	}
	(*TChannelState)(unsafe.Pointer(statePtr)).FinputEncodingState = (*(*TGetsState)(unsafe.Pointer(bp))).Fstate
	XTcl_ExternalToUtf(tls, libc.UintptrFromInt32(0), (*(*TGetsState)(unsafe.Pointer(bp))).Fencoding, bufPtr+40+uintptr((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved), int64((*(*TGetsState)(unsafe.Pointer(bp))).FrawRead), (*TChannelState)(unsafe.Pointer(statePtr)).FinputEncodingFlags|int32(TCL_ENCODING_NO_TERMINATE), statePtr+24, *(*uintptr)(unsafe.Pointer(bp + 64)), int64(eol)-int64(*(*uintptr)(unsafe.Pointer(bp + 64)))+int64(skip)+int64(TCL_UTF_MAX)-int64(1), bp+40, libc.UintptrFromInt32(0), bp+48)
	*(*TTcl_Size)(unsafe.Pointer(bufPtr + 16)) += int64((*(*TGetsState)(unsafe.Pointer(bp))).FrawRead)
	/*
	 * Recycle all the emptied buffers.
	 */
	XTcl_SetObjLength(tls, objPtr, int64(eol)-int64((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes))
	_CommonGetsCleanup(tls, chanPtr)
	*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(11))
	copiedTotal = (*(*TGetsState)(unsafe.Pointer(bp))).FtotalChars + (*(*TGetsState)(unsafe.Pointer(bp))).FcharsWrote - skip
	goto done
	/*
	 * Couldn't get a complete line. This only happens if we get a error
	 * reading from the channel or we are non-blocking and there wasn't an EOL
	 * or EOF in the data available.
	 */
	goto restore
restore:
	;
	/*
	 * Regenerate the top channel, in case it was changed due to
	 * self-modifying reflected transforms.
	 */
	if chanPtr != (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr {
		XTclChannelRelease(tls, chanPtr)
		chanPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr
		XTclChannelPreserve(tls, chanPtr)
	}
	bufPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead
	if bufPtr != libc.UintptrFromInt32(0) {
		(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved = int64(oldRemoved)
		bufPtr = (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr
	}
	for {
		if !(bufPtr != libc.UintptrFromInt32(0)) {
			break
		}
		(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved = int64(BUFFER_PADDING)
		goto _14
	_14:
		;
		bufPtr = (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr
	}
	_CommonGetsCleanup(tls, chanPtr)
	(*TChannelState)(unsafe.Pointer(statePtr)).FinputEncodingState = oldState
	(*TChannelState)(unsafe.Pointer(statePtr)).FinputEncodingFlags = oldFlags
	XTcl_SetObjLength(tls, objPtr, *(*TTcl_Size)(unsafe.Pointer(bp + 56)))
	/*
	 * We didn't get a complete line so we need to indicate to UpdateInterest
	 * that the gets blocked. It will wait for more data instead of firing a
	 * timer, avoiding a busy wait. This is where we are assuming that the
	 * next operation is a gets. No more file events will be delivered on this
	 * channel until new data arrives or some operation is performed on the
	 * channel (e.g. gets, read, fconfigure) that changes the blocking state.
	 * Note that this means a file event will not be delivered even though a
	 * read would be able to consume the buffered data.
	 */
	*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(14)
	copiedTotal = -int32(1)
	/*
	 * Update the notifier state so we don't block while there is still data
	 * in the buffers.
	 */
	goto done
done:
	;
	/*
	 * Regenerate the top channel, in case it was changed due to
	 * self-modifying reflected transforms.
	 */
	if chanPtr != (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr {
		XTclChannelRelease(tls, chanPtr)
		chanPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr
		XTclChannelPreserve(tls, chanPtr)
	}
	_UpdateInterest(tls, chanPtr)
	XTclChannelRelease(tls, chanPtr)
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(15)) != 0 && (*(*TGetsState)(unsafe.Pointer(bp))).FbytesWrote == 0 {
		(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved = int64(oldRemoved)
		XTcl_SetErrno(tls, int32(EILSEQ))
		copiedTotal = -int32(1)
	}
	*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(15))
	return int64(copiedTotal)
}

/*
 *---------------------------------------------------------------------------
 *
 * TclGetsObjBinary --
 *
 *	A variation of Tcl_GetsObj that works directly on the buffers until
 *	end-of-line or end-of-file has been seen. Bytes read from the input
 *	channel return as a ByteArray obj.
 *
 *	WARNING!  The notion of "binary" used here is different from notions
 *	of "binary" used in other places. In particular, this "binary" routine
 *	may be called when an -eofchar is set on the channel.
 *
 * Results:
 *	Number of characters accumulated in the object or TCL_INDEX_NONE if error,
 *	blocked, or EOF. If TCL_INDEX_NONE, use Tcl_GetErrno() to retrieve the POSIX error
 *	code for the error or condition that occurred.
 *
 * Side effects:
 *	Consumes input from the channel.
 *
 *	On reading EOF, leave channel pointing at EOF char. On reading EOL,
 *	leave channel pointing after EOL, but don't return EOL in dst buffer.
 *
 *---------------------------------------------------------------------------
 */

func _TclGetsObjBinary(tls *libc.TLS, chan1 TTcl_Channel, objPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The line read will be appended to this
	 * object as UTF-8 characters. */
	var bufPtr, byteArray, chanPtr, dst, dstEnd, eof, eol, statePtr uintptr
	var copiedTotal, eolChar, inEofChar, oldFlags, oldRemoved, skip, v1 int32
	var oldLength, rawLen TTcl_Size
	var _ /* byteLen at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bufPtr, byteArray, chanPtr, copiedTotal, dst, dstEnd, eof, eol, eolChar, inEofChar, oldFlags, oldLength, oldRemoved, rawLen, skip, statePtr, v1
	chanPtr = chan1
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	/*
	 * This operation should occur at the top of a channel stack.
	 */
	chanPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr
	XTclChannelPreserve(tls, chanPtr)
	bufPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead
	/*
	 * Preserved so we can restore the channel's state in case we don't find a
	 * newline in the available input.
	 */
	byteArray = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), objPtr, bp)
	if byteArray == libc.UintptrFromInt32(0) {
		XTcl_SetErrno(tls, int32(EILSEQ))
		return -int32(1)
	}
	oldFlags = (*TChannelState)(unsafe.Pointer(statePtr)).FinputEncodingFlags
	oldRemoved = int32(BUFFER_PADDING)
	oldLength = *(*TTcl_Size)(unsafe.Pointer(bp))
	if bufPtr != libc.UintptrFromInt32(0) {
		oldRemoved = int32((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved)
	}
	rawLen = 0
	skip = 0
	eof = libc.UintptrFromInt32(0)
	inEofChar = (*TChannelState)(unsafe.Pointer(statePtr)).FinEofChar
	/*
	 * Only handle TCL_TRANSLATE_LF and TCL_TRANSLATE_CR.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).FinputTranslation == int32(TCL_TRANSLATE_LF) {
		v1 = int32('\n')
	} else {
		v1 = int32('\r')
	}
	eolChar = v1
	*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(11))
	for int32(1) != 0 {
		/*
		 * Subtract the number of bytes that were removed from channel buffer
		 * during last call.
		 */
		if bufPtr != libc.UintptrFromInt32(0) {
			*(*TTcl_Size)(unsafe.Pointer(bufPtr + 16)) += rawLen
			if !((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded > (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved) {
				bufPtr = (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr
			}
		}
		if bufPtr == libc.UintptrFromInt32(0) || (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded == int64(BUFFER_PADDING) {
			/*
			 * All channel buffers were exhausted and the caller still hasn't
			 * seen EOL. Need to read more bytes from the channel device. Side
			 * effect is to allocate another channel buffer.
			 */
			if _GetInput(tls, chanPtr) != 0 {
				goto restore
			}
			bufPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueTail
			if bufPtr == libc.UintptrFromInt32(0) {
				goto restore
			}
		} else {
			/*
			 * Incoming CHANNEL_STICKY_EOF is filtered out on entry.  A new
			 * CHANNEL_STICKY_EOF set in this routine leads to return before
			 * coming back here.  When we are not dealing with
			 * CHANNEL_STICKY_EOF, a CHANNEL_EOF implies an empty buffer.
			 * Here the buffer is non-empty so we know we're a non-EOF.
			 */
		}
		dst = bufPtr + 40 + uintptr((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved)
		dstEnd = dst + uintptr((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded-(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved)
		/*
		 * Remember if EOF char is seen, then look for EOL anyhow, because the
		 * EOL might be before the EOF char.
		 * XXX - in the binary case, consider coincident search for eol/eof.
		 */
		if inEofChar != int32('\000') {
			eol = dst
			for {
				if !(eol < dstEnd) {
					break
				}
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(eol))) == inEofChar {
					dstEnd = eol
					eof = eol
					break
				}
				goto _2
			_2:
				;
				eol++
			}
		}
		/*
		 * On EOL, leave current file position pointing after the EOL, but
		 * don't store the EOL in the output string.
		 */
		eol = dst
		for {
			if !(eol < dstEnd) {
				break
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(eol))) == eolChar {
				skip = int32(1)
				goto gotEOL
			}
			goto _3
		_3:
			;
			eol++
		}
		if eof != libc.UintptrFromInt32(0) {
			/*
			 * EOF character was seen. On EOF, leave current file position
			 * pointing at the EOF character, but don't store the EOF
			 * character in the output string.
			 */
			*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1)<<libc.Int32FromInt32(9) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(10)
			*(*int32)(unsafe.Pointer(statePtr + 32)) |= int32(TCL_ENCODING_END)
			*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1)<<libc.Int32FromInt32(11) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(12))
		}
		if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(9)) != 0 {
			skip = 0
			eol = dstEnd
			if dst == dstEnd && *(*TTcl_Size)(unsafe.Pointer(bp)) == oldLength {
				/*
				 * If we didn't append any bytes before encountering EOF,
				 * caller needs to see TCL_INDEX_NONE.
				 */
				byteArray = XTcl_SetByteArrayLength(tls, objPtr, oldLength)
				_CommonGetsCleanup(tls, chanPtr)
				copiedTotal = -int32(1)
				*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(11))
				goto done
			}
			goto gotEOL
		}
		if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(11)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(6)) == libc.Int32FromInt32(1)<<libc.Int32FromInt32(11)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(6) {
			goto restore
		}
		/*
		 * Copy bytes from the channel buffer to the ByteArray. This may
		 * realloc space, so keep track of result.
		 */
		rawLen = int64(dstEnd) - int64(dst)
		byteArray = XTcl_SetByteArrayLength(tls, objPtr, *(*TTcl_Size)(unsafe.Pointer(bp))+rawLen)
		libc.Xmemcpy(tls, byteArray+uintptr(*(*TTcl_Size)(unsafe.Pointer(bp))), dst, libc.Uint64FromInt64(rawLen))
		*(*TTcl_Size)(unsafe.Pointer(bp)) += rawLen
	}
	/*
	 * Found EOL or EOF, but the output buffer may now contain too many bytes.
	 * We need to know how many bytes correspond to the number we want, so we
	 * can remove the correct number of bytes from the channel buffer.
	 */
	goto gotEOL
gotEOL:
	;
	if bufPtr == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+44382, 0)
	}
	rawLen = int64(eol) - int64(dst)
	byteArray = XTcl_SetByteArrayLength(tls, objPtr, *(*TTcl_Size)(unsafe.Pointer(bp))+rawLen)
	libc.Xmemcpy(tls, byteArray+uintptr(*(*TTcl_Size)(unsafe.Pointer(bp))), dst, libc.Uint64FromInt64(rawLen))
	*(*TTcl_Size)(unsafe.Pointer(bp)) += rawLen
	*(*TTcl_Size)(unsafe.Pointer(bufPtr + 16)) += rawLen + int64(skip)
	/*
	 * Convert the buffer if there was an encoding.
	 * XXX - unimplemented.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fencoding != _GetBinaryEncoding(tls) {
	}
	/*
	 * Recycle all the emptied buffers.
	 */
	_CommonGetsCleanup(tls, chanPtr)
	*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(11))
	copiedTotal = int32(*(*TTcl_Size)(unsafe.Pointer(bp)))
	goto done
	/*
	 * Couldn't get a complete line. This only happens if we get a error
	 * reading from the channel or we are non-blocking and there wasn't an EOL
	 * or EOF in the data available.
	 */
	goto restore
restore:
	;
	bufPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead
	if bufPtr != 0 {
		(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved = int64(oldRemoved)
		bufPtr = (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr
	}
	for {
		if !(bufPtr != libc.UintptrFromInt32(0)) {
			break
		}
		(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved = int64(BUFFER_PADDING)
		goto _4
	_4:
		;
		bufPtr = (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr
	}
	_CommonGetsCleanup(tls, chanPtr)
	(*TChannelState)(unsafe.Pointer(statePtr)).FinputEncodingFlags = oldFlags
	byteArray = XTcl_SetByteArrayLength(tls, objPtr, oldLength)
	/*
	 * We didn't get a complete line so we need to indicate to UpdateInterest
	 * that the gets blocked. It will wait for more data instead of firing a
	 * timer, avoiding a busy wait. This is where we are assuming that the
	 * next operation is a gets. No more file events will be delivered on this
	 * channel until new data arrives or some operation is performed on the
	 * channel (e.g. gets, read, fconfigure) that changes the blocking state.
	 * Note that this means a file event will not be delivered even though a
	 * read would be able to consume the buffered data.
	 */
	*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(14)
	copiedTotal = -int32(1)
	/*
	 * Update the notifier state so we don't block while there is still data
	 * in the buffers.
	 */
	goto done
done:
	;
	_UpdateInterest(tls, chanPtr)
	XTclChannelRelease(tls, chanPtr)
	return copiedTotal
}

/*
 *---------------------------------------------------------------------------
 *
 * FreeBinaryEncoding --
 *
 *	Frees any "iso8859-1" Tcl_Encoding created by [gets] on a binary
 *	channel in a thread as part of that thread's finalization.
 *
 * Results:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func _FreeBinaryEncoding(tls *libc.TLS) {
	var tsdPtr uintptr
	_ = tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey2)), int64(64))
	if (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FbinaryEncoding != libc.UintptrFromInt32(0) {
		XTcl_FreeEncoding(tls, (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FbinaryEncoding)
		(*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FbinaryEncoding = libc.UintptrFromInt32(0)
	}
}

func _GetBinaryEncoding(tls *libc.TLS) (r TTcl_Encoding) {
	var tsdPtr uintptr
	_ = tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey2)), int64(64))
	if (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FbinaryEncoding == libc.UintptrFromInt32(0) {
		(*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FbinaryEncoding = XTcl_GetEncoding(tls, libc.UintptrFromInt32(0), __ccgo_ts+29173)
	}
	if (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FbinaryEncoding == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+44433, 0)
	}
	return (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FbinaryEncoding
}

/*
 *---------------------------------------------------------------------------
 *
 * FilterInputBytes --
 *
 *	Helper function for Tcl_GetsObj. Produces UTF-8 characters from raw
 *	bytes read from the channel.
 *
 *	Consumes available bytes from channel buffers. When channel buffers
 *	are exhausted, reads more bytes from channel device into a new channel
 *	buffer. It is the caller's responsibility to free the channel buffers
 *	that have been exhausted.
 *
 * Results:
 *	The return value is -1 if there was an error reading from the channel,
 *	0 otherwise.
 *
 * Side effects:
 *	Status object keeps track of how much data from channel buffers has
 *	been consumed and where UTF-8 bytes should be stored.
 *
 *---------------------------------------------------------------------------
 */

func _FilterInputBytes(tls *libc.TLS, chanPtr uintptr, gsPtr uintptr) (r int32) {
	/* Current state of gets operation. */
	var bufPtr, dst, nextPtr, objPtr, raw, statePtr uintptr
	var dstNeeded, extra, length, offset, rawLen, result, spaceLeft, toRead, v3 int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bufPtr, dst, dstNeeded, extra, length, nextPtr, objPtr, offset, raw, rawLen, result, spaceLeft, statePtr, toRead, v3
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	objPtr = (*TGetsState)(unsafe.Pointer(gsPtr)).FobjPtr
	/*
	 * Subtract the number of bytes that were removed from channel buffer
	 * during last call.
	 */
	bufPtr = (*TGetsState)(unsafe.Pointer(gsPtr)).FbufPtr
	if bufPtr != libc.UintptrFromInt32(0) {
		*(*TTcl_Size)(unsafe.Pointer(bufPtr + 16)) += int64((*TGetsState)(unsafe.Pointer(gsPtr)).FrawRead)
		if !((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded > (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved) {
			bufPtr = (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr
		}
	}
	*(*int32)(unsafe.Pointer(gsPtr + 52)) += (*TGetsState)(unsafe.Pointer(gsPtr)).FcharsWrote
	if !(bufPtr == libc.UintptrFromInt32(0) || (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded == int64(BUFFER_PADDING)) {
		goto _1
	}
	/*
	 * All channel buffers were exhausted and the caller still hasn't seen
	 * EOL. Need to read more bytes from the channel device. Side effect
	 * is to allocate another channel buffer.
	 */
	goto read
read:
	;
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(6)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(11)) == libc.Int32FromInt32(1)<<libc.Int32FromInt32(6)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(11) {
		(*TGetsState)(unsafe.Pointer(gsPtr)).FcharsWrote = 0
		(*TGetsState)(unsafe.Pointer(gsPtr)).FrawRead = 0
		return -int32(1)
	}
	if _GetInput(tls, chanPtr) != 0 {
		(*TGetsState)(unsafe.Pointer(gsPtr)).FcharsWrote = 0
		(*TGetsState)(unsafe.Pointer(gsPtr)).FrawRead = 0
		return -int32(1)
	}
	bufPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueTail
	(*TGetsState)(unsafe.Pointer(gsPtr)).FbufPtr = bufPtr
	if bufPtr == libc.UintptrFromInt32(0) {
		(*TGetsState)(unsafe.Pointer(gsPtr)).FcharsWrote = 0
		(*TGetsState)(unsafe.Pointer(gsPtr)).FrawRead = 0
		return -int32(1)
	}
	goto _2
_1:
	;
	/*
	 * Incoming CHANNEL_STICKY_EOF is filtered out on entry.  A new
	 * CHANNEL_STICKY_EOF set in this routine leads to return before
	 * coming back here.  When we are not dealing with CHANNEL_STICKY_EOF,
	 * a CHANNEL_EOF implies an empty buffer.  Here the buffer is
	 * non-empty so we know we're a non-EOF.
	 */
_2:
	;
	/*
	 * Convert some of the bytes from the channel buffer to UTF-8. Space in
	 * objPtr's string rep is used to hold the UTF-8 characters. Grow the
	 * string rep if we need more space.
	 */
	raw = bufPtr + 40 + uintptr((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved)
	rawLen = int32((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded - (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved)
	dst = *(*uintptr)(unsafe.Pointer((*TGetsState)(unsafe.Pointer(gsPtr)).FdstPtr))
	offset = int32(int64(dst) - int64((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes))
	toRead = int32(ENCODING_LINESIZE)
	if toRead > rawLen {
		toRead = rawLen
	}
	dstNeeded = toRead * int32(TCL_UTF_MAX)
	spaceLeft = int32((*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength - int64(offset))
	if dstNeeded > spaceLeft {
		if offset < dstNeeded {
			v3 = dstNeeded
		} else {
			v3 = offset
		}
		length = offset + v3
		if XTcl_AttemptSetObjLength(tls, objPtr, int64(length)) == 0 {
			length = offset + dstNeeded
			if XTcl_AttemptSetObjLength(tls, objPtr, int64(length)) == 0 {
				dstNeeded = libc.Int32FromInt32(TCL_UTF_MAX) - libc.Int32FromInt32(1) + toRead
				length = offset + dstNeeded
				XTcl_SetObjLength(tls, objPtr, int64(length))
			}
		}
		spaceLeft = length - offset
		dst = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr(offset)
		*(*uintptr)(unsafe.Pointer((*TGetsState)(unsafe.Pointer(gsPtr)).FdstPtr)) = dst
	}
	(*TGetsState)(unsafe.Pointer(gsPtr)).Fstate = (*TChannelState)(unsafe.Pointer(statePtr)).FinputEncodingState
	result = XTcl_ExternalToUtf(tls, libc.UintptrFromInt32(0), (*TGetsState)(unsafe.Pointer(gsPtr)).Fencoding, raw, int64(rawLen), (*TChannelState)(unsafe.Pointer(statePtr)).FinputEncodingFlags|int32(TCL_ENCODING_NO_TERMINATE), statePtr+24, dst, int64(spaceLeft), gsPtr+40, gsPtr+44, gsPtr+48)
	if result == -int32(3) || result == -int32(2) {
		*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(15)
		*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(10))
		*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(9))
		result = TCL_OK
	}
	/*
	 * Make sure that if we go through 'gets', that we reset the
	 * TCL_ENCODING_START flag still. [Bug #523988]
	 */
	*(*int32)(unsafe.Pointer(statePtr + 32)) &= ^libc.Int32FromInt32(TCL_ENCODING_START)
	if result == -int32(1) {
		nextPtr = (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr
		if !(bufPtr != 0 && (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded >= (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FbufLength) {
			if (*TGetsState)(unsafe.Pointer(gsPtr)).FrawRead > 0 {
				/*
				 * Some raw bytes were converted to UTF-8. Fall through,
				 * returning those UTF-8 characters because a EOL might be
				 * present in them.
				 */
			} else {
				if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(9)) != 0 {
					/*
					 * There was a partial character followed by EOF on the
					 * device. Fall through, returning that nothing was found.
					 */
					(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved = (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded
				} else {
					/*
					 * There are no more cached raw bytes left. See if we can get
					 * some more, but avoid blocking on a non-blocking channel.
					 */
					goto read
				}
			}
		} else {
			if nextPtr == libc.UintptrFromInt32(0) {
				nextPtr = _AllocChannelBuffer(tls, (*TChannelState)(unsafe.Pointer(statePtr)).FbufSize)
				(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr = nextPtr
				(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueTail = nextPtr
			}
			extra = rawLen - (*TGetsState)(unsafe.Pointer(gsPtr)).FrawRead
			libc.Xmemcpy(tls, nextPtr+40+uintptr(libc.Int32FromInt32(BUFFER_PADDING)-extra), raw+uintptr((*TGetsState)(unsafe.Pointer(gsPtr)).FrawRead), libc.Uint64FromInt32(extra))
			*(*TTcl_Size)(unsafe.Pointer(nextPtr + 16)) -= int64(extra)
			*(*TTcl_Size)(unsafe.Pointer(bufPtr + 8)) -= int64(extra)
		}
	}
	(*TGetsState)(unsafe.Pointer(gsPtr)).FbufPtr = bufPtr
	return 0
}

/*
 *---------------------------------------------------------------------------
 *
 * PeekAhead --
 *
 *	Helper function used by Tcl_GetsObj(). Called when we've seen a \r at
 *	the end of the UTF-8 string and want to look ahead one character to
 *	see if it is a \n.
 *
 * Results:
 *	*gsPtr->dstPtr is filled with a pointer to the start of the range of
 *	UTF-8 characters that were found by peeking and *dstEndPtr is filled
 *	with a pointer to the bytes just after the end of the range.
 *
 * Side effects:
 *	If no more raw bytes were available in one of the channel buffers,
 *	tries to perform a non-blocking read to get more bytes from the
 *	channel device.
 *
 *---------------------------------------------------------------------------
 */

func _PeekAhead(tls *libc.TLS, chanPtr uintptr, dstEndPtr uintptr, gsPtr uintptr) {
	/* Current state of gets operation. */
	var blockModeProc, bufPtr, statePtr uintptr
	var bytesLeft int32
	_, _, _, _ = blockModeProc, bufPtr, bytesLeft, statePtr
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	bufPtr = (*TGetsState)(unsafe.Pointer(gsPtr)).FbufPtr
	/*
	 * If there's any more raw input that's still buffered, we'll peek into
	 * that. Otherwise, only get more data from the channel driver if it looks
	 * like there might actually be more data. The assumption is that if the
	 * channel buffer is filled right up to the end, then there might be more
	 * data to read.
	 */
	blockModeProc = libc.UintptrFromInt32(0)
	if (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr == libc.UintptrFromInt32(0) {
		bytesLeft = int32((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded - (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved - int64((*TGetsState)(unsafe.Pointer(gsPtr)).FrawRead))
		if bytesLeft == 0 {
			if !(bufPtr != 0 && (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded >= (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FbufLength) {
				/*
				 * Don't peek ahead if last read was short read.
				 */
				goto cleanup
			}
			if !((*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(6)) != 0) {
				blockModeProc = XTcl_ChannelBlockModeProc(tls, (*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr)
				if blockModeProc == libc.UintptrFromInt32(0) {
					/*
					 * Don't peek ahead if cannot set non-blocking mode.
					 */
					goto cleanup
				}
				_StackSetBlockMode(tls, chanPtr, int32(TCL_MODE_NONBLOCKING))
			}
		}
	}
	if _FilterInputBytes(tls, chanPtr, gsPtr) == 0 {
		*(*uintptr)(unsafe.Pointer(dstEndPtr)) = *(*uintptr)(unsafe.Pointer((*TGetsState)(unsafe.Pointer(gsPtr)).FdstPtr)) + uintptr((*TGetsState)(unsafe.Pointer(gsPtr)).FbytesWrote)
	}
	if blockModeProc != libc.UintptrFromInt32(0) {
		_StackSetBlockMode(tls, chanPtr, TCL_MODE_BLOCKING)
	}
	return
	goto cleanup
cleanup:
	;
	*(*TTcl_Size)(unsafe.Pointer(bufPtr + 16)) += int64((*TGetsState)(unsafe.Pointer(gsPtr)).FrawRead)
	(*TGetsState)(unsafe.Pointer(gsPtr)).FrawRead = 0
	*(*int32)(unsafe.Pointer(gsPtr + 52)) += (*TGetsState)(unsafe.Pointer(gsPtr)).FcharsWrote
	(*TGetsState)(unsafe.Pointer(gsPtr)).FbytesWrote = 0
	(*TGetsState)(unsafe.Pointer(gsPtr)).FcharsWrote = 0
}

/*
 *---------------------------------------------------------------------------
 *
 * CommonGetsCleanup --
 *
 *	Helper function for Tcl_GetsObj() to restore the channel after a
 *	"gets" operation.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Encoding may be freed.
 *
 *---------------------------------------------------------------------------
 */

func _CommonGetsCleanup(tls *libc.TLS, chanPtr uintptr) {
	var bufPtr, nextPtr, statePtr uintptr
	var extra TTcl_Size
	_, _, _, _ = bufPtr, extra, nextPtr, statePtr
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	bufPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead
	for {
		if !(bufPtr != libc.UintptrFromInt32(0)) {
			break
		}
		nextPtr = (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr
		if (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded > (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved {
			break
		}
		_RecycleBuffer(tls, statePtr, bufPtr, 0)
		goto _1
	_1:
		;
		bufPtr = nextPtr
	}
	(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead = bufPtr
	if bufPtr == libc.UintptrFromInt32(0) {
		(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueTail = libc.UintptrFromInt32(0)
	} else {
		/*
		 * If any multi-byte characters were split across channel buffer
		 * boundaries, the split-up bytes were moved to the next channel
		 * buffer by FilterInputBytes(). Move the bytes back to their original
		 * buffer because the caller could change the channel's encoding which
		 * could change the interpretation of whether those bytes really made
		 * up multi-byte characters after all.
		 */
		nextPtr = (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr
		for {
			if !(nextPtr != libc.UintptrFromInt32(0)) {
				break
			}
			extra = (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FbufLength - (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded
			if extra > 0 {
				libc.Xmemcpy(tls, bufPtr+40+uintptr((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded), nextPtr+40+uintptr(libc.Int64FromInt32(BUFFER_PADDING)-extra), libc.Uint64FromInt64(extra))
				*(*TTcl_Size)(unsafe.Pointer(bufPtr + 8)) += extra
				(*TChannelBuffer)(unsafe.Pointer(nextPtr)).FnextRemoved = int64(BUFFER_PADDING)
			}
			bufPtr = nextPtr
			goto _2
		_2:
			;
			nextPtr = (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_Read --
 *
 *	Reads a given number of bytes from a channel. EOL and EOF translation
 *	is done on the bytes being read, so the number of bytes consumed from
 *	the channel may not be equal to the number of bytes stored in the
 *	destination buffer.
 *
 *	No encoding conversions are applied to the bytes being read.
 *
 * Results:
 *	The number of bytes read, or TCL_INDEX_NONE on error. Use Tcl_GetErrno() to
 *	retrieve the error code for the error that occurred.
 *
 * Side effects:
 *	May cause input to be buffered.
 *
 *----------------------------------------------------------------------
 */

func XTcl_Read(tls *libc.TLS, chan1 TTcl_Channel, dst uintptr, bytesToRead TTcl_Size) (r TTcl_Size) {
	/* Maximum number of bytes to read. */
	var chanPtr, statePtr uintptr
	_, _ = chanPtr, statePtr
	chanPtr = chan1
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	/* State info for channel */
	/*
	 * This operation should occur at the top of a channel stack.
	 */
	chanPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr
	if _CheckChannelErrors(tls, statePtr, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
		return int64(-libc.Int32FromInt32(1))
	}
	return _DoRead(tls, chanPtr, dst, bytesToRead, 0)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ReadRaw --
 *
 *	Reads a given number of bytes from a channel. EOL and EOF translation
 *	is done on the bytes being read, so the number of bytes consumed from
 *	the channel may not be equal to the number of bytes stored in the
 *	destination buffer.
 *
 *	No encoding conversions are applied to the bytes being read.
 *
 * Results:
 *	The number of bytes read, or TCL_INDEX_NONE on error. Use Tcl_GetErrno() to
 *	retrieve the error code for the error that occurred.
 *
 * Side effects:
 *	May cause input to be buffered.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ReadRaw(tls *libc.TLS, chan1 TTcl_Channel, readBuf uintptr, bytesToRead TTcl_Size) (r TTcl_Size) {
	/* Maximum number of bytes to read. */
	var bufPtr, chanPtr, statePtr uintptr
	var bytesInBuffer, copied, nread, toCopy, v1 int32
	_, _, _, _, _, _, _, _ = bufPtr, bytesInBuffer, chanPtr, copied, nread, statePtr, toCopy, v1
	chanPtr = chan1
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	/* State info for channel */
	copied = 0
	if _CheckChannelErrors(tls, statePtr, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(16)) != 0 {
		return int64(-libc.Int32FromInt32(1))
	}
	/*
	 * First read bytes from the push-back buffers.
	 */
	for (*TChannel)(unsafe.Pointer(chanPtr)).FinQueueHead != 0 && bytesToRead > 0 {
		bufPtr = (*TChannel)(unsafe.Pointer(chanPtr)).FinQueueHead
		bytesInBuffer = int32((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded - (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved)
		if bytesInBuffer < int32(bytesToRead) {
			v1 = bytesInBuffer
		} else {
			v1 = int32(bytesToRead)
		}
		toCopy = v1
		/*
		 * Copy the current chunk into the read buffer.
		 */
		libc.Xmemcpy(tls, readBuf, bufPtr+40+uintptr((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved), libc.Uint64FromInt32(toCopy))
		*(*TTcl_Size)(unsafe.Pointer(bufPtr + 16)) += int64(toCopy)
		copied += toCopy
		readBuf += uintptr(toCopy)
		bytesToRead -= int64(toCopy)
		/*
		 * If the current buffer is empty recycle it.
		 */
		if (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded == (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved {
			(*TChannel)(unsafe.Pointer(chanPtr)).FinQueueHead = (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr
			if (*TChannel)(unsafe.Pointer(chanPtr)).FinQueueHead == libc.UintptrFromInt32(0) {
				(*TChannel)(unsafe.Pointer(chanPtr)).FinQueueTail = libc.UintptrFromInt32(0)
			}
			_RecycleBuffer(tls, (*TChannel)(unsafe.Pointer(chanPtr)).Fstate, bufPtr, 0)
		}
	}
	/*
	 * Go to the driver only if we got nothing from pushback.  Have to do it
	 * this way to avoid EOF mistimings when we consider the ability that EOF
	 * may not be a permanent condition in the driver, and in that case we
	 * have to synchronize.
	 */
	if copied != 0 {
		return int64(copied)
	}
	/*
	 * This test not needed.
	 */
	if bytesToRead > 0 {
		nread = _ChanRead(tls, chanPtr, readBuf, int32(bytesToRead))
		if nread == -int32(1) {
			/*
			 * An error signaled.  If CHANNEL_BLOCKED, then the error is not
			 * real, but an indication of blocked state.  In that case, retain
			 * the flag and let caller receive the short read of copied bytes
			 * from the pushback.  HOWEVER, if copied==0 bytes from pushback
			 * then repeat signalling the blocked state as an error to caller
			 * so there is no false report of an EOF.  When !CHANNEL_BLOCKED,
			 * the error is real and passes on to caller.
			 */
			if !((*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(11)) != 0) || copied == 0 {
				copied = -int32(1)
			}
		} else {
			if nread > 0 {
				/*
				 * Successful read (short is OK) - add to bytes copied.
				 */
				copied += nread
			} else {
				/*
				 * nread == 0.  Driver is at EOF. Let that state filter up.
				 */
			}
		}
	}
	return int64(copied)
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_ReadChars --
 *
 *	Reads from the channel until the requested number of characters have
 *	been seen, EOF is seen, or the channel would block. EOL and EOF
 *	translation is done. If reading binary data, the raw bytes are wrapped
 *	in a Tcl byte array object. Otherwise, the raw bytes are converted to
 *	UTF-8 using the channel's current encoding and stored in a Tcl string
 *	object.
 *
 * Results:
 *	The number of characters read, or TCL_INDEX_NONE on error. Use Tcl_GetErrno() to
 *	retrieve the error code for the error that occurred.
 *
 * Side effects:
 *	May cause input to be buffered.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_ReadChars(tls *libc.TLS, chan1 TTcl_Channel, objPtr uintptr, toRead TTcl_Size, appendFlag int32) (r TTcl_Size) {
	/* If non-zero, data read from the channel
	 * will be appended to the object. Otherwise,
	 * the data will replace the existing contents
	 * of the object. */
	var chanPtr, statePtr uintptr
	_, _ = chanPtr, statePtr
	chanPtr = chan1
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	/* State info for channel */
	/*
	 * This operation should occur at the top of a channel stack.
	 */
	chanPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr
	if _CheckChannelErrors(tls, statePtr, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
		/*
		 * Update the notifier state so we don't block while there is still
		 * data in the buffers.
		 */
		_UpdateInterest(tls, chanPtr)
		return int64(-libc.Int32FromInt32(1))
	}
	return _DoReadChars(tls, chanPtr, objPtr, toRead, 0, appendFlag)
}

/*
 *---------------------------------------------------------------------------
 *
 * DoReadChars --
 *
 *	Reads from the channel until the requested number of characters have
 *	been seen, EOF is seen, or the channel would block. EOL and EOF
 *	translation is done. If reading binary data, the raw bytes are wrapped
 *	in a Tcl byte array object. Otherwise, the raw bytes are converted to
 *	UTF-8 using the channel's current encoding and stored in a Tcl string
 *	object.
 *
 * Results:
 *	The number of characters read, or TCL_INDEX_NONE on error. Use Tcl_GetErrno() to
 *	retrieve the error code for the error that occurred.
 *
 * Side effects:
 *	May cause input to be buffered.
 *
 *---------------------------------------------------------------------------
 */

func _DoReadChars(tls *libc.TLS, chanPtr uintptr, objPtr uintptr, toRead TTcl_Size, allowShortReads int32, appendFlag int32) (r TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* If non-zero, data read from the channel
	 * will be appended to the object. Otherwise,
	 * the data will replace the existing contents
	 * of the object. */
	var binaryMode, copiedNow, result int32
	var bufPtr, nextPtr, statePtr uintptr
	var copied TTcl_Size
	var encoding TTcl_Encoding
	var _ /* factor at bp+0 */ int32
	_, _, _, _, _, _, _, _ = binaryMode, bufPtr, copied, copiedNow, encoding, nextPtr, result, statePtr
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	encoding = (*TChannelState)(unsafe.Pointer(statePtr)).Fencoding
	*(*int32)(unsafe.Pointer(bp)) = int32(UTF_EXPANSION_FACTOR)
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(15)) != 0 {
		*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1)<<libc.Int32FromInt32(9) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(15))
		/* TODO: UpdateInterest not needed here? */
		_UpdateInterest(tls, chanPtr)
		XTcl_SetErrno(tls, int32(EILSEQ))
		return int64(-int32(1))
	}
	/*
	 * Early out when next read will see eofchar.
	 *
	 * NOTE: See DoRead for argument that it's a bug (one we're keeping) to
	 * have this escape before the one for zero-char read request.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(10)) != 0 {
		*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(9)
		/* TODO: UpdateInterest not needed here? */
		_UpdateInterest(tls, chanPtr)
		return 0
	}
	/*
	 * Special handling for zero-char read request.
	 */
	if toRead == 0 {
		if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(9)) != 0 {
			*(*int32)(unsafe.Pointer(statePtr + 32)) |= int32(TCL_ENCODING_START)
		}
		*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1)<<libc.Int32FromInt32(11) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(9))
		*(*int32)(unsafe.Pointer(statePtr + 32)) &= ^libc.Int32FromInt32(TCL_ENCODING_END)
		/* TODO: UpdateInterest not needed here? */
		_UpdateInterest(tls, chanPtr)
		return 0
	}
	/*
	 * This operation should occur at the top of a channel stack.
	 */
	chanPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr
	XTclChannelPreserve(tls, chanPtr)
	binaryMode = libc.BoolInt32(encoding == _GetBinaryEncoding(tls) && (*TChannelState)(unsafe.Pointer(statePtr)).FinputTranslation == int32(TCL_TRANSLATE_LF) && (*TChannelState)(unsafe.Pointer(statePtr)).FinEofChar == int32('\000'))
	if appendFlag != 0 {
		if binaryMode != 0 && libc.UintptrFromInt32(0) == XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), objPtr, libc.UintptrFromInt32(0)) {
			binaryMode = 0
		}
	} else {
		if binaryMode != 0 {
			XTcl_SetByteArrayLength(tls, objPtr, 0)
		} else {
			XTcl_SetObjLength(tls, objPtr, 0)
		}
	}
	/*
	 * Must clear the BLOCKED|EOF flags here since we check before reading.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(9)) != 0 {
		*(*int32)(unsafe.Pointer(statePtr + 32)) |= int32(TCL_ENCODING_START)
	}
	*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1)<<libc.Int32FromInt32(11) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(9))
	*(*int32)(unsafe.Pointer(statePtr + 32)) &= ^libc.Int32FromInt32(TCL_ENCODING_END)
	copied = 0
	for {
		if !(toRead != 0) {
			break
		}
		copiedNow = -int32(1)
		if (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead != libc.UintptrFromInt32(0) {
			if binaryMode != 0 {
				copiedNow = _ReadBytes(tls, statePtr, objPtr, int32(toRead))
			} else {
				copiedNow = _ReadChars(tls, statePtr, objPtr, int32(toRead), bp)
			}
			/*
			 * Recycle current buffer if empty.
			 */
			bufPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead
			if (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded == (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved {
				nextPtr = (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr
				_RecycleBuffer(tls, statePtr, bufPtr, 0)
				(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead = nextPtr
				if nextPtr == libc.UintptrFromInt32(0) {
					(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueTail = libc.UintptrFromInt32(0)
				}
			}
			/*
			 * If CHANNEL_ENCODING_ERROR and CHANNEL_STICKY_EOF are both set,
			 * then CHANNEL_ENCODING_ERROR was caused by data that occurred
			 * after the EOF character was encountered, so it doesn't count as
			 * a real error.
			 */
			if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(15)) != 0 && !((*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(10)) != 0) && !((*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(6)) != 0) {
				goto finish
			}
		}
		if copiedNow < 0 {
			if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(9)) != 0 {
				break
			}
			if ((*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(6)) != 0 || allowShortReads != 0) && (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(11)) != 0 {
				break
			}
			result = _GetInput(tls, chanPtr)
			if chanPtr != (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr {
				XTclChannelRelease(tls, chanPtr)
				chanPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr
				XTclChannelPreserve(tls, chanPtr)
			}
			if result != 0 {
				if !((*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(11)) != 0) {
					copied = int64(-int32(1))
				}
				break
			}
		} else {
			copied += int64(copiedNow)
			if toRead != int64(-libc.Int32FromInt32(1)) {
				toRead -= int64(copiedNow) /* Only decr if not reading whole file */
			}
		}
		goto _1
	_1:
	}
	goto finish
finish:
	;
	/*
	 * Failure to fill a channel buffer may have left channel reporting a
	 * "blocked" state, but so long as we fulfilled the request here, the
	 * caller does not consider us blocked.
	 */
	if toRead == 0 {
		*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(11))
	}
	/*
	 * Regenerate chanPtr in case it was changed due to
	 * self-modifying reflected transforms.
	 */
	if chanPtr != (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr {
		XTclChannelRelease(tls, chanPtr)
		chanPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr
		XTclChannelPreserve(tls, chanPtr)
	}
	/*
	 * Update the notifier state so we don't block while there is still data
	 * in the buffers.
	 */
	_UpdateInterest(tls, chanPtr)
	/* This must comes after UpdateInterest(), which may set errno */
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(15)) != 0 && (!(copied != 0) || !((*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(6)) != 0)) {
		/* Channel either is blocking or is nonblocking with no data
		 * succesfully red before the error.  Return an error so that callers
		 * like [read] can also return an error.
		 */
		*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1)<<libc.Int32FromInt32(9) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(15))
		XTcl_SetErrno(tls, int32(EILSEQ))
		copied = int64(-int32(1))
	}
	XTclChannelRelease(tls, chanPtr)
	return copied
}

/*
 *---------------------------------------------------------------------------
 *
 * ReadBytes --
 *
 *	Reads from the channel until the requested number of bytes have been
 *	seen, EOF is seen, or the channel would block. Bytes from the channel
 *	are stored in objPtr as a ByteArray object. EOL and EOF translation
 *	are done.
 *
 *	'bytesToRead' can safely be a very large number because space is only
 *	allocated to hold data read from the channel as needed.
 *
 * Results:
 *	The return value is the number of bytes appended to the object, or
 *	TCL_INDEX_NONE to indicate that zero bytes were read due to an EOF.
 *
 * Side effects:
 *	The storage of bytes in objPtr can cause (re-)allocation of memory.
 *
 *---------------------------------------------------------------------------
 */

func _ReadBytes(tls *libc.TLS, statePtr uintptr, objPtr uintptr, bytesToRead int32) (r int32) {
	/* Maximum number of bytes to store, or -1 to
	 * get all available bytes. Bytes are obtained
	 * from the first buffer in the queue - even
	 * if this number is larger than the number of
	 * bytes available in the first buffer, only
	 * the bytes from the first buffer are
	 * returned. */
	var bufPtr uintptr
	var srcLen, toRead, v1 int32
	_, _, _, _ = bufPtr, srcLen, toRead, v1
	bufPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead
	srcLen = int32((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded - (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved)
	if bytesToRead > srcLen || bytesToRead < 0 {
		v1 = srcLen
	} else {
		v1 = bytesToRead
	}
	toRead = v1
	XTclAppendBytesToByteArray(tls, objPtr, bufPtr+40+uintptr((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved), int64(toRead))
	*(*TTcl_Size)(unsafe.Pointer(bufPtr + 16)) += int64(toRead)
	return toRead
}

/*
 *---------------------------------------------------------------------------
 *
 * ReadChars --
 *
 *	Reads from the channel until the requested number of UTF-8 characters
 *	have been seen, EOF is seen, or the channel would block. Raw bytes
 *	from the channel are converted to UTF-8 and stored in objPtr. EOL and
 *	EOF translation is done.
 *
 *	'charsToRead' can safely be a very large number because space is only
 *	allocated to hold data read from the channel as needed.
 *
 *	'charsToRead' may *not* be 0.
 *
 * Results:
 *	The return value is the number of characters appended to the object,
 *	*offsetPtr is filled with the number of bytes that were appended, and
 *	*factorPtr is filled with the expansion factor used to guess how many
 *	bytes of UTF-8 to allocate to hold N source bytes.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func _ReadChars(tls *libc.TLS, statePtr uintptr, objPtr uintptr, charsToRead int32, factorPtr uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* On input, contains a guess of how many
	 * bytes need to be allocated to hold the
	 * result of converting N source bytes to
	 * UTF-8. On output, contains another guess
	 * based on the data seen so far. */
	var bufPtr, dst, nextPtr, src, v4 uintptr
	var code, dstLimit, factor, flags, savedFlags, savedIEFlags, srcLen, toRead, v1 int32
	var encoding TTcl_Encoding
	var savedState TTcl_EncodingState
	var v3 int64
	var _ /* buffer at bp+50 */ [5]uint8
	var _ /* count at bp+44 */ int32
	var _ /* decoded at bp+40 */ int32
	var _ /* dstDecoded at bp+16 */ int32
	var _ /* dstRead at bp+20 */ int32
	var _ /* dstWrote at bp+24 */ int32
	var _ /* numBytes at bp+0 */ TTcl_Size
	var _ /* numChars at bp+32 */ int32
	var _ /* read at bp+36 */ int32
	var _ /* size at bp+8 */ TTcl_Size
	var _ /* srcRead at bp+28 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bufPtr, code, dst, dstLimit, encoding, factor, flags, nextPtr, savedFlags, savedIEFlags, savedState, src, srcLen, toRead, v1, v3, v4
	encoding = (*TChannelState)(unsafe.Pointer(statePtr)).Fencoding
	savedState = (*TChannelState)(unsafe.Pointer(statePtr)).FinputEncodingState
	bufPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead
	savedIEFlags = (*TChannelState)(unsafe.Pointer(statePtr)).FinputEncodingFlags
	savedFlags = (*TChannelState)(unsafe.Pointer(statePtr)).Fflags
	src = bufPtr + 40 + uintptr((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved)
	srcLen = int32((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded - (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved)
	if charsToRead < 0 || charsToRead > srcLen {
		v1 = srcLen
	} else {
		v1 = charsToRead
	}
	/*
	 * One src byte can yield at most one character.  So when the number of
	 * src bytes we plan to read is less than the limit on character count to
	 * be read, clearly we will remain within that limit, and we can use the
	 * value of "srcLen" as a tighter limit for sizing receiving buffers.
	 */
	toRead = v1
	/*
	 * 'factor' is how much we guess that the bytes in the source buffer will
	 * expand when converted to UTF-8 chars. This guess comes from analyzing
	 * how many characters were produced by the previous pass.
	 */
	factor = *(*int32)(unsafe.Pointer(factorPtr))
	dstLimit = libc.Int32FromInt32(TCL_UTF_MAX) - libc.Int32FromInt32(1) + toRead*factor/int32(UTF_EXPANSION_FACTOR)
	if dstLimit <= 0 {
		dstLimit = int32(INT_MAX) /* avoid overflow */
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
		_ = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		XTcl_GetStringFromObj(tls, objPtr, bp)
	}
	XTclAppendUtfToUtf(tls, objPtr, libc.UintptrFromInt32(0), int64(dstLimit))
	if toRead == srcLen {
		dst = XTclGetStringStorage(tls, objPtr, bp+8) + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8))-*(*TTcl_Size)(unsafe.Pointer(bp)) > int64(INT_MAX) {
			v3 = int64(INT_MAX)
		} else {
			v3 = *(*TTcl_Size)(unsafe.Pointer(bp + 8)) - *(*TTcl_Size)(unsafe.Pointer(bp))
		}
		dstLimit = int32(v3)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
			v4 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		} else {
			v4 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
		}
		dst = v4 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))
	}
	/*
	 * This routine is burdened with satisfying several constraints. It cannot
	 * append more than 'charsToRead` chars onto objPtr. This is measured
	 * after encoding and translation transformations are completed. There is
	 * no precise number of src bytes that can be associated with the limit.
	 * Yet, when we are done, we must know precisely the number of src bytes
	 * that were consumed to produce the appended chars, so that all
	 * subsequent bytes are left in the buffers for future read operations.
	 *
	 * The consequence is that we have no choice but to implement a "trial and
	 * error" approach, where in general we may need to perform
	 * transformations and copies multiple times to achieve a consistent set
	 * of results.  This takes the shape of a loop.
	 */
	for int32(1) != 0 {
		flags = (*TChannelState)(unsafe.Pointer(statePtr)).FinputEncodingFlags | int32(TCL_ENCODING_NO_TERMINATE)
		if charsToRead > 0 {
			flags |= int32(TCL_ENCODING_CHAR_LIMIT)
			*(*int32)(unsafe.Pointer(bp + 32)) = charsToRead
		}
		/*
		 * Perform the encoding transformation.  Read no more than srcLen
		 * bytes, write no more than dstLimit bytes.
		 *
		 * Some trickiness with encoding flags here.  We do not want the end
		 * of a buffer to be treated as the end of all input when the presence
		 * of bytes in a next buffer are already known to exist.  This is
		 * checked with an assert() because so far no test case causing the
		 * assertion to be false has been created.  The normal operations of
		 * channel reading appear to cause EOF and TCL_ENCODING_END setting to
		 * appear only in situations where there are no further bytes in any
		 * buffers.
		 */
		code = XTcl_ExternalToUtf(tls, libc.UintptrFromInt32(0), encoding, src, int64(srcLen), flags, statePtr+24, dst, int64(dstLimit), bp+28, bp+16, bp+32)
		if code == -int32(3) || code == -int32(2) || code == -int32(1) && (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(9)) != 0 {
			*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(15)
			code = TCL_OK
		}
		/*
		 * Perform the translation transformation in place.  Read no more than
		 * the dstDecoded bytes the encoding transformation actually produced.
		 * Capture the number of bytes written in dstWrote. Capture the number
		 * of bytes actually consumed in dstRead.
		 */
		*(*int32)(unsafe.Pointer(bp + 24)) = dstLimit
		*(*int32)(unsafe.Pointer(bp + 20)) = *(*int32)(unsafe.Pointer(bp + 16))
		_TranslateInputEOL(tls, statePtr, dst, dst, bp+24, bp+20)
		if *(*int32)(unsafe.Pointer(bp + 20)) < *(*int32)(unsafe.Pointer(bp + 16)) {
			/*
			 * The encoding transformation produced bytes that the translation
			 * transformation did not consume.  Why did this happen?
			 */
			if (*TChannelState)(unsafe.Pointer(statePtr)).FinEofChar != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dst + uintptr(*(*int32)(unsafe.Pointer(bp + 20)))))) == (*TChannelState)(unsafe.Pointer(statePtr)).FinEofChar {
				/*
				 * 1) There's an eof char set on the channel, and
				 *    we saw it and stopped translating at that point.
				 *
				 * NOTE the bizarre spec of TranslateInputEOL in this case.
				 * Clearly the eof char had to be read in order to account for
				 * the stopping, but the value of dstRead does not include it.
				 *
				 * Also rather bizarre, our caller can only notice an EOF
				 * condition if we return the value TCL_INDEX_NONE as the number of chars
				 * read.  This forces us to perform a 2-call dance where the
				 * first call can read all the chars up to the eof char, and
				 * the second call is solely for consuming the encoded eof
				 * char then pointed at by src so that we can return that
				 * magic TCL_INDEX_NONE value.  This seems really wasteful, especially
				 * since the first decoding pass of each call is likely to
				 * decode many bytes beyond that eof char that's all we care
				 * about.
				 */
				if *(*int32)(unsafe.Pointer(bp + 20)) == 0 {
					/*
					 * Curious choice in the eof char handling.  We leave the
					 * eof char in the buffer. So, no need to compute a proper
					 * srcRead value. At this point, there are no chars before
					 * the eof char in the buffer.
					 */
					XTcl_SetObjLength(tls, objPtr, *(*TTcl_Size)(unsafe.Pointer(bp)))
					return -int32(1)
				}
				/*
				 * There are chars leading the buffer before the eof char.
				 * Adjust the dstLimit so we go back and read only those
				 * and do not encounter the eof char this time.
				 */
				dstLimit = *(*int32)(unsafe.Pointer(bp + 20)) + (libc.Int32FromInt32(TCL_UTF_MAX) - libc.Int32FromInt32(1))
				(*TChannelState)(unsafe.Pointer(statePtr)).Fflags = savedFlags
				(*TChannelState)(unsafe.Pointer(statePtr)).FinputEncodingFlags = savedIEFlags
				(*TChannelState)(unsafe.Pointer(statePtr)).FinputEncodingState = savedState
				continue
			}
			/*
			 * 2) The other way to read fewer bytes than are decoded is when
			 *    the final byte is \r and we're in a CRLF translation mode so
			 *    we cannot decide whether to record \r or \n yet.
			 */
			if *(*int32)(unsafe.Pointer(bp + 24)) > 0 {
				/*
				 * There are chars we can read before we hit the bare CR.  Go
				 * back with a smaller dstLimit so we get them in the next
				 * pass, compute a matching srcRead, and don't end up back
				 * here in this call.
				 */
				dstLimit = *(*int32)(unsafe.Pointer(bp + 20)) + (libc.Int32FromInt32(TCL_UTF_MAX) - libc.Int32FromInt32(1))
				(*TChannelState)(unsafe.Pointer(statePtr)).Fflags = savedFlags
				(*TChannelState)(unsafe.Pointer(statePtr)).FinputEncodingFlags = savedIEFlags
				(*TChannelState)(unsafe.Pointer(statePtr)).FinputEncodingState = savedState
				continue
			}
			/*
			 * We decoded only the bare CR, and we cannot read a translated
			 * char from that alone. We have to know what's next.  So why do
			 * we only have the one decoded char?
			 */
			if code != TCL_OK {
				/*
				 * Didn't get everything the buffer could offer
				 */
				(*TChannelState)(unsafe.Pointer(statePtr)).Fflags = savedFlags
				(*TChannelState)(unsafe.Pointer(statePtr)).FinputEncodingFlags = savedIEFlags
				(*TChannelState)(unsafe.Pointer(statePtr)).FinputEncodingState = savedState
				XTcl_ExternalToUtf(tls, libc.UintptrFromInt32(0), encoding, src, int64(srcLen), (*TChannelState)(unsafe.Pointer(statePtr)).FinputEncodingFlags|int32(TCL_ENCODING_NO_TERMINATE), statePtr+24, bp+50, int64(5), bp+36, bp+40, bp+44)
				if *(*int32)(unsafe.Pointer(bp + 44)) == int32(2) {
					if libc.Int32FromUint8((*(*[5]uint8)(unsafe.Pointer(bp + 50)))[int32(1)]) == int32('\n') {
						/* \r\n translate to \n */
						*(*uint8)(unsafe.Pointer(dst)) = uint8('\n')
						*(*TTcl_Size)(unsafe.Pointer(bufPtr + 16)) += int64(*(*int32)(unsafe.Pointer(bp + 36)))
					} else {
						*(*uint8)(unsafe.Pointer(dst)) = uint8('\r')
						*(*TTcl_Size)(unsafe.Pointer(bufPtr + 16)) += int64(*(*int32)(unsafe.Pointer(bp + 28)))
					}
					*(*int32)(unsafe.Pointer(statePtr + 32)) &= ^libc.Int32FromInt32(TCL_ENCODING_START)
					XTcl_SetObjLength(tls, objPtr, *(*TTcl_Size)(unsafe.Pointer(bp))+int64(1))
					return int32(1)
				}
			} else {
				if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(9)) != 0 {
					/*
					 * The bare \r is the only char and we will never read a
					 * subsequent char to make the determination.
					 */
					*(*uint8)(unsafe.Pointer(dst)) = uint8('\r')
					(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved = (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded
					XTcl_SetObjLength(tls, objPtr, *(*TTcl_Size)(unsafe.Pointer(bp))+int64(1))
					return int32(1)
				}
			}
			/*
			 * Revise the dstRead value so that the numChars calc below
			 * correctly computes zero characters read.
			 */
			*(*int32)(unsafe.Pointer(bp + 20)) = *(*int32)(unsafe.Pointer(bp + 32))
			/* FALL THROUGH - get more data (dstWrote == 0) */
		}
		/*
		 * The translation transformation can only reduce the number of chars
		 * when it converts \r\n into \n. The reduction in the number of chars
		 * is the difference in bytes read and written.
		 */
		*(*int32)(unsafe.Pointer(bp + 32)) -= *(*int32)(unsafe.Pointer(bp + 20)) - *(*int32)(unsafe.Pointer(bp + 24))
		if charsToRead > 0 && *(*int32)(unsafe.Pointer(bp + 32)) > charsToRead {
			/*
			 * TODO: This cannot happen anymore.
			 *
			 * We read more chars than allowed.  Reset limits to prevent that
			 * and try again.  Don't forget the extra padding of TCL_UTF_MAX
			 * bytes demanded by the Tcl_ExternalToUtf() call!
			 */
			dstLimit = int32(int64(XTcl_UtfAtIndex(tls, dst, int64(charsToRead))) - int64(dst) + int64(libc.Int32FromInt32(TCL_UTF_MAX)-libc.Int32FromInt32(1)))
			(*TChannelState)(unsafe.Pointer(statePtr)).Fflags = savedFlags
			(*TChannelState)(unsafe.Pointer(statePtr)).FinputEncodingFlags = savedIEFlags
			(*TChannelState)(unsafe.Pointer(statePtr)).FinputEncodingState = savedState
			continue
		}
		if *(*int32)(unsafe.Pointer(bp + 24)) == 0 {
			/*
			 * We were not able to read any chars.
			 */
			/*
			 * There is one situation where this is the correct final result.
			 * If the src buffer contains only a single \n byte, and we are in
			 * TCL_TRANSLATE_AUTO mode, and when the translation pass was made
			 * the INPUT_SAW_CR flag was set on the channel. In that case, the
			 * correct behavior is to consume that \n and produce the empty
			 * string.
			 */
			if *(*int32)(unsafe.Pointer(bp + 20)) == int32(1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dst))) == int32('\n') {
				goto consume
			}
			/*
			 * Otherwise, reading zero characters indicates there's something
			 * incomplete at the end of the src buffer.  Maybe there were not
			 * enough src bytes to decode into a char.  Maybe a lone \r could
			 * not be translated (crlf mode).  Need to combine any unused src
			 * bytes we have in the first buffer with subsequent bytes to try
			 * again.
			 */
			nextPtr = (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr
			if nextPtr == libc.UintptrFromInt32(0) {
				if srcLen > 0 {
					*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(14)
				}
				XTcl_SetObjLength(tls, objPtr, *(*TTcl_Size)(unsafe.Pointer(bp)))
				return -int32(1)
			}
			/*
			 * Space is made at the beginning of the buffer to copy the
			 * previous unused bytes there. Check first if the buffer we are
			 * using actually has enough space at its beginning for the data
			 * we are copying.  Because if not we will write over the buffer
			 * management information, especially the 'nextPtr'.
			 *
			 * Note that the BUFFER_PADDING (See AllocChannelBuffer) is used
			 * to prevent exactly this situation. I.e. it should never happen.
			 * Therefore it is ok to panic should it happen despite the
			 * precautions.
			 */
			if (*TChannelBuffer)(unsafe.Pointer(nextPtr)).FnextRemoved < int64(srcLen) {
				XTcl_Panic(tls, __ccgo_ts+44466, 0)
			}
			*(*TTcl_Size)(unsafe.Pointer(nextPtr + 16)) -= int64(srcLen)
			libc.Xmemcpy(tls, nextPtr+40+uintptr((*TChannelBuffer)(unsafe.Pointer(nextPtr)).FnextRemoved), src, libc.Uint64FromInt32(srcLen))
			_RecycleBuffer(tls, statePtr, bufPtr, 0)
			(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead = nextPtr
			XTcl_SetObjLength(tls, objPtr, *(*TTcl_Size)(unsafe.Pointer(bp)))
			return _ReadChars(tls, statePtr, objPtr, charsToRead, factorPtr)
		}
		*(*int32)(unsafe.Pointer(statePtr + 32)) &= ^libc.Int32FromInt32(TCL_ENCODING_START)
		goto consume
	consume:
		;
		*(*TTcl_Size)(unsafe.Pointer(bufPtr + 16)) += int64(*(*int32)(unsafe.Pointer(bp + 28)))
		/*
		 * If this read contained multibyte characters, revise factorPtr so
		 * the next read will allocate bigger buffers.
		 */
		if *(*int32)(unsafe.Pointer(bp + 32)) != 0 && *(*int32)(unsafe.Pointer(bp + 32)) < *(*int32)(unsafe.Pointer(bp + 28)) {
			*(*int32)(unsafe.Pointer(factorPtr)) = *(*int32)(unsafe.Pointer(bp + 28)) * int32(UTF_EXPANSION_FACTOR) / *(*int32)(unsafe.Pointer(bp + 32))
		}
		XTcl_SetObjLength(tls, objPtr, *(*TTcl_Size)(unsafe.Pointer(bp))+int64(*(*int32)(unsafe.Pointer(bp + 24))))
		return *(*int32)(unsafe.Pointer(bp + 32))
	}
	return r
}

/*
 *---------------------------------------------------------------------------
 *
 * TranslateInputEOL --
 *
 *	Perform input EOL and EOF translation on the source buffer, leaving
 *	the translated result in the destination buffer.
 *
 * Results:
 *	The return value is 1 if the EOF character was found when copying
 *	bytes to the destination buffer, 0 otherwise.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func _TranslateInputEOL(tls *libc.TLS, statePtr uintptr, dstStart uintptr, srcStart uintptr, dstLenPtr uintptr, srcLenPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* On entry, the length of source buffer. On
	 * exit, the number of bytes read from the
	 * source buffer. */
	var crFound, crFound1, dst, dst1, dst2, dstEnd, eof, src, src1, v1, v11, v2, v3, v5, v6, v7, v8 uintptr
	var dstLen, inEofChar, lesser, lesser1, numBytes, numBytes1, srcLen, v10, v12, v4, v9 int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = crFound, crFound1, dst, dst1, dst2, dstEnd, dstLen, eof, inEofChar, lesser, lesser1, numBytes, numBytes1, src, src1, srcLen, v1, v10, v11, v12, v2, v3, v4, v5, v6, v7, v8, v9
	eof = libc.UintptrFromInt32(0)
	dstLen = *(*int32)(unsafe.Pointer(dstLenPtr))
	srcLen = *(*int32)(unsafe.Pointer(srcLenPtr))
	inEofChar = (*TChannelState)(unsafe.Pointer(statePtr)).FinEofChar
	/*
	 * Depending on the translation mode in use, there's no need to scan more
	 * srcLen bytes at srcStart than can possibly transform to dstLen bytes.
	 * This keeps the scan for eof char below from being pointlessly long.
	 */
	switch (*TChannelState)(unsafe.Pointer(statePtr)).FinputTranslation {
	case int32(TCL_TRANSLATE_LF):
		fallthrough
	case int32(TCL_TRANSLATE_CR):
		if srcLen > dstLen {
			/*
			 * In these modes, each src byte become a dst byte.
			 */
			srcLen = dstLen
		}
	default:
		/*
		 * In other modes, at most 2 src bytes become a dst byte.
		 */
		if srcLen/int32(2) > dstLen {
			srcLen = int32(2) * dstLen
		}
		break
	}
	if inEofChar != int32('\000') {
		/*
		 * Make sure we do not read past any logical end of channel input
		 * created by the presence of the input eof char.
		 */
		v1 = libc.Xmemchr(tls, srcStart, inEofChar, libc.Uint64FromInt32(srcLen))
		eof = v1
		if v1 != 0 {
			srcLen = int32(int64(eof) - int64(srcStart))
		}
	}
	switch (*TChannelState)(unsafe.Pointer(statePtr)).FinputTranslation {
	case int32(TCL_TRANSLATE_LF):
		fallthrough
	case int32(TCL_TRANSLATE_CR):
		if dstStart != srcStart {
			libc.Xmemcpy(tls, dstStart, srcStart, libc.Uint64FromInt32(srcLen))
		}
		if (*TChannelState)(unsafe.Pointer(statePtr)).FinputTranslation == int32(TCL_TRANSLATE_CR) {
			dst = dstStart
			dstEnd = dstStart + uintptr(srcLen)
			for {
				v2 = libc.Xmemchr(tls, dst, int32('\r'), libc.Uint64FromInt64(int64(dstEnd)-int64(dst)))
				dst = v2
				if !(v2 != 0) {
					break
				}
				v3 = dst
				dst++
				*(*uint8)(unsafe.Pointer(v3)) = uint8('\n')
			}
		}
		dstLen = srcLen
	case int32(TCL_TRANSLATE_CRLF):
		src = srcStart
		dst1 = dstStart
		if dstLen < srcLen {
			v4 = dstLen
		} else {
			v4 = srcLen
		}
		lesser = v4
		for {
			v5 = libc.Xmemchr(tls, src, int32('\r'), libc.Uint64FromInt32(lesser))
			crFound = v5
			if !(v5 != 0) {
				break
			}
			numBytes = int32(int64(crFound) - int64(src))
			libc.Xmemmove(tls, dst1, src, libc.Uint64FromInt32(numBytes))
			dst1 += uintptr(numBytes)
			dstLen -= numBytes
			src += uintptr(numBytes)
			srcLen -= numBytes
			if srcLen == int32(1) {
				/* valid src bytes end in \r */
				if eof != 0 {
					v6 = dst1
					dst1++
					*(*uint8)(unsafe.Pointer(v6)) = uint8('\r')
					src++
					srcLen--
				} else {
					lesser = 0
					break
				}
			} else {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1))) == int32('\n') {
					v7 = dst1
					dst1++
					*(*uint8)(unsafe.Pointer(v7)) = uint8('\n')
					src += uintptr(2)
					srcLen -= int32(2)
				} else {
					v8 = dst1
					dst1++
					*(*uint8)(unsafe.Pointer(v8)) = uint8('\r')
					src++
					srcLen--
				}
			}
			dstLen--
			if dstLen < srcLen {
				v9 = dstLen
			} else {
				v9 = srcLen
			}
			lesser = v9
		}
		libc.Xmemmove(tls, dst1, src, libc.Uint64FromInt32(lesser))
		srcLen = int32(int64(src+uintptr(lesser)) - int64(srcStart))
		dstLen = int32(int64(dst1+uintptr(lesser)) - int64(dstStart))
	case int32(TCL_TRANSLATE_AUTO):
		src1 = srcStart
		dst2 = dstStart
		if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(12)) != 0 && srcLen != 0 {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src1))) == int32('\n') {
				src1++
				srcLen--
			}
			*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(12))
		}
		if dstLen < srcLen {
			v10 = dstLen
		} else {
			v10 = srcLen
		}
		lesser1 = v10
		for {
			v11 = libc.Xmemchr(tls, src1, int32('\r'), libc.Uint64FromInt32(lesser1))
			crFound1 = v11
			if !(v11 != 0) {
				break
			}
			numBytes1 = int32(int64(crFound1) - int64(src1))
			libc.Xmemmove(tls, dst2, src1, libc.Uint64FromInt32(numBytes1))
			*(*uint8)(unsafe.Pointer(dst2 + uintptr(numBytes1))) = uint8('\n')
			dst2 += uintptr(numBytes1 + int32(1))
			dstLen -= numBytes1 + int32(1)
			src1 += uintptr(numBytes1 + int32(1))
			srcLen -= numBytes1 + int32(1)
			if srcLen == 0 {
				*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(12)
			} else {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src1))) == int32('\n') {
					src1++
					srcLen--
				}
			}
			if dstLen < srcLen {
				v12 = dstLen
			} else {
				v12 = srcLen
			}
			lesser1 = v12
		}
		libc.Xmemmove(tls, dst2, src1, libc.Uint64FromInt32(lesser1))
		srcLen = int32(int64(src1+uintptr(lesser1)) - int64(srcStart))
		dstLen = int32(int64(dst2+uintptr(lesser1)) - int64(dstStart))
	default:
		XTcl_Panic(tls, __ccgo_ts+44510, libc.VaList(bp+8, (*TChannelState)(unsafe.Pointer(statePtr)).FinputTranslation))
	}
	*(*int32)(unsafe.Pointer(dstLenPtr)) = dstLen
	*(*int32)(unsafe.Pointer(srcLenPtr)) = srcLen
	if srcStart+uintptr(srcLen) == eof {
		/*
		 * EOF character was seen in EOL translated range. Leave current file
		 * position pointing at the EOF character, but don't store the EOF
		 * character in the output string.
		 *
		 * If CHANNEL_ENCODING_ERROR is set, it can only be because of data
		 * encountered after the EOF character, so it is nonsense.  Unset it.
		 */
		*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1)<<libc.Int32FromInt32(9) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(10)
		*(*int32)(unsafe.Pointer(statePtr + 32)) |= int32(TCL_ENCODING_END)
		*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1)<<libc.Int32FromInt32(11) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(12) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(15))
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_Ungets --
 *
 *	Causes the supplied string to be added to the input queue of the
 *	channel, at either the head or tail of the queue.
 *
 * Results:
 *	The number of bytes stored in the channel, or TCL_INDEX_NONE on error.
 *
 * Side effects:
 *	Adds input to the input queue of a channel.
 *
 *----------------------------------------------------------------------
 */

func XTcl_Ungets(tls *libc.TLS, chan1 TTcl_Channel, str uintptr, len1 TTcl_Size, atEnd int32) (r TTcl_Size) {
	/* If non-zero, add at end of queue; otherwise
	 * add at head of queue. */
	var bufPtr, chanPtr, statePtr uintptr
	var flags int32
	_, _, _, _ = bufPtr, chanPtr, flags, statePtr
	chanPtr = chan1
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	/*
	 * This operation should occur at the top of a channel stack.
	 */
	chanPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr
	/*
	 * CheckChannelErrors clears too many flag bits in this one case.
	 */
	flags = (*TChannelState)(unsafe.Pointer(statePtr)).Fflags
	if _CheckChannelErrors(tls, statePtr, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
		len1 = int64(-libc.Int32FromInt32(1))
		goto done
	}
	(*TChannelState)(unsafe.Pointer(statePtr)).Fflags = flags
	/*
	 * Clear the EOF flags, and clear the BLOCKED bit.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(9)) != 0 {
		*(*int32)(unsafe.Pointer(statePtr + 32)) |= int32(TCL_ENCODING_START)
	}
	*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1)<<libc.Int32FromInt32(11) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(10) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(9) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(12))
	*(*int32)(unsafe.Pointer(statePtr + 32)) &= ^libc.Int32FromInt32(TCL_ENCODING_END)
	bufPtr = _AllocChannelBuffer(tls, len1)
	libc.Xmemcpy(tls, bufPtr+40+uintptr((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded), str, libc.Uint64FromInt64(len1))
	*(*TTcl_Size)(unsafe.Pointer(bufPtr + 8)) += len1
	if (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead == libc.UintptrFromInt32(0) {
		(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr = libc.UintptrFromInt32(0)
		(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead = bufPtr
		(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueTail = bufPtr
	} else {
		if atEnd != 0 {
			(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr = libc.UintptrFromInt32(0)
			(*TChannelBuffer)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FinQueueTail)).FnextPtr = bufPtr
			(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueTail = bufPtr
		} else {
			(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead
			(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead = bufPtr
		}
	}
	/*
	 * Update the notifier state so we don't block while there is still data
	 * in the buffers.
	 */
	goto done
done:
	;
	_UpdateInterest(tls, chanPtr)
	return len1
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_Flush --
 *
 *	Flushes output data on a channel.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	May flush output queued on this channel.
 *
 *----------------------------------------------------------------------
 */

func XTcl_Flush(tls *libc.TLS, chan1 TTcl_Channel) (r int32) {
	/* The Channel to flush. */
	var chanPtr, statePtr uintptr
	var result int32
	_, _, _ = chanPtr, result, statePtr /* Of calling FlushChannel. */
	chanPtr = chan1
	/* The actual channel. */
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	/* State of actual channel. */
	/*
	 * This operation should occur at the top of a channel stack.
	 */
	chanPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr
	if _CheckChannelErrors(tls, statePtr, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
		return int32(TCL_ERROR)
	}
	result = _FlushChannel(tls, libc.UintptrFromInt32(0), chanPtr, 0)
	if result != 0 {
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * DiscardInputQueued --
 *
 *	Discards any input read from the channel but not yet consumed by Tcl
 *	reading commands.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	May discard input from the channel. If discardLastBuffer is zero,
 *	leaves one buffer in place for back-filling.
 *
 *----------------------------------------------------------------------
 */

func _DiscardInputQueued(tls *libc.TLS, statePtr uintptr, discardSavedBuffers int32) {
	/* If non-zero, discard all buffers including
	 * last one. */
	var bufPtr, nxtPtr uintptr
	_, _ = bufPtr, nxtPtr
	/* Loop variables. */
	bufPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead
	(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead = libc.UintptrFromInt32(0)
	(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueTail = libc.UintptrFromInt32(0)
	for {
		if !(bufPtr != libc.UintptrFromInt32(0)) {
			break
		}
		nxtPtr = (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr
		_RecycleBuffer(tls, statePtr, bufPtr, discardSavedBuffers)
		goto _1
	_1:
		;
		bufPtr = nxtPtr
	}
	/*
	 * If discardSavedBuffers is nonzero, must also discard any previously
	 * saved buffer in the saveInBufPtr field.
	 */
	if discardSavedBuffers != 0 && (*TChannelState)(unsafe.Pointer(statePtr)).FsaveInBufPtr != libc.UintptrFromInt32(0) {
		_ReleaseChannelBuffer(tls, (*TChannelState)(unsafe.Pointer(statePtr)).FsaveInBufPtr)
		(*TChannelState)(unsafe.Pointer(statePtr)).FsaveInBufPtr = libc.UintptrFromInt32(0)
	}
}

/*
 *---------------------------------------------------------------------------
 *
 * GetInput --
 *
 *	Reads input data from a device into a channel buffer.
 *
 *	IMPORTANT!  This routine is only called on a chanPtr argument
 *	that is the top channel of a stack!
 *
 * Results:
 *	The return value is the Posix error code if an error occurred while
 *	reading from the file, or 0 otherwise.
 *
 * Side effects:
 *	Reads from the underlying device.
 *
 *---------------------------------------------------------------------------
 */

func _GetInput(tls *libc.TLS, chanPtr uintptr) (r int32) {
	/* Channel to read input from. */
	var bufPtr, statePtr uintptr
	var nread, result, toRead int32
	_, _, _, _, _ = bufPtr, nread, result, statePtr, toRead /* New buffer to add to input queue. */
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	/* State info for channel */
	/*
	 * Verify that all callers know better than to call us when
	 * it's recorded that the next char waiting to be read is the
	 * eofchar.
	 */
	/*
	 * Prevent reading from a dead channel -- a channel that has been closed
	 * but not yet deallocated, which can happen if the exit handler for
	 * channel cleanup has run but the channel is still registered in some
	 * interpreter.
	 */
	if _CheckForDeadChannel(tls, libc.UintptrFromInt32(0), statePtr) != 0 {
		return int32(EINVAL)
	}
	/*
	 * WARNING: There was once a comment here claiming that it was a bad idea
	 * to make another call to the inputproc of a channel driver when EOF has
	 * already been detected on the channel.  Through much of Tcl's history,
	 * this warning was then completely negated by having all (most?) read
	 * paths clear the EOF setting before reaching here.  So we had a guard
	 * that was never triggered.
	 *
	 * Don't be tempted to restore the guard.  Even if EOF is set on the
	 * channel, continue through and call the inputproc again.  This is the
	 * way to enable the ability to [read] again beyond the EOF, which seems a
	 * strange thing to do, but for which use cases exist [Tcl Bug 5adc350683]
	 * and which may even be essential for channels representing things like
	 * ttys or other devices where the stream might take the logical form of a
	 * series of 'files' separated by an EOF condition.
	 *
	 * First check for more buffers in the pushback area of the topmost
	 * channel in the stack and use them. They can be the result of a
	 * transformation which went away without reading all the information
	 * placed in the area when it was stacked.
	 */
	if (*TChannel)(unsafe.Pointer(chanPtr)).FinQueueHead != libc.UintptrFromInt32(0) {
		/* TODO: Tests to cover this. */
		(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead = (*TChannel)(unsafe.Pointer(chanPtr)).FinQueueHead
		(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueTail = (*TChannel)(unsafe.Pointer(chanPtr)).FinQueueTail
		(*TChannel)(unsafe.Pointer(chanPtr)).FinQueueHead = libc.UintptrFromInt32(0)
		(*TChannel)(unsafe.Pointer(chanPtr)).FinQueueTail = libc.UintptrFromInt32(0)
		return 0
	}
	/*
	 * Nothing in the pushback area, fall back to the usual handling (driver,
	 * etc.)
	 */
	/*
	 * See if we can fill an existing buffer. If we can, read only as much as
	 * will fit in it. Otherwise allocate a new buffer, add it to the input
	 * queue and attempt to fill it to the max.
	 */
	bufPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueTail
	if bufPtr == libc.UintptrFromInt32(0) || bufPtr != 0 && (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded >= (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FbufLength {
		bufPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FsaveInBufPtr
		(*TChannelState)(unsafe.Pointer(statePtr)).FsaveInBufPtr = libc.UintptrFromInt32(0)
		/*
		 * Check the actual buffersize against the requested buffersize.
		 * Saved buffers of the wrong size are squashed. This is done to honor
		 * dynamic changes of the buffersize made by the user.
		 *
		 * TODO: Tests to cover this.
		 */
		if bufPtr != libc.UintptrFromInt32(0) && (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FbufLength != (*TChannelState)(unsafe.Pointer(statePtr)).FbufSize+int64(BUFFER_PADDING) {
			_ReleaseChannelBuffer(tls, bufPtr)
			bufPtr = libc.UintptrFromInt32(0)
		}
		if bufPtr == libc.UintptrFromInt32(0) {
			bufPtr = _AllocChannelBuffer(tls, (*TChannelState)(unsafe.Pointer(statePtr)).FbufSize)
		}
		(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr = libc.UintptrFromInt32(0)
		toRead = int32((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FbufLength - (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded)
		if (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueTail == libc.UintptrFromInt32(0) {
			(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead = bufPtr
		} else {
			(*TChannelBuffer)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FinQueueTail)).FnextPtr = bufPtr
		}
		(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueTail = bufPtr
	} else {
		toRead = int32((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FbufLength - (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded)
	}
	_PreserveChannelBuffer(tls, bufPtr)
	nread = _ChanRead(tls, chanPtr, bufPtr+40+uintptr((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded), toRead)
	_ReleaseChannelBuffer(tls, bufPtr)
	if nread < 0 {
		result = XTcl_GetErrno(tls)
	} else {
		result = 0
		if (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueTail != libc.UintptrFromInt32(0) {
			*(*TTcl_Size)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FinQueueTail + 8)) += int64(nread)
		}
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_Seek --
 *
 *	Implements seeking on Tcl Channels. This is a public function so that
 *	other C facilities may be implemented on top of it.
 *
 * Results:
 *	The new access point or -1 on error. If error, use Tcl_GetErrno() to
 *	retrieve the POSIX error code for the error that occurred.
 *
 * Side effects:
 *	May flush output on the channel. May discard queued input.
 *
 *----------------------------------------------------------------------
 */

func XTcl_Seek(tls *libc.TLS, chan1 TTcl_Channel, offset int64, mode int32) (r int64) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Relative to which location to seek? */
	var chanPtr, statePtr uintptr
	var curPos int64
	var inputBuffered, outputBuffered, wasAsync int32
	var _ /* result at bp+0 */ int32
	_, _, _, _, _, _ = chanPtr, curPos, inputBuffered, outputBuffered, statePtr, wasAsync
	chanPtr = chan1
	/* The real IO channel. */
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate /* Was the channel nonblocking before the seek
	 * operation? If so, must restore to
	 * non-blocking mode after the seek. */
	if _CheckChannelErrors(tls, statePtr, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
		return int64(-int32(1))
	}
	/*
	 * Disallow seek on dead channels - channels that have been closed but not
	 * yet been deallocated. Such channels can be found if the exit handler
	 * for channel cleanup has run but the channel is still registered in an
	 * interpreter.
	 */
	if _CheckForDeadChannel(tls, libc.UintptrFromInt32(0), statePtr) != 0 {
		return int64(-int32(1))
	}
	/*
	 * This operation should occur at the top of a channel stack.
	 */
	chanPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr
	/*
	 * Disallow seek on channels whose type does not have a seek procedure
	 * defined. This means that the channel does not support seeking.
	 */
	if XTcl_ChannelWideSeekProc(tls, (*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr) == libc.UintptrFromInt32(0) {
		XTcl_SetErrno(tls, int32(EINVAL))
		return int64(-int32(1))
	}
	/*
	 * Compute how much input and output is buffered. If both input and output
	 * is buffered, cannot compute the current position.
	 */
	inputBuffered = XTcl_InputBuffered(tls, chan1)
	outputBuffered = XTcl_OutputBuffered(tls, chan1)
	if inputBuffered != 0 && outputBuffered != 0 {
		XTcl_SetErrno(tls, int32(EFAULT))
		return int64(-int32(1))
	}
	/*
	 * If we are seeking relative to the current position, compute the
	 * corrected offset taking into account the amount of unread input.
	 */
	if mode == int32(1) {
		offset -= int64(inputBuffered)
	}
	/*
	 * Discard any queued input - this input should not be read after the
	 * seek.
	 */
	_DiscardInputQueued(tls, statePtr, 0)
	/*
	 * Reset EOF and BLOCKED flags. We invalidate them by moving the access
	 * point. Also clear CR related flags.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(9)) != 0 {
		*(*int32)(unsafe.Pointer(statePtr + 32)) |= int32(TCL_ENCODING_START)
	}
	*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1)<<libc.Int32FromInt32(9) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(10) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(11) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(12))
	*(*int32)(unsafe.Pointer(statePtr + 32)) &= ^libc.Int32FromInt32(TCL_ENCODING_END)
	/*
	 * If the channel is in asynchronous output mode, switch it back to
	 * synchronous mode and cancel any async flush that may be scheduled.
	 * After the flush, the channel will be put back into asynchronous output
	 * mode.
	 */
	wasAsync = 0
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(6)) != 0 {
		wasAsync = int32(1)
		*(*int32)(unsafe.Pointer(bp)) = _StackSetBlockMode(tls, chanPtr, TCL_MODE_BLOCKING)
		if *(*int32)(unsafe.Pointer(bp)) != 0 {
			return int64(-int32(1))
		}
		*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(6))
		if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(7)) != 0 {
			*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(7))
		}
	}
	/*
	 * If the flush fails we cannot recover the original position. In that
	 * case the seek is not attempted because we do not know where the access
	 * position is - instead we return the error. FlushChannel has already
	 * called Tcl_SetErrno() to report the error upwards. If the flush
	 * succeeds we do the seek also.
	 */
	if _FlushChannel(tls, libc.UintptrFromInt32(0), chanPtr, 0) != 0 {
		curPos = int64(-int32(1))
	} else {
		/*
		 * Now seek to the new position in the channel as requested by the
		 * caller.
		 */
		curPos = _ChanSeek(tls, chanPtr, offset, mode, bp)
		if curPos == int64(-int32(1)) {
			XTcl_SetErrno(tls, *(*int32)(unsafe.Pointer(bp)))
		}
	}
	/*
	 * Restore to nonblocking mode if that was the previous behavior.
	 *
	 * NOTE: Even if there was an async flush active we do not restore it now
	 * because we already flushed all the queued output, above.
	 */
	if wasAsync != 0 {
		*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(6)
		*(*int32)(unsafe.Pointer(bp)) = _StackSetBlockMode(tls, chanPtr, int32(TCL_MODE_NONBLOCKING))
		if *(*int32)(unsafe.Pointer(bp)) != 0 {
			return int64(-int32(1))
		}
	}
	return curPos
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_Tell --
 *
 *	Returns the position of the next character to be read/written on this
 *	channel.
 *
 * Results:
 *	A nonnegative integer on success, -1 on failure. If failed, use
 *	Tcl_GetErrno() to retrieve the POSIX error code for the error that
 *	occurred.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_Tell(tls *libc.TLS, chan1 TTcl_Channel) (r int64) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The channel to return pos for. */
	var chanPtr, statePtr uintptr
	var curPos int64
	var inputBuffered, outputBuffered int32
	var _ /* result at bp+0 */ int32
	_, _, _, _, _ = chanPtr, curPos, inputBuffered, outputBuffered, statePtr
	chanPtr = chan1
	/* The real IO channel. */
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate /* Position on device. */
	if _CheckChannelErrors(tls, statePtr, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
		return int64(-int32(1))
	}
	/*
	 * Disallow tell on dead channels -- channels that have been closed but
	 * not yet been deallocated. Such channels can be found if the exit
	 * handler for channel cleanup has run but the channel is still registered
	 * in an interpreter.
	 */
	if _CheckForDeadChannel(tls, libc.UintptrFromInt32(0), statePtr) != 0 {
		return int64(-int32(1))
	}
	/*
	 * This operation should occur at the top of a channel stack.
	 */
	chanPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr
	/*
	 * Disallow tell on channels whose type does not have a seek procedure
	 * defined. This means that the channel does not support seeking.
	 */
	if XTcl_ChannelWideSeekProc(tls, (*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr) == libc.UintptrFromInt32(0) {
		XTcl_SetErrno(tls, int32(EINVAL))
		return int64(-int32(1))
	}
	/*
	 * Compute how much input and output is buffered. If both input and output
	 * is buffered, cannot compute the current position.
	 */
	inputBuffered = XTcl_InputBuffered(tls, chan1)
	outputBuffered = XTcl_OutputBuffered(tls, chan1)
	/*
	 * Get the current position in the device and compute the position where
	 * the next character will be read or written. Note that we prefer the
	 * wideSeekProc if that is available and non-NULL...
	 */
	curPos = _ChanSeek(tls, chanPtr, 0, int32(1), bp)
	if curPos == int64(-int32(1)) {
		XTcl_SetErrno(tls, *(*int32)(unsafe.Pointer(bp)))
		return int64(-int32(1))
	}
	if inputBuffered != 0 {
		return curPos - int64(inputBuffered)
	}
	return curPos + int64(outputBuffered)
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_TruncateChannel --
 *
 *	Truncate a channel to the given length.
 *
 * Results:
 *	TCL_OK on success, TCL_ERROR if the operation failed (e.g., is not
 *	supported by the type of channel, or the underlying OS operation
 *	failed in some way).
 *
 * Side effects:
 *	Seeks the channel to the current location. Sets errno on OS error.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_TruncateChannel(tls *libc.TLS, chan1 TTcl_Channel, length int64) (r int32) {
	/* Length to truncate it to. */
	var chanPtr, truncateProc uintptr
	var result int32
	_, _, _ = chanPtr, result, truncateProc
	chanPtr = chan1
	truncateProc = XTcl_ChannelTruncateProc(tls, (*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr)
	if truncateProc == libc.UintptrFromInt32(0) {
		/*
		 * Feature not supported and it's not emulatable. Pretend it's
		 * returned an EINVAL, a very generic error!
		 */
		XTcl_SetErrno(tls, int32(EINVAL))
		return int32(TCL_ERROR)
	}
	if !((*TChannelState1)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).Fstate)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0) {
		/*
		 * We require that the file was opened of writing. Do that check now
		 * so that we only flush if we think we're going to succeed.
		 */
		XTcl_SetErrno(tls, int32(EINVAL))
		return int32(TCL_ERROR)
	}
	/*
	 * Seek first to force a total flush of all pending buffers and ditch any
	 * preread input data.
	 */
	_WillWrite(tls, chanPtr)
	if _WillRead(tls, chanPtr) == -int32(1) {
		return int32(TCL_ERROR)
	}
	/*
	 * We're all flushed to disk now and we also don't have any unfortunate
	 * input baggage around either; can truncate with impunity.
	 */
	result = (*(*func(*libc.TLS, uintptr, int64) int32)(unsafe.Pointer(&struct{ uintptr }{truncateProc})))(tls, (*TChannel)(unsafe.Pointer(chanPtr)).FinstanceData, length)
	if result != 0 {
		XTcl_SetErrno(tls, result)
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *---------------------------------------------------------------------------
 *
 * CheckChannelErrors --
 *
 *	See if the channel is in an ready state and can perform the desired
 *	operation.
 *
 * Results:
 *	The return value is 0 if the channel is OK, otherwise the return value
 *	is -1 and errno is set to indicate the error.
 *
 * Side effects:
 *	May clear the EOF and/or BLOCKED bits if reading from channel.
 *
 *---------------------------------------------------------------------------
 */

func _CheckChannelErrors(tls *libc.TLS, statePtr uintptr, flags int32) (r int32) {
	/* Test if channel supports desired operation:
	 * TCL_READABLE, TCL_WRITABLE. Also indicates
	 * Raw read or write for special close
	 * processing */
	var cachePtr, v2 uintptr
	var direction int32
	var v1 TTcl_Size
	var v3 bool
	_, _, _, _, _ = cachePtr, direction, v1, v2, v3
	direction = flags & (libc.Int32FromInt32(1)<<libc.Int32FromInt32(1) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(2))
	/*
	 * Check for unreported error.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).FunreportedError != 0 {
		XTcl_SetErrno(tls, (*TChannelState)(unsafe.Pointer(statePtr)).FunreportedError)
		(*TChannelState)(unsafe.Pointer(statePtr)).FunreportedError = 0
		/*
		 * TIP #219, Tcl Channel Reflection API.
		 * Move a deferred error message back into the channel bypass.
		 */
		if (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg != libc.UintptrFromInt32(0) {
			v2 = (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if !(v1 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).Flength = int64(-libc.Int32FromInt32(1))
					if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
						cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)
				}
			}
		}
		(*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg = (*TChannelState)(unsafe.Pointer(statePtr)).FunreportedMsg
		(*TChannelState)(unsafe.Pointer(statePtr)).FunreportedMsg = libc.UintptrFromInt32(0)
		return -int32(1)
	}
	/*
	 * Only the raw read and write operations are allowed during close in
	 * order to drain data from stacked channels.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(8)) != 0 && !(flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(16)) != 0) {
		XTcl_SetErrno(tls, int32(EACCES))
		return -int32(1)
	}
	/*
	 * Fail if the channel is not opened for desired operation.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&direction == 0 {
		XTcl_SetErrno(tls, int32(EACCES))
		return -int32(1)
	}
	/*
	 * Fail if the channel is in the middle of a background copy.
	 *
	 * Don't do this tests for raw channels here or else the chaining in the
	 * transformation drivers will fail with 'file busy' error instead of
	 * retrieving and transforming the data to copy.
	 */
	if ((*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrR != 0 && flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 || (*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrW != 0 && flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0) && flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(16)) == 0 {
		XTcl_SetErrno(tls, int32(EBUSY))
		return -int32(1)
	}
	if direction == libc.Int32FromInt32(1)<<libc.Int32FromInt32(1) {
		*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(14))
	}
	return 0
}

/*
 *----------------------------------------------------------------------
 *
 * TclChanIsBinary --
 *
 *	Returns 1 if the channel is a binary channel, 0 otherwise.
 *
 * Results:
 *	1 or 0, always.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclChanIsBinary(tls *libc.TLS, chan1 TTcl_Channel) (r int32) {
	/* Does this channel have EOF? */
	var statePtr uintptr
	_ = statePtr
	statePtr = (*TChannel)(unsafe.Pointer(chan1)).Fstate
	/* State of real channel structure. */
	return libc.BoolInt32((*TChannelState)(unsafe.Pointer(statePtr)).Fencoding == _GetBinaryEncoding(tls) && !((*TChannelState)(unsafe.Pointer(statePtr)).FinEofChar != 0) && (!((*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0) || (*TChannelState)(unsafe.Pointer(statePtr)).FinputTranslation == int32(TCL_TRANSLATE_LF)) && (!((*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0) || (*TChannelState)(unsafe.Pointer(statePtr)).FoutputTranslation == int32(TCL_TRANSLATE_LF)))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_Eof --
 *
 *	Returns 1 if the channel is at EOF, 0 otherwise.
 *
 * Results:
 *	1 or 0, always.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_Eof(tls *libc.TLS, chan1 TTcl_Channel) (r int32) {
	/* Does this channel have EOF? */
	var statePtr uintptr
	var v1 int32
	_, _ = statePtr, v1
	statePtr = (*TChannel)(unsafe.Pointer(chan1)).Fstate
	/* State of real channel structure. */
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(15)) != 0 {
		return 0
	}
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(9)) != 0 {
		v1 = int32(1)
	} else {
		v1 = 0
	}
	return v1
}

/*
 *----------------------------------------------------------------------
 *
 * TclChannelGetBlockingMode --
 *
 *	Returns 1 if the channel is in blocking mode (default), 0 otherwise.
 *
 * Results:
 *	1 or 0, always.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclChannelGetBlockingMode(tls *libc.TLS, chan1 TTcl_Channel) (r int32) {
	var statePtr uintptr
	var v1 int32
	_, _ = statePtr, v1
	statePtr = (*TChannel)(unsafe.Pointer(chan1)).Fstate
	/* State of real channel structure. */
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(6)) != 0 {
		v1 = 0
	} else {
		v1 = int32(1)
	}
	return v1
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_InputBlocked --
 *
 *	Returns 1 if input is blocked on this channel, 0 otherwise.
 *
 * Results:
 *	0 or 1, always.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_InputBlocked(tls *libc.TLS, chan1 TTcl_Channel) (r int32) {
	/* Is this channel blocked? */
	var statePtr uintptr
	var v1 int32
	_, _ = statePtr, v1
	statePtr = (*TChannel)(unsafe.Pointer(chan1)).Fstate
	/* State of real channel structure. */
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(11)) != 0 {
		v1 = int32(1)
	} else {
		v1 = 0
	}
	return v1
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_InputBuffered --
 *
 *	Returns the number of bytes of input currently buffered in the common
 *	internal buffer of a channel.
 *
 * Results:
 *	The number of input bytes buffered, or zero if the channel is not open
 *	for reading.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_InputBuffered(tls *libc.TLS, chan1 TTcl_Channel) (r int32) {
	/* The channel to query. */
	var bufPtr, statePtr uintptr
	var bytesBuffered int32
	_, _, _ = bufPtr, bytesBuffered, statePtr
	statePtr = (*TChannel)(unsafe.Pointer(chan1)).Fstate
	bytesBuffered = 0
	bufPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead
	for {
		if !(bufPtr != libc.UintptrFromInt32(0)) {
			break
		}
		bytesBuffered = int32(int64(bytesBuffered) + ((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded - (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved))
		goto _1
	_1:
		;
		bufPtr = (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr
	}
	/*
	 * Remember the bytes in the topmost pushback area.
	 */
	bufPtr = (*TChannel)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr)).FinQueueHead
	for {
		if !(bufPtr != libc.UintptrFromInt32(0)) {
			break
		}
		bytesBuffered = int32(int64(bytesBuffered) + ((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded - (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved))
		goto _2
	_2:
		;
		bufPtr = (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr
	}
	return bytesBuffered
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_OutputBuffered --
 *
 *    Returns the number of bytes of output currently buffered in the common
 *    internal buffer of a channel.
 *
 * Results:
 *    The number of output bytes buffered, or zero if the channel is not open
 *    for writing.
 *
 * Side effects:
 *    None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_OutputBuffered(tls *libc.TLS, chan1 TTcl_Channel) (r int32) {
	/* The channel to query. */
	var bufPtr, curOutPtr, statePtr uintptr
	var bytesBuffered int32
	_, _, _, _ = bufPtr, bytesBuffered, curOutPtr, statePtr
	statePtr = (*TChannel)(unsafe.Pointer(chan1)).Fstate
	bytesBuffered = 0
	bufPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FoutQueueHead
	for {
		if !(bufPtr != libc.UintptrFromInt32(0)) {
			break
		}
		bytesBuffered = int32(int64(bytesBuffered) + ((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded - (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved))
		goto _1
	_1:
		;
		bufPtr = (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr
	}
	if (*TChannelState)(unsafe.Pointer(statePtr)).FcurOutPtr != libc.UintptrFromInt32(0) {
		curOutPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FcurOutPtr
		if (*TChannelBuffer)(unsafe.Pointer(curOutPtr)).FnextAdded > (*TChannelBuffer)(unsafe.Pointer(curOutPtr)).FnextRemoved {
			bytesBuffered = int32(int64(bytesBuffered) + ((*TChannelBuffer)(unsafe.Pointer(curOutPtr)).FnextAdded - (*TChannelBuffer)(unsafe.Pointer(curOutPtr)).FnextRemoved))
		}
	}
	return bytesBuffered
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ChannelBuffered --
 *
 *	Returns the number of bytes of input currently buffered in the
 *	internal buffer (push back area) of a channel.
 *
 * Results:
 *	The number of input bytes buffered, or zero if the channel is not open
 *	for reading.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ChannelBuffered(tls *libc.TLS, chan1 TTcl_Channel) (r int32) {
	/* The channel to query. */
	var bufPtr, chanPtr uintptr
	var bytesBuffered int32
	_, _, _ = bufPtr, bytesBuffered, chanPtr
	chanPtr = chan1
	bytesBuffered = 0
	bufPtr = (*TChannel)(unsafe.Pointer(chanPtr)).FinQueueHead
	for {
		if !(bufPtr != libc.UintptrFromInt32(0)) {
			break
		}
		bytesBuffered = int32(int64(bytesBuffered) + ((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded - (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved))
		goto _1
	_1:
		;
		bufPtr = (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr
	}
	return bytesBuffered
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetChannelBufferSize --
 *
 *	Sets the size of buffers to allocate to store input or output in the
 *	channel. The size must be between 1 byte and 1 MByte.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Sets the size of buffers subsequently allocated for this channel.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetChannelBufferSize(tls *libc.TLS, chan1 TTcl_Channel, sz TTcl_Size) {
	/* The size to set. */
	var statePtr uintptr
	_ = statePtr /* State of real channel structure. */
	/*
	 * Clip the buffer size to force it into the [1,1M] range
	 */
	if sz < int64(1) {
		sz = int64(1)
	} else {
		if sz > int64(libc.Int32FromInt32(1024)*libc.Int32FromInt32(1024)) {
			sz = int64(libc.Int32FromInt32(1024) * libc.Int32FromInt32(1024))
		}
	}
	statePtr = (*TChannel)(unsafe.Pointer(chan1)).Fstate
	if (*TChannelState)(unsafe.Pointer(statePtr)).FbufSize == sz {
		return
	}
	(*TChannelState)(unsafe.Pointer(statePtr)).FbufSize = sz
	/*
	 * If bufsize changes, need to get rid of old utility buffer.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).FsaveInBufPtr != libc.UintptrFromInt32(0) {
		_RecycleBuffer(tls, statePtr, (*TChannelState)(unsafe.Pointer(statePtr)).FsaveInBufPtr, int32(1))
		(*TChannelState)(unsafe.Pointer(statePtr)).FsaveInBufPtr = libc.UintptrFromInt32(0)
	}
	if (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead != libc.UintptrFromInt32(0) && (*TChannelBuffer)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead)).FnextPtr == libc.UintptrFromInt32(0) && (*TChannelBuffer)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead)).FnextAdded == (*TChannelBuffer)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead)).FnextRemoved {
		_RecycleBuffer(tls, statePtr, (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead, int32(1))
		(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead = libc.UintptrFromInt32(0)
		(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueTail = libc.UintptrFromInt32(0)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetChannelBufferSize --
 *
 *	Retrieves the size of buffers to allocate for this channel.
 *
 * Results:
 *	The size.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetChannelBufferSize(tls *libc.TLS, chan1 TTcl_Channel) (r TTcl_Size) {
	/* The channel for which to find the buffer
	 * size. */
	var statePtr uintptr
	_ = statePtr
	statePtr = (*TChannel)(unsafe.Pointer(chan1)).Fstate
	/* State of real channel structure. */
	return (*TChannelState)(unsafe.Pointer(statePtr)).FbufSize
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_BadChannelOption --
 *
 *	This procedure generates a "bad option" error message in an (optional)
 *	interpreter. It is used by channel drivers when a invalid Set/Get
 *	option is requested. Its purpose is to concatenate the generic options
 *	list to the specific ones and factorize the generic options error
 *	message string.
 *
 * Results:
 *	TCL_ERROR.
 *
 * Side effects:

 *	An error message is generated in interp's result object to indicate
 *	that a command was invoked with a bad option. The message has the
 *	form:
 *		bad option "blah": should be one of
 *		<...generic options...>+<...specific options...>
 *	"blah" is the optionName argument and "<specific options>" is a space
 *	separated list of specific option words. The function takes good care
 *	of inserting minus signs before each option, commas after, and an "or"
 *	before the last option.
 *
 *----------------------------------------------------------------------
 */

func XTcl_BadChannelOption(tls *libc.TLS, interp uintptr, optionName uintptr, optionList uintptr) (r int32) {
	bp := tls.Alloc(256)
	defer tls.Free(256) /* Specific options list to append to the
	 * standard generic options. Can be NULL for
	 * generic options only. */
	var errObj, genericopt, v1 uintptr
	var i TTcl_Size
	var _ /* argc at bp+8 */ TTcl_Size
	var _ /* argv at bp+0 */ uintptr
	var _ /* ds at bp+16 */ TTcl_DString
	_, _, _, _ = errObj, genericopt, i, v1
	if interp != libc.UintptrFromInt32(0) {
		genericopt = __ccgo_ts + 44539
		XTcl_DStringInit(tls, bp+16)
		XTcl_DStringAppend(tls, bp+16, genericopt, int64(-int32(1)))
		if optionList != 0 && *(*uint8)(unsafe.Pointer(optionList)) != 0 {
			XTcl_DStringAppend(tls, bp+16, __ccgo_ts+14830, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))
			XTcl_DStringAppend(tls, bp+16, optionList, int64(-int32(1)))
		}
		if XTcl_SplitList(tls, interp, (*TTcl_DString)(unsafe.Pointer(bp+16)).Fstring1, bp+8, bp) != TCL_OK {
			XTcl_Panic(tls, __ccgo_ts+44606, 0)
		}
		XTcl_ResetResult(tls, interp)
		if optionName != 0 {
			v1 = optionName
		} else {
			v1 = __ccgo_ts + 1945
		}
		errObj = XTcl_ObjPrintf(tls, __ccgo_ts+44646, libc.VaList(bp+248, v1))
		*(*TTcl_Size)(unsafe.Pointer(bp + 8))--
		i = 0
		for {
			if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) {
				break
			}
			XTcl_AppendPrintfToObj(tls, errObj, __ccgo_ts+44681, libc.VaList(bp+248, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(i)*8))))
			goto _2
		_2:
			;
			i++
		}
		XTcl_AppendPrintfToObj(tls, errObj, __ccgo_ts+44687, libc.VaList(bp+248, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(i)*8))))
		XTcl_SetObjResult(tls, interp, errObj)
		XTcl_DStringFree(tls, bp+16)
		XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp)))
	}
	XTcl_SetErrno(tls, int32(EINVAL))
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetChannelOption --
 *
 *	Gets a mode associated with an IO channel. If the optionName arg is
 *	non NULL, retrieves the value of that option. If the optionName arg is
 *	NULL, retrieves a list of alternating option names and values for the
 *	given channel.
 *
 * Results:
 *	A standard Tcl result. Also sets the supplied DString to the string
 *	value of the option(s) returned.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetChannelOption(tls *libc.TLS, interp uintptr, chan1 TTcl_Channel, optionName uintptr, dsPtr uintptr) (r int32) {
	bp := tls.Alloc(160)
	defer tls.Free(160) /* Where to store value(s). */
	var chanPtr, profileName, statePtr, v1 uintptr
	var flags, profile int32
	var len1 Tsize_t
	var _ /* buf at bp+128 */ [4]uint8
	var _ /* optionVal at bp+0 */ [128]uint8
	_, _, _, _, _, _, _ = chanPtr, flags, len1, profile, profileName, statePtr, v1 /* Buffer for snprintf. */
	chanPtr = chan1
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	/*
	 * Disallow options on dead channels -- channels that have been closed but
	 * not yet been deallocated. Such channels can be found if the exit
	 * handler for channel cleanup has run but the channel is still registered
	 * in an interpreter.
	 */
	if _CheckForDeadChannel(tls, interp, statePtr) != 0 {
		return int32(TCL_ERROR)
	}
	/*
	 * This operation should occur at the top of a channel stack.
	 */
	chanPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr
	/*
	 * If we are in the middle of a background copy, use the saved flags.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrR != 0 {
		flags = (*TCopyState1)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrR)).FreadFlags
	} else {
		if (*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrW != 0 {
			flags = (*TCopyState1)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrW)).FwriteFlags
		} else {
			flags = (*TChannelState)(unsafe.Pointer(statePtr)).Fflags
		}
	}
	/*
	 * If the optionName is NULL it means that we want a list of all options
	 * and values.
	 */
	if optionName == libc.UintptrFromInt32(0) {
		len1 = uint64(0)
	} else {
		len1 = libc.Xstrlen(tls, optionName)
	}
	if len1 == uint64(0) || len1 > libc.Uint64FromInt32(libc.Int32FromInt32(2)) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(optionName + 1))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 42927 + 1))) && libc.Xstrncmp(tls, optionName, __ccgo_ts+42927, len1) == 0 {
		if len1 == uint64(0) {
			XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+42927)
		}
		if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(6)) != 0 {
			v1 = __ccgo_ts + 14828
		} else {
			v1 = __ccgo_ts + 21397
		}
		XTcl_DStringAppendElement(tls, dsPtr, v1)
		if len1 > uint64(0) {
			return TCL_OK
		}
	}
	if len1 == uint64(0) || len1 > libc.Uint64FromInt32(libc.Int32FromInt32(7)) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(optionName + 1))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 44694 + 1))) && libc.Xstrncmp(tls, optionName, __ccgo_ts+44694, len1) == 0 {
		if len1 == uint64(0) {
			XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+44694)
		}
		if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(17)) != 0 {
			XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+16589)
		} else {
			if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(18)) != 0 {
				XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+44705)
			} else {
				XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+44710)
			}
		}
		if len1 > uint64(0) {
			return TCL_OK
		}
	}
	if len1 == uint64(0) || len1 > libc.Uint64FromInt32(libc.Int32FromInt32(7)) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(optionName + 1))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 44715 + 1))) && libc.Xstrncmp(tls, optionName, __ccgo_ts+44715, len1) == 0 {
		if len1 == uint64(0) {
			XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+44715)
		}
		XTclFormatInt(tls, bp, (*TChannelState)(unsafe.Pointer(statePtr)).FbufSize)
		XTcl_DStringAppendElement(tls, dsPtr, bp)
		if len1 > uint64(0) {
			return TCL_OK
		}
	}
	if len1 == uint64(0) || len1 > libc.Uint64FromInt32(libc.Int32FromInt32(2)) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(optionName + 1))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 19036 + 1))) && libc.Xstrncmp(tls, optionName, __ccgo_ts+19036, len1) == 0 {
		if len1 == uint64(0) {
			XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+19036)
		}
		XTcl_DStringAppendElement(tls, dsPtr, XTcl_GetEncodingName(tls, (*TChannelState)(unsafe.Pointer(statePtr)).Fencoding))
		if len1 > uint64(0) {
			return TCL_OK
		}
	}
	if len1 == uint64(0) || len1 > libc.Uint64FromInt32(libc.Int32FromInt32(2)) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(optionName + 1))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 44727 + 1))) && libc.Xstrncmp(tls, optionName, __ccgo_ts+44727, len1) == 0 {
		*(*[4]uint8)(unsafe.Pointer(bp + 128)) = [4]uint8{}
		if len1 == uint64(0) {
			XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+44727)
		}
		if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 && (*TChannelState)(unsafe.Pointer(statePtr)).FinEofChar != 0 {
			libc.X__builtin_snprintf(tls, bp+128, uint64(4), __ccgo_ts+28180, libc.VaList(bp+144, (*TChannelState)(unsafe.Pointer(statePtr)).FinEofChar))
		}
		if len1 > uint64(0) {
			XTcl_DStringAppend(tls, dsPtr, bp+128, int64(-int32(1)))
			return TCL_OK
		}
		XTcl_DStringAppendElement(tls, dsPtr, bp+128)
	}
	if len1 == uint64(0) || len1 > libc.Uint64FromInt32(libc.Int32FromInt32(1)) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(optionName + 1))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 15022 + 1))) && libc.Xstrncmp(tls, optionName, __ccgo_ts+15022, len1) == 0 {
		if len1 == uint64(0) {
			XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+15022)
		}
		/* Note currently input and output profiles are same */
		profile = libc.Int32FromUint32(libc.Uint32FromInt32((*TChannelState)(unsafe.Pointer(statePtr)).FinputEncodingFlags) & libc.Uint32FromUint32(ENCODING_PROFILE_MASK))
		profileName = XTclEncodingProfileIdToName(tls, interp, profile)
		if profileName == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
		XTcl_DStringAppendElement(tls, dsPtr, profileName)
		if len1 > uint64(0) {
			return TCL_OK
		}
	}
	if len1 == uint64(0) || len1 > libc.Uint64FromInt32(libc.Int32FromInt32(1)) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(optionName + 1))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 44736 + 1))) && libc.Xstrncmp(tls, optionName, __ccgo_ts+44736, len1) == 0 {
		if len1 == uint64(0) {
			XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+44736)
		}
		if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) == libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(2) && len1 == uint64(0) {
			XTcl_DStringStartSublist(tls, dsPtr)
		}
		if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
			if (*TChannelState)(unsafe.Pointer(statePtr)).FinputTranslation == int32(TCL_TRANSLATE_AUTO) {
				XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+44749)
			} else {
				if (*TChannelState)(unsafe.Pointer(statePtr)).FinputTranslation == int32(TCL_TRANSLATE_CR) {
					XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+44754)
				} else {
					if (*TChannelState)(unsafe.Pointer(statePtr)).FinputTranslation == int32(TCL_TRANSLATE_CRLF) {
						XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+44757)
					} else {
						XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+44762)
					}
				}
			}
		}
		if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
			if (*TChannelState)(unsafe.Pointer(statePtr)).FoutputTranslation == int32(TCL_TRANSLATE_AUTO) {
				XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+44749)
			} else {
				if (*TChannelState)(unsafe.Pointer(statePtr)).FoutputTranslation == int32(TCL_TRANSLATE_CR) {
					XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+44754)
				} else {
					if (*TChannelState)(unsafe.Pointer(statePtr)).FoutputTranslation == int32(TCL_TRANSLATE_CRLF) {
						XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+44757)
					} else {
						XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+44762)
					}
				}
			}
		}
		if !(flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0) {
			/*
			 * Not readable or writable (e.g. server socket)
			 */
			XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+44749)
		}
		if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) == libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(2) && len1 == uint64(0) {
			XTcl_DStringEndSublist(tls, dsPtr)
		}
		if len1 > uint64(0) {
			return TCL_OK
		}
	}
	if (*TTcl_ChannelType)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr)).FgetOptionProc != libc.UintptrFromInt32(0) {
		/*
		 * Let the driver specific handle additional options and result code
		 * and message.
		 */
		return (*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ChannelType)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr)).FgetOptionProc})))(tls, (*TChannel)(unsafe.Pointer(chanPtr)).FinstanceData, interp, optionName, dsPtr)
	} else {
		/*
		 * No driver specific options case.
		 */
		if len1 == uint64(0) {
			return TCL_OK
		}
		return XTcl_BadChannelOption(tls, interp, optionName, libc.UintptrFromInt32(0))
	}
	return r
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_SetChannelOption --
 *
 *	Sets an option on a channel.
 *
 * Results:
 *	A standard Tcl result. On error, sets interp's result object if
 *	interp is not NULL.
 *
 * Side effects:
 *	May modify an option on a device.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_SetChannelOption(tls *libc.TLS, interp uintptr, chan1 TTcl_Channel, optionName uintptr, newValue uintptr) (r int32) {
	bp := tls.Alloc(112)
	defer tls.Free(112) /* New value for option. */
	var chanPtr, readMode, statePtr, writeMode, v10, v11, v12, v9, p1, p2, p3, p4, p5, p6, p7, p8 uintptr
	var code, profile int32
	var encoding TTcl_Encoding
	var len1 Tsize_t
	var translation TTclEolTranslation
	var _ /* argc at bp+0 */ TTcl_Size
	var _ /* argv at bp+8 */ uintptr
	var _ /* newBufferSize at bp+24 */ TTcl_WideInt
	var _ /* newMode at bp+16 */ int32
	var _ /* obj at bp+32 */ TTcl_Obj
	var _ /* profile at bp+80 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = chanPtr, code, encoding, len1, profile, readMode, statePtr, translation, writeMode, v10, v11, v12, v9, p1, p2, p3, p4, p5, p6, p7, p8
	chanPtr = chan1
	/* The real IO channel. */
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	*(*uintptr)(unsafe.Pointer(bp + 8)) = libc.UintptrFromInt32(0)
	/*
	 * If the channel is in the middle of a background copy, fail.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrR != 0 || (*TChannelState)(unsafe.Pointer(statePtr)).FcsPtrW != 0 {
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+44765, int64(-int32(1))))
		}
		return int32(TCL_ERROR)
	}
	/*
	 * Disallow options on dead channels -- channels that have been closed but
	 * not yet been deallocated. Such channels can be found if the exit
	 * handler for channel cleanup has run but the channel is still registered
	 * in an interpreter.
	 */
	if _CheckForDeadChannel(tls, libc.UintptrFromInt32(0), statePtr) != 0 {
		return int32(TCL_ERROR)
	}
	/*
	 * This operation should occur at the top of a channel stack.
	 */
	chanPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr
	len1 = libc.Xstrlen(tls, optionName)
	if len1 > libc.Uint64FromInt32(libc.Int32FromInt32(2)) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(optionName + 1))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 42927 + 1))) && libc.Xstrncmp(tls, optionName, __ccgo_ts+42927, len1) == 0 {
		if XTcl_GetBool(tls, interp, newValue, (libc.Int32FromInt32(TCL_NULL_OK)-libc.Int32FromInt32(2))&libc.Int32FromInt64(4), bp+16) == int32(TCL_ERROR) {
			return int32(TCL_ERROR)
		}
		if *(*int32)(unsafe.Pointer(bp + 16)) != 0 {
			*(*int32)(unsafe.Pointer(bp + 16)) = TCL_MODE_BLOCKING
		} else {
			*(*int32)(unsafe.Pointer(bp + 16)) = int32(TCL_MODE_NONBLOCKING)
		}
		return _SetBlockMode(tls, interp, chanPtr, *(*int32)(unsafe.Pointer(bp + 16)))
	} else {
		if len1 > libc.Uint64FromInt32(libc.Int32FromInt32(7)) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(optionName + 1))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 44694 + 1))) && libc.Xstrncmp(tls, optionName, __ccgo_ts+44694, len1) == 0 {
			len1 = libc.Xstrlen(tls, newValue)
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(newValue))) == int32('f') && libc.Xstrncmp(tls, newValue, __ccgo_ts+44710, len1) == 0 {
				*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1)<<libc.Int32FromInt32(18) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(17))
			} else {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(newValue))) == int32('l') && libc.Xstrncmp(tls, newValue, __ccgo_ts+16589, len1) == 0 {
					*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(18))
					*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(17)
				} else {
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(newValue))) == int32('n') && libc.Xstrncmp(tls, newValue, __ccgo_ts+44705, len1) == 0 {
						*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(17))
						*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(18)
					} else {
						if interp != 0 {
							XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+44824, int64(-int32(1))))
							return int32(TCL_ERROR)
						}
					}
				}
			}
			return TCL_OK
		} else {
			if len1 > libc.Uint64FromInt32(libc.Int32FromInt32(7)) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(optionName + 1))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 44715 + 1))) && libc.Xstrncmp(tls, optionName, __ccgo_ts+44715, len1) == 0 {
				(*(*TTcl_Obj)(unsafe.Pointer(bp + 32))).FrefCount = int64(1)
				(*(*TTcl_Obj)(unsafe.Pointer(bp + 32))).Fbytes = newValue
				(*(*TTcl_Obj)(unsafe.Pointer(bp + 32))).Flength = libc.Int64FromUint64(libc.Xstrlen(tls, newValue))
				(*(*TTcl_Obj)(unsafe.Pointer(bp + 32))).FtypePtr = libc.UintptrFromInt32(0)
				code = XTcl_GetWideIntFromObj(tls, interp, bp+32, bp+24)
				if (*TTcl_Obj)(unsafe.Pointer(bp+32)).FtypePtr != libc.UintptrFromInt32(0) {
					if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(bp+32)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
						(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(bp + 32)).FtypePtr)).FfreeIntRepProc})))(tls, bp+32)
					}
					(*TTcl_Obj)(unsafe.Pointer(bp + 32)).FtypePtr = libc.UintptrFromInt32(0)
				}
				if code == int32(TCL_ERROR) {
					return int32(TCL_ERROR)
				}
				XTcl_SetChannelBufferSize(tls, chan1, *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)))
				return TCL_OK
			} else {
				if len1 > libc.Uint64FromInt32(libc.Int32FromInt32(2)) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(optionName + 1))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 19036 + 1))) && libc.Xstrncmp(tls, optionName, __ccgo_ts+19036, len1) == 0 {
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(newValue))) == int32('\000') || !(libc.Xstrcmp(tls, newValue, __ccgo_ts+10664) != 0) {
						if interp != 0 {
							XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+44885, libc.VaList(bp+96, newValue)))
						}
						return int32(TCL_ERROR)
					} else {
						encoding = XTcl_GetEncoding(tls, interp, newValue)
						if encoding == libc.UintptrFromInt32(0) {
							return int32(TCL_ERROR)
						}
					}
					/*
					 * When the channel has an escape sequence driven encoding such as
					 * iso2022, the terminated escape sequence must write to the buffer.
					 */
					if (*TChannelState)(unsafe.Pointer(statePtr)).Fencoding != _GetBinaryEncoding(tls) && !((*TChannelState)(unsafe.Pointer(statePtr)).FoutputEncodingFlags&libc.Int32FromInt32(TCL_ENCODING_START) != 0) && _CheckChannelErrors(tls, statePtr, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) == 0 {
						*(*int32)(unsafe.Pointer(statePtr + 48)) |= int32(TCL_ENCODING_END)
						_Write(tls, chanPtr, __ccgo_ts+1945, 0, (*TChannelState1)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).Fstate)).Fencoding)
					}
					XTcl_FreeEncoding(tls, (*TChannelState)(unsafe.Pointer(statePtr)).Fencoding)
					(*TChannelState)(unsafe.Pointer(statePtr)).Fencoding = encoding
					(*TChannelState)(unsafe.Pointer(statePtr)).FinputEncodingState = libc.UintptrFromInt32(0)
					profile = libc.Int32FromUint32(libc.Uint32FromInt32((*TChannelState)(unsafe.Pointer(statePtr)).FinputEncodingFlags) & libc.Uint32FromUint32(ENCODING_PROFILE_MASK))
					(*TChannelState)(unsafe.Pointer(statePtr)).FinputEncodingFlags = int32(TCL_ENCODING_START)
					p1 = statePtr + 32
					*(*int32)(unsafe.Pointer(p1)) = int32(uint32(*(*int32)(unsafe.Pointer(p1))) & ^libc.Uint32FromUint32(ENCODING_PROFILE_MASK))
					p2 = statePtr + 32
					*(*int32)(unsafe.Pointer(p2)) = int32(uint32(*(*int32)(unsafe.Pointer(p2))) | libc.Uint32FromInt32(profile)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK))
					(*TChannelState)(unsafe.Pointer(statePtr)).FoutputEncodingState = libc.UintptrFromInt32(0)
					(*TChannelState)(unsafe.Pointer(statePtr)).FoutputEncodingFlags = int32(TCL_ENCODING_START)
					p3 = statePtr + 48
					*(*int32)(unsafe.Pointer(p3)) = int32(uint32(*(*int32)(unsafe.Pointer(p3))) & ^libc.Uint32FromUint32(ENCODING_PROFILE_MASK))
					p4 = statePtr + 48
					*(*int32)(unsafe.Pointer(p4)) = int32(uint32(*(*int32)(unsafe.Pointer(p4))) | libc.Uint32FromInt32(profile)&libc.Uint32FromUint32(ENCODING_PROFILE_MASK)) /* Same as input */
					*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1)<<libc.Int32FromInt32(14) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(15))
					_UpdateInterest(tls, chanPtr)
					return TCL_OK
				} else {
					if len1 > libc.Uint64FromInt32(libc.Int32FromInt32(2)) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(optionName + 1))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 44727 + 1))) && libc.Xstrncmp(tls, optionName, __ccgo_ts+44727, len1) == 0 {
						if !(*(*uint8)(unsafe.Pointer(newValue)) != 0) || !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(newValue)))&libc.Int32FromInt32(0x80) != 0) && (!(*(*uint8)(unsafe.Pointer(newValue + 1)) != 0) || !(libc.Xstrcmp(tls, newValue+uintptr(1), __ccgo_ts+44995) != 0)) {
							if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
								(*TChannelState)(unsafe.Pointer(statePtr)).FinEofChar = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(newValue)))
							}
						} else {
							if interp != 0 {
								XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+44999, int64(-libc.Int32FromInt32(1))))
							}
							XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
							return int32(TCL_ERROR)
						}
						if *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) {
							XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
						}
						/*
						 * [Bug 930851] Reset EOF and BLOCKED flags. Changing the character
						 * which signals eof can transform a current eof condition into a 'go
						 * ahead'. Ditto for blocked.
						 */
						if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(9)) != 0 {
							*(*int32)(unsafe.Pointer(statePtr + 32)) |= int32(TCL_ENCODING_START)
						}
						*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1)<<libc.Int32FromInt32(9) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(10) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(11))
						*(*int32)(unsafe.Pointer(statePtr + 32)) &= ^libc.Int32FromInt32(TCL_ENCODING_END)
						return TCL_OK
					} else {
						if len1 > libc.Uint64FromInt32(libc.Int32FromInt32(1)) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(optionName + 1))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 15022 + 1))) && libc.Xstrncmp(tls, optionName, __ccgo_ts+15022, len1) == 0 {
							if XTclEncodingProfileNameToId(tls, interp, newValue, bp+80) != TCL_OK {
								return int32(TCL_ERROR)
							}
							p5 = statePtr + 32
							*(*int32)(unsafe.Pointer(p5)) = int32(uint32(*(*int32)(unsafe.Pointer(p5))) & ^libc.Uint32FromUint32(ENCODING_PROFILE_MASK))
							p6 = statePtr + 32
							*(*int32)(unsafe.Pointer(p6)) = int32(uint32(*(*int32)(unsafe.Pointer(p6))) | libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 80)))&libc.Uint32FromUint32(ENCODING_PROFILE_MASK))
							p7 = statePtr + 48
							*(*int32)(unsafe.Pointer(p7)) = int32(uint32(*(*int32)(unsafe.Pointer(p7))) & ^libc.Uint32FromUint32(ENCODING_PROFILE_MASK))
							p8 = statePtr + 48
							*(*int32)(unsafe.Pointer(p8)) = int32(uint32(*(*int32)(unsafe.Pointer(p8))) | libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 80)))&libc.Uint32FromUint32(ENCODING_PROFILE_MASK))
							*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1)<<libc.Int32FromInt32(14) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(15))
							return TCL_OK
						} else {
							if len1 > libc.Uint64FromInt32(libc.Int32FromInt32(1)) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(optionName + 1))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 44736 + 1))) && libc.Xstrncmp(tls, optionName, __ccgo_ts+44736, len1) == 0 {
								if XTcl_SplitList(tls, interp, newValue, bp, bp+8) == int32(TCL_ERROR) {
									return int32(TCL_ERROR)
								}
								if *(*TTcl_Size)(unsafe.Pointer(bp)) == int64(1) {
									if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
										v9 = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))
									} else {
										v9 = libc.UintptrFromInt32(0)
									}
									readMode = v9
									if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
										v10 = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))
									} else {
										v10 = libc.UintptrFromInt32(0)
									}
									writeMode = v10
								} else {
									if *(*TTcl_Size)(unsafe.Pointer(bp)) == int64(2) {
										if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
											v11 = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))
										} else {
											v11 = libc.UintptrFromInt32(0)
										}
										readMode = v11
										if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
											v12 = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*8))
										} else {
											v12 = libc.UintptrFromInt32(0)
										}
										writeMode = v12
									} else {
										if interp != 0 {
											XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+45055, int64(-int32(1))))
										}
										XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
										return int32(TCL_ERROR)
									}
								}
								if readMode != 0 {
									if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(readMode))) == int32('\000') {
										translation = (*TChannelState)(unsafe.Pointer(statePtr)).FinputTranslation
									} else {
										if libc.Xstrcmp(tls, readMode, __ccgo_ts+44749) == 0 {
											translation = int32(TCL_TRANSLATE_AUTO)
										} else {
											if libc.Xstrcmp(tls, readMode, __ccgo_ts+10664) == 0 {
												translation = int32(TCL_TRANSLATE_LF)
												(*TChannelState)(unsafe.Pointer(statePtr)).FinEofChar = 0
												XTcl_FreeEncoding(tls, (*TChannelState)(unsafe.Pointer(statePtr)).Fencoding)
												(*TChannelState)(unsafe.Pointer(statePtr)).Fencoding = XTcl_GetEncoding(tls, libc.UintptrFromInt32(0), __ccgo_ts+29173)
											} else {
												if libc.Xstrcmp(tls, readMode, __ccgo_ts+44762) == 0 {
													translation = int32(TCL_TRANSLATE_LF)
												} else {
													if libc.Xstrcmp(tls, readMode, __ccgo_ts+44754) == 0 {
														translation = int32(TCL_TRANSLATE_CR)
													} else {
														if libc.Xstrcmp(tls, readMode, __ccgo_ts+44757) == 0 {
															translation = int32(TCL_TRANSLATE_CRLF)
														} else {
															if libc.Xstrcmp(tls, readMode, __ccgo_ts+45117) == 0 {
																translation = int32(TCL_TRANSLATE_LF)
															} else {
																if interp != 0 {
																	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+45126, int64(-int32(1))))
																}
																XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
																return int32(TCL_ERROR)
															}
														}
													}
												}
											}
										}
									}
									/*
									 * Reset the EOL flags since we need to look at any buffered data
									 * to see if the new translation mode allows us to complete the
									 * line.
									 */
									if translation != (*TChannelState)(unsafe.Pointer(statePtr)).FinputTranslation {
										(*TChannelState)(unsafe.Pointer(statePtr)).FinputTranslation = translation
										*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1)<<libc.Int32FromInt32(12) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(14))
										_UpdateInterest(tls, chanPtr)
									}
								}
								if writeMode != 0 {
									if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(writeMode))) == int32('\000') {
										/* Do nothing. */
									} else {
										if libc.Xstrcmp(tls, writeMode, __ccgo_ts+44749) == 0 {
											/*
											 * This is a hack to get TCP sockets to produce output in CRLF
											 * mode if they are being set into AUTO mode. A better
											 * solution for achieving this effect will be coded later.
											 */
											if libc.Xstrcmp(tls, XTcl_ChannelName(tls, (*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr), __ccgo_ts+45209) == 0 {
												(*TChannelState)(unsafe.Pointer(statePtr)).FoutputTranslation = int32(TCL_TRANSLATE_CRLF)
											} else {
												(*TChannelState)(unsafe.Pointer(statePtr)).FoutputTranslation = int32(TCL_TRANSLATE_LF)
											}
										} else {
											if libc.Xstrcmp(tls, writeMode, __ccgo_ts+10664) == 0 {
												(*TChannelState)(unsafe.Pointer(statePtr)).FoutputTranslation = int32(TCL_TRANSLATE_LF)
												XTcl_FreeEncoding(tls, (*TChannelState)(unsafe.Pointer(statePtr)).Fencoding)
												(*TChannelState)(unsafe.Pointer(statePtr)).Fencoding = XTcl_GetEncoding(tls, libc.UintptrFromInt32(0), __ccgo_ts+29173)
											} else {
												if libc.Xstrcmp(tls, writeMode, __ccgo_ts+44762) == 0 {
													(*TChannelState)(unsafe.Pointer(statePtr)).FoutputTranslation = int32(TCL_TRANSLATE_LF)
												} else {
													if libc.Xstrcmp(tls, writeMode, __ccgo_ts+44754) == 0 {
														(*TChannelState)(unsafe.Pointer(statePtr)).FoutputTranslation = int32(TCL_TRANSLATE_CR)
													} else {
														if libc.Xstrcmp(tls, writeMode, __ccgo_ts+44757) == 0 {
															(*TChannelState)(unsafe.Pointer(statePtr)).FoutputTranslation = int32(TCL_TRANSLATE_CRLF)
														} else {
															if libc.Xstrcmp(tls, writeMode, __ccgo_ts+45117) == 0 {
																(*TChannelState)(unsafe.Pointer(statePtr)).FoutputTranslation = int32(TCL_TRANSLATE_LF)
															} else {
																if interp != 0 {
																	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+45126, int64(-int32(1))))
																}
																XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
																return int32(TCL_ERROR)
															}
														}
													}
												}
											}
										}
									}
								}
								XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
								return TCL_OK
							} else {
								if (*TTcl_ChannelType)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr)).FsetOptionProc != libc.UintptrFromInt32(0) {
									return (*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ChannelType)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr)).FsetOptionProc})))(tls, (*TChannel)(unsafe.Pointer(chanPtr)).FinstanceData, interp, optionName, newValue)
								} else {
									return XTcl_BadChannelOption(tls, interp, optionName, libc.UintptrFromInt32(0))
								}
							}
						}
					}
				}
			}
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * CleanupChannelHandlers --
 *
 *	Removes channel handlers that refer to the supplied interpreter, so
 *	that if the actual channel is not closed now, these handlers will not
 *	run on subsequent events on the channel. This would be erroneous,
 *	because the interpreter no longer has a reference to this channel.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Removes channel handlers.
 *
 *----------------------------------------------------------------------
 */

func _CleanupChannelHandlers(tls *libc.TLS, interp uintptr, chanPtr uintptr) {
	var cachePtr, nextPtr, prevPtr, sPtr, statePtr, v3 uintptr
	var v2 TTcl_Size
	var v4 bool
	_, _, _, _, _, _, _, _ = cachePtr, nextPtr, prevPtr, sPtr, statePtr, v2, v3, v4
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	/*
	 * Remove fileevent records on this channel that refer to the given
	 * interpreter.
	 */
	sPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FscriptRecordPtr
	prevPtr = libc.UintptrFromInt32(0)
	for {
		if !(sPtr != libc.UintptrFromInt32(0)) {
			break
		}
		nextPtr = (*TEventScriptRecord)(unsafe.Pointer(sPtr)).FnextPtr
		if (*TEventScriptRecord)(unsafe.Pointer(sPtr)).Finterp == interp {
			if prevPtr == libc.UintptrFromInt32(0) {
				(*TChannelState)(unsafe.Pointer(statePtr)).FscriptRecordPtr = nextPtr
			} else {
				(*TEventScriptRecord)(unsafe.Pointer(prevPtr)).FnextPtr = nextPtr
			}
			XTcl_DeleteChannelHandler(tls, chanPtr, __ccgo_fp(XTclChannelEventScriptInvoker), sPtr)
			v3 = (*TEventScriptRecord)(unsafe.Pointer(sPtr)).FscriptPtr
			v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
			*(*TTcl_Size)(unsafe.Pointer(v3))--
			if !(v2 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(sPtr)).FscriptPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(sPtr)).FscriptPtr)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(sPtr)).FscriptPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(sPtr)).FscriptPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(sPtr)).FscriptPtr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(sPtr)).FscriptPtr)).Flength = int64(-libc.Int32FromInt32(1))
					if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
						cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v4 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, (*TEventScriptRecord)(unsafe.Pointer(sPtr)).FscriptPtr)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(sPtr)).FscriptPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*TEventScriptRecord)(unsafe.Pointer(sPtr)).FscriptPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, (*TEventScriptRecord)(unsafe.Pointer(sPtr)).FscriptPtr)
				}
			}
			XTclpFree(tls, sPtr)
		} else {
			prevPtr = sPtr
		}
		goto _1
	_1:
		;
		sPtr = nextPtr
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_NotifyChannel --
 *
 *	This procedure is called by a channel driver when a driver detects an
 *	event on a channel. This procedure is responsible for actually
 *	handling the event by invoking any channel handler callbacks.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Whatever the channel handler callback procedure does.
 *
 *----------------------------------------------------------------------
 */

func XTcl_NotifyChannel(tls *libc.TLS, channel TTcl_Channel, mask int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* OR'ed combination of TCL_READABLE,
	 * TCL_WRITABLE, or TCL_EXCEPTION: indicates
	 * which events were detected. */
	var chPtr, chanPtr, statePtr, tsdPtr, upChanPtr, upHandlerProc, upTypePtr uintptr
	var _ /* nh at bp+0 */ TNextChannelHandler
	_, _, _, _, _, _, _ = chPtr, chanPtr, statePtr, tsdPtr, upChanPtr, upHandlerProc, upTypePtr
	chanPtr = channel
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey2)), int64(64))
	/*
	 * In contrast to the other API functions this procedure walks towards the
	 * top of a stack and not down from it.
	 *
	 * The channel calling this procedure is the one who generated the event,
	 * and thus does not take part in handling it. IOW, its HandlerProc is not
	 * called, instead we begin with the channel above it.
	 *
	 * This behaviour also allows the transformation channels to generate
	 * their own events and pass them upward.
	 */
	for mask != 0 && (*TChannel)(unsafe.Pointer(chanPtr)).FupChanPtr != libc.UintptrFromInt32(0) {
		upChanPtr = (*TChannel)(unsafe.Pointer(chanPtr)).FupChanPtr
		upTypePtr = (*TChannel)(unsafe.Pointer(upChanPtr)).FtypePtr
		upHandlerProc = XTcl_ChannelHandlerProc(tls, upTypePtr)
		if upHandlerProc != libc.UintptrFromInt32(0) {
			mask = (*(*func(*libc.TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{upHandlerProc})))(tls, (*TChannel)(unsafe.Pointer(upChanPtr)).FinstanceData, mask)
		}
		/*
		 * ELSE: Ignore transformations which are unable to handle the event
		 * coming from below. Assume that they don't change the mask and pass
		 * it on.
		 */
		chanPtr = upChanPtr
	}
	channel = chanPtr
	/*
	 * Here we have either reached the top of the stack or the mask is empty.
	 * We break out of the procedure if it is the latter.
	 */
	if !(mask != 0) {
		return
	}
	/*
	 * We are now above the topmost channel in a stack and have events left.
	 * Now call the channel handlers as usual.
	 *
	 * Preserve the channel struct in case the script closes it.
	 */
	XTclChannelPreserve(tls, channel)
	XTcl_Preserve(tls, statePtr)
	/*
	 * Avoid processing if the channel owner has been changed.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).FmanagingThread != XTcl_GetCurrentThread(tls) {
		goto done
	}
	/*
	 * If we are flushing in the background, be sure to call FlushChannel for
	 * writable events. Note that we have to discard the writable event so we
	 * don't call any write handlers before the flush is complete.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(7)) != 0 && mask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
		if 0 == _FlushChannel(tls, libc.UintptrFromInt32(0), chanPtr, int32(1)) {
			mask &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(2))
		}
	}
	/*
	 * Add this invocation to the list of recursive invocations of
	 * Tcl_NotifyChannel.
	 */
	(*(*TNextChannelHandler)(unsafe.Pointer(bp))).FnextHandlerPtr = libc.UintptrFromInt32(0)
	(*(*TNextChannelHandler)(unsafe.Pointer(bp))).FnestedHandlerPtr = (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FnestedHandlerPtr
	(*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FnestedHandlerPtr = bp
	chPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FchPtr
	for {
		if !(chPtr != libc.UintptrFromInt32(0)) {
			break
		}
		/*
		 * If this channel handler is interested in any of the events that
		 * have occurred on the channel, invoke its procedure.
		 */
		if (*TChannelHandler)(unsafe.Pointer(chPtr)).Fmask&mask != 0 {
			(*(*TNextChannelHandler)(unsafe.Pointer(bp))).FnextHandlerPtr = (*TChannelHandler)(unsafe.Pointer(chPtr)).FnextPtr
			(*(*func(*libc.TLS, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{(*TChannelHandler)(unsafe.Pointer(chPtr)).Fproc})))(tls, (*TChannelHandler)(unsafe.Pointer(chPtr)).FclientData, (*TChannelHandler)(unsafe.Pointer(chPtr)).Fmask&mask)
			chPtr = (*(*TNextChannelHandler)(unsafe.Pointer(bp))).FnextHandlerPtr
		} else {
			chPtr = (*TChannelHandler)(unsafe.Pointer(chPtr)).FnextPtr
		}
		/*
		 * Stop if the channel owner has been changed in-between.
		 */
		if (*TChannelState1)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).Fstate)).FmanagingThread != XTcl_GetCurrentThread(tls) {
			goto done
		}
		goto _1
	_1:
	}
	/*
	 * Update the notifier interest, since it may have changed after invoking
	 * event handlers. Skip that if the channel was deleted in the call to the
	 * channel handler.
	 */
	if (*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr != libc.UintptrFromInt32(0) {
		/*
		 * TODO: This call may not be needed.  If a handler induced a
		 * change in interest, that handler should have made its own
		 * UpdateInterest() call, one would think.
		 */
		_UpdateInterest(tls, chanPtr)
	}
	goto done
done:
	;
	XTcl_Release(tls, statePtr)
	XTclChannelRelease(tls, channel)
	(*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FnestedHandlerPtr = (*(*TNextChannelHandler)(unsafe.Pointer(bp))).FnestedHandlerPtr
}

/*
 *----------------------------------------------------------------------
 *
 * UpdateInterest --
 *
 *	Arrange for the notifier to call us back at appropriate times based on
 *	the current state of the channel.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	May schedule a timer or driver handler.
 *
 *----------------------------------------------------------------------
 */

func _UpdateInterest(tls *libc.TLS, chanPtr uintptr) {
	/* Channel to update. */
	var mask int32
	var statePtr uintptr
	_, _ = mask, statePtr
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	/* State info for channel */
	mask = (*TChannelState)(unsafe.Pointer(statePtr)).FinterestMask
	if (*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr == libc.UintptrFromInt32(0) {
		/* Do not update interest on a closed channel */
		return
	}
	/*
	 * If there are flushed buffers waiting to be written, then we need to
	 * watch for the channel to become writable.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(7)) != 0 {
		mask |= libc.Int32FromInt32(1) << libc.Int32FromInt32(2)
	}
	/*
	 * If there is data in the input queue, and we aren't waiting for more
	 * data, then we need to schedule a timer so we don't block in the
	 * notifier. Also, cancel the read interest so we don't get duplicate
	 * events.
	 */
	if mask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
		if !((*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(14)) != 0) && (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead != libc.UintptrFromInt32(0) && (*TChannelBuffer)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead)).FnextAdded > (*TChannelBuffer)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead)).FnextRemoved {
			mask &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(1))
			/*
			 * Andreas Kupries, April 11, 2003
			 *
			 * Some operating systems (Solaris 2.6 and higher (but not Solaris
			 * 2.5, go figure)) generate READABLE and EXCEPTION events when
			 * select()'ing [*] on a plain file, even if EOF was not yet
			 * reached. This is a problem in the following situation:
			 *
			 * - An extension asks to get both READABLE and EXCEPTION events.
			 * - It reads data into a buffer smaller than the buffer used by
			 *	 Tcl itself.
			 * - It does not process all events in the event queue, but only
			 *	 one, at least in some situations.
			 *
			 * In that case we can get into a situation where
			 *
			 * - Tcl drops READABLE here, because it has data in its own
			 *	 buffers waiting to be read by the extension.
			 * - A READABLE event is synthesized via timer.
			 * - The OS still reports the EXCEPTION condition on the file.
			 * - And the extension gets the EXCEPTION event first, and handles
			 *	 this as EOF.
			 *
			 * End result ==> Premature end of reading from a file.
			 *
			 * The concrete example is 'Expect', and its [expect] command
			 * (and at the C-level, deep in the bowels of Expect,
			 * 'exp_get_next_event'. See marker 'SunOS' for commentary in
			 * that function too).
			 *
			 * [*] As the Tcl notifier does. See also for marker 'SunOS' in
			 * file 'exp_event.c' of Expect.
			 *
			 * Our solution here is to drop the interest in the EXCEPTION
			 * events too. This compiles on all platforms, and also passes the
			 * testsuite on all of them.
			 */
			mask &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(3))
			if !((*TChannelState)(unsafe.Pointer(statePtr)).Ftimer != 0) {
				XTclChannelPreserve(tls, chanPtr)
				(*TChannelState)(unsafe.Pointer(statePtr)).FtimerChanPtr = chanPtr
				(*TChannelState)(unsafe.Pointer(statePtr)).Ftimer = XTcl_CreateTimerHandler(tls, SYNTHETIC_EVENT_TIME, __ccgo_fp(_ChannelTimerProc), chanPtr)
			}
		}
	}
	_ChanWatch(tls, chanPtr, mask)
}

/*
 *----------------------------------------------------------------------
 *
 * ChannelTimerProc --
 *
 *	Timer handler scheduled by UpdateInterest to monitor the channel
 *	buffers until they are empty.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	May invoke channel handlers.
 *
 *----------------------------------------------------------------------
 */

func _ChannelTimerProc(tls *libc.TLS, clientData uintptr) {
	var chanPtr, statePtr uintptr
	_, _ = chanPtr, statePtr
	chanPtr = clientData
	/* State info for channel */
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	if (*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr == libc.UintptrFromInt32(0) {
		(*TChannelState)(unsafe.Pointer(statePtr)).Ftimer = libc.UintptrFromInt32(0)
		XTclChannelRelease(tls, (*TChannelState)(unsafe.Pointer(statePtr)).FtimerChanPtr)
		(*TChannelState)(unsafe.Pointer(statePtr)).FtimerChanPtr = libc.UintptrFromInt32(0)
	} else {
		if !((*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(14)) != 0) && (*TChannelState)(unsafe.Pointer(statePtr)).FinterestMask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 && (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead != libc.UintptrFromInt32(0) && (*TChannelBuffer)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead)).FnextAdded > (*TChannelBuffer)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead)).FnextRemoved {
			/*
			 * Restart the timer in case a channel handler reenters the event loop
			 * before UpdateInterest gets called by Tcl_NotifyChannel.
			 */
			(*TChannelState)(unsafe.Pointer(statePtr)).Ftimer = XTcl_CreateTimerHandler(tls, SYNTHETIC_EVENT_TIME, __ccgo_fp(_ChannelTimerProc), chanPtr)
			XTcl_Preserve(tls, statePtr)
			XTcl_NotifyChannel(tls, chanPtr, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1))
			XTcl_Release(tls, statePtr)
		} else {
			(*TChannelState)(unsafe.Pointer(statePtr)).Ftimer = libc.UintptrFromInt32(0)
			_UpdateInterest(tls, chanPtr)
			XTclChannelRelease(tls, (*TChannelState)(unsafe.Pointer(statePtr)).FtimerChanPtr)
			(*TChannelState)(unsafe.Pointer(statePtr)).FtimerChanPtr = libc.UintptrFromInt32(0)
		}
	}
}

func _DeleteTimerHandler(tls *libc.TLS, statePtr uintptr) {
	if (*TChannelState)(unsafe.Pointer(statePtr)).Ftimer != libc.UintptrFromInt32(0) {
		XTcl_DeleteTimerHandler(tls, (*TChannelState)(unsafe.Pointer(statePtr)).Ftimer)
		(*TChannelState)(unsafe.Pointer(statePtr)).Ftimer = libc.UintptrFromInt32(0)
		XTclChannelRelease(tls, (*TChannelState)(unsafe.Pointer(statePtr)).FtimerChanPtr)
		(*TChannelState)(unsafe.Pointer(statePtr)).FtimerChanPtr = libc.UintptrFromInt32(0)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_CreateChannelHandler --
 *
 *	Arrange for a given procedure to be invoked whenever the channel
 *	indicated by the chanPtr arg becomes readable or writable.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	From now on, whenever the I/O channel given by chanPtr becomes ready
 *	in the way indicated by mask, proc will be invoked. See the manual
 *	entry for details on the calling sequence to proc. If there is already
 *	an event handler for chan, proc and clientData, then the mask will be
 *	updated.
 *
 *----------------------------------------------------------------------
 */

func XTcl_CreateChannelHandler(tls *libc.TLS, chan1 TTcl_Channel, mask int32, proc uintptr, clientData uintptr) {
	/* Arbitrary data to pass to proc. */
	var chPtr, chanPtr, statePtr uintptr
	_, _, _ = chPtr, chanPtr, statePtr
	chanPtr = chan1
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	/* State info for channel */
	/*
	 * Check whether this channel handler is not already registered. If it is
	 * not, create a new record, else reuse existing record (smash current
	 * values).
	 */
	chPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FchPtr
	for {
		if !(chPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TChannelHandler)(unsafe.Pointer(chPtr)).FchanPtr == chanPtr && (*TChannelHandler)(unsafe.Pointer(chPtr)).Fproc == proc && (*TChannelHandler)(unsafe.Pointer(chPtr)).FclientData == clientData {
			break
		}
		goto _1
	_1:
		;
		chPtr = (*TChannelHandler)(unsafe.Pointer(chPtr)).FnextPtr
	}
	if chPtr == libc.UintptrFromInt32(0) {
		chPtr = XTcl_Alloc(tls, uint64(40))
		(*TChannelHandler)(unsafe.Pointer(chPtr)).Fmask = 0
		(*TChannelHandler)(unsafe.Pointer(chPtr)).Fproc = proc
		(*TChannelHandler)(unsafe.Pointer(chPtr)).FclientData = clientData
		(*TChannelHandler)(unsafe.Pointer(chPtr)).FchanPtr = chanPtr
		(*TChannelHandler)(unsafe.Pointer(chPtr)).FnextPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FchPtr
		(*TChannelState)(unsafe.Pointer(statePtr)).FchPtr = chPtr
	}
	/*
	 * The remainder of the initialization below is done regardless of whether
	 * this is a new record or a modification of an old one.
	 */
	(*TChannelHandler)(unsafe.Pointer(chPtr)).Fmask = mask
	/*
	 * Recompute the interest mask for the channel - this call may actually be
	 * disabling an existing handler.
	 */
	(*TChannelState)(unsafe.Pointer(statePtr)).FinterestMask = 0
	chPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FchPtr
	for {
		if !(chPtr != libc.UintptrFromInt32(0)) {
			break
		}
		*(*int32)(unsafe.Pointer(statePtr + 152)) |= (*TChannelHandler)(unsafe.Pointer(chPtr)).Fmask
		goto _2
	_2:
		;
		chPtr = (*TChannelHandler)(unsafe.Pointer(chPtr)).FnextPtr
	}
	_UpdateInterest(tls, (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DeleteChannelHandler --
 *
 *	Cancel a previously arranged callback arrangement for an IO channel.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	If a callback was previously registered for this chan, proc and
 *	clientData, it is removed and the callback will no longer be called
 *	when the channel becomes ready for IO.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DeleteChannelHandler(tls *libc.TLS, chan1 TTcl_Channel, proc uintptr, clientData uintptr) {
	/* The client data in the callback to
	 * delete. */
	var chPtr, chanPtr, nhPtr, prevChPtr, statePtr, tsdPtr uintptr
	_, _, _, _, _, _ = chPtr, chanPtr, nhPtr, prevChPtr, statePtr, tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey2)), int64(64))
	chanPtr = chan1
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	/*
	 * Find the entry and the previous one in the list.
	 */
	prevChPtr = libc.UintptrFromInt32(0)
	chPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FchPtr
	for {
		if !(chPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TChannelHandler)(unsafe.Pointer(chPtr)).FchanPtr == chanPtr && (*TChannelHandler)(unsafe.Pointer(chPtr)).FclientData == clientData && (*TChannelHandler)(unsafe.Pointer(chPtr)).Fproc == proc {
			break
		}
		prevChPtr = chPtr
		goto _1
	_1:
		;
		chPtr = (*TChannelHandler)(unsafe.Pointer(chPtr)).FnextPtr
	}
	/*
	 * If not found, return without doing anything.
	 */
	if chPtr == libc.UintptrFromInt32(0) {
		return
	}
	/*
	 * If Tcl_NotifyChannel is about to process this handler, tell it to
	 * process the next one instead - we are going to delete *this* one.
	 */
	nhPtr = (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FnestedHandlerPtr
	for {
		if !(nhPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TNextChannelHandler)(unsafe.Pointer(nhPtr)).FnextHandlerPtr == chPtr {
			(*TNextChannelHandler)(unsafe.Pointer(nhPtr)).FnextHandlerPtr = (*TChannelHandler)(unsafe.Pointer(chPtr)).FnextPtr
		}
		goto _2
	_2:
		;
		nhPtr = (*TNextChannelHandler)(unsafe.Pointer(nhPtr)).FnestedHandlerPtr
	}
	/*
	 * Splice it out of the list of channel handlers.
	 */
	if prevChPtr == libc.UintptrFromInt32(0) {
		(*TChannelState)(unsafe.Pointer(statePtr)).FchPtr = (*TChannelHandler)(unsafe.Pointer(chPtr)).FnextPtr
	} else {
		(*TChannelHandler)(unsafe.Pointer(prevChPtr)).FnextPtr = (*TChannelHandler)(unsafe.Pointer(chPtr)).FnextPtr
	}
	XTclpFree(tls, chPtr)
	/*
	 * Recompute the interest list for the channel, so that infinite loops
	 * will not result if Tcl_DeleteChannelHandler is called inside an event.
	 */
	(*TChannelState)(unsafe.Pointer(statePtr)).FinterestMask = 0
	chPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FchPtr
	for {
		if !(chPtr != libc.UintptrFromInt32(0)) {
			break
		}
		*(*int32)(unsafe.Pointer(statePtr + 152)) |= (*TChannelHandler)(unsafe.Pointer(chPtr)).Fmask
		goto _3
	_3:
		;
		chPtr = (*TChannelHandler)(unsafe.Pointer(chPtr)).FnextPtr
	}
	_UpdateInterest(tls, (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * DeleteScriptRecord --
 *
 *	Delete a script record for this combination of channel, interp and
 *	mask.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Deletes a script record and cancels a channel event handler.
 *
 *----------------------------------------------------------------------
 */

func _DeleteScriptRecord(tls *libc.TLS, interp uintptr, chanPtr uintptr, mask int32) {
	/* Events in mask must exactly match mask of
	 * script to delete. */
	var cachePtr, esPtr, prevEsPtr, statePtr, v3 uintptr
	var v2 TTcl_Size
	var v4 bool
	_, _, _, _, _, _, _ = cachePtr, esPtr, prevEsPtr, statePtr, v2, v3, v4
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	esPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FscriptRecordPtr
	prevEsPtr = libc.UintptrFromInt32(0)
	for {
		if !(esPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TEventScriptRecord)(unsafe.Pointer(esPtr)).Finterp == interp && (*TEventScriptRecord)(unsafe.Pointer(esPtr)).Fmask == mask {
			if esPtr == (*TChannelState)(unsafe.Pointer(statePtr)).FscriptRecordPtr {
				(*TChannelState)(unsafe.Pointer(statePtr)).FscriptRecordPtr = (*TEventScriptRecord)(unsafe.Pointer(esPtr)).FnextPtr
			} else {
				(*TEventScriptRecord)(unsafe.Pointer(prevEsPtr)).FnextPtr = (*TEventScriptRecord)(unsafe.Pointer(esPtr)).FnextPtr
			}
			XTcl_DeleteChannelHandler(tls, chanPtr, __ccgo_fp(XTclChannelEventScriptInvoker), esPtr)
			v3 = (*TEventScriptRecord)(unsafe.Pointer(esPtr)).FscriptPtr
			v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
			*(*TTcl_Size)(unsafe.Pointer(v3))--
			if !(v2 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(esPtr)).FscriptPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(esPtr)).FscriptPtr)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(esPtr)).FscriptPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(esPtr)).FscriptPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(esPtr)).FscriptPtr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(esPtr)).FscriptPtr)).Flength = int64(-libc.Int32FromInt32(1))
					if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
						cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v4 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, (*TEventScriptRecord)(unsafe.Pointer(esPtr)).FscriptPtr)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(esPtr)).FscriptPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*TEventScriptRecord)(unsafe.Pointer(esPtr)).FscriptPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, (*TEventScriptRecord)(unsafe.Pointer(esPtr)).FscriptPtr)
				}
			}
			XTclpFree(tls, esPtr)
			break
		}
		goto _1
	_1:
		;
		prevEsPtr = esPtr
		esPtr = (*TEventScriptRecord)(unsafe.Pointer(esPtr)).FnextPtr
	}
}

/*
 *----------------------------------------------------------------------
 *
 * CreateScriptRecord --
 *
 *	Creates a record to store a script to be executed when a specific
 *	event fires on a specific channel.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Causes the script to be stored for later execution.
 *
 *----------------------------------------------------------------------
 */

func _CreateScriptRecord(tls *libc.TLS, interp uintptr, chanPtr uintptr, mask int32, scriptPtr uintptr) {
	/* Pointer to script object. */
	var cachePtr, esPtr, statePtr, v3 uintptr
	var makeCH int32
	var v2 TTcl_Size
	var v4 bool
	_, _, _, _, _, _, _ = cachePtr, esPtr, makeCH, statePtr, v2, v3, v4
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	esPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FscriptRecordPtr
	for {
		if !(esPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TEventScriptRecord)(unsafe.Pointer(esPtr)).Finterp == interp && (*TEventScriptRecord)(unsafe.Pointer(esPtr)).Fmask == mask {
			v3 = (*TEventScriptRecord)(unsafe.Pointer(esPtr)).FscriptPtr
			v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
			*(*TTcl_Size)(unsafe.Pointer(v3))--
			if !(v2 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(esPtr)).FscriptPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(esPtr)).FscriptPtr)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(esPtr)).FscriptPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(esPtr)).FscriptPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(esPtr)).FscriptPtr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(esPtr)).FscriptPtr)).Flength = int64(-libc.Int32FromInt32(1))
					if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
						cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v4 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, (*TEventScriptRecord)(unsafe.Pointer(esPtr)).FscriptPtr)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer((*TEventScriptRecord)(unsafe.Pointer(esPtr)).FscriptPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*TEventScriptRecord)(unsafe.Pointer(esPtr)).FscriptPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, (*TEventScriptRecord)(unsafe.Pointer(esPtr)).FscriptPtr)
				}
			}
			(*TEventScriptRecord)(unsafe.Pointer(esPtr)).FscriptPtr = libc.UintptrFromInt32(0)
			break
		}
		goto _1
	_1:
		;
		esPtr = (*TEventScriptRecord)(unsafe.Pointer(esPtr)).FnextPtr
	}
	makeCH = libc.BoolInt32(esPtr == libc.UintptrFromInt32(0))
	if makeCH != 0 {
		esPtr = XTcl_Alloc(tls, uint64(40))
	}
	/*
	 * Initialize the structure before calling Tcl_CreateChannelHandler,
	 * because a reflected channel calling 'chan postevent' aka
	 * 'Tcl_NotifyChannel' in its 'watch'Proc will invoke
	 * 'TclChannelEventScriptInvoker' immediately, and we do not wish it to
	 * see uninitialized memory and crash. See [Bug 2918110].
	 */
	(*TEventScriptRecord)(unsafe.Pointer(esPtr)).FchanPtr = chanPtr
	(*TEventScriptRecord)(unsafe.Pointer(esPtr)).Finterp = interp
	(*TEventScriptRecord)(unsafe.Pointer(esPtr)).Fmask = mask
	(*TTcl_Obj)(unsafe.Pointer(scriptPtr)).FrefCount++
	(*TEventScriptRecord)(unsafe.Pointer(esPtr)).FscriptPtr = scriptPtr
	if makeCH != 0 {
		(*TEventScriptRecord)(unsafe.Pointer(esPtr)).FnextPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FscriptRecordPtr
		(*TChannelState)(unsafe.Pointer(statePtr)).FscriptRecordPtr = esPtr
		XTcl_CreateChannelHandler(tls, chanPtr, mask, __ccgo_fp(XTclChannelEventScriptInvoker), esPtr)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclChannelEventScriptInvoker --
 *
 *	Invokes a script scheduled by "fileevent" for when the channel becomes
 *	ready for IO. This function is invoked by the channel handler which
 *	was created by the Tcl "fileevent" command.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Whatever the script does.
 *
 *----------------------------------------------------------------------
 */

func XTclChannelEventScriptInvoker(tls *libc.TLS, clientData uintptr, dummy9140 int32) {
	var chanPtr, esPtr, interp uintptr
	var mask, result int32
	_, _, _, _, _ = chanPtr, esPtr, interp, mask, result
	esPtr = clientData
	/* The event script + interpreter to eval it
	 * in. */
	chanPtr = (*TEventScriptRecord)(unsafe.Pointer(esPtr)).FchanPtr
	/* The channel for which this handler is
	 * registered. */
	interp = (*TEventScriptRecord)(unsafe.Pointer(esPtr)).Finterp
	/* Interpreter in which to eval the script. */
	mask = (*TEventScriptRecord)(unsafe.Pointer(esPtr)).Fmask /* Result of call to eval script. */
	/*
	 * Be sure event executed in managed channel (covering bugs similar [f583715154]).
	 */
	/*
	 * We must preserve the interpreter so we can report errors on it later.
	 * Note that we do not need to preserve the channel because that is done
	 * by Tcl_NotifyChannel before calling channel handlers.
	 */
	XTcl_Preserve(tls, interp)
	XTclChannelPreserve(tls, chanPtr)
	result = XTcl_EvalObjEx(tls, interp, (*TEventScriptRecord)(unsafe.Pointer(esPtr)).FscriptPtr, int32(TCL_EVAL_GLOBAL))
	/*
	 * On error, cause a background error and remove the channel handler and
	 * the script record.
	 *
	 * NOTE: Must delete channel handler before causing the background error
	 * because the background error may want to reinstall the handler.
	 */
	if result != TCL_OK {
		if (*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr != libc.UintptrFromInt32(0) {
			_DeleteScriptRecord(tls, interp, chanPtr, mask)
		}
		XTcl_BackgroundException(tls, interp, result)
	}
	XTclChannelRelease(tls, chanPtr)
	XTcl_Release(tls, interp)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FileEventObjCmd --
 *
 *	This procedure implements the "fileevent" Tcl command. See the user
 *	documentation for details on what it does. This command is based on
 *	the Tk command "fileevent" which in turn is based on work contributed
 *	by Mark Diekhans.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	May create a channel handler for the specified channel.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FileEventObjCmd(tls *libc.TLS, dummy9207 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Argument objects. */
	var chan1 TTcl_Channel
	var chanName, chanPtr, esPtr, statePtr, v1, v2, v4 uintptr
	var mask int32
	var _ /* modeIndex at bp+0 */ int32
	_, _, _, _, _, _, _, _, _ = chan1, chanName, chanPtr, esPtr, mask, statePtr, v1, v2, v4
	if objc != int32(3) && objc != int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+45213)
		return int32(TCL_ERROR)
	}
	if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), uintptr(unsafe.Pointer(&_modeOptions)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+45236, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	mask = _maskArray[*(*int32)(unsafe.Pointer(bp))]
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	chanName = v1
	chan1 = XTcl_GetChannel(tls, interp, chanName, libc.UintptrFromInt32(0))
	if chan1 == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	chanPtr = chan1
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&mask == 0 {
		if mask == libc.Int32FromInt32(1)<<libc.Int32FromInt32(1) {
			v2 = __ccgo_ts + 5780
		} else {
			v2 = __ccgo_ts + 5864
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+45247, libc.VaList(bp+16, v2)))
		return int32(TCL_ERROR)
	}
	/*
	 * If we are supposed to return the script, do so.
	 */
	if objc == int32(3) {
		esPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FscriptRecordPtr
		for {
			if !(esPtr != libc.UintptrFromInt32(0)) {
				break
			}
			if (*TEventScriptRecord)(unsafe.Pointer(esPtr)).Finterp == interp && (*TEventScriptRecord)(unsafe.Pointer(esPtr)).Fmask == mask {
				XTcl_SetObjResult(tls, interp, (*TEventScriptRecord)(unsafe.Pointer(esPtr)).FscriptPtr)
				break
			}
			goto _3
		_3:
			;
			esPtr = (*TEventScriptRecord)(unsafe.Pointer(esPtr)).FnextPtr
		}
		return TCL_OK
	}
	/*
	 * If we are supposed to delete a stored script, do so.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes != 0 {
		v4 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes
	} else {
		v4 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0))
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) == int32('\000') {
		_DeleteScriptRecord(tls, interp, chanPtr, mask)
		return TCL_OK
	}
	/*
	 * Make the script record that will link between the event and the script
	 * to invoke. This also creates a channel event handler which will
	 * evaluate the script in the supplied interpreter.
	 */
	_CreateScriptRecord(tls, interp, chanPtr, mask, *(*uintptr)(unsafe.Pointer(objv + 3*8)))
	return TCL_OK
}

var _modeOptions = [3]uintptr{
	0: __ccgo_ts + 5780,
	1: __ccgo_ts + 5864,
	2: libc.UintptrFromInt32(0),
}

var _maskArray = [2]int32{
	0: libc.Int32FromInt32(1) << libc.Int32FromInt32(1),
	1: libc.Int32FromInt32(1) << libc.Int32FromInt32(2),
}

/*
 *----------------------------------------------------------------------
 *
 * ZeroTransferTimerProc --
 *
 *	Timer handler scheduled by TclCopyChannel so that -command is
 *	called asynchronously even when -size is 0.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Calls CopyData for -command invocation.
 *
 *----------------------------------------------------------------------
 */

func _ZeroTransferTimerProc(tls *libc.TLS, clientData uintptr) {
	/* calling CopyData with mask==0 still implies immediate invocation of the
	 *  -command callback, and completion of the fcopy.
	 */
	_CopyData(tls, clientData, 0)
}

/*
 *----------------------------------------------------------------------
 *
 * TclCopyChannel --
 *
 *	This routine copies data from one channel to another, either
 *	synchronously or asynchronously. If a command script is supplied, the
 *	operation runs in the background. The script is invoked when the copy
 *	completes. Otherwise the function waits until the copy is completed
 *	before returning.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	May schedule a background copy operation that causes both channels to
 *	be marked busy.
 *
 *----------------------------------------------------------------------
 */

func XTclCopyChannel(tls *libc.TLS, interp uintptr, inChan TTcl_Channel, outChan TTcl_Channel, toRead int64, cmdPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Pointer to script to execute or NULL. */
	var csPtr, inPtr, inStatePtr, outPtr, outStatePtr uintptr
	var moveBytes, nonBlocking, readFlags, writeFlags, v1, v2, v3, v5 int32
	var v4 bool
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = csPtr, inPtr, inStatePtr, moveBytes, nonBlocking, outPtr, outStatePtr, readFlags, writeFlags, v1, v2, v3, v4, v5
	inPtr = inChan
	outPtr = outChan
	if cmdPtr != 0 {
		v1 = libc.Int32FromInt32(1) << libc.Int32FromInt32(6)
	} else {
		v1 = 0
	}
	nonBlocking = v1
	inStatePtr = (*TChannel)(unsafe.Pointer(inPtr)).Fstate
	outStatePtr = (*TChannel)(unsafe.Pointer(outPtr)).Fstate
	if (*TChannelState)(unsafe.Pointer(inStatePtr)).FcsPtrR != 0 && libc.Bool(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0) || (*TChannelState)(unsafe.Pointer(inStatePtr)).FcsPtrW != 0 && libc.Bool(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0) {
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+45265, libc.VaList(bp+8, XTcl_GetChannelName(tls, inChan))))
		}
		return int32(TCL_ERROR)
	}
	if (*TChannelState)(unsafe.Pointer(outStatePtr)).FcsPtrR != 0 && libc.Bool(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0) || (*TChannelState)(unsafe.Pointer(outStatePtr)).FcsPtrW != 0 && libc.Bool(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0) {
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+45265, libc.VaList(bp+8, XTcl_GetChannelName(tls, outChan))))
		}
		return int32(TCL_ERROR)
	}
	readFlags = (*TChannelState)(unsafe.Pointer(inStatePtr)).Fflags
	writeFlags = (*TChannelState)(unsafe.Pointer(outStatePtr)).Fflags
	/*
	 * Set up the blocking mode appropriately. Background copies need
	 * non-blocking channels. Foreground copies need blocking channels. If
	 * there is an error, restore the old blocking mode.
	 */
	if nonBlocking != readFlags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(6)) {
		if nonBlocking != 0 {
			v2 = int32(TCL_MODE_NONBLOCKING)
		} else {
			v2 = TCL_MODE_BLOCKING
		}
		if _SetBlockMode(tls, interp, inPtr, v2) != TCL_OK {
			return int32(TCL_ERROR)
		}
	}
	if v4 = inPtr != outPtr && nonBlocking != writeFlags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(6)); v4 {
		if nonBlocking != 0 {
			v3 = int32(TCL_MODE_NONBLOCKING)
		} else {
			v3 = TCL_MODE_BLOCKING
		}
	}
	if v4 && _SetBlockMode(tls, libc.UintptrFromInt32(0), outPtr, v3) != TCL_OK && nonBlocking != readFlags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(6)) {
		if readFlags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(6)) != 0 {
			v5 = int32(TCL_MODE_NONBLOCKING)
		} else {
			v5 = TCL_MODE_BLOCKING
		}
		_SetBlockMode(tls, libc.UintptrFromInt32(0), inPtr, v5)
		return int32(TCL_ERROR)
	}
	/*
	 * Make sure the output side is unbuffered.
	 */
	*(*int32)(unsafe.Pointer(outStatePtr + 8)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(17))
	*(*int32)(unsafe.Pointer(outStatePtr + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(18)
	moveBytes = _Lossless(tls, inStatePtr, outStatePtr, toRead)
	/*
	 * Allocate a new CopyState to maintain info about the current copy in
	 * progress. This structure will be deallocated when the copy is
	 * completed.
	 */
	csPtr = XTcl_Alloc(tls, uint64(libc.UintptrFromInt32(0)+72)+libc.Uint64FromUint32(1)+libc.Uint64FromInt64(libc.BoolInt64(!(moveBytes != 0))*(*TChannelState)(unsafe.Pointer(inStatePtr)).FbufSize))
	(*TCopyState)(unsafe.Pointer(csPtr)).FbufSize = libc.BoolInt64(!(moveBytes != 0)) * (*TChannelState)(unsafe.Pointer(inStatePtr)).FbufSize
	(*TCopyState)(unsafe.Pointer(csPtr)).FreadPtr = inPtr
	(*TCopyState)(unsafe.Pointer(csPtr)).FwritePtr = outPtr
	(*TCopyState)(unsafe.Pointer(csPtr)).FrefCount = int32(2) /* two references below (inStatePtr, outStatePtr) */
	(*TCopyState)(unsafe.Pointer(csPtr)).FreadFlags = readFlags
	(*TCopyState)(unsafe.Pointer(csPtr)).FwriteFlags = writeFlags
	(*TCopyState)(unsafe.Pointer(csPtr)).FtoRead = toRead
	(*TCopyState)(unsafe.Pointer(csPtr)).Ftotal = 0
	(*TCopyState)(unsafe.Pointer(csPtr)).Finterp = interp
	if cmdPtr != 0 {
		(*TTcl_Obj)(unsafe.Pointer(cmdPtr)).FrefCount++
	}
	(*TCopyState)(unsafe.Pointer(csPtr)).FcmdPtr = cmdPtr
	XTclChannelPreserve(tls, inChan)
	XTclChannelPreserve(tls, outChan)
	(*TChannelState)(unsafe.Pointer(inStatePtr)).FcsPtrR = csPtr
	(*TChannelState)(unsafe.Pointer(outStatePtr)).FcsPtrW = csPtr
	if moveBytes != 0 {
		return _MoveBytes(tls, csPtr)
	}
	/*
	 * Special handling of -size 0 async transfers, so that the -command is
	 * still called asynchronously.
	 */
	if nonBlocking == libc.Int32FromInt32(1)<<libc.Int32FromInt32(6) && toRead == 0 {
		XTcl_CreateTimerHandler(tls, 0, __ccgo_fp(_ZeroTransferTimerProc), csPtr)
		return TCL_OK
	}
	/*
	 * Start copying data between the channels.
	 */
	return _CopyData(tls, csPtr, 0)
}

/*
 *----------------------------------------------------------------------
 *
 * CopyData --
 *
 *	This function implements the lowest level of the copying mechanism for
 *	TclCopyChannel.
 *
 * Results:
 *	Returns TCL_OK on success, else TCL_ERROR.
 *
 * Side effects:
 *	Moves data between channels, may create channel handlers.
 *
 *----------------------------------------------------------------------
 */

func _MBCallback(tls *libc.TLS, csPtr uintptr, errObj uintptr) {
	var cachePtr, cmdPtr, interp, v2 uintptr
	var code int32
	var total TTcl_WideInt
	var v1 TTcl_Size
	var v3 bool
	_, _, _, _, _, _, _, _ = cachePtr, cmdPtr, code, interp, total, v1, v2, v3
	cmdPtr = XTcl_DuplicateObj(tls, (*TCopyState)(unsafe.Pointer(csPtr)).FcmdPtr)
	total = (*TCopyState)(unsafe.Pointer(csPtr)).Ftotal
	interp = (*TCopyState)(unsafe.Pointer(csPtr)).Finterp
	(*TTcl_Obj)(unsafe.Pointer(cmdPtr)).FrefCount++
	_StopCopy(tls, csPtr)
	/* TODO: What if cmdPtr is not a list?! */
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), cmdPtr, XTcl_NewWideIntObj(tls, total))
	if errObj != 0 {
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), cmdPtr, errObj)
	}
	XTcl_Preserve(tls, interp)
	code = XTcl_EvalObjEx(tls, interp, cmdPtr, int32(TCL_EVAL_GLOBAL))
	if code != TCL_OK {
		XTcl_BackgroundException(tls, interp, code)
	}
	XTcl_Release(tls, interp)
	v2 = cmdPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if !(v1 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(cmdPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(cmdPtr)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(cmdPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(cmdPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(cmdPtr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(cmdPtr)).Flength = int64(-libc.Int32FromInt32(1))
			if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, cmdPtr)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(cmdPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = cmdPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, cmdPtr)
		}
	}
}

func _MBError(tls *libc.TLS, csPtr uintptr, mask int32, errorCode int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var errObj, v1 uintptr
	var inChan, outChan, v2 TTcl_Channel
	_, _, _, _, _ = errObj, inChan, outChan, v1, v2
	inChan = (*TCopyState)(unsafe.Pointer(csPtr)).FreadPtr
	outChan = (*TCopyState)(unsafe.Pointer(csPtr)).FwritePtr
	XTcl_SetErrno(tls, errorCode)
	if mask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
		v1 = __ccgo_ts + 5552
	} else {
		v1 = __ccgo_ts + 45286
	}
	if mask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
		v2 = inChan
	} else {
		v2 = outChan
	}
	errObj = XTcl_ObjPrintf(tls, __ccgo_ts+45291, libc.VaList(bp+8, v1, XTcl_GetChannelName(tls, v2), XTcl_PosixError(tls, (*TCopyState)(unsafe.Pointer(csPtr)).Finterp)))
	if (*TCopyState)(unsafe.Pointer(csPtr)).FcmdPtr != 0 {
		_MBCallback(tls, csPtr, errObj)
	} else {
		XTcl_SetObjResult(tls, (*TCopyState)(unsafe.Pointer(csPtr)).Finterp, errObj)
		_StopCopy(tls, csPtr)
	}
}

func _MBEvent(tls *libc.TLS, clientData uintptr, mask int32) {
	var csPtr, inStatePtr uintptr
	var inChan, outChan TTcl_Channel
	_, _, _, _ = csPtr, inChan, inStatePtr, outChan
	csPtr = clientData
	inChan = (*TCopyState)(unsafe.Pointer(csPtr)).FreadPtr
	outChan = (*TCopyState)(unsafe.Pointer(csPtr)).FwritePtr
	inStatePtr = (*TChannel1)(unsafe.Pointer((*TCopyState)(unsafe.Pointer(csPtr)).FreadPtr)).Fstate
	if mask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
		XTcl_DeleteChannelHandler(tls, inChan, __ccgo_fp(_MBEvent), csPtr)
		XTcl_DeleteChannelHandler(tls, outChan, __ccgo_fp(_MBEvent), csPtr)
		switch _MBWrite(tls, csPtr) {
		case TCL_OK:
			_MBCallback(tls, csPtr, libc.UintptrFromInt32(0))
		case int32(TCL_CONTINUE):
			XTcl_CreateChannelHandler(tls, inChan, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1), __ccgo_fp(_MBEvent), csPtr)
			break
		}
	} else {
		if mask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
			if TCL_OK == _MBRead(tls, csPtr) {
				/* When at least one full buffer is present, stop reading. */
				if (*TChannelState)(unsafe.Pointer(inStatePtr)).FinQueueHead != 0 && (*TChannelBuffer)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(inStatePtr)).FinQueueHead)).FnextAdded >= (*TChannelBuffer)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(inStatePtr)).FinQueueHead)).FbufLength || !(XTcl_InputBlocked(tls, inChan) != 0) {
					XTcl_DeleteChannelHandler(tls, inChan, __ccgo_fp(_MBEvent), csPtr)
				}
				/* Successful read -- set up to write the bytes we read */
				XTcl_CreateChannelHandler(tls, outChan, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2), __ccgo_fp(_MBEvent), csPtr)
			}
		}
	}
}

func _MBRead(tls *libc.TLS, csPtr uintptr) (r int32) {
	var bufPtr, inStatePtr uintptr
	var code int32
	_, _, _ = bufPtr, code, inStatePtr
	inStatePtr = (*TChannel1)(unsafe.Pointer((*TCopyState)(unsafe.Pointer(csPtr)).FreadPtr)).Fstate
	bufPtr = (*TChannelState)(unsafe.Pointer(inStatePtr)).FinQueueHead
	if bufPtr != 0 && (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded-(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved > 0 {
		return TCL_OK
	}
	code = _GetInput(tls, (*TChannelState)(unsafe.Pointer(inStatePtr)).FtopChanPtr)
	if code == 0 || (*TChannelState)(unsafe.Pointer(inStatePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(11)) != 0 {
		return TCL_OK
	} else {
		_MBError(tls, csPtr, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1), code)
		return int32(TCL_ERROR)
	}
	return r
}

func _MBWrite(tls *libc.TLS, csPtr uintptr) (r int32) {
	var bufPtr, inStatePtr, outStatePtr, tail uintptr
	var code, extra int32
	var inBytes TTcl_WideInt
	_, _, _, _, _, _, _ = bufPtr, code, extra, inBytes, inStatePtr, outStatePtr, tail
	inStatePtr = (*TChannel1)(unsafe.Pointer((*TCopyState)(unsafe.Pointer(csPtr)).FreadPtr)).Fstate
	outStatePtr = (*TChannel1)(unsafe.Pointer((*TCopyState)(unsafe.Pointer(csPtr)).FwritePtr)).Fstate
	bufPtr = (*TChannelState)(unsafe.Pointer(inStatePtr)).FinQueueHead
	tail = libc.UintptrFromInt32(0)
	inBytes = 0
	/* Count up number of bytes waiting in the input queue */
	for bufPtr != 0 {
		inBytes += (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded - (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved
		tail = bufPtr
		if (*TCopyState)(unsafe.Pointer(csPtr)).FtoRead != int64(-int32(1)) && (*TCopyState)(unsafe.Pointer(csPtr)).FtoRead < inBytes {
			/* Queue has enough bytes to complete the copy */
			break
		}
		bufPtr = (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr
	}
	if bufPtr != 0 {
		/* Split the overflowing buffer in two */
		extra = int32(inBytes - (*TCopyState)(unsafe.Pointer(csPtr)).FtoRead)
		/* Note that going with int for extra assumes that inBytes is not too
		 * much over toRead to require a wide itself. If that gets violated
		 * then the calculations involving extra must be made wide too.
		 *
		 * Noted with Win32/MSVC debug build treating the warning (possible of
		 * data in long long to int conversion) as error.
		 */
		bufPtr = _AllocChannelBuffer(tls, int64(extra))
		*(*TTcl_Size)(unsafe.Pointer(tail + 8)) -= int64(extra)
		libc.Xmemcpy(tls, bufPtr+40+uintptr((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded), tail+40+uintptr((*TChannelBuffer)(unsafe.Pointer(tail)).FnextAdded), libc.Uint64FromInt32(extra))
		*(*TTcl_Size)(unsafe.Pointer(bufPtr + 8)) += int64(extra)
		(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr = (*TChannelBuffer)(unsafe.Pointer(tail)).FnextPtr
		(*TChannelBuffer)(unsafe.Pointer(tail)).FnextPtr = libc.UintptrFromInt32(0)
		inBytes = (*TCopyState)(unsafe.Pointer(csPtr)).FtoRead
	}
	/* Update the byte counts */
	if (*TCopyState)(unsafe.Pointer(csPtr)).FtoRead != int64(-int32(1)) {
		*(*TTcl_WideInt)(unsafe.Pointer(csPtr + 32)) -= inBytes
	}
	*(*TTcl_WideInt)(unsafe.Pointer(csPtr + 40)) += inBytes
	/* Move buffers from input to output channels */
	if (*TChannelState)(unsafe.Pointer(outStatePtr)).FoutQueueTail != 0 {
		(*TChannelBuffer)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(outStatePtr)).FoutQueueTail)).FnextPtr = (*TChannelState)(unsafe.Pointer(inStatePtr)).FinQueueHead
	} else {
		(*TChannelState)(unsafe.Pointer(outStatePtr)).FoutQueueHead = (*TChannelState)(unsafe.Pointer(inStatePtr)).FinQueueHead
	}
	(*TChannelState)(unsafe.Pointer(outStatePtr)).FoutQueueTail = tail
	(*TChannelState)(unsafe.Pointer(inStatePtr)).FinQueueHead = bufPtr
	if (*TChannelState)(unsafe.Pointer(inStatePtr)).FinQueueTail == tail {
		(*TChannelState)(unsafe.Pointer(inStatePtr)).FinQueueTail = bufPtr
	}
	if bufPtr == libc.UintptrFromInt32(0) {
		(*TChannelState)(unsafe.Pointer(inStatePtr)).FinQueueTail = libc.UintptrFromInt32(0)
	}
	code = _FlushChannel(tls, (*TCopyState)(unsafe.Pointer(csPtr)).Finterp, (*TChannelState)(unsafe.Pointer(outStatePtr)).FtopChanPtr, 0)
	if code != 0 {
		_MBError(tls, csPtr, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2), code)
		return int32(TCL_ERROR)
	}
	if (*TCopyState)(unsafe.Pointer(csPtr)).FtoRead == 0 || (*TChannelState)(unsafe.Pointer(inStatePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(9)) != 0 {
		return TCL_OK
	}
	return int32(TCL_CONTINUE)
}

func _MoveBytes(tls *libc.TLS, csPtr uintptr) (r int32) {
	/* State of copy operation. */
	var bufPtr, outStatePtr uintptr
	var code, errorCode int32
	var inChan TTcl_Channel
	_, _, _, _, _ = bufPtr, code, errorCode, inChan, outStatePtr
	outStatePtr = (*TChannel1)(unsafe.Pointer((*TCopyState)(unsafe.Pointer(csPtr)).FwritePtr)).Fstate
	bufPtr = (*TChannelState)(unsafe.Pointer(outStatePtr)).FcurOutPtr
	if bufPtr != 0 && (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded-(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved != 0 {
		/* If we start with unflushed bytes in the destination
		 * channel, flush them out of the way first. */
		errorCode = _FlushChannel(tls, (*TCopyState)(unsafe.Pointer(csPtr)).Finterp, (*TChannelState)(unsafe.Pointer(outStatePtr)).FtopChanPtr, 0)
		if errorCode != 0 {
			_MBError(tls, csPtr, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2), errorCode)
			return int32(TCL_ERROR)
		}
	}
	if (*TCopyState)(unsafe.Pointer(csPtr)).FcmdPtr != 0 {
		inChan = (*TCopyState)(unsafe.Pointer(csPtr)).FreadPtr
		XTcl_CreateChannelHandler(tls, inChan, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1), __ccgo_fp(_MBEvent), csPtr)
		return TCL_OK
	}
	for int32(1) != 0 {
		if int32(TCL_ERROR) == _MBRead(tls, csPtr) {
			return int32(TCL_ERROR)
		}
		code = _MBWrite(tls, csPtr)
		if code == TCL_OK {
			XTcl_SetObjResult(tls, (*TCopyState)(unsafe.Pointer(csPtr)).Finterp, XTcl_NewWideIntObj(tls, (*TCopyState)(unsafe.Pointer(csPtr)).Ftotal))
			_StopCopy(tls, csPtr)
			return TCL_OK
		}
		if code == int32(TCL_ERROR) {
			return int32(TCL_ERROR)
		}
		/* code == TCL_CONTINUE --> continue the loop */
	}
	return TCL_OK /* Silence compiler warnings */
}

func _CopyData(tls *libc.TLS, csPtr uintptr, mask int32) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Current channel event flags. */
	var _objPtr, _objPtr1, bufObj, buffer, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cmdPtr, errObj, inStatePtr, interp, outStatePtr, v11, v13, v17, v19, v22, v25, v28, v9 uintptr
	var code, moveBytes, result, underflow int32
	var inChan, outChan TTcl_Channel
	var size, total TTcl_WideInt
	var v1, v12, v15, v20, v23, v26, v29, v7 bool
	var v10, v16, v18, v21, v24, v27, v8 TTcl_Size
	var _ /* msg at bp+0 */ uintptr
	var _ /* sizePart at bp+16 */ TTcl_Size
	var _ /* sizeb at bp+8 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, bufObj, buffer, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cmdPtr, code, errObj, inChan, inStatePtr, interp, moveBytes, outChan, outStatePtr, result, size, total, underflow, v1, v10, v11, v12, v13, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v7, v8, v9
	errObj = libc.UintptrFromInt32(0)
	bufObj = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	result = TCL_OK                                  /* Input underflow */
	(*TCopyState)(unsafe.Pointer(csPtr)).FrefCount++ /* avoid freeing during handling */
	inChan = (*TCopyState)(unsafe.Pointer(csPtr)).FreadPtr
	outChan = (*TCopyState)(unsafe.Pointer(csPtr)).FwritePtr
	inStatePtr = (*TChannel1)(unsafe.Pointer((*TCopyState)(unsafe.Pointer(csPtr)).FreadPtr)).Fstate
	outStatePtr = (*TChannel1)(unsafe.Pointer((*TCopyState)(unsafe.Pointer(csPtr)).FwritePtr)).Fstate
	interp = (*TCopyState)(unsafe.Pointer(csPtr)).Finterp
	cmdPtr = (*TCopyState)(unsafe.Pointer(csPtr)).FcmdPtr
	/*
	 * Copy the data the slow way, using the translation mechanism.
	 *
	 * Note: We have make sure that we use the topmost channel in a stack for
	 * the copying. The caller uses Tcl_GetChannel to access it, and thus gets
	 * the bottom of the stack.
	 */
	moveBytes = _Lossless(tls, inStatePtr, outStatePtr, (*TCopyState)(unsafe.Pointer(csPtr)).FtoRead)
	if !(moveBytes != 0) {
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			bufObj = XTclThreadAllocObj(tls)
		} else {
			bufObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(bufObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(bufObj)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(bufObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(bufObj)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(bufObj)).FtypePtr = libc.UintptrFromInt32(0)
		(*TTcl_Obj)(unsafe.Pointer(bufObj)).FrefCount++
	}
_3:
	;
	if !((*TCopyState)(unsafe.Pointer(csPtr)).FtoRead != 0) {
		goto _2
	}
	/*
	 * Check for unreported background errors.
	 */
	XTcl_GetChannelError(tls, inChan, bp)
	if (*TChannelState)(unsafe.Pointer(inStatePtr)).FunreportedError != 0 || *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
		XTcl_SetErrno(tls, (*TChannelState)(unsafe.Pointer(inStatePtr)).FunreportedError)
		(*TChannelState)(unsafe.Pointer(inStatePtr)).FunreportedError = 0
		goto readError
	} else {
		if (*TChannelState)(unsafe.Pointer(inStatePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(15)) != 0 {
			XTcl_SetErrno(tls, int32(EILSEQ))
			*(*int32)(unsafe.Pointer(inStatePtr + 8)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(15))
			goto readError
		}
	}
	XTcl_GetChannelError(tls, outChan, bp)
	if (*TChannelState)(unsafe.Pointer(outStatePtr)).FunreportedError != 0 || *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
		XTcl_SetErrno(tls, (*TChannelState)(unsafe.Pointer(outStatePtr)).FunreportedError)
		(*TChannelState)(unsafe.Pointer(outStatePtr)).FunreportedError = 0
		goto writeError
	} else {
		if (*TChannelState)(unsafe.Pointer(outStatePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(15)) != 0 {
			XTcl_SetErrno(tls, int32(EILSEQ))
			*(*int32)(unsafe.Pointer(outStatePtr + 8)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(15))
			goto writeError
		}
	}
	if cmdPtr != 0 && mask == 0 {
		/*
		 * In async mode, we skip reading synchronously and fake an
		 * underflow instead to prime the readable fileevent.
		 */
		size = 0
		underflow = int32(1)
	} else {
		/*
		 * Read up to bufSize characters.
		 */
		if (*TCopyState)(unsafe.Pointer(csPtr)).FtoRead == int64(-int32(1)) || (*TCopyState)(unsafe.Pointer(csPtr)).FtoRead > (*TCopyState)(unsafe.Pointer(csPtr)).FbufSize {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TCopyState)(unsafe.Pointer(csPtr)).FbufSize
		} else {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TCopyState)(unsafe.Pointer(csPtr)).FtoRead
		}
		if moveBytes != 0 {
			size = _DoRead(tls, (*TChannelState)(unsafe.Pointer(inStatePtr)).FtopChanPtr, csPtr+72, *(*TTcl_Size)(unsafe.Pointer(bp + 8)), libc.BoolInt32(!((*TChannelState)(unsafe.Pointer(inStatePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(6)) != 0)))
		} else {
			size = _DoReadChars(tls, (*TChannelState)(unsafe.Pointer(inStatePtr)).FtopChanPtr, bufObj, *(*TTcl_Size)(unsafe.Pointer(bp + 8)), libc.BoolInt32(!((*TChannelState)(unsafe.Pointer(inStatePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(6)) != 0)), 0)
			/*
			 * In case of a recoverable encoding error, any data before
			 * the error should be written. This data is in the bufObj.
			 * Program flow for this case:
			 * - Check, if there are any remaining bytes to write
			 * - If yes, simulate a successful read to write them out
			 * - Come back here by the outer loop and read again
			 * - Do not enter in the if below, as there are no pending
			 *  writes
			 * - Fail below with a read error
			 */
			if size < 0 && XTcl_GetErrno(tls) == int32(EILSEQ) {
				if (*TTcl_Obj)(unsafe.Pointer(bufObj)).Fbytes != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = (*TTcl_Obj)(unsafe.Pointer(bufObj)).Flength
					_ = (*TTcl_Obj)(unsafe.Pointer(bufObj)).Fbytes
				} else {
					XTcl_GetStringFromObj(tls, bufObj, bp+16)
				}
				if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) > 0 {
					size = *(*TTcl_Size)(unsafe.Pointer(bp + 16))
				}
			}
		}
		underflow = libc.BoolInt32(size >= 0 && size < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) /* Input underflow */
	}
	if !(size < 0) {
		goto _5
	}
	goto readError
readError:
	;
	if interp != 0 {
		if v7 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v7 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v7 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			errObj = XTclThreadAllocObj(tls)
		} else {
			errObj = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(errObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(errObj)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(errObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(errObj)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(errObj)).FtypePtr = libc.UintptrFromInt32(0)
		XTcl_AppendStringsToObj(tls, errObj, libc.VaList(bp+32, __ccgo_ts+45312, XTcl_GetChannelName(tls, inChan), __ccgo_ts+45328, libc.UintptrFromInt32(0)))
		if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
			XTcl_AppendObjToObj(tls, errObj, *(*uintptr)(unsafe.Pointer(bp)))
		} else {
			XTcl_AppendStringsToObj(tls, errObj, libc.VaList(bp+32, XTcl_PosixError(tls, interp), libc.UintptrFromInt32(0)))
		}
	}
	if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
		_objPtr = *(*uintptr)(unsafe.Pointer(bp))
		v9 = _objPtr
		v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
		*(*TTcl_Size)(unsafe.Pointer(v9))--
		if v8 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	goto _2
	goto _6
_5:
	;
	if underflow != 0 {
		/*
		 * We had an underflow on the read side. If we are at EOF, and not
		 * in the synchronous part of an asynchronous fcopy, then the
		 * copying is done, otherwise set up a channel handler to detect
		 * when the channel becomes readable again.
		 */
		if size == 0 && XTcl_Eof(tls, inChan) != 0 && !(cmdPtr != 0 && mask == 0) {
			goto _2
		}
		if cmdPtr != 0 && (!(XTcl_Eof(tls, inChan) != 0) || mask == 0) && !(mask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0) {
			if mask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
				XTcl_DeleteChannelHandler(tls, outChan, __ccgo_fp(_CopyEventProc), csPtr)
			}
			XTcl_CreateChannelHandler(tls, inChan, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1), __ccgo_fp(_CopyEventProc), csPtr)
		}
		if size == 0 {
			if !((*TChannelState)(unsafe.Pointer(inStatePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(6)) != 0) {
				/*
				 * We allowed a short read.  Keep trying.
				 */
				goto _3
			}
			if bufObj != libc.UintptrFromInt32(0) {
				v11 = bufObj
				v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
				*(*TTcl_Size)(unsafe.Pointer(v11))--
				if !(v10 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(bufObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(bufObj)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(bufObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(bufObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(bufObj)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(bufObj)).Flength = int64(-libc.Int32FromInt32(1))
						if v12 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v12 {
							cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v12 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, bufObj)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(bufObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = bufObj
							(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, bufObj)
					}
				}
				bufObj = libc.UintptrFromInt32(0)
			}
			goto done
		}
	}
_6:
	;
	/*
	 * Now write the buffer out.
	 */
	if moveBytes != 0 {
		buffer = csPtr + 72
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = _Write(tls, (*TChannelState)(unsafe.Pointer(outStatePtr)).FtopChanPtr, buffer, size, XtclIdentityEncoding)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(bufObj)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(bufObj)).Flength
			v13 = (*TTcl_Obj)(unsafe.Pointer(bufObj)).Fbytes
		} else {
			v13 = XTcl_GetStringFromObj(tls, bufObj, bp+8)
		}
		buffer = v13
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = _Write(tls, (*TChannelState)(unsafe.Pointer(outStatePtr)).FtopChanPtr, buffer, *(*TTcl_Size)(unsafe.Pointer(bp + 8)), (*TChannelState1)(unsafe.Pointer((*TChannel)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(outStatePtr)).FtopChanPtr)).Fstate)).Fencoding)
	}
	/*
	 * [Bug 2895565]. At this point 'size' still contains the number of
	 * characters which have been read. We keep this to later to
	 * update the totals and toRead information, see marker (UP) below. We
	 * must not overwrite it with 'sizeb', which is the number of written
	 * characters, and both EOL translation and encoding
	 * conversion may have changed this number unpredictably in relation
	 * to 'size' (It can be smaller or larger, in the latter case able to
	 * drive toRead below -1, causing infinite looping). Completely
	 * unsuitable for updating totals and toRead.
	 */
	if !(*(*TTcl_Size)(unsafe.Pointer(bp + 8)) < 0) {
		goto _14
	}
	goto writeError
writeError:
	;
	if interp != 0 {
		if v15 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v15 {
			cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v15 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
			errObj = XTclThreadAllocObj(tls)
		} else {
			errObj = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(errObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(errObj)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(errObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(errObj)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(errObj)).FtypePtr = libc.UintptrFromInt32(0)
		XTcl_AppendStringsToObj(tls, errObj, libc.VaList(bp+32, __ccgo_ts+45332, XTcl_GetChannelName(tls, outChan), __ccgo_ts+45328, libc.UintptrFromInt32(0)))
		if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
			XTcl_AppendObjToObj(tls, errObj, *(*uintptr)(unsafe.Pointer(bp)))
		} else {
			XTcl_AppendStringsToObj(tls, errObj, libc.VaList(bp+32, XTcl_PosixError(tls, interp), libc.UintptrFromInt32(0)))
		}
	}
	if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
		_objPtr1 = *(*uintptr)(unsafe.Pointer(bp))
		v17 = _objPtr1
		v16 = *(*TTcl_Size)(unsafe.Pointer(v17))
		*(*TTcl_Size)(unsafe.Pointer(v17))--
		if v16 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
	goto _2
_14:
	;
	/*
	 * Update the current character count. Do it now so the count is valid
	 * before a return or break takes us out of the loop. The invariant at
	 * the top of the loop should be that csPtr->toRead holds the number
	 * of characters left to copy.
	 */
	if (*TCopyState)(unsafe.Pointer(csPtr)).FtoRead != int64(-int32(1)) {
		*(*TTcl_WideInt)(unsafe.Pointer(csPtr + 32)) -= size
	}
	*(*TTcl_WideInt)(unsafe.Pointer(csPtr + 40)) += size
	/*
	 * Break loop if EOF && (size>0)
	 */
	if XTcl_Eof(tls, inChan) != 0 {
		goto _2
	}
	/*
	 * Check to see if the write is happening in the background. If so,
	 * stop copying and wait for the channel to become writable again.
	 * After input underflow we already installed a readable handler
	 * therefore we don't need a writable handler.
	 */
	if !(underflow != 0) && (*TChannelState)(unsafe.Pointer(outStatePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(7)) != 0 {
		if !(mask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0) {
			if mask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
				XTcl_DeleteChannelHandler(tls, inChan, __ccgo_fp(_CopyEventProc), csPtr)
			}
			XTcl_CreateChannelHandler(tls, outChan, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2), __ccgo_fp(_CopyEventProc), csPtr)
		}
		if bufObj != libc.UintptrFromInt32(0) {
			v19 = bufObj
			v18 = *(*TTcl_Size)(unsafe.Pointer(v19))
			*(*TTcl_Size)(unsafe.Pointer(v19))--
			if !(v18 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(bufObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(bufObj)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(bufObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(bufObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(bufObj)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(bufObj)).Flength = int64(-libc.Int32FromInt32(1))
					if v20 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v20 {
						cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v20 || ((*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, bufObj)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(bufObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = bufObj
						(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, bufObj)
				}
			}
			bufObj = libc.UintptrFromInt32(0)
		}
		goto done
	}
	/*
	 * For background copies, we only do one buffer per invocation so we
	 * don't starve the rest of the system.
	 */
	if cmdPtr != 0 && (*TCopyState)(unsafe.Pointer(csPtr)).FtoRead != 0 {
		/*
		 * The first time we enter this code, there won't be a channel
		 * handler established yet, so do it here.
		 */
		if mask == 0 {
			XTcl_CreateChannelHandler(tls, outChan, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2), __ccgo_fp(_CopyEventProc), csPtr)
		}
		if bufObj != libc.UintptrFromInt32(0) {
			v22 = bufObj
			v21 = *(*TTcl_Size)(unsafe.Pointer(v22))
			*(*TTcl_Size)(unsafe.Pointer(v22))--
			if !(v21 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(bufObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(bufObj)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(bufObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(bufObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(bufObj)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(bufObj)).Flength = int64(-libc.Int32FromInt32(1))
					if v23 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v23 {
						cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v23 || ((*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, bufObj)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(bufObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = bufObj
						(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, bufObj)
				}
			}
			bufObj = libc.UintptrFromInt32(0)
		}
		goto done
	}
	goto _3
_2:
	; /* while */
	if bufObj != libc.UintptrFromInt32(0) {
		v25 = bufObj
		v24 = *(*TTcl_Size)(unsafe.Pointer(v25))
		*(*TTcl_Size)(unsafe.Pointer(v25))--
		if !(v24 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(bufObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(bufObj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(bufObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(bufObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(bufObj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(bufObj)).Flength = int64(-libc.Int32FromInt32(1))
				if v26 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v26 {
					cachePtr6 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v26 || ((*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, bufObj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(bufObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr = bufObj
					(*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, bufObj)
			}
		}
		bufObj = libc.UintptrFromInt32(0)
	}
	/*
	 * Make the callback or return the number of characters transferred. The
	 * local total is used because StopCopy frees csPtr.
	 */
	total = (*TCopyState)(unsafe.Pointer(csPtr)).Ftotal
	if cmdPtr != 0 && interp != 0 {
		/*
		 * Get a private copy of the command so we can mutate it by adding
		 * arguments. Note that StopCopy frees our saved reference to the
		 * original command obj.
		 */
		cmdPtr = XTcl_DuplicateObj(tls, cmdPtr)
		(*TTcl_Obj)(unsafe.Pointer(cmdPtr)).FrefCount++
		_StopCopy(tls, csPtr)
		XTcl_Preserve(tls, interp)
		XTcl_ListObjAppendElement(tls, interp, cmdPtr, XTcl_NewWideIntObj(tls, total))
		if errObj != 0 {
			XTcl_ListObjAppendElement(tls, interp, cmdPtr, errObj)
		}
		code = XTcl_EvalObjEx(tls, interp, cmdPtr, int32(TCL_EVAL_GLOBAL))
		if code != TCL_OK {
			XTcl_BackgroundException(tls, interp, code)
			result = int32(TCL_ERROR)
		}
		v28 = cmdPtr
		v27 = *(*TTcl_Size)(unsafe.Pointer(v28))
		*(*TTcl_Size)(unsafe.Pointer(v28))--
		if !(v27 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(cmdPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(cmdPtr)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(cmdPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(cmdPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(cmdPtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(cmdPtr)).Flength = int64(-libc.Int32FromInt32(1))
				if v29 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v29 {
					cachePtr7 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v29 || ((*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, cmdPtr)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(cmdPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr = cmdPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, cmdPtr)
			}
		}
		XTcl_Release(tls, interp)
	} else {
		_StopCopy(tls, csPtr)
		if interp != 0 {
			if errObj != 0 {
				XTcl_SetObjResult(tls, interp, errObj)
				result = int32(TCL_ERROR)
			} else {
				XTcl_ResetResult(tls, interp)
				XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, total))
			}
		}
	}
	goto done
done:
	;
	_CopyDecrRefCount(tls, csPtr)
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * DoRead --
 *
 *	Stores up to "bytesToRead" bytes in memory pointed to by "dst".
 *	These bytes come from reading the channel "chanPtr" and
 *	performing the configured translations.  No encoding conversions
 *	are applied to the bytes being read.
 *
 * Results:
 *	The number of bytes actually stored (<= bytesToRead),
 *	or TCL_INDEX_NONE if there is an error in reading the channel.  Use
 *	Tcl_GetErrno() to retrieve the error code for the error
 *	that occurred.
 *
 *	The number of bytes stored can be less than the number
 *	requested when
 *	  - EOF is reached on the channel; or
 *	  - the channel is non-blocking, and we've read all we can
 *	    without blocking.
 *	  - a channel reading error occurs (and we return TCL_INDEX_NONE)
 *
 * Side effects:
 *	May cause input to be buffered.
 *
 *----------------------------------------------------------------------
 */

func _DoRead(tls *libc.TLS, chanPtr uintptr, dst uintptr, bytesToRead TTcl_Size, allowShortReads int32) (r TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Allow half-blocking (pipes,sockets) */
	var bufPtr, nextPtr, p, statePtr, v6 uintptr
	var code int32
	var _ /* bytesRead at bp+0 */ int32
	var _ /* bytesWritten at bp+4 */ int32
	_, _, _, _, _, _ = bufPtr, code, nextPtr, p, statePtr, v6
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	p = dst
	/*
	 * Early out when we know a read will get the eofchar.
	 *
	 * NOTE: This seems to be a bug.  The special handling for
	 * a zero-char read request ought to come first.  As coded
	 * the EOF due to eofchar has distinguishing behavior from
	 * the EOF due to reported EOF on the underlying device, and
	 * that seems undesirable.  However recent history indicates
	 * that new inconsistent behavior in a patchlevel has problems
	 * too.  Keep on keeping on for now.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(15)) != 0 {
		_UpdateInterest(tls, chanPtr)
		XTcl_SetErrno(tls, int32(EILSEQ))
		return int64(-int32(1))
	}
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(10)) != 0 {
		*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(9)
		/* TODO: Don't need this call */
		_UpdateInterest(tls, chanPtr)
		return 0
	}
	/*
	 * Special handling for zero-char read request.
	 */
	if bytesToRead == 0 {
		if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(9)) != 0 {
			*(*int32)(unsafe.Pointer(statePtr + 32)) |= int32(TCL_ENCODING_START)
		}
		*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1)<<libc.Int32FromInt32(11) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(9))
		*(*int32)(unsafe.Pointer(statePtr + 32)) &= ^libc.Int32FromInt32(TCL_ENCODING_END)
		/* TODO: Don't need this call */
		_UpdateInterest(tls, chanPtr)
		return 0
	}
	XTclChannelPreserve(tls, chanPtr)
_2:
	;
	if !(bytesToRead != 0) {
		goto _1
	}
	bufPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead
	/*
	 * Don't read more data if we have what we need.
	 */
_4:
	;
	if !(!(bufPtr != 0) || !(bufPtr != 0 && (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded >= (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FbufLength) && (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded-(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved < bytesToRead) {
		goto _3
	}
	goto moreData
moreData:
	;
	code = _GetInput(tls, chanPtr)
	bufPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(9)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(11)) != 0 {
		/*
		 * Further reads cannot do any more.
		 */
		goto _3
	}
	if code != 0 || !(bufPtr != 0) {
		/* Read error (or channel dead/closed) */
		goto readErr
	}
	goto _4
_3:
	;
	if !!(bufPtr != 0) {
		goto _5
	}
	goto readErr
readErr:
	;
	_UpdateInterest(tls, chanPtr)
	XTclChannelRelease(tls, chanPtr)
	return int64(-int32(1))
_5:
	;
	*(*int32)(unsafe.Pointer(bp)) = int32((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded - (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved)
	*(*int32)(unsafe.Pointer(bp + 4)) = int32(bytesToRead)
	_TranslateInputEOL(tls, statePtr, p, bufPtr+40+uintptr((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved), bp+4, bp)
	*(*TTcl_Size)(unsafe.Pointer(bufPtr + 16)) += int64(*(*int32)(unsafe.Pointer(bp)))
	p += uintptr(*(*int32)(unsafe.Pointer(bp + 4)))
	bytesToRead -= int64(*(*int32)(unsafe.Pointer(bp + 4)))
	if !((*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded == (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved) {
		/*
		 * Buffer is not empty.  How can that be?
		 *
		 * 0) We stopped early because we got all the bytes we were
		 *    seeking. That's fine.
		 */
		if bytesToRead == 0 {
			goto _1
		}
		/*
		 * 1) We're @EOF because we saw eof char, or there was an encoding error.
		 */
		if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(10)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(15)) != 0 {
			goto _1
		}
		/*
		 * 2) The buffer holds a \r while in CRLF translation, followed by
		 *    the end of the buffer.
		 */
		if (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr == libc.UintptrFromInt32(0) {
			/*
			 * There's no more buffered data...
			 */
			if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(9)) != 0 {
				/*
				 * ...and there never will be.
				 */
				v6 = p
				p++
				*(*uint8)(unsafe.Pointer(v6)) = uint8('\r')
				bytesToRead--
				(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved++
			} else {
				if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(11)) != 0 {
					/*
					 * ...and we cannot get more now.
					 */
					*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(14)
					goto _1
				} else {
					/*
					 * ...so we need to get some.
					 */
					goto moreData
				}
			}
		}
		if (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr != 0 {
			/*
			 * There's a next buffer.  Shift orphan \r to it.
			 */
			nextPtr = (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr
			*(*TTcl_Size)(unsafe.Pointer(nextPtr + 16)) -= int64(1)
			*(*uint8)(unsafe.Pointer(nextPtr + 40 + uintptr((*TChannelBuffer)(unsafe.Pointer(nextPtr)).FnextRemoved))) = uint8('\r')
			(*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved++
		}
	}
	if (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded == (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved {
		(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead = (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextPtr
		if (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead == libc.UintptrFromInt32(0) {
			(*TChannelState)(unsafe.Pointer(statePtr)).FinQueueTail = libc.UintptrFromInt32(0)
		}
		_RecycleBuffer(tls, statePtr, bufPtr, 0)
		bufPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FinQueueHead
	}
	if ((*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(6)) != 0 || allowShortReads != 0) && (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(11)) != 0 {
		goto _1
	}
	/*
	 * When there's no buffered data to read, and we're at EOF, escape to
	 * the caller.
	 */
	if (*TChannelState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(9)) != 0 && (bufPtr == libc.UintptrFromInt32(0) || (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextAdded == (*TChannelBuffer)(unsafe.Pointer(bufPtr)).FnextRemoved) {
		goto _1
	}
	goto _2
_1:
	;
	if bytesToRead == 0 {
		*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(11))
	}
	_UpdateInterest(tls, chanPtr)
	XTclChannelRelease(tls, chanPtr)
	return int64(p) - int64(dst)
}

/*
 *----------------------------------------------------------------------
 *
 * CopyEventProc --
 *
 *	This routine is invoked as a channel event handler for the background
 *	copy operation. It is just a trivial wrapper around the CopyData
 *	routine.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _CopyEventProc(tls *libc.TLS, clientData uintptr, mask int32) {
	_CopyData(tls, clientData, mask)
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * Lossless --
//	 *
//	 *	Determines whether copying characters between two channel states would
//	 *	be lossless, i.e. whether one byte corresponds to one character, every
//	 *	character appears in the Unicode character set, there are no
//	 *	translations to be performed, and no inline signals to respond to.
//	 *
//	 * Result:
//	 *	True if copying would be lossless.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _Lossless(tls *libc.TLS, inStatePtr uintptr, outStatePtr uintptr, toRead int64) (r int32) {
	return libc.BoolInt32((*TChannelState)(unsafe.Pointer(inStatePtr)).FinEofChar == int32('\000') && (*TChannelState)(unsafe.Pointer(inStatePtr)).FinputTranslation == int32(TCL_TRANSLATE_LF) && (*TChannelState)(unsafe.Pointer(outStatePtr)).FoutputTranslation == int32(TCL_TRANSLATE_LF) && ((*TChannelState)(unsafe.Pointer(inStatePtr)).Fencoding == _GetBinaryEncoding(tls) && (*TChannelState)(unsafe.Pointer(outStatePtr)).Fencoding == _GetBinaryEncoding(tls) || toRead == int64(-int32(1)) && (*TChannelState)(unsafe.Pointer(inStatePtr)).Fencoding == (*TChannelState)(unsafe.Pointer(outStatePtr)).Fencoding && libc.Uint32FromInt32((*TChannelState)(unsafe.Pointer(inStatePtr)).FinputEncodingFlags)&uint32(ENCODING_PROFILE_MASK) == uint32(TCL_ENCODING_PROFILE_TCL8) && libc.Uint32FromInt32((*TChannelState)(unsafe.Pointer(outStatePtr)).FinputEncodingFlags)&uint32(ENCODING_PROFILE_MASK) == uint32(TCL_ENCODING_PROFILE_TCL8)))
}

/*
 *----------------------------------------------------------------------
 *
 * StopCopy --
 *
 *	This routine halts a copy that is in progress.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Removes any pending channel handlers and restores the blocking and
 *	buffering modes of the channels. The CopyState is freed.
 *
 *----------------------------------------------------------------------
 */

func _StopCopy(tls *libc.TLS, csPtr uintptr) {
	/* State for bg copy to stop . */
	var cachePtr, inStatePtr, outStatePtr, v4 uintptr
	var inChan, outChan TTcl_Channel
	var nonBlocking, v1, v2 int32
	var v3 TTcl_Size
	var v5 bool
	_, _, _, _, _, _, _, _, _, _, _ = cachePtr, inChan, inStatePtr, nonBlocking, outChan, outStatePtr, v1, v2, v3, v4, v5
	if !(csPtr != 0) {
		return
	}
	inChan = (*TCopyState)(unsafe.Pointer(csPtr)).FreadPtr
	outChan = (*TCopyState)(unsafe.Pointer(csPtr)).FwritePtr
	inStatePtr = (*TChannel1)(unsafe.Pointer((*TCopyState)(unsafe.Pointer(csPtr)).FreadPtr)).Fstate
	outStatePtr = (*TChannel1)(unsafe.Pointer((*TCopyState)(unsafe.Pointer(csPtr)).FwritePtr)).Fstate
	/*
	 * Restore the old blocking mode and output buffering mode.
	 */
	nonBlocking = (*TCopyState)(unsafe.Pointer(csPtr)).FreadFlags & (libc.Int32FromInt32(1) << libc.Int32FromInt32(6))
	if nonBlocking != (*TChannelState)(unsafe.Pointer(inStatePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(6)) {
		if nonBlocking != 0 {
			v1 = int32(TCL_MODE_NONBLOCKING)
		} else {
			v1 = TCL_MODE_BLOCKING
		}
		_SetBlockMode(tls, libc.UintptrFromInt32(0), (*TCopyState)(unsafe.Pointer(csPtr)).FreadPtr, v1)
	}
	if (*TCopyState)(unsafe.Pointer(csPtr)).FreadPtr != (*TCopyState)(unsafe.Pointer(csPtr)).FwritePtr {
		nonBlocking = (*TCopyState)(unsafe.Pointer(csPtr)).FwriteFlags & (libc.Int32FromInt32(1) << libc.Int32FromInt32(6))
		if nonBlocking != (*TChannelState)(unsafe.Pointer(outStatePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(6)) {
			if nonBlocking != 0 {
				v2 = int32(TCL_MODE_NONBLOCKING)
			} else {
				v2 = TCL_MODE_BLOCKING
			}
			_SetBlockMode(tls, libc.UintptrFromInt32(0), (*TCopyState)(unsafe.Pointer(csPtr)).FwritePtr, v2)
		}
	}
	*(*int32)(unsafe.Pointer(outStatePtr + 8)) &= ^(libc.Int32FromInt32(1)<<libc.Int32FromInt32(17) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(18))
	*(*int32)(unsafe.Pointer(outStatePtr + 8)) |= (*TCopyState)(unsafe.Pointer(csPtr)).FwriteFlags & (libc.Int32FromInt32(1)<<libc.Int32FromInt32(17) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(18))
	if (*TCopyState)(unsafe.Pointer(csPtr)).FcmdPtr != 0 {
		XTcl_DeleteChannelHandler(tls, inChan, __ccgo_fp(_CopyEventProc), csPtr)
		if inChan != outChan {
			XTcl_DeleteChannelHandler(tls, outChan, __ccgo_fp(_CopyEventProc), csPtr)
		}
		XTcl_DeleteChannelHandler(tls, inChan, __ccgo_fp(_MBEvent), csPtr)
		XTcl_DeleteChannelHandler(tls, outChan, __ccgo_fp(_MBEvent), csPtr)
		v4 = (*TCopyState)(unsafe.Pointer(csPtr)).FcmdPtr
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if !(v3 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer((*TCopyState)(unsafe.Pointer(csPtr)).FcmdPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TCopyState)(unsafe.Pointer(csPtr)).FcmdPtr)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer((*TCopyState)(unsafe.Pointer(csPtr)).FcmdPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TCopyState)(unsafe.Pointer(csPtr)).FcmdPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TCopyState)(unsafe.Pointer(csPtr)).FcmdPtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer((*TCopyState)(unsafe.Pointer(csPtr)).FcmdPtr)).Flength = int64(-libc.Int32FromInt32(1))
				if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v5 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, (*TCopyState)(unsafe.Pointer(csPtr)).FcmdPtr)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer((*TCopyState)(unsafe.Pointer(csPtr)).FcmdPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*TCopyState)(unsafe.Pointer(csPtr)).FcmdPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, (*TCopyState)(unsafe.Pointer(csPtr)).FcmdPtr)
			}
		}
		(*TCopyState)(unsafe.Pointer(csPtr)).FcmdPtr = libc.UintptrFromInt32(0)
	}
	if (*TChannelState)(unsafe.Pointer(inStatePtr)).FcsPtrR != 0 {
		(*TChannelState)(unsafe.Pointer(inStatePtr)).FcsPtrR = libc.UintptrFromInt32(0)
		_CopyDecrRefCount(tls, csPtr)
	}
	if (*TChannelState)(unsafe.Pointer(outStatePtr)).FcsPtrW != 0 {
		(*TChannelState)(unsafe.Pointer(outStatePtr)).FcsPtrW = libc.UintptrFromInt32(0)
		_CopyDecrRefCount(tls, csPtr)
	}
}

func _CopyDecrRefCount(tls *libc.TLS, csPtr uintptr) {
	var v1 int32
	var v2 uintptr
	_, _ = v1, v2
	v2 = csPtr + 16
	v1 = *(*int32)(unsafe.Pointer(v2))
	*(*int32)(unsafe.Pointer(v2))--
	if v1 > int32(1) {
		return
	}
	XTclChannelRelease(tls, (*TCopyState)(unsafe.Pointer(csPtr)).FreadPtr)
	XTclChannelRelease(tls, (*TCopyState)(unsafe.Pointer(csPtr)).FwritePtr)
	XTclpFree(tls, csPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * StackSetBlockMode --
 *
 *	This function sets the blocking mode for a channel, iterating through
 *	each channel in a stack and updates the state flags.
 *
 * Results:
 *	0 if OK, result code from failed blockModeProc otherwise.
 *
 * Side effects:
 *	Modifies the blocking mode of the channel and possibly generates an
 *	error.
 *
 *----------------------------------------------------------------------
 */

func _StackSetBlockMode(tls *libc.TLS, chanPtr uintptr, mode int32) (r int32) {
	/* One of TCL_MODE_BLOCKING or
	 * TCL_MODE_NONBLOCKING. */
	var blockModeProc, statePtr uintptr
	var result int32
	_, _, _ = blockModeProc, result, statePtr
	result = 0
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	/*
	 * Start at the top of the channel stack
	 * TODO: Examine what can go wrong when blockModeProc calls
	 * disturb the stacking state of the channel.
	 */
	chanPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr
	for chanPtr != libc.UintptrFromInt32(0) {
		blockModeProc = XTcl_ChannelBlockModeProc(tls, (*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr)
		if blockModeProc != libc.UintptrFromInt32(0) {
			result = (*(*func(*libc.TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{blockModeProc})))(tls, (*TChannel)(unsafe.Pointer(chanPtr)).FinstanceData, mode)
			if result != 0 {
				XTcl_SetErrno(tls, result)
				return result
			}
		}
		chanPtr = (*TChannel)(unsafe.Pointer(chanPtr)).FdownChanPtr
	}
	return 0
}

/*
 *----------------------------------------------------------------------
 *
 * SetBlockMode --
 *
 *	This function sets the blocking mode for a channel and updates the
 *	state flags.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Modifies the blocking mode of the channel and possibly generates an
 *	error.
 *
 *----------------------------------------------------------------------
 */

func _SetBlockMode(tls *libc.TLS, interp uintptr, chanPtr uintptr, mode int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* One of TCL_MODE_BLOCKING or
	 * TCL_MODE_NONBLOCKING. */
	var result int32
	var statePtr uintptr
	_, _ = result, statePtr
	result = 0
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	/* State info for channel */
	result = _StackSetBlockMode(tls, chanPtr, mode)
	if result != 0 {
		if interp != libc.UintptrFromInt32(0) {
			/*
			 * TIP #219.
			 * Move error messages put by the driver into the bypass area and
			 * put them into the regular interpreter result. Fall back to the
			 * regular message if nothing was found in the bypass.
			 *
			 * Note that we cannot have a message in the interpreter bypass
			 * area, StackSetBlockMode is restricted to the channel bypass.
			 * We still need the interp as the destination of the move.
			 */
			if !(XTclChanCaughtErrorBypass(tls, interp, chanPtr) != 0) {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+45348, libc.VaList(bp+8, XTcl_PosixError(tls, interp))))
			}
		} else {
			/*
			 * TIP #219.
			 * If we have no interpreter to put a bypass message into we have
			 * to clear it, to prevent its propagation and use in other places
			 * unrelated to the actual occurence of the problem.
			 */
			XTcl_SetChannelError(tls, chanPtr, libc.UintptrFromInt32(0))
		}
		return int32(TCL_ERROR)
	}
	if mode == TCL_MODE_BLOCKING {
		*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1)<<libc.Int32FromInt32(6) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(7))
	} else {
		*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(6)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetChannelNames --
 *
 *	Return the names of all open channels in the interp.
 *
 * Results:
 *	TCL_OK or TCL_ERROR.
 *
 * Side effects:
 *	Interp result modified with list of channel names.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetChannelNames(tls *libc.TLS, interp uintptr) (r int32) {
	/* Interp for error reporting. */
	return XTcl_GetChannelNamesEx(tls, interp, libc.UintptrFromInt32(0))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetChannelNamesEx --
 *
 *	Return the names of open channels in the interp filtered
 *	through a pattern. If pattern is NULL, it returns all the open
 *	channels.
 *
 * Results:
 *	TCL_OK or TCL_ERROR.
 *
 * Side effects:
 *	Interp result modified with list of channel names.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetChannelNamesEx(tls *libc.TLS, interp uintptr, pattern uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Pattern to filter on. */
	var cachePtr, cachePtr1, hPtr, hTblPtr, name, resultPtr, statePtr, tsdPtr, v7 uintptr
	var v1, v8 bool
	var v6 TTcl_Size
	var _ /* hSearch at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, hPtr, hTblPtr, name, resultPtr, statePtr, tsdPtr, v1, v6, v7, v8
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey2)), int64(64)) /* Search variable. */
	if interp == libc.UintptrFromInt32(0) {
		return TCL_OK
	}
	/*
	 * Get the channel table that stores the channels registered for this
	 * interpreter.
	 */
	hTblPtr = _GetChannelTable(tls, interp)
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultPtr = XTclThreadAllocObj(tls)
	} else {
		resultPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FtypePtr = libc.UintptrFromInt32(0)
	if pattern != libc.UintptrFromInt32(0) && libc.Xstrpbrk(tls, pattern, __ccgo_ts+16411) == libc.UintptrFromInt32(0) && !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) == int32('s') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern + 1))) == int32('t') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern + 2))) == int32('d')) {
		if (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(hTblPtr)).FfindProc})))(tls, hTblPtr, pattern) != libc.UintptrFromInt32(0) && XTcl_ListObjAppendElement(tls, interp, resultPtr, XTcl_NewStringObj(tls, pattern, int64(-int32(1)))) != TCL_OK {
			goto error
		}
		goto done
	}
	hPtr = XTcl_FirstHashEntry(tls, hTblPtr, bp)
_4:
	;
	if !(hPtr != libc.UintptrFromInt32(0)) {
		goto _2
	}
	statePtr = (*TChannel)(unsafe.Pointer((*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData)).Fstate
	if (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr == (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdinChannel {
		name = __ccgo_ts + 43095
	} else {
		if (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr == (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdoutChannel {
			name = __ccgo_ts + 43101
		} else {
			if (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr == (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstderrChannel {
				name = __ccgo_ts + 43108
			} else {
				/*
				 * This is also stored in Tcl_GetHashKey(hTblPtr, hPtr), but it's
				 * simpler to just grab the name from the statePtr.
				 */
				name = (*TChannelState)(unsafe.Pointer(statePtr)).FchannelName
			}
		}
	}
	if !((pattern == libc.UintptrFromInt32(0) || XTcl_StringCaseMatch(tls, name, pattern, 0) != 0) && XTcl_ListObjAppendElement(tls, interp, resultPtr, XTcl_NewStringObj(tls, name, int64(-int32(1)))) != TCL_OK) {
		goto _5
	}
	goto error
error:
	;
	v7 = resultPtr
	v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
	*(*TTcl_Size)(unsafe.Pointer(v7))--
	if !(v6 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(resultPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(resultPtr)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Flength = int64(-libc.Int32FromInt32(1))
			if v8 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v8 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v8 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, resultPtr)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(resultPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = resultPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, resultPtr)
		}
	}
	return int32(TCL_ERROR)
_5:
	;
	goto _3
_3:
	;
	hPtr = XTcl_NextHashEntry(tls, bp)
	goto _4
	goto _2
_2:
	;
	goto done
done:
	;
	XTcl_SetObjResult(tls, interp, resultPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_IsChannelRegistered --
 *
 *	Checks whether the channel is associated with the interp. See also
 *	Tcl_RegisterChannel and Tcl_UnregisterChannel.
 *
 * Results:
 *	0 if the channel is not registered in the interpreter, 1 else.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_IsChannelRegistered(tls *libc.TLS, interp uintptr, chan1 TTcl_Channel) (r int32) {
	/* The channel to check */
	var chanPtr, hPtr, hTblPtr, statePtr uintptr
	_, _, _, _ = chanPtr, hPtr, hTblPtr, statePtr /* State of the real channel. */
	/*
	 * Always check bottom-most channel in the stack. This is the one that
	 * gets registered.
	 */
	chanPtr = (*TChannelState1)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chan1)).Fstate)).FbottomChanPtr
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	hTblPtr = XTcl_GetAssocData(tls, interp, __ccgo_ts+42937, libc.UintptrFromInt32(0))
	if hTblPtr == libc.UintptrFromInt32(0) {
		return 0
	}
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(hTblPtr)).FfindProc})))(tls, hTblPtr, (*TChannelState)(unsafe.Pointer(statePtr)).FchannelName)
	if hPtr == libc.UintptrFromInt32(0) {
		return 0
	}
	if (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData != chanPtr {
		return 0
	}
	return int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_IsChannelShared --
 *
 *	Checks whether the channel is shared by multiple interpreters.
 *
 * Results:
 *	A boolean value (0 = Not shared, 1 = Shared).
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_IsChannelShared(tls *libc.TLS, chan1 TTcl_Channel) (r int32) {
	/* The channel to query */
	var statePtr uintptr
	var v1 int32
	_, _ = statePtr, v1
	statePtr = (*TChannel)(unsafe.Pointer(chan1)).Fstate
	/* State of real channel structure. */
	if (*TChannelState)(unsafe.Pointer(statePtr)).FrefCount > int64(1) {
		v1 = int32(1)
	} else {
		v1 = 0
	}
	return v1
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_IsChannelExisting --
 *
 *	Checks whether a channel of the given name exists in the
 *	(thread)-global list of all channels. See Tcl_GetChannelNamesEx for
 *	function exposed at the Tcl level.
 *
 * Results:
 *	A boolean value (0 = Does not exist, 1 = Does exist).
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_IsChannelExisting(tls *libc.TLS, chanName uintptr) (r int32) {
	/* The name of the channel to look for. */
	var chanNameLen int32
	var name, statePtr, tsdPtr uintptr
	_, _, _, _ = chanNameLen, name, statePtr, tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey2)), int64(64))
	chanNameLen = libc.Int32FromUint64(libc.Xstrlen(tls, chanName))
	statePtr = (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FfirstCSPtr
	for {
		if !(statePtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr == (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdinChannel {
			name = __ccgo_ts + 43095
		} else {
			if (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr == (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstdoutChannel {
				name = __ccgo_ts + 43101
			} else {
				if (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr == (*TThreadSpecificData3)(unsafe.Pointer(tsdPtr)).FstderrChannel {
					name = __ccgo_ts + 43108
				} else {
					name = (*TChannelState)(unsafe.Pointer(statePtr)).FchannelName
				}
			}
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(chanName))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) && libc.Xmemcmp(tls, name, chanName, libc.Uint64FromInt32(chanNameLen+int32(1))) == 0 {
			return int32(1)
		}
		goto _1
	_1:
		;
		statePtr = (*TChannelState)(unsafe.Pointer(statePtr)).FnextCSPtr
	}
	return 0
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ChannelName --
 *
 *	Return the name of the channel type.
 *
 * Results:
 *	A pointer the name of the channel type.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ChannelName(tls *libc.TLS, chanTypePtr uintptr) (r uintptr) {
	/* Pointer to channel type. */
	return (*TTcl_ChannelType)(unsafe.Pointer(chanTypePtr)).FtypeName
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ChannelVersion --
 *
 *	Return the of version of the channel type.
 *
 * Results:
 *	One of the TCL_CHANNEL_VERSION_* constants from tcl.h
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ChannelVersion(tls *libc.TLS, chanTypePtr uintptr) (r TTcl_ChannelTypeVersion) {
	/* Pointer to channel type. */
	return (*TTcl_ChannelType)(unsafe.Pointer(chanTypePtr)).Fversion
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ChannelBlockModeProc --
 *
 *	Return the Tcl_DriverBlockModeProc of the channel type.
 *
 * Results:
 *	A pointer to the proc.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------- */

func XTcl_ChannelBlockModeProc(tls *libc.TLS, chanTypePtr uintptr) (r uintptr) {
	/* Pointer to channel type. */
	return (*TTcl_ChannelType)(unsafe.Pointer(chanTypePtr)).FblockModeProc
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ChannelClose2Proc --
 *
 *	Return the Tcl_DriverClose2Proc of the channel type.
 *
 * Results:
 *	A pointer to the proc.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ChannelClose2Proc(tls *libc.TLS, chanTypePtr uintptr) (r uintptr) {
	/* Pointer to channel type. */
	return (*TTcl_ChannelType)(unsafe.Pointer(chanTypePtr)).Fclose2Proc
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ChannelInputProc --
 *
 *	Return the Tcl_DriverInputProc of the channel type.
 *
 * Results:
 *	A pointer to the proc.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ChannelInputProc(tls *libc.TLS, chanTypePtr uintptr) (r uintptr) {
	/* Pointer to channel type. */
	return (*TTcl_ChannelType)(unsafe.Pointer(chanTypePtr)).FinputProc
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ChannelOutputProc --
 *
 *	Return the Tcl_DriverOutputProc of the channel type.
 *
 * Results:
 *	A pointer to the proc.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ChannelOutputProc(tls *libc.TLS, chanTypePtr uintptr) (r uintptr) {
	/* Pointer to channel type. */
	return (*TTcl_ChannelType)(unsafe.Pointer(chanTypePtr)).FoutputProc
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ChannelSetOptionProc --
 *
 *	Return the Tcl_DriverSetOptionProc of the channel type.
 *
 * Results:
 *	A pointer to the proc.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ChannelSetOptionProc(tls *libc.TLS, chanTypePtr uintptr) (r uintptr) {
	/* Pointer to channel type. */
	return (*TTcl_ChannelType)(unsafe.Pointer(chanTypePtr)).FsetOptionProc
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ChannelGetOptionProc --
 *
 *	Return the Tcl_DriverGetOptionProc of the channel type.
 *
 * Results:
 *	A pointer to the proc.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ChannelGetOptionProc(tls *libc.TLS, chanTypePtr uintptr) (r uintptr) {
	/* Pointer to channel type. */
	return (*TTcl_ChannelType)(unsafe.Pointer(chanTypePtr)).FgetOptionProc
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ChannelWatchProc --
 *
 *	Return the Tcl_DriverWatchProc of the channel type.
 *
 * Results:
 *	A pointer to the proc.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ChannelWatchProc(tls *libc.TLS, chanTypePtr uintptr) (r uintptr) {
	/* Pointer to channel type. */
	return (*TTcl_ChannelType)(unsafe.Pointer(chanTypePtr)).FwatchProc
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ChannelGetHandleProc --
 *
 *	Return the Tcl_DriverGetHandleProc of the channel type.
 *
 * Results:
 *	A pointer to the proc.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ChannelGetHandleProc(tls *libc.TLS, chanTypePtr uintptr) (r uintptr) {
	/* Pointer to channel type. */
	return (*TTcl_ChannelType)(unsafe.Pointer(chanTypePtr)).FgetHandleProc
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ChannelFlushProc --
 *
 *	Return the Tcl_DriverFlushProc of the channel type.
 *
 * Results:
 *	A pointer to the proc.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ChannelFlushProc(tls *libc.TLS, chanTypePtr uintptr) (r uintptr) {
	/* Pointer to channel type. */
	return (*TTcl_ChannelType)(unsafe.Pointer(chanTypePtr)).FflushProc
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ChannelHandlerProc --
 *
 *	Return the Tcl_DriverHandlerProc of the channel type.
 *
 * Results:
 *	A pointer to the proc.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ChannelHandlerProc(tls *libc.TLS, chanTypePtr uintptr) (r uintptr) {
	/* Pointer to channel type. */
	return (*TTcl_ChannelType)(unsafe.Pointer(chanTypePtr)).FhandlerProc
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ChannelWideSeekProc --
 *
 *	Return the Tcl_DriverWideSeekProc of the channel type.
 *
 * Results:
 *	A pointer to the proc.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ChannelWideSeekProc(tls *libc.TLS, chanTypePtr uintptr) (r uintptr) {
	/* Pointer to channel type. */
	return (*TTcl_ChannelType)(unsafe.Pointer(chanTypePtr)).FwideSeekProc
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ChannelThreadActionProc --
 *
 *	TIP #218, Channel Thread Actions. Return the
 *	Tcl_DriverThreadActionProc of the channel type.
 *
 * Results:
 *	A pointer to the proc.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ChannelThreadActionProc(tls *libc.TLS, chanTypePtr uintptr) (r uintptr) {
	/* Pointer to channel type. */
	return (*TTcl_ChannelType)(unsafe.Pointer(chanTypePtr)).FthreadActionProc
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetChannelErrorInterp --
 *
 *	TIP #219, Tcl Channel Reflection API.
 *	Store an error message for the I/O system.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Discards a previously stored message.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetChannelErrorInterp(tls *libc.TLS, interp uintptr, msg uintptr) {
	/* Error message to store. */
	var cachePtr, disposePtr, iPtr, v2 uintptr
	var v1 TTcl_Size
	var v3 bool
	_, _, _, _, _, _ = cachePtr, disposePtr, iPtr, v1, v2, v3
	iPtr = interp
	disposePtr = (*TInterp)(unsafe.Pointer(iPtr)).FchanMsg
	if msg != libc.UintptrFromInt32(0) {
		(*TInterp)(unsafe.Pointer(iPtr)).FchanMsg = _FixLevelCode(tls, msg)
		(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FchanMsg)).FrefCount++
	} else {
		(*TInterp)(unsafe.Pointer(iPtr)).FchanMsg = libc.UintptrFromInt32(0)
	}
	if disposePtr != libc.UintptrFromInt32(0) {
		v2 = disposePtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if !(v1 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(disposePtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(disposePtr)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(disposePtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(disposePtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(disposePtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(disposePtr)).Flength = int64(-libc.Int32FromInt32(1))
				if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, disposePtr)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(disposePtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = disposePtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, disposePtr)
			}
		}
	}
	return
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetChannelError --
 *
 *	TIP #219, Tcl Channel Reflection API.
 *	Store an error message for the I/O system.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Discards a previously stored message.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetChannelError(tls *libc.TLS, chan1 TTcl_Channel, msg uintptr) {
	/* Error message to store. */
	var cachePtr, disposePtr, statePtr, v2 uintptr
	var v1 TTcl_Size
	var v3 bool
	_, _, _, _, _, _ = cachePtr, disposePtr, statePtr, v1, v2, v3
	statePtr = (*TChannel)(unsafe.Pointer(chan1)).Fstate
	disposePtr = (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg
	if msg != libc.UintptrFromInt32(0) {
		(*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg = _FixLevelCode(tls, msg)
		(*TTcl_Obj)(unsafe.Pointer((*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg)).FrefCount++
	} else {
		(*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg = libc.UintptrFromInt32(0)
	}
	if disposePtr != libc.UintptrFromInt32(0) {
		v2 = disposePtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if !(v1 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(disposePtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(disposePtr)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(disposePtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(disposePtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(disposePtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(disposePtr)).Flength = int64(-libc.Int32FromInt32(1))
				if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, disposePtr)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(disposePtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = disposePtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, disposePtr)
			}
		}
	}
	return
}

/*
 *----------------------------------------------------------------------
 *
 * FixLevelCode --
 *
 *	TIP #219, Tcl Channel Reflection API.
 *	Scans an error message for bad -code / -level directives. Returns a
 *	modified copy with such directives corrected, and the input if it had
 *	no problems.
 *
 * Results:
 *	A Tcl_Obj*
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _FixLevelCode(tls *libc.TLS, msg uintptr) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var cignore, explicitResult, i, j, lcn, lignore, newcode, newlevel, numOptions, res, v1, v11, v12, v15, v16, v18, v19, v20, v21, v22, v6 int32
	var lvn, v10, v14, v17, v5, v7 uintptr
	var v2, v3 int64
	var v8, v9 bool
	var _ /* lc at bp+0 */ TTcl_Size
	var _ /* lv at bp+8 */ uintptr
	var _ /* val at bp+16 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cignore, explicitResult, i, j, lcn, lignore, lvn, newcode, newlevel, numOptions, res, v1, v10, v11, v12, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v3, v5, v6, v7, v8, v9
	newlevel = -int32(1)
	newcode = -int32(1)
	/* ASSERT msg != NULL */
	/*
	 * Process the caught message.
	 *
	 * Syntax = (option value)... ?message?
	 *
	 * Bad message syntax causes a panic, because the other side uses
	 * Tcl_GetReturnOptions and list construction functions to marshal the
	 * information. Hence an error means that we've got serious breakage.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(msg)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(msg + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(msg + 32))).Fptr2)).FspanStart
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(msg + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(msg + 32))).Fptr1 + 40 + uintptr(v2)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(msg + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(msg + 32))).Fptr2)).FspanLength
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(msg + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v3
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), msg, bp, bp+8)
	}
	res = v1
	if res != TCL_OK {
		XTcl_Panic(tls, __ccgo_ts+45380, 0)
	}
	explicitResult = libc.BoolInt32(int64(1) == *(*TTcl_Size)(unsafe.Pointer(bp))%int64(2))
	numOptions = int32(*(*TTcl_Size)(unsafe.Pointer(bp)) - int64(explicitResult))
	/*
	 * No options, nothing to do.
	 */
	if numOptions == 0 {
		return msg
	}
	/*
	 * Check for -code x, x != 1|error, and -level x, x != 0
	 */
	i = 0
	for {
		if !(i < numOptions) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)))).Fbytes != 0 {
			v5 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)))).Fbytes
		} else {
			v5 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		if 0 == libc.Xstrcmp(tls, v5, __ccgo_ts+30753) {
			/*
			 * !"error", !integer, integer != 1 (numeric code for error)
			 */
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i+int32(1))*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i+int32(1))*8)))).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i+int32(1))*8)))).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
				*(*int32)(unsafe.Pointer(bp + 16)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i+int32(1))*8)))).FinternalRep)))
				v6 = libc.Int32FromInt32(TCL_OK)
			} else {
				v6 = XTcl_GetIntFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i+int32(1))*8)), bp+16)
			}
			res = v6
			if v9 = res == TCL_OK && *(*int32)(unsafe.Pointer(bp + 16)) != int32(1); !v9 {
				if v8 = res != TCL_OK; v8 {
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i+int32(1))*8)))).Fbytes != 0 {
						v7 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i+int32(1))*8)))).Fbytes
					} else {
						v7 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i+int32(1))*8)), libc.UintptrFromInt32(0))
					}
				}
			}
			if v9 || v8 && 0 != libc.Xstrcmp(tls, v7, __ccgo_ts+5181) {
				newcode = int32(1)
			}
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)))).Fbytes != 0 {
				v10 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)))).Fbytes
			} else {
				v10 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)), libc.UintptrFromInt32(0))
			}
			if 0 == libc.Xstrcmp(tls, v10, __ccgo_ts+30715) {
				/*
				 * !integer, integer != 0
				 */
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i+int32(1))*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i+int32(1))*8)))).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i+int32(1))*8)))).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
					*(*int32)(unsafe.Pointer(bp + 16)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i+int32(1))*8)))).FinternalRep)))
					v11 = libc.Int32FromInt32(TCL_OK)
				} else {
					v11 = XTcl_GetIntFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i+int32(1))*8)), bp+16)
				}
				res = v11
				if res != TCL_OK || *(*int32)(unsafe.Pointer(bp + 16)) != 0 {
					newlevel = 0
				}
			}
		}
		goto _4
	_4:
		;
		i += int32(2)
	}
	/*
	 * -code, -level are either not present or ok. Nothing to do.
	 */
	if newlevel < 0 && newcode < 0 {
		return msg
	}
	lcn = numOptions
	if explicitResult != 0 {
		lcn++
	}
	if newlevel >= 0 {
		lcn += int32(2)
	}
	if newcode >= 0 {
		lcn += int32(2)
	}
	lvn = XTcl_Alloc(tls, libc.Uint64FromInt32(lcn)*uint64(8))
	/*
	 * New level/code information is spliced into the first occurrence of
	 * -level, -code, further occurrences are ignored. The options cannot be
	 * not present, we would not come here. Options which are ok are simply
	 * copied over.
	 */
	v12 = libc.Int32FromInt32(0)
	cignore = v12
	lignore = v12
	i = 0
	j = libc.Int32FromInt32(0)
	for {
		if !(i < numOptions) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)))).Fbytes != 0 {
			v14 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)))).Fbytes
		} else {
			v14 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		if 0 == libc.Xstrcmp(tls, v14, __ccgo_ts+30715) {
			if newlevel >= 0 {
				v15 = j
				j++
				*(*uintptr)(unsafe.Pointer(lvn + uintptr(v15)*8)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8))
				v16 = j
				j++
				*(*uintptr)(unsafe.Pointer(lvn + uintptr(v16)*8)) = XTcl_NewWideIntObj(tls, int64(newlevel))
				newlevel = -int32(1)
				lignore = int32(1)
				goto _13
			} else {
				if lignore != 0 {
					goto _13
				}
			}
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)))).Fbytes != 0 {
				v17 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)))).Fbytes
			} else {
				v17 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)), libc.UintptrFromInt32(0))
			}
			if 0 == libc.Xstrcmp(tls, v17, __ccgo_ts+30753) {
				if newcode >= 0 {
					v18 = j
					j++
					*(*uintptr)(unsafe.Pointer(lvn + uintptr(v18)*8)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8))
					v19 = j
					j++
					*(*uintptr)(unsafe.Pointer(lvn + uintptr(v19)*8)) = XTcl_NewWideIntObj(tls, int64(newcode))
					newcode = -int32(1)
					cignore = int32(1)
					goto _13
				} else {
					if cignore != 0 {
						goto _13
					}
				}
			}
		}
		/*
		 * Keep everything else, possibly copied down.
		 */
		v20 = j
		j++
		*(*uintptr)(unsafe.Pointer(lvn + uintptr(v20)*8)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8))
		v21 = j
		j++
		*(*uintptr)(unsafe.Pointer(lvn + uintptr(v21)*8)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i+int32(1))*8))
		goto _13
	_13:
		;
		i += int32(2)
	}
	if newlevel >= 0 {
		XTcl_Panic(tls, __ccgo_ts+45423, 0)
	}
	if newcode >= 0 {
		XTcl_Panic(tls, __ccgo_ts+45460, 0)
	}
	if explicitResult != 0 {
		v22 = j
		j++
		*(*uintptr)(unsafe.Pointer(lvn + uintptr(v22)*8)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8))
	}
	msg = XTcl_NewListObj(tls, int64(j), lvn)
	XTclpFree(tls, lvn)
	return msg
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetChannelErrorInterp --
 *
 *	TIP #219, Tcl Channel Reflection API.
 *	Return the message stored by the channel driver.
 *
 * Results:
 *	Tcl error message object.
 *
 * Side effects:
 *	Resets the stored data to NULL.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetChannelErrorInterp(tls *libc.TLS, interp uintptr, msg uintptr) {
	/* Place for error message. */
	var iPtr uintptr
	_ = iPtr
	iPtr = interp
	*(*uintptr)(unsafe.Pointer(msg)) = (*TInterp)(unsafe.Pointer(iPtr)).FchanMsg
	(*TInterp)(unsafe.Pointer(iPtr)).FchanMsg = libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetChannelError --
 *
 *	TIP #219, Tcl Channel Reflection API.
 *	Return the message stored by the channel driver.
 *
 * Results:
 *	Tcl error message object.
 *
 * Side effects:
 *	Resets the stored data to NULL.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetChannelError(tls *libc.TLS, chan1 TTcl_Channel, msg uintptr) {
	/* Place for error message. */
	var statePtr uintptr
	_ = statePtr
	statePtr = (*TChannel)(unsafe.Pointer(chan1)).Fstate
	*(*uintptr)(unsafe.Pointer(msg)) = (*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg
	(*TChannelState)(unsafe.Pointer(statePtr)).FchanMsg = libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ChannelTruncateProc --
 *
 *	TIP #208 (subsection relating to truncation, based on TIP #206).
 *	Return the Tcl_DriverTruncateProc of the channel type.
 *
 * Results:
 *	A pointer to the proc.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ChannelTruncateProc(tls *libc.TLS, chanTypePtr uintptr) (r uintptr) {
	/* Pointer to channel type. */
	return (*TTcl_ChannelType)(unsafe.Pointer(chanTypePtr)).FtruncateProc
}

/*
 *----------------------------------------------------------------------
 *
 * DupChannelInternalRep --
 *
 *	Initialize the internal representation of a new Tcl_Obj to a copy of
 *	the internal representation of an existing string object.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	copyPtr's internal rep is set to a copy of srcPtr's internal
 *	representation.
 *
 *----------------------------------------------------------------------
 */

func _DupChannelInternalRep(tls *libc.TLS, srcPtr uintptr, copyPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Object with internal rep to set. Must not
	 * currently have an internal rep.*/
	var irPtr, resPtr, v1, v2 uintptr
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_, _, _, _ = irPtr, resPtr, v1, v2
	if (*TTcl_Obj)(unsafe.Pointer(srcPtr)).FtypePtr == uintptr(unsafe.Pointer(&_chanObjType)) {
		v1 = srcPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	resPtr = v2
	(*TResolvedChanName)(unsafe.Pointer(resPtr)).FrefCount++
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr1 = resPtr
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr2 = libc.UintptrFromInt32(0)
	XTcl_StoreInternalRep(tls, copyPtr, uintptr(unsafe.Pointer(&_chanObjType)), bp)
}

/*
 *----------------------------------------------------------------------
 *
 * FreeChannelInternalRep --
 *
 *	Release statePtr storage.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	May cause state to be freed.
 *
 *----------------------------------------------------------------------
 */

func _FreeChannelInternalRep(tls *libc.TLS, objPtr uintptr) {
	/* Object with internal rep to free. */
	var irPtr, resPtr, v1, v2, v4 uintptr
	var v3 Tsize_t
	_, _, _, _, _, _ = irPtr, resPtr, v1, v2, v3, v4
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_chanObjType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	resPtr = v2
	v4 = resPtr + 24
	v3 = *(*Tsize_t)(unsafe.Pointer(v4))
	*(*Tsize_t)(unsafe.Pointer(v4))--
	if v3 > uint64(1) {
		return
	}
	XTcl_Release(tls, (*TResolvedChanName)(unsafe.Pointer(resPtr)).FstatePtr)
	XTclpFree(tls, resPtr)
}

type TChannel1 = struct {
	Fstate        uintptr
	FinstanceData uintptr
	FtypePtr      uintptr
	FdownChanPtr  uintptr
	FupChanPtr    uintptr
	FinQueueHead  uintptr
	FinQueueTail  uintptr
	FrefCount     TTcl_Size
}

type TChannelState1 = struct {
	FchannelName         uintptr
	Fflags               int32
	Fencoding            TTcl_Encoding
	FinputEncodingState  TTcl_EncodingState
	FinputEncodingFlags  int32
	FoutputEncodingState TTcl_EncodingState
	FoutputEncodingFlags int32
	FinputTranslation    TTclEolTranslation
	FoutputTranslation   TTclEolTranslation
	FinEofChar           int32
	FunreportedError     int32
	FrefCount            TTcl_Size
	FcloseCbPtr          uintptr
	FoutputStage         uintptr
	FcurOutPtr           uintptr
	FoutQueueHead        uintptr
	FoutQueueTail        uintptr
	FsaveInBufPtr        uintptr
	FinQueueHead         uintptr
	FinQueueTail         uintptr
	FchPtr               uintptr
	FinterestMask        int32
	FscriptRecordPtr     uintptr
	FbufSize             TTcl_Size
	Ftimer               TTcl_TimerToken
	FtimerChanPtr        uintptr
	FcsPtrR              uintptr
	FcsPtrW              uintptr
	FtopChanPtr          uintptr
	FbottomChanPtr       uintptr
	FnextCSPtr           uintptr
	FmanagingThread      TTcl_ThreadId
	FchanMsg             uintptr
	FunreportedMsg       uintptr
	Fepoch               TTcl_Size
	FmaxPerms            int32
}

type TCopyState1 = struct {
	FreadPtr    uintptr
	FwritePtr   uintptr
	FrefCount   int32
	FreadFlags  int32
	FwriteFlags int32
	FtoRead     TTcl_WideInt
	Ftotal      TTcl_WideInt
	Finterp     uintptr
	FcmdPtr     uintptr
	FbufSize    TTcl_Size
}

const TCL_PLATFORM_TRANSLATION2 = 0

/* !END!: Do not edit above this line. */

/*
 * Callback structure for accept callback in a TCP server.
 */

type TAcceptCallback = struct {
	Fscript uintptr
	Finterp uintptr
}

/*
 * Thread local storage used to maintain a per-thread stdout channel obj.
 * It must be per-thread because of std channel limitations.
 */

type TThreadSpecificData4 = struct {
	Finitialized  int32
	FstdoutObjPtr uintptr
}

var _dataKey3 TTcl_ThreadDataKey

/*
 *----------------------------------------------------------------------
 *
 * FinalizeIOCmdTSD --
 *
 *	Release the storage associated with the per-thread cache.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _FinalizeIOCmdTSD(tls *libc.TLS, dummy72 uintptr) {
	var _objPtr, tsdPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _ = _objPtr, tsdPtr, v1, v2
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey3)), int64(16))
	if (*TThreadSpecificData4)(unsafe.Pointer(tsdPtr)).FstdoutObjPtr != libc.UintptrFromInt32(0) {
		_objPtr = (*TThreadSpecificData4)(unsafe.Pointer(tsdPtr)).FstdoutObjPtr
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		(*TThreadSpecificData4)(unsafe.Pointer(tsdPtr)).FstdoutObjPtr = libc.UintptrFromInt32(0)
	}
	(*TThreadSpecificData4)(unsafe.Pointer(tsdPtr)).Finitialized = 0
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_PutsObjCmd --
 *
 *	This function is invoked to process the "puts" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Produces output on a channel.
 *
 *----------------------------------------------------------------------
 */

func XTcl_PutsObjCmd(tls *libc.TLS, dummy102 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument objects. */
	var cachePtr, chanObjPtr, string1, tsdPtr, v1, v2, v4, v5 uintptr
	var newline int32
	var result TTcl_Size
	var v3 bool
	var _ /* chan at bp+0 */ TTcl_Channel
	var _ /* mode at bp+8 */ int32
	_, _, _, _, _, _, _, _, _, _, _ = cachePtr, chanObjPtr, newline, result, string1, tsdPtr, v1, v2, v3, v4, v5 /* String to write. */
	chanObjPtr = libc.UintptrFromInt32(0)                                                                        /* Mode in which channel is opened. */
	switch objc {
	case int32(2): /* [puts $x] */
		string1 = *(*uintptr)(unsafe.Pointer(objv + 1*8))
		newline = int32(1)
	case int32(3): /* [puts -nonewline $x] or [puts $chan $x] */
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
		}
		if libc.Xstrcmp(tls, v1, __ccgo_ts+45496) == 0 {
			newline = 0
		} else {
			newline = int32(1)
			chanObjPtr = *(*uintptr)(unsafe.Pointer(objv + 1*8))
		}
		string1 = *(*uintptr)(unsafe.Pointer(objv + 2*8))
	case int32(4): /* [puts -nonewline $chan $x] or
		 * [puts $chan $x nonewline] */
		newline = 0
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
		}
		if libc.Xstrcmp(tls, v2, __ccgo_ts+45496) == 0 {
			chanObjPtr = *(*uintptr)(unsafe.Pointer(objv + 2*8))
			string1 = *(*uintptr)(unsafe.Pointer(objv + 3*8))
			break
		}
		/* Fall through */
		fallthrough
	default: /* [puts] or
		 * [puts some bad number of arguments...] */
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+45507)
		return int32(TCL_ERROR)
	}
	if chanObjPtr == libc.UintptrFromInt32(0) {
		tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey3)), int64(16))
		if !((*TThreadSpecificData4)(unsafe.Pointer(tsdPtr)).Finitialized != 0) {
			(*TThreadSpecificData4)(unsafe.Pointer(tsdPtr)).Finitialized = int32(1)
			if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				(*TThreadSpecificData4)(unsafe.Pointer(tsdPtr)).FstdoutObjPtr = XTclThreadAllocObj(tls)
			} else {
				(*TThreadSpecificData4)(unsafe.Pointer(tsdPtr)).FstdoutObjPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*TThreadSpecificData4)(unsafe.Pointer(tsdPtr)).FstdoutObjPtr + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer((*TThreadSpecificData4)(unsafe.Pointer(tsdPtr)).FstdoutObjPtr)).FrefCount = 0
			if libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1) == uint64(0) {
				(*TTcl_Obj)(unsafe.Pointer((*TThreadSpecificData4)(unsafe.Pointer(tsdPtr)).FstdoutObjPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer((*TThreadSpecificData4)(unsafe.Pointer(tsdPtr)).FstdoutObjPtr)).Flength = int64(libc.Int32FromInt32(0))
			} else {
				(*TTcl_Obj)(unsafe.Pointer((*TThreadSpecificData4)(unsafe.Pointer(tsdPtr)).FstdoutObjPtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
				libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*TThreadSpecificData4)(unsafe.Pointer(tsdPtr)).FstdoutObjPtr)).Fbytes, __ccgo_ts+43101, libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1))
				*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TThreadSpecificData4)(unsafe.Pointer(tsdPtr)).FstdoutObjPtr)).Fbytes + uintptr(libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1)))) = uint8('\000')
				(*TTcl_Obj)(unsafe.Pointer((*TThreadSpecificData4)(unsafe.Pointer(tsdPtr)).FstdoutObjPtr)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(7) - libc.Uint64FromInt32(1))
			}
			(*TTcl_Obj)(unsafe.Pointer((*TThreadSpecificData4)(unsafe.Pointer(tsdPtr)).FstdoutObjPtr)).FtypePtr = libc.UintptrFromInt32(0)
			(*TTcl_Obj)(unsafe.Pointer((*TThreadSpecificData4)(unsafe.Pointer(tsdPtr)).FstdoutObjPtr)).FrefCount++
			XTcl_CreateThreadExitHandler(tls, __ccgo_fp(_FinalizeIOCmdTSD), libc.UintptrFromInt32(0))
		}
		chanObjPtr = (*TThreadSpecificData4)(unsafe.Pointer(tsdPtr)).FstdoutObjPtr
	}
	if XTclGetChannelFromObj(tls, interp, chanObjPtr, bp, bp+8, 0) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if !(*(*int32)(unsafe.Pointer(bp + 8))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0) {
		if (*TTcl_Obj)(unsafe.Pointer(chanObjPtr)).Fbytes != 0 {
			v4 = (*TTcl_Obj)(unsafe.Pointer(chanObjPtr)).Fbytes
		} else {
			v4 = XTcl_GetStringFromObj(tls, chanObjPtr, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+45537, libc.VaList(bp+24, v4)))
		return int32(TCL_ERROR)
	}
	XTclChannelPreserve(tls, *(*TTcl_Channel)(unsafe.Pointer(bp)))
	result = XTcl_WriteObj(tls, *(*TTcl_Channel)(unsafe.Pointer(bp)), string1)
	if result == int64(-libc.Int32FromInt32(1)) {
		goto error
	}
	if newline != 0 {
		result = XTcl_WriteChars(tls, *(*TTcl_Channel)(unsafe.Pointer(bp)), __ccgo_ts+286, int64(1))
		if result == int64(-libc.Int32FromInt32(1)) {
			goto error
		}
	}
	XTclChannelRelease(tls, *(*TTcl_Channel)(unsafe.Pointer(bp)))
	return TCL_OK
	/*
	 * TIP #219.
	 * Capture error messages put by the driver into the bypass area and put
	 * them into the regular interpreter result. Fall back to the regular
	 * message if nothing was found in the bypass.
	 */
	goto error
error:
	;
	if !(XTclChanCaughtErrorBypass(tls, interp, *(*TTcl_Channel)(unsafe.Pointer(bp))) != 0) {
		if (*TTcl_Obj)(unsafe.Pointer(chanObjPtr)).Fbytes != 0 {
			v5 = (*TTcl_Obj)(unsafe.Pointer(chanObjPtr)).Fbytes
		} else {
			v5 = XTcl_GetStringFromObj(tls, chanObjPtr, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+45576, libc.VaList(bp+24, v5, XTcl_PosixError(tls, interp))))
	}
	XTclChannelRelease(tls, *(*TTcl_Channel)(unsafe.Pointer(bp)))
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FlushObjCmd --
 *
 *	This function is called to process the Tcl "flush" command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	May cause output to appear on the specified channel.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FlushObjCmd(tls *libc.TLS, dummy215 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument objects. */
	var chanObjPtr, v1, v2 uintptr
	var _ /* chan at bp+0 */ TTcl_Channel
	var _ /* mode at bp+8 */ int32
	_, _, _ = chanObjPtr, v1, v2
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+42889)
		return int32(TCL_ERROR)
	}
	chanObjPtr = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	if XTclGetChannelFromObj(tls, interp, chanObjPtr, bp, bp+8, 0) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if !(*(*int32)(unsafe.Pointer(bp + 8))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0) {
		if (*TTcl_Obj)(unsafe.Pointer(chanObjPtr)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(chanObjPtr)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, chanObjPtr, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+45537, libc.VaList(bp+24, v1)))
		return int32(TCL_ERROR)
	}
	XTclChannelPreserve(tls, *(*TTcl_Channel)(unsafe.Pointer(bp)))
	if XTcl_Flush(tls, *(*TTcl_Channel)(unsafe.Pointer(bp))) != TCL_OK {
		/*
		 * TIP #219.
		 * Capture error messages put by the driver into the bypass area and
		 * put them into the regular interpreter result. Fall back to the
		 * regular message if nothing was found in the bypass.
		 */
		if !(XTclChanCaughtErrorBypass(tls, interp, *(*TTcl_Channel)(unsafe.Pointer(bp))) != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(chanObjPtr)).Fbytes != 0 {
				v2 = (*TTcl_Obj)(unsafe.Pointer(chanObjPtr)).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, chanObjPtr, libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+45599, libc.VaList(bp+24, v2, XTcl_PosixError(tls, interp))))
		}
		XTclChannelRelease(tls, *(*TTcl_Channel)(unsafe.Pointer(bp)))
		return int32(TCL_ERROR)
	}
	XTclChannelRelease(tls, *(*TTcl_Channel)(unsafe.Pointer(bp)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetsObjCmd --
 *
 *	This function is called to process the Tcl "gets" command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	May consume input from channel.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetsObjCmd(tls *libc.TLS, dummy279 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument objects. */
	var _objPtr, cachePtr, cachePtr1, chanObjPtr, lineLenObj, linePtr, v1, v4, v5 uintptr
	var code int32
	var lineLen, v3 TTcl_Size
	var v2, v6 bool
	var _ /* chan at bp+0 */ TTcl_Channel
	var _ /* mode at bp+8 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, cachePtr1, chanObjPtr, code, lineLen, lineLenObj, linePtr, v1, v2, v3, v4, v5, v6
	code = TCL_OK
	if objc != int32(2) && objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+45623)
		return int32(TCL_ERROR)
	}
	chanObjPtr = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	if XTclGetChannelFromObj(tls, interp, chanObjPtr, bp, bp+8, 0) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if !(*(*int32)(unsafe.Pointer(bp + 8))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0) {
		if (*TTcl_Obj)(unsafe.Pointer(chanObjPtr)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(chanObjPtr)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, chanObjPtr, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+45641, libc.VaList(bp+24, v1)))
		return int32(TCL_ERROR)
	}
	XTclChannelPreserve(tls, *(*TTcl_Channel)(unsafe.Pointer(bp)))
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		linePtr = XTclThreadAllocObj(tls)
	} else {
		linePtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(linePtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(linePtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(linePtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(linePtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(linePtr)).FtypePtr = libc.UintptrFromInt32(0)
	lineLen = XTcl_GetsObj(tls, *(*TTcl_Channel)(unsafe.Pointer(bp)), linePtr)
	if lineLen == int64(-libc.Int32FromInt32(1)) {
		if !(XTcl_Eof(tls, *(*TTcl_Channel)(unsafe.Pointer(bp))) != 0) && !(XTcl_InputBlocked(tls, *(*TTcl_Channel)(unsafe.Pointer(bp))) != 0) {
			_objPtr = linePtr
			v4 = _objPtr
			v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
			*(*TTcl_Size)(unsafe.Pointer(v4))--
			if v3 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			/*
			 * TIP #219.
			 * Capture error messages put by the driver into the bypass area
			 * and put them into the regular interpreter result. Fall back to
			 * the regular message if nothing was found in the bypass.
			 */
			if !(XTclChanCaughtErrorBypass(tls, interp, *(*TTcl_Channel)(unsafe.Pointer(bp))) != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(chanObjPtr)).Fbytes != 0 {
					v5 = (*TTcl_Obj)(unsafe.Pointer(chanObjPtr)).Fbytes
				} else {
					v5 = XTcl_GetStringFromObj(tls, chanObjPtr, libc.UintptrFromInt32(0))
				}
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+45680, libc.VaList(bp+24, v5, XTcl_PosixError(tls, interp))))
			}
			code = int32(TCL_ERROR)
			goto done
		}
		lineLen = int64(-libc.Int32FromInt32(1))
	}
	if objc == int32(3) {
		if XTcl_ObjSetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0), linePtr, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
			code = int32(TCL_ERROR)
			goto done
		}
		if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v6 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			lineLenObj = XTclThreadAllocObj(tls)
		} else {
			lineLenObj = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(lineLenObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(lineLenObj)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(lineLenObj)).Fbytes = libc.UintptrFromInt32(0)
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(lineLenObj)).FinternalRep)) = lineLen
		(*TTcl_Obj)(unsafe.Pointer(lineLenObj)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
		XTcl_SetObjResult(tls, interp, lineLenObj)
	} else {
		XTcl_SetObjResult(tls, interp, linePtr)
	}
	goto done
done:
	;
	XTclChannelRelease(tls, *(*TTcl_Channel)(unsafe.Pointer(bp)))
	return code
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ReadObjCmd --
 *
 *	This function is invoked to process the Tcl "read" command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	May consume input from channel.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ReadObjCmd(tls *libc.TLS, dummy365 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* Argument objects. */
	var _objPtr, cachePtr, chanObjPtr, iPtr, result, resultPtr, returnOptsPtr, v10, v2, v3, v5, v8, v9 uintptr
	var charactersRead, v7 TTcl_Size
	var i, newline, v4 int32
	var v6 bool
	var _ /* chan at bp+0 */ TTcl_Channel
	var _ /* length at bp+24 */ TTcl_Size
	var _ /* mode at bp+16 */ int32
	var _ /* toRead at bp+8 */ TTcl_WideInt
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, chanObjPtr, charactersRead, i, iPtr, newline, result, resultPtr, returnOptsPtr, v10, v2, v3, v4, v5, v6, v7, v8, v9
	if !(objc != int32(2) && objc != int32(3)) {
		goto _1
	}
	goto argerror
argerror:
	;
	iPtr = interp
	XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+45703)
	/*
	 * Do not append directly; that makes ensembles using this command as
	 * a subcommand produce the wrong message.
	 */
	*(*int32)(unsafe.Pointer(iPtr + 368)) |= int32(INTERP_ALTERNATE_WRONG_ARGS)
	XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+45722)
	return int32(TCL_ERROR)
_1:
	;
	i = int32(1)
	newline = 0
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	if libc.Xstrcmp(tls, v2, __ccgo_ts+45496) == 0 {
		newline = int32(1)
		i++
	}
	if i == objc {
		goto argerror
	}
	chanObjPtr = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
	if XTclGetChannelFromObj(tls, interp, chanObjPtr, bp, bp+16, 0) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if !(*(*int32)(unsafe.Pointer(bp + 16))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0) {
		if (*TTcl_Obj)(unsafe.Pointer(chanObjPtr)).Fbytes != 0 {
			v3 = (*TTcl_Obj)(unsafe.Pointer(chanObjPtr)).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, chanObjPtr, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+45641, libc.VaList(bp+40, v3)))
		return int32(TCL_ERROR)
	}
	i++ /* Consumed channel name. */
	/*
	 * Compute how many bytes to read.
	 */
	*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) = int64(-int32(1))
	if i < objc {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
			*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep))
			v4 = libc.Int32FromInt32(TCL_OK)
		} else {
			v4 = XTcl_GetWideIntFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp+8)
		}
		if v4 != TCL_OK || *(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) < 0 {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
				v5 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
			} else {
				v5 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+45743, libc.VaList(bp+40, v5)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+45786, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
	}
	if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v6 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultPtr = XTclThreadAllocObj(tls)
	} else {
		resultPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FtypePtr = libc.UintptrFromInt32(0)
	XTclChannelPreserve(tls, *(*TTcl_Channel)(unsafe.Pointer(bp)))
	charactersRead = XTcl_ReadChars(tls, *(*TTcl_Channel)(unsafe.Pointer(bp)), resultPtr, *(*TTcl_WideInt)(unsafe.Pointer(bp + 8)), 0)
	if charactersRead == int64(-libc.Int32FromInt32(1)) {
		returnOptsPtr = libc.UintptrFromInt32(0)
		if XTclChannelGetBlockingMode(tls, *(*TTcl_Channel)(unsafe.Pointer(bp))) != 0 {
			returnOptsPtr = XTcl_NewDictObj(tls)
			XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), returnOptsPtr, XTcl_NewStringObj(tls, __ccgo_ts+45793, int64(-int32(1))), resultPtr)
		} else {
			_objPtr = resultPtr
			v8 = _objPtr
			v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
			*(*TTcl_Size)(unsafe.Pointer(v8))--
			if v7 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
		/*
		 * TIP #219.
		 * Capture error messages put by the driver into the bypass area and
		 * put them into the regular interpreter result. Fall back to the
		 * regular message if nothing was found in the bypass.
		 */
		if !(XTclChanCaughtErrorBypass(tls, interp, *(*TTcl_Channel)(unsafe.Pointer(bp))) != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(chanObjPtr)).Fbytes != 0 {
				v9 = (*TTcl_Obj)(unsafe.Pointer(chanObjPtr)).Fbytes
			} else {
				v9 = XTcl_GetStringFromObj(tls, chanObjPtr, libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+45680, libc.VaList(bp+40, v9, XTcl_PosixError(tls, interp))))
		}
		XTclChannelRelease(tls, *(*TTcl_Channel)(unsafe.Pointer(bp)))
		if returnOptsPtr != 0 {
			XTcl_SetReturnOptions(tls, interp, returnOptsPtr)
		}
		return int32(TCL_ERROR)
	}
	/*
	 * If requested, remove the last newline in the channel if at EOF.
	 */
	if charactersRead > 0 && newline != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = (*TTcl_Obj)(unsafe.Pointer(resultPtr)).Flength
			v10 = (*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes
		} else {
			v10 = XTcl_GetStringFromObj(tls, resultPtr, bp+24)
		}
		result = v10
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(result + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 24))-int64(1))))) == int32('\n') {
			XTcl_SetObjLength(tls, resultPtr, *(*TTcl_Size)(unsafe.Pointer(bp + 24))-int64(1))
		}
	}
	XTcl_SetObjResult(tls, interp, resultPtr)
	XTclChannelRelease(tls, *(*TTcl_Channel)(unsafe.Pointer(bp)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SeekObjCmd --
 *
 *	This function is invoked to process the Tcl "seek" command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Moves the position of the access point on the specified channel.  May
 *	flush queued output.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SeekObjCmd(tls *libc.TLS, dummy502 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument objects. */
	var mode, v1 int32
	var result TTcl_WideInt
	var v2 uintptr
	var _ /* chan at bp+0 */ TTcl_Channel
	var _ /* offset at bp+8 */ TTcl_WideInt
	var _ /* optionIndex at bp+16 */ int32
	_, _, _, _ = mode, result, v1, v2
	if objc != int32(3) && objc != int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+45805)
		return int32(TCL_ERROR)
	}
	if XTclGetChannelFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp, libc.UintptrFromInt32(0), 0) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep))
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_GetWideIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp+8)
	}
	if v1 != TCL_OK {
		return int32(TCL_ERROR)
	}
	mode = 0
	if objc == int32(4) {
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)), uintptr(unsafe.Pointer(&_originOptions)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+45829, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+16) != TCL_OK {
			return int32(TCL_ERROR)
		}
		mode = _modeArray[*(*int32)(unsafe.Pointer(bp + 16))]
	}
	XTclChannelPreserve(tls, *(*TTcl_Channel)(unsafe.Pointer(bp)))
	result = XTcl_Seek(tls, *(*TTcl_Channel)(unsafe.Pointer(bp)), *(*TTcl_WideInt)(unsafe.Pointer(bp + 8)), mode)
	if result == int64(-int32(1)) {
		/*
		 * TIP #219.
		 * Capture error messages put by the driver into the bypass area and
		 * put them into the regular interpreter result. Fall back to the
		 * regular message if nothing was found in the bypass.
		 */
		if !(XTclChanCaughtErrorBypass(tls, interp, *(*TTcl_Channel)(unsafe.Pointer(bp))) != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
				v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+45836, libc.VaList(bp+32, v2, XTcl_PosixError(tls, interp))))
		}
		XTclChannelRelease(tls, *(*TTcl_Channel)(unsafe.Pointer(bp)))
		return int32(TCL_ERROR)
	}
	XTclChannelRelease(tls, *(*TTcl_Channel)(unsafe.Pointer(bp)))
	return TCL_OK
}

var _originOptions = [4]uintptr{
	0: __ccgo_ts + 45799,
	1: __ccgo_ts + 11670,
	2: __ccgo_ts + 21833,
	3: libc.UintptrFromInt32(0),
}

var _modeArray = [3]int32{
	1: int32(1),
	2: int32(2),
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_TellObjCmd --
 *
 *	This function is invoked to process the Tcl "tell" command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_TellObjCmd(tls *libc.TLS, dummy577 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var code int32
	var newLoc TTcl_WideInt
	var _ /* chan at bp+0 */ TTcl_Channel
	_, _ = code, newLoc
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+42889)
		return int32(TCL_ERROR)
	}
	/*
	 * Try to find a channel with the right name and permissions in the IO
	 * channel table of this interpreter.
	 */
	if XTclGetChannelFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp, libc.UintptrFromInt32(0), 0) != TCL_OK {
		return int32(TCL_ERROR)
	}
	XTclChannelPreserve(tls, *(*TTcl_Channel)(unsafe.Pointer(bp)))
	newLoc = XTcl_Tell(tls, *(*TTcl_Channel)(unsafe.Pointer(bp)))
	/*
	 * TIP #219.
	 * Capture error messages put by the driver into the bypass area and put
	 * them into the regular interpreter result.
	 */
	code = XTclChanCaughtErrorBypass(tls, interp, *(*TTcl_Channel)(unsafe.Pointer(bp)))
	XTclChannelRelease(tls, *(*TTcl_Channel)(unsafe.Pointer(bp)))
	if code != 0 {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, newLoc))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_CloseObjCmd --
 *
 *	This function is invoked to process the Tcl "close" command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	May discard queued input; may flush queued output.
 *
 *----------------------------------------------------------------------
 */

func XTcl_CloseObjCmd(tls *libc.TLS, dummy638 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument objects. */
	var dir int32
	var resultPtr, string1, v1 uintptr
	var _ /* chan at bp+0 */ TTcl_Channel
	var _ /* index at bp+8 */ int32
	var _ /* len at bp+16 */ TTcl_Size
	_, _, _, _ = dir, resultPtr, string1, v1 /* The channel to close. */
	if objc != int32(2) && objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+45866)
		return int32(TCL_ERROR)
	}
	if XTclGetChannelFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp, libc.UintptrFromInt32(0), 0) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if objc == int32(3) {
		/*
		 * Get direction requested to close, and check syntax.
		 */
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), uintptr(unsafe.Pointer(&_dirOptions)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+45886, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+8) != TCL_OK {
			return int32(TCL_ERROR)
		}
		dir = _dirArray[*(*int32)(unsafe.Pointer(bp + 8))]
		/*
		 * Check direction against channel mode. It is an error if we try to
		 * close a direction not supported by the channel (already closed, or
		 * never opened for that direction).
		 */
		if !(dir&XTcl_GetChannelMode(tls, *(*TTcl_Channel)(unsafe.Pointer(bp))) != 0) {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+44165, libc.VaList(bp+32, _dirOptions[*(*int32)(unsafe.Pointer(bp + 8))])))
			return int32(TCL_ERROR)
		}
		/*
		 * Special handling is needed if and only if the channel mode supports
		 * more than the direction to close. Because if the close the last
		 * direction supported we can and will go through the regular
		 * process.
		 */
		if XTcl_GetChannelMode(tls, *(*TTcl_Channel)(unsafe.Pointer(bp)))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != dir {
			return XTcl_CloseEx(tls, interp, *(*TTcl_Channel)(unsafe.Pointer(bp)), dir)
		}
	}
	if XTcl_UnregisterChannel(tls, interp, *(*TTcl_Channel)(unsafe.Pointer(bp))) != TCL_OK {
		/*
		 * If there is an error message and it ends with a newline, remove the
		 * newline. This is done for command pipeline channels where the error
		 * output from the subprocesses is stored in interp's result.
		 *
		 * NOTE: This is likely to not have any effect on regular error
		 * messages produced by drivers during the closing of a channel,
		 * because the Tcl convention is that such error messages do not have
		 * a terminating newline.
		 */
		resultPtr = XTcl_GetObjResult(tls, interp)
		if (*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount > int64(1) {
			resultPtr = XTcl_DuplicateObj(tls, resultPtr)
			XTcl_SetObjResult(tls, interp, resultPtr)
		}
		if (*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = (*TTcl_Obj)(unsafe.Pointer(resultPtr)).Flength
			v1 = (*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, resultPtr, bp+16)
		}
		string1 = v1
		if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) > 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 16))-int64(1))))) == int32('\n') {
			XTcl_SetObjLength(tls, resultPtr, *(*TTcl_Size)(unsafe.Pointer(bp + 16))-int64(1))
		}
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

var _dirOptions = [3]uintptr{
	0: __ccgo_ts + 5552,
	1: __ccgo_ts + 44159,
	2: libc.UintptrFromInt32(0),
}

var _dirArray = [2]int32{
	0: libc.Int32FromInt32(1) << libc.Int32FromInt32(1),
	1: libc.Int32FromInt32(1) << libc.Int32FromInt32(2),
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FconfigureObjCmd --
 *
 *	This function is invoked to process the Tcl "fconfigure" command. See
 *	the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	May modify the behavior of an IO channel.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FconfigureObjCmd(tls *libc.TLS, dummy746 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(464)
	defer tls.Free(464) /* Argument objects. */
	var i int32
	var optionName, valueName, v1, v3, v4 uintptr
	var _ /* chan at bp+0 */ TTcl_Channel
	var _ /* ds at bp+232 */ TTcl_DString
	var _ /* ds at bp+8 */ TTcl_DString
	_, _, _, _, _, _ = i, optionName, valueName, v1, v3, v4 /* Iterate over arg-value pairs. */
	if objc < int32(2) || objc%int32(2) == int32(1) && objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+45896)
		return int32(TCL_ERROR)
	}
	if XTclGetChannelFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp, libc.UintptrFromInt32(0), 0) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if objc == int32(2) { /* DString to hold result of calling
		 * Tcl_GetChannelOption. */
		XTcl_DStringInit(tls, bp+8)
		if XTcl_GetChannelOption(tls, interp, *(*TTcl_Channel)(unsafe.Pointer(bp)), libc.UintptrFromInt32(0), bp+8) != TCL_OK {
			XTcl_DStringFree(tls, bp+8)
			return int32(TCL_ERROR)
		}
		XTcl_DStringResult(tls, interp, bp+8)
		return TCL_OK
	} else {
		if objc == int32(3) { /* DString to hold result of calling
			 * Tcl_GetChannelOption. */
			XTcl_DStringInit(tls, bp+232)
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
				v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
			} else {
				v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
			}
			optionName = v1
			if XTcl_GetChannelOption(tls, interp, *(*TTcl_Channel)(unsafe.Pointer(bp)), optionName, bp+232) != TCL_OK {
				XTcl_DStringFree(tls, bp+232)
				return int32(TCL_ERROR)
			}
			XTcl_DStringResult(tls, interp, bp+232)
			return TCL_OK
		}
	}
	i = int32(3)
	for {
		if !(i < objc) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i-int32(1))*8)))).Fbytes != 0 {
			v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i-int32(1))*8)))).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i-int32(1))*8)), libc.UintptrFromInt32(0))
		}
		optionName = v3
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
			v4 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
		} else {
			v4 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		valueName = v4
		if XTcl_SetChannelOption(tls, interp, *(*TTcl_Channel)(unsafe.Pointer(bp)), optionName, valueName) != TCL_OK {
			return int32(TCL_ERROR)
		}
		goto _2
	_2:
		;
		i += int32(2)
	}
	return TCL_OK
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_EofObjCmd --
 *
 *	This function is invoked to process the Tcl "eof" command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Sets interp's result to boolean true or false depending on whether the
 *	specified channel has an EOF condition.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_EofObjCmd(tls *libc.TLS, dummy821 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var _ /* chan at bp+0 */ TTcl_Channel
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+42889)
		return int32(TCL_ERROR)
	}
	if XTclGetChannelFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp, libc.UintptrFromInt32(0), 0) != TCL_OK {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(XTcl_Eof(tls, *(*TTcl_Channel)(unsafe.Pointer(bp))) != 0)))
	return TCL_OK
}

/*
 *---------------------------------------------------------------------------
 *
 * ChanIsBinaryCmd --
 *
 *	This function is invoked to process the Tcl "chan isbinary" command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Sets interp's result to boolean true or false depending on whether the
 *	specified channel is a binary channel.
 *
 *---------------------------------------------------------------------------
 */

func _ChanIsBinaryCmd(tls *libc.TLS, dummy861 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var _ /* chan at bp+0 */ TTcl_Channel
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+42889)
		return int32(TCL_ERROR)
	}
	if XTclGetChannelFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp, libc.UintptrFromInt32(0), 0) != TCL_OK {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(XTclChanIsBinary(tls, *(*TTcl_Channel)(unsafe.Pointer(bp))) != 0)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ExecObjCmd --
 *
 *	This function is invoked to process the "exec" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ExecObjCmd(tls *libc.TLS, dummy900 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Argument objects. */
	var _objPtr, argv, cachePtr, resultPtr, string1, v10, v11, v2, v3, v5 uintptr
	var argc, background, i, ignoreStderr, keepNewline, result, skip, v6, v7 int32
	var chan1 TTcl_Channel
	var v8 bool
	var v9 TTcl_Size
	var _ /* index at bp+0 */ int32
	var _ /* length at bp+8 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, argc, argv, background, cachePtr, chan1, i, ignoreStderr, keepNewline, result, resultPtr, skip, string1, v10, v11, v2, v3, v5, v6, v7, v8, v9
	/*
	 * Check for any leading option arguments.
	 */
	keepNewline = 0
	ignoreStderr = 0
	skip = int32(1)
	for {
		if !(skip < objc) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(skip)*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(skip)*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(skip)*8)), libc.UintptrFromInt32(0))
		}
		string1 = v2
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1))) != int32('-') {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(skip)*8)), uintptr(unsafe.Pointer(&_options15)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(TCL_EXACT)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
			return int32(TCL_ERROR)
		}
		if *(*int32)(unsafe.Pointer(bp)) == 1 {
			keepNewline = int32(1)
		} else {
			if *(*int32)(unsafe.Pointer(bp)) == 0 {
				ignoreStderr = int32(1)
			} else {
				skip++
				break
			}
		}
		goto _1
	_1:
		;
		skip++
	}
	if objc <= skip {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+45951)
		return int32(TCL_ERROR)
	}
	/*
	 * See if the command is to be run in background.
	 */
	background = 0
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))).Fbytes != 0 {
		v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))).Fbytes
	} else {
		v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), libc.UintptrFromInt32(0))
	}
	string1 = v3
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1))) == int32('&') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1 + 1))) == int32('\000') {
		objc--
		background = int32(1)
	}
	/*
	 * Create the string argument array "argv". Make sure argv is large enough
	 * to hold the argc arguments plus 1 extra for the zero end-of-argv word.
	 */
	argc = objc - skip
	argv = XTclStackAlloc(tls, interp, libc.Uint64FromInt32(argc+libc.Int32FromInt32(1))*uint64(8))
	/*
	 * Copy the string conversions of each (post option) object into the
	 * argument vector.
	 */
	i = 0
	for {
		if !(i < argc) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+skip)*8)))).Fbytes != 0 {
			v5 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+skip)*8)))).Fbytes
		} else {
			v5 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+skip)*8)), libc.UintptrFromInt32(0))
		}
		*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)) = v5
		goto _4
	_4:
		;
		i++
	}
	*(*uintptr)(unsafe.Pointer(argv + uintptr(argc)*8)) = libc.UintptrFromInt32(0)
	if background != 0 {
		v6 = 0
	} else {
		if ignoreStderr != 0 {
			v7 = libc.Int32FromInt32(1) << libc.Int32FromInt32(2)
		} else {
			v7 = libc.Int32FromInt32(1)<<libc.Int32FromInt32(2) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(3)
		}
		v6 = v7
	}
	chan1 = XTcl_OpenCommandChannel(tls, interp, int64(argc), argv, v6)
	/*
	 * Free the argv array.
	 */
	XTclStackFree(tls, interp, argv)
	if chan1 == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/* Bug [0f1ddc0df7] - encoding errors - use replace profile */
	if XTcl_SetChannelOption(tls, libc.UintptrFromInt32(0), chan1, __ccgo_ts+15022, __ccgo_ts+19738) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if background != 0 {
		/*
		 * Store the list of PIDs from the pipeline in interp's result and
		 * detach the PIDs (instead of waiting for them).
		 */
		XTclGetAndDetachPids(tls, interp, chan1)
		if XTcl_CloseEx(tls, interp, chan1, 0) != TCL_OK {
			return int32(TCL_ERROR)
		}
		return TCL_OK
	}
	if v8 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v8 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v8 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultPtr = XTclThreadAllocObj(tls)
	} else {
		resultPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FtypePtr = libc.UintptrFromInt32(0)
	if XTcl_GetChannelHandle(tls, chan1, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1), libc.UintptrFromInt32(0)) == TCL_OK {
		if XTcl_ReadChars(tls, chan1, resultPtr, int64(-int32(1)), 0) == int64(-libc.Int32FromInt32(1)) {
			/*
			 * TIP #219.
			 * Capture error messages put by the driver into the bypass area
			 * and put them into the regular interpreter result. Fall back to
			 * the regular message if nothing was found in the bypass.
			 */
			if !(XTclChanCaughtErrorBypass(tls, interp, chan1) != 0) {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+45979, libc.VaList(bp+24, XTcl_PosixError(tls, interp))))
				_objPtr = resultPtr
				v10 = _objPtr
				v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
				*(*TTcl_Size)(unsafe.Pointer(v10))--
				if v9 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
			return int32(TCL_ERROR)
		}
	}
	/*
	 * If the process produced anything on stderr, it will have been returned
	 * in the interpreter result. It needs to be appended to the result
	 * string.
	 */
	result = XTcl_CloseEx(tls, interp, chan1, 0)
	XTcl_AppendObjToObj(tls, resultPtr, XTcl_GetObjResult(tls, interp))
	/*
	 * If the last character of the result is a newline, then remove the
	 * newline character.
	 */
	if keepNewline == 0 {
		if (*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(resultPtr)).Flength
			v11 = (*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes
		} else {
			v11 = XTcl_GetStringFromObj(tls, resultPtr, bp+8)
		}
		string1 = v11
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8))-int64(1))))) == int32('\n') {
			XTcl_SetObjLength(tls, resultPtr, *(*TTcl_Size)(unsafe.Pointer(bp + 8))-int64(1))
		}
	}
	XTcl_SetObjResult(tls, interp, resultPtr)
	return result
}

var _options15 = [4]uintptr{
	0: __ccgo_ts + 45924,
	1: __ccgo_ts + 45938,
	2: __ccgo_ts + 18684,
	3: libc.UintptrFromInt32(0),
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_FblockedObjCmd --
 *
 *	This function is invoked to process the Tcl "fblocked" command. See
 *	the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Sets interp's result to boolean true or false depending on whether the
 *	preceding input operation on the channel would have blocked.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_FblockedObjCmd(tls *libc.TLS, dummy1072 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Argument objects. */
	var v1 uintptr
	var _ /* chan at bp+0 */ TTcl_Channel
	var _ /* mode at bp+8 */ int32
	_ = v1
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+42889)
		return int32(TCL_ERROR)
	}
	if XTclGetChannelFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp, bp+8, 0) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if !(*(*int32)(unsafe.Pointer(bp + 8))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+45641, libc.VaList(bp+24, v1)))
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(XTcl_InputBlocked(tls, *(*TTcl_Channel)(unsafe.Pointer(bp))) != 0)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_OpenObjCmd --
 *
 *	This function is invoked to process the "open" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_OpenObjCmd(tls *libc.TLS, dummy1118 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Argument objects. */
	var _objPtr, cachePtr, modeString, permObj, permString, what, v1, v2, v6, v9 uintptr
	var chan1 TTcl_Channel
	var code, flags, mode, pipeline, scanned, v4, v7 int32
	var v3, v8 bool
	var v5 TTcl_Size
	var _ /* cmdArgv at bp+16 */ uintptr
	var _ /* cmdObjc at bp+8 */ TTcl_Size
	var _ /* modeFlags at bp+4 */ int32
	var _ /* prot at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, chan1, code, flags, mode, modeString, permObj, permString, pipeline, scanned, what, v1, v2, v3, v4, v5, v6, v7, v8, v9
	if objc < int32(2) || objc > int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+46017)
		return int32(TCL_ERROR)
	}
	*(*int32)(unsafe.Pointer(bp)) = int32(0666)
	if objc == int32(2) {
		modeString = __ccgo_ts + 25877
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		modeString = v1
		if objc == int32(4) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes != 0 {
				v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0))
			}
			permString = v2
			code = int32(TCL_ERROR)
			scanned = int32(XTclParseAllWhiteSpace(tls, permString, int64(-int32(1))))
			/*
			 * Support legacy octal numbers.
			 */
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(permString + uintptr(scanned)))) == int32('0') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(permString + uintptr(scanned+int32(1))))) >= int32('0') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(permString + uintptr(scanned+int32(1))))) <= int32('7') {
				if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
					permObj = XTclThreadAllocObj(tls)
				} else {
					permObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(permObj + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(permObj)).FrefCount = 0
				if libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1) == uint64(0) {
					(*TTcl_Obj)(unsafe.Pointer(permObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(permObj)).Flength = int64(libc.Int32FromInt32(0))
				} else {
					(*TTcl_Obj)(unsafe.Pointer(permObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
					libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(permObj)).Fbytes, __ccgo_ts+46049, libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1))
					*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(permObj)).Fbytes + uintptr(libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)))) = uint8('\000')
					(*TTcl_Obj)(unsafe.Pointer(permObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(3) - libc.Uint64FromInt32(1))
				}
				(*TTcl_Obj)(unsafe.Pointer(permObj)).FtypePtr = libc.UintptrFromInt32(0)
				XTcl_AppendToObj(tls, permObj, permString+uintptr(scanned)+uintptr(1), int64(-int32(1)))
				if (*TTcl_Obj)(unsafe.Pointer(permObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(permObj)).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(permObj)).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
					*(*int32)(unsafe.Pointer(bp)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(permObj)).FinternalRep)))
					v4 = libc.Int32FromInt32(TCL_OK)
				} else {
					v4 = XTcl_GetIntFromObj(tls, libc.UintptrFromInt32(0), permObj, bp)
				}
				code = v4
				_objPtr = permObj
				v6 = _objPtr
				v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
				*(*TTcl_Size)(unsafe.Pointer(v6))--
				if v5 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
			if v8 = code == int32(TCL_ERROR); v8 {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
					*(*int32)(unsafe.Pointer(bp)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep)))
					v7 = libc.Int32FromInt32(TCL_OK)
				} else {
					v7 = XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)), bp)
				}
			}
			if v8 && v7 != TCL_OK {
				return int32(TCL_ERROR)
			}
		}
	}
	pipeline = 0
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v9 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v9 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	what = v9
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(what))) == int32('|') {
		pipeline = int32(1)
	}
	/*
	 * Open the file or create a process pipeline.
	 */
	if !(pipeline != 0) {
		chan1 = XTcl_FSOpenFileChannel(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), modeString, *(*int32)(unsafe.Pointer(bp)))
	} else {
		if XTcl_SplitList(tls, interp, what+uintptr(1), bp+8, bp+16) != TCL_OK {
			return int32(TCL_ERROR)
		}
		mode = XTclGetOpenMode(tls, interp, modeString, bp+4)
		if mode == -int32(1) {
			chan1 = libc.UintptrFromInt32(0)
		} else {
			flags = libc.Int32FromInt32(1)<<libc.Int32FromInt32(3) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(4)
			switch mode & (libc.Int32FromInt32(03) | libc.Int32FromInt32(O_PATH)) {
			case O_RDONLY:
				flags |= libc.Int32FromInt32(1) << libc.Int32FromInt32(2)
			case int32(O_WRONLY):
				flags |= libc.Int32FromInt32(1) << libc.Int32FromInt32(1)
			case int32(O_RDWR):
				flags |= libc.Int32FromInt32(1)<<libc.Int32FromInt32(1) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)
			default:
				XTcl_Panic(tls, __ccgo_ts+46052, 0)
				break
			}
			chan1 = XTcl_OpenCommandChannel(tls, interp, *(*TTcl_Size)(unsafe.Pointer(bp + 8)), *(*uintptr)(unsafe.Pointer(bp + 16)), flags)
			if *(*int32)(unsafe.Pointer(bp + 4))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(16)) != 0 && chan1 != 0 {
				XTcl_SetChannelOption(tls, interp, chan1, __ccgo_ts+44736, __ccgo_ts+10664)
			}
		}
		XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
	}
	if chan1 == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	XTcl_RegisterChannel(tls, interp, chan1)
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, XTcl_GetChannelName(tls, chan1), int64(-int32(1))))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TcpAcceptCallbacksDeleteProc --
 *
 *	Assocdata cleanup routine called when an interpreter is being deleted
 *	to set the interp field of all the accept callback records registered
 *	with the interpreter to NULL. This will prevent the interpreter from
 *	being used in the future to eval accept scripts.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Deallocates memory and sets the interp field of all the accept
 *	callback records to NULL to prevent this interpreter from being used
 *	subsequently to eval accept scripts.
 *
 *----------------------------------------------------------------------
 */

func _TcpAcceptCallbacksDeleteProc(tls *libc.TLS, clientData uintptr, dummy1244 uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var acceptCallbackPtr, hPtr, hTblPtr uintptr
	var _ /* hSearch at bp+0 */ TTcl_HashSearch
	_, _, _ = acceptCallbackPtr, hPtr, hTblPtr
	hTblPtr = clientData
	hPtr = XTcl_FirstHashEntry(tls, hTblPtr, bp)
	for {
		if !(hPtr != libc.UintptrFromInt32(0)) {
			break
		}
		acceptCallbackPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		(*TAcceptCallback)(unsafe.Pointer(acceptCallbackPtr)).Finterp = libc.UintptrFromInt32(0)
		goto _1
	_1:
		;
		hPtr = XTcl_NextHashEntry(tls, bp)
	}
	XTcl_DeleteHashTable(tls, hTblPtr)
	XTclpFree(tls, hTblPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * RegisterTcpServerInterpCleanup --
 *
 *	Registers an accept callback record to have its interp field set to
 *	NULL when the interpreter is deleted.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	When, in the future, the interpreter is deleted, the interp field of
 *	the accept callback data structure will be set to NULL. This will
 *	prevent attempts to eval the accept script in a deleted interpreter.
 *
 *----------------------------------------------------------------------
 */

func _RegisterTcpServerInterpCleanup(tls *libc.TLS, interp uintptr, acceptCallbackPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	/* The accept callback record whose interp
	 * field we want set to NULL when the
	 * interpreter is deleted. */
	var hPtr, hTblPtr uintptr
	var _ /* isNew at bp+0 */ int32
	_, _ = hPtr, hTblPtr /* Is the entry new? */
	hTblPtr = XTcl_GetAssocData(tls, interp, __ccgo_ts+46084, libc.UintptrFromInt32(0))
	if hTblPtr == libc.UintptrFromInt32(0) {
		hTblPtr = XTcl_Alloc(tls, uint64(104))
		XTcl_InitHashTable(tls, hTblPtr, int32(TCL_ONE_WORD_KEYS))
		XTcl_SetAssocData(tls, interp, __ccgo_ts+46084, __ccgo_fp(_TcpAcceptCallbacksDeleteProc), hTblPtr)
	}
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(hTblPtr)).FcreateProc})))(tls, hTblPtr, acceptCallbackPtr, bp)
	if !(*(*int32)(unsafe.Pointer(bp)) != 0) {
		XTcl_Panic(tls, __ccgo_ts+46106, 0)
	}
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = acceptCallbackPtr
}

/*
 *----------------------------------------------------------------------
 *
 * UnregisterTcpServerInterpCleanupProc --
 *
 *	Unregister a previously registered accept callback record. The interp
 *	field of this record will no longer be set to NULL in the future when
 *	the interpreter is deleted.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Prevents the interp field of the accept callback record from being set
 *	to NULL in the future when the interpreter is deleted.
 *
 *----------------------------------------------------------------------
 */

func _UnregisterTcpServerInterpCleanupProc(tls *libc.TLS, interp uintptr, acceptCallbackPtr uintptr) {
	/* The record for which to delete the
	 * registration. */
	var hPtr, hTblPtr uintptr
	_, _ = hPtr, hTblPtr
	hTblPtr = XTcl_GetAssocData(tls, interp, __ccgo_ts+46084, libc.UintptrFromInt32(0))
	if hTblPtr == libc.UintptrFromInt32(0) {
		return
	}
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(hTblPtr)).FfindProc})))(tls, hTblPtr, acceptCallbackPtr)
	if hPtr != libc.UintptrFromInt32(0) {
		XTcl_DeleteHashEntry(tls, hPtr)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * AcceptCallbackProc --
 *
 *	This callback is invoked by the TCP channel driver when it accepts a
 *	new connection from a client on a server socket.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Whatever the script does.
 *
 *----------------------------------------------------------------------
 */

func _AcceptCallbackProc(tls *libc.TLS, callbackData uintptr, chan1 TTcl_Channel, address uintptr, port int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Port of client that was accepted. */
	var _objPtr, _objPtr1, acceptCallbackPtr, interp, script, v2, v4 uintptr
	var result int32
	var v1, v3 TTcl_Size
	var _ /* objv at bp+0 */ [2]uintptr
	_, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, acceptCallbackPtr, interp, result, script, v1, v2, v3, v4
	acceptCallbackPtr = callbackData
	/*
	 * Check if the callback is still valid; the interpreter may have gone
	 * away, this is signalled by setting the interp field of the callback
	 * data to NULL.
	 */
	if (*TAcceptCallback)(unsafe.Pointer(acceptCallbackPtr)).Finterp != libc.UintptrFromInt32(0) {
		interp = (*TAcceptCallback)(unsafe.Pointer(acceptCallbackPtr)).Finterp
		result = TCL_OK
		(*(*[2]uintptr)(unsafe.Pointer(bp)))[0] = (*TAcceptCallback)(unsafe.Pointer(acceptCallbackPtr)).Fscript
		(*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)] = XTcl_NewListObj(tls, int64(3), libc.UintptrFromInt32(0))
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), (*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)], XTcl_NewStringObj(tls, XTcl_GetChannelName(tls, chan1), int64(-int32(1))))
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), (*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)], XTcl_NewStringObj(tls, address, int64(-int32(1))))
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), (*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)], XTcl_NewWideIntObj(tls, int64(port)))
		script = XTcl_ConcatObj(tls, int64(2), bp)
		(*TTcl_Obj)(unsafe.Pointer(script)).FrefCount++
		_objPtr = (*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)]
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		XTcl_Preserve(tls, interp)
		XTcl_RegisterChannel(tls, interp, chan1)
		/*
		 * Artificially bump the refcount to protect the channel from being
		 * deleted while the script is being evaluated.
		 */
		XTcl_RegisterChannel(tls, libc.UintptrFromInt32(0), chan1)
		result = XTcl_EvalObjEx(tls, interp, script, libc.Int32FromInt32(TCL_EVAL_DIRECT)|libc.Int32FromInt32(TCL_EVAL_GLOBAL))
		_objPtr1 = script
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		if result != TCL_OK {
			XTcl_BackgroundException(tls, interp, result)
			XTcl_UnregisterChannel(tls, interp, chan1)
		}
		/*
		 * Decrement the artificially bumped refcount. After this it is not
		 * safe anymore to use "chan", because it may now be deleted.
		 */
		XTcl_UnregisterChannel(tls, libc.UintptrFromInt32(0), chan1)
		XTcl_Release(tls, interp)
	} else {
		/*
		 * The interpreter has been deleted, so there is no useful way to use
		 * the client socket - just close it.
		 */
		XTcl_CloseEx(tls, libc.UintptrFromInt32(0), chan1, 0)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TcpServerCloseProc --
 *
 *	This callback is called when the TCP server channel for which it was
 *	registered is being closed. It informs the interpreter in which the
 *	accept script is evaluated (if that interpreter still exists) that
 *	this channel no longer needs to be informed if the interpreter is
 *	deleted.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	In the future, if the interpreter is deleted this channel will no
 *	longer be informed.
 *
 *----------------------------------------------------------------------
 */

func _TcpServerCloseProc(tls *libc.TLS, callbackData uintptr) {
	/* The data passed in the call to
	 * Tcl_CreateCloseHandler. */
	var _objPtr, acceptCallbackPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _ = _objPtr, acceptCallbackPtr, v1, v2
	acceptCallbackPtr = callbackData
	/* The actual data. */
	if (*TAcceptCallback)(unsafe.Pointer(acceptCallbackPtr)).Finterp != libc.UintptrFromInt32(0) {
		_UnregisterTcpServerInterpCleanupProc(tls, (*TAcceptCallback)(unsafe.Pointer(acceptCallbackPtr)).Finterp, acceptCallbackPtr)
	}
	_objPtr = (*TAcceptCallback)(unsafe.Pointer(acceptCallbackPtr)).Fscript
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	XTclpFree(tls, acceptCallbackPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SocketObjCmd --
 *
 *	This function is invoked to process the "socket" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Creates a socket based channel.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SocketObjCmd(tls *libc.TLS, dummy1494 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Argument objects. */
	var _objPtr, acceptCallbackPtr, arg, host, iPtr, myPortName, myaddr, port, script, v10, v12, v2, v3, v4, v9 uintptr
	var a, async, server int32
	var chan1 TTcl_Channel
	var flags uint32
	var v11 TTcl_Size
	var _ /* backlog at bp+16 */ int32
	var _ /* myport at bp+4 */ int32
	var _ /* optionIndex at bp+0 */ int32
	var _ /* portNum at bp+20 */ int32
	var _ /* reusea at bp+12 */ int32
	var _ /* reusep at bp+8 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, a, acceptCallbackPtr, arg, async, chan1, flags, host, iPtr, myPortName, myaddr, port, script, server, v10, v11, v12, v2, v3, v4, v9
	server = 0
	*(*int32)(unsafe.Pointer(bp + 4)) = 0
	async = 0
	*(*int32)(unsafe.Pointer(bp + 8)) = -int32(1)
	*(*int32)(unsafe.Pointer(bp + 12)) = -int32(1)
	*(*int32)(unsafe.Pointer(bp + 16)) = -int32(1)
	flags = uint32(0)
	myaddr = libc.UintptrFromInt32(0)
	script = libc.UintptrFromInt32(0)
	a = int32(1)
	for {
		if !(a < objc) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(a)*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(a)*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(a)*8)), libc.UintptrFromInt32(0))
		}
		arg = v2
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(arg))) != int32('-') {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(a)*8)), uintptr(unsafe.Pointer(&_socketOptions)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(TCL_EXACT)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
			return int32(TCL_ERROR)
		}
		switch *(*int32)(unsafe.Pointer(bp)) {
		case 0:
			if server == int32(1) {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+46222, int64(-int32(1))))
				return int32(TCL_ERROR)
			}
			async = int32(1)
		case 2:
			a++
			if a >= objc {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+46266, int64(-int32(1))))
				return int32(TCL_ERROR)
			}
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(a)*8)))).Fbytes != 0 {
				v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(a)*8)))).Fbytes
			} else {
				v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(a)*8)), libc.UintptrFromInt32(0))
			}
			myaddr = v3
		case 3:
			a++
			if a >= objc {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+46303, int64(-int32(1))))
				return int32(TCL_ERROR)
			}
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(a)*8)))).Fbytes != 0 {
				v4 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(a)*8)))).Fbytes
			} else {
				v4 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(a)*8)), libc.UintptrFromInt32(0))
			}
			myPortName = v4
			if XTclSockGetPort(tls, interp, myPortName, __ccgo_ts+45209, bp+4) != TCL_OK {
				return int32(TCL_ERROR)
			}
		case 6:
			if async == int32(1) {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+46222, int64(-int32(1))))
				return int32(TCL_ERROR)
			}
			server = int32(1)
			a++
			if a >= objc {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+46340, int64(-int32(1))))
				return int32(TCL_ERROR)
			}
			script = *(*uintptr)(unsafe.Pointer(objv + uintptr(a)*8))
		case 4:
			a++
			if a >= objc {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+46377, int64(-int32(1))))
				return int32(TCL_ERROR)
			}
			if XTcl_GetBoolFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(a)*8)), (libc.Int32FromInt32(TCL_NULL_OK)-libc.Int32FromInt32(2))&libc.Int32FromInt64(4), bp+12) != TCL_OK {
				return int32(TCL_ERROR)
			}
		case 5:
			a++
			if a >= objc {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+46417, int64(-int32(1))))
				return int32(TCL_ERROR)
			}
			if XTcl_GetBoolFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(a)*8)), (libc.Int32FromInt32(TCL_NULL_OK)-libc.Int32FromInt32(2))&libc.Int32FromInt64(4), bp+8) != TCL_OK {
				return int32(TCL_ERROR)
			}
		case 1:
			a++
			if a >= objc {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+46457, int64(-int32(1))))
				return int32(TCL_ERROR)
			}
			if XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(a)*8)), bp+16) != TCL_OK {
				return int32(TCL_ERROR)
			}
		default:
			XTcl_Panic(tls, __ccgo_ts+46495, 0)
		}
		goto _1
	_1:
		;
		a++
	}
	if !(server != 0) {
		goto _5
	}
	host = myaddr /* NULL implies INADDR_ANY */
	if *(*int32)(unsafe.Pointer(bp + 4)) != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+46547, int64(-int32(1))))
		return int32(TCL_ERROR)
	}
	goto _6
_5:
	;
	if !(a < objc) {
		goto _7
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(a)*8)))).Fbytes != 0 {
		v9 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(a)*8)))).Fbytes
	} else {
		v9 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(a)*8)), libc.UintptrFromInt32(0))
	}
	host = v9
	a++
	goto _8
_7:
	;
	goto wrongNumArgs
wrongNumArgs:
	;
	iPtr = interp
	XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+46587)
	*(*int32)(unsafe.Pointer(iPtr + 368)) |= int32(INTERP_ALTERNATE_WRONG_ARGS)
	XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+46638)
	return int32(TCL_ERROR)
_8:
	;
_6:
	;
	if !(server != 0) && (*(*int32)(unsafe.Pointer(bp + 12)) != -int32(1) || *(*int32)(unsafe.Pointer(bp + 8)) != -int32(1) || *(*int32)(unsafe.Pointer(bp + 16)) != -int32(1)) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+46733, int64(-int32(1))))
		return int32(TCL_ERROR)
	}
	/*
	 * Set the options to their default value if the user didn't override
	 * their value.
	 */
	if *(*int32)(unsafe.Pointer(bp + 8)) == -int32(1) {
		*(*int32)(unsafe.Pointer(bp + 8)) = 0
	}
	if *(*int32)(unsafe.Pointer(bp + 12)) == -int32(1) {
		*(*int32)(unsafe.Pointer(bp + 12)) = int32(1)
	}
	/*
	 * Build the bitset with the flags values.
	 */
	if *(*int32)(unsafe.Pointer(bp + 12)) != 0 {
		flags |= libc.Uint32FromInt32(libc.Int32FromInt32(1) << libc.Int32FromInt32(0))
	}
	if *(*int32)(unsafe.Pointer(bp + 8)) != 0 {
		flags |= libc.Uint32FromInt32(libc.Int32FromInt32(1) << libc.Int32FromInt32(1))
	}
	/*
	 * All the arguments should have been parsed by now, 'a' points to the
	 * last one, the port number.
	 */
	if a != objc-int32(1) {
		goto wrongNumArgs
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(a)*8)))).Fbytes != 0 {
		v10 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(a)*8)))).Fbytes
	} else {
		v10 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(a)*8)), libc.UintptrFromInt32(0))
	}
	port = v10
	if server != 0 {
		acceptCallbackPtr = XTcl_Alloc(tls, uint64(16))
		(*TTcl_Obj)(unsafe.Pointer(script)).FrefCount++
		(*TAcceptCallback)(unsafe.Pointer(acceptCallbackPtr)).Fscript = script
		(*TAcceptCallback)(unsafe.Pointer(acceptCallbackPtr)).Finterp = interp
		chan1 = XTcl_OpenTcpServerEx(tls, interp, port, host, flags, *(*int32)(unsafe.Pointer(bp + 16)), __ccgo_fp(_AcceptCallbackProc), acceptCallbackPtr)
		if chan1 == libc.UintptrFromInt32(0) {
			_objPtr = script
			v12 = _objPtr
			v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
			*(*TTcl_Size)(unsafe.Pointer(v12))--
			if v11 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			XTclpFree(tls, acceptCallbackPtr)
			return int32(TCL_ERROR)
		}
		/*
		 * Register with the interpreter to let us know when the interpreter
		 * is deleted (by having the callback set the interp field of the
		 * acceptCallbackPtr's structure to NULL). This is to avoid trying to
		 * eval the script in a deleted interpreter.
		 */
		_RegisterTcpServerInterpCleanup(tls, interp, acceptCallbackPtr)
		/*
		 * Register a close callback. This callback will inform the
		 * interpreter (if it still exists) that this channel does not need to
		 * be informed when the interpreter is deleted.
		 */
		XTcl_CreateCloseHandler(tls, chan1, __ccgo_fp(_TcpServerCloseProc), acceptCallbackPtr)
	} else {
		if XTclSockGetPort(tls, interp, port, __ccgo_ts+45209, bp+20) != TCL_OK {
			return int32(TCL_ERROR)
		}
		chan1 = XTcl_OpenTcpClient(tls, interp, *(*int32)(unsafe.Pointer(bp + 20)), host, myaddr, *(*int32)(unsafe.Pointer(bp + 4)), async)
		if chan1 == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
	}
	XTcl_RegisterChannel(tls, interp, chan1)
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, XTcl_GetChannelName(tls, chan1), int64(-int32(1))))
	return TCL_OK
}

var _socketOptions = [8]uintptr{
	0: __ccgo_ts + 46160,
	1: __ccgo_ts + 46167,
	2: __ccgo_ts + 46176,
	3: __ccgo_ts + 46184,
	4: __ccgo_ts + 46192,
	5: __ccgo_ts + 46203,
	6: __ccgo_ts + 46214,
	7: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FcopyObjCmd --
 *
 *	This function is invoked to process the "fcopy" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Moves data between two channels and possibly sets up a background copy
 *	handler.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FcopyObjCmd(tls *libc.TLS, dummy1745 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument objects. */
	var cmdPtr, v1, v2 uintptr
	var i, v4 int32
	var _ /* inChan at bp+0 */ TTcl_Channel
	var _ /* index at bp+20 */ int32
	var _ /* mode at bp+16 */ int32
	var _ /* outChan at bp+8 */ TTcl_Channel
	var _ /* toRead at bp+24 */ TTcl_WideInt
	_, _, _, _, _ = cmdPtr, i, v1, v2, v4
	if objc < int32(3) || objc > int32(7) || objc == int32(4) || objc == int32(6) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+46811)
		return int32(TCL_ERROR)
	}
	/*
	 * Parse the channel arguments and verify that they are readable or
	 * writable, as appropriate.
	 */
	if XTclGetChannelFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp, bp+16, 0) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if !(*(*int32)(unsafe.Pointer(bp + 16))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+45641, libc.VaList(bp+40, v1)))
		return int32(TCL_ERROR)
	}
	if XTclGetChannelFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp+8, bp+16, 0) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if !(*(*int32)(unsafe.Pointer(bp + 16))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+45537, libc.VaList(bp+40, v2)))
		return int32(TCL_ERROR)
	}
	*(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) = int64(-int32(1))
	cmdPtr = libc.UintptrFromInt32(0)
	i = int32(3)
	for {
		if !(i < objc) {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_switches1)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+20) != TCL_OK {
			return int32(TCL_ERROR)
		}
		switch *(*int32)(unsafe.Pointer(bp + 20)) {
		case 0:
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
				*(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)))).FinternalRep))
				v4 = libc.Int32FromInt32(TCL_OK)
			} else {
				v4 = XTcl_GetWideIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)), bp+24)
			}
			if v4 != TCL_OK {
				return int32(TCL_ERROR)
			}
			if *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) < 0 {
				/*
				 * Handle all negative sizes like -1, meaning 'copy all'. By
				 * resetting toRead we avoid changes in the core copying
				 * functions (which explicitly check for -1 and crash on any
				 * other negative value).
				 */
				*(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) = int64(-int32(1))
			}
		case 1:
			cmdPtr = *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8))
			break
		}
		goto _3
	_3:
		;
		i += int32(2)
	}
	return XTclCopyChannel(tls, interp, *(*TTcl_Channel)(unsafe.Pointer(bp)), *(*TTcl_Channel)(unsafe.Pointer(bp + 8)), *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)), cmdPtr)
}

var _switches1 = [3]uintptr{
	0: __ccgo_ts + 46805,
	1: __ccgo_ts + 18236,
	2: libc.UintptrFromInt32(0),
}

/*
 *---------------------------------------------------------------------------
 *
 * ChanPendingObjCmd --
 *
 *	This function is invoked to process the Tcl "chan pending" command
 *	(TIP #287). See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Sets interp's result to the number of bytes of buffered input or
 *	output (depending on whether the first argument is "input" or
 *	"output"), or -1 if the channel wasn't opened for that mode.
 *
 *---------------------------------------------------------------------------
 */

func _ChanPendingObjCmd(tls *libc.TLS, dummy1840 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var _ /* chan at bp+0 */ TTcl_Channel
	var _ /* index at bp+8 */ int32
	var _ /* mode at bp+12 */ int32
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+46870)
		return int32(TCL_ERROR)
	}
	if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), uintptr(unsafe.Pointer(&_options16)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+15665, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+8) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if XTclGetChannelFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp, bp+12, 0) != TCL_OK {
		return int32(TCL_ERROR)
	}
	switch *(*int32)(unsafe.Pointer(bp + 8)) {
	case 0:
		if !(*(*int32)(unsafe.Pointer(bp + 12))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, int64(-int32(1))))
		} else {
			XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, int64(XTcl_InputBuffered(tls, *(*TTcl_Channel)(unsafe.Pointer(bp))))))
		}
	case 1:
		if !(*(*int32)(unsafe.Pointer(bp + 12))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, int64(-int32(1))))
		} else {
			XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, int64(XTcl_OutputBuffered(tls, *(*TTcl_Channel)(unsafe.Pointer(bp))))))
		}
		break
	}
	return TCL_OK
}

var _options16 = [3]uintptr{
	0: __ccgo_ts + 46857,
	1: __ccgo_ts + 46863,
	2: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * ChanTruncateObjCmd --
 *
 *	This function is invoked to process the "chan truncate" Tcl command.
 *	See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Truncates a channel (or rather a file underlying a channel).
 *
 *----------------------------------------------------------------------
 */

func _ChanTruncateObjCmd(tls *libc.TLS, dummy1902 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument objects. */
	var v1 int32
	var v2, v3 uintptr
	var _ /* chan at bp+0 */ TTcl_Channel
	var _ /* length at bp+8 */ TTcl_WideInt
	_, _, _ = v1, v2, v3
	if objc < int32(2) || objc > int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+46883)
		return int32(TCL_ERROR)
	}
	if XTclGetChannelFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp, libc.UintptrFromInt32(0), 0) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if objc == int32(3) {
		/*
		 * User is supplying an explicit length.
		 */
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
			*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FinternalRep))
			v1 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1 = XTcl_GetWideIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp+8)
		}
		if v1 != TCL_OK {
			return int32(TCL_ERROR)
		}
		if *(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) < 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+46900, int64(-int32(1))))
			return int32(TCL_ERROR)
		}
	} else {
		/*
		 * User wants to truncate to the current file position.
		 */
		*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) = XTcl_Tell(tls, *(*TTcl_Channel)(unsafe.Pointer(bp)))
		if *(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) == int64(-int32(1)) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
				v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+46943, libc.VaList(bp+24, v2, XTcl_PosixError(tls, interp))))
			return int32(TCL_ERROR)
		}
	}
	if XTcl_TruncateChannel(tls, *(*TTcl_Channel)(unsafe.Pointer(bp)), *(*TTcl_WideInt)(unsafe.Pointer(bp + 8))) != TCL_OK {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
			v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+46992, libc.VaList(bp+24, v3, XTcl_PosixError(tls, interp))))
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * ChanPipeObjCmd --
 *
 *	This function is invoked to process the "chan pipe" Tcl command.
 *	See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Creates a pair of Tcl channels wrapping both ends of a new
 *	anonymous pipe.
 *
 *----------------------------------------------------------------------
 */

func _ChanPipeObjCmd(tls *libc.TLS, dummy1975 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var cachePtr, resultPtr uintptr
	var channelNames [2]uintptr
	var v1 bool
	var _ /* rchan at bp+0 */ TTcl_Channel
	var _ /* wchan at bp+8 */ TTcl_Channel
	_, _, _, _ = cachePtr, channelNames, resultPtr, v1
	if objc != int32(1) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+1945)
		return int32(TCL_ERROR)
	}
	if XTcl_CreatePipe(tls, interp, bp, bp+8, 0) != TCL_OK {
		return int32(TCL_ERROR)
	}
	channelNames[0] = XTcl_GetChannelName(tls, *(*TTcl_Channel)(unsafe.Pointer(bp)))
	channelNames[int32(1)] = XTcl_GetChannelName(tls, *(*TTcl_Channel)(unsafe.Pointer(bp + 8)))
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultPtr = XTclThreadAllocObj(tls)
	} else {
		resultPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FtypePtr = libc.UintptrFromInt32(0)
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultPtr, XTcl_NewStringObj(tls, channelNames[0], int64(-int32(1))))
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultPtr, XTcl_NewStringObj(tls, channelNames[int32(1)], int64(-int32(1))))
	XTcl_SetObjResult(tls, interp, resultPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclChannelNamesCmd --
 *
 *	This function is invoked to process the "chan names" and "file
 *	channels" Tcl commands.  See the user documentation for details on
 *	what they do.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclChannelNamesCmd(tls *libc.TLS, dummy2026 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var v1, v2 uintptr
	_, _ = v1, v2
	if objc < int32(1) || objc > int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+16401)
		return int32(TCL_ERROR)
	}
	if objc == int32(1) {
		v1 = libc.UintptrFromInt32(0)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
		}
		v1 = v2
	}
	return XTcl_GetChannelNamesEx(tls, interp, v1)
}

/*
 *----------------------------------------------------------------------
 *
 * TclInitChanCmd --
 *
 *	This function is invoked to create the "chan" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A Tcl command handle.
 *
 * Side effects:
 *	None (since nothing is byte-compiled).
 *
 *----------------------------------------------------------------------
 */

func XTclInitChanCmd(tls *libc.TLS, interp uintptr) (r TTcl_Command) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var ensemble TTcl_Command
	var i int32
	var _ /* mapObj at bp+0 */ uintptr
	_, _ = ensemble, i
	ensemble = XTclMakeEnsemble(tls, interp, __ccgo_ts+47094, uintptr(unsafe.Pointer(&_initMap1)))
	XTcl_GetEnsembleMappingDict(tls, libc.UintptrFromInt32(0), ensemble, bp)
	i = 0
	for {
		if !(_extras[i] != 0) {
			break
		}
		/*
		 * Can assume that reference counts are all incremented.
		 */
		XTclDictPutString(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), _extras[i], _extras[i+int32(1)])
		goto _1
	_1:
		;
		i += int32(2)
	}
	XTcl_SetEnsembleMappingDict(tls, interp, ensemble, *(*uintptr)(unsafe.Pointer(bp)))
	return ensemble
}

/*
 * Most commands are plugged directly together, but some are done via
 * alias-like rewriting; [chan configure] is this way for security reasons
 * (want overwriting of [fconfigure] to control that nicely), and [chan
 * names] because the functionality isn't available as a separate command
 * function at the moment.
 */
var _initMap1 = [21]TEnsembleImplMap{
	0: {
		Fname: __ccgo_ts + 47026,
	},
	1: {
		Fname: __ccgo_ts + 5462,
	},
	2: {
		Fname: __ccgo_ts + 5658,
	},
	3: {
		Fname: __ccgo_ts + 26194,
	},
	4: {
		Fname: __ccgo_ts + 5468,
	},
	5: {
		Fname: __ccgo_ts + 47034,
	},
	6: {
		Fname: __ccgo_ts + 5518,
	},
	7: {
		Fname: __ccgo_ts + 5524,
	},
	8: {
		Fname: __ccgo_ts + 47040,
	},
	9: {
		Fname: __ccgo_ts + 15007,
	},
	10: {
		Fname: __ccgo_ts + 47049,
	},
	11: {
		Fname: __ccgo_ts + 47057,
	},
	12: {
		Fname: __ccgo_ts + 3047,
	},
	13: {
		Fname: __ccgo_ts + 47062,
	},
	14: {
		Fname: __ccgo_ts + 2116,
	},
	15: {
		Fname: __ccgo_ts + 5543,
	},
	16: {
		Fname: __ccgo_ts + 5552,
	},
	17: {
		Fname: __ccgo_ts + 5557,
	},
	18: {
		Fname: __ccgo_ts + 5576,
	},
	19: {
		Fname: __ccgo_ts + 47072,
	},
	20: {},
}

func init() {
	p := unsafe.Pointer(&_initMap1)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(XTcl_FblockedObjCmd)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(XTcl_CloseObjCmd)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(XTclCompileBasic1Or2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(XTcl_FcopyObjCmd)
	*(*uintptr)(unsafe.Add(p, 152)) = __ccgo_fp(XTclChanCreateObjCmd)
	*(*uintptr)(unsafe.Add(p, 160)) = __ccgo_fp(XTclCompileBasic2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 200)) = __ccgo_fp(XTcl_EofObjCmd)
	*(*uintptr)(unsafe.Add(p, 208)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 248)) = __ccgo_fp(XTcl_FileEventObjCmd)
	*(*uintptr)(unsafe.Add(p, 256)) = __ccgo_fp(XTclCompileBasic2Or3ArgCmd)
	*(*uintptr)(unsafe.Add(p, 296)) = __ccgo_fp(XTcl_FlushObjCmd)
	*(*uintptr)(unsafe.Add(p, 304)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 344)) = __ccgo_fp(XTcl_GetsObjCmd)
	*(*uintptr)(unsafe.Add(p, 352)) = __ccgo_fp(XTclCompileBasic1Or2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 392)) = __ccgo_fp(_ChanIsBinaryCmd)
	*(*uintptr)(unsafe.Add(p, 400)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 440)) = __ccgo_fp(XTclChannelNamesCmd)
	*(*uintptr)(unsafe.Add(p, 448)) = __ccgo_fp(XTclCompileBasic0Or1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 488)) = __ccgo_fp(_ChanPendingObjCmd)
	*(*uintptr)(unsafe.Add(p, 496)) = __ccgo_fp(XTclCompileBasic2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 536)) = __ccgo_fp(_ChanPipeObjCmd)
	*(*uintptr)(unsafe.Add(p, 544)) = __ccgo_fp(XTclCompileBasic0ArgCmd)
	*(*uintptr)(unsafe.Add(p, 584)) = __ccgo_fp(XTclChanPopObjCmd)
	*(*uintptr)(unsafe.Add(p, 592)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 632)) = __ccgo_fp(XTclChanPostEventObjCmd)
	*(*uintptr)(unsafe.Add(p, 640)) = __ccgo_fp(XTclCompileBasic2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 680)) = __ccgo_fp(XTclChanPushObjCmd)
	*(*uintptr)(unsafe.Add(p, 688)) = __ccgo_fp(XTclCompileBasic2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 728)) = __ccgo_fp(XTcl_PutsObjCmd)
	*(*uintptr)(unsafe.Add(p, 776)) = __ccgo_fp(XTcl_ReadObjCmd)
	*(*uintptr)(unsafe.Add(p, 824)) = __ccgo_fp(XTcl_SeekObjCmd)
	*(*uintptr)(unsafe.Add(p, 832)) = __ccgo_fp(XTclCompileBasic2Or3ArgCmd)
	*(*uintptr)(unsafe.Add(p, 872)) = __ccgo_fp(XTcl_TellObjCmd)
	*(*uintptr)(unsafe.Add(p, 880)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 920)) = __ccgo_fp(_ChanTruncateObjCmd)
	*(*uintptr)(unsafe.Add(p, 928)) = __ccgo_fp(XTclCompileBasic1Or2ArgCmd)
}

var _extras = [3]uintptr{
	0: __ccgo_ts + 29497,
	1: __ccgo_ts + 47081,
	2: libc.UintptrFromInt32(0),
}

const EOK = 0
const NULLABLE_METHODS = 1
const RANDW = 6
const RCMKEY = "ReflectedChannelMap"
const REQUIRED_METHODS = 1

/*
 * The C layer channel type/driver definition used by the reflection.
 */

var _reflectedChannelType = TTcl_ChannelType{
	FtypeName: __ccgo_ts + 47099,
	Fversion:  libc.UintptrFromInt32(0x5),
}

func init() {
	p := unsafe.Pointer(&_reflectedChannelType)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_ReflectInput)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_ReflectOutput)
	*(*uintptr)(unsafe.Add(p, 48)) = __ccgo_fp(_ReflectSetOption)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(_ReflectGetOption)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(_ReflectWatch)
	*(*uintptr)(unsafe.Add(p, 80)) = __ccgo_fp(_ReflectClose)
	*(*uintptr)(unsafe.Add(p, 88)) = __ccgo_fp(_ReflectBlock)
	*(*uintptr)(unsafe.Add(p, 112)) = __ccgo_fp(_ReflectSeekWide)
	*(*uintptr)(unsafe.Add(p, 120)) = __ccgo_fp(_ReflectThread)
	*(*uintptr)(unsafe.Add(p, 128)) = __ccgo_fp(_ReflectTruncate)
}

/*
 * Instance data for a reflected channel. ===========================
 */

type TReflectedChannel = struct {
	Fchan1    TTcl_Channel
	Finterp   uintptr
	Fthread   TTcl_ThreadId
	Fowner    TTcl_ThreadId
	Fcmd      uintptr
	Fmethods  uintptr
	Fname     uintptr
	Fmode     int32
	Finterest int32
	Fdead     int32
}

/*
 * Structure of the table mapping from channel handles to reflected
 * channels. Each interpreter which has the handler command for one or more
 * reflected channels records them in such a table, so that 'chan postevent'
 * is able to find them even if the actual channel was moved to a different
 * interpreter and/or thread.
 *
 * The table is reachable via the standard interpreter AssocData, the key is
 * defined below.
 */

type TReflectedChannelMap = struct {
	Fmap1 TTcl_HashTable
}

/*
 * Event literals. ==================================================
 */

var _eventOptions = [3]uintptr{
	0: __ccgo_ts + 5552,
	1: __ccgo_ts + 44159,
	2: libc.UintptrFromInt32(0),
}

type TEventOption = int32

const EVENT_READ = 0
const EVENT_WRITE = 1

/*
 * Method literals. ==================================================
 */

var _methodNames = [12]uintptr{
	0:  __ccgo_ts + 47111,
	1:  __ccgo_ts + 47120,
	2:  __ccgo_ts + 47125,
	3:  __ccgo_ts + 29497,
	4:  __ccgo_ts + 47133,
	5:  __ccgo_ts + 47142,
	6:  __ccgo_ts + 5552,
	7:  __ccgo_ts + 5557,
	8:  __ccgo_ts + 47072,
	9:  __ccgo_ts + 47153,
	10: __ccgo_ts + 44159,
	11: libc.UintptrFromInt32(0),
}

type TMethodName = int32

const METH_BLOCKING = 0
const METH_CGET = 1
const METH_CGETALL = 2
const METH_CONFIGURE = 3
const METH_FINAL = 4
const METH_INIT = 5
const METH_READ = 6
const METH_SEEK = 7
const METH_TRUNCATE = 8
const METH_WATCH = 9
const METH_WRITE = 10

/*
 * Thread specific types and structures.
 *
 * We are here essentially creating a very specific implementation of 'thread
 * send'.
 */

/*
 * Enumeration of all operations which can be forwarded.
 */

type TForwardedOperation = int32

const ForwardedClose = 0
const ForwardedInput = 1
const ForwardedOutput = 2
const ForwardedSeek = 3
const ForwardedWatch = 4
const ForwardedBlock = 5
const ForwardedSetOpt = 6
const ForwardedGetOpt = 7
const ForwardedGetOptAll = 8
const ForwardedTruncate = 9

/*
 * Event used to forward driver invocations to the thread actually managing
 * the channel. We cannot construct the command to execute and forward that.
 * Because then it will contain a mixture of Tcl_Obj's belonging to both the
 * command handler thread (CT), and the thread managing the channel (MT),
 * executed in CT. Tcl_Obj's are not allowed to cross thread boundaries. So we
 * forward an operation code, the argument details, and reference to results.
 * The command is assembled in the CT and belongs fully to that thread. No
 * sharing problems.
 */

type TForwardParamBase = struct {
	Fcode     int32
	FmsgStr   uintptr
	FmustFree int32
}

/*
 * Operation specific parameter/result structures. (These are "subtypes" of
 * ForwardParamBase. Where an operation does not need any special types, it
 * has no "subtype" and just uses ForwardParamBase, as listed above.)
 */

type TForwardParamInput = struct {
	Fbase   TForwardParamBase
	Fbuf    uintptr
	FtoRead TTcl_Size
}

type TForwardParamOutput = struct {
	Fbase    TForwardParamBase
	Fbuf     uintptr
	FtoWrite TTcl_Size
}

type TForwardParamSeek = struct {
	Fbase     TForwardParamBase
	FseekMode int32
	Foffset   TTcl_WideInt
}

type TForwardParamWatch = struct {
	Fbase TForwardParamBase
	Fmask int32
}

type TForwardParamBlock = struct {
	Fbase        TForwardParamBase
	Fnonblocking int32
}

type TForwardParamSetOpt = struct {
	Fbase  TForwardParamBase
	Fname  uintptr
	Fvalue uintptr
}

type TForwardParamGetOpt = struct {
	Fbase  TForwardParamBase
	Fname  uintptr
	Fvalue uintptr
}

type TForwardParamTruncate = struct {
	Fbase   TForwardParamBase
	Flength TTcl_WideInt
}

/*
 * Now join all these together in a single union for convenience.
 */

type TForwardParam = struct {
	Finput       [0]TForwardParamInput
	Foutput      [0]TForwardParamOutput
	Fseek        [0]TForwardParamSeek
	Fwatch       [0]TForwardParamWatch
	Fblock       [0]TForwardParamBlock
	FsetOpt      [0]TForwardParamSetOpt
	FgetOpt      [0]TForwardParamGetOpt
	Ftruncate    [0]TForwardParamTruncate
	Fbase        TForwardParamBase
	F__ccgo_pad9 [16]byte
}

/*
 * Forward declaration.
 */

type TForwardingResult = struct {
	Fsrc     TTcl_ThreadId
	Fdst     TTcl_ThreadId
	Fdsti    uintptr
	Fdone    TTcl_Condition
	Fresult  int32
	FevPtr   uintptr
	FprevPtr uintptr
	FnextPtr uintptr
}

/*
 * General event structure, with reference to operation specific data.
 */

type TForwardingEvent = struct {
	Fevent     TTcl_Event
	FresultPtr uintptr
	Fop        TForwardedOperation
	FrcPtr     uintptr
	Fparam     uintptr
}

/*
 * Structure to manage the result of the forwarding. This is not the result of
 * the operation itself, but about the success of the forward event itself.
 * The event can be successful, even if the operation which was forwarded
 * failed. It is also there to manage the synchronization between the involved
 * threads.
 */

type TForwardingResult1 = struct {
	Fsrc     TTcl_ThreadId
	Fdst     TTcl_ThreadId
	Fdsti    uintptr
	Fdone    TTcl_Condition
	Fresult  int32
	FevPtr   uintptr
	FprevPtr uintptr
	FnextPtr uintptr
}

type TThreadSpecificData5 = struct {
	FrcmPtr uintptr
}

var _dataKey4 TTcl_ThreadDataKey

/*
 * List of forwarded operations which have not completed yet, plus the mutex
 * to protect the access to this process global list.
 */

var _forwardList = libc.UintptrFromInt32(0)

var _rcForwardMutex TTcl_Mutex

/*
 * Global constant strings (messages). ==================
 * These string are used directly as bypass errors, thus they have to be valid
 * Tcl lists where the last element is the message itself. Hence the
 * list-quoting to keep the words of the message together. See also [x].
 */

var _msg_read_toomuch = __ccgo_ts + 47159
var _msg_read_nonbyte = __ccgo_ts + 47196
var _msg_write_toomuch = __ccgo_ts + 47228
var _msg_write_nothing = __ccgo_ts + 47262
var _msg_seek_beforestart = __ccgo_ts + 47284
var _msg_send_originlost = __ccgo_ts + 47314
var _msg_send_dstlost = __ccgo_ts + 47336
var _msg_dstlost = __ccgo_ts + 47349

/*
 * Main methods to plug into the 'chan' ensemble'. ==================
 */

/*
 *----------------------------------------------------------------------
 *
 * TclChanCreateObjCmd --
 *
 *	This function is invoked to process the "chan create" Tcl command.
 *	See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result. The handle of the new channel is placed in the
 *	interp result.
 *
 * Side effects:
 *	Creates a new channel.
 *
 *----------------------------------------------------------------------
 */

func XTclChanCreateObjCmd(tls *libc.TLS, dummy491 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, _objPtr6, _objPtr7, cachePtr, chanPtr, clonePtr, cmdObj, err, hPtr, modeObj, rcId, rcPtr, rcmPtr, v11, v14, v16, v17, v18, v19, v2, v20, v21, v22, v24, v26, v28, v4, v8, v9 uintptr
	var chan1 TTcl_Channel
	var methods, result, v5 int32
	var v1, v10, v13, v15, v23, v25, v27, v3 TTcl_Size
	var v12 bool
	var v6, v7 int64
	var _ /* cmdNameObj at bp+8 */ uintptr
	var _ /* isNew at bp+48 */ int32
	var _ /* listc at bp+16 */ TTcl_Size
	var _ /* listv at bp+24 */ uintptr
	var _ /* methIndex at bp+32 */ int32
	var _ /* mode at bp+0 */ int32
	var _ /* resObj at bp+40 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, _objPtr6, _objPtr7, cachePtr, chan1, chanPtr, clonePtr, cmdObj, err, hPtr, methods, modeObj, rcId, rcPtr, rcmPtr, result, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v3, v4, v5, v6, v7, v8, v9
	/*
	 * Number of arguments...
	 */
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+47422)
		return int32(TCL_ERROR)
	}
	/*
	 * First argument is a list of modes. Allowed entries are "read", "write".
	 * Empty list is uncommon, but allowed. Abbreviations are ok.
	 */
	modeObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(1)*8))
	if _EncodeEventMask(tls, interp, __ccgo_ts+15665, *(*uintptr)(unsafe.Pointer(objv + uintptr(1)*8)), bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Second argument is command prefix, i.e. list of words, first word is
	 * name of handler command, other words are fixed arguments. Run the
	 * 'initialize' method to get the list of supported methods. Validate
	 * this.
	 */
	cmdObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(2)*8))
	/*
	 * Basic check that the command prefix truly is a list.
	 */
	if XTcl_ListObjIndex(tls, interp, cmdObj, 0, bp+8) != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Now create the channel.
	 */
	rcId = _NextHandle(tls)
	rcPtr = _NewReflectedChannel(tls, interp, cmdObj, *(*int32)(unsafe.Pointer(bp)), rcId)
	if !(rcPtr != 0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Invoke 'initialize' and validate that the handler is present and ok.
	 * Squash the channel if not.
	 *
	 * Note: The conversion of 'mode' back into a Tcl_Obj ensures that
	 * 'initialize' is invoked with canonical mode names, and no
	 * abbreviations. Using modeObj directly could feed abbreviations into the
	 * handler, and the handler is not specified to handle such.
	 */
	modeObj = _DecodeEventMask(tls, *(*int32)(unsafe.Pointer(bp)))
	/* assert modeObj.refCount == 1 */
	result = _InvokeTclMethod(tls, rcPtr, int32(METH_INIT), modeObj, libc.UintptrFromInt32(0), bp+40)
	_objPtr = modeObj
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	if result != TCL_OK {
		_UnmarshallErrorResult(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 40)))
		_objPtr1 = *(*uintptr)(unsafe.Pointer(bp + 40))
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		} /* Remove reference held from invoke */
		goto error
	}
	/*
	 * Verify the result.
	 * - List, of method names. Convert to mask.
	 *   Check for non-optionals through the mask.
	 *   Compare open mode against optional r/w.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr2 != 0 {
			v6 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr2)).FspanStart
		} else {
			v6 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 24)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr1 + 40 + uintptr(v6)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr2 != 0 {
			v7 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr2)).FspanLength
		} else {
			v7 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = v7
		v5 = libc.Int32FromInt32(TCL_OK)
	} else {
		v5 = XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 40)), bp+16, bp+24)
	}
	if v5 != TCL_OK {
		if (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes != 0 {
			v8 = (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes
		} else {
			v8 = XTcl_GetStringFromObj(tls, cmdObj, libc.UintptrFromInt32(0))
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).Fbytes != 0 {
			v9 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).Fbytes
		} else {
			v9 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 40)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+47437, libc.VaList(bp+64, v8, v9)))
		_objPtr2 = *(*uintptr)(unsafe.Pointer(bp + 40))
		v11 = _objPtr2
		v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
		*(*TTcl_Size)(unsafe.Pointer(v11))--
		if v10 <= int64(1) {
			XTclFreeObj(tls, _objPtr2)
		}
		goto error
	}
	methods = 0
	for *(*TTcl_Size)(unsafe.Pointer(bp + 16)) > 0 {
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 16))-int64(1))*8)), uintptr(unsafe.Pointer(&_methodNames)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+28559, libc.Int32FromInt32(TCL_EXACT)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+32) != TCL_OK {
			if v12 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v12 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v12 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				err = XTclThreadAllocObj(tls)
			} else {
				err = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(err + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(err)).FrefCount = 0
			if libc.Uint64FromInt64(15)-libc.Uint64FromInt32(1) == uint64(0) {
				(*TTcl_Obj)(unsafe.Pointer(err)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(err)).Flength = int64(libc.Int32FromInt32(0))
			} else {
				(*TTcl_Obj)(unsafe.Pointer(err)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(15)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
				libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(err)).Fbytes, __ccgo_ts+47488, libc.Uint64FromInt64(15)-libc.Uint64FromInt32(1))
				*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(err)).Fbytes + uintptr(libc.Uint64FromInt64(15)-libc.Uint64FromInt32(1)))) = uint8('\000')
				(*TTcl_Obj)(unsafe.Pointer(err)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(15) - libc.Uint64FromInt32(1))
			}
			(*TTcl_Obj)(unsafe.Pointer(err)).FtypePtr = libc.UintptrFromInt32(0)
			XTcl_AppendObjToObj(tls, err, cmdObj)
			XTcl_AppendToObj(tls, err, __ccgo_ts+47503, int64(-int32(1)))
			XTcl_AppendObjToObj(tls, err, XTcl_GetObjResult(tls, interp))
			XTcl_SetObjResult(tls, interp, err)
			_objPtr3 = *(*uintptr)(unsafe.Pointer(bp + 40))
			v14 = _objPtr3
			v13 = *(*TTcl_Size)(unsafe.Pointer(v14))
			*(*TTcl_Size)(unsafe.Pointer(v14))--
			if v13 <= int64(1) {
				XTclFreeObj(tls, _objPtr3)
			}
			goto error
		}
		methods |= int32(1) << *(*int32)(unsafe.Pointer(bp + 32))
		*(*TTcl_Size)(unsafe.Pointer(bp + 16))--
	}
	_objPtr4 = *(*uintptr)(unsafe.Pointer(bp + 40))
	v16 = _objPtr4
	v15 = *(*TTcl_Size)(unsafe.Pointer(v16))
	*(*TTcl_Size)(unsafe.Pointer(v16))--
	if v15 <= int64(1) {
		XTclFreeObj(tls, _objPtr4)
	}
	if (libc.Int32FromInt32(1)<<int32(METH_INIT)|libc.Int32FromInt32(1)<<int32(METH_FINAL)|libc.Int32FromInt32(1)<<int32(METH_WATCH))&methods != libc.Int32FromInt32(1)<<int32(METH_INIT)|libc.Int32FromInt32(1)<<int32(METH_FINAL)|libc.Int32FromInt32(1)<<int32(METH_WATCH) {
		if (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes != 0 {
			v17 = (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes
		} else {
			v17 = XTcl_GetStringFromObj(tls, cmdObj, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+47526, libc.VaList(bp+64, v17)))
		goto error
	}
	if *(*int32)(unsafe.Pointer(bp))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 && !(methods&(libc.Int32FromInt32(1)<<int32(METH_READ)) != 0) {
		if (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes != 0 {
			v18 = (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes
		} else {
			v18 = XTcl_GetStringFromObj(tls, cmdObj, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+47582, libc.VaList(bp+64, v18)))
		goto error
	}
	if *(*int32)(unsafe.Pointer(bp))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 && !(methods&(libc.Int32FromInt32(1)<<int32(METH_WRITE)) != 0) {
		if (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes != 0 {
			v19 = (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes
		} else {
			v19 = XTcl_GetStringFromObj(tls, cmdObj, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+47622, libc.VaList(bp+64, v19)))
		goto error
	}
	if !(!(methods&(libc.Int32FromInt32(1)<<int32(METH_CGET)) != 0) || methods&(libc.Int32FromInt32(1)<<int32(METH_CGETALL)) != 0) {
		if (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes != 0 {
			v20 = (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes
		} else {
			v20 = XTcl_GetStringFromObj(tls, cmdObj, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+47663, libc.VaList(bp+64, v20)))
		goto error
	}
	if !(!(methods&(libc.Int32FromInt32(1)<<int32(METH_CGETALL)) != 0) || methods&(libc.Int32FromInt32(1)<<int32(METH_CGET)) != 0) {
		if (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes != 0 {
			v21 = (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes
		} else {
			v21 = XTcl_GetStringFromObj(tls, cmdObj, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+47715, libc.VaList(bp+64, v21)))
		goto error
	}
	XTcl_ResetResult(tls, interp)
	/*
	 * Everything is fine now.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(rcId)).Fbytes != 0 {
		v22 = (*TTcl_Obj)(unsafe.Pointer(rcId)).Fbytes
	} else {
		v22 = XTcl_GetStringFromObj(tls, rcId, libc.UintptrFromInt32(0))
	}
	chan1 = XTcl_CreateChannel(tls, uintptr(unsafe.Pointer(&_reflectedChannelType)), v22, rcPtr, *(*int32)(unsafe.Pointer(bp)))
	(*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fchan1 = chan1
	XTclChannelPreserve(tls, chan1)
	chanPtr = chan1
	if methods&(libc.Int32FromInt32(1)<<int32(METH_BLOCKING)|libc.Int32FromInt32(1)<<int32(METH_SEEK)|libc.Int32FromInt32(1)<<int32(METH_CONFIGURE)|libc.Int32FromInt32(1)<<int32(METH_CGET)|libc.Int32FromInt32(1)<<int32(METH_CGETALL)|libc.Int32FromInt32(1)<<int32(METH_TRUNCATE)) != libc.Int32FromInt32(1)<<int32(METH_BLOCKING)|libc.Int32FromInt32(1)<<int32(METH_SEEK)|libc.Int32FromInt32(1)<<int32(METH_CONFIGURE)|libc.Int32FromInt32(1)<<int32(METH_CGET)|libc.Int32FromInt32(1)<<int32(METH_CGETALL)|libc.Int32FromInt32(1)<<int32(METH_TRUNCATE) {
		/*
		 * Some of the nullable methods are not supported. We clone the
		 * channel type, null the associated C functions, and use the result
		 * as the actual channel type.
		 */
		clonePtr = XTcl_Alloc(tls, uint64(136))
		libc.Xmemcpy(tls, clonePtr, uintptr(unsafe.Pointer(&_reflectedChannelType)), uint64(136))
		if !(methods&(libc.Int32FromInt32(1)<<int32(METH_CONFIGURE)) != 0) {
			(*TTcl_ChannelType)(unsafe.Pointer(clonePtr)).FsetOptionProc = libc.UintptrFromInt32(0)
		}
		if !(methods&(libc.Int32FromInt32(1)<<int32(METH_CGET)) != 0) && !(methods&(libc.Int32FromInt32(1)<<int32(METH_CGETALL)) != 0) {
			(*TTcl_ChannelType)(unsafe.Pointer(clonePtr)).FgetOptionProc = libc.UintptrFromInt32(0)
		}
		if !(methods&(libc.Int32FromInt32(1)<<int32(METH_BLOCKING)) != 0) {
			(*TTcl_ChannelType)(unsafe.Pointer(clonePtr)).FblockModeProc = libc.UintptrFromInt32(0)
		}
		if !(methods&(libc.Int32FromInt32(1)<<int32(METH_SEEK)) != 0) {
			(*TTcl_ChannelType)(unsafe.Pointer(clonePtr)).FwideSeekProc = libc.UintptrFromInt32(0)
		}
		if !(methods&(libc.Int32FromInt32(1)<<int32(METH_TRUNCATE)) != 0) {
			(*TTcl_ChannelType)(unsafe.Pointer(clonePtr)).FtruncateProc = libc.UintptrFromInt32(0)
		}
		(*TChannel)(unsafe.Pointer(chanPtr)).FtypePtr = clonePtr
	}
	/*
	 * Register the channel in the I/O system, and in our map for 'chan
	 * postevent'.
	 */
	XTcl_RegisterChannel(tls, interp, chan1)
	rcmPtr = _GetReflectedChannelMap(tls, interp)
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(rcmPtr)).FcreateProc})))(tls, rcmPtr, (*TChannelState1)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).Fstate)).FchannelName, bp+48)
	if !(*(*int32)(unsafe.Pointer(bp + 48)) != 0) && chanPtr != (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData {
		XTcl_Panic(tls, __ccgo_ts+47767, 0)
	}
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = chan1
	rcmPtr = _GetThreadReflectedChannelMap(tls)
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(rcmPtr)).FcreateProc})))(tls, rcmPtr, (*TChannelState1)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).Fstate)).FchannelName, bp+48)
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = chan1
	/*
	 * Return handle as result of command.
	 */
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, (*TChannelState1)(unsafe.Pointer((*TChannel)(unsafe.Pointer(chanPtr)).Fstate)).FchannelName, int64(-int32(1))))
	return TCL_OK
	goto error
error:
	;
	_objPtr5 = (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fname
	v24 = _objPtr5
	v23 = *(*TTcl_Size)(unsafe.Pointer(v24))
	*(*TTcl_Size)(unsafe.Pointer(v24))--
	if v23 <= int64(1) {
		XTclFreeObj(tls, _objPtr5)
	}
	_objPtr6 = (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fmethods
	v26 = _objPtr6
	v25 = *(*TTcl_Size)(unsafe.Pointer(v26))
	*(*TTcl_Size)(unsafe.Pointer(v26))--
	if v25 <= int64(1) {
		XTclFreeObj(tls, _objPtr6)
	}
	_objPtr7 = (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fcmd
	v28 = _objPtr7
	v27 = *(*TTcl_Size)(unsafe.Pointer(v28))
	*(*TTcl_Size)(unsafe.Pointer(v28))--
	if v27 <= int64(1) {
		XTclFreeObj(tls, _objPtr7)
	}
	XTclpFree(tls, rcPtr)
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * TclChanPostEventObjCmd --
 *
 *	This function is invoked to process the "chan postevent" Tcl command.
 *	See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Posts events to a reflected channel, invokes event handlers. The
 *	latter implies that arbitrary side effects are possible.
 *
 *----------------------------------------------------------------------
 */

type TReflectEvent = struct {
	Fheader TTcl_Event
	FrcPtr  uintptr
	Fevents int32
}

func _ReflectEventRun(tls *libc.TLS, ev uintptr, dummy773 int32) (r int32) {
	var e uintptr
	_ = e
	/* OWNER thread
	 *
	 * Note: When the channel is closed any pending events of this type are
	 * deleted. See ReflectClose() for the Tcl_DeleteEvents() calls
	 * accomplishing that.
	 */
	e = ev
	XTcl_NotifyChannel(tls, (*TReflectedChannel)(unsafe.Pointer((*TReflectEvent)(unsafe.Pointer(e)).FrcPtr)).Fchan1, (*TReflectEvent)(unsafe.Pointer(e)).Fevents)
	return int32(1)
}

func _ReflectEventDelete(tls *libc.TLS, ev uintptr, cd uintptr) (r int32) {
	var e uintptr
	_ = e
	/* OWNER thread
	 *
	 * Invoked by DeleteThreadReflectedChannelMap() and ReflectClose(). The
	 * latter ensures that no pending events of this type are run on an
	 * invalid channel.
	 */
	e = ev
	if (*TTcl_Event)(unsafe.Pointer(ev)).Fproc != __ccgo_fp(_ReflectEventRun) || cd != libc.UintptrFromInt32(0) && cd != (*TReflectEvent)(unsafe.Pointer(e)).FrcPtr {
		return 0
	}
	return int32(1)
}

func XTclChanPostEventObjCmd(tls *libc.TLS, dummy811 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var chan1 TTcl_Channel
	var chanId, chanTypePtr, ev, hPtr, rcPtr, rcmPtr, v1 uintptr
	var _ /* events at bp+0 */ int32
	_, _, _, _, _, _, _, _ = chan1, chanId, chanTypePtr, ev, hPtr, rcPtr, rcmPtr, v1 /* Entry in the above map */
	/*
	 * Number of arguments...
	 */
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+47812)
		return int32(TCL_ERROR)
	}
	/*
	 * First argument is a channel, a reflected channel, and the call of this
	 * command is done from the interp defining the channel handler cmd.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(1)*8)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(1)*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(1)*8)), libc.UintptrFromInt32(0))
	}
	chanId = v1
	rcmPtr = _GetReflectedChannelMap(tls, interp)
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(rcmPtr)).FfindProc})))(tls, rcmPtr, chanId)
	if hPtr == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+47830, libc.VaList(bp+16, chanId)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+43147, chanId, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Note that the search above subsumes several of the older checks,
	 * namely:
	 *
	 * (1) Does the channel handle refer to a reflected channel?
	 * (2) Is the post event issued from the interpreter holding the handler
	 *     of the reflected channel?
	 *
	 * A successful search answers yes to both. Because the map holds only
	 * handles of reflected channels, and only of such whose handler is
	 * defined in this interpreter.
	 *
	 * We keep the old checks for both, for paranoia, but abort now instead of
	 * throwing errors, as failure now means that our internal data structures
	 * have gone seriously haywire.
	 */
	chan1 = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
	chanTypePtr = XTcl_GetChannelType(tls, chan1)
	/*
	 * We use a function referenced by the channel type as our cookie to
	 * detect calls to non-reflecting channels. The channel type itself is not
	 * suitable, as it might not be the static definition in this file, but a
	 * clone thereof. And while we have reserved the name of the type nothing
	 * in the core checks against violation, so someone else might have
	 * created a channel type using our name, clashing with ourselves.
	 */
	if (*TTcl_ChannelType)(unsafe.Pointer(chanTypePtr)).FwatchProc != __ccgo_fp(_ReflectWatch) {
		XTcl_Panic(tls, __ccgo_ts+47872, 0)
	}
	rcPtr = XTcl_GetChannelInstanceData(tls, chan1)
	if (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterp != interp {
		XTcl_Panic(tls, __ccgo_ts+47931, 0)
	}
	/*
	 * Second argument is a list of events. Allowed entries are "read",
	 * "write". Expect at least one list element. Abbreviations are ok.
	 */
	if _EncodeEventMask(tls, interp, __ccgo_ts+47034, *(*uintptr)(unsafe.Pointer(objv + uintptr(2)*8)), bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if *(*int32)(unsafe.Pointer(bp)) == 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+48008, int64(-int32(1))))
		return int32(TCL_ERROR)
	}
	/*
	 * Check that the channel is actually interested in the provided events.
	 */
	if *(*int32)(unsafe.Pointer(bp)) & ^(*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterest != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+48033, libc.VaList(bp+16, chanId)))
		return int32(TCL_ERROR)
	}
	/*
	 * We have the channel and the events to post.
	 */
	if (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fowner == (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fthread {
		XTcl_NotifyChannel(tls, chan1, *(*int32)(unsafe.Pointer(bp)))
	} else {
		ev = XTcl_Alloc(tls, uint64(32))
		(*TReflectEvent)(unsafe.Pointer(ev)).Fheader.Fproc = __ccgo_fp(_ReflectEventRun)
		(*TReflectEvent)(unsafe.Pointer(ev)).Fevents = *(*int32)(unsafe.Pointer(bp))
		(*TReflectEvent)(unsafe.Pointer(ev)).FrcPtr = rcPtr
		/*
		 * We are not preserving the structure here. When the channel is
		 * closed any pending events are deleted, see ReflectClose(), and
		 * ReflectEventDelete(). Trying to preserve and later release when the
		 * event is run may generate a situation where the channel structure
		 * is deleted but not our structure, crashing in
		 * FreeReflectedChannel().
		 *
		 * Force creation of the RCM, for proper cleanup on thread teardown.
		 * The teardown of unprocessed events is currently coupled to the
		 * thread reflected channel map
		 */
		_GetThreadReflectedChannelMap(tls)
		/*
		 * XXX Race condition !!
		 * XXX The destination thread may not exist anymore already.
		 * XXX (Delayed postevent executed after channel got removed).
		 * XXX Can we detect this ? (check the validity of the owner threadid ?)
		 * XXX Actually, in that case the channel should be dead also !
		 */
		XTcl_ThreadQueueEvent(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fowner, ev, int32(TCL_QUEUE_TAIL)|int32(TCL_QUEUE_ALERT_IF_EMPTY))
	}
	/*
	 * Squash interp results left by the event script.
	 */
	XTcl_ResetResult(tls, interp)
	return TCL_OK
}

/*
 * Channel error message marshalling utilities.
 */

func _MarshallError(tls *libc.TLS, interp uintptr) (r uintptr) {
	var returnOpt uintptr
	_ = returnOpt
	/*
	 * Capture the result status of the interpreter into a string. => List of
	 * options and values, followed by the error message. The result has
	 * refCount 0.
	 */
	returnOpt = XTcl_GetReturnOptions(tls, interp, int32(TCL_ERROR))
	/*
	 * => returnOpt.refCount == 0. We can append directly.
	 */
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), returnOpt, XTcl_GetObjResult(tls, interp))
	return returnOpt
}

func _UnmarshallErrorResult(tls *libc.TLS, interp uintptr, msgObj uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var explicitResult, v1 int32
	var numOptions TTcl_Size
	var v2, v3 int64
	var _ /* lc at bp+0 */ TTcl_Size
	var _ /* lv at bp+8 */ uintptr
	_, _, _, _, _ = explicitResult, numOptions, v1, v2, v3
	/*
	 * Process the caught message.
	 *
	 * Syntax = (option value)... ?message?
	 *
	 * Bad syntax causes a panic. This is OK because the other side uses
	 * Tcl_GetReturnOptions and list construction functions to marshal the
	 * information; if we panic here, something has gone badly wrong already.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(msgObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(msgObj + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(msgObj + 32))).Fptr2)).FspanStart
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(msgObj + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(msgObj + 32))).Fptr1 + 40 + uintptr(v2)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(msgObj + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(msgObj + 32))).Fptr2)).FspanLength
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(msgObj + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v3
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjGetElements(tls, interp, msgObj, bp, bp+8)
	}
	if v1 != TCL_OK {
		XTcl_Panic(tls, __ccgo_ts+48088, 0)
	}
	if interp == libc.UintptrFromInt32(0) {
		return
	}
	explicitResult = int32(*(*TTcl_Size)(unsafe.Pointer(bp)) & int64(1)) /* Odd number of values? */
	numOptions = *(*TTcl_Size)(unsafe.Pointer(bp)) - int64(explicitResult)
	if explicitResult != 0 {
		XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp))-int64(1))*8)))
	}
	XTcl_SetReturnOptions(tls, interp, XTcl_NewListObj(tls, numOptions, *(*uintptr)(unsafe.Pointer(bp + 8))))
	*(*int32)(unsafe.Pointer(interp + 368)) &= ^libc.Int32FromInt32(ERR_ALREADY_LOGGED)
}

func XTclChanCaughtErrorBypass(tls *libc.TLS, interp uintptr, chan1 TTcl_Channel) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, _objPtr1, _objPtr2, msgObj, v2, v4, v6 uintptr
	var v1, v3, v5 TTcl_Size
	var _ /* chanMsgObj at bp+0 */ uintptr
	var _ /* interpMsgObj at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, msgObj, v1, v2, v3, v4, v5, v6
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(bp + 8)) = libc.UintptrFromInt32(0)
	msgObj = libc.UintptrFromInt32(0)
	/*
	 * Get a bypassed error message from channel and/or interpreter, save the
	 * reference, then kill the returned objects, if there were any. If there
	 * are messages in both the channel has preference.
	 */
	if chan1 == libc.UintptrFromInt32(0) && interp == libc.UintptrFromInt32(0) {
		return 0
	}
	if chan1 != libc.UintptrFromInt32(0) {
		XTcl_GetChannelError(tls, chan1, bp)
	}
	if interp != libc.UintptrFromInt32(0) {
		XTcl_GetChannelErrorInterp(tls, interp, bp+8)
	}
	if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
		msgObj = *(*uintptr)(unsafe.Pointer(bp))
	} else {
		if *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) {
			msgObj = *(*uintptr)(unsafe.Pointer(bp + 8))
		}
	}
	if msgObj != libc.UintptrFromInt32(0) {
		(*TTcl_Obj)(unsafe.Pointer(msgObj)).FrefCount++
	}
	if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
		_objPtr = *(*uintptr)(unsafe.Pointer(bp))
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	if *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) {
		_objPtr1 = *(*uintptr)(unsafe.Pointer(bp + 8))
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
	/*
	 * No message returned, nothing caught.
	 */
	if msgObj == libc.UintptrFromInt32(0) {
		return 0
	}
	_UnmarshallErrorResult(tls, interp, msgObj)
	_objPtr2 = msgObj
	v6 = _objPtr2
	v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
	*(*TTcl_Size)(unsafe.Pointer(v6))--
	if v5 <= int64(1) {
		XTclFreeObj(tls, _objPtr2)
	}
	return int32(1)
}

/*
 * Driver functions. ================================================
 */

/*
 *----------------------------------------------------------------------
 *
 * ReflectClose --
 *
 *	This function is invoked when the channel is closed, to delete the
 *	driver-specific instance data.
 *
 * Results:
 *	A Posix error.
 *
 * Side effects:
 *	Releases memory. Arbitrary, as it calls upon a script.
 *
 *----------------------------------------------------------------------
 */

func _ReflectClose(tls *libc.TLS, clientData uintptr, interp uintptr, flags int32) (r int32) {
	bp := tls.Alloc(96)
	defer tls.Free(96)
	var _objPtr, hPtr, rcPtr, rcmPtr, tctPtr, v2 uintptr
	var result, v3 int32
	var v1 TTcl_Size
	var _ /* p at bp+48 */ TForwardParam
	var _ /* p at bp+8 */ TForwardParam
	var _ /* resObj at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _ = _objPtr, hPtr, rcPtr, rcmPtr, result, tctPtr, v1, v2, v3
	rcPtr = clientData
	if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
		return int32(EINVAL)
	}
	if XTclInThreadExit(tls) != 0 {
		/*
		 * This call comes from TclFinalizeIOSystem. There are no
		 * interpreters, and therefore we cannot call upon the handler command
		 * anymore. Threading is irrelevant as well. Simply clean up all
		 * the C level data structures and leave the Tcl level to the other
		 * finalization functions.
		 */
		/*
		 * THREADED => Forward this to the origin thread
		 *
		 * Note: DeleteThreadReflectedChannelMap() is the thread exit handler
		 * for the origin thread. Use this to clean up the structure? Except
		 * if lost?
		 */
		if (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fthread != XTcl_GetCurrentThread(tls) {
			_ForwardOpToHandlerThread(tls, rcPtr, int32(ForwardedClose), bp+8)
			result = (*(*TForwardParam)(unsafe.Pointer(bp + 8))).Fbase.Fcode
			/*
			 * Now squash the pending reflection events for this channel.
			 */
			XTcl_DeleteEvents(tls, __ccgo_fp(_ReflectEventDelete), rcPtr)
			if result != TCL_OK {
				if (*TForwardParam)(unsafe.Pointer(bp+8)).Fbase.FmustFree != 0 {
					XTclpFree(tls, (*TForwardParam)(unsafe.Pointer(bp+8)).Fbase.FmsgStr)
				}
			}
		}
		tctPtr = (*TChannel)(unsafe.Pointer((*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fchan1)).FtypePtr
		if tctPtr != 0 && tctPtr != uintptr(unsafe.Pointer(&_reflectedChannelType)) {
			XTclpFree(tls, tctPtr)
			(*TChannel)(unsafe.Pointer((*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fchan1)).FtypePtr = libc.UintptrFromInt32(0)
		}
		XTcl_EventuallyFree(tls, rcPtr, __ccgo_fp(_FreeReflectedChannel))
		return EOK
	}
	/*
	 * Are we in the correct thread?
	 */
	if (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fthread != XTcl_GetCurrentThread(tls) {
		_ForwardOpToHandlerThread(tls, rcPtr, int32(ForwardedClose), bp+48)
		result = (*(*TForwardParam)(unsafe.Pointer(bp + 48))).Fbase.Fcode
		/*
		 * Now squash the pending reflection events for this channel.
		 */
		XTcl_DeleteEvents(tls, __ccgo_fp(_ReflectEventDelete), rcPtr)
		if result != TCL_OK {
			if interp != libc.UintptrFromInt32(0) {
				XTcl_SetChannelErrorInterp(tls, interp, XTcl_NewStringObj(tls, (*TForwardParam)(unsafe.Pointer(bp+48)).Fbase.FmsgStr, int64(-int32(1))))
			}
			if (*TForwardParam)(unsafe.Pointer(bp+48)).Fbase.FmustFree != 0 {
				XTclpFree(tls, (*TForwardParam)(unsafe.Pointer(bp+48)).Fbase.FmsgStr)
			}
		}
	} else {
		result = _InvokeTclMethod(tls, rcPtr, int32(METH_FINAL), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), bp)
		if result != TCL_OK && interp != libc.UintptrFromInt32(0) {
			XTcl_SetChannelErrorInterp(tls, interp, *(*uintptr)(unsafe.Pointer(bp)))
		}
		_objPtr = *(*uintptr)(unsafe.Pointer(bp))
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		} /* Remove reference we held from the
		 * invoke */
		/*
		 * Remove the channel from the map before releasing the memory, to
		 * prevent future accesses (like by 'postevent') from finding and
		 * dereferencing a dangling pointer.
		 *
		 * NOTE: The channel may not be in the map. This is ok, that happens
		 * when the channel was created in a different interpreter and/or
		 * thread and then was moved here.
		 *
		 * NOTE: The channel may have been removed from the map already via
		 * the per-interp DeleteReflectedChannelMap exit-handler.
		 */
		if !((*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fdead != 0) {
			rcmPtr = _GetReflectedChannelMap(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterp)
			hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(rcmPtr)).FfindProc})))(tls, rcmPtr, XTcl_GetChannelName(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fchan1))
			if hPtr != 0 {
				XTcl_DeleteHashEntry(tls, hPtr)
			}
		}
		rcmPtr = _GetThreadReflectedChannelMap(tls)
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(rcmPtr)).FfindProc})))(tls, rcmPtr, XTcl_GetChannelName(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fchan1))
		if hPtr != 0 {
			XTcl_DeleteHashEntry(tls, hPtr)
		}
	}
	tctPtr = (*TChannel)(unsafe.Pointer((*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fchan1)).FtypePtr
	if tctPtr != 0 && tctPtr != uintptr(unsafe.Pointer(&_reflectedChannelType)) {
		XTclpFree(tls, tctPtr)
		(*TChannel)(unsafe.Pointer((*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fchan1)).FtypePtr = libc.UintptrFromInt32(0)
	}
	XTcl_EventuallyFree(tls, rcPtr, __ccgo_fp(_FreeReflectedChannel))
	if result == TCL_OK {
		v3 = EOK
	} else {
		v3 = int32(EINVAL)
	}
	return v3
}

/*
 *----------------------------------------------------------------------
 *
 * ReflectInput --
 *
 *	This function is invoked when more data is requested from the channel.
 *
 * Results:
 *	The number of bytes read.
 *
 * Side effects:
 *	Allocates memory. Arbitrary, as it calls upon a script.
 *
 *----------------------------------------------------------------------
 */

func _ReflectInput(tls *libc.TLS, clientData uintptr, buf uintptr, toRead int32, errorCodePtr uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var _objPtr, _objPtr1, bytev, cachePtr, rcPtr, toReadObj, v3, v5 uintptr
	var code int32
	var v1 bool
	var v2, v4 TTcl_Size
	var _ /* bytec at bp+0 */ TTcl_Size
	var _ /* p at bp+16 */ TForwardParam
	var _ /* resObj at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, bytev, cachePtr, code, rcPtr, toReadObj, v1, v2, v3, v4, v5
	rcPtr = clientData
	*(*TTcl_Size)(unsafe.Pointer(bp)) = 0 /* Result data for 'read' */
	/*
	 * Are we in the correct thread?
	 */
	if (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fthread != XTcl_GetCurrentThread(tls) {
		(*(*TForwardParamInput)(unsafe.Pointer(bp + 16))).Fbuf = buf
		(*(*TForwardParamInput)(unsafe.Pointer(bp + 16))).FtoRead = int64(toRead)
		_ForwardOpToHandlerThread(tls, rcPtr, int32(ForwardedInput), bp+16)
		if (*(*TForwardParam)(unsafe.Pointer(bp + 16))).Fbase.Fcode != TCL_OK {
			if (*(*TForwardParam)(unsafe.Pointer(bp + 16))).Fbase.Fcode < 0 {
				/*
				 * No error message, this is an errno signal.
				 */
				*(*int32)(unsafe.Pointer(errorCodePtr)) = -(*(*TForwardParam)(unsafe.Pointer(bp + 16))).Fbase.Fcode
			} else {
				XTcl_SetChannelError(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fchan1, XTcl_NewStringObj(tls, (*TForwardParam)(unsafe.Pointer(bp+16)).Fbase.FmsgStr, int64(-int32(1))))
				if (*TForwardParam)(unsafe.Pointer(bp+16)).Fbase.FmustFree != 0 {
					XTclpFree(tls, (*TForwardParam)(unsafe.Pointer(bp+16)).Fbase.FmsgStr)
				}
				*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(EINVAL)
			}
			(*(*TForwardParamInput)(unsafe.Pointer(bp + 16))).FtoRead = int64(-libc.Int32FromInt32(1))
		} else {
			*(*int32)(unsafe.Pointer(errorCodePtr)) = EOK
		}
		return int32((*(*TForwardParamInput)(unsafe.Pointer(bp + 16))).FtoRead)
	}
	/* ASSERT: rcPtr->method & FLAG(METH_READ) */
	/* ASSERT: rcPtr->mode & TCL_READABLE */
	XTcl_Preserve(tls, rcPtr)
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		toReadObj = XTclThreadAllocObj(tls)
	} else {
		toReadObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(toReadObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(toReadObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(toReadObj)).Fbytes = libc.UintptrFromInt32(0)
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(toReadObj)).FinternalRep)) = int64(toRead)
	(*TTcl_Obj)(unsafe.Pointer(toReadObj)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	(*TTcl_Obj)(unsafe.Pointer(toReadObj)).FrefCount++
	if _InvokeTclMethod(tls, rcPtr, int32(METH_READ), toReadObj, libc.UintptrFromInt32(0), bp+8) != TCL_OK {
		code = _ErrnoReturn(tls, rcPtr, *(*uintptr)(unsafe.Pointer(bp + 8)))
		if code < 0 {
			*(*int32)(unsafe.Pointer(errorCodePtr)) = -code
			goto error
		}
		XTcl_SetChannelError(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fchan1, *(*uintptr)(unsafe.Pointer(bp + 8)))
		goto invalid
	}
	bytev = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 8)), bp)
	if bytev == libc.UintptrFromInt32(0) {
		XTcl_SetChannelError(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fchan1, XTcl_NewStringObj(tls, _msg_read_nonbyte, int64(-int32(1))))
		goto invalid
	} else {
		if int64(toRead) < *(*TTcl_Size)(unsafe.Pointer(bp)) {
			XTcl_SetChannelError(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fchan1, XTcl_NewStringObj(tls, _msg_read_toomuch, int64(-int32(1))))
			goto invalid
		}
	}
	*(*int32)(unsafe.Pointer(errorCodePtr)) = EOK
	if *(*TTcl_Size)(unsafe.Pointer(bp)) > 0 {
		libc.Xmemcpy(tls, buf, bytev, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))))
	}
	goto stop
stop:
	;
	_objPtr = toReadObj
	v3 = _objPtr
	v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
	*(*TTcl_Size)(unsafe.Pointer(v3))--
	if v2 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	_objPtr1 = *(*uintptr)(unsafe.Pointer(bp + 8))
	v5 = _objPtr1
	v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
	*(*TTcl_Size)(unsafe.Pointer(v5))--
	if v4 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	} /* Remove reference held from invoke */
	XTcl_Release(tls, rcPtr)
	return int32(*(*TTcl_Size)(unsafe.Pointer(bp)))
	goto invalid
invalid:
	;
	*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(EINVAL)
	goto error
error:
	;
	*(*TTcl_Size)(unsafe.Pointer(bp)) = int64(-int32(1))
	goto stop
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * ReflectOutput --
 *
 *	This function is invoked when data is writen to the channel.
 *
 * Results:
 *	The number of bytes actually written.
 *
 * Side effects:
 *	Allocates memory. Arbitrary, as it calls upon a script.
 *
 *----------------------------------------------------------------------
 */

func _ReflectOutput(tls *libc.TLS, clientData uintptr, buf uintptr, toWrite int32, errorCodePtr uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var _objPtr, _objPtr1, bufObj, rcPtr, v2, v4 uintptr
	var code int32
	var v1, v3 TTcl_Size
	var _ /* p at bp+16 */ TForwardParam
	var _ /* resObj at bp+0 */ uintptr
	var _ /* written at bp+8 */ int32
	_, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, bufObj, code, rcPtr, v1, v2, v3, v4
	rcPtr = clientData
	/*
	 * Are we in the correct thread?
	 */
	if (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fthread != XTcl_GetCurrentThread(tls) {
		(*(*TForwardParamOutput)(unsafe.Pointer(bp + 16))).Fbuf = buf
		(*(*TForwardParamOutput)(unsafe.Pointer(bp + 16))).FtoWrite = int64(toWrite)
		_ForwardOpToHandlerThread(tls, rcPtr, int32(ForwardedOutput), bp+16)
		if (*(*TForwardParam)(unsafe.Pointer(bp + 16))).Fbase.Fcode != TCL_OK {
			if (*(*TForwardParam)(unsafe.Pointer(bp + 16))).Fbase.Fcode < 0 {
				/*
				 * No error message, this is an errno signal.
				 */
				*(*int32)(unsafe.Pointer(errorCodePtr)) = -(*(*TForwardParam)(unsafe.Pointer(bp + 16))).Fbase.Fcode
			} else {
				XTcl_SetChannelError(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fchan1, XTcl_NewStringObj(tls, (*TForwardParam)(unsafe.Pointer(bp+16)).Fbase.FmsgStr, int64(-int32(1))))
				if (*TForwardParam)(unsafe.Pointer(bp+16)).Fbase.FmustFree != 0 {
					XTclpFree(tls, (*TForwardParam)(unsafe.Pointer(bp+16)).Fbase.FmsgStr)
				}
				*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(EINVAL)
			}
			(*(*TForwardParamOutput)(unsafe.Pointer(bp + 16))).FtoWrite = int64(-int32(1))
		} else {
			*(*int32)(unsafe.Pointer(errorCodePtr)) = EOK
		}
		return int32((*(*TForwardParamOutput)(unsafe.Pointer(bp + 16))).FtoWrite)
	}
	/* ASSERT: rcPtr->method & FLAG(METH_WRITE) */
	/* ASSERT: rcPtr->mode & TCL_WRITABLE */
	XTcl_Preserve(tls, rcPtr)
	XTcl_Preserve(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterp)
	bufObj = XTcl_NewByteArrayObj(tls, buf, int64(toWrite))
	(*TTcl_Obj)(unsafe.Pointer(bufObj)).FrefCount++
	if _InvokeTclMethod(tls, rcPtr, int32(METH_WRITE), bufObj, libc.UintptrFromInt32(0), bp) != TCL_OK {
		code = _ErrnoReturn(tls, rcPtr, *(*uintptr)(unsafe.Pointer(bp)))
		if code < 0 {
			*(*int32)(unsafe.Pointer(errorCodePtr)) = -code
			goto error
		}
		XTcl_SetChannelError(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fchan1, *(*uintptr)(unsafe.Pointer(bp)))
		goto invalid
	}
	if XTcl_InterpDeleted(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterp) != 0 {
		/*
		 * The interp was destroyed during InvokeTclMethod().
		 */
		XTcl_SetChannelError(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fchan1, XTcl_NewStringObj(tls, _msg_send_dstlost, int64(-int32(1))))
		goto invalid
	}
	if XTcl_GetIntFromObj(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterp, *(*uintptr)(unsafe.Pointer(bp)), bp+8) != TCL_OK {
		XTcl_SetChannelError(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fchan1, _MarshallError(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterp))
		goto invalid
	}
	if *(*int32)(unsafe.Pointer(bp + 8)) == 0 && toWrite > 0 {
		/*
		 * The handler claims to have written nothing of what it was given.
		 * That is bad.
		 */
		XTcl_SetChannelError(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fchan1, XTcl_NewStringObj(tls, _msg_write_nothing, int64(-int32(1))))
		goto invalid
	}
	if toWrite < *(*int32)(unsafe.Pointer(bp + 8)) {
		/*
		 * The handler claims to have written more than it was given. That is
		 * bad. Note that the I/O core would crash if we were to return this
		 * information, trying to write -nnn bytes in the next iteration.
		 */
		XTcl_SetChannelError(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fchan1, XTcl_NewStringObj(tls, _msg_write_toomuch, int64(-int32(1))))
		goto invalid
	}
	*(*int32)(unsafe.Pointer(errorCodePtr)) = EOK
	goto stop
stop:
	;
	_objPtr = bufObj
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	_objPtr1 = *(*uintptr)(unsafe.Pointer(bp))
	v4 = _objPtr1
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	if v3 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	} /* Remove reference held from invoke */
	XTcl_Release(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterp)
	XTcl_Release(tls, rcPtr)
	return *(*int32)(unsafe.Pointer(bp + 8))
	goto invalid
invalid:
	;
	*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(EINVAL)
	goto error
error:
	;
	*(*int32)(unsafe.Pointer(bp + 8)) = -int32(1)
	goto stop
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * ReflectSeekWide / ReflectSeek --
 *
 *	This function is invoked when the user wishes to seek on the channel.
 *
 * Results:
 *	The new location of the access point.
 *
 * Side effects:
 *	Allocates memory. Arbitrary, as it calls upon a script.
 *
 *----------------------------------------------------------------------
 */

func _ReflectSeekWide(tls *libc.TLS, clientData uintptr, offset int64, seekMode int32, errorCodePtr uintptr) (r int64) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var _objPtr, _objPtr1, _objPtr2, baseObj, cachePtr, offObj, rcPtr, v10, v2, v3, v6, v8 uintptr
	var v1 bool
	var v4 int32
	var v5, v7, v9 TTcl_Size
	var _ /* newLoc at bp+8 */ TTcl_WideInt
	var _ /* p at bp+16 */ TForwardParam
	var _ /* resObj at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, baseObj, cachePtr, offObj, rcPtr, v1, v10, v2, v3, v4, v5, v6, v7, v8, v9
	rcPtr = clientData
	/*
	 * Are we in the correct thread?
	 */
	if (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fthread != XTcl_GetCurrentThread(tls) {
		(*(*TForwardParamSeek)(unsafe.Pointer(bp + 16))).FseekMode = seekMode
		(*(*TForwardParamSeek)(unsafe.Pointer(bp + 16))).Foffset = offset
		_ForwardOpToHandlerThread(tls, rcPtr, int32(ForwardedSeek), bp+16)
		if (*(*TForwardParam)(unsafe.Pointer(bp + 16))).Fbase.Fcode != TCL_OK {
			XTcl_SetChannelError(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fchan1, XTcl_NewStringObj(tls, (*TForwardParam)(unsafe.Pointer(bp+16)).Fbase.FmsgStr, int64(-int32(1))))
			if (*TForwardParam)(unsafe.Pointer(bp+16)).Fbase.FmustFree != 0 {
				XTclpFree(tls, (*TForwardParam)(unsafe.Pointer(bp+16)).Fbase.FmsgStr)
			}
			*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(EINVAL)
			(*(*TForwardParamSeek)(unsafe.Pointer(bp + 16))).Foffset = int64(-int32(1))
		} else {
			*(*int32)(unsafe.Pointer(errorCodePtr)) = EOK
		}
		return (*(*TForwardParamSeek)(unsafe.Pointer(bp + 16))).Foffset
	}
	/* ASSERT: rcPtr->method & FLAG(METH_SEEK) */
	XTcl_Preserve(tls, rcPtr)
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		offObj = XTclThreadAllocObj(tls)
	} else {
		offObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(offObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(offObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(offObj)).Fbytes = libc.UintptrFromInt32(0)
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(offObj)).FinternalRep)) = offset
	(*TTcl_Obj)(unsafe.Pointer(offObj)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	if seekMode == 0 {
		v2 = __ccgo_ts + 45799
	} else {
		if seekMode == int32(1) {
			v3 = __ccgo_ts + 11670
		} else {
			v3 = __ccgo_ts + 21833
		}
		v2 = v3
	}
	baseObj = XTcl_NewStringObj(tls, v2, int64(-int32(1)))
	(*TTcl_Obj)(unsafe.Pointer(offObj)).FrefCount++
	(*TTcl_Obj)(unsafe.Pointer(baseObj)).FrefCount++
	if _InvokeTclMethod(tls, rcPtr, int32(METH_SEEK), offObj, baseObj, bp) != TCL_OK {
		XTcl_SetChannelError(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fchan1, *(*uintptr)(unsafe.Pointer(bp)))
		goto invalid
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FinternalRep))
		v4 = libc.Int32FromInt32(TCL_OK)
	} else {
		v4 = XTcl_GetWideIntFromObj(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterp, *(*uintptr)(unsafe.Pointer(bp)), bp+8)
	}
	if v4 != TCL_OK {
		XTcl_SetChannelError(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fchan1, _MarshallError(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterp))
		goto invalid
	}
	if *(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) < 0 {
		XTcl_SetChannelError(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fchan1, XTcl_NewStringObj(tls, _msg_seek_beforestart, int64(-int32(1))))
		goto invalid
	}
	*(*int32)(unsafe.Pointer(errorCodePtr)) = EOK
	goto stop
stop:
	;
	_objPtr = offObj
	v6 = _objPtr
	v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
	*(*TTcl_Size)(unsafe.Pointer(v6))--
	if v5 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	_objPtr1 = baseObj
	v8 = _objPtr1
	v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
	*(*TTcl_Size)(unsafe.Pointer(v8))--
	if v7 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	_objPtr2 = *(*uintptr)(unsafe.Pointer(bp))
	v10 = _objPtr2
	v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
	*(*TTcl_Size)(unsafe.Pointer(v10))--
	if v9 <= int64(1) {
		XTclFreeObj(tls, _objPtr2)
	} /* Remove reference held from invoke */
	XTcl_Release(tls, rcPtr)
	return *(*TTcl_WideInt)(unsafe.Pointer(bp + 8))
	goto invalid
invalid:
	;
	*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(EINVAL)
	*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) = int64(-int32(1))
	goto stop
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * ReflectWatch --
 *
 *	This function is invoked to tell the channel what events the I/O
 *	system is interested in.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Allocates memory. Arbitrary, as it calls upon a script.
 *
 *----------------------------------------------------------------------
 */

func _ReflectWatch(tls *libc.TLS, clientData uintptr, mask int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var _objPtr, maskObj, rcPtr, v2 uintptr
	var v1 TTcl_Size
	var _ /* p at bp+0 */ TForwardParam
	_, _, _, _, _ = _objPtr, maskObj, rcPtr, v1, v2
	rcPtr = clientData
	/*
	 * We restrict the interest to what the channel can support. IOW there
	 * will never be write events for a channel which is not writable.
	 * Analoguously for read events and non-readable channels.
	 */
	mask &= (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fmode
	if mask == (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterest {
		/*
		 * Same old, same old, why should we do something?
		 */
		return
	}
	/*
	 * Are we in the correct thread?
	 */
	if (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fthread != XTcl_GetCurrentThread(tls) {
		(*(*TForwardParamWatch)(unsafe.Pointer(&*(*TForwardParam)(unsafe.Pointer(bp))))).Fmask = mask
		_ForwardOpToHandlerThread(tls, rcPtr, int32(ForwardedWatch), bp)
		/*
		 * Any failure from the forward is ignored. We have no place to put
		 * this.
		 */
		return
	}
	XTcl_Preserve(tls, rcPtr)
	(*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterest = mask
	maskObj = _DecodeEventMask(tls, mask)
	/* assert maskObj.refCount == 1 */
	_InvokeTclMethod(tls, rcPtr, int32(METH_WATCH), maskObj, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	_objPtr = maskObj
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	XTcl_Release(tls, rcPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * ReflectBlock --
 *
 *	This function is invoked to tell the channel which blocking behaviour
 *	is required of it.
 *
 * Results:
 *	A Posix error number.
 *
 * Side effects:
 *	Allocates memory. Arbitrary, as it calls upon a script.
 *
 *----------------------------------------------------------------------
 */

func _ReflectBlock(tls *libc.TLS, clientData uintptr, nonblocking int32) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var _objPtr, _objPtr1, blockObj, rcPtr, v2, v4 uintptr
	var errorNum int32
	var v1, v3 TTcl_Size
	var _ /* p at bp+8 */ TForwardParam
	var _ /* resObj at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, blockObj, errorNum, rcPtr, v1, v2, v3, v4
	rcPtr = clientData /* Result data for 'blocking' */
	/*
	 * Are we in the correct thread?
	 */
	if (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fthread != XTcl_GetCurrentThread(tls) {
		(*(*TForwardParamBlock)(unsafe.Pointer(&*(*TForwardParam)(unsafe.Pointer(bp + 8))))).Fnonblocking = nonblocking
		_ForwardOpToHandlerThread(tls, rcPtr, int32(ForwardedBlock), bp+8)
		if (*(*TForwardParam)(unsafe.Pointer(bp + 8))).Fbase.Fcode != TCL_OK {
			XTcl_SetChannelError(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fchan1, XTcl_NewStringObj(tls, (*TForwardParam)(unsafe.Pointer(bp+8)).Fbase.FmsgStr, int64(-int32(1))))
			if (*TForwardParam)(unsafe.Pointer(bp+8)).Fbase.FmustFree != 0 {
				XTclpFree(tls, (*TForwardParam)(unsafe.Pointer(bp+8)).Fbase.FmsgStr)
			}
			return int32(EINVAL)
		}
		return EOK
	}
	blockObj = XTcl_NewWideIntObj(tls, libc.BoolInt64(libc.BoolInt32(!(nonblocking != 0)) != 0))
	(*TTcl_Obj)(unsafe.Pointer(blockObj)).FrefCount++
	XTcl_Preserve(tls, rcPtr)
	if _InvokeTclMethod(tls, rcPtr, int32(METH_BLOCKING), blockObj, libc.UintptrFromInt32(0), bp) != TCL_OK {
		XTcl_SetChannelError(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fchan1, *(*uintptr)(unsafe.Pointer(bp)))
		errorNum = int32(EINVAL)
	} else {
		errorNum = EOK
	}
	_objPtr = blockObj
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	_objPtr1 = *(*uintptr)(unsafe.Pointer(bp))
	v4 = _objPtr1
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	if v3 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	} /* Remove reference held from invoke */
	XTcl_Release(tls, rcPtr)
	return errorNum
}

/*
 *----------------------------------------------------------------------
 *
 * ReflectThread --
 *
 *	This function is invoked to tell the channel about thread movements.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Allocates memory. Arbitrary, as it calls upon a script.
 *
 *----------------------------------------------------------------------
 */

func _ReflectThread(tls *libc.TLS, clientData uintptr, action int32) {
	var rcPtr uintptr
	_ = rcPtr
	rcPtr = clientData
	switch action {
	case TCL_CHANNEL_THREAD_INSERT:
		(*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fowner = XTcl_GetCurrentThread(tls)
	case int32(TCL_CHANNEL_THREAD_REMOVE):
		(*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fowner = libc.UintptrFromInt32(0)
	default:
		XTcl_Panic(tls, __ccgo_ts+48142, 0)
		break
	}
}

/*
 *----------------------------------------------------------------------
 *
 * ReflectSetOption --
 *
 *	This function is invoked to configure a channel option.
 *
 * Results:
 *	A standard Tcl result code.
 *
 * Side effects:
 *	Arbitrary, as it calls upon a Tcl script.
 *
 *----------------------------------------------------------------------
 */

func _ReflectSetOption(tls *libc.TLS, clientData uintptr, interp uintptr, optionName uintptr, newValue uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* The new value */
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, err, optionObj, rcPtr, valueObj, v2, v4, v6, v8 uintptr
	var result int32
	var v1, v3, v5, v7 TTcl_Size
	var _ /* p at bp+8 */ TForwardParam
	var _ /* resObj at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, err, optionObj, rcPtr, result, valueObj, v1, v2, v3, v4, v5, v6, v7, v8
	rcPtr = clientData /* Result data for 'configure' */
	/*
	 * Are we in the correct thread?
	 */
	if (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fthread != XTcl_GetCurrentThread(tls) {
		(*(*TForwardParamSetOpt)(unsafe.Pointer(bp + 8))).Fname = optionName
		(*(*TForwardParamSetOpt)(unsafe.Pointer(bp + 8))).Fvalue = newValue
		_ForwardOpToHandlerThread(tls, rcPtr, int32(ForwardedSetOpt), bp+8)
		if (*(*TForwardParam)(unsafe.Pointer(bp + 8))).Fbase.Fcode != TCL_OK {
			err = XTcl_NewStringObj(tls, (*(*TForwardParam)(unsafe.Pointer(bp + 8))).Fbase.FmsgStr, int64(-int32(1)))
			_UnmarshallErrorResult(tls, interp, err)
			_objPtr = err
			v2 = _objPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if v1 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			if (*TForwardParam)(unsafe.Pointer(bp+8)).Fbase.FmustFree != 0 {
				XTclpFree(tls, (*TForwardParam)(unsafe.Pointer(bp+8)).Fbase.FmsgStr)
			}
		}
		return (*(*TForwardParam)(unsafe.Pointer(bp + 8))).Fbase.Fcode
	}
	XTcl_Preserve(tls, rcPtr)
	optionObj = XTcl_NewStringObj(tls, optionName, int64(-int32(1)))
	valueObj = XTcl_NewStringObj(tls, newValue, int64(-int32(1)))
	(*TTcl_Obj)(unsafe.Pointer(optionObj)).FrefCount++
	(*TTcl_Obj)(unsafe.Pointer(valueObj)).FrefCount++
	result = _InvokeTclMethod(tls, rcPtr, int32(METH_CONFIGURE), optionObj, valueObj, bp)
	if result != TCL_OK {
		_UnmarshallErrorResult(tls, interp, *(*uintptr)(unsafe.Pointer(bp)))
	}
	_objPtr1 = optionObj
	v4 = _objPtr1
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	if v3 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	_objPtr2 = valueObj
	v6 = _objPtr2
	v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
	*(*TTcl_Size)(unsafe.Pointer(v6))--
	if v5 <= int64(1) {
		XTclFreeObj(tls, _objPtr2)
	}
	_objPtr3 = *(*uintptr)(unsafe.Pointer(bp))
	v8 = _objPtr3
	v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
	*(*TTcl_Size)(unsafe.Pointer(v8))--
	if v7 <= int64(1) {
		XTclFreeObj(tls, _objPtr3)
	} /* Remove reference held from invoke */
	XTcl_Release(tls, rcPtr)
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * ReflectGetOption --
 *
 *	This function is invoked to retrieve all or a channel option.
 *
 * Results:
 *	A standard Tcl result code.
 *
 * Side effects:
 *	Arbitrary, as it calls upon a Tcl script.
 *
 *----------------------------------------------------------------------
 */

func _ReflectGetOption(tls *libc.TLS, clientData uintptr, interp uintptr, optionName uintptr, dsPtr uintptr) (r int32) {
	bp := tls.Alloc(96)
	defer tls.Free(96) /* String to place the result into */
	var _objPtr, _objPtr1, _objPtr2, err, optionObj, rcPtr, str, v11, v2, v6, v7, v9 uintptr
	var method TMethodName
	var opcode TForwardedOperation
	var result, v3 int32
	var v1, v10, v8 TTcl_Size
	var v4, v5 int64
	var _ /* len at bp+64 */ TTcl_Size
	var _ /* listc at bp+8 */ TTcl_Size
	var _ /* listv at bp+16 */ uintptr
	var _ /* p at bp+24 */ TForwardParam
	var _ /* resObj at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, err, method, opcode, optionObj, rcPtr, result, str, v1, v10, v11, v2, v3, v4, v5, v6, v7, v8, v9
	/*
	 * This code is special. It has regular passing of Tcl result, and errors.
	 * The bypass functions are not required.
	 */
	rcPtr = clientData
	result = TCL_OK
	/*
	 * Are we in the correct thread?
	 */
	if (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fthread != XTcl_GetCurrentThread(tls) {
		(*(*TForwardParamGetOpt)(unsafe.Pointer(bp + 24))).Fname = optionName
		(*(*TForwardParamGetOpt)(unsafe.Pointer(bp + 24))).Fvalue = dsPtr
		if optionName == libc.UintptrFromInt32(0) {
			opcode = int32(ForwardedGetOptAll)
		} else {
			opcode = int32(ForwardedGetOpt)
		}
		_ForwardOpToHandlerThread(tls, rcPtr, opcode, bp+24)
		if (*(*TForwardParam)(unsafe.Pointer(bp + 24))).Fbase.Fcode != TCL_OK {
			err = XTcl_NewStringObj(tls, (*(*TForwardParam)(unsafe.Pointer(bp + 24))).Fbase.FmsgStr, int64(-int32(1)))
			_UnmarshallErrorResult(tls, interp, err)
			_objPtr = err
			v2 = _objPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if v1 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			if (*TForwardParam)(unsafe.Pointer(bp+24)).Fbase.FmustFree != 0 {
				XTclpFree(tls, (*TForwardParam)(unsafe.Pointer(bp+24)).Fbase.FmsgStr)
			}
		}
		return (*(*TForwardParam)(unsafe.Pointer(bp + 24))).Fbase.Fcode
	}
	if optionName == libc.UintptrFromInt32(0) {
		/*
		 * Retrieve all options.
		 */
		method = int32(METH_CGETALL)
		optionObj = libc.UintptrFromInt32(0)
	} else {
		/*
		 * Retrieve the value of one option.
		 */
		method = int32(METH_CGET)
		optionObj = XTcl_NewStringObj(tls, optionName, int64(-int32(1)))
		(*TTcl_Obj)(unsafe.Pointer(optionObj)).FrefCount++
	}
	XTcl_Preserve(tls, rcPtr)
	if _InvokeTclMethod(tls, rcPtr, method, optionObj, libc.UintptrFromInt32(0), bp) != TCL_OK {
		_UnmarshallErrorResult(tls, interp, *(*uintptr)(unsafe.Pointer(bp)))
		goto error
	}
	/*
	 * The result has to go into the 'dsPtr' for propagation to the caller of
	 * the driver.
	 */
	if optionObj != libc.UintptrFromInt32(0) {
		XTclDStringAppendObj(tls, dsPtr, *(*uintptr)(unsafe.Pointer(bp)))
		goto ok
	}
	/*
	 * Extract the list and append each item as element.
	 */
	/*
	 * NOTE (4): If we extract the string rep we can assume a properly quoted
	 * string. Together with a separating space this way of simply appending
	 * the whole string rep might be faster. It also doesn't check if the
	 * result is a valid list. Nor that the list has an even number elements.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr2 != 0 {
			v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr2)).FspanStart
		} else {
			v4 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 16)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr1 + 40 + uintptr(v4)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr2 != 0 {
			v5 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr2)).FspanLength
		} else {
			v5 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v5
		v3 = libc.Int32FromInt32(TCL_OK)
	} else {
		v3 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), bp+8, bp+16)
	}
	if v3 != TCL_OK {
		goto error
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp + 8))%int64(2) == int64(1) {
		/*
		 * Odd number of elements is wrong.
		 */
		XTcl_ResetResult(tls, interp)
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(1) {
			v6 = __ccgo_ts + 1945
		} else {
			v6 = __ccgo_ts + 25879
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+48170, libc.VaList(bp+80, *(*TTcl_Size)(unsafe.Pointer(bp + 8)), v6)))
		goto error
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 64)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Flength
			v7 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes
		} else {
			v7 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+64)
		}
		str = v7
		if *(*TTcl_Size)(unsafe.Pointer(bp + 64)) != 0 {
			XTcl_DStringAppend(tls, dsPtr, __ccgo_ts+14830, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))
			XTcl_DStringAppend(tls, dsPtr, str, *(*TTcl_Size)(unsafe.Pointer(bp + 64)))
		}
		goto ok
	}
	goto ok
ok:
	;
	result = TCL_OK
	goto stop
stop:
	;
	if optionObj != 0 {
		_objPtr1 = optionObj
		v9 = _objPtr1
		v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
		*(*TTcl_Size)(unsafe.Pointer(v9))--
		if v8 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
	_objPtr2 = *(*uintptr)(unsafe.Pointer(bp))
	v11 = _objPtr2
	v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
	*(*TTcl_Size)(unsafe.Pointer(v11))--
	if v10 <= int64(1) {
		XTclFreeObj(tls, _objPtr2)
	} /* Remove reference held from invoke */
	XTcl_Release(tls, rcPtr)
	return result
	goto error
error:
	;
	result = int32(TCL_ERROR)
	goto stop
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * ReflectTruncate --
 *
 *	This function is invoked to truncate a channel's file size.
 *
 * Results:
 *	A standard Tcl result code.
 *
 * Side effects:
 *	Arbitrary, as it calls upon a Tcl script.
 *
 *----------------------------------------------------------------------
 */

func _ReflectTruncate(tls *libc.TLS, clientData uintptr, length int64) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Length to truncate to. */
	var _objPtr, _objPtr1, lenObj, rcPtr, v2, v4 uintptr
	var errorNum int32
	var v1, v3 TTcl_Size
	var _ /* p at bp+8 */ TForwardParam
	var _ /* resObj at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, errorNum, lenObj, rcPtr, v1, v2, v3, v4
	rcPtr = clientData /* Result for 'truncate' */
	/*
	 * Are we in the correct thread?
	 */
	if (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fthread != XTcl_GetCurrentThread(tls) {
		(*(*TForwardParamTruncate)(unsafe.Pointer(&*(*TForwardParam)(unsafe.Pointer(bp + 8))))).Flength = length
		_ForwardOpToHandlerThread(tls, rcPtr, int32(ForwardedTruncate), bp+8)
		if (*(*TForwardParam)(unsafe.Pointer(bp + 8))).Fbase.Fcode != TCL_OK {
			XTcl_SetChannelError(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fchan1, XTcl_NewStringObj(tls, (*TForwardParam)(unsafe.Pointer(bp+8)).Fbase.FmsgStr, int64(-int32(1))))
			if (*TForwardParam)(unsafe.Pointer(bp+8)).Fbase.FmustFree != 0 {
				XTclpFree(tls, (*TForwardParam)(unsafe.Pointer(bp+8)).Fbase.FmsgStr)
			}
			return int32(EINVAL)
		}
		return EOK
	}
	/* ASSERT: rcPtr->method & FLAG(METH_TRUNCATE) */
	XTcl_Preserve(tls, rcPtr)
	lenObj = XTcl_NewWideIntObj(tls, length)
	(*TTcl_Obj)(unsafe.Pointer(lenObj)).FrefCount++
	if _InvokeTclMethod(tls, rcPtr, int32(METH_TRUNCATE), lenObj, libc.UintptrFromInt32(0), bp) != TCL_OK {
		XTcl_SetChannelError(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fchan1, *(*uintptr)(unsafe.Pointer(bp)))
		errorNum = int32(EINVAL)
	} else {
		errorNum = EOK
	}
	_objPtr = lenObj
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	_objPtr1 = *(*uintptr)(unsafe.Pointer(bp))
	v4 = _objPtr1
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	if v3 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	} /* Remove reference held from invoke */
	XTcl_Release(tls, rcPtr)
	return errorNum
}

/*
 * Helpers. =========================================================
 */

/*
 *----------------------------------------------------------------------
 *
 * EncodeEventMask --
 *
 *	This function takes a list of event items and constructs the
 *	equivalent internal bitmask. The list may be empty but will usually
 *	contain at least one element. Valid elements are "read", "write", or
 *	any unique abbreviation of them. Note that the bitmask is not changed
 *	if problems are encountered.
 *
 * Results:
 *	A standard Tcl error code. A bitmask where TCL_READABLE and/or
 *	TCL_WRITABLE can be set.
 *
 * Side effects:
 *	May shimmer 'obj' to a list representation. May place an error message
 *	into the interp result.
 *
 *----------------------------------------------------------------------
 */

func _EncodeEventMask(tls *libc.TLS, interp uintptr, objName uintptr, obj uintptr, mask uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var events, v1 int32
	var v2, v3 int64
	var _ /* evIndex at bp+16 */ int32
	var _ /* listc at bp+0 */ TTcl_Size
	var _ /* listv at bp+8 */ uintptr
	_, _, _, _ = events, v1, v2, v3 /* Id of event for an element of the eventspec
	 * list. */
	if (*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(obj + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(obj + 32))).Fptr2)).FspanStart
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(obj + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(obj + 32))).Fptr1 + 40 + uintptr(v2)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(obj + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(obj + 32))).Fptr2)).FspanLength
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(obj + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v3
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjGetElements(tls, interp, obj, bp, bp+8)
	}
	if v1 != TCL_OK {
		return int32(TCL_ERROR)
	}
	events = 0
	for *(*TTcl_Size)(unsafe.Pointer(bp)) > 0 {
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp))-int64(1))*8)), uintptr(unsafe.Pointer(&_eventOptions)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), objName, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+16) != TCL_OK {
			return int32(TCL_ERROR)
		}
		switch *(*int32)(unsafe.Pointer(bp + 16)) {
		case int32(EVENT_READ):
			events |= libc.Int32FromInt32(1) << libc.Int32FromInt32(1)
		case int32(EVENT_WRITE):
			events |= libc.Int32FromInt32(1) << libc.Int32FromInt32(2)
			break
		}
		*(*TTcl_Size)(unsafe.Pointer(bp))--
	}
	*(*int32)(unsafe.Pointer(mask)) = events
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * DecodeEventMask --
 *
 *	This function takes an internal bitmask of events and constructs the
 *	equivalent list of event items.
 *
 * Results, Contract:
 *	A Tcl_Obj reference. The object will have a refCount of one. The user
 *	has to decrement it to release the object.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _DecodeEventMask(tls *libc.TLS, mask int32) (r uintptr) {
	var evObj, eventStr uintptr
	_, _ = evObj, eventStr
	switch mask & (libc.Int32FromInt32(1)<<libc.Int32FromInt32(1) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) {
	case libc.Int32FromInt32(1)<<libc.Int32FromInt32(1) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(2):
		eventStr = __ccgo_ts + 48240
	case libc.Int32FromInt32(1) << libc.Int32FromInt32(1):
		eventStr = __ccgo_ts + 5552
	case libc.Int32FromInt32(1) << libc.Int32FromInt32(2):
		eventStr = __ccgo_ts + 44159
	default:
		eventStr = __ccgo_ts + 1945
		break
	}
	evObj = XTcl_NewStringObj(tls, eventStr, int64(-int32(1)))
	(*TTcl_Obj)(unsafe.Pointer(evObj)).FrefCount++
	/* assert evObj.refCount == 1 */
	return evObj
}

/*
 *----------------------------------------------------------------------
 *
 * NewReflectedChannel --
 *
 *	This function is invoked to allocate and initialize the instance data
 *	of a new reflected channel.
 *
 * Results:
 *	A heap-allocated channel instance.
 *
 * Side effects:
 *	Allocates memory.
 *
 *----------------------------------------------------------------------
 */

func _NewReflectedChannel(tls *libc.TLS, interp uintptr, cmdpfxObj uintptr, mode int32, handleObj uintptr) (r uintptr) {
	var mn, v1 int32
	var rcPtr uintptr
	_, _, _ = mn, rcPtr, v1
	mn = 0
	rcPtr = XTcl_Alloc(tls, uint64(72))
	/* rcPtr->chan: Assigned by caller. Dummy data here. */
	(*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fchan1 = libc.UintptrFromInt32(0)
	(*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterp = interp
	(*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fdead = 0
	(*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fthread = XTcl_GetCurrentThread(tls)
	(*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fmode = mode
	(*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterest = 0 /* Initially no interest registered */
	(*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fcmd = XTclListObjCopy(tls, libc.UintptrFromInt32(0), cmdpfxObj)
	(*TTcl_Obj)(unsafe.Pointer((*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fcmd)).FrefCount++
	(*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fmethods = XTcl_NewListObj(tls, int64(int32(METH_WRITE)+libc.Int32FromInt32(1)), libc.UintptrFromInt32(0))
	for mn <= int32(METH_WRITE) {
		v1 = mn
		mn++
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fmethods, XTcl_NewStringObj(tls, _methodNames[v1], int64(-int32(1))))
	}
	(*TTcl_Obj)(unsafe.Pointer((*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fmethods)).FrefCount++
	(*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fname = handleObj
	(*TTcl_Obj)(unsafe.Pointer((*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fname)).FrefCount++
	return rcPtr
}

/*
 *----------------------------------------------------------------------
 *
 * NextHandle --
 *
 *	This function is invoked to generate a channel handle for a new
 *	reflected channel.
 *
 * Results:
 *	A Tcl_Obj containing the string of the new channel handle. The
 *	refcount of the returned object is -- zero --.
 *
 * Side effects:
 *	May allocate memory. Mutex-protected critical section locks out other
 *	threads for a short time.
 *
 *----------------------------------------------------------------------
 */

func _NextHandle(tls *libc.TLS) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var resObj uintptr
	_ = resObj
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_rcCounterMutex)))
	resObj = XTcl_ObjPrintf(tls, __ccgo_ts+48251, libc.VaList(bp+8, _rcCounter))
	_rcCounter++
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_rcCounterMutex)))
	return resObj
}

/*
 * Count number of generated reflected channels. Used for id generation.
 * Ids are never reclaimed and there is no dealing with wrap around. On
 * the other hand, "unsigned long" should be big enough except for
 * absolute longrunners (generate a 100 ids per second => overflow will
 * occur in 1 1/3 years).
 */

var _rcCounterMutex TTcl_Mutex

var _rcCounter uint64

func _CleanRefChannelInstance(tls *libc.TLS, rcPtr uintptr) {
	var _objPtr, _objPtr1, _objPtr2, v2, v4, v6 uintptr
	var v1, v3, v5 TTcl_Size
	_, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, v1, v2, v3, v4, v5, v6
	if (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fname != 0 {
		/*
		 * Reset obj-type (channel is deleted or dead anyway) to avoid leakage
		 * by cyclic references (see bug [79474c58800cdf94]).
		 */
		if (*TTcl_Obj)(unsafe.Pointer((*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fname)).FtypePtr != libc.UintptrFromInt32(0) {
			if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fname)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
				(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fname)).FtypePtr)).FfreeIntRepProc})))(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fname)
			}
			(*TTcl_Obj)(unsafe.Pointer((*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fname)).FtypePtr = libc.UintptrFromInt32(0)
		}
		_objPtr = (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fname
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		(*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fname = libc.UintptrFromInt32(0)
	}
	if (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fmethods != 0 {
		_objPtr1 = (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fmethods
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		(*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fmethods = libc.UintptrFromInt32(0)
	}
	if (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fcmd != 0 {
		_objPtr2 = (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fcmd
		v6 = _objPtr2
		v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
		*(*TTcl_Size)(unsafe.Pointer(v6))--
		if v5 <= int64(1) {
			XTclFreeObj(tls, _objPtr2)
		}
		(*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fcmd = libc.UintptrFromInt32(0)
	}
}

func _FreeReflectedChannel(tls *libc.TLS, blockPtr uintptr) {
	var chanPtr, rcPtr uintptr
	_, _ = chanPtr, rcPtr
	rcPtr = blockPtr
	chanPtr = (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fchan1
	XTclChannelRelease(tls, chanPtr)
	_CleanRefChannelInstance(tls, rcPtr)
	XTclpFree(tls, rcPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * InvokeTclMethod --
 *
 *	This function is used to invoke the Tcl level of a reflected channel.
 *	It handles all the command assembly, invocation, and generic state and
 *	result mgmt. It does *not* handle thread redirection; that is the
 *	responsibility of clients of this function.
 *
 * Results:
 *	Result code and data as returned by the method.
 *
 * Side effects:
 *	Arbitrary, as it calls upon a Tcl script.
 *
 * Contract:
 *	argOneObj.refCount >= 1 on entry and exit, if argOneObj != NULL
 *	argTwoObj.refCount >= 1 on entry and exit, if argTwoObj != NULL
 *	resObj.refCount in {0, 1, ...}
 *
 *----------------------------------------------------------------------
 */

func _InvokeTclMethod(tls *libc.TLS, rcPtr uintptr, method TMethodName, argOneObj uintptr, argTwoObj uintptr, resultObjPtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* NULL'able */
	var _objPtr, _objPtr1, cmd, cmdString, resObj, v1, v3, v5 uintptr
	var result int32
	var sr TTcl_InterpState
	var v2, v4 TTcl_Size
	var _ /* cmdLen at bp+8 */ TTcl_Size
	var _ /* methObj at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cmd, cmdString, resObj, result, sr, v1, v2, v3, v4, v5
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0) /* Result code of method invocation */
	resObj = libc.UintptrFromInt32(0)
	if (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fdead != 0 {
		/*
		 * The channel is marked as dead. Bail out immediately, with an
		 * appropriate error.
		 */
		if resultObjPtr != libc.UintptrFromInt32(0) {
			resObj = XTcl_NewStringObj(tls, _msg_dstlost, int64(-int32(1)))
			*(*uintptr)(unsafe.Pointer(resultObjPtr)) = resObj
			(*TTcl_Obj)(unsafe.Pointer(resObj)).FrefCount++
		}
		/*
		 * Not touching argOneObj, argTwoObj, they have not been used.
		 * See the contract as well.
		 */
		return int32(TCL_ERROR)
	}
	/*
	 * Insert method into the callback command, after the command prefix,
	 * before the channel id.
	 */
	cmd = XTclListObjCopy(tls, libc.UintptrFromInt32(0), (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fcmd)
	XTcl_ListObjIndex(tls, libc.UintptrFromInt32(0), (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fmethods, int64(method), bp)
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), cmd, *(*uintptr)(unsafe.Pointer(bp)))
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), cmd, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fname)
	/*
	 * Append the additional argument containing method specific details
	 * behind the channel id. If specified.
	 *
	 * Because of the contract there is no need to increment the refcounts.
	 * The objects will survive the Tcl_EvalObjv without change.
	 */
	if argOneObj != 0 {
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), cmd, argOneObj)
		if argTwoObj != 0 {
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), cmd, argTwoObj)
		}
	}
	/*
	 * And run the handler... This is done in auch a manner which leaves any
	 * existing state intact.
	 */
	(*TTcl_Obj)(unsafe.Pointer(cmd)).FrefCount++
	sr = XTcl_SaveInterpState(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterp, 0)
	XTcl_Preserve(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterp)
	result = XTcl_EvalObjEx(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterp, cmd, int32(TCL_EVAL_GLOBAL))
	/*
	 * We do not try to extract the result information if the caller has no
	 * interest in it. I.e. there is no need to put effort into creating
	 * something which is discarded immediately after.
	 */
	if resultObjPtr != 0 {
		if result == TCL_OK {
			/*
			 * Ok result taken as is, also if the caller requests that there
			 * is no capture.
			 */
			resObj = XTcl_GetObjResult(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterp)
		} else {
			/*
			 * Non-ok result is always treated as an error. We have to capture
			 * the full state of the result, including additional options.
			 *
			 * This is complex and ugly, and would be completely unnecessary
			 * if we only added support for a TCL_FORBID_EXCEPTIONS flag.
			 */
			if result != int32(TCL_ERROR) {
				if (*TTcl_Obj)(unsafe.Pointer(cmd)).Fbytes != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(cmd)).Flength
					v1 = (*TTcl_Obj)(unsafe.Pointer(cmd)).Fbytes
				} else {
					v1 = XTcl_GetStringFromObj(tls, cmd, bp+8)
				}
				cmdString = v1
				(*TTcl_Obj)(unsafe.Pointer(cmd)).FrefCount++
				XTcl_ResetResult(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterp)
				XTcl_SetObjResult(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterp, XTcl_ObjPrintf(tls, __ccgo_ts+48257, libc.VaList(bp+24, result)))
				XTcl_LogCommandInfo(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterp, cmdString, cmdString, *(*TTcl_Size)(unsafe.Pointer(bp + 8)))
				_objPtr = cmd
				v3 = _objPtr
				v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
				*(*TTcl_Size)(unsafe.Pointer(v3))--
				if v2 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
				result = int32(TCL_ERROR)
			}
			XTcl_AppendObjToErrorInfo(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterp, XTcl_ObjPrintf(tls, __ccgo_ts+48292, libc.VaList(bp+24, _methodNames[method])))
			resObj = _MarshallError(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterp)
		}
		(*TTcl_Obj)(unsafe.Pointer(resObj)).FrefCount++
	}
	_objPtr1 = cmd
	v5 = _objPtr1
	v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
	*(*TTcl_Size)(unsafe.Pointer(v5))--
	if v4 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	XTcl_RestoreInterpState(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterp, sr)
	XTcl_Release(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterp)
	/*
	 * The resObj has a ref count of 1 at this location. This means that the
	 * caller of InvokeTclMethod has to dispose of it (but only if it was
	 * returned to it).
	 */
	if resultObjPtr != libc.UintptrFromInt32(0) {
		*(*uintptr)(unsafe.Pointer(resultObjPtr)) = resObj
	}
	/*
	 * There no need to handle the case where nothing is returned, because for
	 * that case resObj was not set anyway.
	 */
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * ErrnoReturn --
 *
 *	Checks a method error result if it returned an 'errno'.
 *
 * Results:
 *	The negative errno found in the error result, or 0.
 *
 * Side effects:
 *	None.
 *
 * Users:
 *	ReflectInput/Output(), to enable the signaling of EAGAIN on 0-sized
 *	short reads/writes.
 *
 *----------------------------------------------------------------------
 */

func _ErrnoReturn(tls *libc.TLS, rcPtr uintptr, resObj uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var sr TTcl_InterpState
	var v1 uintptr
	var _ /* code at bp+0 */ int32
	_, _ = sr, v1 /* State of handler interp */
	if (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fdead != 0 {
		return 0
	}
	sr = XTcl_SaveInterpState(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterp, 0)
	_UnmarshallErrorResult(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterp, resObj)
	resObj = XTcl_GetObjResult(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterp)
	if XTcl_GetIntFromObj(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterp, resObj, bp) != TCL_OK || *(*int32)(unsafe.Pointer(bp)) >= 0 {
		if (*TTcl_Obj)(unsafe.Pointer(resObj)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(resObj)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, resObj, libc.UintptrFromInt32(0))
		}
		if libc.Xstrcmp(tls, __ccgo_ts+48328, v1) == 0 {
			*(*int32)(unsafe.Pointer(bp)) = -int32(EAGAIN)
		} else {
			*(*int32)(unsafe.Pointer(bp)) = 0
		}
	}
	XTcl_RestoreInterpState(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterp, sr)
	return *(*int32)(unsafe.Pointer(bp))
}

/*
 *----------------------------------------------------------------------
 *
 * GetReflectedChannelMap --
 *
 *	Gets and potentially initializes the reflected channel map for an
 *	interpreter.
 *
 * Results:
 *	A pointer to the map created, for use by the caller.
 *
 * Side effects:
 *	Initializes the reflected channel map for an interpreter.
 *
 *----------------------------------------------------------------------
 */

func _GetReflectedChannelMap(tls *libc.TLS, interp uintptr) (r uintptr) {
	var rcmPtr uintptr
	_ = rcmPtr
	rcmPtr = XTcl_GetAssocData(tls, interp, __ccgo_ts+48335, libc.UintptrFromInt32(0))
	if rcmPtr == libc.UintptrFromInt32(0) {
		rcmPtr = XTcl_Alloc(tls, uint64(104))
		XTcl_InitHashTable(tls, rcmPtr, TCL_STRING_KEYS)
		XTcl_SetAssocData(tls, interp, __ccgo_ts+48335, __ccgo_fp(_DeleteReflectedChannelMap), rcmPtr)
	}
	return rcmPtr
}

/*
 *----------------------------------------------------------------------
 *
 * DeleteReflectedChannelMap --
 *
 *	Deletes the channel table for an interpreter, closing any open
 *	channels whose refcount reaches zero. This procedure is invoked when
 *	an interpreter is deleted, via the AssocData cleanup mechanism.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Deletes the hash table of channels. May close channels. May flush
 *	output on closed channels. Removes any channelEvent handlers that were
 *	registered in this interpreter.
 *
 *----------------------------------------------------------------------
 */

func _MarkDead(tls *libc.TLS, rcPtr uintptr) {
	if (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fdead != 0 {
		return
	}
	_CleanRefChannelInstance(tls, rcPtr)
	(*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fdead = int32(1)
}

func _DeleteReflectedChannelMap(tls *libc.TLS, clientData uintptr, interp uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* The interpreter being deleted. */
	var chan1 TTcl_Channel
	var evPtr, hPtr, paramPtr, rcPtr, rcmPtr, resultPtr uintptr
	var _ /* hSearch at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _, _ = chan1, evPtr, hPtr, paramPtr, rcPtr, rcmPtr, resultPtr
	rcmPtr = clientData
	/*
	 * Delete all entries. The channels may have been closed already, or will
	 * be closed later, by the standard IO finalization of an interpreter
	 * under destruction. Except for the channels which were moved to a
	 * different interpreter and/or thread. They do not exist from the IO
	 * systems point of view and will not get closed. Therefore mark all as
	 * dead so that any future access will cause a proper error. For channels
	 * in a different thread we actually do the same as
	 * DeleteThreadReflectedChannelMap(), just restricted to the channels of
	 * this interp.
	 */
	hPtr = XTcl_FirstHashEntry(tls, rcmPtr, bp)
	for {
		if !(hPtr != libc.UintptrFromInt32(0)) {
			break
		}
		chan1 = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		rcPtr = XTcl_GetChannelInstanceData(tls, chan1)
		_MarkDead(tls, rcPtr)
		XTcl_DeleteHashEntry(tls, hPtr)
		goto _1
	_1:
		;
		hPtr = XTcl_FirstHashEntry(tls, rcmPtr, bp)
	}
	XTcl_DeleteHashTable(tls, rcmPtr)
	XTclpFree(tls, rcmPtr)
	/*
	 * The origin interpreter for one or more reflected channels is gone.
	 */
	/*
	 * Go through the list of pending results and cancel all whose events were
	 * destined for this interpreter. While this is in progress we block any
	 * other access to the list of pending results.
	 */
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_rcForwardMutex)))
	resultPtr = _forwardList
	for {
		if !(resultPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TForwardingResult)(unsafe.Pointer(resultPtr)).Fdsti != interp {
			/*
			 * Ignore results/events for other interpreters.
			 */
			goto _2
		}
		/*
		 * The receiver for the event exited, before processing the event. We
		 * detach the result now, wake the originator up and signal failure.
		 *
		 * Attention: Results may have been detached already, by either the
		 * receiver, or this thread, as part of other parts in the thread
		 * teardown. Such results are ignored. See ticket [b47b176adf] for the
		 * identical race condition in Tcl 8.6 IORTrans.
		 */
		evPtr = (*TForwardingResult)(unsafe.Pointer(resultPtr)).FevPtr
		/*
		 * Basic crash safety until this routine can get revised [3411310]
		 */
		if evPtr == libc.UintptrFromInt32(0) {
			goto _2
		}
		paramPtr = (*TForwardingEvent)(unsafe.Pointer(evPtr)).Fparam
		if !(evPtr != 0) {
			goto _2
		}
		(*TForwardingEvent)(unsafe.Pointer(evPtr)).FresultPtr = libc.UintptrFromInt32(0)
		(*TForwardingResult)(unsafe.Pointer(resultPtr)).FevPtr = libc.UintptrFromInt32(0)
		(*TForwardingResult)(unsafe.Pointer(resultPtr)).Fresult = int32(TCL_ERROR)
		(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.Fcode = int32(TCL_ERROR)
		(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.FmustFree = 0
		(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.FmsgStr = _msg_send_dstlost
		XTcl_ConditionNotify(tls, resultPtr+24)
		goto _2
	_2:
		;
		resultPtr = (*TForwardingResult)(unsafe.Pointer(resultPtr)).FnextPtr
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_rcForwardMutex)))
	/*
	 * Get the map of all channels handled by the current thread. This is a
	 * ReflectedChannelMap, but on a per-thread basis, not per-interp. Go
	 * through the channels and remove all which were handled by this
	 * interpreter. They have already been marked as dead.
	 */
	rcmPtr = _GetThreadReflectedChannelMap(tls)
	hPtr = XTcl_FirstHashEntry(tls, rcmPtr, bp)
	for {
		if !(hPtr != libc.UintptrFromInt32(0)) {
			break
		}
		chan1 = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		rcPtr = XTcl_GetChannelInstanceData(tls, chan1)
		if (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterp != interp {
			/*
			 * Ignore entries for other interpreters.
			 */
			goto _3
		}
		_MarkDead(tls, rcPtr)
		XTcl_DeleteHashEntry(tls, hPtr)
		goto _3
	_3:
		;
		hPtr = XTcl_NextHashEntry(tls, bp)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * GetThreadReflectedChannelMap --
 *
 *	Gets and potentially initializes the reflected channel map for a
 *	thread.
 *
 * Results:
 *	A pointer to the map created, for use by the caller.
 *
 * Side effects:
 *	Initializes the reflected channel map for a thread.
 *
 *----------------------------------------------------------------------
 */

func _GetThreadReflectedChannelMap(tls *libc.TLS) (r uintptr) {
	var tsdPtr uintptr
	_ = tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey4)), int64(8))
	if !((*TThreadSpecificData5)(unsafe.Pointer(tsdPtr)).FrcmPtr != 0) {
		(*TThreadSpecificData5)(unsafe.Pointer(tsdPtr)).FrcmPtr = XTcl_Alloc(tls, uint64(104))
		XTcl_InitHashTable(tls, (*TThreadSpecificData5)(unsafe.Pointer(tsdPtr)).FrcmPtr, TCL_STRING_KEYS)
		XTcl_CreateThreadExitHandler(tls, __ccgo_fp(_DeleteThreadReflectedChannelMap), libc.UintptrFromInt32(0))
	}
	return (*TThreadSpecificData5)(unsafe.Pointer(tsdPtr)).FrcmPtr
}

/*
 *----------------------------------------------------------------------
 *
 * DeleteThreadReflectedChannelMap --
 *
 *	Deletes the channel table for a thread. This procedure is invoked when
 *	a thread is deleted. The channels have already been marked as dead, in
 *	DeleteReflectedChannelMap().
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Deletes the hash table of channels.
 *
 *----------------------------------------------------------------------
 */

func _DeleteThreadReflectedChannelMap(tls *libc.TLS, dummy2745 uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var chan1 TTcl_Channel
	var evPtr, hPtr, paramPtr, rcPtr, rcmPtr, resultPtr, tsdPtr uintptr
	var self TTcl_ThreadId
	var _ /* hSearch at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _, _, _, _ = chan1, evPtr, hPtr, paramPtr, rcPtr, rcmPtr, resultPtr, self, tsdPtr /* Search variable. */
	self = XTcl_GetCurrentThread(tls)
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey4)), int64(8))
	/*
	 * The origin thread for one or more reflected channels is gone.
	 * NOTE: If this function is called due to a thread getting killed the
	 *       per-interp DeleteReflectedChannelMap is apparently not called.
	 */
	/*
	 * Go through the list of pending results and cancel all whose events were
	 * destined for this thread. While this is in progress we block any other
	 * access to the list of pending results.
	 */
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_rcForwardMutex)))
	resultPtr = _forwardList
	for {
		if !(resultPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TForwardingResult)(unsafe.Pointer(resultPtr)).Fdst != self {
			/*
			 * Ignore results/events for other threads.
			 */
			goto _1
		}
		/*
		 * The receiver for the event exited, before processing the event. We
		 * detach the result now, wake the originator up and signal failure.
		 *
		 * Attention: Results may have been detached already, by either the
		 * receiver, or this thread, as part of other parts in the thread
		 * teardown. Such results are ignored. See ticket [b47b176adf] for the
		 * identical race condition in Tcl 8.6 IORTrans.
		 */
		evPtr = (*TForwardingResult)(unsafe.Pointer(resultPtr)).FevPtr
		/*
		 * Basic crash safety until this routine can get revised [3411310]
		 */
		if evPtr == libc.UintptrFromInt32(0) {
			goto _1
		}
		paramPtr = (*TForwardingEvent)(unsafe.Pointer(evPtr)).Fparam
		if !(evPtr != 0) {
			goto _1
		}
		(*TForwardingEvent)(unsafe.Pointer(evPtr)).FresultPtr = libc.UintptrFromInt32(0)
		(*TForwardingResult)(unsafe.Pointer(resultPtr)).FevPtr = libc.UintptrFromInt32(0)
		(*TForwardingResult)(unsafe.Pointer(resultPtr)).Fresult = int32(TCL_ERROR)
		(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.Fcode = int32(TCL_ERROR)
		(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.FmustFree = 0
		(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.FmsgStr = _msg_send_dstlost
		XTcl_ConditionNotify(tls, resultPtr+24)
		goto _1
	_1:
		;
		resultPtr = (*TForwardingResult)(unsafe.Pointer(resultPtr)).FnextPtr
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_rcForwardMutex)))
	/*
	 * Run over the event queue of this thread and remove all ReflectEvent's
	 * still pending. These are inbound events for reflected channels this
	 * thread owns but doesn't handle. The inverse of the channel map
	 * actually.
	 */
	XTcl_DeleteEvents(tls, __ccgo_fp(_ReflectEventDelete), libc.UintptrFromInt32(0))
	/*
	 * Get the map of all channels handled by the current thread. This is a
	 * ReflectedChannelMap, but on a per-thread basis, not per-interp. Go
	 * through the channels, remove all, mark them as dead.
	 */
	rcmPtr = _GetThreadReflectedChannelMap(tls)
	(*TThreadSpecificData5)(unsafe.Pointer(tsdPtr)).FrcmPtr = libc.UintptrFromInt32(0)
	hPtr = XTcl_FirstHashEntry(tls, rcmPtr, bp)
	for {
		if !(hPtr != libc.UintptrFromInt32(0)) {
			break
		}
		chan1 = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		rcPtr = XTcl_GetChannelInstanceData(tls, chan1)
		_MarkDead(tls, rcPtr)
		XTcl_DeleteHashEntry(tls, hPtr)
		goto _2
	_2:
		;
		hPtr = XTcl_FirstHashEntry(tls, rcmPtr, bp)
	}
	XTclpFree(tls, rcmPtr)
}

func _ForwardOpToHandlerThread(tls *libc.TLS, rcPtr uintptr, op TForwardedOperation, param uintptr) {
	/* Arguments */
	var dst TTcl_ThreadId
	var evPtr, resultPtr uintptr
	_, _, _ = dst, evPtr, resultPtr
	/*
	 * Core of the communication from OWNER to HANDLER thread. The receiver is
	 * ForwardProc() below.
	 */
	dst = (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fthread
	/*
	 * We gather the lock early. This allows us to check the liveness of the
	 * channel without interference from DeleteThreadReflectedChannelMap().
	 */
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_rcForwardMutex)))
	if (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fdead != 0 {
		/*
		 * The channel is marked as dead. Bail out immediately, with an
		 * appropriate error. Do not forget to unlock the mutex on this path.
		 */
		(*TForwardParam)(unsafe.Pointer(param)).Fbase.Fcode = int32(TCL_ERROR)
		(*TForwardParam)(unsafe.Pointer(param)).Fbase.FmustFree = 0
		(*TForwardParam)(unsafe.Pointer(param)).Fbase.FmsgStr = _msg_send_dstlost
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_rcForwardMutex)))
		return
	}
	/*
	 * Create and initialize the event and data structures.
	 */
	evPtr = XTcl_Alloc(tls, uint64(48))
	resultPtr = XTcl_Alloc(tls, uint64(64))
	(*TForwardingEvent)(unsafe.Pointer(evPtr)).Fevent.Fproc = __ccgo_fp(_ForwardProc)
	(*TForwardingEvent)(unsafe.Pointer(evPtr)).FresultPtr = resultPtr
	(*TForwardingEvent)(unsafe.Pointer(evPtr)).Fop = op
	(*TForwardingEvent)(unsafe.Pointer(evPtr)).FrcPtr = rcPtr
	(*TForwardingEvent)(unsafe.Pointer(evPtr)).Fparam = param
	(*TForwardingResult)(unsafe.Pointer(resultPtr)).Fsrc = XTcl_GetCurrentThread(tls)
	(*TForwardingResult)(unsafe.Pointer(resultPtr)).Fdst = dst
	(*TForwardingResult)(unsafe.Pointer(resultPtr)).Fdsti = (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterp
	(*TForwardingResult)(unsafe.Pointer(resultPtr)).Fdone = libc.UintptrFromInt32(0)
	(*TForwardingResult)(unsafe.Pointer(resultPtr)).Fresult = -int32(1)
	(*TForwardingResult)(unsafe.Pointer(resultPtr)).FevPtr = evPtr
	/*
	 * Now execute the forward.
	 */
	(*TForwardingResult)(unsafe.Pointer(resultPtr)).FnextPtr = _forwardList
	if _forwardList != libc.UintptrFromInt32(0) {
		(*TForwardingResult)(unsafe.Pointer(_forwardList)).FprevPtr = resultPtr
	}
	(*TForwardingResult)(unsafe.Pointer(resultPtr)).FprevPtr = libc.UintptrFromInt32(0)
	_forwardList = resultPtr
	/*
	 * Do not unlock here. That is done by the ConditionWait.
	 */
	/*
	 * Ensure cleanup of the event if the origin thread exits while this event
	 * is pending or in progress. Exit of the destination thread is handled by
	 * DeleteThreadReflectedChannelMap(), this is set up by
	 * GetThreadReflectedChannelMap(). This is what we use the 'forwardList'
	 * (see above) for.
	 */
	XTcl_CreateThreadExitHandler(tls, __ccgo_fp(_SrcExitProc), evPtr)
	/*
	 * Queue the event and poke the other thread's notifier.
	 */
	XTcl_ThreadQueueEvent(tls, dst, evPtr, int32(TCL_QUEUE_TAIL)|int32(TCL_QUEUE_ALERT_IF_EMPTY))
	/*
	 * (*) Block until the handler thread has either processed the transfer or
	 * rejected it.
	 */
	for (*TForwardingResult)(unsafe.Pointer(resultPtr)).Fresult < 0 {
		/*
		 * NOTE (1): Is it possible that the current thread goes away while
		 * waiting here? IOW Is it possible that "SrcExitProc" is called while
		 * we are here? See complementary note (2) in "SrcExitProc"
		 *
		 * The ConditionWait unlocks the mutex during the wait and relocks it
		 * immediately after.
		 */
		XTcl_ConditionWait(tls, resultPtr+24, uintptr(unsafe.Pointer(&_rcForwardMutex)), libc.UintptrFromInt32(0))
	}
	/*
	 * Unlink result from the forwarder list. No need to lock. Either still
	 * locked, or locked by the ConditionWait
	 */
	if (*TForwardingResult)(unsafe.Pointer(resultPtr)).FprevPtr != libc.UintptrFromInt32(0) {
		(*TForwardingResult)(unsafe.Pointer((*TForwardingResult)(unsafe.Pointer(resultPtr)).FprevPtr)).FnextPtr = (*TForwardingResult)(unsafe.Pointer(resultPtr)).FnextPtr
	} else {
		_forwardList = (*TForwardingResult)(unsafe.Pointer(resultPtr)).FnextPtr
	}
	if (*TForwardingResult)(unsafe.Pointer(resultPtr)).FnextPtr != libc.UintptrFromInt32(0) {
		(*TForwardingResult)(unsafe.Pointer((*TForwardingResult)(unsafe.Pointer(resultPtr)).FnextPtr)).FprevPtr = (*TForwardingResult)(unsafe.Pointer(resultPtr)).FprevPtr
	}
	(*TForwardingResult)(unsafe.Pointer(resultPtr)).FnextPtr = libc.UintptrFromInt32(0)
	(*TForwardingResult)(unsafe.Pointer(resultPtr)).FprevPtr = libc.UintptrFromInt32(0)
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_rcForwardMutex)))
	XTcl_ConditionFinalize(tls, resultPtr+24)
	/*
	 * Kill the cleanup handler now, and the result structure as well, before
	 * returning the success code.
	 *
	 * Note: The event structure has already been deleted.
	 */
	XTcl_DeleteThreadExitHandler(tls, __ccgo_fp(_SrcExitProc), evPtr)
	XTclpFree(tls, resultPtr)
}

func _ForwardProc(tls *libc.TLS, evGPtr uintptr, dummy2971 int32) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var _objPtr, _objPtr1, _objPtr10, _objPtr11, _objPtr12, _objPtr13, _objPtr2, _objPtr3, _objPtr4, _objPtr5, _objPtr6, _objPtr7, _objPtr8, _objPtr9, baseObj, blockObj, buf, bufObj, bytev, cachePtr, cachePtr1, evPtr, hPtr, interp, lenObj, maskObj, offObj, optionObj, optionObj1, paramPtr, rcPtr, rcmPtr, resultPtr, str, toReadObj, valueObj, v10, v13, v15, v17, v19, v21, v23, v25, v27, v3, v32, v33, v34, v36, v38, v5, v7, v9 uintptr
	var code, code1, v11, v28 int32
	var v1, v8 bool
	var v12, v14, v16, v18, v2, v20, v22, v24, v26, v31, v35, v37, v4, v6 TTcl_Size
	var v29, v30 int64
	var _ /* bytec at bp+8 */ TTcl_Size
	var _ /* len at bp+48 */ TTcl_Size
	var _ /* listc at bp+32 */ TTcl_Size
	var _ /* listv at bp+40 */ uintptr
	var _ /* newLoc at bp+24 */ TTcl_WideInt
	var _ /* resObj at bp+0 */ uintptr
	var _ /* written at bp+16 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr10, _objPtr11, _objPtr12, _objPtr13, _objPtr2, _objPtr3, _objPtr4, _objPtr5, _objPtr6, _objPtr7, _objPtr8, _objPtr9, baseObj, blockObj, buf, bufObj, bytev, cachePtr, cachePtr1, code, code1, evPtr, hPtr, interp, lenObj, maskObj, offObj, optionObj, optionObj1, paramPtr, rcPtr, rcmPtr, resultPtr, str, toReadObj, valueObj, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v4, v5, v6, v7, v8, v9
	/*
	 * HANDLER thread.
	 * The receiver part for the operations coming from the OWNER thread.
	 * See ForwardOpToHandlerThread() for the transmitter.
	 *
	 * Notes regarding access to the referenced data.
	 *
	 * In principle the data belongs to the originating thread (see
	 * evPtr->src), however this thread is currently blocked at (*), i.e.,
	 * quiescent. Because of this we can treat the data as belonging to us,
	 * without fear of race conditions. I.e. we can read and write as we like.
	 *
	 * The only thing we cannot be sure of is the resultPtr. This can be
	 * NULLed if the originating thread went away while the event is handled
	 * here now.
	 */
	evPtr = evGPtr
	resultPtr = (*TForwardingEvent)(unsafe.Pointer(evPtr)).FresultPtr
	rcPtr = (*TForwardingEvent)(unsafe.Pointer(evPtr)).FrcPtr
	interp = (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterp
	paramPtr = (*TForwardingEvent)(unsafe.Pointer(evPtr)).Fparam
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0) /* Entry in the above map */
	/*
	 * Ignore the event if no one is waiting for its result anymore.
	 */
	if !(resultPtr != 0) {
		return int32(1)
	}
	(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.Fcode = TCL_OK
	(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.FmsgStr = libc.UintptrFromInt32(0)
	(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.FmustFree = 0
	switch (*TForwardingEvent)(unsafe.Pointer(evPtr)).Fop {
	/*
	 * The destination thread for the following operations is
	 * rcPtr->thread, which contains rcPtr->interp, the interp we have to
	 * call upon for the driver.
	 */
	case int32(ForwardedClose):
		/*
		 * No parameters/results.
		 */
		if _InvokeTclMethod(tls, rcPtr, int32(METH_FINAL), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), bp) != TCL_OK {
			_ForwardSetObjError(tls, paramPtr, *(*uintptr)(unsafe.Pointer(bp)))
		}
		/*
		 * Freeing is done here, in the origin thread, callback command
		 * objects belong to this thread. Deallocating them in a different
		 * thread is not allowed
		 *
		 * We remove the channel from both interpreter and thread maps before
		 * releasing the memory, to prevent future accesses (like by
		 * 'postevent') from finding and dereferencing a dangling pointer.
		 */
		rcmPtr = _GetReflectedChannelMap(tls, interp)
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(rcmPtr)).FfindProc})))(tls, rcmPtr, XTcl_GetChannelName(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fchan1))
		XTcl_DeleteHashEntry(tls, hPtr)
		rcmPtr = _GetThreadReflectedChannelMap(tls)
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(rcmPtr)).FfindProc})))(tls, rcmPtr, XTcl_GetChannelName(tls, (*TReflectedChannel)(unsafe.Pointer(rcPtr)).Fchan1))
		XTcl_DeleteHashEntry(tls, hPtr)
		_MarkDead(tls, rcPtr)
	case int32(ForwardedInput):
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			toReadObj = XTclThreadAllocObj(tls)
		} else {
			toReadObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(toReadObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(toReadObj)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(toReadObj)).Fbytes = libc.UintptrFromInt32(0)
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(toReadObj)).FinternalRep)) = (*(*TForwardParamInput)(unsafe.Pointer(paramPtr))).FtoRead
		(*TTcl_Obj)(unsafe.Pointer(toReadObj)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
		(*TTcl_Obj)(unsafe.Pointer(toReadObj)).FrefCount++
		XTcl_Preserve(tls, rcPtr)
		if _InvokeTclMethod(tls, rcPtr, int32(METH_READ), toReadObj, libc.UintptrFromInt32(0), bp) != TCL_OK {
			code = _ErrnoReturn(tls, rcPtr, *(*uintptr)(unsafe.Pointer(bp)))
			if code < 0 {
				(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.Fcode = code
			} else {
				_ForwardSetObjError(tls, paramPtr, *(*uintptr)(unsafe.Pointer(bp)))
			}
			(*(*TForwardParamInput)(unsafe.Pointer(paramPtr))).FtoRead = int64(-libc.Int32FromInt32(1))
		} else {
			/*
			 * Process a regular result.
			 */
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0 /* Array of returned bytes */
			bytev = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), bp+8)
			if bytev == libc.UintptrFromInt32(0) {
				(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.Fcode = int32(TCL_ERROR)
				(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.FmustFree = 0
				(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.FmsgStr = _msg_read_nonbyte
				(*(*TForwardParamInput)(unsafe.Pointer(paramPtr))).FtoRead = int64(-int32(1))
			} else {
				if (*(*TForwardParamInput)(unsafe.Pointer(paramPtr))).FtoRead < *(*TTcl_Size)(unsafe.Pointer(bp + 8)) {
					(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.Fcode = int32(TCL_ERROR)
					(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.FmustFree = 0
					(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.FmsgStr = _msg_read_toomuch
					(*(*TForwardParamInput)(unsafe.Pointer(paramPtr))).FtoRead = int64(-libc.Int32FromInt32(1))
				} else {
					if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > 0 {
						libc.Xmemcpy(tls, (*(*TForwardParamInput)(unsafe.Pointer(paramPtr))).Fbuf, bytev, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8))))
					}
					(*(*TForwardParamInput)(unsafe.Pointer(paramPtr))).FtoRead = *(*TTcl_Size)(unsafe.Pointer(bp + 8))
				}
			}
		}
		XTcl_Release(tls, rcPtr)
		_objPtr = toReadObj
		v3 = _objPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	case int32(ForwardedOutput):
		bufObj = XTcl_NewByteArrayObj(tls, (*(*TForwardParamOutput)(unsafe.Pointer(paramPtr))).Fbuf, (*(*TForwardParamOutput)(unsafe.Pointer(paramPtr))).FtoWrite)
		(*TTcl_Obj)(unsafe.Pointer(bufObj)).FrefCount++
		XTcl_Preserve(tls, rcPtr)
		if _InvokeTclMethod(tls, rcPtr, int32(METH_WRITE), bufObj, libc.UintptrFromInt32(0), bp) != TCL_OK {
			code1 = _ErrnoReturn(tls, rcPtr, *(*uintptr)(unsafe.Pointer(bp)))
			if code1 < 0 {
				(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.Fcode = code1
			} else {
				_ForwardSetObjError(tls, paramPtr, *(*uintptr)(unsafe.Pointer(bp)))
			}
			(*(*TForwardParamOutput)(unsafe.Pointer(paramPtr))).FtoWrite = int64(-int32(1))
		} else {
			if XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), bp+16) != TCL_OK {
				_objPtr1 = *(*uintptr)(unsafe.Pointer(bp))
				v5 = _objPtr1
				v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
				*(*TTcl_Size)(unsafe.Pointer(v5))--
				if v4 <= int64(1) {
					XTclFreeObj(tls, _objPtr1)
				}
				*(*uintptr)(unsafe.Pointer(bp)) = _MarshallError(tls, interp)
				_ForwardSetObjError(tls, paramPtr, *(*uintptr)(unsafe.Pointer(bp)))
				(*(*TForwardParamOutput)(unsafe.Pointer(paramPtr))).FtoWrite = int64(-int32(1))
			} else {
				if *(*int32)(unsafe.Pointer(bp + 16)) == 0 || (*(*TForwardParamOutput)(unsafe.Pointer(paramPtr))).FtoWrite < int64(*(*int32)(unsafe.Pointer(bp + 16))) {
					(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.Fcode = int32(TCL_ERROR)
					(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.FmustFree = 0
					(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.FmsgStr = _msg_write_toomuch
					(*(*TForwardParamOutput)(unsafe.Pointer(paramPtr))).FtoWrite = int64(-int32(1))
				} else {
					(*(*TForwardParamOutput)(unsafe.Pointer(paramPtr))).FtoWrite = int64(*(*int32)(unsafe.Pointer(bp + 16)))
				}
			}
		}
		XTcl_Release(tls, rcPtr)
		_objPtr2 = bufObj
		v7 = _objPtr2
		v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
		*(*TTcl_Size)(unsafe.Pointer(v7))--
		if v6 <= int64(1) {
			XTclFreeObj(tls, _objPtr2)
		}
	case int32(ForwardedSeek):
		if v8 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v8 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v8 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			offObj = XTclThreadAllocObj(tls)
		} else {
			offObj = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(offObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(offObj)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(offObj)).Fbytes = libc.UintptrFromInt32(0)
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(offObj)).FinternalRep)) = (*(*TForwardParamSeek)(unsafe.Pointer(paramPtr))).Foffset
		(*TTcl_Obj)(unsafe.Pointer(offObj)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
		if (*(*TForwardParamSeek)(unsafe.Pointer(paramPtr))).FseekMode == 0 {
			v9 = __ccgo_ts + 45799
		} else {
			if (*(*TForwardParamSeek)(unsafe.Pointer(paramPtr))).FseekMode == int32(1) {
				v10 = __ccgo_ts + 11670
			} else {
				v10 = __ccgo_ts + 21833
			}
			v9 = v10
		}
		baseObj = XTcl_NewStringObj(tls, v9, int64(-int32(1)))
		(*TTcl_Obj)(unsafe.Pointer(offObj)).FrefCount++
		(*TTcl_Obj)(unsafe.Pointer(baseObj)).FrefCount++
		XTcl_Preserve(tls, rcPtr)
		if _InvokeTclMethod(tls, rcPtr, int32(METH_SEEK), offObj, baseObj, bp) != TCL_OK {
			_ForwardSetObjError(tls, paramPtr, *(*uintptr)(unsafe.Pointer(bp)))
			(*(*TForwardParamSeek)(unsafe.Pointer(paramPtr))).Foffset = int64(-int32(1))
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
				*(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FinternalRep))
				v11 = libc.Int32FromInt32(TCL_OK)
			} else {
				v11 = XTcl_GetWideIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), bp+24)
			}
			if v11 == TCL_OK {
				if *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) < 0 {
					(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.Fcode = int32(TCL_ERROR)
					(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.FmustFree = 0
					(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.FmsgStr = _msg_seek_beforestart
					(*(*TForwardParamSeek)(unsafe.Pointer(paramPtr))).Foffset = int64(-int32(1))
				} else {
					(*(*TForwardParamSeek)(unsafe.Pointer(paramPtr))).Foffset = *(*TTcl_WideInt)(unsafe.Pointer(bp + 24))
				}
			} else {
				_objPtr3 = *(*uintptr)(unsafe.Pointer(bp))
				v13 = _objPtr3
				v12 = *(*TTcl_Size)(unsafe.Pointer(v13))
				*(*TTcl_Size)(unsafe.Pointer(v13))--
				if v12 <= int64(1) {
					XTclFreeObj(tls, _objPtr3)
				}
				*(*uintptr)(unsafe.Pointer(bp)) = _MarshallError(tls, interp)
				_ForwardSetObjError(tls, paramPtr, *(*uintptr)(unsafe.Pointer(bp)))
				(*(*TForwardParamSeek)(unsafe.Pointer(paramPtr))).Foffset = int64(-int32(1))
			}
		}
		XTcl_Release(tls, rcPtr)
		_objPtr4 = offObj
		v15 = _objPtr4
		v14 = *(*TTcl_Size)(unsafe.Pointer(v15))
		*(*TTcl_Size)(unsafe.Pointer(v15))--
		if v14 <= int64(1) {
			XTclFreeObj(tls, _objPtr4)
		}
		_objPtr5 = baseObj
		v17 = _objPtr5
		v16 = *(*TTcl_Size)(unsafe.Pointer(v17))
		*(*TTcl_Size)(unsafe.Pointer(v17))--
		if v16 <= int64(1) {
			XTclFreeObj(tls, _objPtr5)
		}
	case int32(ForwardedWatch):
		maskObj = _DecodeEventMask(tls, (*(*TForwardParamWatch)(unsafe.Pointer(paramPtr))).Fmask)
		/* assert maskObj.refCount == 1 */
		XTcl_Preserve(tls, rcPtr)
		(*TReflectedChannel)(unsafe.Pointer(rcPtr)).Finterest = (*(*TForwardParamWatch)(unsafe.Pointer(paramPtr))).Fmask
		_InvokeTclMethod(tls, rcPtr, int32(METH_WATCH), maskObj, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
		_objPtr6 = maskObj
		v19 = _objPtr6
		v18 = *(*TTcl_Size)(unsafe.Pointer(v19))
		*(*TTcl_Size)(unsafe.Pointer(v19))--
		if v18 <= int64(1) {
			XTclFreeObj(tls, _objPtr6)
		}
		XTcl_Release(tls, rcPtr)
	case int32(ForwardedBlock):
		blockObj = XTcl_NewWideIntObj(tls, libc.BoolInt64(libc.BoolInt32(!((*(*TForwardParamBlock)(unsafe.Pointer(paramPtr))).Fnonblocking != 0)) != 0))
		(*TTcl_Obj)(unsafe.Pointer(blockObj)).FrefCount++
		XTcl_Preserve(tls, rcPtr)
		if _InvokeTclMethod(tls, rcPtr, int32(METH_BLOCKING), blockObj, libc.UintptrFromInt32(0), bp) != TCL_OK {
			_ForwardSetObjError(tls, paramPtr, *(*uintptr)(unsafe.Pointer(bp)))
		}
		XTcl_Release(tls, rcPtr)
		_objPtr7 = blockObj
		v21 = _objPtr7
		v20 = *(*TTcl_Size)(unsafe.Pointer(v21))
		*(*TTcl_Size)(unsafe.Pointer(v21))--
		if v20 <= int64(1) {
			XTclFreeObj(tls, _objPtr7)
		}
	case int32(ForwardedSetOpt):
		optionObj = XTcl_NewStringObj(tls, (*(*TForwardParamSetOpt)(unsafe.Pointer(paramPtr))).Fname, int64(-int32(1)))
		valueObj = XTcl_NewStringObj(tls, (*(*TForwardParamSetOpt)(unsafe.Pointer(paramPtr))).Fvalue, int64(-int32(1)))
		(*TTcl_Obj)(unsafe.Pointer(optionObj)).FrefCount++
		(*TTcl_Obj)(unsafe.Pointer(valueObj)).FrefCount++
		XTcl_Preserve(tls, rcPtr)
		if _InvokeTclMethod(tls, rcPtr, int32(METH_CONFIGURE), optionObj, valueObj, bp) != TCL_OK {
			_ForwardSetObjError(tls, paramPtr, *(*uintptr)(unsafe.Pointer(bp)))
		}
		XTcl_Release(tls, rcPtr)
		_objPtr8 = optionObj
		v23 = _objPtr8
		v22 = *(*TTcl_Size)(unsafe.Pointer(v23))
		*(*TTcl_Size)(unsafe.Pointer(v23))--
		if v22 <= int64(1) {
			XTclFreeObj(tls, _objPtr8)
		}
		_objPtr9 = valueObj
		v25 = _objPtr9
		v24 = *(*TTcl_Size)(unsafe.Pointer(v25))
		*(*TTcl_Size)(unsafe.Pointer(v25))--
		if v24 <= int64(1) {
			XTclFreeObj(tls, _objPtr9)
		}
	case int32(ForwardedGetOpt):
		/*
		 * Retrieve the value of one option.
		 */
		optionObj1 = XTcl_NewStringObj(tls, (*(*TForwardParamGetOpt)(unsafe.Pointer(paramPtr))).Fname, int64(-int32(1)))
		(*TTcl_Obj)(unsafe.Pointer(optionObj1)).FrefCount++
		XTcl_Preserve(tls, rcPtr)
		if _InvokeTclMethod(tls, rcPtr, int32(METH_CGET), optionObj1, libc.UintptrFromInt32(0), bp) != TCL_OK {
			_ForwardSetObjError(tls, paramPtr, *(*uintptr)(unsafe.Pointer(bp)))
		} else {
			XTclDStringAppendObj(tls, (*(*TForwardParamGetOpt)(unsafe.Pointer(paramPtr))).Fvalue, *(*uintptr)(unsafe.Pointer(bp)))
		}
		XTcl_Release(tls, rcPtr)
		_objPtr10 = optionObj1
		v27 = _objPtr10
		v26 = *(*TTcl_Size)(unsafe.Pointer(v27))
		*(*TTcl_Size)(unsafe.Pointer(v27))--
		if v26 <= int64(1) {
			XTclFreeObj(tls, _objPtr10)
		}
	case int32(ForwardedGetOptAll):
		/*
		 * Retrieve all options.
		 */
		XTcl_Preserve(tls, rcPtr)
		if _InvokeTclMethod(tls, rcPtr, int32(METH_CGETALL), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), bp) != TCL_OK {
			_ForwardSetObjError(tls, paramPtr, *(*uintptr)(unsafe.Pointer(bp)))
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr2 != 0 {
					v29 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr2)).FspanStart
				} else {
					v29 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr1)).FfirstUsed
				}
				*(*uintptr)(unsafe.Pointer(bp + 40)) = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr1 + 40 + uintptr(v29)*8
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr2 != 0 {
					v30 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr2)).FspanLength
				} else {
					v30 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = v30
				v28 = libc.Int32FromInt32(TCL_OK)
			} else {
				v28 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), bp+32, bp+40)
			}
			if v28 != TCL_OK {
				_objPtr11 = *(*uintptr)(unsafe.Pointer(bp))
				v32 = _objPtr11
				v31 = *(*TTcl_Size)(unsafe.Pointer(v32))
				*(*TTcl_Size)(unsafe.Pointer(v32))--
				if v31 <= int64(1) {
					XTclFreeObj(tls, _objPtr11)
				}
				*(*uintptr)(unsafe.Pointer(bp)) = _MarshallError(tls, interp)
				_ForwardSetObjError(tls, paramPtr, *(*uintptr)(unsafe.Pointer(bp)))
			} else {
				if *(*TTcl_Size)(unsafe.Pointer(bp + 32))%int64(2) == int64(1) {
					/*
					 * Odd number of elements is wrong. [x].
					 */
					buf = XTcl_Alloc(tls, uint64(200))
					if *(*TTcl_Size)(unsafe.Pointer(bp + 32)) == int64(1) {
						v33 = __ccgo_ts + 48355
					} else {
						v33 = __ccgo_ts + 48363
					}
					libc.X__builtin_snprintf(tls, buf, uint64(200), __ccgo_ts+48372, libc.VaList(bp+64, *(*TTcl_Size)(unsafe.Pointer(bp + 32)), v33))
					(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.Fcode = int32(TCL_ERROR)
					(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.FmustFree = int32(1)
					(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.FmsgStr = buf
				} else {
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes != 0 {
						*(*TTcl_Size)(unsafe.Pointer(bp + 48)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Flength
						v34 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes
					} else {
						v34 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+48)
					}
					str = v34
					if *(*TTcl_Size)(unsafe.Pointer(bp + 48)) != 0 {
						XTcl_DStringAppend(tls, (*(*TForwardParamGetOpt)(unsafe.Pointer(paramPtr))).Fvalue, __ccgo_ts+14830, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))
						XTcl_DStringAppend(tls, (*(*TForwardParamGetOpt)(unsafe.Pointer(paramPtr))).Fvalue, str, *(*TTcl_Size)(unsafe.Pointer(bp + 48)))
					}
				}
			}
		}
		XTcl_Release(tls, rcPtr)
	case int32(ForwardedTruncate):
		lenObj = XTcl_NewWideIntObj(tls, (*(*TForwardParamTruncate)(unsafe.Pointer(paramPtr))).Flength)
		(*TTcl_Obj)(unsafe.Pointer(lenObj)).FrefCount++
		XTcl_Preserve(tls, rcPtr)
		if _InvokeTclMethod(tls, rcPtr, int32(METH_TRUNCATE), lenObj, libc.UintptrFromInt32(0), bp) != TCL_OK {
			_ForwardSetObjError(tls, paramPtr, *(*uintptr)(unsafe.Pointer(bp)))
		}
		XTcl_Release(tls, rcPtr)
		_objPtr12 = lenObj
		v36 = _objPtr12
		v35 = *(*TTcl_Size)(unsafe.Pointer(v36))
		*(*TTcl_Size)(unsafe.Pointer(v36))--
		if v35 <= int64(1) {
			XTclFreeObj(tls, _objPtr12)
		}
	default:
		/*
		 * Bad operation code.
		 */
		XTcl_Panic(tls, __ccgo_ts+48437, 0)
		break
	}
	/*
	 * Remove the reference we held on the result of the invoke, if we had
	 * such.
	 */
	if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
		_objPtr13 = *(*uintptr)(unsafe.Pointer(bp))
		v38 = _objPtr13
		v37 = *(*TTcl_Size)(unsafe.Pointer(v38))
		*(*TTcl_Size)(unsafe.Pointer(v38))--
		if v37 <= int64(1) {
			XTclFreeObj(tls, _objPtr13)
		}
	}
	if resultPtr != 0 {
		/*
		 * Report the forwarding result synchronously to the waiting caller.
		 * This unblocks (*) as well. This is wrapped into a conditional
		 * because the caller may have exited in the mean time.
		 */
		XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_rcForwardMutex)))
		(*TForwardingResult)(unsafe.Pointer(resultPtr)).Fresult = TCL_OK
		XTcl_ConditionNotify(tls, resultPtr+24)
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_rcForwardMutex)))
	}
	return int32(1)
}

func _SrcExitProc(tls *libc.TLS, clientData uintptr) {
	var evPtr, paramPtr, resultPtr uintptr
	_, _, _ = evPtr, paramPtr, resultPtr
	evPtr = clientData
	/*
	 * NOTE (2): Can this handler be called with the originator blocked?
	 */
	/*
	 * The originator for the event exited. It is not sure if this can happen,
	 * as the originator should be blocked at (*) while the event is in
	 * transit/pending.
	 *
	 * We make sure that the event cannot refer to the result anymore, remove
	 * it from the list of pending results and free the structure. Locking the
	 * access ensures that we cannot get in conflict with "ForwardProc",
	 * should it already execute the event.
	 */
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_rcForwardMutex)))
	resultPtr = (*TForwardingEvent)(unsafe.Pointer(evPtr)).FresultPtr
	paramPtr = (*TForwardingEvent)(unsafe.Pointer(evPtr)).Fparam
	(*TForwardingEvent)(unsafe.Pointer(evPtr)).FresultPtr = libc.UintptrFromInt32(0)
	(*TForwardingResult)(unsafe.Pointer(resultPtr)).FevPtr = libc.UintptrFromInt32(0)
	(*TForwardingResult)(unsafe.Pointer(resultPtr)).Fresult = int32(TCL_ERROR)
	(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.Fcode = int32(TCL_ERROR)
	(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.FmustFree = 0
	(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.FmsgStr = _msg_send_originlost
	/*
	 * See below: TclSpliceOut(resultPtr, forwardList);
	 */
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_rcForwardMutex)))
	/*
	 * This unlocks (*). The structure will be spliced out and freed by
	 * "ForwardProc". Maybe.
	 */
	XTcl_ConditionNotify(tls, resultPtr+24)
}

func _ForwardSetObjError(tls *libc.TLS, paramPtr uintptr, obj uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var msgStr, v1 uintptr
	var _ /* len at bp+0 */ TTcl_Size
	_, _ = msgStr, v1
	if (*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(obj)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, obj, bp)
	}
	msgStr = v1
	*(*TTcl_Size)(unsafe.Pointer(bp))++
	(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.Fcode = int32(TCL_ERROR)
	(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.FmustFree = int32(1)
	(*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.FmsgStr = XTcl_Alloc(tls, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))))
	libc.Xmemcpy(tls, (*TForwardParam)(unsafe.Pointer(paramPtr)).Fbase.FmsgStr, msgStr, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))))
}

const FLUSH_DISCARD = 0
const FLUSH_WRITE = 1
const RB_INCREMENT = 512
const RTMKEY = "ReflectedTransformMap"

/*
 * The C layer channel type/driver definition used by the reflection.
 */

var _reflectedTransformType = TTcl_ChannelType{
	FtypeName: __ccgo_ts + 48471,
	Fversion:  libc.UintptrFromInt32(0x5),
}

func init() {
	p := unsafe.Pointer(&_reflectedTransformType)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_ReflectInput1)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_ReflectOutput1)
	*(*uintptr)(unsafe.Add(p, 48)) = __ccgo_fp(_ReflectSetOption1)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(_ReflectGetOption1)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(_ReflectWatch1)
	*(*uintptr)(unsafe.Add(p, 72)) = __ccgo_fp(_ReflectHandle)
	*(*uintptr)(unsafe.Add(p, 80)) = __ccgo_fp(_ReflectClose1)
	*(*uintptr)(unsafe.Add(p, 88)) = __ccgo_fp(_ReflectBlock1)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(_ReflectNotify)
	*(*uintptr)(unsafe.Add(p, 112)) = __ccgo_fp(_ReflectSeekWide1)
}

/*
 * Structure of the buffer to hold transform results to be consumed by higher
 * layers upon reading from the channel, plus the functions to manage such.
 */

type TResultBuffer = struct {
	Fbuf       uintptr
	Fallocated Tsize_t
	Fused      Tsize_t
}

/*
 * Convenience macro to make some casts easier to use.
 */

/*
 * Instance data for a reflected transformation. ===========================
 */

type TReflectedTransform = struct {
	Fchan1         TTcl_Channel
	Fparent        TTcl_Channel
	Finterp        uintptr
	Fhandle        uintptr
	Fthread        TTcl_ThreadId
	Ftimer         TTcl_TimerToken
	Fargc          int32
	Fargv          uintptr
	Fmethods       int32
	Fmode          int32
	Fnonblocking   int32
	FreadIsDrained int32
	FeofPending    int32
	Fdead          int32
	Fresult        TResultBuffer
}

/*
 * Structure of the table mapping from transform handles to reflected
 * transform (channels). Each interpreter which has the handler command for
 * one or more reflected transforms records them in such a table, so that we
 * are able to find them during interpreter/thread cleanup even if the actual
 * channel they belong to was moved to a different interpreter and/or thread.
 *
 * The table is reachable via the standard interpreter AssocData, the key is
 * defined below.
 */

type TReflectedTransformMap = struct {
	Fmap1 TTcl_HashTable
}

/*
 * Method literals. ==================================================
 */

var _methodNames1 = [9]uintptr{
	0: __ccgo_ts + 48485,
	1: __ccgo_ts + 48491,
	2: __ccgo_ts + 47133,
	3: __ccgo_ts + 5518,
	4: __ccgo_ts + 47142,
	5: __ccgo_ts + 48497,
	6: __ccgo_ts + 5552,
	7: __ccgo_ts + 44159,
	8: libc.UintptrFromInt32(0),
}

const METH_CLEAR = 0
const METH_DRAIN = 1
const METH_FINAL1 = 2
const METH_FLUSH = 3
const METH_INIT1 = 4
const METH_LIMIT = 5
const METH_WRITE1 = 7

const ForwardedClear = 0
const ForwardedClose1 = 1
const ForwardedDrain = 2
const ForwardedFlush = 3
const ForwardedInput1 = 4
const ForwardedLimit = 5
const ForwardedOutput1 = 6

/*
 * Operation specific parameter/result structures. (These are "subtypes" of
 * ForwardParamBase. Where an operation does not need any special types, it
 * has no "subtype" and just uses ForwardParamBase, as listed above.)
 */

type TForwardParamTransform = struct {
	Fbase TForwardParamBase
	Fbuf  uintptr
	Fsize TTcl_Size
}

type TForwardParamLimit = struct {
	Fbase TForwardParamBase
	Fmax  int32
}

/*
 * Now join all these together in a single union for convenience.
 */

type TForwardParam1 = struct {
	Ftransform   [0]TForwardParamTransform
	Flimit       [0]TForwardParamLimit
	Fbase        TForwardParamBase
	F__ccgo_pad3 [16]byte
}

/*
 * General event structure, with reference to operation specific data.
 */

type TForwardingEvent1 = struct {
	Fevent     TTcl_Event
	FresultPtr uintptr
	Fop        TForwardedOperation
	FrtPtr     uintptr
	Fparam     uintptr
}

type TThreadSpecificData6 = struct {
	FrtmPtr uintptr
}

var _dataKey5 TTcl_ThreadDataKey

/*
 * List of forwarded operations which have not completed yet, plus the mutex
 * to protect the access to this process global list.
 */

var _forwardList1 = libc.UintptrFromInt32(0)

var _rtForwardMutex TTcl_Mutex

/*
 * Global constant strings (messages). ==================
 * These string are used directly as bypass errors, thus they have to be valid
 * Tcl lists where the last element is the message itself. Hence the
 * list-quoting to keep the words of the message together. See also [x].
 */

var _msg_read_unsup = __ccgo_ts + 48504
var _msg_write_unsup = __ccgo_ts + 48539
var _msg_send_originlost1 = __ccgo_ts + 47314
var _msg_send_dstlost1 = __ccgo_ts + 47336
var _msg_dstlost1 = __ccgo_ts + 47349

/*
 * Operation codes for TransformFlush().
 */

/*
 * Main methods to plug into the 'chan' ensemble'. ==================
 */

/*
 *----------------------------------------------------------------------
 *
 * TclChanPushObjCmd --
 *
 *	This function is invoked to process the "chan push" Tcl command. See
 *	the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result. The handle of the new channel is placed in the
 *	interp result.
 *
 * Side effects:
 *	Creates a new channel.
 *
 *----------------------------------------------------------------------
 */

func XTclChanPushObjCmd(tls *libc.TLS, dummy497 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, chanObj, cmdObj, hPtr, modeObj, rtId, rtPtr, rtmPtr, v1, v10, v12, v13, v15, v17, v18, v19, v20, v21, v22, v23, v3, v5, v9 uintptr
	var methods, result, v6 int32
	var parentChan TTcl_Channel
	var v11, v14, v16, v2, v4 TTcl_Size
	var v7, v8 int64
	var _ /* cmdNameObj at bp+8 */ uintptr
	var _ /* isNew at bp+48 */ int32
	var _ /* listc at bp+16 */ TTcl_Size
	var _ /* listv at bp+24 */ uintptr
	var _ /* methIndex at bp+32 */ int32
	var _ /* mode at bp+0 */ int32
	var _ /* resObj at bp+40 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, chanObj, cmdObj, hPtr, methods, modeObj, parentChan, result, rtId, rtPtr, rtmPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v3, v4, v5, v6, v7, v8, v9
	/*
	 * Number of arguments...
	 */
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+48575)
		return int32(TCL_ERROR)
	}
	/*
	 * First argument is a channel handle.
	 */
	chanObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(1)*8))
	if (*TTcl_Obj)(unsafe.Pointer(chanObj)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(chanObj)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, chanObj, libc.UintptrFromInt32(0))
	}
	parentChan = XTcl_GetChannel(tls, interp, v1, bp)
	if parentChan == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	parentChan = XTcl_GetTopChannel(tls, parentChan)
	/*
	 * Second argument is command prefix, i.e. list of words, first word is
	 * name of handler command, other words are fixed arguments. Run the
	 * 'initialize' method to get the list of supported methods. Validate
	 * this.
	 */
	cmdObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(2)*8))
	/*
	 * Basic check that the command prefix truly is a list.
	 */
	if XTcl_ListObjIndex(tls, interp, cmdObj, 0, bp+8) != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Now create the transformation (channel).
	 */
	rtId = _NextHandle1(tls)
	rtPtr = _NewReflectedTransform(tls, interp, cmdObj, *(*int32)(unsafe.Pointer(bp)), rtId, parentChan)
	/*
	 * Invoke 'initialize' and validate that the handler is present and ok.
	 * Squash the transformation if not.
	 */
	modeObj = _DecodeEventMask1(tls, *(*int32)(unsafe.Pointer(bp)))
	/* assert modeObj.refCount == 1 */
	result = _InvokeTclMethod1(tls, rtPtr, __ccgo_ts+47142, modeObj, libc.UintptrFromInt32(0), bp+40)
	_objPtr = modeObj
	v3 = _objPtr
	v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
	*(*TTcl_Size)(unsafe.Pointer(v3))--
	if v2 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	if result != TCL_OK {
		_UnmarshallErrorResult1(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 40)))
		_objPtr1 = *(*uintptr)(unsafe.Pointer(bp + 40))
		v5 = _objPtr1
		v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
		*(*TTcl_Size)(unsafe.Pointer(v5))--
		if v4 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		} /* Remove reference held from invoke */
		goto error
	}
	/*
	 * Verify the result.
	 * - List, of method names. Convert to mask. Check for non-optionals
	 *   through the mask. Compare open mode against optional r/w.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr2 != 0 {
			v7 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr2)).FspanStart
		} else {
			v7 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 24)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr1 + 40 + uintptr(v7)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr2 != 0 {
			v8 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr2)).FspanLength
		} else {
			v8 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = v8
		v6 = libc.Int32FromInt32(TCL_OK)
	} else {
		v6 = XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 40)), bp+16, bp+24)
	}
	if v6 != TCL_OK {
		if (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes != 0 {
			v9 = (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes
		} else {
			v9 = XTcl_GetStringFromObj(tls, cmdObj, libc.UintptrFromInt32(0))
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).Fbytes != 0 {
			v10 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).Fbytes
		} else {
			v10 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 40)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+47437, libc.VaList(bp+64, v9, v10)))
		_objPtr2 = *(*uintptr)(unsafe.Pointer(bp + 40))
		v12 = _objPtr2
		v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
		*(*TTcl_Size)(unsafe.Pointer(v12))--
		if v11 <= int64(1) {
			XTclFreeObj(tls, _objPtr2)
		}
		goto error
	}
	methods = 0
	for *(*TTcl_Size)(unsafe.Pointer(bp + 16)) > 0 {
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 16))-int64(1))*8)), uintptr(unsafe.Pointer(&_methodNames1)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+28559, libc.Int32FromInt32(TCL_EXACT)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+32) != TCL_OK {
			if (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes != 0 {
				v13 = (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes
			} else {
				v13 = XTcl_GetStringFromObj(tls, cmdObj, libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+48593, libc.VaList(bp+64, v13, XTcl_GetStringFromObj(tls, XTcl_GetObjResult(tls, interp), libc.UintptrFromInt32(0)))))
			_objPtr3 = *(*uintptr)(unsafe.Pointer(bp + 40))
			v15 = _objPtr3
			v14 = *(*TTcl_Size)(unsafe.Pointer(v15))
			*(*TTcl_Size)(unsafe.Pointer(v15))--
			if v14 <= int64(1) {
				XTclFreeObj(tls, _objPtr3)
			}
			goto error
		}
		methods |= int32(1) << *(*int32)(unsafe.Pointer(bp + 32))
		*(*TTcl_Size)(unsafe.Pointer(bp + 16))--
	}
	_objPtr4 = *(*uintptr)(unsafe.Pointer(bp + 40))
	v17 = _objPtr4
	v16 = *(*TTcl_Size)(unsafe.Pointer(v17))
	*(*TTcl_Size)(unsafe.Pointer(v17))--
	if v16 <= int64(1) {
		XTclFreeObj(tls, _objPtr4)
	}
	if (libc.Int32FromInt32(1)<<int32(METH_INIT1)|libc.Int32FromInt32(1)<<int32(METH_FINAL1))&methods != libc.Int32FromInt32(1)<<int32(METH_INIT1)|libc.Int32FromInt32(1)<<int32(METH_FINAL1) {
		if (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes != 0 {
			v18 = (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes
		} else {
			v18 = XTcl_GetStringFromObj(tls, cmdObj, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+47526, libc.VaList(bp+64, v18)))
		goto error
	}
	/*
	 * Mode tell us what the parent channel supports. The methods tell us what
	 * the handler supports. We remove the non-supported bits from the mode
	 * and check that the channel is not completely inaccessible. Afterward the
	 * mode tells us which methods are still required, and these methods will
	 * also be supported by the handler, by design of the check.
	 */
	if !(methods&(libc.Int32FromInt32(1)<<int32(METH_READ)) != 0) {
		*(*int32)(unsafe.Pointer(bp)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(1))
	}
	if !(methods&(libc.Int32FromInt32(1)<<int32(METH_WRITE1)) != 0) {
		*(*int32)(unsafe.Pointer(bp)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(2))
	}
	if !(*(*int32)(unsafe.Pointer(bp)) != 0) {
		if (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes != 0 {
			v19 = (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes
		} else {
			v19 = XTcl_GetStringFromObj(tls, cmdObj, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+48634, libc.VaList(bp+64, v19)))
		goto error
	}
	/*
	 * The mode and support for it is ok, now check the internal constraints.
	 */
	if !(!(methods&(libc.Int32FromInt32(1)<<int32(METH_DRAIN)) != 0) || methods&(libc.Int32FromInt32(1)<<int32(METH_READ)) != 0) {
		if (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes != 0 {
			v20 = (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes
		} else {
			v20 = XTcl_GetStringFromObj(tls, cmdObj, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+48683, libc.VaList(bp+64, v20)))
		goto error
	}
	if !(!(methods&(libc.Int32FromInt32(1)<<int32(METH_FLUSH)) != 0) || methods&(libc.Int32FromInt32(1)<<int32(METH_WRITE1)) != 0) {
		if (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes != 0 {
			v21 = (*TTcl_Obj)(unsafe.Pointer(cmdObj)).Fbytes
		} else {
			v21 = XTcl_GetStringFromObj(tls, cmdObj, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+48733, libc.VaList(bp+64, v21)))
		goto error
	}
	XTcl_ResetResult(tls, interp)
	/*
	 * Everything is fine now.
	 */
	(*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fmethods = methods
	(*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fmode = *(*int32)(unsafe.Pointer(bp))
	(*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fchan1 = XTcl_StackChannel(tls, interp, uintptr(unsafe.Pointer(&_reflectedTransformType)), rtPtr, *(*int32)(unsafe.Pointer(bp)), (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fparent)
	/*
	 * Register the transform in our map for proper handling of deleted
	 * interpreters and/or threads.
	 */
	rtmPtr = _GetReflectedTransformMap(tls, interp)
	if (*TTcl_Obj)(unsafe.Pointer(rtId)).Fbytes != 0 {
		v22 = (*TTcl_Obj)(unsafe.Pointer(rtId)).Fbytes
	} else {
		v22 = XTcl_GetStringFromObj(tls, rtId, libc.UintptrFromInt32(0))
	}
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(rtmPtr)).FcreateProc})))(tls, rtmPtr, v22, bp+48)
	if !(*(*int32)(unsafe.Pointer(bp + 48)) != 0) && rtPtr != (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData {
		XTcl_Panic(tls, __ccgo_ts+48784, 0)
	}
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = rtPtr
	rtmPtr = _GetThreadReflectedTransformMap(tls)
	if (*TTcl_Obj)(unsafe.Pointer(rtId)).Fbytes != 0 {
		v23 = (*TTcl_Obj)(unsafe.Pointer(rtId)).Fbytes
	} else {
		v23 = XTcl_GetStringFromObj(tls, rtId, libc.UintptrFromInt32(0))
	}
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(rtmPtr)).FcreateProc})))(tls, rtmPtr, v23, bp+48)
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = rtPtr
	/*
	 * Return the channel as the result of the command.
	 */
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, XTcl_GetChannelName(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fchan1), int64(-int32(1))))
	return TCL_OK
	goto error
error:
	;
	/*
	 * We are not going through ReflectClose as we never had a channel
	 * structure.
	 */
	XTcl_EventuallyFree(tls, rtPtr, __ccgo_fp(_FreeReflectedTransform))
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * TclChanPopObjCmd --
 *
 *	This function is invoked to process the "chan pop" Tcl command. See
 *	the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Posts events to a reflected channel, invokes event handlers. The
 *	latter implies that arbitrary side effects are possible.
 *
 *----------------------------------------------------------------------
 */

func XTclChanPopObjCmd(tls *libc.TLS, dummy740 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var chan1 TTcl_Channel
	var chanId, v1 uintptr
	var _ /* mode at bp+0 */ int32
	_, _, _ = chan1, chanId, v1 /* Channel r/w mode */
	/*
	 * Number of arguments...
	 */
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+42889)
		return int32(TCL_ERROR)
	}
	/*
	 * First argument is a channel, which may have a (reflected)
	 * transformation.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(1)*8)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(1)*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(1)*8)), libc.UintptrFromInt32(0))
	}
	chanId = v1
	chan1 = XTcl_GetChannel(tls, interp, chanId, bp)
	if chan1 == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Removing transformations is generic, and not restricted to reflected
	 * transformations.
	 */
	XTcl_UnstackChannel(tls, interp, chan1)
	return TCL_OK
}

/*
 * Channel error message marshalling utilities.
 */

func _MarshallError1(tls *libc.TLS, interp uintptr) (r uintptr) {
	var returnOpt uintptr
	_ = returnOpt
	/*
	 * Capture the result status of the interpreter into a string. => List of
	 * options and values, followed by the error message. The result has
	 * refCount 0.
	 */
	returnOpt = XTcl_GetReturnOptions(tls, interp, int32(TCL_ERROR))
	/*
	 * => returnOpt.refCount == 0. We can append directly.
	 */
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), returnOpt, XTcl_GetObjResult(tls, interp))
	return returnOpt
}

func _UnmarshallErrorResult1(tls *libc.TLS, interp uintptr, msgObj uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var explicitResult, v1 int32
	var numOptions TTcl_Size
	var v2, v3 int64
	var _ /* lc at bp+0 */ TTcl_Size
	var _ /* lv at bp+8 */ uintptr
	_, _, _, _, _ = explicitResult, numOptions, v1, v2, v3
	/*
	 * Process the caught message.
	 *
	 * Syntax = (option value)... ?message?
	 *
	 * Bad syntax causes a panic. This is OK because the other side uses
	 * Tcl_GetReturnOptions and list construction functions to marshall the
	 * information; if we panic here, something has gone badly wrong already.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(msgObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(msgObj + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(msgObj + 32))).Fptr2)).FspanStart
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(msgObj + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(msgObj + 32))).Fptr1 + 40 + uintptr(v2)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(msgObj + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(msgObj + 32))).Fptr2)).FspanLength
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(msgObj + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v3
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjGetElements(tls, interp, msgObj, bp, bp+8)
	}
	if v1 != TCL_OK {
		XTcl_Panic(tls, __ccgo_ts+48088, 0)
	}
	if interp == libc.UintptrFromInt32(0) {
		return
	}
	explicitResult = int32(*(*TTcl_Size)(unsafe.Pointer(bp)) & int64(1)) /* Odd number of values? */
	numOptions = *(*TTcl_Size)(unsafe.Pointer(bp)) - int64(explicitResult)
	if explicitResult != 0 {
		XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp))-int64(1))*8)))
	}
	XTcl_SetReturnOptions(tls, interp, XTcl_NewListObj(tls, numOptions, *(*uintptr)(unsafe.Pointer(bp + 8))))
	*(*int32)(unsafe.Pointer(interp + 368)) &= ^libc.Int32FromInt32(ERR_ALREADY_LOGGED)
}

/*
 * Driver functions. ================================================
 */

/*
 *----------------------------------------------------------------------
 *
 * ReflectClose --
 *
 *	This function is invoked when the channel is closed, to delete the
 *	driver specific instance data.
 *
 * Results:
 *	A Posix error.
 *
 * Side effects:
 *	Releases memory. Arbitrary, as it calls upon a script.
 *
 *----------------------------------------------------------------------
 */

func _ReflectClose1(tls *libc.TLS, clientData uintptr, interp uintptr, flags int32) (r int32) {
	bp := tls.Alloc(96)
	defer tls.Free(96)
	var _objPtr, hPtr, rtPtr, rtmPtr, v2, v3, v4 uintptr
	var errorCodeSet, result, v5, v6 int32
	var v1 TTcl_Size
	var _ /* errorCode at bp+0 */ int32
	var _ /* p at bp+16 */ TForwardParam1
	var _ /* p at bp+56 */ TForwardParam1
	var _ /* resObj at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, errorCodeSet, hPtr, result, rtPtr, rtmPtr, v1, v2, v3, v4, v5, v6
	rtPtr = clientData
	errorCodeSet = 0
	result = TCL_OK /* Entry in the above map */
	if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
		return int32(EINVAL)
	}
	if XTclInThreadExit(tls) != 0 {
		/*
		 * This call comes from TclFinalizeIOSystem. There are no
		 * interpreters, and therefore we cannot call upon the handler command
		 * anymore. Threading is irrelevant as well. We simply clean up all
		 * our C level data structures and leave the Tcl level to the other
		 * finalization functions.
		 */
		/*
		 * THREADED => Forward this to the origin thread
		 *
		 * Note: DeleteThreadReflectedTransformMap() is the thread exit handler
		 * for the origin thread. Use this to clean up the structure? Except
		 * if lost?
		 */
		if (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fthread != XTcl_GetCurrentThread(tls) {
			_ForwardOpToOwnerThread(tls, rtPtr, int32(ForwardedClose1), bp+16)
			result = (*(*TForwardParam1)(unsafe.Pointer(bp + 16))).Fbase.Fcode
			if result != TCL_OK {
				if (*TForwardParam1)(unsafe.Pointer(bp+16)).Fbase.FmustFree != 0 {
					XTclpFree(tls, (*TForwardParam1)(unsafe.Pointer(bp+16)).Fbase.FmsgStr)
				}
			}
		}
		XTcl_EventuallyFree(tls, rtPtr, __ccgo_fp(_FreeReflectedTransform))
		return EOK
	}
	/*
	 * In the reflected channel implementation a cleaned method mask here
	 * implies that the channel creation was aborted, and "finalize" must not
	 * be called. for transformations however we are not going through here on
	 * such an abort, but directly through FreeReflectedTransform. So for us
	 * that check is not necessary. We always go through 'finalize'.
	 */
	if (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fmethods&(libc.Int32FromInt32(1)<<int32(METH_DRAIN)) != 0 && !((*TReflectedTransform)(unsafe.Pointer(rtPtr)).FreadIsDrained != 0) {
		if !(_TransformDrain(tls, rtPtr, bp) != 0) {
			if (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fthread != XTcl_GetCurrentThread(tls) {
				XTcl_EventuallyFree(tls, rtPtr, __ccgo_fp(_FreeReflectedTransform))
				return *(*int32)(unsafe.Pointer(bp))
			}
			errorCodeSet = int32(1)
			goto cleanup
		}
	}
	if (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fmethods&(libc.Int32FromInt32(1)<<int32(METH_FLUSH)) != 0 {
		if !(_TransformFlush(tls, rtPtr, bp, int32(FLUSH_WRITE)) != 0) {
			if (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fthread != XTcl_GetCurrentThread(tls) {
				XTcl_EventuallyFree(tls, rtPtr, __ccgo_fp(_FreeReflectedTransform))
				return *(*int32)(unsafe.Pointer(bp))
			}
			errorCodeSet = int32(1)
			goto cleanup
		}
	}
	/*
	 * Are we in the correct thread?
	 */
	if (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fthread != XTcl_GetCurrentThread(tls) {
		_ForwardOpToOwnerThread(tls, rtPtr, int32(ForwardedClose1), bp+56)
		result = (*(*TForwardParam1)(unsafe.Pointer(bp + 56))).Fbase.Fcode
		XTcl_EventuallyFree(tls, rtPtr, __ccgo_fp(_FreeReflectedTransform))
		if result != TCL_OK {
			if interp != libc.UintptrFromInt32(0) {
				XTcl_SetChannelErrorInterp(tls, interp, XTcl_NewStringObj(tls, (*TForwardParam1)(unsafe.Pointer(bp+56)).Fbase.FmsgStr, int64(-int32(1))))
			}
			if (*TForwardParam1)(unsafe.Pointer(bp+56)).Fbase.FmustFree != 0 {
				XTclpFree(tls, (*TForwardParam1)(unsafe.Pointer(bp+56)).Fbase.FmsgStr)
			}
			return int32(EINVAL)
		}
		return EOK
	}
	/*
	 * Do the actual invocation of "finalize" now; we're in the right thread.
	 */
	result = _InvokeTclMethod1(tls, rtPtr, __ccgo_ts+47133, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), bp+8)
	if result != TCL_OK && interp != libc.UintptrFromInt32(0) {
		XTcl_SetChannelErrorInterp(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 8)))
	}
	_objPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	} /* Remove reference we held from the
	 * invoke. */
	goto cleanup
cleanup:
	;
	/*
	 * Remove the transform from the map before releasing the memory, to
	 * prevent future accesses from finding and dereferencing a dangling
	 * pointer.
	 *
	 * NOTE: The transform may not be in the map. This is ok, that happens
	 * when the transform was created in a different interpreter and/or thread
	 * and then was moved here.
	 *
	 * NOTE: The channel may have been removed from the map already via
	 * the per-interp DeleteReflectedTransformMap exit-handler.
	 */
	if !((*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fdead != 0) {
		rtmPtr = _GetReflectedTransformMap(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Finterp)
		if (*TTcl_Obj)(unsafe.Pointer((*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fhandle)).Fbytes != 0 {
			v3 = (*TTcl_Obj)(unsafe.Pointer((*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fhandle)).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fhandle, libc.UintptrFromInt32(0))
		}
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(rtmPtr)).FfindProc})))(tls, rtmPtr, v3)
		if hPtr != 0 {
			XTcl_DeleteHashEntry(tls, hPtr)
		}
		/*
		 * In a threaded interpreter we manage a per-thread map as well,
		 * to allow us to survive if the script level pulls the rug out
		 * under a channel by deleting the owning thread.
		 */
		rtmPtr = _GetThreadReflectedTransformMap(tls)
		if (*TTcl_Obj)(unsafe.Pointer((*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fhandle)).Fbytes != 0 {
			v4 = (*TTcl_Obj)(unsafe.Pointer((*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fhandle)).Fbytes
		} else {
			v4 = XTcl_GetStringFromObj(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fhandle, libc.UintptrFromInt32(0))
		}
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(rtmPtr)).FfindProc})))(tls, rtmPtr, v4)
		if hPtr != 0 {
			XTcl_DeleteHashEntry(tls, hPtr)
		}
	}
	XTcl_EventuallyFree(tls, rtPtr, __ccgo_fp(_FreeReflectedTransform))
	if errorCodeSet != 0 {
		v5 = *(*int32)(unsafe.Pointer(bp))
	} else {
		if result == TCL_OK {
			v6 = EOK
		} else {
			v6 = int32(EINVAL)
		}
		v5 = v6
	}
	return v5
}

/*
 *----------------------------------------------------------------------
 *
 * ReflectInput --
 *
 *	This function is invoked when more data is requested from the channel.
 *
 * Results:
 *	The number of bytes read.
 *
 * Side effects:
 *	Allocates memory. Arbitrary, as it calls upon a script.
 *
 *----------------------------------------------------------------------
 */

func _ReflectInput1(tls *libc.TLS, clientData uintptr, buf uintptr, toRead int32, errorCodePtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, _objPtr1, bufObj, cachePtr, rtPtr, v2, v5 uintptr
	var copied, gotBytes, readBytes int32
	var v1, v4 TTcl_Size
	var v3 bool
	var _ /* maxRead at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, bufObj, cachePtr, copied, gotBytes, readBytes, rtPtr, v1, v2, v3, v4, v5
	rtPtr = clientData
	/*
	 * The following check can be done before thread redirection, because we
	 * are reading from an item which is readonly, i.e. will never change
	 * during the lifetime of the channel.
	 */
	if !((*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fmethods&(libc.Int32FromInt32(1)<<int32(METH_READ)) != 0) {
		XTcl_SetChannelError(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fchan1, XTcl_NewStringObj(tls, _msg_read_unsup, int64(-int32(1))))
		*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(EINVAL)
		return -int32(1)
	}
	XTcl_Preserve(tls, rtPtr)
	/* TODO: Consider a more appropriate buffer size. */
	bufObj = XTcl_NewByteArrayObj(tls, libc.UintptrFromInt32(0), int64(toRead))
	(*TTcl_Obj)(unsafe.Pointer(bufObj)).FrefCount++
	gotBytes = 0
	if (*TReflectedTransform)(unsafe.Pointer(rtPtr)).FeofPending != 0 {
		goto stop
	}
	(*TReflectedTransform)(unsafe.Pointer(rtPtr)).FreadIsDrained = 0
	for toRead > 0 {
		/*
		 * Loop until the request is satisfied (or no data available from
		 * below, possibly EOF).
		 */
		copied = libc.Int32FromUint64(_ResultCopy(tls, rtPtr+88, buf, libc.Uint64FromInt32(toRead)))
		toRead -= copied
		buf += uintptr(copied)
		gotBytes += copied
		if toRead == 0 {
			goto stop
		}
		if (*TReflectedTransform)(unsafe.Pointer(rtPtr)).FeofPending != 0 {
			goto stop
		}
		/*
		 * The buffer is exhausted, but the caller wants even more. We now
		 * have to go to the underlying channel, get more bytes and then
		 * transform them for delivery. We may not get what we want (full EOF
		 * or temporarily out of data).
		 *
		 * Length (rtPtr->result) == 0, toRead > 0 here. Use 'buf'! as target
		 * to store the intermediary information read from the parent channel.
		 *
		 * Ask the transform how much data it allows us to read from the
		 * underlying channel. This feature allows the transform to signal EOF
		 * upstream although there is none downstream. Useful to control an
		 * unbounded 'fcopy' for example, either through counting bytes, or by
		 * pattern matching.
		 */
		if (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fmethods&(libc.Int32FromInt32(1)<<int32(METH_LIMIT)) != 0 {
			*(*int32)(unsafe.Pointer(bp)) = -int32(1)
			if !(_TransformLimit(tls, rtPtr, errorCodePtr, bp) != 0) {
				goto error
			}
			if *(*int32)(unsafe.Pointer(bp)) == 0 {
				goto stop
			} else {
				if *(*int32)(unsafe.Pointer(bp)) > 0 {
					if *(*int32)(unsafe.Pointer(bp)) < toRead {
						toRead = *(*int32)(unsafe.Pointer(bp))
					}
				}
			} /* else: 'maxRead < 0' == Accept the current value of toRead */
		}
		if toRead <= 0 {
			goto stop
		}
		readBytes = int32(XTcl_ReadRaw(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fparent, XTcl_SetByteArrayLength(tls, bufObj, int64(toRead)), int64(toRead)))
		if readBytes < 0 {
			if XTcl_InputBlocked(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fparent) != 0 && gotBytes > 0 {
				/*
				 * Down channel is blocked and offers zero additional bytes.
				 * The nonzero gotBytes already returned makes the total
				 * operation a valid short read.  Return to caller.
				 */
				goto stop
			}
			/*
			 * Either the down channel is not blocked (a real error)
			 * or it is and there are gotBytes==0 byte copied so far.
			 * In either case, pass up the error, so we either report
			 * any real error, or do not mistakenly signal EOF by
			 * returning 0 to the caller.
			 */
			*(*int32)(unsafe.Pointer(errorCodePtr)) = XTcl_GetErrno(tls)
			goto error
		}
		if readBytes == 0 {
			/*
			 * Zero returned from Tcl_ReadRaw() always indicates EOF
			 * on the down channel.
			 */
			(*TReflectedTransform)(unsafe.Pointer(rtPtr)).FeofPending = int32(1)
			/*
			 * Now this is a bit different. The partial data waiting is
			 * converted and returned.
			 */
			if (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fmethods&(libc.Int32FromInt32(1)<<int32(METH_DRAIN)) != 0 {
				if !(_TransformDrain(tls, rtPtr, errorCodePtr) != 0) {
					goto error
				}
			}
			if (*TResultBuffer)(unsafe.Pointer(rtPtr+88)).Fused == uint64(0) {
				/*
				 * The drain delivered nothing.
				 */
				goto stop
			}
			continue /* at: while (toRead > 0) */
		} /* readBytes == 0 */
		/*
		 * Transform the read chunk, which was not empty. Anything we got back
		 * is a transformation result is put into our buffers, and the next
		 * iteration will put it into the result.
		 */
		XTcl_SetByteArrayLength(tls, bufObj, int64(readBytes))
		if !(_TransformRead(tls, rtPtr, errorCodePtr, bufObj) != 0) {
			goto error
		}
		if (*TTcl_Obj)(unsafe.Pointer(bufObj)).FrefCount > int64(1) {
			_objPtr = bufObj
			v2 = _objPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if v1 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				bufObj = XTclThreadAllocObj(tls)
			} else {
				bufObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(bufObj + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(bufObj)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(bufObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(bufObj)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(bufObj)).FtypePtr = libc.UintptrFromInt32(0)
			(*TTcl_Obj)(unsafe.Pointer(bufObj)).FrefCount++
		}
		XTcl_SetByteArrayLength(tls, bufObj, 0)
	} /* while toRead > 0 */
	goto stop
stop:
	;
	if gotBytes == 0 {
		(*TReflectedTransform)(unsafe.Pointer(rtPtr)).FeofPending = 0
	}
	_objPtr1 = bufObj
	v5 = _objPtr1
	v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
	*(*TTcl_Size)(unsafe.Pointer(v5))--
	if v4 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	XTcl_Release(tls, rtPtr)
	return gotBytes
	goto error
error:
	;
	gotBytes = -int32(1)
	goto stop
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * ReflectOutput --
 *
 *	This function is invoked when data is written to the channel.
 *
 * Results:
 *	The number of bytes actually written.
 *
 * Side effects:
 *	Allocates memory. Arbitrary, as it calls upon a script.
 *
 *----------------------------------------------------------------------
 */

func _ReflectOutput1(tls *libc.TLS, clientData uintptr, buf uintptr, toWrite int32, errorCodePtr uintptr) (r int32) {
	var rtPtr uintptr
	_ = rtPtr
	rtPtr = clientData
	/*
	 * The following check can be done before thread redirection, because we
	 * are reading from an item which is readonly, i.e. will never change
	 * during the lifetime of the channel.
	 */
	if !((*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fmethods&(libc.Int32FromInt32(1)<<int32(METH_WRITE1)) != 0) {
		XTcl_SetChannelError(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fchan1, XTcl_NewStringObj(tls, _msg_write_unsup, int64(-int32(1))))
		*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(EINVAL)
		return -int32(1)
	}
	if toWrite == 0 {
		/*
		 * Nothing came in to write, ignore the call
		 */
		return 0
	}
	/*
	 * Discard partial data in the input buffers, i.e. on the read side. Like
	 * we do when explicitly seeking as well.
	 */
	XTcl_Preserve(tls, rtPtr)
	if (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fmethods&(libc.Int32FromInt32(1)<<int32(METH_CLEAR)) != 0 {
		_TransformClear(tls, rtPtr)
	}
	/*
	 * Hand the data to the transformation itself. Anything it deigned to
	 * return to us is a (partial) transformation result and written to the
	 * parent channel for further processing.
	 */
	if !(_TransformWrite(tls, rtPtr, errorCodePtr, buf, toWrite) != 0) {
		XTcl_Release(tls, rtPtr)
		return -int32(1)
	}
	*(*int32)(unsafe.Pointer(errorCodePtr)) = EOK
	XTcl_Release(tls, rtPtr)
	return toWrite
}

/*
 *----------------------------------------------------------------------
 *
 * ReflectSeekWide / ReflectSeek --
 *
 *	This function is invoked when the user wishes to seek on the channel.
 *
 * Results:
 *	The new location of the access point.
 *
 * Side effects:
 *	Allocates memory. Arbitrary, per the parent channel, and the called
 *	scripts.
 *
 *----------------------------------------------------------------------
 */

func _ReflectSeekWide1(tls *libc.TLS, clientData uintptr, offset int64, seekMode int32, errorCodePtr uintptr) (r int64) {
	var curPos TTcl_WideInt
	var parent, rtPtr uintptr
	_, _, _ = curPos, parent, rtPtr
	rtPtr = clientData
	parent = (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fparent /* Position on the device. */
	/*
	 * Check if we can leave out involving the Tcl level, i.e. transformation
	 * handler. This is true for tell requests, and transformations which
	 * support neither flush, nor drain. For these cases we can pass the
	 * request down and the result back up unchanged.
	 */
	XTcl_Preserve(tls, rtPtr)
	if (seekMode != int32(1) || offset != 0) && ((*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fmethods&(libc.Int32FromInt32(1)<<int32(METH_CLEAR)) != 0 || (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fmethods&(libc.Int32FromInt32(1)<<int32(METH_FLUSH)) != 0) {
		/*
		 * Neither a tell request, nor clear/flush both not supported. We have
		 * to go through the Tcl level to clear and/or flush the
		 * transformation.
		 */
		if (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fmethods&(libc.Int32FromInt32(1)<<int32(METH_CLEAR)) != 0 {
			_TransformClear(tls, rtPtr)
		}
		/*
		 * When flushing the transform for seeking the generated results are
		 * irrelevant. We cannot put them into the channel, this would move
		 * the location, throwing it off with regard to where we are and are
		 * seeking to.
		 */
		if (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fmethods&(libc.Int32FromInt32(1)<<int32(METH_FLUSH)) != 0 {
			if !(_TransformFlush(tls, rtPtr, errorCodePtr, FLUSH_DISCARD) != 0) {
				XTcl_Release(tls, rtPtr)
				return int64(-int32(1))
			}
		}
	}
	/*
	 * Now seek to the new position in the channel as requested by the
	 * caller. Note that we prefer the wideSeekProc if that is available and
	 * non-NULL...
	 */
	if XTcl_ChannelWideSeekProc(tls, (*TChannel)(unsafe.Pointer(parent)).FtypePtr) == libc.UintptrFromInt32(0) {
		*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(EINVAL)
		curPos = int64(-int32(1))
	} else {
		curPos = (*(*func(*libc.TLS, uintptr, int64, int32, uintptr) int64)(unsafe.Pointer(&struct{ uintptr }{XTcl_ChannelWideSeekProc(tls, (*TChannel)(unsafe.Pointer(parent)).FtypePtr)})))(tls, (*TChannel)(unsafe.Pointer(parent)).FinstanceData, offset, seekMode, errorCodePtr)
	}
	if curPos == int64(-int32(1)) {
		XTcl_SetErrno(tls, *(*int32)(unsafe.Pointer(errorCodePtr)))
	}
	*(*int32)(unsafe.Pointer(errorCodePtr)) = EOK
	XTcl_Release(tls, rtPtr)
	return curPos
}

/*
 *----------------------------------------------------------------------
 *
 * ReflectWatch --
 *
 *	This function is invoked to tell the channel what events the I/O
 *	system is interested in.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Allocates memory. Arbitrary, as it calls upon a script.
 *
 *----------------------------------------------------------------------
 */

func _ReflectWatch1(tls *libc.TLS, clientData uintptr, mask int32) {
	var rtPtr, watchProc uintptr
	_, _ = rtPtr, watchProc
	rtPtr = clientData
	watchProc = XTcl_ChannelWatchProc(tls, XTcl_GetChannelType(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fparent))
	(*(*func(*libc.TLS, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{watchProc})))(tls, XTcl_GetChannelInstanceData(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fparent), mask)
	/*
	 * Management of the internal timer.
	 */
	if !(mask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0) || (*TResultBuffer)(unsafe.Pointer(rtPtr+88)).Fused == uint64(0) {
		/*
		 * A pending timer may exist, but either is there no (more) interest
		 * in the events it generates or nothing is available for reading.
		 * Remove it, if existing.
		 */
		_TimerKill(tls, rtPtr)
	} else {
		/*
		 * There might be no pending timer, but there is interest in readable
		 * events and we actually have data waiting, so generate a timer to
		 * flush that if it does not exist.
		 */
		_TimerSetup(tls, rtPtr)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * ReflectBlock --
 *
 *	This function is invoked to tell the channel which blocking behaviour
 *	is required of it.
 *
 * Results:
 *	A Posix error number.
 *
 * Side effects:
 *	Allocates memory. Arbitrary, as it calls upon a script.
 *
 *----------------------------------------------------------------------
 */

func _ReflectBlock1(tls *libc.TLS, clientData uintptr, nonblocking int32) (r int32) {
	var rtPtr uintptr
	_ = rtPtr
	rtPtr = clientData
	/*
	 * Transformations simply record the blocking mode in their C level
	 * structure for use by --> ReflectInput. The Tcl level doesn't see this
	 * information or change. As such thread forwarding is not required.
	 */
	(*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fnonblocking = nonblocking
	return EOK
}

/*
 *----------------------------------------------------------------------
 *
 * ReflectSetOption --
 *
 *	This function is invoked to configure a channel option.
 *
 * Results:
 *	A standard Tcl result code.
 *
 * Side effects:
 *	Arbitrary, per the parent channel.
 *
 *----------------------------------------------------------------------
 */

func _ReflectSetOption1(tls *libc.TLS, clientData uintptr, interp uintptr, optionName uintptr, newValue uintptr) (r int32) {
	/* The new value */
	var rtPtr, setOptionProc uintptr
	_, _ = rtPtr, setOptionProc
	rtPtr = clientData
	/*
	 * Transformations have no options. Thus the call is passed down unchanged
	 * to the parent channel for processing. Its results are passed back
	 * unchanged as well. This all happens in the thread we are in. As the Tcl
	 * level is not involved there is no need for thread forwarding.
	 */
	setOptionProc = XTcl_ChannelSetOptionProc(tls, XTcl_GetChannelType(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fparent))
	if setOptionProc == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	return (*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{setOptionProc})))(tls, XTcl_GetChannelInstanceData(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fparent), interp, optionName, newValue)
}

/*
 *----------------------------------------------------------------------
 *
 * ReflectGetOption --
 *
 *	This function is invoked to retrieve all or a channel options.
 *
 * Results:
 *	A standard Tcl result code.
 *
 * Side effects:
 *	Arbitrary, per the parent channel.
 *
 *----------------------------------------------------------------------
 */

func _ReflectGetOption1(tls *libc.TLS, clientData uintptr, interp uintptr, optionName uintptr, dsPtr uintptr) (r int32) {
	/* String to place the result into */
	var getOptionProc, rtPtr uintptr
	_, _ = getOptionProc, rtPtr
	rtPtr = clientData
	/*
	 * Transformations have no options. Thus the call is passed down unchanged
	 * to the parent channel for processing. Its results are passed back
	 * unchanged as well. This all happens in the thread we are in. As the Tcl
	 * level is not involved there is no need for thread forwarding.
	 *
	 * Note that the parent not having a driver for option retrieval is not an
	 * immediate error. A query for all options is ok. Only a request for a
	 * specific option has to fail.
	 */
	getOptionProc = XTcl_ChannelGetOptionProc(tls, XTcl_GetChannelType(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fparent))
	if getOptionProc != libc.UintptrFromInt32(0) {
		return (*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{getOptionProc})))(tls, XTcl_GetChannelInstanceData(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fparent), interp, optionName, dsPtr)
	} else {
		if optionName == libc.UintptrFromInt32(0) {
			return TCL_OK
		} else {
			return int32(TCL_ERROR)
		}
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * ReflectHandle --
 *
 *	This function is invoked to retrieve the associated file handle.
 *
 * Results:
 *	A standard Tcl result code.
 *
 * Side effects:
 *	Arbitrary, per the parent channel.
 *
 *----------------------------------------------------------------------
 */

func _ReflectHandle(tls *libc.TLS, clientData uintptr, direction int32, handlePtr uintptr) (r int32) {
	var rtPtr uintptr
	_ = rtPtr
	rtPtr = clientData
	/*
	 * Transformations have no handle of their own. As such we simply query
	 * the parent channel for it. This way the query will ripple down through
	 * all transformations until reaches the base channel. Which then returns
	 * its handle, or fails. The former will then ripple up the stack.
	 *
	 * This all happens in the thread we are in. As the Tcl level is not
	 * involved no forwarding is required.
	 */
	return XTcl_GetChannelHandle(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fparent, direction, handlePtr)
}

/*
 *----------------------------------------------------------------------
 *
 * ReflectNotify --
 *
 *	This function is invoked to reported incoming events.
 *
 * Results:
 *	A standard Tcl result code.
 *
 * Side effects:
 *	Arbitrary, per the parent channel.
 *
 *----------------------------------------------------------------------
 */

func _ReflectNotify(tls *libc.TLS, clientData uintptr, mask int32) (r int32) {
	var rtPtr uintptr
	_ = rtPtr
	rtPtr = clientData
	/*
	 * An event occurred in the underlying channel.
	 *
	 * We delete our timer. It was not fired, yet we are here, so the channel
	 * below generated such an event and we don't have to. The renewal of the
	 * interest after the execution of channel handlers will eventually cause
	 * us to recreate the timer (in ReflectWatch).
	 */
	_TimerKill(tls, rtPtr)
	/*
	 * Pass to higher layers.
	 */
	return mask
}

/*
 * Helpers. =========================================================
 */

/*
 *----------------------------------------------------------------------
 *
 * DecodeEventMask --
 *
 *	This function takes an internal bitmask of events and constructs the
 *	equivalent list of event items.
 *
 * Results:
 *	A Tcl_Obj reference. The object will have a refCount of one. The user
 *	has to decrement it to release the object.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 * DUPLICATE of 'DecodeEventMask' in tclIORChan.c
 */

func _DecodeEventMask1(tls *libc.TLS, mask int32) (r uintptr) {
	var evObj, eventStr uintptr
	_, _ = evObj, eventStr
	switch mask & (libc.Int32FromInt32(1)<<libc.Int32FromInt32(1) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) {
	case libc.Int32FromInt32(1)<<libc.Int32FromInt32(1) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(2):
		eventStr = __ccgo_ts + 48240
	case libc.Int32FromInt32(1) << libc.Int32FromInt32(1):
		eventStr = __ccgo_ts + 5552
	case libc.Int32FromInt32(1) << libc.Int32FromInt32(2):
		eventStr = __ccgo_ts + 44159
	default:
		eventStr = __ccgo_ts + 1945
		break
	}
	evObj = XTcl_NewStringObj(tls, eventStr, int64(-int32(1)))
	(*TTcl_Obj)(unsafe.Pointer(evObj)).FrefCount++
	return evObj
}

/*
 *----------------------------------------------------------------------
 *
 * NewReflectedTransform --
 *
 *	This function is invoked to allocate and initialize the instance data
 *	of a new reflected channel.
 *
 * Results:
 *	A heap-allocated channel instance.
 *
 * Side effects:
 *	Allocates memory.
 *
 *----------------------------------------------------------------------
 */

func _NewReflectedTransform(tls *libc.TLS, interp uintptr, cmdpfxObj uintptr, dummy1710 int32, handleObj uintptr, parentChan TTcl_Channel) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var i TTcl_Size
	var rtPtr, word, v5 uintptr
	var v2, v3 int64
	var _ /* listc at bp+0 */ TTcl_Size
	var _ /* listv at bp+8 */ uintptr
	_, _, _, _, _, _ = i, rtPtr, word, v2, v3, v5
	rtPtr = XTcl_Alloc(tls, uint64(112))
	/* rtPtr->chan: Assigned by caller. Dummy data here. */
	/* rtPtr->methods: Assigned by caller. Dummy data here. */
	(*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fchan1 = libc.UintptrFromInt32(0)
	(*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fmethods = 0
	(*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fthread = XTcl_GetCurrentThread(tls)
	(*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fparent = parentChan
	(*TReflectedTransform)(unsafe.Pointer(rtPtr)).Finterp = interp
	(*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fhandle = handleObj
	(*TTcl_Obj)(unsafe.Pointer(handleObj)).FrefCount++
	(*TReflectedTransform)(unsafe.Pointer(rtPtr)).Ftimer = libc.UintptrFromInt32(0)
	(*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fmode = 0
	(*TReflectedTransform)(unsafe.Pointer(rtPtr)).FreadIsDrained = 0
	(*TReflectedTransform)(unsafe.Pointer(rtPtr)).FeofPending = 0
	(*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fnonblocking = (*TChannelState1)(unsafe.Pointer((*TChannel)(unsafe.Pointer(parentChan)).Fstate)).Fflags & (libc.Int32FromInt32(1) << libc.Int32FromInt32(6))
	(*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fdead = 0
	/*
	 * Query parent for current blocking mode.
	 */
	_ResultInit(tls, rtPtr+88)
	/*
	 * Method placeholder.
	 */
	/* ASSERT: cmdpfxObj is a Tcl List */
	if (*TTcl_Obj)(unsafe.Pointer(cmdpfxObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(cmdpfxObj + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(cmdpfxObj + 32))).Fptr2)).FspanStart
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(cmdpfxObj + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(cmdpfxObj + 32))).Fptr1 + 40 + uintptr(v2)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(cmdpfxObj + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(cmdpfxObj + 32))).Fptr2)).FspanLength
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(cmdpfxObj + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v3
		_ = libc.Int32FromInt32(TCL_OK)
	} else {
		XTcl_ListObjGetElements(tls, interp, cmdpfxObj, bp, bp+8)
	}
	/*
	 * See [==] as well.
	 * Storage for the command prefix and the additional words required for
	 * the invocation of methods in the command handler.
	 *
	 * listv [0] [listc-1] | [listc]  [listc+1] |
	 * argv  [0]   ... [.] | [argc-2] [argc-1]  | [argc]  [argc+2]
	 *       cmd   ... pfx | method   chan      | detail1 detail2
	 */
	(*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fargc = int32(*(*TTcl_Size)(unsafe.Pointer(bp)) + int64(2))
	(*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fargv = XTcl_Alloc(tls, uint64(8)*libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))+libc.Int64FromInt32(4)))
	/*
	 * Duplicate object references.
	 */
	i = 0
	for {
		if !(i < *(*TTcl_Size)(unsafe.Pointer(bp))) {
			break
		}
		v5 = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8))
		*(*uintptr)(unsafe.Pointer((*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fargv + uintptr(i)*8)) = v5
		word = v5
		(*TTcl_Obj)(unsafe.Pointer(word)).FrefCount++
		goto _4
	_4:
		;
		i++
	}
	i++ /* Skip placeholder for method */
	/*
	 * See [x] in FreeReflectedTransform for release
	 */
	*(*uintptr)(unsafe.Pointer((*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fargv + uintptr(i)*8)) = handleObj
	(*TTcl_Obj)(unsafe.Pointer(handleObj)).FrefCount++
	/*
	 * The next two objects are kept empty, varying arguments.
	 */
	/*
	 * Initialization complete.
	 */
	return rtPtr
}

/*
 *----------------------------------------------------------------------
 *
 * NextHandle --
 *
 *	This function is invoked to generate a channel handle for a new
 *	reflected channel.
 *
 * Results:
 *	A Tcl_Obj containing the string of the new channel handle. The
 *	refcount of the returned object is -- zero --.
 *
 * Side effects:
 *	May allocate memory. Mutex protected critical section locks out other
 *	threads for a short time.
 *
 *----------------------------------------------------------------------
 */

func _NextHandle1(tls *libc.TLS) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var resObj uintptr
	_ = resObj
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_rtCounterMutex)))
	resObj = XTcl_ObjPrintf(tls, __ccgo_ts+48835, libc.VaList(bp+8, _rtCounter))
	_rtCounter++
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_rtCounterMutex)))
	return resObj
}

/*
 * Count number of generated reflected channels. Used for id generation.
 * Ids are never reclaimed and there is no dealing with wrap around. On
 * the other hand, "unsigned long" should be big enough except for
 * absolute longrunners (generate a 100 ids per second => overflow will
 * occur in 1 1/3 years).
 */

var _rtCounterMutex TTcl_Mutex

var _rtCounter uint64

func _FreeReflectedTransformArgs(tls *libc.TLS, rtPtr uintptr) {
	var _objPtr, _objPtr1, _objPtr2, v2, v5, v7 uintptr
	var i, n int32
	var v1, v4, v6 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, i, n, v1, v2, v4, v5, v6, v7
	n = (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fargc - int32(2)
	if n < 0 {
		return
	}
	_objPtr = (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fhandle
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	(*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fhandle = libc.UintptrFromInt32(0)
	i = 0
	for {
		if !(i < n) {
			break
		}
		_objPtr1 = *(*uintptr)(unsafe.Pointer((*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fargv + uintptr(i)*8))
		v5 = _objPtr1
		v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
		*(*TTcl_Size)(unsafe.Pointer(v5))--
		if v4 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		goto _3
	_3:
		;
		i++
	}
	/*
	 * See [x] in NewReflectedTransform for lock
	 * n+1 = argc-1.
	 */
	_objPtr2 = *(*uintptr)(unsafe.Pointer((*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fargv + uintptr(n+int32(1))*8))
	v7 = _objPtr2
	v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
	*(*TTcl_Size)(unsafe.Pointer(v7))--
	if v6 <= int64(1) {
		XTclFreeObj(tls, _objPtr2)
	}
	(*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fargc = int32(1)
}

func _FreeReflectedTransform(tls *libc.TLS, blockPtr uintptr) {
	var rtPtr uintptr
	_ = rtPtr
	rtPtr = blockPtr
	_TimerKill(tls, rtPtr)
	_ResultClear(tls, rtPtr+88)
	_FreeReflectedTransformArgs(tls, rtPtr)
	XTclpFree(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fargv)
	XTclpFree(tls, rtPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * InvokeTclMethod --
 *
 *	This function is used to invoke the Tcl level of a reflected channel.
 *	It handles all the command assembly, invocation, and generic state and
 *	result mgmt. It does *not* handle thread redirection; that is the
 *	responsibility of clients of this function.
 *
 * Results:
 *	Result code and data as returned by the method.
 *
 * Side effects:
 *	Arbitrary, as it calls upon a Tcl script.
 *
 * Contract:
 *	argOneObj.refCount >= 1 on entry and exit, if argOneObj != NULL
 *	argTwoObj.refCount >= 1 on entry and exit, if argTwoObj != NULL
 *	resObj.refCount in {0, 1, ...}
 *
 *----------------------------------------------------------------------
 * Semi-DUPLICATE of 'InvokeTclMethod' in tclIORChan.c
 * - Semi because different structures are used.
 * - Still possible to factor out the commonalities into a separate structure.
 */

func _InvokeTclMethod1(tls *libc.TLS, rtPtr uintptr, method uintptr, argOneObj uintptr, argTwoObj uintptr, resultObjPtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* NULL'able */
	var _objPtr, _objPtr1, cmd, cmdString, methObj, resObj, v1, v3, v5 uintptr
	var cmdc, result int32
	var sr TTcl_InterpState
	var v2, v4 TTcl_Size
	var _ /* cmdLen at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cmd, cmdString, cmdc, methObj, resObj, result, sr, v1, v2, v3, v4, v5 /* #words in constructed command */
	methObj = libc.UintptrFromInt32(0)                                                                                                  /* Result code of method invocation */
	resObj = libc.UintptrFromInt32(0)                                                                                                   /* Result of method invocation. */
	if (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fdead != 0 {
		/*
		 * The transform is marked as dead. Bail out immediately, with an
		 * appropriate error.
		 */
		if resultObjPtr != libc.UintptrFromInt32(0) {
			resObj = XTcl_NewStringObj(tls, _msg_dstlost1, int64(-int32(1)))
			*(*uintptr)(unsafe.Pointer(resultObjPtr)) = resObj
			(*TTcl_Obj)(unsafe.Pointer(resObj)).FrefCount++
		}
		return int32(TCL_ERROR)
	}
	/*
	 * NOTE (5): Decide impl. issue: Cache objects with method names?
	 * Requires TSD data as reflections can be created in many different
	 * threads.
	 * NO: Caching of command resolutions means storage per channel.
	 */
	/*
	 * Insert method into the preallocated area, after the command prefix,
	 * before the channel id.
	 */
	methObj = XTcl_NewStringObj(tls, method, int64(-int32(1)))
	(*TTcl_Obj)(unsafe.Pointer(methObj)).FrefCount++
	*(*uintptr)(unsafe.Pointer((*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fargv + uintptr((*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fargc-int32(2))*8)) = methObj
	/*
	 * Append the additional argument containing method specific details
	 * behind the channel id. If specified.
	 *
	 * Because of the contract there is no need to increment the refcounts.
	 * The objects will survive the Tcl_EvalObjv without change.
	 */
	cmdc = (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fargc
	if argOneObj != 0 {
		*(*uintptr)(unsafe.Pointer((*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fargv + uintptr(cmdc)*8)) = argOneObj
		cmdc++
		if argTwoObj != 0 {
			*(*uintptr)(unsafe.Pointer((*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fargv + uintptr(cmdc)*8)) = argTwoObj
			cmdc++
		}
	}
	/*
	 * And run the handler... This is done in a manner which leaves any
	 * existing state intact.
	 */
	sr = XTcl_SaveInterpState(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Finterp, 0)
	XTcl_Preserve(tls, rtPtr)
	XTcl_Preserve(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Finterp)
	result = XTcl_EvalObjv(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Finterp, int64(cmdc), (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fargv, int32(TCL_EVAL_GLOBAL))
	/*
	 * We do not try to extract the result information if the caller has no
	 * interest in it. I.e. there is no need to put effort into creating
	 * something which is discarded immediately after.
	 */
	if resultObjPtr != 0 {
		if result == TCL_OK {
			/*
			 * Ok result taken as is, also if the caller requests that there
			 * is no capture.
			 */
			resObj = XTcl_GetObjResult(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Finterp)
		} else {
			/*
			 * Non-ok result is always treated as an error. We have to capture
			 * the full state of the result, including additional options.
			 *
			 * This is complex and ugly, and would be completely unnecessary
			 * if we only added support for a TCL_FORBID_EXCEPTIONS flag.
			 */
			if result != int32(TCL_ERROR) {
				cmd = XTcl_NewListObj(tls, int64(cmdc), (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fargv)
				if (*TTcl_Obj)(unsafe.Pointer(cmd)).Fbytes != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(cmd)).Flength
					v1 = (*TTcl_Obj)(unsafe.Pointer(cmd)).Fbytes
				} else {
					v1 = XTcl_GetStringFromObj(tls, cmd, bp)
				}
				cmdString = v1
				(*TTcl_Obj)(unsafe.Pointer(cmd)).FrefCount++
				XTcl_ResetResult(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Finterp)
				XTcl_SetObjResult(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Finterp, XTcl_ObjPrintf(tls, __ccgo_ts+48257, libc.VaList(bp+16, result)))
				XTcl_LogCommandInfo(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Finterp, cmdString, cmdString, *(*TTcl_Size)(unsafe.Pointer(bp)))
				_objPtr = cmd
				v3 = _objPtr
				v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
				*(*TTcl_Size)(unsafe.Pointer(v3))--
				if v2 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
				result = int32(TCL_ERROR)
			}
			XTcl_AppendObjToErrorInfo(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Finterp, XTcl_ObjPrintf(tls, __ccgo_ts+48292, libc.VaList(bp+16, method)))
			resObj = _MarshallError1(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Finterp)
		}
		(*TTcl_Obj)(unsafe.Pointer(resObj)).FrefCount++
	}
	XTcl_RestoreInterpState(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Finterp, sr)
	XTcl_Release(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Finterp)
	XTcl_Release(tls, rtPtr)
	/*
	 * Cleanup of the dynamic parts of the command.
	 *
	 * The detail objects survived the Tcl_EvalObjv without change because of
	 * the contract. Therefore there is no need to decrement the refcounts. Only
	 * the internal method object has to be disposed of.
	 */
	_objPtr1 = methObj
	v5 = _objPtr1
	v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
	*(*TTcl_Size)(unsafe.Pointer(v5))--
	if v4 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	/*
	 * The resObj has a ref count of 1 at this location. This means that the
	 * caller of InvokeTclMethod has to dispose of it (but only if it was
	 * returned to it).
	 */
	if resultObjPtr != libc.UintptrFromInt32(0) {
		*(*uintptr)(unsafe.Pointer(resultObjPtr)) = resObj
	}
	/*
	 * There no need to handle the case where nothing is returned, because for
	 * that case resObj was not set anyway.
	 */
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * GetReflectedTransformMap --
 *
 *	Gets and potentially initializes the reflected channel map for an
 *	interpreter.
 *
 * Results:
 *	A pointer to the map created, for use by the caller.
 *
 * Side effects:
 *	Initializes the reflected channel map for an interpreter.
 *
 *----------------------------------------------------------------------
 */

func _GetReflectedTransformMap(tls *libc.TLS, interp uintptr) (r uintptr) {
	var rtmPtr uintptr
	_ = rtmPtr
	rtmPtr = XTcl_GetAssocData(tls, interp, __ccgo_ts+48841, libc.UintptrFromInt32(0))
	if rtmPtr == libc.UintptrFromInt32(0) {
		rtmPtr = XTcl_Alloc(tls, uint64(104))
		XTcl_InitHashTable(tls, rtmPtr, TCL_STRING_KEYS)
		XTcl_SetAssocData(tls, interp, __ccgo_ts+48841, __ccgo_fp(_DeleteReflectedTransformMap), rtmPtr)
	}
	return rtmPtr
}

/*
 *----------------------------------------------------------------------
 *
 * DeleteReflectedTransformMap --
 *
 *	Deletes the channel table for an interpreter, closing any open
 *	channels whose refcount reaches zero. This procedure is invoked when
 *	an interpreter is deleted, via the AssocData cleanup mechanism.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Deletes the hash table of channels. May close channels. May flush
 *	output on closed channels. Removes any channeEvent handlers that were
 *	registered in this interpreter.
 *
 *----------------------------------------------------------------------
 */

func _DeleteReflectedTransformMap(tls *libc.TLS, clientData uintptr, interp uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* The interpreter being deleted. */
	var evPtr, hPtr, paramPtr, resultPtr, rtPtr, rtmPtr uintptr
	var _ /* hSearch at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _ = evPtr, hPtr, paramPtr, resultPtr, rtPtr, rtmPtr
	/*
	 * Delete all entries. The channels may have been closed already, or will
	 * be closed later, by the standard IO finalization of an interpreter
	 * under destruction. Except for the channels which were moved to a
	 * different interpreter and/or thread. They do not exist from the IO
	 * systems point of view and will not get closed. Therefore mark all as
	 * dead so that any future access will cause a proper error. For channels
	 * in a different thread we actually do the same as
	 * DeleteThreadReflectedTransformMap(), just restricted to the channels of
	 * this interp.
	 */
	rtmPtr = clientData
	hPtr = XTcl_FirstHashEntry(tls, rtmPtr, bp)
	for {
		if !(hPtr != libc.UintptrFromInt32(0)) {
			break
		}
		rtPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		(*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fdead = int32(1)
		XTcl_DeleteHashEntry(tls, hPtr)
		goto _1
	_1:
		;
		hPtr = XTcl_FirstHashEntry(tls, rtmPtr, bp)
	}
	XTcl_DeleteHashTable(tls, rtmPtr)
	XTclpFree(tls, rtmPtr)
	/*
	 * The origin interpreter for one or more reflected channels is gone.
	 */
	/*
	 * Get the map of all channels handled by the current thread. This is a
	 * ReflectedTransformMap, but on a per-thread basis, not per-interp. Go
	 * through the channels and remove all which were handled by this
	 * interpreter. They have already been marked as dead.
	 */
	rtmPtr = _GetThreadReflectedTransformMap(tls)
	hPtr = XTcl_FirstHashEntry(tls, rtmPtr, bp)
	for {
		if !(hPtr != libc.UintptrFromInt32(0)) {
			break
		}
		rtPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		if (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Finterp != interp {
			/*
			 * Ignore entries for other interpreters.
			 */
			goto _2
		}
		(*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fdead = int32(1)
		_FreeReflectedTransformArgs(tls, rtPtr)
		XTcl_DeleteHashEntry(tls, hPtr)
		goto _2
	_2:
		;
		hPtr = XTcl_NextHashEntry(tls, bp)
	}
	/*
	 * Go through the list of pending results and cancel all whose events were
	 * destined for this interpreter. While this is in progress we block any
	 * other access to the list of pending results.
	 */
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_rtForwardMutex)))
	resultPtr = _forwardList1
	for {
		if !(resultPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TForwardingResult)(unsafe.Pointer(resultPtr)).Fdsti != interp {
			/*
			 * Ignore results/events for other interpreters.
			 */
			goto _3
		}
		/*
		 * The receiver for the event exited, before processing the event. We
		 * detach the result now, wake the originator up and signal failure.
		 */
		evPtr = (*TForwardingResult)(unsafe.Pointer(resultPtr)).FevPtr
		if evPtr == libc.UintptrFromInt32(0) {
			goto _3
		}
		paramPtr = (*TForwardingEvent1)(unsafe.Pointer(evPtr)).Fparam
		(*TForwardingEvent1)(unsafe.Pointer(evPtr)).FresultPtr = libc.UintptrFromInt32(0)
		(*TForwardingResult)(unsafe.Pointer(resultPtr)).FevPtr = libc.UintptrFromInt32(0)
		(*TForwardingResult)(unsafe.Pointer(resultPtr)).Fresult = int32(TCL_ERROR)
		(*TForwardParam1)(unsafe.Pointer(paramPtr)).Fbase.Fcode = int32(TCL_ERROR)
		(*TForwardParam1)(unsafe.Pointer(paramPtr)).Fbase.FmustFree = 0
		(*TForwardParam1)(unsafe.Pointer(paramPtr)).Fbase.FmsgStr = _msg_send_dstlost1
		XTcl_ConditionNotify(tls, resultPtr+24)
		goto _3
	_3:
		;
		resultPtr = (*TForwardingResult)(unsafe.Pointer(resultPtr)).FnextPtr
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_rtForwardMutex)))
}

/*
 *----------------------------------------------------------------------
 *
 * GetThreadReflectedTransformMap --
 *
 *	Gets and potentially initializes the reflected channel map for a
 *	thread.
 *
 * Results:
 *	A pointer to the map created, for use by the caller.
 *
 * Side effects:
 *	Initializes the reflected channel map for a thread.
 *
 *----------------------------------------------------------------------
 */

func _GetThreadReflectedTransformMap(tls *libc.TLS) (r uintptr) {
	var tsdPtr uintptr
	_ = tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey5)), int64(8))
	if !((*TThreadSpecificData6)(unsafe.Pointer(tsdPtr)).FrtmPtr != 0) {
		(*TThreadSpecificData6)(unsafe.Pointer(tsdPtr)).FrtmPtr = XTcl_Alloc(tls, uint64(104))
		XTcl_InitHashTable(tls, (*TThreadSpecificData6)(unsafe.Pointer(tsdPtr)).FrtmPtr, TCL_STRING_KEYS)
		XTcl_CreateThreadExitHandler(tls, __ccgo_fp(_DeleteThreadReflectedTransformMap), libc.UintptrFromInt32(0))
	}
	return (*TThreadSpecificData6)(unsafe.Pointer(tsdPtr)).FrtmPtr
}

/*
 *----------------------------------------------------------------------
 *
 * DeleteThreadReflectedTransformMap --
 *
 *	Deletes the channel table for a thread. This procedure is invoked when
 *	a thread is deleted. The channels have already been marked as dead, in
 *	DeleteReflectedTransformMap().
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Deletes the hash table of channels.
 *
 *----------------------------------------------------------------------
 */

func _DeleteThreadReflectedTransformMap(tls *libc.TLS, dummy2269 uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var evPtr, hPtr, paramPtr, resultPtr, rtPtr, rtmPtr uintptr
	var self TTcl_ThreadId
	var _ /* hSearch at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _, _ = evPtr, hPtr, paramPtr, resultPtr, rtPtr, rtmPtr, self /* Search variable. */
	self = XTcl_GetCurrentThread(tls)
	/*
	 * The origin thread for one or more reflected channels is gone.
	 * NOTE: If this function is called due to a thread getting killed the
	 *       per-interp DeleteReflectedTransformMap is apparently not called.
	 */
	/*
	 * Get the map of all channels handled by the current thread. This is a
	 * ReflectedTransformMap, but on a per-thread basis, not per-interp. Go
	 * through the channels, remove all, mark them as dead.
	 */
	rtmPtr = _GetThreadReflectedTransformMap(tls)
	hPtr = XTcl_FirstHashEntry(tls, rtmPtr, bp)
	for {
		if !(hPtr != libc.UintptrFromInt32(0)) {
			break
		}
		rtPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		(*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fdead = int32(1)
		_FreeReflectedTransformArgs(tls, rtPtr)
		XTcl_DeleteHashEntry(tls, hPtr)
		goto _1
	_1:
		;
		hPtr = XTcl_FirstHashEntry(tls, rtmPtr, bp)
	}
	XTclpFree(tls, rtmPtr)
	/*
	 * Go through the list of pending results and cancel all whose events were
	 * destined for this thread. While this is in progress we block any
	 * other access to the list of pending results.
	 */
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_rtForwardMutex)))
	resultPtr = _forwardList1
	for {
		if !(resultPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TForwardingResult)(unsafe.Pointer(resultPtr)).Fdst != self {
			/*
			 * Ignore results/events for other threads.
			 */
			goto _2
		}
		/*
		 * The receiver for the event exited, before processing the event. We
		 * detach the result now, wake the originator up and signal failure.
		 */
		evPtr = (*TForwardingResult)(unsafe.Pointer(resultPtr)).FevPtr
		if evPtr == libc.UintptrFromInt32(0) {
			goto _2
		}
		paramPtr = (*TForwardingEvent1)(unsafe.Pointer(evPtr)).Fparam
		(*TForwardingEvent1)(unsafe.Pointer(evPtr)).FresultPtr = libc.UintptrFromInt32(0)
		(*TForwardingResult)(unsafe.Pointer(resultPtr)).FevPtr = libc.UintptrFromInt32(0)
		(*TForwardingResult)(unsafe.Pointer(resultPtr)).Fresult = int32(TCL_ERROR)
		(*TForwardParam1)(unsafe.Pointer(paramPtr)).Fbase.Fcode = int32(TCL_ERROR)
		(*TForwardParam1)(unsafe.Pointer(paramPtr)).Fbase.FmustFree = 0
		(*TForwardParam1)(unsafe.Pointer(paramPtr)).Fbase.FmsgStr = _msg_send_dstlost1
		XTcl_ConditionNotify(tls, resultPtr+24)
		goto _2
	_2:
		;
		resultPtr = (*TForwardingResult)(unsafe.Pointer(resultPtr)).FnextPtr
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_rtForwardMutex)))
}

func _ForwardOpToOwnerThread(tls *libc.TLS, rtPtr uintptr, op TForwardedOperation, param uintptr) {
	/* Arguments */
	var dst TTcl_ThreadId
	var evPtr, resultPtr uintptr
	_, _, _ = dst, evPtr, resultPtr
	dst = (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fthread
	/*
	 * We gather the lock early. This allows us to check the liveness of the
	 * channel without interference from DeleteThreadReflectedTransformMap().
	 */
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_rtForwardMutex)))
	if (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fdead != 0 {
		/*
		 * The channel is marked as dead. Bail out immediately, with an
		 * appropriate error. Do not forget to unlock the mutex on this path.
		 */
		(*TForwardParam1)(unsafe.Pointer(param)).Fbase.Fcode = int32(TCL_ERROR)
		(*TForwardParam1)(unsafe.Pointer(param)).Fbase.FmustFree = 0
		(*TForwardParam1)(unsafe.Pointer(param)).Fbase.FmsgStr = _msg_send_dstlost1
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_rtForwardMutex)))
		return
	}
	/*
	 * Create and initialize the event and data structures.
	 */
	evPtr = XTcl_Alloc(tls, uint64(48))
	resultPtr = XTcl_Alloc(tls, uint64(64))
	(*TForwardingEvent1)(unsafe.Pointer(evPtr)).Fevent.Fproc = __ccgo_fp(_ForwardProc1)
	(*TForwardingEvent1)(unsafe.Pointer(evPtr)).FresultPtr = resultPtr
	(*TForwardingEvent1)(unsafe.Pointer(evPtr)).Fop = op
	(*TForwardingEvent1)(unsafe.Pointer(evPtr)).FrtPtr = rtPtr
	(*TForwardingEvent1)(unsafe.Pointer(evPtr)).Fparam = param
	(*TForwardingResult)(unsafe.Pointer(resultPtr)).Fsrc = XTcl_GetCurrentThread(tls)
	(*TForwardingResult)(unsafe.Pointer(resultPtr)).Fdst = dst
	(*TForwardingResult)(unsafe.Pointer(resultPtr)).Fdsti = (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Finterp
	(*TForwardingResult)(unsafe.Pointer(resultPtr)).Fdone = libc.UintptrFromInt32(0)
	(*TForwardingResult)(unsafe.Pointer(resultPtr)).Fresult = -int32(1)
	(*TForwardingResult)(unsafe.Pointer(resultPtr)).FevPtr = evPtr
	/*
	 * Now execute the forward.
	 */
	(*TForwardingResult)(unsafe.Pointer(resultPtr)).FnextPtr = _forwardList1
	if _forwardList1 != libc.UintptrFromInt32(0) {
		(*TForwardingResult)(unsafe.Pointer(_forwardList1)).FprevPtr = resultPtr
	}
	(*TForwardingResult)(unsafe.Pointer(resultPtr)).FprevPtr = libc.UintptrFromInt32(0)
	_forwardList1 = resultPtr
	/* Do not unlock here. That is done by the ConditionWait */
	/*
	 * Ensure cleanup of the event if the origin thread exits while this event
	 * is pending or in progress. Exit of the destination thread is handled by
	 * DeleteThreadReflectionChannelMap(), this is set up by
	 * GetThreadReflectedTransformMap(). This is what we use the 'forwardList'
	 * (see above) for.
	 */
	XTcl_CreateThreadExitHandler(tls, __ccgo_fp(_SrcExitProc1), evPtr)
	/*
	 * Queue the event and poke the other thread's notifier.
	 */
	XTcl_ThreadQueueEvent(tls, dst, evPtr, int32(TCL_QUEUE_TAIL)|int32(TCL_QUEUE_ALERT_IF_EMPTY))
	/*
	 * (*) Block until the other thread has either processed the transfer or
	 * rejected it.
	 */
	for (*TForwardingResult)(unsafe.Pointer(resultPtr)).Fresult < 0 {
		/*
		 * NOTE (1): Is it possible that the current thread goes away while
		 * waiting here? IOW Is it possible that "SrcExitProc" is called
		 * while we are here? See complementary note (2) in "SrcExitProc"
		 *
		 * The ConditionWait unlocks the mutex during the wait and relocks it
		 * immediately after.
		 */
		XTcl_ConditionWait(tls, resultPtr+24, uintptr(unsafe.Pointer(&_rtForwardMutex)), libc.UintptrFromInt32(0))
	}
	/*
	 * Unlink result from the forwarder list. No need to lock. Either still
	 * locked, or locked by the ConditionWait
	 */
	if (*TForwardingResult)(unsafe.Pointer(resultPtr)).FprevPtr != libc.UintptrFromInt32(0) {
		(*TForwardingResult)(unsafe.Pointer((*TForwardingResult)(unsafe.Pointer(resultPtr)).FprevPtr)).FnextPtr = (*TForwardingResult)(unsafe.Pointer(resultPtr)).FnextPtr
	} else {
		_forwardList1 = (*TForwardingResult)(unsafe.Pointer(resultPtr)).FnextPtr
	}
	if (*TForwardingResult)(unsafe.Pointer(resultPtr)).FnextPtr != libc.UintptrFromInt32(0) {
		(*TForwardingResult)(unsafe.Pointer((*TForwardingResult)(unsafe.Pointer(resultPtr)).FnextPtr)).FprevPtr = (*TForwardingResult)(unsafe.Pointer(resultPtr)).FprevPtr
	}
	(*TForwardingResult)(unsafe.Pointer(resultPtr)).FnextPtr = libc.UintptrFromInt32(0)
	(*TForwardingResult)(unsafe.Pointer(resultPtr)).FprevPtr = libc.UintptrFromInt32(0)
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_rtForwardMutex)))
	XTcl_ConditionFinalize(tls, resultPtr+24)
	/*
	 * Kill the cleanup handler now, and the result structure as well, before
	 * returning the success code.
	 *
	 * Note: The event structure has already been deleted by the destination
	 * notifier, after it serviced the event.
	 */
	XTcl_DeleteThreadExitHandler(tls, __ccgo_fp(_SrcExitProc1), evPtr)
	XTclpFree(tls, resultPtr)
}

func _ForwardProc1(tls *libc.TLS, evGPtr uintptr, dummy2463 int32) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var _objPtr, _objPtr1, _objPtr2, bufObj, bufObj1, bytev, bytev1, bytev2, bytev3, evPtr, hPtr, interp, paramPtr, resultPtr, rtPtr, rtmPtr, v1, v2, v4, v6, v8 uintptr
	var v3, v5, v7 TTcl_Size
	var _ /* bytec at bp+16 */ TTcl_Size
	var _ /* bytec at bp+24 */ TTcl_Size
	var _ /* bytec at bp+32 */ TTcl_Size
	var _ /* bytec at bp+8 */ TTcl_Size
	var _ /* resObj at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, bufObj, bufObj1, bytev, bytev1, bytev2, bytev3, evPtr, hPtr, interp, paramPtr, resultPtr, rtPtr, rtmPtr, v1, v2, v3, v4, v5, v6, v7, v8
	/*
	 * Notes regarding access to the referenced data.
	 *
	 * In principle the data belongs to the originating thread (see
	 * evPtr->src), however this thread is currently blocked at (*), i.e.
	 * quiescent. Because of this we can treat the data as belonging to us,
	 * without fear of race conditions. I.e. we can read and write as we like.
	 *
	 * The only thing we cannot be sure of is the resultPtr. This can be
	 * NULLed if the originating thread went away while the event is handled
	 * here now.
	 */
	evPtr = evGPtr
	resultPtr = (*TForwardingEvent1)(unsafe.Pointer(evPtr)).FresultPtr
	rtPtr = (*TForwardingEvent1)(unsafe.Pointer(evPtr)).FrtPtr
	interp = (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Finterp
	paramPtr = (*TForwardingEvent1)(unsafe.Pointer(evPtr)).Fparam
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0) /* Entry in the above map */
	/*
	 * Ignore the event if no one is waiting for its result anymore.
	 */
	if !(resultPtr != 0) {
		return int32(1)
	}
	(*TForwardParam1)(unsafe.Pointer(paramPtr)).Fbase.Fcode = TCL_OK
	(*TForwardParam1)(unsafe.Pointer(paramPtr)).Fbase.FmsgStr = libc.UintptrFromInt32(0)
	(*TForwardParam1)(unsafe.Pointer(paramPtr)).Fbase.FmustFree = 0
	switch (*TForwardingEvent1)(unsafe.Pointer(evPtr)).Fop {
	/*
	 * The destination thread for the following operations is
	 * rtPtr->thread, which contains rtPtr->interp, the interp we have to
	 * call upon for the driver.
	 */
	case int32(ForwardedClose1):
		/*
		 * No parameters/results.
		 */
		if _InvokeTclMethod1(tls, rtPtr, __ccgo_ts+47133, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), bp) != TCL_OK {
			_ForwardSetObjError1(tls, paramPtr, *(*uintptr)(unsafe.Pointer(bp)))
		}
		/*
		 * Freeing is done here, in the origin thread, because the argv[]
		 * objects belong to this thread. Deallocating them in a different
		 * thread is not allowed
		 */
		/*
		 * Remove the channel from the map before releasing the memory, to
		 * prevent future accesses (like by 'postevent') from finding and
		 * dereferencing a dangling pointer.
		 */
		rtmPtr = _GetReflectedTransformMap(tls, interp)
		if (*TTcl_Obj)(unsafe.Pointer((*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fhandle)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer((*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fhandle)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fhandle, libc.UintptrFromInt32(0))
		}
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(rtmPtr)).FfindProc})))(tls, rtmPtr, v1)
		XTcl_DeleteHashEntry(tls, hPtr)
		/*
		 * In a threaded interpreter we manage a per-thread map as well, to
		 * allow us to survive if the script level pulls the rug out under a
		 * channel by deleting the owning thread.
		 */
		rtmPtr = _GetThreadReflectedTransformMap(tls)
		if (*TTcl_Obj)(unsafe.Pointer((*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fhandle)).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer((*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fhandle)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fhandle, libc.UintptrFromInt32(0))
		}
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(rtmPtr)).FfindProc})))(tls, rtmPtr, v2)
		XTcl_DeleteHashEntry(tls, hPtr)
		_FreeReflectedTransformArgs(tls, rtPtr)
	case int32(ForwardedInput1):
		bufObj = XTcl_NewByteArrayObj(tls, (*(*TForwardParamTransform)(unsafe.Pointer(paramPtr))).Fbuf, (*(*TForwardParamTransform)(unsafe.Pointer(paramPtr))).Fsize)
		(*TTcl_Obj)(unsafe.Pointer(bufObj)).FrefCount++
		if _InvokeTclMethod1(tls, rtPtr, __ccgo_ts+5552, bufObj, libc.UintptrFromInt32(0), bp) != TCL_OK {
			_ForwardSetObjError1(tls, paramPtr, *(*uintptr)(unsafe.Pointer(bp)))
			(*(*TForwardParamTransform)(unsafe.Pointer(paramPtr))).Fsize = int64(-libc.Int32FromInt32(1))
		} else {
			/*
			 * Process a regular return. Contains the transformation result.
			 * Sent it back to the request originator.
			 */
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0
			/* Array of returned bytes */
			bytev = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), bp+8)
			(*(*TForwardParamTransform)(unsafe.Pointer(paramPtr))).Fsize = *(*TTcl_Size)(unsafe.Pointer(bp + 8))
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > 0 {
				(*(*TForwardParamTransform)(unsafe.Pointer(paramPtr))).Fbuf = XTcl_Alloc(tls, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8))))
				libc.Xmemcpy(tls, (*(*TForwardParamTransform)(unsafe.Pointer(paramPtr))).Fbuf, bytev, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8))))
			} else {
				(*(*TForwardParamTransform)(unsafe.Pointer(paramPtr))).Fbuf = libc.UintptrFromInt32(0)
			}
		}
		_objPtr = bufObj
		v4 = _objPtr
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	case int32(ForwardedOutput1):
		bufObj1 = XTcl_NewByteArrayObj(tls, (*(*TForwardParamTransform)(unsafe.Pointer(paramPtr))).Fbuf, (*(*TForwardParamTransform)(unsafe.Pointer(paramPtr))).Fsize)
		(*TTcl_Obj)(unsafe.Pointer(bufObj1)).FrefCount++
		if _InvokeTclMethod1(tls, rtPtr, __ccgo_ts+44159, bufObj1, libc.UintptrFromInt32(0), bp) != TCL_OK {
			_ForwardSetObjError1(tls, paramPtr, *(*uintptr)(unsafe.Pointer(bp)))
			(*(*TForwardParamTransform)(unsafe.Pointer(paramPtr))).Fsize = int64(-libc.Int32FromInt32(1))
		} else {
			/*
			 * Process a regular return. Contains the transformation result.
			 * Sent it back to the request originator.
			 */
			*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = 0
			/* Array of returned bytes */
			bytev1 = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), bp+16)
			(*(*TForwardParamTransform)(unsafe.Pointer(paramPtr))).Fsize = *(*TTcl_Size)(unsafe.Pointer(bp + 16))
			if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) > 0 {
				(*(*TForwardParamTransform)(unsafe.Pointer(paramPtr))).Fbuf = XTcl_Alloc(tls, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 16))))
				libc.Xmemcpy(tls, (*(*TForwardParamTransform)(unsafe.Pointer(paramPtr))).Fbuf, bytev1, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 16))))
			} else {
				(*(*TForwardParamTransform)(unsafe.Pointer(paramPtr))).Fbuf = libc.UintptrFromInt32(0)
			}
		}
		_objPtr1 = bufObj1
		v6 = _objPtr1
		v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
		*(*TTcl_Size)(unsafe.Pointer(v6))--
		if v5 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	case int32(ForwardedDrain):
		if _InvokeTclMethod1(tls, rtPtr, __ccgo_ts+48491, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), bp) != TCL_OK {
			_ForwardSetObjError1(tls, paramPtr, *(*uintptr)(unsafe.Pointer(bp)))
			(*(*TForwardParamTransform)(unsafe.Pointer(paramPtr))).Fsize = int64(-libc.Int32FromInt32(1))
		} else {
			/*
			 * Process a regular return. Contains the transformation result.
			 * Sent it back to the request originator.
			 */
			*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = 0 /* Array of returned bytes */
			bytev2 = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), bp+24)
			(*(*TForwardParamTransform)(unsafe.Pointer(paramPtr))).Fsize = *(*TTcl_Size)(unsafe.Pointer(bp + 24))
			if *(*TTcl_Size)(unsafe.Pointer(bp + 24)) > 0 {
				(*(*TForwardParamTransform)(unsafe.Pointer(paramPtr))).Fbuf = XTcl_Alloc(tls, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 24))))
				libc.Xmemcpy(tls, (*(*TForwardParamTransform)(unsafe.Pointer(paramPtr))).Fbuf, bytev2, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 24))))
			} else {
				(*(*TForwardParamTransform)(unsafe.Pointer(paramPtr))).Fbuf = libc.UintptrFromInt32(0)
			}
		}
	case int32(ForwardedFlush):
		if _InvokeTclMethod1(tls, rtPtr, __ccgo_ts+5518, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), bp) != TCL_OK {
			_ForwardSetObjError1(tls, paramPtr, *(*uintptr)(unsafe.Pointer(bp)))
			(*(*TForwardParamTransform)(unsafe.Pointer(paramPtr))).Fsize = int64(-libc.Int32FromInt32(1))
		} else {
			/*
			 * Process a regular return. Contains the transformation result.
			 * Sent it back to the request originator.
			 */
			*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = 0
			/* Array of returned bytes */
			bytev3 = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), bp+32)
			(*(*TForwardParamTransform)(unsafe.Pointer(paramPtr))).Fsize = *(*TTcl_Size)(unsafe.Pointer(bp + 32))
			if *(*TTcl_Size)(unsafe.Pointer(bp + 32)) > 0 {
				(*(*TForwardParamTransform)(unsafe.Pointer(paramPtr))).Fbuf = XTcl_Alloc(tls, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 32))))
				libc.Xmemcpy(tls, (*(*TForwardParamTransform)(unsafe.Pointer(paramPtr))).Fbuf, bytev3, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 32))))
			} else {
				(*(*TForwardParamTransform)(unsafe.Pointer(paramPtr))).Fbuf = libc.UintptrFromInt32(0)
			}
		}
	case int32(ForwardedClear):
		_InvokeTclMethod1(tls, rtPtr, __ccgo_ts+48485, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	case int32(ForwardedLimit):
		if _InvokeTclMethod1(tls, rtPtr, __ccgo_ts+48497, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), bp) != TCL_OK {
			_ForwardSetObjError1(tls, paramPtr, *(*uintptr)(unsafe.Pointer(bp)))
			(*(*TForwardParamLimit)(unsafe.Pointer(paramPtr))).Fmax = -int32(1)
		} else {
			if XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), paramPtr+24) != TCL_OK {
				_ForwardSetObjError1(tls, paramPtr, _MarshallError1(tls, interp))
				(*(*TForwardParamLimit)(unsafe.Pointer(paramPtr))).Fmax = -int32(1)
			}
		}
	default:
		/*
		 * Bad operation code.
		 */
		XTcl_Panic(tls, __ccgo_ts+48437, 0)
		break
	}
	/*
	 * Remove the reference we held on the result of the invoke, if we had
	 * such.
	 */
	if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
		_objPtr2 = *(*uintptr)(unsafe.Pointer(bp))
		v8 = _objPtr2
		v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
		*(*TTcl_Size)(unsafe.Pointer(v8))--
		if v7 <= int64(1) {
			XTclFreeObj(tls, _objPtr2)
		}
	}
	if resultPtr != 0 {
		/*
		 * Report the forwarding result synchronously to the waiting caller.
		 * This unblocks (*) as well. This is wrapped into a conditional
		 * because the caller may have exited in the mean time.
		 */
		XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_rtForwardMutex)))
		(*TForwardingResult)(unsafe.Pointer(resultPtr)).Fresult = TCL_OK
		XTcl_ConditionNotify(tls, resultPtr+24)
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_rtForwardMutex)))
	}
	return int32(1)
}

func _SrcExitProc1(tls *libc.TLS, clientData uintptr) {
	var evPtr, paramPtr, resultPtr uintptr
	_, _, _ = evPtr, paramPtr, resultPtr
	evPtr = clientData
	/*
	 * NOTE (2): Can this handler be called with the originator blocked?
	 */
	/*
	 * The originator for the event exited. It is not sure if this can happen,
	 * as the originator should be blocked at (*) while the event is in
	 * transit/pending.
	 *
	 * We make sure that the event cannot refer to the result anymore, remove
	 * it from the list of pending results and free the structure. Locking the
	 * access ensures that we cannot get in conflict with "ForwardProc",
	 * should it already execute the event.
	 */
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_rtForwardMutex)))
	resultPtr = (*TForwardingEvent1)(unsafe.Pointer(evPtr)).FresultPtr
	paramPtr = (*TForwardingEvent1)(unsafe.Pointer(evPtr)).Fparam
	(*TForwardingEvent1)(unsafe.Pointer(evPtr)).FresultPtr = libc.UintptrFromInt32(0)
	(*TForwardingResult)(unsafe.Pointer(resultPtr)).FevPtr = libc.UintptrFromInt32(0)
	(*TForwardingResult)(unsafe.Pointer(resultPtr)).Fresult = int32(TCL_ERROR)
	(*TForwardParam1)(unsafe.Pointer(paramPtr)).Fbase.Fcode = int32(TCL_ERROR)
	(*TForwardParam1)(unsafe.Pointer(paramPtr)).Fbase.FmustFree = 0
	(*TForwardParam1)(unsafe.Pointer(paramPtr)).Fbase.FmsgStr = _msg_send_originlost1
	/*
	 * See below: TclSpliceOut(resultPtr, forwardList);
	 */
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_rtForwardMutex)))
	/*
	 * This unlocks (*). The structure will be spliced out and freed by
	 * "ForwardProc". Maybe.
	 */
	XTcl_ConditionNotify(tls, resultPtr+24)
}

func _ForwardSetObjError1(tls *libc.TLS, paramPtr uintptr, obj uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var msgStr, v1 uintptr
	var _ /* len at bp+0 */ TTcl_Size
	_, _ = msgStr, v1
	if (*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(obj)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, obj, bp)
	}
	msgStr = v1
	*(*TTcl_Size)(unsafe.Pointer(bp))++
	(*TForwardParam1)(unsafe.Pointer(paramPtr)).Fbase.Fcode = int32(TCL_ERROR)
	(*TForwardParam1)(unsafe.Pointer(paramPtr)).Fbase.FmustFree = int32(1)
	(*TForwardParam1)(unsafe.Pointer(paramPtr)).Fbase.FmsgStr = XTcl_Alloc(tls, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))))
	libc.Xmemcpy(tls, (*TForwardParam1)(unsafe.Pointer(paramPtr)).Fbase.FmsgStr, msgStr, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))))
}

/*
 *----------------------------------------------------------------------
 *
 * TimerKill --
 *
 *	Timer management. Removes the internal timer if it exists.
 *
 * Side effects:
 *	See above.
 *
 * Result:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _TimerKill(tls *libc.TLS, rtPtr uintptr) {
	if (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Ftimer == libc.UintptrFromInt32(0) {
		return
	}
	/*
	 * Delete an existing flush-out timer, prevent it from firing on a
	 * removed/dead channel.
	 */
	XTcl_DeleteTimerHandler(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Ftimer)
	(*TReflectedTransform)(unsafe.Pointer(rtPtr)).Ftimer = libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * TimerSetup --
 *
 *	Timer management. Creates the internal timer if it does not exist.
 *
 * Side effects:
 *	See above.
 *
 * Result:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _TimerSetup(tls *libc.TLS, rtPtr uintptr) {
	if (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Ftimer != libc.UintptrFromInt32(0) {
		return
	}
	(*TReflectedTransform)(unsafe.Pointer(rtPtr)).Ftimer = XTcl_CreateTimerHandler(tls, SYNTHETIC_EVENT_TIME, __ccgo_fp(_TimerRun), rtPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * TimerRun --
 *
 *	Called by the notifier (-> timer) to flush out information waiting in
 *	channel buffers.
 *
 * Side effects:
 *	As of 'Tcl_NotifyChannel'.
 *
 * Result:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _TimerRun(tls *libc.TLS, clientData uintptr) {
	var rtPtr uintptr
	_ = rtPtr
	rtPtr = clientData
	(*TReflectedTransform)(unsafe.Pointer(rtPtr)).Ftimer = libc.UintptrFromInt32(0)
	XTcl_NotifyChannel(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fchan1, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1))
}

/*
 *----------------------------------------------------------------------
 *
 * ResultInit --
 *
 *	Initializes the specified buffer structure. The structure will contain
 *	valid information for an empty buffer.
 *
 * Side effects:
 *	See above.
 *
 * Result:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _ResultInit(tls *libc.TLS, rPtr uintptr) {
	/* Reference to the structure to
	 * initialize. */
	(*TResultBuffer)(unsafe.Pointer(rPtr)).Fused = uint64(0)
	(*TResultBuffer)(unsafe.Pointer(rPtr)).Fallocated = uint64(0)
	(*TResultBuffer)(unsafe.Pointer(rPtr)).Fbuf = libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * ResultClear --
 *
 *	Deallocates any memory allocated by 'ResultAdd'.
 *
 * Side effects:
 *	See above.
 *
 * Result:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _ResultClear(tls *libc.TLS, rPtr uintptr) {
	/* Reference to the buffer to clear out */
	(*TResultBuffer)(unsafe.Pointer(rPtr)).Fused = uint64(0)
	if !((*TResultBuffer)(unsafe.Pointer(rPtr)).Fallocated != 0) {
		return
	}
	XTclpFree(tls, (*TResultBuffer)(unsafe.Pointer(rPtr)).Fbuf)
	(*TResultBuffer)(unsafe.Pointer(rPtr)).Fbuf = libc.UintptrFromInt32(0)
	(*TResultBuffer)(unsafe.Pointer(rPtr)).Fallocated = uint64(0)
}

/*
 *----------------------------------------------------------------------
 *
 * ResultAdd --
 *
 *	Adds the bytes in the specified array to the buffer, by appending it.
 *
 * Side effects:
 *	See above.
 *
 * Result:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _ResultAdd(tls *libc.TLS, rPtr uintptr, buf uintptr, toWrite Tsize_t) {
	/* The number of bytes in 'buf' */
	if (*TResultBuffer)(unsafe.Pointer(rPtr)).Fused+toWrite+uint64(1) > (*TResultBuffer)(unsafe.Pointer(rPtr)).Fallocated {
		/*
		 * Extension of the internal buffer is required.
		 * NOTE: Currently linear. Should be doubling to amortize.
		 */
		if (*TResultBuffer)(unsafe.Pointer(rPtr)).Fallocated == uint64(0) {
			(*TResultBuffer)(unsafe.Pointer(rPtr)).Fallocated = toWrite + libc.Uint64FromInt32(libc.Int32FromInt32(RB_INCREMENT))
			(*TResultBuffer)(unsafe.Pointer(rPtr)).Fbuf = XTcl_Alloc(tls, (*TResultBuffer)(unsafe.Pointer(rPtr)).Fallocated)
		} else {
			*(*Tsize_t)(unsafe.Pointer(rPtr + 8)) += toWrite + libc.Uint64FromInt32(libc.Int32FromInt32(RB_INCREMENT))
			(*TResultBuffer)(unsafe.Pointer(rPtr)).Fbuf = XTcl_Realloc(tls, (*TResultBuffer)(unsafe.Pointer(rPtr)).Fbuf, (*TResultBuffer)(unsafe.Pointer(rPtr)).Fallocated)
		}
	}
	/*
	 * Now copy data.
	 */
	libc.Xmemcpy(tls, (*TResultBuffer)(unsafe.Pointer(rPtr)).Fbuf+uintptr((*TResultBuffer)(unsafe.Pointer(rPtr)).Fused), buf, toWrite)
	*(*Tsize_t)(unsafe.Pointer(rPtr + 16)) += toWrite
}

/*
 *----------------------------------------------------------------------
 *
 * ResultCopy --
 *
 *	Copies the requested number of bytes from the buffer into the
 *	specified array and removes them from the buffer afterward. Copies
 *	less if there is not enough data in the buffer.
 *
 * Side effects:
 *	See above.
 *
 * Result:
 *	The number of actually copied bytes, possibly less than 'toRead'.
 *
 *----------------------------------------------------------------------
 */

func _ResultCopy(tls *libc.TLS, rPtr uintptr, buf uintptr, toRead Tsize_t) (r Tsize_t) {
	/* Number of requested bytes */
	var copied int32
	_ = copied
	if (*TResultBuffer)(unsafe.Pointer(rPtr)).Fused == uint64(0) {
		/*
		 * Nothing to copy in the case of an empty buffer.
		 */
		copied = 0
	} else {
		if (*TResultBuffer)(unsafe.Pointer(rPtr)).Fused == toRead {
			/*
			 * We have just enough. Copy everything to the caller.
			 */
			libc.Xmemcpy(tls, buf, (*TResultBuffer)(unsafe.Pointer(rPtr)).Fbuf, toRead)
			(*TResultBuffer)(unsafe.Pointer(rPtr)).Fused = uint64(0)
			copied = libc.Int32FromUint64(toRead)
		} else {
			if (*TResultBuffer)(unsafe.Pointer(rPtr)).Fused > toRead {
				/*
				 * The internal buffer contains more than requested. Copy the
				 * requested subset to the caller, and shift the remaining bytes down.
				 */
				libc.Xmemcpy(tls, buf, (*TResultBuffer)(unsafe.Pointer(rPtr)).Fbuf, toRead)
				libc.Xmemmove(tls, (*TResultBuffer)(unsafe.Pointer(rPtr)).Fbuf, (*TResultBuffer)(unsafe.Pointer(rPtr)).Fbuf+uintptr(toRead), (*TResultBuffer)(unsafe.Pointer(rPtr)).Fused-toRead)
				*(*Tsize_t)(unsafe.Pointer(rPtr + 16)) -= toRead
				copied = libc.Int32FromUint64(toRead)
			} else {
				/*
				 * There is not enough in the buffer to satisfy the caller, so take
				 * everything.
				 */
				libc.Xmemcpy(tls, buf, (*TResultBuffer)(unsafe.Pointer(rPtr)).Fbuf, (*TResultBuffer)(unsafe.Pointer(rPtr)).Fused)
				toRead = (*TResultBuffer)(unsafe.Pointer(rPtr)).Fused
				(*TResultBuffer)(unsafe.Pointer(rPtr)).Fused = uint64(0)
				copied = libc.Int32FromUint64(toRead)
			}
		}
	}
	/* -- common postwork code ------- */
	return libc.Uint64FromInt32(copied)
}

func _TransformRead(tls *libc.TLS, rtPtr uintptr, errorCodePtr uintptr, bufObj uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var _objPtr, _objPtr1, bytev, v2, v4 uintptr
	var v1, v3 TTcl_Size
	var _ /* bytec at bp+8 */ TTcl_Size
	var _ /* p at bp+16 */ TForwardParam1
	var _ /* resObj at bp+0 */ uintptr
	_, _, _, _, _, _, _ = _objPtr, _objPtr1, bytev, v1, v2, v3, v4
	*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0 /* Array of returned bytes */
	/*
	 * Are we in the correct thread?
	 */
	if (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fthread != XTcl_GetCurrentThread(tls) {
		(*(*TForwardParamTransform)(unsafe.Pointer(bp + 16))).Fbuf = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), bufObj, bp+16+32)
		_ForwardOpToOwnerThread(tls, rtPtr, int32(ForwardedInput1), bp+16)
		if (*(*TForwardParam1)(unsafe.Pointer(bp + 16))).Fbase.Fcode != TCL_OK {
			XTcl_SetChannelError(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fchan1, XTcl_NewStringObj(tls, (*TForwardParam1)(unsafe.Pointer(bp+16)).Fbase.FmsgStr, int64(-int32(1))))
			if (*TForwardParam1)(unsafe.Pointer(bp+16)).Fbase.FmustFree != 0 {
				XTclpFree(tls, (*TForwardParam1)(unsafe.Pointer(bp+16)).Fbase.FmsgStr)
			}
			*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(EINVAL)
			return 0
		}
		*(*int32)(unsafe.Pointer(errorCodePtr)) = EOK
		_ResultAdd(tls, rtPtr+88, (*(*TForwardParamTransform)(unsafe.Pointer(bp + 16))).Fbuf, libc.Uint64FromInt64((*(*TForwardParamTransform)(unsafe.Pointer(bp + 16))).Fsize))
		XTclpFree(tls, (*(*TForwardParamTransform)(unsafe.Pointer(bp + 16))).Fbuf)
		return int32(1)
	}
	/* ASSERT: rtPtr->method & FLAG(METH_READ) */
	/* ASSERT: rtPtr->mode & TCL_READABLE */
	if _InvokeTclMethod1(tls, rtPtr, __ccgo_ts+5552, bufObj, libc.UintptrFromInt32(0), bp) != TCL_OK {
		XTcl_SetChannelError(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fchan1, *(*uintptr)(unsafe.Pointer(bp)))
		_objPtr = *(*uintptr)(unsafe.Pointer(bp))
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		} /* Remove reference held from invoke */
		*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(EINVAL)
		return 0
	}
	bytev = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), bp+8)
	_ResultAdd(tls, rtPtr+88, bytev, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8))))
	_objPtr1 = *(*uintptr)(unsafe.Pointer(bp))
	v4 = _objPtr1
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	if v3 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	} /* Remove reference held from invoke */
	return int32(1)
}

func _TransformWrite(tls *libc.TLS, rtPtr uintptr, errorCodePtr uintptr, buf uintptr, toWrite int32) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, bufObj, bytev, v2, v4, v6, v8 uintptr
	var res int32
	var v1, v3, v5, v7 TTcl_Size
	var _ /* bytec at bp+8 */ TTcl_Size
	var _ /* p at bp+16 */ TForwardParam1
	var _ /* resObj at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, bufObj, bytev, res, v1, v2, v3, v4, v5, v6, v7, v8
	*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0
	/*
	 * Are we in the correct thread?
	 */
	if (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fthread != XTcl_GetCurrentThread(tls) {
		(*(*TForwardParamTransform)(unsafe.Pointer(bp + 16))).Fbuf = buf
		(*(*TForwardParamTransform)(unsafe.Pointer(bp + 16))).Fsize = int64(toWrite)
		_ForwardOpToOwnerThread(tls, rtPtr, int32(ForwardedOutput1), bp+16)
		if (*(*TForwardParam1)(unsafe.Pointer(bp + 16))).Fbase.Fcode != TCL_OK {
			XTcl_SetChannelError(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fchan1, XTcl_NewStringObj(tls, (*TForwardParam1)(unsafe.Pointer(bp+16)).Fbase.FmsgStr, int64(-int32(1))))
			if (*TForwardParam1)(unsafe.Pointer(bp+16)).Fbase.FmustFree != 0 {
				XTclpFree(tls, (*TForwardParam1)(unsafe.Pointer(bp+16)).Fbase.FmsgStr)
			}
			*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(EINVAL)
			return 0
		}
		*(*int32)(unsafe.Pointer(errorCodePtr)) = EOK
		res = int32(XTcl_WriteRaw(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fparent, (*(*TForwardParamTransform)(unsafe.Pointer(bp + 16))).Fbuf, (*(*TForwardParamTransform)(unsafe.Pointer(bp + 16))).Fsize))
		XTclpFree(tls, (*(*TForwardParamTransform)(unsafe.Pointer(bp + 16))).Fbuf)
	} else {
		/* ASSERT: rtPtr->method & FLAG(METH_WRITE) */
		/* ASSERT: rtPtr->mode & TCL_WRITABLE */
		bufObj = XTcl_NewByteArrayObj(tls, buf, int64(toWrite))
		(*TTcl_Obj)(unsafe.Pointer(bufObj)).FrefCount++
		if _InvokeTclMethod1(tls, rtPtr, __ccgo_ts+44159, bufObj, libc.UintptrFromInt32(0), bp) != TCL_OK {
			*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(EINVAL)
			XTcl_SetChannelError(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fchan1, *(*uintptr)(unsafe.Pointer(bp)))
			_objPtr = bufObj
			v2 = _objPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if v1 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			_objPtr1 = *(*uintptr)(unsafe.Pointer(bp))
			v4 = _objPtr1
			v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
			*(*TTcl_Size)(unsafe.Pointer(v4))--
			if v3 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			} /* Remove reference held from invoke */
			return 0
		}
		*(*int32)(unsafe.Pointer(errorCodePtr)) = EOK
		bytev = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), bp+8)
		res = int32(XTcl_WriteRaw(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fparent, bytev, *(*TTcl_Size)(unsafe.Pointer(bp + 8))))
		_objPtr2 = bufObj
		v6 = _objPtr2
		v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
		*(*TTcl_Size)(unsafe.Pointer(v6))--
		if v5 <= int64(1) {
			XTclFreeObj(tls, _objPtr2)
		}
		_objPtr3 = *(*uintptr)(unsafe.Pointer(bp))
		v8 = _objPtr3
		v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
		*(*TTcl_Size)(unsafe.Pointer(v8))--
		if v7 <= int64(1) {
			XTclFreeObj(tls, _objPtr3)
		} /* Remove reference held from invoke */
	}
	if res < 0 {
		*(*int32)(unsafe.Pointer(errorCodePtr)) = XTcl_GetErrno(tls)
		return 0
	}
	return int32(1)
}

func _TransformDrain(tls *libc.TLS, rtPtr uintptr, errorCodePtr uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var _objPtr, _objPtr1, bytev, v2, v4 uintptr
	var v1, v3 TTcl_Size
	var _ /* bytec at bp+8 */ TTcl_Size
	var _ /* p at bp+16 */ TForwardParam1
	var _ /* resObj at bp+0 */ uintptr
	_, _, _, _, _, _, _ = _objPtr, _objPtr1, bytev, v1, v2, v3, v4
	*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0 /* Array of returned bytes */
	/*
	 * Are we in the correct thread?
	 */
	if (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fthread != XTcl_GetCurrentThread(tls) {
		_ForwardOpToOwnerThread(tls, rtPtr, int32(ForwardedDrain), bp+16)
		if (*(*TForwardParam1)(unsafe.Pointer(bp + 16))).Fbase.Fcode != TCL_OK {
			XTcl_SetChannelError(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fchan1, XTcl_NewStringObj(tls, (*TForwardParam1)(unsafe.Pointer(bp+16)).Fbase.FmsgStr, int64(-int32(1))))
			if (*TForwardParam1)(unsafe.Pointer(bp+16)).Fbase.FmustFree != 0 {
				XTclpFree(tls, (*TForwardParam1)(unsafe.Pointer(bp+16)).Fbase.FmsgStr)
			}
			*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(EINVAL)
			return 0
		}
		*(*int32)(unsafe.Pointer(errorCodePtr)) = EOK
		_ResultAdd(tls, rtPtr+88, (*(*TForwardParamTransform)(unsafe.Pointer(bp + 16))).Fbuf, libc.Uint64FromInt64((*(*TForwardParamTransform)(unsafe.Pointer(bp + 16))).Fsize))
		XTclpFree(tls, (*(*TForwardParamTransform)(unsafe.Pointer(bp + 16))).Fbuf)
	} else {
		if _InvokeTclMethod1(tls, rtPtr, __ccgo_ts+48491, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), bp) != TCL_OK {
			XTcl_SetChannelError(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fchan1, *(*uintptr)(unsafe.Pointer(bp)))
			_objPtr = *(*uintptr)(unsafe.Pointer(bp))
			v2 = _objPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if v1 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			} /* Remove reference held from invoke */
			*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(EINVAL)
			return 0
		}
		bytev = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), bp+8)
		_ResultAdd(tls, rtPtr+88, bytev, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8))))
		_objPtr1 = *(*uintptr)(unsafe.Pointer(bp))
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		} /* Remove reference held from invoke */
	}
	(*TReflectedTransform)(unsafe.Pointer(rtPtr)).FreadIsDrained = int32(1)
	return int32(1)
}

func _TransformFlush(tls *libc.TLS, rtPtr uintptr, errorCodePtr uintptr, op int32) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var _objPtr, _objPtr1, bytev, v2, v4 uintptr
	var res int32
	var v1, v3 TTcl_Size
	var _ /* bytec at bp+8 */ TTcl_Size
	var _ /* p at bp+16 */ TForwardParam1
	var _ /* resObj at bp+0 */ uintptr
	_, _, _, _, _, _, _, _ = _objPtr, _objPtr1, bytev, res, v1, v2, v3, v4
	*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0
	/*
	 * Are we in the correct thread?
	 */
	if (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fthread != XTcl_GetCurrentThread(tls) {
		_ForwardOpToOwnerThread(tls, rtPtr, int32(ForwardedFlush), bp+16)
		if (*(*TForwardParam1)(unsafe.Pointer(bp + 16))).Fbase.Fcode != TCL_OK {
			XTcl_SetChannelError(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fchan1, XTcl_NewStringObj(tls, (*TForwardParam1)(unsafe.Pointer(bp+16)).Fbase.FmsgStr, int64(-int32(1))))
			if (*TForwardParam1)(unsafe.Pointer(bp+16)).Fbase.FmustFree != 0 {
				XTclpFree(tls, (*TForwardParam1)(unsafe.Pointer(bp+16)).Fbase.FmsgStr)
			}
			*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(EINVAL)
			return 0
		}
		*(*int32)(unsafe.Pointer(errorCodePtr)) = EOK
		if op == int32(FLUSH_WRITE) {
			res = int32(XTcl_WriteRaw(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fparent, (*(*TForwardParamTransform)(unsafe.Pointer(bp + 16))).Fbuf, (*(*TForwardParamTransform)(unsafe.Pointer(bp + 16))).Fsize))
		} else {
			res = 0
		}
		XTclpFree(tls, (*(*TForwardParamTransform)(unsafe.Pointer(bp + 16))).Fbuf)
	} else {
		if _InvokeTclMethod1(tls, rtPtr, __ccgo_ts+5518, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), bp) != TCL_OK {
			XTcl_SetChannelError(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fchan1, *(*uintptr)(unsafe.Pointer(bp)))
			_objPtr = *(*uintptr)(unsafe.Pointer(bp))
			v2 = _objPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if v1 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			} /* Remove reference held from invoke */
			*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(EINVAL)
			return 0
		}
		if op == int32(FLUSH_WRITE) {
			bytev = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), bp+8)
			res = int32(XTcl_WriteRaw(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fparent, bytev, *(*TTcl_Size)(unsafe.Pointer(bp + 8))))
		} else {
			res = 0
		}
		_objPtr1 = *(*uintptr)(unsafe.Pointer(bp))
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		} /* Remove reference held from invoke */
	}
	if res < 0 {
		*(*int32)(unsafe.Pointer(errorCodePtr)) = XTcl_GetErrno(tls)
		return 0
	}
	return int32(1)
}

func _TransformClear(tls *libc.TLS, rtPtr uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var _ /* p at bp+0 */ TForwardParam1
	/*
	 * Are we in the correct thread?
	 */
	if (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fthread != XTcl_GetCurrentThread(tls) {
		_ForwardOpToOwnerThread(tls, rtPtr, int32(ForwardedClear), bp)
		return
	}
	/* ASSERT: rtPtr->method & FLAG(METH_READ) */
	/* ASSERT: rtPtr->mode & TCL_READABLE */
	_InvokeTclMethod1(tls, rtPtr, __ccgo_ts+48485, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	(*TReflectedTransform)(unsafe.Pointer(rtPtr)).FreadIsDrained = 0
	(*TReflectedTransform)(unsafe.Pointer(rtPtr)).FeofPending = 0
	_ResultClear(tls, rtPtr+88)
}

func _TransformLimit(tls *libc.TLS, rtPtr uintptr, errorCodePtr uintptr, maxPtr uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var _objPtr, _objPtr1, _objPtr2, v2, v4, v6 uintptr
	var sr TTcl_InterpState
	var v1, v3, v5 TTcl_Size
	var _ /* p at bp+8 */ TForwardParam1
	var _ /* resObj at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, sr, v1, v2, v3, v4, v5, v6 /* State of handler interp */
	/*
	 * Are we in the correct thread?
	 */
	if (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fthread != XTcl_GetCurrentThread(tls) {
		_ForwardOpToOwnerThread(tls, rtPtr, int32(ForwardedLimit), bp+8)
		if (*(*TForwardParam1)(unsafe.Pointer(bp + 8))).Fbase.Fcode != TCL_OK {
			XTcl_SetChannelError(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fchan1, XTcl_NewStringObj(tls, (*TForwardParam1)(unsafe.Pointer(bp+8)).Fbase.FmsgStr, int64(-int32(1))))
			if (*TForwardParam1)(unsafe.Pointer(bp+8)).Fbase.FmustFree != 0 {
				XTclpFree(tls, (*TForwardParam1)(unsafe.Pointer(bp+8)).Fbase.FmsgStr)
			}
			*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(EINVAL)
			return 0
		}
		*(*int32)(unsafe.Pointer(errorCodePtr)) = EOK
		*(*int32)(unsafe.Pointer(maxPtr)) = (*(*TForwardParamLimit)(unsafe.Pointer(&*(*TForwardParam1)(unsafe.Pointer(bp + 8))))).Fmax
		return int32(1)
	}
	/* ASSERT: rtPtr->method & FLAG(METH_WRITE) */
	/* ASSERT: rtPtr->mode & TCL_WRITABLE */
	if _InvokeTclMethod1(tls, rtPtr, __ccgo_ts+48497, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), bp) != TCL_OK {
		XTcl_SetChannelError(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fchan1, *(*uintptr)(unsafe.Pointer(bp)))
		_objPtr = *(*uintptr)(unsafe.Pointer(bp))
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		} /* Remove reference held from invoke */
		*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(EINVAL)
		return 0
	}
	sr = XTcl_SaveInterpState(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Finterp, 0)
	if XTcl_GetIntFromObj(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Finterp, *(*uintptr)(unsafe.Pointer(bp)), maxPtr) != TCL_OK {
		_objPtr1 = *(*uintptr)(unsafe.Pointer(bp))
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		} /* Remove reference held from invoke */
		XTcl_SetChannelError(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Fchan1, _MarshallError1(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Finterp))
		*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(EINVAL)
		XTcl_RestoreInterpState(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Finterp, sr)
		return 0
	}
	_objPtr2 = *(*uintptr)(unsafe.Pointer(bp))
	v6 = _objPtr2
	v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
	*(*TTcl_Size)(unsafe.Pointer(v6))--
	if v5 <= int64(1) {
		XTclFreeObj(tls, _objPtr2)
	} /* Remove reference held from invoke */
	XTcl_RestoreInterpState(tls, (*TReflectedTransform)(unsafe.Pointer(rtPtr)).Finterp, sr)
	return int32(1)
}

const CHANNEL_ASYNC = 1
const FLUSH_DELAY = 5
const INCREMENT = 512
const P_NO_PRESERVE = 0
const P_PRESERVE = 1
const TRANSMIT_DONT = 0
const TRANSMIT_DOWN = 1
const TRANSMIT_IBUF = 3
const TRANSMIT_NUM = 4
const TRANSMIT_SELF = 2

/*
 * Forward declarations of internal procedures. Third, helper procedures
 * encapsulating essential tasks.
 */

type TTransformChannelData = struct {
	Fself          TTcl_Channel
	FreadIsFlushed int32
	FeofPending    int32
	Fflags         int32
	FwatchMask     int32
	Fmode          int32
	Ftimer         TTcl_TimerToken
	FmaxRead       int32
	Finterp        uintptr
	Fcommand       uintptr
	Fresult        TResultBuffer
	FrefCount      Tsize_t
}

/*
 * This structure describes the channel type structure for Tcl-based
 * transformations.
 */

var _transformChannelType = TTcl_ChannelType{
	FtypeName: __ccgo_ts + 48863,
	Fversion:  libc.UintptrFromInt32(0x5),
}

func init() {
	p := unsafe.Pointer(&_transformChannelType)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_TransformInputProc)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_TransformOutputProc)
	*(*uintptr)(unsafe.Add(p, 48)) = __ccgo_fp(_TransformSetOptionProc)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(_TransformGetOptionProc)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(_TransformWatchProc)
	*(*uintptr)(unsafe.Add(p, 72)) = __ccgo_fp(_TransformGetFileHandleProc)
	*(*uintptr)(unsafe.Add(p, 80)) = __ccgo_fp(_TransformCloseProc)
	*(*uintptr)(unsafe.Add(p, 88)) = __ccgo_fp(_TransformBlockModeProc)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(_TransformNotifyProc)
	*(*uintptr)(unsafe.Add(p, 112)) = __ccgo_fp(_TransformWideSeekProc)
}

/*
 * Possible values for 'flags' field in control structure, see below.
 */

/*
 * Definition of the structure containing the information about the internal
 * input buffer.
 */

type TResultBuffer1 = struct {
	Fbuf       uintptr
	Fallocated Tsize_t
	Fused      Tsize_t
}

/*
 * Additional bytes to allocate during buffer expansion.
 */

/*
 * Number of milliseconds to wait before firing an event to flush out
 * information waiting in buffers (fileevent support).
 */

/*
 * Convenience macro to make some casts easier to use.
 */

/*
 * Definition of a structure used by all transformations generated here to
 * maintain their local state.
 */

type TTransformChannelData1 = struct {
	Fself          TTcl_Channel
	FreadIsFlushed int32
	FeofPending    int32
	Fflags         int32
	FwatchMask     int32
	Fmode          int32
	Ftimer         TTcl_TimerToken
	FmaxRead       int32
	Finterp        uintptr
	Fcommand       uintptr
	Fresult        TResultBuffer
	FrefCount      Tsize_t
}

func _PreserveData(tls *libc.TLS, dataPtr uintptr) {
	(*TTransformChannelData)(unsafe.Pointer(dataPtr)).FrefCount++
}

func _ReleaseData(tls *libc.TLS, dataPtr uintptr) {
	var _objPtr, v2, v4 uintptr
	var v1 Tsize_t
	var v3 TTcl_Size
	_, _, _, _, _ = _objPtr, v1, v2, v3, v4
	v2 = dataPtr + 88
	v1 = *(*Tsize_t)(unsafe.Pointer(v2))
	*(*Tsize_t)(unsafe.Pointer(v2))--
	if v1 > uint64(1) {
		return
	}
	_ResultClear1(tls, dataPtr+64)
	_objPtr = (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fcommand
	v4 = _objPtr
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	if v3 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	XTclpFree(tls, dataPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * TclChannelTransform --
 *
 *	Implements the Tcl "testchannel transform" debugging command. This is
 *	part of the testing environment. This sets up a tcl script (cmdObjPtr)
 *	to be used as a transform on the channel.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclChannelTransform(tls *libc.TLS, interp uintptr, chan1 TTcl_Channel, cmdObjPtr uintptr) (r int32) {
	bp := tls.Alloc(256)
	defer tls.Free(256) /* Script to use for transform. */
	var chanPtr, dataPtr, statePtr uintptr
	var mode, v1 int32
	var v2 int64
	var _ /* ds at bp+8 */ TTcl_DString
	var _ /* objc at bp+0 */ TTcl_Size
	_, _, _, _, _, _ = chanPtr, dataPtr, mode, statePtr, v1, v2
	if chan1 == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(cmdObjPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(cmdObjPtr + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(cmdObjPtr + 32))).Fptr2)).FspanLength
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(cmdObjPtr + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v2
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjLength(tls, interp, cmdObjPtr, bp)
	}
	if TCL_OK != v1 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+48873, int64(-int32(1))))
		return int32(TCL_ERROR)
	}
	chanPtr = chan1
	statePtr = (*TChannel)(unsafe.Pointer(chanPtr)).Fstate
	chanPtr = (*TChannelState)(unsafe.Pointer(statePtr)).FtopChanPtr
	chan1 = chanPtr
	mode = (*TChannelState)(unsafe.Pointer(statePtr)).Fflags & (libc.Int32FromInt32(1)<<libc.Int32FromInt32(1) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(2))
	/*
	 * Now initialize the transformation state and stack it upon the specified
	 * channel. One of the necessary things to do is to retrieve the blocking
	 * regime of the underlying channel and to use the same for us too.
	 */
	dataPtr = XTcl_Alloc(tls, uint64(96))
	(*TTransformChannelData)(unsafe.Pointer(dataPtr)).FrefCount = uint64(1)
	XTcl_DStringInit(tls, bp+8)
	XTcl_GetChannelOption(tls, interp, chan1, __ccgo_ts+42927, bp+8)
	(*TTransformChannelData)(unsafe.Pointer(dataPtr)).FreadIsFlushed = 0
	(*TTransformChannelData)(unsafe.Pointer(dataPtr)).FeofPending = 0
	(*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fflags = 0
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*(*TTcl_DString)(unsafe.Pointer(bp + 8))).Fstring1))) == int32('0') {
		*(*int32)(unsafe.Pointer(dataPtr + 16)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(0)
	}
	XTcl_DStringFree(tls, bp+8)
	(*TTransformChannelData)(unsafe.Pointer(dataPtr)).FwatchMask = 0
	(*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fmode = mode
	(*TTransformChannelData)(unsafe.Pointer(dataPtr)).Ftimer = libc.UintptrFromInt32(0)
	(*TTransformChannelData)(unsafe.Pointer(dataPtr)).FmaxRead = int32(4096) /* Initial value not relevant. */
	(*TTransformChannelData)(unsafe.Pointer(dataPtr)).Finterp = interp
	(*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fcommand = cmdObjPtr
	(*TTcl_Obj)(unsafe.Pointer((*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fcommand)).FrefCount++
	_ResultInit1(tls, dataPtr+64)
	(*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fself = XTcl_StackChannel(tls, interp, uintptr(unsafe.Pointer(&_transformChannelType)), dataPtr, mode, chan1)
	if (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fself == libc.UintptrFromInt32(0) {
		XTcl_AppendPrintfToObj(tls, XTcl_GetObjResult(tls, interp), __ccgo_ts+48902, libc.VaList(bp+240, XTcl_GetChannelName(tls, chan1)))
		_ReleaseData(tls, dataPtr)
		return int32(TCL_ERROR)
	}
	XTcl_Preserve(tls, (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fself)
	/*
	 * At last initialize the transformation at the script level.
	 */
	_PreserveData(tls, dataPtr)
	if (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fmode&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 && _ExecuteCallback(tls, dataPtr, libc.UintptrFromInt32(0), __ccgo_ts+48932, libc.UintptrFromInt32(0), 0, TRANSMIT_DONT, P_NO_PRESERVE) != TCL_OK {
		XTcl_UnstackChannel(tls, interp, chan1)
		_ReleaseData(tls, dataPtr)
		return int32(TCL_ERROR)
	}
	if (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fmode&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 && _ExecuteCallback(tls, dataPtr, libc.UintptrFromInt32(0), __ccgo_ts+48945, libc.UintptrFromInt32(0), 0, TRANSMIT_DONT, P_NO_PRESERVE) != TCL_OK {
		_ExecuteCallback(tls, dataPtr, libc.UintptrFromInt32(0), __ccgo_ts+48957, libc.UintptrFromInt32(0), 0, TRANSMIT_DONT, P_NO_PRESERVE)
		XTcl_UnstackChannel(tls, interp, chan1)
		_ReleaseData(tls, dataPtr)
		return int32(TCL_ERROR)
	}
	_ReleaseData(tls, dataPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * ExecuteCallback --
 *
 *	Executes the defined callback for buffer and operation.
 *
 * Side effects:
 *	As of the executed tcl script.
 *
 * Result:
 *	A standard TCL error code. In case of an error a message is left in
 *	the result area of the specified interpreter.
 *
 *----------------------------------------------------------------------
 */

func _ExecuteCallback(tls *libc.TLS, dataPtr uintptr, interp uintptr, op uintptr, buf uintptr, bufLen int32, transmit int32, preserve int32) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Flag. If true the procedure will preserve
	 * the result state of all accessed
	 * interpreters. */
	var _objPtr, _objPtr1, command, eval, resBuf, resObj, v2, v4 uintptr
	var res int32
	var state TTcl_InterpState
	var v1, v3 TTcl_Size
	var _ /* resLen at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, command, eval, res, resBuf, resObj, state, v1, v2, v3, v4 /* See below, switch (transmit). */
	*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	state = libc.UintptrFromInt32(0)
	res = TCL_OK
	command = XTclListObjCopy(tls, libc.UintptrFromInt32(0), (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fcommand)
	eval = (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Finterp
	XTcl_Preserve(tls, eval)
	/*
	 * Step 1, create the complete command to execute. Do this by appending
	 * operation and buffer to operate upon to a copy of the callback
	 * definition. We *cannot* create a list containing 3 objects and then use
	 * 'Tcl_EvalObjv', because the command may contain additional prefixed
	 * arguments. Feather's curried commands would come in handy here.
	 */
	if preserve == int32(P_PRESERVE) {
		state = XTcl_SaveInterpState(tls, eval, res)
	}
	(*TTcl_Obj)(unsafe.Pointer(command)).FrefCount++
	res = XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), command, XTcl_NewStringObj(tls, op, int64(-int32(1))))
	if res != TCL_OK {
		_objPtr = command
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		XTcl_Release(tls, eval)
		return res
	}
	/*
	 * Use a byte-array to prevent the misinterpretation of binary data coming
	 * through as Utf while at the tcl level.
	 */
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), command, XTcl_NewByteArrayObj(tls, buf, int64(bufLen)))
	/*
	 * Step 2, execute the command at the global level of the interpreter used
	 * to create the transformation. Destroy the command afterward. If an
	 * error occurred and the current interpreter is defined and not equal to
	 * the interpreter for the callback, then copy the error message into
	 * current interpreter. Don't copy if in preservation mode.
	 */
	res = XTcl_EvalObjEx(tls, eval, command, int32(TCL_EVAL_GLOBAL))
	_objPtr1 = command
	v4 = _objPtr1
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	if v3 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	command = libc.UintptrFromInt32(0)
	if res != TCL_OK && interp != libc.UintptrFromInt32(0) && eval != interp && preserve == P_NO_PRESERVE {
		XTcl_SetObjResult(tls, interp, XTcl_GetObjResult(tls, eval))
		XTcl_Release(tls, eval)
		return res
	}
	/*
	 * Step 3, transmit a possible conversion result to the underlying
	 * channel, or ourselves.
	 */
	switch transmit {
	case TRANSMIT_DONT:
		goto _5
	case int32(TRANSMIT_DOWN):
		goto _6
	case int32(TRANSMIT_SELF):
		goto _7
	case int32(TRANSMIT_IBUF):
		goto _8
	case int32(TRANSMIT_NUM):
		goto _9
	}
	goto _10
_5:
	;
	/* nothing to do */
	goto _10
_6:
	;
	if (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fself == libc.UintptrFromInt32(0) {
		goto _10
	}
	resObj = XTcl_GetObjResult(tls, eval)
	resBuf = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), resObj, bp)
	if resBuf != 0 {
		XTcl_WriteRaw(tls, XTcl_GetStackedChannel(tls, (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fself), resBuf, *(*TTcl_Size)(unsafe.Pointer(bp)))
		goto _10
	}
	goto nonBytes
_7:
	;
	if (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fself == libc.UintptrFromInt32(0) {
		goto _10
	}
	resObj = XTcl_GetObjResult(tls, eval)
	resBuf = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), resObj, bp)
	if resBuf != 0 {
		XTcl_WriteRaw(tls, (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fself, resBuf, *(*TTcl_Size)(unsafe.Pointer(bp)))
		goto _10
	}
	goto nonBytes
_8:
	;
	resObj = XTcl_GetObjResult(tls, eval)
	resBuf = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), resObj, bp)
	if resBuf != 0 {
		_ResultAdd1(tls, dataPtr+64, resBuf, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))))
		goto _10
	}
	goto nonBytes
nonBytes:
	;
	XTcl_AppendResult(tls, interp, libc.VaList(bp+16, __ccgo_ts+48970, libc.UintptrFromInt32(0)))
	XTcl_Release(tls, eval)
	return int32(TCL_ERROR)
_9:
	;
	/*
	 * Interpret result as integer number.
	 */
	resObj = XTcl_GetObjResult(tls, eval)
	if (*TTcl_Obj)(unsafe.Pointer(resObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(resObj)).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(resObj)).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
		*(*int32)(unsafe.Pointer(dataPtr + 40)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(resObj)).FinternalRep)))
		_ = libc.Int32FromInt32(TCL_OK)
	} else {
		XTcl_GetIntFromObj(tls, eval, resObj, dataPtr+40)
	}
	goto _10
_10:
	;
	XTcl_ResetResult(tls, eval)
	if preserve == int32(P_PRESERVE) {
		XTcl_RestoreInterpState(tls, eval, state)
	}
	XTcl_Release(tls, eval)
	return res
}

/*
 *----------------------------------------------------------------------
 *
 * TransformBlockModeProc --
 *
 *	Trap handler. Called by the generic IO system during option processing
 *	to change the blocking mode of the channel.
 *
 * Side effects:
 *	Forwards the request to the underlying channel.
 *
 * Result:
 *	0 if successful, errno when failed.
 *
 *----------------------------------------------------------------------
 */

func _TransformBlockModeProc(tls *libc.TLS, instanceData uintptr, mode int32) (r int32) {
	/* New blocking mode. */
	var dataPtr uintptr
	_ = dataPtr
	dataPtr = instanceData
	if mode == int32(TCL_MODE_NONBLOCKING) {
		*(*int32)(unsafe.Pointer(dataPtr + 16)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(0)
	} else {
		*(*int32)(unsafe.Pointer(dataPtr + 16)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(0))
	}
	return 0
}

/*
 *----------------------------------------------------------------------
 *
 * TransformCloseProc --
 *
 *	Trap handler. Called by the generic IO system during destruction of
 *	the transformation channel.
 *
 * Side effects:
 *	Releases the memory allocated in 'Tcl_TransformObjCmd'.
 *
 * Result:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _TransformCloseProc(tls *libc.TLS, instanceData uintptr, interp uintptr, flags int32) (r int32) {
	var dataPtr uintptr
	_ = dataPtr
	dataPtr = instanceData
	if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
		return int32(EINVAL)
	}
	/*
	 * Important: In this procedure 'dataPtr->self' already points to the
	 * underlying channel.
	 *
	 * There is no need to cancel an existing channel handler, this is already
	 * done. Either by 'Tcl_UnstackChannel' or by the general cleanup in
	 * 'Tcl_Close'.
	 *
	 * But we have to cancel an active timer to prevent it from firing on the
	 * removed channel.
	 */
	if (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Ftimer != libc.UintptrFromInt32(0) {
		XTcl_DeleteTimerHandler(tls, (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Ftimer)
		(*TTransformChannelData)(unsafe.Pointer(dataPtr)).Ftimer = libc.UintptrFromInt32(0)
	}
	/*
	 * Now flush data waiting in internal buffers to output and input. The
	 * input must be done despite the fact that there is no real receiver for
	 * it anymore. But the scripts might have sideeffects other parts of the
	 * system rely on (f.e. signalling the close to interested parties).
	 */
	_PreserveData(tls, dataPtr)
	if (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fmode&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
		_ExecuteCallback(tls, dataPtr, interp, __ccgo_ts+49013, libc.UintptrFromInt32(0), 0, int32(TRANSMIT_DOWN), int32(P_PRESERVE))
	}
	if (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fmode&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 && !((*TTransformChannelData)(unsafe.Pointer(dataPtr)).FreadIsFlushed != 0) {
		(*TTransformChannelData)(unsafe.Pointer(dataPtr)).FreadIsFlushed = int32(1)
		_ExecuteCallback(tls, dataPtr, interp, __ccgo_ts+49025, libc.UintptrFromInt32(0), 0, int32(TRANSMIT_IBUF), int32(P_PRESERVE))
	}
	if (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fmode&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
		_ExecuteCallback(tls, dataPtr, interp, __ccgo_ts+48957, libc.UintptrFromInt32(0), 0, TRANSMIT_DONT, int32(P_PRESERVE))
	}
	if (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fmode&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
		_ExecuteCallback(tls, dataPtr, interp, __ccgo_ts+49036, libc.UintptrFromInt32(0), 0, TRANSMIT_DONT, int32(P_PRESERVE))
	}
	_ReleaseData(tls, dataPtr)
	/*
	 * General cleanup.
	 */
	XTcl_Release(tls, (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fself)
	(*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fself = libc.UintptrFromInt32(0)
	_ReleaseData(tls, dataPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TransformInputProc --
 *
 *	Called by the generic IO system to convert read data.
 *
 * Side effects:
 *	As defined by the conversion.
 *
 * Result:
 *	A transformed buffer.
 *
 *----------------------------------------------------------------------
 */

func _TransformInputProc(tls *libc.TLS, instanceData uintptr, buf uintptr, toRead int32, errorCodePtr uintptr) (r int32) {
	var copied, gotBytes, read int32
	var dataPtr uintptr
	var downChan TTcl_Channel
	_, _, _, _, _ = copied, dataPtr, downChan, gotBytes, read
	dataPtr = instanceData
	/*
	 * Should assert(dataPtr->mode & TCL_READABLE);
	 */
	if toRead == 0 || (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fself == libc.UintptrFromInt32(0) {
		/*
		 * Catch a no-op. TODO: Is this a panic()?
		 */
		return 0
	}
	gotBytes = 0
	downChan = XTcl_GetStackedChannel(tls, (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fself)
	_PreserveData(tls, dataPtr)
	for toRead > 0 {
		/*
		 * Loop until the request is satisfied (or no data is available from
		 * below, possibly EOF).
		 */
		copied = libc.Int32FromUint64(_ResultCopy1(tls, dataPtr+64, buf, libc.Uint64FromInt32(toRead)))
		toRead -= copied
		buf += uintptr(copied)
		gotBytes += copied
		if toRead == 0 {
			/*
			 * The request was completely satisfied from our buffers. We can
			 * break out of the loop and return to the caller.
			 */
			break
		}
		/*
		 * Length (dataPtr->result) == 0, toRead > 0 here. Use the incoming
		 * 'buf'! as target to store the intermediary information read from
		 * the underlying channel.
		 *
		 * Ask the tcl level how much data it allows us to read from the
		 * underlying channel. This feature allows the transform to signal EOF
		 * upstream although there is none downstream. Useful to control an
		 * unbounded 'fcopy', either through counting bytes, or by pattern
		 * matching.
		 */
		_ExecuteCallback(tls, dataPtr, libc.UintptrFromInt32(0), __ccgo_ts+49048, libc.UintptrFromInt32(0), 0, int32(TRANSMIT_NUM), int32(P_PRESERVE))
		if (*TTransformChannelData)(unsafe.Pointer(dataPtr)).FmaxRead >= 0 {
			if (*TTransformChannelData)(unsafe.Pointer(dataPtr)).FmaxRead < toRead {
				toRead = (*TTransformChannelData)(unsafe.Pointer(dataPtr)).FmaxRead
			}
		} /* else: 'maxRead < 0' == Accept the current value of toRead. */
		if toRead <= 0 {
			break
		}
		if (*TTransformChannelData)(unsafe.Pointer(dataPtr)).FeofPending != 0 {
			/*
			 * Already saw EOF from downChan; don't ask again.
			 * NOTE: Could move this up to avoid the last maxRead
			 * execution.  Believe this would still be correct behavior,
			 * but the test suite tests the whole command callback
			 * sequence, so leave it unchanged for now.
			 */
			break
		}
		/*
		 * Get bytes from the underlying channel.
		 */
		read = int32(XTcl_ReadRaw(tls, downChan, buf, int64(toRead)))
		if read < 0 {
			if XTcl_InputBlocked(tls, downChan) != 0 && gotBytes > 0 {
				/*
				 * Zero bytes available from downChan because blocked.
				 * But nonzero bytes already copied, so total is a
				 * valid blocked short read. Return to caller.
				 */
				break
			}
			/*
			 * Either downChan is not blocked (there's a real error).
			 * or it is and there are no bytes copied yet.  In either
			 * case we want to pass the "error" along to the caller,
			 * either to report an error, or to signal to the caller
			 * that zero bytes are available because blocked.
			 */
			*(*int32)(unsafe.Pointer(errorCodePtr)) = XTcl_GetErrno(tls)
			gotBytes = -int32(1)
			break
		} else {
			if read == 0 {
				/*
				 * Zero returned from Tcl_ReadRaw() always indicates EOF
				 * on the down channel.
				 */
				(*TTransformChannelData)(unsafe.Pointer(dataPtr)).FeofPending = int32(1)
				(*TTransformChannelData)(unsafe.Pointer(dataPtr)).FreadIsFlushed = int32(1)
				_ExecuteCallback(tls, dataPtr, libc.UintptrFromInt32(0), __ccgo_ts+49025, libc.UintptrFromInt32(0), 0, int32(TRANSMIT_IBUF), int32(P_PRESERVE))
				if _ResultEmpty(tls, dataPtr+64) != 0 {
					/*
					 * We had nothing to flush.
					 */
					break
				}
				continue /* at: while (toRead > 0) */
			}
		} /* read == 0 */
		/*
		 * Transform the read chunk and add the result to our read buffer
		 * (dataPtr->result).
		 */
		if _ExecuteCallback(tls, dataPtr, libc.UintptrFromInt32(0), __ccgo_ts+5552, buf, read, int32(TRANSMIT_IBUF), int32(P_PRESERVE)) != TCL_OK {
			*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(EINVAL)
			gotBytes = -int32(1)
			break
		}
	} /* while toRead > 0 */
	if gotBytes == 0 {
		(*TTransformChannelData)(unsafe.Pointer(dataPtr)).FeofPending = 0
	}
	_ReleaseData(tls, dataPtr)
	return gotBytes
}

/*
 *----------------------------------------------------------------------
 *
 * TransformOutputProc --
 *
 *	Called by the generic IO system to convert data waiting to be written.
 *
 * Side effects:
 *	As defined by the transformation.
 *
 * Result:
 *	A transformed buffer.
 *
 *----------------------------------------------------------------------
 */

func _TransformOutputProc(tls *libc.TLS, instanceData uintptr, buf uintptr, toWrite int32, errorCodePtr uintptr) (r int32) {
	var dataPtr uintptr
	_ = dataPtr
	dataPtr = instanceData
	/*
	 * Should assert(dataPtr->mode & TCL_WRITABLE);
	 */
	if toWrite == 0 {
		/*
		 * Catch a no-op.
		 */
		return 0
	}
	_PreserveData(tls, dataPtr)
	if _ExecuteCallback(tls, dataPtr, libc.UintptrFromInt32(0), __ccgo_ts+44159, buf, toWrite, int32(TRANSMIT_DOWN), P_NO_PRESERVE) != TCL_OK {
		*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(EINVAL)
		toWrite = -int32(1)
	}
	_ReleaseData(tls, dataPtr)
	return toWrite
}

/*
 *----------------------------------------------------------------------
 *
 * TransformWideSeekProc --
 *
 *	This procedure is called by the generic IO level to move the access
 *	point in a channel, with a (potentially) 64-bit offset.
 *
 * Side effects:
 *	Moves the location at which the channel will be accessed in future
 *	operations. Flushes all transformation buffers, then forwards it to
 *	the underlying channel.
 *
 * Result:
 *	-1 if failed, the new position if successful. An output argument
 *	contains the POSIX error code if an error occurred, or zero.
 *
 *----------------------------------------------------------------------
 */

func _TransformWideSeekProc(tls *libc.TLS, instanceData uintptr, offset int64, mode int32, errorCodePtr uintptr) (r int64) {
	/* Location of error flag. */
	var dataPtr, parentData, parentType, parentWideSeekProc uintptr
	var parent TTcl_Channel
	_, _, _, _, _ = dataPtr, parent, parentData, parentType, parentWideSeekProc
	dataPtr = instanceData
	parent = XTcl_GetStackedChannel(tls, (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fself)
	parentType = XTcl_GetChannelType(tls, parent)
	parentWideSeekProc = XTcl_ChannelWideSeekProc(tls, parentType)
	parentData = XTcl_GetChannelInstanceData(tls, parent)
	if offset == 0 && mode == int32(1) {
		/*
		 * This is no seek but a request to tell the caller the current
		 * location. Simply pass the request down.
		 */
		if parentWideSeekProc != libc.UintptrFromInt32(0) {
			return (*(*func(*libc.TLS, uintptr, int64, int32, uintptr) int64)(unsafe.Pointer(&struct{ uintptr }{parentWideSeekProc})))(tls, parentData, offset, mode, errorCodePtr)
		} else {
			*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(EINVAL)
			return int64(-int32(1))
		}
	}
	/*
	 * It is a real request to change the position. Flush all data waiting for
	 * output and discard everything in the input buffers. Then pass the
	 * request down, unchanged.
	 */
	_PreserveData(tls, dataPtr)
	if (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fmode&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
		_ExecuteCallback(tls, dataPtr, libc.UintptrFromInt32(0), __ccgo_ts+49013, libc.UintptrFromInt32(0), 0, int32(TRANSMIT_DOWN), P_NO_PRESERVE)
	}
	if (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fmode&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
		_ExecuteCallback(tls, dataPtr, libc.UintptrFromInt32(0), __ccgo_ts+49062, libc.UintptrFromInt32(0), 0, TRANSMIT_DONT, P_NO_PRESERVE)
		_ResultClear1(tls, dataPtr+64)
		(*TTransformChannelData)(unsafe.Pointer(dataPtr)).FreadIsFlushed = 0
		(*TTransformChannelData)(unsafe.Pointer(dataPtr)).FeofPending = 0
	}
	_ReleaseData(tls, dataPtr)
	/*
	 * If we have a wide seek capability, we should stick with that.
	 */
	if parentWideSeekProc == libc.UintptrFromInt32(0) {
		*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(EINVAL)
		return int64(-int32(1))
	}
	return (*(*func(*libc.TLS, uintptr, int64, int32, uintptr) int64)(unsafe.Pointer(&struct{ uintptr }{parentWideSeekProc})))(tls, parentData, offset, mode, errorCodePtr)
}

/*
 *----------------------------------------------------------------------
 *
 * TransformSetOptionProc --
 *
 *	Called by generic layer to handle the reconfiguration of channel
 *	specific options. As this channel type does not have such, it simply
 *	passes all requests downstream.
 *
 * Side effects:
 *	As defined by the channel downstream.
 *
 * Result:
 *	A standard TCL error code.
 *
 *----------------------------------------------------------------------
 */

func _TransformSetOptionProc(tls *libc.TLS, instanceData uintptr, interp uintptr, optionName uintptr, value uintptr) (r int32) {
	var dataPtr, setOptionProc uintptr
	var downChan TTcl_Channel
	_, _, _ = dataPtr, downChan, setOptionProc
	dataPtr = instanceData
	downChan = XTcl_GetStackedChannel(tls, (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fself)
	setOptionProc = XTcl_ChannelSetOptionProc(tls, XTcl_GetChannelType(tls, downChan))
	if setOptionProc == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	return (*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{setOptionProc})))(tls, XTcl_GetChannelInstanceData(tls, downChan), interp, optionName, value)
}

/*
 *----------------------------------------------------------------------
 *
 * TransformGetOptionProc --
 *
 *	Called by generic layer to handle requests for the values of channel
 *	specific options. As this channel type does not have such, it simply
 *	passes all requests downstream.
 *
 * Side effects:
 *	As defined by the channel downstream.
 *
 * Result:
 *	A standard TCL error code.
 *
 *----------------------------------------------------------------------
 */

func _TransformGetOptionProc(tls *libc.TLS, instanceData uintptr, interp uintptr, optionName uintptr, dsPtr uintptr) (r int32) {
	var dataPtr, getOptionProc uintptr
	var downChan TTcl_Channel
	_, _, _ = dataPtr, downChan, getOptionProc
	dataPtr = instanceData
	downChan = XTcl_GetStackedChannel(tls, (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fself)
	getOptionProc = XTcl_ChannelGetOptionProc(tls, XTcl_GetChannelType(tls, downChan))
	if getOptionProc != libc.UintptrFromInt32(0) {
		return (*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{getOptionProc})))(tls, XTcl_GetChannelInstanceData(tls, downChan), interp, optionName, dsPtr)
	} else {
		if optionName == libc.UintptrFromInt32(0) {
			/*
			 * Request is query for all options, this is ok.
			 */
			return TCL_OK
		}
	}
	/*
	 * Request for a specific option has to fail, since we don't have any.
	 */
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * TransformWatchProc --
 *
 *	Initialize the notifier to watch for events from this channel.
 *
 * Side effects:
 *	Sets up the notifier so that a future event on the channel will be
 *	seen by Tcl.
 *
 * Result:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _TransformWatchProc(tls *libc.TLS, instanceData uintptr, mask int32) {
	/* Events of interest. */
	var dataPtr uintptr
	var downChan TTcl_Channel
	_, _ = dataPtr, downChan
	dataPtr = instanceData
	/*
	 * The caller expressed interest in events occurring for this channel. We
	 * are forwarding the call to the underlying channel now.
	 */
	(*TTransformChannelData)(unsafe.Pointer(dataPtr)).FwatchMask = mask
	/*
	 * No channel handlers any more. We will be notified automatically about
	 * events on the channel below via a call to our 'TransformNotifyProc'.
	 * But we have to pass the interest down now. We are allowed to add
	 * additional 'interest' to the mask if we want to. But this
	 * transformation has no such interest. It just passes the request down,
	 * unchanged.
	 */
	if (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fself == libc.UintptrFromInt32(0) {
		return
	}
	downChan = XTcl_GetStackedChannel(tls, (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fself)
	(*(*func(*libc.TLS, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ChannelType)(unsafe.Pointer(XTcl_GetChannelType(tls, downChan))).FwatchProc})))(tls, XTcl_GetChannelInstanceData(tls, downChan), mask)
	/*
	 * Management of the internal timer.
	 */
	if (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Ftimer != libc.UintptrFromInt32(0) && (!(mask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0) || _ResultEmpty(tls, dataPtr+64) != 0) {
		/*
		 * A pending timer exists, but either is there no (more) interest in
		 * the events it generates or nothing is available for reading, so
		 * remove it.
		 */
		XTcl_DeleteTimerHandler(tls, (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Ftimer)
		(*TTransformChannelData)(unsafe.Pointer(dataPtr)).Ftimer = libc.UintptrFromInt32(0)
	}
	if (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Ftimer == libc.UintptrFromInt32(0) && mask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 && !(_ResultEmpty(tls, dataPtr+64) != 0) {
		/*
		 * There is no pending timer, but there is interest in readable events
		 * and we actually have data waiting, so generate a timer to flush
		 * that.
		 */
		(*TTransformChannelData)(unsafe.Pointer(dataPtr)).Ftimer = XTcl_CreateTimerHandler(tls, int32(FLUSH_DELAY), __ccgo_fp(_TransformChannelHandlerTimer), dataPtr)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TransformGetFileHandleProc --
 *
 *	Called from Tcl_GetChannelHandle to retrieve OS specific file handle
 *	from inside this channel.
 *
 * Side effects:
 *	None.
 *
 * Result:
 *	The appropriate Tcl_File or NULL if not present.
 *
 *----------------------------------------------------------------------
 */

func _TransformGetFileHandleProc(tls *libc.TLS, instanceData uintptr, direction int32, handlePtr uintptr) (r int32) {
	/* Place to store the handle into. */
	var dataPtr uintptr
	_ = dataPtr
	dataPtr = instanceData
	/*
	 * Return the handle belonging to parent channel. IOW, pass the request
	 * down and the result up.
	 */
	return XTcl_GetChannelHandle(tls, XTcl_GetStackedChannel(tls, (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fself), direction, handlePtr)
}

/*
 *----------------------------------------------------------------------
 *
 * TransformNotifyProc --
 *
 *	Handler called by Tcl to inform us of activity on the underlying
 *	channel.
 *
 * Side effects:
 *	May process the incoming event by itself.
 *
 * Result:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _TransformNotifyProc(tls *libc.TLS, clientData uintptr, mask int32) (r int32) {
	/* The mask of occurring events. */
	var dataPtr uintptr
	_ = dataPtr
	dataPtr = clientData
	/*
	 * An event occurred in the underlying channel. This transformation doesn't
	 * process such events thus returns the incoming mask unchanged.
	 */
	if (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Ftimer != libc.UintptrFromInt32(0) {
		/*
		 * Delete an existing timer. It was not fired, yet we are here, so the
		 * channel below generated such an event and we don't have to. The
		 * renewal of the interest after the execution of channel handlers
		 * will eventually cause us to recreate the timer (in
		 * TransformWatchProc).
		 */
		XTcl_DeleteTimerHandler(tls, (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Ftimer)
		(*TTransformChannelData)(unsafe.Pointer(dataPtr)).Ftimer = libc.UintptrFromInt32(0)
	}
	return mask
}

/*
 *----------------------------------------------------------------------
 *
 * TransformChannelHandlerTimer --
 *
 *	Called by the notifier (-> timer) to flush out information waiting in
 *	the input buffer.
 *
 * Side effects:
 *	As of 'Tcl_NotifyChannel'.
 *
 * Result:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _TransformChannelHandlerTimer(tls *libc.TLS, clientData uintptr) {
	/* Transformation to query. */
	var dataPtr uintptr
	_ = dataPtr
	dataPtr = clientData
	(*TTransformChannelData)(unsafe.Pointer(dataPtr)).Ftimer = libc.UintptrFromInt32(0)
	if !((*TTransformChannelData)(unsafe.Pointer(dataPtr)).FwatchMask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0) || _ResultEmpty(tls, dataPtr+64) != 0 {
		/*
		 * The timer fired, but either is there no (more) interest in the
		 * events it generates or nothing is available for reading, so ignore
		 * it and don't recreate it.
		 */
		return
	}
	XTcl_NotifyChannel(tls, (*TTransformChannelData)(unsafe.Pointer(dataPtr)).Fself, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1))
}

/*
 *----------------------------------------------------------------------
 *
 * ResultClear --
 *
 *	Deallocates any memory allocated by 'ResultAdd'.
 *
 * Side effects:
 *	See above.
 *
 * Result:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _ResultClear1(tls *libc.TLS, r uintptr) {
	/* Reference to the buffer to clear out. */
	(*TResultBuffer)(unsafe.Pointer(r)).Fused = uint64(0)
	if (*TResultBuffer)(unsafe.Pointer(r)).Fallocated != 0 {
		XTclpFree(tls, (*TResultBuffer)(unsafe.Pointer(r)).Fbuf)
		(*TResultBuffer)(unsafe.Pointer(r)).Fbuf = libc.UintptrFromInt32(0)
		(*TResultBuffer)(unsafe.Pointer(r)).Fallocated = uint64(0)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * ResultInit --
 *
 *	Initializes the specified buffer structure. The structure will contain
 *	valid information for an empty buffer.
 *
 * Side effects:
 *	See above.
 *
 * Result:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _ResultInit1(tls *libc.TLS, r uintptr) {
	/* Reference to the structure to
	 * initialize. */
	(*TResultBuffer)(unsafe.Pointer(r)).Fused = uint64(0)
	(*TResultBuffer)(unsafe.Pointer(r)).Fallocated = uint64(0)
	(*TResultBuffer)(unsafe.Pointer(r)).Fbuf = libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * ResultEmpty --
 *
 *	Returns whether the number of bytes stored in the buffer is zero.
 *
 * Side effects:
 *	None.
 *
 * Result:
 *	A boolean.
 *
 *----------------------------------------------------------------------
 */

func _ResultEmpty(tls *libc.TLS, r uintptr) (r1 int32) {
	/* The structure to query. */
	return libc.BoolInt32((*TResultBuffer)(unsafe.Pointer(r)).Fused == uint64(0))
}

/*
 *----------------------------------------------------------------------
 *
 * ResultCopy --
 *
 *	Copies the requested number of bytes from the buffer into the
 *	specified array and removes them from the buffer afterward. Copies
 *	less if there is not enough data in the buffer.
 *
 * Side effects:
 *	See above.
 *
 * Result:
 *	The number of actually copied bytes, possibly less than 'toRead'.
 *
 *----------------------------------------------------------------------
 */

func _ResultCopy1(tls *libc.TLS, r uintptr, buf uintptr, toRead Tsize_t) (r1 Tsize_t) {
	/* Number of requested bytes. */
	if _ResultEmpty(tls, r) != 0 {
		/*
		 * Nothing to copy in the case of an empty buffer.
		 */
		return uint64(0)
	} else {
		if (*TResultBuffer)(unsafe.Pointer(r)).Fused == toRead {
			/*
			 * We have just enough. Copy everything to the caller.
			 */
			libc.Xmemcpy(tls, buf, (*TResultBuffer)(unsafe.Pointer(r)).Fbuf, toRead)
			(*TResultBuffer)(unsafe.Pointer(r)).Fused = uint64(0)
		} else {
			if (*TResultBuffer)(unsafe.Pointer(r)).Fused > toRead {
				/*
				 * The internal buffer contains more than requested. Copy the
				 * requested subset to the caller, and shift the remaining bytes down.
				 */
				libc.Xmemcpy(tls, buf, (*TResultBuffer)(unsafe.Pointer(r)).Fbuf, toRead)
				libc.Xmemmove(tls, (*TResultBuffer)(unsafe.Pointer(r)).Fbuf, (*TResultBuffer)(unsafe.Pointer(r)).Fbuf+uintptr(toRead), (*TResultBuffer)(unsafe.Pointer(r)).Fused-toRead)
				*(*Tsize_t)(unsafe.Pointer(r + 16)) -= toRead
			} else {
				/*
				 * There is not enough in the buffer to satisfy the caller, so take
				 * everything.
				 */
				libc.Xmemcpy(tls, buf, (*TResultBuffer)(unsafe.Pointer(r)).Fbuf, (*TResultBuffer)(unsafe.Pointer(r)).Fused)
				toRead = (*TResultBuffer)(unsafe.Pointer(r)).Fused
				(*TResultBuffer)(unsafe.Pointer(r)).Fused = uint64(0)
			}
		}
	}
	return toRead
}

/*
 *----------------------------------------------------------------------
 *
 * ResultAdd --
 *
 *	Adds the bytes in the specified array to the buffer, by appending it.
 *
 * Side effects:
 *	See above.
 *
 * Result:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _ResultAdd1(tls *libc.TLS, r uintptr, buf uintptr, toWrite Tsize_t) {
	/* The number of bytes in 'buf'. */
	if (*TResultBuffer)(unsafe.Pointer(r)).Fused+toWrite+uint64(1) > (*TResultBuffer)(unsafe.Pointer(r)).Fallocated {
		/*
		 * Extension of the internal buffer is required.
		 */
		if (*TResultBuffer)(unsafe.Pointer(r)).Fallocated == uint64(0) {
			(*TResultBuffer)(unsafe.Pointer(r)).Fallocated = toWrite + uint64(INCREMENT)
			(*TResultBuffer)(unsafe.Pointer(r)).Fbuf = XTcl_Alloc(tls, (*TResultBuffer)(unsafe.Pointer(r)).Fallocated)
		} else {
			*(*Tsize_t)(unsafe.Pointer(r + 8)) += toWrite + uint64(INCREMENT)
			(*TResultBuffer)(unsafe.Pointer(r)).Fbuf = XTcl_Realloc(tls, (*TResultBuffer)(unsafe.Pointer(r)).Fbuf, (*TResultBuffer)(unsafe.Pointer(r)).Fallocated)
		}
	}
	/*
	 * Now we may copy the data.
	 */
	libc.Xmemcpy(tls, (*TResultBuffer)(unsafe.Pointer(r)).Fbuf+uintptr((*TResultBuffer)(unsafe.Pointer(r)).Fused), buf, toWrite)
	*(*Tsize_t)(unsafe.Pointer(r + 16)) += toWrite
}

const SOCKET = 0

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 *---------------------------------------------------------------------------
 *
 * TclSockGetPort --
 *
 *	Maps from a string, which could be a service name, to a port. Used by
 *	socket creation code to get port numbers and resolve registered
 *	service names to port numbers.
 *
 * Results:
 *	A standard Tcl result. On success, the port number is returned in
 *	portPtr. On failure, an error message is left in the interp's result.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTclSockGetPort(tls *libc.TLS, interp uintptr, string1 uintptr, proto uintptr, portPtr uintptr) (r int32) {
	bp := tls.Alloc(224)
	defer tls.Free(224) /* Return port number */
	var native, sp uintptr
	var _ /* ds at bp+0 */ TTcl_DString
	_, _ = native, sp
	if XTcl_GetInt(tls, libc.UintptrFromInt32(0), string1, portPtr) != TCL_OK {
		/*
		 * Don't bother translating 'proto' to native.
		 */
		if XTcl_UtfToExternalDStringEx(tls, interp, libc.UintptrFromInt32(0), string1, int64(-int32(1)), 0, bp, libc.UintptrFromInt32(0)) != TCL_OK {
			XTcl_DStringFree(tls, bp)
			return int32(TCL_ERROR)
		}
		native = (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1
		sp = libc.Xgetservbyname(tls, native, proto) /* INTL: Native. */
		XTcl_DStringFree(tls, bp)
		if sp != libc.UintptrFromInt32(0) {
			*(*int32)(unsafe.Pointer(portPtr)) = libc.Int32FromUint16(libc.Xntohs(tls, libc.Uint16FromInt32((*Tservent)(unsafe.Pointer(sp)).Fs_port)))
			return TCL_OK
		}
	}
	if XTcl_GetInt(tls, interp, string1, portPtr) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if *(*int32)(unsafe.Pointer(portPtr)) > int32(0xFFFF) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+49073, int64(-int32(1))))
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclSockMinimumBuffers --
 *
 *	Ensure minimum buffer sizes (non zero).
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Sets SO_SNDBUF and SO_RCVBUF sizes.
 *
 *----------------------------------------------------------------------
 */

func XTclSockMinimumBuffers(tls *libc.TLS, sock uintptr, size1 TTcl_Size) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Minimum buffer size */
	var _ /* current at bp+0 */ int32
	var _ /* len at bp+4 */ Tsocklen_t
	var _ /* size at bp+8 */ int32
	*(*int32)(unsafe.Pointer(bp + 8)) = int32(size1)
	if int64(*(*int32)(unsafe.Pointer(bp + 8))) != size1 {
		return int32(TCL_ERROR)
	}
	*(*Tsocklen_t)(unsafe.Pointer(bp + 4)) = uint32(4)
	libc.Xgetsockopt(tls, libc.Int32FromUint64(uint64(sock)), int32(SOL_SOCKET), int32(SO_SNDBUF), bp, bp+4)
	if *(*int32)(unsafe.Pointer(bp)) < *(*int32)(unsafe.Pointer(bp + 8)) {
		*(*Tsocklen_t)(unsafe.Pointer(bp + 4)) = uint32(4)
		libc.Xsetsockopt(tls, libc.Int32FromUint64(uint64(sock)), int32(SOL_SOCKET), int32(SO_SNDBUF), bp+8, *(*Tsocklen_t)(unsafe.Pointer(bp + 4)))
	}
	*(*Tsocklen_t)(unsafe.Pointer(bp + 4)) = uint32(4)
	libc.Xgetsockopt(tls, libc.Int32FromUint64(uint64(sock)), int32(SOL_SOCKET), int32(SO_RCVBUF), bp, bp+4)
	if *(*int32)(unsafe.Pointer(bp)) < *(*int32)(unsafe.Pointer(bp + 8)) {
		*(*Tsocklen_t)(unsafe.Pointer(bp + 4)) = uint32(4)
		libc.Xsetsockopt(tls, libc.Int32FromUint64(uint64(sock)), int32(SOL_SOCKET), int32(SO_RCVBUF), bp+8, *(*Tsocklen_t)(unsafe.Pointer(bp + 4)))
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCreateSocketAddress --
 *
 *	This function initializes a sockaddr structure for a host and port.
 *
 * Results:
 *	1 if the host was valid, 0 if the host could not be converted to an IP
 *	address.
 *
 * Side effects:
 *	Fills in the *sockaddrPtr structure.
 *
 *----------------------------------------------------------------------
 */

func XTclCreateSocketAddress(tls *libc.TLS, interp uintptr, addrlist uintptr, host uintptr, port int32, willBind int32, errorMsgPtr uintptr) (r int32) {
	bp := tls.Alloc(304)
	defer tls.Free(304) /* Place to store the error message detail, if
	 * available. */
	var family, native, p, portstring, v4head, v4ptr, v6head, v6ptr, v1 uintptr
	var result int32
	var _ /* ds at bp+72 */ TTcl_DString
	var _ /* hints at bp+0 */ Taddrinfo
	var _ /* portbuf at bp+48 */ [24]uint8
	_, _, _, _, _, _, _, _, _, _ = family, native, p, portstring, result, v4head, v4ptr, v6head, v6ptr, v1
	v4head = libc.UintptrFromInt32(0)
	v4ptr = libc.UintptrFromInt32(0)
	v6head = libc.UintptrFromInt32(0)
	v6ptr = libc.UintptrFromInt32(0)
	native = libc.UintptrFromInt32(0)
	family = libc.UintptrFromInt32(0)
	if host != libc.UintptrFromInt32(0) {
		if XTcl_UtfToExternalDStringEx(tls, interp, libc.UintptrFromInt32(0), host, int64(-int32(1)), 0, bp+72, libc.UintptrFromInt32(0)) != TCL_OK {
			XTcl_DStringFree(tls, bp+72)
			return 0
		}
		native = (*TTcl_DString)(unsafe.Pointer(bp + 72)).Fstring1
	}
	/*
	 * Workaround for OSX's apparent inability to resolve "localhost", "0"
	 * when the loopback device is the only available network interface.
	 */
	if host != libc.UintptrFromInt32(0) && port == 0 {
		portstring = libc.UintptrFromInt32(0)
	} else {
		XTclFormatInt(tls, bp+48, int64(port))
		portstring = bp + 48
	}
	libc.Xmemset(tls, bp, 0, uint64(48))
	(*(*Taddrinfo)(unsafe.Pointer(bp))).Fai_family = PF_UNSPEC
	/*
	 * Magic variable to enforce a certain address family; to be superseded
	 * by a TIP that adds explicit switches to [socket].
	 */
	if interp != libc.UintptrFromInt32(0) {
		family = XTcl_GetVar2(tls, interp, __ccgo_ts+49116, libc.UintptrFromInt32(0), 0)
		if family != libc.UintptrFromInt32(0) {
			if libc.Xstrcmp(tls, family, __ccgo_ts+49145) == 0 {
				(*(*Taddrinfo)(unsafe.Pointer(bp))).Fai_family = int32(PF_INET)
			} else {
				if libc.Xstrcmp(tls, family, __ccgo_ts+49150) == 0 {
					(*(*Taddrinfo)(unsafe.Pointer(bp))).Fai_family = int32(PF_INET6)
				}
			}
		}
	}
	(*(*Taddrinfo)(unsafe.Pointer(bp))).Fai_socktype = int32(SOCK_STREAM)
	if willBind != 0 {
		(*(*Taddrinfo)(unsafe.Pointer(bp))).Fai_flags |= int32(AI_PASSIVE)
	}
	result = libc.Xgetaddrinfo(tls, native, portstring, bp, addrlist)
	if host != libc.UintptrFromInt32(0) {
		XTcl_DStringFree(tls, bp+72)
	}
	if result != 0 {
		if result == -int32(11) {
			v1 = XTcl_PosixError(tls, interp)
		} else {
			v1 = libc.Xgai_strerror(tls, result)
		}
		*(*uintptr)(unsafe.Pointer(errorMsgPtr)) = v1
		return 0
	}
	/*
	 * Put IPv4 addresses before IPv6 addresses to maximize backwards
	 * compatibility of [fconfigure -sockname] output.
	 *
	 * There might be more elegant/efficient ways to do this.
	 */
	if willBind != 0 {
		p = *(*uintptr)(unsafe.Pointer(addrlist))
		for {
			if !(p != libc.UintptrFromInt32(0)) {
				break
			}
			if (*Taddrinfo)(unsafe.Pointer(p)).Fai_family == int32(PF_INET) {
				if v4head == libc.UintptrFromInt32(0) {
					v4head = p
				} else {
					(*Taddrinfo)(unsafe.Pointer(v4ptr)).Fai_next = p
				}
				v4ptr = p
			} else {
				if v6head == libc.UintptrFromInt32(0) {
					v6head = p
				} else {
					(*Taddrinfo)(unsafe.Pointer(v6ptr)).Fai_next = p
				}
				v6ptr = p
			}
			goto _2
		_2:
			;
			p = (*Taddrinfo)(unsafe.Pointer(p)).Fai_next
		}
		*(*uintptr)(unsafe.Pointer(addrlist)) = libc.UintptrFromInt32(0)
		if v6head != libc.UintptrFromInt32(0) {
			*(*uintptr)(unsafe.Pointer(addrlist)) = v6head
			(*Taddrinfo)(unsafe.Pointer(v6ptr)).Fai_next = libc.UintptrFromInt32(0)
		}
		if v4head != libc.UintptrFromInt32(0) {
			(*Taddrinfo)(unsafe.Pointer(v4ptr)).Fai_next = *(*uintptr)(unsafe.Pointer(addrlist))
			*(*uintptr)(unsafe.Pointer(addrlist)) = v4head
		}
	}
	return int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_OpenTcpServer --
 *
 *	Opens a TCP server socket and creates a channel around it.
 *
 * Results:
 *	The channel or NULL if failed. If an error occurred, an error message
 *	is left in the interp's result if interp is not NULL.
 *
 * Side effects:
 *	Opens a server socket and creates a new channel.
 *
 *----------------------------------------------------------------------
 */

func XTcl_OpenTcpServer(tls *libc.TLS, interp uintptr, port int32, host uintptr, acceptProc uintptr, callbackData uintptr) (r TTcl_Channel) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _ /* portbuf at bp+0 */ [24]uint8
	XTclFormatInt(tls, bp, int64(port))
	return XTcl_OpenTcpServerEx(tls, interp, bp, host, libc.Uint32FromInt32(-libc.Int32FromInt32(1)), libc.Int32FromInt32(1)<<libc.Int32FromInt32(0), acceptProc, callbackData)
}

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * struct FilesystemRecord --
 *
 * An item in a linked list of registered filesystems
 */

type TFilesystemRecord = struct {
	FclientData uintptr
	FfsPtr      uintptr
	FnextPtr    uintptr
	FprevPtr    uintptr
}

/*
 */

type TThreadSpecificData7 = struct {
	Finitialized     int32
	FcwdPathEpoch    Tsize_t
	FfilesystemEpoch Tsize_t
	FcwdPathPtr      uintptr
	FcwdClientData   uintptr
	FfilesystemList  uintptr
	Fclaims          Tsize_t
}

func init() {
	p := unsafe.Pointer(&XtclNativeFilesystem)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(XTclNativePathInFilesystem)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(XTclNativeDupInternalRep)
	*(*uintptr)(unsafe.Add(p, 40)) = __ccgo_fp(_NativeFreeInternalRep)
	*(*uintptr)(unsafe.Add(p, 48)) = __ccgo_fp(XTclpNativeToNormalized)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(XTclNativeCreateNativeRep)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(XTclpObjNormalizePath)
	*(*uintptr)(unsafe.Add(p, 72)) = __ccgo_fp(XTclpFilesystemPathType)
	*(*uintptr)(unsafe.Add(p, 80)) = __ccgo_fp(_NativeFilesystemSeparator)
	*(*uintptr)(unsafe.Add(p, 88)) = __ccgo_fp(XTclpObjStat)
	*(*uintptr)(unsafe.Add(p, 96)) = __ccgo_fp(XTclpObjAccess)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(XTclpOpenFileChannel)
	*(*uintptr)(unsafe.Add(p, 112)) = __ccgo_fp(XTclpMatchInDirectory)
	*(*uintptr)(unsafe.Add(p, 120)) = __ccgo_fp(XTclpUtime)
	*(*uintptr)(unsafe.Add(p, 128)) = __ccgo_fp(XTclpObjLink)
	*(*uintptr)(unsafe.Add(p, 136)) = __ccgo_fp(XTclpObjListVolumes)
	*(*uintptr)(unsafe.Add(p, 144)) = __ccgo_fp(_NativeFileAttrStrings)
	*(*uintptr)(unsafe.Add(p, 152)) = __ccgo_fp(_NativeFileAttrsGet)
	*(*uintptr)(unsafe.Add(p, 160)) = __ccgo_fp(_NativeFileAttrsSet)
	*(*uintptr)(unsafe.Add(p, 168)) = __ccgo_fp(XTclpObjCreateDirectory)
	*(*uintptr)(unsafe.Add(p, 176)) = __ccgo_fp(XTclpObjRemoveDirectory)
	*(*uintptr)(unsafe.Add(p, 184)) = __ccgo_fp(XTclpObjDeleteFile)
	*(*uintptr)(unsafe.Add(p, 192)) = __ccgo_fp(XTclpObjCopyFile)
	*(*uintptr)(unsafe.Add(p, 200)) = __ccgo_fp(XTclpObjRenameFile)
	*(*uintptr)(unsafe.Add(p, 208)) = __ccgo_fp(XTclpObjCopyDirectory)
	*(*uintptr)(unsafe.Add(p, 216)) = __ccgo_fp(XTclpObjLstat)
	*(*uintptr)(unsafe.Add(p, 224)) = __ccgo_fp(XTclpDlopen)
	*(*uintptr)(unsafe.Add(p, 232)) = __ccgo_fp(XTclpGetNativeCwd)
	*(*uintptr)(unsafe.Add(p, 240)) = __ccgo_fp(XTclpObjChdir)
}

/*
 * An initial record in the linked list for the native filesystem.  Remains at
 * the tail of the list and is never freed.  Currently the native filesystem is
 * hard-coded.  It may make sense to modify this to accommodate unconventional
 * uses of Tcl that provide no native filesystem.
 */

var _nativeFilesystemRecord = TFilesystemRecord{
	FfsPtr: uintptr(unsafe.Pointer(&XtclNativeFilesystem)),
}

/*
 * Incremented each time the linked list of filesystems is modified.  For
 * multithreaded builds, invalidates all cached filesystem internal
 * representations.
 */

var _theFilesystemEpoch = uint64(1)

/*
 * The linked list of filesystems.  To minimize locking each thread maintains a
 * local copy of this list.
 *
 */

var _filesystemList = uintptr(unsafe.Pointer(&_nativeFilesystemRecord))

var _filesystemMutex TTcl_Mutex

/*
 * A files-system indepent sense of the current directory.
 */

var _cwdPathPtr = libc.UintptrFromInt32(0)
var _cwdPathEpoch = uint64(0) /* The pathname of the current directory */
var _cwdClientData = libc.UintptrFromInt32(0)

var _cwdMutex TTcl_Mutex

var _fsDataKey TTcl_ThreadDataKey

/*
 * When a temporary copy of a file is created on the native filesystem in order
 * to load the file, an FsDivertLoad structure is created to track both the
 * actual unloadProc/clientData combination which was used, and the original and
 * modified filenames.  This makes it possible to correctly undo the entire
 * operation in order to unload the library.
 */

type TFsDivertLoad = struct {
	FloadHandle            TTcl_LoadHandle
	FunloadProcPtr         uintptr
	FdivertedFile          uintptr
	FdivertedFilesystem    uintptr
	FdivertedFileNativeRep uintptr
}

/*
 * Obsolete string-based APIs that should be removed in a future release,
 * perhaps in Tcl 9.
 */

// C documentation
//
//	/* Obsolete */
func XTcl_Stat(tls *libc.TLS, path uintptr, oldStyleBuf uintptr) (r int32) {
	bp := tls.Alloc(144)
	defer tls.Free(144) /* Filled with results of stat call. */
	var _objPtr, pathPtr, v2 uintptr
	var ret int32
	var v1 TTcl_Size
	var _ /* buf at bp+0 */ TTcl_StatBuf
	_, _, _, _, _ = _objPtr, pathPtr, ret, v1, v2
	pathPtr = XTcl_NewStringObj(tls, path, int64(-int32(1)))
	(*TTcl_Obj)(unsafe.Pointer(pathPtr)).FrefCount++
	ret = XTcl_FSStat(tls, pathPtr, bp)
	_objPtr = pathPtr
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	if ret != -int32(1) {
		/*
		 * Copy across all supported fields, with possible type coercion on
		 * those fields that change between the normal and lf64 versions of
		 * the stat structure (on Solaris at least). This is slow when the
		 * structure sizes coincide, but that's what you get for using an
		 * obsolete interface.
		 */
		(*Tstat)(unsafe.Pointer(oldStyleBuf)).Fst_mode = (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_mode
		(*Tstat)(unsafe.Pointer(oldStyleBuf)).Fst_ino = (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_ino
		(*Tstat)(unsafe.Pointer(oldStyleBuf)).Fst_dev = (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_dev
		(*Tstat)(unsafe.Pointer(oldStyleBuf)).Fst_rdev = (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_rdev
		(*Tstat)(unsafe.Pointer(oldStyleBuf)).Fst_nlink = (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_nlink
		(*Tstat)(unsafe.Pointer(oldStyleBuf)).Fst_uid = (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_uid
		(*Tstat)(unsafe.Pointer(oldStyleBuf)).Fst_gid = (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_gid
		(*Tstat)(unsafe.Pointer(oldStyleBuf)).Fst_size = (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_size
		(*Tstat)(unsafe.Pointer(oldStyleBuf)).Fst_atim.Ftv_sec = XTcl_GetAccessTimeFromStat(tls, bp)
		(*Tstat)(unsafe.Pointer(oldStyleBuf)).Fst_mtim.Ftv_sec = XTcl_GetModificationTimeFromStat(tls, bp)
		(*Tstat)(unsafe.Pointer(oldStyleBuf)).Fst_ctim.Ftv_sec = XTcl_GetChangeTimeFromStat(tls, bp)
		(*Tstat)(unsafe.Pointer(oldStyleBuf)).Fst_blksize = (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_blksize
		(*Tstat)(unsafe.Pointer(oldStyleBuf)).Fst_blocks = (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_blocks
	}
	return ret
}

// C documentation
//
//	/* Obsolete */
func XTcl_Access(tls *libc.TLS, path uintptr, mode int32) (r int32) {
	/* Permission setting. */
	var _objPtr, pathPtr, v2 uintptr
	var ret int32
	var v1 TTcl_Size
	_, _, _, _, _ = _objPtr, pathPtr, ret, v1, v2
	pathPtr = XTcl_NewStringObj(tls, path, int64(-int32(1)))
	(*TTcl_Obj)(unsafe.Pointer(pathPtr)).FrefCount++
	ret = XTcl_FSAccess(tls, pathPtr, mode)
	_objPtr = pathPtr
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return ret
}

// C documentation
//
//	/* Obsolete */
func XTcl_OpenFileChannel(tls *libc.TLS, interp uintptr, path uintptr, modeString uintptr, permissions int32) (r TTcl_Channel) {
	/* The modes to use if creating a new file. */
	var _objPtr, pathPtr, v2 uintptr
	var ret TTcl_Channel
	var v1 TTcl_Size
	_, _, _, _, _ = _objPtr, pathPtr, ret, v1, v2
	pathPtr = XTcl_NewStringObj(tls, path, int64(-int32(1)))
	(*TTcl_Obj)(unsafe.Pointer(pathPtr)).FrefCount++
	ret = XTcl_FSOpenFileChannel(tls, interp, pathPtr, modeString, permissions)
	_objPtr = pathPtr
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return ret
}

// C documentation
//
//	/* Obsolete */
func XTcl_Chdir(tls *libc.TLS, dirName uintptr) (r int32) {
	var _objPtr, pathPtr, v2 uintptr
	var ret int32
	var v1 TTcl_Size
	_, _, _, _, _ = _objPtr, pathPtr, ret, v1, v2
	pathPtr = XTcl_NewStringObj(tls, dirName, int64(-int32(1)))
	(*TTcl_Obj)(unsafe.Pointer(pathPtr)).FrefCount++
	ret = XTcl_FSChdir(tls, pathPtr)
	_objPtr = pathPtr
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return ret
}

// C documentation
//
//	/* Obsolete */
func XTcl_GetCwd(tls *libc.TLS, interp uintptr, cwdPtr uintptr) (r uintptr) {
	var _objPtr, cwd, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _ = _objPtr, cwd, v1, v2
	cwd = XTcl_FSGetCwd(tls, interp)
	if cwd == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	XTcl_DStringInit(tls, cwdPtr)
	XTclDStringAppendObj(tls, cwdPtr, cwd)
	_objPtr = cwd
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return (*TTcl_DString)(unsafe.Pointer(cwdPtr)).Fstring1
}

func XTcl_EvalFile(tls *libc.TLS, interp uintptr, fileName uintptr) (r int32) {
	/* Pathname of the file containing the script.
	 * Performs Tilde-substitution on this
	 * pathaname. */
	var _objPtr, pathPtr, v2 uintptr
	var ret int32
	var v1 TTcl_Size
	_, _, _, _, _ = _objPtr, pathPtr, ret, v1, v2
	pathPtr = XTcl_NewStringObj(tls, fileName, int64(-int32(1)))
	(*TTcl_Obj)(unsafe.Pointer(pathPtr)).FrefCount++
	ret = XTcl_FSEvalFile(tls, interp, pathPtr)
	_objPtr = pathPtr
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return ret
}

/*
 * The basic filesystem implementation.
 */

func _FsThrExitProc(tls *libc.TLS, cd uintptr) {
	var _objPtr, fsRecPtr, tmpFsRecPtr, tsdPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _, _, _ = _objPtr, fsRecPtr, tmpFsRecPtr, tsdPtr, v1, v2
	tsdPtr = cd
	fsRecPtr = libc.UintptrFromInt32(0)
	tmpFsRecPtr = libc.UintptrFromInt32(0)
	/*
	 * Discard the cwd copy.
	 */
	if (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr != libc.UintptrFromInt32(0) {
		_objPtr = (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		(*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr = libc.UintptrFromInt32(0)
	}
	if (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdClientData != libc.UintptrFromInt32(0) {
		_NativeFreeInternalRep(tls, (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdClientData)
	}
	/*
	 * Discard the filesystems cache.
	 */
	fsRecPtr = (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FfilesystemList
	for fsRecPtr != libc.UintptrFromInt32(0) {
		tmpFsRecPtr = (*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FnextPtr
		(*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FfsPtr = libc.UintptrFromInt32(0)
		XTclpFree(tls, fsRecPtr)
		fsRecPtr = tmpFsRecPtr
	}
	(*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FfilesystemList = libc.UintptrFromInt32(0)
	(*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).Finitialized = 0
}

func XTclFSCwdIsNative(tls *libc.TLS) (r int32) {
	var _objPtr, temp, tsdPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _, _ = _objPtr, temp, tsdPtr, v1, v2
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_fsDataKey)), int64(56))
	/* if not yet initialized - ensure we'll once obtain cwd */
	if !((*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathEpoch != 0) {
		temp = XTcl_FSGetCwd(tls, libc.UintptrFromInt32(0))
		if temp != 0 {
			_objPtr = temp
			v2 = _objPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if v1 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
	}
	if (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdClientData != libc.UintptrFromInt32(0) {
		return int32(1)
	} else {
		return 0
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * TclFSCwdPointerEquals --
 *	Determine whether the given pathname is equal to the current working
 *	directory.
 *
 * Results:
 *	1 if equal, 0 otherwise.
 *
 * Side effects:
 *	Updates TSD if needed.
 *
 *	Stores a pointer to the current directory in *pathPtrPtr if it is not
 *	already there and the current directory is not NULL.
 *
 *	If *pathPtrPtr is not null its reference count is decremented
 *	before it is replaced.
 *----------------------------------------------------------------------
 */

func XTclFSCwdPointerEquals(tls *libc.TLS, pathPtrPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, _objPtr1, str1, str2, tsdPtr, v2, v3, v4, v6 uintptr
	var v1, v5 TTcl_Size
	var _ /* len1 at bp+0 */ TTcl_Size
	var _ /* len2 at bp+8 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, str1, str2, tsdPtr, v1, v2, v3, v4, v5, v6
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_fsDataKey)), int64(56))
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_cwdMutex)))
	if (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr == libc.UintptrFromInt32(0) || (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathEpoch != _cwdPathEpoch {
		if (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr != libc.UintptrFromInt32(0) {
			_objPtr = (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr
			v2 = _objPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if v1 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
		if (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdClientData != libc.UintptrFromInt32(0) {
			_NativeFreeInternalRep(tls, (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdClientData)
		}
		if _cwdPathPtr == libc.UintptrFromInt32(0) {
			(*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr = libc.UintptrFromInt32(0)
		} else {
			(*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr = XTcl_DuplicateObj(tls, _cwdPathPtr)
			(*TTcl_Obj)(unsafe.Pointer((*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr)).FrefCount++
		}
		if _cwdClientData == libc.UintptrFromInt32(0) {
			(*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdClientData = libc.UintptrFromInt32(0)
		} else {
			(*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdClientData = XTclNativeDupInternalRep(tls, _cwdClientData)
		}
		(*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathEpoch = _cwdPathEpoch
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_cwdMutex)))
	if (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).Finitialized == 0 {
		XTcl_CreateThreadExitHandler(tls, __ccgo_fp(_FsThrExitProc), tsdPtr)
		(*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).Finitialized = int32(1)
	}
	if pathPtrPtr == libc.UintptrFromInt32(0) {
		return libc.BoolInt32((*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr == libc.UintptrFromInt32(0))
	}
	if (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr == *(*uintptr)(unsafe.Pointer(pathPtrPtr)) {
		return int32(1)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer((*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer((*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr)).Flength
			v3 = (*TTcl_Obj)(unsafe.Pointer((*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr)).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr, bp)
		}
		str1 = v3
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(pathPtrPtr)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(pathPtrPtr)))).Flength
			v4 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(pathPtrPtr)))).Fbytes
		} else {
			v4 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(pathPtrPtr)), bp+8)
		}
		str2 = v4
		if *(*TTcl_Size)(unsafe.Pointer(bp)) == *(*TTcl_Size)(unsafe.Pointer(bp + 8)) && !(libc.Xmemcmp(tls, str1, str2, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))) != 0) {
			/*
			 * The values are equal but the objects are different.  Cache the
			 * current structure in place of the old one.
			 */
			_objPtr1 = *(*uintptr)(unsafe.Pointer(pathPtrPtr))
			v6 = _objPtr1
			v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
			*(*TTcl_Size)(unsafe.Pointer(v6))--
			if v5 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
			*(*uintptr)(unsafe.Pointer(pathPtrPtr)) = (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(pathPtrPtr)))).FrefCount++
			return int32(1)
		} else {
			return 0
		}
	}
	return r
}

func _FsRecacheFilesystemList(tls *libc.TLS) {
	var fsRecPtr, list, next, tmpFsRecPtr, toFree, tsdPtr uintptr
	_, _, _, _, _, _ = fsRecPtr, list, next, tmpFsRecPtr, toFree, tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_fsDataKey)), int64(56))
	tmpFsRecPtr = libc.UintptrFromInt32(0)
	toFree = libc.UintptrFromInt32(0)
	/*
	 * Trash the current cache.
	 */
	fsRecPtr = (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FfilesystemList
	for fsRecPtr != libc.UintptrFromInt32(0) {
		tmpFsRecPtr = (*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FnextPtr
		(*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FnextPtr = toFree
		toFree = fsRecPtr
		fsRecPtr = tmpFsRecPtr
	}
	/*
	 * Locate tail of the global filesystem list.
	 */
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_filesystemMutex)))
	fsRecPtr = _filesystemList
	for fsRecPtr != libc.UintptrFromInt32(0) {
		tmpFsRecPtr = fsRecPtr
		fsRecPtr = (*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FnextPtr
	}
	/*
	 * Refill the cache, honouring the order.
	 */
	list = libc.UintptrFromInt32(0)
	fsRecPtr = tmpFsRecPtr
	for fsRecPtr != libc.UintptrFromInt32(0) {
		tmpFsRecPtr = XTcl_Alloc(tls, uint64(32))
		*(*TFilesystemRecord)(unsafe.Pointer(tmpFsRecPtr)) = *(*TFilesystemRecord)(unsafe.Pointer(fsRecPtr))
		(*TFilesystemRecord)(unsafe.Pointer(tmpFsRecPtr)).FnextPtr = list
		(*TFilesystemRecord)(unsafe.Pointer(tmpFsRecPtr)).FprevPtr = libc.UintptrFromInt32(0)
		list = tmpFsRecPtr
		fsRecPtr = (*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FprevPtr
	}
	(*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FfilesystemList = list
	(*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FfilesystemEpoch = _theFilesystemEpoch
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_filesystemMutex)))
	for toFree != 0 {
		next = (*TFilesystemRecord)(unsafe.Pointer(toFree)).FnextPtr
		(*TFilesystemRecord)(unsafe.Pointer(toFree)).FfsPtr = libc.UintptrFromInt32(0)
		XTclpFree(tls, toFree)
		toFree = next
	}
	/*
	 * Make sure the above gets released on thread exit.
	 */
	if (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).Finitialized == 0 {
		XTcl_CreateThreadExitHandler(tls, __ccgo_fp(_FsThrExitProc), tsdPtr)
		(*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).Finitialized = int32(1)
	}
}

func _FsGetFirstFilesystem(tls *libc.TLS) (r uintptr) {
	var tsdPtr uintptr
	_ = tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_fsDataKey)), int64(56))
	if (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FfilesystemList == libc.UintptrFromInt32(0) || (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).Fclaims == uint64(0) && (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FfilesystemEpoch != _theFilesystemEpoch {
		_FsRecacheFilesystemList(tls)
	}
	return (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FfilesystemList
}

/*
 * The epoch can is changed when a filesystems is added or removed, when
 * "system encoding" changes, and when env(HOME) changes.
 */

func XTclFSEpochOk(tls *libc.TLS, filesystemEpoch Tsize_t) (r int32) {
	return libc.BoolInt32(filesystemEpoch == uint64(0) || filesystemEpoch == _theFilesystemEpoch)
}

func _Claim(tls *libc.TLS) {
	var tsdPtr uintptr
	_ = tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_fsDataKey)), int64(56))
	(*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).Fclaims++
}

func _Disclaim(tls *libc.TLS) {
	var tsdPtr uintptr
	_ = tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_fsDataKey)), int64(56))
	(*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).Fclaims--
}

func XTclFSEpoch(tls *libc.TLS) (r Tsize_t) {
	var tsdPtr uintptr
	_ = tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_fsDataKey)), int64(56))
	return (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FfilesystemEpoch
}

/*
 * If non-NULL, take posession of clientData and free it later.
 */

func _FsUpdateCwd(tls *libc.TLS, cwdObj uintptr, clientData uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, _objPtr1, str, tsdPtr, v1, v3, v6 uintptr
	var v2, v5 TTcl_Size
	var v4 Tsize_t
	var _ /* len at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, str, tsdPtr, v1, v2, v3, v4, v5, v6
	*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	str = libc.UintptrFromInt32(0)
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_fsDataKey)), int64(56))
	if cwdObj != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(cwdObj)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(cwdObj)).Flength
			v1 = (*TTcl_Obj)(unsafe.Pointer(cwdObj)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, cwdObj, bp)
		}
		str = v1
	}
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_cwdMutex)))
	if _cwdPathPtr != libc.UintptrFromInt32(0) {
		_objPtr = _cwdPathPtr
		v3 = _objPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	if _cwdClientData != libc.UintptrFromInt32(0) {
		_NativeFreeInternalRep(tls, _cwdClientData)
	}
	if cwdObj == libc.UintptrFromInt32(0) {
		_cwdPathPtr = libc.UintptrFromInt32(0)
		_cwdClientData = libc.UintptrFromInt32(0)
	} else {
		/*
		 * This must be stored as a string obj!
		 */
		_cwdPathPtr = XTcl_NewStringObj(tls, str, *(*TTcl_Size)(unsafe.Pointer(bp)))
		(*TTcl_Obj)(unsafe.Pointer(_cwdPathPtr)).FrefCount++
		_cwdClientData = XTclNativeDupInternalRep(tls, clientData)
	}
	_cwdPathEpoch++
	v4 = _cwdPathEpoch
	if v4 == uint64(0) {
		_cwdPathEpoch++
	}
	(*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathEpoch = _cwdPathEpoch
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_cwdMutex)))
	if (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr != 0 {
		_objPtr1 = (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr
		v6 = _objPtr1
		v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
		*(*TTcl_Size)(unsafe.Pointer(v6))--
		if v5 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
	if (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdClientData != 0 {
		_NativeFreeInternalRep(tls, (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdClientData)
	}
	if cwdObj == libc.UintptrFromInt32(0) {
		(*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr = libc.UintptrFromInt32(0)
		(*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdClientData = libc.UintptrFromInt32(0)
	} else {
		(*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr = XTcl_NewStringObj(tls, str, *(*TTcl_Size)(unsafe.Pointer(bp)))
		(*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdClientData = clientData
		(*TTcl_Obj)(unsafe.Pointer((*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr)).FrefCount++
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclFinalizeFilesystem --
 *
 *	Clean up the filesystem.  After this, any call to a Tcl_FS... function
 *	fails.
 *
 *	If TclResetFilesystem is called later, it restores the filesystem to a
 *	pristine state.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Frees memory allocated for the filesystem.
 *
 *----------------------------------------------------------------------
 */

func XTclFinalizeFilesystem(tls *libc.TLS) {
	var _objPtr, fsRecPtr, tmpFsRecPtr, v2 uintptr
	var v1 TTcl_Size
	var v3 Tsize_t
	_, _, _, _, _, _ = _objPtr, fsRecPtr, tmpFsRecPtr, v1, v2, v3
	/*
	 * Assume that only one thread is active. Otherwise mutexes would be needed
	 * around this code.
	 * TO DO:  This assumption is false, isn't it?
	 */
	if _cwdPathPtr != libc.UintptrFromInt32(0) {
		_objPtr = _cwdPathPtr
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		_cwdPathPtr = libc.UintptrFromInt32(0)
		_cwdPathEpoch = uint64(0)
	}
	if _cwdClientData != libc.UintptrFromInt32(0) {
		_NativeFreeInternalRep(tls, _cwdClientData)
		_cwdClientData = libc.UintptrFromInt32(0)
	}
	/*
	 * Remove all filesystems, freeing any allocated memory that is no longer
	 * needed.
	 */
	XTclZipfsFinalize(tls)
	fsRecPtr = _filesystemList
	for fsRecPtr != libc.UintptrFromInt32(0) {
		tmpFsRecPtr = (*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FnextPtr
		/*
		 * The native filesystem is static, so don't free it.
		 */
		if fsRecPtr != uintptr(unsafe.Pointer(&_nativeFilesystemRecord)) {
			XTclpFree(tls, fsRecPtr)
		}
		fsRecPtr = tmpFsRecPtr
	}
	_theFilesystemEpoch++
	v3 = _theFilesystemEpoch
	if v3 == uint64(0) {
		_theFilesystemEpoch++
	}
	_filesystemList = libc.UintptrFromInt32(0)
	/*
	 * filesystemList is now NULL. Any attempt to use the filesystem is likely
	 * to fail.
	 */
}

/*
 *----------------------------------------------------------------------
 *
 * TclResetFilesystem --
 *
 *	Restore the filesystem to a pristine state.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclResetFilesystem(tls *libc.TLS) {
	var v1 Tsize_t
	_ = v1
	_filesystemList = uintptr(unsafe.Pointer(&_nativeFilesystemRecord))
	_theFilesystemEpoch++
	v1 = _theFilesystemEpoch
	if v1 == uint64(0) {
		_theFilesystemEpoch++
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FSRegister --
 *
 *	Prepends to the list of registered fileystems a new FilesystemRecord
 *	for the given Tcl_Filesystem, which is added even if it is already in
 *	the list.  To determine whether the filesystem is already in the list,
 *	use Tcl_FSData().
 *
 *	Functions that use the list generally process it from head to tail and
 *	use the first filesystem that is suitable.  Therefore, when adding a
 *	diagnostic filsystem (one which simply reports all fs activity), it
 *	must be at the head of the list.  I.e. it must be the last one
 *	registered.
 *
 * Results:
 *	TCL_OK, or TCL_ERROR if memory for a new node in the list could
 *	not be allocated.
 *
 * Side effects:
 *	Allocates memory for a filesystem record and modifies the list of
 *	registered filesystems.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FSRegister(tls *libc.TLS, clientData uintptr, fsPtr uintptr) (r int32) {
	/* The filesystem record for the new fs. */
	var newFilesystemPtr uintptr
	var v1 Tsize_t
	_, _ = newFilesystemPtr, v1
	if fsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	newFilesystemPtr = XTcl_Alloc(tls, uint64(32))
	(*TFilesystemRecord)(unsafe.Pointer(newFilesystemPtr)).FclientData = clientData
	(*TFilesystemRecord)(unsafe.Pointer(newFilesystemPtr)).FfsPtr = fsPtr
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_filesystemMutex)))
	(*TFilesystemRecord)(unsafe.Pointer(newFilesystemPtr)).FnextPtr = _filesystemList
	(*TFilesystemRecord)(unsafe.Pointer(newFilesystemPtr)).FprevPtr = libc.UintptrFromInt32(0)
	if _filesystemList != 0 {
		(*TFilesystemRecord)(unsafe.Pointer(_filesystemList)).FprevPtr = newFilesystemPtr
	}
	_filesystemList = newFilesystemPtr
	/*
	 * Increment the filesystem epoch counter since existing pathnames might
	 * conceivably now belong to different filesystems.
	 */
	_theFilesystemEpoch++
	v1 = _theFilesystemEpoch
	if v1 == uint64(0) {
		_theFilesystemEpoch++
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_filesystemMutex)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FSUnregister --
 *
 *	Removes the record for given filesystem from the list of registered
 *	filesystems. Refuses to remove the built-in (native) filesystem.  This
 *	might be changed in the future to allow a smaller Tcl core in which the
 *	native filesystem is not used at all, e.g. initializing Tcl over a
 *	network connection.
 *
 * Results:
 *	TCL_OK if the function pointer was successfully removed, or TCL_ERROR
 *	otherwise.
 *
 * Side effects:
 *	The list of registered filesystems is updated.  Memory for the
 *	corresponding FilesystemRecord is eventually freed.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FSUnregister(tls *libc.TLS, fsPtr uintptr) (r int32) {
	/* The filesystem record to remove. */
	var fsRecPtr uintptr
	var retVal int32
	var v1 Tsize_t
	_, _, _ = fsRecPtr, retVal, v1
	retVal = int32(TCL_ERROR)
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_filesystemMutex)))
	/*
	 * Traverse filesystemList in search of the record whose
	 * 'fsPtr' member matches 'fsPtr' and remove that record from the list.
	 * Do not revmoe the record for the native filesystem.
	 */
	fsRecPtr = _filesystemList
	for retVal == int32(TCL_ERROR) && fsRecPtr != uintptr(unsafe.Pointer(&_nativeFilesystemRecord)) {
		if (*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FfsPtr == fsPtr {
			if (*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FprevPtr != 0 {
				(*TFilesystemRecord1)(unsafe.Pointer((*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FprevPtr)).FnextPtr = (*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FnextPtr
			} else {
				_filesystemList = (*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FnextPtr
			}
			if (*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FnextPtr != 0 {
				(*TFilesystemRecord1)(unsafe.Pointer((*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FnextPtr)).FprevPtr = (*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FprevPtr
			}
			/*
			 * Each cached pathname could now belong to a different filesystem,
			 * so increment the filesystem epoch counter to ensure that cached
			 * information about the removed filesystem is not used.
			 */
			_theFilesystemEpoch++
			v1 = _theFilesystemEpoch
			if v1 == uint64(0) {
				_theFilesystemEpoch++
			}
			XTclpFree(tls, fsRecPtr)
			retVal = TCL_OK
		} else {
			fsRecPtr = (*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FnextPtr
		}
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_filesystemMutex)))
	return retVal
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FSMatchInDirectory --
 *
 *	Search in the given pathname for files matching the given pattern.
 *	Used by [glob].  Processes just one pattern for one directory.  Callers
 *	such as TclGlob and DoGlob implement manage the searching of multiple
 *	directories in cases such as
 *		glob -dir $dir -join * pkgIndex.tcl
 *
 * Results:
 *
 *	TCL_OK, or TCL_ERROR
 *
 * Side effects:
 *	resultPtr is populated, or in the case of an TCL_ERROR, an error message is
 *	set in the interpreter.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FSMatchInDirectory(tls *libc.TLS, interp uintptr, resultPtr uintptr, pathPtr uintptr, pattern uintptr, types uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Specifies acceptable types.
	 * May be NULL. The directory flag is
	 * particularly significant. */
	var _objPtr, cachePtr, cachePtr1, cwd, fsPtr, tmpResultPtr, v1, v12, v9 uintptr
	var i, v11, v8 TTcl_Size
	var ret, v4 int32
	var v10, v2, v3 bool
	var v5, v6 int64
	var _ /* elemsPtr at bp+0 */ uintptr
	var _ /* resLength at bp+8 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, cachePtr1, cwd, fsPtr, i, ret, tmpResultPtr, v1, v10, v11, v12, v2, v3, v4, v5, v6, v8, v9
	ret = -int32(1)
	if types != libc.UintptrFromInt32(0) && (*TTcl_GlobTypeData)(unsafe.Pointer(types)).Ftype1&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(7)) != 0 {
		/*
		 * Currently external callers may not query mounts, which would be a
		 * valuable future step. This is the only routine that knows about
		 * mounts, so we're being called recursively by ourself. Return no
		 * matches.
		 */
		return TCL_OK
	}
	if pathPtr != libc.UintptrFromInt32(0) {
		fsPtr = XTcl_FSGetFileSystemForPath(tls, pathPtr)
	} else {
		fsPtr = libc.UintptrFromInt32(0)
	}
	if fsPtr != libc.UintptrFromInt32(0) {
		/*
		 * A corresponding filesystem was found. Search within it.
		 */
		if (*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FmatchInDirectoryProc == libc.UintptrFromInt32(0) {
			XTcl_SetErrno(tls, int32(ENOENT))
			return -int32(1)
		}
		ret = (*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FmatchInDirectoryProc})))(tls, interp, resultPtr, pathPtr, pattern, types)
		if ret == TCL_OK && pattern != libc.UintptrFromInt32(0) {
			_FsAddMountsToGlobResult(tls, resultPtr, pathPtr, pattern, types)
		}
		return ret
	}
	if v2 = pathPtr != libc.UintptrFromInt32(0); v2 {
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
		}
	}
	if v2 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) != int32('\000') {
		/*
		 * There is a pathname but it belongs to no known filesystem. Mayday!
		 */
		XTcl_SetErrno(tls, int32(ENOENT))
		return -int32(1)
	}
	/*
	 * The pathname is empty or NULL so search in the current working
	 * directory.  matchInDirectoryProc prefixes each result with this
	 * directory, so trim it from each result.  Deal with this here in the
	 * generic code because otherwise every filesystem implementation of
	 * Tcl_FSMatchInDirectory has to do it.
	 */
	cwd = XTcl_FSGetCwd(tls, libc.UintptrFromInt32(0))
	if cwd == libc.UintptrFromInt32(0) {
		if interp != libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+49156, int64(-int32(1))))
		}
		return int32(TCL_ERROR)
	}
	fsPtr = XTcl_FSGetFileSystemForPath(tls, cwd)
	if fsPtr != libc.UintptrFromInt32(0) && (*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FmatchInDirectoryProc != libc.UintptrFromInt32(0) {
		if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			tmpResultPtr = XTclThreadAllocObj(tls)
		} else {
			tmpResultPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(tmpResultPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(tmpResultPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(tmpResultPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(tmpResultPtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(tmpResultPtr)).FtypePtr = libc.UintptrFromInt32(0)
		(*TTcl_Obj)(unsafe.Pointer(tmpResultPtr)).FrefCount++
		ret = (*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FmatchInDirectoryProc})))(tls, interp, tmpResultPtr, cwd, pattern, types)
		if ret == TCL_OK {
			_FsAddMountsToGlobResult(tls, tmpResultPtr, cwd, pattern, types)
			/*
			 * resultPtr and tmpResultPtr are guaranteed to be distinct.
			 */
			if (*TTcl_Obj)(unsafe.Pointer(tmpResultPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(tmpResultPtr + 32))).Fptr2 != 0 {
					v5 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(tmpResultPtr + 32))).Fptr2)).FspanStart
				} else {
					v5 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(tmpResultPtr + 32))).Fptr1)).FfirstUsed
				}
				*(*uintptr)(unsafe.Pointer(bp)) = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(tmpResultPtr + 32))).Fptr1 + 40 + uintptr(v5)*8
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(tmpResultPtr + 32))).Fptr2 != 0 {
					v6 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(tmpResultPtr + 32))).Fptr2)).FspanLength
				} else {
					v6 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(tmpResultPtr + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v6
				v4 = libc.Int32FromInt32(TCL_OK)
			} else {
				v4 = XTcl_ListObjGetElements(tls, interp, tmpResultPtr, bp+8, bp)
			}
			ret = v4
			i = 0
			for {
				if !(ret == TCL_OK && i < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) {
					break
				}
				ret = XTcl_ListObjAppendElement(tls, interp, resultPtr, XTclFSMakePathRelative(tls, interp, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(i)*8)), cwd))
				goto _7
			_7:
				;
				i++
			}
		}
		v9 = tmpResultPtr
		v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
		*(*TTcl_Size)(unsafe.Pointer(v9))--
		if !(v8 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(tmpResultPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpResultPtr)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(tmpResultPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(tmpResultPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(tmpResultPtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(tmpResultPtr)).Flength = int64(-libc.Int32FromInt32(1))
				if v10 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v10 {
					cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v10 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, tmpResultPtr)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(tmpResultPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = tmpResultPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, tmpResultPtr)
			}
		}
	}
	_objPtr = cwd
	v12 = _objPtr
	v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
	*(*TTcl_Size)(unsafe.Pointer(v12))--
	if v11 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return ret
}

/*
 *----------------------------------------------------------------------
 *
 * FsAddMountsToGlobResult --
 *	Adds any mounted pathnames to a set of results so that simple things
 *	like 'glob *' merge mounts and listings correctly.  Used by the
 *	Tcl_FSMatchInDirectory.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Stores a result in resultPtr.
 *
 *----------------------------------------------------------------------
 */

func _FsAddMountsToGlobResult(tls *libc.TLS, resultPtr uintptr, pathPtr uintptr, pattern uintptr, types uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Acceptable types.  May be NULL. The
	 * directory flag is particularly significant. */
	var _objPtr, mount, mounts, norm, path, v10, v7, v8 uintptr
	var dir, found, v1, v3 int32
	var i, j, v9 TTcl_Size
	var v2, v4 int64
	var _ /* gElt at bp+24 */ uintptr
	var _ /* gLength at bp+8 */ TTcl_Size
	var _ /* len at bp+32 */ TTcl_Size
	var _ /* mElt at bp+16 */ uintptr
	var _ /* mLength at bp+0 */ TTcl_Size
	var _ /* mlen at bp+40 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, dir, found, i, j, mount, mounts, norm, path, v1, v10, v2, v3, v4, v7, v8, v9
	dir = libc.BoolInt32(types == libc.UintptrFromInt32(0) || (*TTcl_GlobTypeData)(unsafe.Pointer(types)).Ftype1&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0)
	mounts = _FsListMounts(tls, pathPtr, pattern)
	if mounts == libc.UintptrFromInt32(0) {
		return
	}
	if (*TTcl_Obj)(unsafe.Pointer(mounts)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(mounts + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(mounts + 32))).Fptr2)).FspanLength
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(mounts + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v2
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), mounts, bp)
	}
	if v1 != TCL_OK || *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
		goto endOfMounts
	}
	if (*TTcl_Obj)(unsafe.Pointer(resultPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultPtr + 32))).Fptr2 != 0 {
			v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(resultPtr + 32))).Fptr2)).FspanLength
		} else {
			v4 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(resultPtr + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v4
		v3 = libc.Int32FromInt32(TCL_OK)
	} else {
		v3 = XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), resultPtr, bp+8)
	}
	if v3 != TCL_OK {
		goto endOfMounts
	}
	i = 0
	for {
		if !(i < *(*TTcl_Size)(unsafe.Pointer(bp))) {
			break
		}
		found = 0
		XTcl_ListObjIndex(tls, libc.UintptrFromInt32(0), mounts, i, bp+16)
		j = 0
		for {
			if !(j < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) {
				break
			}
			XTcl_ListObjIndex(tls, libc.UintptrFromInt32(0), resultPtr, j, bp+24)
			if XTcl_FSEqualPaths(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), *(*uintptr)(unsafe.Pointer(bp + 24))) != 0 {
				found = int32(1)
				if !(dir != 0) {
					/*
					 * We don't want to list this.
					 */
					XTcl_ListObjReplace(tls, libc.UintptrFromInt32(0), resultPtr, j, int64(1), 0, libc.UintptrFromInt32(0))
					*(*TTcl_Size)(unsafe.Pointer(bp + 8))--
				}
				break /* Break out of for loop. */
			}
			goto _6
		_6:
			;
			j++
		}
		if !(found != 0) && dir != 0 {
			/*
			 * mElt is normalized and lies inside pathPtr so
			 * add to the result the right representation of mElt,
			 * i.e. the representation relative to pathPtr.
			 */
			norm = XTcl_FSGetNormalizedPath(tls, libc.UintptrFromInt32(0), pathPtr)
			if norm != libc.UintptrFromInt32(0) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Flength
					v7 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes
				} else {
					v7 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), bp+40)
				}
				mount = v7
				if (*TTcl_Obj)(unsafe.Pointer(norm)).Fbytes != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = (*TTcl_Obj)(unsafe.Pointer(norm)).Flength
					v8 = (*TTcl_Obj)(unsafe.Pointer(norm)).Fbytes
				} else {
					v8 = XTcl_GetStringFromObj(tls, norm, bp+32)
				}
				path = v8
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 32))-int64(1))))) == int32('/') {
					/*
					 * Deal with the root of the volume.
					 */
					*(*TTcl_Size)(unsafe.Pointer(bp + 32))--
				}
				*(*TTcl_Size)(unsafe.Pointer(bp + 32))++ /* account for '/' in the mElt [Bug 1602539] */
				*(*uintptr)(unsafe.Pointer(bp + 16)) = XTclNewFSPathObj(tls, pathPtr, mount+uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 32))), *(*TTcl_Size)(unsafe.Pointer(bp + 40))-*(*TTcl_Size)(unsafe.Pointer(bp + 32)))
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultPtr, *(*uintptr)(unsafe.Pointer(bp + 16)))
			}
			/*
			 * Not comparing mounts to mounts, so no need to increment gLength
			 */
		}
		goto _5
	_5:
		;
		i++
	}
	goto endOfMounts
endOfMounts:
	;
	_objPtr = mounts
	v10 = _objPtr
	v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
	*(*TTcl_Size)(unsafe.Pointer(v10))--
	if v9 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FSMountsChanged --
 *
 *	Announecs that mount points have changed or that the system encoding
 *	has changed.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The shared 'theFilesystemEpoch' is incremented, invalidating every
 *	exising cached internal representation of a pathname.  Avoid calling
 *	Tcl_FSMountsChanged whenever possible.  It must be called when:
 *
 *	(1) A filesystem is registered or unregistered. This is only necessary
 *	if the new filesystem accepts file pathnames as-is.  Normally the
 *	filesystem is really a shell which doesn't yet have any mount points
 *	established and so its 'pathInFilesystem' routine always fails.
 *	However, for safety, Tcl calls 'Tcl_FSMountsChanged' each time a
 *	filesystem is registered or unregistered.
 *
 *	(2) An additional mount point is established inside an existing
 *	filesystem (except for the native file system; see note below).
 *
 *	(3) A filesystem changes the list of available volumes (except for the
 *	native file system; see note below).
 *
 *	(4) The mapping from a string representation of a file to a full,
 *	normalized pathname changes.
 *
 *	Tcl has no control over (2) and (3), so each registered filesystem must
 *	call Tcl_FSMountsChnaged in each of those circumstances.
 *
 *	The reason for the exception in 2,3 for the native filesystem is that
 *	the native filesystem claims every file without determining whether
 *	the file exists, or even whether the pathname makes sense.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FSMountsChanged(tls *libc.TLS, dummy1234 uintptr) {
	/*
	 * fsPtr is currently unused.  In the future it might invalidate files for
	 * a particular filesystem, or take some other more advanced action.
	 */
	var v1 Tsize_t
	_ = v1
	/*
	 * Increment the filesystem epoch to invalidate every existing cached
	 * internal representation.
	 */
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_filesystemMutex)))
	_theFilesystemEpoch++
	v1 = _theFilesystemEpoch
	if v1 == uint64(0) {
		_theFilesystemEpoch++
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_filesystemMutex)))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FSData --
 *
 *	Retrieves the clientData member of the given filesystem.
 *
 * Results:
 *	A clientData value, or NULL if the given filesystem is not registered.
 *	The clientData value itself may also be NULL.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FSData(tls *libc.TLS, fsPtr uintptr) (r uintptr) {
	/* The filesystem to find in the list of
	 *  registered filesystems. */
	var fsRecPtr, retVal uintptr
	_, _ = fsRecPtr, retVal
	retVal = libc.UintptrFromInt32(0)
	fsRecPtr = _FsGetFirstFilesystem(tls)
	/*
	 * Find the filesystem in and retrieve its clientData.
	 */
	for retVal == libc.UintptrFromInt32(0) && fsRecPtr != libc.UintptrFromInt32(0) {
		if (*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FfsPtr == fsPtr {
			retVal = (*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FclientData
		}
		fsRecPtr = (*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FnextPtr
	}
	return retVal
}

/*
 *---------------------------------------------------------------------------
 *
 * TclFSNormalizeToUniquePath --
 *
 *	Converts the given pathname, containing no ../, ./ components, into a
 *	unique pathname for the given platform. On Unix the resulting pathname
 *	is free of symbolic links/aliases, and on Windows it is the long
 *	case-preserving form.
 *
 *
 * Results:
 *	Stores the resulting pathname in pathPtr and returns the offset of the
 *	last byte processed in pathPtr.
 *
 * Side effects:
 *	None (beyond the memory allocation for the result).
 *
 * Special notes:
 *	If the filesystem-specific normalizePathProcs can reintroduce ../, ./
 *	components into the pathname, this function does not return the correct
 *	result. This may be possible with symbolic links on unix.
 *
 *
 *---------------------------------------------------------------------------
 */

func XTclFSNormalizeToUniquePath(tls *libc.TLS, interp uintptr, pathPtr uintptr, startAt int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Offset the string of pathPtr to start at.
	 * Must either be 0 or offset of a directory
	 * separator at the end of a pathname part that
	 * is already normalized, I.e. not the index of
	 * the byte just after the separator.  */
	var firstFsRecPtr, fsRecPtr, path, v1 uintptr
	var isVfsPath int32
	var _ /* i at bp+0 */ TTcl_Size
	_, _, _, _, _ = firstFsRecPtr, fsRecPtr, isVfsPath, path, v1
	isVfsPath = 0
	/*
	 * Pathnames starting with a UNC prefix and ending with a colon character
	 * are reserved for VFS use.  These names can not conflict with real UNC
	 * pathnames per https://msdn.microsoft.com/en-us/library/gg465305.aspx and
	 * rfc3986's definition of reg-name.
	 *
	 * We check these first to avoid useless calls to the native filesystem's
	 * normalizePathProc.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, pathPtr, bp)
	}
	path = v1
	if *(*TTcl_Size)(unsafe.Pointer(bp)) >= int64(3) && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('/') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 1))) == int32('/') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('\\') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 1))) == int32('\\')) {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = int64(2)
		for {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))))) == int32('\000') {
				break
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) {
				break
			}
			goto _2
		_2:
			;
			*(*TTcl_Size)(unsafe.Pointer(bp))++
		}
		*(*TTcl_Size)(unsafe.Pointer(bp))--
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))))) == int32(':') {
			isVfsPath = int32(1)
		}
	}
	/*
	 * Call the the normalizePathProc routine of each registered filesystem.
	 */
	firstFsRecPtr = _FsGetFirstFilesystem(tls)
	_Claim(tls)
	if !(isVfsPath != 0) {
		/*
		 * Find and call the native filesystem handler first if there is one
		 * because the root of Tcl's filesystem is always a native filesystem
		 * (i.e., '/' on unix is native).
		 */
		fsRecPtr = firstFsRecPtr
		for {
			if !(fsRecPtr != libc.UintptrFromInt32(0)) {
				break
			}
			if (*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FfsPtr != uintptr(unsafe.Pointer(&XtclNativeFilesystem)) {
				goto _3
			}
			/*
			 * TODO: Always call the normalizePathProc here because it should
			 * always exist.
			 */
			if (*TTcl_Filesystem)(unsafe.Pointer((*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FfsPtr)).FnormalizePathProc != libc.UintptrFromInt32(0) {
				startAt = (*(*func(*libc.TLS, uintptr, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer((*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FfsPtr)).FnormalizePathProc})))(tls, interp, pathPtr, startAt)
			}
			break
			goto _3
		_3:
			;
			fsRecPtr = (*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FnextPtr
		}
	}
	fsRecPtr = firstFsRecPtr
	for {
		if !(fsRecPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FfsPtr == uintptr(unsafe.Pointer(&XtclNativeFilesystem)) {
			/*
			 * Skip the native system this time through.
			 */
			goto _4
		}
		if (*TTcl_Filesystem)(unsafe.Pointer((*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FfsPtr)).FnormalizePathProc != libc.UintptrFromInt32(0) {
			startAt = (*(*func(*libc.TLS, uintptr, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer((*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FfsPtr)).FnormalizePathProc})))(tls, interp, pathPtr, startAt)
		}
		/*
		 * This efficiency check could be added:
		 *		if (retVal == length-of(pathPtr)) {break;}
		 * but there's not much benefit.
		 */
		goto _4
	_4:
		;
		fsRecPtr = (*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FnextPtr
	}
	_Disclaim(tls)
	return startAt
}

/*
 *---------------------------------------------------------------------------
 *
 * TclGetOpenMode --
 *
 *	Computes a POSIX mode mask for opening a file.
 *
 * Results:
 *	The mode to pass to "open", or -1 if an error occurs.
 *
 * Side effects:
 *	Sets *modeFlagsPtr to 1 to tell the caller to
 *	seek to EOF after opening the file, or to 0 otherwise.
 *
 *	Adds CHANNEL_RAW_MODE to *modeFlagsPtr to tell the caller
 *	to configure the channel as a binary channel.
 *
 *	If there is an error and interp is not NULL, sets
 *	interpreter result to an error message.
 *
 * Special note:
 *	Based on a prototype implementation contributed by Mark Diekhans.
 *
 *---------------------------------------------------------------------------
 */

func XTclGetOpenMode(tls *libc.TLS, interp uintptr, modeString uintptr, modeFlagsPtr uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var c, gotRW, mode int32
	var flag uintptr
	var i, v1 TTcl_Size
	var _ /* modeArgc at bp+0 */ TTcl_Size
	var _ /* modeArgv at bp+8 */ uintptr
	_, _, _, _, _, _ = c, flag, gotRW, i, mode, v1
	*(*uintptr)(unsafe.Pointer(bp + 8)) = libc.UintptrFromInt32(0)
	/*
	 * Check for the simpler fopen-like access modes like "r" which are
	 * distinguished from the POSIX access modes by the presence of a
	 * lower-case first letter.
	 */
	*(*int32)(unsafe.Pointer(modeFlagsPtr)) = 0
	mode = O_RDONLY
	/*
	 * Guard against wide characters before using byte-oriented routines.
	 */
	if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(modeString)))&libc.Int32FromInt32(0x80) != 0) && libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(modeString)))-uint32('a') < uint32(26)) != 0 { /* INTL: ISO only. */
		switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(modeString))) {
		case int32('r'):
		case int32('w'):
			mode = libc.Int32FromInt32(O_WRONLY) | libc.Int32FromInt32(O_CREAT) | libc.Int32FromInt32(O_TRUNC)
		case int32('a'):
			/*
			 * Add O_APPEND for proper automatic seek-to-end-on-write by the
			 * OS. [Bug 680143]
			 */
			mode = libc.Int32FromInt32(O_WRONLY) | libc.Int32FromInt32(O_CREAT) | libc.Int32FromInt32(O_APPEND)
			*(*int32)(unsafe.Pointer(modeFlagsPtr)) |= int32(1)
		default:
			goto error
		}
		i = int64(1)
		for i < int64(3) && *(*uint8)(unsafe.Pointer(modeString + uintptr(i))) != 0 {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(modeString + uintptr(i)))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(modeString + uintptr(i-int64(1))))) {
				goto error
			}
			v1 = i
			i++
			switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(modeString + uintptr(v1)))) {
			case int32('+'):
				/*
				 * Remove O_APPEND so that the seek command works. [Bug
				 * 1773127]
				 */
				mode = mode & ^(libc.Int32FromInt32(03)|libc.Int32FromInt32(O_PATH)|libc.Int32FromInt32(O_APPEND)) | int32(O_RDWR)
			case int32('b'):
				*(*int32)(unsafe.Pointer(modeFlagsPtr)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(16)
			default:
				goto error
			}
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(modeString + uintptr(i)))) != 0 {
			goto error
		}
		return mode
		goto error
	error:
		;
		*(*int32)(unsafe.Pointer(modeFlagsPtr)) = 0
		if interp != libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+49210, libc.VaList(bp+24, modeString)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+49235, __ccgo_ts+11134, libc.UintptrFromInt32(0)))
		}
		return -int32(1)
	}
	/*
	 * The access modes are specified as a list of POSIX modes like O_CREAT.
	 *
	 * Tcl_SplitList must work correctly when interp is NULL.
	 */
	if !(XTcl_SplitList(tls, interp, modeString, bp, bp+8) != TCL_OK) {
		goto _2
	}
	goto invAccessMode
invAccessMode:
	;
	if interp != libc.UintptrFromInt32(0) {
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+49244, int64(-int32(1))))
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, modeString, int64(-int32(1))))
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+14586, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+49235, __ccgo_ts+11134, libc.UintptrFromInt32(0)))
	}
	if *(*uintptr)(unsafe.Pointer(bp + 8)) != 0 {
		XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
	}
	return -int32(1)
_2:
	;
	gotRW = 0
	i = 0
	for {
		if !(i < *(*TTcl_Size)(unsafe.Pointer(bp))) {
			break
		}
		flag = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8))
		c = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(flag)))
		if !(c == int32('R') && libc.Xstrcmp(tls, flag, __ccgo_ts+49286) == 0) {
			goto _4
		}
		if !(gotRW != 0) {
			goto _6
		}
		goto invRW
	invRW:
		;
		if interp != libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+49293, libc.VaList(bp+24, flag)))
		}
		goto invAccessMode
	_6:
		;
		mode = mode & ^(libc.Int32FromInt32(03)|libc.Int32FromInt32(O_PATH)) | O_RDONLY
		gotRW = int32(1)
		goto _5
	_4:
		;
		if c == int32('W') && libc.Xstrcmp(tls, flag, __ccgo_ts+49369) == 0 {
			if gotRW != 0 {
				goto invRW
			}
			mode = mode & ^(libc.Int32FromInt32(03)|libc.Int32FromInt32(O_PATH)) | int32(O_WRONLY)
			gotRW = int32(1)
		} else {
			if c == int32('R') && libc.Xstrcmp(tls, flag, __ccgo_ts+49376) == 0 {
				if gotRW != 0 {
					goto invRW
				}
				mode = mode & ^(libc.Int32FromInt32(03)|libc.Int32FromInt32(O_PATH)) | int32(O_RDWR)
				gotRW = int32(1)
			} else {
				if !(c == int32('A') && libc.Xstrcmp(tls, flag, __ccgo_ts+49381) == 0) {
					goto _7
				}
				if !(mode&int32(O_APPEND) != 0) {
					goto _9
				}
				goto accessFlagRepeated
			accessFlagRepeated:
				;
				if interp != 0 {
					XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+49388, libc.VaList(bp+24, flag)))
				}
				goto invAccessMode
			_9:
				;
				mode |= int32(O_APPEND)
				*(*int32)(unsafe.Pointer(modeFlagsPtr)) |= int32(1)
				goto _8
			_7:
				;
				if c == int32('C') && libc.Xstrcmp(tls, flag, __ccgo_ts+49414) == 0 {
					if mode&int32(O_CREAT) != 0 {
						goto accessFlagRepeated
					}
					mode |= int32(O_CREAT)
				} else {
					if c == int32('E') && libc.Xstrcmp(tls, flag, __ccgo_ts+49420) == 0 {
						if mode&int32(O_EXCL) != 0 {
							goto accessFlagRepeated
						}
						mode |= int32(O_EXCL)
					} else {
						if c == int32('N') && libc.Xstrcmp(tls, flag, __ccgo_ts+49425) == 0 {
							if mode&int32(O_NOCTTY) != 0 {
								goto accessFlagRepeated
							}
							mode |= int32(O_NOCTTY)
						} else {
							if c == int32('N') && libc.Xstrcmp(tls, flag, __ccgo_ts+49432) == 0 {
								if mode&int32(O_NONBLOCK) != 0 {
									goto accessFlagRepeated
								}
								mode |= int32(O_NONBLOCK)
							} else {
								if c == int32('T') && libc.Xstrcmp(tls, flag, __ccgo_ts+49441) == 0 {
									if mode&int32(O_TRUNC) != 0 {
										goto accessFlagRepeated
									}
									mode |= int32(O_TRUNC)
								} else {
									if c == int32('B') && libc.Xstrcmp(tls, flag, __ccgo_ts+11120) == 0 {
										if *(*int32)(unsafe.Pointer(modeFlagsPtr))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(16)) != 0 {
											goto accessFlagRepeated
										}
										*(*int32)(unsafe.Pointer(modeFlagsPtr)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(16)
									} else {
										if interp != libc.UintptrFromInt32(0) {
											XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+49447, libc.VaList(bp+24, flag)))
										}
										goto invAccessMode
									}
								}
							}
						}
					}
				}
			_8:
			}
		}
	_5:
		;
		goto _3
	_3:
		;
		i++
	}
	XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
	if !(gotRW != 0) {
		if interp != libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+49559, int64(-int32(1))))
		}
		return -int32(1)
	}
	return mode
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FSEvalFile, Tcl_FSEvalFileEx, TclNREvalFile --
 *
 *	Reads a file and evaluates it as a script.
 *
 *	Tcl_FSEvalFile is Tcl_FSEvalFileEx without the encodingName argument.
 *
 *	TclNREvalFile is an NRE-enabled version of Tcl_FSEvalFileEx.
 *
 * Results:
 *	A standard Tcl result, which is either the result of executing the
 *	file or an error indicating why the file couldn't be read.
 *
 * Side effects:
 *	Arbitrary, depending on the contents of the script.  While the script
 *	is evaluated iPtr->scriptFile is a reference to pathPtr, and after the
 *	evaluation completes, has its original value restored again.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FSEvalFile(tls *libc.TLS, interp uintptr, pathPtr uintptr) (r int32) {
	/* Pathname of file containing the script.
	 * Tilde-substitution is performed on this
	 * pathname. */
	return XTcl_FSEvalFileEx(tls, interp, pathPtr, libc.UintptrFromInt32(0))
}

func XTcl_FSEvalFileEx(tls *libc.TLS, interp uintptr, pathPtr uintptr, encodingName uintptr) (r int32) {
	bp := tls.Alloc(192)
	defer tls.Free(192) /* Either the name of an encoding or NULL to
	 * use the utf-8 encoding. */
	var _objPtr, _objPtr1, cachePtr, iPtr, objPtr, oldScriptFile, pathString, string1, v1, v10, v12, v14, v2, v4, v5, v6, v7, v9 uintptr
	var chan1 TTcl_Channel
	var limit, overflow, result, v11 int32
	var v13, v8 TTcl_Size
	var v3 bool
	var _ /* length at bp+0 */ TTcl_Size
	var _ /* statBuf at bp+8 */ TTcl_StatBuf
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, chan1, iPtr, limit, objPtr, oldScriptFile, overflow, pathString, result, string1, v1, v10, v11, v12, v13, v14, v2, v3, v4, v5, v6, v7, v8, v9
	result = int32(TCL_ERROR)
	if XTcl_FSGetNormalizedPath(tls, interp, pathPtr) == libc.UintptrFromInt32(0) {
		return result
	}
	if XTcl_FSStat(tls, pathPtr, bp+8) == -int32(1) {
		XTcl_SetErrno(tls, *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))))
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+49615, libc.VaList(bp+160, v1, XTcl_PosixError(tls, interp))))
		return result
	}
	chan1 = XTcl_FSOpenFileChannel(tls, interp, pathPtr, __ccgo_ts+25877, int32(0644))
	if chan1 == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+49615, libc.VaList(bp+160, v2, XTcl_PosixError(tls, interp))))
		return result
	}
	/*
	 * The eof character is \x1A (^Z). Tcl uses it on every platform to allow
	 * for scripted documents. [Bug: 2040]
	 */
	XTcl_SetChannelOption(tls, interp, chan1, __ccgo_ts+44727, __ccgo_ts+49643)
	/*
	 * If the encoding is specified, set the channel to that encoding.
	 * Otherwise use utf-8.  If the encoding is unknown report an error.
	 */
	if encodingName == libc.UintptrFromInt32(0) {
		encodingName = __ccgo_ts + 29080
	}
	if XTcl_SetChannelOption(tls, interp, chan1, __ccgo_ts+19036, encodingName) != TCL_OK {
		XTcl_CloseEx(tls, interp, chan1, 0)
		return result
	}
	if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount++
	/*
	 * Read first character of stream to check for utf-8 BOM
	 */
	if XTcl_ReadChars(tls, chan1, objPtr, int64(1), 0) == int64(-libc.Int32FromInt32(1)) {
		XTcl_CloseEx(tls, interp, chan1, 0)
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
			v4 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
		} else {
			v4 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+49615, libc.VaList(bp+160, v4, XTcl_PosixError(tls, interp))))
		goto end
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		v5 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		v5 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
	}
	string1 = v5
	/*
	 * If first character is not a BOM, append the remaining characters.
	 * Otherwise, replace them. [Bug 3466099]
	 */
	if XTcl_ReadChars(tls, chan1, objPtr, int64(-libc.Int32FromInt32(1)), libc.Xmemcmp(tls, string1, __ccgo_ts+49645, uint64(3))) == int64(-libc.Int32FromInt32(1)) {
		XTcl_CloseEx(tls, interp, chan1, 0)
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
			v6 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
		} else {
			v6 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+49615, libc.VaList(bp+160, v6, XTcl_PosixError(tls, interp))))
		goto end
	}
	if XTcl_CloseEx(tls, interp, chan1, 0) != TCL_OK {
		goto end
	}
	iPtr = interp
	oldScriptFile = (*TInterp)(unsafe.Pointer(iPtr)).FscriptFile
	(*TInterp)(unsafe.Pointer(iPtr)).FscriptFile = pathPtr
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FscriptFile)).FrefCount++
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
		v7 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		v7 = XTcl_GetStringFromObj(tls, objPtr, bp)
	}
	string1 = v7
	/*
	 * TIP #280:  Open a frame for the evaluated script.
	 */
	*(*int32)(unsafe.Pointer(iPtr + 256)) |= int32(TCL_EVAL_FILE)
	result = XTclEvalEx(tls, interp, string1, *(*TTcl_Size)(unsafe.Pointer(bp)), 0, int64(1), libc.UintptrFromInt32(0), string1)
	/*
	 * Restore the original iPtr->scriptFile value, but because the value may
	 * have hanged during evaluation, don't assume it currently points to
	 * pathPtr.
	 */
	if (*TInterp)(unsafe.Pointer(iPtr)).FscriptFile != libc.UintptrFromInt32(0) {
		_objPtr = (*TInterp)(unsafe.Pointer(iPtr)).FscriptFile
		v9 = _objPtr
		v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
		*(*TTcl_Size)(unsafe.Pointer(v9))--
		if v8 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	(*TInterp)(unsafe.Pointer(iPtr)).FscriptFile = oldScriptFile
	if result == int32(TCL_RETURN) {
		result = XTclUpdateReturnInfo(tls, iPtr)
	} else {
		if result == int32(TCL_ERROR) {
			if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Flength
				v10 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
			} else {
				v10 = XTcl_GetStringFromObj(tls, pathPtr, bp)
			}
			/*
			 * Record information about where the error occurred.
			 */
			pathString = v10
			limit = int32(150)
			overflow = libc.BoolInt32(*(*TTcl_Size)(unsafe.Pointer(bp)) > int64(limit))
			if overflow != 0 {
				v11 = limit
			} else {
				v11 = int32(*(*TTcl_Size)(unsafe.Pointer(bp)))
			}
			if overflow != 0 {
				v12 = __ccgo_ts + 8560
			} else {
				v12 = __ccgo_ts + 1945
			}
			XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+49649, libc.VaList(bp+160, v11, pathString, v12, XTcl_GetErrorLine(tls, interp))))
		}
	}
	goto end
end:
	;
	_objPtr1 = objPtr
	v14 = _objPtr1
	v13 = *(*TTcl_Size)(unsafe.Pointer(v14))
	*(*TTcl_Size)(unsafe.Pointer(v14))--
	if v13 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	return result
}

func XTclNREvalFile(tls *libc.TLS, interp uintptr, pathPtr uintptr, encodingName uintptr) (r int32) {
	bp := tls.Alloc(176)
	defer tls.Free(176) /* The name of an encoding to use, or NULL to
	 *  use the utf-8 encoding. */
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, cachePtr, cachePtr1, iPtr, objPtr, oldScriptFile, string1, v1, v11, v13, v2, v3, v5, v7, v8, v9 uintptr
	var chan1 TTcl_Channel
	var v10, v12, v6 TTcl_Size
	var v14, v4 bool
	var _ /* _callbackPtr at bp+144 */ uintptr
	var _ /* statBuf at bp+0 */ TTcl_StatBuf
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, cachePtr, cachePtr1, chan1, iPtr, objPtr, oldScriptFile, string1, v1, v10, v11, v12, v13, v14, v2, v3, v4, v5, v6, v7, v8, v9
	if XTcl_FSGetNormalizedPath(tls, interp, pathPtr) == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if XTcl_FSStat(tls, pathPtr, bp) == -int32(1) {
		XTcl_SetErrno(tls, *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))))
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+49615, libc.VaList(bp+160, v1, XTcl_PosixError(tls, interp))))
		return int32(TCL_ERROR)
	}
	chan1 = XTcl_FSOpenFileChannel(tls, interp, pathPtr, __ccgo_ts+25877, int32(0644))
	if chan1 == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+49615, libc.VaList(bp+160, v2, XTcl_PosixError(tls, interp))))
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
		v3 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
	} else {
		v3 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
	}
	XTclPkgFileSeen(tls, interp, v3)
	/*
	 * The eof character is \x1A (^Z). Tcl uses it on every platform to allow
	 * for scripted documents. [Bug: 2040]
	 */
	XTcl_SetChannelOption(tls, interp, chan1, __ccgo_ts+44727, __ccgo_ts+49643)
	/*
	 * If the encoding is specified, set the channel to that encoding.
	 * Otherwise use utf-8.  If the encoding is unknown report an error.
	 */
	if encodingName == libc.UintptrFromInt32(0) {
		encodingName = __ccgo_ts + 29080
	}
	if XTcl_SetChannelOption(tls, interp, chan1, __ccgo_ts+19036, encodingName) != TCL_OK {
		XTcl_CloseEx(tls, interp, chan1, 0)
		return int32(TCL_ERROR)
	}
	if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount++
	/*
	 * Read first character of stream to check for utf-8 BOM
	 */
	if XTcl_ReadChars(tls, chan1, objPtr, int64(1), 0) == int64(-libc.Int32FromInt32(1)) {
		XTcl_CloseEx(tls, interp, chan1, 0)
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
			v5 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
		} else {
			v5 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+49615, libc.VaList(bp+160, v5, XTcl_PosixError(tls, interp))))
		_objPtr = objPtr
		v7 = _objPtr
		v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
		*(*TTcl_Size)(unsafe.Pointer(v7))--
		if v6 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		v8 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		v8 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
	}
	string1 = v8
	/*
	 * If first character is not a BOM, append the remaining characters.
	 * Otherwise, replace them. [Bug 3466099]
	 */
	if XTcl_ReadChars(tls, chan1, objPtr, int64(-libc.Int32FromInt32(1)), libc.Xmemcmp(tls, string1, __ccgo_ts+49645, uint64(3))) == int64(-libc.Int32FromInt32(1)) {
		XTcl_CloseEx(tls, interp, chan1, 0)
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
			v9 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
		} else {
			v9 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+49615, libc.VaList(bp+160, v9, XTcl_PosixError(tls, interp))))
		_objPtr1 = objPtr
		v11 = _objPtr1
		v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
		*(*TTcl_Size)(unsafe.Pointer(v11))--
		if v10 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		return int32(TCL_ERROR)
	}
	if XTcl_CloseEx(tls, interp, chan1, 0) != TCL_OK {
		_objPtr2 = objPtr
		v13 = _objPtr2
		v12 = *(*TTcl_Size)(unsafe.Pointer(v13))
		*(*TTcl_Size)(unsafe.Pointer(v13))--
		if v12 <= int64(1) {
			XTclFreeObj(tls, _objPtr2)
		}
		return int32(TCL_ERROR)
	}
	iPtr = interp
	oldScriptFile = (*TInterp)(unsafe.Pointer(iPtr)).FscriptFile
	(*TInterp)(unsafe.Pointer(iPtr)).FscriptFile = pathPtr
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FscriptFile)).FrefCount++
	/*
	 * TIP #280:  Open a frame for the evaluated script.
	 */
	*(*int32)(unsafe.Pointer(iPtr + 256)) |= int32(TCL_EVAL_FILE)
	if v14 = interp == libc.UintptrFromInt32(0); !v14 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v14 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr3 = XTclThreadAllocObj(tls)
	} else {
		_objPtr3 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr3 + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 144)) = _objPtr3
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 144)))).FprocPtr = __ccgo_fp(_EvalFileCallback)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 144)) + 8)) = oldScriptFile
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 144)) + 8 + 1*8)) = pathPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 144)) + 8 + 2*8)) = objPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 144)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 144)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 144))
	return XTclNREvalObjEx(tls, interp, objPtr, 0, libc.UintptrFromInt32(0), -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff))
}

func _EvalFileCallback(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var _objPtr, _objPtr1, iPtr, objPtr, oldScriptFile, pathPtr, pathString, v2, v3, v5, v7 uintptr
	var limit, overflow, v4 int32
	var v1, v6 TTcl_Size
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, iPtr, limit, objPtr, oldScriptFile, overflow, pathPtr, pathString, v1, v2, v3, v4, v5, v6, v7
	iPtr = interp
	oldScriptFile = *(*uintptr)(unsafe.Pointer(data))
	pathPtr = *(*uintptr)(unsafe.Pointer(data + 1*8))
	objPtr = *(*uintptr)(unsafe.Pointer(data + 2*8))
	/*
	 * Restore the original iPtr->scriptFile value, but because the value may
	 * have hanged during evaluation, don't assume it currently points to
	 * pathPtr.
	 */
	if (*TInterp)(unsafe.Pointer(iPtr)).FscriptFile != libc.UintptrFromInt32(0) {
		_objPtr = (*TInterp)(unsafe.Pointer(iPtr)).FscriptFile
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	(*TInterp)(unsafe.Pointer(iPtr)).FscriptFile = oldScriptFile
	if result == int32(TCL_RETURN) {
		result = XTclUpdateReturnInfo(tls, iPtr)
	} else {
		if result == int32(TCL_ERROR) {
			if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Flength
				v3 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
			} else {
				v3 = XTcl_GetStringFromObj(tls, pathPtr, bp)
			}
			pathString = v3
			limit = int32(150)
			overflow = libc.BoolInt32(*(*TTcl_Size)(unsafe.Pointer(bp)) > int64(limit))
			if overflow != 0 {
				v4 = limit
			} else {
				v4 = int32(*(*TTcl_Size)(unsafe.Pointer(bp)))
			}
			if overflow != 0 {
				v5 = __ccgo_ts + 8560
			} else {
				v5 = __ccgo_ts + 1945
			}
			XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+49649, libc.VaList(bp+16, v4, pathString, v5, XTcl_GetErrorLine(tls, interp))))
		}
	}
	_objPtr1 = objPtr
	v7 = _objPtr1
	v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
	*(*TTcl_Size)(unsafe.Pointer(v7))--
	if v6 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetErrno --
 *
 *	Currently the global variable "errno", but could in the future change
 *	to something else.
 *
 * Results:
 *	The current Tcl error number.
 *
 * Side effects:
 *	None. The value of the Tcl error code variable is only defined if it
 *	was set by a previous call to Tcl_SetErrno.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetErrno(tls *libc.TLS) (r int32) {
	/*
	 * On some platforms errno is thread-local, as implemented by the C
	 * library.
	 */
	return *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetErrno --
 *
 *	Sets the Tcl error code to the given value. On some saner platforms
 *	this is implemented in the C library as a thread-local value , but this
 *	is *really* unsafe to assume!
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Modifies the Tcl error code value.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetErrno(tls *libc.TLS, err int32) {
	/* The new value. */
	/*
	 * On some platforms, errno is implemented by the C library as a thread
	 * local value
	 */
	*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = err
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_PosixError --
 *
 *	Typically called after a UNIX kernel call returns an error.  Sets the
 *	interpreter errorCode to machine-parsable information about the error.
 *
 * Results:
 *	A human-readable sring describing the error.
 *
 * Side effects:
 *	Sets the errorCode value of the interpreter.
 *
 *----------------------------------------------------------------------
 */

func XTcl_PosixError(tls *libc.TLS, interp uintptr) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Interpreter to set the errorCode of */
	var id, msg uintptr
	_, _ = id, msg
	msg = XTcl_ErrnoMsg(tls, *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))))
	id = XTcl_ErrnoId(tls)
	if interp != 0 {
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+49678, id, msg, libc.UintptrFromInt32(0)))
	}
	return msg
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FSStat --
 *	Calls 'statProc' of the filesystem corresponding to pathPtr.
 *
 *	Replaces the standard library "stat" routine.
 *
 * Results:
 *	See stat documentation.
 *
 * Side effects:
 *	See stat documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FSStat(tls *libc.TLS, pathPtr uintptr, buf uintptr) (r int32) {
	/* A buffer to hold the results of the call to
	 *  stat. */
	var fsPtr uintptr
	_ = fsPtr
	fsPtr = XTcl_FSGetFileSystemForPath(tls, pathPtr)
	if fsPtr != libc.UintptrFromInt32(0) && (*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FstatProc != libc.UintptrFromInt32(0) {
		return (*(*func(*libc.TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FstatProc})))(tls, pathPtr, buf)
	}
	XTcl_SetErrno(tls, int32(ENOENT))
	return -int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FSLstat --
 *	Calls the 'lstatProc' of the filesystem corresponding to pathPtr.
 *
 *	Replaces the library version of lstat.  If the filesystem doesn't
 *	provide lstatProc but does provide statProc, Tcl falls back to
 *	statProc.
 *
 * Results:
 *	See lstat documentation.
 *
 * Side effects:
 *	See lstat documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FSLstat(tls *libc.TLS, pathPtr uintptr, buf uintptr) (r int32) {
	/* Filled with results of that call to stat. */
	var fsPtr uintptr
	_ = fsPtr
	fsPtr = XTcl_FSGetFileSystemForPath(tls, pathPtr)
	if fsPtr != libc.UintptrFromInt32(0) {
		if (*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FlstatProc != libc.UintptrFromInt32(0) {
			return (*(*func(*libc.TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FlstatProc})))(tls, pathPtr, buf)
		}
		if (*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FstatProc != libc.UintptrFromInt32(0) {
			return (*(*func(*libc.TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FstatProc})))(tls, pathPtr, buf)
		}
	}
	XTcl_SetErrno(tls, int32(ENOENT))
	return -int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FSAccess --
 *
 *	Calls 'accessProc' of the filesystem corresponding to pathPtr.
 *
 *	Replaces the library version of access.
 *
 * Results:
 *	See access documentation.
 *
 * Side effects:
 *	See access documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FSAccess(tls *libc.TLS, pathPtr uintptr, mode int32) (r int32) {
	/* Permission setting. */
	var fsPtr uintptr
	_ = fsPtr
	fsPtr = XTcl_FSGetFileSystemForPath(tls, pathPtr)
	if fsPtr != libc.UintptrFromInt32(0) && (*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FaccessProc != libc.UintptrFromInt32(0) {
		return (*(*func(*libc.TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FaccessProc})))(tls, pathPtr, mode)
	}
	XTcl_SetErrno(tls, int32(ENOENT))
	return -int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FSOpenFileChannel --
 *
 *	Calls 'openfileChannelProc' of the filesystem corresponding to
 *	pathPtr.
 *
 * Results:
 *	The new channel, or NULL if the named file could not be opened.
 *
 * Side effects:
 *	Opens a channel, possibly creating the corresponding the file on the
 *	filesystem.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FSOpenFileChannel(tls *libc.TLS, interp uintptr, pathPtr uintptr, modeString uintptr, permissions int32) (r TTcl_Channel) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* What modes to use if opening the file
	 * involves creating it. */
	var fsPtr, v1, v2 uintptr
	var mode int32
	var retVal TTcl_Channel
	var _ /* modeFlags at bp+0 */ int32
	_, _, _, _, _ = fsPtr, mode, retVal, v1, v2
	retVal = libc.UintptrFromInt32(0)
	fsPtr = XTcl_FSGetFileSystemForPath(tls, pathPtr)
	if fsPtr != libc.UintptrFromInt32(0) && (*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FopenFileChannelProc != libc.UintptrFromInt32(0) {
		/*
		 * Parse the mode to determine whether to seek at the outset
		 * and/or set the channel into binary mode.
		 */
		mode = XTclGetOpenMode(tls, interp, modeString, bp)
		if mode == -int32(1) {
			return libc.UintptrFromInt32(0)
		}
		/*
		 * Open the file.
		 */
		retVal = (*(*func(*libc.TLS, uintptr, uintptr, int32, int32) TTcl_Channel)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FopenFileChannelProc})))(tls, interp, pathPtr, mode, permissions)
		if retVal == libc.UintptrFromInt32(0) {
			return libc.UintptrFromInt32(0)
		}
		/*
		 * Seek and/or set binary mode as determined above.
		 */
		if *(*int32)(unsafe.Pointer(bp))&int32(1) != 0 && XTcl_Seek(tls, retVal, libc.Int64FromInt32(0), int32(2)) < libc.Int64FromInt32(0) {
			if interp != libc.UintptrFromInt32(0) {
				if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
					v1 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
				} else {
					v1 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
				}
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+49684, libc.VaList(bp+16, v1, XTcl_PosixError(tls, interp))))
			}
			XTcl_CloseEx(tls, libc.UintptrFromInt32(0), retVal, 0)
			return libc.UintptrFromInt32(0)
		}
		if *(*int32)(unsafe.Pointer(bp))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(16)) != 0 {
			XTcl_SetChannelOption(tls, interp, retVal, __ccgo_ts+44736, __ccgo_ts+10664)
		}
		return retVal
	}
	/*
	 * File doesn't belong to any filesystem that can open it.
	 */
	XTcl_SetErrno(tls, int32(ENOENT))
	if interp != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+49737, libc.VaList(bp+16, v2, XTcl_PosixError(tls, interp))))
	}
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FSUtime --
 *
 *	Calls 'uTimeProc' of the filesystem corresponding to the given
 *	pathname.
 *
 *	Replaces the library version of utime.
 *
 * Results:
 *	See utime documentation.
 *
 * Side effects:
 *	See utime documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FSUtime(tls *libc.TLS, pathPtr uintptr, tval uintptr) (r int32) {
	/* Specifies the access/modification
	 * times to use. Should not be modified. */
	var err int32
	var fsPtr uintptr
	_, _ = err, fsPtr
	fsPtr = XTcl_FSGetFileSystemForPath(tls, pathPtr)
	if fsPtr == libc.UintptrFromInt32(0) {
		err = int32(ENOENT)
	} else {
		if (*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FutimeProc != libc.UintptrFromInt32(0) {
			return (*(*func(*libc.TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FutimeProc})))(tls, pathPtr, tval)
		}
		err = int32(EOPNOTSUPP)
	}
	XTcl_SetErrno(tls, err)
	return -int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * NativeFileAttrStrings --
 *
 *	Implements the platform-dependent 'file attributes' subcommand for the
 *	native filesystem, for listing the set of possible attribute strings.
 *	Part of Tcl's native filesystem support. Placed here because it is used
 *	under both Unix and Windows.
 *
 * Results:
 *	An array of strings
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _NativeFileAttrStrings(tls *libc.TLS, dummy2322 uintptr, dummy2323 uintptr) (r uintptr) {
	return uintptr(unsafe.Pointer(&XtclpFileAttrStrings))
}

/*
 *----------------------------------------------------------------------
 *
 * NativeFileAttrsGet --
 *
 *	Implements the platform-dependent 'file attributes' subcommand for the
 *	native filesystem for 'get' operations.  Part of Tcl's native
 *	filesystem support.  Defined here because it is used under both Unix
 *	and Windows.
 *
 * Results:
 *	Standard Tcl return code.
 *
 *	If there was no error, stores in objPtrRef a pointer to a new object
 *	having a refCount of zero and  holding the result.  The caller should
 *	store it somewhere, e.g. as the Tcl result, or decrement its refCount
 *	to free it.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _NativeFileAttrsGet(tls *libc.TLS, interp uintptr, index int32, pathPtr uintptr, objPtrRef uintptr) (r int32) {
	/* Where to store the a pointer to the result. */
	return (*(*func(*libc.TLS, uintptr, int32, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{XtclpFileAttrProcs[index].FgetProc})))(tls, interp, index, pathPtr, objPtrRef)
}

/*
 *----------------------------------------------------------------------
 *
 * NativeFileAttrsSet --
 *
 *	Implements the platform-dependent 'file attributes' subcommand for the
 *	native filesystem for 'set' operations.  A part of Tcl's native
 *	filesystem support, it is defined here because it is used under both
 *	Unix and Windows.
 *
 * Results:
 *	A standard Tcl return code.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _NativeFileAttrsSet(tls *libc.TLS, interp uintptr, index int32, pathPtr uintptr, objPtr uintptr) (r int32) {
	/* The value to set. */
	return (*(*func(*libc.TLS, uintptr, int32, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{XtclpFileAttrProcs[index].FsetProc})))(tls, interp, index, pathPtr, objPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FSFileAttrStrings --
 *
 *	Implements part of the hookable 'file attributes'
 *	subcommand.
 *
 *	Calls 'fileAttrStringsProc' of the filesystem corresponding to the
 *	given pathname.
 *
 * Results:
 *	Returns an array of strings, or returns NULL and stores in objPtrRef
 *	a pointer to a new Tcl list having a refCount of zero, and containing
 *	the file attribute strings.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FSFileAttrStrings(tls *libc.TLS, pathPtr uintptr, objPtrRef uintptr) (r uintptr) {
	var fsPtr uintptr
	_ = fsPtr
	fsPtr = XTcl_FSGetFileSystemForPath(tls, pathPtr)
	if fsPtr != libc.UintptrFromInt32(0) && (*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FfileAttrStringsProc != libc.UintptrFromInt32(0) {
		return (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FfileAttrStringsProc})))(tls, pathPtr, objPtrRef)
	}
	XTcl_SetErrno(tls, int32(ENOENT))
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * TclFSFileAttrIndex --
 *
 *	Given an attribute name, determines the index of the attribute in the
 *	attribute table.
 *
 * Results:
 *	A standard Tcl result code.
 *
 *	If there is no error, stores the index in *indexPtr.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclFSFileAttrIndex(tls *libc.TLS, pathPtr uintptr, attributeName uintptr, indexPtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* A place to store the result. */
	var attrTable, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, tmpObj, v11, v14, v16, v19, v2, v5 uintptr
	var i, v1, v10, v15, v18, v4 TTcl_Size
	var result, v7 int32
	var v12, v17, v20, v3, v6 bool
	var v8, v9 int64
	var _ /* listObj at bp+0 */ uintptr
	var _ /* objc at bp+8 */ TTcl_Size
	var _ /* objv at bp+16 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = attrTable, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, i, result, tmpObj, v1, v10, v11, v12, v14, v15, v16, v17, v18, v19, v2, v20, v3, v4, v5, v6, v7, v8, v9
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	/*
	 * Get the attribute table for the file.
	 */
	attrTable = XTcl_FSFileAttrStrings(tls, pathPtr, bp)
	if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FrefCount++
	}
	if attrTable != libc.UintptrFromInt32(0) {
		/*
		 * It's a constant attribute table, so use T_GIFO.
		 */
		tmpObj = XTcl_NewStringObj(tls, attributeName, int64(-int32(1)))
		result = XTcl_GetIndexFromObjStruct(tls, libc.UintptrFromInt32(0), tmpObj, attrTable, libc.Int64FromUint64(libc.Uint64FromInt64(8)), libc.UintptrFromInt32(0), libc.Int32FromInt32(TCL_EXACT)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), indexPtr)
		v2 = tmpObj
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if !(v1 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = int64(-libc.Int32FromInt32(1))
				if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, tmpObj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(tmpObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = tmpObj
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, tmpObj)
			}
		}
		if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
			v5 = *(*uintptr)(unsafe.Pointer(bp))
			v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
			*(*TTcl_Size)(unsafe.Pointer(v5))--
			if !(v4 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Flength = int64(-libc.Int32FromInt32(1))
					if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
						cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v6 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp)))
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp))
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp)))
				}
			}
		}
		return result
	} else {
		if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr2 != 0 {
					v8 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr2)).FspanStart
				} else {
					v8 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr1)).FfirstUsed
				}
				*(*uintptr)(unsafe.Pointer(bp + 16)) = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr1 + 40 + uintptr(v8)*8
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr2 != 0 {
					v9 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr2)).FspanLength
				} else {
					v9 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v9
				v7 = libc.Int32FromInt32(TCL_OK)
			} else {
				v7 = XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), bp+8, bp+16)
			}
			if v7 != TCL_OK {
				v11 = *(*uintptr)(unsafe.Pointer(bp))
				v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
				*(*TTcl_Size)(unsafe.Pointer(v11))--
				if !(v10 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Flength = int64(-libc.Int32FromInt32(1))
						if v12 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v12 {
							cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v12 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp)))
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp))
							(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp)))
					}
				}
				return int32(TCL_ERROR)
			}
			i = 0
			for {
				if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) {
					break
				}
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i)*8)))).Fbytes != 0 {
					v14 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i)*8)))).Fbytes
				} else {
					v14 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i)*8)), libc.UintptrFromInt32(0))
				}
				if !(libc.Xstrcmp(tls, attributeName, v14) != 0) {
					v16 = *(*uintptr)(unsafe.Pointer(bp))
					v15 = *(*TTcl_Size)(unsafe.Pointer(v16))
					*(*TTcl_Size)(unsafe.Pointer(v16))--
					if !(v15 > int64(1)) {
						if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr)).FfreeIntRepProc != 0) {
							if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
								XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes)
							}
							(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Flength = int64(-libc.Int32FromInt32(1))
							if v17 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v17 {
								cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
							}
							if v17 || ((*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
								XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp)))
							} else {
								(*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
								(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp))
								(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects++
							}
						} else {
							XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp)))
						}
					}
					*(*int32)(unsafe.Pointer(indexPtr)) = int32(i)
					return TCL_OK
				}
				goto _13
			_13:
				;
				i++
			}
			v19 = *(*uintptr)(unsafe.Pointer(bp))
			v18 = *(*TTcl_Size)(unsafe.Pointer(v19))
			*(*TTcl_Size)(unsafe.Pointer(v19))--
			if !(v18 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Flength = int64(-libc.Int32FromInt32(1))
					if v20 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v20 {
						cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v20 || ((*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp)))
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp))
						(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp)))
				}
			}
			return int32(TCL_ERROR)
		} else {
			return int32(TCL_ERROR)
		}
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FSFileAttrsGet --
 *
 *	Implements read access for the hookable 'file attributes' subcommand.
 *
 *	Calls 'fileAttrsGetProc' of the filesystem corresponding to the given
 *	pathname.
 *
 * Results:
 *	A standard Tcl return code.
 *
 *	On success, stores in objPtrRef a pointer to a new Tcl_Obj having a
 *	refCount of zero, and containing the result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FSFileAttrsGet(tls *libc.TLS, interp uintptr, index int32, pathPtr uintptr, objPtrRef uintptr) (r int32) {
	/* A place to store the result. */
	var fsPtr uintptr
	_ = fsPtr
	fsPtr = XTcl_FSGetFileSystemForPath(tls, pathPtr)
	if fsPtr != libc.UintptrFromInt32(0) && (*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FfileAttrsGetProc != libc.UintptrFromInt32(0) {
		return (*(*func(*libc.TLS, uintptr, int32, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FfileAttrsGetProc})))(tls, interp, index, pathPtr, objPtrRef)
	}
	XTcl_SetErrno(tls, int32(ENOENT))
	return -int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FSFileAttrsSet --
 *
 *	Implements write access for the hookable 'file
 *	attributes' subcommand.
 *
 *	Calls 'fileAttrsSetProc' for the filesystem corresponding to the given
 *	pathname.
 *
 * Results:
 *	A standard Tcl return code.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FSFileAttrsSet(tls *libc.TLS, interp uintptr, index int32, pathPtr uintptr, objPtr uintptr) (r int32) {
	/* A place to store the result. */
	var fsPtr uintptr
	_ = fsPtr
	fsPtr = XTcl_FSGetFileSystemForPath(tls, pathPtr)
	if fsPtr != libc.UintptrFromInt32(0) && (*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FfileAttrsSetProc != libc.UintptrFromInt32(0) {
		return (*(*func(*libc.TLS, uintptr, int32, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FfileAttrsSetProc})))(tls, interp, index, pathPtr, objPtr)
	}
	XTcl_SetErrno(tls, int32(ENOENT))
	return -int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FSGetCwd --
 *
 *	Replaces the library version of getcwd().
 *
 *	Most virtual filesystems do not implement cwdProc. Tcl maintains its
 *	own record of the current directory which it keeps synchronized with
 *	the filesystem corresponding to the pathname of the current directory
 *	if the filesystem provides a cwdProc (the native filesystem does).
 *
 *	If Tcl's current directory is not in the native filesystem, Tcl's
 *	current directory and the current directory of the process are
 *	different.  To avoid confusion, extensions should call Tcl_FSGetCwd to
 *	obtain the current directory from Tcl rather than from the operating
 *	system.
 *
 * Results:
 *	Returns a pointer to a Tcl_Obj having a refCount of 1 and containing
 *	the current thread's local copy of the global cwdPathPtr value.
 *
 *	Returns NULL if the current directory could not be determined, and
 *	leaves an error message in the interpreter's result.
 *
 * Side effects:
 *	Various objects may be freed and allocated.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FSGetCwd(tls *libc.TLS, interp uintptr) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, _objPtr6, cd, fsPtr, fsRecPtr, norm, norm1, norm2, proc2, proc21, retCd, retCd1, retVal, retVal1, str1, str2, tsdPtr, v12, v13, v17, v19, v21, v3, v5, v7, v9 uintptr
	var v16, v18, v2, v20, v4, v6, v8 TTcl_Size
	var _ /* len1 at bp+0 */ TTcl_Size
	var _ /* len2 at bp+8 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, _objPtr6, cd, fsPtr, fsRecPtr, norm, norm1, norm2, proc2, proc21, retCd, retCd1, retVal, retVal1, str1, str2, tsdPtr, v12, v13, v16, v17, v18, v19, v2, v20, v21, v3, v4, v5, v6, v7, v8, v9
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_fsDataKey)), int64(56))
	if XTclFSCwdPointerEquals(tls, libc.UintptrFromInt32(0)) != 0 {
		retVal = libc.UintptrFromInt32(0)
		/*
		 * This is the first time this routine has been called. Call
		 * 'getCwdProc' for each registered filsystems until one returns
		 * something other than NULL, which is a pointer to the pathname of the
		 * current directory.
		 */
		fsRecPtr = _FsGetFirstFilesystem(tls)
		_Claim(tls)
		for {
			if !(retVal == libc.UintptrFromInt32(0) && fsRecPtr != libc.UintptrFromInt32(0)) {
				break
			}
			if (*TTcl_Filesystem)(unsafe.Pointer((*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FfsPtr)).FgetCwdProc == libc.UintptrFromInt32(0) {
				goto _1
			}
			if (*TTcl_Filesystem)(unsafe.Pointer((*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FfsPtr)).Fversion == libc.UintptrFromInt32(0x1) {
				retVal = (*(*func(*libc.TLS, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer((*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FfsPtr)).FgetCwdProc})))(tls, interp)
				goto _1
			}
			proc2 = (*TTcl_Filesystem)(unsafe.Pointer((*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FfsPtr)).FgetCwdProc
			retCd = (*(*func(*libc.TLS, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{proc2})))(tls, libc.UintptrFromInt32(0))
			if retCd != libc.UintptrFromInt32(0) {
				/*
				 * Found the pathname of the current directory.
				 */
				retVal = (*(*func(*libc.TLS, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer((*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FfsPtr)).FinternalToNormalizedProc})))(tls, retCd)
				(*TTcl_Obj)(unsafe.Pointer(retVal)).FrefCount++
				norm = XTclFSNormalizeAbsolutePath(tls, interp, retVal)
				if norm != libc.UintptrFromInt32(0) {
					/*
					 * Assign to global storage the pathname of the current
					 * directory and copy it into thread-local storage as
					 * well.
					 *
					 * At system startup multiple threads could in principle
					 * call this function simultaneously, which is a little
					 * peculiar, but should be fine given the mutex locks in
					 * FSUPdateCWD.  Once some value is assigned to the global
					 * variable the 'else' branch below is always taken, which
					 * is simpler.
					 */
					_FsUpdateCwd(tls, norm, retCd)
					_objPtr = norm
					v3 = _objPtr
					v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
					*(*TTcl_Size)(unsafe.Pointer(v3))--
					if v2 <= int64(1) {
						XTclFreeObj(tls, _objPtr)
					}
				} else {
					(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer((*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FfsPtr)).FfreeInternalRepProc})))(tls, retCd)
				}
				_objPtr1 = retVal
				v5 = _objPtr1
				v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
				*(*TTcl_Size)(unsafe.Pointer(v5))--
				if v4 <= int64(1) {
					XTclFreeObj(tls, _objPtr1)
				}
				retVal = libc.UintptrFromInt32(0)
				_Disclaim(tls)
				goto cdDidNotChange
			} else {
				if interp != libc.UintptrFromInt32(0) {
					XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+49760, libc.VaList(bp+24, XTcl_PosixError(tls, interp))))
				}
			}
			goto _1
		_1:
			;
			fsRecPtr = (*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FnextPtr
		}
		_Disclaim(tls)
		if retVal != libc.UintptrFromInt32(0) {
			/*
			 * On some platforms the pathname of the current directory might
			 * not be normalized.  For efficiency, ensure that it is
			 * normalized.  For the sake of efficiency, we want a completely
			 * normalized current working directory at all times.
			 */
			norm1 = XTclFSNormalizeAbsolutePath(tls, interp, retVal)
			if norm1 != libc.UintptrFromInt32(0) {
				/*
				 * We found a current working directory, which is now in our
				 * global storage. We must make a copy. Norm already has a
				 * refCount of 1.
				 *
				 * Threading issue: Multiple threads at system startup could in
				 * principle call this function simultaneously. They will
				 * therefore each set the cwdPathPtr independently, which is a
				 * bit peculiar, but should be fine. Once we have a cwd, we'll
				 * always be in the 'else' branch below which is simpler.
				 */
				cd = XTcl_FSGetNativePath(tls, norm1)
				_FsUpdateCwd(tls, norm1, XTclNativeDupInternalRep(tls, cd))
				_objPtr2 = norm1
				v7 = _objPtr2
				v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
				*(*TTcl_Size)(unsafe.Pointer(v7))--
				if v6 <= int64(1) {
					XTclFreeObj(tls, _objPtr2)
				}
			}
			_objPtr3 = retVal
			v9 = _objPtr3
			v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
			*(*TTcl_Size)(unsafe.Pointer(v9))--
			if v8 <= int64(1) {
				XTclFreeObj(tls, _objPtr3)
			}
		} else {
			/*
			 * retVal is NULL.  There is no current directory, which could be
			 * problematic.
			 */
		}
	} else {
		/*
		 * There is a thread-local value for the pathname of the current
		 * directory.  Give corresponding filesystem a chance update the value
		 * if it is out-of-date. This allows an error to be thrown if, for
		 * example, the permissions on the current working directory have
		 * changed.
		 */
		fsPtr = XTcl_FSGetFileSystemForPath(tls, (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr)
		retCd1 = libc.UintptrFromInt32(0)
		if fsPtr == libc.UintptrFromInt32(0) || (*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FgetCwdProc == libc.UintptrFromInt32(0) {
			/*
			 * There is no corresponding filesystem or the filesystem does not
			 * have a getCwd routine. Just assume current local value is ok.
			 */
			goto cdDidNotChange
		}
		if (*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).Fversion == libc.UintptrFromInt32(0x1) {
			retVal1 = (*(*func(*libc.TLS, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FgetCwdProc})))(tls, interp)
		} else {
			/*
			 * New API.
			 */
			proc21 = (*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FgetCwdProc
			retCd1 = (*(*func(*libc.TLS, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{proc21})))(tls, (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdClientData)
			if retCd1 == libc.UintptrFromInt32(0) && interp != libc.UintptrFromInt32(0) {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+49760, libc.VaList(bp+24, XTcl_PosixError(tls, interp))))
			}
			if retCd1 == (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdClientData {
				goto cdDidNotChange
			}
			/*
			 * Looks like a new current directory.
			 */
			retVal1 = (*(*func(*libc.TLS, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FinternalToNormalizedProc})))(tls, retCd1)
			(*TTcl_Obj)(unsafe.Pointer(retVal1)).FrefCount++
		}
		if retVal1 == libc.UintptrFromInt32(0) {
			/*
			 * The current directory could not be determined.  Reset the
			 * current direcory to ensure, for example, that 'pwd' does actually
			 * throw the correct error in Tcl.  This is tested for in the test
			 * suite on unix.
			 */
			_FsUpdateCwd(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
			goto cdDidNotChange
		}
		norm2 = XTclFSNormalizeAbsolutePath(tls, interp, retVal1)
		if norm2 == libc.UintptrFromInt32(0) {
			/*
			 * 'norm' shouldn't ever be NULL, but we are careful.
			 */
			/* Do nothing */
			if retCd1 != libc.UintptrFromInt32(0) {
				(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FfreeInternalRepProc})))(tls, retCd1)
			}
		} else {
			if !(norm2 == (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr) {
				goto _10
			}
			goto cdEqual
			goto _11
		_10:
			;
			if (*TTcl_Obj)(unsafe.Pointer((*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr)).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer((*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr)).Flength
				v12 = (*TTcl_Obj)(unsafe.Pointer((*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr)).Fbytes
			} else {
				v12 = XTcl_GetStringFromObj(tls, (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr, bp)
			}
			str1 = v12
			if (*TTcl_Obj)(unsafe.Pointer(norm2)).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(norm2)).Flength
				v13 = (*TTcl_Obj)(unsafe.Pointer(norm2)).Fbytes
			} else {
				v13 = XTcl_GetStringFromObj(tls, norm2, bp+8)
			}
			str2 = v13
			if !(*(*TTcl_Size)(unsafe.Pointer(bp)) == *(*TTcl_Size)(unsafe.Pointer(bp + 8)) && libc.Xstrcmp(tls, str1, str2) == 0) {
				goto _14
			}
			/*
			 * The pathname values are equal so retain the old pathname
			 * object which is probably already shared and free the
			 * normalized pathname that was just produced.
			 */
			goto cdEqual
		cdEqual:
			;
			_objPtr4 = norm2
			v17 = _objPtr4
			v16 = *(*TTcl_Size)(unsafe.Pointer(v17))
			*(*TTcl_Size)(unsafe.Pointer(v17))--
			if v16 <= int64(1) {
				XTclFreeObj(tls, _objPtr4)
			}
			if retCd1 != libc.UintptrFromInt32(0) {
				(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FfreeInternalRepProc})))(tls, retCd1)
			}
			goto _15
		_14:
			;
			/*
			 * The pathname of the current directory is not the same as
			 * this thread's local cached value.  Replace the local value.
			 */
			_FsUpdateCwd(tls, norm2, retCd1)
			_objPtr5 = norm2
			v19 = _objPtr5
			v18 = *(*TTcl_Size)(unsafe.Pointer(v19))
			*(*TTcl_Size)(unsafe.Pointer(v19))--
			if v18 <= int64(1) {
				XTclFreeObj(tls, _objPtr5)
			}
		_15:
			;
		_11:
		}
		_objPtr6 = retVal1
		v21 = _objPtr6
		v20 = *(*TTcl_Size)(unsafe.Pointer(v21))
		*(*TTcl_Size)(unsafe.Pointer(v21))--
		if v20 <= int64(1) {
			XTclFreeObj(tls, _objPtr6)
		}
	}
	goto cdDidNotChange
cdDidNotChange:
	;
	if (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr != libc.UintptrFromInt32(0) {
		(*TTcl_Obj)(unsafe.Pointer((*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr)).FrefCount++
	}
	return (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FSChdir --
 *
 *	Replaces the library version of chdir().
 *
 *	Calls 'chdirProc' of the filesystem that corresponds to the given
 *	pathname.
 *
 * Results:
 *	See chdir() documentation.
 *
 * Side effects:
 *	See chdir() documentation.
 *
 *	On success stores in cwdPathPtr the pathname of the new current
 *	directory.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FSChdir(tls *libc.TLS, pathPtr uintptr) (r int32) {
	bp := tls.Alloc(144)
	defer tls.Free(144)
	var cd, fsPtr, normDirName, oldFsPtr, oldcd, proc2, tsdPtr uintptr
	var retVal int32
	var _ /* buf at bp+0 */ TTcl_StatBuf
	_, _, _, _, _, _, _, _ = cd, fsPtr, normDirName, oldFsPtr, oldcd, proc2, retVal, tsdPtr
	oldFsPtr = libc.UintptrFromInt32(0)
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_fsDataKey)), int64(56))
	retVal = -int32(1)
	if (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr != libc.UintptrFromInt32(0) {
		oldFsPtr = XTcl_FSGetFileSystemForPath(tls, (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdPathPtr)
	}
	if XTcl_FSGetNormalizedPath(tls, libc.UintptrFromInt32(0), pathPtr) == libc.UintptrFromInt32(0) {
		XTcl_SetErrno(tls, int32(ENOENT))
		return retVal
	}
	fsPtr = XTcl_FSGetFileSystemForPath(tls, pathPtr)
	if fsPtr != libc.UintptrFromInt32(0) {
		if (*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FchdirProc != libc.UintptrFromInt32(0) {
			/*
			 * If this fails Tcl_SetErrno() has already been called.
			 */
			retVal = (*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FchdirProc})))(tls, pathPtr)
		} else {
			if XTcl_FSStat(tls, pathPtr, bp) == 0 && (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) && XTcl_FSAccess(tls, pathPtr, int32(R_OK)) == 0 {
				/*
				 * stat was successful, and the file is a directory and is
				 * readable.  Can proceed to change the current directory.
				 */
				retVal = 0
			} else {
				/*
				 * 'Tcl_SetErrno()' has already been called.
				 */
			}
		}
	} else {
		XTcl_SetErrno(tls, int32(ENOENT))
	}
	if retVal == 0 {
		/* Assume that the cwd was actually changed to the normalized value
		 * just calculated, and cache that information.  */
		/*
		 * If the filesystem epoch changed recently, the normalized pathname or
		 * its internal handle may be different from what was found above.
		 * This can easily be the case with scripted documents . Therefore get
		 * the normalized pathname again. The correct value will have been
		 * cached as a result of the Tcl_FSGetFileSystemForPath call, above.
		 */
		normDirName = XTcl_FSGetNormalizedPath(tls, libc.UintptrFromInt32(0), pathPtr)
		if normDirName == libc.UintptrFromInt32(0) {
			/* Not really true, but what else to do? */
			XTcl_SetErrno(tls, int32(ENOENT))
			return -int32(1)
		}
		if fsPtr == uintptr(unsafe.Pointer(&XtclNativeFilesystem)) {
			oldcd = (*TThreadSpecificData7)(unsafe.Pointer(tsdPtr)).FcwdClientData
			/*
			 * Assume that the native filesystem has a getCwdProc and that it
			 * is at version 2.
			 */
			proc2 = (*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FgetCwdProc
			cd = (*(*func(*libc.TLS, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{proc2})))(tls, oldcd)
			if cd != oldcd {
				/*
				 * Call getCwdProc() and store the resulting internal handle to
				 * compare things with it later.  This might not be
				 * exactly the same string as that of the fully normalized
				 * pathname.  For example, for the Windows internal handle the
				 * separator is the backslash character.  On Unix it might well
				 * be true that the internal handle is the fully normalized
				 * pathname and one could simply use:
				 *	cd = Tcl_FSGetNativePath(pathPtr);
				 * but this can't be guaranteed in the general case.  In fact,
				 * the internal handle could be any value the filesystem
				 * decides to use to identify a node.
				 */
				_FsUpdateCwd(tls, normDirName, cd)
			}
		} else {
			/*
			 * Tcl_FSGetCwd() synchronizes the file-global cwdPathPtr if
			 * needed.  However, if there is no 'getCwdProc', cwdPathPtr must be
			 * updated right now because there won't be another chance.  This
			 * block of code is currently executed whether or not the
			 * filesystem provides a getCwdProc, but it should in principle
			 * work to only call this block if fsPtr->getCwdProc == NULL.
			 */
			_FsUpdateCwd(tls, normDirName, libc.UintptrFromInt32(0))
		}
		if oldFsPtr != libc.UintptrFromInt32(0) && fsPtr != oldFsPtr {
			/*
			 * The filesystem of the current directory is not the same as the
			 * filesystem of the previous current directory.  Invalidate All
			 * FsPath objects.
			 */
			XTcl_FSMountsChanged(tls, libc.UintptrFromInt32(0))
		}
	} else {
		/*
		 * The current directory is now changed or an error occurred and an
		 * error message is now set. Just continue.
		 */
	}
	return retVal
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FSLoadFile --
 *
 *	Loads a dynamic shared object by passing the given pathname unmodified
 *	to Tcl_LoadFile, and provides pointers to the functions named by 'sym1'
 *	and 'sym2', and another pointer to a function that unloads the object.
 *
 * Results:
 *	A standard Tcl completion code. If an error occurs, sets the
 *	interpreter's result to an error message.
 *
 * Side effects:
 *	A dynamic shared object is loaded into memory.  This may later be
 *	unloaded by passing the handlePtr to *unloadProcPtr.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FSLoadFile(tls *libc.TLS, interp uintptr, pathPtr uintptr, sym1 uintptr, sym2 uintptr, proc1Ptr uintptr, proc2Ptr uintptr, handlePtr uintptr, dummy3027 uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var res int32
	var v1 uintptr
	var _ /* procPtrs at bp+24 */ [2]uintptr
	var _ /* symbols at bp+0 */ [3]uintptr
	_, _ = res, v1
	(*(*[3]uintptr)(unsafe.Pointer(bp)))[0] = sym1
	(*(*[3]uintptr)(unsafe.Pointer(bp)))[int32(1)] = sym2
	(*(*[3]uintptr)(unsafe.Pointer(bp)))[int32(2)] = libc.UintptrFromInt32(0)
	res = XTcl_LoadFile(tls, interp, pathPtr, bp, 0, bp+24, handlePtr)
	if res == TCL_OK {
		*(*uintptr)(unsafe.Pointer(proc1Ptr)) = (*(*[2]uintptr)(unsafe.Pointer(bp + 24)))[0]
		*(*uintptr)(unsafe.Pointer(proc2Ptr)) = (*(*[2]uintptr)(unsafe.Pointer(bp + 24)))[int32(1)]
	} else {
		v1 = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(proc2Ptr)) = v1
		*(*uintptr)(unsafe.Pointer(proc1Ptr)) = v1
	}
	return res
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LoadFile --
 *
 *	Load a dynamic shared object by calling 'loadFileProc' of the
 *	filesystem corresponding to the given pathname, and then finds within
 *	the loaded object the functions named in symbols[].
 *
 *	The given pathname is passed unmodified to `loadFileProc`, which
 *	decides how to resolve it.  On POSIX systems the native filesystem
 *	passes the given pathname to dlopen(), which resolves the filename
 *	according to its own set of rules.  This behaviour is not very
 *	compatible with virtual filesystems, and has other problems as
 *	documented for [load], so it is recommended to use an absolute
 *	pathname.
 *
 * Results:
 *	A standard Tcl completion code. If an error occurs, sets the
 *	interpreter result to an error message.
 *
 * Side effects:
 *	Memory is allocated for the new object. May be freed by calling
 *	TclFS_UnloadFile.
 *
 *----------------------------------------------------------------------
 */

/*
 * Modern HPUX allows the unlink (no ETXTBSY error) yet somehow trashes some
 * internal data structures, preventing any additional dynamic shared objects
 * from getting properly loaded. Only the first is ok.  Work around the issue
 * by not unlinking, i.e., emulating the behaviour of the older HPUX which
 * denied removal.
 *
 * Doing the unlink is also an issue within docker containers, whose AUFS
 * bungles this as well, see
 *     https://github.com/dotcloud/docker/issues/1911
 *
 */

func _skipUnlink(tls *libc.TLS, shlibFile uintptr) (r int32) {
	var skipstr uintptr
	_ = skipstr
	/*
	 * Unlinking is not performed in the following cases:
	 *
	 * 1. The operating system is HPUX.
	 *
	 * 2. If the environment variable TCL_TEMPLOAD_NO_UNLINK is present and
	 *    set to true (an integer > 0)
	 *
	 * 3. TCL_TEMPLOAD_NO_UNLINK is not true (an integer > 0) and AUFS
	 *    filesystem can be detected (using statfs, if available).
	 */
	skipstr = libc.Xgetenv(tls, __ccgo_ts+49801)
	if skipstr != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(skipstr))) != int32('\000') {
		return libc.Xatoi(tls, skipstr)
	}
	_ = shlibFile
	/*
	 * No HPUX, environment variable override, or AUFS detected.  Perform
	 * unlink.
	 */
	return 0
}

func XTcl_LoadFile(tls *libc.TLS, interp uintptr, pathPtr uintptr, symbols uintptr, flags int32, procVPtrs uintptr, handlePtr uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* A place to hold a token for the loaded object.
	 * Can be used by TclpFindSymbol. */
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, cachePtr, copyFsPtr, copyToPtr, fsPtr, newUnloadProcPtr, perm, procPtrs, tvdlPtr, v1, v10, v12, v14, v3, v5, v8 uintptr
	var divertedLoadHandle TTcl_LoadHandle
	var i, retVal int32
	var v11, v13, v2, v4, v7, v9 TTcl_Size
	var v6 bool
	var _ /* index at bp+16 */ int32
	var _ /* newLoadHandle at bp+8 */ TTcl_LoadHandle
	var _ /* unloadProcPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, cachePtr, copyFsPtr, copyToPtr, divertedLoadHandle, fsPtr, i, newUnloadProcPtr, perm, procPtrs, retVal, tvdlPtr, v1, v10, v11, v12, v13, v14, v2, v3, v4, v5, v6, v7, v8, v9
	procPtrs = procVPtrs
	fsPtr = XTcl_FSGetFileSystemForPath(tls, pathPtr)
	*(*TTcl_LoadHandle)(unsafe.Pointer(bp + 8)) = libc.UintptrFromInt32(0)
	divertedLoadHandle = libc.UintptrFromInt32(0)
	newUnloadProcPtr = libc.UintptrFromInt32(0)
	if fsPtr == libc.UintptrFromInt32(0) {
		XTcl_SetErrno(tls, int32(ENOENT))
		return int32(TCL_ERROR)
	}
	if (*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FloadFileProc != libc.UintptrFromInt32(0) {
		retVal = (*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FloadFileProc})))(tls, interp, pathPtr, handlePtr, bp, flags)
		if retVal == TCL_OK {
			if *(*TTcl_LoadHandle)(unsafe.Pointer(handlePtr)) == libc.UintptrFromInt32(0) {
				return int32(TCL_ERROR)
			}
			if interp != 0 {
				XTcl_ResetResult(tls, interp)
			}
			goto resolveSymbols
		}
		if XTcl_GetErrno(tls) != int32(EXDEV) {
			return retVal
		}
	}
	/*
	 * The filesystem doesn't support 'load'. Fall to the following:
	 */
	/*
	 * Make sure the file is accessible.
	 */
	if XTcl_FSAccess(tls, pathPtr, int32(R_OK)) != 0 {
		if interp != 0 {
			if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
				v1 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
			} else {
				v1 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+49824, libc.VaList(bp+32, v1, XTcl_PosixError(tls, interp))))
		}
		return int32(TCL_ERROR)
	}
	/*
	 * Get a temporary filename, first to copy the file into, and then to load.
	 */
	copyToPtr = XTclpTempFileNameForLibrary(tls, interp, pathPtr)
	if copyToPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	(*TTcl_Obj)(unsafe.Pointer(copyToPtr)).FrefCount++
	copyFsPtr = XTcl_FSGetFileSystemForPath(tls, copyToPtr)
	if copyFsPtr == libc.UintptrFromInt32(0) || copyFsPtr == fsPtr {
		/*
		 * Tcl_FSLoadFile isn't available for the filesystem of the temporary
		 * file.  In order to avoid a possible infinite loop, do not attempt to
		 * load further.
		 */
		/*
		 * Try to delete the file we probably created and then exit.
		 */
		XTcl_FSDeleteFile(tls, copyToPtr)
		_objPtr = copyToPtr
		v3 = _objPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+49855, int64(-int32(1))))
		}
		return int32(TCL_ERROR)
	}
	if XTclCrossFilesystemCopy(tls, interp, pathPtr, copyToPtr) != TCL_OK {
		XTcl_FSDeleteFile(tls, copyToPtr)
		_objPtr1 = copyToPtr
		v5 = _objPtr1
		v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
		*(*TTcl_Size)(unsafe.Pointer(v5))--
		if v4 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		return int32(TCL_ERROR)
	}
	/*
	 * It might be necessary on some systems to set the appropriate permissions
	 * on the file.  On Unix we could loop over the file attributes and set any
	 * that are called "-permissions" to 0700, but just do it directly instead:
	 */
	if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v6 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		perm = XTclThreadAllocObj(tls)
	} else {
		perm = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(perm + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(perm)).FrefCount = 0
	if libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(perm)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(perm)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(perm)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(perm)).Fbytes, __ccgo_ts+49893, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(perm)).Fbytes + uintptr(libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(perm)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(5) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(perm)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(perm)).FrefCount++
	if XTclFSFileAttrIndex(tls, copyToPtr, __ccgo_ts+33918, bp+16) == TCL_OK {
		XTcl_FSFileAttrsSet(tls, libc.UintptrFromInt32(0), *(*int32)(unsafe.Pointer(bp + 16)), copyToPtr, perm)
	}
	_objPtr2 = perm
	v8 = _objPtr2
	v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
	*(*TTcl_Size)(unsafe.Pointer(v8))--
	if v7 <= int64(1) {
		XTclFreeObj(tls, _objPtr2)
	}
	/*
	 * The cross-filesystem copy may have stored the number of bytes in the
	 * result, so reset the result now.
	 */
	if interp != 0 {
		XTcl_ResetResult(tls, interp)
	}
	retVal = XTcl_LoadFile(tls, interp, copyToPtr, symbols, flags, procPtrs, bp+8)
	if retVal != TCL_OK {
		XTcl_FSDeleteFile(tls, copyToPtr)
		_objPtr3 = copyToPtr
		v10 = _objPtr3
		v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
		*(*TTcl_Size)(unsafe.Pointer(v10))--
		if v9 <= int64(1) {
			XTclFreeObj(tls, _objPtr3)
		}
		return retVal
	}
	/*
	 * Try to delete the file immediately.  Some operatings systems allow this,
	 * and it avoids leaving the copy laying around after exit.
	 */
	if !(_skipUnlink(tls, copyToPtr) != 0) && XTcl_FSDeleteFile(tls, copyToPtr) == TCL_OK {
		_objPtr4 = copyToPtr
		v12 = _objPtr4
		v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
		*(*TTcl_Size)(unsafe.Pointer(v12))--
		if v11 <= int64(1) {
			XTclFreeObj(tls, _objPtr4)
		}
		/*
		 * Tell the caller all the details:  The package list maintained by
		 * 'load' stores the original (vfs) pathname, the handle of object
		 * loaded from the temporary file, and the unloadProcPtr.
		 */
		*(*TTcl_LoadHandle)(unsafe.Pointer(handlePtr)) = *(*TTcl_LoadHandle)(unsafe.Pointer(bp + 8))
		if interp != 0 {
			XTcl_ResetResult(tls, interp)
		}
		return TCL_OK
	}
	/*
	 * Divert the unloading in order to unload and cleanup the temporary file.
	 */
	tvdlPtr = XTcl_Alloc(tls, uint64(40))
	/*
	 * Remember three pieces of information in order to clean up the diverted
	 * load completely on platforms which allow proper unloading of code.
	 */
	(*TFsDivertLoad)(unsafe.Pointer(tvdlPtr)).FloadHandle = *(*TTcl_LoadHandle)(unsafe.Pointer(bp + 8))
	(*TFsDivertLoad)(unsafe.Pointer(tvdlPtr)).FunloadProcPtr = newUnloadProcPtr
	if copyFsPtr != uintptr(unsafe.Pointer(&XtclNativeFilesystem)) {
		/* refCount of copyToPtr is already incremented.  */
		(*TFsDivertLoad)(unsafe.Pointer(tvdlPtr)).FdivertedFile = copyToPtr
		/*
		 * This is the filesystem for the temporary file the object was loaded
		 * from.  A reference to copyToPtr is already stored in
		 * tvdlPtr->divertedFile, so need need to increment the refCount again.
		 */
		(*TFsDivertLoad)(unsafe.Pointer(tvdlPtr)).FdivertedFilesystem = copyFsPtr
		(*TFsDivertLoad)(unsafe.Pointer(tvdlPtr)).FdivertedFileNativeRep = libc.UintptrFromInt32(0)
	} else {
		/*
		 * Grab the native representation.
		 */
		(*TFsDivertLoad)(unsafe.Pointer(tvdlPtr)).FdivertedFileNativeRep = XTclNativeDupInternalRep(tls, XTcl_FSGetInternalRep(tls, copyToPtr, copyFsPtr))
		/*
		 * Don't keeep a reference to the Tcl_Obj or the native filesystem.
		 */
		(*TFsDivertLoad)(unsafe.Pointer(tvdlPtr)).FdivertedFile = libc.UintptrFromInt32(0)
		(*TFsDivertLoad)(unsafe.Pointer(tvdlPtr)).FdivertedFilesystem = libc.UintptrFromInt32(0)
		_objPtr5 = copyToPtr
		v14 = _objPtr5
		v13 = *(*TTcl_Size)(unsafe.Pointer(v14))
		*(*TTcl_Size)(unsafe.Pointer(v14))--
		if v13 <= int64(1) {
			XTclFreeObj(tls, _objPtr5)
		}
	}
	copyToPtr = libc.UintptrFromInt32(0)
	divertedLoadHandle = XTcl_Alloc(tls, uint64(24))
	(*TTcl_LoadHandle_)(unsafe.Pointer(divertedLoadHandle)).FclientData = tvdlPtr
	(*TTcl_LoadHandle_)(unsafe.Pointer(divertedLoadHandle)).FfindSymbolProcPtr = __ccgo_fp(_DivertFindSymbol)
	(*TTcl_LoadHandle_)(unsafe.Pointer(divertedLoadHandle)).FunloadFileProcPtr = __ccgo_fp(_DivertUnloadFile)
	*(*TTcl_LoadHandle)(unsafe.Pointer(handlePtr)) = divertedLoadHandle
	if interp != 0 {
		XTcl_ResetResult(tls, interp)
	}
	return retVal
	goto resolveSymbols
resolveSymbols:
	;
	/*
	 * handlePtr now contains a token for the loaded object.
	 * Resolve the symbols.
	 */
	if symbols != libc.UintptrFromInt32(0) {
		i = 0
		for {
			if !(*(*uintptr)(unsafe.Pointer(symbols + uintptr(i)*8)) != libc.UintptrFromInt32(0)) {
				break
			}
			*(*uintptr)(unsafe.Pointer(procPtrs + uintptr(i)*8)) = XTcl_FindSymbol(tls, interp, *(*TTcl_LoadHandle)(unsafe.Pointer(handlePtr)), *(*uintptr)(unsafe.Pointer(symbols + uintptr(i)*8)))
			if *(*uintptr)(unsafe.Pointer(procPtrs + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				/*
				 * At least one symbol in the list was not found.  Unload the
				 * file and return an error code.  Tcl_FindSymbol should have
				 * already left an appropriate error message.
				 */
				(*(*func(*libc.TLS, TTcl_LoadHandle))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_LoadHandle_)(unsafe.Pointer(*(*TTcl_LoadHandle)(unsafe.Pointer(handlePtr)))).FunloadFileProcPtr})))(tls, *(*TTcl_LoadHandle)(unsafe.Pointer(handlePtr)))
				*(*TTcl_LoadHandle)(unsafe.Pointer(handlePtr)) = libc.UintptrFromInt32(0)
				return int32(TCL_ERROR)
			}
			goto _15
		_15:
			;
			i++
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * DivertFindSymbol --
 *
 *	Find a symbol in a shared library loaded by making a copying a file
 *	from the virtual filesystem to a native filesystem.
 *
 *----------------------------------------------------------------------
 */

func _DivertFindSymbol(tls *libc.TLS, interp uintptr, loadHandle TTcl_LoadHandle, symbol uintptr) (r uintptr) {
	/* The name of symbol to resolve. */
	var originalHandle TTcl_LoadHandle
	var tvdlPtr uintptr
	_, _ = originalHandle, tvdlPtr
	tvdlPtr = (*TTcl_LoadHandle_)(unsafe.Pointer(loadHandle)).FclientData
	originalHandle = (*TFsDivertLoad)(unsafe.Pointer(tvdlPtr)).FloadHandle
	return (*(*func(*libc.TLS, uintptr, TTcl_LoadHandle, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_LoadHandle_)(unsafe.Pointer(originalHandle)).FfindSymbolProcPtr})))(tls, interp, originalHandle, symbol)
}

/*
 *----------------------------------------------------------------------
 *
 * DivertUnloadFile --
 *
 *	Unloads an object that was loaded from a temporary file copied from the
 *	virtual filesystem the native filesystem.
 *
 *----------------------------------------------------------------------
 */

func _DivertUnloadFile(tls *libc.TLS, loadHandle TTcl_LoadHandle) {
	/* A handle for the loaded object. */
	var _objPtr, tvdlPtr, v2 uintptr
	var originalHandle TTcl_LoadHandle
	var v1 TTcl_Size
	_, _, _, _, _ = _objPtr, originalHandle, tvdlPtr, v1, v2
	tvdlPtr = (*TTcl_LoadHandle_)(unsafe.Pointer(loadHandle)).FclientData
	if tvdlPtr == libc.UintptrFromInt32(0) {
		/*
		 * tvdlPtr was provided by Tcl_LoadFile so it should not be NULL here.
		 */
		return
	}
	originalHandle = (*TFsDivertLoad)(unsafe.Pointer(tvdlPtr)).FloadHandle
	/*
	 * Call the real 'unloadfile' proc.  This must be called first so that the
	 * shared library is actually unloaded by the OS. Otherwise, the following
	 * 'delete' may fail because the shared library is still in use.
	 */
	(*(*func(*libc.TLS, TTcl_LoadHandle))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_LoadHandle_)(unsafe.Pointer(originalHandle)).FunloadFileProcPtr})))(tls, originalHandle)
	/*
	 * Determine which filesystem contains the temporary copy of the file.
	 */
	if (*TFsDivertLoad)(unsafe.Pointer(tvdlPtr)).FdivertedFilesystem == libc.UintptrFromInt32(0) {
		/*
		 * Use the function for the native filsystem, which works even at
		 * this late stage.
		 */
		XTclpDeleteFile(tls, (*TFsDivertLoad)(unsafe.Pointer(tvdlPtr)).FdivertedFileNativeRep)
		_NativeFreeInternalRep(tls, (*TFsDivertLoad)(unsafe.Pointer(tvdlPtr)).FdivertedFileNativeRep)
	} else {
		/*
		 * Remove the temporary file.  If encodings have been cleaned up
		 * already, this may crash.
		 */
		if (*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer((*TFsDivertLoad)(unsafe.Pointer(tvdlPtr)).FdivertedFilesystem)).FdeleteFileProc})))(tls, (*TFsDivertLoad)(unsafe.Pointer(tvdlPtr)).FdivertedFile) != TCL_OK {
			/*
			 * This may have happened because Tcl is exiting, and encodings may
			 * have already been deleted or something else the filesystem
			 * depends on may be gone.
			 *
			 * TO DO:  Figure out how to delete this file more robustly, or
			 * give the filesystem the information it needs to delete the file
			 * more robustly.  One problem might be that the filesystem cannot
			 * extract the information it needs from the above pathname object
			 * because Tcl's entire filesystem apparatus (the code in this
			 * file) has been finalized and there is no way to get the native
			 * handle of the file.
			 */
		}
		/*
		 * This also decrements the refCount of the Tcl_Filesystem
		 * corresponding to this file. which might cause the filesystem to be
		 * deallocated if Tcl is exiting.
		 */
		_objPtr = (*TFsDivertLoad)(unsafe.Pointer(tvdlPtr)).FdivertedFile
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	XTclpFree(tls, tvdlPtr)
	XTclpFree(tls, loadHandle)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FindSymbol --
 *
 *	Find a symbol in a loaded object.
 *
 *	Previously filesystem-specific, but has been made portable by having
 *	TclpDlopen return a structure that includes procedure pointers.
 *
 * Results:
 *	Returns a pointer to the symbol if found.  Otherwise, sets
 *	an error message in the interpreter result and returns NULL.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FindSymbol(tls *libc.TLS, interp uintptr, loadHandle TTcl_LoadHandle, symbol uintptr) (r uintptr) {
	/* The name of the symbol to resolve. */
	return (*(*func(*libc.TLS, uintptr, TTcl_LoadHandle, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_LoadHandle_)(unsafe.Pointer(loadHandle)).FfindSymbolProcPtr})))(tls, interp, loadHandle, symbol)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FSUnloadFile --
 *
 *	Unloads a loaded  object if unloading is supported for the object.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FSUnloadFile(tls *libc.TLS, interp uintptr, handle TTcl_LoadHandle) (r int32) {
	/* A handle for the object to unload. */
	if (*TTcl_LoadHandle_)(unsafe.Pointer(handle)).FunloadFileProcPtr == libc.UintptrFromInt32(0) {
		if interp != libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+49898, int64(-int32(1))))
		}
		return int32(TCL_ERROR)
	}
	if (*TTcl_LoadHandle_)(unsafe.Pointer(handle)).FunloadFileProcPtr != libc.UintptrFromInt32(0) {
		(*(*func(*libc.TLS, TTcl_LoadHandle))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_LoadHandle_)(unsafe.Pointer(handle)).FunloadFileProcPtr})))(tls, handle)
	}
	return TCL_OK
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_FSLink --
 *
 *	Creates or inspects a link by calling 'linkProc' of the filesystem
 *	corresponding to the given pathname.  Replaces the library version of
 *	readlink().
 *
 * Results:
 *	If toPtr is NULL, a Tcl_Obj containing the value the symbolic link for
 *	'pathPtr', or NULL if a symbolic link was not accessible.  The caller
 *	should Tcl_DecrRefCount on the result to release it.  Otherwise NULL.
 *
 *	In this case the result has no additional reference count and need not
 *	be freed. The actual action to perform is given by the 'linkAction'
 *	flags, which is a combination of:
 *
 *		TCL_CREATE_SYMBOLIC_LINK
 *		TCL_CREATE_HARD_LINK
 *
 *	Most filesystems do not support linking across to different
 *	filesystems, so this function usually fails if the filesystem
 *	corresponding to toPtr is not the same as the filesystem corresponding
 *	to pathPtr.
 *
 * Side effects:
 *	Creates or sets a link if toPtr is not NULL.
 *
 *	See readlink().
 *
 *---------------------------------------------------------------------------
 */

func XTcl_FSLink(tls *libc.TLS, pathPtr uintptr, toPtr uintptr, linkAction int32) (r uintptr) {
	/* Action to perform. */
	var fsPtr uintptr
	_ = fsPtr
	fsPtr = XTcl_FSGetFileSystemForPath(tls, pathPtr)
	if fsPtr != 0 {
		if (*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FlinkProc == libc.UintptrFromInt32(0) {
			XTcl_SetErrno(tls, int32(EOPNOTSUPP))
			return libc.UintptrFromInt32(0)
		} else {
			return (*(*func(*libc.TLS, uintptr, uintptr, int32) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FlinkProc})))(tls, pathPtr, toPtr, linkAction)
		}
	}
	/*
	 * If S_IFLNK isn't defined the machine doesn't support symbolic links, so
	 * the file can't possibly be a symbolic link. Generate an EINVAL error,
	 * which is what happens on machines that do support symbolic links when
	 * readlink is called for a file that isn't a symbolic link.
	 */
	XTcl_SetErrno(tls, int32(ENOENT))
	return libc.UintptrFromInt32(0)
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_FSListVolumes --
 *
 *	Lists the currently mounted volumes by calling `listVolumesProc` of
 *	each registered filesystem, and combining the results to form a list of
 *	volumes.
 *
 * Results:
 *	The list of volumes, in an object which has refCount 0.
 *
 * Side effects:
 *	None
 *
 *---------------------------------------------------------------------------
 */

func XTcl_FSListVolumes(tls *libc.TLS) (r uintptr) {
	var _objPtr, cachePtr, fsRecPtr, resultPtr, thisFsVolumes, v3 uintptr
	var v1 bool
	var v2 TTcl_Size
	_, _, _, _, _, _, _, _ = _objPtr, cachePtr, fsRecPtr, resultPtr, thisFsVolumes, v1, v2, v3
	/*
	 * Call each "listVolumes" function of each registered filesystem in
	 * succession. A non-NULL return value indicates the particular function
	 * has succeeded.
	 */
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultPtr = XTclThreadAllocObj(tls)
	} else {
		resultPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FtypePtr = libc.UintptrFromInt32(0)
	fsRecPtr = _FsGetFirstFilesystem(tls)
	_Claim(tls)
	for fsRecPtr != libc.UintptrFromInt32(0) {
		if (*TTcl_Filesystem)(unsafe.Pointer((*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FfsPtr)).FlistVolumesProc != libc.UintptrFromInt32(0) {
			thisFsVolumes = (*(*func(*libc.TLS) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer((*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FfsPtr)).FlistVolumesProc})))(tls)
			if thisFsVolumes != libc.UintptrFromInt32(0) {
				XTcl_ListObjAppendList(tls, libc.UintptrFromInt32(0), resultPtr, thisFsVolumes)
				/*
				 * The refCount of each list returned by a `listVolumesProc`
				 * is already incremented.  Do not hang onto the list, though.
				 * It belongs to the filesystem.  Add its contents to the
				 * result we are building, and then decrement the refCount.
				 */
				_objPtr = thisFsVolumes
				v3 = _objPtr
				v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
				*(*TTcl_Size)(unsafe.Pointer(v3))--
				if v2 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
		}
		fsRecPtr = (*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FnextPtr
	}
	_Disclaim(tls)
	return resultPtr
}

/*
 *---------------------------------------------------------------------------
 *
 * FsListMounts --
 *
 *	Lists the mounts mathing the given pattern in the given directory.
 *
 * Results:
 *	A list, having a refCount of 0, of the matching mounts, or NULL if no
 *	search was performed because no filesystem provided a search routine.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func _FsListMounts(tls *libc.TLS, pathPtr uintptr, pattern uintptr) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Pattern to match against. */
	var cachePtr, fsRecPtr, resultPtr uintptr
	var v1 bool
	var _ /* mountsOnly at bp+0 */ TTcl_GlobTypeData
	_, _, _, _ = cachePtr, fsRecPtr, resultPtr, v1
	*(*TTcl_GlobTypeData)(unsafe.Pointer(bp)) = TTcl_GlobTypeData{
		Ftype1: libc.Int32FromInt32(1) << libc.Int32FromInt32(7),
	}
	resultPtr = libc.UintptrFromInt32(0)
	/*
	 * Call the matchInDirectory function of each registered filesystem,
	 * passing it 'mountsOnly'.  Results accumulate in resultPtr.
	 */
	fsRecPtr = _FsGetFirstFilesystem(tls)
	_Claim(tls)
	for fsRecPtr != libc.UintptrFromInt32(0) {
		if (*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FfsPtr != uintptr(unsafe.Pointer(&XtclNativeFilesystem)) && (*TTcl_Filesystem)(unsafe.Pointer((*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FfsPtr)).FmatchInDirectoryProc != libc.UintptrFromInt32(0) {
			if resultPtr == libc.UintptrFromInt32(0) {
				if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
					resultPtr = XTclThreadAllocObj(tls)
				} else {
					resultPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(resultPtr + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Flength = 0
				(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FtypePtr = libc.UintptrFromInt32(0)
			}
			(*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer((*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FfsPtr)).FmatchInDirectoryProc})))(tls, libc.UintptrFromInt32(0), resultPtr, pathPtr, pattern, bp)
		}
		fsRecPtr = (*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FnextPtr
	}
	_Disclaim(tls)
	return resultPtr
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_FSSplitPath --
 *
 *	Splits a pathname into its components.
 *
 * Results:
 *	A list with refCount of zero.
 *
 * Side effects:
 *	If lenPtr is not null, sets it to the number of elements in the result.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_FSSplitPath(tls *libc.TLS, pathPtr uintptr, lenPtr uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* A place to hold the number of pathname
	 * elements. */
	var _objPtr, cachePtr, elementStart, nextElt, p, result, sep, v1, v3, v5, v7 uintptr
	var length, v2 TTcl_Size
	var separator uint8
	var v4 bool
	var v9 int64
	var _ /* driveNameLength at bp+8 */ TTcl_Size
	var _ /* fsPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, elementStart, length, nextElt, p, result, sep, separator, v1, v2, v3, v4, v5, v7, v9
	result = libc.UintptrFromInt32(0)
	separator = uint8('/')
	/*
	 * Perform platform-specific splitting.
	 */
	if XTclFSGetPathType(tls, pathPtr, bp, bp+8) == int32(TCL_PATH_ABSOLUTE) {
		if *(*uintptr)(unsafe.Pointer(bp)) == uintptr(unsafe.Pointer(&XtclNativeFilesystem)) {
			return XTclpNativeSplitPath(tls, pathPtr, lenPtr)
		}
	} else {
		return XTclpNativeSplitPath(tls, pathPtr, lenPtr)
	}
	/* Assume each separator is a single character. */
	if (*TTcl_Filesystem)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FfilesystemSeparatorProc != libc.UintptrFromInt32(0) {
		sep = (*(*func(*libc.TLS, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FfilesystemSeparatorProc})))(tls, pathPtr)
		if sep != libc.UintptrFromInt32(0) {
			(*TTcl_Obj)(unsafe.Pointer(sep)).FrefCount++
			if (*TTcl_Obj)(unsafe.Pointer(sep)).Fbytes != 0 {
				v1 = (*TTcl_Obj)(unsafe.Pointer(sep)).Fbytes
			} else {
				v1 = XTcl_GetStringFromObj(tls, sep, libc.UintptrFromInt32(0))
			}
			separator = *(*uint8)(unsafe.Pointer(v1))
			_objPtr = sep
			v3 = _objPtr
			v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
			*(*TTcl_Size)(unsafe.Pointer(v3))--
			if v2 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
	}
	/*
	 * Add the drive name as first element of the result. The drive name may
	 * contain strange characters like colons and sequences of forward slashes
	 * For example, 'ftp://' is a valid drive name.
	 */
	if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		result = XTclThreadAllocObj(tls)
	} else {
		result = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(result + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(result)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(result)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(result)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(result)).FtypePtr = libc.UintptrFromInt32(0)
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
		v5 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
	} else {
		v5 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
	}
	p = v5
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), result, XTcl_NewStringObj(tls, p, *(*TTcl_Size)(unsafe.Pointer(bp + 8))))
	p += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
	/*
	 * Add the remaining pathname elements to the list.
	 */
	for {
		elementStart = p
		for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('\000') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != libc.Int32FromUint8(separator) {
			p++
		}
		length = int64(p) - int64(elementStart)
		if length > 0 {
			nextElt = XTcl_NewStringObj(tls, elementStart, length)
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), result, nextElt)
		}
		v7 = p
		p++
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v7))) == int32('\000') {
			break
		}
		goto _6
	_6:
	}
	if lenPtr != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(result)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(result + 32))).Fptr2 != 0 {
				v9 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(result + 32))).Fptr2)).FspanLength
			} else {
				v9 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(result + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(lenPtr)) = v9
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), result, lenPtr)
		}
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * TclGetPathType --
 *
 *	Helper function used by TclFSGetPathType and TclJoinPath.
 *
 * Results:
 *	One of TCL_PATH_ABSOLUTE, TCL_PATH_RELATIVE, or
 *	TCL_PATH_VOLUME_RELATIVE.
 *
 * Side effects:
 *	See **filesystemPtrptr, *driveNameLengthPtr and **driveNameRef,
 *
 *----------------------------------------------------------------------
 */

func XTclGetPathType(tls *libc.TLS, pathPtr uintptr, filesystemPtrPtr uintptr, driveNameLengthPtr uintptr, driveNameRef uintptr) (r TTcl_PathType) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* If not NULL, for an absolute pathname, a
	 * place to store a pointer to an object with a
	 * refCount of 1, and whose value is the name
	 * of the volume. */
	var path, v1 uintptr
	var type1 TTcl_PathType
	var _ /* pathLen at bp+0 */ TTcl_Size
	_, _, _ = path, type1, v1
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, pathPtr, bp)
	}
	path = v1
	type1 = XTclFSNonnativePathType(tls, path, *(*TTcl_Size)(unsafe.Pointer(bp)), filesystemPtrPtr, driveNameLengthPtr, driveNameRef)
	if type1 != int32(TCL_PATH_ABSOLUTE) {
		type1 = XTclpGetNativePathType(tls, pathPtr, driveNameLengthPtr, driveNameRef)
		if type1 == int32(TCL_PATH_ABSOLUTE) && filesystemPtrPtr != libc.UintptrFromInt32(0) {
			*(*uintptr)(unsafe.Pointer(filesystemPtrPtr)) = uintptr(unsafe.Pointer(&XtclNativeFilesystem))
		}
	}
	return type1
}

/*
 *----------------------------------------------------------------------
 *
 * TclFSNonnativePathType --
 *
 *	Helper function used by TclGetPathType. Checks whether the given
 *	pathname starts with a string which corresponds to a file volume in
 *	some registered filesystem other than the native one.  For speed and
 *	historical reasons the native filesystem has special hard-coded checks
 *	dotted here and there in the filesystem code.
 *
 * Results:
 *	One of TCL_PATH_ABSOLUTE or TCL_PATH_RELATIVE.  The filesystem
 *	reference will be set if and only if it is non-NULL and the function's
 *	return value is TCL_PATH_ABSOLUTE.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclFSNonnativePathType(tls *libc.TLS, path uintptr, pathLen TTcl_Size, filesystemPtrPtr uintptr, driveNameLengthPtr uintptr, driveNameRef uintptr) (r TTcl_PathType) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* If not NULL, a place to store a pointer to
	 * an object having its refCount already
	 * incremented, and contining the name of the
	 * volume if the pathname is absolute. */
	var _objPtr, fsRecPtr, strVol, thisFsVolumes, v3, v5 uintptr
	var type1 TTcl_PathType
	var v1 int32
	var v2 int64
	var v4 TTcl_Size
	var _ /* len at bp+16 */ TTcl_Size
	var _ /* numVolumes at bp+0 */ TTcl_Size
	var _ /* vol at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _ = _objPtr, fsRecPtr, strVol, thisFsVolumes, type1, v1, v2, v3, v4, v5
	type1 = int32(TCL_PATH_RELATIVE)
	/*
	 * Determine whether the given pathname is an absolute pathname on some
	 * filesystem other than the native filesystem.
	 */
	fsRecPtr = _FsGetFirstFilesystem(tls)
	_Claim(tls)
	for fsRecPtr != libc.UintptrFromInt32(0) {
		/*
		 * Skip the native filesystem because otherwise some of the tests
		 * in the Tcl testsuite might fail because some of the tests
		 * artificially change the current platform (between win, unix) but the
		 * list of volumes obtained by calling fsRecPtr->fsPtr->listVolumesProc
		 * reflects the current (real) platform only. In particular, on Unix
		 * '/' matchs the beginning of certain absolute Windows pathnames
		 * starting '//' and those tests go wrong.
		 *
		 * There is another reason to skip the native filesystem:  Since the
		 * tclFilename.c code has nice fast 'absolute path' checkers, there is
		 * no reason to waste time doing that in this frequently-called
		 * function.  It is better to save the overhead of the native
		 * filesystem continuously returning a list of volumes.
		 */
		if (*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FfsPtr != uintptr(unsafe.Pointer(&XtclNativeFilesystem)) && (*TTcl_Filesystem)(unsafe.Pointer((*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FfsPtr)).FlistVolumesProc != libc.UintptrFromInt32(0) {
			thisFsVolumes = (*(*func(*libc.TLS) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer((*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FfsPtr)).FlistVolumesProc})))(tls)
			if thisFsVolumes != libc.UintptrFromInt32(0) {
				if (*TTcl_Obj)(unsafe.Pointer(thisFsVolumes)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
					if (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(thisFsVolumes + 32))).Fptr2 != 0 {
						v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(thisFsVolumes + 32))).Fptr2)).FspanLength
					} else {
						v2 = (*TListStore)(unsafe.Pointer((*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(thisFsVolumes + 32))).Fptr1)).FnumUsed
					}
					*(*TTcl_Size)(unsafe.Pointer(bp)) = v2
					v1 = libc.Int32FromInt32(TCL_OK)
				} else {
					v1 = XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), thisFsVolumes, bp)
				}
				if v1 != TCL_OK {
					/*
					 * This is VERY bad; the listVolumesProc didn't return a
					 * valid list. Set numVolumes to -1 to skip the loop below
					 * and just return with the current value of 'type'.
					 *
					 * It would be better to signal an error here, but
					 * Tcl_Panic seems a bit excessive.
					 */
					*(*TTcl_Size)(unsafe.Pointer(bp)) = int64(-libc.Int32FromInt32(1))
				}
				for *(*TTcl_Size)(unsafe.Pointer(bp)) > 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp))--
					XTcl_ListObjIndex(tls, libc.UintptrFromInt32(0), thisFsVolumes, *(*TTcl_Size)(unsafe.Pointer(bp)), bp+8)
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != 0 {
						*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength
						v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes
					} else {
						v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), bp+16)
					}
					strVol = v3
					if pathLen < *(*TTcl_Size)(unsafe.Pointer(bp + 16)) {
						continue
					}
					if libc.Xstrncmp(tls, strVol, path, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 16)))) == 0 {
						type1 = int32(TCL_PATH_ABSOLUTE)
						if filesystemPtrPtr != libc.UintptrFromInt32(0) {
							*(*uintptr)(unsafe.Pointer(filesystemPtrPtr)) = (*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FfsPtr
						}
						if driveNameLengthPtr != libc.UintptrFromInt32(0) {
							*(*TTcl_Size)(unsafe.Pointer(driveNameLengthPtr)) = *(*TTcl_Size)(unsafe.Pointer(bp + 16))
						}
						if driveNameRef != libc.UintptrFromInt32(0) {
							*(*uintptr)(unsafe.Pointer(driveNameRef)) = *(*uintptr)(unsafe.Pointer(bp + 8))
							(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
						}
						break
					}
				}
				_objPtr = thisFsVolumes
				v5 = _objPtr
				v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
				*(*TTcl_Size)(unsafe.Pointer(v5))--
				if v4 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
				if type1 == int32(TCL_PATH_ABSOLUTE) {
					/*
					 * No need to examine additional filesystems.
					 */
					break
				}
			}
		}
		fsRecPtr = (*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FnextPtr
	}
	_Disclaim(tls)
	return type1
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_FSRenameFile --
 *
 *	If the two pathnames correspond to the same filesystem, call
 *	'renameFileProc' of that filesystem.  Otherwise return the POSIX error
 *	'EXDEV', and -1.
 *
 * Results:
 *	A standard Tcl error code if a rename function was called, or -1
 *	otherwise.
 *
 * Side effects:
 *	A file may be renamed.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_FSRenameFile(tls *libc.TLS, srcPathPtr uintptr, destPathPtr uintptr) (r int32) {
	/* The new pathname for the file. */
	var fsPtr, fsPtr2 uintptr
	var retVal int32
	_, _, _ = fsPtr, fsPtr2, retVal
	retVal = -int32(1)
	fsPtr = XTcl_FSGetFileSystemForPath(tls, srcPathPtr)
	fsPtr2 = XTcl_FSGetFileSystemForPath(tls, destPathPtr)
	if fsPtr == fsPtr2 && fsPtr != libc.UintptrFromInt32(0) && (*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FrenameFileProc != libc.UintptrFromInt32(0) {
		retVal = (*(*func(*libc.TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FrenameFileProc})))(tls, srcPathPtr, destPathPtr)
	}
	if retVal == -int32(1) {
		XTcl_SetErrno(tls, int32(EXDEV))
	}
	return retVal
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_FSCopyFile --
 *
 *	If both pathnames correspond to the same filesystem, calls
 *	'copyFileProc' of that filesystem.
 *
 *	In the native filesystems, 'copyFileProc' copies a link itself, not the
 *	thing the link points to.
 *
 * Results:
 *	A standard Tcl return code if a copyFileProc was called, or -1
 *	otherwise.
 *
 * Side effects:
 *	A file might be copied.  The POSIX error 'EXDEV' is set if a copy
 *	function was not called.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_FSCopyFile(tls *libc.TLS, srcPathPtr uintptr, destPathPtr uintptr) (r int32) {
	/* The new pathname to copy the file to. */
	var fsPtr, fsPtr2 uintptr
	var retVal int32
	_, _, _ = fsPtr, fsPtr2, retVal
	retVal = -int32(1)
	fsPtr = XTcl_FSGetFileSystemForPath(tls, srcPathPtr)
	fsPtr2 = XTcl_FSGetFileSystemForPath(tls, destPathPtr)
	if fsPtr == fsPtr2 && fsPtr != libc.UintptrFromInt32(0) && (*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FcopyFileProc != libc.UintptrFromInt32(0) {
		retVal = (*(*func(*libc.TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FcopyFileProc})))(tls, srcPathPtr, destPathPtr)
	}
	if retVal == -int32(1) {
		XTcl_SetErrno(tls, int32(EXDEV))
	}
	return retVal
}

/*
 *---------------------------------------------------------------------------
 *
 * TclCrossFilesystemCopy --
 *
 *	Helper for Tcl_FSCopyFile and Tcl_FSLoadFile.  Copies a file from one
 *	filesystem to another, overwiting any file that already exists.
 *
 * Results:
 *	A standard Tcl return code.
 *
 * Side effects:
 *	A file may be copied.
 *
 *---------------------------------------------------------------------------
 */

func XTclCrossFilesystemCopy(tls *libc.TLS, interp uintptr, source uintptr, target uintptr) (r int32) {
	bp := tls.Alloc(160)
	defer tls.Free(160) /* Pathname to copy the file to. */
	var in, out TTcl_Channel
	var prot, result int32
	var _ /* sourceStatBuf at bp+0 */ TTcl_StatBuf
	var _ /* tval at bp+144 */ Tutimbuf
	_, _, _, _ = in, out, prot, result
	result = int32(TCL_ERROR)
	prot = int32(0666)
	out = XTcl_FSOpenFileChannel(tls, interp, target, __ccgo_ts+49951, prot)
	if out == libc.UintptrFromInt32(0) {
		/*
		 * Failed to open an output channel.  Bail out.
		 */
		goto done
	}
	in = XTcl_FSOpenFileChannel(tls, interp, source, __ccgo_ts+49954, prot)
	if in == libc.UintptrFromInt32(0) {
		/*
		 * Could not open an input channel.  Why didn't the caller check this?
		 */
		XTcl_CloseEx(tls, interp, out, 0)
		goto done
	}
	/*
	 * Copy the file synchronously.  TO DO:  Maybe add an asynchronous option
	 * to support virtual filesystems that are slow (e.g. network sockets).
	 */
	if XTclCopyChannel(tls, interp, in, out, int64(-int32(1)), libc.UintptrFromInt32(0)) == TCL_OK {
		result = TCL_OK
	}
	/*
	 * If the copy failed, assume that copy channel left an error message.
	 */
	XTcl_CloseEx(tls, interp, in, 0)
	XTcl_CloseEx(tls, interp, out, 0)
	/*
	 * Set modification date of copied file.
	 */
	if XTcl_FSLstat(tls, source, bp) == 0 {
		(*(*Tutimbuf)(unsafe.Pointer(bp + 144))).Factime = XTcl_GetAccessTimeFromStat(tls, bp)
		(*(*Tutimbuf)(unsafe.Pointer(bp + 144))).Fmodtime = XTcl_GetModificationTimeFromStat(tls, bp)
		XTcl_FSUtime(tls, target, bp+144)
	}
	goto done
done:
	;
	return result
	return r
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_FSDeleteFile --
 *
 *	Calls 'deleteFileProc' of the filesystem corresponding to the given
 *	pathname.
 *
 * Results:
 *	A standard Tcl return code.
 *
 * Side effects:
 *	A file may be deleted.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_FSDeleteFile(tls *libc.TLS, pathPtr uintptr) (r int32) {
	/* Pathname of file to be removed (UTF-8). */
	var err int32
	var fsPtr uintptr
	_, _ = err, fsPtr
	fsPtr = XTcl_FSGetFileSystemForPath(tls, pathPtr)
	if fsPtr == libc.UintptrFromInt32(0) {
		err = int32(ENOENT)
	} else {
		if (*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FdeleteFileProc != libc.UintptrFromInt32(0) {
			return (*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FdeleteFileProc})))(tls, pathPtr)
		}
		err = int32(EOPNOTSUPP)
	}
	XTcl_SetErrno(tls, err)
	return -int32(1)
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_FSCreateDirectory --
 *
 *	Calls 'createDirectoryProc' of the filesystem corresponding to the
 *	given pathname.
 *
 * Results:
 *	A standard Tcl return code, or -1 if no createDirectoryProc is found.
 *
 * Side effects:
 *	A directory may be created.  POSIX error 'ENOENT' is set if no
 *	createDirectoryProc is found.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_FSCreateDirectory(tls *libc.TLS, pathPtr uintptr) (r int32) {
	/* Pathname of directory to create (UTF-8). */
	var err int32
	var fsPtr uintptr
	_, _ = err, fsPtr
	fsPtr = XTcl_FSGetFileSystemForPath(tls, pathPtr)
	if fsPtr == libc.UintptrFromInt32(0) {
		err = int32(ENOENT)
	} else {
		if (*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FcreateDirectoryProc != libc.UintptrFromInt32(0) {
			return (*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FcreateDirectoryProc})))(tls, pathPtr)
		}
		err = int32(EOPNOTSUPP)
	}
	XTcl_SetErrno(tls, err)
	return -int32(1)
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_FSCopyDirectory --
 *
 *	If both pathnames correspond to the same filesystem, calls
 *	'copyDirectoryProc' of that filesystem.
 *
 * Results:
 *	A standard Tcl return code, or -1 if no 'copyDirectoryProc' is found.
 *
 * Side effects:
 *	A directory may be copied. POSIX error 'EXDEV' is set if no
 *	copyDirectoryProc is found.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_FSCopyDirectory(tls *libc.TLS, srcPathPtr uintptr, destPathPtr uintptr, errorPtr uintptr) (r int32) {
	/* If not NULL, and there is an error, a place
	 * to store a pointer to a new object, with
	 * its refCount already incremented, and
	 * containing the pathname name of file
	 * causing the error. */
	var fsPtr, fsPtr2 uintptr
	var retVal int32
	_, _, _ = fsPtr, fsPtr2, retVal
	retVal = -int32(1)
	fsPtr = XTcl_FSGetFileSystemForPath(tls, srcPathPtr)
	fsPtr2 = XTcl_FSGetFileSystemForPath(tls, destPathPtr)
	if fsPtr == fsPtr2 && fsPtr != libc.UintptrFromInt32(0) && (*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FcopyDirectoryProc != libc.UintptrFromInt32(0) {
		retVal = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FcopyDirectoryProc})))(tls, srcPathPtr, destPathPtr, errorPtr)
	}
	if retVal == -int32(1) {
		XTcl_SetErrno(tls, int32(EXDEV))
	}
	return retVal
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_FSRemoveDirectory --
 *
 *	Calls 'removeDirectoryProc' of the filesystem corresponding to remove
 *	pathPtr.
 *
 * Results:
 *	A standard Tcl return code, or -1 if no removeDirectoryProc is found.
 *
 * Side effects:
 *	A directory may be removed.  POSIX error 'ENOENT' is set if no
 *	removeDirectoryProc is found.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_FSRemoveDirectory(tls *libc.TLS, pathPtr uintptr, recursive int32, errorPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* If not NULL and an error occurs, stores a
	 * place to store a pointer to a new
	 * object having a refCount of 1 and containing
	 * the name of the file that produced an error. */
	var _objPtr, _objPtr1, cwdPtr, cwdStr, dirPtr, fsPtr, normPath, normPathStr, v1, v2, v4, v6 uintptr
	var v3, v5 TTcl_Size
	var _ /* cwdLen at bp+0 */ TTcl_Size
	var _ /* normLen at bp+8 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cwdPtr, cwdStr, dirPtr, fsPtr, normPath, normPathStr, v1, v2, v3, v4, v5, v6
	fsPtr = XTcl_FSGetFileSystemForPath(tls, pathPtr)
	if fsPtr == libc.UintptrFromInt32(0) {
		XTcl_SetErrno(tls, int32(ENOENT))
		return -int32(1)
	}
	if (*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FremoveDirectoryProc == libc.UintptrFromInt32(0) {
		XTcl_SetErrno(tls, int32(EOPNOTSUPP))
		return -int32(1)
	}
	if recursive != 0 {
		cwdPtr = XTcl_FSGetCwd(tls, libc.UintptrFromInt32(0))
		if cwdPtr != libc.UintptrFromInt32(0) {
			normPath = XTcl_FSGetNormalizedPath(tls, libc.UintptrFromInt32(0), pathPtr)
			if normPath != libc.UintptrFromInt32(0) {
				if (*TTcl_Obj)(unsafe.Pointer(normPath)).Fbytes != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(normPath)).Flength
					v1 = (*TTcl_Obj)(unsafe.Pointer(normPath)).Fbytes
				} else {
					v1 = XTcl_GetStringFromObj(tls, normPath, bp+8)
				}
				normPathStr = v1
				if (*TTcl_Obj)(unsafe.Pointer(cwdPtr)).Fbytes != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(cwdPtr)).Flength
					v2 = (*TTcl_Obj)(unsafe.Pointer(cwdPtr)).Fbytes
				} else {
					v2 = XTcl_GetStringFromObj(tls, cwdPtr, bp)
				}
				cwdStr = v2
				if *(*TTcl_Size)(unsafe.Pointer(bp)) >= *(*TTcl_Size)(unsafe.Pointer(bp + 8)) && libc.Xstrncmp(tls, normPathStr, cwdStr, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))) == 0 {
					/*
					 * The cwd is inside the directory to be removed.  Change
					 * the cwd to [file dirname $path].
					 */
					dirPtr = XTclPathPart(tls, libc.UintptrFromInt32(0), pathPtr, int32(TCL_PATH_DIRNAME))
					XTcl_FSChdir(tls, dirPtr)
					_objPtr = dirPtr
					v4 = _objPtr
					v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
					*(*TTcl_Size)(unsafe.Pointer(v4))--
					if v3 <= int64(1) {
						XTclFreeObj(tls, _objPtr)
					}
				}
			}
			_objPtr1 = cwdPtr
			v6 = _objPtr1
			v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
			*(*TTcl_Size)(unsafe.Pointer(v6))--
			if v5 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
		}
	}
	return (*(*func(*libc.TLS, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FremoveDirectoryProc})))(tls, pathPtr, recursive, errorPtr)
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_FSGetFileSystemForPath --
 *
 *	Produces the filesystem that corresponds to the given pathname.
 *
 * Results:
 *	The corresponding Tcl_Filesystem, or NULL if the pathname is invalid.
 *
 * Side effects:
 *	The internal representation of fsPtrPtr is converted to fsPathType if
 *	needed, and that internal representation is updated as needed.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_FSGetFileSystemForPath(tls *libc.TLS, pathPtr uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var fsRecPtr uintptr
	var _ /* clientData at bp+8 */ uintptr
	var _ /* retVal at bp+0 */ uintptr
	_ = fsRecPtr
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	if pathPtr == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+49957, 0)
		return libc.UintptrFromInt32(0)
	}
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FrefCount == 0 {
		/*
		 * Avoid possible segfaults or nondeterministic memory leaks where the
		 * reference count has been incorreclty managed.
		 */
		XTcl_Panic(tls, __ccgo_ts+50008, 0)
		return libc.UintptrFromInt32(0)
	}
	/* Start with an up-to-date copy of the filesystem. */
	fsRecPtr = _FsGetFirstFilesystem(tls)
	_Claim(tls)
	/*
	 * Ensure that pathPtr is a valid pathname.
	 */
	if XTclFSEnsureEpochOk(tls, pathPtr, bp) != TCL_OK {
		/* not a valid pathname */
		_Disclaim(tls)
		return libc.UintptrFromInt32(0)
	} else {
		if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
			/*
			 * Found the filesystem in the internal representation of pathPtr.
			 */
			_Disclaim(tls)
			return *(*uintptr)(unsafe.Pointer(bp))
		}
	}
	/*
	 * Call each of the "pathInFilesystem" functions in succession until the
	 * corresponding filesystem is found.
	 */
	for {
		if !(fsRecPtr != libc.UintptrFromInt32(0)) {
			break
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = libc.UintptrFromInt32(0)
		if (*TTcl_Filesystem)(unsafe.Pointer((*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FfsPtr)).FpathInFilesystemProc == libc.UintptrFromInt32(0) {
			goto _1
		}
		if (*(*func(*libc.TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer((*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FfsPtr)).FpathInFilesystemProc})))(tls, pathPtr, bp+8) != -int32(1) {
			/* This is the filesystem for pathPtr.  Assume the type of pathPtr
			 * hasn't been changed by the above call to the
			 * pathInFilesystemProc, and cache this result in the internal
			 * representation of pathPtr.  */
			XTclFSSetPathDetails(tls, pathPtr, (*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FfsPtr, *(*uintptr)(unsafe.Pointer(bp + 8)))
			_Disclaim(tls)
			return (*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FfsPtr
		}
		goto _1
	_1:
		;
		fsRecPtr = (*TFilesystemRecord)(unsafe.Pointer(fsRecPtr)).FnextPtr
	}
	_Disclaim(tls)
	return libc.UintptrFromInt32(0)
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_FSGetNativePath --
 *
 *  See Tcl_FSGetInternalRep.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_FSGetNativePath(tls *libc.TLS, pathPtr uintptr) (r uintptr) {
	return XTcl_FSGetInternalRep(tls, pathPtr, uintptr(unsafe.Pointer(&XtclNativeFilesystem)))
}

/*
 *---------------------------------------------------------------------------
 *
 * NativeFreeInternalRep --
 *
 *	Free a native internal representation.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Memory is released.
 *
 *---------------------------------------------------------------------------
 */

func _NativeFreeInternalRep(tls *libc.TLS, clientData uintptr) {
	XTclpFree(tls, clientData)
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_FSFileSystemInfo --
 *	Produce the type of a pathname and the type of its filesystem.
 *
 *
 * Results:
 *	A list where the first item is the name of the filesystem (e.g.
 *	"native" or "vfs"), and the second item is the type of the given
 *	pathname within that filesystem.
 *
 * Side effects:
 *	The internal representation of pathPtr may be converted to a
 *	fsPathType.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_FSFileSystemInfo(tls *libc.TLS, pathPtr uintptr) (r uintptr) {
	var fsPtr, resPtr, typePtr uintptr
	_, _, _ = fsPtr, resPtr, typePtr
	fsPtr = XTcl_FSGetFileSystemForPath(tls, pathPtr)
	if fsPtr == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	resPtr = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resPtr, XTcl_NewStringObj(tls, (*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FtypeName, int64(-int32(1))))
	if (*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FfilesystemPathTypeProc != libc.UintptrFromInt32(0) {
		typePtr = (*(*func(*libc.TLS, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FfilesystemPathTypeProc})))(tls, pathPtr)
		if typePtr != libc.UintptrFromInt32(0) {
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resPtr, typePtr)
		}
	}
	return resPtr
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_FSPathSeparator --
 *
 *	Produces the separator for given pathname.
 *
 * Results:
 *	A Tcl object having a refCount of zero.
 *
 * Side effects:
 *	The internal representation of pathPtr may be converted to a fsPathType
 *
 *---------------------------------------------------------------------------
 */

func XTcl_FSPathSeparator(tls *libc.TLS, pathPtr uintptr) (r uintptr) {
	var cachePtr, fsPtr, resultObj uintptr
	var v1 bool
	_, _, _, _ = cachePtr, fsPtr, resultObj, v1
	fsPtr = XTcl_FSGetFileSystemForPath(tls, pathPtr)
	if fsPtr == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	if (*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FfilesystemSeparatorProc != libc.UintptrFromInt32(0) {
		return (*(*func(*libc.TLS, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer(fsPtr)).FfilesystemSeparatorProc})))(tls, pathPtr)
	}
	/*
	 * Use the standard forward slash character if filesystem does not to
	 * provide a filesystemSeparatorProc.
	 */
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	if libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes, __ccgo_ts+6339, libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes + uintptr(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(2) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	return resultObj
}

/*
 *---------------------------------------------------------------------------
 *
 * NativeFilesystemSeparator --
 *
 *	This function, part of the native filesystem support, returns the
 *	separator for the given pathname.
 *
 * Results:
 *	The separator character.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func _NativeFilesystemSeparator(tls *libc.TLS, dummy4619 uintptr) (r uintptr) {
	var separator uintptr
	_ = separator
	separator = libc.UintptrFromInt32(0)
	switch XtclPlatform {
	case int32(TCL_PLATFORM_UNIX):
		separator = __ccgo_ts + 6339
	case int32(TCL_PLATFORM_WINDOWS):
		separator = __ccgo_ts + 15596
		break
	}
	return XTcl_NewStringObj(tls, separator, int64(1))
}

type TFilesystemRecord1 = struct {
	FclientData uintptr
	FfsPtr      uintptr
	FnextPtr    uintptr
	FprevPtr    uintptr
}

const FLT_MAX3 = 3.4028234663852886e+38
const FLT_MIN1 = 1.1754943508222875e-38
const LINK_ALLOC_ADDR = 4
const LINK_ALLOC_LAST = 8
const LINK_BEING_UPDATED = 2
const LINK_READ_ONLY = 1

/*
 * For each linked variable there is a data structure of the following type,
 * which describes the link and is the clientData for the trace set on the Tcl
 * variable.
 */

type TLink = struct {
	Finterp    uintptr
	FnsPtr     uintptr
	FvarName   uintptr
	Faddr      uintptr
	Fbytes     TTcl_Size
	FnumElems  TTcl_Size
	Ftype1     int32
	FlastValue struct {
		Fuc           [0]uint8
		Fi            [0]int32
		Fui           [0]uint32
		Fs            [0]int16
		Fus           [0]uint16
		Fw            [0]TTcl_WideInt
		Fuw           [0]TTcl_WideUInt
		Ff            [0]float32
		Fd            [0]float64
		FaryPtr       [0]uintptr
		FcPtr         [0]uintptr
		FucPtr        [0]uintptr
		FsPtr         [0]uintptr
		FusPtr        [0]uintptr
		FiPtr         [0]uintptr
		FuiPtr        [0]uintptr
		FlPtr         [0]uintptr
		FulPtr        [0]uintptr
		FwPtr         [0]uintptr
		FuwPtr        [0]uintptr
		FfPtr         [0]uintptr
		FdPtr         [0]uintptr
		Fc            uint8
		F__ccgo_pad23 [7]byte
	}
	Fflags int32
}

/*
 * A marker type used to flag weirdnesses so we can pass them around right.
 */

var _invalidRealType = TTcl_ObjType{
	Fname:    __ccgo_ts + 50073,
	Fversion: uint64(libc.UintptrFromInt32(0) + 56),
}

func init() {
	p := unsafe.Pointer(&_invalidRealType)
	*(*uintptr)(unsafe.Add(p, 48)) = __ccgo_fp(XTclLengthOne)
}

/*
 * Convenience macro for accessing the value of the C variable pointed to by a
 * link. Note that this macro produces something that may be regarded as an
 * lvalue or rvalue; it may be assigned to as well as read. Also note that
 * this macro assumes the name of the variable being accessed (linkPtr); this
 * is not strictly a good thing, but it keeps the code much shorter and
 * cleaner.
 */

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LinkVar --
 *
 *	Link a C variable to a Tcl variable so that changes to either one
 *	causes the other to change.
 *
 * Results:
 *	The return value is TCL_OK if everything went well or TCL_ERROR if an
 *	error occurred (the interp's result is also set after errors).
 *
 * Side effects:
 *	The value at *addr is linked to the Tcl variable "varName", using
 *	"type" to convert between string values for Tcl and binary values for
 *	*addr.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LinkVar(tls *libc.TLS, interp uintptr, varName uintptr, addr uintptr, type1 int32) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Type of C variable: TCL_LINK_INT, etc. Also
	 * may have TCL_LINK_READ_ONLY OR'ed in. */
	var _objPtr, _objPtr1, linkPtr, objPtr, v2, v4 uintptr
	var code int32
	var v1, v3 TTcl_Size
	var _ /* dummy at bp+0 */ uintptr
	var _ /* name at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, code, linkPtr, objPtr, v1, v2, v3, v4
	linkPtr = XTcl_VarTraceInfo2(tls, interp, varName, libc.UintptrFromInt32(0), int32(TCL_GLOBAL_ONLY), __ccgo_fp(_LinkTraceProc), libc.UintptrFromInt32(0))
	if linkPtr != libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+50085, libc.VaList(bp+24, varName)))
		return int32(TCL_ERROR)
	}
	linkPtr = XTcl_Alloc(tls, uint64(72))
	(*TLink)(unsafe.Pointer(linkPtr)).Finterp = interp
	(*TLink)(unsafe.Pointer(linkPtr)).FnsPtr = libc.UintptrFromInt32(0)
	(*TLink)(unsafe.Pointer(linkPtr)).FvarName = XTcl_NewStringObj(tls, varName, int64(-int32(1)))
	(*TTcl_Obj)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).FvarName)).FrefCount++
	(*TLink)(unsafe.Pointer(linkPtr)).Faddr = addr
	(*TLink)(unsafe.Pointer(linkPtr)).Ftype1 = type1 & ^libc.Int32FromInt32(TCL_LINK_READ_ONLY)
	if type1&int32(TCL_LINK_READ_ONLY) != 0 {
		(*TLink)(unsafe.Pointer(linkPtr)).Fflags = int32(LINK_READ_ONLY)
	} else {
		(*TLink)(unsafe.Pointer(linkPtr)).Fflags = 0
	}
	(*TLink)(unsafe.Pointer(linkPtr)).Fbytes = 0
	(*TLink)(unsafe.Pointer(linkPtr)).FnumElems = 0
	objPtr = _ObjValue(tls, linkPtr)
	if XTcl_ObjSetVar2(tls, interp, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0), objPtr, libc.Int32FromInt32(TCL_GLOBAL_ONLY)|libc.Int32FromInt32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
		_objPtr = (*TLink)(unsafe.Pointer(linkPtr)).FvarName
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		_LinkFree(tls, linkPtr)
		return int32(TCL_ERROR)
	}
	XTclGetNamespaceForQualName(tls, interp, varName, libc.UintptrFromInt32(0), int32(TCL_GLOBAL_ONLY), linkPtr+8, bp, bp, bp+8)
	(*TNamespace)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).FnsPtr)).FrefCount++
	code = XTcl_TraceVar2(tls, interp, varName, libc.UintptrFromInt32(0), libc.Int32FromInt32(TCL_GLOBAL_ONLY)|libc.Int32FromInt32(TCL_TRACE_READS)|libc.Int32FromInt32(TCL_TRACE_WRITES)|libc.Int32FromInt32(TCL_TRACE_UNSETS), __ccgo_fp(_LinkTraceProc), linkPtr)
	if code != TCL_OK {
		_objPtr1 = (*TLink)(unsafe.Pointer(linkPtr)).FvarName
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		_LinkFree(tls, linkPtr)
	}
	return code
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LinkArray --
 *
 *	Link a C variable array to a Tcl variable so that changes to either
 *	one causes the other to change.
 *
 * Results:
 *	The return value is TCL_OK if everything went well or TCL_ERROR if an
 *	error occurred (the interp's result is also set after errors).
 *
 * Side effects:
 *	The value at *addr is linked to the Tcl variable "varName", using
 *	"type" to convert between string values for Tcl and binary values for
 *	*addr.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LinkArray(tls *libc.TLS, interp uintptr, varName uintptr, addr uintptr, type1 int32, size TTcl_Size) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Size of C variable array, >1 if array */
	var _objPtr, _objPtr1, linkPtr, objPtr, v2, v4 uintptr
	var code int32
	var v1, v3 TTcl_Size
	var _ /* dummy at bp+0 */ uintptr
	var _ /* name at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, code, linkPtr, objPtr, v1, v2, v3, v4
	if size < int64(1) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+50117, int64(-int32(1))))
		return int32(TCL_ERROR)
	}
	linkPtr = XTcl_Alloc(tls, uint64(72))
	(*TLink)(unsafe.Pointer(linkPtr)).Ftype1 = type1 & ^libc.Int32FromInt32(TCL_LINK_READ_ONLY)
	(*TLink)(unsafe.Pointer(linkPtr)).FnumElems = size
	if type1&int32(TCL_LINK_READ_ONLY) != 0 {
		(*TLink)(unsafe.Pointer(linkPtr)).Fflags = int32(LINK_READ_ONLY)
	} else {
		(*TLink)(unsafe.Pointer(linkPtr)).Fflags = 0
	}
	switch (*TLink)(unsafe.Pointer(linkPtr)).Ftype1 {
	case int32(TCL_LINK_INT):
		fallthrough
	case int32(TCL_LINK_BOOLEAN):
		(*TLink)(unsafe.Pointer(linkPtr)).Fbytes = libc.Int64FromUint64(libc.Uint64FromInt64(size) * uint64(4))
	case int32(TCL_LINK_DOUBLE):
		(*TLink)(unsafe.Pointer(linkPtr)).Fbytes = libc.Int64FromUint64(libc.Uint64FromInt64(size) * uint64(8))
	case int32(TCL_LINK_WIDE_INT):
		(*TLink)(unsafe.Pointer(linkPtr)).Fbytes = libc.Int64FromUint64(libc.Uint64FromInt64(size) * uint64(8))
	case int32(TCL_LINK_WIDE_UINT):
		(*TLink)(unsafe.Pointer(linkPtr)).Fbytes = libc.Int64FromUint64(libc.Uint64FromInt64(size) * uint64(8))
	case int32(TCL_LINK_CHAR):
		(*TLink)(unsafe.Pointer(linkPtr)).Fbytes = libc.Int64FromUint64(libc.Uint64FromInt64(size) * uint64(1))
	case int32(TCL_LINK_UCHAR):
		(*TLink)(unsafe.Pointer(linkPtr)).Fbytes = libc.Int64FromUint64(libc.Uint64FromInt64(size) * uint64(1))
	case int32(TCL_LINK_SHORT):
		(*TLink)(unsafe.Pointer(linkPtr)).Fbytes = libc.Int64FromUint64(libc.Uint64FromInt64(size) * uint64(2))
	case int32(TCL_LINK_USHORT):
		(*TLink)(unsafe.Pointer(linkPtr)).Fbytes = libc.Int64FromUint64(libc.Uint64FromInt64(size) * uint64(2))
	case int32(TCL_LINK_UINT):
		(*TLink)(unsafe.Pointer(linkPtr)).Fbytes = libc.Int64FromUint64(libc.Uint64FromInt64(size) * uint64(4))
	case int32(TCL_LINK_FLOAT):
		(*TLink)(unsafe.Pointer(linkPtr)).Fbytes = libc.Int64FromUint64(libc.Uint64FromInt64(size) * uint64(4))
	case int32(TCL_LINK_STRING):
		(*TLink)(unsafe.Pointer(linkPtr)).Fbytes = libc.Int64FromUint64(libc.Uint64FromInt64(size) * uint64(1))
		size = int64(1) /* This is a variable length string, no need
		 * to check last value. */
		/*
		 * If no address is given create one and use as address the
		 * not needed linkPtr->lastValue
		 */
		if addr == libc.UintptrFromInt32(0) {
			*(*uintptr)(unsafe.Pointer(linkPtr + 56)) = XTcl_Alloc(tls, libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).Fbytes))
			*(*int32)(unsafe.Pointer(linkPtr + 64)) |= int32(LINK_ALLOC_LAST)
			addr = linkPtr + 56
		}
	case int32(TCL_LINK_CHARS):
		fallthrough
	case int32(TCL_LINK_BINARY):
		(*TLink)(unsafe.Pointer(linkPtr)).Fbytes = libc.Int64FromUint64(libc.Uint64FromInt64(size) * uint64(1))
	default:
		_LinkFree(tls, linkPtr)
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+50140, int64(-int32(1))))
		return int32(TCL_ERROR)
	}
	/*
	 * Allocate C variable space in case no address is given
	 */
	if addr == libc.UintptrFromInt32(0) {
		(*TLink)(unsafe.Pointer(linkPtr)).Faddr = XTcl_Alloc(tls, libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).Fbytes))
		*(*int32)(unsafe.Pointer(linkPtr + 64)) |= int32(LINK_ALLOC_ADDR)
	} else {
		(*TLink)(unsafe.Pointer(linkPtr)).Faddr = addr
	}
	/*
	 * If necessary create space for last used value.
	 */
	if size > int64(1) {
		*(*uintptr)(unsafe.Pointer(linkPtr + 56)) = XTcl_Alloc(tls, libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).Fbytes))
		*(*int32)(unsafe.Pointer(linkPtr + 64)) |= int32(LINK_ALLOC_LAST)
	}
	/*
	 * Initialize allocated space.
	 */
	if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_ADDR) != 0 {
		libc.Xmemset(tls, (*TLink)(unsafe.Pointer(linkPtr)).Faddr, 0, libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).Fbytes))
	}
	if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
		libc.Xmemset(tls, *(*uintptr)(unsafe.Pointer(linkPtr + 56)), 0, libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).Fbytes))
	}
	/*
	 * Set common structure values.
	 */
	(*TLink)(unsafe.Pointer(linkPtr)).Finterp = interp
	(*TLink)(unsafe.Pointer(linkPtr)).FvarName = XTcl_NewStringObj(tls, varName, int64(-int32(1)))
	(*TTcl_Obj)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).FvarName)).FrefCount++
	XTclGetNamespaceForQualName(tls, interp, varName, libc.UintptrFromInt32(0), int32(TCL_GLOBAL_ONLY), linkPtr+8, bp, bp, bp+8)
	(*TNamespace)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).FnsPtr)).FrefCount++
	objPtr = _ObjValue(tls, linkPtr)
	if XTcl_ObjSetVar2(tls, interp, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0), objPtr, libc.Int32FromInt32(TCL_GLOBAL_ONLY)|libc.Int32FromInt32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
		_objPtr = (*TLink)(unsafe.Pointer(linkPtr)).FvarName
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		_LinkFree(tls, linkPtr)
		return int32(TCL_ERROR)
	}
	code = XTcl_TraceVar2(tls, interp, varName, libc.UintptrFromInt32(0), libc.Int32FromInt32(TCL_GLOBAL_ONLY)|libc.Int32FromInt32(TCL_TRACE_READS)|libc.Int32FromInt32(TCL_TRACE_WRITES)|libc.Int32FromInt32(TCL_TRACE_UNSETS), __ccgo_fp(_LinkTraceProc), linkPtr)
	if code != TCL_OK {
		_objPtr1 = (*TLink)(unsafe.Pointer(linkPtr)).FvarName
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		_LinkFree(tls, linkPtr)
	}
	return code
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UnlinkVar --
 *
 *	Destroy the link between a Tcl variable and a C variable.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	If "varName" was previously linked to a C variable, the link is broken
 *	to make the variable independent. If there was no previous link for
 *	"varName" then nothing happens.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UnlinkVar(tls *libc.TLS, interp uintptr, varName uintptr) {
	/* Global variable in interp to unlink. */
	var _objPtr, linkPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _ = _objPtr, linkPtr, v1, v2
	linkPtr = XTcl_VarTraceInfo2(tls, interp, varName, libc.UintptrFromInt32(0), int32(TCL_GLOBAL_ONLY), __ccgo_fp(_LinkTraceProc), libc.UintptrFromInt32(0))
	if linkPtr == libc.UintptrFromInt32(0) {
		return
	}
	XTcl_UntraceVar2(tls, interp, varName, libc.UintptrFromInt32(0), libc.Int32FromInt32(TCL_GLOBAL_ONLY)|libc.Int32FromInt32(TCL_TRACE_READS)|libc.Int32FromInt32(TCL_TRACE_WRITES)|libc.Int32FromInt32(TCL_TRACE_UNSETS), __ccgo_fp(_LinkTraceProc), linkPtr)
	_objPtr = (*TLink)(unsafe.Pointer(linkPtr)).FvarName
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	_LinkFree(tls, linkPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UpdateLinkedVar --
 *
 *	This function is invoked after a linked variable has been changed by C
 *	code. It updates the Tcl variable so that traces on the variable will
 *	trigger.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The Tcl variable "varName" is updated from its C value, causing traces
 *	on the variable to trigger.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UpdateLinkedVar(tls *libc.TLS, interp uintptr, varName uintptr) {
	/* Name of global variable that is linked. */
	var linkPtr uintptr
	var savedFlag int32
	_, _ = linkPtr, savedFlag
	linkPtr = XTcl_VarTraceInfo2(tls, interp, varName, libc.UintptrFromInt32(0), int32(TCL_GLOBAL_ONLY), __ccgo_fp(_LinkTraceProc), libc.UintptrFromInt32(0))
	if linkPtr == libc.UintptrFromInt32(0) {
		return
	}
	savedFlag = (*TLink)(unsafe.Pointer(linkPtr)).Fflags & int32(LINK_BEING_UPDATED)
	*(*int32)(unsafe.Pointer(linkPtr + 64)) |= int32(LINK_BEING_UPDATED)
	XTcl_ObjSetVar2(tls, interp, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0), _ObjValue(tls, linkPtr), int32(TCL_GLOBAL_ONLY))
	/*
	 * Callback may have unlinked the variable. [Bug 1740631]
	 */
	linkPtr = XTcl_VarTraceInfo2(tls, interp, varName, libc.UintptrFromInt32(0), int32(TCL_GLOBAL_ONLY), __ccgo_fp(_LinkTraceProc), libc.UintptrFromInt32(0))
	if linkPtr != libc.UintptrFromInt32(0) {
		(*TLink)(unsafe.Pointer(linkPtr)).Fflags = (*TLink)(unsafe.Pointer(linkPtr)).Fflags & ^libc.Int32FromInt32(LINK_BEING_UPDATED) | savedFlag
	}
}

/*
 *----------------------------------------------------------------------
 *
 * GetInt, GetWide, GetUWide, GetDouble, EqualDouble, IsSpecial --
 *
 *	Helper functions for LinkTraceProc and ObjValue. These are all
 *	factored out here to make those functions simpler.
 *
 *----------------------------------------------------------------------
 */

func _GetInt(tls *libc.TLS, objPtr uintptr, intPtr uintptr) (r int32) {
	return libc.BoolInt32(XTcl_GetIntFromObj(tls, libc.UintptrFromInt32(0), objPtr, intPtr) != TCL_OK && _GetInvalidIntFromObj(tls, objPtr, intPtr) != TCL_OK)
}

func _GetWide(tls *libc.TLS, objPtr uintptr, widePtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var v1 int32
	var _ /* intValue at bp+0 */ int32
	_ = v1
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*TTcl_WideInt)(unsafe.Pointer(widePtr)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep))
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_GetWideIntFromObj(tls, libc.UintptrFromInt32(0), objPtr, widePtr)
	}
	if v1 != TCL_OK {
		if _GetInvalidIntFromObj(tls, objPtr, bp) != TCL_OK {
			return int32(1)
		}
		*(*TTcl_WideInt)(unsafe.Pointer(widePtr)) = int64(*(*int32)(unsafe.Pointer(bp)))
	}
	return 0
}

func _GetUWide(tls *libc.TLS, objPtr uintptr, uwidePtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _ /* intValue at bp+0 */ int32
	if XTcl_GetWideUIntFromObj(tls, libc.UintptrFromInt32(0), objPtr, uwidePtr) != TCL_OK {
		if _GetInvalidIntFromObj(tls, objPtr, bp) != TCL_OK {
			return int32(1)
		}
		*(*TTcl_WideUInt)(unsafe.Pointer(uwidePtr)) = libc.Uint64FromInt32(*(*int32)(unsafe.Pointer(bp)))
	}
	return 0
}

func _GetDouble(tls *libc.TLS, objPtr uintptr, dblPtr uintptr) (r int32) {
	if XTcl_GetDoubleFromObj(tls, libc.UintptrFromInt32(0), objPtr, dblPtr) == TCL_OK {
		return 0
	} else {
		return libc.BoolInt32(_GetInvalidDoubleFromObj(tls, objPtr, dblPtr) != TCL_OK)
	}
	return r
}

func _EqualDouble(tls *libc.TLS, a float64, b float64) (r int32) {
	return libc.BoolInt32(a == b)
}

func _IsSpecial(tls *libc.TLS, a float64) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var v1 uint64
	var _ /* __u at bp+0 */ struct {
		F__i [0]uint64
		F__f float64
	}
	_ = v1
	*(*float64)(unsafe.Pointer(bp)) = a
	v1 = *(*uint64)(unsafe.Pointer(bp))
	goto _2
_2:
	return libc.BoolInt32(v1&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) == libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52))
}

/*
 * Mark an object as holding a weird double.
 */

func _SetInvalidRealFromAny(tls *libc.TLS, dummy566 uintptr, objPtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var str, v1 uintptr
	var _ /* doubleValue at bp+16 */ float64
	var _ /* endPtr at bp+0 */ uintptr
	var _ /* length at bp+8 */ TTcl_Size
	_, _ = str, v1
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, objPtr, bp+8)
	}
	str = v1
	if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) == int32('.') {
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = uintptr(unsafe.Pointer(&_invalidRealType))
		*(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) = float64(0)
		return TCL_OK
	}
	if XTclParseNumber(tls, libc.UintptrFromInt32(0), objPtr, libc.UintptrFromInt32(0), str, *(*TTcl_Size)(unsafe.Pointer(bp + 8)), bp, int32(TCL_PARSE_DECIMAL_ONLY)) == TCL_OK {
		/*
		 * If number is followed by [eE][+-]?, then it is an invalid
		 * double, but it could be the start of a valid double.
		 */
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('e') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('E') {
			*(*uintptr)(unsafe.Pointer(bp))++
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('+') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('-') {
				*(*uintptr)(unsafe.Pointer(bp))++
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == 0 {
				*(*float64)(unsafe.Pointer(bp + 16)) = float64(0)
				XTcl_GetDoubleFromObj(tls, libc.UintptrFromInt32(0), objPtr, bp+16)
				if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != libc.UintptrFromInt32(0) {
					if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
						(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc})))(tls, objPtr)
					}
					(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
				}
				(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = uintptr(unsafe.Pointer(&_invalidRealType))
				*(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) = *(*float64)(unsafe.Pointer(bp + 16))
				return TCL_OK
			}
		}
	}
	return int32(TCL_ERROR)
}

/*
 * This function checks for integer representations, which are valid
 * when linking with C variables, but which are invalid in other
 * contexts in Tcl. Handled are "+", "-", "", "0x", "0b", "0d" and "0o"
 * (upperand lowercase). See bug [39f6304c2e].
 */

func _GetInvalidIntFromObj(tls *libc.TLS, objPtr uintptr, intPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var str, v1 uintptr
	var _ /* length at bp+0 */ TTcl_Size
	_, _ = str, v1
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, objPtr, bp)
	}
	str = v1
	if *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 || *(*TTcl_Size)(unsafe.Pointer(bp)) == int64(2) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) == int32('0') && libc.Xstrchr(tls, __ccgo_ts+50171, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str + 1)))) != 0 {
		*(*int32)(unsafe.Pointer(intPtr)) = 0
		return TCL_OK
	} else {
		if *(*TTcl_Size)(unsafe.Pointer(bp)) == int64(1) && libc.Xstrchr(tls, __ccgo_ts+50180, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str)))) != 0 {
			*(*int32)(unsafe.Pointer(intPtr)) = libc.BoolInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) == int32('+'))
			return TCL_OK
		}
	}
	return int32(TCL_ERROR)
}

/*
 * This function checks for double representations, which are valid
 * when linking with C variables, but which are invalid in other
 * contexts in Tcl. Handled are "+", "-", "", ".", "0x", "0b" and "0o"
 * (upper- and lowercase) and sequences like "1e-". See bug [39f6304c2e].
 */

func _GetInvalidDoubleFromObj(tls *libc.TLS, objPtr uintptr, doublePtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _ /* intValue at bp+0 */ int32
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_invalidRealType)) {
		goto gotdouble
	}
	if _GetInvalidIntFromObj(tls, objPtr, bp) == TCL_OK {
		*(*float64)(unsafe.Pointer(doublePtr)) = float64(*(*int32)(unsafe.Pointer(bp)))
		return TCL_OK
	}
	if !(_SetInvalidRealFromAny(tls, libc.UintptrFromInt32(0), objPtr) == TCL_OK) {
		goto _1
	}
	goto gotdouble
gotdouble:
	;
	*(*float64)(unsafe.Pointer(doublePtr)) = *(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep))
	return TCL_OK
_1:
	;
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * LinkTraceProc --
 *
 *	This function is invoked when a linked Tcl variable is read, written,
 *	or unset from Tcl. It's responsible for keeping the C variable in sync
 *	with the Tcl variable.
 *
 * Results:
 *	If all goes well, NULL is returned; otherwise an error message is
 *	returned.
 *
 * Side effects:
 *	The C variable may be updated to make it consistent with the Tcl
 *	variable, or the Tcl variable may be overwritten to reject a
 *	modification.
 *
 *----------------------------------------------------------------------
 */

func _LinkTraceProc(tls *libc.TLS, clientData uintptr, interp uintptr, dummy685 uintptr, dummy686 uintptr, flags int32) (r uintptr) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Miscellaneous additional information. */
	var _objPtr, linkPtr, pp, value, valueObj, varPtr, varPtr1, varPtr2, varPtr3, varPtr4, varPtr5, varPtr6, v2, v3, v4, v6 uintptr
	var changed, v7 int32
	var i, v1, v5 TTcl_Size
	var v15, v17 uint8
	var v19 int16
	var v21 uint16
	var v23 uint32
	var v25 TTcl_WideUInt
	var v27 float32
	var v8, v9 int64
	var _ /* objc at bp+40 */ TTcl_Size
	var _ /* objv at bp+48 */ uintptr
	var _ /* valueDouble at bp+32 */ float64
	var _ /* valueInt at bp+8 */ int32
	var _ /* valueLength at bp+0 */ TTcl_Size
	var _ /* valueUWide at bp+24 */ TTcl_WideUInt
	var _ /* valueWide at bp+16 */ TTcl_WideInt
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, changed, i, linkPtr, pp, value, valueObj, varPtr, varPtr1, varPtr2, varPtr3, varPtr4, varPtr5, varPtr6, v1, v15, v17, v19, v2, v21, v23, v25, v27, v3, v4, v5, v6, v7, v8, v9
	linkPtr = clientData
	*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	/*
	 * If the variable is being unset, then just re-create it (with a trace)
	 * unless the whole interpreter is going away.
	 */
	if flags&int32(TCL_TRACE_UNSETS) != 0 {
		if XTcl_InterpDeleted(tls, interp) != 0 || XTclNamespaceDeleted(tls, (*TLink)(unsafe.Pointer(linkPtr)).FnsPtr) != 0 {
			_objPtr = (*TLink)(unsafe.Pointer(linkPtr)).FvarName
			v2 = _objPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if v1 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			_LinkFree(tls, linkPtr)
		} else {
			if flags&int32(TCL_TRACE_DESTROYED) != 0 {
				XTcl_ObjSetVar2(tls, interp, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0), _ObjValue(tls, linkPtr), int32(TCL_GLOBAL_ONLY))
				if (*TTcl_Obj)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).FvarName)).Fbytes != 0 {
					v3 = (*TTcl_Obj)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).FvarName)).Fbytes
				} else {
					v3 = XTcl_GetStringFromObj(tls, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0))
				}
				XTcl_TraceVar2(tls, interp, v3, libc.UintptrFromInt32(0), libc.Int32FromInt32(TCL_GLOBAL_ONLY)|libc.Int32FromInt32(TCL_TRACE_READS)|libc.Int32FromInt32(TCL_TRACE_WRITES)|libc.Int32FromInt32(TCL_TRACE_UNSETS), __ccgo_fp(_LinkTraceProc), linkPtr)
			}
		}
		return libc.UintptrFromInt32(0)
	}
	/*
	 * If we were invoked because of a call to Tcl_UpdateLinkedVar, then don't
	 * do anything at all. In particular, we don't want to get upset that the
	 * variable is being modified, even if it is supposed to be read-only.
	 */
	if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_BEING_UPDATED) != 0 {
		return libc.UintptrFromInt32(0)
	}
	/*
	 * For read accesses, update the Tcl variable if the C variable has
	 * changed since the last time we updated the Tcl variable.
	 */
	if flags&int32(TCL_TRACE_READS) != 0 {
		/*
		 * Variable arrays
		 */
		if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
			changed = libc.Xmemcmp(tls, (*TLink)(unsafe.Pointer(linkPtr)).Faddr, *(*uintptr)(unsafe.Pointer(linkPtr + 56)), libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).Fbytes))
		} else {
			/* single variables */
			switch (*TLink)(unsafe.Pointer(linkPtr)).Ftype1 {
			case int32(TCL_LINK_INT):
				fallthrough
			case int32(TCL_LINK_BOOLEAN):
				changed = libc.BoolInt32(*(*int32)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr)) != *(*int32)(unsafe.Pointer(&(*TLink)(unsafe.Pointer(linkPtr)).FlastValue)))
			case int32(TCL_LINK_DOUBLE):
				changed = libc.BoolInt32(!(_EqualDouble(tls, *(*float64)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr)), *(*float64)(unsafe.Pointer(linkPtr + 56))) != 0))
			case int32(TCL_LINK_WIDE_INT):
				changed = libc.BoolInt32(*(*TTcl_WideInt)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr)) != *(*TTcl_WideInt)(unsafe.Pointer(linkPtr + 56)))
			case int32(TCL_LINK_WIDE_UINT):
				changed = libc.BoolInt32(*(*TTcl_WideUInt)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr)) != *(*TTcl_WideUInt)(unsafe.Pointer(linkPtr + 56)))
			case int32(TCL_LINK_CHAR):
				changed = libc.BoolInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr))) != libc.Int32FromUint8((*TLink)(unsafe.Pointer(linkPtr)).FlastValue.Fc))
			case int32(TCL_LINK_UCHAR):
				changed = libc.BoolInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr))) != libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(&(*TLink)(unsafe.Pointer(linkPtr)).FlastValue))))
			case int32(TCL_LINK_SHORT):
				changed = libc.BoolInt32(int32(*(*int16)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr))) != int32(*(*int16)(unsafe.Pointer(&(*TLink)(unsafe.Pointer(linkPtr)).FlastValue))))
			case int32(TCL_LINK_USHORT):
				changed = libc.BoolInt32(libc.Int32FromUint16(*(*uint16)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr))) != libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(&(*TLink)(unsafe.Pointer(linkPtr)).FlastValue))))
			case int32(TCL_LINK_UINT):
				changed = libc.BoolInt32(*(*uint32)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr)) != *(*uint32)(unsafe.Pointer(&(*TLink)(unsafe.Pointer(linkPtr)).FlastValue)))
			case int32(TCL_LINK_FLOAT):
				changed = libc.BoolInt32(!(_EqualDouble(tls, float64(*(*float32)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr))), float64(*(*float32)(unsafe.Pointer(&(*TLink)(unsafe.Pointer(linkPtr)).FlastValue)))) != 0))
			case int32(TCL_LINK_STRING):
				fallthrough
			case int32(TCL_LINK_CHARS):
				fallthrough
			case int32(TCL_LINK_BINARY):
				changed = int32(1)
			default:
				changed = 0
				/* return (char *) "internal error: bad linked variable type"; */
			}
		}
		if changed != 0 {
			XTcl_ObjSetVar2(tls, interp, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0), _ObjValue(tls, linkPtr), int32(TCL_GLOBAL_ONLY))
		}
		return libc.UintptrFromInt32(0)
	}
	/*
	 * For writes, first make sure that the variable is writable. Then convert
	 * the Tcl value to C if possible. If the variable isn't writable or can't
	 * be converted, then restore the variable's old value and return an
	 * error. Another tricky thing: we have to save and restore the interp's
	 * result, since the variable access could occur when the result has been
	 * partially set.
	 */
	if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_READ_ONLY) != 0 {
		XTcl_ObjSetVar2(tls, interp, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0), _ObjValue(tls, linkPtr), int32(TCL_GLOBAL_ONLY))
		return __ccgo_ts + 50183
	}
	valueObj = XTcl_ObjGetVar2(tls, interp, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0), int32(TCL_GLOBAL_ONLY))
	if valueObj == libc.UintptrFromInt32(0) {
		/*
		 * This shouldn't ever happen.
		 */
		return __ccgo_ts + 50212
	}
	/*
	 * Special cases.
	 */
	switch (*TLink)(unsafe.Pointer(linkPtr)).Ftype1 {
	case int32(TCL_LINK_STRING):
		if (*TTcl_Obj)(unsafe.Pointer(valueObj)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(valueObj)).Flength
			v4 = (*TTcl_Obj)(unsafe.Pointer(valueObj)).Fbytes
		} else {
			v4 = XTcl_GetStringFromObj(tls, valueObj, bp)
		}
		value = v4
		pp = (*TLink)(unsafe.Pointer(linkPtr)).Faddr
		*(*TTcl_Size)(unsafe.Pointer(bp))++
		v5 = *(*TTcl_Size)(unsafe.Pointer(bp))
		*(*uintptr)(unsafe.Pointer(pp)) = XTcl_Realloc(tls, *(*uintptr)(unsafe.Pointer(pp)), libc.Uint64FromInt64(v5))
		libc.Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(pp)), value, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))))
		return libc.UintptrFromInt32(0)
	case int32(TCL_LINK_CHARS):
		if (*TTcl_Obj)(unsafe.Pointer(valueObj)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(valueObj)).Flength
			v6 = (*TTcl_Obj)(unsafe.Pointer(valueObj)).Fbytes
		} else {
			v6 = XTcl_GetStringFromObj(tls, valueObj, bp)
		}
		value = v6
		*(*TTcl_Size)(unsafe.Pointer(bp))++ /* include end of string char */
		if *(*TTcl_Size)(unsafe.Pointer(bp)) > (*TLink)(unsafe.Pointer(linkPtr)).Fbytes {
			return __ccgo_ts + 50261
		}
		if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
			libc.Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(linkPtr + 56)), value, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))))
			libc.Xmemcpy(tls, (*TLink)(unsafe.Pointer(linkPtr)).Faddr, value, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))))
		} else {
			(*TLink)(unsafe.Pointer(linkPtr)).FlastValue.Fc = uint8('\000')
			*(*uint8)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr)) = (*TLink)(unsafe.Pointer(linkPtr)).FlastValue.Fc
		}
		return libc.UintptrFromInt32(0)
	case int32(TCL_LINK_BINARY):
		value = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), valueObj, bp)
		if value == libc.UintptrFromInt32(0) {
			return __ccgo_ts + 50287
		} else {
			if *(*TTcl_Size)(unsafe.Pointer(bp)) != (*TLink)(unsafe.Pointer(linkPtr)).Fbytes {
				return __ccgo_ts + 50308
			}
		}
		if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
			libc.Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(linkPtr + 56)), value, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))))
			libc.Xmemcpy(tls, (*TLink)(unsafe.Pointer(linkPtr)).Faddr, value, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))))
		} else {
			*(*uint8)(unsafe.Pointer(&(*TLink)(unsafe.Pointer(linkPtr)).FlastValue)) = *(*uint8)(unsafe.Pointer(value))
			*(*uint8)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr)) = *(*uint8)(unsafe.Pointer(&(*TLink)(unsafe.Pointer(linkPtr)).FlastValue))
		}
		return libc.UintptrFromInt32(0)
	}
	/*
	 * A helper macro. Writing this as a function is messy because of type
	 * variance.
	 */
	/*
	 * If we're working with an array of numbers, extract the Tcl list.
	 */
	if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(valueObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(valueObj + 32))).Fptr2 != 0 {
				v8 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(valueObj + 32))).Fptr2)).FspanStart
			} else {
				v8 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(valueObj + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 48)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(valueObj + 32))).Fptr1 + 40 + uintptr(v8)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(valueObj + 32))).Fptr2 != 0 {
				v9 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(valueObj + 32))).Fptr2)).FspanLength
			} else {
				v9 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(valueObj + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = v9
			v7 = libc.Int32FromInt32(TCL_OK)
		} else {
			v7 = XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), valueObj, bp+40, bp+48)
		}
		if v7 == int32(TCL_ERROR) || *(*TTcl_Size)(unsafe.Pointer(bp + 40)) != (*TLink)(unsafe.Pointer(linkPtr)).FnumElems {
			return __ccgo_ts + 50335
		}
	}
	switch (*TLink)(unsafe.Pointer(linkPtr)).Ftype1 {
	case int32(TCL_LINK_INT):
		if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
			i = 0
			for {
				if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 40))) {
					break
				}
				varPtr = *(*uintptr)(unsafe.Pointer(linkPtr + 56)) + uintptr(i)*4
				if _GetInt(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + uintptr(i)*8)), varPtr) != 0 {
					XTcl_ObjSetVar2(tls, interp, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0), _ObjValue(tls, linkPtr), int32(TCL_GLOBAL_ONLY))
					return __ccgo_ts + 50351
				}
				goto _10
			_10:
				;
				i++
			}
		} else {
			varPtr1 = linkPtr + 56
			if _GetInt(tls, valueObj, varPtr1) != 0 {
				XTcl_ObjSetVar2(tls, interp, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0), _ObjValue(tls, linkPtr), int32(TCL_GLOBAL_ONLY))
				return __ccgo_ts + 50391
			}
			*(*int32)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr)) = *(*int32)(unsafe.Pointer(varPtr1))
		}
	case int32(TCL_LINK_WIDE_INT):
		if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
			i = 0
			for {
				if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 40))) {
					break
				}
				varPtr2 = *(*uintptr)(unsafe.Pointer(linkPtr + 56)) + uintptr(i)*8
				if _GetWide(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + uintptr(i)*8)), varPtr2) != 0 {
					XTcl_ObjSetVar2(tls, interp, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0), _ObjValue(tls, linkPtr), int32(TCL_GLOBAL_ONLY))
					return __ccgo_ts + 50424
				}
				goto _11
			_11:
				;
				i++
			}
		} else {
			varPtr3 = linkPtr + 56
			if _GetWide(tls, valueObj, varPtr3) != 0 {
				XTcl_ObjSetVar2(tls, interp, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0), _ObjValue(tls, linkPtr), int32(TCL_GLOBAL_ONLY))
				return __ccgo_ts + 50468
			}
			*(*TTcl_WideInt)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr)) = *(*TTcl_WideInt)(unsafe.Pointer(varPtr3))
		}
	case int32(TCL_LINK_DOUBLE):
		if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
			i = 0
			for {
				if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 40))) {
					break
				}
				if _GetDouble(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + uintptr(i)*8)), *(*uintptr)(unsafe.Pointer(linkPtr + 56))+uintptr(i)*8) != 0 {
					XTcl_ObjSetVar2(tls, interp, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0), _ObjValue(tls, linkPtr), int32(TCL_GLOBAL_ONLY))
					return __ccgo_ts + 50506
				}
				goto _12
			_12:
				;
				i++
			}
		} else {
			varPtr4 = linkPtr + 56
			if _GetDouble(tls, valueObj, varPtr4) != 0 {
				XTcl_ObjSetVar2(tls, interp, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0), _ObjValue(tls, linkPtr), int32(TCL_GLOBAL_ONLY))
				return __ccgo_ts + 50542
			}
			*(*float64)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr)) = *(*float64)(unsafe.Pointer(varPtr4))
		}
	case int32(TCL_LINK_BOOLEAN):
		if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
			i = 0
			for {
				if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 40))) {
					break
				}
				varPtr5 = *(*uintptr)(unsafe.Pointer(linkPtr + 56)) + uintptr(i)*4
				if XTcl_GetBoolFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + uintptr(i)*8)), (libc.Int32FromInt32(TCL_NULL_OK)-libc.Int32FromInt32(2))&libc.Int32FromInt64(4), varPtr5) != TCL_OK {
					XTcl_ObjSetVar2(tls, interp, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0), _ObjValue(tls, linkPtr), int32(TCL_GLOBAL_ONLY))
					return __ccgo_ts + 50572
				}
				goto _13
			_13:
				;
				i++
			}
		} else {
			varPtr6 = linkPtr + 56
			if XTcl_GetBoolFromObj(tls, libc.UintptrFromInt32(0), valueObj, (libc.Int32FromInt32(TCL_NULL_OK)-libc.Int32FromInt32(2))&libc.Int32FromInt64(4), varPtr6) != TCL_OK {
				XTcl_ObjSetVar2(tls, interp, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0), _ObjValue(tls, linkPtr), int32(TCL_GLOBAL_ONLY))
				return __ccgo_ts + 50611
			}
			*(*int32)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr)) = *(*int32)(unsafe.Pointer(varPtr6))
		}
	case int32(TCL_LINK_CHAR):
		if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
			i = 0
			for {
				if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 40))) {
					break
				}
				if _GetInt(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + uintptr(i)*8)), bp+8) != 0 || !(*(*int32)(unsafe.Pointer(bp + 8)) >= -int32(128) && *(*int32)(unsafe.Pointer(bp + 8)) <= int32(SCHAR_MAX)) {
					XTcl_ObjSetVar2(tls, interp, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0), _ObjValue(tls, linkPtr), int32(TCL_GLOBAL_ONLY))
					return __ccgo_ts + 50644
				}
				*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(linkPtr + 56)) + uintptr(i))) = libc.Uint8FromInt32(*(*int32)(unsafe.Pointer(bp + 8)))
				goto _14
			_14:
				;
				i++
			}
		} else {
			if _GetInt(tls, valueObj, bp+8) != 0 || !(*(*int32)(unsafe.Pointer(bp + 8)) >= -int32(128) && *(*int32)(unsafe.Pointer(bp + 8)) <= int32(SCHAR_MAX)) {
				XTcl_ObjSetVar2(tls, interp, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0), _ObjValue(tls, linkPtr), int32(TCL_GLOBAL_ONLY))
				return __ccgo_ts + 50680
			}
			v15 = libc.Uint8FromInt32(*(*int32)(unsafe.Pointer(bp + 8)))
			(*TLink)(unsafe.Pointer(linkPtr)).FlastValue.Fc = v15
			*(*uint8)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr)) = v15
		}
	case int32(TCL_LINK_UCHAR):
		if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
			i = 0
			for {
				if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 40))) {
					break
				}
				if _GetInt(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + uintptr(i)*8)), bp+8) != 0 || !(*(*int32)(unsafe.Pointer(bp + 8)) >= 0 && *(*int32)(unsafe.Pointer(bp + 8)) <= libc.Int32FromInt32(UCHAR_MAX)) {
					XTcl_ObjSetVar2(tls, interp, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0), _ObjValue(tls, linkPtr), int32(TCL_GLOBAL_ONLY))
					return __ccgo_ts + 50710
				}
				*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(linkPtr + 56)) + uintptr(i))) = libc.Uint8FromInt32(*(*int32)(unsafe.Pointer(bp + 8)))
				goto _16
			_16:
				;
				i++
			}
		} else {
			if _GetInt(tls, valueObj, bp+8) != 0 || !(*(*int32)(unsafe.Pointer(bp + 8)) >= 0 && *(*int32)(unsafe.Pointer(bp + 8)) <= libc.Int32FromInt32(UCHAR_MAX)) {
				XTcl_ObjSetVar2(tls, interp, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0), _ObjValue(tls, linkPtr), int32(TCL_GLOBAL_ONLY))
				return __ccgo_ts + 50755
			}
			v17 = libc.Uint8FromInt32(*(*int32)(unsafe.Pointer(bp + 8)))
			*(*uint8)(unsafe.Pointer(&(*TLink)(unsafe.Pointer(linkPtr)).FlastValue)) = v17
			*(*uint8)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr)) = v17
		}
	case int32(TCL_LINK_SHORT):
		if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
			i = 0
			for {
				if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 40))) {
					break
				}
				if _GetInt(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + uintptr(i)*8)), bp+8) != 0 || !(*(*int32)(unsafe.Pointer(bp + 8)) >= -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fff) && *(*int32)(unsafe.Pointer(bp + 8)) <= int32(SHRT_MAX)) {
					XTcl_ObjSetVar2(tls, interp, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0), _ObjValue(tls, linkPtr), int32(TCL_GLOBAL_ONLY))
					return __ccgo_ts + 50794
				}
				*(*int16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(linkPtr + 56)) + uintptr(i)*2)) = int16(*(*int32)(unsafe.Pointer(bp + 8)))
				goto _18
			_18:
				;
				i++
			}
		} else {
			if _GetInt(tls, valueObj, bp+8) != 0 || !(*(*int32)(unsafe.Pointer(bp + 8)) >= -libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fff) && *(*int32)(unsafe.Pointer(bp + 8)) <= int32(SHRT_MAX)) {
				XTcl_ObjSetVar2(tls, interp, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0), _ObjValue(tls, linkPtr), int32(TCL_GLOBAL_ONLY))
				return __ccgo_ts + 50831
			}
			v19 = int16(*(*int32)(unsafe.Pointer(bp + 8)))
			*(*int16)(unsafe.Pointer(&(*TLink)(unsafe.Pointer(linkPtr)).FlastValue)) = v19
			*(*int16)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr)) = v19
		}
	case int32(TCL_LINK_USHORT):
		if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
			i = 0
			for {
				if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 40))) {
					break
				}
				if _GetInt(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + uintptr(i)*8)), bp+8) != 0 || !(*(*int32)(unsafe.Pointer(bp + 8)) >= 0 && *(*int32)(unsafe.Pointer(bp + 8)) <= libc.Int32FromInt32(USHRT_MAX)) {
					XTcl_ObjSetVar2(tls, interp, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0), _ObjValue(tls, linkPtr), int32(TCL_GLOBAL_ONLY))
					return __ccgo_ts + 50862
				}
				*(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(linkPtr + 56)) + uintptr(i)*2)) = libc.Uint16FromInt32(*(*int32)(unsafe.Pointer(bp + 8)))
				goto _20
			_20:
				;
				i++
			}
		} else {
			if _GetInt(tls, valueObj, bp+8) != 0 || !(*(*int32)(unsafe.Pointer(bp + 8)) >= 0 && *(*int32)(unsafe.Pointer(bp + 8)) <= libc.Int32FromInt32(USHRT_MAX)) {
				XTcl_ObjSetVar2(tls, interp, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0), _ObjValue(tls, linkPtr), int32(TCL_GLOBAL_ONLY))
				return __ccgo_ts + 50908
			}
			v21 = libc.Uint16FromInt32(*(*int32)(unsafe.Pointer(bp + 8)))
			*(*uint16)(unsafe.Pointer(&(*TLink)(unsafe.Pointer(linkPtr)).FlastValue)) = v21
			*(*uint16)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr)) = v21
		}
	case int32(TCL_LINK_UINT):
		if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
			i = 0
			for {
				if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 40))) {
					break
				}
				if _GetWide(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + uintptr(i)*8)), bp+16) != 0 || !(*(*TTcl_WideInt)(unsafe.Pointer(bp + 16)) >= int64(libc.Int32FromInt32(0)) && *(*TTcl_WideInt)(unsafe.Pointer(bp + 16)) <= libc.Int64FromUint32(0xffffffff)) {
					XTcl_ObjSetVar2(tls, interp, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0), _ObjValue(tls, linkPtr), int32(TCL_GLOBAL_ONLY))
					return __ccgo_ts + 50948
				}
				*(*uint32)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(linkPtr + 56)) + uintptr(i)*4)) = libc.Uint32FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 16)))
				goto _22
			_22:
				;
				i++
			}
		} else {
			if _GetWide(tls, valueObj, bp+16) != 0 || !(*(*TTcl_WideInt)(unsafe.Pointer(bp + 16)) >= int64(libc.Int32FromInt32(0)) && *(*TTcl_WideInt)(unsafe.Pointer(bp + 16)) <= libc.Int64FromUint32(0xffffffff)) {
				XTcl_ObjSetVar2(tls, interp, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0), _ObjValue(tls, linkPtr), int32(TCL_GLOBAL_ONLY))
				return __ccgo_ts + 50992
			}
			v23 = libc.Uint32FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 16)))
			*(*uint32)(unsafe.Pointer(&(*TLink)(unsafe.Pointer(linkPtr)).FlastValue)) = v23
			*(*uint32)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr)) = v23
		}
	case int32(TCL_LINK_WIDE_UINT):
		if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
			i = 0
			for {
				if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 40))) {
					break
				}
				if _GetUWide(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + uintptr(i)*8)), bp+24) != 0 {
					XTcl_ObjSetVar2(tls, interp, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0), _ObjValue(tls, linkPtr), int32(TCL_GLOBAL_ONLY))
					return __ccgo_ts + 51030
				}
				*(*TTcl_WideUInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(linkPtr + 56)) + uintptr(i)*8)) = *(*TTcl_WideUInt)(unsafe.Pointer(bp + 24))
				goto _24
			_24:
				;
				i++
			}
		} else {
			if _GetUWide(tls, valueObj, bp+24) != 0 {
				XTcl_ObjSetVar2(tls, interp, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0), _ObjValue(tls, linkPtr), int32(TCL_GLOBAL_ONLY))
				return __ccgo_ts + 51079
			}
			v25 = *(*TTcl_WideUInt)(unsafe.Pointer(bp + 24))
			*(*TTcl_WideUInt)(unsafe.Pointer(linkPtr + 56)) = v25
			*(*TTcl_WideUInt)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr)) = v25
		}
	case int32(TCL_LINK_FLOAT):
		if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
			i = 0
			for {
				if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 40))) {
					break
				}
				if _GetDouble(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + uintptr(i)*8)), bp+32) != 0 && !(libc.Xfabs(tls, *(*float64)(unsafe.Pointer(bp + 32))) >= float64(libc.Float32FromFloat32(1.1754943508222875e-38)) && libc.Xfabs(tls, *(*float64)(unsafe.Pointer(bp + 32))) <= float64(libc.Float32FromFloat32(3.4028234663852886e+38))) && !(_IsSpecial(tls, *(*float64)(unsafe.Pointer(bp + 32))) != 0) {
					XTcl_ObjSetVar2(tls, interp, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0), _ObjValue(tls, linkPtr), int32(TCL_GLOBAL_ONLY))
					return __ccgo_ts + 51122
				}
				*(*float32)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(linkPtr + 56)) + uintptr(i)*4)) = float32(*(*float64)(unsafe.Pointer(bp + 32)))
				goto _26
			_26:
				;
				i++
			}
		} else {
			if _GetDouble(tls, valueObj, bp+32) != 0 && !(libc.Xfabs(tls, *(*float64)(unsafe.Pointer(bp + 32))) >= float64(libc.Float32FromFloat32(1.1754943508222875e-38)) && libc.Xfabs(tls, *(*float64)(unsafe.Pointer(bp + 32))) <= float64(libc.Float32FromFloat32(3.4028234663852886e+38))) && !(_IsSpecial(tls, *(*float64)(unsafe.Pointer(bp + 32))) != 0) {
				XTcl_ObjSetVar2(tls, interp, (*TLink)(unsafe.Pointer(linkPtr)).FvarName, libc.UintptrFromInt32(0), _ObjValue(tls, linkPtr), int32(TCL_GLOBAL_ONLY))
				return __ccgo_ts + 51159
			}
			v27 = float32(*(*float64)(unsafe.Pointer(bp + 32)))
			*(*float32)(unsafe.Pointer(&(*TLink)(unsafe.Pointer(linkPtr)).FlastValue)) = v27
			*(*float32)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr)) = v27
		}
	default:
		return __ccgo_ts + 51190
	}
	if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
		libc.Xmemcpy(tls, (*TLink)(unsafe.Pointer(linkPtr)).Faddr, *(*uintptr)(unsafe.Pointer(linkPtr + 56)), libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).Fbytes))
	}
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * ObjValue --
 *
 *	Converts the value of a C variable to a Tcl_Obj* for use in a Tcl
 *	variable to which it is linked.
 *
 * Results:
 *	The return value is a pointer to a Tcl_Obj that represents the value
 *	of the C variable given by linkPtr.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _ObjValue(tls *libc.TLS, linkPtr uintptr) (r uintptr) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Structure describing linked variable. */
	var cachePtr, cachePtr1, cachePtr10, cachePtr11, cachePtr12, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cachePtr8, cachePtr9, objv, p, resultObj, uwObj uintptr
	var i TTcl_Size
	var uw_, uw_1 TTcl_WideUInt
	var v18, v20, v22, v25, v27, v29, v31, v33, v35, v37, v38, v39, v43 bool
	var _ /* bignumValue_ at bp+0 */ Tmp_int
	var _ /* bignumValue_ at bp+24 */ Tmp_int
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr10, cachePtr11, cachePtr12, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cachePtr8, cachePtr9, i, objv, p, resultObj, uwObj, uw_, uw_1, v18, v20, v22, v25, v27, v29, v31, v33, v35, v37, v38, v39, v43
	switch (*TLink)(unsafe.Pointer(linkPtr)).Ftype1 {
	case int32(TCL_LINK_INT):
		goto _1
	case int32(TCL_LINK_WIDE_INT):
		goto _2
	case int32(TCL_LINK_DOUBLE):
		goto _3
	case int32(TCL_LINK_BOOLEAN):
		goto _4
	case int32(TCL_LINK_CHAR):
		goto _5
	case int32(TCL_LINK_UCHAR):
		goto _6
	case int32(TCL_LINK_SHORT):
		goto _7
	case int32(TCL_LINK_USHORT):
		goto _8
	case int32(TCL_LINK_UINT):
		goto _9
	case int32(TCL_LINK_FLOAT):
		goto _10
	case int32(TCL_LINK_WIDE_UINT):
		goto _11
	case int32(TCL_LINK_STRING):
		goto _12
	case int32(TCL_LINK_CHARS):
		goto _13
	case int32(TCL_LINK_BINARY):
		goto _14
	default:
		goto _15
	}
	goto _16
_1:
	;
	if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
		libc.Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(linkPtr + 56)), (*TLink)(unsafe.Pointer(linkPtr)).Faddr, libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).Fbytes))
		objv = XTcl_Alloc(tls, libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).FnumElems)*uint64(8))
		i = 0
		for {
			if !(i < (*TLink)(unsafe.Pointer(linkPtr)).FnumElems) {
				break
			}
			if v18 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v18 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v18 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) = XTclThreadAllocObj(tls)
			} else {
				*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes = libc.UintptrFromInt32(0)
			*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep)) = int64(*(*int32)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(linkPtr + 56)) + uintptr(i)*4)))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
			goto _17
		_17:
			;
			i++
		}
		resultObj = XTcl_NewListObj(tls, (*TLink)(unsafe.Pointer(linkPtr)).FnumElems, objv)
		XTclpFree(tls, objv)
		return resultObj
	}
	*(*int32)(unsafe.Pointer(&(*TLink)(unsafe.Pointer(linkPtr)).FlastValue)) = *(*int32)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr))
	return XTcl_NewWideIntObj(tls, int64(*(*int32)(unsafe.Pointer(&(*TLink)(unsafe.Pointer(linkPtr)).FlastValue))))
_2:
	;
	if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
		libc.Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(linkPtr + 56)), (*TLink)(unsafe.Pointer(linkPtr)).Faddr, libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).Fbytes))
		objv = XTcl_Alloc(tls, libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).FnumElems)*uint64(8))
		i = 0
		for {
			if !(i < (*TLink)(unsafe.Pointer(linkPtr)).FnumElems) {
				break
			}
			if v20 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v20 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v20 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
				*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) = XTclThreadAllocObj(tls)
			} else {
				*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes = libc.UintptrFromInt32(0)
			*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep)) = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(linkPtr + 56)) + uintptr(i)*8))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
			goto _19
		_19:
			;
			i++
		}
		resultObj = XTcl_NewListObj(tls, (*TLink)(unsafe.Pointer(linkPtr)).FnumElems, objv)
		XTclpFree(tls, objv)
		return resultObj
	}
	*(*TTcl_WideInt)(unsafe.Pointer(linkPtr + 56)) = *(*TTcl_WideInt)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr))
	return XTcl_NewWideIntObj(tls, *(*TTcl_WideInt)(unsafe.Pointer(linkPtr + 56)))
_3:
	;
	if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
		libc.Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(linkPtr + 56)), (*TLink)(unsafe.Pointer(linkPtr)).Faddr, libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).Fbytes))
		objv = XTcl_Alloc(tls, libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).FnumElems)*uint64(8))
		i = 0
		for {
			if !(i < (*TLink)(unsafe.Pointer(linkPtr)).FnumElems) {
				break
			}
			if v22 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v22 {
				cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v22 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
				*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) = XTclThreadAllocObj(tls)
			} else {
				*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes = libc.UintptrFromInt32(0)
			*(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep)) = *(*float64)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(linkPtr + 56)) + uintptr(i)*8))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclDoubleType))
			goto _21
		_21:
			;
			i++
		}
		resultObj = XTcl_NewListObj(tls, (*TLink)(unsafe.Pointer(linkPtr)).FnumElems, objv)
		XTclpFree(tls, objv)
		return resultObj
	}
	*(*float64)(unsafe.Pointer(linkPtr + 56)) = *(*float64)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr))
	return XTcl_NewDoubleObj(tls, *(*float64)(unsafe.Pointer(linkPtr + 56)))
_4:
	;
	if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
		libc.Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(linkPtr + 56)), (*TLink)(unsafe.Pointer(linkPtr)).Faddr, libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).Fbytes))
		objv = XTcl_Alloc(tls, libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).FnumElems)*uint64(8))
		i = 0
		for {
			if !(i < (*TLink)(unsafe.Pointer(linkPtr)).FnumElems) {
				break
			}
			*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) = XTcl_NewWideIntObj(tls, libc.BoolInt64(libc.BoolInt32(*(*int32)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(linkPtr + 56)) + uintptr(i)*4)) != 0) != 0))
			goto _23
		_23:
			;
			i++
		}
		resultObj = XTcl_NewListObj(tls, (*TLink)(unsafe.Pointer(linkPtr)).FnumElems, objv)
		XTclpFree(tls, objv)
		return resultObj
	}
	*(*int32)(unsafe.Pointer(&(*TLink)(unsafe.Pointer(linkPtr)).FlastValue)) = *(*int32)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr))
	return XTcl_NewWideIntObj(tls, libc.BoolInt64(*(*int32)(unsafe.Pointer(&(*TLink)(unsafe.Pointer(linkPtr)).FlastValue)) != 0))
_5:
	;
	if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
		libc.Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(linkPtr + 56)), (*TLink)(unsafe.Pointer(linkPtr)).Faddr, libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).Fbytes))
		objv = XTcl_Alloc(tls, libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).FnumElems)*uint64(8))
		i = 0
		for {
			if !(i < (*TLink)(unsafe.Pointer(linkPtr)).FnumElems) {
				break
			}
			if v25 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v25 {
				cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v25 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
				*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) = XTclThreadAllocObj(tls)
			} else {
				*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes = libc.UintptrFromInt32(0)
			*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep)) = libc.Int64FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(linkPtr + 56)) + uintptr(i))))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
			goto _24
		_24:
			;
			i++
		}
		resultObj = XTcl_NewListObj(tls, (*TLink)(unsafe.Pointer(linkPtr)).FnumElems, objv)
		XTclpFree(tls, objv)
		return resultObj
	}
	(*TLink)(unsafe.Pointer(linkPtr)).FlastValue.Fc = *(*uint8)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr))
	return XTcl_NewWideIntObj(tls, libc.Int64FromUint8((*TLink)(unsafe.Pointer(linkPtr)).FlastValue.Fc))
_6:
	;
	if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
		libc.Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(linkPtr + 56)), (*TLink)(unsafe.Pointer(linkPtr)).Faddr, libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).Fbytes))
		objv = XTcl_Alloc(tls, libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).FnumElems)*uint64(8))
		i = 0
		for {
			if !(i < (*TLink)(unsafe.Pointer(linkPtr)).FnumElems) {
				break
			}
			if v27 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v27 {
				cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v27 || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == libc.Uint64FromInt32(0) {
				*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) = XTclThreadAllocObj(tls)
			} else {
				*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes = libc.UintptrFromInt32(0)
			*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep)) = libc.Int64FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(linkPtr + 56)) + uintptr(i))))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
			goto _26
		_26:
			;
			i++
		}
		resultObj = XTcl_NewListObj(tls, (*TLink)(unsafe.Pointer(linkPtr)).FnumElems, objv)
		XTclpFree(tls, objv)
		return resultObj
	}
	*(*uint8)(unsafe.Pointer(&(*TLink)(unsafe.Pointer(linkPtr)).FlastValue)) = *(*uint8)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr))
	return XTcl_NewWideIntObj(tls, libc.Int64FromUint8(*(*uint8)(unsafe.Pointer(&(*TLink)(unsafe.Pointer(linkPtr)).FlastValue))))
_7:
	;
	if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
		libc.Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(linkPtr + 56)), (*TLink)(unsafe.Pointer(linkPtr)).Faddr, libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).Fbytes))
		objv = XTcl_Alloc(tls, libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).FnumElems)*uint64(8))
		i = 0
		for {
			if !(i < (*TLink)(unsafe.Pointer(linkPtr)).FnumElems) {
				break
			}
			if v29 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v29 {
				cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v29 || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == libc.Uint64FromInt32(0) {
				*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) = XTclThreadAllocObj(tls)
			} else {
				*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes = libc.UintptrFromInt32(0)
			*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep)) = int64(*(*int16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(linkPtr + 56)) + uintptr(i)*2)))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
			goto _28
		_28:
			;
			i++
		}
		resultObj = XTcl_NewListObj(tls, (*TLink)(unsafe.Pointer(linkPtr)).FnumElems, objv)
		XTclpFree(tls, objv)
		return resultObj
	}
	*(*int16)(unsafe.Pointer(&(*TLink)(unsafe.Pointer(linkPtr)).FlastValue)) = *(*int16)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr))
	return XTcl_NewWideIntObj(tls, int64(*(*int16)(unsafe.Pointer(&(*TLink)(unsafe.Pointer(linkPtr)).FlastValue))))
_8:
	;
	if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
		libc.Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(linkPtr + 56)), (*TLink)(unsafe.Pointer(linkPtr)).Faddr, libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).Fbytes))
		objv = XTcl_Alloc(tls, libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).FnumElems)*uint64(8))
		i = 0
		for {
			if !(i < (*TLink)(unsafe.Pointer(linkPtr)).FnumElems) {
				break
			}
			if v31 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v31 {
				cachePtr6 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v31 || (*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects == libc.Uint64FromInt32(0) {
				*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) = XTclThreadAllocObj(tls)
			} else {
				*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes = libc.UintptrFromInt32(0)
			*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep)) = libc.Int64FromUint16(*(*uint16)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(linkPtr + 56)) + uintptr(i)*2)))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
			goto _30
		_30:
			;
			i++
		}
		resultObj = XTcl_NewListObj(tls, (*TLink)(unsafe.Pointer(linkPtr)).FnumElems, objv)
		XTclpFree(tls, objv)
		return resultObj
	}
	*(*uint16)(unsafe.Pointer(&(*TLink)(unsafe.Pointer(linkPtr)).FlastValue)) = *(*uint16)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr))
	return XTcl_NewWideIntObj(tls, libc.Int64FromUint16(*(*uint16)(unsafe.Pointer(&(*TLink)(unsafe.Pointer(linkPtr)).FlastValue))))
_9:
	;
	if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
		libc.Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(linkPtr + 56)), (*TLink)(unsafe.Pointer(linkPtr)).Faddr, libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).Fbytes))
		objv = XTcl_Alloc(tls, libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).FnumElems)*uint64(8))
		i = 0
		for {
			if !(i < (*TLink)(unsafe.Pointer(linkPtr)).FnumElems) {
				break
			}
			if v33 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v33 {
				cachePtr7 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v33 || (*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects == libc.Uint64FromInt32(0) {
				*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) = XTclThreadAllocObj(tls)
			} else {
				*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes = libc.UintptrFromInt32(0)
			*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep)) = libc.Int64FromUint32(*(*uint32)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(linkPtr + 56)) + uintptr(i)*4)))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
			goto _32
		_32:
			;
			i++
		}
		resultObj = XTcl_NewListObj(tls, (*TLink)(unsafe.Pointer(linkPtr)).FnumElems, objv)
		XTclpFree(tls, objv)
		return resultObj
	}
	*(*uint32)(unsafe.Pointer(&(*TLink)(unsafe.Pointer(linkPtr)).FlastValue)) = *(*uint32)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr))
	return XTcl_NewWideIntObj(tls, libc.Int64FromUint32(*(*uint32)(unsafe.Pointer(&(*TLink)(unsafe.Pointer(linkPtr)).FlastValue))))
_10:
	;
	if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
		libc.Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(linkPtr + 56)), (*TLink)(unsafe.Pointer(linkPtr)).Faddr, libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).Fbytes))
		objv = XTcl_Alloc(tls, libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).FnumElems)*uint64(8))
		i = 0
		for {
			if !(i < (*TLink)(unsafe.Pointer(linkPtr)).FnumElems) {
				break
			}
			if v35 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v35 {
				cachePtr8 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v35 || (*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects == libc.Uint64FromInt32(0) {
				*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) = XTclThreadAllocObj(tls)
			} else {
				*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr8)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr8)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes = libc.UintptrFromInt32(0)
			*(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep)) = float64(*(*float32)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(linkPtr + 56)) + uintptr(i)*4)))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclDoubleType))
			goto _34
		_34:
			;
			i++
		}
		resultObj = XTcl_NewListObj(tls, (*TLink)(unsafe.Pointer(linkPtr)).FnumElems, objv)
		XTclpFree(tls, objv)
		return resultObj
	}
	*(*float32)(unsafe.Pointer(&(*TLink)(unsafe.Pointer(linkPtr)).FlastValue)) = *(*float32)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr))
	return XTcl_NewDoubleObj(tls, float64(*(*float32)(unsafe.Pointer(&(*TLink)(unsafe.Pointer(linkPtr)).FlastValue))))
_11:
	;
	if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
		libc.Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(linkPtr + 56)), (*TLink)(unsafe.Pointer(linkPtr)).Faddr, libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).Fbytes))
		objv = XTcl_Alloc(tls, libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).FnumElems)*uint64(8))
		i = 0
		for {
			if !(i < (*TLink)(unsafe.Pointer(linkPtr)).FnumElems) {
				break
			}
			if v37 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v37 {
				cachePtr9 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v37 || (*TAllocCache)(unsafe.Pointer(cachePtr9)).FnumObjects == libc.Uint64FromInt32(0) {
				*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) = XTclThreadAllocObj(tls)
			} else {
				*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr9)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr9)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr9)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes = libc.UintptrFromInt32(0)
			uw_ = *(*TTcl_WideUInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(linkPtr + 56)) + uintptr(i)*8))
			if uw_ > libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) {
				if XTclBN_mp_init_u64(tls, bp, uw_) != MP_OKAY {
					XTcl_Panic(tls, __ccgo_ts+13273, libc.VaList(bp+56, __ccgo_ts+13293))
				}
				XTclSetBignumInternalRep(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp)
			} else {
				*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FinternalRep)) = libc.Int64FromUint64(uw_)
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
			}
			goto _36
		_36:
			;
			i++
		}
		resultObj = XTcl_NewListObj(tls, (*TLink)(unsafe.Pointer(linkPtr)).FnumElems, objv)
		XTclpFree(tls, objv)
		return resultObj
	}
	*(*TTcl_WideUInt)(unsafe.Pointer(linkPtr + 56)) = *(*TTcl_WideUInt)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr))
	if v38 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v38 {
		cachePtr10 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v38 || (*TAllocCache)(unsafe.Pointer(cachePtr10)).FnumObjects == libc.Uint64FromInt32(0) {
		uwObj = XTclThreadAllocObj(tls)
	} else {
		uwObj = (*TAllocCache)(unsafe.Pointer(cachePtr10)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr10)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(uwObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr10)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(uwObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(uwObj)).Fbytes = libc.UintptrFromInt32(0)
	uw_1 = *(*TTcl_WideUInt)(unsafe.Pointer(linkPtr + 56))
	if uw_1 > libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) {
		if XTclBN_mp_init_u64(tls, bp+24, uw_1) != MP_OKAY {
			XTcl_Panic(tls, __ccgo_ts+13273, libc.VaList(bp+56, __ccgo_ts+13293))
		}
		XTclSetBignumInternalRep(tls, uwObj, bp+24)
	} else {
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(uwObj)).FinternalRep)) = libc.Int64FromUint64(uw_1)
		(*TTcl_Obj)(unsafe.Pointer(uwObj)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	}
	return uwObj
_12:
	;
	p = *(*uintptr)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr))
	if p == libc.UintptrFromInt32(0) {
		if v39 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v39 {
			cachePtr11 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v39 || (*TAllocCache)(unsafe.Pointer(cachePtr11)).FnumObjects == libc.Uint64FromInt32(0) {
			resultObj = XTclThreadAllocObj(tls)
		} else {
			resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr11)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr11)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(resultObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr11)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
		if libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes, __ccgo_ts+51231, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes + uintptr(libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(5) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
		return resultObj
	}
	return XTcl_NewStringObj(tls, p, int64(-int32(1)))
_13:
	;
	if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
		libc.Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(linkPtr + 56)), (*TLink)(unsafe.Pointer(linkPtr)).Faddr, libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).Fbytes))
		*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(linkPtr + 56)) + uintptr((*TLink)(unsafe.Pointer(linkPtr)).Fbytes-int64(1)))) = uint8('\000')
		/* take care of proper string end */
		return XTcl_NewStringObj(tls, *(*uintptr)(unsafe.Pointer(linkPtr + 56)), (*TLink)(unsafe.Pointer(linkPtr)).Fbytes)
	}
	(*TLink)(unsafe.Pointer(linkPtr)).FlastValue.Fc = uint8('\000')
	return XTcl_NewStringObj(tls, linkPtr+56, int64(1))
_14:
	;
	if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
		libc.Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(linkPtr + 56)), (*TLink)(unsafe.Pointer(linkPtr)).Faddr, libc.Uint64FromInt64((*TLink)(unsafe.Pointer(linkPtr)).Fbytes))
		return XTcl_NewByteArrayObj(tls, (*TLink)(unsafe.Pointer(linkPtr)).Faddr, (*TLink)(unsafe.Pointer(linkPtr)).Fbytes)
	}
	*(*uint8)(unsafe.Pointer(&(*TLink)(unsafe.Pointer(linkPtr)).FlastValue)) = *(*uint8)(unsafe.Pointer((*TLink)(unsafe.Pointer(linkPtr)).Faddr))
	return XTcl_NewByteArrayObj(tls, linkPtr+56, int64(1))
	/*
	 * This code only gets executed if the link type is unknown (shouldn't
	 * ever happen).
	 */
_15:
	;
_42:
	;
	if v43 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v43 {
		cachePtr12 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v43 || (*TAllocCache)(unsafe.Pointer(cachePtr12)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr12)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr12)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr12)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	if libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes, __ccgo_ts+51236, libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes + uintptr(libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(3) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	goto _41
_41:
	;
	if 0 != 0 {
		goto _42
	}
	goto _40
_40:
	;
	return resultObj
_16:
	;
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * LinkFree --
 *
 *	Free's allocated space of given link and link structure.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _LinkFree(tls *libc.TLS, linkPtr uintptr) {
	/* Structure describing linked variable. */
	if (*TLink)(unsafe.Pointer(linkPtr)).FnsPtr != 0 {
		XTclNsDecrRefCount(tls, (*TLink)(unsafe.Pointer(linkPtr)).FnsPtr)
	}
	if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_ADDR) != 0 {
		XTclpFree(tls, (*TLink)(unsafe.Pointer(linkPtr)).Faddr)
	}
	if (*TLink)(unsafe.Pointer(linkPtr)).Fflags&int32(LINK_ALLOC_LAST) != 0 {
		XTclpFree(tls, *(*uintptr)(unsafe.Pointer(linkPtr + 56)))
	}
	XTclpFree(tls, linkPtr)
}

const FLT_MAX4 = 0
const FLT_MIN2 = 0
const LISTREP_PANIC_ON_FAIL = 1
const LISTREP_SPACE_FAVOR_BACK = 4
const LISTREP_SPACE_FAVOR_FRONT = 2
const LISTREP_SPACE_FAVOR_NONE = 6
const LISTREP_SPACE_FLAGS = 14
const LISTREP_SPACE_ONLY_BACK = 8

func init() {
	p := unsafe.Pointer(&XtclListType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_FreeListInternalRep)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_DupListInternalRep)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_UpdateStringOfList)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_SetListFromAny)
	*(*uintptr)(unsafe.Add(p, 48)) = __ccgo_fp(_ListLength)
}

/* Macros to manipulate the List internal rep */

/* Returns number of free unused slots at the back of the ListRep's ListStore */

/* Returns number of free unused slots at the front of the ListRep's ListStore */

/* Returns a pointer to the slot corresponding to list index listIdx_ */

/*
 * Macros to replace the internal representation in a Tcl_Obj. There are
 * subtle differences in each so make sure to use the right one to avoid
 * memory leaks, access to freed memory and the like.
 *
 * ListObjStompRep - assumes the Tcl_Obj internal representation can be
 * overwritten AND that the passed ListRep already has reference counts that
 * include the reference from the Tcl_Obj. Basically just copies the pointers
 * and sets the internal Tcl_Obj type to list
 *
 * ListObjOverwriteRep - like ListObjOverwriteRep but additionally
 * increments reference counts on the passed ListRep. Generally used when
 * the string representation of the Tcl_Obj is not to be modified.
 *
 * ListObjReplaceRepAndInvalidate - Like ListObjOverwriteRep but additionally
 * assumes the Tcl_Obj internal rep is valid (and possibly even same as
 * passed ListRep) and frees it first. Additionally invalidates the string
 * representation. Generally used when modifying a Tcl_Obj value.
 */

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * ListSpanNew --
//	 *
//	 *    Allocates and initializes memory for a new ListSpan. The reference
//	 *    count on the returned struct is 0.
//	 *
//	 * Results:
//	 *    Non-NULL pointer to the allocated ListSpan.
//	 *
//	 * Side effects:
//	 *    The function will panic on memory allocation failure.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _ListSpanNew(tls *libc.TLS, firstSlot TTcl_Size, numSlots TTcl_Size) (r uintptr) {
	/* Number of slots covered by the span */
	var spanPtr uintptr
	_ = spanPtr
	spanPtr = XTcl_Alloc(tls, uint64(24))
	(*TListSpan)(unsafe.Pointer(spanPtr)).FrefCount = uint64(0)
	(*TListSpan)(unsafe.Pointer(spanPtr)).FspanStart = firstSlot
	(*TListSpan)(unsafe.Pointer(spanPtr)).FspanLength = numSlots
	return spanPtr
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * ListSpanDecrRefs --
//	 *
//	 *   Decrements the reference count on a span, freeing the memory if
//	 *   it drops to zero or less.
//	 *
//	 * Results:
//	 *   None.
//	 *
//	 * Side effects:
//	 *   The memory may be freed.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _ListSpanDecrRefs(tls *libc.TLS, spanPtr uintptr) {
	if (*TListSpan)(unsafe.Pointer(spanPtr)).FrefCount <= uint64(1) {
		XTclpFree(tls, spanPtr)
	} else {
		*(*Tsize_t)(unsafe.Pointer(spanPtr + 16)) -= uint64(1)
	}
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * ListSpanMerited --
//	 *
//	 *    Creation of a new list may sometimes be done as a span on existing
//	 *    storage instead of allocating new. The tradeoff is that if the
//	 *    original list is released, the new span-based list may hold on to
//	 *    more memory than desired. This function implements heuristics for
//	 *    deciding which option is better.
//	 *
//	 * Results:
//	 *    Returns non-0 if a span-based list is likely to be more optimal
//	 *    and 0 if not.
//	 *
//	 * Side effects:
//	 *    None.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _ListSpanMerited(tls *libc.TLS, length TTcl_Size, usedStorageLength TTcl_Size, allocatedStorageLength TTcl_Size) (r int32) {
	/* Length of the currently allocation */
	/*
	 * Possible optimizations for future consideration
	 * - heuristic LIST_SPAN_THRESHOLD
	 * - currently, information about the sharing (ref count) of existing
	 * storage is not passed. Perhaps it should be. For example if the
	 * existing storage has a "large" ref count, then it might make sense
	 * to do even a small span.
	 */
	if length < int64(LIST_SPAN_THRESHOLD) {
		return 0 /* No span for small lists */
	}
	if length < allocatedStorageLength/int64(2)-allocatedStorageLength/int64(8) {
		return 0 /* No span if less than 3/8 of allocation */
	}
	if length < usedStorageLength/int64(2) {
		return 0 /* No span if less than half current storage */
	}
	return int32(1)
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * ListRepFreeUnreferenced --
//	 *
//	 *    Inline wrapper for ListRepUnsharedFreeUnreferenced that does quick checks
//	 *    before calling it.
//	 *
//	 *    IMPORTANT: this function must not be called on an internal
//	 *    representation of a Tcl_Obj that is itself shared.
//	 *
//	 * Results:
//	 *    None.
//	 *
//	 * Side effects:
//	 *    See comments for ListRepUnsharedFreeUnreferenced.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _ListRepFreeUnreferenced(tls *libc.TLS, repPtr uintptr) {
	if !((*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(repPtr)).FstorePtr)).FrefCount > libc.Uint64FromInt32(1)) && (*TListRep)(unsafe.Pointer(repPtr)).FspanPtr != 0 {
		/* T:listrep-1.5.1 */
		_ListRepUnsharedFreeUnreferenced(tls, repPtr)
	}
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * ObjArrayIncrRefs --
//	 *
//	 *    Increments the reference counts for Tcl_Obj's in a subarray.
//	 *
//	 * Results:
//	 *    None.
//	 *
//	 * Side effects:
//	 *    As above.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _ObjArrayIncrRefs(tls *libc.TLS, objv uintptr, startIdx TTcl_Size, count TTcl_Size) {
	/* Number of elements in the subarray */
	var end uintptr
	_ = end
	objv += uintptr(startIdx) * 8
	end = objv + uintptr(count)*8
	for objv < end {
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).FrefCount++
		objv += 8
	}
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * ObjArrayDecrRefs --
//	 *
//	 *    Decrements the reference counts for Tcl_Obj's in a subarray.
//	 *
//	 * Results:
//	 *    None.
//	 *
//	 * Side effects:
//	 *    As above.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _ObjArrayDecrRefs(tls *libc.TLS, objv uintptr, startIdx TTcl_Size, count TTcl_Size) {
	/* Number of elements in the subarray */
	var _objPtr, end, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _ = _objPtr, end, v1, v2
	objv += uintptr(startIdx) * 8
	end = objv + uintptr(count)*8
	for objv < end {
		_objPtr = *(*uintptr)(unsafe.Pointer(objv))
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		objv += 8
	}
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * ObjArrayCopy --
//	 *
//	 *    Copies an array of Tcl_Obj* pointers.
//	 *
//	 * Results:
//	 *    None.
//	 *
//	 * Side effects:
//	 *    Reference counts on copied Tcl_Obj's are incremented.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _ObjArrayCopy(tls *libc.TLS, to uintptr, count TTcl_Size, from uintptr) {
	/* Source array of Tcl_Obj* */
	var end, v1, v2 uintptr
	_, _, _ = end, v1, v2
	end = to + uintptr(count)*8
	/* TODO - would memmove followed by separate IncrRef loop be faster? */
	for to < end {
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(from)))).FrefCount++
		v1 = to
		to += 8
		v2 = from
		from += 8
		*(*uintptr)(unsafe.Pointer(v1)) = *(*uintptr)(unsafe.Pointer(v2))
	}
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * MemoryAllocationError --
//	 *
//	 *    Generates a memory allocation failure error.
//	 *
//	 * Results:
//	 *    Always TCL_ERROR.
//	 *
//	 * Side effects:
//	 *    Error message and code are stored in the interpreter if not NULL.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _MemoryAllocationError(tls *libc.TLS, interp uintptr, size Tsize_t) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Size of attempted allocation that failed */
	if interp != libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+51239, libc.VaList(bp+8, size)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+2008, libc.UintptrFromInt32(0)))
	}
	return int32(TCL_ERROR)
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * ListLimitExceeded --
//	 *
//	 *    Generates an error for exceeding maximum list size.
//	 *
//	 * Results:
//	 *    Always TCL_ERROR.
//	 *
//	 * Side effects:
//	 *    Error message and code are stored in the interpreter if not NULL.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _ListLimitExceededError(tls *libc.TLS, interp uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	if interp != libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+1970, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+2008, libc.UintptrFromInt32(0)))
	}
	return int32(TCL_ERROR)
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * ListRepUnsharedShiftDown --
//	 *
//	 *    Shifts the "in-use" contents in the ListStore for a ListRep down
//	 *    by the given number of slots. The ListStore must be unshared and
//	 *    the free space at the front of the storage area must be big enough.
//	 *    It is the caller's responsibility to check.
//	 *
//	 * Results:
//	 *    None.
//	 *
//	 * Side effects:
//	 *    The contents of the ListRep's ListStore area are shifted down in the
//	 *    storage area. The ListRep's ListSpan is updated accordingly.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _ListRepUnsharedShiftDown(tls *libc.TLS, repPtr uintptr, shiftCount TTcl_Size) {
	var storePtr uintptr
	_ = storePtr
	storePtr = (*TListRep)(unsafe.Pointer(repPtr)).FstorePtr
	libc.Xmemmove(tls, storePtr+40+uintptr((*TListStore)(unsafe.Pointer(storePtr)).FfirstUsed-shiftCount)*8, storePtr+40+uintptr((*TListStore)(unsafe.Pointer(storePtr)).FfirstUsed)*8, libc.Uint64FromInt64((*TListStore)(unsafe.Pointer(storePtr)).FnumUsed)*uint64(8))
	*(*TTcl_Size)(unsafe.Pointer(storePtr)) -= shiftCount
	if (*TListRep)(unsafe.Pointer(repPtr)).FspanPtr != 0 {
		*(*TTcl_Size)(unsafe.Pointer((*TListRep)(unsafe.Pointer(repPtr)).FspanPtr)) -= shiftCount
	} else {
		/*
		 * If there was no span, firstUsed must have been 0 (Invariant)
		 * AND shiftCount must have been 0 (<= firstUsed on call)
		 * In other words, this would have been a no-op
		 */
	}
}

/*
 *------------------------------------------------------------------------
 *
 * ListRepUnsharedShiftUp --
 *
 *    Shifts the "in-use" contents in the ListStore for a ListRep up
 *    by the given number of slots. The ListStore must be unshared and
 *    the free space at the back of the storage area must be big enough.
 *    It is the caller's responsibility to check.
 *    TODO - this function is not currently used.
 *
 * Results:
 *    None.
 *
 * Side effects:
 *    The contents of the ListRep's ListStore area are shifted up in the
 *    storage area. The ListRep's ListSpan is updated accordingly.
 *
 *------------------------------------------------------------------------
 */

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * ListRepValidate --
//	 *
//	 *	Checks all invariants for a ListRep and panics on failure.
//	 *	Note this is independent of NDEBUG, assert etc.
//	 *
//	 * Results:
//	 *    None.
//	 *
//	 * Side effects:
//	 *    Panics if any invariant is not met.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _ListRepValidate(tls *libc.TLS, repPtr uintptr, file uintptr, lineNum int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var condition, storePtr uintptr
	var v1, v2, v3, v4 int64
	_, _, _, _, _, _ = condition, storePtr, v1, v2, v3, v4
	storePtr = (*TListRep)(unsafe.Pointer(repPtr)).FstorePtr
	_ = storePtr /* To stop gcc from whining about unused vars */
	/* Separate each condition so line number gives exact reason for failure */
	if !(storePtr != libc.UintptrFromInt32(0)) {
		condition = __ccgo_ts + 51291
		goto failure
	}
	if !((*TListStore)(unsafe.Pointer(storePtr)).FnumAllocated >= libc.Int64FromInt32(0)) {
		condition = __ccgo_ts + 51308
		goto failure
	}
	if !((*TListStore)(unsafe.Pointer(storePtr)).FnumAllocated <= libc.Int64FromUint64((libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))-uint64(libc.UintptrFromInt32(0)+40))/libc.Uint64FromInt64(8))) {
		condition = __ccgo_ts + 51336
		goto failure
	}
	if !((*TListStore)(unsafe.Pointer(storePtr)).FfirstUsed >= libc.Int64FromInt32(0)) {
		condition = __ccgo_ts + 51371
		goto failure
	}
	if !((*TListStore)(unsafe.Pointer(storePtr)).FfirstUsed < (*TListStore)(unsafe.Pointer(storePtr)).FnumAllocated) {
		condition = __ccgo_ts + 51396
		goto failure
	}
	if !((*TListStore)(unsafe.Pointer(storePtr)).FnumUsed >= libc.Int64FromInt32(0)) {
		condition = __ccgo_ts + 51441
		goto failure
	}
	if !((*TListStore)(unsafe.Pointer(storePtr)).FnumUsed <= (*TListStore)(unsafe.Pointer(storePtr)).FnumAllocated) {
		condition = __ccgo_ts + 51464
		goto failure
	}
	if !((*TListStore)(unsafe.Pointer(storePtr)).FfirstUsed <= (*TListStore)(unsafe.Pointer(storePtr)).FnumAllocated-(*TListStore)(unsafe.Pointer(storePtr)).FnumUsed) {
		condition = __ccgo_ts + 51508
		goto failure
	}
	if !((*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(repPtr)).FstorePtr)).FrefCount > libc.Uint64FromInt32(1)) {
		/*
		 * If this is the only reference and there is no span, then store
		 * occupancy must begin at 0
		 */
		if !((*TListRep)(unsafe.Pointer(repPtr)).FspanPtr != 0 || (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(repPtr)).FstorePtr)).FfirstUsed == 0) {
			condition = __ccgo_ts + 51576
			goto failure
		}
	}
	if (*TListRep)(unsafe.Pointer(repPtr)).FspanPtr != 0 {
		v1 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(repPtr)).FspanPtr)).FspanStart
	} else {
		v1 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(repPtr)).FstorePtr)).FfirstUsed
	}
	if !(v1 >= (*TListStore)(unsafe.Pointer(storePtr)).FfirstUsed) {
		condition = __ccgo_ts + 51628
		goto failure
	}
	if (*TListRep)(unsafe.Pointer(repPtr)).FspanPtr != 0 {
		v2 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(repPtr)).FspanPtr)).FspanLength
	} else {
		v2 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(repPtr)).FstorePtr)).FnumUsed
	}
	if !(v2 <= (*TListStore)(unsafe.Pointer(storePtr)).FnumUsed) {
		condition = __ccgo_ts + 51672
		goto failure
	}
	if (*TListRep)(unsafe.Pointer(repPtr)).FspanPtr != 0 {
		v3 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(repPtr)).FspanPtr)).FspanStart
	} else {
		v3 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(repPtr)).FstorePtr)).FfirstUsed
	}
	if (*TListRep)(unsafe.Pointer(repPtr)).FspanPtr != 0 {
		v4 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(repPtr)).FspanPtr)).FspanLength
	} else {
		v4 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(repPtr)).FstorePtr)).FnumUsed
	}
	if !(v3 <= (*TListStore)(unsafe.Pointer(storePtr)).FfirstUsed+(*TListStore)(unsafe.Pointer(storePtr)).FnumUsed-v4) {
		condition = __ccgo_ts + 51715
		goto failure
	}
	return
	goto failure
failure:
	;
	XTcl_Panic(tls, __ccgo_ts+51805, libc.VaList(bp+8, file, lineNum, condition))
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * TclListObjValidate --
//	 *
//	 *    Wrapper around ListRepValidate. Primarily used from test suite.
//	 *
//	 * Results:
//	 *    None.
//	 *
//	 * Side effects:
//	 *    Will panic if internal structure is not consistent or if object
//	 *    cannot be converted to a list object.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func XTclListObjValidate(tls *libc.TLS, interp uintptr, listObj uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _ /* listRep at bp+0 */ TListRep
	if _TclListObjGetRep(tls, interp, listObj, bp) != TCL_OK {
		XTcl_Panic(tls, __ccgo_ts+51856, 0)
	}
	_ListRepValidate(tls, bp, __ccgo_ts+51930, int32(710))
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * ListStoreNew --
//	 *
//	 *	Allocates a new ListStore with space for at least objc elements. objc
//	 *	must be > 0.  If objv!=NULL, initializes with the first objc values
//	 *	in that array.  If objv==NULL, initalize 0 elements, with space
//	 *	to add objc more.
//	 *
//	 *      Normally the function allocates the exact space requested unless
//	 *      the flags arguments has any LISTREP_SPACE_*
//	 *      bits set. See the comments for those #defines.
//	 *
//	 * Results:
//	 *      On success, a pointer to the allocated ListStore is returned.
//	 *      On allocation failure, panics if LISTREP_PANIC_ON_FAIL is set in
//	 *      flags; otherwise returns NULL.
//	 *
//	 * Side effects:
//	 *	The ref counts of the elements in objv are incremented on success
//	 *	since the returned ListStore references them.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _ListStoreNew(tls *libc.TLS, objc TTcl_Size, objv uintptr, flags int32) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var extra TTcl_Size
	var spaceFlags int32
	var storePtr, v1 uintptr
	var _ /* capacity at bp+0 */ TTcl_Size
	_, _, _, _ = extra, spaceFlags, storePtr, v1
	/*
	 * First check to see if we'd overflow and try to allocate an object
	 * larger than our memory allocator allows.
	 */
	if objc > libc.Int64FromUint64((libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))-uint64(libc.UintptrFromInt32(0)+40))/libc.Uint64FromInt64(8)) {
		if flags&int32(LISTREP_PANIC_ON_FAIL) != 0 {
			XTcl_Panic(tls, __ccgo_ts+1970, 0)
		}
		return libc.UintptrFromInt32(0)
	}
	storePtr = libc.UintptrFromInt32(0)
	if flags&(libc.Int32FromInt32(LISTREP_SPACE_FAVOR_FRONT)|libc.Int32FromInt32(LISTREP_SPACE_FAVOR_BACK)|libc.Int32FromInt32(LISTREP_SPACE_ONLY_BACK)) != 0 {
		/* Caller requests extra space front, back or both */
		v1 = XTclAttemptReallocElemsEx(tls, libc.UintptrFromInt32(0), objc, int64(8), libc.Int64FromUint64(uint64(libc.UintptrFromInt32(0)+40)), bp)
		goto _2
	_2:
		storePtr = v1
	} else {
		/* Exact allocation */
		*(*TTcl_Size)(unsafe.Pointer(bp)) = objc
		storePtr = XTclpAlloc(tls, libc.Uint64FromInt64(libc.Int64FromUint64(uint64(libc.UintptrFromInt32(0)+40)+libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))*libc.Uint64FromInt64(8))))
	}
	if storePtr == libc.UintptrFromInt32(0) {
		if flags&int32(LISTREP_PANIC_ON_FAIL) != 0 {
			XTcl_Panic(tls, __ccgo_ts+52009, libc.VaList(bp+16, libc.Int64FromUint64(uint64(libc.UintptrFromInt32(0)+40)+libc.Uint64FromInt64(objc)*libc.Uint64FromInt64(8))))
		}
		return libc.UintptrFromInt32(0)
	}
	(*TListStore)(unsafe.Pointer(storePtr)).FrefCount = uint64(0)
	(*TListStore)(unsafe.Pointer(storePtr)).Fflags = 0
	(*TListStore)(unsafe.Pointer(storePtr)).FnumAllocated = *(*TTcl_Size)(unsafe.Pointer(bp))
	if *(*TTcl_Size)(unsafe.Pointer(bp)) == objc {
		(*TListStore)(unsafe.Pointer(storePtr)).FfirstUsed = 0
	} else {
		extra = *(*TTcl_Size)(unsafe.Pointer(bp)) - objc
		spaceFlags = flags & (libc.Int32FromInt32(LISTREP_SPACE_FAVOR_FRONT) | libc.Int32FromInt32(LISTREP_SPACE_FAVOR_BACK) | libc.Int32FromInt32(LISTREP_SPACE_ONLY_BACK))
		if spaceFlags == int32(LISTREP_SPACE_ONLY_BACK) {
			(*TListStore)(unsafe.Pointer(storePtr)).FfirstUsed = 0
		} else {
			if spaceFlags == int32(LISTREP_SPACE_FAVOR_FRONT) {
				/* Leave more space in the front */
				(*TListStore)(unsafe.Pointer(storePtr)).FfirstUsed = extra - extra/int64(4) /* NOT same as 3*extra/4 */
			} else {
				if spaceFlags == int32(LISTREP_SPACE_FAVOR_BACK) {
					/* Leave more space in the back */
					(*TListStore)(unsafe.Pointer(storePtr)).FfirstUsed = extra / int64(4)
				} else {
					/* Apportion equally */
					(*TListStore)(unsafe.Pointer(storePtr)).FfirstUsed = extra / int64(2)
				}
			}
		}
	}
	if objv != 0 {
		(*TListStore)(unsafe.Pointer(storePtr)).FnumUsed = objc
		_ObjArrayCopy(tls, storePtr+40+uintptr((*TListStore)(unsafe.Pointer(storePtr)).FfirstUsed)*8, objc, objv)
	} else {
		(*TListStore)(unsafe.Pointer(storePtr)).FnumUsed = 0
	}
	return storePtr
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * ListStoreReallocate --
//	 *
//	 *    Reallocates the memory for a ListStore allocating extra for
//	 *    possible future growth.
//	 *
//	 * Results:
//	 *    Pointer to the ListStore which may be the same as storePtr or pointer
//	 *    to a new block of memory. On reallocation failure, NULL is returned.
//	 *
//	 *
//	 * Side effects:
//	 *    The memory pointed to by storePtr is freed if it a new block has to
//	 *    be returned.
//	 *
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _ListStoreReallocate(tls *libc.TLS, storePtr uintptr, needed TTcl_Size) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _ /* capacity at bp+0 */ TTcl_Size
	if needed > libc.Int64FromUint64((libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))-uint64(libc.UintptrFromInt32(0)+40))/libc.Uint64FromInt64(8)) {
		return libc.UintptrFromInt32(0)
	}
	storePtr = XTclAttemptReallocElemsEx(tls, storePtr, needed, int64(8), libc.Int64FromUint64(uint64(libc.UintptrFromInt32(0)+40)), bp)
	/* Only the capacity has changed, fix it in the header */
	if storePtr != 0 {
		(*TListStore)(unsafe.Pointer(storePtr)).FnumAllocated = *(*TTcl_Size)(unsafe.Pointer(bp))
	}
	return storePtr
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * ListRepInit --
//	 *
//	 *      Initializes a ListRep to hold a list internal representation
//	 *      with space for objc elements.
//	 *
//	 *      objc must be > 0. If objv!=NULL, initializes with the first objc
//	 *      values in that array. If objv==NULL, initalize list internal rep to
//	 *      have 0 elements, with space to add objc more.
//	 *
//	 *	Normally the function allocates the exact space requested unless
//	 *	the flags arguments has one of the LISTREP_SPACE_* bits set.
//	 *	See the comments for those #defines.
//	 *
//	 *      The reference counts of the ListStore and ListSpan (if present)
//	 *	pointed to by the initialized repPtr are set to zero.
//	 *	Caller has to manage them as necessary.
//	 *
//	 * Results:
//	 *      On success, TCL_OK is returned with *listRepPtr initialized.
//	 *      On failure, panics if LISTREP_PANIC_ON_FAIL is set in flags; otherwise
//	 *	returns TCL_ERROR with *listRepPtr fields set to NULL.
//	 *
//	 * Side effects:
//	 *	The ref counts of the elements in objv are incremented since the
//	 *	resulting list now refers to them.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _ListRepInit(tls *libc.TLS, objc TTcl_Size, objv uintptr, flags int32, repPtr uintptr) (r int32) {
	var storePtr uintptr
	_ = storePtr
	storePtr = _ListStoreNew(tls, objc, objv, flags)
	if storePtr != 0 {
		(*TListRep)(unsafe.Pointer(repPtr)).FstorePtr = storePtr
		if (*TListStore)(unsafe.Pointer(storePtr)).FfirstUsed == 0 {
			(*TListRep)(unsafe.Pointer(repPtr)).FspanPtr = libc.UintptrFromInt32(0)
		} else {
			(*TListRep)(unsafe.Pointer(repPtr)).FspanPtr = _ListSpanNew(tls, (*TListStore)(unsafe.Pointer(storePtr)).FfirstUsed, (*TListStore)(unsafe.Pointer(storePtr)).FnumUsed)
		}
		return TCL_OK
	}
	/*
	 * Initialize to keep gcc happy at the call site. Else it complains
	 * about possibly uninitialized use.
	 */
	(*TListRep)(unsafe.Pointer(repPtr)).FstorePtr = libc.UintptrFromInt32(0)
	(*TListRep)(unsafe.Pointer(repPtr)).FspanPtr = libc.UintptrFromInt32(0)
	return int32(TCL_ERROR)
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * ListRepInitAttempt --
//	 *
//	 *	Creates a list internal rep with space for objc elements. See
//	 *	ListRepInit for requirements for parameters (in particular objc must
//	 *	be > 0). This function only adds error messages to the interpreter if
//	 *	not NULL.
//	 *
//	 *      The reference counts of the ListStore and ListSpan (if present)
//	 *	pointed to by the initialized repPtr are set to zero.
//	 *	Caller has to manage them as necessary.
//	 *
//	 * Results:
//	 *      On success, TCL_OK is returned with *listRepPtr initialized.
//	 *	On allocation failure, returnes TCL_ERROR with an error message
//	 *	in the interpreter if non-NULL.
//	 *
//	 * Side effects:
//	 *	The ref counts of the elements in objv are incremented since the
//	 *	resulting list now refers to them.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _ListRepInitAttempt(tls *libc.TLS, interp uintptr, objc TTcl_Size, objv uintptr, repPtr uintptr) (r int32) {
	var result int32
	_ = result
	result = _ListRepInit(tls, objc, objv, 0, repPtr)
	if result != TCL_OK && interp != libc.UintptrFromInt32(0) {
		if objc > libc.Int64FromUint64((libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))-uint64(libc.UintptrFromInt32(0)+40))/libc.Uint64FromInt64(8)) {
			_ListLimitExceededError(tls, interp)
		} else {
			_MemoryAllocationError(tls, interp, libc.Uint64FromInt64(libc.Int64FromUint64(uint64(libc.UintptrFromInt32(0)+40)+libc.Uint64FromInt64(objc)*libc.Uint64FromInt64(8))))
		}
	}
	return result
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * ListRepClone --
//	 *
//	 *    Does a deep clone of an existing ListRep.
//	 *
//	 *    Normally the function allocates the exact space needed unless
//	 *    the flags arguments has one of the LISTREP_SPACE_* bits set.
//	 *    See the comments for those #defines.
//	 *
//	 * Results:
//	 *    None.
//	 *
//	 * Side effects:
//	 *    The toRepPtr location is initialized with the ListStore and ListSpan
//	 *    (if needed) containing a copy of the list elements in fromRepPtr.
//	 *    The function will panic if memory cannot be allocated.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _ListRepClone(tls *libc.TLS, fromRepPtr uintptr, toRepPtr uintptr, flags int32) {
	var fromObjs uintptr
	var numFrom TTcl_Size
	var v1, v2 int64
	_, _, _, _ = fromObjs, numFrom, v1, v2
	if (*TListRep)(unsafe.Pointer(fromRepPtr)).FspanPtr != 0 {
		v1 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(fromRepPtr)).FspanPtr)).FspanStart
	} else {
		v1 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(fromRepPtr)).FstorePtr)).FfirstUsed
	}
	fromObjs = (*TListRep)(unsafe.Pointer(fromRepPtr)).FstorePtr + 40 + uintptr(v1)*8
	if (*TListRep)(unsafe.Pointer(fromRepPtr)).FspanPtr != 0 {
		v2 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(fromRepPtr)).FspanPtr)).FspanLength
	} else {
		v2 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(fromRepPtr)).FstorePtr)).FnumUsed
	}
	numFrom = v2
	_ListRepInit(tls, numFrom, fromObjs, flags|int32(LISTREP_PANIC_ON_FAIL), toRepPtr)
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * ListRepUnsharedFreeUnreferenced --
//	 *
//	 *    Frees any Tcl_Obj's from the "in-use" area of the ListStore for a
//	 *    ListRep that are not actually references from any lists.
//	 *
//	 *    IMPORTANT: this function must not be called on a shared internal
//	 *    representation or the internal representation of a shared Tcl_Obj.
//	 *
//	 * Results:
//	 *    None.
//	 *
//	 * Side effects:
//	 *    The firstUsed and numUsed fields of the ListStore are updated to
//	 *    reflect the new "in-use" extent.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _ListRepUnsharedFreeUnreferenced(tls *libc.TLS, repPtr uintptr) {
	var count TTcl_Size
	var spanPtr, storePtr uintptr
	_, _, _ = count, spanPtr, storePtr
	storePtr = (*TListRep)(unsafe.Pointer(repPtr)).FstorePtr
	spanPtr = (*TListRep)(unsafe.Pointer(repPtr)).FspanPtr
	if spanPtr == libc.UintptrFromInt32(0) {
		/* Invariant TBD */
		return
	}
	/* Collect garbage at front */
	count = (*TListSpan)(unsafe.Pointer(spanPtr)).FspanStart - (*TListStore)(unsafe.Pointer(storePtr)).FfirstUsed
	if count > 0 {
		/* T:listrep-1.5.1,6.{1:8} */
		_ObjArrayDecrRefs(tls, storePtr+40, (*TListStore)(unsafe.Pointer(storePtr)).FfirstUsed, count)
		(*TListStore)(unsafe.Pointer(storePtr)).FfirstUsed = (*TListSpan)(unsafe.Pointer(spanPtr)).FspanStart
		*(*TTcl_Size)(unsafe.Pointer(storePtr + 8)) -= count
	}
	/* Collect garbage at back */
	count = (*TListStore)(unsafe.Pointer(storePtr)).FfirstUsed + (*TListStore)(unsafe.Pointer(storePtr)).FnumUsed - ((*TListSpan)(unsafe.Pointer(spanPtr)).FspanStart + (*TListSpan)(unsafe.Pointer(spanPtr)).FspanLength)
	if count > 0 {
		/* T:listrep-6.{1:8} */
		_ObjArrayDecrRefs(tls, storePtr+40, (*TListSpan)(unsafe.Pointer(spanPtr)).FspanStart+(*TListSpan)(unsafe.Pointer(spanPtr)).FspanLength, count)
		*(*TTcl_Size)(unsafe.Pointer(storePtr + 8)) -= count
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_NewListObj --
 *
 *	This function is normally called when not debugging: i.e., when
 *	TCL_MEM_DEBUG is not defined. It creates a new list object from an
 *	(objc,objv) array: that is, each of the objc elements of the array
 *	referenced by objv is inserted as an element into a new Tcl object.
 *
 *	When TCL_MEM_DEBUG is defined, this function just returns the result
 *	of calling the debugging version Tcl_DbNewListObj.
 *
 * Results:
 *	A new list object is returned that is initialized from the object
 *	pointers in objv. If objc is less than or equal to zero, an empty
 *	object is returned. The new object's string representation is left
 *	NULL. The resulting new list object has ref count 0.
 *
 * Side effects:
 *	The ref counts of the elements in objv are incremented since the
 *	resulting list now refers to them.
 *
 *----------------------------------------------------------------------
 */

func XTcl_NewListObj(tls *libc.TLS, objc TTcl_Size, objv uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* An array of pointers to Tcl objects. */
	var _isobjPtr, cachePtr, listObj uintptr
	var v1 bool
	var _ /* listRep at bp+0 */ TListRep
	_, _, _, _ = _isobjPtr, cachePtr, listObj, v1
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		listObj = XTclThreadAllocObj(tls)
	} else {
		listObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(listObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(listObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(listObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr = libc.UintptrFromInt32(0)
	if objc <= 0 {
		return listObj
	}
	_ListRepInit(tls, objc, objv, int32(LISTREP_PANIC_ON_FAIL), bp)
	(*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FrefCount++
	if (*TListRep)(unsafe.Pointer(bp)).FspanPtr != 0 {
		(*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FspanPtr)).FrefCount++
	}
	if (*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr != libc.UintptrFromInt32(0) {
		if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).FfreeIntRepProc})))(tls, listObj)
		}
		(*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr = libc.UintptrFromInt32(0)
	}
	_isobjPtr = listObj
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(listObj + 32))).Fptr1 = (*TListRep)(unsafe.Pointer(bp)).FstorePtr
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(listObj + 32))).Fptr2 = (*TListRep)(unsafe.Pointer(bp)).FspanPtr
	(*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr = uintptr(unsafe.Pointer(&XtclListType))
	return listObj
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DbNewListObj --
 *
 *	This function is normally called when debugging: i.e., when
 *	TCL_MEM_DEBUG is defined. It creates new list objects. It is the same
 *	as the Tcl_NewListObj function above except that it calls
 *	Tcl_DbCkalloc directly with the file name and line number from its
 *	caller. This simplifies debugging since then the [memory active]
 *	command will report the correct file name and line number when
 *	reporting objects that haven't been freed.
 *
 *	When TCL_MEM_DEBUG is not defined, this function just returns the
 *	result of calling Tcl_NewListObj.
 *
 * Results:
 *	A new list object is returned that is initialized from the object
 *	pointers in objv. If objc is less than or equal to zero, an empty
 *	object is returned. The new object's string representation is left
 *	NULL. The new list object has ref count 0.
 *
 * Side effects:
 *	The ref counts of the elements in objv are incremented since the
 *	resulting list now refers to them.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DbNewListObj(tls *libc.TLS, objc TTcl_Size, objv uintptr, dummy1174 uintptr, dummy1175 int32) (r uintptr) {
	return XTcl_NewListObj(tls, objc, objv)
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * TclNewListObj2 --
//	 *
//	 *    Create a new Tcl_Obj list comprising of the concatenation of two
//	 *    Tcl_Obj* arrays.
//	 *    TODO - currently this function is not used within tclListObj but
//	 *    need to see if it would be useful in other files that preallocate
//	 *    lists and then append.
//	 *
//	 * Results:
//	 *    Non-NULL pointer to the allocate Tcl_Obj.
//	 *
//	 * Side effects:
//	 *    None.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func XTclNewListObj2(tls *libc.TLS, objc1 TTcl_Size, objv1 uintptr, objc2 TTcl_Size, objv2 uintptr) (r uintptr) {
	/* Second array of pointers to Tcl objects. */
	var listObj, storePtr uintptr
	var objc TTcl_Size
	_, _, _ = listObj, objc, storePtr
	objc = objc1 + objc2
	listObj = XTcl_NewListObj(tls, objc, libc.UintptrFromInt32(0))
	if objc == 0 {
		return listObj /* An empty object */
	}
	storePtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(listObj + 32))).Fptr1
	if objc1 != 0 {
		_ObjArrayCopy(tls, storePtr+40, objc1, objv1)
	}
	if objc2 != 0 {
		_ObjArrayCopy(tls, storePtr+40+uintptr(objc1)*8, objc2, objv2)
	}
	(*TListStore)(unsafe.Pointer(storePtr)).FnumUsed = objc
	return listObj
}

/*
 *----------------------------------------------------------------------
 *
 * TclListObjGetRep --
 *
 *	This function returns a copy of the ListRep stored
 *	as the internal representation of an object. The reference
 *	counts of the (ListStore, ListSpan) contained in the representation
 *	are NOT incremented.
 *
 * Results:
 *	The return value is normally TCL_OK; in this case *listRepP
 *	is set to a copy of the descriptor stored as the internal
 *	representation of the Tcl_Obj containing a list. if listPtr does not
 *	refer to a list object and the object can not be converted to one,
 *	TCL_ERROR is returned and an error message will be left in the
 *	interpreter's result if interp is not NULL.
 *
 * Side effects:
 *	The possible conversion of the object referenced by listPtr
 *	to a list object. *repPtr is initialized to the internal rep
 *      if result is TCL_OK, or set to NULL on error.
 *----------------------------------------------------------------------
 */

func _TclListObjGetRep(tls *libc.TLS, interp uintptr, listObj uintptr, repPtr uintptr) (r int32) {
	/* Location to store descriptor */
	var result int32
	_ = result
	if !((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType))) {
		result = _SetListFromAny(tls, interp, listObj)
		if result != TCL_OK {
			/* Init to keep gcc happy wrt uninitialized fields at call site */
			(*TListRep)(unsafe.Pointer(repPtr)).FstorePtr = libc.UintptrFromInt32(0)
			(*TListRep)(unsafe.Pointer(repPtr)).FspanPtr = libc.UintptrFromInt32(0)
			return result
		}
	}
	(*TListRep)(unsafe.Pointer(repPtr)).FstorePtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(listObj + 32))).Fptr1
	(*TListRep)(unsafe.Pointer(repPtr)).FspanPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(listObj + 32))).Fptr2
	return TCL_OK
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * Tcl_SetListObj --
//	 *
//	 *	Modify an object to be a list containing each of the objc elements of
//	 *	the object array referenced by objv.
//	 *
//	 * Results:
//	 *	None.
//	 *
//	 * Side effects:
//	 *	The object is made a list object and is initialized from the object
//	 *	pointers in objv. If objc is less than or equal to zero, an empty
//	 *	object is returned. The new object's string representation is left
//	 *	NULL. The ref counts of the elements in objv are incremented since the
//	 *	list now refers to them. The object's old string and internal
//	 *	representations are freed and its type is set NULL.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func XTcl_SetListObj(tls *libc.TLS, objPtr uintptr, objc TTcl_Size, objv uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* An array of pointers to Tcl objects. */
	var _isobjPtr, _isobjPtr1 uintptr
	var _ /* listRep at bp+0 */ TListRep
	_, _ = _isobjPtr, _isobjPtr1
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+10229, libc.VaList(bp+24, __ccgo_ts+52057))
	}
	/*
	 * Set the object's type to "list" and initialize the internal rep.
	 * However, if there are no elements to put in the list, just give the
	 * object an empty string rep and a NULL type. NOTE ListRepInit must
	 * not be called with objc == 0!
	 */
	if objc > 0 {
		/* TODO - perhaps ask for extra space? */
		_ListRepInit(tls, objc, objv, int32(LISTREP_PANIC_ON_FAIL), bp)
		(*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FrefCount++
		if (*TListRep)(unsafe.Pointer(bp)).FspanPtr != 0 {
			(*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FspanPtr)).FrefCount++
		}
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != libc.UintptrFromInt32(0) {
			if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
				(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc})))(tls, objPtr)
			}
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
		}
		_isobjPtr = objPtr
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
		}
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1 = (*TListRep)(unsafe.Pointer(bp)).FstorePtr
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr2 = (*TListRep)(unsafe.Pointer(bp)).FspanPtr
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclListType))
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != libc.UintptrFromInt32(0) {
			if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
				(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc})))(tls, objPtr)
			}
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
		}
		_isobjPtr1 = objPtr
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes = libc.UintptrFromInt32(0)
		}
		XTcl_InitStringRep(tls, objPtr, libc.UintptrFromInt32(0), uint64(0))
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclListObjCopy --
 *
 *	Makes a "pure list" copy of a list value. This provides for the C
 *	level a counterpart of the [lrange $list 0 end] command, while using
 *	internals details to be as efficient as possible.
 *
 * Results:
 *	Normally returns a pointer to a new Tcl_Obj, that contains the same
 *	list value as *listPtr does. The returned Tcl_Obj has a refCount of
 *	zero. If *listPtr does not hold a list, NULL is returned, and if
 *	interp is non-NULL, an error message is recorded there.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclListObjCopy(tls *libc.TLS, interp uintptr, listObj uintptr) (r uintptr) {
	/* List object for which an element array is
	 * to be returned. */
	var _isobjPtr, cachePtr, copyObj, v1 uintptr
	var v2 bool
	_, _, _, _, _ = _isobjPtr, cachePtr, copyObj, v1, v2
	if !((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType))) {
		if (*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+48) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+48) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).Fversion) {
			v1 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).FlengthProc
		} else {
			v1 = libc.UintptrFromInt32(0)
		}
		if v1 != 0 {
			return XTcl_DuplicateObj(tls, listObj)
		}
		if _SetListFromAny(tls, interp, listObj) != TCL_OK {
			return libc.UintptrFromInt32(0)
		}
	}
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		copyObj = XTclThreadAllocObj(tls)
	} else {
		copyObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(copyObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(copyObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(copyObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(copyObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(copyObj)).FtypePtr = libc.UintptrFromInt32(0)
	_isobjPtr = copyObj
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
	_DupListInternalRep(tls, listObj, copyObj)
	return copyObj
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * ListRepRange --
//	 *
//	 *	Initializes a ListRep as a range within the passed ListRep.
//	 *	The range limits are clamped to the list boundaries.
//	 *
//	 * Results:
//	 *	None.
//	 *
//	 * Side effects:
//	 *      The ListStore and ListSpan referenced by in the returned ListRep
//	 *      may or may not be the same as those passed in. For example, the
//	 *      ListStore may differ because the range is small enough that a new
//	 *      ListStore is more memory-optimal. The ListSpan may differ because
//	 *      it is NULL or shared. Regardless, reference counts on the returned
//	 *      values are not incremented. Generally, ListObjReplaceRepAndInvalidate
//	 *      may be used to store the new ListRep back into an object or a
//	 *      ListRepIncrRefs followed by ListRepDecrRefs to free in case of errors.
//	 *	Any other use should be carefully reconsidered.
//	 *      TODO WARNING:- this is an awkward interface and easy for caller
//	 *      to get wrong. Mostly due to refcount combinations. Perhaps passing
//	 *      in the source listObj instead of source listRep might simplify.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _ListRepRange(tls *libc.TLS, srcRepPtr uintptr, rangeStart TTcl_Size, rangeEnd TTcl_Size, preserveSrcRep int32, rangeRepPtr uintptr) {
	/* Output. Must NOT be == srcRepPtr */
	var numAfterRangeEnd, numSrcElems, rangeLen, spanStart TTcl_Size
	var srcElems uintptr
	var v1, v2, v3, v4, v5, v6, v7, v8 int64
	_, _, _, _, _, _, _, _, _, _, _, _, _ = numAfterRangeEnd, numSrcElems, rangeLen, spanStart, srcElems, v1, v2, v3, v4, v5, v6, v7, v8
	if (*TListRep)(unsafe.Pointer(srcRepPtr)).FspanPtr != 0 {
		v1 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FspanPtr)).FspanLength
	} else {
		v1 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FstorePtr)).FnumUsed
	}
	numSrcElems = v1
	/* Take the opportunity to garbage collect */
	/* TODO - we probably do not need the preserveSrcRep here unlike later */
	if !(preserveSrcRep != 0) {
		/* T:listrep-1.{4,5,8,9},2.{4:7},3.{15:18},4.{7,8} */
		_ListRepFreeUnreferenced(tls, srcRepPtr)
	} /* else T:listrep-2.{4.2,4.3,5.2,5.3,6.2,7.2,8.1} */
	if rangeStart < 0 {
		rangeStart = 0
	}
	if rangeEnd >= numSrcElems {
		rangeEnd = numSrcElems - int64(1)
	}
	if rangeStart > rangeEnd {
		/* Empty list of capacity 1. */
		_ListRepInit(tls, int64(1), libc.UintptrFromInt32(0), int32(LISTREP_PANIC_ON_FAIL), rangeRepPtr)
		return
	}
	rangeLen = rangeEnd - rangeStart + int64(1)
	/*
	 * We can create a range one of four ways:
	 *  (0) Range encapsulates entire list
	 *  (1) Special case: deleting in-place from end of an unshared object
	 *  (2) Use a ListSpan referencing the current ListStore
	 *  (3) Creating a new ListStore
	 *  (4) Removing all elements outside the range in the current ListStore
	 * Option (4) may only be done if caller has not disallowed it AND
	 * the ListStore is not shared.
	 *
	 * The choice depends on heuristics related to speed and memory.
	 * TODO - heuristics below need to be measured and tuned.
	 *
	 * Note: Even if nothing below cause any changes, we still want the
	 * string-canonizing effect of [lrange 0 end] so the Tcl_Obj should not
	 * be returned as is even if the range encompasses the whole list.
	 */
	if rangeStart == 0 && rangeEnd == numSrcElems-int64(1) {
		/* Option 0 - entire list. This may be used to canonicalize */
		/* T:listrep-1.10.1,2.8.1 */
		*(*TListRep)(unsafe.Pointer(rangeRepPtr)) = *(*TListRep)(unsafe.Pointer(srcRepPtr)) /* Not ref counts not incremented */
	} else {
		if rangeStart == 0 && !(preserveSrcRep != 0) && (!((*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FstorePtr)).FrefCount > libc.Uint64FromInt32(1)) && (*TListRep)(unsafe.Pointer(srcRepPtr)).FspanPtr == libc.UintptrFromInt32(0)) {
			/* Option 1 - Special case unshared, exclude end elements, no span  */
			/* If no span */
			if (*TListRep)(unsafe.Pointer(srcRepPtr)).FspanPtr != 0 {
				v2 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FspanPtr)).FspanStart
			} else {
				v2 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FstorePtr)).FfirstUsed
			}
			srcElems = (*TListRep)(unsafe.Pointer(srcRepPtr)).FstorePtr + 40 + uintptr(v2)*8
			if (*TListRep)(unsafe.Pointer(srcRepPtr)).FspanPtr != 0 {
				v3 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FspanPtr)).FspanLength
			} else {
				v3 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FstorePtr)).FnumUsed
			}
			numSrcElems = v3
			numAfterRangeEnd = numSrcElems - (rangeEnd + int64(1))
			/* Assert: Because numSrcElems > rangeEnd earlier */
			if numAfterRangeEnd != 0 {
				/* T:listrep-1.{8,9} */
				_ObjArrayDecrRefs(tls, srcElems, rangeEnd+int64(1), numAfterRangeEnd)
			}
			/* srcRepPtr->storePtr->firstUsed,numAllocated unchanged */
			(*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FstorePtr)).FnumUsed = rangeLen
			(*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FstorePtr)).Fflags = 0
			(*TListRep)(unsafe.Pointer(rangeRepPtr)).FstorePtr = (*TListRep)(unsafe.Pointer(srcRepPtr)).FstorePtr /* Note no incr ref */
			(*TListRep)(unsafe.Pointer(rangeRepPtr)).FspanPtr = libc.UintptrFromInt32(0)
		} else {
			if _ListSpanMerited(tls, rangeLen, (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FstorePtr)).FnumUsed, (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FstorePtr)).FnumAllocated) != 0 {
				if (*TListRep)(unsafe.Pointer(srcRepPtr)).FspanPtr != 0 {
					v4 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FspanPtr)).FspanStart
				} else {
					v4 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FstorePtr)).FfirstUsed
				}
				/* Option 2 - because span would be most efficient */
				spanStart = v4 + rangeStart
				if !(preserveSrcRep != 0) && (*TListRep)(unsafe.Pointer(srcRepPtr)).FspanPtr != 0 && (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FspanPtr)).FrefCount <= uint64(1) {
					/* If span is not shared reuse it */
					/* T:listrep-2.7.3,3.{16,18} */
					(*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FspanPtr)).FspanStart = spanStart
					(*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FspanPtr)).FspanLength = rangeLen
					*(*TListRep)(unsafe.Pointer(rangeRepPtr)) = *(*TListRep)(unsafe.Pointer(srcRepPtr))
				} else {
					/* Span not present or is shared. */
					/* T:listrep-1.5,2.{5,7},4.{7,8} */
					(*TListRep)(unsafe.Pointer(rangeRepPtr)).FstorePtr = (*TListRep)(unsafe.Pointer(srcRepPtr)).FstorePtr
					(*TListRep)(unsafe.Pointer(rangeRepPtr)).FspanPtr = _ListSpanNew(tls, spanStart, rangeLen)
				}
				/*
				 * We have potentially created a new internal representation that
				 * references the same storage as srcRep but not yet incremented its
				 * reference count. So do NOT call freezombies if preserveSrcRep
				 * is mandated.
				 */
				if !(preserveSrcRep != 0) {
					/* T:listrep-1.{5.1,5.2,5.4},2.{5,7},3.{16,18},4.{7,8} */
					_ListRepFreeUnreferenced(tls, rangeRepPtr)
				}
			} else {
				if preserveSrcRep != 0 || (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FstorePtr)).FrefCount > uint64(1) {
					/* Option 3 - span or modification in place not allowed/desired */
					/* T:listrep-2.{4,6} */
					if (*TListRep)(unsafe.Pointer(srcRepPtr)).FspanPtr != 0 {
						v5 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FspanPtr)).FspanStart
					} else {
						v5 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FstorePtr)).FfirstUsed
					}
					srcElems = (*TListRep)(unsafe.Pointer(srcRepPtr)).FstorePtr + 40 + uintptr(v5)*8
					if (*TListRep)(unsafe.Pointer(srcRepPtr)).FspanPtr != 0 {
						v6 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FspanPtr)).FspanLength
					} else {
						v6 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FstorePtr)).FnumUsed
					}
					numSrcElems = v6
					/* TODO - allocate extra space? */
					_ListRepInit(tls, rangeLen, srcElems+uintptr(rangeStart)*8, int32(LISTREP_PANIC_ON_FAIL), rangeRepPtr)
				} else {
					/*
					 * Option 4 - modify in place. Note that because of the invariant
					 * that spanless list stores must start at 0, we have to move
					 * everything to the front.
					 * TODO - perhaps if a span already exists, no need to move to front?
					 * or maybe no need to move all the way to the front?
					 * TODO - if range is small relative to allocation, allocate new?
					 */
					/* Asserts follow from call to ListRepFreeUnreferenced earlier */
					if (*TListRep)(unsafe.Pointer(srcRepPtr)).FspanPtr != 0 {
						v7 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FspanPtr)).FspanStart
					} else {
						v7 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FstorePtr)).FfirstUsed
					}
					srcElems = (*TListRep)(unsafe.Pointer(srcRepPtr)).FstorePtr + 40 + uintptr(v7)*8
					if (*TListRep)(unsafe.Pointer(srcRepPtr)).FspanPtr != 0 {
						v8 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FspanPtr)).FspanLength
					} else {
						v8 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FstorePtr)).FnumUsed
					}
					numSrcElems = v8
					/* Free leading elements outside range */
					if rangeStart != 0 {
						/* T:listrep-1.4,3.15 */
						_ObjArrayDecrRefs(tls, srcElems, 0, rangeStart)
					}
					/* Ditto for trailing */
					numAfterRangeEnd = numSrcElems - (rangeEnd + int64(1))
					/* Assert: Because numSrcElems > rangeEnd earlier */
					if numAfterRangeEnd != 0 {
						/* T:listrep-3.17 */
						_ObjArrayDecrRefs(tls, srcElems, rangeEnd+int64(1), numAfterRangeEnd)
					}
					libc.Xmemmove(tls, (*TListRep)(unsafe.Pointer(srcRepPtr)).FstorePtr+40, (*TListRep)(unsafe.Pointer(srcRepPtr)).FstorePtr+40+uintptr((*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FstorePtr)).FfirstUsed+rangeStart)*8, libc.Uint64FromInt64(rangeLen)*uint64(8))
					(*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FstorePtr)).FfirstUsed = 0
					(*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FstorePtr)).FnumUsed = rangeLen
					(*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FstorePtr)).Fflags = 0
					if (*TListRep)(unsafe.Pointer(srcRepPtr)).FspanPtr != 0 {
						/* In case the source has a span, update it for consistency */
						/* T:listrep-3.{15,17} */
						(*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FspanPtr)).FspanStart = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FstorePtr)).FfirstUsed
						(*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FspanPtr)).FspanLength = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(srcRepPtr)).FstorePtr)).FnumUsed
					}
					(*TListRep)(unsafe.Pointer(rangeRepPtr)).FstorePtr = (*TListRep)(unsafe.Pointer(srcRepPtr)).FstorePtr
					(*TListRep)(unsafe.Pointer(rangeRepPtr)).FspanPtr = libc.UintptrFromInt32(0)
				}
			}
		}
	}
	/* TODO - call freezombies here if !preserveSrcRep? */
	/* Note ref counts intentionally not incremented */
	return
}

/*
 *----------------------------------------------------------------------
 *
 * TclListObjRange --
 *
 *	Makes a slice of a list value.
 *      *listObj must be known to be a valid list.
 *
 * Results:
 *	Returns a pointer to the sliced list.
 *      This may be a new object or the same object if not shared.
 *	Returns NULL if passed listObj was not a list and could not be
 *	converted to one.
 *
 * Side effects:
 *	The possible conversion of the object referenced by listPtr
 *	to a list object.
 *
 *----------------------------------------------------------------------
 */

func XTclListObjRange(tls *libc.TLS, interp uintptr, listObj uintptr, rangeStart TTcl_Size, rangeEnd TTcl_Size) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Index of last element to include. */
	var _isobjPtr, cachePtr uintptr
	var isShared int32
	var v1 bool
	var _ /* listRep at bp+0 */ TListRep
	var _ /* resultRep at bp+16 */ TListRep
	_, _, _, _ = _isobjPtr, cachePtr, isShared, v1
	if _TclListObjGetRep(tls, interp, listObj, bp) != TCL_OK {
		return libc.UintptrFromInt32(0)
	}
	isShared = libc.BoolInt32((*TTcl_Obj)(unsafe.Pointer(listObj)).FrefCount > int64(1))
	_ListRepRange(tls, bp, rangeStart, rangeEnd, isShared, bp+16)
	if isShared != 0 {
		/* T:listrep-1.10.1,2.{4.2,4.3,5.2,5.3,6.2,7.2,8.1} */
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			listObj = XTclThreadAllocObj(tls)
		} else {
			listObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(listObj)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(listObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(listObj)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr = libc.UintptrFromInt32(0)
	} /* T:listrep-1.{4.3,5.1,5.2} */
	(*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp+16)).FstorePtr)).FrefCount++
	if (*TListRep)(unsafe.Pointer(bp+16)).FspanPtr != 0 {
		(*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp+16)).FspanPtr)).FrefCount++
	}
	if (*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr != libc.UintptrFromInt32(0) {
		if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).FfreeIntRepProc})))(tls, listObj)
		}
		(*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr = libc.UintptrFromInt32(0)
	}
	_isobjPtr = listObj
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(listObj + 32))).Fptr1 = (*TListRep)(unsafe.Pointer(bp + 16)).FstorePtr
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(listObj + 32))).Fptr2 = (*TListRep)(unsafe.Pointer(bp + 16)).FspanPtr
	(*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr = uintptr(unsafe.Pointer(&XtclListType))
	return listObj
}

/*
 *----------------------------------------------------------------------
 *
 * TclListObjGetElement --
 *
 *	Returns a single element from the array of the elements in a list
 *	object, without doing any bounds checking.  Caller must ensure
 *	that ObjPtr of type 'tclListType' and that index is valid for the
 *	list.
 *
 *----------------------------------------------------------------------
 */

func XTclListObjGetElement(tls *libc.TLS, objPtr uintptr, index TTcl_Size) (r uintptr) {
	var v1 int64
	_ = v1
	if (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr2 != 0 {
		v1 = (*TListSpan)(unsafe.Pointer((*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr2)).FspanStart
	} else {
		v1 = (*TListStore)(unsafe.Pointer((*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1)).FfirstUsed
	}
	return *(*uintptr)(unsafe.Pointer((*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1 + 40 + uintptr(v1+index)*8))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ListObjGetElements --
 *
 *	This function returns an (objc,objv) array of the elements in a list
 *	object.
 *
 * Results:
 *	The return value is normally TCL_OK; in this case *objcPtr is set to
 *	the count of list elements and *objvPtr is set to a pointer to an
 *	array of (*objcPtr) pointers to each list element. If listPtr does not
 *	refer to a list object and the object can not be converted to one,
 *	TCL_ERROR is returned and an error message will be left in the
 *	interpreter's result if interp is not NULL.
 *
 *	The objects referenced by the returned array should be treated as
 *	readonly and their ref counts are _not_ incremented; the caller must
 *	do that if it holds on to a reference. Furthermore, the pointer and
 *	length returned by this function may change as soon as any function is
 *	called on the list object; be careful about retaining the pointer in a
 *	local data structure.
 *
 * Side effects:
 *	The possible conversion of the object referenced by listPtr
 *	to a list object.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ListObjGetElements(tls *libc.TLS, interp1 uintptr, objPtr1 uintptr, objcPtr uintptr, objvPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Where to store the pointer to an array of
	 * pointers to the list's objects. */
	var proc, v1, v2, v3 uintptr
	var v4 int32
	var v6, v7 int64
	var _ /* listRep at bp+0 */ TListRep
	_, _, _, _, _, _, _ = proc, v1, v2, v3, v4, v6, v7
	if (*TTcl_Obj)(unsafe.Pointer(objPtr1)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+80) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+80) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr1)).FtypePtr)).Fversion) {
		v1 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr1)).FtypePtr)).FgetElementsProc
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	if v1 != 0 {
		v2 = objPtr1
		if (*TTcl_Obj)(unsafe.Pointer(v2)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+80) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+80) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v2)).FtypePtr)).Fversion) {
			v3 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v2)).FtypePtr)).FgetElementsProc
		} else {
			v3 = libc.UintptrFromInt32(0)
		}
		proc = v3
		v4 = (*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{proc})))(tls, interp1, v2, objcPtr, objvPtr)
		goto _5
	_5:
		return v4
	}
	if _TclListObjGetRep(tls, interp1, objPtr1, bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if (*TListRep)(unsafe.Pointer(bp)).FspanPtr != 0 {
		v6 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FspanPtr)).FspanStart
	} else {
		v6 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FfirstUsed
	}
	*(*uintptr)(unsafe.Pointer(objvPtr)) = (*TListRep)(unsafe.Pointer(bp)).FstorePtr + 40 + uintptr(v6)*8
	if (*TListRep)(unsafe.Pointer(bp)).FspanPtr != 0 {
		v7 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FspanPtr)).FspanLength
	} else {
		v7 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FnumUsed
	}
	*(*TTcl_Size)(unsafe.Pointer(objcPtr)) = v7
	return TCL_OK
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * Tcl_ListObjAppendList --
//	 *
//	 *	This function appends the elements in the list fromObj
//	 *	to toObj. toObj must not be shared else the function will panic.
//	 *
//	 * Results:
//	 *	The return value is normally TCL_OK. If fromObj or toObj do not
//	 *	refer to list values, TCL_ERROR is returned and an error message is
//	 *	left in the interpreter's result if interp is not NULL.
//	 *
//	 * Side effects:
//	 *	The reference counts of the elements in fromObj are incremented
//	 *	since the list now refers to them. toObj and fromObj are
//	 *	converted, if necessary, to list objects. Also, appending the new
//	 *	elements may cause toObj's array of element pointers to grow.
//	 *	toObj's old string representation, if any, is invalidated.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func XTcl_ListObjAppendList(tls *libc.TLS, interp uintptr, toObj uintptr, fromObj uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* List obj with elements to append. */
	var v1 int32
	var v2, v3 int64
	var _ /* objc at bp+0 */ TTcl_Size
	var _ /* objv at bp+8 */ uintptr
	_, _, _ = v1, v2, v3
	if (*TTcl_Obj)(unsafe.Pointer(toObj)).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+10229, libc.VaList(bp+24, __ccgo_ts+52072))
	}
	if (*TTcl_Obj)(unsafe.Pointer(fromObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(fromObj + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(fromObj + 32))).Fptr2)).FspanStart
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(fromObj + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(fromObj + 32))).Fptr1 + 40 + uintptr(v2)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(fromObj + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(fromObj + 32))).Fptr2)).FspanLength
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(fromObj + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v3
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjGetElements(tls, interp, fromObj, bp, bp+8)
	}
	if v1 != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Insert the new elements starting after the lists's last element.
	 * Delete zero existing elements.
	 */
	return XTclListObjAppendElements(tls, interp, toObj, *(*TTcl_Size)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 8)))
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * TclListObjAppendElements --
//	 *
//	 *      Appends multiple elements to a Tcl_Obj list object. If
//	 *      the passed Tcl_Obj is not a list object, it will be converted to one
//	 *      and an error raised if the conversion fails.
//	 *
//	 *	The Tcl_Obj must not be shared though the internal representation
//	 *	may be.
//	 *
//	 * Results:
//	 *	On success, TCL_OK is returned with the specified elements appended.
//	 *	On failure, TCL_ERROR is returned with an error message in the
//	 *	interpreter if not NULL.
//	 *
//	 * Side effects:
//	 *    None.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func XTclListObjAppendElements(tls *libc.TLS, interp uintptr, toObj uintptr, elemCount TTcl_Size, elemObjv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Objects to append to toObj's list. */
	var _isobjPtr, _isobjPtr1, _isobjPtr2, newStorePtr, toObjv uintptr
	var finalLen, numTailFree, shiftCount, toLen TTcl_Size
	var v1, v2, v3, v4, v6, v7 int64
	var v5 int32
	var _ /* listRep at bp+0 */ TListRep
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _isobjPtr, _isobjPtr1, _isobjPtr2, finalLen, newStorePtr, numTailFree, shiftCount, toLen, toObjv, v1, v2, v3, v4, v5, v6, v7
	if (*TTcl_Obj)(unsafe.Pointer(toObj)).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+10229, libc.VaList(bp+24, __ccgo_ts+52094))
	}
	if _TclListObjGetRep(tls, interp, toObj, bp) != TCL_OK {
		/* Cannot be converted to a list */
		return int32(TCL_ERROR)
	}
	if elemCount <= 0 {
		/*
		 * Note that when elemCount <= 0, this routine is logically a
		 * no-op, removing and adding no elements to the list. However, by removing
		 * the string representation, we get the important side effect that the
		 * resulting listPtr is a list in canonical form. This is important.
		 * Resist any temptation to optimize this case further. See bug [e38dce74e2].
		 */
		if !((*TTcl_Obj)(unsafe.Pointer(toObj)).Fbytes == libc.UintptrFromInt32(0) || (*TListStore)(unsafe.Pointer((*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(toObj + 32))).Fptr1)).Fflags&int32(LISTSTORE_CANONICAL) != 0 || (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(toObj + 32))).Fptr2 != libc.UintptrFromInt32(0)) {
			_isobjPtr = toObj
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
				if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
			}
		}
		/* Nothing to do. Note AFTER check for list above */
		return TCL_OK
	}
	if (*TListRep)(unsafe.Pointer(bp)).FspanPtr != 0 {
		v1 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FspanPtr)).FspanStart
	} else {
		v1 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FfirstUsed
	}
	toObjv = (*TListRep)(unsafe.Pointer(bp)).FstorePtr + 40 + uintptr(v1)*8
	if (*TListRep)(unsafe.Pointer(bp)).FspanPtr != 0 {
		v2 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FspanPtr)).FspanLength
	} else {
		v2 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FnumUsed
	}
	toLen = v2
	if elemCount > libc.Int64FromUint64((libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))-uint64(libc.UintptrFromInt32(0)+40))/libc.Uint64FromInt64(8)) || toLen > libc.Int64FromUint64((libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))-uint64(libc.UintptrFromInt32(0)+40))/libc.Uint64FromInt64(8))-elemCount {
		return _ListLimitExceededError(tls, interp)
	}
	finalLen = toLen + elemCount
	if !((*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FrefCount > libc.Uint64FromInt32(1)) {
		_ListRepFreeUnreferenced(tls, bp) /* Collect garbage before checking room */
		if finalLen > (*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FnumAllocated {
			/* T:listrep-1.{2,11},3.6 */
			newStorePtr = _ListStoreReallocate(tls, (*(*TListRep)(unsafe.Pointer(bp))).FstorePtr, finalLen)
			if newStorePtr == libc.UintptrFromInt32(0) {
				return _MemoryAllocationError(tls, interp, libc.Uint64FromInt64(libc.Int64FromUint64(uint64(libc.UintptrFromInt32(0)+40)+libc.Uint64FromInt64(finalLen)*libc.Uint64FromInt64(8))))
			}
			(*(*TListRep)(unsafe.Pointer(bp))).FstorePtr = newStorePtr
			/*
			 * WARNING: at this point the Tcl_Obj internal rep potentially
			 * points to freed storage if the reallocation returned a
			 * different location. Overwrite it to bring it back in sync.
			 */
			(*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(toObj + 32))).Fptr1 = (*TListRep)(unsafe.Pointer(bp)).FstorePtr
			(*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(toObj + 32))).Fptr2 = (*TListRep)(unsafe.Pointer(bp)).FspanPtr
			(*TTcl_Obj)(unsafe.Pointer(toObj)).FtypePtr = uintptr(unsafe.Pointer(&XtclListType))
		} /* else T:listrep-3.{4,5} */
		/* Current store big enough */
		numTailFree = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FnumAllocated - ((*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FfirstUsed + (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FnumUsed)
		/* Total free */
		if numTailFree < elemCount {
			/* Not enough room at back. Move some to front */
			/* T:listrep-3.5 */
			shiftCount = elemCount - numTailFree
			/* Divide remaining space between front and back */
			shiftCount += ((*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FnumAllocated - finalLen) / int64(2)
			if shiftCount != 0 {
				/* T:listrep-3.5 */
				_ListRepUnsharedShiftDown(tls, bp, shiftCount)
			}
		} /* else T:listrep-3.{4,6} */
		if (*TListRep)(unsafe.Pointer(bp)).FspanPtr != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FspanPtr)).FspanStart
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FfirstUsed
		}
		if (*TListRep)(unsafe.Pointer(bp)).FspanPtr != 0 {
			v4 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FspanPtr)).FspanLength
		} else {
			v4 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FnumUsed
		}
		_ObjArrayCopy(tls, (*(*TListRep)(unsafe.Pointer(bp))).FstorePtr+40+uintptr(v3+v4)*8, elemCount, elemObjv)
		(*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FnumUsed = finalLen
		if (*(*TListRep)(unsafe.Pointer(bp))).FspanPtr != 0 {
			/* T:listrep-3.{4,5,6} */
			(*TListSpan)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FspanPtr)).FspanLength = finalLen
		} /* else T:listrep-3.6.3 */
		(*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FrefCount++
		if (*TListRep)(unsafe.Pointer(bp)).FspanPtr != 0 {
			(*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FspanPtr)).FrefCount++
		}
		if (*TTcl_Obj)(unsafe.Pointer(toObj)).FtypePtr != libc.UintptrFromInt32(0) {
			if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(toObj)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
				(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(toObj)).FtypePtr)).FfreeIntRepProc})))(tls, toObj)
			}
			(*TTcl_Obj)(unsafe.Pointer(toObj)).FtypePtr = libc.UintptrFromInt32(0)
		}
		_isobjPtr1 = toObj
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes = libc.UintptrFromInt32(0)
		}
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(toObj + 32))).Fptr1 = (*TListRep)(unsafe.Pointer(bp)).FstorePtr
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(toObj + 32))).Fptr2 = (*TListRep)(unsafe.Pointer(bp)).FspanPtr
		(*TTcl_Obj)(unsafe.Pointer(toObj)).FtypePtr = uintptr(unsafe.Pointer(&XtclListType))
		return TCL_OK
	}
	/*
	 * Have to make a new list rep, either shared or no room in old one.
	 * If the old list did not have a span (all elements at front), do
	 * not leave space in the front either, assuming all appends and no
	 * prepends.
	 */
	if (*(*TListRep)(unsafe.Pointer(bp))).FspanPtr != 0 {
		v5 = int32(LISTREP_SPACE_FAVOR_BACK)
	} else {
		v5 = int32(LISTREP_SPACE_ONLY_BACK)
	}
	if _ListRepInit(tls, finalLen, libc.UintptrFromInt32(0), v5, bp) != TCL_OK {
		return _MemoryAllocationError(tls, interp, libc.Uint64FromInt64(finalLen))
	}
	if toLen != 0 {
		/* T:listrep-2.{2,9},4.5 */
		if (*TListRep)(unsafe.Pointer(bp)).FspanPtr != 0 {
			v6 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FspanPtr)).FspanStart
		} else {
			v6 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FfirstUsed
		}
		_ObjArrayCopy(tls, (*TListRep)(unsafe.Pointer(bp)).FstorePtr+40+uintptr(v6+int64(libc.Int32FromInt32(0)))*8, toLen, toObjv)
	}
	if (*TListRep)(unsafe.Pointer(bp)).FspanPtr != 0 {
		v7 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FspanPtr)).FspanStart
	} else {
		v7 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FfirstUsed
	}
	_ObjArrayCopy(tls, (*TListRep)(unsafe.Pointer(bp)).FstorePtr+40+uintptr(v7+toLen)*8, elemCount, elemObjv)
	(*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FnumUsed = finalLen
	if (*(*TListRep)(unsafe.Pointer(bp))).FspanPtr != 0 {
		/* T:listrep-4.5 */
		(*TListSpan)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FspanPtr)).FspanLength = finalLen
	}
	(*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FrefCount++
	if (*TListRep)(unsafe.Pointer(bp)).FspanPtr != 0 {
		(*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FspanPtr)).FrefCount++
	}
	if (*TTcl_Obj)(unsafe.Pointer(toObj)).FtypePtr != libc.UintptrFromInt32(0) {
		if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(toObj)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(toObj)).FtypePtr)).FfreeIntRepProc})))(tls, toObj)
		}
		(*TTcl_Obj)(unsafe.Pointer(toObj)).FtypePtr = libc.UintptrFromInt32(0)
	}
	_isobjPtr2 = toObj
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr2)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr2)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr2)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr2)).Fbytes = libc.UintptrFromInt32(0)
	}
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(toObj + 32))).Fptr1 = (*TListRep)(unsafe.Pointer(bp)).FstorePtr
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(toObj + 32))).Fptr2 = (*TListRep)(unsafe.Pointer(bp)).FspanPtr
	(*TTcl_Obj)(unsafe.Pointer(toObj)).FtypePtr = uintptr(unsafe.Pointer(&XtclListType))
	return TCL_OK
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * Tcl_ListObjAppendElement --
//	 *
//	 *	Like 'Tcl_ListObjAppendList', but Appends a single value to a list.
//	 *
//	 * Value
//	 *
//	 *	TCL_OK
//	 *
//	 *	    'objPtr' is appended to the elements of 'listPtr'.
//	 *
//	 *	TCL_ERROR
//	 *
//	 *	    listPtr does not refer to a list object and the object can not be
//	 *	    converted to one. An error message will be left in the
//	 *	    interpreter's result if interp is not NULL.
//	 *
//	 * Effect
//	 *
//	 *	If 'listPtr' is not already of type 'tclListType', it is converted.
//	 *	The 'refCount' of 'objPtr' is incremented as it is added to 'listPtr'.
//	 *	Appending the new element may cause the array of element pointers
//	 *	in 'listObj' to grow.  Any preexisting string representation of
//	 *	'listPtr' is invalidated.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func XTcl_ListObjAppendElement(tls *libc.TLS, interp uintptr, toObj uintptr, _elemObj uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	*(*uintptr)(unsafe.Pointer(bp)) = _elemObj /* Object to append to toObj's list. */
	/*
	 * TODO - compare perf with 8.6 to see if worth optimizing single
	 * element case
	 */
	return XTclListObjAppendElements(tls, interp, toObj, int64(1), bp)
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * Tcl_ListObjIndex --
//	 *
//	 *	Retrieve a pointer to the element of 'listPtr' at 'index'.  The index
//	 *	of the first element is 0.
//	 *
//	 * Returns:
//	 *	TCL_OK
//	 *	    A pointer to the element at 'index' is stored in 'objPtrPtr'.  If
//	 *	    'index' is out of range, NULL is stored in 'objPtrPtr'.  This
//	 *	    object should be treated as readonly and its 'refCount' is _not_
//	 *	    incremented. The caller must do that if it holds on to the
//	 *	    reference.
//	 *
//	 *	TCL_ERROR
//	 *	    'listPtr' is not a valid list. An error message is left in the
//	 *	    interpreter's result if 'interp' is not NULL.
//	 *
//	 * Effect:
//	 *	If 'listPtr' is not already of type 'tclListType', it is converted.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func XTcl_ListObjIndex(tls *libc.TLS, interp1 uintptr, listObj uintptr, index1 TTcl_Size, objPtrPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The resulting Tcl_Obj* is stored here. */
	var hasAbstractList, v4, v6 int32
	var proc, v1, v2, v3 uintptr
	var v7, v8 int64
	var _ /* elemObjs at bp+0 */ uintptr
	var _ /* numElems at bp+8 */ TTcl_Size
	_, _, _, _, _, _, _, _, _ = hasAbstractList, proc, v1, v2, v3, v4, v6, v7, v8
	/* Empty string => empty list. Avoid unnecessary shimmering */
	if (*TTcl_Obj)(unsafe.Pointer(listObj)).Fbytes == uintptr(unsafe.Pointer(&XtclEmptyString)) {
		*(*uintptr)(unsafe.Pointer(objPtrPtr)) = libc.UintptrFromInt32(0)
		return TCL_OK
	}
	if (*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+56) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+56) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).Fversion) {
		v1 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).FindexProc
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	hasAbstractList = libc.BoolInt32(v1 != uintptr(0))
	if hasAbstractList != 0 {
		v2 = listObj
		if (*TTcl_Obj)(unsafe.Pointer(v2)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+56) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+56) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v2)).FtypePtr)).Fversion) {
			v3 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v2)).FtypePtr)).FindexProc
		} else {
			v3 = libc.UintptrFromInt32(0)
		}
		proc = v3
		v4 = (*(*func(*libc.TLS, uintptr, uintptr, TTcl_Size, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{proc})))(tls, interp1, v2, index1, objPtrPtr)
		goto _5
	_5:
		return v4
	}
	if (*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listObj + 32))).Fptr2 != 0 {
			v7 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr2)).FspanStart
		} else {
			v7 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listObj + 32))).Fptr1 + 40 + uintptr(v7)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listObj + 32))).Fptr2 != 0 {
			v8 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr2)).FspanLength
		} else {
			v8 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v8
		v6 = libc.Int32FromInt32(TCL_OK)
	} else {
		v6 = XTcl_ListObjGetElements(tls, interp1, listObj, bp+8, bp)
	}
	if v6 != TCL_OK {
		return int32(TCL_ERROR)
	}
	if index1 < 0 || index1 >= *(*TTcl_Size)(unsafe.Pointer(bp + 8)) {
		*(*uintptr)(unsafe.Pointer(objPtrPtr)) = libc.UintptrFromInt32(0)
	} else {
		*(*uintptr)(unsafe.Pointer(objPtrPtr)) = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(index1)*8))
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ListObjLength --
 *
 *	This function returns the number of elements in a list object. If the
 *	object is not already a list object, an attempt will be made to
 *	convert it to one.
 *
 * Results:
 *	The return value is normally TCL_OK; in this case *lenPtr will be set
 *	to the integer count of list elements. If listPtr does not refer to a
 *	list object and the object can not be converted to one, TCL_ERROR is
 *	returned and an error message will be left in the interpreter's result
 *	if interp is not NULL.
 *
 * Side effects:
 *	The possible conversion of the argument object to a list object.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ListObjLength(tls *libc.TLS, interp uintptr, listObj uintptr, lenPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The resulting length is stored here. */
	var proc, v1, v2, v3 uintptr
	var v4 TTcl_Size
	var v6 int64
	var _ /* listRep at bp+0 */ TListRep
	_, _, _, _, _, _ = proc, v1, v2, v3, v4, v6
	/* Empty string => empty list. Avoid unnecessary shimmering */
	if (*TTcl_Obj)(unsafe.Pointer(listObj)).Fbytes == uintptr(unsafe.Pointer(&XtclEmptyString)) {
		*(*TTcl_Size)(unsafe.Pointer(lenPtr)) = 0
		return TCL_OK
	}
	if (*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+48) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+48) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).Fversion) {
		v1 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).FlengthProc
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	if v1 != 0 {
		v2 = listObj
		if (*TTcl_Obj)(unsafe.Pointer(v2)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+48) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+48) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v2)).FtypePtr)).Fversion) {
			v3 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v2)).FtypePtr)).FlengthProc
		} else {
			v3 = libc.UintptrFromInt32(0)
		}
		proc = v3
		v4 = (*(*func(*libc.TLS, uintptr) TTcl_Size)(unsafe.Pointer(&struct{ uintptr }{proc})))(tls, v2)
		goto _5
	_5:
		*(*TTcl_Size)(unsafe.Pointer(lenPtr)) = v4
		return TCL_OK
	}
	if _TclListObjGetRep(tls, interp, listObj, bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if (*TListRep)(unsafe.Pointer(bp)).FspanPtr != 0 {
		v6 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FspanPtr)).FspanLength
	} else {
		v6 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FnumUsed
	}
	*(*TTcl_Size)(unsafe.Pointer(lenPtr)) = v6
	return TCL_OK
}

func _ListLength(tls *libc.TLS, listPtr uintptr) (r TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var v1 int64
	var _ /* listRep at bp+0 */ TListRep
	_ = v1
	(*TListRep)(unsafe.Pointer(bp)).FstorePtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(listPtr + 32))).Fptr1
	(*TListRep)(unsafe.Pointer(bp)).FspanPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(listPtr + 32))).Fptr2
	if (*TListRep)(unsafe.Pointer(bp)).FspanPtr != 0 {
		v1 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FspanPtr)).FspanLength
	} else {
		v1 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FnumUsed
	}
	return v1
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * Tcl_ListObjReplace --
//	 *
//	 *	This function replaces zero or more elements of the list referenced by
//	 *	listObj with the objects from an (objc,objv) array. The objc elements
//	 *	of the array referenced by objv replace the count elements in listPtr
//	 *	starting at first.
//	 *
//	 *	If the argument first is zero or negative, it refers to the first
//	 *	element. If first is greater than or equal to the number of elements
//	 *	in the list, then no elements are deleted; the new elements are
//	 *	appended to the list. Count gives the number of elements to replace.
//	 *	If count is zero or negative then no elements are deleted; the new
//	 *	elements are simply inserted before first.
//	 *
//	 *	The argument objv refers to an array of objc pointers to the new
//	 *	elements to be added to listPtr in place of those that were deleted.
//	 *	If objv is NULL, no new elements are added. If listPtr is not a list
//	 *	object, an attempt will be made to convert it to one.
//	 *
//	 * Results:
//	 *	The return value is normally TCL_OK. If listPtr does not refer to a
//	 *	list object and can not be converted to one, TCL_ERROR is returned and
//	 *	an error message will be left in the interpreter's result if interp is
//	 *	not NULL.
//	 *
//	 * Side effects:
//	 *	The ref counts of the objc elements in objv are incremented since the
//	 *	resulting list now refers to them. Similarly, the ref counts for
//	 *	replaced objects are decremented. listObj is converted, if necessary,
//	 *	to a list object. listObj's old string representation, if any, is
//	 *	freed.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func XTcl_ListObjReplace(tls *libc.TLS, interp1 uintptr, listObj uintptr, first1 TTcl_Size, numToDelete1 TTcl_Size, numToInsert1 TTcl_Size, insertObjs1 uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* Tcl objects to insert */
	var _isobjPtr, _isobjPtr1, _isobjPtr2, _isobjPtr3, _isobjPtr4, _isobjPtr5, listObjs, newStorePtr, proc, toObjs, v1, v2, v3 uintptr
	var extraShift, extraShift1, finalFreeSpace, leadSegmentLen, leadShift, leadSpace, lenChange, newLen, numFreeSlots, origListLen, postShiftLeadSpace, postShiftTailSpace, tailSegmentLen, tailShift, tailSpace, tailStart, tailStart1 TTcl_Size
	var favor, v4 int32
	var v10, v11, v6, v7, v9 int64
	var v8 bool
	var _ /* headRep at bp+32 */ TListRep
	var _ /* listRep at bp+0 */ TListRep
	var _ /* newRep at bp+48 */ TListRep
	var _ /* tailRep at bp+16 */ TListRep
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _isobjPtr, _isobjPtr1, _isobjPtr2, _isobjPtr3, _isobjPtr4, _isobjPtr5, extraShift, extraShift1, favor, finalFreeSpace, leadSegmentLen, leadShift, leadSpace, lenChange, listObjs, newLen, newStorePtr, numFreeSlots, origListLen, postShiftLeadSpace, postShiftTailSpace, proc, tailSegmentLen, tailShift, tailSpace, tailStart, tailStart1, toObjs, v1, v10, v11, v2, v3, v4, v6, v7, v8, v9
	if (*TTcl_Obj)(unsafe.Pointer(listObj)).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+10229, libc.VaList(bp+72, __ccgo_ts+52119))
	}
	if (*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+96) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+96) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).Fversion) {
		v1 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).FreplaceProc
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	if v1 != 0 {
		v2 = listObj
		if (*TTcl_Obj)(unsafe.Pointer(v2)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+96) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+96) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v2)).FtypePtr)).Fversion) {
			v3 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v2)).FtypePtr)).FreplaceProc
		} else {
			v3 = libc.UintptrFromInt32(0)
		}
		proc = v3
		v4 = (*(*func(*libc.TLS, uintptr, uintptr, TTcl_Size, TTcl_Size, TTcl_Size, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{proc})))(tls, interp1, v2, first1, numToDelete1, numToInsert1, insertObjs1)
		goto _5
	_5:
		return v4
	}
	if _TclListObjGetRep(tls, interp1, listObj, bp) != TCL_OK {
		/* Cannot be converted to a list */
		return int32(TCL_ERROR)
	}
	/* Make limits sane */
	if (*TListRep)(unsafe.Pointer(bp)).FspanPtr != 0 {
		v6 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FspanPtr)).FspanLength
	} else {
		v6 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FnumUsed
	}
	origListLen = v6
	if first1 < 0 {
		first1 = 0
	}
	if first1 > origListLen {
		first1 = origListLen /* So we'll insert after last element. */
	}
	if numToDelete1 < 0 {
		numToDelete1 = 0
	} else {
		if first1 > libc.Int64FromUint64((libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))-uint64(libc.UintptrFromInt32(0)+40))/libc.Uint64FromInt64(8))-numToDelete1 || origListLen < first1+numToDelete1 {
			numToDelete1 = origListLen - first1
		}
	}
	if numToInsert1 > libc.Int64FromUint64((libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))-uint64(libc.UintptrFromInt32(0)+40))/libc.Uint64FromInt64(8))-(origListLen-numToDelete1) {
		return _ListLimitExceededError(tls, interp1)
	}
	if first1+numToDelete1 >= origListLen {
		/* Operating at back of list. Favor leaving space at back */
		favor = int32(LISTREP_SPACE_FAVOR_BACK)
	} else {
		if first1 == 0 {
			/* Operating on front of list. Favor leaving space in front */
			favor = int32(LISTREP_SPACE_FAVOR_FRONT)
		} else {
			/* Operating on middle of list. */
			favor = libc.Int32FromInt32(LISTREP_SPACE_FAVOR_FRONT) | libc.Int32FromInt32(LISTREP_SPACE_FAVOR_BACK)
		}
	}
	/*
	 * There are a number of special cases to consider from an optimization
	 * point of view.
	 * (1) Pure deletes (numToInsert==0) from the front or back can be treated
	 * as a range op irrespective of whether the ListStore is shared or not
	 * (2) Pure inserts (numToDelete == 0)
	 *   (2a) Pure inserts at the back can be treated as appends
	 *   (2b) Pure inserts from the *front* can be optimized under certain
	 *   conditions by inserting before first ListStore slot in use if there
	 *   is room, again irrespective of sharing
	 * (3) If the ListStore is shared OR there is insufficient free space
	 * OR existing allocation is too large compared to new size, create
	 * a new ListStore
	 * (4) Unshared ListStore with sufficient free space. Delete, shift and
	 * insert within the ListStore.
	 */
	/* Note: do not do TclInvalidateStringRep as yet in case there are errors */
	/* Check Case (1) - Treat pure deletes from front or back as range ops */
	if numToInsert1 == 0 {
		if numToDelete1 == 0 {
			/*
			 * Should force canonical even for no-op. Remember Tcl_Obj unshared
			 * so OK to invalidate string rep
			 */
			/* T:listrep-1.10,2.8 */
			_isobjPtr = listObj
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
				if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
			}
			return TCL_OK
		}
		if first1 == 0 {
			_ListRepRange(tls, bp, numToDelete1, origListLen-int64(1), 0, bp+16)
			(*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp+16)).FstorePtr)).FrefCount++
			if (*TListRep)(unsafe.Pointer(bp+16)).FspanPtr != 0 {
				(*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp+16)).FspanPtr)).FrefCount++
			}
			if (*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr != libc.UintptrFromInt32(0) {
				if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
					(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).FfreeIntRepProc})))(tls, listObj)
				}
				(*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr = libc.UintptrFromInt32(0)
			}
			_isobjPtr1 = listObj
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes != libc.UintptrFromInt32(0) {
				if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes = libc.UintptrFromInt32(0)
			}
			(*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr1 = (*TListRep)(unsafe.Pointer(bp + 16)).FstorePtr
			(*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr2 = (*TListRep)(unsafe.Pointer(bp + 16)).FspanPtr
			(*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr = uintptr(unsafe.Pointer(&XtclListType))
			return TCL_OK
		} else {
			if first1+numToDelete1 >= origListLen {
				_ListRepRange(tls, bp, 0, first1-int64(1), 0, bp+32)
				(*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp+32)).FstorePtr)).FrefCount++
				if (*TListRep)(unsafe.Pointer(bp+32)).FspanPtr != 0 {
					(*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp+32)).FspanPtr)).FrefCount++
				}
				if (*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr != libc.UintptrFromInt32(0) {
					if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
						(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).FfreeIntRepProc})))(tls, listObj)
					}
					(*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr = libc.UintptrFromInt32(0)
				}
				_isobjPtr2 = listObj
				if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr2)).Fbytes != libc.UintptrFromInt32(0) {
					if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr2)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr2)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(_isobjPtr2)).Fbytes = libc.UintptrFromInt32(0)
				}
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr1 = (*TListRep)(unsafe.Pointer(bp + 32)).FstorePtr
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr2 = (*TListRep)(unsafe.Pointer(bp + 32)).FspanPtr
				(*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr = uintptr(unsafe.Pointer(&XtclListType))
				return TCL_OK
			}
		}
		/* Deletion from middle. Fall through to general case */
	}
	/* Garbage collect before checking the pure insert optimization */
	_ListRepFreeUnreferenced(tls, bp)
	/*
	 * Check Case (2) - pure inserts under certain conditions:
	 */
	if numToDelete1 == 0 {
		/* Case (2a) - Append to list. */
		if first1 == origListLen {
			/* T:listrep-1.11,2.9,3.{5,6},2.2.1 */
			return XTclListObjAppendElements(tls, interp1, listObj, numToInsert1, insertObjs1)
		}
		/*
		 * Case (2b) - pure inserts at front under some circumstances
		 * (i) Insertion must be at head of list
		 * (ii) The list's span must be at head of the in-use slots in the store
		 * (iii) There must be unused room at front of the store
		 * NOTE THIS IS TRUE EVEN IF THE ListStore IS SHARED as it will not
		 * affect the other Tcl_Obj's referencing this ListStore.
		 */
		if v8 = first1 == 0; v8 {
			if (*TListRep)(unsafe.Pointer(bp)).FspanPtr != 0 {
				v7 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FspanPtr)).FspanStart
			} else {
				v7 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FfirstUsed
			}
		}
		if v8 && v7 == (*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FfirstUsed && numToInsert1 <= (*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FfirstUsed {
			/* Else would have returned above */
			*(*TTcl_Size)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)) -= numToInsert1
			_ObjArrayCopy(tls, (*(*TListRep)(unsafe.Pointer(bp))).FstorePtr+40+uintptr((*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FfirstUsed)*8, numToInsert1, insertObjs1)
			*(*TTcl_Size)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr + 8)) += numToInsert1
			newLen = (*TListSpan)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FspanPtr)).FspanLength + numToInsert1
			if (*(*TListRep)(unsafe.Pointer(bp))).FspanPtr != 0 && (*TListSpan)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FspanPtr)).FrefCount <= uint64(1) {
				/* An unshared span record, re-use it */
				/* T:listrep-3.1 */
				(*TListSpan)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FspanPtr)).FspanStart = (*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FfirstUsed
				(*TListSpan)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FspanPtr)).FspanLength = newLen
			} else {
				/* Need a new span record */
				if (*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FfirstUsed == 0 {
					(*(*TListRep)(unsafe.Pointer(bp))).FspanPtr = libc.UintptrFromInt32(0)
				} else {
					/* T:listrep-4.3 */
					(*(*TListRep)(unsafe.Pointer(bp))).FspanPtr = _ListSpanNew(tls, (*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FfirstUsed, newLen)
				}
			}
			(*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FrefCount++
			if (*TListRep)(unsafe.Pointer(bp)).FspanPtr != 0 {
				(*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FspanPtr)).FrefCount++
			}
			if (*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr != libc.UintptrFromInt32(0) {
				if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
					(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).FfreeIntRepProc})))(tls, listObj)
				}
				(*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr = libc.UintptrFromInt32(0)
			}
			_isobjPtr3 = listObj
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr3)).Fbytes != libc.UintptrFromInt32(0) {
				if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr3)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr3)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(_isobjPtr3)).Fbytes = libc.UintptrFromInt32(0)
			}
			(*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr1 = (*TListRep)(unsafe.Pointer(bp)).FstorePtr
			(*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr2 = (*TListRep)(unsafe.Pointer(bp)).FspanPtr
			(*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr = uintptr(unsafe.Pointer(&XtclListType))
			return TCL_OK
		}
	}
	/* Just for readability of the code */
	lenChange = numToInsert1 - numToDelete1
	leadSegmentLen = first1
	tailSegmentLen = origListLen - (first1 + numToDelete1)
	numFreeSlots = (*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FnumAllocated - (*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FnumUsed
	/*
	 * Before further processing, if unshared, try and reallocate to avoid
	 * new allocation below. This avoids expensive ref count manipulation
	 * later by not having to go through the ListRepInit and
	 * ListObjReplaceAndInvalidate below.
	 * TODO - we could be smarter about the reallocate. Use of realloc
	 * means all new free space is at the back. Instead, the realloc could
	 * be an explicit alloc and memmove which would let us redistribute
	 * free space.
	 */
	if numFreeSlots < lenChange && !((*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FrefCount > libc.Uint64FromInt32(1)) {
		/* T:listrep-1.{1,3,14,18,21},3.{3,10,11,14,27,32,41} */
		newStorePtr = _ListStoreReallocate(tls, (*(*TListRep)(unsafe.Pointer(bp))).FstorePtr, origListLen+lenChange)
		if newStorePtr == libc.UintptrFromInt32(0) {
			return _MemoryAllocationError(tls, interp1, libc.Uint64FromInt64(libc.Int64FromUint64(uint64(libc.UintptrFromInt32(0)+40)+libc.Uint64FromInt64(origListLen+lenChange)*libc.Uint64FromInt64(8))))
		}
		(*(*TListRep)(unsafe.Pointer(bp))).FstorePtr = newStorePtr
		numFreeSlots = (*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FnumAllocated - (*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FnumUsed
		/*
		 * WARNING: at this point the Tcl_Obj internal rep potentially
		 * points to freed storage if the reallocation returned a
		 * different location. Overwrite it to bring it back in sync.
		 */
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listObj + 32))).Fptr1 = (*TListRep)(unsafe.Pointer(bp)).FstorePtr
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listObj + 32))).Fptr2 = (*TListRep)(unsafe.Pointer(bp)).FspanPtr
		(*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr = uintptr(unsafe.Pointer(&XtclListType))
	}
	/*
	 * Case (3) a new ListStore is required
	 * (a) The passed-in ListStore is shared
	 * (b) There is not enough free space in the unshared passed-in ListStore
	 * (c) The new unshared size is much "smaller" (TODO) than the allocated space
	 * TODO - for unshared case ONLY, consider a "move" based implementation
	 */
	if (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FrefCount > uint64(1) || numFreeSlots < lenChange || origListLen+lenChange < (*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FnumAllocated/int64(4) {
		if (*TListRep)(unsafe.Pointer(bp)).FspanPtr != 0 {
			v9 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FspanPtr)).FspanStart
		} else {
			v9 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FfirstUsed
		}
		listObjs = (*(*TListRep)(unsafe.Pointer(bp))).FstorePtr + 40 + uintptr(v9)*8
		_ListRepInit(tls, origListLen+lenChange, libc.UintptrFromInt32(0), int32(LISTREP_PANIC_ON_FAIL)|favor, bp+48)
		if (*TListRep)(unsafe.Pointer(bp+48)).FspanPtr != 0 {
			v10 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp + 48)).FspanPtr)).FspanStart
		} else {
			v10 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp + 48)).FstorePtr)).FfirstUsed
		}
		toObjs = (*TListRep)(unsafe.Pointer(bp+48)).FstorePtr + 40 + uintptr(v10+int64(libc.Int32FromInt32(0)))*8
		if leadSegmentLen > 0 {
			/* T:listrep-2.{2,3,13:18},4.{6,9,13:18} */
			_ObjArrayCopy(tls, toObjs, leadSegmentLen, listObjs)
		}
		if numToInsert1 > 0 {
			/* T:listrep-2.{1,2,3,10:18},4.{1,2,4,6,10:18} */
			_ObjArrayCopy(tls, toObjs+uintptr(leadSegmentLen)*8, numToInsert1, insertObjs1)
		}
		if tailSegmentLen > 0 {
			/* T:listrep-2.{1,2,3,10:15},4.{1,2,4,6,9:12,16:18} */
			_ObjArrayCopy(tls, toObjs+uintptr(leadSegmentLen+numToInsert1)*8, tailSegmentLen, listObjs+uintptr(leadSegmentLen+numToDelete1)*8)
		}
		(*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp + 48))).FstorePtr)).FnumUsed = origListLen + lenChange
		if (*(*TListRep)(unsafe.Pointer(bp + 48))).FspanPtr != 0 {
			/* T:listrep-2.{1,2,3,10:18},4.{1,2,4,6,9:18} */
			(*TListSpan)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp + 48))).FspanPtr)).FspanLength = (*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp + 48))).FstorePtr)).FnumUsed
		}
		(*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp+48)).FstorePtr)).FrefCount++
		if (*TListRep)(unsafe.Pointer(bp+48)).FspanPtr != 0 {
			(*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp+48)).FspanPtr)).FrefCount++
		}
		if (*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr != libc.UintptrFromInt32(0) {
			if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
				(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).FfreeIntRepProc})))(tls, listObj)
			}
			(*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr = libc.UintptrFromInt32(0)
		}
		_isobjPtr4 = listObj
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr4)).Fbytes != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr4)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr4)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(_isobjPtr4)).Fbytes = libc.UintptrFromInt32(0)
		}
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listObj + 32))).Fptr1 = (*TListRep)(unsafe.Pointer(bp + 48)).FstorePtr
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listObj + 32))).Fptr2 = (*TListRep)(unsafe.Pointer(bp + 48)).FspanPtr
		(*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr = uintptr(unsafe.Pointer(&XtclListType))
		return TCL_OK
	}
	/*
	 * Case (4) - unshared ListStore with sufficient room.
	 * After deleting elements, there will be a corresponding gap. If this
	 * gap does not match number of insertions, either the lead segment,
	 * or the tail segment, or both will have to be moved.
	 * The general strategy is to move the fewest number of elements. If
	 *
	 * TODO - what about appends to unshared ? Is below sufficiently optimal?
	 */
	/* Following must hold for unshared listreps after ListRepFreeUnreferenced above */
	/* Base of slot array holding the list elements */
	if (*TListRep)(unsafe.Pointer(bp)).FspanPtr != 0 {
		v11 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FspanPtr)).FspanStart
	} else {
		v11 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FfirstUsed
	}
	listObjs = (*(*TListRep)(unsafe.Pointer(bp))).FstorePtr + 40 + uintptr(v11)*8
	/*
	 * Free up elements to be deleted. Before that, increment the ref counts
	 * for objects to be inserted in case there is overlap. T:listobj-11.1
	 */
	if numToInsert1 != 0 {
		/* T:listrep-1.{1,3,12:21},3.{2,3,7:14,23:41} */
		_ObjArrayIncrRefs(tls, insertObjs1, 0, numToInsert1)
	}
	if numToDelete1 != 0 {
		/* T:listrep-1.{6,7,12:21},3.{19:41} */
		_ObjArrayDecrRefs(tls, listObjs, first1, numToDelete1)
	}
	/*
	 * TODO - below the moves are optimized but this may result in needing a
	 * span allocation. Perhaps for small lists, it may be more efficient to
	 * just move everything up front and save on allocating a span.
	 */
	/*
	 * Calculate shifts if necessary to accommodate insertions.
	 * NOTE: all indices are relative to listObjs which is not necessarily the
	 * start of the ListStore storage area.
	 *
	 * leadShift - how much to shift the lead segment
	 * tailShift - how much to shift the tail segment
	 * insertTarget - index where to insert.
	 */
	if lenChange == 0 {
		/* T:listrep-1.{12,15,19},3.{23,28,33}. Exact fit */
		leadShift = 0
		tailShift = 0
	} else {
		if lenChange < 0 {
			/*
			 * More deletions than insertions. The gap after deletions is large
			 * enough for insertions. Move a segment depending on size.
			 */
			if leadSegmentLen > tailSegmentLen {
				/* Tail segment smaller. Insert after lead, move tail down */
				/* T:listrep-1.{7,17,20},3.{21,2229,35} */
				leadShift = 0
				tailShift = lenChange
			} else {
				/* Lead segment smaller. Insert before tail, move lead up */
				/* T:listrep-1.{6,13,16},3.{19,20,24,34} */
				leadShift = -lenChange
				tailShift = 0
			}
		} else {
			/* Reminder */
			/*
			 * We need to make room for the insertions. Again we have multiple
			 * possibilities. We may be able to get by just shifting one segment
			 * or need to shift both. In the former case, favor shifting the
			 * smaller segment.
			 */
			leadSpace = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FfirstUsed
			tailSpace = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FnumAllocated - ((*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FfirstUsed + (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FnumUsed)
			finalFreeSpace = leadSpace + tailSpace - lenChange
			if leadSpace >= lenChange && (leadSegmentLen < tailSegmentLen || tailSpace < lenChange) {
				/* Move only lead to the front to make more room */
				/* T:listrep-3.25,36,38, */
				leadShift = -lenChange
				tailShift = 0
				/*
				 * Redistribute the remaining free space between the front and
				 * back if either there is no tail space left or if the
				 * entire list is the head anyways. This is an important
				 * optimization for further operations like further asymmetric
				 * insertions.
				 */
				if finalFreeSpace > int64(1) && (tailSpace == 0 || tailSegmentLen == 0) {
					postShiftLeadSpace = leadSpace - lenChange
					if postShiftLeadSpace > finalFreeSpace/int64(2) {
						extraShift = postShiftLeadSpace - finalFreeSpace/int64(2)
						leadShift -= extraShift
						tailShift = -extraShift /* Move tail to the front as well */
					}
				} /* else T:listrep-3.{7,12,25,38} */
			} else {
				if tailSpace >= lenChange {
					/* Move only tail segment to the back to make more room. */
					/* T:listrep-3.{8,10,11,14,26,27,30,32,37,39,41} */
					leadShift = 0
					tailShift = lenChange
					/*
					 * See comments above. This is analogous.
					 */
					if finalFreeSpace > int64(1) && (leadSpace == 0 || leadSegmentLen == 0) {
						postShiftTailSpace = tailSpace - lenChange
						if postShiftTailSpace > finalFreeSpace/int64(2) {
							/* T:listrep-1.{1,3,14,18,21},3.{2,3,26,27} */
							extraShift1 = postShiftTailSpace - finalFreeSpace/int64(2)
							tailShift += extraShift1
							leadShift = extraShift1 /* Move head to the back as well */
						}
					}
				} else {
					/*
					 * Both lead and tail need to be shifted to make room.
					 * Divide remaining free space equally between front and back.
					 */
					/* T:listrep-3.{9,13,31,40} */
					/*
					 * leadShift = leadSpace - (finalFreeSpace/2)
					 * Thus leadShift <= leadSpace
					 * Also,
					 * = leadSpace - (leadSpace + tailSpace - lenChange)/2
					 * = leadSpace/2 - tailSpace/2 + lenChange/2
					 * >= 0 because lenChange > tailSpace
					 */
					leadShift = leadSpace - finalFreeSpace/int64(2)
					tailShift = lenChange - leadShift
					if tailShift > tailSpace {
						/* Account for integer division errors */
						leadShift += int64(1)
						tailShift -= int64(1)
					}
					/*
					 * Following must be true because otherwise one of the previous
					 * if clauses would have been taken.
					 */
					leadShift = -leadShift /* Lead is actually shifted downward */
				}
			}
		}
	}
	/* Careful about order of moves! */
	if leadShift > 0 {
		/* Will happen when we have to make room at bottom */
		if tailShift != 0 && tailSegmentLen != 0 {
			/* T:listrep-1.{1,3,14,18},3.{2,3,26,27} */
			tailStart = leadSegmentLen + numToDelete1
			libc.Xmemmove(tls, listObjs+uintptr(tailStart+tailShift)*8, listObjs+uintptr(tailStart)*8, libc.Uint64FromInt64(tailSegmentLen)*uint64(8))
		}
		if leadSegmentLen != 0 {
			/* T:listrep-1.{3,6,16,18,21},3.{19,20,34} */
			libc.Xmemmove(tls, listObjs+uintptr(leadShift)*8, listObjs, libc.Uint64FromInt64(leadSegmentLen)*uint64(8))
		}
	} else {
		if leadShift != 0 && leadSegmentLen != 0 {
			/* T:listrep-3.{7,9,12,13,31,36,38,40} */
			libc.Xmemmove(tls, listObjs+uintptr(leadShift)*8, listObjs, libc.Uint64FromInt64(leadSegmentLen)*uint64(8))
		}
		if tailShift != 0 && tailSegmentLen != 0 {
			/* T:listrep-1.{7,17},3.{8:11,13,14,21,22,35,37,39:41} */
			tailStart1 = leadSegmentLen + numToDelete1
			libc.Xmemmove(tls, listObjs+uintptr(tailStart1+tailShift)*8, listObjs+uintptr(tailStart1)*8, libc.Uint64FromInt64(tailSegmentLen)*uint64(8))
		}
	}
	if numToInsert1 != 0 {
		/* Do NOT use ObjArrayCopy here since we have already incr'ed ref counts */
		/* T:listrep-1.{1,3,12:21},3.{2,3,7:14,23:41} */
		libc.Xmemmove(tls, listObjs+uintptr(leadSegmentLen+leadShift)*8, insertObjs1, libc.Uint64FromInt64(numToInsert1)*uint64(8))
	}
	*(*TTcl_Size)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)) += leadShift
	(*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FnumUsed = origListLen + lenChange
	(*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).Fflags = 0
	if (*(*TListRep)(unsafe.Pointer(bp))).FspanPtr != 0 && (*TListSpan)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FspanPtr)).FrefCount <= uint64(1) {
		/* An unshared span record, re-use it, even if not required */
		/* T:listrep-3.{2,3,7:14},3.{19:41} */
		(*TListSpan)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FspanPtr)).FspanStart = (*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FfirstUsed
		(*TListSpan)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FspanPtr)).FspanLength = (*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FnumUsed
	} else {
		/* Need a new span record */
		if (*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FfirstUsed == 0 {
			/* T:listrep-1.{7,12,15,17,19,20} */
			(*(*TListRep)(unsafe.Pointer(bp))).FspanPtr = libc.UintptrFromInt32(0)
		} else {
			/* T:listrep-1.{1,3,6.1,13,14,16,18,21} */
			(*(*TListRep)(unsafe.Pointer(bp))).FspanPtr = _ListSpanNew(tls, (*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FfirstUsed, (*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FnumUsed)
		}
	}
	(*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FrefCount++
	if (*TListRep)(unsafe.Pointer(bp)).FspanPtr != 0 {
		(*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FspanPtr)).FrefCount++
	}
	if (*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr != libc.UintptrFromInt32(0) {
		if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).FfreeIntRepProc})))(tls, listObj)
		}
		(*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr = libc.UintptrFromInt32(0)
	}
	_isobjPtr5 = listObj
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr5)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr5)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr5)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr5)).Fbytes = libc.UintptrFromInt32(0)
	}
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(listObj + 32))).Fptr1 = (*TListRep)(unsafe.Pointer(bp)).FstorePtr
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(listObj + 32))).Fptr2 = (*TListRep)(unsafe.Pointer(bp)).FspanPtr
	(*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr = uintptr(unsafe.Pointer(&XtclListType))
	return TCL_OK
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * TclLindexList --
//	 *
//	 *	This procedure handles the 'lindex' command when objc==3.
//	 *
//	 * Results:
//	 *	Returns a pointer to the object extracted, or NULL if an error
//	 *	occurred. The returned object already includes one reference count for
//	 *	the pointer returned.
//	 *
//	 * Side effects:
//	 *	None.
//	 *
//	 * Notes:
//	 *	This procedure is implemented entirely as a wrapper around
//	 *	TclLindexFlat. All it does is reconfigure the argument format into the
//	 *	form required by TclLindexFlat, while taking care to manage shimmering
//	 *	in such a way that we tend to keep the most useful internalreps and/or
//	 *	avoid the most expensive conversions.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func XTclLindexList(tls *libc.TLS, interp uintptr, listObj uintptr, _argObj uintptr) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	*(*uintptr)(unsafe.Pointer(bp)) = _argObj /* Index or index list. */
	var _objPtr, indexListCopy, v7 uintptr
	var v1 int32
	var v2 bool
	var v4, v5 int64
	var v6 TTcl_Size
	var _ /* index at bp+8 */ TTcl_Size
	var _ /* indexObjs at bp+16 */ uintptr
	var _ /* numIndexObjs at bp+24 */ TTcl_Size
	_, _, _, _, _, _, _, _ = _objPtr, indexListCopy, v1, v2, v4, v5, v6, v7
	/*
	 * Determine whether argPtr designates a list or a single index. We have
	 * to be careful about the order of the checks to avoid repeated
	 * shimmering; if internal rep is already a list do not shimmer it.
	 * see TIP#22 and TIP#33 for the details.
	 */
	if v2 = !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType))); v2 {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FinternalRep)) <= int64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))-libc.Int64FromInt32(1)) {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FinternalRep))
			v1 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1 = XTcl_GetIntForIndex(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))-libc.Int64FromInt32(1), bp+8)
		}
	}
	if v2 && v1 == TCL_OK {
		/*
		 * argPtr designates a single index.
		 */
		return XTclLindexFlat(tls, interp, listObj, int64(1), bp)
	}
	/*
	 * Here we make a private copy of the index list argument to avoid any
	 * shimmering issues that might invalidate the indices array below while
	 * we are still using it. This is probably unnecessary. It does not appear
	 * that any damaging shimmering is possible, and no test has been devised
	 * to show any error when this private copy is not made. But it's cheap,
	 * and it offers some future-proofing insurance in case the TclLindexFlat
	 * implementation changes in some unexpected way, or some new form of
	 * trace or callback permits things to happen that the current
	 * implementation does not.
	 */
	indexListCopy = XTclListObjCopy(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)))
	if indexListCopy == libc.UintptrFromInt32(0) {
		/*
		 * The argument is neither an index nor a well-formed list.
		 * Report the error via TclLindexFlat.
		 * TODO - This is as original code. why not directly return an error?
		 */
		return XTclLindexFlat(tls, interp, listObj, int64(1), bp)
	}
	if (*TTcl_Obj)(unsafe.Pointer(indexListCopy)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(indexListCopy + 32))).Fptr2 != 0 {
			v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(indexListCopy + 32))).Fptr2)).FspanStart
		} else {
			v4 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(indexListCopy + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 16)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(indexListCopy + 32))).Fptr1 + 40 + uintptr(v4)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(indexListCopy + 32))).Fptr2 != 0 {
			v5 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(indexListCopy + 32))).Fptr2)).FspanLength
		} else {
			v5 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(indexListCopy + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = v5
		_ = libc.Int32FromInt32(TCL_OK)
	} else {
		XTcl_ListObjGetElements(tls, interp, indexListCopy, bp+24, bp+16)
	}
	listObj = XTclLindexFlat(tls, interp, listObj, *(*TTcl_Size)(unsafe.Pointer(bp + 24)), *(*uintptr)(unsafe.Pointer(bp + 16)))
	_objPtr = indexListCopy
	v7 = _objPtr
	v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
	*(*TTcl_Size)(unsafe.Pointer(v7))--
	if v6 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return listObj
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * TclLindexFlat --
//	 *
//	 *	This procedure is the core of the 'lindex' command, with all index
//	 *	arguments presented as a flat list.
//	 *
//	 * Results:
//	 *	Returns a pointer to the object extracted, or NULL if an error
//	 *	occurred. The returned object already includes one reference count for
//	 *	the pointer returned.
//	 *
//	 * Side effects:
//	 *	None.
//	 *
//	 * Notes:
//	 *	The reference count of the returned object includes one reference
//	 *	corresponding to the pointer returned. Thus, the calling code will
//	 *	usually do something like:
//	 *		Tcl_SetObjResult(interp, result);
//	 *		Tcl_DecrRefCount(result);
//	 *
//	 *----------------------------------------------------------------------
//	 */
func XTclLindexFlat(tls *libc.TLS, interp1 uintptr, listObj uintptr, indexCount TTcl_Size, indexArray uintptr) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Array of pointers to Tcl objects that
	 * represent the indices in the list. */
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, _objPtr6, cachePtr, e2Obj, elemPtrs, itemObj, proc, proc1, v1, v13, v16, v2, v21, v23, v26, v3, v30, v32, v8, v9 uintptr
	var i, listLen, v12, v15, v18, v20, v22, v25, v29, v31, v4 TTcl_Size
	var status, v10, v17, v19, v7 int32
	var v24 bool
	var v27, v28 int64
	var _ /* elemObj at bp+8 */ uintptr
	var _ /* index at bp+0 */ TTcl_Size
	var _ /* index at bp+16 */ TTcl_Size
	var _ /* listLen at bp+24 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, _objPtr6, cachePtr, e2Obj, elemPtrs, i, itemObj, listLen, proc, proc1, status, v1, v10, v12, v13, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v4, v7, v8, v9
	/* Handle AbstractList as special case */
	if (*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+56) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+56) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).Fversion) {
		v1 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).FindexProc
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	if v1 != 0 {
		v2 = listObj
		if (*TTcl_Obj)(unsafe.Pointer(v2)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+48) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+48) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v2)).FtypePtr)).Fversion) {
			v3 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v2)).FtypePtr)).FlengthProc
		} else {
			v3 = libc.UintptrFromInt32(0)
		}
		proc = v3
		v4 = (*(*func(*libc.TLS, uintptr) TTcl_Size)(unsafe.Pointer(&struct{ uintptr }{proc})))(tls, v2)
		goto _5
	_5:
		listLen = v4
		*(*uintptr)(unsafe.Pointer(bp + 8)) = listObj /* for lindex without indices return list */
		i = 0
		for {
			if !(i < indexCount && listObj != 0) {
				break
			}
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(indexArray + uintptr(i)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(indexArray + uintptr(i)*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(indexArray + uintptr(i)*8)))).FinternalRep)) <= listLen-int64(1) {
				*(*TTcl_Size)(unsafe.Pointer(bp)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(indexArray + uintptr(i)*8)))).FinternalRep))
				v7 = libc.Int32FromInt32(TCL_OK)
			} else {
				v7 = XTcl_GetIntForIndex(tls, interp1, *(*uintptr)(unsafe.Pointer(indexArray + uintptr(i)*8)), listLen-libc.Int64FromInt32(1), bp)
			}
			if v7 == TCL_OK {
				// TODO: ???
			}
			if i == 0 {
				v8 = listObj
				if (*TTcl_Obj)(unsafe.Pointer(v8)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+56) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+56) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v8)).FtypePtr)).Fversion) {
					v9 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v8)).FtypePtr)).FindexProc
				} else {
					v9 = libc.UintptrFromInt32(0)
				}
				proc1 = v9
				v10 = (*(*func(*libc.TLS, uintptr, uintptr, TTcl_Size, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{proc1})))(tls, interp1, v8, *(*TTcl_Size)(unsafe.Pointer(bp)), bp+8)
				goto _11
			_11:
				if v10 != TCL_OK {
					return libc.UintptrFromInt32(0)
				}
			} else {
				if *(*TTcl_Size)(unsafe.Pointer(bp)) > 0 {
					// TODO: support nested lists
					e2Obj = XTclLindexFlat(tls, interp1, *(*uintptr)(unsafe.Pointer(bp + 8)), int64(1), indexArray+uintptr(i)*8)
					_objPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
					v13 = _objPtr
					v12 = *(*TTcl_Size)(unsafe.Pointer(v13))
					*(*TTcl_Size)(unsafe.Pointer(v13))--
					if v12 <= int64(1) {
						XTclFreeObj(tls, _objPtr)
					}
					*(*uintptr)(unsafe.Pointer(bp + 8)) = e2Obj
				}
			}
			goto _6
		_6:
			;
			i++
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
		return *(*uintptr)(unsafe.Pointer(bp + 8))
	}
	(*TTcl_Obj)(unsafe.Pointer(listObj)).FrefCount++
	i = 0
	for {
		if !(i < indexCount && listObj != 0) {
			break
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = 0
		elemPtrs = libc.UintptrFromInt32(0)
		status = XTcl_ListObjLength(tls, interp1, listObj, bp+24)
		if status != TCL_OK {
			_objPtr1 = listObj
			v16 = _objPtr1
			v15 = *(*TTcl_Size)(unsafe.Pointer(v16))
			*(*TTcl_Size)(unsafe.Pointer(v16))--
			if v15 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
			return libc.UintptrFromInt32(0)
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(indexArray + uintptr(i)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(indexArray + uintptr(i)*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(indexArray + uintptr(i)*8)))).FinternalRep)) <= *(*TTcl_Size)(unsafe.Pointer(bp + 24))-int64(1) {
			*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(indexArray + uintptr(i)*8)))).FinternalRep))
			v17 = libc.Int32FromInt32(TCL_OK)
		} else {
			v17 = XTcl_GetIntForIndex(tls, interp1, *(*uintptr)(unsafe.Pointer(indexArray + uintptr(i)*8)), *(*TTcl_Size)(unsafe.Pointer(bp + 24))-libc.Int64FromInt32(1), bp+16)
		}
		if v17 == TCL_OK {
			if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) < 0 || *(*TTcl_Size)(unsafe.Pointer(bp + 16)) >= *(*TTcl_Size)(unsafe.Pointer(bp + 24)) {
				/*
				 * Index is out of range. Break out of loop with empty result.
				 * First check remaining indices for validity
				 */
				for {
					i++
					v18 = i
					if !(v18 < indexCount) {
						break
					}
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(indexArray + uintptr(i)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(indexArray + uintptr(i)*8)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(indexArray + uintptr(i)*8)))).FinternalRep)) <= int64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))-libc.Int64FromInt32(1)) {
						*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(indexArray + uintptr(i)*8)))).FinternalRep))
						v19 = libc.Int32FromInt32(TCL_OK)
					} else {
						v19 = XTcl_GetIntForIndex(tls, interp1, *(*uintptr)(unsafe.Pointer(indexArray + uintptr(i)*8)), libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))-libc.Int64FromInt32(1), bp+16)
					}
					if v19 != TCL_OK {
						_objPtr2 = listObj
						v21 = _objPtr2
						v20 = *(*TTcl_Size)(unsafe.Pointer(v21))
						*(*TTcl_Size)(unsafe.Pointer(v21))--
						if v20 <= int64(1) {
							XTclFreeObj(tls, _objPtr2)
						}
						return libc.UintptrFromInt32(0)
					}
				}
				_objPtr3 = listObj
				v23 = _objPtr3
				v22 = *(*TTcl_Size)(unsafe.Pointer(v23))
				*(*TTcl_Size)(unsafe.Pointer(v23))--
				if v22 <= int64(1) {
					XTclFreeObj(tls, _objPtr3)
				}
				if v24 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v24 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v24 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
					listObj = XTclThreadAllocObj(tls)
				} else {
					listObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(listObj + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(listObj)).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer(listObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(listObj)).Flength = 0
				(*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr = libc.UintptrFromInt32(0)
				(*TTcl_Obj)(unsafe.Pointer(listObj)).FrefCount++
			} else {
				/*
				 * Must set the internal rep again because it may have been
				 * changed by TclGetIntForIndexM. See test lindex-8.4.
				 */
				if !((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType))) {
					status = _SetListFromAny(tls, interp1, listObj)
					if status != TCL_OK {
						/* The list is not a list at all => error.  */
						_objPtr4 = listObj
						v26 = _objPtr4
						v25 = *(*TTcl_Size)(unsafe.Pointer(v26))
						*(*TTcl_Size)(unsafe.Pointer(v26))--
						if v25 <= int64(1) {
							XTclFreeObj(tls, _objPtr4)
						}
						return libc.UintptrFromInt32(0)
					}
				}
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr2 != 0 {
					v27 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(listObj + 32))).Fptr2)).FspanStart
				} else {
					v27 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(listObj + 32))).Fptr1)).FfirstUsed
				}
				elemPtrs = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr1 + 40 + uintptr(v27)*8
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr2 != 0 {
					v28 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(listObj + 32))).Fptr2)).FspanLength
				} else {
					v28 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(listObj + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = v28
				/* increment this reference count first before decrementing
				 * just in case they are the same Tcl_Obj
				 */
				itemObj = *(*uintptr)(unsafe.Pointer(elemPtrs + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 16)))*8))
				(*TTcl_Obj)(unsafe.Pointer(itemObj)).FrefCount++
				_objPtr5 = listObj
				v30 = _objPtr5
				v29 = *(*TTcl_Size)(unsafe.Pointer(v30))
				*(*TTcl_Size)(unsafe.Pointer(v30))--
				if v29 <= int64(1) {
					XTclFreeObj(tls, _objPtr5)
				}
				/* Extract the pointer to the appropriate element. */
				listObj = itemObj
			}
		} else {
			_objPtr6 = listObj
			v32 = _objPtr6
			v31 = *(*TTcl_Size)(unsafe.Pointer(v32))
			*(*TTcl_Size)(unsafe.Pointer(v32))--
			if v31 <= int64(1) {
				XTclFreeObj(tls, _objPtr6)
			}
			listObj = libc.UintptrFromInt32(0)
		}
		goto _14
	_14:
		;
		i++
	}
	return listObj
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * TclLsetList --
//	 *
//	 *	Core of the 'lset' command when objc == 4. Objv[2] may be either a
//	 *	scalar index or a list of indices.
//	 *      It also handles 'lpop' when given a NULL value.
//	 *
//	 * Results:
//	 *	Returns the new value of the list variable, or NULL if there was an
//	 *	error. The returned object includes one reference count for the
//	 *	pointer returned.
//	 *
//	 * Side effects:
//	 *	None.
//	 *
//	 * Notes:
//	 *	This procedure is implemented entirely as a wrapper around
//	 *	TclLsetFlat. All it does is reconfigure the argument format into the
//	 *	form required by TclLsetFlat, while taking care to manage shimmering
//	 *	in such a way that we tend to keep the most useful internalreps and/or
//	 *	avoid the most expensive conversions.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func XTclLsetList(tls *libc.TLS, interp1 uintptr, listObj uintptr, _indexArgObj uintptr, valueObj1 uintptr) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	*(*uintptr)(unsafe.Pointer(bp)) = _indexArgObj /* Value arg to 'lset' or NULL to 'lpop'. */
	var _objPtr, _objPtr1, indexListCopy, proc, retValueObj, v12, v14, v3, v4, v5, v6 uintptr
	var v1, v8 int32
	var v10, v9 int64
	var v11, v13 TTcl_Size
	var v2 bool
	var _ /* index at bp+24 */ TTcl_Size
	var _ /* indexCount at bp+8 */ TTcl_Size
	var _ /* indices at bp+16 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, indexListCopy, proc, retValueObj, v1, v10, v11, v12, v13, v14, v2, v3, v4, v5, v6, v8, v9
	*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0 /* Number of indices in the index list. */
	*(*uintptr)(unsafe.Pointer(bp + 16)) = libc.UintptrFromInt32(0)
	/*
	 * Determine whether the index arg designates a list or a single index.
	 * We have to be careful about the order of the checks to avoid repeated
	 * shimmering; see TIP #22 and #23 for details.
	 */
	if v2 = !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType))); v2 {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FinternalRep)) <= int64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))-libc.Int64FromInt32(1)) {
			*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FinternalRep))
			v1 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1 = XTcl_GetIntForIndex(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))-libc.Int64FromInt32(1), bp+24)
		}
	}
	if v2 && v1 == TCL_OK {
		if (*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+88) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+88) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).Fversion) {
			v3 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).FsetElementProc
		} else {
			v3 = libc.UintptrFromInt32(0)
		}
		if v3 != 0 {
			*(*uintptr)(unsafe.Pointer(bp + 16)) = bp
			v4 = listObj
			if (*TTcl_Obj)(unsafe.Pointer(v4)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+88) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+88) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v4)).FtypePtr)).Fversion) {
				v5 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v4)).FtypePtr)).FsetElementProc
			} else {
				v5 = libc.UintptrFromInt32(0)
			}
			proc = v5
			v6 = (*(*func(*libc.TLS, uintptr, uintptr, TTcl_Size, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{proc})))(tls, interp1, v4, int64(1), *(*uintptr)(unsafe.Pointer(bp + 16)), valueObj1)
			goto _7
		_7:
			retValueObj = v6
			if retValueObj != 0 {
				(*TTcl_Obj)(unsafe.Pointer(retValueObj)).FrefCount++
			}
		} else {
			/* indexArgPtr designates a single index. */
			/* T:listrep-1.{2.1,12.1,15.1,19.1},2.{2.3,9.3,10.1,13.1,16.1}, 3.{4,5,6}.3 */
			retValueObj = XTclLsetFlat(tls, interp1, listObj, int64(1), bp, valueObj1)
		}
	} else {
		indexListCopy = XTclListObjCopy(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)))
		if !(indexListCopy != 0) {
			/*
			 * indexArgPtr designates something that is neither an index nor a
			 * well formed list. Report the error via TclLsetFlat.
			 */
			retValueObj = XTclLsetFlat(tls, interp1, listObj, int64(1), bp, valueObj1)
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(indexListCopy)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(indexListCopy + 32))).Fptr2 != 0 {
					v9 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(indexListCopy + 32))).Fptr2)).FspanStart
				} else {
					v9 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(indexListCopy + 32))).Fptr1)).FfirstUsed
				}
				*(*uintptr)(unsafe.Pointer(bp + 16)) = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(indexListCopy + 32))).Fptr1 + 40 + uintptr(v9)*8
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(indexListCopy + 32))).Fptr2 != 0 {
					v10 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(indexListCopy + 32))).Fptr2)).FspanLength
				} else {
					v10 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(indexListCopy + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v10
				v8 = libc.Int32FromInt32(TCL_OK)
			} else {
				v8 = XTcl_ListObjGetElements(tls, interp1, indexListCopy, bp+8, bp+16)
			}
			if TCL_OK != v8 {
				_objPtr = indexListCopy
				v12 = _objPtr
				v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
				*(*TTcl_Size)(unsafe.Pointer(v12))--
				if v11 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
				/*
				 * indexArgPtr designates something that is neither an index nor a
				 * well formed list. Report the error via TclLsetFlat.
				 */
				retValueObj = XTclLsetFlat(tls, interp1, listObj, int64(1), bp, valueObj1)
			} else {
				/*
				 * Let TclLsetFlat perform the actual lset operation.
				 */
				retValueObj = XTclLsetFlat(tls, interp1, listObj, *(*TTcl_Size)(unsafe.Pointer(bp + 8)), *(*uintptr)(unsafe.Pointer(bp + 16)), valueObj1)
				if indexListCopy != 0 {
					_objPtr1 = indexListCopy
					v14 = _objPtr1
					v13 = *(*TTcl_Size)(unsafe.Pointer(v14))
					*(*TTcl_Size)(unsafe.Pointer(v14))--
					if v13 <= int64(1) {
						XTclFreeObj(tls, _objPtr1)
					}
				}
			}
		}
	}
	return retValueObj
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * TclLsetFlat --
//	 *
//	 *	Core engine of the 'lset' command.
//	 *      It also handles 'lpop' when given a NULL value.
//	 *
//	 * Results:
//	 *	Returns the new value of the list variable, or NULL if an error
//	 *	occurred. The returned object includes one reference count for the
//	 *	pointer returned.
//	 *
//	 * Side effects:
//	 *	On entry, the reference count of the variable value does not reflect
//	 *	any references held on the stack. The first action of this function is
//	 *	to determine whether the object is shared, and to duplicate it if it
//	 *	is. The reference count of the duplicate is incremented. At this
//	 *	point, the reference count will be 1 for either case, so that the
//	 *	object will appear to be unshared.
//	 *
//	 *	If an error occurs, and the object has been duplicated, the reference
//	 *	count on the duplicate is decremented so that it is now 0: this
//	 *	dismisses any memory that was allocated by this function.
//	 *
//	 *	If no error occurs, the reference count of the original object is
//	 *	incremented if the object has not been duplicated, and nothing is done
//	 *	to a reference count of the duplicate. Now the reference count of an
//	 *	unduplicated object is 2 (the returned pointer, plus the one stored in
//	 *	the variable). The reference count of a duplicate object is 1,
//	 *	reflecting that the returned pointer is the only active reference. The
//	 *	caller is expected to store the returned value back in the variable
//	 *	and decrement its reference count. (INST_STORE_* does exactly this.)
//	 *
//	 *----------------------------------------------------------------------
//	 */
func XTclLsetFlat(tls *libc.TLS, interp uintptr, listObj uintptr, indexCount TTcl_Size, indexArray uintptr, valueObj uintptr) (r uintptr) {
	bp := tls.Alloc(176)
	defer tls.Free(176) /* Value arg to 'lset' or NULL to 'lpop'. */
	var _isobjPtr, _isobjPtr1, _objPtr, cachePtr, objPtr, parentList, pendingInvalidatesPtr, retValueObj, subListObj, v1, v10, v6 uintptr
	var numPendingInvalidates, v7, v9 TTcl_Size
	var result, v2, v5 int32
	var v12, v3, v4 int64
	var v8 bool
	var _ /* elemCount at bp+96 */ TTcl_Size
	var _ /* elemPtrs at bp+104 */ uintptr
	var _ /* index at bp+0 */ TTcl_Size
	var _ /* len at bp+8 */ TTcl_Size
	var _ /* objInternalRep at bp+112 */ TListRep
	var _ /* pendingInvalidates at bp+16 */ [10]uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _isobjPtr, _isobjPtr1, _objPtr, cachePtr, numPendingInvalidates, objPtr, parentList, pendingInvalidatesPtr, result, retValueObj, subListObj, v1, v10, v12, v2, v3, v4, v5, v6, v7, v8, v9
	pendingInvalidatesPtr = bp + 16
	numPendingInvalidates = 0
	/*
	 * If there are no indices, simply return the new value.  (Without
	 * indices, [lset] is a synonym for [set].
	 * [lpop] does not use this but protect for NULL valueObj just in case.
	 */
	if indexCount == 0 {
		if valueObj != libc.UintptrFromInt32(0) {
			(*TTcl_Obj)(unsafe.Pointer(valueObj)).FrefCount++
		}
		return valueObj
	}
	/*
	 * If the list is shared, make a copy we can modify (copy-on-write).  We
	 * use Tcl_DuplicateObj() instead of TclListObjCopy() for a few reasons:
	 * 1) we have not yet confirmed listObj is actually a list; 2) We make a
	 * verbatim copy of any existing string rep, and when we combine that with
	 * the delayed invalidation of string reps of modified Tcl_Obj's
	 * implemented below, the outcome is that any error condition that causes
	 * this routine to return NULL, will leave the string rep of listObj and
	 * all elements to be unchanged.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(listObj)).FrefCount > int64(1) {
		v1 = XTcl_DuplicateObj(tls, listObj)
	} else {
		v1 = listObj
	}
	subListObj = v1
	/*
	 * Anchor the linked list of Tcl_Obj's whose string reps must be
	 * invalidated if the operation succeeds.
	 */
	retValueObj = subListObj
	result = TCL_OK
	/* Allocate if static array for pending invalidations is too small */
	if indexCount > libc.Int64FromUint64(libc.Uint64FromInt64(80)/libc.Uint64FromInt64(8)) {
		pendingInvalidatesPtr = XTcl_Alloc(tls, libc.Uint64FromInt64(indexCount)*uint64(8))
	}
	/*
	 * Loop through all the index arguments, and for each one dive into the
	 * appropriate sublist.
	 */
	for cond := true; cond; cond = indexCount > 0 {
		/*
		 * Check for the possible error conditions...
		 */
		if (*TTcl_Obj)(unsafe.Pointer(subListObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(subListObj + 32))).Fptr2 != 0 {
				v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(subListObj + 32))).Fptr2)).FspanStart
			} else {
				v3 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(subListObj + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 104)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(subListObj + 32))).Fptr1 + 40 + uintptr(v3)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(subListObj + 32))).Fptr2 != 0 {
				v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(subListObj + 32))).Fptr2)).FspanLength
			} else {
				v4 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(subListObj + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 96)) = v4
			v2 = libc.Int32FromInt32(TCL_OK)
		} else {
			v2 = XTcl_ListObjGetElements(tls, interp, subListObj, bp+96, bp+104)
		}
		if v2 != TCL_OK {
			/* ...the sublist we're indexing into isn't a list at all. */
			result = int32(TCL_ERROR)
			break
		}
		/*
		 * WARNING: the macro TclGetIntForIndexM is not safe for
		 * post-increments, avoid '*indexArray++' here.
		 */
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(indexArray)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(indexArray)))).FinternalRep)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(indexArray)))).FinternalRep)) <= *(*TTcl_Size)(unsafe.Pointer(bp + 96))-int64(1) {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(indexArray)))).FinternalRep))
			v5 = libc.Int32FromInt32(TCL_OK)
		} else {
			v5 = XTcl_GetIntForIndex(tls, interp, *(*uintptr)(unsafe.Pointer(indexArray)), *(*TTcl_Size)(unsafe.Pointer(bp + 96))-libc.Int64FromInt32(1), bp)
		}
		if v5 != TCL_OK {
			/* ...the index we're trying to use isn't an index at all. */
			result = int32(TCL_ERROR)
			indexArray += 8 /* Why bother with this increment? TBD */
			break
		}
		indexArray += 8
		/*
		 * Special case 0-length lists. The Tcl indexing function treat
		 * will return any value beyond length as TCL_SIZE_MAX for this
		 * case.
		 */
		if *(*TTcl_Size)(unsafe.Pointer(bp)) == libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)) && *(*TTcl_Size)(unsafe.Pointer(bp + 96)) == 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp)) < 0 || *(*TTcl_Size)(unsafe.Pointer(bp)) > *(*TTcl_Size)(unsafe.Pointer(bp + 96)) || valueObj == libc.UintptrFromInt32(0) && *(*TTcl_Size)(unsafe.Pointer(bp)) >= *(*TTcl_Size)(unsafe.Pointer(bp + 96)) {
			/* ...the index points outside the sublist. */
			if interp != libc.UintptrFromInt32(0) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(indexArray + uintptr(-libc.Int32FromInt32(1))*8)))).Fbytes != 0 {
					v6 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(indexArray + uintptr(-libc.Int32FromInt32(1))*8)))).Fbytes
				} else {
					v6 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(indexArray + uintptr(-libc.Int32FromInt32(1))*8)), libc.UintptrFromInt32(0))
				}
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+17830, libc.VaList(bp+136, v6)))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+136, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+17278, __ccgo_ts+17284, libc.UintptrFromInt32(0)))
			}
			result = int32(TCL_ERROR)
			break
		}
		/*
		 * No error conditions.  As long as we're not yet on the last index,
		 * determine the next sublist for the next pass through the loop,
		 * and take steps to make sure it is an unshared copy, as we intend
		 * to modify it.
		 */
		indexCount--
		v7 = indexCount
		if v7 != 0 {
			parentList = subListObj
			if *(*TTcl_Size)(unsafe.Pointer(bp)) == *(*TTcl_Size)(unsafe.Pointer(bp + 96)) {
				if v8 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v8 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v8 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
					subListObj = XTclThreadAllocObj(tls)
				} else {
					subListObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(subListObj + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(subListObj)).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer(subListObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(subListObj)).Flength = 0
				(*TTcl_Obj)(unsafe.Pointer(subListObj)).FtypePtr = libc.UintptrFromInt32(0)
			} else {
				subListObj = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 104)) + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))*8))
			}
			if (*TTcl_Obj)(unsafe.Pointer(subListObj)).FrefCount > int64(1) {
				subListObj = XTcl_DuplicateObj(tls, subListObj)
			}
			/*
			 * Replace the original elemPtr[index] in parentList with a copy
			 * we know to be unshared.  This call will also deal with the
			 * situation where parentList shares its internalrep with other
			 * Tcl_Obj's.  Dealing with the shared internalrep case can
			 * cause subListObj to become shared again, so detect that case
			 * and make and store another copy.
			 */
			if *(*TTcl_Size)(unsafe.Pointer(bp)) == *(*TTcl_Size)(unsafe.Pointer(bp + 96)) {
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), parentList, subListObj)
			} else {
				XTclListObjSetElement(tls, libc.UintptrFromInt32(0), parentList, *(*TTcl_Size)(unsafe.Pointer(bp)), subListObj)
			}
			if (*TTcl_Obj)(unsafe.Pointer(subListObj)).FrefCount > int64(1) {
				subListObj = XTcl_DuplicateObj(tls, subListObj)
				XTclListObjSetElement(tls, libc.UintptrFromInt32(0), parentList, *(*TTcl_Size)(unsafe.Pointer(bp)), subListObj)
			}
			/*
			 * The TclListObjSetElement() calls do not spoil the string rep
			 * of parentList, and that's fine for now, since all we've done
			 * so far is replace a list element with an unshared copy.  The
			 * list value remains the same, so the string rep. is still
			 * valid, and unchanged, which is good because if this whole
			 * routine returns NULL, we'd like to leave no change to the
			 * value of the lset variable.  Later on, when we set valueObj
			 * in its proper place, then all containing lists will have
			 * their values changed, and will need their string reps
			 * spoiled.  We maintain a list of all those Tcl_Obj's
			 * pendingInvalidatesPtr[] so we can spoil them at that time.
			 */
			*(*uintptr)(unsafe.Pointer(pendingInvalidatesPtr + uintptr(numPendingInvalidates)*8)) = parentList
			numPendingInvalidates++
		}
	}
	/*
	 * Either we've detected and error condition, and exited the loop with
	 * result == TCL_ERROR, or we've successfully reached the last index, and
	 * we're ready to store valueObj. On success, we need to invalidate
	 * the string representations of intermediate lists whose contained
	 * list element would have changed.
	 */
	if result == TCL_OK {
		for numPendingInvalidates > 0 {
			numPendingInvalidates--
			objPtr = *(*uintptr)(unsafe.Pointer(pendingInvalidatesPtr + uintptr(numPendingInvalidates)*8))
			if result == TCL_OK {
				_TclListObjGetRep(tls, libc.UintptrFromInt32(0), objPtr, bp+112)
				(*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp+112)).FstorePtr)).FrefCount++
				if (*TListRep)(unsafe.Pointer(bp+112)).FspanPtr != 0 {
					(*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp+112)).FspanPtr)).FrefCount++
				}
				if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != libc.UintptrFromInt32(0) {
					if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
						(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc})))(tls, objPtr)
					}
					(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
				}
				_isobjPtr = objPtr
				if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
					if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
				}
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr1 = (*TListRep)(unsafe.Pointer(bp + 112)).FstorePtr
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr2 = (*TListRep)(unsafe.Pointer(bp + 112)).FspanPtr
				(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclListType))
			}
		}
	}
	if pendingInvalidatesPtr != bp+16 {
		XTclpFree(tls, pendingInvalidatesPtr)
	}
	if result != TCL_OK {
		/*
		 * Error return; message is already in interp. Clean up any excess
		 * memory.
		 */
		if retValueObj != listObj {
			_objPtr = retValueObj
			v10 = _objPtr
			v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
			*(*TTcl_Size)(unsafe.Pointer(v10))--
			if v9 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
		return libc.UintptrFromInt32(0)
	}
	/*
	 * Store valueObj in proper sublist and return. The -1 is to avoid a
	 * compiler warning (not a problem because we checked that we have a
	 * proper list - or something convertible to one - above).
	 */
	*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = int64(-int32(1))
	if (*TTcl_Obj)(unsafe.Pointer(subListObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(subListObj + 32))).Fptr2 != 0 {
			v12 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(subListObj + 32))).Fptr2)).FspanLength
		} else {
			v12 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(subListObj + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v12
		_ = libc.Int32FromInt32(TCL_OK)
	} else {
		XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), subListObj, bp+8)
	}
	if valueObj == libc.UintptrFromInt32(0) {
		/* T:listrep-1.{4.2,5.4,6.1,7.1,8.3},2.{4,5}.4 */
		XTcl_ListObjReplace(tls, libc.UintptrFromInt32(0), subListObj, *(*TTcl_Size)(unsafe.Pointer(bp)), int64(1), 0, libc.UintptrFromInt32(0))
	} else {
		if *(*TTcl_Size)(unsafe.Pointer(bp)) == *(*TTcl_Size)(unsafe.Pointer(bp + 8)) {
			/* T:listrep-1.2.1,2.{2.3,9.3},3.{4,5,6}.3 */
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), subListObj, valueObj)
		} else {
			/* T:listrep-1.{12.1,15.1,19.1},2.{10,13,16}.1 */
			XTclListObjSetElement(tls, libc.UintptrFromInt32(0), subListObj, *(*TTcl_Size)(unsafe.Pointer(bp)), valueObj)
			_isobjPtr1 = subListObj
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes != libc.UintptrFromInt32(0) {
				if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes = libc.UintptrFromInt32(0)
			}
		}
	}
	(*TTcl_Obj)(unsafe.Pointer(retValueObj)).FrefCount++
	return retValueObj
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * TclListObjSetElement --
//	 *
//	 *	Set a single element of a list to a specified value
//	 *
//	 * Results:
//	 *	The return value is normally TCL_OK. If listObj does not refer to a
//	 *	list object and cannot be converted to one, TCL_ERROR is returned and
//	 *	an error message will be left in the interpreter result if interp is
//	 *	not NULL. Similarly, if index designates an element outside the range
//	 *	[0..listLength-1], where listLength is the count of elements in the
//	 *	list object designated by listObj, TCL_ERROR is returned and an error
//	 *	message is left in the interpreter result.
//	 *
//	 * Side effects:
//	 *	Tcl_Panic if listObj designates a shared object. Otherwise, attempts
//	 *	to convert it to a list with a non-shared internal rep. Decrements the
//	 *	ref count of the object at the specified index within the list,
//	 *	replaces with the object designated by valueObj, and increments the
//	 *	ref count of the replacement object.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func XTclListObjSetElement(tls *libc.TLS, interp uintptr, listObj uintptr, index TTcl_Size, valueObj uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* Tcl object to store in the designated list
	 * element. */
	var _isobjPtr, _objPtr, elemPtrs, v5 uintptr
	var elemCount, v4 TTcl_Size
	var v1, v2, v3 int64
	var _ /* listRep at bp+0 */ TListRep
	var _ /* newInternalRep at bp+16 */ TListRep
	_, _, _, _, _, _, _, _, _ = _isobjPtr, _objPtr, elemCount, elemPtrs, v1, v2, v3, v4, v5 /* Number of elements in the list. */
	/* Ensure that the listObj parameter designates an unshared list. */
	if (*TTcl_Obj)(unsafe.Pointer(listObj)).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+10229, libc.VaList(bp+40, __ccgo_ts+52138))
	}
	if _TclListObjGetRep(tls, interp, listObj, bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if (*TListRep)(unsafe.Pointer(bp)).FspanPtr != 0 {
		v1 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FspanPtr)).FspanLength
	} else {
		v1 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FnumUsed
	}
	elemCount = v1
	/* Ensure that the index is in bounds. */
	if index < 0 || index >= elemCount {
		if interp != libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+52159, libc.VaList(bp+40, index)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+17278, __ccgo_ts+17284, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	/*
	 * Note - garbage collect this only AFTER checking indices above.
	 * Do not want to modify listrep and then not store it back in listObj.
	 */
	_ListRepFreeUnreferenced(tls, bp)
	/* Replace a shared internal rep with an unshared copy */
	if (*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FrefCount > uint64(1) {
		/* T:listrep-2.{10,13,16}.1 */
		/* TODO - leave extra space? */
		_ListRepClone(tls, bp, bp+16, int32(LISTREP_PANIC_ON_FAIL))
		*(*TListRep)(unsafe.Pointer(bp)) = *(*TListRep)(unsafe.Pointer(bp + 16))
	} /* else T:listrep-1.{12.1,15.1,19.1} */
	/* Retrieve element array AFTER potential cloning above */
	if (*TListRep)(unsafe.Pointer(bp)).FspanPtr != 0 {
		v2 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FspanPtr)).FspanStart
	} else {
		v2 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FfirstUsed
	}
	elemPtrs = (*TListRep)(unsafe.Pointer(bp)).FstorePtr + 40 + uintptr(v2)*8
	if (*TListRep)(unsafe.Pointer(bp)).FspanPtr != 0 {
		v3 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FspanPtr)).FspanLength
	} else {
		v3 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FnumUsed
	}
	elemCount = v3
	/*
	 * Add a reference to the new list element and remove from old before
	 * replacing it. Order is important!
	 */
	(*TTcl_Obj)(unsafe.Pointer(valueObj)).FrefCount++
	_objPtr = *(*uintptr)(unsafe.Pointer(elemPtrs + uintptr(index)*8))
	v5 = _objPtr
	v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
	*(*TTcl_Size)(unsafe.Pointer(v5))--
	if v4 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	*(*uintptr)(unsafe.Pointer(elemPtrs + uintptr(index)*8)) = valueObj
	/* Internal rep may be cloned so replace */
	(*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FrefCount++
	if (*TListRep)(unsafe.Pointer(bp)).FspanPtr != 0 {
		(*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FspanPtr)).FrefCount++
	}
	if (*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr != libc.UintptrFromInt32(0) {
		if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).FfreeIntRepProc})))(tls, listObj)
		}
		(*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr = libc.UintptrFromInt32(0)
	}
	_isobjPtr = listObj
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(listObj + 32))).Fptr1 = (*TListRep)(unsafe.Pointer(bp)).FstorePtr
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(listObj + 32))).Fptr2 = (*TListRep)(unsafe.Pointer(bp)).FspanPtr
	(*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr = uintptr(unsafe.Pointer(&XtclListType))
	return TCL_OK
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * FreeListInternalRep --
//	 *
//	 *	Deallocate the storage associated with a list object's internal
//	 *	representation.
//	 *
//	 * Results:
//	 *	None.
//	 *
//	 * Side effects:
//	 *	Frees listPtr's List* internal representation, if no longer shared.
//	 *	May decrement the ref counts of element objects, which may free them.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _FreeListInternalRep(tls *libc.TLS, listObj uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* List object with internal rep to free. */
	var v1 Tsize_t
	var v2 uintptr
	var _ /* listRep at bp+0 */ TListRep
	_, _ = v1, v2
	(*TListRep)(unsafe.Pointer(bp)).FstorePtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(listObj + 32))).Fptr1
	(*TListRep)(unsafe.Pointer(bp)).FspanPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(listObj + 32))).Fptr2
	v2 = (*(*TListRep)(unsafe.Pointer(bp))).FstorePtr + 24
	v1 = *(*Tsize_t)(unsafe.Pointer(v2))
	*(*Tsize_t)(unsafe.Pointer(v2))--
	if v1 <= uint64(1) {
		_ObjArrayDecrRefs(tls, (*(*TListRep)(unsafe.Pointer(bp))).FstorePtr+40, (*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FfirstUsed, (*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FnumUsed)
		XTclpFree(tls, (*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)
	}
	if (*(*TListRep)(unsafe.Pointer(bp))).FspanPtr != 0 {
		_ListSpanDecrRefs(tls, (*(*TListRep)(unsafe.Pointer(bp))).FspanPtr)
	}
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * DupListInternalRep --
//	 *
//	 *	Initialize the internal representation of a list Tcl_Obj to share the
//	 *	internal representation of an existing list object.
//	 *
//	 * Results:
//	 *	None.
//	 *
//	 * Side effects:
//	 *	The reference count of the List internal rep is incremented.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _DupListInternalRep(tls *libc.TLS, srcObj uintptr, copyObj uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Object with internal rep to set. */
	var _ /* listRep at bp+0 */ TListRep
	(*TListRep)(unsafe.Pointer(bp)).FstorePtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(srcObj + 32))).Fptr1
	(*TListRep)(unsafe.Pointer(bp)).FspanPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(srcObj + 32))).Fptr2
	(*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FrefCount++
	if (*TListRep)(unsafe.Pointer(bp)).FspanPtr != 0 {
		(*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FspanPtr)).FrefCount++
	}
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(copyObj + 32))).Fptr1 = (*TListRep)(unsafe.Pointer(bp)).FstorePtr
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(copyObj + 32))).Fptr2 = (*TListRep)(unsafe.Pointer(bp)).FspanPtr
	(*TTcl_Obj)(unsafe.Pointer(copyObj)).FtypePtr = uintptr(unsafe.Pointer(&XtclListType))
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * SetListFromAny --
//	 *
//	 *	Attempt to generate a list internal form for the Tcl object "objPtr".
//	 *
//	 * Results:
//	 *	The return value is TCL_OK or TCL_ERROR. If an error occurs during
//	 *	conversion, an error message is left in the interpreter's result
//	 *	unless "interp" is NULL.
//	 *
//	 * Side effects:
//	 *	If no error occurs, a list is stored as "objPtr"s internal
//	 *	representation.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _SetListFromAny(tls *libc.TLS, interp1 uintptr, objPtr2 uintptr) (r int32) {
	bp := tls.Alloc(128)
	defer tls.Free(128) /* The object to convert. */
	var _isobjPtr, _objPtr, cachePtr, check, elemPtrs, proc, proc1, v10, v11, v14, v15, v19, v2, v21, v23, v24, v3, v4, v5, v6 uintptr
	var elemCount, estCount, i, v20, v7 TTcl_Size
	var v1 int64
	var v12 int32
	var v22 bool
	var _ /* done at bp+56 */ int32
	var _ /* elemSize at bp+104 */ TTcl_Size
	var _ /* elemStart at bp+96 */ uintptr
	var _ /* keyPtr at bp+16 */ uintptr
	var _ /* length at bp+72 */ TTcl_Size
	var _ /* limit at bp+80 */ uintptr
	var _ /* listRep at bp+0 */ TListRep
	var _ /* literal at bp+112 */ int32
	var _ /* nextElem at bp+88 */ uintptr
	var _ /* search at bp+32 */ TTcl_DictSearch
	var _ /* size at bp+64 */ TTcl_Size
	var _ /* valuePtr at bp+24 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _isobjPtr, _objPtr, cachePtr, check, elemCount, elemPtrs, estCount, i, proc, proc1, v1, v10, v11, v12, v14, v15, v19, v2, v20, v21, v22, v23, v24, v3, v4, v5, v6, v7
	/*
	 * Dictionaries are a special case; they have a string representation such
	 * that *all* valid dictionaries are valid lists. Hence we can convert
	 * more directly. Only do this when there's no existing string rep; if
	 * there is, it is the string rep that's authoritative (because it could
	 * describe duplicate keys).
	 */
	if !((*TTcl_Obj)(unsafe.Pointer(objPtr2)).Fbytes != libc.UintptrFromInt32(0)) && (*TTcl_Obj)(unsafe.Pointer(objPtr2)).FtypePtr == uintptr(unsafe.Pointer(&XtclDictType)) {
		/*
		 * Create the new list representation. Note that we do not need to do
		 * anything with the string representation as the transformation (and
		 * the reverse back to a dictionary) are both order-preserving. Also
		 * note that since we know we've got a valid dictionary (by
		 * representation) we also know that fetching the size of the
		 * dictionary or iterating over it will not fail.
		 */
		XTcl_DictObjSize(tls, libc.UintptrFromInt32(0), objPtr2, bp+64)
		/* TODO - leave space in front and/or back? */
		if *(*TTcl_Size)(unsafe.Pointer(bp + 64)) > 0 {
			v1 = int64(2) * *(*TTcl_Size)(unsafe.Pointer(bp + 64))
		} else {
			v1 = int64(1)
		}
		if _ListRepInitAttempt(tls, interp1, v1, libc.UintptrFromInt32(0), bp) != TCL_OK {
			return int32(TCL_ERROR)
		}
		/* Guard against future changes */
		(*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FnumUsed = int64(2) * *(*TTcl_Size)(unsafe.Pointer(bp + 64))
		/* Populate the list representation. */
		elemPtrs = (*(*TListRep)(unsafe.Pointer(bp))).FstorePtr + 40
		XTcl_DictObjFirst(tls, libc.UintptrFromInt32(0), objPtr2, bp+32, bp+16, bp+24, bp+56)
		for !(*(*int32)(unsafe.Pointer(bp + 56)) != 0) {
			v2 = elemPtrs
			elemPtrs += 8
			*(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(bp + 16))
			v3 = elemPtrs
			elemPtrs += 8
			*(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(bp + 24))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount++
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).FrefCount++
			XTcl_DictObjNext(tls, bp+32, bp+16, bp+24, bp+56)
		}
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr2)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+56) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+56) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr2)).FtypePtr)).Fversion) {
			v4 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr2)).FtypePtr)).FindexProc
		} else {
			v4 = libc.UintptrFromInt32(0)
		}
		if v4 != 0 {
			v5 = objPtr2
			if (*TTcl_Obj)(unsafe.Pointer(v5)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+48) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+48) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v5)).FtypePtr)).Fversion) {
				v6 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v5)).FtypePtr)).FlengthProc
			} else {
				v6 = libc.UintptrFromInt32(0)
			}
			proc = v6
			v7 = (*(*func(*libc.TLS, uintptr) TTcl_Size)(unsafe.Pointer(&struct{ uintptr }{proc})))(tls, v5)
			goto _8
		_8:
			elemCount = v7
			if _ListRepInitAttempt(tls, interp1, elemCount, libc.UintptrFromInt32(0), bp) != TCL_OK {
				return int32(TCL_ERROR)
			}
			/* Guard against future changes */
			elemPtrs = (*(*TListRep)(unsafe.Pointer(bp))).FstorePtr + 40
			/* Each iteration, store a list element */
			i = 0
			for {
				if !(i < elemCount) {
					break
				}
				v10 = objPtr2
				if (*TTcl_Obj)(unsafe.Pointer(v10)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+56) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+56) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v10)).FtypePtr)).Fversion) {
					v11 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(v10)).FtypePtr)).FindexProc
				} else {
					v11 = libc.UintptrFromInt32(0)
				}
				proc1 = v11
				v12 = (*(*func(*libc.TLS, uintptr, uintptr, TTcl_Size, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{proc1})))(tls, interp1, v10, i, elemPtrs)
				goto _13
			_13:
				if v12 != TCL_OK {
					return int32(TCL_ERROR)
				}
				v14 = elemPtrs
				elemPtrs += 8
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(v14)))).FrefCount++ /* Since list now holds ref to it. */
				goto _9
			_9:
				;
				i++
			}
			(*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FnumUsed = elemCount
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr2)).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 72)) = (*TTcl_Obj)(unsafe.Pointer(objPtr2)).Flength
				v15 = (*TTcl_Obj)(unsafe.Pointer(objPtr2)).Fbytes
			} else {
				v15 = XTcl_GetStringFromObj(tls, objPtr2, bp+72)
			}
			*(*uintptr)(unsafe.Pointer(bp + 88)) = v15
			/*
			 * Allocate enough space to hold a (Tcl_Obj *) for each
			 * (possible) list element.
			 */
			estCount = XTclMaxListLength(tls, *(*uintptr)(unsafe.Pointer(bp + 88)), *(*TTcl_Size)(unsafe.Pointer(bp + 72)), bp+80)
			estCount += libc.BoolInt64(estCount == libc.Int64FromInt32(0)) /* Smallest list struct holds 1
			 * element. */
			/* TODO - allocate additional space? */
			if _ListRepInitAttempt(tls, interp1, estCount, libc.UintptrFromInt32(0), bp) != TCL_OK {
				return int32(TCL_ERROR)
			}
			/* Guard against future changes */
			elemPtrs = (*(*TListRep)(unsafe.Pointer(bp))).FstorePtr + 40
			/* Each iteration, parse and store a list element. */
		_17:
			;
			if !(*(*uintptr)(unsafe.Pointer(bp + 88)) < *(*uintptr)(unsafe.Pointer(bp + 80))) {
				goto _16
			}
			if !(TCL_OK != XTclFindElement(tls, interp1, *(*uintptr)(unsafe.Pointer(bp + 88)), int64(*(*uintptr)(unsafe.Pointer(bp + 80)))-int64(*(*uintptr)(unsafe.Pointer(bp + 88))), bp+96, bp+88, bp+104, bp+112)) {
				goto _18
			}
			goto fail
		fail:
			;
			for {
				elemPtrs -= 8
				v19 = elemPtrs
				if !(v19 >= (*(*TListRep)(unsafe.Pointer(bp))).FstorePtr+40) {
					break
				}
				_objPtr = *(*uintptr)(unsafe.Pointer(elemPtrs))
				v21 = _objPtr
				v20 = *(*TTcl_Size)(unsafe.Pointer(v21))
				*(*TTcl_Size)(unsafe.Pointer(v21))--
				if v20 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
			XTclpFree(tls, (*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)
			return int32(TCL_ERROR)
		_18:
			;
			if *(*uintptr)(unsafe.Pointer(bp + 96)) == *(*uintptr)(unsafe.Pointer(bp + 80)) {
				goto _16
			}
			if v22 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v22 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v22 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				*(*uintptr)(unsafe.Pointer(elemPtrs)) = XTclThreadAllocObj(tls)
			} else {
				*(*uintptr)(unsafe.Pointer(elemPtrs)) = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(elemPtrs)) + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(elemPtrs)))).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(elemPtrs)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(elemPtrs)))).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(elemPtrs)))).FtypePtr = libc.UintptrFromInt32(0)
			_isobjPtr = *(*uintptr)(unsafe.Pointer(elemPtrs))
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
				if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
			}
			if *(*int32)(unsafe.Pointer(bp + 112)) != 0 {
				v23 = *(*uintptr)(unsafe.Pointer(bp + 96))
			} else {
				v23 = libc.UintptrFromInt32(0)
			}
			check = XTcl_InitStringRep(tls, *(*uintptr)(unsafe.Pointer(elemPtrs)), v23, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 104))))
			if *(*TTcl_Size)(unsafe.Pointer(bp + 104)) != 0 && check == libc.UintptrFromInt32(0) {
				_MemoryAllocationError(tls, interp1, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 104))))
				goto fail
			}
			if !(*(*int32)(unsafe.Pointer(bp + 112)) != 0) {
				XTcl_InitStringRep(tls, *(*uintptr)(unsafe.Pointer(elemPtrs)), libc.UintptrFromInt32(0), libc.Uint64FromInt64(XTclCopyAndCollapse(tls, *(*TTcl_Size)(unsafe.Pointer(bp + 104)), *(*uintptr)(unsafe.Pointer(bp + 96)), check)))
			}
			v24 = elemPtrs
			elemPtrs += 8
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(v24)))).FrefCount++ /* Since list now holds ref to it. */
			goto _17
		_16:
			;
			(*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr)).FnumUsed = (int64(elemPtrs) - T__predefined_ptrdiff_t((*(*TListRep)(unsafe.Pointer(bp))).FstorePtr+40)) / 8
		}
	}
	/*
	 * Store the new internalRep. We do this as late
	 * as possible to allow the conversion code, in particular
	 * Tcl_GetStringFromObj, to use the old internalRep.
	 */
	/*
	 * Note old string representation NOT to be invalidated.
	 * So do NOT use ListObjReplaceRepAndInvalidate. InternalRep to be freed AFTER
	 * IncrRefs so do not use ListObjOverwriteRep
	 */
	(*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FrefCount++
	if (*TListRep)(unsafe.Pointer(bp)).FspanPtr != 0 {
		(*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FspanPtr)).FrefCount++
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr2)).FtypePtr != libc.UintptrFromInt32(0) {
		if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr2)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr2)).FtypePtr)).FfreeIntRepProc})))(tls, objPtr2)
		}
		(*TTcl_Obj)(unsafe.Pointer(objPtr2)).FtypePtr = libc.UintptrFromInt32(0)
	}
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr2 + 32))).Fptr1 = (*(*TListRep)(unsafe.Pointer(bp))).FstorePtr
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr2 + 32))).Fptr2 = (*(*TListRep)(unsafe.Pointer(bp))).FspanPtr
	(*TTcl_Obj)(unsafe.Pointer(objPtr2)).FtypePtr = uintptr(unsafe.Pointer(&XtclListType))
	return TCL_OK
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * UpdateStringOfList --
//	 *
//	 *	Update the string representation for a list object.
//	 *
//	 *	Any previously-existing string representation is not invalidated, so
//	 *	storage is lost if this has not been taken care of.
//	 *
//	 * Effect
//	 *
//	 *	The string representation of 'listPtr' is set to the resulting string.
//	 *	This string will be empty if the list has no elements. It is assumed
//	 *	that the list internal representation is not NULL.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _UpdateStringOfList(tls *libc.TLS, listObj uintptr) {
	bp := tls.Alloc(112)
	defer tls.Free(112) /* List object with string rep to update. */
	var bytesNeeded Tsize_t
	var dst, elem, elemPtrs, flagPtr, start, v12, v13, v5, v6, p10 uintptr
	var i, numElems TTcl_Size
	var v1, v2 int64
	var v11, v4 int32
	var v7, v8 bool
	var _ /* length at bp+64 */ TTcl_Size
	var _ /* listRep at bp+72 */ TListRep
	var _ /* localFlags at bp+0 */ [64]uint8
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bytesNeeded, dst, elem, elemPtrs, flagPtr, i, numElems, start, v1, v11, v12, v13, v2, v4, v5, v6, v7, v8, p10
	flagPtr = libc.UintptrFromInt32(0)
	bytesNeeded = uint64(0)
	(*TListRep)(unsafe.Pointer(bp + 72)).FstorePtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(listObj + 32))).Fptr1
	(*TListRep)(unsafe.Pointer(bp + 72)).FspanPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(listObj + 32))).Fptr2
	if (*TListRep)(unsafe.Pointer(bp+72)).FspanPtr != 0 {
		v1 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp + 72)).FspanPtr)).FspanStart
	} else {
		v1 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp + 72)).FstorePtr)).FfirstUsed
	}
	elemPtrs = (*TListRep)(unsafe.Pointer(bp+72)).FstorePtr + 40 + uintptr(v1)*8
	if (*TListRep)(unsafe.Pointer(bp+72)).FspanPtr != 0 {
		v2 = (*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp + 72)).FspanPtr)).FspanLength
	} else {
		v2 = (*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp + 72)).FstorePtr)).FnumUsed
	}
	numElems = v2
	/*
	 * Mark the list as being canonical; although it will now have a string
	 * rep, it is one we derived through proper "canonical" quoting and so
	 * it's known to be free from nasties relating to [concat] and [eval].
	 * However, we only do this if
	 *
	 * (a) the store is not shared as a shared store may be referenced by
	 * multiple lists with different string reps. (see [a366c6efee]), AND
	 *
	 * (b) list does not have a span. Consider a list generated from a
	 * string and then this function called for a spanned list generated
	 * from the original list. We cannot mark the list store as canonical as
	 * that would also make the originating list canonical, which it may not
	 * be. On the other hand, the spanned list itself is always canonical
	 * (never generated from a string) so it does not have to be explicitly
	 * marked as such. The ListObjIsCanonical macro takes this into account.
	 * See the comments there.
	 */
	if (*TListStore)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp + 72))).FstorePtr)).FrefCount < uint64(2) && (*(*TListRep)(unsafe.Pointer(bp + 72))).FspanPtr == libc.UintptrFromInt32(0) {
		/* Invariant */
		*(*int32)(unsafe.Pointer((*(*TListRep)(unsafe.Pointer(bp + 72))).FstorePtr + 32)) |= int32(LISTSTORE_CANONICAL)
	}
	/* Handle empty list case first, so rest of the routine is simpler. */
	if numElems == 0 {
		XTcl_InitStringRep(tls, listObj, libc.UintptrFromInt32(0), uint64(0))
		return
	}
	/* Pass 1: estimate space, gather flags. */
	if numElems <= int64(LOCAL_SIZE) {
		flagPtr = bp
	} else {
		/* We know numElems <= LIST_MAX, so this is safe. */
		flagPtr = XTcl_Alloc(tls, libc.Uint64FromInt64(numElems))
	}
	i = 0
	for {
		if !(i < numElems) {
			break
		}
		if i != 0 {
			v4 = int32(TCL_DONT_QUOTE_HASH)
		} else {
			v4 = 0
		}
		*(*uint8)(unsafe.Pointer(flagPtr + uintptr(i))) = libc.Uint8FromInt32(v4)
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(elemPtrs + uintptr(i)*8)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 64)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(elemPtrs + uintptr(i)*8)))).Flength
			v5 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(elemPtrs + uintptr(i)*8)))).Fbytes
		} else {
			v5 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(elemPtrs + uintptr(i)*8)), bp+64)
		}
		elem = v5
		bytesNeeded += libc.Uint64FromInt64(XTclScanElement(tls, elem, *(*TTcl_Size)(unsafe.Pointer(bp + 64)), flagPtr+uintptr(i)))
		if bytesNeeded > uint64(0xffffffffffffffff)-libc.Uint64FromInt64(numElems) {
			XTcl_Panic(tls, __ccgo_ts+52184, libc.VaList(bp+96, uint64(0xffffffffffffffff)))
		}
		goto _3
	_3:
		;
		i++
	}
	bytesNeeded += libc.Uint64FromInt64(numElems - int64(1))
	/*
	 * Pass 2: copy into string rep buffer.
	 */
	v6 = XTcl_InitStringRep(tls, listObj, libc.UintptrFromInt32(0), bytesNeeded)
	dst = v6
	start = v6
	if v8 = bytesNeeded != 0; v8 {
		if v7 = dst != 0; !v7 {
			XTcl_Panic(tls, __ccgo_ts+10479, libc.VaList(bp+96, bytesNeeded))
		}
	}
	_ = v8 && (v7 || libc.Bool(libc.Int32FromInt32(1) != 0))
	i = 0
	for {
		if !(i < numElems) {
			break
		}
		p10 = flagPtr + uintptr(i)
		if i != 0 {
			v11 = int32(TCL_DONT_QUOTE_HASH)
		} else {
			v11 = 0
		}
		*(*uint8)(unsafe.Pointer(p10)) = uint8(int32(*(*uint8)(unsafe.Pointer(p10))) | v11)
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(elemPtrs + uintptr(i)*8)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 64)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(elemPtrs + uintptr(i)*8)))).Flength
			v12 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(elemPtrs + uintptr(i)*8)))).Fbytes
		} else {
			v12 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(elemPtrs + uintptr(i)*8)), bp+64)
		}
		elem = v12
		dst += uintptr(XTclConvertElement(tls, elem, *(*TTcl_Size)(unsafe.Pointer(bp + 64)), dst, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(flagPtr + uintptr(i))))))
		v13 = dst
		dst++
		*(*uint8)(unsafe.Pointer(v13)) = uint8(' ')
		goto _9
	_9:
		;
		i++
	}
	/* Set the string length to what was actually written, the safe choice */
	XTcl_InitStringRep(tls, listObj, libc.UintptrFromInt32(0), libc.Uint64FromInt64(int64(dst-uintptr(1))-int64(start)))
	if flagPtr != bp {
		XTclpFree(tls, flagPtr)
	}
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * TclListTestObj --
//	 *
//	 *    Returns a list object with a specific internal rep and content.
//	 *    Used specifically for testing so span can be controlled explicitly.
//	 *
//	 * Results:
//	 *    Pointer to the Tcl_Obj containing the list.
//	 *
//	 * Side effects:
//	 *    None.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func XTclListTestObj(tls *libc.TLS, length Tsize_t, leadingSpace Tsize_t, endSpace Tsize_t) (r uintptr) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var _isobjPtr, cachePtr, cachePtr1, listObj, storePtr uintptr
	var capacity, i Tsize_t
	var uw_ TTcl_WideUInt
	var v1, v3 bool
	var _ /* bignumValue_ at bp+16 */ Tmp_int
	var _ /* listRep at bp+0 */ TListRep
	_, _, _, _, _, _, _, _, _, _ = _isobjPtr, cachePtr, cachePtr1, capacity, i, listObj, storePtr, uw_, v1, v3
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		listObj = XTclThreadAllocObj(tls)
	} else {
		listObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(listObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(listObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(listObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr = libc.UintptrFromInt32(0)
	/* Only a test object so ignoring overflow checks */
	capacity = length + leadingSpace + endSpace
	if capacity == uint64(0) {
		return listObj
	}
	if capacity > libc.Uint64FromInt64(libc.Int64FromUint64((libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))-uint64(libc.UintptrFromInt32(0)+40))/libc.Uint64FromInt64(8))) {
		return libc.UintptrFromInt32(0)
	}
	_ListRepInit(tls, libc.Int64FromUint64(capacity), libc.UintptrFromInt32(0), int32(LISTREP_PANIC_ON_FAIL), bp)
	storePtr = (*(*TListRep)(unsafe.Pointer(bp))).FstorePtr
	i = uint64(0)
	for {
		if !(i < length) {
			break
		}
		if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(storePtr + 40 + uintptr(i+leadingSpace)*8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(storePtr + 40 + uintptr(i+leadingSpace)*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(storePtr + 40 + uintptr(i+leadingSpace)*8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(storePtr + 40 + uintptr(i+leadingSpace)*8)))).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(storePtr + 40 + uintptr(i+leadingSpace)*8)))).Fbytes = libc.UintptrFromInt32(0)
		uw_ = i
		if uw_ > libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) {
			if XTclBN_mp_init_u64(tls, bp+16, uw_) != MP_OKAY {
				XTcl_Panic(tls, __ccgo_ts+13273, libc.VaList(bp+48, __ccgo_ts+13293))
			}
			XTclSetBignumInternalRep(tls, *(*uintptr)(unsafe.Pointer(storePtr + 40 + uintptr(i+leadingSpace)*8)), bp+16)
		} else {
			*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(storePtr + 40 + uintptr(i+leadingSpace)*8)))).FinternalRep)) = libc.Int64FromUint64(uw_)
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(storePtr + 40 + uintptr(i+leadingSpace)*8)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(storePtr + 40 + uintptr(i+leadingSpace)*8)))).FrefCount++
		goto _2
	_2:
		;
		i++
	}
	(*TListStore)(unsafe.Pointer(storePtr)).FfirstUsed = libc.Int64FromUint64(leadingSpace)
	(*TListStore)(unsafe.Pointer(storePtr)).FnumUsed = libc.Int64FromUint64(length)
	if leadingSpace != uint64(0) {
		(*(*TListRep)(unsafe.Pointer(bp))).FspanPtr = _ListSpanNew(tls, libc.Int64FromUint64(leadingSpace), libc.Int64FromUint64(length))
	}
	(*TListStore)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FstorePtr)).FrefCount++
	if (*TListRep)(unsafe.Pointer(bp)).FspanPtr != 0 {
		(*TListSpan)(unsafe.Pointer((*TListRep)(unsafe.Pointer(bp)).FspanPtr)).FrefCount++
	}
	if (*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr != libc.UintptrFromInt32(0) {
		if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr)).FfreeIntRepProc})))(tls, listObj)
		}
		(*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr = libc.UintptrFromInt32(0)
	}
	_isobjPtr = listObj
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(listObj + 32))).Fptr1 = (*TListRep)(unsafe.Pointer(bp)).FstorePtr
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(listObj + 32))).Fptr2 = (*TListRep)(unsafe.Pointer(bp)).FspanPtr
	(*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr = uintptr(unsafe.Pointer(&XtclListType))
	return listObj
}

/*
 *----------------------------------------------------------------------
 *
 * TclInitLiteralTable --
 *
 *	This function is called to initialize the fields of a literal table
 *	structure for either an interpreter or a compilation's CompileEnv
 *	structure.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The literal table is made ready for use.
 *
 *----------------------------------------------------------------------
 */

func XTclInitLiteralTable(tls *libc.TLS, tablePtr uintptr) {
	/* Pointer to table structure, which is
	 * supplied by the caller. */
	var v1, v2 uintptr
	_, _ = v1, v2
	(*TLiteralTable)(unsafe.Pointer(tablePtr)).Fbuckets = tablePtr + 8
	v1 = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(tablePtr + 8 + 1*8)) = v1
	*(*uintptr)(unsafe.Pointer(tablePtr + 8)) = v1
	v2 = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(tablePtr + 8 + 3*8)) = v2
	*(*uintptr)(unsafe.Pointer(tablePtr + 8 + 2*8)) = v2
	(*TLiteralTable)(unsafe.Pointer(tablePtr)).FnumBuckets = uint64(TCL_SMALL_HASH_TABLE)
	(*TLiteralTable)(unsafe.Pointer(tablePtr)).FnumEntries = uint64(0)
	(*TLiteralTable)(unsafe.Pointer(tablePtr)).FrebuildSize = libc.Uint64FromInt32(libc.Int32FromInt32(TCL_SMALL_HASH_TABLE) * libc.Int32FromInt32(REBUILD_MULTIPLIER))
	(*TLiteralTable)(unsafe.Pointer(tablePtr)).Fmask = uint64(3)
}

/*
 *----------------------------------------------------------------------
 *
 * TclDeleteLiteralTable --
 *
 *	This function frees up everything associated with a literal table
 *	except for the table's structure itself. It is called when the
 *	interpreter is deleted.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Each literal in the table is released: i.e., its reference count in
 *	the global literal table is decremented and, if it becomes zero, the
 *	literal is freed. In addition, the table's bucket array is freed.
 *
 *----------------------------------------------------------------------
 */

func XTclDeleteLiteralTable(tls *libc.TLS, interp uintptr, tablePtr uintptr) {
	/* Points to the literal table to delete. */
	var cachePtr, entryPtr, nextPtr, objPtr, v3 uintptr
	var i Tsize_t
	var v2 TTcl_Size
	var v4 bool
	_, _, _, _, _, _, _, _ = cachePtr, entryPtr, i, nextPtr, objPtr, v2, v3, v4
	/*
	 * Release remaining literals in the table. Note that releasing a literal
	 * might release other literals, modifying the table, so we restart the
	 * search from the bucket chain we last found an entry.
	 */
	_ = interp
	/*
	 * We used to call TclReleaseLiteral for each literal in the table, which
	 * is rather inefficient as it causes one lookup-by-hash for each
	 * reference to the literal. We now rely at interp-deletion on each
	 * bytecode object to release its references to the literal Tcl_Obj
	 * without requiring that it updates the global table itself, and deal
	 * here only with the table.
	 */
	i = uint64(0)
	for {
		if !(i < (*TLiteralTable)(unsafe.Pointer(tablePtr)).FnumBuckets) {
			break
		}
		entryPtr = *(*uintptr)(unsafe.Pointer((*TLiteralTable)(unsafe.Pointer(tablePtr)).Fbuckets + uintptr(i)*8))
		for entryPtr != libc.UintptrFromInt32(0) {
			objPtr = (*TLiteralEntry)(unsafe.Pointer(entryPtr)).FobjPtr
			v3 = objPtr
			v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
			*(*TTcl_Size)(unsafe.Pointer(v3))--
			if !(v2 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(-libc.Int32FromInt32(1))
					if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
						cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v4 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, objPtr)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(objPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = objPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, objPtr)
				}
			}
			nextPtr = (*TLiteralEntry)(unsafe.Pointer(entryPtr)).FnextPtr
			XTclpFree(tls, entryPtr)
			entryPtr = nextPtr
		}
		goto _1
	_1:
		;
		i++
	}
	/*
	 * Free up the table's bucket array if it was dynamically allocated.
	 */
	if (*TLiteralTable)(unsafe.Pointer(tablePtr)).Fbuckets != tablePtr+8 {
		XTclpFree(tls, (*TLiteralTable)(unsafe.Pointer(tablePtr)).Fbuckets)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclCreateLiteral --
 *
 *	Find, or if necessary create, an object in the interpreter's literal
 *	table that has a string representation matching the argument
 *	string. If nsPtr!=NULL then only literals stored for the namespace are
 *	considered.
 *
 * Results:
 *	The literal object. If it was created in this call *newPtr is set to
 *	1, else 0. NULL is returned if newPtr==NULL and no literal is found.
 *
 * Side effects:
 *	Increments the ref count of the global LiteralEntry since the caller
 *	now holds a reference. If LITERAL_ON_HEAP is set in flags, this
 *	function is given ownership of the string: if an object is created
 *	then its string representation is set directly from string, otherwise
 *	the string is freed. Typically, a caller sets LITERAL_ON_HEAP if
 *	"string" is an already heap-allocated buffer holding the result of
 *	backslash substitutions.
 *
 *----------------------------------------------------------------------
 */

func XTclCreateLiteral(tls *libc.TLS, iPtr uintptr, bytes uintptr, length TTcl_Size, hash Tsize_t, newPtr uintptr, nsPtr uintptr, flags int32, globalPtrPtr uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var cachePtr, globalPtr, globalTablePtr, objBytes, objPtr, v2, v4 uintptr
	var globalHash Tsize_t
	var v3 bool
	var _ /* objLength at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _ = cachePtr, globalHash, globalPtr, globalTablePtr, objBytes, objPtr, v2, v3, v4
	globalTablePtr = iPtr + 264
	/*
	 * Is it in the interpreter's global literal table?
	 */
	if hash == libc.Uint64FromInt64(int64(-libc.Int32FromInt32(1))) {
		hash = _HashString(tls, bytes, libc.Uint64FromInt64(length))
	}
	globalHash = hash & (*TLiteralTable)(unsafe.Pointer(globalTablePtr)).Fmask
	globalPtr = *(*uintptr)(unsafe.Pointer((*TLiteralTable)(unsafe.Pointer(globalTablePtr)).Fbuckets + uintptr(globalHash)*8))
	for {
		if !(globalPtr != libc.UintptrFromInt32(0)) {
			break
		}
		objPtr = (*TLiteralEntry)(unsafe.Pointer(globalPtr)).FobjPtr
		if (*TLiteralEntry)(unsafe.Pointer(globalPtr)).FnsPtr == nsPtr {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
				v2 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, objPtr, bp)
			}
			objBytes = v2
			if *(*TTcl_Size)(unsafe.Pointer(bp)) == length && (length == 0 || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(objBytes))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes))) && libc.Xmemcmp(tls, objBytes, bytes, libc.Uint64FromInt64(length)) == 0) {
				/*
				 * A literal was found: return it
				 */
				if newPtr != 0 {
					*(*int32)(unsafe.Pointer(newPtr)) = 0
				}
				if globalPtrPtr != 0 {
					*(*uintptr)(unsafe.Pointer(globalPtrPtr)) = globalPtr
				}
				if flags&int32(LITERAL_ON_HEAP) != 0 {
					XTclpFree(tls, bytes)
				}
				if (*TLiteralEntry)(unsafe.Pointer(globalPtr)).FrefCount != int64(-libc.Int32FromInt32(1)) {
					(*TLiteralEntry)(unsafe.Pointer(globalPtr)).FrefCount++
				}
				return objPtr
			}
		}
		goto _1
	_1:
		;
		globalPtr = (*TLiteralEntry)(unsafe.Pointer(globalPtr)).FnextPtr
	}
	if !(newPtr != 0) {
		if flags&int32(LITERAL_ON_HEAP) != 0 {
			XTclpFree(tls, bytes)
		}
		return libc.UintptrFromInt32(0)
	}
	/*
	 * The literal is new to the interpreter.
	 */
	if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	if flags&int32(LITERAL_ON_HEAP) != 0 {
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = bytes
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = length
	} else {
		if length == 0 {
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(length+libc.Int64FromUint32(1)))
			if bytes != 0 {
				v4 = bytes
			} else {
				v4 = uintptr(unsafe.Pointer(&XtclEmptyString))
			}
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, v4, libc.Uint64FromInt64(length))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr(length))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = length
		}
	}
	/* Should the new literal be shared globally? */
	if flags&int32(LITERAL_UNSHARED) != 0 {
		/*
		 * No, do *not* add it the global literal table
		 * Make clear, that no global value is returned
		 */
		if globalPtrPtr != libc.UintptrFromInt32(0) {
			*(*uintptr)(unsafe.Pointer(globalPtrPtr)) = libc.UintptrFromInt32(0)
		}
		return objPtr
	}
	/*
	 * Yes, add it to the global literal table.
	 */
	globalPtr = XTcl_Alloc(tls, uint64(32))
	(*TLiteralEntry)(unsafe.Pointer(globalPtr)).FobjPtr = objPtr
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount++
	(*TLiteralEntry)(unsafe.Pointer(globalPtr)).FrefCount = int64(1)
	(*TLiteralEntry)(unsafe.Pointer(globalPtr)).FnsPtr = nsPtr
	(*TLiteralEntry)(unsafe.Pointer(globalPtr)).FnextPtr = *(*uintptr)(unsafe.Pointer((*TLiteralTable)(unsafe.Pointer(globalTablePtr)).Fbuckets + uintptr(globalHash)*8))
	*(*uintptr)(unsafe.Pointer((*TLiteralTable)(unsafe.Pointer(globalTablePtr)).Fbuckets + uintptr(globalHash)*8)) = globalPtr
	(*TLiteralTable)(unsafe.Pointer(globalTablePtr)).FnumEntries++
	/*
	 * If the global literal table has exceeded a decent size, rebuild it with
	 * more buckets.
	 */
	if (*TLiteralTable)(unsafe.Pointer(globalTablePtr)).FnumEntries >= (*TLiteralTable)(unsafe.Pointer(globalTablePtr)).FrebuildSize {
		_RebuildLiteralTable(tls, globalTablePtr)
	}
	if globalPtrPtr != 0 {
		*(*uintptr)(unsafe.Pointer(globalPtrPtr)) = globalPtr
	}
	*(*int32)(unsafe.Pointer(newPtr)) = int32(1)
	return objPtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclFetchLiteral --
 *
 *	Fetch from a CompileEnv the literal value identified by an index
 *	value, as returned by a prior call to TclRegisterLiteral().
 *
 * Results:
 *	The literal value, or NULL if the index is out of range.
 *
 *----------------------------------------------------------------------
 */

func XTclFetchLiteral(tls *libc.TLS, envPtr uintptr, index TTcl_Size) (r uintptr) {
	/* Index of the desired literal, as returned
	 * by prior call to TclRegisterLiteral() */
	if index >= (*TCompileEnv)(unsafe.Pointer(envPtr)).FliteralArrayNext {
		return libc.UintptrFromInt32(0)
	}
	return (*(*TLiteralEntry)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FliteralArrayPtr + uintptr(index)*32))).FobjPtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclRegisterLiteral --
 *
 *	Find, or if necessary create, an object in a CompileEnv literal array
 *	that has a string representation matching the argument string.
 *
 * Results:
 *	The index in the CompileEnv's literal array that references a shared
 *	literal matching the string. The object is created if necessary.
 *
 * Side effects:
 *	To maximize sharing, we look up the string in the interpreter's global
 *	literal table. If not found, we create a new shared literal in the
 *	global table. We then add a reference to the shared literal in the
 *	CompileEnv's literal array.
 *
 *	If LITERAL_ON_HEAP is set in flags, this function is given ownership
 *	of the string: if an object is created then its string representation
 *	is set directly from string, otherwise the string is freed. Typically,
 *	a caller sets LITERAL_ON_HEAP if "string" is an already heap-allocated
 *	buffer holding the result of backslash substitutions.
 *
 *----------------------------------------------------------------------
 */

func XTclRegisterLiteral(tls *libc.TLS, ePtr uintptr, bytes uintptr, length TTcl_Size, flags int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* If LITERAL_ON_HEAP then the caller already
	 * malloc'd bytes and ownership is passed to
	 * this function. If LITERAL_CMD_NAME then
	 * the literal should not be shared across
	 * namespaces. */
	var envPtr, iPtr, localPtr, localTablePtr, nsPtr, objPtr uintptr
	var hash, localHash, objIndex Tsize_t
	var v1 uint64
	var _ /* globalPtr at bp+0 */ uintptr
	var _ /* isNew at bp+8 */ int32
	_, _, _, _, _, _, _, _, _, _ = envPtr, hash, iPtr, localHash, localPtr, localTablePtr, nsPtr, objIndex, objPtr, v1
	envPtr = ePtr
	iPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FiPtr
	localTablePtr = envPtr + 72
	if length < 0 {
		if bytes != 0 {
			v1 = libc.Xstrlen(tls, bytes)
		} else {
			v1 = uint64(0)
		}
		length = libc.Int64FromUint64(v1)
	}
	hash = _HashString(tls, bytes, libc.Uint64FromInt64(length))
	/*
	 * Is the literal already in the CompileEnv's local literal array? If so,
	 * just return its index.
	 */
	localHash = hash & (*TLiteralTable)(unsafe.Pointer(localTablePtr)).Fmask
	localPtr = *(*uintptr)(unsafe.Pointer((*TLiteralTable)(unsafe.Pointer(localTablePtr)).Fbuckets + uintptr(localHash)*8))
	for {
		if !(localPtr != libc.UintptrFromInt32(0)) {
			break
		}
		objPtr = (*TLiteralEntry)(unsafe.Pointer(localPtr)).FobjPtr
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength == length && (length == 0 || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes))) && libc.Xmemcmp(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, bytes, libc.Uint64FromInt64(length)) == 0) {
			if flags&int32(LITERAL_ON_HEAP) != 0 {
				XTclpFree(tls, bytes)
			}
			objIndex = libc.Uint64FromInt64((int64(localPtr) - int64((*TCompileEnv)(unsafe.Pointer(envPtr)).FliteralArrayPtr)) / 32)
			if objIndex > uint64(INT_MAX) {
				XTcl_Panic(tls, __ccgo_ts+52230, 0)
			}
			return libc.Int32FromUint64(objIndex)
		}
		goto _2
	_2:
		;
		localPtr = (*TLiteralEntry)(unsafe.Pointer(localPtr)).FnextPtr
	}
	/*
	 * The literal is new to this CompileEnv. If it is a command name, avoid
	 * sharing it across namespaces, and try not to share it with non-cmd
	 * literals. Note that FQ command names can be shared, so that we register
	 * the namespace as the interp's global NS.
	 */
	if flags&int32(LITERAL_CMD_NAME) != 0 {
		if length >= int64(2) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes))) == int32(':') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes + 1))) == int32(':') {
			nsPtr = (*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr
		} else {
			nsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FnsPtr
		}
	} else {
		nsPtr = libc.UintptrFromInt32(0)
	}
	/*
	 * Is it in the interpreter's global literal table? If not, create it.
	 */
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	objPtr = XTclCreateLiteral(tls, iPtr, bytes, length, hash, bp+8, nsPtr, flags, bp)
	objIndex = _AddLocalLiteralEntry(tls, envPtr, objPtr, libc.Int32FromUint64(localHash))
	if objIndex > uint64(INT_MAX) {
		XTcl_Panic(tls, __ccgo_ts+52230, 0)
	}
	return libc.Int32FromUint64(objIndex)
}

/*
 *----------------------------------------------------------------------
 *
 * TclHideLiteral --
 *
 *	Remove a literal entry from the literal hash tables, leaving it in the
 *	literal array so existing references continue to function. This makes
 *	it possible to turn a shared literal into a private literal that
 *	cannot be shared.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Removes the literal from the local hash table and decrements the
 *	global hash entry's reference count.
 *
 *----------------------------------------------------------------------
 */

func XTclHideLiteral(tls *libc.TLS, interp uintptr, envPtr uintptr, index int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The index of the entry in the literal
	 * array. */
	var bytes, entryPtr, lPtr, localTablePtr, newObjPtr, nextPtrPtr, v1 uintptr
	var localHash Tsize_t
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _ = bytes, entryPtr, lPtr, localHash, localTablePtr, newObjPtr, nextPtrPtr, v1
	localTablePtr = envPtr + 72
	lPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FliteralArrayPtr + uintptr(index)*32
	/*
	 * To avoid unwanted sharing we need to copy the object and remove it from
	 * the local and global literal tables. It still has a slot in the literal
	 * array so it can be referred to by byte codes, but it will not be
	 * matched by literal searches.
	 */
	newObjPtr = XTcl_DuplicateObj(tls, (*TLiteralEntry)(unsafe.Pointer(lPtr)).FobjPtr)
	(*TTcl_Obj)(unsafe.Pointer(newObjPtr)).FrefCount++
	XTclReleaseLiteral(tls, interp, (*TLiteralEntry)(unsafe.Pointer(lPtr)).FobjPtr)
	(*TLiteralEntry)(unsafe.Pointer(lPtr)).FobjPtr = newObjPtr
	if (*TTcl_Obj)(unsafe.Pointer(newObjPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(newObjPtr)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(newObjPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, newObjPtr, bp)
	}
	bytes = v1
	localHash = _HashString(tls, bytes, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))) & (*TLiteralTable)(unsafe.Pointer(localTablePtr)).Fmask
	nextPtrPtr = (*TLiteralTable)(unsafe.Pointer(localTablePtr)).Fbuckets + uintptr(localHash)*8
	entryPtr = *(*uintptr)(unsafe.Pointer(nextPtrPtr))
	for {
		if !(entryPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if entryPtr == lPtr {
			*(*uintptr)(unsafe.Pointer(nextPtrPtr)) = (*TLiteralEntry)(unsafe.Pointer(lPtr)).FnextPtr
			(*TLiteralEntry)(unsafe.Pointer(lPtr)).FnextPtr = libc.UintptrFromInt32(0)
			(*TLiteralTable)(unsafe.Pointer(localTablePtr)).FnumEntries--
			break
		}
		nextPtrPtr = entryPtr
		goto _2
	_2:
		;
		entryPtr = *(*uintptr)(unsafe.Pointer(nextPtrPtr))
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclAddLiteralObj --
 *
 *	Add a single literal object to the literal array. This function does
 *	not add the literal to the local or global literal tables. The caller
 *	is expected to add the entry to whatever tables are appropriate.
 *
 * Results:
 *	The index in the CompileEnv's literal array that references the
 *	literal. Stores the pointer to the new literal entry in the location
 *	referenced by the localPtrPtr argument.
 *
 * Side effects:
 *	Expands the literal array if necessary. Increments the refcount on the
 *	literal object.
 *
 *----------------------------------------------------------------------
 */

func XTclAddLiteralObj(tls *libc.TLS, envPtr uintptr, objPtr uintptr, litPtrPtr uintptr) (r int32) {
	/* The location where the pointer to the new
	 * literal entry should be stored. May be
	 * NULL. */
	var lPtr uintptr
	var objIndex Tsize_t
	_, _ = lPtr, objIndex
	if (*TCompileEnv)(unsafe.Pointer(envPtr)).FliteralArrayNext >= (*TCompileEnv)(unsafe.Pointer(envPtr)).FliteralArrayEnd {
		_ExpandLocalLiteralArray(tls, envPtr)
	}
	objIndex = libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr)).FliteralArrayNext)
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FliteralArrayNext++
	if objIndex > uint64(INT_MAX) {
		XTcl_Panic(tls, __ccgo_ts+52230, 0)
	}
	lPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FliteralArrayPtr + uintptr(objIndex)*32
	(*TLiteralEntry)(unsafe.Pointer(lPtr)).FobjPtr = objPtr
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount++
	(*TLiteralEntry)(unsafe.Pointer(lPtr)).FrefCount = int64(-libc.Int32FromInt32(1)) /* i.e., unused */
	(*TLiteralEntry)(unsafe.Pointer(lPtr)).FnextPtr = libc.UintptrFromInt32(0)
	if litPtrPtr != 0 {
		*(*uintptr)(unsafe.Pointer(litPtrPtr)) = lPtr
	}
	return libc.Int32FromUint64(objIndex)
}

/*
 *----------------------------------------------------------------------
 *
 * AddLocalLiteralEntry --
 *
 *	Insert a new literal into a CompileEnv's local literal array.
 *
 * Results:
 *	The index in the CompileEnv's literal array that references the
 *	literal.
 *
 * Side effects:
 *	Expands the literal array if necessary. May rebuild the hash bucket
 *	array of the CompileEnv's literal array if it becomes too large.
 *
 *----------------------------------------------------------------------
 */

func _AddLocalLiteralEntry(tls *libc.TLS, envPtr uintptr, objPtr uintptr, localHash int32) (r Tsize_t) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Hash value for the literal's string. */
	var localTablePtr uintptr
	var objIndex Tsize_t
	var _ /* localPtr at bp+0 */ uintptr
	_, _ = localTablePtr, objIndex
	localTablePtr = envPtr + 72
	objIndex = libc.Uint64FromInt32(XTclAddLiteralObj(tls, envPtr, objPtr, bp))
	/*
	 * Add the literal to the local table.
	 */
	(*TLiteralEntry)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = *(*uintptr)(unsafe.Pointer((*TLiteralTable)(unsafe.Pointer(localTablePtr)).Fbuckets + uintptr(localHash)*8))
	*(*uintptr)(unsafe.Pointer((*TLiteralTable)(unsafe.Pointer(localTablePtr)).Fbuckets + uintptr(localHash)*8)) = *(*uintptr)(unsafe.Pointer(bp))
	(*TLiteralTable)(unsafe.Pointer(localTablePtr)).FnumEntries++
	/*
	 * If the CompileEnv's local literal table has exceeded a decent size,
	 * rebuild it with more buckets.
	 */
	if (*TLiteralTable)(unsafe.Pointer(localTablePtr)).FnumEntries >= (*TLiteralTable)(unsafe.Pointer(localTablePtr)).FrebuildSize {
		_RebuildLiteralTable(tls, localTablePtr)
	}
	return objIndex
}

/*
 *----------------------------------------------------------------------
 *
 * ExpandLocalLiteralArray --
 *
 *	Function that uses malloc to allocate more storage for a CompileEnv's
 *	local literal array.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The literal array in *envPtr is reallocated to a new array of double
 *	the size, and if envPtr->mallocedLiteralArray is non-zero the old
 *	array is freed. Entries are copied from the old array to the new one.
 *	The local literal table is updated to refer to the new entries.
 *
 *----------------------------------------------------------------------
 */

func _ExpandLocalLiteralArray(tls *libc.TLS, envPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Points to the CompileEnv whose object array
	 * must be enlarged. */
	var currArrayPtr, localTablePtr, newArrayPtr uintptr
	var currBytes, currElems, i, newSize Tsize_t
	var v1 uint64
	_, _, _, _, _, _, _, _ = currArrayPtr, currBytes, currElems, i, localTablePtr, newArrayPtr, newSize, v1
	/*
	 * The current allocated local literal entries are stored between elements
	 * 0 and (envPtr->literalArrayNext - 1) [inclusive].
	 */
	localTablePtr = envPtr + 72
	currElems = libc.Uint64FromInt64((*TCompileEnv)(unsafe.Pointer(envPtr)).FliteralArrayNext)
	currBytes = currElems * libc.Uint64FromInt64(32)
	currArrayPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FliteralArrayPtr
	if currBytes <= uint64(libc.Uint32FromUint32(0xffffffff)/libc.Uint32FromInt32(2)) {
		v1 = uint64(2) * currBytes
	} else {
		v1 = uint64(0xffffffff)
	}
	newSize = v1
	if currBytes == newSize {
		XTcl_Panic(tls, __ccgo_ts+52294, libc.VaList(bp+8, currElems))
	}
	if (*TCompileEnv)(unsafe.Pointer(envPtr)).FmallocedLiteralArray != 0 {
		newArrayPtr = XTcl_Realloc(tls, currArrayPtr, newSize)
	} else {
		/*
		 * envPtr->literalArrayPtr isn't a Tcl_Alloc'd pointer, so we must
		 * code a Tcl_Realloc equivalent for ourselves.
		 */
		newArrayPtr = XTcl_Alloc(tls, newSize)
		libc.Xmemcpy(tls, newArrayPtr, currArrayPtr, currBytes)
		(*TCompileEnv)(unsafe.Pointer(envPtr)).FmallocedLiteralArray = int32(1)
	}
	/*
	 * Update the local literal table's bucket array.
	 */
	if currArrayPtr != newArrayPtr {
		i = uint64(0)
		for {
			if !(i < currElems) {
				break
			}
			if (*(*TLiteralEntry)(unsafe.Pointer(newArrayPtr + uintptr(i)*32))).FnextPtr != libc.UintptrFromInt32(0) {
				(*(*TLiteralEntry)(unsafe.Pointer(newArrayPtr + uintptr(i)*32))).FnextPtr = newArrayPtr + uintptr((int64((*(*TLiteralEntry)(unsafe.Pointer(newArrayPtr + uintptr(i)*32))).FnextPtr)-int64(currArrayPtr))/32)*32
			}
			goto _2
		_2:
			;
			i++
		}
		i = uint64(0)
		for {
			if !(i < (*TLiteralTable)(unsafe.Pointer(localTablePtr)).FnumBuckets) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TLiteralTable)(unsafe.Pointer(localTablePtr)).Fbuckets + uintptr(i)*8)) != libc.UintptrFromInt32(0) {
				*(*uintptr)(unsafe.Pointer((*TLiteralTable)(unsafe.Pointer(localTablePtr)).Fbuckets + uintptr(i)*8)) = newArrayPtr + uintptr((int64(*(*uintptr)(unsafe.Pointer((*TLiteralTable)(unsafe.Pointer(localTablePtr)).Fbuckets + uintptr(i)*8)))-int64(currArrayPtr))/32)*32
			}
			goto _3
		_3:
			;
			i++
		}
	}
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FliteralArrayPtr = newArrayPtr
	(*TCompileEnv)(unsafe.Pointer(envPtr)).FliteralArrayEnd = libc.Int64FromUint64(newSize / uint64(32))
}

/*
 *----------------------------------------------------------------------
 *
 * TclReleaseLiteral --
 *
 *	This function releases a reference to one of the shared Tcl objects
 *	that hold literals. It is called to release the literals referenced by
 *	a ByteCode that is being destroyed, and it is also called by
 *	TclDeleteLiteralTable.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The reference count for the global LiteralTable entry that corresponds
 *	to the literal is decremented. If no other reference to a global
 *	literal object remains, it is freed.
 *
 *----------------------------------------------------------------------
 */

func XTclReleaseLiteral(tls *libc.TLS, interp uintptr, objPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Points to a literal object that was
	 * previously created by a call to
	 * TclRegisterLiteral. */
	var _objPtr, bytes, cachePtr, entryPtr, globalTablePtr, iPtr, prevPtr, v1, v10, v4, v7 uintptr
	var index Tsize_t
	var v3, v6, v9 TTcl_Size
	var v5, v8 bool
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, bytes, cachePtr, entryPtr, globalTablePtr, iPtr, index, prevPtr, v1, v10, v3, v4, v5, v6, v7, v8, v9
	iPtr = interp
	if iPtr == libc.UintptrFromInt32(0) {
		goto done
	}
	globalTablePtr = iPtr + 264
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, objPtr, bp)
	}
	bytes = v1
	index = _HashString(tls, bytes, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))) & (*TLiteralTable)(unsafe.Pointer(globalTablePtr)).Fmask
	/*
	 * Check to see if the object is in the global literal table and remove
	 * this reference. The object may not be in the table if it is a hidden
	 * local literal.
	 */
	prevPtr = libc.UintptrFromInt32(0)
	entryPtr = *(*uintptr)(unsafe.Pointer((*TLiteralTable)(unsafe.Pointer(globalTablePtr)).Fbuckets + uintptr(index)*8))
	for {
		if !(entryPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TLiteralEntry)(unsafe.Pointer(entryPtr)).FobjPtr == objPtr {
			/*
			 * If the literal is no longer being used by any ByteCode, delete
			 * the entry then remove the reference corresponding to the global
			 * literal table entry (decrement the ref count of the object).
			 */
			if v5 = (*TLiteralEntry)(unsafe.Pointer(entryPtr)).FrefCount != int64(-libc.Int32FromInt32(1)); v5 {
				v4 = entryPtr + 16
				v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
				*(*TTcl_Size)(unsafe.Pointer(v4))--
			}
			if v5 && v3 <= int64(1) {
				if prevPtr == libc.UintptrFromInt32(0) {
					*(*uintptr)(unsafe.Pointer((*TLiteralTable)(unsafe.Pointer(globalTablePtr)).Fbuckets + uintptr(index)*8)) = (*TLiteralEntry)(unsafe.Pointer(entryPtr)).FnextPtr
				} else {
					(*TLiteralEntry)(unsafe.Pointer(prevPtr)).FnextPtr = (*TLiteralEntry)(unsafe.Pointer(entryPtr)).FnextPtr
				}
				XTclpFree(tls, entryPtr)
				(*TLiteralTable)(unsafe.Pointer(globalTablePtr)).FnumEntries--
				v7 = objPtr
				v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
				*(*TTcl_Size)(unsafe.Pointer(v7))--
				if !(v6 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(-libc.Int32FromInt32(1))
						if v8 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v8 {
							cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v8 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, objPtr)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(objPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = objPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, objPtr)
					}
				}
			}
			break
		}
		goto _2
	_2:
		;
		prevPtr = entryPtr
		entryPtr = (*TLiteralEntry)(unsafe.Pointer(entryPtr)).FnextPtr
	}
	/*
	 * Remove the reference corresponding to the local literal table entry.
	 */
	goto done
done:
	;
	_objPtr = objPtr
	v10 = _objPtr
	v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
	*(*TTcl_Size)(unsafe.Pointer(v10))--
	if v9 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * HashString --
 *
 *	Compute a one-word summary of a text string, which can be used to
 *	generate a hash index.
 *
 * Results:
 *	The return value is a one-word summary of the information in string.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _HashString(tls *libc.TLS, string1 uintptr, length Tsize_t) (r Tsize_t) {
	/* Number of bytes in the string. */
	var result, v1 Tsize_t
	var v2 uintptr
	_, _, _ = result, v1, v2
	result = uint64(0)
	/*
	 * I tried a zillion different hash functions and asked many other people
	 * for advice. Many people had their own favorite functions, all
	 * different, but no-one had much idea why they were good ones. I chose
	 * the one below (multiply by 9 and add new character) because of the
	 * following reasons:
	 *
	 * 1. Multiplying by 10 is perfect for keys that are decimal strings, and
	 *    multiplying by 9 is just about as good.
	 * 2. Times-9 is (shift-left-3) plus (old). This means that each
	 *    character's bits hang around in the low-order bits of the hash value
	 *    for ever, plus they spread fairly rapidly up to the high-order bits
	 *    to fill out the hash value. This seems works well both for decimal
	 *    and non-decimal strings.
	 *
	 * Note that this function is very weak against malicious strings; it's
	 * very easy to generate multiple keys that have the same hashcode. On the
	 * other hand, that hardly ever actually occurs and this function *is*
	 * very cheap, even by comparison with industry-standard hashes like FNV.
	 * If real strength of hash is required though, use a custom hash based on
	 * Bob Jenkins's lookup3(), but be aware that it's significantly slower.
	 * Tcl scripts tend to not have a big issue in this area, and literals
	 * mostly aren't looked up by name anyway.
	 *
	 * See also HashStringKey in tclHash.c.
	 * See also TclObjHashKey in tclObj.c.
	 *
	 * See [tcl-Feature Request #2958832]
	 */
	if length > uint64(0) {
		result = uint64(*(*uint8)(unsafe.Pointer(string1)))
		for {
			length--
			v1 = length
			if !(v1 != 0) {
				break
			}
			string1++
			v2 = string1
			result += result<<libc.Int32FromInt32(3) + uint64(*(*uint8)(unsafe.Pointer(v2)))
		}
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * RebuildLiteralTable --
 *
 *	This function is invoked when the ratio of entries to hash buckets
 *	becomes too large in a local or global literal table. It allocates a
 *	larger bucket array and moves the entries into the new buckets.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Memory gets reallocated and entries get rehashed into new buckets.
 *
 *----------------------------------------------------------------------
 */

func _RebuildLiteralTable(tls *libc.TLS, tablePtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	/* Local or global table to enlarge. */
	var bucketPtr, bytes, entryPtr, newChainPtr, oldBuckets, oldChainPtr, v4 uintptr
	var count, index, oldSize Tsize_t
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _ = bucketPtr, bytes, count, entryPtr, index, newChainPtr, oldBuckets, oldChainPtr, oldSize, v4
	oldSize = (*TLiteralTable)(unsafe.Pointer(tablePtr)).FnumBuckets
	oldBuckets = (*TLiteralTable)(unsafe.Pointer(tablePtr)).Fbuckets
	/*
	 * Allocate and initialize the new bucket array, and set up hashing
	 * constants for new array size.
	 */
	if oldSize > libc.Uint64FromUint32(0xffffffff)/(libc.Uint64FromInt32(4)*libc.Uint64FromInt64(8)) {
		/*
		 * Memory allocator limitations will not let us create the
		 * next larger table size.  Best option is to limp along
		 * with what we have.
		 */
		return
	}
	*(*Tsize_t)(unsafe.Pointer(tablePtr + 40)) *= uint64(4)
	(*TLiteralTable)(unsafe.Pointer(tablePtr)).Fbuckets = XTcl_Alloc(tls, (*TLiteralTable)(unsafe.Pointer(tablePtr)).FnumBuckets*uint64(8))
	count = (*TLiteralTable)(unsafe.Pointer(tablePtr)).FnumBuckets
	newChainPtr = (*TLiteralTable)(unsafe.Pointer(tablePtr)).Fbuckets
	for {
		if !(count > uint64(0)) {
			break
		}
		*(*uintptr)(unsafe.Pointer(newChainPtr)) = libc.UintptrFromInt32(0)
		goto _1
	_1:
		;
		count--
		newChainPtr += 8
	}
	*(*Tsize_t)(unsafe.Pointer(tablePtr + 56)) *= uint64(4)
	(*TLiteralTable)(unsafe.Pointer(tablePtr)).Fmask = (*TLiteralTable)(unsafe.Pointer(tablePtr)).Fmask<<libc.Int32FromInt32(2) + uint64(3)
	/*
	 * Rehash all of the existing entries into the new bucket array.
	 */
	oldChainPtr = oldBuckets
	for {
		if !(oldSize > uint64(0)) {
			break
		}
		entryPtr = *(*uintptr)(unsafe.Pointer(oldChainPtr))
		for {
			if !(entryPtr != libc.UintptrFromInt32(0)) {
				break
			}
			if (*TTcl_Obj)(unsafe.Pointer((*TLiteralEntry)(unsafe.Pointer(entryPtr)).FobjPtr)).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer((*TLiteralEntry)(unsafe.Pointer(entryPtr)).FobjPtr)).Flength
				v4 = (*TTcl_Obj)(unsafe.Pointer((*TLiteralEntry)(unsafe.Pointer(entryPtr)).FobjPtr)).Fbytes
			} else {
				v4 = XTcl_GetStringFromObj(tls, (*TLiteralEntry)(unsafe.Pointer(entryPtr)).FobjPtr, bp)
			}
			bytes = v4
			index = _HashString(tls, bytes, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))) & (*TLiteralTable)(unsafe.Pointer(tablePtr)).Fmask
			*(*uintptr)(unsafe.Pointer(oldChainPtr)) = (*TLiteralEntry)(unsafe.Pointer(entryPtr)).FnextPtr
			bucketPtr = (*TLiteralTable)(unsafe.Pointer(tablePtr)).Fbuckets + uintptr(index)*8
			(*TLiteralEntry)(unsafe.Pointer(entryPtr)).FnextPtr = *(*uintptr)(unsafe.Pointer(bucketPtr))
			*(*uintptr)(unsafe.Pointer(bucketPtr)) = entryPtr
			goto _3
		_3:
			;
			entryPtr = *(*uintptr)(unsafe.Pointer(oldChainPtr))
		}
		goto _2
	_2:
		;
		oldSize--
		oldChainPtr += 8
	}
	/*
	 * Free up the old bucket array, if it was dynamically allocated.
	 */
	if oldBuckets != tablePtr+8 {
		XTclpFree(tls, oldBuckets)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclInvalidateCmdLiteral --
 *
 *	Invalidate a command literal entry, if present in the literal hash
 *	tables, by resetting its internal representation. This invalidation
 *	leaves it in the literal tables and in existing literal arrays. As a
 *	result, existing references continue to work but we force a fresh
 *	command look-up upon the next use (see, in particular,
 *	TclSetCmdNameObj()).
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Resets the internal representation of the CmdName Tcl_Obj
 *	using TclFreeInternalRep().
 *
 *----------------------------------------------------------------------
 */

func XTclInvalidateCmdLiteral(tls *libc.TLS, interp uintptr, name uintptr, nsPtr uintptr) {
	/* The namespace for which to lookup and
	 * invalidate a cmd literal. */
	var iPtr, literalObjPtr uintptr
	_, _ = iPtr, literalObjPtr
	iPtr = interp
	literalObjPtr = XTclCreateLiteral(tls, iPtr, name, libc.Int64FromUint64(libc.Xstrlen(tls, name)), libc.Uint64FromInt64(int64(-libc.Int32FromInt32(1))), libc.UintptrFromInt32(0), nsPtr, 0, libc.UintptrFromInt32(0))
	if literalObjPtr != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(literalObjPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclCmdNameType)) {
			if (*TTcl_Obj)(unsafe.Pointer(literalObjPtr)).FtypePtr != libc.UintptrFromInt32(0) {
				if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(literalObjPtr)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
					(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(literalObjPtr)).FtypePtr)).FfreeIntRepProc})))(tls, literalObjPtr)
				}
				(*TTcl_Obj)(unsafe.Pointer(literalObjPtr)).FtypePtr = libc.UintptrFromInt32(0)
			}
		}
		/* Balance the refcount effects of TclCreateLiteral() above */
		(*TTcl_Obj)(unsafe.Pointer(literalObjPtr)).FrefCount++
		XTclReleaseLiteral(tls, interp, literalObjPtr)
	}
}

/* Epoch of the tcl environment
 * (if changed with tcl-env). */

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * The following structure describes a library that has been loaded either
 * dynamically (with the "load" command) or statically (as indicated by a call
 * to Tcl_StaticLibrary). All such libraries are linked together into a
 * single list for the process.
 */

type TLoadedLibrary = struct {
	FfileName           uintptr
	Fprefix             uintptr
	FloadHandle         TTcl_LoadHandle
	FinitProc           uintptr
	FsafeInitProc       uintptr
	FunloadProc         uintptr
	FsafeUnloadProc     uintptr
	FinterpRefCount     int32
	FsafeInterpRefCount int32
	FnextPtr            uintptr
}

/*
 * TCL_THREADS
 * There is a global list of libraries that is anchored at firstLibraryPtr.
 * Access to this list is governed by a mutex.
 */

var _firstLibraryPtr = libc.UintptrFromInt32(0)

/* First in list of all libraries loaded into
 * this process. */
var _libraryMutex TTcl_Mutex

/*
 * The following structure represents a particular library that has been
 * incorporated into a particular interpreter (by calling its initialization
 * function). There is a list of these structures for each interpreter, with
 * an AssocData value (key "load") for the interpreter that points to the
 * first library (if any).
 */

type TInterpLibrary = struct {
	FlibraryPtr uintptr
	FnextPtr    uintptr
}

func _IsStatic(tls *libc.TLS, libraryPtr uintptr) (r int32) {
	return libc.BoolInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FfileName))) == int32('\000'))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LoadObjCmd --
 *
 *	This function is invoked to process the "load" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LoadObjCmd(tls *libc.TLS, dummy125 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(1456)
	defer tls.Free(1456) /* Argument objects. */
	var _objPtr, _objPtr1, childIntName, defaultPtr, fullFileName, iPtr, ipFirstPtr, ipPtr, libraryPtr, p, pkgGuess, prefix, savedobjv, splitPtr, target, v1, v11, v13, v2, v3, v4, v7 uintptr
	var code, filesMatch, flags, namesMatch, offset int32
	var len1 Tsize_t
	var v10, v12 TTcl_Size
	var v9 int64
	var _ /* ch at bp+1376 */ TTcl_UniChar
	var _ /* index at bp+1380 */ int32
	var _ /* initName at bp+448 */ TTcl_DString
	var _ /* initProc at bp+1360 */ uintptr
	var _ /* loadHandle at bp+1368 */ TTcl_LoadHandle
	var _ /* pElements at bp+1392 */ TTcl_Size
	var _ /* pfx at bp+0 */ TTcl_DString
	var _ /* pkgGuessPtr at bp+1384 */ uintptr
	var _ /* safeInitName at bp+672 */ TTcl_DString
	var _ /* safeUnloadName at bp+1120 */ TTcl_DString
	var _ /* symbols at bp+1344 */ [2]uintptr
	var _ /* tmp at bp+224 */ TTcl_DString
	var _ /* unloadName at bp+896 */ TTcl_DString
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, childIntName, code, defaultPtr, filesMatch, flags, fullFileName, iPtr, ipFirstPtr, ipPtr, len1, libraryPtr, namesMatch, offset, p, pkgGuess, prefix, savedobjv, splitPtr, target, v1, v10, v11, v12, v13, v2, v3, v4, v7, v9
	*(*TTcl_UniChar)(unsafe.Pointer(bp + 1376)) = 0
	flags = 0
	savedobjv = objv
	for objc > int32(2) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) != int32('-') {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), uintptr(unsafe.Pointer(&_options17)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+1380) != TCL_OK {
			return int32(TCL_ERROR)
		}
		objv += 8
		objc--
		if 0 == *(*int32)(unsafe.Pointer(bp + 1380)) {
			flags |= int32(TCL_LOAD_GLOBAL)
		} else {
			if 1 == *(*int32)(unsafe.Pointer(bp + 1380)) {
				flags |= int32(TCL_LOAD_LAZY)
			} else {
				break
			}
		}
	}
	if objc < int32(2) || objc > int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), savedobjv, __ccgo_ts+52354)
		return int32(TCL_ERROR)
	}
	if XTcl_FSConvertToPathType(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8))) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	fullFileName = v2
	XTcl_DStringInit(tls, bp)
	XTcl_DStringInit(tls, bp+448)
	XTcl_DStringInit(tls, bp+672)
	XTcl_DStringInit(tls, bp+896)
	XTcl_DStringInit(tls, bp+1120)
	XTcl_DStringInit(tls, bp+224)
	prefix = libc.UintptrFromInt32(0)
	if objc >= int32(3) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		prefix = v3
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(prefix))) == int32('\000') {
			prefix = libc.UintptrFromInt32(0)
		}
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(fullFileName))) == 0 && prefix == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+52404, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+1408, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+52444, __ccgo_ts+52449, libc.UintptrFromInt32(0)))
		code = int32(TCL_ERROR)
		goto done
	}
	/*
	 * Figure out which interpreter we're going to load the library into.
	 */
	target = interp
	if objc == int32(4) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes != 0 {
			v4 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes
		} else {
			v4 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0))
		}
		childIntName = v4
		target = XTcl_GetChild(tls, interp, childIntName)
		if target == libc.UintptrFromInt32(0) {
			code = int32(TCL_ERROR)
			goto done
		}
	}
	/*
	 * Scan through the libraries that are currently loaded to see if the
	 * library we want is already loaded. We'll use a loaded library if it
	 * meets any of the following conditions:
	 *  - Its name and file match the once we're looking for.
	 *  - Its file matches, and we weren't given a name.
	 *  - Its name matches, the file name was specified as empty, and there is
	 *	  only no statically loaded library with the same prefix.
	 */
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_libraryMutex)))
	defaultPtr = libc.UintptrFromInt32(0)
	libraryPtr = _firstLibraryPtr
	for {
		if !(libraryPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if prefix == libc.UintptrFromInt32(0) {
			namesMatch = 0
		} else {
			XTcl_DStringSetLength(tls, bp, 0)
			XTcl_DStringAppend(tls, bp, prefix, int64(-int32(1)))
			XTcl_DStringSetLength(tls, bp+224, 0)
			XTcl_DStringAppend(tls, bp+224, (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).Fprefix, int64(-int32(1)))
			if libc.Xstrcmp(tls, (*TTcl_DString)(unsafe.Pointer(bp+224)).Fstring1, (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1) == 0 {
				namesMatch = int32(1)
			} else {
				namesMatch = 0
			}
		}
		XTcl_DStringSetLength(tls, bp, 0)
		filesMatch = libc.BoolInt32(libc.Xstrcmp(tls, (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FfileName, fullFileName) == 0)
		if filesMatch != 0 && (namesMatch != 0 || prefix == libc.UintptrFromInt32(0)) {
			break
		}
		if namesMatch != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(fullFileName))) == 0 {
			defaultPtr = libraryPtr
		}
		if filesMatch != 0 && !(namesMatch != 0) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(fullFileName))) != 0 {
			/*
			 * Can't have two different libraries loaded from the same file.
			 */
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+52459, libc.VaList(bp+1408, fullFileName, (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).Fprefix)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+1408, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+52444, __ccgo_ts+52503, libc.UintptrFromInt32(0)))
			code = int32(TCL_ERROR)
			XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_libraryMutex)))
			goto done
		}
		goto _5
	_5:
		;
		libraryPtr = (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FnextPtr
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_libraryMutex)))
	if libraryPtr == libc.UintptrFromInt32(0) {
		libraryPtr = defaultPtr
	}
	/*
	 * Scan through the list of libraries already loaded in the target
	 * interpreter. If the library we want is already loaded there, then
	 * there's nothing for us to do.
	 */
	if libraryPtr != libc.UintptrFromInt32(0) {
		ipFirstPtr = XTcl_GetAssocData(tls, target, __ccgo_ts+52520, libc.UintptrFromInt32(0))
		ipPtr = ipFirstPtr
		for {
			if !(ipPtr != libc.UintptrFromInt32(0)) {
				break
			}
			if (*TInterpLibrary)(unsafe.Pointer(ipPtr)).FlibraryPtr == libraryPtr {
				code = TCL_OK
				goto done
			}
			goto _6
		_6:
			;
			ipPtr = (*TInterpLibrary)(unsafe.Pointer(ipPtr)).FnextPtr
		}
	}
	if libraryPtr == libc.UintptrFromInt32(0) {
		/*
		 * The desired file isn't currently loaded, so load it. It's an error
		 * if the desired library is a static one.
		 */
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(fullFileName))) == 0 {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+52528, libc.VaList(bp+1408, prefix)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+1408, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+52444, __ccgo_ts+52577, libc.UintptrFromInt32(0)))
			code = int32(TCL_ERROR)
			goto done
		}
		/*
		 * Figure out the prefix if it wasn't provided explicitly.
		 */
		if prefix != libc.UintptrFromInt32(0) {
			XTcl_DStringAppend(tls, bp, prefix, int64(-int32(1)))
		} else {
			/*
			 * Threading note - this call used to be protected by a mutex.
			 */
			/*
			 * The platform-specific code couldn't figure out the prefix.
			 * Make a guess by taking the last element of the file
			 * name, stripping off any leading "lib" and/or "tcl9", and
			 * then using all of the alphabetic and underline characters
			 * that follow that.
			 */
			splitPtr = XTcl_FSSplitPath(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+1392)
			XTcl_ListObjIndex(tls, libc.UintptrFromInt32(0), splitPtr, *(*TTcl_Size)(unsafe.Pointer(bp + 1392))-int64(1), bp+1384)
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 1384)))).Fbytes != 0 {
				v7 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 1384)))).Fbytes
			} else {
				v7 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 1384)), libc.UintptrFromInt32(0))
			}
			pkgGuess = v7
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pkgGuess))) == int32('l') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pkgGuess + 1))) == int32('i') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pkgGuess + 2))) == int32('b') {
				pkgGuess += uintptr(3)
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pkgGuess))) == int32('t') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pkgGuess + 1))) == int32('c') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pkgGuess + 2))) == int32('l') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pkgGuess + 3))) == int32('9') {
				pkgGuess += uintptr(4)
			}
			p = pkgGuess
			for {
				if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != 0) {
					break
				}
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) < int32(0x80) {
					*(*TTcl_UniChar)(unsafe.Pointer(bp + 1376)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))
					v9 = int64(libc.Int32FromInt32(1))
				} else {
					v9 = XTcl_UtfToUniChar(tls, p, bp+1376)
				}
				offset = int32(v9)
				if !(XTcl_UniCharIsWordChar(tls, libc.Int32FromUint8(libc.Uint8FromInt32(*(*TTcl_UniChar)(unsafe.Pointer(bp + 1376))))) != 0) || XTcl_UniCharIsDigit(tls, libc.Int32FromUint8(libc.Uint8FromInt32(*(*TTcl_UniChar)(unsafe.Pointer(bp + 1376))))) != 0 {
					break
				}
				goto _8
			_8:
				;
				p += uintptr(offset)
			}
			if p == pkgGuess {
				_objPtr = splitPtr
				v11 = _objPtr
				v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
				*(*TTcl_Size)(unsafe.Pointer(v11))--
				if v10 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+52587, libc.VaList(bp+1408, fullFileName)))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+1408, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+52444, __ccgo_ts+52619, libc.UintptrFromInt32(0)))
				code = int32(TCL_ERROR)
				goto done
			}
			XTcl_DStringAppend(tls, bp, pkgGuess, int64(p)-int64(pkgGuess))
			_objPtr1 = splitPtr
			v13 = _objPtr1
			v12 = *(*TTcl_Size)(unsafe.Pointer(v13))
			*(*TTcl_Size)(unsafe.Pointer(v13))--
			if v12 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
			/*
			 * Fix the capitalization in the prefix so that the first
			 * character is in caps (or title case) but the others are all
			 * lower-case.
			 */
			XTcl_DStringSetLength(tls, bp, XTcl_UtfToTitle(tls, (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1))
		}
		/*
		 * Compute the names of the two initialization functions, based on the
		 * prefix.
		 */
		XTclDStringAppendDString(tls, bp+448, bp)
		XTcl_DStringAppend(tls, bp+448, __ccgo_ts+52631, libc.Int64FromUint64(libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)))
		XTclDStringAppendDString(tls, bp+672, bp)
		XTcl_DStringAppend(tls, bp+672, __ccgo_ts+52637, libc.Int64FromUint64(libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1)))
		XTclDStringAppendDString(tls, bp+896, bp)
		XTcl_DStringAppend(tls, bp+896, __ccgo_ts+52647, libc.Int64FromUint64(libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)))
		XTclDStringAppendDString(tls, bp+1120, bp)
		XTcl_DStringAppend(tls, bp+1120, __ccgo_ts+52655, libc.Int64FromUint64(libc.Uint64FromInt64(12)-libc.Uint64FromInt32(1)))
		/*
		 * Call platform-specific code to load the library and find the two
		 * initialization functions.
		 */
		(*(*[2]uintptr)(unsafe.Pointer(bp + 1344)))[0] = (*TTcl_DString)(unsafe.Pointer(bp + 448)).Fstring1
		(*(*[2]uintptr)(unsafe.Pointer(bp + 1344)))[int32(1)] = libc.UintptrFromInt32(0)
		XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_libraryMutex)))
		code = XTcl_LoadFile(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+1344, flags, bp+1360, bp+1368)
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_libraryMutex)))
		if code != TCL_OK {
			goto done
		}
		/*
		 * Create a new record to describe this library.
		 */
		libraryPtr = XTcl_Alloc(tls, uint64(72))
		len1 = libc.Xstrlen(tls, fullFileName) + uint64(1)
		(*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FfileName = XTcl_Alloc(tls, len1)
		libc.Xmemcpy(tls, (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FfileName, fullFileName, len1)
		len1 = libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(bp)).Flength + int64(1))
		(*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).Fprefix = XTcl_Alloc(tls, len1)
		libc.Xmemcpy(tls, (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).Fprefix, (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1, len1)
		(*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FloadHandle = *(*TTcl_LoadHandle)(unsafe.Pointer(bp + 1368))
		(*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FinitProc = *(*uintptr)(unsafe.Pointer(bp + 1360))
		(*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FsafeInitProc = XTcl_FindSymbol(tls, interp, *(*TTcl_LoadHandle)(unsafe.Pointer(bp + 1368)), (*TTcl_DString)(unsafe.Pointer(bp+672)).Fstring1)
		(*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FunloadProc = XTcl_FindSymbol(tls, interp, *(*TTcl_LoadHandle)(unsafe.Pointer(bp + 1368)), (*TTcl_DString)(unsafe.Pointer(bp+896)).Fstring1)
		(*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FsafeUnloadProc = XTcl_FindSymbol(tls, interp, *(*TTcl_LoadHandle)(unsafe.Pointer(bp + 1368)), (*TTcl_DString)(unsafe.Pointer(bp+1120)).Fstring1)
		(*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FinterpRefCount = 0
		(*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FsafeInterpRefCount = 0
		XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_libraryMutex)))
		(*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FnextPtr = _firstLibraryPtr
		_firstLibraryPtr = libraryPtr
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_libraryMutex)))
		/*
		 * The Tcl_FindSymbol calls may have left a spurious error message in
		 * the interpreter result.
		 */
		XTcl_ResetResult(tls, interp)
	}
	/*
	 * Invoke the library's initialization function (either the normal one or
	 * the safe one, depending on whether or not the interpreter is safe).
	 */
	if XTcl_IsSafe(tls, target) != 0 {
		if (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FsafeInitProc == libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+52667, libc.VaList(bp+1408, (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).Fprefix)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+1408, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+52444, __ccgo_ts+41864, libc.UintptrFromInt32(0)))
			code = int32(TCL_ERROR)
			goto done
		}
		code = (*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FsafeInitProc})))(tls, target)
	} else {
		if (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FinitProc == libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+52734, libc.VaList(bp+1408, (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).Fprefix)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+1408, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+52444, __ccgo_ts+52793, libc.UintptrFromInt32(0)))
			code = int32(TCL_ERROR)
			goto done
		}
		code = (*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FinitProc})))(tls, target)
	}
	/*
	 * Test for whether the initialization failed. If so, transfer the error
	 * from the target interpreter to the originating one.
	 */
	if code != TCL_OK {
		iPtr = target
		if (*TInterp)(unsafe.Pointer(iPtr)).FlegacyResult != 0 && *(*uint8)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FlegacyResult)) != 0 && !((*TInterp)(unsafe.Pointer(iPtr)).FlegacyFreeProc != 0) {
			/*
			 * A call to Tcl_InitStubs() determined the caller extension and
			 * this interp are incompatible in their stubs mechanisms, and
			 * recorded the error in the oldest legacy place we have to do so.
			 */
			XTcl_SetObjResult(tls, target, XTcl_NewStringObj(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlegacyResult, int64(-int32(1))))
			(*TInterp)(unsafe.Pointer(iPtr)).FlegacyResult = libc.UintptrFromInt32(0)
			(*TInterp)(unsafe.Pointer(iPtr)).FlegacyFreeProc = uintptr(-libc.Int32FromInt32(1))
		}
		XTcl_TransferResult(tls, target, code, interp)
		goto done
	}
	/*
	 * Record the fact that the library has been loaded in the target
	 * interpreter.
	 *
	 * Update the proper reference count.
	 */
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_libraryMutex)))
	if XTcl_IsSafe(tls, target) != 0 {
		(*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FsafeInterpRefCount++
	} else {
		(*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FinterpRefCount++
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_libraryMutex)))
	/*
	 * Refetch ipFirstPtr: loading the library may have introduced additional
	 * static libraries at the head of the linked list!
	 */
	ipFirstPtr = XTcl_GetAssocData(tls, target, __ccgo_ts+52520, libc.UintptrFromInt32(0))
	ipPtr = XTcl_Alloc(tls, uint64(16))
	(*TInterpLibrary)(unsafe.Pointer(ipPtr)).FlibraryPtr = libraryPtr
	(*TInterpLibrary)(unsafe.Pointer(ipPtr)).FnextPtr = ipFirstPtr
	XTcl_SetAssocData(tls, target, __ccgo_ts+52520, __ccgo_fp(_LoadCleanupProc), ipPtr)
	goto done
done:
	;
	XTcl_DStringFree(tls, bp)
	XTcl_DStringFree(tls, bp+448)
	XTcl_DStringFree(tls, bp+672)
	XTcl_DStringFree(tls, bp+896)
	XTcl_DStringFree(tls, bp+1120)
	XTcl_DStringFree(tls, bp+224)
	return code
}

var _options17 = [4]uintptr{
	0: __ccgo_ts + 40947,
	1: __ccgo_ts + 52348,
	2: __ccgo_ts + 18684,
	3: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UnloadObjCmd --
 *
 *	Implements the "unload" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UnloadObjCmd(tls *libc.TLS, dummy552 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(512)
	defer tls.Free(512) /* Argument objects. */
	var childIntName, fullFileName, ipFirstPtr, ipPtr, libraryPtr, prefix, target, v2, v3, v4, v5 uintptr
	var code, complain, filesMatch, i, keepLibrary, namesMatch int32
	var _ /* index at bp+448 */ int32
	var _ /* pfx at bp+0 */ TTcl_DString
	var _ /* tmp at bp+224 */ TTcl_DString
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = childIntName, code, complain, filesMatch, fullFileName, i, ipFirstPtr, ipPtr, keepLibrary, libraryPtr, namesMatch, prefix, target, v2, v3, v4, v5
	complain = int32(1)
	keepLibrary = 0
	fullFileName = __ccgo_ts + 1945
	i = int32(1)
	for {
		if !(i < objc) {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_options18)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+448) != TCL_OK {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
				v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
			}
			fullFileName = v2
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(fullFileName))) == int32('-') {
				/*
				 * It looks like the command contains an option so signal an
				 * error
				 */
				return int32(TCL_ERROR)
			} else {
				/*
				 * This clearly isn't an option; assume it's the filename. We
				 * must clear the error.
				 */
				XTcl_ResetResult(tls, interp)
				break
			}
		}
		switch *(*int32)(unsafe.Pointer(bp + 448)) {
		case 0: /* -nocomplain */
			complain = 0
		case 1: /* -keeplibrary */
			keepLibrary = int32(1)
		case 2: /* -- */
			i++
			goto endOfForLoop
		}
		goto _1
	_1:
		;
		i++
	}
	goto endOfForLoop
endOfForLoop:
	;
	if objc-i < int32(1) || objc-i > int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+52817)
		return int32(TCL_ERROR)
	}
	if XTcl_FSConvertToPathType(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
		v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
	} else {
		v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
	}
	fullFileName = v3
	XTcl_DStringInit(tls, bp)
	XTcl_DStringInit(tls, bp+224)
	prefix = libc.UintptrFromInt32(0)
	if objc-i >= int32(2) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)))).Fbytes != 0 {
			v4 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)))).Fbytes
		} else {
			v4 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)), libc.UintptrFromInt32(0))
		}
		prefix = v4
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(prefix))) == int32('\000') {
			prefix = libc.UintptrFromInt32(0)
		}
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(fullFileName))) == 0 && prefix == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+52404, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+464, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+52858, __ccgo_ts+52449, libc.UintptrFromInt32(0)))
		code = int32(TCL_ERROR)
		goto done
	}
	/*
	 * Figure out which interpreter we're going to load the library into.
	 */
	target = interp
	if objc-i == int32(3) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(2))*8)))).Fbytes != 0 {
			v5 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(2))*8)))).Fbytes
		} else {
			v5 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(2))*8)), libc.UintptrFromInt32(0))
		}
		childIntName = v5
		target = XTcl_GetChild(tls, interp, childIntName)
		if target == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
	}
	/*
	 * Scan through the libraries that are currently loaded to see if the
	 * library we want is already loaded. We'll use a loaded library if it
	 * meets any of the following conditions:
	 *  - Its prefix and file match the once we're looking for.
	 *  - Its file matches, and we weren't given a prefix.
	 *  - Its prefix matches, the file name was specified as empty, and there is
	 *	  no statically loaded library with the same prefix.
	 */
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_libraryMutex)))
	libraryPtr = _firstLibraryPtr
	for {
		if !(libraryPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if prefix == libc.UintptrFromInt32(0) {
			namesMatch = 0
		} else {
			XTcl_DStringSetLength(tls, bp, 0)
			XTcl_DStringAppend(tls, bp, prefix, int64(-int32(1)))
			XTcl_DStringSetLength(tls, bp+224, 0)
			XTcl_DStringAppend(tls, bp+224, (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).Fprefix, int64(-int32(1)))
			if libc.Xstrcmp(tls, (*TTcl_DString)(unsafe.Pointer(bp+224)).Fstring1, (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1) == 0 {
				namesMatch = int32(1)
			} else {
				namesMatch = 0
			}
		}
		XTcl_DStringSetLength(tls, bp, 0)
		filesMatch = libc.BoolInt32(libc.Xstrcmp(tls, (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FfileName, fullFileName) == 0)
		if filesMatch != 0 && (namesMatch != 0 || prefix == libc.UintptrFromInt32(0)) {
			break
		}
		if filesMatch != 0 && !(namesMatch != 0) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(fullFileName))) != 0 {
			break
		}
		goto _6
	_6:
		;
		libraryPtr = (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FnextPtr
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_libraryMutex)))
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(fullFileName))) == 0 {
		/*
		 * It's an error to try unload a static library.
		 */
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+52865, libc.VaList(bp+464, prefix)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+464, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+52858, __ccgo_ts+52934, libc.UintptrFromInt32(0)))
		code = int32(TCL_ERROR)
		goto done
	}
	if libraryPtr == libc.UintptrFromInt32(0) {
		/*
		 * The DLL pointed by the provided filename has never been loaded.
		 */
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+52941, libc.VaList(bp+464, fullFileName)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+464, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+52858, __ccgo_ts+52973, libc.UintptrFromInt32(0)))
		code = int32(TCL_ERROR)
		goto done
	}
	/*
	 * Scan through the list of libraries already loaded in the target
	 * interpreter. If the library we want is already loaded there, then we
	 * should proceed with unloading.
	 */
	code = int32(TCL_ERROR)
	if libraryPtr != libc.UintptrFromInt32(0) {
		ipFirstPtr = XTcl_GetAssocData(tls, target, __ccgo_ts+52520, libc.UintptrFromInt32(0))
		ipPtr = ipFirstPtr
		for {
			if !(ipPtr != libc.UintptrFromInt32(0)) {
				break
			}
			if (*TInterpLibrary)(unsafe.Pointer(ipPtr)).FlibraryPtr == libraryPtr {
				code = TCL_OK
				break
			}
			goto _7
		_7:
			;
			ipPtr = (*TInterpLibrary)(unsafe.Pointer(ipPtr)).FnextPtr
		}
	}
	if code != TCL_OK {
		/*
		 * The library has not been loaded in this interpreter.
		 */
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+52985, libc.VaList(bp+464, fullFileName)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+464, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+52858, __ccgo_ts+52973, libc.UintptrFromInt32(0)))
		code = int32(TCL_ERROR)
		goto done
	}
	code = _UnloadLibrary(tls, interp, target, libraryPtr, keepLibrary, fullFileName, 0)
	goto done
done:
	;
	XTcl_DStringFree(tls, bp)
	XTcl_DStringFree(tls, bp+224)
	if !(complain != 0) && code != TCL_OK {
		code = TCL_OK
		XTcl_ResetResult(tls, interp)
	}
	return code
}

var _options18 = [4]uintptr{
	0: __ccgo_ts + 22371,
	1: __ccgo_ts + 52804,
	2: __ccgo_ts + 18684,
	3: libc.UintptrFromInt32(0),
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * UnloadLibrary --
//	 *
//	 *	Unloads a library from an interpreter, and also from the process if it
//	 *	is unloadable, i.e. if it provides an "unload" function.
//	 *
//	 * Results:
//	 *	A standard Tcl result.
//	 *
//	 * Side effects:
//	 *	See description.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _UnloadLibrary(tls *libc.TLS, interp uintptr, target uintptr, libraryPtr uintptr, keepLibrary int32, fullFileName uintptr, interpExiting int32) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var code, safeRefCount, trustedRefCount int32
	var ipFirstPtr, ipPrevPtr, ipPtr, iterLibraryPtr, unloadProc uintptr
	_, _, _, _, _, _, _, _ = code, ipFirstPtr, ipPrevPtr, ipPtr, iterLibraryPtr, safeRefCount, trustedRefCount, unloadProc
	trustedRefCount = -int32(1)
	safeRefCount = -int32(1)
	unloadProc = libc.UintptrFromInt32(0)
	/*
	 * Ensure that the DLL can be unloaded. If it is a trusted interpreter,
	 * libraryPtr->unloadProc must not be NULL for the DLL to be unloadable. If
	 * the interpreter is a safe one, libraryPtr->safeUnloadProc must be non-NULL.
	 */
	if XTcl_IsSafe(tls, target) != 0 {
		if (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FsafeUnloadProc == libc.UintptrFromInt32(0) {
			if !(interpExiting != 0) {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+53037, libc.VaList(bp+8, fullFileName)))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+52858, __ccgo_ts+53091, libc.UintptrFromInt32(0)))
				code = int32(TCL_ERROR)
				goto done
			}
		}
		unloadProc = (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FsafeUnloadProc
	} else {
		if (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FunloadProc == libc.UintptrFromInt32(0) {
			if !(interpExiting != 0) {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+53098, libc.VaList(bp+8, fullFileName)))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+52858, __ccgo_ts+53091, libc.UintptrFromInt32(0)))
				code = int32(TCL_ERROR)
				goto done
			}
		}
		unloadProc = (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FunloadProc
	}
	/*
	 * We are ready to unload the library. First, evaluate the unload
	 * function. If this fails, we cannot proceed with unload. Also, we must
	 * specify the proper flag to pass to the unload callback.
	 * TCL_UNLOAD_DETACH_FROM_INTERPRETER is defined when the callback should
	 * only remove itself from the interpreter; the library will be unloaded
	 * in a future call of unload. In case the library will be unloaded just
	 * after the callback returns, TCL_UNLOAD_DETACH_FROM_PROCESS is passed.
	 */
	if unloadProc == libc.UintptrFromInt32(0) {
		code = TCL_OK
	} else {
		code = libc.Int32FromInt32(1) << libc.Int32FromInt32(0)
		if !(keepLibrary != 0) {
			XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_libraryMutex)))
			trustedRefCount = (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FinterpRefCount
			safeRefCount = (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FsafeInterpRefCount
			XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_libraryMutex)))
			if XTcl_IsSafe(tls, target) != 0 {
				safeRefCount--
			} else {
				trustedRefCount--
			}
			if safeRefCount <= 0 && trustedRefCount <= 0 {
				code = libc.Int32FromInt32(1) << libc.Int32FromInt32(1)
			}
		}
		code = (*(*func(*libc.TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{unloadProc})))(tls, target, code)
	}
	if code != TCL_OK {
		XTcl_TransferResult(tls, target, code, interp)
		goto done
	}
	/*
	 * Remove this library from the interpreter's library cache.
	 */
	if !(interpExiting != 0) {
		ipFirstPtr = XTcl_GetAssocData(tls, target, __ccgo_ts+52520, libc.UintptrFromInt32(0))
		if ipFirstPtr != 0 {
			ipPtr = ipFirstPtr
			if (*TInterpLibrary)(unsafe.Pointer(ipPtr)).FlibraryPtr == libraryPtr {
				ipFirstPtr = (*TInterpLibrary)(unsafe.Pointer(ipFirstPtr)).FnextPtr
			} else {
				ipPrevPtr = ipPtr
				for {
					if !(ipPtr != libc.UintptrFromInt32(0)) {
						break
					}
					if (*TInterpLibrary)(unsafe.Pointer(ipPtr)).FlibraryPtr == libraryPtr {
						(*TInterpLibrary)(unsafe.Pointer(ipPrevPtr)).FnextPtr = (*TInterpLibrary)(unsafe.Pointer(ipPtr)).FnextPtr
						break
					}
					goto _1
				_1:
					;
					ipPrevPtr = ipPtr
					ipPtr = (*TInterpLibrary)(unsafe.Pointer(ipPtr)).FnextPtr
				}
			}
			XTclpFree(tls, ipPtr)
			XTcl_SetAssocData(tls, target, __ccgo_ts+52520, __ccgo_fp(_LoadCleanupProc), ipFirstPtr)
		}
	}
	if _IsStatic(tls, libraryPtr) != 0 {
		goto done
	}
	/*
	 * The unload function was called succesfully.
	 */
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_libraryMutex)))
	if XTcl_IsSafe(tls, target) != 0 {
		(*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FsafeInterpRefCount--
		/*
		 * Do not let counter get negative.
		 */
		if (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FsafeInterpRefCount < 0 {
			(*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FsafeInterpRefCount = 0
		}
	} else {
		(*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FinterpRefCount--
		/*
		 * Do not let counter get negative.
		 */
		if (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FinterpRefCount < 0 {
			(*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FinterpRefCount = 0
		}
	}
	trustedRefCount = (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FinterpRefCount
	safeRefCount = (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FsafeInterpRefCount
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_libraryMutex)))
	code = TCL_OK
	if (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FsafeInterpRefCount <= 0 && (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FinterpRefCount <= 0 && unloadProc != libc.UintptrFromInt32(0) && !(keepLibrary != 0) {
		/*
		 * Unload the shared library from the application memory...
		 */
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+53155, libc.VaList(bp+8, fullFileName)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+52858, __ccgo_ts+53204, libc.UintptrFromInt32(0)))
		code = int32(TCL_ERROR)
	}
	goto done
done:
	;
	return code
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_StaticLibrary --
 *
 *	This function is invoked to indicate that a particular library has
 *	been linked statically with an application.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Once this function completes, the library becomes loadable via the
 *	"load" command with an empty file name.
 *
 *----------------------------------------------------------------------
 */

func XTcl_StaticLibrary(tls *libc.TLS, interp uintptr, prefix uintptr, initProc uintptr, safeInitProc uintptr) {
	/* Function to call to incorporate this
	 * library into a safe interpreter (one that
	 * will execute untrusted scripts). NULL means
	 * the library can't be used in safe
	 * interpreters. */
	var ipFirstPtr, ipPtr, libraryPtr uintptr
	_, _, _ = ipFirstPtr, ipPtr, libraryPtr
	/*
	 * Check to see if someone else has already reported this library as
	 * statically loaded in the process.
	 */
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_libraryMutex)))
	libraryPtr = _firstLibraryPtr
	for {
		if !(libraryPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FinitProc == initProc && (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FsafeInitProc == safeInitProc && libc.Xstrcmp(tls, (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).Fprefix, prefix) == 0 {
			break
		}
		goto _1
	_1:
		;
		libraryPtr = (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FnextPtr
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_libraryMutex)))
	/*
	 * If the library is not yet recorded as being loaded statically, add it
	 * to the list now.
	 */
	if libraryPtr == libc.UintptrFromInt32(0) {
		libraryPtr = XTcl_Alloc(tls, uint64(72))
		(*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FfileName = XTcl_Alloc(tls, uint64(1))
		*(*uint8)(unsafe.Pointer((*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FfileName)) = uint8(0)
		(*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).Fprefix = XTcl_Alloc(tls, libc.Xstrlen(tls, prefix)+uint64(1))
		libc.Xstrcpy(tls, (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).Fprefix, prefix)
		(*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FloadHandle = libc.UintptrFromInt32(0)
		(*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FinitProc = initProc
		(*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FsafeInitProc = safeInitProc
		(*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FunloadProc = libc.UintptrFromInt32(0)
		(*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FsafeUnloadProc = libc.UintptrFromInt32(0)
		XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_libraryMutex)))
		(*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FnextPtr = _firstLibraryPtr
		_firstLibraryPtr = libraryPtr
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_libraryMutex)))
	}
	if interp != libc.UintptrFromInt32(0) {
		/*
		 * If we're loading the library into an interpreter, determine whether
		 * it's already loaded.
		 */
		ipFirstPtr = XTcl_GetAssocData(tls, interp, __ccgo_ts+52520, libc.UintptrFromInt32(0))
		ipPtr = ipFirstPtr
		for {
			if !(ipPtr != libc.UintptrFromInt32(0)) {
				break
			}
			if (*TInterpLibrary)(unsafe.Pointer(ipPtr)).FlibraryPtr == libraryPtr {
				return
			}
			goto _2
		_2:
			;
			ipPtr = (*TInterpLibrary)(unsafe.Pointer(ipPtr)).FnextPtr
		}
		/*
		 * Library isn't loaded in the current interp yet. Mark it as now being
		 * loaded.
		 */
		ipPtr = XTcl_Alloc(tls, uint64(16))
		(*TInterpLibrary)(unsafe.Pointer(ipPtr)).FlibraryPtr = libraryPtr
		(*TInterpLibrary)(unsafe.Pointer(ipPtr)).FnextPtr = ipFirstPtr
		XTcl_SetAssocData(tls, interp, __ccgo_ts+52520, __ccgo_fp(_LoadCleanupProc), ipPtr)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclGetLoadedLibraries --
 *
 *	This function returns information about all of the files that are
 *	loaded (either in a particular interpreter, or for all interpreters).
 *
 * Results:
 *	The return value is a standard Tcl completion code. If successful, a
 *	list of lists is placed in the interp's result. Each sublist
 *	corresponds to one loaded file; its first element is the name of the
 *	file (or an empty string for something that's statically loaded) and
 *	the second element is the prefix of the library in that file.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclGetLoadedLibraries(tls *libc.TLS, interp uintptr, targetName uintptr, prefix uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Prefix or NULL. If NULL, return info
	 * for all prefixes. */
	var cachePtr, cachePtr1, ipPtr, libraryPtr, resultObj, target uintptr
	var v1, v4 bool
	var _ /* pkgDesc at bp+0 */ [2]uintptr
	_, _, _, _, _, _, _, _ = cachePtr, cachePtr1, ipPtr, libraryPtr, resultObj, target, v1, v4
	if targetName == libc.UintptrFromInt32(0) {
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			resultObj = XTclThreadAllocObj(tls)
		} else {
			resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(resultObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
		XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_libraryMutex)))
		libraryPtr = _firstLibraryPtr
		for {
			if !(libraryPtr != libc.UintptrFromInt32(0)) {
				break
			}
			(*(*[2]uintptr)(unsafe.Pointer(bp)))[0] = XTcl_NewStringObj(tls, (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FfileName, int64(-int32(1)))
			(*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)] = XTcl_NewStringObj(tls, (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).Fprefix, int64(-int32(1)))
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, XTcl_NewListObj(tls, int64(2), bp))
			goto _2
		_2:
			;
			libraryPtr = (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FnextPtr
		}
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_libraryMutex)))
		XTcl_SetObjResult(tls, interp, resultObj)
		return TCL_OK
	}
	target = XTcl_GetChild(tls, interp, targetName)
	if target == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	ipPtr = XTcl_GetAssocData(tls, target, __ccgo_ts+52520, libc.UintptrFromInt32(0))
	/*
	 * Return information about all of the available libraries.
	 */
	if prefix != 0 {
		resultObj = libc.UintptrFromInt32(0)
		for {
			if !(ipPtr != libc.UintptrFromInt32(0)) {
				break
			}
			libraryPtr = (*TInterpLibrary)(unsafe.Pointer(ipPtr)).FlibraryPtr
			if !(libc.Xstrcmp(tls, prefix, (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).Fprefix) != 0) {
				resultObj = XTcl_NewStringObj(tls, (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FfileName, int64(-int32(1)))
				break
			}
			goto _3
		_3:
			;
			ipPtr = (*TInterpLibrary)(unsafe.Pointer(ipPtr)).FnextPtr
		}
		if resultObj != 0 {
			XTcl_SetObjResult(tls, interp, resultObj)
		}
		return TCL_OK
	}
	/*
	 * Return information about only the libraries that are loaded in a given
	 * interpreter.
	 */
	if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	for {
		if !(ipPtr != libc.UintptrFromInt32(0)) {
			break
		}
		libraryPtr = (*TInterpLibrary)(unsafe.Pointer(ipPtr)).FlibraryPtr
		(*(*[2]uintptr)(unsafe.Pointer(bp)))[0] = XTcl_NewStringObj(tls, (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FfileName, int64(-int32(1)))
		(*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)] = XTcl_NewStringObj(tls, (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).Fprefix, int64(-int32(1)))
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, XTcl_NewListObj(tls, int64(2), bp))
		goto _5
	_5:
		;
		ipPtr = (*TInterpLibrary)(unsafe.Pointer(ipPtr)).FnextPtr
	}
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * LoadCleanupProc --
 *
 *	This function is called to delete all of the InterpLibrary structures
 *	for an interpreter when the interpreter is deleted. It gets invoked
 *	via the Tcl AssocData mechanism.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Storage for all of the InterpLibrary functions for interp get deleted.
 *
 *----------------------------------------------------------------------
 */

func _LoadCleanupProc(tls *libc.TLS, clientData uintptr, interp uintptr) {
	var ipPtr, libraryPtr, nextPtr uintptr
	_, _, _ = ipPtr, libraryPtr, nextPtr
	ipPtr = clientData
	for ipPtr != 0 {
		libraryPtr = (*TInterpLibrary)(unsafe.Pointer(ipPtr)).FlibraryPtr
		_UnloadLibrary(tls, interp, interp, libraryPtr, 0, __ccgo_ts+1945, int32(1))
		/* UnloadLibrary doesn't free it by interp delete, so do it here and
		 * repeat for next. */
		nextPtr = (*TInterpLibrary)(unsafe.Pointer(ipPtr)).FnextPtr
		XTclpFree(tls, ipPtr)
		ipPtr = nextPtr
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclFinalizeLoad --
 *
 *	This function is invoked just before the application exits. It frees
 *	all of the LoadedLibrary structures.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Memory is freed.
 *
 *----------------------------------------------------------------------
 */

func XTclFinalizeLoad(tls *libc.TLS) {
	var libraryPtr uintptr
	_ = libraryPtr
	/*
	 * No synchronization here because there should just be one thread alive
	 * at this point. Logically, libraryMutex should be grabbed at this point,
	 * but the Mutexes get finalized before the call to this routine. The only
	 * subsystem left alive at this point is the memory allocator.
	 */
	for _firstLibraryPtr != libc.UintptrFromInt32(0) {
		libraryPtr = _firstLibraryPtr
		_firstLibraryPtr = (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FnextPtr
		XTclpFree(tls, (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).FfileName)
		XTclpFree(tls, (*TLoadedLibrary)(unsafe.Pointer(libraryPtr)).Fprefix)
		XTclpFree(tls, libraryPtr)
	}
}

const TCHAR = 0
const _tcscmp = 0

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * The default prompt used when the user has not overridden it.
 */

var _DEFAULT_PRIMARY_PROMPT = [3]uint8{'%', ' '}
var _ENCODING_ERROR1 = [29]uint8{10, 9, '(', 'e', 'n', 'c', 'o', 'd', 'i', 'n', 'g', ' ', 'e', 'r', 'r', 'o', 'r', ' ', 'i', 'n', ' ', 's', 't', 'd', 'e', 'r', 'r', ')'}

/*
 * This file can be compiled on Windows in UNICODE mode, as well as on all
 * other platforms using the native encoding. This is done by using the normal
 * Windows functions like _tcscmp, but on platforms which don't have <tchar.h>
 * we have to translate that to strcmp here.
 */

func _NewNativeObj(tls *libc.TLS, string1 uintptr) (r uintptr) {
	bp := tls.Alloc(224)
	defer tls.Free(224)
	var _ /* ds at bp+0 */ TTcl_DString
	XTcl_ExternalToUtfDString(tls, libc.UintptrFromInt32(0), string1, int64(-int32(1)), bp)
	return XTcl_DStringToObj(tls, bp)
}

/*
 * Declarations for various library functions and variables (don't want to
 * include tclPort.h here, because people might copy this file out of the Tcl
 * source directory to make their own modified versions).
 */

/*
 * The thread-local variables for this file's functions.
 */

type TThreadSpecificData8 = struct {
	Fpath         uintptr
	Fencoding     uintptr
	FmainLoopProc uintptr
}

/*
 * Structure definition for information used to keep the state of an
 * interactive command processor that reads lines from standard input and
 * writes prompts and results to standard output.
 */

type TPromptType = int32

const PROMPT_NONE = 0
const /* Print no prompt */
PROMPT_START = 1
const /* Print prompt for command start */
PROMPT_CONTINUE = 2

type TInteractiveState = struct {
	Finput      TTcl_Channel
	Ftty        int32
	FcommandPtr uintptr
	Fprompt     TPromptType
	Finterp     uintptr
}

var _dataKey6 TTcl_ThreadDataKey

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetStartupScript --
 *
 *	Sets the path and encoding of the startup script to be evaluated by
 *	Tcl_Main, used to override the command line processing.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetStartupScript(tls *libc.TLS, path uintptr, encodingName uintptr) {
	/* Encoding of the data in that file */
	var _objPtr, _objPtr1, encodingObj, tsdPtr, v2, v4 uintptr
	var v1, v3 TTcl_Size
	_, _, _, _, _, _, _, _ = _objPtr, _objPtr1, encodingObj, tsdPtr, v1, v2, v3, v4
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey6)), int64(24))
	encodingObj = libc.UintptrFromInt32(0)
	if encodingName != libc.UintptrFromInt32(0) {
		encodingObj = XTcl_NewStringObj(tls, encodingName, int64(-int32(1)))
		(*TTcl_Obj)(unsafe.Pointer(encodingObj)).FrefCount++
	}
	if path != libc.UintptrFromInt32(0) {
		(*TTcl_Obj)(unsafe.Pointer(path)).FrefCount++
	}
	if (*TThreadSpecificData8)(unsafe.Pointer(tsdPtr)).Fpath != libc.UintptrFromInt32(0) {
		_objPtr = (*TThreadSpecificData8)(unsafe.Pointer(tsdPtr)).Fpath
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	(*TThreadSpecificData8)(unsafe.Pointer(tsdPtr)).Fpath = path
	if (*TThreadSpecificData8)(unsafe.Pointer(tsdPtr)).Fencoding != libc.UintptrFromInt32(0) {
		_objPtr1 = (*TThreadSpecificData8)(unsafe.Pointer(tsdPtr)).Fencoding
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
	(*TThreadSpecificData8)(unsafe.Pointer(tsdPtr)).Fencoding = encodingObj
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetStartupScript --
 *
 *	Gets the path and encoding of the startup script to be evaluated by
 *	Tcl_Main.
 *
 * Results:
 *	The path of the startup script; NULL if none has been set.
 *
 * Side effects:
 *	If encodingPtr is not NULL, stores a (const char *) in it pointing to
 *	the encoding name registered for the startup script. Tcl retains
 *	ownership of the string, and may free it. Caller should make a copy
 *	for long-term use.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetStartupScript(tls *libc.TLS, encodingPtr uintptr) (r uintptr) {
	/* When not NULL, points to storage for the
	 * (const char *) that points to the
	 * registered encoding name for the startup
	 * script. */
	var tsdPtr uintptr
	_ = tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey6)), int64(24))
	if encodingPtr != libc.UintptrFromInt32(0) {
		if (*TThreadSpecificData8)(unsafe.Pointer(tsdPtr)).Fencoding != libc.UintptrFromInt32(0) {
			*(*uintptr)(unsafe.Pointer(encodingPtr)) = XTcl_GetStringFromObj(tls, (*TThreadSpecificData8)(unsafe.Pointer(tsdPtr)).Fencoding, libc.UintptrFromInt32(0))
		} else {
			*(*uintptr)(unsafe.Pointer(encodingPtr)) = libc.UintptrFromInt32(0)
		}
	}
	return (*TThreadSpecificData8)(unsafe.Pointer(tsdPtr)).Fpath
}

/*----------------------------------------------------------------------
 *
 * Tcl_SourceRCFile --
 *
 *	This function is typically invoked by Tcl_Main of Tk_Main function to
 *	source an application specific rc file into the interpreter at startup
 *	time. If the filename cannot be translated (e.g. it referred to a bogus
 *	user or there was no HOME environment variable). Just do nothing.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Depends on what's in the rc script.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SourceRCFile(tls *libc.TLS, interp uintptr) {
	bp := tls.Alloc(224)
	defer tls.Free(224) /* Interpreter to source rc file into. */
	var c, chan1 TTcl_Channel
	var fileName, fullName uintptr
	var _ /* temp at bp+0 */ TTcl_DString
	_, _, _, _ = c, chan1, fileName, fullName
	fileName = XTcl_GetVar2(tls, interp, __ccgo_ts+53213, libc.UintptrFromInt32(0), int32(TCL_GLOBAL_ONLY))
	if fileName != libc.UintptrFromInt32(0) {
		XTcl_DStringInit(tls, bp)
		fullName = XTcl_TranslateFileName(tls, interp, fileName, bp)
		if fullName != libc.UintptrFromInt32(0) {
			/*
			 * Test for the existence of the rc file before trying to read it.
			 */
			c = XTcl_OpenFileChannel(tls, libc.UintptrFromInt32(0), fullName, __ccgo_ts+25877, 0)
			if c != libc.UintptrFromInt32(0) {
				XTcl_CloseEx(tls, libc.UintptrFromInt32(0), c, 0)
				if XTcl_EvalFile(tls, interp, fullName) != TCL_OK {
					chan1 = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(3))
					if chan1 != 0 {
						if XTcl_WriteObj(tls, chan1, XTcl_GetObjResult(tls, interp)) < 0 {
							XTcl_WriteChars(tls, chan1, uintptr(unsafe.Pointer(&_ENCODING_ERROR1)), int64(-int32(1)))
						}
						XTcl_WriteChars(tls, chan1, __ccgo_ts+286, int64(1))
					}
				}
			}
		}
		XTcl_DStringFree(tls, bp)
	}
}

/*----------------------------------------------------------------------
 *
 * Tcl_MainEx --
 *
 *	Main program for tclsh and most other Tcl-based applications.
 *
 * Results:
 *	None. This function never returns (it exits the process when it's
 *	done).
 *
 * Side effects:
 *	This function initializes the Tcl world and then starts interpreting
 *	commands; almost anything could happen, depending on the script being
 *	interpreted.
 *
 *----------------------------------------------------------------------
 */
func XTcl_MainEx(tls *libc.TLS, argc TTcl_Size, argv uintptr, appInitProc uintptr, interp uintptr) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, _objPtr6, _objPtr7, appName, argvPtr, cachePtr, cachePtr1, cmd, mainLoopProc, options, path, resultPtr, value, v11, v14, v17, v19, v21, v3, v7, v9 uintptr
	var chan1 TTcl_Channel
	var code, exitCode int32
	var i, v10, v12, v13, v16, v18, v2, v20, v4, v5, v6, v8 TTcl_Size
	var v1, v15 bool
	var _ /* encodingName at bp+0 */ uintptr
	var _ /* is at bp+8 */ TInteractiveState
	var _ /* length at bp+56 */ TTcl_Size
	var _ /* valuePtr at bp+48 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, _objPtr6, _objPtr7, appName, argvPtr, cachePtr, cachePtr1, chan1, cmd, code, exitCode, i, mainLoopProc, options, path, resultPtr, value, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v3, v4, v5, v6, v7, v8, v9
	i = 0
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	exitCode = 0
	XTclpSetInitialEncodings(tls)
	if argc > 0 {
		argc-- /* consume argv[0] */
		i++
	}
	XTclpFindExecutable(tls, *(*uintptr)(unsafe.Pointer(argv))) /* nb: this could be NULL
	 * w/ (eg) an empty argv supplied to execve() */
	(*(*TInteractiveState)(unsafe.Pointer(bp + 8))).Finterp = interp
	(*(*TInteractiveState)(unsafe.Pointer(bp + 8))).Fprompt = int32(PROMPT_START)
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		(*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr = XTclThreadAllocObj(tls)
	} else {
		(*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer((*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer((*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer((*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr)).FtypePtr = libc.UintptrFromInt32(0)
	/*
	 * If the application has not already set a startup script, parse the
	 * first few command line arguments to determine the script path and
	 * encoding.
	 */
	if libc.UintptrFromInt32(0) == XTcl_GetStartupScript(tls, libc.UintptrFromInt32(0)) {
		/*
		 * Check whether first 3 args (argv[1] - argv[3]) look like
		 *  -encoding ENCODING FILENAME
		 * or like
		 *  FILENAME
		 */
		/* mind argc is being adjusted as we proceed */
		if argc >= int64(3) && 0 == libc.Xstrcmp(tls, __ccgo_ts+19036, *(*uintptr)(unsafe.Pointer(argv + 1*8))) && int32('-') != libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + 3*8))))) {
			value = _NewNativeObj(tls, *(*uintptr)(unsafe.Pointer(argv + 2*8)))
			XTcl_SetStartupScript(tls, _NewNativeObj(tls, *(*uintptr)(unsafe.Pointer(argv + 3*8))), XTcl_GetStringFromObj(tls, value, libc.UintptrFromInt32(0)))
			_objPtr = value
			v3 = _objPtr
			v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
			*(*TTcl_Size)(unsafe.Pointer(v3))--
			if v2 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			argc -= int64(3)
			i += int64(3)
		} else {
			if argc >= int64(1) && int32('-') != libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + 1*8))))) {
				XTcl_SetStartupScript(tls, _NewNativeObj(tls, *(*uintptr)(unsafe.Pointer(argv + 1*8))), libc.UintptrFromInt32(0))
				argc--
				i++
			}
		}
	}
	path = XTcl_GetStartupScript(tls, bp)
	if path != libc.UintptrFromInt32(0) {
		appName = path
	} else {
		if *(*uintptr)(unsafe.Pointer(argv)) != 0 {
			appName = _NewNativeObj(tls, *(*uintptr)(unsafe.Pointer(argv)))
		} else {
			appName = XTcl_NewStringObj(tls, __ccgo_ts+53228, int64(-int32(1)))
		}
	}
	XTcl_SetVar2Ex(tls, interp, __ccgo_ts+53234, libc.UintptrFromInt32(0), appName, int32(TCL_GLOBAL_ONLY))
	XTcl_SetVar2Ex(tls, interp, __ccgo_ts+53240, libc.UintptrFromInt32(0), XTcl_NewWideIntObj(tls, argc), int32(TCL_GLOBAL_ONLY))
	argvPtr = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
	for {
		v4 = argc
		argc--
		if !(v4 != 0) {
			break
		}
		v5 = i
		i++
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), argvPtr, _NewNativeObj(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(v5)*8))))
	}
	XTcl_SetVar2Ex(tls, interp, __ccgo_ts+53245, libc.UintptrFromInt32(0), argvPtr, int32(TCL_GLOBAL_ONLY))
	/*
	 * Set the "tcl_interactive" variable.
	 */
	(*(*TInteractiveState)(unsafe.Pointer(bp + 8))).Ftty = libc.Xisatty(tls, 0)
	XTcl_SetVar2Ex(tls, interp, __ccgo_ts+41524, libc.UintptrFromInt32(0), XTcl_NewWideIntObj(tls, libc.BoolInt64(libc.BoolInt32(!(path != 0) && (*(*TInteractiveState)(unsafe.Pointer(bp + 8))).Ftty != 0) != 0)), int32(TCL_GLOBAL_ONLY))
	/*
	 * Invoke application-specific initialization.
	 */
	XTcl_Preserve(tls, interp)
	if (*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{appInitProc})))(tls, interp) != TCL_OK {
		chan1 = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(3))
		if chan1 != 0 {
			XTcl_WriteChars(tls, chan1, __ccgo_ts+53250, int64(-int32(1)))
			if XTcl_WriteObj(tls, chan1, XTcl_GetObjResult(tls, interp)) < 0 {
				XTcl_WriteChars(tls, chan1, uintptr(unsafe.Pointer(&_ENCODING_ERROR1)), int64(-int32(1)))
			}
			XTcl_WriteChars(tls, chan1, __ccgo_ts+286, int64(1))
		}
	}
	if XTcl_InterpDeleted(tls, interp) != 0 {
		goto done
	}
	if XTcl_LimitExceeded(tls, interp) != 0 {
		goto done
	}
	if XTclFullFinalizationRequested(tls) != 0 {
		/*
		 * Arrange for final deletion of the main interp
		 */
		/* ARGH Munchhausen effect */
		XTcl_CreateExitHandler(tls, __ccgo_fp(_FreeMainInterp), interp)
	}
	/*
	 * Invoke the script specified on the command line, if any. Must fetch it
	 * again, as the appInitProc might have reset it.
	 */
	path = XTcl_GetStartupScript(tls, bp)
	if path != libc.UintptrFromInt32(0) {
		XTcl_ResetResult(tls, interp)
		code = XTcl_FSEvalFileEx(tls, interp, path, *(*uintptr)(unsafe.Pointer(bp)))
		if code != TCL_OK {
			chan1 = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(3))
			if chan1 != 0 {
				options = XTcl_GetReturnOptions(tls, interp, code)
				*(*uintptr)(unsafe.Pointer(bp + 48)) = libc.UintptrFromInt32(0)
				XTclDictGet(tls, libc.UintptrFromInt32(0), options, __ccgo_ts+15220, bp+48)
				if *(*uintptr)(unsafe.Pointer(bp + 48)) != 0 {
					if XTcl_WriteObj(tls, chan1, *(*uintptr)(unsafe.Pointer(bp + 48))) < 0 {
						XTcl_WriteChars(tls, chan1, uintptr(unsafe.Pointer(&_ENCODING_ERROR1)), int64(-int32(1)))
					}
				}
				XTcl_WriteChars(tls, chan1, __ccgo_ts+286, int64(1))
				_objPtr1 = options
				v7 = _objPtr1
				v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
				*(*TTcl_Size)(unsafe.Pointer(v7))--
				if v6 <= int64(1) {
					XTclFreeObj(tls, _objPtr1)
				}
			}
			exitCode = int32(1)
		}
		goto done
	}
	/*
	 * We're running interactively. Source a user-specific startup file if the
	 * application specified one and if the file exists.
	 */
	XTcl_SourceRCFile(tls, interp)
	if XTcl_LimitExceeded(tls, interp) != 0 {
		goto done
	}
	/*
	 * Process commands from stdin until there's an end-of-file. Note that we
	 * need to fetch the standard channels again after every eval, since they
	 * may have been changed.
	 */
	(*TTcl_Obj)(unsafe.Pointer((*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr)).FrefCount++
	/*
	 * Get a new value for tty if anyone writes to ::tcl_interactive
	 */
	XTcl_LinkVar(tls, interp, __ccgo_ts+41524, bp+8+8, int32(TCL_LINK_BOOLEAN))
	(*(*TInteractiveState)(unsafe.Pointer(bp + 8))).Finput = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1))
	for (*(*TInteractiveState)(unsafe.Pointer(bp + 8))).Finput != libc.UintptrFromInt32(0) && !(XTcl_InterpDeleted(tls, interp) != 0) {
		mainLoopProc = XTclGetMainLoop(tls)
		if mainLoopProc == libc.UintptrFromInt32(0) {
			if (*(*TInteractiveState)(unsafe.Pointer(bp + 8))).Ftty != 0 {
				_Prompt(tls, interp, bp+8)
				if XTcl_InterpDeleted(tls, interp) != 0 {
					break
				}
				if XTcl_LimitExceeded(tls, interp) != 0 {
					break
				}
				(*(*TInteractiveState)(unsafe.Pointer(bp + 8))).Finput = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1))
				if (*(*TInteractiveState)(unsafe.Pointer(bp + 8))).Finput == libc.UintptrFromInt32(0) {
					break
				}
			}
			if (*TTcl_Obj)(unsafe.Pointer((*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr)).FrefCount > int64(1) {
				_objPtr2 = (*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr
				v9 = _objPtr2
				v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
				*(*TTcl_Size)(unsafe.Pointer(v9))--
				if v8 <= int64(1) {
					XTclFreeObj(tls, _objPtr2)
				}
				(*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr = XTcl_DuplicateObj(tls, (*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr)
				(*TTcl_Obj)(unsafe.Pointer((*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr)).FrefCount++
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 56)) = XTcl_GetsObj(tls, (*(*TInteractiveState)(unsafe.Pointer(bp + 8))).Finput, (*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr)
			if *(*TTcl_Size)(unsafe.Pointer(bp + 56)) < 0 {
				if XTcl_InputBlocked(tls, (*(*TInteractiveState)(unsafe.Pointer(bp + 8))).Finput) != 0 {
					/*
					 * This can only happen if stdin has been set to
					 * non-blocking. In that case cycle back and try again.
					 * This sets up a tight polling loop (since we have no
					 * event loop running). If this causes bad CPU hogging, we
					 * might try toggling the blocking on stdin instead.
					 */
					continue
				}
				/*
				 * Either EOF, or an error on stdin; we're done
				 */
				break
			}
			/*
			 * Add the newline removed by Tcl_GetsObj back to the string. Have
			 * to add it back before testing completeness, because it can make
			 * a difference. [Bug 1775878]
			 */
			if (*TTcl_Obj)(unsafe.Pointer((*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr)).FrefCount > int64(1) {
				_objPtr3 = (*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr
				v11 = _objPtr3
				v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
				*(*TTcl_Size)(unsafe.Pointer(v11))--
				if v10 <= int64(1) {
					XTclFreeObj(tls, _objPtr3)
				}
				(*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr = XTcl_DuplicateObj(tls, (*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr)
				(*TTcl_Obj)(unsafe.Pointer((*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr)).FrefCount++
			}
			XTcl_AppendToObj(tls, (*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr, __ccgo_ts+286, int64(1))
			if !(XTclObjCommandComplete(tls, (*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr) != 0) {
				(*(*TInteractiveState)(unsafe.Pointer(bp + 8))).Fprompt = int32(PROMPT_CONTINUE)
				continue
			}
			(*(*TInteractiveState)(unsafe.Pointer(bp + 8))).Fprompt = int32(PROMPT_START)
			/*
			 * The final newline is syntactically redundant, and causes some
			 * error messages troubles deeper in, so lop it back off.
			 */
			XTcl_GetStringFromObj(tls, (*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr, bp+56)
			*(*TTcl_Size)(unsafe.Pointer(bp + 56))--
			v12 = *(*TTcl_Size)(unsafe.Pointer(bp + 56))
			XTcl_SetObjLength(tls, (*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr, v12)
			code = XTcl_RecordAndEvalObj(tls, interp, (*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr, int32(TCL_EVAL_GLOBAL))
			(*(*TInteractiveState)(unsafe.Pointer(bp + 8))).Finput = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1))
			_objPtr4 = (*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr
			v14 = _objPtr4
			v13 = *(*TTcl_Size)(unsafe.Pointer(v14))
			*(*TTcl_Size)(unsafe.Pointer(v14))--
			if v13 <= int64(1) {
				XTclFreeObj(tls, _objPtr4)
			}
			if v15 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v15 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v15 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
				(*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr = XTclThreadAllocObj(tls)
			} else {
				(*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer((*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer((*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer((*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer((*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr)).FtypePtr = libc.UintptrFromInt32(0)
			(*TTcl_Obj)(unsafe.Pointer((*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr)).FrefCount++
			if code != TCL_OK {
				chan1 = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(3))
				if chan1 != 0 {
					if XTcl_WriteObj(tls, chan1, XTcl_GetObjResult(tls, interp)) < 0 {
						XTcl_WriteChars(tls, chan1, uintptr(unsafe.Pointer(&_ENCODING_ERROR1)), int64(-int32(1)))
					}
					XTcl_WriteChars(tls, chan1, __ccgo_ts+286, int64(1))
				}
			} else {
				if (*(*TInteractiveState)(unsafe.Pointer(bp + 8))).Ftty != 0 {
					resultPtr = XTcl_GetObjResult(tls, interp)
					(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount++
					XTcl_GetStringFromObj(tls, resultPtr, bp+56)
					chan1 = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2))
					if *(*TTcl_Size)(unsafe.Pointer(bp + 56)) > 0 && chan1 != 0 {
						if XTcl_WriteObj(tls, chan1, resultPtr) < 0 {
							XTcl_WriteChars(tls, chan1, uintptr(unsafe.Pointer(&_ENCODING_ERROR1)), int64(-int32(1)))
						}
						XTcl_WriteChars(tls, chan1, __ccgo_ts+286, int64(1))
					}
					_objPtr5 = resultPtr
					v17 = _objPtr5
					v16 = *(*TTcl_Size)(unsafe.Pointer(v17))
					*(*TTcl_Size)(unsafe.Pointer(v17))--
					if v16 <= int64(1) {
						XTclFreeObj(tls, _objPtr5)
					}
				}
			}
		} else { /* (mainLoopProc != NULL) */
			/*
			 * If a main loop has been defined while running interactively, we
			 * want to start a fileevent based prompt by establishing a
			 * channel handler for stdin.
			 */
			if (*(*TInteractiveState)(unsafe.Pointer(bp + 8))).Finput != 0 {
				if (*(*TInteractiveState)(unsafe.Pointer(bp + 8))).Ftty != 0 {
					_Prompt(tls, interp, bp+8)
				}
				XTcl_CreateChannelHandler(tls, (*(*TInteractiveState)(unsafe.Pointer(bp + 8))).Finput, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1), __ccgo_fp(_StdinProc), bp+8)
			}
			(*(*func(*libc.TLS))(unsafe.Pointer(&struct{ uintptr }{mainLoopProc})))(tls)
			XTcl_SetMainLoop(tls, libc.UintptrFromInt32(0))
			if (*(*TInteractiveState)(unsafe.Pointer(bp + 8))).Finput != 0 {
				XTcl_DeleteChannelHandler(tls, (*(*TInteractiveState)(unsafe.Pointer(bp + 8))).Finput, __ccgo_fp(_StdinProc), bp+8)
			}
			(*(*TInteractiveState)(unsafe.Pointer(bp + 8))).Finput = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1))
		}
		/*
		 * This code here only for the (unsupported and deprecated) [checkmem]
		 * command.
		 */
	}
	goto done
done:
	;
	mainLoopProc = XTclGetMainLoop(tls)
	if exitCode == 0 && mainLoopProc != 0 && !(XTcl_LimitExceeded(tls, interp) != 0) {
		/*
		 * If everything has gone OK so far, call the main loop proc, if it
		 * exists. Packages (like Tk) can set it to start processing events at
		 * this point.
		 */
		(*(*func(*libc.TLS))(unsafe.Pointer(&struct{ uintptr }{mainLoopProc})))(tls)
		XTcl_SetMainLoop(tls, libc.UintptrFromInt32(0))
	}
	if (*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr != libc.UintptrFromInt32(0) {
		_objPtr6 = (*(*TInteractiveState)(unsafe.Pointer(bp + 8))).FcommandPtr
		v19 = _objPtr6
		v18 = *(*TTcl_Size)(unsafe.Pointer(v19))
		*(*TTcl_Size)(unsafe.Pointer(v19))--
		if v18 <= int64(1) {
			XTclFreeObj(tls, _objPtr6)
		}
	}
	/*
	 * Rather than calling exit, invoke the "exit" command so that users can
	 * replace "exit" with some other command to do additional cleanup on
	 * exit. The Tcl_EvalObjEx call should never return.
	 */
	if !(XTcl_InterpDeleted(tls, interp) != 0) && !(XTcl_LimitExceeded(tls, interp) != 0) {
		cmd = XTcl_ObjPrintf(tls, __ccgo_ts+53295, libc.VaList(bp+72, exitCode))
		(*TTcl_Obj)(unsafe.Pointer(cmd)).FrefCount++
		XTcl_EvalObjEx(tls, interp, cmd, int32(TCL_EVAL_GLOBAL))
		_objPtr7 = cmd
		v21 = _objPtr7
		v20 = *(*TTcl_Size)(unsafe.Pointer(v21))
		*(*TTcl_Size)(unsafe.Pointer(v21))--
		if v20 <= int64(1) {
			XTclFreeObj(tls, _objPtr7)
		}
	}
	/*
	 * If Tcl_EvalObjEx returns, trying to eval [exit], something unusual is
	 * happening. Maybe interp has been deleted; maybe [exit] was redefined,
	 * maybe we've blown up because of an exceeded limit. We still want to
	 * cleanup and exit.
	 */
	XTcl_Exit(tls, exitCode)
}

/*
 *---------------------------------------------------------------
 *
 * Tcl_SetMainLoop --
 *
 *	Sets an alternative main loop function.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	This function will be called before Tcl exits, allowing for the
 *	creation of an event loop.
 *
 *---------------------------------------------------------------
 */

func XTcl_SetMainLoop(tls *libc.TLS, proc uintptr) {
	var tsdPtr uintptr
	_ = tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey6)), int64(24))
	(*TThreadSpecificData8)(unsafe.Pointer(tsdPtr)).FmainLoopProc = proc
}

/*
 *---------------------------------------------------------------
 *
 * TclGetMainLoop --
 *
 *	Returns the current alternative main loop function.
 *
 * Results:
 *	Returns the previously defined main loop function, or NULL to indicate
 *	that no such function has been installed and standard tclsh behaviour
 *	(i.e., exit once the script is evaluated if not interactive) is
 *	requested..
 *
 * Side effects:
 *	None (other than possible creation of this file's TSD block).
 *
 *---------------------------------------------------------------
 */

func XTclGetMainLoop(tls *libc.TLS) (r uintptr) {
	var tsdPtr uintptr
	_ = tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey6)), int64(24))
	return (*TThreadSpecificData8)(unsafe.Pointer(tsdPtr)).FmainLoopProc
}

/*
 *----------------------------------------------------------------------
 *
 * TclFullFinalizationRequested --
 *
 *	This function returns true when either -DPURIFY is specified, or the
 *	environment variable TCL_FINALIZE_ON_EXIT is set and not "0". This
 *	predicate is called at places affecting the exit sequence, so that the
 *	default behavior is a fast and deadlock-free exit, and the modified
 *	behavior is a more thorough finalization for debugging purposes (leak
 *	hunting etc).
 *
 * Results:
 *	A boolean.
 *
 *----------------------------------------------------------------------
 */
func XTclFullFinalizationRequested(tls *libc.TLS) (r int32) {
	bp := tls.Alloc(224)
	defer tls.Free(224)
	var fin uintptr
	var finalize int32
	var _ /* ds at bp+0 */ TTcl_DString
	_, _ = fin, finalize
	finalize = 0
	fin = XTclGetEnv(tls, __ccgo_ts+53303, bp)
	finalize = libc.BoolInt32(fin != libc.UintptrFromInt32(0) && libc.Xstrcmp(tls, fin, __ccgo_ts+14828) != 0)
	if fin != libc.UintptrFromInt32(0) {
		XTcl_DStringFree(tls, bp)
	}
	return finalize
}

/*
 *----------------------------------------------------------------------
 *
 * StdinProc --
 *
 *	This function is invoked by the event dispatcher whenever standard
 *	input becomes readable. It grabs the next line of input characters,
 *	adds them to a command being assembled, and executes the command if
 *	it's complete.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Could be almost arbitrary, depending on the command that's typed.
 *
 *----------------------------------------------------------------------
 */

func _StdinProc(tls *libc.TLS, clientData uintptr, dummy739 int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, cachePtr, commandPtr, interp, isPtr, resultPtr, v11, v2, v4, v8 uintptr
	var chan1, v6 TTcl_Channel
	var code int32
	var v1, v10, v3, v5, v7 TTcl_Size
	var v9 bool
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, cachePtr, chan1, code, commandPtr, interp, isPtr, resultPtr, v1, v10, v11, v2, v3, v4, v5, v6, v7, v8, v9
	isPtr = clientData
	chan1 = (*TInteractiveState)(unsafe.Pointer(isPtr)).Finput
	commandPtr = (*TInteractiveState)(unsafe.Pointer(isPtr)).FcommandPtr
	interp = (*TInteractiveState)(unsafe.Pointer(isPtr)).Finterp
	if (*TTcl_Obj)(unsafe.Pointer(commandPtr)).FrefCount > int64(1) {
		_objPtr = commandPtr
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		commandPtr = XTcl_DuplicateObj(tls, commandPtr)
		(*TTcl_Obj)(unsafe.Pointer(commandPtr)).FrefCount++
	}
	*(*TTcl_Size)(unsafe.Pointer(bp)) = XTcl_GetsObj(tls, chan1, commandPtr)
	if *(*TTcl_Size)(unsafe.Pointer(bp)) < 0 {
		if XTcl_InputBlocked(tls, chan1) != 0 {
			return
		}
		if (*TInteractiveState)(unsafe.Pointer(isPtr)).Ftty != 0 {
			/*
			 * Would be better to find a way to exit the mainLoop? Or perhaps
			 * evaluate [exit]? Leaving as is for now due to compatibility
			 * concerns.
			 */
			XTcl_Exit(tls, 0)
		}
		XTcl_DeleteChannelHandler(tls, chan1, __ccgo_fp(_StdinProc), isPtr)
		return
	}
	if (*TTcl_Obj)(unsafe.Pointer(commandPtr)).FrefCount > int64(1) {
		_objPtr1 = commandPtr
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		commandPtr = XTcl_DuplicateObj(tls, commandPtr)
		(*TTcl_Obj)(unsafe.Pointer(commandPtr)).FrefCount++
	}
	XTcl_AppendToObj(tls, commandPtr, __ccgo_ts+286, int64(1))
	if !(XTclObjCommandComplete(tls, commandPtr) != 0) {
		(*TInteractiveState)(unsafe.Pointer(isPtr)).Fprompt = int32(PROMPT_CONTINUE)
		goto prompt
	}
	(*TInteractiveState)(unsafe.Pointer(isPtr)).Fprompt = int32(PROMPT_START)
	XTcl_GetStringFromObj(tls, commandPtr, bp)
	*(*TTcl_Size)(unsafe.Pointer(bp))--
	v5 = *(*TTcl_Size)(unsafe.Pointer(bp))
	XTcl_SetObjLength(tls, commandPtr, v5)
	/*
	 * Disable the stdin channel handler while evaluating the command;
	 * otherwise if the command re-enters the event loop we might process
	 * commands from stdin before the current command is finished. Among other
	 * things, this will trash the text of the command being evaluated.
	 */
	XTcl_CreateChannelHandler(tls, chan1, 0, __ccgo_fp(_StdinProc), isPtr)
	code = XTcl_RecordAndEvalObj(tls, interp, commandPtr, int32(TCL_EVAL_GLOBAL))
	v6 = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1))
	chan1 = v6
	(*TInteractiveState)(unsafe.Pointer(isPtr)).Finput = v6
	_objPtr2 = commandPtr
	v8 = _objPtr2
	v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
	*(*TTcl_Size)(unsafe.Pointer(v8))--
	if v7 <= int64(1) {
		XTclFreeObj(tls, _objPtr2)
	}
	if v9 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v9 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v9 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		commandPtr = XTclThreadAllocObj(tls)
	} else {
		commandPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(commandPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(commandPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(commandPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(commandPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(commandPtr)).FtypePtr = libc.UintptrFromInt32(0)
	(*TInteractiveState)(unsafe.Pointer(isPtr)).FcommandPtr = commandPtr
	(*TTcl_Obj)(unsafe.Pointer(commandPtr)).FrefCount++
	if chan1 != libc.UintptrFromInt32(0) {
		XTcl_CreateChannelHandler(tls, chan1, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1), __ccgo_fp(_StdinProc), isPtr)
	}
	if code != TCL_OK {
		chan1 = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(3))
		if chan1 != libc.UintptrFromInt32(0) {
			if XTcl_WriteObj(tls, chan1, XTcl_GetObjResult(tls, interp)) < 0 {
				XTcl_WriteChars(tls, chan1, uintptr(unsafe.Pointer(&_ENCODING_ERROR1)), int64(-int32(1)))
			}
			XTcl_WriteChars(tls, chan1, __ccgo_ts+286, int64(1))
		}
	} else {
		if (*TInteractiveState)(unsafe.Pointer(isPtr)).Ftty != 0 {
			resultPtr = XTcl_GetObjResult(tls, interp)
			chan1 = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2))
			(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount++
			XTcl_GetStringFromObj(tls, resultPtr, bp)
			if *(*TTcl_Size)(unsafe.Pointer(bp)) > 0 && chan1 != libc.UintptrFromInt32(0) {
				if XTcl_WriteObj(tls, chan1, resultPtr) < 0 {
					XTcl_WriteChars(tls, chan1, uintptr(unsafe.Pointer(&_ENCODING_ERROR1)), int64(-int32(1)))
				}
				XTcl_WriteChars(tls, chan1, __ccgo_ts+286, int64(1))
			}
			_objPtr3 = resultPtr
			v11 = _objPtr3
			v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
			*(*TTcl_Size)(unsafe.Pointer(v11))--
			if v10 <= int64(1) {
				XTclFreeObj(tls, _objPtr3)
			}
		}
	}
	/*
	 * If a tty stdin is still around, output a prompt.
	 */
	goto prompt
prompt:
	;
	if (*TInteractiveState)(unsafe.Pointer(isPtr)).Ftty != 0 && (*TInteractiveState)(unsafe.Pointer(isPtr)).Finput != libc.UintptrFromInt32(0) {
		_Prompt(tls, interp, isPtr)
		(*TInteractiveState)(unsafe.Pointer(isPtr)).Finput = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1))
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Prompt --
 *
 *	Issue a prompt on standard output, or invoke a script to issue the
 *	prompt.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	A prompt gets output, and a Tcl script may be evaluated in interp.
 *
 *----------------------------------------------------------------------
 */

func _Prompt(tls *libc.TLS, interp uintptr, isPtr uintptr) {
	/* InteractiveState. Filled with PROMPT_NONE
	 * after a prompt is printed. */
	var chan1 TTcl_Channel
	var code int32
	var promptCmdPtr, v1 uintptr
	_, _, _, _ = chan1, code, promptCmdPtr, v1
	if (*TInteractiveState)(unsafe.Pointer(isPtr)).Fprompt == int32(PROMPT_NONE) {
		return
	}
	if (*TInteractiveState)(unsafe.Pointer(isPtr)).Fprompt == int32(PROMPT_CONTINUE) {
		v1 = __ccgo_ts + 53324
	} else {
		v1 = __ccgo_ts + 53336
	}
	promptCmdPtr = XTcl_GetVar2Ex(tls, interp, v1, libc.UintptrFromInt32(0), int32(TCL_GLOBAL_ONLY))
	if XTcl_InterpDeleted(tls, interp) != 0 {
		return
	}
	if !(promptCmdPtr == libc.UintptrFromInt32(0)) {
		goto _2
	}
	goto defaultPrompt
defaultPrompt:
	;
	if (*TInteractiveState)(unsafe.Pointer(isPtr)).Fprompt == int32(PROMPT_START) {
		chan1 = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2))
		if chan1 != libc.UintptrFromInt32(0) {
			XTcl_WriteChars(tls, chan1, uintptr(unsafe.Pointer(&_DEFAULT_PRIMARY_PROMPT)), libc.Int64FromUint64(libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)))
		}
	}
	goto _3
_2:
	;
	code = XTcl_EvalObjEx(tls, interp, promptCmdPtr, int32(TCL_EVAL_GLOBAL))
	if code != TCL_OK {
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+53348, int64(-int32(1))))
		chan1 = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(3))
		if chan1 != libc.UintptrFromInt32(0) {
			if XTcl_WriteObj(tls, chan1, XTcl_GetObjResult(tls, interp)) < 0 {
				XTcl_WriteChars(tls, chan1, uintptr(unsafe.Pointer(&_ENCODING_ERROR1)), int64(-int32(1)))
			}
			XTcl_WriteChars(tls, chan1, __ccgo_ts+286, int64(1))
		}
		goto defaultPrompt
	}
_3:
	;
	chan1 = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2))
	if chan1 != libc.UintptrFromInt32(0) {
		XTcl_Flush(tls, chan1)
	}
	(*TInteractiveState)(unsafe.Pointer(isPtr)).Fprompt = int32(PROMPT_NONE)
}

/*
 *----------------------------------------------------------------------
 *
 * FreeMainInterp --
 *
 *	Exit handler used to cleanup the main interpreter and ancillary
 *	startup script storage at exit.
 *
 *----------------------------------------------------------------------
 */

func _FreeMainInterp(tls *libc.TLS, clientData uintptr) {
	var interp uintptr
	_ = interp
	interp = clientData
	/*if (TclInExit()) return;*/
	if !(XTcl_InterpDeleted(tls, interp) != 0) {
		XTcl_DeleteInterp(tls, interp)
	}
	XTcl_SetStartupScript(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	XTcl_Release(tls, interp)
}

/*
 * Thread-local storage used to avoid having a global lock on data that is not
 * limited to a single interpreter.
 */

type TThreadSpecificData9 = struct {
	FnumNsCreated Tsize_t
}

var _dataKey7 TTcl_ThreadDataKey

/*
 * This structure contains a cached pointer to a namespace that is the result
 * of resolving the namespace's name in some other namespace. It is the
 * internal representation for a nsName object. It contains the pointer along
 * with some information that is used to check the cached pointer's validity.
 */

type TResolvedNsName = struct {
	FnsPtr    uintptr
	FrefNsPtr uintptr
	FrefCount Tsize_t
}

/*
 * This structure defines a Tcl object type that contains a namespace
 * reference. It is used in commands that take the name of a namespace as an
 * argument. The namespace reference is resolved, and the result in cached in
 * the object.
 */

var _nsNameType = TTcl_ObjType{
	Fname: __ccgo_ts + 53384,
}

func init() {
	p := unsafe.Pointer(&_nsNameType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_FreeNsNameInternalRep)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_DupNsNameInternalRep)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_SetNsNameFromAny)
}

/*
 * Array of values describing how to implement each standard subcommand of the
 * "namespace" command.
 */

var _defaultNamespaceMap = [20]TEnsembleImplMap{
	0: {
		Fname: __ccgo_ts + 40526,
	},
	1: {
		Fname: __ccgo_ts + 53391,
	},
	2: {
		Fname: __ccgo_ts + 11670,
	},
	3: {
		Fname: __ccgo_ts + 5663,
	},
	4: {
		Fname: __ccgo_ts + 6470,
	},
	5: {
		Fname: __ccgo_ts + 2464,
	},
	6: {
		Fname: __ccgo_ts + 5689,
	},
	7: {
		Fname: __ccgo_ts + 53396,
	},
	8: {
		Fname: __ccgo_ts + 53403,
	},
	9: {
		Fname: __ccgo_ts + 6492,
	},
	10: {
		Fname: __ccgo_ts + 21821,
	},
	11: {
		Fname: __ccgo_ts + 45829,
	},
	12: {
		Fname: __ccgo_ts + 53410,
	},
	13: {
		Fname: __ccgo_ts + 34695,
	},
	14: {
		Fname: __ccgo_ts + 53417,
	},
	15: {
		Fname: __ccgo_ts + 5817,
	},
	16: {
		Fname: __ccgo_ts + 15720,
	},
	17: {
		Fname: __ccgo_ts + 3496,
	},
	18: {
		Fname: __ccgo_ts + 53428,
	},
	19: {},
}

func init() {
	p := unsafe.Pointer(&_defaultNamespaceMap)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_NamespaceChildrenCmd)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(XTclCompileBasic0To2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(_NamespaceCodeCmd)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(XTclCompileNamespaceCodeCmd)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(_NamespaceCurrentCmd)
	*(*uintptr)(unsafe.Add(p, 112)) = __ccgo_fp(XTclCompileNamespaceCurrentCmd)
	*(*uintptr)(unsafe.Add(p, 152)) = __ccgo_fp(_NamespaceDeleteCmd)
	*(*uintptr)(unsafe.Add(p, 160)) = __ccgo_fp(XTclCompileBasicMin0ArgCmd)
	*(*uintptr)(unsafe.Add(p, 200)) = __ccgo_fp(XTclNamespaceEnsembleCmd)
	*(*uintptr)(unsafe.Add(p, 248)) = __ccgo_fp(_NamespaceEvalCmd)
	*(*uintptr)(unsafe.Add(p, 264)) = __ccgo_fp(_NRNamespaceEvalCmd)
	*(*uintptr)(unsafe.Add(p, 296)) = __ccgo_fp(_NamespaceExistsCmd)
	*(*uintptr)(unsafe.Add(p, 304)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 344)) = __ccgo_fp(_NamespaceExportCmd)
	*(*uintptr)(unsafe.Add(p, 352)) = __ccgo_fp(XTclCompileBasicMin0ArgCmd)
	*(*uintptr)(unsafe.Add(p, 392)) = __ccgo_fp(_NamespaceForgetCmd)
	*(*uintptr)(unsafe.Add(p, 400)) = __ccgo_fp(XTclCompileBasicMin0ArgCmd)
	*(*uintptr)(unsafe.Add(p, 440)) = __ccgo_fp(_NamespaceImportCmd)
	*(*uintptr)(unsafe.Add(p, 448)) = __ccgo_fp(XTclCompileBasicMin0ArgCmd)
	*(*uintptr)(unsafe.Add(p, 488)) = __ccgo_fp(_NamespaceInscopeCmd)
	*(*uintptr)(unsafe.Add(p, 504)) = __ccgo_fp(_NRNamespaceInscopeCmd)
	*(*uintptr)(unsafe.Add(p, 536)) = __ccgo_fp(_NamespaceOriginCmd)
	*(*uintptr)(unsafe.Add(p, 544)) = __ccgo_fp(XTclCompileNamespaceOriginCmd)
	*(*uintptr)(unsafe.Add(p, 584)) = __ccgo_fp(_NamespaceParentCmd)
	*(*uintptr)(unsafe.Add(p, 592)) = __ccgo_fp(XTclCompileBasic0Or1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 632)) = __ccgo_fp(_NamespacePathCmd)
	*(*uintptr)(unsafe.Add(p, 640)) = __ccgo_fp(XTclCompileBasic0Or1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 680)) = __ccgo_fp(_NamespaceQualifiersCmd)
	*(*uintptr)(unsafe.Add(p, 688)) = __ccgo_fp(XTclCompileNamespaceQualifiersCmd)
	*(*uintptr)(unsafe.Add(p, 728)) = __ccgo_fp(_NamespaceTailCmd)
	*(*uintptr)(unsafe.Add(p, 736)) = __ccgo_fp(XTclCompileNamespaceTailCmd)
	*(*uintptr)(unsafe.Add(p, 776)) = __ccgo_fp(_NamespaceUnknownCmd)
	*(*uintptr)(unsafe.Add(p, 784)) = __ccgo_fp(XTclCompileBasic0Or1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 824)) = __ccgo_fp(_NamespaceUpvarCmd)
	*(*uintptr)(unsafe.Add(p, 832)) = __ccgo_fp(XTclCompileNamespaceUpvarCmd)
	*(*uintptr)(unsafe.Add(p, 872)) = __ccgo_fp(_NamespaceWhichCmd)
	*(*uintptr)(unsafe.Add(p, 880)) = __ccgo_fp(XTclCompileNamespaceWhichCmd)
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * CreateChildEntry --
//	 *
//	 *	Create a child namespace hash table entry.
//	 *
//	 * Results:
//	 *	Handle to hash table entry for a child namespace with the given name.
//	 *	Caller should handle filling in the namespace value.
//	 *
//	 * Side effects:
//	 *	None.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _CreateChildEntry(tls *libc.TLS, nsPtr uintptr, name uintptr, isNewPtr uintptr) (r uintptr) {
	/* Pointer to var with whether this is new. */
	return (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(nsPtr + 40)).FcreateProc})))(tls, nsPtr+40, name, isNewPtr)
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * FindChildEntry --
//	 *
//	 *	Look up a child namespace hash table entry.
//	 *
//	 * Results:
//	 *	Handle to hash table entry if a child namespace with the given name
//	 *	exists, otherwise NULL.
//	 *
//	 * Side effects:
//	 *	None.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _FindChildEntry(tls *libc.TLS, nsPtr uintptr, name uintptr) (r uintptr) {
	/* Simple name to look for. */
	return (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(nsPtr + 40)).FfindProc})))(tls, nsPtr+40, name)
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * FirstChildEntry --
//	 *
//	 *	Start an iteration through the collection of child namespaces.
//	 *
//	 * Results:
//	 *	Handle to hash table entry if a child namespace exists, otherwise NULL.
//	 *
//	 * Side effects:
//	 *	Updates the search handle.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _FirstChildEntry(tls *libc.TLS, nsPtr uintptr, searchPtr uintptr) (r uintptr) {
	/* Iteration handle reference. */
	return XTcl_FirstHashEntry(tls, nsPtr+40, searchPtr)
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * NumChildEntries --
//	 *
//	 *	Get the count of child namespaces.
//	 *
//	 * Results:
//	 *	Number of child entries.
//	 *
//	 * Side effects:
//	 *	None.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _NumChildEntries(tls *libc.TLS, nsPtr uintptr) (r TTcl_Size) {
	return (*TNamespace)(unsafe.Pointer(nsPtr)).FchildTable.FnumEntries
}

/*
 *----------------------------------------------------------------------
 *
 * TclInitNamespaceSubsystem --
 *
 *	This function is called to initialize all the structures that are used
 *	by namespaces on a per-process basis.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclInitNamespaceSubsystem(tls *libc.TLS) {
	/*
	 * Does nothing for now.
	 */
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetCurrentNamespace --
 *
 *	Returns a pointer to an interpreter's currently active namespace.
 *
 * Results:
 *	Returns a pointer to the interpreter's current namespace.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetCurrentNamespace(tls *libc.TLS, interp uintptr) (r uintptr) {
	/* Interpreter whose current namespace is
	 * being queried. */
	return (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FnsPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetGlobalNamespace --
 *
 *	Returns a pointer to an interpreter's global :: namespace.
 *
 * Results:
 *	Returns a pointer to the specified interpreter's global namespace.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetGlobalNamespace(tls *libc.TLS, interp uintptr) (r uintptr) {
	/* Interpreter whose global namespace should
	 * be returned. */
	return (*TInterp)(unsafe.Pointer(interp)).FglobalNsPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_PushCallFrame --
 *
 *	Pushes a new call frame onto the interpreter's Tcl call stack. Called
 *	when executing a Tcl procedure or a "namespace eval" or "namespace
 *	inscope" command.
 *
 * Results:
 *	Returns TCL_OK if successful, or TCL_ERROR (along with an error
 *	message in the interpreter's result object) if something goes wrong.
 *
 * Side effects:
 *	Modifies the interpreter's Tcl call stack.
 *
 *----------------------------------------------------------------------
 */

func XTcl_PushCallFrame(tls *libc.TLS, interp uintptr, callFramePtr uintptr, namespacePtr uintptr, isProcCallFrame int32) (r int32) {
	/* If nonzero, the frame represents a called
	 * Tcl procedure and may have local vars. Vars
	 * will ordinarily be looked up in the frame.
	 * If new variables are created, they will be
	 * created in the frame. If 0, the frame is
	 * for a "namespace eval" or "namespace
	 * inscope" command and var references are
	 * treated as references to namespace
	 * variables. */
	var framePtr, iPtr, nsPtr uintptr
	_, _, _ = framePtr, iPtr, nsPtr
	iPtr = interp
	framePtr = callFramePtr
	if namespacePtr == libc.UintptrFromInt32(0) {
		nsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FnsPtr
	} else {
		nsPtr = namespacePtr
		/*
		 * TODO: Examine whether it would be better to guard based on NS_DYING
		 * or NS_TEARDOWN. It appears that these are not tested because they can
		 * be set in a global interp that has been [namespace delete]d, but
		 * which never really completely goes away because of lingering global
		 * things like ::errorInfo and [::unknown] and hidden commands.
		 * Review of those designs might permit stricter checking here.
		 */
		if (*TNamespace)(unsafe.Pointer(nsPtr)).Fflags&int32(NS_DEAD) != 0 {
			XTcl_Panic(tls, __ccgo_ts+53434, 0)
		}
	}
	(*TNamespace)(unsafe.Pointer(nsPtr)).FactivationCount++
	(*TCallFrame)(unsafe.Pointer(framePtr)).FnsPtr = nsPtr
	(*TCallFrame)(unsafe.Pointer(framePtr)).FisProcCallFrame = isProcCallFrame
	(*TCallFrame)(unsafe.Pointer(framePtr)).Fobjc = 0
	(*TCallFrame)(unsafe.Pointer(framePtr)).Fobjv = libc.UintptrFromInt32(0)
	(*TCallFrame)(unsafe.Pointer(framePtr)).FcallerPtr = (*TInterp)(unsafe.Pointer(iPtr)).FframePtr
	(*TCallFrame)(unsafe.Pointer(framePtr)).FcallerVarPtr = (*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr
	if (*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr != libc.UintptrFromInt32(0) {
		(*TCallFrame)(unsafe.Pointer(framePtr)).Flevel = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).Flevel + libc.Int64FromUint32(1)
	} else {
		(*TCallFrame)(unsafe.Pointer(framePtr)).Flevel = 0
	}
	(*TCallFrame)(unsafe.Pointer(framePtr)).FprocPtr = libc.UintptrFromInt32(0)     /* no called procedure */
	(*TCallFrame)(unsafe.Pointer(framePtr)).FvarTablePtr = libc.UintptrFromInt32(0) /* and no local variables */
	(*TCallFrame)(unsafe.Pointer(framePtr)).FnumCompiledLocals = 0
	(*TCallFrame)(unsafe.Pointer(framePtr)).FcompiledLocals = libc.UintptrFromInt32(0)
	(*TCallFrame)(unsafe.Pointer(framePtr)).FclientData = libc.UintptrFromInt32(0)
	(*TCallFrame)(unsafe.Pointer(framePtr)).FlocalCachePtr = libc.UintptrFromInt32(0)
	(*TCallFrame)(unsafe.Pointer(framePtr)).FtailcallPtr = libc.UintptrFromInt32(0)
	/*
	 * Push the new call frame onto the interpreter's stack of procedure call
	 * frames making it the current frame.
	 */
	(*TInterp)(unsafe.Pointer(iPtr)).FframePtr = framePtr
	(*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr = framePtr
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_PopCallFrame --
 *
 *	Removes a call frame from the Tcl call stack for the interpreter.
 *	Called to remove a frame previously pushed by Tcl_PushCallFrame.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Modifies the call stack of the interpreter. Resets various fields of
 *	the popped call frame. If a namespace has been deleted and has no more
 *	activations on the call stack, the namespace is destroyed.
 *
 *----------------------------------------------------------------------
 */

func XTcl_PopCallFrame(tls *libc.TLS, interp uintptr) {
	/* Interpreter with call frame to pop. */
	var framePtr, iPtr, nsPtr, v2, v4 uintptr
	var v1, v3 TTcl_Size
	_, _, _, _, _, _, _ = framePtr, iPtr, nsPtr, v1, v2, v3, v4
	iPtr = interp
	framePtr = (*TInterp)(unsafe.Pointer(iPtr)).FframePtr
	/*
	 * It's important to remove the call frame from the interpreter's stack of
	 * call frames before deleting local variables, so that traces invoked by
	 * the variable deletion don't see the partially-deleted frame.
	 */
	if (*TCallFrame)(unsafe.Pointer(framePtr)).FcallerPtr != 0 {
		(*TInterp)(unsafe.Pointer(iPtr)).FframePtr = (*TCallFrame)(unsafe.Pointer(framePtr)).FcallerPtr
		(*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr = (*TCallFrame)(unsafe.Pointer(framePtr)).FcallerVarPtr
	} else {
		/* Tcl_PopCallFrame: trying to pop rootCallFrame! */
	}
	if (*TCallFrame)(unsafe.Pointer(framePtr)).FvarTablePtr != libc.UintptrFromInt32(0) {
		XTclDeleteVars(tls, iPtr, (*TCallFrame)(unsafe.Pointer(framePtr)).FvarTablePtr)
		XTclpFree(tls, (*TCallFrame)(unsafe.Pointer(framePtr)).FvarTablePtr)
		(*TCallFrame)(unsafe.Pointer(framePtr)).FvarTablePtr = libc.UintptrFromInt32(0)
	}
	if (*TCallFrame)(unsafe.Pointer(framePtr)).FnumCompiledLocals > 0 {
		XTclDeleteCompiledLocalVars(tls, iPtr, framePtr)
		v2 = (*TCallFrame)(unsafe.Pointer(framePtr)).FlocalCachePtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeLocalCache(tls, interp, (*TCallFrame)(unsafe.Pointer(framePtr)).FlocalCachePtr)
		}
		(*TCallFrame)(unsafe.Pointer(framePtr)).FlocalCachePtr = libc.UintptrFromInt32(0)
	}
	/*
	 * Decrement the namespace's count of active call frames. If the namespace
	 * is "dying" and there are no more active call frames, call
	 * Tcl_DeleteNamespace to destroy it.
	 */
	nsPtr = (*TCallFrame)(unsafe.Pointer(framePtr)).FnsPtr
	v4 = nsPtr + 168
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	if v3 <= libc.BoolInt64(nsPtr == (*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr) && (*TNamespace)(unsafe.Pointer(nsPtr)).Fflags&int32(NS_DYING) != 0 {
		XTcl_DeleteNamespace(tls, nsPtr)
	}
	(*TCallFrame)(unsafe.Pointer(framePtr)).FnsPtr = libc.UintptrFromInt32(0)
	if (*TCallFrame)(unsafe.Pointer(framePtr)).FtailcallPtr != 0 {
		/* Reusing the existing reference count from framePtr->tailcallPtr, so
		 * no need to Tcl_IncrRefCount(framePtr->tailcallPtr)*/
		XTclSetTailcall(tls, interp, (*TCallFrame)(unsafe.Pointer(framePtr)).FtailcallPtr)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclPushStackFrame --
 *
 *	Allocates a new call frame in the interpreter's execution stack, then
 *	pushes it onto the interpreter's Tcl call stack. Called when executing
 *	a Tcl procedure or a "namespace eval" or "namespace inscope" command.
 *
 * Results:
 *	Returns TCL_OK if successful, or TCL_ERROR (along with an error
 *	message in the interpreter's result object) if something goes wrong.
 *
 * Side effects:
 *	Modifies the interpreter's Tcl call stack.
 *
 *----------------------------------------------------------------------
 */

func XTclPushStackFrame(tls *libc.TLS, interp uintptr, framePtrPtr uintptr, namespacePtr uintptr, isProcCallFrame int32) (r int32) {
	/* If nonzero, the frame represents a called
	 * Tcl procedure and may have local vars. Vars
	 * will ordinarily be looked up in the frame.
	 * If new variables are created, they will be
	 * created in the frame. If 0, the frame is
	 * for a "namespace eval" or "namespace
	 * inscope" command and var references are
	 * treated as references to namespace
	 * variables. */
	*(*uintptr)(unsafe.Pointer(framePtrPtr)) = XTclStackAlloc(tls, interp, uint64(112))
	return XTcl_PushCallFrame(tls, interp, *(*uintptr)(unsafe.Pointer(framePtrPtr)), namespacePtr, isProcCallFrame)
}

func XTclPopStackFrame(tls *libc.TLS, interp uintptr) {
	/* Interpreter with call frame to pop. */
	var freePtr uintptr
	_ = freePtr
	freePtr = (*TInterp)(unsafe.Pointer(interp)).FframePtr
	XTcl_PopCallFrame(tls, interp)
	XTclStackFree(tls, interp, freePtr)
}

/*
 *----------------------------------------------------------------------
 *
 * EstablishErrorCodeTraces --
 *
 *	Creates traces on the ::errorCode variable to keep its value
 *	consistent with the expectations of legacy code.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Read and unset traces are established on ::errorCode.
 *
 *----------------------------------------------------------------------
 */

func _EstablishErrorCodeTraces(tls *libc.TLS, dummy617 uintptr, interp uintptr, dummy619 uintptr, dummy620 uintptr, dummy621 int32) (r uintptr) {
	XTcl_TraceVar2(tls, interp, __ccgo_ts+53479, libc.UintptrFromInt32(0), libc.Int32FromInt32(TCL_GLOBAL_ONLY)|libc.Int32FromInt32(TCL_TRACE_READS), __ccgo_fp(_ErrorCodeRead), libc.UintptrFromInt32(0))
	XTcl_TraceVar2(tls, interp, __ccgo_ts+53479, libc.UintptrFromInt32(0), libc.Int32FromInt32(TCL_GLOBAL_ONLY)|libc.Int32FromInt32(TCL_TRACE_UNSETS), __ccgo_fp(_EstablishErrorCodeTraces), libc.UintptrFromInt32(0))
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * ErrorCodeRead --
 *
 *	Called when the ::errorCode variable is read. Copies the current value
 *	of the interp's errorCode field into ::errorCode.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _ErrorCodeRead(tls *libc.TLS, dummy649 uintptr, interp uintptr, dummy651 uintptr, dummy652 uintptr, dummy653 int32) (r uintptr) {
	var iPtr uintptr
	_ = iPtr
	iPtr = interp
	if XTcl_InterpDeleted(tls, interp) != 0 || !((*TInterp)(unsafe.Pointer(iPtr)).Fflags&libc.Int32FromInt32(ERR_LEGACY_COPY) != 0) {
		return libc.UintptrFromInt32(0)
	}
	if (*TInterp)(unsafe.Pointer(iPtr)).FerrorCode != 0 {
		XTcl_ObjSetVar2(tls, interp, (*TInterp)(unsafe.Pointer(iPtr)).FecVar, libc.UintptrFromInt32(0), (*TInterp)(unsafe.Pointer(iPtr)).FerrorCode, int32(TCL_GLOBAL_ONLY))
		return libc.UintptrFromInt32(0)
	}
	if libc.UintptrFromInt32(0) == XTcl_ObjGetVar2(tls, interp, (*TInterp)(unsafe.Pointer(iPtr)).FecVar, libc.UintptrFromInt32(0), int32(TCL_GLOBAL_ONLY)) {
		XTcl_ObjSetVar2(tls, interp, (*TInterp)(unsafe.Pointer(iPtr)).FecVar, libc.UintptrFromInt32(0), XTcl_NewObj(tls), int32(TCL_GLOBAL_ONLY))
	}
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * EstablishErrorInfoTraces --
 *
 *	Creates traces on the ::errorInfo variable to keep its value
 *	consistent with the expectations of legacy code.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Read and unset traces are established on ::errorInfo.
 *
 *----------------------------------------------------------------------
 */

func _EstablishErrorInfoTraces(tls *libc.TLS, dummy691 uintptr, interp uintptr, dummy693 uintptr, dummy694 uintptr, dummy695 int32) (r uintptr) {
	XTcl_TraceVar2(tls, interp, __ccgo_ts+30797, libc.UintptrFromInt32(0), libc.Int32FromInt32(TCL_GLOBAL_ONLY)|libc.Int32FromInt32(TCL_TRACE_READS), __ccgo_fp(_ErrorInfoRead), libc.UintptrFromInt32(0))
	XTcl_TraceVar2(tls, interp, __ccgo_ts+30797, libc.UintptrFromInt32(0), libc.Int32FromInt32(TCL_GLOBAL_ONLY)|libc.Int32FromInt32(TCL_TRACE_UNSETS), __ccgo_fp(_EstablishErrorInfoTraces), libc.UintptrFromInt32(0))
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * ErrorInfoRead --
 *
 *	Called when the ::errorInfo variable is read. Copies the current value
 *	of the interp's errorInfo field into ::errorInfo.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _ErrorInfoRead(tls *libc.TLS, dummy723 uintptr, interp uintptr, dummy725 uintptr, dummy726 uintptr, dummy727 int32) (r uintptr) {
	var iPtr uintptr
	_ = iPtr
	iPtr = interp
	if XTcl_InterpDeleted(tls, interp) != 0 || !((*TInterp)(unsafe.Pointer(iPtr)).Fflags&libc.Int32FromInt32(ERR_LEGACY_COPY) != 0) {
		return libc.UintptrFromInt32(0)
	}
	if (*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo != 0 {
		XTcl_ObjSetVar2(tls, interp, (*TInterp)(unsafe.Pointer(iPtr)).FeiVar, libc.UintptrFromInt32(0), (*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo, int32(TCL_GLOBAL_ONLY))
		return libc.UintptrFromInt32(0)
	}
	if libc.UintptrFromInt32(0) == XTcl_ObjGetVar2(tls, interp, (*TInterp)(unsafe.Pointer(iPtr)).FeiVar, libc.UintptrFromInt32(0), int32(TCL_GLOBAL_ONLY)) {
		XTcl_ObjSetVar2(tls, interp, (*TInterp)(unsafe.Pointer(iPtr)).FeiVar, libc.UintptrFromInt32(0), XTcl_NewObj(tls), int32(TCL_GLOBAL_ONLY))
	}
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_CreateNamespace --
 *
 *	Creates a new namespace with the given name. If there is no active
 *	namespace (i.e., the interpreter is being initialized), the global ::
 *	namespace is created and returned.
 *
 * Results:
 *	Returns a pointer to the new namespace if successful. If the namespace
 *	already exists or if another error occurs, this routine returns NULL,
 *	along with an error message in the interpreter's result object.
 *
 * Side effects:
 *	If the name contains "::" qualifiers and a parent namespace does not
 *	already exist, it is automatically created.
 *
 *----------------------------------------------------------------------
 */

func XTcl_CreateNamespace(tls *libc.TLS, interp uintptr, name uintptr, clientData uintptr, deleteProc uintptr) (r uintptr) {
	bp := tls.Alloc(768)
	defer tls.Free(768)
	/* Function called to delete client data when
	 * the namespace is deleted. NULL if no
	 * function should be called. */
	var ancestorPtr, buffPtr, entryPtr, globalNsPtr, iPtr, namePtr, nameStr, nsPtr, tempPtr, tsdPtr, v3 uintptr
	var nameLen, v1, v2 Tsize_t
	var _ /* buffer1 at bp+32 */ TTcl_DString
	var _ /* buffer2 at bp+256 */ TTcl_DString
	var _ /* dummy1Ptr at bp+8 */ uintptr
	var _ /* dummy2Ptr at bp+16 */ uintptr
	var _ /* newEntry at bp+480 */ int32
	var _ /* parentPtr at bp+0 */ uintptr
	var _ /* simpleName at bp+24 */ uintptr
	var _ /* tmpBuffer at bp+488 */ TTcl_DString
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = ancestorPtr, buffPtr, entryPtr, globalNsPtr, iPtr, nameLen, namePtr, nameStr, nsPtr, tempPtr, tsdPtr, v1, v2, v3
	iPtr = interp
	globalNsPtr = (*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey7)), int64(8))
	XTcl_DStringInit(tls, bp+488)
	/*
	 * If there is no active namespace, the interpreter is being initialized.
	 */
	if globalNsPtr == libc.UintptrFromInt32(0) && (*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr == libc.UintptrFromInt32(0) {
		/*
		 * Treat this namespace as the global namespace, and avoid looking for
		 * a parent.
		 */
		*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(bp + 24)) = __ccgo_ts + 1945
		goto doCreate
	}
	/*
	 * Ensure that there are no trailing colons as that causes chaos when a
	 * deleteProc is specified. [Bug d614d63989]
	 */
	if deleteProc != libc.UintptrFromInt32(0) {
		nameStr = name + uintptr(libc.Xstrlen(tls, name)) - uintptr(2)
		if nameStr >= name && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(nameStr + 1))) == int32(':') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(nameStr))) == int32(':') {
			XTcl_DStringAppend(tls, bp+488, name, int64(-int32(1)))
			for {
				v1 = libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(bp + 488)).Flength)
				nameLen = v1
				if !(v1 > uint64(0) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_DString)(unsafe.Pointer(bp+488)).Fstring1 + uintptr(nameLen-uint64(1))))) == int32(':')) {
					break
				}
				XTcl_DStringSetLength(tls, bp+488, libc.Int64FromUint64(nameLen-uint64(1)))
			}
			name = (*TTcl_DString)(unsafe.Pointer(bp + 488)).Fstring1
		}
	}
	/*
	 * If we've ended up with an empty string now, we're attempting to create
	 * the global namespace despite the global namespace existing. That's
	 * naughty!
	 */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32('\000') {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+53489, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+720, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+10127, __ccgo_ts+53558, libc.UintptrFromInt32(0)))
		XTcl_DStringFree(tls, bp+488)
		return libc.UintptrFromInt32(0)
	}
	/*
	 * Find the parent for the new namespace.
	 */
	XTclGetNamespaceForQualName(tls, interp, name, libc.UintptrFromInt32(0), int32(TCL_CREATE_NS_IF_UNKNOWN), bp, bp+8, bp+16, bp+24)
	/*
	 * If the unqualified name at the end is empty, there were trailing "::"s
	 * after the namespace's name which we ignore. The new namespace was
	 * already (recursively) created and is pointed to by parentPtr.
	 */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24))))) == int32('\000') {
		XTcl_DStringFree(tls, bp+488)
		return *(*uintptr)(unsafe.Pointer(bp))
	}
	/*
	 * Check for a bad namespace name and make sure that the name does not
	 * already exist in the parent namespace.
	 */
	if _FindChildEntry(tls, *(*uintptr)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 24))) != libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+53571, libc.VaList(bp+720, name)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+720, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+10127, __ccgo_ts+53615, libc.UintptrFromInt32(0)))
		XTcl_DStringFree(tls, bp+488)
		return libc.UintptrFromInt32(0)
	}
	/*
	 * Create the new namespace and root it in its parent. Increment the count
	 * of namespaces created.
	 */
	goto doCreate
doCreate:
	;
	nsPtr = XTcl_Alloc(tls, uint64(528))
	nameLen = libc.Xstrlen(tls, *(*uintptr)(unsafe.Pointer(bp + 24))) + uint64(1)
	(*TNamespace)(unsafe.Pointer(nsPtr)).Fname = XTcl_Alloc(tls, nameLen)
	libc.Xmemcpy(tls, (*TNamespace)(unsafe.Pointer(nsPtr)).Fname, *(*uintptr)(unsafe.Pointer(bp + 24)), nameLen)
	(*TNamespace)(unsafe.Pointer(nsPtr)).FfullName = libc.UintptrFromInt32(0) /* Set below. */
	(*TNamespace)(unsafe.Pointer(nsPtr)).FclientData = clientData
	(*TNamespace)(unsafe.Pointer(nsPtr)).FdeleteProc = deleteProc
	(*TNamespace)(unsafe.Pointer(nsPtr)).FparentPtr = *(*uintptr)(unsafe.Pointer(bp))
	XTcl_InitHashTable(tls, nsPtr+40, TCL_STRING_KEYS)
	v3 = tsdPtr
	*(*Tsize_t)(unsafe.Pointer(v3))++
	v2 = *(*Tsize_t)(unsafe.Pointer(v3))
	(*TNamespace)(unsafe.Pointer(nsPtr)).FnsId = v2
	(*TNamespace)(unsafe.Pointer(nsPtr)).Finterp = interp
	(*TNamespace)(unsafe.Pointer(nsPtr)).Fflags = 0
	(*TNamespace)(unsafe.Pointer(nsPtr)).FactivationCount = 0
	(*TNamespace)(unsafe.Pointer(nsPtr)).FrefCount = 0
	XTcl_InitHashTable(tls, nsPtr+184, TCL_STRING_KEYS)
	XTclInitVarHashTable(tls, nsPtr+288, nsPtr)
	(*TNamespace)(unsafe.Pointer(nsPtr)).FexportArrayPtr = libc.UintptrFromInt32(0)
	(*TNamespace)(unsafe.Pointer(nsPtr)).FnumExportPatterns = 0
	(*TNamespace)(unsafe.Pointer(nsPtr)).FmaxExportPatterns = 0
	(*TNamespace)(unsafe.Pointer(nsPtr)).FcmdRefEpoch = 0
	(*TNamespace)(unsafe.Pointer(nsPtr)).FresolverEpoch = 0
	(*TNamespace)(unsafe.Pointer(nsPtr)).FcmdResProc = libc.UintptrFromInt32(0)
	(*TNamespace)(unsafe.Pointer(nsPtr)).FvarResProc = libc.UintptrFromInt32(0)
	(*TNamespace)(unsafe.Pointer(nsPtr)).FcompiledVarResProc = libc.UintptrFromInt32(0)
	(*TNamespace)(unsafe.Pointer(nsPtr)).FexportLookupEpoch = 0
	(*TNamespace)(unsafe.Pointer(nsPtr)).Fensembles = libc.UintptrFromInt32(0)
	(*TNamespace)(unsafe.Pointer(nsPtr)).FunknownHandlerPtr = libc.UintptrFromInt32(0)
	(*TNamespace)(unsafe.Pointer(nsPtr)).FcommandPathLength = 0
	(*TNamespace)(unsafe.Pointer(nsPtr)).FcommandPathArray = libc.UintptrFromInt32(0)
	(*TNamespace)(unsafe.Pointer(nsPtr)).FcommandPathSourceList = libc.UintptrFromInt32(0)
	(*TNamespace)(unsafe.Pointer(nsPtr)).FearlyDeleteProc = libc.UintptrFromInt32(0)
	if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
		entryPtr = _CreateChildEntry(tls, *(*uintptr)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 24)), bp+480)
		(*TTcl_HashEntry)(unsafe.Pointer(entryPtr)).FclientData = nsPtr
	} else {
		/*
		 * In the global namespace create traces to maintain the ::errorInfo
		 * and ::errorCode variables.
		 */
		(*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr = nsPtr
		_EstablishErrorInfoTraces(tls, libc.UintptrFromInt32(0), interp, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), 0)
		_EstablishErrorCodeTraces(tls, libc.UintptrFromInt32(0), interp, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), 0)
	}
	/*
	 * Build the fully qualified name for this namespace.
	 */
	XTcl_DStringInit(tls, bp+32)
	XTcl_DStringInit(tls, bp+256)
	namePtr = bp + 32
	buffPtr = bp + 256
	ancestorPtr = nsPtr
	for {
		if !(ancestorPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if ancestorPtr != globalNsPtr {
			tempPtr = namePtr
			XTcl_DStringAppend(tls, buffPtr, __ccgo_ts+7650, libc.Int64FromUint64(libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)))
			XTcl_DStringAppend(tls, buffPtr, (*TNamespace)(unsafe.Pointer(ancestorPtr)).Fname, int64(-int32(1)))
			XTclDStringAppendDString(tls, buffPtr, namePtr)
			/*
			 * Clear the unwanted buffer or we end up appending to previous
			 * results, making the namespace fullNames of nested namespaces
			 * very wrong (and strange).
			 */
			XTcl_DStringSetLength(tls, namePtr, 0)
			/*
			 * Now swap the buffer pointers so that we build in the other
			 * buffer. This is faster than repeated copying back and forth
			 * between buffers.
			 */
			namePtr = buffPtr
			buffPtr = tempPtr
		}
		goto _4
	_4:
		;
		ancestorPtr = (*TNamespace)(unsafe.Pointer(ancestorPtr)).FparentPtr
	}
	name = (*TTcl_DString)(unsafe.Pointer(namePtr)).Fstring1
	nameLen = libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(namePtr)).Flength)
	(*TNamespace)(unsafe.Pointer(nsPtr)).FfullName = XTcl_Alloc(tls, nameLen+uint64(1))
	libc.Xmemcpy(tls, (*TNamespace)(unsafe.Pointer(nsPtr)).FfullName, name, nameLen+uint64(1))
	XTcl_DStringFree(tls, bp+32)
	XTcl_DStringFree(tls, bp+256)
	XTcl_DStringFree(tls, bp+488)
	/*
	 * If compilation of commands originating from the parent NS is
	 * suppressed, suppress it for commands originating in this one too.
	 */
	if (*TNamespace)(unsafe.Pointer(nsPtr)).FparentPtr != libc.UintptrFromInt32(0) && (*TNamespace1)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(nsPtr)).FparentPtr)).Fflags&int32(NS_SUPPRESS_COMPILATION) != 0 {
		*(*int32)(unsafe.Pointer(nsPtr + 160)) |= int32(NS_SUPPRESS_COMPILATION)
	}
	/*
	 * Return a pointer to the new namespace.
	 */
	return nsPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DeleteNamespace --
 *
 *	Deletes a namespace and all of the commands, variables, and other
 *	namespaces within it.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	When a namespace is deleted, it is automatically removed as a child of
 *	its parent namespace. Also, all its commands, variables and child
 *	namespaces are deleted.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DeleteNamespace(tls *libc.TLS, namespacePtr uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Points to the namespace to delete. */
	var _objPtr, cmdPtr, earlyDeleteProc, ensemblePtr, entryPtr, globalNsPtr, interp, nsPtr, v3 uintptr
	var v2 TTcl_Size
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _, _, _, _, _ = _objPtr, cmdPtr, earlyDeleteProc, ensemblePtr, entryPtr, globalNsPtr, interp, nsPtr, v2, v3
	nsPtr = namespacePtr
	interp = (*TNamespace)(unsafe.Pointer(nsPtr)).Finterp
	globalNsPtr = (*TInterp)(unsafe.Pointer(interp)).FglobalNsPtr
	/*
	 * Ensure that this namespace doesn't get deallocated in the meantime.
	 */
	(*TNamespace)(unsafe.Pointer(nsPtr)).FrefCount++
	/*
	 * Give anyone interested - notably TclOO - a chance to use this namespace
	 * normally despite the fact that the namespace is going to go. Allows the
	 * calling of destructors. Will only be called once (unless re-established
	 * by the called function). [Bug 2950259]
	 *
	 * Note that setting this field requires access to the internal definition
	 * of namespaces, so it should only be accessed by code that knows about
	 * being careful with reentrancy.
	 */
	if (*TNamespace)(unsafe.Pointer(nsPtr)).FearlyDeleteProc != libc.UintptrFromInt32(0) {
		earlyDeleteProc = (*TNamespace)(unsafe.Pointer(nsPtr)).FearlyDeleteProc
		(*TNamespace)(unsafe.Pointer(nsPtr)).FearlyDeleteProc = libc.UintptrFromInt32(0)
		(*TNamespace)(unsafe.Pointer(nsPtr)).FactivationCount++
		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{earlyDeleteProc})))(tls, (*TNamespace)(unsafe.Pointer(nsPtr)).FclientData)
		(*TNamespace)(unsafe.Pointer(nsPtr)).FactivationCount--
	}
	/*
	 * Delete all coroutine commands now: break the circular ref cycle between
	 * the namespace and the coroutine command [Bug 2724403]. This code is
	 * essentially duplicated in TclTeardownNamespace() for all other
	 * commands. Don't optimize to Tcl_NextHashEntry() because of traces.
	 *
	 * NOTE: we could avoid traversing the ns's command list by keeping a
	 * separate list of coros.
	 */
	entryPtr = XTcl_FirstHashEntry(tls, nsPtr+184, bp)
	for {
		if !(entryPtr != libc.UintptrFromInt32(0)) {
			break
		}
		cmdPtr = (*TTcl_HashEntry)(unsafe.Pointer(entryPtr)).FclientData
		if (*TCommand)(unsafe.Pointer(cmdPtr)).FnreProc == __ccgo_fp(XTclNRInterpCoroutine) {
			XTcl_DeleteCommandFromToken(tls, interp, cmdPtr)
			entryPtr = XTcl_FirstHashEntry(tls, nsPtr+184, bp)
		} else {
			entryPtr = XTcl_NextHashEntry(tls, bp)
		}
		goto _1
	_1:
	}
	/*
	 * If the namespace has associated ensemble commands, delete them first.
	 * This leaves the actual contents of the namespace alone (unless they are
	 * linked ensemble commands, of course). Note that this code is actually
	 * reentrant so command delete traces won't purturb things badly.
	 */
	for (*TNamespace)(unsafe.Pointer(nsPtr)).Fensembles != libc.UintptrFromInt32(0) {
		ensemblePtr = (*TNamespace)(unsafe.Pointer(nsPtr)).Fensembles
		/*
		 * Splice out and link to indicate that we've already been killed.
		 */
		(*TNamespace)(unsafe.Pointer(nsPtr)).Fensembles = (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).Fnext
		(*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).Fnext = ensemblePtr
		XTcl_DeleteCommandFromToken(tls, interp, (*TEnsembleConfig)(unsafe.Pointer(ensemblePtr)).Ftoken)
	}
	/*
	 * If the namespace has a registered unknown handler (TIP 181), then free
	 * it here.
	 */
	if (*TNamespace)(unsafe.Pointer(nsPtr)).FunknownHandlerPtr != libc.UintptrFromInt32(0) {
		_objPtr = (*TNamespace)(unsafe.Pointer(nsPtr)).FunknownHandlerPtr
		v3 = _objPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		(*TNamespace)(unsafe.Pointer(nsPtr)).FunknownHandlerPtr = libc.UintptrFromInt32(0)
	}
	/*
	 * If the namespace is on the call frame stack, it is marked as "dying"
	 * (NS_DYING is OR'd into its flags):  Contents of the namespace are
	 * still available and visible until the namespace is later marked as
	 * NS_DEAD, and its commands and variables are still usable by any
	 * active call frames referring to th namespace. When all active call
	 * frames referring to the namespace have been popped from the Tcl
	 * stack, Tcl_PopCallFrame calls Tcl_DeleteNamespace again. If no
	 * nsName objects refer to the namespace (i.e., if its refCount is
	 * zero), its commands and variables are deleted and the storage for
	 * its namespace structure is freed.  Otherwise, if its refCount is
	 * nonzero, the namespace's commands and variables are deleted but the
	 * structure isn't freed. Instead, NS_DEAD is OR'd into the structure's
	 * flags to allow the namespace resolution code to recognize that the
	 * namespace is "deleted".  The structure's storage is freed by
	 * FreeNsNameInternalRep when its refCount reaches 0.
	 */
	if (*TNamespace)(unsafe.Pointer(nsPtr)).FactivationCount > libc.BoolInt64(nsPtr == globalNsPtr) {
		*(*int32)(unsafe.Pointer(nsPtr + 160)) |= int32(NS_DYING)
		if (*TNamespace)(unsafe.Pointer(nsPtr)).FparentPtr != libc.UintptrFromInt32(0) {
			entryPtr = _FindChildEntry(tls, (*TNamespace)(unsafe.Pointer(nsPtr)).FparentPtr, (*TNamespace)(unsafe.Pointer(nsPtr)).Fname)
			if entryPtr != libc.UintptrFromInt32(0) {
				XTcl_DeleteHashEntry(tls, entryPtr)
			}
		}
		(*TNamespace)(unsafe.Pointer(nsPtr)).FparentPtr = libc.UintptrFromInt32(0)
	} else {
		if !((*TNamespace)(unsafe.Pointer(nsPtr)).Fflags&libc.Int32FromInt32(NS_TEARDOWN) != 0) {
			/*
			 * Delete the namespace and everything in it. If this is the global
			 * namespace, then clear it but don't free its storage unless the
			 * interpreter is being torn down. Set the NS_TEARDOWN flag to avoid
			 * recursive calls here - if the namespace is really in the process of
			 * being deleted, ignore any second call.
			 */
			*(*int32)(unsafe.Pointer(nsPtr + 160)) |= libc.Int32FromInt32(NS_DYING) | libc.Int32FromInt32(NS_TEARDOWN)
			XTclTeardownNamespace(tls, nsPtr)
			if nsPtr != globalNsPtr || (*TInterp)(unsafe.Pointer(interp)).Fflags&int32(DELETED) != 0 {
				/*
				 * If this is the global namespace, then it may have residual
				 * "errorInfo" and "errorCode" variables for errors that occurred
				 * while it was being torn down. Try to clear the variable list
				 * one last time.
				 */
				XTclDeleteNamespaceVars(tls, nsPtr)
				XTcl_DeleteHashTable(tls, nsPtr+40)
				XTcl_DeleteHashTable(tls, nsPtr+184)
				*(*int32)(unsafe.Pointer(nsPtr + 160)) |= int32(NS_DEAD)
			} else {
				/*
				 * Restore the ::errorInfo and ::errorCode traces.
				 */
				_EstablishErrorInfoTraces(tls, libc.UintptrFromInt32(0), interp, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), 0)
				_EstablishErrorCodeTraces(tls, libc.UintptrFromInt32(0), interp, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), 0)
				/*
				 * We didn't really kill it, so remove the KILLED marks, so it can
				 * get killed later, avoiding mem leaks.
				 */
				*(*int32)(unsafe.Pointer(nsPtr + 160)) &= ^(libc.Int32FromInt32(NS_DYING) | libc.Int32FromInt32(NS_TEARDOWN))
			}
		}
	}
	XTclNsDecrRefCount(tls, nsPtr)
}

func XTclNamespaceDeleted(tls *libc.TLS, nsPtr uintptr) (r int32) {
	var v1 int32
	_ = v1
	if (*TNamespace)(unsafe.Pointer(nsPtr)).Fflags&int32(NS_DYING) != 0 {
		v1 = int32(1)
	} else {
		v1 = 0
	}
	return v1
}

func XTclDeleteNamespaceChildren(tls *libc.TLS, nsPtr uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Namespace whose children to delete */
	var children, entryPtr, interp uintptr
	var i, length Tsize_t
	var unchecked int32
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _ = children, entryPtr, i, interp, length, unchecked
	interp = (*TNamespace)(unsafe.Pointer(nsPtr)).Finterp
	/*
	 * Delete all the child namespaces.
	 *
	 * BE CAREFUL: When each child is deleted, it divorces itself from its
	 * parent.  The hash table can't be properly traversed if its elements are
	 * being deleted.  Because of traces (and the desire to avoid the
	 * quadratic problems of just using Tcl_FirstHashEntry over and over, [Bug
	 * f97d4ee020]) copy to a temporary array and then delete all those
	 * namespaces.
	 *
	 * Important: leave the hash table itself still live.
	 */
	unchecked = libc.BoolInt32(_NumChildEntries(tls, nsPtr) > 0)
	for _NumChildEntries(tls, nsPtr) > 0 && unchecked != 0 {
		length = libc.Uint64FromInt64(_NumChildEntries(tls, nsPtr))
		children = XTclStackAlloc(tls, interp, uint64(8)*length)
		i = uint64(0)
		entryPtr = _FirstChildEntry(tls, nsPtr, bp)
		for {
			if !(entryPtr != libc.UintptrFromInt32(0)) {
				break
			}
			*(*uintptr)(unsafe.Pointer(children + uintptr(i)*8)) = (*TTcl_HashEntry)(unsafe.Pointer(entryPtr)).FclientData
			(*TNamespace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(children + uintptr(i)*8)))).FrefCount++
			i++
			goto _1
		_1:
			;
			entryPtr = XTcl_NextHashEntry(tls, bp)
		}
		unchecked = 0
		i = uint64(0)
		for {
			if !(i < length) {
				break
			}
			if !((*TNamespace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(children + uintptr(i)*8)))).Fflags&libc.Int32FromInt32(NS_DYING) != 0) {
				unchecked = int32(1)
				XTcl_DeleteNamespace(tls, *(*uintptr)(unsafe.Pointer(children + uintptr(i)*8)))
				XTclNsDecrRefCount(tls, *(*uintptr)(unsafe.Pointer(children + uintptr(i)*8)))
			}
			goto _2
		_2:
			;
			i++
		}
		XTclStackFree(tls, interp, children)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclTeardownNamespace --
 *
 *	Used internally to dismantle and unlink a namespace when it is
 *	deleted. Divorces the namespace from its parent, and deletes all
 *	commands, variables, and child namespaces.
 *
 *	This is kept separate from Tcl_DeleteNamespace so that the global
 *	namespace can be handled specially.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Removes this namespace from its parent's child namespace hashtable.
 *	Deletes all commands, variables and namespaces in this namespace.
 *
 *----------------------------------------------------------------------
 */

func XTclTeardownNamespace(tls *libc.TLS, nsPtr uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Points to the namespace to be dismantled
	 * and unlinked from its parent. */
	var cmds, entryPtr, interp, nsPathPtr, v4 uintptr
	var i, length, v3 TTcl_Size
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _, _, _ = cmds, entryPtr, i, interp, length, nsPathPtr, v3, v4
	interp = (*TNamespace)(unsafe.Pointer(nsPtr)).Finterp
	/*
	 * Start by destroying the namespace's variable table, since variables
	 * might trigger traces. Variable table should be cleared but not freed!
	 * TclDeleteNamespaceVars frees it, so we reinitialize it afterwards.
	 */
	XTclDeleteNamespaceVars(tls, nsPtr)
	XTclInitVarHashTable(tls, nsPtr+288, nsPtr)
	/*
	 * Delete all commands in this namespace. Be careful when traversing the
	 * hash table: when each command is deleted, it removes itself from the
	 * command table. Because of traces (and the desire to avoid the quadratic
	 * problems of just using Tcl_FirstHashEntry over and over, [Bug
	 * f97d4ee020]) we copy to a temporary array and then delete all those
	 * commands.
	 */
	for (*TNamespace)(unsafe.Pointer(nsPtr)).FcmdTable.FnumEntries > 0 {
		length = (*TNamespace)(unsafe.Pointer(nsPtr)).FcmdTable.FnumEntries
		cmds = XTclStackAlloc(tls, interp, uint64(8)*libc.Uint64FromInt64(length))
		i = 0
		entryPtr = XTcl_FirstHashEntry(tls, nsPtr+184, bp)
		for {
			if !(entryPtr != libc.UintptrFromInt32(0)) {
				break
			}
			*(*uintptr)(unsafe.Pointer(cmds + uintptr(i)*8)) = (*TTcl_HashEntry)(unsafe.Pointer(entryPtr)).FclientData
			(*TCommand)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(cmds + uintptr(i)*8)))).FrefCount++
			i++
			goto _1
		_1:
			;
			entryPtr = XTcl_NextHashEntry(tls, bp)
		}
		i = 0
		for {
			if !(i < length) {
				break
			}
			XTcl_DeleteCommandFromToken(tls, interp, *(*uintptr)(unsafe.Pointer(cmds + uintptr(i)*8)))
			v4 = *(*uintptr)(unsafe.Pointer(cmds + uintptr(i)*8)) + 16
			v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
			*(*TTcl_Size)(unsafe.Pointer(v4))--
			if v3 <= int64(1) {
				XTclpFree(tls, *(*uintptr)(unsafe.Pointer(cmds + uintptr(i)*8)))
			}
			goto _2
		_2:
			;
			i++
		}
		XTclStackFree(tls, interp, cmds)
	}
	XTcl_DeleteHashTable(tls, nsPtr+184)
	XTcl_InitHashTable(tls, nsPtr+184, TCL_STRING_KEYS)
	/*
	 * Remove the namespace from its parent's child hashtable.
	 */
	if (*TNamespace)(unsafe.Pointer(nsPtr)).FparentPtr != libc.UintptrFromInt32(0) {
		entryPtr = _FindChildEntry(tls, (*TNamespace)(unsafe.Pointer(nsPtr)).FparentPtr, (*TNamespace)(unsafe.Pointer(nsPtr)).Fname)
		if entryPtr != libc.UintptrFromInt32(0) {
			XTcl_DeleteHashEntry(tls, entryPtr)
		}
	}
	(*TNamespace)(unsafe.Pointer(nsPtr)).FparentPtr = libc.UintptrFromInt32(0)
	/*
	 * Delete the namespace path if one is installed.
	 */
	if (*TNamespace)(unsafe.Pointer(nsPtr)).FcommandPathLength != 0 {
		_UnlinkNsPath(tls, nsPtr)
		(*TNamespace)(unsafe.Pointer(nsPtr)).FcommandPathLength = 0
	}
	if (*TNamespace)(unsafe.Pointer(nsPtr)).FcommandPathSourceList != libc.UintptrFromInt32(0) {
		nsPathPtr = (*TNamespace)(unsafe.Pointer(nsPtr)).FcommandPathSourceList
		for cond := true; cond; cond = nsPathPtr != libc.UintptrFromInt32(0) {
			if (*TNamespacePathEntry)(unsafe.Pointer(nsPathPtr)).FnsPtr != libc.UintptrFromInt32(0) && (*TNamespacePathEntry)(unsafe.Pointer(nsPathPtr)).FcreatorNsPtr != libc.UintptrFromInt32(0) {
				(*TNamespace)(unsafe.Pointer((*TNamespacePathEntry)(unsafe.Pointer(nsPathPtr)).FcreatorNsPtr)).FcmdRefEpoch++
			}
			(*TNamespacePathEntry)(unsafe.Pointer(nsPathPtr)).FnsPtr = libc.UintptrFromInt32(0)
			nsPathPtr = (*TNamespacePathEntry)(unsafe.Pointer(nsPathPtr)).FnextPtr
		}
		(*TNamespace)(unsafe.Pointer(nsPtr)).FcommandPathSourceList = libc.UintptrFromInt32(0)
	}
	XTclDeleteNamespaceChildren(tls, nsPtr)
	/*
	 * Free the namespace's export pattern array.
	 */
	if (*TNamespace)(unsafe.Pointer(nsPtr)).FexportArrayPtr != libc.UintptrFromInt32(0) {
		i = 0
		for {
			if !(i < (*TNamespace)(unsafe.Pointer(nsPtr)).FnumExportPatterns) {
				break
			}
			XTclpFree(tls, *(*uintptr)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(nsPtr)).FexportArrayPtr + uintptr(i)*8)))
			goto _5
		_5:
			;
			i++
		}
		XTclpFree(tls, (*TNamespace)(unsafe.Pointer(nsPtr)).FexportArrayPtr)
		(*TNamespace)(unsafe.Pointer(nsPtr)).FexportArrayPtr = libc.UintptrFromInt32(0)
		(*TNamespace)(unsafe.Pointer(nsPtr)).FnumExportPatterns = 0
		(*TNamespace)(unsafe.Pointer(nsPtr)).FmaxExportPatterns = 0
	}
	/*
	 * Free any client data associated with the namespace.
	 */
	if (*TNamespace)(unsafe.Pointer(nsPtr)).FdeleteProc != libc.UintptrFromInt32(0) {
		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TNamespace)(unsafe.Pointer(nsPtr)).FdeleteProc})))(tls, (*TNamespace)(unsafe.Pointer(nsPtr)).FclientData)
	}
	(*TNamespace)(unsafe.Pointer(nsPtr)).FdeleteProc = libc.UintptrFromInt32(0)
	(*TNamespace)(unsafe.Pointer(nsPtr)).FclientData = libc.UintptrFromInt32(0)
	/*
	 * Reset the namespace's id field to ensure that this namespace won't be
	 * interpreted as valid by, e.g., the cache validation code for cached
	 * command references in Tcl_GetCommandFromObj.
	 */
	(*TNamespace)(unsafe.Pointer(nsPtr)).FnsId = uint64(0)
}

/*
 *----------------------------------------------------------------------
 *
 * NamespaceFree --
 *
 *	Called after a namespace has been deleted, when its reference count
 *	reaches 0. Frees the data structure representing the namespace.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _NamespaceFree(tls *libc.TLS, nsPtr uintptr) {
	/* Points to the namespace to free. */
	/*
	 * Most of the namespace's contents are freed when the namespace is
	 * deleted by Tcl_DeleteNamespace. All that remains is to free its names
	 * (for error messages), and the structure itself.
	 */
	XTclpFree(tls, (*TNamespace)(unsafe.Pointer(nsPtr)).Fname)
	XTclpFree(tls, (*TNamespace)(unsafe.Pointer(nsPtr)).FfullName)
	XTclpFree(tls, nsPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * TclNsDecrRefCount --
 *
 *	Drops a reference to a namespace and frees it if the namespace has
 *	been deleted and the last reference has just been dropped.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclNsDecrRefCount(tls *libc.TLS, nsPtr uintptr) {
	var v1 TTcl_Size
	var v2 uintptr
	_, _ = v1, v2
	v2 = nsPtr + 176
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) && (*TNamespace)(unsafe.Pointer(nsPtr)).Fflags&int32(NS_DEAD) != 0 {
		_NamespaceFree(tls, nsPtr)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_Export --
 *
 *	Makes all the commands matching a pattern available to later be
 *	imported from the namespace specified by namespacePtr (or the current
 *	namespace if namespacePtr is NULL). The specified pattern is appended
 *	onto the namespace's export pattern list, which is optionally cleared
 *	beforehand.
 *
 * Results:
 *	Returns TCL_OK if successful, or TCL_ERROR (along with an error
 *	message in the interpreter's result) if something goes wrong.
 *
 * Side effects:
 *	Appends the export pattern onto the namespace's export list.
 *	Optionally reset the namespace's export pattern list.
 *
 *----------------------------------------------------------------------
 */

func XTcl_Export(tls *libc.TLS, interp uintptr, namespacePtr uintptr, pattern uintptr, resetListFirst int32) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* If nonzero, resets the namespace's export
	 * list before appending. */
	var currNsPtr, nsPtr, patternCpy uintptr
	var i, len1, neededElems TTcl_Size
	var v3 int64
	var _ /* dummyPtr at bp+8 */ uintptr
	var _ /* exportNsPtr at bp+0 */ uintptr
	var _ /* simplePattern at bp+16 */ uintptr
	_, _, _, _, _, _, _ = currNsPtr, i, len1, neededElems, nsPtr, patternCpy, v3
	currNsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FnsPtr
	/*
	 * If the specified namespace is NULL, use the current namespace.
	 */
	if namespacePtr == libc.UintptrFromInt32(0) {
		nsPtr = currNsPtr
	} else {
		nsPtr = namespacePtr
	}
	/*
	 * If resetListFirst is true (nonzero), clear the namespace's export
	 * pattern list.
	 */
	if resetListFirst != 0 {
		if (*TNamespace)(unsafe.Pointer(nsPtr)).FexportArrayPtr != libc.UintptrFromInt32(0) {
			i = 0
			for {
				if !(i < (*TNamespace)(unsafe.Pointer(nsPtr)).FnumExportPatterns) {
					break
				}
				XTclpFree(tls, *(*uintptr)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(nsPtr)).FexportArrayPtr + uintptr(i)*8)))
				goto _1
			_1:
				;
				i++
			}
			XTclpFree(tls, (*TNamespace)(unsafe.Pointer(nsPtr)).FexportArrayPtr)
			(*TNamespace)(unsafe.Pointer(nsPtr)).FexportArrayPtr = libc.UintptrFromInt32(0)
			if (*TNamespace)(unsafe.Pointer(nsPtr)).FnumExportPatterns != 0 {
				(*TNamespace)(unsafe.Pointer(nsPtr)).FexportLookupEpoch++
			}
			if (*TNamespace)(unsafe.Pointer(nsPtr)).FcommandPathLength != 0 {
				(*TNamespace)(unsafe.Pointer(nsPtr)).FcmdRefEpoch++
			}
			(*TNamespace)(unsafe.Pointer(nsPtr)).FnumExportPatterns = 0
			(*TNamespace)(unsafe.Pointer(nsPtr)).FmaxExportPatterns = 0
		}
	}
	/*
	 * Check that the pattern doesn't have namespace qualifiers.
	 */
	XTclGetNamespaceForQualName(tls, interp, pattern, nsPtr, int32(TCL_NAMESPACE_ONLY), bp, bp+8, bp+8, bp+16)
	if *(*uintptr)(unsafe.Pointer(bp)) != nsPtr || libc.Xstrcmp(tls, pattern, *(*uintptr)(unsafe.Pointer(bp + 16))) != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+53630, libc.VaList(bp+32, pattern)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+32, __ccgo_ts+2004, __ccgo_ts+53693, __ccgo_ts+11134, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Make sure that we don't already have the pattern in the array
	 */
	if (*TNamespace)(unsafe.Pointer(nsPtr)).FexportArrayPtr != libc.UintptrFromInt32(0) {
		i = 0
		for {
			if !(i < (*TNamespace)(unsafe.Pointer(nsPtr)).FnumExportPatterns) {
				break
			}
			if libc.Xstrcmp(tls, pattern, *(*uintptr)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(nsPtr)).FexportArrayPtr + uintptr(i)*8))) == 0 {
				/*
				 * The pattern already exists in the list.
				 */
				return TCL_OK
			}
			goto _2
		_2:
			;
			i++
		}
	}
	/*
	 * Make sure there is room in the namespace's pattern array for the new
	 * pattern.
	 */
	neededElems = (*TNamespace)(unsafe.Pointer(nsPtr)).FnumExportPatterns + int64(1)
	if neededElems > (*TNamespace)(unsafe.Pointer(nsPtr)).FmaxExportPatterns {
		if (*TNamespace)(unsafe.Pointer(nsPtr)).FmaxExportPatterns != 0 {
			v3 = int64(2) * (*TNamespace)(unsafe.Pointer(nsPtr)).FmaxExportPatterns
		} else {
			v3 = int64(5)
		}
		(*TNamespace)(unsafe.Pointer(nsPtr)).FmaxExportPatterns = v3
		(*TNamespace)(unsafe.Pointer(nsPtr)).FexportArrayPtr = XTcl_Realloc(tls, (*TNamespace)(unsafe.Pointer(nsPtr)).FexportArrayPtr, uint64(8)*libc.Uint64FromInt64((*TNamespace)(unsafe.Pointer(nsPtr)).FmaxExportPatterns))
	}
	/*
	 * Add the pattern to the namespace's array of export patterns.
	 */
	len1 = libc.Int64FromUint64(libc.Xstrlen(tls, pattern))
	patternCpy = XTcl_Alloc(tls, libc.Uint64FromInt64(len1+int64(1)))
	libc.Xmemcpy(tls, patternCpy, pattern, libc.Uint64FromInt64(len1+int64(1)))
	*(*uintptr)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(nsPtr)).FexportArrayPtr + uintptr((*TNamespace)(unsafe.Pointer(nsPtr)).FnumExportPatterns)*8)) = patternCpy
	(*TNamespace)(unsafe.Pointer(nsPtr)).FnumExportPatterns++
	/*
	 * The list of commands actually exported from the namespace might have
	 * changed (probably will have!) However, we do not need to recompute this
	 * just yet; next time we need the info will be soon enough.
	 */
	if (*TNamespace)(unsafe.Pointer(nsPtr)).FnumExportPatterns != 0 {
		(*TNamespace)(unsafe.Pointer(nsPtr)).FexportLookupEpoch++
	}
	if (*TNamespace)(unsafe.Pointer(nsPtr)).FcommandPathLength != 0 {
		(*TNamespace)(unsafe.Pointer(nsPtr)).FcmdRefEpoch++
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_AppendExportList --
 *
 *	Appends onto the argument object the list of export patterns for the
 *	specified namespace.
 *
 * Results:
 *	The return value is normally TCL_OK; in this case the object
 *	referenced by objPtr has each export pattern appended to it. If an
 *	error occurs, TCL_ERROR is returned and the interpreter's result holds
 *	an error message.
 *
 * Side effects:
 *	If necessary, the object referenced by objPtr is converted into a list
 *	object.
 *
 *----------------------------------------------------------------------
 */

func XTcl_AppendExportList(tls *libc.TLS, interp uintptr, namespacePtr uintptr, objPtr uintptr) (r int32) {
	/* Points to the Tcl object onto which the
	 * export pattern list is appended. */
	var i TTcl_Size
	var nsPtr uintptr
	var result int32
	_, _, _ = i, nsPtr, result
	/*
	 * If the specified namespace is NULL, use the current namespace.
	 */
	if namespacePtr == libc.UintptrFromInt32(0) {
		nsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FnsPtr
	} else {
		nsPtr = namespacePtr
	}
	/*
	 * Append the export pattern list onto objPtr.
	 */
	i = 0
	for {
		if !(i < (*TNamespace)(unsafe.Pointer(nsPtr)).FnumExportPatterns) {
			break
		}
		result = XTcl_ListObjAppendElement(tls, interp, objPtr, XTcl_NewStringObj(tls, *(*uintptr)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(nsPtr)).FexportArrayPtr + uintptr(i)*8)), int64(-int32(1))))
		if result != TCL_OK {
			return result
		}
		goto _1
	_1:
		;
		i++
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_Import --
 *
 *	Imports all of the commands matching a pattern into the namespace
 *	specified by namespacePtr (or the current namespace if contextNsPtr is
 *	NULL). This is done by creating a new command (the "imported command")
 *	that points to the real command in its original namespace.
 *
 *	If matching commands are on the autoload path but haven't been loaded
 *	yet, this command forces them to be loaded, then creates the links to
 *	them.
 *
 * Results:
 *	Returns TCL_OK if successful, or TCL_ERROR (along with an error
 *	message in the interpreter's result) if something goes wrong.
 *
 * Side effects:
 *	Creates new commands in the importing namespace. These indirect calls
 *	back to the real command and are deleted if the real commands are
 *	deleted.
 *
 *----------------------------------------------------------------------
 */

func XTcl_Import(tls *libc.TLS, interp uintptr, namespacePtr uintptr, pattern uintptr, allowOverwrite int32) (r int32) {
	bp := tls.Alloc(112)
	defer tls.Free(112) /* If nonzero, allow existing commands to be
	 * overwritten by imported commands. If 0,
	 * return an error if an imported cmd
	 * conflicts with an existing one. */
	var _objPtr, _objPtr1, cachePtr, cmdName, hPtr, nsPtr, v3, v5, v7 uintptr
	var result int32
	var v1 bool
	var v2, v4 TTcl_Size
	var _ /* dummyPtr at bp+8 */ uintptr
	var _ /* importNsPtr at bp+0 */ uintptr
	var _ /* objv at bp+48 */ [2]uintptr
	var _ /* search at bp+24 */ TTcl_HashSearch
	var _ /* simplePattern at bp+16 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, cmdName, hPtr, nsPtr, result, v1, v2, v3, v4, v5, v7
	/*
	 * If the specified namespace is NULL, use the current namespace.
	 */
	if namespacePtr == libc.UintptrFromInt32(0) {
		nsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FnsPtr
	} else {
		nsPtr = namespacePtr
	}
	/*
	 * First, invoke the "auto_import" command with the pattern being
	 * imported. This command is part of the Tcl library. It looks for
	 * imported commands in autoloaded libraries and loads them in. That way,
	 * they will be found when we try to create links below.
	 *
	 * Note that we don't just call Tcl_EvalObjv() directly because we do not
	 * want absence of the command to be a failure case.
	 */
	if XTcl_FindCommand(tls, interp, __ccgo_ts+53700, libc.UintptrFromInt32(0), int32(TCL_GLOBAL_ONLY)) != libc.UintptrFromInt32(0) {
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			(*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[0] = XTclThreadAllocObj(tls)
		} else {
			(*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[0] = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[0] + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[0])).FrefCount = 0
		if libc.Uint64FromInt64(12)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[0])).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[0])).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[0])).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(12)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[0])).Fbytes, __ccgo_ts+53700, libc.Uint64FromInt64(12)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[0])).Fbytes + uintptr(libc.Uint64FromInt64(12)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[0])).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(12) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[0])).FtypePtr = libc.UintptrFromInt32(0)
		(*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[int32(1)] = XTcl_NewStringObj(tls, pattern, int64(-int32(1)))
		(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[0])).FrefCount++
		(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[int32(1)])).FrefCount++
		result = XTcl_EvalObjv(tls, interp, int64(2), bp+48, int32(TCL_GLOBAL_ONLY))
		_objPtr = (*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[0]
		v3 = _objPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		_objPtr1 = (*(*[2]uintptr)(unsafe.Pointer(bp + 48)))[int32(1)]
		v5 = _objPtr1
		v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
		*(*TTcl_Size)(unsafe.Pointer(v5))--
		if v4 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		if result != TCL_OK {
			return int32(TCL_ERROR)
		}
		XTcl_ResetResult(tls, interp)
	}
	/*
	 * From the pattern, find the namespace from which we are importing and
	 * get the simple pattern (no namespace qualifiers or ::'s) at the end.
	 */
	if libc.Xstrlen(tls, pattern) == uint64(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+53712, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+72, __ccgo_ts+2004, __ccgo_ts+53733, __ccgo_ts+22759, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	XTclGetNamespaceForQualName(tls, interp, pattern, nsPtr, int32(TCL_NAMESPACE_ONLY), bp, bp+8, bp+8, bp+16)
	if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+53740, libc.VaList(bp+72, pattern)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+72, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+10127, pattern, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if *(*uintptr)(unsafe.Pointer(bp)) == nsPtr {
		if pattern == *(*uintptr)(unsafe.Pointer(bp + 16)) {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+53781, libc.VaList(bp+72, pattern)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+72, __ccgo_ts+2004, __ccgo_ts+53733, __ccgo_ts+53827, libc.UintptrFromInt32(0)))
		} else {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+53834, libc.VaList(bp+72, pattern, (*TNamespace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fname)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+72, __ccgo_ts+2004, __ccgo_ts+53733, __ccgo_ts+42580, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	/*
	 * Scan through the command table in the source namespace and look for
	 * exported commands that match the string pattern. Create an "imported
	 * command" in the current namespace for each imported command; these
	 * commands redirect their invocations to the "real" command.
	 */
	if *(*uintptr)(unsafe.Pointer(bp + 16)) != libc.UintptrFromInt32(0) && libc.Xstrpbrk(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), __ccgo_ts+16411) == libc.UintptrFromInt32(0) {
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 184)).FfindProc})))(tls, *(*uintptr)(unsafe.Pointer(bp))+184, *(*uintptr)(unsafe.Pointer(bp + 16)))
		if hPtr == libc.UintptrFromInt32(0) {
			return TCL_OK
		}
		return _DoImport(tls, interp, nsPtr, hPtr, *(*uintptr)(unsafe.Pointer(bp + 16)), pattern, *(*uintptr)(unsafe.Pointer(bp)), allowOverwrite)
	}
	hPtr = XTcl_FirstHashEntry(tls, *(*uintptr)(unsafe.Pointer(bp))+184, bp+24)
	for {
		if !(hPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TTcl_HashTable)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))+184)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))+184)).FkeyType == -int32(1) {
			v7 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
		} else {
			v7 = hPtr + 32
		}
		cmdName = v7
		if XTcl_StringCaseMatch(tls, cmdName, *(*uintptr)(unsafe.Pointer(bp + 16)), 0) != 0 && _DoImport(tls, interp, nsPtr, hPtr, cmdName, pattern, *(*uintptr)(unsafe.Pointer(bp)), allowOverwrite) == int32(TCL_ERROR) {
			return int32(TCL_ERROR)
		}
		goto _6
	_6:
		;
		hPtr = XTcl_NextHashEntry(tls, bp+24)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * DoImport --
 *
 *	Import a particular command from one namespace into another. Helper
 *	for Tcl_Import().
 *
 * Results:
 *	Standard Tcl result code. If TCL_ERROR, appends an error message to
 *	the interpreter result.
 *
 * Side effects:
 *	A new command is created in the target namespace unless this is a
 *	reimport of exactly the same command as before.
 *
 *----------------------------------------------------------------------
 */

func _DoImport(tls *libc.TLS, interp uintptr, nsPtr uintptr, hPtr uintptr, cmdName uintptr, pattern uintptr, importNsPtr uintptr, allowOverwrite int32) (r int32) {
	bp := tls.Alloc(272)
	defer tls.Free(272)
	var cmdPtr, dataPtr, dataPtr1, found, linkCmd, overwrite, overwrite1, refPtr uintptr
	var exported, i, v1 TTcl_Size
	var importedCmd TTcl_Command
	var _ /* ds at bp+0 */ TTcl_DString
	_, _, _, _, _, _, _, _, _, _, _, _ = cmdPtr, dataPtr, dataPtr1, exported, found, i, importedCmd, linkCmd, overwrite, overwrite1, refPtr, v1
	i = 0
	exported = 0
	/*
	 * The command cmdName in the source namespace matches the pattern. Check
	 * whether it was exported. If it wasn't, we ignore it.
	 */
	for !(exported != 0) && i < (*TNamespace)(unsafe.Pointer(importNsPtr)).FnumExportPatterns {
		v1 = i
		i++
		exported |= int64(XTcl_StringCaseMatch(tls, cmdName, *(*uintptr)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(importNsPtr)).FexportArrayPtr + uintptr(v1)*8)), 0))
	}
	if !(exported != 0) {
		return TCL_OK
	}
	/*
	 * Unless there is a name clash, create an imported command in the current
	 * namespace that refers to cmdPtr.
	 */
	found = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(nsPtr + 184)).FfindProc})))(tls, nsPtr+184, cmdName)
	if found == libc.UintptrFromInt32(0) || allowOverwrite != 0 {
		XTcl_DStringInit(tls, bp)
		XTcl_DStringAppend(tls, bp, (*TNamespace)(unsafe.Pointer(nsPtr)).FfullName, int64(-int32(1)))
		if nsPtr != (*TInterp)(unsafe.Pointer(interp)).FglobalNsPtr {
			XTcl_DStringAppend(tls, bp, __ccgo_ts+7650, libc.Int64FromUint64(libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)))
		}
		XTcl_DStringAppend(tls, bp, cmdName, int64(-int32(1)))
		/*
		 * Check whether creating the new imported command in the current
		 * namespace would create a cycle of imported command references.
		 */
		cmdPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		if found != libc.UintptrFromInt32(0) && (*TCommand)(unsafe.Pointer(cmdPtr)).FdeleteProc == __ccgo_fp(_DeleteImportedCmd) {
			overwrite = (*TTcl_HashEntry)(unsafe.Pointer(found)).FclientData
			linkCmd = cmdPtr
			for (*TCommand)(unsafe.Pointer(linkCmd)).FdeleteProc == __ccgo_fp(_DeleteImportedCmd) {
				dataPtr = (*TCommand)(unsafe.Pointer(linkCmd)).FobjClientData
				linkCmd = (*TImportedCmdData)(unsafe.Pointer(dataPtr)).FrealCmdPtr
				if overwrite == linkCmd {
					XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+53902, libc.VaList(bp+232, pattern, (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1)))
					XTcl_DStringFree(tls, bp)
					XTcl_SetErrorCode(tls, interp, libc.VaList(bp+232, __ccgo_ts+2004, __ccgo_ts+53733, __ccgo_ts+53966, libc.UintptrFromInt32(0)))
					return int32(TCL_ERROR)
				}
			}
		}
		dataPtr = XTcl_Alloc(tls, uint64(16))
		importedCmd = XTcl_NRCreateCommand(tls, interp, (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1, __ccgo_fp(XTclInvokeImportedCmd), __ccgo_fp(_InvokeImportedNRCmd), dataPtr, __ccgo_fp(_DeleteImportedCmd))
		(*TImportedCmdData)(unsafe.Pointer(dataPtr)).FrealCmdPtr = cmdPtr
		/* corresponding decrement is in DeleteImportedCmd */
		(*TCommand)(unsafe.Pointer(cmdPtr)).FrefCount++
		(*TImportedCmdData)(unsafe.Pointer(dataPtr)).FselfPtr = importedCmd
		(*TCommand1)(unsafe.Pointer((*TImportedCmdData)(unsafe.Pointer(dataPtr)).FselfPtr)).FcompileProc = (*TCommand)(unsafe.Pointer(cmdPtr)).FcompileProc
		XTcl_DStringFree(tls, bp)
		/*
		 * Create an ImportRef structure describing this new import command
		 * and add it to the import ref list in the "real" command.
		 */
		refPtr = XTcl_Alloc(tls, uint64(16))
		(*TImportRef)(unsafe.Pointer(refPtr)).FimportedCmdPtr = importedCmd
		(*TImportRef)(unsafe.Pointer(refPtr)).FnextPtr = (*TCommand)(unsafe.Pointer(cmdPtr)).FimportRefPtr
		(*TCommand)(unsafe.Pointer(cmdPtr)).FimportRefPtr = refPtr
	} else {
		overwrite1 = (*TTcl_HashEntry)(unsafe.Pointer(found)).FclientData
		if (*TCommand)(unsafe.Pointer(overwrite1)).FdeleteProc == __ccgo_fp(_DeleteImportedCmd) {
			dataPtr1 = (*TCommand)(unsafe.Pointer(overwrite1)).FobjClientData
			if (*TImportedCmdData)(unsafe.Pointer(dataPtr1)).FrealCmdPtr == (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData {
				/*
				 * Repeated import of same command is acceptable.
				 */
				return TCL_OK
			}
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+53971, libc.VaList(bp+232, cmdName)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+232, __ccgo_ts+2004, __ccgo_ts+53733, __ccgo_ts+54013, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ForgetImport --
 *
 *	Deletes commands previously imported into the namespace indicated.
 *	The by namespacePtr, or the current namespace of interp, when
 *	namespacePtr is NULL. The pattern controls which imported commands are
 *	deleted. A simple pattern, one without namespace separators, matches
 *	the current command names of imported commands in the namespace.
 *	Matching imported commands are deleted. A qualified pattern is
 *	interpreted as deletion selection on the basis of where the command is
 *	imported from. The original command and "first link" command for each
 *	imported command are determined, and they are matched against the
 *	pattern. A match leads to deletion of the imported command.
 *
 * Results:
 *	Returns TCL_ERROR and records an error message in the interp result if
 *	a namespace qualified pattern refers to a namespace that does not
 *	exist. Otherwise, returns TCL_OK.
 *
 * Side effects:
 *	May delete commands.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ForgetImport(tls *libc.TLS, interp uintptr, namespacePtr uintptr, pattern uintptr) (r int32) {
	bp := tls.Alloc(176)
	defer tls.Free(176) /* String pattern indicating which imported
	 * commands to remove. */
	var cmdName, cmdPtr, cmdPtr1, cmdPtr2, dataPtr, hPtr, nsPtr, v2 uintptr
	var firstToken, origin, token TTcl_Command
	var _ /* dummyPtr at bp+8 */ uintptr
	var _ /* info at bp+48 */ TTcl_CmdInfo
	var _ /* search at bp+24 */ TTcl_HashSearch
	var _ /* simplePattern at bp+16 */ uintptr
	var _ /* sourceNsPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _ = cmdName, cmdPtr, cmdPtr1, cmdPtr2, dataPtr, firstToken, hPtr, nsPtr, origin, token, v2
	/*
	 * If the specified namespace is NULL, use the current namespace.
	 */
	if namespacePtr == libc.UintptrFromInt32(0) {
		nsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FnsPtr
	} else {
		nsPtr = namespacePtr
	}
	/*
	 * Parse the pattern into its namespace-qualification (if any) and the
	 * simple pattern.
	 */
	XTclGetNamespaceForQualName(tls, interp, pattern, nsPtr, int32(TCL_NAMESPACE_ONLY), bp, bp+8, bp+8, bp+16)
	if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+54023, libc.VaList(bp+136, pattern)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+136, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+10127, pattern, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if libc.Xstrcmp(tls, pattern, *(*uintptr)(unsafe.Pointer(bp + 16))) == 0 {
		/*
		 * The pattern is simple. Delete any imported commands that match it.
		 */
		if libc.Xstrpbrk(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), __ccgo_ts+16411) == libc.UintptrFromInt32(0) {
			hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(nsPtr + 184)).FfindProc})))(tls, nsPtr+184, *(*uintptr)(unsafe.Pointer(bp + 16)))
			if hPtr != libc.UintptrFromInt32(0) {
				cmdPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
				if cmdPtr != 0 && (*TCommand)(unsafe.Pointer(cmdPtr)).FdeleteProc == __ccgo_fp(_DeleteImportedCmd) {
					XTcl_DeleteCommandFromToken(tls, interp, cmdPtr)
				}
			}
			return TCL_OK
		}
		hPtr = XTcl_FirstHashEntry(tls, nsPtr+184, bp+24)
		for {
			if !(hPtr != libc.UintptrFromInt32(0)) {
				break
			}
			cmdPtr1 = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
			if (*TCommand)(unsafe.Pointer(cmdPtr1)).FdeleteProc != __ccgo_fp(_DeleteImportedCmd) {
				goto _1
			}
			if (*TTcl_HashTable)(unsafe.Pointer(nsPtr+184)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(nsPtr+184)).FkeyType == -int32(1) {
				v2 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
			} else {
				v2 = hPtr + 32
			}
			cmdName = v2
			if XTcl_StringCaseMatch(tls, cmdName, *(*uintptr)(unsafe.Pointer(bp + 16)), 0) != 0 {
				XTcl_DeleteCommandFromToken(tls, interp, cmdPtr1)
			}
			goto _1
		_1:
			;
			hPtr = XTcl_NextHashEntry(tls, bp+24)
		}
		return TCL_OK
	}
	/*
	 * The pattern was namespace-qualified.
	 */
	hPtr = XTcl_FirstHashEntry(tls, nsPtr+184, bp+24)
	for {
		if !(hPtr != libc.UintptrFromInt32(0)) {
			break
		}
		token = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		origin = XTclGetOriginalCommand(tls, token)
		if XTcl_GetCommandInfoFromToken(tls, origin, bp+48) == 0 {
			goto _3 /* Not an imported command. */
		}
		if (*(*TTcl_CmdInfo)(unsafe.Pointer(bp + 48))).FnamespacePtr != *(*uintptr)(unsafe.Pointer(bp)) {
			/*
			 * Original not in namespace we're matching. Check the first link
			 * in the import chain.
			 */
			cmdPtr2 = token
			dataPtr = (*TCommand)(unsafe.Pointer(cmdPtr2)).FobjClientData
			firstToken = (*TImportedCmdData)(unsafe.Pointer(dataPtr)).FrealCmdPtr
			if firstToken == origin {
				goto _3
			}
			XTcl_GetCommandInfoFromToken(tls, firstToken, bp+48)
			if (*(*TTcl_CmdInfo)(unsafe.Pointer(bp + 48))).FnamespacePtr != *(*uintptr)(unsafe.Pointer(bp)) {
				goto _3
			}
			origin = firstToken
		}
		if XTcl_StringCaseMatch(tls, XTcl_GetCommandName(tls, libc.UintptrFromInt32(0), origin), *(*uintptr)(unsafe.Pointer(bp + 16)), 0) != 0 {
			XTcl_DeleteCommandFromToken(tls, interp, token)
		}
		goto _3
	_3:
		;
		hPtr = XTcl_NextHashEntry(tls, bp+24)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclGetOriginalCommand --
 *
 *	An imported command is created in an namespace when a "real" command
 *	is imported from another namespace. If the specified command is an
 *	imported command, this function returns the original command it refers
 *	to.
 *
 * Results:
 *	If the command was imported into a sequence of namespaces a, b,...,n
 *	where each successive namespace just imports the command from the
 *	previous namespace, this function returns the Tcl_Command token in the
 *	first namespace, a. Otherwise, if the specified command is not an
 *	imported command, the function returns NULL.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclGetOriginalCommand(tls *libc.TLS, command TTcl_Command) (r TTcl_Command) {
	/* The imported command for which the original
	 * command should be returned. */
	var cmdPtr, dataPtr uintptr
	_, _ = cmdPtr, dataPtr
	cmdPtr = command
	if (*TCommand)(unsafe.Pointer(cmdPtr)).FdeleteProc != __ccgo_fp(_DeleteImportedCmd) {
		return libc.UintptrFromInt32(0)
	}
	for (*TCommand)(unsafe.Pointer(cmdPtr)).FdeleteProc == __ccgo_fp(_DeleteImportedCmd) {
		dataPtr = (*TCommand)(unsafe.Pointer(cmdPtr)).FobjClientData
		cmdPtr = (*TImportedCmdData)(unsafe.Pointer(dataPtr)).FrealCmdPtr
	}
	return cmdPtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclInvokeImportedCmd --
 *
 *	Invoked by Tcl whenever the user calls an imported command that was
 *	created by Tcl_Import. Finds the "real" command (in another
 *	namespace), and passes control to it.
 *
 * Results:
 *	Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If anything goes
 *	wrong, the result object is set to an error message.
 *
 *----------------------------------------------------------------------
 */

func _InvokeImportedNRCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* The argument objects. */
	var dataPtr, realCmdPtr uintptr
	_, _ = dataPtr, realCmdPtr
	dataPtr = clientData
	realCmdPtr = (*TImportedCmdData)(unsafe.Pointer(dataPtr)).FrealCmdPtr
	XTclSkipTailcall(tls, interp)
	return XTclNREvalObjv(tls, interp, int64(objc), objv, int32(TCL_EVAL_NOERR), realCmdPtr)
}

func XTclInvokeImportedCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* The argument objects. */
	return XTcl_NRCallObjProc(tls, interp, __ccgo_fp(_InvokeImportedNRCmd), clientData, int64(objc), objv)
}

/*
 *----------------------------------------------------------------------
 *
 * DeleteImportedCmd --
 *
 *	Invoked by Tcl whenever an imported command is deleted. The "real"
 *	command keeps a list of all the imported commands that refer to it, so
 *	those imported commands can be deleted when the real command is
 *	deleted. This function removes the imported command reference from the
 *	real command's list, and frees up the memory associated with the
 *	imported command.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Removes the imported command from the real command's import list.
 *
 *----------------------------------------------------------------------
 */

func _DeleteImportedCmd(tls *libc.TLS, clientData uintptr) {
	/* Points to the imported command's
	 * ImportedCmdData structure. */
	var dataPtr, prevPtr, realCmdPtr, refPtr, selfPtr, v3 uintptr
	var v2 TTcl_Size
	_, _, _, _, _, _, _ = dataPtr, prevPtr, realCmdPtr, refPtr, selfPtr, v2, v3
	dataPtr = clientData
	realCmdPtr = (*TImportedCmdData)(unsafe.Pointer(dataPtr)).FrealCmdPtr
	selfPtr = (*TImportedCmdData)(unsafe.Pointer(dataPtr)).FselfPtr
	prevPtr = libc.UintptrFromInt32(0)
	refPtr = (*TCommand)(unsafe.Pointer(realCmdPtr)).FimportRefPtr
	for {
		if !(refPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TImportRef)(unsafe.Pointer(refPtr)).FimportedCmdPtr == selfPtr {
			/*
			 * Remove *refPtr from real command's list of imported commands
			 * that refer to it.
			 */
			if prevPtr == libc.UintptrFromInt32(0) { /* refPtr is first in list. */
				(*TCommand)(unsafe.Pointer(realCmdPtr)).FimportRefPtr = (*TImportRef)(unsafe.Pointer(refPtr)).FnextPtr
			} else {
				(*TImportRef)(unsafe.Pointer(prevPtr)).FnextPtr = (*TImportRef)(unsafe.Pointer(refPtr)).FnextPtr
			}
			XTclpFree(tls, refPtr)
			v3 = realCmdPtr + 16
			v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
			*(*TTcl_Size)(unsafe.Pointer(v3))--
			if v2 <= int64(1) {
				XTclpFree(tls, realCmdPtr)
			}
			XTclpFree(tls, dataPtr)
			return
		}
		prevPtr = refPtr
		goto _1
	_1:
		;
		refPtr = (*TImportRef)(unsafe.Pointer(refPtr)).FnextPtr
	}
	XTcl_Panic(tls, __ccgo_ts+54074, 0)
}

/*
 *----------------------------------------------------------------------
 *
 * TclGetNamespaceForQualName --
 *
 *	Given a qualified name specifying a command, variable, or namespace,
 *	and a namespace in which to resolve the name, this function returns a
 *	pointer to the namespace that contains the item. A qualified name
 *	consists of the "simple" name of an item qualified by the names of an
 *	arbitrary number of containing namespace separated by "::"s. If the
 *	qualified name starts with "::", it is interpreted absolutely from the
 *	global namespace. Otherwise, it is interpreted relative to the
 *	namespace specified by cxtNsPtr if it is non-NULL. If cxtNsPtr is
 *	NULL, the name is interpreted relative to the current namespace.
 *
 *	A relative name like "foo::bar::x" can be found starting in either the
 *	current namespace or in the global namespace. So each search usually
 *	follows two tracks, and two possible namespaces are returned. If the
 *	function sets either *nsPtrPtr or *altNsPtrPtr to NULL, then that path
 *	failed.
 *
 *	If "flags" contains TCL_GLOBAL_ONLY, the relative qualified name is
 *	sought only in the global :: namespace. The alternate search (also)
 *	starting from the global namespace is ignored and *altNsPtrPtr is set
 *	NULL.
 *
 *	If "flags" contains TCL_NAMESPACE_ONLY, the relative qualified name is
 *	sought only in the namespace specified by cxtNsPtr. The alternate
 *	search starting from the global namespace is ignored and *altNsPtrPtr
 *	is set NULL. If both TCL_GLOBAL_ONLY and TCL_NAMESPACE_ONLY are
 *	specified, TCL_GLOBAL_ONLY is ignored and the search starts from the
 *	namespace specified by cxtNsPtr.
 *
 *	If "flags" contains TCL_CREATE_NS_IF_UNKNOWN, all namespace components
 *	of the qualified name that cannot be found are automatically created
 *	within their specified parent. This makes sure that functions like
 *	Tcl_CreateObjCommand always succeed. There is no alternate search path,
 *	so *altNsPtrPtr is set NULL.
 *
 *	If "flags" contains TCL_FIND_ONLY_NS, the qualified name is treated as
 *	a reference to a namespace, and the entire qualified name is followed.
 *	If the name is relative, the namespace is looked up only in the
 *	current namespace. A pointer to the namespace is stored in *nsPtrPtr
 *	and NULL is stored in *simpleNamePtr. Otherwise, if TCL_FIND_ONLY_NS
 *	is not specified, only the leading components are treated as namespace
 *	names, and a pointer to the simple name of the final component is
 *	stored in *simpleNamePtr.
 *
 * Results:
 *	It sets *nsPtrPtr and *altNsPtrPtr to point to the two possible
 *	namespaces which represent the last (containing) namespace in the
 *	qualified name. If the function sets either *nsPtrPtr or *altNsPtrPtr
 *	to NULL, then the search along that path failed. The function also
 *	stores a pointer to the simple name of the final component in
 *	*simpleNamePtr. If the qualified name is "::" or was treated as a
 *	namespace reference (TCL_FIND_ONLY_NS), the function stores a pointer
 *	to the namespace in *nsPtrPtr, NULL in *altNsPtrPtr, and sets
 *	*simpleNamePtr to point to an empty string.
 *
 *	If there is an error, this function returns TCL_ERROR. If "flags"
 *	contains TCL_LEAVE_ERR_MSG, an error message is returned in the
 *	interpreter's result object. Otherwise, the interpreter's result
 *	object is left unchanged.
 *
 *	*actualCxtPtrPtr is set to the actual context namespace. It is set to
 *	the input context namespace pointer in cxtNsPtr. If cxtNsPtr is NULL,
 *	it is set to the current namespace context.
 *
 *	For backwards compatibility with the TclPro byte code loader, this
 *	function always returns TCL_OK.
 *
 * Side effects:
 *	If "flags" contains TCL_CREATE_NS_IF_UNKNOWN, new namespaces may be
 *	created.
 *
 *----------------------------------------------------------------------
 */

func XTclGetNamespaceForQualName(tls *libc.TLS, interp uintptr, qualName uintptr, cxtNsPtr uintptr, flags int32, nsPtrPtr uintptr, altNsPtrPtr uintptr, actualCxtPtrPtr uintptr, simpleNamePtr uintptr) (r int32) {
	bp := tls.Alloc(256)
	defer tls.Free(256) /* Address where function stores the simple
	 * name at end of the qualName, or NULL if
	 * qualName is "::" or the flag
	 * TCL_FIND_ONLY_NS was specified. */
	var altNsPtr, end, entryPtr, globalNsPtr, iPtr, lastAltNsPtr, lastNsPtr, nsName, nsPtr, start uintptr
	var len1 int32
	var _ /* buffer at bp+0 */ TTcl_DString
	var _ /* framePtr at bp+224 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _ = altNsPtr, end, entryPtr, globalNsPtr, iPtr, lastAltNsPtr, lastNsPtr, len1, nsName, nsPtr, start
	iPtr = interp
	nsPtr = cxtNsPtr
	lastNsPtr = libc.UintptrFromInt32(0)
	lastAltNsPtr = libc.UintptrFromInt32(0)
	globalNsPtr = (*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr
	/*
	 * Determine the context namespace nsPtr in which to start the primary
	 * search. If the qualName name starts with a "::" or TCL_GLOBAL_ONLY was
	 * specified, search from the global namespace. Otherwise, use the
	 * namespace given in cxtNsPtr, or if that is NULL, use the current
	 * namespace context. Note that we always treat two or more adjacent ":"s
	 * as a namespace separator.
	 */
	if flags&int32(TCL_GLOBAL_ONLY) != 0 {
		nsPtr = globalNsPtr
	} else {
		if nsPtr == libc.UintptrFromInt32(0) {
			nsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FnsPtr
		}
	}
	start = qualName /* Points to start of qualifying
	 * namespace. */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(qualName))) == int32(':') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(qualName + 1))) == int32(':') {
		start = qualName + uintptr(2) /* Skip over the initial :: */
		for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start))) == int32(':') {
			start++ /* Skip over a subsequent : */
		}
		nsPtr = globalNsPtr
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start))) == int32('\000') { /* qualName is just two or more
			 * ":"s. */
			*(*uintptr)(unsafe.Pointer(nsPtrPtr)) = globalNsPtr
			*(*uintptr)(unsafe.Pointer(altNsPtrPtr)) = libc.UintptrFromInt32(0)
			*(*uintptr)(unsafe.Pointer(actualCxtPtrPtr)) = globalNsPtr
			*(*uintptr)(unsafe.Pointer(simpleNamePtr)) = start /* Points to empty string. */
			return TCL_OK
		}
	}
	*(*uintptr)(unsafe.Pointer(actualCxtPtrPtr)) = nsPtr
	/*
	 * Start an alternate search path starting with the global namespace.
	 * However, if the starting context is the global namespace, or if the
	 * flag is set to search only the namespace *cxtNsPtr, ignore the
	 * alternate search path.
	 */
	altNsPtr = globalNsPtr
	if nsPtr == globalNsPtr || flags&(libc.Int32FromInt32(TCL_NAMESPACE_ONLY)|libc.Int32FromInt32(TCL_FIND_ONLY_NS)) != 0 {
		altNsPtr = libc.UintptrFromInt32(0)
	}
	/*
	 * Loop to resolve each namespace qualifier in qualName.
	 */
	XTcl_DStringInit(tls, bp)
	end = start
	for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(start))) != int32('\000') {
		/*
		 * Find the next namespace qualifier (i.e., a name ending in "::") or
		 * the end of the qualified name (i.e., a name ending in "\0"). Set
		 * len to the number of characters, starting from start, in the name;
		 * set end to point after the "::"s or at the "\0".
		 */
		len1 = 0
		end = start
		for {
			if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(end))) != int32('\000')) {
				break
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(end))) == int32(':') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(end + 1))) == int32(':') {
				end += uintptr(2) /* Skip over the initial :: */
				for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(end))) == int32(':') {
					end++ /* Skip over the subsequent : */
				}
				break /* Exit for loop; end is after ::'s */
			}
			len1++
			goto _1
		_1:
			;
			end++
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(end))) == int32('\000') && !(int64(end)-int64(start) >= int64(2) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(end + uintptr(-libc.Int32FromInt32(1))))) == int32(':') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(end + uintptr(-libc.Int32FromInt32(2))))) == int32(':')) {
			/*
			 * qualName ended with a simple name at start. If TCL_FIND_ONLY_NS
			 * was specified, look this up as a namespace. Otherwise, start is
			 * the name of a cmd or var and we are done.
			 */
			if flags&int32(TCL_FIND_ONLY_NS) != 0 {
				nsName = start
			} else {
				*(*uintptr)(unsafe.Pointer(simpleNamePtr)) = start
				goto done
			}
		} else {
			/*
			 * start points to the beginning of a namespace qualifier ending
			 * in "::". end points to the start of a name in that namespace
			 * that might be empty. Copy the namespace qualifier to a buffer
			 * so it can be null terminated. We can't modify the incoming
			 * qualName since it may be a string constant.
			 */
			XTcl_DStringSetLength(tls, bp, 0)
			XTcl_DStringAppend(tls, bp, start, int64(len1))
			nsName = (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1
		}
		/*
		 * Look up the namespace qualifier nsName in the current namespace
		 * context. If it isn't found but TCL_CREATE_NS_IF_UNKNOWN is set,
		 * create that qualifying namespace. This is needed for functions like
		 * Tcl_CreateObjCommand that cannot fail.
		 */
		if nsPtr != libc.UintptrFromInt32(0) {
			entryPtr = _FindChildEntry(tls, nsPtr, nsName)
			if entryPtr != libc.UintptrFromInt32(0) {
				nsPtr = (*TTcl_HashEntry)(unsafe.Pointer(entryPtr)).FclientData
			} else {
				if flags&int32(TCL_CREATE_NS_IF_UNKNOWN) != 0 {
					XTclPushStackFrame(tls, interp, bp+224, nsPtr, 0)
					nsPtr = XTcl_CreateNamespace(tls, interp, nsName, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
					XTclPopStackFrame(tls, interp)
					if nsPtr == libc.UintptrFromInt32(0) {
						XTcl_Panic(tls, __ccgo_ts+54150, libc.VaList(bp+240, nsName))
					}
				} else {
					/*
					 * Namespace not found and was not created.
					 * Remember last found namespace for TCL_FIND_IF_NOT_SIMPLE.
					 */
					lastNsPtr = nsPtr
					nsPtr = libc.UintptrFromInt32(0)
				}
			}
		}
		/*
		 * Look up the namespace qualifier in the alternate search path too.
		 */
		if altNsPtr != libc.UintptrFromInt32(0) {
			entryPtr = _FindChildEntry(tls, altNsPtr, nsName)
			if entryPtr != libc.UintptrFromInt32(0) {
				altNsPtr = (*TTcl_HashEntry)(unsafe.Pointer(entryPtr)).FclientData
			} else {
				/* Remember last found in alternate path */
				lastAltNsPtr = altNsPtr
				altNsPtr = libc.UintptrFromInt32(0)
			}
		}
		/*
		 * If both search paths have failed, return NULL results.
		 */
		if nsPtr == libc.UintptrFromInt32(0) && altNsPtr == libc.UintptrFromInt32(0) {
			if flags&int32(TCL_FIND_IF_NOT_SIMPLE) != 0 {
				/*
				 * return last found NS, regardless simple name or not,
				 * e. g. ::A::B::C::D -> ::A::B and C::D, if namespace C
				 * cannot be found in ::A::B
				 */
				nsPtr = lastNsPtr
				altNsPtr = lastAltNsPtr
				*(*uintptr)(unsafe.Pointer(simpleNamePtr)) = start
				goto done
			}
			*(*uintptr)(unsafe.Pointer(simpleNamePtr)) = libc.UintptrFromInt32(0)
			goto done
		}
		start = end
	}
	/*
	 * We ignore trailing "::"s in a namespace name, but in a command or
	 * variable name, trailing "::"s refer to the cmd or var named {}.
	 */
	if flags&int32(TCL_FIND_ONLY_NS) != 0 || end > start && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(end + uintptr(-libc.Int32FromInt32(1))))) != int32(':') {
		*(*uintptr)(unsafe.Pointer(simpleNamePtr)) = libc.UintptrFromInt32(0) /* Found namespace name. */
	} else {
		*(*uintptr)(unsafe.Pointer(simpleNamePtr)) = end /* Found cmd/var: points to empty
		 * string. */
	}
	/*
	 * As a special case, if we are looking for a namespace and qualName is ""
	 * and the current active namespace (nsPtr) is not the global namespace,
	 * return NULL (no namespace was found). This is because namespaces can
	 * not have empty names except for the global namespace.
	 */
	if flags&int32(TCL_FIND_ONLY_NS) != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(qualName))) == int32('\000') && nsPtr != globalNsPtr {
		nsPtr = libc.UintptrFromInt32(0)
	}
	goto done
done:
	;
	*(*uintptr)(unsafe.Pointer(nsPtrPtr)) = nsPtr
	*(*uintptr)(unsafe.Pointer(altNsPtrPtr)) = altNsPtr
	XTcl_DStringFree(tls, bp)
	return TCL_OK
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * TclEnsureNamespace --
//	 *
//	 *	Provide a namespace that is not deleted.
//	 *
//	 * Value
//	 *
//	 *	namespacePtr, if it is not scheduled for deletion, or a pointer to a
//	 *	new namespace with the same name otherwise.
//	 *
//	 * Effect
//	 *	None.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func XTclEnsureNamespace(tls *libc.TLS, interp uintptr, namespacePtr uintptr) (r uintptr) {
	var nsPtr uintptr
	_ = nsPtr
	nsPtr = namespacePtr
	if !((*TNamespace)(unsafe.Pointer(nsPtr)).Fflags&libc.Int32FromInt32(NS_DYING) != 0) {
		return namespacePtr
	}
	return XTcl_CreateNamespace(tls, interp, (*TNamespace)(unsafe.Pointer(nsPtr)).FfullName, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FindNamespace --
 *
 *	Searches for a namespace.
 *
 * Results:
 *	Returns a pointer to the namespace if it is found. Otherwise, returns
 *	NULL and leaves an error message in the interpreter's result object if
 *	"flags" contains TCL_LEAVE_ERR_MSG.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FindNamespace(tls *libc.TLS, interp uintptr, name uintptr, contextNsPtr uintptr, flags int32) (r uintptr) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* Flags controlling namespace lookup: an OR'd
	 * combination of TCL_GLOBAL_ONLY and
	 * TCL_LEAVE_ERR_MSG flags. */
	var _ /* dummy at bp+24 */ uintptr
	var _ /* dummy1Ptr at bp+8 */ uintptr
	var _ /* dummy2Ptr at bp+16 */ uintptr
	var _ /* nsPtr at bp+0 */ uintptr
	/*
	 * Find the namespace(s) that contain the specified namespace name. Add
	 * the TCL_FIND_ONLY_NS flag to resolve the name all the way down to its
	 * last component, a namespace.
	 */
	XTclGetNamespaceForQualName(tls, interp, name, contextNsPtr, flags|int32(TCL_FIND_ONLY_NS), bp, bp+8, bp+16, bp+24)
	if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
		return *(*uintptr)(unsafe.Pointer(bp))
	}
	if flags&int32(TCL_LEAVE_ERR_MSG) != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+54182, libc.VaList(bp+40, name)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+10127, name, libc.UintptrFromInt32(0)))
	}
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FindCommand --
 *
 *	Searches for a command.
 *
 * Results:
 *	Returns a token for the command if it is found. Otherwise, if it can't
 *	be found or there is an error, returns NULL and leaves an error
 *	message in the interpreter's result object if "flags" contains
 *	TCL_LEAVE_ERR_MSG.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FindCommand(tls *libc.TLS, interp uintptr, name uintptr, contextNsPtr uintptr, flags int32) (r TTcl_Command) {
	bp := tls.Alloc(112)
	defer tls.Free(112) /* An OR'd combination of flags:
	 * TCL_GLOBAL_ONLY (look up name only in
	 * global namespace), TCL_NAMESPACE_ONLY (look
	 * up only in contextNsPtr, or the current
	 * namespace if contextNsPtr is NULL), and
	 * TCL_LEAVE_ERR_MSG. If both TCL_GLOBAL_ONLY
	 * and TCL_NAMESPACE_ONLY are given,
	 * TCL_GLOBAL_ONLY is ignored. */
	var cmdPtr, entryPtr, iPtr, pathNsPtr, resPtr uintptr
	var i TTcl_Size
	var result, search int32
	var _ /* cmd at bp+16 */ TTcl_Command
	var _ /* cxtNsPtr at bp+0 */ uintptr
	var _ /* dummyNsPtr at bp+32 */ uintptr
	var _ /* nsPtr at bp+40 */ [2]uintptr
	var _ /* realNsPtr at bp+24 */ uintptr
	var _ /* simpleName at bp+8 */ uintptr
	_, _, _, _, _, _, _, _ = cmdPtr, entryPtr, i, iPtr, pathNsPtr, resPtr, result, search
	iPtr = interp
	/*
	 * If this namespace has a command resolver, then give it first crack at
	 * the command resolution. If the interpreter has any command resolvers,
	 * consult them next. The command resolver functions may return a
	 * Tcl_Command value, they may signal to continue onward, or they may
	 * signal an error.
	 */
	if flags&int32(TCL_GLOBAL_ONLY) != 0 || !(libc.Xstrncmp(tls, name, __ccgo_ts+7650, uint64(2)) != 0) {
		*(*uintptr)(unsafe.Pointer(bp)) = (*TInterp)(unsafe.Pointer(interp)).FglobalNsPtr
	} else {
		if contextNsPtr != libc.UintptrFromInt32(0) {
			*(*uintptr)(unsafe.Pointer(bp)) = contextNsPtr
		} else {
			*(*uintptr)(unsafe.Pointer(bp)) = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FnsPtr
		}
	}
	if (*TNamespace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FcmdResProc != libc.UintptrFromInt32(0) || (*TInterp)(unsafe.Pointer(iPtr)).FresolverPtr != libc.UintptrFromInt32(0) {
		resPtr = (*TInterp)(unsafe.Pointer(iPtr)).FresolverPtr
		if (*TNamespace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FcmdResProc != 0 {
			result = (*(*func(*libc.TLS, uintptr, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TNamespace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FcmdResProc})))(tls, interp, name, *(*uintptr)(unsafe.Pointer(bp)), flags, bp+16)
		} else {
			result = int32(TCL_CONTINUE)
		}
		for result == int32(TCL_CONTINUE) && resPtr != 0 {
			if (*TResolverScheme)(unsafe.Pointer(resPtr)).FcmdResProc != 0 {
				result = (*(*func(*libc.TLS, uintptr, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TResolverScheme)(unsafe.Pointer(resPtr)).FcmdResProc})))(tls, interp, name, *(*uintptr)(unsafe.Pointer(bp)), flags, bp+16)
			}
			resPtr = (*TResolverScheme)(unsafe.Pointer(resPtr)).FnextPtr
		}
		if result == TCL_OK {
			*(*int32)(unsafe.Pointer(*(*TTcl_Command)(unsafe.Pointer(bp + 16)) + 88)) |= int32(CMD_VIA_RESOLVER)
			return *(*TTcl_Command)(unsafe.Pointer(bp + 16))
		} else {
			if result != int32(TCL_CONTINUE) {
				return libc.UintptrFromInt32(0)
			}
		}
	}
	/*
	 * Find the namespace(s) that contain the command.
	 */
	cmdPtr = libc.UintptrFromInt32(0)
	if (*TNamespace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FcommandPathLength != 0 && libc.Xstrncmp(tls, name, __ccgo_ts+7650, uint64(2)) != 0 && !(flags&libc.Int32FromInt32(TCL_NAMESPACE_ONLY) != 0) {
		XTclGetNamespaceForQualName(tls, interp, name, *(*uintptr)(unsafe.Pointer(bp)), int32(TCL_NAMESPACE_ONLY), bp+24, bp+32, bp+32, bp+8)
		if *(*uintptr)(unsafe.Pointer(bp + 24)) != libc.UintptrFromInt32(0) && *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) {
			if *(*uintptr)(unsafe.Pointer(bp)) == *(*uintptr)(unsafe.Pointer(bp + 24)) || !((*TNamespace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Fflags&libc.Int32FromInt32(NS_DEAD) != 0) {
				entryPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 184)).FfindProc})))(tls, *(*uintptr)(unsafe.Pointer(bp + 24))+184, *(*uintptr)(unsafe.Pointer(bp + 8)))
				if entryPtr != libc.UintptrFromInt32(0) {
					cmdPtr = (*TTcl_HashEntry)(unsafe.Pointer(entryPtr)).FclientData
				}
			}
		}
		/*
		 * Next, check along the path.
		 */
		i = 0
		for {
			if !(cmdPtr == libc.UintptrFromInt32(0) && i < (*TNamespace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FcommandPathLength) {
				break
			}
			pathNsPtr = (*(*TNamespacePathEntry)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FcommandPathArray + uintptr(i)*32))).FnsPtr
			if pathNsPtr == libc.UintptrFromInt32(0) {
				goto _1
			}
			XTclGetNamespaceForQualName(tls, interp, name, pathNsPtr, int32(TCL_NAMESPACE_ONLY), bp+24, bp+32, bp+32, bp+8)
			if *(*uintptr)(unsafe.Pointer(bp + 24)) != libc.UintptrFromInt32(0) && *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) && !((*TNamespace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Fflags&libc.Int32FromInt32(NS_DEAD) != 0) {
				entryPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 184)).FfindProc})))(tls, *(*uintptr)(unsafe.Pointer(bp + 24))+184, *(*uintptr)(unsafe.Pointer(bp + 8)))
				if entryPtr != libc.UintptrFromInt32(0) {
					cmdPtr = (*TTcl_HashEntry)(unsafe.Pointer(entryPtr)).FclientData
				}
			}
			goto _1
		_1:
			;
			i++
		}
		/*
		 * If we've still not found the command, look in the global namespace
		 * as a last resort.
		 */
		if cmdPtr == libc.UintptrFromInt32(0) {
			XTclGetNamespaceForQualName(tls, interp, name, libc.UintptrFromInt32(0), int32(TCL_GLOBAL_ONLY), bp+24, bp+32, bp+32, bp+8)
			if *(*uintptr)(unsafe.Pointer(bp + 24)) != libc.UintptrFromInt32(0) && *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) && !((*TNamespace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Fflags&libc.Int32FromInt32(NS_DEAD) != 0) {
				entryPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 184)).FfindProc})))(tls, *(*uintptr)(unsafe.Pointer(bp + 24))+184, *(*uintptr)(unsafe.Pointer(bp + 8)))
				if entryPtr != libc.UintptrFromInt32(0) {
					cmdPtr = (*TTcl_HashEntry)(unsafe.Pointer(entryPtr)).FclientData
				}
			}
		}
	} else {
		XTclGetNamespaceForQualName(tls, interp, name, *(*uintptr)(unsafe.Pointer(bp)), flags, bp+40, bp+40+1*8, bp, bp+8)
		/*
		 * Look for the command in the command table of its namespace. Be sure
		 * to check both possible search paths: from the specified namespace
		 * context and from the global namespace.
		 */
		search = 0
		for {
			if !(search < int32(2) && cmdPtr == libc.UintptrFromInt32(0)) {
				break
			}
			if (*(*[2]uintptr)(unsafe.Pointer(bp + 40)))[search] != libc.UintptrFromInt32(0) && *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) {
				entryPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp + 40)))[search] + 184)).FfindProc})))(tls, (*(*[2]uintptr)(unsafe.Pointer(bp + 40)))[search]+184, *(*uintptr)(unsafe.Pointer(bp + 8)))
				if entryPtr != libc.UintptrFromInt32(0) {
					cmdPtr = (*TTcl_HashEntry)(unsafe.Pointer(entryPtr)).FclientData
				}
			}
			goto _2
		_2:
			;
			search++
		}
	}
	if cmdPtr != libc.UintptrFromInt32(0) {
		*(*int32)(unsafe.Pointer(cmdPtr + 88)) &= ^libc.Int32FromInt32(CMD_VIA_RESOLVER)
		return cmdPtr
	}
	if flags&int32(TCL_LEAVE_ERR_MSG) != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+54205, libc.VaList(bp+64, name)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+64, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+8118, name, libc.UintptrFromInt32(0)))
	}
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * TclResetShadowedCmdRefs --
 *
 *	Called when a command is added to a namespace to check for existing
 *	command references that the new command may invalidate. Consider the
 *	following cases that could happen when you add a command "foo" to a
 *	namespace "b":
 *	   1. It could shadow a command named "foo" at the global scope. If
 *	      it does, all command references in the namespace "b" are
 *	      suspect.
 *	   2. Suppose the namespace "b" resides in a namespace "a". Then to
 *	      "a" the new command "b::foo" could shadow another command
 *	      "b::foo" in the global namespace. If so, then all command
 *	      references in "a" * are suspect.
 *	The same checks are applied to all parent namespaces, until we reach
 *	the global :: namespace.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	If the new command shadows an existing command, the cmdRefEpoch
 *	counter is incremented in each namespace that sees the shadow. This
 *	invalidates all command references that were previously cached in that
 *	namespace. The next time the commands are used, they are resolved from
 *	scratch.
 *
 *----------------------------------------------------------------------
 */

func XTclResetShadowedCmdRefs(tls *libc.TLS, interp uintptr, newCmdPtr uintptr) {
	/* Points to the new command. */
	var cmdName, globalNsPtr, hPtr, nsPtr, shadowNsPtr, trailNsPtr, trailPtr, v1 uintptr
	var found, i, newSize, trailFront, trailSize int32
	_, _, _, _, _, _, _, _, _, _, _, _, _ = cmdName, found, globalNsPtr, hPtr, i, newSize, nsPtr, shadowNsPtr, trailFront, trailNsPtr, trailPtr, trailSize, v1
	globalNsPtr = (*TInterp)(unsafe.Pointer(interp)).FglobalNsPtr
	trailFront = -int32(1)
	trailSize = int32(5) /* Formerly NUM_TRAIL_ELEMS. */
	trailPtr = XTclStackAlloc(tls, interp, libc.Uint64FromInt32(trailSize)*uint64(8))
	/*
	 * Start at the namespace containing the new command, and work up through
	 * the list of parents. Stop just before the global namespace, since the
	 * global namespace can't "shadow" its own entries.
	 *
	 * The namespace "trail" list we build consists of the names of each
	 * namespace that encloses the new command, in order from outermost to
	 * innermost: for example, "a" then "b". Each iteration of this loop
	 * eventually extends the trail upwards by one namespace, nsPtr. We use
	 * this trail list to see if nsPtr (e.g. "a" in 2. above) could have
	 * now-invalid cached command references. This will happen if nsPtr
	 * (e.g. "a") contains a sequence of child namespaces (e.g. "b") such that
	 * there is a identically-named sequence of child namespaces starting from
	 * :: (e.g. "::b") whose tail namespace contains a command also named
	 * cmdName.
	 */
	if (*TTcl_HashTable)(unsafe.Pointer((*TTcl_HashEntry)(unsafe.Pointer((*TCommand)(unsafe.Pointer(newCmdPtr)).FhPtr)).FtablePtr)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer((*TTcl_HashEntry)(unsafe.Pointer((*TCommand)(unsafe.Pointer(newCmdPtr)).FhPtr)).FtablePtr)).FkeyType == -int32(1) {
		v1 = *(*uintptr)(unsafe.Pointer((*TCommand)(unsafe.Pointer(newCmdPtr)).FhPtr + 32))
	} else {
		v1 = (*TCommand)(unsafe.Pointer(newCmdPtr)).FhPtr + 32
	}
	cmdName = v1
	nsPtr = (*TCommand)(unsafe.Pointer(newCmdPtr)).FnsPtr
	for {
		if !(nsPtr != libc.UintptrFromInt32(0) && nsPtr != globalNsPtr) {
			break
		}
		/*
		 * Find the maximal sequence of child namespaces contained in nsPtr
		 * such that there is a identically-named sequence of child namespaces
		 * starting from ::. shadowNsPtr will be the tail of this sequence, or
		 * the deepest namespace under :: that might contain a command now
		 * shadowed by cmdName. We check below if shadowNsPtr actually
		 * contains a command cmdName.
		 */
		found = int32(1)
		shadowNsPtr = globalNsPtr
		i = trailFront
		for {
			if !(i >= 0) {
				break
			}
			trailNsPtr = *(*uintptr)(unsafe.Pointer(trailPtr + uintptr(i)*8))
			hPtr = _FindChildEntry(tls, shadowNsPtr, (*TNamespace)(unsafe.Pointer(trailNsPtr)).Fname)
			if hPtr != libc.UintptrFromInt32(0) {
				shadowNsPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
			} else {
				found = 0
				break
			}
			goto _3
		_3:
			;
			i--
		}
		/*
		 * If shadowNsPtr contains a command named cmdName, we invalidate all
		 * of the command refs cached in nsPtr. As a boundary case,
		 * shadowNsPtr is initially :: and we check for case 1. above.
		 */
		if found != 0 {
			hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(shadowNsPtr + 184)).FfindProc})))(tls, shadowNsPtr+184, cmdName)
			if hPtr != libc.UintptrFromInt32(0) {
				(*TNamespace)(unsafe.Pointer(nsPtr)).FcmdRefEpoch++
				XTclInvalidateNsPath(tls, nsPtr)
				/*
				 * If the shadowed command was compiled to bytecodes, we
				 * invalidate all the bytecodes in nsPtr, to force a new
				 * compilation. We use the resolverEpoch to signal the need
				 * for a fresh compilation of every bytecode.
				 */
				if (*TCommand)(unsafe.Pointer((*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData)).FcompileProc != libc.UintptrFromInt32(0) {
					(*TNamespace)(unsafe.Pointer(nsPtr)).FresolverEpoch++
				}
			}
		}
		/*
		 * Insert nsPtr at the front of the trail list: i.e., at the end of
		 * the trailPtr array.
		 */
		trailFront++
		if trailFront == trailSize {
			newSize = int32(2) * trailSize
			trailPtr = XTclStackRealloc(tls, interp, trailPtr, libc.Uint64FromInt32(newSize)*uint64(8))
			trailSize = newSize
		}
		*(*uintptr)(unsafe.Pointer(trailPtr + uintptr(trailFront)*8)) = nsPtr
		goto _2
	_2:
		;
		nsPtr = (*TNamespace)(unsafe.Pointer(nsPtr)).FparentPtr
	}
	XTclStackFree(tls, interp, trailPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * TclGetNamespaceFromObj, GetNamespaceFromObj --
 *
 *	Gets the namespace specified by the name in a Tcl_Obj.
 *
 * Results:
 *	Returns TCL_OK if the namespace was resolved successfully, and stores
 *	a pointer to the namespace in the location specified by nsPtrPtr. If
 *	the namespace can't be found, or anything else goes wrong, this
 *	function returns TCL_ERROR and writes an error message to interp,
 *	if non-NULL.
 *
 * Side effects:
 *	May update the internal representation for the object, caching the
 *	namespace reference. The next time this function is called, the
 *	namespace value can be found quickly.
 *
 *----------------------------------------------------------------------
 */

func XTclGetNamespaceFromObj(tls *libc.TLS, interp uintptr, objPtr uintptr, nsPtrPtr uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Result namespace pointer goes here. */
	var name, v1 uintptr
	_, _ = name, v1
	if _GetNamespaceFromObj(tls, interp, objPtr, nsPtrPtr) == int32(TCL_ERROR) {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
		}
		name = v1
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32(':') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name + 1))) == int32(':') {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+54226, libc.VaList(bp+8, name)))
		} else {
			/*
			 * Get the current namespace name.
			 */
			_NamespaceCurrentCmd(tls, libc.UintptrFromInt32(0), interp, int32(1), libc.UintptrFromInt32(0))
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+54251, libc.VaList(bp+8, name, XTcl_GetStringFromObj(tls, XTcl_GetObjResult(tls, interp), libc.UintptrFromInt32(0)))))
		}
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+10127, name, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

func _GetNamespaceFromObj(tls *libc.TLS, interp uintptr, objPtr uintptr, nsPtrPtr uintptr) (r int32) {
	/* Result namespace pointer goes here. */
	var irPtr, irPtr1, nsPtr, refNsPtr, resNamePtr, v1, v2, v3, v4 uintptr
	_, _, _, _, _, _, _, _, _ = irPtr, irPtr1, nsPtr, refNsPtr, resNamePtr, v1, v2, v3, v4
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_nsNameType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	resNamePtr = v2
	if resNamePtr != 0 {
		/*
		 * Check that the ResolvedNsName is still valid; avoid letting the ref
		 * cross interps.
		 */
		nsPtr = (*TResolvedNsName)(unsafe.Pointer(resNamePtr)).FnsPtr
		refNsPtr = (*TResolvedNsName)(unsafe.Pointer(resNamePtr)).FrefNsPtr
		if !((*TNamespace)(unsafe.Pointer(nsPtr)).Fflags&libc.Int32FromInt32(NS_DYING) != 0) && interp == (*TNamespace)(unsafe.Pointer(nsPtr)).Finterp && (!(refNsPtr != 0) || refNsPtr == (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FnsPtr) {
			*(*uintptr)(unsafe.Pointer(nsPtrPtr)) = nsPtr
			return TCL_OK
		}
		XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&_nsNameType)), libc.UintptrFromInt32(0))
	}
	if _SetNsNameFromAny(tls, interp, objPtr) == TCL_OK {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_nsNameType)) {
			v3 = objPtr + 32
		} else {
			v3 = libc.UintptrFromInt32(0)
		}
		irPtr1 = v3
		if irPtr1 != 0 {
			v4 = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(irPtr1))).Fptr1
		} else {
			v4 = libc.UintptrFromInt32(0)
		}
		resNamePtr = v4
		*(*uintptr)(unsafe.Pointer(nsPtrPtr)) = (*TResolvedNsName)(unsafe.Pointer(resNamePtr)).FnsPtr
		return TCL_OK
	}
	return int32(TCL_ERROR)
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * TclNewNamespaceObj --
//	 *
//	 *	Gets an object that contains a reference to a given namespace.
//	 *
//	 *	Note that this gets the name of the namespace immediately; this means
//	 *	that the name is guaranteed to persist even if the namespace is
//	 *	deleted. (This is checked by test namespace-7.1.)
//	 *
//	 * Results:
//	 *	Returns a newly-allocated Tcl_Obj.
//	 *
//	 * Side effects:
//	 *	None.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func XTclNewNamespaceObj(tls *libc.TLS, namespacePtr uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var cachePtr, nsPtr, objPtr, resNamePtr, v2 uintptr
	var len1 TTcl_Size
	var v1 bool
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_, _, _, _, _, _, _ = cachePtr, len1, nsPtr, objPtr, resNamePtr, v1, v2
	nsPtr = namespacePtr
	/*
	 * If NS_DEAD set, we have no name any more; the fullName field may have
	 * been deallocated.
	 */
	/*
	 * Need to get the name pro-actively; the name must persist after the
	 * namespace is deleted. This is the easiest way.
	 */
	len1 = libc.Int64FromUint64(libc.Xstrlen(tls, (*TNamespace)(unsafe.Pointer(nsPtr)).FfullName))
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	if len1 == 0 {
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(len1+libc.Int64FromUint32(1)))
		if (*TNamespace)(unsafe.Pointer(nsPtr)).FfullName != 0 {
			v2 = (*TNamespace)(unsafe.Pointer(nsPtr)).FfullName
		} else {
			v2 = uintptr(unsafe.Pointer(&XtclEmptyString))
		}
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, v2, libc.Uint64FromInt64(len1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr(len1))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = len1
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	/*
	 * But we know exactly which namespace this resolves to. Remember that
	 * unless things are already being taken apart.
	 */
	if !((*TNamespace)(unsafe.Pointer(nsPtr)).Fflags&(libc.Int32FromInt32(NS_DYING)|libc.Int32FromInt32(NS_TEARDOWN)) != 0) {
		resNamePtr = XTcl_Alloc(tls, uint64(24))
		(*TResolvedNsName)(unsafe.Pointer(resNamePtr)).FnsPtr = nsPtr
		(*TResolvedNsName)(unsafe.Pointer(resNamePtr)).FrefNsPtr = libc.UintptrFromInt32(0)
		(*TResolvedNsName)(unsafe.Pointer(resNamePtr)).FrefCount = uint64(0)
		(*TNamespace)(unsafe.Pointer(nsPtr)).FrefCount++
		(*TResolvedNsName)(unsafe.Pointer(resNamePtr)).FrefCount++
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(bp))).Fptr1 = resNamePtr
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(bp))).Fptr2 = libc.UintptrFromInt32(0)
		XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&_nsNameType)), bp)
	}
	return objPtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclInitNamespaceCmd --
 *
 *	This function is called to create the "namespace" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	Handle for the namespace command, or NULL on failure.
 *
 * Side effects:
 *	none
 *
 *----------------------------------------------------------------------
 */

func XTclInitNamespaceCmd(tls *libc.TLS, interp uintptr) (r TTcl_Command) {
	/* Current interpreter. */
	return XTclMakeEnsemble(tls, interp, __ccgo_ts+21846, uintptr(unsafe.Pointer(&_defaultNamespaceMap)))
}

/*
 *----------------------------------------------------------------------
 *
 * NamespaceChildrenCmd --
 *
 *	Invoked to implement the "namespace children" command that returns a
 *	list containing the fully-qualified names of the child namespaces of a
 *	given namespace. Handles the following syntax:
 *
 *	    namespace children ?name? ?pattern?
 *
 * Results:
 *	Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If anything goes
 *	wrong, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func _NamespaceChildrenCmd(tls *libc.TLS, dummy3133 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(256)
	defer tls.Free(256) /* Argument objects. */
	var childNsPtr, entryPtr, globalNsPtr, listPtr, name, nsPtr, pattern, v1 uintptr
	var length Tsize_t
	var v2 int32
	var _ /* buffer at bp+8 */ TTcl_DString
	var _ /* namespacePtr at bp+0 */ uintptr
	var _ /* search at bp+232 */ TTcl_HashSearch
	_, _, _, _, _, _, _, _, _, _ = childNsPtr, entryPtr, globalNsPtr, length, listPtr, name, nsPtr, pattern, v1, v2
	globalNsPtr = (*TInterp)(unsafe.Pointer(interp)).FglobalNsPtr
	pattern = libc.UintptrFromInt32(0)
	/*
	 * Get a pointer to the specified namespace, or the current namespace.
	 */
	if objc == int32(1) {
		nsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FnsPtr
	} else {
		if objc == int32(2) || objc == int32(3) {
			if XTclGetNamespaceFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp) != TCL_OK {
				return int32(TCL_ERROR)
			}
			nsPtr = *(*uintptr)(unsafe.Pointer(bp))
		} else {
			XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+54284)
			return int32(TCL_ERROR)
		}
	}
	/*
	 * Get the glob-style pattern, if any, used to narrow the search.
	 */
	XTcl_DStringInit(tls, bp+8)
	if objc == int32(3) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		name = v1
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32(':') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name + 1))) == int32(':') {
			pattern = name
		} else {
			XTcl_DStringAppend(tls, bp+8, (*TNamespace)(unsafe.Pointer(nsPtr)).FfullName, int64(-int32(1)))
			if nsPtr != globalNsPtr {
				XTcl_DStringAppend(tls, bp+8, __ccgo_ts+7650, libc.Int64FromUint64(libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)))
			}
			XTcl_DStringAppend(tls, bp+8, name, int64(-int32(1)))
			pattern = (*TTcl_DString)(unsafe.Pointer(bp + 8)).Fstring1
		}
	}
	/*
	 * Create a list containing the full names of all child namespaces whose
	 * names match the specified pattern, if any.
	 */
	listPtr = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
	if pattern != libc.UintptrFromInt32(0) && libc.Xstrpbrk(tls, pattern, __ccgo_ts+16411) == libc.UintptrFromInt32(0) {
		length = libc.Xstrlen(tls, (*TNamespace)(unsafe.Pointer(nsPtr)).FfullName)
		if libc.Xstrncmp(tls, pattern, (*TNamespace)(unsafe.Pointer(nsPtr)).FfullName, length) != 0 {
			goto searchDone
		}
		/*
		 * Global namespace members are prefixed with "::", others not. Ticket [63449c0514]
		 */
		if nsPtr != globalNsPtr {
			v2 = int32(2)
		} else {
			v2 = 0
		}
		if _FindChildEntry(tls, nsPtr, uintptr(v2)+pattern+uintptr(length)) != libc.UintptrFromInt32(0) {
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listPtr, XTcl_NewStringObj(tls, pattern, int64(-int32(1))))
		}
		goto searchDone
	}
	entryPtr = _FirstChildEntry(tls, nsPtr, bp+232)
	for entryPtr != libc.UintptrFromInt32(0) {
		childNsPtr = (*TTcl_HashEntry)(unsafe.Pointer(entryPtr)).FclientData
		if pattern == libc.UintptrFromInt32(0) || XTcl_StringCaseMatch(tls, (*TNamespace)(unsafe.Pointer(childNsPtr)).FfullName, pattern, 0) != 0 {
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listPtr, XTclNewNamespaceObj(tls, childNsPtr))
		}
		entryPtr = XTcl_NextHashEntry(tls, bp+232)
	}
	goto searchDone
searchDone:
	;
	XTcl_SetObjResult(tls, interp, listPtr)
	XTcl_DStringFree(tls, bp+8)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * NamespaceCodeCmd --
 *
 *	Invoked to implement the "namespace code" command to capture the
 *	namespace context of a command. Handles the following syntax:
 *
 *	    namespace code arg
 *
 *	Here "arg" can be a list. "namespace code arg" produces a result
 *	equivalent to that produced by the command
 *
 *	    list ::namespace inscope [namespace current] $arg
 *
 *	However, if "arg" is itself a scoped value starting with "::namespace
 *	inscope", then the result is just "arg".
 *
 * Results:
 *	Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
 *
 * Side effects:
 *	If anything goes wrong, this function returns an error message as the
 *	result in the interpreter's result object.
 *
 *----------------------------------------------------------------------
 */

func _NamespaceCodeCmd(tls *libc.TLS, dummy3251 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var arg, cachePtr, cachePtr1, cachePtr2, listPtr, objPtr, v1 uintptr
	var v2, v3, v4 bool
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _ = arg, cachePtr, cachePtr1, cachePtr2, listPtr, objPtr, v1, v2, v3, v4
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+28196)
		return int32(TCL_ERROR)
	}
	/*
	   * If "arg" is already a scoped value, then return it directly.
	   * Take care to only check for scoping in precisely the style that
	   * [::namespace code] generates it.  Anything more forgiving can have
	   * the effect of failing in namespaces that contain their own custom
	   " "namespace" command.  [Bug 3202171].
	*/
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
	}
	arg = v1
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(arg))) == int32(':') && *(*TTcl_Size)(unsafe.Pointer(bp)) > int64(20) && libc.Xstrncmp(tls, arg, __ccgo_ts+21788, uint64(20)) == 0 {
		XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
		return TCL_OK
	}
	/*
	 * Otherwise, construct a scoped command by building a list with
	 * "namespace inscope", the full name of the current namespace, and the
	 * argument "arg". By constructing a list, we ensure that scoped commands
	 * are interpreted properly when they are executed later, by the
	 * "namespace inscope" command.
	 */
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		listPtr = XTclThreadAllocObj(tls)
	} else {
		listPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(listPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(listPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(listPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(listPtr)).FtypePtr = libc.UintptrFromInt32(0)
	if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	if libc.Uint64FromInt64(12)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(12)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, __ccgo_ts+21809, libc.Uint64FromInt64(12)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr(libc.Uint64FromInt64(12)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(12) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listPtr, objPtr)
	if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
		cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	if libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, __ccgo_ts+21821, libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr(libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(8) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listPtr, objPtr)
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listPtr, XTclNewNamespaceObj(tls, (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FnsPtr))
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listPtr, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	XTcl_SetObjResult(tls, interp, listPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * NamespaceCurrentCmd --
 *
 *	Invoked to implement the "namespace current" command which returns the
 *	fully-qualified name of the current namespace. Handles the following
 *	syntax:
 *
 *	    namespace current
 *
 * Results:
 *	Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If anything goes
 *	wrong, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func _NamespaceCurrentCmd(tls *libc.TLS, dummy3326 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	if objc != int32(1) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, libc.UintptrFromInt32(0))
		return int32(TCL_ERROR)
	}
	/*
	 * The "real" name of the global namespace ("::") is the null string, but
	 * we return "::" for it as a convenience to programmers. Note that "" and
	 * "::" are treated as synonyms by the namespace code so that it is still
	 * easy to do things like:
	 *
	 *    namespace [namespace current]::bar { ... }
	 *
	 * This behavior is encoded into TclNewNamespaceObj().
	 */
	XTcl_SetObjResult(tls, interp, XTclNewNamespaceObj(tls, (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FnsPtr))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * NamespaceDeleteCmd --
 *
 *	Invoked to implement the "namespace delete" command to delete
 *	namespace(s). Handles the following syntax:
 *
 *	    namespace delete ?name name...?
 *
 *	Each name identifies a namespace. It may include a sequence of
 *	namespace qualifiers separated by "::"s. If a namespace is found, it
 *	is deleted: all variables and procedures contained in that namespace
 *	are deleted. If that namespace is being used on the call stack, it is
 *	kept alive (but logically deleted) until it is removed from the call
 *	stack: that is, it can no longer be referenced by name but any
 *	currently executing procedure that refers to it is allowed to do so
 *	until the procedure returns. If the namespace can't be found, this
 *	function returns an error. If no namespaces are specified, this
 *	command does nothing.
 *
 * Results:
 *	Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
 *
 * Side effects:
 *	Deletes the specified namespaces. If anything goes wrong, this
 *	function returns an error message in the interpreter's result object.
 *
 *----------------------------------------------------------------------
 */

func _NamespaceDeleteCmd(tls *libc.TLS, dummy3385 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument objects. */
	var i int32
	var name, namespacePtr, v2, v3, v4, v6 uintptr
	_, _, _, _, _, _, _ = i, name, namespacePtr, v2, v3, v4, v6
	if objc < int32(1) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+54301)
		return int32(TCL_ERROR)
	}
	/*
	 * Destroying one namespace may cause another to be destroyed. Break this
	 * into two passes: first check to make sure that all namespaces on the
	 * command line are valid, and report any errors.
	 */
	i = int32(1)
	for {
		if !(i < objc) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		name = v2
		namespacePtr = XTcl_FindNamespace(tls, interp, name, libc.UintptrFromInt32(0), 0)
		if namespacePtr == libc.UintptrFromInt32(0) || (*TNamespace)(unsafe.Pointer(namespacePtr)).Fflags&int32(NS_TEARDOWN) != 0 {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
				v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
			} else {
				v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+54316, libc.VaList(bp+8, v3)))
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
				v4 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
			} else {
				v4 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
			}
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+10127, v4, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		goto _1
	_1:
		;
		i++
	}
	/*
	 * Okay, now delete each namespace.
	 */
	i = int32(1)
	for {
		if !(i < objc) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
			v6 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
		} else {
			v6 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		name = v6
		namespacePtr = XTcl_FindNamespace(tls, interp, name, libc.UintptrFromInt32(0), 0)
		if namespacePtr != 0 {
			XTcl_DeleteNamespace(tls, namespacePtr)
		}
		goto _5
	_5:
		;
		i++
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * NamespaceEvalCmd --
 *
 *	Invoked to implement the "namespace eval" command. Executes commands
 *	in a namespace. If the namespace does not already exist, it is
 *	created. Handles the following syntax:
 *
 *	    namespace eval name arg ?arg...?
 *
 *	If more than one arg argument is specified, the command that is
 *	executed is the result of concatenating the arguments together with a
 *	space between each argument.
 *
 * Results:
 *	Returns TCL_OK if the namespace is found and the commands are executed
 *	successfully. Returns TCL_ERROR if anything goes wrong.
 *
 * Side effects:
 *	Returns the result of the command in the interpreter's result object.
 *	If anything goes wrong, this function returns an error message as the
 *	result.
 *
 *----------------------------------------------------------------------
 */

func _NamespaceEvalCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	return XTcl_NRCallObjProc(tls, interp, __ccgo_fp(_NRNamespaceEvalCmd), clientData, int64(objc), objv)
}

func _NRNamespaceEvalCmd(tls *libc.TLS, dummy3473 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument objects. */
	var _objPtr, cachePtr, framePtrPtr, iPtr, name, objPtr, v1 uintptr
	var result int32
	var v2 bool
	var _ /* _callbackPtr at bp+32 */ uintptr
	var _ /* framePtr at bp+24 */ uintptr
	var _ /* invoker at bp+0 */ uintptr
	var _ /* namespacePtr at bp+16 */ uintptr
	var _ /* word at bp+8 */ int32
	_, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, framePtrPtr, iPtr, name, objPtr, result, v1, v2
	iPtr = interp
	if objc < int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+54367)
		return int32(TCL_ERROR)
	}
	/*
	 * Try to resolve the namespace reference, caching the result in the
	 * namespace object along the way.
	 */
	result = _GetNamespaceFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+16)
	/*
	 * If the namespace wasn't found, try to create it.
	 */
	if result == int32(TCL_ERROR) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
		}
		name = v1
		*(*uintptr)(unsafe.Pointer(bp + 16)) = XTcl_CreateNamespace(tls, interp, name, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
		if *(*uintptr)(unsafe.Pointer(bp + 16)) == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
	}
	/*
	 * Make the specified namespace the current namespace and evaluate the
	 * command(s).
	 */
	/* This is needed to satisfy GCC 3.3's strict aliasing rules */
	framePtrPtr = bp + 24
	XTclPushStackFrame(tls, interp, framePtrPtr, *(*uintptr)(unsafe.Pointer(bp + 16)), 0)
	(*TCallFrame)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Fobjv = XTclFetchEnsembleRoot(tls, interp, objv, int64(objc), *(*uintptr)(unsafe.Pointer(bp + 24))+16)
	if objc == int32(3) {
		/*
		 * TIP #280: Make actual argument location available to eval'd script.
		 */
		objPtr = *(*uintptr)(unsafe.Pointer(objv + 2*8))
		*(*uintptr)(unsafe.Pointer(bp)) = (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr
		*(*int32)(unsafe.Pointer(bp + 8)) = int32(3)
		XTclArgumentGet(tls, interp, objPtr, bp, bp+8)
	} else {
		/*
		 * More than one argument: concatenate them together with spaces
		 * between, then evaluate the result. Tcl_EvalObjEx will delete the
		 * object when it decrements its refcount after eval'ing it.
		 */
		objPtr = XTcl_ConcatObj(tls, int64(objc-int32(2)), objv+uintptr(2)*8)
		*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
		*(*int32)(unsafe.Pointer(bp + 8)) = 0
	}
	/*
	 * TIP #280: Make invoking context available to eval'd script.
	 */
	if v2 = interp == libc.UintptrFromInt32(0); !v2 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 32)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))).FprocPtr = __ccgo_fp(_NsEval_Callback)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)) + 8)) = *(*uintptr)(unsafe.Pointer(bp + 16))
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)) + 8 + 1*8)) = __ccgo_ts + 2464
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 32))
	return XTclNREvalObjEx(tls, interp, objPtr, 0, *(*uintptr)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 8)))
}

func _NsEval_Callback(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var cmd, namespacePtr, v2 uintptr
	var length Tsize_t
	var limit, v1 uint32
	var overflow int32
	_, _, _, _, _, _, _ = cmd, length, limit, namespacePtr, overflow, v1, v2
	namespacePtr = *(*uintptr)(unsafe.Pointer(data))
	if result == int32(TCL_ERROR) {
		length = libc.Xstrlen(tls, (*TTcl_Namespace)(unsafe.Pointer(namespacePtr)).FfullName)
		limit = uint32(200)
		overflow = libc.BoolInt32(length > uint64(limit))
		cmd = *(*uintptr)(unsafe.Pointer(data + 1*8))
		if overflow != 0 {
			v1 = limit
		} else {
			v1 = uint32(length)
		}
		if overflow != 0 {
			v2 = __ccgo_ts + 8560
		} else {
			v2 = __ccgo_ts + 1945
		}
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+54385, libc.VaList(bp+8, cmd, v1, (*TTcl_Namespace)(unsafe.Pointer(namespacePtr)).FfullName, v2, XTcl_GetErrorLine(tls, interp))))
	}
	/*
	 * Restore the previous "current" namespace.
	 */
	XTclPopStackFrame(tls, interp)
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * NamespaceExistsCmd --
 *
 *	Invoked to implement the "namespace exists" command that returns true
 *	if the given namespace currently exists, and false otherwise. Handles
 *	the following syntax:
 *
 *	    namespace exists name
 *
 * Results:
 *	Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If anything goes
 *	wrong, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func _NamespaceExistsCmd(tls *libc.TLS, dummy3605 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var _ /* namespacePtr at bp+0 */ uintptr
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+3726)
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(libc.BoolInt32(_GetNamespaceFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp) == TCL_OK) != 0)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * NamespaceExportCmd --
 *
 *	Invoked to implement the "namespace export" command that specifies
 *	which commands are exported from a namespace. The exported commands
 *	are those that can be imported into another namespace using "namespace
 *	import". Both commands defined in a namespace and commands the
 *	namespace has imported can be exported by a namespace. This command
 *	has the following syntax:
 *
 *	    namespace export ?-clear? ?pattern pattern...?
 *
 *	Each pattern may contain "string match"-style pattern matching special
 *	characters, but the pattern may not include any namespace qualifiers:
 *	that is, the pattern must specify commands in the current (exporting)
 *	namespace. The specified patterns are appended onto the namespace's
 *	list of export patterns.
 *
 *	To reset the namespace's export pattern list, specify the "-clear"
 *	flag.
 *
 *	If there are no export patterns and the "-clear" flag isn't given,
 *	this command returns the namespace's current export list.
 *
 * Results:
 *	Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If anything goes
 *	wrong, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func _NamespaceExportCmd(tls *libc.TLS, dummy3660 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var cachePtr, listPtr, v2, v4 uintptr
	var firstArg, i, result int32
	var v1 bool
	_, _, _, _, _, _, _, _ = cachePtr, firstArg, i, listPtr, result, v1, v2, v4
	if objc < int32(1) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+54432)
		return int32(TCL_ERROR)
	}
	/*
	 * If no pattern arguments are given, and "-clear" isn't specified, return
	 * the namespace's current export pattern list.
	 */
	if objc == int32(1) {
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			listPtr = XTclThreadAllocObj(tls)
		} else {
			listPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(listPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(listPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(listPtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(listPtr)).FtypePtr = libc.UintptrFromInt32(0)
		XTcl_AppendExportList(tls, interp, libc.UintptrFromInt32(0), listPtr)
		XTcl_SetObjResult(tls, interp, listPtr)
		return TCL_OK
	}
	/*
	 * Process the optional "-clear" argument.
	 */
	firstArg = int32(1)
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(firstArg)*8)))).Fbytes != 0 {
		v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(firstArg)*8)))).Fbytes
	} else {
		v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(firstArg)*8)), libc.UintptrFromInt32(0))
	}
	if libc.Xstrcmp(tls, __ccgo_ts+12698, v2) == 0 {
		XTcl_Export(tls, interp, libc.UintptrFromInt32(0), __ccgo_ts+7650, int32(1))
		XTcl_ResetResult(tls, interp)
		firstArg++
	}
	/*
	 * Add each pattern to the namespace's export pattern list.
	 */
	i = firstArg
	for {
		if !(i < objc) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
			v4 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
		} else {
			v4 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		result = XTcl_Export(tls, interp, libc.UintptrFromInt32(0), v4, 0)
		if result != TCL_OK {
			return result
		}
		goto _3
	_3:
		;
		i++
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * NamespaceForgetCmd --
 *
 *	Invoked to implement the "namespace forget" command to remove imported
 *	commands from a namespace. Handles the following syntax:
 *
 *	    namespace forget ?pattern pattern...?
 *
 *	Each pattern is a name like "foo::*" or "a::b::x*". That is, the
 *	pattern may include the special pattern matching characters recognized
 *	by the "string match" command, but only in the command name at the end
 *	of the qualified name; the special pattern characters may not appear
 *	in a namespace name. All of the commands that match that pattern are
 *	checked to see if they have an imported command in the current
 *	namespace that refers to the matched command. If there is an alias, it
 *	is removed.
 *
 * Results:
 *	Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
 *
 * Side effects:
 *	Imported commands are removed from the current namespace. If anything
 *	goes wrong, this function returns an error message in the
 *	interpreter's result object.
 *
 *----------------------------------------------------------------------
 */

func _NamespaceForgetCmd(tls *libc.TLS, dummy3742 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var i, result int32
	var pattern, v2 uintptr
	_, _, _, _ = i, pattern, result, v2
	if objc < int32(1) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+54462)
		return int32(TCL_ERROR)
	}
	i = int32(1)
	for {
		if !(i < objc) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		pattern = v2
		result = XTcl_ForgetImport(tls, interp, libc.UintptrFromInt32(0), pattern)
		if result != TCL_OK {
			return result
		}
		goto _1
	_1:
		;
		i++
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * NamespaceImportCmd --
 *
 *	Invoked to implement the "namespace import" command that imports
 *	commands into a namespace. Handles the following syntax:
 *
 *	    namespace import ?-force? ?pattern pattern...?
 *
 *	Each pattern is a namespace-qualified name like "foo::*", "a::b::x*",
 *	or "bar::p". That is, the pattern may include the special pattern
 *	matching characters recognized by the "string match" command, but only
 *	in the command name at the end of the qualified name; the special
 *	pattern characters may not appear in a namespace name. All of the
 *	commands that match the pattern and which are exported from their
 *	namespace are made accessible from the current namespace context. This
 *	is done by creating a new "imported command" in the current namespace
 *	that points to the real command in its original namespace; when the
 *	imported command is called, it invokes the real command.
 *
 *	If an imported command conflicts with an existing command, it is
 *	treated as an error. But if the "-force" option is included, then
 *	existing commands are overwritten by the imported commands.
 *
 *	If there are no pattern arguments and the "-force" flag isn't given,
 *	this command returns the list of commands currently imported in
 *	the current namespace.
 *
 * Results:
 *	Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
 *
 * Side effects:
 *	Adds imported commands to the current namespace. If anything goes
 *	wrong, this function returns an error message in the interpreter's
 *	result object.
 *
 *----------------------------------------------------------------------
 */

func _NamespaceImportCmd(tls *libc.TLS, dummy3807 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Argument objects. */
	var allowOverwrite, firstArg, i, result int32
	var cachePtr, cmdPtr, hPtr, listPtr, nsPtr, pattern, string1, v1, v4, v6 uintptr
	var v2 bool
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = allowOverwrite, cachePtr, cmdPtr, firstArg, hPtr, i, listPtr, nsPtr, pattern, result, string1, v1, v2, v4, v6
	allowOverwrite = 0
	if objc < int32(1) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+54483)
		return int32(TCL_ERROR)
	}
	/*
	 * Skip over the optional "-force" as the first argument.
	 */
	firstArg = int32(1)
	if firstArg < objc {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(firstArg)*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(firstArg)*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(firstArg)*8)), libc.UintptrFromInt32(0))
		}
		string1 = v1
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1))) == int32('-') && libc.Xstrcmp(tls, string1, __ccgo_ts+34096) == 0 {
			allowOverwrite = int32(1)
			firstArg++
		}
	} else {
		nsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FnsPtr
		if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			listPtr = XTclThreadAllocObj(tls)
		} else {
			listPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(listPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(listPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(listPtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(listPtr)).FtypePtr = libc.UintptrFromInt32(0)
		hPtr = XTcl_FirstHashEntry(tls, nsPtr+184, bp)
		for {
			if !(hPtr != libc.UintptrFromInt32(0)) {
				break
			}
			cmdPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
			if (*TCommand)(unsafe.Pointer(cmdPtr)).FdeleteProc == __ccgo_fp(_DeleteImportedCmd) {
				if (*TTcl_HashTable)(unsafe.Pointer(nsPtr+184)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(nsPtr+184)).FkeyType == -int32(1) {
					v4 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
				} else {
					v4 = hPtr + 32
				}
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listPtr, XTcl_NewStringObj(tls, v4, int64(-int32(1))))
			}
			goto _3
		_3:
			;
			hPtr = XTcl_NextHashEntry(tls, bp)
		}
		XTcl_SetObjResult(tls, interp, listPtr)
		return TCL_OK
	}
	/*
	 * Handle the imports for each of the patterns.
	 */
	i = firstArg
	for {
		if !(i < objc) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
			v6 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
		} else {
			v6 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		pattern = v6
		result = XTcl_Import(tls, interp, libc.UintptrFromInt32(0), pattern, allowOverwrite)
		if result != TCL_OK {
			return result
		}
		goto _5
	_5:
		;
		i++
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * NamespaceInscopeCmd --
 *
 *	Invoked to implement the "namespace inscope" command that executes a
 *	script in the context of a particular namespace. This command is not
 *	expected to be used directly by programmers; calls to it are generated
 *	implicitly when programs use "namespace code" commands to register
 *	callback scripts. Handles the following syntax:
 *
 *	    namespace inscope name arg ?arg...?
 *
 *	The "namespace inscope" command is much like the "namespace eval"
 *	command except that it has lappend semantics and the namespace must
 *	already exist. It treats the first argument as a list, and appends any
 *	arguments after the first onto the end as proper list elements. For
 *	example,
 *
 *	    namespace inscope ::foo {a b} c d e
 *
 *	is equivalent to
 *
 *	    namespace eval ::foo [concat {a b} [list c d e]]
 *
 *	This lappend semantics is important because many callback scripts are
 *	actually prefixes.
 *
 * Results:
 *	Returns TCL_OK to indicate success, or TCL_ERROR to indicate failure.
 *
 * Side effects:
 *	Returns a result in the Tcl interpreter's result object.
 *
 *----------------------------------------------------------------------
 */

func _NamespaceInscopeCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	return XTcl_NRCallObjProc(tls, interp, __ccgo_fp(_NRNamespaceInscopeCmd), clientData, int64(objc), objv)
}

func _NRNamespaceInscopeCmd(tls *libc.TLS, dummy3922 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument objects. */
	var _objPtr, _objPtr1, cachePtr, cmdObjPtr, framePtrPtr, v2 uintptr
	var v1 TTcl_Size
	var v3 bool
	var _ /* _callbackPtr at bp+32 */ uintptr
	var _ /* concatObjv at bp+16 */ [2]uintptr
	var _ /* framePtr at bp+8 */ uintptr
	var _ /* namespacePtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, cmdObjPtr, framePtrPtr, v1, v2, v3
	if objc < int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+54367)
		return int32(TCL_ERROR)
	}
	/*
	 * Resolve the namespace reference.
	 */
	if XTclGetNamespaceFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Make the specified namespace the current namespace.
	 */
	framePtrPtr = bp + 8 /* This is needed to satisfy GCC's
	 * strict aliasing rules. */
	XTclPushStackFrame(tls, interp, framePtrPtr, *(*uintptr)(unsafe.Pointer(bp)), 0)
	(*TCallFrame)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fobjv = XTclFetchEnsembleRoot(tls, interp, objv, int64(objc), *(*uintptr)(unsafe.Pointer(bp + 8))+16)
	/*
	 * Execute the command. If there is just one argument, just treat it as a
	 * script and evaluate it. Otherwise, create a list from the arguments
	 * after the first one, then concatenate the first argument and the list
	 * of extra arguments to form the command to evaluate.
	 */
	if objc == int32(3) {
		cmdObjPtr = *(*uintptr)(unsafe.Pointer(objv + 2*8))
	} else {
		(*(*[2]uintptr)(unsafe.Pointer(bp + 16)))[0] = *(*uintptr)(unsafe.Pointer(objv + 2*8))
		(*(*[2]uintptr)(unsafe.Pointer(bp + 16)))[int32(1)] = XTcl_NewListObj(tls, int64(objc-int32(3)), objv+uintptr(3)*8)
		cmdObjPtr = XTcl_ConcatObj(tls, int64(2), bp+16)
		_objPtr = (*(*[2]uintptr)(unsafe.Pointer(bp + 16)))[int32(1)]
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		} /* We're done with the list object. */
	}
	if v3 = interp == libc.UintptrFromInt32(0); !v3 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr1 = XTclThreadAllocObj(tls)
	} else {
		_objPtr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr1 + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 32)) = _objPtr1
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))).FprocPtr = __ccgo_fp(_NsEval_Callback)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)) + 8)) = *(*uintptr)(unsafe.Pointer(bp))
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)) + 8 + 1*8)) = __ccgo_ts + 21821
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 32))
	return XTclNREvalObjEx(tls, interp, cmdObjPtr, 0, libc.UintptrFromInt32(0), 0)
}

/*
 *----------------------------------------------------------------------
 *
 * NamespaceOriginCmd --
 *
 *	Invoked to implement the "namespace origin" command to return the
 *	fully-qualified name of the "real" command to which the specified
 *	"imported command" refers. Handles the following syntax:
 *
 *	    namespace origin name
 *
 * Results:
 *	An imported command is created in an namespace when that namespace
 *	imports a command from another namespace. If a command is imported
 *	into a sequence of namespaces a, b,...,n where each successive
 *	namespace just imports the command from the previous namespace, this
 *	command returns the fully-qualified name of the original command in
 *	the first namespace, a. If "name" does not refer to an alias, its
 *	fully-qualified name is returned. The returned name is stored in the
 *	interpreter's result object. This function returns TCL_OK if
 *	successful, and TCL_ERROR if anything goes wrong.
 *
 * Side effects:
 *	If anything goes wrong, this function returns an error message in the
 *	interpreter's result object.
 *
 *----------------------------------------------------------------------
 */

func _NamespaceOriginCmd(tls *libc.TLS, dummy4009 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument objects. */
	var _objPtr, cachePtr, resultPtr, v3, v4, v5 uintptr
	var cmd, origCmd TTcl_Command
	var v1 bool
	var v2 TTcl_Size
	_, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, cmd, origCmd, resultPtr, v1, v2, v3, v4, v5
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+3726)
		return int32(TCL_ERROR)
	}
	cmd = XTcl_GetCommandFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if cmd == libc.UintptrFromInt32(0) {
		goto namespaceOriginError
	}
	origCmd = XTclGetOriginalCommand(tls, cmd)
	if origCmd == libc.UintptrFromInt32(0) {
		origCmd = cmd
	}
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultPtr = XTclThreadAllocObj(tls)
	} else {
		resultPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FtypePtr = libc.UintptrFromInt32(0)
	XTcl_GetCommandFullName(tls, interp, origCmd, resultPtr)
	if XTclCheckEmptyString(tls, resultPtr) == int32(TCL_EMPTYSTRING_YES) {
		_objPtr = resultPtr
		v3 = _objPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		goto namespaceOriginError
	}
	XTcl_SetObjResult(tls, interp, resultPtr)
	return TCL_OK
	goto namespaceOriginError
namespaceOriginError:
	;
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v4 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v4 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+8511, libc.VaList(bp+8, v4)))
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v5 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v5 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+8118, v5, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * NamespaceParentCmd --
 *
 *	Invoked to implement the "namespace parent" command that returns the
 *	fully-qualified name of the parent namespace for a specified
 *	namespace. Handles the following syntax:
 *
 *	    namespace parent ?name?
 *
 * Results:
 *	Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If anything goes
 *	wrong, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func _NamespaceParentCmd(tls *libc.TLS, dummy4070 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var _ /* nsPtr at bp+0 */ uintptr
	if objc == int32(1) {
		*(*uintptr)(unsafe.Pointer(bp)) = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FnsPtr
	} else {
		if objc == int32(2) {
			if XTclGetNamespaceFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp) != TCL_OK {
				return int32(TCL_ERROR)
			}
		} else {
			XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+15589)
			return int32(TCL_ERROR)
		}
	}
	/*
	 * Report the parent of the specified namespace.
	 */
	if (*TTcl_Namespace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FparentPtr != libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTclNewNamespaceObj(tls, (*TTcl_Namespace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FparentPtr))
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * NamespacePathCmd --
 *
 *	Invoked to implement the "namespace path" command that reads and
 *	writes the current namespace's command resolution path. Has one
 *	optional argument: if present, it is a list of named namespaces to set
 *	the path to, and if absent, the current path should be returned.
 *	Handles the following syntax:
 *
 *	    namespace path ?nsList?
 *
 * Results:
 *	Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong
 *	(most notably if the namespace list contains the name of something
 *	other than a namespace). In the successful-exit case, may set the
 *	interpreter result to the list of names of the namespaces on the
 *	current namespace's path.
 *
 * Side effects:
 *	May update the namespace path (triggering a recomputing of all command
 *	names that depend on the namespace for resolution).
 *
 *----------------------------------------------------------------------
 */

func _NamespacePathCmd(tls *libc.TLS, dummy4127 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var cachePtr, namespaceList, nsPtr, resultObj uintptr
	var i TTcl_Size
	var result, v3 int32
	var v1 bool
	var v4, v5 int64
	var _ /* nsObjc at bp+0 */ TTcl_Size
	var _ /* nsObjv at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _ = cachePtr, i, namespaceList, nsPtr, result, resultObj, v1, v3, v4, v5
	nsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FnsPtr
	result = int32(TCL_ERROR)
	namespaceList = libc.UintptrFromInt32(0)
	if objc > int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+54513)
		return int32(TCL_ERROR)
	}
	/*
	 * If no path is given, return the current path.
	 */
	if objc == int32(1) {
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			resultObj = XTclThreadAllocObj(tls)
		} else {
			resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(resultObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
		i = 0
		for {
			if !(i < (*TNamespace)(unsafe.Pointer(nsPtr)).FcommandPathLength) {
				break
			}
			if (*(*TNamespacePathEntry)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(nsPtr)).FcommandPathArray + uintptr(i)*32))).FnsPtr != libc.UintptrFromInt32(0) {
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, XTclNewNamespaceObj(tls, (*(*TNamespacePathEntry)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(nsPtr)).FcommandPathArray + uintptr(i)*32))).FnsPtr))
			}
			goto _2
		_2:
			;
			i++
		}
		XTcl_SetObjResult(tls, interp, resultObj)
		return TCL_OK
	}
	/*
	 * There is a path given, so parse it into an array of namespace pointers.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
			v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanStart
		} else {
			v4 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1 + 40 + uintptr(v4)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
			v5 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanLength
		} else {
			v5 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v5
		v3 = libc.Int32FromInt32(TCL_OK)
	} else {
		v3 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp, bp+8)
	}
	if v3 != TCL_OK {
		goto badNamespace
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp)) != 0 {
		namespaceList = XTclStackAlloc(tls, interp, uint64(8)*libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))))
		i = 0
		for {
			if !(i < *(*TTcl_Size)(unsafe.Pointer(bp))) {
				break
			}
			if XTclGetNamespaceFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)), namespaceList+uintptr(i)*8) != TCL_OK {
				goto badNamespace
			}
			goto _6
		_6:
			;
			i++
		}
	}
	/*
	 * Now we have the list of valid namespaces, install it as the path.
	 */
	XTclSetNsPath(tls, nsPtr, *(*TTcl_Size)(unsafe.Pointer(bp)), namespaceList)
	result = TCL_OK
	goto badNamespace
badNamespace:
	;
	if namespaceList != libc.UintptrFromInt32(0) {
		XTclStackFree(tls, interp, namespaceList)
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * TclSetNsPath --
 *
 *	Sets the namespace command name resolution path to the given list of
 *	namespaces. If the list is empty (of zero length) the path is set to
 *	empty and the default old-style behaviour of command name resolution
 *	is used.
 *
 * Results:
 *	nothing
 *
 * Side effects:
 *	Invalidates the command name resolution caches for any command
 *	resolved in the given namespace.
 *
 *----------------------------------------------------------------------
 */

func XTclSetNsPath(tls *libc.TLS, nsPtr uintptr, pathLength TTcl_Size, pathAry uintptr) {
	/* Array of namespaces that are the path. */
	var i TTcl_Size
	var tmpPathArray uintptr
	_, _ = i, tmpPathArray
	if pathLength != 0 {
		tmpPathArray = XTcl_Alloc(tls, uint64(32)*libc.Uint64FromInt64(pathLength))
		i = 0
		for {
			if !(i < pathLength) {
				break
			}
			(*(*TNamespacePathEntry)(unsafe.Pointer(tmpPathArray + uintptr(i)*32))).FnsPtr = *(*uintptr)(unsafe.Pointer(pathAry + uintptr(i)*8))
			(*(*TNamespacePathEntry)(unsafe.Pointer(tmpPathArray + uintptr(i)*32))).FcreatorNsPtr = nsPtr
			(*(*TNamespacePathEntry)(unsafe.Pointer(tmpPathArray + uintptr(i)*32))).FprevPtr = libc.UintptrFromInt32(0)
			(*(*TNamespacePathEntry)(unsafe.Pointer(tmpPathArray + uintptr(i)*32))).FnextPtr = (*TNamespace)(unsafe.Pointer((*(*TNamespacePathEntry)(unsafe.Pointer(tmpPathArray + uintptr(i)*32))).FnsPtr)).FcommandPathSourceList
			if (*(*TNamespacePathEntry)(unsafe.Pointer(tmpPathArray + uintptr(i)*32))).FnextPtr != libc.UintptrFromInt32(0) {
				(*TNamespacePathEntry)(unsafe.Pointer((*(*TNamespacePathEntry)(unsafe.Pointer(tmpPathArray + uintptr(i)*32))).FnextPtr)).FprevPtr = tmpPathArray + uintptr(i)*32
			}
			(*TNamespace)(unsafe.Pointer((*(*TNamespacePathEntry)(unsafe.Pointer(tmpPathArray + uintptr(i)*32))).FnsPtr)).FcommandPathSourceList = tmpPathArray + uintptr(i)*32
			goto _1
		_1:
			;
			i++
		}
		if (*TNamespace)(unsafe.Pointer(nsPtr)).FcommandPathLength != 0 {
			_UnlinkNsPath(tls, nsPtr)
		}
		(*TNamespace)(unsafe.Pointer(nsPtr)).FcommandPathArray = tmpPathArray
	} else {
		if (*TNamespace)(unsafe.Pointer(nsPtr)).FcommandPathLength != 0 {
			_UnlinkNsPath(tls, nsPtr)
		}
	}
	(*TNamespace)(unsafe.Pointer(nsPtr)).FcommandPathLength = pathLength
	(*TNamespace)(unsafe.Pointer(nsPtr)).FcmdRefEpoch++
	(*TNamespace)(unsafe.Pointer(nsPtr)).FresolverEpoch++
}

/*
 *----------------------------------------------------------------------
 *
 * UnlinkNsPath --
 *
 *	Delete the given namespace's command name resolution path. Only call
 *	if the path is non-empty. Caller must reset the counter containing the
 *	path size.
 *
 * Results:
 *	nothing
 *
 * Side effects:
 *	Deletes the array of path entries and unlinks those path entries from
 *	the target namespace's list of interested namespaces.
 *
 *----------------------------------------------------------------------
 */

func _UnlinkNsPath(tls *libc.TLS, nsPtr uintptr) {
	var i TTcl_Size
	var nsPathPtr uintptr
	_, _ = i, nsPathPtr
	i = 0
	for {
		if !(i < (*TNamespace)(unsafe.Pointer(nsPtr)).FcommandPathLength) {
			break
		}
		nsPathPtr = (*TNamespace)(unsafe.Pointer(nsPtr)).FcommandPathArray + uintptr(i)*32
		if (*TNamespacePathEntry)(unsafe.Pointer(nsPathPtr)).FprevPtr != libc.UintptrFromInt32(0) {
			(*TNamespacePathEntry)(unsafe.Pointer((*TNamespacePathEntry)(unsafe.Pointer(nsPathPtr)).FprevPtr)).FnextPtr = (*TNamespacePathEntry)(unsafe.Pointer(nsPathPtr)).FnextPtr
		}
		if (*TNamespacePathEntry)(unsafe.Pointer(nsPathPtr)).FnextPtr != libc.UintptrFromInt32(0) {
			(*TNamespacePathEntry)(unsafe.Pointer((*TNamespacePathEntry)(unsafe.Pointer(nsPathPtr)).FnextPtr)).FprevPtr = (*TNamespacePathEntry)(unsafe.Pointer(nsPathPtr)).FprevPtr
		}
		if (*TNamespacePathEntry)(unsafe.Pointer(nsPathPtr)).FnsPtr != libc.UintptrFromInt32(0) {
			if (*TNamespace)(unsafe.Pointer((*TNamespacePathEntry)(unsafe.Pointer(nsPathPtr)).FnsPtr)).FcommandPathSourceList == nsPathPtr {
				(*TNamespace)(unsafe.Pointer((*TNamespacePathEntry)(unsafe.Pointer(nsPathPtr)).FnsPtr)).FcommandPathSourceList = (*TNamespacePathEntry)(unsafe.Pointer(nsPathPtr)).FnextPtr
			}
		}
		goto _1
	_1:
		;
		i++
	}
	XTclpFree(tls, (*TNamespace)(unsafe.Pointer(nsPtr)).FcommandPathArray)
}

/*
 *----------------------------------------------------------------------
 *
 * TclInvalidateNsPath --
 *
 *	Invalidate the name resolution caches for all names looked up in
 *	namespaces whose name path includes the given namespace.
 *
 * Results:
 *	nothing
 *
 * Side effects:
 *	Increments the command reference epoch in each namespace whose path
 *	includes the given namespace. This causes any cached resolved names
 *	whose root caching context starts at that namespace to be recomputed
 *	the next time they are used.
 *
 *----------------------------------------------------------------------
 */

func XTclInvalidateNsPath(tls *libc.TLS, nsPtr uintptr) {
	var nsPathPtr uintptr
	_ = nsPathPtr
	nsPathPtr = (*TNamespace)(unsafe.Pointer(nsPtr)).FcommandPathSourceList
	for nsPathPtr != libc.UintptrFromInt32(0) {
		if (*TNamespacePathEntry)(unsafe.Pointer(nsPathPtr)).FnsPtr != libc.UintptrFromInt32(0) {
			(*TNamespace)(unsafe.Pointer((*TNamespacePathEntry)(unsafe.Pointer(nsPathPtr)).FcreatorNsPtr)).FcmdRefEpoch++
		}
		nsPathPtr = (*TNamespacePathEntry)(unsafe.Pointer(nsPathPtr)).FnextPtr
	}
}

/*
 *----------------------------------------------------------------------
 *
 * NamespaceQualifiersCmd --
 *
 *	Invoked to implement the "namespace qualifiers" command that returns
 *	any leading namespace qualifiers in a string. These qualifiers are
 *	namespace names separated by "::"s. For example, for "::foo::p" this
 *	command returns "::foo", and for "::" it returns "". This command is
 *	the complement of the "namespace tail" command. Note that this command
 *	does not check whether the "namespace" names are, in fact, the names
 *	of currently defined namespaces. Handles the following syntax:
 *
 *	    namespace qualifiers string
 *
 * Results:
 *	Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If anything goes
 *	wrong, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func _NamespaceQualifiersCmd(tls *libc.TLS, dummy4354 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var length Tsize_t
	var name, p, v1, v3 uintptr
	_, _, _, _, _ = length, name, p, v1, v3
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+19514)
		return int32(TCL_ERROR)
	}
	/*
	 * Find the end of the string, then work backward and find the start of
	 * the last "::" qualifier.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	name = v1
	p = name
	for {
		if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('\000')) {
			break
		}
		/* empty body */
		goto _2
	_2:
		;
		p++
	}
	for {
		p--
		v3 = p
		if !(v3 >= name) {
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(':') && p > name && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-libc.Int32FromInt32(1))))) == int32(':') {
			p -= uintptr(2) /* Back up over the :: */
			for p >= name && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(':') {
				p-- /* Back up over the preceding : */
			}
			break
		}
	}
	if p >= name {
		length = libc.Uint64FromInt64(int64(p) - int64(name) + int64(1))
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, name, libc.Int64FromUint64(length)))
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * NamespaceUnknownCmd --
 *
 *	Invoked to implement the "namespace unknown" command (TIP 181) that
 *	sets or queries a per-namespace unknown command handler. This handler
 *	is called when command lookup fails (current and global ns). The
 *	default handler for the global namespace is ::unknown. The default
 *	handler for other namespaces is to call the global namespace unknown
 *	handler. Passing an empty list results in resetting the handler to its
 *	default.
 *
 *	    namespace unknown ?handler?
 *
 * Results:
 *	Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
 *
 * Side effects:
 *	If no handler is specified, returns a result in the interpreter's
 *	result object, otherwise it sets the unknown handler pointer in the
 *	current namespace to the script fragment provided. If anything goes
 *	wrong, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func _NamespaceUnknownCmd(tls *libc.TLS, dummy4422 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var cachePtr, currNsPtr, resultPtr uintptr
	var rc int32
	var v1 bool
	_, _, _, _, _ = cachePtr, currNsPtr, rc, resultPtr, v1
	if objc > int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+54524)
		return int32(TCL_ERROR)
	}
	currNsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FnsPtr
	if objc == int32(1) {
		/*
		 * Introspection - return the current namespace handler.
		 */
		resultPtr = XTcl_GetNamespaceUnknownHandler(tls, interp, currNsPtr)
		if resultPtr == libc.UintptrFromInt32(0) {
			if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				resultPtr = XTclThreadAllocObj(tls)
			} else {
				resultPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(resultPtr + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FtypePtr = libc.UintptrFromInt32(0)
		}
		XTcl_SetObjResult(tls, interp, resultPtr)
	} else {
		rc = XTcl_SetNamespaceUnknownHandler(tls, interp, currNsPtr, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
		if rc == TCL_OK {
			XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
		}
		return rc
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetNamespaceUnknownHandler --
 *
 *	Returns the unknown command handler registered for the given
 *	namespace.
 *
 * Results:
 *	Returns the current unknown command handler, or NULL if none exists
 *	for the namespace.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetNamespaceUnknownHandler(tls *libc.TLS, interp uintptr, nsPtr uintptr) (r uintptr) {
	/* The namespace. */
	var cachePtr, currNsPtr uintptr
	var v1 bool
	_, _, _ = cachePtr, currNsPtr, v1
	currNsPtr = nsPtr
	if (*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr == libc.UintptrFromInt32(0) && currNsPtr == (*TInterp)(unsafe.Pointer(interp)).FglobalNsPtr {
		/*
		 * Default handler for global namespace is "::unknown". For all other
		 * namespaces, it is NULL (which falls back on the global unknown
		 * handler).
		 */
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			(*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr = XTclThreadAllocObj(tls)
		} else {
			(*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer((*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr)).FrefCount = 0
		if libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr)).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr)).Fbytes, __ccgo_ts+8501, libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr)).Fbytes + uintptr(libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(10) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr)).FtypePtr = libc.UintptrFromInt32(0)
		(*TTcl_Obj)(unsafe.Pointer((*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr)).FrefCount++
	}
	return (*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetNamespaceUnknownHandler --
 *
 *	Sets the unknown command handler for the given namespace to the
 *	command prefix passed.
 *
 * Results:
 *	Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
 *
 * Side effects:
 *	Sets the namespace unknown command handler. If the passed in handler
 *	is NULL or an empty list, then the handler is reset to its default. If
 *	an error occurs, then an error message is left in the interpreter
 *	result.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetNamespaceUnknownHandler(tls *libc.TLS, interp uintptr, nsPtr uintptr, handlerPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The new handler, or NULL to reset. */
	var _objPtr, currNsPtr, v4 uintptr
	var v1 int32
	var v2 int64
	var v3 TTcl_Size
	var _ /* lstlen at bp+0 */ TTcl_Size
	_, _, _, _, _, _ = _objPtr, currNsPtr, v1, v2, v3, v4
	*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	currNsPtr = nsPtr
	/*
	 * Ensure that we check for errors *first* before we change anything.
	 */
	if handlerPtr != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(handlerPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(handlerPtr + 32))).Fptr2 != 0 {
				v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(handlerPtr + 32))).Fptr2)).FspanLength
			} else {
				v2 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(handlerPtr + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp)) = v2
			v1 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1 = XTcl_ListObjLength(tls, interp, handlerPtr, bp)
		}
		if v1 != TCL_OK {
			/*
			 * Not a list.
			 */
			return int32(TCL_ERROR)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp)) > 0 {
			/*
			 * We are going to be saving this handler. Increment the reference
			 * count before decrementing the refcount on the previous handler,
			 * so that nothing strange can happen if we are told to set the
			 * handler to the previous value.
			 */
			(*TTcl_Obj)(unsafe.Pointer(handlerPtr)).FrefCount++
		}
	}
	/*
	 * Remove old handler next.
	 */
	if (*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr != libc.UintptrFromInt32(0) {
		_objPtr = (*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr
		v4 = _objPtr
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	/*
	 * Install the new handler.
	 */
	if *(*TTcl_Size)(unsafe.Pointer(bp)) > 0 {
		/*
		 * Just store the handler. It already has the correct reference count.
		 */
		(*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr = handlerPtr
	} else {
		/*
		 * If NULL or an empty list is passed, this resets to the default
		 * handler.
		 */
		(*TNamespace)(unsafe.Pointer(currNsPtr)).FunknownHandlerPtr = libc.UintptrFromInt32(0)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * NamespaceTailCmd --
 *
 *	Invoked to implement the "namespace tail" command that returns the
 *	trailing name at the end of a string with "::" namespace qualifiers.
 *	These qualifiers are namespace names separated by "::"s. For example,
 *	for "::foo::p" this command returns "p", and for "::" it returns "".
 *	This command is the complement of the "namespace qualifiers" command.
 *	Note that this command does not check whether the "namespace" names
 *	are, in fact, the names of currently defined namespaces. Handles the
 *	following syntax:
 *
 *	    namespace tail string
 *
 * Results:
 *	Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If anything goes
 *	wrong, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func _NamespaceTailCmd(tls *libc.TLS, dummy4609 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var name, p, v1, v3 uintptr
	_, _, _, _ = name, p, v1, v3
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+19514)
		return int32(TCL_ERROR)
	}
	/*
	 * Find the end of the string, then work backward and find the last "::"
	 * qualifier.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	name = v1
	p = name
	for {
		if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('\000')) {
			break
		}
		/* empty body */
		goto _2
	_2:
		;
		p++
	}
	for {
		p--
		v3 = p
		if !(v3 > name) {
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(':') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-libc.Int32FromInt32(1))))) == int32(':') {
			p++ /* Just after the last "::" */
			break
		}
	}
	if p >= name {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, p, int64(-int32(1))))
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * NamespaceUpvarCmd --
 *
 *	Invoked to implement the "namespace upvar" command, that creates
 *	variables in the current scope linked to variables in another
 *	namespace. Handles the following syntax:
 *
 *	    namespace upvar ns otherVar myVar ?otherVar myVar ...?
 *
 * Results:
 *	Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
 *
 * Side effects:
 *	Creates new variables in the current scope, linked to the
 *	corresponding variables in the stipulated namespace. If anything goes
 *	wrong, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func _NamespaceUpvarCmd(tls *libc.TLS, dummy4667 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var iPtr, myName, otherPtr, savedNsPtr, v2 uintptr
	var _ /* arrayPtr at bp+8 */ uintptr
	var _ /* nsPtr at bp+0 */ uintptr
	_, _, _, _, _ = iPtr, myName, otherPtr, savedNsPtr, v2
	iPtr = interp
	if objc < int32(2) || objc&int32(1) != 0 {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+54533)
		return int32(TCL_ERROR)
	}
	if XTclGetNamespaceFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	objc -= int32(2)
	objv += uintptr(2) * 8
	for {
		if !(objc > 0) {
			break
		}
		/*
		 * Locate the other variable.
		 */
		savedNsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FnsPtr
		(*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FnsPtr = *(*uintptr)(unsafe.Pointer(bp))
		otherPtr = XTclObjLookupVarEx(tls, interp, *(*uintptr)(unsafe.Pointer(objv)), libc.UintptrFromInt32(0), libc.Int32FromInt32(TCL_NAMESPACE_ONLY)|libc.Int32FromInt32(TCL_LEAVE_ERR_MSG)|libc.Int32FromInt32(TCL_AVOID_RESOLVERS), __ccgo_ts+32162, int32(1), int32(1), bp+8)
		(*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FnsPtr = savedNsPtr
		if otherPtr == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
		/*
		 * Create the new variable and link it to otherPtr.
		 */
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
		}
		myName = v2
		if XTclPtrMakeUpvar(tls, interp, otherPtr, myName, 0, -int32(1)) != TCL_OK {
			return int32(TCL_ERROR)
		}
		goto _1
	_1:
		;
		objc -= int32(2)
		objv += uintptr(2) * 8
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * NamespaceWhichCmd --
 *
 *	Invoked to implement the "namespace which" command that returns the
 *	fully-qualified name of a command or variable. If the specified
 *	command or variable does not exist, it returns "". Handles the
 *	following syntax:
 *
 *	    namespace which ?-command? ?-variable? name
 *
 * Results:
 *	Returns TCL_OK if successful, and TCL_ERROR if anything goes wrong.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If anything goes
 *	wrong, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func _NamespaceWhichCmd(tls *libc.TLS, dummy4741 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var cachePtr, resultPtr, v4 uintptr
	var cmd TTcl_Command
	var var1 TTcl_Var
	var v3 bool
	var _ /* lookupType at bp+0 */ int32
	_, _, _, _, _, _ = cachePtr, cmd, resultPtr, var1, v3, v4
	*(*int32)(unsafe.Pointer(bp)) = 0
	if !(objc < int32(2) || objc > int32(3)) {
		goto _1
	}
	goto badArgs
badArgs:
	;
	XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+54557)
	return int32(TCL_ERROR)
	goto _2
_1:
	;
	if objc == int32(3) {
		/*
		 * Look for a flag controlling the lookup.
		 */
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), uintptr(unsafe.Pointer(&_opts)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
			/*
			 * Preserve old style of error message!
			 */
			XTcl_ResetResult(tls, interp)
			goto badArgs
		}
	}
_2:
	;
	if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultPtr = XTclThreadAllocObj(tls)
	} else {
		resultPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FtypePtr = libc.UintptrFromInt32(0)
	switch *(*int32)(unsafe.Pointer(bp)) {
	case 0: /* -command */
		cmd = XTcl_GetCommandFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))
		if cmd != libc.UintptrFromInt32(0) {
			XTcl_GetCommandFullName(tls, interp, cmd, resultPtr)
		}
	case int32(1):
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))).Fbytes != 0 {
			v4 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))).Fbytes
		} else {
			v4 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), libc.UintptrFromInt32(0))
		} /* -variable */
		var1 = XTcl_FindNamespaceVar(tls, interp, v4, libc.UintptrFromInt32(0), 0)
		if var1 != libc.UintptrFromInt32(0) {
			XTcl_GetVariableFullName(tls, interp, var1, resultPtr)
		}
		break
	}
	XTcl_SetObjResult(tls, interp, resultPtr)
	return TCL_OK
}

var _opts = [3]uintptr{
	0: __ccgo_ts + 18236,
	1: __ccgo_ts + 31116,
	2: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * FreeNsNameInternalRep --
 *
 *	Frees the resources associated with a nsName object's internal
 *	representation.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Decrements the ref count of any Namespace structure pointed to by the
 *	nsName's internal representation. If there are no more references to
 *	the namespace, it's structure will be freed.
 *
 *----------------------------------------------------------------------
 */

func _FreeNsNameInternalRep(tls *libc.TLS, objPtr uintptr) {
	/* nsName object with internal representation
	 * to free. */
	var irPtr, resNamePtr, v1, v2, v4 uintptr
	var v3 Tsize_t
	_, _, _, _, _, _ = irPtr, resNamePtr, v1, v2, v3, v4
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_nsNameType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	resNamePtr = v2
	/*
	 * Decrement the reference count of the namespace. If there are no more
	 * references, free it up.
	 */
	v4 = resNamePtr + 16
	v3 = *(*Tsize_t)(unsafe.Pointer(v4))
	*(*Tsize_t)(unsafe.Pointer(v4))--
	if v3 <= uint64(1) {
		/*
		 * Decrement the reference count for the cached namespace. If the
		 * namespace is dead, and there are no more references to it, free
		 * it.
		 */
		XTclNsDecrRefCount(tls, (*TResolvedNsName)(unsafe.Pointer(resNamePtr)).FnsPtr)
		XTclpFree(tls, resNamePtr)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * DupNsNameInternalRep --
 *
 *	Initializes the internal representation of a nsName object to a copy
 *	of the internal representation of another nsName object.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	copyPtr's internal rep is set to refer to the same namespace
 *	referenced by srcPtr's internal rep. Increments the ref count of the
 *	ResolvedNsName structure used to hold the namespace reference.
 *
 *----------------------------------------------------------------------
 */

func _DupNsNameInternalRep(tls *libc.TLS, srcPtr uintptr, copyPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Object with internal rep to set. */
	var irPtr, resNamePtr, v1, v2 uintptr
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_, _, _, _ = irPtr, resNamePtr, v1, v2
	if (*TTcl_Obj)(unsafe.Pointer(srcPtr)).FtypePtr == uintptr(unsafe.Pointer(&_nsNameType)) {
		v1 = srcPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	resNamePtr = v2
	(*TResolvedNsName)(unsafe.Pointer(resNamePtr)).FrefCount++
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr1 = resNamePtr
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr2 = libc.UintptrFromInt32(0)
	XTcl_StoreInternalRep(tls, copyPtr, uintptr(unsafe.Pointer(&_nsNameType)), bp)
}

/*
 *----------------------------------------------------------------------
 *
 * SetNsNameFromAny --
 *
 *	Attempt to generate a nsName internal representation for a Tcl object.
 *
 * Results:
 *	Returns TCL_OK if the value could be converted to a proper namespace
 *	reference. Otherwise, it returns TCL_ERROR, along with an error
 *	message in the interpreter's result object.
 *
 * Side effects:
 *	If successful, the object is made a nsName object. Its internal rep is
 *	set to point to a ResolvedNsName, which contains a cached pointer to
 *	the Namespace. Reference counts are kept on both the ResolvedNsName
 *	and the Namespace, so we can keep track of their usage and free them
 *	when appropriate.
 *
 *----------------------------------------------------------------------
 */

func _SetNsNameFromAny(tls *libc.TLS, interp uintptr, objPtr uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* The object to convert. */
	var name, resNamePtr, v1 uintptr
	var _ /* dummy at bp+0 */ uintptr
	var _ /* dummy1Ptr at bp+16 */ uintptr
	var _ /* dummy2Ptr at bp+24 */ uintptr
	var _ /* ir at bp+32 */ TTcl_ObjInternalRep
	var _ /* nsPtr at bp+8 */ uintptr
	_, _, _ = name, resNamePtr, v1
	if interp == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
	}
	name = v1
	XTclGetNamespaceForQualName(tls, interp, name, libc.UintptrFromInt32(0), int32(TCL_FIND_ONLY_NS), bp+8, bp+16, bp+24, bp)
	if *(*uintptr)(unsafe.Pointer(bp + 8)) == libc.UintptrFromInt32(0) || (*TNamespace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fflags&int32(NS_DYING) != 0 {
		return int32(TCL_ERROR)
	}
	/*
	 * If we found a namespace, then create a new ResolvedNsName structure
	 * that holds a reference to it.
	 */
	(*TNamespace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
	resNamePtr = XTcl_Alloc(tls, uint64(24))
	(*TResolvedNsName)(unsafe.Pointer(resNamePtr)).FnsPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32(':') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name + 1))) == int32(':') {
		(*TResolvedNsName)(unsafe.Pointer(resNamePtr)).FrefNsPtr = libc.UintptrFromInt32(0)
	} else {
		(*TResolvedNsName)(unsafe.Pointer(resNamePtr)).FrefNsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FnsPtr
	}
	(*TResolvedNsName)(unsafe.Pointer(resNamePtr)).FrefCount = uint64(0)
	(*TResolvedNsName)(unsafe.Pointer(resNamePtr)).FrefCount++
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp + 32))).Fptr1 = resNamePtr
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp + 32))).Fptr2 = libc.UintptrFromInt32(0)
	XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&_nsNameType)), bp+32)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclGetNamespaceCommandTable --
 *
 *	Returns the hash table of commands.
 *
 * Results:
 *	Pointer to the hash table.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclGetNamespaceCommandTable(tls *libc.TLS, nsPtr uintptr) (r uintptr) {
	return nsPtr + 184
}

/*
 *----------------------------------------------------------------------
 *
 * TclGetNamespaceChildTable --
 *
 *	Returns the hash table of child namespaces.
 *
 * Results:
 *	Pointer to the hash table.
 *
 * Side effects:
 *	Might allocate memory.
 *
 *----------------------------------------------------------------------
 */

func XTclGetNamespaceChildTable(tls *libc.TLS, nsPtr uintptr) (r uintptr) {
	var nPtr uintptr
	_ = nPtr
	nPtr = nsPtr
	return nPtr + 40
}

/*
 *----------------------------------------------------------------------
 *
 * TclLogCommandInfo --
 *
 *	Invoked after an error occurs in an interpreter.
 *	Adds information to iPtr->errorInfo/errorStack fields to describe the
 *	command that was being executed when the error occurred. When pc and
 *	tosPtr are non-NULL, conveying a bytecode execution "inner context",
 *	and the offending instruction is suitable, and that inner context is
 *	recorded in errorStack.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Information about the command is added to errorInfo/errorStack and the
 *	line number stored internally in the interpreter is set.
 *
 *----------------------------------------------------------------------
 */

func XTclLogCommandInfo(tls *libc.TLS, interp uintptr, script uintptr, command uintptr, length TTcl_Size, pc uintptr, tosPtr uintptr) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Current stack of bytecode execution
	 * context */
	var _objPtr, hPtr, iPtr, innerContext, newObj, p, tracePtr, varPtr, v2, v4, v6 uintptr
	var limit, overflow, v3 int32
	var v5 TTcl_Size
	var v8 int64
	var _ /* arrayPtr at bp+0 */ uintptr
	var _ /* len at bp+8 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, hPtr, iPtr, innerContext, limit, newObj, overflow, p, tracePtr, varPtr, v2, v3, v4, v5, v6, v8
	iPtr = interp
	limit = int32(150)
	if (*TInterp)(unsafe.Pointer(iPtr)).Fflags&int32(ERR_ALREADY_LOGGED) != 0 {
		/*
		 * Someone else has already logged error information for this command.
		 * Don't add anything more.
		 */
		return
	}
	if command != libc.UintptrFromInt32(0) {
		/*
		 * Compute the line number where the error occurred.
		 */
		(*TInterp)(unsafe.Pointer(iPtr)).FerrorLine = int32(1)
		p = script
		for {
			if !(p != command) {
				break
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('\n') {
				(*TInterp)(unsafe.Pointer(iPtr)).FerrorLine++
			}
			goto _1
		_1:
			;
			p++
		}
		if length < 0 {
			length = libc.Int64FromUint64(libc.Xstrlen(tls, command))
		}
		overflow = libc.BoolInt32(length > int64(limit))
		if (*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo == libc.UintptrFromInt32(0) {
			v2 = __ccgo_ts + 54585
		} else {
			v2 = __ccgo_ts + 54601
		}
		if overflow != 0 {
			v3 = limit
		} else {
			v3 = int32(length)
		}
		if overflow != 0 {
			v4 = __ccgo_ts + 8560
		} else {
			v4 = __ccgo_ts + 1945
		}
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+54621, libc.VaList(bp+24, v2, v3, command, v4)))
		varPtr = XTclObjLookupVarEx(tls, interp, (*TInterp)(unsafe.Pointer(iPtr)).FeiVar, libc.UintptrFromInt32(0), int32(TCL_GLOBAL_ONLY), libc.UintptrFromInt32(0), 0, 0, bp)
		if varPtr == libc.UintptrFromInt32(0) || !((*TVar)(unsafe.Pointer(varPtr)).Fflags&(libc.Int32FromInt32(VAR_TRACED_READ)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_TRACED_ARRAY)|libc.Int32FromInt32(VAR_TRACED_UNSET)) != 0) {
			/*
			 * Should not happen.
			 */
			return
		} else {
			hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iPtr + 792)).FfindProc})))(tls, iPtr+792, varPtr)
			tracePtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
			if (*TVarTrace)(unsafe.Pointer(tracePtr)).FtraceProc != __ccgo_fp(_EstablishErrorInfoTraces) {
				/*
				 * The most recent trace set on ::errorInfo is not the one the
				 * core itself puts on last. This means some other code is
				 * tracing the variable, and the additional trace(s) might be
				 * write traces that expect the timing of writes to
				 * ::errorInfo that existed Tcl releases before 8.5. To
				 * satisfy that compatibility need, we write the current
				 * -errorinfo value to the ::errorInfo variable.
				 */
				XTcl_ObjSetVar2(tls, interp, (*TInterp)(unsafe.Pointer(iPtr)).FeiVar, libc.UintptrFromInt32(0), (*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo, int32(TCL_GLOBAL_ONLY))
			}
		}
	}
	/*
	 * TIP #348
	 */
	if (*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FerrorStack)).FrefCount > int64(1) {
		newObj = XTcl_DuplicateObj(tls, (*TInterp)(unsafe.Pointer(iPtr)).FerrorStack)
		_objPtr = (*TInterp)(unsafe.Pointer(iPtr)).FerrorStack
		v6 = _objPtr
		v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
		*(*TTcl_Size)(unsafe.Pointer(v6))--
		if v5 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		(*TTcl_Obj)(unsafe.Pointer(newObj)).FrefCount++
		(*TInterp)(unsafe.Pointer(iPtr)).FerrorStack = newObj
	}
	if (*TInterp)(unsafe.Pointer(iPtr)).FresetErrorStack != 0 {
		(*TInterp)(unsafe.Pointer(iPtr)).FresetErrorStack = 0
		if (*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FerrorStack)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FerrorStack + 32))).Fptr2 != 0 {
				v8 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FerrorStack + 32))).Fptr2)).FspanLength
			} else {
				v8 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FerrorStack + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v8
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_ListObjLength(tls, interp, (*TInterp)(unsafe.Pointer(iPtr)).FerrorStack, bp+8)
		}
		/*
		 * Reset while keeping the list internalrep as much as possible.
		 */
		XTcl_ListObjReplace(tls, interp, (*TInterp)(unsafe.Pointer(iPtr)).FerrorStack, 0, *(*TTcl_Size)(unsafe.Pointer(bp + 8)), 0, libc.UintptrFromInt32(0))
		if pc != libc.UintptrFromInt32(0) {
			innerContext = XTclGetInnerContext(tls, interp, pc, tosPtr)
			if innerContext != libc.UintptrFromInt32(0) {
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), (*TInterp)(unsafe.Pointer(iPtr)).FerrorStack, (*TInterp)(unsafe.Pointer(iPtr)).FinnerLiteral)
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), (*TInterp)(unsafe.Pointer(iPtr)).FerrorStack, innerContext)
			}
		} else {
			if command != libc.UintptrFromInt32(0) {
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), (*TInterp)(unsafe.Pointer(iPtr)).FerrorStack, (*TInterp)(unsafe.Pointer(iPtr)).FinnerLiteral)
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), (*TInterp)(unsafe.Pointer(iPtr)).FerrorStack, XTcl_NewStringObj(tls, command, length))
			}
		}
	}
	if !((*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FframePtr)).Fobjc != 0) {
		/*
		 * Special frame, nothing to report.
		 */
	} else {
		if (*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr != (*TInterp)(unsafe.Pointer(iPtr)).FframePtr {
			/*
			 * uplevel case, [lappend errorstack UP $relativelevel]
			 */
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), (*TInterp)(unsafe.Pointer(iPtr)).FerrorStack, (*TInterp)(unsafe.Pointer(iPtr)).FupLiteral)
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), (*TInterp)(unsafe.Pointer(iPtr)).FerrorStack, XTcl_NewWideIntObj(tls, int64(int32((*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FframePtr)).Flevel-(*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).Flevel))))
		} else {
			if (*TInterp)(unsafe.Pointer(iPtr)).FframePtr != (*TInterp)(unsafe.Pointer(iPtr)).FrootFramePtr {
				/*
				 * normal case, [lappend errorstack CALL [info level 0]]
				 */
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), (*TInterp)(unsafe.Pointer(iPtr)).FerrorStack, (*TInterp)(unsafe.Pointer(iPtr)).FcallLiteral)
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), (*TInterp)(unsafe.Pointer(iPtr)).FerrorStack, XTcl_NewListObj(tls, (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FframePtr)).Fobjc, (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FframePtr)).Fobjv))
			}
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclErrorStackResetIf --
 *
 *	The TIP 348 reset/no-bc part of TLCI, for specific use by
 *	TclCompileSyntaxError.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Reset errorstack if it needs be, and in that case remember the
 *	passed-in error message as inner context.
 *
 *----------------------------------------------------------------------
 */

func XTclErrorStackResetIf(tls *libc.TLS, interp uintptr, msg uintptr, length TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, iPtr, newObj, v2 uintptr
	var v1 TTcl_Size
	var v4 int64
	var _ /* len at bp+0 */ TTcl_Size
	_, _, _, _, _, _ = _objPtr, iPtr, newObj, v1, v2, v4
	iPtr = interp
	if (*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FerrorStack)).FrefCount > int64(1) {
		newObj = XTcl_DuplicateObj(tls, (*TInterp)(unsafe.Pointer(iPtr)).FerrorStack)
		_objPtr = (*TInterp)(unsafe.Pointer(iPtr)).FerrorStack
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		(*TTcl_Obj)(unsafe.Pointer(newObj)).FrefCount++
		(*TInterp)(unsafe.Pointer(iPtr)).FerrorStack = newObj
	}
	if (*TInterp)(unsafe.Pointer(iPtr)).FresetErrorStack != 0 {
		(*TInterp)(unsafe.Pointer(iPtr)).FresetErrorStack = 0
		if (*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FerrorStack)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FerrorStack + 32))).Fptr2 != 0 {
				v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FerrorStack + 32))).Fptr2)).FspanLength
			} else {
				v4 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FerrorStack + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp)) = v4
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_ListObjLength(tls, interp, (*TInterp)(unsafe.Pointer(iPtr)).FerrorStack, bp)
		}
		/*
		 * Reset while keeping the list internalrep as much as possible.
		 */
		XTcl_ListObjReplace(tls, interp, (*TInterp)(unsafe.Pointer(iPtr)).FerrorStack, 0, *(*TTcl_Size)(unsafe.Pointer(bp)), 0, libc.UintptrFromInt32(0))
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), (*TInterp)(unsafe.Pointer(iPtr)).FerrorStack, (*TInterp)(unsafe.Pointer(iPtr)).FinnerLiteral)
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), (*TInterp)(unsafe.Pointer(iPtr)).FerrorStack, XTcl_NewStringObj(tls, msg, length))
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LogCommandInfo --
 *
 *	This function is invoked after an error occurs in an interpreter. It
 *	adds information to iPtr->errorInfo/errorStack fields to describe the
 *	command that was being executed when the error occurred.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Information about the command is added to errorInfo/errorStack and the
 *	line number stored internally in the interpreter is set.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LogCommandInfo(tls *libc.TLS, interp uintptr, script uintptr, command uintptr, length TTcl_Size) {
	/* Number of bytes in command (-1 means use
	 * all bytes up to first null byte). */
	XTclLogCommandInfo(tls, interp, script, command, length, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
}

type TNamespace1 = struct {
	Fname                  uintptr
	FfullName              uintptr
	FclientData            uintptr
	FdeleteProc            uintptr
	FparentPtr             uintptr
	FchildTable            TTcl_HashTable
	FnsId                  Tsize_t
	Finterp                uintptr
	Fflags                 int32
	FactivationCount       TTcl_Size
	FrefCount              TTcl_Size
	FcmdTable              TTcl_HashTable
	FvarTable              TTclVarHashTable
	FexportArrayPtr        uintptr
	FnumExportPatterns     TTcl_Size
	FmaxExportPatterns     TTcl_Size
	FcmdRefEpoch           TTcl_Size
	FresolverEpoch         TTcl_Size
	FcmdResProc            uintptr
	FvarResProc            uintptr
	FcompiledVarResProc    uintptr
	FexportLookupEpoch     TTcl_Size
	Fensembles             uintptr
	FunknownHandlerPtr     uintptr
	FcommandPathLength     TTcl_Size
	FcommandPathArray      uintptr
	FcommandPathSourceList uintptr
	FearlyDeleteProc       uintptr
}

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * Notifier hooks that are checked in the public wrappers for the default
 * notifier functions (for overriding via Tcl_SetNotifier).
 */

var _tclNotifierHooks = TTcl_NotifierProcs{}

/*
 * For each event source (created with Tcl_CreateEventSource) there is a
 * structure of the following type:
 */

type TEventSource = struct {
	FsetupProc  uintptr
	FcheckProc  uintptr
	FclientData uintptr
	FnextPtr    uintptr
}

/*
 * The following structure keeps track of the state of the notifier on a
 * per-thread basis. The first three elements keep track of the event queue.
 * In addition to the first (next to be serviced) and last events in the
 * queue, we keep track of a "marker" event. This provides a simple priority
 * mechanism whereby events can be inserted at the front of the queue but
 * behind all other high-priority events already in the queue (this is used
 * for things like a sequence of Enter and Leave events generated during a
 * grab in Tk). These elements are protected by the queueMutex so that any
 * thread can queue an event on any notifier. Note that all of the values in
 * this structure will be initialized to 0.
 */

type TThreadSpecificData10 = struct {
	FfirstEventPtr       uintptr
	FlastEventPtr        uintptr
	FmarkerEventPtr      uintptr
	FeventCount          TTcl_Size
	FqueueMutex          TTcl_Mutex
	FserviceMode         int32
	FblockTimeSet        int32
	FblockTime           TTcl_Time
	FinTraversal         int32
	Finitialized         int32
	FfirstEventSourcePtr uintptr
	FthreadId            TTcl_ThreadId
	FclientData          uintptr
	FnextPtr             uintptr
}

var _dataKey8 TTcl_ThreadDataKey

/*
 * Global list of notifiers. Access to this list is controlled by the listLock
 * mutex. If this becomes a performance bottleneck, this could be replaced
 * with a hashtable.
 */

var _firstNotifierPtr = libc.UintptrFromInt32(0)

var _listLock TTcl_Mutex

/*
 *----------------------------------------------------------------------
 *
 * TclInitNotifier --
 *
 *	Initialize the thread local data structures for the notifier
 *	subsystem.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Adds the current thread to the global list of notifiers.
 *
 *----------------------------------------------------------------------
 */

func XTclInitNotifier(tls *libc.TLS) {
	var threadId TTcl_ThreadId
	var tsdPtr uintptr
	_, _ = threadId, tsdPtr
	threadId = XTcl_GetCurrentThread(tls)
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_listLock)))
	tsdPtr = _firstNotifierPtr
	for {
		if !(tsdPtr != 0 && (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FthreadId != threadId) {
			break
		}
		/* Empty loop body. */
		goto _1
	_1:
		;
		tsdPtr = (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FnextPtr
	}
	if libc.UintptrFromInt32(0) == tsdPtr {
		/*
		 * Notifier not yet initialized in this thread.
		 */
		tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey8)), int64(104))
		(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FthreadId = threadId
		(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FclientData = XTcl_InitNotifier(tls)
		(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).Finitialized = int32(1)
		(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FnextPtr = _firstNotifierPtr
		_firstNotifierPtr = tsdPtr
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_listLock)))
}

/*
 *----------------------------------------------------------------------
 *
 * TclFinalizeNotifier --
 *
 *	Finalize the thread local data structures for the notifier subsystem.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Removes the notifier associated with the current thread from the
 *	global notifier list. This is done only if the notifier was
 *	initialized for this thread by call to TclInitNotifier(). This is
 *	always true for threads which have been seeded with an Tcl
 *	interpreter, since the call to Tcl_CreateInterp will, among other
 *	things, call TclInitializeSubsystems() and this one will, in turn,
 *	call the TclInitNotifier() for the thread. For threads created without
 *	the Tcl interpreter, though, nobody is explicitly nor implicitly
 *	calling the TclInitNotifier hence, TclFinalizeNotifier should not be
 *	performed at all.
 *
 *----------------------------------------------------------------------
 */

func XTclFinalizeNotifier(tls *libc.TLS) {
	var evPtr, hold, prevPtrPtr, tsdPtr uintptr
	_, _, _, _ = evPtr, hold, prevPtrPtr, tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey8)), int64(104))
	if !((*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).Finitialized != 0) {
		return /* Notifier not initialized for the current thread */
	}
	XTcl_MutexLock(tls, tsdPtr+32)
	evPtr = (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FfirstEventPtr
	for {
		if !(evPtr != libc.UintptrFromInt32(0)) {
			break
		}
		hold = evPtr
		evPtr = (*TTcl_Event)(unsafe.Pointer(evPtr)).FnextPtr
		XTclpFree(tls, hold)
		goto _1
	_1:
	}
	(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FfirstEventPtr = libc.UintptrFromInt32(0)
	(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FlastEventPtr = libc.UintptrFromInt32(0)
	(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FeventCount = 0
	XTcl_MutexUnlock(tls, tsdPtr+32)
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_listLock)))
	XTcl_FinalizeNotifier(tls, (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FclientData)
	XTcl_MutexFinalize(tls, tsdPtr+32)
	prevPtrPtr = uintptr(unsafe.Pointer(&_firstNotifierPtr))
	for {
		if !(*(*uintptr)(unsafe.Pointer(prevPtrPtr)) != libc.UintptrFromInt32(0)) {
			break
		}
		if *(*uintptr)(unsafe.Pointer(prevPtrPtr)) == tsdPtr {
			*(*uintptr)(unsafe.Pointer(prevPtrPtr)) = (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FnextPtr
			break
		}
		goto _2
	_2:
		;
		prevPtrPtr = *(*uintptr)(unsafe.Pointer(prevPtrPtr)) + 96
	}
	(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).Finitialized = 0
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_listLock)))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetNotifier --
 *
 *	Install a set of alternate functions for use with the notifier. In
 *	particular, this can be used to install the Xt-based notifier for use
 *	with the Browser plugin.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Set the tclNotifierHooks global, which is checked in the default
 *	notifier functions.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetNotifier(tls *libc.TLS, notifierProcPtr uintptr) {
	_tclNotifierHooks = *(*TTcl_NotifierProcs)(unsafe.Pointer(notifierProcPtr))
	/*
	 * Don't allow hooks to refer to the hook point functions; avoids infinite
	 * loop.
	 */
	if _tclNotifierHooks.FsetTimerProc == __ccgo_fp(XTcl_SetTimer) {
		_tclNotifierHooks.FsetTimerProc = libc.UintptrFromInt32(0)
	}
	if _tclNotifierHooks.FwaitForEventProc == __ccgo_fp(XTcl_WaitForEvent) {
		_tclNotifierHooks.FwaitForEventProc = libc.UintptrFromInt32(0)
	}
	if _tclNotifierHooks.FinitNotifierProc == __ccgo_fp(XTcl_InitNotifier) {
		_tclNotifierHooks.FinitNotifierProc = libc.UintptrFromInt32(0)
	}
	if _tclNotifierHooks.FfinalizeNotifierProc == __ccgo_fp(XTcl_FinalizeNotifier) {
		_tclNotifierHooks.FfinalizeNotifierProc = libc.UintptrFromInt32(0)
	}
	if _tclNotifierHooks.FalertNotifierProc == __ccgo_fp(XTcl_AlertNotifier) {
		_tclNotifierHooks.FalertNotifierProc = libc.UintptrFromInt32(0)
	}
	if _tclNotifierHooks.FserviceModeHookProc == __ccgo_fp(XTcl_ServiceModeHook) {
		_tclNotifierHooks.FserviceModeHookProc = libc.UintptrFromInt32(0)
	}
	if _tclNotifierHooks.FcreateFileHandlerProc == __ccgo_fp(XTcl_CreateFileHandler) {
		_tclNotifierHooks.FcreateFileHandlerProc = libc.UintptrFromInt32(0)
	}
	if _tclNotifierHooks.FdeleteFileHandlerProc == __ccgo_fp(XTcl_DeleteFileHandler) {
		_tclNotifierHooks.FdeleteFileHandlerProc = libc.UintptrFromInt32(0)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_CreateEventSource --
 *
 *	This function is invoked to create a new source of events. The source
 *	is identified by a function that gets invoked during Tcl_DoOneEvent to
 *	check for events on that source and queue them.
 *
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	SetupProc and checkProc will be invoked each time that Tcl_DoOneEvent
 *	runs out of things to do. SetupProc will be invoked before
 *	Tcl_DoOneEvent calls select or whatever else it uses to wait for
 *	events. SetupProc typically calls functions like Tcl_SetMaxBlockTime
 *	to indicate what to wait for.
 *
 *	CheckProc is called after select or whatever operation was actually
 *	used to wait. It figures out whether anything interesting actually
 *	happened (e.g. by calling Tcl_AsyncReady), and then calls
 *	Tcl_QueueEvent to queue any events that are ready.
 *
 *	Each of these functions is passed two arguments, e.g.
 *		(*checkProc)(void *clientData, int flags));
 *	ClientData is the same as the clientData argument here, and flags is a
 *	combination of things like TCL_FILE_EVENTS that indicates what events
 *	are of interest: setupProc and checkProc use flags to figure out
 *	whether their events are relevant or not.
 *
 *----------------------------------------------------------------------
 */

func XTcl_CreateEventSource(tls *libc.TLS, setupProc uintptr, checkProc uintptr, clientData uintptr) {
	/* One-word argument to pass to setupProc and
	 * checkProc. */
	var sourcePtr, tsdPtr uintptr
	_, _ = sourcePtr, tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey8)), int64(104))
	sourcePtr = XTcl_Alloc(tls, uint64(32))
	(*TEventSource)(unsafe.Pointer(sourcePtr)).FsetupProc = setupProc
	(*TEventSource)(unsafe.Pointer(sourcePtr)).FcheckProc = checkProc
	(*TEventSource)(unsafe.Pointer(sourcePtr)).FclientData = clientData
	(*TEventSource)(unsafe.Pointer(sourcePtr)).FnextPtr = (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FfirstEventSourcePtr
	(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FfirstEventSourcePtr = sourcePtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DeleteEventSource --
 *
 *	This function is invoked to delete the source of events given by proc
 *	and clientData.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The given event source is canceled, so its function will never again
 *	be called. If no such source exists, nothing happens.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DeleteEventSource(tls *libc.TLS, setupProc uintptr, checkProc uintptr, clientData uintptr) {
	/* One-word argument to pass to setupProc and
	 * checkProc. */
	var prevPtr, sourcePtr, tsdPtr uintptr
	_, _, _ = prevPtr, sourcePtr, tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey8)), int64(104))
	sourcePtr = (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FfirstEventSourcePtr
	prevPtr = libc.UintptrFromInt32(0)
	for {
		if !(sourcePtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TEventSource)(unsafe.Pointer(sourcePtr)).FsetupProc != setupProc || (*TEventSource)(unsafe.Pointer(sourcePtr)).FcheckProc != checkProc || (*TEventSource)(unsafe.Pointer(sourcePtr)).FclientData != clientData {
			goto _1
		}
		if prevPtr == libc.UintptrFromInt32(0) {
			(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FfirstEventSourcePtr = (*TEventSource)(unsafe.Pointer(sourcePtr)).FnextPtr
		} else {
			(*TEventSource)(unsafe.Pointer(prevPtr)).FnextPtr = (*TEventSource)(unsafe.Pointer(sourcePtr)).FnextPtr
		}
		XTclpFree(tls, sourcePtr)
		return
		goto _1
	_1:
		;
		prevPtr = sourcePtr
		sourcePtr = (*TEventSource)(unsafe.Pointer(sourcePtr)).FnextPtr
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_QueueEvent --
 *
 *	Queue an event on the event queue associated with the current thread.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_QueueEvent(tls *libc.TLS, evPtr uintptr, position int32) {
	/* One of TCL_QUEUE_TAIL, TCL_QUEUE_HEAD, TCL_QUEUE_MARK,
	 * possibly combined with TCL_QUEUE_ALERT_IF_EMPTY. */
	var tsdPtr uintptr
	_ = tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey8)), int64(104))
	_QueueEvent(tls, tsdPtr, evPtr, position)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ThreadQueueEvent --
 *
 *	Queue an event on the specified thread's event queue.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ThreadQueueEvent(tls *libc.TLS, threadId TTcl_ThreadId, evPtr uintptr, position int32) {
	/* One of TCL_QUEUE_TAIL, TCL_QUEUE_HEAD, TCL_QUEUE_MARK,
	 * possibly combined with TCL_QUEUE_ALERT_IF_EMPTY. */
	var tsdPtr uintptr
	_ = tsdPtr
	/*
	 * Find the notifier associated with the specified thread.
	 */
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_listLock)))
	tsdPtr = _firstNotifierPtr
	for {
		if !(tsdPtr != 0 && (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FthreadId != threadId) {
			break
		}
		/* Empty loop body. */
		goto _1
	_1:
		;
		tsdPtr = (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FnextPtr
	}
	/*
	 * Queue the event if there was a notifier associated with the thread.
	 */
	if tsdPtr != 0 {
		if _QueueEvent(tls, tsdPtr, evPtr, position) != 0 {
			XTcl_AlertNotifier(tls, (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FclientData)
		}
	} else {
		XTclpFree(tls, evPtr)
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_listLock)))
}

/*
 *----------------------------------------------------------------------
 *
 * QueueEvent --
 *
 *	Insert an event into the specified thread's event queue at one of
 *	three positions: the head, the tail, or before a floating marker.
 *	Events inserted before the marker will be processed in first-in-
 *	first-out order, but before any events inserted at the tail of the
 *	queue. Events inserted at the head of the queue will be processed in
 *	last-in-first-out order.
 *
 * Results:
 *	For TCL_QUEUE_ALERT_IF_EMPTY the empty state before the
 *	operation is returned.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _QueueEvent(tls *libc.TLS, tsdPtr uintptr, evPtr uintptr, position int32) (r int32) {
	/* One of TCL_QUEUE_TAIL, TCL_QUEUE_HEAD, TCL_QUEUE_MARK,
	 * possibly combined with TCL_QUEUE_ALERT_IF_EMPTY */
	var wasEmpty int32
	_ = wasEmpty
	wasEmpty = 0
	XTcl_MutexLock(tls, tsdPtr+32)
	if position&int32(3) == int32(TCL_QUEUE_TAIL) {
		/*
		 * Append the event on the end of the queue.
		 */
		(*TTcl_Event)(unsafe.Pointer(evPtr)).FnextPtr = libc.UintptrFromInt32(0)
		if (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FfirstEventPtr == libc.UintptrFromInt32(0) {
			(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FfirstEventPtr = evPtr
		} else {
			(*TTcl_Event)(unsafe.Pointer((*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FlastEventPtr)).FnextPtr = evPtr
		}
		(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FlastEventPtr = evPtr
	} else {
		if position&int32(3) == int32(TCL_QUEUE_HEAD) {
			/*
			 * Push the event on the head of the queue.
			 */
			(*TTcl_Event)(unsafe.Pointer(evPtr)).FnextPtr = (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FfirstEventPtr
			if (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FfirstEventPtr == libc.UintptrFromInt32(0) {
				(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FlastEventPtr = evPtr
			}
			(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FfirstEventPtr = evPtr
		} else {
			if position&int32(3) == int32(TCL_QUEUE_MARK) {
				/*
				 * Insert the event after the current marker event and advance the
				 * marker to the new event.
				 */
				if (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FmarkerEventPtr == libc.UintptrFromInt32(0) {
					(*TTcl_Event)(unsafe.Pointer(evPtr)).FnextPtr = (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FfirstEventPtr
					(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FfirstEventPtr = evPtr
				} else {
					(*TTcl_Event)(unsafe.Pointer(evPtr)).FnextPtr = (*TTcl_Event)(unsafe.Pointer((*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FmarkerEventPtr)).FnextPtr
					(*TTcl_Event)(unsafe.Pointer((*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FmarkerEventPtr)).FnextPtr = evPtr
				}
				(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FmarkerEventPtr = evPtr
				if (*TTcl_Event)(unsafe.Pointer(evPtr)).FnextPtr == libc.UintptrFromInt32(0) {
					(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FlastEventPtr = evPtr
				}
			}
		}
	}
	if position&int32(TCL_QUEUE_ALERT_IF_EMPTY) != 0 {
		wasEmpty = libc.BoolInt32((*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FeventCount <= 0)
	}
	(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FeventCount++
	XTcl_MutexUnlock(tls, tsdPtr+32)
	return wasEmpty
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DeleteEvents --
 *
 *	Calls a function for each event in the queue and deletes those for
 *	which the function returns 1. Events for which the function returns 0
 *	are left in the queue. Operates on the queue associated with the
 *	current thread.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Potentially removes one or more events from the event queue.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DeleteEvents(tls *libc.TLS, proc uintptr, clientData uintptr) {
	/* The type-specific data. */
	var evPtr, hold, prevPtr, tsdPtr uintptr
	_, _, _, _ = evPtr, hold, prevPtr, tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey8)), int64(104))
	XTcl_MutexLock(tls, tsdPtr+32)
	/*
	 * Walk the queue of events for the thread, applying 'proc' to each to
	 * decide whether to eliminate the event.
	 */
	prevPtr = libc.UintptrFromInt32(0)
	evPtr = (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FfirstEventPtr
	for evPtr != libc.UintptrFromInt32(0) {
		if (*(*func(*libc.TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{proc})))(tls, evPtr, clientData) == int32(1) {
			/*
			 * This event should be deleted. Unlink it.
			 */
			if prevPtr == libc.UintptrFromInt32(0) {
				(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FfirstEventPtr = (*TTcl_Event)(unsafe.Pointer(evPtr)).FnextPtr
			} else {
				(*TTcl_Event)(unsafe.Pointer(prevPtr)).FnextPtr = (*TTcl_Event)(unsafe.Pointer(evPtr)).FnextPtr
			}
			/*
			 * Update 'last' and 'marker' events if either has been deleted.
			 */
			if (*TTcl_Event)(unsafe.Pointer(evPtr)).FnextPtr == libc.UintptrFromInt32(0) {
				(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FlastEventPtr = prevPtr
			}
			if (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FmarkerEventPtr == evPtr {
				(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FmarkerEventPtr = prevPtr
			}
			/*
			 * Delete the event data structure.
			 */
			hold = evPtr
			evPtr = (*TTcl_Event)(unsafe.Pointer(evPtr)).FnextPtr
			XTclpFree(tls, hold)
			(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FeventCount--
		} else {
			/*
			 * Event is to be retained.
			 */
			prevPtr = evPtr
			evPtr = (*TTcl_Event)(unsafe.Pointer(evPtr)).FnextPtr
		}
	}
	XTcl_MutexUnlock(tls, tsdPtr+32)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ServiceEvent --
 *
 *	Process one event from the event queue, or invoke an asynchronous
 *	event handler. Operates on event queue for current thread.
 *
 * Results:
 *	The return value is 1 if the function actually found an event to
 *	process. If no processing occurred, then 0 is returned.
 *
 * Side effects:
 *	Invokes all of the event handlers for the highest priority event in
 *	the event queue. May collapse some events into a single event or
 *	discard stale events.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ServiceEvent(tls *libc.TLS, flags int32) (r int32) {
	/* Indicates what events should be processed.
	 * May be any combination of TCL_WINDOW_EVENTS
	 * TCL_FILE_EVENTS, TCL_TIMER_EVENTS, or other
	 * flags defined elsewhere. Events not
	 * matching this will be skipped for
	 * processing later. */
	var evPtr, prevPtr, proc, tsdPtr uintptr
	var eventCount TTcl_Size
	var result int32
	_, _, _, _, _, _ = evPtr, eventCount, prevPtr, proc, result, tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey8)), int64(104))
	/*
	 * Asynchronous event handlers are considered to be the highest priority
	 * events, and so must be invoked before we process events on the event
	 * queue.
	 */
	if XTcl_AsyncReady(tls) != 0 {
		XTcl_AsyncInvoke(tls, libc.UintptrFromInt32(0), 0)
		return int32(1)
	}
	/*
	 * No event flags is equivalent to TCL_ALL_EVENTS.
	 */
	if flags & ^(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) == 0 {
		flags |= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(1))
	}
	/*
	 * Loop through all the events in the queue until we find one that can
	 * actually be handled.
	 */
	XTcl_MutexLock(tls, tsdPtr+32)
	evPtr = (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FfirstEventPtr
	for {
		if !(evPtr != libc.UintptrFromInt32(0)) {
			break
		}
		/*
		 * Call the handler for the event. If it actually handles the event
		 * then free the storage for the event. There are two tricky things
		 * here, both stemming from the fact that the event code may be
		 * re-entered while servicing the event:
		 *
		 * 1. Set the "proc" field to NULL.  This is a signal to ourselves
		 *    that we shouldn't reexecute the handler if the event loop is
		 *    re-entered.
		 * 2. When freeing the event, must search the queue again from the
		 *    front to find it. This is because the event queue could change
		 *    almost arbitrarily while handling the event, so we can't depend
		 *    on pointers found now still being valid when the handler
		 *    returns.
		 */
		proc = (*TTcl_Event)(unsafe.Pointer(evPtr)).Fproc
		if proc == libc.UintptrFromInt32(0) {
			goto _1
		}
		(*TTcl_Event)(unsafe.Pointer(evPtr)).Fproc = libc.UintptrFromInt32(0)
		/*
		 * Release the lock before calling the event function. This allows
		 * other threads to post events if we enter a recursive event loop in
		 * this thread. Note that we are making the assumption that if the
		 * proc returns 0, the event is still in the list.
		 *
		 * The eventCount is remembered and set to zero that the next
		 * level of Tcl_ServiceEvent() gets an empty condition for the
		 * Tcl_ThreadQueueEvent() to perform optional wakeups.
		 * On exit of the next level, the eventCount is readjusted.
		 */
		eventCount = (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FeventCount
		(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FeventCount = 0
		XTcl_MutexUnlock(tls, tsdPtr+32)
		result = (*(*func(*libc.TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{proc})))(tls, evPtr, flags)
		XTcl_MutexLock(tls, tsdPtr+32)
		*(*TTcl_Size)(unsafe.Pointer(tsdPtr + 24)) += eventCount
		if result != 0 {
			/*
			 * The event was processed, so remove it from the queue.
			 */
			if (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FfirstEventPtr == evPtr {
				(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FfirstEventPtr = (*TTcl_Event)(unsafe.Pointer(evPtr)).FnextPtr
				if (*TTcl_Event)(unsafe.Pointer(evPtr)).FnextPtr == libc.UintptrFromInt32(0) {
					(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FlastEventPtr = libc.UintptrFromInt32(0)
				}
				if (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FmarkerEventPtr == evPtr {
					(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FmarkerEventPtr = libc.UintptrFromInt32(0)
				}
			} else {
				prevPtr = (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FfirstEventPtr
				for {
					if !(prevPtr != 0 && (*TTcl_Event)(unsafe.Pointer(prevPtr)).FnextPtr != evPtr) {
						break
					}
					/* Empty loop body. */
					goto _2
				_2:
					;
					prevPtr = (*TTcl_Event)(unsafe.Pointer(prevPtr)).FnextPtr
				}
				if prevPtr != 0 {
					(*TTcl_Event)(unsafe.Pointer(prevPtr)).FnextPtr = (*TTcl_Event)(unsafe.Pointer(evPtr)).FnextPtr
					if (*TTcl_Event)(unsafe.Pointer(evPtr)).FnextPtr == libc.UintptrFromInt32(0) {
						(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FlastEventPtr = prevPtr
					}
					if (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FmarkerEventPtr == evPtr {
						(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FmarkerEventPtr = prevPtr
					}
				} else {
					evPtr = libc.UintptrFromInt32(0)
				}
			}
			if evPtr != 0 {
				XTclpFree(tls, evPtr)
				(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FeventCount--
			}
			XTcl_MutexUnlock(tls, tsdPtr+32)
			return int32(1)
		} else {
			/*
			 * The event wasn't actually handled, so we have to restore the
			 * proc field to allow the event to be attempted again.
			 */
			(*TTcl_Event)(unsafe.Pointer(evPtr)).Fproc = proc
		}
		goto _1
	_1:
		;
		evPtr = (*TTcl_Event)(unsafe.Pointer(evPtr)).FnextPtr
	}
	XTcl_MutexUnlock(tls, tsdPtr+32)
	return 0
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetServiceMode --
 *
 *	This routine returns the current service mode of the notifier.
 *
 * Results:
 *	Returns either TCL_SERVICE_ALL or TCL_SERVICE_NONE.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetServiceMode(tls *libc.TLS) (r int32) {
	var tsdPtr uintptr
	_ = tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey8)), int64(104))
	return (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FserviceMode
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetServiceMode --
 *
 *	This routine sets the current service mode of the tsdPtr->
 *
 * Results:
 *	Returns the previous service mode.
 *
 * Side effects:
 *	Invokes the notifier service mode hook function.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetServiceMode(tls *libc.TLS, mode int32) (r int32) {
	/* New service mode: TCL_SERVICE_ALL or
	 * TCL_SERVICE_NONE */
	var oldMode int32
	var tsdPtr uintptr
	_, _ = oldMode, tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey8)), int64(104))
	oldMode = (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FserviceMode
	(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FserviceMode = mode
	XTcl_ServiceModeHook(tls, mode)
	return oldMode
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetMaxBlockTime --
 *
 *	This function is invoked by event sources to tell the notifier how
 *	long it may block the next time it blocks. The timePtr argument gives
 *	a maximum time; the actual time may be less if some other event source
 *	requested a smaller time.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	May reduce the length of the next sleep in the tsdPtr->
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetMaxBlockTime(tls *libc.TLS, timePtr uintptr) {
	/* Specifies a maximum elapsed time for the
	 * next blocking operation in the event
	 * tsdPtr-> */
	var tsdPtr uintptr
	_ = tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey8)), int64(104))
	if !((*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FblockTimeSet != 0) || (*TTcl_Time)(unsafe.Pointer(timePtr)).Fsec < (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FblockTime.Fsec || (*TTcl_Time)(unsafe.Pointer(timePtr)).Fsec == (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FblockTime.Fsec && (*TTcl_Time)(unsafe.Pointer(timePtr)).Fusec < (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FblockTime.Fusec {
		(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FblockTime = *(*TTcl_Time)(unsafe.Pointer(timePtr))
		(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FblockTimeSet = int32(1)
	}
	/*
	 * If we are called outside an event source traversal, set the timeout
	 * immediately.
	 */
	if !((*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FinTraversal != 0) {
		XTcl_SetTimer(tls, tsdPtr+48)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DoOneEvent --
 *
 *	Process a single event of some sort. If there's no work to do, wait
 *	for an event to occur, then process it.
 *
 * Results:
 *	The return value is 1 if the function actually found an event to
 *	process. If no processing occurred, then 0 is returned (this can
 *	happen if the TCL_DONT_WAIT flag is set or if there are no event
 *	handlers to wait for in the set specified by flags).
 *
 * Side effects:
 *	May delay execution of process while waiting for an event, unless
 *	TCL_DONT_WAIT is set in the flags argument. Event sources are invoked
 *	to check for and queue events. Event handlers may produce arbitrary
 *	side effects.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DoOneEvent(tls *libc.TLS, flags int32) (r int32) {
	/* Miscellaneous flag values: may be any
	 * combination of TCL_DONT_WAIT,
	 * TCL_WINDOW_EVENTS, TCL_FILE_EVENTS,
	 * TCL_TIMER_EVENTS, TCL_IDLE_EVENTS, or
	 * others defined by event sources. */
	var oldMode, result int32
	var sourcePtr, timePtr, tsdPtr uintptr
	_, _, _, _, _ = oldMode, result, sourcePtr, timePtr, tsdPtr
	result = 0
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey8)), int64(104))
	/*
	 * The first thing we do is to service any asynchronous event handlers.
	 */
	if XTcl_AsyncReady(tls) != 0 {
		XTcl_AsyncInvoke(tls, libc.UintptrFromInt32(0), 0)
		return int32(1)
	}
	/*
	 * No event flags is equivalent to TCL_ALL_EVENTS.
	 */
	if flags & ^(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) == 0 {
		flags |= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(1))
	}
	/*
	 * Set the service mode to none so notifier event routines won't try to
	 * service events recursively.
	 */
	oldMode = (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FserviceMode
	(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FserviceMode = TCL_SERVICE_NONE
	/*
	 * The core of this function is an infinite loop, even though we only
	 * service one event. The reason for this is that we may be processing
	 * events that don't do anything inside of Tcl.
	 */
	for int32(1) != 0 {
		/*
		 * If idle events are the only things to service, skip the main part
		 * of the loop and go directly to handle idle events (i.e. don't wait
		 * even if TCL_DONT_WAIT isn't set).
		 */
		if flags & ^(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) == libc.Int32FromInt32(1)<<libc.Int32FromInt32(5) {
			flags = libc.Int32FromInt32(1)<<libc.Int32FromInt32(5) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)
			goto idleEvents
		}
		/*
		 * Ask Tcl to service a queued event, if there are any.
		 */
		if XTcl_ServiceEvent(tls, flags) != 0 {
			result = int32(1)
			break
		}
		/*
		 * If TCL_DONT_WAIT is set, be sure to poll rather than blocking,
		 * otherwise reset the block time to infinity.
		 */
		if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
			(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FblockTime.Fsec = 0
			(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FblockTime.Fusec = 0
			(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FblockTimeSet = int32(1)
		} else {
			(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FblockTimeSet = 0
		}
		/*
		 * Set up all the event sources for new events. This will cause the
		 * block time to be updated if necessary.
		 */
		(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FinTraversal = int32(1)
		sourcePtr = (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FfirstEventSourcePtr
		for {
			if !(sourcePtr != libc.UintptrFromInt32(0)) {
				break
			}
			if (*TEventSource)(unsafe.Pointer(sourcePtr)).FsetupProc != 0 {
				(*(*func(*libc.TLS, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{(*TEventSource)(unsafe.Pointer(sourcePtr)).FsetupProc})))(tls, (*TEventSource)(unsafe.Pointer(sourcePtr)).FclientData, flags)
			}
			goto _1
		_1:
			;
			sourcePtr = (*TEventSource)(unsafe.Pointer(sourcePtr)).FnextPtr
		}
		(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FinTraversal = 0
		if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 || (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FblockTimeSet != 0 {
			timePtr = tsdPtr + 48
		} else {
			timePtr = libc.UintptrFromInt32(0)
		}
		/*
		 * Wait for a new event or a timeout. If Tcl_WaitForEvent returns -1,
		 * we should abort Tcl_DoOneEvent.
		 */
		result = XTcl_WaitForEvent(tls, timePtr)
		if result < 0 {
			result = 0
			break
		}
		/*
		 * Check all the event sources for new events.
		 */
		sourcePtr = (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FfirstEventSourcePtr
		for {
			if !(sourcePtr != libc.UintptrFromInt32(0)) {
				break
			}
			if (*TEventSource)(unsafe.Pointer(sourcePtr)).FcheckProc != 0 {
				(*(*func(*libc.TLS, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{(*TEventSource)(unsafe.Pointer(sourcePtr)).FcheckProc})))(tls, (*TEventSource)(unsafe.Pointer(sourcePtr)).FclientData, flags)
			}
			goto _2
		_2:
			;
			sourcePtr = (*TEventSource)(unsafe.Pointer(sourcePtr)).FnextPtr
		}
		/*
		 * Check for events queued by the notifier or event sources.
		 */
		if XTcl_ServiceEvent(tls, flags) != 0 {
			result = int32(1)
			break
		}
		/*
		 * We've tried everything at this point, but nobody we know about had
		 * anything to do. Check for idle events. If none, either quit or go
		 * back to the top and try again.
		 */
		goto idleEvents
	idleEvents:
		;
		if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(5)) != 0 {
			if XTclServiceIdle(tls) != 0 {
				result = int32(1)
				break
			}
		}
		if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
			break
		}
		/*
		 * If Tcl_WaitForEvent has returned 1, indicating that one system event
		 * has been dispatched (and thus that some Tcl code might have been
		 * indirectly executed), we break out of the loop in order, e.g.  to
		 * give vwait a chance to determine whether that system event had the
		 * side effect of changing the variable (so the vwait can return and
		 * unwind properly).
		 *
		 * NB: We will process idle events if any first, because otherwise we
		 *     might never do the idle events if the notifier always gets
		 *     system events.
		 */
		if result != 0 {
			break
		}
	}
	(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FserviceMode = oldMode
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ServiceAll --
 *
 *	This routine checks all of the event sources, processes events that
 *	are on the Tcl event queue, and then calls the any idle handlers.
 *	Platform specific notifier callbacks that generate events should call
 *	this routine before returning to the system in order to ensure that
 *	Tcl gets a chance to process the new events.
 *
 * Results:
 *	Returns 1 if an event or idle handler was invoked, else 0.
 *
 * Side effects:
 *	Anything that an event or idle handler may do.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ServiceAll(tls *libc.TLS) (r int32) {
	var result int32
	var sourcePtr, tsdPtr uintptr
	_, _, _ = result, sourcePtr, tsdPtr
	result = 0
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey8)), int64(104))
	if (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FserviceMode == TCL_SERVICE_NONE {
		return result
	}
	/*
	 * We need to turn off event servicing like we do in Tcl_DoOneEvent, to
	 * avoid recursive calls.
	 */
	(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FserviceMode = TCL_SERVICE_NONE
	/*
	 * Check async handlers first.
	 */
	if XTcl_AsyncReady(tls) != 0 {
		XTcl_AsyncInvoke(tls, libc.UintptrFromInt32(0), 0)
	}
	/*
	 * Make a single pass through all event sources, queued events, and idle
	 * handlers. Note that we wait to update the notifier timer until the end
	 * so we can avoid multiple changes.
	 */
	(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FinTraversal = int32(1)
	(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FblockTimeSet = 0
	sourcePtr = (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FfirstEventSourcePtr
	for {
		if !(sourcePtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TEventSource)(unsafe.Pointer(sourcePtr)).FsetupProc != 0 {
			(*(*func(*libc.TLS, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{(*TEventSource)(unsafe.Pointer(sourcePtr)).FsetupProc})))(tls, (*TEventSource)(unsafe.Pointer(sourcePtr)).FclientData, ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(1)))
		}
		goto _1
	_1:
		;
		sourcePtr = (*TEventSource)(unsafe.Pointer(sourcePtr)).FnextPtr
	}
	sourcePtr = (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FfirstEventSourcePtr
	for {
		if !(sourcePtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TEventSource)(unsafe.Pointer(sourcePtr)).FcheckProc != 0 {
			(*(*func(*libc.TLS, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{(*TEventSource)(unsafe.Pointer(sourcePtr)).FcheckProc})))(tls, (*TEventSource)(unsafe.Pointer(sourcePtr)).FclientData, ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(1)))
		}
		goto _2
	_2:
		;
		sourcePtr = (*TEventSource)(unsafe.Pointer(sourcePtr)).FnextPtr
	}
	for XTcl_ServiceEvent(tls, 0) != 0 {
		result = int32(1)
	}
	if XTclServiceIdle(tls) != 0 {
		result = int32(1)
	}
	if !((*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FblockTimeSet != 0) {
		XTcl_SetTimer(tls, libc.UintptrFromInt32(0))
	} else {
		XTcl_SetTimer(tls, tsdPtr+48)
	}
	(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FinTraversal = 0
	(*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FserviceMode = int32(TCL_SERVICE_ALL)
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ThreadAlert --
 *
 *	This function wakes up the notifier associated with the specified
 *	thread (if there is one).
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ThreadAlert(tls *libc.TLS, threadId TTcl_ThreadId) {
	/* Identifier for thread to use. */
	var tsdPtr uintptr
	_ = tsdPtr
	/*
	 * Find the notifier associated with the specified thread. Note that we
	 * need to hold the listLock while calling Tcl_AlertNotifier to avoid a
	 * race condition where the specified thread might destroy its notifier.
	 */
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_listLock)))
	tsdPtr = _firstNotifierPtr
	for {
		if !(tsdPtr != 0) {
			break
		}
		if (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FthreadId == threadId {
			XTcl_AlertNotifier(tls, (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FclientData)
			break
		}
		goto _1
	_1:
		;
		tsdPtr = (*TThreadSpecificData10)(unsafe.Pointer(tsdPtr)).FnextPtr
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_listLock)))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_InitNotifier --
 *
 *	Initializes the platform specific notifier state. Forwards to the
 *	platform implementation when the hook is not enabled.
 *
 * Results:
 *	Returns a handle to the notifier state for this thread..
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_InitNotifier(tls *libc.TLS) (r uintptr) {
	if _tclNotifierHooks.FinitNotifierProc != 0 {
		return (*(*func(*libc.TLS) uintptr)(unsafe.Pointer(&struct{ uintptr }{_tclNotifierHooks.FinitNotifierProc})))(tls)
	} else {
		return XTclpInitNotifier(tls)
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FinalizeNotifier --
 *
 *	This function is called to cleanup the notifier state before a thread
 *	is terminated. Forwards to the platform implementation when the hook
 *	is not enabled.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	If no finalizeNotifierProc notifier hook exists, TclpFinalizeNotifier
 *	is called.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FinalizeNotifier(tls *libc.TLS, clientData uintptr) {
	if _tclNotifierHooks.FfinalizeNotifierProc != 0 {
		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{_tclNotifierHooks.FfinalizeNotifierProc})))(tls, clientData)
	} else {
		XTclpFinalizeNotifier(tls, clientData)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_AlertNotifier --
 *
 *	Wake up the specified notifier from any thread. This routine is called
 *	by the platform independent notifier code whenever the Tcl_ThreadAlert
 *	routine is called. This routine is guaranteed not to be called by Tcl
 *	on a given notifier after Tcl_FinalizeNotifier is called for that
 *	notifier.  This routine is typically called from a thread other than
 *	the notifier's thread.  Forwards to the platform implementation when
 *	the hook is not enabled.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	See the platform-specific implementations.
 *
 *----------------------------------------------------------------------
 */

func XTcl_AlertNotifier(tls *libc.TLS, clientData uintptr) {
	/* Pointer to thread data. */
	if _tclNotifierHooks.FalertNotifierProc != 0 {
		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{_tclNotifierHooks.FalertNotifierProc})))(tls, clientData)
	} else {
		XTclpAlertNotifier(tls, clientData)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ServiceModeHook --
 *
 *	This function is invoked whenever the service mode changes.  Forwards
 *	to the platform implementation when the hook is not enabled.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	See the platform-specific implementations.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ServiceModeHook(tls *libc.TLS, mode int32) {
	/* Either TCL_SERVICE_ALL, or
	 * TCL_SERVICE_NONE. */
	if _tclNotifierHooks.FserviceModeHookProc != 0 {
		(*(*func(*libc.TLS, int32))(unsafe.Pointer(&struct{ uintptr }{_tclNotifierHooks.FserviceModeHookProc})))(tls, mode)
	} else {
		XTclpServiceModeHook(tls, mode)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetTimer --
 *
 *	This function sets the current notifier timer value.  Forwards to the
 *	platform implementation when the hook is not enabled.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	See the platform-specific implementations.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetTimer(tls *libc.TLS, timePtr uintptr) {
	/* Timeout value, may be NULL. */
	if _tclNotifierHooks.FsetTimerProc != 0 {
		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{_tclNotifierHooks.FsetTimerProc})))(tls, timePtr)
	} else {
		XTclpSetTimer(tls, timePtr)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_WaitForEvent --
 *
 *	This function is called by Tcl_DoOneEvent to wait for new events on
 *	the notifier's message queue.  If the block time is 0, then
 *	Tcl_WaitForEvent just polls without blocking.  Forwards to the
 *	platform implementation when the hook is not enabled.
 *
 * Results:
 *	Returns -1 if the wait would block forever, 1 if an out-of-loop source
 *	was processed (see platform-specific notes) and otherwise returns 0.
 *
 * Side effects:
 *	Queues file events that are detected by the notifier.
 *
 *----------------------------------------------------------------------
 */

func XTcl_WaitForEvent(tls *libc.TLS, timePtr uintptr) (r int32) {
	/* Maximum block time, or NULL. */
	if _tclNotifierHooks.FwaitForEventProc != 0 {
		return (*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{_tclNotifierHooks.FwaitForEventProc})))(tls, timePtr)
	} else {
		return XTclpWaitForEvent(tls, timePtr)
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_CreateFileHandler --
 *
 *	This function registers a file descriptor handler with the notifier.
 *	Forwards to the platform implementation when the hook is not enabled.
 *
 *	This function is not defined on Windows. The OS API there is too
 *	different.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Creates a new file handler structure.
 *
 *----------------------------------------------------------------------
 */

func XTcl_CreateFileHandler(tls *libc.TLS, fd int32, mask int32, proc uintptr, clientData uintptr) {
	/* Arbitrary data to pass to proc. */
	if _tclNotifierHooks.FcreateFileHandlerProc != 0 {
		(*(*func(*libc.TLS, int32, int32, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{_tclNotifierHooks.FcreateFileHandlerProc})))(tls, fd, mask, proc, clientData)
	} else {
		XTclpCreateFileHandler(tls, fd, mask, proc, clientData)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DeleteFileHandler --
 *
 *	Cancel a previously-arranged callback arrangement for a file
 *	descriptor.  Forwards to the platform implementation when the hook is
 *	not enabled.
 *
 *	This function is not defined on Windows. The OS API there is too
 *	different.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	If a callback was previously registered on the file descriptor, remove
 *	it.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DeleteFileHandler(tls *libc.TLS, fd int32) {
	/* Stream id for which to remove callback
	 * function. */
	if _tclNotifierHooks.FdeleteFileHandlerProc != 0 {
		(*(*func(*libc.TLS, int32))(unsafe.Pointer(&struct{ uintptr }{_tclNotifierHooks.FdeleteFileHandlerProc})))(tls, fd)
	} else {
		XTclpDeleteFileHandler(tls, fd)
	}
}

/*
 * Table of all object types.
 */

var _typeTable TTcl_HashTable
var _typeTableInitialized = int32(0) /* 0 means not yet initialized. */

var _tableMutex TTcl_Mutex

/*
 * All static variables used in this file are collected into a single instance
 * of the following structure.  For multi-threaded implementations, there is
 * one instance of this structure for each thread.
 *
 * Notice that different structures with the same name appear in other files.
 * The structure defined below is used in this file only.
 */

type TThreadSpecificData11 = struct {
	FlineCLPtr uintptr
}

var _dataKey9 TTcl_ThreadDataKey

/*
 * Nested Tcl_Obj deletion management support
 *
 * All context references used in the object freeing code are pointers to this
 * structure; every thread will have its own structure instance. The purpose
 * of this structure is to allow deeply nested collections of Tcl_Objs to be
 * freed without taking a vast depth of C stack (which could cause all sorts
 * of breakage.)
 */

type TPendingObjData = struct {
	FdeletionCount int32
	FdeletionStack uintptr
}

/*
 * These are separated out so that some semantic content is attached
 * to them.
 */

// C documentation
//
//	/*
//	 * Macro to set up the local reference to the deletion context.
//	 */
var _pendingObjDataKey TTcl_ThreadDataKey

func init() {
	p := unsafe.Pointer(&XtclBooleanType)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(XTclSetBooleanFromAny)
	*(*uintptr)(unsafe.Add(p, 48)) = __ccgo_fp(XTclLengthOne)
}

func init() {
	p := unsafe.Pointer(&XtclDoubleType)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_UpdateStringOfDouble)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_SetDoubleFromAny)
	*(*uintptr)(unsafe.Add(p, 48)) = __ccgo_fp(XTclLengthOne)
}

func init() {
	p := unsafe.Pointer(&XtclIntType)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_UpdateStringOfInt)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_SetIntFromAny)
	*(*uintptr)(unsafe.Add(p, 48)) = __ccgo_fp(XTclLengthOne)
}

func init() {
	p := unsafe.Pointer(&XtclBignumType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_FreeBignum)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_DupBignum)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_UpdateStringOfBignum)
	*(*uintptr)(unsafe.Add(p, 48)) = __ccgo_fp(XTclLengthOne)
}

func init() {
	p := unsafe.Pointer(&XtclObjHashKeyType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(XTclHashObjKey)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(XTclCompareObjKeys)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_AllocObjEntry)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(XTclFreeObjEntry)
}

func init() {
	p := unsafe.Pointer(&XtclCmdNameType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_FreeCmdNameInternalRep)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_DupCmdNameInternalRep)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_SetCmdNameFromAny)
}

/*
 * Structure containing a cached pointer to a command that is the result of
 * resolving the command's name in some namespace. It is the internal
 * representation for a cmdName object. It contains the pointer along with
 * some information that is used to check the pointer's validity.
 */

type TResolvedCmdName = struct {
	FcmdPtr        uintptr
	FrefNsPtr      uintptr
	FrefNsId       Tsize_t
	FrefNsCmdEpoch TTcl_Size
	FcmdEpoch      TTcl_Size
	FrefCount      Tsize_t
}

/*
 *-------------------------------------------------------------------------
 *
 * TclInitObjectSubsystem --
 *
 *	This function is invoked to perform once-only initialization of the
 *	type table. It also registers the object types defined in this file.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Initializes the table of defined object types "typeTable" with builtin
 *	object types defined in this file.
 *
 *-------------------------------------------------------------------------
 */

func XTclInitObjSubsystem(tls *libc.TLS) {
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_tableMutex)))
	_typeTableInitialized = int32(1)
	XTcl_InitHashTable(tls, uintptr(unsafe.Pointer(&_typeTable)), TCL_STRING_KEYS)
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_tableMutex)))
	XTcl_RegisterObjType(tls, uintptr(unsafe.Pointer(&XtclByteCodeType)))
	XTcl_RegisterObjType(tls, uintptr(unsafe.Pointer(&XtclCmdNameType)))
	XTcl_RegisterObjType(tls, uintptr(unsafe.Pointer(&XtclDictType)))
	XTcl_RegisterObjType(tls, uintptr(unsafe.Pointer(&XtclDoubleType)))
	XTcl_RegisterObjType(tls, uintptr(unsafe.Pointer(&XtclListType)))
	XTcl_RegisterObjType(tls, uintptr(unsafe.Pointer(&XtclProcBodyType)))
	XTcl_RegisterObjType(tls, uintptr(unsafe.Pointer(&XtclRegexpType)))
	XTcl_RegisterObjType(tls, uintptr(unsafe.Pointer(&XtclStringType)))
}

/*
 *----------------------------------------------------------------------
 *
 * TclFinalizeThreadObjects --
 *
 *	This function is called by Tcl_FinalizeThread to clean up thread
 *	specific Tcl_Obj information.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclFinalizeThreadObjects(tls *libc.TLS) {
}

/*
 *----------------------------------------------------------------------
 *
 * TclFinalizeObjects --
 *
 *	This function is called by Tcl_Finalize to clean up all registered
 *	Tcl_ObjType's and to reset the tclFreeObjList.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclFinalizeObjects(tls *libc.TLS) {
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_tableMutex)))
	if _typeTableInitialized != 0 {
		XTcl_DeleteHashTable(tls, uintptr(unsafe.Pointer(&_typeTable)))
		_typeTableInitialized = 0
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_tableMutex)))
	/*
	 * All we do here is reset the head pointer of the linked list of free
	 * Tcl_Obj's to NULL; the memory finalization will take care of releasing
	 * memory for us.
	 */
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&XtclObjMutex)))
	XtclFreeObjList = libc.UintptrFromInt32(0)
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&XtclObjMutex)))
}

/*
 *----------------------------------------------------------------------
 *
 * TclGetContLineTable --
 *
 *	This procedure is a helper which returns the thread-specific
 *	hash-table used to track continuation line information associated with
 *	Tcl_Obj*, and the objThreadMap, etc.
 *
 * Results:
 *	A reference to the thread-data.
 *
 * Side effects:
 *	May allocate memory for the thread-data.
 *
 * TIP #280
 *----------------------------------------------------------------------
 */

func _TclGetContLineTable(tls *libc.TLS) (r uintptr) {
	var tsdPtr uintptr
	_ = tsdPtr
	/*
	 * Initialize the hashtable tracking invisible continuation lines.  For
	 * the release we use a thread exit handler to ensure that this is done
	 * before TSD blocks are made invalid. The TclFinalizeObjects() which
	 * would be the natural place for this is invoked afterwards, meaning that
	 * we try to operate on a data structure already gone.
	 */
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey9)), int64(8))
	if !((*TThreadSpecificData11)(unsafe.Pointer(tsdPtr)).FlineCLPtr != 0) {
		(*TThreadSpecificData11)(unsafe.Pointer(tsdPtr)).FlineCLPtr = XTcl_Alloc(tls, uint64(104))
		XTcl_InitHashTable(tls, (*TThreadSpecificData11)(unsafe.Pointer(tsdPtr)).FlineCLPtr, int32(TCL_ONE_WORD_KEYS))
		XTcl_CreateThreadExitHandler(tls, __ccgo_fp(_TclThreadFinalizeContLines), libc.UintptrFromInt32(0))
	}
	return tsdPtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclContinuationsEnter --
 *
 *	This procedure is a helper which saves the continuation line
 *	information associated with a Tcl_Obj*.
 *
 * Results:
 *	A reference to the newly created continuation line location table.
 *
 * Side effects:
 *	Allocates memory for the table of continuation line locations.
 *
 * TIP #280
 *----------------------------------------------------------------------
 */

func XTclContinuationsEnter(tls *libc.TLS, objPtr uintptr, num TTcl_Size, loc uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var clLocPtr, hPtr, tsdPtr uintptr
	var _ /* newEntry at bp+0 */ int32
	_, _, _ = clLocPtr, hPtr, tsdPtr
	tsdPtr = _TclGetContLineTable(tls)
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TThreadSpecificData11)(unsafe.Pointer(tsdPtr)).FlineCLPtr)).FcreateProc})))(tls, (*TThreadSpecificData11)(unsafe.Pointer(tsdPtr)).FlineCLPtr, objPtr, bp)
	clLocPtr = XTcl_Alloc(tls, uint64(libc.UintptrFromInt32(0)+8)+libc.Uint64FromInt64(num+libc.Int64FromUint32(1))*uint64(8))
	if !(*(*int32)(unsafe.Pointer(bp)) != 0) {
		/*
		 * We're entering ContLineLoc data for the same value more than one
		 * time. Taking care not to leak the old entry.
		 *
		 * This can happen when literals in a proc body are shared. See for
		 * example test info-30.19 where the action (code) for all branches of
		 * the switch command is identical, mapping them all to the same
		 * literal. An interesting result of this is that the number and
		 * locations (offset) of invisible continuation lines in the literal
		 * are the same for all occurrences.
		 *
		 * Note that while reusing the existing entry is possible it requires
		 * the same actions as for a new entry because we have to copy the
		 * incoming num/loc data even so. Because we are called from
		 * TclContinuationsEnterDerived for this case, which modified the
		 * stored locations (Rebased to the proper relative offset). Just
		 * returning the stored entry would rebase them a second time, or
		 * more, hosing the data. It is easier to simply replace, as we are
		 * doing.
		 */
		XTclpFree(tls, (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData)
	}
	(*TContLineLoc)(unsafe.Pointer(clLocPtr)).Fnum = num
	libc.Xmemcpy(tls, clLocPtr+8, loc, libc.Uint64FromInt64(num)*uint64(8))
	*(*TTcl_Size)(unsafe.Pointer(clLocPtr + 8 + uintptr(num)*8)) = int64(-libc.Int32FromInt32(1)) /* Sentinel */
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = clLocPtr
	return clLocPtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclContinuationsEnterDerived --
 *
 *	This procedure is a helper which computes the continuation line
 *	information associated with a Tcl_Obj* cut from the middle of a
 *	script.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Allocates memory for the table of continuation line locations.
 *
 * TIP #280
 *----------------------------------------------------------------------
 */

func XTclContinuationsEnterDerived(tls *libc.TLS, objPtr uintptr, start TTcl_Size, clNext uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var clLocPtr, wordCLLast uintptr
	var end, i, num TTcl_Size
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _, _ = clLocPtr, end, i, num, wordCLLast
	wordCLLast = clNext
	/*
	 * We have to handle invisible continuations lines here as well, despite
	 * the code we have in TclSubstTokens (TST) for that. Why ?  Nesting. If
	 * our script is the sole argument to an 'eval' command, for example, the
	 * scriptCLLocPtr we are using was generated by a previous call to TST,
	 * and while the words we have here may contain continuation lines they
	 * are invisible already, and the inner call to TST had no bs+nl sequences
	 * to trigger its code.
	 *
	 * Luckily for us, the table we have to create here for the current word
	 * has to be a slice of the table currently in use, with the locations
	 * suitably modified to be relative to the start of the word instead of
	 * relative to the script.
	 *
	 * That is what we are doing now. Determine the slice we need, and if not
	 * empty, wrap it into a new table, and save the result into our
	 * thread-global hashtable, as usual.
	 */
	/*
	 * First compute the range of the word within the script. (Is there a
	 * better way which doesn't shimmer?)
	 */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
		_ = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		XTcl_GetStringFromObj(tls, objPtr, bp)
	}
	end = start + *(*TTcl_Size)(unsafe.Pointer(bp)) /* First char after the word */
	/*
	 * Then compute the table slice covering the range of the word.
	 */
	for *(*TTcl_Size)(unsafe.Pointer(wordCLLast)) >= 0 && *(*TTcl_Size)(unsafe.Pointer(wordCLLast)) < end {
		wordCLLast += 8
	}
	/*
	 * And generate the table from the slice, if it was not empty.
	 */
	num = (int64(wordCLLast) - int64(clNext)) / 8
	if num != 0 {
		clLocPtr = XTclContinuationsEnter(tls, objPtr, num, clNext)
		/*
		 * Re-base the locations.
		 */
		i = 0
		for {
			if !(i < num) {
				break
			}
			*(*TTcl_Size)(unsafe.Pointer(clLocPtr + 8 + uintptr(i)*8)) -= start
			/*
			 * Continuation lines coming before the string and affecting us
			 * should not happen, due to the proper maintenance of clNext
			 * during compilation.
			 */
			if *(*TTcl_Size)(unsafe.Pointer(clLocPtr + 8 + uintptr(i)*8)) < 0 {
				XTcl_Panic(tls, __ccgo_ts+54653, 0)
			}
			goto _2
		_2:
			;
			i++
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclContinuationsCopy --
 *
 *	This procedure is a helper which copies the continuation line
 *	information associated with a Tcl_Obj* to another Tcl_Obj*. It is
 *	assumed that both contain the same string/script. Use this when a
 *	script is duplicated because it was shared.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Allocates memory for the table of continuation line locations.
 *
 * TIP #280
 *----------------------------------------------------------------------
 */

func XTclContinuationsCopy(tls *libc.TLS, objPtr uintptr, originObjPtr uintptr) {
	var clLocPtr, hPtr, tsdPtr uintptr
	_, _, _ = clLocPtr, hPtr, tsdPtr
	tsdPtr = _TclGetContLineTable(tls)
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TThreadSpecificData11)(unsafe.Pointer(tsdPtr)).FlineCLPtr)).FfindProc})))(tls, (*TThreadSpecificData11)(unsafe.Pointer(tsdPtr)).FlineCLPtr, originObjPtr)
	if hPtr != 0 {
		clLocPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		XTclContinuationsEnter(tls, objPtr, (*TContLineLoc)(unsafe.Pointer(clLocPtr)).Fnum, clLocPtr+8)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclContinuationsGet --
 *
 *	This procedure is a helper which retrieves the continuation line
 *	information associated with a Tcl_Obj*, if it has any.
 *
 * Results:
 *	A reference to the continuation line location table, or NULL if the
 *	Tcl_Obj* has no such information associated with it.
 *
 * Side effects:
 *	None.
 *
 * TIP #280
 *----------------------------------------------------------------------
 */

func XTclContinuationsGet(tls *libc.TLS, objPtr uintptr) (r uintptr) {
	var hPtr, tsdPtr uintptr
	_, _ = hPtr, tsdPtr
	tsdPtr = _TclGetContLineTable(tls)
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TThreadSpecificData11)(unsafe.Pointer(tsdPtr)).FlineCLPtr)).FfindProc})))(tls, (*TThreadSpecificData11)(unsafe.Pointer(tsdPtr)).FlineCLPtr, objPtr)
	if !(hPtr != 0) {
		return libc.UintptrFromInt32(0)
	}
	return (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
}

/*
 *----------------------------------------------------------------------
 *
 * TclThreadFinalizeContLines --
 *
 *	This procedure is a helper which releases all continuation line
 *	information currently known. It is run as a thread exit handler.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Releases memory.
 *
 * TIP #280
 *----------------------------------------------------------------------
 */

func _TclThreadFinalizeContLines(tls *libc.TLS, dummy768 uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var hPtr, tsdPtr uintptr
	var _ /* hSearch at bp+0 */ TTcl_HashSearch
	_, _ = hPtr, tsdPtr
	/*
	 * Release the hashtable tracking invisible continuation lines.
	 */
	tsdPtr = _TclGetContLineTable(tls)
	hPtr = XTcl_FirstHashEntry(tls, (*TThreadSpecificData11)(unsafe.Pointer(tsdPtr)).FlineCLPtr, bp)
	for {
		if !(hPtr != libc.UintptrFromInt32(0)) {
			break
		}
		XTclpFree(tls, (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData)
		XTcl_DeleteHashEntry(tls, hPtr)
		goto _1
	_1:
		;
		hPtr = XTcl_NextHashEntry(tls, bp)
	}
	XTcl_DeleteHashTable(tls, (*TThreadSpecificData11)(unsafe.Pointer(tsdPtr)).FlineCLPtr)
	XTclpFree(tls, (*TThreadSpecificData11)(unsafe.Pointer(tsdPtr)).FlineCLPtr)
	(*TThreadSpecificData11)(unsafe.Pointer(tsdPtr)).FlineCLPtr = libc.UintptrFromInt32(0)
}

/*
 *--------------------------------------------------------------
 *
 * Tcl_RegisterObjType --
 *
 *	This function is called to register a new Tcl object type in the table
 *	of all object types supported by Tcl.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The type is registered in the Tcl type table. If there was already a
 *	type with the same name as in typePtr, it is replaced with the new
 *	type.
 *
 *--------------------------------------------------------------
 */

func XTcl_RegisterObjType(tls *libc.TLS, typePtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Information about object type; storage must
	 * be statically allocated (must live
	 * forever). */
	var _ /* isNew at bp+0 */ int32
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_tableMutex)))
	(*TTcl_HashEntry)(unsafe.Pointer((*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_typeTable)))).FcreateProc})))(tls, uintptr(unsafe.Pointer(&_typeTable)), (*TTcl_ObjType)(unsafe.Pointer(typePtr)).Fname, bp))).FclientData = typePtr
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_tableMutex)))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_AppendAllObjTypes --
 *
 *	This function appends onto the argument object the name of each object
 *	type as a list element. This includes the builtin object types (e.g.
 *	int, list) as well as those added using Tcl_NewObj. These names can be
 *	used, for example, with Tcl_GetObjType to get pointers to the
 *	corresponding Tcl_ObjType structures.
 *
 * Results:
 *	The return value is normally TCL_OK; in this case the object
 *	referenced by objPtr has each type name appended to it. If an error
 *	occurs, TCL_ERROR is returned and the interpreter's result holds an
 *	error message.
 *
 * Side effects:
 *	If necessary, the object referenced by objPtr is converted into a list
 *	object.
 *
 *----------------------------------------------------------------------
 */

func XTcl_AppendAllObjTypes(tls *libc.TLS, interp uintptr, objPtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Points to the Tcl object onto which the
	 * name of each registered type is appended as
	 * a list element. */
	var hPtr, v4 uintptr
	var v1 int32
	var v2 int64
	var _ /* numElems at bp+24 */ TTcl_Size
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _ = hPtr, v1, v2, v4
	/*
	 * Get the test for a valid list out of the way first.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr2)).FspanLength
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = v2
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjLength(tls, interp, objPtr, bp+24)
	}
	if v1 != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Type names are NUL-terminated, not counted strings. This code relies on
	 * that.
	 */
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_tableMutex)))
	hPtr = XTcl_FirstHashEntry(tls, uintptr(unsafe.Pointer(&_typeTable)), bp)
	for {
		if !(hPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_typeTable)))).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_typeTable)))).FkeyType == -int32(1) {
			v4 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
		} else {
			v4 = hPtr + 32
		}
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), objPtr, XTcl_NewStringObj(tls, v4, int64(-int32(1))))
		goto _3
	_3:
		;
		hPtr = XTcl_NextHashEntry(tls, bp)
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_tableMutex)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetObjType --
 *
 *	This function looks up an object type by name.
 *
 * Results:
 *	If an object type with name matching "typeName" is found, a pointer to
 *	its Tcl_ObjType structure is returned; otherwise, NULL is returned.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetObjType(tls *libc.TLS, typeName uintptr) (r uintptr) {
	/* Name of Tcl object type to look up. */
	var hPtr, typePtr uintptr
	_, _ = hPtr, typePtr
	typePtr = libc.UintptrFromInt32(0)
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_tableMutex)))
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_typeTable)))).FfindProc})))(tls, uintptr(unsafe.Pointer(&_typeTable)), typeName)
	if hPtr != libc.UintptrFromInt32(0) {
		typePtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_tableMutex)))
	return typePtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ConvertToType --
 *
 *	Convert the Tcl object "objPtr" to have type "typePtr" if possible.
 *
 * Results:
 *	The return value is TCL_OK on success and TCL_ERROR on failure. If
 *	TCL_ERROR is returned, then the interpreter's result contains an error
 *	message unless "interp" is NULL. Passing a NULL "interp" allows this
 *	function to be used as a test whether the conversion could be done
 *	(and in fact was done).
 *
 * Side effects:
 *	Any internal representation for the old type is freed.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ConvertToType(tls *libc.TLS, interp uintptr, objPtr uintptr, typePtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* The target type. */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == typePtr {
		return TCL_OK
	}
	/*
	 * Use the target type's Tcl_SetFromAnyProc to set "objPtr"s internal form
	 * as appropriate for the target type. This frees the old internal
	 * representation.
	 */
	if (*TTcl_ObjType)(unsafe.Pointer(typePtr)).FsetFromAnyProc == libc.UintptrFromInt32(0) {
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+54718, libc.VaList(bp+8, (*TTcl_ObjType)(unsafe.Pointer(typePtr)).Fname)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+54749, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	return (*(*func(*libc.TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer(typePtr)).FsetFromAnyProc})))(tls, interp, objPtr)
}

/*
 *--------------------------------------------------------------
 *
 * TclDbDumpActiveObjects --
 *
 *	This function is called to dump all of the active Tcl_Obj structs this
 *	allocator knows about.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *--------------------------------------------------------------
 */

func XTclDbDumpActiveObjects(tls *libc.TLS, dummy1010 uintptr) {
}

/*
 *----------------------------------------------------------------------
 *
 * TclDbInitNewObj --
 *
 *	Called via the TclNewObj or TclDbNewObj macros when TCL_MEM_DEBUG is
 *	enabled. This function will initialize the members of a Tcl_Obj
 *	struct. Initialization would be done inline via the TclNewObj macro
 *	when compiling without TCL_MEM_DEBUG.
 *
 * Results:
 *	The Tcl_Obj struct members are initialized.
 *
 * Side effects:
 *	None.
 *----------------------------------------------------------------------
 */

/*
 *----------------------------------------------------------------------
 *
 * Tcl_NewObj --
 *
 *	This function is normally called when not debugging: i.e., when
 *	TCL_MEM_DEBUG is not defined. It creates new Tcl objects that denote
 *	the empty string. These objects have a NULL object type and NULL
 *	string representation byte pointer. Type managers call this routine to
 *	allocate new objects that they further initialize.
 *
 *	When TCL_MEM_DEBUG is defined, this function just returns the result
 *	of calling the debugging version Tcl_DbNewObj.
 *
 * Results:
 *	The result is a newly allocated object that represents the empty
 *	string. The new object's typePtr is set NULL and its ref count is set
 *	to 0.
 *
 * Side effects:
 *	If compiling with TCL_COMPILE_STATS, this function increments the
 *	global count of allocated objects (tclObjsAlloced).
 *
 *----------------------------------------------------------------------
 */

func XTcl_NewObj(tls *libc.TLS) (r uintptr) {
	var cachePtr, objPtr uintptr
	var v1 bool
	_, _, _ = cachePtr, objPtr, v1
	/*
	 * Use the macro defined in tclInt.h - it will use the correct allocator.
	 */
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	return objPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DbNewObj --
 *
 *	This function is normally called when debugging: i.e., when
 *	TCL_MEM_DEBUG is defined. It creates new Tcl objects that denote the
 *	empty string. It is the same as the Tcl_NewObj function above except
 *	that it calls Tcl_DbCkalloc directly with the file name and line
 *	number from its caller. This simplifies debugging since then the
 *	[memory active] command will report the correct file name and line
 *	number when reporting objects that haven't been freed.
 *
 *	When TCL_MEM_DEBUG is not defined, this function just returns the
 *	result of calling Tcl_NewObj.
 *
 * Results:
 *	The result is a newly allocated that represents the empty string. The
 *	new object's typePtr is set NULL and its ref count is set to 0.
 *
 * Side effects:
 *	If compiling with TCL_COMPILE_STATS, this function increments the
 *	global count of allocated objects (tclObjsAlloced).
 *
 *----------------------------------------------------------------------
 */

func XTcl_DbNewObj(tls *libc.TLS, dummy1183 uintptr, dummy1184 int32) (r uintptr) {
	var cachePtr, objPtr uintptr
	var v1 bool
	_, _, _ = cachePtr, objPtr, v1
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	return objPtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclAllocateFreeObjects --
 *
 *	Function to allocate a number of free Tcl_Objs. This is done using a
 *	single Tcl_Alloc to reduce the overhead for Tcl_Obj allocation.
 *
 *	Assumes mutex is held.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	tclFreeObjList, the head of the list of free Tcl_Objs, is set to the
 *	first of a number of free Tcl_Obj's linked together by their
 *	internalRep.twoPtrValue.ptr1's.
 *
 *----------------------------------------------------------------------
 */

func XTclAllocateFreeObjects(tls *libc.TLS) {
	var basePtr, objPtr, prevPtr uintptr
	var bytesToAlloc Tsize_t
	var i int32
	_, _, _, _, _ = basePtr, bytesToAlloc, i, objPtr, prevPtr
	bytesToAlloc = libc.Uint64FromInt32(100) * libc.Uint64FromInt64(48)
	/*
	 * This has been noted by Purify to be a potential leak. The problem is
	 * that Tcl, when not TCL_MEM_DEBUG compiled, keeps around all allocated
	 * Tcl_Obj's, pointed to by tclFreeObjList, when freed instead of actually
	 * freeing the memory. TclFinalizeObjects() does not Tcl_Free() this memory,
	 * but leaves it to Tcl's memory subsystem finalization to release it.
	 * Purify apparently can't figure that out, and fires a false alarm.
	 */
	basePtr = XTcl_Alloc(tls, bytesToAlloc)
	prevPtr = libc.UintptrFromInt32(0)
	objPtr = basePtr
	i = 0
	for {
		if !(i < int32(100)) {
			break
		}
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1 = prevPtr
		prevPtr = objPtr
		objPtr += 48
		goto _1
	_1:
		;
		i++
	}
	XtclFreeObjList = prevPtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclFreeObj --
 *
 *	This function frees the memory associated with the argument object.
 *	It is called by the tcl.h macro Tcl_DecrRefCount when an object's ref
 *	count is zero. It is only "public" since it must be callable by that
 *	macro wherever the macro is used. It should not be directly called by
 *	clients.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Deallocates the storage for the object's Tcl_Obj structure after
 *	deallocating the string representation and calling the type-specific
 *	Tcl_FreeInternalRepProc to deallocate the object's internal
 *	representation. If compiling with TCL_COMPILE_STATS, this function
 *	increments the global count of freed objects (tclObjsFreed).
 *
 *----------------------------------------------------------------------
 */

func XTclFreeObj(tls *libc.TLS, objPtr uintptr) {
	/* The object to be freed. */
	var _isobjPtr, cachePtr, cachePtr1, cachePtr2, context, hPtr, objToFree, tsdPtr uintptr
	var v1, v2, v3 bool
	_, _, _, _, _, _, _, _, _, _, _ = _isobjPtr, cachePtr, cachePtr1, cachePtr2, context, hPtr, objToFree, tsdPtr, v1, v2, v3
	/*
	 * Invalidate the string rep first so we can use the bytes value for our
	 * pointer chain, and signal an obj deletion (as opposed to shimmering)
	 * with 'length == -1'.
	 */
	_isobjPtr = objPtr
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(-libc.Int32FromInt32(1))
	if !((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != 0) {
		/*
		 * objPtr can be freed safely, as it will not attempt to free any
		 * other objects: it will not cause recursive calls to this function.
		 */
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
			XTclThreadFreeObj(tls, objPtr)
		} else {
			(*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = objPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
		}
	} else {
		/*
		 * This macro declares a variable, so must come here...
		 */
		context = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_pendingObjDataKey)), int64(16))
		if (*TPendingObjData)(unsafe.Pointer(context)).FdeletionCount > 0 {
			/* The string rep is already invalidated so we can use the bytes value      * for our pointer chain: push onto the head of the stack. */ (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = (*TPendingObjData)(unsafe.Pointer(context)).FdeletionStack
			(*TPendingObjData)(unsafe.Pointer(context)).FdeletionStack = objPtr
		} else {
			/*
			 * Note that the contents of the while loop assume that the string
			 * rep has already been freed and we don't want to do anything
			 * fancy with adding to the queue inside ourselves. Must take care
			 * to unstack the object first since freeing the internal rep can
			 * add further objects to the stack. The code assumes that it is
			 * the first thing in a block; all current usages in the core
			 * satisfy this.
			 */
			(*TPendingObjData)(unsafe.Pointer(context)).FdeletionCount++
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc})))(tls, objPtr)
			(*TPendingObjData)(unsafe.Pointer(context)).FdeletionCount--
			if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v2 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, objPtr)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = objPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
			}
			(*TPendingObjData)(unsafe.Pointer(context)).FdeletionCount++
			for (*TPendingObjData)(unsafe.Pointer(context)).FdeletionStack != libc.UintptrFromInt32(0) {
				objToFree = (*TPendingObjData)(unsafe.Pointer(context)).FdeletionStack
				(*TPendingObjData)(unsafe.Pointer(context)).FdeletionStack = (*TTcl_Obj)(unsafe.Pointer(objToFree)).Fbytes
				if (*TTcl_Obj)(unsafe.Pointer(objToFree)).FtypePtr != libc.UintptrFromInt32(0) && (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objToFree)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
					(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objToFree)).FtypePtr)).FfreeIntRepProc})))(tls, objToFree)
				}
				if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
					cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, objToFree)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(objToFree + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = objToFree
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
				}
			}
			(*TPendingObjData)(unsafe.Pointer(context)).FdeletionCount--
		}
	}
	/*
	 * We cannot use TclGetContinuationTable() here, because that may
	 * re-initialize the thread-data for calls coming after the finalization.
	 * We have to access it using the low-level call and then check for
	 * validity. This function can be called after TclFinalizeThreadData() has
	 * already killed the thread-global data structures. Performing
	 * TCL_TSD_INIT will leave us with an uninitialized memory block upon
	 * which we crash (if we where to access the uninitialized hashtable).
	 */
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey9)), int64(8))
	if (*TThreadSpecificData11)(unsafe.Pointer(tsdPtr)).FlineCLPtr != 0 {
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TThreadSpecificData11)(unsafe.Pointer(tsdPtr)).FlineCLPtr)).FfindProc})))(tls, (*TThreadSpecificData11)(unsafe.Pointer(tsdPtr)).FlineCLPtr, objPtr)
		if hPtr != 0 {
			XTclpFree(tls, (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData)
			XTcl_DeleteHashEntry(tls, hPtr)
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclObjBeingDeleted --
 *
 *	This function returns 1 when the Tcl_Obj is being deleted. It is
 *	provided for the rare cases where the reason for the loss of an
 *	internal rep might be relevant. [FR 1512138]
 *
 * Results:
 *	1 if being deleted, 0 otherwise.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclObjBeingDeleted(tls *libc.TLS, objPtr uintptr) (r int32) {
	return libc.BoolInt32((*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength == int64(-libc.Int32FromInt32(1)))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DuplicateObj --
 *
 *	Create and return a new object that is a duplicate of the argument
 *	object.
 *
 * Results:
 *	The return value is a pointer to a newly created Tcl_Obj. This object
 *	has reference count 0 and the same type, if any, as the source object
 *	objPtr. Also:
 *	  1) If the source object has a valid string rep, we copy it;
 *	     otherwise, the duplicate's string rep is set NULL to mark it
 *	     invalid.
 *	  2) If the source object has an internal representation (i.e. its
 *	     typePtr is non-NULL), the new object's internal rep is set to a
 *	     copy; otherwise the new internal rep is marked invalid.
 *
 * Side effects:
 *	What constitutes "copying" the internal representation depends on the
 *	type. For example, if the argument object is a list, the element
 *	objects it points to will not actually be copied but will be shared
 *	with the duplicate list. That is, the ref counts of the element
 *	objects will be incremented.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DuplicateObj(tls *libc.TLS, objPtr uintptr) (r uintptr) {
	/* The object to duplicate. */
	var bytes, cachePtr, dupPtr, typePtr, v2 uintptr
	var v1 bool
	_, _, _, _, _, _ = bytes, cachePtr, dupPtr, typePtr, v1, v2
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		dupPtr = XTclThreadAllocObj(tls)
	} else {
		dupPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(dupPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(dupPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(dupPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(dupPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(dupPtr)).FtypePtr = libc.UintptrFromInt32(0)
	typePtr = (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr
	bytes = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	if bytes != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength == 0 {
			(*TTcl_Obj)(unsafe.Pointer(dupPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(dupPtr)).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(dupPtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64((*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength+libc.Int64FromUint32(1)))
			if bytes != 0 {
				v2 = bytes
			} else {
				v2 = uintptr(unsafe.Pointer(&XtclEmptyString))
			}
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(dupPtr)).Fbytes, v2, libc.Uint64FromInt64((*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dupPtr)).Fbytes + uintptr((*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(dupPtr)).Flength = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
		}
	} else {
		(*TTcl_Obj)(unsafe.Pointer(dupPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
	if typePtr != 0 {
		if (*TTcl_ObjType)(unsafe.Pointer(typePtr)).FdupIntRepProc != 0 {
			(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer(typePtr)).FdupIntRepProc})))(tls, objPtr, dupPtr)
		} else {
			(*TTcl_Obj)(unsafe.Pointer(dupPtr)).FinternalRep = (*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep
			(*TTcl_Obj)(unsafe.Pointer(dupPtr)).FtypePtr = typePtr
		}
	}
	return dupPtr
}

func XTclSetDuplicateObj(tls *libc.TLS, dupPtr uintptr, objPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _isobjPtr, bytes, typePtr, v1 uintptr
	_, _, _, _ = _isobjPtr, bytes, typePtr, v1
	if (*TTcl_Obj)(unsafe.Pointer(dupPtr)).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+10229, libc.VaList(bp+8, __ccgo_ts+54759))
	}
	_isobjPtr = dupPtr
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
	if (*TTcl_Obj)(unsafe.Pointer(dupPtr)).FtypePtr != libc.UintptrFromInt32(0) {
		if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dupPtr)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dupPtr)).FtypePtr)).FfreeIntRepProc})))(tls, dupPtr)
		}
		(*TTcl_Obj)(unsafe.Pointer(dupPtr)).FtypePtr = libc.UintptrFromInt32(0)
	}
	typePtr = (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr
	bytes = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	if bytes != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength == 0 {
			(*TTcl_Obj)(unsafe.Pointer(dupPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(dupPtr)).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(dupPtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64((*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength+libc.Int64FromUint32(1)))
			if bytes != 0 {
				v1 = bytes
			} else {
				v1 = uintptr(unsafe.Pointer(&XtclEmptyString))
			}
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(dupPtr)).Fbytes, v1, libc.Uint64FromInt64((*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dupPtr)).Fbytes + uintptr((*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(dupPtr)).Flength = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
		}
	} else {
		(*TTcl_Obj)(unsafe.Pointer(dupPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
	if typePtr != 0 {
		if (*TTcl_ObjType)(unsafe.Pointer(typePtr)).FdupIntRepProc != 0 {
			(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer(typePtr)).FdupIntRepProc})))(tls, objPtr, dupPtr)
		} else {
			(*TTcl_Obj)(unsafe.Pointer(dupPtr)).FinternalRep = (*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep
			(*TTcl_Obj)(unsafe.Pointer(dupPtr)).FtypePtr = typePtr
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetString --
 *
 *	Returns the string representation byte array pointer for an object.
 *
 * Results:
 *	Returns a pointer to the string representation of objPtr. The byte
 *	array referenced by the returned pointer must not be modified by the
 *	caller. Furthermore, the caller must copy the bytes if they need to
 *	retain them since the object's string rep can change as a result of
 *	other operations.
 *
 * Side effects:
 *	May call the object's updateStringProc to update the string
 *	representation from the internal representation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetString(tls *libc.TLS, objPtr uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Object whose string rep byte pointer should
	 * be returned. */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes == libc.UintptrFromInt32(0) {
		/*
		 * Note we do not check for objPtr->typePtr == NULL.  An invariant
		 * of a properly maintained Tcl_Obj is that at least  one of
		 * objPtr->bytes and objPtr->typePtr must not be NULL.  If broken
		 * extensions fail to maintain that invariant, we can crash here.
		 */
		if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FupdateStringProc == libc.UintptrFromInt32(0) {
			/*
			 * Those Tcl_ObjTypes which choose not to define an
			 * updateStringProc must be written in such a way that
			 * (objPtr->bytes) never becomes NULL.
			 */
			XTcl_Panic(tls, __ccgo_ts+54778, libc.VaList(bp+8, (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).Fname))
		}
		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FupdateStringProc})))(tls, objPtr)
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes == libc.UintptrFromInt32(0) || (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength == int64(-libc.Int32FromInt32(1)) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr((*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength)))) != int32('\000') {
			XTcl_Panic(tls, __ccgo_ts+54829, libc.VaList(bp+8, (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).Fname))
		}
	}
	return (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetStringFromObj/TclGetStringFromObj --
 *
 *	Returns the string representation's byte array pointer and length for
 *	an object.
 *
 * Results:
 *	Returns a pointer to the string representation of objPtr. If lengthPtr
 *	isn't NULL, the length of the string representation is stored at
 *	*lengthPtr. The byte array referenced by the returned pointer must not
 *	be modified by the caller. Furthermore, the caller must copy the bytes
 *	if they need to retain them since the object's string rep can change
 *	as a result of other operations.
 *
 * Side effects:
 *	May call the object's updateStringProc to update the string
 *	representation from the internal representation.
 *
 *----------------------------------------------------------------------
 */

func XTclGetStringFromObj(tls *libc.TLS, objPtr uintptr, lengthPtr uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* If non-NULL, the location where the string
	 * rep's byte array length should * be stored.
	 * If NULL, no length is stored. */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes == libc.UintptrFromInt32(0) {
		/*
		 * Note we do not check for objPtr->typePtr == NULL.  An invariant
		 * of a properly maintained Tcl_Obj is that at least  one of
		 * objPtr->bytes and objPtr->typePtr must not be NULL.  If broken
		 * extensions fail to maintain that invariant, we can crash here.
		 */
		if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FupdateStringProc == libc.UintptrFromInt32(0) {
			/*
			 * Those Tcl_ObjTypes which choose not to define an
			 * updateStringProc must be written in such a way that
			 * (objPtr->bytes) never becomes NULL.
			 */
			XTcl_Panic(tls, __ccgo_ts+54778, libc.VaList(bp+8, (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).Fname))
		}
		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FupdateStringProc})))(tls, objPtr)
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes == libc.UintptrFromInt32(0) || (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength == int64(-libc.Int32FromInt32(1)) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr((*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength)))) != int32('\000') {
			XTcl_Panic(tls, __ccgo_ts+54829, libc.VaList(bp+8, (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).Fname))
		}
	}
	if lengthPtr != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength > int64(INT_MAX) {
			XTcl_Panic(tls, __ccgo_ts+54896, 0)
		}
		*(*int32)(unsafe.Pointer(lengthPtr)) = int32((*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength)
	}
	return (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
}

func XTcl_GetStringFromObj(tls *libc.TLS, objPtr uintptr, lengthPtr uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* If non-NULL, the location where the string
	 * rep's byte array length should * be stored.
	 * If NULL, no length is stored. */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes == libc.UintptrFromInt32(0) {
		/*
		 * Note we do not check for objPtr->typePtr == NULL.  An invariant
		 * of a properly maintained Tcl_Obj is that at least  one of
		 * objPtr->bytes and objPtr->typePtr must not be NULL.  If broken
		 * extensions fail to maintain that invariant, we can crash here.
		 */
		if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FupdateStringProc == libc.UintptrFromInt32(0) {
			/*
			 * Those Tcl_ObjTypes which choose not to define an
			 * updateStringProc must be written in such a way that
			 * (objPtr->bytes) never becomes NULL.
			 */
			XTcl_Panic(tls, __ccgo_ts+54778, libc.VaList(bp+8, (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).Fname))
		}
		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FupdateStringProc})))(tls, objPtr)
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes == libc.UintptrFromInt32(0) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr((*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength)))) != int32('\000') {
			XTcl_Panic(tls, __ccgo_ts+54829, libc.VaList(bp+8, (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).Fname))
		}
	}
	if lengthPtr != libc.UintptrFromInt32(0) {
		*(*TTcl_Size)(unsafe.Pointer(lengthPtr)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
	}
	return (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_InitStringRep --
 *
 *	This function is called in several configurations to provide all
 *	the tools needed to set an object's string representation. The
 *	function is determined by the arguments.
 *
 *	(objPtr->bytes != NULL && bytes != NULL) || (numBytes == -1)
 *	    Invalid call -- panic!
 *
 *	objPtr->bytes == NULL && bytes == NULL && numBytes != -1
 *	    Allocation only - allocate space for (numBytes+1) chars.
 *	    store in objPtr->bytes and return. Also sets
 *	    objPtr->length to 0 and objPtr->bytes[0] to NUL.
 *
 *	objPtr->bytes == NULL && bytes != NULL && numBytes != -1
 *	    Allocate and copy. bytes is assumed to point to chars to
 *	    copy into the string rep. objPtr->length = numBytes. Allocate
 *	    array of (numBytes + 1) chars. store in objPtr->bytes. Copy
 *	    numBytes chars from bytes to objPtr->bytes; Set
 *	    objPtr->bytes[numBytes] to NUL and return objPtr->bytes.
 *	    Caller must guarantee there are numBytes chars at bytes to
 *	    be copied.
 *
 *	objPtr->bytes != NULL && bytes == NULL && numBytes != -1
 *	    Truncate.  Set objPtr->length to numBytes and
 *	    objPr->bytes[numBytes] to NUL.  Caller has to guarantee
 *	    that a prior allocating call allocated enough bytes for
 *	    this to be valid. Return objPtr->bytes.
 *
 *	Caller is expected to ascertain that the bytes copied into
 *	the string rep make up complete valid UTF-8 characters.
 *
 * Results:
 *	A pointer to the string rep of objPtr.
 *
 * Side effects:
 *	As described above.
 *
 *----------------------------------------------------------------------
 */

func XTcl_InitStringRep(tls *libc.TLS, objPtr uintptr, bytes uintptr, numBytes Tsize_t) (r uintptr) {
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes == libc.UintptrFromInt32(0) {
		/* Start with no string rep */
		if numBytes == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(libc.Int32FromInt32(0))
			return (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		} else {
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = XTclpAlloc(tls, numBytes+uint64(1))
			if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
				(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = libc.Int64FromUint64(numBytes)
				if bytes != 0 {
					libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, bytes, numBytes)
				}
				*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr((*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength))) = uint8('\000')
			}
		}
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes == uintptr(unsafe.Pointer(&XtclEmptyString)) {
			/* Start with empty string rep (not allocated) */
			if numBytes == uint64(0) {
				return (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
			} else {
				(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = XTclpAlloc(tls, numBytes+uint64(1))
				if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
					(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = libc.Int64FromUint64(numBytes)
					*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr((*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength))) = uint8('\000')
				}
			}
		} else {
			/* Start with non-empty string rep (allocated) */
			if numBytes == uint64(0) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes)
				(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(libc.Int32FromInt32(0))
				return (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
			} else {
				(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = XTclpRealloc(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, numBytes+uint64(1))
				if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
					(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = libc.Int64FromUint64(numBytes)
					*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr((*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength))) = uint8('\000')
				}
			}
		}
	}
	return (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_InvalidateStringRep --
 *
 *	This function is called to invalidate an object's string
 *	representation.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Deallocates the storage for any old string representation, then sets
 *	the string representation NULL to mark it invalid.
 *
 *----------------------------------------------------------------------
 */

func XTcl_InvalidateStringRep(tls *libc.TLS, objPtr uintptr) {
	/* Object whose string rep byte pointer should
	 * be freed. */
	var _isobjPtr uintptr
	_ = _isobjPtr
	_isobjPtr = objPtr
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_HasStringRep --
 *
 *	This function reports whether object has a string representation.
 *
 * Results:
 *	Boolean.
 *----------------------------------------------------------------------
 */

func XTcl_HasStringRep(tls *libc.TLS, objPtr uintptr) (r int32) {
	/* Object to test */
	return libc.BoolInt32((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != libc.UintptrFromInt32(0))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_StoreInternalRep --
 *
 *	Called to set the object's internal representation to match a
 *	particular type.
 *
 *	It is the caller's responsibility to guarantee that
 *	the value of the submitted internalrep is in agreement with
 *	the value of any existing string rep.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Calls the freeIntRepProc of the current Tcl_ObjType, if any.
 *	Sets the internalRep and typePtr fields to the submitted values.
 *
 *----------------------------------------------------------------------
 */

func XTcl_StoreInternalRep(tls *libc.TLS, objPtr uintptr, typePtr uintptr, irPtr uintptr) {
	/* New internalrep for the object */
	/* Clear out any existing internalrep ( "shimmer" ) */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != libc.UintptrFromInt32(0) {
		if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc})))(tls, objPtr)
		}
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	}
	/* When irPtr == NULL, just leave objPtr with no internalrep for typePtr */
	if irPtr != 0 {
		/* Copy the new internalrep into place */
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep = *(*TTcl_ObjInternalRep)(unsafe.Pointer(irPtr))
		/* Set the type to match */
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = typePtr
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FetchInternalRep --
 *
 *	This function is called to retrieve the object's internal
 *	representation matching a requested type, if any.
 *
 * Results:
 *	A read-only pointer to the associated Tcl_ObjInternalRep, or
 *	NULL if no such internal representation exists.
 *
 * Side effects:
 *	Calls the freeIntRepProc of the current Tcl_ObjType, if any.
 *	Sets the internalRep and typePtr fields to the submitted values.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FetchInternalRep(tls *libc.TLS, objPtr uintptr, typePtr uintptr) (r uintptr) {
	/* Requested type */
	var v1 uintptr
	_ = v1
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == typePtr {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	return v1
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FreeInternalRep --
 *
 *	This function is called to free an object's internal representation.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Calls the freeIntRepProc of the current Tcl_ObjType, if any.
 *	Sets typePtr field to NULL.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FreeInternalRep(tls *libc.TLS, objPtr uintptr) {
	/* Object whose internal rep should be freed. */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != libc.UintptrFromInt32(0) {
		if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc})))(tls, objPtr)
		}
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetBoolFromObj, Tcl_GetBooleanFromObj --
 *
 *	Attempt to return a boolean from the Tcl object "objPtr". This
 *	includes conversion from any of Tcl's numeric types.
 *
 * Results:
 *	The return value is a standard Tcl object result. If an error occurs
 *	during conversion, an error message is left in the interpreter's
 *	result unless "interp" is NULL.
 *
 * Side effects:
 *	The internalrep of *objPtr may be changed.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetBoolFromObj(tls *libc.TLS, interp uintptr, objPtr uintptr, flags int32, charPtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Place to store resulting boolean. */
	var _objPtr, cachePtr, lengthProc, v11, v12, v13, v2, v4 uintptr
	var result int32
	var v1, v14 bool
	var v3 TTcl_Size
	var _ /* d at bp+8 */ float64
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, lengthProc, result, v1, v11, v12, v13, v14, v2, v3, v4
	if flags&int32(TCL_NULL_OK) != 0 && (objPtr == libc.UintptrFromInt32(0) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(XTcl_GetString(tls, objPtr)))) == int32('\000')) {
		result = -int32(1)
		goto boolEnd
	} else {
		if objPtr == libc.UintptrFromInt32(0) {
			if interp != 0 {
				if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
					objPtr = XTclThreadAllocObj(tls)
				} else {
					objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(objPtr + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
				(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
				if flags&int32(TCL_NULL_OK) != 0 {
					v2 = __ccgo_ts + 54993
				} else {
					v2 = __ccgo_ts + 55013
				}
				XTclParseNumber(tls, interp, objPtr, v2, libc.UintptrFromInt32(0), int64(-libc.Int32FromInt32(1)), libc.UintptrFromInt32(0), 0)
				_objPtr = objPtr
				v4 = _objPtr
				v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
				*(*TTcl_Size)(unsafe.Pointer(v4))--
				if v3 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
			return int32(TCL_ERROR)
		}
	}
_7:
	;
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) || (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclBooleanType)) {
		result = libc.BoolInt32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) != 0)
		goto boolEnd
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
		if XTcl_GetDoubleFromObj(tls, interp, objPtr, bp+8) != TCL_OK {
			return int32(TCL_ERROR)
		}
		result = libc.BoolInt32(*(*float64)(unsafe.Pointer(bp + 8)) != float64(0))
		goto boolEnd
	}
	if !((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclBignumType))) {
		goto _8
	}
	result = int32(1)
	goto boolEnd
boolEnd:
	;
	if charPtr != libc.UintptrFromInt32(0) {
		flags &= libc.Int32FromInt32(TCL_NULL_OK) - libc.Int32FromInt32(2)
		if flags != 0 {
			if flags == libc.Int32FromInt64(4) {
				*(*int32)(unsafe.Pointer(charPtr)) = result
				return TCL_OK
			} else {
				if flags == libc.Int32FromInt64(2) {
					*(*int16)(unsafe.Pointer(charPtr)) = int16(result)
					return TCL_OK
				} else {
					XTcl_Panic(tls, __ccgo_ts+55027, libc.VaList(bp+24, __ccgo_ts+55049))
				}
			}
		}
		*(*uint8)(unsafe.Pointer(charPtr)) = libc.Uint8FromInt32(result)
	}
	return TCL_OK
_8:
	;
	/* Handle dict separately, because it doesn't have a lengthProc */
	if !((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDictType))) {
		goto _9
	}
	XTcl_DictObjSize(tls, libc.UintptrFromInt32(0), objPtr, bp)
	if !(*(*TTcl_Size)(unsafe.Pointer(bp)) > 0) {
		goto _10
	}
	goto listRep
listRep:
	;
	if interp != 0 {
		if flags&int32(TCL_NULL_OK) != 0 {
			v11 = __ccgo_ts + 55068
		} else {
			v11 = __ccgo_ts + 1945
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+55075, libc.VaList(bp+24, v11)))
	}
	return int32(TCL_ERROR)
_10:
	;
_9:
	;
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+48) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+48) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).Fversion) {
		v12 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FlengthProc
	} else {
		v12 = libc.UintptrFromInt32(0)
	}
	lengthProc = v12
	if lengthProc != 0 && (*(*func(*libc.TLS, uintptr) TTcl_Size)(unsafe.Pointer(&struct{ uintptr }{lengthProc})))(tls, objPtr) != int64(1) {
		goto listRep
	}
	goto _6
_6:
	;
	if v14 = _ParseBoolean(tls, objPtr) == TCL_OK; !v14 {
		if flags&int32(TCL_NULL_OK) != 0 {
			v13 = __ccgo_ts + 54993
		} else {
			v13 = __ccgo_ts + 55013
		}
	}
	if v14 || TCL_OK == XTclParseNumber(tls, interp, objPtr, v13, libc.UintptrFromInt32(0), int64(-int32(1)), libc.UintptrFromInt32(0), 0) {
		goto _7
	}
	goto _5
_5:
	;
	return int32(TCL_ERROR)
}

func XTcl_GetBooleanFromObj(tls *libc.TLS, interp uintptr, objPtr uintptr, intPtr uintptr) (r int32) {
	/* Place to store resulting boolean. */
	return XTcl_GetBoolFromObj(tls, interp, objPtr, (libc.Int32FromInt32(TCL_NULL_OK)-libc.Int32FromInt32(2))&libc.Int32FromInt64(4), intPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * TclSetBooleanFromAny --
 *
 *	Attempt to generate a boolean internal form for the Tcl object
 *	"objPtr".
 *
 * Results:
 *	The return value is a standard Tcl result. If an error occurs during
 *	conversion, an error message is left in the interpreter's result
 *	unless "interp" is NULL.
 *
 * Side effects:
 *	If no error occurs, an integer 1 or 0 is stored as "objPtr"s internal
 *	representation and the type of "objPtr" is set to boolean or int.
 *
 *----------------------------------------------------------------------
 */

func XTclSetBooleanFromAny(tls *libc.TLS, interp uintptr, objPtr uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* The object to convert. */
	var cachePtr, msg, str uintptr
	var v1 bool
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _ = cachePtr, msg, str, v1
	/*
	 * For some "pure" numeric Tcl_ObjTypes (no string rep), we can determine
	 * whether a boolean conversion is possible without generating the string
	 * rep.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
			if libc.Uint64FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep))) < uint64(2) {
				return TCL_OK
			}
			goto badBoolean
		}
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclBignumType)) {
			goto badBoolean
		}
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
			goto badBoolean
		}
	}
	if _ParseBoolean(tls, objPtr) == TCL_OK {
		return TCL_OK
	}
	goto badBoolean
badBoolean:
	;
	if interp != libc.UintptrFromInt32(0) {
		str = XTcl_GetStringFromObj(tls, objPtr, bp)
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			msg = XTclThreadAllocObj(tls)
		} else {
			msg = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(msg + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(msg)).FrefCount = 0
		if libc.Uint64FromInt64(33)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(msg)).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(33)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes, __ccgo_ts+55115, libc.Uint64FromInt64(33)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(msg)).Fbytes + uintptr(libc.Uint64FromInt64(33)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(msg)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(33) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer(msg)).FtypePtr = libc.UintptrFromInt32(0)
		XTcl_AppendLimitedToObj(tls, msg, str, *(*TTcl_Size)(unsafe.Pointer(bp)), int64(50), __ccgo_ts+1945)
		XTcl_AppendToObj(tls, msg, __ccgo_ts+14586, int64(-int32(1)))
		XTcl_SetObjResult(tls, interp, msg)
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+55148, libc.UintptrFromInt32(0)))
	}
	return int32(TCL_ERROR)
}

func _ParseBoolean(tls *libc.TLS, objPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The object to parse/convert. */
	var c uint8
	var i TTcl_Size
	var newBool int32
	var str uintptr
	var _ /* length at bp+8 */ TTcl_Size
	var _ /* lowerCase at bp+0 */ [6]uint8
	_, _, _, _ = c, i, newBool, str
	str = XTcl_GetStringFromObj(tls, objPtr, bp+8)
	if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) < int64(1) || *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > int64(5) {
		/*
		 * Longest valid boolean string rep. is "false".
		 */
		return int32(TCL_ERROR)
	}
	switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) {
	case int32('0'):
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(1) {
			newBool = 0
			goto numericBoolean
		}
		return int32(TCL_ERROR)
	case int32('1'):
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == int64(1) {
			newBool = int32(1)
			goto numericBoolean
		}
		return int32(TCL_ERROR)
	}
	/*
	 * Force to lower case for case-insensitive detection. Filter out known
	 * invalid characters at the same time.
	 */
	i = 0
	for {
		if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) {
			break
		}
		c = *(*uint8)(unsafe.Pointer(str + uintptr(i)))
		switch libc.Int32FromUint8(c) {
		case int32('A'):
			fallthrough
		case int32('E'):
			fallthrough
		case int32('F'):
			fallthrough
		case int32('L'):
			fallthrough
		case int32('N'):
			fallthrough
		case int32('O'):
			fallthrough
		case int32('R'):
			fallthrough
		case int32('S'):
			fallthrough
		case int32('T'):
			fallthrough
		case int32('U'):
			fallthrough
		case int32('Y'):
			(*(*[6]uint8)(unsafe.Pointer(bp)))[i] = libc.Uint8FromInt32(libc.Int32FromUint8(c) + libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromUint8('a')-libc.Int32FromUint8('A'))))
		case int32('a'):
			fallthrough
		case int32('e'):
			fallthrough
		case int32('f'):
			fallthrough
		case int32('l'):
			fallthrough
		case int32('n'):
			fallthrough
		case int32('o'):
			fallthrough
		case int32('r'):
			fallthrough
		case int32('s'):
			fallthrough
		case int32('t'):
			fallthrough
		case int32('u'):
			fallthrough
		case int32('y'):
			(*(*[6]uint8)(unsafe.Pointer(bp)))[i] = c
		default:
			return int32(TCL_ERROR)
		}
		goto _1
	_1:
		;
		i++
	}
	(*(*[6]uint8)(unsafe.Pointer(bp)))[*(*TTcl_Size)(unsafe.Pointer(bp + 8))] = uint8(0)
	switch libc.Int32FromUint8((*(*[6]uint8)(unsafe.Pointer(bp)))[0]) {
	case int32('y'):
		/*
		 * Checking the 'y' is redundant, but makes the code clearer.
		 */
		if libc.Xstrncmp(tls, bp, __ccgo_ts+55156, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))) == 0 {
			newBool = int32(1)
			goto goodBoolean
		}
		return int32(TCL_ERROR)
	case int32('n'):
		if libc.Xstrncmp(tls, bp, __ccgo_ts+55160, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))) == 0 {
			newBool = 0
			goto goodBoolean
		}
		return int32(TCL_ERROR)
	case int32('t'):
		if libc.Xstrncmp(tls, bp, __ccgo_ts+19233, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))) == 0 {
			newBool = int32(1)
			goto goodBoolean
		}
		return int32(TCL_ERROR)
	case int32('f'):
		if libc.Xstrncmp(tls, bp, __ccgo_ts+19227, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))) == 0 {
			newBool = 0
			goto goodBoolean
		}
		return int32(TCL_ERROR)
	case int32('o'):
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) < int64(2) {
			return int32(TCL_ERROR)
		}
		if libc.Xstrncmp(tls, bp, __ccgo_ts+20802, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))) == 0 {
			newBool = int32(1)
			goto goodBoolean
		} else {
			if libc.Xstrncmp(tls, bp, __ccgo_ts+55163, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))) == 0 {
				newBool = 0
				goto goodBoolean
			}
		}
		return int32(TCL_ERROR)
	default:
		return int32(TCL_ERROR)
	}
	/*
	 * Free the old internalRep before setting the new one. We do this as late
	 * as possible to allow the conversion code, in particular
	 * Tcl_GetStringFromObj, to use that old internalRep.
	 */
	goto goodBoolean
goodBoolean:
	;
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != libc.UintptrFromInt32(0) {
		if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc})))(tls, objPtr)
		}
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	}
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) = int64(newBool)
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclBooleanType))
	return TCL_OK
	goto numericBoolean
numericBoolean:
	;
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != libc.UintptrFromInt32(0) {
		if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc})))(tls, objPtr)
		}
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	}
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) = int64(newBool)
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_NewDoubleObj --
 *
 *	This function is normally called when not debugging: i.e., when
 *	TCL_MEM_DEBUG is not defined. It creates a new double object and
 *	initializes it from the argument double value.
 *
 *	When TCL_MEM_DEBUG is defined, this function just returns the result
 *	of calling the debugging version Tcl_DbNewDoubleObj.
 *
 * Results:
 *	The newly created object is returned. This object will have an
 *	invalid string representation. The returned object has ref count 0.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_NewDoubleObj(tls *libc.TLS, dblValue float64) (r uintptr) {
	/* Double used to initialize the object. */
	var cachePtr, objPtr uintptr
	var v1 bool
	_, _, _ = cachePtr, objPtr, v1
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = libc.UintptrFromInt32(0)
	*(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) = dblValue
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclDoubleType))
	return objPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DbNewDoubleObj --
 *
 *	This function is normally called when debugging: i.e., when
 *	TCL_MEM_DEBUG is defined. It creates new double objects. It is the
 *	same as the Tcl_NewDoubleObj function above except that it calls
 *	Tcl_DbCkalloc directly with the file name and line number from its
 *	caller. This simplifies debugging since then the [memory active]
 *	command will report the correct file name and line number when
 *	reporting objects that haven't been freed.
 *
 *	When TCL_MEM_DEBUG is not defined, this function just returns the
 *	result of calling Tcl_NewDoubleObj.
 *
 * Results:
 *	The newly created object is returned. This object will have an invalid
 *	string representation. The returned object has ref count 0.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DbNewDoubleObj(tls *libc.TLS, dblValue float64, dummy2378 uintptr, dummy2379 int32) (r uintptr) {
	return XTcl_NewDoubleObj(tls, dblValue)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetDoubleObj --
 *
 *	Modify an object to be a double object and to have the specified
 *	double value.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The object's old string rep, if any, is freed. Also, any old internal
 *	rep is freed.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetDoubleObj(tls *libc.TLS, objPtr uintptr, dblValue float64) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Double used to set the object's value. */
	var _isobjPtr uintptr
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_ = _isobjPtr
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+10229, libc.VaList(bp+24, __ccgo_ts+55167))
	}
	*(*float64)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp)))) = dblValue
	_isobjPtr = objPtr
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
	XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&XtclDoubleType)), bp)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetDoubleFromObj --
 *
 *	Attempt to return a double from the Tcl object "objPtr". If the object
 *	is not already a double, an attempt will be made to convert it to one.
 *
 * Results:
 *	The return value is a standard Tcl object result. If an error occurs
 *	during conversion, an error message is left in the interpreter's
 *	result unless "interp" is NULL.
 *
 * Side effects:
 *	If the object is not already a double, the conversion will free any
 *	old internal representation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetDoubleFromObj(tls *libc.TLS, interp uintptr, objPtr uintptr, dblPtr uintptr) (r int32) {
	bp := tls.Alloc(96)
	defer tls.Free(96) /* Place to store resulting double. */
	var bignumObj, lengthProc, v8 uintptr
	var bignumPayload int32
	var v4 uint64
	var _ /* __u at bp+0 */ struct {
		F__i [0]uint64
		F__f float64
	}
	var _ /* big at bp+16 */ Tmp_int
	var _ /* length at bp+8 */ TTcl_Size
	_, _, _, _, _ = bignumObj, bignumPayload, lengthProc, v4, v8
_3:
	;
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
		*(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep))
		v4 = *(*uint64)(unsafe.Pointer(bp))
		goto _5
	_5:
		if libc.BoolInt32(v4&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) > libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
			if interp != libc.UintptrFromInt32(0) {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+55184, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+48, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+55221, __ccgo_ts+55228, libc.UintptrFromInt32(0)))
			}
			return int32(TCL_ERROR)
		}
		*(*float64)(unsafe.Pointer(dblPtr)) = *(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep))
		return TCL_OK
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*float64)(unsafe.Pointer(dblPtr)) = float64(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)))
		return TCL_OK
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclBignumType)) {
		bignumObj = objPtr
		bignumPayload = int32(int64((*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(bignumObj + 32))).Fptr2))
		if bignumPayload == -int32(1) {
			*(*Tmp_int)(unsafe.Pointer(bp + 16)) = *(*Tmp_int)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(bignumObj + 32))).Fptr1))
		} else {
			(*(*Tmp_int)(unsafe.Pointer(bp + 16))).Fdp = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(bignumObj + 32))).Fptr1
			(*(*Tmp_int)(unsafe.Pointer(bp + 16))).Fsign = bignumPayload >> int32(30)
			(*(*Tmp_int)(unsafe.Pointer(bp + 16))).Falloc = bignumPayload >> int32(15) & int32(0x7FFF)
			(*(*Tmp_int)(unsafe.Pointer(bp + 16))).Fused = bignumPayload & int32(0x7FFF)
		}
		*(*float64)(unsafe.Pointer(dblPtr)) = XTclBignumToDouble(tls, bp+16)
		return TCL_OK
	}
	/* Handle dict separately, because it doesn't have a lengthProc */
	if !((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDictType))) {
		goto _6
	}
	XTcl_DictObjSize(tls, libc.UintptrFromInt32(0), objPtr, bp+8)
	if !(*(*TTcl_Size)(unsafe.Pointer(bp + 8)) > 0) {
		goto _7
	}
	goto listRep
listRep:
	;
	if interp != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+55232, int64(-libc.Int32FromInt32(1))))
	}
	return int32(TCL_ERROR)
_7:
	;
_6:
	;
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+48) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+48) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).Fversion) {
		v8 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FlengthProc
	} else {
		v8 = libc.UintptrFromInt32(0)
	}
	lengthProc = v8
	if lengthProc != 0 && (*(*func(*libc.TLS, uintptr) TTcl_Size)(unsafe.Pointer(&struct{ uintptr }{lengthProc})))(tls, objPtr) != int64(1) {
		goto listRep
	}
	goto _2
_2:
	;
	if _SetDoubleFromAny(tls, interp, objPtr) == TCL_OK {
		goto _3
	}
	goto _1
_1:
	;
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * SetDoubleFromAny --
 *
 *	Attempt to generate an double-precision floating point internal form
 *	for the Tcl object "objPtr".
 *
 * Results:
 *	The return value is a standard Tcl object result. If an error occurs
 *	during conversion, an error message is left in the interpreter's
 *	result unless "interp" is NULL.
 *
 * Side effects:
 *	If no error occurs, a double is stored as "objPtr"s internal
 *	representation.
 *
 *----------------------------------------------------------------------
 */

func _SetDoubleFromAny(tls *libc.TLS, interp uintptr, objPtr uintptr) (r int32) {
	/* The object to convert. */
	return XTclParseNumber(tls, interp, objPtr, __ccgo_ts+55278, libc.UintptrFromInt32(0), int64(-int32(1)), libc.UintptrFromInt32(0), 0)
}

/*
 *----------------------------------------------------------------------
 *
 * UpdateStringOfDouble --
 *
 *	Update the string representation for a double-precision floating point
 *	object. Note: This function does not free an
 *	existing old string rep so storage will be lost if this has not
 *	already been done.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The object's string is set to a valid string that results from the
 *	double-to-string conversion.
 *
 *----------------------------------------------------------------------
 */

func _UpdateStringOfDouble(tls *libc.TLS, objPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Double obj with string rep to update. */
	var dst uintptr
	var v1, v2 bool
	_, _, _ = dst, v1, v2
	dst = XTcl_InitStringRep(tls, objPtr, libc.UintptrFromInt32(0), libc.Uint64FromInt32(libc.Int32FromInt32(TCL_MAX_PREC)+libc.Int32FromInt32(10)))
	if v2 = libc.Bool(libc.Int32FromInt32(TCL_MAX_PREC)+libc.Int32FromInt32(10)+libc.Int32FromInt32(1) != 0); v2 {
		if v1 = dst != 0; !v1 {
			XTcl_Panic(tls, __ccgo_ts+10479, libc.VaList(bp+8, libc.Uint64FromInt32(libc.Int32FromInt32(TCL_MAX_PREC)+libc.Int32FromInt32(10)+libc.Int32FromInt32(1))))
		}
	}
	_ = v2 && (v1 || libc.Bool(libc.Int32FromInt32(1) != 0))
	XTcl_PrintDouble(tls, libc.UintptrFromInt32(0), *(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)), dst)
	XTcl_InitStringRep(tls, objPtr, libc.UintptrFromInt32(0), libc.Xstrlen(tls, dst))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetIntFromObj --
 *
 *	Retrieve the integer value of 'objPtr'.
 *
 * Value
 *
 *	TCL_OK
 *
 *	    Success.
 *
 *	TCL_ERROR
 *
 *	    An error occurred during conversion or the integral value can not
 *	    be represented as an integer (it might be too large). An error
 *	    message is left in the interpreter's result if 'interp' is not
 *	    NULL.
 *
 * Effect
 *
 *	'objPtr' is converted to an integer if necessary if it is not one
 *	already.  The conversion frees any previously-existing internal
 *	representation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetIntFromObj(tls *libc.TLS, interp uintptr, objPtr uintptr, intPtr uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Place to store resulting int. */
	var s uintptr
	var v1 int32
	var _ /* l at bp+0 */ int64
	_, _ = s, v1
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*int64)(unsafe.Pointer(bp)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep))
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_GetLongFromObj(tls, interp, objPtr, bp)
	}
	if v1 != TCL_OK {
		return int32(TCL_ERROR)
	}
	if libc.Bool(libc.Uint64FromUint64(2)*libc.Uint64FromInt64(0x7fffffffffffffff)+libc.Uint64FromInt32(1) > uint64(0xffffffff)) && (*(*int64)(unsafe.Pointer(bp)) > libc.Int64FromUint32(0xffffffff) || *(*int64)(unsafe.Pointer(bp)) < int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff))) {
		if interp != libc.UintptrFromInt32(0) {
			s = __ccgo_ts + 11737
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, s, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+8919, __ccgo_ts+55300, s, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	*(*int32)(unsafe.Pointer(intPtr)) = int32(*(*int64)(unsafe.Pointer(bp)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * SetIntFromAny --
 *
 *	Attempts to force the internal representation for a Tcl object to
 *	tclIntType, specifically.
 *
 * Results:
 *	The return value is a standard object Tcl result. If an error occurs
 *	during conversion, an error message is left in the interpreter's
 *	result unless "interp" is NULL.
 *
 *----------------------------------------------------------------------
 */

func _SetIntFromAny(tls *libc.TLS, interp uintptr, objPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Pointer to the object to convert */
	var v1 int32
	var _ /* w at bp+0 */ TTcl_WideInt
	_ = v1
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*TTcl_WideInt)(unsafe.Pointer(bp)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep))
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_GetWideIntFromObj(tls, interp, objPtr, bp)
	}
	return v1
}

/*
 *----------------------------------------------------------------------
 *
 * UpdateStringOfInt --
 *
 *	Update the string representation for an integer object. Note: This
 *	function does not free an existing old string rep so storage will be
 *	lost if this has not already been done.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The object's string is set to a valid string that results from the
 *	int-to-string conversion.
 *
 *----------------------------------------------------------------------
 */

func _UpdateStringOfInt(tls *libc.TLS, objPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Int object whose string rep to update. */
	var dst uintptr
	var v1, v2 bool
	_, _, _ = dst, v1, v2
	dst = XTcl_InitStringRep(tls, objPtr, libc.UintptrFromInt32(0), libc.Uint64FromInt32(libc.Int32FromInt32(3)*libc.Int32FromInt64(8)))
	if v2 = libc.Bool(libc.Int32FromInt32(3)*libc.Int32FromInt64(8)+libc.Int32FromInt32(1) != 0); v2 {
		if v1 = dst != 0; !v1 {
			XTcl_Panic(tls, __ccgo_ts+10479, libc.VaList(bp+8, libc.Uint64FromInt32(libc.Int32FromInt32(3)*libc.Int32FromInt64(8)+libc.Int32FromInt32(1))))
		}
	}
	_ = v2 && (v1 || libc.Bool(libc.Int32FromInt32(1) != 0))
	XTcl_InitStringRep(tls, objPtr, libc.UintptrFromInt32(0), libc.Uint64FromInt64(XTclFormatInt(tls, dst, *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)))))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetLongFromObj --
 *
 *	Attempt to return an long integer from the Tcl object "objPtr". If the
 *	object is not already an int object, an attempt will be made to
 *	convert it to one.
 *
 * Results:
 *	The return value is a standard Tcl object result. If an error occurs
 *	during conversion, an error message is left in the interpreter's
 *	result unless "interp" is NULL.
 *
 * Side effects:
 *	If the object is not already an int object, the conversion will free
 *	any old internal representation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetLongFromObj(tls *libc.TLS, interp uintptr, objPtr uintptr, longPtr uintptr) (r int32) {
	bp := tls.Alloc(96)
	defer tls.Free(96) /* Place to store resulting long. */
	var bignumObj, bytes, lengthProc, msg, s, v4, v6, v9 uintptr
	var bignumPayload int32
	var value uint64
	var v5 Tsize_t
	var _ /* big at bp+8 */ Tmp_int
	var _ /* length at bp+0 */ TTcl_Size
	var _ /* numBytes at bp+40 */ Tsize_t
	var _ /* scratch at bp+32 */ uint64
	_, _, _, _, _, _, _, _, _, _, _ = bignumObj, bignumPayload, bytes, lengthProc, msg, s, value, v4, v5, v6, v9
_3:
	;
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*int64)(unsafe.Pointer(longPtr)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep))
		return TCL_OK
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
		if interp != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
				v4 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
			} else {
				v4 = XTcl_GetString(tls, objPtr)
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+55310, libc.VaList(bp+56, v4)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+56, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+55340, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclBignumType)) {
		/*
		 * Must check for those bignum values that can fit in a long, even
		 * when auto-narrowing is enabled. Only those values in the signed
		 * long range get auto-narrowed to tclIntType, while all the
		 * values in the unsigned long range will fit in a long.
		 */
		value = uint64(0)
		bytes = bp + 32
		bignumObj = objPtr
		bignumPayload = int32(int64((*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(bignumObj + 32))).Fptr2))
		if bignumPayload == -int32(1) {
			*(*Tmp_int)(unsafe.Pointer(bp + 8)) = *(*Tmp_int)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(bignumObj + 32))).Fptr1))
		} else {
			(*(*Tmp_int)(unsafe.Pointer(bp + 8))).Fdp = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(bignumObj + 32))).Fptr1
			(*(*Tmp_int)(unsafe.Pointer(bp + 8))).Fsign = bignumPayload >> int32(30)
			(*(*Tmp_int)(unsafe.Pointer(bp + 8))).Falloc = bignumPayload >> int32(15) & int32(0x7FFF)
			(*(*Tmp_int)(unsafe.Pointer(bp + 8))).Fused = bignumPayload & int32(0x7FFF)
		}
		if XTclBN_mp_to_ubin(tls, bp+8, bytes, uint64(8), bp+40) == MP_OKAY {
			for {
				v5 = *(*Tsize_t)(unsafe.Pointer(bp + 40))
				*(*Tsize_t)(unsafe.Pointer(bp + 40))--
				if !(v5 > uint64(0)) {
					break
				}
				v6 = bytes
				bytes++
				value = value<<int32(CHAR_BIT) | uint64(*(*uint8)(unsafe.Pointer(v6)))
			}
			if (*(*Tmp_int)(unsafe.Pointer(bp + 8))).Fsign != 0 {
				if value <= libc.Uint64FromInt32(1)+libc.Uint64FromInt64(0x7fffffffffffffff) {
					*(*int64)(unsafe.Pointer(longPtr)) = libc.Int64FromUint64(-value)
					return TCL_OK
				}
			} else {
				if value <= libc.Uint64FromUint64(2)*libc.Uint64FromInt64(0x7fffffffffffffff)+libc.Uint64FromInt32(1) {
					*(*int64)(unsafe.Pointer(longPtr)) = libc.Int64FromUint64(value)
					return TCL_OK
				}
			}
		}
		if interp != libc.UintptrFromInt32(0) {
			s = __ccgo_ts + 11737
			msg = XTcl_NewStringObj(tls, s, int64(-int32(1)))
			XTcl_SetObjResult(tls, interp, msg)
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+56, __ccgo_ts+8919, __ccgo_ts+55300, s, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	/* Handle dict separately, because it doesn't have a lengthProc */
	if !((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDictType))) {
		goto _7
	}
	XTcl_DictObjSize(tls, libc.UintptrFromInt32(0), objPtr, bp)
	if !(*(*TTcl_Size)(unsafe.Pointer(bp)) > 0) {
		goto _8
	}
	goto listRep
listRep:
	;
	if interp != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+55348, int64(-int32(1))))
	}
	return int32(TCL_ERROR)
_8:
	;
_7:
	;
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+48) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+48) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).Fversion) {
		v9 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FlengthProc
	} else {
		v9 = libc.UintptrFromInt32(0)
	}
	lengthProc = v9
	if lengthProc != 0 && (*(*func(*libc.TLS, uintptr) TTcl_Size)(unsafe.Pointer(&struct{ uintptr }{lengthProc})))(tls, objPtr) != int64(1) {
		goto listRep
	}
	goto _2
_2:
	;
	if XTclParseNumber(tls, interp, objPtr, __ccgo_ts+6223, libc.UintptrFromInt32(0), int64(-int32(1)), libc.UintptrFromInt32(0), int32(TCL_PARSE_INTEGER_ONLY)) == TCL_OK {
		goto _3
	}
	goto _1
_1:
	;
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_NewWideIntObj --
 *
 *	If a client is compiled with TCL_MEM_DEBUG defined, calls to
 *	Tcl_NewWideIntObj to create a new 64-bit integer object end up calling
 *	the debugging function Tcl_DbNewWideIntObj instead.
 *
 *	Otherwise, if the client is compiled without TCL_MEM_DEBUG defined,
 *	calls to Tcl_NewWideIntObj result in a call to one of the two
 *	Tcl_NewWideIntObj implementations below. We provide two
 *	implementations so that the Tcl core can be compiled to do memory
 *	debugging of the core even if a client does not request it for itself.
 *
 * Results:
 *	The newly created object is returned. This object will have an invalid
 *	string representation. The returned object has ref count 0.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_NewWideIntObj(tls *libc.TLS, wideValue TTcl_WideInt) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	/* Wide integer used to initialize the new
	 * object. */
	var _isobjPtr, cachePtr, objPtr uintptr
	var v1 bool
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_, _, _, _ = _isobjPtr, cachePtr, objPtr, v1
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp)))) = wideValue
	_isobjPtr = objPtr
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
	XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&XtclIntType)), bp)
	return objPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_NewWideUIntObj --
 *
 * Results:
 *	The newly created object is returned. This object will have an invalid
 *	string representation. The returned object has ref count 0.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_NewWideUIntObj(tls *libc.TLS, uwideValue TTcl_WideUInt) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	/* Wide integer used to initialize the new
	 * object. */
	var cachePtr, objPtr uintptr
	var uw_ TTcl_WideUInt
	var v1 bool
	var _ /* bignumValue_ at bp+0 */ Tmp_int
	_, _, _, _ = cachePtr, objPtr, uw_, v1
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = libc.UintptrFromInt32(0)
	uw_ = uwideValue
	if uw_ > libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) {
		if XTclBN_mp_init_u64(tls, bp, uw_) != MP_OKAY {
			XTcl_Panic(tls, __ccgo_ts+13273, libc.VaList(bp+32, __ccgo_ts+13293))
		}
		XTclSetBignumInternalRep(tls, objPtr, bp)
	} else {
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) = libc.Int64FromUint64(uw_)
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	}
	return objPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DbNewWideIntObj --
 *
 *	If a client is compiled with TCL_MEM_DEBUG defined, calls to
 *	Tcl_NewWideIntObj to create new wide integer end up calling the
 *	debugging function Tcl_DbNewWideIntObj instead. We provide two
 *	implementations of Tcl_DbNewWideIntObj so that whether the Tcl core is
 *	compiled to do memory debugging of the core is independent of whether
 *	a client requests debugging for itself.
 *
 *	When the core is compiled with TCL_MEM_DEBUG defined,
 *	Tcl_DbNewWideIntObj calls Tcl_DbCkalloc directly with the file name
 *	and line number from its caller. This simplifies debugging since then
 *	the checkmem command will report the caller's file name and line
 *	number when reporting objects that haven't been freed.
 *
 *	Otherwise, when the core is compiled without TCL_MEM_DEBUG defined,
 *	this function just returns the result of calling Tcl_NewWideIntObj.
 *
 * Results:
 *	The newly created wide integer object is returned. This object will
 *	have an invalid string representation. The returned object has ref
 *	count 0.
 *
 * Side effects:
 *	Allocates memory.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DbNewWideIntObj(tls *libc.TLS, wideValue TTcl_WideInt, dummy2925 uintptr, dummy2926 int32) (r uintptr) {
	return XTcl_NewWideIntObj(tls, wideValue)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetWideIntObj --
 *
 *	Modify an object to be a wide integer object and to have the specified
 *	wide integer value.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The object's old string rep, if any, is freed. Also, any old internal
 *	rep is freed.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetWideIntObj(tls *libc.TLS, objPtr uintptr, wideValue TTcl_WideInt) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	/* Wide integer used to initialize the
	 * object's value. */
	var _isobjPtr uintptr
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_ = _isobjPtr
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+10229, libc.VaList(bp+24, __ccgo_ts+55380))
	}
	*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp)))) = wideValue
	_isobjPtr = objPtr
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
	XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&XtclIntType)), bp)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetWideUIntObj --
 *
 *	Modify an object to be a wide integer object or a bignum object
 *	and to have the specified unsigned wide integer value.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The object's old string rep, if any, is freed. Also, any old internal
 *	rep is freed.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetWideUIntObj(tls *libc.TLS, objPtr uintptr, uwideValue TTcl_WideUInt) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	/* Wide integer used to initialize the
	 * object's value. */
	var _isobjPtr uintptr
	var _ /* bignumValue at bp+0 */ Tmp_int
	var _ /* ir at bp+24 */ TTcl_ObjInternalRep
	_ = _isobjPtr
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+10229, libc.VaList(bp+48, __ccgo_ts+55398))
	}
	if uwideValue > libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) {
		if XTclBN_mp_init_u64(tls, bp, uwideValue) != MP_OKAY {
			XTcl_Panic(tls, __ccgo_ts+13273, libc.VaList(bp+48, __ccgo_ts+55398))
		}
		XTclSetBignumInternalRep(tls, objPtr, bp)
	}
	*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 24)))) = libc.Int64FromUint64(uwideValue)
	_isobjPtr = objPtr
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
	XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&XtclIntType)), bp+24)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetWideIntFromObj --
 *
 *	Attempt to return a wide integer from the Tcl object "objPtr". If the
 *	object is not already a wide int object, an attempt will be made to
 *	convert it to one.
 *
 * Results:
 *	The return value is a standard Tcl object result. If an error occurs
 *	during conversion, an error message is left in the interpreter's
 *	result unless "interp" is NULL.
 *
 * Side effects:
 *	If the object is not already an int object, the conversion will free
 *	any old internal representation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetWideIntFromObj(tls *libc.TLS, interp uintptr, objPtr uintptr, wideIntPtr uintptr) (r int32) {
	bp := tls.Alloc(96)
	defer tls.Free(96)
	/* Place to store resulting long. */
	var bignumObj, bytes, lengthProc, msg, s, v4, v6, v9 uintptr
	var bignumPayload int32
	var value TTcl_WideUInt
	var v5 Tsize_t
	var _ /* big at bp+8 */ Tmp_int
	var _ /* length at bp+0 */ TTcl_Size
	var _ /* numBytes at bp+32 */ Tsize_t
	var _ /* scratch at bp+40 */ TTcl_WideInt
	_, _, _, _, _, _, _, _, _, _, _ = bignumObj, bignumPayload, bytes, lengthProc, msg, s, value, v4, v5, v6, v9
_3:
	;
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*TTcl_WideInt)(unsafe.Pointer(wideIntPtr)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep))
		return TCL_OK
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
		if interp != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
				v4 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
			} else {
				v4 = XTcl_GetString(tls, objPtr)
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+55310, libc.VaList(bp+56, v4)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+56, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+55340, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclBignumType)) {
		value = uint64(0)
		bytes = bp + 40
		bignumObj = objPtr
		bignumPayload = int32(int64((*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(bignumObj + 32))).Fptr2))
		if bignumPayload == -int32(1) {
			*(*Tmp_int)(unsafe.Pointer(bp + 8)) = *(*Tmp_int)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(bignumObj + 32))).Fptr1))
		} else {
			(*(*Tmp_int)(unsafe.Pointer(bp + 8))).Fdp = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(bignumObj + 32))).Fptr1
			(*(*Tmp_int)(unsafe.Pointer(bp + 8))).Fsign = bignumPayload >> int32(30)
			(*(*Tmp_int)(unsafe.Pointer(bp + 8))).Falloc = bignumPayload >> int32(15) & int32(0x7FFF)
			(*(*Tmp_int)(unsafe.Pointer(bp + 8))).Fused = bignumPayload & int32(0x7FFF)
		}
		if XTclBN_mp_to_ubin(tls, bp+8, bytes, uint64(8), bp+32) == MP_OKAY {
			for {
				v5 = *(*Tsize_t)(unsafe.Pointer(bp + 32))
				*(*Tsize_t)(unsafe.Pointer(bp + 32))--
				if !(v5 > uint64(0)) {
					break
				}
				v6 = bytes
				bytes++
				value = value<<libc.Int32FromInt32(CHAR_BIT) | uint64(*(*uint8)(unsafe.Pointer(v6)))
			}
			if (*(*Tmp_int)(unsafe.Pointer(bp + 8))).Fsign != 0 {
				if value <= libc.Uint64FromInt32(1)+^libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))+libc.Uint64FromInt32(1))) {
					*(*TTcl_WideInt)(unsafe.Pointer(wideIntPtr)) = libc.Int64FromUint64(-value)
					return TCL_OK
				}
			} else {
				if value <= libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) {
					*(*TTcl_WideInt)(unsafe.Pointer(wideIntPtr)) = libc.Int64FromUint64(value)
					return TCL_OK
				}
			}
		}
		if interp != libc.UintptrFromInt32(0) {
			s = __ccgo_ts + 11737
			msg = XTcl_NewStringObj(tls, s, int64(-int32(1)))
			XTcl_SetObjResult(tls, interp, msg)
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+56, __ccgo_ts+8919, __ccgo_ts+55300, s, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	/* Handle dict separately, because it doesn't have a lengthProc */
	if !((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDictType))) {
		goto _7
	}
	XTcl_DictObjSize(tls, libc.UintptrFromInt32(0), objPtr, bp)
	if !(*(*TTcl_Size)(unsafe.Pointer(bp)) > 0) {
		goto _8
	}
	goto listRep
listRep:
	;
	if interp != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+55348, int64(-int32(1))))
	}
	return int32(TCL_ERROR)
_8:
	;
_7:
	;
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+48) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+48) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).Fversion) {
		v9 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FlengthProc
	} else {
		v9 = libc.UintptrFromInt32(0)
	}
	lengthProc = v9
	if lengthProc != 0 && (*(*func(*libc.TLS, uintptr) TTcl_Size)(unsafe.Pointer(&struct{ uintptr }{lengthProc})))(tls, objPtr) != int64(1) {
		goto listRep
	}
	goto _2
_2:
	;
	if XTclParseNumber(tls, interp, objPtr, __ccgo_ts+6223, libc.UintptrFromInt32(0), int64(-int32(1)), libc.UintptrFromInt32(0), int32(TCL_PARSE_INTEGER_ONLY)) == TCL_OK {
		goto _3
	}
	goto _1
_1:
	;
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetWideUIntFromObj --
 *
 *	Attempt to return a unsigned wide integer from the Tcl object "objPtr". If the
 *	object is not already a wide int object or a bignum object, an attempt will
 *	be made to convert it to one.
 *
 * Results:
 *	The return value is a standard Tcl object result. If an error occurs
 *	during conversion, an error message is left in the interpreter's
 *	result unless "interp" is NULL.
 *
 * Side effects:
 *	If the object is not already an int object, the conversion will free
 *	any old internal representation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetWideUIntFromObj(tls *libc.TLS, interp uintptr, objPtr uintptr, wideUIntPtr uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	/* Place to store resulting long. */
	var bignumObj, bytes, msg, s, v6, v8 uintptr
	var bignumPayload int32
	var value TTcl_WideUInt
	var v7 Tsize_t
	var _ /* big at bp+0 */ Tmp_int
	var _ /* numBytes at bp+24 */ Tsize_t
	var _ /* scratch at bp+32 */ TTcl_WideUInt
	_, _, _, _, _, _, _, _, _ = bignumObj, bignumPayload, bytes, msg, s, value, v6, v7, v8
_3:
	;
	if !((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType))) {
		goto _4
	}
	if !(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) < 0) {
		goto _5
	}
	goto wideUIntOutOfRange
wideUIntOutOfRange:
	;
	if interp != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
			v6 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		} else {
			v6 = XTcl_GetString(tls, objPtr)
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+55417, libc.VaList(bp+48, v6)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+48, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+55340, libc.UintptrFromInt32(0)))
	}
	return int32(TCL_ERROR)
_5:
	;
	*(*TTcl_WideUInt)(unsafe.Pointer(wideUIntPtr)) = libc.Uint64FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)))
	return TCL_OK
_4:
	;
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
		goto wideUIntOutOfRange
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclBignumType)) {
		value = uint64(0)
		bytes = bp + 32
		bignumObj = objPtr
		bignumPayload = int32(int64((*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(bignumObj + 32))).Fptr2))
		if bignumPayload == -int32(1) {
			*(*Tmp_int)(unsafe.Pointer(bp)) = *(*Tmp_int)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(bignumObj + 32))).Fptr1))
		} else {
			(*(*Tmp_int)(unsafe.Pointer(bp))).Fdp = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(bignumObj + 32))).Fptr1
			(*(*Tmp_int)(unsafe.Pointer(bp))).Fsign = bignumPayload >> int32(30)
			(*(*Tmp_int)(unsafe.Pointer(bp))).Falloc = bignumPayload >> int32(15) & int32(0x7FFF)
			(*(*Tmp_int)(unsafe.Pointer(bp))).Fused = bignumPayload & int32(0x7FFF)
		}
		if (*(*Tmp_int)(unsafe.Pointer(bp))).Fsign == int32(MP_NEG) {
			goto wideUIntOutOfRange
		}
		if XTclBN_mp_to_ubin(tls, bp, bytes, uint64(8), bp+24) == MP_OKAY {
			for {
				v7 = *(*Tsize_t)(unsafe.Pointer(bp + 24))
				*(*Tsize_t)(unsafe.Pointer(bp + 24))--
				if !(v7 > uint64(0)) {
					break
				}
				v8 = bytes
				bytes++
				value = value<<libc.Int32FromInt32(CHAR_BIT) | uint64(*(*uint8)(unsafe.Pointer(v8)))
			}
			*(*TTcl_WideUInt)(unsafe.Pointer(wideUIntPtr)) = value
			return TCL_OK
		}
		if interp != libc.UintptrFromInt32(0) {
			s = __ccgo_ts + 11737
			msg = XTcl_NewStringObj(tls, s, int64(-int32(1)))
			XTcl_SetObjResult(tls, interp, msg)
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+48, __ccgo_ts+8919, __ccgo_ts+55300, s, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	goto _2
_2:
	;
	if XTclParseNumber(tls, interp, objPtr, __ccgo_ts+6223, libc.UintptrFromInt32(0), int64(-int32(1)), libc.UintptrFromInt32(0), int32(TCL_PARSE_INTEGER_ONLY)) == TCL_OK {
		goto _3
	}
	goto _1
_1:
	;
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * TclGetWideBitsFromObj --
 *
 *	Attempt to return a wide integer from the Tcl object "objPtr". If the
 *	object is not already a int, double or bignum, an attempt will be made
 *	to convert it to one of these. Out-of-range values don't result in an
 *	error, but only the least significant 64 bits will be returned.
 *
 * Results:
 *	The return value is a standard Tcl object result. If an error occurs
 *	during conversion, an error message is left in the interpreter's
 *	result unless "interp" is NULL.
 *
 * Side effects:
 *	If the object is not already an int, double or bignum object, the
 *	conversion will free any old internal representation.
 *
 *----------------------------------------------------------------------
 */

func XTclGetWideBitsFromObj(tls *libc.TLS, interp uintptr, objPtr uintptr, wideIntPtr uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* Place to store resulting wide integer. */
	var bytes, v1, v3 uintptr
	var err Tmp_err
	var value TTcl_WideUInt
	var v2 Tsize_t
	var v4 int64
	var _ /* big at bp+0 */ Tmp_int
	var _ /* numBytes at bp+32 */ Tsize_t
	var _ /* scratch at bp+24 */ TTcl_WideUInt
	_, _, _, _, _, _, _ = bytes, err, value, v1, v2, v3, v4
	for cond := true; cond; cond = XTclParseNumber(tls, interp, objPtr, __ccgo_ts+6223, libc.UintptrFromInt32(0), int64(-int32(1)), libc.UintptrFromInt32(0), int32(TCL_PARSE_INTEGER_ONLY)) == TCL_OK {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
			*(*TTcl_WideInt)(unsafe.Pointer(wideIntPtr)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep))
			return TCL_OK
		}
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
			if interp != libc.UintptrFromInt32(0) {
				if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
					v1 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
				} else {
					v1 = XTcl_GetString(tls, objPtr)
				}
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+55310, libc.VaList(bp+48, v1)))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+48, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+55340, libc.UintptrFromInt32(0)))
			}
			return int32(TCL_ERROR)
		}
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclBignumType)) {
			value = uint64(0)
			bytes = bp + 24
			XTcl_GetBignumFromObj(tls, libc.UintptrFromInt32(0), objPtr, bp)
			err = XTclBN_mp_mod_2d(tls, bp, libc.Int32FromUint64(libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8)), bp)
			if err == MP_OKAY {
				err = XTclBN_mp_to_ubin(tls, bp, bytes, uint64(8), bp+32)
			}
			if err != MP_OKAY {
				return int32(TCL_ERROR)
			}
			for {
				v2 = *(*Tsize_t)(unsafe.Pointer(bp + 32))
				*(*Tsize_t)(unsafe.Pointer(bp + 32))--
				if !(v2 > uint64(0)) {
					break
				}
				v3 = bytes
				bytes++
				value = value<<libc.Int32FromInt32(CHAR_BIT) | uint64(*(*uint8)(unsafe.Pointer(v3)))
			}
			if !((*(*Tmp_int)(unsafe.Pointer(bp))).Fsign != 0) {
				v4 = libc.Int64FromUint64(value)
			} else {
				v4 = -libc.Int64FromUint64(value)
			}
			*(*TTcl_WideInt)(unsafe.Pointer(wideIntPtr)) = v4
			XTclBN_mp_clear(tls, bp)
			return TCL_OK
		}
	}
	return int32(TCL_ERROR)
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * Tcl_GetSizeIntFromObj --
//	 *
//	 *	Attempt to return a Tcl_Size from the Tcl object "objPtr".
//	 *
//	 * Results:
//	 *  TCL_OK - the converted Tcl_Size value is stored in *sizePtr
//	 *  TCL_ERROR - the error message is stored in interp
//	 *
//	 * Side effects:
//	 *	The function may free up any existing internal representation.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func XTcl_GetSizeIntFromObj(tls *libc.TLS, interp uintptr, objPtr uintptr, sizePtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Place to store resulting int. */
	var v1, v2 int32
	var _ /* wide at bp+0 */ TTcl_WideInt
	_, _ = v1, v2
	if uint64(8) == uint64(4) {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
			*(*int32)(unsafe.Pointer(sizePtr)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)))
			v1 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1 = XTcl_GetIntFromObj(tls, interp, objPtr, sizePtr)
		}
		return v1
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
			*(*TTcl_WideInt)(unsafe.Pointer(bp)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep))
			v2 = libc.Int32FromInt32(TCL_OK)
		} else {
			v2 = XTcl_GetWideIntFromObj(tls, interp, objPtr, bp)
		}
		if v2 != TCL_OK {
			return int32(TCL_ERROR)
		}
		*(*TTcl_Size)(unsafe.Pointer(sizePtr)) = *(*TTcl_WideInt)(unsafe.Pointer(bp))
		return TCL_OK
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * FreeBignum --
 *
 *	This function frees the internal rep of a bignum.
 *
 * Results:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _FreeBignum(tls *libc.TLS, objPtr uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var bignumObj uintptr
	var bignumPayload int32
	var _ /* toFree at bp+0 */ Tmp_int
	_, _ = bignumObj, bignumPayload /* Bignum to free */
	bignumObj = objPtr
	bignumPayload = int32(int64((*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bignumObj + 32))).Fptr2))
	if bignumPayload == -int32(1) {
		*(*Tmp_int)(unsafe.Pointer(bp)) = *(*Tmp_int)(unsafe.Pointer((*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(bignumObj + 32))).Fptr1))
	} else {
		(*(*Tmp_int)(unsafe.Pointer(bp))).Fdp = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(bignumObj + 32))).Fptr1
		(*(*Tmp_int)(unsafe.Pointer(bp))).Fsign = bignumPayload >> int32(30)
		(*(*Tmp_int)(unsafe.Pointer(bp))).Falloc = bignumPayload >> int32(15) & int32(0x7FFF)
		(*(*Tmp_int)(unsafe.Pointer(bp))).Fused = bignumPayload & int32(0x7FFF)
	}
	XTclBN_mp_clear(tls, bp)
	if int64((*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr2) < 0 {
		XTclpFree(tls, (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1)
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * DupBignum --
 *
 *	This function duplicates the internal rep of a bignum.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The destination object receives a copy of the source object
 *
 *----------------------------------------------------------------------
 */

func _DupBignum(tls *libc.TLS, srcPtr uintptr, copyPtr uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var bignumObj, temp uintptr
	var bignumPayload int32
	var _ /* bignumCopy at bp+24 */ Tmp_int
	var _ /* bignumVal at bp+0 */ Tmp_int
	_, _, _ = bignumObj, bignumPayload, temp
	(*TTcl_Obj)(unsafe.Pointer(copyPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclBignumType))
	bignumObj = srcPtr
	bignumPayload = int32(int64((*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bignumObj + 32))).Fptr2))
	if bignumPayload == -int32(1) {
		*(*Tmp_int)(unsafe.Pointer(bp)) = *(*Tmp_int)(unsafe.Pointer((*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(bignumObj + 32))).Fptr1))
	} else {
		(*(*Tmp_int)(unsafe.Pointer(bp))).Fdp = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(bignumObj + 32))).Fptr1
		(*(*Tmp_int)(unsafe.Pointer(bp))).Fsign = bignumPayload >> int32(30)
		(*(*Tmp_int)(unsafe.Pointer(bp))).Falloc = bignumPayload >> int32(15) & int32(0x7FFF)
		(*(*Tmp_int)(unsafe.Pointer(bp))).Fused = bignumPayload & int32(0x7FFF)
	}
	if XTclBN_mp_init_copy(tls, bp+24, bp) != MP_OKAY {
		XTcl_Panic(tls, __ccgo_ts+55456, 0)
	}
	if (*(*Tmp_int)(unsafe.Pointer(bp + 24))).Fused > int32(0x7FFF) {
		temp = XTcl_Alloc(tls, uint64(24))
		*(*Tmp_int)(unsafe.Pointer(temp)) = *(*Tmp_int)(unsafe.Pointer(bp + 24))
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(copyPtr + 32))).Fptr1 = temp
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(copyPtr + 32))).Fptr2 = uintptr(int64(-libc.Int32FromInt32(1)))
	} else {
		if (*(*Tmp_int)(unsafe.Pointer(bp + 24))).Falloc <= int32(0x7FFF) || XTclBN_mp_shrink(tls, bp+24) == MP_OKAY {
			(*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(copyPtr + 32))).Fptr1 = (*(*Tmp_int)(unsafe.Pointer(bp + 24))).Fdp
			(*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(copyPtr + 32))).Fptr2 = uintptr(int64((*(*Tmp_int)(unsafe.Pointer(bp + 24))).Fsign<<libc.Int32FromInt32(30) | (*(*Tmp_int)(unsafe.Pointer(bp + 24))).Falloc<<libc.Int32FromInt32(15) | (*(*Tmp_int)(unsafe.Pointer(bp + 24))).Fused))
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * UpdateStringOfBignum --
 *
 *	This function updates the string representation of a bignum object.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The object's string is set to whatever results from the bignum-
 *	to-string conversion.
 *
 * The object's existing string representation is NOT freed; memory will leak
 * if the string rep is still valid at the time this function is called.
 *
 *----------------------------------------------------------------------
 */

func _UpdateStringOfBignum(tls *libc.TLS, objPtr uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var bignumObj, stringVal uintptr
	var bignumPayload int32
	var v1, v2 bool
	var _ /* bignumVal at bp+0 */ Tmp_int
	var _ /* size at bp+24 */ int32
	_, _, _, _, _ = bignumObj, bignumPayload, stringVal, v1, v2
	bignumObj = objPtr
	bignumPayload = int32(int64((*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bignumObj + 32))).Fptr2))
	if bignumPayload == -int32(1) {
		*(*Tmp_int)(unsafe.Pointer(bp)) = *(*Tmp_int)(unsafe.Pointer((*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(bignumObj + 32))).Fptr1))
	} else {
		(*(*Tmp_int)(unsafe.Pointer(bp))).Fdp = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(bignumObj + 32))).Fptr1
		(*(*Tmp_int)(unsafe.Pointer(bp))).Fsign = bignumPayload >> int32(30)
		(*(*Tmp_int)(unsafe.Pointer(bp))).Falloc = bignumPayload >> int32(15) & int32(0x7FFF)
		(*(*Tmp_int)(unsafe.Pointer(bp))).Fused = bignumPayload & int32(0x7FFF)
	}
	if MP_OKAY != XTclBN_mp_radix_size(tls, bp, int32(10), bp+24) {
		XTcl_Panic(tls, __ccgo_ts+55492, 0)
	}
	if *(*int32)(unsafe.Pointer(bp + 24)) < int32(2) {
		/*
		 * mp_radix_size() returns < 2 when more than INT_MAX bytes would be
		 * needed to hold the string rep (because mp_radix_size ignores
		 * integer overflow issues).
		 *
		 * Note that so long as we enforce our bignums to the size that fits
		 * in a packed bignum, this branch will never be taken.
		 */
		XTcl_Panic(tls, __ccgo_ts+55535, 0)
	}
	stringVal = XTcl_InitStringRep(tls, objPtr, libc.UintptrFromInt32(0), libc.Uint64FromInt32(*(*int32)(unsafe.Pointer(bp + 24))-int32(1)))
	if v2 = *(*int32)(unsafe.Pointer(bp + 24)) != 0; v2 {
		if v1 = stringVal != 0; !v1 {
			XTcl_Panic(tls, __ccgo_ts+10479, libc.VaList(bp+40, libc.Uint64FromInt32(*(*int32)(unsafe.Pointer(bp + 24)))))
		}
	}
	_ = v2 && (v1 || libc.Bool(libc.Int32FromInt32(1) != 0))
	if MP_OKAY != XTclBN_mp_to_radix(tls, bp, stringVal, libc.Uint64FromInt32(*(*int32)(unsafe.Pointer(bp + 24))), libc.UintptrFromInt32(0), int32(10)) {
		XTcl_Panic(tls, __ccgo_ts+55586, 0)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_NewBignumObj --
 *
 *	Creates and initializes a bignum object.
 *
 * Results:
 *	Returns the newly created object.
 *
 * Side effects:
 *	The bignum value is cleared, since ownership has transferred to Tcl.
 *
 *----------------------------------------------------------------------
 */

func XTcl_NewBignumObj(tls *libc.TLS, bignumValue uintptr) (r uintptr) {
	var cachePtr, objPtr uintptr
	var v1 bool
	_, _, _ = cachePtr, objPtr, v1
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	XTcl_SetBignumObj(tls, objPtr, bignumValue)
	return objPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DbNewBignumObj --
 *
 *	This function is normally called when debugging: that is, when
 *	TCL_MEM_DEBUG is defined. It constructs a bignum object, recording the
 *	creation point so that [memory active] can report it.
 *
 * Results:
 *	Returns the newly created object.
 *
 * Side effects:
 *	The bignum value is cleared, since ownership has transferred to Tcl.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DbNewBignumObj(tls *libc.TLS, bignumValue uintptr, dummy3478 uintptr, dummy3479 int32) (r uintptr) {
	return XTcl_NewBignumObj(tls, bignumValue)
}

/*
 *----------------------------------------------------------------------
 *
 * GetBignumFromObj --
 *
 *	This function retrieves a 'bignum' value from a Tcl object, converting
 *	the object if necessary. Either copies or transfers the mp_int value
 *	depending on the copy flag value passed in.
 *
 * Results:
 *	Returns TCL_OK if the conversion is successful, TCL_ERROR otherwise.
 *
 * Side effects:
 *	A copy of bignum is stored in *bignumValue, which is expected to be
 *	uninitialized or cleared. If conversion fails, and the 'interp'
 *	argument is not NULL, an error message is stored in the interpreter
 *	result.
 *
 *----------------------------------------------------------------------
 */

func _GetBignumFromObj(tls *libc.TLS, interp uintptr, objPtr uintptr, copy1 int32, bignumValue uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Returned bignum value. */
	var bignumObj, bignumObj1, v1 uintptr
	var bignumPayload, bignumPayload1 int32
	var _ /* temp at bp+0 */ Tmp_int
	_, _, _, _, _ = bignumObj, bignumObj1, bignumPayload, bignumPayload1, v1
	for cond := true; cond; cond = XTclParseNumber(tls, interp, objPtr, __ccgo_ts+6223, libc.UintptrFromInt32(0), int64(-int32(1)), libc.UintptrFromInt32(0), int32(TCL_PARSE_INTEGER_ONLY)) == TCL_OK {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclBignumType)) {
			if copy1 != 0 || (*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount > int64(1) {
				bignumObj = objPtr
				bignumPayload = int32(int64((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(bignumObj + 32))).Fptr2))
				if bignumPayload == -int32(1) {
					*(*Tmp_int)(unsafe.Pointer(bp)) = *(*Tmp_int)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(bignumObj + 32))).Fptr1))
				} else {
					(*(*Tmp_int)(unsafe.Pointer(bp))).Fdp = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(bignumObj + 32))).Fptr1
					(*(*Tmp_int)(unsafe.Pointer(bp))).Fsign = bignumPayload >> int32(30)
					(*(*Tmp_int)(unsafe.Pointer(bp))).Falloc = bignumPayload >> int32(15) & int32(0x7FFF)
					(*(*Tmp_int)(unsafe.Pointer(bp))).Fused = bignumPayload & int32(0x7FFF)
				}
				if XTclBN_mp_init_copy(tls, bignumValue, bp) != MP_OKAY {
					return int32(TCL_ERROR)
				}
			} else {
				bignumObj1 = objPtr
				bignumPayload1 = int32(int64((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(bignumObj1 + 32))).Fptr2))
				if bignumPayload1 == -int32(1) {
					*(*Tmp_int)(unsafe.Pointer(bignumValue)) = *(*Tmp_int)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(bignumObj1 + 32))).Fptr1))
				} else {
					(*Tmp_int)(unsafe.Pointer(bignumValue)).Fdp = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(bignumObj1 + 32))).Fptr1
					(*Tmp_int)(unsafe.Pointer(bignumValue)).Fsign = bignumPayload1 >> int32(30)
					(*Tmp_int)(unsafe.Pointer(bignumValue)).Falloc = bignumPayload1 >> int32(15) & int32(0x7FFF)
					(*Tmp_int)(unsafe.Pointer(bignumValue)).Fused = bignumPayload1 & int32(0x7FFF)
				}
				/* Optimized TclFreeInternalRep */
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr1 = libc.UintptrFromInt32(0)
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr2 = libc.UintptrFromInt32(0)
				(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
				/*
				 * TODO: If objPtr has a string rep, this leaves
				 * it undisturbed.  Not clear that's proper. Pure
				 * bignum values are converted to empty string.
				 */
				if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes == libc.UintptrFromInt32(0) {
					(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(libc.Int32FromInt32(0))
				}
			}
			return TCL_OK
		}
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
			if XTclBN_mp_init_i64(tls, bignumValue, *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep))) != MP_OKAY {
				return int32(TCL_ERROR)
			}
			return TCL_OK
		}
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
			if interp != libc.UintptrFromInt32(0) {
				if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
					v1 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
				} else {
					v1 = XTcl_GetString(tls, objPtr)
				}
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+55310, libc.VaList(bp+32, v1)))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+32, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+55340, libc.UintptrFromInt32(0)))
			}
			return int32(TCL_ERROR)
		}
	}
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetBignumFromObj --
 *
 *	This function retrieves a 'bignum' value from a Tcl object, converting
 *	the object if necessary.
 *
 * Results:
 *	Returns TCL_OK if the conversion is successful, TCL_ERROR otherwise.
 *
 * Side effects:
 *	A copy of bignum is stored in *bignumValue, which is expected to be
 *	uninitialized or cleared. If conversion fails, an the 'interp'
 *	argument is not NULL, an error message is stored in the interpreter
 *	result.
 *
 *	It is expected that the caller will NOT have invoked mp_init on the
 *	bignum value before passing it in. Tcl will initialize the mp_int as
 *	it sets the value. The value is a copy of the value in objPtr, so it
 *	becomes the responsibility of the caller to call mp_clear on it.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetBignumFromObj(tls *libc.TLS, interp uintptr, objPtr uintptr, bignumValue uintptr) (r int32) {
	/* Returned bignum value. */
	return _GetBignumFromObj(tls, interp, objPtr, int32(1), bignumValue)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_TakeBignumFromObj --
 *
 *	This function retrieves a 'bignum' value from a Tcl object, converting
 *	the object if necessary.
 *
 * Results:
 *	Returns TCL_OK if the conversion is successful, TCL_ERROR otherwise.
 *
 * Side effects:
 *	A copy of bignum is stored in *bignumValue, which is expected to be
 *	uninitialized or cleared. If conversion fails and the 'interp'
 *	argument is not NULL, an error message is stored in the interpreter
 *	result.
 *
 *	It is expected that the caller will NOT have invoked mp_init on the
 *	bignum value before passing it in. Tcl will initialize the mp_int as
 *	it sets the value. The value is transferred from the internals of
 *	objPtr to the caller, passing responsibility of the caller to call
 *	mp_clear on it. The objPtr is cleared to hold an empty value.
 *
 *----------------------------------------------------------------------
 */

func XTcl_TakeBignumFromObj(tls *libc.TLS, interp uintptr, objPtr uintptr, bignumValue uintptr) (r int32) {
	/* Returned bignum value. */
	return _GetBignumFromObj(tls, interp, objPtr, 0, bignumValue)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetBignumObj --
 *
 *	This function sets the value of a Tcl_Obj to a large integer.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Object value is stored. The bignum value is cleared, since ownership
 *	has transferred to Tcl.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetBignumObj(tls *libc.TLS, objPtr uintptr, big uintptr) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Value to store */
	var _isobjPtr, _isobjPtr1, _isobjPtr2, bignumValue, bytes, v2 uintptr
	var value TTcl_WideUInt
	var v1 Tsize_t
	var _ /* ir at bp+16 */ TTcl_ObjInternalRep
	var _ /* ir at bp+32 */ TTcl_ObjInternalRep
	var _ /* numBytes at bp+0 */ Tsize_t
	var _ /* scratch at bp+8 */ TTcl_WideUInt
	_, _, _, _, _, _, _, _ = _isobjPtr, _isobjPtr1, _isobjPtr2, bignumValue, bytes, value, v1, v2
	value = uint64(0)
	bytes = bp + 8
	bignumValue = big
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+10229, libc.VaList(bp+56, __ccgo_ts+55629))
	}
	if XTclBN_mp_to_ubin(tls, bignumValue, bytes, uint64(8), bp) != MP_OKAY {
		goto tooLargeForWide
	}
	for {
		v1 = *(*Tsize_t)(unsafe.Pointer(bp))
		*(*Tsize_t)(unsafe.Pointer(bp))--
		if !(v1 > uint64(0)) {
			break
		}
		v2 = bytes
		bytes++
		value = value<<libc.Int32FromInt32(CHAR_BIT) | uint64(*(*uint8)(unsafe.Pointer(v2)))
	}
	if value > libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))+libc.Uint64FromInt32((*Tmp_int)(unsafe.Pointer(bignumValue)).Fsign) {
		goto tooLargeForWide
	}
	if (*Tmp_int)(unsafe.Pointer(bignumValue)).Fsign != 0 {
		*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 16)))) = libc.Int64FromUint64(-value)
		_isobjPtr = objPtr
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
		}
		XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&XtclIntType)), bp+16)
	} else {
		*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 32)))) = libc.Int64FromUint64(value)
		_isobjPtr1 = objPtr
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes = libc.UintptrFromInt32(0)
		}
		XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&XtclIntType)), bp+32)
	}
	XTclBN_mp_clear(tls, bignumValue)
	return
	goto tooLargeForWide
tooLargeForWide:
	;
	_isobjPtr2 = objPtr
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr2)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr2)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr2)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr2)).Fbytes = libc.UintptrFromInt32(0)
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != libc.UintptrFromInt32(0) {
		if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc})))(tls, objPtr)
		}
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	}
	XTclSetBignumInternalRep(tls, objPtr, bignumValue)
}

/*
 *----------------------------------------------------------------------
 *
 * TclSetBignumInternalRep --
 *
 *	Install a bignum into the internal representation of an object.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Object internal representation is updated and object type is set. The
 *	bignum value is cleared, since ownership has transferred to the
 *	object.
 *
 *----------------------------------------------------------------------
 */

func XTclSetBignumInternalRep(tls *libc.TLS, objPtr uintptr, big uintptr) {
	var bignumValue, temp uintptr
	var v1 int32
	_, _, _ = bignumValue, temp, v1
	bignumValue = big
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclBignumType))
	if (*Tmp_int)(unsafe.Pointer(bignumValue)).Fused > int32(0x7FFF) {
		temp = XTcl_Alloc(tls, uint64(24))
		*(*Tmp_int)(unsafe.Pointer(temp)) = *(*Tmp_int)(unsafe.Pointer(bignumValue))
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1 = temp
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr2 = uintptr(int64(-libc.Int32FromInt32(1)))
	} else {
		if (*Tmp_int)(unsafe.Pointer(bignumValue)).Falloc <= int32(0x7FFF) || XTclBN_mp_shrink(tls, bignumValue) == MP_OKAY {
			(*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr1 = (*Tmp_int)(unsafe.Pointer(bignumValue)).Fdp
			(*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr2 = uintptr(int64((*Tmp_int)(unsafe.Pointer(bignumValue)).Fsign<<libc.Int32FromInt32(30) | (*Tmp_int)(unsafe.Pointer(bignumValue)).Falloc<<libc.Int32FromInt32(15) | (*Tmp_int)(unsafe.Pointer(bignumValue)).Fused))
		}
	}
	/*
	 * Clear the mp_int value.
	 *
	 * Don't call mp_clear() because it would free the digit array we just
	 * packed into the Tcl_Obj.
	 */
	(*Tmp_int)(unsafe.Pointer(bignumValue)).Fdp = libc.UintptrFromInt32(0)
	v1 = libc.Int32FromInt32(0)
	(*Tmp_int)(unsafe.Pointer(bignumValue)).Fused = v1
	(*Tmp_int)(unsafe.Pointer(bignumValue)).Falloc = v1
	(*Tmp_int)(unsafe.Pointer(bignumValue)).Fsign = int32(MP_NEG)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetNumberFromObj --
 *
 *      Extracts a number (of any possible numeric type) from an object.
 *
 * Results:
 *      Whether the extraction worked. The type is stored in the variable
 *      referred to by the typePtr argument, and a pointer to the
 *      representation is stored in the variable referred to by the
 *      clientDataPtr.
 *
 * Side effects:
 *      Can allocate thread-specific data for handling the copy-out space for
 *      bignums; this space is shared within a thread.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetNumberFromObj(tls *libc.TLS, interp uintptr, objPtr uintptr, clientDataPtr uintptr, typePtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var bigPtr, bignumObj, lengthProc, v8 uintptr
	var bignumPayload int32
	var v4 uint64
	var _ /* __u at bp+0 */ struct {
		F__i [0]uint64
		F__f float64
	}
	var _ /* length at bp+8 */ TTcl_Size
	_, _, _, _, _, _ = bigPtr, bignumObj, bignumPayload, lengthProc, v4, v8
_3:
	;
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
		*(*float64)(unsafe.Pointer(bp)) = *(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep))
		v4 = *(*uint64)(unsafe.Pointer(bp))
		goto _5
	_5:
		if libc.BoolInt32(v4&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) > libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
			*(*int32)(unsafe.Pointer(typePtr)) = int32(TCL_NUMBER_NAN)
		} else {
			*(*int32)(unsafe.Pointer(typePtr)) = int32(TCL_NUMBER_DOUBLE)
		}
		*(*uintptr)(unsafe.Pointer(clientDataPtr)) = objPtr + 32
		return TCL_OK
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*int32)(unsafe.Pointer(typePtr)) = int32(TCL_NUMBER_INT)
		*(*uintptr)(unsafe.Pointer(clientDataPtr)) = objPtr + 32
		return TCL_OK
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclBignumType)) {
		bigPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_bignumKey)), int64(24))
		bignumObj = objPtr
		bignumPayload = int32(int64((*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(bignumObj + 32))).Fptr2))
		if bignumPayload == -int32(1) {
			*(*Tmp_int)(unsafe.Pointer(bigPtr)) = *(*Tmp_int)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(bignumObj + 32))).Fptr1))
		} else {
			(*Tmp_int)(unsafe.Pointer(bigPtr)).Fdp = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(bignumObj + 32))).Fptr1
			(*Tmp_int)(unsafe.Pointer(bigPtr)).Fsign = bignumPayload >> int32(30)
			(*Tmp_int)(unsafe.Pointer(bigPtr)).Falloc = bignumPayload >> int32(15) & int32(0x7FFF)
			(*Tmp_int)(unsafe.Pointer(bigPtr)).Fused = bignumPayload & int32(0x7FFF)
		}
		*(*int32)(unsafe.Pointer(typePtr)) = int32(TCL_NUMBER_BIG)
		*(*uintptr)(unsafe.Pointer(clientDataPtr)) = bigPtr
		return TCL_OK
	}
	/* Handle dict separately, because it doesn't have a lengthProc */
	if !((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDictType))) {
		goto _6
	}
	XTcl_DictObjSize(tls, libc.UintptrFromInt32(0), objPtr, bp+8)
	if !(*(*TTcl_Size)(unsafe.Pointer(bp + 8)) > 0) {
		goto _7
	}
	goto listRep
listRep:
	;
	if interp != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+55646, int64(-int32(1))))
	}
	return int32(TCL_ERROR)
_7:
	;
_6:
	;
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+48) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+48) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).Fversion) {
		v8 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FlengthProc
	} else {
		v8 = libc.UintptrFromInt32(0)
	}
	lengthProc = v8
	if lengthProc != 0 && (*(*func(*libc.TLS, uintptr) TTcl_Size)(unsafe.Pointer(&struct{ uintptr }{lengthProc})))(tls, objPtr) != int64(1) {
		goto listRep
	}
	goto _2
_2:
	;
	if TCL_OK == XTclParseNumber(tls, interp, objPtr, __ccgo_ts+55677, libc.UintptrFromInt32(0), int64(-int32(1)), libc.UintptrFromInt32(0), 0) {
		goto _3
	}
	goto _1
_1:
	;
	return int32(TCL_ERROR)
}

var _bignumKey TTcl_ThreadDataKey

func XTcl_GetNumber(tls *libc.TLS, interp uintptr, bytes uintptr, numBytes TTcl_Size, clientDataPtr uintptr, typePtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var objPtr uintptr
	_ = objPtr
	objPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_numberCacheKey)), int64(48))
	XTcl_FreeInternalRep(tls, objPtr)
	if bytes == libc.UintptrFromInt32(0) {
		bytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		numBytes = 0
	}
	if numBytes < 0 {
		numBytes = libc.Int64FromUint64(libc.Xstrlen(tls, bytes))
	}
	if numBytes > int64(INT_MAX) {
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+55684, libc.VaList(bp+8, int32(INT_MAX))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+2008, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = bytes
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = numBytes
	return XTcl_GetNumberFromObj(tls, interp, objPtr, clientDataPtr, typePtr)
}

var _numberCacheKey TTcl_ThreadDataKey

/*
 *----------------------------------------------------------------------
 *
 * Tcl_IncrRefCount --
 *
 *	Increments the reference count of the object.
 *
 * Results:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_IncrRefCount(tls *libc.TLS, objPtr uintptr) {
	/* The object we are registering a reference to. */
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount++
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DecrRefCount --
 *
 *	Decrements the reference count of the object.
 *
 * Results:
 *	The storage for objPtr may be freed.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DecrRefCount(tls *libc.TLS, objPtr uintptr) {
	/* The object we are releasing a reference to. */
	var v1 TTcl_Size
	var v2 uintptr
	_, _ = v1, v2
	v2 = objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, objPtr)
	}
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * TclUndoRefCount --
//	 *
//	 *	Decrement the refCount of objPtr without causing it to be freed if it
//	 *	drops from 1 to 0.  This allows a function increment a refCount but
//	 *	then decrement it and still be able to pass return it to a caller,
//	 *	possibly with a refCount of 0.  The caller must have previously
//	 *	incremented the refCount.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func XTclUndoRefCount(tls *libc.TLS, objPtr uintptr) {
	/* The object we are releasing a reference to. */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount > 0 {
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount--
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_IsShared --
 *
 *	Tests if the object has a ref count greater than one.
 *
 * Results:
 *	Boolean value that is the result of the test.
 *
 *----------------------------------------------------------------------
 */

func XTcl_IsShared(tls *libc.TLS, objPtr uintptr) (r int32) {
	/* The object to test for being shared. */
	return libc.BoolInt32((*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount > int64(1))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DbIncrRefCount --
 *
 *	This function is normally called when debugging: i.e., when
 *	TCL_MEM_DEBUG is defined. This checks to see whether or not the memory
 *	has been freed before incrementing the ref count.
 *
 *	When TCL_MEM_DEBUG is not defined, this function just increments the
 *	reference count of the object.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The object's ref count is incremented.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DbIncrRefCount(tls *libc.TLS, objPtr uintptr, dummy3983 uintptr, dummy3984 int32) {
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount++
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DbDecrRefCount --
 *
 *	This function is normally called when debugging: i.e., when
 *	TCL_MEM_DEBUG is defined. This checks to see whether or not the memory
 *	has been freed before decrementing the ref count.
 *
 *	When TCL_MEM_DEBUG is not defined, this function just decrements the
 *	reference count of the object.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The object's ref count is incremented.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DbDecrRefCount(tls *libc.TLS, objPtr uintptr, dummy4059 uintptr, dummy4060 int32) {
	var v1 TTcl_Size
	var v2 uintptr
	_, _ = v1, v2
	v2 = objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, objPtr)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DbIsShared --
 *
 *	This function is normally called when debugging: i.e., when
 *	TCL_MEM_DEBUG is defined. It tests whether the object has a ref count
 *	greater than one.
 *
 *	When TCL_MEM_DEBUG is not defined, this function just tests if the
 *	object has a ref count greater than one.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DbIsShared(tls *libc.TLS, objPtr uintptr, dummy4098 uintptr, dummy4099 int32) (r int32) {
	return libc.BoolInt32((*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount > int64(1))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_InitObjHashTable --
 *
 *	Given storage for a hash table, set up the fields to prepare the hash
 *	table for use, the keys are Tcl_Obj *.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	TablePtr is now ready to be passed to Tcl_FindHashEntry and
 *	Tcl_CreateHashEntry.
 *
 *----------------------------------------------------------------------
 */

func XTcl_InitObjHashTable(tls *libc.TLS, tablePtr uintptr) {
	/* Pointer to table record, which is supplied
	 * by the caller. */
	XTcl_InitCustomHashTable(tls, tablePtr, -int32(1), uintptr(unsafe.Pointer(&XtclObjHashKeyType)))
}

/*
 *----------------------------------------------------------------------
 *
 * AllocObjEntry --
 *
 *	Allocate space for a Tcl_HashEntry containing the Tcl_Obj * key.
 *
 * Results:
 *	The return value is a pointer to the created entry.
 *
 * Side effects:
 *	Increments the reference count on the object.
 *
 *----------------------------------------------------------------------
 */

func _AllocObjEntry(tls *libc.TLS, dummy4194 uintptr, keyPtr uintptr) (r uintptr) {
	/* Key to store in the hash table entry. */
	var hPtr, objPtr uintptr
	_, _ = hPtr, objPtr
	objPtr = keyPtr
	hPtr = XTcl_Alloc(tls, uint64(40))
	*(*uintptr)(unsafe.Pointer(hPtr + 32)) = objPtr
	XTcl_IncrRefCount(tls, objPtr)
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = libc.UintptrFromInt32(0)
	return hPtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclCompareObjKeys --
 *
 *	Compares two Tcl_Obj * keys.
 *
 * Results:
 *	The return value is 0 if they are different and 1 if they are the
 *	same.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclCompareObjKeys(tls *libc.TLS, keyPtr uintptr, hPtr uintptr) (r int32) {
	/* Existing key to compare. */
	var l1, l2 Tsize_t
	var objPtr1, objPtr2, p1, p2, v1, v2 uintptr
	_, _, _, _, _, _, _, _ = l1, l2, objPtr1, objPtr2, p1, p2, v1, v2
	objPtr1 = keyPtr
	objPtr2 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
	/*
		     * If the object pointers are the same then they match.
		     * OPT: this comparison was moved to the caller
		       if (objPtr1 == objPtr2) {
			   return 1;
		       }
	*/
	/*
	 * Don't use Tcl_GetStringFromObj as it would prevent l1 and l2 being
	 * in a register.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr1)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(objPtr1)).Fbytes
	} else {
		v1 = XTcl_GetString(tls, objPtr1)
	}
	p1 = v1
	l1 = libc.Uint64FromInt64((*TTcl_Obj)(unsafe.Pointer(objPtr1)).Flength)
	if (*TTcl_Obj)(unsafe.Pointer(objPtr2)).Fbytes != 0 {
		v2 = (*TTcl_Obj)(unsafe.Pointer(objPtr2)).Fbytes
	} else {
		v2 = XTcl_GetString(tls, objPtr2)
	}
	p2 = v2
	l2 = libc.Uint64FromInt64((*TTcl_Obj)(unsafe.Pointer(objPtr2)).Flength)
	/*
	 * Only compare if the string representations are of the same length.
	 */
	if l1 == l2 {
		for {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p1))) != libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p2))) {
				break
			}
			if l1 == uint64(0) {
				return int32(1)
			}
			goto _3
		_3:
			;
			p1++
			p2++
			l1--
		}
	}
	return 0
}

/*
 *----------------------------------------------------------------------
 *
 * TclFreeObjEntry --
 *
 *	Frees space for a Tcl_HashEntry containing the Tcl_Obj * key.
 *
 * Results:
 *	The return value is a pointer to the created entry.
 *
 * Side effects:
 *	Decrements the reference count of the object.
 *
 *----------------------------------------------------------------------
 */

func XTclFreeObjEntry(tls *libc.TLS, hPtr uintptr) {
	/* Hash entry to free. */
	var objPtr uintptr
	_ = objPtr
	objPtr = *(*uintptr)(unsafe.Pointer(hPtr + 32))
	XTcl_DecrRefCount(tls, objPtr)
	XTclpFree(tls, hPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * TclHashObjKey --
 *
 *	Compute a one-word summary of the string representation of the
 *	Tcl_Obj, which can be used to generate a hash index.
 *
 * Results:
 *	The return value is a one-word summary of the information in the
 *	string representation of the Tcl_Obj.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclHashObjKey(tls *libc.TLS, dummy4317 uintptr, keyPtr uintptr) (r Tsize_t) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Key from which to compute hash value. */
	var objPtr, string1, v2 uintptr
	var result Tsize_t
	var v1 TTcl_Size
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _, _ = objPtr, result, string1, v1, v2
	objPtr = keyPtr
	string1 = XTcl_GetStringFromObj(tls, objPtr, bp)
	result = uint64(0)
	/*
	 * I tried a zillion different hash functions and asked many other people
	 * for advice. Many people had their own favorite functions, all
	 * different, but no-one had much idea why they were good ones. I chose
	 * the one below (multiply by 9 and add new character) because of the
	 * following reasons:
	 *
	 * 1. Multiplying by 10 is perfect for keys that are decimal strings, and
	 *    multiplying by 9 is just about as good.
	 * 2. Times-9 is (shift-left-3) plus (old). This means that each
	 *    character's bits hang around in the low-order bits of the hash value
	 *    for ever, plus they spread fairly rapidly up to the high-order bits
	 *    to fill out the hash value. This seems works well both for decimal
	 *    and non-decimal strings.
	 *
	 * Note that this function is very weak against malicious strings; it's
	 * very easy to generate multiple keys that have the same hashcode. On the
	 * other hand, that hardly ever actually occurs and this function *is*
	 * very cheap, even by comparison with industry-standard hashes like FNV.
	 * If real strength of hash is required though, use a custom hash based on
	 * Bob Jenkins's lookup3(), but be aware that it's significantly slower.
	 * Tcl does not use that level of strength because it typically does not
	 * need it (and some of the aspects of that strength are genuinely
	 * unnecessary given the rest of Tcl's hash machinery, and the fact that
	 * we do not either transfer hashes to another machine, use them as a true
	 * substitute for equality, or attempt to minimize work in rebuilding the
	 * hash table).
	 *
	 * See also HashStringKey in tclHash.c.
	 * See also HashString in tclLiteral.c.
	 *
	 * See [tcl-Feature Request #2958832]
	 */
	if *(*TTcl_Size)(unsafe.Pointer(bp)) > 0 {
		result = uint64(*(*uint8)(unsafe.Pointer(string1)))
		for {
			*(*TTcl_Size)(unsafe.Pointer(bp))--
			v1 = *(*TTcl_Size)(unsafe.Pointer(bp))
			if !(v1 != 0) {
				break
			}
			string1++
			v2 = string1
			result += result<<libc.Int32FromInt32(3) + uint64(*(*uint8)(unsafe.Pointer(v2)))
		}
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetCommandFromObj --
 *
 *	Returns the command specified by the name in a Tcl_Obj.
 *
 * Results:
 *	Returns a token for the command if it is found. Otherwise, if it can't
 *	be found or there is an error, returns NULL.
 *
 * Side effects:
 *	May update the internal representation for the object, caching the
 *	command reference so that the next time this function is called with
 *	the same object, the command can be found quickly.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetCommandFromObj(tls *libc.TLS, interp uintptr, objPtr uintptr) (r TTcl_Command) {
	/* The object containing the command's name.
	 * If the name starts with "::", will be
	 * looked up in global namespace. Else, looked
	 * up first in the current namespace, then in
	 * global namespace. */
	var cmdPtr, refNsPtr, resPtr, v1 uintptr
	_, _, _, _ = cmdPtr, refNsPtr, resPtr, v1
	/*
	 * Get the internal representation, converting to a command type if
	 * needed. The internal representation is a ResolvedCmdName that points to
	 * the actual command.
	 *
	 * Check the context namespace and the namespace epoch of the resolved
	 * symbol to make sure that it is fresh. Note that we verify that the
	 * namespace id of the context namespace is the same as the one we cached;
	 * this insures that the namespace wasn't deleted and a new one created at
	 * the same address with the same command epoch. Note that fully qualified
	 * names have a NULL refNsPtr, these checks needn't be made.
	 *
	 * Check also that the command's epoch is up to date, and that the command
	 * is not deleted.
	 *
	 * If any check fails, then force another conversion to the command type,
	 * to discard the old rep and create a new one.
	 */
	resPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclCmdNameType)) {
		cmdPtr = (*TResolvedCmdName)(unsafe.Pointer(resPtr)).FcmdPtr
		if (*TCommand)(unsafe.Pointer(cmdPtr)).FcmdEpoch == (*TResolvedCmdName)(unsafe.Pointer(resPtr)).FcmdEpoch && interp == (*TNamespace)(unsafe.Pointer((*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr)).Finterp && !((*TNamespace)(unsafe.Pointer((*TCommand)(unsafe.Pointer(cmdPtr)).FnsPtr)).Fflags&libc.Int32FromInt32(NS_DYING) != 0) {
			refNsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FnsPtr
			if (*TResolvedCmdName)(unsafe.Pointer(resPtr)).FrefNsPtr == libc.UintptrFromInt32(0) || refNsPtr == (*TResolvedCmdName)(unsafe.Pointer(resPtr)).FrefNsPtr && (*TResolvedCmdName)(unsafe.Pointer(resPtr)).FrefNsId == (*TNamespace)(unsafe.Pointer(refNsPtr)).FnsId && (*TResolvedCmdName)(unsafe.Pointer(resPtr)).FrefNsCmdEpoch == (*TNamespace)(unsafe.Pointer(refNsPtr)).FcmdRefEpoch {
				return cmdPtr
			}
		}
	}
	/*
	 * OK, must create a new internal representation (or fail) as any cache we
	 * had is invalid one way or another.
	 */
	/* See [07d13d99b0a9] why we cannot call SetCmdNameFromAny() directly here. */
	if (*(*func(*libc.TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{XtclCmdNameType.FsetFromAnyProc})))(tls, interp, objPtr) != TCL_OK {
		return libc.UintptrFromInt32(0)
	}
	resPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1
	if resPtr != 0 {
		v1 = (*TResolvedCmdName)(unsafe.Pointer(resPtr)).FcmdPtr
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	return v1
}

/*
 *----------------------------------------------------------------------
 *
 * TclSetCmdNameObj --
 *
 *	Modify an object to be an CmdName object that refers to the argument
 *	Command structure.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The object's old internal rep is freed. Its string rep is not
 *	changed. The refcount in the Command structure is incremented to keep
 *	it from being freed if the command is later deleted until
 *	TclNRExecuteByteCode has a chance to recognize that it was deleted.
 *
 *----------------------------------------------------------------------
 */

func _SetCmdNameObj(tls *libc.TLS, interp uintptr, objPtr uintptr, cmdPtr uintptr, resPtr uintptr) {
	var currNsPtr, fillPtr, iPtr, name, v1 uintptr
	_, _, _, _, _ = currNsPtr, fillPtr, iPtr, name, v1
	iPtr = interp
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		v1 = XTcl_GetString(tls, objPtr)
	}
	name = v1
	if resPtr != 0 {
		fillPtr = resPtr
	} else {
		fillPtr = XTcl_Alloc(tls, uint64(48))
		(*TResolvedCmdName)(unsafe.Pointer(fillPtr)).FrefCount = uint64(1)
	}
	(*TResolvedCmdName)(unsafe.Pointer(fillPtr)).FcmdPtr = cmdPtr
	(*TCommand)(unsafe.Pointer(cmdPtr)).FrefCount++
	(*TResolvedCmdName)(unsafe.Pointer(fillPtr)).FcmdEpoch = (*TCommand)(unsafe.Pointer(cmdPtr)).FcmdEpoch
	/* NOTE: relying on NULL termination here. */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32(':') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name + 1))) == int32(':') {
		/*
		 * Fully qualified names always resolve to same thing. No need
		 * to record resolution context information.
		 */
		(*TResolvedCmdName)(unsafe.Pointer(fillPtr)).FrefNsPtr = libc.UintptrFromInt32(0)
		(*TResolvedCmdName)(unsafe.Pointer(fillPtr)).FrefNsId = uint64(0) /* Will not be read */
		(*TResolvedCmdName)(unsafe.Pointer(fillPtr)).FrefNsCmdEpoch = 0   /* Will not be read */
	} else {
		/*
		 * Record current state of current namespace as the resolution
		 * context of this command name lookup.
		 */
		currNsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FnsPtr
		(*TResolvedCmdName)(unsafe.Pointer(fillPtr)).FrefNsPtr = currNsPtr
		(*TResolvedCmdName)(unsafe.Pointer(fillPtr)).FrefNsId = (*TNamespace)(unsafe.Pointer(currNsPtr)).FnsId
		(*TResolvedCmdName)(unsafe.Pointer(fillPtr)).FrefNsCmdEpoch = (*TNamespace)(unsafe.Pointer(currNsPtr)).FcmdRefEpoch
	}
	if resPtr == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != libc.UintptrFromInt32(0) {
			if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
				(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc})))(tls, objPtr)
			}
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
		}
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1 = fillPtr
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr2 = libc.UintptrFromInt32(0)
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclCmdNameType))
	}
}

func XTclSetCmdNameObj(tls *libc.TLS, interp uintptr, objPtr uintptr, cmdPtr uintptr) {
	/* Points to Command structure that the
	 * CmdName object should refer to. */
	var resPtr uintptr
	_ = resPtr
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclCmdNameType)) {
		resPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		if resPtr != libc.UintptrFromInt32(0) && (*TResolvedCmdName)(unsafe.Pointer(resPtr)).FcmdPtr == cmdPtr {
			return
		}
	}
	_SetCmdNameObj(tls, interp, objPtr, cmdPtr, libc.UintptrFromInt32(0))
}

/*
 *----------------------------------------------------------------------
 *
 * FreeCmdNameInternalRep --
 *
 *	Frees the resources associated with a cmdName object's internal
 *	representation.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Decrements the ref count of any cached ResolvedCmdName structure
 *	pointed to by the cmdName's internal representation. If this is the
 *	last use of the ResolvedCmdName, it is freed. This in turn decrements
 *	the ref count of the Command structure pointed to by the
 *	ResolvedSymbol, which may free the Command structure.
 *
 *----------------------------------------------------------------------
 */

func _FreeCmdNameInternalRep(tls *libc.TLS, objPtr uintptr) {
	/* CmdName object with internal
	 * representation to free. */
	var cmdPtr, resPtr, v2, v4 uintptr
	var v1 Tsize_t
	var v3 TTcl_Size
	_, _, _, _, _, _ = cmdPtr, resPtr, v1, v2, v3, v4
	resPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1
	/*
	 * Decrement the reference count of the ResolvedCmdName structure. If
	 * there are no more uses, free the ResolvedCmdName structure.
	 */
	v2 = resPtr + 40
	v1 = *(*Tsize_t)(unsafe.Pointer(v2))
	*(*Tsize_t)(unsafe.Pointer(v2))--
	if v1 <= uint64(1) {
		/*
		 * Now free the cached command, unless it is still in its hash
		 * table or if there are other references to it from other cmdName
		 * objects.
		 */
		cmdPtr = (*TResolvedCmdName)(unsafe.Pointer(resPtr)).FcmdPtr
		v4 = cmdPtr + 16
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclpFree(tls, cmdPtr)
		}
		XTclpFree(tls, resPtr)
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * DupCmdNameInternalRep --
 *
 *	Initialize the internal representation of an cmdName Tcl_Obj to a copy
 *	of the internal representation of an existing cmdName object.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	"copyPtr"s internal rep is set to point to the ResolvedCmdName
 *	structure corresponding to "srcPtr"s internal rep. Increments the ref
 *	count of the ResolvedCmdName structure pointed to by the cmdName's
 *	internal representation.
 *
 *----------------------------------------------------------------------
 */

func _DupCmdNameInternalRep(tls *libc.TLS, srcPtr uintptr, copyPtr uintptr) {
	/* Object with internal rep to set. */
	var resPtr uintptr
	_ = resPtr
	resPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(srcPtr + 32))).Fptr1
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(copyPtr + 32))).Fptr1 = resPtr
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(copyPtr + 32))).Fptr2 = libc.UintptrFromInt32(0)
	(*TResolvedCmdName)(unsafe.Pointer(resPtr)).FrefCount++
	(*TTcl_Obj)(unsafe.Pointer(copyPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclCmdNameType))
}

/*
 *----------------------------------------------------------------------
 *
 * SetCmdNameFromAny --
 *
 *	Generate an cmdName internal form for the Tcl object "objPtr".
 *
 * Results:
 *	The return value is a standard Tcl result. The conversion always
 *	succeeds and TCL_OK is returned.
 *
 * Side effects:
 *	A pointer to a ResolvedCmdName structure that holds a cached pointer
 *	to the command with a name that matches objPtr's string rep is stored
 *	as objPtr's internal representation. This ResolvedCmdName pointer will
 *	be NULL if no matching command was found. The ref count of the cached
 *	Command's structure (if any) is also incremented.
 *
 *----------------------------------------------------------------------
 */

func _SetCmdNameFromAny(tls *libc.TLS, interp uintptr, objPtr uintptr) (r int32) {
	/* The object to convert. */
	var cmdPtr, name, oldCmdPtr, resPtr, v1, v3, v5 uintptr
	var v2, v4 TTcl_Size
	_, _, _, _, _, _, _, _, _ = cmdPtr, name, oldCmdPtr, resPtr, v1, v2, v3, v4, v5
	if interp == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Find the Command structure, if any, that describes the command called
	 * "name". Build a ResolvedCmdName that holds a cached pointer to this
	 * Command, and bump the reference count in the referenced Command
	 * structure. A Command structure will not be deleted as long as it is
	 * referenced from a CmdName object.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		v1 = XTcl_GetString(tls, objPtr)
	}
	name = v1
	cmdPtr = XTcl_FindCommand(tls, interp, name, libc.UintptrFromInt32(0), 0)
	/*
	 * Stop shimmering and caching nothing when we found nothing.  Just
	 * report the failure to find the command as an error.
	 */
	if cmdPtr == libc.UintptrFromInt32(0) || !((*TCommand)(unsafe.Pointer(cmdPtr)).FhPtr != libc.UintptrFromInt32(0)) {
		return int32(TCL_ERROR)
	}
	resPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclCmdNameType)) && (*TResolvedCmdName)(unsafe.Pointer(resPtr)).FrefCount == uint64(1) {
		/*
		 * Re-use existing ResolvedCmdName struct when possible.
		 * Cleanup the old fields that need it.
		 */
		oldCmdPtr = (*TResolvedCmdName)(unsafe.Pointer(resPtr)).FcmdPtr
		v3 = oldCmdPtr + 16
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 <= int64(1) {
			v5 = oldCmdPtr + 16
			v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
			*(*TTcl_Size)(unsafe.Pointer(v5))--
			if v4 <= int64(1) {
				XTclpFree(tls, oldCmdPtr)
			}
		}
	} else {
		resPtr = libc.UintptrFromInt32(0)
	}
	_SetCmdNameObj(tls, interp, objPtr, cmdPtr, resPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_RepresentationCmd --
 *
 *	Implementation of the "tcl::unsupported::representation" command.
 *
 * Results:
 *	Reports the current representation (Tcl_Obj type) of its argument.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_RepresentationCmd(tls *libc.TLS, dummy4718 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var descObj, v1 uintptr
	_, _ = descObj, v1
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+3605)
		return int32(TCL_ERROR)
	}
	/*
	 * Value is a bignum with a refcount of 14, object pointer at 0x12345678,
	 * internal representation 0x45671234:0x98765432, string representation
	 * "1872361827361287"
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr != 0 {
		v1 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr)).Fname
	} else {
		v1 = __ccgo_ts + 55729
	}
	descObj = XTcl_ObjPrintf(tls, __ccgo_ts+55741, libc.VaList(bp+8, v1, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FrefCount, *(*uintptr)(unsafe.Pointer(objv + 1*8))))
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclDoubleType)) {
			XTcl_AppendPrintfToObj(tls, descObj, __ccgo_ts+55800, libc.VaList(bp+8, *(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FinternalRep))))
		} else {
			XTcl_AppendPrintfToObj(tls, descObj, __ccgo_ts+55829, libc.VaList(bp+8, (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1, (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2))
		}
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		XTcl_AppendToObj(tls, descObj, __ccgo_ts+55861, int64(-int32(1)))
		XTcl_AppendLimitedToObj(tls, descObj, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Flength, int64(16), __ccgo_ts+8560)
		XTcl_AppendToObj(tls, descObj, __ccgo_ts+14586, int64(-int32(1)))
	} else {
		XTcl_AppendToObj(tls, descObj, __ccgo_ts+55887, int64(-int32(1)))
	}
	XTcl_SetObjResult(tls, interp, descObj)
	return TCL_OK
}

/*
 * Helper macros.
 */

/*
 * ----------------------------------------------------------------------
 *
 * LocateTargetAddresses --
 *
 *	Populate a hash table with places that we need to be careful around
 *	because they're the targets of various kinds of jumps and other
 *	non-local behavior.
 *
 * ----------------------------------------------------------------------
 */

func _LocateTargetAddresses(tls *libc.TLS, envPtr uintptr, tablePtr uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var currentInstPtr, hPtr, rangePtr, targetInstPtr uintptr
	var i TTcl_Size
	var _ /* hSearch at bp+8 */ TTcl_HashSearch
	var _ /* isNew at bp+0 */ int32
	_, _, _, _, _ = currentInstPtr, hPtr, i, rangePtr, targetInstPtr
	XTcl_InitHashTable(tls, tablePtr, int32(TCL_ONE_WORD_KEYS))
	/*
	 * The starts of commands represent target addresses.
	 */
	i = 0
	for {
		if !(i < (*TCompileEnv)(unsafe.Pointer(envPtr)).FnumCommands) {
			break
		}
		(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FcreateProc})))(tls, tablePtr, (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart+uintptr((*(*TCmdLocation)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FcmdMapPtr + uintptr(i)*32))).FcodeOffset), bp)
		goto _1
	_1:
		;
		i++
	}
	/*
	 * Find places where we should be careful about replacing instructions
	 * because they are the targets of various types of jumps.
	 */
	currentInstPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart
	for {
		if !(currentInstPtr < (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext) {
			break
		}
		switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr))) {
		case int32(INST_JUMP_FALSE1):
			goto _3
		case int32(INST_JUMP_TRUE1):
			goto _4
		case int32(INST_JUMP1):
			goto _5
		case int32(INST_START_CMD):
			goto _6
		case int32(INST_JUMP_FALSE4):
			goto _7
		case int32(INST_JUMP_TRUE4):
			goto _8
		case int32(INST_JUMP4):
			goto _9
		case int32(INST_BEGIN_CATCH4):
			goto _10
		case int32(INST_JUMP_TABLE):
			goto _11
		case int32(INST_RETURN_CODE_BRANCH):
			goto _12
		}
		goto _13
	_5:
		;
	_4:
		;
	_3:
		;
		targetInstPtr = currentInstPtr + uintptr(int32(*(*int8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1)))))
		goto storeTarget
	_9:
		;
	_8:
		;
	_7:
		;
	_6:
		;
		targetInstPtr = currentInstPtr + uintptr(libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24)|libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16))|libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8))|uint32(*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))
		goto storeTarget
	_10:
		;
		targetInstPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr((*(*TExceptionRange)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayPtr + uintptr(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24)|libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)|libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)|libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))*56))).FcodeOffset)
		goto storeTarget
	storeTarget:
		;
		(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FcreateProc})))(tls, tablePtr, targetInstPtr, bp)
		goto _13
	_11:
		;
		hPtr = XTcl_FirstHashEntry(tls, (*(*TAuxData)(unsafe.Pointer((*TCompileEnv)(unsafe.Pointer(envPtr)).FauxDataArrayPtr + uintptr(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24)|libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)|libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)|libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))))))*16))).FclientData, bp+8)
		for {
			if !(hPtr != 0) {
				break
			}
			targetInstPtr = currentInstPtr + uintptr(int64((*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData))
			(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FcreateProc})))(tls, tablePtr, targetInstPtr, bp)
			goto _14
		_14:
			;
			hPtr = XTcl_NextHashEntry(tls, bp+8)
		}
		goto _13
	_12:
		;
		i = int64(TCL_ERROR)
		for {
			if !(i < int64(libc.Int32FromInt32(TCL_CONTINUE)+libc.Int32FromInt32(1))) {
				break
			}
			(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FcreateProc})))(tls, tablePtr, currentInstPtr+uintptr(libc.Int64FromInt32(2)*i)-libc.UintptrFromInt32(1), bp)
			goto _15
		_15:
			;
			i++
		}
		goto _13
	_13:
		;
		goto _2
	_2:
		;
		currentInstPtr += uintptr(XtclInstructionTable[*(*uint8)(unsafe.Pointer(currentInstPtr))].FnumBytes)
	}
	/*
	 * Add a marker *after* the last bytecode instruction. WARNING: points to
	 * one past the end!
	 */
	(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FcreateProc})))(tls, tablePtr, currentInstPtr, bp)
	/*
	 * Enter in the targets of exception ranges.
	 */
	i = 0
	for {
		if !(i < (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayNext) {
			break
		}
		rangePtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FexceptArrayPtr + uintptr(i)*56
		if (*TExceptionRange)(unsafe.Pointer(rangePtr)).Ftype1 == int32(CATCH_EXCEPTION_RANGE) {
			targetInstPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr((*TExceptionRange)(unsafe.Pointer(rangePtr)).FcatchOffset)
			(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FcreateProc})))(tls, tablePtr, targetInstPtr, bp)
		} else {
			targetInstPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr((*TExceptionRange)(unsafe.Pointer(rangePtr)).FbreakOffset)
			(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FcreateProc})))(tls, tablePtr, targetInstPtr, bp)
			if (*TExceptionRange)(unsafe.Pointer(rangePtr)).FcontinueOffset != int64(-libc.Int32FromInt32(1)) {
				targetInstPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart + uintptr((*TExceptionRange)(unsafe.Pointer(rangePtr)).FcontinueOffset)
				(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FcreateProc})))(tls, tablePtr, targetInstPtr, bp)
			}
		}
		goto _16
	_16:
		;
		i++
	}
}

/*
 * ----------------------------------------------------------------------
 *
 * TrimUnreachable --
 *
 *	Converts code that provably can't be executed into NOPs and reduces
 *	the overall reported length of the bytecode where that is possible.
 *
 * ----------------------------------------------------------------------
 */

func _TrimUnreachable(tls *libc.TLS, envPtr uintptr) {
	bp := tls.Alloc(112)
	defer tls.Free(112)
	var clear, v2 int32
	var currentInstPtr uintptr
	var _ /* targets at bp+0 */ TTcl_HashTable
	_, _, _ = clear, currentInstPtr, v2
	_LocateTargetAddresses(tls, envPtr, bp)
	currentInstPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart
	for {
		if !(currentInstPtr < (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext-uintptr(1)) {
			break
		}
		clear = 0
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr))) != int32(INST_DONE) {
			goto _1
		}
		for !((*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(bp)).FfindProc})))(tls, bp, currentInstPtr+libc.UintptrFromInt32(1)+uintptr(clear)) != libc.UintptrFromInt32(0)) {
			clear = int32(int64(clear) + XtclInstructionTable[*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1) + uintptr(clear)))].FnumBytes)
		}
		if currentInstPtr+uintptr(1)+uintptr(clear) == (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext {
			*(*uintptr)(unsafe.Pointer(envPtr + 152)) -= uintptr(clear)
		} else {
			for {
				v2 = clear
				clear--
				if !(v2 > 0) {
					break
				}
				*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1) + uintptr(clear))) = uint8(INST_NOP)
			}
		}
		goto _1
	_1:
		;
		currentInstPtr += uintptr(XtclInstructionTable[*(*uint8)(unsafe.Pointer(currentInstPtr))].FnumBytes)
	}
	XTcl_DeleteHashTable(tls, bp)
}

/*
 * ----------------------------------------------------------------------
 *
 * ConvertZeroEffectToNOP --
 *
 *	Replace PUSH/POP sequences (when non-hazardous) with NOPs. Also
 *	replace PUSH empty/STR_CONCAT and TRY_CVT_NUMERIC (when followed by an
 *	operation that guarantees the check for arithmeticity) and eliminate
 *	LNOT when we can invert the following JUMP condition.
 *
 * ----------------------------------------------------------------------
 */

func _ConvertZeroEffectToNOP(tls *libc.TLS, envPtr uintptr) {
	bp := tls.Alloc(128)
	defer tls.Free(128)
	var blank, i, nextInst, size int32
	var currentInstPtr, litPtr, litPtr1 uintptr
	var _ /* numBytes at bp+104 */ TTcl_Size
	var _ /* numBytes at bp+112 */ TTcl_Size
	var _ /* targets at bp+0 */ TTcl_HashTable
	_, _, _, _, _, _, _ = blank, currentInstPtr, i, litPtr, litPtr1, nextInst, size
	_LocateTargetAddresses(tls, envPtr, bp)
	currentInstPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart
	for {
		if !(currentInstPtr < (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext) {
			break
		}
		blank = 0
		size = int32(XtclInstructionTable[*(*uint8)(unsafe.Pointer(currentInstPtr))].FnumBytes)
		for currentInstPtr+uintptr(size) < (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr + uintptr(size)))) == int32(INST_NOP) {
			if (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(bp)).FfindProc})))(tls, bp, currentInstPtr+uintptr(size)) != libc.UintptrFromInt32(0) {
				break
			}
			size = int32(int64(size) + XtclInstructionTable[libc.Uint8FromInt32(int32(INST_NOP))].FnumBytes)
		}
		if (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(bp)).FfindProc})))(tls, bp, currentInstPtr+uintptr(size)) != libc.UintptrFromInt32(0) {
			goto _1
		}
		nextInst = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr + uintptr(size))))
		switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr))) {
		case int32(INST_PUSH1):
			if nextInst == int32(INST_POP) {
				blank = int32(int64(size) + XtclInstructionTable[libc.Uint8FromInt32(nextInst)].FnumBytes)
			} else {
				if nextInst == int32(INST_STR_CONCAT1) && uint32(*(*uint8)(unsafe.Pointer(currentInstPtr + uintptr(size) + libc.UintptrFromInt32(1)))) == uint32(2) {
					litPtr = XTclFetchLiteral(tls, envPtr, libc.Int64FromUint32(uint32(*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1))))))
					if (*TTcl_Obj)(unsafe.Pointer(litPtr)).Fbytes != 0 {
						*(*TTcl_Size)(unsafe.Pointer(bp + 104)) = (*TTcl_Obj)(unsafe.Pointer(litPtr)).Flength
						_ = (*TTcl_Obj)(unsafe.Pointer(litPtr)).Fbytes
					} else {
						XTcl_GetStringFromObj(tls, litPtr, bp+104)
					}
					if *(*TTcl_Size)(unsafe.Pointer(bp + 104)) == 0 {
						blank = int32(int64(size) + XtclInstructionTable[libc.Uint8FromInt32(nextInst)].FnumBytes)
					}
				}
			}
		case int32(INST_PUSH4):
			if nextInst == int32(INST_POP) {
				blank = size + int32(1)
			} else {
				if nextInst == int32(INST_STR_CONCAT1) && uint32(*(*uint8)(unsafe.Pointer(currentInstPtr + uintptr(size) + libc.UintptrFromInt32(1)))) == uint32(2) {
					litPtr1 = XTclFetchLiteral(tls, envPtr, libc.Int64FromUint32(libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24)|libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)|libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)|libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))))
					if (*TTcl_Obj)(unsafe.Pointer(litPtr1)).Fbytes != 0 {
						*(*TTcl_Size)(unsafe.Pointer(bp + 112)) = (*TTcl_Obj)(unsafe.Pointer(litPtr1)).Flength
						_ = (*TTcl_Obj)(unsafe.Pointer(litPtr1)).Fbytes
					} else {
						XTcl_GetStringFromObj(tls, litPtr1, bp+112)
					}
					if *(*TTcl_Size)(unsafe.Pointer(bp + 112)) == 0 {
						blank = int32(int64(size) + XtclInstructionTable[libc.Uint8FromInt32(nextInst)].FnumBytes)
					}
				}
			}
		case int32(INST_LNOT):
			switch nextInst {
			case int32(INST_JUMP_TRUE1):
				blank = size
				*(*uint8)(unsafe.Pointer(currentInstPtr + uintptr(size))) = uint8(INST_JUMP_FALSE1)
			case int32(INST_JUMP_FALSE1):
				blank = size
				*(*uint8)(unsafe.Pointer(currentInstPtr + uintptr(size))) = uint8(INST_JUMP_TRUE1)
			case int32(INST_JUMP_TRUE4):
				blank = size
				*(*uint8)(unsafe.Pointer(currentInstPtr + uintptr(size))) = uint8(INST_JUMP_FALSE4)
			case int32(INST_JUMP_FALSE4):
				blank = size
				*(*uint8)(unsafe.Pointer(currentInstPtr + uintptr(size))) = uint8(INST_JUMP_TRUE4)
				break
			}
		case int32(INST_TRY_CVT_TO_NUMERIC):
			switch nextInst {
			case int32(INST_JUMP_TRUE1):
				fallthrough
			case int32(INST_JUMP_TRUE4):
				fallthrough
			case int32(INST_JUMP_FALSE1):
				fallthrough
			case int32(INST_JUMP_FALSE4):
				fallthrough
			case int32(INST_INCR_SCALAR1):
				fallthrough
			case int32(INST_INCR_ARRAY1):
				fallthrough
			case int32(INST_INCR_ARRAY_STK):
				fallthrough
			case int32(INST_INCR_SCALAR_STK):
				fallthrough
			case int32(INST_INCR_STK):
				fallthrough
			case int32(INST_EQ):
				fallthrough
			case int32(INST_NEQ):
				fallthrough
			case int32(INST_LT):
				fallthrough
			case int32(INST_LE):
				fallthrough
			case int32(INST_GT):
				fallthrough
			case int32(INST_GE):
				fallthrough
			case int32(INST_MOD):
				fallthrough
			case int32(INST_LSHIFT):
				fallthrough
			case int32(INST_RSHIFT):
				fallthrough
			case int32(INST_BITOR):
				fallthrough
			case int32(INST_BITXOR):
				fallthrough
			case int32(INST_BITAND):
				fallthrough
			case int32(INST_EXPON):
				fallthrough
			case int32(INST_ADD):
				fallthrough
			case int32(INST_SUB):
				fallthrough
			case int32(INST_DIV):
				fallthrough
			case int32(INST_MULT):
				fallthrough
			case int32(INST_LNOT):
				fallthrough
			case int32(INST_BITNOT):
				fallthrough
			case int32(INST_UMINUS):
				fallthrough
			case int32(INST_UPLUS):
				fallthrough
			case int32(INST_TRY_CVT_TO_NUMERIC):
				blank = size
				break
			}
			break
		}
		if blank > 0 {
			i = 0
			for {
				if !(i < blank) {
					break
				}
				*(*uint8)(unsafe.Pointer(currentInstPtr + uintptr(i))) = uint8(INST_NOP)
				goto _4
			_4:
				;
				i++
			}
			size = blank
		}
		goto _1
	_1:
		;
		currentInstPtr += uintptr(size)
	}
	XTcl_DeleteHashTable(tls, bp)
}

/*
 * ----------------------------------------------------------------------
 *
 * AdvanceJumps --
 *
 *	Advance jumps past NOPs and chained JUMPs. After this runs, the only
 *	JUMPs that jump to a NOP or a JUMP will be length-1 ones that run out
 *	of room in their opcode to be targeted to where they really belong.
 *
 * ----------------------------------------------------------------------
 */

func _AdvanceJumps(tls *libc.TLS, envPtr uintptr) {
	bp := tls.Alloc(112)
	defer tls.Free(112)
	var currentInstPtr uintptr
	var delta, offset int32
	var _ /* isNew at bp+104 */ int32
	var _ /* jumps at bp+0 */ TTcl_HashTable
	_, _, _ = currentInstPtr, delta, offset
	currentInstPtr = (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeStart
	for {
		if !(currentInstPtr < (*TCompileEnv)(unsafe.Pointer(envPtr)).FcodeNext-uintptr(1)) {
			break
		}
		switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr))) {
		case int32(INST_JUMP1):
			fallthrough
		case int32(INST_JUMP_TRUE1):
			fallthrough
		case int32(INST_JUMP_FALSE1):
			offset = int32(*(*int8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1))))
			XTcl_InitHashTable(tls, bp, int32(TCL_ONE_WORD_KEYS))
			delta = 0
			for {
				if !(offset+delta != 0) {
					break
				}
				if offset+delta < -int32(128) || offset+delta > int32(127) {
					break
				}
				(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(bp)).FcreateProc})))(tls, bp, uintptr(int64(offset)), bp+104)
				if !(*(*int32)(unsafe.Pointer(bp + 104)) != 0) {
					offset = int32(*(*int8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1))))
					break
				}
				offset += delta
				switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr + uintptr(offset)))) {
				case int32(INST_NOP):
					delta = int32(XtclInstructionTable[libc.Uint8FromInt32(int32(INST_NOP))].FnumBytes)
					goto _2
				case int32(INST_JUMP1):
					delta = int32(*(*int8)(unsafe.Pointer(currentInstPtr + uintptr(offset) + libc.UintptrFromInt32(1))))
					goto _2
				case int32(INST_JUMP4):
					delta = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(currentInstPtr + uintptr(offset) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr + uintptr(offset) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr + uintptr(offset) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(currentInstPtr + uintptr(offset) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
					goto _2
				}
				break
				goto _2
			_2:
			}
			XTcl_DeleteHashTable(tls, bp)
			*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(offset))
			goto _1
		case int32(INST_JUMP4):
			fallthrough
		case int32(INST_JUMP_TRUE4):
			fallthrough
		case int32(INST_JUMP_FALSE4):
			XTcl_InitHashTable(tls, bp, int32(TCL_ONE_WORD_KEYS))
			(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(bp)).FcreateProc})))(tls, bp, uintptr(int64(libc.Int32FromInt32(0))), bp+104)
			offset = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
			for {
				if !(offset != 0) {
					break
				}
				(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(bp)).FcreateProc})))(tls, bp, uintptr(int64(offset)), bp+104)
				if !(*(*int32)(unsafe.Pointer(bp + 104)) != 0) {
					offset = libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
					break
				}
				switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr + uintptr(offset)))) {
				case int32(INST_NOP):
					offset = int32(int64(offset) + XtclInstructionTable[libc.Uint8FromInt32(int32(INST_NOP))].FnumBytes)
					goto _3
				case int32(INST_JUMP1):
					offset += int32(*(*int8)(unsafe.Pointer(currentInstPtr + uintptr(offset) + libc.UintptrFromInt32(1))))
					goto _3
				case int32(INST_JUMP4):
					offset += libc.Int32FromUint32(uint32(*(*uint8)(unsafe.Pointer(currentInstPtr + uintptr(offset) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr + uintptr(offset) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))))<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentInstPtr + uintptr(offset) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))))<<libc.Int32FromInt32(8)) | uint32(*(*uint8)(unsafe.Pointer(currentInstPtr + uintptr(offset) + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3)))))
					goto _3
				}
				break
				goto _3
			_3:
			}
			XTcl_DeleteHashTable(tls, bp)
			*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(offset) >> libc.Int32FromInt32(24))
			*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(1))) = uint8(libc.Uint32FromInt32(offset) >> libc.Int32FromInt32(16))
			*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(2))) = uint8(libc.Uint32FromInt32(offset) >> libc.Int32FromInt32(8))
			*(*uint8)(unsafe.Pointer(currentInstPtr + libc.UintptrFromInt32(1) + libc.UintptrFromInt32(3))) = uint8(libc.Uint32FromInt32(offset))
			goto _1
		}
		goto _1
	_1:
		;
		currentInstPtr += uintptr(XtclInstructionTable[*(*uint8)(unsafe.Pointer(currentInstPtr))].FnumBytes)
	}
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOptimizeBytecode --
 *
 *	A very simple peephole optimizer for bytecode.
 *
 * ----------------------------------------------------------------------
 */

func XTclOptimizeBytecode(tls *libc.TLS, envPtr uintptr) {
	_ConvertZeroEffectToNOP(tls, envPtr)
	_AdvanceJumps(tls, envPtr)
	_TrimUnreachable(tls, envPtr)
}

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * The panicProc variable contains a pointer to an application specific panic
 * procedure.
 */

var _panicProc = uintptr(0)

func init() {
	p := unsafe.Pointer(&_panicProc)
	*(*uintptr)(unsafe.Add(p, 0)) = libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetPanicProc --
 *
 *	Replace the default panic behavior with the specified function.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Sets the panicProc variable.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetPanicProc(tls *libc.TLS, proc uintptr) (r uintptr) {
	_panicProc = proc
	return XTcl_InitSubsystems(tls)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_Panic --
 *
 *	Print an error message and kill the process.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The process dies, entering the debugger if possible.
 *
 *----------------------------------------------------------------------
 */

/*
 * The following comment is here so that Coverity's static analyzer knows that
 * a Tcl_Panic() call can never return and avoids lots of false positives.
 */

// C documentation
//
//	/* coverity[+kill] */
func XTcl_Panic(tls *libc.TLS, format uintptr, va uintptr) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8 uintptr
	var argList Tva_list
	_, _, _, _, _, _, _, _, _ = arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, argList
	argList = va
	arg1 = libc.VaUintptr(&argList)
	arg2 = libc.VaUintptr(&argList)
	arg3 = libc.VaUintptr(&argList)
	arg4 = libc.VaUintptr(&argList)
	arg5 = libc.VaUintptr(&argList)
	arg6 = libc.VaUintptr(&argList)
	arg7 = libc.VaUintptr(&argList)
	arg8 = libc.VaUintptr(&argList)
	_ = argList
	if _panicProc != libc.UintptrFromInt32(0) {
		(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{_panicProc})))(tls, format, libc.VaList(bp+8, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8))
	} else {
		libc.Xfprintf(tls, libc.Xstderr, format, libc.VaList(bp+8, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8))
		libc.Xfprintf(tls, libc.Xstderr, __ccgo_ts+286, 0)
		libc.Xfflush(tls, libc.Xstderr)
	}
	libc.X__builtin_trap(tls)
	libc.Xabort(tls)
}

type ParseTypeFlags = int32

const TYPE_NORMAL = 0
const TYPE_SPACE = 1
const TYPE_COMMAND_END = 2
const TYPE_SUBS = 4
const TYPE_QUOTE = 8
const TYPE_CLOSE_PAREN = 16
const TYPE_CLOSE_BRACK = 32
const TYPE_BRACE = 64
const TYPE_OPEN_PAREN = 128
const TYPE_BAD_ARRAY_INDEX = 216

/*
 *----------------------------------------------------------------------
 *
 * TclParseInit --
 *
 *	Initialize the fields of a Tcl_Parse struct.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The Tcl_Parse struct pointed to by parsePtr gets initialized.
 *
 *----------------------------------------------------------------------
 */

func XTclParseInit(tls *libc.TLS, interp uintptr, start uintptr, numBytes TTcl_Size, parsePtr uintptr) {
	/* Points to struct to initialize */
	(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords = 0
	(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr = parsePtr + 104
	(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens = 0
	(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokensAvailable = int64(NUM_STATIC_TOKENS)
	(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fstring1 = start
	(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fend = start + uintptr(numBytes)
	(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fend
	(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Finterp = interp
	(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fincomplete = 0
	(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FerrorType = TCL_PARSE_SUCCESS
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ParseCommand --
 *
 *	Given a string, this function parses the first Tcl command in the
 *	string and returns information about the structure of the command.
 *
 * Results:
 *	The return value is TCL_OK if the command was parsed successfully and
 *	TCL_ERROR otherwise. If an error occurs and interp isn't NULL then an
 *	error message is left in its result. On a successful return, parsePtr
 *	is filled in with information about the command that was parsed.
 *
 * Side effects:
 *	If there is insufficient space in parsePtr to hold all the information
 *	about the command, then additional space is malloc-ed. If the function
 *	returns TCL_OK then the caller must eventually invoke Tcl_FreeParse to
 *	release any additional space that was allocated.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ParseCommand(tls *libc.TLS, interp uintptr, start uintptr, numBytes TTcl_Size, nested int32, parsePtr uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	/* Structure to fill in with information about
	 * the parsed command; any previous
	 * information in the structure is ignored. */
	var _needed, _needed1, allocated, allocated1, elemCount, expIdx, growthNeeded, i, scanned, wordIndex TTcl_Size
	var code, expandWord, isLiteral, quoted, terminators int32
	var expPtr, listEnd, listStart, newPtr, newPtr1, oldPtr, oldPtr1, src, tokenPtr, v5 uintptr
	var _ /* elemStart at bp+32 */ uintptr
	var _ /* literal at bp+16 */ int32
	var _ /* nextElem at bp+24 */ uintptr
	var _ /* size at bp+40 */ TTcl_Size
	var _ /* termPtr at bp+8 */ uintptr
	var _ /* type at bp+0 */ uint8
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _needed, _needed1, allocated, allocated1, code, elemCount, expIdx, expPtr, expandWord, growthNeeded, i, isLiteral, listEnd, listStart, newPtr, newPtr1, oldPtr, oldPtr1, quoted, scanned, src, terminators, tokenPtr, wordIndex, v5
	if numBytes < 0 && start != 0 {
		numBytes = libc.Int64FromUint64(libc.Xstrlen(tls, start))
	}
	XTclParseInit(tls, interp, start, numBytes, parsePtr)
	if start == libc.UintptrFromInt32(0) && numBytes != 0 {
		if interp != libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+55914, int64(-int32(1))))
		}
		return int32(TCL_ERROR)
	}
	(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommentStart = libc.UintptrFromInt32(0)
	(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommentSize = 0
	(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart = libc.UintptrFromInt32(0)
	(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandSize = 0
	if nested != 0 {
		terminators = int32(TYPE_COMMAND_END) | int32(TYPE_CLOSE_BRACK)
	} else {
		terminators = int32(TYPE_COMMAND_END)
	}
	/*
	 * Parse any leading space and comments before the first word of the
	 * command.
	 */
	scanned = _ParseComment(tls, start, numBytes, parsePtr)
	src = start + uintptr(scanned)
	numBytes -= scanned
	if numBytes == 0 {
		if nested != 0 {
			(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fincomplete = nested
		}
	}
	/*
	 * The following loop parses the words of the command, one word in each
	 * iteration through the loop.
	 */
	(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart = src
	*(*uint8)(unsafe.Pointer(bp)) = XtclCharTypeTable[*(*uint8)(unsafe.Pointer(src))]
	scanned = int64(1) /* Can't have missing whitepsace before first word. */
_2:
	;
	if !(int32(1) != 0) {
		goto _1
	}
	expandWord = 0
	/* Are we at command termination? */
	if numBytes == 0 || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp)))&terminators != 0 {
		(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm = src
		(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandSize = int64(src+libc.BoolUintptr(numBytes != libc.Int64FromInt32(0))) - int64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart)
		return TCL_OK
	}
	/* Are we missing white space after previous word? */
	if !(scanned == 0) {
		goto _3
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + uintptr(-libc.Int32FromInt32(1))))) == int32('"') {
		if interp != libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+55941, int64(-int32(1))))
		}
		(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FerrorType = int32(TCL_PARSE_QUOTE_EXTRA)
	} else {
		if interp != libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+55976, int64(-int32(1))))
		}
		(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FerrorType = int32(TCL_PARSE_BRACE_EXTRA)
	}
	(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm = src
	goto error
error:
	;
	XTcl_FreeParse(tls, parsePtr)
	(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandSize = int64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fend) - int64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommandStart)
	return int32(TCL_ERROR)
_3:
	;
	/*
	 * Create the token for the word.
	 */
	_needed = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens + int64(libc.Int32FromInt32(1))
	if _needed > (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokensAvailable {
		allocated = int64(2) * _needed
		oldPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
		if oldPtr == parsePtr+104 {
			oldPtr = libc.UintptrFromInt32(0)
		}
		newPtr = XTclpRealloc(tls, oldPtr, libc.Uint64FromInt64(allocated)*uint64(32))
		if newPtr == libc.UintptrFromInt32(0) {
			allocated = libc.Int64FromUint64(libc.Uint64FromInt64(_needed+int64(libc.Int32FromInt32(1))) + libc.Uint64FromInt32(TCL_MIN_GROWTH)/libc.Uint64FromInt64(32))
			newPtr = XTcl_Realloc(tls, oldPtr, libc.Uint64FromInt64(allocated)*uint64(32))
		}
		(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokensAvailable = allocated
		if oldPtr == libc.UintptrFromInt32(0) {
			libc.Xmemcpy(tls, newPtr, parsePtr+104, libc.Uint64FromInt64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens)*uint64(32))
		}
		(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr = newPtr
	}
	wordIndex = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr(wordIndex)*32
	(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 = int32(TCL_TOKEN_WORD)
	(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart = src
	(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens++
	(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords++
	/*
	 * At this point the word can have one of four forms: something
	 * enclosed in quotes, something enclosed in braces, and expanding
	 * word, or an unquoted word (anything else).
	 */
	goto parseWord
parseWord:
	;
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) == int32('"') {
		if XTcl_ParseQuotedString(tls, interp, src, numBytes, parsePtr, int32(1), bp+8) != TCL_OK {
			goto error
		}
		src = *(*uintptr)(unsafe.Pointer(bp + 8))
		numBytes = int64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fend) - int64(src)
	} else {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) == int32('{') {
			expIdx = wordIndex + int64(1)
			if XTcl_ParseBraces(tls, interp, src, numBytes, parsePtr, int32(1), bp+8) != TCL_OK {
				goto error
			}
			src = *(*uintptr)(unsafe.Pointer(bp + 8))
			numBytes = int64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fend) - int64(src)
			/*
			 * Check whether the braces contained the word expansion prefix
			 * {*}
			 */
			expPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr(expIdx)*32
			if 0 == expandWord && expIdx+int64(1) == (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens && (int64(1) == (*TTcl_Token)(unsafe.Pointer(expPtr)).Fsize && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_Token)(unsafe.Pointer(expPtr)).Fstart))) == int32('*')) && numBytes > 0 && 0 == _ParseWhiteSpace(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), numBytes, parsePtr+68, bp) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) != int32(TYPE_COMMAND_END) {
				expandWord = int32(1)
				(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens--
				goto parseWord
			}
		} else {
			/*
			 * This is an unquoted word. Call ParseTokens and let it do all of
			 * the work.
			 */
			if _ParseTokens(tls, src, numBytes, int32(TYPE_SPACE)|terminators, int32(TCL_SUBST_ALL), parsePtr) != TCL_OK {
				goto error
			}
			src = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm
			numBytes = int64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fend) - int64(src)
		}
	}
	/*
	 * Finish filling in the token for the word and check for the special
	 * case of a word consisting of a single range of literal text.
	 */
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr(wordIndex)*32
	(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize = int64(src) - int64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart)
	(*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens - (wordIndex + int64(1))
	if expandWord != 0 {
		isLiteral = int32(1)
		/*
		 * When a command includes a word that is an expanded literal; for
		 * example, {*}{1 2 3}, the parser performs that expansion
		 * immediately, generating several TCL_TOKEN_SIMPLE_WORDs instead
		 * of a single TCL_TOKEN_EXPAND_WORD that the Tcl_ParseCommand()
		 * caller might have to expand. This notably makes it simpler for
		 * those callers that wish to track line endings, such as those
		 * that implement key parts of TIP 280.
		 *
		 * First check whether the thing to be expanded is a literal,
		 * in the sense of being composed entirely of TCL_TOKEN_TEXT
		 * tokens.
		 */
		i = int64(1)
		for {
			if !(i <= (*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents) {
				break
			}
			if (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + uintptr(i)*32))).Ftype1 != int32(TCL_TOKEN_TEXT) {
				isLiteral = 0
				break
			}
			goto _4
		_4:
			;
			i++
		}
		if isLiteral != 0 {
			elemCount = 0
			code = TCL_OK
			*(*int32)(unsafe.Pointer(bp + 16)) = int32(1)
			/*
			 * The word to be expanded is a literal, so determine the
			 * boundaries of the literal string to be treated as a list
			 * and expanded. That literal string starts at
			 * tokenPtr[1].start, and includes all bytes up to, but not
			 * including (tokenPtr[tokenPtr->numComponents].start +
			 * tokenPtr[tokenPtr->numComponents].size)
			 */
			listEnd = (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents)*32))).Fstart + uintptr((*(*TTcl_Token)(unsafe.Pointer(tokenPtr + uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents)*32))).Fsize)
			*(*uintptr)(unsafe.Pointer(bp + 24)) = (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart
			/*
			 * Step through the literal string, parsing and counting list
			 * elements.
			 */
			for *(*uintptr)(unsafe.Pointer(bp + 24)) < listEnd {
				code = XTclFindElement(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 24)), int64(listEnd)-int64(*(*uintptr)(unsafe.Pointer(bp + 24))), bp+32, bp+24, bp+40, bp+16)
				if code != TCL_OK || !(*(*int32)(unsafe.Pointer(bp + 16)) != 0) {
					break
				}
				if *(*uintptr)(unsafe.Pointer(bp + 32)) < listEnd {
					elemCount++
				}
			}
			if code != TCL_OK || !(*(*int32)(unsafe.Pointer(bp + 16)) != 0) {
				/*
				 * Some list element could not be parsed, or is not
				 * present as a literal substring of the script.  The
				 * compiler cannot handle list elements that get generated
				 * by a call to TclCopyAndCollapse(). Defer  the
				 * handling of  this to  compile/eval time, where  code is
				 * already  in place to  report the  "attempt to  expand a
				 * non-list" error or expand lists that require
				 * substitution.
				 */
				(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 = int32(TCL_TOKEN_EXPAND_WORD)
			} else {
				if elemCount == 0 {
					/*
					 * We are expanding a literal empty list. This means that
					 * the expanding word completely disappears, leaving no
					 * word generated this pass through the loop. Adjust
					 * accounting appropriately.
					 */
					(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumWords--
					(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens = wordIndex
				} else {
					growthNeeded = wordIndex + int64(2)*elemCount - (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens
					*(*TTcl_Size)(unsafe.Pointer(parsePtr + 32)) += elemCount - int64(1)
					if growthNeeded > 0 {
						_needed1 = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens + growthNeeded
						if _needed1 > (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokensAvailable {
							allocated1 = int64(2) * _needed1
							oldPtr1 = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
							if oldPtr1 == parsePtr+104 {
								oldPtr1 = libc.UintptrFromInt32(0)
							}
							newPtr1 = XTclpRealloc(tls, oldPtr1, libc.Uint64FromInt64(allocated1)*uint64(32))
							if newPtr1 == libc.UintptrFromInt32(0) {
								allocated1 = libc.Int64FromUint64(libc.Uint64FromInt64(_needed1+growthNeeded) + libc.Uint64FromInt32(TCL_MIN_GROWTH)/libc.Uint64FromInt64(32))
								newPtr1 = XTcl_Realloc(tls, oldPtr1, libc.Uint64FromInt64(allocated1)*uint64(32))
							}
							(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokensAvailable = allocated1
							if oldPtr1 == libc.UintptrFromInt32(0) {
								libc.Xmemcpy(tls, newPtr1, parsePtr+104, libc.Uint64FromInt64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens)*uint64(32))
							}
							(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr = newPtr1
						}
						tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr(wordIndex)*32
					}
					(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens = wordIndex + int64(2)*elemCount
					/*
					 * Generate a TCL_TOKEN_SIMPLE_WORD token sequence for
					 * each element of the literal list we are expanding in
					 * place. Take care with the start and size fields of each
					 * token so they point to the right literal characters in
					 * the original script to represent the right expanded
					 * word value.
					 */
					v5 = (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart
					*(*uintptr)(unsafe.Pointer(bp + 24)) = v5
					listStart = v5
					for *(*uintptr)(unsafe.Pointer(bp + 24)) < listEnd {
						(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 = int32(TCL_TOKEN_SIMPLE_WORD)
						(*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents = int64(1)
						tokenPtr += 32
						(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 = int32(TCL_TOKEN_TEXT)
						(*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents = 0
						XTclFindElement(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 24)), int64(listEnd)-int64(*(*uintptr)(unsafe.Pointer(bp + 24))), tokenPtr+8, bp+24, tokenPtr+16, libc.UintptrFromInt32(0))
						quoted = libc.BoolInt32((libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart + uintptr(-libc.Int32FromInt32(1))))) == int32('{') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart + uintptr(-libc.Int32FromInt32(1))))) == int32('"')) && (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart > listStart)
						(*(*TTcl_Token)(unsafe.Pointer(tokenPtr + uintptr(-libc.Int32FromInt32(1))*32))).Fstart = (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart - uintptr(quoted)
						(*(*TTcl_Token)(unsafe.Pointer(tokenPtr + uintptr(-libc.Int32FromInt32(1))*32))).Fsize = int64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart+uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize)) - int64((*(*TTcl_Token)(unsafe.Pointer(tokenPtr + uintptr(-libc.Int32FromInt32(1))*32))).Fstart) + int64(quoted)
						tokenPtr += 32
					}
				}
			}
		} else {
			/*
			 * The word to be expanded is not a literal, so defer
			 * expansion to compile/eval time by marking with a
			 * TCL_TOKEN_EXPAND_WORD token.
			 */
			(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 = int32(TCL_TOKEN_EXPAND_WORD)
		}
	} else {
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents == int64(1) && (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Ftype1 == int32(TCL_TOKEN_TEXT) {
			(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 = int32(TCL_TOKEN_SIMPLE_WORD)
		}
	}
	/* Parse the whitespace between words. */
	scanned = _ParseWhiteSpace(tls, src, numBytes, parsePtr+68, bp)
	src += uintptr(scanned)
	numBytes -= scanned
	goto _2
_1:
	;
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * TclIsSpaceProc --
 *
 *	Report whether byte is in the set of whitespace characters used by
 *	Tcl to separate words in scripts or elements in lists.
 *
 * Results:
 *	Returns 1, if byte is in the set, 0 otherwise.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclIsSpaceProc(tls *libc.TLS, byte1 int32) (r int32) {
	return libc.BoolInt32(libc.Int32FromUint8(XtclCharTypeTable[libc.Uint8FromInt32(byte1)])&int32(TYPE_SPACE) != 0 || byte1 == int32('\n'))
}

/*
 *----------------------------------------------------------------------
 *
 * TclIsBareword--
 *
 *	Report whether byte is one that can be part of a "bareword".
 *	This concept is named in expression parsing, where it determines
 *	what can be a legal function name, but is the same definition used
 *	in determining what variable names can be parsed as variable
 *	substitutions without the benefit of enclosing braces.  The set of
 *	ASCII chars that are accepted are the numeric chars ('0'-'9'),
 *	the alphabetic chars ('a'-'z', 'A'-'Z')	and underscore ('_').
 *
 * Results:
 *	Returns 1, if byte is in the accepted set of chars, 0 otherwise.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclIsBareword(tls *libc.TLS, byte1 int32) (r int32) {
	if byte1 < int32('0') || byte1 > int32('z') {
		return 0
	}
	if byte1 <= int32('9') || byte1 >= int32('a') {
		return int32(1)
	}
	if byte1 == int32('_') {
		return int32(1)
	}
	if byte1 < int32('A') || byte1 > int32('Z') {
		return 0
	}
	return int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * ParseWhiteSpace --
 *
 *	Scans up to numBytes bytes starting at src, consuming white space
 *	between words as defined by Tcl's parsing rules.
 *
 * Results:
 *	Returns the number of bytes recognized as white space. Records at
 *	parsePtr, information about the parse. Records at typePtr the
 *	character type of the non-whitespace character that terminated the
 *	scan.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _ParseWhiteSpace(tls *libc.TLS, src uintptr, numBytes TTcl_Size, incompletePtr uintptr, typePtr uintptr) (r TTcl_Size) {
	/* Points to location to store character type
	 * of character that ends run of whitespace */
	var p uintptr
	var type1, v1 uint8
	var v2 bool
	var v3, v4 TTcl_Size
	_, _, _, _, _, _ = p, type1, v1, v2, v3, v4
	type1 = uint8(TYPE_NORMAL)
	p = src
	for int32(1) != 0 {
		for {
			if v2 = numBytes != 0; v2 {
				v1 = XtclCharTypeTable[*(*uint8)(unsafe.Pointer(p))]
				type1 = v1
			}
			if !(v2 && libc.Int32FromUint8(v1)&int32(TYPE_SPACE) != 0) {
				break
			}
			numBytes--
			p++
		}
		if numBytes != 0 && libc.Int32FromUint8(type1)&int32(TYPE_SUBS) != 0 {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('\\') {
				break
			}
			numBytes--
			v3 = numBytes
			if v3 == 0 {
				break
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) != int32('\n') {
				break
			}
			p += uintptr(2)
			numBytes--
			v4 = numBytes
			if v4 == 0 {
				*(*int32)(unsafe.Pointer(incompletePtr)) = int32(1)
				break
			}
			continue
		}
		break
	}
	*(*uint8)(unsafe.Pointer(typePtr)) = type1
	return int64(p) - int64(src)
}

/*
 *----------------------------------------------------------------------
 *
 * TclParseAllWhiteSpace --
 *
 *	Scans up to numBytes bytes starting at src, consuming all white space
 *	including the command-terminating newline characters.
 *
 * Results:
 *	Returns the number of bytes recognized as white space.
 *
 *----------------------------------------------------------------------
 */

func _ParseAllWhiteSpace(tls *libc.TLS, src uintptr, numBytes TTcl_Size, incompletePtr uintptr) (r TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Set true if parse is incomplete. */
	var p uintptr
	var scanned, v1 TTcl_Size
	var v2 bool
	var _ /* type at bp+0 */ uint8
	_, _, _, _ = p, scanned, v1, v2
	p = src
	for {
		scanned = _ParseWhiteSpace(tls, p, numBytes, incompletePtr, bp)
		p += uintptr(scanned)
		numBytes -= scanned
		goto _3
	_3:
		;
		if v2 = numBytes != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('\n'); v2 {
			p++
			numBytes--
			v1 = numBytes
		}
		if !(v2 && v1 != 0) {
			break
		}
	}
	return int64(p) - int64(src)
}

func XTclParseAllWhiteSpace(tls *libc.TLS, src uintptr, numBytes TTcl_Size) (r TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Max number of byes to scan */
	var _ /* dummy at bp+0 */ int32
	return _ParseAllWhiteSpace(tls, src, numBytes, bp)
}

/*
 *----------------------------------------------------------------------
 *
 * ParseHex --
 *
 *	Scans a hexadecimal number as a Tcl_UniChar value (e.g., for parsing
 *	\x and \u escape sequences). At most numBytes bytes are scanned.
 *
 * Results:
 *	The numeric value is stored in *resultPtr. Returns the number of bytes
 *	consumed.
 *
 * Notes:
 *	Relies on the following properties of the ASCII character set, with
 *	which UTF-8 is compatible:
 *
 *	The digits '0' .. '9' and the letters 'A' .. 'Z' and 'a' .. 'z' occupy
 *	consecutive code points, and '0' < 'A' < 'a'.
 *
 *----------------------------------------------------------------------
 */

func _ParseHex(tls *libc.TLS, src uintptr, numBytes TTcl_Size, resultPtr uintptr) (r int32) {
	/* Points to storage provided by caller where
	 * the character resulting from the
	 * conversion is to be written. */
	var digit uint8
	var p uintptr
	var result int32
	var v1 TTcl_Size
	_, _, _, _ = digit, p, result, v1
	result = 0
	p = src
	for {
		v1 = numBytes
		numBytes--
		if !(v1 != 0) {
			break
		}
		digit = *(*uint8)(unsafe.Pointer(p))
		if !(libc.Xisxdigit(tls, libc.Int32FromUint8(digit)) != 0) || result > int32(0x10FFF) {
			break
		}
		p++
		result <<= int32(4)
		if libc.Int32FromUint8(digit) >= int32('a') {
			result |= int32(10) + libc.Int32FromUint8(digit) - int32('a')
		} else {
			if libc.Int32FromUint8(digit) >= int32('A') {
				result |= int32(10) + libc.Int32FromUint8(digit) - int32('A')
			} else {
				result |= libc.Int32FromUint8(digit) - int32('0')
			}
		}
	}
	*(*int32)(unsafe.Pointer(resultPtr)) = result
	return int32(int64(p) - int64(src))
}

/*
 *----------------------------------------------------------------------
 *
 * TclParseBackslash --
 *
 *	Scans up to numBytes bytes starting at src, consuming a backslash
 *	sequence as defined by Tcl's parsing rules.
 *
 * Results:
 *	Records at readPtr the number of bytes making up the backslash
 *	sequence. Records at dst the UTF-8 encoded equivalent of that
 *	backslash sequence. Returns the number of bytes written to dst, at
 *	most TCL_UTF_MAX. Either readPtr or dst may be NULL, if the results
 *	are not needed, but the return value is the same either way.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclParseBackslash(tls *libc.TLS, src uintptr, numBytes TTcl_Size, readPtr uintptr, dst uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* NULL, or points to buffer where the UTF-8
	 * encoding of the backslash sequence is to be
	 * written. At most 4 bytes will be written there. */
	var count TTcl_Size
	var p uintptr
	var v1, v2, v3, v4, v5 int64
	var _ /* buf at bp+8 */ [4]uint8
	var _ /* result at bp+4 */ int32
	var _ /* unichar at bp+0 */ int32
	var _ /* utfBytes at bp+16 */ [8]uint8
	_, _, _, _, _, _, _ = count, p, v1, v2, v3, v4, v5
	p = src + uintptr(1)
	*(*[4]uint8)(unsafe.Pointer(bp + 8)) = [4]uint8{}
	if numBytes == 0 {
		if readPtr != libc.UintptrFromInt32(0) {
			*(*TTcl_Size)(unsafe.Pointer(readPtr)) = 0
		}
		return 0
	}
	if dst == libc.UintptrFromInt32(0) {
		dst = bp + 8
	}
	if numBytes == int64(1) {
		/*
		 * Can only scan the backslash, so return it.
		 */
		*(*int32)(unsafe.Pointer(bp + 4)) = int32('\\')
		count = int64(1)
		goto done
	}
	count = int64(2)
	switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) {
	/*
	 * Note: in the conversions below, use absolute values (e.g., 0xA)
	 * rather than symbolic values (e.g. \n) that get converted by the
	 * compiler. It's possible that compilers on some platforms will do
	 * the symbolic conversions differently, which could result in
	 * non-portable Tcl scripts.
	 */
	case int32('a'):
		*(*int32)(unsafe.Pointer(bp + 4)) = int32(0x7)
	case int32('b'):
		*(*int32)(unsafe.Pointer(bp + 4)) = int32(0x8)
	case int32('f'):
		*(*int32)(unsafe.Pointer(bp + 4)) = int32(0xC)
	case int32('n'):
		*(*int32)(unsafe.Pointer(bp + 4)) = int32(0xA)
	case int32('r'):
		*(*int32)(unsafe.Pointer(bp + 4)) = int32(0xD)
	case int32('t'):
		*(*int32)(unsafe.Pointer(bp + 4)) = int32(0x9)
	case int32('v'):
		*(*int32)(unsafe.Pointer(bp + 4)) = int32(0xB)
	case int32('x'):
		if numBytes > int64(3) {
			v1 = int64(2)
		} else {
			v1 = numBytes - int64(2)
		}
		count += int64(_ParseHex(tls, p+uintptr(1), v1, bp+4))
		if count == int64(2) {
			/*
			 * No hexdigits -> This is just "x".
			 */
			*(*int32)(unsafe.Pointer(bp + 4)) = int32('x')
		} else {
			/*
			 * Keep only the last byte (2 hex digits).
			 */
			*(*int32)(unsafe.Pointer(bp + 4)) = libc.Int32FromUint8(libc.Uint8FromInt32(*(*int32)(unsafe.Pointer(bp + 4))))
		}
	case int32('u'):
		if numBytes > int64(5) {
			v2 = int64(4)
		} else {
			v2 = numBytes - int64(2)
		}
		count += int64(_ParseHex(tls, p+uintptr(1), v2, bp+4))
		if count == int64(2) {
			/*
			 * No hexdigits -> This is just "u".
			 */
			*(*int32)(unsafe.Pointer(bp + 4)) = int32('u')
		}
	case int32('U'):
		if numBytes > int64(9) {
			v3 = int64(8)
		} else {
			v3 = numBytes - int64(2)
		}
		count += int64(_ParseHex(tls, p+uintptr(1), v3, bp+4))
		if count == int64(2) {
			/*
			 * No hexdigits -> This is just "U".
			 */
			*(*int32)(unsafe.Pointer(bp + 4)) = int32('U')
		}
	case int32('\n'):
		count--
		for cond := true; cond; cond = count < numBytes && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(' ') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('\t')) {
			p++
			count++
		}
		*(*int32)(unsafe.Pointer(bp + 4)) = int32(' ')
	case 0:
		*(*int32)(unsafe.Pointer(bp + 4)) = int32('\\')
		count = int64(1)
	default:
		/*
		 * Check for an octal number \oo?o?
		 */
		if libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) < int32('8') { /* INTL: digit */
			*(*int32)(unsafe.Pointer(bp + 4)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - int32('0')
			p++
			if numBytes == int64(2) || !(libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-libc.Uint32FromUint8('0') < libc.Uint32FromInt32(10)) != 0) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) >= int32('8') {
				break
			}
			count = int64(3)
			*(*int32)(unsafe.Pointer(bp + 4)) = *(*int32)(unsafe.Pointer(bp + 4))<<int32(3) + (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - int32('0'))
			p++
			if numBytes == int64(3) || !(libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-libc.Uint32FromUint8('0') < libc.Uint32FromInt32(10)) != 0) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) >= int32('8') || *(*int32)(unsafe.Pointer(bp + 4)) >= int32(0x20) {
				break
			}
			count = int64(4)
			*(*int32)(unsafe.Pointer(bp + 4)) = libc.Int32FromUint8(libc.Uint8FromInt32(*(*int32)(unsafe.Pointer(bp + 4))<<libc.Int32FromInt32(3) + (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - libc.Int32FromUint8('0'))))
			break
		}
		/*
		 * We have to convert here in case the user has put a backslash in
		 * front of a multi-byte utf-8 character. While this means nothing
		 * special, we shouldn't break up a correct utf-8 character. [Bug
		 * #217987] test subst-3.2
		 */
		if XTcl_UtfCharComplete(tls, p, numBytes-int64(1)) != 0 {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) < int32(0x80) {
				*(*int32)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))
				v4 = int64(libc.Int32FromInt32(1))
			} else {
				v4 = XTcl_UtfToUniChar(tls, p, bp)
			}
			count = v4 + int64(1) /* +1 for '\' */
		} else {
			libc.Xmemcpy(tls, bp+16, p, libc.Uint64FromInt64(numBytes-int64(1)))
			(*(*[8]uint8)(unsafe.Pointer(bp + 16)))[numBytes-int64(1)] = uint8('\000')
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 16))) < int32(0x80) {
				*(*int32)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 16)))
				v5 = int64(libc.Int32FromInt32(1))
			} else {
				v5 = XTcl_UtfToUniChar(tls, bp+16, bp)
			}
			count = v5 + int64(1)
		}
		*(*int32)(unsafe.Pointer(bp + 4)) = *(*int32)(unsafe.Pointer(bp))
		break
	}
	goto done
done:
	;
	if readPtr != libc.UintptrFromInt32(0) {
		*(*TTcl_Size)(unsafe.Pointer(readPtr)) = count
	}
	count = XTcl_UniCharToUtf(tls, *(*int32)(unsafe.Pointer(bp + 4)), dst)
	return int32(count)
}

/*
 *----------------------------------------------------------------------
 *
 * ParseComment --
 *
 *	Scans up to numBytes bytes starting at src, consuming a Tcl comment as
 *	defined by Tcl's parsing rules.
 *
 * Results:
 *	Records in parsePtr information about the parse. Returns the number of
 *	bytes consumed.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _ParseComment(tls *libc.TLS, src uintptr, numBytes TTcl_Size, parsePtr uintptr) (r TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Information about parse in progress.
	 * Updated if parsing indicates an incomplete
	 * command. */
	var p uintptr
	var scanned TTcl_Size
	var _ /* incomplete at bp+0 */ int32
	_, _ = p, scanned
	p = src
	*(*int32)(unsafe.Pointer(bp)) = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fincomplete
	for numBytes != 0 {
		scanned = _ParseAllWhiteSpace(tls, p, numBytes, bp)
		p += uintptr(scanned)
		numBytes -= scanned
		if numBytes == 0 || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('#') {
			break
		}
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommentStart == libc.UintptrFromInt32(0) {
			(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommentStart = p
		}
		p++
		numBytes--
		for numBytes != 0 {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('\n') {
				p++
				numBytes--
				break
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('\\') {
				p++
				numBytes--
				if numBytes == 0 {
					break
				}
			}
			*(*int32)(unsafe.Pointer(bp)) = libc.BoolInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('\n'))
			p++
			numBytes--
		}
		(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommentSize = int64(p) - int64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FcommentStart)
	}
	(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fincomplete = *(*int32)(unsafe.Pointer(bp))
	return int64(p) - int64(src)
}

/*
 *----------------------------------------------------------------------
 *
 * ParseTokens --
 *
 *	This function forms the heart of the Tcl parser. It parses one or more
 *	tokens from a string, up to a termination point specified by the
 *	caller. This function is used to parse unquoted command words (those
 *	not in quotes or braces), words in quotes, and array indices for
 *	variables. No more than numBytes bytes will be scanned.
 *
 * Results:
 *	Tokens are added to parsePtr and parsePtr->term is filled in with the
 *	address of the character that terminated the parse (the first one
 *	whose CHAR_TYPE matched mask or the character at parsePtr->end). The
 *	return value is TCL_OK if the parse completed successfully and
 *	TCL_ERROR otherwise. If a parse error occurs and parsePtr->interp is
 *	not NULL, then an error message is left in the interpreter's result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _ParseTokens(tls *libc.TLS, src uintptr, numBytes TTcl_Size, mask int32, flags int32, parsePtr uintptr) (r int32) {
	/* Information about parse in progress.
	 * Updated with additional tokens and
	 * termination information. */
	var _needed, _needed1, allocated, allocated1, originalTokens, varToken, v3 TTcl_Size
	var curEnd, nestedPtr, newPtr, newPtr1, oldPtr, oldPtr1, tokenPtr uintptr
	var noSubstBS, noSubstCmds, noSubstVars int32
	var type1, v1 uint8
	var v2 bool
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _needed, _needed1, allocated, allocated1, curEnd, nestedPtr, newPtr, newPtr1, noSubstBS, noSubstCmds, noSubstVars, oldPtr, oldPtr1, originalTokens, tokenPtr, type1, varToken, v1, v2, v3
	noSubstCmds = libc.BoolInt32(!(flags&libc.Int32FromInt32(TCL_SUBST_COMMANDS) != 0))
	noSubstVars = libc.BoolInt32(!(flags&libc.Int32FromInt32(TCL_SUBST_VARIABLES) != 0))
	noSubstBS = libc.BoolInt32(!(flags&libc.Int32FromInt32(TCL_SUBST_BACKSLASHES) != 0))
	/*
	 * Each iteration through the following loop adds one token of type
	 * TCL_TOKEN_TEXT, TCL_TOKEN_BS, TCL_TOKEN_COMMAND, or TCL_TOKEN_VARIABLE
	 * to parsePtr. For TCL_TOKEN_VARIABLE tokens, additional tokens are added
	 * for the parsed variable name.
	 */
	originalTokens = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens
	for {
		if v2 = numBytes != 0; v2 {
			v1 = XtclCharTypeTable[*(*uint8)(unsafe.Pointer(src))]
			type1 = v1
		}
		if !(v2 && !(libc.Int32FromUint8(v1)&mask != 0)) {
			break
		}
		_needed = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens + int64(libc.Int32FromInt32(1))
		if _needed > (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokensAvailable {
			allocated = int64(2) * _needed
			oldPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
			if oldPtr == parsePtr+104 {
				oldPtr = libc.UintptrFromInt32(0)
			}
			newPtr = XTclpRealloc(tls, oldPtr, libc.Uint64FromInt64(allocated)*uint64(32))
			if newPtr == libc.UintptrFromInt32(0) {
				allocated = libc.Int64FromUint64(libc.Uint64FromInt64(_needed+int64(libc.Int32FromInt32(1))) + libc.Uint64FromInt32(TCL_MIN_GROWTH)/libc.Uint64FromInt64(32))
				newPtr = XTcl_Realloc(tls, oldPtr, libc.Uint64FromInt64(allocated)*uint64(32))
			}
			(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokensAvailable = allocated
			if oldPtr == libc.UintptrFromInt32(0) {
				libc.Xmemcpy(tls, newPtr, parsePtr+104, libc.Uint64FromInt64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens)*uint64(32))
			}
			(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr = newPtr
		}
		tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens)*32
		(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart = src
		(*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents = 0
		if libc.Int32FromUint8(type1)&int32(TYPE_SUBS) == 0 {
			/*
			 * This is a simple range of characters. Scan to find the end of
			 * the range.
			 */
			for {
				src++
				numBytes--
				v3 = numBytes
				if !(v3 != 0 && !(libc.Int32FromUint8(XtclCharTypeTable[*(*uint8)(unsafe.Pointer(src))])&(mask|int32(TYPE_SUBS)) != 0)) {
					break
				}
				/* empty loop */
			}
			(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 = int32(TCL_TOKEN_TEXT)
			(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize = int64(src) - int64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart)
			(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens++
		} else {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) == int32('$') {
				if noSubstVars != 0 {
					(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 = int32(TCL_TOKEN_TEXT)
					(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize = int64(1)
					(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens++
					src++
					numBytes--
					continue
				}
				/*
				 * This is a variable reference. Call Tcl_ParseVarName to do all
				 * the dirty work of parsing the name.
				 */
				varToken = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens
				if XTcl_ParseVarName(tls, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Finterp, src, numBytes, parsePtr, int32(1)) != TCL_OK {
					return int32(TCL_ERROR)
				}
				src += uintptr((*(*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr(varToken)*32))).Fsize)
				numBytes -= (*(*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr(varToken)*32))).Fsize
			} else {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) == int32('[') {
					if noSubstCmds != 0 {
						(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 = int32(TCL_TOKEN_TEXT)
						(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize = int64(1)
						(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens++
						src++
						numBytes--
						continue
					}
					/*
					 * Command substitution. Call Tcl_ParseCommand recursively (and
					 * repeatedly) to parse the nested command(s), then throw away the
					 * parse information.
					 */
					src++
					numBytes--
					nestedPtr = XTclStackAlloc(tls, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Finterp, uint64(744))
					for int32(1) != 0 {
						if XTcl_ParseCommand(tls, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Finterp, src, numBytes, int32(1), nestedPtr) != TCL_OK {
							(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FerrorType = (*TTcl_Parse)(unsafe.Pointer(nestedPtr)).FerrorType
							(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm = (*TTcl_Parse)(unsafe.Pointer(nestedPtr)).Fterm
							(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fincomplete = (*TTcl_Parse)(unsafe.Pointer(nestedPtr)).Fincomplete
							XTclStackFree(tls, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Finterp, nestedPtr)
							return int32(TCL_ERROR)
						}
						curEnd = src + uintptr(numBytes)
						src = (*TTcl_Parse)(unsafe.Pointer(nestedPtr)).FcommandStart + uintptr((*TTcl_Parse)(unsafe.Pointer(nestedPtr)).FcommandSize)
						numBytes = int64(curEnd) - int64(src)
						XTcl_FreeParse(tls, nestedPtr)
						/*
						 * Check for the closing ']' that ends the command
						 * substitution. It must have been the last character of the
						 * parsed command.
						 */
						if (*TTcl_Parse)(unsafe.Pointer(nestedPtr)).Fterm < (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fend && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(nestedPtr)).Fterm))) == int32(']') && !((*TTcl_Parse)(unsafe.Pointer(nestedPtr)).Fincomplete != 0) {
							break
						}
						if numBytes == 0 {
							if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Finterp != libc.UintptrFromInt32(0) {
								XTcl_SetObjResult(tls, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Finterp, XTcl_NewStringObj(tls, __ccgo_ts+22711, int64(-int32(1))))
							}
							(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FerrorType = int32(TCL_PARSE_MISSING_BRACKET)
							(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm = (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart
							(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fincomplete = int32(1)
							XTclStackFree(tls, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Finterp, nestedPtr)
							return int32(TCL_ERROR)
						}
					}
					XTclStackFree(tls, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Finterp, nestedPtr)
					(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 = int32(TCL_TOKEN_COMMAND)
					(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize = int64(src) - int64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart)
					(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens++
				} else {
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) == int32('\\') {
						if noSubstBS != 0 {
							(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 = int32(TCL_TOKEN_TEXT)
							(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize = int64(1)
							(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens++
							src++
							numBytes--
							continue
						}
						/*
						 * Backslash substitution.
						 */
						XTclParseBackslash(tls, src, numBytes, tokenPtr+16, libc.UintptrFromInt32(0))
						if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize == int64(1) {
							/*
							 * Just a backslash, due to end of string.
							 */
							(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 = int32(TCL_TOKEN_TEXT)
							(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens++
							src++
							numBytes--
							continue
						}
						if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1))) == int32('\n') {
							if numBytes == int64(2) {
								(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fincomplete = int32(1)
							}
							/*
							 * Note: backslash-newline is special in that it is treated
							 * the same as a space character would be. This means that it
							 * could terminate the token.
							 */
							if mask&int32(TYPE_SPACE) != 0 {
								if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens == originalTokens {
									goto finishToken
								}
								break
							}
						}
						(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 = int32(TCL_TOKEN_BS)
						(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens++
						src += uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize)
						numBytes -= (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize
					} else {
						if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) == 0 {
							(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 = int32(TCL_TOKEN_TEXT)
							(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize = int64(1)
							(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens++
							src++
							numBytes--
						} else {
							XTcl_Panic(tls, __ccgo_ts+56011, 0)
						}
					}
				}
			}
		}
	}
	if !((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens == originalTokens) {
		goto _4
	}
	/*
	 * There was nothing in this range of text. Add an empty token for the
	 * empty range, so that there is always at least one token added.
	 */
	_needed1 = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens + int64(libc.Int32FromInt32(1))
	if _needed1 > (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokensAvailable {
		allocated1 = int64(2) * _needed1
		oldPtr1 = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
		if oldPtr1 == parsePtr+104 {
			oldPtr1 = libc.UintptrFromInt32(0)
		}
		newPtr1 = XTclpRealloc(tls, oldPtr1, libc.Uint64FromInt64(allocated1)*uint64(32))
		if newPtr1 == libc.UintptrFromInt32(0) {
			allocated1 = libc.Int64FromUint64(libc.Uint64FromInt64(_needed1+int64(libc.Int32FromInt32(1))) + libc.Uint64FromInt32(TCL_MIN_GROWTH)/libc.Uint64FromInt64(32))
			newPtr1 = XTcl_Realloc(tls, oldPtr1, libc.Uint64FromInt64(allocated1)*uint64(32))
		}
		(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokensAvailable = allocated1
		if oldPtr1 == libc.UintptrFromInt32(0) {
			libc.Xmemcpy(tls, newPtr1, parsePtr+104, libc.Uint64FromInt64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens)*uint64(32))
		}
		(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr = newPtr1
	}
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens)*32
	(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart = src
	(*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents = 0
	goto finishToken
finishToken:
	;
	(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 = int32(TCL_TOKEN_TEXT)
	(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize = 0
	(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens++
_4:
	;
	(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm = src
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FreeParse --
 *
 *	This function is invoked to free any dynamic storage that may have
 *	been allocated by a previous call to Tcl_ParseCommand.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	If there is any dynamically allocated memory in *parsePtr, it is
 *	freed.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FreeParse(tls *libc.TLS, parsePtr uintptr) {
	/* Structure that was filled in by a previous
	 * call to Tcl_ParseCommand. */
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr != parsePtr+104 {
		XTclpFree(tls, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)
		(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr = parsePtr + 104
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ParseVarName --
 *
 *	Given a string starting with a $ sign, parse off a variable name and
 *	return information about the parse. No more than numBytes bytes will
 *	be scanned.
 *
 * Results:
 *	The return value is TCL_OK if the command was parsed successfully and
 *	TCL_ERROR otherwise. If an error occurs and interp isn't NULL then an
 *	error message is left in its result. On a successful return, tokenPtr
 *	and numTokens fields of parsePtr are filled in with information about
 *	the variable name that was parsed. The "size" field of the first new
 *	token gives the total number of bytes in the variable name. Other
 *	fields in parsePtr are undefined.
 *
 * Side effects:
 *	If there is insufficient space in parsePtr to hold all the information
 *	about the command, then additional space is malloc-ed. If the function
 *	returns TCL_OK then the caller must eventually invoke Tcl_FreeParse to
 *	release any additional space that was allocated.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ParseVarName(tls *libc.TLS, interp uintptr, start uintptr, numBytes TTcl_Size, parsePtr uintptr, append1 int32) (r int32) {
	/* Non-zero means append tokens to existing
	 * information in parsePtr; zero means ignore
	 * existing tokens in parsePtr and
	 * reinitialize it. */
	var _needed, allocated TTcl_Size
	var array uint32
	var braceCount, varIndex int32
	var ch uint8
	var newPtr, oldPtr, src, tokenPtr uintptr
	_, _, _, _, _, _, _, _, _, _ = _needed, allocated, array, braceCount, ch, newPtr, oldPtr, src, tokenPtr, varIndex
	if numBytes < 0 && start != 0 {
		numBytes = libc.Int64FromUint64(libc.Xstrlen(tls, start))
	}
	if !(append1 != 0) {
		XTclParseInit(tls, interp, start, numBytes, parsePtr)
	}
	if numBytes == 0 || start == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Generate one token for the variable, an additional token for the name,
	 * plus any number of additional tokens for the index, if there is one.
	 */
	src = start
	_needed = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens + int64(libc.Int32FromInt32(2))
	if _needed > (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokensAvailable {
		allocated = int64(2) * _needed
		oldPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
		if oldPtr == parsePtr+104 {
			oldPtr = libc.UintptrFromInt32(0)
		}
		newPtr = XTclpRealloc(tls, oldPtr, libc.Uint64FromInt64(allocated)*uint64(32))
		if newPtr == libc.UintptrFromInt32(0) {
			allocated = libc.Int64FromUint64(libc.Uint64FromInt64(_needed+int64(libc.Int32FromInt32(2))) + libc.Uint64FromInt32(TCL_MIN_GROWTH)/libc.Uint64FromInt64(32))
			newPtr = XTcl_Realloc(tls, oldPtr, libc.Uint64FromInt64(allocated)*uint64(32))
		}
		(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokensAvailable = allocated
		if oldPtr == libc.UintptrFromInt32(0) {
			libc.Xmemcpy(tls, newPtr, parsePtr+104, libc.Uint64FromInt64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens)*uint64(32))
		}
		(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr = newPtr
	}
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens)*32
	(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 = int32(TCL_TOKEN_VARIABLE)
	(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart = src
	varIndex = int32((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens)
	(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens++
	tokenPtr += 32
	src++
	numBytes--
	if numBytes == 0 {
		goto justADollarSign
	}
	(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 = int32(TCL_TOKEN_TEXT)
	(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart = src
	(*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents = 0
	/*
	 * The name of the variable can have three forms:
	 * 1. The $ sign is followed by an open curly brace. Then the variable
	 *	  name is everything up to the next close curly brace, and the
	 *	  variable is a scalar variable.
	 * 2. The $ sign is not followed by an open curly brace. Then the variable
	 *	  name is everything up to the next character that isn't a letter,
	 *	  digit, or underscore. :: sequences are also considered part of the
	 *	  variable name, in order to support namespaces. If the following
	 *	  character is an open parenthesis, then the information between
	 *	  parentheses is the array element name.
	 * 3. The $ sign is followed by something that isn't a letter, digit, or
	 *	  underscore: in this case, there is no variable name and the token is
	 *	  just "$".
	 */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) == int32('{') {
		braceCount = 0
		src++
		numBytes--
		(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 = int32(TCL_TOKEN_TEXT)
		(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart = src
		(*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents = 0
		ch = *(*uint8)(unsafe.Pointer(src))
		for numBytes != 0 && (braceCount > 0 || libc.Int32FromUint8(ch) != int32('}')) {
			switch libc.Int32FromUint8(ch) {
			case int32('{'):
				braceCount++
			case int32('}'):
				braceCount--
			case int32('\\'):
				/* if 2 or more left, consume 2, else consume
				 * just the \ and let it run into the end */
				if numBytes > int64(1) {
					src++
					numBytes--
				}
			}
			numBytes--
			src++
			ch = *(*uint8)(unsafe.Pointer(src))
		}
		if numBytes == 0 {
			if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Finterp != libc.UintptrFromInt32(0) {
				XTcl_SetObjResult(tls, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Finterp, XTcl_NewStringObj(tls, __ccgo_ts+56053, int64(-int32(1))))
			}
			(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FerrorType = int32(TCL_PARSE_MISSING_VAR_BRACE)
			(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm = (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart - uintptr(1)
			(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fincomplete = int32(1)
			goto error
		}
		(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize = int64(src) - int64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart)
		(*(*TTcl_Token)(unsafe.Pointer(tokenPtr + uintptr(-libc.Int32FromInt32(1))*32))).Fsize = int64(src) - int64((*(*TTcl_Token)(unsafe.Pointer(tokenPtr + uintptr(-libc.Int32FromInt32(1))*32))).Fstart)
		(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens++
		src++
	} else {
		(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 = int32(TCL_TOKEN_TEXT)
		(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart = src
		(*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents = 0
		for numBytes != 0 {
			if XTclIsBareword(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))) != 0 {
				src += uintptr(1)
				numBytes -= int64(1)
				continue
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) == int32(':') && numBytes != int64(1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1))) == int32(':') {
				src += uintptr(2)
				numBytes -= int64(2)
				for numBytes != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) == int32(':') {
					src++
					numBytes--
				}
				continue
			}
			break
		}
		/*
		 * Support for empty array names here.
		 */
		array = libc.BoolUint32(numBytes != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) == int32('('))
		(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize = int64(src) - int64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart)
		if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize == 0 && !(array != 0) {
			goto justADollarSign
		}
		(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens++
		if array != 0 {
			/*
			 * This is a reference to an array element. Call ParseTokens
			 * recursively to parse the element name, since it could contain
			 * any number of substitutions.
			 */
			if TCL_OK != _ParseTokens(tls, src+uintptr(1), numBytes-int64(1), int32(TYPE_BAD_ARRAY_INDEX), int32(TCL_SUBST_ALL), parsePtr) {
				goto error
			}
			if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm == src+uintptr(numBytes) {
				if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Finterp != libc.UintptrFromInt32(0) {
					XTcl_SetObjResult(tls, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Finterp, XTcl_NewStringObj(tls, __ccgo_ts+56091, int64(-int32(1))))
				}
				(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FerrorType = int32(TCL_PARSE_MISSING_PAREN)
				(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm = src
				(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fincomplete = int32(1)
				goto error
			} else {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm))) != int32(')') {
					if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Finterp != libc.UintptrFromInt32(0) {
						XTcl_SetObjResult(tls, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Finterp, XTcl_NewStringObj(tls, __ccgo_ts+56101, int64(-int32(1))))
					}
					(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FerrorType = int32(TCL_PARSE_SYNTAX)
					(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm = src
					goto error
				}
			}
			src = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm + uintptr(1)
		}
	}
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr(varIndex)*32
	(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize = int64(src) - int64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart)
	(*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens - int64(varIndex+libc.Int32FromInt32(1))
	return TCL_OK
	/*
	 * The dollar sign isn't followed by a variable name. Replace the
	 * TCL_TOKEN_VARIABLE token with a TCL_TOKEN_TEXT token for the dollar
	 * sign.
	 */
	goto justADollarSign
justADollarSign:
	;
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr(varIndex)*32
	(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 = int32(TCL_TOKEN_TEXT)
	(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize = int64(1)
	(*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents = 0
	return TCL_OK
	goto error
error:
	;
	XTcl_FreeParse(tls, parsePtr)
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ParseVar --
 *
 *	Given a string starting with a $ sign, parse off a variable name and
 *	return its value.
 *
 * Results:
 *	The return value is the contents of the variable given by the leading
 *	characters of string. If termPtr isn't NULL, *termPtr gets filled in
 *	with the address of the character just after the last one in the
 *	variable specifier. If the variable doesn't exist, then the return
 *	value is NULL and an error message will be left in interp's result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ParseVar(tls *libc.TLS, interp uintptr, start uintptr, termPtr uintptr) (r uintptr) {
	/* If non-NULL, points to word to fill in with
	 * character just after last one in the
	 * variable specifier. */
	var code int32
	var objPtr, parsePtr, v1 uintptr
	_, _, _, _ = code, objPtr, parsePtr, v1
	parsePtr = XTclStackAlloc(tls, interp, uint64(744))
	if XTcl_ParseVarName(tls, interp, start, int64(-libc.Int32FromInt32(1)), parsePtr, 0) != TCL_OK {
		XTclStackFree(tls, interp, parsePtr)
		return libc.UintptrFromInt32(0)
	}
	if termPtr != libc.UintptrFromInt32(0) {
		*(*uintptr)(unsafe.Pointer(termPtr)) = start + uintptr((*TTcl_Token)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr)).Fsize)
	}
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens == int64(1) {
		/*
		 * There isn't a variable name after all: the $ is just a $.
		 */
		XTclStackFree(tls, interp, parsePtr)
		return __ccgo_ts + 56134
	}
	code = XTclSubstTokens(tls, interp, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens, libc.UintptrFromInt32(0), int64(1), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	XTcl_FreeParse(tls, parsePtr)
	XTclStackFree(tls, interp, parsePtr)
	if code != TCL_OK {
		return libc.UintptrFromInt32(0)
	}
	objPtr = XTcl_GetObjResult(tls, interp)
	/*
	 * At this point we should have an object containing the value of a
	 * variable. Just return the string from that object.
	 *
	 * Since TclSubstTokens above returned TCL_OK, we know that objPtr
	 * is shared.  It is in both the interp result and the value of the
	 * variable.  Returning the string relies on that to be true.
	 */
	XTcl_ResetResult(tls, interp)
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
	}
	return v1
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ParseBraces --
 *
 *	Given a string in braces such as a Tcl command argument or a string
 *	value in a Tcl expression, this function parses the string and returns
 *	information about the parse. No more than numBytes bytes will be
 *	scanned.
 *
 * Results:
 *	The return value is TCL_OK if the string was parsed successfully and
 *	TCL_ERROR otherwise. If an error occurs and interp isn't NULL then an
 *	error message is left in its result. On a successful return, tokenPtr
 *	and numTokens fields of parsePtr are filled in with information about
 *	the string that was parsed. Other fields in parsePtr are undefined.
 *	termPtr is set to point to the character just after the last one in
 *	the braced string.
 *
 * Side effects:
 *	If there is insufficient space in parsePtr to hold all the information
 *	about the command, then additional space is malloc-ed. If the function
 *	returns TCL_OK then the caller must eventually invoke Tcl_FreeParse to
 *	release any additional space that was allocated.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ParseBraces(tls *libc.TLS, interp uintptr, start uintptr, numBytes TTcl_Size, parsePtr uintptr, append1 int32, termPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* If non-NULL, points to word in which to
	 * store a pointer to the character just after
	 * the terminating '}' if the parse was
	 * successful. */
	var _needed, _needed1, allocated, allocated1, level, startIndex, v1, v2 TTcl_Size
	var newPtr, newPtr1, oldPtr, oldPtr1, src, tokenPtr, v3 uintptr
	var openBrace, v4 int32
	var v5 bool
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _needed, _needed1, allocated, allocated1, level, newPtr, newPtr1, oldPtr, oldPtr1, openBrace, src, startIndex, tokenPtr, v1, v2, v3, v4, v5
	if numBytes < 0 && start != 0 {
		numBytes = libc.Int64FromUint64(libc.Xstrlen(tls, start))
	}
	if !(append1 != 0) {
		XTclParseInit(tls, interp, start, numBytes, parsePtr)
	}
	if numBytes == 0 || start == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	src = start
	startIndex = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens
	_needed = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens + int64(libc.Int32FromInt32(1))
	if _needed > (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokensAvailable {
		allocated = int64(2) * _needed
		oldPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
		if oldPtr == parsePtr+104 {
			oldPtr = libc.UintptrFromInt32(0)
		}
		newPtr = XTclpRealloc(tls, oldPtr, libc.Uint64FromInt64(allocated)*uint64(32))
		if newPtr == libc.UintptrFromInt32(0) {
			allocated = libc.Int64FromUint64(libc.Uint64FromInt64(_needed+int64(libc.Int32FromInt32(1))) + libc.Uint64FromInt32(TCL_MIN_GROWTH)/libc.Uint64FromInt64(32))
			newPtr = XTcl_Realloc(tls, oldPtr, libc.Uint64FromInt64(allocated)*uint64(32))
		}
		(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokensAvailable = allocated
		if oldPtr == libc.UintptrFromInt32(0) {
			libc.Xmemcpy(tls, newPtr, parsePtr+104, libc.Uint64FromInt64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens)*uint64(32))
		}
		(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr = newPtr
	}
	tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr(startIndex)*32
	(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 = int32(TCL_TOKEN_TEXT)
	(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart = src + uintptr(1)
	(*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents = 0
	level = int64(1)
	for int32(1) != 0 {
		for {
			src++
			numBytes--
			v1 = numBytes
			if !(v1 != 0) {
				break
			}
			if libc.Int32FromUint8(XtclCharTypeTable[*(*uint8)(unsafe.Pointer(src))]) != int32(TYPE_NORMAL) {
				break
			}
		}
		if numBytes == 0 {
			goto missingBraceError
		}
		switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) {
		case int32('{'):
			level++
		case int32('}'):
			level--
			v2 = level
			if v2 == 0 {
				/*
				 * Decide if we need to finish emitting a partially-finished
				 * token. There are 3 cases:
				 *     {abc \newline xyz} or {xyz}
				 *		- finish emitting "xyz" token
				 *     {abc \newline}
				 *		- don't emit token after \newline
				 *     {}	- finish emitting zero-sized token
				 *
				 * The last case ensures that there is a token (even if empty)
				 * that describes the braced string.
				 */
				if src != (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart || (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens == startIndex {
					(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize = int64(src) - int64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart)
					(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens++
				}
				if termPtr != libc.UintptrFromInt32(0) {
					*(*uintptr)(unsafe.Pointer(termPtr)) = src + uintptr(1)
				}
				return TCL_OK
			}
		case int32('\\'):
			XTclParseBackslash(tls, src, numBytes, bp, libc.UintptrFromInt32(0))
			if *(*TTcl_Size)(unsafe.Pointer(bp)) > int64(1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1))) == int32('\n') {
				/*
				 * A backslash-newline sequence must be collapsed, even inside
				 * braces, so we have to split the word into multiple tokens
				 * so that the backslash-newline can be represented
				 * explicitly.
				 */
				if numBytes == int64(2) {
					(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fincomplete = int32(1)
				}
				(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize = int64(src) - int64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart)
				if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize != 0 {
					(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens++
				}
				_needed1 = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens + int64(libc.Int32FromInt32(2))
				if _needed1 > (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokensAvailable {
					allocated1 = int64(2) * _needed1
					oldPtr1 = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
					if oldPtr1 == parsePtr+104 {
						oldPtr1 = libc.UintptrFromInt32(0)
					}
					newPtr1 = XTclpRealloc(tls, oldPtr1, libc.Uint64FromInt64(allocated1)*uint64(32))
					if newPtr1 == libc.UintptrFromInt32(0) {
						allocated1 = libc.Int64FromUint64(libc.Uint64FromInt64(_needed1+int64(libc.Int32FromInt32(2))) + libc.Uint64FromInt32(TCL_MIN_GROWTH)/libc.Uint64FromInt64(32))
						newPtr1 = XTcl_Realloc(tls, oldPtr1, libc.Uint64FromInt64(allocated1)*uint64(32))
					}
					(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokensAvailable = allocated1
					if oldPtr1 == libc.UintptrFromInt32(0) {
						libc.Xmemcpy(tls, newPtr1, parsePtr+104, libc.Uint64FromInt64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens)*uint64(32))
					}
					(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr = newPtr1
				}
				tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens)*32
				(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 = int32(TCL_TOKEN_BS)
				(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart = src
				(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize = *(*TTcl_Size)(unsafe.Pointer(bp))
				(*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents = 0
				(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens++
				src += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)) - int64(1))
				numBytes -= *(*TTcl_Size)(unsafe.Pointer(bp)) - int64(1)
				tokenPtr += 32
				(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 = int32(TCL_TOKEN_TEXT)
				(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart = src + uintptr(1)
				(*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents = 0
			} else {
				src += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)) - int64(1))
				numBytes -= *(*TTcl_Size)(unsafe.Pointer(bp)) - int64(1)
			}
			break
		}
	}
	goto missingBraceError
missingBraceError:
	;
	(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FerrorType = int32(TCL_PARSE_MISSING_BRACE)
	(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm = start
	(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fincomplete = int32(1)
	if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Finterp == libc.UintptrFromInt32(0) {
		/*
		 * Skip straight to the exit code since we have no interpreter to put
		 * error message in.
		 */
		goto error
	}
	XTcl_SetObjResult(tls, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Finterp, XTcl_NewStringObj(tls, __ccgo_ts+56136, int64(-int32(1))))
	/*
	 * Guess if the problem is due to comments by searching the source string
	 * for a possible open brace within the context of a comment. Since we
	 * aren't performing a full Tcl parse, just look for an open brace
	 * preceded by a '<whitespace>#' on the same line.
	 */
	openBrace = 0
	for {
		src--
		v3 = src
		if !(v3 > start) {
			break
		}
		switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) {
		case int32('{'):
			openBrace = int32(1)
		case int32('\n'):
			openBrace = 0
		case int32('#'):
			if v5 = openBrace != 0; v5 {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + uintptr(-libc.Int32FromInt32(1))))) > int32(0x20) {
					v4 = 0
				} else {
					v4 = XTclIsSpaceProc(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + uintptr(-libc.Int32FromInt32(1))))))
				}
			}
			if v5 && v4 != 0 {
				XTcl_AppendToObj(tls, XTcl_GetObjResult(tls, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Finterp), __ccgo_ts+56156, int64(-int32(1)))
				goto error
			}
			break
		}
	}
	goto error
error:
	;
	XTcl_FreeParse(tls, parsePtr)
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ParseQuotedString --
 *
 *	Given a double-quoted string such as a quoted Tcl command argument or
 *	a quoted value in a Tcl expression, this function parses the string
 *	and returns information about the parse. No more than numBytes bytes
 *	will be scanned.
 *
 * Results:
 *	The return value is TCL_OK if the string was parsed successfully and
 *	TCL_ERROR otherwise. If an error occurs and interp isn't NULL then an
 *	error message is left in its result. On a successful return, tokenPtr
 *	and numTokens fields of parsePtr are filled in with information about
 *	the string that was parsed. Other fields in parsePtr are undefined.
 *	termPtr is set to point to the character just after the quoted
 *	string's terminating close-quote.
 *
 * Side effects:
 *	If there is insufficient space in parsePtr to hold all the information
 *	about the command, then additional space is malloc-ed. If the function
 *	returns TCL_OK then the caller must eventually invoke Tcl_FreeParse to
 *	release any additional space that was allocated.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ParseQuotedString(tls *libc.TLS, interp uintptr, start uintptr, numBytes TTcl_Size, parsePtr uintptr, append1 int32, termPtr uintptr) (r int32) {
	/* If non-NULL, points to word in which to
	 * store a pointer to the character just after
	 * the quoted string's terminating close-quote
	 * if the parse succeeds. */
	if numBytes < 0 && start != 0 {
		numBytes = libc.Int64FromUint64(libc.Xstrlen(tls, start))
	}
	if !(append1 != 0) {
		XTclParseInit(tls, interp, start, numBytes, parsePtr)
	}
	if numBytes == 0 || start == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if TCL_OK != _ParseTokens(tls, start+uintptr(1), numBytes-int64(1), int32(TYPE_QUOTE), int32(TCL_SUBST_ALL), parsePtr) {
		goto error
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm))) != int32('"') {
		if (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Finterp != libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Finterp, XTcl_NewStringObj(tls, __ccgo_ts+56195, int64(-int32(1))))
		}
		(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FerrorType = int32(TCL_PARSE_MISSING_QUOTE)
		(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm = start
		(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fincomplete = int32(1)
		goto error
	}
	if termPtr != libc.UintptrFromInt32(0) {
		*(*uintptr)(unsafe.Pointer(termPtr)) = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm + libc.UintptrFromInt32(1)
	}
	return TCL_OK
	goto error
error:
	;
	XTcl_FreeParse(tls, parsePtr)
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * TclSubstParse --
 *
 *	Token parser used by the [subst] command. Parses the string made up of
 *	'numBytes' bytes starting at 'bytes'. Parsing is controlled by the
 *	flags argument to provide support for the -nobackslashes, -nocommands,
 *	and -novariables options, as represented by the flag values
 *	TCL_SUBST_BACKSLASHES, TCL_SUBST_COMMANDS, TCL_SUBST_VARIABLES.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The Tcl_Parse struct '*parsePtr' is filled with parse results.
 *	The caller is expected to eventually call Tcl_FreeParse() to properly
 *	cleanup the value written there.
 *
 *	If a parse error occurs, the Tcl_InterpState value '*statePtr' is
 *	filled with the state created by that error. When *statePtr is written
 *	to, the caller is expected to make the required calls to either
 *	Tcl_RestoreInterpState() or Tcl_DiscardInterpState() to dispose of the
 *	value written there.
 *
 *----------------------------------------------------------------------
 */

func XTclSubstParse(tls *libc.TLS, interp uintptr, bytes uintptr, numBytes TTcl_Size, flags int32, parsePtr uintptr, statePtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _needed, allocated, length TTcl_Size
	var lastTerm, nestedPtr, newPtr, oldPtr, p, tokenPtr, varTokenPtr uintptr
	_, _, _, _, _, _, _, _, _, _ = _needed, allocated, lastTerm, length, nestedPtr, newPtr, oldPtr, p, tokenPtr, varTokenPtr
	length = numBytes
	p = bytes
	XTclParseInit(tls, interp, p, length, parsePtr)
	/*
	 * First parse the string rep of objPtr, as if it were enclosed as a
	 * "-quoted word in a normal Tcl command. Honor flags that selectively
	 * inhibit types of substitution.
	 */
	if TCL_OK != _ParseTokens(tls, p, length, 0, flags, parsePtr) {
		/*
		 * There was a parse error. Save the interpreter state for possible
		 * error reporting later.
		 */
		*(*TTcl_InterpState)(unsafe.Pointer(statePtr)) = XTcl_SaveInterpState(tls, interp, int32(TCL_ERROR))
		/*
		 * We need to re-parse to get the portion of the string we can [subst]
		 * before the parse error. Sadly, all the Tcl_Token's created by the
		 * first parse attempt are gone, freed according to the public spec
		 * for the Tcl_Parse* routines. The only clue we have is parse.term,
		 * which points to either the unmatched opener, or to characters that
		 * follow a close brace or close quote.
		 *
		 * Call ParseTokens again, working on the string up to parse.term.
		 * Keep repeating until we get a good parse on a prefix.
		 */
		for cond := true; cond; cond = TCL_OK != _ParseTokens(tls, p, int64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fend)-int64(p), 0, flags, parsePtr) {
			(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens = 0
			(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokensAvailable = int64(NUM_STATIC_TOKENS)
			(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fend = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm
			(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fincomplete = 0
			(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FerrorType = TCL_PARSE_SUCCESS
		}
		/*
		 * The good parse will have to be followed by {, (, or [.
		 */
		switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm))) {
		case int32('{'):
			/*
			 * Parse error was a missing } in a ${varname} variable
			 * substitution at the toplevel. We will subst everything up to
			 * that broken variable substitution before reporting the parse
			 * error. Substituting the leftover '$' will have no side-effects,
			 * so the current token stream is fine.
			 */
		case int32('('):
			/*
			 * Parse error was during the parsing of the index part of an
			 * array variable substitution at the toplevel.
			 */
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm - libc.UintptrFromInt32(1)))) == int32('$') {
				/*
				 * Special case where removing the array index left us with
				 * just a dollar sign (array variable with name the empty
				 * string as its name), instead of with a scalar variable
				 * reference.
				 *
				 * As in the previous case, existing token stream is OK.
				 */
			} else {
				/*
				 * The current parse includes a successful parse of a scalar
				 * variable substitution where there should have been an array
				 * variable substitution. We remove that mistaken part of the
				 * parse before moving on. A scalar variable substitution is
				 * two tokens.
				 */
				varTokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens)*32 - uintptr(2)*32
				if (*TTcl_Token)(unsafe.Pointer(varTokenPtr)).Ftype1 != int32(TCL_TOKEN_VARIABLE) {
					XTcl_Panic(tls, __ccgo_ts+56205, 0)
				}
				if (*(*TTcl_Token)(unsafe.Pointer(varTokenPtr + 1*32))).Ftype1 != int32(TCL_TOKEN_TEXT) {
					XTcl_Panic(tls, __ccgo_ts+56205, 0)
				}
				*(*TTcl_Size)(unsafe.Pointer(parsePtr + 48)) -= int64(2)
			}
		case int32('['):
			/*
			 * Parse error occurred during parsing of a toplevel command
			 * substitution.
			 */
			(*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fend = p + uintptr(length)
			p = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm + uintptr(1)
			length = int64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fend) - int64(p)
			if length == 0 {
				/*
				 * No commands, just an unmatched [. As in previous cases,
				 * existing token stream is OK.
				 */
			} else {
				lastTerm = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm
				nestedPtr = XTclStackAlloc(tls, interp, uint64(744))
				for TCL_OK == XTcl_ParseCommand(tls, libc.UintptrFromInt32(0), p, length, 0, nestedPtr) {
					XTcl_FreeParse(tls, nestedPtr)
					p = (*TTcl_Parse)(unsafe.Pointer(nestedPtr)).Fterm + libc.BoolUintptr((*TTcl_Parse)(unsafe.Pointer(nestedPtr)).Fterm < (*TTcl_Parse)(unsafe.Pointer(nestedPtr)).Fend)
					length = int64((*TTcl_Parse)(unsafe.Pointer(nestedPtr)).Fend) - int64(p)
					if length == 0 && (*TTcl_Parse)(unsafe.Pointer(nestedPtr)).Fterm == (*TTcl_Parse)(unsafe.Pointer(nestedPtr)).Fend {
						/*
						 * If we run out of string, blame the missing close
						 * bracket on the last command, and do not evaluate it
						 * during substitution.
						 */
						break
					}
					lastTerm = (*TTcl_Parse)(unsafe.Pointer(nestedPtr)).Fterm
				}
				XTclStackFree(tls, interp, nestedPtr)
				if lastTerm == (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm {
					/*
					 * Parse error in first command. No commands to subst, add
					 * no more tokens.
					 */
					break
				}
				/*
				 * Create a command substitution token for whatever commands
				 * got parsed.
				 */
				_needed = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens + int64(libc.Int32FromInt32(1))
				if _needed > (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokensAvailable {
					allocated = int64(2) * _needed
					oldPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr
					if oldPtr == parsePtr+104 {
						oldPtr = libc.UintptrFromInt32(0)
					}
					newPtr = XTclpRealloc(tls, oldPtr, libc.Uint64FromInt64(allocated)*uint64(32))
					if newPtr == libc.UintptrFromInt32(0) {
						allocated = libc.Int64FromUint64(libc.Uint64FromInt64(_needed+int64(libc.Int32FromInt32(1))) + libc.Uint64FromInt32(TCL_MIN_GROWTH)/libc.Uint64FromInt64(32))
						newPtr = XTcl_Realloc(tls, oldPtr, libc.Uint64FromInt64(allocated)*uint64(32))
					}
					(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokensAvailable = allocated
					if oldPtr == libc.UintptrFromInt32(0) {
						libc.Xmemcpy(tls, newPtr, parsePtr+104, libc.Uint64FromInt64((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens)*uint64(32))
					}
					(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr = newPtr
				}
				tokenPtr = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).FtokenPtr + uintptr((*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens)*32
				(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart = (*TTcl_Parse)(unsafe.Pointer(parsePtr)).Fterm
				(*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents = 0
				(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 = int32(TCL_TOKEN_COMMAND)
				(*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize = int64(lastTerm) - int64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart) + int64(1)
				(*TTcl_Parse)(unsafe.Pointer(parsePtr)).FnumTokens++
			}
		default:
			XTcl_Panic(tls, __ccgo_ts+56238, libc.VaList(bp+8, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(length))))))
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclSubstTokens --
 *
 *	Accepts an array of count Tcl_Token's, and creates a result value in
 *	the interp from concatenating the results of performing Tcl
 *	substitution on each Tcl_Token. Substitution is interrupted if any
 *	non-TCL_OK completion code arises.
 *
 * Results:
 *	The return value is a standard Tcl completion code. The result in
 *	interp is the substituted value, or an error message if TCL_ERROR is
 *	returned. If tokensLeftPtr is not NULL, then it points to an int where
 *	the number of tokens remaining to be processed is written.
 *
 * Side effects:
 *	Can be anything, depending on the types of substitution done.
 *
 *----------------------------------------------------------------------
 */

func XTclSubstTokens(tls *libc.TLS, interp uintptr, tokenPtr uintptr, count TTcl_Size, tokensLeftPtr uintptr, _line TTcl_Size, _clNextOuter uintptr, outerScript uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	*(*TTcl_Size)(unsafe.Pointer(bp)) = _line
	*(*uintptr)(unsafe.Pointer(bp + 8)) = _clNextOuter /* continuation line data. This is set by
	 * EvalEx() to properly handle [...]-nested
	 * commands. The 'outerScript' refers to the
	 * most-outer script containing the embedded
	 * command, which is refered to by 'script'.
	 * The 'clNextOuter' refers to the current
	 * entry in the table of continuation lines in
	 * this "main script", and the character
	 * offsets are relative to the 'outerScript'
	 * as well.
	 *
	 * If outerScript == script, then this call is
	 * for words in the outer-most script or
	 * command. See Tcl_EvalEx and TclEvalObjEx
	 * for the places generating arguments for
	 * which this is true. */
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, append1, appendObj, arrayIndex, clPosition, iPtr, result, varName, v11, v5, v7, v9 uintptr
	var adjust, i, maxNumCL, numCL, theline, v10, v4, v6, v8 TTcl_Size
	var appendByteLength, code, inFile, isLiteral int32
	var _ /* clPos at bp+24 */ TTcl_Size
	var _ /* utfCharBytes at bp+16 */ [4]uint8
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, adjust, append1, appendByteLength, appendObj, arrayIndex, clPosition, code, i, iPtr, inFile, isLiteral, maxNumCL, numCL, result, theline, varName, v10, v11, v4, v5, v6, v7, v8, v9
	code = TCL_OK
	clPosition = libc.UintptrFromInt32(0)
	iPtr = interp
	inFile = (*TInterp)(unsafe.Pointer(iPtr)).FevalFlags & int32(TCL_EVAL_FILE)
	/*
	 * Each pass through this loop will substitute one token, and its
	 * components, if any. The only thing tricky here is that we go to some
	 * effort to pass Tcl_Obj's through untouched, to avoid string copying and
	 * Tcl_Obj creation if possible, to aid performance and limit shimmering.
	 *
	 * Further optimization opportunities might be to check for the equivalent
	 * of Tcl_SetObjResult(interp, Tcl_GetObjResult(interp)) and omit them.
	 */
	/*
	 * For the handling of continuation lines in literals, first check if
	 * this is actually a literal. If not then forego the additional
	 * processing. Otherwise preallocate a small table to store the
	 * locations of all continuation lines we find in this literal, if any.
	 * The table is extended if needed.
	 */
	numCL = 0
	maxNumCL = 0
	isLiteral = int32(1)
	i = 0
	for {
		if !(i < count) {
			break
		}
		if (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + uintptr(i)*32))).Ftype1 != int32(TCL_TOKEN_TEXT) && (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + uintptr(i)*32))).Ftype1 != int32(TCL_TOKEN_BS) {
			isLiteral = 0
			break
		}
		goto _1
	_1:
		;
		i++
	}
	if isLiteral != 0 {
		maxNumCL = int64(NUM_STATIC_POS)
		clPosition = XTcl_Alloc(tls, libc.Uint64FromInt64(maxNumCL)*uint64(8))
	}
	adjust = 0
	result = libc.UintptrFromInt32(0)
	for {
		if !(count > 0 && code == TCL_OK) {
			break
		}
		appendObj = libc.UintptrFromInt32(0)
		append1 = libc.UintptrFromInt32(0)
		appendByteLength = 0
		*(*[4]uint8)(unsafe.Pointer(bp + 16)) = [4]uint8{}
		switch (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1 {
		case int32(TCL_TOKEN_TEXT):
			append1 = (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart
			appendByteLength = int32((*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize)
		case int32(TCL_TOKEN_BS):
			appendByteLength = XTclParseBackslash(tls, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize, libc.UintptrFromInt32(0), bp+16)
			append1 = bp + 16
			/*
			 * If the backslash sequence we found is in a literal, and
			 * represented a continuation line, we compute and store its
			 * location (as char offset to the beginning of the _result_
			 * script). We may have to extend the table of locations.
			 *
			 * Note that the continuation line information is relevant even if
			 * the word we are processing is not a literal, as it can affect
			 * nested commands. See the branch for TCL_TOKEN_COMMAND below,
			 * where the adjustment we are tracking here is taken into
			 * account. The good thing is that we do not need a table of
			 * everything, just the number of lines we have to add as
			 * correction.
			 */
			if appendByteLength == int32(1) && libc.Int32FromUint8((*(*[4]uint8)(unsafe.Pointer(bp + 16)))[0]) == int32(' ') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart + 1))) == int32('\n') {
				if isLiteral != 0 {
					if result == uintptr(0) {
						*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = 0
					} else {
						if (*TTcl_Obj)(unsafe.Pointer(result)).Fbytes != 0 {
							*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = (*TTcl_Obj)(unsafe.Pointer(result)).Flength
							_ = (*TTcl_Obj)(unsafe.Pointer(result)).Fbytes
						} else {
							XTcl_GetStringFromObj(tls, result, bp+24)
						}
					}
					if numCL >= maxNumCL {
						maxNumCL *= int64(2)
						clPosition = XTcl_Realloc(tls, clPosition, libc.Uint64FromInt64(maxNumCL)*uint64(8))
					}
					*(*TTcl_Size)(unsafe.Pointer(clPosition + uintptr(numCL)*8)) = *(*TTcl_Size)(unsafe.Pointer(bp + 24))
					numCL++
				}
				adjust++
			}
		case int32(TCL_TOKEN_COMMAND):
			/* TIP #280: Transfer line information to nested command */
			(*TInterp)(unsafe.Pointer(iPtr)).FnumLevels++
			code = XTclInterpReady(tls, interp)
			if code == TCL_OK {
				XTclAdvanceContinuations(tls, bp, bp+8, int32(int64((*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart)-int64(outerScript)))
				theline = *(*TTcl_Size)(unsafe.Pointer(bp)) + adjust
				code = XTclEvalEx(tls, interp, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart+uintptr(1), (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize-int64(2), 0, theline, *(*uintptr)(unsafe.Pointer(bp + 8)), outerScript)
				XTclAdvanceLines(tls, bp, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart+uintptr(1), (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fstart+uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).Fsize)-uintptr(1))
				/*
				 * Restore flag reset by nested eval for future bracketed
				 * commands and their cmdframe setup
				 */
				if inFile != 0 {
					*(*int32)(unsafe.Pointer(iPtr + 256)) |= int32(TCL_EVAL_FILE)
				}
			}
			(*TInterp)(unsafe.Pointer(iPtr)).FnumLevels--
			XTclResetCancellation(tls, interp, 0)
			appendObj = XTcl_GetObjResult(tls, interp)
		case int32(TCL_TOKEN_VARIABLE):
			arrayIndex = libc.UintptrFromInt32(0)
			varName = libc.UintptrFromInt32(0)
			if (*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents > int64(1) {
				/*
				 * Subst the index part of an array variable reference.
				 */
				code = XTclSubstTokens(tls, interp, tokenPtr+uintptr(2)*32, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents-int64(1), libc.UintptrFromInt32(0), *(*TTcl_Size)(unsafe.Pointer(bp)), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
				arrayIndex = XTcl_GetObjResult(tls, interp)
				(*TTcl_Obj)(unsafe.Pointer(arrayIndex)).FrefCount++
			}
			if code == TCL_OK {
				varName = XTcl_NewStringObj(tls, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fstart, (*(*TTcl_Token)(unsafe.Pointer(tokenPtr + 1*32))).Fsize)
				appendObj = XTcl_ObjGetVar2(tls, interp, varName, arrayIndex, int32(TCL_LEAVE_ERR_MSG))
				_objPtr = varName
				v5 = _objPtr
				v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
				*(*TTcl_Size)(unsafe.Pointer(v5))--
				if v4 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
				if appendObj == libc.UintptrFromInt32(0) {
					code = int32(TCL_ERROR)
				}
			}
			switch code {
			case TCL_OK: /* Got value */
				fallthrough
			case int32(TCL_ERROR): /* Already have error message */
				fallthrough
			case int32(TCL_BREAK): /* Will not substitute anyway */
				fallthrough
			case int32(TCL_CONTINUE): /* Will not substitute anyway */
			default:
				/*
				 * All other return codes, we will subst the result from the
				 * code-throwing evaluation.
				 */
				appendObj = XTcl_GetObjResult(tls, interp)
			}
			if arrayIndex != libc.UintptrFromInt32(0) {
				_objPtr1 = arrayIndex
				v7 = _objPtr1
				v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
				*(*TTcl_Size)(unsafe.Pointer(v7))--
				if v6 <= int64(1) {
					XTclFreeObj(tls, _objPtr1)
				}
			}
			count -= (*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents
			tokenPtr += uintptr((*TTcl_Token)(unsafe.Pointer(tokenPtr)).FnumComponents) * 32
		default:
			XTcl_Panic(tls, __ccgo_ts+56269, libc.VaList(bp+40, (*TTcl_Token)(unsafe.Pointer(tokenPtr)).Ftype1))
		}
		if code == int32(TCL_BREAK) || code == int32(TCL_CONTINUE) {
			/*
			 * Inhibit substitution.
			 */
			goto _2
		}
		if result == libc.UintptrFromInt32(0) {
			/*
			 * First pass through. If we have a Tcl_Obj, just use it. If not,
			 * create one from our string.
			 */
			if appendObj != libc.UintptrFromInt32(0) {
				result = appendObj
			} else {
				result = XTcl_NewStringObj(tls, append1, int64(appendByteLength))
			}
			(*TTcl_Obj)(unsafe.Pointer(result)).FrefCount++
		} else {
			/*
			 * Subsequent passes. Append to result.
			 */
			if (*TTcl_Obj)(unsafe.Pointer(result)).FrefCount > int64(1) {
				_objPtr2 = result
				v9 = _objPtr2
				v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
				*(*TTcl_Size)(unsafe.Pointer(v9))--
				if v8 <= int64(1) {
					XTclFreeObj(tls, _objPtr2)
				}
				result = XTcl_DuplicateObj(tls, result)
				(*TTcl_Obj)(unsafe.Pointer(result)).FrefCount++
			}
			if appendObj != libc.UintptrFromInt32(0) {
				XTcl_AppendObjToObj(tls, result, appendObj)
			} else {
				XTcl_AppendToObj(tls, result, append1, int64(appendByteLength))
			}
		}
		goto _2
	_2:
		;
		count--
		tokenPtr += 32
	}
	if code != int32(TCL_ERROR) { /* Keep error message in result! */
		if result != libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, result)
			/*
			 * If the code found continuation lines (which implies that this
			 * word is a literal), then we store the accumulated table of
			 * locations in the thread-global data structure for the bytecode
			 * compiler to find later, assuming that the literal is a script
			 * which will be compiled.
			 */
			if numCL != 0 {
				XTclContinuationsEnter(tls, result, numCL, clPosition)
			}
			/*
			 * Release the temp table we used to collect the locations of
			 * continuation lines, if any.
			 */
			if maxNumCL != 0 {
				XTclpFree(tls, clPosition)
			}
		} else {
			XTcl_ResetResult(tls, interp)
		}
	}
	if tokensLeftPtr != libc.UintptrFromInt32(0) {
		*(*int32)(unsafe.Pointer(tokensLeftPtr)) = int32(count)
	}
	if result != libc.UintptrFromInt32(0) {
		_objPtr3 = result
		v11 = _objPtr3
		v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
		*(*TTcl_Size)(unsafe.Pointer(v11))--
		if v10 <= int64(1) {
			XTclFreeObj(tls, _objPtr3)
		}
	}
	return code
}

/*
 *----------------------------------------------------------------------
 *
 * CommandComplete --
 *
 *	This function is shared by TclCommandComplete and
 *	Tcl_ObjCommandComplete; it does all the real work of seeing whether a
 *	script is complete
 *
 * Results:
 *	1 is returned if the script is complete, 0 if there are open
 *	delimiters such as " or (. 1 is also returned if there is a parse
 *	error in the script other than unmatched delimiters.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _CommandComplete(tls *libc.TLS, script uintptr, numBytes TTcl_Size) (r int32) {
	bp := tls.Alloc(752)
	defer tls.Free(752) /* Number of bytes in script. */
	var end, p uintptr
	var result int32
	var _ /* parse at bp+0 */ TTcl_Parse
	_, _, _ = end, p, result
	p = script
	end = p + uintptr(numBytes)
	for XTcl_ParseCommand(tls, libc.UintptrFromInt32(0), p, int64(end)-int64(p), 0, bp) == TCL_OK {
		p = (*(*TTcl_Parse)(unsafe.Pointer(bp))).FcommandStart + uintptr((*(*TTcl_Parse)(unsafe.Pointer(bp))).FcommandSize)
		if p >= end {
			break
		}
		XTcl_FreeParse(tls, bp)
	}
	if (*(*TTcl_Parse)(unsafe.Pointer(bp))).Fincomplete != 0 {
		result = 0
	} else {
		result = int32(1)
	}
	XTcl_FreeParse(tls, bp)
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_CommandComplete --
 *
 *	Given a partial or complete Tcl script, this function determines
 *	whether the script is complete in the sense of having matched braces
 *	and quotes and brackets.
 *
 * Results:
 *	1 is returned if the script is complete, 0 otherwise. 1 is also
 *	returned if there is a parse error in the script other than unmatched
 *	delimiters.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_CommandComplete(tls *libc.TLS, script uintptr) (r int32) {
	/* Script to check. */
	return _CommandComplete(tls, script, libc.Int64FromUint64(libc.Xstrlen(tls, script)))
}

/*
 *----------------------------------------------------------------------
 *
 * TclObjCommandComplete --
 *
 *	Given a partial or complete Tcl command in a Tcl object, this function
 *	determines whether the command is complete in the sense of having
 *	matched braces and quotes and brackets.
 *
 * Results:
 *	1 is returned if the command is complete, 0 otherwise.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclObjCommandComplete(tls *libc.TLS, objPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Points to object holding script to
	 * check. */
	var script, v1 uintptr
	var _ /* length at bp+0 */ TTcl_Size
	_, _ = script, v1
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, objPtr, bp)
	}
	script = v1
	return _CommandComplete(tls, script, *(*TTcl_Size)(unsafe.Pointer(bp)))
}

const TCLPATH_APPENDED = 1
const TCLPATH_NEEDNORM = 4

/*
 * Define the 'path' object type, which Tcl uses to represent file paths
 * internally.
 */

var _fsPathType = TTcl_ObjType{
	Fname: __ccgo_ts + 34695,
}

func init() {
	p := unsafe.Pointer(&_fsPathType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_FreeFsPathInternalRep)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_DupFsPathInternalRep)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_UpdateStringOfFsPath)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_SetFsPathFromAny)
}

/*
 * struct FsPath --
 *
 * Internal representation of a Tcl_Obj of fsPathType
 */

type TFsPath = struct {
	FtranslatedPathPtr uintptr
	FnormPathPtr       uintptr
	FcwdPtr            uintptr
	Fflags             int32
	FnativePathPtr     uintptr
	FfilesystemEpoch   Tsize_t
	FfsPtr             uintptr
}

/*
 * Flag values for FsPath->flags.
 */

/*
 * Define some macros to give us convenient access to path-object specific
 * fields.
 */

/*
 *---------------------------------------------------------------------------
 *
 * TclFSNormalizeAbsolutePath --
 *
 *	Takes an absolute path specification and computes a 'normalized' path
 *	from it.
 *
 *	A normalized path is one which has all '../', './' removed. Also it is
 *	one which is in the 'standard' format for the native platform. On
 *	Unix, this means the path must be free of symbolic links/aliases, and
 *	on Windows it means we want the long form, with that long form's
 *	case-dependence (which gives us a unique, case-dependent path).
 *
 *	The behaviour of this function if passed a non-absolute path is NOT
 *	defined.
 *
 *	pathPtr may have a refCount of zero, or may be a shared object.
 *
 * Results:
 *	The result is returned in a Tcl_Obj with a refCount already
 *	incremented, which gives the caller ownership of it.  The caller must
 *	arrange for Tcl_DecRefCount to be called when the object is no-longer
 *	needed.
 *
 * Side effects:
 *	None (beyond the memory allocation for the result).
 *
 * Special note:
 *	Originally based on code from Matt Newman and Jean-Claude Wippler.
 *	Totally rewritten later by Vince Darley to handle symbolic links.
 *
 *---------------------------------------------------------------------------
 */

func XTclFSNormalizeAbsolutePath(tls *libc.TLS, interp uintptr, pathPtr uintptr) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Absolute path to normalize */
	var cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, dirSep, linkObj, linkStr, oldDirSep, path, path1, path2, path3, retVal, v1, v12, v14, v16, v19, v2, v21, v23, v27, v29, v31, v4, v7, v9 uintptr
	var first, minLen, needTrailingSlash, zipVolumeLen, v24 int32
	var i, v10, v11, v15, v18, v25, v26, v30, v6 TTcl_Size
	var v13, v17, v20, v28, v32, v8 bool
	var _ /* curLen at bp+0 */ TTcl_Size
	var _ /* curLen at bp+8 */ TTcl_Size
	var _ /* len at bp+16 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, dirSep, first, i, linkObj, linkStr, minLen, needTrailingSlash, oldDirSep, path, path1, path2, path3, retVal, zipVolumeLen, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v4, v6, v7, v8, v9
	first = int32(1) /* Set to zero once we've passed the first
	 * directory separator - we can't use '..' to
	 * remove the volume in a path. */
	retVal = libc.UintptrFromInt32(0)
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
	}
	dirSep = v1
	zipVolumeLen = XTclIsZipfsPath(tls, dirSep)
	if zipVolumeLen != 0 {
		/*
		 * NOTE: file normalization for zipfs is very specific to
		 * format of zipfs volume being of the form //xxx:/
		 */
		dirSep += uintptr(zipVolumeLen - int32(1)) /* Start parse after : */
	} else {
		if XtclPlatform == int32(TCL_PLATFORM_WINDOWS) {
			if (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep))) == int32('/') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep))) == int32('\\')) && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep + 1))) == int32('/') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep + 1))) == int32('\\')) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep + 2))) == int32('?') && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep + 3))) == int32('/') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep + 3))) == int32('\\')) {
				/* NT extended path */
				dirSep += uintptr(4)
				if (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep))) == int32('U') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep))) == int32('u')) && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep + 1))) == int32('N') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep + 1))) == int32('n')) && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep + 2))) == int32('C') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep + 2))) == int32('c')) && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep + 3))) == int32('/') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep + 3))) == int32('\\')) {
					/* NT extended UNC path */
					dirSep += uintptr(4)
				}
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep))) != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep + 1))) == int32(':') && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep + 2))) == int32('/') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep + 2))) == int32('\\')) {
				/* Do nothing */
			} else {
				if (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep))) == int32('/') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep))) == int32('\\')) && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep + 1))) == int32('/') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep + 1))) == int32('\\')) {
					/*
					 * UNC style path, where we must skip over the first separator,
					 * since the first two segments are actually inseparable.
					 */
					dirSep += uintptr(2)
					dirSep += uintptr(_FindSplitPos(tls, dirSep, int32('/')))
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep))) != 0 {
						dirSep++
					}
				}
			}
		}
	}
	/*
	 * Scan forward from one directory separator to the next, checking for
	 * '..' and '.' sequences which must be handled specially. In particular
	 * handling of '..' can be complicated if the directory before is a link,
	 * since we will have to expand the link to be able to back up one level.
	 */
	for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep))) != 0 {
		oldDirSep = dirSep
		if !(first != 0) {
			dirSep++
		}
		dirSep += uintptr(_FindSplitPos(tls, dirSep, int32('/')))
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep))) == 0 || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep + 1))) == 0 {
			if retVal != libc.UintptrFromInt32(0) {
				XTcl_AppendToObj(tls, retVal, oldDirSep, int64(dirSep)-int64(oldDirSep))
			}
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep + 1))) == int32('.') {
			if retVal != libc.UintptrFromInt32(0) {
				XTcl_AppendToObj(tls, retVal, oldDirSep, int64(dirSep)-int64(oldDirSep))
				oldDirSep = dirSep
			}
			goto again
		again:
			;
			if _IsSeparatorOrNull(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep + 2)))) != 0 {
				if retVal == libc.UintptrFromInt32(0) {
					if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
						v2 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
					} else {
						v2 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
					}
					path = v2
					retVal = XTcl_NewStringObj(tls, path, int64(dirSep)-int64(path))
					(*TTcl_Obj)(unsafe.Pointer(retVal)).FrefCount++
				}
				if (*TTcl_Obj)(unsafe.Pointer(retVal)).Fbytes != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(retVal)).Flength
					_ = (*TTcl_Obj)(unsafe.Pointer(retVal)).Fbytes
				} else {
					XTcl_GetStringFromObj(tls, retVal, bp)
				}
				if *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
					XTcl_AppendToObj(tls, retVal, dirSep, int64(1))
				}
				dirSep += uintptr(2)
				oldDirSep = dirSep
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep))) != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep + 1))) == int32('.') {
					goto again
				}
				continue
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep + 2))) == int32('.') && _IsSeparatorOrNull(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep + 3)))) != 0 {
				/*
				 * Have '..' so need to skip previous directory.
				 */
				if retVal == libc.UintptrFromInt32(0) {
					if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
						v4 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
					} else {
						v4 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
					}
					path1 = v4
					retVal = XTcl_NewStringObj(tls, path1, int64(dirSep)-int64(path1))
					(*TTcl_Obj)(unsafe.Pointer(retVal)).FrefCount++
				}
				if (*TTcl_Obj)(unsafe.Pointer(retVal)).Fbytes != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(retVal)).Flength
					_ = (*TTcl_Obj)(unsafe.Pointer(retVal)).Fbytes
				} else {
					XTcl_GetStringFromObj(tls, retVal, bp+8)
				}
				if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == 0 {
					XTcl_AppendToObj(tls, retVal, dirSep, int64(1))
				}
				if !(first != 0) || XtclPlatform == int32(TCL_PLATFORM_UNIX) {
					if zipVolumeLen != 0 {
						linkObj = libc.UintptrFromInt32(0)
					} else {
						linkObj = XTcl_FSLink(tls, retVal, libc.UintptrFromInt32(0), 0)
						/* Safety check in case driver caused sharing */
						if (*TTcl_Obj)(unsafe.Pointer(retVal)).FrefCount > int64(1) {
							v7 = retVal
							v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
							*(*TTcl_Size)(unsafe.Pointer(v7))--
							if !(v6 > int64(1)) {
								if !((*TTcl_Obj)(unsafe.Pointer(retVal)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(retVal)).FtypePtr)).FfreeIntRepProc != 0) {
									if (*TTcl_Obj)(unsafe.Pointer(retVal)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(retVal)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
										XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(retVal)).Fbytes)
									}
									(*TTcl_Obj)(unsafe.Pointer(retVal)).Flength = int64(-libc.Int32FromInt32(1))
									if v8 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v8 {
										cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
									}
									if v8 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
										XTclThreadFreeObj(tls, retVal)
									} else {
										(*(*struct {
											Fptr1 uintptr
											Fptr2 uintptr
										})(unsafe.Pointer(retVal + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
										(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = retVal
										(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
									}
								} else {
									XTclFreeObj(tls, retVal)
								}
							}
							retVal = XTcl_DuplicateObj(tls, retVal)
							(*TTcl_Obj)(unsafe.Pointer(retVal)).FrefCount++
						}
					}
					if linkObj != libc.UintptrFromInt32(0) {
						/*
						 * Got a link. Need to check if the link is relative
						 * or absolute, for those platforms where relative
						 * links exist.
						 */
						if XtclPlatform != int32(TCL_PLATFORM_WINDOWS) && XTcl_FSGetPathType(tls, linkObj) == int32(TCL_PATH_RELATIVE) {
							if (*TTcl_Obj)(unsafe.Pointer(retVal)).Fbytes != 0 {
								*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(retVal)).Flength
								v9 = (*TTcl_Obj)(unsafe.Pointer(retVal)).Fbytes
							} else {
								v9 = XTcl_GetStringFromObj(tls, retVal, bp+8)
							}
							/*
							 * We need to follow this link which is relative
							 * to retVal's directory. This means concatenating
							 * the link onto the directory of the path so far.
							 */
							path2 = v9
							for {
								v10 = *(*TTcl_Size)(unsafe.Pointer(bp + 8))
								*(*TTcl_Size)(unsafe.Pointer(bp + 8))--
								if !(v10 > 0) {
									break
								}
								if _IsSeparatorOrNull(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path2 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8))))))) != 0 {
									break
								}
							}
							/*
							 * We want the trailing slash.
							 */
							XTcl_SetObjLength(tls, retVal, *(*TTcl_Size)(unsafe.Pointer(bp + 8))+int64(1))
							XTcl_AppendObjToObj(tls, retVal, linkObj)
							v12 = linkObj
							v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
							*(*TTcl_Size)(unsafe.Pointer(v12))--
							if !(v11 > int64(1)) {
								if !((*TTcl_Obj)(unsafe.Pointer(linkObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(linkObj)).FtypePtr)).FfreeIntRepProc != 0) {
									if (*TTcl_Obj)(unsafe.Pointer(linkObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(linkObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
										XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(linkObj)).Fbytes)
									}
									(*TTcl_Obj)(unsafe.Pointer(linkObj)).Flength = int64(-libc.Int32FromInt32(1))
									if v13 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v13 {
										cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
									}
									if v13 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
										XTclThreadFreeObj(tls, linkObj)
									} else {
										(*(*struct {
											Fptr1 uintptr
											Fptr2 uintptr
										})(unsafe.Pointer(linkObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
										(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = linkObj
										(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
									}
								} else {
									XTclFreeObj(tls, linkObj)
								}
							}
							if (*TTcl_Obj)(unsafe.Pointer(retVal)).Fbytes != 0 {
								*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(retVal)).Flength
								v14 = (*TTcl_Obj)(unsafe.Pointer(retVal)).Fbytes
							} else {
								v14 = XTcl_GetStringFromObj(tls, retVal, bp+8)
							}
							linkStr = v14
						} else {
							/*
							 * Absolute link.
							 */
							v16 = retVal
							v15 = *(*TTcl_Size)(unsafe.Pointer(v16))
							*(*TTcl_Size)(unsafe.Pointer(v16))--
							if !(v15 > int64(1)) {
								if !((*TTcl_Obj)(unsafe.Pointer(retVal)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(retVal)).FtypePtr)).FfreeIntRepProc != 0) {
									if (*TTcl_Obj)(unsafe.Pointer(retVal)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(retVal)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
										XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(retVal)).Fbytes)
									}
									(*TTcl_Obj)(unsafe.Pointer(retVal)).Flength = int64(-libc.Int32FromInt32(1))
									if v17 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v17 {
										cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
									}
									if v17 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
										XTclThreadFreeObj(tls, retVal)
									} else {
										(*(*struct {
											Fptr1 uintptr
											Fptr2 uintptr
										})(unsafe.Pointer(retVal + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
										(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = retVal
										(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
									}
								} else {
									XTclFreeObj(tls, retVal)
								}
							}
							if (*TTcl_Obj)(unsafe.Pointer(linkObj)).FrefCount > int64(1) {
								retVal = XTcl_DuplicateObj(tls, linkObj)
								v19 = linkObj
								v18 = *(*TTcl_Size)(unsafe.Pointer(v19))
								*(*TTcl_Size)(unsafe.Pointer(v19))--
								if !(v18 > int64(1)) {
									if !((*TTcl_Obj)(unsafe.Pointer(linkObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(linkObj)).FtypePtr)).FfreeIntRepProc != 0) {
										if (*TTcl_Obj)(unsafe.Pointer(linkObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(linkObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
											XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(linkObj)).Fbytes)
										}
										(*TTcl_Obj)(unsafe.Pointer(linkObj)).Flength = int64(-libc.Int32FromInt32(1))
										if v20 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v20 {
											cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
										}
										if v20 || ((*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
											XTclThreadFreeObj(tls, linkObj)
										} else {
											(*(*struct {
												Fptr1 uintptr
												Fptr2 uintptr
											})(unsafe.Pointer(linkObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
											(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = linkObj
											(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects++
										}
									} else {
										XTclFreeObj(tls, linkObj)
									}
								}
							} else {
								retVal = linkObj
							}
							if (*TTcl_Obj)(unsafe.Pointer(retVal)).Fbytes != 0 {
								*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(retVal)).Flength
								v21 = (*TTcl_Obj)(unsafe.Pointer(retVal)).Fbytes
							} else {
								v21 = XTcl_GetStringFromObj(tls, retVal, bp+8)
							}
							linkStr = v21
							/*
							 * Convert to forward-slashes on windows.
							 */
							if XtclPlatform == int32(TCL_PLATFORM_WINDOWS) {
								i = 0
								for {
									if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) {
										break
									}
									if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(linkStr + uintptr(i)))) == int32('\\') {
										*(*uint8)(unsafe.Pointer(linkStr + uintptr(i))) = uint8('/')
									}
									goto _22
								_22:
									;
									i++
								}
							}
						}
					} else {
						if (*TTcl_Obj)(unsafe.Pointer(retVal)).Fbytes != 0 {
							*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(retVal)).Flength
							v23 = (*TTcl_Obj)(unsafe.Pointer(retVal)).Fbytes
						} else {
							v23 = XTcl_GetStringFromObj(tls, retVal, bp+8)
						}
						linkStr = v23
					}
					if zipVolumeLen != 0 {
						v24 = zipVolumeLen - int32(1)
					} else {
						v24 = 0
					}
					/*
					 * Either way, we now remove the last path element (but
					 * not the first character of the path). In the case of
					 * zipfs, make sure not to go beyond the zipfs volume.
					 */
					minLen = v24
					for {
						*(*TTcl_Size)(unsafe.Pointer(bp + 8))--
						v25 = *(*TTcl_Size)(unsafe.Pointer(bp + 8))
						if !(v25 >= int64(minLen)) {
							break
						}
						if _IsSeparatorOrNull(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(linkStr + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8))))))) != 0 {
							if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) != 0 {
								XTcl_SetObjLength(tls, retVal, *(*TTcl_Size)(unsafe.Pointer(bp + 8)))
							} else {
								XTcl_SetObjLength(tls, retVal, int64(1))
							}
							break
						}
					}
				}
				dirSep += uintptr(3)
				oldDirSep = dirSep
				if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep))) != 0 {
					XTcl_SetObjLength(tls, retVal, 0)
				}
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep))) != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirSep + 1))) == int32('.') {
					goto again
				}
				continue
			}
		}
		first = 0
		if retVal != libc.UintptrFromInt32(0) {
			XTcl_AppendToObj(tls, retVal, oldDirSep, int64(dirSep)-int64(oldDirSep))
		}
	}
	/*
	 * If we didn't make any changes, just use the input path.
	 */
	if retVal == libc.UintptrFromInt32(0) {
		retVal = pathPtr
		(*TTcl_Obj)(unsafe.Pointer(retVal)).FrefCount++
		if (*TTcl_Obj)(unsafe.Pointer(retVal)).FrefCount > int64(1) {
			/*
			 * Unfortunately, the platform-specific normalization code which
			 * will be called below has no way of dealing with the case where
			 * an object is shared. It is expecting to modify an object in
			 * place. So, we must duplicate this here to ensure an object with
			 * a single ref-count.
			 *
			 * If that changes in the future (e.g. the normalize proc is given
			 * one object and is able to return a different one), then we
			 * could remove this code.
			 */
			v27 = retVal
			v26 = *(*TTcl_Size)(unsafe.Pointer(v27))
			*(*TTcl_Size)(unsafe.Pointer(v27))--
			if !(v26 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(retVal)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(retVal)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(retVal)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(retVal)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(retVal)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(retVal)).Flength = int64(-libc.Int32FromInt32(1))
					if v28 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v28 {
						cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v28 || ((*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, retVal)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(retVal + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = retVal
						(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, retVal)
				}
			}
			retVal = XTcl_DuplicateObj(tls, pathPtr)
			(*TTcl_Obj)(unsafe.Pointer(retVal)).FrefCount++
		}
	}
	/*
	 * Ensure a windows drive like C:/ has a trailing separator.
	 * Likewise for zipfs volumes.
	 */
	if zipVolumeLen != 0 || XtclPlatform == int32(TCL_PLATFORM_WINDOWS) {
		needTrailingSlash = 0
		if (*TTcl_Obj)(unsafe.Pointer(retVal)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = (*TTcl_Obj)(unsafe.Pointer(retVal)).Flength
			v29 = (*TTcl_Obj)(unsafe.Pointer(retVal)).Fbytes
		} else {
			v29 = XTcl_GetStringFromObj(tls, retVal, bp+16)
		}
		path3 = v29
		if zipVolumeLen != 0 {
			if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) == int64(zipVolumeLen-libc.Int32FromInt32(1)) {
				needTrailingSlash = int32(1)
			}
		} else {
			if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) == int64(2) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path3))) != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path3 + 1))) == int32(':') {
				needTrailingSlash = int32(1)
			}
		}
		if needTrailingSlash != 0 {
			if (*TTcl_Obj)(unsafe.Pointer(retVal)).FrefCount > int64(1) {
				v31 = retVal
				v30 = *(*TTcl_Size)(unsafe.Pointer(v31))
				*(*TTcl_Size)(unsafe.Pointer(v31))--
				if !(v30 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(retVal)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(retVal)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(retVal)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(retVal)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(retVal)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(retVal)).Flength = int64(-libc.Int32FromInt32(1))
						if v32 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v32 {
							cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v32 || ((*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, retVal)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(retVal + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = retVal
							(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, retVal)
					}
				}
				retVal = XTcl_DuplicateObj(tls, retVal)
				(*TTcl_Obj)(unsafe.Pointer(retVal)).FrefCount++
			}
			XTcl_AppendToObj(tls, retVal, __ccgo_ts+6339, int64(1))
		}
	}
	/*
	 * Now we have an absolute path, with no '..', '.' sequences, but it still
	 * may not be in 'unique' form, depending on the platform. For instance,
	 * Unix is case-sensitive, so the path is ok. Windows is case-insensitive,
	 * and also has the weird 'longname/shortname' thing (e.g. C:/Program
	 * Files/ and C:/Progra~1/ are equivalent).
	 *
	 * Virtual file systems which may be registered may have other criteria
	 * for normalizing a path.
	 */
	XTclFSNormalizeToUniquePath(tls, interp, retVal, 0)
	/*
	 * Since we know it is a normalized path, we can actually convert this
	 * object into an FsPath for greater efficiency
	 */
	_MakePathFromNormalized(tls, interp, retVal)
	/*
	 * This has a refCount of 1 for the caller, unlike many Tcl_Obj APIs.
	 */
	return retVal
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FSGetPathType --
 *
 *	Determines whether a given path is relative to the current directory,
 *	relative to the current volume, or absolute.
 *
 * Results:
 *	Returns one of TCL_PATH_ABSOLUTE, TCL_PATH_RELATIVE, or
 *	TCL_PATH_VOLUME_RELATIVE.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FSGetPathType(tls *libc.TLS, pathPtr uintptr) (r TTcl_PathType) {
	return XTclFSGetPathType(tls, pathPtr, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
}

/*
 *----------------------------------------------------------------------
 *
 * TclFSGetPathType --
 *
 *	Determines whether a given path is relative to the current directory,
 *	relative to the current volume, or absolute. If the caller wishes to
 *	know which filesystem claimed the path (in the case for which the path
 *	is absolute), then a reference to a filesystem pointer can be passed
 *	in (but passing NULL is acceptable).
 *
 * Results:
 *	Returns one of TCL_PATH_ABSOLUTE, TCL_PATH_RELATIVE, or
 *	TCL_PATH_VOLUME_RELATIVE. The filesystem reference will be set if and
 *	only if it is non-NULL and the function's return value is
 *	TCL_PATH_ABSOLUTE.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclFSGetPathType(tls *libc.TLS, pathPtr uintptr, filesystemPtrPtr uintptr, driveNameLengthPtr uintptr) (r TTcl_PathType) {
	var fsPathPtr, v1, v2 uintptr
	_, _, _ = fsPathPtr, v1, v2
	if XTcl_FSConvertToPathType(tls, libc.UintptrFromInt32(0), pathPtr) != TCL_OK {
		return XTclGetPathType(tls, pathPtr, filesystemPtrPtr, driveNameLengthPtr, libc.UintptrFromInt32(0))
	}
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
		v1 = pathPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	fsPathPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(v1))).Fptr1
	if (*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr == libc.UintptrFromInt32(0) {
		return XTclGetPathType(tls, pathPtr, filesystemPtrPtr, driveNameLengthPtr, libc.UintptrFromInt32(0))
	}
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
		v2 = pathPtr + 32
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	if (*TFsPath)(unsafe.Pointer((*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(v2))).Fptr1)).Fflags == 0 {
		/* The path is not absolute... */
		/* On other systems, quickly deduce !absolute -> relative */
		return int32(TCL_PATH_RELATIVE)
	}
	return XTclFSGetPathType(tls, (*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr, filesystemPtrPtr, driveNameLengthPtr)
}

/*
 *---------------------------------------------------------------------------
 *
 * TclPathPart
 *
 *	This function calculates the requested part of the given path, which
 *	can be:
 *
 *	- the directory above ('file dirname')
 *	- the tail            ('file tail')
 *	- the extension       ('file extension')
 *	- the root            ('file root')
 *
 *	The 'portion' parameter dictates which of these to calculate. There
 *	are a number of special cases both to be more efficient, and because
 *	the behaviour when given a path with only a single element is defined
 *	to require the expansion of that single element, where possible.
 *
 *	Should look into integrating 'FileBasename' in tclFCmd.c into this
 *	function.
 *
 * Results:
 *	NULL if an error occurred, otherwise a Tcl_Obj owned by the caller
 *	(i.e. most likely with refCount 1).
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTclPathPart(tls *libc.TLS, dummy569 uintptr, pathPtr uintptr, portion TTcl_PathPart) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Requested portion of name */
	var cachePtr, cachePtr1, cachePtr2, extension, extension1, fileName, fileName1, fsPathPtr, rest, rest1, resultPtr, root, splitPtr, v12, v3, v4, v5, v6, v7, v8 uintptr
	var v10, v13, v9 bool
	var v11 TTcl_Size
	var _ /* length at bp+16 */ TTcl_Size
	var _ /* length at bp+40 */ TTcl_Size
	var _ /* numBytes at bp+0 */ TTcl_Size
	var _ /* numBytes at bp+8 */ TTcl_Size
	var _ /* resultPtr at bp+32 */ uintptr
	var _ /* splitElements at bp+24 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, extension, extension1, fileName, fileName1, fsPathPtr, rest, rest1, resultPtr, root, splitPtr, v10, v11, v12, v13, v3, v4, v5, v6, v7, v8, v9
	if !((*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType))) {
		goto _1
	}
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
		v3 = pathPtr + 32
	} else {
		v3 = libc.UintptrFromInt32(0)
	}
	fsPathPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(v3))).Fptr1
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
		v4 = pathPtr + 32
	} else {
		v4 = libc.UintptrFromInt32(0)
	}
	if (*TFsPath)(unsafe.Pointer((*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(v4))).Fptr1)).Fflags != 0 {
		switch portion {
		case int32(TCL_PATH_DIRNAME):
			if (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).Flength
				v5 = (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).Fbytes
			} else {
				v5 = XTcl_GetStringFromObj(tls, (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr, bp)
			}
			rest = v5
			if libc.Xstrchr(tls, rest, int32('/')) != libc.UintptrFromInt32(0) {
				goto standardPath
			}
			/*
			 * If the joined-on bit is empty, then [file dirname] is
			 * documented to return all but the last non-empty element
			 * of the path, so we need to split apart the main part to
			 * get the right answer.  We could do that here, but it's
			 * simpler to fall back to the standardPath code.
			 * [Bug 2710920]
			 */
			if *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
				goto standardPath
			}
			if XtclPlatform == int32(TCL_PLATFORM_WINDOWS) && libc.Xstrchr(tls, rest, int32('\\')) != libc.UintptrFromInt32(0) {
				goto standardPath
			}
			/*
			 * The joined-on path is simple, so we can just return here.
			 */
			(*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr)).FrefCount++
			return (*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr
		case int32(TCL_PATH_TAIL):
			if (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).Flength
				v6 = (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).Fbytes
			} else {
				v6 = XTcl_GetStringFromObj(tls, (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr, bp+8)
			}
			rest1 = v6
			if libc.Xstrchr(tls, rest1, int32('/')) != libc.UintptrFromInt32(0) {
				goto standardPath
			}
			/*
			 * If the joined-on bit is empty, then [file tail] is
			 * documented to return the last non-empty element
			 * of the path, so we need to split off the last element
			 * of the main part to get the right answer.  We could do
			 * that here, but it's simpler to fall back to the
			 * standardPath code.  [Bug 2710920]
			 */
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == 0 {
				goto standardPath
			}
			if XtclPlatform == int32(TCL_PLATFORM_WINDOWS) && libc.Xstrchr(tls, rest1, int32('\\')) != libc.UintptrFromInt32(0) {
				goto standardPath
			}
			(*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).FrefCount++
			return (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr
		case int32(TCL_PATH_EXTENSION):
			return _GetExtension(tls, (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)
		case int32(TCL_PATH_ROOT):
			if (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).Flength
				v7 = (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).Fbytes
			} else {
				v7 = XTcl_GetStringFromObj(tls, (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr, bp+16)
			}
			fileName = v7
			extension = XTclGetExtension(tls, fileName)
			if extension == libc.UintptrFromInt32(0) {
				/*
				 * There is no extension so the root is the same as the
				 * path we were given.
				 */
				(*TTcl_Obj)(unsafe.Pointer(pathPtr)).FrefCount++
				return pathPtr
			} else {
				/*
				 * Need to return the whole path with the extension
				 * suffix removed.  Do that by joining our "head" to
				 * our "tail" with the extension suffix removed from
				 * the tail.
				 */
				resultPtr = XTclNewFSPathObj(tls, (*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr, fileName, libc.Int64FromUint64(libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 16)))-libc.Xstrlen(tls, extension)))
				(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount++
				return resultPtr
			}
			fallthrough
		default:
			/* We should never get here */
			XTcl_Panic(tls, __ccgo_ts+56313, 0)
			/* For less clever compilers */
			return libc.UintptrFromInt32(0)
		}
	} else {
		if (*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr != libc.UintptrFromInt32(0) {
			/* Relative path */
			goto standardPath
		} else {
			/* Absolute path */
			goto standardPath
		}
	}
	goto _2
_1:
	;
	goto standardPath
standardPath:
	;
	*(*uintptr)(unsafe.Pointer(bp + 32)) = libc.UintptrFromInt32(0)
	if portion == int32(TCL_PATH_EXTENSION) {
		return _GetExtension(tls, pathPtr)
	} else {
		if portion == int32(TCL_PATH_ROOT) {
			if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Flength
				v8 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
			} else {
				v8 = XTcl_GetStringFromObj(tls, pathPtr, bp+40)
			}
			fileName1 = v8
			extension1 = XTclGetExtension(tls, fileName1)
			if extension1 == libc.UintptrFromInt32(0) {
				(*TTcl_Obj)(unsafe.Pointer(pathPtr)).FrefCount++
				return pathPtr
			} else {
				root = XTcl_NewStringObj(tls, fileName1, libc.Int64FromUint64(libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 40)))-libc.Xstrlen(tls, extension1)))
				(*TTcl_Obj)(unsafe.Pointer(root)).FrefCount++
				return root
			}
		}
	}
	/*
	 * Tcl_FSSplitPath in the handling of home directories;
	 * Tcl_FSSplitPath preserves the "~",  but this code computes the
	 * actual full path name, if we had just a single component.
	 */
	splitPtr = XTcl_FSSplitPath(tls, pathPtr, bp+24)
	(*TTcl_Obj)(unsafe.Pointer(splitPtr)).FrefCount++
	if portion == int32(TCL_PATH_TAIL) {
		/*
		 * Return the last component, unless it is the only component, and
		 * it is the root of an absolute path.
		 */
		if *(*TTcl_Size)(unsafe.Pointer(bp + 24)) > 0 && (*(*TTcl_Size)(unsafe.Pointer(bp + 24)) > int64(1) || XTcl_FSGetPathType(tls, pathPtr) == int32(TCL_PATH_RELATIVE)) {
			XTcl_ListObjIndex(tls, libc.UintptrFromInt32(0), splitPtr, *(*TTcl_Size)(unsafe.Pointer(bp + 24))-int64(1), bp+32)
		} else {
			if v9 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v9 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v9 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				*(*uintptr)(unsafe.Pointer(bp + 32)) = XTclThreadAllocObj(tls)
			} else {
				*(*uintptr)(unsafe.Pointer(bp + 32)) = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)) + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))).FtypePtr = libc.UintptrFromInt32(0)
		}
	} else {
		/*
		 * Return all but the last component. If there is only one
		 * component, return it if the path was non-relative, otherwise
		 * return the current directory.
		 */
		if *(*TTcl_Size)(unsafe.Pointer(bp + 24)) > int64(1) {
			*(*uintptr)(unsafe.Pointer(bp + 32)) = XTcl_FSJoinPath(tls, splitPtr, *(*TTcl_Size)(unsafe.Pointer(bp + 24))-int64(1))
		} else {
			if *(*TTcl_Size)(unsafe.Pointer(bp + 24)) == 0 || XTcl_FSGetPathType(tls, pathPtr) == int32(TCL_PATH_RELATIVE) {
				if v10 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v10 {
					cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v10 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
					*(*uintptr)(unsafe.Pointer(bp + 32)) = XTclThreadAllocObj(tls)
				} else {
					*(*uintptr)(unsafe.Pointer(bp + 32)) = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)) + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))).FrefCount = 0
				if libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1) == uint64(0) {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))).Flength = int64(libc.Int32FromInt32(0))
				} else {
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
					libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))).Fbytes, __ccgo_ts+35293, libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1))
					*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))).Fbytes + uintptr(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))) = uint8('\000')
					(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(2) - libc.Uint64FromInt32(1))
				}
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))).FtypePtr = libc.UintptrFromInt32(0)
			} else {
				XTcl_ListObjIndex(tls, libc.UintptrFromInt32(0), splitPtr, 0, bp+32)
			}
		}
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))).FrefCount++
	v12 = splitPtr
	v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
	*(*TTcl_Size)(unsafe.Pointer(v12))--
	if !(v11 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(splitPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(splitPtr)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(splitPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(splitPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(splitPtr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(splitPtr)).Flength = int64(-libc.Int32FromInt32(1))
			if v13 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v13 {
				cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v13 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, splitPtr)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(splitPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = splitPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, splitPtr)
		}
	}
	return *(*uintptr)(unsafe.Pointer(bp + 32))
_2:
	;
	return r
}

/*
 * Simple helper function
 */

func _GetExtension(tls *libc.TLS, pathPtr uintptr) (r uintptr) {
	var cachePtr, extension, ret, tail, v1 uintptr
	var v2 bool
	_, _, _, _, _, _ = cachePtr, extension, ret, tail, v1, v2
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
	}
	tail = v1
	extension = XTclGetExtension(tls, tail)
	if extension == libc.UintptrFromInt32(0) {
		if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			ret = XTclThreadAllocObj(tls)
		} else {
			ret = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(ret + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(ret)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(ret)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(ret)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(ret)).FtypePtr = libc.UintptrFromInt32(0)
	} else {
		ret = XTcl_NewStringObj(tls, extension, int64(-int32(1)))
	}
	(*TTcl_Obj)(unsafe.Pointer(ret)).FrefCount++
	return ret
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_FSJoinPath --
 *
 *	This function takes the given Tcl_Obj, which should be a valid list,
 *	and returns the path object given by considering the first 'elements'
 *	elements as valid path segments (each path segment may be a complete
 *	path, a partial path or just a single possible directory or file
 *	name). If any path segment is actually an absolute path, then all
 *	prior path segments are discarded.
 *
 *	If elements < 0, we use the entire list that was given.
 *
 *	It is possible that the returned object is actually an element of the
 *	given list, so the caller should be careful to store a refCount to it
 *	before freeing the list.
 *
 * Results:
 *	Returns object with refCount of zero, (or if non-zero, it has
 *	references elsewhere in Tcl). Either way, the caller must increment
 *	its refCount before use. Note that in the case where the caller has
 *	asked to join zero elements of the list, the return value will be an
 *	empty-string Tcl_Obj.
 *
 *	If the given listObj was invalid, then the calling routine has a bug,
 *	and this function will just return NULL.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_FSJoinPath(tls *libc.TLS, listObj uintptr, elements TTcl_Size) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Number of elements to use (-1 = all) */
	var res uintptr
	var v1 int32
	var v2, v3, v5, v6 int64
	var _ /* objc at bp+0 */ TTcl_Size
	var _ /* objv at bp+8 */ uintptr
	_, _, _, _, _, _ = res, v1, v2, v3, v5, v6
	if (*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listObj + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr2)).FspanLength
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v2
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), listObj, bp)
	}
	if v1 != TCL_OK {
		return libc.UintptrFromInt32(0)
	}
	if elements >= 0 && elements <= *(*TTcl_Size)(unsafe.Pointer(bp)) {
		v3 = elements
	} else {
		v3 = *(*TTcl_Size)(unsafe.Pointer(bp))
	}
	elements = v3
	if (*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listObj + 32))).Fptr2 != 0 {
			v5 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr2)).FspanStart
		} else {
			v5 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listObj + 32))).Fptr1 + 40 + uintptr(v5)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listObj + 32))).Fptr2 != 0 {
			v6 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr2)).FspanLength
		} else {
			v6 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v6
		_ = libc.Int32FromInt32(TCL_OK)
	} else {
		XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), listObj, bp, bp+8)
	}
	res = XTclJoinPath(tls, elements, *(*uintptr)(unsafe.Pointer(bp + 8)), 0)
	return res
}

func XTclJoinPath(tls *libc.TLS, elements TTcl_Size, objv uintptr, forceRelative int32) (r uintptr) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* If non-zero, assume all more paths are
	 * relative (e.g. simple normalization) */
	var _objPtr, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, elt, elt1, eltIr, ptr, res, sep, str, str1, strElt, tailObj, v11, v14, v17, v2, v20, v22, v25, v26, v28, v31, v34, v36, v37, v38, v4, v5, v7, v8, v9 uintptr
	var i, v13, v16, v19, v21, v27, v30 TTcl_Size
	var needsSep, v12, v3 int32
	var type1, type11 TTcl_PathType
	var v1, v15, v18, v23, v24, v29, v32, v6 bool
	var _ /* driveName at bp+40 */ uintptr
	var _ /* driveNameLength at bp+16 */ TTcl_Size
	var _ /* fsPtr at bp+0 */ uintptr
	var _ /* len at bp+8 */ TTcl_Size
	var _ /* length at bp+32 */ TTcl_Size
	var _ /* separator at bp+48 */ uint8
	var _ /* strEltLen at bp+24 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, elt, elt1, eltIr, i, needsSep, ptr, res, sep, str, str1, strElt, tailObj, type1, type11, v1, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v34, v36, v37, v38, v4, v5, v6, v7, v8, v9
	res = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	if elements == 0 {
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			res = XTclThreadAllocObj(tls)
		} else {
			res = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(res + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(res)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(res)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(res)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(res)).FtypePtr = libc.UintptrFromInt32(0)
		return res
	}
	if elements == int64(2) {
		elt = *(*uintptr)(unsafe.Pointer(objv))
		if (*TTcl_Obj)(unsafe.Pointer(elt)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
			v2 = elt + 32
		} else {
			v2 = libc.UintptrFromInt32(0)
		}
		eltIr = v2
		/*
		 * This is a special case where we can be much more efficient, where
		 * we are joining a single relative path onto an object that is
		 * already of path type. The 'TclNewFSPathObj' call below creates an
		 * object which can be normalized more efficiently. Currently we only
		 * use the special case when we have exactly two elements, but we
		 * could expand that in the future.
		 *
		 * Bugfix [a47641a0]. TclNewFSPathObj requires first argument
		 * to be an absolute path. Added a check to ensure that elt is absolute.
		 */
		if eltIr != 0 && !((*TTcl_Obj)(unsafe.Pointer(elt)).Fbytes != libc.UintptrFromInt32(0) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(elt)).Fbytes))) == int32('\000')) && XTclGetPathType(tls, elt, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0)) == int32(TCL_PATH_ABSOLUTE) {
			tailObj = *(*uintptr)(unsafe.Pointer(objv + 1*8))
			/* if forceRelative - second path is relative */
			if forceRelative != 0 {
				v3 = int32(TCL_PATH_RELATIVE)
			} else {
				v3 = XTclGetPathType(tls, tailObj, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
			}
			type1 = v3
			if type1 == int32(TCL_PATH_RELATIVE) {
				if (*TTcl_Obj)(unsafe.Pointer(tailObj)).Fbytes != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(tailObj)).Flength
					v4 = (*TTcl_Obj)(unsafe.Pointer(tailObj)).Fbytes
				} else {
					v4 = XTcl_GetStringFromObj(tls, tailObj, bp+8)
				}
				str = v4
				if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == 0 {
					/*
					 * This happens if we try to handle the root volume '/'.
					 * There's no need to return a special path object, when
					 * the base itself is just fine!
					 */
					return elt
				}
				/*
				 * If it doesn't begin with '.' and is a Unix path or it a
				 * windows path without backslashes, then we can be very
				 * efficient here. (In fact even a windows path with
				 * backslashes can be joined efficiently, but the path object
				 * would not have forward slashes only, and this would
				 * therefore contradict our 'file join' documentation).
				 */
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) != int32('.') && (XtclPlatform != int32(TCL_PLATFORM_WINDOWS) || libc.Xstrchr(tls, str, int32('\\')) == libc.UintptrFromInt32(0)) {
					/*
					 * Finally, on Windows, 'file join' is defined to convert
					 * all backslashes to forward slashes, so the base part
					 * cannot have backslashes either.
					 */
					if v6 = XtclPlatform != int32(TCL_PLATFORM_WINDOWS); !v6 {
						if (*TTcl_Obj)(unsafe.Pointer(elt)).Fbytes != 0 {
							v5 = (*TTcl_Obj)(unsafe.Pointer(elt)).Fbytes
						} else {
							v5 = XTcl_GetStringFromObj(tls, elt, libc.UintptrFromInt32(0))
						}
					}
					if v6 || libc.Xstrchr(tls, v5, int32('\\')) == libc.UintptrFromInt32(0) {
						if (*TTcl_Obj)(unsafe.Pointer(elt)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
							v7 = elt + 32
						} else {
							v7 = libc.UintptrFromInt32(0)
						}
						if (*TFsPath)(unsafe.Pointer((*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(v7))).Fptr1)).Fflags != 0 {
							return XTclNewFSPathObj(tls, elt, str, *(*TTcl_Size)(unsafe.Pointer(bp + 8)))
						}
						if int32(TCL_PATH_ABSOLUTE) != XTcl_FSGetPathType(tls, elt) {
							return XTclNewFSPathObj(tls, elt, str, *(*TTcl_Size)(unsafe.Pointer(bp + 8)))
						}
						XTcl_FSGetNormalizedPath(tls, libc.UintptrFromInt32(0), elt)
						if (*TTcl_Obj)(unsafe.Pointer(elt)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
							v8 = elt + 32
						} else {
							v8 = libc.UintptrFromInt32(0)
						}
						if elt == (*TFsPath)(unsafe.Pointer((*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(v8))).Fptr1)).FnormPathPtr {
							return XTclNewFSPathObj(tls, elt, str, *(*TTcl_Size)(unsafe.Pointer(bp + 8)))
						}
					}
				}
				/*
				 * Otherwise we don't have an easy join, and we must let the
				 * more general code below handle things.
				 */
			} else {
				if XtclPlatform == int32(TCL_PLATFORM_UNIX) {
					return tailObj
				} else {
					if (*TTcl_Obj)(unsafe.Pointer(tailObj)).Fbytes != 0 {
						v9 = (*TTcl_Obj)(unsafe.Pointer(tailObj)).Fbytes
					} else {
						v9 = XTcl_GetStringFromObj(tls, tailObj, libc.UintptrFromInt32(0))
					}
					str1 = v9
					if XtclPlatform == int32(TCL_PLATFORM_WINDOWS) {
						if libc.Xstrchr(tls, str1, int32('\\')) == libc.UintptrFromInt32(0) {
							return tailObj
						}
					}
				}
			}
		}
	}
	i = 0
	for {
		if !(i < elements) {
			break
		}
		*(*uintptr)(unsafe.Pointer(bp + 40)) = libc.UintptrFromInt32(0)
		elt1 = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
		if (*TTcl_Obj)(unsafe.Pointer(elt1)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = (*TTcl_Obj)(unsafe.Pointer(elt1)).Flength
			v11 = (*TTcl_Obj)(unsafe.Pointer(elt1)).Fbytes
		} else {
			v11 = XTcl_GetStringFromObj(tls, elt1, bp+24)
		}
		strElt = v11
		*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = 0
		/* if forceRelative - all paths excepting first one are relative */
		if forceRelative != 0 && i > 0 {
			v12 = int32(TCL_PATH_RELATIVE)
		} else {
			v12 = XTclGetPathType(tls, elt1, bp, bp+16, bp+40)
		}
		type11 = v12
		if type11 != int32(TCL_PATH_RELATIVE) {
			/*
			 * Zero out the current result.
			 */
			if res != libc.UintptrFromInt32(0) {
				v14 = res
				v13 = *(*TTcl_Size)(unsafe.Pointer(v14))
				*(*TTcl_Size)(unsafe.Pointer(v14))--
				if !(v13 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(res)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(res)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(res)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(res)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(res)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(res)).Flength = int64(-libc.Int32FromInt32(1))
						if v15 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v15 {
							cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v15 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, res)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(res + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = res
							(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, res)
					}
				}
			}
			if *(*uintptr)(unsafe.Pointer(bp + 40)) != libc.UintptrFromInt32(0) {
				/*
				 * We've been given a separate drive-name object, because the
				 * prefix in 'elt' is not in a suitable format for us (e.g. it
				 * may contain irrelevant multiple separators, like
				 * C://///foo).
				 */
				res = XTcl_DuplicateObj(tls, *(*uintptr)(unsafe.Pointer(bp + 40)))
				v17 = *(*uintptr)(unsafe.Pointer(bp + 40))
				v16 = *(*TTcl_Size)(unsafe.Pointer(v17))
				*(*TTcl_Size)(unsafe.Pointer(v17))--
				if !(v16 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).Flength = int64(-libc.Int32FromInt32(1))
						if v18 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v18 {
							cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v18 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 40)))
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp + 40))
							(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 40)))
					}
				}
				/*
				 * Do not set driveName to NULL, because we will check its
				 * value below (but we won't access the contents, since those
				 * have been cleaned-up).
				 */
			} else {
				res = XTcl_NewStringObj(tls, strElt, *(*TTcl_Size)(unsafe.Pointer(bp + 16)))
			}
			strElt += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 16)))
		} else {
			if *(*uintptr)(unsafe.Pointer(bp + 40)) != libc.UintptrFromInt32(0) {
				_objPtr = *(*uintptr)(unsafe.Pointer(bp + 40))
				v20 = _objPtr
				v19 = *(*TTcl_Size)(unsafe.Pointer(v20))
				*(*TTcl_Size)(unsafe.Pointer(v20))--
				if v19 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
		}
		/*
		 * Optimisation block: if this is the last element to be examined, and
		 * it is absolute or the only element, and the drive-prefix was ok (if
		 * there is one), it might be that the path is already in a suitable
		 * form to be returned. Then we can short-cut the rest of this
		 * function.
		 */
		if *(*uintptr)(unsafe.Pointer(bp + 40)) == libc.UintptrFromInt32(0) && i == elements-int64(1) && (type11 != int32(TCL_PATH_RELATIVE) || res == libc.UintptrFromInt32(0)) {
			/*
			 * It's the last path segment. Perform a quick check if the path
			 * is already in a suitable form.
			 */
			if XtclPlatform == int32(TCL_PLATFORM_WINDOWS) {
				if libc.Xstrchr(tls, strElt, int32('\\')) != libc.UintptrFromInt32(0) {
					goto noQuickReturn
				}
			}
			ptr = strElt
			/* [Bug f34cf83dd0] */
			if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) > 0 {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ptr))) == int32('/') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ptr + uintptr(-libc.Int32FromInt32(1))))) == int32('/') {
					goto noQuickReturn
				}
			}
			for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ptr))) != int32('\000') {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ptr))) == int32('/') && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ptr + 1))) == int32('/') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ptr + 1))) == int32('\000')) {
					/*
					 * We have a repeated file separator, which means the path
					 * is not in normalized form
					 */
					goto noQuickReturn
				}
				ptr++
			}
			if res != libc.UintptrFromInt32(0) {
				v22 = res
				v21 = *(*TTcl_Size)(unsafe.Pointer(v22))
				*(*TTcl_Size)(unsafe.Pointer(v22))--
				if !(v21 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(res)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(res)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(res)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(res)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(res)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(res)).Flength = int64(-libc.Int32FromInt32(1))
						if v23 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v23 {
							cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v23 || ((*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, res)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(res + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = res
							(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, res)
					}
				}
			}
			/*
			 * This element is just what we want to return already; no further
			 * manipulation is requred.
			 */
			return elt1
		}
		/*
		 * The path element was not of a suitable form to be returned as is.
		 * We need to perform a more complex operation here.
		 */
		goto noQuickReturn
	noQuickReturn:
		;
		if res == libc.UintptrFromInt32(0) {
			if v24 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v24 {
				cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v24 || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == libc.Uint64FromInt32(0) {
				res = XTclThreadAllocObj(tls)
			} else {
				res = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(res + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(res)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(res)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(res)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(res)).FtypePtr = libc.UintptrFromInt32(0)
		}
		if (*TTcl_Obj)(unsafe.Pointer(res)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = (*TTcl_Obj)(unsafe.Pointer(res)).Flength
			v25 = (*TTcl_Obj)(unsafe.Pointer(res)).Fbytes
		} else {
			v25 = XTcl_GetStringFromObj(tls, res, bp+32)
		}
		ptr = v25
		/*
		 * A NULL value for fsPtr at this stage basically means we're trying
		 * to join a relative path onto something which is also relative (or
		 * empty). There's nothing particularly wrong with that.
		 */
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(strElt))) == int32('\000') {
			goto _10
		}
		if *(*uintptr)(unsafe.Pointer(bp)) == uintptr(unsafe.Pointer(&XtclNativeFilesystem)) || *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
			XTclpNativeJoinPath(tls, res, strElt)
		} else {
			*(*uint8)(unsafe.Pointer(bp + 48)) = uint8('/')
			needsSep = 0
			if (*TTcl_Filesystem)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FfilesystemSeparatorProc != libc.UintptrFromInt32(0) {
				sep = (*(*func(*libc.TLS, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FfilesystemSeparatorProc})))(tls, res)
				if sep != libc.UintptrFromInt32(0) {
					if (*TTcl_Obj)(unsafe.Pointer(sep)).Fbytes != 0 {
						v26 = (*TTcl_Obj)(unsafe.Pointer(sep)).Fbytes
					} else {
						v26 = XTcl_GetStringFromObj(tls, sep, libc.UintptrFromInt32(0))
					}
					*(*uint8)(unsafe.Pointer(bp + 48)) = *(*uint8)(unsafe.Pointer(v26))
					v28 = sep
					v27 = *(*TTcl_Size)(unsafe.Pointer(v28))
					*(*TTcl_Size)(unsafe.Pointer(v28))--
					if !(v27 > int64(1)) {
						if !((*TTcl_Obj)(unsafe.Pointer(sep)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(sep)).FtypePtr)).FfreeIntRepProc != 0) {
							if (*TTcl_Obj)(unsafe.Pointer(sep)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(sep)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
								XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(sep)).Fbytes)
							}
							(*TTcl_Obj)(unsafe.Pointer(sep)).Flength = int64(-libc.Int32FromInt32(1))
							if v29 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v29 {
								cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
							}
							if v29 || ((*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
								XTclThreadFreeObj(tls, sep)
							} else {
								(*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer(sep + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
								(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = sep
								(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects++
							}
						} else {
							XTclFreeObj(tls, sep)
						}
					}
				}
				/* Safety check in case the VFS driver caused sharing */
				if (*TTcl_Obj)(unsafe.Pointer(res)).FrefCount > int64(1) {
					v31 = res
					v30 = *(*TTcl_Size)(unsafe.Pointer(v31))
					*(*TTcl_Size)(unsafe.Pointer(v31))--
					if !(v30 > int64(1)) {
						if !((*TTcl_Obj)(unsafe.Pointer(res)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(res)).FtypePtr)).FfreeIntRepProc != 0) {
							if (*TTcl_Obj)(unsafe.Pointer(res)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(res)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
								XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(res)).Fbytes)
							}
							(*TTcl_Obj)(unsafe.Pointer(res)).Flength = int64(-libc.Int32FromInt32(1))
							if v32 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v32 {
								cachePtr6 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
							}
							if v32 || ((*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
								XTclThreadFreeObj(tls, res)
							} else {
								(*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer(res + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr
								(*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr = res
								(*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects++
							}
						} else {
							XTclFreeObj(tls, res)
						}
					}
					res = XTcl_DuplicateObj(tls, res)
					(*TTcl_Obj)(unsafe.Pointer(res)).FrefCount++
				}
			}
			if *(*TTcl_Size)(unsafe.Pointer(bp + 32)) > 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ptr + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 32))-int64(1))))) != int32('/') {
				XTcl_AppendToObj(tls, res, bp+48, int64(1))
				if (*TTcl_Obj)(unsafe.Pointer(res)).Fbytes != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = (*TTcl_Obj)(unsafe.Pointer(res)).Flength
					_ = (*TTcl_Obj)(unsafe.Pointer(res)).Fbytes
				} else {
					XTcl_GetStringFromObj(tls, res, bp+32)
				}
			}
			XTcl_SetObjLength(tls, res, libc.Int64FromUint64(libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 32)))+libc.Xstrlen(tls, strElt)))
			if (*TTcl_Obj)(unsafe.Pointer(res)).Fbytes != 0 {
				v34 = (*TTcl_Obj)(unsafe.Pointer(res)).Fbytes
			} else {
				v34 = XTcl_GetStringFromObj(tls, res, libc.UintptrFromInt32(0))
			}
			ptr = v34 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 32)))
			for {
				if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(strElt))) != int32('\000')) {
					break
				}
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(strElt))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 48))) {
					for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(strElt + 1))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 48))) {
						strElt++
					}
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(strElt + 1))) != int32('\000') {
						if needsSep != 0 {
							v36 = ptr
							ptr++
							*(*uint8)(unsafe.Pointer(v36)) = *(*uint8)(unsafe.Pointer(bp + 48))
						}
					}
				} else {
					v37 = ptr
					ptr++
					*(*uint8)(unsafe.Pointer(v37)) = *(*uint8)(unsafe.Pointer(strElt))
					needsSep = int32(1)
				}
				goto _35
			_35:
				;
				strElt++
			}
			if (*TTcl_Obj)(unsafe.Pointer(res)).Fbytes != 0 {
				v38 = (*TTcl_Obj)(unsafe.Pointer(res)).Fbytes
			} else {
				v38 = XTcl_GetStringFromObj(tls, res, libc.UintptrFromInt32(0))
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = int64(ptr) - int64(v38)
			XTcl_SetObjLength(tls, res, *(*TTcl_Size)(unsafe.Pointer(bp + 32)))
		}
		goto _10
	_10:
		;
		i++
	}
	return res
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_FSConvertToPathType --
 *
 *	This function tries to convert the given Tcl_Obj to a valid Tcl path
 *	type, taking account of the fact that the cwd may have changed even if
 *	this object is already supposedly of the correct type.
 *
 *	The filename may begin with "~" (to indicate current user's home
 *	directory) or "~<user>" (to indicate any user's home directory).
 *
 * Results:
 *	Standard Tcl error code.
 *
 * Side effects:
 *	The old representation may be freed, and new memory allocated.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_FSConvertToPathType(tls *libc.TLS, interp uintptr, pathPtr uintptr) (r int32) {
	/* Object to convert to a valid, current path
	 * type. */
	var v1 uintptr
	_ = v1
	/*
	 * While it is bad practice to examine an object's type directly, this is
	 * actually the best thing to do here. The reason is that if we are
	 * converting this object to FsPath type for the first time, we don't need
	 * to worry whether the 'cwd' has changed. On the other hand, if this
	 * object is already of FsPath type, and is a relative path, we do have to
	 * worry about the cwd. If the cwd has changed, we must recompute the
	 * path.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
			v1 = pathPtr + 32
		} else {
			v1 = libc.UintptrFromInt32(0)
		}
		if XTclFSEpochOk(tls, (*TFsPath)(unsafe.Pointer((*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(v1))).Fptr1)).FfilesystemEpoch) != 0 {
			return TCL_OK
		}
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
			_ = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
		} else {
			XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
		}
		XTcl_StoreInternalRep(tls, pathPtr, uintptr(unsafe.Pointer(&_fsPathType)), libc.UintptrFromInt32(0))
	}
	return _SetFsPathFromAny(tls, interp, pathPtr)
}

/*
 * Helper function for normalization.
 */

func _IsSeparatorOrNull(tls *libc.TLS, ch int32) (r int32) {
	var v1, v2 int32
	_, _ = v1, v2
	if ch == 0 {
		return int32(1)
	}
	switch XtclPlatform {
	case int32(TCL_PLATFORM_UNIX):
		if ch == int32('/') {
			v1 = int32(1)
		} else {
			v1 = 0
		}
		return v1
	case int32(TCL_PLATFORM_WINDOWS):
		if ch == int32('/') || ch == int32('\\') {
			v2 = int32(1)
		} else {
			v2 = 0
		}
		return v2
	}
	return 0
}

/*
 * Helper function for SetFsPathFromAny. Returns position of first directory
 * delimiter in the path. If no separator is found, then returns the position
 * of the end of the string.
 */

func _FindSplitPos(tls *libc.TLS, path uintptr, separator int32) (r TTcl_Size) {
	var count int32
	_ = count
	count = 0
	switch XtclPlatform {
	case int32(TCL_PLATFORM_UNIX):
		goto _1
	case int32(TCL_PLATFORM_WINDOWS):
		goto _2
	}
	goto _3
_1:
	;
_5:
	;
	if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(count)))) != 0) {
		goto _4
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(count)))) == separator {
		return int64(count)
	}
	count++
	goto _5
_4:
	;
	goto _3
_2:
	;
	for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(count)))) != 0 {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(count)))) == separator || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(count)))) == int32('\\') {
			return int64(count)
		}
		count++
	}
	goto _3
_3:
	;
	return int64(count)
}

/*
 *---------------------------------------------------------------------------
 *
 * TclNewFSPathObj --
 *
 *	Creates a path object whose string representation is '[file join
 *	dirPtr addStrRep]', but does so in a way that allows for more
 *	efficient creation and caching of normalized paths, and more efficient
 *	'file dirname', 'file tail', etc.
 *
 * Assumptions:
 *	'dirPtr' must be an absolute path. 'len' may not be zero.
 *
 * Results:
 *	The new Tcl object, with refCount zero.
 *
 * Side effects:
 *	Memory is allocated. 'dirPtr' gets an additional refCount.
 *
 *---------------------------------------------------------------------------
 */

func XTclNewFSPathObj(tls *libc.TLS, dirPtr uintptr, addStrRep uintptr, len1 TTcl_Size) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _isobjPtr, cachePtr, fsPathPtr, p, pathPtr, v2, v4, v5 uintptr
	var count, state int32
	var v1 bool
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_, _, _, _, _, _, _, _, _, _, _ = _isobjPtr, cachePtr, count, fsPathPtr, p, pathPtr, state, v1, v2, v4, v5
	state = 0
	count = 0
	/*
	 * This comment is kept from the days of tilde expansion because
	 * it is illustrative of a more general problem.
	 * [Bug 2806250] - this is only a partial solution of the problem.
	 * The PATHFLAGS != 0 representation assumes in many places that
	 * the "tail" part stored in the normPathPtr field is itself a
	 * relative path.  Strings that begin with "~" are not relative paths,
	 * so we must prevent their storage in the normPathPtr field.
	 *
	 * More generally we ought to be testing "addStrRep" for any value
	 * that is not a relative path, but in an unconstrained VFS world
	 * that could be just about anything, and testing could be expensive.
	 * Since this routine plays a big role in [glob], anything that slows
	 * it down would be unwelcome.  For now, continue the risk of further
	 * bugs when some Tcl_Filesystem uses otherwise relative path strings
	 * as absolute path strings.  Sensible Tcl_Filesystems will avoid
	 * that by mounting on path prefixes like foo:// which cannot be the
	 * name of a file or directory read from a native [glob] operation.
	 */
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		pathPtr = XTclThreadAllocObj(tls)
	} else {
		pathPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(pathPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(pathPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(pathPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr = libc.UintptrFromInt32(0)
	fsPathPtr = XTcl_Alloc(tls, uint64(56))
	/*
	 * Set up the path.
	 */
	(*TFsPath)(unsafe.Pointer(fsPathPtr)).FtranslatedPathPtr = libc.UintptrFromInt32(0)
	(*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr = XTcl_NewStringObj(tls, addStrRep, len1)
	(*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).FrefCount++
	(*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr = dirPtr
	(*TTcl_Obj)(unsafe.Pointer(dirPtr)).FrefCount++
	(*TFsPath)(unsafe.Pointer(fsPathPtr)).FnativePathPtr = libc.UintptrFromInt32(0)
	(*TFsPath)(unsafe.Pointer(fsPathPtr)).FfsPtr = libc.UintptrFromInt32(0)
	(*TFsPath)(unsafe.Pointer(fsPathPtr)).FfilesystemEpoch = uint64(0)
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr1 = fsPathPtr
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr2 = libc.UintptrFromInt32(0)
	XTcl_StoreInternalRep(tls, pathPtr, uintptr(unsafe.Pointer(&_fsPathType)), bp)
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
		v2 = pathPtr + 32
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	(*TFsPath)(unsafe.Pointer((*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(v2))).Fptr1)).Fflags = int32(TCLPATH_APPENDED)
	_isobjPtr = pathPtr
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
	/*
	 * Look for path components made up of only "."
	 * This is overly conservative analysis to keep simple. It may mark some
	 * things as needing more aggressive normalization that don't actually
	 * need it. No harm done.
	 */
	p = addStrRep
	for {
		if !(len1 > 0) {
			break
		}
		switch state {
		case 0: /* So far only "." since last dirsep or start */
			switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) {
			case int32('.'):
				count = int32(1)
			case int32('/'):
				fallthrough
			case int32('\\'):
				fallthrough
			case int32(':'):
				if count != 0 {
					if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
						v4 = pathPtr + 32
					} else {
						v4 = libc.UintptrFromInt32(0)
					}
					*(*int32)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(v4))).Fptr1 + 24)) |= int32(TCLPATH_NEEDNORM)
					len1 = 0
				}
			default:
				count = 0
				state = int32(1)
			}
		case int32(1): /* Scanning for next dirsep */
			switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) {
			case int32('/'):
				fallthrough
			case int32('\\'):
				fallthrough
			case int32(':'):
				state = 0
				break
			}
		}
		goto _3
	_3:
		;
		p++
		len1--
	}
	if len1 == 0 && count != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
			v5 = pathPtr + 32
		} else {
			v5 = libc.UintptrFromInt32(0)
		}
		*(*int32)(unsafe.Pointer((*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(v5))).Fptr1 + 24)) |= int32(TCLPATH_NEEDNORM)
	}
	return pathPtr
}

func _AppendPath(tls *libc.TLS, head uintptr, tail uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var bytes, copy1, v1 uintptr
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _ = bytes, copy1, v1
	copy1 = XTcl_DuplicateObj(tls, head)
	/*
	 * This is likely buggy when dealing with virtual filesystem drivers
	 * that use some character other than "/" as a path separator.  I know
	 * of no evidence that such a foolish thing exists.  This solution was
	 * chosen so that "JoinPath" operations that pass through either path
	 * internalrep produce the same results; that is, bugward compatibility.  If
	 * we need to fix that bug here, it needs fixing in TclJoinPath() too.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(tail)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(tail)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(tail)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, tail, bp)
	}
	bytes = v1
	if *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
		XTcl_AppendToObj(tls, copy1, __ccgo_ts+6339, int64(1))
	} else {
		XTclpNativeJoinPath(tls, copy1, bytes)
	}
	return copy1
}

/*
 *---------------------------------------------------------------------------
 *
 * TclFSMakePathRelative --
 *
 *	Only for internal use.
 *
 *	Takes a path and a directory, where we _assume_ both path and
 *	directory are absolute, normalized and that the path lies inside the
 *	directory. Returns a Tcl_Obj representing filename of the path
 *	relative to the directory.
 *
 * Results:
 *	NULL on error, otherwise a valid object, typically with refCount of
 *	zero, which it is assumed the caller will increment.
 *
 * Side effects:
 *	The old representation may be freed, and new memory allocated.
 *
 *---------------------------------------------------------------------------
 */

func XTclFSMakePathRelative(tls *libc.TLS, dummy1388 uintptr, pathPtr uintptr, cwdPtr uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Make it relative to this. */
	var fsPathPtr, irPtr, tempStr, v1, v2, v3, v4, v5 uintptr
	var _ /* cwdLen at bp+0 */ TTcl_Size
	var _ /* len at bp+8 */ TTcl_Size
	_, _, _, _, _, _, _, _ = fsPathPtr, irPtr, tempStr, v1, v2, v3, v4, v5
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
		v1 = pathPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
			v2 = pathPtr + 32
		} else {
			v2 = libc.UintptrFromInt32(0)
		}
		fsPathPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(v2))).Fptr1
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
			v3 = pathPtr + 32
		} else {
			v3 = libc.UintptrFromInt32(0)
		}
		if (*TFsPath)(unsafe.Pointer((*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(v3))).Fptr1)).Fflags != 0 && (*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr == cwdPtr {
			return (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr
		}
	}
	/*
	 * We know the cwd is a normalised object which does not end in a
	 * directory delimiter, unless the cwd is the name of a volume, in which
	 * case it will end in a delimiter! We handle this situation here. A
	 * better test than the '!= sep' might be to simply check if 'cwd' is a
	 * root volume.
	 *
	 * Note that if we get this wrong, we will strip off either too much or
	 * too little below, leading to wrong answers returned by glob.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(cwdPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(cwdPtr)).Flength
		v4 = (*TTcl_Obj)(unsafe.Pointer(cwdPtr)).Fbytes
	} else {
		v4 = XTcl_GetStringFromObj(tls, cwdPtr, bp)
	}
	tempStr = v4
	/*
	 * Should we perhaps use 'Tcl_FSPathSeparator'? But then what about the
	 * Windows special case? Perhaps we should just check if cwd is a root
	 * volume.
	 */
	switch XtclPlatform {
	case int32(TCL_PLATFORM_UNIX):
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(tempStr + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp))-int64(1))))) != int32('/') {
			*(*TTcl_Size)(unsafe.Pointer(bp))++
		}
	case int32(TCL_PLATFORM_WINDOWS):
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(tempStr + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp))-int64(1))))) != int32('/') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(tempStr + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp))-int64(1))))) != int32('\\') {
			*(*TTcl_Size)(unsafe.Pointer(bp))++
		}
		break
	}
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Flength
		v5 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
	} else {
		v5 = XTcl_GetStringFromObj(tls, pathPtr, bp+8)
	}
	tempStr = v5
	return XTcl_NewStringObj(tls, tempStr+uintptr(*(*TTcl_Size)(unsafe.Pointer(bp))), *(*TTcl_Size)(unsafe.Pointer(bp + 8))-*(*TTcl_Size)(unsafe.Pointer(bp)))
}

/*
 *---------------------------------------------------------------------------
 *
 * MakePathFromNormalized --
 *
 *	Like SetFsPathFromAny, but assumes the given object is an absolute
 *	normalized path. Only for internal use.
 *
 * Results:
 *	Standard Tcl error code.
 *
 * Side effects:
 *	The old representation may be freed, and new memory allocated.
 *
 *---------------------------------------------------------------------------
 */

func _MakePathFromNormalized(tls *libc.TLS, dummy1459 uintptr, pathPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The object to convert. */
	var fsPathPtr, v1, v2 uintptr
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_, _, _ = fsPathPtr, v1, v2
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
		return TCL_OK
	}
	fsPathPtr = XTcl_Alloc(tls, uint64(56))
	/*
	 * It's a pure normalized absolute path.
	 */
	(*TFsPath)(unsafe.Pointer(fsPathPtr)).FtranslatedPathPtr = libc.UintptrFromInt32(0)
	v1 = XTcl_DuplicateObj(tls, pathPtr)
	(*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr = v1
	(*TTcl_Obj)(unsafe.Pointer(v1)).FrefCount++
	(*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr = libc.UintptrFromInt32(0)
	(*TFsPath)(unsafe.Pointer(fsPathPtr)).FnativePathPtr = libc.UintptrFromInt32(0)
	(*TFsPath)(unsafe.Pointer(fsPathPtr)).FfsPtr = libc.UintptrFromInt32(0)
	/* Remember the epoch under which we decided pathPtr was normalized */
	(*TFsPath)(unsafe.Pointer(fsPathPtr)).FfilesystemEpoch = XTclFSEpoch(tls)
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr1 = fsPathPtr
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr2 = libc.UintptrFromInt32(0)
	XTcl_StoreInternalRep(tls, pathPtr, uintptr(unsafe.Pointer(&_fsPathType)), bp)
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
		v2 = pathPtr + 32
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	(*TFsPath)(unsafe.Pointer((*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(v2))).Fptr1)).Fflags = 0
	return TCL_OK
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_FSNewNativePath --
 *
 *	Performs the something like the reverse of the usual
 *	obj->path->nativerep conversions. If some code retrieves a path in
 *	native form (from, e.g. readlink or a native dialog), and that path is
 *	to be used at the Tcl level, then calling this function is an
 *	efficient way of creating the appropriate path object type.
 *
 *	Any memory which is allocated for 'clientData' should be retained
 *	until clientData is passed to the filesystem's freeInternalRepProc
 *	when it can be freed. The built in platform-specific filesystems use
 *	'Tcl_Alloc' to allocate clientData, and Tcl_Free to free it.
 *
 * Results:
 *	NULL or a valid path object pointer, with refCount zero.
 *
 * Side effects:
 *	New memory may be allocated.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_FSNewNativePath(tls *libc.TLS, fromFilesystem uintptr, clientData uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var fsPathPtr, pathPtr, v1, v2 uintptr
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_, _, _, _ = fsPathPtr, pathPtr, v1, v2
	pathPtr = libc.UintptrFromInt32(0)
	if (*TTcl_Filesystem)(unsafe.Pointer(fromFilesystem)).FinternalToNormalizedProc != libc.UintptrFromInt32(0) {
		pathPtr = (*(*func(*libc.TLS, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_Filesystem)(unsafe.Pointer(fromFilesystem)).FinternalToNormalizedProc})))(tls, clientData)
	}
	if pathPtr == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	/*
	 * Free old representation; shouldn't normally be any, but best to be
	 * safe.
	 */
	XTcl_StoreInternalRep(tls, pathPtr, uintptr(unsafe.Pointer(&_fsPathType)), libc.UintptrFromInt32(0))
	fsPathPtr = XTcl_Alloc(tls, uint64(56))
	(*TFsPath)(unsafe.Pointer(fsPathPtr)).FtranslatedPathPtr = libc.UintptrFromInt32(0)
	v1 = XTcl_DuplicateObj(tls, pathPtr)
	(*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr = v1
	(*TTcl_Obj)(unsafe.Pointer(v1)).FrefCount++
	(*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr = libc.UintptrFromInt32(0)
	(*TFsPath)(unsafe.Pointer(fsPathPtr)).FnativePathPtr = clientData
	(*TFsPath)(unsafe.Pointer(fsPathPtr)).FfsPtr = fromFilesystem
	(*TFsPath)(unsafe.Pointer(fsPathPtr)).FfilesystemEpoch = XTclFSEpoch(tls)
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr1 = fsPathPtr
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr2 = libc.UintptrFromInt32(0)
	XTcl_StoreInternalRep(tls, pathPtr, uintptr(unsafe.Pointer(&_fsPathType)), bp)
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
		v2 = pathPtr + 32
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	(*TFsPath)(unsafe.Pointer((*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(v2))).Fptr1)).Fflags = 0
	return pathPtr
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_FSGetTranslatedPath --
 *
 *	Attempts to extract the translated path from the given
 *	Tcl_Obj. If the translation succeeds (i.e. the object is a valid
 *	path), then it is returned. Otherwise NULL is returned and an
 *	error message may be left in the interpreter if it is not NULL.
 *
 * Results:
 *	A Tcl_Obj pointer or NULL.
 *
 * Side effects:
 *	pathPtr is converted to fsPathType if necessary.
 *
 *	FsPath members are modified as needed.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_FSGetTranslatedPath(tls *libc.TLS, interp uintptr, pathPtr uintptr) (r uintptr) {
	var _objPtr, retObj, srcFsPathPtr, translatedCwdIrPtr, translatedCwdPtr, v1, v2, v3, v4, v5, v7 uintptr
	var v6 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, retObj, srcFsPathPtr, translatedCwdIrPtr, translatedCwdPtr, v1, v2, v3, v4, v5, v6, v7
	retObj = libc.UintptrFromInt32(0)
	if XTcl_FSConvertToPathType(tls, interp, pathPtr) != TCL_OK {
		return libc.UintptrFromInt32(0)
	}
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
		v1 = pathPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	srcFsPathPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(v1))).Fptr1
	if (*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FtranslatedPathPtr == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
			v2 = pathPtr + 32
		} else {
			v2 = libc.UintptrFromInt32(0)
		}
		if (*TFsPath)(unsafe.Pointer((*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(v2))).Fptr1)).Fflags == 0 {
			/*
			 * Path is already normalized
			 */
			retObj = (*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FnormPathPtr
		} else {
			/*
			 * We lack a translated path result, but we have a directory
			 * (cwdPtr) and a tail (normPathPtr), and if we join the
			 * translated version of cwdPtr to normPathPtr, we'll get the
			 * translated result we need, and can store it for future use.
			 */
			translatedCwdPtr = XTcl_FSGetTranslatedPath(tls, interp, (*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FcwdPtr)
			if translatedCwdPtr == libc.UintptrFromInt32(0) {
				return libc.UintptrFromInt32(0)
			}
			retObj = XTcl_FSJoinToPath(tls, translatedCwdPtr, int64(1), srcFsPathPtr+8)
			v3 = retObj
			(*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FtranslatedPathPtr = v3
			(*TTcl_Obj)(unsafe.Pointer(v3)).FrefCount++
			if (*TTcl_Obj)(unsafe.Pointer(translatedCwdPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
				v4 = translatedCwdPtr + 32
			} else {
				v4 = libc.UintptrFromInt32(0)
			}
			translatedCwdIrPtr = v4
			if translatedCwdIrPtr != 0 {
				if (*TTcl_Obj)(unsafe.Pointer(translatedCwdPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
					v5 = translatedCwdPtr + 32
				} else {
					v5 = libc.UintptrFromInt32(0)
				}
				(*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FfilesystemEpoch = (*TFsPath)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(v5))).Fptr1)).FfilesystemEpoch
			} else {
				(*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FfilesystemEpoch = uint64(0)
			}
			_objPtr = translatedCwdPtr
			v7 = _objPtr
			v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
			*(*TTcl_Size)(unsafe.Pointer(v7))--
			if v6 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
	} else {
		/*
		 * It is an ordinary path object.
		 */
		retObj = (*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FtranslatedPathPtr
	}
	if retObj != libc.UintptrFromInt32(0) {
		(*TTcl_Obj)(unsafe.Pointer(retObj)).FrefCount++
	}
	return retObj
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_FSGetTranslatedStringPath --
 *
 *	This function attempts to extract the translated path from the given
 *	Tcl_Obj. If the translation succeeds (i.e. the object is a valid
 *	path), then the path is returned. Otherwise NULL will be returned, and
 *	an error message may be left in the interpreter (if it is non-NULL)
 *
 * Results:
 *	NULL or a valid string.
 *
 * Side effects:
 *	Only those of 'Tcl_FSConvertToPathType'
 *
 *---------------------------------------------------------------------------
 */

func XTcl_FSGetTranslatedStringPath(tls *libc.TLS, interp uintptr, pathPtr uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var cachePtr, orig, result, transPtr, v1, v3 uintptr
	var v2 TTcl_Size
	var v4 bool
	var _ /* len at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _ = cachePtr, orig, result, transPtr, v1, v2, v3, v4
	transPtr = XTcl_FSGetTranslatedPath(tls, interp, pathPtr)
	if transPtr != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(transPtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(transPtr)).Flength
			v1 = (*TTcl_Obj)(unsafe.Pointer(transPtr)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, transPtr, bp)
		}
		orig = v1
		result = XTcl_Alloc(tls, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))+int64(1)))
		libc.Xmemcpy(tls, result, orig, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))+int64(1)))
		v3 = transPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if !(v2 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(transPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(transPtr)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(transPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(transPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(transPtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(transPtr)).Flength = int64(-libc.Int32FromInt32(1))
				if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v4 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, transPtr)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(transPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = transPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, transPtr)
			}
		}
		return result
	}
	return libc.UintptrFromInt32(0)
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_FSGetNormalizedPath --
 *
 *	This important function attempts to extract from the given Tcl_Obj a
 *	unique normalised path representation, whose string value can be used
 *	as a unique identifier for the file.
 *
 * Results:
 *	NULL or a valid path object pointer.
 *
 * Side effects:
 *	New memory may be allocated. The Tcl 'errno' may be modified in the
 *	process of trying to examine various path possibilities.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_FSGetNormalizedPath(tls *libc.TLS, interp uintptr, pathPtr uintptr) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _objPtr, _objPtr1, _objPtr2, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, copy1, copy11, dir, fsPathPtr, newCopy, origDir, origDirFsPathPtr, path, useThisCwd, v1, v11, v14, v17, v2, v20, v23, v26, v28, v30, v32, v33, v35, v37, v39, v6, v8, v9 uintptr
	var pathType int32
	var type1 TTcl_PathType
	var v10, v13, v16, v19, v22, v25, v34, v36, v38, v7 TTcl_Size
	var v12, v15, v18, v21, v24, v27, v40 bool
	var _ /* absolutePath at bp+24 */ uintptr
	var _ /* cwdLen at bp+16 */ TTcl_Size
	var _ /* cwdLen at bp+8 */ TTcl_Size
	var _ /* tailLen at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, copy1, copy11, dir, fsPathPtr, newCopy, origDir, origDirFsPathPtr, path, pathType, type1, useThisCwd, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v30, v32, v33, v34, v35, v36, v37, v38, v39, v40, v6, v7, v8, v9
	if XTcl_FSConvertToPathType(tls, interp, pathPtr) != TCL_OK {
		return libc.UintptrFromInt32(0)
	}
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
		v1 = pathPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	fsPathPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(v1))).Fptr1
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
		v2 = pathPtr + 32
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	if (*TFsPath)(unsafe.Pointer((*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(v2))).Fptr1)).Fflags != 0 {
		pathType = XTcl_FSGetPathType(tls, (*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr)
		dir = XTcl_FSGetNormalizedPath(tls, interp, (*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr)
		if dir == libc.UintptrFromInt32(0) {
			return libc.UintptrFromInt32(0)
		}
		/* TODO: Figure out why this is needed. */
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
			_ = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
		} else {
			XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
		}
		if (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).Flength
			_ = (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).Fbytes
		} else {
			XTcl_GetStringFromObj(tls, (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr, bp)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp)) != 0 {
			copy1 = _AppendPath(tls, dir, (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)
		} else {
			copy1 = XTcl_DuplicateObj(tls, dir)
		}
		(*TTcl_Obj)(unsafe.Pointer(dir)).FrefCount++
		(*TTcl_Obj)(unsafe.Pointer(copy1)).FrefCount++
		/*
		 * We now own a reference on both 'dir' and 'copy'
		 */
		if (*TTcl_Obj)(unsafe.Pointer(dir)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(dir)).Flength
			_ = (*TTcl_Obj)(unsafe.Pointer(dir)).Fbytes
		} else {
			XTcl_GetStringFromObj(tls, dir, bp+8)
		}
		/* Normalize the combined string. */
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
			v6 = pathPtr + 32
		} else {
			v6 = libc.UintptrFromInt32(0)
		}
		if (*TFsPath)(unsafe.Pointer((*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(v6))).Fptr1)).Fflags&int32(TCLPATH_NEEDNORM) != 0 {
			/*
			 * If the "tail" part has components (like /../) that cause the
			 * combined path to need more complete normalizing, call on the
			 * more powerful routine to accomplish that so we avoid [Bug
			 * 2385549] ...
			 */
			newCopy = XTclFSNormalizeAbsolutePath(tls, interp, copy1)
			_objPtr = copy1
			v8 = _objPtr
			v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
			*(*TTcl_Size)(unsafe.Pointer(v8))--
			if v7 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			copy1 = newCopy
		} else {
			/*
			 * ... but in most cases where we join a trouble free tail to a
			 * normalized head, we can more efficiently normalize the combined
			 * path by passing over only the unnormalized tail portion. When
			 * this is sufficient, prior developers claim this should be much
			 * faster. We use 'cwdLen' so that we are already pointing at
			 * the dir-separator that we know about. The normalization code
			 * will actually start off directly after that separator.
			 */
			XTclFSNormalizeToUniquePath(tls, interp, copy1, int32(*(*TTcl_Size)(unsafe.Pointer(bp + 8))))
		}
		/* Now we need to construct the new path object. */
		if pathType == int32(TCL_PATH_RELATIVE) {
			origDir = (*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr
			if (*TTcl_Obj)(unsafe.Pointer(origDir)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
				v9 = origDir + 32
			} else {
				v9 = libc.UintptrFromInt32(0)
			}
			/*
			 * NOTE: here we are (dangerously?) assuming that origDir points
			 * to a Tcl_Obj with Tcl_ObjType == &fsPathType. The
			 *     pathType = Tcl_FSGetPathType(fsPathPtr->cwdPtr);
			 * above that set the pathType value should have established that,
			 * but it's far less clear on what basis we know there's been no
			 * shimmering since then.
			 */
			origDirFsPathPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(v9))).Fptr1
			(*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr = (*TFsPath)(unsafe.Pointer(origDirFsPathPtr)).FcwdPtr
			(*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr)).FrefCount++
			v11 = (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr
			v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
			*(*TTcl_Size)(unsafe.Pointer(v11))--
			if !(v10 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).Flength = int64(-libc.Int32FromInt32(1))
					if v12 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v12 {
						cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v12 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)
				}
			}
			(*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr = copy1
			v14 = dir
			v13 = *(*TTcl_Size)(unsafe.Pointer(v14))
			*(*TTcl_Size)(unsafe.Pointer(v14))--
			if !(v13 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(dir)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dir)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(dir)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(dir)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(dir)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(dir)).Flength = int64(-libc.Int32FromInt32(1))
					if v15 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v15 {
						cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v15 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, dir)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(dir + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = dir
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, dir)
				}
			}
			v17 = origDir
			v16 = *(*TTcl_Size)(unsafe.Pointer(v17))
			*(*TTcl_Size)(unsafe.Pointer(v17))--
			if !(v16 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(origDir)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(origDir)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(origDir)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(origDir)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(origDir)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(origDir)).Flength = int64(-libc.Int32FromInt32(1))
					if v18 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v18 {
						cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v18 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, origDir)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(origDir + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = origDir
						(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, origDir)
				}
			}
		} else {
			v20 = (*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr
			v19 = *(*TTcl_Size)(unsafe.Pointer(v20))
			*(*TTcl_Size)(unsafe.Pointer(v20))--
			if !(v19 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr)).Flength = int64(-libc.Int32FromInt32(1))
					if v21 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v21 {
						cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v21 || ((*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, (*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, (*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr)
				}
			}
			(*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr = libc.UintptrFromInt32(0)
			v23 = (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr
			v22 = *(*TTcl_Size)(unsafe.Pointer(v23))
			*(*TTcl_Size)(unsafe.Pointer(v23))--
			if !(v22 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).Flength = int64(-libc.Int32FromInt32(1))
					if v24 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v24 {
						cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v24 || ((*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)
				}
			}
			(*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr = copy1
			v26 = dir
			v25 = *(*TTcl_Size)(unsafe.Pointer(v26))
			*(*TTcl_Size)(unsafe.Pointer(v26))--
			if !(v25 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(dir)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(dir)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(dir)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(dir)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(dir)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(dir)).Flength = int64(-libc.Int32FromInt32(1))
					if v27 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v27 {
						cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v27 || ((*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, dir)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(dir + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = dir
						(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, dir)
				}
			}
		}
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
			v28 = pathPtr + 32
		} else {
			v28 = libc.UintptrFromInt32(0)
		}
		(*TFsPath)(unsafe.Pointer((*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(v28))).Fptr1)).Fflags = 0
	}
	/*
	 * Ensure cwd hasn't changed.
	 */
	if (*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr != libc.UintptrFromInt32(0) {
		if !(XTclFSCwdPointerEquals(tls, fsPathPtr+16) != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
				_ = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
			} else {
				XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
			}
			XTcl_StoreInternalRep(tls, pathPtr, uintptr(unsafe.Pointer(&_fsPathType)), libc.UintptrFromInt32(0))
			if _SetFsPathFromAny(tls, interp, pathPtr) != TCL_OK {
				return libc.UintptrFromInt32(0)
			}
			if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
				v30 = pathPtr + 32
			} else {
				v30 = libc.UintptrFromInt32(0)
			}
			fsPathPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(v30))).Fptr1
		} else {
			if (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr == libc.UintptrFromInt32(0) {
				copy11 = _AppendPath(tls, (*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr, pathPtr)
				if (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr)).Fbytes != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr)).Flength
					_ = (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr)).Fbytes
				} else {
					XTcl_GetStringFromObj(tls, (*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr, bp+16)
				}
				if (*TTcl_Obj)(unsafe.Pointer(copy11)).Fbytes != 0 {
					v32 = (*TTcl_Obj)(unsafe.Pointer(copy11)).Fbytes
				} else {
					v32 = XTcl_GetStringFromObj(tls, copy11, libc.UintptrFromInt32(0))
				}
				*(*TTcl_Size)(unsafe.Pointer(bp + 16)) += libc.BoolInt64(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v32 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 16)))))) == libc.Int32FromUint8('/'))
				/*
				 * Normalize the combined string, but only starting after the end
				 * of the previously normalized 'dir'. This should be much faster!
				 */
				XTclFSNormalizeToUniquePath(tls, interp, copy11, int32(*(*TTcl_Size)(unsafe.Pointer(bp + 16))-int64(1)))
				(*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr = copy11
				(*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).FrefCount++
			}
		}
	}
	if (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr == libc.UintptrFromInt32(0) {
		useThisCwd = libc.UintptrFromInt32(0)
		/*
		 * Since normPathPtr is NULL but this is a valid path object, we know
		 * that the translatedPathPtr cannot be NULL.
		 */
		*(*uintptr)(unsafe.Pointer(bp + 24)) = (*TFsPath)(unsafe.Pointer(fsPathPtr)).FtranslatedPathPtr
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Fbytes != 0 {
			v33 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Fbytes
		} else {
			v33 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 24)), libc.UintptrFromInt32(0))
		}
		path = v33
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).FrefCount++
		/*
		 * We have to be a little bit careful here to avoid infinite loops
		 * we're asking Tcl_FSGetPathType to return the path's type, but that
		 * call can actually result in a lot of other filesystem action, which
		 * might loop back through here.
		 */
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('\000') {
			/*
			 * Special handling for the empty string value. This one is very
			 * weird with [file normalize {}] => {}. (The reasoning supporting
			 * this is unknown to DGP, but he fears changing it.) Attempt here
			 * to keep the expectations of other parts of Tcl_Filesystem code
			 * about state of the FsPath fields satisfied.
			 *
			 * In particular, capture the cwd value and save so it can be
			 * stored in the cwdPtr field below.
			 */
			useThisCwd = XTcl_FSGetCwd(tls, interp)
		} else {
			/*
			 * We don't ask for the type of 'pathPtr' here, because that is
			 * not correct for our purposes when we have a path like '~'. Tcl
			 * has a bit of a contradiction in that '~' paths are defined as
			 * 'absolute', but in reality can be just about anything,
			 * depending on how env(HOME) is set.
			 */
			type1 = XTcl_FSGetPathType(tls, *(*uintptr)(unsafe.Pointer(bp + 24)))
			if type1 == int32(TCL_PATH_RELATIVE) {
				useThisCwd = XTcl_FSGetCwd(tls, interp)
				if useThisCwd == libc.UintptrFromInt32(0) {
					return libc.UintptrFromInt32(0)
				}
				_objPtr1 = *(*uintptr)(unsafe.Pointer(bp + 24))
				v35 = _objPtr1
				v34 = *(*TTcl_Size)(unsafe.Pointer(v35))
				*(*TTcl_Size)(unsafe.Pointer(v35))--
				if v34 <= int64(1) {
					XTclFreeObj(tls, _objPtr1)
				}
				*(*uintptr)(unsafe.Pointer(bp + 24)) = XTcl_FSJoinToPath(tls, useThisCwd, int64(1), bp+24)
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).FrefCount++
				/*
				 * We have a refCount on the cwd.
				 */
			}
		}
		/*
		 * Already has refCount incremented.
		 */
		if (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr != 0 {
			_objPtr2 = (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr
			v37 = _objPtr2
			v36 = *(*TTcl_Size)(unsafe.Pointer(v37))
			*(*TTcl_Size)(unsafe.Pointer(v37))--
			if v36 <= int64(1) {
				XTclFreeObj(tls, _objPtr2)
			}
		}
		(*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr = XTclFSNormalizeAbsolutePath(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 24)))
		if useThisCwd != libc.UintptrFromInt32(0) {
			/*
			 * We just need to free an object we allocated above for relative
			 * paths (this was returned by Tcl_FSJoinToPath above), and then
			 * of course store the cwd.
			 */
			(*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr = useThisCwd
		}
		v39 = *(*uintptr)(unsafe.Pointer(bp + 24))
		v38 = *(*TTcl_Size)(unsafe.Pointer(v39))
		*(*TTcl_Size)(unsafe.Pointer(v39))--
		if !(v38 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Flength = int64(-libc.Int32FromInt32(1))
				if v40 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v40 {
					cachePtr6 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v40 || ((*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 24)))
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp + 24))
					(*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp + 24)))
			}
		}
	}
	return (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_FSGetInternalRep --
 *
 *	Produces a native representation of a given path object in the given
 *	filesystem.
 *
 *	In the future it might be desirable to have separate versions
 *	of this function with different signatures, for example
 *	Tcl_FSGetNativeWinPath, Tcl_FSGetNativeUnixPath etc. Right now, since
 *	native paths are all string based, we use just one function.
 *
 * Results:
 *
 *	The native handle for the path, or NULL if the path is not handled by
 *	the given filesystem
 *
 * Side effects:
 *
 *	Tcl_FSCreateInternalRepProc if needed to produce the native
 *	handle, which is then stored in the internal representation of pathPtr.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_FSGetInternalRep(tls *libc.TLS, pathPtr uintptr, fsPtr uintptr) (r uintptr) {
	var actualFs, nativePathPtr, proc, srcFsPathPtr, v1, v2, v3 uintptr
	_, _, _, _, _, _, _ = actualFs, nativePathPtr, proc, srcFsPathPtr, v1, v2, v3
	if XTcl_FSConvertToPathType(tls, libc.UintptrFromInt32(0), pathPtr) != TCL_OK {
		return libc.UintptrFromInt32(0)
	}
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
		v1 = pathPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	srcFsPathPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(v1))).Fptr1
	/*
	 * Currently there must be a unique bi-directional mapping between a path
	 * and a filesystem, and therefore there is no way to "remap" a file, i.e.,
	 * to map a file in one filesystem into another. Another way of putting
	 * this is that 'stacked' filesystems are not allowed.  It could be useful
	 * in the future to redesign the system to allow that.
	 *
	 * Even something simple like a 'pass through' filesystem which logs all
	 * activity and passes the calls onto the native system would be nice, but
	 * not currently easily achievable.
	 */
	if (*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FfsPtr == libc.UintptrFromInt32(0) {
		XTcl_FSGetFileSystemForPath(tls, pathPtr)
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
			v2 = pathPtr + 32
		} else {
			v2 = libc.UintptrFromInt32(0)
		}
		srcFsPathPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(v2))).Fptr1
		if (*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FfsPtr == libc.UintptrFromInt32(0) {
			/*
			 * The path is probably not a valid path in the filesystsem, and is
			 * most likely to be a use of the empty path "" via a direct call
			 * to one of the objectified interfaces (e.g. from the Tcl
			 * testsuite).
			 */
			return libc.UintptrFromInt32(0)
		}
	}
	/*
	 * If the file belongs to a different filesystem, perhaps it is actually
	 * linked through to a file in the given filesystem. Check this by
	 * inspecting the filesystem associated with the given path.
	 */
	if fsPtr != (*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FfsPtr {
		actualFs = XTcl_FSGetFileSystemForPath(tls, pathPtr)
		if actualFs == fsPtr {
			return XTcl_FSGetInternalRep(tls, pathPtr, fsPtr)
		}
		return libc.UintptrFromInt32(0)
	}
	if (*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FnativePathPtr == libc.UintptrFromInt32(0) {
		proc = (*TTcl_Filesystem)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FfsPtr)).FcreateInternalRepProc
		if proc == libc.UintptrFromInt32(0) {
			return libc.UintptrFromInt32(0)
		}
		nativePathPtr = (*(*func(*libc.TLS, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{proc})))(tls, pathPtr)
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
			v3 = pathPtr + 32
		} else {
			v3 = libc.UintptrFromInt32(0)
		}
		srcFsPathPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(v3))).Fptr1
		(*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FnativePathPtr = nativePathPtr
		(*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FfilesystemEpoch = XTclFSEpoch(tls)
	}
	return (*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FnativePathPtr
}

/*
 *---------------------------------------------------------------------------
 *
 * TclFSEnsureEpochOk --
 *
 *	Ensure that the path is a valid path, and that it has a
 *	fsPathType internal representation that is not stale.
 *
 * Results:
 *	A standard Tcl return code.
 *
 * Side effects:
 *	The internal representation of fsPtrPtr is converted to fsPathType if
 *	possible.
 *
 *---------------------------------------------------------------------------
 */

func XTclFSEnsureEpochOk(tls *libc.TLS, pathPtr uintptr, fsPtrPtr uintptr) (r int32) {
	var srcFsPathPtr, v1, v3 uintptr
	_, _, _ = srcFsPathPtr, v1, v3
	if !((*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType))) {
		return TCL_OK
	}
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
		v1 = pathPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	srcFsPathPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(v1))).Fptr1
	if !(XTclFSEpochOk(tls, (*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FfilesystemEpoch) != 0) {
		/*
		 * The filesystem has changed in some way since the internal
		 * representation for this object was calculated. Discard the stale
		 * representation and recalculate it.
		 */
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
			_ = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
		} else {
			XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
		}
		XTcl_StoreInternalRep(tls, pathPtr, uintptr(unsafe.Pointer(&_fsPathType)), libc.UintptrFromInt32(0))
		if _SetFsPathFromAny(tls, libc.UintptrFromInt32(0), pathPtr) != TCL_OK {
			return int32(TCL_ERROR)
		}
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
			v3 = pathPtr + 32
		} else {
			v3 = libc.UintptrFromInt32(0)
		}
		srcFsPathPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(v3))).Fptr1
	}
	if (*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FfsPtr != libc.UintptrFromInt32(0) {
		/*
		 * There is already a filesystem assigned to this path.
		 */
		*(*uintptr)(unsafe.Pointer(fsPtrPtr)) = (*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FfsPtr
	}
	return TCL_OK
}

/*
 *---------------------------------------------------------------------------
 *
 * TclFSSetPathDetails --
 *
 *	???
 *
 * Results:
 *	None
 *
 * Side effects:
 *	???
 *
 *---------------------------------------------------------------------------
 */

func XTclFSSetPathDetails(tls *libc.TLS, pathPtr uintptr, fsPtr uintptr, clientData uintptr) {
	var srcFsPathPtr, v1 uintptr
	_, _ = srcFsPathPtr, v1
	/*
	 * Make sure pathPtr is of the correct type.
	 */
	if !((*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType))) {
		if _SetFsPathFromAny(tls, libc.UintptrFromInt32(0), pathPtr) != TCL_OK {
			return
		}
	}
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
		v1 = pathPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	srcFsPathPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(v1))).Fptr1
	(*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FfsPtr = fsPtr
	(*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FnativePathPtr = clientData
	(*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FfilesystemEpoch = XTclFSEpoch(tls)
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_FSEqualPaths --
 *
 *	This function tests whether the two paths given are equal path
 *	objects. If either or both is NULL, 0 is always returned.
 *
 * Results:
 *	1 or 0.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_FSEqualPaths(tls *libc.TLS, firstPtr uintptr, secondPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var firstStr, secondStr, v1, v2, v3, v4 uintptr
	var tempErrno int32
	var _ /* firstLen at bp+0 */ TTcl_Size
	var _ /* secondLen at bp+8 */ TTcl_Size
	_, _, _, _, _, _, _ = firstStr, secondStr, tempErrno, v1, v2, v3, v4
	if firstPtr == secondPtr {
		return int32(1)
	}
	if firstPtr == libc.UintptrFromInt32(0) || secondPtr == libc.UintptrFromInt32(0) {
		return 0
	}
	if (*TTcl_Obj)(unsafe.Pointer(firstPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(firstPtr)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(firstPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, firstPtr, bp)
	}
	firstStr = v1
	if (*TTcl_Obj)(unsafe.Pointer(secondPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(secondPtr)).Flength
		v2 = (*TTcl_Obj)(unsafe.Pointer(secondPtr)).Fbytes
	} else {
		v2 = XTcl_GetStringFromObj(tls, secondPtr, bp+8)
	}
	secondStr = v2
	if *(*TTcl_Size)(unsafe.Pointer(bp)) == *(*TTcl_Size)(unsafe.Pointer(bp + 8)) && !(libc.Xmemcmp(tls, firstStr, secondStr, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))) != 0) {
		return int32(1)
	}
	/*
	 * Try the most thorough, correct method of comparing fully normalized
	 * paths.
	 */
	tempErrno = XTcl_GetErrno(tls)
	firstPtr = XTcl_FSGetNormalizedPath(tls, libc.UintptrFromInt32(0), firstPtr)
	secondPtr = XTcl_FSGetNormalizedPath(tls, libc.UintptrFromInt32(0), secondPtr)
	XTcl_SetErrno(tls, tempErrno)
	if firstPtr == libc.UintptrFromInt32(0) || secondPtr == libc.UintptrFromInt32(0) {
		return 0
	}
	if (*TTcl_Obj)(unsafe.Pointer(firstPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(firstPtr)).Flength
		v3 = (*TTcl_Obj)(unsafe.Pointer(firstPtr)).Fbytes
	} else {
		v3 = XTcl_GetStringFromObj(tls, firstPtr, bp)
	}
	firstStr = v3
	if (*TTcl_Obj)(unsafe.Pointer(secondPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(secondPtr)).Flength
		v4 = (*TTcl_Obj)(unsafe.Pointer(secondPtr)).Fbytes
	} else {
		v4 = XTcl_GetStringFromObj(tls, secondPtr, bp+8)
	}
	secondStr = v4
	return libc.BoolInt32(*(*TTcl_Size)(unsafe.Pointer(bp)) == *(*TTcl_Size)(unsafe.Pointer(bp + 8)) && !(libc.Xmemcmp(tls, firstStr, secondStr, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))) != 0))
}

/*
 *---------------------------------------------------------------------------
 *
 * SetFsPathFromAny --
 *
 *	Attempt to convert the internal representation of pathPtr to
 *	fsPathType.
 *
 * Results:
 *	Standard Tcl error code.
 *
 * Side effects:
 *	The old representation may be freed, and new memory allocated.
 *
 *---------------------------------------------------------------------------
 */

func _SetFsPathFromAny(tls *libc.TLS, dummy2198 uintptr, _pathPtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	*(*uintptr)(unsafe.Pointer(bp)) = _pathPtr /* The object to convert. */
	var fsPathPtr, transPtr, v2 uintptr
	var _ /* ir at bp+16 */ TTcl_ObjInternalRep
	var _ /* len at bp+8 */ TTcl_Size
	_, _, _ = fsPathPtr, transPtr, v2
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
		return TCL_OK
	}
	/*
	 * First step is to translate the filename. This is similar to
	 * Tcl_TranslateFilename, but shouldn't convert everything to windows
	 * backslashes on that platform. The current implementation of this piece
	 * is a slightly optimised version of the various Tilde/Split/Join stuff
	 * to avoid multiple split/join operations.
	 *
	 * We remove any trailing directory separator.
	 *
	 * However, the split/join routines are quite complex, and one has to make
	 * sure not to break anything on Unix or Win (fCmd.test, fileName.test and
	 * cmdAH.test exercise most of the code).
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Flength
		_ = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes
	} else {
		XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+8)
	} /* TODO: Is this needed? */
	transPtr = XTclJoinPath(tls, int64(1), bp, int32(1))
	/*
	 * Now we have a translated filename in 'transPtr'. This will have forward
	 * slashes on Windows, and will not contain any ~user sequences.
	 */
	fsPathPtr = XTcl_Alloc(tls, uint64(56))
	if transPtr == *(*uintptr)(unsafe.Pointer(bp)) {
		XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp)), libc.UintptrFromInt32(0))
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr != libc.UintptrFromInt32(0) {
			if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
				(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr)).FfreeIntRepProc})))(tls, *(*uintptr)(unsafe.Pointer(bp)))
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr = libc.UintptrFromInt32(0)
		}
		transPtr = XTcl_DuplicateObj(tls, *(*uintptr)(unsafe.Pointer(bp)))
		(*TFsPath)(unsafe.Pointer(fsPathPtr)).FfilesystemEpoch = uint64(0)
	} else {
		(*TFsPath)(unsafe.Pointer(fsPathPtr)).FfilesystemEpoch = XTclFSEpoch(tls)
	}
	(*TTcl_Obj)(unsafe.Pointer(transPtr)).FrefCount++
	(*TFsPath)(unsafe.Pointer(fsPathPtr)).FtranslatedPathPtr = transPtr
	(*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr = libc.UintptrFromInt32(0)
	(*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr = libc.UintptrFromInt32(0)
	(*TFsPath)(unsafe.Pointer(fsPathPtr)).FnativePathPtr = libc.UintptrFromInt32(0)
	(*TFsPath)(unsafe.Pointer(fsPathPtr)).FfsPtr = libc.UintptrFromInt32(0)
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp + 16))).Fptr1 = fsPathPtr
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp + 16))).Fptr2 = libc.UintptrFromInt32(0)
	XTcl_StoreInternalRep(tls, *(*uintptr)(unsafe.Pointer(bp)), uintptr(unsafe.Pointer(&_fsPathType)), bp+16)
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
		v2 = *(*uintptr)(unsafe.Pointer(bp)) + 32
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	(*TFsPath)(unsafe.Pointer((*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(v2))).Fptr1)).Fflags = 0
	return TCL_OK
}

func _FreeFsPathInternalRep(tls *libc.TLS, pathPtr uintptr) {
	/* Path object with internal rep to free. */
	var cachePtr, cachePtr1, cachePtr2, freeProc, fsPathPtr, v1, v3, v6, v9 uintptr
	var v10, v4, v7 bool
	var v2, v5, v8 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, freeProc, fsPathPtr, v1, v10, v2, v3, v4, v5, v6, v7, v8, v9
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
		v1 = pathPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	fsPathPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(v1))).Fptr1
	if (*TFsPath)(unsafe.Pointer(fsPathPtr)).FtranslatedPathPtr != libc.UintptrFromInt32(0) {
		if (*TFsPath)(unsafe.Pointer(fsPathPtr)).FtranslatedPathPtr != pathPtr {
			v3 = (*TFsPath)(unsafe.Pointer(fsPathPtr)).FtranslatedPathPtr
			v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
			*(*TTcl_Size)(unsafe.Pointer(v3))--
			if !(v2 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FtranslatedPathPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FtranslatedPathPtr)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FtranslatedPathPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FtranslatedPathPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FtranslatedPathPtr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FtranslatedPathPtr)).Flength = int64(-libc.Int32FromInt32(1))
					if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
						cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v4 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, (*TFsPath)(unsafe.Pointer(fsPathPtr)).FtranslatedPathPtr)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FtranslatedPathPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*TFsPath)(unsafe.Pointer(fsPathPtr)).FtranslatedPathPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, (*TFsPath)(unsafe.Pointer(fsPathPtr)).FtranslatedPathPtr)
				}
			}
		}
	}
	if (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr != libc.UintptrFromInt32(0) {
		if (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr != pathPtr {
			v6 = (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr
			v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
			*(*TTcl_Size)(unsafe.Pointer(v6))--
			if !(v5 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)).Flength = int64(-libc.Int32FromInt32(1))
					if v7 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v7 {
						cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v7 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)
				}
			}
		}
		(*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr = libc.UintptrFromInt32(0)
	}
	if (*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr != libc.UintptrFromInt32(0) {
		v9 = (*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr
		v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
		*(*TTcl_Size)(unsafe.Pointer(v9))--
		if !(v8 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr)).Flength = int64(-libc.Int32FromInt32(1))
				if v10 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v10 {
					cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v10 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, (*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, (*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr)
			}
		}
		(*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr = libc.UintptrFromInt32(0)
	}
	if (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnativePathPtr != libc.UintptrFromInt32(0) && (*TFsPath)(unsafe.Pointer(fsPathPtr)).FfsPtr != libc.UintptrFromInt32(0) {
		freeProc = (*TTcl_Filesystem)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(fsPathPtr)).FfsPtr)).FfreeInternalRepProc
		if freeProc != libc.UintptrFromInt32(0) {
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{freeProc})))(tls, (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnativePathPtr)
			(*TFsPath)(unsafe.Pointer(fsPathPtr)).FnativePathPtr = libc.UintptrFromInt32(0)
		}
	}
	XTclpFree(tls, fsPathPtr)
}

func _DupFsPathInternalRep(tls *libc.TLS, srcPtr uintptr, copyPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Path obj with internal rep to set. */
	var copyFsPathPtr, dupProc, srcFsPathPtr, v1 uintptr
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_, _, _, _ = copyFsPathPtr, dupProc, srcFsPathPtr, v1
	if (*TTcl_Obj)(unsafe.Pointer(srcPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
		v1 = srcPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	srcFsPathPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(v1))).Fptr1
	copyFsPathPtr = XTcl_Alloc(tls, uint64(56))
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr1 = copyFsPathPtr
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr2 = libc.UintptrFromInt32(0)
	XTcl_StoreInternalRep(tls, copyPtr, uintptr(unsafe.Pointer(&_fsPathType)), bp)
	(*TFsPath)(unsafe.Pointer(copyFsPathPtr)).FtranslatedPathPtr = (*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FtranslatedPathPtr
	if (*TFsPath)(unsafe.Pointer(copyFsPathPtr)).FtranslatedPathPtr != libc.UintptrFromInt32(0) {
		(*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(copyFsPathPtr)).FtranslatedPathPtr)).FrefCount++
	}
	(*TFsPath)(unsafe.Pointer(copyFsPathPtr)).FnormPathPtr = (*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FnormPathPtr
	if (*TFsPath)(unsafe.Pointer(copyFsPathPtr)).FnormPathPtr != libc.UintptrFromInt32(0) {
		(*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(copyFsPathPtr)).FnormPathPtr)).FrefCount++
	}
	(*TFsPath)(unsafe.Pointer(copyFsPathPtr)).FcwdPtr = (*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FcwdPtr
	if (*TFsPath)(unsafe.Pointer(copyFsPathPtr)).FcwdPtr != libc.UintptrFromInt32(0) {
		(*TTcl_Obj)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(copyFsPathPtr)).FcwdPtr)).FrefCount++
	}
	(*TFsPath)(unsafe.Pointer(copyFsPathPtr)).Fflags = (*TFsPath)(unsafe.Pointer(srcFsPathPtr)).Fflags
	if (*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FfsPtr != libc.UintptrFromInt32(0) && (*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FnativePathPtr != libc.UintptrFromInt32(0) {
		dupProc = (*TTcl_Filesystem)(unsafe.Pointer((*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FfsPtr)).FdupInternalRepProc
		if dupProc != libc.UintptrFromInt32(0) {
			(*TFsPath)(unsafe.Pointer(copyFsPathPtr)).FnativePathPtr = (*(*func(*libc.TLS, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{dupProc})))(tls, (*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FnativePathPtr)
		} else {
			(*TFsPath)(unsafe.Pointer(copyFsPathPtr)).FnativePathPtr = libc.UintptrFromInt32(0)
		}
	} else {
		(*TFsPath)(unsafe.Pointer(copyFsPathPtr)).FnativePathPtr = libc.UintptrFromInt32(0)
	}
	(*TFsPath)(unsafe.Pointer(copyFsPathPtr)).FfsPtr = (*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FfsPtr
	(*TFsPath)(unsafe.Pointer(copyFsPathPtr)).FfilesystemEpoch = (*TFsPath)(unsafe.Pointer(srcFsPathPtr)).FfilesystemEpoch
}

/*
 *---------------------------------------------------------------------------
 *
 * UpdateStringOfFsPath --
 *
 *	Gives an object a valid string rep.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Memory may be allocated.
 *
 *---------------------------------------------------------------------------
 */

func _UpdateStringOfFsPath(tls *libc.TLS, pathPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* path obj with string rep to update. */
	var cachePtr, copy1, fsPathPtr, v1, v2, v3, v5 uintptr
	var v4 TTcl_Size
	var v6 bool
	var _ /* cwdLen at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _ = cachePtr, copy1, fsPathPtr, v1, v2, v3, v4, v5, v6
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
		v1 = pathPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	fsPathPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(v1))).Fptr1
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
		v2 = pathPtr + 32
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	if (*TFsPath)(unsafe.Pointer((*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(v2))).Fptr1)).Fflags == 0 || (*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr == libc.UintptrFromInt32(0) {
		if (*TFsPath)(unsafe.Pointer(fsPathPtr)).FtranslatedPathPtr == libc.UintptrFromInt32(0) {
			XTcl_Panic(tls, __ccgo_ts+56340, 0)
		} else {
			copy1 = XTcl_DuplicateObj(tls, (*TFsPath)(unsafe.Pointer(fsPathPtr)).FtranslatedPathPtr)
		}
	} else {
		copy1 = _AppendPath(tls, (*TFsPath)(unsafe.Pointer(fsPathPtr)).FcwdPtr, (*TFsPath)(unsafe.Pointer(fsPathPtr)).FnormPathPtr)
	}
	if (*TTcl_Obj)(unsafe.Pointer(copy1)).FrefCount > int64(1) {
		copy1 = XTcl_DuplicateObj(tls, copy1)
	}
	(*TTcl_Obj)(unsafe.Pointer(copy1)).FrefCount++
	/* Steal copy's string rep */
	if (*TTcl_Obj)(unsafe.Pointer(copy1)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(copy1)).Flength
		v3 = (*TTcl_Obj)(unsafe.Pointer(copy1)).Fbytes
	} else {
		v3 = XTcl_GetStringFromObj(tls, copy1, bp)
	}
	(*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes = v3
	(*TTcl_Obj)(unsafe.Pointer(pathPtr)).Flength = *(*TTcl_Size)(unsafe.Pointer(bp))
	(*TTcl_Obj)(unsafe.Pointer(copy1)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(copy1)).Flength = int64(libc.Int32FromInt32(0))
	v5 = copy1
	v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
	*(*TTcl_Size)(unsafe.Pointer(v5))--
	if !(v4 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(copy1)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(copy1)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(copy1)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(copy1)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(copy1)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(copy1)).Flength = int64(-libc.Int32FromInt32(1))
			if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v6 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, copy1)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(copy1 + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = copy1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, copy1)
		}
	}
}

/*
 *---------------------------------------------------------------------------
 *
 * TclNativePathInFilesystem --
 *
 *	Any path object is acceptable to the native filesystem, by default (we
 *	will throw errors when illegal paths are actually tried to be used).
 *
 *	However, this behavior means the native filesystem must be the last
 *	filesystem in the lookup list (otherwise it will claim all files
 *	belong to it, and other filesystems will never get a look in).
 *
 * Results:
 *	TCL_OK, to indicate 'yes', -1 to indicate no.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTclNativePathInFilesystem(tls *libc.TLS, pathPtr uintptr, dummy2402 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _ /* len at bp+0 */ TTcl_Size
	/*
	 * A special case is required to handle the empty path "". This is a valid
	 * path (i.e. the user should be able to do 'file exists ""' without
	 * throwing an error), but equally the path doesn't exist. Those are the
	 * semantics of Tcl (at present anyway), so we have to abide by them here.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr == uintptr(unsafe.Pointer(&_fsPathType)) {
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != libc.UintptrFromInt32(0) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes))) == int32('\000') {
			/*
			 * We reject the empty path "".
			 */
			return -int32(1)
		}
		/*
		 * Otherwise there is no way this path can be empty.
		 */
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Flength
			_ = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
		} else {
			XTcl_GetStringFromObj(tls, pathPtr, bp)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
			/*
			 * We reject the empty path "".
			 */
			return -int32(1)
		}
	}
	/*
	 * Path is of correct type, or is of non-zero length, so we accept it.
	 */
	return TCL_OK
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * MakeTildeRelativePath --
//	 *
//	 *      Returns a path relative to the home directory of a user.
//	 *      Note there is a difference between not specifying a user and
//	 *	explicitly specifying the current user. This mimics Tcl8's tilde
//	 *	expansion.
//	 *
//	 *	The subPath argument is joined to the expanded home directory
//	 *	as in Tcl_JoinPath. This means if it is not relative, it will
//	 *	returned as the result with the home directory only checked
//	 *	for user name validity.
//	 *
//	 * Results:
//	 *	Returns TCL_OK on success with home directory path in *dsPtr
//	 *	and TCL_ERROR on failure with error message in interp if non-NULL.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _MakeTildeRelativePath(tls *libc.TLS, interp uintptr, user uintptr, subPath uintptr, dsPtr uintptr) (r int32) {
	bp := tls.Alloc(304)
	defer tls.Free(304) /* Output. Is initialized by the function. Must
	 * be freed on success */
	var _ /* dir at bp+0 */ uintptr
	var _ /* dirString at bp+8 */ TTcl_DString
	var _ /* parts at bp+232 */ [2]uintptr
	XTcl_DStringInit(tls, dsPtr)
	XTcl_DStringInit(tls, bp+8)
	if user == libc.UintptrFromInt32(0) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(user))) == 0 {
		/* No user name specified -> current user */
		*(*uintptr)(unsafe.Pointer(bp)) = XTclGetEnv(tls, __ccgo_ts+56388, bp+8)
		if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
			if interp != 0 {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+56393, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+256, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+56448, __ccgo_ts+56453, libc.UintptrFromInt32(0)))
			}
			return int32(TCL_ERROR)
		}
	} else {
		/* User name specified - ~user */
		*(*uintptr)(unsafe.Pointer(bp)) = XTclpGetUserHome(tls, user, bp+8)
		if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
			if interp != libc.UintptrFromInt32(0) {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+56462, libc.VaList(bp+256, user)))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+256, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+56448, __ccgo_ts+56486, libc.UintptrFromInt32(0)))
			}
			return int32(TCL_ERROR)
		}
	}
	if subPath != 0 {
		(*(*[2]uintptr)(unsafe.Pointer(bp + 232)))[0] = *(*uintptr)(unsafe.Pointer(bp))
		(*(*[2]uintptr)(unsafe.Pointer(bp + 232)))[int32(1)] = subPath
		XTcl_JoinPath(tls, int64(2), bp+232, dsPtr)
	} else {
		XTcl_JoinPath(tls, int64(1), bp, dsPtr)
	}
	XTcl_DStringFree(tls, bp+8)
	return TCL_OK
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * TclGetHomeDirObj --
//	 *
//	 *	Wrapper around MakeTildeRelativePath. See that function.
//	 *
//	 * Results:
//	 *      Returns a Tcl_Obj containing the home directory of a user
//	 *	or NULL on failure with error message in interp if non-NULL.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func XTclGetHomeDirObj(tls *libc.TLS, interp uintptr, user uintptr) (r uintptr) {
	bp := tls.Alloc(224)
	defer tls.Free(224) /* User name. NULL -> current user */
	var _ /* dirString at bp+0 */ TTcl_DString
	if _MakeTildeRelativePath(tls, interp, user, libc.UintptrFromInt32(0), bp) != TCL_OK {
		return libc.UintptrFromInt32(0)
	}
	return XTcl_DStringToObj(tls, bp)
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * Tcl_FSTildeExpand --
//	 *
//	 *	Copies the path passed in to the output Tcl_DString dsPtr,
//	 *	resolving leading ~ and ~user components in the path if present.
//	 *      An error is returned if such a component IS present AND cannot
//	 *      be resolved.
//	 *
//	 *	The output dsPtr must be cleared by caller on success.
//	 *
//	 * Results:
//	 *      TCL_OK - path did not contain leading ~ or it was successful resolved
//	 *      TCL_ERROR - ~ component could not be resolved.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func XTcl_FSTildeExpand(tls *libc.TLS, interp uintptr, path uintptr, dsPtr uintptr) (r int32) {
	bp := tls.Alloc(224)
	defer tls.Free(224) /* Output DString for resolved path. */
	var result int32
	var split TTcl_Size
	var user, v1, v2 uintptr
	var _ /* dsUser at bp+0 */ TTcl_DString
	_, _, _, _, _ = result, split, user, v1, v2
	XTcl_DStringInit(tls, dsPtr)
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) != int32('~') {
		XTcl_DStringAppend(tls, dsPtr, path, int64(-int32(1)))
		return TCL_OK
	}
	/*
	 * We have multiple cases '~', '~user', '~/foo/bar...', '~user/foo...'
	 * FindSplitPos returns 1 for '~/...' as well as for '~'. Note on
	 * Windows FindSplitPos implicitly checks for '\' as separator
	 * in addition to what is passed.
	 */
	split = _FindSplitPos(tls, path, int32('/'))
	if split == int64(1) {
		/* No user name specified '~' or '~/...' -> current user */
		if *(*uint8)(unsafe.Pointer(path + 1)) != 0 {
			v1 = uintptr(2) + path
		} else {
			v1 = libc.UintptrFromInt32(0)
		}
		result = _MakeTildeRelativePath(tls, interp, libc.UintptrFromInt32(0), v1, dsPtr)
	} else {
		XTcl_DStringInit(tls, bp)
		XTcl_DStringAppend(tls, bp, path+uintptr(1), split-int64(1))
		user = (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1
		/* path[split] is / for ~user/... or \0 for ~user */
		if *(*uint8)(unsafe.Pointer(path + uintptr(split))) != 0 {
			v2 = path + uintptr(split+int64(1))
		} else {
			v2 = libc.UintptrFromInt32(0)
		}
		result = _MakeTildeRelativePath(tls, interp, user, v2, dsPtr)
		XTcl_DStringFree(tls, bp)
	}
	if result != TCL_OK {
		/* Do not rely on caller to free in case of errors */
		XTcl_DStringFree(tls, dsPtr)
	}
	return result
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * TclResolveTildePath --
//	 *
//	 *	If the passed path is begins with a tilde, does tilde resolution
//	 *	and returns a Tcl_Obj containing the resolved path. If the tilde
//	 *	component cannot be resolved, returns NULL. If the path does not
//	 *	begin with a tilde, returns as is.
//	 *
//	 * Results:
//	 *      Returns a Tcl_Obj with resolved path. This may be a new Tcl_Obj
//	 *	with ref count 0 or that pathObj that was passed in without its
//	 *	ref count modified.
//	 *      Returns NULL if the path begins with a ~ that cannot be resolved
//	 *	and stores an error message in interp if non-NULL.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func XTclResolveTildePath(tls *libc.TLS, interp uintptr, pathObj uintptr) (r uintptr) {
	bp := tls.Alloc(240)
	defer tls.Free(240)
	var path, v1 uintptr
	var _ /* len at bp+0 */ TTcl_Size
	var _ /* resolvedPath at bp+8 */ TTcl_DString
	_, _ = path, v1
	if (*TTcl_Obj)(unsafe.Pointer(pathObj)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(pathObj)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(pathObj)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, pathObj, bp)
	}
	path = v1
	/* Optimize to skip unnecessary calls below */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) != int32('~') {
		return pathObj
	}
	if XTcl_FSTildeExpand(tls, interp, path, bp+8) != TCL_OK {
		return libc.UintptrFromInt32(0)
	}
	return XTcl_DStringToObj(tls, bp+8)
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * TclResolveTildePathList --
//	 *
//	 *	Given a Tcl_Obj that is a list of paths, returns a Tcl_Obj containing
//	 *	the paths with any ~-prefixed paths resolved.
//	 *
//	 *	Empty strings and ~-prefixed paths that cannot be resolved are
//	 *      removed from the returned list.
//	 *
//	 *      The trailing components of the path are returned verbatim. No
//	 *	processing is done on them. Moreover, no assumptions should be
//	 *	made about the separators in the returned path. They may be /
//	 *	or native. Appropriate path manipulations functions should be
//	 *	used by caller if desired.
//	 *
//	 * Results:
//	 *	Returns a Tcl_Obj with resolved paths. This may be a new Tcl_Obj with
//	 *	reference count 0 or the original passed-in Tcl_Obj if no paths needed
//	 *	resolution. A NULL is returned if the passed in value is not a list
//	 *	or was NULL.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func XTclResolveTildePathList(tls *libc.TLS, pathsObj uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var i TTcl_Size
	var path, resolvedPath, resolvedPaths uintptr
	var _ /* objc at bp+8 */ TTcl_Size
	var _ /* objv at bp+0 */ uintptr
	_, _, _, _ = i, path, resolvedPath, resolvedPaths
	if pathsObj == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	if XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), pathsObj, bp+8, bp) != TCL_OK {
		return libc.UintptrFromInt32(0) /* Not a list */
	}
	/*
	 * Figure out if any paths need resolving to avoid unnecessary allocations.
	 */
	i = 0
	for {
		if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) {
			break
		}
		path = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(i)*8)), libc.UintptrFromInt32(0))
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == int32('~') {
			break /* At least one path needs resolution */
		}
		goto _1
	_1:
		;
		i++
	}
	if i == *(*TTcl_Size)(unsafe.Pointer(bp + 8)) {
		return pathsObj /* No paths needed to be resolved */
	}
	resolvedPaths = XTcl_NewListObj(tls, *(*TTcl_Size)(unsafe.Pointer(bp + 8)), libc.UintptrFromInt32(0))
	i = 0
	for {
		if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) {
			break
		}
		path = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(i)*8)), libc.UintptrFromInt32(0))
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path))) == 0 {
			goto _2 /* Skip empty strings */
		}
		resolvedPath = XTclResolveTildePath(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(i)*8)))
		if resolvedPath != 0 {
			/* Paths that cannot be resolved are skipped */
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resolvedPaths, resolvedPath)
		}
		goto _2
	_2:
		;
		i++
	}
	return resolvedPaths
}

/* Epoch of the tcl environment
 * (if changed with tcl-env). */

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * A linked list of the following structures is used to keep track of child
 * processes that have been detached but haven't exited yet, so we can make
 * sure that they're properly "reaped" (officially waited for) and don't lie
 * around as zombies cluttering the system.
 */

type TDetached = struct {
	Fpid     TTcl_Pid
	FnextPtr uintptr
}

var _detList = libc.UintptrFromInt32(0)

// C documentation
//
//	/* List of all detached proceses. */
var _pipeMutex TTcl_Mutex

/*
 *----------------------------------------------------------------------
 *
 * FileForRedirect --
 *
 *	This function does much of the work of parsing redirection operators.
 *	It handles "@" if specified and allowed, and a file name, and opens
 *	the file if necessary.
 *
 * Results:
 *	The return value is the descriptor number for the file. If an error
 *	occurs then NULL is returned and an error message is left in the
 *	interp's result. Several arguments are side-effected; see the argument
 *	list below for details.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _FileForRedirect(tls *libc.TLS, interp uintptr, spec uintptr, atOK int32, arg uintptr, nextArg uintptr, flags int32, skipPtr uintptr, closePtr uintptr, releasePtr uintptr) (r TTclFile) {
	bp := tls.Alloc(288)
	defer tls.Free(288)
	var chan1 TTcl_Channel
	var file TTclFile
	var name, v2, v3 uintptr
	var writing, v1 int32
	var _ /* msg at bp+0 */ uintptr
	var _ /* nameString at bp+8 */ TTcl_DString
	_, _, _, _, _, _, _ = chan1, file, name, writing, v1, v2, v3
	writing = flags & int32(O_WRONLY)
	*(*int32)(unsafe.Pointer(skipPtr)) = int32(1)
	if atOK != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(spec))) == int32('@') {
		spec++
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(spec))) == int32('\000') {
			spec = nextArg
			if spec == libc.UintptrFromInt32(0) {
				goto badLastArg
			}
			*(*int32)(unsafe.Pointer(skipPtr)) = int32(2)
		}
		chan1 = XTcl_GetChannel(tls, interp, spec, libc.UintptrFromInt32(0))
		if chan1 == libc.UintptrFromInt32(0) {
			return libc.UintptrFromInt32(0)
		}
		if writing != 0 {
			v1 = libc.Int32FromInt32(1) << libc.Int32FromInt32(2)
		} else {
			v1 = libc.Int32FromInt32(1) << libc.Int32FromInt32(1)
		}
		file = XTclpMakeFile(tls, chan1, v1)
		if file == libc.UintptrFromInt32(0) {
			XTcl_GetChannelError(tls, chan1, bp)
			if *(*uintptr)(unsafe.Pointer(bp)) != 0 {
				XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(bp)))
			} else {
				if writing != 0 {
					v2 = __ccgo_ts + 56493
				} else {
					v2 = __ccgo_ts + 56501
				}
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+56509, libc.VaList(bp+240, XTcl_GetChannelName(tls, chan1), v2)))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+240, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+56543, __ccgo_ts+56548, libc.UintptrFromInt32(0)))
			}
			return libc.UintptrFromInt32(0)
		}
		*(*int32)(unsafe.Pointer(releasePtr)) = int32(1)
		if writing != 0 {
			/*
			 * Be sure to flush output to the file, so that anything written
			 * by the child appears after stuff we've already written.
			 */
			XTcl_Flush(tls, chan1)
		}
	} else {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(spec))) == int32('\000') {
			spec = nextArg
			if spec == libc.UintptrFromInt32(0) {
				goto badLastArg
			}
			*(*int32)(unsafe.Pointer(skipPtr)) = int32(2)
		}
		name = XTcl_TranslateFileName(tls, interp, spec, bp+8)
		if name == libc.UintptrFromInt32(0) {
			return libc.UintptrFromInt32(0)
		}
		file = XTclpOpenFile(tls, name, flags)
		XTcl_DStringFree(tls, bp+8)
		if file == libc.UintptrFromInt32(0) {
			if writing != 0 {
				v3 = __ccgo_ts + 44159
			} else {
				v3 = __ccgo_ts + 5552
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+56556, libc.VaList(bp+240, v3, spec, XTcl_PosixError(tls, interp))))
			return libc.UintptrFromInt32(0)
		}
		*(*int32)(unsafe.Pointer(closePtr)) = int32(1)
	}
	return file
	goto badLastArg
badLastArg:
	;
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+56582, libc.VaList(bp+240, arg)))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+240, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+56543, __ccgo_ts+26810, libc.UintptrFromInt32(0)))
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DetachPids --
 *
 *	This function is called to indicate that one or more child processes
 *	have been placed in background and will never be waited for; they
 *	should eventually be reaped by Tcl_ReapDetachedProcs.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DetachPids(tls *libc.TLS, numPids TTcl_Size, pidPtr uintptr) {
	/* Array of pids to detach. */
	var detPtr uintptr
	var i TTcl_Size
	_, _ = detPtr, i
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_pipeMutex)))
	i = 0
	for {
		if !(i < numPids) {
			break
		}
		detPtr = XTcl_Alloc(tls, uint64(16))
		(*TDetached)(unsafe.Pointer(detPtr)).Fpid = *(*TTcl_Pid)(unsafe.Pointer(pidPtr + uintptr(i)*8))
		(*TDetached)(unsafe.Pointer(detPtr)).FnextPtr = _detList
		_detList = detPtr
		goto _1
	_1:
		;
		i++
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_pipeMutex)))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ReapDetachedProcs --
 *
 *	This function checks to see if any detached processes have exited and,
 *	if so, it "reaps" them by officially waiting on them. It should be
 *	called "occasionally" to make sure that all detached processes are
 *	eventually reaped.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Processes are waited on, so that they can be reaped by the system.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ReapDetachedProcs(tls *libc.TLS) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var detPtr, nextPtr, prevPtr uintptr
	var status int32
	var _ /* code at bp+0 */ int32
	_, _, _, _ = detPtr, nextPtr, prevPtr, status
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_pipeMutex)))
	detPtr = _detList
	prevPtr = libc.UintptrFromInt32(0)
	for {
		if !(detPtr != libc.UintptrFromInt32(0)) {
			break
		}
		status = XTclProcessWait(tls, (*TDetached)(unsafe.Pointer(detPtr)).Fpid, int32(WNOHANG), bp, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
		if status == int32(TCL_PROCESS_UNCHANGED) || status == int32(TCL_PROCESS_ERROR) && *(*int32)(unsafe.Pointer(bp)) != int32(ECHILD) {
			prevPtr = detPtr
			detPtr = (*TDetached)(unsafe.Pointer(detPtr)).FnextPtr
			goto _1
		}
		nextPtr = (*TDetached)(unsafe.Pointer(detPtr)).FnextPtr
		if prevPtr == libc.UintptrFromInt32(0) {
			_detList = (*TDetached)(unsafe.Pointer(detPtr)).FnextPtr
		} else {
			(*TDetached)(unsafe.Pointer(prevPtr)).FnextPtr = (*TDetached)(unsafe.Pointer(detPtr)).FnextPtr
		}
		XTclpFree(tls, detPtr)
		detPtr = nextPtr
		goto _1
	_1:
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_pipeMutex)))
}

/*
 *----------------------------------------------------------------------
 *
 * TclCleanupChildren --
 *
 *	This is a utility function used to wait for child processes to exit,
 *	record information about abnormal exits, and then collect any stderr
 *	output generated by them.
 *
 * Results:
 *	The return value is a standard Tcl result. If anything at weird
 *	happened with the child processes, TCL_ERROR is returned and a message
 *	is left in the interp's result.
 *
 * Side effects:
 *	If the last character of the interp's result is a newline, then it is
 *	removed unless keepNewline is non-zero. File errorId gets closed, and
 *	pidPtr is freed back to the storage allocator.
 *
 *----------------------------------------------------------------------
 */

func XTclCleanupChildren(tls *libc.TLS, interp uintptr, numPids TTcl_Size, pidPtr uintptr, errorChan TTcl_Channel) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Channel for file containing stderr output
	 * from pipeline. NULL means there isn't any
	 * stderr output. */
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, cachePtr, objPtr, v12, v14, v3, v5, v7, v9 uintptr
	var abnormalExit, anyErrorInfo, count, result int32
	var i, v11, v13, v2, v4, v6, v8 TTcl_Size
	var waitStatus TTclProcessWaitStatus
	var v10 bool
	var _ /* code at bp+0 */ int32
	var _ /* error at bp+16 */ uintptr
	var _ /* msg at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, abnormalExit, anyErrorInfo, cachePtr, count, i, objPtr, result, waitStatus, v10, v11, v12, v13, v14, v2, v3, v4, v5, v6, v7, v8, v9
	result = TCL_OK
	abnormalExit = 0
	i = 0
	for {
		if !(i < numPids) {
			break
		}
		waitStatus = XTclProcessWait(tls, *(*TTcl_Pid)(unsafe.Pointer(pidPtr + uintptr(i)*8)), 0, bp, bp+8, bp+16)
		if waitStatus == int32(TCL_PROCESS_ERROR) {
			result = int32(TCL_ERROR)
			if interp != libc.UintptrFromInt32(0) {
				XTcl_SetObjErrorCode(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 16)))
				XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 8)))
			}
			_objPtr = *(*uintptr)(unsafe.Pointer(bp + 16))
			v3 = _objPtr
			v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
			*(*TTcl_Size)(unsafe.Pointer(v3))--
			if v2 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			_objPtr1 = *(*uintptr)(unsafe.Pointer(bp + 8))
			v5 = _objPtr1
			v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
			*(*TTcl_Size)(unsafe.Pointer(v5))--
			if v4 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
			goto _1
		}
		/*
		 * Create error messages for unusual process exits. An extra newline
		 * gets appended to each error message, but it gets removed below (in
		 * the same fashion that an extra newline in the command's output is
		 * removed).
		 */
		if waitStatus != int32(TCL_PROCESS_EXITED) || *(*int32)(unsafe.Pointer(bp)) != 0 {
			result = int32(TCL_ERROR)
			if waitStatus == int32(TCL_PROCESS_EXITED) {
				if interp != libc.UintptrFromInt32(0) {
					XTcl_SetObjErrorCode(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 16)))
				}
				abnormalExit = int32(1)
			} else {
				if interp != libc.UintptrFromInt32(0) {
					XTcl_SetObjErrorCode(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 16)))
					XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 8)))
				}
			}
			_objPtr2 = *(*uintptr)(unsafe.Pointer(bp + 16))
			v7 = _objPtr2
			v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
			*(*TTcl_Size)(unsafe.Pointer(v7))--
			if v6 <= int64(1) {
				XTclFreeObj(tls, _objPtr2)
			}
			_objPtr3 = *(*uintptr)(unsafe.Pointer(bp + 8))
			v9 = _objPtr3
			v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
			*(*TTcl_Size)(unsafe.Pointer(v9))--
			if v8 <= int64(1) {
				XTclFreeObj(tls, _objPtr3)
			}
		}
		goto _1
	_1:
		;
		i++
	}
	/*
	 * Read the standard error file. If there's anything there, then return an
	 * error and add the file's contents to the result string.
	 */
	anyErrorInfo = 0
	if errorChan != libc.UintptrFromInt32(0) {
		/*
		 * Make sure we start at the beginning of the file.
		 */
		if interp != libc.UintptrFromInt32(0) {
			XTcl_Seek(tls, errorChan, 0, 0)
			if v10 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v10 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v10 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				objPtr = XTclThreadAllocObj(tls)
			} else {
				objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
			count = int32(XTcl_ReadChars(tls, errorChan, objPtr, int64(-libc.Int32FromInt32(1)), 0))
			if count == -int32(1) {
				result = int32(TCL_ERROR)
				_objPtr4 = objPtr
				v12 = _objPtr4
				v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
				*(*TTcl_Size)(unsafe.Pointer(v12))--
				if v11 <= int64(1) {
					XTclFreeObj(tls, _objPtr4)
				}
				XTcl_ResetResult(tls, interp)
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+56625, libc.VaList(bp+32, XTcl_PosixError(tls, interp))))
			} else {
				if count > 0 {
					anyErrorInfo = int32(1)
					XTcl_SetObjResult(tls, interp, objPtr)
					result = int32(TCL_ERROR)
				} else {
					_objPtr5 = objPtr
					v14 = _objPtr5
					v13 = *(*TTcl_Size)(unsafe.Pointer(v14))
					*(*TTcl_Size)(unsafe.Pointer(v14))--
					if v13 <= int64(1) {
						XTclFreeObj(tls, _objPtr5)
					}
				}
			}
		}
		XTcl_CloseEx(tls, libc.UintptrFromInt32(0), errorChan, 0)
	}
	/*
	 * If a child exited abnormally but didn't output any error information at
	 * all, generate an error message here.
	 */
	if abnormalExit != 0 && anyErrorInfo == 0 && interp != libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+56662, int64(-int32(1))))
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * TclCreatePipeline --
 *
 *	Given an argc/argv array, instantiate a pipeline of processes as
 *	described by the argv.
 *
 *	This function is unofficially exported for use by BLT.
 *
 * Results:
 *	The return value is a count of the number of new processes created, or
 *	TCL_INDEX_NONE if an error occurred while creating the pipeline. *pidArrayPtr is
 *	filled in with the address of a dynamically allocated array giving the
 *	ids of all of the processes. It is up to the caller to free this array
 *	when it isn't needed anymore. If inPipePtr is non-NULL, *inPipePtr is
 *	filled in with the file id for the input pipe for the pipeline (if
 *	any): the caller must eventually close this file. If outPipePtr isn't
 *	NULL, then *outPipePtr is filled in with the file id for the output
 *	pipe from the pipeline: the caller must close this file. If errFilePtr
 *	isn't NULL, then *errFilePtr is filled with a file id that may be used
 *	to read error output after the pipeline completes.
 *
 * Side effects:
 *	Processes and pipes are created.
 *
 *----------------------------------------------------------------------
 */

func XTclCreatePipeline(tls *libc.TLS, interp uintptr, argc TTcl_Size, argv uintptr, pidArrayPtr uintptr, inPipePtr uintptr, outPipePtr uintptr, errFilePtr uintptr) (r TTcl_Size) {
	bp := tls.Alloc(352)
	defer tls.Free(352) /* If non-NULL, all stderr output from the
	 * pipeline will go to a temporary file
	 * created here, and a descriptor to read the
	 * file will be left at *errFilePtr. The file
	 * will be removed already, so closing this
	 * descriptor will be the end of the file. If
	 * this is NULL, then all stderr output goes
	 * to our stderr. If the pipeline specifies
	 * redirection then the file will still be
	 * created but it will never get any data. */
	var atOK, errorToOutput, flags, joinThisError, needCmd, result int32
	var channel TTcl_Channel
	var cmdCount, i, j, lastArg, lastBar, numPids TTcl_Size
	var curErrFile, curInFile, errorFile TTclFile
	var inputLiteral, nextArg, oldName, p, pidPtr, v2, v3, v4, v5, v6 uintptr
	var _ /* curOutFile at bp+280 */ TTclFile
	var _ /* errorClose at bp+32 */ int32
	var _ /* errorRelease at bp+36 */ int32
	var _ /* execBuffer at bp+48 */ TTcl_DString
	var _ /* inputClose at bp+8 */ int32
	var _ /* inputFile at bp+0 */ TTclFile
	var _ /* inputRelease at bp+12 */ int32
	var _ /* outputClose at bp+24 */ int32
	var _ /* outputFile at bp+16 */ TTclFile
	var _ /* outputRelease at bp+28 */ int32
	var _ /* pid at bp+288 */ TTcl_Pid
	var _ /* pipeIn at bp+272 */ TTclFile
	var _ /* skip at bp+40 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = atOK, channel, cmdCount, curErrFile, curInFile, errorFile, errorToOutput, flags, i, inputLiteral, j, joinThisError, lastArg, lastBar, needCmd, nextArg, numPids, oldName, p, pidPtr, result, v2, v3, v4, v5, v6
	pidPtr = libc.UintptrFromInt32(0) /* Count of number of distinct commands found
	 * in argc/argv. */
	inputLiteral = libc.UintptrFromInt32(0)
	/* If non-null, then this points to a string
	 * containing input data (specified via <<) to
	 * be piped to the first process in the
	 * pipeline. */
	*(*TTclFile)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0) /* If != NULL, gives file to use as input for
	 * first process in pipeline (specified via <
	 * or <@). */
	*(*int32)(unsafe.Pointer(bp + 8)) = 0 /* If non-zero, then inputFile should be
	 * closed when cleaning up. */
	*(*int32)(unsafe.Pointer(bp + 12)) = 0
	*(*TTclFile)(unsafe.Pointer(bp + 16)) = libc.UintptrFromInt32(0) /* Writable file for output from last command
	 * in pipeline (could be file or pipe). NULL
	 * means use stdout. */
	*(*int32)(unsafe.Pointer(bp + 24)) = 0 /* If non-zero, then outputFile should be
	 * closed when cleaning up. */
	*(*int32)(unsafe.Pointer(bp + 28)) = 0
	errorFile = libc.UintptrFromInt32(0) /* Writable file for error output from all
	 * commands in pipeline. NULL means use
	 * stderr. */
	*(*int32)(unsafe.Pointer(bp + 32)) = 0 /* If non-zero, then errorFile should be
	 * closed when cleaning up. */
	*(*int32)(unsafe.Pointer(bp + 36)) = 0
	errorToOutput = 0
	if inPipePtr != libc.UintptrFromInt32(0) {
		*(*TTclFile)(unsafe.Pointer(inPipePtr)) = libc.UintptrFromInt32(0)
	}
	if outPipePtr != libc.UintptrFromInt32(0) {
		*(*TTclFile)(unsafe.Pointer(outPipePtr)) = libc.UintptrFromInt32(0)
	}
	if errFilePtr != libc.UintptrFromInt32(0) {
		*(*TTclFile)(unsafe.Pointer(errFilePtr)) = libc.UintptrFromInt32(0)
	}
	XTcl_DStringInit(tls, bp+48)
	*(*TTclFile)(unsafe.Pointer(bp + 272)) = libc.UintptrFromInt32(0)
	curInFile = libc.UintptrFromInt32(0)
	*(*TTclFile)(unsafe.Pointer(bp + 280)) = libc.UintptrFromInt32(0)
	numPids = 0
	/*
	 * First, scan through all the arguments to figure out the structure of
	 * the pipeline. Process all of the input and output redirection arguments
	 * and remove them from the argument list in the pipeline. Count the
	 * number of distinct processes (it's the number of "|" arguments plus
	 * one) but don't remove the "|" arguments because they'll be used in the
	 * second pass to separate the individual child processes. Cannot start
	 * the child processes in this pass because the redirection symbols may
	 * appear anywhere in the command line - e.g., the '<' that specifies the
	 * input to the entire pipe may appear at the very end of the argument
	 * list.
	 */
	lastBar = int64(-int32(1))
	cmdCount = int64(1)
	needCmd = int32(1)
	i = 0
	for {
		if !(i < argc) {
			break
		}
		errorToOutput = 0
		*(*int32)(unsafe.Pointer(bp + 40)) = 0
		p = *(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8))
		v2 = p
		p++
		switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) {
		case int32('|'):
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('&') {
				p++
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('\000') {
				if i == lastBar+int64(1) || i == argc-int64(1) {
					XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+56694, int64(-int32(1))))
					XTcl_SetErrorCode(tls, interp, libc.VaList(bp+304, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+56543, __ccgo_ts+56728, libc.UintptrFromInt32(0)))
					goto error
				}
			}
			lastBar = i
			cmdCount++
			needCmd = int32(1)
		case int32('<'):
			if *(*int32)(unsafe.Pointer(bp + 8)) != 0 {
				*(*int32)(unsafe.Pointer(bp + 8)) = 0
				XTclpCloseFile(tls, *(*TTclFile)(unsafe.Pointer(bp)))
			}
			if *(*int32)(unsafe.Pointer(bp + 12)) != 0 {
				*(*int32)(unsafe.Pointer(bp + 12)) = 0
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('<') {
				*(*TTclFile)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
				inputLiteral = p + uintptr(1)
				*(*int32)(unsafe.Pointer(bp + 40)) = int32(1)
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(inputLiteral))) == int32('\000') {
					if i+int64(1) == argc {
						v3 = libc.UintptrFromInt32(0)
					} else {
						v3 = *(*uintptr)(unsafe.Pointer(argv + uintptr(i+int64(1))*8))
					}
					inputLiteral = v3
					if inputLiteral == libc.UintptrFromInt32(0) {
						XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+56582, libc.VaList(bp+304, *(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)))))
						XTcl_SetErrorCode(tls, interp, libc.VaList(bp+304, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+56543, __ccgo_ts+56728, libc.UintptrFromInt32(0)))
						goto error
					}
					*(*int32)(unsafe.Pointer(bp + 40)) = int32(2)
				}
			} else {
				if i+int64(1) == argc {
					v4 = libc.UintptrFromInt32(0)
				} else {
					v4 = *(*uintptr)(unsafe.Pointer(argv + uintptr(i+int64(1))*8))
				}
				nextArg = v4
				inputLiteral = libc.UintptrFromInt32(0)
				*(*TTclFile)(unsafe.Pointer(bp)) = _FileForRedirect(tls, interp, p, int32(1), *(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)), nextArg, O_RDONLY, bp+40, bp+8, bp+12)
				if *(*TTclFile)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
					goto error
				}
			}
		case int32('>'):
			atOK = int32(1)
			flags = libc.Int32FromInt32(O_WRONLY) | libc.Int32FromInt32(O_CREAT) | libc.Int32FromInt32(O_TRUNC)
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('>') {
				p++
				atOK = 0
				/*
				 * Note that the O_APPEND flag only has an effect on POSIX
				 * platforms. On Windows, we just have to carry on regardless.
				 */
				flags = libc.Int32FromInt32(O_WRONLY) | libc.Int32FromInt32(O_CREAT) | libc.Int32FromInt32(O_APPEND)
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('&') {
				if *(*int32)(unsafe.Pointer(bp + 32)) != 0 {
					*(*int32)(unsafe.Pointer(bp + 32)) = 0
					XTclpCloseFile(tls, errorFile)
				}
				errorToOutput = int32(1)
				p++
			}
			/*
			 * Close the old output file, but only if the error file is not
			 * also using it.
			 */
			if *(*int32)(unsafe.Pointer(bp + 24)) != 0 {
				*(*int32)(unsafe.Pointer(bp + 24)) = 0
				if errorFile == *(*TTclFile)(unsafe.Pointer(bp + 16)) {
					*(*int32)(unsafe.Pointer(bp + 32)) = int32(1)
				} else {
					XTclpCloseFile(tls, *(*TTclFile)(unsafe.Pointer(bp + 16)))
				}
			}
			if *(*int32)(unsafe.Pointer(bp + 28)) != 0 {
				*(*int32)(unsafe.Pointer(bp + 28)) = 0
				if errorFile == *(*TTclFile)(unsafe.Pointer(bp + 16)) {
					*(*int32)(unsafe.Pointer(bp + 36)) = int32(1)
				} else {
				}
			}
			if i+int64(1) == argc {
				v5 = libc.UintptrFromInt32(0)
			} else {
				v5 = *(*uintptr)(unsafe.Pointer(argv + uintptr(i+int64(1))*8))
			}
			nextArg = v5
			*(*TTclFile)(unsafe.Pointer(bp + 16)) = _FileForRedirect(tls, interp, p, atOK, *(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)), nextArg, flags, bp+40, bp+24, bp+28)
			if *(*TTclFile)(unsafe.Pointer(bp + 16)) == libc.UintptrFromInt32(0) {
				goto error
			}
			if errorToOutput != 0 {
				if *(*int32)(unsafe.Pointer(bp + 32)) != 0 {
					*(*int32)(unsafe.Pointer(bp + 32)) = 0
					XTclpCloseFile(tls, errorFile)
				}
				if *(*int32)(unsafe.Pointer(bp + 36)) != 0 {
					*(*int32)(unsafe.Pointer(bp + 36)) = 0
				}
				errorFile = *(*TTclFile)(unsafe.Pointer(bp + 16))
			}
		case int32('2'):
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('>') {
				break
			}
			p++
			atOK = int32(1)
			flags = libc.Int32FromInt32(O_WRONLY) | libc.Int32FromInt32(O_CREAT) | libc.Int32FromInt32(O_TRUNC)
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('>') {
				p++
				atOK = 0
				/*
				 * Note that the O_APPEND flag only has an effect on POSIX
				 * platforms. On Windows, we just have to carry on regardless.
				 */
				flags = libc.Int32FromInt32(O_WRONLY) | libc.Int32FromInt32(O_CREAT) | libc.Int32FromInt32(O_APPEND)
			}
			if *(*int32)(unsafe.Pointer(bp + 32)) != 0 {
				*(*int32)(unsafe.Pointer(bp + 32)) = 0
				XTclpCloseFile(tls, errorFile)
			}
			if *(*int32)(unsafe.Pointer(bp + 36)) != 0 {
				*(*int32)(unsafe.Pointer(bp + 36)) = 0
			}
			if atOK != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('@') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('1') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 2))) == int32('\000') {
				/*
				 * Special case handling of 2>@1 to redirect stderr to the
				 * exec/open output pipe as well. This is meant for the end of
				 * the command string, otherwise use |& between commands.
				 */
				if i != argc-int64(1) {
					XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+56739, libc.VaList(bp+304, *(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)))))
					XTcl_SetErrorCode(tls, interp, libc.VaList(bp+304, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+56543, __ccgo_ts+56728, libc.UintptrFromInt32(0)))
					goto error
				}
				errorFile = *(*TTclFile)(unsafe.Pointer(bp + 16))
				errorToOutput = int32(2)
				*(*int32)(unsafe.Pointer(bp + 40)) = int32(1)
			} else {
				if i+int64(1) == argc {
					v6 = libc.UintptrFromInt32(0)
				} else {
					v6 = *(*uintptr)(unsafe.Pointer(argv + uintptr(i+int64(1))*8))
				}
				nextArg = v6
				errorFile = _FileForRedirect(tls, interp, p, atOK, *(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)), nextArg, flags, bp+40, bp+32, bp+36)
				if errorFile == libc.UintptrFromInt32(0) {
					goto error
				}
			}
		default:
			/*
			 * Got a command word, not a redirection.
			 */
			needCmd = 0
			break
		}
		if *(*int32)(unsafe.Pointer(bp + 40)) != 0 {
			j = i + int64(*(*int32)(unsafe.Pointer(bp + 40)))
			for {
				if !(j < argc) {
					break
				}
				*(*uintptr)(unsafe.Pointer(argv + uintptr(j-int64(*(*int32)(unsafe.Pointer(bp + 40))))*8)) = *(*uintptr)(unsafe.Pointer(argv + uintptr(j)*8))
				goto _7
			_7:
				;
				j++
			}
			argc -= int64(*(*int32)(unsafe.Pointer(bp + 40)))
			i -= int64(1)
		}
		goto _1
	_1:
		;
		i++
	}
	if needCmd != 0 {
		/*
		 * We had a bar followed only by redirections.
		 */
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+56694, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+304, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+56543, __ccgo_ts+56728, libc.UintptrFromInt32(0)))
		goto error
	}
	if *(*TTclFile)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
		if inputLiteral != libc.UintptrFromInt32(0) {
			/*
			 * The input for the first process is immediate data coming from
			 * Tcl. Create a temporary file for it and put the data into the
			 * file.
			 */
			*(*TTclFile)(unsafe.Pointer(bp)) = XTclpCreateTempFile(tls, inputLiteral)
			if *(*TTclFile)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+56781, libc.VaList(bp+304, XTcl_PosixError(tls, interp))))
				goto error
			}
			*(*int32)(unsafe.Pointer(bp + 8)) = int32(1)
		} else {
			if inPipePtr != libc.UintptrFromInt32(0) {
				/*
				 * The input for the first process in the pipeline is to come from
				 * a pipe that can be written from by the caller.
				 */
				if XTclpCreatePipe(tls, bp, inPipePtr) == 0 {
					XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+56824, libc.VaList(bp+304, XTcl_PosixError(tls, interp))))
					goto error
				}
				*(*int32)(unsafe.Pointer(bp + 8)) = int32(1)
			} else {
				/*
				 * The input for the first process comes from stdin.
				 */
				channel = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1))
				if channel != libc.UintptrFromInt32(0) {
					*(*TTclFile)(unsafe.Pointer(bp)) = XTclpMakeFile(tls, channel, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1))
					if *(*TTclFile)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
						*(*int32)(unsafe.Pointer(bp + 12)) = int32(1)
					}
				}
			}
		}
	}
	if *(*TTclFile)(unsafe.Pointer(bp + 16)) == libc.UintptrFromInt32(0) {
		if outPipePtr != libc.UintptrFromInt32(0) {
			/*
			 * Output from the last process in the pipeline is to go to a pipe
			 * that can be read by the caller.
			 */
			if XTclpCreatePipe(tls, outPipePtr, bp+16) == 0 {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+56867, libc.VaList(bp+304, XTcl_PosixError(tls, interp))))
				goto error
			}
			*(*int32)(unsafe.Pointer(bp + 24)) = int32(1)
		} else {
			/*
			 * The output for the last process goes to stdout.
			 */
			channel = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2))
			if channel != 0 {
				*(*TTclFile)(unsafe.Pointer(bp + 16)) = XTclpMakeFile(tls, channel, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2))
				if *(*TTclFile)(unsafe.Pointer(bp + 16)) != libc.UintptrFromInt32(0) {
					*(*int32)(unsafe.Pointer(bp + 28)) = int32(1)
				}
			}
		}
	}
	if errorFile == libc.UintptrFromInt32(0) {
		if errorToOutput == int32(2) {
			/*
			 * Handle 2>@1 special case at end of cmd line.
			 */
			errorFile = *(*TTclFile)(unsafe.Pointer(bp + 16))
		} else {
			if errFilePtr != libc.UintptrFromInt32(0) {
				/*
				 * Set up the standard error output sink for the pipeline, if
				 * requested. Use a temporary file which is opened, then deleted.
				 * Could potentially just use pipe, but if it filled up it could
				 * cause the pipeline to deadlock: we'd be waiting for processes
				 * to complete before reading stderr, and processes couldn't
				 * complete because stderr was backed up.
				 */
				errorFile = XTclpCreateTempFile(tls, libc.UintptrFromInt32(0))
				if errorFile == libc.UintptrFromInt32(0) {
					XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+56911, libc.VaList(bp+304, XTcl_PosixError(tls, interp))))
					goto error
				}
				*(*TTclFile)(unsafe.Pointer(errFilePtr)) = errorFile
			} else {
				/*
				 * Errors from the pipeline go to stderr.
				 */
				channel = XTcl_GetStdChannel(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(3))
				if channel != 0 {
					errorFile = XTclpMakeFile(tls, channel, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2))
					if errorFile != libc.UintptrFromInt32(0) {
						*(*int32)(unsafe.Pointer(bp + 36)) = int32(1)
					}
				}
			}
		}
	}
	/*
	 * Scan through the argc array, creating a process for each group of
	 * arguments between the "|" characters.
	 */
	XTcl_ReapDetachedProcs(tls)
	pidPtr = XTcl_Alloc(tls, libc.Uint64FromInt64(cmdCount)*uint64(8))
	curInFile = *(*TTclFile)(unsafe.Pointer(bp))
	i = 0
	for {
		if !(i < argc) {
			break
		}
		/*
		 * Convert the program name into native form.
		 */
		if XTcl_TranslateFileName(tls, interp, *(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)), bp+48) == libc.UintptrFromInt32(0) {
			goto error
		}
		/*
		 * Find the end of the current segment of the pipeline.
		 */
		joinThisError = 0
		lastArg = i
		for {
			if !(lastArg < argc) {
				break
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(lastArg)*8))))) != int32('|') {
				goto _9
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(lastArg)*8)) + 1))) == int32('\000') {
				break
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(lastArg)*8)) + 1))) == int32('&') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(lastArg)*8)) + 2))) == int32('\000') {
				joinThisError = int32(1)
				break
			}
			goto _9
		_9:
			;
			lastArg++
		}
		/*
		 * If this is the last segment, use the specified outputFile.
		 * Otherwise create an intermediate pipe. pipeIn will become the
		 * curInFile for the next segment of the pipe.
		 */
		if lastArg == argc {
			*(*TTclFile)(unsafe.Pointer(bp + 280)) = *(*TTclFile)(unsafe.Pointer(bp + 16))
		} else {
			*(*uintptr)(unsafe.Pointer(argv + uintptr(lastArg)*8)) = libc.UintptrFromInt32(0)
			if XTclpCreatePipe(tls, bp+272, bp+280) == 0 {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+56954, libc.VaList(bp+304, XTcl_PosixError(tls, interp))))
				goto error
			}
		}
		if joinThisError != 0 {
			curErrFile = *(*TTclFile)(unsafe.Pointer(bp + 280))
		} else {
			curErrFile = errorFile
		}
		/*
		 * Restore argv[i], since a caller wouldn't expect the contents of
		 * argv to be modified.
		 */
		oldName = *(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8))
		*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)) = (*TTcl_DString)(unsafe.Pointer(bp + 48)).Fstring1
		result = _TclpCreateProcess(tls, interp, libc.Uint64FromInt64(lastArg-i), argv+uintptr(i)*8, curInFile, *(*TTclFile)(unsafe.Pointer(bp + 280)), curErrFile, bp+288)
		*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)) = oldName
		if result != TCL_OK {
			goto error
		}
		XTcl_DStringFree(tls, bp+48)
		*(*TTcl_Pid)(unsafe.Pointer(pidPtr + uintptr(numPids)*8)) = *(*TTcl_Pid)(unsafe.Pointer(bp + 288))
		numPids++
		XTclProcessCreated(tls, *(*TTcl_Pid)(unsafe.Pointer(bp + 288)))
		/*
		 * Close off our copies of file descriptors that were set up for this
		 * child, then set up the input for the next child.
		 */
		if curInFile != libc.UintptrFromInt32(0) && curInFile != *(*TTclFile)(unsafe.Pointer(bp)) {
			XTclpCloseFile(tls, curInFile)
		}
		curInFile = *(*TTclFile)(unsafe.Pointer(bp + 272))
		*(*TTclFile)(unsafe.Pointer(bp + 272)) = libc.UintptrFromInt32(0)
		if *(*TTclFile)(unsafe.Pointer(bp + 280)) != libc.UintptrFromInt32(0) && *(*TTclFile)(unsafe.Pointer(bp + 280)) != *(*TTclFile)(unsafe.Pointer(bp + 16)) {
			XTclpCloseFile(tls, *(*TTclFile)(unsafe.Pointer(bp + 280)))
		}
		*(*TTclFile)(unsafe.Pointer(bp + 280)) = libc.UintptrFromInt32(0)
		goto _8
	_8:
		;
		i = lastArg + int64(1)
	}
	*(*uintptr)(unsafe.Pointer(pidArrayPtr)) = pidPtr
	/*
	 * All done. Cleanup open files lying around and then return.
	 */
	goto cleanup
cleanup:
	;
	XTcl_DStringFree(tls, bp+48)
	if *(*int32)(unsafe.Pointer(bp + 8)) != 0 {
		XTclpCloseFile(tls, *(*TTclFile)(unsafe.Pointer(bp)))
	} else {
		if *(*int32)(unsafe.Pointer(bp + 12)) != 0 {
		}
	}
	if *(*int32)(unsafe.Pointer(bp + 24)) != 0 {
		XTclpCloseFile(tls, *(*TTclFile)(unsafe.Pointer(bp + 16)))
	} else {
		if *(*int32)(unsafe.Pointer(bp + 28)) != 0 {
		}
	}
	if *(*int32)(unsafe.Pointer(bp + 32)) != 0 {
		XTclpCloseFile(tls, errorFile)
	} else {
		if *(*int32)(unsafe.Pointer(bp + 36)) != 0 {
		}
	}
	return numPids
	/*
	 * An error occurred. There could have been extra files open, such as
	 * pipes between children. Clean them all up. Detach any child processes
	 * that have been created.
	 */
	goto error
error:
	;
	if *(*TTclFile)(unsafe.Pointer(bp + 272)) != libc.UintptrFromInt32(0) {
		XTclpCloseFile(tls, *(*TTclFile)(unsafe.Pointer(bp + 272)))
	}
	if *(*TTclFile)(unsafe.Pointer(bp + 280)) != libc.UintptrFromInt32(0) && *(*TTclFile)(unsafe.Pointer(bp + 280)) != *(*TTclFile)(unsafe.Pointer(bp + 16)) {
		XTclpCloseFile(tls, *(*TTclFile)(unsafe.Pointer(bp + 280)))
	}
	if curInFile != libc.UintptrFromInt32(0) && curInFile != *(*TTclFile)(unsafe.Pointer(bp)) {
		XTclpCloseFile(tls, curInFile)
	}
	if inPipePtr != libc.UintptrFromInt32(0) && *(*TTclFile)(unsafe.Pointer(inPipePtr)) != libc.UintptrFromInt32(0) {
		XTclpCloseFile(tls, *(*TTclFile)(unsafe.Pointer(inPipePtr)))
		*(*TTclFile)(unsafe.Pointer(inPipePtr)) = libc.UintptrFromInt32(0)
	}
	if outPipePtr != libc.UintptrFromInt32(0) && *(*TTclFile)(unsafe.Pointer(outPipePtr)) != libc.UintptrFromInt32(0) {
		XTclpCloseFile(tls, *(*TTclFile)(unsafe.Pointer(outPipePtr)))
		*(*TTclFile)(unsafe.Pointer(outPipePtr)) = libc.UintptrFromInt32(0)
	}
	if errFilePtr != libc.UintptrFromInt32(0) && *(*TTclFile)(unsafe.Pointer(errFilePtr)) != libc.UintptrFromInt32(0) {
		XTclpCloseFile(tls, *(*TTclFile)(unsafe.Pointer(errFilePtr)))
		*(*TTclFile)(unsafe.Pointer(errFilePtr)) = libc.UintptrFromInt32(0)
	}
	if pidPtr != libc.UintptrFromInt32(0) {
		i = 0
		for {
			if !(i < numPids) {
				break
			}
			if *(*TTcl_Pid)(unsafe.Pointer(pidPtr + uintptr(i)*8)) != uintptr(-libc.Int32FromInt32(1)) {
				XTcl_DetachPids(tls, int64(1), pidPtr+uintptr(i)*8)
			}
			goto _10
		_10:
			;
			i++
		}
		XTclpFree(tls, pidPtr)
	}
	numPids = int64(-int32(1))
	goto cleanup
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_OpenCommandChannel --
 *
 *	Opens an I/O channel to one or more subprocesses specified by argc and
 *	argv. The flags argument determines the disposition of the stdio
 *	handles. If the TCL_STDIN flag is set then the standard input for the
 *	first subprocess will be tied to the channel: writing to the channel
 *	will provide input to the subprocess. If TCL_STDIN is not set, then
 *	standard input for the first subprocess will be the same as this
 *	application's standard input. If TCL_STDOUT is set then standard
 *	output from the last subprocess can be read from the channel;
 *	otherwise it goes to this application's standard output. If TCL_STDERR
 *	is set, standard error output for all subprocesses is returned to the
 *	channel and results in an error when the channel is closed; otherwise
 *	it goes to this application's standard error. If TCL_ENFORCE_MODE is
 *	not set, then argc and argv can redirect the stdio handles to override
 *	TCL_STDIN, TCL_STDOUT, and TCL_STDERR; if it is set, then it is an
 *	error for argc and argv to override stdio channels for which
 *	TCL_STDIN, TCL_STDOUT, and TCL_STDERR have been set.
 *
 * Results:
 *	A new command channel, or NULL on failure with an error message left
 *	in interp.
 *
 * Side effects:
 *	Creates processes, opens pipes.
 *
 *----------------------------------------------------------------------
 */

func XTcl_OpenCommandChannel(tls *libc.TLS, interp uintptr, argc TTcl_Size, argv uintptr, flags int32) (r TTcl_Channel) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* Or'ed combination of TCL_STDIN, TCL_STDOUT,
	 * TCL_STDERR, and TCL_ENFORCE_MODE. */
	var channel TTcl_Channel
	var errFilePtr, inPipePtr, outPipePtr, v3, v4, v5 uintptr
	var numPids TTcl_Size
	var v1, v2 TTclFile
	var _ /* errFile at bp+16 */ TTclFile
	var _ /* inPipe at bp+0 */ TTclFile
	var _ /* outPipe at bp+8 */ TTclFile
	var _ /* pidPtr at bp+24 */ uintptr
	_, _, _, _, _, _, _, _, _, _ = channel, errFilePtr, inPipePtr, numPids, outPipePtr, v1, v2, v3, v4, v5
	*(*uintptr)(unsafe.Pointer(bp + 24)) = libc.UintptrFromInt32(0)
	v2 = libc.UintptrFromInt32(0)
	*(*TTclFile)(unsafe.Pointer(bp + 16)) = v2
	v1 = v2
	*(*TTclFile)(unsafe.Pointer(bp + 8)) = v1
	*(*TTclFile)(unsafe.Pointer(bp)) = v1
	if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
		v3 = bp
	} else {
		v3 = libc.UintptrFromInt32(0)
	}
	inPipePtr = v3
	if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
		v4 = bp + 8
	} else {
		v4 = libc.UintptrFromInt32(0)
	}
	outPipePtr = v4
	if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(3)) != 0 {
		v5 = bp + 16
	} else {
		v5 = libc.UintptrFromInt32(0)
	}
	errFilePtr = v5
	numPids = XTclCreatePipeline(tls, interp, argc, argv, bp+24, inPipePtr, outPipePtr, errFilePtr)
	if numPids < 0 {
		goto error
	}
	/*
	 * Verify that the pipes that were created satisfy the readable/writable
	 * constraints.
	 */
	if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(4)) != 0 {
		if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 && *(*TTclFile)(unsafe.Pointer(bp + 8)) == libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+56979, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+56543, __ccgo_ts+57042, libc.UintptrFromInt32(0)))
			goto error
		}
		if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 && *(*TTclFile)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+57054, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+56543, __ccgo_ts+57042, libc.UintptrFromInt32(0)))
			goto error
		}
	}
	channel = XTclpCreateCommandChannel(tls, *(*TTclFile)(unsafe.Pointer(bp + 8)), *(*TTclFile)(unsafe.Pointer(bp)), *(*TTclFile)(unsafe.Pointer(bp + 16)), libc.Uint64FromInt64(numPids), *(*uintptr)(unsafe.Pointer(bp + 24)))
	if channel == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+57114, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+56543, __ccgo_ts+57152, libc.UintptrFromInt32(0)))
		goto error
	}
	return channel
	goto error
error:
	;
	if *(*uintptr)(unsafe.Pointer(bp + 24)) != 0 {
		XTcl_DetachPids(tls, numPids, *(*uintptr)(unsafe.Pointer(bp + 24)))
		XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 24)))
	}
	if *(*TTclFile)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
		XTclpCloseFile(tls, *(*TTclFile)(unsafe.Pointer(bp)))
	}
	if *(*TTclFile)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) {
		XTclpCloseFile(tls, *(*TTclFile)(unsafe.Pointer(bp + 8)))
	}
	if *(*TTclFile)(unsafe.Pointer(bp + 16)) != libc.UintptrFromInt32(0) {
		XTclpCloseFile(tls, *(*TTclFile)(unsafe.Pointer(bp + 16)))
	}
	return libc.UintptrFromInt32(0)
}

/*
 * Each invocation of the "package ifneeded" command creates a structure of
 * the following type, which is used to load the package into the interpreter
 * if it is requested with a "package require" command.
 */

type TPkgAvail = struct {
	Fversion  uintptr
	Fscript   uintptr
	FpkgIndex uintptr
	FnextPtr  uintptr
}

type TPkgName = struct {
	FnextPtr uintptr
}

type TPkgFiles = struct {
	Fnames uintptr
	Ftable TTcl_HashTable
}

/*
 * For each package that is known in any way to an interpreter, there is one
 * record of the following type. These records are stored in the
 * "packageTable" hash table in the interpreter, keyed by package name such as
 * "Tk" (no version number).
 */

type TPackage = struct {
	Fversion    uintptr
	FavailPtr   uintptr
	FclientData uintptr
}

type TRequire = struct {
	FclientDataPtr    uintptr
	Fname             uintptr
	FpkgPtr           uintptr
	FversionToProvide uintptr
}

type TRequireProcArgs = struct {
	Fname          uintptr
	FclientDataPtr uintptr
}

/*
 * Helper macros.
 */

/*
 *----------------------------------------------------------------------
 *
 * Tcl_PkgProvide / Tcl_PkgProvideEx --
 *
 *	This function is invoked to declare that a particular version of a
 *	particular package is now present in an interpreter. There must not be
 *	any other version of this package already provided in the interpreter.
 *
 * Results:
 *	Normally returns TCL_OK; if there is already another version of the
 *	package loaded then TCL_ERROR is returned and an error message is left
 *	in the interp's result.
 *
 * Side effects:
 *	The interpreter remembers that this package is available, so that no
 *	other version of the package may be provided for the interpreter.
 *
 *----------------------------------------------------------------------
 */

func XTcl_PkgProvide(tls *libc.TLS, interp uintptr, name uintptr, version uintptr) (r int32) {
	/* Version string for package. */
	return XTcl_PkgProvideEx(tls, interp, name, version, libc.UintptrFromInt32(0))
}

func XTcl_PkgProvideEx(tls *libc.TLS, interp uintptr, name uintptr, version uintptr, clientData uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* clientdata for this package (normally used
	 * for C callback function table) */
	var pkgPtr uintptr
	var res int32
	var _ /* pvi at bp+0 */ uintptr
	var _ /* vi at bp+8 */ uintptr
	_, _ = pkgPtr, res
	pkgPtr = _FindPackage(tls, interp, name)
	if (*TPackage)(unsafe.Pointer(pkgPtr)).Fversion == libc.UintptrFromInt32(0) {
		(*TPackage)(unsafe.Pointer(pkgPtr)).Fversion = XTcl_NewStringObj(tls, version, int64(-int32(1)))
		(*TTcl_Obj)(unsafe.Pointer((*TPackage)(unsafe.Pointer(pkgPtr)).Fversion)).FrefCount++
		(*TPackage)(unsafe.Pointer(pkgPtr)).FclientData = clientData
		return TCL_OK
	}
	if _CheckVersionAndConvert(tls, interp, XTcl_GetStringFromObj(tls, (*TPackage)(unsafe.Pointer(pkgPtr)).Fversion, libc.UintptrFromInt32(0)), bp, libc.UintptrFromInt32(0)) != TCL_OK {
		return int32(TCL_ERROR)
	} else {
		if _CheckVersionAndConvert(tls, interp, version, bp+8, libc.UintptrFromInt32(0)) != TCL_OK {
			XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp)))
			return int32(TCL_ERROR)
		}
	}
	res = _CompareVersions(tls, *(*uintptr)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 8)), libc.UintptrFromInt32(0))
	XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp)))
	XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
	if res == 0 {
		if clientData != libc.UintptrFromInt32(0) {
			(*TPackage)(unsafe.Pointer(pkgPtr)).FclientData = clientData
		}
		return TCL_OK
	}
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+57159, libc.VaList(bp+24, name, XTcl_GetStringFromObj(tls, (*TPackage)(unsafe.Pointer(pkgPtr)).Fversion, libc.UintptrFromInt32(0)), version)))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+57219, __ccgo_ts+57227, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_PkgRequire / Tcl_PkgRequireEx / Tcl_PkgRequireProc --
 *
 *	This function is called by code that depends on a particular version
 *	of a particular package. If the package is not already provided in the
 *	interpreter, this function invokes a Tcl script to provide it. If the
 *	package is already provided, this function makes sure that the
 *	caller's needs don't conflict with the version that is present.
 *
 * Results:
 *	If successful, returns the version string for the currently provided
 *	version of the package, which may be different from the "version"
 *	argument. If the caller's requirements cannot be met (e.g. the version
 *	requested conflicts with a currently provided version, or the required
 *	version cannot be found, or the script to provide the required version
 *	generates an error), NULL is returned and an error message is left in
 *	the interp's result.
 *
 * Side effects:
 *	The script from some previous "package ifneeded" command may be
 *	invoked to provide the package.
 *
 *----------------------------------------------------------------------
 */

func _PkgFilesCleanupProc(tls *libc.TLS, clientData uintptr, dummy229 uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _objPtr, entry, name, obj, pkgFiles, v2 uintptr
	var v1 TTcl_Size
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _, _ = _objPtr, entry, name, obj, pkgFiles, v1, v2
	pkgFiles = clientData
	for (*TPkgFiles)(unsafe.Pointer(pkgFiles)).Fnames != 0 {
		name = (*TPkgFiles)(unsafe.Pointer(pkgFiles)).Fnames
		(*TPkgFiles)(unsafe.Pointer(pkgFiles)).Fnames = (*TPkgName)(unsafe.Pointer(name)).FnextPtr
		XTclpFree(tls, name)
	}
	entry = XTcl_FirstHashEntry(tls, pkgFiles+8, bp)
	for entry != 0 {
		obj = (*TTcl_HashEntry)(unsafe.Pointer(entry)).FclientData
		_objPtr = obj
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		entry = XTcl_NextHashEntry(tls, bp)
	}
	XTcl_DeleteHashTable(tls, pkgFiles+8)
	XTclpFree(tls, pkgFiles)
	return
}

func XTclInitPkgFiles(tls *libc.TLS, interp uintptr) (r uintptr) {
	var pkgFiles uintptr
	_ = pkgFiles
	/*
	 * If assocdata "tclPkgFiles" doesn't exist yet, create it.
	 */
	pkgFiles = XTcl_GetAssocData(tls, interp, __ccgo_ts+19053, libc.UintptrFromInt32(0))
	if !(pkgFiles != 0) {
		pkgFiles = XTcl_Alloc(tls, uint64(112))
		(*TPkgFiles)(unsafe.Pointer(pkgFiles)).Fnames = libc.UintptrFromInt32(0)
		XTcl_InitHashTable(tls, pkgFiles+8, TCL_STRING_KEYS)
		XTcl_SetAssocData(tls, interp, __ccgo_ts+19053, __ccgo_fp(_PkgFilesCleanupProc), pkgFiles)
	}
	return pkgFiles
}

func XTclPkgFileSeen(tls *libc.TLS, interp uintptr, fileName uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var cachePtr, entry, list, name, pkgFiles, table uintptr
	var v1 bool
	var _ /* isNew at bp+0 */ int32
	_, _, _, _, _, _, _ = cachePtr, entry, list, name, pkgFiles, table, v1
	pkgFiles = XTcl_GetAssocData(tls, interp, __ccgo_ts+19053, libc.UintptrFromInt32(0))
	if pkgFiles != 0 && (*TPkgFiles)(unsafe.Pointer(pkgFiles)).Fnames != 0 {
		name = (*TPkgFiles)(unsafe.Pointer(pkgFiles)).Fnames + 8
		table = pkgFiles + 8
		entry = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(table)).FcreateProc})))(tls, table, name, bp)
		if *(*int32)(unsafe.Pointer(bp)) != 0 {
			if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				list = XTclThreadAllocObj(tls)
			} else {
				list = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(list + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(list)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(list)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(list)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(list)).FtypePtr = libc.UintptrFromInt32(0)
			(*TTcl_HashEntry)(unsafe.Pointer(entry)).FclientData = list
			(*TTcl_Obj)(unsafe.Pointer(list)).FrefCount++
		} else {
			list = (*TTcl_HashEntry)(unsafe.Pointer(entry)).FclientData
		}
		XTcl_ListObjAppendElement(tls, interp, list, XTcl_NewStringObj(tls, fileName, int64(-int32(1))))
	}
}

func XTcl_PkgRequire(tls *libc.TLS, interp uintptr, name uintptr, version uintptr, exact int32) (r uintptr) {
	/* Non-zero means that only the particular
	 * version given is acceptable. Zero means use
	 * the latest compatible version. */
	return XTcl_PkgRequireEx(tls, interp, name, version, exact, libc.UintptrFromInt32(0))
}

func XTcl_PkgRequireEx(tls *libc.TLS, interp uintptr, name uintptr, version uintptr, exact int32, clientDataPtr uintptr) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Used to return the client data for this
	 * package. If it is NULL then the client data
	 * is not returned. This is unchanged if this
	 * call fails for any reason. */
	var cachePtr, result, v2 uintptr
	var v1 TTcl_Size
	var v3 bool
	var _ /* ov at bp+0 */ uintptr
	_, _, _, _, _ = cachePtr, result, v1, v2, v3
	result = libc.UintptrFromInt32(0)
	/*
	 * If an attempt is being made to load this into a standalone executable
	 * on a platform where backlinking is not supported then this must be a
	 * shared version of Tcl (Otherwise the load would have failed). Detect
	 * this situation by checking that this library has been correctly
	 * initialised. If it has not been then return immediately as nothing will
	 * work.
	 */
	if XtclEmptyStringRep == libc.UintptrFromInt32(0) {
		/*
		 * OK, so what's going on here?
		 *
		 * First, what are we doing? We are performing a check on behalf of
		 * one particular caller, Tcl_InitStubs(). When a package is stub-
		 * enabled, it is statically linked to libtclstub.a, which contains a
		 * copy of Tcl_InitStubs(). When a stub-enabled package is loaded, its
		 * *_Init() function is supposed to call Tcl_InitStubs() before
		 * calling any other functions in the Tcl library. The first Tcl
		 * function called by Tcl_InitStubs() through the stub table is
		 * Tcl_PkgRequireEx(), so this code right here is the first code that
		 * is part of the original Tcl library in the executable that gets
		 * executed on behalf of a newly loaded stub-enabled package.
		 *
		 * One easy error for the developer/builder of a stub-enabled package
		 * to make is to forget to define USE_TCL_STUBS when compiling the
		 * package. When that happens, the package will contain symbols that
		 * are references to the Tcl library, rather than function pointers
		 * referencing the stub table. On platforms that lack backlinking,
		 * those unresolved references may cause the loading of the package to
		 * also load a second copy of the Tcl library, leading to all kinds of
		 * trouble. We would like to catch that error and report a useful
		 * message back to the user. That's what we're doing.
		 *
		 * Second, how does this work? If we reach this point, then the global
		 * variable tclEmptyStringRep has the value NULL. Compare that with
		 * the definition of tclEmptyStringRep near the top of this file.  It
		 * clearly should not have the value NULL; it should point to the char
		 * tclEmptyString. If we see it having the value NULL, then somehow we
		 * are seeing a Tcl library that isn't completely initialized, and
		 * that's an indicator for the error condition described above.
		 * (Further explanation is welcome.)
		 *
		 * Third, so what do we do about it? This situation indicates the
		 * package we just loaded wasn't properly compiled to be stub-enabled,
		 * yet it thinks it is stub-enabled (it called Tcl_InitStubs()). We
		 * want to report that the package just loaded is broken, so we want
		 * to place an error message in the interpreter result and return NULL
		 * to indicate failure to Tcl_InitStubs() so that it will also fail.
		 * (Further explanation why we don't want to Tcl_Panic() is welcome.
		 * After all, two Tcl libraries can't be a good thing!)
		 *
		 * Trouble is that's going to be tricky. We're now using a Tcl library
		 * that's not fully initialized. Functions in it may not work
		 * reliably, so be very careful about adding any other calls here
		 * without checking how they behave when initialization is incomplete.
		 */
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+57243, libc.VaList(bp+16, name)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+57219, __ccgo_ts+57341, libc.UintptrFromInt32(0)))
		return libc.UintptrFromInt32(0)
	}
	/*
	 * Translate between old and new API, and defer to the new function.
	 */
	if version == libc.UintptrFromInt32(0) {
		if XTcl_PkgRequireProc(tls, interp, name, 0, libc.UintptrFromInt32(0), clientDataPtr) == TCL_OK {
			result = XTcl_GetStringFromObj(tls, XTcl_GetObjResult(tls, interp), libc.UintptrFromInt32(0))
			XTcl_ResetResult(tls, interp)
		}
	} else {
		if exact != 0 && TCL_OK != _CheckVersionAndConvert(tls, interp, version, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0)) {
			return libc.UintptrFromInt32(0)
		}
		*(*uintptr)(unsafe.Pointer(bp)) = XTcl_NewStringObj(tls, version, int64(-int32(1)))
		if exact != 0 {
			XTcl_AppendStringsToObj(tls, *(*uintptr)(unsafe.Pointer(bp)), libc.VaList(bp+16, __ccgo_ts+6319, version, libc.UintptrFromInt32(0)))
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FrefCount++
		if XTcl_PkgRequireProc(tls, interp, name, int64(1), bp, clientDataPtr) == TCL_OK {
			result = XTcl_GetStringFromObj(tls, XTcl_GetObjResult(tls, interp), libc.UintptrFromInt32(0))
			XTcl_ResetResult(tls, interp)
		}
		v2 = *(*uintptr)(unsafe.Pointer(bp))
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if !(v1 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Flength = int64(-libc.Int32FromInt32(1))
				if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp)))
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(bp))
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(bp)))
			}
		}
	}
	return result
}

func XTcl_PkgRequireProc(tls *libc.TLS, interp uintptr, name uintptr, reqc TTcl_Size, reqv uintptr, clientDataPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _ /* args at bp+0 */ TRequireProcArgs
	(*(*TRequireProcArgs)(unsafe.Pointer(bp))).Fname = name
	(*(*TRequireProcArgs)(unsafe.Pointer(bp))).FclientDataPtr = clientDataPtr
	return XTcl_NRCallObjProc(tls, interp, __ccgo_fp(_TclNRPkgRequireProc), bp, reqc, reqv)
}

func _TclNRPkgRequireProc(tls *libc.TLS, clientData uintptr, interp uintptr, reqc int32, reqv uintptr) (r int32) {
	var args uintptr
	_ = args
	args = clientData
	XTcl_NRAddCallback(tls, interp, __ccgo_fp(_PkgRequireCore), (*TRequireProcArgs)(unsafe.Pointer(args)).Fname, uintptr(int64(reqc)), reqv, (*TRequireProcArgs)(unsafe.Pointer(args)).FclientDataPtr)
	return TCL_OK
}

func _PkgRequireCore(tls *libc.TLS, data uintptr, interp uintptr, dummy462 int32) (r int32) {
	var code, reqc int32
	var name, reqPtr, reqv uintptr
	_, _, _, _, _ = code, name, reqPtr, reqc, reqv
	name = *(*uintptr)(unsafe.Pointer(data))
	reqc = int32(int64(*(*uintptr)(unsafe.Pointer(data + 1*8))))
	reqv = *(*uintptr)(unsafe.Pointer(data + 2*8))
	code = _CheckAllRequirements(tls, interp, reqc, reqv)
	if code != TCL_OK {
		return code
	}
	reqPtr = XTcl_Alloc(tls, uint64(32))
	XTcl_NRAddCallback(tls, interp, __ccgo_fp(_PkgRequireCoreCleanup), reqPtr, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	(*TRequire)(unsafe.Pointer(reqPtr)).FclientDataPtr = *(*uintptr)(unsafe.Pointer(data + 3*8))
	(*TRequire)(unsafe.Pointer(reqPtr)).Fname = name
	(*TRequire)(unsafe.Pointer(reqPtr)).FpkgPtr = _FindPackage(tls, interp, name)
	if (*TPackage)(unsafe.Pointer((*TRequire)(unsafe.Pointer(reqPtr)).FpkgPtr)).Fversion == libc.UintptrFromInt32(0) {
		XTcl_NRAddCallback(tls, interp, __ccgo_fp(_SelectPackage), reqPtr, uintptr(int64(reqc)), reqv, __ccgo_fp(_PkgRequireCoreStep1))
	} else {
		XTcl_NRAddCallback(tls, interp, __ccgo_fp(_PkgRequireCoreFinal), reqPtr, uintptr(int64(reqc)), reqv, libc.UintptrFromInt32(0))
	}
	return TCL_OK
}

func _PkgRequireCoreStep1(tls *libc.TLS, data uintptr, interp uintptr, dummy493 int32) (r int32) {
	bp := tls.Alloc(224)
	defer tls.Free(224)
	var name, reqPtr, reqv, script uintptr
	var reqc int32
	var _ /* command at bp+0 */ TTcl_DString
	_, _, _, _, _ = name, reqPtr, reqc, reqv, script
	reqPtr = *(*uintptr)(unsafe.Pointer(data))
	reqc = int32(int64(*(*uintptr)(unsafe.Pointer(data + 1*8))))
	reqv = *(*uintptr)(unsafe.Pointer(data + 2*8))
	name = (*TRequire)(unsafe.Pointer(reqPtr)).Fname
	/*
	 * If we've got the package in the DB already, go on to actually loading
	 * it.
	 */
	if (*TPackage)(unsafe.Pointer((*TRequire)(unsafe.Pointer(reqPtr)).FpkgPtr)).Fversion != libc.UintptrFromInt32(0) {
		XTcl_NRAddCallback(tls, interp, __ccgo_fp(_PkgRequireCoreFinal), reqPtr, uintptr(int64(reqc)), reqv, libc.UintptrFromInt32(0))
		return TCL_OK
	}
	/*
	 * The package is not in the database. If there is a "package unknown"
	 * command, invoke it.
	 */
	script = (*TInterp)(unsafe.Pointer(interp)).FpackageUnknown
	if script == libc.UintptrFromInt32(0) {
		/*
		 * No package unknown script. Move on to finalizing.
		 */
		XTcl_NRAddCallback(tls, interp, __ccgo_fp(_PkgRequireCoreFinal), reqPtr, uintptr(int64(reqc)), reqv, libc.UintptrFromInt32(0))
		return TCL_OK
	}
	/*
	 * Invoke the "package unknown" script synchronously.
	 */
	XTcl_DStringInit(tls, bp)
	XTcl_DStringAppend(tls, bp, script, int64(-int32(1)))
	XTcl_DStringAppendElement(tls, bp, name)
	_AddRequirementsToDString(tls, bp, reqc, reqv)
	XTcl_NRAddCallback(tls, interp, __ccgo_fp(_PkgRequireCoreStep2), reqPtr, uintptr(int64(reqc)), reqv, libc.UintptrFromInt32(0))
	XTcl_NREvalObj(tls, interp, XTcl_DStringToObj(tls, bp), int32(TCL_EVAL_GLOBAL))
	return TCL_OK
}

func _PkgRequireCoreStep2(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var name, reqPtr, reqv uintptr
	var reqc int32
	_, _, _, _ = name, reqPtr, reqc, reqv
	reqPtr = *(*uintptr)(unsafe.Pointer(data))
	reqc = int32(int64(*(*uintptr)(unsafe.Pointer(data + 1*8))))
	reqv = *(*uintptr)(unsafe.Pointer(data + 2*8))
	name = (*TRequire)(unsafe.Pointer(reqPtr)).Fname /* Name of desired package. */
	if result != TCL_OK && result != int32(TCL_ERROR) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+57351, libc.VaList(bp+8, result)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+57219, __ccgo_ts+57371, libc.UintptrFromInt32(0)))
		result = int32(TCL_ERROR)
	}
	if result == int32(TCL_ERROR) {
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+57381, int64(-int32(1))))
		return result
	}
	XTcl_ResetResult(tls, interp)
	/*
	 * pkgPtr may now be invalid, so refresh it.
	 */
	(*TRequire)(unsafe.Pointer(reqPtr)).FpkgPtr = _FindPackage(tls, interp, name)
	XTcl_NRAddCallback(tls, interp, __ccgo_fp(_SelectPackage), reqPtr, uintptr(int64(reqc)), reqv, __ccgo_fp(_PkgRequireCoreFinal))
	return TCL_OK
}

func _PkgRequireCoreFinal(tls *libc.TLS, data uintptr, interp uintptr, dummy583 int32) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var clientDataPtr, name, ptr, reqPtr, reqv uintptr
	var reqc, satisfies int32
	var _ /* pkgVersionI at bp+0 */ uintptr
	_, _, _, _, _, _, _ = clientDataPtr, name, ptr, reqPtr, reqc, reqv, satisfies
	reqPtr = *(*uintptr)(unsafe.Pointer(data))
	reqc = int32(int64(*(*uintptr)(unsafe.Pointer(data + 1*8))))
	reqv = *(*uintptr)(unsafe.Pointer(data + 2*8))
	clientDataPtr = (*TRequire)(unsafe.Pointer(reqPtr)).FclientDataPtr
	name = (*TRequire)(unsafe.Pointer(reqPtr)).Fname /* Name of desired package. */
	if (*TPackage)(unsafe.Pointer((*TRequire)(unsafe.Pointer(reqPtr)).FpkgPtr)).Fversion == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+57413, libc.VaList(bp+16, name)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+57219, __ccgo_ts+57435, libc.UintptrFromInt32(0)))
		_AddRequirementsToResult(tls, interp, reqc, reqv)
		return int32(TCL_ERROR)
	}
	/*
	 * Ensure that the provided version meets the current requirements.
	 */
	if reqc != 0 {
		_CheckVersionAndConvert(tls, interp, XTcl_GetStringFromObj(tls, (*TPackage)(unsafe.Pointer((*TRequire)(unsafe.Pointer(reqPtr)).FpkgPtr)).Fversion, libc.UintptrFromInt32(0)), bp, libc.UintptrFromInt32(0))
		satisfies = _SomeRequirementSatisfied(tls, *(*uintptr)(unsafe.Pointer(bp)), reqc, reqv)
		XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp)))
		if !(satisfies != 0) {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+57443, libc.VaList(bp+16, name, XTcl_GetStringFromObj(tls, (*TPackage)(unsafe.Pointer((*TRequire)(unsafe.Pointer(reqPtr)).FpkgPtr)).Fversion, libc.UintptrFromInt32(0)))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+57219, __ccgo_ts+57227, libc.UintptrFromInt32(0)))
			_AddRequirementsToResult(tls, interp, reqc, reqv)
			return int32(TCL_ERROR)
		}
	}
	if clientDataPtr != 0 {
		ptr = clientDataPtr
		*(*uintptr)(unsafe.Pointer(ptr)) = (*TPackage)(unsafe.Pointer((*TRequire)(unsafe.Pointer(reqPtr)).FpkgPtr)).FclientData
	}
	XTcl_SetObjResult(tls, interp, (*TPackage)(unsafe.Pointer((*TRequire)(unsafe.Pointer(reqPtr)).FpkgPtr)).Fversion)
	return TCL_OK
}

func _PkgRequireCoreCleanup(tls *libc.TLS, data uintptr, dummy634 uintptr, result int32) (r int32) {
	XTclpFree(tls, *(*uintptr)(unsafe.Pointer(data)))
	return result
}

func _SelectPackage(tls *libc.TLS, data uintptr, interp uintptr, dummy645 int32) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var availPtr, bestPtr, bestStablePtr, iPtr, name, pkgFiles, pkgName, pkgPtr, reqPtr, reqv, versionToProvide uintptr
	var reqc, res, res1, satisfies int32
	var _ /* availStable at bp+24 */ int32
	var _ /* availVersion at bp+0 */ uintptr
	var _ /* bestStableVersion at bp+16 */ uintptr
	var _ /* bestVersion at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = availPtr, bestPtr, bestStablePtr, iPtr, name, pkgFiles, pkgName, pkgPtr, reqPtr, reqc, reqv, res, res1, satisfies, versionToProvide
	reqPtr = *(*uintptr)(unsafe.Pointer(data))
	reqc = int32(int64(*(*uintptr)(unsafe.Pointer(data + 1*8))))
	reqv = *(*uintptr)(unsafe.Pointer(data + 2*8))
	name = (*TRequire)(unsafe.Pointer(reqPtr)).Fname
	pkgPtr = (*TRequire)(unsafe.Pointer(reqPtr)).FpkgPtr
	iPtr = interp
	/*
	 * Check whether we're already attempting to load some version of this
	 * package (circular dependency detection).
	 */
	if (*TPackage)(unsafe.Pointer(pkgPtr)).FclientData != libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+57492, libc.VaList(bp+40, name, (*TPackage)(unsafe.Pointer(pkgPtr)).FclientData, name)))
		_AddRequirementsToResult(tls, interp, reqc, reqv)
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+57219, __ccgo_ts+57558, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * The package isn't yet present. Search the list of available versions
	 * and invoke the script for the best available version. We are actually
	 * locating the best, and the best stable version. One of them is then
	 * chosen based on the selection mode.
	 */
	bestPtr = libc.UintptrFromInt32(0)
	bestStablePtr = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(bp + 8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(bp + 16)) = libc.UintptrFromInt32(0)
	availPtr = (*TPackage)(unsafe.Pointer(pkgPtr)).FavailPtr
	for {
		if !(availPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if _CheckVersionAndConvert(tls, interp, (*TPkgAvail)(unsafe.Pointer(availPtr)).Fversion, bp, bp+24) != TCL_OK {
			/*
			 * The provided version number has invalid syntax. This should not
			 * happen. This should have been caught by the 'package ifneeded'
			 * registering the package.
			 */
			goto _1
		}
		/*
		 * Check satisfaction of requirements before considering the current
		 * version further.
		 */
		if reqc > 0 {
			satisfies = _SomeRequirementSatisfied(tls, *(*uintptr)(unsafe.Pointer(bp)), reqc, reqv)
			if !(satisfies != 0) {
				XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp)))
				*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
				goto _1
			}
		}
		if !(bestPtr != libc.UintptrFromInt32(0)) {
			goto _2
		}
		res = _CompareVersions(tls, *(*uintptr)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 8)), libc.UintptrFromInt32(0))
		/*
		 * Note: Used internal reps in the comparison!
		 */
		if res > 0 {
			/*
			 * The version of the package sought is better than the
			 * currently selected version.
			 */
			XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
			*(*uintptr)(unsafe.Pointer(bp + 8)) = libc.UintptrFromInt32(0)
			goto newbest
		}
		goto _3
	_2:
		;
		goto newbest
	newbest:
		;
		/*
		 * We have found a version which is better than our max.
		 */
		bestPtr = availPtr
		_CheckVersionAndConvert(tls, interp, (*TPkgAvail)(unsafe.Pointer(bestPtr)).Fversion, bp+8, libc.UintptrFromInt32(0))
	_3:
		;
		if !(*(*int32)(unsafe.Pointer(bp + 24)) != 0) {
			XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp)))
			*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
			goto _1
		}
		if !(bestStablePtr != libc.UintptrFromInt32(0)) {
			goto _4
		}
		res1 = _CompareVersions(tls, *(*uintptr)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 16)), libc.UintptrFromInt32(0))
		/*
		 * Note: Used internal reps in the comparison!
		 */
		if res1 > 0 {
			/*
			 * This stable version of the package sought is better than
			 * the currently selected stable version.
			 */
			XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
			*(*uintptr)(unsafe.Pointer(bp + 16)) = libc.UintptrFromInt32(0)
			goto newstable
		}
		goto _5
	_4:
		;
		goto newstable
	newstable:
		;
		/*
		 * We have found a stable version which is better than our max
		 * stable.
		 */
		bestStablePtr = availPtr
		_CheckVersionAndConvert(tls, interp, (*TPkgAvail)(unsafe.Pointer(bestStablePtr)).Fversion, bp+16, libc.UintptrFromInt32(0))
	_5:
		;
		XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp)))
		*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
		goto _1
	_1:
		;
		availPtr = (*TPkgAvail)(unsafe.Pointer(availPtr)).FnextPtr
	} /* end for */
	/*
	 * Clean up memorized internal reps, if any.
	 */
	if *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) {
		XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
		*(*uintptr)(unsafe.Pointer(bp + 8)) = libc.UintptrFromInt32(0)
	}
	if *(*uintptr)(unsafe.Pointer(bp + 16)) != libc.UintptrFromInt32(0) {
		XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
		*(*uintptr)(unsafe.Pointer(bp + 16)) = libc.UintptrFromInt32(0)
	}
	/*
	 * Now choose a version among the two best. For 'latest' we simply take
	 * (actually keep) the best. For 'stable' we take the best stable, if
	 * there is any, or the best if there is nothing stable.
	 */
	if (*TInterp)(unsafe.Pointer(iPtr)).FpackagePrefer == int32(PKG_PREFER_STABLE) && bestStablePtr != libc.UintptrFromInt32(0) {
		bestPtr = bestStablePtr
	}
	if bestPtr == libc.UintptrFromInt32(0) {
		XTcl_NRAddCallback(tls, interp, *(*uintptr)(unsafe.Pointer(data + 3*8)), reqPtr, uintptr(int64(reqc)), reqv, libc.UintptrFromInt32(0))
	} else {
		/*
		 * We found an ifneeded script for the package. Be careful while
		 * executing it: this could cause reentrancy, so (a) protect the
		 * script itself from deletion and (b) don't assume that bestPtr will
		 * still exist when the script completes.
		 */
		versionToProvide = (*TPkgAvail)(unsafe.Pointer(bestPtr)).Fversion
		XTcl_Preserve(tls, versionToProvide)
		(*TPackage)(unsafe.Pointer(pkgPtr)).FclientData = versionToProvide
		pkgFiles = XTclInitPkgFiles(tls, interp)
		/*
		 * Push "ifneeded" package name in "tclPkgFiles" assocdata.
		 */
		pkgName = XTcl_Alloc(tls, uint64(libc.UintptrFromInt32(0)+8)+libc.Uint64FromInt32(1)+libc.Xstrlen(tls, name))
		(*TPkgName)(unsafe.Pointer(pkgName)).FnextPtr = (*TPkgFiles)(unsafe.Pointer(pkgFiles)).Fnames
		libc.Xstrcpy(tls, pkgName+8, name)
		(*TPkgFiles)(unsafe.Pointer(pkgFiles)).Fnames = pkgName
		if (*TPkgAvail)(unsafe.Pointer(bestPtr)).FpkgIndex != 0 {
			XTclPkgFileSeen(tls, interp, (*TPkgAvail)(unsafe.Pointer(bestPtr)).FpkgIndex)
		}
		(*TRequire)(unsafe.Pointer(reqPtr)).FversionToProvide = versionToProvide
		XTcl_NRAddCallback(tls, interp, __ccgo_fp(_SelectPackageFinal), reqPtr, uintptr(int64(reqc)), reqv, *(*uintptr)(unsafe.Pointer(data + 3*8)))
		XTcl_NREvalObj(tls, interp, XTcl_NewStringObj(tls, (*TPkgAvail)(unsafe.Pointer(bestPtr)).Fscript, int64(-int32(1))), int32(TCL_EVAL_GLOBAL))
	}
	return TCL_OK
}

func _SelectPackageFinal(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var _objPtr, cachePtr, cachePtr1, codePtr, name, pkgFiles, pkgName, reqPtr, reqv, versionToProvide, v2, v4, v7 uintptr
	var reqc, res int32
	var v1, v5 bool
	var v3, v6 TTcl_Size
	var _ /* pvi at bp+0 */ uintptr
	var _ /* vi at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, cachePtr1, codePtr, name, pkgFiles, pkgName, reqPtr, reqc, reqv, res, versionToProvide, v1, v2, v3, v4, v5, v6, v7
	reqPtr = *(*uintptr)(unsafe.Pointer(data))
	reqc = int32(int64(*(*uintptr)(unsafe.Pointer(data + 1*8))))
	reqv = *(*uintptr)(unsafe.Pointer(data + 2*8))
	name = (*TRequire)(unsafe.Pointer(reqPtr)).Fname
	versionToProvide = (*TRequire)(unsafe.Pointer(reqPtr)).FversionToProvide
	/*
	 * Pop the "ifneeded" package name from "tclPkgFiles" assocdata
	 */
	pkgFiles = XTcl_GetAssocData(tls, interp, __ccgo_ts+19053, libc.UintptrFromInt32(0))
	pkgName = (*TPkgFiles)(unsafe.Pointer(pkgFiles)).Fnames
	(*TPkgFiles)(unsafe.Pointer(pkgFiles)).Fnames = (*TPkgName)(unsafe.Pointer(pkgName)).FnextPtr
	XTclpFree(tls, pkgName)
	(*TRequire)(unsafe.Pointer(reqPtr)).FpkgPtr = _FindPackage(tls, interp, name)
	if result == TCL_OK {
		XTcl_ResetResult(tls, interp)
		if (*TPackage)(unsafe.Pointer((*TRequire)(unsafe.Pointer(reqPtr)).FpkgPtr)).Fversion == libc.UintptrFromInt32(0) {
			result = int32(TCL_ERROR)
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+57570, libc.VaList(bp+24, name, versionToProvide, name)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+57219, __ccgo_ts+57645, libc.UintptrFromInt32(0)))
		} else {
			if TCL_OK != _CheckVersionAndConvert(tls, interp, XTcl_GetStringFromObj(tls, (*TPackage)(unsafe.Pointer((*TRequire)(unsafe.Pointer(reqPtr)).FpkgPtr)).Fversion, libc.UintptrFromInt32(0)), bp, libc.UintptrFromInt32(0)) {
				result = int32(TCL_ERROR)
			} else {
				if _CheckVersionAndConvert(tls, interp, versionToProvide, bp+8, libc.UintptrFromInt32(0)) != TCL_OK {
					XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp)))
					result = int32(TCL_ERROR)
				} else {
					res = _CompareVersions(tls, *(*uintptr)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 8)), libc.UintptrFromInt32(0))
					XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp)))
					XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
					if res != 0 {
						result = int32(TCL_ERROR)
						XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+57656, libc.VaList(bp+24, name, versionToProvide, name, XTcl_GetStringFromObj(tls, (*TPackage)(unsafe.Pointer((*TRequire)(unsafe.Pointer(reqPtr)).FpkgPtr)).Fversion, libc.UintptrFromInt32(0)))))
						XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+57219, __ccgo_ts+57728, libc.UintptrFromInt32(0)))
					}
				}
			}
		}
	} else {
		if result != int32(TCL_ERROR) {
			if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				codePtr = XTclThreadAllocObj(tls)
			} else {
				codePtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(codePtr + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(codePtr)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(codePtr)).Fbytes = libc.UintptrFromInt32(0)
			*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(codePtr)).FinternalRep)) = int64(result)
			(*TTcl_Obj)(unsafe.Pointer(codePtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
			if (*TTcl_Obj)(unsafe.Pointer(codePtr)).Fbytes != 0 {
				v2 = (*TTcl_Obj)(unsafe.Pointer(codePtr)).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, codePtr, libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+57741, libc.VaList(bp+24, name, versionToProvide, v2)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+57219, __ccgo_ts+57371, libc.UintptrFromInt32(0)))
			v4 = codePtr
			v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
			*(*TTcl_Size)(unsafe.Pointer(v4))--
			if !(v3 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(codePtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(codePtr)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(codePtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(codePtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(codePtr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(codePtr)).Flength = int64(-libc.Int32FromInt32(1))
					if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
						cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v5 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, codePtr)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(codePtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = codePtr
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, codePtr)
				}
			}
			result = int32(TCL_ERROR)
		}
	}
	if result == int32(TCL_ERROR) {
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+57802, libc.VaList(bp+24, name, versionToProvide)))
	}
	XTcl_Release(tls, versionToProvide)
	if result != TCL_OK {
		/*
		 * Take a non-TCL_OK code from the script as an indication the package
		 * wasn't loaded properly, so the package system should not remember
		 * an improper load.
		 *
		 * This is consistent with our returning NULL. If we're not willing to
		 * tell our caller we got a particular version, we shouldn't store
		 * that version for telling future callers either.
		 */
		if (*TPackage)(unsafe.Pointer((*TRequire)(unsafe.Pointer(reqPtr)).FpkgPtr)).Fversion != libc.UintptrFromInt32(0) {
			_objPtr = (*TPackage)(unsafe.Pointer((*TRequire)(unsafe.Pointer(reqPtr)).FpkgPtr)).Fversion
			v7 = _objPtr
			v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
			*(*TTcl_Size)(unsafe.Pointer(v7))--
			if v6 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			(*TPackage)(unsafe.Pointer((*TRequire)(unsafe.Pointer(reqPtr)).FpkgPtr)).Fversion = libc.UintptrFromInt32(0)
		}
		(*TPackage)(unsafe.Pointer((*TRequire)(unsafe.Pointer(reqPtr)).FpkgPtr)).FclientData = libc.UintptrFromInt32(0)
		return result
	}
	XTcl_NRAddCallback(tls, interp, *(*uintptr)(unsafe.Pointer(data + 3*8)), reqPtr, uintptr(int64(reqc)), reqv, libc.UintptrFromInt32(0))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_PkgPresent / Tcl_PkgPresentEx --
 *
 *	Checks to see whether the specified package is present. If it is not
 *	then no additional action is taken.
 *
 * Results:
 *	If successful, returns the version string for the currently provided
 *	version of the package, which may be different from the "version"
 *	argument. If the caller's requirements cannot be met (e.g. the version
 *	requested conflicts with a currently provided version), NULL is
 *	returned and an error message is left in interp->result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_PkgPresent(tls *libc.TLS, interp uintptr, name uintptr, version uintptr, exact int32) (r uintptr) {
	/* Non-zero means that only the particular
	 * version given is acceptable. Zero means use
	 * the latest compatible version. */
	return XTcl_PkgPresentEx(tls, interp, name, version, exact, libc.UintptrFromInt32(0))
}

func XTcl_PkgPresentEx(tls *libc.TLS, interp uintptr, name uintptr, version uintptr, exact int32, clientDataPtr uintptr) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Used to return the client data for this
	 * package. If it is NULL then the client data
	 * is not returned. This is unchanged if this
	 * call fails for any reason. */
	var foundVersion, hPtr, iPtr, pkgPtr uintptr
	_, _, _, _ = foundVersion, hPtr, iPtr, pkgPtr
	iPtr = interp
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iPtr + 136)).FfindProc})))(tls, iPtr+136, name)
	if hPtr != 0 {
		pkgPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		if (*TPackage)(unsafe.Pointer(pkgPtr)).Fversion != libc.UintptrFromInt32(0) {
			/*
			 * At this point we know that the package is present. Make sure
			 * that the provided version meets the current requirement by
			 * calling Tcl_PkgRequireEx() to check for us.
			 */
			foundVersion = XTcl_PkgRequireEx(tls, interp, name, version, exact, clientDataPtr)
			if foundVersion == libc.UintptrFromInt32(0) {
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+57219, name, libc.UintptrFromInt32(0)))
			}
			return foundVersion
		}
	}
	if version != libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+57841, libc.VaList(bp+8, name, version)))
	} else {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+57870, libc.VaList(bp+8, name)))
	}
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+57219, name, libc.UintptrFromInt32(0)))
	return libc.UintptrFromInt32(0)
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * Tcl_PackageObjCmd --
//	 *
//	 *	This function is invoked to process the "package" Tcl command. See the
//	 *	user documentation for details on what it does.
//	 *
//	 * Results:
//	 *	A standard Tcl result.
//	 *
//	 * Side effects:
//	 *	See the user documentation.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func XTcl_PackageObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	return XTcl_NRCallObjProc(tls, interp, __ccgo_fp(XTclNRPackageObjCmd), clientData, int64(objc), objv)
}

func XTclNRPackageObjCmd(tls *libc.TLS, dummy1062 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(144)
	defer tls.Free(144) /* Argument objects. */
	var _objPtr, _objPtr1, argv2, argv3, argv4, availPtr, cachePtr, cachePtr1, entry, hPtr, iPtr, keyString, name, newobjv, obj, objvListPtr, ov, pkgFiles, pkgFiles1, pkgPtr, prevPtr, resultObj, resultObj1, tablePtr, version, v15, v17, v19, v21, v22, v23, v24, v26, v27, v30, v31, v32, v33, v34, v36, v37, v38, v40, v41, v42, v50, v51, v52, v54, v56 uintptr
	var exact, res, satisfies int32
	var i, v18, v20 TTcl_Size
	var v28, v35, v53 bool
	var v44, v45, v48, v49 int64
	var _ /* argv2i at bp+104 */ uintptr
	var _ /* argv3i at bp+72 */ uintptr
	var _ /* avi at bp+80 */ uintptr
	var _ /* iva at bp+40 */ uintptr
	var _ /* ivb at bp+48 */ uintptr
	var _ /* length at bp+64 */ TTcl_Size
	var _ /* length at bp+88 */ TTcl_Size
	var _ /* newObjvPtr at bp+56 */ uintptr
	var _ /* newPref at bp+96 */ int32
	var _ /* newobjc at bp+8 */ TTcl_Size
	var _ /* optionIndex at bp+0 */ int32
	var _ /* search at bp+16 */ TTcl_HashSearch
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, argv2, argv3, argv4, availPtr, cachePtr, cachePtr1, entry, exact, hPtr, i, iPtr, keyString, name, newobjv, obj, objvListPtr, ov, pkgFiles, pkgFiles1, pkgPtr, prevPtr, res, resultObj, resultObj1, satisfies, tablePtr, version, v15, v17, v18, v19, v20, v21, v22, v23, v24, v26, v27, v28, v30, v31, v32, v33, v34, v35, v36, v37, v38, v40, v41, v42, v44, v45, v48, v49, v50, v51, v52, v53, v54, v56
	iPtr = interp
	*(*uintptr)(unsafe.Pointer(bp + 40)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(bp + 48)) = libc.UintptrFromInt32(0)
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+57971)
		return int32(TCL_ERROR)
	}
	if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), uintptr(unsafe.Pointer(&_pkgOptions)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	switch *(*int32)(unsafe.Pointer(bp)) {
	case 0:
		goto _1
	case 1:
		goto _2
	case 2:
		goto _3
	case 3:
		goto _4
	case 5:
		goto _5
	case 6:
		goto _6
	case 7:
		goto _7
	case 8:
		goto _8
	case 4:
		goto _9
	case 9:
		goto _10
	case 10:
		goto _11
	case 11:
		goto _12
	default:
		goto _13
	}
	goto _14
_1:
	;
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+5344)
		return int32(TCL_ERROR)
	}
	pkgFiles = XTcl_GetAssocData(tls, interp, __ccgo_ts+19053, libc.UintptrFromInt32(0))
	if pkgFiles != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v15 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v15 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		entry = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(pkgFiles + 8)).FfindProc})))(tls, pkgFiles+8, v15)
		if entry != 0 {
			XTcl_SetObjResult(tls, interp, (*TTcl_HashEntry)(unsafe.Pointer(entry)).FclientData)
		}
	}
	goto _14
_2:
	;
	pkgFiles1 = XTcl_GetAssocData(tls, interp, __ccgo_ts+19053, libc.UintptrFromInt32(0))
	i = int64(2)
	for {
		if !(i < int64(objc)) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
			v17 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
		} else {
			v17 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		keyString = v17
		if pkgFiles1 != 0 {
			hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(pkgFiles1 + 8)).FfindProc})))(tls, pkgFiles1+8, keyString)
			if hPtr != 0 {
				obj = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
				XTcl_DeleteHashEntry(tls, hPtr)
				_objPtr = obj
				v19 = _objPtr
				v18 = *(*TTcl_Size)(unsafe.Pointer(v19))
				*(*TTcl_Size)(unsafe.Pointer(v19))--
				if v18 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
		}
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iPtr + 136)).FfindProc})))(tls, iPtr+136, keyString)
		if hPtr == libc.UintptrFromInt32(0) {
			goto _16
		}
		pkgPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		XTcl_DeleteHashEntry(tls, hPtr)
		if (*TPackage)(unsafe.Pointer(pkgPtr)).Fversion != libc.UintptrFromInt32(0) {
			_objPtr1 = (*TPackage)(unsafe.Pointer(pkgPtr)).Fversion
			v21 = _objPtr1
			v20 = *(*TTcl_Size)(unsafe.Pointer(v21))
			*(*TTcl_Size)(unsafe.Pointer(v21))--
			if v20 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
		}
		for (*TPackage)(unsafe.Pointer(pkgPtr)).FavailPtr != libc.UintptrFromInt32(0) {
			availPtr = (*TPackage)(unsafe.Pointer(pkgPtr)).FavailPtr
			(*TPackage)(unsafe.Pointer(pkgPtr)).FavailPtr = (*TPkgAvail)(unsafe.Pointer(availPtr)).FnextPtr
			XTcl_EventuallyFree(tls, (*TPkgAvail)(unsafe.Pointer(availPtr)).Fversion, libc.UintptrFromInt32(3))
			XTcl_EventuallyFree(tls, (*TPkgAvail)(unsafe.Pointer(availPtr)).Fscript, libc.UintptrFromInt32(3))
			if (*TPkgAvail)(unsafe.Pointer(availPtr)).FpkgIndex != 0 {
				XTcl_EventuallyFree(tls, (*TPkgAvail)(unsafe.Pointer(availPtr)).FpkgIndex, libc.UintptrFromInt32(3))
				(*TPkgAvail)(unsafe.Pointer(availPtr)).FpkgIndex = libc.UintptrFromInt32(0)
			}
			XTclpFree(tls, availPtr)
		}
		XTclpFree(tls, pkgPtr)
		goto _16
	_16:
		;
		i++
	}
	goto _14
_3:
	;
	if objc != int32(4) && objc != int32(5) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+57988)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes != 0 {
		v22 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes
	} else {
		v22 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0))
	}
	argv3 = v22
	if _CheckVersionAndConvert(tls, interp, argv3, bp+72, libc.UintptrFromInt32(0)) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
		v23 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
	} else {
		v23 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
	}
	argv2 = v23
	if objc == int32(4) {
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iPtr + 136)).FfindProc})))(tls, iPtr+136, argv2)
		if hPtr == libc.UintptrFromInt32(0) {
			XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 72)))
			return TCL_OK
		}
		pkgPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
	} else {
		pkgPtr = _FindPackage(tls, interp, argv2)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 64)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Flength
		v24 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes
	} else {
		v24 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), bp+64)
	}
	argv3 = v24
	availPtr = (*TPackage)(unsafe.Pointer(pkgPtr)).FavailPtr
	prevPtr = libc.UintptrFromInt32(0)
	for {
		if !(availPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if _CheckVersionAndConvert(tls, interp, (*TPkgAvail)(unsafe.Pointer(availPtr)).Fversion, bp+80, libc.UintptrFromInt32(0)) != TCL_OK {
			XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 72)))
			return int32(TCL_ERROR)
		}
		res = _CompareVersions(tls, *(*uintptr)(unsafe.Pointer(bp + 80)), *(*uintptr)(unsafe.Pointer(bp + 72)), libc.UintptrFromInt32(0))
		XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 80)))
		if res == 0 {
			if objc == int32(4) {
				XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 72)))
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, (*TPkgAvail)(unsafe.Pointer(availPtr)).Fscript, int64(-int32(1))))
				return TCL_OK
			}
			XTcl_EventuallyFree(tls, (*TPkgAvail)(unsafe.Pointer(availPtr)).Fscript, libc.UintptrFromInt32(3))
			if (*TPkgAvail)(unsafe.Pointer(availPtr)).FpkgIndex != 0 {
				XTcl_EventuallyFree(tls, (*TPkgAvail)(unsafe.Pointer(availPtr)).FpkgIndex, libc.UintptrFromInt32(3))
				(*TPkgAvail)(unsafe.Pointer(availPtr)).FpkgIndex = libc.UintptrFromInt32(0)
			}
			break
		}
		goto _25
	_25:
		;
		prevPtr = availPtr
		availPtr = (*TPkgAvail)(unsafe.Pointer(availPtr)).FnextPtr
	}
	XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 72)))
	if objc == int32(4) {
		return TCL_OK
	}
	if availPtr == libc.UintptrFromInt32(0) {
		availPtr = XTcl_Alloc(tls, uint64(32))
		(*TPkgAvail)(unsafe.Pointer(availPtr)).FpkgIndex = libc.UintptrFromInt32(0)
		(*TPkgAvail)(unsafe.Pointer(availPtr)).Fversion = XTcl_Alloc(tls, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 64))+int64(1)))
		libc.Xmemcpy(tls, (*TPkgAvail)(unsafe.Pointer(availPtr)).Fversion, argv3, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 64))+libc.Int64FromInt32(1)))
		if prevPtr == libc.UintptrFromInt32(0) {
			(*TPkgAvail)(unsafe.Pointer(availPtr)).FnextPtr = (*TPackage)(unsafe.Pointer(pkgPtr)).FavailPtr
			(*TPackage)(unsafe.Pointer(pkgPtr)).FavailPtr = availPtr
		} else {
			(*TPkgAvail)(unsafe.Pointer(availPtr)).FnextPtr = (*TPkgAvail)(unsafe.Pointer(prevPtr)).FnextPtr
			(*TPkgAvail)(unsafe.Pointer(prevPtr)).FnextPtr = availPtr
		}
	}
	if (*TInterp)(unsafe.Pointer(iPtr)).FscriptFile != 0 {
		if (*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FscriptFile)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 64)) = (*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FscriptFile)).Flength
			v26 = (*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FscriptFile)).Fbytes
		} else {
			v26 = XTcl_GetStringFromObj(tls, (*TInterp)(unsafe.Pointer(iPtr)).FscriptFile, bp+64)
		}
		argv4 = v26
		(*TPkgAvail)(unsafe.Pointer(availPtr)).FpkgIndex = XTcl_Alloc(tls, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 64))+int64(1)))
		libc.Xmemcpy(tls, (*TPkgAvail)(unsafe.Pointer(availPtr)).FpkgIndex, argv4, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 64))+libc.Int64FromInt32(1)))
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)))).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 64)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)))).Flength
		v27 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)))).Fbytes
	} else {
		v27 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 4*8)), bp+64)
	}
	argv4 = v27
	(*TPkgAvail)(unsafe.Pointer(availPtr)).Fscript = XTcl_Alloc(tls, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 64))+int64(1)))
	libc.Xmemcpy(tls, (*TPkgAvail)(unsafe.Pointer(availPtr)).Fscript, argv4, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 64))+libc.Int64FromInt32(1)))
	goto _14
_4:
	;
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, libc.UintptrFromInt32(0))
		return int32(TCL_ERROR)
	} else {
		if v28 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v28 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v28 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			resultObj = XTclThreadAllocObj(tls)
		} else {
			resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(resultObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
		tablePtr = iPtr + 136
		hPtr = XTcl_FirstHashEntry(tls, tablePtr, bp+16)
		for {
			if !(hPtr != libc.UintptrFromInt32(0)) {
				break
			}
			pkgPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
			if (*TPackage)(unsafe.Pointer(pkgPtr)).Fversion != libc.UintptrFromInt32(0) || (*TPackage)(unsafe.Pointer(pkgPtr)).FavailPtr != libc.UintptrFromInt32(0) {
				if (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FkeyType == -int32(1) {
					v30 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
				} else {
					v30 = hPtr + 32
				}
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, XTcl_NewStringObj(tls, v30, int64(-int32(1))))
			}
			goto _29
		_29:
			;
			hPtr = XTcl_NextHashEntry(tls, bp+16)
		}
		XTcl_SetObjResult(tls, interp, resultObj)
	}
	goto _14
_5:
	;
	if objc < int32(3) {
		goto require
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
		v31 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
	} else {
		v31 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
	}
	argv2 = v31
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(argv2))) == int32('-') && libc.Xstrcmp(tls, argv2, __ccgo_ts+17506) == 0 {
		if objc != int32(5) {
			goto requireSyntax
		}
		exact = int32(1)
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes != 0 {
			v32 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes
		} else {
			v32 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0))
		}
		name = v32
	} else {
		exact = 0
		name = argv2
	}
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iPtr + 136)).FfindProc})))(tls, iPtr+136, name)
	if hPtr != libc.UintptrFromInt32(0) {
		pkgPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		if (*TPackage)(unsafe.Pointer(pkgPtr)).Fversion != libc.UintptrFromInt32(0) {
			goto require
		}
	}
	version = libc.UintptrFromInt32(0)
	if exact != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)))).Fbytes != 0 {
			v33 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)))).Fbytes
		} else {
			v33 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 4*8)), libc.UintptrFromInt32(0))
		}
		version = v33
		if _CheckVersionAndConvert(tls, interp, version, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0)) != TCL_OK {
			return int32(TCL_ERROR)
		}
	} else {
		if _CheckAllRequirements(tls, interp, objc-int32(3), objv+uintptr(3)*8) != TCL_OK {
			return int32(TCL_ERROR)
		}
		if v35 = objc > int32(3); v35 {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes != 0 {
				v34 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes
			} else {
				v34 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0))
			}
		}
		if v35 && _CheckVersionAndConvert(tls, interp, v34, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0)) == TCL_OK {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes != 0 {
				v36 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes
			} else {
				v36 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0))
			}
			version = v36
		}
	}
	XTcl_PkgPresentEx(tls, interp, name, version, exact, libc.UintptrFromInt32(0))
	return int32(TCL_ERROR)
	goto _14
_6:
	;
	if objc != int32(3) && objc != int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+58013)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
		v37 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
	} else {
		v37 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
	}
	argv2 = v37
	if objc == int32(3) {
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iPtr + 136)).FfindProc})))(tls, iPtr+136, argv2)
		if hPtr != libc.UintptrFromInt32(0) {
			pkgPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
			if (*TPackage)(unsafe.Pointer(pkgPtr)).Fversion != libc.UintptrFromInt32(0) {
				XTcl_SetObjResult(tls, interp, (*TPackage)(unsafe.Pointer(pkgPtr)).Fversion)
			}
		}
		return TCL_OK
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes != 0 {
		v38 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes
	} else {
		v38 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0))
	}
	argv3 = v38
	if _CheckVersionAndConvert(tls, interp, argv3, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0)) != TCL_OK {
		return int32(TCL_ERROR)
	}
	return XTcl_PkgProvideEx(tls, interp, argv2, argv3, libc.UintptrFromInt32(0))
_7:
	;
	goto require
require:
	;
	if !(objc < int32(3)) {
		goto _39
	}
	goto requireSyntax
requireSyntax:
	;
	XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+58031)
	return int32(TCL_ERROR)
_39:
	;
	version = libc.UintptrFromInt32(0)
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
		v40 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
	} else {
		v40 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
	}
	argv2 = v40
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(argv2))) == int32('-') && libc.Xstrcmp(tls, argv2, __ccgo_ts+17506) == 0 {
		if objc != int32(5) {
			goto requireSyntax
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)))).Fbytes != 0 {
			v41 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)))).Fbytes
		} else {
			v41 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 4*8)), libc.UintptrFromInt32(0))
		}
		version = v41
		if _CheckVersionAndConvert(tls, interp, version, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0)) != TCL_OK {
			return int32(TCL_ERROR)
		}
		/*
		 * Create a new-style requirement for the exact version.
		 */
		ov = XTcl_NewStringObj(tls, version, int64(-int32(1)))
		XTcl_AppendStringsToObj(tls, ov, libc.VaList(bp+120, __ccgo_ts+6319, version, libc.UintptrFromInt32(0)))
		version = libc.UintptrFromInt32(0)
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes != 0 {
			v42 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes
		} else {
			v42 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0))
		}
		argv3 = v42
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FrefCount++
		objvListPtr = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
		(*TTcl_Obj)(unsafe.Pointer(objvListPtr)).FrefCount++
		XTcl_ListObjAppendElement(tls, interp, objvListPtr, ov)
		if (*TTcl_Obj)(unsafe.Pointer(objvListPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objvListPtr + 32))).Fptr2 != 0 {
				v44 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objvListPtr + 32))).Fptr2)).FspanStart
			} else {
				v44 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objvListPtr + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 56)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objvListPtr + 32))).Fptr1 + 40 + uintptr(v44)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objvListPtr + 32))).Fptr2 != 0 {
				v45 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objvListPtr + 32))).Fptr2)).FspanLength
			} else {
				v45 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objvListPtr + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v45
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_ListObjGetElements(tls, interp, objvListPtr, bp+8, bp+56)
		}
		XTcl_NRAddCallback(tls, interp, __ccgo_fp(_TclNRPackageObjCmdCleanup), *(*uintptr)(unsafe.Pointer(objv + 3*8)), objvListPtr, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
		XTcl_NRAddCallback(tls, interp, __ccgo_fp(_PkgRequireCore), argv3, uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8))), *(*uintptr)(unsafe.Pointer(bp + 56)), libc.UintptrFromInt32(0))
		return TCL_OK
	} else {
		newobjv = objv + uintptr(3)*8
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = int64(objc - int32(3))
		if _CheckAllRequirements(tls, interp, objc-int32(3), objv+uintptr(3)*8) != TCL_OK {
			return int32(TCL_ERROR)
		}
		objvListPtr = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
		(*TTcl_Obj)(unsafe.Pointer(objvListPtr)).FrefCount++
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).FrefCount++
		i = 0
		for {
			if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 8))) {
				break
			}
			/*
			 * Tcl_Obj structures may have come from another interpreter,
			 * so duplicate them.
			 */
			XTcl_ListObjAppendElement(tls, interp, objvListPtr, XTcl_DuplicateObj(tls, *(*uintptr)(unsafe.Pointer(newobjv + uintptr(i)*8))))
			goto _46
		_46:
			;
			i++
		}
		if (*TTcl_Obj)(unsafe.Pointer(objvListPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objvListPtr + 32))).Fptr2 != 0 {
				v48 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objvListPtr + 32))).Fptr2)).FspanStart
			} else {
				v48 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objvListPtr + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 56)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objvListPtr + 32))).Fptr1 + 40 + uintptr(v48)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objvListPtr + 32))).Fptr2 != 0 {
				v49 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objvListPtr + 32))).Fptr2)).FspanLength
			} else {
				v49 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objvListPtr + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v49
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_ListObjGetElements(tls, interp, objvListPtr, bp+8, bp+56)
		}
		XTcl_NRAddCallback(tls, interp, __ccgo_fp(_TclNRPackageObjCmdCleanup), *(*uintptr)(unsafe.Pointer(objv + 2*8)), objvListPtr, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
		XTcl_NRAddCallback(tls, interp, __ccgo_fp(_PkgRequireCore), argv2, uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8))), *(*uintptr)(unsafe.Pointer(bp + 56)), libc.UintptrFromInt32(0))
		return TCL_OK
	}
	goto _14
_8:
	;
	if objc == int32(2) {
		if (*TInterp)(unsafe.Pointer(iPtr)).FpackageUnknown != libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, (*TInterp)(unsafe.Pointer(iPtr)).FpackageUnknown, int64(-int32(1))))
		}
	} else {
		if objc == int32(3) {
			if (*TInterp)(unsafe.Pointer(iPtr)).FpackageUnknown != libc.UintptrFromInt32(0) {
				XTclpFree(tls, (*TInterp)(unsafe.Pointer(iPtr)).FpackageUnknown)
			}
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 88)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Flength
				v50 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
			} else {
				v50 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp+88)
			}
			argv2 = v50
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(argv2))) == 0 {
				(*TInterp)(unsafe.Pointer(iPtr)).FpackageUnknown = libc.UintptrFromInt32(0)
			} else {
				(*TInterp)(unsafe.Pointer(iPtr)).FpackageUnknown = XTcl_Alloc(tls, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 88))+int64(1)))
				libc.Xmemcpy(tls, (*TInterp)(unsafe.Pointer(iPtr)).FpackageUnknown, argv2, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 88))+libc.Int64FromInt32(1)))
			}
		} else {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+58066)
			return int32(TCL_ERROR)
		}
	}
	goto _14
_9:
	;
	/*
	 * See tclInt.h for the enum, just before Interp.
	 */
	if objc > int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+58090)
		return int32(TCL_ERROR)
	} else {
		if objc == int32(3) {
			if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), uintptr(unsafe.Pointer(&_pkgPreferOptions)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+58106, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+96) != TCL_OK {
				return int32(TCL_ERROR)
			}
			if *(*int32)(unsafe.Pointer(bp + 96)) < (*TInterp)(unsafe.Pointer(iPtr)).FpackagePrefer {
				(*TInterp)(unsafe.Pointer(iPtr)).FpackagePrefer = *(*int32)(unsafe.Pointer(bp + 96))
			}
		}
	}
	/*
	 * Always return current value.
	 */
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, _pkgPreferOptions[(*TInterp)(unsafe.Pointer(iPtr)).FpackagePrefer], int64(-int32(1))))
	goto _14
_10:
	;
	if objc != int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+58117)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes != 0 {
		v51 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes
	} else {
		v51 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0))
	}
	argv3 = v51
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
		v52 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
	} else {
		v52 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
	}
	argv2 = v52
	if _CheckVersionAndConvert(tls, interp, argv2, bp+40, libc.UintptrFromInt32(0)) != TCL_OK || _CheckVersionAndConvert(tls, interp, argv3, bp+48, libc.UintptrFromInt32(0)) != TCL_OK {
		if *(*uintptr)(unsafe.Pointer(bp + 40)) != libc.UintptrFromInt32(0) {
			XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 40)))
		}
		/*
		 * ivb cannot be set in this branch.
		 */
		return int32(TCL_ERROR)
	}
	/*
	 * Comparison is done on the internal representation.
	 */
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, int64(_CompareVersions(tls, *(*uintptr)(unsafe.Pointer(bp + 40)), *(*uintptr)(unsafe.Pointer(bp + 48)), libc.UintptrFromInt32(0)))))
	XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 40)))
	XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 48)))
	goto _14
_11:
	;
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+5344)
		return int32(TCL_ERROR)
	} else {
		if v53 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v53 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v53 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			resultObj1 = XTclThreadAllocObj(tls)
		} else {
			resultObj1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(resultObj1 + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(resultObj1)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(resultObj1)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(resultObj1)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(resultObj1)).FtypePtr = libc.UintptrFromInt32(0)
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v54 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v54 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		argv2 = v54
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iPtr + 136)).FfindProc})))(tls, iPtr+136, argv2)
		if hPtr != libc.UintptrFromInt32(0) {
			pkgPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
			availPtr = (*TPackage)(unsafe.Pointer(pkgPtr)).FavailPtr
			for {
				if !(availPtr != libc.UintptrFromInt32(0)) {
					break
				}
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj1, XTcl_NewStringObj(tls, (*TPkgAvail)(unsafe.Pointer(availPtr)).Fversion, int64(-int32(1))))
				goto _55
			_55:
				;
				availPtr = (*TPkgAvail)(unsafe.Pointer(availPtr)).FnextPtr
			}
		}
		XTcl_SetObjResult(tls, interp, resultObj1)
	}
	goto _14
_12:
	;
	*(*uintptr)(unsafe.Pointer(bp + 104)) = libc.UintptrFromInt32(0)
	if objc < int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+58135)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
		v56 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
	} else {
		v56 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
	}
	argv2 = v56
	if _CheckVersionAndConvert(tls, interp, argv2, bp+104, libc.UintptrFromInt32(0)) != TCL_OK {
		return int32(TCL_ERROR)
	} else {
		if _CheckAllRequirements(tls, interp, objc-int32(3), objv+uintptr(3)*8) != TCL_OK {
			XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 104)))
			return int32(TCL_ERROR)
		}
	}
	satisfies = _SomeRequirementSatisfied(tls, *(*uintptr)(unsafe.Pointer(bp + 104)), objc-int32(3), objv+uintptr(3)*8)
	XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 104)))
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(satisfies != 0)))
	goto _14
_13:
	;
	XTcl_Panic(tls, __ccgo_ts+58161, 0)
_14:
	;
	return TCL_OK
}

var _pkgOptions = [13]uintptr{
	0:  __ccgo_ts + 57896,
	1:  __ccgo_ts + 53403,
	2:  __ccgo_ts + 57902,
	3:  __ccgo_ts + 15007,
	4:  __ccgo_ts + 57911,
	5:  __ccgo_ts + 57918,
	6:  __ccgo_ts + 57926,
	7:  __ccgo_ts + 57934,
	8:  __ccgo_ts + 15720,
	9:  __ccgo_ts + 57942,
	10: __ccgo_ts + 57951,
	11: __ccgo_ts + 57960,
	12: libc.UintptrFromInt32(0),
}

var _pkgPreferOptions = [3]uintptr{
	0: __ccgo_ts + 58076,
	1: __ccgo_ts + 58083,
	2: libc.UintptrFromInt32(0),
}

func _TclNRPackageObjCmdCleanup(tls *libc.TLS, data uintptr, dummy1539 uintptr, result int32) (r int32) {
	var cachePtr, cachePtr1, v2, v5 uintptr
	var v1, v4 TTcl_Size
	var v3, v6 bool
	_, _, _, _, _, _, _, _ = cachePtr, cachePtr1, v1, v2, v3, v4, v5, v6
	v2 = *(*uintptr)(unsafe.Pointer(data))
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if !(v1 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(data)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(data)))).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(data)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(data)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(data)))).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(data)))).Flength = int64(-libc.Int32FromInt32(1))
			if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(data)))
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(data)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(data))
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(data)))
		}
	}
	v5 = *(*uintptr)(unsafe.Pointer(data + 1*8))
	v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
	*(*TTcl_Size)(unsafe.Pointer(v5))--
	if !(v4 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(data + 1*8)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(data + 1*8)))).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(data + 1*8)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(data + 1*8)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(data + 1*8)))).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(data + 1*8)))).Flength = int64(-libc.Int32FromInt32(1))
			if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v6 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(data + 1*8)))
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(data + 1*8)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(data + 1*8))
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(data + 1*8)))
		}
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * FindPackage --
 *
 *	This function finds the Package record for a particular package in a
 *	particular interpreter, creating a record if one doesn't already
 *	exist.
 *
 * Results:
 *	The return value is a pointer to the Package record for the package.
 *
 * Side effects:
 *	A new Package record may be created.
 *
 *----------------------------------------------------------------------
 */

func _FindPackage(tls *libc.TLS, interp uintptr, name uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Name of package to fine. */
	var hPtr, iPtr, pkgPtr uintptr
	var _ /* isNew at bp+0 */ int32
	_, _, _ = hPtr, iPtr, pkgPtr
	iPtr = interp
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iPtr + 136)).FcreateProc})))(tls, iPtr+136, name, bp)
	if *(*int32)(unsafe.Pointer(bp)) != 0 {
		pkgPtr = XTcl_Alloc(tls, uint64(24))
		(*TPackage)(unsafe.Pointer(pkgPtr)).Fversion = libc.UintptrFromInt32(0)
		(*TPackage)(unsafe.Pointer(pkgPtr)).FavailPtr = libc.UintptrFromInt32(0)
		(*TPackage)(unsafe.Pointer(pkgPtr)).FclientData = libc.UintptrFromInt32(0)
		(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = pkgPtr
	} else {
		pkgPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
	}
	return pkgPtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclFreePackageInfo --
 *
 *	This function is called during interpreter deletion to free all of the
 *	package-related information for the interpreter.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Memory is freed.
 *
 *----------------------------------------------------------------------
 */

func XTclFreePackageInfo(tls *libc.TLS, iPtr uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Interpreter that is being deleted. */
	var _objPtr, availPtr, hPtr, pkgPtr, v3 uintptr
	var v2 TTcl_Size
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _ = _objPtr, availPtr, hPtr, pkgPtr, v2, v3
	hPtr = XTcl_FirstHashEntry(tls, iPtr+136, bp)
	for {
		if !(hPtr != libc.UintptrFromInt32(0)) {
			break
		}
		pkgPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		if (*TPackage)(unsafe.Pointer(pkgPtr)).Fversion != libc.UintptrFromInt32(0) {
			_objPtr = (*TPackage)(unsafe.Pointer(pkgPtr)).Fversion
			v3 = _objPtr
			v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
			*(*TTcl_Size)(unsafe.Pointer(v3))--
			if v2 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
		for (*TPackage)(unsafe.Pointer(pkgPtr)).FavailPtr != libc.UintptrFromInt32(0) {
			availPtr = (*TPackage)(unsafe.Pointer(pkgPtr)).FavailPtr
			(*TPackage)(unsafe.Pointer(pkgPtr)).FavailPtr = (*TPkgAvail)(unsafe.Pointer(availPtr)).FnextPtr
			XTcl_EventuallyFree(tls, (*TPkgAvail)(unsafe.Pointer(availPtr)).Fversion, libc.UintptrFromInt32(3))
			XTcl_EventuallyFree(tls, (*TPkgAvail)(unsafe.Pointer(availPtr)).Fscript, libc.UintptrFromInt32(3))
			if (*TPkgAvail)(unsafe.Pointer(availPtr)).FpkgIndex != 0 {
				XTcl_EventuallyFree(tls, (*TPkgAvail)(unsafe.Pointer(availPtr)).FpkgIndex, libc.UintptrFromInt32(3))
				(*TPkgAvail)(unsafe.Pointer(availPtr)).FpkgIndex = libc.UintptrFromInt32(0)
			}
			XTclpFree(tls, availPtr)
		}
		XTclpFree(tls, pkgPtr)
		goto _1
	_1:
		;
		hPtr = XTcl_NextHashEntry(tls, bp)
	}
	XTcl_DeleteHashTable(tls, iPtr+136)
	if (*TInterp)(unsafe.Pointer(iPtr)).FpackageUnknown != libc.UintptrFromInt32(0) {
		XTclpFree(tls, (*TInterp)(unsafe.Pointer(iPtr)).FpackageUnknown)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * CheckVersionAndConvert --
 *
 *	This function checks to see whether a version number has valid syntax.
 *	It also generates a semi-internal representation (string rep of a list
 *	of numbers).
 *
 * Results:
 *	If string is a properly formed version number the TCL_OK is returned.
 *	Otherwise TCL_ERROR is returned and an error message is left in the
 *	interp's result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _CheckVersionAndConvert(tls *libc.TLS, interp uintptr, string1 uintptr, internal uintptr, stable uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Flag: Version is (un)stable. */
	var hasunstable int32
	var ibuf, ip, p, v1, v10, v11, v12, v13, v14, v3, v4, v5, v6, v7, v8, v9 uintptr
	var prevChar uint8
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hasunstable, ibuf, ip, p, prevChar, v1, v10, v11, v12, v13, v14, v3, v4, v5, v6, v7, v8, v9
	p = string1
	hasunstable = 0
	/*
	 * 4* assuming that each char is a separator (a,b become ' -x ').
	 * 4+ to have space for an additional -2 at the end
	 */
	ibuf = XTcl_Alloc(tls, uint64(4)+uint64(4)*libc.Xstrlen(tls, string1))
	ip = ibuf
	/*
	 * Basic rules
	 * (1) First character has to be a digit.
	 * (2) All other characters have to be a digit or '.'
	 * (3) Two '.'s may not follow each other.
	 *
	 * TIP 268, Modified rules
	 * (1) s.a.
	 * (2) All other characters have to be a digit, 'a', 'b', or '.'
	 * (3) s.a.
	 * (4) Only one of 'a' or 'b' may occur.
	 * (5) Neither 'a', nor 'b' may occur before or after a '.'
	 */
	if !(libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-libc.Uint32FromUint8('0') < libc.Uint32FromInt32(10)) != 0) { /* INTL: digit */
		goto error
	}
	v1 = ip
	ip++
	*(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(p))
	prevChar = *(*uint8)(unsafe.Pointer(p))
	p++
	for {
		if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('+')) {
			break
		}
		if !(libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-libc.Uint32FromUint8('0') < libc.Uint32FromInt32(10)) != 0) && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('.') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('a') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('b') || (hasunstable != 0 && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('a') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('b')) || (libc.Int32FromUint8(prevChar) == int32('a') || libc.Int32FromUint8(prevChar) == int32('b') || libc.Int32FromUint8(prevChar) == int32('.')) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('.') || (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('a') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('b') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('.')) && libc.Int32FromUint8(prevChar) == int32('.'))) {
			goto error
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('a') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('b') {
			hasunstable = int32(1)
		}
		/*
		 * Translation to the internal rep. Regular version chars are copied
		 * as is. The separators are translated to numerics. The new separator
		 * for all parts is space.
		 */
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('.') {
			v3 = ip
			ip++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(' ')
			v4 = ip
			ip++
			*(*uint8)(unsafe.Pointer(v4)) = uint8('0')
			v5 = ip
			ip++
			*(*uint8)(unsafe.Pointer(v5)) = uint8(' ')
		} else {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('a') {
				v6 = ip
				ip++
				*(*uint8)(unsafe.Pointer(v6)) = uint8(' ')
				v7 = ip
				ip++
				*(*uint8)(unsafe.Pointer(v7)) = uint8('-')
				v8 = ip
				ip++
				*(*uint8)(unsafe.Pointer(v8)) = uint8('2')
				v9 = ip
				ip++
				*(*uint8)(unsafe.Pointer(v9)) = uint8(' ')
			} else {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('b') {
					v10 = ip
					ip++
					*(*uint8)(unsafe.Pointer(v10)) = uint8(' ')
					v11 = ip
					ip++
					*(*uint8)(unsafe.Pointer(v11)) = uint8('-')
					v12 = ip
					ip++
					*(*uint8)(unsafe.Pointer(v12)) = uint8('1')
					v13 = ip
					ip++
					*(*uint8)(unsafe.Pointer(v13)) = uint8(' ')
				} else {
					v14 = ip
					ip++
					*(*uint8)(unsafe.Pointer(v14)) = *(*uint8)(unsafe.Pointer(p))
				}
			}
		}
		prevChar = *(*uint8)(unsafe.Pointer(p))
		goto _2
	_2:
		;
		p++
	}
	if libc.Int32FromUint8(prevChar) != int32('.') && libc.Int32FromUint8(prevChar) != int32('a') && libc.Int32FromUint8(prevChar) != int32('b') {
		*(*uint8)(unsafe.Pointer(ip)) = uint8('\000')
		if internal != libc.UintptrFromInt32(0) {
			*(*uintptr)(unsafe.Pointer(internal)) = ibuf
		} else {
			XTclpFree(tls, ibuf)
		}
		if stable != libc.UintptrFromInt32(0) {
			*(*int32)(unsafe.Pointer(stable)) = libc.BoolInt32(!(hasunstable != 0))
		}
		return TCL_OK
	}
	goto error
error:
	;
	XTclpFree(tls, ibuf)
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+58211, libc.VaList(bp+8, string1)))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+58248, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * CompareVersions --
 *
 *	This function compares two version numbers (in internal rep).
 *
 * Results:
 *	The return value is -1 if v1 is less than v2, 0 if the two version
 *	numbers are the same, and 1 if v1 is greater than v2. If *satPtr is
 *	non-NULL, the word it points to is filled in with 1 if v2 >= v1 and
 *	both numbers have the same major number or 0 otherwise.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _CompareVersions(tls *libc.TLS, v1 uintptr, v2 uintptr, isMajorPtr uintptr) (r int32) {
	/* If non-null, the word pointed to is filled
	 * in with a 0/1 value. 1 means that the
	 * difference occurred in the first element. */
	var e1, e2, s1, s2 uintptr
	var flip, res, thisIsMajor, v11, v21 int32
	var o1, o2 uint8
	_, _, _, _, _, _, _, _, _, _, _ = e1, e2, flip, o1, o2, res, s1, s2, thisIsMajor, v11, v21
	/*
	 * Each iteration of the following loop processes one number from each
	 * string, terminated by a " " (space). If those numbers don't match then
	 * the comparison is over; otherwise, we loop back for the next number.
	 *
	 * TIP 268.
	 * This is identical the function 'ComparePkgVersion', but using the new
	 * space separator as used by the internal rep of version numbers. The
	 * special separators 'a' and 'b' have already been dealt with in
	 * 'CheckVersionAndConvert', they were translated into numbers as well.
	 * This keeps the comparison sane. Otherwise we would have to compare
	 * numerics, the separators, and also deal with the special case of
	 * end-of-string compared to separators. The semi-list rep we get here is
	 * much easier to handle, as it is still regular.
	 *
	 * Rewritten to not compute a numeric value for the extracted version
	 * number, but do string comparison. Skip any leading zeros for that to
	 * work. This change breaks through the 32bit-limit on version numbers.
	 */
	thisIsMajor = int32(1)
	s1 = v1
	s2 = v2
	for int32(1) != 0 {
		/*
		 * Parse one decimal number from the front of each string. Skip
		 * leading zeros. Terminate found number for upcoming string-wise
		 * comparison, if needed.
		 */
		for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(s1))) != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(s1))) == int32('0') {
			s1++
		}
		for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(s2))) != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(s2))) == int32('0') {
			s2++
		}
		/*
		 * s1, s2 now point to the beginnings of the numbers to compare. Test
		 * for their signs first, as shortcut to the result (different signs),
		 * or determines if result has to be flipped (both negative). If there
		 * is no shortcut we have to insert terminators later to limit the
		 * strcmp.
		 */
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(s1))) == int32('-') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(s2))) != int32('-') {
			/* s1 < 0, s2 >= 0 => s1 < s2 */
			res = -int32(1)
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(s1))) != int32('-') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(s2))) == int32('-') {
			/* s1 >= 0, s2 < 0 => s1 > s2 */
			res = int32(1)
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(s1))) == int32('-') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(s2))) == int32('-') {
			/* a < b => -a > -b, etc. */
			s1++
			s2++
			flip = int32(1)
		} else {
			flip = 0
		}
		/*
		 * The string comparison is needed, so now we determine where the
		 * numbers end.
		 */
		e1 = s1
		for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(e1))) != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(e1))) != int32(' ') {
			e1++
		}
		e2 = s2
		for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(e2))) != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(e2))) != int32(' ') {
			e2++
		}
		/*
		 * s1 .. e1 and s2 .. e2 now bracket the numbers to compare. Insert
		 * terminators, compare, and restore actual contents. First however
		 * another shortcut. Compare lengths. Shorter string is smaller
		 * number! Thus we strcmp only strings of identical length.
		 */
		if int64(e1)-int64(s1) < int64(e2)-int64(s2) {
			res = -int32(1)
		} else {
			if int64(e2)-int64(s2) < int64(e1)-int64(s1) {
				res = int32(1)
			} else {
				o1 = *(*uint8)(unsafe.Pointer(e1))
				*(*uint8)(unsafe.Pointer(e1)) = uint8('\000')
				o2 = *(*uint8)(unsafe.Pointer(e2))
				*(*uint8)(unsafe.Pointer(e2)) = uint8('\000')
				res = libc.Xstrcmp(tls, s1, s2)
				if res < 0 {
					v11 = -int32(1)
				} else {
					if res != 0 {
						v21 = int32(1)
					} else {
						v21 = 0
					}
					v11 = v21
				}
				res = v11
				*(*uint8)(unsafe.Pointer(e1)) = o1
				*(*uint8)(unsafe.Pointer(e2)) = o2
			}
		}
		/*
		 * Stop comparing segments when a difference has been found. Here we
		 * may have to flip the result to account for signs.
		 */
		if res != 0 {
			if flip != 0 {
				res = -res
			}
			break
		}
		/*
		 * Go on to the next version number if the current numbers match.
		 * However stop processing if the end of both numbers has been
		 * reached.
		 */
		s1 = e1
		s2 = e2
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(s1))) != 0 {
			s1++
		} else {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(s2))) == 0 {
				/*
				 * s1, s2 both at the end => identical
				 */
				res = 0
				break
			}
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(s2))) != 0 {
			s2++
		}
		thisIsMajor = 0
	}
	if isMajorPtr != libc.UintptrFromInt32(0) {
		*(*int32)(unsafe.Pointer(isMajorPtr)) = thisIsMajor
	}
	return res
}

/*
 *----------------------------------------------------------------------
 *
 * CheckAllRequirements --
 *
 *	This function checks to see whether all requirements in a set have
 *	valid syntax.
 *
 * Results:
 *	TCL_OK is returned if all requirements are valid. Otherwise TCL_ERROR
 *	is returned and an error message is left in the interp's result.
 *
 * Side effects:
 *	May modify the interpreter result.
 *
 *----------------------------------------------------------------------
 */

func _CheckAllRequirements(tls *libc.TLS, interp uintptr, reqc int32, reqv uintptr) (r int32) {
	var i int32
	var v2 uintptr
	_, _ = i, v2
	i = 0
	for {
		if !(i < reqc) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(reqv + uintptr(i)*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(reqv + uintptr(i)*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(reqv + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		if _CheckRequirement(tls, interp, v2) != TCL_OK {
			return int32(TCL_ERROR)
		}
		goto _1
	_1:
		;
		i++
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * CheckRequirement --
 *
 *	This function checks to see whether a requirement has valid syntax.
 *
 * Results:
 *	If string is a properly formed requirement then TCL_OK is returned.
 *	Otherwise TCL_ERROR is returned and an error message is left in the
 *	interp's result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _CheckRequirement(tls *libc.TLS, interp uintptr, string1 uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Supposedly a requirement. */
	var buf, dash, v1 uintptr
	var local__len Tsize_t
	_, _, _, _ = buf, dash, local__len, v1
	/*
	 * Syntax of requirement = version
	 *			     = version-version
	 *			     = version-
	 */
	dash = libc.UintptrFromInt32(0)
	if libc.Xstrchr(tls, string1, int32('+')) != 0 {
		v1 = libc.UintptrFromInt32(0)
	} else {
		v1 = libc.Xstrchr(tls, string1, int32('-'))
	}
	dash = v1
	if dash == libc.UintptrFromInt32(0) {
		/*
		 * '+' found or no dash found: has to be a simple version.
		 */
		return _CheckVersionAndConvert(tls, interp, string1, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	}
	if libc.Xstrchr(tls, dash+uintptr(1), int32('-')) != libc.UintptrFromInt32(0) {
		/*
		 * More dashes found after the first. This is wrong.
		 */
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+58256, libc.VaList(bp+8, string1)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+58300, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Exactly one dash is present. Copy the string, split at the location of
	 * dash and check that both parts are versions. Note that the max part can
	 * be empty. Also note that the string allocated with strdup() must be
	 * freed with free() and not Tcl_Free().
	 */
	local__len = libc.Xstrlen(tls, string1) + uint64(1)
	buf = XTcl_Alloc(tls, local__len)
	libc.Xmemcpy(tls, buf, string1, local__len)
	dash = buf + uintptr(int64(dash)-int64(string1))
	*(*uint8)(unsafe.Pointer(dash)) = uint8('\000') /* buf now <=> min part */
	dash++                                          /* dash now <=> max part */
	if _CheckVersionAndConvert(tls, interp, buf, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0)) != TCL_OK || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dash))) != int32('\000') && _CheckVersionAndConvert(tls, interp, dash, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0)) != TCL_OK {
		XTclpFree(tls, buf)
		return int32(TCL_ERROR)
	}
	XTclpFree(tls, buf)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * AddRequirementsToResult --
 *
 *	This function accumulates requirements in the interpreter result.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The interpreter result is extended.
 *
 *----------------------------------------------------------------------
 */

func _AddRequirementsToResult(tls *libc.TLS, interp uintptr, reqc int32, reqv uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* 0 means to use the latest version
	 * available. */
	var i int32
	var result, v, v2 uintptr
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _ = i, result, v, v2
	result = XTcl_GetObjResult(tls, interp)
	i = 0
	for {
		if !(i < reqc) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(reqv + uintptr(i)*8)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(reqv + uintptr(i)*8)))).Flength
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(reqv + uintptr(i)*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(reqv + uintptr(i)*8)), bp)
		}
		v = v2
		if *(*TTcl_Size)(unsafe.Pointer(bp))&int64(0x1) != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp))/int64(2))))) == int32('-') && libc.Xstrncmp(tls, v, v+uintptr((*(*TTcl_Size)(unsafe.Pointer(bp))+libc.Int64FromInt32(1))/libc.Int64FromInt32(2)), libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))/int64(2))) == 0 {
			XTcl_AppendPrintfToObj(tls, result, __ccgo_ts+58313, libc.VaList(bp+16, v+uintptr((*(*TTcl_Size)(unsafe.Pointer(bp))+libc.Int64FromInt32(1))/libc.Int64FromInt32(2))))
		} else {
			XTcl_AppendPrintfToObj(tls, result, __ccgo_ts+58325, libc.VaList(bp+16, v))
		}
		goto _1
	_1:
		;
		i++
	}
}

/*
 *----------------------------------------------------------------------
 *
 * AddRequirementsToDString --
 *
 *	This function accumulates requirements in a DString.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The DString argument is extended.
 *
 *----------------------------------------------------------------------
 */

func _AddRequirementsToDString(tls *libc.TLS, dsPtr uintptr, reqc int32, reqv uintptr) {
	/* 0 means to use the latest version
	 * available. */
	var i int32
	_ = i
	if reqc > 0 {
		i = 0
		for {
			if !(i < reqc) {
				break
			}
			XTcl_DStringAppend(tls, dsPtr, __ccgo_ts+14830, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))
			XTclDStringAppendObj(tls, dsPtr, *(*uintptr)(unsafe.Pointer(reqv + uintptr(i)*8)))
			goto _1
		_1:
			;
			i++
		}
	} else {
		XTcl_DStringAppend(tls, dsPtr, __ccgo_ts+58329, libc.Int64FromUint64(libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)))
	}
}

/*
 *----------------------------------------------------------------------
 *
 * SomeRequirementSatisfied --
 *
 *	This function checks to see whether a version satisfies at least one
 *	of a set of requirements.
 *
 * Results:
 *	If the requirements are satisfied 1 is returned. Otherwise 0 is
 *	returned. The function assumes that all pieces have valid syntax. And
 *	is allowed to make that assumption.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _SomeRequirementSatisfied(tls *libc.TLS, availVersionI uintptr, reqc int32, reqv uintptr) (r int32) {
	/* 0 means to use the latest version
	 * available. */
	var i int32
	var v2 uintptr
	_, _ = i, v2
	i = 0
	for {
		if !(i < reqc) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(reqv + uintptr(i)*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(reqv + uintptr(i)*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(reqv + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		if _RequirementSatisfied(tls, availVersionI, v2) != 0 {
			return int32(1)
		}
		goto _1
	_1:
		;
		i++
	}
	return 0
}

/*
 *----------------------------------------------------------------------
 *
 * RequirementSatisfied --
 *
 *	This function checks to see whether a version satisfies a requirement.
 *
 * Results:
 *	If the requirement is satisfied 1 is returned. Otherwise 0 is
 *	returned. The function assumes that all pieces have valid syntax, and
 *	is allowed to make that assumption.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _RequirementSatisfied(tls *libc.TLS, havei uintptr, req uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Requirement string the candidate has to
	 * satisfy. */
	var buf, dash uintptr
	var local__len Tsize_t
	var res, satisfied int32
	var _ /* max at bp+8 */ uintptr
	var _ /* min at bp+0 */ uintptr
	var _ /* reqi at bp+16 */ uintptr
	var _ /* thisIsMajor at bp+24 */ int32
	_, _, _, _, _ = buf, dash, local__len, res, satisfied
	dash = libc.UintptrFromInt32(0)
	dash = libc.Xstrchr(tls, req, int32('-'))
	if dash == libc.UintptrFromInt32(0) {
		/*
		 * No dash found, is a simple version, fallback to regular check. The
		 * 'CheckVersionAndConvert' cannot fail. We pad the requirement with
		 * 'a0', i.e '-2' before doing the comparison to properly accept
		 * unstables as well.
		 */
		*(*uintptr)(unsafe.Pointer(bp + 16)) = libc.UintptrFromInt32(0)
		_CheckVersionAndConvert(tls, libc.UintptrFromInt32(0), req, bp+16, libc.UintptrFromInt32(0))
		libc.Xstrcat(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), __ccgo_ts+58333)
		res = _CompareVersions(tls, havei, *(*uintptr)(unsafe.Pointer(bp + 16)), bp+24)
		satisfied = libc.BoolInt32(res == 0 || res == int32(1) && !(*(*int32)(unsafe.Pointer(bp + 24)) != 0))
		XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
		return satisfied
	}
	/*
	 * Exactly one dash is present (Assumption of valid syntax). Copy the req,
	 * split at the location of dash and check that both parts are versions.
	 * Note that the max part can be empty.
	 */
	local__len = libc.Xstrlen(tls, req) + uint64(1)
	buf = XTcl_Alloc(tls, local__len)
	libc.Xmemcpy(tls, buf, req, local__len)
	dash = buf + uintptr(int64(dash)-int64(req))
	*(*uint8)(unsafe.Pointer(dash)) = uint8('\000') /* buf now <=> min part */
	dash++                                          /* dash now <=> max part */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dash))) == int32('\000') {
		/*
		 * We have a min, but no max. For the comparison we generate the
		 * internal rep, padded with 'a0' i.e. '-2'.
		 */
		_CheckVersionAndConvert(tls, libc.UintptrFromInt32(0), buf, bp, libc.UintptrFromInt32(0))
		libc.Xstrcat(tls, *(*uintptr)(unsafe.Pointer(bp)), __ccgo_ts+58333)
		satisfied = libc.BoolInt32(_CompareVersions(tls, havei, *(*uintptr)(unsafe.Pointer(bp)), libc.UintptrFromInt32(0)) >= 0)
		XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp)))
		XTclpFree(tls, buf)
		return satisfied
	}
	/*
	 * We have both min and max, and generate their internal reps. When
	 * identical we compare as is, otherwise we pad with 'a0' to over the range
	 * a bit.
	 */
	_CheckVersionAndConvert(tls, libc.UintptrFromInt32(0), buf, bp, libc.UintptrFromInt32(0))
	_CheckVersionAndConvert(tls, libc.UintptrFromInt32(0), dash, bp+8, libc.UintptrFromInt32(0))
	if _CompareVersions(tls, *(*uintptr)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 8)), libc.UintptrFromInt32(0)) == 0 {
		satisfied = libc.BoolInt32(_CompareVersions(tls, *(*uintptr)(unsafe.Pointer(bp)), havei, libc.UintptrFromInt32(0)) == 0)
	} else {
		libc.Xstrcat(tls, *(*uintptr)(unsafe.Pointer(bp)), __ccgo_ts+58333)
		libc.Xstrcat(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), __ccgo_ts+58333)
		satisfied = libc.BoolInt32(_CompareVersions(tls, *(*uintptr)(unsafe.Pointer(bp)), havei, libc.UintptrFromInt32(0)) <= 0 && _CompareVersions(tls, havei, *(*uintptr)(unsafe.Pointer(bp + 8)), libc.UintptrFromInt32(0)) < 0)
	}
	XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp)))
	XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
	XTclpFree(tls, buf)
	return satisfied
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_PkgInitStubsCheck --
 *
 *	This is a replacement routine for Tcl_InitStubs() that is called
 *	from code where -DUSE_TCL_STUBS has not been enabled.
 *
 * Results:
 *	Returns the version of a conforming stubs table, or NULL, if
 *	the table version doesn't satisfy the requested requirements,
 *	according to historical practice.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_PkgInitStubsCheck(tls *libc.TLS, interp uintptr, version uintptr, exact int32) (r uintptr) {
	var actualVersion, p, v1 uintptr
	var count int32
	_, _, _, _ = actualVersion, count, p, v1
	actualVersion = XTcl_PkgPresentEx(tls, interp, __ccgo_ts+7146, version, 0, libc.UintptrFromInt32(0))
	if exact&int32(1) != 0 && actualVersion != 0 {
		p = version
		count = 0
		for *(*uint8)(unsafe.Pointer(p)) != 0 {
			v1 = p
			p++
			count += libc.BoolInt32(!(libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(v1)))-libc.Uint32FromUint8('0') < libc.Uint32FromInt32(10)) != 0))
		}
		if count == int32(1) {
			if 0 != libc.Xstrncmp(tls, version, actualVersion, libc.Xstrlen(tls, version)) {
				/* Construct error message */
				XTcl_PkgPresentEx(tls, interp, __ccgo_ts+7146, version, int32(1), libc.UintptrFromInt32(0))
				return libc.UintptrFromInt32(0)
			}
		} else {
			return XTcl_PkgPresentEx(tls, interp, __ccgo_ts+7146, version, int32(1), libc.UintptrFromInt32(0))
		}
	}
	return actualVersion
}

const CFG_64 = "1"
const CFG_COMPILE_DEBUG = "0"
const CFG_COMPILE_STATS = "0"
const CFG_DEBUG = "0"
const CFG_INSTALL_BINDIR = "/usr/local/bin"
const CFG_INSTALL_DOCDIR = "/usr/local/share/man"
const CFG_INSTALL_INCDIR = "/usr/local/include"
const CFG_INSTALL_LIBDIR = "/usr/local/lib"
const CFG_INSTALL_SCRDIR = "/usr/local/lib/tcl9.0"
const CFG_MEMDEBUG = "0"
const CFG_OPTIMIZED = "1"
const CFG_PROFILED = "0"
const CFG_RUNTIME_BINDIR = "/usr/local/bin"
const CFG_RUNTIME_DLLFILE = "libtcl9.0.a"
const CFG_RUNTIME_DOCDIR = "/usr/local/share/man"
const CFG_RUNTIME_INCDIR = "/usr/local/include"
const CFG_RUNTIME_LIBDIR = "/usr/local/lib"
const CFG_RUNTIME_SCRDIR = "/usr/local/lib/tcl9.0"
const CFG_THREADED = "1"

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * Use C preprocessor statements to define the various values for the embedded
 * configuration information.
 */

var _cfg = [19]TTcl_Config{
	0: {
		Fkey:   __ccgo_ts + 40535,
		Fvalue: __ccgo_ts + 14828,
	},
	1: {
		Fkey:   __ccgo_ts + 58337,
		Fvalue: __ccgo_ts + 21397,
	},
	2: {
		Fkey:   __ccgo_ts + 58346,
		Fvalue: __ccgo_ts + 14828,
	},
	3: {
		Fkey:   __ccgo_ts + 58355,
		Fvalue: __ccgo_ts + 21397,
	},
	4: {
		Fkey:   __ccgo_ts + 58361,
		Fvalue: __ccgo_ts + 21397,
	},
	5: {
		Fkey:   __ccgo_ts + 58371,
		Fvalue: __ccgo_ts + 14828,
	},
	6: {
		Fkey:   __ccgo_ts + 58381,
		Fvalue: __ccgo_ts + 14828,
	},
	7: {
		Fkey:   __ccgo_ts + 58395,
		Fvalue: __ccgo_ts + 14828,
	},
	8: {
		Fkey:   __ccgo_ts + 58409,
		Fvalue: __ccgo_ts + 58424,
	},
	9: {
		Fkey:   __ccgo_ts + 58439,
		Fvalue: __ccgo_ts + 58454,
	},
	10: {
		Fkey:   __ccgo_ts + 58469,
		Fvalue: __ccgo_ts + 58487,
	},
	11: {
		Fkey:   __ccgo_ts + 58509,
		Fvalue: __ccgo_ts + 58528,
	},
	12: {
		Fkey:   __ccgo_ts + 58547,
		Fvalue: __ccgo_ts + 58562,
	},
	13: {
		Fkey:   __ccgo_ts + 58583,
		Fvalue: __ccgo_ts + 58424,
	},
	14: {
		Fkey:   __ccgo_ts + 58598,
		Fvalue: __ccgo_ts + 58454,
	},
	15: {
		Fkey:   __ccgo_ts + 58613,
		Fvalue: __ccgo_ts + 58487,
	},
	16: {
		Fkey:   __ccgo_ts + 58631,
		Fvalue: __ccgo_ts + 58528,
	},
	17: {
		Fkey:   __ccgo_ts + 58650,
		Fvalue: __ccgo_ts + 58562,
	},
	18: {},
}

func XTclInitEmbeddedConfigurationInformation(tls *libc.TLS, interp uintptr) {
	/* Interpreter the configuration command is
	 * registered in. */
	XTcl_RegisterConfig(tls, interp, __ccgo_ts+7241, uintptr(unsafe.Pointer(&_cfg)), __ccgo_ts+29080)
}

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ErrnoId --
 *
 *	Return a textual identifier for the current errno value.
 *
 * Results:
 *	This procedure returns a machine-readable textual identifier that
 *	corresponds to the current errno value (e.g. "EPERM"). The identifier
 *	is the same as the #define name in errno.h.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ErrnoId(tls *libc.TLS) (r uintptr) {
	switch *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) {
	case int32(E2BIG):
		return __ccgo_ts + 58665
	case int32(EACCES):
		return __ccgo_ts + 58671
	case int32(EADDRINUSE):
		return __ccgo_ts + 58678
	case int32(EADDRNOTAVAIL):
		return __ccgo_ts + 58689
	case int32(EADV):
		return __ccgo_ts + 58703
	case int32(EAFNOSUPPORT):
		return __ccgo_ts + 58708
	case int32(EAGAIN):
		return __ccgo_ts + 48328
	case int32(EALREADY):
		return __ccgo_ts + 58721
	case int32(EBADE):
		return __ccgo_ts + 58730
	case int32(EBADF):
		return __ccgo_ts + 58736
	case int32(EBADFD):
		return __ccgo_ts + 58742
	case int32(EBADMSG):
		return __ccgo_ts + 58749
	case int32(EBADR):
		return __ccgo_ts + 58757
	case int32(EBADRQC):
		return __ccgo_ts + 58763
	case int32(EBADSLT):
		return __ccgo_ts + 58771
	case int32(EBFONT):
		return __ccgo_ts + 58779
	case int32(EBUSY):
		return __ccgo_ts + 58786
	case int32(ECANCELED):
		return __ccgo_ts + 58792
	case int32(ECHILD):
		return __ccgo_ts + 58802
	case int32(ECHRNG):
		return __ccgo_ts + 58809
	case int32(ECOMM):
		return __ccgo_ts + 58816
	case int32(ECONNABORTED):
		return __ccgo_ts + 58822
	case int32(ECONNREFUSED):
		return __ccgo_ts + 58835
	case int32(ECONNRESET):
		return __ccgo_ts + 58848
	case int32(EDEADLK):
		return __ccgo_ts + 58859
	case int32(EDESTADDRREQ):
		return __ccgo_ts + 58867
	case int32(EDOM):
		return __ccgo_ts + 58880
	case int32(EDOTDOT):
		return __ccgo_ts + 58885
	case int32(EDQUOT):
		return __ccgo_ts + 58893
	case int32(EEXIST):
		return __ccgo_ts + 58900
	case int32(EFAULT):
		return __ccgo_ts + 58907
	case int32(EFBIG):
		return __ccgo_ts + 58914
	case int32(EHOSTDOWN):
		return __ccgo_ts + 58920
	case int32(EHOSTUNREACH):
		return __ccgo_ts + 58930
	case int32(EIDRM):
		return __ccgo_ts + 58943
	case int32(EILSEQ):
		return __ccgo_ts + 58949
	case int32(EINPROGRESS):
		return __ccgo_ts + 58956
	case int32(EINTR):
		return __ccgo_ts + 58968
	case int32(EINVAL):
		return __ccgo_ts + 14588
	case int32(EIO):
		return __ccgo_ts + 58974
	case int32(EISCONN):
		return __ccgo_ts + 58978
	case int32(EISDIR):
		return __ccgo_ts + 58986
	case int32(EISNAM):
		return __ccgo_ts + 58993
	case int32(EL2HLT):
		return __ccgo_ts + 59000
	case int32(EL2NSYNC):
		return __ccgo_ts + 59007
	case int32(EL3HLT):
		return __ccgo_ts + 59016
	case int32(EL3RST):
		return __ccgo_ts + 59023
	case int32(ELIBACC):
		return __ccgo_ts + 59030
	case int32(ELIBBAD):
		return __ccgo_ts + 59038
	case int32(ELIBEXEC):
		return __ccgo_ts + 59046
	case int32(ELIBMAX):
		return __ccgo_ts + 59055
	case int32(ELIBSCN):
		return __ccgo_ts + 59063
	case int32(ELNRNG):
		return __ccgo_ts + 59071
	case int32(ELOOP):
		return __ccgo_ts + 59078
	case int32(EMEDIUMTYPE):
		return __ccgo_ts + 59084
	case int32(EMFILE):
		return __ccgo_ts + 59096
	case int32(EMLINK):
		return __ccgo_ts + 59103
	case int32(EMSGSIZE):
		return __ccgo_ts + 59110
	case int32(EMULTIHOP):
		return __ccgo_ts + 59119
	case int32(ENAMETOOLONG):
		return __ccgo_ts + 59129
	case int32(ENAVAIL):
		return __ccgo_ts + 59142
	case int32(ENETDOWN):
		return __ccgo_ts + 59150
	case int32(ENETRESET):
		return __ccgo_ts + 59159
	case int32(ENETUNREACH):
		return __ccgo_ts + 59169
	case int32(ENFILE):
		return __ccgo_ts + 59181
	case int32(ENOANO):
		return __ccgo_ts + 59188
	case int32(ENOBUFS):
		return __ccgo_ts + 59195
	case int32(ENOCSI):
		return __ccgo_ts + 59203
	case int32(ENODATA):
		return __ccgo_ts + 59210
	case int32(ENODEV):
		return __ccgo_ts + 59218
	case int32(ENOENT):
		return __ccgo_ts + 59225
	case int32(ENOEXEC):
		return __ccgo_ts + 59232
	case int32(ENOLCK):
		return __ccgo_ts + 59240
	case int32(ENOLINK):
		return __ccgo_ts + 59247
	case int32(ENOMEM):
		return __ccgo_ts + 59255
	case int32(ENOMEDIUM):
		return __ccgo_ts + 59262
	case int32(ENOMSG):
		return __ccgo_ts + 59272
	case int32(ENONET):
		return __ccgo_ts + 59279
	case int32(ENOPKG):
		return __ccgo_ts + 59286
	case int32(ENOPROTOOPT):
		return __ccgo_ts + 59293
	case int32(ENOSPC):
		return __ccgo_ts + 59305
	case int32(ENOSR):
		return __ccgo_ts + 59312
	case int32(ENOSTR):
		return __ccgo_ts + 59318
	case int32(ENOSYS):
		return __ccgo_ts + 59325
	case int32(ENOTBLK):
		return __ccgo_ts + 59332
	case int32(ENOTCONN):
		return __ccgo_ts + 59340
	case int32(ENOTRECOVERABLE):
		return __ccgo_ts + 59349
	case int32(ENOTDIR):
		return __ccgo_ts + 59365
	case int32(ENOTEMPTY):
		return __ccgo_ts + 59373
	case int32(ENOTNAM):
		return __ccgo_ts + 59383
	case int32(ENOTSOCK):
		return __ccgo_ts + 59391
	case int32(EOPNOTSUPP):
		return __ccgo_ts + 59400
	case int32(ENOTTY):
		return __ccgo_ts + 59408
	case int32(ENOTUNIQ):
		return __ccgo_ts + 59415
	case int32(ENXIO):
		return __ccgo_ts + 59424
	case int32(EOVERFLOW):
		return __ccgo_ts + 59430
	case int32(EOWNERDEAD):
		return __ccgo_ts + 59440
	case int32(EPERM):
		return __ccgo_ts + 59451
	case int32(EPFNOSUPPORT):
		return __ccgo_ts + 59457
	case int32(EPIPE):
		return __ccgo_ts + 59470
	case int32(EPROTO):
		return __ccgo_ts + 59476
	case int32(EPROTONOSUPPORT):
		return __ccgo_ts + 59483
	case int32(EPROTOTYPE):
		return __ccgo_ts + 59499
	case int32(ERANGE):
		return __ccgo_ts + 59510
	case int32(EREMCHG):
		return __ccgo_ts + 59517
	case int32(EREMOTE):
		return __ccgo_ts + 59525
	case int32(EREMOTEIO):
		return __ccgo_ts + 59533
	case int32(ERESTART):
		return __ccgo_ts + 59543
	case int32(EROFS):
		return __ccgo_ts + 59552
	case int32(ESHUTDOWN):
		return __ccgo_ts + 59558
	case int32(ESOCKTNOSUPPORT):
		return __ccgo_ts + 59568
	case int32(ESPIPE):
		return __ccgo_ts + 59584
	case int32(ESRCH):
		return __ccgo_ts + 59591
	case int32(ESRMNT):
		return __ccgo_ts + 59597
	case int32(ESTALE):
		return __ccgo_ts + 59604
	case int32(ETIME):
		return __ccgo_ts + 59611
	case int32(ETIMEDOUT):
		return __ccgo_ts + 59617
	case int32(ETOOMANYREFS):
		return __ccgo_ts + 59627
	case int32(ETXTBSY):
		return __ccgo_ts + 59640
	case int32(EUCLEAN):
		return __ccgo_ts + 59648
	case int32(EUNATCH):
		return __ccgo_ts + 59656
	case int32(EUSERS):
		return __ccgo_ts + 59664
	case int32(EXDEV):
		return __ccgo_ts + 59671
	case int32(EXFULL):
		return __ccgo_ts + 59677
	}
	return __ccgo_ts + 59684
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ErrnoMsg --
 *
 *	Return a human-readable message corresponding to a given errno value.
 *
 * Results:
 *	The return value is the standard POSIX error message for errno.  This
 *	procedure is used instead of strerror because strerror returns
 *	slightly different values on different machines (e.g. different
 *	capitalizations), which cause problems for things such as regression
 *	tests. This procedure provides messages for most standard errors, then
 *	it calls strerror for things it doesn't understand.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ErrnoMsg(tls *libc.TLS, err int32) (r uintptr) {
	/* Error number (such as in errno variable). */
	switch err {
	case int32(E2BIG):
		return __ccgo_ts + 59698
	case int32(EACCES):
		return __ccgo_ts + 59721
	case int32(EADDRINUSE):
		return __ccgo_ts + 59739
	case int32(EADDRNOTAVAIL):
		return __ccgo_ts + 59762
	case int32(EADV):
		return __ccgo_ts + 59794
	case int32(EAFNOSUPPORT):
		return __ccgo_ts + 59810
	case int32(EAGAIN):
		return __ccgo_ts + 59851
	case int32(EALREADY):
		return __ccgo_ts + 59884
	case int32(EBADE):
		return __ccgo_ts + 59914
	case int32(EBADF):
		return __ccgo_ts + 59931
	case int32(EBADFD):
		return __ccgo_ts + 59951
	case int32(EBADMSG):
		return __ccgo_ts + 59980
	case int32(EBADR):
		return __ccgo_ts + 59992
	case int32(EBADRQC):
		return __ccgo_ts + 60019
	case int32(EBADSLT):
		return __ccgo_ts + 60040
	case int32(EBFONT):
		return __ccgo_ts + 60053
	case int32(EBUSY):
		return __ccgo_ts + 60074
	case int32(ECANCELED):
		return __ccgo_ts + 60098
	case int32(ECHILD):
		return __ccgo_ts + 60117
	case int32(ECHRNG):
		return __ccgo_ts + 60136
	case int32(ECOMM):
		return __ccgo_ts + 60164
	case int32(ECONNABORTED):
		return __ccgo_ts + 60192
	case int32(ECONNREFUSED):
		return __ccgo_ts + 60225
	case int32(ECONNRESET):
		return __ccgo_ts + 60244
	case int32(EDEADLK):
		return __ccgo_ts + 60269
	case int32(EDESTADDRREQ):
		return __ccgo_ts + 60295
	case int32(EDOM):
		return __ccgo_ts + 60324
	case int32(EDOTDOT):
		return __ccgo_ts + 60357
	case int32(EDQUOT):
		return __ccgo_ts + 60375
	case int32(EEXIST):
		return __ccgo_ts + 60395
	case int32(EFAULT):
		return __ccgo_ts + 60407
	case int32(EFBIG):
		return __ccgo_ts + 60419
	case int32(EHOSTDOWN):
		return __ccgo_ts + 60434
	case int32(EHOSTUNREACH):
		return __ccgo_ts + 60447
	case int32(EIDRM):
		return __ccgo_ts + 60464
	case int32(EILSEQ):
		return __ccgo_ts + 60483
	case int32(EINPROGRESS):
		return __ccgo_ts + 60533
	case int32(EINTR):
		return __ccgo_ts + 60559
	case int32(EINVAL):
		return __ccgo_ts + 60583
	case int32(EIO):
		return __ccgo_ts + 60600
	case int32(EISCONN):
		return __ccgo_ts + 60619
	case int32(EISDIR):
		return __ccgo_ts + 60659
	case int32(EISNAM):
		return __ccgo_ts + 60674
	case int32(EL2HLT):
		return __ccgo_ts + 60695
	case int32(EL2NSYNC):
		return __ccgo_ts + 60710
	case int32(EL3HLT):
		return __ccgo_ts + 60735
	case int32(EL3RST):
		return __ccgo_ts + 60750
	case int32(ELIBACC):
		return __ccgo_ts + 60764
	case int32(ELIBBAD):
		return __ccgo_ts + 60803
	case int32(ELIBEXEC):
		return __ccgo_ts + 60840
	case int32(ELIBMAX):
		return __ccgo_ts + 60878
	case int32(ELIBSCN):
		return __ccgo_ts + 60926
	case int32(ELNRNG):
		return __ccgo_ts + 60958
	case int32(ELOOP):
		return __ccgo_ts + 60983
	case int32(EMEDIUMTYPE):
		return __ccgo_ts + 61017
	case int32(EMFILE):
		return __ccgo_ts + 61035
	case int32(EMLINK):
		return __ccgo_ts + 61055
	case int32(EMSGSIZE):
		return __ccgo_ts + 61070
	case int32(EMULTIHOP):
		return __ccgo_ts + 61087
	case int32(ENAMETOOLONG):
		return __ccgo_ts + 61106
	case int32(ENAVAIL):
		return __ccgo_ts + 61125
	case int32(ENETDOWN):
		return __ccgo_ts + 61139
	case int32(ENETRESET):
		return __ccgo_ts + 61155
	case int32(ENETUNREACH):
		return __ccgo_ts + 61191
	case int32(ENFILE):
		return __ccgo_ts + 61214
	case int32(ENOANO):
		return __ccgo_ts + 61244
	case int32(ENOBUFS):
		return __ccgo_ts + 61253
	case int32(ENOCSI):
		return __ccgo_ts + 61279
	case int32(ENODATA):
		return __ccgo_ts + 61306
	case int32(ENODEV):
		return __ccgo_ts + 61324
	case int32(ENOENT):
		return __ccgo_ts + 61339
	case int32(ENOEXEC):
		return __ccgo_ts + 61365
	case int32(ENOLCK):
		return __ccgo_ts + 61383
	case int32(ENOLINK):
		return __ccgo_ts + 61402
	case int32(ENOMEM):
		return __ccgo_ts + 61424
	case int32(ENOMEDIUM):
		return __ccgo_ts + 61447
	case int32(ENOMSG):
		return __ccgo_ts + 61463
	case int32(ENONET):
		return __ccgo_ts + 61490
	case int32(ENOPKG):
		return __ccgo_ts + 61520
	case int32(ENOPROTOOPT):
		return __ccgo_ts + 61542
	case int32(ENOSPC):
		return __ccgo_ts + 61565
	case int32(ENOSR):
		return __ccgo_ts + 61589
	case int32(ENOSTR):
		return __ccgo_ts + 61614
	case int32(ENOSYS):
		return __ccgo_ts + 61634
	case int32(ENOTBLK):
		return __ccgo_ts + 61659
	case int32(ENOTCONN):
		return __ccgo_ts + 61681
	case int32(ENOTDIR):
		return __ccgo_ts + 61717
	case int32(ENOTEMPTY):
		return __ccgo_ts + 61733
	case int32(ENOTNAM):
		return __ccgo_ts + 61753
	case int32(ENOTRECOVERABLE):
		return __ccgo_ts + 61769
	case int32(ENOTSOCK):
		return __ccgo_ts + 61791
	case int32(EOPNOTSUPP):
		return __ccgo_ts + 61822
	case int32(ENOTTY):
		return __ccgo_ts + 61846
	case int32(ENOTUNIQ):
		return __ccgo_ts + 61877
	case int32(ENXIO):
		return __ccgo_ts + 61904
	case int32(EOVERFLOW):
		return __ccgo_ts + 61930
	case int32(EOWNERDEAD):
		return __ccgo_ts + 61968
	case int32(EPERM):
		return __ccgo_ts + 61979
	case int32(EPFNOSUPPORT):
		return __ccgo_ts + 62003
	case int32(EPIPE):
		return __ccgo_ts + 62033
	case int32(EPROTO):
		return __ccgo_ts + 62045
	case int32(EPROTONOSUPPORT):
		return __ccgo_ts + 62060
	case int32(EPROTOTYPE):
		return __ccgo_ts + 62083
	case int32(ERANGE):
		return __ccgo_ts + 62114
	case int32(EREMCHG):
		return __ccgo_ts + 62144
	case int32(EREMOTE):
		return __ccgo_ts + 62167
	case int32(EREMOTEIO):
		return __ccgo_ts + 62184
	case int32(ERESTART):
		return __ccgo_ts + 62201
	case int32(EROFS):
		return __ccgo_ts + 62245
	case int32(ESHUTDOWN):
		return __ccgo_ts + 62267
	case int32(ESOCKTNOSUPPORT):
		return __ccgo_ts + 62313
	case int32(ESPIPE):
		return __ccgo_ts + 62339
	case int32(ESRCH):
		return __ccgo_ts + 62352
	case int32(ESRMNT):
		return __ccgo_ts + 62368
	case int32(ESTALE):
		return __ccgo_ts + 62382
	case int32(ESTRPIPE):
		return __ccgo_ts + 62400
	case int32(ETIME):
		return __ccgo_ts + 62419
	case int32(ETIMEDOUT):
		return __ccgo_ts + 62433
	case int32(ETOOMANYREFS):
		return __ccgo_ts + 62454
	case int32(ETXTBSY):
		return __ccgo_ts + 62489
	case int32(EUCLEAN):
		return __ccgo_ts + 62504
	case int32(EUNATCH):
		return __ccgo_ts + 62529
	case int32(EUSERS):
		return __ccgo_ts + 62558
	case int32(EXDEV):
		return __ccgo_ts + 62573
	case int32(EXFULL):
		return __ccgo_ts + 62599
	default:
		return libc.Xstrerror(tls, err)
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SignalId --
 *
 *	Return a textual identifier for a signal number.
 *
 * Results:
 *	This procedure returns a machine-readable textual identifier that
 *	corresponds to sig.  The identifier is the same as the #define name in
 *	signal.h.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SignalId(tls *libc.TLS, sig int32) (r uintptr) {
	/* Number of signal. */
	switch sig {
	case int32(SIGABRT):
		return __ccgo_ts + 62613
	case int32(SIGALRM):
		return __ccgo_ts + 62621
	case int32(SIGBUS):
		return __ccgo_ts + 62629
	case int32(SIGCHLD):
		return __ccgo_ts + 62636
	case int32(SIGCONT):
		return __ccgo_ts + 62644
	case int32(SIGFPE):
		return __ccgo_ts + 62652
	case int32(SIGHUP):
		return __ccgo_ts + 62659
	case int32(SIGILL):
		return __ccgo_ts + 62666
	case int32(SIGINT):
		return __ccgo_ts + 62673
	case int32(SIGIO):
		return __ccgo_ts + 62680
	case int32(SIGKILL):
		return __ccgo_ts + 62686
	case int32(SIGPIPE):
		return __ccgo_ts + 62694
	case int32(SIGPROF):
		return __ccgo_ts + 62702
	case int32(SIGPWR):
		return __ccgo_ts + 62710
	case int32(SIGQUIT):
		return __ccgo_ts + 62717
	case int32(SIGSEGV):
		return __ccgo_ts + 62725
	case int32(SIGSTOP):
		return __ccgo_ts + 62733
	case int32(SIGSYS):
		return __ccgo_ts + 62741
	case int32(SIGTERM):
		return __ccgo_ts + 62748
	case int32(SIGTRAP):
		return __ccgo_ts + 62756
	case int32(SIGTSTP):
		return __ccgo_ts + 62764
	case int32(SIGTTIN):
		return __ccgo_ts + 62772
	case int32(SIGTTOU):
		return __ccgo_ts + 62780
	case int32(SIGURG):
		return __ccgo_ts + 62788
	case int32(SIGUSR1):
		return __ccgo_ts + 62795
	case int32(SIGUSR2):
		return __ccgo_ts + 62803
	case int32(SIGVTALRM):
		return __ccgo_ts + 62811
	case int32(SIGWINCH):
		return __ccgo_ts + 62821
	case int32(SIGXCPU):
		return __ccgo_ts + 62830
	case int32(SIGXFSZ):
		return __ccgo_ts + 62838
	}
	return __ccgo_ts + 62846
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SignalMsg --
 *
 *	Return a human-readable message describing a signal.
 *
 * Results:
 *	This procedure returns a string describing sig that should make sense
 *	to a human.  It may not be easy for a machine to parse.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SignalMsg(tls *libc.TLS, sig int32) (r uintptr) {
	/* Number of signal. */
	switch sig {
	case int32(SIGABRT):
		return __ccgo_ts + 62613
	case int32(SIGALRM):
		return __ccgo_ts + 62861
	case int32(SIGBUS):
		return __ccgo_ts + 62873
	case int32(SIGCHLD):
		return __ccgo_ts + 62883
	case int32(SIGCONT):
		return __ccgo_ts + 62904
	case int32(SIGFPE):
		return __ccgo_ts + 62924
	case int32(SIGHUP):
		return __ccgo_ts + 62949
	case int32(SIGILL):
		return __ccgo_ts + 62956
	case int32(SIGINT):
		return __ccgo_ts + 62976
	case int32(SIGIO):
		return __ccgo_ts + 62986
	case int32(SIGKILL):
		return __ccgo_ts + 63016
	case int32(SIGPIPE):
		return __ccgo_ts + 63028
	case int32(SIGPROF):
		return __ccgo_ts + 63058
	case int32(SIGPWR):
		return __ccgo_ts + 63074
	case int32(SIGQUIT):
		return __ccgo_ts + 63093
	case int32(SIGSEGV):
		return __ccgo_ts + 63105
	case int32(SIGSTOP):
		return __ccgo_ts + 63128
	case int32(SIGSYS):
		return __ccgo_ts + 63133
	case int32(SIGTERM):
		return __ccgo_ts + 63161
	case int32(SIGTRAP):
		return __ccgo_ts + 63189
	case int32(SIGTSTP):
		return __ccgo_ts + 63200
	case int32(SIGTTIN):
		return __ccgo_ts + 63221
	case int32(SIGTTOU):
		return __ccgo_ts + 63241
	case int32(SIGURG):
		return __ccgo_ts + 63262
	case int32(SIGUSR1):
		return __ccgo_ts + 63283
	case int32(SIGUSR2):
		return __ccgo_ts + 63305
	case int32(SIGVTALRM):
		return __ccgo_ts + 63327
	case int32(SIGWINCH):
		return __ccgo_ts + 63346
	case int32(SIGXCPU):
		return __ccgo_ts + 63361
	case int32(SIGXFSZ):
		return __ccgo_ts + 63385
	}
	return __ccgo_ts + 62846
}

const INITIAL_SIZE = 2

/* Epoch of the tcl environment
 * (if changed with tcl-env). */

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * The following data structure is used to keep track of all the Tcl_Preserve
 * calls that are still in effect. It grows as needed to accommodate any
 * number of calls in effect.
 */

type TReference = struct {
	FclientData uintptr
	FrefCount   Tsize_t
	FmustFree   int32
	FfreeProc   uintptr
}

/*
 * Global data structures used to hold the list of preserved data references.
 * These variables are protected by "preserveMutex".
 */

var _refArray = libc.UintptrFromInt32(0)

// C documentation
//
//	/* First in array of references. */
var _spaceAvl = uint64(0) /* Total number of structures available at
 * *firstRefPtr. */
var _inUse = uint64(0) /* Count of structures currently in use in
 * refArray. */

var _preserveMutex TTcl_Mutex

/* To protect the above statics */

/*
 * The following data structure is used to keep track of whether an arbitrary
 * block of memory has been deleted. This is used by the TclHandle code to
 * avoid the more time-expensive algorithm of Tcl_Preserve(). This mechanism
 * is mainly used when we have lots of references to a few big, expensive
 * objects that we don't want to live any longer than necessary.
 */

type THandleStruct = struct {
	Fptr      uintptr
	FrefCount Tsize_t
}

/*
 *----------------------------------------------------------------------
 *
 * TclFinalizePreserve --
 *
 *	Called during exit processing to clean up the reference array.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Frees the storage of the reference array.
 *
 *----------------------------------------------------------------------
 */

func XTclFinalizePreserve(tls *libc.TLS) {
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_preserveMutex)))
	if _spaceAvl != uint64(0) {
		XTclpFree(tls, _refArray)
		_refArray = libc.UintptrFromInt32(0)
		_inUse = uint64(0)
		_spaceAvl = uint64(0)
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_preserveMutex)))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_Preserve --
 *
 *	This function is used by a function to declare its interest in a
 *	particular block of memory, so that the block will not be reallocated
 *	until a matching call to Tcl_Release has been made.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Information is retained so that the block of memory will not be freed
 *	until at least the matching call to Tcl_Release.
 *
 *----------------------------------------------------------------------
 */

func XTcl_Preserve(tls *libc.TLS, clientData uintptr) {
	/* Pointer to malloc'ed block of memory. */
	var i Tsize_t
	var refPtr uintptr
	var v2 uint64
	_, _, _ = i, refPtr, v2
	/*
	 * See if there is already a reference for this pointer. If so, just
	 * increment its reference count.
	 */
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_preserveMutex)))
	i = uint64(0)
	refPtr = _refArray
	for {
		if !(i < _inUse) {
			break
		}
		if (*TReference)(unsafe.Pointer(refPtr)).FclientData == clientData {
			(*TReference)(unsafe.Pointer(refPtr)).FrefCount++
			XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_preserveMutex)))
			return
		}
		goto _1
	_1:
		;
		i++
		refPtr += 32
	}
	/*
	 * Make a reference array if it doesn't already exist, or make it bigger
	 * if it is full.
	 */
	if _inUse == _spaceAvl {
		if _spaceAvl != 0 {
			v2 = uint64(2) * _spaceAvl
		} else {
			v2 = uint64(INITIAL_SIZE)
		}
		_spaceAvl = v2
		_refArray = XTcl_Realloc(tls, _refArray, _spaceAvl*uint64(32))
	}
	/*
	 * Make a new entry for the new reference.
	 */
	refPtr = _refArray + uintptr(_inUse)*32
	(*TReference)(unsafe.Pointer(refPtr)).FclientData = clientData
	(*TReference)(unsafe.Pointer(refPtr)).FrefCount = uint64(1)
	(*TReference)(unsafe.Pointer(refPtr)).FmustFree = 0
	(*TReference)(unsafe.Pointer(refPtr)).FfreeProc = uintptr(0)
	_inUse += uint64(1)
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_preserveMutex)))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_Release --
 *
 *	This function is called to cancel a previous call to Tcl_Preserve,
 *	thereby allowing a block of memory to be freed (if no one else cares
 *	about it).
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	If Tcl_EventuallyFree has been called for clientData, and if no other
 *	call to Tcl_Preserve is still in effect, the block of memory is freed.
 *
 *----------------------------------------------------------------------
 */

func XTcl_Release(tls *libc.TLS, clientData uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Pointer to malloc'ed block of memory. */
	var freeProc, refPtr, v3 uintptr
	var i, v2 Tsize_t
	var mustFree int32
	_, _, _, _, _, _ = freeProc, i, mustFree, refPtr, v2, v3
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_preserveMutex)))
	i = uint64(0)
	refPtr = _refArray
	for {
		if !(i < _inUse) {
			break
		}
		if (*TReference)(unsafe.Pointer(refPtr)).FclientData != clientData {
			goto _1
		}
		v3 = refPtr + 8
		v2 = *(*Tsize_t)(unsafe.Pointer(v3))
		*(*Tsize_t)(unsafe.Pointer(v3))--
		if v2 > uint64(1) {
			XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_preserveMutex)))
			return
		}
		/*
		 * Must remove information from the slot before calling freeProc to
		 * avoid reentrancy problems if the freeProc calls Tcl_Preserve on the
		 * same clientData. Copy down the last reference in the array to
		 * overwrite the current slot.
		 */
		freeProc = (*TReference)(unsafe.Pointer(refPtr)).FfreeProc
		mustFree = (*TReference)(unsafe.Pointer(refPtr)).FmustFree
		_inUse--
		if i < _inUse {
			*(*TReference)(unsafe.Pointer(_refArray + uintptr(i)*32)) = *(*TReference)(unsafe.Pointer(_refArray + uintptr(_inUse)*32))
		}
		/*
		 * Now committed to disposing the data. But first, we've patched up
		 * all the global data structures so we should release the mutex now.
		 * Only then should we dabble around with potentially-slow memory
		 * managers...
		 */
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_preserveMutex)))
		if mustFree != 0 {
			if freeProc == libc.UintptrFromInt32(3) {
				XTclpFree(tls, clientData)
			} else {
				(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{freeProc})))(tls, clientData)
			}
		}
		return
		goto _1
	_1:
		;
		i++
		refPtr += 32
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_preserveMutex)))
	/*
	 * Reference not found. This is a bug in the caller.
	 */
	XTcl_Panic(tls, __ccgo_ts+63410, libc.VaList(bp+8, clientData))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_EventuallyFree --
 *
 *	Free up a block of memory, unless a call to Tcl_Preserve is in effect
 *	for that block. In this case, defer the free until all calls to
 *	Tcl_Preserve have been undone by matching calls to Tcl_Release.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Ptr may be released by calling free().
 *
 *----------------------------------------------------------------------
 */

func XTcl_EventuallyFree(tls *libc.TLS, clientData uintptr, freeProc uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Function to actually do free. */
	var i Tsize_t
	var refPtr uintptr
	_, _ = i, refPtr
	/*
	 * See if there is a reference for this pointer. If so, set its "mustFree"
	 * flag (the flag had better not be set already!).
	 */
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_preserveMutex)))
	i = uint64(0)
	refPtr = _refArray
	for {
		if !(i < _inUse) {
			break
		}
		if (*TReference)(unsafe.Pointer(refPtr)).FclientData != clientData {
			goto _1
		}
		if (*TReference)(unsafe.Pointer(refPtr)).FmustFree != 0 {
			XTcl_Panic(tls, __ccgo_ts+63453, libc.VaList(bp+8, clientData))
		}
		(*TReference)(unsafe.Pointer(refPtr)).FmustFree = int32(1)
		(*TReference)(unsafe.Pointer(refPtr)).FfreeProc = freeProc
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_preserveMutex)))
		return
		goto _1
	_1:
		;
		i++
		refPtr += 32
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_preserveMutex)))
	/*
	 * No reference for this block.  Free it now.
	 */
	if freeProc == libc.UintptrFromInt32(3) {
		XTclpFree(tls, clientData)
	} else {
		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{freeProc})))(tls, clientData)
	}
}

/*
 *---------------------------------------------------------------------------
 *
 * TclHandleCreate --
 *
 *	Allocate a handle that contains enough information to determine if an
 *	arbitrary malloc'd block has been deleted. This is used to avoid the
 *	more time-expensive algorithm of Tcl_Preserve().
 *
 * Results:
 *	The return value is a TclHandle that refers to the given malloc'd
 *	block. Doubly dereferencing the returned handle will give back the
 *	pointer to the block, or will give NULL if the block has been deleted.
 *
 * Side effects:
 *	The caller must keep track of this handle (generally by storing it in
 *	a field in the malloc'd block) and call TclHandleFree() on this handle
 *	when the block is deleted. Everything else that wishes to keep track
 *	of whether the malloc'd block has been deleted should use calls to
 *	TclHandlePreserve() and TclHandleRelease() on the associated handle.
 *
 *---------------------------------------------------------------------------
 */

func XTclHandleCreate(tls *libc.TLS, ptr uintptr) (r TTclHandle) {
	/* Pointer to an arbitrary block of memory to
	 * be tracked for deletion. Must not be
	 * NULL. */
	var handlePtr uintptr
	_ = handlePtr
	handlePtr = XTcl_Alloc(tls, uint64(16))
	(*THandleStruct)(unsafe.Pointer(handlePtr)).Fptr = ptr
	(*THandleStruct)(unsafe.Pointer(handlePtr)).FrefCount = uint64(0)
	return handlePtr
}

/*
 *---------------------------------------------------------------------------
 *
 * TclHandleFree --
 *
 *	Called when the arbitrary malloc'd block associated with the handle is
 *	being deleted. Modifies the handle so that doubly dereferencing it
 *	will give NULL. This informs any user of the handle that the block of
 *	memory formerly referenced by the handle has been freed.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	If nothing is referring to the handle, the handle will be reclaimed.
 *
 *---------------------------------------------------------------------------
 */

func XTclHandleFree(tls *libc.TLS, handle TTclHandle) {
	/* Previously created handle associated with a
	 * malloc'd block that is being deleted. The
	 * handle is modified so that doubly
	 * dereferencing it will give NULL. */
	var handlePtr uintptr
	_ = handlePtr
	handlePtr = handle
	(*THandleStruct)(unsafe.Pointer(handlePtr)).Fptr = libc.UintptrFromInt32(0)
	if (*THandleStruct)(unsafe.Pointer(handlePtr)).FrefCount == uint64(0) {
		XTclpFree(tls, handlePtr)
	}
}

/*
 *---------------------------------------------------------------------------
 *
 * TclHandlePreserve --
 *
 *	Declare an interest in the arbitrary malloc'd block associated with
 *	the handle.
 *
 * Results:
 *	The return value is the handle argument, with its ref count
 *	incremented.
 *
 * Side effects:
 *	For each call to TclHandlePreserve(), there should be a matching call
 *	to TclHandleRelease() when the caller is no longer interested in the
 *	malloc'd block associated with the handle.
 *
 *---------------------------------------------------------------------------
 */

func XTclHandlePreserve(tls *libc.TLS, handle TTclHandle) (r TTclHandle) {
	/* Declare an interest in the block of memory
	 * referenced by this handle. */
	var handlePtr uintptr
	_ = handlePtr
	handlePtr = handle
	(*THandleStruct)(unsafe.Pointer(handlePtr)).FrefCount++
	return handle
}

/*
 *---------------------------------------------------------------------------
 *
 * TclHandleRelease --
 *
 *	This function is called to release an interest in the malloc'd block
 *	associated with the handle.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The ref count of the handle is decremented. If the malloc'd block has
 *	been freed and if no one is using the handle any more, the handle will
 *	be reclaimed.
 *
 *---------------------------------------------------------------------------
 */

func XTclHandleRelease(tls *libc.TLS, handle TTclHandle) {
	/* Unregister interest in the block of memory
	 * referenced by this handle. */
	var handlePtr, v2 uintptr
	var v1 Tsize_t
	_, _, _ = handlePtr, v1, v2
	handlePtr = handle
	v2 = handlePtr + 8
	v1 = *(*Tsize_t)(unsafe.Pointer(v2))
	*(*Tsize_t)(unsafe.Pointer(v2))--
	if v1 <= uint64(1) && (*THandleStruct)(unsafe.Pointer(handlePtr)).Fptr == libc.UintptrFromInt32(0) {
		XTclpFree(tls, handlePtr)
	}
}

/*
 * Variables that are part of the [apply] command implementation and which
 * have to be passed to the other side of the NRE call.
 */

type TApplyExtraData = struct {
	Fcmd TCommand
	Fefi TExtraFrameInfo
}

func init() {
	p := unsafe.Pointer(&XtclProcBodyType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_ProcBodyFree)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_ProcBodyDup)
}

/*
 * The [upvar]/[uplevel] level reference type. Uses the wideValue field
 * to remember the integer value of a parsed #<integer> format.
 *
 * Uses the default behaviour throughout, and never disposes of the string
 * rep; it's just a cache type.
 */

var _levelReferenceType = TTcl_ObjType{
	Fname:    __ccgo_ts + 63501,
	Fversion: uint64(libc.UintptrFromInt32(0) + 56),
}

func init() {
	p := unsafe.Pointer(&_levelReferenceType)
	*(*uintptr)(unsafe.Add(p, 48)) = __ccgo_fp(XTclLengthOne)
}

/*
 * The type of lambdas. Note that every lambda will *always* have a string
 * representation.
 *
 * Internally, ptr1 is a pointer to a Proc instance that is not bound to a
 * command name, and ptr2 is a pointer to the namespace that the Proc instance
 * will execute within. IF YOU CHANGE THIS, CHECK IN tclDisassemble.c TOO.
 */

var _lambdaType = TTcl_ObjType{
	Fname: __ccgo_ts + 63516,
}

func init() {
	p := unsafe.Pointer(&_lambdaType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_FreeLambdaInternalRep)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_DupLambdaInternalRep)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_SetLambdaFromAny)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ProcObjCmd --
 *
 *	This object-based function is invoked to process the "proc" Tcl
 *	command. See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl object result value.
 *
 * Side effects:
 *	A new procedure gets created.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ProcObjCmd(tls *libc.TLS, dummy160 uintptr, interp uintptr, objc TTcl_Size, objv uintptr) (r int32) {
	bp := tls.Alloc(96)
	defer tls.Free(96) /* Argument objects. */
	var _objPtr, _objPtr1, cfOldPtr, cfPtr, contextPtr, hePtr, iPtr, procArgs, procBody, procName, v1, v3, v5, v6, v7 uintptr
	var cmd TTcl_Command
	var v2, v4 TTcl_Size
	var _ /* altNsPtr at bp+24 */ uintptr
	var _ /* cxtNsPtr at bp+32 */ uintptr
	var _ /* isNew at bp+40 */ int32
	var _ /* nsPtr at bp+16 */ uintptr
	var _ /* numBytes at bp+48 */ TTcl_Size
	var _ /* procPtr at bp+0 */ uintptr
	var _ /* simpleName at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cfOldPtr, cfPtr, cmd, contextPtr, hePtr, iPtr, procArgs, procBody, procName, v1, v2, v3, v4, v5, v6, v7
	iPtr = interp
	if objc != int64(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+63527)
		return int32(TCL_ERROR)
	}
	/*
	 * Determine the namespace where the procedure should reside. Unless the
	 * command name includes namespace qualifiers, this will be the current
	 * namespace.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	procName = v1
	XTclGetNamespaceForQualName(tls, interp, procName, libc.UintptrFromInt32(0), 0, bp+16, bp+24, bp+32, bp+8)
	if *(*uintptr)(unsafe.Pointer(bp + 16)) == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+10080, libc.VaList(bp+64, procName)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+64, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+8118, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if *(*uintptr)(unsafe.Pointer(bp + 8)) == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+10137, libc.VaList(bp+64, procName)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+64, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+8118, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Create the data structure to represent the procedure.
	 */
	if XTclCreateProc(tls, interp, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 8)), *(*uintptr)(unsafe.Pointer(objv + 2*8)), *(*uintptr)(unsafe.Pointer(objv + 3*8)), bp) != TCL_OK {
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+63542, int64(-int32(1))))
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), int64(-int32(1))))
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+8564, int64(-int32(1))))
		return int32(TCL_ERROR)
	}
	cmd = XTclNRCreateCommandInNs(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 8)), *(*uintptr)(unsafe.Pointer(bp + 16)), __ccgo_fp(XTclObjInterpProc), __ccgo_fp(_NRInterpProc), *(*uintptr)(unsafe.Pointer(bp)), __ccgo_fp(XTclProcDeleteProc))
	/*
	 * Now initialize the new procedure's cmdPtr field. This will be used
	 * later when the procedure is called to determine what namespace the
	 * procedure will run in. This will be different than the current
	 * namespace if the proc was renamed into a different namespace.
	 */
	(*TProc)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FcmdPtr = cmd
	/*
	 * TIP #280: Remember the line the procedure body is starting on. In a
	 * bytecode context we ask the engine to provide us with the necessary
	 * information. This is for the initialization of the byte code compiler
	 * when the body is used for the first time.
	 *
	 * This code is nearly identical to the #280 code in SetLambdaFromAny, see
	 * this file. The differences are the different index of the body in the
	 * line array of the context, and the lambda code requires some special
	 * processing. Find a way to factor the common elements into a single
	 * function.
	 */
	if (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr != 0 {
		contextPtr = XTclStackAlloc(tls, interp, uint64(88))
		*(*TCmdFrame)(unsafe.Pointer(contextPtr)) = *(*TCmdFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr))
		if (*TCmdFrame)(unsafe.Pointer(contextPtr)).Ftype1 == int32(TCL_LOCATION_BC) {
			/*
			 * Retrieve source information from the bytecode, if possible. If
			 * the information is retrieved successfully, context.type will be
			 * TCL_LOCATION_SOURCE and the reference held by
			 * context.data.eval.path will be counted.
			 */
			XTclGetSrcInfoForPc(tls, contextPtr)
		} else {
			if (*TCmdFrame)(unsafe.Pointer(contextPtr)).Ftype1 == int32(TCL_LOCATION_SOURCE) {
				/*
				 * The copy into 'context' up above has created another reference
				 * to 'context.data.eval.path'; account for it.
				 */
				(*TTcl_Obj)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(contextPtr)).Fdata.Feval.Fpath)).FrefCount++
			}
		}
		if (*TCmdFrame)(unsafe.Pointer(contextPtr)).Ftype1 == int32(TCL_LOCATION_SOURCE) {
			/*
			 * We can account for source location within a proc only if the
			 * proc body was not created by substitution.
			 */
			if (*TCmdFrame)(unsafe.Pointer(contextPtr)).Fline != 0 && (*TCmdFrame)(unsafe.Pointer(contextPtr)).Fnline >= int64(4) && *(*TTcl_Size)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(contextPtr)).Fline + 3*8)) >= 0 {
				cfPtr = XTcl_Alloc(tls, uint64(88))
				(*TCmdFrame)(unsafe.Pointer(cfPtr)).Flevel = -int32(1)
				(*TCmdFrame)(unsafe.Pointer(cfPtr)).Ftype1 = (*TCmdFrame)(unsafe.Pointer(contextPtr)).Ftype1
				(*TCmdFrame)(unsafe.Pointer(cfPtr)).Fline = XTcl_Alloc(tls, uint64(8))
				*(*TTcl_Size)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(cfPtr)).Fline)) = *(*TTcl_Size)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(contextPtr)).Fline + 3*8))
				(*TCmdFrame)(unsafe.Pointer(cfPtr)).Fnline = int64(1)
				(*TCmdFrame)(unsafe.Pointer(cfPtr)).FframePtr = libc.UintptrFromInt32(0)
				(*TCmdFrame)(unsafe.Pointer(cfPtr)).FnextPtr = libc.UintptrFromInt32(0)
				(*TCmdFrame)(unsafe.Pointer(cfPtr)).Fdata.Feval.Fpath = (*TCmdFrame)(unsafe.Pointer(contextPtr)).Fdata.Feval.Fpath
				(*TTcl_Obj)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(cfPtr)).Fdata.Feval.Fpath)).FrefCount++
				(*TCmdFrame)(unsafe.Pointer(cfPtr)).Fcmd = libc.UintptrFromInt32(0)
				(*TCmdFrame)(unsafe.Pointer(cfPtr)).Flen1 = 0
				hePtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FlinePBodyPtr)).FcreateProc})))(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlinePBodyPtr, *(*uintptr)(unsafe.Pointer(bp)), bp+40)
				if !(*(*int32)(unsafe.Pointer(bp + 40)) != 0) {
					/*
					 * Get the old command frame and release it. See also
					 * TclProcCleanupProc in this file. Currently it seems as
					 * if only the procbodytest::proc command of the testsuite
					 * is able to trigger this situation.
					 */
					cfOldPtr = (*TTcl_HashEntry)(unsafe.Pointer(hePtr)).FclientData
					if (*TCmdFrame)(unsafe.Pointer(cfOldPtr)).Ftype1 == int32(TCL_LOCATION_SOURCE) {
						_objPtr = (*TCmdFrame)(unsafe.Pointer(cfOldPtr)).Fdata.Feval.Fpath
						v3 = _objPtr
						v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
						*(*TTcl_Size)(unsafe.Pointer(v3))--
						if v2 <= int64(1) {
							XTclFreeObj(tls, _objPtr)
						}
						(*TCmdFrame)(unsafe.Pointer(cfOldPtr)).Fdata.Feval.Fpath = libc.UintptrFromInt32(0)
					}
					XTclpFree(tls, (*TCmdFrame)(unsafe.Pointer(cfOldPtr)).Fline)
					(*TCmdFrame)(unsafe.Pointer(cfOldPtr)).Fline = libc.UintptrFromInt32(0)
					XTclpFree(tls, cfOldPtr)
				}
				(*TTcl_HashEntry)(unsafe.Pointer(hePtr)).FclientData = cfPtr
			}
			/*
			 * 'contextPtr' is going out of scope; account for the reference
			 * that it's holding to the path name.
			 */
			_objPtr1 = (*TCmdFrame)(unsafe.Pointer(contextPtr)).Fdata.Feval.Fpath
			v5 = _objPtr1
			v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
			*(*TTcl_Size)(unsafe.Pointer(v5))--
			if v4 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
			(*TCmdFrame)(unsafe.Pointer(contextPtr)).Fdata.Feval.Fpath = libc.UintptrFromInt32(0)
		}
		XTclStackFree(tls, interp, contextPtr)
	}
	/*
	 * Optimize for no-op procs: if the body is not precompiled (like a TclPro
	 * procbody), and the argument list is just "args" and the body is empty,
	 * define a compileProc to compile a no-op.
	 *
	 * Notes:
	 *	 - cannot be done for any argument list without having different
	 *	   compiled/not-compiled behaviour in the "wrong argument #" case, or
	 *	   making this code much more complicated. In any case, it doesn't
	 *	   seem to make a lot of sense to verify the number of arguments we
	 *	   are about to ignore ...
	 *	 - could be enhanced to handle also non-empty bodies that contain only
	 *	   comments; however, parsing the body will slow down the compilation
	 *	   of all procs whose argument list is just _args_
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclProcBodyType)) {
		goto done
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
		v6 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
	} else {
		v6 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
	}
	procArgs = v6
	for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(procArgs))) == int32(' ') {
		procArgs++
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(procArgs))) == int32('a') && libc.Xstrncmp(tls, procArgs, __ccgo_ts+15990, uint64(4)) == 0 {
		procArgs += uintptr(4)
		for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(procArgs))) != int32('\000') {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(procArgs))) != int32(' ') {
				goto done
			}
			procArgs++
		}
		/*
		 * The argument list is just "args"; check the body
		 */
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 48)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Flength
			v7 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes
		} else {
			v7 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), bp+48)
		}
		procBody = v7
		if XTclParseAllWhiteSpace(tls, procBody, *(*TTcl_Size)(unsafe.Pointer(bp + 48))) < *(*TTcl_Size)(unsafe.Pointer(bp + 48)) {
			goto done
		}
		/*
		 * The body is just spaces: link the compileProc
		 */
		(*TCommand)(unsafe.Pointer(cmd)).FcompileProc = __ccgo_fp(XTclCompileNoOp)
	}
	goto done
done:
	;
	return TCL_OK
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * TclCreateProc --
 *
 *	Creates the data associated with a Tcl procedure definition. This
 *	function knows how to handle two types of body objects: strings and
 *	procbody. Strings are the traditional (and common) value for bodies,
 *	procbody are values created by extensions that have loaded a
 *	previously compiled script.
 *
 * Results:
 *	Returns TCL_OK on success, along with a pointer to a Tcl procedure
 *	definition in procPtrPtr where the cmdPtr field is not initialised.
 *	This definition should be freed by calling TclProcCleanupProc() when
 *	it is no longer needed. Returns TCL_ERROR if anything goes wrong.
 *
 * Side effects:
 *	If anything goes wrong, this function returns an error message in the
 *	interpreter.
 *
 *----------------------------------------------------------------------
 */

func XTclCreateProc(tls *libc.TLS, interp uintptr, dummy405 uintptr, procName uintptr, argsPtr uintptr, bodyPtr uintptr, procPtrPtr uintptr) (r int32) {
	bp := tls.Alloc(112)
	defer tls.Free(112) /* Returns: pointer to proc data. */
	var _objPtr, _objPtr1, argname, argnamei, argnamelast, bytes, errorObj, errorObj1, errorObj2, iPtr, irPtr, localPtr, procPtr, sharedBodyPtr, tmpPtr, value, v1, v11, v12, v13, v14, v15, v16, v18, v2, v20, v3 uintptr
	var i, v17, v19 TTcl_Size
	var precompiled, result, v4, v8 int32
	var v10, v5, v6, v9 int64
	var _ /* argArray at bp+8 */ uintptr
	var _ /* fieldCount at bp+24 */ TTcl_Size
	var _ /* fieldValues at bp+40 */ uintptr
	var _ /* length at bp+16 */ TTcl_Size
	var _ /* nameLength at bp+32 */ TTcl_Size
	var _ /* numArgs at bp+0 */ TTcl_Size
	var _ /* tmpLength at bp+48 */ TTcl_Size
	var _ /* valueLength at bp+56 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, argname, argnamei, argnamelast, bytes, errorObj, errorObj1, errorObj2, i, iPtr, irPtr, localPtr, precompiled, procPtr, result, sharedBodyPtr, tmpPtr, value, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v3, v4, v5, v6, v8, v9
	iPtr = interp
	procPtr = libc.UintptrFromInt32(0)
	localPtr = libc.UintptrFromInt32(0)
	precompiled = 0
	if (*TTcl_Obj)(unsafe.Pointer(bodyPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclProcBodyType)) {
		v1 = bodyPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	procPtr = v2
	if procPtr != libc.UintptrFromInt32(0) {
		/*
		 * Because the body is a TclProProcBody, the actual body is already
		 * compiled, and it is not shared with anyone else, so it's OK not to
		 * unshare it (as a matter of fact, it is bad to unshare it, because
		 * there may be no source code).
		 *
		 * We don't create and initialize a Proc structure for the procedure;
		 * rather, we use what is in the body object. We increment the ref
		 * count of the Proc struct since the command (soon to be created)
		 * will be holding a reference to it.
		 */
		(*TProc)(unsafe.Pointer(procPtr)).FiPtr = iPtr
		(*TProc)(unsafe.Pointer(procPtr)).FrefCount++
		precompiled = int32(1)
	} else {
		/*
		 * If the procedure's body object is shared because its string value
		 * is identical to, e.g., the body of another procedure, we must
		 * create a private copy for this procedure to use. Such sharing of
		 * procedure bodies is rare but can cause problems. A procedure body
		 * is compiled in a context that includes the number of "slots"
		 * allocated by the compiler for local variables. There is a local
		 * variable slot for each formal parameter (the
		 * "procPtr->numCompiledLocals = numArgs" assignment below). This
		 * means that the same code can not be shared by two procedures that
		 * have a different number of arguments, even if their bodies are
		 * identical. Note that we don't use Tcl_DuplicateObj since we would
		 * not want any bytecode internal representation.
		 */
		if (*TTcl_Obj)(unsafe.Pointer(bodyPtr)).FrefCount > int64(1) {
			sharedBodyPtr = bodyPtr
			if (*TTcl_Obj)(unsafe.Pointer(bodyPtr)).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = (*TTcl_Obj)(unsafe.Pointer(bodyPtr)).Flength
				v3 = (*TTcl_Obj)(unsafe.Pointer(bodyPtr)).Fbytes
			} else {
				v3 = XTcl_GetStringFromObj(tls, bodyPtr, bp+16)
			}
			bytes = v3
			bodyPtr = XTcl_NewStringObj(tls, bytes, *(*TTcl_Size)(unsafe.Pointer(bp + 16)))
			/*
			 * TIP #280.
			 * Ensure that the continuation line data for the original body is
			 * not lost and applies to the new body as well.
			 */
			XTclContinuationsCopy(tls, bodyPtr, sharedBodyPtr)
		}
		/*
		 * Create and initialize a Proc structure for the procedure. We
		 * increment the ref count of the procedure's body object since there
		 * will be a reference to it in the Proc structure.
		 */
		(*TTcl_Obj)(unsafe.Pointer(bodyPtr)).FrefCount++
		procPtr = XTcl_Alloc(tls, uint64(64))
		(*TProc)(unsafe.Pointer(procPtr)).FiPtr = iPtr
		(*TProc)(unsafe.Pointer(procPtr)).FrefCount = int64(1)
		(*TProc)(unsafe.Pointer(procPtr)).FbodyPtr = bodyPtr
		(*TProc)(unsafe.Pointer(procPtr)).FnumArgs = 0 /* Actual argument count is set below. */
		(*TProc)(unsafe.Pointer(procPtr)).FnumCompiledLocals = 0
		(*TProc)(unsafe.Pointer(procPtr)).FfirstLocalPtr = libc.UintptrFromInt32(0)
		(*TProc)(unsafe.Pointer(procPtr)).FlastLocalPtr = libc.UintptrFromInt32(0)
	}
	/*
	 * Break up the argument list into argument specifiers, then process each
	 * argument specifier. If the body is precompiled, processing is limited
	 * to checking that the parsed argument is consistent with the one stored
	 * in the Proc.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(argsPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(argsPtr + 32))).Fptr2 != 0 {
			v5 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(argsPtr + 32))).Fptr2)).FspanStart
		} else {
			v5 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(argsPtr + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(argsPtr + 32))).Fptr1 + 40 + uintptr(v5)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(argsPtr + 32))).Fptr2 != 0 {
			v6 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(argsPtr + 32))).Fptr2)).FspanLength
		} else {
			v6 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(argsPtr + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v6
		v4 = libc.Int32FromInt32(TCL_OK)
	} else {
		v4 = XTcl_ListObjGetElements(tls, interp, argsPtr, bp, bp+8)
	}
	result = v4
	if result != TCL_OK {
		goto procError
	}
	if precompiled != 0 {
		if *(*TTcl_Size)(unsafe.Pointer(bp)) > (*TProc)(unsafe.Pointer(procPtr)).FnumArgs {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+63564, libc.VaList(bp+72, procName, *(*TTcl_Size)(unsafe.Pointer(bp)), (*TProc)(unsafe.Pointer(procPtr)).FnumArgs)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+72, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+28605, __ccgo_ts+63642, libc.UintptrFromInt32(0)))
			goto procError
		}
		localPtr = (*TProc)(unsafe.Pointer(procPtr)).FfirstLocalPtr
	} else {
		(*TProc)(unsafe.Pointer(procPtr)).FnumArgs = *(*TTcl_Size)(unsafe.Pointer(bp))
		(*TProc)(unsafe.Pointer(procPtr)).FnumCompiledLocals = *(*TTcl_Size)(unsafe.Pointer(bp))
	}
	i = 0
	for {
		if !(i < *(*TTcl_Size)(unsafe.Pointer(bp))) {
			break
		}
		/*
		 * Now divide the specifier up into name and default.
		 */
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)) + 32))).Fptr2 != 0 {
				v9 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)) + 32))).Fptr2)).FspanStart
			} else {
				v9 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)) + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 40)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)) + 32))).Fptr1 + 40 + uintptr(v9)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)) + 32))).Fptr2 != 0 {
				v10 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)) + 32))).Fptr2)).FspanLength
			} else {
				v10 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = v10
			v8 = libc.Int32FromInt32(TCL_OK)
		} else {
			v8 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)), bp+24, bp+40)
		}
		result = v8
		if result != TCL_OK {
			goto procError
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 24)) > int64(2) {
			errorObj = XTcl_NewStringObj(tls, __ccgo_ts+63655, int64(-int32(1)))
			XTcl_AppendObjToObj(tls, errorObj, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)))
			XTcl_AppendToObj(tls, errorObj, __ccgo_ts+14586, int64(-int32(1)))
			XTcl_SetObjResult(tls, interp, errorObj)
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+72, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+28605, __ccgo_ts+63695, libc.UintptrFromInt32(0)))
			goto procError
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 24)) == 0 || XTcl_GetCharLength(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40))))) == 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+63716, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+72, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+28605, __ccgo_ts+63695, libc.UintptrFromInt32(0)))
			goto procError
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))))).Flength
			v11 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))))).Fbytes
		} else {
			v11 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))), bp+32)
		}
		argname = v11
		/*
		 * Check that the formal parameter name is a scalar.
		 */
		argnamei = argname
		if *(*TTcl_Size)(unsafe.Pointer(bp + 32)) > 0 {
			v12 = argname + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 32))) - uintptr(1)
		} else {
			v12 = argname
		}
		argnamelast = v12
		for argnamei < argnamelast {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(argnamei))) == int32('(') {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(argnamelast))) == int32(')') { /* We have an array element. */
					if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))))).Fbytes != 0 {
						v13 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))))).Fbytes
					} else {
						v13 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))), libc.UintptrFromInt32(0))
					}
					XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+63738, libc.VaList(bp+72, v13)))
					XTcl_SetErrorCode(tls, interp, libc.VaList(bp+72, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+28605, __ccgo_ts+63695, libc.UintptrFromInt32(0)))
					goto procError
				}
			} else {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(argnamei))) == int32(':') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(argnamei + 1))) == int32(':') {
					errorObj1 = XTcl_NewStringObj(tls, __ccgo_ts+63780, int64(-int32(1)))
					XTcl_AppendObjToObj(tls, errorObj1, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))))
					XTcl_AppendToObj(tls, errorObj1, __ccgo_ts+63799, int64(-int32(1)))
					XTcl_SetObjResult(tls, interp, errorObj1)
					XTcl_SetErrorCode(tls, interp, libc.VaList(bp+72, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+28605, __ccgo_ts+63695, libc.UintptrFromInt32(0)))
					goto procError
				}
			}
			argnamei++
		}
		if precompiled != 0 {
			/*
			 * Compare the parsed argument with the stored one. Note that the
			 * only flag value that makes sense at this point is VAR_ARGUMENT
			 * (its value was kept the same as pre VarReform to simplify
			 * tbcload's processing of older byetcodes).
			 *
			 * The only other flag value that is important to retrieve from
			 * precompiled procs is VAR_TEMPORARY (also unchanged). It is
			 * needed later when retrieving the variable names.
			 */
			if (*TCompiledLocal)(unsafe.Pointer(localPtr)).FnameLength != *(*TTcl_Size)(unsafe.Pointer(bp + 32)) || libc.Xmemcmp(tls, localPtr+44, argname, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 32)))) != 0 || (*TCompiledLocal)(unsafe.Pointer(localPtr)).FframeIndex != i || !((*TCompiledLocal)(unsafe.Pointer(localPtr)).Fflags&libc.Int32FromInt32(VAR_ARGUMENT) != 0) || (*TCompiledLocal)(unsafe.Pointer(localPtr)).FdefValuePtr == libc.UintptrFromInt32(0) && *(*TTcl_Size)(unsafe.Pointer(bp + 24)) == int64(2) || (*TCompiledLocal)(unsafe.Pointer(localPtr)).FdefValuePtr != libc.UintptrFromInt32(0) && *(*TTcl_Size)(unsafe.Pointer(bp + 24)) != int64(2) {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+63822, libc.VaList(bp+72, procName, i)))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+72, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+28605, __ccgo_ts+63642, libc.UintptrFromInt32(0)))
				goto procError
			}
			/*
			 * Compare the default value if any.
			 */
			if (*TCompiledLocal)(unsafe.Pointer(localPtr)).FdefValuePtr != libc.UintptrFromInt32(0) {
				if (*TTcl_Obj)(unsafe.Pointer((*TCompiledLocal)(unsafe.Pointer(localPtr)).FdefValuePtr)).Fbytes != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp + 48)) = (*TTcl_Obj)(unsafe.Pointer((*TCompiledLocal)(unsafe.Pointer(localPtr)).FdefValuePtr)).Flength
					v14 = (*TTcl_Obj)(unsafe.Pointer((*TCompiledLocal)(unsafe.Pointer(localPtr)).FdefValuePtr)).Fbytes
				} else {
					v14 = XTcl_GetStringFromObj(tls, (*TCompiledLocal)(unsafe.Pointer(localPtr)).FdefValuePtr, bp+48)
				}
				tmpPtr = v14
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 1*8)))).Fbytes != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp + 56)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 1*8)))).Flength
					v15 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 1*8)))).Fbytes
				} else {
					v15 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 1*8)), bp+56)
				}
				value = v15
				if *(*TTcl_Size)(unsafe.Pointer(bp + 56)) != *(*TTcl_Size)(unsafe.Pointer(bp + 48)) || libc.Xmemcmp(tls, value, tmpPtr, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 48)))) != 0 {
					errorObj2 = XTcl_ObjPrintf(tls, __ccgo_ts+63897, libc.VaList(bp+72, procName))
					XTcl_AppendObjToObj(tls, errorObj2, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))))
					XTcl_AppendToObj(tls, errorObj2, __ccgo_ts+63932, int64(-int32(1)))
					XTcl_SetObjResult(tls, interp, errorObj2)
					XTcl_SetErrorCode(tls, interp, libc.VaList(bp+72, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+28605, __ccgo_ts+63642, libc.UintptrFromInt32(0)))
					goto procError
				}
			}
			if i == *(*TTcl_Size)(unsafe.Pointer(bp))-int64(1) && (*TCompiledLocal)(unsafe.Pointer(localPtr)).FnameLength == int64(4) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(localPtr + 44))) == int32('a') && libc.Xstrcmp(tls, localPtr+44, __ccgo_ts+15990) == 0 {
				*(*int32)(unsafe.Pointer(localPtr + 40)) |= int32(VAR_IS_ARGS)
			}
			localPtr = (*TCompiledLocal)(unsafe.Pointer(localPtr)).FnextPtr
		} else {
			/*
			 * Allocate an entry in the runtime procedure frame's array of
			 * local variables for the argument.
			 */
			localPtr = XTcl_Alloc(tls, uint64(libc.UintptrFromInt32(0)+44)+libc.Uint64FromUint32(1)+libc.Uint64FromInt64((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))))).Flength))
			if (*TProc)(unsafe.Pointer(procPtr)).FfirstLocalPtr == libc.UintptrFromInt32(0) {
				v16 = localPtr
				(*TProc)(unsafe.Pointer(procPtr)).FlastLocalPtr = v16
				(*TProc)(unsafe.Pointer(procPtr)).FfirstLocalPtr = v16
			} else {
				(*TCompiledLocal)(unsafe.Pointer((*TProc)(unsafe.Pointer(procPtr)).FlastLocalPtr)).FnextPtr = localPtr
				(*TProc)(unsafe.Pointer(procPtr)).FlastLocalPtr = localPtr
			}
			(*TCompiledLocal)(unsafe.Pointer(localPtr)).FnextPtr = libc.UintptrFromInt32(0)
			(*TCompiledLocal)(unsafe.Pointer(localPtr)).FnameLength = *(*TTcl_Size)(unsafe.Pointer(bp + 32))
			(*TCompiledLocal)(unsafe.Pointer(localPtr)).FframeIndex = i
			(*TCompiledLocal)(unsafe.Pointer(localPtr)).Fflags = int32(VAR_ARGUMENT)
			(*TCompiledLocal)(unsafe.Pointer(localPtr)).FresolveInfo = libc.UintptrFromInt32(0)
			if *(*TTcl_Size)(unsafe.Pointer(bp + 24)) == int64(2) {
				(*TCompiledLocal)(unsafe.Pointer(localPtr)).FdefValuePtr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 1*8))
				(*TTcl_Obj)(unsafe.Pointer((*TCompiledLocal)(unsafe.Pointer(localPtr)).FdefValuePtr)).FrefCount++
			} else {
				(*TCompiledLocal)(unsafe.Pointer(localPtr)).FdefValuePtr = libc.UintptrFromInt32(0)
			}
			libc.Xmemcpy(tls, localPtr+44, argname, libc.Uint64FromInt64((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))))).Flength+int64(1)))
			if i == *(*TTcl_Size)(unsafe.Pointer(bp))-int64(1) && (*TCompiledLocal)(unsafe.Pointer(localPtr)).FnameLength == int64(4) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(localPtr + 44))) == int32('a') && libc.Xmemcmp(tls, localPtr+44, __ccgo_ts+15990, uint64(4)) == 0 {
				*(*int32)(unsafe.Pointer(localPtr + 40)) |= int32(VAR_IS_ARGS)
			}
		}
		goto _7
	_7:
		;
		i++
	}
	*(*uintptr)(unsafe.Pointer(procPtrPtr)) = procPtr
	return TCL_OK
	goto procError
procError:
	;
	if precompiled != 0 {
		(*TProc)(unsafe.Pointer(procPtr)).FrefCount--
	} else {
		_objPtr = bodyPtr
		v18 = _objPtr
		v17 = *(*TTcl_Size)(unsafe.Pointer(v18))
		*(*TTcl_Size)(unsafe.Pointer(v18))--
		if v17 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		for (*TProc)(unsafe.Pointer(procPtr)).FfirstLocalPtr != libc.UintptrFromInt32(0) {
			localPtr = (*TProc)(unsafe.Pointer(procPtr)).FfirstLocalPtr
			(*TProc)(unsafe.Pointer(procPtr)).FfirstLocalPtr = (*TCompiledLocal)(unsafe.Pointer(localPtr)).FnextPtr
			if (*TCompiledLocal)(unsafe.Pointer(localPtr)).FdefValuePtr != libc.UintptrFromInt32(0) {
				_objPtr1 = (*TCompiledLocal)(unsafe.Pointer(localPtr)).FdefValuePtr
				v20 = _objPtr1
				v19 = *(*TTcl_Size)(unsafe.Pointer(v20))
				*(*TTcl_Size)(unsafe.Pointer(v20))--
				if v19 <= int64(1) {
					XTclFreeObj(tls, _objPtr1)
				}
			}
			XTclpFree(tls, localPtr)
		}
		XTclpFree(tls, procPtr)
	}
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * TclGetFrame --
 *
 *	Given a description of a procedure frame, such as the first argument
 *	to an "uplevel" or "upvar" command, locate the call frame for the
 *	appropriate level of procedure.
 *
 * Results:
 *	The return value is -1 if an error occurred in finding the frame (in
 *	this case an error message is left in the interp's result). 1 is
 *	returned if string was either a number or a number preceded by "#" and
 *	it specified a valid frame. 0 is returned if string isn't one of the
 *	two things above (in this case, the lookup acts as if string were
 *	"1"). The variable pointed to by framePtrPtr is filled in with the
 *	address of the desired frame (unless an error occurs, in which case it
 *	isn't modified).
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclGetFrame(tls *libc.TLS, interp uintptr, name uintptr, framePtrPtr uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Store pointer to frame here (or NULL if
	 * global frame indicated). */
	var result int32
	var _ /* obj at bp+0 */ TTcl_Obj
	_ = result
	(*(*TTcl_Obj)(unsafe.Pointer(bp))).Fbytes = name
	(*(*TTcl_Obj)(unsafe.Pointer(bp))).Flength = libc.Int64FromUint64(libc.Xstrlen(tls, name))
	(*(*TTcl_Obj)(unsafe.Pointer(bp))).FtypePtr = libc.UintptrFromInt32(0)
	result = XTclObjGetFrame(tls, interp, bp, framePtrPtr)
	if (*TTcl_Obj)(unsafe.Pointer(bp)).FtypePtr != libc.UintptrFromInt32(0) {
		if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(bp)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(bp)).FtypePtr)).FfreeIntRepProc})))(tls, bp)
		}
		(*TTcl_Obj)(unsafe.Pointer(bp)).FtypePtr = libc.UintptrFromInt32(0)
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * TclObjGetFrame --
 *
 *	Given a description of a procedure frame, such as the first argument
 *	to an "uplevel" or "upvar" command, locate the call frame for the
 *	appropriate level of procedure.
 *
 * Results:
 *	The return value is -1 if an error occurred in finding the frame (in
 *	this case an error message is left in the interp's result). 1 is
 *	returned if objPtr was either an int or an int preceded by "#" and
 *	it specified a valid frame. 0 is returned if objPtr isn't one of the
 *	two things above (in this case, the lookup acts as if objPtr were
 *	"1"). The variable pointed to by framePtrPtr is filled in with the
 *	address of the desired frame (unless an error occurs, in which case it
 *	isn't modified).
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclObjGetFrame(tls *libc.TLS, interp uintptr, objPtr uintptr, framePtrPtr uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* Store pointer to frame here (or NULL if
	 * global frame indicated). */
	var curLevel, result int32
	var framePtr, iPtr, irPtr, name, v2, v3, v4, v6, v7 uintptr
	var _ /* ir at bp+16 */ TTcl_ObjInternalRep
	var _ /* level at bp+0 */ int32
	var _ /* w at bp+8 */ TTcl_WideInt
	_, _, _, _, _, _, _, _, _, _, _ = curLevel, framePtr, iPtr, irPtr, name, result, v2, v3, v4, v6, v7
	iPtr = interp
	name = libc.UintptrFromInt32(0)
	/*
	 * Parse object to figure out which level number to go to.
	 */
	result = 0
	curLevel = int32((*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).Flevel)
	/*
	 * Check for integer first, since that has potential to spare us
	 * a generation of a stringrep.
	 */
	if objPtr == libc.UintptrFromInt32(0) {
		/* Do nothing */
	} else {
		if TCL_OK == XTcl_GetIntFromObj(tls, libc.UintptrFromInt32(0), objPtr, bp) {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
				*(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep))
				_ = libc.Int32FromInt32(TCL_OK)
			} else {
				XTcl_GetWideIntFromObj(tls, libc.UintptrFromInt32(0), objPtr, bp+8)
			}
			if *(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) < 0 || *(*TTcl_WideInt)(unsafe.Pointer(bp + 8)) > int64(INT_MAX) || int64(curLevel) > *(*TTcl_WideInt)(unsafe.Pointer(bp + 8))+int64(INT_MAX) {
				result = -int32(1)
			} else {
				*(*int32)(unsafe.Pointer(bp)) = curLevel - *(*int32)(unsafe.Pointer(bp))
				result = int32(1)
			}
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_levelReferenceType)) {
				v3 = objPtr + 32
			} else {
				v3 = libc.UintptrFromInt32(0)
			}
			v2 = v3
			irPtr = v2
			if v2 != 0 {
				*(*int32)(unsafe.Pointer(bp)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(irPtr)))
				result = int32(1)
			} else {
				if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
					v4 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
				} else {
					v4 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
				}
				name = v4
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32('#') {
					if TCL_OK == XTcl_GetInt(tls, libc.UintptrFromInt32(0), name+uintptr(1), bp) {
						if *(*int32)(unsafe.Pointer(bp)) < 0 || *(*int32)(unsafe.Pointer(bp)) > 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name + 1))) == int32('-') {
							result = -int32(1)
						} else {
							*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 16)))) = int64(*(*int32)(unsafe.Pointer(bp)))
							XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&_levelReferenceType)), bp+16)
							result = int32(1)
						}
					} else {
						result = -int32(1)
					}
				} else {
					if XTclGetWideBitsFromObj(tls, libc.UintptrFromInt32(0), objPtr, bp+8) == TCL_OK {
						/*
						 * If this were an integer, we'd have succeeded already.
						 * Docs say we have to treat this as a 'bad level'  error.
						 */
						result = -int32(1)
					}
				}
			}
		}
	}
	if result != -int32(1) {
		/* if relative current level */
		if result == 0 {
			if !(curLevel != 0) {
				/* we are in top-level, so simply generate bad level */
				name = __ccgo_ts + 21397
				goto badLevel
			}
			*(*int32)(unsafe.Pointer(bp)) = curLevel - int32(1)
		}
		if *(*int32)(unsafe.Pointer(bp)) >= 0 {
			framePtr = (*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr
			for {
				if !(framePtr != libc.UintptrFromInt32(0)) {
					break
				}
				if int32((*TCallFrame)(unsafe.Pointer(framePtr)).Flevel) == *(*int32)(unsafe.Pointer(bp)) {
					*(*uintptr)(unsafe.Pointer(framePtrPtr)) = framePtr
					return result
				}
				goto _5
			_5:
				;
				framePtr = (*TCallFrame)(unsafe.Pointer(framePtr)).FcallerVarPtr
			}
		}
	}
	goto badLevel
badLevel:
	;
	if name == libc.UintptrFromInt32(0) {
		if objPtr != 0 {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
				v7 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
			} else {
				v7 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
			}
			v6 = v7
		} else {
			v6 = __ccgo_ts + 21397
		}
		name = v6
	}
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+16556, libc.VaList(bp+40, name)))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+16571, name, libc.UintptrFromInt32(0)))
	return -int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UplevelObjCmd --
 *
 *	This object function is invoked to process the "uplevel" Tcl command.
 *	See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl object result value.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _Uplevel_Callback(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var savedVarFramePtr uintptr
	_ = savedVarFramePtr
	savedVarFramePtr = *(*uintptr)(unsafe.Pointer(data))
	if result == int32(TCL_ERROR) {
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+63987, libc.VaList(bp+8, XTcl_GetErrorLine(tls, interp))))
	}
	/*
	 * Restore the variable frame, and return.
	 */
	(*TInterp)(unsafe.Pointer(interp)).FvarFramePtr = savedVarFramePtr
	return result
}

func XTcl_UplevelObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	return XTcl_NRCallObjProc(tls, interp, __ccgo_fp(XTclNRUplevelObjCmd), clientData, int64(objc), objv)
}

func XTclNRUplevelObjCmd(tls *libc.TLS, dummy904 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument objects. */
	var _objPtr, cachePtr, iPtr, objPtr, savedVarFramePtr uintptr
	var result, status, v3 int32
	var v4 int64
	var v5 bool
	var _ /* _callbackPtr at bp+32 */ uintptr
	var _ /* framePtr at bp+16 */ uintptr
	var _ /* invoker at bp+0 */ uintptr
	var _ /* llength at bp+24 */ TTcl_Size
	var _ /* word at bp+8 */ int32
	_, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, iPtr, objPtr, result, savedVarFramePtr, status, v3, v4, v5
	iPtr = interp
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	*(*int32)(unsafe.Pointer(bp + 8)) = 0
	if !(objc < int32(2)) {
		goto _1
	}
	/* to do
	 *    simplify things by interpreting the argument as a command when there
	 *    is only one argument.  This requires a TIP since currently a single
	 *    argument is interpreted as a level indicator if possible.
	 */
	goto uplevelSyntax
uplevelSyntax:
	;
	XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+64017)
	return int32(TCL_ERROR)
	goto _2
_1:
	;
	if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != libc.UintptrFromInt32(0)) && objc == int32(2) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
				v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanLength
			} else {
				v4 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = v4
			v3 = libc.Int32FromInt32(TCL_OK)
		} else {
			v3 = XTcl_ListObjLength(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+24)
		}
		status = v3
		if status == TCL_OK && *(*TTcl_Size)(unsafe.Pointer(bp + 24)) > int64(1) {
			/* the first argument can't interpreted as a level. Avoid
			 * generating a string representation of the script. */
			result = XTclGetFrame(tls, interp, __ccgo_ts+21397, bp+16)
			if result == -int32(1) {
				return int32(TCL_ERROR)
			}
			objc -= int32(1)
			objv += uintptr(1) * 8
			goto havelevel
		}
	}
_2:
	;
	/*
	 * Find the level to use for executing the command.
	 */
	result = XTclObjGetFrame(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+16)
	if result == -int32(1) {
		return int32(TCL_ERROR)
	}
	objc -= result + int32(1)
	if objc == 0 {
		goto uplevelSyntax
	}
	objv += uintptr(result+int32(1)) * 8
	goto havelevel
havelevel:
	;
	/*
	 * Modify the interpreter state to execute in the given frame.
	 */
	savedVarFramePtr = (*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr
	(*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr = *(*uintptr)(unsafe.Pointer(bp + 16))
	/*
	 * Execute the residual arguments as a command.
	 */
	if objc == int32(1) {
		/*
		 * TIP #280. Make actual argument location available to eval'd script
		 */
		XTclArgumentGet(tls, interp, *(*uintptr)(unsafe.Pointer(objv)), bp, bp+8)
		objPtr = *(*uintptr)(unsafe.Pointer(objv))
	} else {
		/*
		 * More than one argument: concatenate them together with spaces
		 * between, then evaluate the result. Tcl_EvalObjEx will delete the
		 * object when it decrements its refcount after eval'ing it.
		 */
		objPtr = XTcl_ConcatObj(tls, int64(objc), objv)
	}
	if v5 = interp == libc.UintptrFromInt32(0); !v5 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v5 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 32)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))).FprocPtr = __ccgo_fp(_Uplevel_Callback)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)) + 8)) = savedVarFramePtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 32))
	return XTclNREvalObjEx(tls, interp, objPtr, 0, *(*uintptr)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 8)))
}

/*
 *----------------------------------------------------------------------
 *
 * TclFindProc --
 *
 *	Given the name of a procedure, return a pointer to the record
 *	describing the procedure. The procedure will be looked up using the
 *	usual rules: first in the current namespace and then in the global
 *	namespace.
 *
 * Results:
 *	NULL is returned if the name doesn't correspond to any procedure.
 *	Otherwise, the return value is a pointer to the procedure's record. If
 *	the name is found but refers to an imported command that points to a
 *	"real" procedure defined in another namespace, a pointer to that
 *	"real" procedure's structure is returned.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclFindProc(tls *libc.TLS, iPtr uintptr, procName uintptr) (r uintptr) {
	/* Name of desired procedure. */
	var cmd TTcl_Command
	var cmdPtr uintptr
	_, _ = cmd, cmdPtr
	cmd = XTcl_FindCommand(tls, iPtr, procName, libc.UintptrFromInt32(0), 0)
	if cmd == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	cmdPtr = cmd
	return XTclIsProc(tls, cmdPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * TclIsProc --
 *
 *	Tells whether a command is a Tcl procedure or not.
 *
 * Results:
 *	If the given command is actually a Tcl procedure, the return value is
 *	the address of the record describing the procedure. Otherwise the
 *	return value is 0.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclIsProc(tls *libc.TLS, cmdPtr uintptr) (r uintptr) {
	/* Command to test. */
	var origCmd TTcl_Command
	_ = origCmd
	origCmd = XTclGetOriginalCommand(tls, cmdPtr)
	if origCmd != libc.UintptrFromInt32(0) {
		cmdPtr = origCmd
	}
	if (*TCommand)(unsafe.Pointer(cmdPtr)).FdeleteProc == __ccgo_fp(XTclProcDeleteProc) {
		return (*TCommand)(unsafe.Pointer(cmdPtr)).FobjClientData
	}
	return libc.UintptrFromInt32(0)
}

func _ProcWrongNumArgs(tls *libc.TLS, interp uintptr, skip int32) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var _objPtr, argObj, cachePtr, defPtr, desiredObjs, final, framePtr, namePtr, procPtr, v3, v6 uintptr
	var i, localCt, numArgs, v5 TTcl_Size
	var v2 bool
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, argObj, cachePtr, defPtr, desiredObjs, final, framePtr, i, localCt, namePtr, numArgs, procPtr, v2, v3, v5, v6
	framePtr = (*TInterp)(unsafe.Pointer(interp)).FvarFramePtr
	procPtr = (*TCallFrame)(unsafe.Pointer(framePtr)).FprocPtr
	localCt = (*TProc)(unsafe.Pointer(procPtr)).FnumCompiledLocals
	final = libc.UintptrFromInt32(0)
	/*
	 * Build up desired argument list for Tcl_WrongNumArgs
	 */
	numArgs = (*TProc)(unsafe.Pointer((*TCallFrame)(unsafe.Pointer(framePtr)).FprocPtr)).FnumArgs
	desiredObjs = XTclStackAlloc(tls, interp, uint64(8)*libc.Uint64FromInt64(numArgs+libc.Int64FromInt32(1)))
	if (*TCallFrame)(unsafe.Pointer(framePtr)).FisProcCallFrame&int32(FRAME_IS_LAMBDA) != 0 {
		*(*uintptr)(unsafe.Pointer(desiredObjs)) = XTcl_NewStringObj(tls, __ccgo_ts+63516, int64(-int32(1)))
	} else {
		*(*uintptr)(unsafe.Pointer(desiredObjs)) = *(*uintptr)(unsafe.Pointer((*TCallFrame)(unsafe.Pointer(framePtr)).Fobjv + uintptr(skip-int32(1))*8))
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(desiredObjs)))).FrefCount++
	if localCt > 0 {
		defPtr = (*TCallFrame)(unsafe.Pointer(framePtr)).FlocalCachePtr + 16 + uintptr(localCt)*8
		i = int64(1)
		for {
			if !(i <= numArgs) {
				break
			}
			namePtr = *(*uintptr)(unsafe.Pointer((*TCallFrame)(unsafe.Pointer(framePtr)).FlocalCachePtr + 16 + uintptr(i-libc.Int64FromInt32(1))*8))
			if *(*uintptr)(unsafe.Pointer(defPtr + 8)) != libc.UintptrFromInt32(0) {
				if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
					argObj = XTclThreadAllocObj(tls)
				} else {
					argObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(argObj + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(argObj)).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer(argObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(argObj)).Flength = 0
				(*TTcl_Obj)(unsafe.Pointer(argObj)).FtypePtr = libc.UintptrFromInt32(0)
				if (*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes != 0 {
					v3 = (*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes
				} else {
					v3 = XTcl_GetStringFromObj(tls, namePtr, libc.UintptrFromInt32(0))
				}
				XTcl_AppendStringsToObj(tls, argObj, libc.VaList(bp+8, __ccgo_ts+64043, v3, __ccgo_ts+64043, libc.UintptrFromInt32(0)))
			} else {
				if (*TVar)(unsafe.Pointer(defPtr)).Fflags&int32(VAR_IS_ARGS) != 0 {
					numArgs--
					final = __ccgo_ts + 64045
					break
				} else {
					argObj = namePtr
					(*TTcl_Obj)(unsafe.Pointer(namePtr)).FrefCount++
				}
			}
			*(*uintptr)(unsafe.Pointer(desiredObjs + uintptr(i)*8)) = argObj
			goto _1
		_1:
			;
			i++
			defPtr += 16
		}
	}
	XTcl_ResetResult(tls, interp)
	XTcl_WrongNumArgs(tls, interp, numArgs+int64(1), desiredObjs, final)
	i = 0
	for {
		if !(i <= numArgs) {
			break
		}
		_objPtr = *(*uintptr)(unsafe.Pointer(desiredObjs + uintptr(i)*8))
		v6 = _objPtr
		v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
		*(*TTcl_Size)(unsafe.Pointer(v6))--
		if v5 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		goto _4
	_4:
		;
		i++
	}
	XTclStackFree(tls, interp, desiredObjs)
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * InitResolvedLocals --
 *
 *	This routine is invoked in order to initialize the compiled locals
 *	table for a new call frame.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	May invoke various name resolvers in order to determine which
 *	variables are being referenced at runtime.
 *
 *----------------------------------------------------------------------
 */

func _InitResolvedLocals(tls *libc.TLS, interp uintptr, codePtr uintptr, varPtr uintptr, nsPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Pointer to current namespace. */
	var firstLocalPtr, iPtr, localPtr, resPtr, resVarInfo, resolvedVarPtr uintptr
	var haveResolvers, result, varNum, v1 int32
	var _ /* vinfo at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _ = firstLocalPtr, haveResolvers, iPtr, localPtr, resPtr, resVarInfo, resolvedVarPtr, result, varNum, v1
	iPtr = interp
	haveResolvers = libc.BoolInt32((*TNamespace)(unsafe.Pointer(nsPtr)).FcompiledVarResProc != 0 || (*TInterp)(unsafe.Pointer(iPtr)).FresolverPtr != 0)
	/*
	 * Find the localPtr corresponding to varPtr
	 */
	varNum = int32((int64(varPtr) - int64((*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FframePtr)).FcompiledLocals)) / 16)
	localPtr = (*TProc)(unsafe.Pointer((*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FframePtr)).FprocPtr)).FfirstLocalPtr
	for {
		v1 = varNum
		varNum--
		if !(v1 != 0) {
			break
		}
		localPtr = (*TCompiledLocal)(unsafe.Pointer(localPtr)).FnextPtr
	}
	if !(haveResolvers != 0 && (*TByteCode)(unsafe.Pointer(codePtr)).Fflags&uint32(TCL_BYTECODE_RESOLVE_VARS) != 0) {
		goto doInitResolvedLocals
	}
	/*
	 * This is the first run after a recompile, or else the resolver epoch
	 * has changed: update the resolver cache.
	 */
	firstLocalPtr = localPtr
	for {
		if !(localPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TCompiledLocal)(unsafe.Pointer(localPtr)).FresolveInfo != 0 {
			if (*TTcl_ResolvedVarInfo)(unsafe.Pointer((*TCompiledLocal)(unsafe.Pointer(localPtr)).FresolveInfo)).FdeleteProc != 0 {
				(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ResolvedVarInfo)(unsafe.Pointer((*TCompiledLocal)(unsafe.Pointer(localPtr)).FresolveInfo)).FdeleteProc})))(tls, (*TCompiledLocal)(unsafe.Pointer(localPtr)).FresolveInfo)
			} else {
				XTclpFree(tls, (*TCompiledLocal)(unsafe.Pointer(localPtr)).FresolveInfo)
			}
			(*TCompiledLocal)(unsafe.Pointer(localPtr)).FresolveInfo = libc.UintptrFromInt32(0)
		}
		*(*int32)(unsafe.Pointer(localPtr + 40)) &= ^libc.Int32FromInt32(VAR_RESOLVED)
		if haveResolvers != 0 && !((*TCompiledLocal)(unsafe.Pointer(localPtr)).Fflags&(libc.Int32FromInt32(VAR_ARGUMENT)|libc.Int32FromInt32(VAR_TEMPORARY)) != 0) {
			resPtr = (*TInterp)(unsafe.Pointer(iPtr)).FresolverPtr
			if (*TNamespace)(unsafe.Pointer(nsPtr)).FcompiledVarResProc != 0 {
				result = (*(*func(*libc.TLS, uintptr, uintptr, TTcl_Size, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TNamespace)(unsafe.Pointer(nsPtr)).FcompiledVarResProc})))(tls, (*TNamespace)(unsafe.Pointer(nsPtr)).Finterp, localPtr+44, (*TCompiledLocal)(unsafe.Pointer(localPtr)).FnameLength, nsPtr, bp)
			} else {
				result = int32(TCL_CONTINUE)
			}
			for result == int32(TCL_CONTINUE) && resPtr != 0 {
				if (*TResolverScheme)(unsafe.Pointer(resPtr)).FcompiledVarResProc != 0 {
					result = (*(*func(*libc.TLS, uintptr, uintptr, TTcl_Size, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TResolverScheme)(unsafe.Pointer(resPtr)).FcompiledVarResProc})))(tls, (*TNamespace)(unsafe.Pointer(nsPtr)).Finterp, localPtr+44, (*TCompiledLocal)(unsafe.Pointer(localPtr)).FnameLength, nsPtr, bp)
				}
				resPtr = (*TResolverScheme)(unsafe.Pointer(resPtr)).FnextPtr
			}
			if result == TCL_OK {
				(*TCompiledLocal)(unsafe.Pointer(localPtr)).FresolveInfo = *(*uintptr)(unsafe.Pointer(bp))
				*(*int32)(unsafe.Pointer(localPtr + 40)) |= int32(VAR_RESOLVED)
			}
		}
		goto _2
	_2:
		;
		localPtr = (*TCompiledLocal)(unsafe.Pointer(localPtr)).FnextPtr
	}
	localPtr = firstLocalPtr
	*(*uint32)(unsafe.Pointer(codePtr + 40)) &= libc.Uint32FromInt32(^libc.Int32FromInt32(TCL_BYTECODE_RESOLVE_VARS))
	/*
	 * Initialize the array of local variables stored in the call frame. Some
	 * variables may have special resolution rules. In that case, we call
	 * their "resolver" procs to get our hands on the variable, and we make
	 * the compiled local a link to the real variable.
	 */
	goto doInitResolvedLocals
doInitResolvedLocals:
	;
	for {
		if !(localPtr != libc.UintptrFromInt32(0)) {
			break
		}
		(*TVar)(unsafe.Pointer(varPtr)).Fflags = 0
		*(*uintptr)(unsafe.Pointer(varPtr + 8)) = libc.UintptrFromInt32(0)
		/*
		 * Now invoke the resolvers to determine the exact variables that
		 * should be used.
		 */
		resVarInfo = (*TCompiledLocal)(unsafe.Pointer(localPtr)).FresolveInfo
		if resVarInfo != 0 && (*TTcl_ResolvedVarInfo)(unsafe.Pointer(resVarInfo)).FfetchProc != 0 {
			resolvedVarPtr = (*(*func(*libc.TLS, uintptr, uintptr) TTcl_Var)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ResolvedVarInfo)(unsafe.Pointer(resVarInfo)).FfetchProc})))(tls, interp, resVarInfo)
			if resolvedVarPtr != 0 {
				if (*TVar)(unsafe.Pointer(resolvedVarPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
					(*TVarInHash)(unsafe.Pointer(resolvedVarPtr)).FrefCount++
				}
				(*TVar)(unsafe.Pointer(varPtr)).Fflags = int32(VAR_LINK)
				*(*uintptr)(unsafe.Pointer(varPtr + 8)) = resolvedVarPtr
			}
		}
		goto _3
	_3:
		;
		varPtr += 16
		localPtr = (*TCompiledLocal)(unsafe.Pointer(localPtr)).FnextPtr
	}
}

func XTclFreeLocalCache(tls *libc.TLS, interp uintptr, localCachePtr uintptr) {
	var i TTcl_Size
	var namePtrPtr, objPtr uintptr
	_, _, _ = i, namePtrPtr, objPtr
	namePtrPtr = localCachePtr + 16
	i = 0
	for {
		if !(i < (*TLocalCache)(unsafe.Pointer(localCachePtr)).FnumVars) {
			break
		}
		objPtr = *(*uintptr)(unsafe.Pointer(namePtrPtr))
		if objPtr != 0 {
			/* TclReleaseLiteral calls Tcl_DecrRefCount for us */
			XTclReleaseLiteral(tls, interp, objPtr)
		}
		goto _1
	_1:
		;
		i++
		namePtrPtr += 8
	}
	XTclpFree(tls, localCachePtr)
}

func _InitLocalCache(tls *libc.TLS, procPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var codePtr, iPtr, irPtr, localCachePtr, localPtr, namePtr, varPtr, v1, v2 uintptr
	var i, localCt, numArgs TTcl_Size
	var _ /* isNew at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _ = codePtr, i, iPtr, irPtr, localCachePtr, localCt, localPtr, namePtr, numArgs, varPtr, v1, v2
	iPtr = (*TProc)(unsafe.Pointer(procPtr)).FiPtr
	localCt = (*TProc)(unsafe.Pointer(procPtr)).FnumCompiledLocals
	numArgs = (*TProc)(unsafe.Pointer(procPtr)).FnumArgs
	i = 0
	if (*TTcl_Obj)(unsafe.Pointer((*TProc)(unsafe.Pointer(procPtr)).FbodyPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclByteCodeType)) {
		v1 = (*TProc)(unsafe.Pointer(procPtr)).FbodyPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	codePtr = v2
	/*
	 * Cache the names and initial values of local variables; store the
	 * cache in both the framePtr for this execution and in the codePtr
	 * for future calls.
	 */
	localCachePtr = XTcl_Alloc(tls, uint64(libc.UintptrFromInt32(0)+16)+libc.Uint64FromInt64(localCt)*uint64(8)+libc.Uint64FromInt64(numArgs)*uint64(16))
	namePtr = localCachePtr + 16
	varPtr = namePtr + uintptr(localCt)*8
	localPtr = (*TProc)(unsafe.Pointer(procPtr)).FfirstLocalPtr
	for localPtr != 0 {
		if (*TCompiledLocal)(unsafe.Pointer(localPtr)).Fflags&int32(VAR_TEMPORARY) != 0 {
			*(*uintptr)(unsafe.Pointer(namePtr)) = libc.UintptrFromInt32(0)
		} else {
			*(*uintptr)(unsafe.Pointer(namePtr)) = XTclCreateLiteral(tls, iPtr, localPtr+44, (*TCompiledLocal)(unsafe.Pointer(localPtr)).FnameLength, libc.Uint64FromInt64(int64(-libc.Int32FromInt32(1))), bp, libc.UintptrFromInt32(0), 0, libc.UintptrFromInt32(0))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(namePtr)))).FrefCount++
		}
		if i < numArgs {
			(*TVar)(unsafe.Pointer(varPtr)).Fflags = (*TCompiledLocal)(unsafe.Pointer(localPtr)).Fflags & int32(VAR_IS_ARGS)
			*(*uintptr)(unsafe.Pointer(varPtr + 8)) = (*TCompiledLocal)(unsafe.Pointer(localPtr)).FdefValuePtr
			varPtr += 16
			i++
		}
		namePtr += 8
		localPtr = (*TCompiledLocal)(unsafe.Pointer(localPtr)).FnextPtr
	}
	(*TByteCode)(unsafe.Pointer(codePtr)).FlocalCachePtr = localCachePtr
	(*TLocalCache)(unsafe.Pointer(localCachePtr)).FrefCount = int64(1)
	(*TLocalCache)(unsafe.Pointer(localCachePtr)).FnumVars = localCt
}

/*
 *----------------------------------------------------------------------
 *
 * InitArgsAndLocals --
 *
 *	This routine is invoked in order to initialize the arguments and other
 *	compiled locals table for a new call frame.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Allocates memory on the stack for the compiled local variables, the
 *	caller is responsible for freeing them. Initialises all variables. May
 *	invoke various name resolvers in order to determine which variables
 *	are being referenced at runtime.
 *
 *----------------------------------------------------------------------
 */

func _InitArgsAndLocals(tls *libc.TLS, interp uintptr, skip int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Number of initial arguments to be skipped,
	 * i.e., words in the "command name". */
	var _objPtr, argObjs, cachePtr, codePtr, defPtr, framePtr, irPtr, listPtr, objPtr, objPtr1, objPtr2, objPtr3, procPtr, varPtr, v1, v2, v7 uintptr
	var argCt, i, imax, localCt, numArgs TTcl_Size
	var v10 bool
	var v3, v9 int64
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, argCt, argObjs, cachePtr, codePtr, defPtr, framePtr, i, imax, irPtr, listPtr, localCt, numArgs, objPtr, objPtr1, objPtr2, objPtr3, procPtr, varPtr, v1, v10, v2, v3, v7, v9
	framePtr = (*TInterp)(unsafe.Pointer(interp)).FvarFramePtr
	procPtr = (*TCallFrame)(unsafe.Pointer(framePtr)).FprocPtr
	localCt = (*TProc)(unsafe.Pointer(procPtr)).FnumCompiledLocals
	if (*TTcl_Obj)(unsafe.Pointer((*TProc)(unsafe.Pointer(procPtr)).FbodyPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclByteCodeType)) {
		v1 = (*TProc)(unsafe.Pointer(procPtr)).FbodyPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	codePtr = v2
	/*
	 * Make sure that the local cache of variable names and initial values has
	 * been initialised properly .
	 */
	if localCt != 0 {
		if !((*TByteCode)(unsafe.Pointer(codePtr)).FlocalCachePtr != 0) {
			_InitLocalCache(tls, procPtr)
		}
		(*TCallFrame)(unsafe.Pointer(framePtr)).FlocalCachePtr = (*TByteCode)(unsafe.Pointer(codePtr)).FlocalCachePtr
		(*TLocalCache)(unsafe.Pointer((*TCallFrame)(unsafe.Pointer(framePtr)).FlocalCachePtr)).FrefCount++
		defPtr = (*TCallFrame)(unsafe.Pointer(framePtr)).FlocalCachePtr + 16 + uintptr(localCt)*8
	} else {
		defPtr = libc.UintptrFromInt32(0)
	}
	/*
	 * Create the "compiledLocals" array. Make sure it is large enough to hold
	 * all the procedure's compiled local variables, including its formal
	 * parameters.
	 */
	varPtr = XTclStackAlloc(tls, interp, libc.Uint64FromInt64(localCt)*uint64(16))
	(*TCallFrame)(unsafe.Pointer(framePtr)).FcompiledLocals = varPtr
	(*TCallFrame)(unsafe.Pointer(framePtr)).FnumCompiledLocals = localCt
	/*
	 * Match and assign the call's actual parameters to the procedure's formal
	 * arguments. The formal arguments are described by the first numArgs
	 * entries in both the Proc structure's local variable list and the call
	 * frame's local variable array.
	 */
	numArgs = (*TProc)(unsafe.Pointer(procPtr)).FnumArgs
	argCt = (*TCallFrame)(unsafe.Pointer(framePtr)).Fobjc - int64(skip) /* Set it to the number of args to the
	 * procedure. */
	if numArgs == 0 {
		if argCt != 0 {
			goto incorrectArgs
		} else {
			goto correctArgs
		}
	}
	argObjs = (*TCallFrame)(unsafe.Pointer(framePtr)).Fobjv + uintptr(skip)*8
	if argCt < numArgs-int64(1) {
		v3 = argCt
	} else {
		v3 = numArgs - int64(1)
	}
	imax = v3
	i = 0
	for {
		if !(i < imax) {
			break
		}
		/*
		 * "Normal" arguments; last formal is special, depends on it being
		 * 'args'.
		 */
		objPtr = *(*uintptr)(unsafe.Pointer(argObjs + uintptr(i)*8))
		(*TVar)(unsafe.Pointer(varPtr)).Fflags = 0
		*(*uintptr)(unsafe.Pointer(varPtr + 8)) = objPtr
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount++ /* Local var is a reference. */
		goto _4
	_4:
		;
		i++
		varPtr += 16
		if defPtr != 0 {
			defPtr += 16
		}
	}
	for {
		if !(i < numArgs-int64(1)) {
			break
		}
		if defPtr != 0 {
			v7 = *(*uintptr)(unsafe.Pointer(defPtr + 8))
		} else {
			v7 = libc.UintptrFromInt32(0)
		}
		/*
		 * This loop is entered if argCt < (numArgs-1). Set default values;
		 * last formal is special.
		 */
		objPtr1 = v7
		if !(objPtr1 != 0) {
			goto incorrectArgs
		}
		(*TVar)(unsafe.Pointer(varPtr)).Fflags = 0
		*(*uintptr)(unsafe.Pointer(varPtr + 8)) = objPtr1
		(*TTcl_Obj)(unsafe.Pointer(objPtr1)).FrefCount++ /* Local var reference. */
		goto _6
	_6:
		;
		i++
		varPtr += 16
		if defPtr != 0 {
			defPtr += 16
		}
	}
	/*
	 * When we get here, the last formal argument remains to be defined:
	 * defPtr and varPtr point to the last argument to be initialized.
	 */
	(*TVar)(unsafe.Pointer(varPtr)).Fflags = 0
	if defPtr != 0 && (*TVar)(unsafe.Pointer(defPtr)).Fflags&int32(VAR_IS_ARGS) != 0 {
		if argCt > i {
			v9 = argCt - i
		} else {
			v9 = 0
		}
		listPtr = XTcl_NewListObj(tls, v9, argObjs+uintptr(i)*8)
		*(*uintptr)(unsafe.Pointer(varPtr + 8)) = listPtr
		(*TTcl_Obj)(unsafe.Pointer(listPtr)).FrefCount++ /* Local var is a reference. */
	} else {
		if argCt == numArgs {
			objPtr2 = *(*uintptr)(unsafe.Pointer(argObjs + uintptr(i)*8))
			*(*uintptr)(unsafe.Pointer(varPtr + 8)) = objPtr2
			(*TTcl_Obj)(unsafe.Pointer(objPtr2)).FrefCount++ /* Local var is a reference. */
		} else {
			if argCt < numArgs && defPtr != 0 && *(*uintptr)(unsafe.Pointer(defPtr + 8)) != 0 {
				objPtr3 = *(*uintptr)(unsafe.Pointer(defPtr + 8))
				*(*uintptr)(unsafe.Pointer(varPtr + 8)) = objPtr3
				(*TTcl_Obj)(unsafe.Pointer(objPtr3)).FrefCount++ /* Local var is a reference. */
			} else {
				goto incorrectArgs
			}
		}
	}
	varPtr += 16
	/*
	 * Initialise and resolve the remaining compiledLocals. In the absence of
	 * resolvers, they are undefined local vars: (flags=0, value=NULL).
	 */
	goto correctArgs
correctArgs:
	;
	if numArgs < localCt {
		if !((*TNamespace)(unsafe.Pointer((*TCallFrame)(unsafe.Pointer(framePtr)).FnsPtr)).FcompiledVarResProc != 0) && !((*TInterp)(unsafe.Pointer(interp)).FresolverPtr != 0) {
			libc.Xmemset(tls, varPtr, 0, libc.Uint64FromInt64(localCt-numArgs)*uint64(16))
		} else {
			_InitResolvedLocals(tls, interp, codePtr, varPtr, (*TCallFrame)(unsafe.Pointer(framePtr)).FnsPtr)
		}
	}
	return TCL_OK
	/*
	 * Initialise all compiled locals to avoid problems at DeleteLocalVars.
	 */
	goto incorrectArgs
incorrectArgs:
	;
	if skip != int32(1) && XTclInitRewriteEnsemble(tls, interp, int64(skip-int32(1)), 0, (*TCallFrame)(unsafe.Pointer(framePtr)).Fobjv) != 0 {
		if v10 = interp == libc.UintptrFromInt32(0); !v10 {
			cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
		}
		if v10 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			_objPtr = XTclThreadAllocObj(tls)
		} else {
			_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(_objPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(XTclClearRootEnsemble)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
		(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
	}
	libc.Xmemset(tls, varPtr, 0, libc.Uint64FromInt64((int64((*TCallFrame)(unsafe.Pointer(framePtr)).FcompiledLocals+uintptr(localCt)*16)-int64(varPtr))/16)*uint64(16))
	return _ProcWrongNumArgs(tls, interp, skip)
}

/*
 *----------------------------------------------------------------------
 *
 * TclPushProcCallFrame --
 *
 *	Compiles a proc body if necessary, then pushes a CallFrame suitable
 *	for executing it.
 *
 * Results:
 *	A standard Tcl object result value.
 *
 * Side effects:
 *	The proc's body may be recompiled. A CallFrame is pushed, it will have
 *	to be popped by the caller.
 *
 *----------------------------------------------------------------------
 */

func XTclPushProcCallFrame(tls *libc.TLS, clientData uintptr, interp uintptr, objc TTcl_Size, objv uintptr, isLambda int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* 1 if this is a call by ApplyObjCmd: it
	 * needs special rules for error msg */
	var codePtr, framePtrPtr, iPtr, irPtr, nsPtr, procPtr, v1, v2, v5, v6 uintptr
	var result, v7 int32
	var _ /* framePtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _ = codePtr, framePtrPtr, iPtr, irPtr, nsPtr, procPtr, result, v1, v2, v5, v6, v7
	procPtr = clientData
	nsPtr = (*TCommand1)(unsafe.Pointer((*TProc)(unsafe.Pointer(procPtr)).FcmdPtr)).FnsPtr
	/*
	 * If necessary (i.e. if we haven't got a suitable compilation already
	 * cached) compile the procedure's body. The compiler will allocate frame
	 * slots for the procedure's non-argument local variables. Note that
	 * compiling the body might increase procPtr->numCompiledLocals if new
	 * local variables are found while compiling.
	 */
	if (*TTcl_Obj)(unsafe.Pointer((*TProc)(unsafe.Pointer(procPtr)).FbodyPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclByteCodeType)) {
		v1 = (*TProc)(unsafe.Pointer(procPtr)).FbodyPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	codePtr = v2
	if !(codePtr != libc.UintptrFromInt32(0)) {
		goto _3
	}
	iPtr = interp
	/*
	 * When we've got bytecode, this is the check for validity. That is,
	 * the bytecode must be for the right interpreter (no cross-leaks!),
	 * the code must be from the current epoch (so subcommand compilation
	 * is up-to-date), the namespace must match (so variable handling
	 * is right) and the resolverEpoch must match (so that new shadowed
	 * commands and/or resolver changes are considered).
	 * Ensure the ByteCode's procPtr is the same (or it's precompiled).
	 */
	if *(*uintptr)(unsafe.Pointer((*TByteCode)(unsafe.Pointer(codePtr)).FinterpHandle)) != iPtr || (*TByteCode)(unsafe.Pointer(codePtr)).FcompileEpoch != (*TInterp)(unsafe.Pointer(iPtr)).FcompileEpoch || (*TByteCode)(unsafe.Pointer(codePtr)).FnsPtr != nsPtr || (*TByteCode)(unsafe.Pointer(codePtr)).FnsEpoch != (*TNamespace)(unsafe.Pointer(nsPtr)).FresolverEpoch || (*TByteCode)(unsafe.Pointer(codePtr)).FprocPtr != procPtr && (*TTcl_Obj)(unsafe.Pointer((*TProc)(unsafe.Pointer(procPtr)).FbodyPtr)).Fbytes != 0 {
		goto doCompilation
	}
	goto _4
_3:
	;
	goto doCompilation
doCompilation:
	;
	if isLambda != 0 {
		v5 = __ccgo_ts + 64055
	} else {
		v5 = __ccgo_ts + 64075
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(isLambda)*8)))).Fbytes != 0 {
		v6 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(isLambda)*8)))).Fbytes
	} else {
		v6 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(isLambda)*8)), libc.UintptrFromInt32(0))
	}
	result = XTclProcCompileProc(tls, interp, procPtr, (*TProc)(unsafe.Pointer(procPtr)).FbodyPtr, nsPtr, v5, v6)
	if result != TCL_OK {
		return result
	}
_4:
	;
	/*
	 * Set up and push a new call frame for the new procedure invocation.
	 * This call frame will execute in the proc's namespace, which might be
	 * different than the current namespace. The proc's namespace is that of
	 * its command, which can change if the command is renamed from one
	 * namespace to another.
	 */
	framePtrPtr = bp
	if isLambda != 0 {
		v7 = libc.Int32FromInt32(FRAME_IS_PROC) | libc.Int32FromInt32(FRAME_IS_LAMBDA)
	} else {
		v7 = int32(FRAME_IS_PROC)
	}
	XTclPushStackFrame(tls, interp, framePtrPtr, nsPtr, v7)
	(*TCallFrame)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fobjc = objc
	(*TCallFrame)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fobjv = objv
	(*TCallFrame)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = procPtr
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclObjInterpProc --
 *
 *	When a Tcl procedure gets invoked during bytecode evaluation, this
 *	object-based routine gets invoked to interpret the procedure.
 *
 * Results:
 *	A standard Tcl object result value.
 *
 * Side effects:
 *	Depends on the commands in the procedure.
 *
 *----------------------------------------------------------------------
 */

func XTclObjInterpProc(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument value objects. */
	/*
	 * Not used much in the core; external interface for iTcl
	 */
	return XTcl_NRCallObjProc(tls, interp, __ccgo_fp(_NRInterpProc), clientData, int64(objc), objv)
}

func XTclNRInterpProc(tls *libc.TLS, clientData uintptr, interp uintptr, objc TTcl_Size, objv uintptr) (r int32) {
	/* Argument value objects. */
	var result int32
	_ = result
	result = XTclPushProcCallFrame(tls, clientData, interp, objc, objv, 0)
	if result != TCL_OK {
		return int32(TCL_ERROR)
	}
	return XTclNRInterpProcCore(tls, interp, *(*uintptr)(unsafe.Pointer(objv)), int64(1), __ccgo_fp(_MakeProcError))
}

func _NRInterpProc(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument value objects. */
	var result int32
	_ = result
	result = XTclPushProcCallFrame(tls, clientData, interp, int64(objc), objv, 0)
	if result != TCL_OK {
		return int32(TCL_ERROR)
	}
	return XTclNRInterpProcCore(tls, interp, *(*uintptr)(unsafe.Pointer(objv)), int64(1), __ccgo_fp(_MakeProcError))
}

func _ObjInterpProc2(tls *libc.TLS, clientData uintptr, interp uintptr, objc TTcl_Size, objv uintptr) (r int32) {
	/* Argument value objects. */
	/*
	 * Not used much in the core; external interface for iTcl
	 */
	return XTcl_NRCallObjProc2(tls, interp, __ccgo_fp(XTclNRInterpProc), clientData, objc, objv)
}

/*
 *----------------------------------------------------------------------
 *
 * TclNRInterpProcCore --
 *
 *	When a Tcl procedure, lambda term or anything else that works like a
 *	procedure gets invoked during bytecode evaluation, this object-based
 *	routine gets invoked to interpret the body.
 *
 * Results:
 *	A standard Tcl object result value.
 *
 * Side effects:
 *	Nearly anything; depends on the commands in the procedure body.
 *
 *----------------------------------------------------------------------
 */

func XTclNRInterpProcCore(tls *libc.TLS, interp uintptr, procNameObj uintptr, skip TTcl_Size, errorProc uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* How to convert results from the script into
	 * results of the overall procedure. */
	var _objPtr, cachePtr, codePtr, freePtr, iPtr, irPtr, procPtr, v1, v2 uintptr
	var result int32
	var v3 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, codePtr, freePtr, iPtr, irPtr, procPtr, result, v1, v2, v3
	iPtr = interp
	procPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FprocPtr
	result = _InitArgsAndLocals(tls, interp, int32(skip))
	if result != TCL_OK {
		freePtr = (*TInterp)(unsafe.Pointer(iPtr)).FframePtr
		XTcl_PopCallFrame(tls, interp) /* Pop but do not free. */
		XTclStackFree(tls, interp, (*TCallFrame)(unsafe.Pointer(freePtr)).FcompiledLocals)
		/* Free compiledLocals. */
		XTclStackFree(tls, interp, freePtr) /* Free CallFrame. */
		return int32(TCL_ERROR)
	}
	/*
	 * Invoke the commands in the procedure's body.
	 */
	(*TProc)(unsafe.Pointer(procPtr)).FrefCount++
	if (*TTcl_Obj)(unsafe.Pointer((*TProc)(unsafe.Pointer(procPtr)).FbodyPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclByteCodeType)) {
		v1 = (*TProc)(unsafe.Pointer(procPtr)).FbodyPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	codePtr = v2
	if v3 = interp == libc.UintptrFromInt32(0); !v3 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(_InterpProcNR2)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = procNameObj
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = errorProc
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
	return XTclNRExecuteByteCode(tls, interp, codePtr)
}

func _InterpProcNR2(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r1 int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var errorProc, freePtr, iPtr, procNameObj, procPtr, r, v2, v3, v5, v7, v8, v9 uintptr
	var l, l1, v4 TTcl_Size
	var v1, v6 int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = errorProc, freePtr, iPtr, l, l1, procNameObj, procPtr, r, v1, v2, v3, v4, v5, v6, v7, v8, v9
	iPtr = interp
	procPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FprocPtr
	procNameObj = *(*uintptr)(unsafe.Pointer(data))
	errorProc = *(*uintptr)(unsafe.Pointer(data + 1*8))
	if 0 != 0 {
		if (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FisProcCallFrame&int32(FRAME_IS_LAMBDA) != 0 {
			v1 = int32(1)
		} else {
			v1 = 0
		}
		l = int64(v1)
		if l < (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).Fobjc {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).Fobjv + uintptr(l)*8)))).Fbytes != 0 {
				v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).Fobjv + uintptr(l)*8)))).Fbytes
			} else {
				v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer((*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).Fobjv + uintptr(l)*8)), libc.UintptrFromInt32(0))
			}
			v2 = v3
		} else {
			v2 = libc.UintptrFromInt32(0)
		}
		if v2 != 0 {
		}
	}
	v5 = procPtr + 8
	v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
	*(*TTcl_Size)(unsafe.Pointer(v5))--
	if v4 <= int64(1) {
		XTclProcCleanupProc(tls, procPtr)
	}
	/*
	 * Free the stack-allocated compiled locals and CallFrame. It is important
	 * to pop the call frame without freeing it first: the compiledLocals
	 * cannot be freed before the frame is popped, as the local variables must
	 * be deleted. But the compiledLocals must be freed first, as they were
	 * allocated later on the stack.
	 */
	if result != TCL_OK {
		goto process
	}
	goto done
done:
	;
	if 0 != 0 {
		if (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FisProcCallFrame&int32(FRAME_IS_LAMBDA) != 0 {
			v6 = int32(1)
		} else {
			v6 = 0
		}
		l1 = int64(v6)
		r = XTcl_GetObjResult(tls, interp)
		if l1 < (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).Fobjc {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).Fobjv + uintptr(l1)*8)))).Fbytes != 0 {
				v8 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).Fobjv + uintptr(l1)*8)))).Fbytes
			} else {
				v8 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer((*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).Fobjv + uintptr(l1)*8)), libc.UintptrFromInt32(0))
			}
			v7 = v8
		} else {
			v7 = libc.UintptrFromInt32(0)
		}
		if v7 != 0 {
		}
		if r != 0 {
		}
	}
	freePtr = (*TInterp)(unsafe.Pointer(iPtr)).FframePtr
	XTcl_PopCallFrame(tls, interp) /* Pop but do not free. */
	XTclStackFree(tls, interp, (*TCallFrame)(unsafe.Pointer(freePtr)).FcompiledLocals)
	/* Free compiledLocals. */
	XTclStackFree(tls, interp, freePtr) /* Free CallFrame. */
	return result
	/*
	 * Process any non-TCL_OK result code.
	 */
	goto process
process:
	;
	switch result {
	case int32(TCL_RETURN):
		/*
		 * If it is a 'return', do the TIP#90 processing now.
		 */
		result = XTclUpdateReturnInfo(tls, interp)
	case int32(TCL_CONTINUE):
		fallthrough
	case int32(TCL_BREAK):
		/*
		 * It's an error to get to this point from a 'break' or 'continue', so
		 * transform to an error now.
		 */
		if result == int32(TCL_BREAK) {
			v9 = __ccgo_ts + 5123
		} else {
			v9 = __ccgo_ts + 5141
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+64088, libc.VaList(bp+8, v9)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+38216, __ccgo_ts+64119, libc.UintptrFromInt32(0)))
		result = int32(TCL_ERROR)
		/* FALLTHRU */
		fallthrough
	case int32(TCL_ERROR):
		/*
		 * Now it _must_ be an error, so we need to log it as such. This means
		 * filling out the error trace. Luckily, we just hand this off to the
		 * function handed to us as an argument.
		 */
		(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{errorProc})))(tls, interp, procNameObj)
	}
	goto done
	return r1
}

/*
 *----------------------------------------------------------------------
 *
 * TclProcCompileProc --
 *
 *	Called just before a procedure is executed to compile the body to byte
 *	codes. If the type of the body is not "byte code" or if the compile
 *	conditions have changed (namespace context, epoch counters, etc.) then
 *	the body is recompiled. Otherwise, this function does nothing.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	May change the internal representation of the body object to compiled
 *	code.
 *
 *----------------------------------------------------------------------
 */

func XTclProcCompileProc(tls *libc.TLS, interp uintptr, procPtr uintptr, bodyPtr uintptr, nsPtr uintptr, description uintptr, procName uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Name of this procedure. */
	var clPtr, codePtr, hePtr, iPtr, irPtr, lastPtr, toFree, v1, v2, v4 uintptr
	var i, numArgs int32
	var _ /* framePtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _ = clPtr, codePtr, hePtr, i, iPtr, irPtr, lastPtr, numArgs, toFree, v1, v2, v4
	iPtr = interp
	if (*TTcl_Obj)(unsafe.Pointer(bodyPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclByteCodeType)) {
		v1 = bodyPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	codePtr = v2
	/*
	 * If necessary, compile the procedure's body. The compiler will allocate
	 * frame slots for the procedure's non-argument local variables. If the
	 * ByteCode already exists, make sure it hasn't been invalidated by
	 * someone redefining a core command (this might make the compiled code
	 * wrong). Also, if the code was compiled in/for a different interpreter,
	 * we recompile it. Note that compiling the body might increase
	 * procPtr->numCompiledLocals if new local variables are found while
	 * compiling.
	 *
	 * Ensure the ByteCode's procPtr is the same (or it is pure precompiled).
	 * Precompiled procedure bodies, however, are immutable and therefore they
	 * are not recompiled, even if things have changed.
	 */
	if codePtr != libc.UintptrFromInt32(0) {
		if *(*uintptr)(unsafe.Pointer((*TByteCode)(unsafe.Pointer(codePtr)).FinterpHandle)) == iPtr && (*TByteCode)(unsafe.Pointer(codePtr)).FcompileEpoch == (*TInterp)(unsafe.Pointer(iPtr)).FcompileEpoch && (*TByteCode)(unsafe.Pointer(codePtr)).FnsPtr == nsPtr && (*TByteCode)(unsafe.Pointer(codePtr)).FnsEpoch == (*TNamespace)(unsafe.Pointer(nsPtr)).FresolverEpoch && ((*TByteCode)(unsafe.Pointer(codePtr)).FprocPtr == procPtr || !((*TTcl_Obj)(unsafe.Pointer(bodyPtr)).Fbytes != 0)) {
			return TCL_OK
		}
		if (*TByteCode)(unsafe.Pointer(codePtr)).Fflags&uint32(TCL_BYTECODE_PRECOMPILED) != 0 {
			if *(*uintptr)(unsafe.Pointer((*TByteCode)(unsafe.Pointer(codePtr)).FinterpHandle)) != iPtr {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+64130, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+28605, __ccgo_ts+64166, libc.UintptrFromInt32(0)))
				return int32(TCL_ERROR)
			}
			(*TByteCode)(unsafe.Pointer(codePtr)).FcompileEpoch = (*TInterp)(unsafe.Pointer(iPtr)).FcompileEpoch
			(*TByteCode)(unsafe.Pointer(codePtr)).FnsPtr = nsPtr
		} else {
			XTcl_StoreInternalRep(tls, bodyPtr, uintptr(unsafe.Pointer(&XtclByteCodeType)), libc.UintptrFromInt32(0))
			codePtr = libc.UintptrFromInt32(0)
		}
	}
	if codePtr == libc.UintptrFromInt32(0) {
		_ = description
		_ = procName
		/*
		 * Plug the current procPtr into the interpreter and coerce the code
		 * body to byte codes. The interpreter needs to know which proc it's
		 * compiling so that it can access its list of compiled locals.
		 *
		 * TRICKY NOTE: Be careful to push a call frame with the proper
		 *   namespace context, so that the byte codes are compiled in the
		 *   appropriate class context.
		 */
		(*TInterp)(unsafe.Pointer(iPtr)).FcompiledProcPtr = procPtr
		if (*TProc)(unsafe.Pointer(procPtr)).FnumCompiledLocals > (*TProc)(unsafe.Pointer(procPtr)).FnumArgs {
			clPtr = (*TProc)(unsafe.Pointer(procPtr)).FfirstLocalPtr
			lastPtr = libc.UintptrFromInt32(0)
			numArgs = int32((*TProc)(unsafe.Pointer(procPtr)).FnumArgs)
			i = 0
			for {
				if !(i < numArgs) {
					break
				}
				lastPtr = clPtr
				clPtr = (*TCompiledLocal)(unsafe.Pointer(clPtr)).FnextPtr
				goto _3
			_3:
				;
				i++
			}
			if lastPtr != 0 {
				(*TCompiledLocal)(unsafe.Pointer(lastPtr)).FnextPtr = libc.UintptrFromInt32(0)
			} else {
				(*TProc)(unsafe.Pointer(procPtr)).FfirstLocalPtr = libc.UintptrFromInt32(0)
			}
			(*TProc)(unsafe.Pointer(procPtr)).FlastLocalPtr = lastPtr
			for clPtr != 0 {
				toFree = clPtr
				clPtr = (*TCompiledLocal)(unsafe.Pointer(clPtr)).FnextPtr
				if (*TCompiledLocal)(unsafe.Pointer(toFree)).FresolveInfo != 0 {
					if (*TTcl_ResolvedVarInfo)(unsafe.Pointer((*TCompiledLocal)(unsafe.Pointer(toFree)).FresolveInfo)).FdeleteProc != 0 {
						(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ResolvedVarInfo)(unsafe.Pointer((*TCompiledLocal)(unsafe.Pointer(toFree)).FresolveInfo)).FdeleteProc})))(tls, (*TCompiledLocal)(unsafe.Pointer(toFree)).FresolveInfo)
					} else {
						XTclpFree(tls, (*TCompiledLocal)(unsafe.Pointer(toFree)).FresolveInfo)
					}
				}
				XTclpFree(tls, toFree)
			}
			(*TProc)(unsafe.Pointer(procPtr)).FnumCompiledLocals = (*TProc)(unsafe.Pointer(procPtr)).FnumArgs
		}
		XTclPushStackFrame(tls, interp, bp, nsPtr, 0)
		/*
		 * TIP #280: We get the invoking context from the cmdFrame which
		 * was saved by 'Tcl_ProcObjCmd' (using linePBodyPtr).
		 */
		hePtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FlinePBodyPtr)).FfindProc})))(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlinePBodyPtr, procPtr)
		/*
		 * Constructed saved frame has body as word 0. See Tcl_ProcObjCmd.
		 */
		(*TInterp)(unsafe.Pointer(iPtr)).FinvokeWord = 0
		if hePtr != 0 {
			v4 = (*TTcl_HashEntry)(unsafe.Pointer(hePtr)).FclientData
		} else {
			v4 = libc.UintptrFromInt32(0)
		}
		(*TInterp)(unsafe.Pointer(iPtr)).FinvokeCmdFramePtr = v4
		XTclSetByteCodeFromAny(tls, interp, bodyPtr, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
		(*TInterp)(unsafe.Pointer(iPtr)).FinvokeCmdFramePtr = libc.UintptrFromInt32(0)
		XTclPopStackFrame(tls, interp)
	} else {
		if (*TByteCode)(unsafe.Pointer(codePtr)).FnsEpoch != (*TNamespace)(unsafe.Pointer(nsPtr)).FresolverEpoch {
			/*
			 * The resolver epoch has changed, but we only need to invalidate the
			 * resolver cache.
			 */
			(*TByteCode)(unsafe.Pointer(codePtr)).FnsEpoch = (*TNamespace)(unsafe.Pointer(nsPtr)).FresolverEpoch
			*(*uint32)(unsafe.Pointer(codePtr + 40)) |= uint32(TCL_BYTECODE_RESOLVE_VARS)
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * MakeProcError --
 *
 *	Function called by TclObjInterpProc to create the stack information
 *	upon an error from a procedure.
 *
 * Results:
 *	The interpreter's error info trace is set to a value that supplements
 *	the error code.
 *
 * Side effects:
 *	none.
 *
 *----------------------------------------------------------------------
 */

func _MakeProcError(tls *libc.TLS, interp uintptr, procNameObj uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Name of the procedure. Used for error
	 * messages and trace information. */
	var limit, overflow, v2 int32
	var procName, v1, v3 uintptr
	var _ /* nameLen at bp+0 */ TTcl_Size
	_, _, _, _, _, _ = limit, overflow, procName, v1, v2, v3
	limit = int32(60)
	if (*TTcl_Obj)(unsafe.Pointer(procNameObj)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(procNameObj)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(procNameObj)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, procNameObj, bp)
	}
	procName = v1
	overflow = libc.BoolInt32(*(*TTcl_Size)(unsafe.Pointer(bp)) > int64(limit))
	if overflow != 0 {
		v2 = limit
	} else {
		v2 = int32(*(*TTcl_Size)(unsafe.Pointer(bp)))
	}
	if overflow != 0 {
		v3 = __ccgo_ts + 8560
	} else {
		v3 = __ccgo_ts + 1945
	}
	XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+64186, libc.VaList(bp+16, v2, procName, v3, XTcl_GetErrorLine(tls, interp))))
}

/*
 *----------------------------------------------------------------------
 *
 * TclProcDeleteProc --
 *
 *	This function is invoked just before a command procedure is removed
 *	from an interpreter. Its job is to release all the resources allocated
 *	to the procedure.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Memory gets freed, unless the procedure is actively being executed.
 *	In this case the cleanup is delayed until the last call to the current
 *	procedure completes.
 *
 *----------------------------------------------------------------------
 */

func XTclProcDeleteProc(tls *libc.TLS, clientData uintptr) {
	/* Procedure to be deleted. */
	var procPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _ = procPtr, v1, v2
	procPtr = clientData
	v2 = procPtr + 8
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclProcCleanupProc(tls, procPtr)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclProcCleanupProc --
 *
 *	This function does all the real work of freeing up a Proc structure.
 *	It's called only when the structure's reference count becomes zero.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Memory gets freed.
 *
 *----------------------------------------------------------------------
 */

func XTclProcCleanupProc(tls *libc.TLS, procPtr uintptr) {
	/* Procedure to be deleted. */
	var _objPtr, _objPtr1, _objPtr2, bodyPtr, cfPtr, codePtr, defPtr, hePtr, iPtr, irPtr, localPtr, nextPtr, resVarInfo, v1, v2, v4, v7, v9 uintptr
	var v3, v6, v8 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, bodyPtr, cfPtr, codePtr, defPtr, hePtr, iPtr, irPtr, localPtr, nextPtr, resVarInfo, v1, v2, v3, v4, v6, v7, v8, v9
	bodyPtr = (*TProc)(unsafe.Pointer(procPtr)).FbodyPtr
	hePtr = libc.UintptrFromInt32(0)
	cfPtr = libc.UintptrFromInt32(0)
	iPtr = (*TProc)(unsafe.Pointer(procPtr)).FiPtr
	if bodyPtr != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(bodyPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclByteCodeType)) {
			v1 = bodyPtr + 32
		} else {
			v1 = libc.UintptrFromInt32(0)
		}
		irPtr = v1
		if irPtr != 0 {
			v2 = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(irPtr))).Fptr1
		} else {
			v2 = libc.UintptrFromInt32(0)
		}
		codePtr = v2
		if codePtr != libc.UintptrFromInt32(0) && (*TByteCode)(unsafe.Pointer(codePtr)).FprocPtr == procPtr {
			(*TByteCode)(unsafe.Pointer(codePtr)).FprocPtr = libc.UintptrFromInt32(0)
		}
		_objPtr = bodyPtr
		v4 = _objPtr
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	localPtr = (*TProc)(unsafe.Pointer(procPtr)).FfirstLocalPtr
	for {
		if !(localPtr != libc.UintptrFromInt32(0)) {
			break
		}
		nextPtr = (*TCompiledLocal)(unsafe.Pointer(localPtr)).FnextPtr
		resVarInfo = (*TCompiledLocal)(unsafe.Pointer(localPtr)).FresolveInfo
		if resVarInfo != 0 {
			if (*TTcl_ResolvedVarInfo)(unsafe.Pointer(resVarInfo)).FdeleteProc != 0 {
				(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ResolvedVarInfo)(unsafe.Pointer(resVarInfo)).FdeleteProc})))(tls, resVarInfo)
			} else {
				XTclpFree(tls, resVarInfo)
			}
		}
		if (*TCompiledLocal)(unsafe.Pointer(localPtr)).FdefValuePtr != libc.UintptrFromInt32(0) {
			defPtr = (*TCompiledLocal)(unsafe.Pointer(localPtr)).FdefValuePtr
			_objPtr1 = defPtr
			v7 = _objPtr1
			v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
			*(*TTcl_Size)(unsafe.Pointer(v7))--
			if v6 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
		}
		XTclpFree(tls, localPtr)
		localPtr = nextPtr
		goto _5
	_5:
	}
	XTclpFree(tls, procPtr)
	/*
	 * TIP #280: Release the location data associated with this Proc
	 * structure, if any. The interpreter may not exist (For example for
	 * procbody structures created by tbcload.
	 */
	if iPtr == libc.UintptrFromInt32(0) {
		return
	}
	hePtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FlinePBodyPtr)).FfindProc})))(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlinePBodyPtr, procPtr)
	if !(hePtr != 0) {
		return
	}
	cfPtr = (*TTcl_HashEntry)(unsafe.Pointer(hePtr)).FclientData
	if cfPtr != 0 {
		if (*TCmdFrame)(unsafe.Pointer(cfPtr)).Ftype1 == int32(TCL_LOCATION_SOURCE) {
			_objPtr2 = (*TCmdFrame)(unsafe.Pointer(cfPtr)).Fdata.Feval.Fpath
			v9 = _objPtr2
			v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
			*(*TTcl_Size)(unsafe.Pointer(v9))--
			if v8 <= int64(1) {
				XTclFreeObj(tls, _objPtr2)
			}
			(*TCmdFrame)(unsafe.Pointer(cfPtr)).Fdata.Feval.Fpath = libc.UintptrFromInt32(0)
		}
		XTclpFree(tls, (*TCmdFrame)(unsafe.Pointer(cfPtr)).Fline)
		(*TCmdFrame)(unsafe.Pointer(cfPtr)).Fline = libc.UintptrFromInt32(0)
		XTclpFree(tls, cfPtr)
	}
	XTcl_DeleteHashEntry(tls, hePtr)
}

/*
 *----------------------------------------------------------------------
 *
 * TclUpdateReturnInfo --
 *
 *	This function is called when procedures return, and at other points
 *	where the TCL_RETURN code is used. It examines the returnLevel and
 *	returnCode to determine the real return status.
 *
 * Results:
 *	The return value is the true completion code to use for the procedure
 *	or script, instead of TCL_RETURN.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclUpdateReturnInfo(tls *libc.TLS, iPtr uintptr) (r int32) {
	/* Interpreter for which TCL_RETURN exception
	 * is being processed. */
	var code int32
	_ = code
	code = int32(TCL_RETURN)
	(*TInterp)(unsafe.Pointer(iPtr)).FreturnLevel--
	if (*TInterp)(unsafe.Pointer(iPtr)).FreturnLevel < 0 {
		XTcl_Panic(tls, __ccgo_ts+64220, 0)
	}
	if (*TInterp)(unsafe.Pointer(iPtr)).FreturnLevel == 0 {
		/*
		 * Now we've reached the level to return the requested -code.
		 * Since iPtr->returnLevel and iPtr->returnCode have completed
		 * their task, we now reset them to default values so that any
		 * bare "return TCL_RETURN" that may follow will work [Bug 2152286].
		 */
		code = (*TInterp)(unsafe.Pointer(iPtr)).FreturnCode
		(*TInterp)(unsafe.Pointer(iPtr)).FreturnLevel = int32(1)
		(*TInterp)(unsafe.Pointer(iPtr)).FreturnCode = TCL_OK
		if code == int32(TCL_ERROR) {
			*(*int32)(unsafe.Pointer(iPtr + 368)) |= int32(ERR_LEGACY_COPY)
		}
	}
	return code
}

/*
 *----------------------------------------------------------------------
 *
 * TclGetObjInterpProc/TclGetObjInterpProc2 --
 *
 *	Returns a pointer to the TclObjInterpProc/ObjInterpProc2 functions;
 *	this is different from the value obtained from the TclObjInterpProc
 *	reference on systems like Windows where import and export versions
 *	of a function exported by a DLL exist.
 *
 * Results:
 *	Returns the internal address of the TclObjInterpProc/ObjInterpProc2
 *	functions.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclGetObjInterpProc(tls *libc.TLS) (r uintptr) {
	return __ccgo_fp(XTclObjInterpProc)
}

func XTclGetObjInterpProc2(tls *libc.TLS) (r uintptr) {
	return __ccgo_fp(_ObjInterpProc2)
}

/*
 *----------------------------------------------------------------------
 *
 * TclNewProcBodyObj --
 *
 *	Creates a new object, of type "procbody", whose internal
 *	representation is the given Proc struct. The newly created object's
 *	reference count is 0.
 *
 * Results:
 *	Returns a pointer to a newly allocated Tcl_Obj, NULL on error.
 *
 * Side effects:
 *	The reference count in the ByteCode attached to the Proc is bumped up
 *	by one, since the internal rep stores a pointer to it.
 *
 *----------------------------------------------------------------------
 */

func XTclNewProcBodyObj(tls *libc.TLS, procPtr uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* the Proc struct to store as the internal
	 * representation. */
	var cachePtr, objPtr uintptr
	var v1 bool
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_, _, _ = cachePtr, objPtr, v1
	if !(procPtr != 0) {
		return libc.UintptrFromInt32(0)
	}
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	if objPtr != 0 {
		(*TProc)(unsafe.Pointer(procPtr)).FrefCount++
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(bp))).Fptr1 = procPtr
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(bp))).Fptr2 = libc.UintptrFromInt32(0)
		XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&XtclProcBodyType)), bp)
	}
	return objPtr
}

/*
 *----------------------------------------------------------------------
 *
 * ProcBodyDup --
 *
 *	Tcl_ObjType's Dup function for the proc body object. Bumps the
 *	reference count on the Proc stored in the internal representation.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Sets up the object in dupPtr to be a duplicate of the one in srcPtr.
 *
 *----------------------------------------------------------------------
 */

func _ProcBodyDup(tls *libc.TLS, srcPtr uintptr, dupPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Target object for the duplication. */
	var irPtr, procPtr, v1, v2 uintptr
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_, _, _, _ = irPtr, procPtr, v1, v2
	if (*TTcl_Obj)(unsafe.Pointer(srcPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclProcBodyType)) {
		v1 = srcPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	procPtr = v2
	(*TProc)(unsafe.Pointer(procPtr)).FrefCount++
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr1 = procPtr
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr2 = libc.UintptrFromInt32(0)
	XTcl_StoreInternalRep(tls, dupPtr, uintptr(unsafe.Pointer(&XtclProcBodyType)), bp)
}

/*
 *----------------------------------------------------------------------
 *
 * ProcBodyFree --
 *
 *	Tcl_ObjType's Free function for the proc body object. The reference
 *	count on its Proc struct is decreased by 1; if the count reaches 0,
 *	the proc is freed.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	If the reference count on the Proc struct reaches 0, the struct is
 *	freed.
 *
 *----------------------------------------------------------------------
 */

func _ProcBodyFree(tls *libc.TLS, objPtr uintptr) {
	/* The object to clean up. */
	var irPtr, procPtr, v1, v2, v4 uintptr
	var v3 TTcl_Size
	_, _, _, _, _, _ = irPtr, procPtr, v1, v2, v3, v4
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclProcBodyType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	procPtr = v2
	v4 = procPtr + 8
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	if v3 <= int64(1) {
		XTclProcCleanupProc(tls, procPtr)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * DupLambdaInternalRep, FreeLambdaInternalRep, SetLambdaFromAny --
 *
 *	How to manage the internal representations of lambda term objects.
 *	Syntactically they look like a two- or three-element list, where the
 *	first element is the formal arguments, the second is the body, and
 *	the (optional) third is the namespace to execute the lambda term
 *	within (the global namespace is assumed if it is absent).
 *
 *----------------------------------------------------------------------
 */

func _DupLambdaInternalRep(tls *libc.TLS, srcPtr uintptr, copyPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Object with internal rep to set. */
	var irPtr, nsObjPtr, procPtr, v1, v2, v3 uintptr
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_, _, _, _, _, _ = irPtr, nsObjPtr, procPtr, v1, v2, v3
	if (*TTcl_Obj)(unsafe.Pointer(srcPtr)).FtypePtr == uintptr(unsafe.Pointer(&_lambdaType)) {
		v1 = srcPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	procPtr = v2
	if irPtr != 0 {
		v3 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr2
	} else {
		v3 = libc.UintptrFromInt32(0)
	}
	nsObjPtr = v3
	(*TProc)(unsafe.Pointer(procPtr)).FrefCount++
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr1 = procPtr
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr2 = nsObjPtr
	(*TTcl_Obj)(unsafe.Pointer(nsObjPtr)).FrefCount++
	XTcl_StoreInternalRep(tls, copyPtr, uintptr(unsafe.Pointer(&_lambdaType)), bp)
}

func _FreeLambdaInternalRep(tls *libc.TLS, objPtr uintptr) {
	/* CmdName object with internal representation
	 * to free. */
	var cachePtr, irPtr, nsObjPtr, procPtr, v1, v2, v3, v5, v7 uintptr
	var v4, v6 TTcl_Size
	var v8 bool
	_, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, irPtr, nsObjPtr, procPtr, v1, v2, v3, v4, v5, v6, v7, v8
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_lambdaType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	procPtr = v2
	if irPtr != 0 {
		v3 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr2
	} else {
		v3 = libc.UintptrFromInt32(0)
	}
	nsObjPtr = v3
	v5 = procPtr + 8
	v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
	*(*TTcl_Size)(unsafe.Pointer(v5))--
	if v4 <= int64(1) {
		XTclProcCleanupProc(tls, procPtr)
	}
	v7 = nsObjPtr
	v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
	*(*TTcl_Size)(unsafe.Pointer(v7))--
	if !(v6 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(nsObjPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(nsObjPtr)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(nsObjPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(nsObjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(nsObjPtr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(nsObjPtr)).Flength = int64(-libc.Int32FromInt32(1))
			if v8 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v8 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v8 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, nsObjPtr)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(nsObjPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = nsObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, nsObjPtr)
		}
	}
}

func _SetLambdaFromAny(tls *libc.TLS, interp uintptr, objPtr uintptr) (r int32) {
	bp := tls.Alloc(112)
	defer tls.Free(112) /* The object to convert. */
	var _objPtr, argsPtr, bodyPtr, cachePtr, cachePtr1, cfPtr, contextPtr, iPtr, name, nsName, nsObjPtr, v11, v6, v7, v9 uintptr
	var result, v1, v3 int32
	var v10, v12 bool
	var v2, v4, v5 int64
	var v8 TTcl_Size
	var _ /* buf at bp+32 */ [2]TTcl_Size
	var _ /* ir at bp+48 */ TTcl_ObjInternalRep
	var _ /* isNew at bp+8 */ int32
	var _ /* objc at bp+16 */ TTcl_Size
	var _ /* objv at bp+0 */ uintptr
	var _ /* procPtr at bp+24 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, argsPtr, bodyPtr, cachePtr, cachePtr1, cfPtr, contextPtr, iPtr, name, nsName, nsObjPtr, result, v1, v10, v11, v12, v2, v3, v4, v5, v6, v7, v8, v9
	iPtr = interp
	cfPtr = libc.UintptrFromInt32(0)
	if interp == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Convert objPtr to list type first; if it cannot be converted, or if its
	 * length is not 2, then it cannot be converted to lambdaType.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr2)).FspanLength
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = v2
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), objPtr, bp+16)
	}
	result = v1
	if result != TCL_OK || *(*TTcl_Size)(unsafe.Pointer(bp + 16)) != int64(2) && *(*TTcl_Size)(unsafe.Pointer(bp + 16)) != int64(3) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+64263, libc.VaList(bp+72, XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0)))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+72, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+64307, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr2 != 0 {
			v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr2)).FspanStart
		} else {
			v4 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1 + 40 + uintptr(v4)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr2 != 0 {
			v5 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr2)).FspanLength
		} else {
			v5 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = v5
		v3 = libc.Int32FromInt32(TCL_OK)
	} else {
		v3 = XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), objPtr, bp+16, bp)
	}
	result = v3
	if result != TCL_OK || *(*TTcl_Size)(unsafe.Pointer(bp + 16)) != int64(2) && *(*TTcl_Size)(unsafe.Pointer(bp + 16)) != int64(3) {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
			v6 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		} else {
			v6 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+64263, libc.VaList(bp+72, v6)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+72, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+64307, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	argsPtr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))
	bodyPtr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1*8))
	/*
	 * Create and initialize the Proc struct. The cmdPtr field is set to NULL
	 * to signal that this is an anonymous function.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		v7 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		v7 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
	}
	name = v7
	if XTclCreateProc(tls, interp, libc.UintptrFromInt32(0), name, argsPtr, bodyPtr, bp+24) != TCL_OK {
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+64314, libc.VaList(bp+72, name)))
		return int32(TCL_ERROR)
	}
	/*
	 * CAREFUL: TclCreateProc returns refCount==1! [Bug 1578454]
	 * procPtr->refCount = 1;
	 */
	(*TProc)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).FcmdPtr = libc.UintptrFromInt32(0)
	/*
	 * TIP #280: Remember the line the apply body is starting on. In a Byte
	 * code context we ask the engine to provide us with the necessary
	 * information. This is for the initialization of the byte code compiler
	 * when the body is used for the first time.
	 *
	 * NOTE: The body is the second word in the 'objPtr'. Its location,
	 * accessible through 'context.line[1]' (see below) is therefore only the
	 * first approximation of the actual line the body is on. We have to use
	 * the string rep of the 'objPtr' to determine the exact line. This is
	 * available already through 'name'. Use 'TclListLines', see 'switch'
	 * (tclCmdMZ.c).
	 *
	 * This code is nearly identical to the #280 code in Tcl_ProcObjCmd, see
	 * this file. The differences are the different index of the body in the
	 * line array of the context, and the special processing mentioned in the
	 * previous paragraph to track into the list. Find a way to factor the
	 * common elements into a single function.
	 */
	if (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr != 0 {
		contextPtr = XTclStackAlloc(tls, interp, uint64(88))
		*(*TCmdFrame)(unsafe.Pointer(contextPtr)) = *(*TCmdFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr))
		if (*TCmdFrame)(unsafe.Pointer(contextPtr)).Ftype1 == int32(TCL_LOCATION_BC) {
			/*
			 * Retrieve the source context from the bytecode. This call
			 * accounts for the reference to the source file, if any, held in
			 * 'context.data.eval.path'.
			 */
			XTclGetSrcInfoForPc(tls, contextPtr)
		} else {
			if (*TCmdFrame)(unsafe.Pointer(contextPtr)).Ftype1 == int32(TCL_LOCATION_SOURCE) {
				/*
				 * We created a new reference to the source file path name when we
				 * created 'context' above. Account for the reference.
				 */
				(*TTcl_Obj)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(contextPtr)).Fdata.Feval.Fpath)).FrefCount++
			}
		}
		if (*TCmdFrame)(unsafe.Pointer(contextPtr)).Ftype1 == int32(TCL_LOCATION_SOURCE) {
			/*
			 * We can record source location within a lambda only if the body
			 * was not created by substitution.
			 */
			if (*TCmdFrame)(unsafe.Pointer(contextPtr)).Fline != 0 && (*TCmdFrame)(unsafe.Pointer(contextPtr)).Fnline >= int64(2) && *(*TTcl_Size)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(contextPtr)).Fline + 1*8)) >= 0 {
				/*
				 * Move from approximation (line of list cmd word) to actual
				 * location (line of 2nd list element).
				 */
				cfPtr = XTcl_Alloc(tls, uint64(88))
				XTclListLines(tls, objPtr, *(*TTcl_Size)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(contextPtr)).Fline + 1*8)), int64(2), bp+32, libc.UintptrFromInt32(0))
				(*TCmdFrame)(unsafe.Pointer(cfPtr)).Flevel = -int32(1)
				(*TCmdFrame)(unsafe.Pointer(cfPtr)).Ftype1 = (*TCmdFrame)(unsafe.Pointer(contextPtr)).Ftype1
				(*TCmdFrame)(unsafe.Pointer(cfPtr)).Fline = XTcl_Alloc(tls, uint64(8))
				*(*TTcl_Size)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(cfPtr)).Fline)) = (*(*[2]TTcl_Size)(unsafe.Pointer(bp + 32)))[int32(1)]
				(*TCmdFrame)(unsafe.Pointer(cfPtr)).Fnline = int64(1)
				(*TCmdFrame)(unsafe.Pointer(cfPtr)).FframePtr = libc.UintptrFromInt32(0)
				(*TCmdFrame)(unsafe.Pointer(cfPtr)).FnextPtr = libc.UintptrFromInt32(0)
				(*TCmdFrame)(unsafe.Pointer(cfPtr)).Fdata.Feval.Fpath = (*TCmdFrame)(unsafe.Pointer(contextPtr)).Fdata.Feval.Fpath
				(*TTcl_Obj)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(cfPtr)).Fdata.Feval.Fpath)).FrefCount++
				(*TCmdFrame)(unsafe.Pointer(cfPtr)).Fcmd = libc.UintptrFromInt32(0)
				(*TCmdFrame)(unsafe.Pointer(cfPtr)).Flen1 = 0
			}
			/*
			 * 'contextPtr' is going out of scope. Release the reference that
			 * it's holding to the source file path
			 */
			_objPtr = (*TCmdFrame)(unsafe.Pointer(contextPtr)).Fdata.Feval.Fpath
			v9 = _objPtr
			v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
			*(*TTcl_Size)(unsafe.Pointer(v9))--
			if v8 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
		XTclStackFree(tls, interp, contextPtr)
	}
	(*TTcl_HashEntry)(unsafe.Pointer((*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FlinePBodyPtr)).FcreateProc})))(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlinePBodyPtr, *(*uintptr)(unsafe.Pointer(bp + 24)), bp+8))).FclientData = cfPtr
	/*
	 * Set the namespace for this lambda: given by objv[2] understood as a
	 * global reference, or else global per default.
	 */
	if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) == int64(2) {
		if v10 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v10 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v10 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			nsObjPtr = XTclThreadAllocObj(tls)
		} else {
			nsObjPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(nsObjPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(nsObjPtr)).FrefCount = 0
		if libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer(nsObjPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(nsObjPtr)).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(nsObjPtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(nsObjPtr)).Fbytes, __ccgo_ts+7650, libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(nsObjPtr)).Fbytes + uintptr(libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(nsObjPtr)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(3) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer(nsObjPtr)).FtypePtr = libc.UintptrFromInt32(0)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2*8)))).Fbytes != 0 {
			v11 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2*8)))).Fbytes
		} else {
			v11 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2*8)), libc.UintptrFromInt32(0))
		}
		nsName = v11
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(nsName))) != int32(':') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(nsName + 1))) != int32(':') {
			if v12 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v12 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v12 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
				nsObjPtr = XTclThreadAllocObj(tls)
			} else {
				nsObjPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(nsObjPtr + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(nsObjPtr)).FrefCount = 0
			if libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1) == uint64(0) {
				(*TTcl_Obj)(unsafe.Pointer(nsObjPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(nsObjPtr)).Flength = int64(libc.Int32FromInt32(0))
			} else {
				(*TTcl_Obj)(unsafe.Pointer(nsObjPtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
				libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(nsObjPtr)).Fbytes, __ccgo_ts+7650, libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1))
				*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(nsObjPtr)).Fbytes + uintptr(libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)))) = uint8('\000')
				(*TTcl_Obj)(unsafe.Pointer(nsObjPtr)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(3) - libc.Uint64FromInt32(1))
			}
			(*TTcl_Obj)(unsafe.Pointer(nsObjPtr)).FtypePtr = libc.UintptrFromInt32(0)
			XTcl_AppendObjToObj(tls, nsObjPtr, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2*8)))
		} else {
			nsObjPtr = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2*8))
		}
	}
	/*
	 * Free the list internalrep of objPtr - this will free argsPtr, but
	 * bodyPtr retains a reference from the Proc structure. Then finish the
	 * conversion to lambdaType.
	 */
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp + 48))).Fptr1 = *(*uintptr)(unsafe.Pointer(bp + 24))
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp + 48))).Fptr2 = nsObjPtr
	(*TTcl_Obj)(unsafe.Pointer(nsObjPtr)).FrefCount++
	XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&_lambdaType)), bp+48)
	return TCL_OK
}

func XTclGetLambdaFromObj(tls *libc.TLS, interp uintptr, objPtr uintptr, nsObjPtrPtr uintptr) (r uintptr) {
	var irPtr, irPtr1, nsObjPtr, procPtr, v1, v2, v3, v4, v5, v6 uintptr
	_, _, _, _, _, _, _, _, _, _ = irPtr, irPtr1, nsObjPtr, procPtr, v1, v2, v3, v4, v5, v6
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_lambdaType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	procPtr = v2
	if irPtr != 0 {
		v3 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr2
	} else {
		v3 = libc.UintptrFromInt32(0)
	}
	nsObjPtr = v3
	if procPtr == libc.UintptrFromInt32(0) {
		if _SetLambdaFromAny(tls, interp, objPtr) != TCL_OK {
			return libc.UintptrFromInt32(0)
		}
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_lambdaType)) {
			v4 = objPtr + 32
		} else {
			v4 = libc.UintptrFromInt32(0)
		}
		irPtr1 = v4
		if irPtr1 != 0 {
			v5 = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(irPtr1))).Fptr1
		} else {
			v5 = libc.UintptrFromInt32(0)
		}
		procPtr = v5
		if irPtr1 != 0 {
			v6 = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(irPtr1))).Fptr2
		} else {
			v6 = libc.UintptrFromInt32(0)
		}
		nsObjPtr = v6
	}
	if (*TProc)(unsafe.Pointer(procPtr)).FiPtr != interp {
		return libc.UintptrFromInt32(0)
	}
	*(*uintptr)(unsafe.Pointer(nsObjPtrPtr)) = nsObjPtr
	return procPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ApplyObjCmd --
 *
 *	This object-based function is invoked to process the "apply" Tcl
 *	command. See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl object result value.
 *
 * Side effects:
 *	Depends on the content of the lambda term (i.e., objv[1]).
 *
 *----------------------------------------------------------------------
 */

func XTcl_ApplyObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	return XTcl_NRCallObjProc(tls, interp, __ccgo_fp(XTclNRApplyObjCmd), clientData, int64(objc), objv)
}

func XTclNRApplyObjCmd(tls *libc.TLS, dummy2672 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Argument objects. */
	var _objPtr, cachePtr, extraPtr, lambdaPtr, procPtr uintptr
	var result int32
	var v1 bool
	var _ /* _callbackPtr at bp+16 */ uintptr
	var _ /* nsObjPtr at bp+0 */ uintptr
	var _ /* nsPtr at bp+8 */ uintptr
	_, _, _, _, _, _, _ = _objPtr, cachePtr, extraPtr, lambdaPtr, procPtr, result, v1
	procPtr = libc.UintptrFromInt32(0)
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+64352)
		return int32(TCL_ERROR)
	}
	/*
	 * Set lambdaPtr, convert it to tclLambdaType in the current interp if
	 * necessary.
	 */
	lambdaPtr = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	procPtr = XTclGetLambdaFromObj(tls, interp, lambdaPtr, bp)
	if procPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Push a call frame for the lambda namespace.
	 * Note that TclObjInterpProc() will pop it.
	 */
	result = XTclGetNamespaceFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), bp+8)
	if result != TCL_OK {
		return int32(TCL_ERROR)
	}
	extraPtr = XTclStackAlloc(tls, interp, uint64(176))
	libc.Xmemset(tls, extraPtr, 0, uint64(120))
	(*TProc)(unsafe.Pointer(procPtr)).FcmdPtr = extraPtr
	(*TApplyExtraData)(unsafe.Pointer(extraPtr)).Fcmd.FnsPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
	/*
	 * TIP#280 (semi-)HACK!
	 *
	 * Using cmd.clientData to tell [info frame] how to render the lambdaPtr.
	 * The InfoFrameCmd will detect this case by testing cmd.hPtr for NULL.
	 * This condition holds here because of the memset() above, and nowhere
	 * else (in the core). Regular commands always have a valid hPtr, and
	 * lambda's never.
	 */
	(*TApplyExtraData)(unsafe.Pointer(extraPtr)).Fefi.Flength = int64(1)
	(*(*TExtraFrameInfoField)(unsafe.Pointer(extraPtr + 120 + 8))).Fname = __ccgo_ts + 28552
	(*(*TExtraFrameInfoField)(unsafe.Pointer(extraPtr + 120 + 8))).Fproc = libc.UintptrFromInt32(0)
	(*(*TExtraFrameInfoField)(unsafe.Pointer(extraPtr + 120 + 8))).FclientData = lambdaPtr
	(*TApplyExtraData)(unsafe.Pointer(extraPtr)).Fcmd.FclientData = extraPtr + 120
	result = XTclPushProcCallFrame(tls, procPtr, interp, int64(objc), objv, int32(1))
	if result == TCL_OK {
		if v1 = interp == libc.UintptrFromInt32(0); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			_objPtr = XTclThreadAllocObj(tls)
		} else {
			_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(_objPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		*(*uintptr)(unsafe.Pointer(bp + 16)) = _objPtr
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FprocPtr = __ccgo_fp(_ApplyNR2)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8)) = extraPtr
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
		(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 16))
		result = XTclNRInterpProcCore(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), int64(2), __ccgo_fp(_MakeLambdaError))
	}
	return result
}

func _ApplyNR2(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	var extraPtr uintptr
	_ = extraPtr
	extraPtr = *(*uintptr)(unsafe.Pointer(data))
	XTclStackFree(tls, interp, extraPtr)
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * MakeLambdaError --
 *
 *	Function called by TclObjInterpProc to create the stack information
 *	upon an error from a lambda term.
 *
 * Results:
 *	The interpreter's error info trace is set to a value that supplements
 *	the error code.
 *
 * Side effects:
 *	none.
 *
 *----------------------------------------------------------------------
 */

func _MakeLambdaError(tls *libc.TLS, interp uintptr, procNameObj uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Name of the procedure. Used for error
	 * messages and trace information. */
	var limit, overflow, v2 int32
	var procName, v1, v3 uintptr
	var _ /* nameLen at bp+0 */ TTcl_Size
	_, _, _, _, _, _ = limit, overflow, procName, v1, v2, v3
	limit = int32(60)
	if (*TTcl_Obj)(unsafe.Pointer(procNameObj)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(procNameObj)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(procNameObj)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, procNameObj, bp)
	}
	procName = v1
	overflow = libc.BoolInt32(*(*TTcl_Size)(unsafe.Pointer(bp)) > int64(limit))
	if overflow != 0 {
		v2 = limit
	} else {
		v2 = int32(*(*TTcl_Size)(unsafe.Pointer(bp)))
	}
	if overflow != 0 {
		v3 = __ccgo_ts + 8560
	} else {
		v3 = __ccgo_ts + 1945
	}
	XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+64373, libc.VaList(bp+16, v2, procName, v3, XTcl_GetErrorLine(tls, interp))))
}

/*
 *----------------------------------------------------------------------
 *
 * TclGetCmdFrameForProcedure --
 *
 *	How to get the CmdFrame information for a procedure.
 *
 * Results:
 *	A pointer to the CmdFrame (only guaranteed to be valid until the next
 *	Tcl command is processed or the interpreter's state is otherwise
 *	modified) or a NULL if the information is not available.
 *
 * Side effects:
 *	none.
 *
 *----------------------------------------------------------------------
 */

func XTclGetCmdFrameForProcedure(tls *libc.TLS, procPtr uintptr) (r uintptr) {
	/* The procedure whose cmd-frame is to be
	 * looked up. */
	var hePtr uintptr
	_ = hePtr
	if procPtr == libc.UintptrFromInt32(0) || (*TProc)(unsafe.Pointer(procPtr)).FiPtr == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	hePtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TInterp1)(unsafe.Pointer((*TProc)(unsafe.Pointer(procPtr)).FiPtr)).FlinePBodyPtr)).FfindProc})))(tls, (*TInterp1)(unsafe.Pointer((*TProc)(unsafe.Pointer(procPtr)).FiPtr)).FlinePBodyPtr, procPtr)
	if hePtr == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	return (*TTcl_HashEntry)(unsafe.Pointer(hePtr)).FclientData
}

type TInterp1 = struct {
	FlegacyResult           uintptr
	FlegacyFreeProc         uintptr
	FerrorLine              int32
	FstubTable              uintptr
	Fhandle                 TTclHandle
	FglobalNsPtr            uintptr
	FhiddenCmdTablePtr      uintptr
	FinterpInfo             uintptr
	Foptimizer              uintptr
	FnumLevels              TTcl_Size
	FmaxNestingDepth        TTcl_Size
	FframePtr               uintptr
	FvarFramePtr            uintptr
	FactiveVarTracePtr      uintptr
	FreturnCode             int32
	FrootFramePtr           uintptr
	FlookupNsPtr            uintptr
	FpackageTable           TTcl_HashTable
	FpackageUnknown         uintptr
	FcmdCount               TTcl_Size
	FevalFlags              int32
	FliteralTable           TLiteralTable
	FcompileEpoch           TTcl_Size
	FcompiledProcPtr        uintptr
	FresolverPtr            uintptr
	FscriptFile             uintptr
	Fflags                  int32
	FrandSeed               int64
	FtracePtr               uintptr
	FassocData              uintptr
	FexecEnvPtr             uintptr
	FemptyObjPtr            uintptr
	FobjResultPtr           uintptr
	FthreadId               TTcl_ThreadId
	FactiveCmdTracePtr      uintptr
	FactiveInterpTracePtr   uintptr
	FtracesForbiddingInline TTcl_Size
	FreturnOpts             uintptr
	FerrorInfo              uintptr
	FeiVar                  uintptr
	FerrorCode              uintptr
	FecVar                  uintptr
	FreturnLevel            int32
	Flimit                  struct {
		Factive            int32
		FgranularityTicker int32
		Fexceeded          int32
		FcmdCount          TTcl_Size
		FcmdHandlers       uintptr
		FcmdGranularity    int32
		Ftime              TTcl_Time
		FtimeHandlers      uintptr
		FtimeGranularity   int32
		FtimeEvent         TTcl_TimerToken
		Fcallbacks         TTcl_HashTable
	}
	FensembleRewrite struct {
		FsourceObjs      uintptr
		FnumRemovedObjs  TTcl_Size
		FnumInsertedObjs TTcl_Size
	}
	FchanMsg           uintptr
	FcmdFramePtr       uintptr
	FinvokeCmdFramePtr uintptr
	FinvokeWord        int32
	FlinePBodyPtr      uintptr
	FlineBCPtr         uintptr
	FlineLABCPtr       uintptr
	FlineLAPtr         uintptr
	FscriptCLLocPtr    uintptr
	FpackagePrefer     int32
	FvarTraces         TTcl_HashTable
	FvarSearches       TTcl_HashTable
	FallocCache        uintptr
	FpendingObjDataPtr uintptr
	FasyncReadyPtr     uintptr
	FobjectFoundation  uintptr
	FdeferredCallbacks uintptr
	FasyncCancel       TTcl_AsyncHandler
	FasyncCancelMsg    uintptr
	FerrorStack        uintptr
	FupLiteral         uintptr
	FcallLiteral       uintptr
	FinnerLiteral      uintptr
	FinnerContext      uintptr
	FresetErrorStack   int32
}

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * Autopurge flag. Process-global because of the way Tcl manages child
 * processes (see tclPipe.c).
 */

var _autopurge = int32(1)

/* Autopurge flag. */

/*
 * Hash tables that keeps track of all child process statuses. Keys are the
 * child process ids and resolved pids, values are (ProcessInfo *).
 */

type TProcessInfo = struct {
	Fpid         TTcl_Pid
	FresolvedPid int32
	Fpurge       int32
	Fstatus      TTclProcessWaitStatus
	Fcode        int32
	Fmsg         uintptr
	Ferror1      uintptr
}

var _infoTablePerPid TTcl_HashTable
var _infoTablePerResolvedPid TTcl_HashTable
var _infoTablesInitialized = int32(0) /* 0 means not yet initialized. */

var _infoTablesMutex TTcl_Mutex

/*
 *----------------------------------------------------------------------
 *
 * InitProcessInfo --
 *
 *	Initializes the ProcessInfo structure.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Memory written.
 *
 *----------------------------------------------------------------------
 */

func _InitProcessInfo(tls *libc.TLS, info uintptr, pid TTcl_Pid, resolvedPid TTcl_Size) {
	/* Resolved process id. */
	(*TProcessInfo)(unsafe.Pointer(info)).Fpid = pid
	(*TProcessInfo)(unsafe.Pointer(info)).FresolvedPid = int32(resolvedPid)
	(*TProcessInfo)(unsafe.Pointer(info)).Fpurge = 0
	(*TProcessInfo)(unsafe.Pointer(info)).Fstatus = int32(TCL_PROCESS_UNCHANGED)
	(*TProcessInfo)(unsafe.Pointer(info)).Fcode = 0
	(*TProcessInfo)(unsafe.Pointer(info)).Fmsg = libc.UintptrFromInt32(0)
	(*TProcessInfo)(unsafe.Pointer(info)).Ferror1 = libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * FreeProcessInfo --
 *
 *	Free the ProcessInfo structure.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Memory deallocated, Tcl_Obj refcount decreased.
 *
 *----------------------------------------------------------------------
 */

func _FreeProcessInfo(tls *libc.TLS, info uintptr) {
	/* Structure to free. */
	var _objPtr, _objPtr1, v2, v4 uintptr
	var v1, v3 TTcl_Size
	_, _, _, _, _, _ = _objPtr, _objPtr1, v1, v2, v3, v4
	/*
	 * Free stored Tcl_Objs.
	 */
	if (*TProcessInfo)(unsafe.Pointer(info)).Fmsg != 0 {
		_objPtr = (*TProcessInfo)(unsafe.Pointer(info)).Fmsg
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	if (*TProcessInfo)(unsafe.Pointer(info)).Ferror1 != 0 {
		_objPtr1 = (*TProcessInfo)(unsafe.Pointer(info)).Ferror1
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
	/*
	 * Free allocated structure.
	 */
	XTclpFree(tls, info)
}

/*
 *----------------------------------------------------------------------
 *
 * RefreshProcessInfo --
 *
 *	Refresh process info.
 *
 * Results:
 *	Nonzero if state changed, else zero.
 *
 * Side effects:
 *	May call WaitProcessStatus, which can block if WNOHANG option is set.
 *
 *----------------------------------------------------------------------
 */

func _RefreshProcessInfo(tls *libc.TLS, info uintptr, options int32) (r int32) {
	/* Options passed to WaitProcessStatus. */
	if (*TProcessInfo)(unsafe.Pointer(info)).Fstatus == int32(TCL_PROCESS_UNCHANGED) {
		/*
		 * Refresh & store status.
		 */
		(*TProcessInfo)(unsafe.Pointer(info)).Fstatus = _WaitProcessStatus(tls, (*TProcessInfo)(unsafe.Pointer(info)).Fpid, int64((*TProcessInfo)(unsafe.Pointer(info)).FresolvedPid), options, info+20, info+24, info+32)
		if (*TProcessInfo)(unsafe.Pointer(info)).Fmsg != 0 {
			(*TTcl_Obj)(unsafe.Pointer((*TProcessInfo)(unsafe.Pointer(info)).Fmsg)).FrefCount++
		}
		if (*TProcessInfo)(unsafe.Pointer(info)).Ferror1 != 0 {
			(*TTcl_Obj)(unsafe.Pointer((*TProcessInfo)(unsafe.Pointer(info)).Ferror1)).FrefCount++
		}
		return libc.BoolInt32((*TProcessInfo)(unsafe.Pointer(info)).Fstatus != int32(TCL_PROCESS_UNCHANGED))
	} else {
		/*
		 * No change.
		 */
		return 0
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * WaitProcessStatus --
 *
 *	Wait for process status to change.
 *
 * Results:
 *	TclProcessWaitStatus enum value.
 *
 * Side effects:
 *	May call WaitProcessStatus, which can block if WNOHANG option is set.
 *
 *----------------------------------------------------------------------
 */

func _WaitProcessStatus(tls *libc.TLS, pid TTcl_Pid, resolvedPid TTcl_Size, options int32, codePtr uintptr, msgObjPtr uintptr, errorObjPtr uintptr) (r TTclProcessWaitStatus) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* If non-NULL, will receive error code. */
	var cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, msg uintptr
	var v1, v2, v3, v4, v5 bool
	var _ /* errorStrings at bp+8 */ [5]uintptr
	var _ /* waitStatus at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, msg, v1, v2, v3, v4, v5
	pid = XTcl_WaitPid(tls, pid, bp, options)
	if pid == uintptr(0) {
		/*
		 * No change.
		 */
		return int32(TCL_PROCESS_UNCHANGED)
	}
	/*
	 * Get process status.
	 */
	if pid == uintptr(-libc.Int32FromInt32(1)) {
		/*
		 * POSIX errName msg
		 */
		msg = XTcl_ErrnoMsg(tls, *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))))
		if *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(ECHILD) {
			/*
			 * This changeup in message suggested by Mark Diekhans to
			 * remind people that ECHILD errors can occur on some
			 * systems if SIGCHLD isn't in its default state.
			 */
			msg = __ccgo_ts + 64409
		}
		if codePtr != 0 {
			*(*int32)(unsafe.Pointer(codePtr)) = *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))
		}
		if msgObjPtr != 0 {
			*(*uintptr)(unsafe.Pointer(msgObjPtr)) = XTcl_ObjPrintf(tls, __ccgo_ts+64461, libc.VaList(bp+56, msg))
		}
		if errorObjPtr != 0 {
			(*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[0] = XTcl_NewStringObj(tls, __ccgo_ts+49678, int64(-int32(1)))
			(*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] = XTcl_NewStringObj(tls, XTcl_ErrnoId(tls), int64(-int32(1)))
			(*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(2)] = XTcl_NewStringObj(tls, msg, int64(-int32(1)))
			*(*uintptr)(unsafe.Pointer(errorObjPtr)) = XTcl_NewListObj(tls, int64(3), bp+8)
		}
		return int32(TCL_PROCESS_ERROR)
	} else {
		if !(*(*int32)(unsafe.Pointer(bp))&libc.Int32FromInt32(0x7f) != 0) {
			if codePtr != 0 {
				*(*int32)(unsafe.Pointer(codePtr)) = *(*int32)(unsafe.Pointer(bp)) & int32(0xff00) >> int32(8)
			}
			if !(*(*int32)(unsafe.Pointer(bp))&libc.Int32FromInt32(0xff00)>>libc.Int32FromInt32(8) != 0) {
				/*
				 * Normal exit.
				 */
				if msgObjPtr != 0 {
					*(*uintptr)(unsafe.Pointer(msgObjPtr)) = libc.UintptrFromInt32(0)
				}
				if errorObjPtr != 0 {
					*(*uintptr)(unsafe.Pointer(errorObjPtr)) = libc.UintptrFromInt32(0)
				}
			} else {
				/*
				 * CHILDSTATUS pid code
				 *
				 * Child exited with a non-zero exit status.
				 */
				if msgObjPtr != 0 {
					*(*uintptr)(unsafe.Pointer(msgObjPtr)) = XTcl_NewStringObj(tls, __ccgo_ts+56662, int64(-int32(1)))
				}
				if errorObjPtr != 0 {
					(*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[0] = XTcl_NewStringObj(tls, __ccgo_ts+64499, int64(-int32(1)))
					if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
						cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
						(*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] = XTclThreadAllocObj(tls)
					} else {
						(*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).FrefCount = 0
					(*TTcl_Obj)(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).Fbytes = libc.UintptrFromInt32(0)
					*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).FinternalRep)) = resolvedPid
					(*TTcl_Obj)(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
					if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
						cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
						(*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(2)] = XTclThreadAllocObj(tls)
					} else {
						(*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(2)] = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(2)] + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(2)])).FrefCount = 0
					(*TTcl_Obj)(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(2)])).Fbytes = libc.UintptrFromInt32(0)
					*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(2)])).FinternalRep)) = int64(*(*int32)(unsafe.Pointer(bp)) & libc.Int32FromInt32(0xff00) >> libc.Int32FromInt32(8))
					(*TTcl_Obj)(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(2)])).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
					*(*uintptr)(unsafe.Pointer(errorObjPtr)) = XTcl_NewListObj(tls, int64(3), bp+8)
				}
			}
			return int32(TCL_PROCESS_EXITED)
		} else {
			if libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))&libc.Int32FromInt32(0xffff))-uint32(1) < uint32(0xff) {
				/*
				 * CHILDKILLED pid sigName msg
				 *
				 * Child killed because of a signal.
				 */
				msg = XTcl_SignalMsg(tls, *(*int32)(unsafe.Pointer(bp))&int32(0x7f))
				if codePtr != 0 {
					*(*int32)(unsafe.Pointer(codePtr)) = *(*int32)(unsafe.Pointer(bp)) & int32(0x7f)
				}
				if msgObjPtr != 0 {
					*(*uintptr)(unsafe.Pointer(msgObjPtr)) = XTcl_ObjPrintf(tls, __ccgo_ts+64511, libc.VaList(bp+56, msg))
				}
				if errorObjPtr != 0 {
					(*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[0] = XTcl_NewStringObj(tls, __ccgo_ts+64528, int64(-int32(1)))
					if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
						cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
						(*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] = XTclThreadAllocObj(tls)
					} else {
						(*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).FrefCount = 0
					(*TTcl_Obj)(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).Fbytes = libc.UintptrFromInt32(0)
					*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).FinternalRep)) = resolvedPid
					(*TTcl_Obj)(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
					(*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(2)] = XTcl_NewStringObj(tls, XTcl_SignalId(tls, *(*int32)(unsafe.Pointer(bp))&int32(0x7f)), int64(-int32(1)))
					(*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(3)] = XTcl_NewStringObj(tls, msg, int64(-int32(1)))
					*(*uintptr)(unsafe.Pointer(errorObjPtr)) = XTcl_NewListObj(tls, int64(4), bp+8)
				}
				return int32(TCL_PROCESS_SIGNALED)
			} else {
				if int32(libc.Int16FromUint32(libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp))&libc.Int32FromInt32(0xffff))*libc.Uint32FromUint32(0x10001)>>libc.Int32FromInt32(8))) > int32(0x7f00) {
					/*
					 * CHILDSUSP pid sigName msg
					 *
					 * Child suspended because of a signal.
					 */
					msg = XTcl_SignalMsg(tls, *(*int32)(unsafe.Pointer(bp))&int32(0xff00)>>int32(8))
					if codePtr != 0 {
						*(*int32)(unsafe.Pointer(codePtr)) = *(*int32)(unsafe.Pointer(bp)) & int32(0xff00) >> int32(8)
					}
					if msgObjPtr != 0 {
						*(*uintptr)(unsafe.Pointer(msgObjPtr)) = XTcl_ObjPrintf(tls, __ccgo_ts+64540, libc.VaList(bp+56, msg))
					}
					if errorObjPtr != 0 {
						(*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[0] = XTcl_NewStringObj(tls, __ccgo_ts+64560, int64(-int32(1)))
						if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
							cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
							(*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] = XTclThreadAllocObj(tls)
						} else {
							(*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] + 32))).Fptr1
							(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
						}
						(*TTcl_Obj)(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).FrefCount = 0
						(*TTcl_Obj)(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).Fbytes = libc.UintptrFromInt32(0)
						*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).FinternalRep)) = resolvedPid
						(*TTcl_Obj)(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
						(*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(2)] = XTcl_NewStringObj(tls, XTcl_SignalId(tls, *(*int32)(unsafe.Pointer(bp))&int32(0xff00)>>int32(8)), int64(-int32(1)))
						(*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(3)] = XTcl_NewStringObj(tls, msg, int64(-int32(1)))
						*(*uintptr)(unsafe.Pointer(errorObjPtr)) = XTcl_NewListObj(tls, int64(4), bp+8)
					}
					return int32(TCL_PROCESS_STOPPED)
				} else {
					/*
					 * TCL OPERATION EXEC ODDWAITRESULT
					 *
					 * Child wait status didn't make sense.
					 */
					if codePtr != 0 {
						*(*int32)(unsafe.Pointer(codePtr)) = *(*int32)(unsafe.Pointer(bp))
					}
					if msgObjPtr != 0 {
						*(*uintptr)(unsafe.Pointer(msgObjPtr)) = XTcl_NewStringObj(tls, __ccgo_ts+64570, int64(-int32(1)))
					}
					if errorObjPtr != 0 {
						(*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[0] = XTcl_NewStringObj(tls, __ccgo_ts+2004, int64(-int32(1)))
						(*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] = XTcl_NewStringObj(tls, __ccgo_ts+8210, int64(-int32(1)))
						(*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(2)] = XTcl_NewStringObj(tls, __ccgo_ts+56543, int64(-int32(1)))
						(*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(3)] = XTcl_NewStringObj(tls, __ccgo_ts+64607, int64(-int32(1)))
						if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
							cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v5 || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == libc.Uint64FromInt32(0) {
							(*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(4)] = XTclThreadAllocObj(tls)
						} else {
							(*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(4)] = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(4)] + 32))).Fptr1
							(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects--
						}
						(*TTcl_Obj)(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(4)])).FrefCount = 0
						(*TTcl_Obj)(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(4)])).Fbytes = libc.UintptrFromInt32(0)
						*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(4)])).FinternalRep)) = resolvedPid
						(*TTcl_Obj)(unsafe.Pointer((*(*[5]uintptr)(unsafe.Pointer(bp + 8)))[int32(4)])).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
						*(*uintptr)(unsafe.Pointer(errorObjPtr)) = XTcl_NewListObj(tls, int64(5), bp+8)
					}
					return int32(TCL_PROCESS_UNKNOWN_STATUS)
				}
			}
		}
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * BuildProcessStatusObj --
 *
 *	Build a list object with process status. The first element is always
 *	a standard Tcl return value, which can be either TCL_OK or TCL_ERROR.
 *	In the latter case, the second element is the error message and the
 *	third element is a Tcl error code (see tclvars).
 *
 * Results:
 *	A list object.
 *
 * Side effects:
 *	Tcl_Objs are created.
 *
 *----------------------------------------------------------------------
 */

func _BuildProcessStatusObj(tls *libc.TLS, info uintptr) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var cachePtr uintptr
	var v1 bool
	var _ /* resultObjs at bp+0 */ [3]uintptr
	_, _ = cachePtr, v1
	if (*TProcessInfo)(unsafe.Pointer(info)).Fstatus == int32(TCL_PROCESS_UNCHANGED) {
		/*
		 * Process still running, return empty obj.
		 */
		return XTcl_NewObj(tls)
	}
	if (*TProcessInfo)(unsafe.Pointer(info)).Fstatus == int32(TCL_PROCESS_EXITED) && (*TProcessInfo)(unsafe.Pointer(info)).Fcode == 0 {
		/*
		 * Normal exit, return TCL_OK.
		 */
		return XTcl_NewWideIntObj(tls, TCL_OK)
	}
	/*
	 * Abnormal exit, return {TCL_ERROR msg error}
	 */
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		(*(*[3]uintptr)(unsafe.Pointer(bp)))[0] = XTclThreadAllocObj(tls)
	} else {
		(*(*[3]uintptr)(unsafe.Pointer(bp)))[0] = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp)))[0] + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp)))[0])).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp)))[0])).Fbytes = libc.UintptrFromInt32(0)
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp)))[0])).FinternalRep)) = int64(libc.Int32FromInt32(TCL_ERROR))
	(*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp)))[0])).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	(*(*[3]uintptr)(unsafe.Pointer(bp)))[int32(1)] = (*TProcessInfo)(unsafe.Pointer(info)).Fmsg
	(*(*[3]uintptr)(unsafe.Pointer(bp)))[int32(2)] = (*TProcessInfo)(unsafe.Pointer(info)).Ferror1
	return XTcl_NewListObj(tls, int64(3), bp)
}

/*----------------------------------------------------------------------
 *
 * ProcessListObjCmd --
 *
 *	This function implements the 'tcl::process list' Tcl command.
 *	Refer to the user documentation for details on what it does.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	Access to the internal structures is protected by infoTablesMutex.
 *
 *----------------------------------------------------------------------
 */

func _ProcessListObjCmd(tls *libc.TLS, dummy421 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Argument objects. */
	var entry, info, list uintptr
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _ = entry, info, list
	if objc != int32(1) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, libc.UintptrFromInt32(0))
		return int32(TCL_ERROR)
	}
	/*
	 * Return the list of all chid process ids.
	 */
	list = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_infoTablesMutex)))
	entry = XTcl_FirstHashEntry(tls, uintptr(unsafe.Pointer(&_infoTablePerResolvedPid)), bp)
	for {
		if !(entry != libc.UintptrFromInt32(0)) {
			break
		}
		info = (*TTcl_HashEntry)(unsafe.Pointer(entry)).FclientData
		XTcl_ListObjAppendElement(tls, interp, list, XTcl_NewWideIntObj(tls, int64((*TProcessInfo)(unsafe.Pointer(info)).FresolvedPid)))
		goto _1
	_1:
		;
		entry = XTcl_NextHashEntry(tls, bp)
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_infoTablesMutex)))
	XTcl_SetObjResult(tls, interp, list)
	return TCL_OK
}

/*----------------------------------------------------------------------
 *
 * ProcessStatusObjCmd --
 *
 *	This function implements the 'tcl::process status' Tcl command.
 *	Refer to the user documentation for details on what it does.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	Access to the internal structures is protected by infoTablesMutex.
 *	Calls RefreshProcessInfo, which can block if -wait switch is given.
 *
 *----------------------------------------------------------------------
 */

func _ProcessStatusObjCmd(tls *libc.TLS, dummy472 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument objects. */
	var _objPtr, dict, entry, info, savedobjv, v1, v8 uintptr
	var i, v7 TTcl_Size
	var options, result, v3 int32
	var v4, v5 int64
	var _ /* index at bp+44 */ int32
	var _ /* numPids at bp+24 */ TTcl_Size
	var _ /* pid at bp+40 */ int32
	var _ /* pidObjs at bp+32 */ uintptr
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, dict, entry, i, info, options, result, savedobjv, v1, v3, v4, v5, v7, v8
	options = int32(WNOHANG)
	savedobjv = objv
	for objc > int32(1) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) != int32('-') {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), uintptr(unsafe.Pointer(&_switches2)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+64627, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+44) != TCL_OK {
			return int32(TCL_ERROR)
		}
		objv += 8
		objc--
		if 0 == *(*int32)(unsafe.Pointer(bp + 44)) {
			options = 0
		} else {
			break
		}
	}
	if objc != int32(1) && objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), savedobjv, __ccgo_ts+64636)
		return int32(TCL_ERROR)
	}
	if objc == int32(1) {
		/*
		* Return a dict with all child process statuses.
		 */
		dict = XTcl_NewDictObj(tls)
		XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_infoTablesMutex)))
		entry = XTcl_FirstHashEntry(tls, uintptr(unsafe.Pointer(&_infoTablePerResolvedPid)), bp)
		for {
			if !(entry != libc.UintptrFromInt32(0)) {
				break
			}
			info = (*TTcl_HashEntry)(unsafe.Pointer(entry)).FclientData
			_RefreshProcessInfo(tls, info, options)
			if (*TProcessInfo)(unsafe.Pointer(info)).Fpurge != 0 && _autopurge != 0 {
				/*
				 * Purge entry.
				 */
				XTcl_DeleteHashEntry(tls, entry)
				entry = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_infoTablePerPid)))).FfindProc})))(tls, uintptr(unsafe.Pointer(&_infoTablePerPid)), (*TProcessInfo)(unsafe.Pointer(info)).Fpid)
				XTcl_DeleteHashEntry(tls, entry)
				_FreeProcessInfo(tls, info)
			} else {
				/*
				 * Add to result.
				 */
				XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dict, XTcl_NewWideIntObj(tls, int64((*TProcessInfo)(unsafe.Pointer(info)).FresolvedPid)), _BuildProcessStatusObj(tls, info))
			}
			goto _2
		_2:
			;
			entry = XTcl_NextHashEntry(tls, bp)
		}
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_infoTablesMutex)))
	} else {
		/*
		 * Only return statuses of provided processes.
		 */
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
				v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanStart
			} else {
				v4 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 32)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1 + 40 + uintptr(v4)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
				v5 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanLength
			} else {
				v5 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = v5
			v3 = libc.Int32FromInt32(TCL_OK)
		} else {
			v3 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+24, bp+32)
		}
		result = v3
		if result != TCL_OK {
			return result
		}
		dict = XTcl_NewDictObj(tls)
		XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_infoTablesMutex)))
		i = 0
		for {
			if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 24))) {
				break
			}
			result = XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)) + uintptr(i)*8)), bp+40)
			if result != TCL_OK {
				XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_infoTablesMutex)))
				_objPtr = dict
				v8 = _objPtr
				v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
				*(*TTcl_Size)(unsafe.Pointer(v8))--
				if v7 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
				return result
			}
			entry = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_infoTablePerResolvedPid)))).FfindProc})))(tls, uintptr(unsafe.Pointer(&_infoTablePerResolvedPid)), uintptr(int64(*(*int32)(unsafe.Pointer(bp + 40)))))
			if !(entry != 0) {
				/*
				 * Skip unknown process.
				 */
				goto _6
			}
			info = (*TTcl_HashEntry)(unsafe.Pointer(entry)).FclientData
			_RefreshProcessInfo(tls, info, options)
			if (*TProcessInfo)(unsafe.Pointer(info)).Fpurge != 0 && _autopurge != 0 {
				/*
				 * Purge entry.
				 */
				XTcl_DeleteHashEntry(tls, entry)
				entry = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_infoTablePerPid)))).FfindProc})))(tls, uintptr(unsafe.Pointer(&_infoTablePerPid)), (*TProcessInfo)(unsafe.Pointer(info)).Fpid)
				XTcl_DeleteHashEntry(tls, entry)
				_FreeProcessInfo(tls, info)
			} else {
				/*
				 * Add to result.
				 */
				XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), dict, XTcl_NewWideIntObj(tls, int64((*TProcessInfo)(unsafe.Pointer(info)).FresolvedPid)), _BuildProcessStatusObj(tls, info))
			}
			goto _6
		_6:
			;
			i++
		}
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_infoTablesMutex)))
	}
	XTcl_SetObjResult(tls, interp, dict)
	return TCL_OK
}

var _switches2 = [3]uintptr{
	0: __ccgo_ts + 64621,
	1: __ccgo_ts + 18684,
	2: libc.UintptrFromInt32(0),
}

/*----------------------------------------------------------------------
 *
 * ProcessPurgeObjCmd --
 *
 *	This function implements the 'tcl::process purge' Tcl command.
 *	Refer to the user documentation for details on what it does.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	Frees all ProcessInfo structures with their purge flag set.
 *
 *----------------------------------------------------------------------
 */

func _ProcessPurgeObjCmd(tls *libc.TLS, dummy619 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument objects. */
	var entry, info uintptr
	var i TTcl_Size
	var result, v2 int32
	var v3, v4 int64
	var _ /* numPids at bp+24 */ TTcl_Size
	var _ /* pid at bp+40 */ int32
	var _ /* pidObjs at bp+32 */ uintptr
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _, _ = entry, i, info, result, v2, v3, v4
	if objc != int32(1) && objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+64654)
		return int32(TCL_ERROR)
	}
	/*
	 * First reap detached procs so that their purge flag is up-to-date.
	 */
	XTcl_ReapDetachedProcs(tls)
	if objc == int32(1) {
		/*
		 * Purge all terminated processes.
		 */
		XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_infoTablesMutex)))
		entry = XTcl_FirstHashEntry(tls, uintptr(unsafe.Pointer(&_infoTablePerResolvedPid)), bp)
		for {
			if !(entry != libc.UintptrFromInt32(0)) {
				break
			}
			info = (*TTcl_HashEntry)(unsafe.Pointer(entry)).FclientData
			if (*TProcessInfo)(unsafe.Pointer(info)).Fpurge != 0 {
				XTcl_DeleteHashEntry(tls, entry)
				entry = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_infoTablePerPid)))).FfindProc})))(tls, uintptr(unsafe.Pointer(&_infoTablePerPid)), (*TProcessInfo)(unsafe.Pointer(info)).Fpid)
				XTcl_DeleteHashEntry(tls, entry)
				_FreeProcessInfo(tls, info)
			}
			goto _1
		_1:
			;
			entry = XTcl_NextHashEntry(tls, bp)
		}
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_infoTablesMutex)))
	} else {
		/*
		 * Purge only provided processes.
		 */
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
				v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanStart
			} else {
				v3 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 32)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1 + 40 + uintptr(v3)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
				v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanLength
			} else {
				v4 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = v4
			v2 = libc.Int32FromInt32(TCL_OK)
		} else {
			v2 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+24, bp+32)
		}
		result = v2
		if result != TCL_OK {
			return result
		}
		XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_infoTablesMutex)))
		i = 0
		for {
			if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 24))) {
				break
			}
			result = XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)) + uintptr(i)*8)), bp+40)
			if result != TCL_OK {
				XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_infoTablesMutex)))
				return result
			}
			entry = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_infoTablePerResolvedPid)))).FfindProc})))(tls, uintptr(unsafe.Pointer(&_infoTablePerResolvedPid)), uintptr(int64(*(*int32)(unsafe.Pointer(bp + 40)))))
			if !(entry != 0) {
				/*
				 * Skip unknown process.
				 */
				goto _5
			}
			info = (*TTcl_HashEntry)(unsafe.Pointer(entry)).FclientData
			if (*TProcessInfo)(unsafe.Pointer(info)).Fpurge != 0 {
				XTcl_DeleteHashEntry(tls, entry)
				entry = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_infoTablePerPid)))).FfindProc})))(tls, uintptr(unsafe.Pointer(&_infoTablePerPid)), (*TProcessInfo)(unsafe.Pointer(info)).Fpid)
				XTcl_DeleteHashEntry(tls, entry)
				_FreeProcessInfo(tls, info)
			}
			goto _5
		_5:
			;
			i++
		}
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_infoTablesMutex)))
	}
	return TCL_OK
}

/*----------------------------------------------------------------------
 *
 * ProcessAutopurgeObjCmd --
 *
 *	This function implements the 'tcl::process autopurge' Tcl command.
 *	Refer to the user documentation for details on what it does.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	Alters detached process handling by Tcl_ReapDetachedProcs().
 *
 *----------------------------------------------------------------------
 */

func _ProcessAutopurgeObjCmd(tls *libc.TLS, dummy717 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var result int32
	var _ /* flag at bp+0 */ int32
	_ = result
	if objc != int32(1) && objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+64661)
		return int32(TCL_ERROR)
	}
	if objc == int32(2) {
		result = XTcl_GetBoolFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), (libc.Int32FromInt32(TCL_NULL_OK)-libc.Int32FromInt32(2))&libc.Int32FromInt64(4), bp)
		if result != TCL_OK {
			return result
		}
		_autopurge = libc.BoolInt32(!!(*(*int32)(unsafe.Pointer(bp)) != 0))
	}
	/*
	 * Return current value.
	 */
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(_autopurge != 0)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclInitProcessCmd --
 *
 *	This procedure creates the "tcl::process" Tcl command. See the user
 *	documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTclInitProcessCmd(tls *libc.TLS, interp uintptr) (r TTcl_Command) {
	/* Current interpreter. */
	var processCmd TTcl_Command
	_ = processCmd
	if _infoTablesInitialized == 0 {
		XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_infoTablesMutex)))
		if _infoTablesInitialized == 0 {
			XTcl_InitHashTable(tls, uintptr(unsafe.Pointer(&_infoTablePerPid)), int32(TCL_ONE_WORD_KEYS))
			XTcl_InitHashTable(tls, uintptr(unsafe.Pointer(&_infoTablePerResolvedPid)), int32(TCL_ONE_WORD_KEYS))
			_infoTablesInitialized = int32(1)
		}
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_infoTablesMutex)))
	}
	processCmd = XTclMakeEnsemble(tls, interp, __ccgo_ts+64668, uintptr(unsafe.Pointer(&_processImplMap)))
	XTcl_Export(tls, interp, XTcl_FindNamespace(tls, interp, __ccgo_ts+23915, libc.UintptrFromInt32(0), 0), __ccgo_ts+5903, 0)
	return processCmd
}

var _processImplMap = [5]TEnsembleImplMap{
	0: {
		Fname:   __ccgo_ts + 2860,
		Funsafe: int32(1),
	},
	1: {
		Fname:   __ccgo_ts + 5911,
		Funsafe: int32(1),
	},
	2: {
		Fname:   __ccgo_ts + 5918,
		Funsafe: int32(1),
	},
	3: {
		Fname:   __ccgo_ts + 5924,
		Funsafe: int32(1),
	},
	4: {},
}

func init() {
	p := unsafe.Pointer(&_processImplMap)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_ProcessListObjCmd)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(XTclCompileBasic0ArgCmd)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(_ProcessStatusObjCmd)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(XTclCompileBasicMin0ArgCmd)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(_ProcessPurgeObjCmd)
	*(*uintptr)(unsafe.Add(p, 112)) = __ccgo_fp(XTclCompileBasic0Or1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 152)) = __ccgo_fp(_ProcessAutopurgeObjCmd)
	*(*uintptr)(unsafe.Add(p, 160)) = __ccgo_fp(XTclCompileBasic0Or1ArgCmd)
}

/*
 *----------------------------------------------------------------------
 *
 * TclProcessCreated --
 *
 *	Called when a child process has been created by Tcl.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Internal structures are updated with a new ProcessInfo.
 *
 *----------------------------------------------------------------------
 */

func XTclProcessCreated(tls *libc.TLS, pid TTcl_Pid) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Process id. */
	var entry, entry2, info uintptr
	var resolvedPid TTcl_Size
	var _ /* isNew at bp+0 */ int32
	_, _, _, _ = entry, entry2, info, resolvedPid
	/*
	 * Get resolved pid first.
	 */
	resolvedPid = int64(pid)
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_infoTablesMutex)))
	/*
	 * Create entry in pid table.
	 */
	entry = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_infoTablePerPid)))).FcreateProc})))(tls, uintptr(unsafe.Pointer(&_infoTablePerPid)), pid, bp)
	if !(*(*int32)(unsafe.Pointer(bp)) != 0) {
		/*
		 * Pid was reused, free old info and reuse structure.
		 */
		info = (*TTcl_HashEntry)(unsafe.Pointer(entry)).FclientData
		entry2 = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_infoTablePerResolvedPid)))).FfindProc})))(tls, uintptr(unsafe.Pointer(&_infoTablePerResolvedPid)), uintptr(resolvedPid))
		if entry2 != 0 {
			XTcl_DeleteHashEntry(tls, entry2)
		}
		_FreeProcessInfo(tls, info)
	}
	/*
	 * Allocate and initialize info structure.
	 */
	info = XTcl_Alloc(tls, uint64(40))
	_InitProcessInfo(tls, info, pid, resolvedPid)
	/*
	 * Add entry to tables.
	 */
	(*TTcl_HashEntry)(unsafe.Pointer(entry)).FclientData = info
	entry = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_infoTablePerResolvedPid)))).FcreateProc})))(tls, uintptr(unsafe.Pointer(&_infoTablePerResolvedPid)), uintptr(resolvedPid), bp)
	(*TTcl_HashEntry)(unsafe.Pointer(entry)).FclientData = info
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_infoTablesMutex)))
}

/*
 *----------------------------------------------------------------------
 *
 * TclProcessWait --
 *
 *	Wait for process status to change.
 *
 * Results:
 *	TclProcessWaitStatus enum value.
 *
 * Side effects:
 *	Completed process info structures are purged immediately (autopurge on)
 *	or eventually (autopurge off).
 *
 *----------------------------------------------------------------------
 */

func XTclProcessWait(tls *libc.TLS, pid TTcl_Pid, options int32, codePtr uintptr, msgObjPtr uintptr, errorObjPtr uintptr) (r TTclProcessWaitStatus) {
	/* If non-NULL, will receive error code. */
	var entry, info uintptr
	var result TTclProcessWaitStatus
	_, _, _ = entry, info, result
	/*
	 * First search for pid in table.
	 */
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_infoTablesMutex)))
	entry = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_infoTablePerPid)))).FfindProc})))(tls, uintptr(unsafe.Pointer(&_infoTablePerPid)), pid)
	if !(entry != 0) {
		/*
		 * Unknown process, just call WaitProcessStatus and return.
		 */
		result = _WaitProcessStatus(tls, pid, int64(pid), options, codePtr, msgObjPtr, errorObjPtr)
		if msgObjPtr != 0 && *(*uintptr)(unsafe.Pointer(msgObjPtr)) != 0 {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(msgObjPtr)))).FrefCount++
		}
		if errorObjPtr != 0 && *(*uintptr)(unsafe.Pointer(errorObjPtr)) != 0 {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(errorObjPtr)))).FrefCount++
		}
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_infoTablesMutex)))
		return result
	}
	info = (*TTcl_HashEntry)(unsafe.Pointer(entry)).FclientData
	if (*TProcessInfo)(unsafe.Pointer(info)).Fpurge != 0 {
		/*
		 * Process has completed but TclProcessWait has already been called,
		 * so report no change.
		 */
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_infoTablesMutex)))
		return int32(TCL_PROCESS_UNCHANGED)
	}
	_RefreshProcessInfo(tls, info, options)
	if (*TProcessInfo)(unsafe.Pointer(info)).Fstatus == int32(TCL_PROCESS_UNCHANGED) {
		/*
		 * No change, stop there.
		 */
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_infoTablesMutex)))
		return int32(TCL_PROCESS_UNCHANGED)
	}
	/*
	 * Set return values.
	 */
	result = (*TProcessInfo)(unsafe.Pointer(info)).Fstatus
	if codePtr != 0 {
		*(*int32)(unsafe.Pointer(codePtr)) = (*TProcessInfo)(unsafe.Pointer(info)).Fcode
	}
	if msgObjPtr != 0 {
		*(*uintptr)(unsafe.Pointer(msgObjPtr)) = (*TProcessInfo)(unsafe.Pointer(info)).Fmsg
	}
	if errorObjPtr != 0 {
		*(*uintptr)(unsafe.Pointer(errorObjPtr)) = (*TProcessInfo)(unsafe.Pointer(info)).Ferror1
	}
	if msgObjPtr != 0 && *(*uintptr)(unsafe.Pointer(msgObjPtr)) != 0 {
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(msgObjPtr)))).FrefCount++
	}
	if errorObjPtr != 0 && *(*uintptr)(unsafe.Pointer(errorObjPtr)) != 0 {
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(errorObjPtr)))).FrefCount++
	}
	if _autopurge != 0 {
		/*
		 * Purge now.
		 */
		XTcl_DeleteHashEntry(tls, entry)
		entry = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_infoTablePerResolvedPid)))).FfindProc})))(tls, uintptr(unsafe.Pointer(&_infoTablePerResolvedPid)), uintptr(int64((*TProcessInfo)(unsafe.Pointer(info)).FresolvedPid)))
		XTcl_DeleteHashEntry(tls, entry)
		_FreeProcessInfo(tls, info)
	} else {
		/*
		 * Eventually purge. Subsequent calls will return
		 * TCL_PROCESS_UNCHANGED.
		 */
		(*TProcessInfo)(unsafe.Pointer(info)).Fpurge = int32(1)
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_infoTablesMutex)))
	return result
}

const NUM_REGEXPS = 30
const TCL_REG_GLOBOK_FLAGS = 27

/*
 *----------------------------------------------------------------------
 * The routines in this file use Henry Spencer's regular expression package
 * contained in the following additional source files:
 *
 *	regc_color.c	regc_cvec.c	regc_lex.c
 *	regc_nfa.c	regcomp.c	regcustom.h
 *	rege_dfa.c	regerror.c	regerrs.h
 *	regex.h		regexec.c	regfree.c
 *	regfronts.c	regguts.h
 *
 * Copyright © 1998 Henry Spencer.  All rights reserved.
 *
 * Development of this software was funded, in part, by Cray Research Inc.,
 * UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
 * Corporation, none of whom are responsible for the results. The author
 * thanks all of them.
 *
 * Redistribution and use in source and binary forms -- with or without
 * modification -- are permitted for any purpose, provided that
 * redistributions in source form retain this entire copyright notice and
 * indicate the origin and nature of any modifications.
 *
 * I'd appreciate being given credit for this package in the documentation of
 * software which uses it, but that is not a requirement.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
 * HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * *** NOTE: this code has been altered slightly for use in Tcl: ***
 * *** 1. Names have been changed, e.g. from re_comp to		 ***
 * ***    TclRegComp, to avoid clashes with other		 ***
 * ***    regexp implementations used by applications.		 ***
 */

/*
 * Thread local storage used to maintain a per-thread cache of compiled
 * regular expressions.
 */

type TThreadSpecificData12 = struct {
	Finitialized int32
	Fpatterns    [30]uintptr
	FpatLengths  [30]Tsize_t
	Fregexps     [30]uintptr
}

var _dataKey10 TTcl_ThreadDataKey

func init() {
	p := unsafe.Pointer(&XtclRegexpType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_FreeRegexpInternalRep)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_DupRegexpInternalRep)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_SetRegexpFromAny)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_RegExpCompile --
 *
 *	Compile a regular expression into a form suitable for fast matching.
 *	This function is DEPRECATED in favor of the object version of the
 *	command.
 *
 * Results:
 *	The return value is a pointer to the compiled form of string, suitable
 *	for passing to Tcl_RegExpExec. This compiled form is only valid up
 *	until the next call to this function, so don't keep these around for a
 *	long time! If an error occurred while compiling the pattern, then NULL
 *	is returned and an error message is left in the interp's result.
 *
 * Side effects:
 *	Updates the cache of compiled regexps.
 *
 *----------------------------------------------------------------------
 */

func XTcl_RegExpCompile(tls *libc.TLS, interp uintptr, pattern uintptr) (r TTcl_RegExp) {
	/* String for which to produce compiled
	 * regular expression. */
	return _CompileRegexp(tls, interp, pattern, libc.Xstrlen(tls, pattern), int32(REG_ADVANCED))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_RegExpExec --
 *
 *	Execute the regular expression matcher using a compiled form of a
 *	regular expression and save information about any match that is found.
 *
 * Results:
 *	If an error occurs during the matching operation then -1 is returned
 *	and the interp's result contains an error message. Otherwise the
 *	return value is 1 if a matching range is found and 0 if there is no
 *	matching range.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_RegExpExec(tls *libc.TLS, interp uintptr, re TTcl_RegExp, text uintptr, start uintptr) (r int32) {
	bp := tls.Alloc(224)
	defer tls.Free(224) /* If text is part of a larger string, this
	 * identifies beginning of larger string, so
	 * that "^" won't match. */
	var flags, result int32
	var numChars Tsize_t
	var regexp, ustr uintptr
	var _ /* ds at bp+0 */ TTcl_DString
	_, _, _, _, _ = flags, numChars, regexp, result, ustr
	regexp = re
	/*
	 * If the starting point is offset from the beginning of the buffer, then
	 * we need to tell the regexp engine not to match "^".
	 */
	if text > start {
		flags = int32(REG_NOTBOL)
	} else {
		flags = 0
	}
	/*
	 * Remember the string for use by Tcl_RegExpRange().
	 */
	(*TTclRegexp)(unsafe.Pointer(regexp)).Fstring1 = text
	(*TTclRegexp)(unsafe.Pointer(regexp)).FobjPtr = libc.UintptrFromInt32(0)
	/*
	 * Convert the string to Unicode and perform the match.
	 */
	XTcl_DStringInit(tls, bp)
	ustr = XTcl_UtfToUniCharDString(tls, text, int64(-libc.Int32FromInt32(1)), bp)
	numChars = libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(bp)).Flength) / uint64(4)
	result = _RegExpExecUniChar(tls, interp, re, ustr, numChars, libc.Uint64FromInt64(int64(-libc.Int32FromInt32(1))), flags)
	XTcl_DStringFree(tls, bp)
	return result
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_RegExpRange --
 *
 *	Returns pointers describing the range of a regular expression match,
 *	or one of the subranges within the match.
 *
 * Results:
 *	The variables at *startPtr and *endPtr are modified to hold the
 *	addresses of the endpoints of the range given by index. If the
 *	specified range doesn't exist then NULLs are returned.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_RegExpRange(tls *libc.TLS, re TTcl_RegExp, index TTcl_Size, startPtr uintptr, endPtr uintptr) {
	/* Store address of character just after last
	 * in (sub-)range here. */
	var regexpPtr, string1, v1, v2, v3 uintptr
	_, _, _, _, _ = regexpPtr, string1, v1, v2, v3
	regexpPtr = re
	if index < 0 || libc.Uint64FromInt64(index) > (*TTclRegexp)(unsafe.Pointer(regexpPtr)).Fre.Fre_nsub {
		v1 = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(endPtr)) = v1
		*(*uintptr)(unsafe.Pointer(startPtr)) = v1
	} else {
		if (*(*Tregmatch_t)(unsafe.Pointer((*TTclRegexp)(unsafe.Pointer(regexpPtr)).Fmatches + uintptr(index)*16))).Frm_so == libc.Uint64FromInt32(-libc.Int32FromInt32(1)) {
			v2 = libc.UintptrFromInt32(0)
			*(*uintptr)(unsafe.Pointer(endPtr)) = v2
			*(*uintptr)(unsafe.Pointer(startPtr)) = v2
		} else {
			if (*TTclRegexp)(unsafe.Pointer(regexpPtr)).FobjPtr != 0 {
				if (*TTcl_Obj)(unsafe.Pointer((*TTclRegexp)(unsafe.Pointer(regexpPtr)).FobjPtr)).Fbytes != 0 {
					v3 = (*TTcl_Obj)(unsafe.Pointer((*TTclRegexp)(unsafe.Pointer(regexpPtr)).FobjPtr)).Fbytes
				} else {
					v3 = XTcl_GetStringFromObj(tls, (*TTclRegexp)(unsafe.Pointer(regexpPtr)).FobjPtr, libc.UintptrFromInt32(0))
				}
				string1 = v3
			} else {
				string1 = (*TTclRegexp)(unsafe.Pointer(regexpPtr)).Fstring1
			}
			*(*uintptr)(unsafe.Pointer(startPtr)) = XTcl_UtfAtIndex(tls, string1, libc.Int64FromUint64((*(*Tregmatch_t)(unsafe.Pointer((*TTclRegexp)(unsafe.Pointer(regexpPtr)).Fmatches + uintptr(index)*16))).Frm_so))
			*(*uintptr)(unsafe.Pointer(endPtr)) = XTcl_UtfAtIndex(tls, string1, libc.Int64FromUint64((*(*Tregmatch_t)(unsafe.Pointer((*TTclRegexp)(unsafe.Pointer(regexpPtr)).Fmatches + uintptr(index)*16))).Frm_eo))
		}
	}
}

/*
 *---------------------------------------------------------------------------
 *
 * RegExpExecUniChar --
 *
 *	Execute the regular expression matcher using a compiled form of a
 *	regular expression and save information about any match that is found.
 *
 * Results:
 *	If an error occurs during the matching operation then -1 is returned
 *	and an error message is left in interp's result. Otherwise the return
 *	value is 1 if a matching range was found or 0 if there was no matching
 *	range.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _RegExpExecUniChar(tls *libc.TLS, interp uintptr, re TTcl_RegExp, wString uintptr, numChars Tsize_t, nm Tsize_t, flags int32) (r int32) {
	/* Regular expression flags. */
	var last Tsize_t
	var regexpPtr uintptr
	var status int32
	_, _, _ = last, regexpPtr, status
	regexpPtr = re
	last = (*TTclRegexp)(unsafe.Pointer(regexpPtr)).Fre.Fre_nsub + uint64(1)
	if nm >= last {
		nm = last
	}
	status = XTclReExec(tls, regexpPtr+8, wString, numChars, regexpPtr+88, nm, (*TTclRegexp)(unsafe.Pointer(regexpPtr)).Fmatches, flags)
	/*
	 * Check for errors.
	 */
	if status != REG_OKAY {
		if status == int32(REG_NOMATCH) {
			return 0
		}
		if interp != libc.UintptrFromInt32(0) {
			XTclRegError(tls, interp, __ccgo_ts+64683, status)
		}
		return -int32(1)
	}
	return int32(1)
}

/*
 *---------------------------------------------------------------------------
 *
 * TclRegExpRangeUniChar --
 *
 *	Returns pointers describing the range of a regular expression match,
 *	or one of the subranges within the match, or the hypothetical range
 *	represented by the rm_extend field of the rm_detail_t.
 *
 * Results:
 *	The variables at *startPtr and *endPtr are modified to hold the
 *	offsets of the endpoints of the range given by index. If the specified
 *	range doesn't exist then -1s are supplied.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTclRegExpRangeUniChar(tls *libc.TLS, re TTcl_RegExp, index TTcl_Size, startPtr uintptr, endPtr uintptr) {
	/* Store address of character just after last
	 * in (sub-)range here. */
	var regexpPtr uintptr
	_ = regexpPtr
	regexpPtr = re
	if (*TTclRegexp)(unsafe.Pointer(regexpPtr)).Fflags&int32(REG_EXPECT) != 0 && index == int64(-int32(1)) {
		*(*TTcl_Size)(unsafe.Pointer(startPtr)) = libc.Int64FromUint64((*TTclRegexp)(unsafe.Pointer(regexpPtr)).Fdetails.Frm_extend.Frm_so)
		*(*TTcl_Size)(unsafe.Pointer(endPtr)) = libc.Int64FromUint64((*TTclRegexp)(unsafe.Pointer(regexpPtr)).Fdetails.Frm_extend.Frm_eo)
	} else {
		if index < 0 || libc.Uint64FromInt64(index) > (*TTclRegexp)(unsafe.Pointer(regexpPtr)).Fre.Fre_nsub+uint64(1) {
			*(*TTcl_Size)(unsafe.Pointer(startPtr)) = int64(-int32(1))
			*(*TTcl_Size)(unsafe.Pointer(endPtr)) = int64(-int32(1))
		} else {
			*(*TTcl_Size)(unsafe.Pointer(startPtr)) = libc.Int64FromUint64((*(*Tregmatch_t)(unsafe.Pointer((*TTclRegexp)(unsafe.Pointer(regexpPtr)).Fmatches + uintptr(index)*16))).Frm_so)
			*(*TTcl_Size)(unsafe.Pointer(endPtr)) = libc.Int64FromUint64((*(*Tregmatch_t)(unsafe.Pointer((*TTclRegexp)(unsafe.Pointer(regexpPtr)).Fmatches + uintptr(index)*16))).Frm_eo)
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_RegExpMatch --
 *
 *	See if a string matches a regular expression.
 *
 * Results:
 *	If an error occurs during the matching operation then -1 is returned
 *	and the interp's result contains an error message. Otherwise the
 *	return value is 1 if "text" matches "pattern" and 0 otherwise.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_RegExpMatch(tls *libc.TLS, interp uintptr, text uintptr, pattern uintptr) (r int32) {
	/* Regular expression to match against text. */
	var re TTcl_RegExp
	_ = re
	re = XTcl_RegExpCompile(tls, interp, pattern)
	if re == libc.UintptrFromInt32(0) {
		return -int32(1)
	}
	return XTcl_RegExpExec(tls, interp, re, text, text)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_RegExpExecObj --
 *
 *	Execute a precompiled regexp against the given object.
 *
 * Results:
 *	If an error occurs during the matching operation then -1 is returned
 *	and the interp's result contains an error message. Otherwise the
 *	return value is 1 if "string" matches "pattern" and 0 otherwise.
 *
 * Side effects:
 *	Converts the object to a Unicode object.
 *
 *----------------------------------------------------------------------
 */

func XTcl_RegExpExecObj(tls *libc.TLS, interp uintptr, re TTcl_RegExp, textObj uintptr, offset TTcl_Size, nmatches TTcl_Size, flags int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Regular expression execution flags. */
	var nocase, reflags, v1 int32
	var regexpPtr, udata uintptr
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _, _ = nocase, reflags, regexpPtr, udata, v1
	regexpPtr = re
	reflags = (*TTclRegexp)(unsafe.Pointer(regexpPtr)).Fflags
	/*
	 * Take advantage of the equivalent glob pattern, if one exists.
	 * This is possible based only on the right mix of incoming flags (0)
	 * and regexp compile flags.
	 */
	if offset == 0 && nmatches == 0 && flags == 0 && !(reflags & ^(libc.Int32FromInt32(TCL_REG_ADVANCED)|libc.Int32FromInt32(TCL_REG_NOSUB)|libc.Int32FromInt32(TCL_REG_NOCASE)) != 0) && (*TTclRegexp)(unsafe.Pointer(regexpPtr)).FglobObjPtr != libc.UintptrFromInt32(0) {
		if reflags&int32(TCL_REG_NOCASE) != 0 {
			v1 = libc.Int32FromInt32(1) << libc.Int32FromInt32(0)
		} else {
			v1 = 0
		}
		nocase = v1
		/*
		 * Pass to TclStringMatchObj for obj-specific handling.
		 * XXX: Currently doesn't take advantage of exact-ness that
		 * XXX: TclReToGlob tells us about
		 */
		return XTclStringMatchObj(tls, textObj, (*TTclRegexp)(unsafe.Pointer(regexpPtr)).FglobObjPtr, nocase)
	}
	/*
	 * Save the target object so we can extract strings from it later.
	 */
	(*TTclRegexp)(unsafe.Pointer(regexpPtr)).Fstring1 = libc.UintptrFromInt32(0)
	(*TTclRegexp)(unsafe.Pointer(regexpPtr)).FobjPtr = textObj
	udata = XTcl_GetUnicodeFromObj(tls, textObj, bp)
	if offset > *(*TTcl_Size)(unsafe.Pointer(bp)) {
		offset = *(*TTcl_Size)(unsafe.Pointer(bp))
	}
	udata += uintptr(offset) * 4
	*(*TTcl_Size)(unsafe.Pointer(bp)) -= offset
	return _RegExpExecUniChar(tls, interp, re, udata, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))), libc.Uint64FromInt64(nmatches), flags)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_RegExpMatchObj --
 *
 *	See if an object matches a regular expression.
 *
 * Results:
 *	If an error occurs during the matching operation then -1 is returned
 *	and the interp's result contains an error message. Otherwise the
 *	return value is 1 if "text" matches "pattern" and 0 otherwise.
 *
 * Side effects:
 *	Changes the internal rep of the pattern and string objects.
 *
 *----------------------------------------------------------------------
 */

func XTcl_RegExpMatchObj(tls *libc.TLS, interp uintptr, textObj uintptr, patternObj uintptr) (r int32) {
	/* Regular expression to match against
	 * string. */
	var re, v1, v2 TTcl_RegExp
	var v3 bool
	_, _, _, _ = re, v1, v2, v3
	/*
	 * For performance reasons, first try compiling the RE without support for
	 * subexpressions. On failure, try again without TCL_REG_NOSUB in case the
	 * RE has backreferences in it. Closely related to [Bug 1366683]. If this
	 * still fails, an error message will be left in the interpreter.
	 */
	v1 = XTcl_GetRegExpFromObj(tls, interp, patternObj, libc.Int32FromInt32(TCL_REG_ADVANCED)|libc.Int32FromInt32(TCL_REG_NOSUB))
	re = v1
	if v3 = !(v1 != 0); v3 {
		v2 = XTcl_GetRegExpFromObj(tls, interp, patternObj, int32(TCL_REG_ADVANCED))
		re = v2
	}
	if v3 && !(v2 != 0) {
		return -int32(1)
	}
	return XTcl_RegExpExecObj(tls, interp, re, textObj, 0, 0, 0)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_RegExpGetInfo --
 *
 *	Retrieve information about the current match.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_RegExpGetInfo(tls *libc.TLS, regexp TTcl_RegExp, infoPtr uintptr) {
	/* Match information is stored here. */
	var regexpPtr uintptr
	_ = regexpPtr
	regexpPtr = regexp
	(*TTcl_RegExpInfo)(unsafe.Pointer(infoPtr)).Fnsubs = libc.Int64FromUint64((*TTclRegexp)(unsafe.Pointer(regexpPtr)).Fre.Fre_nsub)
	(*TTcl_RegExpInfo)(unsafe.Pointer(infoPtr)).Fmatches = (*TTclRegexp)(unsafe.Pointer(regexpPtr)).Fmatches
	(*TTcl_RegExpInfo)(unsafe.Pointer(infoPtr)).FextendStart = libc.Int64FromUint64((*TTclRegexp)(unsafe.Pointer(regexpPtr)).Fdetails.Frm_extend.Frm_so)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetRegExpFromObj --
 *
 *	Compile a regular expression into a form suitable for fast matching.
 *	This function caches the result in a Tcl_Obj.
 *
 * Results:
 *	The return value is a pointer to the compiled form of string, suitable
 *	for passing to Tcl_RegExpExec. If an error occurred while compiling
 *	the pattern, then NULL is returned and an error message is left in the
 *	interp's result.
 *
 * Side effects:
 *	Updates the native rep of the Tcl_Obj.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetRegExpFromObj(tls *libc.TLS, interp uintptr, objPtr uintptr, flags int32) (r TTcl_RegExp) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Regular expression compilation flags. */
	var irPtr, pattern, regexpPtr, v1, v2, v3 uintptr
	var _ /* ir at bp+8 */ TTcl_ObjInternalRep
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _, _, _ = irPtr, pattern, regexpPtr, v1, v2, v3
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclRegexpType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	regexpPtr = v2
	if regexpPtr == libc.UintptrFromInt32(0) || (*TTclRegexp)(unsafe.Pointer(regexpPtr)).Fflags != flags {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
			v3 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, objPtr, bp)
		}
		pattern = v3
		regexpPtr = _CompileRegexp(tls, interp, pattern, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))), flags)
		if regexpPtr == libc.UintptrFromInt32(0) {
			return libc.UintptrFromInt32(0)
		}
		(*TTclRegexp)(unsafe.Pointer(regexpPtr)).FrefCount++
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(bp + 8))).Fptr1 = regexpPtr
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(bp + 8))).Fptr2 = libc.UintptrFromInt32(0)
		XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&XtclRegexpType)), bp+8)
	}
	return regexpPtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclRegAbout --
 *
 *	Return information about a compiled regular expression.
 *
 * Results:
 *	The return value is -1 for failure, 0 for success, although at the
 *	moment there's nothing that could fail. On success, a list is left in
 *	the interp's result: first element is the subexpression count, second
 *	is a list of re_info bit names.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclRegAbout(tls *libc.TLS, interp uintptr, re TTcl_RegExp) (r int32) {
	/* The compiled regular expression. */
	var cachePtr, cachePtr1, cachePtr2, inf, infoObj, regexpPtr, resultObj uintptr
	var v1, v2, v3 bool
	_, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, inf, infoObj, regexpPtr, resultObj, v1, v2, v3
	regexpPtr = re
	/*
	 * The reset here guarantees that the interpreter result is empty and
	 * unshared. This means that we can use Tcl_ListObjAppendElement on the
	 * result object quite safely.
	 */
	XTcl_ResetResult(tls, interp)
	/*
	 * Assume that there will never be more than INT_MAX subexpressions. This
	 * is a pretty reasonable assumption; the RE engine doesn't scale _that_
	 * well and Tcl has other limits that constrain things as well...
	 */
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		infoObj = XTclThreadAllocObj(tls)
	} else {
		infoObj = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(infoObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(infoObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(infoObj)).Fbytes = libc.UintptrFromInt32(0)
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(infoObj)).FinternalRep)) = libc.Int64FromUint64((*TTclRegexp)(unsafe.Pointer(regexpPtr)).Fre.Fre_nsub)
	(*TTcl_Obj)(unsafe.Pointer(infoObj)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, infoObj)
	/*
	 * Now append a list of all the bit-flags set for the RE.
	 */
	if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
		cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
		infoObj = XTclThreadAllocObj(tls)
	} else {
		infoObj = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(infoObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(infoObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(infoObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(infoObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(infoObj)).FtypePtr = libc.UintptrFromInt32(0)
	inf = uintptr(unsafe.Pointer(&_infonames))
	for {
		if !((*struct {
			Fbit  int32
			Ftext uintptr
		})(unsafe.Pointer(inf)).Fbit != 0) {
			break
		}
		if (*TTclRegexp)(unsafe.Pointer(regexpPtr)).Fre.Fre_info&int64((*struct {
			Fbit  int32
			Ftext uintptr
		})(unsafe.Pointer(inf)).Fbit) != 0 {
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), infoObj, XTcl_NewStringObj(tls, (*struct {
				Fbit  int32
				Ftext uintptr
			})(unsafe.Pointer(inf)).Ftext, int64(-int32(1))))
		}
		goto _4
	_4:
		;
		inf += 16
	}
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, infoObj)
	XTcl_SetObjResult(tls, interp, resultObj)
	return 0
}

var _infonames = [15]struct {
	Fbit  int32
	Ftext uintptr
}{
	0: {
		Fbit:  int32(REG_UBACKREF),
		Ftext: __ccgo_ts + 64725,
	},
	1: {
		Fbit:  int32(REG_ULOOKAHEAD),
		Ftext: __ccgo_ts + 64738,
	},
	2: {
		Fbit:  int32(REG_UBOUNDS),
		Ftext: __ccgo_ts + 64753,
	},
	3: {
		Fbit:  int32(REG_UBRACES),
		Ftext: __ccgo_ts + 64765,
	},
	4: {
		Fbit:  int32(REG_UBSALNUM),
		Ftext: __ccgo_ts + 64777,
	},
	5: {
		Fbit:  int32(REG_UPBOTCH),
		Ftext: __ccgo_ts + 64790,
	},
	6: {
		Fbit:  int32(REG_UBBS),
		Ftext: __ccgo_ts + 64802,
	},
	7: {
		Fbit:  int32(REG_UNONPOSIX),
		Ftext: __ccgo_ts + 64811,
	},
	8: {
		Fbit:  int32(REG_UUNSPEC),
		Ftext: __ccgo_ts + 64825,
	},
	9: {
		Fbit:  int32(REG_UUNPORT),
		Ftext: __ccgo_ts + 64837,
	},
	10: {
		Fbit:  int32(REG_ULOCALE),
		Ftext: __ccgo_ts + 64849,
	},
	11: {
		Fbit:  int32(REG_UEMPTYMATCH),
		Ftext: __ccgo_ts + 64861,
	},
	12: {
		Fbit:  int32(REG_UIMPOSSIBLE),
		Ftext: __ccgo_ts + 64877,
	},
	13: {
		Fbit:  int32(REG_USHORTEST),
		Ftext: __ccgo_ts + 64893,
	},
	14: {},
}

/*
 *----------------------------------------------------------------------
 *
 * TclRegError --
 *
 *	Generate an error message based on the regexp status code.
 *
 * Results:
 *	Places an error in the interpreter.
 *
 * Side effects:
 *	Sets errorCode as well.
 *
 *----------------------------------------------------------------------
 */

func XTclRegError(tls *libc.TLS, interp uintptr, msg uintptr, status int32) {
	bp := tls.Alloc(176)
	defer tls.Free(176) /* Status code to report. */
	var n Tsize_t
	var p, v1 uintptr
	var _ /* buf at bp+0 */ [100]uint8
	var _ /* cbuf at bp+100 */ [24]uint8
	_, _, _ = n, p, v1
	XTcl_ResetResult(tls, interp)
	n = XTclReError(tls, status, bp, uint64(100))
	if n > uint64(100) {
		v1 = __ccgo_ts + 8560
	} else {
		v1 = __ccgo_ts + 1945
	}
	p = v1
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+64907, libc.VaList(bp+136, msg, bp, p)))
	libc.X__builtin_snprintf(tls, bp+100, uint64(24), __ccgo_ts+260, libc.VaList(bp+136, status))
	XTclReError(tls, int32(REG_ITOA), bp+100, uint64(24))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+136, __ccgo_ts+18795, bp+100, bp, libc.UintptrFromInt32(0)))
}

/*
 *----------------------------------------------------------------------
 *
 * FreeRegexpInternalRep --
 *
 *	Deallocate the storage associated with a regexp object's internal
 *	representation.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Frees the compiled regular expression.
 *
 *----------------------------------------------------------------------
 */

func _FreeRegexpInternalRep(tls *libc.TLS, objPtr uintptr) {
	/* Regexp object with internal rep to free. */
	var irPtr, regexpRepPtr, v1, v2, v4 uintptr
	var v3 TTcl_Size
	_, _, _, _, _, _ = irPtr, regexpRepPtr, v1, v2, v3, v4
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclRegexpType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	regexpRepPtr = v2
	/*
	 * If this is the last reference to the regexp, free it.
	 */
	v4 = regexpRepPtr + 104
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	if v3 <= int64(1) {
		_FreeRegexp(tls, regexpRepPtr)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * DupRegexpInternalRep --
 *
 *	We copy the reference to the compiled regexp and bump its reference
 *	count.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Increments the reference count of the regexp.
 *
 *----------------------------------------------------------------------
 */

func _DupRegexpInternalRep(tls *libc.TLS, srcPtr uintptr, copyPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Object with internal rep to set. */
	var irPtr, regexpPtr, v1, v2 uintptr
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_, _, _, _ = irPtr, regexpPtr, v1, v2
	if (*TTcl_Obj)(unsafe.Pointer(srcPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclRegexpType)) {
		v1 = srcPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	regexpPtr = v2
	(*TTclRegexp)(unsafe.Pointer(regexpPtr)).FrefCount++
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr1 = regexpPtr
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr2 = libc.UintptrFromInt32(0)
	XTcl_StoreInternalRep(tls, copyPtr, uintptr(unsafe.Pointer(&XtclRegexpType)), bp)
}

/*
 *----------------------------------------------------------------------
 *
 * SetRegexpFromAny --
 *
 *	Attempt to generate a compiled regular expression for the Tcl object
 *	"objPtr".
 *
 * Results:
 *	The return value is TCL_OK or TCL_ERROR. If an error occurs during
 *	conversion, an error message is left in the interpreter's result
 *	unless "interp" is NULL.
 *
 * Side effects:
 *	If no error occurs, a regular expression is stored as "objPtr"s
 *	internal representation.
 *
 *----------------------------------------------------------------------
 */

func _SetRegexpFromAny(tls *libc.TLS, interp uintptr, objPtr uintptr) (r int32) {
	/* The object to convert. */
	if XTcl_GetRegExpFromObj(tls, interp, objPtr, int32(REG_ADVANCED)) == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *---------------------------------------------------------------------------
 *
 * CompileRegexp --
 *
 *	Attempt to compile the given regexp pattern. If the compiled regular
 *	expression can be found in the per-thread cache, it will be used
 *	instead of compiling a new copy.
 *
 * Results:
 *	The return value is a pointer to a newly allocated TclRegexp that
 *	represents the compiled pattern, or NULL if the pattern could not be
 *	compiled. If NULL is returned, an error message is left in the
 *	interp's result.
 *
 * Side effects:
 *	The thread-local regexp cache is updated and a new TclRegexp may be
 *	allocated.
 *
 *----------------------------------------------------------------------
 */

func _CompileRegexp(tls *libc.TLS, interp uintptr, string1 uintptr, length Tsize_t, flags int32) (r uintptr) {
	bp := tls.Alloc(240)
	defer tls.Free(240) /* Compilation flags. */
	var cachedString, oldRegexpPtr, regexpPtr, tsdPtr, uniString, v4 uintptr
	var i, j, numChars, status int32
	var v3 TTcl_Size
	var _ /* exact at bp+0 */ int32
	var _ /* stringBuf at bp+8 */ TTcl_DString
	_, _, _, _, _, _, _, _, _, _, _ = cachedString, i, j, numChars, oldRegexpPtr, regexpPtr, status, tsdPtr, uniString, v3, v4
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey10)), int64(728))
	if !((*TThreadSpecificData12)(unsafe.Pointer(tsdPtr)).Finitialized != 0) {
		(*TThreadSpecificData12)(unsafe.Pointer(tsdPtr)).Finitialized = int32(1)
		XTcl_CreateThreadExitHandler(tls, __ccgo_fp(_FinalizeRegexp), libc.UintptrFromInt32(0))
	}
	/*
	 * This routine maintains a second-level regular expression cache in
	 * addition to the per-object regexp cache. The per-thread cache is needed
	 * to handle the case where for various reasons the object is lost between
	 * invocations of the regexp command, but the literal pattern is the same.
	 */
	/*
	 * Check the per-thread compiled regexp cache. We can only reuse a regexp
	 * if it has the same pattern and the same flags.
	 */
	i = 0
	for {
		if !(i < int32(NUM_REGEXPS) && *(*uintptr)(unsafe.Pointer(tsdPtr + 8 + uintptr(i)*8)) != libc.UintptrFromInt32(0)) {
			break
		}
		if length == *(*Tsize_t)(unsafe.Pointer(tsdPtr + 248 + uintptr(i)*8)) && (*TTclRegexp1)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tsdPtr + 488 + uintptr(i)*8)))).Fflags == flags && libc.Xstrcmp(tls, string1, *(*uintptr)(unsafe.Pointer(tsdPtr + 8 + uintptr(i)*8))) == 0 {
			/*
			 * Move the matched pattern to the first slot in the cache and
			 * shift the other patterns down one position.
			 */
			if i != 0 {
				cachedString = *(*uintptr)(unsafe.Pointer(tsdPtr + 8 + uintptr(i)*8))
				regexpPtr = *(*uintptr)(unsafe.Pointer(tsdPtr + 488 + uintptr(i)*8))
				j = i - int32(1)
				for {
					if !(j >= 0) {
						break
					}
					*(*uintptr)(unsafe.Pointer(tsdPtr + 8 + uintptr(j+int32(1))*8)) = *(*uintptr)(unsafe.Pointer(tsdPtr + 8 + uintptr(j)*8))
					*(*Tsize_t)(unsafe.Pointer(tsdPtr + 248 + uintptr(j+int32(1))*8)) = *(*Tsize_t)(unsafe.Pointer(tsdPtr + 248 + uintptr(j)*8))
					*(*uintptr)(unsafe.Pointer(tsdPtr + 488 + uintptr(j+int32(1))*8)) = *(*uintptr)(unsafe.Pointer(tsdPtr + 488 + uintptr(j)*8))
					goto _2
				_2:
					;
					j--
				}
				*(*uintptr)(unsafe.Pointer(tsdPtr + 8)) = cachedString
				*(*Tsize_t)(unsafe.Pointer(tsdPtr + 248)) = length
				*(*uintptr)(unsafe.Pointer(tsdPtr + 488)) = regexpPtr
			}
			return *(*uintptr)(unsafe.Pointer(tsdPtr + 488))
		}
		goto _1
	_1:
		;
		i++
	}
	/*
	 * This is a new expression, so compile it and add it to the cache.
	 */
	regexpPtr = XTcl_Alloc(tls, uint64(112))
	(*TTclRegexp)(unsafe.Pointer(regexpPtr)).FobjPtr = libc.UintptrFromInt32(0)
	(*TTclRegexp)(unsafe.Pointer(regexpPtr)).Fstring1 = libc.UintptrFromInt32(0)
	(*TTclRegexp)(unsafe.Pointer(regexpPtr)).Fdetails.Frm_extend.Frm_so = libc.Uint64FromInt64(int64(-libc.Int32FromInt32(1)))
	(*TTclRegexp)(unsafe.Pointer(regexpPtr)).Fdetails.Frm_extend.Frm_eo = libc.Uint64FromInt64(int64(-libc.Int32FromInt32(1)))
	/*
	 * Get the up-to-date string representation and map to unicode.
	 */
	XTcl_DStringInit(tls, bp+8)
	uniString = XTcl_UtfToUniCharDString(tls, string1, libc.Int64FromUint64(length), bp+8)
	numChars = libc.Int32FromUint64(libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(bp+8)).Flength) / uint64(4))
	/*
	 * Compile the string and check for errors.
	 */
	(*TTclRegexp)(unsafe.Pointer(regexpPtr)).Fflags = flags
	status = XTclReComp(tls, regexpPtr+8, uniString, libc.Uint64FromInt32(numChars), flags)
	XTcl_DStringFree(tls, bp+8)
	if status != REG_OKAY {
		/*
		 * Clean up and report errors in the interpreter, if possible.
		 */
		XTclpFree(tls, regexpPtr)
		if interp != 0 {
			XTclRegError(tls, interp, __ccgo_ts+64914, status)
		}
		return libc.UintptrFromInt32(0)
	}
	/*
	 * Convert RE to a glob pattern equivalent, if any, and cache it.  If this
	 * is not possible, then globObjPtr will be NULL.  This is used by
	 * Tcl_RegExpExecObj to optionally do a fast match (avoids RE engine).
	 */
	if XTclReToGlob(tls, libc.UintptrFromInt32(0), string1, libc.Int64FromUint64(length), bp+8, bp, libc.UintptrFromInt32(0)) == TCL_OK {
		(*TTclRegexp)(unsafe.Pointer(regexpPtr)).FglobObjPtr = XTcl_DStringToObj(tls, bp+8)
		(*TTcl_Obj)(unsafe.Pointer((*TTclRegexp)(unsafe.Pointer(regexpPtr)).FglobObjPtr)).FrefCount++
	} else {
		(*TTclRegexp)(unsafe.Pointer(regexpPtr)).FglobObjPtr = libc.UintptrFromInt32(0)
	}
	/*
	 * Allocate enough space for all of the subexpressions, plus one extra for
	 * the entire pattern.
	 */
	(*TTclRegexp)(unsafe.Pointer(regexpPtr)).Fmatches = XTcl_Alloc(tls, uint64(16)*((*TTclRegexp)(unsafe.Pointer(regexpPtr)).Fre.Fre_nsub+uint64(1)))
	/*
	 * Initialize the refcount to one initially, since it is in the cache.
	 */
	(*TTclRegexp)(unsafe.Pointer(regexpPtr)).FrefCount = int64(1)
	/*
	 * Free the last regexp, if necessary, and make room at the head of the
	 * list for the new regexp.
	 */
	if *(*uintptr)(unsafe.Pointer(tsdPtr + 8 + uintptr(libc.Int32FromInt32(NUM_REGEXPS)-libc.Int32FromInt32(1))*8)) != libc.UintptrFromInt32(0) {
		oldRegexpPtr = *(*uintptr)(unsafe.Pointer(tsdPtr + 488 + uintptr(libc.Int32FromInt32(NUM_REGEXPS)-libc.Int32FromInt32(1))*8))
		v4 = oldRegexpPtr + 104
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			_FreeRegexp(tls, oldRegexpPtr)
		}
		XTclpFree(tls, *(*uintptr)(unsafe.Pointer(tsdPtr + 8 + uintptr(libc.Int32FromInt32(NUM_REGEXPS)-libc.Int32FromInt32(1))*8)))
	}
	i = libc.Int32FromInt32(NUM_REGEXPS) - libc.Int32FromInt32(2)
	for {
		if !(i >= 0) {
			break
		}
		*(*uintptr)(unsafe.Pointer(tsdPtr + 8 + uintptr(i+int32(1))*8)) = *(*uintptr)(unsafe.Pointer(tsdPtr + 8 + uintptr(i)*8))
		*(*Tsize_t)(unsafe.Pointer(tsdPtr + 248 + uintptr(i+int32(1))*8)) = *(*Tsize_t)(unsafe.Pointer(tsdPtr + 248 + uintptr(i)*8))
		*(*uintptr)(unsafe.Pointer(tsdPtr + 488 + uintptr(i+int32(1))*8)) = *(*uintptr)(unsafe.Pointer(tsdPtr + 488 + uintptr(i)*8))
		goto _5
	_5:
		;
		i--
	}
	*(*uintptr)(unsafe.Pointer(tsdPtr + 8)) = XTcl_Alloc(tls, length+uint64(1))
	libc.Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(tsdPtr + 8)), string1, length+uint64(1))
	*(*Tsize_t)(unsafe.Pointer(tsdPtr + 248)) = length
	*(*uintptr)(unsafe.Pointer(tsdPtr + 488)) = regexpPtr
	return regexpPtr
}

/*
 *----------------------------------------------------------------------
 *
 * FreeRegexp --
 *
 *	Release the storage associated with a TclRegexp.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _FreeRegexp(tls *libc.TLS, regexpPtr uintptr) {
	/* Compiled regular expression to free. */
	var cachePtr, v2 uintptr
	var v1 TTcl_Size
	var v3 bool
	_, _, _, _ = cachePtr, v1, v2, v3
	XTclReFree(tls, regexpPtr+8)
	if (*TTclRegexp)(unsafe.Pointer(regexpPtr)).FglobObjPtr != 0 {
		v2 = (*TTclRegexp)(unsafe.Pointer(regexpPtr)).FglobObjPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if !(v1 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer((*TTclRegexp)(unsafe.Pointer(regexpPtr)).FglobObjPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TTclRegexp)(unsafe.Pointer(regexpPtr)).FglobObjPtr)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer((*TTclRegexp)(unsafe.Pointer(regexpPtr)).FglobObjPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TTclRegexp)(unsafe.Pointer(regexpPtr)).FglobObjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TTclRegexp)(unsafe.Pointer(regexpPtr)).FglobObjPtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer((*TTclRegexp)(unsafe.Pointer(regexpPtr)).FglobObjPtr)).Flength = int64(-libc.Int32FromInt32(1))
				if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, (*TTclRegexp)(unsafe.Pointer(regexpPtr)).FglobObjPtr)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer((*TTclRegexp)(unsafe.Pointer(regexpPtr)).FglobObjPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*TTclRegexp)(unsafe.Pointer(regexpPtr)).FglobObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, (*TTclRegexp)(unsafe.Pointer(regexpPtr)).FglobObjPtr)
			}
		}
	}
	if (*TTclRegexp)(unsafe.Pointer(regexpPtr)).Fmatches != 0 {
		XTclpFree(tls, (*TTclRegexp)(unsafe.Pointer(regexpPtr)).Fmatches)
	}
	XTclpFree(tls, regexpPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * FinalizeRegexp --
 *
 *	Release the storage associated with the per-thread regexp cache.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _FinalizeRegexp(tls *libc.TLS, dummy1056 uintptr) {
	var i int32
	var regexpPtr, tsdPtr, v3 uintptr
	var v2 TTcl_Size
	_, _, _, _, _ = i, regexpPtr, tsdPtr, v2, v3
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey10)), int64(728))
	i = 0
	for {
		if !(i < int32(NUM_REGEXPS) && *(*uintptr)(unsafe.Pointer(tsdPtr + 8 + uintptr(i)*8)) != libc.UintptrFromInt32(0)) {
			break
		}
		regexpPtr = *(*uintptr)(unsafe.Pointer(tsdPtr + 488 + uintptr(i)*8))
		v3 = regexpPtr + 104
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 <= int64(1) {
			_FreeRegexp(tls, regexpPtr)
		}
		XTclpFree(tls, *(*uintptr)(unsafe.Pointer(tsdPtr + 8 + uintptr(i)*8)))
		*(*uintptr)(unsafe.Pointer(tsdPtr + 8 + uintptr(i)*8)) = libc.UintptrFromInt32(0)
		goto _1
	_1:
		;
		i++
	}
	/*
	 * We may find ourselves reinitialized if another finalization routine
	 * invokes regexps.
	 */
	(*TThreadSpecificData12)(unsafe.Pointer(tsdPtr)).Finitialized = 0
}

type TTclRegexp1 = struct {
	Fflags      int32
	Fre         Tregex_t
	Fstring1    uintptr
	FobjPtr     uintptr
	FglobObjPtr uintptr
	Fmatches    uintptr
	Fdetails    Trm_detail_t
	FrefCount   TTcl_Size
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_AddInterpResolvers --
 *
 *	Adds a set of command/variable resolution functions to an interpreter.
 *	These functions are consulted when commands are resolved in
 *	Tcl_FindCommand, and when variables are resolved in TclLookupVar and
 *	LookupCompiledLocal. Each namespace may also have its own set of
 *	resolution functions which take precedence over those for the
 *	interpreter.
 *
 *	When a name is resolved, it is handled as follows. First, the name is
 *	passed to the resolution functions for the namespace. If not resolved,
 *	the name is passed to each of the resolution functions added to the
 *	interpreter. Finally, if still not resolved, the name is handled using
 *	the default Tcl rules for name resolution.
 *
 * Results:
 *	Returns pointers to the current name resolution functions in the
 *	cmdProcPtr, varProcPtr and compiledVarProcPtr arguments.
 *
 * Side effects:
 *	If a compiledVarProc is specified, this function bumps the
 *	compileEpoch for the interpreter, forcing all code to be recompiled.
 *	If a cmdProc is specified, this function bumps the cmdRefEpoch in all
 *	namespaces, forcing commands to be resolved again using the new rules.
 *
 *----------------------------------------------------------------------
 */

func XTcl_AddInterpResolvers(tls *libc.TLS, interp uintptr, name uintptr, cmdProc uintptr, varProc uintptr, compiledVarProc uintptr) {
	/* Function for variable resolution at compile
	 * time. */
	var iPtr, resPtr uintptr
	var len1 uint32
	_, _, _ = iPtr, len1, resPtr
	iPtr = interp
	/*
	 * Since we're adding a new name resolution scheme, we must force all code
	 * to be recompiled to use the new scheme. If there are new compiled
	 * variable resolution rules, bump the compiler epoch to invalidate
	 * compiled code. If there are new command resolution rules, bump the
	 * cmdRefEpoch in all namespaces.
	 */
	if compiledVarProc != 0 {
		(*TInterp)(unsafe.Pointer(iPtr)).FcompileEpoch++
	}
	if cmdProc != 0 {
		_BumpCmdRefEpochs(tls, (*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr)
	}
	/*
	 * Look for an existing scheme with the given name. If found, then replace
	 * its rules.
	 */
	resPtr = (*TInterp)(unsafe.Pointer(iPtr)).FresolverPtr
	for {
		if !(resPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TResolverScheme)(unsafe.Pointer(resPtr)).Fname))) && libc.Xstrcmp(tls, name, (*TResolverScheme)(unsafe.Pointer(resPtr)).Fname) == 0 {
			(*TResolverScheme)(unsafe.Pointer(resPtr)).FcmdResProc = cmdProc
			(*TResolverScheme)(unsafe.Pointer(resPtr)).FvarResProc = varProc
			(*TResolverScheme)(unsafe.Pointer(resPtr)).FcompiledVarResProc = compiledVarProc
			return
		}
		goto _1
	_1:
		;
		resPtr = (*TResolverScheme)(unsafe.Pointer(resPtr)).FnextPtr
	}
	/*
	 * Otherwise, this is a new scheme. Add it to the FRONT of the linked
	 * list, so that it overrides existing schemes.
	 */
	resPtr = XTcl_Alloc(tls, uint64(40))
	len1 = uint32(libc.Xstrlen(tls, name) + uint64(1))
	(*TResolverScheme)(unsafe.Pointer(resPtr)).Fname = XTcl_Alloc(tls, uint64(len1))
	libc.Xmemcpy(tls, (*TResolverScheme)(unsafe.Pointer(resPtr)).Fname, name, uint64(len1))
	(*TResolverScheme)(unsafe.Pointer(resPtr)).FcmdResProc = cmdProc
	(*TResolverScheme)(unsafe.Pointer(resPtr)).FvarResProc = varProc
	(*TResolverScheme)(unsafe.Pointer(resPtr)).FcompiledVarResProc = compiledVarProc
	(*TResolverScheme)(unsafe.Pointer(resPtr)).FnextPtr = (*TInterp)(unsafe.Pointer(iPtr)).FresolverPtr
	(*TInterp)(unsafe.Pointer(iPtr)).FresolverPtr = resPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetInterpResolvers --
 *
 *	Looks for a set of command/variable resolution functions with the
 *	given name in an interpreter. These functions are registered by
 *	calling Tcl_AddInterpResolvers.
 *
 * Results:
 *	If the name is recognized, this function returns non-zero, along with
 *	pointers to the name resolution functions in the Tcl_ResolverInfo
 *	structure. If the name is not recognized, this function returns zero.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetInterpResolvers(tls *libc.TLS, interp uintptr, name uintptr, resInfoPtr uintptr) (r int32) {
	/* Returns pointers to the functions, if
	 * found */
	var iPtr, resPtr uintptr
	_, _ = iPtr, resPtr
	iPtr = interp
	/*
	 * Look for an existing scheme with the given name. If found, then return
	 * pointers to its functions.
	 */
	resPtr = (*TInterp)(unsafe.Pointer(iPtr)).FresolverPtr
	for {
		if !(resPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TResolverScheme)(unsafe.Pointer(resPtr)).Fname))) && libc.Xstrcmp(tls, name, (*TResolverScheme)(unsafe.Pointer(resPtr)).Fname) == 0 {
			(*TTcl_ResolverInfo)(unsafe.Pointer(resInfoPtr)).FcmdResProc = (*TResolverScheme)(unsafe.Pointer(resPtr)).FcmdResProc
			(*TTcl_ResolverInfo)(unsafe.Pointer(resInfoPtr)).FvarResProc = (*TResolverScheme)(unsafe.Pointer(resPtr)).FvarResProc
			(*TTcl_ResolverInfo)(unsafe.Pointer(resInfoPtr)).FcompiledVarResProc = (*TResolverScheme)(unsafe.Pointer(resPtr)).FcompiledVarResProc
			return int32(1)
		}
		goto _1
	_1:
		;
		resPtr = (*TResolverScheme)(unsafe.Pointer(resPtr)).FnextPtr
	}
	return 0
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_RemoveInterpResolvers --
 *
 *	Removes a set of command/variable resolution functions previously
 *	added by Tcl_AddInterpResolvers. The next time a command/variable name
 *	is resolved, these functions won't be consulted.
 *
 * Results:
 *	Returns non-zero if the name was recognized and the resolution scheme
 *	was deleted. Returns zero otherwise.
 *
 * Side effects:
 *	If a scheme with a compiledVarProc was deleted, this function bumps
 *	the compileEpoch for the interpreter, forcing all code to be
 *	recompiled. If a scheme with a cmdProc was deleted, this function
 *	bumps the cmdRefEpoch in all namespaces, forcing commands to be
 *	resolved again using the new rules.
 *
 *----------------------------------------------------------------------
 */

func XTcl_RemoveInterpResolvers(tls *libc.TLS, interp uintptr, name uintptr) (r int32) {
	/* Name of the scheme to be removed. */
	var iPtr, prevPtrPtr, resPtr uintptr
	_, _, _ = iPtr, prevPtrPtr, resPtr
	iPtr = interp
	/*
	 * Look for an existing scheme with the given name.
	 */
	prevPtrPtr = iPtr + 352
	resPtr = (*TInterp)(unsafe.Pointer(iPtr)).FresolverPtr
	for {
		if !(resPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TResolverScheme)(unsafe.Pointer(resPtr)).Fname))) && libc.Xstrcmp(tls, name, (*TResolverScheme)(unsafe.Pointer(resPtr)).Fname) == 0 {
			break
		}
		prevPtrPtr = resPtr + 32
		goto _1
	_1:
		;
		resPtr = (*TResolverScheme)(unsafe.Pointer(resPtr)).FnextPtr
	}
	/*
	 * If we found the scheme, delete it.
	 */
	if resPtr != 0 {
		/*
		 * If we're deleting a scheme with compiled variable resolution rules,
		 * bump the compiler epoch to invalidate compiled code. If we're
		 * deleting a scheme with command resolution rules, bump the
		 * cmdRefEpoch in all namespaces.
		 */
		if (*TResolverScheme)(unsafe.Pointer(resPtr)).FcompiledVarResProc != 0 {
			(*TInterp)(unsafe.Pointer(iPtr)).FcompileEpoch++
		}
		if (*TResolverScheme)(unsafe.Pointer(resPtr)).FcmdResProc != 0 {
			_BumpCmdRefEpochs(tls, (*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr)
		}
		*(*uintptr)(unsafe.Pointer(prevPtrPtr)) = (*TResolverScheme)(unsafe.Pointer(resPtr)).FnextPtr
		XTclpFree(tls, (*TResolverScheme)(unsafe.Pointer(resPtr)).Fname)
		XTclpFree(tls, resPtr)
		return int32(1)
	}
	return 0
}

/*
 *----------------------------------------------------------------------
 *
 * BumpCmdRefEpochs --
 *
 *	This function is used to bump the cmdRefEpoch counters in the
 *	specified namespace and all of its child namespaces. It is used
 *	whenever name resolution schemes are added/removed from an
 *	interpreter, to invalidate all command references.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Bumps the cmdRefEpoch in the specified namespace and its children,
 *	recursively.
 *
 *----------------------------------------------------------------------
 */

func _BumpCmdRefEpochs(tls *libc.TLS, nsPtr uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Namespace being modified. */
	var childNsPtr, entry uintptr
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _ = childNsPtr, entry
	(*TNamespace)(unsafe.Pointer(nsPtr)).FcmdRefEpoch++
	entry = XTcl_FirstHashEntry(tls, nsPtr+40, bp)
	for {
		if !(entry != libc.UintptrFromInt32(0)) {
			break
		}
		childNsPtr = (*TTcl_HashEntry)(unsafe.Pointer(entry)).FclientData
		_BumpCmdRefEpochs(tls, childNsPtr)
		goto _1
	_1:
		;
		entry = XTcl_NextHashEntry(tls, bp)
	}
	XTclInvalidateNsPath(tls, nsPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetNamespaceResolvers --
 *
 *	Sets the command/variable resolution functions for a namespace,
 *	thereby changing the way that command/variable names are interpreted.
 *	This allows extension writers to support different name resolution
 *	schemes, such as those for object-oriented packages.
 *
 *	Command resolution is handled by a function of the following type:
 *
 *	  typedef int (Tcl_ResolveCmdProc)(Tcl_Interp *interp,
 *		  const char *name, Tcl_Namespace *context,
 *		  int flags, Tcl_Command *rPtr);
 *
 *	Whenever a command is executed or Tcl_FindCommand is invoked within
 *	the namespace, this function is called to resolve the command name. If
 *	this function is able to resolve the name, it should return the status
 *	code TCL_OK, along with the corresponding Tcl_Command in the rPtr
 *	argument. Otherwise, the function can return TCL_CONTINUE, and the
 *	command will be treated under the usual name resolution rules. Or, it
 *	can return TCL_ERROR, and the command will be considered invalid.
 *
 *	Variable resolution is handled by two functions. The first is called
 *	whenever a variable needs to be resolved at compile time:
 *
 *	  typedef int (Tcl_ResolveCompiledVarProc)(Tcl_Interp *interp,
 *		  const char *name, Tcl_Namespace *context,
 *		  Tcl_ResolvedVarInfo *rPtr);
 *
 *	If this function is able to resolve the name, it should return the
 *	status code TCL_OK, along with variable resolution info in the rPtr
 *	argument; this info will be used to set up compiled locals in the call
 *	frame at runtime. The function may also return TCL_CONTINUE, and the
 *	variable will be treated under the usual name resolution rules. Or, it
 *	can return TCL_ERROR, and the variable will be considered invalid.
 *
 *	Another function is used whenever a variable needs to be resolved at
 *	runtime but it is not recognized as a compiled local. (For example,
 *	the variable may be requested via Tcl_FindNamespaceVar.) This function
 *	has the following type:
 *
 *	  typedef int (Tcl_ResolveVarProc)(Tcl_Interp *interp,
 *		  const char *name, Tcl_Namespace *context,
 *		  int flags, Tcl_Var *rPtr);
 *
 *	This function is quite similar to the compile-time version. It returns
 *	the same status codes, but if variable resolution succeeds, this
 *	function returns a Tcl_Var directly via the rPtr argument.
 *
 * Results:
 *	Nothing.
 *
 * Side effects:
 *	Bumps the command epoch counter for the namespace, invalidating all
 *	command references in that namespace. Also bumps the resolver epoch
 *	counter for the namespace, forcing all code in the namespace to be
 *	recompiled.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetNamespaceResolvers(tls *libc.TLS, namespacePtr uintptr, cmdProc uintptr, varProc uintptr, compiledVarProc uintptr) {
	/* Function for variable resolution at compile
	 * time. */
	var nsPtr uintptr
	_ = nsPtr
	nsPtr = namespacePtr
	/*
	 * Plug in the new command resolver, and bump the epoch counters so that
	 * all code will have to be recompiled and all commands will have to be
	 * resolved again using the new policy.
	 */
	(*TNamespace)(unsafe.Pointer(nsPtr)).FcmdResProc = cmdProc
	(*TNamespace)(unsafe.Pointer(nsPtr)).FvarResProc = varProc
	(*TNamespace)(unsafe.Pointer(nsPtr)).FcompiledVarResProc = compiledVarProc
	(*TNamespace)(unsafe.Pointer(nsPtr)).FcmdRefEpoch++
	(*TNamespace)(unsafe.Pointer(nsPtr)).FresolverEpoch++
	XTclInvalidateNsPath(tls, nsPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetNamespaceResolvers --
 *
 *	Returns the current command/variable resolution functions for a
 *	namespace. By default, these functions are NULL. New functions can be
 *	installed by calling Tcl_SetNamespaceResolvers, to provide new name
 *	resolution rules.
 *
 * Results:
 *	Returns non-zero if any name resolution functions have been assigned
 *	to this namespace; also returns pointers to the functions in the
 *	Tcl_ResolverInfo structure. Returns zero otherwise.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetNamespaceResolvers(tls *libc.TLS, namespacePtr uintptr, resInfoPtr uintptr) (r int32) {
	/* Returns: pointers for all name resolution
	 * functions assigned to this namespace. */
	var nsPtr uintptr
	_ = nsPtr
	nsPtr = namespacePtr
	(*TTcl_ResolverInfo)(unsafe.Pointer(resInfoPtr)).FcmdResProc = (*TNamespace)(unsafe.Pointer(nsPtr)).FcmdResProc
	(*TTcl_ResolverInfo)(unsafe.Pointer(resInfoPtr)).FvarResProc = (*TNamespace)(unsafe.Pointer(nsPtr)).FvarResProc
	(*TTcl_ResolverInfo)(unsafe.Pointer(resInfoPtr)).FcompiledVarResProc = (*TNamespace)(unsafe.Pointer(nsPtr)).FcompiledVarResProc
	if (*TNamespace)(unsafe.Pointer(nsPtr)).FcmdResProc != libc.UintptrFromInt32(0) || (*TNamespace)(unsafe.Pointer(nsPtr)).FvarResProc != libc.UintptrFromInt32(0) || (*TNamespace)(unsafe.Pointer(nsPtr)).FcompiledVarResProc != libc.UintptrFromInt32(0) {
		return int32(1)
	}
	return 0
}

/*
 * Indices of the standard return options dictionary keys.
 */

type returnKeys = int32

const KEY_CODE = 0
const KEY_ERRORCODE = 1
const KEY_ERRORINFO = 2
const KEY_ERRORLINE = 3
const KEY_LEVEL = 4
const KEY_OPTIONS = 5
const KEY_ERRORSTACK = 6
const KEY_LAST = 7

/*
 * This structure is used to take a snapshot of the interpreter state in
 * Tcl_SaveInterpState. You can snapshot the state, execute a command, and
 * then back up to the result or the error that was previously in progress.
 */

type TInterpState = struct {
	Fstatus          int32
	Fflags           int32
	FreturnLevel     int32
	FreturnCode      int32
	FerrorInfo       uintptr
	FerrorCode       uintptr
	FreturnOpts      uintptr
	FobjResult       uintptr
	FerrorStack      uintptr
	FresetErrorStack int32
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SaveInterpState --
 *
 *	Fills a token with a snapshot of the current state of the interpreter.
 *	The snapshot can be restored at any point by Tcl_RestoreInterpState.
 *
 *	The token returned must be eventually passed to one of the routines
 *	Tcl_RestoreInterpState or Tcl_DiscardInterpState, or there will be a
 *	memory leak.
 *
 * Results:
 *	Returns a token representing the interp state.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SaveInterpState(tls *libc.TLS, interp uintptr, status int32) (r TTcl_InterpState) {
	/* status code for current operation */
	var iPtr, statePtr uintptr
	_, _ = iPtr, statePtr
	iPtr = interp
	statePtr = XTcl_Alloc(tls, uint64(64))
	(*TInterpState)(unsafe.Pointer(statePtr)).Fstatus = status
	(*TInterpState)(unsafe.Pointer(statePtr)).Fflags = (*TInterp)(unsafe.Pointer(iPtr)).Fflags & int32(ERR_ALREADY_LOGGED)
	(*TInterpState)(unsafe.Pointer(statePtr)).FreturnLevel = (*TInterp)(unsafe.Pointer(iPtr)).FreturnLevel
	(*TInterpState)(unsafe.Pointer(statePtr)).FreturnCode = (*TInterp)(unsafe.Pointer(iPtr)).FreturnCode
	(*TInterpState)(unsafe.Pointer(statePtr)).FerrorInfo = (*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo
	(*TInterpState)(unsafe.Pointer(statePtr)).FerrorStack = (*TInterp)(unsafe.Pointer(iPtr)).FerrorStack
	(*TInterpState)(unsafe.Pointer(statePtr)).FresetErrorStack = (*TInterp)(unsafe.Pointer(iPtr)).FresetErrorStack
	if (*TInterpState)(unsafe.Pointer(statePtr)).FerrorInfo != 0 {
		(*TTcl_Obj)(unsafe.Pointer((*TInterpState)(unsafe.Pointer(statePtr)).FerrorInfo)).FrefCount++
	}
	(*TInterpState)(unsafe.Pointer(statePtr)).FerrorCode = (*TInterp)(unsafe.Pointer(iPtr)).FerrorCode
	if (*TInterpState)(unsafe.Pointer(statePtr)).FerrorCode != 0 {
		(*TTcl_Obj)(unsafe.Pointer((*TInterpState)(unsafe.Pointer(statePtr)).FerrorCode)).FrefCount++
	}
	(*TInterpState)(unsafe.Pointer(statePtr)).FreturnOpts = (*TInterp)(unsafe.Pointer(iPtr)).FreturnOpts
	if (*TInterpState)(unsafe.Pointer(statePtr)).FreturnOpts != 0 {
		(*TTcl_Obj)(unsafe.Pointer((*TInterpState)(unsafe.Pointer(statePtr)).FreturnOpts)).FrefCount++
	}
	if (*TInterpState)(unsafe.Pointer(statePtr)).FerrorStack != 0 {
		(*TTcl_Obj)(unsafe.Pointer((*TInterpState)(unsafe.Pointer(statePtr)).FerrorStack)).FrefCount++
	}
	(*TInterpState)(unsafe.Pointer(statePtr)).FobjResult = XTcl_GetObjResult(tls, interp)
	(*TTcl_Obj)(unsafe.Pointer((*TInterpState)(unsafe.Pointer(statePtr)).FobjResult)).FrefCount++
	return statePtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_RestoreInterpState --
 *
 *	Accepts an interp and a token previously returned by
 *	Tcl_SaveInterpState. Restore the state of the interp to what it was at
 *	the time of the Tcl_SaveInterpState call.
 *
 * Results:
 *	Returns the status value originally passed in to Tcl_SaveInterpState.
 *
 * Side effects:
 *	Restores the interp state and frees memory held by token.
 *
 *----------------------------------------------------------------------
 */

func XTcl_RestoreInterpState(tls *libc.TLS, interp uintptr, state TTcl_InterpState) (r int32) {
	/* Saved interpreter state. */
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, iPtr, statePtr, v2, v4, v6, v8 uintptr
	var status int32
	var v1, v3, v5, v7 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, iPtr, statePtr, status, v1, v2, v3, v4, v5, v6, v7, v8
	iPtr = interp
	statePtr = state
	status = (*TInterpState)(unsafe.Pointer(statePtr)).Fstatus
	*(*int32)(unsafe.Pointer(iPtr + 368)) &= ^libc.Int32FromInt32(ERR_ALREADY_LOGGED)
	*(*int32)(unsafe.Pointer(iPtr + 368)) |= (*TInterpState)(unsafe.Pointer(statePtr)).Fflags & int32(ERR_ALREADY_LOGGED)
	(*TInterp)(unsafe.Pointer(iPtr)).FreturnLevel = (*TInterpState)(unsafe.Pointer(statePtr)).FreturnLevel
	(*TInterp)(unsafe.Pointer(iPtr)).FreturnCode = (*TInterpState)(unsafe.Pointer(statePtr)).FreturnCode
	(*TInterp)(unsafe.Pointer(iPtr)).FresetErrorStack = (*TInterpState)(unsafe.Pointer(statePtr)).FresetErrorStack
	if (*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo != 0 {
		_objPtr = (*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	(*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo = (*TInterpState)(unsafe.Pointer(statePtr)).FerrorInfo
	if (*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo != 0 {
		(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo)).FrefCount++
	}
	if (*TInterp)(unsafe.Pointer(iPtr)).FerrorCode != 0 {
		_objPtr1 = (*TInterp)(unsafe.Pointer(iPtr)).FerrorCode
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
	(*TInterp)(unsafe.Pointer(iPtr)).FerrorCode = (*TInterpState)(unsafe.Pointer(statePtr)).FerrorCode
	if (*TInterp)(unsafe.Pointer(iPtr)).FerrorCode != 0 {
		(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FerrorCode)).FrefCount++
	}
	if (*TInterp)(unsafe.Pointer(iPtr)).FerrorStack != 0 {
		_objPtr2 = (*TInterp)(unsafe.Pointer(iPtr)).FerrorStack
		v6 = _objPtr2
		v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
		*(*TTcl_Size)(unsafe.Pointer(v6))--
		if v5 <= int64(1) {
			XTclFreeObj(tls, _objPtr2)
		}
	}
	(*TInterp)(unsafe.Pointer(iPtr)).FerrorStack = (*TInterpState)(unsafe.Pointer(statePtr)).FerrorStack
	if (*TInterp)(unsafe.Pointer(iPtr)).FerrorStack != 0 {
		(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FerrorStack)).FrefCount++
	}
	if (*TInterp)(unsafe.Pointer(iPtr)).FreturnOpts != 0 {
		_objPtr3 = (*TInterp)(unsafe.Pointer(iPtr)).FreturnOpts
		v8 = _objPtr3
		v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
		*(*TTcl_Size)(unsafe.Pointer(v8))--
		if v7 <= int64(1) {
			XTclFreeObj(tls, _objPtr3)
		}
	}
	(*TInterp)(unsafe.Pointer(iPtr)).FreturnOpts = (*TInterpState)(unsafe.Pointer(statePtr)).FreturnOpts
	if (*TInterp)(unsafe.Pointer(iPtr)).FreturnOpts != 0 {
		(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FreturnOpts)).FrefCount++
	}
	XTcl_SetObjResult(tls, interp, (*TInterpState)(unsafe.Pointer(statePtr)).FobjResult)
	XTcl_DiscardInterpState(tls, state)
	return status
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DiscardInterpState --
 *
 *	Accepts a token previously returned by Tcl_SaveInterpState. Frees the
 *	memory it uses.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Frees memory.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DiscardInterpState(tls *libc.TLS, state TTcl_InterpState) {
	/* saved interpreter state */
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, statePtr, v10, v2, v4, v6, v8 uintptr
	var v1, v3, v5, v7, v9 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, statePtr, v1, v10, v2, v3, v4, v5, v6, v7, v8, v9
	statePtr = state
	if (*TInterpState)(unsafe.Pointer(statePtr)).FerrorInfo != 0 {
		_objPtr = (*TInterpState)(unsafe.Pointer(statePtr)).FerrorInfo
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	if (*TInterpState)(unsafe.Pointer(statePtr)).FerrorCode != 0 {
		_objPtr1 = (*TInterpState)(unsafe.Pointer(statePtr)).FerrorCode
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
	if (*TInterpState)(unsafe.Pointer(statePtr)).FreturnOpts != 0 {
		_objPtr2 = (*TInterpState)(unsafe.Pointer(statePtr)).FreturnOpts
		v6 = _objPtr2
		v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
		*(*TTcl_Size)(unsafe.Pointer(v6))--
		if v5 <= int64(1) {
			XTclFreeObj(tls, _objPtr2)
		}
	}
	if (*TInterpState)(unsafe.Pointer(statePtr)).FerrorStack != 0 {
		_objPtr3 = (*TInterpState)(unsafe.Pointer(statePtr)).FerrorStack
		v8 = _objPtr3
		v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
		*(*TTcl_Size)(unsafe.Pointer(v8))--
		if v7 <= int64(1) {
			XTclFreeObj(tls, _objPtr3)
		}
	}
	_objPtr4 = (*TInterpState)(unsafe.Pointer(statePtr)).FobjResult
	v10 = _objPtr4
	v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
	*(*TTcl_Size)(unsafe.Pointer(v10))--
	if v9 <= int64(1) {
		XTclFreeObj(tls, _objPtr4)
	}
	XTclpFree(tls, statePtr)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetObjResult --
 *	Makes objPtr the interpreter's result value.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Stores objPtr interp->objResultPtr, increments its reference count, and
 *	decrements the reference count of any existing interp->objResultPtr.
 *
 *	The string result is reset.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetObjResult(tls *libc.TLS, interp uintptr, objPtr uintptr) {
	/* The value to set as the result. */
	var cachePtr, iPtr, oldObjResult, v2 uintptr
	var v1 TTcl_Size
	var v3 bool
	_, _, _, _, _, _ = cachePtr, iPtr, oldObjResult, v1, v2, v3
	iPtr = interp
	oldObjResult = (*TInterp)(unsafe.Pointer(iPtr)).FobjResultPtr
	if objPtr == oldObjResult {
		/* This should be impossible */
		return
	} else {
		(*TInterp)(unsafe.Pointer(iPtr)).FobjResultPtr = objPtr
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount++
		v2 = oldObjResult
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if !(v1 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(oldObjResult)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(oldObjResult)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(oldObjResult)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(oldObjResult)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(oldObjResult)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(oldObjResult)).Flength = int64(-libc.Int32FromInt32(1))
				if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, oldObjResult)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(oldObjResult + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = oldObjResult
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, oldObjResult)
			}
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetObjResult --
 *
 *	Returns an interpreter's result value as a Tcl object. The object's
 *	reference count is not modified; the caller must do that if it needs
 *	to hold on to a long-term reference to it.
 *
 * Results:
 *	The interpreter's result as an object.
 *
 * Side effects:
 *	If the interpreter has a non-empty string result, the result object is
 *	either empty or stale because some function set interp->result
 *	directly. If so, the string result is moved to the result object then
 *	the string result is reset.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetObjResult(tls *libc.TLS, interp uintptr) (r uintptr) {
	/* Interpreter whose result to return. */
	var iPtr uintptr
	_ = iPtr
	iPtr = interp
	return (*TInterp)(unsafe.Pointer(iPtr)).FobjResultPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_AppendResult --
 *
 *	Append a variable number of strings onto the interpreter's result.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The result of the interpreter given by the first argument is extended
 *	by the strings given by the second and following arguments (up to a
 *	terminating NULL argument).
 *
 *	If the string result is non-empty, the object result forced to be a
 *	duplicate of it first. There will be a string result afterwards.
 *
 *----------------------------------------------------------------------
 */

func XTcl_AppendResult(tls *libc.TLS, interp uintptr, va uintptr) {
	var argList Tva_list
	var bytes, objPtr uintptr
	_, _, _ = argList, bytes, objPtr
	argList = va
	objPtr = XTcl_GetObjResult(tls, interp)
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount > int64(1) {
		objPtr = XTcl_DuplicateObj(tls, objPtr)
	}
	for int32(1) != 0 {
		bytes = libc.VaUintptr(&argList)
		if bytes == libc.UintptrFromInt32(0) {
			break
		}
		XTcl_AppendToObj(tls, objPtr, bytes, int64(-int32(1)))
	}
	XTcl_SetObjResult(tls, interp, objPtr)
	_ = argList
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_AppendElement --
 *
 *	Convert a string to a valid Tcl list element and append it to the
 *	result (which is ostensibly a list).
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The result in the interpreter given by the first argument is extended
 *	with a list element converted from string. A separator space is added
 *	before the converted list element unless the current result is empty,
 *	contains the single character "{", or ends in " {".
 *
 *	If the string result is empty, the object result is moved to the
 *	string result, then the object result is reset.
 *
 *----------------------------------------------------------------------
 */

func XTcl_AppendElement(tls *libc.TLS, interp uintptr, element uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* String to convert to list element and add
	 * to result. */
	var _objPtr, bytes, iPtr, listPtr, v1, v3 uintptr
	var v2 TTcl_Size
	var _ /* elementPtr at bp+0 */ uintptr
	var _ /* length at bp+8 */ TTcl_Size
	_, _, _, _, _, _, _ = _objPtr, bytes, iPtr, listPtr, v1, v2, v3
	iPtr = interp
	*(*uintptr)(unsafe.Pointer(bp)) = XTcl_NewStringObj(tls, element, int64(-int32(1)))
	listPtr = XTcl_NewListObj(tls, int64(1), bp)
	if (*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FobjResultPtr)).FrefCount > int64(1) {
		XTcl_SetObjResult(tls, interp, XTcl_DuplicateObj(tls, (*TInterp)(unsafe.Pointer(iPtr)).FobjResultPtr))
	}
	if (*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FobjResultPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FobjResultPtr)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FobjResultPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, (*TInterp)(unsafe.Pointer(iPtr)).FobjResultPtr, bp+8)
	}
	bytes = v1
	if XTclNeedSpace(tls, bytes, bytes+uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))) != 0 {
		XTcl_AppendToObj(tls, (*TInterp)(unsafe.Pointer(iPtr)).FobjResultPtr, __ccgo_ts+14830, int64(1))
	}
	XTcl_AppendObjToObj(tls, (*TInterp)(unsafe.Pointer(iPtr)).FobjResultPtr, listPtr)
	_objPtr = listPtr
	v3 = _objPtr
	v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
	*(*TTcl_Size)(unsafe.Pointer(v3))--
	if v2 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ResetResult --
 *
 *	This function resets both the interpreter's string and object results.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	It resets the result object to an unshared empty object. It then
 *	restores the interpreter's string result area to its default
 *	initialized state, freeing up any memory that may have been allocated.
 *	It also clears any error information for the interpreter.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ResetResult(tls *libc.TLS, interp uintptr) {
	/* Interpreter for which to clear result. */
	var _objPtr, _objPtr1, _objPtr2, iPtr, v2, v4, v6 uintptr
	var v1, v3, v5 TTcl_Size
	_, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, iPtr, v1, v2, v3, v4, v5, v6
	iPtr = interp
	_ResetObjResult(tls, iPtr)
	if (*TInterp)(unsafe.Pointer(iPtr)).FerrorCode != 0 {
		/* Legacy support */
		if (*TInterp)(unsafe.Pointer(iPtr)).Fflags&int32(ERR_LEGACY_COPY) != 0 {
			XTcl_ObjSetVar2(tls, interp, (*TInterp)(unsafe.Pointer(iPtr)).FecVar, libc.UintptrFromInt32(0), (*TInterp)(unsafe.Pointer(iPtr)).FerrorCode, int32(TCL_GLOBAL_ONLY))
		}
		_objPtr = (*TInterp)(unsafe.Pointer(iPtr)).FerrorCode
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		(*TInterp)(unsafe.Pointer(iPtr)).FerrorCode = libc.UintptrFromInt32(0)
	}
	if (*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo != 0 {
		/* Legacy support */
		if (*TInterp)(unsafe.Pointer(iPtr)).Fflags&int32(ERR_LEGACY_COPY) != 0 {
			XTcl_ObjSetVar2(tls, interp, (*TInterp)(unsafe.Pointer(iPtr)).FeiVar, libc.UintptrFromInt32(0), (*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo, int32(TCL_GLOBAL_ONLY))
		}
		_objPtr1 = (*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		(*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo = libc.UintptrFromInt32(0)
	}
	(*TInterp)(unsafe.Pointer(iPtr)).FresetErrorStack = int32(1)
	(*TInterp)(unsafe.Pointer(iPtr)).FreturnLevel = int32(1)
	(*TInterp)(unsafe.Pointer(iPtr)).FreturnCode = TCL_OK
	if (*TInterp)(unsafe.Pointer(iPtr)).FreturnOpts != 0 {
		_objPtr2 = (*TInterp)(unsafe.Pointer(iPtr)).FreturnOpts
		v6 = _objPtr2
		v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
		*(*TTcl_Size)(unsafe.Pointer(v6))--
		if v5 <= int64(1) {
			XTclFreeObj(tls, _objPtr2)
		}
		(*TInterp)(unsafe.Pointer(iPtr)).FreturnOpts = libc.UintptrFromInt32(0)
	}
	*(*int32)(unsafe.Pointer(iPtr + 368)) &= ^(libc.Int32FromInt32(ERR_ALREADY_LOGGED) | libc.Int32FromInt32(ERR_LEGACY_COPY))
}

/*
 *----------------------------------------------------------------------
 *
 * ResetObjResult --
 *
 *	Function used to reset an interpreter's Tcl result object.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Resets the interpreter's result object to an unshared empty string
 *	object with ref count one. It does not clear any error information in
 *	the interpreter.
 *
 *----------------------------------------------------------------------
 */

func _ResetObjResult(tls *libc.TLS, iPtr uintptr) {
	/* Points to the interpreter whose result
	 * object should be reset. */
	var cachePtr, cachePtr1, objResultPtr, v2 uintptr
	var v1 TTcl_Size
	var v3, v4 bool
	_, _, _, _, _, _, _ = cachePtr, cachePtr1, objResultPtr, v1, v2, v3, v4
	objResultPtr = (*TInterp)(unsafe.Pointer(iPtr)).FobjResultPtr
	if (*TTcl_Obj)(unsafe.Pointer(objResultPtr)).FrefCount > int64(1) {
		v2 = objResultPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if !(v1 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(objResultPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objResultPtr)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(objResultPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objResultPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(objResultPtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(objResultPtr)).Flength = int64(-libc.Int32FromInt32(1))
				if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, objResultPtr)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(objResultPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = objResultPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, objResultPtr)
			}
		}
		if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			objResultPtr = XTclThreadAllocObj(tls)
		} else {
			objResultPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objResultPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(objResultPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(objResultPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(objResultPtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(objResultPtr)).FtypePtr = libc.UintptrFromInt32(0)
		(*TTcl_Obj)(unsafe.Pointer(objResultPtr)).FrefCount++
		(*TInterp)(unsafe.Pointer(iPtr)).FobjResultPtr = objResultPtr
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(objResultPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			if (*TTcl_Obj)(unsafe.Pointer(objResultPtr)).Fbytes != 0 {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(objResultPtr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(objResultPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(objResultPtr)).Flength = 0
		}
		if (*TTcl_Obj)(unsafe.Pointer(objResultPtr)).FtypePtr != libc.UintptrFromInt32(0) {
			if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objResultPtr)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
				(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objResultPtr)).FtypePtr)).FfreeIntRepProc})))(tls, objResultPtr)
			}
			(*TTcl_Obj)(unsafe.Pointer(objResultPtr)).FtypePtr = libc.UintptrFromInt32(0)
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetErrorCode --
 *
 *	This function is called to record machine-readable information about
 *	an error that is about to be returned.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The errorCode field of the interp is modified to hold all of the
 *	arguments to this function, in a list form with each argument becoming
 *	one element of the list.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetErrorCode(tls *libc.TLS, interp uintptr, va uintptr) {
	var argList Tva_list
	var cachePtr, elem, errorObj uintptr
	var v1 bool
	_, _, _, _, _ = argList, cachePtr, elem, errorObj, v1
	/*
	 * Scan through the arguments one at a time, appending them to the
	 * errorCode field as list elements.
	 */
	argList = va
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		errorObj = XTclThreadAllocObj(tls)
	} else {
		errorObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(errorObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(errorObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(errorObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(errorObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(errorObj)).FtypePtr = libc.UintptrFromInt32(0)
	/*
	 * Scan through the arguments one at a time, appending them to the
	 * errorCode field as list elements.
	 */
	for int32(1) != 0 {
		elem = libc.VaUintptr(&argList)
		if elem == libc.UintptrFromInt32(0) {
			break
		}
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), errorObj, XTcl_NewStringObj(tls, elem, int64(-int32(1))))
	}
	XTcl_SetObjErrorCode(tls, interp, errorObj)
	_ = argList
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetObjErrorCode --
 *
 *	This function is called to record machine-readable information about
 *	an error that is about to be returned. The caller should build a list
 *	object up and pass it to this routine.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The errorCode field of the interp is set to the new value.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetObjErrorCode(tls *libc.TLS, interp uintptr, errorObjPtr uintptr) {
	var _objPtr, iPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _ = _objPtr, iPtr, v1, v2
	iPtr = interp
	if (*TInterp)(unsafe.Pointer(iPtr)).FerrorCode != 0 {
		_objPtr = (*TInterp)(unsafe.Pointer(iPtr)).FerrorCode
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	(*TInterp)(unsafe.Pointer(iPtr)).FerrorCode = errorObjPtr
	(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FerrorCode)).FrefCount++
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetErrorLine --
 *
 *      Returns the line number associated with the current error.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetErrorLine(tls *libc.TLS, interp uintptr) (r int32) {
	return (*TInterp)(unsafe.Pointer(interp)).FerrorLine
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetErrorLine --
 *
 *      Sets the line number associated with the current error.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetErrorLine(tls *libc.TLS, interp uintptr, value int32) {
	(*TInterp)(unsafe.Pointer(interp)).FerrorLine = value
}

/*
 *----------------------------------------------------------------------
 *
 * GetKeys --
 *
 *	Returns a Tcl_Obj * array of the standard keys used in the return
 *	options dictionary.
 *
 *	Broadly sharing one copy of these key values helps with both memory
 *	efficiency and dictionary lookup times.
 *
 * Results:
 *	A Tcl_Obj * array.
 *
 * Side effects:
 *	First time called in a thread, creates the keys (allocating memory)
 *	and arranges for their cleanup at thread exit.
 *
 *----------------------------------------------------------------------
 */

func _GetKeys(tls *libc.TLS) (r uintptr) {
	var cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, keys uintptr
	var i int32
	var v1, v2, v3, v4, v5, v6, v7 bool
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, i, keys, v1, v2, v3, v4, v5, v6, v7
	keys = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_returnKeysKey)), libc.Int64FromUint64(uint64(KEY_LAST)*libc.Uint64FromInt64(8)))
	if *(*uintptr)(unsafe.Pointer(keys)) == libc.UintptrFromInt32(0) {
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_CODE)*8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_CODE)*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_CODE)*8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_CODE)*8)))).FrefCount = 0
		if libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_CODE)*8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_CODE)*8)))).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_CODE)*8)))).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_CODE)*8)))).Fbytes, __ccgo_ts+30753, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_CODE)*8)))).Fbytes + uintptr(libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_CODE)*8)))).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(6) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_CODE)*8)))).FtypePtr = libc.UintptrFromInt32(0)
		if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORCODE)*8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORCODE)*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORCODE)*8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORCODE)*8)))).FrefCount = 0
		if libc.Uint64FromInt64(11)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORCODE)*8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORCODE)*8)))).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORCODE)*8)))).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(11)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORCODE)*8)))).Fbytes, __ccgo_ts+15231, libc.Uint64FromInt64(11)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORCODE)*8)))).Fbytes + uintptr(libc.Uint64FromInt64(11)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORCODE)*8)))).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(11) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORCODE)*8)))).FtypePtr = libc.UintptrFromInt32(0)
		if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
			cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORINFO)*8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORINFO)*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORINFO)*8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORINFO)*8)))).FrefCount = 0
		if libc.Uint64FromInt64(11)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORINFO)*8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORINFO)*8)))).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORINFO)*8)))).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(11)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORINFO)*8)))).Fbytes, __ccgo_ts+15220, libc.Uint64FromInt64(11)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORINFO)*8)))).Fbytes + uintptr(libc.Uint64FromInt64(11)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORINFO)*8)))).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(11) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORINFO)*8)))).FtypePtr = libc.UintptrFromInt32(0)
		if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
			cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORLINE)*8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORLINE)*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORLINE)*8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORLINE)*8)))).FrefCount = 0
		if libc.Uint64FromInt64(11)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORLINE)*8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORLINE)*8)))).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORLINE)*8)))).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(11)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORLINE)*8)))).Fbytes, __ccgo_ts+64958, libc.Uint64FromInt64(11)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORLINE)*8)))).Fbytes + uintptr(libc.Uint64FromInt64(11)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORLINE)*8)))).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(11) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORLINE)*8)))).FtypePtr = libc.UintptrFromInt32(0)
		if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
			cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v5 || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORSTACK)*8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORSTACK)*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORSTACK)*8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORSTACK)*8)))).FrefCount = 0
		if libc.Uint64FromInt64(12)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORSTACK)*8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORSTACK)*8)))).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORSTACK)*8)))).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(12)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORSTACK)*8)))).Fbytes, __ccgo_ts+64969, libc.Uint64FromInt64(12)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORSTACK)*8)))).Fbytes + uintptr(libc.Uint64FromInt64(12)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORSTACK)*8)))).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(12) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORSTACK)*8)))).FtypePtr = libc.UintptrFromInt32(0)
		if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
			cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v6 || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_LEVEL)*8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_LEVEL)*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_LEVEL)*8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_LEVEL)*8)))).FrefCount = 0
		if libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_LEVEL)*8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_LEVEL)*8)))).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_LEVEL)*8)))).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_LEVEL)*8)))).Fbytes, __ccgo_ts+30715, libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_LEVEL)*8)))).Fbytes + uintptr(libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_LEVEL)*8)))).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(7) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_LEVEL)*8)))).FtypePtr = libc.UintptrFromInt32(0)
		if v7 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v7 {
			cachePtr6 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v7 || (*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_OPTIONS)*8)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_OPTIONS)*8)) = (*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_OPTIONS)*8)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_OPTIONS)*8)))).FrefCount = 0
		if libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_OPTIONS)*8)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_OPTIONS)*8)))).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_OPTIONS)*8)))).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_OPTIONS)*8)))).Fbytes, __ccgo_ts+21837, libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_OPTIONS)*8)))).Fbytes + uintptr(libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_OPTIONS)*8)))).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(9) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_OPTIONS)*8)))).FtypePtr = libc.UintptrFromInt32(0)
		i = int32(KEY_CODE)
		for {
			if !(i < int32(KEY_LAST)) {
				break
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(i)*8)))).FrefCount++
			goto _8
		_8:
			;
			i++
		}
		/*
		 * ... and arrange for their clenaup.
		 */
		XTcl_CreateThreadExitHandler(tls, __ccgo_fp(_ReleaseKeys), keys)
	}
	return keys
}

var _returnKeysKey TTcl_ThreadDataKey

/*
 *----------------------------------------------------------------------
 *
 * ReleaseKeys --
 *
 *	Called as a thread exit handler to cleanup return options dictionary
 *	keys.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Frees memory.
 *
 *----------------------------------------------------------------------
 */

func _ReleaseKeys(tls *libc.TLS, clientData uintptr) {
	var _objPtr, keys, v3 uintptr
	var i int32
	var v2 TTcl_Size
	_, _, _, _, _ = _objPtr, i, keys, v2, v3
	keys = clientData
	i = int32(KEY_CODE)
	for {
		if !(i < int32(KEY_LAST)) {
			break
		}
		_objPtr = *(*uintptr)(unsafe.Pointer(keys + uintptr(i)*8))
		v3 = _objPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		*(*uintptr)(unsafe.Pointer(keys + uintptr(i)*8)) = libc.UintptrFromInt32(0)
		goto _1
	_1:
		;
		i++
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclProcessReturn --
 *
 *	Does the work of the [return] command based on the code, level, and
 *	returnOpts arguments. Note that the code argument must agree with the
 *	-code entry in returnOpts and the level argument must agree with the
 *	-level entry in returnOpts, as is the case for values returned from
 *	TclMergeReturnOptions.
 *
 * Results:
 *	Returns the return code the [return] command should return.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclProcessReturn(tls *libc.TLS, interp uintptr, code int32, level int32, returnOpts uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var _objPtr, _objPtr1, _objPtr2, iPtr, keys, newObj, v2, v4, v7 uintptr
	var v1, v3, v6 TTcl_Size
	var v10, v12, v9 int64
	var v8 int32
	var _ /* len at bp+16 */ TTcl_Size
	var _ /* length at bp+8 */ TTcl_Size
	var _ /* valueObjc at bp+24 */ TTcl_Size
	var _ /* valueObjv at bp+32 */ uintptr
	var _ /* valuePtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, iPtr, keys, newObj, v1, v10, v12, v2, v3, v4, v6, v7, v8, v9
	iPtr = interp
	keys = _GetKeys(tls)
	/*
	 * Store the merged return options.
	 */
	if (*TInterp)(unsafe.Pointer(iPtr)).FreturnOpts != returnOpts {
		if (*TInterp)(unsafe.Pointer(iPtr)).FreturnOpts != 0 {
			_objPtr = (*TInterp)(unsafe.Pointer(iPtr)).FreturnOpts
			v2 = _objPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if v1 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
		(*TInterp)(unsafe.Pointer(iPtr)).FreturnOpts = returnOpts
		(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FreturnOpts)).FrefCount++
	}
	if code == int32(TCL_ERROR) {
		if (*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo != 0 {
			_objPtr1 = (*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo
			v4 = _objPtr1
			v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
			*(*TTcl_Size)(unsafe.Pointer(v4))--
			if v3 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
			(*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo = libc.UintptrFromInt32(0)
		}
		XTcl_DictObjGet(tls, libc.UintptrFromInt32(0), (*TInterp)(unsafe.Pointer(iPtr)).FreturnOpts, *(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORINFO)*8)), bp)
		if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Flength
				_ = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes
			} else {
				XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+8)
			}
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) != 0 {
				(*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo = *(*uintptr)(unsafe.Pointer(bp))
				(*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo)).FrefCount++
				*(*int32)(unsafe.Pointer(iPtr + 368)) |= int32(ERR_ALREADY_LOGGED)
			}
		}
		XTcl_DictObjGet(tls, libc.UintptrFromInt32(0), (*TInterp)(unsafe.Pointer(iPtr)).FreturnOpts, *(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORSTACK)*8)), bp)
		if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FerrorStack)).FrefCount > int64(1) {
				newObj = XTcl_DuplicateObj(tls, (*TInterp)(unsafe.Pointer(iPtr)).FerrorStack)
				_objPtr2 = (*TInterp)(unsafe.Pointer(iPtr)).FerrorStack
				v7 = _objPtr2
				v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
				*(*TTcl_Size)(unsafe.Pointer(v7))--
				if v6 <= int64(1) {
					XTclFreeObj(tls, _objPtr2)
				}
				(*TTcl_Obj)(unsafe.Pointer(newObj)).FrefCount++
				(*TInterp)(unsafe.Pointer(iPtr)).FerrorStack = newObj
			}
			/*
			 * List extraction done after duplication to avoid moving the rug
			 * if someone does [return -errorstack [info errorstack]]
			 */
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr2 != 0 {
					v9 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr2)).FspanStart
				} else {
					v9 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr1)).FfirstUsed
				}
				*(*uintptr)(unsafe.Pointer(bp + 32)) = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr1 + 40 + uintptr(v9)*8
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr2 != 0 {
					v10 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr2)).FspanLength
				} else {
					v10 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = v10
				v8 = libc.Int32FromInt32(TCL_OK)
			} else {
				v8 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), bp+24, bp+32)
			}
			if v8 == int32(TCL_ERROR) {
				return int32(TCL_ERROR)
			}
			(*TInterp)(unsafe.Pointer(iPtr)).FresetErrorStack = 0
			if (*TTcl_Obj)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FerrorStack)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FerrorStack + 32))).Fptr2 != 0 {
					v12 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FerrorStack + 32))).Fptr2)).FspanLength
				} else {
					v12 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FerrorStack + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = v12
				_ = libc.Int32FromInt32(TCL_OK)
			} else {
				XTcl_ListObjLength(tls, interp, (*TInterp)(unsafe.Pointer(iPtr)).FerrorStack, bp+16)
			}
			/*
			 * Reset while keeping the list internalrep as much as possible.
			 */
			XTcl_ListObjReplace(tls, interp, (*TInterp)(unsafe.Pointer(iPtr)).FerrorStack, 0, *(*TTcl_Size)(unsafe.Pointer(bp + 16)), *(*TTcl_Size)(unsafe.Pointer(bp + 24)), *(*uintptr)(unsafe.Pointer(bp + 32)))
		}
		XTcl_DictObjGet(tls, libc.UintptrFromInt32(0), (*TInterp)(unsafe.Pointer(iPtr)).FreturnOpts, *(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORCODE)*8)), bp)
		if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
			XTcl_SetObjErrorCode(tls, interp, *(*uintptr)(unsafe.Pointer(bp)))
		} else {
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+48, __ccgo_ts+8881, libc.UintptrFromInt32(0)))
		}
		XTcl_DictObjGet(tls, libc.UintptrFromInt32(0), (*TInterp)(unsafe.Pointer(iPtr)).FreturnOpts, *(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORLINE)*8)), bp)
		if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
				*(*int32)(unsafe.Pointer(iPtr + 16)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FinternalRep)))
				_ = libc.Int32FromInt32(TCL_OK)
			} else {
				XTcl_GetIntFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), iPtr+16)
			}
		}
	}
	if level != 0 {
		(*TInterp)(unsafe.Pointer(iPtr)).FreturnLevel = level
		(*TInterp)(unsafe.Pointer(iPtr)).FreturnCode = code
		return int32(TCL_RETURN)
	}
	if code == int32(TCL_ERROR) {
		*(*int32)(unsafe.Pointer(iPtr + 368)) |= int32(ERR_LEGACY_COPY)
	}
	return code
}

/*
 *----------------------------------------------------------------------
 *
 * TclMergeReturnOptions --
 *
 *	Parses, checks, and stores the options to the [return] command.
 *
 * Results:
 *	Returns TCL_ERROR if any of the option values are invalid. Otherwise,
 *	returns TCL_OK, and writes the returnOpts, code, and level values to
 *	the pointers provided.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclMergeReturnOptions(tls *libc.TLS, interp uintptr, objc int32, objv uintptr, optionsPtrPtr uintptr, codePtr uintptr, levelPtr uintptr) (r int32) {
	bp := tls.Alloc(112)
	defer tls.Free(112) /* If not NULL, points to space where the
	 * -level value should be written. */
	var _objPtr, _objPtr1, cachePtr, compare, dict, keys, opt, returnOpts, v10, v13, v14, v16, v18, v3, v4, v5, v7 uintptr
	var v1 bool
	var v11, v6, v8 int32
	var v12, v9 int64
	var v15, v17 TTcl_Size
	var _ /* code at bp+0 */ int32
	var _ /* done at bp+40 */ int32
	var _ /* keyPtr at bp+48 */ uintptr
	var _ /* length at bp+56 */ TTcl_Size
	var _ /* length at bp+64 */ TTcl_Size
	var _ /* level at bp+4 */ int32
	var _ /* search at bp+16 */ TTcl_DictSearch
	var _ /* valuePtr at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, compare, dict, keys, opt, returnOpts, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v3, v4, v5, v6, v7, v8, v9
	*(*int32)(unsafe.Pointer(bp)) = TCL_OK
	*(*int32)(unsafe.Pointer(bp + 4)) = int32(1)
	keys = _GetKeys(tls)
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		returnOpts = XTclThreadAllocObj(tls)
	} else {
		returnOpts = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(returnOpts + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(returnOpts)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(returnOpts)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(returnOpts)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(returnOpts)).FtypePtr = libc.UintptrFromInt32(0)
	for {
		if !(objc > int32(1)) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes != 0 {
			v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv)), libc.UintptrFromInt32(0))
		}
		opt = v3
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_OPTIONS)*8)))).Fbytes != 0 {
			v4 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_OPTIONS)*8)))).Fbytes
		} else {
			v4 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_OPTIONS)*8)), libc.UintptrFromInt32(0))
		}
		compare = v4
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Flength == (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_OPTIONS)*8)))).Flength && libc.Xmemcmp(tls, opt, compare, libc.Uint64FromInt64((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Flength)) == 0 {
			*(*int32)(unsafe.Pointer(bp + 40)) = 0
			dict = *(*uintptr)(unsafe.Pointer(objv + 1*8))
			goto nestedOptions
		nestedOptions:
			;
			if int32(TCL_ERROR) == XTcl_DictObjFirst(tls, libc.UintptrFromInt32(0), dict, bp+16, bp+48, bp+8, bp+40) {
				/*
				 * Value is not a legal dictionary.
				 */
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
					v5 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
				} else {
					v5 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
				}
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+64981, libc.VaList(bp+80, compare, v5)))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+80, __ccgo_ts+2004, __ccgo_ts+38216, __ccgo_ts+65028, libc.UintptrFromInt32(0)))
				goto error
			}
			for !(*(*int32)(unsafe.Pointer(bp + 40)) != 0) {
				XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), returnOpts, *(*uintptr)(unsafe.Pointer(bp + 48)), *(*uintptr)(unsafe.Pointer(bp + 8)))
				XTcl_DictObjNext(tls, bp+16, bp+48, bp+8, bp+40)
			}
			XTcl_DictObjGet(tls, libc.UintptrFromInt32(0), returnOpts, *(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_OPTIONS)*8)), bp+8)
			if *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) {
				dict = *(*uintptr)(unsafe.Pointer(bp + 8))
				XTcl_DictObjRemove(tls, libc.UintptrFromInt32(0), returnOpts, *(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_OPTIONS)*8)))
				goto nestedOptions
			}
		} else {
			XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), returnOpts, *(*uintptr)(unsafe.Pointer(objv)), *(*uintptr)(unsafe.Pointer(objv + 1*8)))
		}
		goto _2
	_2:
		;
		objv += uintptr(2) * 8
		objc -= int32(2)
	}
	/*
	 * Check for bogus -code value.
	 */
	XTcl_DictObjGet(tls, libc.UintptrFromInt32(0), returnOpts, *(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_CODE)*8)), bp+8)
	if *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) {
		if XTclGetCompletionCodeFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 8)), bp) == int32(TCL_ERROR) {
			goto error
		}
		XTcl_DictObjRemove(tls, libc.UintptrFromInt32(0), returnOpts, *(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_CODE)*8)))
	}
	/*
	 * Check for bogus -level value.
	 */
	XTcl_DictObjGet(tls, libc.UintptrFromInt32(0), returnOpts, *(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_LEVEL)*8)), bp+8)
	if *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
			*(*int32)(unsafe.Pointer(bp + 4)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FinternalRep)))
			v6 = libc.Int32FromInt32(TCL_OK)
		} else {
			v6 = XTcl_GetIntFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 8)), bp+4)
		}
		if int32(TCL_ERROR) == v6 || *(*int32)(unsafe.Pointer(bp + 4)) < 0 {
			/*
			 * Value is not a legal level.
			 */
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != 0 {
				v7 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes
			} else {
				v7 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+65044, libc.VaList(bp+80, v7)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+80, __ccgo_ts+2004, __ccgo_ts+38216, __ccgo_ts+65105, libc.UintptrFromInt32(0)))
			goto error
		}
		XTcl_DictObjRemove(tls, libc.UintptrFromInt32(0), returnOpts, *(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_LEVEL)*8)))
	}
	/*
	 * Check for bogus -errorcode value.
	 */
	XTcl_DictObjGet(tls, libc.UintptrFromInt32(0), returnOpts, *(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORCODE)*8)), bp+8)
	if *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr2 != 0 {
				v9 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr2)).FspanLength
			} else {
				v9 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 56)) = v9
			v8 = libc.Int32FromInt32(TCL_OK)
		} else {
			v8 = XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 8)), bp+56)
		}
		if int32(TCL_ERROR) == v8 {
			/*
			 * Value is not a list, which is illegal for -errorcode.
			 */
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != 0 {
				v10 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes
			} else {
				v10 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+65119, libc.VaList(bp+80, v10)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+80, __ccgo_ts+2004, __ccgo_ts+38216, __ccgo_ts+65170, libc.UintptrFromInt32(0)))
			goto error
		}
	}
	/*
	 * Check for bogus -errorstack value.
	 */
	XTcl_DictObjGet(tls, libc.UintptrFromInt32(0), returnOpts, *(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORSTACK)*8)), bp+8)
	if *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr2 != 0 {
				v12 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr2)).FspanLength
			} else {
				v12 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 64)) = v12
			v11 = libc.Int32FromInt32(TCL_OK)
		} else {
			v11 = XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 8)), bp+64)
		}
		if int32(TCL_ERROR) == v11 {
			/*
			 * Value is not a list, which is illegal for -errorstack.
			 */
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != 0 {
				v13 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes
			} else {
				v13 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+65188, libc.VaList(bp+80, v13)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+80, __ccgo_ts+2004, __ccgo_ts+38216, __ccgo_ts+65240, libc.UintptrFromInt32(0)))
			goto error
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 64))%int64(2) != 0 {
			/*
			 * Errorstack must always be an even-sized list
			 */
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes != 0 {
				v14 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fbytes
			} else {
				v14 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+65259, libc.VaList(bp+80, v14)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+80, __ccgo_ts+2004, __ccgo_ts+38216, __ccgo_ts+65306, libc.UintptrFromInt32(0)))
			goto error
		}
	}
	/*
	 * Convert [return -code return -level X] to [return -code ok -level X+1]
	 */
	if *(*int32)(unsafe.Pointer(bp)) == int32(TCL_RETURN) {
		*(*int32)(unsafe.Pointer(bp + 4))++
		*(*int32)(unsafe.Pointer(bp)) = TCL_OK
	}
	if codePtr != libc.UintptrFromInt32(0) {
		*(*int32)(unsafe.Pointer(codePtr)) = *(*int32)(unsafe.Pointer(bp))
	}
	if levelPtr != libc.UintptrFromInt32(0) {
		*(*int32)(unsafe.Pointer(levelPtr)) = *(*int32)(unsafe.Pointer(bp + 4))
	}
	if optionsPtrPtr == libc.UintptrFromInt32(0) {
		/*
		 * Not passing back the options (?!), so clean them up.
		 */
		_objPtr = returnOpts
		v16 = _objPtr
		v15 = *(*TTcl_Size)(unsafe.Pointer(v16))
		*(*TTcl_Size)(unsafe.Pointer(v16))--
		if v15 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	} else {
		*(*uintptr)(unsafe.Pointer(optionsPtrPtr)) = returnOpts
	}
	return TCL_OK
	goto error
error:
	;
	_objPtr1 = returnOpts
	v18 = _objPtr1
	v17 = *(*TTcl_Size)(unsafe.Pointer(v18))
	*(*TTcl_Size)(unsafe.Pointer(v18))--
	if v17 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	return int32(TCL_ERROR)
}

/*
 *-------------------------------------------------------------------------
 *
 * Tcl_GetReturnOptions --
 *
 *	Packs up the interp state into a dictionary of return options.
 *
 * Results:
 *	A dictionary of return options.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func XTcl_GetReturnOptions(tls *libc.TLS, interp uintptr, result int32) (r uintptr) {
	var cachePtr, iPtr, keys, options uintptr
	var v1 bool
	_, _, _, _, _ = cachePtr, iPtr, keys, options, v1
	iPtr = interp
	keys = _GetKeys(tls)
	if (*TInterp)(unsafe.Pointer(iPtr)).FreturnOpts != 0 {
		options = XTcl_DuplicateObj(tls, (*TInterp)(unsafe.Pointer(iPtr)).FreturnOpts)
	} else {
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			options = XTclThreadAllocObj(tls)
		} else {
			options = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(options + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(options)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(options)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(options)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(options)).FtypePtr = libc.UintptrFromInt32(0)
	}
	if result == int32(TCL_RETURN) {
		XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), options, *(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_CODE)*8)), XTcl_NewWideIntObj(tls, int64((*TInterp)(unsafe.Pointer(iPtr)).FreturnCode)))
		XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), options, *(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_LEVEL)*8)), XTcl_NewWideIntObj(tls, int64((*TInterp)(unsafe.Pointer(iPtr)).FreturnLevel)))
	} else {
		XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), options, *(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_CODE)*8)), XTcl_NewWideIntObj(tls, int64(result)))
		XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), options, *(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_LEVEL)*8)), XTcl_NewWideIntObj(tls, 0))
	}
	if result == int32(TCL_ERROR) {
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+1945, int64(-int32(1))))
		XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), options, *(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORSTACK)*8)), (*TInterp)(unsafe.Pointer(iPtr)).FerrorStack)
	}
	if (*TInterp)(unsafe.Pointer(iPtr)).FerrorCode != 0 {
		XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), options, *(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORCODE)*8)), (*TInterp)(unsafe.Pointer(iPtr)).FerrorCode)
	}
	if (*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo != 0 {
		XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), options, *(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORINFO)*8)), (*TInterp)(unsafe.Pointer(iPtr)).FerrorInfo)
		XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), options, *(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORLINE)*8)), XTcl_NewWideIntObj(tls, int64((*TInterp)(unsafe.Pointer(iPtr)).FerrorLine)))
	}
	return options
}

/*
 *-------------------------------------------------------------------------
 *
 * TclNoErrorStack --
 *
 *	Removes the -errorstack entry from an options dict to avoid reference
 *	cycles.
 *
 * Results:
 *	The (unshared) argument options dict, modified in -place.
 *
 *-------------------------------------------------------------------------
 */

func XTclNoErrorStack(tls *libc.TLS, interp uintptr, options uintptr) (r uintptr) {
	var keys uintptr
	_ = keys
	keys = _GetKeys(tls)
	XTcl_DictObjRemove(tls, interp, options, *(*uintptr)(unsafe.Pointer(keys + uintptr(KEY_ERRORSTACK)*8)))
	return options
}

/*
 *-------------------------------------------------------------------------
 *
 * Tcl_SetReturnOptions --
 *
 *	Accepts an interp and a dictionary of return options, and sets the
 *	return options of the interp to match the dictionary.
 *
 * Results:
 *	A standard status code. Usually TCL_OK, but TCL_ERROR if an invalid
 *	option value was found in the dictionary. If a -level value of 0 is in
 *	the dictionary, then the -code value in the dictionary will be
 *	returned (TCL_OK default).
 *
 * Side effects:
 *	Sets the state of the interp.
 *
 *-------------------------------------------------------------------------
 */

func XTcl_SetReturnOptions(tls *libc.TLS, interp uintptr, options uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var _objPtr, v4, v6 uintptr
	var v1 int32
	var v2, v3 int64
	var v5 TTcl_Size
	var _ /* code at bp+12 */ int32
	var _ /* level at bp+8 */ int32
	var _ /* mergedOpts at bp+24 */ uintptr
	var _ /* objc at bp+0 */ TTcl_Size
	var _ /* objv at bp+16 */ uintptr
	_, _, _, _, _, _, _ = _objPtr, v1, v2, v3, v4, v5, v6
	(*TTcl_Obj)(unsafe.Pointer(options)).FrefCount++
	if (*TTcl_Obj)(unsafe.Pointer(options)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(options + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(options + 32))).Fptr2)).FspanStart
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(options + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 16)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(options + 32))).Fptr1 + 40 + uintptr(v2)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(options + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(options + 32))).Fptr2)).FspanLength
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(options + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v3
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjGetElements(tls, interp, options, bp, bp+16)
	}
	if int32(TCL_ERROR) == v1 || *(*TTcl_Size)(unsafe.Pointer(bp))%int64(2) != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(options)).Fbytes != 0 {
			v4 = (*TTcl_Obj)(unsafe.Pointer(options)).Fbytes
		} else {
			v4 = XTcl_GetStringFromObj(tls, options, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+65330, libc.VaList(bp+40, v4)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+38216, __ccgo_ts+65028, libc.UintptrFromInt32(0)))
		*(*int32)(unsafe.Pointer(bp + 12)) = int32(TCL_ERROR)
	} else {
		if int32(TCL_ERROR) == XTclMergeReturnOptions(tls, interp, int32(*(*TTcl_Size)(unsafe.Pointer(bp))), *(*uintptr)(unsafe.Pointer(bp + 16)), bp+24, bp+12, bp+8) {
			*(*int32)(unsafe.Pointer(bp + 12)) = int32(TCL_ERROR)
		} else {
			*(*int32)(unsafe.Pointer(bp + 12)) = XTclProcessReturn(tls, interp, *(*int32)(unsafe.Pointer(bp + 12)), *(*int32)(unsafe.Pointer(bp + 8)), *(*uintptr)(unsafe.Pointer(bp + 24)))
		}
	}
	_objPtr = options
	v6 = _objPtr
	v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
	*(*TTcl_Size)(unsafe.Pointer(v6))--
	if v5 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return *(*int32)(unsafe.Pointer(bp + 12))
}

/*
 *-------------------------------------------------------------------------
 *
 * Tcl_TransferResult --
 *
 *	Transfer the result (and error information) from one interp to another.
 *	Used when one interp has caused another interp to evaluate a script
 *	and then wants to transfer the results back to itself.
 *
 * Results:
 *	The result of targetInterp is set to the result read from sourceInterp.
 *	The return options dictionary of sourceInterp is transferred to
 *	targetInterp as appropriate for the return code value code.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func XTcl_TransferResult(tls *libc.TLS, sourceInterp uintptr, code int32, targetInterp uintptr) {
	/* Interp where result and return options
	 * should be stored. If source and target are
	 * the same, nothing is done. */
	var _objPtr, siPtr, tiPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _, _ = _objPtr, siPtr, tiPtr, v1, v2
	tiPtr = targetInterp
	siPtr = sourceInterp
	if sourceInterp == targetInterp {
		return
	}
	if code == TCL_OK && (*TInterp)(unsafe.Pointer(siPtr)).FreturnOpts == libc.UintptrFromInt32(0) {
		/*
		 * Special optimization for the common case of normal command return
		 * code and no explicit return options.
		 */
		if (*TInterp)(unsafe.Pointer(tiPtr)).FreturnOpts != 0 {
			_objPtr = (*TInterp)(unsafe.Pointer(tiPtr)).FreturnOpts
			v2 = _objPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if v1 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			(*TInterp)(unsafe.Pointer(tiPtr)).FreturnOpts = libc.UintptrFromInt32(0)
		}
	} else {
		XTcl_SetReturnOptions(tls, targetInterp, XTcl_GetReturnOptions(tls, sourceInterp, code))
		*(*int32)(unsafe.Pointer(tiPtr + 368)) &= ^libc.Int32FromInt32(ERR_ALREADY_LOGGED)
	}
	XTcl_SetObjResult(tls, targetInterp, XTcl_GetObjResult(tls, sourceInterp))
	XTcl_ResetResult(tls, sourceInterp)
}

/*
 * Flag values used by Tcl_ScanObjCmd.
 */
type ScanFlags = int32

const SCAN_NOSKIP = 1
const /* Don't skip blanks. */
SCAN_SUPPRESS = 2
const /* Suppress assignment. */
SCAN_UNSIGNED = 4
const /* Read an unsigned value. */
SCAN_WIDTH = 8
const /* A width value was supplied. */

SCAN_LONGER = 1024
const /* Asked for a wide value. */
SCAN_BIG = 2048

/*
 * The following structure contains the information associated with a
 * character set.
 */

type TRange = struct {
	Fstart TTcl_UniChar
	Fend   TTcl_UniChar
}

type TCharSet = struct {
	Fexclude int32
	Fnchars  int32
	Fchars   uintptr
	Fnranges int32
	Franges  uintptr
}

/*
 *----------------------------------------------------------------------
 *
 * BuildCharSet --
 *
 *	This function examines a character set format specification and builds
 *	a CharSet containing the individual characters and character ranges
 *	specified.
 *
 * Results:
 *	Returns the next format position.
 *
 * Side effects:
 *	Initializes the charset.
 *
 *----------------------------------------------------------------------
 */

func _BuildCharSet(tls *libc.TLS, cset uintptr, format uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Points to first char of set. */
	var end, v11, v13, v16, v8 uintptr
	var nranges, offset, v10, v12, v15, v5, v7 int32
	var start TTcl_UniChar
	var v1, v14, v17, v2, v3, v4, v6, v9 int64
	var _ /* ch at bp+0 */ TTcl_UniChar
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = end, nranges, offset, start, v1, v10, v11, v12, v13, v14, v15, v16, v17, v2, v3, v4, v5, v6, v7, v8, v9
	*(*TTcl_UniChar)(unsafe.Pointer(bp)) = 0
	libc.Xmemset(tls, cset, 0, uint64(32))
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format))) < int32(0x80) {
		*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format)))
		v1 = int64(libc.Int32FromInt32(1))
	} else {
		v1 = XTcl_UtfToUniChar(tls, format, bp)
	}
	offset = int32(v1)
	if *(*TTcl_UniChar)(unsafe.Pointer(bp)) == int32('^') {
		(*TCharSet)(unsafe.Pointer(cset)).Fexclude = int32(1)
		format += uintptr(offset)
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format)))
			v2 = int64(libc.Int32FromInt32(1))
		} else {
			v2 = XTcl_UtfToUniChar(tls, format, bp)
		}
		offset = int32(v2)
	}
	end = format + uintptr(offset)
	/*
	 * Find the close bracket so we can overallocate the set.
	 */
	if *(*TTcl_UniChar)(unsafe.Pointer(bp)) == int32(']') {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(end))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(end)))
			v3 = int64(libc.Int32FromInt32(1))
		} else {
			v3 = XTcl_UtfToUniChar(tls, end, bp)
		}
		end += uintptr(v3)
	}
	nranges = 0
	for *(*TTcl_UniChar)(unsafe.Pointer(bp)) != int32(']') {
		if *(*TTcl_UniChar)(unsafe.Pointer(bp)) == int32('-') {
			nranges++
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(end))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(end)))
			v4 = int64(libc.Int32FromInt32(1))
		} else {
			v4 = XTcl_UtfToUniChar(tls, end, bp)
		}
		end += uintptr(v4)
	}
	(*TCharSet)(unsafe.Pointer(cset)).Fchars = XTcl_Alloc(tls, uint64(4)*libc.Uint64FromInt64(int64(end)-int64(format)-libc.Int64FromInt32(1)))
	if nranges > 0 {
		(*TCharSet)(unsafe.Pointer(cset)).Franges = XTcl_Alloc(tls, uint64(8)*libc.Uint64FromInt32(nranges))
	} else {
		(*TCharSet)(unsafe.Pointer(cset)).Franges = libc.UintptrFromInt32(0)
	}
	/*
	 * Now build the character set.
	 */
	v5 = libc.Int32FromInt32(0)
	(*TCharSet)(unsafe.Pointer(cset)).Fnranges = v5
	(*TCharSet)(unsafe.Pointer(cset)).Fnchars = v5
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format))) < int32(0x80) {
		*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format)))
		v6 = int64(libc.Int32FromInt32(1))
	} else {
		v6 = XTcl_UtfToUniChar(tls, format, bp)
	}
	format += uintptr(v6)
	start = *(*TTcl_UniChar)(unsafe.Pointer(bp))
	if *(*TTcl_UniChar)(unsafe.Pointer(bp)) == int32(']') || *(*TTcl_UniChar)(unsafe.Pointer(bp)) == int32('-') {
		v8 = cset + 4
		v7 = *(*int32)(unsafe.Pointer(v8))
		*(*int32)(unsafe.Pointer(v8))++
		*(*TTcl_UniChar)(unsafe.Pointer((*TCharSet)(unsafe.Pointer(cset)).Fchars + uintptr(v7)*4)) = *(*TTcl_UniChar)(unsafe.Pointer(bp))
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format)))
			v9 = int64(libc.Int32FromInt32(1))
		} else {
			v9 = XTcl_UtfToUniChar(tls, format, bp)
		}
		format += uintptr(v9)
	}
	for *(*TTcl_UniChar)(unsafe.Pointer(bp)) != int32(']') {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format))) == int32('-') {
			/*
			 * This may be the first character of a range, so don't add it
			 * yet.
			 */
			start = *(*TTcl_UniChar)(unsafe.Pointer(bp))
		} else {
			if *(*TTcl_UniChar)(unsafe.Pointer(bp)) == int32('-') {
				/*
				 * Check to see if this is the last character in the set, in which
				 * case it is not a range and we should add the previous character
				 * as well as the dash.
				 */
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format))) == int32(']') || !((*TCharSet)(unsafe.Pointer(cset)).Franges != 0) {
					v11 = cset + 4
					v10 = *(*int32)(unsafe.Pointer(v11))
					*(*int32)(unsafe.Pointer(v11))++
					*(*TTcl_UniChar)(unsafe.Pointer((*TCharSet)(unsafe.Pointer(cset)).Fchars + uintptr(v10)*4)) = start
					v13 = cset + 4
					v12 = *(*int32)(unsafe.Pointer(v13))
					*(*int32)(unsafe.Pointer(v13))++
					*(*TTcl_UniChar)(unsafe.Pointer((*TCharSet)(unsafe.Pointer(cset)).Fchars + uintptr(v12)*4)) = *(*TTcl_UniChar)(unsafe.Pointer(bp))
				} else {
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format))) < int32(0x80) {
						*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format)))
						v14 = int64(libc.Int32FromInt32(1))
					} else {
						v14 = XTcl_UtfToUniChar(tls, format, bp)
					}
					format += uintptr(v14)
					/*
					 * Check to see if the range is in reverse order.
					 */
					if start < *(*TTcl_UniChar)(unsafe.Pointer(bp)) {
						(*(*TRange)(unsafe.Pointer((*TCharSet)(unsafe.Pointer(cset)).Franges + uintptr((*TCharSet)(unsafe.Pointer(cset)).Fnranges)*8))).Fstart = start
						(*(*TRange)(unsafe.Pointer((*TCharSet)(unsafe.Pointer(cset)).Franges + uintptr((*TCharSet)(unsafe.Pointer(cset)).Fnranges)*8))).Fend = *(*TTcl_UniChar)(unsafe.Pointer(bp))
					} else {
						(*(*TRange)(unsafe.Pointer((*TCharSet)(unsafe.Pointer(cset)).Franges + uintptr((*TCharSet)(unsafe.Pointer(cset)).Fnranges)*8))).Fstart = *(*TTcl_UniChar)(unsafe.Pointer(bp))
						(*(*TRange)(unsafe.Pointer((*TCharSet)(unsafe.Pointer(cset)).Franges + uintptr((*TCharSet)(unsafe.Pointer(cset)).Fnranges)*8))).Fend = start
					}
					(*TCharSet)(unsafe.Pointer(cset)).Fnranges++
				}
			} else {
				v16 = cset + 4
				v15 = *(*int32)(unsafe.Pointer(v16))
				*(*int32)(unsafe.Pointer(v16))++
				*(*TTcl_UniChar)(unsafe.Pointer((*TCharSet)(unsafe.Pointer(cset)).Fchars + uintptr(v15)*4)) = *(*TTcl_UniChar)(unsafe.Pointer(bp))
			}
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format)))
			v17 = int64(libc.Int32FromInt32(1))
		} else {
			v17 = XTcl_UtfToUniChar(tls, format, bp)
		}
		format += uintptr(v17)
	}
	return format
}

/*
 *----------------------------------------------------------------------
 *
 * CharInSet --
 *
 *	Check to see if a character matches the given set.
 *
 * Results:
 *	Returns non-zero if the character matches the given set.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _CharInSet(tls *libc.TLS, cset uintptr, c int32) (r int32) {
	/* Character to test, passed as int because of
	 * non-ANSI prototypes. */
	var ch TTcl_UniChar
	var i, match, v3 int32
	_, _, _, _ = ch, i, match, v3
	ch = c
	match = 0
	i = 0
	for {
		if !(i < (*TCharSet)(unsafe.Pointer(cset)).Fnchars) {
			break
		}
		if *(*TTcl_UniChar)(unsafe.Pointer((*TCharSet)(unsafe.Pointer(cset)).Fchars + uintptr(i)*4)) == ch {
			match = int32(1)
			break
		}
		goto _1
	_1:
		;
		i++
	}
	if !(match != 0) {
		i = 0
		for {
			if !(i < (*TCharSet)(unsafe.Pointer(cset)).Fnranges) {
				break
			}
			if (*(*TRange)(unsafe.Pointer((*TCharSet)(unsafe.Pointer(cset)).Franges + uintptr(i)*8))).Fstart <= ch && ch <= (*(*TRange)(unsafe.Pointer((*TCharSet)(unsafe.Pointer(cset)).Franges + uintptr(i)*8))).Fend {
				match = int32(1)
				break
			}
			goto _2
		_2:
			;
			i++
		}
	}
	if (*TCharSet)(unsafe.Pointer(cset)).Fexclude != 0 {
		v3 = libc.BoolInt32(!(match != 0))
	} else {
		v3 = match
	}
	return v3
}

/*
 *----------------------------------------------------------------------
 *
 * ReleaseCharSet --
 *
 *	Free the storage associated with a character set.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _ReleaseCharSet(tls *libc.TLS, cset uintptr) {
	XTclpFree(tls, (*TCharSet)(unsafe.Pointer(cset)).Fchars)
	if (*TCharSet)(unsafe.Pointer(cset)).Franges != 0 {
		XTclpFree(tls, (*TCharSet)(unsafe.Pointer(cset)).Franges)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * ValidateFormat --
 *
 *	Parse the format string and verify that it is properly formed and that
 *	there are exactly enough variables on the command line.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	May place an error in the interpreter result.
 *
 *----------------------------------------------------------------------
 */

func _ValidateFormat(tls *libc.TLS, interp uintptr, _format uintptr, numVars int32, totalSubs uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	*(*uintptr)(unsafe.Pointer(bp)) = _format /* The number of variables that will be
	 * required. */
	var errorMsg, nassign uintptr
	var flags, gotSequential, gotXpg, i, nspace, nspaceOrig, objIndex, xpgSize, v11, v2, v3, v4 int32
	var ull, ull1 uint64
	var v10, v13, v14, v15, v16, v17, v37, v38, v39, v40, v7, v8, v9 int64
	var _ /* buf at bp+20 */ [5]uint8
	var _ /* ch at bp+16 */ TTcl_UniChar
	var _ /* end at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = errorMsg, flags, gotSequential, gotXpg, i, nassign, nspace, nspaceOrig, objIndex, ull, ull1, xpgSize, v10, v11, v13, v14, v15, v16, v17, v2, v3, v37, v38, v39, v4, v40, v7, v8, v9
	*(*TTcl_UniChar)(unsafe.Pointer(bp + 16)) = 0
	nspace = numVars
	nassign = XTclStackAlloc(tls, interp, libc.Uint64FromInt32(nspace)*uint64(4)) /* Place to build an error messages. Note that
	 * these are messy operations because we do
	 * not want to use the formatting engine;
	 * we're inside there! */
	*(*[5]uint8)(unsafe.Pointer(bp + 20)) = [5]uint8{}
	/*
	 * Initialize an array that records the number of times a variable is
	 * assigned to by the format string. We use this to detect if a variable
	 * is multiply assigned or left unassigned.
	 */
	i = 0
	for {
		if !(i < nspace) {
			break
		}
		*(*int32)(unsafe.Pointer(nassign + uintptr(i)*4)) = 0
		goto _1
	_1:
		;
		i++
	}
	v4 = libc.Int32FromInt32(0)
	gotSequential = v4
	v3 = v4
	gotXpg = v3
	v2 = v3
	objIndex = v2
	xpgSize = v2
_6:
	;
	if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32('\000')) {
		goto _5
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) < int32(0x80) {
		*(*TTcl_UniChar)(unsafe.Pointer(bp + 16)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))
		v7 = int64(libc.Int32FromInt32(1))
	} else {
		v7 = XTcl_UtfToUniChar(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+16)
	}
	*(*uintptr)(unsafe.Pointer(bp)) += uintptr(v7)
	flags = 0
	if *(*TTcl_UniChar)(unsafe.Pointer(bp + 16)) != int32('%') {
		goto _6
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) < int32(0x80) {
		*(*TTcl_UniChar)(unsafe.Pointer(bp + 16)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))
		v8 = int64(libc.Int32FromInt32(1))
	} else {
		v8 = XTcl_UtfToUniChar(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+16)
	}
	*(*uintptr)(unsafe.Pointer(bp)) += uintptr(v8)
	if *(*TTcl_UniChar)(unsafe.Pointer(bp + 16)) == int32('%') {
		goto _6
	}
	if *(*TTcl_UniChar)(unsafe.Pointer(bp + 16)) == int32('*') {
		flags |= int32(SCAN_SUPPRESS)
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 16)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))
			v9 = int64(libc.Int32FromInt32(1))
		} else {
			v9 = XTcl_UtfToUniChar(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+16)
		}
		*(*uintptr)(unsafe.Pointer(bp)) += uintptr(v9)
		goto xpgCheckDone
	}
	if *(*TTcl_UniChar)(unsafe.Pointer(bp + 16)) < int32(0x80) && libc.BoolInt32(uint32(libc.Uint8FromInt32(*(*TTcl_UniChar)(unsafe.Pointer(bp + 16))))-uint32('0') < uint32(10)) != 0 { /* INTL: "C" locale. */
		/*
		 * Check for an XPG3-style %n$ specification. Note: there must
		 * not be a mixture of XPG3 specs and non-XPG3 specs in the same
		 * format string.
		 */
		/* assert(value is >= 0) because of the isdigit() check above */
		ull = libc.Xstrtoull(tls, *(*uintptr)(unsafe.Pointer(bp))-uintptr(1), bp+8, int32(10)) /* INTL: "C" locale. */
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))) != int32('$') {
			goto notXpg
		}
		*(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(1)
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 16)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))
			v10 = int64(libc.Int32FromInt32(1))
		} else {
			v10 = XTcl_UtfToUniChar(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+16)
		}
		*(*uintptr)(unsafe.Pointer(bp)) += uintptr(v10)
		gotXpg = int32(1)
		if gotSequential != 0 {
			goto mixedXPG
		}
		/* >=INT_MAX because 9.0 does not support more than INT_MAX-1 args */
		if ull == uint64(0) || ull >= uint64(INT_MAX) {
			goto badIndex
		}
		objIndex = libc.Int32FromUint64(ull) - int32(1)
		if numVars != 0 && objIndex >= numVars {
			goto badIndex
		} else {
			if numVars == 0 {
				/*
				 * In the case where no vars are specified, the user can
				 * specify %9999$ legally, so we have to consider special
				 * rules for growing the assign array. 'ull' is guaranteed
				 * to be > 0 and < INT_MAX as per checks above.
				 */
				if xpgSize > libc.Int32FromUint64(ull) {
					v11 = xpgSize
				} else {
					v11 = libc.Int32FromUint64(ull)
				}
				xpgSize = v11
			}
		}
		goto xpgCheckDone
	}
	goto notXpg
notXpg:
	;
	gotSequential = int32(1)
	if !(gotXpg != 0) {
		goto _12
	}
	goto mixedXPG
mixedXPG:
	;
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+65357, int64(-int32(1))))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+65404, __ccgo_ts+65411, libc.UintptrFromInt32(0)))
	goto error
_12:
	;
	goto xpgCheckDone
xpgCheckDone:
	;
	/*
	 * Parse any width specifier.
	 */
	if *(*TTcl_UniChar)(unsafe.Pointer(bp + 16)) < int32(0x80) && libc.BoolInt32(uint32(libc.Uint8FromInt32(*(*TTcl_UniChar)(unsafe.Pointer(bp + 16))))-uint32('0') < uint32(10)) != 0 {
		ull1 = libc.Xstrtoull(tls, *(*uintptr)(unsafe.Pointer(bp))-uintptr(1), bp, int32(10)) /* INTL: "C" locale. */
		/* Note >=, not >, to leave room for a nul */
		if ull1 >= libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+65426, libc.VaList(bp+40, ull1, libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))-libc.Int64FromInt32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+65404, __ccgo_ts+65472, libc.UintptrFromInt32(0)))
			goto error
		}
		flags |= int32(SCAN_WIDTH)
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 16)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))
			v13 = int64(libc.Int32FromInt32(1))
		} else {
			v13 = XTcl_UtfToUniChar(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+16)
		}
		*(*uintptr)(unsafe.Pointer(bp)) += uintptr(v13)
	}
	/*
	 * Handle any size specifier.
	 */
	switch *(*TTcl_UniChar)(unsafe.Pointer(bp + 16)) {
	case int32('z'):
		fallthrough
	case int32('t'):
		if uint64(8) > uint64(4) {
			flags |= int32(SCAN_LONGER)
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 16)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))
			v14 = int64(libc.Int32FromInt32(1))
		} else {
			v14 = XTcl_UtfToUniChar(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+16)
		}
		*(*uintptr)(unsafe.Pointer(bp)) += uintptr(v14)
	case int32('L'):
		flags |= int32(SCAN_BIG)
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 16)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))
			v15 = int64(libc.Int32FromInt32(1))
		} else {
			v15 = XTcl_UtfToUniChar(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+16)
		}
		*(*uintptr)(unsafe.Pointer(bp)) += uintptr(v15)
	case int32('l'):
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('l') {
			flags |= int32(SCAN_BIG)
			*(*uintptr)(unsafe.Pointer(bp)) += uintptr(1)
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) < int32(0x80) {
				*(*TTcl_UniChar)(unsafe.Pointer(bp + 16)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))
				v16 = int64(libc.Int32FromInt32(1))
			} else {
				v16 = XTcl_UtfToUniChar(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+16)
			}
			*(*uintptr)(unsafe.Pointer(bp)) += uintptr(v16)
			break
		}
		/* FALLTHRU */
		fallthrough
	case int32('j'):
		fallthrough
	case int32('q'):
		flags |= int32(SCAN_LONGER)
		/* FALLTHRU */
		fallthrough
	case int32('h'):
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 16)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))
			v17 = int64(libc.Int32FromInt32(1))
		} else {
			v17 = XTcl_UtfToUniChar(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+16)
		}
		*(*uintptr)(unsafe.Pointer(bp)) += uintptr(v17)
	}
	if !(flags&int32(SCAN_SUPPRESS) != 0) && numVars != 0 && objIndex >= numVars {
		goto badIndex
	}
	/*
	 * Handle the various field types.
	 */
	switch *(*TTcl_UniChar)(unsafe.Pointer(bp + 16)) {
	case int32('c'):
		goto _18
	case int32('s'):
		goto _19
	case int32('n'):
		goto _20
	case int32('u'):
		goto _21
	case int32('b'):
		goto _22
	case int32('X'):
		goto _23
	case int32('x'):
		goto _24
	case int32('o'):
		goto _25
	case int32('i'):
		goto _26
	case int32('G'):
		goto _27
	case int32('g'):
		goto _28
	case int32('f'):
		goto _29
	case int32('E'):
		goto _30
	case int32('e'):
		goto _31
	case int32('d'):
		goto _32
	case int32('['):
		goto _33
	default:
		goto _34
	}
	goto _35
_18:
	;
	if flags&int32(SCAN_WIDTH) != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+65483, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+65404, __ccgo_ts+65533, libc.UintptrFromInt32(0)))
		goto error
	}
	/* FALLTHRU */
_20:
	;
_19:
	;
	if !(flags&(int32(SCAN_LONGER)|int32(SCAN_BIG)) != 0) {
		goto _36
	}
	goto invalidFieldSize
invalidFieldSize:
	;
	(*(*[5]uint8)(unsafe.Pointer(bp + 20)))[XTcl_UniCharToUtf(tls, *(*TTcl_UniChar)(unsafe.Pointer(bp + 16)), bp+20)] = uint8('\000')
	errorMsg = XTcl_NewStringObj(tls, __ccgo_ts+65542, int64(-int32(1)))
	XTcl_AppendToObj(tls, errorMsg, bp+20, int64(-int32(1)))
	XTcl_AppendToObj(tls, errorMsg, __ccgo_ts+65588, int64(-int32(1)))
	XTcl_SetObjResult(tls, interp, errorMsg)
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+65404, __ccgo_ts+65600, libc.UintptrFromInt32(0)))
	goto error
_36:
	;
	/*
	 * Fall through!
	 */
_32:
	;
_31:
	;
_30:
	;
_29:
	;
_28:
	;
_27:
	;
_26:
	;
_25:
	;
_24:
	;
_23:
	;
_22:
	;
_21:
	;
	goto _35
	/*
	 * Bracket terms need special checking
	 */
_33:
	;
	if flags&(int32(SCAN_LONGER)|int32(SCAN_BIG)) != 0 {
		goto invalidFieldSize
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('\000') {
		goto badSet
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) < int32(0x80) {
		*(*TTcl_UniChar)(unsafe.Pointer(bp + 16)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))
		v37 = int64(libc.Int32FromInt32(1))
	} else {
		v37 = XTcl_UtfToUniChar(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+16)
	}
	*(*uintptr)(unsafe.Pointer(bp)) += uintptr(v37)
	if *(*TTcl_UniChar)(unsafe.Pointer(bp + 16)) == int32('^') {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('\000') {
			goto badSet
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 16)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))
			v38 = int64(libc.Int32FromInt32(1))
		} else {
			v38 = XTcl_UtfToUniChar(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+16)
		}
		*(*uintptr)(unsafe.Pointer(bp)) += uintptr(v38)
	}
	if *(*TTcl_UniChar)(unsafe.Pointer(bp + 16)) == int32(']') {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('\000') {
			goto badSet
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 16)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))
			v39 = int64(libc.Int32FromInt32(1))
		} else {
			v39 = XTcl_UtfToUniChar(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+16)
		}
		*(*uintptr)(unsafe.Pointer(bp)) += uintptr(v39)
	}
	for *(*TTcl_UniChar)(unsafe.Pointer(bp + 16)) != int32(']') {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('\000') {
			goto badSet
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 16)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))
			v40 = int64(libc.Int32FromInt32(1))
		} else {
			v40 = XTcl_UtfToUniChar(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+16)
		}
		*(*uintptr)(unsafe.Pointer(bp)) += uintptr(v40)
	}
	goto _35
	goto badSet
badSet:
	;
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+65608, int64(-int32(1))))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+65404, __ccgo_ts+65637, libc.UintptrFromInt32(0)))
	goto error
_34:
	;
	(*(*[5]uint8)(unsafe.Pointer(bp + 20)))[XTcl_UniCharToUtf(tls, *(*TTcl_UniChar)(unsafe.Pointer(bp + 16)), bp+20)] = uint8('\000')
	errorMsg = XTcl_NewStringObj(tls, __ccgo_ts+65645, int64(-int32(1)))
	XTcl_AppendToObj(tls, errorMsg, bp+20, int64(-int32(1)))
	XTcl_AppendToObj(tls, errorMsg, __ccgo_ts+14586, int64(-int32(1)))
	XTcl_SetObjResult(tls, interp, errorMsg)
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+65404, __ccgo_ts+65677, libc.UintptrFromInt32(0)))
	goto error
_35:
	;
	if !(flags&int32(SCAN_SUPPRESS) != 0) {
		if objIndex >= nspace {
			/*
			 * Expand the nassign buffer. If we are using XPG specifiers,
			 * make sure that we grow to a large enough size. xpgSize is
			 * guaranteed to be at least one larger than objIndex.
			 */
			nspaceOrig = nspace
			if xpgSize != 0 {
				nspace = xpgSize
			} else {
				nspace += int32(16) /* formerly STATIC_LIST_SIZE */
			}
			nassign = XTclStackRealloc(tls, interp, nassign, libc.Uint64FromInt32(nspace)*uint64(4))
			i = nspaceOrig
			for {
				if !(i < nspace) {
					break
				}
				*(*int32)(unsafe.Pointer(nassign + uintptr(i)*4)) = 0
				goto _41
			_41:
				;
				i++
			}
		}
		*(*int32)(unsafe.Pointer(nassign + uintptr(objIndex)*4))++
		objIndex++
	}
	goto _6
_5:
	;
	/*
	 * Verify that all of the variable were assigned exactly once.
	 */
	if numVars == 0 {
		if xpgSize != 0 {
			numVars = xpgSize
		} else {
			numVars = objIndex
		}
	}
	if totalSubs != 0 {
		*(*int32)(unsafe.Pointer(totalSubs)) = numVars
	}
	i = 0
	for {
		if !(i < numVars) {
			break
		}
		if *(*int32)(unsafe.Pointer(nassign + uintptr(i)*4)) > int32(1) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+65685, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+65404, __ccgo_ts+65746, libc.UintptrFromInt32(0)))
			goto error
		} else {
			if !(xpgSize != 0) && *(*int32)(unsafe.Pointer(nassign + uintptr(i)*4)) == 0 {
				/*
				 * If the space is empty, and xpgSize is 0 (means XPG wasn't used,
				 * and/or numVars != 0), then too many vars were given
				 */
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+65759, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+65404, __ccgo_ts+65813, libc.UintptrFromInt32(0)))
				goto error
			}
		}
		goto _42
	_42:
		;
		i++
	}
	XTclStackFree(tls, interp, nassign)
	return TCL_OK
	goto badIndex
badIndex:
	;
	if gotXpg != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+65824, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+65404, __ccgo_ts+65858, libc.UintptrFromInt32(0)))
	} else {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+65869, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+65404, __ccgo_ts+65926, libc.UintptrFromInt32(0)))
	}
	goto error
error:
	;
	XTclStackFree(tls, interp, nassign)
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ScanObjCmd --
 *
 *	This function is invoked to process the "scan" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ScanObjCmd(tls *libc.TLS, dummy599 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(240)
	defer tls.Free(240) /* Argument objects. */
	var _isobjPtr, _isobjPtr1, _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, _objPtr6, _objPtr7, _objPtr8, _objPtr9, baseString, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cachePtr8, emptyObj, objPtr, objs, string1, v1, v3, v42, v44, v46, v49, v51, v55, v57, v59, v64, v68, v72, v74 uintptr
	var code, flags, nconversions, numVars, objIndex, offset, parseFlag, res, result, underflow, v20, v30, v33, v36, v45, v47, v50, v52, v60, v62, v70 int32
	var op uint8
	var ull uint64
	var width, v29, v32, v41, v43, v48, v54, v56, v58, v63, v67, v71, v73 TTcl_Size
	var v10, v11, v12, v13, v14, v15, v16, v17, v18, v21, v28, v31, v34, v6, v7, v8 int64
	var v19, v35, v40, v53, v65, v69, v75, v76, v77 bool
	var _ /* big at bp+128 */ Tmp_int
	var _ /* big at bp+152 */ Tmp_int
	var _ /* big at bp+88 */ Tmp_int
	var _ /* ch at bp+40 */ TTcl_UniChar
	var _ /* cset at bp+56 */ TCharSet
	var _ /* dvalue at bp+192 */ float64
	var _ /* end at bp+24 */ uintptr
	var _ /* format at bp+0 */ uintptr
	var _ /* formatEnd at bp+48 */ uintptr
	var _ /* i at bp+12 */ int32
	var _ /* ir at bp+112 */ TTcl_ObjInternalRep
	var _ /* ir at bp+176 */ TTcl_ObjInternalRep
	var _ /* sch at bp+44 */ TTcl_UniChar
	var _ /* totalVars at bp+8 */ int32
	var _ /* value at bp+16 */ int32
	var _ /* wideValue at bp+32 */ TTcl_WideInt
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _isobjPtr, _isobjPtr1, _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, _objPtr6, _objPtr7, _objPtr8, _objPtr9, baseString, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cachePtr8, code, emptyObj, flags, nconversions, numVars, objIndex, objPtr, objs, offset, op, parseFlag, res, result, string1, ull, underflow, width, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v62, v63, v64, v65, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v8
	*(*int32)(unsafe.Pointer(bp + 8)) = -int32(1)
	op = uint8(0)
	underflow = 0
	*(*TTcl_UniChar)(unsafe.Pointer(bp + 40)) = 0
	*(*TTcl_UniChar)(unsafe.Pointer(bp + 44)) = 0
	objs = libc.UintptrFromInt32(0)
	objPtr = libc.UintptrFromInt32(0)
	if objc < int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+65943)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
	}
	*(*uintptr)(unsafe.Pointer(bp)) = v1
	numVars = objc - int32(3)
	/*
	 * Check for errors in the format string.
	 */
	if _ValidateFormat(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), numVars, bp+8) == int32(TCL_ERROR) {
		return int32(TCL_ERROR)
	}
	/*
	 * Allocate space for the result objects.
	 */
	if *(*int32)(unsafe.Pointer(bp + 8)) > 0 {
		objs = XTcl_Alloc(tls, uint64(8)*libc.Uint64FromInt32(*(*int32)(unsafe.Pointer(bp + 8))))
		*(*int32)(unsafe.Pointer(bp + 12)) = 0
		for {
			if !(*(*int32)(unsafe.Pointer(bp + 12)) < *(*int32)(unsafe.Pointer(bp + 8))) {
				break
			}
			*(*uintptr)(unsafe.Pointer(objs + uintptr(*(*int32)(unsafe.Pointer(bp + 12)))*8)) = libc.UintptrFromInt32(0)
			goto _2
		_2:
			;
			*(*int32)(unsafe.Pointer(bp + 12))++
		}
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	string1 = v3
	baseString = string1
	/*
	 * Iterate over the format string filling in the result objects until we
	 * reach the end of input, the end of the format string, or there is a
	 * mismatch.
	 */
	objIndex = 0
	nconversions = 0
_5:
	;
	if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32('\000')) {
		goto _4
	}
	parseFlag = int32(TCL_PARSE_NO_WHITESPACE)
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) < int32(0x80) {
		*(*TTcl_UniChar)(unsafe.Pointer(bp + 40)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))
		v6 = int64(libc.Int32FromInt32(1))
	} else {
		v6 = XTcl_UtfToUniChar(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+40)
	}
	*(*uintptr)(unsafe.Pointer(bp)) += uintptr(v6)
	flags = 0
	/*
	 * If we see whitespace in the format, skip whitespace in the string.
	 */
	if XTcl_UniCharIsSpace(tls, *(*TTcl_UniChar)(unsafe.Pointer(bp + 40))) != 0 {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 44)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1)))
			v7 = int64(libc.Int32FromInt32(1))
		} else {
			v7 = XTcl_UtfToUniChar(tls, string1, bp+44)
		}
		offset = int32(v7)
		for XTcl_UniCharIsSpace(tls, *(*TTcl_UniChar)(unsafe.Pointer(bp + 44))) != 0 {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1))) == int32('\000') {
				goto done
			}
			string1 += uintptr(offset)
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1))) < int32(0x80) {
				*(*TTcl_UniChar)(unsafe.Pointer(bp + 44)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1)))
				v8 = int64(libc.Int32FromInt32(1))
			} else {
				v8 = XTcl_UtfToUniChar(tls, string1, bp+44)
			}
			offset = int32(v8)
		}
		goto _5
	}
	if !(*(*TTcl_UniChar)(unsafe.Pointer(bp + 40)) != int32('%')) {
		goto _9
	}
	goto literal
literal:
	;
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1))) == int32('\000') {
		underflow = int32(1)
		goto done
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1))) < int32(0x80) {
		*(*TTcl_UniChar)(unsafe.Pointer(bp + 44)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1)))
		v10 = int64(libc.Int32FromInt32(1))
	} else {
		v10 = XTcl_UtfToUniChar(tls, string1, bp+44)
	}
	string1 += uintptr(v10)
	if *(*TTcl_UniChar)(unsafe.Pointer(bp + 40)) != *(*TTcl_UniChar)(unsafe.Pointer(bp + 44)) {
		goto done
	}
	goto _5
_9:
	;
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) < int32(0x80) {
		*(*TTcl_UniChar)(unsafe.Pointer(bp + 40)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))
		v11 = int64(libc.Int32FromInt32(1))
	} else {
		v11 = XTcl_UtfToUniChar(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+40)
	}
	*(*uintptr)(unsafe.Pointer(bp)) += uintptr(v11)
	if *(*TTcl_UniChar)(unsafe.Pointer(bp + 40)) == int32('%') {
		goto literal
	}
	/*
	 * Check for assignment suppression ('*') or an XPG3-style assignment
	 * ('%n$').
	 */
	if *(*TTcl_UniChar)(unsafe.Pointer(bp + 40)) == int32('*') {
		flags |= int32(SCAN_SUPPRESS)
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 40)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))
			v12 = int64(libc.Int32FromInt32(1))
		} else {
			v12 = XTcl_UtfToUniChar(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+40)
		}
		*(*uintptr)(unsafe.Pointer(bp)) += uintptr(v12)
	} else {
		if *(*TTcl_UniChar)(unsafe.Pointer(bp + 40)) < int32(0x80) && libc.BoolInt32(uint32(libc.Uint8FromInt32(*(*TTcl_UniChar)(unsafe.Pointer(bp + 40))))-uint32('0') < uint32(10)) != 0 {
			/* Note currently XPG3 range limited to INT_MAX to match type of objc */
			*(*int32)(unsafe.Pointer(bp + 16)) = libc.Int32FromUint64(libc.Xstrtoul(tls, *(*uintptr)(unsafe.Pointer(bp))-uintptr(1), bp+48, int32(10))) /* INTL: "C" locale. */
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48))))) == int32('$') {
				*(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp + 48)) + uintptr(1)
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) < int32(0x80) {
					*(*TTcl_UniChar)(unsafe.Pointer(bp + 40)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))
					v13 = int64(libc.Int32FromInt32(1))
				} else {
					v13 = XTcl_UtfToUniChar(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+40)
				}
				*(*uintptr)(unsafe.Pointer(bp)) += uintptr(v13)
				objIndex = *(*int32)(unsafe.Pointer(bp + 16)) - int32(1)
			}
		}
	}
	/*
	 * Parse any width specifier.
	 */
	if *(*TTcl_UniChar)(unsafe.Pointer(bp + 40)) < int32(0x80) && libc.BoolInt32(uint32(libc.Uint8FromInt32(*(*TTcl_UniChar)(unsafe.Pointer(bp + 40))))-uint32('0') < uint32(10)) != 0 {
		ull = libc.Xstrtoull(tls, *(*uintptr)(unsafe.Pointer(bp))-uintptr(1), bp, int32(10)) /* INTL: "C" locale. */
		/* Else ValidateFormat should've error'ed */
		width = libc.Int64FromUint64(ull)
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 40)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))
			v14 = int64(libc.Int32FromInt32(1))
		} else {
			v14 = XTcl_UtfToUniChar(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+40)
		}
		*(*uintptr)(unsafe.Pointer(bp)) += uintptr(v14)
	} else {
		width = 0
	}
	/*
	 * Handle any size specifier.
	 */
	switch *(*TTcl_UniChar)(unsafe.Pointer(bp + 40)) {
	case int32('z'):
		fallthrough
	case int32('t'):
		if uint64(8) > uint64(4) {
			flags |= int32(SCAN_LONGER)
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 40)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))
			v15 = int64(libc.Int32FromInt32(1))
		} else {
			v15 = XTcl_UtfToUniChar(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+40)
		}
		*(*uintptr)(unsafe.Pointer(bp)) += uintptr(v15)
	case int32('L'):
		flags |= int32(SCAN_BIG)
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 40)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))
			v16 = int64(libc.Int32FromInt32(1))
		} else {
			v16 = XTcl_UtfToUniChar(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+40)
		}
		*(*uintptr)(unsafe.Pointer(bp)) += uintptr(v16)
	case int32('l'):
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('l') {
			flags |= int32(SCAN_BIG)
			*(*uintptr)(unsafe.Pointer(bp)) += uintptr(1)
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) < int32(0x80) {
				*(*TTcl_UniChar)(unsafe.Pointer(bp + 40)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))
				v17 = int64(libc.Int32FromInt32(1))
			} else {
				v17 = XTcl_UtfToUniChar(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+40)
			}
			*(*uintptr)(unsafe.Pointer(bp)) += uintptr(v17)
			break
		}
		/* FALLTHRU */
		fallthrough
	case int32('j'):
		fallthrough
	case int32('q'):
		flags |= int32(SCAN_LONGER)
		/* FALLTHRU */
		fallthrough
	case int32('h'):
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 40)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))
			v18 = int64(libc.Int32FromInt32(1))
		} else {
			v18 = XTcl_UtfToUniChar(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+40)
		}
		*(*uintptr)(unsafe.Pointer(bp)) += uintptr(v18)
	}
	/*
	 * Handle the various field types.
	 */
	switch *(*TTcl_UniChar)(unsafe.Pointer(bp + 40)) {
	case int32('n'):
		if !(flags&int32(SCAN_SUPPRESS) != 0) {
			if v19 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v19 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v19 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				objPtr = XTclThreadAllocObj(tls)
			} else {
				objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = libc.UintptrFromInt32(0)
			*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) = int64(string1) - int64(baseString)
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount++
			v20 = objIndex
			objIndex++
			*(*uintptr)(unsafe.Pointer(objs + uintptr(v20)*8)) = objPtr
		}
		nconversions++
		goto _5
	case int32('d'):
		op = uint8('i')
		parseFlag |= int32(TCL_PARSE_DECIMAL_ONLY)
	case int32('i'):
		op = uint8('i')
		parseFlag |= int32(TCL_PARSE_SCAN_PREFIXES)
	case int32('o'):
		op = uint8('i')
		parseFlag |= libc.Int32FromInt32(TCL_PARSE_OCTAL_ONLY) | libc.Int32FromInt32(TCL_PARSE_SCAN_PREFIXES)
	case int32('x'):
		fallthrough
	case int32('X'):
		op = uint8('i')
		parseFlag |= int32(TCL_PARSE_HEXADECIMAL_ONLY)
	case int32('b'):
		op = uint8('i')
		parseFlag |= int32(TCL_PARSE_BINARY_ONLY)
	case int32('u'):
		op = uint8('i')
		parseFlag |= int32(TCL_PARSE_DECIMAL_ONLY)
		flags |= int32(SCAN_UNSIGNED)
	case int32('f'):
		fallthrough
	case int32('e'):
		fallthrough
	case int32('E'):
		fallthrough
	case int32('g'):
		fallthrough
	case int32('G'):
		op = uint8('f')
	case int32('s'):
		op = uint8('s')
	case int32('c'):
		op = uint8('c')
		flags |= int32(SCAN_NOSKIP)
	case int32('['):
		op = uint8('[')
		flags |= int32(SCAN_NOSKIP)
		break
	}
	/*
	 * At this point, we will need additional characters from the string
	 * to proceed.
	 */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1))) == int32('\000') {
		underflow = int32(1)
		goto done
	}
	/*
	 * Skip any leading whitespace at the beginning of a field unless the
	 * format suppresses this behavior.
	 */
	if !(flags&int32(SCAN_NOSKIP) != 0) {
		for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1))) != int32('\000') {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1))) < int32(0x80) {
				*(*TTcl_UniChar)(unsafe.Pointer(bp + 44)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1)))
				v21 = int64(libc.Int32FromInt32(1))
			} else {
				v21 = XTcl_UtfToUniChar(tls, string1, bp+44)
			}
			offset = int32(v21)
			if !(XTcl_UniCharIsSpace(tls, *(*TTcl_UniChar)(unsafe.Pointer(bp + 44))) != 0) {
				break
			}
			string1 += uintptr(offset)
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1))) == int32('\000') {
			underflow = int32(1)
			goto done
		}
	}
	/*
	 * Perform the requested scanning operation.
	 */
	switch libc.Int32FromUint8(op) {
	case int32('s'):
		goto _22
	case int32('['):
		goto _23
	case int32('c'):
		goto _24
	case int32('i'):
		goto _25
	case int32('f'):
		goto _26
	}
	goto _27
_22:
	;
	/*
	 * Scan a string up to width characters or whitespace.
	 */
	if width == 0 {
		width = int64(^libc.Int32FromInt32(0))
	}
	*(*uintptr)(unsafe.Pointer(bp + 24)) = string1
	for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24))))) != int32('\000') {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24))))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 44)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))))
			v28 = int64(libc.Int32FromInt32(1))
		} else {
			v28 = XTcl_UtfToUniChar(tls, *(*uintptr)(unsafe.Pointer(bp + 24)), bp+44)
		}
		offset = int32(v28)
		if XTcl_UniCharIsSpace(tls, *(*TTcl_UniChar)(unsafe.Pointer(bp + 44))) != 0 {
			break
		}
		*(*uintptr)(unsafe.Pointer(bp + 24)) += uintptr(offset)
		width--
		v29 = width
		if v29 == 0 {
			break
		}
	}
	if !(flags&int32(SCAN_SUPPRESS) != 0) {
		objPtr = XTcl_NewStringObj(tls, string1, int64(*(*uintptr)(unsafe.Pointer(bp + 24)))-int64(string1))
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount++
		v30 = objIndex
		objIndex++
		*(*uintptr)(unsafe.Pointer(objs + uintptr(v30)*8)) = objPtr
	}
	string1 = *(*uintptr)(unsafe.Pointer(bp + 24))
	goto _27
_23:
	;
	if width == 0 {
		width = int64(^libc.Int32FromInt32(0))
	}
	*(*uintptr)(unsafe.Pointer(bp + 24)) = string1
	*(*uintptr)(unsafe.Pointer(bp)) = _BuildCharSet(tls, bp+56, *(*uintptr)(unsafe.Pointer(bp)))
	for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24))))) != int32('\000') {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24))))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 44)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))))
			v31 = int64(libc.Int32FromInt32(1))
		} else {
			v31 = XTcl_UtfToUniChar(tls, *(*uintptr)(unsafe.Pointer(bp + 24)), bp+44)
		}
		offset = int32(v31)
		if !(_CharInSet(tls, bp+56, *(*TTcl_UniChar)(unsafe.Pointer(bp + 44))) != 0) {
			break
		}
		*(*uintptr)(unsafe.Pointer(bp + 24)) += uintptr(offset)
		width--
		v32 = width
		if v32 == 0 {
			break
		}
	}
	_ReleaseCharSet(tls, bp+56)
	if string1 == *(*uintptr)(unsafe.Pointer(bp + 24)) {
		/*
		 * Nothing matched the range, stop processing.
		 */
		goto done
	}
	if !(flags&int32(SCAN_SUPPRESS) != 0) {
		objPtr = XTcl_NewStringObj(tls, string1, int64(*(*uintptr)(unsafe.Pointer(bp + 24)))-int64(string1))
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount++
		v33 = objIndex
		objIndex++
		*(*uintptr)(unsafe.Pointer(objs + uintptr(v33)*8)) = objPtr
	}
	string1 = *(*uintptr)(unsafe.Pointer(bp + 24))
	goto _27
_24:
	;
	/*
	 * Scan a single Unicode character.
	 */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1))) < int32(0x80) {
		*(*int32)(unsafe.Pointer(bp + 12)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1)))
		v34 = int64(libc.Int32FromInt32(1))
	} else {
		v34 = XTcl_UtfToUniChar(tls, string1, bp+12)
	}
	offset = int32(v34)
	string1 += uintptr(offset)
	if !(flags&int32(SCAN_SUPPRESS) != 0) {
		if v35 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v35 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v35 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			objPtr = XTclThreadAllocObj(tls)
		} else {
			objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = libc.UintptrFromInt32(0)
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) = int64(*(*int32)(unsafe.Pointer(bp + 12)))
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount++
		v36 = objIndex
		objIndex++
		*(*uintptr)(unsafe.Pointer(objs + uintptr(v36)*8)) = objPtr
	}
	goto _27
_25:
	;
	/*
	 * Scan an unsigned or signed integer.
	 */
_39:
	;
	if v40 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v40 {
		cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v40 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = libc.UintptrFromInt32(0)
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) = int64(libc.Int32FromInt32(0))
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	goto _38
_38:
	;
	if 0 != 0 {
		goto _39
	}
	goto _37
_37:
	;
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount++
	if width == 0 {
		width = int64(^libc.Int32FromInt32(0))
	}
	if TCL_OK != XTclParseNumber(tls, libc.UintptrFromInt32(0), objPtr, libc.UintptrFromInt32(0), string1, width, bp+24, libc.Int32FromInt32(TCL_PARSE_INTEGER_ONLY)|libc.Int32FromInt32(TCL_PARSE_NO_UNDERSCORE)|parseFlag) {
		_objPtr = objPtr
		v42 = _objPtr
		v41 = *(*TTcl_Size)(unsafe.Pointer(v42))
		*(*TTcl_Size)(unsafe.Pointer(v42))--
		if v41 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		if width < 0 {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24))))) == int32('\000') {
				underflow = int32(1)
			}
		} else {
			if *(*uintptr)(unsafe.Pointer(bp + 24)) == string1+uintptr(width) {
				underflow = int32(1)
			}
		}
		goto done
	}
	string1 = *(*uintptr)(unsafe.Pointer(bp + 24))
	if flags&int32(SCAN_SUPPRESS) != 0 {
		_objPtr1 = objPtr
		v44 = _objPtr1
		v43 = *(*TTcl_Size)(unsafe.Pointer(v44))
		*(*TTcl_Size)(unsafe.Pointer(v44))--
		if v43 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		goto _27
	}
	if flags&int32(SCAN_LONGER) != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
			*(*TTcl_WideInt)(unsafe.Pointer(bp + 32)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep))
			v45 = libc.Int32FromInt32(TCL_OK)
		} else {
			v45 = XTcl_GetWideIntFromObj(tls, libc.UintptrFromInt32(0), objPtr, bp+32)
		}
		if v45 != TCL_OK {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
				v46 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
			} else {
				v46 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v46))) == int32('-') {
				*(*TTcl_WideInt)(unsafe.Pointer(bp + 32)) = libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) + libc.Uint64FromInt32(1))
			} else {
				*(*TTcl_WideInt)(unsafe.Pointer(bp + 32)) = libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
			}
		}
		if flags&int32(SCAN_UNSIGNED) != 0 && *(*TTcl_WideInt)(unsafe.Pointer(bp + 32)) < 0 {
			if XTclBN_mp_init_u64(tls, bp+88, uint64(libc.Uint64FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 32))))) != MP_OKAY {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+65971, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+208, __ccgo_ts+2004, __ccgo_ts+2008, libc.UintptrFromInt32(0)))
				return int32(TCL_ERROR)
			} else {
				XTcl_SetBignumObj(tls, objPtr, bp+88)
			}
		} else {
			*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 112)))) = *(*TTcl_WideInt)(unsafe.Pointer(bp + 32))
			_isobjPtr = objPtr
			if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
				if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
			}
			XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&XtclIntType)), bp+112)
		}
	} else {
		if flags&int32(SCAN_BIG) != 0 {
			if flags&int32(SCAN_UNSIGNED) != 0 {
				res = XTcl_GetBignumFromObj(tls, interp, objPtr, bp+128)
				if res == TCL_OK {
					if (*Tmp_int)(unsafe.Pointer(bp+128)).Fsign != MP_ZPOS {
						v47 = int32(MP_YES)
					} else {
						v47 = MP_NO
					}
					if v47 != 0 {
						res = int32(TCL_ERROR)
					}
					XTclBN_mp_clear(tls, bp+128)
				}
				if res == int32(TCL_ERROR) {
					if objs != libc.UintptrFromInt32(0) {
						XTclpFree(tls, objs)
					}
					_objPtr2 = objPtr
					v49 = _objPtr2
					v48 = *(*TTcl_Size)(unsafe.Pointer(v49))
					*(*TTcl_Size)(unsafe.Pointer(v49))--
					if v48 <= int64(1) {
						XTclFreeObj(tls, _objPtr2)
					}
					XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+66008, int64(-int32(1))))
					XTcl_SetErrorCode(tls, interp, libc.VaList(bp+208, __ccgo_ts+2004, __ccgo_ts+65404, __ccgo_ts+66042, libc.UintptrFromInt32(0)))
					return int32(TCL_ERROR)
				}
			}
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
				*(*int32)(unsafe.Pointer(bp + 16)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)))
				v50 = libc.Int32FromInt32(TCL_OK)
			} else {
				v50 = XTcl_GetIntFromObj(tls, libc.UintptrFromInt32(0), objPtr, bp+16)
			}
			if v50 != TCL_OK {
				if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
					v51 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
				} else {
					v51 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
				}
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v51))) == int32('-') {
					*(*int32)(unsafe.Pointer(bp + 16)) = -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff)
				} else {
					*(*int32)(unsafe.Pointer(bp + 16)) = int32(INT_MAX)
				}
			}
			if flags&int32(SCAN_UNSIGNED) != 0 && *(*int32)(unsafe.Pointer(bp + 16)) < 0 {
				if XTclBN_mp_init_u64(tls, bp+152, libc.Uint64FromInt32(*(*int32)(unsafe.Pointer(bp + 16)))) != MP_OKAY {
					XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+65971, int64(-int32(1))))
					XTcl_SetErrorCode(tls, interp, libc.VaList(bp+208, __ccgo_ts+2004, __ccgo_ts+2008, libc.UintptrFromInt32(0)))
					return int32(TCL_ERROR)
				} else {
					XTcl_SetBignumObj(tls, objPtr, bp+152)
				}
			} else {
				*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 176)))) = int64(*(*int32)(unsafe.Pointer(bp + 16)))
				_isobjPtr1 = objPtr
				if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes != libc.UintptrFromInt32(0) {
					if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(_isobjPtr1)).Fbytes = libc.UintptrFromInt32(0)
				}
				XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&XtclIntType)), bp+176)
			}
		}
	}
	v52 = objIndex
	objIndex++
	*(*uintptr)(unsafe.Pointer(objs + uintptr(v52)*8)) = objPtr
	goto _27
_26:
	;
	/*
	 * Scan a floating point number
	 */
	if v53 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v53 {
		cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v53 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = libc.UintptrFromInt32(0)
	*(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) = libc.Float64FromFloat64(0)
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclDoubleType))
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount++
	if width == 0 {
		width = int64(^libc.Int32FromInt32(0))
	}
	if TCL_OK != XTclParseNumber(tls, libc.UintptrFromInt32(0), objPtr, libc.UintptrFromInt32(0), string1, width, bp+24, libc.Int32FromInt32(TCL_PARSE_DECIMAL_ONLY)|libc.Int32FromInt32(TCL_PARSE_NO_WHITESPACE)|libc.Int32FromInt32(TCL_PARSE_NO_UNDERSCORE)) {
		_objPtr3 = objPtr
		v55 = _objPtr3
		v54 = *(*TTcl_Size)(unsafe.Pointer(v55))
		*(*TTcl_Size)(unsafe.Pointer(v55))--
		if v54 <= int64(1) {
			XTclFreeObj(tls, _objPtr3)
		}
		if width < 0 {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24))))) == int32('\000') {
				underflow = int32(1)
			}
		} else {
			if *(*uintptr)(unsafe.Pointer(bp + 24)) == string1+uintptr(width) {
				underflow = int32(1)
			}
		}
		goto done
	} else {
		if flags&int32(SCAN_SUPPRESS) != 0 {
			_objPtr4 = objPtr
			v57 = _objPtr4
			v56 = *(*TTcl_Size)(unsafe.Pointer(v57))
			*(*TTcl_Size)(unsafe.Pointer(v57))--
			if v56 <= int64(1) {
				XTclFreeObj(tls, _objPtr4)
			}
			string1 = *(*uintptr)(unsafe.Pointer(bp + 24))
		} else {
			if XTcl_GetDoubleFromObj(tls, libc.UintptrFromInt32(0), objPtr, bp+192) != TCL_OK {
				_objPtr5 = objPtr
				v59 = _objPtr5
				v58 = *(*TTcl_Size)(unsafe.Pointer(v59))
				*(*TTcl_Size)(unsafe.Pointer(v59))--
				if v58 <= int64(1) {
					XTclFreeObj(tls, _objPtr5)
				}
				goto done
			}
			XTcl_SetDoubleObj(tls, objPtr, *(*float64)(unsafe.Pointer(bp + 192)))
			v60 = objIndex
			objIndex++
			*(*uintptr)(unsafe.Pointer(objs + uintptr(v60)*8)) = objPtr
			string1 = *(*uintptr)(unsafe.Pointer(bp + 24))
		}
	}
_27:
	;
	nconversions++
	goto _5
_4:
	;
	goto done
done:
	;
	result = 0
	code = TCL_OK
	if numVars != 0 {
		/*
		 * In this case, variables were specified (classic scan).
		 */
		*(*int32)(unsafe.Pointer(bp + 12)) = 0
		for {
			if !(*(*int32)(unsafe.Pointer(bp + 12)) < *(*int32)(unsafe.Pointer(bp + 8))) {
				break
			}
			if *(*uintptr)(unsafe.Pointer(objs + uintptr(*(*int32)(unsafe.Pointer(bp + 12)))*8)) == libc.UintptrFromInt32(0) {
				goto _61
			}
			result++
			/*
			 * In case of multiple errors in setting variables, just report
			 * the first one.
			 */
			if code == TCL_OK {
				v62 = int32(TCL_LEAVE_ERR_MSG)
			} else {
				v62 = 0
			}
			if XTcl_ObjSetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(*(*int32)(unsafe.Pointer(bp + 12))+int32(3))*8)), libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objs + uintptr(*(*int32)(unsafe.Pointer(bp + 12)))*8)), v62) == libc.UintptrFromInt32(0) {
				code = int32(TCL_ERROR)
			}
			_objPtr6 = *(*uintptr)(unsafe.Pointer(objs + uintptr(*(*int32)(unsafe.Pointer(bp + 12)))*8))
			v64 = _objPtr6
			v63 = *(*TTcl_Size)(unsafe.Pointer(v64))
			*(*TTcl_Size)(unsafe.Pointer(v64))--
			if v63 <= int64(1) {
				XTclFreeObj(tls, _objPtr6)
			}
			goto _61
		_61:
			;
			*(*int32)(unsafe.Pointer(bp + 12))++
		}
	} else {
		/*
		 * Here no vars were specified, we want a list returned (inline scan)
		 * We create an empty Tcl_Obj to fill missing values rather than
		 * allocating a new Tcl_Obj every time. See test scan-bigdata-XX.
		 */
		emptyObj = libc.UintptrFromInt32(0)
		if v65 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v65 {
			cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v65 || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == libc.Uint64FromInt32(0) {
			objPtr = XTclThreadAllocObj(tls)
		} else {
			objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
		*(*int32)(unsafe.Pointer(bp + 12)) = 0
		for {
			if !(code == TCL_OK && *(*int32)(unsafe.Pointer(bp + 12)) < *(*int32)(unsafe.Pointer(bp + 8))) {
				break
			}
			if *(*uintptr)(unsafe.Pointer(objs + uintptr(*(*int32)(unsafe.Pointer(bp + 12)))*8)) != libc.UintptrFromInt32(0) {
				code = XTcl_ListObjAppendElement(tls, interp, objPtr, *(*uintptr)(unsafe.Pointer(objs + uintptr(*(*int32)(unsafe.Pointer(bp + 12)))*8)))
				_objPtr7 = *(*uintptr)(unsafe.Pointer(objs + uintptr(*(*int32)(unsafe.Pointer(bp + 12)))*8))
				v68 = _objPtr7
				v67 = *(*TTcl_Size)(unsafe.Pointer(v68))
				*(*TTcl_Size)(unsafe.Pointer(v68))--
				if v67 <= int64(1) {
					XTclFreeObj(tls, _objPtr7)
				}
			} else {
				/*
				 * More %-specifiers than matching chars, so we just spit out
				 * empty strings for these.
				 */
				if !(emptyObj != 0) {
					if v69 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v69 {
						cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v69 || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == libc.Uint64FromInt32(0) {
						emptyObj = XTclThreadAllocObj(tls)
					} else {
						emptyObj = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(emptyObj + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer(emptyObj)).FrefCount = 0
					(*TTcl_Obj)(unsafe.Pointer(emptyObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(emptyObj)).Flength = 0
					(*TTcl_Obj)(unsafe.Pointer(emptyObj)).FtypePtr = libc.UintptrFromInt32(0)
				}
				code = XTcl_ListObjAppendElement(tls, interp, objPtr, emptyObj)
			}
			goto _66
		_66:
			;
			*(*int32)(unsafe.Pointer(bp + 12))++
		}
		if code != TCL_OK {
			/* If error'ed out, free up remaining. i contains last index freed */
			for {
				*(*int32)(unsafe.Pointer(bp + 12))++
				v70 = *(*int32)(unsafe.Pointer(bp + 12))
				if !(v70 < *(*int32)(unsafe.Pointer(bp + 8))) {
					break
				}
				if *(*uintptr)(unsafe.Pointer(objs + uintptr(*(*int32)(unsafe.Pointer(bp + 12)))*8)) != libc.UintptrFromInt32(0) {
					_objPtr8 = *(*uintptr)(unsafe.Pointer(objs + uintptr(*(*int32)(unsafe.Pointer(bp + 12)))*8))
					v72 = _objPtr8
					v71 = *(*TTcl_Size)(unsafe.Pointer(v72))
					*(*TTcl_Size)(unsafe.Pointer(v72))--
					if v71 <= int64(1) {
						XTclFreeObj(tls, _objPtr8)
					}
				}
			}
			_objPtr9 = objPtr
			v74 = _objPtr9
			v73 = *(*TTcl_Size)(unsafe.Pointer(v74))
			*(*TTcl_Size)(unsafe.Pointer(v74))--
			if v73 <= int64(1) {
				XTclFreeObj(tls, _objPtr9)
			}
			objPtr = libc.UintptrFromInt32(0)
		}
	}
	if objs != libc.UintptrFromInt32(0) {
		XTclpFree(tls, objs)
	}
	if code == TCL_OK {
		if underflow != 0 && nconversions == 0 {
			if numVars != 0 {
				if v75 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v75 {
					cachePtr6 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v75 || (*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects == libc.Uint64FromInt32(0) {
					objPtr = XTclThreadAllocObj(tls)
				} else {
					objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(objPtr + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = libc.UintptrFromInt32(0)
				*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) = int64(-libc.Int32FromInt32(1))
				(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
			} else {
				if objPtr != 0 {
					XTcl_SetListObj(tls, objPtr, 0, libc.UintptrFromInt32(0))
				} else {
					if v76 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v76 {
						cachePtr7 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v76 || (*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects == libc.Uint64FromInt32(0) {
						objPtr = XTclThreadAllocObj(tls)
					} else {
						objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(objPtr + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
					(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
					(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
				}
			}
		} else {
			if numVars != 0 {
				if v77 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v77 {
					cachePtr8 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v77 || (*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects == libc.Uint64FromInt32(0) {
					objPtr = XTclThreadAllocObj(tls)
				} else {
					objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr8)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr8)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(objPtr + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = libc.UintptrFromInt32(0)
				*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) = int64(result)
				(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
			}
		}
		XTcl_SetObjResult(tls, interp, objPtr)
	}
	return code
}

const MAX_FLOAT_SIZE = 320
const TCL_MIN_UNICHAR_GROWTH = 1024

type TString = struct {
	FnumChars   TTcl_Size
	Fallocated  TTcl_Size
	FmaxChars   TTcl_Size
	FhasUnicode int32
}

func init() {
	p := unsafe.Pointer(&XtclStringType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_FreeStringInternalRep)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_DupStringInternalRep)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_UpdateStringOfString)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_SetStringFromAny)
}

/*
 * TCL STRING GROWTH ALGORITHM
 *
 * When growing strings (during an append, for example), the following growth
 * algorithm is used:
 *
 *   Attempt to allocate 2 * (originalLength + appendLength)
 *   On failure:
 *	attempt to allocate originalLength + 2*appendLength + TCL_MIN_GROWTH
 *
 * This algorithm allows very good performance, as it rapidly increases the
 * memory allocated for a given string, which minimizes the number of
 * reallocations that must be performed. However, using only the doubling
 * algorithm can lead to a significant waste of memory. In particular, it may
 * fail even when there is sufficient memory available to complete the append
 * request (but there is not 2*totalLength memory available). So when the
 * doubling fails (because there is not enough memory available), the
 * algorithm requests a smaller amount of memory, which is still enough to
 * cover the request, but which hopefully will be less than the total
 * available memory.
 *
 * The addition of TCL_MIN_GROWTH allows for efficient handling of very
 * small appends. Without this extra slush factor, a sequence of several small
 * appends would cause several memory allocations. As long as
 * TCL_MIN_GROWTH is a reasonable size, we can avoid that behavior.
 *
 * The growth algorithm can be tuned by adjusting the following parameters:
 *
 * TCL_MIN_GROWTH		Additional space, in bytes, to allocate when
 *				the double allocation has failed. Default is
 *				1024 (1 kilobyte).  See tclInt.h.
 */

func _GrowStringBuffer(tls *libc.TLS, objPtr uintptr, needed TTcl_Size, flag int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* If 0, try to overallocate */
	var ptr, stringPtr, v1 uintptr
	var _ /* capacity at bp+0 */ TTcl_Size
	_, _, _ = ptr, stringPtr, v1
	/*
	 * Preconditions:
	 *	TclHasInternalRep(objPtr, &tclStringType)
	 *	needed > stringPtr->allocated
	 *	flag || objPtr->bytes != NULL
	 */
	stringPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1
	needed += int64(1) /* Include terminating nul */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes == uintptr(unsafe.Pointer(&XtclEmptyString)) {
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
	/*
	 * In code below, note 'capacity' and 'needed' include terminating nul,
	 * while stringPtr->allocated does not.
	 */
	if flag == 0 || (*TString)(unsafe.Pointer(stringPtr)).Fallocated > 0 {
		v1 = XTclReallocElemsEx(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, needed, int64(1), 0, bp)
		goto _2
	_2:
		ptr = v1
	} else {
		/* Allocate exact size */
		ptr = XTcl_Realloc(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, libc.Uint64FromInt64(needed))
		*(*TTcl_Size)(unsafe.Pointer(bp)) = needed
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = ptr
	(*TString)(unsafe.Pointer(stringPtr)).Fallocated = *(*TTcl_Size)(unsafe.Pointer(bp)) - int64(1) /* Does not include slot for end nul */
}

func _GrowUnicodeBuffer(tls *libc.TLS, objPtr uintptr, needed TTcl_Size) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var stringPtr uintptr
	var _ /* maxChars at bp+0 */ TTcl_Size
	_ = stringPtr
	/*
	 * Preconditions:
	 *	TclHasInternalRep(objPtr, &tclStringType)
	 *	needed > stringPtr->maxChars
	 */
	stringPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1
	/* Note STRING_MAXCHARS already takes into account space for nul */
	if needed > libc.Int64FromUint64((libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))-uint64(libc.UintptrFromInt32(0)+28))/libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)) {
		XTcl_Panic(tls, __ccgo_ts+66054, libc.VaList(bp+16, libc.Int64FromUint64((libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))-uint64(libc.UintptrFromInt32(0)+28))/libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1))))
	}
	if (*TString)(unsafe.Pointer(stringPtr)).FmaxChars > 0 {
		/* Expansion - try allocating extra space */
		stringPtr = XTclReallocElemsEx(tls, stringPtr, needed+int64(1), int64(4), libc.Int64FromUint64(uint64(libc.UintptrFromInt32(0)+28)), bp)
		*(*TTcl_Size)(unsafe.Pointer(bp)) -= int64(1) /* End nul not included */
	} else {
		/*
		 * First allocation - just big enough. Note needed does
		 * not include terminating nul but STRING_SIZE does
		 */
		stringPtr = XTcl_Realloc(tls, stringPtr, uint64(libc.UintptrFromInt32(0)+28)+libc.Uint64FromInt64(4)+libc.Uint64FromInt64(needed)*libc.Uint64FromInt64(4))
		*(*TTcl_Size)(unsafe.Pointer(bp)) = needed
	}
	(*TString)(unsafe.Pointer(stringPtr)).FmaxChars = *(*TTcl_Size)(unsafe.Pointer(bp))
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr2 = libc.UintptrFromInt32(0)
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1 = stringPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_NewStringObj --
 *
 *	This function is normally called when not debugging: i.e., when
 *	TCL_MEM_DEBUG is not defined. It creates a new string object and
 *	initializes it from the byte pointer and length arguments.
 *
 *	When TCL_MEM_DEBUG is defined, this function just returns the result
 *	of calling the debugging version Tcl_DbNewStringObj.
 *
 * Results:
 *	A newly created string object is returned that has ref count zero.
 *
 * Side effects:
 *	The new object's internal string representation will be set to a copy
 *	of the length bytes starting at "bytes". If "length" is TCL_INDEX_NONE, use
 *	bytes up to the first NUL byte; i.e., assume "bytes" points to a
 *	C-style NUL-terminated string. The object's type is set to NULL. An
 *	extra NUL is added to the end of the new object's byte array.
 *
 *----------------------------------------------------------------------
 */

func XTcl_NewStringObj(tls *libc.TLS, bytes uintptr, length TTcl_Size) (r uintptr) {
	/* The number of bytes to copy from "bytes"
	 * when initializing the new object. If -1,
	 * use bytes up to the first NUL byte. */
	var cachePtr, objPtr, v3 uintptr
	var v1 uint64
	var v2 bool
	_, _, _, _, _ = cachePtr, objPtr, v1, v2, v3
	if length < 0 {
		if bytes != 0 {
			v1 = libc.Xstrlen(tls, bytes)
		} else {
			v1 = uint64(0)
		}
		length = libc.Int64FromUint64(v1)
	}
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	if length == 0 {
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(length+libc.Int64FromUint32(1)))
		if bytes != 0 {
			v3 = bytes
		} else {
			v3 = uintptr(unsafe.Pointer(&XtclEmptyString))
		}
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, v3, libc.Uint64FromInt64(length))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr(length))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = length
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	return objPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DbNewStringObj --
 *
 *	This function is normally called when debugging: i.e., when
 *	TCL_MEM_DEBUG is defined. It creates new string objects. It is the
 *	same as the Tcl_NewStringObj function above except that it calls
 *	Tcl_DbCkalloc directly with the file name and line number from its
 *	caller. This simplifies debugging since then the [memory active]
 *	command will report the correct file name and line number when
 *	reporting objects that haven't been freed.
 *
 *	When TCL_MEM_DEBUG is not defined, this function just returns the
 *	result of calling Tcl_NewStringObj.
 *
 * Results:
 *	A newly created string object is returned that has ref count zero.
 *
 * Side effects:
 *	The new object's internal string representation will be set to a copy
 *	of the length bytes starting at "bytes". If "length" is TCL_INDEX_NONE, use
 *	bytes up to the first NUL byte; i.e., assume "bytes" points to a
 *	C-style NUL-terminated string. The object's type is set to NULL. An
 *	extra NUL is added to the end of the new object's byte array.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DbNewStringObj(tls *libc.TLS, bytes uintptr, length TTcl_Size, dummy316 uintptr, dummy317 int32) (r uintptr) {
	return XTcl_NewStringObj(tls, bytes, length)
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_NewUnicodeObj --
 *
 *	This function is creates a new String object and initializes it from
 *	the given Unicode String. If the Utf String is the same size as the
 *	Unicode string, don't duplicate the data.
 *
 * Results:
 *	The newly created object is returned. This object will have no initial
 *	string representation. The returned object has a ref count of 0.
 *
 * Side effects:
 *	Memory allocated for new object and copy of Unicode argument.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_NewUnicodeObj(tls *libc.TLS, unicode uintptr, numChars TTcl_Size) (r uintptr) {
	/* Number of characters in the unicode
	 * string. */
	var cachePtr, objPtr uintptr
	var v1 bool
	_, _, _ = cachePtr, objPtr, v1
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	_SetUnicodeObj(tls, objPtr, unicode, numChars)
	return objPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetCharLength --
 *
 *	Get the length of the Unicode string from the Tcl object.
 *
 * Results:
 *	Pointer to Unicode string representing the Unicode object.
 *
 * Side effects:
 *	Frees old internal rep. Allocates memory for new "String" internal
 *	rep.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetCharLength(tls *libc.TLS, objPtr uintptr) (r TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The String object to get the num chars
	 * of. */
	var _count, _i TTcl_Size
	var _str, stringPtr uintptr
	var _ /* numChars at bp+0 */ TTcl_Size
	_, _, _, _ = _count, _i, _str, stringPtr
	*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	/*
	 * Quick, no-shimmer return for short string reps.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength < int64(2) {
		/* 0 bytes -> 0 chars; 1 byte -> 1 char */
		return (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
	}
	/*
	 * Optimize the case where we're really dealing with a bytearray object;
	 * we don't need to convert to a string to perform the get-length operation.
	 *
	 * Starting in Tcl 8.7, we check for a "pure" bytearray, because the
	 * machinery behind that test is using a proper bytearray ObjType.  We
	 * could also compute length of an improper bytearray without shimmering
	 * but there's no value in that. We *want* to shimmer an improper bytearray
	 * because improper bytearrays have worthless internal reps.
	 */
	if XTclIsPureByteArray(tls, objPtr) != 0 {
		XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), objPtr, bp)
		return *(*TTcl_Size)(unsafe.Pointer(bp))
	}
	/*
	 * OK, need to work with the object as a string.
	 */
	_SetStringFromAny(tls, libc.UintptrFromInt32(0), objPtr)
	stringPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1
	*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TString)(unsafe.Pointer(stringPtr)).FnumChars
	/*
	 * If numChars is unknown, compute it.
	 */
	if *(*TTcl_Size)(unsafe.Pointer(bp)) < 0 {
		_i = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
		_str = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		for _i > 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(_str))) < int32(0xC0) {
			_i--
			_str++
		}
		_count = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength - _i
		if _i != 0 {
			_count += XTcl_NumUtfChars(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes+uintptr(_count), _i)
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = _count
		(*TString)(unsafe.Pointer(stringPtr)).FnumChars = *(*TTcl_Size)(unsafe.Pointer(bp))
	}
	return *(*TTcl_Size)(unsafe.Pointer(bp))
}

func XTclGetCharLength(tls *libc.TLS, objPtr uintptr) (r TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The String object to get the num chars
	 * of. */
	var _ /* numChars at bp+0 */ TTcl_Size
	*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	/*
	 * Quick, no-shimmer return for short string reps.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength < int64(2) {
		/* 0 bytes -> 0 chars; 1 byte -> 1 char */
		return (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
	}
	/*
	 * Optimize the case where we're really dealing with a bytearray object;
	 * we don't need to convert to a string to perform the get-length operation.
	 *
	 * Starting in Tcl 8.7, we check for a "pure" bytearray, because the
	 * machinery behind that test is using a proper bytearray ObjType.  We
	 * could also compute length of an improper bytearray without shimmering
	 * but there's no value in that. We *want* to shimmer an improper bytearray
	 * because improper bytearrays have worthless internal reps.
	 */
	if XTclIsPureByteArray(tls, objPtr) != 0 {
		XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), objPtr, bp)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
			_ = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		} else {
			XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = XTclNumUtfChars(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength)
	}
	return *(*TTcl_Size)(unsafe.Pointer(bp))
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * TclCheckEmptyString --
//	 *
//	 *	Determine whether the string value of an object is or would be the
//	 *	empty string, without generating a string representation.
//	 *
//	 * Results:
//	 *	Returns 1 if empty, 0 if not, and -1 if unknown.
//	 *
//	 * Side effects:
//	 *	None.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func XTclCheckEmptyString(tls *libc.TLS, objPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var v1 int32
	var v3 int64
	var _ /* length at bp+0 */ TTcl_Size
	_, _ = v1, v3
	*(*TTcl_Size)(unsafe.Pointer(bp)) = int64(-libc.Int32FromInt32(1))
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes == uintptr(unsafe.Pointer(&XtclEmptyString)) {
		return int32(TCL_EMPTYSTRING_YES)
	}
	if XTclIsPureByteArray(tls, objPtr) != 0 && XTcl_GetCharLength(tls, objPtr) == 0 {
		return int32(TCL_EMPTYSTRING_YES)
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		v1 = libc.BoolInt32((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes == libc.UintptrFromInt32(0) || (*TListStore)(unsafe.Pointer((*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1)).Fflags&int32(LISTSTORE_CANONICAL) != 0 || (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr2 != libc.UintptrFromInt32(0))
	} else {
		v1 = 0
	}
	if v1 != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr2 != 0 {
				v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr2)).FspanLength
			} else {
				v3 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp)) = v3
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), objPtr, bp)
		}
		return libc.BoolInt32(*(*TTcl_Size)(unsafe.Pointer(bp)) == 0)
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes == libc.UintptrFromInt32(0) && (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDictType)) {
		XTcl_DictObjSize(tls, libc.UintptrFromInt32(0), objPtr, bp)
		return libc.BoolInt32(*(*TTcl_Size)(unsafe.Pointer(bp)) == 0)
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes == libc.UintptrFromInt32(0) {
		return int32(TCL_EMPTYSTRING_UNKNOWN)
	}
	return libc.BoolInt32((*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength == 0)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetUniChar --
 *
 *	Get the index'th Unicode character from the String object. If index
 *	is out of range or it references a low surrogate preceded by a high
 *	surrogate, the result = -1;
 *
 * Results:
 *	Returns the index'th Unicode character in the Object.
 *
 * Side effects:
 *	Fills unichar with the index'th Unicode character.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetUniChar(tls *libc.TLS, objPtr uintptr, index TTcl_Size) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Get the index'th Unicode character. */
	var _count, _i TTcl_Size
	var _str, bytes, stringPtr uintptr
	var ch int32
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _, _, _ = _count, _i, _str, bytes, ch, stringPtr
	if index < 0 {
		return -int32(1)
	}
	/*
	 * Optimize the case where we're really dealing with a ByteArray object
	 * we don't need to convert to a string to perform the indexing operation.
	 */
	if XTclIsPureByteArray(tls, objPtr) != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
		bytes = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), objPtr, bp)
		if index >= *(*TTcl_Size)(unsafe.Pointer(bp)) {
			return -int32(1)
		}
		return libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes + uintptr(index))))
	}
	/*
	 * OK, need to work with the object as a string.
	 */
	_SetStringFromAny(tls, libc.UintptrFromInt32(0), objPtr)
	stringPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1
	if (*TString)(unsafe.Pointer(stringPtr)).FhasUnicode == 0 {
		/*
		 * If numChars is unknown, compute it.
		 */
		if (*TString)(unsafe.Pointer(stringPtr)).FnumChars == int64(-libc.Int32FromInt32(1)) {
			_i = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
			_str = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
			for _i > 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(_str))) < int32(0xC0) {
				_i--
				_str++
			}
			_count = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength - _i
			if _i != 0 {
				_count += XTcl_NumUtfChars(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes+uintptr(_count), _i)
			}
			(*TString)(unsafe.Pointer(stringPtr)).FnumChars = _count
		}
		if index >= (*TString)(unsafe.Pointer(stringPtr)).FnumChars {
			return -int32(1)
		}
		if (*TString)(unsafe.Pointer(stringPtr)).FnumChars == (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength {
			return libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr(index))))
		}
		_FillUnicodeRep(tls, objPtr)
		stringPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
	}
	if index >= (*TString)(unsafe.Pointer(stringPtr)).FnumChars {
		return -int32(1)
	}
	ch = *(*TTcl_UniChar)(unsafe.Pointer(stringPtr + 28 + uintptr(index)*4))
	return ch
}

func XTclGetUniChar(tls *libc.TLS, objPtr uintptr, index TTcl_Size) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Get the index'th Unicode character. */
	var begin, bytes uintptr
	var numChars TTcl_Size
	var _ /* ch at bp+0 */ int32
	var _ /* length at bp+8 */ TTcl_Size
	_, _, _ = begin, bytes, numChars
	*(*int32)(unsafe.Pointer(bp)) = 0
	if index < 0 {
		return -int32(1)
	}
	/*
	 * Optimize the ByteArray case: no need to convert to a string to
	 * perform the indexing operation.
	 */
	if XTclIsPureByteArray(tls, objPtr) != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0
		bytes = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), objPtr, bp+8)
		if index >= *(*TTcl_Size)(unsafe.Pointer(bp + 8)) {
			return -int32(1)
		}
		return libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes + uintptr(index))))
	}
	numChars = XTclNumUtfChars(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength)
	if index >= numChars {
		return -int32(1)
	}
	begin = XTclUtfAtIndex(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, index)
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(begin))) < int32(0x80) {
		*(*int32)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(begin)))
		_ = libc.Int32FromInt32(1)
	} else {
		XTcl_UtfToUniChar(tls, begin, bp)
	}
	return *(*int32)(unsafe.Pointer(bp))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetUnicodeFromObj/TclGetUnicodeFromObj --
 *
 *	Get the Unicode form of the String object with length. If the object
 *	is not already a String object, it will be converted to one. If the
 *	String object does not have a Unicode rep, then one is create from the
 *	UTF string format.
 *
 * Results:
 *	Returns a pointer to the object's internal Unicode string.
 *
 * Side effects:
 *	Converts the object to have the String internal rep.
 *
 *----------------------------------------------------------------------
 */

func XTclGetUnicodeFromObj(tls *libc.TLS, objPtr uintptr, lengthPtr uintptr) (r uintptr) {
	/* If non-NULL, the location where the string
	 * rep's Tcl_UniChar length should be stored. If
	 * NULL, no length is stored. */
	var stringPtr uintptr
	_ = stringPtr
	_SetStringFromAny(tls, libc.UintptrFromInt32(0), objPtr)
	stringPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1
	if (*TString)(unsafe.Pointer(stringPtr)).FhasUnicode == 0 {
		_FillUnicodeRep(tls, objPtr)
		stringPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
	}
	if lengthPtr != libc.UintptrFromInt32(0) {
		if (*TString)(unsafe.Pointer(stringPtr)).FnumChars > int64(INT_MAX) {
			XTcl_Panic(tls, __ccgo_ts+66106, 0)
		}
		*(*int32)(unsafe.Pointer(lengthPtr)) = int32((*TString)(unsafe.Pointer(stringPtr)).FnumChars)
	}
	return stringPtr + 28
}

func XTcl_GetUnicodeFromObj(tls *libc.TLS, objPtr uintptr, lengthPtr uintptr) (r uintptr) {
	/* If non-NULL, the location where the string
	 * rep's unichar length should be stored. If
	 * NULL, no length is stored. */
	var stringPtr uintptr
	_ = stringPtr
	_SetStringFromAny(tls, libc.UintptrFromInt32(0), objPtr)
	stringPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1
	if (*TString)(unsafe.Pointer(stringPtr)).FhasUnicode == 0 {
		_FillUnicodeRep(tls, objPtr)
		stringPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
	}
	if lengthPtr != libc.UintptrFromInt32(0) {
		*(*TTcl_Size)(unsafe.Pointer(lengthPtr)) = (*TString)(unsafe.Pointer(stringPtr)).FnumChars
	}
	return stringPtr + 28
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetRange --
 *
 *	Create a Tcl Object that contains the chars between first and last of
 *	the object indicated by "objPtr". If the object is not already a
 *	String object, convert it to one.  If first is TCL_INDEX_NONE, the
 *	returned string start at the beginning of objPtr.  If last is
 *	TCL_INDEX_NONE, the returned string ends at the end of objPtr.
 *
 * Results:
 *	Returns a new Tcl Object of the String type.
 *
 * Side effects:
 *	Changes the internal rep of "objPtr" to the String type.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetRange(tls *libc.TLS, objPtr uintptr, first TTcl_Size, last TTcl_Size) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Last index of the range. */
	var _count, _i TTcl_Size
	var _str, bytes, cachePtr, cachePtr1, cachePtr2, newObjPtr, stringPtr uintptr
	var v1, v2, v3 bool
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _ = _count, _i, _str, bytes, cachePtr, cachePtr1, cachePtr2, newObjPtr, stringPtr, v1, v2, v3
	*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	if first < 0 {
		first = 0
	}
	/*
	 * Optimize the case where we're really dealing with a bytearray object
	 * we don't need to convert to a string to perform the substring operation.
	 */
	if XTclIsPureByteArray(tls, objPtr) != 0 {
		bytes = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), objPtr, bp)
		if last < 0 || last >= *(*TTcl_Size)(unsafe.Pointer(bp)) {
			last = *(*TTcl_Size)(unsafe.Pointer(bp)) - int64(1)
		}
		if last < first {
			if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				newObjPtr = XTclThreadAllocObj(tls)
			} else {
				newObjPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(newObjPtr + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(newObjPtr)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(newObjPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(newObjPtr)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(newObjPtr)).FtypePtr = libc.UintptrFromInt32(0)
			return newObjPtr
		}
		return XTcl_NewByteArrayObj(tls, bytes+uintptr(first), last-first+int64(1))
	}
	/*
	 * OK, need to work with the object as a string.
	 */
	_SetStringFromAny(tls, libc.UintptrFromInt32(0), objPtr)
	stringPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1
	if (*TString)(unsafe.Pointer(stringPtr)).FhasUnicode == 0 {
		/*
		 * If numChars is unknown, compute it.
		 */
		if (*TString)(unsafe.Pointer(stringPtr)).FnumChars == int64(-libc.Int32FromInt32(1)) {
			_i = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
			_str = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
			for _i > 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(_str))) < int32(0xC0) {
				_i--
				_str++
			}
			_count = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength - _i
			if _i != 0 {
				_count += XTcl_NumUtfChars(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes+uintptr(_count), _i)
			}
			(*TString)(unsafe.Pointer(stringPtr)).FnumChars = _count
		}
		if (*TString)(unsafe.Pointer(stringPtr)).FnumChars == (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength {
			if last < 0 || last >= (*TString)(unsafe.Pointer(stringPtr)).FnumChars {
				last = (*TString)(unsafe.Pointer(stringPtr)).FnumChars - int64(1)
			}
			if last < first {
				if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
					cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
					newObjPtr = XTclThreadAllocObj(tls)
				} else {
					newObjPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(newObjPtr + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(newObjPtr)).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer(newObjPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(newObjPtr)).Flength = 0
				(*TTcl_Obj)(unsafe.Pointer(newObjPtr)).FtypePtr = libc.UintptrFromInt32(0)
				return newObjPtr
			}
			newObjPtr = XTcl_NewStringObj(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes+uintptr(first), last-first+int64(1))
			/*
			 * Since we know the char length of the result, store it.
			 */
			_SetStringFromAny(tls, libc.UintptrFromInt32(0), newObjPtr)
			stringPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(newObjPtr + 32))).Fptr1
			(*TString)(unsafe.Pointer(stringPtr)).FnumChars = (*TTcl_Obj)(unsafe.Pointer(newObjPtr)).Flength
			return newObjPtr
		}
		_FillUnicodeRep(tls, objPtr)
		stringPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
	}
	if last < 0 || last >= (*TString)(unsafe.Pointer(stringPtr)).FnumChars {
		last = (*TString)(unsafe.Pointer(stringPtr)).FnumChars - int64(1)
	}
	if last < first {
		if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
			cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
			newObjPtr = XTclThreadAllocObj(tls)
		} else {
			newObjPtr = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(newObjPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(newObjPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(newObjPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(newObjPtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(newObjPtr)).FtypePtr = libc.UintptrFromInt32(0)
		return newObjPtr
	}
	return XTcl_NewUnicodeObj(tls, stringPtr+28+uintptr(first)*4, last-first+int64(1))
}

func XTclGetRange(tls *libc.TLS, objPtr uintptr, first TTcl_Size, last TTcl_Size) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Last index of the range. */
	var begin, bytes, cachePtr, cachePtr1, end, newObjPtr uintptr
	var numChars TTcl_Size
	var v1, v2 bool
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _ = begin, bytes, cachePtr, cachePtr1, end, newObjPtr, numChars, v1, v2 /* The Tcl object to find the range of. */
	*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	if first < 0 {
		first = libc.Int64FromInt32(0)
	}
	/*
	 * Optimize the case where we're really dealing with a bytearray object
	 * we don't need to convert to a string to perform the substring operation.
	 */
	if XTclIsPureByteArray(tls, objPtr) != 0 {
		bytes = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), objPtr, bp)
		if last < 0 || last >= *(*TTcl_Size)(unsafe.Pointer(bp)) {
			last = *(*TTcl_Size)(unsafe.Pointer(bp)) - int64(1)
		}
		if last < first {
			if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				newObjPtr = XTclThreadAllocObj(tls)
			} else {
				newObjPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(newObjPtr + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(newObjPtr)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(newObjPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(newObjPtr)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(newObjPtr)).FtypePtr = libc.UintptrFromInt32(0)
			return newObjPtr
		}
		return XTcl_NewByteArrayObj(tls, bytes+uintptr(first), last-first+int64(1))
	}
	numChars = XTclNumUtfChars(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength)
	if last < 0 || last >= numChars {
		last = numChars - int64(1)
	}
	if last < first {
		if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			newObjPtr = XTclThreadAllocObj(tls)
		} else {
			newObjPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(newObjPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(newObjPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(newObjPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(newObjPtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(newObjPtr)).FtypePtr = libc.UintptrFromInt32(0)
		return newObjPtr
	}
	begin = XTclUtfAtIndex(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, first)
	end = XTclUtfAtIndex(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, last+int64(1))
	return XTcl_NewStringObj(tls, begin, int64(end)-int64(begin))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetStringObj --
 *
 *	Modify an object to hold a string that is a copy of the bytes
 *	indicated by the byte pointer and length arguments.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The object's string representation will be set to a copy of the
 *	"length" bytes starting at "bytes". If "length" is TCL_INDEX_NONE, use bytes
 *	up to the first NUL byte; i.e., assume "bytes" points to a C-style
 *	NUL-terminated string. The object's old string and internal
 *	representations are freed and the object's type is set NULL.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetStringObj(tls *libc.TLS, objPtr uintptr, bytes uintptr, length TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The number of bytes to copy from "bytes"
	 * when initializing the object. If -1,
	 * use bytes up to the first NUL byte.*/
	var _isobjPtr, v2 uintptr
	var v1 uint64
	_, _, _ = _isobjPtr, v1, v2
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+10229, libc.VaList(bp+8, __ccgo_ts+66204))
	}
	/*
	 * Set the type to NULL and free any internal rep for the old type.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != libc.UintptrFromInt32(0) {
		if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc})))(tls, objPtr)
		}
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	}
	/*
	 * Free any old string rep, then set the string rep to a copy of the
	 * length bytes starting at "bytes".
	 */
	_isobjPtr = objPtr
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
	if length == int64(-libc.Int32FromInt32(1)) {
		if bytes != 0 {
			v1 = libc.Xstrlen(tls, bytes)
		} else {
			v1 = uint64(0)
		}
		length = libc.Int64FromUint64(v1)
	}
	if length == 0 {
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(length+libc.Int64FromUint32(1)))
		if bytes != 0 {
			v2 = bytes
		} else {
			v2 = uintptr(unsafe.Pointer(&XtclEmptyString))
		}
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, v2, libc.Uint64FromInt64(length))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr(length))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = length
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetObjLength --
 *
 *	Changes the length of the string representation of objPtr.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	If the size of objPtr's string representation is greater than length, a
 *	new terminating null byte is stored in objPtr->bytes at length, and
 *	bytes at positions past length have no meaning.  If the length of the
 *	string representation is greater than length, the storage space is
 *	reallocated to length+1.
 *
 *	The object's internal representation is changed to &tclStringType.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetObjLength(tls *libc.TLS, objPtr uintptr, length TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Number of bytes desired for string
	 * representation of object, not including
	 * terminating null byte. */
	var stringPtr uintptr
	_ = stringPtr
	if length < 0 {
		XTcl_Panic(tls, __ccgo_ts+66221, libc.VaList(bp+8, length))
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+10229, libc.VaList(bp+8, __ccgo_ts+66293))
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength == length {
		return
	}
	_SetStringFromAny(tls, libc.UintptrFromInt32(0), objPtr)
	stringPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != libc.UintptrFromInt32(0) {
		/*
		 * Change length of an existing string rep.
		 */
		if length > (*TString)(unsafe.Pointer(stringPtr)).Fallocated {
			/*
			 * Need to enlarge the buffer.
			 */
			if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes == uintptr(unsafe.Pointer(&XtclEmptyString)) {
				(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(length+int64(1)))
			} else {
				(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = XTcl_Realloc(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, libc.Uint64FromInt64(length+int64(1)))
			}
			(*TString)(unsafe.Pointer(stringPtr)).Fallocated = length
		}
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = length
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr(length))) = uint8(0)
		/*
		 * Invalidate the Unicode data.
		 */
		(*TString)(unsafe.Pointer(stringPtr)).FnumChars = int64(-libc.Int32FromInt32(1))
		(*TString)(unsafe.Pointer(stringPtr)).FhasUnicode = 0
	} else {
		if length > (*TString)(unsafe.Pointer(stringPtr)).FmaxChars {
			stringPtr = XTcl_Realloc(tls, stringPtr, uint64(libc.UintptrFromInt32(0)+28)+libc.Uint64FromInt64(4)+libc.Uint64FromInt64(length)*libc.Uint64FromInt64(4))
			(*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr2 = libc.UintptrFromInt32(0)
			(*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr1 = stringPtr
			(*TString)(unsafe.Pointer(stringPtr)).FmaxChars = length
		}
		/*
		 * Mark the new end of the Unicode string
		 */
		(*TString)(unsafe.Pointer(stringPtr)).FnumChars = length
		*(*TTcl_UniChar)(unsafe.Pointer(stringPtr + 28 + uintptr(length)*4)) = 0
		(*TString)(unsafe.Pointer(stringPtr)).FhasUnicode = int32(1)
		/*
		 * Can only get here when objPtr->bytes == NULL. No need to invalidate
		 * the string rep.
		 */
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_AttemptSetObjLength --
 *
 *	This function changes the length of the string representation of an
 *	object. It uses the attempt* (non-panic'ing) memory allocators.
 *
 * Results:
 *	1 if the requested memory was allocated, 0 otherwise.
 *
 * Side effects:
 *	If the size of objPtr's string representation is greater than length,
 *	then it is reduced to length and a new terminating null byte is stored
 *	in the strength. If the length of the string representation is greater
 *	than length, the storage space is reallocated to the given length; a
 *	null byte is stored at the end, but other bytes past the end of the
 *	original string representation are undefined. The object's internal
 *	representation is changed to "expendable string".
 *
 *----------------------------------------------------------------------
 */

func XTcl_AttemptSetObjLength(tls *libc.TLS, objPtr uintptr, length TTcl_Size) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Number of bytes desired for string
	 * representation of object, not including
	 * terminating null byte. */
	var newBytes, stringPtr uintptr
	_, _ = newBytes, stringPtr
	if length < 0 {
		/* Negative lengths => most likely integer overflow */
		return 0
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+10229, libc.VaList(bp+8, __ccgo_ts+66310))
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength == length {
		return int32(1)
	}
	_SetStringFromAny(tls, libc.UintptrFromInt32(0), objPtr)
	stringPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != libc.UintptrFromInt32(0) {
		/*
		 * Change length of an existing string rep.
		 */
		if length > (*TString)(unsafe.Pointer(stringPtr)).Fallocated {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes == uintptr(unsafe.Pointer(&XtclEmptyString)) {
				newBytes = XTclpAlloc(tls, libc.Uint64FromInt64(length+libc.Int64FromUint32(1)))
			} else {
				newBytes = XTclpRealloc(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, libc.Uint64FromInt64(length+libc.Int64FromUint32(1)))
			}
			if newBytes == libc.UintptrFromInt32(0) {
				return 0
			}
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = newBytes
			(*TString)(unsafe.Pointer(stringPtr)).Fallocated = length
		}
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = length
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr(length))) = uint8(0)
		/*
		 * Invalidate the Unicode data.
		 */
		(*TString)(unsafe.Pointer(stringPtr)).FnumChars = int64(-libc.Int32FromInt32(1))
		(*TString)(unsafe.Pointer(stringPtr)).FhasUnicode = 0
	} else {
		/*
		 * Changing length of pure Unicode string.
		 */
		if length > (*TString)(unsafe.Pointer(stringPtr)).FmaxChars {
			stringPtr = XTclpRealloc(tls, stringPtr, uint64(libc.UintptrFromInt32(0)+28)+libc.Uint64FromInt64(4)+libc.Uint64FromInt64(length)*libc.Uint64FromInt64(4))
			if stringPtr == libc.UintptrFromInt32(0) {
				return 0
			}
			(*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr2 = libc.UintptrFromInt32(0)
			(*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr1 = stringPtr
			(*TString)(unsafe.Pointer(stringPtr)).FmaxChars = length
		}
		/*
		 * Mark the new end of the Unicode string.
		 */
		*(*TTcl_UniChar)(unsafe.Pointer(stringPtr + 28 + uintptr(length)*4)) = 0
		(*TString)(unsafe.Pointer(stringPtr)).FnumChars = length
		(*TString)(unsafe.Pointer(stringPtr)).FhasUnicode = int32(1)
		/*
		 * Can only get here when objPtr->bytes == NULL. No need to invalidate
		 * the string rep.
		 */
	}
	return int32(1)
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_SetUnicodeObj --
 *
 *	Modify an object to hold the Unicode string indicated by "unicode".
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Memory allocated for new "String" internal rep.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_SetUnicodeObj(tls *libc.TLS, objPtr uintptr, unicode uintptr, numChars TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Number of characters in the Unicode
	 * string. */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+10229, libc.VaList(bp+8, __ccgo_ts+66334))
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != libc.UintptrFromInt32(0) {
		if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc})))(tls, objPtr)
		}
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	}
	_SetUnicodeObj(tls, objPtr, unicode, numChars)
}

func _UnicodeLength(tls *libc.TLS, unicode uintptr) (r TTcl_Size) {
	var numChars TTcl_Size
	_ = numChars
	numChars = 0
	if unicode != 0 {
		/* TODO - is this overflow check really necessary? */
		for numChars >= 0 && *(*TTcl_UniChar)(unsafe.Pointer(unicode + uintptr(numChars)*4)) != 0 {
			numChars++
		}
	}
	return numChars
}

func _SetUnicodeObj(tls *libc.TLS, objPtr uintptr, unicode uintptr, numChars TTcl_Size) {
	/* Number of characters in the Unicode
	 * string. */
	var _isobjPtr, stringPtr uintptr
	_, _ = _isobjPtr, stringPtr
	if numChars < 0 {
		numChars = _UnicodeLength(tls, unicode)
	}
	/*
	 * Allocate enough space for the String structure + Unicode string.
	 */
	stringPtr = XTcl_Alloc(tls, uint64(libc.UintptrFromInt32(0)+28)+libc.Uint64FromInt64(4)+libc.Uint64FromInt64(numChars)*libc.Uint64FromInt64(4))
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr2 = libc.UintptrFromInt32(0)
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1 = stringPtr
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclStringType))
	(*TString)(unsafe.Pointer(stringPtr)).FmaxChars = numChars
	libc.Xmemcpy(tls, stringPtr+28, unicode, libc.Uint64FromInt64(numChars)*uint64(4))
	*(*TTcl_UniChar)(unsafe.Pointer(stringPtr + 28 + uintptr(numChars)*4)) = 0
	(*TString)(unsafe.Pointer(stringPtr)).FnumChars = numChars
	(*TString)(unsafe.Pointer(stringPtr)).FhasUnicode = int32(1)
	_isobjPtr = objPtr
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
	(*TString)(unsafe.Pointer(stringPtr)).Fallocated = 0
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_AppendLimitedToObj --
 *
 *	This function appends a limited number of bytes from a sequence of
 *	bytes to an object, marking any limitation with an ellipsis.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The bytes at *bytes are appended to the string representation of
 *	objPtr.
 *
 *----------------------------------------------------------------------
 */

func XTcl_AppendLimitedToObj(tls *libc.TLS, objPtr uintptr, bytes uintptr, length TTcl_Size, limit TTcl_Size, ellipsis uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Ellipsis marker string, appended to the
	 * object to indicate not all available bytes
	 * at "bytes" were appended. */
	var eLen, toCopy TTcl_Size
	var stringPtr uintptr
	var v1 uint64
	_, _, _, _ = eLen, stringPtr, toCopy, v1
	toCopy = 0
	eLen = 0
	if length < 0 {
		if bytes != 0 {
			v1 = libc.Xstrlen(tls, bytes)
		} else {
			v1 = uint64(0)
		}
		length = libc.Int64FromUint64(v1)
	}
	if length == 0 {
		return
	}
	if limit <= 0 {
		return
	}
	if length <= limit {
		toCopy = length
	} else {
		if ellipsis == libc.UintptrFromInt32(0) {
			ellipsis = __ccgo_ts + 8560
		}
		eLen = libc.Int64FromUint64(libc.Xstrlen(tls, ellipsis))
		for eLen > limit {
			eLen = int64(XTcl_UtfPrev(tls, ellipsis+uintptr(eLen), ellipsis)) - int64(ellipsis)
		}
		toCopy = int64(XTcl_UtfPrev(tls, bytes+uintptr(limit)+uintptr(1)-uintptr(eLen), bytes)) - int64(bytes)
	}
	/*
	 * If objPtr has a valid Unicode rep, then append the Unicode conversion
	 * of "bytes" to the objPtr's Unicode rep, otherwise append "bytes" to
	 * objPtr's string rep.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+10229, libc.VaList(bp+8, __ccgo_ts+66352))
	}
	_SetStringFromAny(tls, libc.UintptrFromInt32(0), objPtr)
	stringPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1
	/* If appended string starts with a continuation byte or a lower surrogate,
	 * force objPtr to unicode representation. See [7f1162a867] */
	if bytes != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes)))&int32(0xC0) == int32(0x80) {
		XTcl_GetUnicodeFromObj(tls, objPtr, libc.UintptrFromInt32(0))
		stringPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
	}
	if (*TString)(unsafe.Pointer(stringPtr)).FhasUnicode != 0 && (*TString)(unsafe.Pointer(stringPtr)).FnumChars > 0 {
		_AppendUtfToUnicodeRep(tls, objPtr, bytes, toCopy)
	} else {
		_AppendUtfToUtfRep(tls, objPtr, bytes, toCopy)
	}
	if length <= limit {
		return
	}
	stringPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1
	if (*TString)(unsafe.Pointer(stringPtr)).FhasUnicode != 0 && (*TString)(unsafe.Pointer(stringPtr)).FnumChars > 0 {
		_AppendUtfToUnicodeRep(tls, objPtr, ellipsis, eLen)
	} else {
		_AppendUtfToUtfRep(tls, objPtr, ellipsis, eLen)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_AppendToObj --
 *
 *	This function appends a sequence of bytes to an object.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The bytes at *bytes are appended to the string representation of
 *	objPtr.
 *
 *----------------------------------------------------------------------
 */

func XTcl_AppendToObj(tls *libc.TLS, objPtr uintptr, bytes uintptr, length TTcl_Size) {
	/* The number of bytes to append from "bytes".
	 * If TCL_INDEX_NONE, then append all bytes up to NUL
	 * byte. */
	XTcl_AppendLimitedToObj(tls, objPtr, bytes, length, libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)), libc.UintptrFromInt32(0))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_AppendUnicodeToObj --
 *
 *	This function appends a Unicode string to an object in the most
 *	efficient manner possible.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Invalidates the string rep and creates a new Unicode string.
 *
 *----------------------------------------------------------------------
 */

func XTcl_AppendUnicodeToObj(tls *libc.TLS, objPtr uintptr, unicode uintptr, length TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Number of chars in Unicode. Negative
	 * lengths means nul terminated */
	var stringPtr uintptr
	_ = stringPtr
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+10229, libc.VaList(bp+8, __ccgo_ts+66375))
	}
	if length == 0 {
		return
	}
	_SetStringFromAny(tls, libc.UintptrFromInt32(0), objPtr)
	stringPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1
	/*
	 * If objPtr has a valid Unicode rep, then append the "unicode" to the
	 * objPtr's Unicode rep, otherwise the UTF conversion of "unicode" to
	 * objPtr's string rep.
	 */
	if (*TString)(unsafe.Pointer(stringPtr)).FhasUnicode != 0 {
		_AppendUnicodeToUnicodeRep(tls, objPtr, unicode, length)
	} else {
		_AppendUnicodeToUtfRep(tls, objPtr, unicode, length)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_AppendObjToObj --
 *
 *	This function appends the string rep of one object to another.
 *	"objPtr" cannot be a shared object.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The string rep of appendObjPtr is appended to the string
 *	representation of objPtr.
 *	IMPORTANT: This routine does not and MUST NOT shimmer appendObjPtr.
 *	Callers are counting on that.
 *
 *----------------------------------------------------------------------
 */

func XTcl_AppendObjToObj(tls *libc.TLS, objPtr uintptr, appendObjPtr uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Object to append. */
	var appendNumChars TTcl_Size
	var appendStringPtr, bytes, stringPtr, unicode, v1, v2, v3 uintptr
	var _ /* length at bp+0 */ TTcl_Size
	var _ /* lengthSrc at bp+16 */ TTcl_Size
	var _ /* numChars at bp+8 */ TTcl_Size
	_, _, _, _, _, _, _, _ = appendNumChars, appendStringPtr, bytes, stringPtr, unicode, v1, v2, v3
	*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	appendNumChars = int64(-libc.Int32FromInt32(1))
	if XTclCheckEmptyString(tls, appendObjPtr) == int32(TCL_EMPTYSTRING_YES) {
		return
	}
	if XTclCheckEmptyString(tls, objPtr) == int32(TCL_EMPTYSTRING_YES) {
		XTclSetDuplicateObj(tls, objPtr, appendObjPtr)
		return
	}
	if XTclIsPureByteArray(tls, appendObjPtr) != 0 && (XTclIsPureByteArray(tls, objPtr) != 0 || (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes == uintptr(unsafe.Pointer(&XtclEmptyString))) {
		/*
		 * Both bytearray objects are pure, so the second internal bytearray value
		 * can be appended to the first, with no need to modify the "bytes" field.
		 */
		/*
		 * One might expect the code here to be
		 *
		 *  bytes = Tcl_GetBytesFromObj(NULL, appendObjPtr, &length);
		 *  TclAppendBytesToByteArray(objPtr, bytes, length);
		 *
		 * and essentially all of the time that would be fine. However, it
		 * would run into trouble in the case where objPtr and appendObjPtr
		 * point to the same thing. That may never be a good idea. It seems to
		 * violate Copy On Write, and we don't have any tests for the
		 * situation, since making any Tcl commands that call
		 * Tcl_AppendObjToObj() do that appears impossible (They honor Copy On
		 * Write!). For the sake of extensions that go off into that realm,
		 * though, here's a more complex approach that can handle all the
		 * cases.
		 *
		 * First, get the lengths.
		 */
		*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = 0
		XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), objPtr, bp)
		XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), appendObjPtr, bp+16)
		/*
		 * Grow buffer enough for the append.
		 */
		XTclAppendBytesToByteArray(tls, objPtr, libc.UintptrFromInt32(0), *(*TTcl_Size)(unsafe.Pointer(bp + 16)))
		/*
		 * Reset objPtr back to the original value.
		 */
		XTcl_SetByteArrayLength(tls, objPtr, *(*TTcl_Size)(unsafe.Pointer(bp)))
		/*
		 * Now do the append knowing that buffer growth cannot cause any
		 * trouble.
		 */
		XTclAppendBytesToByteArray(tls, objPtr, XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), appendObjPtr, libc.UintptrFromInt32(0)), *(*TTcl_Size)(unsafe.Pointer(bp + 16)))
		return
	}
	/*
	 * Must append as strings.
	 */
	_SetStringFromAny(tls, libc.UintptrFromInt32(0), objPtr)
	stringPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1
	/* If appended string starts with a continuation byte or a lower surrogate,
	 * force objPtr to unicode representation. See [7f1162a867]
	 * This fixes append-3.4, append-3.7 and utf-1.18 testcases. */
	if (*TTcl_Obj)(unsafe.Pointer(appendObjPtr)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(appendObjPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, appendObjPtr, libc.UintptrFromInt32(0))
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v1)))&int32(0xC0) == int32(0x80) {
		XTcl_GetUnicodeFromObj(tls, objPtr, libc.UintptrFromInt32(0))
		stringPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
	}
	/*
	 * If objPtr has a valid Unicode rep, then get a Unicode string from
	 * appendObjPtr and append it.
	 */
	if (*TString)(unsafe.Pointer(stringPtr)).FhasUnicode != 0 {
		/*
		 * If appendObjPtr is not of the "String" type, don't convert it.
		 */
		if (*TTcl_Obj)(unsafe.Pointer(appendObjPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclStringType)) {
			unicode = XTcl_GetUnicodeFromObj(tls, appendObjPtr, bp+8)
			_AppendUnicodeToUnicodeRep(tls, objPtr, unicode, *(*TTcl_Size)(unsafe.Pointer(bp + 8)))
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(appendObjPtr)).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(appendObjPtr)).Flength
				v2 = (*TTcl_Obj)(unsafe.Pointer(appendObjPtr)).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, appendObjPtr, bp)
			}
			bytes = v2
			_AppendUtfToUnicodeRep(tls, objPtr, bytes, *(*TTcl_Size)(unsafe.Pointer(bp)))
		}
		return
	}
	/*
	 * Append to objPtr's UTF string rep. If we know the number of characters
	 * in both objects before appending, then set the combined number of
	 * characters in the final (appended-to) object.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(appendObjPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(appendObjPtr)).Flength
		v3 = (*TTcl_Obj)(unsafe.Pointer(appendObjPtr)).Fbytes
	} else {
		v3 = XTcl_GetStringFromObj(tls, appendObjPtr, bp)
	}
	bytes = v3
	*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TString)(unsafe.Pointer(stringPtr)).FnumChars
	if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) >= 0 && (*TTcl_Obj)(unsafe.Pointer(appendObjPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclStringType)) {
		appendStringPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(appendObjPtr + 32))).Fptr1
		appendNumChars = (*TString)(unsafe.Pointer(appendStringPtr)).FnumChars
	}
	_AppendUtfToUtfRep(tls, objPtr, bytes, *(*TTcl_Size)(unsafe.Pointer(bp)))
	if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) >= 0 && appendNumChars >= 0 {
		(*TString)(unsafe.Pointer(stringPtr)).FnumChars = *(*TTcl_Size)(unsafe.Pointer(bp + 8)) + appendNumChars
	}
}

/*
 *----------------------------------------------------------------------
 *
 * AppendUnicodeToUnicodeRep --
 *
 *	Appends the contents of unicode to the Unicode rep of
 *	objPtr, which must already have a valid Unicode rep.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	objPtr's internal rep is reallocated.
 *
 *----------------------------------------------------------------------
 */

func _AppendUnicodeToUnicodeRep(tls *libc.TLS, objPtr uintptr, unicode uintptr, appendNumChars TTcl_Size) {
	/* Number of chars of "unicode" to append. */
	var _isobjPtr, stringPtr uintptr
	var numChars, offset TTcl_Size
	_, _, _, _ = _isobjPtr, numChars, offset, stringPtr
	if appendNumChars < 0 {
		appendNumChars = _UnicodeLength(tls, unicode)
	}
	if appendNumChars == 0 {
		return
	}
	_SetStringFromAny(tls, libc.UintptrFromInt32(0), objPtr)
	stringPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1
	/*
	 * If not enough space has been allocated for the Unicode rep, reallocate
	 * the internal rep object with additional space. First try to double the
	 * required allocation; if that fails, try a more modest increase. See the
	 * "TCL STRING GROWTH ALGORITHM" comment at the top of this file for an
	 * explanation of this growth algorithm.
	 */
	numChars = (*TString)(unsafe.Pointer(stringPtr)).FnumChars + appendNumChars
	if numChars > (*TString)(unsafe.Pointer(stringPtr)).FmaxChars {
		offset = int64(-int32(1))
		/*
		 * Protect against case where Unicode points into the existing
		 * stringPtr->unicode array. Force it to follow any relocations due to
		 * the reallocs below.
		 */
		if unicode != 0 && unicode >= stringPtr+28 && unicode <= stringPtr+28+uintptr((*TString)(unsafe.Pointer(stringPtr)).FmaxChars)*4 {
			offset = (int64(unicode) - T__predefined_ptrdiff_t(stringPtr+28)) / 4
		}
		_GrowUnicodeBuffer(tls, objPtr, numChars)
		stringPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		/*
		 * Relocate Unicode if needed; see above.
		 */
		if offset >= 0 {
			unicode = stringPtr + 28 + uintptr(offset)*4
		}
	}
	/*
	 * Copy the new string onto the end of the old string, then add the
	 * trailing null.
	 */
	if unicode != 0 {
		libc.Xmemmove(tls, stringPtr+28+uintptr((*TString)(unsafe.Pointer(stringPtr)).FnumChars)*4, unicode, libc.Uint64FromInt64(appendNumChars)*uint64(4))
	}
	*(*TTcl_UniChar)(unsafe.Pointer(stringPtr + 28 + uintptr(numChars)*4)) = 0
	(*TString)(unsafe.Pointer(stringPtr)).FnumChars = numChars
	(*TString)(unsafe.Pointer(stringPtr)).Fallocated = 0
	_isobjPtr = objPtr
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * AppendUnicodeToUtfRep --
 *
 *	This function converts the contents of "unicode" to UTF and appends
 *	the UTF to the string rep of "objPtr".
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	objPtr's internal rep is reallocated.
 *
 *----------------------------------------------------------------------
 */

func _AppendUnicodeToUtfRep(tls *libc.TLS, objPtr uintptr, unicode uintptr, numChars TTcl_Size) {
	/* Number of chars of Unicode to convert. */
	var stringPtr uintptr
	_ = stringPtr
	stringPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1
	numChars = _ExtendStringRepWithUnicode(tls, objPtr, unicode, numChars)
	if (*TString)(unsafe.Pointer(stringPtr)).FnumChars != int64(-libc.Int32FromInt32(1)) {
		*(*TTcl_Size)(unsafe.Pointer(stringPtr)) += numChars
	}
}

/*
 *----------------------------------------------------------------------
 *
 * AppendUtfToUnicodeRep --
 *
 *	This function converts the contents of "bytes" to Unicode and appends
 *	the Unicode to the Unicode rep of "objPtr". objPtr must already have a
 *	valid Unicode rep. numBytes must be non-negative.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	objPtr's internal rep is reallocated and string rep is cleaned.
 *
 *----------------------------------------------------------------------
 */

func _AppendUtfToUnicodeRep(tls *libc.TLS, objPtr uintptr, bytes uintptr, numBytes TTcl_Size) {
	/* Number of bytes of "bytes" to convert. */
	var _isobjPtr, stringPtr uintptr
	_, _ = _isobjPtr, stringPtr
	if numBytes == 0 {
		return
	}
	_ExtendUnicodeRepWithString(tls, objPtr, bytes, numBytes, int64(-int32(1)))
	_isobjPtr = objPtr
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
	stringPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1
	(*TString)(unsafe.Pointer(stringPtr)).Fallocated = 0
}

/*
 *----------------------------------------------------------------------
 *
 * AppendUtfToUtfRep --
 *
 *	This function appends "numBytes" bytes of "bytes" to the UTF string
 *	rep of "objPtr". objPtr must already have a valid String rep.
 *	numBytes must be non-negative.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	objPtr's string rep is reallocated (by TCL STRING GROWTH ALGORITHM).
 *
 *----------------------------------------------------------------------
 */

func _AppendUtfToUtfRep(tls *libc.TLS, objPtr uintptr, bytes uintptr, numBytes TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Number of bytes of "bytes" to append. */
	var newLength, offset, oldLength TTcl_Size
	var stringPtr uintptr
	_, _, _, _ = newLength, offset, oldLength, stringPtr
	if numBytes == 0 {
		return
	}
	/*
	 * Copy the new string onto the end of the old string, then add the
	 * trailing null.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes == libc.UintptrFromInt32(0) {
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	}
	oldLength = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
	if numBytes > libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))-oldLength {
		XTcl_Panic(tls, __ccgo_ts+66398, libc.VaList(bp+8, libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))))
	}
	newLength = numBytes + oldLength
	stringPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1
	if newLength > (*TString)(unsafe.Pointer(stringPtr)).Fallocated {
		offset = int64(-int32(1))
		/*
		 * Protect against case where unicode points into the existing
		 * stringPtr->unicode array. Force it to follow any relocations due to
		 * the reallocs below.
		 */
		if bytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 && bytes >= (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes && bytes <= (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes+uintptr((*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength) {
			offset = int64(bytes) - int64((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes)
		}
		/*
		 * TODO: consider passing flag=1: no overalloc on first append. This
		 * would make test stringObj-8.1 fail.
		 */
		_GrowStringBuffer(tls, objPtr, newLength, 0)
		/*
		 * Relocate bytes if needed; see above.
		 */
		if offset >= 0 {
			bytes = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr(offset)
		}
	}
	/*
	 * Invalidate the unicode data.
	 */
	(*TString)(unsafe.Pointer(stringPtr)).FnumChars = int64(-int32(1))
	(*TString)(unsafe.Pointer(stringPtr)).FhasUnicode = 0
	if bytes != 0 {
		libc.Xmemmove(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes+uintptr(oldLength), bytes, libc.Uint64FromInt64(numBytes))
	}
	*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr(newLength))) = uint8(0)
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = newLength
}

/*
 *----------------------------------------------------------------------
 *
 * TclAppendUtfToUtf --
 *
 *	This function appends "numBytes" bytes of "bytes" to the UTF string
 *	rep of "objPtr" (objPtr's internal rep converted to string on demand).
 *	numBytes must be non-negative.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	objPtr's string rep is reallocated (by TCL STRING GROWTH ALGORITHM).
 *
 *----------------------------------------------------------------------
 */

func XTclAppendUtfToUtf(tls *libc.TLS, objPtr uintptr, bytes uintptr, numBytes TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Number of bytes of "bytes" to append. */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+10229, libc.VaList(bp+8, __ccgo_ts+66444))
	}
	_SetStringFromAny(tls, libc.UintptrFromInt32(0), objPtr)
	_AppendUtfToUtfRep(tls, objPtr, bytes, numBytes)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_AppendStringsToObj --
 *
 *	This function appends one or more null-terminated strings to an
 *	object.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The contents of all the string arguments are appended to the string
 *	representation of objPtr.
 *
 *----------------------------------------------------------------------
 */

func XTcl_AppendStringsToObj(tls *libc.TLS, objPtr uintptr, va uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var argList Tva_list
	var bytes uintptr
	_, _ = argList, bytes
	argList = va
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+10229, libc.VaList(bp+8, __ccgo_ts+66462))
	}
	for int32(1) != 0 {
		bytes = libc.VaUintptr(&argList)
		if bytes == libc.UintptrFromInt32(0) {
			break
		}
		XTcl_AppendToObj(tls, objPtr, bytes, int64(-int32(1)))
	}
	_ = argList
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_AppendFormatToObj --
 *
 *	This function appends a list of Tcl_Obj's to a Tcl_Obj according to
 *	the formatting instructions embedded in the format string. The
 *	formatting instructions are inspired by sprintf(). Returns TCL_OK when
 *	successful. If there's an error in the arguments, TCL_ERROR is
 *	returned, and an error message is written to the interp, if non-NULL.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_AppendFormatToObj(tls *libc.TLS, interp uintptr, appendObj uintptr, format uintptr, objc TTcl_Size, objv uintptr) (r int32) {
	bp := tls.Alloc(224)
	defer tls.Free(224)
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, bytes, bytes1, bytes2, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, errCode, msg, p, pure, pure1, q, segment, span, v14, v30, v31, v35, v37, v41, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v59, v60, v62, v63, v64, v67, v69, v70, v8 uintptr
	var allocSegment, base, cmpResult, digitOffset, gotHash, gotMinus, gotPlus, gotPrecision, gotSequential, gotSpace, gotXpg, gotZero, index, isNegative, leftover, length, length3, newXpg, numBits, position, sawFlag, shift, step, useBig, useShort, useWide, v15, v27, v28, v38, v44, v46, v9 int32
	var bits, uw TTcl_WideUInt
	var length2, limit, numBytes, numChars, objIndex, segmentLimit, toAppend, v36, v42, v47, v58, v61, v66, v68 TTcl_Size
	var mask Tmp_digit
	var numDigits, v11, v43 TTcl_WideInt
	var s int16
	var ul uint32
	var ull, ull1 uint64
	var us uint16
	var v10, v12, v13, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v3, v4, v6, v7 int64
	var v26, v29, v32, v33, v34, v39, v40, v45, v57 bool
	var _ /* big at bp+72 */ Tmp_int
	var _ /* buf at bp+48 */ [4]uint8
	var _ /* ch at bp+8 */ TTcl_UniChar
	var _ /* code at bp+52 */ int32
	var _ /* d at bp+168 */ float64
	var _ /* end at bp+16 */ uintptr
	var _ /* l at bp+56 */ int32
	var _ /* length at bp+96 */ TTcl_Size
	var _ /* originalLength at bp+0 */ TTcl_Size
	var _ /* precision at bp+32 */ TTcl_WideInt
	var _ /* segmentNumBytes at bp+40 */ TTcl_Size
	var _ /* spec at bp+104 */ [57]uint8
	var _ /* w at bp+64 */ TTcl_WideInt
	var _ /* width at bp+24 */ TTcl_WideInt
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, allocSegment, base, bits, bytes, bytes1, bytes2, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cmpResult, digitOffset, errCode, gotHash, gotMinus, gotPlus, gotPrecision, gotSequential, gotSpace, gotXpg, gotZero, index, isNegative, leftover, length, length2, length3, limit, mask, msg, newXpg, numBits, numBytes, numChars, numDigits, objIndex, p, position, pure, pure1, q, s, sawFlag, segment, segmentLimit, shift, span, step, toAppend, ul, ull, ull1, us, useBig, useShort, useWide, uw, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v66, v67, v68, v69, v7, v70, v8, v9
	span = format
	gotXpg = 0
	gotSequential = 0
	objIndex = 0
	numBytes = 0
	*(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) = 0
	if (*TTcl_Obj)(unsafe.Pointer(appendObj)).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+10229, libc.VaList(bp+184, __ccgo_ts+66519))
	}
	if (*TTcl_Obj)(unsafe.Pointer(appendObj)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(appendObj)).Flength
		_ = (*TTcl_Obj)(unsafe.Pointer(appendObj)).Fbytes
	} else {
		XTcl_GetStringFromObj(tls, appendObj, bp)
	}
	limit = libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)) - *(*TTcl_Size)(unsafe.Pointer(bp))
	/*
	 * Format string is NUL-terminated.
	 */
	for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format))) != int32('\000') {
		gotMinus = 0
		gotHash = 0
		gotZero = 0
		gotSpace = 0
		gotPlus = 0
		useShort = 0
		useBig = 0
		useWide = 0
		allocSegment = 0
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format)))
			v2 = int64(libc.Int32FromInt32(1))
		} else {
			v2 = XTcl_UtfToUniChar(tls, format, bp+8)
		}
		step = int32(v2)
		format += uintptr(step)
		if *(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) != int32('%') {
			numBytes += int64(step)
			continue
		}
		if numBytes != 0 {
			if numBytes > limit {
				msg = _overflow
				errCode = __ccgo_ts + 33538
				goto errorMsg
			}
			XTcl_AppendToObj(tls, appendObj, span, numBytes)
			limit -= numBytes
			numBytes = 0
		}
		/*
		 * Saw a % : process the format specifier.
		 *
		 * Step 0. Handle special case of escaped format marker (i.e., %%).
		 */
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format)))
			v3 = int64(libc.Int32FromInt32(1))
		} else {
			v3 = XTcl_UtfToUniChar(tls, format, bp+8)
		}
		step = int32(v3)
		if *(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) == int32('%') {
			span = format
			numBytes = int64(step)
			format += uintptr(step)
			continue
		}
		/*
		 * Step 1. XPG3 position specifier
		 */
		newXpg = 0
		if libc.BoolInt32(uint32(libc.Uint8FromInt32(*(*TTcl_UniChar)(unsafe.Pointer(bp + 8))))-uint32('0') < uint32(10)) != 0 {
			position = libc.Int32FromUint64(libc.Xstrtoul(tls, format, bp+16, int32(10)))
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16))))) == int32('$') {
				newXpg = int32(1)
				objIndex = int64(position - int32(1))
				format = *(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(1)
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format))) < int32(0x80) {
					*(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format)))
					v4 = int64(libc.Int32FromInt32(1))
				} else {
					v4 = XTcl_UtfToUniChar(tls, format, bp+8)
				}
				step = int32(v4)
			}
		}
		if newXpg != 0 {
			if gotSequential != 0 {
				msg = _mixedXPG
				errCode = __ccgo_ts + 65411
				goto errorMsg
			}
			gotXpg = int32(1)
		} else {
			if gotXpg != 0 {
				msg = _mixedXPG
				errCode = __ccgo_ts + 65411
				goto errorMsg
			}
			gotSequential = int32(1)
		}
		if objIndex < 0 || objIndex >= objc {
			msg = _badIndex[gotXpg]
			if gotXpg != 0 {
				v5 = __ccgo_ts + 65858
			} else {
				v5 = __ccgo_ts + 65926
			}
			errCode = v5
			goto errorMsg
		}
		/*
		 * Step 2. Set of flags.
		 */
		sawFlag = int32(1)
		for cond := true; cond; cond = sawFlag != 0 {
			switch *(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) {
			case int32('-'):
				gotMinus = int32(1)
			case int32('#'):
				gotHash = int32(1)
			case int32('0'):
				gotZero = int32(1)
			case int32(' '):
				gotSpace = int32(1)
			case int32('+'):
				gotPlus = int32(1)
			default:
				sawFlag = 0
			}
			if sawFlag != 0 {
				format += uintptr(step)
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format))) < int32(0x80) {
					*(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format)))
					v6 = int64(libc.Int32FromInt32(1))
				} else {
					v6 = XTcl_UtfToUniChar(tls, format, bp+8)
				}
				step = int32(v6)
			}
		}
		/*
		 * Step 3. Minimum field width.
		 */
		*(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) = 0
		if libc.BoolInt32(uint32(libc.Uint8FromInt32(*(*TTcl_UniChar)(unsafe.Pointer(bp + 8))))-uint32('0') < uint32(10)) != 0 {
			ull = libc.Xstrtoull(tls, format, bp+16, int32(10))
			/* Comparison is >=, not >, to leave room for nul */
			if ull >= libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) {
				msg = _overflow
				errCode = __ccgo_ts + 33538
				goto errorMsg
			}
			*(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) = libc.Int64FromUint64(ull)
			format = *(*uintptr)(unsafe.Pointer(bp + 16))
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format))) < int32(0x80) {
				*(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format)))
				v7 = int64(libc.Int32FromInt32(1))
			} else {
				v7 = XTcl_UtfToUniChar(tls, format, bp+8)
			}
			step = int32(v7)
		} else {
			if *(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) == int32('*') {
				if objIndex >= objc-int64(1) {
					msg = _badIndex[gotXpg]
					if gotXpg != 0 {
						v8 = __ccgo_ts + 65858
					} else {
						v8 = __ccgo_ts + 65926
					}
					errCode = v8
					goto errorMsg
				}
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objIndex)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
					*(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objIndex)*8)))).FinternalRep))
					v9 = libc.Int32FromInt32(TCL_OK)
				} else {
					v9 = XTcl_GetWideIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(objIndex)*8)), bp+24)
				}
				if v9 != TCL_OK {
					goto error
				}
				if *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) < 0 {
					*(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) = -*(*TTcl_WideInt)(unsafe.Pointer(bp + 24))
					gotMinus = int32(1)
				}
				objIndex++
				format += uintptr(step)
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format))) < int32(0x80) {
					*(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format)))
					v10 = int64(libc.Int32FromInt32(1))
				} else {
					v10 = XTcl_UtfToUniChar(tls, format, bp+8)
				}
				step = int32(v10)
			}
		}
		if *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) > limit {
			msg = _overflow
			errCode = __ccgo_ts + 33538
			goto errorMsg
		}
		/*
		 * Step 4. Precision.
		 */
		v11 = libc.Int64FromInt32(0)
		*(*TTcl_WideInt)(unsafe.Pointer(bp + 32)) = v11
		gotPrecision = int32(v11)
		if *(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) == int32('.') {
			gotPrecision = int32(1)
			format += uintptr(step)
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format))) < int32(0x80) {
				*(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format)))
				v12 = int64(libc.Int32FromInt32(1))
			} else {
				v12 = XTcl_UtfToUniChar(tls, format, bp+8)
			}
			step = int32(v12)
		}
		if libc.BoolInt32(uint32(libc.Uint8FromInt32(*(*TTcl_UniChar)(unsafe.Pointer(bp + 8))))-uint32('0') < uint32(10)) != 0 {
			ull1 = libc.Xstrtoull(tls, format, bp+16, int32(10))
			/* Comparison is >=, not >, to leave room for nul */
			if ull1 >= libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) {
				msg = _overflow
				errCode = __ccgo_ts + 33538
				goto errorMsg
			}
			*(*TTcl_WideInt)(unsafe.Pointer(bp + 32)) = libc.Int64FromUint64(ull1)
			format = *(*uintptr)(unsafe.Pointer(bp + 16))
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format))) < int32(0x80) {
				*(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format)))
				v13 = int64(libc.Int32FromInt32(1))
			} else {
				v13 = XTcl_UtfToUniChar(tls, format, bp+8)
			}
			step = int32(v13)
		} else {
			if *(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) == int32('*') {
				if objIndex >= objc-int64(1) {
					msg = _badIndex[gotXpg]
					if gotXpg != 0 {
						v14 = __ccgo_ts + 65858
					} else {
						v14 = __ccgo_ts + 65926
					}
					errCode = v14
					goto errorMsg
				}
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objIndex)*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
					*(*TTcl_WideInt)(unsafe.Pointer(bp + 32)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objIndex)*8)))).FinternalRep))
					v15 = libc.Int32FromInt32(TCL_OK)
				} else {
					v15 = XTcl_GetWideIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(objIndex)*8)), bp+32)
				}
				if v15 != TCL_OK {
					goto error
				}
				/*
				 * TODO: Check this truncation logic.
				 */
				if *(*TTcl_WideInt)(unsafe.Pointer(bp + 32)) < 0 {
					*(*TTcl_WideInt)(unsafe.Pointer(bp + 32)) = 0
				}
				objIndex++
				format += uintptr(step)
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format))) < int32(0x80) {
					*(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format)))
					v16 = int64(libc.Int32FromInt32(1))
				} else {
					v16 = XTcl_UtfToUniChar(tls, format, bp+8)
				}
				step = int32(v16)
			}
		}
		/*
		 * Step 5. Length modifier.
		 */
		if *(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) == int32('h') {
			useShort = int32(1)
			format += uintptr(step)
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format))) < int32(0x80) {
				*(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format)))
				v17 = int64(libc.Int32FromInt32(1))
			} else {
				v17 = XTcl_UtfToUniChar(tls, format, bp+8)
			}
			step = int32(v17)
		} else {
			if *(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) == int32('l') {
				format += uintptr(step)
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format))) < int32(0x80) {
					*(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format)))
					v18 = int64(libc.Int32FromInt32(1))
				} else {
					v18 = XTcl_UtfToUniChar(tls, format, bp+8)
				}
				step = int32(v18)
				if *(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) == int32('l') {
					useBig = int32(1)
					format += uintptr(step)
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format))) < int32(0x80) {
						*(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format)))
						v19 = int64(libc.Int32FromInt32(1))
					} else {
						v19 = XTcl_UtfToUniChar(tls, format, bp+8)
					}
					step = int32(v19)
				} else {
					useWide = int32(1)
				}
			} else {
				if *(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) == int32('I') {
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format + 1))) == int32('6') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format + 2))) == int32('4') {
						format += uintptr(step + libc.Int32FromInt32(2))
						if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format))) < int32(0x80) {
							*(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format)))
							v20 = int64(libc.Int32FromInt32(1))
						} else {
							v20 = XTcl_UtfToUniChar(tls, format, bp+8)
						}
						step = int32(v20)
						useWide = int32(1)
					} else {
						if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format + 1))) == int32('3') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format + 2))) == int32('2') {
							format += uintptr(step + libc.Int32FromInt32(2))
							if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format))) < int32(0x80) {
								*(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format)))
								v21 = int64(libc.Int32FromInt32(1))
							} else {
								v21 = XTcl_UtfToUniChar(tls, format, bp+8)
							}
							step = int32(v21)
						} else {
							format += uintptr(step)
							if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format))) < int32(0x80) {
								*(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format)))
								v22 = int64(libc.Int32FromInt32(1))
							} else {
								v22 = XTcl_UtfToUniChar(tls, format, bp+8)
							}
							step = int32(v22)
						}
					}
				} else {
					if *(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) == int32('q') || *(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) == int32('j') {
						format += uintptr(step)
						if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format))) < int32(0x80) {
							*(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format)))
							v23 = int64(libc.Int32FromInt32(1))
						} else {
							v23 = XTcl_UtfToUniChar(tls, format, bp+8)
						}
						step = int32(v23)
						useWide = int32(1)
					} else {
						if *(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) == int32('t') || *(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) == int32('z') {
							format += uintptr(step)
							if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format))) < int32(0x80) {
								*(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format)))
								v24 = int64(libc.Int32FromInt32(1))
							} else {
								v24 = XTcl_UtfToUniChar(tls, format, bp+8)
							}
							step = int32(v24)
							if uint64(8) > uint64(4) {
								useWide = int32(1)
							}
						} else {
							if *(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) == int32('L') {
								format += uintptr(step)
								if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format))) < int32(0x80) {
									*(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(format)))
									v25 = int64(libc.Int32FromInt32(1))
								} else {
									v25 = XTcl_UtfToUniChar(tls, format, bp+8)
								}
								step = int32(v25)
								useBig = int32(1)
							}
						}
					}
				}
			}
		}
		format += uintptr(step)
		span = format
		/*
		 * Step 6. The actual conversion character.
		 */
		segment = *(*uintptr)(unsafe.Pointer(objv + uintptr(objIndex)*8))
		numChars = int64(-int32(1))
		if *(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) == int32('i') {
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) = int32('d')
		}
		switch *(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) {
		case int32('\000'):
			msg = __ccgo_ts + 66541
			errCode = __ccgo_ts + 66590
			goto errorMsg
		case int32('s'):
			if gotPrecision != 0 {
				numChars = XTcl_GetCharLength(tls, segment)
				if *(*TTcl_WideInt)(unsafe.Pointer(bp + 32)) < numChars {
					if *(*TTcl_WideInt)(unsafe.Pointer(bp + 32)) < int64(1) {
						if v26 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v26 {
							cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v26 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
							segment = XTclThreadAllocObj(tls)
						} else {
							segment = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(segment + 32))).Fptr1
							(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
						}
						(*TTcl_Obj)(unsafe.Pointer(segment)).FrefCount = 0
						(*TTcl_Obj)(unsafe.Pointer(segment)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
						(*TTcl_Obj)(unsafe.Pointer(segment)).Flength = 0
						(*TTcl_Obj)(unsafe.Pointer(segment)).FtypePtr = libc.UintptrFromInt32(0)
					} else {
						segment = XTcl_GetRange(tls, segment, 0, *(*TTcl_WideInt)(unsafe.Pointer(bp + 32))-int64(1))
					}
					numChars = *(*TTcl_WideInt)(unsafe.Pointer(bp + 32))
					(*TTcl_Obj)(unsafe.Pointer(segment)).FrefCount++
					allocSegment = int32(1)
				}
			}
		case int32('c'):
			*(*[4]uint8)(unsafe.Pointer(bp + 48)) = [4]uint8{}
			if (*TTcl_Obj)(unsafe.Pointer(segment)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(segment)).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(segment)).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
				*(*int32)(unsafe.Pointer(bp + 52)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(segment)).FinternalRep)))
				v27 = libc.Int32FromInt32(TCL_OK)
			} else {
				v27 = XTcl_GetIntFromObj(tls, interp, segment, bp+52)
			}
			if v27 != TCL_OK {
				goto error
			}
			if libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 52))) > uint32(0x10FFFF) {
				*(*int32)(unsafe.Pointer(bp + 52)) = int32(0xFFFD)
			}
			length = int32(XTcl_UniCharToUtf(tls, *(*int32)(unsafe.Pointer(bp + 52)), bp+48))
			segment = XTcl_NewStringObj(tls, bp+48, int64(length))
			(*TTcl_Obj)(unsafe.Pointer(segment)).FrefCount++
			allocSegment = int32(1)
		case int32('u'):
			/* FALLTHRU */
			fallthrough
		case int32('d'):
			fallthrough
		case int32('o'):
			fallthrough
		case int32('p'):
			fallthrough
		case int32('x'):
			fallthrough
		case int32('X'):
			fallthrough
		case int32('b'):
			s = 0
			isNegative = 0
			if *(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) == int32('p') && libc.Bool(uint64(8) > uint64(4)) {
				useWide = int32(1)
			}
			if useBig != 0 {
				if XTcl_GetBignumFromObj(tls, interp, segment, bp+72) != TCL_OK {
					goto error
				}
				cmpResult = XTclBN_mp_cmp_d(tls, bp+72, uint32(0))
				isNegative = libc.BoolInt32(cmpResult == -int32(1))
				if cmpResult == MP_EQ {
					gotHash = 0
				}
				if *(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) == int32('u') {
					if isNegative != 0 {
						XTclBN_mp_clear(tls, bp+72)
						msg = __ccgo_ts + 66601
						errCode = __ccgo_ts + 66042
						goto errorMsg
					} else {
						*(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) = int32('d')
					}
				}
			} else {
				if useWide != 0 {
					if XTclGetWideBitsFromObj(tls, interp, segment, bp+64) != TCL_OK {
						goto error
					}
					isNegative = libc.BoolInt32(*(*TTcl_WideInt)(unsafe.Pointer(bp + 64)) < libc.Int64FromInt32(0))
					if *(*TTcl_WideInt)(unsafe.Pointer(bp + 64)) == libc.Int64FromInt32(0) {
						gotHash = 0
					}
				} else {
					if (*TTcl_Obj)(unsafe.Pointer(segment)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(segment)).FinternalRep)) >= int64(-libc.Int32FromInt32(1)-libc.Int32FromInt32(0x7fffffff)) && *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(segment)).FinternalRep)) <= int64(libc.Int32FromInt32(INT_MAX)) {
						*(*int32)(unsafe.Pointer(bp + 56)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(segment)).FinternalRep)))
						v28 = libc.Int32FromInt32(TCL_OK)
					} else {
						v28 = XTcl_GetIntFromObj(tls, libc.UintptrFromInt32(0), segment, bp+56)
					}
					if v28 != TCL_OK {
						if XTclGetWideBitsFromObj(tls, interp, segment, bp+64) != TCL_OK {
							goto error
						} else {
							*(*int32)(unsafe.Pointer(bp + 56)) = int32(*(*TTcl_WideInt)(unsafe.Pointer(bp + 64)))
						}
						if useShort != 0 {
							s = int16(*(*int32)(unsafe.Pointer(bp + 56)))
							isNegative = libc.BoolInt32(int32(s) < int32(libc.Int16FromInt32(0)))
							if int32(s) == int32(libc.Int16FromInt32(0)) {
								gotHash = 0
							}
						} else {
							isNegative = libc.BoolInt32(*(*int32)(unsafe.Pointer(bp + 56)) < libc.Int32FromInt32(0))
							if *(*int32)(unsafe.Pointer(bp + 56)) == libc.Int32FromInt32(0) {
								gotHash = 0
							}
						}
					} else {
						if useShort != 0 {
							s = int16(*(*int32)(unsafe.Pointer(bp + 56)))
							isNegative = libc.BoolInt32(int32(s) < int32(libc.Int16FromInt32(0)))
							if int32(s) == int32(libc.Int16FromInt32(0)) {
								gotHash = 0
							}
						} else {
							isNegative = libc.BoolInt32(*(*int32)(unsafe.Pointer(bp + 56)) < libc.Int32FromInt32(0))
							if *(*int32)(unsafe.Pointer(bp + 56)) == libc.Int32FromInt32(0) {
								gotHash = 0
							}
						}
					}
				}
			}
			if v29 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v29 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v29 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
				segment = XTclThreadAllocObj(tls)
			} else {
				segment = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(segment + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(segment)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(segment)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(segment)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(segment)).FtypePtr = libc.UintptrFromInt32(0)
			allocSegment = int32(1)
			segmentLimit = libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
			(*TTcl_Obj)(unsafe.Pointer(segment)).FrefCount++
			if (isNegative != 0 || gotPlus != 0 || gotSpace != 0) && (useBig != 0 || *(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) == int32('d')) {
				if isNegative != 0 {
					v30 = __ccgo_ts + 6319
				} else {
					if gotPlus != 0 {
						v31 = __ccgo_ts + 6233
					} else {
						v31 = __ccgo_ts + 14830
					}
					v30 = v31
				}
				XTcl_AppendToObj(tls, segment, v30, int64(1))
				segmentLimit -= int64(1)
			}
			if gotHash != 0 || *(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) == int32('p') {
				switch *(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) {
				case int32('o'):
					XTcl_AppendToObj(tls, segment, __ccgo_ts+46049, int64(2))
					segmentLimit -= int64(2)
				case int32('p'):
					fallthrough
				case int32('x'):
					fallthrough
				case int32('X'):
					XTcl_AppendToObj(tls, segment, __ccgo_ts+66635, int64(2))
					segmentLimit -= int64(2)
				case int32('b'):
					XTcl_AppendToObj(tls, segment, __ccgo_ts+66638, int64(2))
					segmentLimit -= int64(2)
				case int32('d'):
					XTcl_AppendToObj(tls, segment, __ccgo_ts+66641, int64(2))
					segmentLimit -= int64(2)
					break
				}
			}
			switch *(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) {
			case int32('d'):
				if useShort != 0 {
					if v32 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v32 {
						cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v32 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
						pure = XTclThreadAllocObj(tls)
					} else {
						pure = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(pure + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer(pure)).FrefCount = 0
					(*TTcl_Obj)(unsafe.Pointer(pure)).Fbytes = libc.UintptrFromInt32(0)
					*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(pure)).FinternalRep)) = int64(s)
					(*TTcl_Obj)(unsafe.Pointer(pure)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
				} else {
					if useWide != 0 {
						if v33 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v33 {
							cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v33 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
							pure = XTclThreadAllocObj(tls)
						} else {
							pure = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(pure + 32))).Fptr1
							(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
						}
						(*TTcl_Obj)(unsafe.Pointer(pure)).FrefCount = 0
						(*TTcl_Obj)(unsafe.Pointer(pure)).Fbytes = libc.UintptrFromInt32(0)
						*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(pure)).FinternalRep)) = *(*TTcl_WideInt)(unsafe.Pointer(bp + 64))
						(*TTcl_Obj)(unsafe.Pointer(pure)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
					} else {
						if useBig != 0 {
							pure = XTcl_NewBignumObj(tls, bp+72)
						} else {
							if v34 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v34 {
								cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
							}
							if v34 || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == libc.Uint64FromInt32(0) {
								pure = XTclThreadAllocObj(tls)
							} else {
								pure = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
								(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer(pure + 32))).Fptr1
								(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects--
							}
							(*TTcl_Obj)(unsafe.Pointer(pure)).FrefCount = 0
							(*TTcl_Obj)(unsafe.Pointer(pure)).Fbytes = libc.UintptrFromInt32(0)
							*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(pure)).FinternalRep)) = int64(*(*int32)(unsafe.Pointer(bp + 56)))
							(*TTcl_Obj)(unsafe.Pointer(pure)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
						}
					}
				}
				(*TTcl_Obj)(unsafe.Pointer(pure)).FrefCount++
				if (*TTcl_Obj)(unsafe.Pointer(pure)).Fbytes != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp + 96)) = (*TTcl_Obj)(unsafe.Pointer(pure)).Flength
					v35 = (*TTcl_Obj)(unsafe.Pointer(pure)).Fbytes
				} else {
					v35 = XTcl_GetStringFromObj(tls, pure, bp+96)
				}
				bytes = v35
				/*
				 * Already did the sign above.
				 */
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes))) == int32('-') {
					*(*TTcl_Size)(unsafe.Pointer(bp + 96))--
					bytes++
				}
				toAppend = *(*TTcl_Size)(unsafe.Pointer(bp + 96))
				/*
				 * Canonical decimal string reps for integers are composed
				 * entirely of one-byte encoded characters, so "length" is the
				 * number of chars.
				 */
				if gotPrecision != 0 {
					if *(*TTcl_Size)(unsafe.Pointer(bp + 96)) < *(*TTcl_WideInt)(unsafe.Pointer(bp + 32)) {
						segmentLimit = segmentLimit - (*(*TTcl_WideInt)(unsafe.Pointer(bp + 32)) - *(*TTcl_Size)(unsafe.Pointer(bp + 96)))
					}
					for *(*TTcl_Size)(unsafe.Pointer(bp + 96)) < *(*TTcl_WideInt)(unsafe.Pointer(bp + 32)) {
						XTcl_AppendToObj(tls, segment, __ccgo_ts+14828, int64(1))
						*(*TTcl_Size)(unsafe.Pointer(bp + 96))++
					}
					gotZero = 0
				}
				if gotZero != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp + 96)) += XTcl_GetCharLength(tls, segment)
					if *(*TTcl_Size)(unsafe.Pointer(bp + 96)) < *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) {
						segmentLimit = segmentLimit - (*(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) - *(*TTcl_Size)(unsafe.Pointer(bp + 96)))
					}
					for *(*TTcl_Size)(unsafe.Pointer(bp + 96)) < *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) {
						XTcl_AppendToObj(tls, segment, __ccgo_ts+14828, int64(1))
						*(*TTcl_Size)(unsafe.Pointer(bp + 96))++
					}
				}
				if toAppend > segmentLimit {
					msg = _overflow
					errCode = __ccgo_ts + 33538
					goto errorMsg
				}
				XTcl_AppendToObj(tls, segment, bytes, toAppend)
				_objPtr = pure
				v37 = _objPtr
				v36 = *(*TTcl_Size)(unsafe.Pointer(v37))
				*(*TTcl_Size)(unsafe.Pointer(v37))--
				if v36 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
			case int32('u'):
				fallthrough
			case int32('o'):
				fallthrough
			case int32('p'):
				fallthrough
			case int32('x'):
				fallthrough
			case int32('X'):
				fallthrough
			case int32('b'):
				bits = uint64(0)
				numDigits = 0
				numBits = int32(4)
				base = int32(16)
				index = 0
				shift = 0
				if *(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) == int32('u') {
					base = int32(10)
				} else {
					if *(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) == int32('o') {
						base = int32(8)
						numBits = int32(3)
					} else {
						if *(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) == int32('b') {
							base = int32(2)
							numBits = int32(1)
						}
					}
				}
				if useShort != 0 {
					us = libc.Uint16FromInt16(s)
					bits = uint64(us)
					for us != 0 {
						numDigits++
						us = uint16(int32(us) / base)
					}
				} else {
					if useWide != 0 {
						uw = libc.Uint64FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 64)))
						bits = uw
						for uw != 0 {
							numDigits++
							uw /= libc.Uint64FromInt32(base)
						}
					} else {
						if v39 = useBig != 0; v39 {
							if (*Tmp_int)(unsafe.Pointer(bp+72)).Fused == 0 {
								v38 = int32(MP_YES)
							} else {
								v38 = MP_NO
							}
						}
						if v39 && !(v38 != 0) {
							leftover = (*(*Tmp_int)(unsafe.Pointer(bp + 72))).Fused * int32(MP_DIGIT_BIT) % numBits
							mask = ^libc.Uint32FromInt32(0) << (int32(MP_DIGIT_BIT) - leftover)
							numDigits = int64(1) + int64((*(*Tmp_int)(unsafe.Pointer(bp + 72))).Fused)*int64(MP_DIGIT_BIT)/int64(numBits)
							for mask&*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 72))).Fdp + uintptr((*(*Tmp_int)(unsafe.Pointer(bp + 72))).Fused-int32(1))*4)) == uint32(0) {
								numDigits--
								mask >>= libc.Uint32FromInt32(numBits)
							}
							if numDigits > int64(INT_MAX) {
								msg = _overflow
								errCode = __ccgo_ts + 33538
								goto errorMsg
							}
						} else {
							if !(useBig != 0) {
								ul = libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(bp + 56)))
								bits = uint64(ul)
								for ul != 0 {
									numDigits++
									ul /= libc.Uint32FromInt32(base)
								}
							}
						}
					}
				}
				/*
				 * Need to be sure zero becomes "0", not "".
				 */
				if numDigits == 0 {
					numDigits = int64(1)
				}
				if v40 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v40 {
					cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v40 || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == libc.Uint64FromInt32(0) {
					pure1 = XTclThreadAllocObj(tls)
				} else {
					pure1 = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(pure1 + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(pure1)).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer(pure1)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(pure1)).Flength = 0
				(*TTcl_Obj)(unsafe.Pointer(pure1)).FtypePtr = libc.UintptrFromInt32(0)
				XTcl_SetObjLength(tls, pure1, numDigits)
				if (*TTcl_Obj)(unsafe.Pointer(pure1)).Fbytes != 0 {
					v41 = (*TTcl_Obj)(unsafe.Pointer(pure1)).Fbytes
				} else {
					v41 = XTcl_GetStringFromObj(tls, pure1, libc.UintptrFromInt32(0))
				}
				bytes1 = v41
				v42 = numDigits
				length2 = v42
				toAppend = v42
				for {
					v43 = numDigits
					numDigits--
					if !(v43 != 0) {
						break
					}
					if v45 = useBig != 0; v45 {
						if (*Tmp_int)(unsafe.Pointer(bp+72)).Fused == 0 {
							v44 = int32(MP_YES)
						} else {
							v44 = MP_NO
						}
					}
					if v45 && !(v44 != 0) {
						if index < (*(*Tmp_int)(unsafe.Pointer(bp + 72))).Fused && libc.Uint64FromInt32(shift) < libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(MP_DIGIT_BIT) {
							v46 = index
							index++
							bits |= uint64(*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 72))).Fdp + uintptr(v46)*4))) << shift
							shift += int32(MP_DIGIT_BIT)
						}
						shift -= numBits
					}
					digitOffset = libc.Int32FromUint64(bits % libc.Uint64FromInt32(base))
					if digitOffset > int32(9) {
						if *(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) == int32('X') {
							*(*uint8)(unsafe.Pointer(bytes1 + uintptr(numDigits))) = libc.Uint8FromInt32(int32('A') + digitOffset - int32(10))
						} else {
							*(*uint8)(unsafe.Pointer(bytes1 + uintptr(numDigits))) = libc.Uint8FromInt32(int32('a') + digitOffset - int32(10))
						}
					} else {
						*(*uint8)(unsafe.Pointer(bytes1 + uintptr(numDigits))) = libc.Uint8FromInt32(int32('0') + digitOffset)
					}
					bits /= libc.Uint64FromInt32(base)
				}
				if useBig != 0 {
					XTclBN_mp_clear(tls, bp+72)
				}
				if gotPrecision != 0 {
					if length2 < *(*TTcl_WideInt)(unsafe.Pointer(bp + 32)) {
						segmentLimit = segmentLimit - (*(*TTcl_WideInt)(unsafe.Pointer(bp + 32)) - length2)
					}
					for length2 < *(*TTcl_WideInt)(unsafe.Pointer(bp + 32)) {
						XTcl_AppendToObj(tls, segment, __ccgo_ts+14828, int64(1))
						length2++
					}
					gotZero = 0
				}
				if gotZero != 0 {
					length2 += XTcl_GetCharLength(tls, segment)
					if length2 < *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) {
						segmentLimit = segmentLimit - (*(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) - length2)
					}
					for length2 < *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) {
						XTcl_AppendToObj(tls, segment, __ccgo_ts+14828, int64(1))
						length2++
					}
				}
				if toAppend > segmentLimit {
					msg = _overflow
					errCode = __ccgo_ts + 33538
					goto errorMsg
				}
				XTcl_AppendObjToObj(tls, segment, pure1)
				_objPtr1 = pure1
				v48 = _objPtr1
				v47 = *(*TTcl_Size)(unsafe.Pointer(v48))
				*(*TTcl_Size)(unsafe.Pointer(v48))--
				if v47 <= int64(1) {
					XTclFreeObj(tls, _objPtr1)
				}
				break
			}
		case int32('a'):
			fallthrough
		case int32('A'):
			fallthrough
		case int32('e'):
			fallthrough
		case int32('E'):
			fallthrough
		case int32('f'):
			fallthrough
		case int32('g'):
			fallthrough
		case int32('G'):
			p = bp + 104
			length3 = int32(MAX_FLOAT_SIZE)
			if XTcl_GetDoubleFromObj(tls, interp, segment, bp+168) != TCL_OK {
				/* TODO: Figure out ACCEPT_NAN here */
				goto error
			}
			v49 = p
			p++
			*(*uint8)(unsafe.Pointer(v49)) = uint8('%')
			if gotMinus != 0 {
				v50 = p
				p++
				*(*uint8)(unsafe.Pointer(v50)) = uint8('-')
			}
			if gotHash != 0 {
				v51 = p
				p++
				*(*uint8)(unsafe.Pointer(v51)) = uint8('#')
			}
			if gotZero != 0 {
				v52 = p
				p++
				*(*uint8)(unsafe.Pointer(v52)) = uint8('0')
			}
			if gotSpace != 0 {
				v53 = p
				p++
				*(*uint8)(unsafe.Pointer(v53)) = uint8(' ')
			}
			if gotPlus != 0 {
				v54 = p
				p++
				*(*uint8)(unsafe.Pointer(v54)) = uint8('+')
			}
			if *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) != 0 {
				p += uintptr(libc.X__builtin_snprintf(tls, p, libc.Uint64FromInt32(libc.Int32FromInt32(3)*libc.Int32FromInt64(8)), __ccgo_ts+66644, libc.VaList(bp+184, *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)))))
				if *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) > int64(length3) {
					length3 = int32(*(*TTcl_WideInt)(unsafe.Pointer(bp + 24)))
				}
			}
			if gotPrecision != 0 {
				v55 = p
				p++
				*(*uint8)(unsafe.Pointer(v55)) = uint8('.')
				p += uintptr(libc.X__builtin_snprintf(tls, p, libc.Uint64FromInt32(libc.Int32FromInt32(3)*libc.Int32FromInt64(8)), __ccgo_ts+66644, libc.VaList(bp+184, *(*TTcl_WideInt)(unsafe.Pointer(bp + 32)))))
				if *(*TTcl_WideInt)(unsafe.Pointer(bp + 32)) > int64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))-int64(length3)) {
					msg = _overflow
					errCode = __ccgo_ts + 33538
					goto errorMsg
				}
				length3 = int32(int64(length3) + *(*TTcl_WideInt)(unsafe.Pointer(bp + 32)))
			}
			/*
			 * Don't pass length modifiers!
			 */
			v56 = p
			p++
			*(*uint8)(unsafe.Pointer(v56)) = libc.Uint8FromInt32(*(*TTcl_UniChar)(unsafe.Pointer(bp + 8)))
			*(*uint8)(unsafe.Pointer(p)) = uint8('\000')
			if v57 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v57 {
				cachePtr6 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v57 || (*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects == libc.Uint64FromInt32(0) {
				segment = XTclThreadAllocObj(tls)
			} else {
				segment = (*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(segment + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(segment)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(segment)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(segment)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(segment)).FtypePtr = libc.UintptrFromInt32(0)
			allocSegment = int32(1)
			if !(XTcl_AttemptSetObjLength(tls, segment, int64(length3)) != 0) {
				if allocSegment != 0 {
					_objPtr2 = segment
					v59 = _objPtr2
					v58 = *(*TTcl_Size)(unsafe.Pointer(v59))
					*(*TTcl_Size)(unsafe.Pointer(v59))--
					if v58 <= int64(1) {
						XTclFreeObj(tls, _objPtr2)
					}
				}
				msg = _overflow
				errCode = __ccgo_ts + 33538
				goto errorMsg
			}
			if (*TTcl_Obj)(unsafe.Pointer(segment)).Fbytes != 0 {
				v60 = (*TTcl_Obj)(unsafe.Pointer(segment)).Fbytes
			} else {
				v60 = XTcl_GetStringFromObj(tls, segment, libc.UintptrFromInt32(0))
			}
			bytes2 = v60
			if !(XTcl_AttemptSetObjLength(tls, segment, int64(libc.X__builtin_snprintf(tls, bytes2, libc.Uint64FromInt64((*TTcl_Obj)(unsafe.Pointer(segment)).Flength), bp+104, libc.VaList(bp+184, *(*float64)(unsafe.Pointer(bp + 168)))))) != 0) {
				if allocSegment != 0 {
					_objPtr3 = segment
					v62 = _objPtr3
					v61 = *(*TTcl_Size)(unsafe.Pointer(v62))
					*(*TTcl_Size)(unsafe.Pointer(v62))--
					if v61 <= int64(1) {
						XTclFreeObj(tls, _objPtr3)
					}
				}
				msg = _overflow
				errCode = __ccgo_ts + 33538
				goto errorMsg
			}
			if *(*TTcl_UniChar)(unsafe.Pointer(bp + 8)) == int32('A') {
				if (*TTcl_Obj)(unsafe.Pointer(segment)).Fbytes != 0 {
					v63 = (*TTcl_Obj)(unsafe.Pointer(segment)).Fbytes
				} else {
					v63 = XTcl_GetStringFromObj(tls, segment, libc.UintptrFromInt32(0))
				}
				q = v63 + uintptr(1)
				*(*uint8)(unsafe.Pointer(q)) = uint8('x')
				q = libc.Xstrchr(tls, q, int32('P'))
				if q != 0 {
					*(*uint8)(unsafe.Pointer(q)) = uint8('p')
				}
			}
		default:
			if interp != libc.UintptrFromInt32(0) {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+66649, libc.VaList(bp+184, *(*TTcl_UniChar)(unsafe.Pointer(bp + 8)))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+184, __ccgo_ts+2004, __ccgo_ts+65404, __ccgo_ts+65677, libc.UintptrFromInt32(0)))
			}
			goto error
		}
		if *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) > 0 && numChars < 0 {
			numChars = XTcl_GetCharLength(tls, segment)
		}
		if !(gotMinus != 0) && *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) > 0 {
			if numChars < *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) {
				limit = limit - (*(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) - numChars)
			}
			for numChars < *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) {
				if gotZero != 0 {
					v64 = __ccgo_ts + 14828
				} else {
					v64 = __ccgo_ts + 14830
				}
				XTcl_AppendToObj(tls, appendObj, v64, int64(1))
				numChars++
			}
		}
		if (*TTcl_Obj)(unsafe.Pointer(segment)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = (*TTcl_Obj)(unsafe.Pointer(segment)).Flength
			_ = (*TTcl_Obj)(unsafe.Pointer(segment)).Fbytes
		} else {
			XTcl_GetStringFromObj(tls, segment, bp+40)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 40)) > limit {
			if allocSegment != 0 {
				_objPtr4 = segment
				v67 = _objPtr4
				v66 = *(*TTcl_Size)(unsafe.Pointer(v67))
				*(*TTcl_Size)(unsafe.Pointer(v67))--
				if v66 <= int64(1) {
					XTclFreeObj(tls, _objPtr4)
				}
			}
			msg = _overflow
			errCode = __ccgo_ts + 33538
			goto errorMsg
		}
		XTcl_AppendObjToObj(tls, appendObj, segment)
		limit -= *(*TTcl_Size)(unsafe.Pointer(bp + 40))
		if allocSegment != 0 {
			_objPtr5 = segment
			v69 = _objPtr5
			v68 = *(*TTcl_Size)(unsafe.Pointer(v69))
			*(*TTcl_Size)(unsafe.Pointer(v69))--
			if v68 <= int64(1) {
				XTclFreeObj(tls, _objPtr5)
			}
		}
		if *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) > 0 {
			if numChars < *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) {
				limit = limit - (*(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) - numChars)
			}
			for numChars < *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) {
				if gotZero != 0 {
					v70 = __ccgo_ts + 14828
				} else {
					v70 = __ccgo_ts + 14830
				}
				XTcl_AppendToObj(tls, appendObj, v70, int64(1))
				numChars++
			}
		}
		objIndex += int64(gotSequential)
	}
	if numBytes != 0 {
		if numBytes > limit {
			msg = _overflow
			errCode = __ccgo_ts + 33538
			goto errorMsg
		}
		XTcl_AppendToObj(tls, appendObj, span, numBytes)
		limit -= numBytes
		numBytes = 0
	}
	return TCL_OK
	goto errorMsg
errorMsg:
	;
	if interp != libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, msg, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+184, __ccgo_ts+2004, __ccgo_ts+65404, errCode, libc.UintptrFromInt32(0)))
	}
	goto error
error:
	;
	XTcl_SetObjLength(tls, appendObj, *(*TTcl_Size)(unsafe.Pointer(bp)))
	return int32(TCL_ERROR)
}

var _mixedXPG = __ccgo_ts + 65357

var _badIndex = [2]uintptr{
	0: __ccgo_ts + 10901,
	1: __ccgo_ts + 65824,
}

var _overflow = __ccgo_ts + 66485

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_Format --
 *
 * Results:
 *	A refcount zero Tcl_Obj.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_Format(tls *libc.TLS, interp uintptr, format uintptr, objc TTcl_Size, objv uintptr) (r uintptr) {
	var _objPtr, cachePtr, objPtr, v3 uintptr
	var result int32
	var v1 bool
	var v2 TTcl_Size
	_, _, _, _, _, _, _ = _objPtr, cachePtr, objPtr, result, v1, v2, v3
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	result = XTcl_AppendFormatToObj(tls, interp, objPtr, format, objc, objv)
	if result != TCL_OK {
		_objPtr = objPtr
		v3 = _objPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		return libc.UintptrFromInt32(0)
	}
	return objPtr
}

/*
 *---------------------------------------------------------------------------
 *
 * AppendPrintfToObjVA --
 *
 * Results:
 *
 * Side effects:
 *
 *---------------------------------------------------------------------------
 */

func _NewLongObj(tls *libc.TLS, c uint8, value int64) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var cachePtr, obj uintptr
	var uw_ TTcl_WideUInt
	var v1 bool
	var _ /* bignumValue_ at bp+0 */ Tmp_int
	_, _, _, _ = cachePtr, obj, uw_, v1
	if value < 0 && libc.Xstrchr(tls, __ccgo_ts+66674, libc.Int32FromUint8(c)) != 0 {
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			obj = XTclThreadAllocObj(tls)
		} else {
			obj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(obj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(obj)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes = libc.UintptrFromInt32(0)
		uw_ = uint64(libc.Uint64FromInt64(value))
		if uw_ > libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) {
			if XTclBN_mp_init_u64(tls, bp, uw_) != MP_OKAY {
				XTcl_Panic(tls, __ccgo_ts+13273, libc.VaList(bp+32, __ccgo_ts+13293))
			}
			XTclSetBignumInternalRep(tls, obj, bp)
		} else {
			*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(obj)).FinternalRep)) = libc.Int64FromUint64(uw_)
			(*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
		}
		return obj
	}
	return XTcl_NewWideIntObj(tls, value)
}

func _NewWideIntObj(tls *libc.TLS, c uint8, value TTcl_WideInt) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var cachePtr, obj uintptr
	var uw_ TTcl_WideUInt
	var v1 bool
	var _ /* bignumValue_ at bp+0 */ Tmp_int
	_, _, _, _ = cachePtr, obj, uw_, v1
	if value < 0 && libc.Xstrchr(tls, __ccgo_ts+66674, libc.Int32FromUint8(c)) != 0 {
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			obj = XTclThreadAllocObj(tls)
		} else {
			obj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(obj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(obj)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes = libc.UintptrFromInt32(0)
		uw_ = libc.Uint64FromInt64(value)
		if uw_ > libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) {
			if XTclBN_mp_init_u64(tls, bp, uw_) != MP_OKAY {
				XTcl_Panic(tls, __ccgo_ts+13273, libc.VaList(bp+32, __ccgo_ts+13293))
			}
			XTclSetBignumInternalRep(tls, obj, bp)
		} else {
			*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(obj)).FinternalRep)) = libc.Int64FromUint64(uw_)
			(*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
		}
		return obj
	}
	return XTcl_NewWideIntObj(tls, value)
}

func _AppendPrintfToObjVA(tls *libc.TLS, objPtr uintptr, format uintptr, argList Tva_list) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var _objPtr, bytes, cachePtr, end, list, p, q, v10, v2, v8 uintptr
	var code, gotPrecision, lastNum, seekingConversion, size, v3 int32
	var v1, v4 bool
	var v6, v7 int64
	var v9 TTcl_Size
	var _ /* end at bp+16 */ uintptr
	var _ /* objc at bp+0 */ TTcl_Size
	var _ /* objv at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, bytes, cachePtr, code, end, gotPrecision, lastNum, list, p, q, seekingConversion, size, v1, v10, v2, v3, v4, v6, v7, v8, v9
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		list = XTclThreadAllocObj(tls)
	} else {
		list = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(list + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(list)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(list)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(list)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(list)).FtypePtr = libc.UintptrFromInt32(0)
	p = format
	(*TTcl_Obj)(unsafe.Pointer(list)).FrefCount++
	for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('\000') {
		size = 0
		seekingConversion = int32(1)
		gotPrecision = 0
		lastNum = -int32(1)
		v2 = p
		p++
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) != int32('%') {
			continue
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('%') {
			p++
			continue
		}
		for cond := true; cond; cond = seekingConversion != 0 {
			switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) {
			case int32('\000'):
				seekingConversion = 0
			case int32('s'):
				bytes = libc.VaUintptr(&argList)
				seekingConversion = 0
				/*
				 * The buffer to copy characters from starts at bytes and ends
				 * at either the first NUL byte, or after lastNum bytes, when
				 * caller has indicated a limit.
				 */
				end = bytes
				for {
					if v4 = !(gotPrecision != 0); !v4 {
						v3 = lastNum
						lastNum--
					}
					if !((v4 || v3 != 0) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(end))) != int32('\000')) {
						break
					}
					end++
				}
				/*
				 * Within that buffer, we trim both ends if needed so that we
				 * copy only whole characters, and avoid copying any partial
				 * multi-byte characters.
				 */
				q = XTcl_UtfPrev(tls, end, bytes)
				if !(XTcl_UtfCharComplete(tls, q, int64(end)-int64(q)) != 0) {
					end = q
				}
				q = bytes + uintptr(4)
				for bytes < end && bytes < q && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes)))&int32(0xC0) == int32(0x80) {
					bytes++
				}
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), list, XTcl_NewStringObj(tls, bytes, int64(end)-int64(bytes)))
			case int32('p'):
				if uint64(8) == uint64(8) {
					size = int32(2)
				}
				/* FALLTHRU */
				fallthrough
			case int32('c'):
				fallthrough
			case int32('i'):
				fallthrough
			case int32('u'):
				fallthrough
			case int32('d'):
				fallthrough
			case int32('o'):
				fallthrough
			case int32('x'):
				fallthrough
			case int32('X'):
				seekingConversion = 0
				switch size {
				case -int32(1):
					fallthrough
				case 0:
					XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), list, XTcl_NewWideIntObj(tls, int64(libc.VaInt32(&argList))))
				case int32(1):
					XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), list, _NewLongObj(tls, *(*uint8)(unsafe.Pointer(p)), libc.VaInt64(&argList)))
				case int32(2):
					XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), list, _NewWideIntObj(tls, *(*uint8)(unsafe.Pointer(p)), libc.VaInt64(&argList)))
				case int32(3):
					XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), list, XTcl_NewBignumObj(tls, libc.VaUintptr(&argList)))
					break
				}
			case int32('a'):
				fallthrough
			case int32('A'):
				fallthrough
			case int32('e'):
				fallthrough
			case int32('E'):
				fallthrough
			case int32('f'):
				fallthrough
			case int32('g'):
				fallthrough
			case int32('G'):
				if size > 0 {
					XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), list, XTcl_NewDoubleObj(tls, float64(libc.VaFloat64(&argList))))
				} else {
					XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), list, XTcl_NewDoubleObj(tls, libc.VaFloat64(&argList)))
				}
				seekingConversion = 0
			case int32('*'):
				lastNum = libc.VaInt32(&argList)
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), list, XTcl_NewWideIntObj(tls, int64(lastNum)))
				p++
			case int32('0'):
				fallthrough
			case int32('1'):
				fallthrough
			case int32('2'):
				fallthrough
			case int32('3'):
				fallthrough
			case int32('4'):
				fallthrough
			case int32('5'):
				fallthrough
			case int32('6'):
				fallthrough
			case int32('7'):
				fallthrough
			case int32('8'):
				fallthrough
			case int32('9'):
				lastNum = libc.Int32FromUint64(libc.Xstrtoul(tls, p, bp+16, int32(10)))
				p = *(*uintptr)(unsafe.Pointer(bp + 16))
			case int32('.'):
				gotPrecision = int32(1)
				p++
			case int32('l'):
				size++
				p++
			case int32('t'):
				fallthrough
			case int32('z'):
				if uint64(8) == uint64(8) {
					size = int32(2)
				}
				p++
			case int32('j'):
				fallthrough
			case int32('q'):
				size = int32(2)
				p++
			case int32('I'):
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('6') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 2))) == int32('4') {
					p += uintptr(2)
					size = int32(2)
				} else {
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('3') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 2))) == int32('2') {
						p += uintptr(2)
					} else {
						if uint64(8) == uint64(8) {
							size = int32(2)
						}
					}
				}
				p++
			case int32('L'):
				size = int32(3)
				p++
			case int32('h'):
				size = -int32(1)
				/* FALLTHRU */
				fallthrough
			default:
				p++
			}
		}
	}
	if (*TTcl_Obj)(unsafe.Pointer(list)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(list + 32))).Fptr2 != 0 {
			v6 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(list + 32))).Fptr2)).FspanStart
		} else {
			v6 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(list + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(list + 32))).Fptr1 + 40 + uintptr(v6)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(list + 32))).Fptr2 != 0 {
			v7 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(list + 32))).Fptr2)).FspanLength
		} else {
			v7 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(list + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v7
		_ = libc.Int32FromInt32(TCL_OK)
	} else {
		XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), list, bp, bp+8)
	}
	code = XTcl_AppendFormatToObj(tls, libc.UintptrFromInt32(0), objPtr, format, *(*TTcl_Size)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 8)))
	if code != TCL_OK {
		if (*TTcl_Obj)(unsafe.Pointer(list)).Fbytes != 0 {
			v8 = (*TTcl_Obj)(unsafe.Pointer(list)).Fbytes
		} else {
			v8 = XTcl_GetStringFromObj(tls, list, libc.UintptrFromInt32(0))
		}
		XTcl_AppendPrintfToObj(tls, objPtr, __ccgo_ts+66680, libc.VaList(bp+32, format, v8))
	}
	_objPtr = list
	v10 = _objPtr
	v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
	*(*TTcl_Size)(unsafe.Pointer(v10))--
	if v9 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_AppendPrintfToObj --
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_AppendPrintfToObj(tls *libc.TLS, objPtr uintptr, format uintptr, va uintptr) {
	var argList Tva_list
	_ = argList
	argList = va
	_AppendPrintfToObjVA(tls, objPtr, format, argList)
	_ = argList
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_ObjPrintf --
 *
 * Results:
 *	A refcount zero Tcl_Obj.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_ObjPrintf(tls *libc.TLS, format uintptr, va uintptr) (r uintptr) {
	var argList Tva_list
	var cachePtr, objPtr uintptr
	var v1 bool
	_, _, _, _ = argList, cachePtr, objPtr, v1
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	argList = va
	_AppendPrintfToObjVA(tls, objPtr, format, argList)
	_ = argList
	return objPtr
}

/*
 *---------------------------------------------------------------------------
 *
 * TclGetStringStorage --
 *
 *	Returns the string storage space of a Tcl_Obj.
 *
 * Results:
 *	The pointer value objPtr->bytes is returned and the number of bytes
 *	allocated there is written to *sizePtr (if known).
 *
 * Side effects:
 *	May set objPtr->bytes.
 *
 *---------------------------------------------------------------------------
 */

func XTclGetStringStorage(tls *libc.TLS, objPtr uintptr, sizePtr uintptr) (r uintptr) {
	var stringPtr, v1 uintptr
	_, _ = stringPtr, v1
	if !((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclStringType))) || (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(sizePtr)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
			v1 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, objPtr, sizePtr)
		}
		return v1
	}
	stringPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1
	*(*TTcl_Size)(unsafe.Pointer(sizePtr)) = (*TString)(unsafe.Pointer(stringPtr)).Fallocated
	return (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
}

/*
 *---------------------------------------------------------------------------
 *
 * TclStringRepeat --
 *
 *	Performs the [string repeat] function.
 *
 * Results:
 *	A (Tcl_Obj *) pointing to the result value, or NULL in case of an
 *	error.
 *
 * Side effects:
 *	On error, when interp is not NULL, error information is left in it.
 *
 *---------------------------------------------------------------------------
 */

func XTclStringRepeat(tls *libc.TLS, interp uintptr, objPtr uintptr, count TTcl_Size, flags int32) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var _isobjPtr, objResultPtr, stringPtr, v2, v3, v4 uintptr
	var binary, inPlace, unichar int32
	var done, maxCount TTcl_Size
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _ = _isobjPtr, binary, done, inPlace, maxCount, objResultPtr, stringPtr, unichar, v2, v3, v4
	inPlace = flags & (libc.Int32FromInt32(1) << libc.Int32FromInt32(1))
	*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	unichar = 0
	done = int64(1)
	binary = XTclIsPureByteArray(tls, objPtr)
	/*
	 * Analyze to determine what representation result should be.
	 * GOALS:	Avoid shimmering & string rep generation.
	 *		Produce pure bytearray when possible.
	 *		Error on overflow.
	 */
	if !(binary != 0) {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclStringType)) {
			stringPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr1
			if (*TString)(unsafe.Pointer(stringPtr)).FhasUnicode != 0 {
				unichar = int32(1)
			}
		}
	}
	if binary != 0 {
		/* Result will be pure byte array. Pre-size it */
		XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), objPtr, bp)
		maxCount = libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
	} else {
		if unichar != 0 {
			/* Result will be pure Tcl_UniChar array. Pre-size it. */
			XTcl_GetUnicodeFromObj(tls, objPtr, bp)
			maxCount = libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) / libc.Uint64FromInt64(4))
		} else {
			/* Result will be concat of string reps. Pre-size it. */
			if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
				_ = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
			} else {
				XTcl_GetStringFromObj(tls, objPtr, bp)
			}
			maxCount = libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
		}
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
		/* Any repeats of empty is empty. */
		return objPtr
	}
	/* maxCount includes space for null */
	if count > maxCount-int64(1) {
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+66398, libc.VaList(bp+16, libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+2008, libc.UintptrFromInt32(0)))
		}
		return libc.UintptrFromInt32(0)
	}
	if binary != 0 {
		/* Efficiently produce a pure byte array result */
		if !(inPlace != 0) || (*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount > int64(1) {
			v2 = XTcl_DuplicateObj(tls, objPtr)
		} else {
			v2 = objPtr
		}
		objResultPtr = v2
		/* Allocate count*length space */
		XTcl_SetByteArrayLength(tls, objResultPtr, count**(*TTcl_Size)(unsafe.Pointer(bp))) /* PANIC? */
		XTcl_SetByteArrayLength(tls, objResultPtr, *(*TTcl_Size)(unsafe.Pointer(bp)))
		for count-done > done {
			XTcl_AppendObjToObj(tls, objResultPtr, objResultPtr)
			done *= int64(2)
		}
		XTclAppendBytesToByteArray(tls, objResultPtr, XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), objResultPtr, libc.UintptrFromInt32(0)), (count-done)**(*TTcl_Size)(unsafe.Pointer(bp)))
	} else {
		if unichar != 0 {
			/*
			 * Efficiently produce a pure Tcl_UniChar array result.
			 */
			if !(inPlace != 0) || (*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount > int64(1) {
				objResultPtr = XTcl_NewUnicodeObj(tls, XTcl_GetUnicodeFromObj(tls, objPtr, libc.UintptrFromInt32(0)), *(*TTcl_Size)(unsafe.Pointer(bp)))
			} else {
				_isobjPtr = objPtr
				if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
					if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
				}
				objResultPtr = objPtr
			}
			/* TODO - overflow check */
			if 0 == XTcl_AttemptSetObjLength(tls, objResultPtr, count**(*TTcl_Size)(unsafe.Pointer(bp))) {
				if interp != 0 {
					XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+66730, libc.VaList(bp+16, uint64(libc.UintptrFromInt32(0)+28)+libc.Uint64FromInt64(4)+libc.Uint64FromInt64(count**(*TTcl_Size)(unsafe.Pointer(bp)))*uint64(4))))
					XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+2008, libc.UintptrFromInt32(0)))
				}
				return libc.UintptrFromInt32(0)
			}
			XTcl_SetObjLength(tls, objResultPtr, *(*TTcl_Size)(unsafe.Pointer(bp)))
			for count-done > done {
				XTcl_AppendObjToObj(tls, objResultPtr, objResultPtr)
				done *= int64(2)
			}
			XTcl_AppendUnicodeToObj(tls, objResultPtr, XTcl_GetUnicodeFromObj(tls, objResultPtr, libc.UintptrFromInt32(0)), (count-done)**(*TTcl_Size)(unsafe.Pointer(bp)))
		} else {
			/*
			 * Efficiently concatenate string reps.
			 */
			if !(inPlace != 0) || (*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount > int64(1) {
				if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
					v3 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
				} else {
					v3 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
				}
				objResultPtr = XTcl_NewStringObj(tls, v3, *(*TTcl_Size)(unsafe.Pointer(bp)))
			} else {
				if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != libc.UintptrFromInt32(0) {
					if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
						(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc})))(tls, objPtr)
					}
					(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
				}
				objResultPtr = objPtr
			}
			/* TODO - overflow check */
			if 0 == XTcl_AttemptSetObjLength(tls, objResultPtr, count**(*TTcl_Size)(unsafe.Pointer(bp))) {
				if interp != 0 {
					XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+66730, libc.VaList(bp+16, count**(*TTcl_Size)(unsafe.Pointer(bp)))))
					XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+2008, libc.UintptrFromInt32(0)))
				}
				return libc.UintptrFromInt32(0)
			}
			XTcl_SetObjLength(tls, objResultPtr, *(*TTcl_Size)(unsafe.Pointer(bp)))
			for count-done > done {
				XTcl_AppendObjToObj(tls, objResultPtr, objResultPtr)
				done *= int64(2)
			}
			if (*TTcl_Obj)(unsafe.Pointer(objResultPtr)).Fbytes != 0 {
				v4 = (*TTcl_Obj)(unsafe.Pointer(objResultPtr)).Fbytes
			} else {
				v4 = XTcl_GetStringFromObj(tls, objResultPtr, libc.UintptrFromInt32(0))
			}
			XTcl_AppendToObj(tls, objResultPtr, v4, (count-done)**(*TTcl_Size)(unsafe.Pointer(bp)))
		}
	}
	return objResultPtr
}

/*
 *---------------------------------------------------------------------------
 *
 * TclStringCat --
 *
 *	Performs the [string cat] function.
 *
 * Results:
 *	A (Tcl_Obj *) pointing to the result value, or NULL in case of an
 *	error.
 *
 * Side effects:
 *	On error, when interp is not NULL, error information is left in it.
 *
 *---------------------------------------------------------------------------
 */

func XTclStringCat(tls *libc.TLS, interp uintptr, objc TTcl_Size, objv uintptr, flags int32) (r uintptr) {
	bp := tls.Alloc(128)
	defer tls.Free(128)
	var _objPtr, _objPtr1, cachePtr, cachePtr1, dst, dst1, dst2, obj, objPtr, objPtr1, objPtr2, objPtr3, objPtr4, objPtr5, objPtr6, objPtr7, objPtr8, objResultPtr, ov, pendingPtr, src, src1, src2, v12, v15, v20, v23, v25, v27, v28, v30, v32, v33, v35, v38, v39, v4, v41, v42, v5, v9 uintptr
	var allowUniChar, binary, forceUniChar, inPlace, requestUniChar int32
	var first, last, numBytes2, oc, v10, v13, v17, v18, v2, v26, v29, v31, v37, v40, v7 TTcl_Size
	var v1, v36, v6 bool
	var _ /* ch at bp+56 */ TTcl_UniChar
	var _ /* length at bp+0 */ TTcl_Size
	var _ /* more at bp+40 */ TTcl_Size
	var _ /* more at bp+64 */ TTcl_Size
	var _ /* more at bp+80 */ TTcl_Size
	var _ /* numBytes at bp+24 */ TTcl_Size
	var _ /* numBytes at bp+8 */ TTcl_Size
	var _ /* numChars at bp+16 */ TTcl_Size
	var _ /* start at bp+32 */ TTcl_Size
	var _ /* start at bp+48 */ TTcl_Size
	var _ /* start at bp+72 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, allowUniChar, binary, cachePtr, cachePtr1, dst, dst1, dst2, first, forceUniChar, inPlace, last, numBytes2, obj, objPtr, objPtr1, objPtr2, objPtr3, objPtr4, objPtr5, objPtr6, objPtr7, objPtr8, objResultPtr, oc, ov, pendingPtr, requestUniChar, src, src1, src2, v1, v10, v12, v13, v15, v17, v18, v2, v20, v23, v25, v26, v27, v28, v29, v30, v31, v32, v33, v35, v36, v37, v38, v39, v4, v40, v41, v42, v5, v6, v7, v9
	binary = int32(1)
	*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	allowUniChar = int32(1)
	requestUniChar = 0
	forceUniChar = 0
	first = objc - int64(1) /* Index of first value possibly not empty */
	last = 0                /* Index of last value possibly not empty */
	inPlace = libc.BoolInt32(flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 && !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).FrefCount > libc.Int64FromInt32(1)))
	if objc <= int64(1) {
		if objc != int64(1) {
			if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				obj = XTclThreadAllocObj(tls)
			} else {
				obj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(obj + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(obj)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(obj)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr = libc.UintptrFromInt32(0)
			return obj
		}
		/* One object; return first */
		return *(*uintptr)(unsafe.Pointer(objv))
	}
	/*
	 * Analyze to determine what representation result should be.
	 * GOALS:	Avoid shimmering & string rep generation.
	 *		Produce pure bytearray when possible.
	 *		Error on overflow.
	 */
	ov = objv
	/*
	 * Analyze to determine what representation result should be.
	 * GOALS:	Avoid shimmering & string rep generation.
	 *		Produce pure bytearray when possible.
	 *		Error on overflow.
	 */
	oc = objc
	for {
		v4 = ov
		ov += 8
		objPtr = *(*uintptr)(unsafe.Pointer(v4))
		if XTclIsPureByteArray(tls, objPtr) != 0 {
			allowUniChar = 0
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
				/* Value has a string rep. */
				if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength != 0 {
					/*
					 * Non-empty string rep. Not a pure bytearray, so we won't
					 * create a pure bytearray.
					 */
					binary = 0
					if v6 = ov > objv+uintptr(1)*8; v6 {
						if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
							v5 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
						} else {
							v5 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
						}
					}
					if v6 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v5)))&int32(0xC0) == int32(0x80) {
						forceUniChar = int32(1)
					} else {
						if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != 0 && !((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclStringType))) {
							/* Prevent shimmer of non-string types. */
							allowUniChar = 0
						}
					}
				}
			} else {
				binary = 0
				if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclStringType)) {
					/* Have a pure Unicode value; ask to preserve it */
					requestUniChar = int32(1)
				} else {
					/* Have another type; prevent shimmer */
					allowUniChar = 0
				}
			}
		}
		goto _3
	_3:
		;
		oc--
		v2 = oc
		if !(v2 != 0 && (binary != 0 || allowUniChar != 0)) {
			break
		}
	}
	if binary != 0 {
		/*
		 * Result will be pure byte array. Pre-size it
		 */
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0
		ov = objv
		oc = objc
		for {
			v9 = ov
			ov += 8
			objPtr1 = *(*uintptr)(unsafe.Pointer(v9))
			/*
			 * Every argument is either a bytearray with a ("pure")
			 * value we know we can safely use, or it is an empty string.
			 * We don't need to count bytes for the empty strings.
			 */
			if XTclIsPureByteArray(tls, objPtr1) != 0 {
				XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), objPtr1, bp+8) /* PANIC? */
				if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) != 0 {
					last = objc - oc
					if *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
						first = last
					}
					if *(*TTcl_Size)(unsafe.Pointer(bp)) > libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))-*(*TTcl_Size)(unsafe.Pointer(bp + 8)) {
						goto overflow
					}
					*(*TTcl_Size)(unsafe.Pointer(bp)) += *(*TTcl_Size)(unsafe.Pointer(bp + 8))
				}
			}
			goto _8
		_8:
			;
			oc--
			v7 = oc
			if !(v7 != 0) {
				break
			}
		}
	} else {
		if allowUniChar != 0 && requestUniChar != 0 || forceUniChar != 0 {
			/*
			 * Result will be pure Tcl_UniChar array. Pre-size it.
			 */
			ov = objv
			oc = objc
			for {
				v12 = ov
				ov += 8
				objPtr2 = *(*uintptr)(unsafe.Pointer(v12))
				if (*TTcl_Obj)(unsafe.Pointer(objPtr2)).Fbytes == libc.UintptrFromInt32(0) || (*TTcl_Obj)(unsafe.Pointer(objPtr2)).Flength != 0 {
					XTcl_GetUnicodeFromObj(tls, objPtr2, bp+16) /* PANIC? */
					if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) != 0 {
						last = objc - oc
						if *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
							first = last
						}
						if *(*TTcl_Size)(unsafe.Pointer(bp)) > libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))/libc.Uint64FromInt64(4)-libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 16)))) {
							goto overflow
						}
						*(*TTcl_Size)(unsafe.Pointer(bp)) += *(*TTcl_Size)(unsafe.Pointer(bp + 16))
					}
				}
				goto _11
			_11:
				;
				oc--
				v10 = oc
				if !(v10 != 0) {
					break
				}
			}
		} else {
			/* Result will be concat of string reps. Pre-size it. */
			ov = objv
			oc = objc
			for cond := true; cond; cond = oc != 0 && *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
				pendingPtr = libc.UintptrFromInt32(0)
				/*
				 * Loop until a possibly non-empty value is reached.
				 * Keep string rep generation pending when possible.
				 */
				for {
					v15 = ov
					ov += 8
					objPtr3 = *(*uintptr)(unsafe.Pointer(v15))
					if (*TTcl_Obj)(unsafe.Pointer(objPtr3)).Fbytes == libc.UintptrFromInt32(0) && XTclCheckEmptyString(tls, objPtr3) != int32(TCL_EMPTYSTRING_YES) {
						/* No string rep; Take the chance we can avoid making it */
						pendingPtr = objPtr3
					} else {
						if (*TTcl_Obj)(unsafe.Pointer(objPtr3)).Fbytes != 0 {
							*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(objPtr3)).Flength
							_ = (*TTcl_Obj)(unsafe.Pointer(objPtr3)).Fbytes
						} else {
							XTcl_GetStringFromObj(tls, objPtr3, bp)
						} /* PANIC? */
					}
					goto _14
				_14:
					;
					oc--
					v13 = oc
					if !(v13 != 0 && *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 && pendingPtr == libc.UintptrFromInt32(0)) {
						break
					}
				}
				/*
				 * Either we found a possibly non-empty value, and we remember
				 * this index as the first and last such value so far seen,
				 * or (oc == 0) and all values are known empty,
				 * so first = last = objc - 1 signals the right quick return.
				 */
				v17 = objc - oc - libc.Int64FromInt32(1)
				last = v17
				first = v17
				if oc != 0 && *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
					/*
					 * There's a pending value followed by more values.  Loop over
					 * remaining values generating strings until a non-empty value
					 * is found, or the pending value gets its string generated.
					 */
					for {
						v20 = ov
						ov += 8
						objPtr4 = *(*uintptr)(unsafe.Pointer(v20))
						if (*TTcl_Obj)(unsafe.Pointer(objPtr4)).Fbytes != 0 {
							*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = (*TTcl_Obj)(unsafe.Pointer(objPtr4)).Flength
							_ = (*TTcl_Obj)(unsafe.Pointer(objPtr4)).Fbytes
						} else {
							XTcl_GetStringFromObj(tls, objPtr4, bp+24)
						} /* PANIC? */
						goto _19
					_19:
						;
						oc--
						v18 = oc
						if !(v18 != 0 && *(*TTcl_Size)(unsafe.Pointer(bp + 24)) == 0 && (*TTcl_Obj)(unsafe.Pointer(pendingPtr)).Fbytes == libc.UintptrFromInt32(0)) {
							break
						}
					}
					if *(*TTcl_Size)(unsafe.Pointer(bp + 24)) != 0 {
						last = objc - oc - int64(1)
					}
					if oc != 0 || *(*TTcl_Size)(unsafe.Pointer(bp + 24)) != 0 {
						if (*TTcl_Obj)(unsafe.Pointer(pendingPtr)).Fbytes != 0 {
							*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(pendingPtr)).Flength
							_ = (*TTcl_Obj)(unsafe.Pointer(pendingPtr)).Fbytes
						} else {
							XTcl_GetStringFromObj(tls, pendingPtr, bp)
						}
					}
					if *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
						if *(*TTcl_Size)(unsafe.Pointer(bp + 24)) != 0 {
							first = last
						}
					} else {
						if *(*TTcl_Size)(unsafe.Pointer(bp + 24)) > libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))-*(*TTcl_Size)(unsafe.Pointer(bp)) {
							goto overflow
						}
					}
					*(*TTcl_Size)(unsafe.Pointer(bp)) += *(*TTcl_Size)(unsafe.Pointer(bp + 24))
				}
			}
			for oc != 0 {
				v23 = ov
				ov += 8
				objPtr5 = *(*uintptr)(unsafe.Pointer(v23))
				if (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes != 0 {
					_ = (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Fbytes
				} else {
					XTcl_GetStringFromObj(tls, objPtr5, libc.UintptrFromInt32(0))
				} /* PANIC? */
				numBytes2 = (*TTcl_Obj)(unsafe.Pointer(objPtr5)).Flength
				if numBytes2 != 0 {
					last = objc - oc
					if numBytes2 > libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))-*(*TTcl_Size)(unsafe.Pointer(bp)) {
						goto overflow
					}
					*(*TTcl_Size)(unsafe.Pointer(bp)) += numBytes2
				}
				oc--
			}
		}
	}
	if last <= first {
		/* Only one non-empty value or zero length; return first */
		/* NOTE: (length == 0) implies (last <= first) */
		return *(*uintptr)(unsafe.Pointer(objv + uintptr(first)*8))
	}
	objv += uintptr(first) * 8
	objc = last - first + libc.Int64FromInt32(1)
	inPlace = libc.BoolInt32(flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 && !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).FrefCount > libc.Int64FromInt32(1)))
	if binary != 0 {
		/*
		 * Broken interface! Byte array value routines offer no way to handle
		 * failure to allocate enough space. Following stanza may panic.
		 */
		if inPlace != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = 0
			v25 = objv
			objv += 8
			objResultPtr = *(*uintptr)(unsafe.Pointer(v25))
			objc--
			XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), objResultPtr, bp+32)
			dst = XTcl_SetByteArrayLength(tls, objResultPtr, *(*TTcl_Size)(unsafe.Pointer(bp))) + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 32)))
		} else {
			objResultPtr = XTcl_NewByteArrayObj(tls, libc.UintptrFromInt32(0), *(*TTcl_Size)(unsafe.Pointer(bp)))
			dst = XTcl_SetByteArrayLength(tls, objResultPtr, *(*TTcl_Size)(unsafe.Pointer(bp)))
		}
		for {
			v26 = objc
			objc--
			if !(v26 != 0) {
				break
			}
			v27 = objv
			objv += 8
			objPtr6 = *(*uintptr)(unsafe.Pointer(v27))
			/*
			 * Every argument is either a bytearray with a ("pure")
			 * value we know we can safely use, or it is an empty string.
			 * We don't need to copy bytes from the empty strings.
			 */
			if XTclIsPureByteArray(tls, objPtr6) != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = 0
				src = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), objPtr6, bp+40)
				libc.Xmemcpy(tls, dst, src, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 40))))
				dst += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 40)))
			}
		}
	} else {
		if allowUniChar != 0 && requestUniChar != 0 || forceUniChar != 0 {
			if inPlace != 0 {
				v28 = objv
				objv += 8
				objResultPtr = *(*uintptr)(unsafe.Pointer(v28))
				objc--
				/* Ugly interface! Force resize of the unicode array. */
				XTcl_GetUnicodeFromObj(tls, objResultPtr, bp+48)
				XTcl_InvalidateStringRep(tls, objResultPtr)
				if 0 == XTcl_AttemptSetObjLength(tls, objResultPtr, *(*TTcl_Size)(unsafe.Pointer(bp))) {
					if interp != 0 {
						XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+66778, libc.VaList(bp+96, uint64(libc.UintptrFromInt32(0)+28)+libc.Uint64FromInt64(4)+libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))*uint64(4))))
						XTcl_SetErrorCode(tls, interp, libc.VaList(bp+96, __ccgo_ts+2004, __ccgo_ts+2008, libc.UintptrFromInt32(0)))
					}
					return libc.UintptrFromInt32(0)
				}
				dst1 = XTcl_GetUnicodeFromObj(tls, objResultPtr, libc.UintptrFromInt32(0)) + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 48)))*4
			} else {
				*(*TTcl_UniChar)(unsafe.Pointer(bp + 56)) = 0
				/* Ugly interface! No scheme to init array size. */
				objResultPtr = XTcl_NewUnicodeObj(tls, bp+56, 0) /* PANIC? */
				if 0 == XTcl_AttemptSetObjLength(tls, objResultPtr, *(*TTcl_Size)(unsafe.Pointer(bp))) {
					_objPtr = objResultPtr
					v30 = _objPtr
					v29 = *(*TTcl_Size)(unsafe.Pointer(v30))
					*(*TTcl_Size)(unsafe.Pointer(v30))--
					if v29 <= int64(1) {
						XTclFreeObj(tls, _objPtr)
					}
					if interp != 0 {
						XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+66778, libc.VaList(bp+96, uint64(libc.UintptrFromInt32(0)+28)+libc.Uint64FromInt64(4)+libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))*uint64(4))))
						XTcl_SetErrorCode(tls, interp, libc.VaList(bp+96, __ccgo_ts+2004, __ccgo_ts+2008, libc.UintptrFromInt32(0)))
					}
					return libc.UintptrFromInt32(0)
				}
				dst1 = XTcl_GetUnicodeFromObj(tls, objResultPtr, libc.UintptrFromInt32(0))
			}
			for {
				v31 = objc
				objc--
				if !(v31 != 0) {
					break
				}
				v32 = objv
				objv += 8
				objPtr7 = *(*uintptr)(unsafe.Pointer(v32))
				if (*TTcl_Obj)(unsafe.Pointer(objPtr7)).Fbytes == libc.UintptrFromInt32(0) || (*TTcl_Obj)(unsafe.Pointer(objPtr7)).Flength != 0 {
					src1 = XTcl_GetUnicodeFromObj(tls, objPtr7, bp+64)
					libc.Xmemcpy(tls, dst1, src1, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 64)))*uint64(4))
					dst1 += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 64))) * 4
				}
			}
		} else {
			if inPlace != 0 {
				v33 = objv
				objv += 8
				objResultPtr = *(*uintptr)(unsafe.Pointer(v33))
				objc--
				if (*TTcl_Obj)(unsafe.Pointer(objResultPtr)).Fbytes != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp + 72)) = (*TTcl_Obj)(unsafe.Pointer(objResultPtr)).Flength
					_ = (*TTcl_Obj)(unsafe.Pointer(objResultPtr)).Fbytes
				} else {
					XTcl_GetStringFromObj(tls, objResultPtr, bp+72)
				}
				if 0 == XTcl_AttemptSetObjLength(tls, objResultPtr, *(*TTcl_Size)(unsafe.Pointer(bp))) {
					if interp != 0 {
						XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+66826, libc.VaList(bp+96, *(*TTcl_Size)(unsafe.Pointer(bp)))))
						XTcl_SetErrorCode(tls, interp, libc.VaList(bp+96, __ccgo_ts+2004, __ccgo_ts+2008, libc.UintptrFromInt32(0)))
					}
					return libc.UintptrFromInt32(0)
				}
				if (*TTcl_Obj)(unsafe.Pointer(objResultPtr)).Fbytes != 0 {
					v35 = (*TTcl_Obj)(unsafe.Pointer(objResultPtr)).Fbytes
				} else {
					v35 = XTcl_GetStringFromObj(tls, objResultPtr, libc.UintptrFromInt32(0))
				}
				dst2 = v35 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 72)))
				if (*TTcl_Obj)(unsafe.Pointer(objResultPtr)).FtypePtr != libc.UintptrFromInt32(0) {
					if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objResultPtr)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
						(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objResultPtr)).FtypePtr)).FfreeIntRepProc})))(tls, objResultPtr)
					}
					(*TTcl_Obj)(unsafe.Pointer(objResultPtr)).FtypePtr = libc.UintptrFromInt32(0)
				}
			} else {
				if v36 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v36 {
					cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v36 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
					objResultPtr = XTclThreadAllocObj(tls)
				} else {
					objResultPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(objResultPtr + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(objResultPtr)).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer(objResultPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(objResultPtr)).Flength = 0
				(*TTcl_Obj)(unsafe.Pointer(objResultPtr)).FtypePtr = libc.UintptrFromInt32(0) /* PANIC? */
				if 0 == XTcl_AttemptSetObjLength(tls, objResultPtr, *(*TTcl_Size)(unsafe.Pointer(bp))) {
					_objPtr1 = objResultPtr
					v38 = _objPtr1
					v37 = *(*TTcl_Size)(unsafe.Pointer(v38))
					*(*TTcl_Size)(unsafe.Pointer(v38))--
					if v37 <= int64(1) {
						XTclFreeObj(tls, _objPtr1)
					}
					if interp != 0 {
						XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+66826, libc.VaList(bp+96, *(*TTcl_Size)(unsafe.Pointer(bp)))))
						XTcl_SetErrorCode(tls, interp, libc.VaList(bp+96, __ccgo_ts+2004, __ccgo_ts+2008, libc.UintptrFromInt32(0)))
					}
					return libc.UintptrFromInt32(0)
				}
				if (*TTcl_Obj)(unsafe.Pointer(objResultPtr)).Fbytes != 0 {
					v39 = (*TTcl_Obj)(unsafe.Pointer(objResultPtr)).Fbytes
				} else {
					v39 = XTcl_GetStringFromObj(tls, objResultPtr, libc.UintptrFromInt32(0))
				}
				dst2 = v39
			}
			for {
				v40 = objc
				objc--
				if !(v40 != 0) {
					break
				}
				v41 = objv
				objv += 8
				objPtr8 = *(*uintptr)(unsafe.Pointer(v41))
				if (*TTcl_Obj)(unsafe.Pointer(objPtr8)).Fbytes == libc.UintptrFromInt32(0) || (*TTcl_Obj)(unsafe.Pointer(objPtr8)).Flength != 0 {
					if (*TTcl_Obj)(unsafe.Pointer(objPtr8)).Fbytes != 0 {
						*(*TTcl_Size)(unsafe.Pointer(bp + 80)) = (*TTcl_Obj)(unsafe.Pointer(objPtr8)).Flength
						v42 = (*TTcl_Obj)(unsafe.Pointer(objPtr8)).Fbytes
					} else {
						v42 = XTcl_GetStringFromObj(tls, objPtr8, bp+80)
					}
					src2 = v42
					libc.Xmemcpy(tls, dst2, src2, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 80))))
					dst2 += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 80)))
				}
			}
			/* Must NUL-terminate! */
			*(*uint8)(unsafe.Pointer(dst2)) = uint8('\000')
		}
	}
	return objResultPtr
	goto overflow
overflow:
	;
	if interp != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+66398, libc.VaList(bp+96, libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+96, __ccgo_ts+2004, __ccgo_ts+2008, libc.UintptrFromInt32(0)))
	}
	return libc.UintptrFromInt32(0)
}

/*
 *---------------------------------------------------------------------------
 *
 * TclStringCmp --
 *	Compare two Tcl_Obj values as strings.
 *
 * Results:
 *	Like memcmp, return -1, 0, or 1.
 *
 * Side effects:
 *	String representations may be generated.  Internal representation may
 *	be changed.
 *
 *---------------------------------------------------------------------------
 */

func _UniCharNcasememcmp(tls *libc.TLS, ucsPtr uintptr, uctPtr uintptr, numChars Tsize_t) (r int32) {
	/* Number of Unichars to compare. */
	var lcs, lct TTcl_UniChar
	var ucs, uct uintptr
	_, _, _, _ = lcs, lct, ucs, uct
	ucs = ucsPtr
	uct = uctPtr
	for {
		if !(numChars != uint64(0)) {
			break
		}
		if *(*TTcl_UniChar)(unsafe.Pointer(ucs)) != *(*TTcl_UniChar)(unsafe.Pointer(uct)) {
			lcs = XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(ucs)))
			lct = XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(uct)))
			if lcs != lct {
				return lcs - lct
			}
		}
		goto _1
	_1:
		;
		numChars--
		ucs += 4
		uct += 4
	}
	return 0
}

func _UtfNmemcmp(tls *libc.TLS, csPtr uintptr, ctPtr uintptr, numChars Tsize_t) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Number of UTF chars to compare. */
	var cs, ct uintptr
	var v1 Tsize_t
	var v2, v3 int64
	var _ /* ch1 at bp+0 */ TTcl_UniChar
	var _ /* ch2 at bp+4 */ TTcl_UniChar
	_, _, _, _, _ = cs, ct, v1, v2, v3
	*(*TTcl_UniChar)(unsafe.Pointer(bp)) = 0
	*(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) = 0
	cs = csPtr
	ct = ctPtr
	/*
	 * Cannot use 'memcmp(cs, ct, n);' as byte representation of \u0000 (the
	 * pair of bytes 0xC0,0x80) is larger than byte representation of \u0001
	 * (the byte 0x01.)
	 */
	for {
		v1 = numChars
		numChars--
		if !(v1 > uint64(0)) {
			break
		}
		/*
		 * n must be interpreted as chars, not bytes. This should be called
		 * only when both strings are of at least n chars long (no need for \0
		 * check)
		 */
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cs))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cs)))
			v2 = int64(libc.Int32FromInt32(1))
		} else {
			v2 = XTcl_UtfToUniChar(tls, cs, bp)
		}
		cs += uintptr(v2)
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ct))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ct)))
			v3 = int64(libc.Int32FromInt32(1))
		} else {
			v3 = XTcl_UtfToUniChar(tls, ct, bp+4)
		}
		ct += uintptr(v3)
		if *(*TTcl_UniChar)(unsafe.Pointer(bp)) != *(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) {
			return *(*TTcl_UniChar)(unsafe.Pointer(bp)) - *(*TTcl_UniChar)(unsafe.Pointer(bp + 4))
		}
	}
	return 0
}

func _UtfNcasememcmp(tls *libc.TLS, csPtr uintptr, ctPtr uintptr, numChars Tsize_t) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Number of UTF chars to compare. */
	var cs, ct uintptr
	var v1 Tsize_t
	var v2, v3 int64
	var _ /* ch1 at bp+0 */ TTcl_UniChar
	var _ /* ch2 at bp+4 */ TTcl_UniChar
	_, _, _, _, _ = cs, ct, v1, v2, v3
	*(*TTcl_UniChar)(unsafe.Pointer(bp)) = 0
	*(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) = 0
	cs = csPtr
	ct = ctPtr
	for {
		v1 = numChars
		numChars--
		if !(v1 > uint64(0)) {
			break
		}
		/*
		 * n must be interpreted as chars, not bytes.
		 * This should be called only when both strings are of
		 * at least n chars long (no need for \0 check)
		 */
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cs))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cs)))
			v2 = int64(libc.Int32FromInt32(1))
		} else {
			v2 = XTcl_UtfToUniChar(tls, cs, bp)
		}
		cs += uintptr(v2)
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ct))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ct)))
			v3 = int64(libc.Int32FromInt32(1))
		} else {
			v3 = XTcl_UtfToUniChar(tls, ct, bp+4)
		}
		ct += uintptr(v3)
		if *(*TTcl_UniChar)(unsafe.Pointer(bp)) != *(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp)) = XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(bp)))
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) = XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(bp + 4)))
			if *(*TTcl_UniChar)(unsafe.Pointer(bp)) != *(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) {
				return *(*TTcl_UniChar)(unsafe.Pointer(bp)) - *(*TTcl_UniChar)(unsafe.Pointer(bp + 4))
			}
		}
	}
	return 0
}

func _UniCharNmemcmp(tls *libc.TLS, ucsPtr uintptr, uctPtr uintptr, numChars Tsize_t) (r int32) {
	/* Number of unichars to compare. */
	var ucs, uct uintptr
	_, _ = ucs, uct
	ucs = ucsPtr
	uct = uctPtr
	/*
	 * We are definitely on a big-endian machine; memcmp() is safe
	 */
	return libc.Xmemcmp(tls, ucs, uct, numChars*uint64(4))
}

func XTclStringCmp(tls *libc.TLS, value1Ptr uintptr, value2Ptr uintptr, checkEq int32, nocase int32, reqlength TTcl_Size) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* requested length in characters;
	 * TCL_INDEX_NONE to compare whole strings */
	var empty, match, v7, v8 int32
	var length TTcl_Size
	var memCmpFn TmemCmpFn_t
	var s1, s2, v1, v2, v3, v4, v5 uintptr
	var v6 int64
	var _ /* s1len at bp+0 */ TTcl_Size
	var _ /* s2len at bp+8 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = empty, length, match, memCmpFn, s1, s2, v1, v2, v3, v4, v5, v6, v7, v8
	*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0
	if reqlength == 0 || value1Ptr == value2Ptr {
		/*
		 * Always match at 0 chars of if it is the same obj.
		 * Note: as documented reqlength negative means it is ignored
		 */
		match = 0
	} else {
		if !(nocase != 0) && XTclIsPureByteArray(tls, value1Ptr) != 0 && XTclIsPureByteArray(tls, value2Ptr) != 0 {
			/*
			 * Use binary versions of comparisons since that won't cause undue
			 * type conversions and it is much faster. Only do this if we're
			 * case-sensitive (which is all that really makes sense with byte
			 * arrays anyway, and we have no memcasecmp() for some reason... :^)
			 */
			s1 = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), value1Ptr, bp)
			s2 = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), value2Ptr, bp+8)
			memCmpFn = __ccgo_fp(libc.Xmemcmp)
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(value1Ptr)).FtypePtr == uintptr(unsafe.Pointer(&XtclStringType)) && (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).FtypePtr == uintptr(unsafe.Pointer(&XtclStringType)) {
				/*
				 * Do a Unicode-specific comparison if both of the args are of String
				 * type. If the char length == byte length, we can do a memcmp. In
				 * benchmark testing this proved the most efficient check between the
				 * Unicode and string comparison operations.
				 */
				if nocase != 0 {
					s1 = XTcl_GetUnicodeFromObj(tls, value1Ptr, bp)
					s2 = XTcl_GetUnicodeFromObj(tls, value2Ptr, bp+8)
					memCmpFn = __ccgo_fp(_UniCharNcasememcmp)
				} else {
					*(*TTcl_Size)(unsafe.Pointer(bp)) = XTcl_GetCharLength(tls, value1Ptr)
					*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = XTcl_GetCharLength(tls, value2Ptr)
					if *(*TTcl_Size)(unsafe.Pointer(bp)) == (*TTcl_Obj)(unsafe.Pointer(value1Ptr)).Flength && (*TTcl_Obj)(unsafe.Pointer(value1Ptr)).Fbytes != libc.UintptrFromInt32(0) && *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Flength && (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes != libc.UintptrFromInt32(0) {
						/* each byte represents one character so s1l3n, s2l3n,
						 * and reqlength are in both bytes and characters */
						s1 = (*TTcl_Obj)(unsafe.Pointer(value1Ptr)).Fbytes
						s2 = (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes
						memCmpFn = __ccgo_fp(libc.Xmemcmp)
					} else {
						s1 = XTcl_GetUnicodeFromObj(tls, value1Ptr, libc.UintptrFromInt32(0))
						s2 = XTcl_GetUnicodeFromObj(tls, value2Ptr, libc.UintptrFromInt32(0))
						if int32(1) != 0 {
							memCmpFn = __ccgo_fp(libc.Xmemcmp)
							*(*TTcl_Size)(unsafe.Pointer(bp)) = TTcl_Size(uint64(*(*TTcl_Size)(unsafe.Pointer(bp))) * libc.Uint64FromInt64(4))
							*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = TTcl_Size(uint64(*(*TTcl_Size)(unsafe.Pointer(bp + 8))) * libc.Uint64FromInt64(4))
							if reqlength > 0 {
								reqlength = TTcl_Size(uint64(reqlength) * libc.Uint64FromInt64(4))
							}
						} else {
							memCmpFn = __ccgo_fp(_UniCharNmemcmp)
						}
					}
				}
			} else {
				empty = XTclCheckEmptyString(tls, value1Ptr)
				if empty > 0 {
					switch XTclCheckEmptyString(tls, value2Ptr) {
					case -int32(1):
						s1 = __ccgo_ts + 1945
						*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
						if (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes != 0 {
							*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Flength
							v1 = (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes
						} else {
							v1 = XTcl_GetStringFromObj(tls, value2Ptr, bp+8)
						}
						s2 = v1
					case 0:
						match = -int32(1)
						goto matchdone
					case int32(1):
						fallthrough
					default: /* avoid warn: `s2` may be used uninitialized */
						match = 0
						goto matchdone
					}
				} else {
					if XTclCheckEmptyString(tls, value2Ptr) > 0 {
						switch empty {
						case -int32(1):
							s2 = __ccgo_ts + 1945
							*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0
							if (*TTcl_Obj)(unsafe.Pointer(value1Ptr)).Fbytes != 0 {
								*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(value1Ptr)).Flength
								v2 = (*TTcl_Obj)(unsafe.Pointer(value1Ptr)).Fbytes
							} else {
								v2 = XTcl_GetStringFromObj(tls, value1Ptr, bp)
							}
							s1 = v2
						case 0:
							match = int32(1)
							goto matchdone
						case int32(1):
							fallthrough
						default: /* avoid warn: `s1` may be used uninitialized */
							match = 0
							goto matchdone
						}
					} else {
						if (*TTcl_Obj)(unsafe.Pointer(value1Ptr)).Fbytes != 0 {
							*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(value1Ptr)).Flength
							v3 = (*TTcl_Obj)(unsafe.Pointer(value1Ptr)).Fbytes
						} else {
							v3 = XTcl_GetStringFromObj(tls, value1Ptr, bp)
						}
						s1 = v3
						if (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes != 0 {
							*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Flength
							v4 = (*TTcl_Obj)(unsafe.Pointer(value2Ptr)).Fbytes
						} else {
							v4 = XTcl_GetStringFromObj(tls, value2Ptr, bp+8)
						}
						s2 = v4
					}
				}
				if !(nocase != 0) && checkEq != 0 && reqlength < 0 {
					/*
					 * When we have equal-length we can check only for
					 * (in)equality. We can use memcmp in all (n)eq cases because
					 * we don't need to worry about lexical LE/BE variance.
					 */
					memCmpFn = __ccgo_fp(libc.Xmemcmp)
				} else {
					/*
					 * As a catch-all we will work with UTF-8. We cannot use
					 * memcmp() as that is unsafe with any string containing NUL
					 * (\xC0\x80 in Tcl's utf rep). We can use the more efficient
					 * TclpUtfNcmp2 if we are case-sensitive and no specific
					 * length was requested.
					 */
					if reqlength < 0 && !(nocase != 0) {
						memCmpFn = __ccgo_fp(XTclpUtfNcmp2)
					} else {
						*(*TTcl_Size)(unsafe.Pointer(bp)) = XTcl_NumUtfChars(tls, s1, *(*TTcl_Size)(unsafe.Pointer(bp)))
						*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = XTcl_NumUtfChars(tls, s2, *(*TTcl_Size)(unsafe.Pointer(bp + 8)))
						if nocase != 0 {
							v5 = __ccgo_fp(_UtfNcasememcmp)
						} else {
							v5 = __ccgo_fp(_UtfNmemcmp)
						}
						memCmpFn = v5
					}
				}
			}
		}
		/* At this point s1len, s2len, and reqlength should by now have been
		 * adjusted so that they are all in the units expected by the selected
		 * comparison function.
		 */
		if *(*TTcl_Size)(unsafe.Pointer(bp)) < *(*TTcl_Size)(unsafe.Pointer(bp + 8)) {
			v6 = *(*TTcl_Size)(unsafe.Pointer(bp))
		} else {
			v6 = *(*TTcl_Size)(unsafe.Pointer(bp + 8))
		}
		length = v6
		if reqlength < 0 {
			/*
			 * The requested length is negative, so ignore it by setting it
			 * to length + 1 to correct the match var.
			 */
			reqlength = length + int64(1)
		} else {
			if reqlength > 0 && reqlength < length {
				length = reqlength
			}
		}
		if checkEq != 0 && reqlength < 0 && *(*TTcl_Size)(unsafe.Pointer(bp)) != *(*TTcl_Size)(unsafe.Pointer(bp + 8)) {
			match = int32(1) /* This will be reversed below. */
		} else {
			/*
			 * The comparison function should compare up to the minimum byte
			 * length only.
			 */
			match = (*(*func(*libc.TLS, uintptr, uintptr, Tsize_t) int32)(unsafe.Pointer(&struct{ uintptr }{memCmpFn})))(tls, s1, s2, libc.Uint64FromInt64(length))
		}
		if match == 0 && reqlength > length {
			match = int32(*(*TTcl_Size)(unsafe.Pointer(bp)) - *(*TTcl_Size)(unsafe.Pointer(bp + 8)))
		}
		if match > 0 {
			v7 = int32(1)
		} else {
			if match < 0 {
				v8 = -int32(1)
			} else {
				v8 = 0
			}
			v7 = v8
		}
		match = v7
	}
	goto matchdone
matchdone:
	;
	return match
	return r
}

/*
 *---------------------------------------------------------------------------
 *
 * TclStringFirst --
 *
 *	Implements the [string first] operation.
 *
 * Results:
 *	If needle is found as a substring of haystack, the index of the
 *	first instance of such a find is returned.  If needle is not present
 *	as a substring of haystack, -1 is returned.
 *
 * Side effects:
 *	needle and haystack may have their Tcl_ObjType changed.
 *
 *---------------------------------------------------------------------------
 */

func XTclStringFirst(tls *libc.TLS, needle uintptr, haystack uintptr, start TTcl_Size) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var bh, bn, cachePtr, check, checkStr, end, endStr, obj, uh, un uintptr
	var value TTcl_Size
	var v2 bool
	var _ /* lh at bp+0 */ TTcl_Size
	var _ /* ln at bp+8 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _ = bh, bn, cachePtr, check, checkStr, end, endStr, obj, uh, un, value, v2
	*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = XTcl_GetCharLength(tls, needle)
	value = int64(-int32(1))
	if start < 0 {
		start = 0
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == 0 {
		/* We don't find empty substrings.  Bizarre!
		 * Whenever this routine is turned into a proper substring
		 * finder, change to `return start` after limits imposed. */
		goto firstEnd
	}
	if XTclIsPureByteArray(tls, needle) != 0 && XTclIsPureByteArray(tls, haystack) != 0 {
		bn = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), needle, bp+8)
		/* Find bytes in bytes */
		bh = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), haystack, bp)
		if *(*TTcl_Size)(unsafe.Pointer(bp)) < *(*TTcl_Size)(unsafe.Pointer(bp + 8)) || start > *(*TTcl_Size)(unsafe.Pointer(bp))-*(*TTcl_Size)(unsafe.Pointer(bp + 8)) {
			/* Don't start the loop if there cannot be a valid answer */
			goto firstEnd
		}
		end = bh + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))
		check = bh + uintptr(start)
		for check+uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8))) <= end {
			/*
			 * Look for the leading byte of the needle in the haystack
			 * starting at check and stopping when there's not enough room
			 * for the needle left.
			 */
			check = libc.Xmemchr(tls, check, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bn))), libc.Uint64FromInt64(int64(end+libc.UintptrFromInt32(1)-uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8))))-int64(check)))
			if check == libc.UintptrFromInt32(0) {
				/* Leading byte not found -> needle cannot be found. */
				goto firstEnd
			}
			/* Leading byte found, check rest of needle. */
			if 0 == libc.Xmemcmp(tls, check+uintptr(1), bn+uintptr(1), libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8))-int64(1))) {
				/* Checks! Return the successful index. */
				value = int64(check) - int64(bh)
				goto firstEnd
			}
			/* Rest of needle match failed; Iterate to continue search. */
			check++
		}
		goto firstEnd
	}
	/*
	 * TODO: It might be nice to support some cases where it is not
	 * necessary to shimmer to &tclStringType to compute the result,
	 * and instead operate just on the objPtr->bytes values directly.
	 * However, we also do not want the answer to change based on the
	 * code pathway, or if it does we want that to be for some values
	 * we explicitly decline to support.  Getting there will involve
	 * locking down in practice more firmly just what encodings produce
	 * what supported results for the objPtr->bytes values.  For now,
	 * do only the well-defined Tcl_UniChar array search.
	 */
	un = XTcl_GetUnicodeFromObj(tls, needle, bp+8)
	uh = XTcl_GetUnicodeFromObj(tls, haystack, bp)
	if *(*TTcl_Size)(unsafe.Pointer(bp)) < *(*TTcl_Size)(unsafe.Pointer(bp + 8)) || start > *(*TTcl_Size)(unsafe.Pointer(bp))-*(*TTcl_Size)(unsafe.Pointer(bp + 8)) {
		/* Don't start the loop if there cannot be a valid answer */
		goto firstEnd
	}
	endStr = uh + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))*4
	checkStr = uh + uintptr(start)*4
	for {
		if !(checkStr+uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))*4 <= endStr) {
			break
		}
		if *(*TTcl_UniChar)(unsafe.Pointer(checkStr)) == *(*TTcl_UniChar)(unsafe.Pointer(un)) && 0 == libc.Xmemcmp(tls, checkStr+uintptr(1)*4, un+uintptr(1)*4, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8))-libc.Int64FromInt32(1))*uint64(4)) {
			value = (int64(checkStr) - int64(uh)) / 4
			goto firstEnd
		}
		goto _1
	_1:
		;
		checkStr += 4
	}
	goto firstEnd
firstEnd:
	;
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		obj = XTclThreadAllocObj(tls)
	} else {
		obj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(obj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(obj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes = libc.UintptrFromInt32(0)
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(obj)).FinternalRep)) = value
	(*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	return obj
}

/*
 *---------------------------------------------------------------------------
 *
 * TclStringLast --
 *
 *	Implements the [string last] operation.
 *
 * Results:
 *	If needle is found as a substring of haystack, the index of the
 *	last instance of such a find is returned.  If needle is not present
 *	as a substring of haystack, -1 is returned.
 *
 * Side effects:
 *	needle and haystack may have their Tcl_ObjType changed.
 *
 *---------------------------------------------------------------------------
 */

func XTclStringLast(tls *libc.TLS, needle uintptr, haystack uintptr, last TTcl_Size) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var bh, bn, cachePtr, check, checkStr, obj, uh, un uintptr
	var value TTcl_Size
	var v1 bool
	var _ /* lh at bp+0 */ TTcl_Size
	var _ /* ln at bp+8 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _ = bh, bn, cachePtr, check, checkStr, obj, uh, un, value, v1
	*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = XTcl_GetCharLength(tls, needle)
	value = int64(-int32(1))
	if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == 0 {
		/*
		 *	We don't find empty substrings.  Bizarre!
		 *
		 *	TODO: When we one day make this a true substring
		 *	finder, change this to "return last", after limitation.
		 */
		goto lastEnd
	}
	if XTclIsPureByteArray(tls, needle) != 0 && XTclIsPureByteArray(tls, haystack) != 0 {
		bh = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), haystack, bp)
		bn = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), needle, bp+8)
		if last >= *(*TTcl_Size)(unsafe.Pointer(bp)) {
			last = *(*TTcl_Size)(unsafe.Pointer(bp)) - int64(1)
		}
		if last+int64(1) < *(*TTcl_Size)(unsafe.Pointer(bp + 8)) {
			/* Don't start the loop if there cannot be a valid answer */
			goto lastEnd
		}
		check = bh + uintptr(last) + uintptr(1) - uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
		for check >= bh {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(check))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bn))) && 0 == libc.Xmemcmp(tls, check+uintptr(1), bn+uintptr(1), libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8))-int64(1))) {
				value = int64(check) - int64(bh)
				goto lastEnd
			}
			check--
		}
		goto lastEnd
	}
	uh = XTcl_GetUnicodeFromObj(tls, haystack, bp)
	un = XTcl_GetUnicodeFromObj(tls, needle, bp+8)
	if last >= *(*TTcl_Size)(unsafe.Pointer(bp)) {
		last = *(*TTcl_Size)(unsafe.Pointer(bp)) - int64(1)
	}
	if last+int64(1) < *(*TTcl_Size)(unsafe.Pointer(bp + 8)) {
		/* Don't start the loop if there cannot be a valid answer */
		goto lastEnd
	}
	checkStr = uh + uintptr(last)*4 + uintptr(1)*4 - uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))*4
	for checkStr >= uh {
		if *(*TTcl_UniChar)(unsafe.Pointer(checkStr)) == *(*TTcl_UniChar)(unsafe.Pointer(un)) && 0 == libc.Xmemcmp(tls, checkStr+uintptr(1)*4, un+uintptr(1)*4, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8))-libc.Int64FromInt32(1))*uint64(4)) {
			value = (int64(checkStr) - int64(uh)) / 4
			goto lastEnd
		}
		checkStr -= 4
	}
	goto lastEnd
lastEnd:
	;
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		obj = XTclThreadAllocObj(tls)
	} else {
		obj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(obj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(obj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes = libc.UintptrFromInt32(0)
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(obj)).FinternalRep)) = value
	(*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	return obj
}

/*
 *---------------------------------------------------------------------------
 *
 * TclStringReverse --
 *
 *	Implements the [string reverse] operation.
 *
 * Results:
 *	A Tcl value which is the [string reverse] of the argument supplied.
 *	When sharing rules permit and the caller requests, the returned value
 *	might be the argument with modifications done in place.
 *
 * Side effects:
 *	May allocate a new Tcl_Obj.
 *
 *---------------------------------------------------------------------------
 */

func _ReverseBytes(tls *libc.TLS, to uintptr, from uintptr, count TTcl_Size) {
	/* Until this many are copied, */
	/* reversing as you go. */
	var c uint8
	var src, v1, v2, v3, v4 uintptr
	_, _, _, _, _, _ = c, src, v1, v2, v3, v4
	src = from + uintptr(count)
	if to == from {
		/* Reversing in place */
		for {
			src--
			v1 = src
			if !(v1 > to) {
				break
			}
			c = *(*uint8)(unsafe.Pointer(src))
			*(*uint8)(unsafe.Pointer(src)) = *(*uint8)(unsafe.Pointer(to))
			v2 = to
			to++
			*(*uint8)(unsafe.Pointer(v2)) = c
		}
	} else {
		for {
			src--
			v3 = src
			if !(v3 >= from) {
				break
			}
			v4 = to
			to++
			*(*uint8)(unsafe.Pointer(v4)) = *(*uint8)(unsafe.Pointer(src))
		}
	}
}

func XTclStringReverse(tls *libc.TLS, objPtr uintptr, flags int32) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var bytesInChar, inPlace int32
	var bytesLeft, numBytes1, numChars TTcl_Size
	var cachePtr, from, from1, from2, src, stringPtr, to, to1, v1, v2, v3, v4, v7 uintptr
	var v5 bool
	var v6 int64
	var _ /* ch at bp+0 */ TTcl_UniChar
	var _ /* chw at bp+16 */ int32
	var _ /* numBytes at bp+8 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bytesInChar, bytesLeft, cachePtr, from, from1, from2, inPlace, numBytes1, numChars, src, stringPtr, to, to1, v1, v2, v3, v4, v5, v6, v7
	*(*TTcl_UniChar)(unsafe.Pointer(bp)) = 0
	inPlace = flags & (libc.Int32FromInt32(1) << libc.Int32FromInt32(1))
	if XTclIsPureByteArray(tls, objPtr) != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0
		from = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), objPtr, bp+8)
		if !(inPlace != 0) || (*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount > int64(1) {
			objPtr = XTcl_NewByteArrayObj(tls, libc.UintptrFromInt32(0), *(*TTcl_Size)(unsafe.Pointer(bp + 8)))
		}
		_ReverseBytes(tls, XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), objPtr, libc.UintptrFromInt32(0)), from, *(*TTcl_Size)(unsafe.Pointer(bp + 8)))
		return objPtr
	}
	_SetStringFromAny(tls, libc.UintptrFromInt32(0), objPtr)
	stringPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1
	if (*TString)(unsafe.Pointer(stringPtr)).FhasUnicode != 0 {
		from1 = XTcl_GetUnicodeFromObj(tls, objPtr, libc.UintptrFromInt32(0))
		stringPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		src = from1 + uintptr((*TString)(unsafe.Pointer(stringPtr)).FnumChars)*4
		if !(inPlace != 0) || (*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount > int64(1) {
			/*
			 * Create a non-empty, pure Unicode value, so we can coax
			 * Tcl_SetObjLength into growing the Unicode rep buffer.
			 */
			objPtr = XTcl_NewUnicodeObj(tls, bp, int64(1))
			XTcl_SetObjLength(tls, objPtr, (*TString)(unsafe.Pointer(stringPtr)).FnumChars)
			to = XTcl_GetUnicodeFromObj(tls, objPtr, libc.UintptrFromInt32(0))
			stringPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr1
			for {
				src -= 4
				v1 = src
				if !(v1 >= from1) {
					break
				}
				v2 = to
				to += 4
				*(*TTcl_UniChar)(unsafe.Pointer(v2)) = *(*TTcl_UniChar)(unsafe.Pointer(src))
			}
		} else {
			/*
			 * Reversing in place.
			 */
			for {
				src -= 4
				v3 = src
				if !(v3 > from1) {
					break
				}
				*(*TTcl_UniChar)(unsafe.Pointer(bp)) = *(*TTcl_UniChar)(unsafe.Pointer(src))
				*(*TTcl_UniChar)(unsafe.Pointer(src)) = *(*TTcl_UniChar)(unsafe.Pointer(from1))
				v4 = from1
				from1 += 4
				*(*TTcl_UniChar)(unsafe.Pointer(v4)) = *(*TTcl_UniChar)(unsafe.Pointer(bp))
			}
		}
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		numChars = (*TString)(unsafe.Pointer(stringPtr)).FnumChars
		numBytes1 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
		from2 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		if !(inPlace != 0) || (*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount > int64(1) {
			if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v5 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				objPtr = XTclThreadAllocObj(tls)
			} else {
				objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
			XTcl_SetObjLength(tls, objPtr, numBytes1)
		}
		to1 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		if numChars < numBytes1 {
			/*
			 * Either numChars == -1 and we don't know how many chars are
			 * represented by objPtr->bytes and we need Pass 1 just in case,
			 * or numChars >= 0 and we know we have fewer chars than bytes, so
			 * we know there's a multibyte character needing Pass 1.
			 *
			 * Pass 1. Reverse the bytes of each multi-byte character.
			 */
			bytesLeft = numBytes1
			for bytesLeft != 0 {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(from2))) < int32(0x80) {
					*(*int32)(unsafe.Pointer(bp + 16)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(from2)))
					v6 = int64(libc.Int32FromInt32(1))
				} else {
					v6 = XTcl_UtfToUniChar(tls, from2, bp+16)
				}
				/*
				 * NOTE: We know that the from buffer is NUL-terminated. It's
				 * part of the contract for objPtr->bytes values. Thus, we can
				 * skip calling Tcl_UtfCharComplete() here.
				 */
				bytesInChar = int32(v6)
				_ReverseBytes(tls, to1, from2, int64(bytesInChar))
				to1 += uintptr(bytesInChar)
				from2 += uintptr(bytesInChar)
				bytesLeft -= int64(bytesInChar)
			}
			v7 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
			to1 = v7
			from2 = v7
		}
		/* Pass 2. Reverse all the bytes. */
		_ReverseBytes(tls, to1, from2, numBytes1)
	}
	return objPtr
}

/*
 *---------------------------------------------------------------------------
 *
 * TclStringReplace --
 *
 *	Implements the inner engine of the [string replace] and
 *	[string insert] commands.
 *
 *	The result is a concatenation of a prefix from objPtr, characters
 *	0 through first-1, the insertPtr string value, and a suffix from
 *	objPtr, characters from first + count to the end. The effect is as if
 *	the inner substring of characters first through first+count-1 are
 *	removed and replaced with insertPtr. If insertPtr is NULL, it is
 *	treated as an empty string. When passed the flag TCL_STRING_IN_PLACE,
 *	this routine will try to do the work within objPtr, so long as no
 *	sharing forbids it. Without that request, or as needed, a new Tcl
 *	value will be allocated to be the result.
 *
 * Results:
 *	A Tcl value that is the result of the substring replacement. May
 *	return NULL in case of an error. When NULL is returned and interp is
 *	non-NULL, error information is left in interp
 *
 *---------------------------------------------------------------------------
 */

func XTclStringReplace(tls *libc.TLS, interp uintptr, objPtr uintptr, first TTcl_Size, count TTcl_Size, insertPtr uintptr, flags int32) (r uintptr) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* TCL_STRING_IN_PLACE => attempt in-place */
	var bytes, iBytes, result, ustring uintptr
	var inPlace int32
	var _ /* newBytes at bp+8 */ TTcl_Size
	var _ /* numBytes at bp+0 */ TTcl_Size
	var _ /* numChars at bp+16 */ TTcl_Size
	_, _, _, _, _ = bytes, iBytes, inPlace, result, ustring
	inPlace = flags & (libc.Int32FromInt32(1) << libc.Int32FromInt32(1))
	/* Replace nothing with nothing */
	if insertPtr == libc.UintptrFromInt32(0) && count <= 0 {
		if inPlace != 0 {
			return objPtr
		} else {
			return XTcl_DuplicateObj(tls, objPtr)
		}
	}
	if first < 0 {
		first = 0
	}
	/*
	 * The caller very likely had to call Tcl_GetCharLength() or similar
	 * to be able to process index values.  This means it is likely that
	 * objPtr is either a proper "bytearray" or a "string" or else it has
	 * a known and short string rep.
	 */
	if XTclIsPureByteArray(tls, objPtr) != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
		bytes = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), objPtr, bp)
		if insertPtr == libc.UintptrFromInt32(0) {
			/* Replace something with nothing. */
			result = XTcl_NewByteArrayObj(tls, libc.UintptrFromInt32(0), *(*TTcl_Size)(unsafe.Pointer(bp))-count) /* PANIC? */
			XTclAppendBytesToByteArray(tls, result, bytes, first)
			XTclAppendBytesToByteArray(tls, result, bytes+uintptr(first)+uintptr(count), *(*TTcl_Size)(unsafe.Pointer(bp))-count-first)
			return result
		}
		/* Replace everything */
		if first == 0 && count == *(*TTcl_Size)(unsafe.Pointer(bp)) {
			return insertPtr
		}
		if XTclIsPureByteArray(tls, insertPtr) != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0
			iBytes = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), insertPtr, bp+8)
			if count == *(*TTcl_Size)(unsafe.Pointer(bp + 8)) && inPlace != 0 && !((*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount > libc.Int64FromInt32(1)) {
				/*
				 * Removal count and replacement count are equal.
				 * Other conditions permit. Do in-place splice.
				 */
				libc.Xmemcpy(tls, bytes+uintptr(first), iBytes, libc.Uint64FromInt64(count))
				XTcl_InvalidateStringRep(tls, objPtr)
				return objPtr
			}
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))-(*(*TTcl_Size)(unsafe.Pointer(bp))-count) {
				if interp != 0 {
					XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+66398, libc.VaList(bp+32, libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))))
					XTcl_SetErrorCode(tls, interp, libc.VaList(bp+32, __ccgo_ts+2004, __ccgo_ts+2008, libc.UintptrFromInt32(0)))
				}
				return libc.UintptrFromInt32(0)
			}
			result = XTcl_NewByteArrayObj(tls, libc.UintptrFromInt32(0), *(*TTcl_Size)(unsafe.Pointer(bp))-count+*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
			/* PANIC? */
			XTcl_SetByteArrayLength(tls, result, 0)
			XTclAppendBytesToByteArray(tls, result, bytes, first)
			XTclAppendBytesToByteArray(tls, result, iBytes, *(*TTcl_Size)(unsafe.Pointer(bp + 8)))
			XTclAppendBytesToByteArray(tls, result, bytes+uintptr(first)+uintptr(count), *(*TTcl_Size)(unsafe.Pointer(bp))-count-first)
			return result
		}
		/* Flow through to try other approaches below */
	}
	/*
	 * TODO: Figure out how not to generate a Tcl_UniChar array rep
	 * when it can be determined objPtr->bytes points to a string of
	 * all single-byte characters so we can index it directly.
	 */
	/* The traditional implementation... */
	ustring = XTcl_GetUnicodeFromObj(tls, objPtr, bp+16)
	/* TODO: Is there an in-place option worth pursuing here? */
	result = XTcl_NewUnicodeObj(tls, ustring, first)
	if insertPtr != 0 {
		XTcl_AppendObjToObj(tls, result, insertPtr)
	}
	if first+count < *(*TTcl_Size)(unsafe.Pointer(bp + 16)) {
		XTcl_AppendUnicodeToObj(tls, result, ustring+uintptr(first)*4+uintptr(count)*4, *(*TTcl_Size)(unsafe.Pointer(bp + 16))-first-count)
	}
	return result
	return r
}

/*
 *---------------------------------------------------------------------------
 *
 * FillUnicodeRep --
 *
 *	Populate the Unicode internal rep with the Unicode form of its string
 *	rep. The object must already have a "String" internal rep.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Reallocates the String internal rep.
 *
 *---------------------------------------------------------------------------
 */

func _FillUnicodeRep(tls *libc.TLS, objPtr uintptr) {
	/* The object in which to fill the unicode
	 * rep. */
	var stringPtr uintptr
	_ = stringPtr
	stringPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1
	_ExtendUnicodeRepWithString(tls, objPtr, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength, (*TString)(unsafe.Pointer(stringPtr)).FnumChars)
}

func _ExtendUnicodeRepWithString(tls *libc.TLS, objPtr uintptr, bytes uintptr, numBytes TTcl_Size, numAppendChars TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _count, _i, needed, numOrigChars, v1, v4 TTcl_Size
	var _str, dst, stringPtr, v3, v6 uintptr
	var v2, v5 int64
	var _ /* unichar at bp+0 */ TTcl_UniChar
	_, _, _, _, _, _, _, _, _, _, _, _, _ = _count, _i, _str, dst, needed, numOrigChars, stringPtr, v1, v2, v3, v4, v5, v6
	stringPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1
	numOrigChars = 0
	*(*TTcl_UniChar)(unsafe.Pointer(bp)) = 0
	if (*TString)(unsafe.Pointer(stringPtr)).FhasUnicode != 0 {
		numOrigChars = (*TString)(unsafe.Pointer(stringPtr)).FnumChars
	}
	if numAppendChars == int64(-libc.Int32FromInt32(1)) {
		_i = numBytes
		_str = bytes
		for _i > 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(_str))) < int32(0xC0) {
			_i--
			_str++
		}
		_count = numBytes - _i
		if _i != 0 {
			_count += XTcl_NumUtfChars(tls, bytes+uintptr(_count), _i)
		}
		numAppendChars = _count
	}
	needed = numOrigChars + numAppendChars
	if needed > (*TString)(unsafe.Pointer(stringPtr)).FmaxChars {
		_GrowUnicodeBuffer(tls, objPtr, needed)
		stringPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
	}
	(*TString)(unsafe.Pointer(stringPtr)).FhasUnicode = int32(1)
	if bytes != 0 {
		(*TString)(unsafe.Pointer(stringPtr)).FnumChars = needed
	} else {
		numAppendChars = 0
	}
	dst = stringPtr + 28 + uintptr(numOrigChars)*4
	v1 = numAppendChars
	numAppendChars--
	if v1 > 0 {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes)))
			v2 = int64(libc.Int32FromInt32(1))
		} else {
			v2 = XTcl_UtfToUniChar(tls, bytes, bp)
		}
		bytes += uintptr(v2)
		v3 = dst
		dst += 4
		*(*TTcl_UniChar)(unsafe.Pointer(v3)) = *(*TTcl_UniChar)(unsafe.Pointer(bp))
		for {
			v4 = numAppendChars
			numAppendChars--
			if !(v4 > 0) {
				break
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes))) < int32(0x80) {
				*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes)))
				v5 = int64(libc.Int32FromInt32(1))
			} else {
				v5 = XTcl_UtfToUniChar(tls, bytes, bp)
			}
			bytes += uintptr(v5)
			v6 = dst
			dst += 4
			*(*TTcl_UniChar)(unsafe.Pointer(v6)) = *(*TTcl_UniChar)(unsafe.Pointer(bp))
		}
	}
	*(*TTcl_UniChar)(unsafe.Pointer(dst)) = 0
}

/*
 *----------------------------------------------------------------------
 *
 * DupStringInternalRep --
 *
 *	Initialize the internal representation of a new Tcl_Obj to a copy of
 *	the internal representation of an existing string object.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	copyPtr's internal rep is set to a copy of srcPtr's internal
 *	representation.
 *
 *----------------------------------------------------------------------
 */

func _DupStringInternalRep(tls *libc.TLS, srcPtr uintptr, copyPtr uintptr) {
	/* Object with internal rep to set. Must not
	 * currently have an internal rep.*/
	var copyMaxChars int32
	var copyStringPtr, srcStringPtr uintptr
	var v1 int64
	_, _, _, _ = copyMaxChars, copyStringPtr, srcStringPtr, v1
	srcStringPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(srcPtr + 32))).Fptr1
	copyStringPtr = libc.UintptrFromInt32(0)
	if (*TString)(unsafe.Pointer(srcStringPtr)).FnumChars == int64(-libc.Int32FromInt32(1)) {
		/*
		 * The String struct in the source value holds zero useful data. Don't
		 * bother copying it. Don't even bother allocating space in which to
		 * copy it. Just let the copy be untyped.
		 */
		return
	}
	if (*TString)(unsafe.Pointer(srcStringPtr)).FhasUnicode != 0 {
		if (*TString)(unsafe.Pointer(srcStringPtr)).FmaxChars/int64(2) >= (*TString)(unsafe.Pointer(srcStringPtr)).FnumChars {
			copyMaxChars = int32(int64(2) * (*TString)(unsafe.Pointer(srcStringPtr)).FnumChars)
		} else {
			copyMaxChars = int32((*TString)(unsafe.Pointer(srcStringPtr)).FmaxChars)
		}
		copyStringPtr = XTclpAlloc(tls, uint64(libc.UintptrFromInt32(0)+28)+libc.Uint64FromInt64(4)+libc.Uint64FromInt32(copyMaxChars)*libc.Uint64FromInt64(4))
		if copyStringPtr == libc.UintptrFromInt32(0) {
			copyMaxChars = int32((*TString)(unsafe.Pointer(srcStringPtr)).FnumChars)
			copyStringPtr = XTcl_Alloc(tls, uint64(libc.UintptrFromInt32(0)+28)+libc.Uint64FromInt64(4)+libc.Uint64FromInt32(copyMaxChars)*libc.Uint64FromInt64(4))
		}
		(*TString)(unsafe.Pointer(copyStringPtr)).FmaxChars = int64(copyMaxChars)
		libc.Xmemcpy(tls, copyStringPtr+28, srcStringPtr+28, libc.Uint64FromInt64((*TString)(unsafe.Pointer(srcStringPtr)).FnumChars)*uint64(4))
		*(*TTcl_UniChar)(unsafe.Pointer(copyStringPtr + 28 + uintptr((*TString)(unsafe.Pointer(srcStringPtr)).FnumChars)*4)) = 0
	} else {
		copyStringPtr = XTcl_Alloc(tls, uint64(libc.UintptrFromInt32(0)+28)+libc.Uint64FromInt64(4)+libc.Uint64FromInt32(libc.Int32FromInt32(0))*libc.Uint64FromInt64(4))
		(*TString)(unsafe.Pointer(copyStringPtr)).FmaxChars = 0
		*(*TTcl_UniChar)(unsafe.Pointer(copyStringPtr + 28)) = 0
	}
	(*TString)(unsafe.Pointer(copyStringPtr)).FhasUnicode = (*TString)(unsafe.Pointer(srcStringPtr)).FhasUnicode
	(*TString)(unsafe.Pointer(copyStringPtr)).FnumChars = (*TString)(unsafe.Pointer(srcStringPtr)).FnumChars
	/*
	 * Tricky point: the string value was copied by generic object management
	 * code, so it doesn't contain any extra bytes that might exist in the
	 * source object.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(copyPtr)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(copyPtr)).Flength
	} else {
		v1 = 0
	}
	(*TString)(unsafe.Pointer(copyStringPtr)).Fallocated = v1
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(copyPtr + 32))).Fptr2 = libc.UintptrFromInt32(0)
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(copyPtr + 32))).Fptr1 = copyStringPtr
	(*TTcl_Obj)(unsafe.Pointer(copyPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclStringType))
}

/*
 *----------------------------------------------------------------------
 *
 * SetStringFromAny --
 *
 *	Create an internal representation of type "String" for an object.
 *
 * Results:
 *	This operation always succeeds and returns TCL_OK.
 *
 * Side effects:
 *	Any old internal representation for objPtr is freed and the internal
 *	representation is set to &tclStringType.
 *
 *----------------------------------------------------------------------
 */

func _SetStringFromAny(tls *libc.TLS, dummy4457 uintptr, objPtr uintptr) (r int32) {
	/* The object to convert. */
	var stringPtr uintptr
	_ = stringPtr
	if !((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclStringType))) {
		stringPtr = XTcl_Alloc(tls, uint64(libc.UintptrFromInt32(0)+28)+libc.Uint64FromInt64(4)+libc.Uint64FromInt32(libc.Int32FromInt32(0))*libc.Uint64FromInt64(4))
		/*
		 * Convert whatever we have into an untyped value. Just A String.
		 */
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
			_ = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		} else {
			XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
		}
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != libc.UintptrFromInt32(0) {
			if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
				(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc})))(tls, objPtr)
			}
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
		}
		/*
		 * Create a basic String internalrep that just points to the UTF-8 string
		 * already in place at objPtr->bytes.
		 */
		(*TString)(unsafe.Pointer(stringPtr)).FnumChars = int64(-int32(1))
		(*TString)(unsafe.Pointer(stringPtr)).Fallocated = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
		(*TString)(unsafe.Pointer(stringPtr)).FmaxChars = 0
		(*TString)(unsafe.Pointer(stringPtr)).FhasUnicode = 0
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr2 = libc.UintptrFromInt32(0)
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1 = stringPtr
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclStringType))
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * UpdateStringOfString --
 *
 *	Update the string representation for an object whose internal
 *	representation is "String".
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The object's string may be set by converting its Unicode representation
 *	to UTF format.
 *
 *----------------------------------------------------------------------
 */

func _UpdateStringOfString(tls *libc.TLS, objPtr uintptr) {
	/* Object with string rep to update. */
	var stringPtr uintptr
	_ = stringPtr
	stringPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1
	/*
	 * This routine is only called when we need to generate the
	 * string rep objPtr->bytes because it does not exist -- it is NULL.
	 * In that circumstance, any lingering claim about the size of
	 * memory pointed to by that NULL pointer is clearly bogus, and
	 * needs a reset.
	 */
	(*TString)(unsafe.Pointer(stringPtr)).Fallocated = 0
	if (*TString)(unsafe.Pointer(stringPtr)).FnumChars == 0 {
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		_ExtendStringRepWithUnicode(tls, objPtr, stringPtr+28, (*TString)(unsafe.Pointer(stringPtr)).FnumChars)
	}
}

func _ExtendStringRepWithUnicode(tls *libc.TLS, objPtr uintptr, unicode uintptr, numChars TTcl_Size) (r TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var dst, stringPtr uintptr
	var i, origLength, size, v1 TTcl_Size
	_, _, _, _, _, _ = dst, i, origLength, size, stringPtr, v1
	size = 0
	stringPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1
	if numChars < 0 {
		numChars = _UnicodeLength(tls, unicode)
	}
	if numChars == 0 {
		return 0
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes == libc.UintptrFromInt32(0) {
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	}
	v1 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
	origLength = v1
	size = v1
	/*
	 * Quick cheap check in case we have more than enough room.
	 */
	if numChars <= (libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))-size)/int64(TCL_UTF_MAX) && (*TString)(unsafe.Pointer(stringPtr)).Fallocated >= size+numChars*int64(TCL_UTF_MAX) {
		goto copyBytes
	}
	i = 0
	for {
		if !(i < numChars && size >= 0) {
			break
		}
		/* TODO - overflow check! I don't think check below at end suffices */
		size += int64(XTclUtfCount(tls, *(*TTcl_UniChar)(unsafe.Pointer(unicode + uintptr(i)*4))))
		goto _2
	_2:
		;
		i++
	}
	if size < 0 {
		XTcl_Panic(tls, __ccgo_ts+66398, libc.VaList(bp+8, libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))))
	}
	/*
	 * Grow space if needed.
	 */
	if size > (*TString)(unsafe.Pointer(stringPtr)).Fallocated {
		_GrowStringBuffer(tls, objPtr, size, int32(1))
	}
	goto copyBytes
copyBytes:
	;
	dst = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes + uintptr(origLength)
	i = 0
	for {
		if !(i < numChars) {
			break
		}
		dst += uintptr(XTcl_UniCharToUtf(tls, *(*TTcl_UniChar)(unsafe.Pointer(unicode + uintptr(i)*4)), dst))
		goto _3
	_3:
		;
		i++
	}
	*(*uint8)(unsafe.Pointer(dst)) = uint8('\000')
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(dst) - int64((*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes)
	return numChars
}

/*
 *----------------------------------------------------------------------
 *
 * FreeStringInternalRep --
 *
 *	Deallocate the storage associated with a String data object's internal
 *	representation.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Frees memory.
 *
 *----------------------------------------------------------------------
 */

func _FreeStringInternalRep(tls *libc.TLS, objPtr uintptr) {
	/* Object with internal rep to free. */
	XTclpFree(tls, (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1)
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
}

var _StrIdxTreeObjType = TTcl_ObjType{
	Fname: __ccgo_ts + 66874,
}

func init() {
	p := unsafe.Pointer(&_StrIdxTreeObjType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_StrIdxTreeObj_FreeIntRepProc)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_StrIdxTreeObj_DupIntRepProc)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_StrIdxTreeObj_UpdateStringProc)
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * TclStrIdxTreeSearch --
//	 *
//	 *	Find largest part of string "start" in indexed tree (case sensitive).
//	 *
//	 *	Also used for building of string index tree.
//	 *
//	 * Results:
//	 *	Return position of UTF character in start after last equal character
//	 *	and found item (with parent).
//	 *
//	 * Side effects:
//	 *	None.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func XTclStrIdxTreeSearch(tls *libc.TLS, foundParent uintptr, foundItem uintptr, tree uintptr, start uintptr, end uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* End of string */
	var cin1, f, item, parent, prevItem, prevParent, prevf, ret, s, v1, v2, v3, v4, v5, v9 uintptr
	var offs TTcl_Size
	var v7, v8 int64
	var _ /* ch1 at bp+0 */ TTcl_UniChar
	var _ /* ch2 at bp+4 */ TTcl_UniChar
	var _ /* cinf at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cin1, f, item, offs, parent, prevItem, prevParent, prevf, ret, s, v1, v2, v3, v4, v5, v7, v8, v9
	parent = tree
	prevParent = tree
	item = (*TTclStrIdxTree)(unsafe.Pointer(tree)).FfirstPtr
	prevItem = libc.UintptrFromInt32(0)
	s = start
	prevf = libc.UintptrFromInt32(0)
	offs = 0
	if item == libc.UintptrFromInt32(0) {
		goto done
	}
	/* search in tree */
	for cond := true; cond; cond = item != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer((*TTclStrIdx)(unsafe.Pointer(item)).Fkey)).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer((*TTclStrIdx)(unsafe.Pointer(item)).Fkey)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, (*TTclStrIdx)(unsafe.Pointer(item)).Fkey, libc.UintptrFromInt32(0))
		}
		v1 = v2 + uintptr(offs)
		cin1 = v1
		*(*uintptr)(unsafe.Pointer(bp + 8)) = v1
		v3 = s
		v4 = cin1
		ret = v3
		for {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) < int32(0x80) {
				*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v3)))
				v7 = int64(libc.Int32FromInt32(1))
			} else {
				v7 = XTcl_UtfToUniChar(tls, v3, bp)
			}
			v3 += uintptr(v7)
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) < int32(0x80) {
				*(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v4)))
				v8 = int64(libc.Int32FromInt32(1))
			} else {
				v8 = XTcl_UtfToUniChar(tls, v4, bp+4)
			}
			v4 += uintptr(v8)
			if *(*TTcl_UniChar)(unsafe.Pointer(bp)) != *(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) {
				*(*TTcl_UniChar)(unsafe.Pointer(bp)) = XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(bp)))
				if *(*TTcl_UniChar)(unsafe.Pointer(bp)) != *(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) {
					break
				}
			}
			*(*uintptr)(unsafe.Pointer(bp + 8)) = v4
			goto _6
		_6:
			;
			v5 = v3
			ret = v5
			if !(v5 < end && v4 < cin1+uintptr((*TTclStrIdx)(unsafe.Pointer(item)).Flength)-uintptr(offs)) {
				break
			}
		}
		v9 = ret
		goto _10
	_10:
		f = v9
		/* if something was found */
		if f > s {
			/* if whole string was found */
			if f >= end {
				start = f
				goto done
			}
			/* set new offset and shift start string */
			offs += int64(*(*uintptr)(unsafe.Pointer(bp + 8))) - int64(cin1)
			s = f
			/* if match item, go deeper as long as possible */
			if offs >= (*TTclStrIdx)(unsafe.Pointer(item)).Flength && (*TTclStrIdx)(unsafe.Pointer(item)).FchildTree.FfirstPtr != 0 {
				/* save previuosly found item (if not ambigous) for
				 * possible fallback (few greedy match) */
				if (*TTclStrIdx)(unsafe.Pointer(item)).Fvalue != libc.UintptrFromInt32(0) {
					prevf = f
					prevItem = item
					prevParent = parent
				}
				parent = item
				item = (*TTclStrIdx)(unsafe.Pointer(item)).FchildTree.FfirstPtr
				continue
			}
			/* no children - return this item and current chars found */
			start = f
			goto done
		}
		item = (*TTclStrIdx)(unsafe.Pointer(item)).FnextPtr
	}
	/* fallback (few greedy match) not ambigous (has a value) */
	if prevItem != libc.UintptrFromInt32(0) {
		item = prevItem
		parent = prevParent
		start = prevf
	}
	goto done
done:
	;
	if foundParent != 0 {
		*(*uintptr)(unsafe.Pointer(foundParent)) = parent
	}
	if foundItem != 0 {
		*(*uintptr)(unsafe.Pointer(foundItem)) = item
	}
	return start
}

func XTclStrIdxTreeFree(tls *libc.TLS, tree uintptr) {
	var _objPtr, t, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _ = _objPtr, t, v1, v2
	for tree != libc.UintptrFromInt32(0) {
		t = tree
		_objPtr = (*TTclStrIdx)(unsafe.Pointer(tree)).Fkey
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		if (*TTclStrIdx)(unsafe.Pointer(tree)).FchildTree.FfirstPtr != libc.UintptrFromInt32(0) {
			XTclStrIdxTreeFree(tls, (*TTclStrIdx)(unsafe.Pointer(tree)).FchildTree.FfirstPtr)
		}
		tree = (*TTclStrIdx)(unsafe.Pointer(tree)).FnextPtr
		XTclpFree(tls, t)
	}
}

/*
 * Several bidirectional list primitives
 */

func _TclStrIdxTreeInsertBranch(tls *libc.TLS, parent uintptr, item uintptr, child uintptr) {
	var v1, v2 uintptr
	_, _ = v1, v2
	if (*TTclStrIdxTree)(unsafe.Pointer(parent)).FfirstPtr == child {
		(*TTclStrIdxTree)(unsafe.Pointer(parent)).FfirstPtr = item
	}
	if (*TTclStrIdxTree)(unsafe.Pointer(parent)).FlastPtr == child {
		(*TTclStrIdxTree)(unsafe.Pointer(parent)).FlastPtr = item
	}
	v1 = (*TTclStrIdx)(unsafe.Pointer(child)).FnextPtr
	(*TTclStrIdx)(unsafe.Pointer(item)).FnextPtr = v1
	if v1 != libc.UintptrFromInt32(0) {
		(*TTclStrIdx)(unsafe.Pointer((*TTclStrIdx)(unsafe.Pointer(item)).FnextPtr)).FprevPtr = item
		(*TTclStrIdx)(unsafe.Pointer(child)).FnextPtr = libc.UintptrFromInt32(0)
	}
	v2 = (*TTclStrIdx)(unsafe.Pointer(child)).FprevPtr
	(*TTclStrIdx)(unsafe.Pointer(item)).FprevPtr = v2
	if v2 != libc.UintptrFromInt32(0) {
		(*TTclStrIdx)(unsafe.Pointer((*TTclStrIdx)(unsafe.Pointer(item)).FprevPtr)).FnextPtr = item
		(*TTclStrIdx)(unsafe.Pointer(child)).FprevPtr = libc.UintptrFromInt32(0)
	}
	(*TTclStrIdx)(unsafe.Pointer(item)).FchildTree.FfirstPtr = child
	(*TTclStrIdx)(unsafe.Pointer(item)).FchildTree.FlastPtr = child
}

func _TclStrIdxTreeAppend(tls *libc.TLS, parent uintptr, item uintptr) {
	if (*TTclStrIdxTree)(unsafe.Pointer(parent)).FlastPtr != libc.UintptrFromInt32(0) {
		(*TTclStrIdx)(unsafe.Pointer((*TTclStrIdxTree)(unsafe.Pointer(parent)).FlastPtr)).FnextPtr = item
	}
	(*TTclStrIdx)(unsafe.Pointer(item)).FprevPtr = (*TTclStrIdxTree)(unsafe.Pointer(parent)).FlastPtr
	(*TTclStrIdx)(unsafe.Pointer(item)).FnextPtr = libc.UintptrFromInt32(0)
	(*TTclStrIdxTree)(unsafe.Pointer(parent)).FlastPtr = item
	if (*TTclStrIdxTree)(unsafe.Pointer(parent)).FfirstPtr == libc.UintptrFromInt32(0) {
		(*TTclStrIdxTree)(unsafe.Pointer(parent)).FfirstPtr = item
	}
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * TclStrIdxTreeBuildFromList --
//	 *
//	 *	Build or extend string indexed tree from tcl list. If the values not
//	 *	given the values of built list are indices starts with 1. Value of 0
//	 *	is thereby reserved to the ambigous values.
//	 *
//	 *	Important: by multiple lists, optimal tree can be created only if list
//	 *	with larger strings used firstly.
//	 *
//	 * Results:
//	 *	Returns a standard Tcl result.
//	 *
//	 * Side effects:
//	 *	None.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func XTclStrIdxTreeBuildFromList(tls *libc.TLS, idxTree uintptr, lstc TTcl_Size, lstv uintptr, values uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, _objPtr1, e, f, item, lwrv, nval, prev, s, val, v10, v13, v2, v4, v5, v6, v8, v9 uintptr
	var i, v12, v7 TTcl_Size
	var ret int32
	var _ /* foundItem at bp+8 */ uintptr
	var _ /* foundParent at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, e, f, i, item, lwrv, nval, prev, ret, s, val, v10, v12, v13, v2, v4, v5, v6, v7, v8, v9
	ret = int32(TCL_ERROR)
	/* create lowercase reflection of the list keys */
	lwrv = XTclpAlloc(tls, uint64(8)*libc.Uint64FromInt64(lstc))
	if lwrv == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	i = 0
	for {
		if !(i < lstc) {
			break
		}
		*(*uintptr)(unsafe.Pointer(lwrv + uintptr(i)*8)) = XTcl_DuplicateObj(tls, *(*uintptr)(unsafe.Pointer(lstv + uintptr(i)*8)))
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(lwrv + uintptr(i)*8)))).FrefCount++
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(lwrv + uintptr(i)*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(lwrv + uintptr(i)*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(lwrv + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(lwrv + uintptr(i)*8)))).Flength = XTcl_UtfToLower(tls, v2)
		goto _1
	_1:
		;
		i++
	}
	/* build index tree of the list keys */
	i = 0
	for {
		if !(i < lstc) {
			break
		}
		*(*uintptr)(unsafe.Pointer(bp)) = idxTree
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(lwrv + uintptr(i)*8)))).Fbytes != 0 {
			v5 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(lwrv + uintptr(i)*8)))).Fbytes
		} else {
			v5 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(lwrv + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		v4 = v5
		s = v4
		e = v4
		e += uintptr((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(lwrv + uintptr(i)*8)))).Flength)
		if values != 0 {
			v6 = *(*uintptr)(unsafe.Pointer(values + uintptr(i)*8))
		} else {
			v6 = uintptr(i + libc.Int64FromInt32(1))
		}
		val = v6
		/* ignore empty keys (impossible to index it) */
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(lwrv + uintptr(i)*8)))).Flength == 0 {
			goto _3
		}
		item = libc.UintptrFromInt32(0)
		if (*TTclStrIdxTree)(unsafe.Pointer(idxTree)).FfirstPtr != libc.UintptrFromInt32(0) {
			f = XTclStrIdxTreeSearch(tls, bp, bp+8, idxTree, s, e)
			/* if common prefix was found */
			if f > s {
				/* ignore element if fulfilled or ambigous */
				if f == e {
					goto _3
				}
				/* if shortest key was found with the same value,
				 * just replace its current key with longest key */
				if (*TTclStrIdx)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fvalue == val && (*TTclStrIdx)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength <= (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(lwrv + uintptr(i)*8)))).Flength && (*TTclStrIdx)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength <= int64(f)-int64(s) && (*TTclStrIdx)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FchildTree.FfirstPtr == libc.UintptrFromInt32(0) {
					nval = *(*uintptr)(unsafe.Pointer(lwrv + uintptr(i)*8))
					if (*TTclStrIdx)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fkey != nval {
						prev = (*TTclStrIdx)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fkey
						(*TTclStrIdx)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fkey = nval
						if (*TTclStrIdx)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fkey != 0 {
							(*TTcl_Obj)(unsafe.Pointer((*TTclStrIdx)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fkey)).FrefCount++
						}
						if prev != libc.UintptrFromInt32(0) {
							_objPtr = prev
							v8 = _objPtr
							v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
							*(*TTcl_Size)(unsafe.Pointer(v8))--
							if v7 <= int64(1) {
								XTclFreeObj(tls, _objPtr)
							}
						}
					}
					(*TTclStrIdx)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(lwrv + uintptr(i)*8)))).Flength
					goto _3
				}
				/* split tree (e. g. j->(jan,jun) + jul == j->(jan,ju->(jun,jul)) )
				 * but don't split by fulfilled child of found item ( ii->iii->iiii ) */
				if (*TTclStrIdx)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Flength != int64(f)-int64(s) {
					/* first split found item (insert one between parent and found + new one) */
					item = XTclpAlloc(tls, uint64(56))
					if item == libc.UintptrFromInt32(0) {
						goto done
					}
					(*TTclStrIdx)(unsafe.Pointer(item)).Fkey = (*TTclStrIdx)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fkey
					if (*TTclStrIdx)(unsafe.Pointer(item)).Fkey != 0 {
						(*TTcl_Obj)(unsafe.Pointer((*TTclStrIdx)(unsafe.Pointer(item)).Fkey)).FrefCount++
					}
					(*TTclStrIdx)(unsafe.Pointer(item)).Flength = int64(f) - int64(s)
					/* set value or mark as ambigous if not the same value of both */
					if (*TTclStrIdx)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fvalue == val {
						v9 = val
					} else {
						v9 = libc.UintptrFromInt32(0)
					}
					(*TTclStrIdx)(unsafe.Pointer(item)).Fvalue = v9
					/* insert group item between foundParent and foundItem */
					_TclStrIdxTreeInsertBranch(tls, *(*uintptr)(unsafe.Pointer(bp)), item, *(*uintptr)(unsafe.Pointer(bp + 8)))
					*(*uintptr)(unsafe.Pointer(bp)) = item
				} else {
					/* the new item should be added as child of found item */
					*(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp + 8))
				}
			}
		}
		/* append item at end of found parent */
		item = XTclpAlloc(tls, uint64(56))
		if item == libc.UintptrFromInt32(0) {
			goto done
		}
		v10 = libc.UintptrFromInt32(0)
		(*TTclStrIdx)(unsafe.Pointer(item)).FchildTree.FfirstPtr = v10
		(*TTclStrIdx)(unsafe.Pointer(item)).FchildTree.FlastPtr = v10
		(*TTclStrIdx)(unsafe.Pointer(item)).Fkey = *(*uintptr)(unsafe.Pointer(lwrv + uintptr(i)*8))
		if (*TTclStrIdx)(unsafe.Pointer(item)).Fkey != 0 {
			(*TTcl_Obj)(unsafe.Pointer((*TTclStrIdx)(unsafe.Pointer(item)).Fkey)).FrefCount++
		}
		(*TTclStrIdx)(unsafe.Pointer(item)).Flength = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(lwrv + uintptr(i)*8)))).Flength
		(*TTclStrIdx)(unsafe.Pointer(item)).Fvalue = val
		_TclStrIdxTreeAppend(tls, *(*uintptr)(unsafe.Pointer(bp)), item)
		goto _3
	_3:
		;
		i++
	}
	ret = TCL_OK
	goto done
done:
	;
	if lwrv != libc.UintptrFromInt32(0) {
		i = 0
		for {
			if !(i < lstc) {
				break
			}
			_objPtr1 = *(*uintptr)(unsafe.Pointer(lwrv + uintptr(i)*8))
			v13 = _objPtr1
			v12 = *(*TTcl_Size)(unsafe.Pointer(v13))
			*(*TTcl_Size)(unsafe.Pointer(v13))--
			if v12 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
			goto _11
		_11:
			;
			i++
		}
		XTclpFree(tls, lwrv)
	}
	if ret != TCL_OK {
		if (*TTclStrIdxTree)(unsafe.Pointer(idxTree)).FfirstPtr != libc.UintptrFromInt32(0) {
			XTclStrIdxTreeFree(tls, (*TTclStrIdxTree)(unsafe.Pointer(idxTree)).FfirstPtr)
		}
	}
	return ret
}

// C documentation
//
//	/* Is a Tcl_Obj (of right type) holding a smart pointer link? */
func _IsLink(tls *libc.TLS, objPtr uintptr) (r int32) {
	var irPtr uintptr
	_ = irPtr
	irPtr = objPtr + 32
	return libc.BoolInt32((*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(irPtr))).Fptr1 != 0 && !((*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(irPtr))).Fptr2 != 0))
}

// C documentation
//
//	/* Follow links (smart pointers) if present. */
func _FollowPossibleLink(tls *libc.TLS, objPtr uintptr) (r uintptr) {
	if _IsLink(tls, objPtr) != 0 {
		objPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
	}
	/* assert(!IsLink(objPtr)); */
	return objPtr
}

func XTclStrIdxTreeNewObj(tls *libc.TLS) (r uintptr) {
	var objPtr, tree uintptr
	_, _ = objPtr, tree
	objPtr = XTcl_NewObj(tls)
	tree = objPtr + 32
	/*
	 * This assert states that we can safely directly have a tree node as the
	 * internal representation of a Tcl_Obj instead of needing to hang it
	 * off the back with an extra alloc.
	 */
	(*TTclStrIdxTree)(unsafe.Pointer(tree)).FfirstPtr = libc.UintptrFromInt32(0)
	(*TTclStrIdxTree)(unsafe.Pointer(tree)).FlastPtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = uintptr(unsafe.Pointer(&_StrIdxTreeObjType))
	/* return tree root in internal representation */
	return objPtr
}

func _StrIdxTreeObj_DupIntRepProc(tls *libc.TLS, srcPtr uintptr, copyPtr uintptr) {
	/* follow links (smart pointers) */
	srcPtr = _FollowPossibleLink(tls, srcPtr)
	/* create smart pointer to it (ptr1 != NULL, ptr2 = NULL) */
	*(*uintptr)(unsafe.Pointer(copyPtr + 32)) = srcPtr
	if *(*uintptr)(unsafe.Pointer(copyPtr + 32)) != 0 {
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(copyPtr + 32)))).FrefCount++
	}
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(copyPtr + 32))).Fptr2 = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(copyPtr)).FtypePtr = uintptr(unsafe.Pointer(&_StrIdxTreeObjType))
}

func _StrIdxTreeObj_FreeIntRepProc(tls *libc.TLS, objPtr uintptr) {
	var _objPtr, tree, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _ = _objPtr, tree, v1, v2
	/* follow links (smart pointers) */
	if _IsLink(tls, objPtr) != 0 {
		/* is a link */
		if *(*uintptr)(unsafe.Pointer(objPtr + 32)) != libc.UintptrFromInt32(0) {
			_objPtr = *(*uintptr)(unsafe.Pointer(objPtr + 32))
			v2 = _objPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if v1 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			*(*uintptr)(unsafe.Pointer(objPtr + 32)) = libc.UintptrFromInt32(0)
		}
	} else {
		/* is a tree */
		tree = objPtr + 32
		if (*TTclStrIdxTree)(unsafe.Pointer(tree)).FfirstPtr != libc.UintptrFromInt32(0) {
			XTclStrIdxTreeFree(tls, (*TTclStrIdxTree)(unsafe.Pointer(tree)).FfirstPtr)
		}
		(*TTclStrIdxTree)(unsafe.Pointer(tree)).FfirstPtr = libc.UintptrFromInt32(0)
		(*TTclStrIdxTree)(unsafe.Pointer(tree)).FlastPtr = libc.UintptrFromInt32(0)
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
}

func _StrIdxTreeObj_UpdateStringProc(tls *libc.TLS, objPtr uintptr) {
	/* currently only dummy empty string possible */
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
}

func XTclStrIdxTreeGetFromObj(tls *libc.TLS, objPtr uintptr) (r uintptr) {
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != uintptr(unsafe.Pointer(&_StrIdxTreeObjType)) {
		return libc.UintptrFromInt32(0)
	}
	/* follow links (smart pointers) */
	objPtr = _FollowPossibleLink(tls, objPtr)
	/* return tree root in internal representation */
	return objPtr + 32
}

const BLETCH = 16
const DBL_MAX1 = 1.7976931348623157e+308
const DIGIT_GROUP = 8
const EXPONENT_BIAS = 1023
const EXP_MASK = 2146435072
const EXP_SHIFT = 20
const FP_PRECISION = 53
const HI_ORDER_SIG_MASK = 1048575
const LOG10_2 = 0.3010299956639812
const LOG10_3HALVES_PLUS_FUDGE = 0.1760912590558
const MAXPOW = 22
const MOST_BITS = -1
const NAN_START = 32760
const N_BIGTENS = 5
const N_LOG2POW5 = 27
const QUICK_MAX = 14
const SIGN_BIT = 2147483648
const TEN_PMAX = 22
const TWO_OVER_3LOG10 = 0.28952965460216784

/*
 * This code supports (at least hypothetically), IBM, Cray, VAX and IEEE-754
 * floating point; of these, only IEEE-754 can represent NaN. IEEE-754 can be
 * uniquely determined by radix and by the widths of significand and exponent.
 */

/*
 * Rounding controls. (Thanks a lot, Intel!)
 */

/*
 * Other platforms are assumed to always operate in full IEEE mode, so we make
 * the macros to go in and out of that mode do nothing.
 */

/*
 * MIPS floating-point units need special settings in control registers to use
 * gradual underflow as we expect.  This fix is for the MIPSpro compiler.
 */

/*
 * HP's PA_RISC architecture uses 7ff4000000000000 to represent a quiet NaN.
 * Everyone else uses 7ff8000000000000. (Why, HP, why?)
 */

/*
 * Constants used by this file (most of which are only ever calculated at
 * runtime).
 */

/* Magic constants */

/*
 * Definitions of the parts of an IEEE754-format floating point number.
 */

/* Mask for the sign bit in the first word of
 * a double. */
/* Mask for the exponent field in the first
 * word of a double. */
/* Hidden 1 bit for the significand. */
/* Mask for the high-order part of the
 * significand in the first word of a
 * double. */
/* Mask for the 52-bit significand. */

/*
 * Derived quantities.
 */

/*
 * Union used to dismantle floating point numbers.
 */

type TDouble = struct {
	Fd [0]float64
	Fq [0]TTcl_WideUInt
	Fw struct {
		Fword0 int32
		Fword1 int32
	}
}

var _maxpow10_wide int32 /* The powers of ten that can be represented
 * exactly as wide integers. */
var _pow10_wide uintptr
var _pow10vals [23]float64

// C documentation
//
//	/* The powers of ten that can be represented
//					 * exactly as IEEE754 doubles. */
var _mmaxpow int32 /* Largest power of ten that can be
 * represented exactly in a 'double'. */
var _log10_DIGIT_MAX int32 /* The number of decimal digits that fit in an
 * mp_digit. */
var _log2FLT_RADIX int32 /* Logarithm of the floating point radix. */
var _mantBits int32      /* Number of bits in a double's significand */
var _pow5 [9]Tmp_int     /* Table of powers of 5**(2**n), up to
 * 5**256 */
var _tiny = float64(0) /* The smallest representable double. */
var _maxDigits int32   /* The maximum number of digits to the left of
 * the decimal point of a double. */
var _minDigits int32 /* The maximum number of digits to the right
 * of the decimal point in a double. */
var _pow_10_2_n = [9]float64{
	0: float64(1),
	1: float64(100),
	2: float64(10000),
	3: float64(1e+08),
	4: float64(1e+16),
	5: float64(1e+32),
	6: float64(1e+64),
	7: float64(1e+128),
	8: float64(1e+256),
}

var _n770_fp int32 /* Flag is 1 on Nokia N770 floating point.
 * Nokia's floating point has the words
 * reversed: if big-endian is 7654 3210,
 * and little-endian is       0123 4567,
 * then Nokia's FP is         4567 0123;
 * little-endian within the 32-bit words but
 * big-endian between them. */

/*
 * Table of powers of 5 that are small enough to fit in an mp_digit.
 */

var _dpow5 = [13]Tmp_digit{
	0:  uint32(1),
	1:  uint32(5),
	2:  uint32(25),
	3:  uint32(125),
	4:  uint32(625),
	5:  uint32(3125),
	6:  uint32(15625),
	7:  uint32(78125),
	8:  uint32(390625),
	9:  uint32(1953125),
	10: uint32(9765625),
	11: uint32(48828125),
	12: uint32(244140625),
}

/*
 * Table of powers: pow5_13[n] = 5**(13*2**(n+1))
 */

var _pow5_13 [5]Tmp_int /* Table of powers: 5**13, 5**26, 5**52,
 * 5**104, 5**208 */
var _tens = [23]float64{
	0:  float64(1),
	1:  float64(10),
	2:  float64(100),
	3:  float64(1000),
	4:  float64(10000),
	5:  float64(100000),
	6:  float64(1e+06),
	7:  float64(1e+07),
	8:  float64(1e+08),
	9:  float64(1e+09),
	10: float64(1e+10),
	11: float64(1e+11),
	12: float64(1e+12),
	13: float64(1e+13),
	14: float64(1e+14),
	15: float64(1e+15),
	16: float64(1e+16),
	17: float64(1e+17),
	18: float64(1e+18),
	19: float64(1e+19),
	20: float64(1e+20),
	21: float64(1e+21),
	22: float64(1e+22),
}

var _itens = [9]int32{
	0: int32(1),
	1: int32(10),
	2: int32(100),
	3: int32(1000),
	4: int32(10000),
	5: int32(100000),
	6: int32(1000000),
	7: int32(10000000),
	8: int32(100000000),
}

var _bigtens = [5]float64{
	0: float64(1e+16),
	1: float64(1e+32),
	2: float64(1e+64),
	3: float64(1e+128),
	4: float64(1e+256),
}

var _log2pow5 = [27]int32{
	0:  int32(01),
	1:  int32(3),
	2:  int32(5),
	3:  int32(7),
	4:  int32(10),
	5:  int32(12),
	6:  int32(14),
	7:  int32(17),
	8:  int32(19),
	9:  int32(21),
	10: int32(24),
	11: int32(26),
	12: int32(28),
	13: int32(31),
	14: int32(33),
	15: int32(35),
	16: int32(38),
	17: int32(40),
	18: int32(42),
	19: int32(45),
	20: int32(47),
	21: int32(49),
	22: int32(52),
	23: int32(54),
	24: int32(56),
	25: int32(59),
	26: int32(61),
}

var _wuipow5 = [28]TTcl_WideUInt{
	0:  libc.Uint64FromUint32(1),
	1:  libc.Uint64FromUint32(5),
	2:  libc.Uint64FromUint32(25),
	3:  libc.Uint64FromUint32(125),
	4:  libc.Uint64FromUint32(625),
	5:  libc.Uint64FromUint32(3125),
	6:  libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(5),
	7:  libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(25),
	8:  libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(125),
	9:  libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(625),
	10: libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125),
	11: libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(5),
	12: libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(25),
	13: libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(125),
	14: libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(625),
	15: libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125),
	16: libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(5),
	17: libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(25),
	18: libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(125),
	19: libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(625),
	20: libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125),
	21: libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(5),
	22: libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(25),
	23: libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(125),
	24: libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(625),
	25: libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125),
	26: libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(5),
	27: libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(3125) * libc.Uint64FromUint32(25),
}

/*
 *----------------------------------------------------------------------
 *
 * TclParseNumber --
 *
 *	Scans bytes, interpreted as characters in Tcl's internal encoding, and
 *	parses the longest prefix that is the string representation of a
 *	number in a format recognized by Tcl.
 *
 *	The arguments bytes, numBytes, and objPtr are the inputs which
 *	determine the string to be parsed. If bytes is non-NULL, it points to
 *	the first byte to be scanned. If bytes is NULL, then objPtr must be
 *	non-NULL, and the string representation of objPtr will be scanned
 *	(generated first, if necessary). The numBytes argument determines the
 *	number of bytes to be scanned. If numBytes is TCL_INDEX_NONE, the first NUL
 *	byte encountered will terminate the scan. Otherwise,
 *	no more than numBytes bytes will be scanned.
 *
 *	The argument flags is an input that controls the numeric formats
 *	recognized by the parser. The flag bits are:
 *
 *	- TCL_PARSE_INTEGER_ONLY:	accept only integer values; reject
 *		strings that denote floating point values (or accept only the
 *		leading portion of them that are integer values).
 *	- TCL_PARSE_SCAN_PREFIXES:	ignore the prefixes 0b and 0o that are
 *		not part of the [scan] command's vocabulary. Use only in
 *		combination with TCL_PARSE_INTEGER_ONLY.
 *	- TCL_PARSE_BINARY_ONLY:	parse only in the binary format, whether
 *		or not a prefix is present that would lead to binary parsing.
 *		Use only in combination with TCL_PARSE_INTEGER_ONLY.
 *	- TCL_PARSE_OCTAL_ONLY:		parse only in the octal format, whether
 *		or not a prefix is present that would lead to octal parsing.
 *		Use only in combination with TCL_PARSE_INTEGER_ONLY.
 *	- TCL_PARSE_HEXADECIMAL_ONLY:	parse only in the hexadecimal format,
 *		whether or not a prefix is present that would lead to
 *		hexadecimal parsing. Use only in combination with
 *		TCL_PARSE_INTEGER_ONLY.
 *	- TCL_PARSE_DECIMAL_ONLY:	parse only in the decimal format, no
 *		matter whether a 0 prefix would normally force a different
 *		base.
 *	- TCL_PARSE_NO_WHITESPACE:	reject any leading/trailing whitespace
 *
 *	The arguments interp and expected are inputs that control error
 *	message generation. If interp is NULL, no error message will be
 *	generated. If interp is non-NULL, then expected must also be non-NULL.
 *	When TCL_ERROR is returned, an error message will be left in the
 *	result of interp, and the expected argument will appear in the error
 *	message as the thing TclParseNumber expected, but failed to find in
 *	the string.
 *
 *	The arguments objPtr and endPtrPtr as well as the return code are the
 *	outputs.
 *
 *	When the parser cannot find any prefix of the string that matches a
 *	format it is looking for, TCL_ERROR is returned and an error message
 *	may be generated and returned as described above. The contents of
 *	objPtr will not be changed. If endPtrPtr is non-NULL, a pointer to the
 *	character in the string that terminated the scan will be written to
 *	*endPtrPtr.
 *
 *	When the parser determines that the entire string matches a format it
 *	is looking for, TCL_OK is returned, and if objPtr is non-NULL, then
 *	the internal rep and Tcl_ObjType of objPtr are set to the "canonical"
 *	numeric value that matches the scanned string. If endPtrPtr is not
 *	NULL, a pointer to the end of the string will be written to *endPtrPtr
 *	(that is, either bytes+numBytes or a pointer to a terminating NUL
 *	byte).
 *
 *	When the parser determines that a partial string matches a format it
 *	is looking for, the value of endPtrPtr determines what happens:
 *
 *	- If endPtrPtr is NULL, then TCL_ERROR is returned, with error message
 *		generation as above.
 *
 *	- If endPtrPtr is non-NULL, then TCL_OK is returned and objPtr
 *		internals are set as above. Also, a pointer to the first
 *		character following the parsed numeric string is written to
 *		*endPtrPtr.
 *
 *	In some cases where the string being scanned is the string rep of
 *	objPtr, this routine can leave objPtr in an inconsistent state where
 *	its string rep and its internal rep do not agree. In these cases the
 *	internal rep will be in agreement with only some substring of the
 *	string rep. This might happen if the caller passes in a non-NULL bytes
 *	value that points somewhere into the string rep. It might happen if
 *	the caller passes in a numBytes value that limits the scan to only a
 *	prefix of the string rep. Or it might happen if a non-NULL value of
 *	endPtrPtr permits a TCL_OK return from only a partial string match. It
 *	is the responsibility of the caller to detect and correct such
 *	inconsistencies when they can and do arise.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	The string representaton of objPtr may be generated.
 *
 *	The internal representation and Tcl_ObjType of objPtr may be changed.
 *	This may involve allocation and/or freeing of memory.
 *
 *----------------------------------------------------------------------
 */

func XTclParseNumber(tls *libc.TLS, interp uintptr, objPtr uintptr, expected uintptr, bytes uintptr, numBytes TTcl_Size, endPtrPtr uintptr, flags int32) (r int32) {
	bp := tls.Alloc(128)
	defer tls.Free(128) /* Flags governing the parse. */
	var acceptLen, len1 TTcl_Size
	var acceptPoint, after, before, msg, p, v3, v6, v8 uintptr
	var acceptState, exponentSignum, numDigitsAfterDp, numSigDigs, numTrailZeros, octalSignificandOverflow, shift, significandOverflow, signum, state, status, v4, v40, v41, v42 int32
	var c, d uint8
	var err Tmp_err
	var exponent, v2 int64
	var octalSignificandWide TTcl_WideUInt
	var v43 bool
	var _ /* argc at bp+64 */ TTcl_Size
	var _ /* argv at bp+72 */ uintptr
	var _ /* length at bp+56 */ TTcl_Size
	var _ /* octalSignificandBig at bp+32 */ Tmp_int
	var _ /* significandBig at bp+8 */ Tmp_int
	var _ /* significandWide at bp+0 */ TTcl_WideUInt
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = acceptLen, acceptPoint, acceptState, after, before, c, d, err, exponent, exponentSignum, len1, msg, numDigitsAfterDp, numSigDigs, numTrailZeros, octalSignificandOverflow, octalSignificandWide, p, shift, significandOverflow, signum, state, status, v2, v3, v4, v40, v41, v42, v43, v6, v8
	state = 0
	acceptState = 0
	signum = 0                                        /* Sign of the number being parsed. */
	*(*TTcl_WideUInt)(unsafe.Pointer(bp)) = uint64(0) /* Significand of the number being parsed (if
	 * it overflows significandWide). */
	significandOverflow = 0          /* Flag==1 iff significandBig is used. */
	octalSignificandWide = uint64(0) /* Significand of octal number once
	 * octalSignificandWide overflows. */
	octalSignificandOverflow = 0
	/* Flag==1 if octalSignificandBig is used. */
	numSigDigs = 0 /* Number of significant digits in the decimal
	 * significand. */
	numTrailZeros = 0 /* Number of trailing zeroes at the current
	 * point in the parse. */
	numDigitsAfterDp = 0 /* Number of digits scanned after the decimal
	 * point. */
	exponentSignum = 0 /* Signum of the exponent of a floating point
	 * number. */
	exponent = 0 /* Number of characters following that
	 * point. */
	status = TCL_OK /* Status to return to caller. */
	d = uint8(0)    /* Last hexadecimal digit scanned; initialized
	 * to avoid a compiler warning. */
	shift = 0 /* Amount to shift when accumulating binary */
	err = MP_OKAY
	/*
	 * Initialize bytes to start of the object's string rep if the caller
	 * didn't pass anything else.
	 */
	if bytes == libc.UintptrFromInt32(0) {
		if interp == libc.UintptrFromInt32(0) && endPtrPtr == libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclDictType)) {
				/* A dict can never be a (single) number */
				return int32(TCL_ERROR)
			}
			if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				/* A list can only be a (single) number if its length == 1 */
				if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
					if (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(objPtr + 32))).Fptr2 != 0 {
						v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(objPtr + 32))).Fptr2)).FspanLength
					} else {
						v2 = (*TListStore)(unsafe.Pointer((*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(objPtr + 32))).Fptr1)).FnumUsed
					}
					*(*TTcl_Size)(unsafe.Pointer(bp + 56)) = v2
					_ = libc.Int32FromInt32(TCL_OK)
				} else {
					XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), objPtr, bp+56)
				}
				if *(*TTcl_Size)(unsafe.Pointer(bp + 56)) != int64(1) {
					return int32(TCL_ERROR)
				}
			}
		}
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
			v3 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
		}
		bytes = v3
	}
	p = bytes
	len1 = numBytes
	acceptPoint = p
	acceptLen = len1
	for int32(1) != 0 {
		if len1 != 0 {
			v4 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))
		} else {
			v4 = int32('\000')
		}
		c = libc.Uint8FromInt32(v4)
		/*
		 * Filter out Numeric Whitespace. Expects:
		 *
		 *   ::digit:: '_' ::digit::
		 *
		 * Verify current '_' is ok, then move on to next character,
		 * otherwise follow through on to error.
		 */
		if libc.Int32FromUint8(c) == int32('_') && !(flags&libc.Int32FromInt32(TCL_PARSE_NO_UNDERSCORE) != 0) {
			if p == bytes {
				/* Not allowed at beginning  */
				goto endgame
			}
			/*
			 * span multiple numeric whitespace
			 *              V
			 *   example: 5___6
			 */
			before = p - libc.UintptrFromInt32(1)
			for {
				if !(before != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(before))) == int32('_')) {
					break
				}
				goto _5
			_5:
				;
				if before > p {
					v6 = before - uintptr(1)
				} else {
					v6 = libc.UintptrFromInt32(0)
				}
				before = v6
			}
			after = p + libc.UintptrFromInt32(1)
			for {
				if !(after != 0 && *(*uint8)(unsafe.Pointer(after)) != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(after))) == int32('_')) {
					break
				}
				goto _7
			_7:
				;
				if *(*uint8)(unsafe.Pointer(after)) != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(after))) == int32('_') {
					v8 = after + uintptr(1)
				} else {
					v8 = libc.UintptrFromInt32(0)
				}
				after = v8
			}
			switch state {
			case 5:
				fallthrough
			case 7:
				if before != 0 && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(before))) != int32('0') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(before))) != int32('1')) || after != 0 && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(after))) != int32('0') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(after))) != int32('1')) {
					/* Not a valid digit */
					goto endgame
				}
			case 4:
				fallthrough
			case 9:
				if before != 0 && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(before))) < int32('0') || int32('7') < libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(before)))) || after != 0 && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(after))) < int32('0') || int32('7') < libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(after)))) {
					goto endgame
				}
			case 12:
				fallthrough
			case 2:
				fallthrough
			case 6:
				fallthrough
			case 10:
				fallthrough
			case 11:
				fallthrough
			case 13:
				fallthrough
			case 14:
				fallthrough
			case 15:
				if (!(before != 0) || libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(before)))-uint32('0') < uint32(10)) != 0) && (!(after != 0) || libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(after)))-uint32('0') < uint32(10)) != 0) {
					break
				}
				if after != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(after))) == int32('(') {
					/* could be function */
					goto continue_num
				}
				goto endgame
			case 3:
				fallthrough
			case 8:
				if (!(before != 0) || libc.Xisxdigit(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(before)))) != 0) && (!(after != 0) || libc.Xisxdigit(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(after)))) != 0) {
					break
				}
				goto endgame
			default:
				/*
				 * Not whitespace, but could be legal for other reasons.
				 * Continue number processing for current character.
				 */
				goto continue_num
			}
			/* Valid whitespace found, move on to the next character */
			goto next
		}
		goto continue_num
	continue_num:
		;
		switch state {
		case 0:
			goto _9
		case 1:
			goto _10
		case 2:
			goto _11
		case 9:
			goto _12
		case 4:
			goto _13
		case 8:
			goto _14
		case 3:
			goto _15
		case 7:
			goto _16
		case 5:
			goto _17
		case 6:
			goto _18
		case 10:
			goto _19
		case 12:
			goto _20
		case 11:
			goto _21
		case 13:
			goto _22
		case 14:
			goto _23
		case 15:
			goto _24
		case 16:
			goto _25
		case 17:
			goto _26
		case 18:
			goto _27
		case 19:
			goto _28
		case 20:
			goto _29
		case 21:
			goto _30
		case 22:
			goto _31
		case 24:
			goto _32
		case 25:
			goto _33
		case 26:
			goto _34
		case 28:
			goto _35
		case 27:
			goto _36
		case 23:
			goto _37
		case 29:
			goto _38
		}
		goto _39
	_9:
		;
		/*
		 * Initial state. Acceptable characters are +, -, digits, period,
		 * I, N, and whitespace.
		 */
		if libc.Int32FromUint8(c) > int32(0x20) {
			v40 = 0
		} else {
			v40 = XTclIsSpaceProc(tls, libc.Int32FromUint8(c))
		}
		if v40 != 0 {
			if flags&int32(TCL_PARSE_NO_WHITESPACE) != 0 {
				goto endgame
			}
			goto _39
		} else {
			if libc.Int32FromUint8(c) == int32('+') {
				state = 1
				goto _39
			} else {
				if libc.Int32FromUint8(c) == int32('-') {
					signum = int32(1)
					state = 1
					goto _39
				}
			}
		}
		/* FALLTHROUGH */
	_10:
		;
		/*
		 * Scanned a leading + or -. Acceptable characters are digits,
		 * period, I, and N.
		 */
		if libc.Int32FromUint8(c) == int32('0') {
			if flags&int32(TCL_PARSE_DECIMAL_ONLY) != 0 {
				state = 10
			} else {
				state = 2
			}
			goto _39
		} else {
			if flags&int32(TCL_PARSE_HEXADECIMAL_ONLY) != 0 {
				goto zerox
			} else {
				if flags&int32(TCL_PARSE_BINARY_ONLY) != 0 {
					goto zerob
				} else {
					if flags&int32(TCL_PARSE_OCTAL_ONLY) != 0 {
						goto zeroo
					} else {
						if libc.BoolInt32(uint32(c)-uint32('0') < uint32(10)) != 0 {
							*(*TTcl_WideUInt)(unsafe.Pointer(bp)) = libc.Uint64FromInt32(libc.Int32FromUint8(c) - int32('0'))
							numSigDigs = int32(1)
							state = 10
							goto _39
						} else {
							if flags&int32(TCL_PARSE_INTEGER_ONLY) != 0 {
								goto endgame
							} else {
								if libc.Int32FromUint8(c) == int32('.') {
									state = 11
									goto _39
								} else {
									if libc.Int32FromUint8(c) == int32('I') || libc.Int32FromUint8(c) == int32('i') {
										state = 16
										goto _39
									} else {
										if libc.Int32FromUint8(c) == int32('N') || libc.Int32FromUint8(c) == int32('n') {
											state = 24
											goto _39
										}
									}
								}
							}
						}
					}
				}
			}
		}
		goto endgame
	_11:
		;
		/*
		 * Scanned a leading zero (perhaps with a + or -). Acceptable
		 * inputs are digits, period, X, b, and E. If 8 or 9 is
		 * encountered, the number can't be octal. This state and the
		 * OCTAL state differ only in whether they recognize 'X' and 'b'.
		 */
		acceptState = state
		acceptPoint = p
		acceptLen = len1
		if libc.Int32FromUint8(c) == int32('x') || libc.Int32FromUint8(c) == int32('X') {
			if flags&(libc.Int32FromInt32(TCL_PARSE_OCTAL_ONLY)|libc.Int32FromInt32(TCL_PARSE_BINARY_ONLY)) != 0 {
				goto endgame
			}
			state = 3
			goto _39
		}
		if flags&int32(TCL_PARSE_HEXADECIMAL_ONLY) != 0 {
			goto zerox
		}
		if flags&int32(TCL_PARSE_SCAN_PREFIXES) != 0 {
			goto zeroo
		}
		if libc.Int32FromUint8(c) == int32('b') || libc.Int32FromUint8(c) == int32('B') {
			if flags&int32(TCL_PARSE_OCTAL_ONLY) != 0 {
				goto endgame
			}
			state = 5
			goto _39
		}
		if flags&int32(TCL_PARSE_BINARY_ONLY) != 0 {
			goto zerob
		}
		if libc.Int32FromUint8(c) == int32('o') || libc.Int32FromUint8(c) == int32('O') {
			state = 4
			goto _39
		}
		if libc.Int32FromUint8(c) == int32('d') || libc.Int32FromUint8(c) == int32('D') {
			state = 6
			goto _39
		}
		goto decimal
	_12:
		;
		/*
		 * Scanned an optional + or -, followed by a string of octal
		 * digits. Acceptable inputs are more digits, period, or E. If 8
		 * or 9 is encountered, commit to floating point.
		 */
		acceptState = state
		acceptPoint = p
		acceptLen = len1
		/* FALLTHROUGH */
	_13:
		;
		goto zeroo
	zeroo:
		;
		if libc.Int32FromUint8(c) == int32('0') {
			numTrailZeros++
			state = 9
			goto _39
		} else {
			if libc.Int32FromUint8(c) >= int32('1') && libc.Int32FromUint8(c) <= int32('7') {
				if objPtr != libc.UintptrFromInt32(0) {
					shift = int32(3) * (numTrailZeros + int32(1))
					significandOverflow = _AccumulateDecimalDigit(tls, libc.Uint32FromInt32(libc.Int32FromUint8(c)-libc.Int32FromUint8('0')), numTrailZeros, bp, bp+8, significandOverflow)
					if !(octalSignificandOverflow != 0) {
						/*
						 * Shifting by as many or more bits than are in the
						 * value being shifted is undefined behavior. Check
						 * for too large shifts first.
						 */
						if octalSignificandWide != uint64(0) && (libc.Uint64FromInt32(shift) >= libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8) || octalSignificandWide > libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>shift) {
							octalSignificandOverflow = int32(1)
							err = XTclBN_mp_init_u64(tls, bp+32, octalSignificandWide)
						}
					}
					if !(octalSignificandOverflow != 0) {
						/*
						 * When the significand is 0, it is possible for the
						 * amount to be shifted to equal or exceed the width
						 * of the significand. Do not shift when the
						 * significand is 0 to avoid undefined behavior.
						 */
						if octalSignificandWide != uint64(0) {
							octalSignificandWide <<= libc.Uint64FromInt32(shift)
						}
						octalSignificandWide += libc.Uint64FromInt32(libc.Int32FromUint8(c) - int32('0'))
					} else {
						if err == MP_OKAY {
							err = XTclBN_mp_mul_2d(tls, bp+32, shift, bp+32)
						}
						if err == MP_OKAY {
							err = XTclBN_mp_add_d(tls, bp+32, libc.Uint32FromInt32(libc.Int32FromUint8(c)-libc.Int32FromUint8('0')), bp+32)
						}
					}
					if err != MP_OKAY {
						return int32(TCL_ERROR)
					}
				}
				if numSigDigs != 0 {
					numSigDigs += numTrailZeros + int32(1)
				} else {
					numSigDigs = int32(1)
				}
				numTrailZeros = 0
				state = 9
				goto _39
			}
		}
		goto endgame
		/*
		 * Scanned 0x. If state is HEXADECIMAL, scanned at least one
		 * character following the 0x. The only acceptable inputs are
		 * hexadecimal digits.
		 */
	_14:
		;
		acceptState = state
		acceptPoint = p
		acceptLen = len1
		/* FALLTHROUGH */
	_15:
		;
		goto zerox
	zerox:
		;
		if libc.Int32FromUint8(c) == int32('0') {
			numTrailZeros++
			state = 8
			goto _39
		} else {
			if libc.BoolInt32(uint32(c)-uint32('0') < uint32(10)) != 0 {
				d = libc.Uint8FromInt32(libc.Int32FromUint8(c) - libc.Int32FromUint8('0'))
			} else {
				if libc.Int32FromUint8(c) >= int32('A') && libc.Int32FromUint8(c) <= int32('F') {
					d = libc.Uint8FromInt32(libc.Int32FromUint8(c) - libc.Int32FromUint8('A') + libc.Int32FromInt32(10))
				} else {
					if libc.Int32FromUint8(c) >= int32('a') && libc.Int32FromUint8(c) <= int32('f') {
						d = libc.Uint8FromInt32(libc.Int32FromUint8(c) - libc.Int32FromUint8('a') + libc.Int32FromInt32(10))
					} else {
						goto endgame
					}
				}
			}
		}
		if objPtr != libc.UintptrFromInt32(0) {
			shift = int32(4) * (numTrailZeros + int32(1))
			if !(significandOverflow != 0) {
				/*
				 * Shifting by as many or more bits than are in the
				 * value being shifted is undefined behavior. Check
				 * for too large shifts first.
				 */
				if *(*TTcl_WideUInt)(unsafe.Pointer(bp)) != uint64(0) && (libc.Uint64FromInt32(shift) >= libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8) || *(*TTcl_WideUInt)(unsafe.Pointer(bp)) > libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>shift) {
					significandOverflow = int32(1)
					err = XTclBN_mp_init_u64(tls, bp+8, *(*TTcl_WideUInt)(unsafe.Pointer(bp)))
				}
			}
			if !(significandOverflow != 0) {
				/*
				 * When the significand is 0, it is possible for the
				 * amount to be shifted to equal or exceed the width
				 * of the significand. Do not shift when the
				 * significand is 0 to avoid undefined behavior.
				 */
				if *(*TTcl_WideUInt)(unsafe.Pointer(bp)) != uint64(0) {
					*(*TTcl_WideUInt)(unsafe.Pointer(bp)) <<= libc.Uint64FromInt32(shift)
				}
				*(*TTcl_WideUInt)(unsafe.Pointer(bp)) += uint64(d)
			} else {
				if err == MP_OKAY {
					err = XTclBN_mp_mul_2d(tls, bp+8, shift, bp+8)
					if err == MP_OKAY {
						err = XTclBN_mp_add_d(tls, bp+8, uint32(d), bp+8)
					}
				}
			}
		}
		if err != MP_OKAY {
			return int32(TCL_ERROR)
		}
		numTrailZeros = 0
		state = 8
		goto _39
	_16:
		;
		acceptState = state
		acceptPoint = p
		acceptLen = len1
		/* FALLTHRU */
	_17:
		;
		goto zerob
	zerob:
		;
		if libc.Int32FromUint8(c) == int32('0') {
			numTrailZeros++
			state = 7
			goto _39
		} else {
			if libc.Int32FromUint8(c) != int32('1') {
				goto endgame
			}
		}
		if objPtr != libc.UintptrFromInt32(0) {
			shift = numTrailZeros + int32(1)
			if !(significandOverflow != 0) {
				/*
				 * Shifting by as many or more bits than are in the
				 * value being shifted is undefined behavior. Check
				 * for too large shifts first.
				 */
				if *(*TTcl_WideUInt)(unsafe.Pointer(bp)) != uint64(0) && (libc.Uint64FromInt32(shift) >= libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8) || *(*TTcl_WideUInt)(unsafe.Pointer(bp)) > libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>shift) {
					significandOverflow = int32(1)
					err = XTclBN_mp_init_u64(tls, bp+8, *(*TTcl_WideUInt)(unsafe.Pointer(bp)))
				}
			}
			if !(significandOverflow != 0) {
				/*
				 * When the significand is 0, it is possible for the
				 * amount to be shifted to equal or exceed the width
				 * of the significand. Do not shift when the
				 * significand is 0 to avoid undefined behavior.
				 */
				if *(*TTcl_WideUInt)(unsafe.Pointer(bp)) != uint64(0) {
					*(*TTcl_WideUInt)(unsafe.Pointer(bp)) <<= libc.Uint64FromInt32(shift)
				}
				*(*TTcl_WideUInt)(unsafe.Pointer(bp)) += uint64(1)
			} else {
				if err == MP_OKAY {
					err = XTclBN_mp_mul_2d(tls, bp+8, shift, bp+8)
					if err == MP_OKAY {
						err = XTclBN_mp_add_d(tls, bp+8, libc.Uint32FromInt32(1), bp+8)
					}
				}
			}
		}
		if err != MP_OKAY {
			return int32(TCL_ERROR)
		}
		numTrailZeros = 0
		state = 7
		goto _39
	_18:
		;
		if libc.Int32FromUint8(c) == int32('0') {
			numTrailZeros++
		} else {
			if !(libc.BoolInt32(uint32(c)-libc.Uint32FromUint8('0') < libc.Uint32FromInt32(10)) != 0) {
				goto endgame
			}
		}
		state = 10
		flags |= int32(TCL_PARSE_INTEGER_ONLY)
		/* FALLTHROUGH */
	_19:
		;
		/*
		 * Scanned an optional + or - followed by a string of decimal
		 * digits.
		 */
		goto decimal
	decimal:
		;
		acceptState = state
		acceptPoint = p
		acceptLen = len1
		if libc.Int32FromUint8(c) == int32('0') {
			numTrailZeros++
			state = 10
			goto _39
		} else {
			if libc.BoolInt32(uint32(c)-uint32('0') < uint32(10)) != 0 {
				if objPtr != libc.UintptrFromInt32(0) {
					significandOverflow = _AccumulateDecimalDigit(tls, libc.Uint32FromInt32(libc.Int32FromUint8(c)-libc.Int32FromUint8('0')), numTrailZeros, bp, bp+8, significandOverflow)
				}
				numSigDigs += numTrailZeros + int32(1)
				numTrailZeros = 0
				state = 10
				goto _39
			} else {
				if flags&int32(TCL_PARSE_INTEGER_ONLY) != 0 {
					goto endgame
				} else {
					if libc.Int32FromUint8(c) == int32('.') {
						state = 12
						goto _39
					} else {
						if libc.Int32FromUint8(c) == int32('E') || libc.Int32FromUint8(c) == int32('e') {
							state = 13
							goto _39
						}
					}
				}
			}
		}
		goto endgame
		/*
		 * Found a decimal point. If no digits have yet been scanned, E is
		 * not allowed; otherwise, it introduces the exponent. If at least
		 * one digit has been found, we have a possible complete number.
		 */
	_20:
		;
		acceptState = state
		acceptPoint = p
		acceptLen = len1
		if libc.Int32FromUint8(c) == int32('E') || libc.Int32FromUint8(c) == int32('e') {
			state = 13
			goto _39
		}
		/* FALLTHROUGH */
	_21:
		;
		if libc.Int32FromUint8(c) == int32('0') {
			numDigitsAfterDp++
			numTrailZeros++
			state = 12
			goto _39
		} else {
			if libc.BoolInt32(uint32(c)-uint32('0') < uint32(10)) != 0 {
				numDigitsAfterDp++
				if objPtr != libc.UintptrFromInt32(0) {
					significandOverflow = _AccumulateDecimalDigit(tls, libc.Uint32FromInt32(libc.Int32FromUint8(c)-libc.Int32FromUint8('0')), numTrailZeros, bp, bp+8, significandOverflow)
				}
				if numSigDigs != 0 {
					numSigDigs += numTrailZeros + int32(1)
				} else {
					numSigDigs = int32(1)
				}
				numTrailZeros = 0
				state = 12
				goto _39
			}
		}
		goto endgame
	_22:
		;
		/*
		 * Scanned the E at the start of an exponent. Make sure a legal
		 * character follows before using the C library strtol routine,
		 * which allows whitespace.
		 */
		if libc.Int32FromUint8(c) == int32('+') {
			state = 14
			goto _39
		} else {
			if libc.Int32FromUint8(c) == int32('-') {
				exponentSignum = int32(1)
				state = 14
				goto _39
			}
		}
		/* FALLTHROUGH */
	_23:
		;
		/*
		 * Found the E at the start of the exponent, followed by a sign
		 * character.
		 */
		if libc.BoolInt32(uint32(c)-uint32('0') < uint32(10)) != 0 {
			exponent = int64(libc.Int32FromUint8(c) - int32('0'))
			state = 15
			goto _39
		}
		goto endgame
	_24:
		;
		/*
		 * Found an exponent with at least one digit. Accumulate it,
		 * making sure to hard-pin it to LONG_MAX on overflow.
		 */
		acceptState = state
		acceptPoint = p
		acceptLen = len1
		if libc.BoolInt32(uint32(c)-uint32('0') < uint32(10)) != 0 {
			if exponent < (libc.Int64FromInt64(0x7fffffffffffffff)-libc.Int64FromInt32(9))/libc.Int64FromInt32(10) {
				exponent = int64(10)*exponent + int64(libc.Int32FromUint8(c)-libc.Int32FromUint8('0'))
			} else {
				exponent = int64(0x7fffffffffffffff)
			}
			state = 15
			goto _39
		}
		goto endgame
		/*
		 * Parse out INFINITY by simply spelling it out. INF is accepted
		 * as an abbreviation; other prefices are not.
		 */
	_25:
		;
		if libc.Int32FromUint8(c) == int32('n') || libc.Int32FromUint8(c) == int32('N') {
			state = 17
			goto _39
		}
		goto endgame
	_26:
		;
		if libc.Int32FromUint8(c) == int32('f') || libc.Int32FromUint8(c) == int32('F') {
			state = 18
			goto _39
		}
		goto endgame
	_27:
		;
		acceptState = state
		acceptPoint = p
		acceptLen = len1
		if libc.Int32FromUint8(c) == int32('i') || libc.Int32FromUint8(c) == int32('I') {
			state = 19
			goto _39
		}
		goto endgame
	_28:
		;
		if libc.Int32FromUint8(c) == int32('n') || libc.Int32FromUint8(c) == int32('N') {
			state = 20
			goto _39
		}
		goto endgame
	_29:
		;
		if libc.Int32FromUint8(c) == int32('i') || libc.Int32FromUint8(c) == int32('I') {
			state = 21
			goto _39
		}
		goto endgame
	_30:
		;
		if libc.Int32FromUint8(c) == int32('t') || libc.Int32FromUint8(c) == int32('T') {
			state = 22
			goto _39
		}
		goto endgame
	_31:
		;
		if libc.Int32FromUint8(c) == int32('y') || libc.Int32FromUint8(c) == int32('Y') {
			state = 23
			goto _39
		}
		goto endgame
		/*
		 * Parse NaN's.
		 */
	_32:
		;
		if libc.Int32FromUint8(c) == int32('a') || libc.Int32FromUint8(c) == int32('A') {
			state = 25
			goto _39
		}
		goto endgame
	_33:
		;
		if libc.Int32FromUint8(c) == int32('n') || libc.Int32FromUint8(c) == int32('N') {
			state = 26
			goto _39
		}
		goto endgame
	_34:
		;
		acceptState = state
		acceptPoint = p
		acceptLen = len1
		if libc.Int32FromUint8(c) == int32('(') {
			state = 27
			goto _39
		}
		goto endgame
		/*
		 * Parse NaN(hexdigits)
		 */
	_35:
		;
		if libc.Int32FromUint8(c) == int32(')') {
			state = 29
			goto _39
		}
		/* FALLTHROUGH */
	_36:
		;
		if libc.Int32FromUint8(c) > int32(0x20) {
			v41 = 0
		} else {
			v41 = XTclIsSpaceProc(tls, libc.Int32FromUint8(c))
		}
		if v41 != 0 {
			goto _39
		}
		if numSigDigs < int32(13) {
			if libc.Int32FromUint8(c) >= int32('0') && libc.Int32FromUint8(c) <= int32('9') {
				d = libc.Uint8FromInt32(libc.Int32FromUint8(c) - int32('0'))
			} else {
				if libc.Int32FromUint8(c) >= int32('a') && libc.Int32FromUint8(c) <= int32('f') {
					d = libc.Uint8FromInt32(int32(10) + libc.Int32FromUint8(c) - int32('a'))
				} else {
					if libc.Int32FromUint8(c) >= int32('A') && libc.Int32FromUint8(c) <= int32('F') {
						d = libc.Uint8FromInt32(int32(10) + libc.Int32FromUint8(c) - int32('A'))
					} else {
						goto endgame
					}
				}
			}
			numSigDigs++
			*(*TTcl_WideUInt)(unsafe.Pointer(bp)) = *(*TTcl_WideUInt)(unsafe.Pointer(bp))<<libc.Int32FromInt32(4) + uint64(d)
			state = 28
			goto _39
		}
		goto endgame
	_38:
		;
	_37:
		;
		acceptState = state
		acceptPoint = p
		acceptLen = len1
		goto endgame
	_39:
		;
		goto next
	next:
		;
		p++
		len1--
	}
	goto endgame
endgame:
	;
	if acceptState == 0 {
		/*
		 * No numeric string at all found.
		 */
		status = int32(TCL_ERROR)
		if endPtrPtr != libc.UintptrFromInt32(0) {
			*(*uintptr)(unsafe.Pointer(endPtrPtr)) = p
		}
	} else {
		/*
		 * Back up to the last accepting state in the lexer.
		 * If the last char seen is the numeric whitespace character '_',
		 * backup to that.
		 */
		p = acceptPoint
		len1 = acceptLen
		if !(flags&libc.Int32FromInt32(TCL_PARSE_NO_WHITESPACE) != 0) {
			/*
			 * Accept trailing whitespace.
			 */
			for {
				if v43 = len1 != 0; v43 {
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) > int32(0x20) {
						v42 = 0
					} else {
						v42 = XTclIsSpaceProc(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))))
					}
				}
				if !(v43 && v42 != 0) {
					break
				}
				p++
				len1--
			}
		}
		if endPtrPtr == libc.UintptrFromInt32(0) {
			if len1 != 0 && (numBytes+int64(1) > int64(1) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('\000')) {
				status = int32(TCL_ERROR)
			}
		} else {
			*(*uintptr)(unsafe.Pointer(endPtrPtr)) = p
		}
	}
	/*
	 * Generate and store the appropriate internal rep.
	 */
	if status == TCL_OK && objPtr != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != libc.UintptrFromInt32(0) {
			if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
				(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc})))(tls, objPtr)
			}
			(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
		}
		switch acceptState {
		case 28:
			goto _44
		case 27:
			goto _45
		case 25:
			goto _46
		case 24:
			goto _47
		case 22:
			goto _48
		case 21:
			goto _49
		case 20:
			goto _50
		case 19:
			goto _51
		case 17:
			goto _52
		case 16:
			goto _53
		case 14:
			goto _54
		case 13:
			goto _55
		case 11:
			goto _56
		case 6:
			goto _57
		case 5:
			goto _58
		case 4:
			goto _59
		case 3:
			goto _60
		case 1:
			goto _61
		case 7:
			goto _62
		case 8:
			goto _63
		case 9:
			goto _64
		case 10:
			goto _65
		case 2:
			goto _66
		case 15:
			goto _67
		case 12:
			goto _68
		case 23:
			goto _69
		case 18:
			goto _70
		case 29:
			goto _71
		case 26:
			goto _72
		case 0:
			goto _73
		}
		goto _74
	_61:
		;
	_60:
		;
	_59:
		;
	_58:
		;
	_57:
		;
	_56:
		;
	_55:
		;
	_54:
		;
	_53:
		;
	_52:
		;
	_51:
		;
	_50:
		;
	_49:
		;
	_48:
		;
	_47:
		;
	_46:
		;
	_45:
		;
	_44:
		;
		XTcl_Panic(tls, __ccgo_ts+66887, libc.VaList(bp+88, acceptState, bytes))
	_62:
		;
		shift = numTrailZeros
		if !(significandOverflow != 0) && *(*TTcl_WideUInt)(unsafe.Pointer(bp)) != uint64(0) && (libc.Uint64FromInt32(shift) >= libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8) || *(*TTcl_WideUInt)(unsafe.Pointer(bp)) > (libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)+libc.Uint64FromInt32(signum))>>shift) {
			significandOverflow = int32(1)
			err = XTclBN_mp_init_u64(tls, bp+8, *(*TTcl_WideUInt)(unsafe.Pointer(bp)))
		}
		if shift != 0 {
			if !(significandOverflow != 0) {
				/*
				 * When the significand is 0, it is possible for the
				 * amount to be shifted to equal or exceed the width
				 * of the significand. Do not shift when the
				 * significand is 0 to avoid undefined behavior.
				 */
				if *(*TTcl_WideUInt)(unsafe.Pointer(bp)) != uint64(0) {
					*(*TTcl_WideUInt)(unsafe.Pointer(bp)) <<= libc.Uint64FromInt32(shift)
				}
			} else {
				if err == MP_OKAY {
					err = XTclBN_mp_mul_2d(tls, bp+8, shift, bp+8)
				}
			}
		}
		if err != MP_OKAY {
			return int32(TCL_ERROR)
		}
		goto returnInteger
	_63:
		;
		/*
		 * Returning a hex integer. Final scaling step.
		 */
		shift = int32(4) * numTrailZeros
		if !(significandOverflow != 0) && *(*TTcl_WideUInt)(unsafe.Pointer(bp)) != uint64(0) && (libc.Uint64FromInt32(shift) >= libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8) || *(*TTcl_WideUInt)(unsafe.Pointer(bp)) > (libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)+libc.Uint64FromInt32(signum))>>shift) {
			significandOverflow = int32(1)
			err = XTclBN_mp_init_u64(tls, bp+8, *(*TTcl_WideUInt)(unsafe.Pointer(bp)))
		}
		if shift != 0 {
			if !(significandOverflow != 0) {
				/*
				 * When the significand is 0, it is possible for the
				 * amount to be shifted to equal or exceed the width
				 * of the significand. Do not shift when the
				 * significand is 0 to avoid undefined behavior.
				 */
				if *(*TTcl_WideUInt)(unsafe.Pointer(bp)) != uint64(0) {
					*(*TTcl_WideUInt)(unsafe.Pointer(bp)) <<= libc.Uint64FromInt32(shift)
				}
			} else {
				if err == MP_OKAY {
					err = XTclBN_mp_mul_2d(tls, bp+8, shift, bp+8)
				}
			}
		}
		if err != MP_OKAY {
			return int32(TCL_ERROR)
		}
		goto returnInteger
	_64:
		;
		/*
		 * Returning an octal integer. Final scaling step.
		 */
		shift = int32(3) * numTrailZeros
		if !(octalSignificandOverflow != 0) && octalSignificandWide != uint64(0) && (libc.Uint64FromInt32(shift) >= libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8) || octalSignificandWide > (libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)+libc.Uint64FromInt32(signum))>>shift) {
			octalSignificandOverflow = int32(1)
			err = XTclBN_mp_init_u64(tls, bp+32, octalSignificandWide)
		}
		if shift != 0 {
			if !(octalSignificandOverflow != 0) {
				/*
				 * When the significand is 0, it is possible for the
				 * amount to be shifted to equal or exceed the width
				 * of the significand. Do not shift when the
				 * significand is 0 to avoid undefined behavior.
				 */
				if octalSignificandWide != uint64(0) {
					octalSignificandWide <<= libc.Uint64FromInt32(shift)
				}
			} else {
				if err == MP_OKAY {
					err = XTclBN_mp_mul_2d(tls, bp+32, shift, bp+32)
				}
			}
		}
		if !(octalSignificandOverflow != 0) {
			if err == MP_OKAY && octalSignificandWide > libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)+libc.Uint64FromInt32(signum) {
				err = XTclBN_mp_init_u64(tls, bp+32, octalSignificandWide)
				octalSignificandOverflow = int32(1)
			} else {
				(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
				if signum != 0 {
					*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) = libc.Int64FromUint64(-octalSignificandWide)
				} else {
					*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) = libc.Int64FromUint64(octalSignificandWide)
				}
			}
		}
		if err == MP_OKAY && octalSignificandOverflow != 0 {
			if signum != 0 {
				err = XTclBN_mp_neg(tls, bp+32, bp+32)
			}
			XTclSetBignumInternalRep(tls, objPtr, bp+32)
		}
		if err != MP_OKAY {
			return int32(TCL_ERROR)
		}
		goto _74
	_66:
		;
	_65:
		;
		significandOverflow = _AccumulateDecimalDigit(tls, uint32(0), numTrailZeros-int32(1), bp, bp+8, significandOverflow)
		if err == MP_OKAY && !(significandOverflow != 0) && *(*TTcl_WideUInt)(unsafe.Pointer(bp)) > libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)+libc.Uint64FromInt32(signum) {
			significandOverflow = int32(1)
			err = XTclBN_mp_init_u64(tls, bp+8, *(*TTcl_WideUInt)(unsafe.Pointer(bp)))
		}
		goto returnInteger
	returnInteger:
		;
		if !(significandOverflow != 0) {
			if err == MP_OKAY && *(*TTcl_WideUInt)(unsafe.Pointer(bp)) > libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)+libc.Uint64FromInt32(signum) {
				err = XTclBN_mp_init_u64(tls, bp+8, *(*TTcl_WideUInt)(unsafe.Pointer(bp)))
				significandOverflow = int32(1)
			} else {
				(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
				if signum != 0 {
					*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) = libc.Int64FromUint64(-*(*TTcl_WideUInt)(unsafe.Pointer(bp)))
				} else {
					*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) = libc.Int64FromUint64(*(*TTcl_WideUInt)(unsafe.Pointer(bp)))
				}
			}
		}
		if err == MP_OKAY && significandOverflow != 0 {
			if signum != 0 {
				err = XTclBN_mp_neg(tls, bp+8, bp+8)
			}
			XTclSetBignumInternalRep(tls, objPtr, bp+8)
		}
		if err != MP_OKAY {
			return int32(TCL_ERROR)
		}
		goto _74
	_68:
		;
	_67:
		;
		/*
		 * Here, we're parsing a floating-point number. 'significandWide'
		 * or 'significandBig' contains the exact significand, according
		 * to whether 'significandOverflow' is set. The desired floating
		 * point value is significand * 10**k, where
		 * k = numTrailZeros+exponent-numDigitsAfterDp.
		 */
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclDoubleType))
		if exponentSignum != 0 {
			/*
			 * At this point exponent>=0, so the following calculation
			 * cannot underflow.
			 */
			exponent = -exponent
		}
		/*
		 * Adjust the exponent for the number of trailing zeros that
		 * have not been accumulated, and the number of digits after
		 * the decimal point. Pin any overflow to LONG_MAX/LONG_MIN
		 * respectively.
		 */
		if exponent >= 0 {
			if exponent-int64(numDigitsAfterDp) > int64(0x7fffffffffffffff)-int64(numTrailZeros) {
				exponent = int64(0x7fffffffffffffff)
			} else {
				exponent = exponent - int64(numDigitsAfterDp) + int64(numTrailZeros)
			}
		} else {
			if exponent+int64(numTrailZeros) < -libc.Int64FromInt64(0x7fffffffffffffff)-libc.Int64FromInt32(1)+int64(numDigitsAfterDp) {
				exponent = -libc.Int64FromInt64(0x7fffffffffffffff) - libc.Int64FromInt32(1)
			} else {
				exponent = exponent + int64(numTrailZeros) - int64(numDigitsAfterDp)
			}
		}
		/*
		 * The desired number is now significandWide * 10**exponent
		 * or significandBig * 10**exponent, depending on whether
		 * the significand has overflowed a wide int.
		 */
		if !(significandOverflow != 0) {
			*(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) = _MakeLowPrecisionDouble(tls, signum, *(*TTcl_WideUInt)(unsafe.Pointer(bp)), numSigDigs, exponent)
		} else {
			*(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) = _MakeHighPrecisionDouble(tls, signum, bp+8, numSigDigs, exponent)
		}
		goto _74
	_70:
		;
	_69:
		;
		if signum != 0 {
			*(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) = -float64(libc.X__builtin_inff(tls))
		} else {
			*(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) = float64(libc.X__builtin_inff(tls))
		}
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclDoubleType))
		goto _74
	_72:
		;
	_71:
		;
		*(*float64)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(objPtr)).FinternalRep)) = _MakeNaN(tls, signum, *(*TTcl_WideUInt)(unsafe.Pointer(bp)))
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclDoubleType))
		goto _74
	_73:
		;
		/* This case only to silence compiler warning. */
		XTcl_Panic(tls, __ccgo_ts+66935, 0)
	_74:
	}
	/*
	 * Format an error message when an invalid number is encountered.
	 */
	if status != TCL_OK {
		if interp != libc.UintptrFromInt32(0) {
			msg = XTcl_ObjPrintf(tls, __ccgo_ts+66983, libc.VaList(bp+88, expected))
			if XTclMaxListLength(tls, bytes, int64(-libc.Int32FromInt32(1)), libc.UintptrFromInt32(0)) > int64(1) && XTcl_SplitList(tls, libc.UintptrFromInt32(0), bytes, bp+64, bp+72) == TCL_OK {
				XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 72)))
				XTcl_AppendToObj(tls, msg, __ccgo_ts+67004, int64(-int32(1)))
			} else {
				XTcl_AppendToObj(tls, msg, __ccgo_ts+14586, int64(-int32(1)))
				XTcl_AppendLimitedToObj(tls, msg, bytes, numBytes, int64(50), __ccgo_ts+1945)
				XTcl_AppendToObj(tls, msg, __ccgo_ts+14586, int64(-int32(1)))
			}
			XTcl_SetObjResult(tls, interp, msg)
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+88, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+45786, libc.UintptrFromInt32(0)))
		}
	}
	/*
	 * Free memory.
	 */
	if octalSignificandOverflow != 0 {
		XTclBN_mp_clear(tls, bp+32)
	}
	if significandOverflow != 0 {
		XTclBN_mp_clear(tls, bp+8)
	}
	return status
}

/*
 *----------------------------------------------------------------------
 *
 * AccumulateDecimalDigit --
 *
 *	Consume a decimal digit in a number being scanned.
 *
 * Results:
 *	Returns 1 if the number has overflowed to a bignum, 0 if it still fits
 *	in a wide integer.
 *
 * Side effects:
 *	Updates either the wide or bignum representation.
 *
 *----------------------------------------------------------------------
 */

func _AccumulateDecimalDigit(tls *libc.TLS, digit uint32, numZeros int32, wideRepPtr uintptr, bignumRepPtr uintptr, bignumFlag int32) (r int32) {
	/* Flag == 1 if the number overflowed previous
	 * to this digit. */
	var err Tmp_err
	var i, n int32
	var w TTcl_WideUInt
	_, _, _, _ = err, i, n, w
	/*
	 * Try wide multiplication first.
	 */
	if !(bignumFlag != 0) {
		w = *(*TTcl_WideUInt)(unsafe.Pointer(wideRepPtr))
		if w == uint64(0) {
			/*
			 * There's no need to multiply if the multiplicand is zero.
			 */
			*(*TTcl_WideUInt)(unsafe.Pointer(wideRepPtr)) = uint64(digit)
			return 0
		} else {
			if numZeros >= _maxpow10_wide || w > (libc.Uint64FromInt32(-libc.Int32FromInt32(1))-uint64(digit)) / *(*TTcl_WideUInt)(unsafe.Pointer(_pow10_wide + uintptr(numZeros+int32(1))*8)) {
				/*
				 * Wide multiplication will overflow.  Expand the number to a
				 * bignum and fall through into the bignum case.
				 */
				if XTclBN_mp_init_u64(tls, bignumRepPtr, w) != MP_OKAY {
					return 0
				}
			} else {
				/*
				 * Wide multiplication.
				 */
				*(*TTcl_WideUInt)(unsafe.Pointer(wideRepPtr)) = w**(*TTcl_WideUInt)(unsafe.Pointer(_pow10_wide + uintptr(numZeros+int32(1))*8)) + uint64(digit)
				return 0
			}
		}
	}
	/*
	 * Bignum multiplication.
	 */
	if numZeros < _log10_DIGIT_MAX {
		/*
		 * Up to about 8 zeros - single digit multiplication.
		 */
		if XTclBN_mp_mul_d(tls, bignumRepPtr, uint32(*(*TTcl_WideUInt)(unsafe.Pointer(_pow10_wide + uintptr(numZeros+int32(1))*8))), bignumRepPtr) != MP_OKAY || XTclBN_mp_add_d(tls, bignumRepPtr, digit, bignumRepPtr) != MP_OKAY {
			return 0
		}
	} else {
		/*
		 * More than single digit multiplication. Multiply by the appropriate
		 * small powers of 5, and then shift. Large strings of zeroes are
		 * eaten 256 at a time; this is less efficient than it could be, but
		 * seems implausible. We presume that MP_DIGIT_BIT is at least 27. The
		 * first multiplication, by up to 10**7, is done with a one-DIGIT
		 * multiply (this presumes that MP_DIGIT_BIT >= 24).
		 */
		n = numZeros + int32(1)
		err = XTclBN_mp_mul_d(tls, bignumRepPtr, uint32(*(*TTcl_WideUInt)(unsafe.Pointer(_pow10_wide + uintptr(n&int32(0x7))*8))), bignumRepPtr)
		i = int32(3)
		for {
			if !(err == MP_OKAY && i <= int32(7)) {
				break
			}
			if n&(int32(1)<<i) != 0 {
				err = XTclBN_mp_mul(tls, bignumRepPtr, uintptr(unsafe.Pointer(&_pow5))+uintptr(i)*24, bignumRepPtr)
			}
			goto _1
		_1:
			;
			i++
		}
		for err == MP_OKAY && n >= int32(256) {
			err = XTclBN_mp_mul(tls, bignumRepPtr, uintptr(unsafe.Pointer(&_pow5))+uintptr(8)*24, bignumRepPtr)
			n -= int32(256)
		}
		if err != MP_OKAY || XTclBN_mp_mul_2d(tls, bignumRepPtr, (numZeros+libc.Int32FromInt32(1)) & ^libc.Int32FromInt32(0x7), bignumRepPtr) != MP_OKAY || XTclBN_mp_add_d(tls, bignumRepPtr, digit, bignumRepPtr) != MP_OKAY {
			return 0
		}
	}
	return int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * MakeLowPrecisionDouble --
 *
 *	Makes the double precision number, signum*significand*10**exponent.
 *
 * Results:
 *	Returns the constructed number.
 *
 *	Common cases, where there are few enough digits that the number can be
 *	represented with at most roundoff, are handled specially here. If the
 *	number requires more than one rounded operation to compute, the code
 *	promotes the significand to a bignum and calls MakeHighPrecisionDouble
 *	to do it instead.
 *
 *----------------------------------------------------------------------
 */

func _MakeLowPrecisionDouble(tls *libc.TLS, signum int32, significand TTcl_WideUInt, numSigDigs int32, exponent int64) (r float64) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Power of ten */
	var diff int32
	var factor, retval float64
	var _ /* significandBig at bp+0 */ Tmp_int
	_, _, _ = diff, factor, retval /* Value of the number. */
	/*
	 * Test for zero significand, which requires explicit construction
	 * of -0.0. (Unary minus returns a positive zero.)
	 */
	if significand == uint64(0) {
		return libc.X__builtin_copysign(tls, float64(0), float64(-signum))
	}
	/*
	 * Set the FP control word for 53 bits, WARNING: It must be reset
	 * before returning.
	 */
	if numSigDigs <= int32(QUICK_MAX) {
		if exponent >= 0 {
			if exponent <= int64(_mmaxpow) {
				/*
				 * The significand is an exact integer, and so is
				 * 10**exponent. The product will be correct to within 1/2 ulp
				 * without special handling.
				 */
				retval = float64(float64(libc.Int64FromUint64(significand)) * _pow10vals[exponent])
				goto returnValue
			} else {
				diff = int32(QUICK_MAX) - numSigDigs
				if exponent-int64(diff) <= int64(_mmaxpow) {
					/*
					 * 10**exponent is not an exact integer, but
					 * 10**(exponent-diff) is exact, and so is
					 * significand*10**diff, so we can still compute the value
					 * with only one roundoff.
					 */
					factor = float64(float64(libc.Int64FromUint64(significand)) * _pow10vals[diff])
					retval = float64(factor * _pow10vals[exponent-int64(diff)])
					goto returnValue
				}
			}
		} else {
			if exponent >= int64(-_mmaxpow) {
				/*
				 * 10**-exponent is an exact integer, and so is the
				 * significand. Compute the result by one division, again with
				 * only one rounding.
				 */
				retval = float64(libc.Int64FromUint64(significand)) / _pow10vals[-exponent]
				goto returnValue
			}
		}
	}
	/*
	 * All the easy cases have failed. Promote the significand to bignum and
	 * call MakeHighPrecisionDouble to do it the hard way.
	 */
	if XTclBN_mp_init_u64(tls, bp, significand) != MP_OKAY {
		return float64(0)
	}
	retval = _MakeHighPrecisionDouble(tls, 0, bp, numSigDigs, exponent)
	XTclBN_mp_clear(tls, bp)
	/*
	 * Come here to return the computed value.
	 */
	goto returnValue
returnValue:
	;
	if signum != 0 {
		retval = -retval
	}
	/*
	 * On gcc on x86, restore the floating point mode word.
	 */
	return retval
}

/*
 *----------------------------------------------------------------------
 *
 * MakeHighPrecisionDouble --
 *
 *	Makes the double precision number, signum*significand*10**exponent.
 *
 * Results:
 *	Returns the constructed number.
 *
 *	MakeHighPrecisionDouble is used when arbitrary-precision arithmetic is
 *	needed to ensure correct rounding. It begins by calculating a
 *	low-precision approximation to the desired number, and then refines
 *	the answer in high precision.
 *
 *----------------------------------------------------------------------
 */

func _MakeHighPrecisionDouble(tls *libc.TLS, signum int32, significand uintptr, numSigDigs int32, exponent int64) (r float64) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Power of 10 by which to multiply */
	var retval float64
	var v1 int32
	var _ /* machexp at bp+0 */ int32
	_, _ = retval, v1
	*(*int32)(unsafe.Pointer(bp)) = 0
	/*
	 * A zero significand requires explicit construction of -0.0.
	 * (Unary minus returns positive zero.)
	 */
	if (*Tmp_int)(unsafe.Pointer(significand)).Fused == 0 {
		v1 = int32(MP_YES)
	} else {
		v1 = MP_NO
	}
	if v1 != 0 {
		return libc.X__builtin_copysign(tls, float64(0), float64(-signum))
	}
	/*
	 * Set the 53-bit rounding mode. WARNING: It must be reset before
	 * returning.
	 */
	/*
	 * Make quick checks for over/underflow. Be careful to avoid
	 * integer overflow when calculating with 'exponent'.
	 */
	if exponent >= 0 && exponent-int64(1) > int64(_maxDigits-numSigDigs) {
		retval = float64(libc.X__builtin_inff(tls))
		goto returnValue
	} else {
		if exponent < 0 && int64(numSigDigs)+exponent < int64(_minDigits+int32(1)) {
			retval = float64(0)
			goto returnValue
		}
	}
	/*
	 * Develop a first approximation to the significand. It is tempting simply
	 * to force bignum to double, but that will overflow on input numbers like
	 * 1.[string repeat 0 1000]1; while this is a not terribly likely
	 * scenario, we still have to deal with it. Use fraction and exponent
	 * instead. Once we have the significand, multiply by 10**exponent. Test
	 * for overflow. Convert back to a double, and test for underflow.
	 */
	retval = _BignumToBiasedFrExp(tls, significand, bp)
	retval = _Pow10TimesFrExp(tls, int32(exponent), retval, bp)
	if *(*int32)(unsafe.Pointer(bp)) > int32(DBL_MAX_EXP)*_log2FLT_RADIX {
		retval = float64(libc.X__builtin_inff(tls))
		goto returnValue
	}
	retval = _SafeLdExp(tls, retval, *(*int32)(unsafe.Pointer(bp)))
	if _tiny == float64(0) {
		_tiny = _SafeLdExp(tls, float64(1), -int32(1021)*_log2FLT_RADIX-_mantBits)
	}
	if retval < _tiny {
		retval = _tiny
	}
	/*
	 * Refine the result twice. (The second refinement should be necessary
	 * only if the best approximation is a power of 2 minus 1/2 ulp).
	 */
	retval = _RefineApproximation(tls, retval, significand, int32(exponent))
	retval = _RefineApproximation(tls, retval, significand, int32(exponent))
	/*
	 * Come here to return the computed value.
	 */
	goto returnValue
returnValue:
	;
	if signum != 0 {
		retval = -retval
	}
	/*
	 * On gcc on x86, restore the floating point mode word.
	 */
	return retval
}

/*
 *----------------------------------------------------------------------
 *
 * MakeNaN --
 *
 *	Makes a "Not a Number" given a set of bits to put in the tag bits
 *
 *	Note that a signalling NaN is never returned.
 *
 *----------------------------------------------------------------------
 */

func _MakeNaN(tls *libc.TLS, signum int32, tags TTcl_WideUInt) (r float64) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Tag bits to put in the NaN. */
	var _ /* theNaN at bp+0 */ struct {
		Fdv [0]float64
		Fiv TTcl_WideUInt
	}
	*(*TTcl_WideUInt)(unsafe.Pointer(bp)) = tags
	*(*TTcl_WideUInt)(unsafe.Pointer(bp)) &= libc.Uint64FromInt32(1)<<libc.Int32FromInt32(51) - libc.Uint64FromInt32(1)
	if signum != 0 {
		*(*TTcl_WideUInt)(unsafe.Pointer(bp)) |= libc.Uint64FromInt32(libc.Int32FromInt32(0x8000)|libc.Int32FromInt32(NAN_START)) << libc.Int32FromInt32(48)
	} else {
		*(*TTcl_WideUInt)(unsafe.Pointer(bp)) |= libc.Uint64FromInt32(NAN_START) << libc.Int32FromInt32(48)
	}
	if _n770_fp != 0 {
		*(*TTcl_WideUInt)(unsafe.Pointer(bp)) = _Nokia770Twiddle(tls, *(*TTcl_WideUInt)(unsafe.Pointer(bp)))
	}
	return *(*float64)(unsafe.Pointer(bp))
}

/*
 *----------------------------------------------------------------------
 *
 * RefineApproximation --
 *
 *	Given a poor approximation to a floating point number, returns a
 *	better one. (The better approximation is correct to within 1 ulp, and
 *	is entirely correct if the poor approximation is correct to 1 ulp.)
 *
 * Results:
 *	Returns the improved result.
 *
 *----------------------------------------------------------------------
 */

func _RefineApproximation(tls *libc.TLS, approxResult float64, exactSignificand uintptr, exponent int32) (r float64) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Power of 10 to multiply by significand. */
	var M2, M5, i, msb, multiplier, nDigits, roundToEven, scale, shift, v1 int32
	var den, minincr, num, quot, rteSignificand, significand float64
	var err Tmp_err
	var rteSigWide TTcl_WideInt
	var _ /* binExponent at bp+0 */ int32
	var _ /* rteExponent at bp+56 */ int32
	var _ /* twoMd at bp+32 */ Tmp_int
	var _ /* twoMv at bp+8 */ Tmp_int
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = M2, M5, den, err, i, minincr, msb, multiplier, nDigits, num, quot, roundToEven, rteSigWide, rteSignificand, scale, shift, significand, v1 /* Lower bound on the absolute value of the
	 * correction term. */
	roundToEven = 0
	err = MP_OKAY
	/*
	 * The first approximation is always low. If we find that it's HUGE_VAL,
	 * we're done.
	 */
	if approxResult == float64(libc.X__builtin_inff(tls)) {
		return approxResult
	}
	significand = libc.Xfrexp(tls, approxResult, bp)
	/*
	 * We are trying to compute a corrector term that, when added to the
	 * approximate result, will yield close to the exact result.
	 * The exact result is exactSignificand * 10**exponent.
	 * The approximate result is significand * 2**binExponent
	 * If exponent<0, we need to multiply the exact value by 10**-exponent
	 * to make it an integer, plus another factor of 2 to decide on rounding.
	 *  Similarly if binExponent<FP_PRECISION, we need
	 * to multiply by 2**FP_PRECISION to make the approximate value an integer.
	 *
	 * Let M = 2**M2 * 5**M5 be the least common multiple of these two
	 * multipliers.
	 */
	i = _mantBits - *(*int32)(unsafe.Pointer(bp))
	if i < 0 {
		M2 = 0
	} else {
		M2 = i
	}
	if exponent > 0 {
		M5 = 0
	} else {
		M5 = -exponent
		if M5-int32(1) > M2 {
			M2 = M5 - int32(1)
		}
	}
	/*
	 * Compute twoMv as 2*M*v, where v is the approximate value.
	 * This is done by bit-whacking to calculate 2**(M2+1)*significand,
	 * and then multiplying by 5**M5.
	 */
	msb = *(*int32)(unsafe.Pointer(bp)) + M2 /* 1008 */
	nDigits = msb/int32(MP_DIGIT_BIT) + int32(1)
	if XTclBN_mp_init_size(tls, bp+8, nDigits) != MP_OKAY {
		return approxResult
	}
	i = msb%int32(MP_DIGIT_BIT) + int32(1)
	(*(*Tmp_int)(unsafe.Pointer(bp + 8))).Fused = nDigits
	significand *= _SafeLdExp(tls, float64(1), i)
	for {
		nDigits--
		v1 = nDigits
		if !(v1 >= 0) {
			break
		}
		*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 8))).Fdp + uintptr(nDigits)*4)) = uint32(significand)
		significand -= float64(uint32(significand))
		significand = _SafeLdExp(tls, significand, int32(MP_DIGIT_BIT))
	}
	i = 0
	for {
		if !(i <= int32(8)) {
			break
		}
		if M5&(int32(1)<<i) != 0 && XTclBN_mp_mul(tls, bp+8, uintptr(unsafe.Pointer(&_pow5))+uintptr(i)*24, bp+8) != MP_OKAY {
			XTclBN_mp_clear(tls, bp+8)
			return approxResult
		}
		goto _2
	_2:
		;
		i++
	}
	/*
	 * Compute twoMd as 2*M*d, where d is the exact value.
	 * This is done by multiplying by 5**(M5+exponent) and then multiplying
	 * by 2**(M5+exponent+1), which is, of course, a left shift.
	 */
	if XTclBN_mp_init_copy(tls, bp+32, exactSignificand) != MP_OKAY {
		XTclBN_mp_clear(tls, bp+8)
		return approxResult
	}
	i = 0
	for {
		if !(i <= int32(8)) {
			break
		}
		if (M5+exponent)&(int32(1)<<i) != 0 {
			err = XTclBN_mp_mul(tls, bp+32, uintptr(unsafe.Pointer(&_pow5))+uintptr(i)*24, bp+32)
		}
		goto _3
	_3:
		;
		i++
	}
	if err == MP_OKAY {
		err = XTclBN_mp_mul_2d(tls, bp+32, M2+exponent+int32(1), bp+32)
	}
	/*
	 * Now let twoMd = twoMd - twoMv, the difference between the exact and
	 * approximate values.
	 */
	if err == MP_OKAY {
		err = XTclBN_mp_sub(tls, bp+32, bp+8, bp+32)
	}
	/*
	 * The result, 2Mv-2Md, needs to be divided by 2M to yield a correction
	 * term. Because 2M may well overflow a double, we need to scale the
	 * denominator by a factor of 2**binExponent-mantBits. Place that factor
	 * times 1/2 ULP into twoMd.
	 */
	scale = *(*int32)(unsafe.Pointer(bp)) - _mantBits - int32(1)
	XTclBN_mp_set_u64(tls, bp+8, uint64(1))
	i = 0
	for {
		if !(i <= int32(8) && err == MP_OKAY) {
			break
		}
		if M5&(int32(1)<<i) != 0 {
			err = XTclBN_mp_mul(tls, bp+8, uintptr(unsafe.Pointer(&_pow5))+uintptr(i)*24, bp+8)
		}
		goto _4
	_4:
		;
		i++
	}
	multiplier = M2 + scale + int32(1)
	if err != MP_OKAY {
		XTclBN_mp_clear(tls, bp+32)
		XTclBN_mp_clear(tls, bp+8)
		return approxResult
	} else {
		if multiplier > 0 {
			err = XTclBN_mp_mul_2d(tls, bp+8, multiplier, bp+8)
		} else {
			if multiplier < 0 {
				err = XTclBN_mp_div_2d(tls, bp+8, -multiplier, bp+8, libc.UintptrFromInt32(0))
			}
		}
	}
	if err != MP_OKAY {
		XTclBN_mp_clear(tls, bp+32)
		XTclBN_mp_clear(tls, bp+8)
		return approxResult
	}
	/*
	 * Will the eventual correction term be less than, equal to, or
	 * greater than 1/2 ULP?
	 */
	switch XTclBN_mp_cmp_mag(tls, bp+32, bp+8) {
	case -int32(1):
		/*
		 * If the error is less than 1/2 ULP, there's no correction to make.
		 */
		XTclBN_mp_clear(tls, bp+32)
		XTclBN_mp_clear(tls, bp+8)
		return approxResult
	case MP_EQ:
		/*
		 * If the error is exactly 1/2 ULP, we need to round to even.
		 */
		roundToEven = int32(1)
	case int32(MP_GT):
		/*
		 * We need to correct the result if the error exceeds 1/2 ULP.
		 */
		break
	}
	/*
	 * If we're in the 'round to even' case, and the significand is already
	 * even, we're done. Return the approximate result.
	 */
	if roundToEven != 0 {
		rteSignificand = libc.Xfrexp(tls, approxResult, bp+56)
		rteSigWide = int64(libc.Xldexp(tls, rteSignificand, int32(FP_PRECISION)))
		if rteSigWide&int64(1) == 0 {
			XTclBN_mp_clear(tls, bp+32)
			XTclBN_mp_clear(tls, bp+8)
			return approxResult
		}
	}
	/*
	 * Reduce the numerator and denominator of the corrector term so that
	 * they will fit in the floating point precision.
	 */
	shift = XTclBN_mp_count_bits(tls, bp+8) - int32(FP_PRECISION) - int32(1)
	if shift > 0 {
		err = XTclBN_mp_div_2d(tls, bp+8, shift, bp+8, libc.UintptrFromInt32(0))
		if err == MP_OKAY {
			err = XTclBN_mp_div_2d(tls, bp+32, shift, bp+32, libc.UintptrFromInt32(0))
		}
	}
	if err != MP_OKAY {
		XTclBN_mp_clear(tls, bp+32)
		XTclBN_mp_clear(tls, bp+8)
		return approxResult
	}
	/*
	 * Convert the numerator and denominator of the corrector term accurately
	 * to floating point numbers.
	 */
	num = XTclBignumToDouble(tls, bp+32)
	den = XTclBignumToDouble(tls, bp+8)
	quot = _SafeLdExp(tls, num/den, scale)
	minincr = _SafeLdExp(tls, float64(1), *(*int32)(unsafe.Pointer(bp))-_mantBits)
	if quot < float64(0) && quot > -minincr {
		quot = -minincr
	} else {
		if quot > float64(0) && quot < minincr {
			quot = minincr
		}
	}
	XTclBN_mp_clear(tls, bp+32)
	XTclBN_mp_clear(tls, bp+8)
	return approxResult + quot
}

/*
 *----------------------------------------------------------------------
 *
 * MultPow5 --
 *
 *	Multiply a bignum by a power of 5.
 *
 * Side effects:
 *	Stores base*5**n in result.
 *
 *----------------------------------------------------------------------
 */

func _MulPow5(tls *libc.TLS, base uintptr, n uint32, result uintptr) (r1 Tmp_err) {
	/* Place to store the result. */
	var err Tmp_err
	var n13, r int32
	var p uintptr
	_, _, _, _ = err, n13, p, r
	p = base
	n13 = libc.Int32FromUint32(n / uint32(13))
	r = libc.Int32FromUint32(n % uint32(13))
	err = MP_OKAY
	if r != 0 {
		err = XTclBN_mp_mul_d(tls, p, _dpow5[r], result)
		p = result
	}
	r = 0
	for err == MP_OKAY && n13 != 0 {
		if n13&int32(1) != 0 {
			err = XTclBN_mp_mul(tls, p, uintptr(unsafe.Pointer(&_pow5_13))+uintptr(r)*24, result)
			p = result
		}
		n13 >>= int32(1)
		r++
	}
	if err == MP_OKAY && p != result {
		err = XTclBN_mp_copy(tls, p, result)
	}
	return err
}

/*
 *----------------------------------------------------------------------
 *
 * NormalizeRightward --
 *
 *	Shifts a number rightward until it is odd (that is, until the least
 *	significant bit is nonzero.
 *
 * Results:
 *	Returns the number of bit positions by which the number was shifted.
 *
 * Side effects:
 *	Shifts the number in place; *wPtr is replaced by the shifted number.
 *
 *----------------------------------------------------------------------
 */

func _NormalizeRightward(tls *libc.TLS, wPtr uintptr) (r int32) {
	/* INOUT: Number to shift. */
	var rv int32
	var w TTcl_WideUInt
	_, _ = rv, w
	rv = 0
	w = *(*TTcl_WideUInt)(unsafe.Pointer(wPtr))
	if !(w&libc.Uint64FromUint32(0xFFFFFFFF) != 0) {
		w >>= uint64(32)
		rv += int32(32)
	}
	if !(w&libc.Uint64FromInt32(0xFFFF) != 0) {
		w >>= uint64(16)
		rv += int32(16)
	}
	if !(w&libc.Uint64FromInt32(0xFF) != 0) {
		w >>= uint64(8)
		rv += int32(8)
	}
	if !(w&libc.Uint64FromInt32(0xF) != 0) {
		w >>= uint64(4)
		rv += int32(4)
	}
	if !(w&libc.Uint64FromInt32(0x3) != 0) {
		w >>= uint64(2)
		rv += int32(2)
	}
	if !(w&libc.Uint64FromInt32(0x1) != 0) {
		w >>= uint64(1)
		rv++
	}
	*(*TTcl_WideUInt)(unsafe.Pointer(wPtr)) = w
	return rv
}

/*
 *----------------------------------------------------------------------
 *
 * RequiredPrecision --
 *
 *	Determines the number of bits needed to hold an integer.
 *
 * Results:
 *	Returns the position of the most significant bit (0 - 63).  Returns 0
 *	if the number is zero.
 *
 *----------------------------------------------------------------------
 */

func _RequiredPrecision(tls *libc.TLS, w TTcl_WideUInt) (r int32) {
	/* Number to interrogate. */
	var rv int32
	var wi uint64
	_, _ = rv, wi
	if w&(libc.Uint64FromUint32(0xFFFFFFFF)<<libc.Int32FromInt32(32)) != 0 {
		wi = uint64(w >> libc.Int32FromInt32(32))
		rv = int32(32)
	} else {
		wi = w
		rv = 0
	}
	if wi&uint64(0xFFFF0000) != 0 {
		wi >>= uint64(16)
		rv += int32(16)
	}
	if wi&uint64(0xFF00) != 0 {
		wi >>= uint64(8)
		rv += int32(8)
	}
	if wi&uint64(0xF0) != 0 {
		wi >>= uint64(4)
		rv += int32(4)
	}
	if wi&uint64(0xC) != 0 {
		wi >>= uint64(2)
		rv += int32(2)
	}
	if wi&uint64(0x2) != 0 {
		wi >>= uint64(1)
		rv++
	}
	if wi&uint64(0x1) != 0 {
		rv++
	}
	return rv
}

/*
 *----------------------------------------------------------------------
 *
 * DoubleToExpAndSig --
 *
 *	Separates a 'double' into exponent and significand.
 *
 * Side effects:
 *	Stores the significand in '*significand' and the exponent in '*expon'
 *	so that dv == significand * 2.0**expon, and significand is odd.  Also
 *	stores the position of the leftmost 1-bit in 'significand' in 'bits'.
 *
 *----------------------------------------------------------------------
 */

func _DoubleToExpAndSig(tls *libc.TLS, dv float64, significand uintptr, expon uintptr, bits uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* OUTPUT: Number of significant bits. */
	var de, k int32
	var _ /* d at bp+0 */ TDouble
	var _ /* z at bp+8 */ TTcl_WideUInt
	_, _ = de, k /* Bit count. */
	*(*float64)(unsafe.Pointer(bp)) = dv
	/*
	 * Extract exponent and significand.
	 */
	de = (*(*struct {
		Fword0 int32
		Fword1 int32
	})(unsafe.Pointer(bp))).Fword0 & int32(EXP_MASK) >> int32(EXP_SHIFT)
	*(*TTcl_WideUInt)(unsafe.Pointer(bp + 8)) = *(*TTcl_WideUInt)(unsafe.Pointer(bp)) & (libc.Uint64FromInt32(HI_ORDER_SIG_MASK)<<libc.Int32FromInt32(32) | libc.Uint64FromUint32(0xFFFFFFFF))
	if de != 0 {
		*(*TTcl_WideUInt)(unsafe.Pointer(bp + 8)) |= libc.Uint64FromInt32(0x00100000) << libc.Int32FromInt32(32)
		k = _NormalizeRightward(tls, bp+8)
		*(*int32)(unsafe.Pointer(bits)) = int32(FP_PRECISION) - k
		*(*int32)(unsafe.Pointer(expon)) = k + (de - int32(EXPONENT_BIAS)) - (libc.Int32FromInt32(FP_PRECISION) - libc.Int32FromInt32(1))
	} else {
		k = _NormalizeRightward(tls, bp+8)
		*(*int32)(unsafe.Pointer(expon)) = k + (de - int32(EXPONENT_BIAS)) - (libc.Int32FromInt32(FP_PRECISION) - libc.Int32FromInt32(1)) + int32(1)
		*(*int32)(unsafe.Pointer(bits)) = _RequiredPrecision(tls, *(*TTcl_WideUInt)(unsafe.Pointer(bp + 8)))
	}
	*(*TTcl_WideUInt)(unsafe.Pointer(significand)) = *(*TTcl_WideUInt)(unsafe.Pointer(bp + 8))
}

/*
 *----------------------------------------------------------------------
 *
 * TakeAbsoluteValue --
 *
 *	Takes the absolute value of a 'double' including 0, Inf and NaN
 *
 * Side effects:
 *	The 'double' in *d is replaced with its absolute value. The signum is
 *	stored in 'sign': 1 for negative, 0 for nonnegative.
 *
 *----------------------------------------------------------------------
 */

func _TakeAbsoluteValue(tls *libc.TLS, d uintptr, sign uintptr) {
	/* Place to put the signum. */
	var p1 uintptr
	_ = p1
	if libc.Uint32FromInt32((*TDouble)(unsafe.Pointer(d)).Fw.Fword0)&uint32(SIGN_BIT) != 0 {
		*(*int32)(unsafe.Pointer(sign)) = int32(1)
		p1 = d
		*(*int32)(unsafe.Pointer(p1)) = int32(uint32(*(*int32)(unsafe.Pointer(p1))) & ^libc.Uint32FromUint32(SIGN_BIT))
	} else {
		*(*int32)(unsafe.Pointer(sign)) = 0
	}
}

/*
 *----------------------------------------------------------------------
 *
 * FormatInfAndNaN --
 *
 *	Bailout for formatting infinities and Not-A-Number.
 *
 * Results:
 *	Returns one of the strings 'Infinity' and 'NaN'.  The string returned
 *	must be freed by the caller using 'Tcl_Free'.
 *
 * Side effects:
 *	Stores 9999 in *decpt, and sets '*endPtr' to designate the terminating
 *	NUL byte of the string if 'endPtr' is not NULL.
 *
 *----------------------------------------------------------------------
 */

func _FormatInfAndNaN(tls *libc.TLS, d uintptr, decpt uintptr, endPtr uintptr) (r uintptr) {
	/* Pointer to the end of the formatted data */
	var retval uintptr
	_ = retval
	*(*int32)(unsafe.Pointer(decpt)) = int32(9999)
	if !((*TDouble)(unsafe.Pointer(d)).Fw.Fword1 != 0) && !((*TDouble)(unsafe.Pointer(d)).Fw.Fword0&libc.Int32FromInt32(HI_ORDER_SIG_MASK) != 0) {
		retval = XTcl_Alloc(tls, uint64(9))
		libc.Xstrcpy(tls, retval, __ccgo_ts+67011)
		if endPtr != 0 {
			*(*uintptr)(unsafe.Pointer(endPtr)) = retval + uintptr(8)
		}
	} else {
		retval = XTcl_Alloc(tls, uint64(4))
		libc.Xstrcpy(tls, retval, __ccgo_ts+67020)
		if endPtr != 0 {
			*(*uintptr)(unsafe.Pointer(endPtr)) = retval + uintptr(3)
		}
	}
	return retval
}

/*
 *----------------------------------------------------------------------
 *
 * FormatZero --
 *
 *	Bailout to format a zero floating-point number.
 *
 * Results:
 *	Returns the constant string "0"
 *
 * Side effects:
 *	Stores 1 in '*decpt' and puts a pointer to the NUL byte terminating
 *	the string in '*endPtr' if 'endPtr' is not NULL.
 *
 *----------------------------------------------------------------------
 */

func _FormatZero(tls *libc.TLS, decpt uintptr, endPtr uintptr) (r uintptr) {
	/* Pointer to the end of the formatted data */
	var retval uintptr
	_ = retval
	retval = XTcl_Alloc(tls, uint64(2))
	libc.Xstrcpy(tls, retval, __ccgo_ts+14828)
	if endPtr != 0 {
		*(*uintptr)(unsafe.Pointer(endPtr)) = retval + uintptr(1)
	}
	*(*int32)(unsafe.Pointer(decpt)) = 0
	return retval
}

/*
 *----------------------------------------------------------------------
 *
 * ApproximateLog10 --
 *
 *	Computes a two-term Taylor series approximation to the common log of a
 *	number, and computes the number's binary log.
 *
 * Results:
 *	Return an approximation to floor(log10(bw*2**be)) that is either exact
 *	or 1 too high.
 *
 *----------------------------------------------------------------------
 */

func _ApproximateLog10(tls *libc.TLS, bw TTcl_WideUInt, be int32, bbits int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Number of bits of precision in bw. */
	var ds float64
	var i, k int32
	var _ /* d2 at bp+0 */ TDouble
	_, _, _ = ds, i, k
	/*
	 * Compute i and d2 such that d = d2*2**i, and 1 < d2 < 2.
	 * Compute an approximation to log10(d),
	 *   log10(d) ~ log10(2) * i + log10(1.5)
	 *            + (significand-1.5)/(1.5 * log(10))
	 */
	*(*TTcl_WideUInt)(unsafe.Pointer(bp)) = bw << (int32(FP_PRECISION) - bbits) & (libc.Uint64FromInt32(HI_ORDER_SIG_MASK)<<libc.Int32FromInt32(32) | libc.Uint64FromUint32(0xFFFFFFFF))
	(*(*struct {
		Fword0 int32
		Fword1 int32
	})(unsafe.Pointer(bp))).Fword0 |= libc.Int32FromInt32(EXPONENT_BIAS) << libc.Int32FromInt32(EXP_SHIFT)
	i = be + bbits - int32(1)
	ds = float64((*(*float64)(unsafe.Pointer(bp))-float64(1.5))*float64(TWO_OVER_3LOG10)) + float64(LOG10_3HALVES_PLUS_FUDGE) + float64(float64(LOG10_2)*float64(i))
	k = int32(ds)
	if float64(k) > ds {
		k--
	}
	return k
}

/*
 *----------------------------------------------------------------------
 *
 * BetterLog10 --
 *
 *	Improves the result of ApproximateLog10 for numbers in the range
 *	1 .. 10**(TEN_PMAX)-1
 *
 * Side effects:
 *	Sets k_check to 0 if the new result is known to be exact, and to 1 if
 *	it may still be one too high.
 *
 * Results:
 *	Returns the improved approximation to log10(d).
 *
 *----------------------------------------------------------------------
 */

func _BetterLog10(tls *libc.TLS, d float64, k int32, k_check uintptr) (r int32) {
	/* Flag == 1 if k is inexact. */
	/*
	 * Performance hack. If k is in the range 0..TEN_PMAX, then we can use a
	 * powers-of-ten table to check it.
	 */
	if k >= 0 && k <= int32(TEN_PMAX) {
		if d < _tens[k] {
			k--
		}
		*(*int32)(unsafe.Pointer(k_check)) = 0
	} else {
		*(*int32)(unsafe.Pointer(k_check)) = int32(1)
	}
	return k
}

/*
 *----------------------------------------------------------------------
 *
 * ComputeScale --
 *
 *	Prepares to format a floating-point number as decimal.
 *
 * Parameters:
 *	floor(log10*x) is k (or possibly k-1).  floor(log2(x) is i.  The
 *	significand of x requires bbits bits to represent.
 *
 * Results:
 *	Determines integers b2, b5, s2, s5 so that sig*2**b2*5**b5/2**s2*2**s5
 *	exactly represents the value of the x/10**k. This value will lie in
 *	the range [1 .. 10), and allows for computing successive digits by
 *	multiplying sig%10 by 10.
 *
 *----------------------------------------------------------------------
 */

func _ComputeScale(tls *libc.TLS, be int32, k int32, b2 uintptr, b5 uintptr, s2 uintptr, s5 uintptr) {
	/* OUTPUT: Power of 5 in the denominator. */
	/*
	 * Scale numerator and denominator powers of 2 so that the input binary
	 * number is the ratio of integers.
	 */
	if be <= 0 {
		*(*int32)(unsafe.Pointer(b2)) = 0
		*(*int32)(unsafe.Pointer(s2)) = -be
	} else {
		*(*int32)(unsafe.Pointer(b2)) = be
		*(*int32)(unsafe.Pointer(s2)) = 0
	}
	/*
	 * Scale numerator and denominator so that the output decimal number is
	 * the ratio of integers.
	 */
	if k >= 0 {
		*(*int32)(unsafe.Pointer(b5)) = 0
		*(*int32)(unsafe.Pointer(s5)) = k
		*(*int32)(unsafe.Pointer(s2)) += k
	} else {
		*(*int32)(unsafe.Pointer(b2)) -= k
		*(*int32)(unsafe.Pointer(b5)) = -k
		*(*int32)(unsafe.Pointer(s5)) = 0
	}
}

/*
 *----------------------------------------------------------------------
 *
 * SetPrecisionLimits --
 *
 *	Determines how many digits of significance should be computed (and,
 *	hence, how much memory need be allocated) for formatting a floating
 *	point number.
 *
 * Given that 'k' is floor(log10(x)):
 * if 'shortest' format is used, there will be at most 18 digits in the
 * result.
 * if 'F' format is used, there will be at most 'ndigits' + k + 1 digits
 * if 'E' format is used, there will be exactly 'ndigits' digits.
 *
 * Side effects:
 *	Adjusts '*ndigitsPtr' to have a valid value. Stores the maximum memory
 *	allocation needed in *iPtr.  Sets '*iLimPtr' to the limiting number of
 *	digits to convert if k has been guessed correctly, and '*iLim1Ptr' to
 *	the limiting number of digits to convert if k has been guessed to be
 *	one too high.
 *
 *----------------------------------------------------------------------
 */

func _SetPrecisionLimits(tls *libc.TLS, flags int32, k int32, ndigitsPtr uintptr, iPtr uintptr, iLimPtr uintptr, iLim1Ptr uintptr) {
	/* OUT: Number of digits of significance if
	 *      the quick method is used. */
	var v1, v2, v3 int32
	_, _, _ = v1, v2, v3
	switch flags & libc.Int32FromInt32(TCL_DD_CONVERSION_TYPE_MASK) {
	case int32(TCL_DD_E_FORMAT):
		if *(*int32)(unsafe.Pointer(ndigitsPtr)) <= 0 {
			*(*int32)(unsafe.Pointer(ndigitsPtr)) = int32(1)
		}
		v2 = *(*int32)(unsafe.Pointer(ndigitsPtr))
		*(*int32)(unsafe.Pointer(iPtr)) = v2
		v1 = v2
		*(*int32)(unsafe.Pointer(iLim1Ptr)) = v1
		*(*int32)(unsafe.Pointer(iLimPtr)) = v1
	case int32(TCL_DD_F_FORMAT):
		*(*int32)(unsafe.Pointer(iPtr)) = *(*int32)(unsafe.Pointer(ndigitsPtr)) + k + int32(1)
		*(*int32)(unsafe.Pointer(iLimPtr)) = *(*int32)(unsafe.Pointer(iPtr))
		*(*int32)(unsafe.Pointer(iLim1Ptr)) = *(*int32)(unsafe.Pointer(iPtr)) - int32(1)
		if *(*int32)(unsafe.Pointer(iPtr)) <= 0 {
			*(*int32)(unsafe.Pointer(iPtr)) = int32(1)
		}
	default:
		v3 = -libc.Int32FromInt32(1)
		*(*int32)(unsafe.Pointer(iLim1Ptr)) = v3
		*(*int32)(unsafe.Pointer(iLimPtr)) = v3
		*(*int32)(unsafe.Pointer(iPtr)) = int32(18)
		*(*int32)(unsafe.Pointer(ndigitsPtr)) = 0
		break
	}
}

/*
 *----------------------------------------------------------------------
 *
 * BumpUp --
 *
 *	Increases a string of digits ending in a series of nines to designate
 *	the next higher number.  xxxxb9999... -> xxxx(b+1)0000...
 *
 * Results:
 *	Returns a pointer to the end of the adjusted string.
 *
 * Side effects:
 *	In the case that the string consists solely of '999999', sets it to
 *	"1" and moves the decimal point (*kPtr) one place to the right.
 *
 *----------------------------------------------------------------------
 */

func _BumpUp(tls *libc.TLS, s uintptr, retval uintptr, kPtr uintptr) (r uintptr) {
	/* Position of the decimal point. */
	var v1 uintptr
	_ = v1
	for {
		s--
		v1 = s
		if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) == int32('9')) {
			break
		}
		if s == retval {
			*(*int32)(unsafe.Pointer(kPtr))++
			*(*uint8)(unsafe.Pointer(s)) = uint8('1')
			return s + uintptr(1)
		}
	}
	*(*uint8)(unsafe.Pointer(s))++
	s++
	return s
}

/*
 *----------------------------------------------------------------------
 *
 * AdjustRange --
 *
 *	Rescales a 'double' in preparation for formatting it using the 'quick'
 *	double-to-string method.
 *
 * Results:
 *	Returns the precision that has been lost in the prescaling as a count
 *	of units in the least significant place.
 *
 *----------------------------------------------------------------------
 */

func _AdjustRange(tls *libc.TLS, dPtr uintptr, k int32) (r int32) {
	/* IN: floor(log10(d)) */
	var d, ds float64
	var i, ieps, j, j1, v2 int32
	_, _, _, _, _, _, _ = d, ds, i, ieps, j, j1, v2 /* Number of roundoff errors that have
	 * accumulated. */
	d = *(*float64)(unsafe.Pointer(dPtr))
	ieps = int32(2)
	if k > 0 {
		/*
		 * The number must be reduced to bring it into range.
		 */
		ds = _tens[k&int32(0xF)]
		j = k >> int32(4)
		if j&int32(BLETCH) != 0 {
			j &= libc.Int32FromInt32(BLETCH) - libc.Int32FromInt32(1)
			d /= _bigtens[libc.Int32FromInt32(N_BIGTENS)-libc.Int32FromInt32(1)]
			ieps++
		}
		i = 0
		for {
			if !(j != 0) {
				break
			}
			if j&int32(1) != 0 {
				ds *= _bigtens[i]
				ieps++
			}
			i++
			goto _1
		_1:
			;
			j >>= int32(1)
		}
		d /= ds
	} else {
		v2 = -k
		j1 = v2
		if v2 != 0 {
			/*
			 * The number must be increased to bring it into range.
			 */
			d *= _tens[j1&int32(0xF)]
			i = 0
			j = j1 >> int32(4)
			for {
				if !(j != 0) {
					break
				}
				if j&int32(1) != 0 {
					ieps++
					d *= _bigtens[i]
				}
				i++
				goto _3
			_3:
				;
				j >>= int32(1)
			}
		}
	}
	*(*float64)(unsafe.Pointer(dPtr)) = d
	return ieps
}

/*
 *----------------------------------------------------------------------
 *
 * ShorteningQuickFormat --
 *
 *	Returns a 'quick' format of a double precision number to a string of
 *	digits, preferring a shorter string of digits if the shorter string is
 *	still within 1/2 ulp of the number.
 *
 * Results:
 *	Returns the string of digits. Returns NULL if the 'quick' method fails
 *	and the bignum method must be used.
 *
 * Side effects:
 *	Stores the position of the decimal point at '*kPtr'.
 *
 *----------------------------------------------------------------------
 */

func _ShorteningQuickFormat(tls *libc.TLS, d float64, k int32, ilim int32, eps float64, retval uintptr, kPtr uintptr) (r uintptr) {
	/* Pointer to stash the position of the
	 * decimal point. */
	var digit, i, v3 int32
	var s, v2 uintptr
	_, _, _, _, _ = digit, i, s, v2, v3
	s = retval
	eps = float64(0.5)/_tens[ilim-int32(1)] - eps
	i = 0
	for {
		/*
		 * Convert a digit.
		 */
		digit = int32(d)
		d -= float64(digit)
		v2 = s
		s++
		*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32('0') + digit)
		/*
		 * Truncate the conversion if the string of digits is within 1/2 ulp
		 * of the actual value.
		 */
		if d < eps {
			*(*int32)(unsafe.Pointer(kPtr)) = k
			return s
		}
		if float64(1)-d < eps {
			*(*int32)(unsafe.Pointer(kPtr)) = k
			return _BumpUp(tls, s, retval, kPtr)
		}
		/*
		 * Bail out if the conversion fails to converge to a sufficiently
		 * precise value.
		 */
		i++
		v3 = i
		if v3 >= ilim {
			return libc.UintptrFromInt32(0)
		}
		/*
		 * Bring the next digit to the integer part.
		 */
		eps *= libc.Float64FromInt32(10)
		d *= float64(10)
		goto _1
	_1:
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * StrictQuickFormat --
 *
 *	Convert a double precision number of a string of a precise number of
 *	digits, using the 'quick' double precision method.
 *
 * Results:
 *	Returns the digit string, or NULL if the bignum method must be used to
 *	do the formatting.
 *
 * Side effects:
 *	Stores the position of the decimal point in '*kPtr'.
 *
 *----------------------------------------------------------------------
 */

func _StrictQuickFormat(tls *libc.TLS, d float64, k int32, ilim int32, eps float64, retval uintptr, kPtr uintptr) (r uintptr) {
	/* Pointer to stash the position of the
	 * decimal point. */
	var digit, i int32
	var s, v2, v3 uintptr
	_, _, _, _, _ = digit, i, s, v2, v3
	s = retval
	eps *= _tens[ilim-int32(1)]
	i = int32(1)
	for {
		/*
		 * Extract a digit.
		 */
		digit = int32(d)
		d -= float64(digit)
		if d == float64(0) {
			ilim = i
		}
		v2 = s
		s++
		*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32('0') + digit)
		/*
		 * When the given digit count is reached, handle trailing strings of 0
		 * and 9.
		 */
		if i == ilim {
			if d > float64(0.5)+eps {
				*(*int32)(unsafe.Pointer(kPtr)) = k
				return _BumpUp(tls, s, retval, kPtr)
			} else {
				if d < float64(0.5)-eps {
					for {
						s--
						v3 = s
						if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) == int32('0')) {
							break
						}
						/* do nothing */
					}
					s++
					*(*int32)(unsafe.Pointer(kPtr)) = k
					return s
				} else {
					return libc.UintptrFromInt32(0)
				}
			}
		}
		/*
		 * Advance to the next digit.
		 */
		i++
		d *= float64(10)
		goto _1
	_1:
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * QuickConversion --
 *
 *	Converts a floating point number the 'quick' way, when only a limited
 *	number of digits is required and floating point arithmetic can
 *	therefore be used for the intermediate results.
 *
 * Results:
 *	Returns the converted string, or NULL if the bignum method must be
 *	used.
 *
 *----------------------------------------------------------------------
 */

func _QuickConversion(tls *libc.TLS, _e float64, k int32, k_check int32, flags int32, len1 int32, ilim int32, ilim1 int32, decpt uintptr, endPtr uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	*(*float64)(unsafe.Pointer(bp)) = _e /* OUTPUT: Pointer to the terminal null
	 * byte. */
	var d float64
	var end, retval uintptr
	var ieps int32
	var _ /* eps at bp+8 */ TDouble
	_, _, _, _ = d, end, ieps, retval /* Workaround for a bug in mingw gcc 3.4.5 */
	/*
	 * Bring d into the range [1 .. 10).
	 */
	ieps = _AdjustRange(tls, bp, k)
	d = *(*float64)(unsafe.Pointer(bp))
	/*
	 * If the guessed value of k didn't get d into range, adjust it by one. If
	 * that leaves us outside the range in which quick format is accurate,
	 * bail out.
	 */
	if k_check != 0 && d < float64(1) && ilim > 0 {
		if ilim1 < 0 {
			return libc.UintptrFromInt32(0)
		}
		ilim = ilim1
		k--
		d = float64(d * float64(10))
		ieps++
	}
	/*
	 * Compute estimated roundoff error.
	 */
	*(*float64)(unsafe.Pointer(bp + 8)) = float64(float64(ieps)*d) + float64(7)
	(*(*struct {
		Fword0 int32
		Fword1 int32
	})(unsafe.Pointer(bp + 8))).Fword0 -= (libc.Int32FromInt32(FP_PRECISION) - libc.Int32FromInt32(1)) << libc.Int32FromInt32(EXP_SHIFT)
	/*
	 * Handle the peculiar case where the result has no significant digits.
	 */
	retval = XTcl_Alloc(tls, libc.Uint64FromInt32(len1+int32(1)))
	if ilim == 0 {
		d = d - float64(5)
		if d > *(*float64)(unsafe.Pointer(bp + 8)) {
			*(*uint8)(unsafe.Pointer(retval)) = uint8('1')
			*(*int32)(unsafe.Pointer(decpt)) = k
			return retval
		} else {
			if d < -*(*float64)(unsafe.Pointer(bp + 8)) {
				*(*int32)(unsafe.Pointer(decpt)) = k
				return retval
			} else {
				XTclpFree(tls, retval)
				return libc.UintptrFromInt32(0)
			}
		}
	}
	/*
	 * Format the digit string.
	 */
	if flags&int32(TCL_DD_SHORTEST) != 0 {
		end = _ShorteningQuickFormat(tls, d, k, ilim, *(*float64)(unsafe.Pointer(bp + 8)), retval, decpt)
	} else {
		end = _StrictQuickFormat(tls, d, k, ilim, *(*float64)(unsafe.Pointer(bp + 8)), retval, decpt)
	}
	if end == libc.UintptrFromInt32(0) {
		XTclpFree(tls, retval)
		return libc.UintptrFromInt32(0)
	}
	*(*uint8)(unsafe.Pointer(end)) = uint8('\000')
	if endPtr != libc.UintptrFromInt32(0) {
		*(*uintptr)(unsafe.Pointer(endPtr)) = end
	}
	return retval
}

/*
 *----------------------------------------------------------------------
 *
 * CastOutPowersOf2 --
 *
 *	Adjust the factors 'b2', 'm2', and 's2' to cast out common powers of 2
 *	from numerator and denominator in preparation for the 'bignum' method
 *	of floating point conversion.
 *
 *----------------------------------------------------------------------
 */

func _CastOutPowersOf2(tls *libc.TLS, b2 uintptr, m2 uintptr, s2 uintptr) {
	/* Power of 2 to multiply the common
	 * denominator. */
	var i int32
	_ = i
	if *(*int32)(unsafe.Pointer(m2)) > 0 && *(*int32)(unsafe.Pointer(s2)) > 0 { /* Find the smallest power of 2 in the
		 * numerator. */
		if *(*int32)(unsafe.Pointer(m2)) < *(*int32)(unsafe.Pointer(s2)) { /* Find the lowest common denominator. */
			i = *(*int32)(unsafe.Pointer(m2))
		} else {
			i = *(*int32)(unsafe.Pointer(s2))
		}
		*(*int32)(unsafe.Pointer(b2)) -= i /* Reduce to lowest terms. */
		*(*int32)(unsafe.Pointer(m2)) -= i
		*(*int32)(unsafe.Pointer(s2)) -= i
	}
}

/*
 *----------------------------------------------------------------------
 *
 * ShorteningInt64Conversion --
 *
 *	Converts a double-precision number to the shortest string of digits
 *	that reconverts exactly to the given number, or to 'ilim' digits if
 *	that will yield a shorter result. The numerator and denominator in
 *	David Gay's conversion algorithm are known to fit in Tcl_WideUInt,
 *	giving considerably faster arithmetic than mp_int's.
 *
 * Results:
 *	Returns the string of significant decimal digits, in newly allocated
 *	memory
 *
 * Side effects:
 *	Stores the location of the decimal point in '*decpt' and the location
 *	of the terminal null byte in '*endPtr'.
 *
 *----------------------------------------------------------------------
 */

func _ShorteningInt64Conversion(tls *libc.TLS, dPtr uintptr, bw TTcl_WideUInt, b2 int32, b5 int32, m2plus int32, m2minus int32, m5 int32, s2 int32, s5 int32, _k int32, len1 int32, ilim int32, ilim1 int32, decpt uintptr, endPtr uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	*(*int32)(unsafe.Pointer(bp)) = _k /* OUTPUT: Position of the terminal '\0' at
	 *	   the end of the returned string. */
	var S, b, mminus, mplus TTcl_WideUInt
	var digit, i int32
	var retval, s, v2, v3, v4, v5, v6 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _ = S, b, digit, i, mminus, mplus, retval, s, v2, v3, v4, v5, v6
	retval = XTcl_Alloc(tls, libc.Uint64FromInt32(len1+int32(1)))
	/* Output buffer. */
	b = bw * _wuipow5[b5] << b2
	/* Numerator of the fraction being
	 * converted. */
	S = _wuipow5[s5] << s2 /* Current output digit. */
	s = retval             /* Current position in the output buffer. */
	/*
	 * Adjust if the logarithm was guessed wrong.
	 */
	if b < S {
		b = uint64(10) * b
		m2plus++
		m2minus++
		m5++
		ilim = ilim1
		*(*int32)(unsafe.Pointer(bp))--
	}
	/*
	 * Compute roundoff ranges.
	 */
	mplus = _wuipow5[m5] << m2plus
	mminus = _wuipow5[m5] << m2minus
	/*
	 * Loop through the digits.
	 */
	i = int32(1)
	for {
		digit = libc.Int32FromUint64(b / S)
		if digit > int32(10) {
			XTcl_Panic(tls, __ccgo_ts+67024, 0)
		}
		b = b % S
		/*
		 * Does the current digit put us on the low side of the exact value
		 * but within roundoff of being exact?
		 */
		if b < mplus || b == mplus && (*TDouble)(unsafe.Pointer(dPtr)).Fw.Fword1&int32(1) == 0 {
			/*
			 * Make sure we shouldn't be rounding *up* instead, in case the
			 * next number above is closer.
			 */
			if uint64(2)*b > S || uint64(2)*b == S && digit&int32(1) != 0 {
				digit++
				if digit == int32(10) {
					v2 = s
					s++
					*(*uint8)(unsafe.Pointer(v2)) = uint8('9')
					s = _BumpUp(tls, s, retval, bp)
					break
				}
			}
			/*
			 * Stash the current digit.
			 */
			v3 = s
			s++
			*(*uint8)(unsafe.Pointer(v3)) = libc.Uint8FromInt32(int32('0') + digit)
			break
		}
		/*
		 * Does one plus the current digit put us within roundoff of the
		 * number?
		 */
		if b > S-mminus || b == S-mminus && (*TDouble)(unsafe.Pointer(dPtr)).Fw.Fword1&int32(1) == 0 {
			if digit == int32(9) {
				v4 = s
				s++
				*(*uint8)(unsafe.Pointer(v4)) = uint8('9')
				s = _BumpUp(tls, s, retval, bp)
				break
			}
			digit++
			v5 = s
			s++
			*(*uint8)(unsafe.Pointer(v5)) = libc.Uint8FromInt32(int32('0') + digit)
			break
		}
		/*
		 * Have we converted all the requested digits?
		 */
		v6 = s
		s++
		*(*uint8)(unsafe.Pointer(v6)) = libc.Uint8FromInt32(int32('0') + digit)
		if i == ilim {
			if uint64(2)*b > S || uint64(2)*b == S && digit&int32(1) != 0 {
				s = _BumpUp(tls, s, retval, bp)
			}
			break
		}
		/*
		 * Advance to the next digit.
		 */
		b = uint64(10) * b
		mplus = uint64(10) * mplus
		mminus = uint64(10) * mminus
		i++
		goto _1
	_1:
	}
	/*
	 * Endgame - store the location of the decimal point and the end of the
	 * string.
	 */
	*(*uint8)(unsafe.Pointer(s)) = uint8('\000')
	*(*int32)(unsafe.Pointer(decpt)) = *(*int32)(unsafe.Pointer(bp))
	if endPtr != 0 {
		*(*uintptr)(unsafe.Pointer(endPtr)) = s
	}
	return retval
}

/*
 *----------------------------------------------------------------------
 *
 * StrictInt64Conversion --
 *
 *	Converts a double-precision number to a fixed-length string of 'ilim'
 *	digits that reconverts exactly to the given number.  ('ilim' should be
 *	replaced with 'ilim1' in the case where log10(d) has been
 *	overestimated).  The numerator and denominator in David Gay's
 *	conversion algorithm are known to fit in Tcl_WideUInt, giving
 *	considerably faster arithmetic than mp_int's.
 *
 * Results:
 *	Returns the string of significant decimal digits, in newly allocated
 *	memory
 *
 * Side effects:
 *	Stores the location of the decimal point in '*decpt' and the location
 *	of the terminal null byte in '*endPtr'.
 *
 *----------------------------------------------------------------------
 */

func _StrictInt64Conversion(tls *libc.TLS, bw TTcl_WideUInt, b2 int32, b5 int32, s2 int32, s5 int32, _k int32, len1 int32, ilim int32, ilim1 int32, decpt uintptr, endPtr uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	*(*int32)(unsafe.Pointer(bp)) = _k /* OUTPUT: Position of the terminal '\0' at
	 *	   the end of the returned string. */
	var S, b TTcl_WideUInt
	var digit, i int32
	var retval, s, v2, v3 uintptr
	_, _, _, _, _, _, _, _ = S, b, digit, i, retval, s, v2, v3
	retval = XTcl_Alloc(tls, libc.Uint64FromInt32(len1+int32(1)))
	/* Output buffer. */
	b = bw * _wuipow5[b5] << b2
	/* Numerator of the fraction being
	 * converted. */
	S = _wuipow5[s5] << s2 /* Current output digit. */
	s = retval             /* Current position in the output buffer. */
	/*
	 * Adjust if the logarithm was guessed wrong.
	 */
	if b < S {
		b = uint64(10) * b
		ilim = ilim1
		*(*int32)(unsafe.Pointer(bp))--
	}
	/*
	 * Loop through the digits.
	 */
	i = int32(1)
	for {
		digit = libc.Int32FromUint64(b / S)
		if digit > int32(10) {
			XTcl_Panic(tls, __ccgo_ts+67024, 0)
		}
		b = b % S
		/*
		 * Have we converted all the requested digits?
		 */
		v2 = s
		s++
		*(*uint8)(unsafe.Pointer(v2)) = libc.Uint8FromInt32(int32('0') + digit)
		if i == ilim {
			if uint64(2)*b > S || uint64(2)*b == S && digit&int32(1) != 0 {
				s = _BumpUp(tls, s, retval, bp)
			} else {
				for {
					s--
					v3 = s
					if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) == int32('0')) {
						break
					}
					/* do nothing */
				}
				s++
			}
			break
		}
		/*
		 * Advance to the next digit.
		 */
		b = uint64(10) * b
		i++
		goto _1
	_1:
	}
	/*
	 * Endgame - store the location of the decimal point and the end of the
	 * string.
	 */
	*(*uint8)(unsafe.Pointer(s)) = uint8('\000')
	*(*int32)(unsafe.Pointer(decpt)) = *(*int32)(unsafe.Pointer(bp))
	if endPtr != 0 {
		*(*uintptr)(unsafe.Pointer(endPtr)) = s
	}
	return retval
}

/*
 *----------------------------------------------------------------------
 *
 * ShouldBankerRoundUpPowD --
 *
 *	Test whether bankers' rounding should round a digit up. Assumption is
 *	made that the denominator of the fraction being tested is a power of
 *	2**MP_DIGIT_BIT.
 *
 * Results:
 *	Returns 1 iff the fraction is more than 1/2, or if the fraction is
 *	exactly 1/2 and the digit is odd.
 *
 *----------------------------------------------------------------------
 */

func _ShouldBankerRoundUpPowD(tls *libc.TLS, b uintptr, sd int32, isodd int32) (r int32) {
	/* 1 if the digit is odd, 0 if even. */
	var i int32
	_ = i
	if (*Tmp_int)(unsafe.Pointer(b)).Fused < sd || *(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(b)).Fdp + uintptr(sd-int32(1))*4))&_topbit == uint32(0) {
		return 0
	}
	if *(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(b)).Fdp + uintptr(sd-int32(1))*4)) != _topbit {
		return int32(1)
	}
	i = sd - int32(2)
	for {
		if !(i >= 0) {
			break
		}
		if *(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(b)).Fdp + uintptr(i)*4)) != uint32(0) {
			return int32(1)
		}
		goto _1
	_1:
		;
		i--
	}
	return isodd
}

var _topbit = libc.Uint32FromInt32(1) << (libc.Int32FromInt32(MP_DIGIT_BIT) - libc.Int32FromInt32(1))

/*
 *----------------------------------------------------------------------
 *
 * ShouldBankerRoundUpToNextPowD --
 *
 *	Tests whether bankers' rounding will round down in the "denominator is
 *	a power of 2**MP_DIGIT" case.
 *
 * Results:
 *	Returns 1 if the rounding will be performed - which increases the
 *	digit by one - and 0 otherwise.
 *
 *----------------------------------------------------------------------
 */

func _ShouldBankerRoundUpToNextPowD(tls *libc.TLS, b uintptr, m uintptr, sd int32, isodd int32, temp uintptr) (r int32) {
	/* Work area for the calculation. */
	var i int32
	_ = i
	/*
	 * Compare B and S-m - which is the same as comparing B+m and S - which we
	 * do by computing b+m and doing a bitwhack compare against
	 * 2**(MP_DIGIT_BIT*sd)
	 */
	if XTclBN_mp_add(tls, b, m, temp) != MP_OKAY || (*Tmp_int)(unsafe.Pointer(temp)).Fused <= sd {
		/* Too few digits to be > s */
		return 0
	}
	if (*Tmp_int)(unsafe.Pointer(temp)).Fused > sd+int32(1) || *(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(temp)).Fdp + uintptr(sd)*4)) > uint32(1) {
		/* >= 2s */
		return int32(1)
	}
	i = sd - int32(1)
	for {
		if !(i >= 0) {
			break
		}
		/* Check for ==s */
		if *(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(temp)).Fdp + uintptr(i)*4)) != uint32(0) { /* > s */
			return int32(1)
		}
		goto _1
	_1:
		;
		i--
	}
	return isodd
}

/*
 *----------------------------------------------------------------------
 *
 * ShorteningBignumConversionPowD --
 *
 *	Converts a double-precision number to the shortest string of digits
 *	that reconverts exactly to the given number, or to 'ilim' digits if
 *	that will yield a shorter result. The denominator in David Gay's
 *	conversion algorithm is known to be a power of 2**MP_DIGIT_BIT, and hence
 *	the division in the main loop may be replaced by a digit shift and
 *	mask.
 *
 * Results:
 *	Returns the string of significant decimal digits, in newly allocated
 *	memory
 *
 * Side effects:
 *	Stores the location of the decimal point in '*decpt' and the location
 *	of the terminal null byte in '*endPtr'.
 *
 *----------------------------------------------------------------------
 */

func _ShorteningBignumConversionPowD(tls *libc.TLS, dPtr uintptr, bw TTcl_WideUInt, b2 int32, b5 int32, m2plus int32, m2minus int32, m5 int32, sd int32, _k int32, len1 int32, ilim int32, ilim1 int32, decpt uintptr, endPtr uintptr) (r uintptr) {
	bp := tls.Alloc(144)
	defer tls.Free(144)
	*(*int32)(unsafe.Pointer(bp)) = _k /* OUTPUT: Position of the terminal '\0' at
	 *	   the end of the returned string. */
	var digit Tmp_digit
	var err Tmp_err
	var i, r1 int32
	var retval, s, v2, v3, v4, v5, v6, v7, v8 uintptr
	var _ /* b at bp+8 */ Tmp_int
	var _ /* mminus at bp+56 */ Tmp_int
	var _ /* mplus at bp+32 */ Tmp_int
	var _ /* temp at bp+80 */ Tmp_int
	_, _, _, _, _, _, _, _, _, _, _, _, _ = digit, err, i, r1, retval, s, v2, v3, v4, v5, v6, v7, v8
	retval = XTcl_Alloc(tls, libc.Uint64FromInt32(len1+int32(1))) /* Current output digit. */
	s = retval
	err = MP_OKAY
	/*
	 * b = bw * 2**b2 * 5**b5
	 * mminus = 5**m5
	 */
	if retval == libc.UintptrFromInt32(0) || XTclBN_mp_init_u64(tls, bp+8, bw) != MP_OKAY {
		return libc.UintptrFromInt32(0)
	}
	if XTclBN_mp_init_set(tls, bp+56, uint32(1)) != MP_OKAY {
		XTclBN_mp_clear(tls, bp+8)
		return libc.UintptrFromInt32(0)
	}
	err = _MulPow5(tls, bp+8, libc.Uint32FromInt32(b5), bp+8)
	if err == MP_OKAY {
		err = XTclBN_mp_mul_2d(tls, bp+8, b2, bp+8)
	}
	/*
	 * Adjust if the logarithm was guessed wrong.
	 */
	if err == MP_OKAY && (*(*Tmp_int)(unsafe.Pointer(bp + 8))).Fused <= sd {
		err = XTclBN_mp_mul_d(tls, bp+8, uint32(10), bp+8)
		m2plus++
		m2minus++
		m5++
		ilim = ilim1
		*(*int32)(unsafe.Pointer(bp))--
	}
	/*
	 * mminus = 5**m5 * 2**m2minus
	 * mplus = 5**m5 * 2**m2plus
	 */
	if err == MP_OKAY {
		err = XTclBN_mp_mul_2d(tls, bp+56, m2minus, bp+56)
	}
	if err == MP_OKAY {
		err = _MulPow5(tls, bp+56, libc.Uint32FromInt32(m5), bp+56)
	}
	if err == MP_OKAY && m2plus > m2minus {
		err = XTclBN_mp_init_copy(tls, bp+32, bp+56)
		if err == MP_OKAY {
			err = XTclBN_mp_mul_2d(tls, bp+32, m2plus-m2minus, bp+32)
		}
	}
	if err == MP_OKAY {
		err = XTclBN_mp_init(tls, bp+80)
	}
	/*
	 * Loop through the digits. Do division and mod by s == 2**(sd*MP_DIGIT_BIT)
	 * by mp_digit extraction.
	 */
	i = 0
	for {
		if (*(*Tmp_int)(unsafe.Pointer(bp + 8))).Fused <= sd {
			digit = uint32(0)
		} else {
			digit = *(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 8))).Fdp + uintptr(sd)*4))
			if (*(*Tmp_int)(unsafe.Pointer(bp + 8))).Fused > sd+int32(1) || digit >= uint32(10) {
				XTcl_Panic(tls, __ccgo_ts+67024, 0)
			}
			(*(*Tmp_int)(unsafe.Pointer(bp + 8))).Fused--
			XTclBN_mp_clamp(tls, bp+8)
		}
		/*
		 * Does the current digit put us on the low side of the exact value
		 * but within roundoff of being exact?
		 */
		if m2plus > m2minus {
			v2 = bp + 32
		} else {
			v2 = bp + 56
		}
		r1 = XTclBN_mp_cmp_mag(tls, bp+8, v2)
		if r1 == -int32(1) || r1 == MP_EQ && (*TDouble)(unsafe.Pointer(dPtr)).Fw.Fword1&int32(1) == 0 {
			/*
			 * Make sure we shouldn't be rounding *up* instead, in case the
			 * next number above is closer.
			 */
			if _ShouldBankerRoundUpPowD(tls, bp+8, sd, libc.Int32FromUint32(digit&uint32(1))) != 0 {
				digit++
				if digit == uint32(10) {
					v3 = s
					s++
					*(*uint8)(unsafe.Pointer(v3)) = uint8('9')
					s = _BumpUp(tls, s, retval, bp)
					break
				}
			}
			/*
			 * Stash the last digit.
			 */
			v4 = s
			s++
			*(*uint8)(unsafe.Pointer(v4)) = uint8(uint32('0') + digit)
			break
		}
		/*
		 * Does one plus the current digit put us within roundoff of the
		 * number?
		 */
		if _ShouldBankerRoundUpToNextPowD(tls, bp+8, bp+56, sd, (*TDouble)(unsafe.Pointer(dPtr)).Fw.Fword1&int32(1), bp+80) != 0 {
			if digit == uint32(9) {
				v5 = s
				s++
				*(*uint8)(unsafe.Pointer(v5)) = uint8('9')
				s = _BumpUp(tls, s, retval, bp)
				break
			}
			digit++
			v6 = s
			s++
			*(*uint8)(unsafe.Pointer(v6)) = uint8(uint32('0') + digit)
			break
		}
		/*
		 * Have we converted all the requested digits?
		 */
		v7 = s
		s++
		*(*uint8)(unsafe.Pointer(v7)) = uint8(uint32('0') + digit)
		if i == ilim {
			if _ShouldBankerRoundUpPowD(tls, bp+8, sd, libc.Int32FromUint32(digit&uint32(1))) != 0 {
				s = _BumpUp(tls, s, retval, bp)
			}
			break
		}
		/*
		 * Advance to the next digit.
		 */
		if err == MP_OKAY {
			err = XTclBN_mp_mul_d(tls, bp+8, uint32(10), bp+8)
		}
		if err == MP_OKAY {
			err = XTclBN_mp_mul_d(tls, bp+56, uint32(10), bp+56)
		}
		if err == MP_OKAY && m2plus > m2minus {
			err = XTclBN_mp_mul_2d(tls, bp+56, m2plus-m2minus, bp+32)
		}
		i++
		goto _1
	_1:
	}
	/*
	 * Endgame - store the location of the decimal point and the end of the
	 * string.
	 */
	if m2plus > m2minus {
		XTclBN_mp_clear(tls, bp+32)
	}
	XTclBN_mp_clear_multi(tls, bp+8, libc.VaList(bp+112, bp+56, bp+80, libc.UintptrFromInt32(0)))
	*(*uint8)(unsafe.Pointer(s)) = uint8('\000')
	*(*int32)(unsafe.Pointer(decpt)) = *(*int32)(unsafe.Pointer(bp))
	if endPtr != 0 {
		*(*uintptr)(unsafe.Pointer(endPtr)) = s
	}
	if err == MP_OKAY {
		v8 = retval
	} else {
		v8 = libc.UintptrFromInt32(0)
	}
	return v8
}

/*
 *----------------------------------------------------------------------
 *
 * StrictBignumConversionPowD --
 *
 *	Converts a double-precision number to a fixed-lengt string of 'ilim'
 *	digits (or 'ilim1' if log10(d) has been overestimated).  The
 *	denominator in David Gay's conversion algorithm is known to be a power
 *	of 2**MP_DIGIT_BIT, and hence the division in the main loop may be
 *	replaced by a digit shift and mask.
 *
 * Results:
 *	Returns the string of significant decimal digits, in newly allocated
 *	memory.
 *
 * Side effects:
 *	Stores the location of the decimal point in '*decpt' and the location
 *	of the terminal null byte in '*endPtr'.
 *
 *----------------------------------------------------------------------
 */

func _StrictBignumConversionPowD(tls *libc.TLS, bw TTcl_WideUInt, b2 int32, b5 int32, sd int32, _k int32, len1 int32, ilim int32, ilim1 int32, decpt uintptr, endPtr uintptr) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	*(*int32)(unsafe.Pointer(bp)) = _k /* OUTPUT: Position of the terminal '\0' at
	 *	   the end of the returned string. */
	var digit Tmp_digit
	var err Tmp_err
	var i int32
	var retval, s, v1, v2 uintptr
	var _ /* b at bp+8 */ Tmp_int
	_, _, _, _, _, _, _ = digit, err, i, retval, s, v1, v2
	retval = XTcl_Alloc(tls, libc.Uint64FromInt32(len1+int32(1))) /* Current output digit. */
	s = retval
	/*
	 * b = bw * 2**b2 * 5**b5
	 */
	if XTclBN_mp_init_u64(tls, bp+8, bw) != MP_OKAY {
		return libc.UintptrFromInt32(0)
	}
	err = _MulPow5(tls, bp+8, libc.Uint32FromInt32(b5), bp+8)
	if err == MP_OKAY {
		err = XTclBN_mp_mul_2d(tls, bp+8, b2, bp+8)
	}
	/*
	 * Adjust if the logarithm was guessed wrong.
	 */
	if err == MP_OKAY && (*(*Tmp_int)(unsafe.Pointer(bp + 8))).Fused <= sd {
		err = XTclBN_mp_mul_d(tls, bp+8, uint32(10), bp+8)
		ilim = ilim1
		*(*int32)(unsafe.Pointer(bp))--
	}
	/*
	 * Loop through the digits. Do division and mod by s == 2**(sd*MP_DIGIT_BIT)
	 * by mp_digit extraction.
	 */
	i = int32(1)
	for err == MP_OKAY {
		if (*(*Tmp_int)(unsafe.Pointer(bp + 8))).Fused <= sd {
			digit = uint32(0)
		} else {
			digit = *(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 8))).Fdp + uintptr(sd)*4))
			if (*(*Tmp_int)(unsafe.Pointer(bp + 8))).Fused > sd+int32(1) || digit >= uint32(10) {
				XTcl_Panic(tls, __ccgo_ts+67024, 0)
			}
			(*(*Tmp_int)(unsafe.Pointer(bp + 8))).Fused--
			XTclBN_mp_clamp(tls, bp+8)
		}
		/*
		 * Have we converted all the requested digits?
		 */
		v1 = s
		s++
		*(*uint8)(unsafe.Pointer(v1)) = uint8(uint32('0') + digit)
		if i == ilim {
			if _ShouldBankerRoundUpPowD(tls, bp+8, sd, libc.Int32FromUint32(digit&uint32(1))) != 0 {
				s = _BumpUp(tls, s, retval, bp)
			}
			for {
				s--
				v2 = s
				if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) == int32('0')) {
					break
				}
				/* do nothing */
			}
			s++
			break
		}
		/*
		 * Advance to the next digit.
		 */
		err = XTclBN_mp_mul_d(tls, bp+8, uint32(10), bp+8)
		i++
	}
	/*
	 * Endgame - store the location of the decimal point and the end of the
	 * string.
	 */
	XTclBN_mp_clear(tls, bp+8)
	*(*uint8)(unsafe.Pointer(s)) = uint8('\000')
	*(*int32)(unsafe.Pointer(decpt)) = *(*int32)(unsafe.Pointer(bp))
	if endPtr != 0 {
		*(*uintptr)(unsafe.Pointer(endPtr)) = s
	}
	return retval
}

/*
 *----------------------------------------------------------------------
 *
 * ShouldBankerRoundUp --
 *
 *	Tests whether a digit should be rounded up or down when finishing
 *	bignum-based floating point conversion.
 *
 * Results:
 *	Returns 1 if the number needs to be rounded up, 0 otherwise.
 *
 *----------------------------------------------------------------------
 */

func _ShouldBankerRoundUp(tls *libc.TLS, twor uintptr, S uintptr, isodd int32) (r1 int32) {
	/* Flag == 1 if the last digit is odd. */
	var r int32
	_ = r
	r = XTclBN_mp_cmp_mag(tls, twor, S)
	switch r {
	case MP_EQ:
		return isodd
	case int32(MP_GT):
		return int32(1)
	default:
		return 0
	}
	return r1
}

/*
 *----------------------------------------------------------------------
 *
 * ShouldBankerRoundUpToNext --
 *
 *	Tests whether the remainder is great enough to force rounding to the
 *	next higher digit.
 *
 * Results:
 *	Returns 1 if the number should be rounded up, 0 otherwise.
 *
 *----------------------------------------------------------------------
 */

func _ShouldBankerRoundUpToNext(tls *libc.TLS, b uintptr, m uintptr, S uintptr, isodd int32) (r1 int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* 1 if the integer significand is odd. */
	var r int32
	var _ /* temp at bp+0 */ Tmp_int
	_ = r
	/*
	 * Compare b and S-m: this is the same as comparing B+m and S.
	 */
	if XTclBN_mp_init(tls, bp) != MP_OKAY || XTclBN_mp_add(tls, b, m, bp) != MP_OKAY {
		return 0
	}
	r = XTclBN_mp_cmp_mag(tls, bp, S)
	XTclBN_mp_clear(tls, bp)
	switch r {
	case MP_EQ:
		return isodd
	case int32(MP_GT):
		return int32(1)
	default:
		return 0
	}
	return r1
}

/*
 *----------------------------------------------------------------------
 *
 * ShorteningBignumConversion --
 *
 *	Convert a floating point number to a variable-length digit string
 *	using the multiprecision method.
 *
 * Results:
 *	Returns the string of digits.
 *
 * Side effects:
 *	Stores the position of the decimal point in *decpt.  Stores a pointer
 *	to the end of the number in *endPtr.
 *
 *----------------------------------------------------------------------
 */

func _ShorteningBignumConversion(tls *libc.TLS, dPtr uintptr, bw TTcl_WideUInt, b2 int32, m2plus int32, m2minus int32, s2 int32, s5 int32, _k int32, len1 int32, ilim int32, ilim1 int32, decpt uintptr, endPtr uintptr) (r uintptr) {
	bp := tls.Alloc(176)
	defer tls.Free(176)
	*(*int32)(unsafe.Pointer(bp)) = _k /* OUTPUT: Pointer to the end of the number */
	var digit, i, minit, r1 int32
	var err Tmp_err
	var retval, s, v1, v2, v3, v4, v5, v6 uintptr
	var _ /* S at bp+80 */ Tmp_int
	var _ /* b at bp+8 */ Tmp_int
	var _ /* dig at bp+104 */ Tmp_int
	var _ /* mminus at bp+32 */ Tmp_int
	var _ /* mplus at bp+56 */ Tmp_int
	_, _, _, _, _, _, _, _, _, _, _, _, _ = digit, err, i, minit, r1, retval, s, v1, v2, v3, v4, v5, v6
	retval = XTcl_Alloc(tls, libc.Uint64FromInt32(len1+int32(1)))
	/* Buffer of digits to return. */
	s = retval /* Current digit of the result. */
	minit = int32(1)
	/*
	 * b = bw * 2**b2 * 5**b5
	 * S = 2**s2 * 5*s5
	 */
	if retval == libc.UintptrFromInt32(0) || XTclBN_mp_init_u64(tls, bp+8, bw) != MP_OKAY {
		return libc.UintptrFromInt32(0)
	}
	err = XTclBN_mp_mul_2d(tls, bp+8, b2, bp+8)
	if err == MP_OKAY {
		err = XTclBN_mp_init_set(tls, bp+80, uint32(1))
	}
	if err == MP_OKAY {
		err = _MulPow5(tls, bp+80, libc.Uint32FromInt32(s5), bp+80)
	}
	if err == MP_OKAY {
		err = XTclBN_mp_mul_2d(tls, bp+80, s2, bp+80)
	}
	/*
	 * Handle the case where we guess the position of the decimal point wrong.
	 */
	if err == MP_OKAY && XTclBN_mp_cmp_mag(tls, bp+8, bp+80) == -int32(1) {
		err = XTclBN_mp_mul_d(tls, bp+8, uint32(10), bp+8)
		minit = int32(10)
		ilim = ilim1
		*(*int32)(unsafe.Pointer(bp))--
	}
	/*
	 * mminus = 2**m2minus * 5**m5
	 */
	if err == MP_OKAY {
		err = XTclBN_mp_init_set(tls, bp+32, libc.Uint32FromInt32(minit))
	}
	if err == MP_OKAY {
		err = XTclBN_mp_mul_2d(tls, bp+32, m2minus, bp+32)
	}
	if err == MP_OKAY && m2plus > m2minus {
		err = XTclBN_mp_init_copy(tls, bp+56, bp+32)
		if err == MP_OKAY {
			err = XTclBN_mp_mul_2d(tls, bp+56, m2plus-m2minus, bp+56)
		}
	}
	/*
	 * Loop through the digits.
	 */
	if err == MP_OKAY {
		err = XTclBN_mp_init(tls, bp+104)
	}
	i = int32(1)
	for err == MP_OKAY {
		err = XTclBN_mp_div(tls, bp+8, bp+80, bp+104, bp+8)
		if (*(*Tmp_int)(unsafe.Pointer(bp + 104))).Fused > int32(1) || *(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 104))).Fdp)) >= uint32(10) {
			XTcl_Panic(tls, __ccgo_ts+67024, 0)
		}
		digit = libc.Int32FromUint32(*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 104))).Fdp)))
		/*
		 * Does the current digit leave us with a remainder small enough to
		 * round to it?
		 */
		if m2plus > m2minus {
			v1 = bp + 56
		} else {
			v1 = bp + 32
		}
		r1 = XTclBN_mp_cmp_mag(tls, bp+8, v1)
		if r1 == -int32(1) || r1 == MP_EQ && (*TDouble)(unsafe.Pointer(dPtr)).Fw.Fword1&int32(1) == 0 {
			err = XTclBN_mp_mul_2d(tls, bp+8, int32(1), bp+8)
			if _ShouldBankerRoundUp(tls, bp+8, bp+80, digit&int32(1)) != 0 {
				digit++
				if digit == int32(10) {
					v2 = s
					s++
					*(*uint8)(unsafe.Pointer(v2)) = uint8('9')
					s = _BumpUp(tls, s, retval, bp)
					break
				}
			}
			v3 = s
			s++
			*(*uint8)(unsafe.Pointer(v3)) = libc.Uint8FromInt32(int32('0') + digit)
			break
		}
		/*
		 * Does the current digit leave us with a remainder large enough to
		 * commit to rounding up to the next higher digit?
		 */
		if _ShouldBankerRoundUpToNext(tls, bp+8, bp+32, bp+80, (*TDouble)(unsafe.Pointer(dPtr)).Fw.Fword1&int32(1)) != 0 {
			digit++
			if digit == int32(10) {
				v4 = s
				s++
				*(*uint8)(unsafe.Pointer(v4)) = uint8('9')
				s = _BumpUp(tls, s, retval, bp)
				break
			}
			v5 = s
			s++
			*(*uint8)(unsafe.Pointer(v5)) = libc.Uint8FromInt32(int32('0') + digit)
			break
		}
		/*
		 * Have we converted all the requested digits?
		 */
		v6 = s
		s++
		*(*uint8)(unsafe.Pointer(v6)) = libc.Uint8FromInt32(int32('0') + digit)
		if err == MP_OKAY && i == ilim {
			err = XTclBN_mp_mul_2d(tls, bp+8, int32(1), bp+8)
			if _ShouldBankerRoundUp(tls, bp+8, bp+80, digit&int32(1)) != 0 {
				s = _BumpUp(tls, s, retval, bp)
			}
			break
		}
		/*
		 * Advance to the next digit.
		 */
		if err == MP_OKAY && s5 > 0 {
			/*
			 * Can possibly shorten the denominator.
			 */
			err = XTclBN_mp_mul_2d(tls, bp+8, int32(1), bp+8)
			if err == MP_OKAY {
				err = XTclBN_mp_mul_2d(tls, bp+32, int32(1), bp+32)
			}
			if err == MP_OKAY && m2plus > m2minus {
				err = XTclBN_mp_mul_2d(tls, bp+56, int32(1), bp+56)
			}
			if err == MP_OKAY {
				err = XTclBN_mp_div_d(tls, bp+80, uint32(5), bp+80, libc.UintptrFromInt32(0))
			}
			s5--
			/*
			 * IDEA: It might possibly be a win to fall back to int64_t
			 *       arithmetic here if S < 2**64/10. But it's a win only for
			 *       a fairly narrow range of magnitudes so perhaps not worth
			 *       bothering.  We already know that we shorten the
			 *       denominator by at least 1 mp_digit, perhaps 2, as we do
			 *       the conversion for 17 digits of significance.
			 * Possible savings:
			 * 10**26   1 trip through loop before fallback possible
			 * 10**27   1 trip
			 * 10**28   2 trips
			 * 10**29   3 trips
			 * 10**30   4 trips
			 * 10**31   5 trips
			 * 10**32   6 trips
			 * 10**33   7 trips
			 * 10**34   8 trips
			 * 10**35   9 trips
			 * 10**36  10 trips
			 * 10**37  11 trips
			 * 10**38  12 trips
			 * 10**39  13 trips
			 * 10**40  14 trips
			 * 10**41  15 trips
			 * 10**42  16 trips
			 * thereafter no gain.
			 */
		} else {
			if err == MP_OKAY {
				err = XTclBN_mp_mul_d(tls, bp+8, uint32(10), bp+8)
				if err == MP_OKAY {
					err = XTclBN_mp_mul_d(tls, bp+32, uint32(10), bp+32)
				}
				if err == MP_OKAY && m2plus > m2minus {
					err = XTclBN_mp_mul_2d(tls, bp+56, int32(10), bp+56)
				}
			}
		}
		i++
	}
	/*
	 * Endgame - store the location of the decimal point and the end of the
	 * string.
	 */
	if m2plus > m2minus {
		XTclBN_mp_clear(tls, bp+56)
	}
	XTclBN_mp_clear_multi(tls, bp+8, libc.VaList(bp+136, bp+32, bp+104, bp+80, libc.UintptrFromInt32(0)))
	*(*uint8)(unsafe.Pointer(s)) = uint8('\000')
	*(*int32)(unsafe.Pointer(decpt)) = *(*int32)(unsafe.Pointer(bp))
	if endPtr != 0 {
		*(*uintptr)(unsafe.Pointer(endPtr)) = s
	}
	return retval
}

/*
 *----------------------------------------------------------------------
 *
 * StrictBignumConversion --
 *
 *	Convert a floating point number to a fixed-length digit string using
 *	the multiprecision method.
 *
 * Results:
 *	Returns the string of digits.
 *
 * Side effects:
 *	Stores the position of the decimal point in *decpt.  Stores a pointer
 *	to the end of the number in *endPtr.
 *
 *----------------------------------------------------------------------
 */

func _StrictBignumConversion(tls *libc.TLS, bw TTcl_WideUInt, b2 int32, s2 int32, s5 int32, _k int32, len1 int32, ilim int32, ilim1 int32, decpt uintptr, endPtr uintptr) (r uintptr) {
	bp := tls.Alloc(112)
	defer tls.Free(112)
	*(*int32)(unsafe.Pointer(bp)) = _k /* OUTPUT: Pointer to the end of the number */
	var digit, g, i, j, t, v2 int32
	var err Tmp_err
	var retval, s, v1, v4, v5 uintptr
	var _ /* S at bp+32 */ Tmp_int
	var _ /* b at bp+8 */ Tmp_int
	var _ /* dig at bp+56 */ Tmp_int
	_, _, _, _, _, _, _, _, _, _, _, _ = digit, err, g, i, j, retval, s, t, v1, v2, v4, v5
	retval = XTcl_Alloc(tls, libc.Uint64FromInt32(len1+int32(1)))
	/* Buffer of digits to return. */
	s = retval
	/*
	 * b = bw * 2**b2 * 5**b5
	 * S = 2**s2 * 5*s5
	 */
	if XTclBN_mp_init(tls, bp+56) != MP_OKAY {
		return libc.UintptrFromInt32(0)
	}
	if XTclBN_mp_init_u64(tls, bp+8, bw) != MP_OKAY {
		XTclBN_mp_clear(tls, bp+56)
		return libc.UintptrFromInt32(0)
	}
	err = XTclBN_mp_mul_2d(tls, bp+8, b2, bp+8)
	if err == MP_OKAY {
		err = XTclBN_mp_init_set(tls, bp+32, uint32(1))
	}
	if err == MP_OKAY {
		err = _MulPow5(tls, bp+32, libc.Uint32FromInt32(s5), bp+32)
		if err == MP_OKAY {
			err = XTclBN_mp_mul_2d(tls, bp+32, s2, bp+32)
		}
	}
	/*
	 * Handle the case where we guess the position of the decimal point wrong.
	 */
	if XTclBN_mp_cmp_mag(tls, bp+8, bp+32) == -int32(1) && XTclBN_mp_mul_d(tls, bp+8, uint32(10), bp+8) == MP_OKAY {
		ilim = ilim1
		*(*int32)(unsafe.Pointer(bp))--
	}
	/*
	 * Convert the leading digit.
	 */
	i = 0
	err = XTclBN_mp_div(tls, bp+8, bp+32, bp+56, bp+8)
	if (*(*Tmp_int)(unsafe.Pointer(bp + 56))).Fused > int32(1) || *(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 56))).Fdp)) >= uint32(10) {
		XTcl_Panic(tls, __ccgo_ts+67024, 0)
	}
	digit = libc.Int32FromUint32(*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 56))).Fdp)))
	/*
	 * Is a single digit all that was requested?
	 */
	v1 = s
	s++
	*(*uint8)(unsafe.Pointer(v1)) = libc.Uint8FromInt32(int32('0') + digit)
	i++
	v2 = i
	if v2 >= ilim {
		if XTclBN_mp_mul_2d(tls, bp+8, int32(1), bp+8) == MP_OKAY && _ShouldBankerRoundUp(tls, bp+8, bp+32, digit&int32(1)) != 0 {
			s = _BumpUp(tls, s, retval, bp)
		}
	} else {
		for err == MP_OKAY {
			/*
			 * Shift by a group of digits.
			 */
			g = ilim - i
			if g > int32(DIGIT_GROUP) {
				g = int32(DIGIT_GROUP)
			}
			if s5 >= g {
				err = XTclBN_mp_div_d(tls, bp+32, _dpow5[g], bp+32, libc.UintptrFromInt32(0))
				s5 -= g
			} else {
				if s5 > 0 {
					err = XTclBN_mp_div_d(tls, bp+32, _dpow5[s5], bp+32, libc.UintptrFromInt32(0))
					if err == MP_OKAY {
						err = XTclBN_mp_mul_d(tls, bp+8, _dpow5[g-s5], bp+8)
					}
					s5 = 0
				} else {
					err = XTclBN_mp_mul_d(tls, bp+8, _dpow5[g], bp+8)
				}
			}
			if err == MP_OKAY {
				err = XTclBN_mp_mul_2d(tls, bp+8, g, bp+8)
			}
			/*
			 * As with the shortening bignum conversion, it's possible at this
			 * point that we will have reduced the denominator to less than
			 * 2**64/10, at which point it would be possible to fall back to
			 * to int64_t arithmetic. But the potential payoff is tremendously
			 * less - unless we're working in F format - because we know that
			 * three groups of digits will always suffice for %#.17e, the
			 * longest format that doesn't introduce empty precision.
			 *
			 * Extract the next group of digits.
			 */
			if err != MP_OKAY || XTclBN_mp_div(tls, bp+8, bp+32, bp+56, bp+8) != MP_OKAY || (*(*Tmp_int)(unsafe.Pointer(bp + 56))).Fused > int32(1) {
				XTcl_Panic(tls, __ccgo_ts+67024, 0)
			}
			digit = libc.Int32FromUint32(*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 56))).Fdp)))
			j = g - int32(1)
			for {
				if !(j >= 0) {
					break
				}
				t = _itens[j]
				v4 = s
				s++
				*(*uint8)(unsafe.Pointer(v4)) = libc.Uint8FromInt32(digit/t + int32('0'))
				digit %= t
				goto _3
			_3:
				;
				j--
			}
			i += g
			/*
			 * Have we converted all the requested digits?
			 */
			if i == ilim {
				if XTclBN_mp_mul_2d(tls, bp+8, int32(1), bp+8) == MP_OKAY && _ShouldBankerRoundUp(tls, bp+8, bp+32, digit&int32(1)) != 0 {
					s = _BumpUp(tls, s, retval, bp)
				}
				break
			}
		}
	}
	for {
		s--
		v5 = s
		if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) == int32('0')) {
			break
		}
		/* do nothing */
	}
	s++
	/*
	 * Endgame - store the location of the decimal point and the end of the
	 * string.
	 */
	XTclBN_mp_clear_multi(tls, bp+8, libc.VaList(bp+88, bp+32, bp+56, libc.UintptrFromInt32(0)))
	*(*uint8)(unsafe.Pointer(s)) = uint8('\000')
	*(*int32)(unsafe.Pointer(decpt)) = *(*int32)(unsafe.Pointer(bp))
	if endPtr != 0 {
		*(*uintptr)(unsafe.Pointer(endPtr)) = s
	}
	return retval
}

/*
 *----------------------------------------------------------------------
 *
 * TclDoubleDigits --
 *
 *	Core of Tcl's conversion of double-precision floating point numbers to
 *	decimal.
 *
 * Results:
 *	Returns a newly-allocated string of digits.
 *
 * Side effects:
 *	Sets *decpt to the index of the character in the string before the
 *	place that the decimal point should go. If 'endPtr' is not NULL, sets
 *	endPtr to point to the terminating '\0' byte of the string. Sets *sign
 *	to 1 if a minus sign should be printed with the number, or 0 if a plus
 *	sign (or no sign) should appear.
 *
 * This function is a service routine that produces the string of digits for
 * floating-point-to-decimal conversion. It can do a number of things
 * according to the 'flags' argument. Valid values for 'flags' include:
 *	TCL_DD_SHORTEST - This is the default for floating point conversion.
 *		It constructs the shortest string of
 *		digits that will reconvert to the given number when scanned.
 *		For floating point numbers that are exactly between two
 *		decimal numbers, it resolves using the 'round to even' rule.
 *		With this value, the 'ndigits' parameter is ignored.
 *	TCL_DD_E_FORMAT - This value is used to prepare numbers for %e format
 *		conversion. It constructs a string of at most 'ndigits' digits,
 *		choosing the one that is closest to the given number (and
 *		resolving ties with 'round to even').  It is allowed to return
 *		fewer than 'ndigits' if the number converts exactly; if the
 *		TCL_DD_E_FORMAT|TCL_DD_SHORTEST is supplied instead, it
 *		also returns fewer digits if the shorter string will still
 *		reconvert without loss to the given input number. In any case,
 *		strings of trailing zeroes are suppressed.
 *	TCL_DD_F_FORMAT - This value is used to prepare numbers for %f format
 *		conversion. It requests that conversion proceed until
 *		'ndigits' digits after the decimal point have been converted.
 *		It is possible for this format to result in a zero-length
 *		string if the number is sufficiently small. Again, it is
 *		permissible for TCL_DD_F_FORMAT to return fewer digits for a
 *		number that converts exactly, and changing the argument to
 *		TCL_DD_F_FORMAT|TCL_DD_SHORTEST will allow the routine
 *		also to return fewer digits if the shorter string will still
 *		reconvert without loss to the given input number. Strings of
 *		trailing zeroes are suppressed.
 *
 *	To any of these flags may be OR'ed TCL_DD_NO_QUICK; this flag requires
 *	all calculations to be done in exact arithmetic. Normally, E and F
 *	format with fewer than about 14 digits will be done with a quick
 *	floating point approximation and fall back on the exact arithmetic
 *	only if the input number is close enough to the midpoint between two
 *	decimal strings that more precision is needed to resolve which string
 *	is correct.
 *
 * The value stored in the 'decpt' argument on return may be negative
 * (indicating that the decimal point falls to the left of the string) or
 * greater than the length of the string. In addition, the value -9999 is used
 * as a sentinel to indicate that the string is one of the special values
 * "Infinity" and "NaN", and that no decimal point should be inserted.
 *
 *----------------------------------------------------------------------
 */

func XTclDoubleDigits(tls *libc.TLS, dv float64, _ndigits int32, flags int32, decpt uintptr, sign uintptr, endPtr uintptr) (r uintptr) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	*(*int32)(unsafe.Pointer(bp)) = _ndigits /* OUTPUT: If not NULL, receives a pointer to
	 *	   one character beyond the end of the
	 *	   returned string. */
	var delta, delta1, denorm, k, len1, len11, m2plus, m5 int32
	var retval uintptr
	var _ /* b2 at bp+36 */ int32
	var _ /* b5 at bp+40 */ int32
	var _ /* bbits at bp+28 */ int32
	var _ /* be at bp+24 */ int32
	var _ /* bw at bp+16 */ TTcl_WideUInt
	var _ /* d at bp+8 */ TDouble
	var _ /* i at bp+60 */ int32
	var _ /* ilim at bp+52 */ int32
	var _ /* ilim1 at bp+56 */ int32
	var _ /* k_check at bp+32 */ int32
	var _ /* m2minus at bp+64 */ int32
	var _ /* s2 at bp+44 */ int32
	var _ /* s5 at bp+48 */ int32
	_, _, _, _, _, _, _, _, _ = delta, delta1, denorm, k, len1, len11, m2plus, m5, retval /* Powers of 2 and 5 in the numerator and
	 * denominator of intermediate results. */
	*(*int32)(unsafe.Pointer(bp + 52)) = -int32(1)
	*(*int32)(unsafe.Pointer(bp + 56)) = -int32(1) /* Return value from this function. */
	*(*int32)(unsafe.Pointer(bp + 60)) = -int32(1)
	/*
	 * Put the input number into a union for bit-whacking.
	 */
	*(*float64)(unsafe.Pointer(bp + 8)) = dv
	/*
	 * Handle the cases of negative numbers (by taking the absolute value:
	 * this includes -Inf and -NaN!), infinity, Not a Number, and zero.
	 */
	_TakeAbsoluteValue(tls, bp+8, sign)
	if (*(*struct {
		Fword0 int32
		Fword1 int32
	})(unsafe.Pointer(bp + 8))).Fword0&int32(EXP_MASK) == int32(EXP_MASK) {
		return _FormatInfAndNaN(tls, bp+8, decpt, endPtr)
	}
	if *(*float64)(unsafe.Pointer(bp + 8)) == float64(0) {
		return _FormatZero(tls, decpt, endPtr)
	}
	/*
	 * Unpack the floating point into a wide integer and an exponent.
	 * Determine the number of bits that the big integer requires, and compute
	 * a quick approximation (which may be one too high) of ceil(log10(d.d)).
	 */
	denorm = libc.BoolInt32((*(*struct {
		Fword0 int32
		Fword1 int32
	})(unsafe.Pointer(bp + 8))).Fword0&int32(EXP_MASK) == 0)
	_DoubleToExpAndSig(tls, *(*float64)(unsafe.Pointer(bp + 8)), bp+16, bp+24, bp+28)
	k = _ApproximateLog10(tls, *(*TTcl_WideUInt)(unsafe.Pointer(bp + 16)), *(*int32)(unsafe.Pointer(bp + 24)), *(*int32)(unsafe.Pointer(bp + 28)))
	k = _BetterLog10(tls, *(*float64)(unsafe.Pointer(bp + 8)), k, bp+32)
	/* At this point, we have:
	 *	  d is the number to convert.
	 *    bw are significand and exponent: d == bw*2**be,
	 *    bbits is the length of bw: 2**bbits-1 <= bw < 2**bbits
	 *	  k is either ceil(log10(d)) or ceil(log10(d))+1. k_check is 0 if we
	 *      know that k is exactly ceil(log10(d)) and 1 if we need to check.
	 *    We want a rational number
	 *      r = b * 10**(1-k) = bw * 2**b2 * 5**b5 / (2**s2 / 5**s5),
	 *    with b2, b5, s2, s5 >= 0.  Note that the most significant decimal
	 *    digit is floor(r) and that successive digits can be obtained by
	 *    setting r <- 10*floor(r) (or b <= 10 * (b % S)).  Find appropriate
	 *    b2, b5, s2, s5.
	 */
	_ComputeScale(tls, *(*int32)(unsafe.Pointer(bp + 24)), k, bp+36, bp+40, bp+44, bp+48)
	/*
	 * Correct an incorrect caller-supplied 'ndigits'.  Also determine:
	 *	i = The maximum number of decimal digits that will be returned in the
	 *      formatted string.  This is k + 1 + ndigits for F format, 18 for
	 *      shortest, and ndigits for E format.
	 *  ilim = The number of significant digits to convert if k has been
	 *         guessed correctly. This is -1 for shortest (which
	 *         stop when all significance has been lost), 'ndigits' for E
	 *         format, and 'k + 1 + ndigits' for F format.
	 *  ilim1 = The minimum number of significant digits to convert if k has
	 *	        been guessed 1 too high. This, too, is -1 for shortest,
	 *	        and 'ndigits' for E format, but it's 'ndigits-1' for F
	 *	        format.
	 */
	_SetPrecisionLimits(tls, flags, k, bp, bp+60, bp+52, bp+56)
	/*
	 * Try to do low-precision conversion in floating point rather than
	 * resorting to expensive multiprecision arithmetic.
	 */
	if *(*int32)(unsafe.Pointer(bp + 52)) >= 0 && *(*int32)(unsafe.Pointer(bp + 52)) <= int32(QUICK_MAX) && !(flags&libc.Int32FromInt32(TCL_DD_NO_QUICK) != 0) {
		retval = _QuickConversion(tls, *(*float64)(unsafe.Pointer(bp + 8)), k, *(*int32)(unsafe.Pointer(bp + 32)), flags, *(*int32)(unsafe.Pointer(bp + 60)), *(*int32)(unsafe.Pointer(bp + 52)), *(*int32)(unsafe.Pointer(bp + 56)), decpt, endPtr)
		if retval != libc.UintptrFromInt32(0) {
			return retval
		}
	}
	/*
	 * For shortening conversions, determine the upper and lower bounds for
	 * the remainder at which we can stop.
	 *   m+ = (2**m2plus * 5**m5) / (2**s2 * 5**s5) is the limit on the high
	 *        side, and
	 *   m- = (2**m2minus * 5**m5) / (2**s2 * 5**s5) is the limit on the low
	 *        side.
	 * We may need to increase s2 to put m2plus, m2minus, b2 over a common
	 * denominator.
	 */
	if flags&int32(TCL_DD_SHORTEST) != 0 {
		*(*int32)(unsafe.Pointer(bp + 64)) = *(*int32)(unsafe.Pointer(bp + 36))
		m5 = *(*int32)(unsafe.Pointer(bp + 40))
		len1 = *(*int32)(unsafe.Pointer(bp + 60))
		/*
		 * Find the quantity i so that (2**i*5**b5)/(2**s2*5**s5) is 1/2 unit
		 * in the least significant place of the floating point number.
		 */
		if denorm != 0 {
			*(*int32)(unsafe.Pointer(bp + 60)) = *(*int32)(unsafe.Pointer(bp + 24)) + int32(EXPONENT_BIAS) + (libc.Int32FromInt32(FP_PRECISION) - libc.Int32FromInt32(1))
		} else {
			*(*int32)(unsafe.Pointer(bp + 60)) = libc.Int32FromInt32(1) + libc.Int32FromInt32(FP_PRECISION) - *(*int32)(unsafe.Pointer(bp + 28))
		}
		*(*int32)(unsafe.Pointer(bp + 36)) += *(*int32)(unsafe.Pointer(bp + 60))
		*(*int32)(unsafe.Pointer(bp + 44)) += *(*int32)(unsafe.Pointer(bp + 60))
		/*
		 * Reduce the fractions to lowest terms, since the above calculation
		 * may have left excess powers of 2 in numerator and denominator.
		 */
		_CastOutPowersOf2(tls, bp+36, bp+64, bp+44)
		/*
		 * In the special case where bw==1, the nearest floating point number
		 * to it on the low side is 1/4 ulp below it. Adjust accordingly.
		 */
		m2plus = *(*int32)(unsafe.Pointer(bp + 64))
		if !(denorm != 0) && *(*TTcl_WideUInt)(unsafe.Pointer(bp + 16)) == uint64(1) {
			*(*int32)(unsafe.Pointer(bp + 36))++
			*(*int32)(unsafe.Pointer(bp + 44))++
			m2plus++
		}
		if *(*int32)(unsafe.Pointer(bp + 48))+int32(1) < int32(N_LOG2POW5) && *(*int32)(unsafe.Pointer(bp + 44))+int32(1)+_log2pow5[*(*int32)(unsafe.Pointer(bp + 48))+int32(1)] < int32(64) {
			/*
			 * If 10*2**s2*5**s5 == 2**(s2+1)+5**(s5+1) fits in a 64-bit word,
			 * then all our intermediate calculations can be done using exact
			 * 64-bit arithmetic with no need for expensive multiprecision
			 * operations. (This will be true for all numbers in the range
			 * [1.0e-3 .. 1.0e+24]).
			 */
			return _ShorteningInt64Conversion(tls, bp+8, *(*TTcl_WideUInt)(unsafe.Pointer(bp + 16)), *(*int32)(unsafe.Pointer(bp + 36)), *(*int32)(unsafe.Pointer(bp + 40)), m2plus, *(*int32)(unsafe.Pointer(bp + 64)), m5, *(*int32)(unsafe.Pointer(bp + 44)), *(*int32)(unsafe.Pointer(bp + 48)), k, len1, *(*int32)(unsafe.Pointer(bp + 52)), *(*int32)(unsafe.Pointer(bp + 56)), decpt, endPtr)
		} else {
			if *(*int32)(unsafe.Pointer(bp + 48)) == 0 {
				/*
				 * The denominator is a power of 2, so we can replace division by
				 * digit shifts. First we round up s2 to a multiple of MP_DIGIT_BIT,
				 * and adjust m2 and b2 accordingly. Then we launch into a version
				 * of the comparison that's specialized for the 'power of mp_digit
				 * in the denominator' case.
				 */
				if *(*int32)(unsafe.Pointer(bp + 44))%int32(MP_DIGIT_BIT) != 0 {
					delta = int32(MP_DIGIT_BIT) - *(*int32)(unsafe.Pointer(bp + 44))%int32(MP_DIGIT_BIT)
					*(*int32)(unsafe.Pointer(bp + 36)) += delta
					m2plus += delta
					*(*int32)(unsafe.Pointer(bp + 64)) += delta
					*(*int32)(unsafe.Pointer(bp + 44)) += delta
				}
				return _ShorteningBignumConversionPowD(tls, bp+8, *(*TTcl_WideUInt)(unsafe.Pointer(bp + 16)), *(*int32)(unsafe.Pointer(bp + 36)), *(*int32)(unsafe.Pointer(bp + 40)), m2plus, *(*int32)(unsafe.Pointer(bp + 64)), m5, *(*int32)(unsafe.Pointer(bp + 44))/int32(MP_DIGIT_BIT), k, len1, *(*int32)(unsafe.Pointer(bp + 52)), *(*int32)(unsafe.Pointer(bp + 56)), decpt, endPtr)
			} else {
				/*
				 * Alas, there's no helpful special case; use full-up bignum
				 * arithmetic for the conversion.
				 */
				return _ShorteningBignumConversion(tls, bp+8, *(*TTcl_WideUInt)(unsafe.Pointer(bp + 16)), *(*int32)(unsafe.Pointer(bp + 36)), m2plus, *(*int32)(unsafe.Pointer(bp + 64)), *(*int32)(unsafe.Pointer(bp + 44)), *(*int32)(unsafe.Pointer(bp + 48)), k, len1, *(*int32)(unsafe.Pointer(bp + 52)), *(*int32)(unsafe.Pointer(bp + 56)), decpt, endPtr)
			}
		}
	} else {
		/*
		 * Non-shortening conversion.
		 */
		len11 = *(*int32)(unsafe.Pointer(bp + 60))
		/*
		 * Reduce numerator and denominator to lowest terms.
		 */
		if *(*int32)(unsafe.Pointer(bp + 36)) >= *(*int32)(unsafe.Pointer(bp + 44)) && *(*int32)(unsafe.Pointer(bp + 44)) > 0 {
			*(*int32)(unsafe.Pointer(bp + 36)) -= *(*int32)(unsafe.Pointer(bp + 44))
			*(*int32)(unsafe.Pointer(bp + 44)) = 0
		} else {
			if *(*int32)(unsafe.Pointer(bp + 44)) >= *(*int32)(unsafe.Pointer(bp + 36)) && *(*int32)(unsafe.Pointer(bp + 36)) > 0 {
				*(*int32)(unsafe.Pointer(bp + 44)) -= *(*int32)(unsafe.Pointer(bp + 36))
				*(*int32)(unsafe.Pointer(bp + 36)) = 0
			}
		}
		if *(*int32)(unsafe.Pointer(bp + 48))+int32(1) < int32(N_LOG2POW5) && *(*int32)(unsafe.Pointer(bp + 44))+int32(1)+_log2pow5[*(*int32)(unsafe.Pointer(bp + 48))+int32(1)] < int32(64) {
			/*
			 * If 10*2**s2*5**s5 == 2**(s2+1)+5**(s5+1) fits in a 64-bit word,
			 * then all our intermediate calculations can be done using exact
			 * 64-bit arithmetic with no need for expensive multiprecision
			 * operations.
			 */
			return _StrictInt64Conversion(tls, *(*TTcl_WideUInt)(unsafe.Pointer(bp + 16)), *(*int32)(unsafe.Pointer(bp + 36)), *(*int32)(unsafe.Pointer(bp + 40)), *(*int32)(unsafe.Pointer(bp + 44)), *(*int32)(unsafe.Pointer(bp + 48)), k, len11, *(*int32)(unsafe.Pointer(bp + 52)), *(*int32)(unsafe.Pointer(bp + 56)), decpt, endPtr)
		} else {
			if *(*int32)(unsafe.Pointer(bp + 48)) == 0 {
				/*
				 * The denominator is a power of 2, so we can replace division by
				 * digit shifts. First we round up s2 to a multiple of MP_DIGIT_BIT,
				 * and adjust m2 and b2 accordingly. Then we launch into a version
				 * of the comparison that's specialized for the 'power of mp_digit
				 * in the denominator' case.
				 */
				if *(*int32)(unsafe.Pointer(bp + 44))%int32(MP_DIGIT_BIT) != 0 {
					delta1 = int32(MP_DIGIT_BIT) - *(*int32)(unsafe.Pointer(bp + 44))%int32(MP_DIGIT_BIT)
					*(*int32)(unsafe.Pointer(bp + 36)) += delta1
					*(*int32)(unsafe.Pointer(bp + 44)) += delta1
				}
				return _StrictBignumConversionPowD(tls, *(*TTcl_WideUInt)(unsafe.Pointer(bp + 16)), *(*int32)(unsafe.Pointer(bp + 36)), *(*int32)(unsafe.Pointer(bp + 40)), *(*int32)(unsafe.Pointer(bp + 44))/int32(MP_DIGIT_BIT), k, len11, *(*int32)(unsafe.Pointer(bp + 52)), *(*int32)(unsafe.Pointer(bp + 56)), decpt, endPtr)
			} else {
				/*
				 * There are no helpful special cases, but at least we know in
				 * advance how many digits we will convert. We can run the
				 * conversion in steps of DIGIT_GROUP digits, so as to have many
				 * fewer mp_int divisions.
				 */
				return _StrictBignumConversion(tls, *(*TTcl_WideUInt)(unsafe.Pointer(bp + 16)), *(*int32)(unsafe.Pointer(bp + 36)), *(*int32)(unsafe.Pointer(bp + 44)), *(*int32)(unsafe.Pointer(bp + 48)), k, len11, *(*int32)(unsafe.Pointer(bp + 52)), *(*int32)(unsafe.Pointer(bp + 56)), decpt, endPtr)
			}
		}
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * TclInitDoubleConversion --
 *
 *	Initializes constants that are needed for conversions to and from
 *	'double'
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The log base 2 of the floating point radix, the number of bits in a
 *	double mantissa, and a table of the powers of five and ten are
 *	computed and stored.
 *
 *----------------------------------------------------------------------
 */

func XTclInitDoubleConversion(tls *libc.TLS) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var d float64
	var err Tmp_err
	var i, x int32
	var u TTcl_WideUInt
	var _ /* bitwhack at bp+0 */ struct {
		Fiv [0]TTcl_WideUInt
		Fdv float64
	}
	_, _, _, _, _ = d, err, i, u, x
	err = MP_OKAY
	/*
	 * Initialize table of powers of 10 expressed as wide integers.
	 */
	_maxpow10_wide = int32(libc.Xfloor(tls, float64(float64(libc.Uint64FromInt64(8)*libc.Uint64FromInt32(CHAR_BIT))*libc.Xlog(tls, float64(2)))/libc.Xlog(tls, float64(10))))
	_pow10_wide = XTcl_Alloc(tls, libc.Uint64FromInt32(_maxpow10_wide+libc.Int32FromInt32(1))*uint64(8))
	u = uint64(1)
	i = 0
	for {
		if !(i < _maxpow10_wide) {
			break
		}
		*(*TTcl_WideUInt)(unsafe.Pointer(_pow10_wide + uintptr(i)*8)) = u
		u *= uint64(10)
		goto _1
	_1:
		;
		i++
	}
	*(*TTcl_WideUInt)(unsafe.Pointer(_pow10_wide + uintptr(i)*8)) = u
	/*
	 * Determine how many bits of precision a double has, and how many decimal
	 * digits that represents.
	 */
	if libc.Xfrexp(tls, libc.Float64FromInt32(FLT_RADIX), uintptr(unsafe.Pointer(&_log2FLT_RADIX))) != float64(0.5) {
		XTcl_Panic(tls, __ccgo_ts+67037, 0)
	}
	_log2FLT_RADIX--
	_mantBits = int32(DBL_MANT_DIG) * _log2FLT_RADIX
	d = float64(1)
	/*
	 * Initialize a table of powers of ten that can be exactly represented in
	 * a double.
	 */
	x = int32(float64(libc.Float64FromInt32(DBL_MANT_DIG)*libc.Xlog(tls, libc.Float64FromInt32(FLT_RADIX))) / libc.Xlog(tls, float64(5)))
	if x < int32(MAXPOW) {
		_mmaxpow = x
	} else {
		_mmaxpow = int32(MAXPOW)
	}
	i = 0
	for {
		if !(i <= _mmaxpow) {
			break
		}
		_pow10vals[i] = d
		d *= float64(10)
		goto _2
	_2:
		;
		i++
	}
	/*
	 * Initialize a table of large powers of five.
	 */
	i = 0
	for {
		if !(i < int32(9)) {
			break
		}
		err = libc.BoolInt32(err != 0 || XTclBN_mp_init(tls, uintptr(unsafe.Pointer(&_pow5))+uintptr(i)*24) != 0)
		goto _3
	_3:
		;
		i++
	}
	XTclBN_mp_set_u64(tls, uintptr(unsafe.Pointer(&_pow5)), uint64(5))
	i = 0
	for {
		if !(i < int32(8)) {
			break
		}
		err = libc.BoolInt32(err != 0 || XTclBN_mp_mul(tls, uintptr(unsafe.Pointer(&_pow5))+uintptr(i)*24, uintptr(unsafe.Pointer(&_pow5))+uintptr(i)*24, uintptr(unsafe.Pointer(&_pow5))+uintptr(i)*24+uintptr(1)*24) != 0)
		goto _4
	_4:
		;
		i++
	}
	err = libc.BoolInt32(err != 0 || XTclBN_mp_init_u64(tls, uintptr(unsafe.Pointer(&_pow5_13)), uint64(1220703125)) != 0)
	i = int32(1)
	for {
		if !(i < int32(5)) {
			break
		}
		err = libc.BoolInt32(err != 0 || XTclBN_mp_init(tls, uintptr(unsafe.Pointer(&_pow5_13))+uintptr(i)*24) != 0)
		err = libc.BoolInt32(err != 0 || XTclBN_mp_mul(tls, uintptr(unsafe.Pointer(&_pow5_13))+uintptr(i)*24-uintptr(1)*24, uintptr(unsafe.Pointer(&_pow5_13))+uintptr(i)*24-uintptr(1)*24, uintptr(unsafe.Pointer(&_pow5_13))+uintptr(i)*24) != 0)
		goto _5
	_5:
		;
		i++
	}
	if err != MP_OKAY {
		XTcl_Panic(tls, __ccgo_ts+1638, 0)
	}
	/*
	 * Determine the number of decimal digits to the left and right of the
	 * decimal point in the largest and smallest double, the smallest double
	 * that differs from zero, and the number of mp_digits needed to represent
	 * the significand of a double.
	 */
	_maxDigits = int32((float64(libc.Float64FromInt32(DBL_MAX_EXP)*libc.Xlog(tls, libc.Float64FromInt32(FLT_RADIX))) + float64(libc.Float64FromFloat64(0.5)*libc.Xlog(tls, float64(10)))) / libc.Xlog(tls, float64(10)))
	_minDigits = int32(libc.Xfloor(tls, float64(float64(-libc.Int32FromInt32(1021)-libc.Int32FromInt32(DBL_MANT_DIG))*libc.Xlog(tls, libc.Float64FromInt32(FLT_RADIX)))/libc.Xlog(tls, float64(10))))
	_log10_DIGIT_MAX = int32(libc.Xfloor(tls, float64(libc.Float64FromInt32(MP_DIGIT_BIT)*libc.Xlog(tls, float64(2)))/libc.Xlog(tls, float64(10))))
	/*
	 * Nokia 770's software-emulated floating point is "middle endian": the
	 * bytes within a 32-bit word are little-endian (like the native
	 * integers), but the two words of a 'double' are presented most
	 * significant word first.
	 */
	*(*float64)(unsafe.Pointer(bp)) = float64(1.000000238418579)
	/* 3ff0 0000 4000 0000 */
	if *(*TTcl_WideUInt)(unsafe.Pointer(bp))>>libc.Int32FromInt32(32) == uint64(0x3FF00000) {
		_n770_fp = 0
	} else {
		if *(*TTcl_WideUInt)(unsafe.Pointer(bp))&uint64(0xFFFFFFFF) == uint64(0x3FF00000) {
			_n770_fp = int32(1)
		} else {
			XTcl_Panic(tls, __ccgo_ts+67082, 0)
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclFinalizeDoubleConversion --
 *
 *	Cleans up this file on exit.
 *
 * Results:
 *	None
 *
 * Side effects:
 *	Memory allocated by TclInitDoubleConversion is freed.
 *
 *----------------------------------------------------------------------
 */

func XTclFinalizeDoubleConversion(tls *libc.TLS) {
	var i int32
	_ = i
	XTclpFree(tls, _pow10_wide)
	i = 0
	for {
		if !(i < int32(9)) {
			break
		}
		XTclBN_mp_clear(tls, uintptr(unsafe.Pointer(&_pow5))+uintptr(i)*24)
		goto _1
	_1:
		;
		i++
	}
	i = 0
	for {
		if !(i < int32(5)) {
			break
		}
		XTclBN_mp_clear(tls, uintptr(unsafe.Pointer(&_pow5_13))+uintptr(i)*24)
		goto _2
	_2:
		;
		i++
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_InitBignumFromDouble --
 *
 *	Extracts the integer part of a double and converts it to an arbitrary
 *	precision integer.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Initializes the bignum supplied, and stores the converted number in
 *	it.
 *
 *----------------------------------------------------------------------
 */

func XTcl_InitBignumFromDouble(tls *libc.TLS, interp uintptr, d float64, big uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Place to store the result. */
	var b, s uintptr
	var err Tmp_err
	var fract float64
	var shift int32
	var w TTcl_WideInt
	var v1 uint64
	var _ /* __u at bp+0 */ struct {
		F__i [0]uint64
		F__f float64
	}
	var _ /* expt at bp+8 */ int32
	_, _, _, _, _, _, _ = b, err, fract, s, shift, w, v1
	b = big
	/*
	 * Infinite values can't convert to bignum.
	 */
	*(*float64)(unsafe.Pointer(bp)) = d
	v1 = *(*uint64)(unsafe.Pointer(bp))
	goto _2
_2:
	if libc.BoolInt32(v1&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) == libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
		if interp != libc.UintptrFromInt32(0) {
			s = __ccgo_ts + 11737
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, s, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+8919, __ccgo_ts+55300, s, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	fract = libc.Xfrexp(tls, d, bp+8)
	if *(*int32)(unsafe.Pointer(bp + 8)) <= 0 {
		err = XTclBN_mp_init(tls, b)
		XTclBN_mp_zero(tls, b)
	} else {
		w = int64(libc.Xldexp(tls, fract, _mantBits))
		shift = *(*int32)(unsafe.Pointer(bp + 8)) - _mantBits
		err = XTclBN_mp_init_i64(tls, b, w)
		if err != MP_OKAY {
			/* just skip */
		} else {
			if shift < 0 {
				err = XTclBN_mp_div_2d(tls, b, -shift, b, libc.UintptrFromInt32(0))
			} else {
				if shift > 0 {
					err = XTclBN_mp_mul_2d(tls, b, shift, b)
				}
			}
		}
	}
	if err != MP_OKAY {
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclBignumToDouble --
 *
 *	Convert an arbitrary-precision integer to a native floating point
 *	number.
 *
 * Results:
 *	Returns the converted number. Sets errno to ERANGE if the number is
 *	too large to convert.
 *
 *----------------------------------------------------------------------
 */

func XTclBignumToDouble(tls *libc.TLS, big uintptr) (r1 float64) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Integer to convert. */
	var a uintptr
	var bits, i, lsb, shift, v1, v2, v3, v5 int32
	var err Tmp_err
	var r float64
	var _ /* b at bp+0 */ Tmp_int
	_, _, _, _, _, _, _, _, _, _, _ = a, bits, err, i, lsb, r, shift, v1, v2, v3, v5
	a = big
	/*
	 * We need a 'mantBits'-bit significand.  Determine what shift will
	 * give us that.
	 */
	bits = XTclBN_mp_count_bits(tls, a)
	if bits > int32(DBL_MAX_EXP)*_log2FLT_RADIX {
		*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = int32(ERANGE)
		if (*Tmp_int)(unsafe.Pointer(a)).Fsign != MP_ZPOS {
			v1 = int32(MP_YES)
		} else {
			v1 = MP_NO
		}
		if v1 != 0 {
			return -float64(libc.X__builtin_inff(tls))
		} else {
			return float64(libc.X__builtin_inff(tls))
		}
	}
	shift = _mantBits - bits
	/*
	 * If shift > 0, shift the significand left by the requisite number of
	 * bits.  If shift == 0, the significand is already exactly 'mantBits'
	 * in length.  If shift < 0, we will need to shift the significand right
	 * by the requisite number of bits, and round it. If the '1-shift'
	 * least significant bits are 0, but the 'shift'th bit is nonzero,
	 * then the significand lies exactly between two values and must be
	 * 'rounded to even'.
	 */
	err = XTclBN_mp_init(tls, bp)
	if err != MP_OKAY {
		/* just skip */
	} else {
		if shift == 0 {
			err = XTclBN_mp_copy(tls, a, bp)
		} else {
			if shift > 0 {
				err = XTclBN_mp_mul_2d(tls, a, shift, bp)
			} else {
				if shift < 0 {
					lsb = XTclBN_mp_cnt_lsb(tls, a)
					if lsb == -int32(1)-shift {
						/*
						 * Round to even
						 */
						err = XTclBN_mp_div_2d(tls, a, -shift, bp, libc.UintptrFromInt32(0))
						if err == MP_OKAY && ((*Tmp_int)(unsafe.Pointer(bp)).Fused != 0 && *(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(bp)).Fdp))&uint32(1) != uint32(0)) {
							if (*Tmp_int)(unsafe.Pointer(bp)).Fsign != MP_ZPOS {
								v2 = int32(MP_YES)
							} else {
								v2 = MP_NO
							}
							if v2 != 0 {
								err = XTclBN_mp_sub_d(tls, bp, uint32(1), bp)
							} else {
								err = XTclBN_mp_add_d(tls, bp, uint32(1), bp)
							}
						}
					} else {
						/*
						 * Ordinary rounding
						 */
						err = XTclBN_mp_div_2d(tls, a, -int32(1)-shift, bp, libc.UintptrFromInt32(0))
						if err != MP_OKAY {
							/* just skip */
						} else {
							if (*Tmp_int)(unsafe.Pointer(bp)).Fsign != MP_ZPOS {
								v3 = int32(MP_YES)
							} else {
								v3 = MP_NO
							}
							if v3 != 0 {
								err = XTclBN_mp_sub_d(tls, bp, uint32(1), bp)
							} else {
								err = XTclBN_mp_add_d(tls, bp, uint32(1), bp)
							}
						}
						err = XTclBN_mp_div_2d(tls, bp, int32(1), bp, libc.UintptrFromInt32(0))
					}
				}
			}
		}
	}
	/*
	 * Accumulate the result, one mp_digit at a time.
	 */
	if err != MP_OKAY {
		return float64(0)
	}
	r = float64(0)
	i = (*(*Tmp_int)(unsafe.Pointer(bp))).Fused - int32(1)
	for {
		if !(i >= 0) {
			break
		}
		r = libc.Xldexp(tls, r, int32(MP_DIGIT_BIT)) + float64(*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp + uintptr(i)*4)))
		goto _4
	_4:
		;
		i--
	}
	XTclBN_mp_clear(tls, bp)
	/*
	 * Scale the result to the correct number of bits.
	 */
	r = libc.Xldexp(tls, r, bits-_mantBits)
	/*
	 * Return the result with the appropriate sign.
	 */
	if (*Tmp_int)(unsafe.Pointer(a)).Fsign != MP_ZPOS {
		v5 = int32(MP_YES)
	} else {
		v5 = MP_NO
	}
	if v5 != 0 {
		return -r
	} else {
		return r
	}
	return r1
}

/*
 *----------------------------------------------------------------------
 *
 * TclCeil --
 *
 *	Computes the smallest floating point number that is at least the
 *	mp_int argument.
 *
 * Results:
 *	Returns the floating point number.
 *
 *----------------------------------------------------------------------
 */

func XTclCeil(tls *libc.TLS, big uintptr) (r1 float64) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Integer to convert. */
	var a uintptr
	var bits, exact, i, shift, v1, v3 int32
	var err Tmp_err
	var r float64
	var v2 bool
	var _ /* b at bp+0 */ Tmp_int
	var _ /* d at bp+24 */ Tmp_int
	_, _, _, _, _, _, _, _, _, _ = a, bits, err, exact, i, r, shift, v1, v2, v3
	r = float64(0)
	a = big
	err = XTclBN_mp_init(tls, bp)
	if v2 = err == MP_OKAY; v2 {
		if (*Tmp_int)(unsafe.Pointer(a)).Fsign != MP_ZPOS {
			v1 = int32(MP_YES)
		} else {
			v1 = MP_NO
		}
	}
	if v2 && v1 != 0 {
		err = XTclBN_mp_neg(tls, a, bp)
		r = -XTclFloor(tls, bp)
	} else {
		bits = XTclBN_mp_count_bits(tls, a)
		if bits > int32(DBL_MAX_EXP)*_log2FLT_RADIX {
			r = float64(libc.X__builtin_inff(tls))
		} else {
			exact = int32(1)
			shift = _mantBits - bits
			if err != MP_OKAY {
				/* just skip */
			} else {
				if shift > 0 {
					err = XTclBN_mp_mul_2d(tls, a, shift, bp)
				} else {
					if shift < 0 {
						err = XTclBN_mp_init(tls, bp+24)
						if err == MP_OKAY {
							err = XTclBN_mp_div_2d(tls, a, -shift, bp, bp+24)
						}
						if (*Tmp_int)(unsafe.Pointer(bp+24)).Fused == 0 {
							v3 = int32(MP_YES)
						} else {
							v3 = MP_NO
						}
						exact = v3
						XTclBN_mp_clear(tls, bp+24)
					} else {
						err = XTclBN_mp_copy(tls, a, bp)
					}
				}
			}
			if err == MP_OKAY && !(exact != 0) {
				err = XTclBN_mp_add_d(tls, bp, uint32(1), bp)
			}
			if err != MP_OKAY {
				return float64(0)
			}
			i = (*(*Tmp_int)(unsafe.Pointer(bp))).Fused - int32(1)
			for {
				if !(i >= 0) {
					break
				}
				r = libc.Xldexp(tls, r, int32(MP_DIGIT_BIT)) + float64(*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp + uintptr(i)*4)))
				goto _4
			_4:
				;
				i--
			}
			r = libc.Xldexp(tls, r, bits-_mantBits)
		}
	}
	XTclBN_mp_clear(tls, bp)
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * TclFloor --
 *
 *	Computes the largest floating point number less than or equal to the
 *	mp_int argument.
 *
 * Results:
 *	Returns the floating point value.
 *
 *----------------------------------------------------------------------
 */

func XTclFloor(tls *libc.TLS, big uintptr) (r1 float64) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Integer to convert. */
	var a uintptr
	var bits, i, shift, v1 int32
	var err Tmp_err
	var r float64
	var v2 bool
	var _ /* b at bp+0 */ Tmp_int
	_, _, _, _, _, _, _, _ = a, bits, err, i, r, shift, v1, v2
	r = float64(0)
	a = big
	err = XTclBN_mp_init(tls, bp)
	if v2 = err == MP_OKAY; v2 {
		if (*Tmp_int)(unsafe.Pointer(a)).Fsign != MP_ZPOS {
			v1 = int32(MP_YES)
		} else {
			v1 = MP_NO
		}
	}
	if v2 && v1 != 0 {
		err = XTclBN_mp_neg(tls, a, bp)
		r = -XTclCeil(tls, bp)
	} else {
		bits = XTclBN_mp_count_bits(tls, a)
		if bits > int32(DBL_MAX_EXP)*_log2FLT_RADIX {
			r = float64(1.7976931348623157e+308)
		} else {
			shift = _mantBits - bits
			if shift > 0 {
				err = XTclBN_mp_mul_2d(tls, a, shift, bp)
			} else {
				if shift < 0 {
					err = XTclBN_mp_div_2d(tls, a, -shift, bp, libc.UintptrFromInt32(0))
				} else {
					err = XTclBN_mp_copy(tls, a, bp)
				}
			}
			if err != MP_OKAY {
				return float64(0)
			}
			i = (*(*Tmp_int)(unsafe.Pointer(bp))).Fused - int32(1)
			for {
				if !(i >= 0) {
					break
				}
				r = libc.Xldexp(tls, r, int32(MP_DIGIT_BIT)) + float64(*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp + uintptr(i)*4)))
				goto _3
			_3:
				;
				i--
			}
			r = libc.Xldexp(tls, r, bits-_mantBits)
		}
	}
	XTclBN_mp_clear(tls, bp)
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * BignumToBiasedFrExp --
 *
 *	Convert an arbitrary-precision integer to a native floating point
 *	number in the range [0.5,1) times a power of two. NOTE: Intentionally
 *	converts to a number that's a few ulp too small, so that
 *	RefineApproximation will not overflow near the high end of the
 *	machine's arithmetic range.
 *
 * Results:
 *	Returns the converted number.
 *
 * Side effects:
 *	Stores the exponent of two in 'machexp'.
 *
 *----------------------------------------------------------------------
 */

func _BignumToBiasedFrExp(tls *libc.TLS, a uintptr, machexp uintptr) (r1 float64) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Power of two. */
	var bits, i, shift, v3 int32
	var err Tmp_err
	var r, v2 float64
	var _ /* b at bp+0 */ Tmp_int
	_, _, _, _, _, _, _ = bits, err, i, r, shift, v2, v3
	err = MP_OKAY
	/*
	 * Determine how many bits we need, and extract that many from the input.
	 * Round to nearest unit in the last place.
	 */
	bits = XTclBN_mp_count_bits(tls, a)
	shift = _mantBits - int32(2) - bits
	if XTclBN_mp_init(tls, bp) != 0 {
		return float64(0)
	}
	if shift > 0 {
		err = XTclBN_mp_mul_2d(tls, a, shift, bp)
	} else {
		if shift < 0 {
			err = XTclBN_mp_div_2d(tls, a, -shift, bp, libc.UintptrFromInt32(0))
		} else {
			err = XTclBN_mp_copy(tls, a, bp)
		}
	}
	/*
	 * Accumulate the result, one mp_digit at a time.
	 */
	r = float64(0)
	if err == MP_OKAY {
		i = (*(*Tmp_int)(unsafe.Pointer(bp))).Fused - int32(1)
		for {
			if !(i >= 0) {
				break
			}
			r = libc.Xldexp(tls, r, int32(MP_DIGIT_BIT)) + float64(*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp + uintptr(i)*4)))
			goto _1
		_1:
			;
			i--
		}
	}
	XTclBN_mp_clear(tls, bp)
	/*
	 * Return the result with the appropriate sign.
	 */
	*(*int32)(unsafe.Pointer(machexp)) = bits - _mantBits + int32(2)
	if (*Tmp_int)(unsafe.Pointer(a)).Fsign != MP_ZPOS {
		v3 = int32(MP_YES)
	} else {
		v3 = MP_NO
	}
	if v3 != 0 {
		v2 = -r
	} else {
		v2 = r
	}
	return v2
}

/*
 *----------------------------------------------------------------------
 *
 * Pow10TimesFrExp --
 *
 *	Multiply a power of ten by a number expressed as fraction and
 *	exponent.
 *
 * Results:
 *	Returns the significand of the result.
 *
 * Side effects:
 *	Overwrites the 'machexp' parameter with the exponent of the result.
 *
 * Assumes that 'exponent' is such that 10**exponent would be a double, even
 * though 'fraction*10**(machexp+exponent)' might overflow.
 *
 *----------------------------------------------------------------------
 */

func _Pow10TimesFrExp(tls *libc.TLS, exponent int32, fraction float64, machexp uintptr) (r float64) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* On input, exponent of multiplicand. On
	 * output, exponent of result. */
	var expt, i int32
	var retval float64
	var _ /* j at bp+0 */ int32
	_, _, _ = expt, i, retval
	expt = *(*int32)(unsafe.Pointer(machexp))
	retval = fraction
	if exponent > 0 {
		/*
		 * Multiply by 10**exponent.
		 */
		retval = libc.Xfrexp(tls, float64(retval*_pow10vals[exponent&int32(0xF)]), bp)
		expt += *(*int32)(unsafe.Pointer(bp))
		i = int32(4)
		for {
			if !(i < int32(9)) {
				break
			}
			if exponent&(int32(1)<<i) != 0 {
				retval = libc.Xfrexp(tls, float64(retval*_pow_10_2_n[i]), bp)
				expt += *(*int32)(unsafe.Pointer(bp))
			}
			goto _1
		_1:
			;
			i++
		}
	} else {
		if exponent < 0 {
			/*
			 * Divide by 10**-exponent.
			 */
			retval = libc.Xfrexp(tls, retval/_pow10vals[-exponent&int32(0xF)], bp)
			expt += *(*int32)(unsafe.Pointer(bp))
			i = int32(4)
			for {
				if !(i < int32(9)) {
					break
				}
				if -exponent&(int32(1)<<i) != 0 {
					retval = libc.Xfrexp(tls, retval/_pow_10_2_n[i], bp)
					expt += *(*int32)(unsafe.Pointer(bp))
				}
				goto _2
			_2:
				;
				i++
			}
		}
	}
	*(*int32)(unsafe.Pointer(machexp)) = expt
	return retval
}

/*
 *----------------------------------------------------------------------
 *
 * SafeLdExp --
 *
 *	Do an 'ldexp' operation, but handle denormals gracefully.
 *
 * Results:
 *	Returns the appropriately scaled value.
 *
 *	On some platforms, 'ldexp' fails when presented with a number too
 *	small to represent as a normalized double. This routine does 'ldexp'
 *	in two steps for those numbers, to return correctly denormalized
 *	values.
 *
 *----------------------------------------------------------------------
 */

func _SafeLdExp(tls *libc.TLS, fract float64, expt int32) (r float64) {
	var a, b, retval float64
	var minexpt int32
	_, _, _, _ = a, b, minexpt, retval
	minexpt = -int32(1021) * _log2FLT_RADIX
	if expt < minexpt {
		a = libc.Xldexp(tls, fract, expt-_mantBits-minexpt)
		b = libc.Xldexp(tls, float64(1), _mantBits+minexpt)
		retval = float64(a * b)
	} else {
		retval = libc.Xldexp(tls, fract, expt)
	}
	return retval
}

/*
 *----------------------------------------------------------------------
 *
 * TclFormatNaN --
 *
 *	Makes the string representation of a "Not a Number"
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Stores the string representation in the supplied buffer, which must be
 *	at least TCL_DOUBLE_SPACE characters.
 *
 *----------------------------------------------------------------------
 */

func XTclFormatNaN(tls *libc.TLS, value float64, buffer uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* String representation. */
	var v1, v2, v3, v4 uintptr
	var _ /* bitwhack at bp+0 */ struct {
		Fiv [0]Tuint64_t
		Fdv float64
	}
	_, _, _, _ = v1, v2, v3, v4
	*(*float64)(unsafe.Pointer(bp)) = value
	if _n770_fp != 0 {
		*(*Tuint64_t)(unsafe.Pointer(bp)) = _Nokia770Twiddle(tls, *(*Tuint64_t)(unsafe.Pointer(bp)))
	}
	if *(*Tuint64_t)(unsafe.Pointer(bp))&(libc.Uint64FromUint64(1)<<libc.Int32FromInt32(63)) != 0 {
		*(*Tuint64_t)(unsafe.Pointer(bp)) &= ^(libc.Uint64FromUint64(1) << libc.Int32FromInt32(63))
		v1 = buffer
		buffer++
		*(*uint8)(unsafe.Pointer(v1)) = uint8('-')
	}
	v2 = buffer
	buffer++
	*(*uint8)(unsafe.Pointer(v2)) = uint8('N')
	v3 = buffer
	buffer++
	*(*uint8)(unsafe.Pointer(v3)) = uint8('a')
	v4 = buffer
	buffer++
	*(*uint8)(unsafe.Pointer(v4)) = uint8('N')
	*(*Tuint64_t)(unsafe.Pointer(bp)) &= libc.Uint64FromUint64(1)<<libc.Int32FromInt32(51) - libc.Uint64FromInt32(1)
	if *(*Tuint64_t)(unsafe.Pointer(bp)) != uint64(0) {
		libc.X__builtin_snprintf(tls, buffer, libc.Uint64FromInt32(libc.Int32FromInt32(TCL_MAX_PREC)+libc.Int32FromInt32(10)), __ccgo_ts+67132, libc.VaList(bp+16, *(*Tuint64_t)(unsafe.Pointer(bp))))
	} else {
		*(*uint8)(unsafe.Pointer(buffer)) = uint8('\000')
	}
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * Nokia770Twiddle --
//	 *
//	 *	Transpose the two words of a number for Nokia 770 floating point
//	 *	handling.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _Nokia770Twiddle(tls *libc.TLS, w TTcl_WideUInt) (r TTcl_WideUInt) {
	/* Number to transpose. */
	return w>>libc.Int32FromInt32(32)&libc.Uint64FromUint32(0xFFFFFFFF) | w<<libc.Int32FromInt32(32)
}

/*
 *----------------------------------------------------------------------
 *
 * TclNokia770Doubles --
 *
 *	Transpose the two words of a number for Nokia 770 floating point
 *	handling.
 *
 *----------------------------------------------------------------------
 */

func XTclNokia770Doubles(tls *libc.TLS) (r int32) {
	return _n770_fp
}

const DBL_MAX2 = 0

/* Epoch of the tcl environment
 * (if changed with tcl-env). */

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * There are three classes of synchronization objects: mutexes, thread data
 * keys, and condition variables. The following are used to record the memory
 * used for these objects so they can be finalized.
 *
 * These statics are guarded by the mutex in the caller of
 * TclRememberThreadData, e.g., TclpThreadDataKeyInit
 */

type TSyncObjRecord = struct {
	Fnum  int32
	Fmax  int32
	Flist uintptr
}

var _keyRecord = TSyncObjRecord{}
var _mutexRecord = TSyncObjRecord{}
var _condRecord = TSyncObjRecord{}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetThreadData --
 *
 *	This function allocates and initializes a chunk of thread local
 *	storage.
 *
 * Results:
 *	A thread-specific pointer to the data structure.
 *
 * Side effects:
 *	Will allocate memory the first time this thread calls for this chunk
 *	of storage.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetThreadData(tls *libc.TLS, keyPtr uintptr, size TTcl_Size) (r uintptr) {
	/* Size of storage block */
	var result uintptr
	_ = result
	/*
	 * Initialize the key for this thread.
	 */
	result = XTclThreadStorageKeyGet(tls, keyPtr)
	if result == libc.UintptrFromInt32(0) {
		result = XTcl_Alloc(tls, libc.Uint64FromInt64(size))
		libc.Xmemset(tls, result, 0, libc.Uint64FromInt64(size))
		XTclThreadStorageKeySet(tls, keyPtr, result)
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * TclThreadDataKeyGet --
 *
 *	This function returns a pointer to a block of thread local storage.
 *
 * Results:
 *	A thread-specific pointer to the data structure, or NULL if the memory
 *	has not been assigned to this key for this thread.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclThreadDataKeyGet(tls *libc.TLS, keyPtr uintptr) (r uintptr) {
	/* Identifier for the data chunk. */
	return XTclThreadStorageKeyGet(tls, keyPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * RememberSyncObject
 *
 *	Keep a list of (mutexes/condition variable/data key) used during
 *	finalization.
 *
 *	Assume global lock is held.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Add to the appropriate list.
 *
 *----------------------------------------------------------------------
 */

func _RememberSyncObject(tls *libc.TLS, objPtr uintptr, recPtr uintptr) {
	/* Record of sync objects */
	var i, j, v3 int32
	var newList uintptr
	_, _, _, _ = i, j, newList, v3
	/*
	 * Reuse any free slot in the list.
	 */
	i = 0
	for {
		if !(i < (*TSyncObjRecord)(unsafe.Pointer(recPtr)).Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TSyncObjRecord)(unsafe.Pointer(recPtr)).Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			*(*uintptr)(unsafe.Pointer((*TSyncObjRecord)(unsafe.Pointer(recPtr)).Flist + uintptr(i)*8)) = objPtr
			return
		}
		goto _1
	_1:
		;
		i++
	}
	/*
	 * Grow the list of pointers if necessary, copying only non-NULL
	 * pointers to the new list.
	 */
	if (*TSyncObjRecord)(unsafe.Pointer(recPtr)).Fnum >= (*TSyncObjRecord)(unsafe.Pointer(recPtr)).Fmax {
		*(*int32)(unsafe.Pointer(recPtr + 4)) += int32(8)
		newList = XTcl_Alloc(tls, libc.Uint64FromInt32((*TSyncObjRecord)(unsafe.Pointer(recPtr)).Fmax)*uint64(8))
		i = 0
		j = libc.Int32FromInt32(0)
		for {
			if !(i < (*TSyncObjRecord)(unsafe.Pointer(recPtr)).Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TSyncObjRecord)(unsafe.Pointer(recPtr)).Flist + uintptr(i)*8)) != libc.UintptrFromInt32(0) {
				v3 = j
				j++
				*(*uintptr)(unsafe.Pointer(newList + uintptr(v3)*8)) = *(*uintptr)(unsafe.Pointer((*TSyncObjRecord)(unsafe.Pointer(recPtr)).Flist + uintptr(i)*8))
			}
			goto _2
		_2:
			;
			i++
		}
		if (*TSyncObjRecord)(unsafe.Pointer(recPtr)).Flist != libc.UintptrFromInt32(0) {
			XTclpFree(tls, (*TSyncObjRecord)(unsafe.Pointer(recPtr)).Flist)
		}
		(*TSyncObjRecord)(unsafe.Pointer(recPtr)).Flist = newList
		(*TSyncObjRecord)(unsafe.Pointer(recPtr)).Fnum = j
	}
	*(*uintptr)(unsafe.Pointer((*TSyncObjRecord)(unsafe.Pointer(recPtr)).Flist + uintptr((*TSyncObjRecord)(unsafe.Pointer(recPtr)).Fnum)*8)) = objPtr
	(*TSyncObjRecord)(unsafe.Pointer(recPtr)).Fnum++
}

/*
 *----------------------------------------------------------------------
 *
 * ForgetSyncObject
 *
 *	Remove a single object from the list.
 *	Assume global lock is held.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Remove from the appropriate list.
 *
 *----------------------------------------------------------------------
 */

func _ForgetSyncObject(tls *libc.TLS, objPtr uintptr, recPtr uintptr) {
	/* Record of sync objects */
	var i int32
	_ = i
	i = 0
	for {
		if !(i < (*TSyncObjRecord)(unsafe.Pointer(recPtr)).Fnum) {
			break
		}
		if objPtr == *(*uintptr)(unsafe.Pointer((*TSyncObjRecord)(unsafe.Pointer(recPtr)).Flist + uintptr(i)*8)) {
			*(*uintptr)(unsafe.Pointer((*TSyncObjRecord)(unsafe.Pointer(recPtr)).Flist + uintptr(i)*8)) = libc.UintptrFromInt32(0)
			return
		}
		goto _1
	_1:
		;
		i++
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclRememberMutex
 *
 *	Keep a list of mutexes used during finalization.
 *	Assume global lock is held.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Add to the mutex list.
 *
 *----------------------------------------------------------------------
 */

func XTclRememberMutex(tls *libc.TLS, mutexPtr uintptr) {
	_RememberSyncObject(tls, mutexPtr, uintptr(unsafe.Pointer(&_mutexRecord)))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_MutexFinalize --
 *
 *	Finalize a single mutex and remove it from the list of remembered
 *	objects.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Remove the mutex from the list.
 *
 *----------------------------------------------------------------------
 */

func XTcl_MutexFinalize(tls *libc.TLS, mutexPtr uintptr) {
	XTclpFinalizeMutex(tls, mutexPtr)
	XTclpGlobalLock(tls)
	_ForgetSyncObject(tls, mutexPtr, uintptr(unsafe.Pointer(&_mutexRecord)))
	XTclpGlobalUnlock(tls)
}

/*
 *----------------------------------------------------------------------
 *
 * TclRememberCondition
 *
 *	Keep a list of condition variables used during finalization.
 *	Assume global lock is held.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Add to the condition variable list.
 *
 *----------------------------------------------------------------------
 */

func XTclRememberCondition(tls *libc.TLS, condPtr uintptr) {
	_RememberSyncObject(tls, condPtr, uintptr(unsafe.Pointer(&_condRecord)))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ConditionFinalize --
 *
 *	Finalize a single condition variable and remove it from the list of
 *	remembered objects.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Remove the condition variable from the list.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ConditionFinalize(tls *libc.TLS, condPtr uintptr) {
	XTclpFinalizeCondition(tls, condPtr)
	XTclpGlobalLock(tls)
	_ForgetSyncObject(tls, condPtr, uintptr(unsafe.Pointer(&_condRecord)))
	XTclpGlobalUnlock(tls)
}

/*
 *----------------------------------------------------------------------
 *
 * TclFinalizeThreadData --
 *
 *	This function cleans up the thread-local storage. Secondary, it cleans
 *	thread alloc cache.
 *	This is called once for each thread before thread exits.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Frees up all thread local storage.
 *
 *----------------------------------------------------------------------
 */

func XTclFinalizeThreadData(tls *libc.TLS, quick int32) {
	XTclFinalizeThreadDataThread(tls)
	if !(quick != 0) {
		/*
		 * Quick exit principle makes it useless to terminate allocators
		 */
		XTclFinalizeThreadAllocThread(tls)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclFinalizeSynchronization --
 *
 *	This function cleans up all synchronization objects: mutexes,
 *	condition variables, and thread-local storage.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Frees up the memory.
 *
 *----------------------------------------------------------------------
 */

func XTclFinalizeSynchronization(tls *libc.TLS) {
	var blockPtr, condPtr, keyPtr, mutexPtr uintptr
	var i int32
	_, _, _, _, _ = blockPtr, condPtr, i, keyPtr, mutexPtr
	XTclpGlobalLock(tls)
	/*
	 * If we're running unthreaded, the TSD blocks are simply stored inside
	 * their thread data keys. Free them here.
	 */
	if _keyRecord.Flist != libc.UintptrFromInt32(0) {
		i = 0
		for {
			if !(i < _keyRecord.Fnum) {
				break
			}
			keyPtr = *(*uintptr)(unsafe.Pointer(_keyRecord.Flist + uintptr(i)*8))
			blockPtr = *(*TTcl_ThreadDataKey)(unsafe.Pointer(keyPtr))
			XTclpFree(tls, blockPtr)
			goto _1
		_1:
			;
			i++
		}
		XTclpFree(tls, _keyRecord.Flist)
		_keyRecord.Flist = libc.UintptrFromInt32(0)
	}
	_keyRecord.Fmax = 0
	_keyRecord.Fnum = 0
	/*
	 * Call thread storage global cleanup.
	 */
	XTclFinalizeThreadStorage(tls)
	i = 0
	for {
		if !(i < _mutexRecord.Fnum) {
			break
		}
		mutexPtr = *(*uintptr)(unsafe.Pointer(_mutexRecord.Flist + uintptr(i)*8))
		if mutexPtr != libc.UintptrFromInt32(0) {
			XTclpFinalizeMutex(tls, mutexPtr)
		}
		goto _2
	_2:
		;
		i++
	}
	if _mutexRecord.Flist != libc.UintptrFromInt32(0) {
		XTclpFree(tls, _mutexRecord.Flist)
		_mutexRecord.Flist = libc.UintptrFromInt32(0)
	}
	_mutexRecord.Fmax = 0
	_mutexRecord.Fnum = 0
	i = 0
	for {
		if !(i < _condRecord.Fnum) {
			break
		}
		condPtr = *(*uintptr)(unsafe.Pointer(_condRecord.Flist + uintptr(i)*8))
		if condPtr != libc.UintptrFromInt32(0) {
			XTclpFinalizeCondition(tls, condPtr)
		}
		goto _3
	_3:
		;
		i++
	}
	if _condRecord.Flist != libc.UintptrFromInt32(0) {
		XTclpFree(tls, _condRecord.Flist)
		_condRecord.Flist = libc.UintptrFromInt32(0)
	}
	_condRecord.Fmax = 0
	_condRecord.Fnum = 0
	XTclpGlobalUnlock(tls)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ExitThread --
 *
 *	This function is called to terminate the current thread. This should
 *	be used by extensions that create threads with additional interpreters
 *	in them.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	All thread exit handlers are invoked, then the thread dies.
 *
 *----------------------------------------------------------------------
 */
func XTcl_ExitThread(tls *libc.TLS, status int32) {
	XTcl_FinalizeThread(tls)
	XTclpThreadExit(tls, status)
}

const MAGIC = 239
const MAXALLOC = 0
const MINALLOC = 0
const NBUCKETS = 11
const NOBJALLOC = 800
const NOBJHIGH = 1200
const RCHECK = 0

/* Epoch of the tcl environment
 * (if changed with tcl-env). */

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * If range checking is enabled, an additional byte will be allocated to store
 * the magic number at the end of the requested memory.
 */

/*
 * The following define the number of Tcl_Obj's to allocate/move at a time and
 * the high water mark to prune a per-thread cache. On a 32 bit system,
 * sizeof(Tcl_Obj) = 24 so 800 * 24 = ~16k.
 */

/* Actual definition moved to tclInt.h */

/*
 * The following union stores accounting information for each block including
 * two small magic numbers and a bucket number when in use or a next pointer
 * when free. The original requested size (not including the Block overhead)
 * is also maintained.
 */

type TBlock = struct {
	Fpadding [0][16]uint8
	Fb       struct {
		Fu struct {
			Fs [0]struct {
				Fmagic1 uint8
				Fbucket uint8
				Funused uint8
				Fmagic2 uint8
			}
			Fnext uintptr
		}
		FreqSize Tsize_t
	}
}

/*
 * The following defines the minimum and maximum block sizes and the number
 * of buckets in the bucket cache.
 */

/*
 * The following structure defines a bucket of blocks with various accounting
 * and statistics information.
 */

type TBucket = struct {
	FfirstPtr      uintptr
	FlastPtr       uintptr
	FnumFree       Tsize_t
	FnumRemoves    Tsize_t
	FnumInserts    Tsize_t
	FnumLocks      Tsize_t
	FtotalAssigned Tsize_t
}

/*
 * The following structure defines a cache of buckets and objs, of which there
 * will be (at most) one per thread. Any changes need to be reflected in the
 * struct AllocCache defined in tclInt.h, possibly also in the initialisation
 * code in Tcl_CreateInterp().
 */

type TCache = struct {
	FnextPtr       uintptr
	Fowner         TTcl_ThreadId
	FfirstObjPtr   uintptr
	FnumObjects    Tsize_t
	FlastPtr       uintptr
	FtotalAssigned Tsize_t
	Fbuckets       [10]TBucket
}

/*
 * The following array specifies various per-bucket limits and locks. The
 * values are statically initialized to avoid calculating them repeatedly.
 */

var _bucketInfo [10]struct {
	FblockSize Tsize_t
	FmaxBlocks Tsize_t
	FnumMove   Tsize_t
	FlockPtr   uintptr
}

/*
 * Local variables defined in this file and initialized at startup.
 */

var _listLockPtr uintptr
var _objLockPtr uintptr
var _sharedCache TCache
var _sharedPtr = uintptr(unsafe.Pointer(&_sharedCache))
var _firstCachePtr = uintptr(unsafe.Pointer(&_sharedCache))

/*
 *----------------------------------------------------------------------
 *
 * GetCache ---
 *
 *	Gets per-thread memory cache, allocating it if necessary.
 *
 * Results:
 *	Pointer to cache.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _GetCache(tls *libc.TLS) (r uintptr) {
	var cachePtr, initLockPtr uintptr
	_, _ = cachePtr, initLockPtr
	/*
	 * Check for first-time initialization.
	 */
	if _listLockPtr == libc.UintptrFromInt32(0) {
		initLockPtr = XTcl_GetAllocMutex(tls)
		XTcl_MutexLock(tls, initLockPtr)
		if _listLockPtr == libc.UintptrFromInt32(0) {
			XTclInitThreadAlloc(tls)
		}
		XTcl_MutexUnlock(tls, initLockPtr)
	}
	/*
	 * Get this thread's cache, allocating if necessary.
	 */
	cachePtr = XTclpGetAllocCache(tls)
	if cachePtr == libc.UintptrFromInt32(0) {
		cachePtr = libc.Xmalloc(tls, uint64(608))
		if cachePtr == libc.UintptrFromInt32(0) {
			XTcl_Panic(tls, __ccgo_ts+67138, 0)
		}
		libc.Xmemset(tls, cachePtr, 0, uint64(608))
		XTcl_MutexLock(tls, _listLockPtr)
		(*TCache)(unsafe.Pointer(cachePtr)).FnextPtr = _firstCachePtr
		_firstCachePtr = cachePtr
		XTcl_MutexUnlock(tls, _listLockPtr)
		(*TCache)(unsafe.Pointer(cachePtr)).Fowner = XTcl_GetCurrentThread(tls)
		XTclpSetAllocCache(tls, cachePtr)
	}
	return cachePtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclFreeAllocCache --
 *
 *	Flush and delete a cache, removing from list of caches.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclFreeAllocCache(tls *libc.TLS, arg uintptr) {
	var bucket uint32
	var cachePtr, nextPtrPtr uintptr
	_, _, _ = bucket, cachePtr, nextPtrPtr
	cachePtr = arg
	/*
	 * Flush blocks.
	 */
	bucket = uint32(0)
	for {
		if !(uint64(bucket) < libc.Uint64FromInt32(11) - (libc.Uint64FromInt64(16)+libc.Uint64FromInt32(8)+(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1))) & ^(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)) >> libc.Int32FromInt32(5)) {
			break
		}
		if (*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FnumFree > uint64(0) {
			_PutBlocks(tls, cachePtr, libc.Int32FromUint32(bucket), (*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FnumFree)
		}
		goto _1
	_1:
		;
		bucket++
	}
	/*
	 * Flush objs.
	 */
	if (*TCache)(unsafe.Pointer(cachePtr)).FnumObjects > uint64(0) {
		_PutObjs(tls, cachePtr, (*TCache)(unsafe.Pointer(cachePtr)).FnumObjects)
	}
	/*
	 * Remove from pool list.
	 */
	XTcl_MutexLock(tls, _listLockPtr)
	nextPtrPtr = uintptr(unsafe.Pointer(&_firstCachePtr))
	for *(*uintptr)(unsafe.Pointer(nextPtrPtr)) != cachePtr {
		nextPtrPtr = *(*uintptr)(unsafe.Pointer(nextPtrPtr))
	}
	*(*uintptr)(unsafe.Pointer(nextPtrPtr)) = (*TCache)(unsafe.Pointer(cachePtr)).FnextPtr
	(*TCache)(unsafe.Pointer(cachePtr)).FnextPtr = libc.UintptrFromInt32(0)
	XTcl_MutexUnlock(tls, _listLockPtr)
	libc.Xfree(tls, cachePtr)
}

/*
 *----------------------------------------------------------------------
 *
 * TclpAlloc --
 *
 *	Allocate memory.
 *
 * Results:
 *	Pointer to memory just beyond Block pointer.
 *
 * Side effects:
 *	May allocate more blocks for a bucket.
 *
 *----------------------------------------------------------------------
 */

func XTclpAlloc(tls *libc.TLS, reqSize Tsize_t) (r uintptr) {
	var blockPtr, cachePtr uintptr
	var bucket int32
	var size Tsize_t
	_, _, _, _ = blockPtr, bucket, cachePtr, size
	cachePtr = XTclpGetAllocCache(tls)
	if cachePtr == libc.UintptrFromInt32(0) {
		cachePtr = _GetCache(tls)
	}
	/*
	 * Increment the requested size to include room for the Block structure.
	 * Call TclpSysAlloc() directly if the required amount is greater than the
	 * largest block, otherwise pop the smallest block large enough,
	 * allocating more blocks if necessary.
	 */
	blockPtr = libc.UintptrFromInt32(0)
	size = reqSize + uint64(16)
	if size > (libc.Uint64FromInt64(16)+libc.Uint64FromInt32(8)+(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1))) & ^(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)) << (libc.Uint64FromInt32(11) - (libc.Uint64FromInt64(16)+libc.Uint64FromInt32(8)+(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1))) & ^(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)) >> libc.Int32FromInt32(5) - libc.Uint64FromInt32(1)) {
		bucket = libc.Int32FromUint64(libc.Uint64FromInt32(11) - (libc.Uint64FromInt64(16)+libc.Uint64FromInt32(8)+(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1))) & ^(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)) >> libc.Int32FromInt32(5))
		blockPtr = libc.Xmalloc(tls, size)
		if blockPtr != libc.UintptrFromInt32(0) {
			*(*Tsize_t)(unsafe.Pointer(cachePtr + 40)) += reqSize
		}
	} else {
		bucket = 0
		for _bucketInfo[bucket].FblockSize < size {
			bucket++
		}
		if (*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FnumFree != 0 || _GetBlocks(tls, cachePtr, bucket) != 0 {
			blockPtr = (*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FfirstPtr
			(*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FfirstPtr = *(*uintptr)(unsafe.Pointer(blockPtr))
			(*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FnumFree--
			(*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FnumRemoves++
			(*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FtotalAssigned += reqSize
		}
	}
	if blockPtr == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	return _Block2Ptr(tls, blockPtr, bucket, reqSize)
}

/*
 *----------------------------------------------------------------------
 *
 * TclpFree --
 *
 *	Return blocks to the thread block cache.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	May move blocks to shared cache.
 *
 *----------------------------------------------------------------------
 */

func XTclpFree(tls *libc.TLS, ptr uintptr) {
	var blockPtr, cachePtr uintptr
	var bucket int32
	_, _, _ = blockPtr, bucket, cachePtr
	if ptr == libc.UintptrFromInt32(0) {
		return
	}
	cachePtr = XTclpGetAllocCache(tls)
	if cachePtr == libc.UintptrFromInt32(0) {
		cachePtr = _GetCache(tls)
	}
	/*
	 * Get the block back from the user pointer and call system free directly
	 * for large blocks. Otherwise, push the block back on the bucket and move
	 * blocks to the shared cache if there are now too many free.
	 */
	blockPtr = _Ptr2Block(tls, ptr)
	bucket = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(blockPtr + 1)))
	if libc.Uint64FromInt32(bucket) == libc.Uint64FromInt32(11) - (libc.Uint64FromInt64(16)+libc.Uint64FromInt32(8)+(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1))) & ^(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)) >> libc.Int32FromInt32(5) {
		*(*Tsize_t)(unsafe.Pointer(cachePtr + 40)) -= (*TBlock)(unsafe.Pointer(blockPtr)).Fb.FreqSize
		libc.Xfree(tls, blockPtr)
		return
	}
	(*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FtotalAssigned -= (*TBlock)(unsafe.Pointer(blockPtr)).Fb.FreqSize
	*(*uintptr)(unsafe.Pointer(blockPtr)) = (*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FfirstPtr
	(*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FfirstPtr = blockPtr
	if (*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FnumFree == uint64(0) {
		(*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FlastPtr = blockPtr
	}
	(*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FnumFree++
	(*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FnumInserts++
	if cachePtr != _sharedPtr && (*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FnumFree > _bucketInfo[bucket].FmaxBlocks {
		_PutBlocks(tls, cachePtr, bucket, _bucketInfo[bucket].FnumMove)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclpRealloc --
 *
 *	Re-allocate memory to a larger or smaller size.
 *
 * Results:
 *	Pointer to memory just beyond Block pointer.
 *
 * Side effects:
 *	Previous memory, if any, may be freed.
 *
 *----------------------------------------------------------------------
 */

func XTclpRealloc(tls *libc.TLS, ptr uintptr, reqSize Tsize_t) (r uintptr) {
	var blockPtr, cachePtr, newPtr uintptr
	var bucket int32
	var min, size Tsize_t
	_, _, _, _, _, _ = blockPtr, bucket, cachePtr, min, newPtr, size
	if ptr == libc.UintptrFromInt32(0) {
		return XTclpAlloc(tls, reqSize)
	}
	cachePtr = XTclpGetAllocCache(tls)
	if cachePtr == libc.UintptrFromInt32(0) {
		cachePtr = _GetCache(tls)
	}
	/*
	 * If the block is not a system block and fits in place, simply return the
	 * existing pointer. Otherwise, if the block is a system block and the new
	 * size would also require a system block, call TclpSysRealloc() directly.
	 */
	blockPtr = _Ptr2Block(tls, ptr)
	size = reqSize + uint64(16)
	bucket = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(blockPtr + 1)))
	if libc.Uint64FromInt32(bucket) != libc.Uint64FromInt32(11) - (libc.Uint64FromInt64(16)+libc.Uint64FromInt32(8)+(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1))) & ^(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)) >> libc.Int32FromInt32(5) {
		if bucket > 0 {
			min = _bucketInfo[bucket-int32(1)].FblockSize
		} else {
			min = uint64(0)
		}
		if size > min && size <= _bucketInfo[bucket].FblockSize {
			(*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FtotalAssigned -= (*TBlock)(unsafe.Pointer(blockPtr)).Fb.FreqSize
			(*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FtotalAssigned += reqSize
			return _Block2Ptr(tls, blockPtr, bucket, reqSize)
		}
	} else {
		if size > (libc.Uint64FromInt64(16)+libc.Uint64FromInt32(8)+(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1))) & ^(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)) << (libc.Uint64FromInt32(11) - (libc.Uint64FromInt64(16)+libc.Uint64FromInt32(8)+(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1))) & ^(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)) >> libc.Int32FromInt32(5) - libc.Uint64FromInt32(1)) {
			*(*Tsize_t)(unsafe.Pointer(cachePtr + 40)) -= (*TBlock)(unsafe.Pointer(blockPtr)).Fb.FreqSize
			*(*Tsize_t)(unsafe.Pointer(cachePtr + 40)) += reqSize
			blockPtr = libc.Xrealloc(tls, blockPtr, size)
			if blockPtr == libc.UintptrFromInt32(0) {
				return libc.UintptrFromInt32(0)
			}
			return _Block2Ptr(tls, blockPtr, libc.Int32FromUint64(libc.Uint64FromInt32(11) - (libc.Uint64FromInt64(16)+libc.Uint64FromInt32(8)+(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1))) & ^(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)) >> libc.Int32FromInt32(5)), reqSize)
		}
	}
	/*
	 * Finally, perform an expensive malloc/copy/free.
	 */
	newPtr = XTclpAlloc(tls, reqSize)
	if newPtr != libc.UintptrFromInt32(0) {
		if reqSize > (*TBlock)(unsafe.Pointer(blockPtr)).Fb.FreqSize {
			reqSize = (*TBlock)(unsafe.Pointer(blockPtr)).Fb.FreqSize
		}
		libc.Xmemcpy(tls, newPtr, ptr, reqSize)
		XTclpFree(tls, ptr)
	}
	return newPtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclThreadAllocObj --
 *
 *	Allocate a Tcl_Obj from the per-thread cache.
 *
 * Results:
 *	Pointer to uninitialized Tcl_Obj.
 *
 * Side effects:
 *	May move Tcl_Obj's from shared cached or allocate new Tcl_Obj's if
 *	list is empty.
 *
 * Note:
 *	If this code is updated, the changes need to be reflected in the macro
 *	TclAllocObjStorageEx() defined in tclInt.h
 *
 *----------------------------------------------------------------------
 */

func XTclThreadAllocObj(tls *libc.TLS) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var cachePtr, newObjsPtr, objPtr uintptr
	var numMove, v1, v2 Tsize_t
	_, _, _, _, _, _ = cachePtr, newObjsPtr, numMove, objPtr, v1, v2
	cachePtr = XTclpGetAllocCache(tls)
	if cachePtr == libc.UintptrFromInt32(0) {
		cachePtr = _GetCache(tls)
	}
	/*
	 * Get this thread's obj list structure and move or allocate new objs if
	 * necessary.
	 */
	if (*TCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) {
		XTcl_MutexLock(tls, _objLockPtr)
		numMove = (*TCache)(unsafe.Pointer(_sharedPtr)).FnumObjects
		if numMove > uint64(0) {
			if numMove > uint64(NOBJALLOC) {
				numMove = uint64(NOBJALLOC)
			}
			_MoveObjs(tls, _sharedPtr, cachePtr, numMove)
		}
		XTcl_MutexUnlock(tls, _objLockPtr)
		if (*TCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) {
			v1 = libc.Uint64FromInt32(NOBJALLOC)
			numMove = v1
			(*TCache)(unsafe.Pointer(cachePtr)).FnumObjects = v1
			newObjsPtr = libc.Xmalloc(tls, uint64(48)*numMove)
			if newObjsPtr == libc.UintptrFromInt32(0) {
				XTcl_Panic(tls, __ccgo_ts+67174, libc.VaList(bp+8, numMove))
			}
			(*TCache)(unsafe.Pointer(cachePtr)).FlastPtr = newObjsPtr + uintptr(numMove)*48 - uintptr(1)*48
			objPtr = (*TCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr /* NULL */
			for {
				v2 = numMove
				numMove--
				if !(v2 > uint64(0)) {
					break
				}
				*(*uintptr)(unsafe.Pointer(newObjsPtr + uintptr(numMove)*48 + 32)) = objPtr
				objPtr = newObjsPtr + uintptr(numMove)*48
			}
			(*TCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = newObjsPtr
		}
	}
	/*
	 * Pop the first object.
	 */
	objPtr = (*TCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
	(*TCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1
	(*TCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	return objPtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclThreadFreeObj --
 *
 *	Return a free Tcl_Obj to the per-thread cache.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	May move free Tcl_Obj's to shared list upon hitting high water mark.
 *
 * Note:
 *	If this code is updated, the changes need to be reflected in the macro
 *	TclAllocObjStorageEx() defined in tclInt.h
 *
 *----------------------------------------------------------------------
 */

func XTclThreadFreeObj(tls *libc.TLS, objPtr uintptr) {
	var cachePtr uintptr
	_ = cachePtr
	cachePtr = XTclpGetAllocCache(tls)
	if cachePtr == libc.UintptrFromInt32(0) {
		cachePtr = _GetCache(tls)
	}
	/*
	 * Get this thread's list and push on the free Tcl_Obj.
	 */
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1 = (*TCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
	(*TCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = objPtr
	if (*TCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) {
		(*TCache)(unsafe.Pointer(cachePtr)).FlastPtr = objPtr
	}
	(*TCache)(unsafe.Pointer(cachePtr)).FnumObjects++
	/*
	 * If the number of free objects has exceeded the high water mark, move
	 * some blocks to the shared list.
	 */
	if (*TCache)(unsafe.Pointer(cachePtr)).FnumObjects > uint64(ALLOC_NOBJHIGH) {
		_PutObjs(tls, cachePtr, uint64(NOBJALLOC))
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetMemoryInfo --
 *
 *	Return a list-of-lists of memory stats.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	List appended to given dstring.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetMemoryInfo(tls *libc.TLS, dsPtr uintptr) {
	bp := tls.Alloc(256)
	defer tls.Free(256)
	var cachePtr uintptr
	var n uint32
	var _ /* buf at bp+0 */ [200]uint8
	_, _ = cachePtr, n
	XTcl_MutexLock(tls, _listLockPtr)
	cachePtr = _firstCachePtr
	for cachePtr != libc.UintptrFromInt32(0) {
		XTcl_DStringStartSublist(tls, dsPtr)
		if cachePtr == _sharedPtr {
			XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+67216)
		} else {
			libc.X__builtin_snprintf(tls, bp, uint64(200), __ccgo_ts+67223, libc.VaList(bp+208, (*TCache)(unsafe.Pointer(cachePtr)).Fowner))
			XTcl_DStringAppendElement(tls, dsPtr, bp)
		}
		n = uint32(0)
		for {
			if !(uint64(n) < libc.Uint64FromInt32(11) - (libc.Uint64FromInt64(16)+libc.Uint64FromInt32(8)+(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1))) & ^(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)) >> libc.Int32FromInt32(5)) {
				break
			}
			libc.X__builtin_snprintf(tls, bp, uint64(200), __ccgo_ts+67232, libc.VaList(bp+208, _bucketInfo[n].FblockSize, (*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(n)*56))).FnumFree, (*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(n)*56))).FnumRemoves, (*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(n)*56))).FnumInserts, (*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(n)*56))).FtotalAssigned, (*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(n)*56))).FnumLocks))
			XTcl_DStringAppendElement(tls, dsPtr, bp)
			goto _1
		_1:
			;
			n++
		}
		XTcl_DStringEndSublist(tls, dsPtr)
		cachePtr = (*TCache)(unsafe.Pointer(cachePtr)).FnextPtr
	}
	XTcl_MutexUnlock(tls, _listLockPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * MoveObjs --
 *
 *	Move Tcl_Obj's between caches.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _MoveObjs(tls *libc.TLS, fromPtr uintptr, toPtr uintptr, numMove Tsize_t) {
	var fromFirstObjPtr, objPtr uintptr
	var v1 Tsize_t
	_, _, _ = fromFirstObjPtr, objPtr, v1
	objPtr = (*TCache)(unsafe.Pointer(fromPtr)).FfirstObjPtr
	fromFirstObjPtr = objPtr
	*(*Tsize_t)(unsafe.Pointer(toPtr + 24)) += numMove
	*(*Tsize_t)(unsafe.Pointer(fromPtr + 24)) -= numMove
	/*
	 * Find the last object to be moved; set the next one (the first one not
	 * to be moved) as the first object in the 'from' cache.
	 */
	for {
		v1 = numMove
		numMove--
		if !(v1 > uint64(1)) {
			break
		}
		objPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
	}
	(*TCache)(unsafe.Pointer(fromPtr)).FfirstObjPtr = (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1
	/*
	 * Move all objects as a block - they are already linked to each other, we
	 * just have to update the first and last.
	 */
	(*TCache)(unsafe.Pointer(toPtr)).FlastPtr = objPtr
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(objPtr + 32))).Fptr1 = (*TCache)(unsafe.Pointer(toPtr)).FfirstObjPtr /* NULL */
	(*TCache)(unsafe.Pointer(toPtr)).FfirstObjPtr = fromFirstObjPtr
}

/*
 *----------------------------------------------------------------------
 *
 * PutObjs --
 *
 *	Move Tcl_Obj's from thread cache to shared cache.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _PutObjs(tls *libc.TLS, fromPtr uintptr, numMove Tsize_t) {
	var firstPtr, lastPtr uintptr
	var keep, v1 Tsize_t
	_, _, _, _ = firstPtr, keep, lastPtr, v1
	keep = (*TCache)(unsafe.Pointer(fromPtr)).FnumObjects - numMove
	lastPtr = libc.UintptrFromInt32(0)
	(*TCache)(unsafe.Pointer(fromPtr)).FnumObjects = keep
	firstPtr = (*TCache)(unsafe.Pointer(fromPtr)).FfirstObjPtr
	if keep == uint64(0) {
		(*TCache)(unsafe.Pointer(fromPtr)).FfirstObjPtr = libc.UintptrFromInt32(0)
	} else {
		for {
			lastPtr = firstPtr
			firstPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(firstPtr + 32))).Fptr1
			goto _2
		_2:
			;
			v1 = keep
			keep--
			if !(v1 > uint64(1)) {
				break
			}
		}
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(lastPtr + 32))).Fptr1 = libc.UintptrFromInt32(0)
	}
	/*
	 * Move all objects as a block - they are already linked to each other, we
	 * just have to update the first and last.
	 */
	XTcl_MutexLock(tls, _objLockPtr)
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer((*TCache)(unsafe.Pointer(fromPtr)).FlastPtr + 32))).Fptr1 = (*TCache)(unsafe.Pointer(_sharedPtr)).FfirstObjPtr
	(*TCache)(unsafe.Pointer(_sharedPtr)).FfirstObjPtr = firstPtr
	if (*TCache)(unsafe.Pointer(_sharedPtr)).FnumObjects == uint64(0) {
		(*TCache)(unsafe.Pointer(_sharedPtr)).FlastPtr = (*TCache)(unsafe.Pointer(fromPtr)).FlastPtr
	}
	*(*Tsize_t)(unsafe.Pointer(_sharedPtr + 24)) += numMove
	XTcl_MutexUnlock(tls, _objLockPtr)
	(*TCache)(unsafe.Pointer(fromPtr)).FlastPtr = lastPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Block2Ptr, Ptr2Block --
 *
 *	Convert between internal blocks and user pointers.
 *
 * Results:
 *	User pointer or internal block.
 *
 * Side effects:
 *	Invalid blocks will abort the server.
 *
 *----------------------------------------------------------------------
 */

func _Block2Ptr(tls *libc.TLS, blockPtr uintptr, bucket int32, reqSize Tsize_t) (r uintptr) {
	var ptr uintptr
	var v1 uint8
	_, _ = ptr, v1
	v1 = libc.Uint8FromInt32(MAGIC)
	*(*uint8)(unsafe.Pointer(blockPtr + 3)) = v1
	*(*uint8)(unsafe.Pointer(blockPtr)) = v1
	*(*uint8)(unsafe.Pointer(blockPtr + 1)) = libc.Uint8FromInt32(bucket)
	(*TBlock)(unsafe.Pointer(blockPtr)).Fb.FreqSize = reqSize
	ptr = blockPtr + libc.UintptrFromInt32(1)*16
	return ptr
}

func _Ptr2Block(tls *libc.TLS, ptr uintptr) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var blockPtr uintptr
	_ = blockPtr
	blockPtr = ptr - libc.UintptrFromInt32(1)*16
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(blockPtr))) != int32(MAGIC) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(blockPtr + 3))) != int32(MAGIC) {
		XTcl_Panic(tls, __ccgo_ts+67256, libc.VaList(bp+8, blockPtr, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(blockPtr))), libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(blockPtr + 3)))))
	}
	return blockPtr
}

/*
 *----------------------------------------------------------------------
 *
 * LockBucket, UnlockBucket --
 *
 *	Set/unset the lock to access a bucket in the shared cache.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Lock activity and contention are monitored globally and on a per-cache
 *	basis.
 *
 *----------------------------------------------------------------------
 */

func _LockBucket(tls *libc.TLS, cachePtr uintptr, bucket int32) {
	XTcl_MutexLock(tls, _bucketInfo[bucket].FlockPtr)
	(*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FnumLocks++
	(*(*TBucket)(unsafe.Pointer(_sharedPtr + 48 + uintptr(bucket)*56))).FnumLocks++
}

func _UnlockBucket(tls *libc.TLS, dummy848 uintptr, bucket int32) {
	XTcl_MutexUnlock(tls, _bucketInfo[bucket].FlockPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * PutBlocks --
 *
 *	Return unused blocks to the shared cache.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _PutBlocks(tls *libc.TLS, cachePtr uintptr, bucket int32, numMove Tsize_t) {
	var firstPtr, lastPtr uintptr
	var keep, v1 Tsize_t
	_, _, _, _ = firstPtr, keep, lastPtr, v1
	/*
	 * We have numFree.  Want to shed numMove. So compute how many
	 * Blocks to keep.
	 */
	keep = (*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FnumFree - numMove
	lastPtr = libc.UintptrFromInt32(0)
	(*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FnumFree = keep
	firstPtr = (*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FfirstPtr
	if keep == uint64(0) {
		(*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FfirstPtr = libc.UintptrFromInt32(0)
	} else {
		for {
			lastPtr = firstPtr
			firstPtr = *(*uintptr)(unsafe.Pointer(firstPtr))
			goto _2
		_2:
			;
			v1 = keep
			keep--
			if !(v1 > uint64(1)) {
				break
			}
		}
		*(*uintptr)(unsafe.Pointer(lastPtr)) = libc.UintptrFromInt32(0)
	}
	/*
	 * Aquire the lock and place the list of blocks at the front of the shared
	 * cache bucket.
	 */
	_LockBucket(tls, cachePtr, bucket)
	*(*uintptr)(unsafe.Pointer((*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FlastPtr)) = (*(*TBucket)(unsafe.Pointer(_sharedPtr + 48 + uintptr(bucket)*56))).FfirstPtr
	(*(*TBucket)(unsafe.Pointer(_sharedPtr + 48 + uintptr(bucket)*56))).FfirstPtr = firstPtr
	if (*(*TBucket)(unsafe.Pointer(_sharedPtr + 48 + uintptr(bucket)*56))).FnumFree == uint64(0) {
		(*(*TBucket)(unsafe.Pointer(_sharedPtr + 48 + uintptr(bucket)*56))).FlastPtr = (*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FlastPtr
	}
	(*(*TBucket)(unsafe.Pointer(_sharedPtr + 48 + uintptr(bucket)*56))).FnumFree += numMove
	_UnlockBucket(tls, cachePtr, bucket)
	(*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FlastPtr = lastPtr
}

/*
 *----------------------------------------------------------------------
 *
 * GetBlocks --
 *
 *	Get more blocks for a bucket.
 *
 * Results:
 *	1 if blocks where allocated, 0 otherwise.
 *
 * Side effects:
 *	Cache may be filled with available blocks.
 *
 *----------------------------------------------------------------------
 */

func _GetBlocks(tls *libc.TLS, cachePtr uintptr, bucket int32) (r int32) {
	var blockPtr uintptr
	var n, size, v1, v2, v3 Tsize_t
	_, _, _, _, _, _ = blockPtr, n, size, v1, v2, v3
	/*
	 * First, attempt to move blocks from the shared cache. Note the
	 * potentially dirty read of numFree before acquiring the lock which is a
	 * slight performance enhancement. The value is verified after the lock is
	 * actually acquired.
	 */
	if cachePtr != _sharedPtr && (*(*TBucket)(unsafe.Pointer(_sharedPtr + 48 + uintptr(bucket)*56))).FnumFree > uint64(0) {
		_LockBucket(tls, cachePtr, bucket)
		if (*(*TBucket)(unsafe.Pointer(_sharedPtr + 48 + uintptr(bucket)*56))).FnumFree > uint64(0) {
			/*
			 * Either move the entire list or walk the list to find the last
			 * block to move.
			 */
			n = _bucketInfo[bucket].FnumMove
			if n >= (*(*TBucket)(unsafe.Pointer(_sharedPtr + 48 + uintptr(bucket)*56))).FnumFree {
				(*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FfirstPtr = (*(*TBucket)(unsafe.Pointer(_sharedPtr + 48 + uintptr(bucket)*56))).FfirstPtr
				(*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FlastPtr = (*(*TBucket)(unsafe.Pointer(_sharedPtr + 48 + uintptr(bucket)*56))).FlastPtr
				(*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FnumFree = (*(*TBucket)(unsafe.Pointer(_sharedPtr + 48 + uintptr(bucket)*56))).FnumFree
				(*(*TBucket)(unsafe.Pointer(_sharedPtr + 48 + uintptr(bucket)*56))).FfirstPtr = libc.UintptrFromInt32(0)
				(*(*TBucket)(unsafe.Pointer(_sharedPtr + 48 + uintptr(bucket)*56))).FnumFree = uint64(0)
			} else {
				blockPtr = (*(*TBucket)(unsafe.Pointer(_sharedPtr + 48 + uintptr(bucket)*56))).FfirstPtr
				(*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FfirstPtr = blockPtr
				(*(*TBucket)(unsafe.Pointer(_sharedPtr + 48 + uintptr(bucket)*56))).FnumFree -= n
				(*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FnumFree = n
				for {
					v1 = n
					n--
					if !(v1 > uint64(1)) {
						break
					}
					blockPtr = *(*uintptr)(unsafe.Pointer(blockPtr))
				}
				(*(*TBucket)(unsafe.Pointer(_sharedPtr + 48 + uintptr(bucket)*56))).FfirstPtr = *(*uintptr)(unsafe.Pointer(blockPtr))
				(*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FlastPtr = blockPtr
				*(*uintptr)(unsafe.Pointer(blockPtr)) = libc.UintptrFromInt32(0)
			}
		}
		_UnlockBucket(tls, cachePtr, bucket)
	}
	if (*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FnumFree == uint64(0) {
		/*
		 * If no blocks could be moved from shared, first look for a larger
		 * block in this cache to split up.
		 */
		blockPtr = libc.UintptrFromInt32(0)
		n = libc.Uint64FromInt32(11) - (libc.Uint64FromInt64(16)+libc.Uint64FromInt32(8)+(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1))) & ^(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)) >> libc.Int32FromInt32(5)
		size = uint64(0)
		for {
			v2 = n
			n--
			if !(v2 > libc.Uint64FromInt32(bucket)+uint64(1)) {
				break
			}
			if (*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(n)*56))).FnumFree > uint64(0) {
				size = _bucketInfo[n].FblockSize
				blockPtr = (*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(n)*56))).FfirstPtr
				(*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(n)*56))).FfirstPtr = *(*uintptr)(unsafe.Pointer(blockPtr))
				(*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(n)*56))).FnumFree--
				break
			}
		}
		/*
		 * Otherwise, allocate a big new block directly.
		 */
		if blockPtr == libc.UintptrFromInt32(0) {
			size = (libc.Uint64FromInt64(16) + libc.Uint64FromInt32(8) + (libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8) - libc.Uint64FromInt32(1))) & ^(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8) - libc.Uint64FromInt32(1)) << (libc.Uint64FromInt32(11) - (libc.Uint64FromInt64(16)+libc.Uint64FromInt32(8)+(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1))) & ^(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)) >> libc.Int32FromInt32(5) - libc.Uint64FromInt32(1))
			blockPtr = libc.Xmalloc(tls, size)
			if blockPtr == libc.UintptrFromInt32(0) {
				return 0
			}
		}
		/*
		 * Split the larger block into smaller blocks for this bucket.
		 */
		n = size / _bucketInfo[bucket].FblockSize
		(*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FnumFree = n
		(*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FfirstPtr = blockPtr
		for {
			v3 = n
			n--
			if !(v3 > uint64(1)) {
				break
			}
			*(*uintptr)(unsafe.Pointer(blockPtr)) = blockPtr + uintptr(_bucketInfo[bucket].FblockSize)
			blockPtr = *(*uintptr)(unsafe.Pointer(blockPtr))
		}
		(*(*TBucket)(unsafe.Pointer(cachePtr + 48 + uintptr(bucket)*56))).FlastPtr = blockPtr
		*(*uintptr)(unsafe.Pointer(blockPtr)) = libc.UintptrFromInt32(0)
	}
	return int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * TclInitThreadAlloc --
 *
 *	Initializes the allocator cache-maintenance structures.
 *      It is done early and protected during the Tcl_InitSubsystems().
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclInitThreadAlloc(tls *libc.TLS) {
	var i uint32
	var v2 uint64
	_, _ = i, v2
	_listLockPtr = XTclpNewAllocMutex(tls)
	_objLockPtr = XTclpNewAllocMutex(tls)
	i = uint32(0)
	for {
		if !(uint64(i) < libc.Uint64FromInt32(11) - (libc.Uint64FromInt64(16)+libc.Uint64FromInt32(8)+(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1))) & ^(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)) >> libc.Int32FromInt32(5)) {
			break
		}
		_bucketInfo[i].FblockSize = (libc.Uint64FromInt64(16) + libc.Uint64FromInt32(8) + (libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8) - libc.Uint64FromInt32(1))) & ^(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8) - libc.Uint64FromInt32(1)) << i
		_bucketInfo[i].FmaxBlocks = libc.Uint64FromInt32(1) << (libc.Uint64FromInt32(11) - (libc.Uint64FromInt64(16)+libc.Uint64FromInt32(8)+(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1))) & ^(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)) >> libc.Int32FromInt32(5) - libc.Uint64FromInt32(1) - uint64(i))
		if uint64(i) < libc.Uint64FromInt32(11) - (libc.Uint64FromInt64(16)+libc.Uint64FromInt32(8)+(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1))) & ^(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)) >> libc.Int32FromInt32(5) - libc.Uint64FromInt32(1) {
			v2 = libc.Uint64FromInt32(1) << (libc.Uint64FromInt32(11) - (libc.Uint64FromInt64(16)+libc.Uint64FromInt32(8)+(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1))) & ^(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)) >> libc.Int32FromInt32(5) - libc.Uint64FromInt32(2) - uint64(i))
		} else {
			v2 = uint64(1)
		}
		_bucketInfo[i].FnumMove = v2
		_bucketInfo[i].FlockPtr = XTclpNewAllocMutex(tls)
		goto _1
	_1:
		;
		i++
	}
	XTclpInitAllocCache(tls)
}

/*
 *----------------------------------------------------------------------
 *
 * TclFinalizeThreadAlloc --
 *
 *	This procedure is used to destroy all private resources used in this
 *	file.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclFinalizeThreadAlloc(tls *libc.TLS) {
	var i uint32
	_ = i
	i = uint32(0)
	for {
		if !(uint64(i) < libc.Uint64FromInt32(11) - (libc.Uint64FromInt64(16)+libc.Uint64FromInt32(8)+(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1))) & ^(libc.Uint64FromInt32(2)*libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)) >> libc.Int32FromInt32(5)) {
			break
		}
		XTclpFreeAllocMutex(tls, _bucketInfo[i].FlockPtr)
		_bucketInfo[i].FlockPtr = libc.UintptrFromInt32(0)
		goto _1
	_1:
		;
		i++
	}
	XTclpFreeAllocMutex(tls, _objLockPtr)
	_objLockPtr = libc.UintptrFromInt32(0)
	XTclpFreeAllocMutex(tls, _listLockPtr)
	_listLockPtr = libc.UintptrFromInt32(0)
	XTclpFreeAllocCache(tls, libc.UintptrFromInt32(0))
}

/*
 *----------------------------------------------------------------------
 *
 * TclFinalizeThreadAllocThread --
 *
 *	This procedure is used to destroy single thread private resources
 *	defined in this file. Called either during Tcl_FinalizeThread() or
 *	Tcl_Finalize().
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclFinalizeThreadAllocThread(tls *libc.TLS) {
	var cachePtr uintptr
	_ = cachePtr
	cachePtr = XTclpGetAllocCache(tls)
	if cachePtr != libc.UintptrFromInt32(0) {
		XTclpFreeAllocCache(tls, cachePtr)
	}
}

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * IMPLEMENTATION NOTES:
 *
 * The primary idea is that we create one platform-specific TSD slot, and use
 * it for storing a table pointer. Each Tcl_ThreadDataKey has an offset into
 * the table of TSD values. We don't use more than 1 platform-specific TSD
 * slot, because there is a hard limit on the number of TSD slots. Valid key
 * offsets are greater than 0; 0 is for the initialized Tcl_ThreadDataKey.
 */

/*
 * The global collection of information about TSDs. This is shared across the
 * whole process, and includes the mutex used to protect it.
 */

var _tsdGlobal = struct {
	Fkey     uintptr
	Fcounter Tsig_atomic_t
	Fmutex   TTcl_Mutex
}{}

/*
 * The type of the data held per thread in a system TSD.
 */

type TTSDTable = struct {
	FtablePtr  uintptr
	Fallocated Tsig_atomic_t
}

/*
 * The actual type of Tcl_ThreadDataKey.
 */

type TTSDUnion = struct {
	Fptr         [0]uintptr
	Foffset      Tsig_atomic_t
	F__ccgo_pad2 [4]byte
}

/*
 * Allocator and deallocator for a TSDTable structure.
 */

func _TSDTableCreate(tls *libc.TLS) (r uintptr) {
	var i Tsig_atomic_t
	var tsdTablePtr uintptr
	_, _ = i, tsdTablePtr
	tsdTablePtr = libc.Xmalloc(tls, uint64(16))
	if tsdTablePtr == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+67288, 0)
	}
	(*TTSDTable)(unsafe.Pointer(tsdTablePtr)).Fallocated = int32(8)
	(*TTSDTable)(unsafe.Pointer(tsdTablePtr)).FtablePtr = libc.Xmalloc(tls, uint64(8)*libc.Uint64FromInt32((*TTSDTable)(unsafe.Pointer(tsdTablePtr)).Fallocated))
	if (*TTSDTable)(unsafe.Pointer(tsdTablePtr)).FtablePtr == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+67288, 0)
	}
	i = 0
	for {
		if !(i < (*TTSDTable)(unsafe.Pointer(tsdTablePtr)).Fallocated) {
			break
		}
		*(*uintptr)(unsafe.Pointer((*TTSDTable)(unsafe.Pointer(tsdTablePtr)).FtablePtr + uintptr(i)*8)) = libc.UintptrFromInt32(0)
		goto _1
	_1:
		;
		i++
	}
	return tsdTablePtr
}

func _TSDTableDelete(tls *libc.TLS, tsdTablePtr uintptr) {
	var i Tsig_atomic_t
	_ = i
	i = 0
	for {
		if !(i < (*TTSDTable)(unsafe.Pointer(tsdTablePtr)).Fallocated) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TTSDTable)(unsafe.Pointer(tsdTablePtr)).FtablePtr + uintptr(i)*8)) != libc.UintptrFromInt32(0) {
			/*
			 * These values were allocated in Tcl_GetThreadData in tclThread.c
			 * and must now be deallocated or they will leak.
			 */
			XTclpFree(tls, *(*uintptr)(unsafe.Pointer((*TTSDTable)(unsafe.Pointer(tsdTablePtr)).FtablePtr + uintptr(i)*8)))
		}
		goto _1
	_1:
		;
		i++
	}
	libc.Xfree(tls, (*TTSDTable)(unsafe.Pointer(tsdTablePtr)).FtablePtr)
	libc.Xfree(tls, tsdTablePtr)
}

/*
 *----------------------------------------------------------------------
 *
 * TSDTableGrow --
 *
 *	This procedure makes the passed TSDTable grow to fit the atLeast
 *	value.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The table is enlarged.
 *
 *----------------------------------------------------------------------
 */

func _TSDTableGrow(tls *libc.TLS, tsdTablePtr uintptr, atLeast Tsig_atomic_t) {
	var i, newAllocated Tsig_atomic_t
	var newTablePtr uintptr
	_, _, _ = i, newAllocated, newTablePtr
	newAllocated = (*TTSDTable)(unsafe.Pointer(tsdTablePtr)).Fallocated * int32(2)
	if newAllocated <= atLeast {
		newAllocated = atLeast + int32(10)
	}
	newTablePtr = libc.Xrealloc(tls, (*TTSDTable)(unsafe.Pointer(tsdTablePtr)).FtablePtr, uint64(8)*libc.Uint64FromInt32(newAllocated))
	if newTablePtr == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+67316, 0)
	}
	i = (*TTSDTable)(unsafe.Pointer(tsdTablePtr)).Fallocated
	for {
		if !(i < newAllocated) {
			break
		}
		*(*uintptr)(unsafe.Pointer(newTablePtr + uintptr(i)*8)) = libc.UintptrFromInt32(0)
		goto _1
	_1:
		;
		i++
	}
	(*TTSDTable)(unsafe.Pointer(tsdTablePtr)).Fallocated = newAllocated
	(*TTSDTable)(unsafe.Pointer(tsdTablePtr)).FtablePtr = newTablePtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclThreadStorageKeyGet --
 *
 *    This procedure gets the value associated with the passed key.
 *
 * Results:
 *	A pointer value associated with the Tcl_ThreadDataKey or NULL.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclThreadStorageKeyGet(tls *libc.TLS, dataKeyPtr uintptr) (r uintptr) {
	var keyPtr, resultPtr, tsdTablePtr uintptr
	var offset Tsig_atomic_t
	_, _, _, _ = keyPtr, offset, resultPtr, tsdTablePtr
	tsdTablePtr = XTclpThreadGetGlobalTSD(tls, _tsdGlobal.Fkey)
	resultPtr = libc.UintptrFromInt32(0)
	keyPtr = dataKeyPtr
	offset = libc.AtomicLoadPInt32(keyPtr)
	if tsdTablePtr != libc.UintptrFromInt32(0) && offset > 0 && offset < (*TTSDTable)(unsafe.Pointer(tsdTablePtr)).Fallocated {
		resultPtr = *(*uintptr)(unsafe.Pointer((*TTSDTable)(unsafe.Pointer(tsdTablePtr)).FtablePtr + uintptr(offset)*8))
	}
	return resultPtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclThreadStorageKeySet --
 *
 *	This procedure set an association of value with the key passed. The
 *	associated value may be retrieved with TclThreadDataKeyGet().
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The thread-specific table may be created or reallocated.
 *
 *----------------------------------------------------------------------
 */

func XTclThreadStorageKeySet(tls *libc.TLS, dataKeyPtr uintptr, value uintptr) {
	var keyPtr, tsdTablePtr, v2 uintptr
	var v1 Tsig_atomic_t
	_, _, _, _ = keyPtr, tsdTablePtr, v1, v2
	tsdTablePtr = XTclpThreadGetGlobalTSD(tls, _tsdGlobal.Fkey)
	keyPtr = dataKeyPtr
	if tsdTablePtr == libc.UintptrFromInt32(0) {
		tsdTablePtr = _TSDTableCreate(tls)
		XTclpThreadSetGlobalTSD(tls, _tsdGlobal.Fkey, tsdTablePtr)
	}
	/*
	 * Get the lock while we check if this TSD is new or not. Note that this
	 * is the only place where Tcl_ThreadDataKey values are set. We use a
	 * double-checked lock to try to avoid having to grab this lock a lot,
	 * since it is on quite a few critical paths and will only get set once in
	 * each location.
	 */
	if libc.AtomicLoadPInt32(keyPtr) == 0 {
		XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_tsdGlobal))+16)
		if libc.AtomicLoadPInt32(keyPtr) == 0 {
			/*
			 * The Tcl_ThreadDataKey hasn't been used yet. Make a new one.
			 */
			v2 = uintptr(unsafe.Pointer(&_tsdGlobal)) + 8
			*(*Tsig_atomic_t)(unsafe.Pointer(v2))++
			v1 = *(*Tsig_atomic_t)(unsafe.Pointer(v2))
			libc.AtomicStorePInt32(keyPtr, v1)
		}
		XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_tsdGlobal))+16)
	}
	/*
	 * Check if this is the first time this Tcl_ThreadDataKey has been used
	 * with the current thread. Note that we don't need to hold a lock when
	 * doing this, as we are *definitely* the only point accessing this
	 * tsdTablePtr right now; it's thread-local.
	 */
	if libc.AtomicLoadPInt32(keyPtr) >= (*TTSDTable)(unsafe.Pointer(tsdTablePtr)).Fallocated {
		_TSDTableGrow(tls, tsdTablePtr, libc.AtomicLoadPInt32(keyPtr))
	}
	/*
	 * Set the value in the Tcl thread-local variable.
	 */
	*(*uintptr)(unsafe.Pointer((*TTSDTable)(unsafe.Pointer(tsdTablePtr)).FtablePtr + uintptr(libc.AtomicLoadPInt32(keyPtr))*8)) = value
}

/*
 *----------------------------------------------------------------------
 *
 * TclFinalizeThreadDataThread --
 *
 *	This procedure finalizes the data for a single thread.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The TSDTable is deleted/freed.
 *
 *----------------------------------------------------------------------
 */

func XTclFinalizeThreadDataThread(tls *libc.TLS) {
	var tsdTablePtr uintptr
	_ = tsdTablePtr
	tsdTablePtr = XTclpThreadGetGlobalTSD(tls, _tsdGlobal.Fkey)
	if tsdTablePtr != libc.UintptrFromInt32(0) {
		_TSDTableDelete(tls, tsdTablePtr)
		XTclpThreadSetGlobalTSD(tls, _tsdGlobal.Fkey, libc.UintptrFromInt32(0))
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclInitializeThreadStorage --
 *
 *	This procedure initializes the TSD subsystem with per-platform code.
 *	This should be called before any Tcl threads are created.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Allocates a system TSD.
 *
 *----------------------------------------------------------------------
 */

func XTclInitThreadStorage(tls *libc.TLS) {
	_tsdGlobal.Fkey = XTclpThreadCreateKey(tls)
}

/*
 *----------------------------------------------------------------------
 *
 * TclFinalizeThreadStorage --
 *
 *	This procedure cleans up the thread storage data key for all threads.
 *	IMPORTANT: All Tcl threads must be finalized before calling this!
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Releases the thread data key.
 *
 *----------------------------------------------------------------------
 */

func XTclFinalizeThreadStorage(tls *libc.TLS) {
	XTclpThreadDeleteKey(tls, _tsdGlobal.Fkey)
	_tsdGlobal.Fkey = libc.UintptrFromInt32(0)
}

const MP_DEFAULT_KARATSUBA_MUL_CUTOFF = 80
const MP_DEFAULT_KARATSUBA_SQR_CUTOFF = 120
const MP_DEFAULT_TOOM_MUL_CUTOFF = 350
const MP_DEFAULT_TOOM_SQR_CUTOFF = 400
const MP_KARATSUBA_MUL_CUTOFF = 80
const MP_KARATSUBA_SQR_CUTOFF = 120
const MP_TOOM_MUL_CUTOFF = 350
const MP_TOOM_SQR_CUTOFF = 400
const TclBN_mp_add = 0
const TclBN_mp_add_d = 0
const TclBN_mp_and = 0
const TclBN_mp_balance_mul = 0
const TclBN_mp_clamp = 0
const TclBN_mp_clear = 0
const TclBN_mp_clear_multi = 0
const TclBN_mp_cmp = 0
const TclBN_mp_cmp_d = 0
const TclBN_mp_cmp_mag = 0
const TclBN_mp_cnt_lsb = 0
const TclBN_mp_copy = 0
const TclBN_mp_count_bits = 0
const TclBN_mp_div = 0
const TclBN_mp_div_2 = 0
const TclBN_mp_div_2d = 0
const TclBN_mp_div_3 = 0
const TclBN_mp_div_d = 0
const TclBN_mp_exch = 0
const TclBN_mp_get_mag_u64 = 0
const TclBN_mp_grow = 0
const TclBN_mp_init = 0
const TclBN_mp_init_copy = 0
const TclBN_mp_init_i64 = 0
const TclBN_mp_init_multi = 0
const TclBN_mp_init_set = 0
const TclBN_mp_init_size = 0
const TclBN_mp_init_u64 = 0
const TclBN_mp_karatsuba_mul = 0
const TclBN_mp_karatsuba_sqr = 0
const TclBN_mp_lshd = 0
const TclBN_mp_mod = 0
const TclBN_mp_mod_2d = 0
const TclBN_mp_mul = 0
const TclBN_mp_mul_2 = 0
const TclBN_mp_mul_2d = 0
const TclBN_mp_mul_d = 0
const TclBN_mp_mul_digs = 0
const TclBN_mp_mul_digs_fast = 0
const TclBN_mp_neg = 0
const TclBN_mp_or = 0
const TclBN_mp_pack = 0
const TclBN_mp_pack_count = 0
const TclBN_mp_radix_size = 0
const TclBN_mp_read_radix = 0
const TclBN_mp_reverse = 0
const TclBN_mp_rshd = 0
const TclBN_mp_set_i64 = 0
const TclBN_mp_set_u64 = 0
const TclBN_mp_shrink = 0
const TclBN_mp_signed_rsh = 0
const TclBN_mp_sqr = 0
const TclBN_mp_sqr_fast = 0
const TclBN_mp_sqrt = 0
const TclBN_mp_sub = 0
const TclBN_mp_sub_d = 0
const TclBN_mp_to_radix = 0
const TclBN_mp_to_ubin = 0
const TclBN_mp_toom_mul = 0
const TclBN_mp_toom_sqr = 0
const TclBN_mp_ubin_size = 0
const TclBN_mp_unpack = 0
const TclBN_mp_xor = 0
const TclBN_mp_zero = 0
const TclBN_s_mp_add = 0
const TclBN_s_mp_sqr = 0
const TclBN_s_mp_sub = 0
const TclWinAddProcess = 0
const TclWinFlushDirtyChannels = 0
const TclWinGetTclInstance = 0
const TclWinNoBackslash = 0
const TclpIsAtty = 0

type Tmp_word = uint64

type Tmp_static_assert_prec_geq_min_prec = [1]uint8

/* code-generating macros */

/*
 * Remove macros that will interfere with the definitions below.
 */

func XTclListObjGetElements(tls *libc.TLS, interp uintptr, listPtr uintptr, objcPtr uintptr, objvPtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var result int32
	var _ /* n at bp+0 */ TTcl_Size
	_ = result
	*(*TTcl_Size)(unsafe.Pointer(bp)) = int64(-libc.Int32FromInt32(1))
	result = XTcl_ListObjGetElements(tls, interp, listPtr, bp, objvPtr)
	if objcPtr != 0 {
		if libc.Bool(uint64(4) != uint64(8)) && result == TCL_OK && *(*TTcl_Size)(unsafe.Pointer(bp)) > int64(INT_MAX) {
			if interp != 0 {
				XTcl_AppendResult(tls, interp, libc.VaList(bp+16, __ccgo_ts+67346, libc.UintptrFromInt32(0)))
			}
			return int32(TCL_ERROR)
		}
		*(*int32)(unsafe.Pointer(objcPtr)) = int32(*(*TTcl_Size)(unsafe.Pointer(bp)))
	}
	return result
}

func XTclListObjLength(tls *libc.TLS, interp uintptr, listPtr uintptr, lengthPtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var result int32
	var _ /* n at bp+0 */ TTcl_Size
	_ = result
	*(*TTcl_Size)(unsafe.Pointer(bp)) = int64(-libc.Int32FromInt32(1))
	result = XTcl_ListObjLength(tls, interp, listPtr, bp)
	if lengthPtr != 0 {
		if libc.Bool(uint64(4) != uint64(8)) && result == TCL_OK && *(*TTcl_Size)(unsafe.Pointer(bp)) > int64(INT_MAX) {
			if interp != 0 {
				XTcl_AppendResult(tls, interp, libc.VaList(bp+16, __ccgo_ts+67346, libc.UintptrFromInt32(0)))
			}
			return int32(TCL_ERROR)
		}
		*(*int32)(unsafe.Pointer(lengthPtr)) = int32(*(*TTcl_Size)(unsafe.Pointer(bp)))
	}
	return result
}

func XTclDictObjSize(tls *libc.TLS, interp uintptr, dictPtr uintptr, sizePtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var result int32
	var _ /* n at bp+0 */ TTcl_Size
	_ = result
	*(*TTcl_Size)(unsafe.Pointer(bp)) = int64(-libc.Int32FromInt32(1))
	result = XTcl_DictObjSize(tls, interp, dictPtr, bp)
	if sizePtr != 0 {
		if libc.Bool(uint64(4) != uint64(8)) && result == TCL_OK && *(*TTcl_Size)(unsafe.Pointer(bp)) > int64(INT_MAX) {
			if interp != 0 {
				XTcl_AppendResult(tls, interp, libc.VaList(bp+16, __ccgo_ts+67377, libc.UintptrFromInt32(0)))
			}
			return int32(TCL_ERROR)
		}
		*(*int32)(unsafe.Pointer(sizePtr)) = int32(*(*TTcl_Size)(unsafe.Pointer(bp)))
	}
	return result
}

func XTclSplitList(tls *libc.TLS, interp uintptr, listStr uintptr, argcPtr uintptr, argvPtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var result int32
	var _ /* n at bp+0 */ TTcl_Size
	_ = result
	*(*TTcl_Size)(unsafe.Pointer(bp)) = int64(-libc.Int32FromInt32(1))
	result = XTcl_SplitList(tls, interp, listStr, bp, argvPtr)
	if argcPtr != 0 {
		if libc.Bool(uint64(4) != uint64(8)) && result == TCL_OK && *(*TTcl_Size)(unsafe.Pointer(bp)) > int64(INT_MAX) {
			if interp != 0 {
				XTcl_AppendResult(tls, interp, libc.VaList(bp+16, __ccgo_ts+67346, libc.UintptrFromInt32(0)))
			}
			XTcl_Free(tls, *(*uintptr)(unsafe.Pointer(argvPtr)))
			return int32(TCL_ERROR)
		}
		*(*int32)(unsafe.Pointer(argcPtr)) = int32(*(*TTcl_Size)(unsafe.Pointer(bp)))
	}
	return result
}

func XTclSplitPath(tls *libc.TLS, path uintptr, argcPtr uintptr, argvPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _ /* n at bp+0 */ TTcl_Size
	*(*TTcl_Size)(unsafe.Pointer(bp)) = int64(-libc.Int32FromInt32(1))
	XTcl_SplitPath(tls, path, bp, argvPtr)
	if argcPtr != 0 {
		if libc.Bool(uint64(4) != uint64(8)) && *(*TTcl_Size)(unsafe.Pointer(bp)) > int64(INT_MAX) {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = int64(-libc.Int32FromInt32(1)) /* No other way to return an error-situation */
			XTcl_Free(tls, *(*uintptr)(unsafe.Pointer(argvPtr)))
			*(*uintptr)(unsafe.Pointer(argvPtr)) = libc.UintptrFromInt32(0)
		}
		*(*int32)(unsafe.Pointer(argcPtr)) = int32(*(*TTcl_Size)(unsafe.Pointer(bp)))
	}
}

func XTclFSSplitPath(tls *libc.TLS, pathPtr uintptr, lenPtr uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, result, v2 uintptr
	var v1 TTcl_Size
	var _ /* n at bp+0 */ TTcl_Size
	_, _, _, _ = _objPtr, result, v1, v2
	*(*TTcl_Size)(unsafe.Pointer(bp)) = int64(-libc.Int32FromInt32(1))
	result = XTcl_FSSplitPath(tls, pathPtr, bp)
	if lenPtr != 0 {
		if libc.Bool(uint64(4) != uint64(8)) && result != 0 && *(*TTcl_Size)(unsafe.Pointer(bp)) > int64(INT_MAX) {
			_objPtr = result
			v2 = _objPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if v1 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			return libc.UintptrFromInt32(0)
		}
		*(*int32)(unsafe.Pointer(lenPtr)) = int32(*(*TTcl_Size)(unsafe.Pointer(bp)))
	}
	return result
}

func XTclParseArgsObjv(tls *libc.TLS, interp uintptr, argTable uintptr, objcPtr uintptr, objv uintptr, remObjv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var result int32
	var v1 int64
	var _ /* n at bp+0 */ TTcl_Size
	_, _ = result, v1
	if *(*int32)(unsafe.Pointer(objcPtr)) < 0 {
		v1 = int64(-libc.Int32FromInt32(1))
	} else {
		v1 = int64(*(*int32)(unsafe.Pointer(objcPtr)))
	}
	*(*TTcl_Size)(unsafe.Pointer(bp)) = v1
	result = XTcl_ParseArgsObjv(tls, interp, argTable, bp, objv, remObjv)
	*(*int32)(unsafe.Pointer(objcPtr)) = int32(*(*TTcl_Size)(unsafe.Pointer(bp)))
	return result
}

func XTclGetAliasObj(tls *libc.TLS, interp uintptr, childCmd uintptr, targetInterpPtr uintptr, targetCmdPtr uintptr, objcPtr uintptr, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var result int32
	var _ /* n at bp+0 */ TTcl_Size
	_ = result
	*(*TTcl_Size)(unsafe.Pointer(bp)) = int64(-libc.Int32FromInt32(1))
	result = XTcl_GetAliasObj(tls, interp, childCmd, targetInterpPtr, targetCmdPtr, bp, objv)
	if objcPtr != 0 {
		if libc.Bool(uint64(4) != uint64(8)) && result == TCL_OK && *(*TTcl_Size)(unsafe.Pointer(bp)) > int64(INT_MAX) {
			if interp != 0 {
				XTcl_AppendResult(tls, interp, libc.VaList(bp+16, __ccgo_ts+67346, libc.UintptrFromInt32(0)))
			}
			return int32(TCL_ERROR)
		}
		*(*int32)(unsafe.Pointer(objcPtr)) = int32(*(*TTcl_Size)(unsafe.Pointer(bp)))
	}
	return result
}

/*
 * The rest of this file shouldn't warn about deprecated functions; they're
 * there because we intend them to be so and know that this file is OK to
 * touch those fields.
 */

/* !BEGIN!: Do not edit below this line. */

var _tclIntStubs = TTclIntStubs{
	Fmagic: libc.Int32FromUint32(0xFCA3BACB) + libc.Int32FromInt64(8),
}

func init() {
	p := unsafe.Pointer(&_tclIntStubs)
	*(*uintptr)(unsafe.Add(p, 40)) = __ccgo_fp(XTclAllocateFreeObjects)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(XTclCleanupChildren)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(XTclCleanupCommand)
	*(*uintptr)(unsafe.Add(p, 72)) = __ccgo_fp(XTclCopyAndCollapse)
	*(*uintptr)(unsafe.Add(p, 88)) = __ccgo_fp(XTclCreatePipeline)
	*(*uintptr)(unsafe.Add(p, 96)) = __ccgo_fp(XTclCreateProc)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(XTclDeleteCompiledLocalVars)
	*(*uintptr)(unsafe.Add(p, 112)) = __ccgo_fp(XTclDeleteVars)
	*(*uintptr)(unsafe.Add(p, 128)) = __ccgo_fp(XTclDumpMemoryInfo)
	*(*uintptr)(unsafe.Add(p, 144)) = __ccgo_fp(XTclExprFloatError)
	*(*uintptr)(unsafe.Add(p, 192)) = __ccgo_fp(XTclFindElement)
	*(*uintptr)(unsafe.Add(p, 200)) = __ccgo_fp(XTclFindProc)
	*(*uintptr)(unsafe.Add(p, 208)) = __ccgo_fp(XTclFormatInt)
	*(*uintptr)(unsafe.Add(p, 216)) = __ccgo_fp(XTclFreePackageInfo)
	*(*uintptr)(unsafe.Add(p, 240)) = __ccgo_fp(XTclpGetDefaultStdChannel)
	*(*uintptr)(unsafe.Add(p, 264)) = __ccgo_fp(XTclGetExtension)
	*(*uintptr)(unsafe.Add(p, 272)) = __ccgo_fp(XTclGetFrame)
	*(*uintptr)(unsafe.Add(p, 320)) = __ccgo_fp(XTclGetNamespaceForQualName)
	*(*uintptr)(unsafe.Add(p, 328)) = __ccgo_fp(XTclGetObjInterpProc)
	*(*uintptr)(unsafe.Add(p, 336)) = __ccgo_fp(XTclGetOpenMode)
	*(*uintptr)(unsafe.Add(p, 344)) = __ccgo_fp(XTclGetOriginalCommand)
	*(*uintptr)(unsafe.Add(p, 352)) = __ccgo_fp(XTclpGetUserHome)
	*(*uintptr)(unsafe.Add(p, 360)) = __ccgo_fp(XTclGetObjInterpProc2)
	*(*uintptr)(unsafe.Add(p, 376)) = __ccgo_fp(XTclHideUnsafeCommands)
	*(*uintptr)(unsafe.Add(p, 384)) = __ccgo_fp(XTclInExit)
	*(*uintptr)(unsafe.Add(p, 424)) = __ccgo_fp(XTclInterpInit)
	*(*uintptr)(unsafe.Add(p, 456)) = __ccgo_fp(XTclIsProc)
	*(*uintptr)(unsafe.Add(p, 480)) = __ccgo_fp(XTclLookupVar)
	*(*uintptr)(unsafe.Add(p, 496)) = __ccgo_fp(XTclNeedSpace)
	*(*uintptr)(unsafe.Add(p, 504)) = __ccgo_fp(XTclNewProcBodyObj)
	*(*uintptr)(unsafe.Add(p, 512)) = __ccgo_fp(XTclObjCommandComplete)
	*(*uintptr)(unsafe.Add(p, 528)) = __ccgo_fp(XTclObjInvoke)
	*(*uintptr)(unsafe.Add(p, 568)) = __ccgo_fp(XTclpAlloc)
	*(*uintptr)(unsafe.Add(p, 608)) = __ccgo_fp(XTclpFree)
	*(*uintptr)(unsafe.Add(p, 616)) = __ccgo_fp(XTclpGetClicks)
	*(*uintptr)(unsafe.Add(p, 624)) = __ccgo_fp(XTclpGetSeconds)
	*(*uintptr)(unsafe.Add(p, 664)) = __ccgo_fp(XTclpRealloc)
	*(*uintptr)(unsafe.Add(p, 728)) = __ccgo_fp(XTclPreventAliasLoop)
	*(*uintptr)(unsafe.Add(p, 744)) = __ccgo_fp(XTclProcCleanupProc)
	*(*uintptr)(unsafe.Add(p, 752)) = __ccgo_fp(XTclProcCompileProc)
	*(*uintptr)(unsafe.Add(p, 760)) = __ccgo_fp(XTclProcDeleteProc)
	*(*uintptr)(unsafe.Add(p, 784)) = __ccgo_fp(XTclRenameCommand)
	*(*uintptr)(unsafe.Add(p, 792)) = __ccgo_fp(XTclResetShadowedCmdRefs)
	*(*uintptr)(unsafe.Add(p, 800)) = __ccgo_fp(XTclServiceIdle)
	*(*uintptr)(unsafe.Add(p, 832)) = __ccgo_fp(XTclSetupEnv)
	*(*uintptr)(unsafe.Add(p, 840)) = __ccgo_fp(XTclSockGetPort)
	*(*uintptr)(unsafe.Add(p, 880)) = __ccgo_fp(XTclTeardownNamespace)
	*(*uintptr)(unsafe.Add(p, 888)) = __ccgo_fp(XTclUpdateReturnInfo)
	*(*uintptr)(unsafe.Add(p, 896)) = __ccgo_fp(XTclSockMinimumBuffers)
	*(*uintptr)(unsafe.Add(p, 904)) = __ccgo_fp(XTcl_AddInterpResolvers)
	*(*uintptr)(unsafe.Add(p, 960)) = __ccgo_fp(XTcl_GetInterpResolvers)
	*(*uintptr)(unsafe.Add(p, 968)) = __ccgo_fp(XTcl_GetNamespaceResolvers)
	*(*uintptr)(unsafe.Add(p, 976)) = __ccgo_fp(XTcl_FindNamespaceVar)
	*(*uintptr)(unsafe.Add(p, 1024)) = __ccgo_fp(XTcl_GetVariableFullName)
	*(*uintptr)(unsafe.Add(p, 1040)) = __ccgo_fp(XTcl_PopCallFrame)
	*(*uintptr)(unsafe.Add(p, 1048)) = __ccgo_fp(XTcl_PushCallFrame)
	*(*uintptr)(unsafe.Add(p, 1056)) = __ccgo_fp(XTcl_RemoveInterpResolvers)
	*(*uintptr)(unsafe.Add(p, 1064)) = __ccgo_fp(XTcl_SetNamespaceResolvers)
	*(*uintptr)(unsafe.Add(p, 1120)) = __ccgo_fp(XTclGetEnv)
	*(*uintptr)(unsafe.Add(p, 1144)) = __ccgo_fp(XTclpGetCwd)
	*(*uintptr)(unsafe.Add(p, 1152)) = __ccgo_fp(XTclSetByteCodeFromAny)
	*(*uintptr)(unsafe.Add(p, 1160)) = __ccgo_fp(XTclAddLiteralObj)
	*(*uintptr)(unsafe.Add(p, 1168)) = __ccgo_fp(XTclHideLiteral)
	*(*uintptr)(unsafe.Add(p, 1176)) = __ccgo_fp(XTclGetAuxDataType)
	*(*uintptr)(unsafe.Add(p, 1184)) = __ccgo_fp(XTclHandleCreate)
	*(*uintptr)(unsafe.Add(p, 1192)) = __ccgo_fp(XTclHandleFree)
	*(*uintptr)(unsafe.Add(p, 1200)) = __ccgo_fp(XTclHandlePreserve)
	*(*uintptr)(unsafe.Add(p, 1208)) = __ccgo_fp(XTclHandleRelease)
	*(*uintptr)(unsafe.Add(p, 1216)) = __ccgo_fp(XTclRegAbout)
	*(*uintptr)(unsafe.Add(p, 1224)) = __ccgo_fp(XTclRegExpRangeUniChar)
	*(*uintptr)(unsafe.Add(p, 1264)) = __ccgo_fp(XTclRegError)
	*(*uintptr)(unsafe.Add(p, 1272)) = __ccgo_fp(XTclVarTraceExists)
	*(*uintptr)(unsafe.Add(p, 1304)) = __ccgo_fp(XTclChannelTransform)
	*(*uintptr)(unsafe.Add(p, 1312)) = __ccgo_fp(XTclChannelEventScriptInvoker)
	*(*uintptr)(unsafe.Add(p, 1320)) = __ccgo_fp(XTclGetInstructionTable)
	*(*uintptr)(unsafe.Add(p, 1328)) = __ccgo_fp(XTclExpandCodeArray)
	*(*uintptr)(unsafe.Add(p, 1336)) = __ccgo_fp(XTclpSetInitialEncodings)
	*(*uintptr)(unsafe.Add(p, 1344)) = __ccgo_fp(XTclListObjSetElement)
	*(*uintptr)(unsafe.Add(p, 1368)) = __ccgo_fp(XTclpUtfNcmp2)
	*(*uintptr)(unsafe.Add(p, 1376)) = __ccgo_fp(XTclCheckInterpTraces)
	*(*uintptr)(unsafe.Add(p, 1384)) = __ccgo_fp(XTclCheckExecutionTraces)
	*(*uintptr)(unsafe.Add(p, 1392)) = __ccgo_fp(XTclInThreadExit)
	*(*uintptr)(unsafe.Add(p, 1400)) = __ccgo_fp(XTclUniCharMatch)
	*(*uintptr)(unsafe.Add(p, 1416)) = __ccgo_fp(XTclCallVarTraces)
	*(*uintptr)(unsafe.Add(p, 1424)) = __ccgo_fp(XTclCleanupVar)
	*(*uintptr)(unsafe.Add(p, 1432)) = __ccgo_fp(XTclVarErrMsg)
	*(*uintptr)(unsafe.Add(p, 1600)) = __ccgo_fp(XTclObjGetFrame)
	*(*uintptr)(unsafe.Add(p, 1616)) = __ccgo_fp(XTclpObjRemoveDirectory)
	*(*uintptr)(unsafe.Add(p, 1624)) = __ccgo_fp(XTclpObjCopyDirectory)
	*(*uintptr)(unsafe.Add(p, 1632)) = __ccgo_fp(XTclpObjCreateDirectory)
	*(*uintptr)(unsafe.Add(p, 1640)) = __ccgo_fp(XTclpObjDeleteFile)
	*(*uintptr)(unsafe.Add(p, 1648)) = __ccgo_fp(XTclpObjCopyFile)
	*(*uintptr)(unsafe.Add(p, 1656)) = __ccgo_fp(XTclpObjRenameFile)
	*(*uintptr)(unsafe.Add(p, 1664)) = __ccgo_fp(XTclpObjStat)
	*(*uintptr)(unsafe.Add(p, 1672)) = __ccgo_fp(XTclpObjAccess)
	*(*uintptr)(unsafe.Add(p, 1680)) = __ccgo_fp(XTclpOpenFileChannel)
	*(*uintptr)(unsafe.Add(p, 1712)) = __ccgo_fp(XTclpFindExecutable)
	*(*uintptr)(unsafe.Add(p, 1720)) = __ccgo_fp(XTclGetObjNameOfExecutable)
	*(*uintptr)(unsafe.Add(p, 1728)) = __ccgo_fp(XTclSetObjNameOfExecutable)
	*(*uintptr)(unsafe.Add(p, 1736)) = __ccgo_fp(XTclStackAlloc)
	*(*uintptr)(unsafe.Add(p, 1744)) = __ccgo_fp(XTclStackFree)
	*(*uintptr)(unsafe.Add(p, 1752)) = __ccgo_fp(XTclPushStackFrame)
	*(*uintptr)(unsafe.Add(p, 1760)) = __ccgo_fp(XTclPopStackFrame)
	*(*uintptr)(unsafe.Add(p, 1768)) = __ccgo_fp(XTclpCreateTemporaryDirectory)
	*(*uintptr)(unsafe.Add(p, 1784)) = __ccgo_fp(XTclListTestObj)
	*(*uintptr)(unsafe.Add(p, 1792)) = __ccgo_fp(XTclListObjValidate)
	*(*uintptr)(unsafe.Add(p, 1800)) = __ccgo_fp(_TclGetCStackPtr)
	*(*uintptr)(unsafe.Add(p, 1808)) = __ccgo_fp(XTclGetPlatform)
	*(*uintptr)(unsafe.Add(p, 1816)) = __ccgo_fp(XTclTraceDictPath)
	*(*uintptr)(unsafe.Add(p, 1824)) = __ccgo_fp(XTclObjBeingDeleted)
	*(*uintptr)(unsafe.Add(p, 1832)) = __ccgo_fp(XTclSetNsPath)
	*(*uintptr)(unsafe.Add(p, 1848)) = __ccgo_fp(XTclPtrMakeUpvar)
	*(*uintptr)(unsafe.Add(p, 1856)) = __ccgo_fp(XTclObjLookupVar)
	*(*uintptr)(unsafe.Add(p, 1864)) = __ccgo_fp(XTclGetNamespaceFromObj)
	*(*uintptr)(unsafe.Add(p, 1872)) = __ccgo_fp(XTclEvalObjEx)
	*(*uintptr)(unsafe.Add(p, 1880)) = __ccgo_fp(XTclGetSrcInfoForPc)
	*(*uintptr)(unsafe.Add(p, 1888)) = __ccgo_fp(XTclVarHashCreateVar)
	*(*uintptr)(unsafe.Add(p, 1896)) = __ccgo_fp(XTclInitVarHashTable)
	*(*uintptr)(unsafe.Add(p, 1912)) = __ccgo_fp(XTclResetCancellation)
	*(*uintptr)(unsafe.Add(p, 1920)) = __ccgo_fp(XTclNRInterpProc)
	*(*uintptr)(unsafe.Add(p, 1928)) = __ccgo_fp(XTclNRInterpProcCore)
	*(*uintptr)(unsafe.Add(p, 1936)) = __ccgo_fp(XTclNRRunCallbacks)
	*(*uintptr)(unsafe.Add(p, 1944)) = __ccgo_fp(XTclNREvalObjEx)
	*(*uintptr)(unsafe.Add(p, 1952)) = __ccgo_fp(XTclNREvalObjv)
	*(*uintptr)(unsafe.Add(p, 1960)) = __ccgo_fp(XTclDbDumpActiveObjects)
	*(*uintptr)(unsafe.Add(p, 1968)) = __ccgo_fp(XTclGetNamespaceChildTable)
	*(*uintptr)(unsafe.Add(p, 1976)) = __ccgo_fp(XTclGetNamespaceCommandTable)
	*(*uintptr)(unsafe.Add(p, 1984)) = __ccgo_fp(XTclInitRewriteEnsemble)
	*(*uintptr)(unsafe.Add(p, 1992)) = __ccgo_fp(XTclResetRewriteEnsemble)
	*(*uintptr)(unsafe.Add(p, 2000)) = __ccgo_fp(XTclCopyChannel)
	*(*uintptr)(unsafe.Add(p, 2008)) = __ccgo_fp(XTclDoubleDigits)
	*(*uintptr)(unsafe.Add(p, 2016)) = __ccgo_fp(XTclSetChildCancelFlags)
	*(*uintptr)(unsafe.Add(p, 2024)) = __ccgo_fp(XTclRegisterLiteral)
	*(*uintptr)(unsafe.Add(p, 2032)) = __ccgo_fp(XTclPtrGetVar)
	*(*uintptr)(unsafe.Add(p, 2040)) = __ccgo_fp(XTclPtrSetVar)
	*(*uintptr)(unsafe.Add(p, 2048)) = __ccgo_fp(XTclPtrIncrObjVar)
	*(*uintptr)(unsafe.Add(p, 2056)) = __ccgo_fp(XTclPtrObjMakeUpvar)
	*(*uintptr)(unsafe.Add(p, 2064)) = __ccgo_fp(XTclPtrUnsetVar)
	*(*uintptr)(unsafe.Add(p, 2072)) = __ccgo_fp(XTcl_StaticLibrary)
}

var _tclIntPlatStubs = TTclIntPlatStubs{
	Fmagic: libc.Int32FromUint32(0xFCA3BACB) + libc.Int32FromInt64(8),
}

func init() {
	p := unsafe.Pointer(&_tclIntPlatStubs)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(XTclpCloseFile)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(XTclpCreateCommandChannel)
	*(*uintptr)(unsafe.Add(p, 40)) = __ccgo_fp(XTclpCreatePipe)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(XTclUnixWaitForFile)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(XTclpMakeFile)
	*(*uintptr)(unsafe.Add(p, 72)) = __ccgo_fp(XTclpOpenFile)
	*(*uintptr)(unsafe.Add(p, 88)) = __ccgo_fp(XTclpCreateTempFile)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(XTclGetAndDetachPids)
	*(*uintptr)(unsafe.Add(p, 136)) = __ccgo_fp(_TclpCreateProcess)
	*(*uintptr)(unsafe.Add(p, 144)) = __ccgo_fp(libc.Xisatty)
	*(*uintptr)(unsafe.Add(p, 152)) = __ccgo_fp(XTclUnixCopyFile)
	*(*uintptr)(unsafe.Add(p, 248)) = __ccgo_fp(_TclWinCPUID)
	*(*uintptr)(unsafe.Add(p, 256)) = __ccgo_fp(XTclUnixOpenTemporaryFile)
}

var _tclPlatStubs = TTclPlatStubs{
	Fmagic: libc.Int32FromUint32(0xFCA3BACB) + libc.Int32FromInt64(8),
}

func init() {
	p := unsafe.Pointer(&XtclTomMathStubs)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(XTclBN_epoch)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(XTclBN_revision)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(XTclBN_mp_add)
	*(*uintptr)(unsafe.Add(p, 40)) = __ccgo_fp(XTclBN_mp_add_d)
	*(*uintptr)(unsafe.Add(p, 48)) = __ccgo_fp(XTclBN_mp_and)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(XTclBN_mp_clamp)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(XTclBN_mp_clear)
	*(*uintptr)(unsafe.Add(p, 72)) = __ccgo_fp(XTclBN_mp_clear_multi)
	*(*uintptr)(unsafe.Add(p, 80)) = __ccgo_fp(XTclBN_mp_cmp)
	*(*uintptr)(unsafe.Add(p, 88)) = __ccgo_fp(XTclBN_mp_cmp_d)
	*(*uintptr)(unsafe.Add(p, 96)) = __ccgo_fp(XTclBN_mp_cmp_mag)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(XTclBN_mp_copy)
	*(*uintptr)(unsafe.Add(p, 112)) = __ccgo_fp(XTclBN_mp_count_bits)
	*(*uintptr)(unsafe.Add(p, 120)) = __ccgo_fp(XTclBN_mp_div)
	*(*uintptr)(unsafe.Add(p, 128)) = __ccgo_fp(XTclBN_mp_div_d)
	*(*uintptr)(unsafe.Add(p, 136)) = __ccgo_fp(XTclBN_mp_div_2)
	*(*uintptr)(unsafe.Add(p, 144)) = __ccgo_fp(XTclBN_mp_div_2d)
	*(*uintptr)(unsafe.Add(p, 160)) = __ccgo_fp(XTclBN_mp_exch)
	*(*uintptr)(unsafe.Add(p, 168)) = __ccgo_fp(XTclBN_mp_expt_n)
	*(*uintptr)(unsafe.Add(p, 176)) = __ccgo_fp(XTclBN_mp_grow)
	*(*uintptr)(unsafe.Add(p, 184)) = __ccgo_fp(XTclBN_mp_init)
	*(*uintptr)(unsafe.Add(p, 192)) = __ccgo_fp(XTclBN_mp_init_copy)
	*(*uintptr)(unsafe.Add(p, 200)) = __ccgo_fp(XTclBN_mp_init_multi)
	*(*uintptr)(unsafe.Add(p, 208)) = __ccgo_fp(XTclBN_mp_init_set)
	*(*uintptr)(unsafe.Add(p, 216)) = __ccgo_fp(XTclBN_mp_init_size)
	*(*uintptr)(unsafe.Add(p, 224)) = __ccgo_fp(XTclBN_mp_lshd)
	*(*uintptr)(unsafe.Add(p, 232)) = __ccgo_fp(XTclBN_mp_mod)
	*(*uintptr)(unsafe.Add(p, 240)) = __ccgo_fp(XTclBN_mp_mod_2d)
	*(*uintptr)(unsafe.Add(p, 248)) = __ccgo_fp(XTclBN_mp_mul)
	*(*uintptr)(unsafe.Add(p, 256)) = __ccgo_fp(XTclBN_mp_mul_d)
	*(*uintptr)(unsafe.Add(p, 264)) = __ccgo_fp(XTclBN_mp_mul_2)
	*(*uintptr)(unsafe.Add(p, 272)) = __ccgo_fp(XTclBN_mp_mul_2d)
	*(*uintptr)(unsafe.Add(p, 280)) = __ccgo_fp(XTclBN_mp_neg)
	*(*uintptr)(unsafe.Add(p, 288)) = __ccgo_fp(XTclBN_mp_or)
	*(*uintptr)(unsafe.Add(p, 296)) = __ccgo_fp(XTclBN_mp_radix_size)
	*(*uintptr)(unsafe.Add(p, 304)) = __ccgo_fp(XTclBN_mp_read_radix)
	*(*uintptr)(unsafe.Add(p, 312)) = __ccgo_fp(XTclBN_mp_rshd)
	*(*uintptr)(unsafe.Add(p, 320)) = __ccgo_fp(XTclBN_mp_shrink)
	*(*uintptr)(unsafe.Add(p, 344)) = __ccgo_fp(XTclBN_mp_sqrt)
	*(*uintptr)(unsafe.Add(p, 352)) = __ccgo_fp(XTclBN_mp_sub)
	*(*uintptr)(unsafe.Add(p, 360)) = __ccgo_fp(XTclBN_mp_sub_d)
	*(*uintptr)(unsafe.Add(p, 392)) = __ccgo_fp(XTclBN_mp_ubin_size)
	*(*uintptr)(unsafe.Add(p, 400)) = __ccgo_fp(XTclBN_mp_xor)
	*(*uintptr)(unsafe.Add(p, 408)) = __ccgo_fp(XTclBN_mp_zero)
	*(*uintptr)(unsafe.Add(p, 520)) = __ccgo_fp(XTclBN_mp_cnt_lsb)
	*(*uintptr)(unsafe.Add(p, 536)) = __ccgo_fp(XTclBN_mp_init_i64)
	*(*uintptr)(unsafe.Add(p, 544)) = __ccgo_fp(XTclBN_mp_init_u64)
	*(*uintptr)(unsafe.Add(p, 560)) = __ccgo_fp(XTclBN_mp_set_u64)
	*(*uintptr)(unsafe.Add(p, 568)) = __ccgo_fp(XTclBN_mp_get_mag_u64)
	*(*uintptr)(unsafe.Add(p, 576)) = __ccgo_fp(XTclBN_mp_set_i64)
	*(*uintptr)(unsafe.Add(p, 584)) = __ccgo_fp(XTclBN_mp_unpack)
	*(*uintptr)(unsafe.Add(p, 592)) = __ccgo_fp(XTclBN_mp_pack)
	*(*uintptr)(unsafe.Add(p, 624)) = __ccgo_fp(XTclBN_mp_signed_rsh)
	*(*uintptr)(unsafe.Add(p, 632)) = __ccgo_fp(XTclBN_mp_pack_count)
	*(*uintptr)(unsafe.Add(p, 640)) = __ccgo_fp(XTclBN_mp_to_ubin)
	*(*uintptr)(unsafe.Add(p, 656)) = __ccgo_fp(XTclBN_mp_to_radix)
}

var _tclStubHooks = TTclStubHooks{
	FtclPlatStubs:    uintptr(unsafe.Pointer(&_tclPlatStubs)),
	FtclIntStubs:     uintptr(unsafe.Pointer(&_tclIntStubs)),
	FtclIntPlatStubs: uintptr(unsafe.Pointer(&_tclIntPlatStubs)),
}

func init() {
	p := unsafe.Pointer(&XtclStubs)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(XTcl_PkgProvideEx)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(XTcl_PkgRequireEx)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(XTcl_Panic)
	*(*uintptr)(unsafe.Add(p, 40)) = __ccgo_fp(XTcl_Alloc)
	*(*uintptr)(unsafe.Add(p, 48)) = __ccgo_fp(XTcl_Free)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(XTcl_Realloc)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(XTcl_DbCkalloc)
	*(*uintptr)(unsafe.Add(p, 72)) = __ccgo_fp(XTcl_DbCkfree)
	*(*uintptr)(unsafe.Add(p, 80)) = __ccgo_fp(XTcl_DbCkrealloc)
	*(*uintptr)(unsafe.Add(p, 88)) = __ccgo_fp(XTcl_CreateFileHandler)
	*(*uintptr)(unsafe.Add(p, 96)) = __ccgo_fp(XTcl_DeleteFileHandler)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(XTcl_SetTimer)
	*(*uintptr)(unsafe.Add(p, 112)) = __ccgo_fp(XTcl_Sleep)
	*(*uintptr)(unsafe.Add(p, 120)) = __ccgo_fp(XTcl_WaitForEvent)
	*(*uintptr)(unsafe.Add(p, 128)) = __ccgo_fp(XTcl_AppendAllObjTypes)
	*(*uintptr)(unsafe.Add(p, 136)) = __ccgo_fp(XTcl_AppendStringsToObj)
	*(*uintptr)(unsafe.Add(p, 144)) = __ccgo_fp(XTcl_AppendToObj)
	*(*uintptr)(unsafe.Add(p, 152)) = __ccgo_fp(XTcl_ConcatObj)
	*(*uintptr)(unsafe.Add(p, 160)) = __ccgo_fp(XTcl_ConvertToType)
	*(*uintptr)(unsafe.Add(p, 168)) = __ccgo_fp(XTcl_DbDecrRefCount)
	*(*uintptr)(unsafe.Add(p, 176)) = __ccgo_fp(XTcl_DbIncrRefCount)
	*(*uintptr)(unsafe.Add(p, 184)) = __ccgo_fp(XTcl_DbIsShared)
	*(*uintptr)(unsafe.Add(p, 200)) = __ccgo_fp(XTcl_DbNewByteArrayObj)
	*(*uintptr)(unsafe.Add(p, 208)) = __ccgo_fp(XTcl_DbNewDoubleObj)
	*(*uintptr)(unsafe.Add(p, 216)) = __ccgo_fp(XTcl_DbNewListObj)
	*(*uintptr)(unsafe.Add(p, 232)) = __ccgo_fp(XTcl_DbNewObj)
	*(*uintptr)(unsafe.Add(p, 240)) = __ccgo_fp(XTcl_DbNewStringObj)
	*(*uintptr)(unsafe.Add(p, 248)) = __ccgo_fp(XTcl_DuplicateObj)
	*(*uintptr)(unsafe.Add(p, 256)) = __ccgo_fp(XTclFreeObj)
	*(*uintptr)(unsafe.Add(p, 264)) = __ccgo_fp(XTcl_GetBoolean)
	*(*uintptr)(unsafe.Add(p, 272)) = __ccgo_fp(XTcl_GetBooleanFromObj)
	*(*uintptr)(unsafe.Add(p, 288)) = __ccgo_fp(XTcl_GetDouble)
	*(*uintptr)(unsafe.Add(p, 296)) = __ccgo_fp(XTcl_GetDoubleFromObj)
	*(*uintptr)(unsafe.Add(p, 312)) = __ccgo_fp(XTcl_GetInt)
	*(*uintptr)(unsafe.Add(p, 320)) = __ccgo_fp(XTcl_GetIntFromObj)
	*(*uintptr)(unsafe.Add(p, 328)) = __ccgo_fp(XTcl_GetLongFromObj)
	*(*uintptr)(unsafe.Add(p, 336)) = __ccgo_fp(XTcl_GetObjType)
	*(*uintptr)(unsafe.Add(p, 344)) = __ccgo_fp(XTclGetStringFromObj)
	*(*uintptr)(unsafe.Add(p, 352)) = __ccgo_fp(XTcl_InvalidateStringRep)
	*(*uintptr)(unsafe.Add(p, 360)) = __ccgo_fp(XTcl_ListObjAppendList)
	*(*uintptr)(unsafe.Add(p, 368)) = __ccgo_fp(XTcl_ListObjAppendElement)
	*(*uintptr)(unsafe.Add(p, 376)) = __ccgo_fp(XTclListObjGetElements)
	*(*uintptr)(unsafe.Add(p, 384)) = __ccgo_fp(XTcl_ListObjIndex)
	*(*uintptr)(unsafe.Add(p, 392)) = __ccgo_fp(XTclListObjLength)
	*(*uintptr)(unsafe.Add(p, 400)) = __ccgo_fp(XTcl_ListObjReplace)
	*(*uintptr)(unsafe.Add(p, 416)) = __ccgo_fp(XTcl_NewByteArrayObj)
	*(*uintptr)(unsafe.Add(p, 424)) = __ccgo_fp(XTcl_NewDoubleObj)
	*(*uintptr)(unsafe.Add(p, 440)) = __ccgo_fp(XTcl_NewListObj)
	*(*uintptr)(unsafe.Add(p, 456)) = __ccgo_fp(XTcl_NewObj)
	*(*uintptr)(unsafe.Add(p, 464)) = __ccgo_fp(XTcl_NewStringObj)
	*(*uintptr)(unsafe.Add(p, 480)) = __ccgo_fp(XTcl_SetByteArrayLength)
	*(*uintptr)(unsafe.Add(p, 488)) = __ccgo_fp(XTcl_SetByteArrayObj)
	*(*uintptr)(unsafe.Add(p, 496)) = __ccgo_fp(XTcl_SetDoubleObj)
	*(*uintptr)(unsafe.Add(p, 512)) = __ccgo_fp(XTcl_SetListObj)
	*(*uintptr)(unsafe.Add(p, 528)) = __ccgo_fp(XTcl_SetObjLength)
	*(*uintptr)(unsafe.Add(p, 536)) = __ccgo_fp(XTcl_SetStringObj)
	*(*uintptr)(unsafe.Add(p, 560)) = __ccgo_fp(XTcl_AllowExceptions)
	*(*uintptr)(unsafe.Add(p, 568)) = __ccgo_fp(XTcl_AppendElement)
	*(*uintptr)(unsafe.Add(p, 576)) = __ccgo_fp(XTcl_AppendResult)
	*(*uintptr)(unsafe.Add(p, 584)) = __ccgo_fp(XTcl_AsyncCreate)
	*(*uintptr)(unsafe.Add(p, 592)) = __ccgo_fp(XTcl_AsyncDelete)
	*(*uintptr)(unsafe.Add(p, 600)) = __ccgo_fp(XTcl_AsyncInvoke)
	*(*uintptr)(unsafe.Add(p, 608)) = __ccgo_fp(XTcl_AsyncMark)
	*(*uintptr)(unsafe.Add(p, 616)) = __ccgo_fp(XTcl_AsyncReady)
	*(*uintptr)(unsafe.Add(p, 640)) = __ccgo_fp(XTcl_BadChannelOption)
	*(*uintptr)(unsafe.Add(p, 648)) = __ccgo_fp(XTcl_CallWhenDeleted)
	*(*uintptr)(unsafe.Add(p, 656)) = __ccgo_fp(XTcl_CancelIdleCall)
	*(*uintptr)(unsafe.Add(p, 672)) = __ccgo_fp(XTcl_CommandComplete)
	*(*uintptr)(unsafe.Add(p, 680)) = __ccgo_fp(XTcl_Concat)
	*(*uintptr)(unsafe.Add(p, 688)) = __ccgo_fp(XTcl_ConvertElement)
	*(*uintptr)(unsafe.Add(p, 696)) = __ccgo_fp(XTcl_ConvertCountedElement)
	*(*uintptr)(unsafe.Add(p, 704)) = __ccgo_fp(XTcl_CreateAlias)
	*(*uintptr)(unsafe.Add(p, 712)) = __ccgo_fp(XTcl_CreateAliasObj)
	*(*uintptr)(unsafe.Add(p, 720)) = __ccgo_fp(XTcl_CreateChannel)
	*(*uintptr)(unsafe.Add(p, 728)) = __ccgo_fp(XTcl_CreateChannelHandler)
	*(*uintptr)(unsafe.Add(p, 736)) = __ccgo_fp(XTcl_CreateCloseHandler)
	*(*uintptr)(unsafe.Add(p, 744)) = __ccgo_fp(XTcl_CreateCommand)
	*(*uintptr)(unsafe.Add(p, 752)) = __ccgo_fp(XTcl_CreateEventSource)
	*(*uintptr)(unsafe.Add(p, 760)) = __ccgo_fp(XTcl_CreateExitHandler)
	*(*uintptr)(unsafe.Add(p, 768)) = __ccgo_fp(XTcl_CreateInterp)
	*(*uintptr)(unsafe.Add(p, 784)) = __ccgo_fp(XTcl_CreateObjCommand)
	*(*uintptr)(unsafe.Add(p, 792)) = __ccgo_fp(XTcl_CreateChild)
	*(*uintptr)(unsafe.Add(p, 800)) = __ccgo_fp(XTcl_CreateTimerHandler)
	*(*uintptr)(unsafe.Add(p, 808)) = __ccgo_fp(XTcl_CreateTrace)
	*(*uintptr)(unsafe.Add(p, 816)) = __ccgo_fp(XTcl_DeleteAssocData)
	*(*uintptr)(unsafe.Add(p, 824)) = __ccgo_fp(XTcl_DeleteChannelHandler)
	*(*uintptr)(unsafe.Add(p, 832)) = __ccgo_fp(XTcl_DeleteCloseHandler)
	*(*uintptr)(unsafe.Add(p, 840)) = __ccgo_fp(XTcl_DeleteCommand)
	*(*uintptr)(unsafe.Add(p, 848)) = __ccgo_fp(XTcl_DeleteCommandFromToken)
	*(*uintptr)(unsafe.Add(p, 856)) = __ccgo_fp(XTcl_DeleteEvents)
	*(*uintptr)(unsafe.Add(p, 864)) = __ccgo_fp(XTcl_DeleteEventSource)
	*(*uintptr)(unsafe.Add(p, 872)) = __ccgo_fp(XTcl_DeleteExitHandler)
	*(*uintptr)(unsafe.Add(p, 880)) = __ccgo_fp(XTcl_DeleteHashEntry)
	*(*uintptr)(unsafe.Add(p, 888)) = __ccgo_fp(XTcl_DeleteHashTable)
	*(*uintptr)(unsafe.Add(p, 896)) = __ccgo_fp(XTcl_DeleteInterp)
	*(*uintptr)(unsafe.Add(p, 904)) = __ccgo_fp(XTcl_DetachPids)
	*(*uintptr)(unsafe.Add(p, 912)) = __ccgo_fp(XTcl_DeleteTimerHandler)
	*(*uintptr)(unsafe.Add(p, 920)) = __ccgo_fp(XTcl_DeleteTrace)
	*(*uintptr)(unsafe.Add(p, 928)) = __ccgo_fp(XTcl_DontCallWhenDeleted)
	*(*uintptr)(unsafe.Add(p, 936)) = __ccgo_fp(XTcl_DoOneEvent)
	*(*uintptr)(unsafe.Add(p, 944)) = __ccgo_fp(XTcl_DoWhenIdle)
	*(*uintptr)(unsafe.Add(p, 952)) = __ccgo_fp(XTcl_DStringAppend)
	*(*uintptr)(unsafe.Add(p, 960)) = __ccgo_fp(XTcl_DStringAppendElement)
	*(*uintptr)(unsafe.Add(p, 968)) = __ccgo_fp(XTcl_DStringEndSublist)
	*(*uintptr)(unsafe.Add(p, 976)) = __ccgo_fp(XTcl_DStringFree)
	*(*uintptr)(unsafe.Add(p, 984)) = __ccgo_fp(XTcl_DStringGetResult)
	*(*uintptr)(unsafe.Add(p, 992)) = __ccgo_fp(XTcl_DStringInit)
	*(*uintptr)(unsafe.Add(p, 1000)) = __ccgo_fp(XTcl_DStringResult)
	*(*uintptr)(unsafe.Add(p, 1008)) = __ccgo_fp(XTcl_DStringSetLength)
	*(*uintptr)(unsafe.Add(p, 1016)) = __ccgo_fp(XTcl_DStringStartSublist)
	*(*uintptr)(unsafe.Add(p, 1024)) = __ccgo_fp(XTcl_Eof)
	*(*uintptr)(unsafe.Add(p, 1032)) = __ccgo_fp(XTcl_ErrnoId)
	*(*uintptr)(unsafe.Add(p, 1040)) = __ccgo_fp(XTcl_ErrnoMsg)
	*(*uintptr)(unsafe.Add(p, 1056)) = __ccgo_fp(XTcl_EvalFile)
	*(*uintptr)(unsafe.Add(p, 1072)) = __ccgo_fp(XTcl_EventuallyFree)
	*(*uintptr)(unsafe.Add(p, 1080)) = __ccgo_fp(XTcl_Exit)
	*(*uintptr)(unsafe.Add(p, 1088)) = __ccgo_fp(XTcl_ExposeCommand)
	*(*uintptr)(unsafe.Add(p, 1096)) = __ccgo_fp(XTcl_ExprBoolean)
	*(*uintptr)(unsafe.Add(p, 1104)) = __ccgo_fp(XTcl_ExprBooleanObj)
	*(*uintptr)(unsafe.Add(p, 1112)) = __ccgo_fp(XTcl_ExprDouble)
	*(*uintptr)(unsafe.Add(p, 1120)) = __ccgo_fp(XTcl_ExprDoubleObj)
	*(*uintptr)(unsafe.Add(p, 1128)) = __ccgo_fp(XTcl_ExprLong)
	*(*uintptr)(unsafe.Add(p, 1136)) = __ccgo_fp(XTcl_ExprLongObj)
	*(*uintptr)(unsafe.Add(p, 1144)) = __ccgo_fp(XTcl_ExprObj)
	*(*uintptr)(unsafe.Add(p, 1152)) = __ccgo_fp(XTcl_ExprString)
	*(*uintptr)(unsafe.Add(p, 1160)) = __ccgo_fp(XTcl_Finalize)
	*(*uintptr)(unsafe.Add(p, 1176)) = __ccgo_fp(XTcl_FirstHashEntry)
	*(*uintptr)(unsafe.Add(p, 1184)) = __ccgo_fp(XTcl_Flush)
	*(*uintptr)(unsafe.Add(p, 1208)) = __ccgo_fp(XTclGetAliasObj)
	*(*uintptr)(unsafe.Add(p, 1216)) = __ccgo_fp(XTcl_GetAssocData)
	*(*uintptr)(unsafe.Add(p, 1224)) = __ccgo_fp(XTcl_GetChannel)
	*(*uintptr)(unsafe.Add(p, 1232)) = __ccgo_fp(XTcl_GetChannelBufferSize)
	*(*uintptr)(unsafe.Add(p, 1240)) = __ccgo_fp(XTcl_GetChannelHandle)
	*(*uintptr)(unsafe.Add(p, 1248)) = __ccgo_fp(XTcl_GetChannelInstanceData)
	*(*uintptr)(unsafe.Add(p, 1256)) = __ccgo_fp(XTcl_GetChannelMode)
	*(*uintptr)(unsafe.Add(p, 1264)) = __ccgo_fp(XTcl_GetChannelName)
	*(*uintptr)(unsafe.Add(p, 1272)) = __ccgo_fp(XTcl_GetChannelOption)
	*(*uintptr)(unsafe.Add(p, 1280)) = __ccgo_fp(XTcl_GetChannelType)
	*(*uintptr)(unsafe.Add(p, 1288)) = __ccgo_fp(XTcl_GetCommandInfo)
	*(*uintptr)(unsafe.Add(p, 1296)) = __ccgo_fp(XTcl_GetCommandName)
	*(*uintptr)(unsafe.Add(p, 1304)) = __ccgo_fp(XTcl_GetErrno)
	*(*uintptr)(unsafe.Add(p, 1312)) = __ccgo_fp(XTcl_GetHostName)
	*(*uintptr)(unsafe.Add(p, 1320)) = __ccgo_fp(XTcl_GetInterpPath)
	*(*uintptr)(unsafe.Add(p, 1328)) = __ccgo_fp(XTcl_GetParent)
	*(*uintptr)(unsafe.Add(p, 1336)) = __ccgo_fp(XTcl_GetNameOfExecutable)
	*(*uintptr)(unsafe.Add(p, 1344)) = __ccgo_fp(XTcl_GetObjResult)
	*(*uintptr)(unsafe.Add(p, 1352)) = __ccgo_fp(XTcl_GetOpenFile)
	*(*uintptr)(unsafe.Add(p, 1360)) = __ccgo_fp(XTcl_GetPathType)
	*(*uintptr)(unsafe.Add(p, 1368)) = __ccgo_fp(XTcl_Gets)
	*(*uintptr)(unsafe.Add(p, 1376)) = __ccgo_fp(XTcl_GetsObj)
	*(*uintptr)(unsafe.Add(p, 1384)) = __ccgo_fp(XTcl_GetServiceMode)
	*(*uintptr)(unsafe.Add(p, 1392)) = __ccgo_fp(XTcl_GetChild)
	*(*uintptr)(unsafe.Add(p, 1400)) = __ccgo_fp(XTcl_GetStdChannel)
	*(*uintptr)(unsafe.Add(p, 1424)) = __ccgo_fp(XTcl_GetVar2)
	*(*uintptr)(unsafe.Add(p, 1448)) = __ccgo_fp(XTcl_HideCommand)
	*(*uintptr)(unsafe.Add(p, 1456)) = __ccgo_fp(XTcl_Init)
	*(*uintptr)(unsafe.Add(p, 1464)) = __ccgo_fp(XTcl_InitHashTable)
	*(*uintptr)(unsafe.Add(p, 1472)) = __ccgo_fp(XTcl_InputBlocked)
	*(*uintptr)(unsafe.Add(p, 1480)) = __ccgo_fp(XTcl_InputBuffered)
	*(*uintptr)(unsafe.Add(p, 1488)) = __ccgo_fp(XTcl_InterpDeleted)
	*(*uintptr)(unsafe.Add(p, 1496)) = __ccgo_fp(XTcl_IsSafe)
	*(*uintptr)(unsafe.Add(p, 1504)) = __ccgo_fp(XTcl_JoinPath)
	*(*uintptr)(unsafe.Add(p, 1512)) = __ccgo_fp(XTcl_LinkVar)
	*(*uintptr)(unsafe.Add(p, 1528)) = __ccgo_fp(XTcl_MakeFileChannel)
	*(*uintptr)(unsafe.Add(p, 1544)) = __ccgo_fp(XTcl_MakeTcpClientChannel)
	*(*uintptr)(unsafe.Add(p, 1552)) = __ccgo_fp(XTcl_Merge)
	*(*uintptr)(unsafe.Add(p, 1560)) = __ccgo_fp(XTcl_NextHashEntry)
	*(*uintptr)(unsafe.Add(p, 1568)) = __ccgo_fp(XTcl_NotifyChannel)
	*(*uintptr)(unsafe.Add(p, 1576)) = __ccgo_fp(XTcl_ObjGetVar2)
	*(*uintptr)(unsafe.Add(p, 1584)) = __ccgo_fp(XTcl_ObjSetVar2)
	*(*uintptr)(unsafe.Add(p, 1592)) = __ccgo_fp(XTcl_OpenCommandChannel)
	*(*uintptr)(unsafe.Add(p, 1600)) = __ccgo_fp(XTcl_OpenFileChannel)
	*(*uintptr)(unsafe.Add(p, 1608)) = __ccgo_fp(XTcl_OpenTcpClient)
	*(*uintptr)(unsafe.Add(p, 1616)) = __ccgo_fp(XTcl_OpenTcpServer)
	*(*uintptr)(unsafe.Add(p, 1624)) = __ccgo_fp(XTcl_Preserve)
	*(*uintptr)(unsafe.Add(p, 1632)) = __ccgo_fp(XTcl_PrintDouble)
	*(*uintptr)(unsafe.Add(p, 1640)) = __ccgo_fp(XTcl_PutEnv)
	*(*uintptr)(unsafe.Add(p, 1648)) = __ccgo_fp(XTcl_PosixError)
	*(*uintptr)(unsafe.Add(p, 1656)) = __ccgo_fp(XTcl_QueueEvent)
	*(*uintptr)(unsafe.Add(p, 1664)) = __ccgo_fp(XTcl_Read)
	*(*uintptr)(unsafe.Add(p, 1672)) = __ccgo_fp(XTcl_ReapDetachedProcs)
	*(*uintptr)(unsafe.Add(p, 1680)) = __ccgo_fp(XTcl_RecordAndEval)
	*(*uintptr)(unsafe.Add(p, 1688)) = __ccgo_fp(XTcl_RecordAndEvalObj)
	*(*uintptr)(unsafe.Add(p, 1696)) = __ccgo_fp(XTcl_RegisterChannel)
	*(*uintptr)(unsafe.Add(p, 1704)) = __ccgo_fp(XTcl_RegisterObjType)
	*(*uintptr)(unsafe.Add(p, 1712)) = __ccgo_fp(XTcl_RegExpCompile)
	*(*uintptr)(unsafe.Add(p, 1720)) = __ccgo_fp(XTcl_RegExpExec)
	*(*uintptr)(unsafe.Add(p, 1728)) = __ccgo_fp(XTcl_RegExpMatch)
	*(*uintptr)(unsafe.Add(p, 1736)) = __ccgo_fp(XTcl_RegExpRange)
	*(*uintptr)(unsafe.Add(p, 1744)) = __ccgo_fp(XTcl_Release)
	*(*uintptr)(unsafe.Add(p, 1752)) = __ccgo_fp(XTcl_ResetResult)
	*(*uintptr)(unsafe.Add(p, 1760)) = __ccgo_fp(XTcl_ScanElement)
	*(*uintptr)(unsafe.Add(p, 1768)) = __ccgo_fp(XTcl_ScanCountedElement)
	*(*uintptr)(unsafe.Add(p, 1784)) = __ccgo_fp(XTcl_ServiceAll)
	*(*uintptr)(unsafe.Add(p, 1792)) = __ccgo_fp(XTcl_ServiceEvent)
	*(*uintptr)(unsafe.Add(p, 1800)) = __ccgo_fp(XTcl_SetAssocData)
	*(*uintptr)(unsafe.Add(p, 1808)) = __ccgo_fp(XTcl_SetChannelBufferSize)
	*(*uintptr)(unsafe.Add(p, 1816)) = __ccgo_fp(XTcl_SetChannelOption)
	*(*uintptr)(unsafe.Add(p, 1824)) = __ccgo_fp(XTcl_SetCommandInfo)
	*(*uintptr)(unsafe.Add(p, 1832)) = __ccgo_fp(XTcl_SetErrno)
	*(*uintptr)(unsafe.Add(p, 1840)) = __ccgo_fp(XTcl_SetErrorCode)
	*(*uintptr)(unsafe.Add(p, 1848)) = __ccgo_fp(XTcl_SetMaxBlockTime)
	*(*uintptr)(unsafe.Add(p, 1864)) = __ccgo_fp(XTcl_SetRecursionLimit)
	*(*uintptr)(unsafe.Add(p, 1880)) = __ccgo_fp(XTcl_SetServiceMode)
	*(*uintptr)(unsafe.Add(p, 1888)) = __ccgo_fp(XTcl_SetObjErrorCode)
	*(*uintptr)(unsafe.Add(p, 1896)) = __ccgo_fp(XTcl_SetObjResult)
	*(*uintptr)(unsafe.Add(p, 1904)) = __ccgo_fp(XTcl_SetStdChannel)
	*(*uintptr)(unsafe.Add(p, 1920)) = __ccgo_fp(XTcl_SetVar2)
	*(*uintptr)(unsafe.Add(p, 1928)) = __ccgo_fp(XTcl_SignalId)
	*(*uintptr)(unsafe.Add(p, 1936)) = __ccgo_fp(XTcl_SignalMsg)
	*(*uintptr)(unsafe.Add(p, 1944)) = __ccgo_fp(XTcl_SourceRCFile)
	*(*uintptr)(unsafe.Add(p, 1952)) = __ccgo_fp(XTclSplitList)
	*(*uintptr)(unsafe.Add(p, 1960)) = __ccgo_fp(XTclSplitPath)
	*(*uintptr)(unsafe.Add(p, 2000)) = __ccgo_fp(XTcl_TraceVar2)
	*(*uintptr)(unsafe.Add(p, 2008)) = __ccgo_fp(XTcl_TranslateFileName)
	*(*uintptr)(unsafe.Add(p, 2016)) = __ccgo_fp(XTcl_Ungets)
	*(*uintptr)(unsafe.Add(p, 2024)) = __ccgo_fp(XTcl_UnlinkVar)
	*(*uintptr)(unsafe.Add(p, 2032)) = __ccgo_fp(XTcl_UnregisterChannel)
	*(*uintptr)(unsafe.Add(p, 2048)) = __ccgo_fp(XTcl_UnsetVar2)
	*(*uintptr)(unsafe.Add(p, 2064)) = __ccgo_fp(XTcl_UntraceVar2)
	*(*uintptr)(unsafe.Add(p, 2072)) = __ccgo_fp(XTcl_UpdateLinkedVar)
	*(*uintptr)(unsafe.Add(p, 2088)) = __ccgo_fp(XTcl_UpVar2)
	*(*uintptr)(unsafe.Add(p, 2096)) = __ccgo_fp(XTcl_VarEval)
	*(*uintptr)(unsafe.Add(p, 2112)) = __ccgo_fp(XTcl_VarTraceInfo2)
	*(*uintptr)(unsafe.Add(p, 2120)) = __ccgo_fp(XTcl_Write)
	*(*uintptr)(unsafe.Add(p, 2128)) = __ccgo_fp(XTcl_WrongNumArgs)
	*(*uintptr)(unsafe.Add(p, 2136)) = __ccgo_fp(XTcl_DumpActiveMemory)
	*(*uintptr)(unsafe.Add(p, 2144)) = __ccgo_fp(XTcl_ValidateAllMemory)
	*(*uintptr)(unsafe.Add(p, 2168)) = __ccgo_fp(XTcl_HashStats)
	*(*uintptr)(unsafe.Add(p, 2176)) = __ccgo_fp(XTcl_ParseVar)
	*(*uintptr)(unsafe.Add(p, 2192)) = __ccgo_fp(XTcl_PkgPresentEx)
	*(*uintptr)(unsafe.Add(p, 2232)) = __ccgo_fp(XTcl_WaitPid)
	*(*uintptr)(unsafe.Add(p, 2248)) = __ccgo_fp(XTcl_GetVersion)
	*(*uintptr)(unsafe.Add(p, 2256)) = __ccgo_fp(XTcl_InitMemory)
	*(*uintptr)(unsafe.Add(p, 2264)) = __ccgo_fp(XTcl_StackChannel)
	*(*uintptr)(unsafe.Add(p, 2272)) = __ccgo_fp(XTcl_UnstackChannel)
	*(*uintptr)(unsafe.Add(p, 2280)) = __ccgo_fp(XTcl_GetStackedChannel)
	*(*uintptr)(unsafe.Add(p, 2288)) = __ccgo_fp(XTcl_SetMainLoop)
	*(*uintptr)(unsafe.Add(p, 2296)) = __ccgo_fp(XTcl_GetAliasObj)
	*(*uintptr)(unsafe.Add(p, 2304)) = __ccgo_fp(XTcl_AppendObjToObj)
	*(*uintptr)(unsafe.Add(p, 2312)) = __ccgo_fp(XTcl_CreateEncoding)
	*(*uintptr)(unsafe.Add(p, 2320)) = __ccgo_fp(XTcl_CreateThreadExitHandler)
	*(*uintptr)(unsafe.Add(p, 2328)) = __ccgo_fp(XTcl_DeleteThreadExitHandler)
	*(*uintptr)(unsafe.Add(p, 2344)) = __ccgo_fp(XTcl_EvalEx)
	*(*uintptr)(unsafe.Add(p, 2352)) = __ccgo_fp(XTcl_EvalObjv)
	*(*uintptr)(unsafe.Add(p, 2360)) = __ccgo_fp(XTcl_EvalObjEx)
	*(*uintptr)(unsafe.Add(p, 2368)) = __ccgo_fp(XTcl_ExitThread)
	*(*uintptr)(unsafe.Add(p, 2376)) = __ccgo_fp(XTcl_ExternalToUtf)
	*(*uintptr)(unsafe.Add(p, 2384)) = __ccgo_fp(XTcl_ExternalToUtfDString)
	*(*uintptr)(unsafe.Add(p, 2392)) = __ccgo_fp(XTcl_FinalizeThread)
	*(*uintptr)(unsafe.Add(p, 2400)) = __ccgo_fp(XTcl_FinalizeNotifier)
	*(*uintptr)(unsafe.Add(p, 2408)) = __ccgo_fp(XTcl_FreeEncoding)
	*(*uintptr)(unsafe.Add(p, 2416)) = __ccgo_fp(XTcl_GetCurrentThread)
	*(*uintptr)(unsafe.Add(p, 2424)) = __ccgo_fp(XTcl_GetEncoding)
	*(*uintptr)(unsafe.Add(p, 2432)) = __ccgo_fp(XTcl_GetEncodingName)
	*(*uintptr)(unsafe.Add(p, 2440)) = __ccgo_fp(XTcl_GetEncodingNames)
	*(*uintptr)(unsafe.Add(p, 2448)) = __ccgo_fp(XTcl_GetIndexFromObjStruct)
	*(*uintptr)(unsafe.Add(p, 2456)) = __ccgo_fp(XTcl_GetThreadData)
	*(*uintptr)(unsafe.Add(p, 2464)) = __ccgo_fp(XTcl_GetVar2Ex)
	*(*uintptr)(unsafe.Add(p, 2472)) = __ccgo_fp(XTcl_InitNotifier)
	*(*uintptr)(unsafe.Add(p, 2480)) = __ccgo_fp(XTcl_MutexLock)
	*(*uintptr)(unsafe.Add(p, 2488)) = __ccgo_fp(XTcl_MutexUnlock)
	*(*uintptr)(unsafe.Add(p, 2496)) = __ccgo_fp(XTcl_ConditionNotify)
	*(*uintptr)(unsafe.Add(p, 2504)) = __ccgo_fp(XTcl_ConditionWait)
	*(*uintptr)(unsafe.Add(p, 2512)) = __ccgo_fp(XTclNumUtfChars)
	*(*uintptr)(unsafe.Add(p, 2520)) = __ccgo_fp(XTcl_ReadChars)
	*(*uintptr)(unsafe.Add(p, 2544)) = __ccgo_fp(XTcl_SetSystemEncoding)
	*(*uintptr)(unsafe.Add(p, 2552)) = __ccgo_fp(XTcl_SetVar2Ex)
	*(*uintptr)(unsafe.Add(p, 2560)) = __ccgo_fp(XTcl_ThreadAlert)
	*(*uintptr)(unsafe.Add(p, 2568)) = __ccgo_fp(XTcl_ThreadQueueEvent)
	*(*uintptr)(unsafe.Add(p, 2576)) = __ccgo_fp(XTcl_UniCharAtIndex)
	*(*uintptr)(unsafe.Add(p, 2584)) = __ccgo_fp(XTcl_UniCharToLower)
	*(*uintptr)(unsafe.Add(p, 2592)) = __ccgo_fp(XTcl_UniCharToTitle)
	*(*uintptr)(unsafe.Add(p, 2600)) = __ccgo_fp(XTcl_UniCharToUpper)
	*(*uintptr)(unsafe.Add(p, 2608)) = __ccgo_fp(XTcl_UniCharToUtf)
	*(*uintptr)(unsafe.Add(p, 2616)) = __ccgo_fp(XTclUtfAtIndex)
	*(*uintptr)(unsafe.Add(p, 2624)) = __ccgo_fp(XTcl_UtfCharComplete)
	*(*uintptr)(unsafe.Add(p, 2632)) = __ccgo_fp(XTcl_UtfBackslash)
	*(*uintptr)(unsafe.Add(p, 2640)) = __ccgo_fp(XTcl_UtfFindFirst)
	*(*uintptr)(unsafe.Add(p, 2648)) = __ccgo_fp(XTcl_UtfFindLast)
	*(*uintptr)(unsafe.Add(p, 2656)) = __ccgo_fp(XTcl_UtfNext)
	*(*uintptr)(unsafe.Add(p, 2664)) = __ccgo_fp(XTcl_UtfPrev)
	*(*uintptr)(unsafe.Add(p, 2672)) = __ccgo_fp(XTcl_UtfToExternal)
	*(*uintptr)(unsafe.Add(p, 2680)) = __ccgo_fp(XTcl_UtfToExternalDString)
	*(*uintptr)(unsafe.Add(p, 2688)) = __ccgo_fp(XTcl_UtfToLower)
	*(*uintptr)(unsafe.Add(p, 2696)) = __ccgo_fp(XTcl_UtfToTitle)
	*(*uintptr)(unsafe.Add(p, 2704)) = __ccgo_fp(XTcl_UtfToChar16)
	*(*uintptr)(unsafe.Add(p, 2712)) = __ccgo_fp(XTcl_UtfToUpper)
	*(*uintptr)(unsafe.Add(p, 2720)) = __ccgo_fp(XTcl_WriteChars)
	*(*uintptr)(unsafe.Add(p, 2728)) = __ccgo_fp(XTcl_WriteObj)
	*(*uintptr)(unsafe.Add(p, 2736)) = __ccgo_fp(XTcl_GetString)
	*(*uintptr)(unsafe.Add(p, 2760)) = __ccgo_fp(XTcl_AlertNotifier)
	*(*uintptr)(unsafe.Add(p, 2768)) = __ccgo_fp(XTcl_ServiceModeHook)
	*(*uintptr)(unsafe.Add(p, 2776)) = __ccgo_fp(XTcl_UniCharIsAlnum)
	*(*uintptr)(unsafe.Add(p, 2784)) = __ccgo_fp(XTcl_UniCharIsAlpha)
	*(*uintptr)(unsafe.Add(p, 2792)) = __ccgo_fp(XTcl_UniCharIsDigit)
	*(*uintptr)(unsafe.Add(p, 2800)) = __ccgo_fp(XTcl_UniCharIsLower)
	*(*uintptr)(unsafe.Add(p, 2808)) = __ccgo_fp(XTcl_UniCharIsSpace)
	*(*uintptr)(unsafe.Add(p, 2816)) = __ccgo_fp(XTcl_UniCharIsUpper)
	*(*uintptr)(unsafe.Add(p, 2824)) = __ccgo_fp(XTcl_UniCharIsWordChar)
	*(*uintptr)(unsafe.Add(p, 2832)) = __ccgo_fp(XTcl_Char16Len)
	*(*uintptr)(unsafe.Add(p, 2848)) = __ccgo_fp(XTcl_Char16ToUtfDString)
	*(*uintptr)(unsafe.Add(p, 2856)) = __ccgo_fp(XTcl_UtfToChar16DString)
	*(*uintptr)(unsafe.Add(p, 2864)) = __ccgo_fp(XTcl_GetRegExpFromObj)
	*(*uintptr)(unsafe.Add(p, 2880)) = __ccgo_fp(XTcl_FreeParse)
	*(*uintptr)(unsafe.Add(p, 2888)) = __ccgo_fp(XTcl_LogCommandInfo)
	*(*uintptr)(unsafe.Add(p, 2896)) = __ccgo_fp(XTcl_ParseBraces)
	*(*uintptr)(unsafe.Add(p, 2904)) = __ccgo_fp(XTcl_ParseCommand)
	*(*uintptr)(unsafe.Add(p, 2912)) = __ccgo_fp(XTcl_ParseExpr)
	*(*uintptr)(unsafe.Add(p, 2920)) = __ccgo_fp(XTcl_ParseQuotedString)
	*(*uintptr)(unsafe.Add(p, 2928)) = __ccgo_fp(XTcl_ParseVarName)
	*(*uintptr)(unsafe.Add(p, 2936)) = __ccgo_fp(XTcl_GetCwd)
	*(*uintptr)(unsafe.Add(p, 2944)) = __ccgo_fp(XTcl_Chdir)
	*(*uintptr)(unsafe.Add(p, 2952)) = __ccgo_fp(XTcl_Access)
	*(*uintptr)(unsafe.Add(p, 2960)) = __ccgo_fp(XTcl_Stat)
	*(*uintptr)(unsafe.Add(p, 2968)) = __ccgo_fp(XTclUtfNcmp)
	*(*uintptr)(unsafe.Add(p, 2976)) = __ccgo_fp(XTclUtfNcasecmp)
	*(*uintptr)(unsafe.Add(p, 2984)) = __ccgo_fp(XTcl_StringCaseMatch)
	*(*uintptr)(unsafe.Add(p, 2992)) = __ccgo_fp(XTcl_UniCharIsControl)
	*(*uintptr)(unsafe.Add(p, 3000)) = __ccgo_fp(XTcl_UniCharIsGraph)
	*(*uintptr)(unsafe.Add(p, 3008)) = __ccgo_fp(XTcl_UniCharIsPrint)
	*(*uintptr)(unsafe.Add(p, 3016)) = __ccgo_fp(XTcl_UniCharIsPunct)
	*(*uintptr)(unsafe.Add(p, 3024)) = __ccgo_fp(XTcl_RegExpExecObj)
	*(*uintptr)(unsafe.Add(p, 3032)) = __ccgo_fp(XTcl_RegExpGetInfo)
	*(*uintptr)(unsafe.Add(p, 3040)) = __ccgo_fp(XTcl_NewUnicodeObj)
	*(*uintptr)(unsafe.Add(p, 3048)) = __ccgo_fp(XTcl_SetUnicodeObj)
	*(*uintptr)(unsafe.Add(p, 3056)) = __ccgo_fp(XTclGetCharLength)
	*(*uintptr)(unsafe.Add(p, 3064)) = __ccgo_fp(XTclGetUniChar)
	*(*uintptr)(unsafe.Add(p, 3080)) = __ccgo_fp(XTclGetRange)
	*(*uintptr)(unsafe.Add(p, 3088)) = __ccgo_fp(XTcl_AppendUnicodeToObj)
	*(*uintptr)(unsafe.Add(p, 3096)) = __ccgo_fp(XTcl_RegExpMatchObj)
	*(*uintptr)(unsafe.Add(p, 3104)) = __ccgo_fp(XTcl_SetNotifier)
	*(*uintptr)(unsafe.Add(p, 3112)) = __ccgo_fp(XTcl_GetAllocMutex)
	*(*uintptr)(unsafe.Add(p, 3120)) = __ccgo_fp(XTcl_GetChannelNames)
	*(*uintptr)(unsafe.Add(p, 3128)) = __ccgo_fp(XTcl_GetChannelNamesEx)
	*(*uintptr)(unsafe.Add(p, 3136)) = __ccgo_fp(XTcl_ProcObjCmd)
	*(*uintptr)(unsafe.Add(p, 3144)) = __ccgo_fp(XTcl_ConditionFinalize)
	*(*uintptr)(unsafe.Add(p, 3152)) = __ccgo_fp(XTcl_MutexFinalize)
	*(*uintptr)(unsafe.Add(p, 3160)) = __ccgo_fp(XTcl_CreateThread)
	*(*uintptr)(unsafe.Add(p, 3168)) = __ccgo_fp(XTcl_ReadRaw)
	*(*uintptr)(unsafe.Add(p, 3176)) = __ccgo_fp(XTcl_WriteRaw)
	*(*uintptr)(unsafe.Add(p, 3184)) = __ccgo_fp(XTcl_GetTopChannel)
	*(*uintptr)(unsafe.Add(p, 3192)) = __ccgo_fp(XTcl_ChannelBuffered)
	*(*uintptr)(unsafe.Add(p, 3200)) = __ccgo_fp(XTcl_ChannelName)
	*(*uintptr)(unsafe.Add(p, 3208)) = __ccgo_fp(XTcl_ChannelVersion)
	*(*uintptr)(unsafe.Add(p, 3216)) = __ccgo_fp(XTcl_ChannelBlockModeProc)
	*(*uintptr)(unsafe.Add(p, 3232)) = __ccgo_fp(XTcl_ChannelClose2Proc)
	*(*uintptr)(unsafe.Add(p, 3240)) = __ccgo_fp(XTcl_ChannelInputProc)
	*(*uintptr)(unsafe.Add(p, 3248)) = __ccgo_fp(XTcl_ChannelOutputProc)
	*(*uintptr)(unsafe.Add(p, 3264)) = __ccgo_fp(XTcl_ChannelSetOptionProc)
	*(*uintptr)(unsafe.Add(p, 3272)) = __ccgo_fp(XTcl_ChannelGetOptionProc)
	*(*uintptr)(unsafe.Add(p, 3280)) = __ccgo_fp(XTcl_ChannelWatchProc)
	*(*uintptr)(unsafe.Add(p, 3288)) = __ccgo_fp(XTcl_ChannelGetHandleProc)
	*(*uintptr)(unsafe.Add(p, 3296)) = __ccgo_fp(XTcl_ChannelFlushProc)
	*(*uintptr)(unsafe.Add(p, 3304)) = __ccgo_fp(XTcl_ChannelHandlerProc)
	*(*uintptr)(unsafe.Add(p, 3312)) = __ccgo_fp(XTcl_JoinThread)
	*(*uintptr)(unsafe.Add(p, 3320)) = __ccgo_fp(XTcl_IsChannelShared)
	*(*uintptr)(unsafe.Add(p, 3328)) = __ccgo_fp(XTcl_IsChannelRegistered)
	*(*uintptr)(unsafe.Add(p, 3336)) = __ccgo_fp(XTcl_CutChannel)
	*(*uintptr)(unsafe.Add(p, 3344)) = __ccgo_fp(XTcl_SpliceChannel)
	*(*uintptr)(unsafe.Add(p, 3352)) = __ccgo_fp(XTcl_ClearChannelHandlers)
	*(*uintptr)(unsafe.Add(p, 3360)) = __ccgo_fp(XTcl_IsChannelExisting)
	*(*uintptr)(unsafe.Add(p, 3400)) = __ccgo_fp(XTcl_InitCustomHashTable)
	*(*uintptr)(unsafe.Add(p, 3408)) = __ccgo_fp(XTcl_InitObjHashTable)
	*(*uintptr)(unsafe.Add(p, 3416)) = __ccgo_fp(XTcl_CommandTraceInfo)
	*(*uintptr)(unsafe.Add(p, 3424)) = __ccgo_fp(XTcl_TraceCommand)
	*(*uintptr)(unsafe.Add(p, 3432)) = __ccgo_fp(XTcl_UntraceCommand)
	*(*uintptr)(unsafe.Add(p, 3440)) = __ccgo_fp(XTclpAlloc)
	*(*uintptr)(unsafe.Add(p, 3448)) = __ccgo_fp(XTcl_AttemptDbCkalloc)
	*(*uintptr)(unsafe.Add(p, 3456)) = __ccgo_fp(XTclpRealloc)
	*(*uintptr)(unsafe.Add(p, 3464)) = __ccgo_fp(XTcl_AttemptDbCkrealloc)
	*(*uintptr)(unsafe.Add(p, 3472)) = __ccgo_fp(XTcl_AttemptSetObjLength)
	*(*uintptr)(unsafe.Add(p, 3480)) = __ccgo_fp(XTcl_GetChannelThread)
	*(*uintptr)(unsafe.Add(p, 3488)) = __ccgo_fp(XTclGetUnicodeFromObj)
	*(*uintptr)(unsafe.Add(p, 3512)) = __ccgo_fp(XTcl_SubstObj)
	*(*uintptr)(unsafe.Add(p, 3520)) = __ccgo_fp(XTcl_DetachChannel)
	*(*uintptr)(unsafe.Add(p, 3528)) = __ccgo_fp(XTcl_IsStandardChannel)
	*(*uintptr)(unsafe.Add(p, 3536)) = __ccgo_fp(XTcl_FSCopyFile)
	*(*uintptr)(unsafe.Add(p, 3544)) = __ccgo_fp(XTcl_FSCopyDirectory)
	*(*uintptr)(unsafe.Add(p, 3552)) = __ccgo_fp(XTcl_FSCreateDirectory)
	*(*uintptr)(unsafe.Add(p, 3560)) = __ccgo_fp(XTcl_FSDeleteFile)
	*(*uintptr)(unsafe.Add(p, 3568)) = __ccgo_fp(XTcl_FSLoadFile)
	*(*uintptr)(unsafe.Add(p, 3576)) = __ccgo_fp(XTcl_FSMatchInDirectory)
	*(*uintptr)(unsafe.Add(p, 3584)) = __ccgo_fp(XTcl_FSLink)
	*(*uintptr)(unsafe.Add(p, 3592)) = __ccgo_fp(XTcl_FSRemoveDirectory)
	*(*uintptr)(unsafe.Add(p, 3600)) = __ccgo_fp(XTcl_FSRenameFile)
	*(*uintptr)(unsafe.Add(p, 3608)) = __ccgo_fp(XTcl_FSLstat)
	*(*uintptr)(unsafe.Add(p, 3616)) = __ccgo_fp(XTcl_FSUtime)
	*(*uintptr)(unsafe.Add(p, 3624)) = __ccgo_fp(XTcl_FSFileAttrsGet)
	*(*uintptr)(unsafe.Add(p, 3632)) = __ccgo_fp(XTcl_FSFileAttrsSet)
	*(*uintptr)(unsafe.Add(p, 3640)) = __ccgo_fp(XTcl_FSFileAttrStrings)
	*(*uintptr)(unsafe.Add(p, 3648)) = __ccgo_fp(XTcl_FSStat)
	*(*uintptr)(unsafe.Add(p, 3656)) = __ccgo_fp(XTcl_FSAccess)
	*(*uintptr)(unsafe.Add(p, 3664)) = __ccgo_fp(XTcl_FSOpenFileChannel)
	*(*uintptr)(unsafe.Add(p, 3672)) = __ccgo_fp(XTcl_FSGetCwd)
	*(*uintptr)(unsafe.Add(p, 3680)) = __ccgo_fp(XTcl_FSChdir)
	*(*uintptr)(unsafe.Add(p, 3688)) = __ccgo_fp(XTcl_FSConvertToPathType)
	*(*uintptr)(unsafe.Add(p, 3696)) = __ccgo_fp(XTcl_FSJoinPath)
	*(*uintptr)(unsafe.Add(p, 3704)) = __ccgo_fp(XTclFSSplitPath)
	*(*uintptr)(unsafe.Add(p, 3712)) = __ccgo_fp(XTcl_FSEqualPaths)
	*(*uintptr)(unsafe.Add(p, 3720)) = __ccgo_fp(XTcl_FSGetNormalizedPath)
	*(*uintptr)(unsafe.Add(p, 3728)) = __ccgo_fp(XTcl_FSJoinToPath)
	*(*uintptr)(unsafe.Add(p, 3736)) = __ccgo_fp(XTcl_FSGetInternalRep)
	*(*uintptr)(unsafe.Add(p, 3744)) = __ccgo_fp(XTcl_FSGetTranslatedPath)
	*(*uintptr)(unsafe.Add(p, 3752)) = __ccgo_fp(XTcl_FSEvalFile)
	*(*uintptr)(unsafe.Add(p, 3760)) = __ccgo_fp(XTcl_FSNewNativePath)
	*(*uintptr)(unsafe.Add(p, 3768)) = __ccgo_fp(XTcl_FSGetNativePath)
	*(*uintptr)(unsafe.Add(p, 3776)) = __ccgo_fp(XTcl_FSFileSystemInfo)
	*(*uintptr)(unsafe.Add(p, 3784)) = __ccgo_fp(XTcl_FSPathSeparator)
	*(*uintptr)(unsafe.Add(p, 3792)) = __ccgo_fp(XTcl_FSListVolumes)
	*(*uintptr)(unsafe.Add(p, 3800)) = __ccgo_fp(XTcl_FSRegister)
	*(*uintptr)(unsafe.Add(p, 3808)) = __ccgo_fp(XTcl_FSUnregister)
	*(*uintptr)(unsafe.Add(p, 3816)) = __ccgo_fp(XTcl_FSData)
	*(*uintptr)(unsafe.Add(p, 3824)) = __ccgo_fp(XTcl_FSGetTranslatedStringPath)
	*(*uintptr)(unsafe.Add(p, 3832)) = __ccgo_fp(XTcl_FSGetFileSystemForPath)
	*(*uintptr)(unsafe.Add(p, 3840)) = __ccgo_fp(XTcl_FSGetPathType)
	*(*uintptr)(unsafe.Add(p, 3848)) = __ccgo_fp(XTcl_OutputBuffered)
	*(*uintptr)(unsafe.Add(p, 3856)) = __ccgo_fp(XTcl_FSMountsChanged)
	*(*uintptr)(unsafe.Add(p, 3864)) = __ccgo_fp(XTcl_EvalTokensStandard)
	*(*uintptr)(unsafe.Add(p, 3872)) = __ccgo_fp(XTcl_GetTime)
	*(*uintptr)(unsafe.Add(p, 3880)) = __ccgo_fp(XTcl_CreateObjTrace)
	*(*uintptr)(unsafe.Add(p, 3888)) = __ccgo_fp(XTcl_GetCommandInfoFromToken)
	*(*uintptr)(unsafe.Add(p, 3896)) = __ccgo_fp(XTcl_SetCommandInfoFromToken)
	*(*uintptr)(unsafe.Add(p, 3904)) = __ccgo_fp(XTcl_DbNewWideIntObj)
	*(*uintptr)(unsafe.Add(p, 3912)) = __ccgo_fp(XTcl_GetWideIntFromObj)
	*(*uintptr)(unsafe.Add(p, 3920)) = __ccgo_fp(XTcl_NewWideIntObj)
	*(*uintptr)(unsafe.Add(p, 3928)) = __ccgo_fp(XTcl_SetWideIntObj)
	*(*uintptr)(unsafe.Add(p, 3936)) = __ccgo_fp(XTcl_AllocStatBuf)
	*(*uintptr)(unsafe.Add(p, 3944)) = __ccgo_fp(XTcl_Seek)
	*(*uintptr)(unsafe.Add(p, 3952)) = __ccgo_fp(XTcl_Tell)
	*(*uintptr)(unsafe.Add(p, 3960)) = __ccgo_fp(XTcl_ChannelWideSeekProc)
	*(*uintptr)(unsafe.Add(p, 3968)) = __ccgo_fp(XTcl_DictObjPut)
	*(*uintptr)(unsafe.Add(p, 3976)) = __ccgo_fp(XTcl_DictObjGet)
	*(*uintptr)(unsafe.Add(p, 3984)) = __ccgo_fp(XTcl_DictObjRemove)
	*(*uintptr)(unsafe.Add(p, 3992)) = __ccgo_fp(XTclDictObjSize)
	*(*uintptr)(unsafe.Add(p, 4000)) = __ccgo_fp(XTcl_DictObjFirst)
	*(*uintptr)(unsafe.Add(p, 4008)) = __ccgo_fp(XTcl_DictObjNext)
	*(*uintptr)(unsafe.Add(p, 4016)) = __ccgo_fp(XTcl_DictObjDone)
	*(*uintptr)(unsafe.Add(p, 4024)) = __ccgo_fp(XTcl_DictObjPutKeyList)
	*(*uintptr)(unsafe.Add(p, 4032)) = __ccgo_fp(XTcl_DictObjRemoveKeyList)
	*(*uintptr)(unsafe.Add(p, 4040)) = __ccgo_fp(XTcl_NewDictObj)
	*(*uintptr)(unsafe.Add(p, 4048)) = __ccgo_fp(XTcl_DbNewDictObj)
	*(*uintptr)(unsafe.Add(p, 4056)) = __ccgo_fp(XTcl_RegisterConfig)
	*(*uintptr)(unsafe.Add(p, 4064)) = __ccgo_fp(XTcl_CreateNamespace)
	*(*uintptr)(unsafe.Add(p, 4072)) = __ccgo_fp(XTcl_DeleteNamespace)
	*(*uintptr)(unsafe.Add(p, 4080)) = __ccgo_fp(XTcl_AppendExportList)
	*(*uintptr)(unsafe.Add(p, 4088)) = __ccgo_fp(XTcl_Export)
	*(*uintptr)(unsafe.Add(p, 4096)) = __ccgo_fp(XTcl_Import)
	*(*uintptr)(unsafe.Add(p, 4104)) = __ccgo_fp(XTcl_ForgetImport)
	*(*uintptr)(unsafe.Add(p, 4112)) = __ccgo_fp(XTcl_GetCurrentNamespace)
	*(*uintptr)(unsafe.Add(p, 4120)) = __ccgo_fp(XTcl_GetGlobalNamespace)
	*(*uintptr)(unsafe.Add(p, 4128)) = __ccgo_fp(XTcl_FindNamespace)
	*(*uintptr)(unsafe.Add(p, 4136)) = __ccgo_fp(XTcl_FindCommand)
	*(*uintptr)(unsafe.Add(p, 4144)) = __ccgo_fp(XTcl_GetCommandFromObj)
	*(*uintptr)(unsafe.Add(p, 4152)) = __ccgo_fp(XTcl_GetCommandFullName)
	*(*uintptr)(unsafe.Add(p, 4160)) = __ccgo_fp(XTcl_FSEvalFileEx)
	*(*uintptr)(unsafe.Add(p, 4176)) = __ccgo_fp(XTcl_LimitAddHandler)
	*(*uintptr)(unsafe.Add(p, 4184)) = __ccgo_fp(XTcl_LimitRemoveHandler)
	*(*uintptr)(unsafe.Add(p, 4192)) = __ccgo_fp(XTcl_LimitReady)
	*(*uintptr)(unsafe.Add(p, 4200)) = __ccgo_fp(XTcl_LimitCheck)
	*(*uintptr)(unsafe.Add(p, 4208)) = __ccgo_fp(XTcl_LimitExceeded)
	*(*uintptr)(unsafe.Add(p, 4216)) = __ccgo_fp(XTcl_LimitSetCommands)
	*(*uintptr)(unsafe.Add(p, 4224)) = __ccgo_fp(XTcl_LimitSetTime)
	*(*uintptr)(unsafe.Add(p, 4232)) = __ccgo_fp(XTcl_LimitSetGranularity)
	*(*uintptr)(unsafe.Add(p, 4240)) = __ccgo_fp(XTcl_LimitTypeEnabled)
	*(*uintptr)(unsafe.Add(p, 4248)) = __ccgo_fp(XTcl_LimitTypeExceeded)
	*(*uintptr)(unsafe.Add(p, 4256)) = __ccgo_fp(XTcl_LimitTypeSet)
	*(*uintptr)(unsafe.Add(p, 4264)) = __ccgo_fp(XTcl_LimitTypeReset)
	*(*uintptr)(unsafe.Add(p, 4272)) = __ccgo_fp(XTcl_LimitGetCommands)
	*(*uintptr)(unsafe.Add(p, 4280)) = __ccgo_fp(XTcl_LimitGetTime)
	*(*uintptr)(unsafe.Add(p, 4288)) = __ccgo_fp(XTcl_LimitGetGranularity)
	*(*uintptr)(unsafe.Add(p, 4296)) = __ccgo_fp(XTcl_SaveInterpState)
	*(*uintptr)(unsafe.Add(p, 4304)) = __ccgo_fp(XTcl_RestoreInterpState)
	*(*uintptr)(unsafe.Add(p, 4312)) = __ccgo_fp(XTcl_DiscardInterpState)
	*(*uintptr)(unsafe.Add(p, 4320)) = __ccgo_fp(XTcl_SetReturnOptions)
	*(*uintptr)(unsafe.Add(p, 4328)) = __ccgo_fp(XTcl_GetReturnOptions)
	*(*uintptr)(unsafe.Add(p, 4336)) = __ccgo_fp(XTcl_IsEnsemble)
	*(*uintptr)(unsafe.Add(p, 4344)) = __ccgo_fp(XTcl_CreateEnsemble)
	*(*uintptr)(unsafe.Add(p, 4352)) = __ccgo_fp(XTcl_FindEnsemble)
	*(*uintptr)(unsafe.Add(p, 4360)) = __ccgo_fp(XTcl_SetEnsembleSubcommandList)
	*(*uintptr)(unsafe.Add(p, 4368)) = __ccgo_fp(XTcl_SetEnsembleMappingDict)
	*(*uintptr)(unsafe.Add(p, 4376)) = __ccgo_fp(XTcl_SetEnsembleUnknownHandler)
	*(*uintptr)(unsafe.Add(p, 4384)) = __ccgo_fp(XTcl_SetEnsembleFlags)
	*(*uintptr)(unsafe.Add(p, 4392)) = __ccgo_fp(XTcl_GetEnsembleSubcommandList)
	*(*uintptr)(unsafe.Add(p, 4400)) = __ccgo_fp(XTcl_GetEnsembleMappingDict)
	*(*uintptr)(unsafe.Add(p, 4408)) = __ccgo_fp(XTcl_GetEnsembleUnknownHandler)
	*(*uintptr)(unsafe.Add(p, 4416)) = __ccgo_fp(XTcl_GetEnsembleFlags)
	*(*uintptr)(unsafe.Add(p, 4424)) = __ccgo_fp(XTcl_GetEnsembleNamespace)
	*(*uintptr)(unsafe.Add(p, 4432)) = __ccgo_fp(XTcl_SetTimeProc)
	*(*uintptr)(unsafe.Add(p, 4440)) = __ccgo_fp(XTcl_QueryTimeProc)
	*(*uintptr)(unsafe.Add(p, 4448)) = __ccgo_fp(XTcl_ChannelThreadActionProc)
	*(*uintptr)(unsafe.Add(p, 4456)) = __ccgo_fp(XTcl_NewBignumObj)
	*(*uintptr)(unsafe.Add(p, 4464)) = __ccgo_fp(XTcl_DbNewBignumObj)
	*(*uintptr)(unsafe.Add(p, 4472)) = __ccgo_fp(XTcl_SetBignumObj)
	*(*uintptr)(unsafe.Add(p, 4480)) = __ccgo_fp(XTcl_GetBignumFromObj)
	*(*uintptr)(unsafe.Add(p, 4488)) = __ccgo_fp(XTcl_TakeBignumFromObj)
	*(*uintptr)(unsafe.Add(p, 4496)) = __ccgo_fp(XTcl_TruncateChannel)
	*(*uintptr)(unsafe.Add(p, 4504)) = __ccgo_fp(XTcl_ChannelTruncateProc)
	*(*uintptr)(unsafe.Add(p, 4512)) = __ccgo_fp(XTcl_SetChannelErrorInterp)
	*(*uintptr)(unsafe.Add(p, 4520)) = __ccgo_fp(XTcl_GetChannelErrorInterp)
	*(*uintptr)(unsafe.Add(p, 4528)) = __ccgo_fp(XTcl_SetChannelError)
	*(*uintptr)(unsafe.Add(p, 4536)) = __ccgo_fp(XTcl_GetChannelError)
	*(*uintptr)(unsafe.Add(p, 4544)) = __ccgo_fp(XTcl_InitBignumFromDouble)
	*(*uintptr)(unsafe.Add(p, 4552)) = __ccgo_fp(XTcl_GetNamespaceUnknownHandler)
	*(*uintptr)(unsafe.Add(p, 4560)) = __ccgo_fp(XTcl_SetNamespaceUnknownHandler)
	*(*uintptr)(unsafe.Add(p, 4568)) = __ccgo_fp(XTcl_GetEncodingFromObj)
	*(*uintptr)(unsafe.Add(p, 4576)) = __ccgo_fp(XTcl_GetEncodingSearchPath)
	*(*uintptr)(unsafe.Add(p, 4584)) = __ccgo_fp(XTcl_SetEncodingSearchPath)
	*(*uintptr)(unsafe.Add(p, 4592)) = __ccgo_fp(XTcl_GetEncodingNameFromEnvironment)
	*(*uintptr)(unsafe.Add(p, 4600)) = __ccgo_fp(XTcl_PkgRequireProc)
	*(*uintptr)(unsafe.Add(p, 4608)) = __ccgo_fp(XTcl_AppendObjToErrorInfo)
	*(*uintptr)(unsafe.Add(p, 4616)) = __ccgo_fp(XTcl_AppendLimitedToObj)
	*(*uintptr)(unsafe.Add(p, 4624)) = __ccgo_fp(XTcl_Format)
	*(*uintptr)(unsafe.Add(p, 4632)) = __ccgo_fp(XTcl_AppendFormatToObj)
	*(*uintptr)(unsafe.Add(p, 4640)) = __ccgo_fp(XTcl_ObjPrintf)
	*(*uintptr)(unsafe.Add(p, 4648)) = __ccgo_fp(XTcl_AppendPrintfToObj)
	*(*uintptr)(unsafe.Add(p, 4656)) = __ccgo_fp(XTcl_CancelEval)
	*(*uintptr)(unsafe.Add(p, 4664)) = __ccgo_fp(XTcl_Canceled)
	*(*uintptr)(unsafe.Add(p, 4672)) = __ccgo_fp(XTcl_CreatePipe)
	*(*uintptr)(unsafe.Add(p, 4680)) = __ccgo_fp(XTcl_NRCreateCommand)
	*(*uintptr)(unsafe.Add(p, 4688)) = __ccgo_fp(XTcl_NREvalObj)
	*(*uintptr)(unsafe.Add(p, 4696)) = __ccgo_fp(XTcl_NREvalObjv)
	*(*uintptr)(unsafe.Add(p, 4704)) = __ccgo_fp(XTcl_NRCmdSwap)
	*(*uintptr)(unsafe.Add(p, 4712)) = __ccgo_fp(XTcl_NRAddCallback)
	*(*uintptr)(unsafe.Add(p, 4720)) = __ccgo_fp(XTcl_NRCallObjProc)
	*(*uintptr)(unsafe.Add(p, 4728)) = __ccgo_fp(XTcl_GetFSDeviceFromStat)
	*(*uintptr)(unsafe.Add(p, 4736)) = __ccgo_fp(XTcl_GetFSInodeFromStat)
	*(*uintptr)(unsafe.Add(p, 4744)) = __ccgo_fp(XTcl_GetModeFromStat)
	*(*uintptr)(unsafe.Add(p, 4752)) = __ccgo_fp(XTcl_GetLinkCountFromStat)
	*(*uintptr)(unsafe.Add(p, 4760)) = __ccgo_fp(XTcl_GetUserIdFromStat)
	*(*uintptr)(unsafe.Add(p, 4768)) = __ccgo_fp(XTcl_GetGroupIdFromStat)
	*(*uintptr)(unsafe.Add(p, 4776)) = __ccgo_fp(XTcl_GetDeviceTypeFromStat)
	*(*uintptr)(unsafe.Add(p, 4784)) = __ccgo_fp(XTcl_GetAccessTimeFromStat)
	*(*uintptr)(unsafe.Add(p, 4792)) = __ccgo_fp(XTcl_GetModificationTimeFromStat)
	*(*uintptr)(unsafe.Add(p, 4800)) = __ccgo_fp(XTcl_GetChangeTimeFromStat)
	*(*uintptr)(unsafe.Add(p, 4808)) = __ccgo_fp(XTcl_GetSizeFromStat)
	*(*uintptr)(unsafe.Add(p, 4816)) = __ccgo_fp(XTcl_GetBlocksFromStat)
	*(*uintptr)(unsafe.Add(p, 4824)) = __ccgo_fp(XTcl_GetBlockSizeFromStat)
	*(*uintptr)(unsafe.Add(p, 4832)) = __ccgo_fp(XTcl_SetEnsembleParameterList)
	*(*uintptr)(unsafe.Add(p, 4840)) = __ccgo_fp(XTcl_GetEnsembleParameterList)
	*(*uintptr)(unsafe.Add(p, 4848)) = __ccgo_fp(XTclParseArgsObjv)
	*(*uintptr)(unsafe.Add(p, 4856)) = __ccgo_fp(XTcl_GetErrorLine)
	*(*uintptr)(unsafe.Add(p, 4864)) = __ccgo_fp(XTcl_SetErrorLine)
	*(*uintptr)(unsafe.Add(p, 4872)) = __ccgo_fp(XTcl_TransferResult)
	*(*uintptr)(unsafe.Add(p, 4880)) = __ccgo_fp(XTcl_InterpActive)
	*(*uintptr)(unsafe.Add(p, 4888)) = __ccgo_fp(XTcl_BackgroundException)
	*(*uintptr)(unsafe.Add(p, 4896)) = __ccgo_fp(XTcl_ZlibDeflate)
	*(*uintptr)(unsafe.Add(p, 4904)) = __ccgo_fp(XTcl_ZlibInflate)
	*(*uintptr)(unsafe.Add(p, 4912)) = __ccgo_fp(XTcl_ZlibCRC32)
	*(*uintptr)(unsafe.Add(p, 4920)) = __ccgo_fp(XTcl_ZlibAdler32)
	*(*uintptr)(unsafe.Add(p, 4928)) = __ccgo_fp(XTcl_ZlibStreamInit)
	*(*uintptr)(unsafe.Add(p, 4936)) = __ccgo_fp(XTcl_ZlibStreamGetCommandName)
	*(*uintptr)(unsafe.Add(p, 4944)) = __ccgo_fp(XTcl_ZlibStreamEof)
	*(*uintptr)(unsafe.Add(p, 4952)) = __ccgo_fp(XTcl_ZlibStreamChecksum)
	*(*uintptr)(unsafe.Add(p, 4960)) = __ccgo_fp(XTcl_ZlibStreamPut)
	*(*uintptr)(unsafe.Add(p, 4968)) = __ccgo_fp(XTcl_ZlibStreamGet)
	*(*uintptr)(unsafe.Add(p, 4976)) = __ccgo_fp(XTcl_ZlibStreamClose)
	*(*uintptr)(unsafe.Add(p, 4984)) = __ccgo_fp(XTcl_ZlibStreamReset)
	*(*uintptr)(unsafe.Add(p, 4992)) = __ccgo_fp(XTcl_SetStartupScript)
	*(*uintptr)(unsafe.Add(p, 5000)) = __ccgo_fp(XTcl_GetStartupScript)
	*(*uintptr)(unsafe.Add(p, 5008)) = __ccgo_fp(XTcl_CloseEx)
	*(*uintptr)(unsafe.Add(p, 5016)) = __ccgo_fp(XTcl_NRExprObj)
	*(*uintptr)(unsafe.Add(p, 5024)) = __ccgo_fp(XTcl_NRSubstObj)
	*(*uintptr)(unsafe.Add(p, 5032)) = __ccgo_fp(XTcl_LoadFile)
	*(*uintptr)(unsafe.Add(p, 5040)) = __ccgo_fp(XTcl_FindSymbol)
	*(*uintptr)(unsafe.Add(p, 5048)) = __ccgo_fp(XTcl_FSUnloadFile)
	*(*uintptr)(unsafe.Add(p, 5056)) = __ccgo_fp(XTcl_ZlibStreamSetCompressionDictionary)
	*(*uintptr)(unsafe.Add(p, 5064)) = __ccgo_fp(XTcl_OpenTcpServerEx)
	*(*uintptr)(unsafe.Add(p, 5072)) = __ccgo_fp(XTclZipfs_Mount)
	*(*uintptr)(unsafe.Add(p, 5080)) = __ccgo_fp(XTclZipfs_Unmount)
	*(*uintptr)(unsafe.Add(p, 5088)) = __ccgo_fp(XTclZipfs_TclLibrary)
	*(*uintptr)(unsafe.Add(p, 5096)) = __ccgo_fp(XTclZipfs_MountBuffer)
	*(*uintptr)(unsafe.Add(p, 5104)) = __ccgo_fp(XTcl_FreeInternalRep)
	*(*uintptr)(unsafe.Add(p, 5112)) = __ccgo_fp(XTcl_InitStringRep)
	*(*uintptr)(unsafe.Add(p, 5120)) = __ccgo_fp(XTcl_FetchInternalRep)
	*(*uintptr)(unsafe.Add(p, 5128)) = __ccgo_fp(XTcl_StoreInternalRep)
	*(*uintptr)(unsafe.Add(p, 5136)) = __ccgo_fp(XTcl_HasStringRep)
	*(*uintptr)(unsafe.Add(p, 5144)) = __ccgo_fp(XTcl_IncrRefCount)
	*(*uintptr)(unsafe.Add(p, 5152)) = __ccgo_fp(XTcl_DecrRefCount)
	*(*uintptr)(unsafe.Add(p, 5160)) = __ccgo_fp(XTcl_IsShared)
	*(*uintptr)(unsafe.Add(p, 5168)) = __ccgo_fp(XTcl_LinkArray)
	*(*uintptr)(unsafe.Add(p, 5176)) = __ccgo_fp(XTcl_GetIntForIndex)
	*(*uintptr)(unsafe.Add(p, 5184)) = __ccgo_fp(XTcl_UtfToUniChar)
	*(*uintptr)(unsafe.Add(p, 5192)) = __ccgo_fp(XTcl_UniCharToUtfDString)
	*(*uintptr)(unsafe.Add(p, 5200)) = __ccgo_fp(XTcl_UtfToUniCharDString)
	*(*uintptr)(unsafe.Add(p, 5208)) = __ccgo_fp(XTclGetBytesFromObj)
	*(*uintptr)(unsafe.Add(p, 5216)) = __ccgo_fp(XTcl_GetBytesFromObj)
	*(*uintptr)(unsafe.Add(p, 5224)) = __ccgo_fp(XTcl_GetStringFromObj)
	*(*uintptr)(unsafe.Add(p, 5232)) = __ccgo_fp(XTcl_GetUnicodeFromObj)
	*(*uintptr)(unsafe.Add(p, 5240)) = __ccgo_fp(XTcl_GetSizeIntFromObj)
	*(*uintptr)(unsafe.Add(p, 5248)) = __ccgo_fp(XTcl_UtfCharComplete)
	*(*uintptr)(unsafe.Add(p, 5256)) = __ccgo_fp(XTcl_UtfNext)
	*(*uintptr)(unsafe.Add(p, 5264)) = __ccgo_fp(XTcl_UtfPrev)
	*(*uintptr)(unsafe.Add(p, 5272)) = __ccgo_fp(XTcl_FSTildeExpand)
	*(*uintptr)(unsafe.Add(p, 5280)) = __ccgo_fp(XTcl_ExternalToUtfDStringEx)
	*(*uintptr)(unsafe.Add(p, 5288)) = __ccgo_fp(XTcl_UtfToExternalDStringEx)
	*(*uintptr)(unsafe.Add(p, 5296)) = __ccgo_fp(XTcl_AsyncMarkFromSignal)
	*(*uintptr)(unsafe.Add(p, 5304)) = __ccgo_fp(XTcl_ListObjGetElements)
	*(*uintptr)(unsafe.Add(p, 5312)) = __ccgo_fp(XTcl_ListObjLength)
	*(*uintptr)(unsafe.Add(p, 5320)) = __ccgo_fp(XTcl_DictObjSize)
	*(*uintptr)(unsafe.Add(p, 5328)) = __ccgo_fp(XTcl_SplitList)
	*(*uintptr)(unsafe.Add(p, 5336)) = __ccgo_fp(XTcl_SplitPath)
	*(*uintptr)(unsafe.Add(p, 5344)) = __ccgo_fp(XTcl_FSSplitPath)
	*(*uintptr)(unsafe.Add(p, 5352)) = __ccgo_fp(XTcl_ParseArgsObjv)
	*(*uintptr)(unsafe.Add(p, 5360)) = __ccgo_fp(XTcl_UniCharLen)
	*(*uintptr)(unsafe.Add(p, 5368)) = __ccgo_fp(XTcl_NumUtfChars)
	*(*uintptr)(unsafe.Add(p, 5376)) = __ccgo_fp(XTcl_GetCharLength)
	*(*uintptr)(unsafe.Add(p, 5384)) = __ccgo_fp(XTcl_UtfAtIndex)
	*(*uintptr)(unsafe.Add(p, 5392)) = __ccgo_fp(XTcl_GetRange)
	*(*uintptr)(unsafe.Add(p, 5400)) = __ccgo_fp(XTcl_GetUniChar)
	*(*uintptr)(unsafe.Add(p, 5408)) = __ccgo_fp(XTcl_GetBool)
	*(*uintptr)(unsafe.Add(p, 5416)) = __ccgo_fp(XTcl_GetBoolFromObj)
	*(*uintptr)(unsafe.Add(p, 5424)) = __ccgo_fp(XTcl_CreateObjCommand2)
	*(*uintptr)(unsafe.Add(p, 5432)) = __ccgo_fp(XTcl_CreateObjTrace2)
	*(*uintptr)(unsafe.Add(p, 5440)) = __ccgo_fp(XTcl_NRCreateCommand2)
	*(*uintptr)(unsafe.Add(p, 5448)) = __ccgo_fp(XTcl_NRCallObjProc2)
	*(*uintptr)(unsafe.Add(p, 5456)) = __ccgo_fp(XTcl_GetNumberFromObj)
	*(*uintptr)(unsafe.Add(p, 5464)) = __ccgo_fp(XTcl_GetNumber)
	*(*uintptr)(unsafe.Add(p, 5472)) = __ccgo_fp(XTcl_RemoveChannelMode)
	*(*uintptr)(unsafe.Add(p, 5480)) = __ccgo_fp(XTcl_GetEncodingNulLength)
	*(*uintptr)(unsafe.Add(p, 5488)) = __ccgo_fp(XTcl_GetWideUIntFromObj)
	*(*uintptr)(unsafe.Add(p, 5496)) = __ccgo_fp(XTcl_DStringToObj)
	*(*uintptr)(unsafe.Add(p, 5504)) = __ccgo_fp(XTcl_UtfNcmp)
	*(*uintptr)(unsafe.Add(p, 5512)) = __ccgo_fp(XTcl_UtfNcasecmp)
	*(*uintptr)(unsafe.Add(p, 5520)) = __ccgo_fp(XTcl_NewWideUIntObj)
	*(*uintptr)(unsafe.Add(p, 5528)) = __ccgo_fp(XTcl_SetWideUIntObj)
}

const SLEEP_OFFLOAD_GETTIMEOFDAY = 20
const TCL_TIME_MAXIMUM_SLICE = 500

/* Epoch of the tcl environment
 * (if changed with tcl-env). */

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * For each timer callback that's pending there is one record of the following
 * type. The normal handlers (created by Tcl_CreateTimerHandler) are chained
 * together in a list sorted by time (earliest event first).
 */

type TTimerHandler = struct {
	Ftime       TTcl_Time
	Fproc       uintptr
	FclientData uintptr
	Ftoken      TTcl_TimerToken
	FnextPtr    uintptr
}

/*
 * The data structure below is used by the "after" command to remember the
 * command to be executed later. All of the pending "after" commands for an
 * interpreter are linked together in a list.
 */

type TAfterInfo = struct {
	FassocPtr   uintptr
	FcommandPtr uintptr
	Fid         int32
	Ftoken      TTcl_TimerToken
	FnextPtr    uintptr
}

/*
 * One of the following structures is associated with each interpreter for
 * which an "after" command has ever been invoked. A pointer to this structure
 * is stored in the AssocData for the "tclAfter" key.
 */

type TAfterAssocData = struct {
	Finterp        uintptr
	FfirstAfterPtr uintptr
}

/*
 * There is one of the following structures for each of the handlers declared
 * in a call to Tcl_DoWhenIdle. All of the currently-active handlers are
 * linked together into a list.
 */

type TIdleHandler = struct {
	Fproc       uintptr
	FclientData uintptr
	Fgeneration int32
	FnextPtr    uintptr
}

/*
 * The timer and idle queues are per-thread because they are associated with
 * the notifier, which is also per-thread.
 *
 * All static variables used in this file are collected into a single instance
 * of the following structure. For multi-threaded implementations, there is
 * one instance of this structure for each thread.
 *
 * Notice that different structures with the same name appear in other files.
 * The structure defined below is used in this file only.
 */

type TThreadSpecificData13 = struct {
	FfirstTimerHandlerPtr uintptr
	FlastTimerId          int32
	FtimerPending         int32
	FidleList             uintptr
	FlastIdlePtr          uintptr
	FidleGeneration       int32
	FafterId              int32
}

var _dataKey11 TTcl_ThreadDataKey

/*
 *----------------------------------------------------------------------
 *
 * InitTimer --
 *
 *	This function initializes the timer module.
 *
 * Results:
 *	A pointer to the thread specific data.
 *
 * Side effects:
 *	Registers the idle and timer event sources.
 *
 *----------------------------------------------------------------------
 */

func _InitTimer(tls *libc.TLS) (r uintptr) {
	var tsdPtr uintptr
	_ = tsdPtr
	tsdPtr = XTclThreadDataKeyGet(tls, uintptr(unsafe.Pointer(&_dataKey11)))
	if tsdPtr == libc.UintptrFromInt32(0) {
		tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey11)), int64(40))
		XTcl_CreateEventSource(tls, __ccgo_fp(_TimerSetupProc), __ccgo_fp(_TimerCheckProc), libc.UintptrFromInt32(0))
		XTcl_CreateThreadExitHandler(tls, __ccgo_fp(_TimerExitProc), libc.UintptrFromInt32(0))
	}
	return tsdPtr
}

/*
 *----------------------------------------------------------------------
 *
 * TimerExitProc --
 *
 *	This function is call at exit or unload time to remove the timer and
 *	idle event sources.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Removes the timer and idle event sources and remaining events.
 *
 *----------------------------------------------------------------------
 */

func _TimerExitProc(tls *libc.TLS, dummy214 uintptr) {
	var timerHandlerPtr, tsdPtr uintptr
	_, _ = timerHandlerPtr, tsdPtr
	tsdPtr = XTclThreadDataKeyGet(tls, uintptr(unsafe.Pointer(&_dataKey11)))
	XTcl_DeleteEventSource(tls, __ccgo_fp(_TimerSetupProc), __ccgo_fp(_TimerCheckProc), libc.UintptrFromInt32(0))
	if tsdPtr != libc.UintptrFromInt32(0) {
		timerHandlerPtr = (*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FfirstTimerHandlerPtr
		for timerHandlerPtr != libc.UintptrFromInt32(0) {
			(*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FfirstTimerHandlerPtr = (*TTimerHandler)(unsafe.Pointer(timerHandlerPtr)).FnextPtr
			XTclpFree(tls, timerHandlerPtr)
			timerHandlerPtr = (*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FfirstTimerHandlerPtr
		}
	}
}

/*
 *--------------------------------------------------------------
 *
 * Tcl_CreateTimerHandler --
 *
 *	Arrange for a given function to be invoked at a particular time in the
 *	future.
 *
 * Results:
 *	The return value is a token for the timer event, which may be used to
 *	delete the event before it fires.
 *
 * Side effects:
 *	When milliseconds have elapsed, proc will be invoked exactly once.
 *
 *--------------------------------------------------------------
 */

func XTcl_CreateTimerHandler(tls *libc.TLS, milliseconds int32, proc uintptr, clientData uintptr) (r TTcl_TimerToken) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Arbitrary data to pass to proc. */
	var _ /* time at bp+0 */ TTcl_Time
	/*
	 * Compute when the event should fire.
	 */
	XTcl_GetTime(tls, bp)
	(*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec += int64(milliseconds / int32(1000))
	(*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec += int64(milliseconds % int32(1000) * int32(1000))
	if (*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec >= int64(1000000) {
		(*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec -= int64(1000000)
		(*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec += int64(1)
	}
	return XTclCreateAbsoluteTimerHandler(tls, bp, proc, clientData)
}

/*
 *--------------------------------------------------------------
 *
 * TclCreateAbsoluteTimerHandler --
 *
 *	Arrange for a given function to be invoked at a particular time in the
 *	future.
 *
 * Results:
 *	The return value is a token for the timer event, which may be used to
 *	delete the event before it fires.
 *
 * Side effects:
 *	When the time in timePtr has been reached, proc will be invoked
 *	exactly once.
 *
 *--------------------------------------------------------------
 */

func XTclCreateAbsoluteTimerHandler(tls *libc.TLS, timePtr uintptr, proc uintptr, clientData uintptr) (r TTcl_TimerToken) {
	var prevPtr, tPtr2, timerHandlerPtr, tsdPtr uintptr
	_, _, _, _ = prevPtr, tPtr2, timerHandlerPtr, tsdPtr
	tsdPtr = _InitTimer(tls)
	timerHandlerPtr = XTcl_Alloc(tls, uint64(48))
	/*
	 * Fill in fields for the event.
	 */
	libc.Xmemcpy(tls, timerHandlerPtr, timePtr, uint64(16))
	(*TTimerHandler)(unsafe.Pointer(timerHandlerPtr)).Fproc = proc
	(*TTimerHandler)(unsafe.Pointer(timerHandlerPtr)).FclientData = clientData
	(*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FlastTimerId++
	(*TTimerHandler)(unsafe.Pointer(timerHandlerPtr)).Ftoken = uintptr(int64((*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FlastTimerId))
	/*
	 * Add the event to the queue in the correct position (ordered by event
	 * firing time).
	 */
	tPtr2 = (*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FfirstTimerHandlerPtr
	prevPtr = libc.UintptrFromInt32(0)
	for {
		if !(tPtr2 != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TTimerHandler)(unsafe.Pointer(timerHandlerPtr)).Ftime.Fsec < (*TTimerHandler)(unsafe.Pointer(tPtr2)).Ftime.Fsec || (*TTimerHandler)(unsafe.Pointer(timerHandlerPtr)).Ftime.Fsec == (*TTimerHandler)(unsafe.Pointer(tPtr2)).Ftime.Fsec && (*TTimerHandler)(unsafe.Pointer(timerHandlerPtr)).Ftime.Fusec < (*TTimerHandler)(unsafe.Pointer(tPtr2)).Ftime.Fusec {
			break
		}
		goto _1
	_1:
		;
		prevPtr = tPtr2
		tPtr2 = (*TTimerHandler)(unsafe.Pointer(tPtr2)).FnextPtr
	}
	(*TTimerHandler)(unsafe.Pointer(timerHandlerPtr)).FnextPtr = tPtr2
	if prevPtr == libc.UintptrFromInt32(0) {
		(*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FfirstTimerHandlerPtr = timerHandlerPtr
	} else {
		(*TTimerHandler)(unsafe.Pointer(prevPtr)).FnextPtr = timerHandlerPtr
	}
	_TimerSetupProc(tls, libc.UintptrFromInt32(0), ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(1)))
	return (*TTimerHandler)(unsafe.Pointer(timerHandlerPtr)).Ftoken
}

/*
 *--------------------------------------------------------------
 *
 * Tcl_DeleteTimerHandler --
 *
 *	Delete a previously-registered timer handler.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Destroy the timer callback identified by TimerToken, so that its
 *	associated function will not be called. If the callback has already
 *	fired, or if the given token doesn't exist, then nothing happens.
 *
 *--------------------------------------------------------------
 */

func XTcl_DeleteTimerHandler(tls *libc.TLS, token TTcl_TimerToken) {
	/* Result previously returned by
	 * Tcl_DeleteTimerHandler. */
	var prevPtr, timerHandlerPtr, tsdPtr uintptr
	_, _, _ = prevPtr, timerHandlerPtr, tsdPtr
	tsdPtr = _InitTimer(tls)
	if token == libc.UintptrFromInt32(0) {
		return
	}
	timerHandlerPtr = (*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FfirstTimerHandlerPtr
	prevPtr = libc.UintptrFromInt32(0)
	for {
		if !(timerHandlerPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TTimerHandler)(unsafe.Pointer(timerHandlerPtr)).Ftoken != token {
			goto _1
		}
		if prevPtr == libc.UintptrFromInt32(0) {
			(*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FfirstTimerHandlerPtr = (*TTimerHandler)(unsafe.Pointer(timerHandlerPtr)).FnextPtr
		} else {
			(*TTimerHandler)(unsafe.Pointer(prevPtr)).FnextPtr = (*TTimerHandler)(unsafe.Pointer(timerHandlerPtr)).FnextPtr
		}
		XTclpFree(tls, timerHandlerPtr)
		return
		goto _1
	_1:
		;
		prevPtr = timerHandlerPtr
		timerHandlerPtr = (*TTimerHandler)(unsafe.Pointer(timerHandlerPtr)).FnextPtr
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TimerSetupProc --
 *
 *	This function is called by Tcl_DoOneEvent to setup the timer event
 *	source for before blocking. This routine checks both the idle and
 *	after timer lists.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	May update the maximum notifier block time.
 *
 *----------------------------------------------------------------------
 */

func _TimerSetupProc(tls *libc.TLS, dummy401 uintptr, flags int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Event flags as passed to Tcl_DoOneEvent. */
	var tsdPtr uintptr
	var _ /* blockTime at bp+0 */ TTcl_Time
	_ = tsdPtr
	tsdPtr = _InitTimer(tls)
	if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(5)) != 0 && (*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FidleList != 0 || flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(4)) != 0 && (*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FtimerPending != 0 {
		/*
		 * There is an idle handler or a pending timer event, so just poll.
		 */
		(*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec = 0
		(*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec = 0
	} else {
		if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(4)) != 0 && (*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FfirstTimerHandlerPtr != 0 {
			/*
			 * Compute the timeout for the next timer on the list.
			 */
			XTcl_GetTime(tls, bp)
			(*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec = (*TTimerHandler)(unsafe.Pointer((*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FfirstTimerHandlerPtr)).Ftime.Fsec - (*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec
			(*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec = (*TTimerHandler)(unsafe.Pointer((*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FfirstTimerHandlerPtr)).Ftime.Fusec - (*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec
			if (*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec < 0 {
				(*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec -= int64(1)
				(*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec += int64(1000000)
			}
			if (*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec < 0 {
				(*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec = 0
				(*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec = 0
			}
		} else {
			return
		}
	}
	XTcl_SetMaxBlockTime(tls, bp)
}

/*
 *----------------------------------------------------------------------
 *
 * TimerCheckProc --
 *
 *	This function is called by Tcl_DoOneEvent to check the timer event
 *	source for events. This routine checks both the idle and after timer
 *	lists.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	May queue an event and update the maximum notifier block time.
 *
 *----------------------------------------------------------------------
 */

func _TimerCheckProc(tls *libc.TLS, dummy459 uintptr, flags int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Event flags as passed to Tcl_DoOneEvent. */
	var timerEvPtr, tsdPtr uintptr
	var _ /* blockTime at bp+0 */ TTcl_Time
	_, _ = timerEvPtr, tsdPtr
	tsdPtr = _InitTimer(tls)
	if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(4)) != 0 && (*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FfirstTimerHandlerPtr != 0 {
		/*
		 * Compute the timeout for the next timer on the list.
		 */
		XTcl_GetTime(tls, bp)
		(*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec = (*TTimerHandler)(unsafe.Pointer((*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FfirstTimerHandlerPtr)).Ftime.Fsec - (*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec
		(*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec = (*TTimerHandler)(unsafe.Pointer((*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FfirstTimerHandlerPtr)).Ftime.Fusec - (*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec
		if (*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec < 0 {
			(*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec -= int64(1)
			(*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec += int64(1000000)
		}
		if (*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec < 0 {
			(*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec = 0
			(*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec = 0
		}
		/*
		 * If the first timer has expired, stick an event on the queue.
		 */
		if (*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec == 0 && (*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec == 0 && !((*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FtimerPending != 0) {
			(*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FtimerPending = int32(1)
			timerEvPtr = XTcl_Alloc(tls, uint64(16))
			(*TTcl_Event)(unsafe.Pointer(timerEvPtr)).Fproc = __ccgo_fp(_TimerHandlerEventProc)
			XTcl_QueueEvent(tls, timerEvPtr, int32(TCL_QUEUE_TAIL))
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TimerHandlerEventProc --
 *
 *	This function is called by Tcl_ServiceEvent when a timer event reaches
 *	the front of the event queue. This function handles the event by
 *	invoking the callbacks for all timers that are ready.
 *
 * Results:
 *	Returns 1 if the event was handled, meaning it should be removed from
 *	the queue. Returns 0 if the event was not handled, meaning it should
 *	stay on the queue. The only time the event isn't handled is if the
 *	TCL_TIMER_EVENTS flag bit isn't set.
 *
 * Side effects:
 *	Whatever the timer handler callback functions do.
 *
 *----------------------------------------------------------------------
 */

func _TimerHandlerEventProc(tls *libc.TLS, dummy521 uintptr, flags int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Flags that indicate what events to handle,
	 * such as TCL_FILE_EVENTS. */
	var currentTimerId int32
	var nextPtrPtr, timerHandlerPtr, tsdPtr uintptr
	var _ /* time at bp+0 */ TTcl_Time
	_, _, _, _ = currentTimerId, nextPtrPtr, timerHandlerPtr, tsdPtr
	tsdPtr = _InitTimer(tls)
	/*
	 * Do nothing if timers aren't enabled. This leaves the event on the
	 * queue, so we will get to it as soon as ServiceEvents() is called with
	 * timers enabled.
	 */
	if !(flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(4)) != 0) {
		return 0
	}
	/*
	 * The code below is trickier than it may look, for the following reasons:
	 *
	 * 1. New handlers can get added to the list while the current one is
	 *	  being processed. If new ones get added, we don't want to process
	 *	  them during this pass through the list to avoid starving other event
	 *	  sources. This is implemented using the token number in the handler:
	 *	  new handlers will have a newer token than any of the ones currently
	 *	  on the list.
	 * 2. The handler can call Tcl_DoOneEvent, so we have to remove the
	 *	  handler from the list before calling it. Otherwise an infinite loop
	 *	  could result.
	 * 3. Tcl_DeleteTimerHandler can be called to remove an element from the
	 *	  list while a handler is executing, so the list could change
	 *	  structure during the call.
	 * 4. Because we only fetch the current time before entering the loop, the
	 *	  only way a new timer will even be considered runnable is if its
	 *	  expiration time is within the same millisecond as the current time.
	 *	  This is fairly likely on Windows, since it has a course granularity
	 *	  clock. Since timers are placed on the queue in time order with the
	 *	  most recently created handler appearing after earlier ones with the
	 *	  same expiration time, we don't have to worry about newer generation
	 *	  timers appearing before later ones.
	 */
	(*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FtimerPending = 0
	currentTimerId = (*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FlastTimerId
	XTcl_GetTime(tls, bp)
	for int32(1) != 0 {
		nextPtrPtr = tsdPtr
		timerHandlerPtr = (*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FfirstTimerHandlerPtr
		if timerHandlerPtr == libc.UintptrFromInt32(0) {
			break
		}
		if (*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec < (*TTimerHandler)(unsafe.Pointer(timerHandlerPtr)).Ftime.Fsec || (*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec == (*TTimerHandler)(unsafe.Pointer(timerHandlerPtr)).Ftime.Fsec && (*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec < (*TTimerHandler)(unsafe.Pointer(timerHandlerPtr)).Ftime.Fusec {
			break
		}
		/*
		 * Bail out if the next timer is of a newer generation.
		 */
		if int64(currentTimerId)-int64((*TTimerHandler)(unsafe.Pointer(timerHandlerPtr)).Ftoken) < 0 {
			break
		}
		/*
		 * Remove the handler from the queue before invoking it, to avoid
		 * potential reentrancy problems.
		 */
		*(*uintptr)(unsafe.Pointer(nextPtrPtr)) = (*TTimerHandler)(unsafe.Pointer(timerHandlerPtr)).FnextPtr
		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTimerHandler)(unsafe.Pointer(timerHandlerPtr)).Fproc})))(tls, (*TTimerHandler)(unsafe.Pointer(timerHandlerPtr)).FclientData)
		XTclpFree(tls, timerHandlerPtr)
	}
	_TimerSetupProc(tls, libc.UintptrFromInt32(0), libc.Int32FromInt32(1)<<libc.Int32FromInt32(4))
	return int32(1)
}

/*
 *--------------------------------------------------------------
 *
 * Tcl_DoWhenIdle --
 *
 *	Arrange for proc to be invoked the next time the system is idle (i.e.,
 *	just before the next time that Tcl_DoOneEvent would have to wait for
 *	something to happen).
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Proc will eventually be called, with clientData as argument. See the
 *	manual entry for details.
 *
 *--------------------------------------------------------------
 */

func XTcl_DoWhenIdle(tls *libc.TLS, proc uintptr, clientData uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Arbitrary value to pass to proc. */
	var idlePtr, tsdPtr uintptr
	var _ /* blockTime at bp+0 */ TTcl_Time
	_, _ = idlePtr, tsdPtr
	tsdPtr = _InitTimer(tls)
	idlePtr = XTcl_Alloc(tls, uint64(32))
	(*TIdleHandler)(unsafe.Pointer(idlePtr)).Fproc = proc
	(*TIdleHandler)(unsafe.Pointer(idlePtr)).FclientData = clientData
	(*TIdleHandler)(unsafe.Pointer(idlePtr)).Fgeneration = (*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FidleGeneration
	(*TIdleHandler)(unsafe.Pointer(idlePtr)).FnextPtr = libc.UintptrFromInt32(0)
	if (*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FlastIdlePtr == libc.UintptrFromInt32(0) {
		(*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FidleList = idlePtr
	} else {
		(*TIdleHandler)(unsafe.Pointer((*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FlastIdlePtr)).FnextPtr = idlePtr
	}
	(*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FlastIdlePtr = idlePtr
	(*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec = 0
	(*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec = 0
	XTcl_SetMaxBlockTime(tls, bp)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_CancelIdleCall --
 *
 *	If there are any when-idle calls requested to a given function with
 *	given clientData, cancel all of them.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	If the proc/clientData combination were on the when-idle list, they
 *	are removed so that they will never be called.
 *
 *----------------------------------------------------------------------
 */

func XTcl_CancelIdleCall(tls *libc.TLS, proc uintptr, clientData uintptr) {
	/* Arbitrary value to pass to proc. */
	var idlePtr, nextPtr, prevPtr, tsdPtr uintptr
	_, _, _, _ = idlePtr, nextPtr, prevPtr, tsdPtr
	tsdPtr = _InitTimer(tls)
	prevPtr = libc.UintptrFromInt32(0)
	idlePtr = (*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FidleList
	for {
		if !(idlePtr != libc.UintptrFromInt32(0)) {
			break
		}
		for (*TIdleHandler)(unsafe.Pointer(idlePtr)).Fproc == proc && (*TIdleHandler)(unsafe.Pointer(idlePtr)).FclientData == clientData {
			nextPtr = (*TIdleHandler)(unsafe.Pointer(idlePtr)).FnextPtr
			XTclpFree(tls, idlePtr)
			idlePtr = nextPtr
			if prevPtr == libc.UintptrFromInt32(0) {
				(*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FidleList = idlePtr
			} else {
				(*TIdleHandler)(unsafe.Pointer(prevPtr)).FnextPtr = idlePtr
			}
			if idlePtr == libc.UintptrFromInt32(0) {
				(*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FlastIdlePtr = prevPtr
				return
			}
		}
		goto _1
	_1:
		;
		prevPtr = idlePtr
		idlePtr = (*TIdleHandler)(unsafe.Pointer(idlePtr)).FnextPtr
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclServiceIdle --
 *
 *	This function is invoked by the notifier when it becomes idle. It will
 *	invoke all idle handlers that are present at the time the call is
 *	invoked, but not those added during idle processing.
 *
 * Results:
 *	The return value is 1 if TclServiceIdle found something to do,
 *	otherwise return value is 0.
 *
 * Side effects:
 *	Invokes all pending idle handlers.
 *
 *----------------------------------------------------------------------
 */

func XTclServiceIdle(tls *libc.TLS) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var idlePtr, tsdPtr uintptr
	var oldGeneration int32
	var _ /* blockTime at bp+0 */ TTcl_Time
	_, _, _ = idlePtr, oldGeneration, tsdPtr
	tsdPtr = _InitTimer(tls)
	if (*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FidleList == libc.UintptrFromInt32(0) {
		return 0
	}
	oldGeneration = (*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FidleGeneration
	(*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FidleGeneration++
	/*
	 * The code below is trickier than it may look, for the following reasons:
	 *
	 * 1. New handlers can get added to the list while the current one is
	 *	  being processed. If new ones get added, we don't want to process
	 *	  them during this pass through the list (want to check for other work
	 *	  to do first). This is implemented using the generation number in the
	 *	  handler: new handlers will have a different generation than any of
	 *	  the ones currently on the list.
	 * 2. The handler can call Tcl_DoOneEvent, so we have to remove the
	 *	  handler from the list before calling it. Otherwise an infinite loop
	 *	  could result.
	 * 3. Tcl_CancelIdleCall can be called to remove an element from the list
	 *	  while a handler is executing, so the list could change structure
	 *	  during the call.
	 */
	idlePtr = (*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FidleList
	for {
		if !(idlePtr != libc.UintptrFromInt32(0) && oldGeneration-(*TIdleHandler)(unsafe.Pointer(idlePtr)).Fgeneration >= 0) {
			break
		}
		(*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FidleList = (*TIdleHandler)(unsafe.Pointer(idlePtr)).FnextPtr
		if (*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FidleList == libc.UintptrFromInt32(0) {
			(*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FlastIdlePtr = libc.UintptrFromInt32(0)
		}
		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TIdleHandler)(unsafe.Pointer(idlePtr)).Fproc})))(tls, (*TIdleHandler)(unsafe.Pointer(idlePtr)).FclientData)
		XTclpFree(tls, idlePtr)
		goto _1
	_1:
		;
		idlePtr = (*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FidleList
	}
	if (*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FidleList != 0 {
		(*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec = 0
		(*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec = 0
		XTcl_SetMaxBlockTime(tls, bp)
	}
	return int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_AfterObjCmd --
 *
 *	This function is invoked to process the "after" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_AfterObjCmd(tls *libc.TLS, dummy781 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(112)
	defer tls.Free(112) /* Argument objects. */
	var _objPtr, afterPtr, arg, assocPtr, cachePtr, cachePtr1, command, commandPtr, eventStr, resultListPtr, resultObj, tempCommand, tsdPtr, v11, v13, v2, v4, v6, v8, p3 uintptr
	var v1 int32
	var v12, v9 bool
	var v7 TTcl_Size
	var _ /* index at bp+32 */ int32
	var _ /* length at bp+24 */ TTcl_Size
	var _ /* ms at bp+0 */ TTcl_WideInt
	var _ /* tempLength at bp+40 */ TTcl_Size
	var _ /* wakeup at bp+8 */ TTcl_Time
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, afterPtr, arg, assocPtr, cachePtr, cachePtr1, command, commandPtr, eventStr, resultListPtr, resultObj, tempCommand, tsdPtr, v1, v11, v12, v13, v2, v4, v6, v7, v8, v9, p3
	*(*TTcl_WideInt)(unsafe.Pointer(bp)) = 0
	*(*int32)(unsafe.Pointer(bp + 32)) = -int32(1)
	tsdPtr = _InitTimer(tls)
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+57971)
		return int32(TCL_ERROR)
	}
	/*
	 * Create the "after" information associated for this interpreter, if it
	 * doesn't already exist.
	 */
	assocPtr = XTcl_GetAssocData(tls, interp, __ccgo_ts+67408, libc.UintptrFromInt32(0))
	if assocPtr == libc.UintptrFromInt32(0) {
		assocPtr = XTcl_Alloc(tls, uint64(16))
		(*TAfterAssocData)(unsafe.Pointer(assocPtr)).Finterp = interp
		(*TAfterAssocData)(unsafe.Pointer(assocPtr)).FfirstAfterPtr = libc.UintptrFromInt32(0)
		XTcl_SetAssocData(tls, interp, __ccgo_ts+67408, __ccgo_fp(_AfterCleanupProc), assocPtr)
	}
	/*
	 * First lets see if the command was passed a number as the first argument.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*TTcl_WideInt)(unsafe.Pointer(bp)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FinternalRep))
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_GetWideIntFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
	}
	if v1 != TCL_OK {
		if XTcl_GetIndexFromObjStruct(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + 1*8)), uintptr(unsafe.Pointer(&_afterSubCmds)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+1945, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+32) != TCL_OK {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
				v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
			}
			arg = v2
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+67417, libc.VaList(bp+56, arg)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+56, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+17278, __ccgo_ts+67478, arg, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
	}
	/*
	 * At this point, either index = -1 and ms contains the number of ms
	 * to wait, or else index is the index of a subcommand.
	 */
	switch *(*int32)(unsafe.Pointer(bp + 32)) {
	case -int32(1):
		if *(*TTcl_WideInt)(unsafe.Pointer(bp)) < 0 {
			*(*TTcl_WideInt)(unsafe.Pointer(bp)) = 0
		}
		if objc == int32(2) {
			return _AfterDelay(tls, interp, *(*TTcl_WideInt)(unsafe.Pointer(bp)))
		}
		afterPtr = XTcl_Alloc(tls, uint64(40))
		(*TAfterInfo)(unsafe.Pointer(afterPtr)).FassocPtr = assocPtr
		if objc == int32(3) {
			(*TAfterInfo)(unsafe.Pointer(afterPtr)).FcommandPtr = *(*uintptr)(unsafe.Pointer(objv + 2*8))
		} else {
			(*TAfterInfo)(unsafe.Pointer(afterPtr)).FcommandPtr = XTcl_ConcatObj(tls, int64(objc-int32(2)), objv+uintptr(2)*8)
		}
		(*TTcl_Obj)(unsafe.Pointer((*TAfterInfo)(unsafe.Pointer(afterPtr)).FcommandPtr)).FrefCount++
		/*
		 * The variable below is used to generate unique identifiers for after
		 * commands. This id can wrap around, which can potentially cause
		 * problems. However, there are not likely to be problems in practice,
		 * because after commands can only be requested to about a month in
		 * the future, and wrap-around is unlikely to occur in less than about
		 * 1-10 years. Thus it's unlikely that any old ids will still be
		 * around when wrap-around occurs.
		 */
		(*TAfterInfo)(unsafe.Pointer(afterPtr)).Fid = (*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FafterId
		*(*int32)(unsafe.Pointer(tsdPtr + 36)) += int32(1)
		XTcl_GetTime(tls, bp+8)
		(*(*TTcl_Time)(unsafe.Pointer(bp + 8))).Fsec += *(*TTcl_WideInt)(unsafe.Pointer(bp)) / int64(1000)
		p3 = bp + 8 + 8
		*(*int64)(unsafe.Pointer(p3)) = int64(*(*int64)(unsafe.Pointer(p3)) + *(*TTcl_WideInt)(unsafe.Pointer(bp))%libc.Int64FromInt32(1000)*libc.Int64FromInt32(1000))
		if (*(*TTcl_Time)(unsafe.Pointer(bp + 8))).Fusec > int64(1000000) {
			(*(*TTcl_Time)(unsafe.Pointer(bp + 8))).Fsec++
			(*(*TTcl_Time)(unsafe.Pointer(bp + 8))).Fusec -= int64(1000000)
		}
		(*TAfterInfo)(unsafe.Pointer(afterPtr)).Ftoken = XTclCreateAbsoluteTimerHandler(tls, bp+8, __ccgo_fp(_AfterProc), afterPtr)
		(*TAfterInfo)(unsafe.Pointer(afterPtr)).FnextPtr = (*TAfterAssocData)(unsafe.Pointer(assocPtr)).FfirstAfterPtr
		(*TAfterAssocData)(unsafe.Pointer(assocPtr)).FfirstAfterPtr = afterPtr
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+67487, libc.VaList(bp+56, (*TAfterInfo)(unsafe.Pointer(afterPtr)).Fid)))
		return TCL_OK
	case 0:
		if objc < int32(3) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+67496)
			return int32(TCL_ERROR)
		}
		if objc == int32(3) {
			commandPtr = *(*uintptr)(unsafe.Pointer(objv + 2*8))
		} else {
			commandPtr = XTcl_ConcatObj(tls, int64(objc-int32(2)), objv+uintptr(2)*8)
		}
		if (*TTcl_Obj)(unsafe.Pointer(commandPtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = (*TTcl_Obj)(unsafe.Pointer(commandPtr)).Flength
			v4 = (*TTcl_Obj)(unsafe.Pointer(commandPtr)).Fbytes
		} else {
			v4 = XTcl_GetStringFromObj(tls, commandPtr, bp+24)
		}
		command = v4
		afterPtr = (*TAfterAssocData)(unsafe.Pointer(assocPtr)).FfirstAfterPtr
		for {
			if !(afterPtr != libc.UintptrFromInt32(0)) {
				break
			}
			if (*TTcl_Obj)(unsafe.Pointer((*TAfterInfo)(unsafe.Pointer(afterPtr)).FcommandPtr)).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = (*TTcl_Obj)(unsafe.Pointer((*TAfterInfo)(unsafe.Pointer(afterPtr)).FcommandPtr)).Flength
				v6 = (*TTcl_Obj)(unsafe.Pointer((*TAfterInfo)(unsafe.Pointer(afterPtr)).FcommandPtr)).Fbytes
			} else {
				v6 = XTcl_GetStringFromObj(tls, (*TAfterInfo)(unsafe.Pointer(afterPtr)).FcommandPtr, bp+40)
			}
			tempCommand = v6
			if *(*TTcl_Size)(unsafe.Pointer(bp + 24)) == *(*TTcl_Size)(unsafe.Pointer(bp + 40)) && !(libc.Xmemcmp(tls, command, tempCommand, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 24)))) != 0) {
				break
			}
			goto _5
		_5:
			;
			afterPtr = (*TAfterInfo)(unsafe.Pointer(afterPtr)).FnextPtr
		}
		if afterPtr == libc.UintptrFromInt32(0) {
			afterPtr = _GetAfterEvent(tls, assocPtr, commandPtr)
		}
		if objc != int32(3) {
			_objPtr = commandPtr
			v8 = _objPtr
			v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
			*(*TTcl_Size)(unsafe.Pointer(v8))--
			if v7 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
		if afterPtr != libc.UintptrFromInt32(0) {
			if (*TAfterInfo)(unsafe.Pointer(afterPtr)).Ftoken != libc.UintptrFromInt32(0) {
				XTcl_DeleteTimerHandler(tls, (*TAfterInfo)(unsafe.Pointer(afterPtr)).Ftoken)
			} else {
				XTcl_CancelIdleCall(tls, __ccgo_fp(_AfterProc), afterPtr)
			}
			_FreeAfterPtr(tls, afterPtr)
		}
	case 1:
		if objc < int32(3) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+67507)
			return int32(TCL_ERROR)
		}
		afterPtr = XTcl_Alloc(tls, uint64(40))
		(*TAfterInfo)(unsafe.Pointer(afterPtr)).FassocPtr = assocPtr
		if objc == int32(3) {
			(*TAfterInfo)(unsafe.Pointer(afterPtr)).FcommandPtr = *(*uintptr)(unsafe.Pointer(objv + 2*8))
		} else {
			(*TAfterInfo)(unsafe.Pointer(afterPtr)).FcommandPtr = XTcl_ConcatObj(tls, int64(objc-int32(2)), objv+uintptr(2)*8)
		}
		(*TTcl_Obj)(unsafe.Pointer((*TAfterInfo)(unsafe.Pointer(afterPtr)).FcommandPtr)).FrefCount++
		(*TAfterInfo)(unsafe.Pointer(afterPtr)).Fid = (*TThreadSpecificData13)(unsafe.Pointer(tsdPtr)).FafterId
		*(*int32)(unsafe.Pointer(tsdPtr + 36)) += int32(1)
		(*TAfterInfo)(unsafe.Pointer(afterPtr)).Ftoken = libc.UintptrFromInt32(0)
		(*TAfterInfo)(unsafe.Pointer(afterPtr)).FnextPtr = (*TAfterAssocData)(unsafe.Pointer(assocPtr)).FfirstAfterPtr
		(*TAfterAssocData)(unsafe.Pointer(assocPtr)).FfirstAfterPtr = afterPtr
		XTcl_DoWhenIdle(tls, __ccgo_fp(_AfterProc), afterPtr)
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+67487, libc.VaList(bp+56, (*TAfterInfo)(unsafe.Pointer(afterPtr)).Fid)))
	case 2:
		if objc == int32(2) {
			if v9 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v9 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v9 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				resultObj = XTclThreadAllocObj(tls)
			} else {
				resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(resultObj + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
			afterPtr = (*TAfterAssocData)(unsafe.Pointer(assocPtr)).FfirstAfterPtr
			for {
				if !(afterPtr != libc.UintptrFromInt32(0)) {
					break
				}
				if (*TAfterAssocData)(unsafe.Pointer(assocPtr)).Finterp == interp {
					XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, XTcl_ObjPrintf(tls, __ccgo_ts+67487, libc.VaList(bp+56, (*TAfterInfo)(unsafe.Pointer(afterPtr)).Fid)))
				}
				goto _10
			_10:
				;
				afterPtr = (*TAfterInfo)(unsafe.Pointer(afterPtr)).FnextPtr
			}
			XTcl_SetObjResult(tls, interp, resultObj)
			return TCL_OK
		}
		if objc != int32(3) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+67527)
			return int32(TCL_ERROR)
		}
		afterPtr = _GetAfterEvent(tls, assocPtr, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
		if afterPtr == libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
				v11 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
			} else {
				v11 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
			}
			eventStr = v11
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+67532, libc.VaList(bp+56, eventStr)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+56, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+31163, eventStr, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		} else {
			if v12 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v12 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v12 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
				resultListPtr = XTclThreadAllocObj(tls)
			} else {
				resultListPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(resultListPtr + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(resultListPtr)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(resultListPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(resultListPtr)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(resultListPtr)).FtypePtr = libc.UintptrFromInt32(0)
			XTcl_ListObjAppendElement(tls, interp, resultListPtr, (*TAfterInfo)(unsafe.Pointer(afterPtr)).FcommandPtr)
			if (*TAfterInfo)(unsafe.Pointer(afterPtr)).Ftoken == libc.UintptrFromInt32(0) {
				v13 = __ccgo_ts + 25836
			} else {
				v13 = __ccgo_ts + 67557
			}
			XTcl_ListObjAppendElement(tls, interp, resultListPtr, XTcl_NewStringObj(tls, v13, int64(-int32(1))))
			XTcl_SetObjResult(tls, interp, resultListPtr)
		}
	default:
		XTcl_Panic(tls, __ccgo_ts+67563, 0)
	}
	return TCL_OK
}

var _afterSubCmds = [4]uintptr{
	0: __ccgo_ts + 40519,
	1: __ccgo_ts + 25836,
	2: __ccgo_ts + 5873,
	3: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * AfterDelay --
 *
 *	Implements the blocking delay behaviour of [after $time]. Tricky
 *	because it has to take into account any time limit that has been set.
 *
 * Results:
 *	Standard Tcl result code (with error set if an error occurred due to a
 *	time limit being exceeded or being canceled).
 *
 * Side effects:
 *	May adjust the time limit granularity marker.
 *
 *----------------------------------------------------------------------
 */

func _AfterDelay(tls *libc.TLS, interp uintptr, ms TTcl_WideInt) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var diff TTcl_WideInt
	var iPtr, p1 uintptr
	var _ /* endTime at bp+0 */ TTcl_Time
	var _ /* now at bp+16 */ TTcl_Time
	_, _, _ = diff, iPtr, p1
	iPtr = interp
	XTcl_GetTime(tls, bp+16)
	*(*TTcl_Time)(unsafe.Pointer(bp)) = *(*TTcl_Time)(unsafe.Pointer(bp + 16))
	(*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec += ms / int64(1000)
	p1 = bp + 8
	*(*int64)(unsafe.Pointer(p1)) = int64(*(*int64)(unsafe.Pointer(p1)) + ms%libc.Int64FromInt32(1000)*libc.Int64FromInt32(1000))
	if (*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec >= int64(1000000) {
		(*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec++
		(*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec -= int64(1000000)
	}
	for cond := true; cond; cond = (*(*TTcl_Time)(unsafe.Pointer(bp + 16))).Fsec < (*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec || (*(*TTcl_Time)(unsafe.Pointer(bp + 16))).Fsec == (*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec && (*(*TTcl_Time)(unsafe.Pointer(bp + 16))).Fusec < (*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec {
		if XTcl_AsyncReady(tls) != 0 {
			if XTcl_AsyncInvoke(tls, interp, TCL_OK) != TCL_OK {
				return int32(TCL_ERROR)
			}
		}
		if XTcl_Canceled(tls, interp, int32(TCL_LEAVE_ERR_MSG)) == int32(TCL_ERROR) {
			return int32(TCL_ERROR)
		}
		if (*TInterp)(unsafe.Pointer(iPtr)).Flimit.FtimeEvent != libc.UintptrFromInt32(0) && ((*TInterp)(unsafe.Pointer(iPtr)).Flimit.Ftime.Fsec < (*(*TTcl_Time)(unsafe.Pointer(bp + 16))).Fsec || (*TInterp)(unsafe.Pointer(iPtr)).Flimit.Ftime.Fsec == (*(*TTcl_Time)(unsafe.Pointer(bp + 16))).Fsec && (*TInterp)(unsafe.Pointer(iPtr)).Flimit.Ftime.Fusec < (*(*TTcl_Time)(unsafe.Pointer(bp + 16))).Fusec) {
			(*TInterp)(unsafe.Pointer(iPtr)).Flimit.FgranularityTicker = 0
			if XTcl_LimitCheck(tls, interp) != TCL_OK {
				return int32(TCL_ERROR)
			}
		}
		if (*TInterp)(unsafe.Pointer(iPtr)).Flimit.FtimeEvent == libc.UintptrFromInt32(0) || ((*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec < (*TInterp)(unsafe.Pointer(iPtr)).Flimit.Ftime.Fsec || (*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec == (*TInterp)(unsafe.Pointer(iPtr)).Flimit.Ftime.Fsec && (*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec < (*TInterp)(unsafe.Pointer(iPtr)).Flimit.Ftime.Fusec) {
			diff = libc.Int64FromInt32(1000)*((*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec-(*(*TTcl_Time)(unsafe.Pointer(bp + 16))).Fsec) + int64(((*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec-(*(*TTcl_Time)(unsafe.Pointer(bp + 16))).Fusec+libc.Int64FromInt32(999))/libc.Int64FromInt32(1000))
			if diff > int64(TCL_TIME_MAXIMUM_SLICE) {
				diff = int64(TCL_TIME_MAXIMUM_SLICE)
			}
			if diff == 0 && ((*(*TTcl_Time)(unsafe.Pointer(bp + 16))).Fsec < (*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec || (*(*TTcl_Time)(unsafe.Pointer(bp + 16))).Fsec == (*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec && (*(*TTcl_Time)(unsafe.Pointer(bp + 16))).Fusec < (*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec) {
				diff = int64(1)
			}
			if diff > 0 {
				XTcl_Sleep(tls, int32(diff))
				if diff < int64(SLEEP_OFFLOAD_GETTIMEOFDAY) {
					break
				}
			} else {
				break
			}
		} else {
			diff = libc.Int64FromInt32(1000)*((*TInterp)(unsafe.Pointer(iPtr)).Flimit.Ftime.Fsec-(*(*TTcl_Time)(unsafe.Pointer(bp + 16))).Fsec) + int64(((*TInterp)(unsafe.Pointer(iPtr)).Flimit.Ftime.Fusec-(*(*TTcl_Time)(unsafe.Pointer(bp + 16))).Fusec)/libc.Int64FromInt32(1000))
			if diff > int64(TCL_TIME_MAXIMUM_SLICE) {
				diff = int64(TCL_TIME_MAXIMUM_SLICE)
			}
			if diff > 0 {
				XTcl_Sleep(tls, int32(diff))
			}
			if XTcl_AsyncReady(tls) != 0 {
				if XTcl_AsyncInvoke(tls, interp, TCL_OK) != TCL_OK {
					return int32(TCL_ERROR)
				}
			}
			if XTcl_Canceled(tls, interp, int32(TCL_LEAVE_ERR_MSG)) == int32(TCL_ERROR) {
				return int32(TCL_ERROR)
			}
			if XTcl_LimitCheck(tls, interp) != TCL_OK {
				return int32(TCL_ERROR)
			}
		}
		XTcl_GetTime(tls, bp+16)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * GetAfterEvent --
 *
 *	This function parses an "after" id such as "after#4" and returns a
 *	pointer to the AfterInfo structure.
 *
 * Results:
 *	The return value is either a pointer to an AfterInfo structure, if one
 *	is found that corresponds to "cmdString" and is for interp, or NULL if
 *	no corresponding after event can be found.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _GetAfterEvent(tls *libc.TLS, assocPtr uintptr, commandPtr uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var afterPtr, cmdString, v1 uintptr
	var id int32
	var _ /* end at bp+0 */ uintptr
	_, _, _, _ = afterPtr, cmdString, id, v1
	if (*TTcl_Obj)(unsafe.Pointer(commandPtr)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(commandPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, commandPtr, libc.UintptrFromInt32(0))
	}
	cmdString = v1
	if libc.Xstrncmp(tls, cmdString, __ccgo_ts+67617, uint64(6)) != 0 {
		return libc.UintptrFromInt32(0)
	}
	cmdString += uintptr(6)
	id = libc.Int32FromUint64(libc.Xstrtoul(tls, cmdString, bp, int32(10)))
	if *(*uintptr)(unsafe.Pointer(bp)) == cmdString || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != 0 {
		return libc.UintptrFromInt32(0)
	}
	afterPtr = (*TAfterAssocData)(unsafe.Pointer(assocPtr)).FfirstAfterPtr
	for {
		if !(afterPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TAfterInfo)(unsafe.Pointer(afterPtr)).Fid == id {
			return afterPtr
		}
		goto _2
	_2:
		;
		afterPtr = (*TAfterInfo)(unsafe.Pointer(afterPtr)).FnextPtr
	}
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * AfterProc --
 *
 *	Timer callback to execute commands registered with the "after"
 *	command.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Executes whatever command was specified. If the command returns an
 *	error, then the command "bgerror" is invoked to process the error; if
 *	bgerror fails then information about the error is output on stderr.
 *
 *----------------------------------------------------------------------
 */

func _AfterProc(tls *libc.TLS, clientData uintptr) {
	/* Describes command to execute. */
	var _objPtr, afterPtr, assocPtr, interp, prevPtr, v3 uintptr
	var result int32
	var v2 TTcl_Size
	_, _, _, _, _, _, _, _ = _objPtr, afterPtr, assocPtr, interp, prevPtr, result, v2, v3
	afterPtr = clientData
	assocPtr = (*TAfterInfo)(unsafe.Pointer(afterPtr)).FassocPtr
	/*
	 * First remove the callback from our list of callbacks; otherwise someone
	 * could delete the callback while it's being executed, which could cause
	 * a core dump.
	 */
	if (*TAfterAssocData)(unsafe.Pointer(assocPtr)).FfirstAfterPtr == afterPtr {
		(*TAfterAssocData)(unsafe.Pointer(assocPtr)).FfirstAfterPtr = (*TAfterInfo)(unsafe.Pointer(afterPtr)).FnextPtr
	} else {
		prevPtr = (*TAfterAssocData)(unsafe.Pointer(assocPtr)).FfirstAfterPtr
		for {
			if !((*TAfterInfo)(unsafe.Pointer(prevPtr)).FnextPtr != afterPtr) {
				break
			}
			/* Empty loop body. */
			goto _1
		_1:
			;
			prevPtr = (*TAfterInfo)(unsafe.Pointer(prevPtr)).FnextPtr
		}
		(*TAfterInfo)(unsafe.Pointer(prevPtr)).FnextPtr = (*TAfterInfo)(unsafe.Pointer(afterPtr)).FnextPtr
	}
	/*
	 * Execute the callback.
	 */
	interp = (*TAfterAssocData)(unsafe.Pointer(assocPtr)).Finterp
	XTcl_Preserve(tls, interp)
	result = XTcl_EvalObjEx(tls, interp, (*TAfterInfo)(unsafe.Pointer(afterPtr)).FcommandPtr, int32(TCL_EVAL_GLOBAL))
	if result != TCL_OK {
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+67624, int64(-int32(1))))
		XTcl_BackgroundException(tls, interp, result)
	}
	XTcl_Release(tls, interp)
	/*
	 * Free the memory for the callback.
	 */
	_objPtr = (*TAfterInfo)(unsafe.Pointer(afterPtr)).FcommandPtr
	v3 = _objPtr
	v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
	*(*TTcl_Size)(unsafe.Pointer(v3))--
	if v2 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	XTclpFree(tls, afterPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * FreeAfterPtr --
 *
 *	This function removes an "after" command from the list of those that
 *	are pending and frees its resources. This function does *not* cancel
 *	the timer handler; if that's needed, the caller must do it.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The memory associated with afterPtr is released.
 *
 *----------------------------------------------------------------------
 */

func _FreeAfterPtr(tls *libc.TLS, afterPtr uintptr) {
	/* Command to be deleted. */
	var _objPtr, assocPtr, prevPtr, v3 uintptr
	var v2 TTcl_Size
	_, _, _, _, _ = _objPtr, assocPtr, prevPtr, v2, v3
	assocPtr = (*TAfterInfo)(unsafe.Pointer(afterPtr)).FassocPtr
	if (*TAfterAssocData)(unsafe.Pointer(assocPtr)).FfirstAfterPtr == afterPtr {
		(*TAfterAssocData)(unsafe.Pointer(assocPtr)).FfirstAfterPtr = (*TAfterInfo)(unsafe.Pointer(afterPtr)).FnextPtr
	} else {
		prevPtr = (*TAfterAssocData)(unsafe.Pointer(assocPtr)).FfirstAfterPtr
		for {
			if !((*TAfterInfo)(unsafe.Pointer(prevPtr)).FnextPtr != afterPtr) {
				break
			}
			/* Empty loop body. */
			goto _1
		_1:
			;
			prevPtr = (*TAfterInfo)(unsafe.Pointer(prevPtr)).FnextPtr
		}
		(*TAfterInfo)(unsafe.Pointer(prevPtr)).FnextPtr = (*TAfterInfo)(unsafe.Pointer(afterPtr)).FnextPtr
	}
	_objPtr = (*TAfterInfo)(unsafe.Pointer(afterPtr)).FcommandPtr
	v3 = _objPtr
	v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
	*(*TTcl_Size)(unsafe.Pointer(v3))--
	if v2 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	XTclpFree(tls, afterPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * AfterCleanupProc --
 *
 *	This function is invoked whenever an interpreter is deleted
 *	to cleanup the AssocData for "tclAfter".
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	After commands are removed.
 *
 *----------------------------------------------------------------------
 */

func _AfterCleanupProc(tls *libc.TLS, clientData uintptr, dummy1256 uintptr) {
	var _objPtr, afterPtr, assocPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _, _ = _objPtr, afterPtr, assocPtr, v1, v2
	assocPtr = clientData
	for (*TAfterAssocData)(unsafe.Pointer(assocPtr)).FfirstAfterPtr != libc.UintptrFromInt32(0) {
		afterPtr = (*TAfterAssocData)(unsafe.Pointer(assocPtr)).FfirstAfterPtr
		(*TAfterAssocData)(unsafe.Pointer(assocPtr)).FfirstAfterPtr = (*TAfterInfo)(unsafe.Pointer(afterPtr)).FnextPtr
		if (*TAfterInfo)(unsafe.Pointer(afterPtr)).Ftoken != libc.UintptrFromInt32(0) {
			XTcl_DeleteTimerHandler(tls, (*TAfterInfo)(unsafe.Pointer(afterPtr)).Ftoken)
		} else {
			XTcl_CancelIdleCall(tls, __ccgo_fp(_AfterProc), afterPtr)
		}
		_objPtr = (*TAfterInfo)(unsafe.Pointer(afterPtr)).FcommandPtr
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		XTclpFree(tls, afterPtr)
	}
	XTclpFree(tls, assocPtr)
}

const TCL_TRACE_ANY_EXEC = 15
const TCL_TRACE_ENTER_DURING_EXEC = 4
const TCL_TRACE_EXEC_DIRECT = 32
const TCL_TRACE_EXEC_IN_PROGRESS = 16
const TCL_TRACE_LEAVE_DURING_EXEC = 8

/* Epoch of the tcl environment
 * (if changed with tcl-env). */

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * Structures used to hold information about variable traces:
 */

type TTraceVarInfo = struct {
	Fflags  int32
	Flength TTcl_Size
}

type TCombinedTraceVarInfo = struct {
	FtraceInfo    TVarTrace
	FtraceCmdInfo TTraceVarInfo
}

/*
 * Structure used to hold information about command traces:
 */

type TTraceCommandInfo = struct {
	Fflags      int32
	Flength     TTcl_Size
	FstepTrace  TTcl_Trace
	FstartLevel TTcl_Size
	FstartCmd   uintptr
	FcurFlags   int32
	FcurCode    int32
	FrefCount   Tsize_t
}

/*
 * Used by command execution traces. Note that we assume in the code that
 * TCL_TRACE_ENTER_DURING_EXEC == 4 * TCL_TRACE_ENTER_EXEC and that
 * TCL_TRACE_LEAVE_DURING_EXEC == 4 * TCL_TRACE_LEAVE_EXEC.
 *
 * TCL_TRACE_ENTER_DURING_EXEC  - Trace each command inside the command
 *				  currently being traced, before execution.
 * TCL_TRACE_LEAVE_DURING_EXEC  - Trace each command inside the command
 *				  currently being traced, after execution.
 * TCL_TRACE_ANY_EXEC		- OR'd combination of all EXEC flags.
 * TCL_TRACE_EXEC_IN_PROGRESS   - The callback function on this trace is
 *				  currently executing. Therefore we don't let
 *				  further traces execute.
 * TCL_TRACE_EXEC_DIRECT	- This execution trace is triggered directly
 *				  by the command being traced, not because of
 *				  an internal trace.
 * The flag 'TCL_TRACE_DESTROYED' may also be used in command execution traces.
 */

/*
 * Forward declarations for functions defined in this file:
 */

type traceOptionsEnum = int32

const TRACE_ADD = 0
const TRACE_INFO = 1
const TRACE_REMOVE = 2

/*
 * Each subcommand has a number of 'types' to which it can apply. Currently
 * 'execution', 'command' and 'variable' are the only types supported. These
 * three arrays MUST be kept in sync! In the future we may provide an API to
 * add to the list of supported trace types.
 */

var _traceTypeOptions = [4]uintptr{
	0: __ccgo_ts + 67646,
	1: __ccgo_ts + 16416,
	2: __ccgo_ts + 3502,
	3: libc.UintptrFromInt32(0),
}
var _traceSubCmds = [3]uintptr{}

func init() {
	p := unsafe.Pointer(&_traceSubCmds)
	*(*uintptr)(unsafe.Add(p, 0)) = __ccgo_fp(_TraceExecutionObjCmd)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_TraceCommandObjCmd)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_TraceVariableObjCmd)
}

/*
 * The following structure holds the client data for string-based
 * trace procs
 */

type TStringTraceData = struct {
	FclientData uintptr
	Fproc       uintptr
}

/*
 * Convenience macros for iterating over the list of traces. Note that each of
 * these *must* be treated as a command, and *must* have a block following it.
 */

/*
 *----------------------------------------------------------------------
 *
 * Tcl_TraceObjCmd --
 *
 *	This function is invoked to process the "trace" Tcl command. See the
 *	user documentation for details on what it does.
 *
 *	Standard syntax as of Tcl 8.4 is:
 *	    trace {add|info|remove} {command|variable} name ops cmd
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *----------------------------------------------------------------------
 */

func XTcl_TraceObjCmd(tls *libc.TLS, dummy189 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var _ /* optionIndex at bp+0 */ traceOptionsEnum
	var _ /* typeIndex at bp+4 */ int32
	var _ /* typeIndex at bp+8 */ int32
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+57971)
		return int32(TCL_ERROR)
	}
	if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), uintptr(unsafe.Pointer(&_traceOptions)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	switch *(*traceOptionsEnum)(unsafe.Pointer(bp)) {
	case int32(TRACE_ADD):
		fallthrough
	case int32(TRACE_REMOVE):
		if objc < int32(3) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+67656)
			return int32(TCL_ERROR)
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), uintptr(unsafe.Pointer(&_traceTypeOptions)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+4) != TCL_OK {
			return int32(TCL_ERROR)
		}
		return (*(*func(*libc.TLS, uintptr, traceOptionsEnum, TTcl_Size, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{_traceSubCmds[*(*int32)(unsafe.Pointer(bp + 4))]})))(tls, interp, *(*traceOptionsEnum)(unsafe.Pointer(bp)), int64(objc), objv)
	case int32(TRACE_INFO):
		if objc < int32(3) {
			/*
			 * Delegate other complaints to the type-specific code which can
			 * give a better error message.
			 */
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+67671)
			return int32(TCL_ERROR)
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), uintptr(unsafe.Pointer(&_traceTypeOptions)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+8) != TCL_OK {
			return int32(TCL_ERROR)
		}
		return (*(*func(*libc.TLS, uintptr, traceOptionsEnum, TTcl_Size, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{_traceSubCmds[*(*int32)(unsafe.Pointer(bp + 8))]})))(tls, interp, *(*traceOptionsEnum)(unsafe.Pointer(bp)), int64(objc), objv)
		break
	}
	return TCL_OK
}

/* Main sub commands to 'trace' */
var _traceOptions = [4]uintptr{
	0: __ccgo_ts + 2121,
	1: __ccgo_ts + 5873,
	2: __ccgo_ts + 26241,
	3: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * TraceExecutionObjCmd --
 *
 *	Helper function for Tcl_TraceObjCmd; implements the [trace
 *	{add|remove|info} execution ...] subcommands. See the user
 *	documentation for details on what these do.
 *
 * Results:
 *	Standard Tcl result.
 *
 * Side effects:
 *	Depends on the operation (add, remove, or info) being performed; may
 *	add or remove command traces on a command.
 *
 *----------------------------------------------------------------------
 */

func _TraceExecutionObjCmd(tls *libc.TLS, interp uintptr, optionIndex traceOptionsEnum, objc TTcl_Size, objv uintptr) (r int32) {
	bp := tls.Alloc(96)
	defer tls.Free(96) /* Argument objects. */
	var _objPtr, _objPtr1, cachePtr, cachePtr1, cachePtr2, cachePtr3, clientData, clientData1, command, eachTraceObjPtr, elemObjPtr, name, opObj, resultListPtr, tcmdPtr, tcmdPtr1, tcmdPtr2, v10, v12, v13, v14, v22, v24, v7, v8, v9 uintptr
	var flags, result, v1, v3 int32
	var i, v21, v23 TTcl_Size
	var v11 Tsize_t
	var v15, v16, v17, v18 bool
	var v2, v20, v4, v5 int64
	var _ /* elemPtrs at bp+24 */ uintptr
	var _ /* index at bp+8 */ int32
	var _ /* length at bp+0 */ TTcl_Size
	var _ /* listLen at bp+16 */ TTcl_Size
	var _ /* numOps at bp+32 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, cachePtr1, cachePtr2, cachePtr3, clientData, clientData1, command, eachTraceObjPtr, elemObjPtr, flags, i, name, opObj, result, resultListPtr, tcmdPtr, tcmdPtr1, tcmdPtr2, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v2, v20, v21, v22, v23, v24, v3, v4, v5, v7, v8, v9
	switch optionIndex {
	case int32(TRACE_ADD):
		fallthrough
	case int32(TRACE_REMOVE):
		flags = 0
		if objc != int64(6) {
			XTcl_WrongNumArgs(tls, interp, int64(3), objv, __ccgo_ts+67713)
			return int32(TCL_ERROR)
		}
		/*
		 * Make sure the ops argument is a list object; get its length and a
		 * pointer to its array of element pointers.
		 */
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr2 != 0 {
				v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr2)).FspanLength
			} else {
				v2 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = v2
			v1 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1 = XTcl_ListObjLength(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 4*8)), bp+16)
		}
		result = v1
		if result != TCL_OK {
			return result
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) == 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+67733, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+48, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+67817, __ccgo_ts+67823, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr2 != 0 {
				v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr2)).FspanStart
			} else {
				v4 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 24)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr1 + 40 + uintptr(v4)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr2 != 0 {
				v5 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr2)).FspanLength
			} else {
				v5 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = v5
			v3 = libc.Int32FromInt32(TCL_OK)
		} else {
			v3 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 4*8)), bp+16, bp+24)
		}
		result = v3
		if result != TCL_OK {
			return result
		}
		i = 0
		for {
			if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 16))) {
				break
			}
			if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + uintptr(i)*8)), uintptr(unsafe.Pointer(&_opStrings)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+18172, libc.Int32FromInt32(TCL_EXACT)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+8) != TCL_OK {
				return int32(TCL_ERROR)
			}
			switch *(*int32)(unsafe.Pointer(bp + 8)) {
			case 0:
				flags |= int32(TCL_TRACE_ENTER_EXEC)
			case 1:
				flags |= int32(TCL_TRACE_LEAVE_EXEC)
			case 2:
				flags |= int32(TCL_TRACE_ENTER_DURING_EXEC)
			case 3:
				flags |= int32(TCL_TRACE_LEAVE_DURING_EXEC)
				break
			}
			goto _6
		_6:
			;
			i++
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 5*8)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 5*8)))).Flength
			v7 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 5*8)))).Fbytes
		} else {
			v7 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 5*8)), bp)
		}
		command = v7
		if optionIndex == int32(TRACE_ADD) {
			tcmdPtr = XTcl_Alloc(tls, uint64(libc.UintptrFromInt32(0)+56)+libc.Uint64FromInt32(1)+libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))))
			(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).Fflags = flags
			(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FstepTrace = libc.UintptrFromInt32(0)
			(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FstartLevel = 0
			(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FstartCmd = libc.UintptrFromInt32(0)
			(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).Flength = *(*TTcl_Size)(unsafe.Pointer(bp))
			(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FrefCount = uint64(1)
			flags |= int32(TCL_TRACE_DELETE)
			if flags&(libc.Int32FromInt32(TCL_TRACE_ENTER_DURING_EXEC)|libc.Int32FromInt32(TCL_TRACE_LEAVE_DURING_EXEC)) != 0 {
				flags |= libc.Int32FromInt32(TCL_TRACE_ENTER_EXEC) | libc.Int32FromInt32(TCL_TRACE_LEAVE_EXEC)
			}
			libc.Xmemcpy(tls, tcmdPtr+56, command, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))+int64(1)))
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes != 0 {
				v8 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes
			} else {
				v8 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0))
			}
			name = v8
			if XTcl_TraceCommand(tls, interp, name, flags, __ccgo_fp(_TraceCommandProc), tcmdPtr) != TCL_OK {
				XTclpFree(tls, tcmdPtr)
				return int32(TCL_ERROR)
			}
		} else {
			/*
			 * First ensure the name given is valid.
			 */
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes != 0 {
				v9 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes
			} else {
				v9 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0))
			}
			name = v9
			if XTcl_FindCommand(tls, interp, name, libc.UintptrFromInt32(0), int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
				return int32(TCL_ERROR)
			}
			clientData = libc.UintptrFromInt32(0)
			for {
				v10 = XTcl_CommandTraceInfo(tls, interp, name, 0, __ccgo_fp(_TraceCommandProc), clientData)
				clientData = v10
				if !(v10 != libc.UintptrFromInt32(0)) {
					break
				}
				tcmdPtr1 = clientData
				/*
				 * In checking the 'flags' field we must remove any extraneous
				 * flags which may have been temporarily added by various
				 * pieces of the trace mechanism.
				 */
				if (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr1)).Flength == *(*TTcl_Size)(unsafe.Pointer(bp)) && (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr1)).Fflags&(libc.Int32FromInt32(TCL_TRACE_ANY_EXEC)|libc.Int32FromInt32(TCL_TRACE_RENAME)|libc.Int32FromInt32(TCL_TRACE_DELETE)) == flags && libc.Xstrncmp(tls, command, tcmdPtr1+56, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))) == 0 {
					flags |= int32(TCL_TRACE_DELETE)
					if flags&(libc.Int32FromInt32(TCL_TRACE_ENTER_DURING_EXEC)|libc.Int32FromInt32(TCL_TRACE_LEAVE_DURING_EXEC)) != 0 {
						flags |= libc.Int32FromInt32(TCL_TRACE_ENTER_EXEC) | libc.Int32FromInt32(TCL_TRACE_LEAVE_EXEC)
					}
					XTcl_UntraceCommand(tls, interp, name, flags, __ccgo_fp(_TraceCommandProc), clientData)
					if (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr1)).FstepTrace != libc.UintptrFromInt32(0) {
						/*
						 * We need to remove the interpreter-wide trace which
						 * we created to allow 'step' traces.
						 */
						XTcl_DeleteTrace(tls, interp, (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr1)).FstepTrace)
						(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr1)).FstepTrace = libc.UintptrFromInt32(0)
						XTclpFree(tls, (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr1)).FstartCmd)
					}
					if (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr1)).Fflags&int32(TCL_TRACE_EXEC_IN_PROGRESS) != 0 {
						/*
						 * Postpone deletion.
						 */
						(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr1)).Fflags = 0
					}
					v12 = tcmdPtr1 + 48
					v11 = *(*Tsize_t)(unsafe.Pointer(v12))
					*(*Tsize_t)(unsafe.Pointer(v12))--
					if v11 <= uint64(1) {
						XTclpFree(tls, tcmdPtr1)
					}
					break
				}
			}
		}
	case int32(TRACE_INFO):
		if objc != int64(4) {
			XTcl_WrongNumArgs(tls, interp, int64(3), objv, __ccgo_ts+3726)
			return int32(TCL_ERROR)
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes != 0 {
			v13 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes
		} else {
			v13 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0))
		}
		name = v13
		/*
		 * First ensure the name given is valid.
		 */
		if XTcl_FindCommand(tls, interp, name, libc.UintptrFromInt32(0), int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
		resultListPtr = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
		clientData1 = libc.UintptrFromInt32(0)
		for {
			v14 = XTcl_CommandTraceInfo(tls, interp, name, 0, __ccgo_fp(_TraceCommandProc), clientData1)
			clientData1 = v14
			if !(v14 != libc.UintptrFromInt32(0)) {
				break
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = 0
			tcmdPtr2 = clientData1
			/*
			 * Build a list with the ops list as the first obj element and the
			 * tcmdPtr->command string as the second obj element. Append this
			 * list (as an element) to the end of the result object list.
			 */
			elemObjPtr = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
			(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).FrefCount++
			if (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr2)).Fflags&int32(TCL_TRACE_ENTER_EXEC) != 0 {
				if v15 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v15 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v15 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
					opObj = XTclThreadAllocObj(tls)
				} else {
					opObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(opObj + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(opObj)).FrefCount = 0
				if libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1) == uint64(0) {
					(*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(opObj)).Flength = int64(libc.Int32FromInt32(0))
				} else {
					(*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
					libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes, __ccgo_ts+67681, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1))
					*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes + uintptr(libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)))) = uint8('\000')
					(*TTcl_Obj)(unsafe.Pointer(opObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(6) - libc.Uint64FromInt32(1))
				}
				(*TTcl_Obj)(unsafe.Pointer(opObj)).FtypePtr = libc.UintptrFromInt32(0)
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), elemObjPtr, opObj)
			}
			if (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr2)).Fflags&int32(TCL_TRACE_LEAVE_EXEC) != 0 {
				if v16 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v16 {
					cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v16 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
					opObj = XTclThreadAllocObj(tls)
				} else {
					opObj = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(opObj + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(opObj)).FrefCount = 0
				if libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1) == uint64(0) {
					(*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(opObj)).Flength = int64(libc.Int32FromInt32(0))
				} else {
					(*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
					libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes, __ccgo_ts+67687, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1))
					*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes + uintptr(libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)))) = uint8('\000')
					(*TTcl_Obj)(unsafe.Pointer(opObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(6) - libc.Uint64FromInt32(1))
				}
				(*TTcl_Obj)(unsafe.Pointer(opObj)).FtypePtr = libc.UintptrFromInt32(0)
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), elemObjPtr, opObj)
			}
			if (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr2)).Fflags&int32(TCL_TRACE_ENTER_DURING_EXEC) != 0 {
				if v17 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v17 {
					cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v17 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
					opObj = XTclThreadAllocObj(tls)
				} else {
					opObj = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(opObj + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(opObj)).FrefCount = 0
				if libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1) == uint64(0) {
					(*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(opObj)).Flength = int64(libc.Int32FromInt32(0))
				} else {
					(*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
					libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes, __ccgo_ts+67693, libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1))
					*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes + uintptr(libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1)))) = uint8('\000')
					(*TTcl_Obj)(unsafe.Pointer(opObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(10) - libc.Uint64FromInt32(1))
				}
				(*TTcl_Obj)(unsafe.Pointer(opObj)).FtypePtr = libc.UintptrFromInt32(0)
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), elemObjPtr, opObj)
			}
			if (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr2)).Fflags&int32(TCL_TRACE_LEAVE_DURING_EXEC) != 0 {
				if v18 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v18 {
					cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v18 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
					opObj = XTclThreadAllocObj(tls)
				} else {
					opObj = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(opObj + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(opObj)).FrefCount = 0
				if libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1) == uint64(0) {
					(*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(opObj)).Flength = int64(libc.Int32FromInt32(0))
				} else {
					(*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
					libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes, __ccgo_ts+67703, libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1))
					*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes + uintptr(libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1)))) = uint8('\000')
					(*TTcl_Obj)(unsafe.Pointer(opObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(10) - libc.Uint64FromInt32(1))
				}
				(*TTcl_Obj)(unsafe.Pointer(opObj)).FtypePtr = libc.UintptrFromInt32(0)
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), elemObjPtr, opObj)
			}
			if (*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(elemObjPtr + 32))).Fptr2 != 0 {
					v20 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(elemObjPtr + 32))).Fptr2)).FspanLength
				} else {
					v20 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(elemObjPtr + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = v20
				_ = libc.Int32FromInt32(TCL_OK)
			} else {
				XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), elemObjPtr, bp+32)
			}
			if 0 == *(*TTcl_Size)(unsafe.Pointer(bp + 32)) {
				_objPtr = elemObjPtr
				v22 = _objPtr
				v21 = *(*TTcl_Size)(unsafe.Pointer(v22))
				*(*TTcl_Size)(unsafe.Pointer(v22))--
				if v21 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
				continue
			}
			eachTraceObjPtr = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), eachTraceObjPtr, elemObjPtr)
			_objPtr1 = elemObjPtr
			v24 = _objPtr1
			v23 = *(*TTcl_Size)(unsafe.Pointer(v24))
			*(*TTcl_Size)(unsafe.Pointer(v24))--
			if v23 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
			elemObjPtr = libc.UintptrFromInt32(0)
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), eachTraceObjPtr, XTcl_NewStringObj(tls, tcmdPtr2+56, int64(-int32(1))))
			XTcl_ListObjAppendElement(tls, interp, resultListPtr, eachTraceObjPtr)
		}
		XTcl_SetObjResult(tls, interp, resultListPtr)
		break
	}
	return TCL_OK
}

var _opStrings = [5]uintptr{
	0: __ccgo_ts + 67681,
	1: __ccgo_ts + 67687,
	2: __ccgo_ts + 67693,
	3: __ccgo_ts + 67703,
	4: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * TraceCommandObjCmd --
 *
 *	Helper function for Tcl_TraceObjCmd; implements the [trace
 *	{add|info|remove} command ...] subcommands. See the user documentation
 *	for details on what these do.
 *
 * Results:
 *	Standard Tcl result.
 *
 * Side effects:
 *	Depends on the operation (add, remove, or info) being performed; may
 *	add or remove command traces on a command.
 *
 *----------------------------------------------------------------------
 */

func _TraceCommandObjCmd(tls *libc.TLS, interp uintptr, optionIndex traceOptionsEnum, objc TTcl_Size, objv uintptr) (r int32) {
	bp := tls.Alloc(96)
	defer tls.Free(96) /* Argument objects. */
	var _objPtr, _objPtr1, cachePtr, cachePtr1, clientData, clientData1, command, eachTraceObjPtr, elemObjPtr, name, opObj, resultListPtr, tcmdPtr, tcmdPtr1, tcmdPtr2, v10, v12, v13, v14, v20, v22, v7, v8, v9 uintptr
	var flags, result, v1, v3 int32
	var i, v19, v21 TTcl_Size
	var v11 Tsize_t
	var v15, v16 bool
	var v18, v2, v4, v5 int64
	var _ /* elemPtrs at bp+24 */ uintptr
	var _ /* index at bp+8 */ int32
	var _ /* length at bp+0 */ TTcl_Size
	var _ /* listLen at bp+16 */ TTcl_Size
	var _ /* numOps at bp+32 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, cachePtr1, clientData, clientData1, command, eachTraceObjPtr, elemObjPtr, flags, i, name, opObj, result, resultListPtr, tcmdPtr, tcmdPtr1, tcmdPtr2, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v21, v22, v3, v4, v5, v7, v8, v9
	switch optionIndex {
	case int32(TRACE_ADD):
		fallthrough
	case int32(TRACE_REMOVE):
		flags = 0
		if objc != int64(6) {
			XTcl_WrongNumArgs(tls, interp, int64(3), objv, __ccgo_ts+67713)
			return int32(TCL_ERROR)
		}
		/*
		 * Make sure the ops argument is a list object; get its length and a
		 * pointer to its array of element pointers.
		 */
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr2 != 0 {
				v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr2)).FspanLength
			} else {
				v2 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = v2
			v1 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1 = XTcl_ListObjLength(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 4*8)), bp+16)
		}
		result = v1
		if result != TCL_OK {
			return result
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) == 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+67829, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+48, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+67817, __ccgo_ts+67823, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr2 != 0 {
				v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr2)).FspanStart
			} else {
				v4 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 24)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr1 + 40 + uintptr(v4)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr2 != 0 {
				v5 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr2)).FspanLength
			} else {
				v5 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = v5
			v3 = libc.Int32FromInt32(TCL_OK)
		} else {
			v3 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 4*8)), bp+16, bp+24)
		}
		result = v3
		if result != TCL_OK {
			return result
		}
		i = 0
		for {
			if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 16))) {
				break
			}
			if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + uintptr(i)*8)), uintptr(unsafe.Pointer(&_opStrings1)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+18172, libc.Int32FromInt32(TCL_EXACT)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+8) != TCL_OK {
				return int32(TCL_ERROR)
			}
			switch *(*int32)(unsafe.Pointer(bp + 8)) {
			case 1:
				flags |= int32(TCL_TRACE_RENAME)
			case 0:
				flags |= int32(TCL_TRACE_DELETE)
				break
			}
			goto _6
		_6:
			;
			i++
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 5*8)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 5*8)))).Flength
			v7 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 5*8)))).Fbytes
		} else {
			v7 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 5*8)), bp)
		}
		command = v7
		if optionIndex == int32(TRACE_ADD) {
			tcmdPtr = XTcl_Alloc(tls, uint64(libc.UintptrFromInt32(0)+56)+libc.Uint64FromInt32(1)+libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))))
			(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).Fflags = flags
			(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FstepTrace = libc.UintptrFromInt32(0)
			(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FstartLevel = 0
			(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FstartCmd = libc.UintptrFromInt32(0)
			(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).Flength = *(*TTcl_Size)(unsafe.Pointer(bp))
			(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FrefCount = uint64(1)
			flags |= int32(TCL_TRACE_DELETE)
			libc.Xmemcpy(tls, tcmdPtr+56, command, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))+int64(1)))
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes != 0 {
				v8 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes
			} else {
				v8 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0))
			}
			name = v8
			if XTcl_TraceCommand(tls, interp, name, flags, __ccgo_fp(_TraceCommandProc), tcmdPtr) != TCL_OK {
				XTclpFree(tls, tcmdPtr)
				return int32(TCL_ERROR)
			}
		} else {
			/*
			 * First ensure the name given is valid.
			 */
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes != 0 {
				v9 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes
			} else {
				v9 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0))
			}
			name = v9
			if XTcl_FindCommand(tls, interp, name, libc.UintptrFromInt32(0), int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
				return int32(TCL_ERROR)
			}
			clientData = libc.UintptrFromInt32(0)
			for {
				v10 = XTcl_CommandTraceInfo(tls, interp, name, 0, __ccgo_fp(_TraceCommandProc), clientData)
				clientData = v10
				if !(v10 != libc.UintptrFromInt32(0)) {
					break
				}
				tcmdPtr1 = clientData
				if (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr1)).Flength == *(*TTcl_Size)(unsafe.Pointer(bp)) && (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr1)).Fflags == flags && libc.Xstrncmp(tls, command, tcmdPtr1+56, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))) == 0 {
					XTcl_UntraceCommand(tls, interp, name, flags|int32(TCL_TRACE_DELETE), __ccgo_fp(_TraceCommandProc), clientData)
					*(*int32)(unsafe.Pointer(tcmdPtr1)) |= int32(TCL_TRACE_DESTROYED)
					v12 = tcmdPtr1 + 48
					v11 = *(*Tsize_t)(unsafe.Pointer(v12))
					*(*Tsize_t)(unsafe.Pointer(v12))--
					if v11 <= uint64(1) {
						XTclpFree(tls, tcmdPtr1)
					}
					break
				}
			}
		}
	case int32(TRACE_INFO):
		if objc != int64(4) {
			XTcl_WrongNumArgs(tls, interp, int64(3), objv, __ccgo_ts+3726)
			return int32(TCL_ERROR)
		}
		/*
		 * First ensure the name given is valid.
		 */
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes != 0 {
			v13 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes
		} else {
			v13 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0))
		}
		name = v13
		if XTcl_FindCommand(tls, interp, name, libc.UintptrFromInt32(0), int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
		resultListPtr = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
		clientData1 = libc.UintptrFromInt32(0)
		for {
			v14 = XTcl_CommandTraceInfo(tls, interp, name, 0, __ccgo_fp(_TraceCommandProc), clientData1)
			clientData1 = v14
			if !(v14 != libc.UintptrFromInt32(0)) {
				break
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = 0
			tcmdPtr2 = clientData1
			/*
			 * Build a list with the ops list as the first obj element and the
			 * tcmdPtr->command string as the second obj element. Append this
			 * list (as an element) to the end of the result object list.
			 */
			elemObjPtr = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
			(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).FrefCount++
			if (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr2)).Fflags&int32(TCL_TRACE_RENAME) != 0 {
				if v15 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v15 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v15 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
					opObj = XTclThreadAllocObj(tls)
				} else {
					opObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(opObj + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(opObj)).FrefCount = 0
				if libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1) == uint64(0) {
					(*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(opObj)).Flength = int64(libc.Int32FromInt32(0))
				} else {
					(*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
					libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes, __ccgo_ts+5364, libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1))
					*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes + uintptr(libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1)))) = uint8('\000')
					(*TTcl_Obj)(unsafe.Pointer(opObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(7) - libc.Uint64FromInt32(1))
				}
				(*TTcl_Obj)(unsafe.Pointer(opObj)).FtypePtr = libc.UintptrFromInt32(0)
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), elemObjPtr, opObj)
			}
			if (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr2)).Fflags&int32(TCL_TRACE_DELETE) != 0 {
				if v16 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v16 {
					cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v16 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
					opObj = XTclThreadAllocObj(tls)
				} else {
					opObj = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(opObj + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(opObj)).FrefCount = 0
				if libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1) == uint64(0) {
					(*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(opObj)).Flength = int64(libc.Int32FromInt32(0))
				} else {
					(*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
					libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes, __ccgo_ts+5663, libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1))
					*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(opObj)).Fbytes + uintptr(libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1)))) = uint8('\000')
					(*TTcl_Obj)(unsafe.Pointer(opObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(7) - libc.Uint64FromInt32(1))
				}
				(*TTcl_Obj)(unsafe.Pointer(opObj)).FtypePtr = libc.UintptrFromInt32(0)
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), elemObjPtr, opObj)
			}
			if (*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(elemObjPtr + 32))).Fptr2 != 0 {
					v18 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(elemObjPtr + 32))).Fptr2)).FspanLength
				} else {
					v18 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(elemObjPtr + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = v18
				_ = libc.Int32FromInt32(TCL_OK)
			} else {
				XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), elemObjPtr, bp+32)
			}
			if 0 == *(*TTcl_Size)(unsafe.Pointer(bp + 32)) {
				_objPtr = elemObjPtr
				v20 = _objPtr
				v19 = *(*TTcl_Size)(unsafe.Pointer(v20))
				*(*TTcl_Size)(unsafe.Pointer(v20))--
				if v19 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
				continue
			}
			eachTraceObjPtr = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), eachTraceObjPtr, elemObjPtr)
			_objPtr1 = elemObjPtr
			v22 = _objPtr1
			v21 = *(*TTcl_Size)(unsafe.Pointer(v22))
			*(*TTcl_Size)(unsafe.Pointer(v22))--
			if v21 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
			elemObjPtr = XTcl_NewStringObj(tls, tcmdPtr2+56, int64(-int32(1)))
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), eachTraceObjPtr, elemObjPtr)
			XTcl_ListObjAppendElement(tls, interp, resultListPtr, eachTraceObjPtr)
		}
		XTcl_SetObjResult(tls, interp, resultListPtr)
		break
	}
	return TCL_OK
}

var _opStrings1 = [3]uintptr{
	0: __ccgo_ts + 5663,
	1: __ccgo_ts + 5364,
	2: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * TraceVariableObjCmd --
 *
 *	Helper function for Tcl_TraceObjCmd; implements the [trace
 *	{add|info|remove} variable ...] subcommands. See the user
 *	documentation for details on what these do.
 *
 * Results:
 *	Standard Tcl result.
 *
 * Side effects:
 *	Depends on the operation (add, remove, or info) being performed; may
 *	add or remove variable traces on a variable.
 *
 *----------------------------------------------------------------------
 */

func _TraceVariableObjCmd(tls *libc.TLS, interp uintptr, optionIndex traceOptionsEnum, objc TTcl_Size, objv uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* Argument objects. */
	var cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, clientData, command, ctvarPtr, eachTraceObjPtr, elemObjPtr, name, opObjPtr, resultListPtr, tvarPtr, tvarPtr1, v10, v12, v13, v7, v8, v9 uintptr
	var flags, result, v1, v3 int32
	var i TTcl_Size
	var v11, v14, v15, v16, v17 bool
	var v2, v4, v5 int64
	var _ /* elemPtrs at bp+24 */ uintptr
	var _ /* index at bp+8 */ int32
	var _ /* length at bp+0 */ TTcl_Size
	var _ /* listLen at bp+16 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, clientData, command, ctvarPtr, eachTraceObjPtr, elemObjPtr, flags, i, name, opObjPtr, result, resultListPtr, tvarPtr, tvarPtr1, v1, v10, v11, v12, v13, v14, v15, v16, v17, v2, v3, v4, v5, v7, v8, v9
	switch optionIndex {
	case int32(TRACE_ADD):
		fallthrough
	case int32(TRACE_REMOVE):
		flags = 0
		if objc != int64(6) {
			XTcl_WrongNumArgs(tls, interp, int64(3), objv, __ccgo_ts+67713)
			return int32(TCL_ERROR)
		}
		/*
		 * Make sure the ops argument is a list object; get its length and a
		 * pointer to its array of element pointers.
		 */
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr2 != 0 {
				v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr2)).FspanLength
			} else {
				v2 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = v2
			v1 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1 = XTcl_ListObjLength(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 4*8)), bp+16)
		}
		result = v1
		if result != TCL_OK {
			return result
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) == 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+67892, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+67817, __ccgo_ts+67823, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr2 != 0 {
				v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr2)).FspanStart
			} else {
				v4 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 24)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr1 + 40 + uintptr(v4)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr2 != 0 {
				v5 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr2)).FspanLength
			} else {
				v5 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 4*8)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = v5
			v3 = libc.Int32FromInt32(TCL_OK)
		} else {
			v3 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 4*8)), bp+16, bp+24)
		}
		result = v3
		if result != TCL_OK {
			return result
		}
		i = 0
		for {
			if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 16))) {
				break
			}
			if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + uintptr(i)*8)), uintptr(unsafe.Pointer(&_opStrings2)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+18172, libc.Int32FromInt32(TCL_EXACT)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+8) != TCL_OK {
				return int32(TCL_ERROR)
			}
			switch *(*int32)(unsafe.Pointer(bp + 8)) {
			case 0:
				flags |= int32(TCL_TRACE_ARRAY)
			case 1:
				flags |= int32(TCL_TRACE_READS)
			case 2:
				flags |= int32(TCL_TRACE_UNSETS)
			case 3:
				flags |= int32(TCL_TRACE_WRITES)
				break
			}
			goto _6
		_6:
			;
			i++
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 5*8)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 5*8)))).Flength
			v7 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 5*8)))).Fbytes
		} else {
			v7 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 5*8)), bp)
		}
		command = v7
		if optionIndex == int32(TRACE_ADD) {
			ctvarPtr = XTcl_Alloc(tls, uint64(libc.UintptrFromInt32(0)+32+16)+libc.Uint64FromInt32(1)+libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))))
			(*TCombinedTraceVarInfo)(unsafe.Pointer(ctvarPtr)).FtraceCmdInfo.Fflags = flags
			(*TCombinedTraceVarInfo)(unsafe.Pointer(ctvarPtr)).FtraceCmdInfo.Flength = *(*TTcl_Size)(unsafe.Pointer(bp))
			flags |= libc.Int32FromInt32(TCL_TRACE_UNSETS) | libc.Int32FromInt32(TCL_TRACE_RESULT_OBJECT)
			libc.Xmemcpy(tls, ctvarPtr+32+16, command, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))+int64(1)))
			(*TCombinedTraceVarInfo)(unsafe.Pointer(ctvarPtr)).FtraceInfo.FtraceProc = __ccgo_fp(_TraceVarProc)
			(*TCombinedTraceVarInfo)(unsafe.Pointer(ctvarPtr)).FtraceInfo.FclientData = ctvarPtr + 32
			(*TCombinedTraceVarInfo)(unsafe.Pointer(ctvarPtr)).FtraceInfo.Fflags = flags
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes != 0 {
				v8 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes
			} else {
				v8 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0))
			}
			name = v8
			if _TraceVarEx(tls, interp, name, libc.UintptrFromInt32(0), ctvarPtr) != TCL_OK {
				XTclpFree(tls, ctvarPtr)
				return int32(TCL_ERROR)
			}
		} else {
			/*
			 * Search through all of our traces on this variable to see if
			 * there's one with the given command. If so, then delete the
			 * first one that matches.
			 */
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes != 0 {
				v9 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes
			} else {
				v9 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0))
			}
			name = v9
			clientData = libc.UintptrFromInt32(0)
			for {
				v10 = XTcl_VarTraceInfo2(tls, interp, name, libc.UintptrFromInt32(0), 0, __ccgo_fp(_TraceVarProc), clientData)
				clientData = v10
				if !(v10 != libc.UintptrFromInt32(0)) {
					break
				}
				tvarPtr = clientData
				if (*TTraceVarInfo)(unsafe.Pointer(tvarPtr)).Flength == *(*TTcl_Size)(unsafe.Pointer(bp)) && (*TTraceVarInfo)(unsafe.Pointer(tvarPtr)).Fflags == flags && libc.Xstrncmp(tls, command, tvarPtr+16, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))) == 0 {
					XTcl_UntraceVar2(tls, interp, name, libc.UintptrFromInt32(0), flags|int32(TCL_TRACE_UNSETS)|int32(TCL_TRACE_RESULT_OBJECT), __ccgo_fp(_TraceVarProc), clientData)
					break
				}
			}
		}
	case int32(TRACE_INFO):
		if objc != int64(4) {
			XTcl_WrongNumArgs(tls, interp, int64(3), objv, __ccgo_ts+3726)
			return int32(TCL_ERROR)
		}
		if v11 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v11 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v11 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			resultListPtr = XTclThreadAllocObj(tls)
		} else {
			resultListPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(resultListPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(resultListPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(resultListPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(resultListPtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(resultListPtr)).FtypePtr = libc.UintptrFromInt32(0)
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes != 0 {
			v12 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes
		} else {
			v12 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0))
		}
		name = v12
		clientData = libc.UintptrFromInt32(0)
		for {
			v13 = XTcl_VarTraceInfo2(tls, interp, name, libc.UintptrFromInt32(0), 0, __ccgo_fp(_TraceVarProc), clientData)
			clientData = v13
			if !(v13 != libc.UintptrFromInt32(0)) {
				break
			}
			tvarPtr1 = clientData
			/*
			 * Build a list with the ops list as the first obj element and the
			 * tcmdPtr->command string as the second obj element. Append this
			 * list (as an element) to the end of the result object list.
			 */
			elemObjPtr = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
			if (*TTraceVarInfo)(unsafe.Pointer(tvarPtr1)).Fflags&int32(TCL_TRACE_ARRAY) != 0 {
				if v14 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v14 {
					cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v14 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
					opObjPtr = XTclThreadAllocObj(tls)
				} else {
					opObjPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(opObjPtr + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(opObjPtr)).FrefCount = 0
				if libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1) == uint64(0) {
					(*TTcl_Obj)(unsafe.Pointer(opObjPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(opObjPtr)).Flength = int64(libc.Int32FromInt32(0))
				} else {
					(*TTcl_Obj)(unsafe.Pointer(opObjPtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
					libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(opObjPtr)).Fbytes, __ccgo_ts+28190, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1))
					*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(opObjPtr)).Fbytes + uintptr(libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)))) = uint8('\000')
					(*TTcl_Obj)(unsafe.Pointer(opObjPtr)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(6) - libc.Uint64FromInt32(1))
				}
				(*TTcl_Obj)(unsafe.Pointer(opObjPtr)).FtypePtr = libc.UintptrFromInt32(0)
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), elemObjPtr, opObjPtr)
			}
			if (*TTraceVarInfo)(unsafe.Pointer(tvarPtr1)).Fflags&int32(TCL_TRACE_READS) != 0 {
				if v15 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v15 {
					cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v15 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
					opObjPtr = XTclThreadAllocObj(tls)
				} else {
					opObjPtr = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(opObjPtr + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(opObjPtr)).FrefCount = 0
				if libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1) == uint64(0) {
					(*TTcl_Obj)(unsafe.Pointer(opObjPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(opObjPtr)).Flength = int64(libc.Int32FromInt32(0))
				} else {
					(*TTcl_Obj)(unsafe.Pointer(opObjPtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
					libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(opObjPtr)).Fbytes, __ccgo_ts+5552, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1))
					*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(opObjPtr)).Fbytes + uintptr(libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)))) = uint8('\000')
					(*TTcl_Obj)(unsafe.Pointer(opObjPtr)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(5) - libc.Uint64FromInt32(1))
				}
				(*TTcl_Obj)(unsafe.Pointer(opObjPtr)).FtypePtr = libc.UintptrFromInt32(0)
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), elemObjPtr, opObjPtr)
			}
			if (*TTraceVarInfo)(unsafe.Pointer(tvarPtr1)).Fflags&int32(TCL_TRACE_WRITES) != 0 {
				if v16 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v16 {
					cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v16 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
					opObjPtr = XTclThreadAllocObj(tls)
				} else {
					opObjPtr = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(opObjPtr + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(opObjPtr)).FrefCount = 0
				if libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1) == uint64(0) {
					(*TTcl_Obj)(unsafe.Pointer(opObjPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(opObjPtr)).Flength = int64(libc.Int32FromInt32(0))
				} else {
					(*TTcl_Obj)(unsafe.Pointer(opObjPtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
					libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(opObjPtr)).Fbytes, __ccgo_ts+44159, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1))
					*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(opObjPtr)).Fbytes + uintptr(libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)))) = uint8('\000')
					(*TTcl_Obj)(unsafe.Pointer(opObjPtr)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(6) - libc.Uint64FromInt32(1))
				}
				(*TTcl_Obj)(unsafe.Pointer(opObjPtr)).FtypePtr = libc.UintptrFromInt32(0)
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), elemObjPtr, opObjPtr)
			}
			if (*TTraceVarInfo)(unsafe.Pointer(tvarPtr1)).Fflags&int32(TCL_TRACE_UNSETS) != 0 {
				if v17 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v17 {
					cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v17 || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == libc.Uint64FromInt32(0) {
					opObjPtr = XTclThreadAllocObj(tls)
				} else {
					opObjPtr = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(opObjPtr + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(opObjPtr)).FrefCount = 0
				if libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1) == uint64(0) {
					(*TTcl_Obj)(unsafe.Pointer(opObjPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
					(*TTcl_Obj)(unsafe.Pointer(opObjPtr)).Flength = int64(libc.Int32FromInt32(0))
				} else {
					(*TTcl_Obj)(unsafe.Pointer(opObjPtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
					libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(opObjPtr)).Fbytes, __ccgo_ts+3450, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1))
					*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(opObjPtr)).Fbytes + uintptr(libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)))) = uint8('\000')
					(*TTcl_Obj)(unsafe.Pointer(opObjPtr)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(6) - libc.Uint64FromInt32(1))
				}
				(*TTcl_Obj)(unsafe.Pointer(opObjPtr)).FtypePtr = libc.UintptrFromInt32(0)
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), elemObjPtr, opObjPtr)
			}
			eachTraceObjPtr = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), eachTraceObjPtr, elemObjPtr)
			elemObjPtr = XTcl_NewStringObj(tls, tvarPtr1+16, int64(-int32(1)))
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), eachTraceObjPtr, elemObjPtr)
			XTcl_ListObjAppendElement(tls, interp, resultListPtr, eachTraceObjPtr)
		}
		XTcl_SetObjResult(tls, interp, resultListPtr)
		break
	}
	return TCL_OK
}

var _opStrings2 = [5]uintptr{
	0: __ccgo_ts + 28190,
	1: __ccgo_ts + 5552,
	2: __ccgo_ts + 3450,
	3: __ccgo_ts + 44159,
	4: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_CommandTraceInfo --
 *
 *	Return the clientData value associated with a trace on a command.
 *	This function can also be used to step through all of the traces on a
 *	particular command that have the same trace function.
 *
 * Results:
 *	The return value is the clientData value associated with a trace on
 *	the given command. Information will only be returned for a trace with
 *	proc as trace function. If the clientData argument is NULL then the
 *	first such trace is returned; otherwise, the next relevant one after
 *	the one given by clientData will be returned. If the command doesn't
 *	exist then an error message is left in the interpreter and NULL is
 *	returned. Also, if there are no (more) traces for the given command,
 *	NULL is returned.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_CommandTraceInfo(tls *libc.TLS, interp uintptr, cmdName uintptr, dummy914 int32, proc uintptr, prevClientData uintptr) (r uintptr) {
	/* If non-NULL, gives last value returned by
	 * this function, so this call will return the
	 * next trace after that one. If NULL, this
	 * call will return the first trace. */
	var cmdPtr, tracePtr uintptr
	_, _ = cmdPtr, tracePtr
	cmdPtr = XTcl_FindCommand(tls, interp, cmdName, libc.UintptrFromInt32(0), int32(TCL_LEAVE_ERR_MSG))
	if cmdPtr == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	/*
	 * Find the relevant trace, if any, and return its clientData.
	 */
	tracePtr = (*TCommand)(unsafe.Pointer(cmdPtr)).FtracePtr
	if prevClientData != libc.UintptrFromInt32(0) {
		for {
			if !(tracePtr != libc.UintptrFromInt32(0)) {
				break
			}
			if (*TCommandTrace)(unsafe.Pointer(tracePtr)).FclientData == prevClientData && (*TCommandTrace)(unsafe.Pointer(tracePtr)).FtraceProc == proc {
				tracePtr = (*TCommandTrace)(unsafe.Pointer(tracePtr)).FnextPtr
				break
			}
			goto _1
		_1:
			;
			tracePtr = (*TCommandTrace)(unsafe.Pointer(tracePtr)).FnextPtr
		}
	}
	for {
		if !(tracePtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TCommandTrace)(unsafe.Pointer(tracePtr)).FtraceProc == proc {
			return (*TCommandTrace)(unsafe.Pointer(tracePtr)).FclientData
		}
		goto _2
	_2:
		;
		tracePtr = (*TCommandTrace)(unsafe.Pointer(tracePtr)).FnextPtr
	}
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_TraceCommand --
 *
 *	Arrange for rename/deletes to a command to cause a function to be
 *	invoked, which can monitor the operations.
 *
 *	Also optionally arrange for execution of that command to cause a
 *	function to be invoked.
 *
 * Results:
 *	A standard Tcl return value.
 *
 * Side effects:
 *	A trace is set up on the command given by cmdName, such that future
 *	changes to the command will be mediated by proc. See the manual
 *	entry for complete details on the calling sequence for proc.
 *
 *----------------------------------------------------------------------
 */

func XTcl_TraceCommand(tls *libc.TLS, interp uintptr, cmdName uintptr, flags int32, proc uintptr, clientData uintptr) (r int32) {
	/* Arbitrary argument to pass to proc. */
	var cmdPtr, iPtr, tracePtr uintptr
	_, _, _ = cmdPtr, iPtr, tracePtr
	cmdPtr = XTcl_FindCommand(tls, interp, cmdName, libc.UintptrFromInt32(0), int32(TCL_LEAVE_ERR_MSG))
	if cmdPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Set up trace information.
	 */
	tracePtr = XTcl_Alloc(tls, uint64(40))
	(*TCommandTrace)(unsafe.Pointer(tracePtr)).FtraceProc = proc
	(*TCommandTrace)(unsafe.Pointer(tracePtr)).FclientData = clientData
	(*TCommandTrace)(unsafe.Pointer(tracePtr)).Fflags = flags & (libc.Int32FromInt32(TCL_TRACE_RENAME) | libc.Int32FromInt32(TCL_TRACE_DELETE) | libc.Int32FromInt32(TCL_TRACE_ANY_EXEC))
	(*TCommandTrace)(unsafe.Pointer(tracePtr)).FnextPtr = (*TCommand)(unsafe.Pointer(cmdPtr)).FtracePtr
	(*TCommandTrace)(unsafe.Pointer(tracePtr)).FrefCount = int64(1)
	(*TCommand)(unsafe.Pointer(cmdPtr)).FtracePtr = tracePtr
	if (*TCommandTrace)(unsafe.Pointer(tracePtr)).Fflags&int32(TCL_TRACE_ANY_EXEC) != 0 {
		/*
		 * Bug 3484621: up the interp's epoch if this is a BC'ed command
		 */
		if (*TCommand)(unsafe.Pointer(cmdPtr)).FcompileProc != libc.UintptrFromInt32(0) && !((*TCommand)(unsafe.Pointer(cmdPtr)).Fflags&libc.Int32FromInt32(CMD_HAS_EXEC_TRACES) != 0) {
			iPtr = interp
			(*TInterp)(unsafe.Pointer(iPtr)).FcompileEpoch++
		}
		*(*int32)(unsafe.Pointer(cmdPtr + 88)) |= int32(CMD_HAS_EXEC_TRACES)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UntraceCommand --
 *
 *	Remove a previously-created trace for a command.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	If there exists a trace for the command given by cmdName with the
 *	given flags, proc, and clientData, then that trace is removed.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UntraceCommand(tls *libc.TLS, interp uintptr, cmdName uintptr, flags int32, proc uintptr, clientData uintptr) {
	/* Arbitrary argument to pass to proc. */
	var activePtr, cmdPtr, iPtr, prevPtr, tracePtr, v4 uintptr
	var hasExecTraces int32
	var v3 TTcl_Size
	_, _, _, _, _, _, _, _ = activePtr, cmdPtr, hasExecTraces, iPtr, prevPtr, tracePtr, v3, v4
	iPtr = interp
	hasExecTraces = 0
	cmdPtr = XTcl_FindCommand(tls, interp, cmdName, libc.UintptrFromInt32(0), int32(TCL_LEAVE_ERR_MSG))
	if cmdPtr == libc.UintptrFromInt32(0) {
		return
	}
	flags &= libc.Int32FromInt32(TCL_TRACE_RENAME) | libc.Int32FromInt32(TCL_TRACE_DELETE) | libc.Int32FromInt32(TCL_TRACE_ANY_EXEC)
	tracePtr = (*TCommand)(unsafe.Pointer(cmdPtr)).FtracePtr
	prevPtr = libc.UintptrFromInt32(0)
	for {
		if tracePtr == libc.UintptrFromInt32(0) {
			return
		}
		if (*TCommandTrace)(unsafe.Pointer(tracePtr)).FtraceProc == proc && (*TCommandTrace)(unsafe.Pointer(tracePtr)).Fflags&(libc.Int32FromInt32(TCL_TRACE_RENAME)|libc.Int32FromInt32(TCL_TRACE_DELETE)|libc.Int32FromInt32(TCL_TRACE_ANY_EXEC)) == flags && (*TCommandTrace)(unsafe.Pointer(tracePtr)).FclientData == clientData {
			if (*TCommandTrace)(unsafe.Pointer(tracePtr)).Fflags&int32(TCL_TRACE_ANY_EXEC) != 0 {
				hasExecTraces = int32(1)
			}
			break
		}
		goto _1
	_1:
		;
		prevPtr = tracePtr
		tracePtr = (*TCommandTrace)(unsafe.Pointer(tracePtr)).FnextPtr
	}
	/*
	 * The code below makes it possible to delete traces while traces are
	 * active: it makes sure that the deleted trace won't be processed by
	 * CallCommandTraces.
	 */
	activePtr = (*TInterp)(unsafe.Pointer(iPtr)).FactiveCmdTracePtr
	for {
		if !(activePtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TActiveCommandTrace)(unsafe.Pointer(activePtr)).FnextTracePtr == tracePtr {
			if (*TActiveCommandTrace)(unsafe.Pointer(activePtr)).FreverseScan != 0 {
				(*TActiveCommandTrace)(unsafe.Pointer(activePtr)).FnextTracePtr = prevPtr
			} else {
				(*TActiveCommandTrace)(unsafe.Pointer(activePtr)).FnextTracePtr = (*TCommandTrace)(unsafe.Pointer(tracePtr)).FnextPtr
			}
		}
		goto _2
	_2:
		;
		activePtr = (*TActiveCommandTrace)(unsafe.Pointer(activePtr)).FnextPtr
	}
	if prevPtr == libc.UintptrFromInt32(0) {
		(*TCommand)(unsafe.Pointer(cmdPtr)).FtracePtr = (*TCommandTrace)(unsafe.Pointer(tracePtr)).FnextPtr
	} else {
		(*TCommandTrace)(unsafe.Pointer(prevPtr)).FnextPtr = (*TCommandTrace)(unsafe.Pointer(tracePtr)).FnextPtr
	}
	(*TCommandTrace)(unsafe.Pointer(tracePtr)).Fflags = 0
	v4 = tracePtr + 32
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	if v3 <= int64(1) {
		XTclpFree(tls, tracePtr)
	}
	if hasExecTraces != 0 {
		tracePtr = (*TCommand)(unsafe.Pointer(cmdPtr)).FtracePtr
		prevPtr = libc.UintptrFromInt32(0)
		for {
			if !(tracePtr != libc.UintptrFromInt32(0)) {
				break
			}
			if (*TCommandTrace)(unsafe.Pointer(tracePtr)).Fflags&int32(TCL_TRACE_ANY_EXEC) != 0 {
				return
			}
			goto _5
		_5:
			;
			prevPtr = tracePtr
			tracePtr = (*TCommandTrace)(unsafe.Pointer(tracePtr)).FnextPtr
		}
		/*
		 * None of the remaining traces on this command are execution traces.
		 * We therefore remove this flag:
		 */
		*(*int32)(unsafe.Pointer(cmdPtr + 88)) &= ^libc.Int32FromInt32(CMD_HAS_EXEC_TRACES)
		/*
		 * Bug 3484621: up the interp's epoch if this is a BC'ed command
		 */
		if (*TCommand)(unsafe.Pointer(cmdPtr)).FcompileProc != libc.UintptrFromInt32(0) {
			(*TInterp)(unsafe.Pointer(iPtr)).FcompileEpoch++
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TraceCommandProc --
 *
 *	This function is called to handle command changes that have been
 *	traced using the "trace" command, when using the 'rename' or 'delete'
 *	options.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Depends on the command associated with the trace.
 *
 *----------------------------------------------------------------------
 */

func _TraceCommandProc(tls *libc.TLS, clientData uintptr, interp uintptr, oldName uintptr, newName uintptr, flags int32) {
	bp := tls.Alloc(224)
	defer tls.Free(224) /* OR-ed bits giving operation and other
	 * information. */
	var code, untraceFlags int32
	var state TTcl_InterpState
	var tcmdPtr, v1, v3 uintptr
	var v2 Tsize_t
	var _ /* cmd at bp+0 */ TTcl_DString
	_, _, _, _, _, _, _ = code, state, tcmdPtr, untraceFlags, v1, v2, v3
	tcmdPtr = clientData
	(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FrefCount++
	if (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).Fflags&flags != 0 && !(XTcl_InterpDeleted(tls, interp) != 0) && !(XTcl_LimitExceeded(tls, interp) != 0) {
		/*
		 * Generate a command to execute by appending list elements for the
		 * old and new command name and the operation.
		 */
		XTcl_DStringInit(tls, bp)
		XTcl_DStringAppend(tls, bp, tcmdPtr+56, (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).Flength)
		XTcl_DStringAppendElement(tls, bp, oldName)
		if newName != 0 {
			v1 = newName
		} else {
			v1 = __ccgo_ts + 1945
		}
		XTcl_DStringAppendElement(tls, bp, v1)
		if flags&int32(TCL_TRACE_RENAME) != 0 {
			XTcl_DStringAppend(tls, bp, __ccgo_ts+67967, libc.Int64FromUint64(libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)))
		} else {
			if flags&int32(TCL_TRACE_DELETE) != 0 {
				XTcl_DStringAppend(tls, bp, __ccgo_ts+67975, libc.Int64FromUint64(libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)))
			}
		}
		/*
		 * Execute the command. We discard any object result the command
		 * returns.
		 *
		 * Add the TCL_TRACE_DESTROYED flag to tcmdPtr to indicate to other
		 * areas that this will be destroyed by us, otherwise a double-free
		 * might occur depending on what the eval does.
		 */
		if flags&int32(TCL_TRACE_DESTROYED) != 0 {
			*(*int32)(unsafe.Pointer(tcmdPtr)) |= int32(TCL_TRACE_DESTROYED)
		}
		code = XTcl_EvalEx(tls, interp, (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1, (*TTcl_DString)(unsafe.Pointer(bp)).Flength, 0)
		if code != TCL_OK {
			/* We ignore errors in these traced commands */
			/*** QUESTION: Use Tcl_BackgroundException(interp, code); instead? ***/
		}
		XTcl_DStringFree(tls, bp)
	}
	/*
	 * We delete when the trace was destroyed or if this is a delete trace,
	 * because command deletes are unconditional, so the trace must go away.
	 */
	if flags&(libc.Int32FromInt32(TCL_TRACE_DESTROYED)|libc.Int32FromInt32(TCL_TRACE_DELETE)) != 0 {
		untraceFlags = (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).Fflags
		if (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FstepTrace != libc.UintptrFromInt32(0) {
			XTcl_DeleteTrace(tls, interp, (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FstepTrace)
			(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FstepTrace = libc.UintptrFromInt32(0)
			XTclpFree(tls, (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FstartCmd)
		}
		if (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).Fflags&int32(TCL_TRACE_EXEC_IN_PROGRESS) != 0 {
			/*
			 * Postpone deletion, until exec trace returns.
			 */
			(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).Fflags = 0
		}
		/*
		 * We need to construct the same flags for Tcl_UntraceCommand as were
		 * passed to Tcl_TraceCommand. Reproduce the processing of [trace add
		 * execution/command]. Be careful to keep this code in sync with that.
		 */
		if untraceFlags&int32(TCL_TRACE_ANY_EXEC) != 0 {
			untraceFlags |= int32(TCL_TRACE_DELETE)
			if untraceFlags&(libc.Int32FromInt32(TCL_TRACE_ENTER_DURING_EXEC)|libc.Int32FromInt32(TCL_TRACE_LEAVE_DURING_EXEC)) != 0 {
				untraceFlags |= libc.Int32FromInt32(TCL_TRACE_ENTER_EXEC) | libc.Int32FromInt32(TCL_TRACE_LEAVE_EXEC)
			}
		} else {
			if untraceFlags&int32(TCL_TRACE_RENAME) != 0 {
				untraceFlags |= int32(TCL_TRACE_DELETE)
			}
		}
		/*
		 * Remove the trace since TCL_TRACE_DESTROYED tells us to, or the
		 * command we're tracing has just gone away. Then decrement the
		 * clientData refCount that was set up by trace creation.
		 *
		 * Note that we save the (return) state of the interpreter to prevent
		 * bizarre error messages.
		 */
		state = XTcl_SaveInterpState(tls, interp, TCL_OK)
		XTcl_UntraceCommand(tls, interp, oldName, untraceFlags, __ccgo_fp(_TraceCommandProc), clientData)
		XTcl_RestoreInterpState(tls, interp, state)
		(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FrefCount--
	}
	v3 = tcmdPtr + 48
	v2 = *(*Tsize_t)(unsafe.Pointer(v3))
	*(*Tsize_t)(unsafe.Pointer(v3))--
	if v2 <= uint64(1) {
		XTclpFree(tls, tcmdPtr)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclCheckExecutionTraces --
 *
 *	Checks on all current command execution traces, and invokes functions
 *	which have been registered. This function can be used by other code
 *	which performs execution to unify the tracing system, so that
 *	execution traces will function for that other code.
 *
 *	For instance extensions like [incr Tcl] which use their own execution
 *	technique can make use of Tcl's tracing.
 *
 *	This function is called by 'TclEvalObjvInternal'
 *
 * Results:
 *	The return value is a standard Tcl completion code such as TCL_OK or
 *	TCL_ERROR, etc.
 *
 * Side effects:
 *	Those side effects made by any trace functions called.
 *
 *----------------------------------------------------------------------
 */

func XTclCheckExecutionTraces(tls *libc.TLS, interp uintptr, command uintptr, dummy1293 TTcl_Size, cmdPtr uintptr, code int32, traceFlags int32, objc TTcl_Size, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Pointers to Tcl_Obj of each argument. */
	var curLevel TTcl_Size
	var iPtr, lastTracePtr, tcmdPtr, tracePtr, v3 uintptr
	var state TTcl_InterpState
	var traceCode int32
	var v2 Tsize_t
	var _ /* active at bp+0 */ TActiveCommandTrace
	_, _, _, _, _, _, _, _, _ = curLevel, iPtr, lastTracePtr, state, tcmdPtr, traceCode, tracePtr, v2, v3
	iPtr = interp
	traceCode = TCL_OK
	state = libc.UintptrFromInt32(0)
	if (*TCommand)(unsafe.Pointer(cmdPtr)).FtracePtr == libc.UintptrFromInt32(0) {
		return traceCode
	}
	curLevel = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).Flevel
	(*(*TActiveCommandTrace)(unsafe.Pointer(bp))).FnextPtr = (*TInterp)(unsafe.Pointer(iPtr)).FactiveCmdTracePtr
	(*TInterp)(unsafe.Pointer(iPtr)).FactiveCmdTracePtr = bp
	(*(*TActiveCommandTrace)(unsafe.Pointer(bp))).FcmdPtr = cmdPtr
	lastTracePtr = libc.UintptrFromInt32(0)
	tracePtr = (*TCommand)(unsafe.Pointer(cmdPtr)).FtracePtr
	for {
		if !(traceCode == TCL_OK && tracePtr != libc.UintptrFromInt32(0)) {
			break
		}
		if traceFlags&int32(TCL_TRACE_LEAVE_EXEC) != 0 {
			/*
			 * Execute the trace command in order of creation for "leave".
			 */
			(*(*TActiveCommandTrace)(unsafe.Pointer(bp))).FreverseScan = int32(1)
			(*(*TActiveCommandTrace)(unsafe.Pointer(bp))).FnextTracePtr = libc.UintptrFromInt32(0)
			tracePtr = (*TCommand)(unsafe.Pointer(cmdPtr)).FtracePtr
			for (*TCommandTrace)(unsafe.Pointer(tracePtr)).FnextPtr != lastTracePtr {
				(*(*TActiveCommandTrace)(unsafe.Pointer(bp))).FnextTracePtr = tracePtr
				tracePtr = (*TCommandTrace)(unsafe.Pointer(tracePtr)).FnextPtr
			}
		} else {
			(*(*TActiveCommandTrace)(unsafe.Pointer(bp))).FreverseScan = 0
			(*(*TActiveCommandTrace)(unsafe.Pointer(bp))).FnextTracePtr = (*TCommandTrace)(unsafe.Pointer(tracePtr)).FnextPtr
		}
		if (*TCommandTrace)(unsafe.Pointer(tracePtr)).FtraceProc == __ccgo_fp(_TraceCommandProc) {
			tcmdPtr = (*TCommandTrace)(unsafe.Pointer(tracePtr)).FclientData
			if (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).Fflags != 0 {
				(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FcurFlags = traceFlags | int32(TCL_TRACE_EXEC_DIRECT)
				(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FcurCode = code
				(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FrefCount++
				if state == libc.UintptrFromInt32(0) {
					state = XTcl_SaveInterpState(tls, interp, code)
				}
				traceCode = _TraceExecutionProc(tls, tcmdPtr, interp, curLevel, command, cmdPtr, objc, objv)
				v3 = tcmdPtr + 48
				v2 = *(*Tsize_t)(unsafe.Pointer(v3))
				*(*Tsize_t)(unsafe.Pointer(v3))--
				if v2 <= uint64(1) {
					XTclpFree(tls, tcmdPtr)
				}
			}
		}
		if (*(*TActiveCommandTrace)(unsafe.Pointer(bp))).FnextTracePtr != 0 {
			lastTracePtr = (*TCommandTrace)(unsafe.Pointer((*(*TActiveCommandTrace)(unsafe.Pointer(bp))).FnextTracePtr)).FnextPtr
		}
		goto _1
	_1:
		;
		tracePtr = (*(*TActiveCommandTrace)(unsafe.Pointer(bp))).FnextTracePtr
	}
	(*TInterp)(unsafe.Pointer(iPtr)).FactiveCmdTracePtr = (*(*TActiveCommandTrace)(unsafe.Pointer(bp))).FnextPtr
	if state != 0 {
		if traceCode == TCL_OK {
			XTcl_RestoreInterpState(tls, interp, state)
		} else {
			XTcl_DiscardInterpState(tls, state)
		}
	}
	return traceCode
}

/*
 *----------------------------------------------------------------------
 *
 * TclCheckInterpTraces --
 *
 *	Checks on all current traces, and invokes functions which have been
 *	registered. This function can be used by other code which performs
 *	execution to unify the tracing system. For instance extensions like
 *	[incr Tcl] which use their own execution technique can make use of
 *	Tcl's tracing.
 *
 *	This function is called by 'TclEvalObjvInternal'
 *
 * Results:
 *	The return value is a standard Tcl completion code such as TCL_OK or
 *	TCL_ERROR, etc.
 *
 * Side effects:
 *	Those side effects made by any trace functions called.
 *
 *----------------------------------------------------------------------
 */

func XTclCheckInterpTraces(tls *libc.TLS, interp uintptr, command uintptr, numChars TTcl_Size, cmdPtr uintptr, code int32, traceFlags int32, objc TTcl_Size, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Pointers to Tcl_Obj of each argument. */
	var curLevel TTcl_Size
	var iPtr, lastTracePtr, tcmdPtr, tracePtr uintptr
	var state TTcl_InterpState
	var traceCode int32
	var _ /* active at bp+0 */ TActiveInterpTrace
	_, _, _, _, _, _, _ = curLevel, iPtr, lastTracePtr, state, tcmdPtr, traceCode, tracePtr
	iPtr = interp
	traceCode = TCL_OK
	state = libc.UintptrFromInt32(0)
	if (*TInterp)(unsafe.Pointer(iPtr)).FtracePtr == libc.UintptrFromInt32(0) || (*TInterp)(unsafe.Pointer(iPtr)).Fflags&int32(INTERP_TRACE_IN_PROGRESS) != 0 {
		return traceCode
	}
	curLevel = (*TInterp)(unsafe.Pointer(iPtr)).FnumLevels
	(*(*TActiveInterpTrace)(unsafe.Pointer(bp))).FnextPtr = (*TInterp)(unsafe.Pointer(iPtr)).FactiveInterpTracePtr
	(*TInterp)(unsafe.Pointer(iPtr)).FactiveInterpTracePtr = bp
	lastTracePtr = libc.UintptrFromInt32(0)
	tracePtr = (*TInterp)(unsafe.Pointer(iPtr)).FtracePtr
	for {
		if !(traceCode == TCL_OK && tracePtr != libc.UintptrFromInt32(0)) {
			break
		}
		if traceFlags&int32(TCL_TRACE_ENTER_EXEC) != 0 {
			/*
			 * Execute the trace command in reverse order of creation for
			 * "enterstep" operation. The order is changed for "enterstep"
			 * instead of for "leavestep" as was done in
			 * TclCheckExecutionTraces because for step traces,
			 * Tcl_CreateObjTrace creates one more linked list of traces which
			 * results in one more reversal of trace invocation.
			 */
			(*(*TActiveInterpTrace)(unsafe.Pointer(bp))).FreverseScan = int32(1)
			(*(*TActiveInterpTrace)(unsafe.Pointer(bp))).FnextTracePtr = libc.UintptrFromInt32(0)
			tracePtr = (*TInterp)(unsafe.Pointer(iPtr)).FtracePtr
			for (*TTrace)(unsafe.Pointer(tracePtr)).FnextPtr != lastTracePtr {
				(*(*TActiveInterpTrace)(unsafe.Pointer(bp))).FnextTracePtr = tracePtr
				tracePtr = (*TTrace)(unsafe.Pointer(tracePtr)).FnextPtr
			}
			if (*(*TActiveInterpTrace)(unsafe.Pointer(bp))).FnextTracePtr != 0 {
				lastTracePtr = (*TTrace)(unsafe.Pointer((*(*TActiveInterpTrace)(unsafe.Pointer(bp))).FnextTracePtr)).FnextPtr
			}
		} else {
			(*(*TActiveInterpTrace)(unsafe.Pointer(bp))).FreverseScan = 0
			(*(*TActiveInterpTrace)(unsafe.Pointer(bp))).FnextTracePtr = (*TTrace)(unsafe.Pointer(tracePtr)).FnextPtr
		}
		if (*TTrace)(unsafe.Pointer(tracePtr)).Flevel > 0 && curLevel > (*TTrace)(unsafe.Pointer(tracePtr)).Flevel {
			goto _1
		}
		if !((*TTrace)(unsafe.Pointer(tracePtr)).Fflags&libc.Int32FromInt32(TCL_TRACE_EXEC_IN_PROGRESS) != 0) {
			/*
			 * The proc invoked might delete the traced command which
			 * might try to free tracePtr. We want to use tracePtr until the
			 * end of this if section, so we use Tcl_Preserve() and
			 * Tcl_Release() to be sure it is not freed while we still need
			 * it.
			 */
			XTcl_Preserve(tls, tracePtr)
			*(*int32)(unsafe.Pointer(tracePtr + 32)) |= int32(TCL_TRACE_EXEC_IN_PROGRESS)
			if state == libc.UintptrFromInt32(0) {
				state = XTcl_SaveInterpState(tls, interp, code)
			}
			if (*TTrace)(unsafe.Pointer(tracePtr)).Fflags&(libc.Int32FromInt32(TCL_TRACE_ENTER_EXEC)|libc.Int32FromInt32(TCL_TRACE_LEAVE_EXEC)) != 0 {
				/*
				 * New style trace.
				 */
				if (*TTrace)(unsafe.Pointer(tracePtr)).Fflags&traceFlags != 0 {
					if (*TTrace)(unsafe.Pointer(tracePtr)).Fproc == __ccgo_fp(_TraceExecutionProc) {
						tcmdPtr = (*TTrace)(unsafe.Pointer(tracePtr)).FclientData
						(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FcurFlags = traceFlags
						(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FcurCode = code
					}
					traceCode = (*(*func(*libc.TLS, uintptr, uintptr, TTcl_Size, uintptr, TTcl_Command, TTcl_Size, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTrace)(unsafe.Pointer(tracePtr)).Fproc})))(tls, (*TTrace)(unsafe.Pointer(tracePtr)).FclientData, interp, curLevel, command, cmdPtr, objc, objv)
				}
			} else {
				/*
				 * Old-style trace.
				 */
				if traceFlags&int32(TCL_TRACE_ENTER_EXEC) != 0 {
					/*
					 * Old-style interpreter-wide traces only trigger before
					 * the command is executed.
					 */
					traceCode = _CallTraceFunction(tls, interp, tracePtr, cmdPtr, command, numChars, objc, objv)
				}
			}
			*(*int32)(unsafe.Pointer(tracePtr + 32)) &= ^libc.Int32FromInt32(TCL_TRACE_EXEC_IN_PROGRESS)
			XTcl_Release(tls, tracePtr)
		}
		goto _1
	_1:
		;
		tracePtr = (*(*TActiveInterpTrace)(unsafe.Pointer(bp))).FnextTracePtr
	}
	(*TInterp)(unsafe.Pointer(iPtr)).FactiveInterpTracePtr = (*(*TActiveInterpTrace)(unsafe.Pointer(bp))).FnextPtr
	if state != 0 {
		if traceCode == TCL_OK {
			XTcl_RestoreInterpState(tls, interp, state)
		} else {
			XTcl_DiscardInterpState(tls, state)
		}
	}
	return traceCode
}

/*
 *----------------------------------------------------------------------
 *
 * CallTraceFunction --
 *
 *	Invokes a trace function registered with an interpreter. These
 *	functions trace command execution. Currently this trace function is
 *	called with the address of the string-based Tcl_CmdProc for the
 *	command, not the Tcl_ObjCmdProc.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Those side effects made by the trace function.
 *
 *----------------------------------------------------------------------
 */

func _CallTraceFunction(tls *libc.TLS, interp uintptr, tracePtr uintptr, cmdPtr uintptr, command uintptr, numChars TTcl_Size, objc TTcl_Size, objv uintptr) (r int32) {
	/* Pointers to Tcl_Obj of each argument. */
	var commandCopy, iPtr uintptr
	var traceCode int32
	_, _, _ = commandCopy, iPtr, traceCode
	iPtr = interp
	/*
	 * Copy the command characters into a new string.
	 */
	commandCopy = XTclStackAlloc(tls, interp, libc.Uint64FromInt64(numChars+int64(1)))
	libc.Xmemcpy(tls, commandCopy, command, libc.Uint64FromInt64(numChars))
	*(*uint8)(unsafe.Pointer(commandCopy + uintptr(numChars))) = uint8('\000')
	/*
	 * Call the trace function then free allocated storage.
	 */
	traceCode = (*(*func(*libc.TLS, uintptr, uintptr, TTcl_Size, uintptr, TTcl_Command, TTcl_Size, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTrace)(unsafe.Pointer(tracePtr)).Fproc})))(tls, (*TTrace)(unsafe.Pointer(tracePtr)).FclientData, iPtr, (*TInterp)(unsafe.Pointer(iPtr)).FnumLevels, commandCopy, cmdPtr, objc, objv)
	XTclStackFree(tls, interp, commandCopy)
	return traceCode
}

/*
 *----------------------------------------------------------------------
 *
 * CommandObjTraceDeleted --
 *
 *	Ensure the trace is correctly deleted by decrementing its refCount and
 *	only deleting if no other references exist.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	May release memory.
 *
 *----------------------------------------------------------------------
 */

func _CommandObjTraceDeleted(tls *libc.TLS, clientData uintptr) {
	var tcmdPtr, v2 uintptr
	var v1 Tsize_t
	_, _, _ = tcmdPtr, v1, v2
	tcmdPtr = clientData
	v2 = tcmdPtr + 48
	v1 = *(*Tsize_t)(unsafe.Pointer(v2))
	*(*Tsize_t)(unsafe.Pointer(v2))--
	if v1 <= uint64(1) {
		XTclpFree(tls, tcmdPtr)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TraceExecutionProc --
 *
 *	This function is invoked whenever code relevant to a 'trace execution'
 *	command is executed. It is called in one of two ways in Tcl's core:
 *
 *	(i) by the TclCheckExecutionTraces, when an execution trace has been
 *	triggered.
 *	(ii) by TclCheckInterpTraces, when a prior execution trace has created
 *	a trace of the internals of a procedure, passing in this function as
 *	the one to be called.
 *
 * Results:
 *	The return value is a standard Tcl completion code such as TCL_OK or
 *	TCL_ERROR, etc.
 *
 * Side effects:
 *	May invoke an arbitrary Tcl procedure, and may create or delete an
 *	interpreter-wide trace.
 *
 *----------------------------------------------------------------------
 */

func _TraceExecutionProc(tls *libc.TLS, clientData uintptr, interp uintptr, level TTcl_Size, command uintptr, dummy1632 TTcl_Command, objc TTcl_Size, objv uintptr) (r int32) {
	bp := tls.Alloc(448)
	defer tls.Free(448)
	var _objPtr, cachePtr, iPtr, resultCode, resultCodeStr, tcmdPtr, v2, v4, v6, v8 uintptr
	var call, code, flags, saveInterpFlags, traceCode int32
	var i, v5 TTcl_Size
	var len1 uint32
	var v3 bool
	var v7 Tsize_t
	var _ /* cmd at bp+0 */ TTcl_DString
	var _ /* sub at bp+224 */ TTcl_DString
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, call, code, flags, i, iPtr, len1, resultCode, resultCodeStr, saveInterpFlags, tcmdPtr, traceCode, v2, v3, v4, v5, v6, v7, v8
	call = 0
	iPtr = interp
	tcmdPtr = clientData
	flags = (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FcurFlags
	code = (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FcurCode
	traceCode = TCL_OK
	if (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).Fflags&int32(TCL_TRACE_EXEC_IN_PROGRESS) != 0 {
		/*
		 * Inside any kind of execution trace callback, we do not allow any
		 * further execution trace callbacks to be called for the same trace.
		 */
		return traceCode
	}
	if !(XTcl_InterpDeleted(tls, interp) != 0) && !(XTcl_LimitExceeded(tls, interp) != 0) {
		/*
		 * Check whether the current call is going to eval arbitrary Tcl code
		 * with a generated trace, or whether we are only going to setup
		 * interpreter-wide traces to implement the 'step' traces. This latter
		 * situation can happen if we create a command trace without either
		 * before or after operations, but with either of the step operations.
		 */
		if flags&int32(TCL_TRACE_EXEC_DIRECT) != 0 {
			call = flags & (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).Fflags & (libc.Int32FromInt32(TCL_TRACE_ENTER_EXEC) | libc.Int32FromInt32(TCL_TRACE_LEAVE_EXEC))
		} else {
			call = int32(1)
		}
		/*
		 * First, if we have returned back to the level at which we created an
		 * interpreter trace for enterstep and/or leavestep execution traces,
		 * we remove it here.
		 */
		if flags&int32(TCL_TRACE_LEAVE_EXEC) != 0 && (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FstepTrace != libc.UintptrFromInt32(0) && level == (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FstartLevel && libc.Xstrcmp(tls, command, (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FstartCmd) == 0 {
			XTcl_DeleteTrace(tls, interp, (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FstepTrace)
			(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FstepTrace = libc.UintptrFromInt32(0)
			XTclpFree(tls, (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FstartCmd)
		}
		/*
		 * Second, create the tcl callback, if required.
		 */
		if call != 0 {
			XTcl_DStringInit(tls, bp)
			XTcl_DStringAppend(tls, bp, tcmdPtr+56, (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).Flength)
			/*
			 * Append command with arguments.
			 */
			XTcl_DStringInit(tls, bp+224)
			i = 0
			for {
				if !(i < objc) {
					break
				}
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
					v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
				} else {
					v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
				}
				XTcl_DStringAppendElement(tls, bp+224, v2)
				goto _1
			_1:
				;
				i++
			}
			XTcl_DStringAppendElement(tls, bp, (*TTcl_DString)(unsafe.Pointer(bp+224)).Fstring1)
			XTcl_DStringFree(tls, bp+224)
			if flags&int32(TCL_TRACE_ENTER_EXEC) != 0 {
				/*
				 * Append trace operation.
				 */
				if flags&int32(TCL_TRACE_EXEC_DIRECT) != 0 {
					XTcl_DStringAppendElement(tls, bp, __ccgo_ts+67681)
				} else {
					XTcl_DStringAppendElement(tls, bp, __ccgo_ts+67693)
				}
			} else {
				if flags&int32(TCL_TRACE_LEAVE_EXEC) != 0 {
					/*
					 * Append result code.
					 */
					if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
						cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
						resultCode = XTclThreadAllocObj(tls)
					} else {
						resultCode = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(resultCode + 32))).Fptr1
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
					}
					(*TTcl_Obj)(unsafe.Pointer(resultCode)).FrefCount = 0
					(*TTcl_Obj)(unsafe.Pointer(resultCode)).Fbytes = libc.UintptrFromInt32(0)
					*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(resultCode)).FinternalRep)) = int64(code)
					(*TTcl_Obj)(unsafe.Pointer(resultCode)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
					if (*TTcl_Obj)(unsafe.Pointer(resultCode)).Fbytes != 0 {
						v4 = (*TTcl_Obj)(unsafe.Pointer(resultCode)).Fbytes
					} else {
						v4 = XTcl_GetStringFromObj(tls, resultCode, libc.UintptrFromInt32(0))
					}
					resultCodeStr = v4
					XTcl_DStringAppendElement(tls, bp, resultCodeStr)
					_objPtr = resultCode
					v6 = _objPtr
					v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
					*(*TTcl_Size)(unsafe.Pointer(v6))--
					if v5 <= int64(1) {
						XTclFreeObj(tls, _objPtr)
					}
					/*
					 * Append result string.
					 */
					XTcl_DStringAppendElement(tls, bp, XTcl_GetStringFromObj(tls, XTcl_GetObjResult(tls, interp), libc.UintptrFromInt32(0)))
					/*
					 * Append trace operation.
					 */
					if flags&int32(TCL_TRACE_EXEC_DIRECT) != 0 {
						XTcl_DStringAppendElement(tls, bp, __ccgo_ts+67687)
					} else {
						XTcl_DStringAppendElement(tls, bp, __ccgo_ts+67703)
					}
				} else {
					XTcl_Panic(tls, __ccgo_ts+67983, 0)
				}
			}
			/*
			 * Execute the command. We discard any object result the command
			 * returns.
			 */
			saveInterpFlags = (*TInterp)(unsafe.Pointer(iPtr)).Fflags
			*(*int32)(unsafe.Pointer(iPtr + 368)) |= int32(INTERP_TRACE_IN_PROGRESS)
			*(*int32)(unsafe.Pointer(tcmdPtr)) |= int32(TCL_TRACE_EXEC_IN_PROGRESS)
			(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FrefCount++
			/*
			 * This line can have quite arbitrary side-effects, including
			 * deleting the trace, the command being traced, or even the
			 * interpreter.
			 */
			traceCode = XTcl_EvalEx(tls, interp, (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1, (*TTcl_DString)(unsafe.Pointer(bp)).Flength, 0)
			*(*int32)(unsafe.Pointer(tcmdPtr)) &= ^libc.Int32FromInt32(TCL_TRACE_EXEC_IN_PROGRESS)
			/*
			 * Restore the interp tracing flag to prevent cmd traces from
			 * affecting interp traces.
			 */
			(*TInterp)(unsafe.Pointer(iPtr)).Fflags = saveInterpFlags
			if (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).Fflags == 0 {
				flags |= int32(TCL_TRACE_DESTROYED)
			}
			XTcl_DStringFree(tls, bp)
		}
		/*
		 * Third, if there are any step execution traces for this proc, we
		 * register an interpreter trace to invoke enterstep and/or leavestep
		 * traces. We also need to save the current stack level and the proc
		 * string in startLevel and startCmd so that we can delete this
		 * interpreter trace when it reaches the end of this proc.
		 */
		if flags&int32(TCL_TRACE_ENTER_EXEC) != 0 && (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FstepTrace == libc.UintptrFromInt32(0) && (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).Fflags&(libc.Int32FromInt32(TCL_TRACE_ENTER_DURING_EXEC)|libc.Int32FromInt32(TCL_TRACE_LEAVE_DURING_EXEC)) != 0 {
			len1 = uint32(libc.Xstrlen(tls, command) + uint64(1))
			(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FstartLevel = level
			(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FstartCmd = XTcl_Alloc(tls, uint64(len1))
			libc.Xmemcpy(tls, (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FstartCmd, command, uint64(len1))
			(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FrefCount++
			(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FstepTrace = XTcl_CreateObjTrace2(tls, interp, 0, (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).Fflags&int32(TCL_TRACE_ANY_EXEC)>>int32(2), __ccgo_fp(_TraceExecutionProc), tcmdPtr, __ccgo_fp(_CommandObjTraceDeleted))
		}
	}
	if flags&int32(TCL_TRACE_DESTROYED) != 0 {
		if (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FstepTrace != libc.UintptrFromInt32(0) {
			XTcl_DeleteTrace(tls, interp, (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FstepTrace)
			(*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FstepTrace = libc.UintptrFromInt32(0)
			XTclpFree(tls, (*TTraceCommandInfo)(unsafe.Pointer(tcmdPtr)).FstartCmd)
		}
	}
	if call != 0 {
		v8 = tcmdPtr + 48
		v7 = *(*Tsize_t)(unsafe.Pointer(v8))
		*(*Tsize_t)(unsafe.Pointer(v8))--
		if v7 <= uint64(1) {
			XTclpFree(tls, tcmdPtr)
		}
	}
	return traceCode
}

/*
 *----------------------------------------------------------------------
 *
 * TraceVarProc --
 *
 *	This function is called to handle variable accesses that have been
 *	traced using the "trace" command.
 *
 * Results:
 *	Normally returns NULL. If the trace command returns an error, then
 *	this function returns an error string.
 *
 * Side effects:
 *	Depends on the command associated with the trace.
 *
 *----------------------------------------------------------------------
 */

func _TraceVarProc(tls *libc.TLS, clientData uintptr, interp uintptr, name1 uintptr, name2 uintptr, flags int32) (r uintptr) {
	bp := tls.Alloc(224)
	defer tls.Free(224) /* OR-ed bits giving operation and other
	 * information. */
	var _objPtr, errMsgObj, errMsgObj1, result, tvarPtr, v1, v3 uintptr
	var code, destroy, rewind int32
	var v2 TTcl_Size
	var _ /* cmd at bp+0 */ TTcl_DString
	_, _, _, _, _, _, _, _, _, _, _ = _objPtr, code, destroy, errMsgObj, errMsgObj1, result, rewind, tvarPtr, v1, v2, v3
	tvarPtr = clientData
	destroy = 0
	rewind = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).Frewind
	/*
	 * We might call Tcl_EvalEx() below, and that might evaluate
	 * [trace remove variable] which might try to free tvarPtr. We want to
	 * use tvarPtr until the end of this function, so we use Tcl_Preserve()
	 * and Tcl_Release() to be sure it is not freed while we still need it.
	 */
	result = libc.UintptrFromInt32(0)
	if (*TTraceVarInfo)(unsafe.Pointer(tvarPtr)).Fflags&flags != 0 && !(XTcl_InterpDeleted(tls, interp) != 0) && !(XTcl_LimitExceeded(tls, interp) != 0) {
		if (*TTraceVarInfo)(unsafe.Pointer(tvarPtr)).Flength != 0 {
			/*
			 * Generate a command to execute by appending list elements for
			 * the two variable names and the operation.
			 */
			XTcl_DStringInit(tls, bp)
			XTcl_DStringAppend(tls, bp, tvarPtr+16, (*TTraceVarInfo)(unsafe.Pointer(tvarPtr)).Flength)
			XTcl_DStringAppendElement(tls, bp, name1)
			if name2 != 0 {
				v1 = name2
			} else {
				v1 = __ccgo_ts + 1945
			}
			XTcl_DStringAppendElement(tls, bp, v1)
			if flags&int32(TCL_TRACE_ARRAY) != 0 {
				XTcl_DStringAppend(tls, bp, __ccgo_ts+68024, libc.Int64FromUint64(libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1)))
			} else {
				if flags&int32(TCL_TRACE_READS) != 0 {
					XTcl_DStringAppend(tls, bp, __ccgo_ts+68031, libc.Int64FromUint64(libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)))
				} else {
					if flags&int32(TCL_TRACE_WRITES) != 0 {
						XTcl_DStringAppend(tls, bp, __ccgo_ts+68037, libc.Int64FromUint64(libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1)))
					} else {
						if flags&int32(TCL_TRACE_UNSETS) != 0 {
							XTcl_DStringAppend(tls, bp, __ccgo_ts+68044, libc.Int64FromUint64(libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1)))
						}
					}
				}
			}
			/*
			 * Execute the command. We discard any object result the command
			 * returns.
			 *
			 * Add the TCL_TRACE_DESTROYED flag to tvarPtr to indicate to
			 * other areas that this will be destroyed by us, otherwise a
			 * double-free might occur depending on what the eval does.
			 */
			if flags&int32(TCL_TRACE_DESTROYED) != 0 && !((*TTraceVarInfo)(unsafe.Pointer(tvarPtr)).Fflags&libc.Int32FromInt32(TCL_TRACE_DESTROYED) != 0) {
				destroy = int32(1)
				*(*int32)(unsafe.Pointer(tvarPtr)) |= int32(TCL_TRACE_DESTROYED)
			}
			/*
			 * Make sure that unset traces are rune even if the execEnv is
			 * rewinding (coroutine deletion, [Bug 2093947]
			 */
			if rewind != 0 && flags&int32(TCL_TRACE_UNSETS) != 0 {
				(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).Frewind = 0
			}
			code = XTcl_EvalEx(tls, interp, (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1, (*TTcl_DString)(unsafe.Pointer(bp)).Flength, 0)
			if rewind != 0 {
				(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).Frewind = rewind
			}
			if code != TCL_OK { /* copy error msg to result */
				errMsgObj = XTcl_GetObjResult(tls, interp)
				(*TTcl_Obj)(unsafe.Pointer(errMsgObj)).FrefCount++
				result = errMsgObj
			}
			XTcl_DStringFree(tls, bp)
		}
	}
	if destroy != 0 && result != libc.UintptrFromInt32(0) {
		errMsgObj1 = result
		_objPtr = errMsgObj1
		v3 = _objPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		result = libc.UintptrFromInt32(0)
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_CreateObjTrace/Tcl_CreateObjTrace2 --
 *
 *	Arrange for a function to be called to trace command execution.
 *
 * Results:
 *	The return value is a token for the trace, which may be passed to
 *	Tcl_DeleteTrace to eliminate the trace.
 *
 * Side effects:
 *	From now on, proc will be called just before a command function is
 *	called to execute a Tcl command. Calls to proc will have the following
 *	form:
 *
 *	void proc(void   *	 clientData,
 *		  Tcl_Interp *	 interp,
 *		  int		 level,
 *		  const char *	 command,
 *		  Tcl_Command	 commandInfo,
 *		  int		 objc,
 *		  Tcl_Obj *const objv[]);
 *
 *	The 'clientData' and 'interp' arguments to 'proc' will be the same as
 *	the arguments to Tcl_CreateObjTrace. The 'level' argument gives the
 *	nesting depth of command interpretation within the interpreter. The
 *	'command' argument is the ASCII text of the command being evaluated -
 *	before any substitutions are performed. The 'commandInfo' argument
 *	gives a handle to the command procedure that will be evaluated. The
 *	'objc' and 'objv' parameters give the parameter vector that will be
 *	passed to the command procedure. Proc does not return a value.
 *
 *	The 'level' argument specifies the maximum nesting level of calls to
 *	be traced. If the execution depth of the interpreter exceeds 'level',
 *	the trace callback is not executed.
 *
 *	The 'flags' argument is either zero or the value,
 *	TCL_ALLOW_INLINE_COMPILATION. If the TCL_ALLOW_INLINE_COMPILATION flag
 *	is not present, the bytecode compiler will not generate inline code
 *	for Tcl's built-in commands. This behavior will have a significant
 *	impact on performance, but will ensure that all command evaluations
 *	are traced. If the TCL_ALLOW_INLINE_COMPILATION flag is present, the
 *	bytecode compiler will have its normal behavior of compiling in-line
 *	code for some of Tcl's built-in commands. In this case, the tracing
 *	will be imprecise - in-line code will not be traced - but run-time
 *	performance will be improved. The latter behavior is desired for many
 *	applications such as profiling of run time.
 *
 *	When the trace is deleted, the 'delProc' function will be invoked,
 *	passing it the original client data.
 *
 *----------------------------------------------------------------------
 */

type TTraceWrapperInfo = struct {
	Fproc       uintptr
	FdelProc    uintptr
	FclientData uintptr
}

func _traceWrapperProc(tls *libc.TLS, clientData uintptr, interp uintptr, level TTcl_Size, command uintptr, commandInfo TTcl_Command, objc TTcl_Size, objv uintptr) (r int32) {
	var info uintptr
	_ = info
	info = clientData
	if objc > int64(INT_MAX) {
		objc = int64(-int32(1)) /* Signal Tcl_CmdObjTraceProc that objc is out of range */
	}
	return (*(*func(*libc.TLS, uintptr, uintptr, int32, uintptr, TTcl_Command, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTraceWrapperInfo)(unsafe.Pointer(info)).Fproc})))(tls, (*TTraceWrapperInfo)(unsafe.Pointer(info)).FclientData, interp, int32(level), command, commandInfo, int32(objc), objv)
}

func _traceWrapperDelProc(tls *libc.TLS, clientData uintptr) {
	var info uintptr
	_ = info
	info = clientData
	clientData = (*TTraceWrapperInfo)(unsafe.Pointer(info)).FclientData
	if (*TTraceWrapperInfo)(unsafe.Pointer(info)).FdelProc != 0 {
		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTraceWrapperInfo)(unsafe.Pointer(info)).FdelProc})))(tls, clientData)
	}
	XTclpFree(tls, info)
}

func XTcl_CreateObjTrace(tls *libc.TLS, interp uintptr, level TTcl_Size, flags int32, proc uintptr, clientData uintptr, delProc uintptr) (r TTcl_Trace) {
	/* Function to call when trace is deleted */
	var info, v1 uintptr
	_, _ = info, v1
	info = XTcl_Alloc(tls, uint64(24))
	(*TTraceWrapperInfo)(unsafe.Pointer(info)).Fproc = proc
	(*TTraceWrapperInfo)(unsafe.Pointer(info)).FdelProc = delProc
	(*TTraceWrapperInfo)(unsafe.Pointer(info)).FclientData = clientData
	if proc != 0 {
		v1 = __ccgo_fp(_traceWrapperProc)
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	return XTcl_CreateObjTrace2(tls, interp, level, flags, v1, info, __ccgo_fp(_traceWrapperDelProc))
}

func XTcl_CreateObjTrace2(tls *libc.TLS, interp uintptr, level TTcl_Size, flags int32, proc uintptr, clientData uintptr, delProc uintptr) (r TTcl_Trace) {
	/* Function to call when trace is deleted */
	var iPtr, tracePtr uintptr
	_, _ = iPtr, tracePtr
	iPtr = interp
	/*
	 * Test if this trace allows inline compilation of commands.
	 */
	if !(flags&libc.Int32FromInt32(TCL_ALLOW_INLINE_COMPILATION) != 0) {
		if (*TInterp)(unsafe.Pointer(iPtr)).FtracesForbiddingInline == 0 {
			/*
			 * When the first trace forbidding inline compilation is created,
			 * invalidate existing compiled code for this interpreter and
			 * arrange (by setting the DONT_COMPILE_CMDS_INLINE flag) that
			 * when compiling new code, no commands will be compiled inline
			 * (i.e., into an inline sequence of instructions). We do this
			 * because commands that were compiled inline will never result in
			 * a command trace being called.
			 */
			(*TInterp)(unsafe.Pointer(iPtr)).FcompileEpoch++
			*(*int32)(unsafe.Pointer(iPtr + 368)) |= int32(DONT_COMPILE_CMDS_INLINE)
		}
		(*TInterp)(unsafe.Pointer(iPtr)).FtracesForbiddingInline++
	}
	tracePtr = XTcl_Alloc(tls, uint64(48))
	(*TTrace)(unsafe.Pointer(tracePtr)).Flevel = level
	(*TTrace)(unsafe.Pointer(tracePtr)).Fproc = proc
	(*TTrace)(unsafe.Pointer(tracePtr)).FclientData = clientData
	(*TTrace)(unsafe.Pointer(tracePtr)).FdelProc = delProc
	(*TTrace)(unsafe.Pointer(tracePtr)).FnextPtr = (*TInterp)(unsafe.Pointer(iPtr)).FtracePtr
	(*TTrace)(unsafe.Pointer(tracePtr)).Fflags = flags
	(*TInterp)(unsafe.Pointer(iPtr)).FtracePtr = tracePtr
	return tracePtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_CreateTrace --
 *
 *	Arrange for a function to be called to trace command execution.
 *
 * Results:
 *	The return value is a token for the trace, which may be passed to
 *	Tcl_DeleteTrace to eliminate the trace.
 *
 * Side effects:
 *	From now on, proc will be called just before a command procedure is
 *	called to execute a Tcl command. Calls to proc will have the following
 *	form:
 *
 *	void
 *	proc(clientData, interp, level, command, cmdProc, cmdClientData,
 *		argc, argv)
 *	    void *clientData;
 *	    Tcl_Interp *interp;
 *	    int level;
 *	    char *command;
 *	    int (*cmdProc)();
 *	    void *cmdClientData;
 *	    int argc;
 *	    char **argv;
 *	{
 *	}
 *
 *	The clientData and interp arguments to proc will be the same as the
 *	corresponding arguments to this function. Level gives the nesting
 *	level of command interpretation for this interpreter (0 corresponds to
 *	top level). Command gives the ASCII text of the raw command, cmdProc
 *	and cmdClientData give the function that will be called to process the
 *	command and the ClientData value it will receive, and argc and argv
 *	give the arguments to the command, after any argument parsing and
 *	substitution. Proc does not return a value.
 *
 *----------------------------------------------------------------------
 */

func XTcl_CreateTrace(tls *libc.TLS, interp uintptr, level TTcl_Size, proc uintptr, clientData uintptr) (r TTcl_Trace) {
	/* Arbitrary value word to pass to proc. */
	var data uintptr
	_ = data
	data = XTcl_Alloc(tls, uint64(16))
	(*TStringTraceData)(unsafe.Pointer(data)).FclientData = clientData
	(*TStringTraceData)(unsafe.Pointer(data)).Fproc = proc
	return XTcl_CreateObjTrace2(tls, interp, level, 0, __ccgo_fp(_StringTraceProc), data, __ccgo_fp(_StringTraceDeleteProc))
}

/*
 *----------------------------------------------------------------------
 *
 * StringTraceProc --
 *
 *	Invoke a string-based trace function from an object-based callback.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Whatever the string-based trace function does.
 *
 *----------------------------------------------------------------------
 */

func _StringTraceProc(tls *libc.TLS, clientData uintptr, interp uintptr, level TTcl_Size, command uintptr, commandInfo TTcl_Command, objc TTcl_Size, objv uintptr) (r int32) {
	var argv, cmdPtr, data, v2 uintptr
	var i TTcl_Size
	_, _, _, _, _ = argv, cmdPtr, data, i, v2
	data = clientData
	cmdPtr = commandInfo
	/*
	 * This is a bit messy because we have to emulate the old trace interface,
	 * which uses strings for everything.
	 */
	argv = XTclStackAlloc(tls, interp, libc.Uint64FromInt64(objc+libc.Int64FromInt32(1))*uint64(8))
	i = 0
	for {
		if !(i < objc) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)) = v2
		goto _1
	_1:
		;
		i++
	}
	*(*uintptr)(unsafe.Pointer(argv + uintptr(objc)*8)) = uintptr(0)
	/*
	 * Invoke the command function. Note that we cast away const-ness on two
	 * parameters for compatibility with legacy code; the code MUST NOT modify
	 * either command or argv.
	 */
	(*(*func(*libc.TLS, uintptr, uintptr, int32, uintptr, uintptr, uintptr, int32, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TStringTraceData)(unsafe.Pointer(data)).Fproc})))(tls, (*TStringTraceData)(unsafe.Pointer(data)).FclientData, interp, int32(level), command, (*TCommand)(unsafe.Pointer(cmdPtr)).Fproc, (*TCommand)(unsafe.Pointer(cmdPtr)).FclientData, int32(objc), argv)
	XTclStackFree(tls, interp, argv)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * StringTraceDeleteProc --
 *
 *	Clean up memory when a string-based trace is deleted.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Allocated memory is returned to the system.
 *
 *----------------------------------------------------------------------
 */

func _StringTraceDeleteProc(tls *libc.TLS, clientData uintptr) {
	XTclpFree(tls, clientData)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DeleteTrace --
 *
 *	Remove a trace.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	From now on there will be no more calls to the function given in
 *	trace.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DeleteTrace(tls *libc.TLS, interp uintptr, trace TTcl_Trace) {
	/* Token for trace (returned previously by
	 * Tcl_CreateTrace). */
	var activePtr, iPtr, prevPtr, tracePtr, tracePtr2 uintptr
	_, _, _, _, _ = activePtr, iPtr, prevPtr, tracePtr, tracePtr2
	iPtr = interp
	tracePtr = trace
	tracePtr2 = iPtr + 384
	/*
	 * Locate the trace entry in the interpreter's trace list, and remove it
	 * from the list.
	 */
	prevPtr = libc.UintptrFromInt32(0)
	for *(*uintptr)(unsafe.Pointer(tracePtr2)) != libc.UintptrFromInt32(0) && *(*uintptr)(unsafe.Pointer(tracePtr2)) != tracePtr {
		prevPtr = *(*uintptr)(unsafe.Pointer(tracePtr2))
		tracePtr2 = prevPtr + 24
	}
	if *(*uintptr)(unsafe.Pointer(tracePtr2)) == libc.UintptrFromInt32(0) {
		return
	}
	*(*uintptr)(unsafe.Pointer(tracePtr2)) = (*TTrace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(tracePtr2)))).FnextPtr
	/*
	 * The code below makes it possible to delete traces while traces are
	 * active: it makes sure that the deleted trace won't be processed by
	 * TclCheckInterpTraces.
	 */
	activePtr = (*TInterp)(unsafe.Pointer(iPtr)).FactiveInterpTracePtr
	for {
		if !(activePtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TActiveInterpTrace)(unsafe.Pointer(activePtr)).FnextTracePtr == tracePtr {
			if (*TActiveInterpTrace)(unsafe.Pointer(activePtr)).FreverseScan != 0 {
				(*TActiveInterpTrace)(unsafe.Pointer(activePtr)).FnextTracePtr = prevPtr
			} else {
				(*TActiveInterpTrace)(unsafe.Pointer(activePtr)).FnextTracePtr = (*TTrace)(unsafe.Pointer(tracePtr)).FnextPtr
			}
		}
		goto _1
	_1:
		;
		activePtr = (*TActiveInterpTrace)(unsafe.Pointer(activePtr)).FnextPtr
	}
	/*
	 * If the trace forbids bytecode compilation, change the interpreter's
	 * state. If bytecode compilation is now permitted, flag the fact and
	 * advance the compilation epoch so that procs will be recompiled to take
	 * advantage of it.
	 */
	if !((*TTrace)(unsafe.Pointer(tracePtr)).Fflags&libc.Int32FromInt32(TCL_ALLOW_INLINE_COMPILATION) != 0) {
		(*TInterp)(unsafe.Pointer(iPtr)).FtracesForbiddingInline--
		if (*TInterp)(unsafe.Pointer(iPtr)).FtracesForbiddingInline == 0 {
			*(*int32)(unsafe.Pointer(iPtr + 368)) &= ^libc.Int32FromInt32(DONT_COMPILE_CMDS_INLINE)
			(*TInterp)(unsafe.Pointer(iPtr)).FcompileEpoch++
		}
	}
	/*
	 * Execute any delete callback.
	 */
	if (*TTrace)(unsafe.Pointer(tracePtr)).FdelProc != libc.UintptrFromInt32(0) {
		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTrace)(unsafe.Pointer(tracePtr)).FdelProc})))(tls, (*TTrace)(unsafe.Pointer(tracePtr)).FclientData)
	}
	/*
	 * Delete the trace object.
	 */
	XTcl_EventuallyFree(tls, tracePtr, libc.UintptrFromInt32(3))
}

/*
 *----------------------------------------------------------------------
 *
 * TclTraceVarExists --
 *
 *	This is called from info exists. We need to trigger read and/or array
 *	traces because they may end up creating a variable that doesn't
 *	currently exist.
 *
 * Results:
 *	A pointer to the Var structure, or NULL.
 *
 * Side effects:
 *	May fill in error messages in the interp.
 *
 *----------------------------------------------------------------------
 */

func XTclVarTraceExists(tls *libc.TLS, interp uintptr, varName uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The variable name */
	var varPtr uintptr
	var _ /* arrayPtr at bp+0 */ uintptr
	_ = varPtr
	/*
	 * The choice of "create" flag values is delicate here, and matches the
	 * semantics of GetVar. Things are still not perfect, however, because if
	 * you do "info exists x" you get a varPtr and therefore trigger traces.
	 * However, if you do "info exists x(i)", then you only get a varPtr if x
	 * is already known to be an array. Otherwise you get NULL, and no trace
	 * is triggered. This matches Tcl 7.6 semantics.
	 */
	varPtr = XTclLookupVar(tls, interp, varName, libc.UintptrFromInt32(0), 0, __ccgo_ts+32162, 0, int32(1), bp)
	if varPtr == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_TRACED_READ) != 0 || *(*uintptr)(unsafe.Pointer(bp)) != 0 && (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fflags&int32(VAR_TRACED_READ) != 0 {
		XTclCallVarTraces(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), varPtr, varName, libc.UintptrFromInt32(0), int32(TCL_TRACE_READS), 0)
	}
	/*
	 * If the variable doesn't exist anymore and no-one's using it, then free
	 * up the relevant structures and hash table entries.
	 */
	if *(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0) {
		XTclCleanupVar(tls, varPtr, *(*uintptr)(unsafe.Pointer(bp)))
		return libc.UintptrFromInt32(0)
	}
	return varPtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclCheckArrayTraces --
 *
 *	This function is invoked to when we operate on an array variable,
 *	to allow any array traces to fire.
 *
 * Results:
 *	Returns TCL_OK to indicate normal operation. Returns TCL_ERROR if
 *	invocation of a trace function indicated an error. When TCL_ERROR is
 *	returned, then error information is left in interp.
 *
 * Side effects:
 *	Almost anything can happen, depending on trace; this function itself
 *	doesn't have any side effects.
 *
 *----------------------------------------------------------------------
 */

func XTclCheckArrayTraces(tls *libc.TLS, interp uintptr, varPtr uintptr, arrayPtr uintptr, name uintptr, index int32) (r int32) {
	var code int32
	var iPtr uintptr
	_, _ = code, iPtr
	code = TCL_OK
	if varPtr != 0 && (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_TRACED_ARRAY) != 0 && ((*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_ARRAY) != 0 || *(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0)) {
		iPtr = interp
		code = XTclObjCallVarTraces(tls, iPtr, arrayPtr, varPtr, name, libc.UintptrFromInt32(0), libc.Int32FromInt32(TCL_NAMESPACE_ONLY)|libc.Int32FromInt32(TCL_GLOBAL_ONLY)|libc.Int32FromInt32(TCL_TRACE_ARRAY), int32(1), index)
	}
	return code
}

/*
 *----------------------------------------------------------------------
 *
 * TclCallVarTraces --
 *
 *	This function is invoked to find and invoke relevant trace functions
 *	associated with a particular operation on a variable. This function
 *	invokes traces both on the variable and on its containing array (where
 *	relevant).
 *
 * Results:
 *	Returns TCL_OK to indicate normal operation. Returns TCL_ERROR if
 *	invocation of a trace function indicated an error. When TCL_ERROR is
 *	returned and leaveErrMsg is true, then the errorInfo field of iPtr has
 *	information about the error placed in it.
 *
 * Side effects:
 *	Almost anything can happen, depending on trace; this function itself
 *	doesn't have any side effects.
 *
 *----------------------------------------------------------------------
 */

func XTclObjCallVarTraces(tls *libc.TLS, iPtr uintptr, arrayPtr uintptr, varPtr uintptr, part1Ptr uintptr, part2Ptr uintptr, flags int32, leaveErrMsg int32, index int32) (r int32) {
	/* Index into the local variable table of the
	 * variable, or -1. Only used when part1Ptr is
	 * NULL. */
	var part1, part2, v1, v2, v3 uintptr
	_, _, _, _, _ = part1, part2, v1, v2, v3
	if !(part1Ptr != 0) {
		part1Ptr = *(*uintptr)(unsafe.Pointer((*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FlocalCachePtr + 16 + uintptr(index)*8))
	}
	if !(part1Ptr != 0) {
		XTcl_Panic(tls, __ccgo_ts+68051, 0)
	}
	if (*TTcl_Obj)(unsafe.Pointer(part1Ptr)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(part1Ptr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, part1Ptr, libc.UintptrFromInt32(0))
	}
	part1 = v1
	if part2Ptr != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(part2Ptr)).Fbytes != 0 {
			v3 = (*TTcl_Obj)(unsafe.Pointer(part2Ptr)).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, part2Ptr, libc.UintptrFromInt32(0))
		}
		v2 = v3
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	part2 = v2
	return XTclCallVarTraces(tls, iPtr, arrayPtr, varPtr, part1, part2, flags, leaveErrMsg)
}

func XTclCallVarTraces(tls *libc.TLS, iPtr uintptr, arrayPtr uintptr, varPtr uintptr, part1 uintptr, part2 uintptr, flags int32, leaveErrMsg int32) (r int32) {
	bp := tls.Alloc(304)
	defer tls.Free(304) /* If true, and one of the traces indicates an
	 * error, then leave an error message and
	 * stack trace information in *iPTr. */
	var code, copiedName, disposeFlags, offset, traceflags int32
	var element, hPtr, keyObj, newPart1, openParen, p, result, tracePtr, type1, verb, v4, v5, v6, v7 uintptr
	var state TTcl_InterpState
	var _ /* active at bp+0 */ TActiveVarTrace
	var _ /* nameCopy at bp+24 */ TTcl_DString
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = code, copiedName, disposeFlags, element, hPtr, keyObj, newPart1, offset, openParen, p, result, state, tracePtr, traceflags, type1, verb, v4, v5, v6, v7
	code = TCL_OK
	disposeFlags = 0
	state = libc.UintptrFromInt32(0)
	traceflags = flags & (libc.Int32FromInt32(VAR_TRACED_READ) | libc.Int32FromInt32(VAR_TRACED_WRITE) | libc.Int32FromInt32(VAR_TRACED_ARRAY) | libc.Int32FromInt32(VAR_TRACED_UNSET))
	/*
	 * If there are already similar trace functions active for the variable,
	 * don't call them again.
	 */
	if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_TRACE_ACTIVE) != 0 {
		return code
	}
	*(*int32)(unsafe.Pointer(varPtr)) |= int32(VAR_TRACE_ACTIVE)
	if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
		(*TVarInHash)(unsafe.Pointer(varPtr)).FrefCount++
	}
	if arrayPtr != 0 && (*TVar)(unsafe.Pointer(arrayPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
		(*TVarInHash)(unsafe.Pointer(arrayPtr)).FrefCount++
	}
	/*
	 * If the variable name hasn't been parsed into array name and element, do
	 * it here. If there really is an array element, make a copy of the
	 * original name so that NULLs can be inserted into it to separate the
	 * names (can't modify the name string in place, because the string might
	 * get used by the callbacks we invoke).
	 */
	copiedName = 0
	if part2 == libc.UintptrFromInt32(0) {
		p = part1
		for {
			if !(*(*uint8)(unsafe.Pointer(p)) != 0) {
				break
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('(') {
				openParen = p
				for cond := true; cond; cond = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('\000') {
					p++
				}
				p--
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(')') {
					offset = int32(int64(openParen) - int64(part1))
					XTcl_DStringInit(tls, bp+24)
					XTcl_DStringAppend(tls, bp+24, part1, int64(p)-int64(part1))
					newPart1 = (*TTcl_DString)(unsafe.Pointer(bp + 24)).Fstring1
					*(*uint8)(unsafe.Pointer(newPart1 + uintptr(offset))) = uint8(0)
					part1 = newPart1
					part2 = newPart1 + uintptr(offset) + uintptr(1)
					copiedName = int32(1)
				}
				break
			}
			goto _1
		_1:
			;
			p++
		}
	}
	/* Keep the original pointer for possible use in an error message */
	element = part2
	if part2 == libc.UintptrFromInt32(0) {
		if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_ARRAY_ELEMENT) != 0 {
			keyObj = *(*uintptr)(unsafe.Pointer(varPtr + 24 + 32))
			part2 = XTcl_GetStringFromObj(tls, keyObj, libc.UintptrFromInt32(0))
		}
	} else {
		if flags&int32(VAR_TRACED_UNSET) != 0 && !(flags&libc.Int32FromInt32(VAR_ARRAY_ELEMENT) != 0) {
			/* On unset traces, part2 has already been set by the caller, and
			 * the VAR_ARRAY_ELEMENT flag indicates whether the accessed
			 * variable actually has a second part, or is a scalar */
			element = libc.UintptrFromInt32(0)
		}
	}
	/*
	 * Invoke traces on the array containing the variable, if relevant.
	 */
	result = libc.UintptrFromInt32(0)
	(*(*TActiveVarTrace)(unsafe.Pointer(bp))).FnextPtr = (*TInterp)(unsafe.Pointer(iPtr)).FactiveVarTracePtr
	(*TInterp)(unsafe.Pointer(iPtr)).FactiveVarTracePtr = bp
	XTcl_Preserve(tls, iPtr)
	if arrayPtr != 0 && !((*TVar)(unsafe.Pointer(arrayPtr)).Fflags&libc.Int32FromInt32(VAR_TRACE_ACTIVE) != 0) && (*TVar)(unsafe.Pointer(arrayPtr)).Fflags&traceflags != 0 {
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iPtr + 792)).FfindProc})))(tls, iPtr+792, arrayPtr)
		(*(*TActiveVarTrace)(unsafe.Pointer(bp))).FvarPtr = arrayPtr
		tracePtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		for {
			if !(tracePtr != libc.UintptrFromInt32(0)) {
				break
			}
			(*(*TActiveVarTrace)(unsafe.Pointer(bp))).FnextTracePtr = (*TVarTrace)(unsafe.Pointer(tracePtr)).FnextPtr
			if !((*TVarTrace)(unsafe.Pointer(tracePtr)).Fflags&flags != 0) {
				goto _2
			}
			XTcl_Preserve(tls, tracePtr)
			if state == libc.UintptrFromInt32(0) {
				state = XTcl_SaveInterpState(tls, iPtr, code)
			}
			result = (*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr, int32) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TVarTrace)(unsafe.Pointer(tracePtr)).FtraceProc})))(tls, (*TVarTrace)(unsafe.Pointer(tracePtr)).FclientData, iPtr, part1, part2, flags)
			if result != libc.UintptrFromInt32(0) {
				if flags&int32(TCL_TRACE_UNSETS) != 0 {
					/*
					 * Ignore errors in unset traces.
					 */
					_DisposeTraceResult(tls, (*TVarTrace)(unsafe.Pointer(tracePtr)).Fflags, result)
				} else {
					disposeFlags = (*TVarTrace)(unsafe.Pointer(tracePtr)).Fflags
					code = int32(TCL_ERROR)
				}
			}
			XTcl_Release(tls, tracePtr)
			if code == int32(TCL_ERROR) {
				goto done
			}
			goto _2
		_2:
			;
			tracePtr = (*(*TActiveVarTrace)(unsafe.Pointer(bp))).FnextTracePtr
		}
	}
	/*
	 * Invoke traces on the variable itself.
	 */
	if flags&int32(TCL_TRACE_UNSETS) != 0 {
		flags |= int32(TCL_TRACE_DESTROYED)
	}
	(*(*TActiveVarTrace)(unsafe.Pointer(bp))).FvarPtr = varPtr
	if (*TVar)(unsafe.Pointer(varPtr)).Fflags&traceflags != 0 {
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iPtr + 792)).FfindProc})))(tls, iPtr+792, varPtr)
		tracePtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		for {
			if !(tracePtr != libc.UintptrFromInt32(0)) {
				break
			}
			(*(*TActiveVarTrace)(unsafe.Pointer(bp))).FnextTracePtr = (*TVarTrace)(unsafe.Pointer(tracePtr)).FnextPtr
			if !((*TVarTrace)(unsafe.Pointer(tracePtr)).Fflags&flags != 0) {
				goto _3
			}
			XTcl_Preserve(tls, tracePtr)
			if state == libc.UintptrFromInt32(0) {
				state = XTcl_SaveInterpState(tls, iPtr, code)
			}
			result = (*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr, int32) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TVarTrace)(unsafe.Pointer(tracePtr)).FtraceProc})))(tls, (*TVarTrace)(unsafe.Pointer(tracePtr)).FclientData, iPtr, part1, part2, flags)
			if result != libc.UintptrFromInt32(0) {
				if flags&int32(TCL_TRACE_UNSETS) != 0 {
					/*
					 * Ignore errors in unset traces.
					 */
					_DisposeTraceResult(tls, (*TVarTrace)(unsafe.Pointer(tracePtr)).Fflags, result)
				} else {
					disposeFlags = (*TVarTrace)(unsafe.Pointer(tracePtr)).Fflags
					code = int32(TCL_ERROR)
				}
			}
			XTcl_Release(tls, tracePtr)
			if code == int32(TCL_ERROR) {
				goto done
			}
			goto _3
		_3:
			;
			tracePtr = (*(*TActiveVarTrace)(unsafe.Pointer(bp))).FnextTracePtr
		}
	}
	/*
	 * Restore the variable's flags, remove the record of our active traces,
	 * and then return.
	 */
	goto done
done:
	;
	if code == int32(TCL_ERROR) {
		if leaveErrMsg != 0 {
			verb = __ccgo_ts + 1945
			type1 = __ccgo_ts + 1945
			switch flags & (libc.Int32FromInt32(TCL_TRACE_READS) | libc.Int32FromInt32(TCL_TRACE_WRITES) | libc.Int32FromInt32(TCL_TRACE_ARRAY)) {
			case int32(TCL_TRACE_READS):
				verb = __ccgo_ts + 5552
				type1 = verb
			case int32(TCL_TRACE_WRITES):
				verb = __ccgo_ts + 5383
				type1 = __ccgo_ts + 44159
			case int32(TCL_TRACE_ARRAY):
				verb = __ccgo_ts + 68088
				type1 = __ccgo_ts + 28190
				break
			}
			if disposeFlags&int32(TCL_TRACE_RESULT_OBJECT) != 0 {
				XTcl_SetObjResult(tls, iPtr, result)
			} else {
				XTcl_SetObjResult(tls, iPtr, XTcl_NewStringObj(tls, result, int64(-int32(1))))
			}
			XTcl_AppendObjToErrorInfo(tls, iPtr, XTcl_NewStringObj(tls, __ccgo_ts+1945, int64(-int32(1))))
			if element != 0 {
				v4 = __ccgo_ts + 68100
			} else {
				v4 = __ccgo_ts + 1945
			}
			if element != 0 {
				v5 = element
			} else {
				v5 = __ccgo_ts + 1945
			}
			if element != 0 {
				v6 = __ccgo_ts + 3563
			} else {
				v6 = __ccgo_ts + 1945
			}
			XTcl_AppendObjToErrorInfo(tls, iPtr, XTcl_ObjPrintf(tls, __ccgo_ts+68102, libc.VaList(bp+256, type1, part1, v4, v5, v6)))
			if disposeFlags&int32(TCL_TRACE_RESULT_OBJECT) != 0 {
				if (*TTcl_Obj)(unsafe.Pointer(result)).Fbytes != 0 {
					v7 = (*TTcl_Obj)(unsafe.Pointer(result)).Fbytes
				} else {
					v7 = XTcl_GetStringFromObj(tls, result, libc.UintptrFromInt32(0))
				}
				XTclVarErrMsg(tls, iPtr, part1, element, verb, v7)
			} else {
				XTclVarErrMsg(tls, iPtr, part1, element, verb, result)
			}
			*(*int32)(unsafe.Pointer(iPtr + 368)) &= ^libc.Int32FromInt32(ERR_ALREADY_LOGGED)
			XTcl_DiscardInterpState(tls, state)
		} else {
			XTcl_RestoreInterpState(tls, iPtr, state)
		}
		_DisposeTraceResult(tls, disposeFlags, result)
	} else {
		if state != 0 {
			if code == TCL_OK {
				code = XTcl_RestoreInterpState(tls, iPtr, state)
			} else {
				XTcl_DiscardInterpState(tls, state)
			}
		}
	}
	if arrayPtr != 0 && (*TVar)(unsafe.Pointer(arrayPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
		(*TVarInHash)(unsafe.Pointer(arrayPtr)).FrefCount--
	}
	if copiedName != 0 {
		XTcl_DStringFree(tls, bp+24)
	}
	*(*int32)(unsafe.Pointer(varPtr)) &= ^libc.Int32FromInt32(VAR_TRACE_ACTIVE)
	if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
		(*TVarInHash)(unsafe.Pointer(varPtr)).FrefCount--
	}
	(*TInterp)(unsafe.Pointer(iPtr)).FactiveVarTracePtr = (*(*TActiveVarTrace)(unsafe.Pointer(bp))).FnextPtr
	XTcl_Release(tls, iPtr)
	return code
}

/*
 *----------------------------------------------------------------------
 *
 * DisposeTraceResult--
 *
 *	This function is called to dispose of the result returned from a trace
 *	function. The disposal method appropriate to the type of result is
 *	determined by flags.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The memory allocated for the trace result may be freed.
 *
 *----------------------------------------------------------------------
 */

func _DisposeTraceResult(tls *libc.TLS, flags int32, result uintptr) {
	/* The result returned from a trace function
	 * to be disposed. */
	var _objPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _ = _objPtr, v1, v2
	if flags&int32(TCL_TRACE_RESULT_DYNAMIC) != 0 {
		XTclpFree(tls, result)
	} else {
		if flags&int32(TCL_TRACE_RESULT_OBJECT) != 0 {
			_objPtr = result
			v2 = _objPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if v1 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UntraceVar2 --
 *
 *	Remove a previously-created trace for a variable.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	If there exists a trace for the variable given by part1 and part2 with
 *	the given flags, proc, and clientData, then that trace is removed.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UntraceVar2(tls *libc.TLS, interp uintptr, part1 uintptr, part2 uintptr, flags int32, proc uintptr, clientData uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Arbitrary argument to pass to proc. */
	var activePtr, hPtr, iPtr, nextPtr, prevPtr, tracePtr, varPtr uintptr
	var allFlags, flagMask int32
	var _ /* arrayPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _ = activePtr, allFlags, flagMask, hPtr, iPtr, nextPtr, prevPtr, tracePtr, varPtr
	iPtr = interp
	allFlags = 0
	/*
	 * Set up a mask to mask out the parts of the flags that we are not
	 * interested in now.
	 */
	flagMask = libc.Int32FromInt32(TCL_GLOBAL_ONLY) | libc.Int32FromInt32(TCL_NAMESPACE_ONLY)
	varPtr = XTclLookupVar(tls, interp, part1, part2, flags&flagMask, libc.UintptrFromInt32(0), 0, 0, bp)
	if varPtr == libc.UintptrFromInt32(0) || !((*TVar)(unsafe.Pointer(varPtr)).Fflags&(libc.Int32FromInt32(VAR_TRACED_READ)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_TRACED_ARRAY)|libc.Int32FromInt32(VAR_TRACED_UNSET))&flags != 0) {
		return
	}
	/*
	 * Set up a mask to mask out the parts of the flags that we are not
	 * interested in now.
	 */
	flagMask = libc.Int32FromInt32(TCL_TRACE_READS) | libc.Int32FromInt32(TCL_TRACE_WRITES) | libc.Int32FromInt32(TCL_TRACE_UNSETS) | libc.Int32FromInt32(TCL_TRACE_ARRAY) | libc.Int32FromInt32(TCL_TRACE_RESULT_DYNAMIC) | libc.Int32FromInt32(TCL_TRACE_RESULT_OBJECT)
	flags &= flagMask
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iPtr + 792)).FfindProc})))(tls, iPtr+792, varPtr)
	tracePtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
	prevPtr = libc.UintptrFromInt32(0)
	for {
		if tracePtr == libc.UintptrFromInt32(0) {
			goto updateFlags
		}
		if (*TVarTrace)(unsafe.Pointer(tracePtr)).FtraceProc == proc && (*TVarTrace)(unsafe.Pointer(tracePtr)).Fflags == flags && (*TVarTrace)(unsafe.Pointer(tracePtr)).FclientData == clientData {
			break
		}
		allFlags |= (*TVarTrace)(unsafe.Pointer(tracePtr)).Fflags
		goto _1
	_1:
		;
		prevPtr = tracePtr
		tracePtr = (*TVarTrace)(unsafe.Pointer(tracePtr)).FnextPtr
	}
	/*
	 * The code below makes it possible to delete traces while traces are
	 * active: it makes sure that the deleted trace won't be processed by
	 * TclCallVarTraces.
	 *
	 * Caveat (Bug 3062331): When an unset trace handler on a variable
	 * tries to delete a different unset trace handler on the same variable,
	 * the results may be surprising.  When variable unset traces fire, the
	 * traced variable is already gone.  So the TclLookupVar() call above
	 * will not find that variable, and not finding it will never reach here
	 * to perform the deletion.  This means callers of Tcl_UntraceVar*()
	 * attempting to delete unset traces from within the handler of another
	 * unset trace have to account for the possibility that their call to
	 * Tcl_UntraceVar*() is a no-op.
	 */
	activePtr = (*TInterp)(unsafe.Pointer(iPtr)).FactiveVarTracePtr
	for {
		if !(activePtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TActiveVarTrace)(unsafe.Pointer(activePtr)).FnextTracePtr == tracePtr {
			(*TActiveVarTrace)(unsafe.Pointer(activePtr)).FnextTracePtr = (*TVarTrace)(unsafe.Pointer(tracePtr)).FnextPtr
		}
		goto _2
	_2:
		;
		activePtr = (*TActiveVarTrace)(unsafe.Pointer(activePtr)).FnextPtr
	}
	nextPtr = (*TVarTrace)(unsafe.Pointer(tracePtr)).FnextPtr
	if prevPtr == libc.UintptrFromInt32(0) {
		if nextPtr != 0 {
			(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = nextPtr
		} else {
			XTcl_DeleteHashEntry(tls, hPtr)
		}
	} else {
		(*TVarTrace)(unsafe.Pointer(prevPtr)).FnextPtr = nextPtr
	}
	(*TVarTrace)(unsafe.Pointer(tracePtr)).FnextPtr = libc.UintptrFromInt32(0)
	XTcl_EventuallyFree(tls, tracePtr, libc.UintptrFromInt32(3))
	tracePtr = nextPtr
	for {
		if !(tracePtr != libc.UintptrFromInt32(0)) {
			break
		}
		allFlags |= (*TVarTrace)(unsafe.Pointer(tracePtr)).Fflags
		goto _3
	_3:
		;
		tracePtr = (*TVarTrace)(unsafe.Pointer(tracePtr)).FnextPtr
	}
	goto updateFlags
updateFlags:
	;
	*(*int32)(unsafe.Pointer(varPtr)) &= ^(libc.Int32FromInt32(VAR_TRACED_READ) | libc.Int32FromInt32(VAR_TRACED_WRITE) | libc.Int32FromInt32(VAR_TRACED_ARRAY) | libc.Int32FromInt32(VAR_TRACED_UNSET))
	if allFlags&(libc.Int32FromInt32(VAR_TRACED_READ)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_TRACED_ARRAY)|libc.Int32FromInt32(VAR_TRACED_UNSET)) != 0 {
		*(*int32)(unsafe.Pointer(varPtr)) |= allFlags & (libc.Int32FromInt32(VAR_TRACED_READ) | libc.Int32FromInt32(VAR_TRACED_WRITE) | libc.Int32FromInt32(VAR_TRACED_ARRAY) | libc.Int32FromInt32(VAR_TRACED_UNSET))
	} else {
		if *(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0) {
			/*
			 * If this is the last trace on the variable, and the variable is
			 * unset and unused, then free up the variable.
			 */
			XTclCleanupVar(tls, varPtr, libc.UintptrFromInt32(0))
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_VarTraceInfo2 --
 *
 *	Same as Tcl_VarTraceInfo, except takes name in two pieces instead of
 *	one.
 *
 * Results:
 *	Same as Tcl_VarTraceInfo.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_VarTraceInfo2(tls *libc.TLS, interp uintptr, part1 uintptr, part2 uintptr, flags int32, proc uintptr, prevClientData uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* If non-NULL, gives last value returned by
	 * this function, so this call will return the
	 * next trace after that one. If NULL, this
	 * call will return the first trace. */
	var hPtr, iPtr, tracePtr, varPtr uintptr
	var _ /* arrayPtr at bp+0 */ uintptr
	_, _, _, _ = hPtr, iPtr, tracePtr, varPtr
	iPtr = interp
	varPtr = XTclLookupVar(tls, interp, part1, part2, flags&(libc.Int32FromInt32(TCL_GLOBAL_ONLY)|libc.Int32FromInt32(TCL_NAMESPACE_ONLY)), libc.UintptrFromInt32(0), 0, 0, bp)
	if varPtr == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	/*
	 * Find the relevant trace, if any, and return its clientData.
	 */
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iPtr + 792)).FfindProc})))(tls, iPtr+792, varPtr)
	if hPtr != 0 {
		tracePtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		if prevClientData != libc.UintptrFromInt32(0) {
			for {
				if !(tracePtr != libc.UintptrFromInt32(0)) {
					break
				}
				if (*TVarTrace)(unsafe.Pointer(tracePtr)).FclientData == prevClientData && (*TVarTrace)(unsafe.Pointer(tracePtr)).FtraceProc == proc {
					tracePtr = (*TVarTrace)(unsafe.Pointer(tracePtr)).FnextPtr
					break
				}
				goto _1
			_1:
				;
				tracePtr = (*TVarTrace)(unsafe.Pointer(tracePtr)).FnextPtr
			}
		}
		for {
			if !(tracePtr != libc.UintptrFromInt32(0)) {
				break
			}
			if (*TVarTrace)(unsafe.Pointer(tracePtr)).FtraceProc == proc {
				return (*TVarTrace)(unsafe.Pointer(tracePtr)).FclientData
			}
			goto _2
		_2:
			;
			tracePtr = (*TVarTrace)(unsafe.Pointer(tracePtr)).FnextPtr
		}
	}
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_TraceVar2 --
 *
 *	Arrange for reads and/or writes to a variable to cause a function to
 *	be invoked, which can monitor the operations and/or change their
 *	actions.
 *
 * Results:
 *	A standard Tcl return value.
 *
 * Side effects:
 *	A trace is set up on the variable given by part1 and part2, such that
 *	future references to the variable will be mediated by proc. See
 *	the manual entry for complete details on the calling sequence for
 *	proc. The variable's flags are updated.
 *
 *----------------------------------------------------------------------
 */

func XTcl_TraceVar2(tls *libc.TLS, interp uintptr, part1 uintptr, part2 uintptr, flags int32, proc uintptr, clientData uintptr) (r int32) {
	/* Arbitrary argument to pass to proc. */
	var result int32
	var tracePtr uintptr
	_, _ = result, tracePtr
	tracePtr = XTcl_Alloc(tls, uint64(32))
	(*TVarTrace)(unsafe.Pointer(tracePtr)).FtraceProc = proc
	(*TVarTrace)(unsafe.Pointer(tracePtr)).FclientData = clientData
	(*TVarTrace)(unsafe.Pointer(tracePtr)).Fflags = flags
	result = _TraceVarEx(tls, interp, part1, part2, tracePtr)
	if result != TCL_OK {
		XTclpFree(tls, tracePtr)
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * TraceVarEx --
 *
 *	Arrange for reads and/or writes to a variable to cause a function to
 *	be invoked, which can monitor the operations and/or change their
 *	actions.
 *
 * Results:
 *	A standard Tcl return value.
 *
 * Side effects:
 *	A trace is set up on the variable given by part1 and part2, such that
 *	future references to the variable will be mediated by the
 *	traceProc listed in tracePtr. See the manual entry for complete
 *	details on the calling sequence for proc.
 *
 *----------------------------------------------------------------------
 */

func _TraceVarEx(tls *libc.TLS, interp uintptr, part1 uintptr, part2 uintptr, tracePtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Structure containing flags, traceProc and
	 * clientData fields. Others should be left
	 * blank. Will be Tcl_Free()d (eventually) if
	 * this function returns TCL_OK, and up to
	 * caller to free if this function returns
	 * TCL_ERROR. */
	var flagMask int32
	var hPtr, iPtr, varPtr uintptr
	var _ /* arrayPtr at bp+0 */ uintptr
	var _ /* isNew at bp+8 */ int32
	_, _, _, _ = flagMask, hPtr, iPtr, varPtr
	iPtr = interp
	/*
	 * We strip 'flags' down to just the parts which are relevant to
	 * TclLookupVar, to avoid conflicts between trace flags and internal
	 * namespace flags such as 'TCL_FIND_ONLY_NS'. This can now occur since we
	 * have trace flags with values 0x1000 and higher.
	 */
	flagMask = libc.Int32FromInt32(TCL_GLOBAL_ONLY) | libc.Int32FromInt32(TCL_NAMESPACE_ONLY)
	varPtr = XTclLookupVar(tls, interp, part1, part2, (*TVarTrace)(unsafe.Pointer(tracePtr)).Fflags&flagMask|int32(TCL_LEAVE_ERR_MSG), __ccgo_ts+5421, int32(1), int32(1), bp)
	if varPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Check for a nonsense flag combination. Note that this is a Tcl_Panic()
	 * because there should be no code path that ever sets both flags.
	 */
	if (*TVarTrace)(unsafe.Pointer(tracePtr)).Fflags&int32(TCL_TRACE_RESULT_DYNAMIC) != 0 && (*TVarTrace)(unsafe.Pointer(tracePtr)).Fflags&int32(TCL_TRACE_RESULT_OBJECT) != 0 {
		XTcl_Panic(tls, __ccgo_ts+68132, 0)
	}
	/*
	 * Set up trace information.
	 */
	flagMask = libc.Int32FromInt32(TCL_TRACE_READS) | libc.Int32FromInt32(TCL_TRACE_WRITES) | libc.Int32FromInt32(TCL_TRACE_UNSETS) | libc.Int32FromInt32(TCL_TRACE_ARRAY) | libc.Int32FromInt32(TCL_TRACE_RESULT_DYNAMIC) | libc.Int32FromInt32(TCL_TRACE_RESULT_OBJECT)
	(*TVarTrace)(unsafe.Pointer(tracePtr)).Fflags = (*TVarTrace)(unsafe.Pointer(tracePtr)).Fflags & flagMask
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iPtr + 792)).FcreateProc})))(tls, iPtr+792, varPtr, bp+8)
	if *(*int32)(unsafe.Pointer(bp + 8)) != 0 {
		(*TVarTrace)(unsafe.Pointer(tracePtr)).FnextPtr = libc.UintptrFromInt32(0)
	} else {
		(*TVarTrace)(unsafe.Pointer(tracePtr)).FnextPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
	}
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = tracePtr
	/*
	 * Mark the variable as traced so we know to call them.
	 */
	*(*int32)(unsafe.Pointer(varPtr)) |= (*TVarTrace)(unsafe.Pointer(tracePtr)).Fflags & (libc.Int32FromInt32(VAR_TRACED_READ) | libc.Int32FromInt32(VAR_TRACED_WRITE) | libc.Int32FromInt32(VAR_TRACED_ARRAY) | libc.Int32FromInt32(VAR_TRACED_UNSET))
	return TCL_OK
}

const LINE_LENGTH = 128
const OFFSET_BITS = 5
const UNICODE_SELF = 128

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * Include the static character classification tables and macros.
 */

/*
 * tclUniData.c --
 *
 *	Declarations of Unicode character information tables.  This file is
 *	automatically generated by the tools/uniParse.tcl script.  Do not
 *	modify this file by hand.
 *
 * Copyright © 1998 Scriptics Corporation.
 * All rights reserved.
 */

/*
 * A 16-bit Unicode character is split into two parts in order to index
 * into the following tables.  The lower OFFSET_BITS comprise an offset
 * into a page of characters.  The upper bits comprise the page number.
 */

/*
 * The pageMap is indexed by page number and returns an alternate page number
 * that identifies a unique page of characters.  Many Unicode characters map
 * to the same alternate page number.
 */

var _pageMap = [6430]uint16{
	1:    uint16(32),
	2:    uint16(64),
	3:    uint16(96),
	5:    uint16(128),
	6:    uint16(160),
	7:    uint16(192),
	8:    uint16(224),
	9:    uint16(256),
	10:   uint16(288),
	11:   uint16(320),
	12:   uint16(352),
	13:   uint16(384),
	14:   uint16(416),
	15:   uint16(448),
	16:   uint16(224),
	17:   uint16(480),
	18:   uint16(512),
	19:   uint16(544),
	20:   uint16(576),
	21:   uint16(608),
	22:   uint16(640),
	23:   uint16(672),
	24:   uint16(704),
	25:   uint16(704),
	26:   uint16(736),
	27:   uint16(768),
	28:   uint16(800),
	29:   uint16(832),
	30:   uint16(864),
	31:   uint16(896),
	32:   uint16(928),
	33:   uint16(960),
	34:   uint16(992),
	35:   uint16(224),
	36:   uint16(1024),
	37:   uint16(224),
	38:   uint16(1056),
	39:   uint16(224),
	40:   uint16(224),
	41:   uint16(1088),
	42:   uint16(1120),
	43:   uint16(1152),
	44:   uint16(1184),
	45:   uint16(1216),
	46:   uint16(1248),
	47:   uint16(1280),
	48:   uint16(1312),
	49:   uint16(1344),
	50:   uint16(1376),
	51:   uint16(1408),
	52:   uint16(1344),
	53:   uint16(1344),
	54:   uint16(1440),
	55:   uint16(1472),
	56:   uint16(1504),
	57:   uint16(1536),
	58:   uint16(1568),
	59:   uint16(1344),
	60:   uint16(1344),
	61:   uint16(1600),
	62:   uint16(1632),
	63:   uint16(1664),
	64:   uint16(1696),
	65:   uint16(1728),
	66:   uint16(1760),
	67:   uint16(1792),
	68:   uint16(1824),
	69:   uint16(1344),
	70:   uint16(1856),
	71:   uint16(1888),
	72:   uint16(1920),
	73:   uint16(1952),
	74:   uint16(1984),
	75:   uint16(2016),
	76:   uint16(2048),
	77:   uint16(2080),
	78:   uint16(2112),
	79:   uint16(2144),
	80:   uint16(2176),
	81:   uint16(2208),
	82:   uint16(2240),
	83:   uint16(2272),
	84:   uint16(2304),
	85:   uint16(2336),
	86:   uint16(2368),
	87:   uint16(2400),
	88:   uint16(2432),
	89:   uint16(2464),
	90:   uint16(2496),
	91:   uint16(2528),
	92:   uint16(2560),
	93:   uint16(2592),
	94:   uint16(2624),
	95:   uint16(2656),
	96:   uint16(2688),
	97:   uint16(2720),
	98:   uint16(2752),
	99:   uint16(2784),
	100:  uint16(2816),
	101:  uint16(2848),
	102:  uint16(2880),
	103:  uint16(2912),
	104:  uint16(2944),
	105:  uint16(2976),
	106:  uint16(3008),
	107:  uint16(3040),
	108:  uint16(3072),
	109:  uint16(3104),
	110:  uint16(3136),
	111:  uint16(3168),
	112:  uint16(3200),
	113:  uint16(3232),
	114:  uint16(3264),
	115:  uint16(3296),
	116:  uint16(3328),
	117:  uint16(3360),
	118:  uint16(3392),
	119:  uint16(3296),
	120:  uint16(3424),
	121:  uint16(3456),
	122:  uint16(3488),
	123:  uint16(3520),
	124:  uint16(3552),
	125:  uint16(3584),
	126:  uint16(3616),
	127:  uint16(3296),
	128:  uint16(1344),
	129:  uint16(3648),
	130:  uint16(3680),
	131:  uint16(3712),
	132:  uint16(3744),
	133:  uint16(3776),
	134:  uint16(3808),
	135:  uint16(3840),
	136:  uint16(1344),
	137:  uint16(1344),
	138:  uint16(1344),
	139:  uint16(1344),
	140:  uint16(1344),
	141:  uint16(1344),
	142:  uint16(1344),
	143:  uint16(1344),
	144:  uint16(1344),
	145:  uint16(1344),
	146:  uint16(3872),
	147:  uint16(1344),
	148:  uint16(3904),
	149:  uint16(3936),
	150:  uint16(3968),
	151:  uint16(1344),
	152:  uint16(4000),
	153:  uint16(1344),
	154:  uint16(4032),
	155:  uint16(4064),
	156:  uint16(4096),
	157:  uint16(4128),
	158:  uint16(4128),
	159:  uint16(4160),
	160:  uint16(4192),
	161:  uint16(1344),
	162:  uint16(1344),
	163:  uint16(1344),
	164:  uint16(1344),
	165:  uint16(1344),
	166:  uint16(1344),
	167:  uint16(1344),
	168:  uint16(1344),
	169:  uint16(1344),
	170:  uint16(1344),
	171:  uint16(1344),
	172:  uint16(1344),
	173:  uint16(1344),
	174:  uint16(1344),
	175:  uint16(1344),
	176:  uint16(1344),
	177:  uint16(1344),
	178:  uint16(1344),
	179:  uint16(4224),
	180:  uint16(4256),
	181:  uint16(1344),
	182:  uint16(1344),
	183:  uint16(4288),
	184:  uint16(4320),
	185:  uint16(4352),
	186:  uint16(4384),
	187:  uint16(4416),
	188:  uint16(1344),
	189:  uint16(4448),
	190:  uint16(4480),
	191:  uint16(4512),
	192:  uint16(4544),
	193:  uint16(1344),
	194:  uint16(4576),
	195:  uint16(4608),
	196:  uint16(4640),
	197:  uint16(4672),
	198:  uint16(1344),
	199:  uint16(4704),
	200:  uint16(4736),
	201:  uint16(4768),
	202:  uint16(4800),
	203:  uint16(4832),
	204:  uint16(1344),
	205:  uint16(4864),
	206:  uint16(4896),
	207:  uint16(4928),
	208:  uint16(4960),
	209:  uint16(1344),
	210:  uint16(4992),
	211:  uint16(5024),
	212:  uint16(5056),
	213:  uint16(5088),
	214:  uint16(5120),
	215:  uint16(3296),
	216:  uint16(5152),
	217:  uint16(5184),
	218:  uint16(5216),
	219:  uint16(5248),
	220:  uint16(5280),
	221:  uint16(5312),
	222:  uint16(1344),
	223:  uint16(5344),
	224:  uint16(1344),
	225:  uint16(5376),
	226:  uint16(5408),
	227:  uint16(5440),
	228:  uint16(5472),
	229:  uint16(5504),
	230:  uint16(5536),
	231:  uint16(5568),
	232:  uint16(5600),
	233:  uint16(5632),
	234:  uint16(5664),
	235:  uint16(5696),
	236:  uint16(5728),
	237:  uint16(5664),
	238:  uint16(704),
	239:  uint16(704),
	240:  uint16(224),
	241:  uint16(224),
	242:  uint16(224),
	243:  uint16(224),
	244:  uint16(5760),
	245:  uint16(224),
	246:  uint16(224),
	247:  uint16(224),
	248:  uint16(5792),
	249:  uint16(5824),
	250:  uint16(5856),
	251:  uint16(5888),
	252:  uint16(5920),
	253:  uint16(5952),
	254:  uint16(5984),
	255:  uint16(6016),
	256:  uint16(6048),
	257:  uint16(6080),
	258:  uint16(6112),
	259:  uint16(6144),
	260:  uint16(6176),
	261:  uint16(6208),
	262:  uint16(6240),
	263:  uint16(6272),
	264:  uint16(6304),
	265:  uint16(6336),
	266:  uint16(6368),
	267:  uint16(6400),
	268:  uint16(6432),
	269:  uint16(6464),
	270:  uint16(6496),
	271:  uint16(6528),
	272:  uint16(6560),
	273:  uint16(6560),
	274:  uint16(6560),
	275:  uint16(6560),
	276:  uint16(6560),
	277:  uint16(6560),
	278:  uint16(6560),
	279:  uint16(6560),
	280:  uint16(6592),
	281:  uint16(6624),
	282:  uint16(4928),
	283:  uint16(6656),
	284:  uint16(6688),
	285:  uint16(6720),
	286:  uint16(6752),
	287:  uint16(6784),
	288:  uint16(4928),
	289:  uint16(6816),
	290:  uint16(6848),
	291:  uint16(6880),
	292:  uint16(6912),
	293:  uint16(6944),
	294:  uint16(6976),
	295:  uint16(7008),
	296:  uint16(4928),
	297:  uint16(4928),
	298:  uint16(4928),
	299:  uint16(4928),
	300:  uint16(4928),
	301:  uint16(7040),
	302:  uint16(7072),
	303:  uint16(7104),
	304:  uint16(4928),
	305:  uint16(4928),
	306:  uint16(4928),
	307:  uint16(7136),
	308:  uint16(4928),
	309:  uint16(4928),
	310:  uint16(4928),
	311:  uint16(4928),
	312:  uint16(4928),
	313:  uint16(4928),
	314:  uint16(4928),
	315:  uint16(7168),
	316:  uint16(7200),
	317:  uint16(4928),
	318:  uint16(7232),
	319:  uint16(7264),
	320:  uint16(4928),
	321:  uint16(4928),
	322:  uint16(4928),
	323:  uint16(4928),
	324:  uint16(4928),
	325:  uint16(4928),
	326:  uint16(4928),
	327:  uint16(4928),
	328:  uint16(6560),
	329:  uint16(6560),
	330:  uint16(6560),
	331:  uint16(6560),
	332:  uint16(7296),
	333:  uint16(6560),
	334:  uint16(7328),
	335:  uint16(7360),
	336:  uint16(6560),
	337:  uint16(6560),
	338:  uint16(6560),
	339:  uint16(6560),
	340:  uint16(6560),
	341:  uint16(6560),
	342:  uint16(6560),
	343:  uint16(6560),
	344:  uint16(4928),
	345:  uint16(7392),
	346:  uint16(7424),
	347:  uint16(7456),
	348:  uint16(7488),
	349:  uint16(4928),
	350:  uint16(4928),
	351:  uint16(4928),
	352:  uint16(7520),
	353:  uint16(7552),
	354:  uint16(7584),
	355:  uint16(7616),
	356:  uint16(224),
	357:  uint16(224),
	358:  uint16(224),
	359:  uint16(7648),
	360:  uint16(7680),
	361:  uint16(7712),
	362:  uint16(1344),
	363:  uint16(7744),
	364:  uint16(7776),
	365:  uint16(7808),
	366:  uint16(7808),
	367:  uint16(704),
	368:  uint16(7840),
	369:  uint16(7872),
	370:  uint16(7904),
	371:  uint16(3296),
	372:  uint16(7936),
	373:  uint16(4928),
	374:  uint16(4928),
	375:  uint16(7968),
	376:  uint16(4928),
	377:  uint16(4928),
	378:  uint16(4928),
	379:  uint16(4928),
	380:  uint16(4928),
	381:  uint16(4928),
	382:  uint16(8000),
	383:  uint16(8032),
	384:  uint16(8064),
	385:  uint16(8096),
	386:  uint16(3200),
	387:  uint16(1344),
	388:  uint16(8128),
	389:  uint16(4192),
	390:  uint16(1344),
	391:  uint16(8160),
	392:  uint16(8192),
	393:  uint16(8224),
	394:  uint16(1344),
	395:  uint16(1344),
	396:  uint16(8256),
	397:  uint16(1344),
	398:  uint16(4928),
	399:  uint16(8288),
	400:  uint16(8320),
	401:  uint16(8352),
	402:  uint16(8384),
	403:  uint16(4928),
	404:  uint16(8352),
	405:  uint16(8416),
	406:  uint16(4928),
	407:  uint16(4928),
	408:  uint16(4928),
	409:  uint16(4928),
	410:  uint16(4928),
	411:  uint16(4928),
	412:  uint16(4928),
	413:  uint16(4928),
	414:  uint16(4928),
	415:  uint16(4928),
	416:  uint16(1344),
	417:  uint16(1344),
	418:  uint16(1344),
	419:  uint16(1344),
	420:  uint16(1344),
	421:  uint16(1344),
	422:  uint16(1344),
	423:  uint16(1344),
	424:  uint16(1344),
	425:  uint16(1344),
	426:  uint16(1344),
	427:  uint16(1344),
	428:  uint16(1344),
	429:  uint16(1344),
	430:  uint16(1344),
	431:  uint16(1344),
	432:  uint16(1344),
	433:  uint16(1344),
	434:  uint16(1344),
	435:  uint16(1344),
	436:  uint16(1344),
	437:  uint16(1344),
	438:  uint16(1344),
	439:  uint16(1344),
	440:  uint16(1344),
	441:  uint16(1344),
	442:  uint16(1344),
	443:  uint16(1344),
	444:  uint16(1344),
	445:  uint16(1344),
	446:  uint16(1344),
	447:  uint16(1344),
	448:  uint16(1344),
	449:  uint16(1344),
	450:  uint16(1344),
	451:  uint16(1344),
	452:  uint16(1344),
	453:  uint16(1344),
	454:  uint16(1344),
	455:  uint16(1344),
	456:  uint16(1344),
	457:  uint16(1344),
	458:  uint16(1344),
	459:  uint16(1344),
	460:  uint16(1344),
	461:  uint16(1344),
	462:  uint16(1344),
	463:  uint16(1344),
	464:  uint16(1344),
	465:  uint16(1344),
	466:  uint16(1344),
	467:  uint16(1344),
	468:  uint16(1344),
	469:  uint16(1344),
	470:  uint16(1344),
	471:  uint16(1344),
	472:  uint16(1344),
	473:  uint16(1344),
	474:  uint16(1344),
	475:  uint16(1344),
	476:  uint16(1344),
	477:  uint16(1344),
	478:  uint16(1344),
	479:  uint16(1344),
	480:  uint16(1344),
	481:  uint16(1344),
	482:  uint16(1344),
	483:  uint16(1344),
	484:  uint16(1344),
	485:  uint16(1344),
	486:  uint16(1344),
	487:  uint16(1344),
	488:  uint16(1344),
	489:  uint16(1344),
	490:  uint16(1344),
	491:  uint16(1344),
	492:  uint16(1344),
	493:  uint16(1344),
	494:  uint16(1344),
	495:  uint16(1344),
	496:  uint16(1344),
	497:  uint16(1344),
	498:  uint16(1344),
	499:  uint16(1344),
	500:  uint16(1344),
	501:  uint16(1344),
	502:  uint16(1344),
	503:  uint16(1344),
	504:  uint16(1344),
	505:  uint16(1344),
	506:  uint16(1344),
	507:  uint16(1344),
	508:  uint16(1344),
	509:  uint16(1344),
	510:  uint16(1344),
	511:  uint16(1344),
	512:  uint16(1344),
	513:  uint16(1344),
	514:  uint16(1344),
	515:  uint16(1344),
	516:  uint16(1344),
	517:  uint16(1344),
	518:  uint16(1344),
	519:  uint16(1344),
	520:  uint16(1344),
	521:  uint16(1344),
	522:  uint16(1344),
	523:  uint16(1344),
	524:  uint16(1344),
	525:  uint16(1344),
	526:  uint16(1344),
	527:  uint16(1344),
	528:  uint16(1344),
	529:  uint16(1344),
	530:  uint16(1344),
	531:  uint16(1344),
	532:  uint16(1344),
	533:  uint16(1344),
	534:  uint16(1344),
	535:  uint16(1344),
	536:  uint16(1344),
	537:  uint16(1344),
	538:  uint16(1344),
	539:  uint16(1344),
	540:  uint16(1344),
	541:  uint16(1344),
	542:  uint16(1344),
	543:  uint16(1344),
	544:  uint16(1344),
	545:  uint16(1344),
	546:  uint16(1344),
	547:  uint16(1344),
	548:  uint16(1344),
	549:  uint16(1344),
	550:  uint16(1344),
	551:  uint16(1344),
	552:  uint16(1344),
	553:  uint16(1344),
	554:  uint16(1344),
	555:  uint16(1344),
	556:  uint16(1344),
	557:  uint16(1344),
	558:  uint16(1344),
	559:  uint16(1344),
	560:  uint16(1344),
	561:  uint16(1344),
	562:  uint16(1344),
	563:  uint16(1344),
	564:  uint16(1344),
	565:  uint16(1344),
	566:  uint16(1344),
	567:  uint16(1344),
	568:  uint16(1344),
	569:  uint16(1344),
	570:  uint16(1344),
	571:  uint16(1344),
	572:  uint16(1344),
	573:  uint16(1344),
	574:  uint16(1344),
	575:  uint16(1344),
	576:  uint16(1344),
	577:  uint16(1344),
	578:  uint16(1344),
	579:  uint16(1344),
	580:  uint16(1344),
	581:  uint16(1344),
	582:  uint16(1344),
	583:  uint16(1344),
	584:  uint16(1344),
	585:  uint16(1344),
	586:  uint16(1344),
	587:  uint16(1344),
	588:  uint16(1344),
	589:  uint16(1344),
	590:  uint16(1344),
	591:  uint16(1344),
	592:  uint16(1344),
	593:  uint16(1344),
	594:  uint16(1344),
	595:  uint16(1344),
	596:  uint16(1344),
	597:  uint16(1344),
	598:  uint16(1344),
	599:  uint16(1344),
	600:  uint16(1344),
	601:  uint16(1344),
	602:  uint16(1344),
	603:  uint16(1344),
	604:  uint16(1344),
	605:  uint16(1344),
	606:  uint16(1344),
	607:  uint16(1344),
	608:  uint16(1344),
	609:  uint16(1344),
	610:  uint16(1344),
	611:  uint16(1344),
	612:  uint16(1344),
	613:  uint16(1344),
	614:  uint16(1344),
	615:  uint16(1344),
	616:  uint16(1344),
	617:  uint16(1344),
	618:  uint16(1344),
	619:  uint16(1344),
	620:  uint16(1344),
	621:  uint16(1344),
	622:  uint16(4928),
	623:  uint16(4928),
	624:  uint16(1344),
	625:  uint16(1344),
	626:  uint16(1344),
	627:  uint16(1344),
	628:  uint16(1344),
	629:  uint16(1344),
	630:  uint16(1344),
	631:  uint16(1344),
	632:  uint16(1344),
	633:  uint16(1344),
	634:  uint16(1344),
	635:  uint16(1344),
	636:  uint16(1344),
	637:  uint16(1344),
	638:  uint16(1344),
	639:  uint16(1344),
	640:  uint16(1344),
	641:  uint16(1344),
	642:  uint16(1344),
	643:  uint16(1344),
	644:  uint16(1344),
	645:  uint16(1344),
	646:  uint16(1344),
	647:  uint16(1344),
	648:  uint16(1344),
	649:  uint16(1344),
	650:  uint16(1344),
	651:  uint16(1344),
	652:  uint16(1344),
	653:  uint16(1344),
	654:  uint16(1344),
	655:  uint16(1344),
	656:  uint16(1344),
	657:  uint16(1344),
	658:  uint16(1344),
	659:  uint16(1344),
	660:  uint16(1344),
	661:  uint16(1344),
	662:  uint16(1344),
	663:  uint16(1344),
	664:  uint16(1344),
	665:  uint16(1344),
	666:  uint16(1344),
	667:  uint16(1344),
	668:  uint16(1344),
	669:  uint16(1344),
	670:  uint16(1344),
	671:  uint16(1344),
	672:  uint16(1344),
	673:  uint16(1344),
	674:  uint16(1344),
	675:  uint16(1344),
	676:  uint16(1344),
	677:  uint16(1344),
	678:  uint16(1344),
	679:  uint16(1344),
	680:  uint16(1344),
	681:  uint16(1344),
	682:  uint16(1344),
	683:  uint16(1344),
	684:  uint16(1344),
	685:  uint16(1344),
	686:  uint16(1344),
	687:  uint16(1344),
	688:  uint16(1344),
	689:  uint16(1344),
	690:  uint16(1344),
	691:  uint16(1344),
	692:  uint16(1344),
	693:  uint16(1344),
	694:  uint16(1344),
	695:  uint16(1344),
	696:  uint16(1344),
	697:  uint16(1344),
	698:  uint16(1344),
	699:  uint16(1344),
	700:  uint16(1344),
	701:  uint16(1344),
	702:  uint16(1344),
	703:  uint16(1344),
	704:  uint16(1344),
	705:  uint16(1344),
	706:  uint16(1344),
	707:  uint16(1344),
	708:  uint16(1344),
	709:  uint16(1344),
	710:  uint16(1344),
	711:  uint16(1344),
	712:  uint16(1344),
	713:  uint16(1344),
	714:  uint16(1344),
	715:  uint16(1344),
	716:  uint16(1344),
	717:  uint16(1344),
	718:  uint16(1344),
	719:  uint16(1344),
	720:  uint16(1344),
	721:  uint16(1344),
	722:  uint16(1344),
	723:  uint16(1344),
	724:  uint16(1344),
	725:  uint16(1344),
	726:  uint16(1344),
	727:  uint16(1344),
	728:  uint16(1344),
	729:  uint16(1344),
	730:  uint16(1344),
	731:  uint16(1344),
	732:  uint16(1344),
	733:  uint16(1344),
	734:  uint16(1344),
	735:  uint16(1344),
	736:  uint16(1344),
	737:  uint16(1344),
	738:  uint16(1344),
	739:  uint16(1344),
	740:  uint16(1344),
	741:  uint16(1344),
	742:  uint16(1344),
	743:  uint16(1344),
	744:  uint16(1344),
	745:  uint16(1344),
	746:  uint16(1344),
	747:  uint16(1344),
	748:  uint16(1344),
	749:  uint16(1344),
	750:  uint16(1344),
	751:  uint16(1344),
	752:  uint16(1344),
	753:  uint16(1344),
	754:  uint16(1344),
	755:  uint16(1344),
	756:  uint16(1344),
	757:  uint16(1344),
	758:  uint16(1344),
	759:  uint16(1344),
	760:  uint16(1344),
	761:  uint16(1344),
	762:  uint16(1344),
	763:  uint16(1344),
	764:  uint16(1344),
	765:  uint16(1344),
	766:  uint16(1344),
	767:  uint16(1344),
	768:  uint16(1344),
	769:  uint16(1344),
	770:  uint16(1344),
	771:  uint16(1344),
	772:  uint16(1344),
	773:  uint16(1344),
	774:  uint16(1344),
	775:  uint16(1344),
	776:  uint16(1344),
	777:  uint16(1344),
	778:  uint16(1344),
	779:  uint16(1344),
	780:  uint16(1344),
	781:  uint16(1344),
	782:  uint16(1344),
	783:  uint16(1344),
	784:  uint16(1344),
	785:  uint16(1344),
	786:  uint16(1344),
	787:  uint16(1344),
	788:  uint16(1344),
	789:  uint16(1344),
	790:  uint16(1344),
	791:  uint16(1344),
	792:  uint16(1344),
	793:  uint16(1344),
	794:  uint16(1344),
	795:  uint16(1344),
	796:  uint16(1344),
	797:  uint16(1344),
	798:  uint16(1344),
	799:  uint16(1344),
	800:  uint16(1344),
	801:  uint16(1344),
	802:  uint16(1344),
	803:  uint16(1344),
	804:  uint16(1344),
	805:  uint16(1344),
	806:  uint16(1344),
	807:  uint16(1344),
	808:  uint16(1344),
	809:  uint16(1344),
	810:  uint16(1344),
	811:  uint16(1344),
	812:  uint16(1344),
	813:  uint16(1344),
	814:  uint16(1344),
	815:  uint16(1344),
	816:  uint16(1344),
	817:  uint16(1344),
	818:  uint16(1344),
	819:  uint16(1344),
	820:  uint16(1344),
	821:  uint16(1344),
	822:  uint16(1344),
	823:  uint16(1344),
	824:  uint16(1344),
	825:  uint16(1344),
	826:  uint16(1344),
	827:  uint16(1344),
	828:  uint16(1344),
	829:  uint16(1344),
	830:  uint16(1344),
	831:  uint16(1344),
	832:  uint16(1344),
	833:  uint16(1344),
	834:  uint16(1344),
	835:  uint16(1344),
	836:  uint16(1344),
	837:  uint16(1344),
	838:  uint16(1344),
	839:  uint16(1344),
	840:  uint16(1344),
	841:  uint16(1344),
	842:  uint16(1344),
	843:  uint16(1344),
	844:  uint16(1344),
	845:  uint16(1344),
	846:  uint16(1344),
	847:  uint16(1344),
	848:  uint16(1344),
	849:  uint16(1344),
	850:  uint16(1344),
	851:  uint16(1344),
	852:  uint16(1344),
	853:  uint16(1344),
	854:  uint16(1344),
	855:  uint16(1344),
	856:  uint16(1344),
	857:  uint16(1344),
	858:  uint16(1344),
	859:  uint16(1344),
	860:  uint16(1344),
	861:  uint16(1344),
	862:  uint16(1344),
	863:  uint16(1344),
	864:  uint16(1344),
	865:  uint16(1344),
	866:  uint16(1344),
	867:  uint16(1344),
	868:  uint16(1344),
	869:  uint16(1344),
	870:  uint16(1344),
	871:  uint16(1344),
	872:  uint16(1344),
	873:  uint16(1344),
	874:  uint16(1344),
	875:  uint16(1344),
	876:  uint16(1344),
	877:  uint16(1344),
	878:  uint16(1344),
	879:  uint16(1344),
	880:  uint16(1344),
	881:  uint16(1344),
	882:  uint16(1344),
	883:  uint16(1344),
	884:  uint16(1344),
	885:  uint16(1344),
	886:  uint16(1344),
	887:  uint16(1344),
	888:  uint16(1344),
	889:  uint16(1344),
	890:  uint16(1344),
	891:  uint16(1344),
	892:  uint16(1344),
	893:  uint16(1344),
	894:  uint16(1344),
	895:  uint16(1344),
	896:  uint16(1344),
	897:  uint16(1344),
	898:  uint16(1344),
	899:  uint16(1344),
	900:  uint16(1344),
	901:  uint16(1344),
	902:  uint16(1344),
	903:  uint16(1344),
	904:  uint16(1344),
	905:  uint16(1344),
	906:  uint16(1344),
	907:  uint16(1344),
	908:  uint16(1344),
	909:  uint16(1344),
	910:  uint16(1344),
	911:  uint16(1344),
	912:  uint16(1344),
	913:  uint16(1344),
	914:  uint16(1344),
	915:  uint16(1344),
	916:  uint16(1344),
	917:  uint16(1344),
	918:  uint16(1344),
	919:  uint16(1344),
	920:  uint16(1344),
	921:  uint16(1344),
	922:  uint16(1344),
	923:  uint16(1344),
	924:  uint16(1344),
	925:  uint16(1344),
	926:  uint16(1344),
	927:  uint16(1344),
	928:  uint16(1344),
	929:  uint16(1344),
	930:  uint16(1344),
	931:  uint16(1344),
	932:  uint16(1344),
	933:  uint16(1344),
	934:  uint16(1344),
	935:  uint16(1344),
	936:  uint16(1344),
	937:  uint16(1344),
	938:  uint16(1344),
	939:  uint16(1344),
	940:  uint16(1344),
	941:  uint16(1344),
	942:  uint16(1344),
	943:  uint16(1344),
	944:  uint16(1344),
	945:  uint16(1344),
	946:  uint16(1344),
	947:  uint16(1344),
	948:  uint16(1344),
	949:  uint16(1344),
	950:  uint16(1344),
	951:  uint16(1344),
	952:  uint16(1344),
	953:  uint16(1344),
	954:  uint16(1344),
	955:  uint16(1344),
	956:  uint16(1344),
	957:  uint16(1344),
	958:  uint16(1344),
	959:  uint16(1344),
	960:  uint16(1344),
	961:  uint16(1344),
	962:  uint16(1344),
	963:  uint16(1344),
	964:  uint16(1344),
	965:  uint16(1344),
	966:  uint16(1344),
	967:  uint16(1344),
	968:  uint16(1344),
	969:  uint16(1344),
	970:  uint16(1344),
	971:  uint16(1344),
	972:  uint16(1344),
	973:  uint16(1344),
	974:  uint16(1344),
	975:  uint16(1344),
	976:  uint16(1344),
	977:  uint16(1344),
	978:  uint16(1344),
	979:  uint16(1344),
	980:  uint16(1344),
	981:  uint16(1344),
	982:  uint16(1344),
	983:  uint16(1344),
	984:  uint16(1344),
	985:  uint16(1344),
	986:  uint16(1344),
	987:  uint16(1344),
	988:  uint16(1344),
	989:  uint16(1344),
	990:  uint16(1344),
	991:  uint16(1344),
	992:  uint16(1344),
	993:  uint16(1344),
	994:  uint16(1344),
	995:  uint16(1344),
	996:  uint16(1344),
	997:  uint16(1344),
	998:  uint16(1344),
	999:  uint16(1344),
	1000: uint16(1344),
	1001: uint16(1344),
	1002: uint16(1344),
	1003: uint16(1344),
	1004: uint16(1344),
	1005: uint16(1344),
	1006: uint16(1344),
	1007: uint16(1344),
	1008: uint16(1344),
	1009: uint16(1344),
	1010: uint16(1344),
	1011: uint16(1344),
	1012: uint16(1344),
	1013: uint16(1344),
	1014: uint16(1344),
	1015: uint16(1344),
	1016: uint16(1344),
	1017: uint16(1344),
	1018: uint16(1344),
	1019: uint16(1344),
	1020: uint16(1344),
	1021: uint16(1344),
	1022: uint16(1344),
	1023: uint16(1344),
	1024: uint16(1344),
	1025: uint16(1344),
	1026: uint16(1344),
	1027: uint16(1344),
	1028: uint16(1344),
	1029: uint16(1344),
	1030: uint16(1344),
	1031: uint16(1344),
	1032: uint16(1344),
	1033: uint16(1344),
	1034: uint16(1344),
	1035: uint16(1344),
	1036: uint16(1344),
	1037: uint16(1344),
	1038: uint16(1344),
	1039: uint16(1344),
	1040: uint16(1344),
	1041: uint16(1344),
	1042: uint16(1344),
	1043: uint16(1344),
	1044: uint16(1344),
	1045: uint16(1344),
	1046: uint16(1344),
	1047: uint16(1344),
	1048: uint16(1344),
	1049: uint16(1344),
	1050: uint16(1344),
	1051: uint16(1344),
	1052: uint16(1344),
	1053: uint16(1344),
	1054: uint16(1344),
	1055: uint16(1344),
	1056: uint16(1344),
	1057: uint16(1344),
	1058: uint16(1344),
	1059: uint16(1344),
	1060: uint16(1344),
	1061: uint16(1344),
	1062: uint16(1344),
	1063: uint16(1344),
	1064: uint16(1344),
	1065: uint16(1344),
	1066: uint16(1344),
	1067: uint16(1344),
	1068: uint16(1344),
	1069: uint16(1344),
	1070: uint16(1344),
	1071: uint16(1344),
	1072: uint16(1344),
	1073: uint16(1344),
	1074: uint16(1344),
	1075: uint16(1344),
	1076: uint16(1344),
	1077: uint16(1344),
	1078: uint16(1344),
	1079: uint16(1344),
	1080: uint16(1344),
	1081: uint16(1344),
	1082: uint16(1344),
	1083: uint16(1344),
	1084: uint16(1344),
	1085: uint16(1344),
	1086: uint16(1344),
	1087: uint16(1344),
	1088: uint16(1344),
	1089: uint16(1344),
	1090: uint16(1344),
	1091: uint16(1344),
	1092: uint16(1344),
	1093: uint16(1344),
	1094: uint16(1344),
	1095: uint16(1344),
	1096: uint16(1344),
	1097: uint16(1344),
	1098: uint16(1344),
	1099: uint16(1344),
	1100: uint16(1344),
	1101: uint16(1344),
	1102: uint16(1344),
	1103: uint16(1344),
	1104: uint16(1344),
	1105: uint16(1344),
	1106: uint16(1344),
	1107: uint16(1344),
	1108: uint16(1344),
	1109: uint16(1344),
	1110: uint16(1344),
	1111: uint16(1344),
	1112: uint16(1344),
	1113: uint16(1344),
	1114: uint16(1344),
	1115: uint16(1344),
	1116: uint16(1344),
	1117: uint16(1344),
	1118: uint16(1344),
	1119: uint16(1344),
	1120: uint16(1344),
	1121: uint16(1344),
	1122: uint16(1344),
	1123: uint16(1344),
	1124: uint16(1344),
	1125: uint16(1344),
	1126: uint16(1344),
	1127: uint16(1344),
	1128: uint16(1344),
	1129: uint16(1344),
	1130: uint16(1344),
	1131: uint16(1344),
	1132: uint16(1344),
	1133: uint16(1344),
	1134: uint16(1344),
	1135: uint16(1344),
	1136: uint16(1344),
	1137: uint16(1344),
	1138: uint16(1344),
	1139: uint16(1344),
	1140: uint16(1344),
	1141: uint16(1344),
	1142: uint16(1344),
	1143: uint16(1344),
	1144: uint16(1344),
	1145: uint16(1344),
	1146: uint16(1344),
	1147: uint16(1344),
	1148: uint16(1344),
	1149: uint16(1344),
	1150: uint16(1344),
	1151: uint16(1344),
	1152: uint16(1344),
	1153: uint16(1344),
	1154: uint16(1344),
	1155: uint16(1344),
	1156: uint16(1344),
	1157: uint16(1344),
	1158: uint16(1344),
	1159: uint16(1344),
	1160: uint16(1344),
	1161: uint16(1344),
	1162: uint16(1344),
	1163: uint16(1344),
	1164: uint16(1344),
	1165: uint16(1344),
	1166: uint16(1344),
	1167: uint16(1344),
	1168: uint16(1344),
	1169: uint16(1344),
	1170: uint16(1344),
	1171: uint16(1344),
	1172: uint16(1344),
	1173: uint16(1344),
	1174: uint16(1344),
	1175: uint16(1344),
	1176: uint16(1344),
	1177: uint16(1344),
	1178: uint16(1344),
	1179: uint16(1344),
	1180: uint16(1344),
	1181: uint16(1344),
	1182: uint16(1344),
	1183: uint16(1344),
	1184: uint16(1344),
	1185: uint16(1344),
	1186: uint16(1344),
	1187: uint16(1344),
	1188: uint16(1344),
	1189: uint16(1344),
	1190: uint16(1344),
	1191: uint16(1344),
	1192: uint16(1344),
	1193: uint16(1344),
	1194: uint16(1344),
	1195: uint16(1344),
	1196: uint16(1344),
	1197: uint16(1344),
	1198: uint16(1344),
	1199: uint16(1344),
	1200: uint16(1344),
	1201: uint16(1344),
	1202: uint16(1344),
	1203: uint16(1344),
	1204: uint16(1344),
	1205: uint16(1344),
	1206: uint16(1344),
	1207: uint16(1344),
	1208: uint16(1344),
	1209: uint16(1344),
	1210: uint16(1344),
	1211: uint16(1344),
	1212: uint16(1344),
	1213: uint16(1344),
	1214: uint16(1344),
	1215: uint16(1344),
	1216: uint16(1344),
	1217: uint16(1344),
	1218: uint16(1344),
	1219: uint16(1344),
	1220: uint16(1344),
	1221: uint16(1344),
	1222: uint16(1344),
	1223: uint16(1344),
	1224: uint16(1344),
	1225: uint16(1344),
	1226: uint16(1344),
	1227: uint16(1344),
	1228: uint16(1344),
	1229: uint16(1344),
	1230: uint16(1344),
	1231: uint16(1344),
	1232: uint16(1344),
	1233: uint16(1344),
	1234: uint16(1344),
	1235: uint16(1344),
	1236: uint16(1344),
	1237: uint16(1344),
	1238: uint16(1344),
	1239: uint16(1344),
	1240: uint16(1344),
	1241: uint16(1344),
	1242: uint16(1344),
	1243: uint16(1344),
	1244: uint16(1344),
	1245: uint16(1344),
	1246: uint16(1344),
	1247: uint16(1344),
	1248: uint16(1344),
	1249: uint16(1344),
	1250: uint16(1344),
	1251: uint16(1344),
	1252: uint16(1344),
	1253: uint16(1344),
	1254: uint16(1344),
	1255: uint16(1344),
	1256: uint16(1344),
	1257: uint16(1344),
	1258: uint16(1344),
	1259: uint16(1344),
	1260: uint16(1344),
	1261: uint16(1344),
	1262: uint16(1344),
	1263: uint16(1344),
	1264: uint16(1344),
	1265: uint16(1344),
	1266: uint16(1344),
	1267: uint16(1344),
	1268: uint16(1344),
	1269: uint16(1344),
	1270: uint16(1344),
	1271: uint16(1344),
	1272: uint16(1344),
	1273: uint16(1344),
	1274: uint16(1344),
	1275: uint16(1344),
	1276: uint16(1344),
	1277: uint16(1344),
	1278: uint16(1344),
	1279: uint16(1344),
	1280: uint16(8448),
	1281: uint16(1344),
	1282: uint16(1344),
	1283: uint16(1344),
	1284: uint16(1344),
	1285: uint16(1344),
	1286: uint16(1344),
	1287: uint16(1344),
	1288: uint16(1344),
	1289: uint16(1344),
	1290: uint16(1344),
	1291: uint16(1344),
	1292: uint16(1344),
	1293: uint16(1344),
	1294: uint16(1344),
	1295: uint16(1344),
	1296: uint16(1344),
	1297: uint16(1344),
	1298: uint16(1344),
	1299: uint16(1344),
	1300: uint16(1344),
	1301: uint16(1344),
	1302: uint16(1344),
	1303: uint16(1344),
	1304: uint16(1344),
	1305: uint16(1344),
	1306: uint16(1344),
	1307: uint16(1344),
	1308: uint16(1344),
	1309: uint16(1344),
	1310: uint16(1344),
	1311: uint16(1344),
	1312: uint16(1344),
	1313: uint16(1344),
	1314: uint16(1344),
	1315: uint16(1344),
	1316: uint16(8480),
	1317: uint16(4928),
	1318: uint16(8512),
	1319: uint16(5440),
	1320: uint16(1344),
	1321: uint16(1344),
	1322: uint16(1344),
	1323: uint16(1344),
	1324: uint16(1344),
	1325: uint16(1344),
	1326: uint16(1344),
	1327: uint16(1344),
	1328: uint16(8544),
	1329: uint16(8576),
	1330: uint16(224),
	1331: uint16(8608),
	1332: uint16(8640),
	1333: uint16(1344),
	1334: uint16(1344),
	1335: uint16(8672),
	1336: uint16(8704),
	1337: uint16(8736),
	1338: uint16(224),
	1339: uint16(8768),
	1340: uint16(8800),
	1341: uint16(8832),
	1342: uint16(8864),
	1343: uint16(8896),
	1344: uint16(8928),
	1345: uint16(8960),
	1346: uint16(1344),
	1347: uint16(8992),
	1348: uint16(9024),
	1349: uint16(9056),
	1350: uint16(9088),
	1351: uint16(9120),
	1352: uint16(1632),
	1353: uint16(9152),
	1354: uint16(9184),
	1355: uint16(9216),
	1356: uint16(1920),
	1357: uint16(9248),
	1358: uint16(9280),
	1359: uint16(9312),
	1360: uint16(1344),
	1361: uint16(9344),
	1362: uint16(9376),
	1363: uint16(9408),
	1364: uint16(1344),
	1365: uint16(9440),
	1366: uint16(9472),
	1367: uint16(9504),
	1368: uint16(9536),
	1369: uint16(9568),
	1370: uint16(9600),
	1371: uint16(9632),
	1372: uint16(9664),
	1373: uint16(9664),
	1374: uint16(1344),
	1375: uint16(9696),
	1376: uint16(1344),
	1377: uint16(1344),
	1378: uint16(1344),
	1379: uint16(1344),
	1380: uint16(1344),
	1381: uint16(1344),
	1382: uint16(1344),
	1383: uint16(1344),
	1384: uint16(1344),
	1385: uint16(1344),
	1386: uint16(1344),
	1387: uint16(1344),
	1388: uint16(1344),
	1389: uint16(1344),
	1390: uint16(1344),
	1391: uint16(1344),
	1392: uint16(1344),
	1393: uint16(1344),
	1394: uint16(1344),
	1395: uint16(1344),
	1396: uint16(1344),
	1397: uint16(1344),
	1398: uint16(1344),
	1399: uint16(1344),
	1400: uint16(1344),
	1401: uint16(1344),
	1402: uint16(1344),
	1403: uint16(1344),
	1404: uint16(1344),
	1405: uint16(1344),
	1406: uint16(1344),
	1407: uint16(1344),
	1408: uint16(1344),
	1409: uint16(1344),
	1410: uint16(1344),
	1411: uint16(1344),
	1412: uint16(1344),
	1413: uint16(1344),
	1414: uint16(1344),
	1415: uint16(1344),
	1416: uint16(1344),
	1417: uint16(1344),
	1418: uint16(1344),
	1419: uint16(1344),
	1420: uint16(1344),
	1421: uint16(1344),
	1422: uint16(1344),
	1423: uint16(1344),
	1424: uint16(1344),
	1425: uint16(1344),
	1426: uint16(1344),
	1427: uint16(1344),
	1428: uint16(1344),
	1429: uint16(1344),
	1430: uint16(1344),
	1431: uint16(1344),
	1432: uint16(1344),
	1433: uint16(1344),
	1434: uint16(1344),
	1435: uint16(1344),
	1436: uint16(1344),
	1437: uint16(1344),
	1438: uint16(1344),
	1439: uint16(1344),
	1440: uint16(1344),
	1441: uint16(1344),
	1442: uint16(1344),
	1443: uint16(1344),
	1444: uint16(1344),
	1445: uint16(1344),
	1446: uint16(1344),
	1447: uint16(1344),
	1448: uint16(1344),
	1449: uint16(1344),
	1450: uint16(1344),
	1451: uint16(1344),
	1452: uint16(1344),
	1453: uint16(1344),
	1454: uint16(1344),
	1455: uint16(1344),
	1456: uint16(1344),
	1457: uint16(1344),
	1458: uint16(1344),
	1459: uint16(1344),
	1460: uint16(1344),
	1461: uint16(1344),
	1462: uint16(1344),
	1463: uint16(1344),
	1464: uint16(1344),
	1465: uint16(1344),
	1466: uint16(1344),
	1467: uint16(1344),
	1468: uint16(1344),
	1469: uint16(1344),
	1470: uint16(1344),
	1471: uint16(1344),
	1472: uint16(1344),
	1473: uint16(1344),
	1474: uint16(1344),
	1475: uint16(1344),
	1476: uint16(1344),
	1477: uint16(1344),
	1478: uint16(1344),
	1479: uint16(1344),
	1480: uint16(1344),
	1481: uint16(1344),
	1482: uint16(1344),
	1483: uint16(1344),
	1484: uint16(1344),
	1485: uint16(1344),
	1486: uint16(1344),
	1487: uint16(1344),
	1488: uint16(1344),
	1489: uint16(1344),
	1490: uint16(1344),
	1491: uint16(1344),
	1492: uint16(1344),
	1493: uint16(1344),
	1494: uint16(1344),
	1495: uint16(1344),
	1496: uint16(1344),
	1497: uint16(1344),
	1498: uint16(1344),
	1499: uint16(1344),
	1500: uint16(1344),
	1501: uint16(1344),
	1502: uint16(1344),
	1503: uint16(1344),
	1504: uint16(1344),
	1505: uint16(1344),
	1506: uint16(1344),
	1507: uint16(1344),
	1508: uint16(1344),
	1509: uint16(1344),
	1510: uint16(1344),
	1511: uint16(1344),
	1512: uint16(1344),
	1513: uint16(1344),
	1514: uint16(1344),
	1515: uint16(1344),
	1516: uint16(1344),
	1517: uint16(1344),
	1518: uint16(1344),
	1519: uint16(1344),
	1520: uint16(1344),
	1521: uint16(1344),
	1522: uint16(1344),
	1523: uint16(1344),
	1524: uint16(1344),
	1525: uint16(1344),
	1526: uint16(1344),
	1527: uint16(1344),
	1528: uint16(1344),
	1529: uint16(1344),
	1530: uint16(1344),
	1531: uint16(1344),
	1532: uint16(1344),
	1533: uint16(1344),
	1534: uint16(1344),
	1535: uint16(1344),
	1536: uint16(1344),
	1537: uint16(1344),
	1538: uint16(1344),
	1539: uint16(1344),
	1540: uint16(1344),
	1541: uint16(1344),
	1542: uint16(1344),
	1543: uint16(1344),
	1544: uint16(1344),
	1545: uint16(1344),
	1546: uint16(1344),
	1547: uint16(1344),
	1548: uint16(1344),
	1549: uint16(1344),
	1550: uint16(1344),
	1551: uint16(1344),
	1552: uint16(1344),
	1553: uint16(1344),
	1554: uint16(1344),
	1555: uint16(1344),
	1556: uint16(1344),
	1557: uint16(1344),
	1558: uint16(1344),
	1559: uint16(1344),
	1560: uint16(1344),
	1561: uint16(1344),
	1562: uint16(1344),
	1563: uint16(1344),
	1564: uint16(1344),
	1565: uint16(1344),
	1566: uint16(1344),
	1567: uint16(1344),
	1568: uint16(1344),
	1569: uint16(1344),
	1570: uint16(1344),
	1571: uint16(1344),
	1572: uint16(1344),
	1573: uint16(1344),
	1574: uint16(1344),
	1575: uint16(1344),
	1576: uint16(1344),
	1577: uint16(1344),
	1578: uint16(1344),
	1579: uint16(1344),
	1580: uint16(1344),
	1581: uint16(1344),
	1582: uint16(1344),
	1583: uint16(1344),
	1584: uint16(1344),
	1585: uint16(1344),
	1586: uint16(1344),
	1587: uint16(1344),
	1588: uint16(1344),
	1589: uint16(1344),
	1590: uint16(1344),
	1591: uint16(1344),
	1592: uint16(1344),
	1593: uint16(1344),
	1594: uint16(1344),
	1595: uint16(1344),
	1596: uint16(1344),
	1597: uint16(1344),
	1598: uint16(1344),
	1599: uint16(1344),
	1600: uint16(1344),
	1601: uint16(1344),
	1602: uint16(1344),
	1603: uint16(1344),
	1604: uint16(1344),
	1605: uint16(1344),
	1606: uint16(1344),
	1607: uint16(1344),
	1608: uint16(1344),
	1609: uint16(1344),
	1610: uint16(1344),
	1611: uint16(1344),
	1612: uint16(1344),
	1613: uint16(1344),
	1614: uint16(1344),
	1615: uint16(1344),
	1616: uint16(1344),
	1617: uint16(1344),
	1618: uint16(1344),
	1619: uint16(1344),
	1620: uint16(1344),
	1621: uint16(1344),
	1622: uint16(1344),
	1623: uint16(1344),
	1624: uint16(1344),
	1625: uint16(1344),
	1626: uint16(1344),
	1627: uint16(1344),
	1628: uint16(1344),
	1629: uint16(1344),
	1630: uint16(1344),
	1631: uint16(1344),
	1632: uint16(1344),
	1633: uint16(1344),
	1634: uint16(1344),
	1635: uint16(1344),
	1636: uint16(1344),
	1637: uint16(1344),
	1638: uint16(1344),
	1639: uint16(1344),
	1640: uint16(1344),
	1641: uint16(1344),
	1642: uint16(1344),
	1643: uint16(1344),
	1644: uint16(1344),
	1645: uint16(1344),
	1646: uint16(1344),
	1647: uint16(1344),
	1648: uint16(1344),
	1649: uint16(1344),
	1650: uint16(1344),
	1651: uint16(1344),
	1652: uint16(1344),
	1653: uint16(1344),
	1654: uint16(1344),
	1655: uint16(1344),
	1656: uint16(1344),
	1657: uint16(1344),
	1658: uint16(1344),
	1659: uint16(1344),
	1660: uint16(1344),
	1661: uint16(1344),
	1662: uint16(1344),
	1663: uint16(1344),
	1664: uint16(1344),
	1665: uint16(1344),
	1666: uint16(1344),
	1667: uint16(1344),
	1668: uint16(1344),
	1669: uint16(1344),
	1670: uint16(1344),
	1671: uint16(1344),
	1672: uint16(1344),
	1673: uint16(1344),
	1674: uint16(1344),
	1675: uint16(1344),
	1676: uint16(1344),
	1677: uint16(1344),
	1678: uint16(1344),
	1679: uint16(1344),
	1680: uint16(1344),
	1681: uint16(1344),
	1682: uint16(1344),
	1683: uint16(1344),
	1684: uint16(1344),
	1685: uint16(1344),
	1686: uint16(1344),
	1687: uint16(1344),
	1688: uint16(1344),
	1689: uint16(1344),
	1690: uint16(1344),
	1691: uint16(1344),
	1692: uint16(1344),
	1693: uint16(1344),
	1694: uint16(1344),
	1695: uint16(1344),
	1696: uint16(1344),
	1697: uint16(1344),
	1698: uint16(1344),
	1699: uint16(1344),
	1700: uint16(1344),
	1701: uint16(1344),
	1702: uint16(1344),
	1703: uint16(1344),
	1704: uint16(1344),
	1705: uint16(1344),
	1706: uint16(1344),
	1707: uint16(1344),
	1708: uint16(1344),
	1709: uint16(1344),
	1710: uint16(1344),
	1711: uint16(1344),
	1712: uint16(1344),
	1713: uint16(1344),
	1714: uint16(1344),
	1715: uint16(1344),
	1716: uint16(1344),
	1717: uint16(1344),
	1718: uint16(1344),
	1719: uint16(1344),
	1720: uint16(1344),
	1721: uint16(1344),
	1722: uint16(1344),
	1723: uint16(1344),
	1724: uint16(1344),
	1725: uint16(9728),
	1726: uint16(9760),
	1727: uint16(9792),
	1728: uint16(9824),
	1729: uint16(9824),
	1730: uint16(9824),
	1731: uint16(9824),
	1732: uint16(9824),
	1733: uint16(9824),
	1734: uint16(9824),
	1735: uint16(9824),
	1736: uint16(9824),
	1737: uint16(9824),
	1738: uint16(9824),
	1739: uint16(9824),
	1740: uint16(9824),
	1741: uint16(9824),
	1742: uint16(9824),
	1743: uint16(9824),
	1744: uint16(9824),
	1745: uint16(9824),
	1746: uint16(9824),
	1747: uint16(9824),
	1748: uint16(9824),
	1749: uint16(9824),
	1750: uint16(9824),
	1751: uint16(9824),
	1752: uint16(9824),
	1753: uint16(9824),
	1754: uint16(9824),
	1755: uint16(9824),
	1756: uint16(9824),
	1757: uint16(9824),
	1758: uint16(9824),
	1759: uint16(9824),
	1760: uint16(9824),
	1761: uint16(9824),
	1762: uint16(9824),
	1763: uint16(9824),
	1764: uint16(9824),
	1765: uint16(9824),
	1766: uint16(9824),
	1767: uint16(9824),
	1768: uint16(9824),
	1769: uint16(9824),
	1770: uint16(9824),
	1771: uint16(9824),
	1772: uint16(9824),
	1773: uint16(9824),
	1774: uint16(9824),
	1775: uint16(9824),
	1776: uint16(9824),
	1777: uint16(9824),
	1778: uint16(9824),
	1779: uint16(9824),
	1780: uint16(9824),
	1781: uint16(9824),
	1782: uint16(9824),
	1783: uint16(9824),
	1784: uint16(9824),
	1785: uint16(9824),
	1786: uint16(9824),
	1787: uint16(9824),
	1788: uint16(9824),
	1789: uint16(9824),
	1790: uint16(9824),
	1791: uint16(9824),
	1792: uint16(9856),
	1793: uint16(9856),
	1794: uint16(9856),
	1795: uint16(9856),
	1796: uint16(9856),
	1797: uint16(9856),
	1798: uint16(9856),
	1799: uint16(9856),
	1800: uint16(9856),
	1801: uint16(9856),
	1802: uint16(9856),
	1803: uint16(9856),
	1804: uint16(9856),
	1805: uint16(9856),
	1806: uint16(9856),
	1807: uint16(9856),
	1808: uint16(9856),
	1809: uint16(9856),
	1810: uint16(9856),
	1811: uint16(9856),
	1812: uint16(9856),
	1813: uint16(9856),
	1814: uint16(9856),
	1815: uint16(9856),
	1816: uint16(9856),
	1817: uint16(9856),
	1818: uint16(9856),
	1819: uint16(9856),
	1820: uint16(9856),
	1821: uint16(9856),
	1822: uint16(9856),
	1823: uint16(9856),
	1824: uint16(9856),
	1825: uint16(9856),
	1826: uint16(9856),
	1827: uint16(9856),
	1828: uint16(9856),
	1829: uint16(9856),
	1830: uint16(9856),
	1831: uint16(9856),
	1832: uint16(9856),
	1833: uint16(9856),
	1834: uint16(9856),
	1835: uint16(9856),
	1836: uint16(9856),
	1837: uint16(9856),
	1838: uint16(9856),
	1839: uint16(9856),
	1840: uint16(9856),
	1841: uint16(9856),
	1842: uint16(9856),
	1843: uint16(9856),
	1844: uint16(9856),
	1845: uint16(9856),
	1846: uint16(9856),
	1847: uint16(9856),
	1848: uint16(9856),
	1849: uint16(9856),
	1850: uint16(9856),
	1851: uint16(9856),
	1852: uint16(9856),
	1853: uint16(9856),
	1854: uint16(9856),
	1855: uint16(9856),
	1856: uint16(9856),
	1857: uint16(9856),
	1858: uint16(9856),
	1859: uint16(9856),
	1860: uint16(9856),
	1861: uint16(9856),
	1862: uint16(9856),
	1863: uint16(9856),
	1864: uint16(9856),
	1865: uint16(9856),
	1866: uint16(9856),
	1867: uint16(9856),
	1868: uint16(9856),
	1869: uint16(9856),
	1870: uint16(9856),
	1871: uint16(9856),
	1872: uint16(9856),
	1873: uint16(9856),
	1874: uint16(9856),
	1875: uint16(9856),
	1876: uint16(9856),
	1877: uint16(9856),
	1878: uint16(9856),
	1879: uint16(9856),
	1880: uint16(9856),
	1881: uint16(9856),
	1882: uint16(9856),
	1883: uint16(9856),
	1884: uint16(9856),
	1885: uint16(9856),
	1886: uint16(9856),
	1887: uint16(9856),
	1888: uint16(9856),
	1889: uint16(9856),
	1890: uint16(9856),
	1891: uint16(9856),
	1892: uint16(9856),
	1893: uint16(9856),
	1894: uint16(9856),
	1895: uint16(9856),
	1896: uint16(9856),
	1897: uint16(9856),
	1898: uint16(9856),
	1899: uint16(9856),
	1900: uint16(9856),
	1901: uint16(9856),
	1902: uint16(9856),
	1903: uint16(9856),
	1904: uint16(9856),
	1905: uint16(9856),
	1906: uint16(9856),
	1907: uint16(9856),
	1908: uint16(9856),
	1909: uint16(9856),
	1910: uint16(9856),
	1911: uint16(9856),
	1912: uint16(9856),
	1913: uint16(9856),
	1914: uint16(9856),
	1915: uint16(9856),
	1916: uint16(9856),
	1917: uint16(9856),
	1918: uint16(9856),
	1919: uint16(9856),
	1920: uint16(9856),
	1921: uint16(9856),
	1922: uint16(9856),
	1923: uint16(9856),
	1924: uint16(9856),
	1925: uint16(9856),
	1926: uint16(9856),
	1927: uint16(9856),
	1928: uint16(9856),
	1929: uint16(9856),
	1930: uint16(9856),
	1931: uint16(9856),
	1932: uint16(9856),
	1933: uint16(9856),
	1934: uint16(9856),
	1935: uint16(9856),
	1936: uint16(9856),
	1937: uint16(9856),
	1938: uint16(9856),
	1939: uint16(9856),
	1940: uint16(9856),
	1941: uint16(9856),
	1942: uint16(9856),
	1943: uint16(9856),
	1944: uint16(9856),
	1945: uint16(9856),
	1946: uint16(9856),
	1947: uint16(9856),
	1948: uint16(9856),
	1949: uint16(9856),
	1950: uint16(9856),
	1951: uint16(9856),
	1952: uint16(9856),
	1953: uint16(9856),
	1954: uint16(9856),
	1955: uint16(9856),
	1956: uint16(9856),
	1957: uint16(9856),
	1958: uint16(9856),
	1959: uint16(9856),
	1960: uint16(9856),
	1961: uint16(9856),
	1962: uint16(9856),
	1963: uint16(9856),
	1964: uint16(9856),
	1965: uint16(9856),
	1966: uint16(9856),
	1967: uint16(9856),
	1968: uint16(9856),
	1969: uint16(9856),
	1970: uint16(9856),
	1971: uint16(9856),
	1972: uint16(9856),
	1973: uint16(9856),
	1974: uint16(9856),
	1975: uint16(9856),
	1976: uint16(9856),
	1977: uint16(9856),
	1978: uint16(9856),
	1979: uint16(9856),
	1980: uint16(9856),
	1981: uint16(9856),
	1982: uint16(9856),
	1983: uint16(9856),
	1984: uint16(9856),
	1985: uint16(9856),
	1986: uint16(9856),
	1987: uint16(9856),
	1988: uint16(9856),
	1989: uint16(9856),
	1990: uint16(9856),
	1991: uint16(9856),
	1992: uint16(1344),
	1993: uint16(1344),
	1994: uint16(1344),
	1995: uint16(1344),
	1996: uint16(1344),
	1997: uint16(1344),
	1998: uint16(1344),
	1999: uint16(1344),
	2000: uint16(1344),
	2001: uint16(1344),
	2002: uint16(1344),
	2003: uint16(9888),
	2004: uint16(1344),
	2005: uint16(1344),
	2006: uint16(9920),
	2007: uint16(3296),
	2008: uint16(9952),
	2009: uint16(9984),
	2010: uint16(10016),
	2011: uint16(1344),
	2012: uint16(1344),
	2013: uint16(10048),
	2014: uint16(10080),
	2015: uint16(1344),
	2016: uint16(1344),
	2017: uint16(1344),
	2018: uint16(1344),
	2019: uint16(1344),
	2020: uint16(1344),
	2021: uint16(1344),
	2022: uint16(1344),
	2023: uint16(1344),
	2024: uint16(1344),
	2025: uint16(10112),
	2026: uint16(10144),
	2027: uint16(1344),
	2028: uint16(10176),
	2029: uint16(1344),
	2030: uint16(10208),
	2031: uint16(10240),
	2032: uint16(10272),
	2033: uint16(10304),
	2034: uint16(10336),
	2035: uint16(10368),
	2036: uint16(1344),
	2037: uint16(1344),
	2038: uint16(1344),
	2039: uint16(10400),
	2040: uint16(10432),
	2041: uint16(64),
	2042: uint16(10464),
	2043: uint16(10496),
	2044: uint16(10528),
	2045: uint16(4736),
	2046: uint16(10560),
	2047: uint16(10592),
	2048: uint16(10624),
	2049: uint16(10656),
	2050: uint16(10688),
	2051: uint16(3296),
	2052: uint16(1344),
	2053: uint16(1344),
	2054: uint16(1344),
	2055: uint16(10720),
	2056: uint16(10752),
	2057: uint16(10784),
	2058: uint16(10816),
	2059: uint16(10848),
	2060: uint16(10880),
	2061: uint16(10912),
	2062: uint16(8032),
	2063: uint16(10944),
	2064: uint16(3296),
	2065: uint16(3296),
	2066: uint16(3296),
	2067: uint16(3296),
	2068: uint16(9216),
	2069: uint16(1344),
	2070: uint16(10976),
	2071: uint16(11008),
	2072: uint16(1344),
	2073: uint16(11040),
	2074: uint16(11072),
	2075: uint16(11104),
	2076: uint16(11136),
	2077: uint16(1344),
	2078: uint16(11168),
	2079: uint16(3296),
	2080: uint16(11200),
	2081: uint16(11232),
	2082: uint16(11264),
	2083: uint16(1344),
	2084: uint16(11296),
	2085: uint16(11328),
	2086: uint16(11360),
	2087: uint16(11392),
	2088: uint16(1344),
	2089: uint16(11424),
	2090: uint16(1344),
	2091: uint16(11456),
	2092: uint16(11488),
	2093: uint16(11520),
	2094: uint16(1344),
	2095: uint16(11552),
	2096: uint16(1344),
	2097: uint16(1344),
	2098: uint16(1344),
	2099: uint16(1344),
	2100: uint16(1344),
	2101: uint16(1344),
	2102: uint16(1344),
	2103: uint16(1344),
	2104: uint16(1344),
	2105: uint16(7776),
	2106: uint16(4704),
	2107: uint16(11584),
	2108: uint16(11616),
	2109: uint16(11648),
	2110: uint16(3296),
	2111: uint16(3296),
	2112: uint16(11680),
	2113: uint16(11712),
	2114: uint16(11744),
	2115: uint16(11776),
	2116: uint16(4736),
	2117: uint16(11808),
	2118: uint16(3296),
	2119: uint16(11840),
	2120: uint16(11872),
	2121: uint16(11904),
	2122: uint16(3296),
	2123: uint16(3296),
	2124: uint16(1344),
	2125: uint16(11936),
	2126: uint16(11968),
	2127: uint16(6880),
	2128: uint16(12000),
	2129: uint16(12032),
	2130: uint16(12064),
	2131: uint16(12096),
	2132: uint16(12128),
	2133: uint16(3296),
	2134: uint16(12160),
	2135: uint16(12192),
	2136: uint16(1344),
	2137: uint16(12224),
	2138: uint16(12256),
	2139: uint16(12288),
	2140: uint16(12320),
	2141: uint16(12352),
	2142: uint16(3296),
	2143: uint16(3296),
	2144: uint16(1344),
	2145: uint16(1344),
	2146: uint16(12384),
	2147: uint16(3296),
	2148: uint16(12416),
	2149: uint16(12448),
	2150: uint16(12480),
	2151: uint16(12512),
	2152: uint16(1344),
	2153: uint16(12544),
	2154: uint16(12576),
	2155: uint16(12608),
	2156: uint16(12640),
	2157: uint16(3296),
	2158: uint16(3296),
	2159: uint16(3296),
	2160: uint16(3296),
	2161: uint16(3296),
	2162: uint16(3296),
	2163: uint16(12672),
	2164: uint16(1344),
	2165: uint16(12704),
	2166: uint16(12736),
	2167: uint16(12768),
	2168: uint16(12128),
	2169: uint16(12800),
	2170: uint16(12832),
	2171: uint16(12864),
	2172: uint16(12896),
	2173: uint16(12864),
	2174: uint16(12928),
	2175: uint16(7776),
	2176: uint16(12960),
	2177: uint16(12992),
	2178: uint16(13024),
	2179: uint16(13056),
	2180: uint16(5280),
	2181: uint16(13088),
	2182: uint16(13120),
	2183: uint16(13152),
	2184: uint16(13184),
	2185: uint16(13216),
	2186: uint16(13248),
	2187: uint16(13280),
	2188: uint16(5280),
	2189: uint16(13312),
	2190: uint16(13344),
	2191: uint16(13376),
	2192: uint16(13408),
	2193: uint16(13440),
	2194: uint16(13472),
	2195: uint16(3296),
	2196: uint16(13504),
	2197: uint16(13536),
	2198: uint16(13568),
	2199: uint16(13600),
	2200: uint16(13632),
	2201: uint16(13664),
	2202: uint16(13696),
	2203: uint16(13728),
	2204: uint16(13760),
	2205: uint16(13792),
	2206: uint16(13824),
	2207: uint16(13856),
	2208: uint16(1344),
	2209: uint16(13888),
	2210: uint16(13920),
	2211: uint16(13952),
	2212: uint16(1344),
	2213: uint16(13984),
	2214: uint16(14016),
	2215: uint16(3296),
	2216: uint16(3296),
	2217: uint16(3296),
	2218: uint16(3296),
	2219: uint16(3296),
	2220: uint16(1344),
	2221: uint16(14048),
	2222: uint16(14080),
	2223: uint16(3296),
	2224: uint16(1344),
	2225: uint16(14112),
	2226: uint16(14144),
	2227: uint16(14176),
	2228: uint16(1344),
	2229: uint16(14208),
	2230: uint16(14240),
	2231: uint16(14272),
	2232: uint16(14304),
	2233: uint16(14336),
	2234: uint16(14368),
	2235: uint16(3296),
	2236: uint16(3296),
	2237: uint16(3296),
	2238: uint16(3296),
	2239: uint16(3296),
	2240: uint16(1344),
	2241: uint16(14400),
	2242: uint16(3296),
	2243: uint16(3296),
	2244: uint16(3296),
	2245: uint16(14432),
	2246: uint16(14464),
	2247: uint16(14496),
	2248: uint16(14528),
	2249: uint16(14560),
	2250: uint16(14592),
	2251: uint16(3296),
	2252: uint16(3296),
	2253: uint16(14624),
	2254: uint16(14656),
	2255: uint16(14688),
	2256: uint16(14720),
	2257: uint16(14752),
	2258: uint16(14784),
	2259: uint16(1344),
	2260: uint16(14816),
	2261: uint16(14848),
	2262: uint16(1344),
	2263: uint16(4608),
	2264: uint16(14880),
	2265: uint16(3296),
	2266: uint16(3296),
	2267: uint16(3296),
	2268: uint16(3296),
	2269: uint16(3296),
	2270: uint16(1344),
	2271: uint16(14912),
	2272: uint16(14944),
	2273: uint16(14976),
	2274: uint16(15008),
	2275: uint16(15040),
	2276: uint16(15072),
	2277: uint16(15104),
	2278: uint16(3296),
	2279: uint16(3296),
	2280: uint16(15136),
	2281: uint16(15168),
	2282: uint16(15200),
	2283: uint16(15232),
	2284: uint16(15264),
	2285: uint16(15296),
	2286: uint16(3296),
	2287: uint16(3296),
	2288: uint16(3296),
	2289: uint16(3296),
	2290: uint16(3296),
	2291: uint16(3296),
	2292: uint16(3296),
	2293: uint16(3296),
	2294: uint16(3296),
	2295: uint16(15328),
	2296: uint16(15360),
	2297: uint16(15392),
	2298: uint16(15424),
	2299: uint16(3296),
	2300: uint16(3296),
	2301: uint16(15456),
	2302: uint16(15488),
	2303: uint16(15520),
	2304: uint16(1344),
	2305: uint16(1344),
	2306: uint16(1344),
	2307: uint16(1344),
	2308: uint16(1344),
	2309: uint16(1344),
	2310: uint16(1344),
	2311: uint16(1344),
	2312: uint16(1344),
	2313: uint16(1344),
	2314: uint16(1344),
	2315: uint16(1344),
	2316: uint16(1344),
	2317: uint16(1344),
	2318: uint16(1344),
	2319: uint16(1344),
	2320: uint16(1344),
	2321: uint16(1344),
	2322: uint16(1344),
	2323: uint16(1344),
	2324: uint16(1344),
	2325: uint16(1344),
	2326: uint16(1344),
	2327: uint16(1344),
	2328: uint16(1344),
	2329: uint16(1344),
	2330: uint16(1344),
	2331: uint16(1344),
	2332: uint16(9920),
	2333: uint16(3296),
	2334: uint16(3296),
	2335: uint16(3296),
	2336: uint16(10816),
	2337: uint16(10816),
	2338: uint16(10816),
	2339: uint16(15552),
	2340: uint16(1344),
	2341: uint16(1344),
	2342: uint16(1344),
	2343: uint16(1344),
	2344: uint16(1344),
	2345: uint16(1344),
	2346: uint16(15584),
	2347: uint16(3296),
	2348: uint16(3296),
	2349: uint16(3296),
	2350: uint16(3296),
	2351: uint16(3296),
	2352: uint16(3296),
	2353: uint16(3296),
	2354: uint16(3296),
	2355: uint16(3296),
	2356: uint16(3296),
	2357: uint16(3296),
	2358: uint16(3296),
	2359: uint16(3296),
	2360: uint16(3296),
	2361: uint16(3296),
	2362: uint16(3296),
	2363: uint16(3296),
	2364: uint16(3296),
	2365: uint16(3296),
	2366: uint16(3296),
	2367: uint16(3296),
	2368: uint16(3296),
	2369: uint16(3296),
	2370: uint16(3296),
	2371: uint16(3296),
	2372: uint16(3296),
	2373: uint16(3296),
	2374: uint16(3296),
	2375: uint16(3296),
	2376: uint16(3296),
	2377: uint16(3296),
	2378: uint16(3296),
	2379: uint16(3296),
	2380: uint16(3296),
	2381: uint16(3296),
	2382: uint16(3296),
	2383: uint16(3296),
	2384: uint16(3296),
	2385: uint16(3296),
	2386: uint16(3296),
	2387: uint16(3296),
	2388: uint16(3296),
	2389: uint16(3296),
	2390: uint16(3296),
	2391: uint16(3296),
	2392: uint16(3296),
	2393: uint16(3296),
	2394: uint16(3296),
	2395: uint16(3296),
	2396: uint16(3296),
	2397: uint16(3296),
	2398: uint16(3296),
	2399: uint16(3296),
	2400: uint16(3296),
	2401: uint16(3296),
	2402: uint16(3296),
	2403: uint16(3296),
	2404: uint16(3296),
	2405: uint16(3296),
	2406: uint16(3296),
	2407: uint16(3296),
	2408: uint16(3296),
	2409: uint16(3296),
	2410: uint16(3296),
	2411: uint16(3296),
	2412: uint16(3296),
	2413: uint16(3296),
	2414: uint16(3296),
	2415: uint16(3296),
	2416: uint16(3296),
	2417: uint16(3296),
	2418: uint16(3296),
	2419: uint16(3296),
	2420: uint16(3296),
	2421: uint16(3296),
	2422: uint16(3296),
	2423: uint16(3296),
	2424: uint16(3296),
	2425: uint16(3296),
	2426: uint16(3296),
	2427: uint16(3296),
	2428: uint16(12864),
	2429: uint16(1344),
	2430: uint16(1344),
	2431: uint16(15616),
	2432: uint16(1344),
	2433: uint16(1344),
	2434: uint16(1344),
	2435: uint16(1344),
	2436: uint16(1344),
	2437: uint16(1344),
	2438: uint16(1344),
	2439: uint16(1344),
	2440: uint16(1344),
	2441: uint16(1344),
	2442: uint16(1344),
	2443: uint16(1344),
	2444: uint16(1344),
	2445: uint16(1344),
	2446: uint16(1344),
	2447: uint16(1344),
	2448: uint16(1344),
	2449: uint16(1344),
	2450: uint16(1344),
	2451: uint16(1344),
	2452: uint16(1344),
	2453: uint16(1344),
	2454: uint16(1344),
	2455: uint16(1344),
	2456: uint16(1344),
	2457: uint16(1344),
	2458: uint16(1344),
	2459: uint16(1344),
	2460: uint16(1344),
	2461: uint16(1344),
	2462: uint16(1344),
	2463: uint16(1344),
	2464: uint16(1344),
	2465: uint16(15648),
	2466: uint16(15680),
	2467: uint16(1344),
	2468: uint16(1344),
	2469: uint16(1344),
	2470: uint16(1344),
	2471: uint16(1344),
	2472: uint16(1344),
	2473: uint16(1344),
	2474: uint16(1344),
	2475: uint16(1344),
	2476: uint16(1344),
	2477: uint16(1344),
	2478: uint16(1344),
	2479: uint16(1344),
	2480: uint16(1344),
	2481: uint16(1344),
	2482: uint16(1344),
	2483: uint16(1344),
	2484: uint16(1344),
	2485: uint16(1344),
	2486: uint16(1344),
	2487: uint16(1344),
	2488: uint16(1344),
	2489: uint16(1344),
	2490: uint16(1344),
	2491: uint16(1344),
	2492: uint16(1344),
	2493: uint16(1344),
	2494: uint16(1344),
	2495: uint16(1344),
	2496: uint16(1344),
	2497: uint16(1344),
	2498: uint16(1344),
	2499: uint16(1344),
	2500: uint16(1344),
	2501: uint16(1344),
	2502: uint16(1344),
	2503: uint16(1344),
	2504: uint16(1344),
	2505: uint16(1344),
	2506: uint16(1344),
	2507: uint16(1344),
	2508: uint16(1344),
	2509: uint16(1344),
	2510: uint16(1344),
	2511: uint16(1344),
	2512: uint16(1344),
	2513: uint16(1344),
	2514: uint16(1344),
	2515: uint16(1344),
	2516: uint16(1344),
	2517: uint16(1344),
	2518: uint16(1344),
	2519: uint16(1344),
	2520: uint16(1344),
	2521: uint16(1344),
	2522: uint16(1344),
	2523: uint16(1344),
	2524: uint16(1344),
	2525: uint16(1344),
	2526: uint16(1344),
	2527: uint16(1344),
	2528: uint16(1344),
	2529: uint16(1344),
	2530: uint16(1344),
	2531: uint16(1344),
	2532: uint16(1344),
	2533: uint16(1344),
	2534: uint16(1344),
	2535: uint16(1344),
	2536: uint16(1344),
	2537: uint16(1344),
	2538: uint16(1344),
	2539: uint16(1344),
	2540: uint16(1344),
	2541: uint16(1344),
	2542: uint16(1344),
	2543: uint16(1344),
	2544: uint16(1344),
	2545: uint16(1344),
	2546: uint16(1344),
	2547: uint16(1344),
	2548: uint16(1344),
	2549: uint16(1344),
	2550: uint16(1344),
	2551: uint16(1344),
	2552: uint16(1344),
	2553: uint16(1344),
	2554: uint16(1344),
	2555: uint16(1344),
	2556: uint16(1344),
	2557: uint16(1344),
	2558: uint16(1344),
	2559: uint16(1344),
	2560: uint16(1344),
	2561: uint16(1344),
	2562: uint16(1344),
	2563: uint16(1344),
	2564: uint16(1344),
	2565: uint16(1344),
	2566: uint16(1344),
	2567: uint16(1344),
	2568: uint16(1344),
	2569: uint16(1344),
	2570: uint16(1344),
	2571: uint16(1344),
	2572: uint16(1344),
	2573: uint16(1344),
	2574: uint16(1344),
	2575: uint16(1344),
	2576: uint16(1344),
	2577: uint16(1344),
	2578: uint16(1344),
	2579: uint16(1344),
	2580: uint16(1344),
	2581: uint16(1344),
	2582: uint16(1344),
	2583: uint16(1344),
	2584: uint16(1344),
	2585: uint16(1344),
	2586: uint16(1344),
	2587: uint16(1344),
	2588: uint16(1344),
	2589: uint16(1344),
	2590: uint16(1344),
	2591: uint16(10720),
	2592: uint16(1344),
	2593: uint16(1344),
	2594: uint16(1344),
	2595: uint16(1344),
	2596: uint16(1344),
	2597: uint16(1344),
	2598: uint16(1344),
	2599: uint16(1344),
	2600: uint16(1344),
	2601: uint16(1344),
	2602: uint16(1344),
	2603: uint16(1344),
	2604: uint16(1344),
	2605: uint16(1344),
	2606: uint16(1344),
	2607: uint16(1344),
	2608: uint16(1344),
	2609: uint16(1344),
	2610: uint16(14368),
	2611: uint16(3296),
	2612: uint16(3296),
	2613: uint16(3296),
	2614: uint16(3296),
	2615: uint16(3296),
	2616: uint16(3296),
	2617: uint16(3296),
	2618: uint16(3296),
	2619: uint16(3296),
	2620: uint16(3296),
	2621: uint16(3296),
	2622: uint16(3296),
	2623: uint16(3296),
	2624: uint16(3296),
	2625: uint16(3296),
	2626: uint16(3296),
	2627: uint16(3296),
	2628: uint16(3296),
	2629: uint16(3296),
	2630: uint16(3296),
	2631: uint16(3296),
	2632: uint16(3296),
	2633: uint16(3296),
	2634: uint16(3296),
	2635: uint16(3296),
	2636: uint16(3296),
	2637: uint16(3296),
	2638: uint16(3296),
	2639: uint16(3296),
	2640: uint16(3296),
	2641: uint16(3296),
	2642: uint16(3296),
	2643: uint16(3296),
	2644: uint16(3296),
	2645: uint16(3296),
	2646: uint16(3296),
	2647: uint16(3296),
	2648: uint16(3296),
	2649: uint16(3296),
	2650: uint16(3296),
	2651: uint16(3296),
	2652: uint16(3296),
	2653: uint16(3296),
	2654: uint16(3296),
	2655: uint16(3296),
	2656: uint16(3296),
	2657: uint16(3296),
	2658: uint16(3296),
	2659: uint16(3296),
	2660: uint16(3296),
	2661: uint16(3296),
	2662: uint16(3296),
	2663: uint16(3296),
	2664: uint16(3296),
	2665: uint16(3296),
	2666: uint16(3296),
	2667: uint16(3296),
	2668: uint16(3296),
	2669: uint16(3296),
	2670: uint16(3296),
	2671: uint16(3296),
	2672: uint16(3296),
	2673: uint16(3296),
	2674: uint16(3296),
	2675: uint16(3296),
	2676: uint16(3296),
	2677: uint16(3296),
	2678: uint16(3296),
	2679: uint16(3296),
	2680: uint16(3296),
	2681: uint16(3296),
	2682: uint16(3296),
	2683: uint16(3296),
	2684: uint16(3296),
	2685: uint16(3296),
	2686: uint16(3296),
	2687: uint16(3296),
	2688: uint16(3296),
	2689: uint16(3296),
	2690: uint16(3296),
	2691: uint16(3296),
	2692: uint16(3296),
	2693: uint16(3296),
	2694: uint16(3296),
	2695: uint16(3296),
	2696: uint16(3296),
	2697: uint16(3296),
	2698: uint16(3296),
	2699: uint16(3296),
	2700: uint16(3296),
	2701: uint16(3296),
	2702: uint16(3296),
	2703: uint16(3296),
	2704: uint16(3296),
	2705: uint16(3296),
	2706: uint16(3296),
	2707: uint16(3296),
	2708: uint16(3296),
	2709: uint16(3296),
	2710: uint16(3296),
	2711: uint16(3296),
	2712: uint16(3296),
	2713: uint16(3296),
	2714: uint16(3296),
	2715: uint16(3296),
	2716: uint16(3296),
	2717: uint16(3296),
	2718: uint16(3296),
	2719: uint16(3296),
	2720: uint16(3296),
	2721: uint16(3296),
	2722: uint16(3296),
	2723: uint16(3296),
	2724: uint16(3296),
	2725: uint16(3296),
	2726: uint16(3296),
	2727: uint16(3296),
	2728: uint16(3296),
	2729: uint16(3296),
	2730: uint16(3296),
	2731: uint16(3296),
	2732: uint16(3296),
	2733: uint16(3296),
	2734: uint16(3296),
	2735: uint16(3296),
	2736: uint16(3296),
	2737: uint16(3296),
	2738: uint16(3296),
	2739: uint16(3296),
	2740: uint16(3296),
	2741: uint16(3296),
	2742: uint16(3296),
	2743: uint16(3296),
	2744: uint16(3296),
	2745: uint16(3296),
	2746: uint16(3296),
	2747: uint16(3296),
	2748: uint16(3296),
	2749: uint16(3296),
	2750: uint16(3296),
	2751: uint16(3296),
	2752: uint16(3296),
	2753: uint16(3296),
	2754: uint16(3296),
	2755: uint16(3296),
	2756: uint16(3296),
	2757: uint16(3296),
	2758: uint16(3296),
	2759: uint16(3296),
	2760: uint16(3296),
	2761: uint16(3296),
	2762: uint16(3296),
	2763: uint16(3296),
	2764: uint16(3296),
	2765: uint16(3296),
	2766: uint16(3296),
	2767: uint16(3296),
	2768: uint16(3296),
	2769: uint16(3296),
	2770: uint16(3296),
	2771: uint16(3296),
	2772: uint16(3296),
	2773: uint16(3296),
	2774: uint16(3296),
	2775: uint16(3296),
	2776: uint16(3296),
	2777: uint16(3296),
	2778: uint16(3296),
	2779: uint16(3296),
	2780: uint16(3296),
	2781: uint16(3296),
	2782: uint16(3296),
	2783: uint16(3296),
	2784: uint16(3296),
	2785: uint16(3296),
	2786: uint16(3296),
	2787: uint16(3296),
	2788: uint16(3296),
	2789: uint16(3296),
	2790: uint16(3296),
	2791: uint16(3296),
	2792: uint16(3296),
	2793: uint16(3296),
	2794: uint16(3296),
	2795: uint16(3296),
	2796: uint16(3296),
	2797: uint16(3296),
	2798: uint16(3296),
	2799: uint16(3296),
	2800: uint16(3296),
	2801: uint16(3296),
	2802: uint16(3296),
	2803: uint16(3296),
	2804: uint16(3296),
	2805: uint16(3296),
	2806: uint16(3296),
	2807: uint16(3296),
	2808: uint16(3296),
	2809: uint16(3296),
	2810: uint16(3296),
	2811: uint16(3296),
	2812: uint16(3296),
	2813: uint16(3296),
	2814: uint16(3296),
	2815: uint16(3296),
	2816: uint16(3296),
	2817: uint16(3296),
	2818: uint16(3296),
	2819: uint16(3296),
	2820: uint16(3296),
	2821: uint16(3296),
	2822: uint16(3296),
	2823: uint16(3296),
	2824: uint16(15712),
	2825: uint16(15744),
	2826: uint16(3296),
	2827: uint16(3296),
	2828: uint16(3296),
	2829: uint16(3296),
	2830: uint16(3296),
	2831: uint16(3296),
	2832: uint16(3296),
	2833: uint16(3296),
	2834: uint16(3296),
	2835: uint16(3296),
	2836: uint16(3296),
	2837: uint16(3296),
	2838: uint16(3296),
	2839: uint16(3296),
	2840: uint16(3296),
	2841: uint16(3296),
	2842: uint16(3296),
	2843: uint16(3296),
	2844: uint16(3296),
	2845: uint16(3296),
	2846: uint16(3296),
	2847: uint16(3296),
	2848: uint16(3296),
	2849: uint16(3296),
	2850: uint16(3296),
	2851: uint16(3296),
	2852: uint16(3296),
	2853: uint16(3296),
	2854: uint16(3296),
	2855: uint16(3296),
	2856: uint16(3296),
	2857: uint16(3296),
	2858: uint16(3296),
	2859: uint16(3296),
	2860: uint16(3296),
	2861: uint16(3296),
	2862: uint16(3296),
	2863: uint16(3296),
	2864: uint16(3296),
	2865: uint16(3296),
	2866: uint16(3296),
	2867: uint16(3296),
	2868: uint16(3296),
	2869: uint16(3296),
	2870: uint16(3296),
	2871: uint16(3296),
	2872: uint16(3296),
	2873: uint16(3296),
	2874: uint16(3296),
	2875: uint16(3296),
	2876: uint16(3296),
	2877: uint16(3296),
	2878: uint16(3296),
	2879: uint16(3296),
	2880: uint16(1344),
	2881: uint16(1344),
	2882: uint16(1344),
	2883: uint16(1344),
	2884: uint16(1344),
	2885: uint16(1344),
	2886: uint16(1344),
	2887: uint16(1344),
	2888: uint16(1344),
	2889: uint16(1344),
	2890: uint16(1344),
	2891: uint16(1344),
	2892: uint16(1344),
	2893: uint16(1344),
	2894: uint16(1344),
	2895: uint16(1344),
	2896: uint16(1344),
	2897: uint16(4608),
	2898: uint16(4736),
	2899: uint16(15776),
	2900: uint16(1344),
	2901: uint16(4736),
	2902: uint16(15808),
	2903: uint16(15840),
	2904: uint16(1344),
	2905: uint16(15872),
	2906: uint16(15904),
	2907: uint16(15936),
	2908: uint16(15968),
	2909: uint16(3296),
	2910: uint16(3296),
	2911: uint16(3296),
	2912: uint16(3296),
	2913: uint16(3296),
	2914: uint16(3296),
	2915: uint16(3296),
	2916: uint16(3296),
	2917: uint16(3296),
	2918: uint16(3296),
	2919: uint16(3296),
	2920: uint16(3296),
	2921: uint16(3296),
	2922: uint16(16000),
	2923: uint16(16032),
	2924: uint16(3296),
	2925: uint16(3296),
	2926: uint16(3296),
	2927: uint16(3296),
	2928: uint16(3296),
	2929: uint16(3296),
	2930: uint16(14432),
	2931: uint16(14464),
	2932: uint16(16064),
	2933: uint16(3296),
	2934: uint16(3296),
	2935: uint16(3296),
	2936: uint16(1344),
	2937: uint16(1344),
	2938: uint16(16096),
	2939: uint16(16128),
	2940: uint16(16160),
	2941: uint16(3296),
	2942: uint16(3296),
	2943: uint16(16192),
	2944: uint16(1344),
	2945: uint16(1344),
	2946: uint16(1344),
	2947: uint16(1344),
	2948: uint16(1344),
	2949: uint16(1344),
	2950: uint16(1344),
	2951: uint16(1344),
	2952: uint16(1344),
	2953: uint16(1344),
	2954: uint16(1344),
	2955: uint16(1344),
	2956: uint16(1344),
	2957: uint16(1344),
	2958: uint16(1344),
	2959: uint16(1344),
	2960: uint16(1344),
	2961: uint16(1344),
	2962: uint16(1344),
	2963: uint16(1344),
	2964: uint16(1344),
	2965: uint16(1344),
	2966: uint16(1344),
	2967: uint16(1344),
	2968: uint16(1344),
	2969: uint16(1344),
	2970: uint16(1344),
	2971: uint16(1344),
	2972: uint16(1344),
	2973: uint16(1344),
	2974: uint16(1344),
	2975: uint16(1344),
	2976: uint16(1344),
	2977: uint16(1344),
	2978: uint16(1344),
	2979: uint16(1344),
	2980: uint16(1344),
	2981: uint16(1344),
	2982: uint16(1344),
	2983: uint16(1344),
	2984: uint16(1344),
	2985: uint16(1344),
	2986: uint16(1344),
	2987: uint16(1344),
	2988: uint16(1344),
	2989: uint16(1344),
	2990: uint16(1344),
	2991: uint16(1344),
	2992: uint16(1344),
	2993: uint16(1344),
	2994: uint16(1344),
	2995: uint16(1344),
	2996: uint16(1344),
	2997: uint16(1344),
	2998: uint16(1344),
	2999: uint16(1344),
	3000: uint16(1344),
	3001: uint16(1344),
	3002: uint16(1344),
	3003: uint16(1344),
	3004: uint16(1344),
	3005: uint16(1344),
	3006: uint16(1344),
	3007: uint16(1344),
	3008: uint16(1344),
	3009: uint16(1344),
	3010: uint16(1344),
	3011: uint16(1344),
	3012: uint16(1344),
	3013: uint16(1344),
	3014: uint16(1344),
	3015: uint16(1344),
	3016: uint16(1344),
	3017: uint16(1344),
	3018: uint16(1344),
	3019: uint16(1344),
	3020: uint16(1344),
	3021: uint16(1344),
	3022: uint16(1344),
	3023: uint16(1344),
	3024: uint16(1344),
	3025: uint16(1344),
	3026: uint16(1344),
	3027: uint16(1344),
	3028: uint16(1344),
	3029: uint16(1344),
	3030: uint16(1344),
	3031: uint16(1344),
	3032: uint16(1344),
	3033: uint16(1344),
	3034: uint16(1344),
	3035: uint16(1344),
	3036: uint16(1344),
	3037: uint16(1344),
	3038: uint16(1344),
	3039: uint16(1344),
	3040: uint16(1344),
	3041: uint16(1344),
	3042: uint16(1344),
	3043: uint16(1344),
	3044: uint16(1344),
	3045: uint16(1344),
	3046: uint16(1344),
	3047: uint16(1344),
	3048: uint16(1344),
	3049: uint16(1344),
	3050: uint16(1344),
	3051: uint16(1344),
	3052: uint16(1344),
	3053: uint16(1344),
	3054: uint16(1344),
	3055: uint16(1344),
	3056: uint16(1344),
	3057: uint16(1344),
	3058: uint16(1344),
	3059: uint16(1344),
	3060: uint16(1344),
	3061: uint16(1344),
	3062: uint16(1344),
	3063: uint16(1344),
	3064: uint16(1344),
	3065: uint16(1344),
	3066: uint16(1344),
	3067: uint16(1344),
	3068: uint16(1344),
	3069: uint16(1344),
	3070: uint16(1344),
	3071: uint16(1344),
	3072: uint16(1344),
	3073: uint16(1344),
	3074: uint16(1344),
	3075: uint16(1344),
	3076: uint16(1344),
	3077: uint16(1344),
	3078: uint16(1344),
	3079: uint16(1344),
	3080: uint16(1344),
	3081: uint16(1344),
	3082: uint16(1344),
	3083: uint16(1344),
	3084: uint16(1344),
	3085: uint16(1344),
	3086: uint16(1344),
	3087: uint16(1344),
	3088: uint16(1344),
	3089: uint16(1344),
	3090: uint16(1344),
	3091: uint16(1344),
	3092: uint16(1344),
	3093: uint16(1344),
	3094: uint16(1344),
	3095: uint16(1344),
	3096: uint16(1344),
	3097: uint16(1344),
	3098: uint16(1344),
	3099: uint16(1344),
	3100: uint16(1344),
	3101: uint16(1344),
	3102: uint16(1344),
	3103: uint16(1344),
	3104: uint16(1344),
	3105: uint16(1344),
	3106: uint16(1344),
	3107: uint16(1344),
	3108: uint16(1344),
	3109: uint16(1344),
	3110: uint16(1344),
	3111: uint16(1344),
	3112: uint16(1344),
	3113: uint16(1344),
	3114: uint16(1344),
	3115: uint16(1344),
	3116: uint16(1344),
	3117: uint16(1344),
	3118: uint16(1344),
	3119: uint16(1344),
	3120: uint16(1344),
	3121: uint16(1344),
	3122: uint16(1344),
	3123: uint16(1344),
	3124: uint16(1344),
	3125: uint16(1344),
	3126: uint16(1344),
	3127: uint16(1344),
	3128: uint16(1344),
	3129: uint16(1344),
	3130: uint16(1344),
	3131: uint16(1344),
	3132: uint16(1344),
	3133: uint16(1344),
	3134: uint16(1344),
	3135: uint16(16224),
	3136: uint16(1344),
	3137: uint16(1344),
	3138: uint16(1344),
	3139: uint16(1344),
	3140: uint16(1344),
	3141: uint16(1344),
	3142: uint16(1344),
	3143: uint16(1344),
	3144: uint16(1344),
	3145: uint16(1344),
	3146: uint16(1344),
	3147: uint16(1344),
	3148: uint16(1344),
	3149: uint16(1344),
	3150: uint16(1344),
	3151: uint16(1344),
	3152: uint16(1344),
	3153: uint16(1344),
	3154: uint16(1344),
	3155: uint16(1344),
	3156: uint16(1344),
	3157: uint16(1344),
	3158: uint16(1344),
	3159: uint16(1344),
	3160: uint16(1344),
	3161: uint16(1344),
	3162: uint16(1344),
	3163: uint16(1344),
	3164: uint16(1344),
	3165: uint16(1344),
	3166: uint16(1344),
	3167: uint16(1344),
	3168: uint16(1344),
	3169: uint16(1344),
	3170: uint16(1344),
	3171: uint16(1344),
	3172: uint16(1344),
	3173: uint16(1344),
	3174: uint16(4704),
	3175: uint16(16256),
	3176: uint16(12384),
	3177: uint16(3296),
	3178: uint16(3296),
	3179: uint16(3296),
	3180: uint16(3296),
	3181: uint16(3296),
	3182: uint16(3296),
	3183: uint16(3296),
	3184: uint16(3296),
	3185: uint16(3296),
	3186: uint16(3296),
	3187: uint16(3296),
	3188: uint16(3296),
	3189: uint16(3296),
	3190: uint16(3296),
	3191: uint16(3296),
	3192: uint16(3296),
	3193: uint16(3296),
	3194: uint16(3296),
	3195: uint16(3296),
	3196: uint16(3296),
	3197: uint16(3296),
	3198: uint16(3296),
	3199: uint16(3296),
	3200: uint16(3296),
	3201: uint16(3296),
	3202: uint16(3296),
	3203: uint16(3296),
	3204: uint16(3296),
	3205: uint16(3296),
	3206: uint16(3296),
	3207: uint16(3296),
	3208: uint16(3296),
	3209: uint16(3296),
	3210: uint16(3296),
	3211: uint16(3296),
	3212: uint16(3296),
	3213: uint16(3296),
	3214: uint16(3296),
	3215: uint16(3296),
	3216: uint16(3296),
	3217: uint16(3296),
	3218: uint16(3296),
	3219: uint16(3296),
	3220: uint16(3296),
	3221: uint16(3296),
	3222: uint16(3296),
	3223: uint16(3296),
	3224: uint16(3296),
	3225: uint16(3296),
	3226: uint16(3296),
	3227: uint16(3296),
	3228: uint16(3296),
	3229: uint16(3296),
	3230: uint16(3296),
	3231: uint16(3296),
	3232: uint16(3296),
	3233: uint16(3296),
	3234: uint16(3296),
	3235: uint16(3296),
	3236: uint16(3296),
	3237: uint16(3296),
	3238: uint16(3296),
	3239: uint16(3296),
	3240: uint16(3296),
	3241: uint16(3296),
	3242: uint16(3296),
	3243: uint16(3296),
	3244: uint16(3296),
	3245: uint16(3296),
	3246: uint16(3296),
	3247: uint16(3296),
	3248: uint16(3296),
	3249: uint16(3296),
	3250: uint16(3296),
	3251: uint16(3296),
	3252: uint16(3296),
	3253: uint16(3296),
	3254: uint16(3296),
	3255: uint16(3296),
	3256: uint16(3296),
	3257: uint16(3296),
	3258: uint16(3296),
	3259: uint16(3296),
	3260: uint16(3296),
	3261: uint16(3296),
	3262: uint16(3296),
	3263: uint16(3296),
	3264: uint16(3296),
	3265: uint16(3296),
	3266: uint16(3296),
	3267: uint16(3296),
	3268: uint16(3296),
	3269: uint16(3296),
	3270: uint16(3296),
	3271: uint16(3296),
	3272: uint16(3296),
	3273: uint16(3296),
	3274: uint16(3296),
	3275: uint16(3296),
	3276: uint16(3296),
	3277: uint16(3296),
	3278: uint16(3296),
	3279: uint16(3296),
	3280: uint16(3296),
	3281: uint16(3296),
	3282: uint16(3296),
	3283: uint16(3296),
	3284: uint16(3296),
	3285: uint16(3296),
	3286: uint16(3296),
	3287: uint16(3296),
	3288: uint16(3296),
	3289: uint16(3296),
	3290: uint16(3296),
	3291: uint16(3296),
	3292: uint16(3296),
	3293: uint16(3296),
	3294: uint16(3296),
	3295: uint16(3296),
	3296: uint16(3296),
	3297: uint16(3296),
	3298: uint16(3296),
	3299: uint16(3296),
	3300: uint16(3296),
	3301: uint16(3296),
	3302: uint16(3296),
	3303: uint16(3296),
	3304: uint16(3296),
	3305: uint16(3296),
	3306: uint16(3296),
	3307: uint16(3296),
	3308: uint16(3296),
	3309: uint16(3296),
	3310: uint16(3296),
	3311: uint16(3296),
	3312: uint16(3296),
	3313: uint16(3296),
	3314: uint16(3296),
	3315: uint16(3296),
	3316: uint16(3296),
	3317: uint16(3296),
	3318: uint16(3296),
	3319: uint16(3296),
	3320: uint16(3296),
	3321: uint16(3296),
	3322: uint16(3296),
	3323: uint16(3296),
	3324: uint16(3296),
	3325: uint16(3296),
	3326: uint16(3296),
	3327: uint16(3296),
	3328: uint16(3296),
	3329: uint16(3296),
	3330: uint16(3296),
	3331: uint16(3296),
	3332: uint16(3296),
	3333: uint16(3296),
	3334: uint16(3296),
	3335: uint16(3296),
	3336: uint16(3296),
	3337: uint16(3296),
	3338: uint16(3296),
	3339: uint16(3296),
	3340: uint16(3296),
	3341: uint16(3296),
	3342: uint16(3296),
	3343: uint16(3296),
	3344: uint16(3296),
	3345: uint16(3296),
	3346: uint16(3296),
	3347: uint16(3296),
	3348: uint16(3296),
	3349: uint16(3296),
	3350: uint16(3296),
	3351: uint16(3296),
	3352: uint16(3296),
	3353: uint16(3296),
	3354: uint16(3296),
	3355: uint16(3296),
	3356: uint16(3296),
	3357: uint16(3296),
	3358: uint16(3296),
	3359: uint16(3296),
	3360: uint16(3296),
	3361: uint16(3296),
	3362: uint16(3296),
	3363: uint16(3296),
	3364: uint16(3296),
	3365: uint16(3296),
	3366: uint16(3296),
	3367: uint16(3296),
	3368: uint16(3296),
	3369: uint16(3296),
	3370: uint16(3296),
	3371: uint16(3296),
	3372: uint16(3296),
	3373: uint16(3296),
	3374: uint16(3296),
	3375: uint16(3296),
	3376: uint16(3296),
	3377: uint16(3296),
	3378: uint16(3296),
	3379: uint16(3296),
	3380: uint16(3296),
	3381: uint16(3296),
	3382: uint16(3296),
	3383: uint16(3296),
	3384: uint16(3296),
	3385: uint16(3296),
	3386: uint16(3296),
	3387: uint16(3296),
	3388: uint16(3296),
	3389: uint16(3296),
	3390: uint16(3296),
	3391: uint16(3296),
	3392: uint16(3296),
	3393: uint16(3296),
	3394: uint16(3296),
	3395: uint16(3296),
	3396: uint16(3296),
	3397: uint16(3296),
	3398: uint16(3296),
	3399: uint16(3296),
	3400: uint16(3296),
	3401: uint16(3296),
	3402: uint16(3296),
	3403: uint16(3296),
	3404: uint16(3296),
	3405: uint16(3296),
	3406: uint16(3296),
	3407: uint16(3296),
	3408: uint16(3296),
	3409: uint16(3296),
	3410: uint16(3296),
	3411: uint16(3296),
	3412: uint16(3296),
	3413: uint16(3296),
	3414: uint16(3296),
	3415: uint16(3296),
	3416: uint16(3296),
	3417: uint16(3296),
	3418: uint16(3296),
	3419: uint16(3296),
	3420: uint16(3296),
	3421: uint16(3296),
	3422: uint16(3296),
	3423: uint16(3296),
	3424: uint16(3296),
	3425: uint16(3296),
	3426: uint16(3296),
	3427: uint16(3296),
	3428: uint16(3296),
	3429: uint16(3296),
	3430: uint16(3296),
	3431: uint16(3296),
	3432: uint16(3296),
	3433: uint16(3296),
	3434: uint16(3296),
	3435: uint16(3296),
	3436: uint16(3296),
	3437: uint16(3296),
	3438: uint16(3296),
	3439: uint16(3296),
	3440: uint16(3296),
	3441: uint16(3296),
	3442: uint16(3296),
	3443: uint16(3296),
	3444: uint16(3296),
	3445: uint16(3296),
	3446: uint16(3296),
	3447: uint16(3296),
	3448: uint16(3296),
	3449: uint16(3296),
	3450: uint16(3296),
	3451: uint16(3296),
	3452: uint16(3296),
	3453: uint16(3296),
	3454: uint16(3296),
	3455: uint16(16288),
	3456: uint16(1344),
	3457: uint16(1344),
	3458: uint16(1344),
	3459: uint16(1344),
	3460: uint16(1344),
	3461: uint16(1344),
	3462: uint16(1344),
	3463: uint16(1344),
	3464: uint16(1344),
	3465: uint16(16320),
	3466: uint16(16352),
	3467: uint16(16384),
	3468: uint16(1344),
	3469: uint16(1344),
	3470: uint16(1344),
	3471: uint16(1344),
	3472: uint16(1344),
	3473: uint16(1344),
	3474: uint16(1344),
	3475: uint16(1344),
	3476: uint16(1344),
	3477: uint16(1344),
	3478: uint16(1344),
	3479: uint16(9792),
	3480: uint16(3296),
	3481: uint16(3296),
	3482: uint16(3296),
	3483: uint16(3296),
	3484: uint16(3296),
	3485: uint16(3296),
	3486: uint16(3296),
	3487: uint16(3296),
	3488: uint16(3296),
	3489: uint16(3296),
	3490: uint16(3296),
	3491: uint16(3296),
	3492: uint16(3296),
	3493: uint16(3296),
	3494: uint16(3296),
	3495: uint16(3296),
	3496: uint16(3296),
	3497: uint16(3296),
	3498: uint16(3296),
	3499: uint16(3296),
	3500: uint16(3296),
	3501: uint16(3296),
	3502: uint16(3296),
	3503: uint16(3296),
	3504: uint16(3296),
	3505: uint16(3296),
	3506: uint16(3296),
	3507: uint16(3296),
	3508: uint16(3296),
	3509: uint16(3296),
	3510: uint16(3296),
	3511: uint16(3296),
	3512: uint16(3296),
	3513: uint16(3296),
	3514: uint16(3296),
	3515: uint16(3296),
	3516: uint16(3296),
	3517: uint16(3296),
	3518: uint16(3296),
	3519: uint16(3296),
	3520: uint16(3296),
	3521: uint16(3296),
	3522: uint16(3296),
	3523: uint16(3296),
	3524: uint16(3296),
	3525: uint16(3296),
	3526: uint16(3296),
	3527: uint16(3296),
	3528: uint16(3296),
	3529: uint16(3296),
	3530: uint16(3296),
	3531: uint16(3296),
	3532: uint16(3296),
	3533: uint16(3296),
	3534: uint16(3296),
	3535: uint16(3296),
	3536: uint16(3296),
	3537: uint16(3296),
	3538: uint16(3296),
	3539: uint16(3296),
	3540: uint16(3296),
	3541: uint16(3296),
	3542: uint16(3296),
	3543: uint16(3296),
	3544: uint16(3296),
	3545: uint16(3296),
	3546: uint16(3296),
	3547: uint16(3296),
	3548: uint16(3296),
	3549: uint16(3296),
	3550: uint16(3296),
	3551: uint16(3296),
	3552: uint16(1344),
	3553: uint16(1344),
	3554: uint16(1344),
	3555: uint16(16416),
	3556: uint16(16448),
	3557: uint16(16480),
	3558: uint16(3296),
	3559: uint16(3296),
	3560: uint16(3296),
	3561: uint16(3296),
	3562: uint16(3296),
	3563: uint16(3296),
	3564: uint16(3296),
	3565: uint16(3296),
	3566: uint16(3296),
	3567: uint16(3296),
	3568: uint16(3296),
	3569: uint16(3296),
	3570: uint16(3296),
	3571: uint16(3296),
	3572: uint16(3296),
	3573: uint16(3296),
	3574: uint16(3296),
	3575: uint16(3296),
	3576: uint16(3296),
	3577: uint16(3296),
	3578: uint16(3296),
	3579: uint16(3296),
	3580: uint16(3296),
	3581: uint16(3296),
	3582: uint16(3296),
	3583: uint16(3296),
	3584: uint16(3296),
	3585: uint16(3296),
	3586: uint16(3296),
	3587: uint16(3296),
	3588: uint16(3296),
	3589: uint16(3296),
	3590: uint16(3296),
	3591: uint16(3296),
	3592: uint16(3296),
	3593: uint16(3296),
	3594: uint16(3296),
	3595: uint16(3296),
	3596: uint16(3296),
	3597: uint16(3296),
	3598: uint16(3296),
	3599: uint16(3296),
	3600: uint16(3296),
	3601: uint16(3296),
	3602: uint16(3296),
	3603: uint16(3296),
	3604: uint16(3296),
	3605: uint16(3296),
	3606: uint16(3296),
	3607: uint16(3296),
	3608: uint16(3296),
	3609: uint16(3296),
	3610: uint16(3296),
	3611: uint16(3296),
	3612: uint16(3296),
	3613: uint16(3296),
	3614: uint16(3296),
	3615: uint16(3296),
	3616: uint16(3296),
	3617: uint16(3296),
	3618: uint16(3296),
	3619: uint16(3296),
	3620: uint16(3296),
	3621: uint16(3296),
	3622: uint16(3296),
	3623: uint16(3296),
	3624: uint16(3296),
	3625: uint16(3296),
	3626: uint16(3296),
	3627: uint16(3296),
	3628: uint16(3296),
	3629: uint16(3296),
	3630: uint16(3296),
	3631: uint16(3296),
	3632: uint16(3296),
	3633: uint16(3296),
	3634: uint16(3296),
	3635: uint16(3296),
	3636: uint16(3296),
	3637: uint16(3296),
	3638: uint16(3296),
	3639: uint16(3296),
	3640: uint16(3296),
	3641: uint16(3296),
	3642: uint16(3296),
	3643: uint16(3296),
	3644: uint16(3296),
	3645: uint16(3296),
	3646: uint16(3296),
	3647: uint16(3296),
	3648: uint16(3296),
	3649: uint16(3296),
	3650: uint16(3296),
	3651: uint16(3296),
	3652: uint16(3296),
	3653: uint16(3296),
	3654: uint16(3296),
	3655: uint16(3296),
	3656: uint16(3296),
	3657: uint16(3296),
	3658: uint16(3296),
	3659: uint16(3296),
	3660: uint16(3296),
	3661: uint16(3296),
	3662: uint16(3296),
	3663: uint16(3296),
	3664: uint16(3296),
	3665: uint16(3296),
	3666: uint16(3296),
	3667: uint16(3296),
	3668: uint16(3296),
	3669: uint16(3296),
	3670: uint16(3296),
	3671: uint16(3296),
	3672: uint16(3296),
	3673: uint16(3296),
	3674: uint16(3296),
	3675: uint16(3296),
	3676: uint16(3296),
	3677: uint16(3296),
	3678: uint16(3296),
	3679: uint16(3296),
	3680: uint16(4928),
	3681: uint16(4928),
	3682: uint16(4928),
	3683: uint16(4928),
	3684: uint16(4928),
	3685: uint16(4928),
	3686: uint16(4928),
	3687: uint16(16512),
	3688: uint16(4928),
	3689: uint16(4928),
	3690: uint16(4928),
	3691: uint16(4928),
	3692: uint16(4928),
	3693: uint16(4928),
	3694: uint16(4928),
	3695: uint16(4928),
	3696: uint16(4928),
	3697: uint16(4928),
	3698: uint16(4928),
	3699: uint16(4928),
	3700: uint16(4928),
	3701: uint16(7968),
	3702: uint16(3296),
	3703: uint16(3296),
	3704: uint16(704),
	3705: uint16(16544),
	3706: uint16(16576),
	3707: uint16(4928),
	3708: uint16(4928),
	3709: uint16(4928),
	3710: uint16(16608),
	3711: uint16(3296),
	3712: uint16(4928),
	3713: uint16(4928),
	3714: uint16(4928),
	3715: uint16(4928),
	3716: uint16(4928),
	3717: uint16(4928),
	3718: uint16(4928),
	3719: uint16(8000),
	3720: uint16(4928),
	3721: uint16(16640),
	3722: uint16(4928),
	3723: uint16(16672),
	3724: uint16(16704),
	3725: uint16(16736),
	3726: uint16(4928),
	3727: uint16(6848),
	3728: uint16(4928),
	3729: uint16(4928),
	3730: uint16(16768),
	3731: uint16(3296),
	3732: uint16(3296),
	3733: uint16(3296),
	3734: uint16(16800),
	3735: uint16(16800),
	3736: uint16(4928),
	3737: uint16(4928),
	3738: uint16(16832),
	3739: uint16(16864),
	3740: uint16(3296),
	3741: uint16(3296),
	3742: uint16(3296),
	3743: uint16(3296),
	3744: uint16(16896),
	3745: uint16(16928),
	3746: uint16(16960),
	3747: uint16(16992),
	3748: uint16(17024),
	3749: uint16(17056),
	3750: uint16(17088),
	3751: uint16(17120),
	3752: uint16(17152),
	3753: uint16(17184),
	3754: uint16(17216),
	3755: uint16(17248),
	3756: uint16(17280),
	3757: uint16(16896),
	3758: uint16(16928),
	3759: uint16(17312),
	3760: uint16(16992),
	3761: uint16(17344),
	3762: uint16(17376),
	3763: uint16(17408),
	3764: uint16(17120),
	3765: uint16(17440),
	3766: uint16(17472),
	3767: uint16(17504),
	3768: uint16(17536),
	3769: uint16(17568),
	3770: uint16(17600),
	3771: uint16(17632),
	3772: uint16(17664),
	3773: uint16(17696),
	3774: uint16(17728),
	3775: uint16(17760),
	3776: uint16(4928),
	3777: uint16(4928),
	3778: uint16(4928),
	3779: uint16(4928),
	3780: uint16(4928),
	3781: uint16(4928),
	3782: uint16(4928),
	3783: uint16(4928),
	3784: uint16(4928),
	3785: uint16(4928),
	3786: uint16(4928),
	3787: uint16(4928),
	3788: uint16(4928),
	3789: uint16(4928),
	3790: uint16(4928),
	3791: uint16(4928),
	3792: uint16(704),
	3793: uint16(17792),
	3794: uint16(704),
	3795: uint16(17824),
	3796: uint16(17856),
	3797: uint16(17888),
	3798: uint16(3296),
	3799: uint16(3296),
	3800: uint16(3296),
	3801: uint16(3296),
	3802: uint16(3296),
	3803: uint16(3296),
	3804: uint16(3296),
	3805: uint16(3296),
	3806: uint16(3296),
	3807: uint16(3296),
	3808: uint16(3296),
	3809: uint16(3296),
	3810: uint16(3296),
	3811: uint16(3296),
	3812: uint16(3296),
	3813: uint16(3296),
	3814: uint16(3296),
	3815: uint16(3296),
	3816: uint16(3296),
	3817: uint16(3296),
	3818: uint16(3296),
	3819: uint16(3296),
	3820: uint16(3296),
	3821: uint16(3296),
	3822: uint16(3296),
	3823: uint16(3296),
	3824: uint16(3296),
	3825: uint16(3296),
	3826: uint16(3296),
	3827: uint16(3296),
	3828: uint16(3296),
	3829: uint16(3296),
	3830: uint16(3296),
	3831: uint16(3296),
	3832: uint16(17920),
	3833: uint16(17952),
	3834: uint16(3296),
	3835: uint16(3296),
	3836: uint16(3296),
	3837: uint16(3296),
	3838: uint16(3296),
	3839: uint16(3296),
	3840: uint16(17984),
	3841: uint16(18016),
	3842: uint16(5664),
	3843: uint16(18048),
	3844: uint16(18080),
	3845: uint16(3296),
	3846: uint16(3296),
	3847: uint16(3296),
	3848: uint16(1344),
	3849: uint16(18112),
	3850: uint16(18144),
	3851: uint16(3296),
	3852: uint16(3296),
	3853: uint16(3296),
	3854: uint16(3296),
	3855: uint16(3296),
	3856: uint16(3296),
	3857: uint16(3296),
	3858: uint16(3296),
	3859: uint16(3296),
	3860: uint16(12864),
	3861: uint16(18176),
	3862: uint16(1344),
	3863: uint16(18208),
	3864: uint16(3296),
	3865: uint16(3296),
	3866: uint16(3296),
	3867: uint16(3296),
	3868: uint16(3296),
	3869: uint16(3296),
	3870: uint16(3296),
	3871: uint16(3296),
	3872: uint16(3296),
	3873: uint16(3296),
	3874: uint16(3296),
	3875: uint16(3296),
	3876: uint16(3296),
	3877: uint16(3296),
	3878: uint16(12864),
	3879: uint16(18240),
	3880: uint16(3296),
	3881: uint16(3296),
	3882: uint16(3296),
	3883: uint16(3296),
	3884: uint16(3296),
	3885: uint16(3296),
	3886: uint16(12864),
	3887: uint16(18272),
	3888: uint16(3296),
	3889: uint16(3296),
	3890: uint16(3296),
	3891: uint16(3296),
	3892: uint16(3296),
	3893: uint16(3296),
	3894: uint16(3296),
	3895: uint16(3296),
	3896: uint16(3296),
	3897: uint16(3296),
	3898: uint16(3296),
	3899: uint16(3296),
	3900: uint16(3296),
	3901: uint16(3296),
	3902: uint16(3296),
	3903: uint16(18304),
	3904: uint16(1344),
	3905: uint16(1344),
	3906: uint16(1344),
	3907: uint16(1344),
	3908: uint16(1344),
	3909: uint16(1344),
	3910: uint16(18336),
	3911: uint16(3296),
	3912: uint16(18368),
	3913: uint16(18400),
	3914: uint16(18432),
	3915: uint16(3296),
	3916: uint16(3296),
	3917: uint16(3296),
	3918: uint16(3296),
	3919: uint16(3296),
	3920: uint16(3296),
	3921: uint16(3296),
	3922: uint16(3296),
	3923: uint16(3296),
	3924: uint16(3296),
	3925: uint16(3296),
	3926: uint16(3296),
	3927: uint16(3296),
	3928: uint16(3296),
	3929: uint16(3296),
	3930: uint16(3296),
	3931: uint16(3296),
	3932: uint16(3296),
	3933: uint16(3296),
	3934: uint16(3296),
	3935: uint16(3296),
	3936: uint16(3296),
	3937: uint16(3296),
	3938: uint16(3296),
	3939: uint16(18464),
	3940: uint16(6880),
	3941: uint16(18496),
	3942: uint16(3296),
	3943: uint16(3296),
	3944: uint16(18528),
	3945: uint16(18560),
	3946: uint16(3296),
	3947: uint16(3296),
	3948: uint16(3296),
	3949: uint16(3296),
	3950: uint16(3296),
	3951: uint16(3296),
	3952: uint16(18592),
	3953: uint16(18624),
	3954: uint16(18656),
	3955: uint16(18688),
	3956: uint16(18720),
	3957: uint16(18752),
	3958: uint16(3296),
	3959: uint16(18784),
	3960: uint16(3296),
	3961: uint16(3296),
	3962: uint16(3296),
	3963: uint16(3296),
	3964: uint16(3296),
	3965: uint16(3296),
	3966: uint16(3296),
	3967: uint16(3296),
	3968: uint16(4928),
	3969: uint16(18816),
	3970: uint16(4928),
	3971: uint16(4928),
	3972: uint16(7968),
	3973: uint16(18848),
	3974: uint16(18880),
	3975: uint16(8000),
	3976: uint16(18912),
	3977: uint16(4928),
	3978: uint16(4928),
	3979: uint16(4928),
	3980: uint16(4928),
	3981: uint16(18944),
	3982: uint16(3296),
	3983: uint16(18976),
	3984: uint16(19008),
	3985: uint16(19040),
	3986: uint16(19072),
	3987: uint16(19104),
	3988: uint16(3296),
	3989: uint16(3296),
	3990: uint16(3296),
	3991: uint16(3296),
	3992: uint16(4928),
	3993: uint16(4928),
	3994: uint16(4928),
	3995: uint16(4928),
	3996: uint16(4928),
	3997: uint16(4928),
	3998: uint16(4928),
	3999: uint16(19136),
	4000: uint16(4928),
	4001: uint16(4928),
	4002: uint16(4928),
	4003: uint16(4928),
	4004: uint16(4928),
	4005: uint16(4928),
	4006: uint16(4928),
	4007: uint16(4928),
	4008: uint16(4928),
	4009: uint16(4928),
	4010: uint16(4928),
	4011: uint16(4928),
	4012: uint16(4928),
	4013: uint16(4928),
	4014: uint16(4928),
	4015: uint16(4928),
	4016: uint16(4928),
	4017: uint16(4928),
	4018: uint16(4928),
	4019: uint16(4928),
	4020: uint16(4928),
	4021: uint16(4928),
	4022: uint16(19168),
	4023: uint16(19200),
	4024: uint16(4928),
	4025: uint16(4928),
	4026: uint16(4928),
	4027: uint16(19232),
	4028: uint16(4928),
	4029: uint16(4928),
	4030: uint16(19264),
	4031: uint16(19296),
	4032: uint16(18816),
	4033: uint16(4928),
	4034: uint16(19328),
	4035: uint16(4928),
	4036: uint16(19360),
	4037: uint16(19392),
	4038: uint16(19424),
	4039: uint16(3296),
	4040: uint16(4928),
	4041: uint16(4928),
	4042: uint16(4928),
	4043: uint16(4928),
	4044: uint16(4928),
	4045: uint16(4928),
	4046: uint16(4928),
	4047: uint16(4928),
	4048: uint16(4928),
	4049: uint16(4928),
	4050: uint16(7968),
	4051: uint16(19456),
	4052: uint16(19488),
	4053: uint16(4928),
	4054: uint16(19520),
	4055: uint16(19552),
	4056: uint16(4928),
	4057: uint16(4928),
	4058: uint16(4928),
	4059: uint16(4928),
	4060: uint16(19584),
	4061: uint16(4928),
	4062: uint16(4928),
	4063: uint16(16512),
	4064: uint16(3296),
	4065: uint16(3296),
	4066: uint16(3296),
	4067: uint16(3296),
	4068: uint16(3296),
	4069: uint16(3296),
	4070: uint16(3296),
	4071: uint16(3296),
	4072: uint16(3296),
	4073: uint16(3296),
	4074: uint16(3296),
	4075: uint16(3296),
	4076: uint16(3296),
	4077: uint16(3296),
	4078: uint16(3296),
	4079: uint16(3296),
	4080: uint16(3296),
	4081: uint16(3296),
	4082: uint16(3296),
	4083: uint16(3296),
	4084: uint16(3296),
	4085: uint16(3296),
	4086: uint16(3296),
	4087: uint16(3296),
	4088: uint16(3296),
	4089: uint16(3296),
	4090: uint16(3296),
	4091: uint16(3296),
	4092: uint16(3296),
	4093: uint16(3296),
	4094: uint16(3296),
	4095: uint16(3296),
	4096: uint16(1344),
	4097: uint16(1344),
	4098: uint16(1344),
	4099: uint16(1344),
	4100: uint16(1344),
	4101: uint16(1344),
	4102: uint16(1344),
	4103: uint16(1344),
	4104: uint16(1344),
	4105: uint16(1344),
	4106: uint16(1344),
	4107: uint16(1344),
	4108: uint16(1344),
	4109: uint16(1344),
	4110: uint16(1344),
	4111: uint16(1344),
	4112: uint16(1344),
	4113: uint16(1344),
	4114: uint16(1344),
	4115: uint16(1344),
	4116: uint16(1344),
	4117: uint16(1344),
	4118: uint16(1344),
	4119: uint16(1344),
	4120: uint16(1344),
	4121: uint16(1344),
	4122: uint16(1344),
	4123: uint16(1344),
	4124: uint16(1344),
	4125: uint16(1344),
	4126: uint16(1344),
	4127: uint16(1344),
	4128: uint16(1344),
	4129: uint16(1344),
	4130: uint16(1344),
	4131: uint16(1344),
	4132: uint16(1344),
	4133: uint16(1344),
	4134: uint16(1344),
	4135: uint16(1344),
	4136: uint16(1344),
	4137: uint16(1344),
	4138: uint16(1344),
	4139: uint16(1344),
	4140: uint16(1344),
	4141: uint16(1344),
	4142: uint16(1344),
	4143: uint16(1344),
	4144: uint16(1344),
	4145: uint16(1344),
	4146: uint16(1344),
	4147: uint16(1344),
	4148: uint16(1344),
	4149: uint16(1344),
	4150: uint16(1344),
	4151: uint16(1344),
	4152: uint16(1344),
	4153: uint16(1344),
	4154: uint16(1344),
	4155: uint16(1344),
	4156: uint16(1344),
	4157: uint16(1344),
	4158: uint16(1344),
	4159: uint16(1344),
	4160: uint16(1344),
	4161: uint16(1344),
	4162: uint16(1344),
	4163: uint16(1344),
	4164: uint16(1344),
	4165: uint16(1344),
	4166: uint16(1344),
	4167: uint16(1344),
	4168: uint16(1344),
	4169: uint16(1344),
	4170: uint16(1344),
	4171: uint16(1344),
	4172: uint16(1344),
	4173: uint16(1344),
	4174: uint16(1344),
	4175: uint16(1344),
	4176: uint16(1344),
	4177: uint16(1344),
	4178: uint16(1344),
	4179: uint16(1344),
	4180: uint16(1344),
	4181: uint16(1344),
	4182: uint16(1344),
	4183: uint16(1344),
	4184: uint16(1344),
	4185: uint16(1344),
	4186: uint16(1344),
	4187: uint16(1344),
	4188: uint16(1344),
	4189: uint16(1344),
	4190: uint16(1344),
	4191: uint16(1344),
	4192: uint16(1344),
	4193: uint16(1344),
	4194: uint16(1344),
	4195: uint16(1344),
	4196: uint16(1344),
	4197: uint16(1344),
	4198: uint16(1344),
	4199: uint16(1344),
	4200: uint16(1344),
	4201: uint16(1344),
	4202: uint16(1344),
	4203: uint16(1344),
	4204: uint16(1344),
	4205: uint16(1344),
	4206: uint16(1344),
	4207: uint16(1344),
	4208: uint16(1344),
	4209: uint16(1344),
	4210: uint16(1344),
	4211: uint16(1344),
	4212: uint16(1344),
	4213: uint16(1344),
	4214: uint16(1344),
	4215: uint16(1344),
	4216: uint16(1344),
	4217: uint16(1344),
	4218: uint16(1344),
	4219: uint16(1344),
	4220: uint16(1344),
	4221: uint16(1344),
	4222: uint16(1344),
	4223: uint16(1344),
	4224: uint16(1344),
	4225: uint16(1344),
	4226: uint16(1344),
	4227: uint16(1344),
	4228: uint16(1344),
	4229: uint16(1344),
	4230: uint16(1344),
	4231: uint16(1344),
	4232: uint16(1344),
	4233: uint16(1344),
	4234: uint16(1344),
	4235: uint16(1344),
	4236: uint16(1344),
	4237: uint16(1344),
	4238: uint16(1344),
	4239: uint16(1344),
	4240: uint16(1344),
	4241: uint16(1344),
	4242: uint16(1344),
	4243: uint16(1344),
	4244: uint16(1344),
	4245: uint16(1344),
	4246: uint16(1344),
	4247: uint16(1344),
	4248: uint16(1344),
	4249: uint16(1344),
	4250: uint16(1344),
	4251: uint16(1344),
	4252: uint16(1344),
	4253: uint16(1344),
	4254: uint16(1344),
	4255: uint16(1344),
	4256: uint16(1344),
	4257: uint16(1344),
	4258: uint16(1344),
	4259: uint16(1344),
	4260: uint16(1344),
	4261: uint16(1344),
	4262: uint16(1344),
	4263: uint16(1344),
	4264: uint16(1344),
	4265: uint16(1344),
	4266: uint16(1344),
	4267: uint16(1344),
	4268: uint16(1344),
	4269: uint16(1344),
	4270: uint16(1344),
	4271: uint16(1344),
	4272: uint16(1344),
	4273: uint16(1344),
	4274: uint16(1344),
	4275: uint16(1344),
	4276: uint16(1344),
	4277: uint16(1344),
	4278: uint16(1344),
	4279: uint16(1344),
	4280: uint16(1344),
	4281: uint16(1344),
	4282: uint16(1344),
	4283: uint16(1344),
	4284: uint16(1344),
	4285: uint16(1344),
	4286: uint16(1344),
	4287: uint16(1344),
	4288: uint16(1344),
	4289: uint16(1344),
	4290: uint16(1344),
	4291: uint16(1344),
	4292: uint16(1344),
	4293: uint16(1344),
	4294: uint16(1344),
	4295: uint16(1344),
	4296: uint16(1344),
	4297: uint16(1344),
	4298: uint16(1344),
	4299: uint16(1344),
	4300: uint16(1344),
	4301: uint16(1344),
	4302: uint16(1344),
	4303: uint16(1344),
	4304: uint16(1344),
	4305: uint16(1344),
	4306: uint16(1344),
	4307: uint16(1344),
	4308: uint16(1344),
	4309: uint16(1344),
	4310: uint16(1344),
	4311: uint16(1344),
	4312: uint16(1344),
	4313: uint16(1344),
	4314: uint16(1344),
	4315: uint16(1344),
	4316: uint16(1344),
	4317: uint16(1344),
	4318: uint16(1344),
	4319: uint16(1344),
	4320: uint16(1344),
	4321: uint16(1344),
	4322: uint16(1344),
	4323: uint16(1344),
	4324: uint16(1344),
	4325: uint16(1344),
	4326: uint16(1344),
	4327: uint16(1344),
	4328: uint16(1344),
	4329: uint16(1344),
	4330: uint16(1344),
	4331: uint16(1344),
	4332: uint16(1344),
	4333: uint16(1344),
	4334: uint16(1344),
	4335: uint16(1344),
	4336: uint16(1344),
	4337: uint16(1344),
	4338: uint16(1344),
	4339: uint16(1344),
	4340: uint16(1344),
	4341: uint16(1344),
	4342: uint16(1344),
	4343: uint16(1344),
	4344: uint16(1344),
	4345: uint16(1344),
	4346: uint16(1344),
	4347: uint16(1344),
	4348: uint16(1344),
	4349: uint16(1344),
	4350: uint16(1344),
	4351: uint16(1344),
	4352: uint16(1344),
	4353: uint16(1344),
	4354: uint16(1344),
	4355: uint16(1344),
	4356: uint16(1344),
	4357: uint16(1344),
	4358: uint16(1344),
	4359: uint16(1344),
	4360: uint16(1344),
	4361: uint16(1344),
	4362: uint16(1344),
	4363: uint16(1344),
	4364: uint16(1344),
	4365: uint16(1344),
	4366: uint16(1344),
	4367: uint16(1344),
	4368: uint16(1344),
	4369: uint16(1344),
	4370: uint16(1344),
	4371: uint16(1344),
	4372: uint16(1344),
	4373: uint16(1344),
	4374: uint16(1344),
	4375: uint16(1344),
	4376: uint16(1344),
	4377: uint16(1344),
	4378: uint16(1344),
	4379: uint16(1344),
	4380: uint16(1344),
	4381: uint16(1344),
	4382: uint16(1344),
	4383: uint16(1344),
	4384: uint16(1344),
	4385: uint16(1344),
	4386: uint16(1344),
	4387: uint16(1344),
	4388: uint16(1344),
	4389: uint16(1344),
	4390: uint16(1344),
	4391: uint16(1344),
	4392: uint16(1344),
	4393: uint16(1344),
	4394: uint16(1344),
	4395: uint16(1344),
	4396: uint16(1344),
	4397: uint16(1344),
	4398: uint16(1344),
	4399: uint16(1344),
	4400: uint16(1344),
	4401: uint16(1344),
	4402: uint16(1344),
	4403: uint16(1344),
	4404: uint16(1344),
	4405: uint16(1344),
	4406: uint16(1344),
	4407: uint16(1344),
	4408: uint16(1344),
	4409: uint16(1344),
	4410: uint16(1344),
	4411: uint16(1344),
	4412: uint16(1344),
	4413: uint16(1344),
	4414: uint16(1344),
	4415: uint16(1344),
	4416: uint16(1344),
	4417: uint16(1344),
	4418: uint16(1344),
	4419: uint16(1344),
	4420: uint16(1344),
	4421: uint16(1344),
	4422: uint16(1344),
	4423: uint16(1344),
	4424: uint16(1344),
	4425: uint16(1344),
	4426: uint16(1344),
	4427: uint16(1344),
	4428: uint16(1344),
	4429: uint16(1344),
	4430: uint16(1344),
	4431: uint16(1344),
	4432: uint16(1344),
	4433: uint16(1344),
	4434: uint16(1344),
	4435: uint16(1344),
	4436: uint16(1344),
	4437: uint16(1344),
	4438: uint16(1344),
	4439: uint16(1344),
	4440: uint16(1344),
	4441: uint16(1344),
	4442: uint16(1344),
	4443: uint16(1344),
	4444: uint16(1344),
	4445: uint16(1344),
	4446: uint16(1344),
	4447: uint16(1344),
	4448: uint16(1344),
	4449: uint16(1344),
	4450: uint16(1344),
	4451: uint16(1344),
	4452: uint16(1344),
	4453: uint16(1344),
	4454: uint16(1344),
	4455: uint16(1344),
	4456: uint16(1344),
	4457: uint16(1344),
	4458: uint16(1344),
	4459: uint16(1344),
	4460: uint16(1344),
	4461: uint16(1344),
	4462: uint16(1344),
	4463: uint16(1344),
	4464: uint16(1344),
	4465: uint16(1344),
	4466: uint16(1344),
	4467: uint16(1344),
	4468: uint16(1344),
	4469: uint16(1344),
	4470: uint16(1344),
	4471: uint16(1344),
	4472: uint16(1344),
	4473: uint16(1344),
	4474: uint16(1344),
	4475: uint16(1344),
	4476: uint16(1344),
	4477: uint16(1344),
	4478: uint16(1344),
	4479: uint16(1344),
	4480: uint16(1344),
	4481: uint16(1344),
	4482: uint16(1344),
	4483: uint16(1344),
	4484: uint16(1344),
	4485: uint16(1344),
	4486: uint16(1344),
	4487: uint16(1344),
	4488: uint16(1344),
	4489: uint16(1344),
	4490: uint16(1344),
	4491: uint16(1344),
	4492: uint16(1344),
	4493: uint16(1344),
	4494: uint16(1344),
	4495: uint16(1344),
	4496: uint16(1344),
	4497: uint16(1344),
	4498: uint16(1344),
	4499: uint16(1344),
	4500: uint16(1344),
	4501: uint16(1344),
	4502: uint16(1344),
	4503: uint16(1344),
	4504: uint16(1344),
	4505: uint16(1344),
	4506: uint16(1344),
	4507: uint16(1344),
	4508: uint16(1344),
	4509: uint16(1344),
	4510: uint16(1344),
	4511: uint16(1344),
	4512: uint16(1344),
	4513: uint16(1344),
	4514: uint16(1344),
	4515: uint16(1344),
	4516: uint16(1344),
	4517: uint16(1344),
	4518: uint16(1344),
	4519: uint16(1344),
	4520: uint16(1344),
	4521: uint16(1344),
	4522: uint16(1344),
	4523: uint16(1344),
	4524: uint16(1344),
	4525: uint16(1344),
	4526: uint16(1344),
	4527: uint16(1344),
	4528: uint16(1344),
	4529: uint16(1344),
	4530: uint16(1344),
	4531: uint16(1344),
	4532: uint16(1344),
	4533: uint16(1344),
	4534: uint16(1344),
	4535: uint16(1344),
	4536: uint16(1344),
	4537: uint16(1344),
	4538: uint16(1344),
	4539: uint16(1344),
	4540: uint16(1344),
	4541: uint16(1344),
	4542: uint16(1344),
	4543: uint16(1344),
	4544: uint16(1344),
	4545: uint16(1344),
	4546: uint16(1344),
	4547: uint16(1344),
	4548: uint16(1344),
	4549: uint16(1344),
	4550: uint16(1344),
	4551: uint16(1344),
	4552: uint16(1344),
	4553: uint16(1344),
	4554: uint16(1344),
	4555: uint16(1344),
	4556: uint16(1344),
	4557: uint16(1344),
	4558: uint16(1344),
	4559: uint16(1344),
	4560: uint16(1344),
	4561: uint16(1344),
	4562: uint16(1344),
	4563: uint16(1344),
	4564: uint16(1344),
	4565: uint16(1344),
	4566: uint16(1344),
	4567: uint16(1344),
	4568: uint16(1344),
	4569: uint16(1344),
	4570: uint16(1344),
	4571: uint16(1344),
	4572: uint16(1344),
	4573: uint16(1344),
	4574: uint16(1344),
	4575: uint16(1344),
	4576: uint16(1344),
	4577: uint16(1344),
	4578: uint16(1344),
	4579: uint16(1344),
	4580: uint16(1344),
	4581: uint16(1344),
	4582: uint16(1344),
	4583: uint16(1344),
	4584: uint16(1344),
	4585: uint16(1344),
	4586: uint16(1344),
	4587: uint16(1344),
	4588: uint16(1344),
	4589: uint16(1344),
	4590: uint16(1344),
	4591: uint16(1344),
	4592: uint16(1344),
	4593: uint16(1344),
	4594: uint16(1344),
	4595: uint16(1344),
	4596: uint16(1344),
	4597: uint16(1344),
	4598: uint16(1344),
	4599: uint16(1344),
	4600: uint16(1344),
	4601: uint16(1344),
	4602: uint16(1344),
	4603: uint16(1344),
	4604: uint16(1344),
	4605: uint16(1344),
	4606: uint16(1344),
	4607: uint16(1344),
	4608: uint16(1344),
	4609: uint16(1344),
	4610: uint16(1344),
	4611: uint16(1344),
	4612: uint16(1344),
	4613: uint16(1344),
	4614: uint16(1344),
	4615: uint16(1344),
	4616: uint16(1344),
	4617: uint16(1344),
	4618: uint16(1344),
	4619: uint16(1344),
	4620: uint16(1344),
	4621: uint16(1344),
	4622: uint16(1344),
	4623: uint16(1344),
	4624: uint16(1344),
	4625: uint16(1344),
	4626: uint16(1344),
	4627: uint16(1344),
	4628: uint16(1344),
	4629: uint16(1344),
	4630: uint16(1344),
	4631: uint16(1344),
	4632: uint16(1344),
	4633: uint16(1344),
	4634: uint16(1344),
	4635: uint16(1344),
	4636: uint16(1344),
	4637: uint16(1344),
	4638: uint16(1344),
	4639: uint16(1344),
	4640: uint16(1344),
	4641: uint16(1344),
	4642: uint16(1344),
	4643: uint16(1344),
	4644: uint16(1344),
	4645: uint16(1344),
	4646: uint16(1344),
	4647: uint16(1344),
	4648: uint16(1344),
	4649: uint16(1344),
	4650: uint16(1344),
	4651: uint16(1344),
	4652: uint16(1344),
	4653: uint16(1344),
	4654: uint16(1344),
	4655: uint16(1344),
	4656: uint16(1344),
	4657: uint16(1344),
	4658: uint16(1344),
	4659: uint16(1344),
	4660: uint16(1344),
	4661: uint16(1344),
	4662: uint16(1344),
	4663: uint16(1344),
	4664: uint16(1344),
	4665: uint16(1344),
	4666: uint16(1344),
	4667: uint16(1344),
	4668: uint16(1344),
	4669: uint16(1344),
	4670: uint16(1344),
	4671: uint16(1344),
	4672: uint16(1344),
	4673: uint16(1344),
	4674: uint16(1344),
	4675: uint16(1344),
	4676: uint16(1344),
	4677: uint16(1344),
	4678: uint16(1344),
	4679: uint16(1344),
	4680: uint16(1344),
	4681: uint16(1344),
	4682: uint16(1344),
	4683: uint16(1344),
	4684: uint16(1344),
	4685: uint16(1344),
	4686: uint16(1344),
	4687: uint16(1344),
	4688: uint16(1344),
	4689: uint16(1344),
	4690: uint16(1344),
	4691: uint16(1344),
	4692: uint16(1344),
	4693: uint16(1344),
	4694: uint16(1344),
	4695: uint16(1344),
	4696: uint16(1344),
	4697: uint16(1344),
	4698: uint16(1344),
	4699: uint16(1344),
	4700: uint16(1344),
	4701: uint16(1344),
	4702: uint16(1344),
	4703: uint16(1344),
	4704: uint16(1344),
	4705: uint16(1344),
	4706: uint16(1344),
	4707: uint16(1344),
	4708: uint16(1344),
	4709: uint16(1344),
	4710: uint16(1344),
	4711: uint16(1344),
	4712: uint16(1344),
	4713: uint16(1344),
	4714: uint16(1344),
	4715: uint16(1344),
	4716: uint16(1344),
	4717: uint16(1344),
	4718: uint16(1344),
	4719: uint16(1344),
	4720: uint16(1344),
	4721: uint16(1344),
	4722: uint16(1344),
	4723: uint16(1344),
	4724: uint16(1344),
	4725: uint16(1344),
	4726: uint16(1344),
	4727: uint16(1344),
	4728: uint16(1344),
	4729: uint16(1344),
	4730: uint16(1344),
	4731: uint16(1344),
	4732: uint16(1344),
	4733: uint16(1344),
	4734: uint16(1344),
	4735: uint16(1344),
	4736: uint16(1344),
	4737: uint16(1344),
	4738: uint16(1344),
	4739: uint16(1344),
	4740: uint16(1344),
	4741: uint16(1344),
	4742: uint16(1344),
	4743: uint16(1344),
	4744: uint16(1344),
	4745: uint16(1344),
	4746: uint16(1344),
	4747: uint16(1344),
	4748: uint16(1344),
	4749: uint16(1344),
	4750: uint16(1344),
	4751: uint16(1344),
	4752: uint16(1344),
	4753: uint16(1344),
	4754: uint16(1344),
	4755: uint16(1344),
	4756: uint16(1344),
	4757: uint16(1344),
	4758: uint16(1344),
	4759: uint16(1344),
	4760: uint16(1344),
	4761: uint16(1344),
	4762: uint16(1344),
	4763: uint16(1344),
	4764: uint16(1344),
	4765: uint16(1344),
	4766: uint16(1344),
	4767: uint16(1344),
	4768: uint16(1344),
	4769: uint16(1344),
	4770: uint16(1344),
	4771: uint16(1344),
	4772: uint16(1344),
	4773: uint16(1344),
	4774: uint16(1344),
	4775: uint16(1344),
	4776: uint16(1344),
	4777: uint16(1344),
	4778: uint16(1344),
	4779: uint16(1344),
	4780: uint16(1344),
	4781: uint16(1344),
	4782: uint16(1344),
	4783: uint16(1344),
	4784: uint16(1344),
	4785: uint16(1344),
	4786: uint16(1344),
	4787: uint16(1344),
	4788: uint16(1344),
	4789: uint16(1344),
	4790: uint16(1344),
	4791: uint16(1344),
	4792: uint16(1344),
	4793: uint16(1344),
	4794: uint16(1344),
	4795: uint16(1344),
	4796: uint16(1344),
	4797: uint16(1344),
	4798: uint16(1344),
	4799: uint16(1344),
	4800: uint16(1344),
	4801: uint16(1344),
	4802: uint16(1344),
	4803: uint16(1344),
	4804: uint16(1344),
	4805: uint16(1344),
	4806: uint16(1344),
	4807: uint16(1344),
	4808: uint16(1344),
	4809: uint16(1344),
	4810: uint16(1344),
	4811: uint16(1344),
	4812: uint16(1344),
	4813: uint16(1344),
	4814: uint16(1344),
	4815: uint16(1344),
	4816: uint16(1344),
	4817: uint16(1344),
	4818: uint16(1344),
	4819: uint16(1344),
	4820: uint16(1344),
	4821: uint16(1344),
	4822: uint16(1344),
	4823: uint16(1344),
	4824: uint16(1344),
	4825: uint16(1344),
	4826: uint16(1344),
	4827: uint16(1344),
	4828: uint16(1344),
	4829: uint16(1344),
	4830: uint16(1344),
	4831: uint16(1344),
	4832: uint16(1344),
	4833: uint16(1344),
	4834: uint16(1344),
	4835: uint16(1344),
	4836: uint16(1344),
	4837: uint16(1344),
	4838: uint16(1344),
	4839: uint16(1344),
	4840: uint16(1344),
	4841: uint16(1344),
	4842: uint16(1344),
	4843: uint16(1344),
	4844: uint16(1344),
	4845: uint16(1344),
	4846: uint16(1344),
	4847: uint16(1344),
	4848: uint16(1344),
	4849: uint16(1344),
	4850: uint16(1344),
	4851: uint16(1344),
	4852: uint16(1344),
	4853: uint16(1344),
	4854: uint16(1344),
	4855: uint16(1344),
	4856: uint16(1344),
	4857: uint16(1344),
	4858: uint16(1344),
	4859: uint16(1344),
	4860: uint16(1344),
	4861: uint16(1344),
	4862: uint16(1344),
	4863: uint16(1344),
	4864: uint16(1344),
	4865: uint16(1344),
	4866: uint16(1344),
	4867: uint16(1344),
	4868: uint16(1344),
	4869: uint16(1344),
	4870: uint16(1344),
	4871: uint16(1344),
	4872: uint16(1344),
	4873: uint16(1344),
	4874: uint16(1344),
	4875: uint16(1344),
	4876: uint16(1344),
	4877: uint16(1344),
	4878: uint16(1344),
	4879: uint16(1344),
	4880: uint16(1344),
	4881: uint16(1344),
	4882: uint16(1344),
	4883: uint16(1344),
	4884: uint16(1344),
	4885: uint16(1344),
	4886: uint16(1344),
	4887: uint16(1344),
	4888: uint16(1344),
	4889: uint16(1344),
	4890: uint16(1344),
	4891: uint16(1344),
	4892: uint16(1344),
	4893: uint16(1344),
	4894: uint16(1344),
	4895: uint16(1344),
	4896: uint16(1344),
	4897: uint16(1344),
	4898: uint16(1344),
	4899: uint16(1344),
	4900: uint16(1344),
	4901: uint16(1344),
	4902: uint16(1344),
	4903: uint16(1344),
	4904: uint16(1344),
	4905: uint16(1344),
	4906: uint16(1344),
	4907: uint16(1344),
	4908: uint16(1344),
	4909: uint16(1344),
	4910: uint16(1344),
	4911: uint16(1344),
	4912: uint16(1344),
	4913: uint16(1344),
	4914: uint16(1344),
	4915: uint16(1344),
	4916: uint16(1344),
	4917: uint16(1344),
	4918: uint16(1344),
	4919: uint16(1344),
	4920: uint16(1344),
	4921: uint16(1344),
	4922: uint16(1344),
	4923: uint16(1344),
	4924: uint16(1344),
	4925: uint16(1344),
	4926: uint16(1344),
	4927: uint16(1344),
	4928: uint16(1344),
	4929: uint16(1344),
	4930: uint16(1344),
	4931: uint16(1344),
	4932: uint16(1344),
	4933: uint16(1344),
	4934: uint16(1344),
	4935: uint16(1344),
	4936: uint16(1344),
	4937: uint16(1344),
	4938: uint16(1344),
	4939: uint16(1344),
	4940: uint16(1344),
	4941: uint16(1344),
	4942: uint16(1344),
	4943: uint16(1344),
	4944: uint16(1344),
	4945: uint16(1344),
	4946: uint16(1344),
	4947: uint16(1344),
	4948: uint16(1344),
	4949: uint16(1344),
	4950: uint16(1344),
	4951: uint16(1344),
	4952: uint16(1344),
	4953: uint16(1344),
	4954: uint16(1344),
	4955: uint16(1344),
	4956: uint16(1344),
	4957: uint16(1344),
	4958: uint16(1344),
	4959: uint16(1344),
	4960: uint16(1344),
	4961: uint16(1344),
	4962: uint16(1344),
	4963: uint16(1344),
	4964: uint16(1344),
	4965: uint16(1344),
	4966: uint16(1344),
	4967: uint16(1344),
	4968: uint16(1344),
	4969: uint16(1344),
	4970: uint16(1344),
	4971: uint16(1344),
	4972: uint16(1344),
	4973: uint16(1344),
	4974: uint16(1344),
	4975: uint16(1344),
	4976: uint16(1344),
	4977: uint16(1344),
	4978: uint16(1344),
	4979: uint16(1344),
	4980: uint16(1344),
	4981: uint16(1344),
	4982: uint16(1344),
	4983: uint16(1344),
	4984: uint16(1344),
	4985: uint16(1344),
	4986: uint16(1344),
	4987: uint16(1344),
	4988: uint16(1344),
	4989: uint16(1344),
	4990: uint16(1344),
	4991: uint16(1344),
	4992: uint16(1344),
	4993: uint16(1344),
	4994: uint16(1344),
	4995: uint16(1344),
	4996: uint16(1344),
	4997: uint16(1344),
	4998: uint16(1344),
	4999: uint16(1344),
	5000: uint16(1344),
	5001: uint16(1344),
	5002: uint16(1344),
	5003: uint16(1344),
	5004: uint16(1344),
	5005: uint16(1344),
	5006: uint16(1344),
	5007: uint16(1344),
	5008: uint16(1344),
	5009: uint16(1344),
	5010: uint16(1344),
	5011: uint16(1344),
	5012: uint16(1344),
	5013: uint16(1344),
	5014: uint16(1344),
	5015: uint16(1344),
	5016: uint16(1344),
	5017: uint16(1344),
	5018: uint16(1344),
	5019: uint16(1344),
	5020: uint16(1344),
	5021: uint16(1344),
	5022: uint16(1344),
	5023: uint16(1344),
	5024: uint16(1344),
	5025: uint16(1344),
	5026: uint16(1344),
	5027: uint16(1344),
	5028: uint16(1344),
	5029: uint16(1344),
	5030: uint16(1344),
	5031: uint16(1344),
	5032: uint16(1344),
	5033: uint16(1344),
	5034: uint16(1344),
	5035: uint16(1344),
	5036: uint16(1344),
	5037: uint16(1344),
	5038: uint16(1344),
	5039: uint16(1344),
	5040: uint16(1344),
	5041: uint16(1344),
	5042: uint16(1344),
	5043: uint16(1344),
	5044: uint16(1344),
	5045: uint16(1344),
	5046: uint16(1344),
	5047: uint16(1344),
	5048: uint16(1344),
	5049: uint16(1344),
	5050: uint16(1344),
	5051: uint16(1344),
	5052: uint16(1344),
	5053: uint16(1344),
	5054: uint16(1344),
	5055: uint16(1344),
	5056: uint16(1344),
	5057: uint16(1344),
	5058: uint16(1344),
	5059: uint16(1344),
	5060: uint16(1344),
	5061: uint16(1344),
	5062: uint16(1344),
	5063: uint16(1344),
	5064: uint16(1344),
	5065: uint16(1344),
	5066: uint16(1344),
	5067: uint16(1344),
	5068: uint16(1344),
	5069: uint16(1344),
	5070: uint16(1344),
	5071: uint16(1344),
	5072: uint16(1344),
	5073: uint16(1344),
	5074: uint16(1344),
	5075: uint16(1344),
	5076: uint16(1344),
	5077: uint16(1344),
	5078: uint16(1344),
	5079: uint16(1344),
	5080: uint16(1344),
	5081: uint16(1344),
	5082: uint16(1344),
	5083: uint16(1344),
	5084: uint16(1344),
	5085: uint16(1344),
	5086: uint16(1344),
	5087: uint16(1344),
	5088: uint16(1344),
	5089: uint16(1344),
	5090: uint16(1344),
	5091: uint16(1344),
	5092: uint16(1344),
	5093: uint16(1344),
	5094: uint16(1344),
	5095: uint16(1344),
	5096: uint16(1344),
	5097: uint16(1344),
	5098: uint16(1344),
	5099: uint16(1344),
	5100: uint16(1344),
	5101: uint16(1344),
	5102: uint16(1344),
	5103: uint16(1344),
	5104: uint16(1344),
	5105: uint16(1344),
	5106: uint16(1344),
	5107: uint16(1344),
	5108: uint16(1344),
	5109: uint16(1344),
	5110: uint16(1344),
	5111: uint16(1344),
	5112: uint16(1344),
	5113: uint16(1344),
	5114: uint16(1344),
	5115: uint16(1344),
	5116: uint16(1344),
	5117: uint16(1344),
	5118: uint16(1344),
	5119: uint16(1344),
	5120: uint16(1344),
	5121: uint16(1344),
	5122: uint16(1344),
	5123: uint16(1344),
	5124: uint16(1344),
	5125: uint16(1344),
	5126: uint16(1344),
	5127: uint16(1344),
	5128: uint16(1344),
	5129: uint16(1344),
	5130: uint16(1344),
	5131: uint16(1344),
	5132: uint16(1344),
	5133: uint16(1344),
	5134: uint16(1344),
	5135: uint16(1344),
	5136: uint16(1344),
	5137: uint16(1344),
	5138: uint16(1344),
	5139: uint16(1344),
	5140: uint16(1344),
	5141: uint16(1344),
	5142: uint16(1344),
	5143: uint16(1344),
	5144: uint16(1344),
	5145: uint16(1344),
	5146: uint16(1344),
	5147: uint16(1344),
	5148: uint16(1344),
	5149: uint16(1344),
	5150: uint16(1344),
	5151: uint16(1344),
	5152: uint16(1344),
	5153: uint16(1344),
	5154: uint16(1344),
	5155: uint16(1344),
	5156: uint16(1344),
	5157: uint16(1344),
	5158: uint16(1344),
	5159: uint16(1344),
	5160: uint16(1344),
	5161: uint16(1344),
	5162: uint16(1344),
	5163: uint16(1344),
	5164: uint16(1344),
	5165: uint16(1344),
	5166: uint16(1344),
	5167: uint16(1344),
	5168: uint16(1344),
	5169: uint16(1344),
	5170: uint16(1344),
	5171: uint16(1344),
	5172: uint16(1344),
	5173: uint16(1344),
	5174: uint16(1344),
	5175: uint16(1344),
	5176: uint16(1344),
	5177: uint16(1344),
	5178: uint16(1344),
	5179: uint16(1344),
	5180: uint16(1344),
	5181: uint16(1344),
	5182: uint16(1344),
	5183: uint16(1344),
	5184: uint16(1344),
	5185: uint16(1344),
	5186: uint16(1344),
	5187: uint16(1344),
	5188: uint16(1344),
	5189: uint16(1344),
	5190: uint16(1344),
	5191: uint16(1344),
	5192: uint16(1344),
	5193: uint16(1344),
	5194: uint16(1344),
	5195: uint16(1344),
	5196: uint16(1344),
	5197: uint16(1344),
	5198: uint16(1344),
	5199: uint16(1344),
	5200: uint16(1344),
	5201: uint16(1344),
	5202: uint16(1344),
	5203: uint16(1344),
	5204: uint16(1344),
	5205: uint16(1344),
	5206: uint16(1344),
	5207: uint16(1344),
	5208: uint16(1344),
	5209: uint16(1344),
	5210: uint16(1344),
	5211: uint16(1344),
	5212: uint16(1344),
	5213: uint16(1344),
	5214: uint16(1344),
	5215: uint16(1344),
	5216: uint16(1344),
	5217: uint16(1344),
	5218: uint16(1344),
	5219: uint16(1344),
	5220: uint16(1344),
	5221: uint16(1344),
	5222: uint16(1344),
	5223: uint16(1344),
	5224: uint16(1344),
	5225: uint16(1344),
	5226: uint16(1344),
	5227: uint16(1344),
	5228: uint16(1344),
	5229: uint16(1344),
	5230: uint16(1344),
	5231: uint16(1344),
	5232: uint16(1344),
	5233: uint16(1344),
	5234: uint16(1344),
	5235: uint16(1344),
	5236: uint16(1344),
	5237: uint16(1344),
	5238: uint16(1344),
	5239: uint16(1344),
	5240: uint16(1344),
	5241: uint16(1344),
	5242: uint16(1344),
	5243: uint16(1344),
	5244: uint16(1344),
	5245: uint16(1344),
	5246: uint16(1344),
	5247: uint16(1344),
	5248: uint16(1344),
	5249: uint16(1344),
	5250: uint16(1344),
	5251: uint16(1344),
	5252: uint16(1344),
	5253: uint16(1344),
	5254: uint16(1344),
	5255: uint16(1344),
	5256: uint16(1344),
	5257: uint16(1344),
	5258: uint16(1344),
	5259: uint16(1344),
	5260: uint16(1344),
	5261: uint16(1344),
	5262: uint16(1344),
	5263: uint16(1344),
	5264: uint16(1344),
	5265: uint16(1344),
	5266: uint16(1344),
	5267: uint16(1344),
	5268: uint16(1344),
	5269: uint16(1344),
	5270: uint16(1344),
	5271: uint16(1344),
	5272: uint16(1344),
	5273: uint16(1344),
	5274: uint16(1344),
	5275: uint16(1344),
	5276: uint16(1344),
	5277: uint16(1344),
	5278: uint16(1344),
	5279: uint16(1344),
	5280: uint16(1344),
	5281: uint16(1344),
	5282: uint16(1344),
	5283: uint16(1344),
	5284: uint16(1344),
	5285: uint16(1344),
	5286: uint16(1344),
	5287: uint16(1344),
	5288: uint16(1344),
	5289: uint16(1344),
	5290: uint16(1344),
	5291: uint16(1344),
	5292: uint16(1344),
	5293: uint16(1344),
	5294: uint16(1344),
	5295: uint16(1344),
	5296: uint16(1344),
	5297: uint16(1344),
	5298: uint16(1344),
	5299: uint16(1344),
	5300: uint16(1344),
	5301: uint16(1344),
	5302: uint16(1344),
	5303: uint16(1344),
	5304: uint16(1344),
	5305: uint16(1344),
	5306: uint16(1344),
	5307: uint16(1344),
	5308: uint16(1344),
	5309: uint16(1344),
	5310: uint16(1344),
	5311: uint16(1344),
	5312: uint16(1344),
	5313: uint16(1344),
	5314: uint16(1344),
	5315: uint16(1344),
	5316: uint16(1344),
	5317: uint16(1344),
	5318: uint16(1344),
	5319: uint16(1344),
	5320: uint16(1344),
	5321: uint16(1344),
	5322: uint16(1344),
	5323: uint16(1344),
	5324: uint16(1344),
	5325: uint16(1344),
	5326: uint16(1344),
	5327: uint16(1344),
	5328: uint16(1344),
	5329: uint16(1344),
	5330: uint16(1344),
	5331: uint16(1344),
	5332: uint16(1344),
	5333: uint16(1344),
	5334: uint16(1344),
	5335: uint16(1344),
	5336: uint16(1344),
	5337: uint16(1344),
	5338: uint16(1344),
	5339: uint16(1344),
	5340: uint16(1344),
	5341: uint16(1344),
	5342: uint16(1344),
	5343: uint16(1344),
	5344: uint16(1344),
	5345: uint16(1344),
	5346: uint16(1344),
	5347: uint16(1344),
	5348: uint16(1344),
	5349: uint16(1344),
	5350: uint16(1344),
	5351: uint16(1344),
	5352: uint16(1344),
	5353: uint16(1344),
	5354: uint16(1344),
	5355: uint16(1344),
	5356: uint16(1344),
	5357: uint16(1344),
	5358: uint16(1344),
	5359: uint16(1344),
	5360: uint16(1344),
	5361: uint16(1344),
	5362: uint16(1344),
	5363: uint16(1344),
	5364: uint16(1344),
	5365: uint16(1344),
	5366: uint16(1344),
	5367: uint16(1344),
	5368: uint16(1344),
	5369: uint16(1344),
	5370: uint16(1344),
	5371: uint16(1344),
	5372: uint16(1344),
	5373: uint16(1344),
	5374: uint16(1344),
	5375: uint16(1344),
	5376: uint16(1344),
	5377: uint16(1344),
	5378: uint16(1344),
	5379: uint16(1344),
	5380: uint16(1344),
	5381: uint16(1344),
	5382: uint16(1344),
	5383: uint16(1344),
	5384: uint16(1344),
	5385: uint16(1344),
	5386: uint16(1344),
	5387: uint16(1344),
	5388: uint16(1344),
	5389: uint16(1344),
	5390: uint16(1344),
	5391: uint16(1344),
	5392: uint16(1344),
	5393: uint16(1344),
	5394: uint16(1344),
	5395: uint16(1344),
	5396: uint16(1344),
	5397: uint16(1344),
	5398: uint16(1344),
	5399: uint16(1344),
	5400: uint16(1344),
	5401: uint16(1344),
	5402: uint16(1344),
	5403: uint16(1344),
	5404: uint16(1344),
	5405: uint16(1344),
	5406: uint16(1344),
	5407: uint16(1344),
	5408: uint16(1344),
	5409: uint16(1344),
	5410: uint16(1344),
	5411: uint16(1344),
	5412: uint16(1344),
	5413: uint16(1344),
	5414: uint16(1344),
	5415: uint16(1344),
	5416: uint16(1344),
	5417: uint16(1344),
	5418: uint16(1344),
	5419: uint16(1344),
	5420: uint16(1344),
	5421: uint16(1344),
	5422: uint16(1344),
	5423: uint16(1344),
	5424: uint16(1344),
	5425: uint16(1344),
	5426: uint16(1344),
	5427: uint16(1344),
	5428: uint16(1344),
	5429: uint16(1344),
	5430: uint16(1344),
	5431: uint16(3296),
	5432: uint16(1344),
	5433: uint16(1344),
	5434: uint16(1344),
	5435: uint16(1344),
	5436: uint16(1344),
	5437: uint16(1344),
	5438: uint16(1344),
	5439: uint16(1344),
	5440: uint16(1344),
	5441: uint16(1344),
	5442: uint16(1344),
	5443: uint16(1344),
	5444: uint16(1344),
	5445: uint16(1344),
	5446: uint16(1344),
	5447: uint16(1344),
	5448: uint16(1344),
	5449: uint16(1344),
	5450: uint16(1344),
	5451: uint16(1344),
	5452: uint16(1344),
	5453: uint16(1344),
	5454: uint16(1344),
	5455: uint16(1344),
	5456: uint16(1344),
	5457: uint16(1344),
	5458: uint16(1344),
	5459: uint16(1344),
	5460: uint16(1344),
	5461: uint16(1344),
	5462: uint16(1344),
	5463: uint16(1344),
	5464: uint16(1344),
	5465: uint16(1344),
	5466: uint16(1344),
	5467: uint16(1344),
	5468: uint16(1344),
	5469: uint16(1344),
	5470: uint16(1344),
	5471: uint16(1344),
	5472: uint16(1344),
	5473: uint16(1344),
	5474: uint16(1344),
	5475: uint16(1344),
	5476: uint16(1344),
	5477: uint16(1344),
	5478: uint16(1344),
	5479: uint16(1344),
	5480: uint16(1344),
	5481: uint16(1344),
	5482: uint16(1344),
	5483: uint16(1344),
	5484: uint16(1344),
	5485: uint16(1344),
	5486: uint16(1344),
	5487: uint16(1344),
	5488: uint16(1344),
	5489: uint16(1344),
	5490: uint16(1344),
	5491: uint16(1344),
	5492: uint16(1344),
	5493: uint16(1344),
	5494: uint16(1344),
	5495: uint16(1344),
	5496: uint16(1344),
	5497: uint16(1344),
	5498: uint16(1344),
	5499: uint16(1344),
	5500: uint16(1344),
	5501: uint16(1344),
	5502: uint16(1344),
	5503: uint16(1344),
	5504: uint16(1344),
	5505: uint16(1344),
	5506: uint16(1344),
	5507: uint16(1344),
	5508: uint16(1344),
	5509: uint16(1344),
	5510: uint16(1344),
	5511: uint16(1344),
	5512: uint16(1344),
	5513: uint16(1344),
	5514: uint16(1344),
	5515: uint16(1344),
	5516: uint16(1344),
	5517: uint16(1344),
	5518: uint16(1344),
	5519: uint16(1344),
	5520: uint16(1344),
	5521: uint16(1344),
	5522: uint16(1344),
	5523: uint16(1344),
	5524: uint16(1344),
	5525: uint16(1344),
	5526: uint16(1344),
	5527: uint16(1344),
	5528: uint16(1344),
	5529: uint16(1344),
	5530: uint16(1344),
	5531: uint16(1344),
	5532: uint16(1344),
	5533: uint16(1344),
	5534: uint16(1344),
	5535: uint16(1344),
	5536: uint16(1344),
	5537: uint16(1344),
	5538: uint16(1344),
	5539: uint16(1344),
	5540: uint16(1344),
	5541: uint16(1344),
	5542: uint16(1344),
	5543: uint16(1344),
	5544: uint16(1344),
	5545: uint16(1344),
	5546: uint16(1344),
	5547: uint16(1344),
	5548: uint16(1344),
	5549: uint16(1344),
	5550: uint16(1344),
	5551: uint16(1344),
	5552: uint16(1344),
	5553: uint16(1344),
	5554: uint16(1344),
	5555: uint16(1344),
	5556: uint16(1344),
	5557: uint16(1344),
	5558: uint16(1344),
	5559: uint16(1344),
	5560: uint16(1344),
	5561: uint16(9920),
	5562: uint16(1344),
	5563: uint16(1344),
	5564: uint16(1344),
	5565: uint16(1344),
	5566: uint16(1344),
	5567: uint16(1344),
	5568: uint16(11296),
	5569: uint16(1344),
	5570: uint16(1344),
	5571: uint16(1344),
	5572: uint16(1344),
	5573: uint16(1344),
	5574: uint16(1344),
	5575: uint16(1344),
	5576: uint16(1344),
	5577: uint16(1344),
	5578: uint16(1344),
	5579: uint16(1344),
	5580: uint16(1344),
	5581: uint16(1344),
	5582: uint16(1344),
	5583: uint16(1344),
	5584: uint16(1344),
	5585: uint16(1344),
	5586: uint16(1344),
	5587: uint16(1344),
	5588: uint16(1344),
	5589: uint16(1344),
	5590: uint16(1344),
	5591: uint16(1344),
	5592: uint16(1344),
	5593: uint16(1344),
	5594: uint16(1344),
	5595: uint16(1344),
	5596: uint16(1344),
	5597: uint16(1344),
	5598: uint16(1344),
	5599: uint16(1344),
	5600: uint16(1344),
	5601: uint16(1344),
	5602: uint16(1344),
	5603: uint16(1344),
	5604: uint16(1344),
	5605: uint16(1344),
	5606: uint16(1344),
	5607: uint16(1344),
	5608: uint16(1344),
	5609: uint16(1344),
	5610: uint16(1344),
	5611: uint16(1344),
	5612: uint16(1344),
	5613: uint16(1344),
	5614: uint16(1344),
	5615: uint16(1344),
	5616: uint16(1344),
	5617: uint16(1344),
	5618: uint16(1344),
	5619: uint16(1344),
	5620: uint16(1344),
	5621: uint16(1344),
	5622: uint16(1344),
	5623: uint16(1344),
	5624: uint16(1344),
	5625: uint16(1344),
	5626: uint16(1344),
	5627: uint16(1344),
	5628: uint16(1344),
	5629: uint16(1344),
	5630: uint16(1344),
	5631: uint16(1344),
	5632: uint16(1344),
	5633: uint16(1344),
	5634: uint16(1344),
	5635: uint16(1344),
	5636: uint16(1344),
	5637: uint16(1344),
	5638: uint16(1344),
	5639: uint16(1344),
	5640: uint16(1344),
	5641: uint16(1344),
	5642: uint16(1344),
	5643: uint16(1344),
	5644: uint16(1344),
	5645: uint16(1344),
	5646: uint16(1344),
	5647: uint16(1344),
	5648: uint16(1344),
	5649: uint16(1344),
	5650: uint16(1344),
	5651: uint16(1344),
	5652: uint16(1344),
	5653: uint16(1344),
	5654: uint16(1344),
	5655: uint16(1344),
	5656: uint16(1344),
	5657: uint16(1344),
	5658: uint16(1344),
	5659: uint16(1344),
	5660: uint16(1344),
	5661: uint16(1344),
	5662: uint16(1344),
	5663: uint16(1344),
	5664: uint16(1344),
	5665: uint16(1344),
	5666: uint16(1344),
	5667: uint16(1344),
	5668: uint16(1344),
	5669: uint16(1344),
	5670: uint16(1344),
	5671: uint16(1344),
	5672: uint16(1344),
	5673: uint16(1344),
	5674: uint16(1344),
	5675: uint16(1344),
	5676: uint16(1344),
	5677: uint16(1344),
	5678: uint16(1344),
	5679: uint16(1344),
	5680: uint16(1344),
	5681: uint16(1344),
	5682: uint16(1344),
	5683: uint16(1344),
	5684: uint16(1344),
	5685: uint16(1344),
	5686: uint16(1344),
	5687: uint16(1344),
	5688: uint16(1344),
	5689: uint16(1344),
	5690: uint16(1344),
	5691: uint16(1344),
	5692: uint16(1344),
	5693: uint16(1344),
	5694: uint16(1344),
	5695: uint16(1344),
	5696: uint16(1344),
	5697: uint16(1344),
	5698: uint16(1344),
	5699: uint16(1344),
	5700: uint16(1344),
	5701: uint16(1344),
	5702: uint16(1344),
	5703: uint16(1344),
	5704: uint16(1344),
	5705: uint16(1344),
	5706: uint16(1344),
	5707: uint16(1344),
	5708: uint16(1344),
	5709: uint16(1344),
	5710: uint16(1344),
	5711: uint16(1344),
	5712: uint16(1344),
	5713: uint16(1344),
	5714: uint16(1344),
	5715: uint16(1344),
	5716: uint16(1344),
	5717: uint16(1344),
	5718: uint16(1344),
	5719: uint16(1344),
	5720: uint16(1344),
	5721: uint16(1344),
	5722: uint16(1344),
	5723: uint16(1344),
	5724: uint16(1344),
	5725: uint16(1344),
	5726: uint16(1344),
	5727: uint16(1344),
	5728: uint16(1344),
	5729: uint16(1344),
	5730: uint16(1344),
	5731: uint16(1344),
	5732: uint16(1344),
	5733: uint16(1344),
	5734: uint16(1344),
	5735: uint16(1344),
	5736: uint16(1344),
	5737: uint16(1344),
	5738: uint16(1344),
	5739: uint16(1344),
	5740: uint16(1344),
	5741: uint16(1344),
	5742: uint16(1344),
	5743: uint16(1344),
	5744: uint16(1344),
	5745: uint16(1344),
	5746: uint16(1344),
	5747: uint16(1344),
	5748: uint16(1344),
	5749: uint16(19616),
	5750: uint16(1344),
	5751: uint16(1344),
	5752: uint16(1344),
	5753: uint16(1344),
	5754: uint16(1344),
	5755: uint16(1344),
	5756: uint16(1344),
	5757: uint16(1344),
	5758: uint16(1344),
	5759: uint16(1344),
	5760: uint16(1344),
	5761: uint16(1344),
	5762: uint16(1344),
	5763: uint16(1344),
	5764: uint16(1344),
	5765: uint16(1344),
	5766: uint16(1344),
	5767: uint16(1344),
	5768: uint16(1344),
	5769: uint16(1344),
	5770: uint16(1344),
	5771: uint16(1344),
	5772: uint16(1344),
	5773: uint16(1344),
	5774: uint16(1344),
	5775: uint16(1344),
	5776: uint16(1344),
	5777: uint16(1344),
	5778: uint16(1344),
	5779: uint16(1344),
	5780: uint16(1344),
	5781: uint16(1344),
	5782: uint16(1344),
	5783: uint16(1344),
	5784: uint16(1344),
	5785: uint16(1344),
	5786: uint16(1344),
	5787: uint16(1344),
	5788: uint16(1344),
	5789: uint16(1344),
	5790: uint16(1344),
	5791: uint16(1344),
	5792: uint16(1344),
	5793: uint16(1344),
	5794: uint16(1344),
	5795: uint16(1344),
	5796: uint16(1344),
	5797: uint16(1344),
	5798: uint16(1344),
	5799: uint16(1344),
	5800: uint16(1344),
	5801: uint16(1344),
	5802: uint16(1344),
	5803: uint16(1344),
	5804: uint16(1344),
	5805: uint16(1344),
	5806: uint16(1344),
	5807: uint16(1344),
	5808: uint16(1344),
	5809: uint16(1344),
	5810: uint16(1344),
	5811: uint16(1344),
	5812: uint16(1344),
	5813: uint16(1344),
	5814: uint16(1344),
	5815: uint16(1344),
	5816: uint16(1344),
	5817: uint16(1344),
	5818: uint16(1344),
	5819: uint16(1344),
	5820: uint16(1344),
	5821: uint16(1344),
	5822: uint16(1344),
	5823: uint16(1344),
	5824: uint16(1344),
	5825: uint16(1344),
	5826: uint16(1344),
	5827: uint16(1344),
	5828: uint16(1344),
	5829: uint16(1344),
	5830: uint16(1344),
	5831: uint16(1344),
	5832: uint16(1344),
	5833: uint16(1344),
	5834: uint16(1344),
	5835: uint16(1344),
	5836: uint16(1344),
	5837: uint16(1344),
	5838: uint16(1344),
	5839: uint16(1344),
	5840: uint16(1344),
	5841: uint16(1344),
	5842: uint16(1344),
	5843: uint16(1344),
	5844: uint16(1344),
	5845: uint16(1344),
	5846: uint16(1344),
	5847: uint16(1344),
	5848: uint16(1344),
	5849: uint16(1344),
	5850: uint16(1344),
	5851: uint16(1344),
	5852: uint16(1344),
	5853: uint16(1344),
	5854: uint16(1344),
	5855: uint16(1344),
	5856: uint16(1344),
	5857: uint16(1344),
	5858: uint16(1344),
	5859: uint16(1344),
	5860: uint16(1344),
	5861: uint16(1344),
	5862: uint16(1344),
	5863: uint16(1344),
	5864: uint16(1344),
	5865: uint16(1344),
	5866: uint16(1344),
	5867: uint16(1344),
	5868: uint16(1344),
	5869: uint16(1344),
	5870: uint16(1344),
	5871: uint16(1344),
	5872: uint16(1344),
	5873: uint16(1344),
	5874: uint16(1344),
	5875: uint16(1344),
	5876: uint16(1344),
	5877: uint16(1344),
	5878: uint16(1344),
	5879: uint16(1344),
	5880: uint16(1344),
	5881: uint16(1344),
	5882: uint16(1344),
	5883: uint16(1344),
	5884: uint16(1344),
	5885: uint16(1344),
	5886: uint16(1344),
	5887: uint16(1344),
	5888: uint16(1344),
	5889: uint16(1344),
	5890: uint16(1344),
	5891: uint16(1344),
	5892: uint16(1344),
	5893: uint16(1344),
	5894: uint16(1344),
	5895: uint16(1344),
	5896: uint16(1344),
	5897: uint16(1344),
	5898: uint16(1344),
	5899: uint16(1344),
	5900: uint16(1344),
	5901: uint16(1344),
	5902: uint16(1344),
	5903: uint16(1344),
	5904: uint16(1344),
	5905: uint16(1344),
	5906: uint16(1344),
	5907: uint16(1344),
	5908: uint16(1344),
	5909: uint16(1344),
	5910: uint16(1344),
	5911: uint16(1344),
	5912: uint16(1344),
	5913: uint16(1344),
	5914: uint16(1344),
	5915: uint16(1344),
	5916: uint16(1344),
	5917: uint16(1344),
	5918: uint16(1344),
	5919: uint16(1344),
	5920: uint16(1344),
	5921: uint16(1344),
	5922: uint16(1344),
	5923: uint16(1344),
	5924: uint16(1344),
	5925: uint16(1344),
	5926: uint16(1344),
	5927: uint16(1344),
	5928: uint16(1344),
	5929: uint16(1344),
	5930: uint16(1344),
	5931: uint16(1344),
	5932: uint16(1344),
	5933: uint16(1344),
	5934: uint16(1344),
	5935: uint16(1344),
	5936: uint16(1344),
	5937: uint16(1344),
	5938: uint16(1344),
	5939: uint16(1344),
	5940: uint16(1344),
	5941: uint16(1344),
	5942: uint16(1344),
	5943: uint16(1344),
	5944: uint16(1344),
	5945: uint16(1344),
	5946: uint16(1344),
	5947: uint16(1344),
	5948: uint16(1344),
	5949: uint16(1344),
	5950: uint16(1344),
	5951: uint16(1344),
	5952: uint16(1344),
	5953: uint16(1344),
	5954: uint16(1344),
	5955: uint16(1344),
	5956: uint16(1344),
	5957: uint16(1344),
	5958: uint16(1344),
	5959: uint16(1344),
	5960: uint16(1344),
	5961: uint16(1344),
	5962: uint16(1344),
	5963: uint16(1344),
	5964: uint16(1344),
	5965: uint16(1344),
	5966: uint16(1344),
	5967: uint16(1344),
	5968: uint16(1344),
	5969: uint16(1344),
	5970: uint16(1344),
	5971: uint16(1344),
	5972: uint16(1344),
	5973: uint16(1344),
	5974: uint16(1344),
	5975: uint16(1344),
	5976: uint16(1344),
	5977: uint16(1344),
	5978: uint16(1344),
	5979: uint16(1344),
	5980: uint16(1344),
	5981: uint16(1344),
	5982: uint16(1344),
	5983: uint16(19648),
	5984: uint16(1344),
	5985: uint16(1344),
	5986: uint16(1344),
	5987: uint16(1344),
	5988: uint16(1344),
	5989: uint16(1344),
	5990: uint16(1344),
	5991: uint16(1344),
	5992: uint16(1344),
	5993: uint16(1344),
	5994: uint16(1344),
	5995: uint16(1344),
	5996: uint16(1344),
	5997: uint16(1344),
	5998: uint16(1344),
	5999: uint16(1344),
	6000: uint16(1344),
	6001: uint16(1344),
	6002: uint16(11296),
	6003: uint16(3296),
	6004: uint16(3296),
	6005: uint16(3296),
	6006: uint16(3296),
	6007: uint16(3296),
	6008: uint16(3296),
	6009: uint16(3296),
	6010: uint16(3296),
	6011: uint16(3296),
	6012: uint16(3296),
	6013: uint16(3296),
	6014: uint16(3296),
	6015: uint16(3296),
	6016: uint16(3296),
	6017: uint16(3296),
	6018: uint16(3296),
	6019: uint16(3296),
	6020: uint16(3296),
	6021: uint16(3296),
	6022: uint16(3296),
	6023: uint16(3296),
	6024: uint16(3296),
	6025: uint16(3296),
	6026: uint16(3296),
	6027: uint16(3296),
	6028: uint16(3296),
	6029: uint16(3296),
	6030: uint16(3296),
	6031: uint16(3296),
	6032: uint16(3296),
	6033: uint16(3296),
	6034: uint16(3296),
	6035: uint16(3296),
	6036: uint16(3296),
	6037: uint16(3296),
	6038: uint16(3296),
	6039: uint16(3296),
	6040: uint16(3296),
	6041: uint16(3296),
	6042: uint16(3296),
	6043: uint16(3296),
	6044: uint16(3296),
	6045: uint16(3296),
	6046: uint16(3296),
	6047: uint16(3296),
	6048: uint16(3296),
	6049: uint16(3296),
	6050: uint16(3296),
	6051: uint16(3296),
	6052: uint16(3296),
	6053: uint16(3296),
	6054: uint16(3296),
	6055: uint16(3296),
	6056: uint16(3296),
	6057: uint16(3296),
	6058: uint16(3296),
	6059: uint16(3296),
	6060: uint16(3296),
	6061: uint16(3296),
	6062: uint16(3296),
	6063: uint16(3296),
	6064: uint16(3296),
	6065: uint16(3296),
	6066: uint16(3296),
	6067: uint16(3296),
	6068: uint16(3296),
	6069: uint16(3296),
	6070: uint16(3296),
	6071: uint16(3296),
	6072: uint16(3296),
	6073: uint16(3296),
	6074: uint16(3296),
	6075: uint16(3296),
	6076: uint16(3296),
	6077: uint16(3296),
	6078: uint16(3296),
	6079: uint16(3296),
	6080: uint16(1344),
	6081: uint16(1344),
	6082: uint16(1344),
	6083: uint16(1344),
	6084: uint16(1344),
	6085: uint16(1344),
	6086: uint16(1344),
	6087: uint16(1344),
	6088: uint16(1344),
	6089: uint16(1344),
	6090: uint16(1344),
	6091: uint16(1344),
	6092: uint16(1344),
	6093: uint16(1344),
	6094: uint16(1344),
	6095: uint16(1344),
	6096: uint16(11296),
	6097: uint16(3296),
	6098: uint16(3296),
	6099: uint16(3296),
	6100: uint16(3296),
	6101: uint16(3296),
	6102: uint16(3296),
	6103: uint16(3296),
	6104: uint16(3296),
	6105: uint16(3296),
	6106: uint16(3296),
	6107: uint16(3296),
	6108: uint16(3296),
	6109: uint16(3296),
	6110: uint16(3296),
	6111: uint16(3296),
	6112: uint16(3296),
	6113: uint16(3296),
	6114: uint16(3296),
	6115: uint16(3296),
	6116: uint16(3296),
	6117: uint16(3296),
	6118: uint16(3296),
	6119: uint16(3296),
	6120: uint16(3296),
	6121: uint16(3296),
	6122: uint16(3296),
	6123: uint16(3296),
	6124: uint16(3296),
	6125: uint16(3296),
	6126: uint16(3296),
	6127: uint16(3296),
	6128: uint16(3296),
	6129: uint16(3296),
	6130: uint16(3296),
	6131: uint16(3296),
	6132: uint16(3296),
	6133: uint16(3296),
	6134: uint16(3296),
	6135: uint16(3296),
	6136: uint16(3296),
	6137: uint16(3296),
	6138: uint16(3296),
	6139: uint16(3296),
	6140: uint16(3296),
	6141: uint16(3296),
	6142: uint16(3296),
	6143: uint16(3296),
	6144: uint16(1344),
	6145: uint16(1344),
	6146: uint16(1344),
	6147: uint16(1344),
	6148: uint16(1344),
	6149: uint16(1344),
	6150: uint16(1344),
	6151: uint16(1344),
	6152: uint16(1344),
	6153: uint16(1344),
	6154: uint16(1344),
	6155: uint16(1344),
	6156: uint16(1344),
	6157: uint16(1344),
	6158: uint16(1344),
	6159: uint16(1344),
	6160: uint16(1344),
	6161: uint16(1344),
	6162: uint16(1344),
	6163: uint16(1344),
	6164: uint16(1344),
	6165: uint16(1344),
	6166: uint16(1344),
	6167: uint16(1344),
	6168: uint16(1344),
	6169: uint16(1344),
	6170: uint16(1344),
	6171: uint16(1344),
	6172: uint16(1344),
	6173: uint16(1344),
	6174: uint16(1344),
	6175: uint16(1344),
	6176: uint16(1344),
	6177: uint16(1344),
	6178: uint16(1344),
	6179: uint16(1344),
	6180: uint16(1344),
	6181: uint16(1344),
	6182: uint16(1344),
	6183: uint16(1344),
	6184: uint16(1344),
	6185: uint16(1344),
	6186: uint16(1344),
	6187: uint16(1344),
	6188: uint16(1344),
	6189: uint16(1344),
	6190: uint16(1344),
	6191: uint16(1344),
	6192: uint16(1344),
	6193: uint16(1344),
	6194: uint16(1344),
	6195: uint16(1344),
	6196: uint16(1344),
	6197: uint16(1344),
	6198: uint16(1344),
	6199: uint16(1344),
	6200: uint16(1344),
	6201: uint16(1344),
	6202: uint16(1344),
	6203: uint16(1344),
	6204: uint16(1344),
	6205: uint16(1344),
	6206: uint16(1344),
	6207: uint16(1344),
	6208: uint16(1344),
	6209: uint16(1344),
	6210: uint16(1344),
	6211: uint16(1344),
	6212: uint16(1344),
	6213: uint16(1344),
	6214: uint16(1344),
	6215: uint16(1344),
	6216: uint16(1344),
	6217: uint16(1344),
	6218: uint16(1344),
	6219: uint16(1344),
	6220: uint16(1344),
	6221: uint16(1344),
	6222: uint16(1344),
	6223: uint16(1344),
	6224: uint16(1344),
	6225: uint16(1344),
	6226: uint16(1344),
	6227: uint16(1344),
	6228: uint16(1344),
	6229: uint16(1344),
	6230: uint16(1344),
	6231: uint16(1344),
	6232: uint16(1344),
	6233: uint16(1344),
	6234: uint16(1344),
	6235: uint16(1344),
	6236: uint16(1344),
	6237: uint16(1344),
	6238: uint16(1344),
	6239: uint16(1344),
	6240: uint16(1344),
	6241: uint16(1344),
	6242: uint16(1344),
	6243: uint16(1344),
	6244: uint16(1344),
	6245: uint16(1344),
	6246: uint16(1344),
	6247: uint16(1344),
	6248: uint16(1344),
	6249: uint16(1344),
	6250: uint16(1344),
	6251: uint16(1344),
	6252: uint16(1344),
	6253: uint16(1344),
	6254: uint16(1344),
	6255: uint16(1344),
	6256: uint16(1344),
	6257: uint16(1344),
	6258: uint16(1344),
	6259: uint16(1344),
	6260: uint16(1344),
	6261: uint16(1344),
	6262: uint16(1344),
	6263: uint16(1344),
	6264: uint16(1344),
	6265: uint16(1344),
	6266: uint16(1344),
	6267: uint16(1344),
	6268: uint16(1344),
	6269: uint16(1344),
	6270: uint16(1344),
	6271: uint16(1344),
	6272: uint16(1344),
	6273: uint16(1344),
	6274: uint16(1344),
	6275: uint16(1344),
	6276: uint16(1344),
	6277: uint16(1344),
	6278: uint16(1344),
	6279: uint16(1344),
	6280: uint16(1344),
	6281: uint16(1344),
	6282: uint16(1344),
	6283: uint16(1344),
	6284: uint16(1344),
	6285: uint16(1344),
	6286: uint16(1344),
	6287: uint16(1344),
	6288: uint16(1344),
	6289: uint16(1344),
	6290: uint16(1344),
	6291: uint16(1344),
	6292: uint16(1344),
	6293: uint16(1344),
	6294: uint16(1344),
	6295: uint16(1344),
	6296: uint16(1344),
	6297: uint16(1344),
	6298: uint16(1792),
	6299: uint16(1344),
	6300: uint16(1344),
	6301: uint16(1344),
	6302: uint16(1344),
	6303: uint16(1344),
	6304: uint16(1344),
	6305: uint16(1344),
	6306: uint16(1344),
	6307: uint16(1344),
	6308: uint16(1344),
	6309: uint16(1344),
	6310: uint16(1344),
	6311: uint16(1344),
	6312: uint16(1344),
	6313: uint16(1344),
	6314: uint16(1344),
	6315: uint16(1344),
	6316: uint16(1344),
	6317: uint16(1344),
	6318: uint16(1344),
	6319: uint16(1344),
	6320: uint16(1344),
	6321: uint16(1344),
	6322: uint16(1344),
	6323: uint16(1344),
	6324: uint16(1344),
	6325: uint16(1344),
	6326: uint16(1344),
	6327: uint16(1344),
	6328: uint16(1344),
	6329: uint16(1344),
	6330: uint16(1344),
	6331: uint16(1344),
	6332: uint16(1344),
	6333: uint16(1344),
	6334: uint16(1344),
	6335: uint16(1344),
	6336: uint16(1344),
	6337: uint16(1344),
	6338: uint16(1344),
	6339: uint16(1344),
	6340: uint16(1344),
	6341: uint16(1344),
	6342: uint16(1344),
	6343: uint16(1344),
	6344: uint16(1344),
	6345: uint16(1344),
	6346: uint16(1344),
	6347: uint16(1344),
	6348: uint16(1344),
	6349: uint16(1344),
	6350: uint16(1344),
	6351: uint16(1344),
	6352: uint16(1344),
	6353: uint16(1344),
	6354: uint16(1344),
	6355: uint16(1344),
	6356: uint16(1344),
	6357: uint16(1344),
	6358: uint16(1344),
	6359: uint16(1344),
	6360: uint16(1344),
	6361: uint16(1344),
	6362: uint16(1344),
	6363: uint16(1344),
	6364: uint16(1344),
	6365: uint16(1344),
	6366: uint16(1344),
	6367: uint16(1344),
	6368: uint16(1344),
	6369: uint16(1344),
	6370: uint16(1344),
	6371: uint16(1344),
	6372: uint16(1344),
	6373: uint16(1344),
	6374: uint16(1344),
	6375: uint16(1344),
	6376: uint16(1344),
	6377: uint16(1344),
	6378: uint16(1344),
	6379: uint16(1344),
	6380: uint16(1344),
	6381: uint16(1344),
	6382: uint16(1344),
	6383: uint16(1344),
	6384: uint16(1344),
	6385: uint16(1344),
	6386: uint16(1344),
	6387: uint16(1344),
	6388: uint16(1344),
	6389: uint16(1344),
	6390: uint16(1344),
	6391: uint16(1344),
	6392: uint16(1344),
	6393: uint16(1344),
	6394: uint16(1344),
	6395: uint16(1344),
	6396: uint16(1344),
	6397: uint16(1344),
	6398: uint16(1344),
	6399: uint16(1344),
	6400: uint16(1344),
	6401: uint16(1344),
	6402: uint16(1344),
	6403: uint16(1344),
	6404: uint16(1344),
	6405: uint16(1344),
	6406: uint16(1344),
	6407: uint16(1344),
	6408: uint16(1344),
	6409: uint16(1344),
	6410: uint16(1344),
	6411: uint16(1344),
	6412: uint16(1344),
	6413: uint16(1344),
	6414: uint16(1344),
	6415: uint16(1344),
	6416: uint16(1344),
	6417: uint16(1344),
	6418: uint16(1344),
	6419: uint16(1344),
	6420: uint16(1344),
	6421: uint16(1344),
	6422: uint16(1344),
	6423: uint16(1344),
	6424: uint16(1344),
	6425: uint16(1344),
	6426: uint16(1344),
	6427: uint16(1344),
	6428: uint16(1344),
	6429: uint16(15968),
}

/*
 * The groupMap is indexed by combining the alternate page number with
 * the page offset and returns a group number that identifies a unique
 * set of character attributes.
 */

var _groupMap = [19680]uint8{
	0:     uint8(1),
	1:     uint8(1),
	2:     uint8(1),
	3:     uint8(1),
	4:     uint8(1),
	5:     uint8(1),
	6:     uint8(1),
	7:     uint8(1),
	8:     uint8(1),
	9:     uint8(1),
	10:    uint8(1),
	11:    uint8(1),
	12:    uint8(1),
	13:    uint8(1),
	14:    uint8(1),
	15:    uint8(1),
	16:    uint8(1),
	17:    uint8(1),
	18:    uint8(1),
	19:    uint8(1),
	20:    uint8(1),
	21:    uint8(1),
	22:    uint8(1),
	23:    uint8(1),
	24:    uint8(1),
	25:    uint8(1),
	26:    uint8(1),
	27:    uint8(1),
	28:    uint8(1),
	29:    uint8(1),
	30:    uint8(1),
	31:    uint8(1),
	32:    uint8(2),
	33:    uint8(3),
	34:    uint8(3),
	35:    uint8(3),
	36:    uint8(4),
	37:    uint8(3),
	38:    uint8(3),
	39:    uint8(3),
	40:    uint8(5),
	41:    uint8(6),
	42:    uint8(3),
	43:    uint8(7),
	44:    uint8(3),
	45:    uint8(8),
	46:    uint8(3),
	47:    uint8(3),
	48:    uint8(9),
	49:    uint8(9),
	50:    uint8(9),
	51:    uint8(9),
	52:    uint8(9),
	53:    uint8(9),
	54:    uint8(9),
	55:    uint8(9),
	56:    uint8(9),
	57:    uint8(9),
	58:    uint8(3),
	59:    uint8(3),
	60:    uint8(7),
	61:    uint8(7),
	62:    uint8(7),
	63:    uint8(3),
	64:    uint8(3),
	65:    uint8(10),
	66:    uint8(10),
	67:    uint8(10),
	68:    uint8(10),
	69:    uint8(10),
	70:    uint8(10),
	71:    uint8(10),
	72:    uint8(10),
	73:    uint8(10),
	74:    uint8(10),
	75:    uint8(10),
	76:    uint8(10),
	77:    uint8(10),
	78:    uint8(10),
	79:    uint8(10),
	80:    uint8(10),
	81:    uint8(10),
	82:    uint8(10),
	83:    uint8(10),
	84:    uint8(10),
	85:    uint8(10),
	86:    uint8(10),
	87:    uint8(10),
	88:    uint8(10),
	89:    uint8(10),
	90:    uint8(10),
	91:    uint8(5),
	92:    uint8(3),
	93:    uint8(6),
	94:    uint8(11),
	95:    uint8(12),
	96:    uint8(11),
	97:    uint8(13),
	98:    uint8(13),
	99:    uint8(13),
	100:   uint8(13),
	101:   uint8(13),
	102:   uint8(13),
	103:   uint8(13),
	104:   uint8(13),
	105:   uint8(13),
	106:   uint8(13),
	107:   uint8(13),
	108:   uint8(13),
	109:   uint8(13),
	110:   uint8(13),
	111:   uint8(13),
	112:   uint8(13),
	113:   uint8(13),
	114:   uint8(13),
	115:   uint8(13),
	116:   uint8(13),
	117:   uint8(13),
	118:   uint8(13),
	119:   uint8(13),
	120:   uint8(13),
	121:   uint8(13),
	122:   uint8(13),
	123:   uint8(5),
	124:   uint8(7),
	125:   uint8(6),
	126:   uint8(7),
	127:   uint8(1),
	128:   uint8(2),
	129:   uint8(3),
	130:   uint8(4),
	131:   uint8(4),
	132:   uint8(4),
	133:   uint8(4),
	134:   uint8(14),
	135:   uint8(3),
	136:   uint8(11),
	137:   uint8(14),
	138:   uint8(15),
	139:   uint8(16),
	140:   uint8(7),
	141:   uint8(17),
	142:   uint8(14),
	143:   uint8(11),
	144:   uint8(14),
	145:   uint8(7),
	146:   uint8(18),
	147:   uint8(18),
	148:   uint8(11),
	149:   uint8(19),
	150:   uint8(3),
	151:   uint8(3),
	152:   uint8(11),
	153:   uint8(18),
	154:   uint8(15),
	155:   uint8(20),
	156:   uint8(18),
	157:   uint8(18),
	158:   uint8(18),
	159:   uint8(3),
	160:   uint8(10),
	161:   uint8(10),
	162:   uint8(10),
	163:   uint8(10),
	164:   uint8(10),
	165:   uint8(10),
	166:   uint8(10),
	167:   uint8(10),
	168:   uint8(10),
	169:   uint8(10),
	170:   uint8(10),
	171:   uint8(10),
	172:   uint8(10),
	173:   uint8(10),
	174:   uint8(10),
	175:   uint8(10),
	176:   uint8(10),
	177:   uint8(10),
	178:   uint8(10),
	179:   uint8(10),
	180:   uint8(10),
	181:   uint8(10),
	182:   uint8(10),
	183:   uint8(7),
	184:   uint8(10),
	185:   uint8(10),
	186:   uint8(10),
	187:   uint8(10),
	188:   uint8(10),
	189:   uint8(10),
	190:   uint8(10),
	191:   uint8(21),
	192:   uint8(13),
	193:   uint8(13),
	194:   uint8(13),
	195:   uint8(13),
	196:   uint8(13),
	197:   uint8(13),
	198:   uint8(13),
	199:   uint8(13),
	200:   uint8(13),
	201:   uint8(13),
	202:   uint8(13),
	203:   uint8(13),
	204:   uint8(13),
	205:   uint8(13),
	206:   uint8(13),
	207:   uint8(13),
	208:   uint8(13),
	209:   uint8(13),
	210:   uint8(13),
	211:   uint8(13),
	212:   uint8(13),
	213:   uint8(13),
	214:   uint8(13),
	215:   uint8(7),
	216:   uint8(13),
	217:   uint8(13),
	218:   uint8(13),
	219:   uint8(13),
	220:   uint8(13),
	221:   uint8(13),
	222:   uint8(13),
	223:   uint8(22),
	224:   uint8(23),
	225:   uint8(24),
	226:   uint8(23),
	227:   uint8(24),
	228:   uint8(23),
	229:   uint8(24),
	230:   uint8(23),
	231:   uint8(24),
	232:   uint8(23),
	233:   uint8(24),
	234:   uint8(23),
	235:   uint8(24),
	236:   uint8(23),
	237:   uint8(24),
	238:   uint8(23),
	239:   uint8(24),
	240:   uint8(23),
	241:   uint8(24),
	242:   uint8(23),
	243:   uint8(24),
	244:   uint8(23),
	245:   uint8(24),
	246:   uint8(23),
	247:   uint8(24),
	248:   uint8(23),
	249:   uint8(24),
	250:   uint8(23),
	251:   uint8(24),
	252:   uint8(23),
	253:   uint8(24),
	254:   uint8(23),
	255:   uint8(24),
	256:   uint8(23),
	257:   uint8(24),
	258:   uint8(23),
	259:   uint8(24),
	260:   uint8(23),
	261:   uint8(24),
	262:   uint8(23),
	263:   uint8(24),
	264:   uint8(23),
	265:   uint8(24),
	266:   uint8(23),
	267:   uint8(24),
	268:   uint8(23),
	269:   uint8(24),
	270:   uint8(23),
	271:   uint8(24),
	272:   uint8(25),
	273:   uint8(26),
	274:   uint8(23),
	275:   uint8(24),
	276:   uint8(23),
	277:   uint8(24),
	278:   uint8(23),
	279:   uint8(24),
	280:   uint8(21),
	281:   uint8(23),
	282:   uint8(24),
	283:   uint8(23),
	284:   uint8(24),
	285:   uint8(23),
	286:   uint8(24),
	287:   uint8(23),
	288:   uint8(24),
	289:   uint8(23),
	290:   uint8(24),
	291:   uint8(23),
	292:   uint8(24),
	293:   uint8(23),
	294:   uint8(24),
	295:   uint8(23),
	296:   uint8(24),
	297:   uint8(21),
	298:   uint8(23),
	299:   uint8(24),
	300:   uint8(23),
	301:   uint8(24),
	302:   uint8(23),
	303:   uint8(24),
	304:   uint8(23),
	305:   uint8(24),
	306:   uint8(23),
	307:   uint8(24),
	308:   uint8(23),
	309:   uint8(24),
	310:   uint8(23),
	311:   uint8(24),
	312:   uint8(23),
	313:   uint8(24),
	314:   uint8(23),
	315:   uint8(24),
	316:   uint8(23),
	317:   uint8(24),
	318:   uint8(23),
	319:   uint8(24),
	320:   uint8(23),
	321:   uint8(24),
	322:   uint8(23),
	323:   uint8(24),
	324:   uint8(23),
	325:   uint8(24),
	326:   uint8(23),
	327:   uint8(24),
	328:   uint8(23),
	329:   uint8(24),
	330:   uint8(23),
	331:   uint8(24),
	332:   uint8(23),
	333:   uint8(24),
	334:   uint8(23),
	335:   uint8(24),
	336:   uint8(23),
	337:   uint8(24),
	338:   uint8(23),
	339:   uint8(24),
	340:   uint8(23),
	341:   uint8(24),
	342:   uint8(23),
	343:   uint8(24),
	344:   uint8(27),
	345:   uint8(23),
	346:   uint8(24),
	347:   uint8(23),
	348:   uint8(24),
	349:   uint8(23),
	350:   uint8(24),
	351:   uint8(28),
	352:   uint8(29),
	353:   uint8(30),
	354:   uint8(23),
	355:   uint8(24),
	356:   uint8(23),
	357:   uint8(24),
	358:   uint8(31),
	359:   uint8(23),
	360:   uint8(24),
	361:   uint8(32),
	362:   uint8(32),
	363:   uint8(23),
	364:   uint8(24),
	365:   uint8(21),
	366:   uint8(33),
	367:   uint8(34),
	368:   uint8(35),
	369:   uint8(23),
	370:   uint8(24),
	371:   uint8(32),
	372:   uint8(36),
	373:   uint8(37),
	374:   uint8(38),
	375:   uint8(39),
	376:   uint8(23),
	377:   uint8(24),
	378:   uint8(40),
	379:   uint8(41),
	380:   uint8(38),
	381:   uint8(42),
	382:   uint8(43),
	383:   uint8(44),
	384:   uint8(23),
	385:   uint8(24),
	386:   uint8(23),
	387:   uint8(24),
	388:   uint8(23),
	389:   uint8(24),
	390:   uint8(45),
	391:   uint8(23),
	392:   uint8(24),
	393:   uint8(45),
	394:   uint8(21),
	395:   uint8(21),
	396:   uint8(23),
	397:   uint8(24),
	398:   uint8(45),
	399:   uint8(23),
	400:   uint8(24),
	401:   uint8(46),
	402:   uint8(46),
	403:   uint8(23),
	404:   uint8(24),
	405:   uint8(23),
	406:   uint8(24),
	407:   uint8(47),
	408:   uint8(23),
	409:   uint8(24),
	410:   uint8(21),
	411:   uint8(15),
	412:   uint8(23),
	413:   uint8(24),
	414:   uint8(21),
	415:   uint8(48),
	416:   uint8(15),
	417:   uint8(15),
	418:   uint8(15),
	419:   uint8(15),
	420:   uint8(49),
	421:   uint8(50),
	422:   uint8(51),
	423:   uint8(49),
	424:   uint8(50),
	425:   uint8(51),
	426:   uint8(49),
	427:   uint8(50),
	428:   uint8(51),
	429:   uint8(23),
	430:   uint8(24),
	431:   uint8(23),
	432:   uint8(24),
	433:   uint8(23),
	434:   uint8(24),
	435:   uint8(23),
	436:   uint8(24),
	437:   uint8(23),
	438:   uint8(24),
	439:   uint8(23),
	440:   uint8(24),
	441:   uint8(23),
	442:   uint8(24),
	443:   uint8(23),
	444:   uint8(24),
	445:   uint8(52),
	446:   uint8(23),
	447:   uint8(24),
	448:   uint8(23),
	449:   uint8(24),
	450:   uint8(23),
	451:   uint8(24),
	452:   uint8(23),
	453:   uint8(24),
	454:   uint8(23),
	455:   uint8(24),
	456:   uint8(23),
	457:   uint8(24),
	458:   uint8(23),
	459:   uint8(24),
	460:   uint8(23),
	461:   uint8(24),
	462:   uint8(23),
	463:   uint8(24),
	464:   uint8(21),
	465:   uint8(49),
	466:   uint8(50),
	467:   uint8(51),
	468:   uint8(23),
	469:   uint8(24),
	470:   uint8(53),
	471:   uint8(54),
	472:   uint8(23),
	473:   uint8(24),
	474:   uint8(23),
	475:   uint8(24),
	476:   uint8(23),
	477:   uint8(24),
	478:   uint8(23),
	479:   uint8(24),
	480:   uint8(55),
	481:   uint8(21),
	482:   uint8(23),
	483:   uint8(24),
	484:   uint8(23),
	485:   uint8(24),
	486:   uint8(23),
	487:   uint8(24),
	488:   uint8(23),
	489:   uint8(24),
	490:   uint8(23),
	491:   uint8(24),
	492:   uint8(23),
	493:   uint8(24),
	494:   uint8(23),
	495:   uint8(24),
	496:   uint8(23),
	497:   uint8(24),
	498:   uint8(23),
	499:   uint8(24),
	500:   uint8(21),
	501:   uint8(21),
	502:   uint8(21),
	503:   uint8(21),
	504:   uint8(21),
	505:   uint8(21),
	506:   uint8(56),
	507:   uint8(23),
	508:   uint8(24),
	509:   uint8(57),
	510:   uint8(58),
	511:   uint8(59),
	512:   uint8(59),
	513:   uint8(23),
	514:   uint8(24),
	515:   uint8(60),
	516:   uint8(61),
	517:   uint8(62),
	518:   uint8(23),
	519:   uint8(24),
	520:   uint8(23),
	521:   uint8(24),
	522:   uint8(23),
	523:   uint8(24),
	524:   uint8(23),
	525:   uint8(24),
	526:   uint8(23),
	527:   uint8(24),
	528:   uint8(63),
	529:   uint8(64),
	530:   uint8(65),
	531:   uint8(66),
	532:   uint8(67),
	533:   uint8(21),
	534:   uint8(68),
	535:   uint8(68),
	536:   uint8(21),
	537:   uint8(69),
	538:   uint8(21),
	539:   uint8(70),
	540:   uint8(71),
	541:   uint8(21),
	542:   uint8(21),
	543:   uint8(21),
	544:   uint8(68),
	545:   uint8(72),
	546:   uint8(21),
	547:   uint8(73),
	548:   uint8(74),
	549:   uint8(75),
	550:   uint8(76),
	551:   uint8(21),
	552:   uint8(77),
	553:   uint8(78),
	554:   uint8(76),
	555:   uint8(79),
	556:   uint8(80),
	557:   uint8(21),
	558:   uint8(21),
	559:   uint8(78),
	560:   uint8(21),
	561:   uint8(81),
	562:   uint8(82),
	563:   uint8(21),
	564:   uint8(21),
	565:   uint8(83),
	566:   uint8(21),
	567:   uint8(21),
	568:   uint8(21),
	569:   uint8(21),
	570:   uint8(21),
	571:   uint8(21),
	572:   uint8(21),
	573:   uint8(84),
	574:   uint8(21),
	575:   uint8(21),
	576:   uint8(85),
	577:   uint8(21),
	578:   uint8(86),
	579:   uint8(85),
	580:   uint8(21),
	581:   uint8(21),
	582:   uint8(21),
	583:   uint8(87),
	584:   uint8(85),
	585:   uint8(88),
	586:   uint8(89),
	587:   uint8(89),
	588:   uint8(90),
	589:   uint8(21),
	590:   uint8(21),
	591:   uint8(21),
	592:   uint8(21),
	593:   uint8(21),
	594:   uint8(91),
	595:   uint8(21),
	596:   uint8(15),
	597:   uint8(21),
	598:   uint8(21),
	599:   uint8(21),
	600:   uint8(21),
	601:   uint8(21),
	602:   uint8(21),
	603:   uint8(21),
	604:   uint8(21),
	605:   uint8(92),
	606:   uint8(93),
	607:   uint8(21),
	608:   uint8(21),
	609:   uint8(21),
	610:   uint8(21),
	611:   uint8(21),
	612:   uint8(21),
	613:   uint8(21),
	614:   uint8(21),
	615:   uint8(21),
	616:   uint8(21),
	617:   uint8(21),
	618:   uint8(21),
	619:   uint8(21),
	620:   uint8(21),
	621:   uint8(21),
	622:   uint8(21),
	623:   uint8(21),
	624:   uint8(94),
	625:   uint8(94),
	626:   uint8(94),
	627:   uint8(94),
	628:   uint8(94),
	629:   uint8(94),
	630:   uint8(94),
	631:   uint8(94),
	632:   uint8(94),
	633:   uint8(94),
	634:   uint8(94),
	635:   uint8(94),
	636:   uint8(94),
	637:   uint8(94),
	638:   uint8(94),
	639:   uint8(94),
	640:   uint8(94),
	641:   uint8(94),
	642:   uint8(11),
	643:   uint8(11),
	644:   uint8(11),
	645:   uint8(11),
	646:   uint8(94),
	647:   uint8(94),
	648:   uint8(94),
	649:   uint8(94),
	650:   uint8(94),
	651:   uint8(94),
	652:   uint8(94),
	653:   uint8(94),
	654:   uint8(94),
	655:   uint8(94),
	656:   uint8(94),
	657:   uint8(94),
	658:   uint8(11),
	659:   uint8(11),
	660:   uint8(11),
	661:   uint8(11),
	662:   uint8(11),
	663:   uint8(11),
	664:   uint8(11),
	665:   uint8(11),
	666:   uint8(11),
	667:   uint8(11),
	668:   uint8(11),
	669:   uint8(11),
	670:   uint8(11),
	671:   uint8(11),
	672:   uint8(94),
	673:   uint8(94),
	674:   uint8(94),
	675:   uint8(94),
	676:   uint8(94),
	677:   uint8(11),
	678:   uint8(11),
	679:   uint8(11),
	680:   uint8(11),
	681:   uint8(11),
	682:   uint8(11),
	683:   uint8(11),
	684:   uint8(94),
	685:   uint8(11),
	686:   uint8(94),
	687:   uint8(11),
	688:   uint8(11),
	689:   uint8(11),
	690:   uint8(11),
	691:   uint8(11),
	692:   uint8(11),
	693:   uint8(11),
	694:   uint8(11),
	695:   uint8(11),
	696:   uint8(11),
	697:   uint8(11),
	698:   uint8(11),
	699:   uint8(11),
	700:   uint8(11),
	701:   uint8(11),
	702:   uint8(11),
	703:   uint8(11),
	704:   uint8(95),
	705:   uint8(95),
	706:   uint8(95),
	707:   uint8(95),
	708:   uint8(95),
	709:   uint8(95),
	710:   uint8(95),
	711:   uint8(95),
	712:   uint8(95),
	713:   uint8(95),
	714:   uint8(95),
	715:   uint8(95),
	716:   uint8(95),
	717:   uint8(95),
	718:   uint8(95),
	719:   uint8(95),
	720:   uint8(95),
	721:   uint8(95),
	722:   uint8(95),
	723:   uint8(95),
	724:   uint8(95),
	725:   uint8(95),
	726:   uint8(95),
	727:   uint8(95),
	728:   uint8(95),
	729:   uint8(95),
	730:   uint8(95),
	731:   uint8(95),
	732:   uint8(95),
	733:   uint8(95),
	734:   uint8(95),
	735:   uint8(95),
	736:   uint8(95),
	737:   uint8(95),
	738:   uint8(95),
	739:   uint8(95),
	740:   uint8(95),
	741:   uint8(96),
	742:   uint8(95),
	743:   uint8(95),
	744:   uint8(95),
	745:   uint8(95),
	746:   uint8(95),
	747:   uint8(95),
	748:   uint8(95),
	749:   uint8(95),
	750:   uint8(95),
	751:   uint8(95),
	752:   uint8(95),
	753:   uint8(95),
	754:   uint8(95),
	755:   uint8(95),
	756:   uint8(95),
	757:   uint8(95),
	758:   uint8(95),
	759:   uint8(95),
	760:   uint8(95),
	761:   uint8(95),
	762:   uint8(95),
	763:   uint8(95),
	764:   uint8(95),
	765:   uint8(95),
	766:   uint8(95),
	767:   uint8(95),
	768:   uint8(95),
	769:   uint8(95),
	770:   uint8(95),
	771:   uint8(95),
	772:   uint8(95),
	773:   uint8(95),
	774:   uint8(95),
	775:   uint8(95),
	776:   uint8(95),
	777:   uint8(95),
	778:   uint8(95),
	779:   uint8(95),
	780:   uint8(95),
	781:   uint8(95),
	782:   uint8(95),
	783:   uint8(95),
	784:   uint8(23),
	785:   uint8(24),
	786:   uint8(23),
	787:   uint8(24),
	788:   uint8(94),
	789:   uint8(11),
	790:   uint8(23),
	791:   uint8(24),
	794:   uint8(94),
	795:   uint8(43),
	796:   uint8(43),
	797:   uint8(43),
	798:   uint8(3),
	799:   uint8(97),
	804:   uint8(11),
	805:   uint8(11),
	806:   uint8(98),
	807:   uint8(3),
	808:   uint8(99),
	809:   uint8(99),
	810:   uint8(99),
	812:   uint8(100),
	814:   uint8(101),
	815:   uint8(101),
	816:   uint8(21),
	817:   uint8(10),
	818:   uint8(10),
	819:   uint8(10),
	820:   uint8(10),
	821:   uint8(10),
	822:   uint8(10),
	823:   uint8(10),
	824:   uint8(10),
	825:   uint8(10),
	826:   uint8(10),
	827:   uint8(10),
	828:   uint8(10),
	829:   uint8(10),
	830:   uint8(10),
	831:   uint8(10),
	832:   uint8(10),
	833:   uint8(10),
	835:   uint8(10),
	836:   uint8(10),
	837:   uint8(10),
	838:   uint8(10),
	839:   uint8(10),
	840:   uint8(10),
	841:   uint8(10),
	842:   uint8(10),
	843:   uint8(10),
	844:   uint8(102),
	845:   uint8(103),
	846:   uint8(103),
	847:   uint8(103),
	848:   uint8(21),
	849:   uint8(13),
	850:   uint8(13),
	851:   uint8(13),
	852:   uint8(13),
	853:   uint8(13),
	854:   uint8(13),
	855:   uint8(13),
	856:   uint8(13),
	857:   uint8(13),
	858:   uint8(13),
	859:   uint8(13),
	860:   uint8(13),
	861:   uint8(13),
	862:   uint8(13),
	863:   uint8(13),
	864:   uint8(13),
	865:   uint8(13),
	866:   uint8(104),
	867:   uint8(13),
	868:   uint8(13),
	869:   uint8(13),
	870:   uint8(13),
	871:   uint8(13),
	872:   uint8(13),
	873:   uint8(13),
	874:   uint8(13),
	875:   uint8(13),
	876:   uint8(105),
	877:   uint8(106),
	878:   uint8(106),
	879:   uint8(107),
	880:   uint8(108),
	881:   uint8(109),
	882:   uint8(110),
	883:   uint8(110),
	884:   uint8(110),
	885:   uint8(111),
	886:   uint8(112),
	887:   uint8(113),
	888:   uint8(23),
	889:   uint8(24),
	890:   uint8(23),
	891:   uint8(24),
	892:   uint8(23),
	893:   uint8(24),
	894:   uint8(23),
	895:   uint8(24),
	896:   uint8(23),
	897:   uint8(24),
	898:   uint8(23),
	899:   uint8(24),
	900:   uint8(23),
	901:   uint8(24),
	902:   uint8(23),
	903:   uint8(24),
	904:   uint8(23),
	905:   uint8(24),
	906:   uint8(23),
	907:   uint8(24),
	908:   uint8(23),
	909:   uint8(24),
	910:   uint8(23),
	911:   uint8(24),
	912:   uint8(114),
	913:   uint8(115),
	914:   uint8(116),
	915:   uint8(117),
	916:   uint8(118),
	917:   uint8(119),
	918:   uint8(7),
	919:   uint8(23),
	920:   uint8(24),
	921:   uint8(120),
	922:   uint8(23),
	923:   uint8(24),
	924:   uint8(21),
	925:   uint8(55),
	926:   uint8(55),
	927:   uint8(55),
	928:   uint8(121),
	929:   uint8(121),
	930:   uint8(121),
	931:   uint8(121),
	932:   uint8(121),
	933:   uint8(121),
	934:   uint8(121),
	935:   uint8(121),
	936:   uint8(121),
	937:   uint8(121),
	938:   uint8(121),
	939:   uint8(121),
	940:   uint8(121),
	941:   uint8(121),
	942:   uint8(121),
	943:   uint8(121),
	944:   uint8(10),
	945:   uint8(10),
	946:   uint8(10),
	947:   uint8(10),
	948:   uint8(10),
	949:   uint8(10),
	950:   uint8(10),
	951:   uint8(10),
	952:   uint8(10),
	953:   uint8(10),
	954:   uint8(10),
	955:   uint8(10),
	956:   uint8(10),
	957:   uint8(10),
	958:   uint8(10),
	959:   uint8(10),
	960:   uint8(10),
	961:   uint8(10),
	962:   uint8(10),
	963:   uint8(10),
	964:   uint8(10),
	965:   uint8(10),
	966:   uint8(10),
	967:   uint8(10),
	968:   uint8(10),
	969:   uint8(10),
	970:   uint8(10),
	971:   uint8(10),
	972:   uint8(10),
	973:   uint8(10),
	974:   uint8(10),
	975:   uint8(10),
	976:   uint8(13),
	977:   uint8(13),
	978:   uint8(13),
	979:   uint8(13),
	980:   uint8(13),
	981:   uint8(13),
	982:   uint8(13),
	983:   uint8(13),
	984:   uint8(13),
	985:   uint8(13),
	986:   uint8(13),
	987:   uint8(13),
	988:   uint8(13),
	989:   uint8(13),
	990:   uint8(13),
	991:   uint8(13),
	992:   uint8(13),
	993:   uint8(13),
	994:   uint8(13),
	995:   uint8(13),
	996:   uint8(13),
	997:   uint8(13),
	998:   uint8(13),
	999:   uint8(13),
	1000:  uint8(13),
	1001:  uint8(13),
	1002:  uint8(13),
	1003:  uint8(13),
	1004:  uint8(13),
	1005:  uint8(13),
	1006:  uint8(13),
	1007:  uint8(13),
	1008:  uint8(115),
	1009:  uint8(115),
	1010:  uint8(115),
	1011:  uint8(115),
	1012:  uint8(115),
	1013:  uint8(115),
	1014:  uint8(115),
	1015:  uint8(115),
	1016:  uint8(115),
	1017:  uint8(115),
	1018:  uint8(115),
	1019:  uint8(115),
	1020:  uint8(115),
	1021:  uint8(115),
	1022:  uint8(115),
	1023:  uint8(115),
	1024:  uint8(23),
	1025:  uint8(24),
	1026:  uint8(14),
	1027:  uint8(95),
	1028:  uint8(95),
	1029:  uint8(95),
	1030:  uint8(95),
	1031:  uint8(95),
	1032:  uint8(122),
	1033:  uint8(122),
	1034:  uint8(23),
	1035:  uint8(24),
	1036:  uint8(23),
	1037:  uint8(24),
	1038:  uint8(23),
	1039:  uint8(24),
	1040:  uint8(23),
	1041:  uint8(24),
	1042:  uint8(23),
	1043:  uint8(24),
	1044:  uint8(23),
	1045:  uint8(24),
	1046:  uint8(23),
	1047:  uint8(24),
	1048:  uint8(23),
	1049:  uint8(24),
	1050:  uint8(23),
	1051:  uint8(24),
	1052:  uint8(23),
	1053:  uint8(24),
	1054:  uint8(23),
	1055:  uint8(24),
	1056:  uint8(123),
	1057:  uint8(23),
	1058:  uint8(24),
	1059:  uint8(23),
	1060:  uint8(24),
	1061:  uint8(23),
	1062:  uint8(24),
	1063:  uint8(23),
	1064:  uint8(24),
	1065:  uint8(23),
	1066:  uint8(24),
	1067:  uint8(23),
	1068:  uint8(24),
	1069:  uint8(23),
	1070:  uint8(24),
	1071:  uint8(124),
	1072:  uint8(23),
	1073:  uint8(24),
	1074:  uint8(23),
	1075:  uint8(24),
	1076:  uint8(23),
	1077:  uint8(24),
	1078:  uint8(23),
	1079:  uint8(24),
	1080:  uint8(23),
	1081:  uint8(24),
	1082:  uint8(23),
	1083:  uint8(24),
	1084:  uint8(23),
	1085:  uint8(24),
	1086:  uint8(23),
	1087:  uint8(24),
	1088:  uint8(23),
	1089:  uint8(24),
	1090:  uint8(23),
	1091:  uint8(24),
	1092:  uint8(23),
	1093:  uint8(24),
	1094:  uint8(23),
	1095:  uint8(24),
	1096:  uint8(23),
	1097:  uint8(24),
	1098:  uint8(23),
	1099:  uint8(24),
	1100:  uint8(23),
	1101:  uint8(24),
	1102:  uint8(23),
	1103:  uint8(24),
	1105:  uint8(125),
	1106:  uint8(125),
	1107:  uint8(125),
	1108:  uint8(125),
	1109:  uint8(125),
	1110:  uint8(125),
	1111:  uint8(125),
	1112:  uint8(125),
	1113:  uint8(125),
	1114:  uint8(125),
	1115:  uint8(125),
	1116:  uint8(125),
	1117:  uint8(125),
	1118:  uint8(125),
	1119:  uint8(125),
	1120:  uint8(125),
	1121:  uint8(125),
	1122:  uint8(125),
	1123:  uint8(125),
	1124:  uint8(125),
	1125:  uint8(125),
	1126:  uint8(125),
	1127:  uint8(125),
	1128:  uint8(125),
	1129:  uint8(125),
	1130:  uint8(125),
	1131:  uint8(125),
	1132:  uint8(125),
	1133:  uint8(125),
	1134:  uint8(125),
	1135:  uint8(125),
	1136:  uint8(125),
	1137:  uint8(125),
	1138:  uint8(125),
	1139:  uint8(125),
	1140:  uint8(125),
	1141:  uint8(125),
	1142:  uint8(125),
	1145:  uint8(94),
	1146:  uint8(3),
	1147:  uint8(3),
	1148:  uint8(3),
	1149:  uint8(3),
	1150:  uint8(3),
	1151:  uint8(3),
	1152:  uint8(21),
	1153:  uint8(126),
	1154:  uint8(126),
	1155:  uint8(126),
	1156:  uint8(126),
	1157:  uint8(126),
	1158:  uint8(126),
	1159:  uint8(126),
	1160:  uint8(126),
	1161:  uint8(126),
	1162:  uint8(126),
	1163:  uint8(126),
	1164:  uint8(126),
	1165:  uint8(126),
	1166:  uint8(126),
	1167:  uint8(126),
	1168:  uint8(126),
	1169:  uint8(126),
	1170:  uint8(126),
	1171:  uint8(126),
	1172:  uint8(126),
	1173:  uint8(126),
	1174:  uint8(126),
	1175:  uint8(126),
	1176:  uint8(126),
	1177:  uint8(126),
	1178:  uint8(126),
	1179:  uint8(126),
	1180:  uint8(126),
	1181:  uint8(126),
	1182:  uint8(126),
	1183:  uint8(126),
	1184:  uint8(126),
	1185:  uint8(126),
	1186:  uint8(126),
	1187:  uint8(126),
	1188:  uint8(126),
	1189:  uint8(126),
	1190:  uint8(126),
	1191:  uint8(21),
	1192:  uint8(21),
	1193:  uint8(3),
	1194:  uint8(8),
	1197:  uint8(14),
	1198:  uint8(14),
	1199:  uint8(4),
	1201:  uint8(95),
	1202:  uint8(95),
	1203:  uint8(95),
	1204:  uint8(95),
	1205:  uint8(95),
	1206:  uint8(95),
	1207:  uint8(95),
	1208:  uint8(95),
	1209:  uint8(95),
	1210:  uint8(95),
	1211:  uint8(95),
	1212:  uint8(95),
	1213:  uint8(95),
	1214:  uint8(95),
	1215:  uint8(95),
	1216:  uint8(95),
	1217:  uint8(95),
	1218:  uint8(95),
	1219:  uint8(95),
	1220:  uint8(95),
	1221:  uint8(95),
	1222:  uint8(95),
	1223:  uint8(95),
	1224:  uint8(95),
	1225:  uint8(95),
	1226:  uint8(95),
	1227:  uint8(95),
	1228:  uint8(95),
	1229:  uint8(95),
	1230:  uint8(95),
	1231:  uint8(95),
	1232:  uint8(95),
	1233:  uint8(95),
	1234:  uint8(95),
	1235:  uint8(95),
	1236:  uint8(95),
	1237:  uint8(95),
	1238:  uint8(95),
	1239:  uint8(95),
	1240:  uint8(95),
	1241:  uint8(95),
	1242:  uint8(95),
	1243:  uint8(95),
	1244:  uint8(95),
	1245:  uint8(95),
	1246:  uint8(8),
	1247:  uint8(95),
	1248:  uint8(3),
	1249:  uint8(95),
	1250:  uint8(95),
	1251:  uint8(3),
	1252:  uint8(95),
	1253:  uint8(95),
	1254:  uint8(3),
	1255:  uint8(95),
	1264:  uint8(15),
	1265:  uint8(15),
	1266:  uint8(15),
	1267:  uint8(15),
	1268:  uint8(15),
	1269:  uint8(15),
	1270:  uint8(15),
	1271:  uint8(15),
	1272:  uint8(15),
	1273:  uint8(15),
	1274:  uint8(15),
	1275:  uint8(15),
	1276:  uint8(15),
	1277:  uint8(15),
	1278:  uint8(15),
	1279:  uint8(15),
	1280:  uint8(15),
	1281:  uint8(15),
	1282:  uint8(15),
	1283:  uint8(15),
	1284:  uint8(15),
	1285:  uint8(15),
	1286:  uint8(15),
	1287:  uint8(15),
	1288:  uint8(15),
	1289:  uint8(15),
	1290:  uint8(15),
	1295:  uint8(15),
	1296:  uint8(15),
	1297:  uint8(15),
	1298:  uint8(15),
	1299:  uint8(3),
	1300:  uint8(3),
	1312:  uint8(17),
	1313:  uint8(17),
	1314:  uint8(17),
	1315:  uint8(17),
	1316:  uint8(17),
	1317:  uint8(17),
	1318:  uint8(7),
	1319:  uint8(7),
	1320:  uint8(7),
	1321:  uint8(3),
	1322:  uint8(3),
	1323:  uint8(4),
	1324:  uint8(3),
	1325:  uint8(3),
	1326:  uint8(14),
	1327:  uint8(14),
	1328:  uint8(95),
	1329:  uint8(95),
	1330:  uint8(95),
	1331:  uint8(95),
	1332:  uint8(95),
	1333:  uint8(95),
	1334:  uint8(95),
	1335:  uint8(95),
	1336:  uint8(95),
	1337:  uint8(95),
	1338:  uint8(95),
	1339:  uint8(3),
	1340:  uint8(17),
	1341:  uint8(3),
	1342:  uint8(3),
	1343:  uint8(3),
	1344:  uint8(15),
	1345:  uint8(15),
	1346:  uint8(15),
	1347:  uint8(15),
	1348:  uint8(15),
	1349:  uint8(15),
	1350:  uint8(15),
	1351:  uint8(15),
	1352:  uint8(15),
	1353:  uint8(15),
	1354:  uint8(15),
	1355:  uint8(15),
	1356:  uint8(15),
	1357:  uint8(15),
	1358:  uint8(15),
	1359:  uint8(15),
	1360:  uint8(15),
	1361:  uint8(15),
	1362:  uint8(15),
	1363:  uint8(15),
	1364:  uint8(15),
	1365:  uint8(15),
	1366:  uint8(15),
	1367:  uint8(15),
	1368:  uint8(15),
	1369:  uint8(15),
	1370:  uint8(15),
	1371:  uint8(15),
	1372:  uint8(15),
	1373:  uint8(15),
	1374:  uint8(15),
	1375:  uint8(15),
	1376:  uint8(94),
	1377:  uint8(15),
	1378:  uint8(15),
	1379:  uint8(15),
	1380:  uint8(15),
	1381:  uint8(15),
	1382:  uint8(15),
	1383:  uint8(15),
	1384:  uint8(15),
	1385:  uint8(15),
	1386:  uint8(15),
	1387:  uint8(95),
	1388:  uint8(95),
	1389:  uint8(95),
	1390:  uint8(95),
	1391:  uint8(95),
	1392:  uint8(95),
	1393:  uint8(95),
	1394:  uint8(95),
	1395:  uint8(95),
	1396:  uint8(95),
	1397:  uint8(95),
	1398:  uint8(95),
	1399:  uint8(95),
	1400:  uint8(95),
	1401:  uint8(95),
	1402:  uint8(95),
	1403:  uint8(95),
	1404:  uint8(95),
	1405:  uint8(95),
	1406:  uint8(95),
	1407:  uint8(95),
	1408:  uint8(9),
	1409:  uint8(9),
	1410:  uint8(9),
	1411:  uint8(9),
	1412:  uint8(9),
	1413:  uint8(9),
	1414:  uint8(9),
	1415:  uint8(9),
	1416:  uint8(9),
	1417:  uint8(9),
	1418:  uint8(3),
	1419:  uint8(3),
	1420:  uint8(3),
	1421:  uint8(3),
	1422:  uint8(15),
	1423:  uint8(15),
	1424:  uint8(95),
	1425:  uint8(15),
	1426:  uint8(15),
	1427:  uint8(15),
	1428:  uint8(15),
	1429:  uint8(15),
	1430:  uint8(15),
	1431:  uint8(15),
	1432:  uint8(15),
	1433:  uint8(15),
	1434:  uint8(15),
	1435:  uint8(15),
	1436:  uint8(15),
	1437:  uint8(15),
	1438:  uint8(15),
	1439:  uint8(15),
	1440:  uint8(15),
	1441:  uint8(15),
	1442:  uint8(15),
	1443:  uint8(15),
	1444:  uint8(15),
	1445:  uint8(15),
	1446:  uint8(15),
	1447:  uint8(15),
	1448:  uint8(15),
	1449:  uint8(15),
	1450:  uint8(15),
	1451:  uint8(15),
	1452:  uint8(15),
	1453:  uint8(15),
	1454:  uint8(15),
	1455:  uint8(15),
	1456:  uint8(15),
	1457:  uint8(15),
	1458:  uint8(15),
	1459:  uint8(15),
	1460:  uint8(3),
	1461:  uint8(15),
	1462:  uint8(95),
	1463:  uint8(95),
	1464:  uint8(95),
	1465:  uint8(95),
	1466:  uint8(95),
	1467:  uint8(95),
	1468:  uint8(95),
	1469:  uint8(17),
	1470:  uint8(14),
	1471:  uint8(95),
	1472:  uint8(95),
	1473:  uint8(95),
	1474:  uint8(95),
	1475:  uint8(95),
	1476:  uint8(95),
	1477:  uint8(94),
	1478:  uint8(94),
	1479:  uint8(95),
	1480:  uint8(95),
	1481:  uint8(14),
	1482:  uint8(95),
	1483:  uint8(95),
	1484:  uint8(95),
	1485:  uint8(95),
	1486:  uint8(15),
	1487:  uint8(15),
	1488:  uint8(9),
	1489:  uint8(9),
	1490:  uint8(9),
	1491:  uint8(9),
	1492:  uint8(9),
	1493:  uint8(9),
	1494:  uint8(9),
	1495:  uint8(9),
	1496:  uint8(9),
	1497:  uint8(9),
	1498:  uint8(15),
	1499:  uint8(15),
	1500:  uint8(15),
	1501:  uint8(14),
	1502:  uint8(14),
	1503:  uint8(15),
	1504:  uint8(3),
	1505:  uint8(3),
	1506:  uint8(3),
	1507:  uint8(3),
	1508:  uint8(3),
	1509:  uint8(3),
	1510:  uint8(3),
	1511:  uint8(3),
	1512:  uint8(3),
	1513:  uint8(3),
	1514:  uint8(3),
	1515:  uint8(3),
	1516:  uint8(3),
	1517:  uint8(3),
	1519:  uint8(17),
	1520:  uint8(15),
	1521:  uint8(95),
	1522:  uint8(15),
	1523:  uint8(15),
	1524:  uint8(15),
	1525:  uint8(15),
	1526:  uint8(15),
	1527:  uint8(15),
	1528:  uint8(15),
	1529:  uint8(15),
	1530:  uint8(15),
	1531:  uint8(15),
	1532:  uint8(15),
	1533:  uint8(15),
	1534:  uint8(15),
	1535:  uint8(15),
	1536:  uint8(15),
	1537:  uint8(15),
	1538:  uint8(15),
	1539:  uint8(15),
	1540:  uint8(15),
	1541:  uint8(15),
	1542:  uint8(15),
	1543:  uint8(15),
	1544:  uint8(15),
	1545:  uint8(15),
	1546:  uint8(15),
	1547:  uint8(15),
	1548:  uint8(15),
	1549:  uint8(15),
	1550:  uint8(15),
	1551:  uint8(15),
	1552:  uint8(95),
	1553:  uint8(95),
	1554:  uint8(95),
	1555:  uint8(95),
	1556:  uint8(95),
	1557:  uint8(95),
	1558:  uint8(95),
	1559:  uint8(95),
	1560:  uint8(95),
	1561:  uint8(95),
	1562:  uint8(95),
	1563:  uint8(95),
	1564:  uint8(95),
	1565:  uint8(95),
	1566:  uint8(95),
	1567:  uint8(95),
	1568:  uint8(95),
	1569:  uint8(95),
	1570:  uint8(95),
	1571:  uint8(95),
	1572:  uint8(95),
	1573:  uint8(95),
	1574:  uint8(95),
	1575:  uint8(95),
	1576:  uint8(95),
	1577:  uint8(95),
	1578:  uint8(95),
	1581:  uint8(15),
	1582:  uint8(15),
	1583:  uint8(15),
	1584:  uint8(15),
	1585:  uint8(15),
	1586:  uint8(15),
	1587:  uint8(15),
	1588:  uint8(15),
	1589:  uint8(15),
	1590:  uint8(15),
	1591:  uint8(15),
	1592:  uint8(15),
	1593:  uint8(15),
	1594:  uint8(15),
	1595:  uint8(15),
	1596:  uint8(15),
	1597:  uint8(15),
	1598:  uint8(15),
	1599:  uint8(15),
	1600:  uint8(15),
	1601:  uint8(15),
	1602:  uint8(15),
	1603:  uint8(15),
	1604:  uint8(15),
	1605:  uint8(15),
	1606:  uint8(95),
	1607:  uint8(95),
	1608:  uint8(95),
	1609:  uint8(95),
	1610:  uint8(95),
	1611:  uint8(95),
	1612:  uint8(95),
	1613:  uint8(95),
	1614:  uint8(95),
	1615:  uint8(95),
	1616:  uint8(95),
	1617:  uint8(15),
	1632:  uint8(9),
	1633:  uint8(9),
	1634:  uint8(9),
	1635:  uint8(9),
	1636:  uint8(9),
	1637:  uint8(9),
	1638:  uint8(9),
	1639:  uint8(9),
	1640:  uint8(9),
	1641:  uint8(9),
	1642:  uint8(15),
	1643:  uint8(15),
	1644:  uint8(15),
	1645:  uint8(15),
	1646:  uint8(15),
	1647:  uint8(15),
	1648:  uint8(15),
	1649:  uint8(15),
	1650:  uint8(15),
	1651:  uint8(15),
	1652:  uint8(15),
	1653:  uint8(15),
	1654:  uint8(15),
	1655:  uint8(15),
	1656:  uint8(15),
	1657:  uint8(15),
	1658:  uint8(15),
	1659:  uint8(15),
	1660:  uint8(15),
	1661:  uint8(15),
	1662:  uint8(15),
	1663:  uint8(15),
	1664:  uint8(15),
	1665:  uint8(15),
	1666:  uint8(15),
	1667:  uint8(15),
	1668:  uint8(15),
	1669:  uint8(15),
	1670:  uint8(15),
	1671:  uint8(15),
	1672:  uint8(15),
	1673:  uint8(15),
	1674:  uint8(15),
	1675:  uint8(95),
	1676:  uint8(95),
	1677:  uint8(95),
	1678:  uint8(95),
	1679:  uint8(95),
	1680:  uint8(95),
	1681:  uint8(95),
	1682:  uint8(95),
	1683:  uint8(95),
	1684:  uint8(94),
	1685:  uint8(94),
	1686:  uint8(14),
	1687:  uint8(3),
	1688:  uint8(3),
	1689:  uint8(3),
	1690:  uint8(94),
	1693:  uint8(95),
	1694:  uint8(4),
	1695:  uint8(4),
	1696:  uint8(15),
	1697:  uint8(15),
	1698:  uint8(15),
	1699:  uint8(15),
	1700:  uint8(15),
	1701:  uint8(15),
	1702:  uint8(15),
	1703:  uint8(15),
	1704:  uint8(15),
	1705:  uint8(15),
	1706:  uint8(15),
	1707:  uint8(15),
	1708:  uint8(15),
	1709:  uint8(15),
	1710:  uint8(15),
	1711:  uint8(15),
	1712:  uint8(15),
	1713:  uint8(15),
	1714:  uint8(15),
	1715:  uint8(15),
	1716:  uint8(15),
	1717:  uint8(15),
	1718:  uint8(95),
	1719:  uint8(95),
	1720:  uint8(95),
	1721:  uint8(95),
	1722:  uint8(94),
	1723:  uint8(95),
	1724:  uint8(95),
	1725:  uint8(95),
	1726:  uint8(95),
	1727:  uint8(95),
	1728:  uint8(95),
	1729:  uint8(95),
	1730:  uint8(95),
	1731:  uint8(95),
	1732:  uint8(94),
	1733:  uint8(95),
	1734:  uint8(95),
	1735:  uint8(95),
	1736:  uint8(94),
	1737:  uint8(95),
	1738:  uint8(95),
	1739:  uint8(95),
	1740:  uint8(95),
	1741:  uint8(95),
	1744:  uint8(3),
	1745:  uint8(3),
	1746:  uint8(3),
	1747:  uint8(3),
	1748:  uint8(3),
	1749:  uint8(3),
	1750:  uint8(3),
	1751:  uint8(3),
	1752:  uint8(3),
	1753:  uint8(3),
	1754:  uint8(3),
	1755:  uint8(3),
	1756:  uint8(3),
	1757:  uint8(3),
	1758:  uint8(3),
	1760:  uint8(15),
	1761:  uint8(15),
	1762:  uint8(15),
	1763:  uint8(15),
	1764:  uint8(15),
	1765:  uint8(15),
	1766:  uint8(15),
	1767:  uint8(15),
	1768:  uint8(15),
	1769:  uint8(15),
	1770:  uint8(15),
	1771:  uint8(15),
	1772:  uint8(15),
	1773:  uint8(15),
	1774:  uint8(15),
	1775:  uint8(15),
	1776:  uint8(15),
	1777:  uint8(15),
	1778:  uint8(15),
	1779:  uint8(15),
	1780:  uint8(15),
	1781:  uint8(15),
	1782:  uint8(15),
	1783:  uint8(15),
	1784:  uint8(15),
	1785:  uint8(95),
	1786:  uint8(95),
	1787:  uint8(95),
	1790:  uint8(3),
	1792:  uint8(15),
	1793:  uint8(15),
	1794:  uint8(15),
	1795:  uint8(15),
	1796:  uint8(15),
	1797:  uint8(15),
	1798:  uint8(15),
	1799:  uint8(15),
	1800:  uint8(15),
	1801:  uint8(15),
	1802:  uint8(15),
	1808:  uint8(15),
	1809:  uint8(15),
	1810:  uint8(15),
	1811:  uint8(15),
	1812:  uint8(15),
	1813:  uint8(15),
	1814:  uint8(15),
	1815:  uint8(15),
	1816:  uint8(15),
	1817:  uint8(15),
	1818:  uint8(15),
	1819:  uint8(15),
	1820:  uint8(15),
	1821:  uint8(15),
	1822:  uint8(15),
	1823:  uint8(15),
	1824:  uint8(15),
	1825:  uint8(15),
	1826:  uint8(15),
	1827:  uint8(15),
	1828:  uint8(15),
	1829:  uint8(15),
	1830:  uint8(15),
	1831:  uint8(15),
	1832:  uint8(11),
	1833:  uint8(15),
	1834:  uint8(15),
	1835:  uint8(15),
	1836:  uint8(15),
	1837:  uint8(15),
	1838:  uint8(15),
	1840:  uint8(17),
	1841:  uint8(17),
	1847:  uint8(95),
	1848:  uint8(95),
	1849:  uint8(95),
	1850:  uint8(95),
	1851:  uint8(95),
	1852:  uint8(95),
	1853:  uint8(95),
	1854:  uint8(95),
	1855:  uint8(95),
	1856:  uint8(15),
	1857:  uint8(15),
	1858:  uint8(15),
	1859:  uint8(15),
	1860:  uint8(15),
	1861:  uint8(15),
	1862:  uint8(15),
	1863:  uint8(15),
	1864:  uint8(15),
	1865:  uint8(94),
	1866:  uint8(95),
	1867:  uint8(95),
	1868:  uint8(95),
	1869:  uint8(95),
	1870:  uint8(95),
	1871:  uint8(95),
	1872:  uint8(95),
	1873:  uint8(95),
	1874:  uint8(95),
	1875:  uint8(95),
	1876:  uint8(95),
	1877:  uint8(95),
	1878:  uint8(95),
	1879:  uint8(95),
	1880:  uint8(95),
	1881:  uint8(95),
	1882:  uint8(95),
	1883:  uint8(95),
	1884:  uint8(95),
	1885:  uint8(95),
	1886:  uint8(95),
	1887:  uint8(95),
	1888:  uint8(95),
	1889:  uint8(95),
	1890:  uint8(17),
	1891:  uint8(95),
	1892:  uint8(95),
	1893:  uint8(95),
	1894:  uint8(95),
	1895:  uint8(95),
	1896:  uint8(95),
	1897:  uint8(95),
	1898:  uint8(95),
	1899:  uint8(95),
	1900:  uint8(95),
	1901:  uint8(95),
	1902:  uint8(95),
	1903:  uint8(95),
	1904:  uint8(95),
	1905:  uint8(95),
	1906:  uint8(95),
	1907:  uint8(95),
	1908:  uint8(95),
	1909:  uint8(95),
	1910:  uint8(95),
	1911:  uint8(95),
	1912:  uint8(95),
	1913:  uint8(95),
	1914:  uint8(95),
	1915:  uint8(95),
	1916:  uint8(95),
	1917:  uint8(95),
	1918:  uint8(95),
	1919:  uint8(95),
	1920:  uint8(95),
	1921:  uint8(95),
	1922:  uint8(95),
	1923:  uint8(127),
	1924:  uint8(15),
	1925:  uint8(15),
	1926:  uint8(15),
	1927:  uint8(15),
	1928:  uint8(15),
	1929:  uint8(15),
	1930:  uint8(15),
	1931:  uint8(15),
	1932:  uint8(15),
	1933:  uint8(15),
	1934:  uint8(15),
	1935:  uint8(15),
	1936:  uint8(15),
	1937:  uint8(15),
	1938:  uint8(15),
	1939:  uint8(15),
	1940:  uint8(15),
	1941:  uint8(15),
	1942:  uint8(15),
	1943:  uint8(15),
	1944:  uint8(15),
	1945:  uint8(15),
	1946:  uint8(15),
	1947:  uint8(15),
	1948:  uint8(15),
	1949:  uint8(15),
	1950:  uint8(15),
	1951:  uint8(15),
	1952:  uint8(15),
	1953:  uint8(15),
	1954:  uint8(15),
	1955:  uint8(15),
	1956:  uint8(15),
	1957:  uint8(15),
	1958:  uint8(15),
	1959:  uint8(15),
	1960:  uint8(15),
	1961:  uint8(15),
	1962:  uint8(15),
	1963:  uint8(15),
	1964:  uint8(15),
	1965:  uint8(15),
	1966:  uint8(15),
	1967:  uint8(15),
	1968:  uint8(15),
	1969:  uint8(15),
	1970:  uint8(15),
	1971:  uint8(15),
	1972:  uint8(15),
	1973:  uint8(15),
	1974:  uint8(15),
	1975:  uint8(15),
	1976:  uint8(15),
	1977:  uint8(15),
	1978:  uint8(95),
	1979:  uint8(127),
	1980:  uint8(95),
	1981:  uint8(15),
	1982:  uint8(127),
	1983:  uint8(127),
	1984:  uint8(127),
	1985:  uint8(95),
	1986:  uint8(95),
	1987:  uint8(95),
	1988:  uint8(95),
	1989:  uint8(95),
	1990:  uint8(95),
	1991:  uint8(95),
	1992:  uint8(95),
	1993:  uint8(127),
	1994:  uint8(127),
	1995:  uint8(127),
	1996:  uint8(127),
	1997:  uint8(95),
	1998:  uint8(127),
	1999:  uint8(127),
	2000:  uint8(15),
	2001:  uint8(95),
	2002:  uint8(95),
	2003:  uint8(95),
	2004:  uint8(95),
	2005:  uint8(95),
	2006:  uint8(95),
	2007:  uint8(95),
	2008:  uint8(15),
	2009:  uint8(15),
	2010:  uint8(15),
	2011:  uint8(15),
	2012:  uint8(15),
	2013:  uint8(15),
	2014:  uint8(15),
	2015:  uint8(15),
	2016:  uint8(15),
	2017:  uint8(15),
	2018:  uint8(95),
	2019:  uint8(95),
	2020:  uint8(3),
	2021:  uint8(3),
	2022:  uint8(9),
	2023:  uint8(9),
	2024:  uint8(9),
	2025:  uint8(9),
	2026:  uint8(9),
	2027:  uint8(9),
	2028:  uint8(9),
	2029:  uint8(9),
	2030:  uint8(9),
	2031:  uint8(9),
	2032:  uint8(3),
	2033:  uint8(94),
	2034:  uint8(15),
	2035:  uint8(15),
	2036:  uint8(15),
	2037:  uint8(15),
	2038:  uint8(15),
	2039:  uint8(15),
	2040:  uint8(15),
	2041:  uint8(15),
	2042:  uint8(15),
	2043:  uint8(15),
	2044:  uint8(15),
	2045:  uint8(15),
	2046:  uint8(15),
	2047:  uint8(15),
	2048:  uint8(15),
	2049:  uint8(95),
	2050:  uint8(127),
	2051:  uint8(127),
	2053:  uint8(15),
	2054:  uint8(15),
	2055:  uint8(15),
	2056:  uint8(15),
	2057:  uint8(15),
	2058:  uint8(15),
	2059:  uint8(15),
	2060:  uint8(15),
	2063:  uint8(15),
	2064:  uint8(15),
	2067:  uint8(15),
	2068:  uint8(15),
	2069:  uint8(15),
	2070:  uint8(15),
	2071:  uint8(15),
	2072:  uint8(15),
	2073:  uint8(15),
	2074:  uint8(15),
	2075:  uint8(15),
	2076:  uint8(15),
	2077:  uint8(15),
	2078:  uint8(15),
	2079:  uint8(15),
	2080:  uint8(15),
	2081:  uint8(15),
	2082:  uint8(15),
	2083:  uint8(15),
	2084:  uint8(15),
	2085:  uint8(15),
	2086:  uint8(15),
	2087:  uint8(15),
	2088:  uint8(15),
	2090:  uint8(15),
	2091:  uint8(15),
	2092:  uint8(15),
	2093:  uint8(15),
	2094:  uint8(15),
	2095:  uint8(15),
	2096:  uint8(15),
	2098:  uint8(15),
	2102:  uint8(15),
	2103:  uint8(15),
	2104:  uint8(15),
	2105:  uint8(15),
	2108:  uint8(95),
	2109:  uint8(15),
	2110:  uint8(127),
	2111:  uint8(127),
	2112:  uint8(127),
	2113:  uint8(95),
	2114:  uint8(95),
	2115:  uint8(95),
	2116:  uint8(95),
	2119:  uint8(127),
	2120:  uint8(127),
	2123:  uint8(127),
	2124:  uint8(127),
	2125:  uint8(95),
	2126:  uint8(15),
	2135:  uint8(127),
	2140:  uint8(15),
	2141:  uint8(15),
	2143:  uint8(15),
	2144:  uint8(15),
	2145:  uint8(15),
	2146:  uint8(95),
	2147:  uint8(95),
	2150:  uint8(9),
	2151:  uint8(9),
	2152:  uint8(9),
	2153:  uint8(9),
	2154:  uint8(9),
	2155:  uint8(9),
	2156:  uint8(9),
	2157:  uint8(9),
	2158:  uint8(9),
	2159:  uint8(9),
	2160:  uint8(15),
	2161:  uint8(15),
	2162:  uint8(4),
	2163:  uint8(4),
	2164:  uint8(18),
	2165:  uint8(18),
	2166:  uint8(18),
	2167:  uint8(18),
	2168:  uint8(18),
	2169:  uint8(18),
	2170:  uint8(14),
	2171:  uint8(4),
	2172:  uint8(15),
	2173:  uint8(3),
	2174:  uint8(95),
	2177:  uint8(95),
	2178:  uint8(95),
	2179:  uint8(127),
	2181:  uint8(15),
	2182:  uint8(15),
	2183:  uint8(15),
	2184:  uint8(15),
	2185:  uint8(15),
	2186:  uint8(15),
	2191:  uint8(15),
	2192:  uint8(15),
	2195:  uint8(15),
	2196:  uint8(15),
	2197:  uint8(15),
	2198:  uint8(15),
	2199:  uint8(15),
	2200:  uint8(15),
	2201:  uint8(15),
	2202:  uint8(15),
	2203:  uint8(15),
	2204:  uint8(15),
	2205:  uint8(15),
	2206:  uint8(15),
	2207:  uint8(15),
	2208:  uint8(15),
	2209:  uint8(15),
	2210:  uint8(15),
	2211:  uint8(15),
	2212:  uint8(15),
	2213:  uint8(15),
	2214:  uint8(15),
	2215:  uint8(15),
	2216:  uint8(15),
	2218:  uint8(15),
	2219:  uint8(15),
	2220:  uint8(15),
	2221:  uint8(15),
	2222:  uint8(15),
	2223:  uint8(15),
	2224:  uint8(15),
	2226:  uint8(15),
	2227:  uint8(15),
	2229:  uint8(15),
	2230:  uint8(15),
	2232:  uint8(15),
	2233:  uint8(15),
	2236:  uint8(95),
	2238:  uint8(127),
	2239:  uint8(127),
	2240:  uint8(127),
	2241:  uint8(95),
	2242:  uint8(95),
	2247:  uint8(95),
	2248:  uint8(95),
	2251:  uint8(95),
	2252:  uint8(95),
	2253:  uint8(95),
	2257:  uint8(95),
	2265:  uint8(15),
	2266:  uint8(15),
	2267:  uint8(15),
	2268:  uint8(15),
	2270:  uint8(15),
	2278:  uint8(9),
	2279:  uint8(9),
	2280:  uint8(9),
	2281:  uint8(9),
	2282:  uint8(9),
	2283:  uint8(9),
	2284:  uint8(9),
	2285:  uint8(9),
	2286:  uint8(9),
	2287:  uint8(9),
	2288:  uint8(95),
	2289:  uint8(95),
	2290:  uint8(15),
	2291:  uint8(15),
	2292:  uint8(15),
	2293:  uint8(95),
	2294:  uint8(3),
	2305:  uint8(95),
	2306:  uint8(95),
	2307:  uint8(127),
	2309:  uint8(15),
	2310:  uint8(15),
	2311:  uint8(15),
	2312:  uint8(15),
	2313:  uint8(15),
	2314:  uint8(15),
	2315:  uint8(15),
	2316:  uint8(15),
	2317:  uint8(15),
	2319:  uint8(15),
	2320:  uint8(15),
	2321:  uint8(15),
	2323:  uint8(15),
	2324:  uint8(15),
	2325:  uint8(15),
	2326:  uint8(15),
	2327:  uint8(15),
	2328:  uint8(15),
	2329:  uint8(15),
	2330:  uint8(15),
	2331:  uint8(15),
	2332:  uint8(15),
	2333:  uint8(15),
	2334:  uint8(15),
	2335:  uint8(15),
	2336:  uint8(15),
	2337:  uint8(15),
	2338:  uint8(15),
	2339:  uint8(15),
	2340:  uint8(15),
	2341:  uint8(15),
	2342:  uint8(15),
	2343:  uint8(15),
	2344:  uint8(15),
	2346:  uint8(15),
	2347:  uint8(15),
	2348:  uint8(15),
	2349:  uint8(15),
	2350:  uint8(15),
	2351:  uint8(15),
	2352:  uint8(15),
	2354:  uint8(15),
	2355:  uint8(15),
	2357:  uint8(15),
	2358:  uint8(15),
	2359:  uint8(15),
	2360:  uint8(15),
	2361:  uint8(15),
	2364:  uint8(95),
	2365:  uint8(15),
	2366:  uint8(127),
	2367:  uint8(127),
	2368:  uint8(127),
	2369:  uint8(95),
	2370:  uint8(95),
	2371:  uint8(95),
	2372:  uint8(95),
	2373:  uint8(95),
	2375:  uint8(95),
	2376:  uint8(95),
	2377:  uint8(127),
	2379:  uint8(127),
	2380:  uint8(127),
	2381:  uint8(95),
	2384:  uint8(15),
	2400:  uint8(15),
	2401:  uint8(15),
	2402:  uint8(95),
	2403:  uint8(95),
	2406:  uint8(9),
	2407:  uint8(9),
	2408:  uint8(9),
	2409:  uint8(9),
	2410:  uint8(9),
	2411:  uint8(9),
	2412:  uint8(9),
	2413:  uint8(9),
	2414:  uint8(9),
	2415:  uint8(9),
	2416:  uint8(3),
	2417:  uint8(4),
	2425:  uint8(15),
	2426:  uint8(95),
	2427:  uint8(95),
	2428:  uint8(95),
	2429:  uint8(95),
	2430:  uint8(95),
	2431:  uint8(95),
	2433:  uint8(95),
	2434:  uint8(127),
	2435:  uint8(127),
	2437:  uint8(15),
	2438:  uint8(15),
	2439:  uint8(15),
	2440:  uint8(15),
	2441:  uint8(15),
	2442:  uint8(15),
	2443:  uint8(15),
	2444:  uint8(15),
	2447:  uint8(15),
	2448:  uint8(15),
	2451:  uint8(15),
	2452:  uint8(15),
	2453:  uint8(15),
	2454:  uint8(15),
	2455:  uint8(15),
	2456:  uint8(15),
	2457:  uint8(15),
	2458:  uint8(15),
	2459:  uint8(15),
	2460:  uint8(15),
	2461:  uint8(15),
	2462:  uint8(15),
	2463:  uint8(15),
	2464:  uint8(15),
	2465:  uint8(15),
	2466:  uint8(15),
	2467:  uint8(15),
	2468:  uint8(15),
	2469:  uint8(15),
	2470:  uint8(15),
	2471:  uint8(15),
	2472:  uint8(15),
	2474:  uint8(15),
	2475:  uint8(15),
	2476:  uint8(15),
	2477:  uint8(15),
	2478:  uint8(15),
	2479:  uint8(15),
	2480:  uint8(15),
	2482:  uint8(15),
	2483:  uint8(15),
	2485:  uint8(15),
	2486:  uint8(15),
	2487:  uint8(15),
	2488:  uint8(15),
	2489:  uint8(15),
	2492:  uint8(95),
	2493:  uint8(15),
	2494:  uint8(127),
	2495:  uint8(95),
	2496:  uint8(127),
	2497:  uint8(95),
	2498:  uint8(95),
	2499:  uint8(95),
	2500:  uint8(95),
	2503:  uint8(127),
	2504:  uint8(127),
	2507:  uint8(127),
	2508:  uint8(127),
	2509:  uint8(95),
	2517:  uint8(95),
	2518:  uint8(95),
	2519:  uint8(127),
	2524:  uint8(15),
	2525:  uint8(15),
	2527:  uint8(15),
	2528:  uint8(15),
	2529:  uint8(15),
	2530:  uint8(95),
	2531:  uint8(95),
	2534:  uint8(9),
	2535:  uint8(9),
	2536:  uint8(9),
	2537:  uint8(9),
	2538:  uint8(9),
	2539:  uint8(9),
	2540:  uint8(9),
	2541:  uint8(9),
	2542:  uint8(9),
	2543:  uint8(9),
	2544:  uint8(14),
	2545:  uint8(15),
	2546:  uint8(18),
	2547:  uint8(18),
	2548:  uint8(18),
	2549:  uint8(18),
	2550:  uint8(18),
	2551:  uint8(18),
	2562:  uint8(95),
	2563:  uint8(15),
	2565:  uint8(15),
	2566:  uint8(15),
	2567:  uint8(15),
	2568:  uint8(15),
	2569:  uint8(15),
	2570:  uint8(15),
	2574:  uint8(15),
	2575:  uint8(15),
	2576:  uint8(15),
	2578:  uint8(15),
	2579:  uint8(15),
	2580:  uint8(15),
	2581:  uint8(15),
	2585:  uint8(15),
	2586:  uint8(15),
	2588:  uint8(15),
	2590:  uint8(15),
	2591:  uint8(15),
	2595:  uint8(15),
	2596:  uint8(15),
	2600:  uint8(15),
	2601:  uint8(15),
	2602:  uint8(15),
	2606:  uint8(15),
	2607:  uint8(15),
	2608:  uint8(15),
	2609:  uint8(15),
	2610:  uint8(15),
	2611:  uint8(15),
	2612:  uint8(15),
	2613:  uint8(15),
	2614:  uint8(15),
	2615:  uint8(15),
	2616:  uint8(15),
	2617:  uint8(15),
	2622:  uint8(127),
	2623:  uint8(127),
	2624:  uint8(95),
	2625:  uint8(127),
	2626:  uint8(127),
	2630:  uint8(127),
	2631:  uint8(127),
	2632:  uint8(127),
	2634:  uint8(127),
	2635:  uint8(127),
	2636:  uint8(127),
	2637:  uint8(95),
	2640:  uint8(15),
	2647:  uint8(127),
	2662:  uint8(9),
	2663:  uint8(9),
	2664:  uint8(9),
	2665:  uint8(9),
	2666:  uint8(9),
	2667:  uint8(9),
	2668:  uint8(9),
	2669:  uint8(9),
	2670:  uint8(9),
	2671:  uint8(9),
	2672:  uint8(18),
	2673:  uint8(18),
	2674:  uint8(18),
	2675:  uint8(14),
	2676:  uint8(14),
	2677:  uint8(14),
	2678:  uint8(14),
	2679:  uint8(14),
	2680:  uint8(14),
	2681:  uint8(4),
	2682:  uint8(14),
	2688:  uint8(95),
	2689:  uint8(127),
	2690:  uint8(127),
	2691:  uint8(127),
	2692:  uint8(95),
	2693:  uint8(15),
	2694:  uint8(15),
	2695:  uint8(15),
	2696:  uint8(15),
	2697:  uint8(15),
	2698:  uint8(15),
	2699:  uint8(15),
	2700:  uint8(15),
	2702:  uint8(15),
	2703:  uint8(15),
	2704:  uint8(15),
	2706:  uint8(15),
	2707:  uint8(15),
	2708:  uint8(15),
	2709:  uint8(15),
	2710:  uint8(15),
	2711:  uint8(15),
	2712:  uint8(15),
	2713:  uint8(15),
	2714:  uint8(15),
	2715:  uint8(15),
	2716:  uint8(15),
	2717:  uint8(15),
	2718:  uint8(15),
	2719:  uint8(15),
	2720:  uint8(15),
	2721:  uint8(15),
	2722:  uint8(15),
	2723:  uint8(15),
	2724:  uint8(15),
	2725:  uint8(15),
	2726:  uint8(15),
	2727:  uint8(15),
	2728:  uint8(15),
	2730:  uint8(15),
	2731:  uint8(15),
	2732:  uint8(15),
	2733:  uint8(15),
	2734:  uint8(15),
	2735:  uint8(15),
	2736:  uint8(15),
	2737:  uint8(15),
	2738:  uint8(15),
	2739:  uint8(15),
	2740:  uint8(15),
	2741:  uint8(15),
	2742:  uint8(15),
	2743:  uint8(15),
	2744:  uint8(15),
	2745:  uint8(15),
	2748:  uint8(95),
	2749:  uint8(15),
	2750:  uint8(95),
	2751:  uint8(95),
	2752:  uint8(95),
	2753:  uint8(127),
	2754:  uint8(127),
	2755:  uint8(127),
	2756:  uint8(127),
	2758:  uint8(95),
	2759:  uint8(95),
	2760:  uint8(95),
	2762:  uint8(95),
	2763:  uint8(95),
	2764:  uint8(95),
	2765:  uint8(95),
	2773:  uint8(95),
	2774:  uint8(95),
	2776:  uint8(15),
	2777:  uint8(15),
	2778:  uint8(15),
	2781:  uint8(15),
	2784:  uint8(15),
	2785:  uint8(15),
	2786:  uint8(95),
	2787:  uint8(95),
	2790:  uint8(9),
	2791:  uint8(9),
	2792:  uint8(9),
	2793:  uint8(9),
	2794:  uint8(9),
	2795:  uint8(9),
	2796:  uint8(9),
	2797:  uint8(9),
	2798:  uint8(9),
	2799:  uint8(9),
	2807:  uint8(3),
	2808:  uint8(18),
	2809:  uint8(18),
	2810:  uint8(18),
	2811:  uint8(18),
	2812:  uint8(18),
	2813:  uint8(18),
	2814:  uint8(18),
	2815:  uint8(14),
	2816:  uint8(15),
	2817:  uint8(95),
	2818:  uint8(127),
	2819:  uint8(127),
	2820:  uint8(3),
	2821:  uint8(15),
	2822:  uint8(15),
	2823:  uint8(15),
	2824:  uint8(15),
	2825:  uint8(15),
	2826:  uint8(15),
	2827:  uint8(15),
	2828:  uint8(15),
	2830:  uint8(15),
	2831:  uint8(15),
	2832:  uint8(15),
	2834:  uint8(15),
	2835:  uint8(15),
	2836:  uint8(15),
	2837:  uint8(15),
	2838:  uint8(15),
	2839:  uint8(15),
	2840:  uint8(15),
	2841:  uint8(15),
	2842:  uint8(15),
	2843:  uint8(15),
	2844:  uint8(15),
	2845:  uint8(15),
	2846:  uint8(15),
	2847:  uint8(15),
	2848:  uint8(15),
	2849:  uint8(15),
	2850:  uint8(15),
	2851:  uint8(15),
	2852:  uint8(15),
	2853:  uint8(15),
	2854:  uint8(15),
	2855:  uint8(15),
	2856:  uint8(15),
	2858:  uint8(15),
	2859:  uint8(15),
	2860:  uint8(15),
	2861:  uint8(15),
	2862:  uint8(15),
	2863:  uint8(15),
	2864:  uint8(15),
	2865:  uint8(15),
	2866:  uint8(15),
	2867:  uint8(15),
	2869:  uint8(15),
	2870:  uint8(15),
	2871:  uint8(15),
	2872:  uint8(15),
	2873:  uint8(15),
	2876:  uint8(95),
	2877:  uint8(15),
	2878:  uint8(127),
	2879:  uint8(95),
	2880:  uint8(127),
	2881:  uint8(127),
	2882:  uint8(127),
	2883:  uint8(127),
	2884:  uint8(127),
	2886:  uint8(95),
	2887:  uint8(127),
	2888:  uint8(127),
	2890:  uint8(127),
	2891:  uint8(127),
	2892:  uint8(95),
	2893:  uint8(95),
	2901:  uint8(127),
	2902:  uint8(127),
	2909:  uint8(15),
	2910:  uint8(15),
	2912:  uint8(15),
	2913:  uint8(15),
	2914:  uint8(95),
	2915:  uint8(95),
	2918:  uint8(9),
	2919:  uint8(9),
	2920:  uint8(9),
	2921:  uint8(9),
	2922:  uint8(9),
	2923:  uint8(9),
	2924:  uint8(9),
	2925:  uint8(9),
	2926:  uint8(9),
	2927:  uint8(9),
	2929:  uint8(15),
	2930:  uint8(15),
	2931:  uint8(127),
	2944:  uint8(95),
	2945:  uint8(95),
	2946:  uint8(127),
	2947:  uint8(127),
	2948:  uint8(15),
	2949:  uint8(15),
	2950:  uint8(15),
	2951:  uint8(15),
	2952:  uint8(15),
	2953:  uint8(15),
	2954:  uint8(15),
	2955:  uint8(15),
	2956:  uint8(15),
	2958:  uint8(15),
	2959:  uint8(15),
	2960:  uint8(15),
	2962:  uint8(15),
	2963:  uint8(15),
	2964:  uint8(15),
	2965:  uint8(15),
	2966:  uint8(15),
	2967:  uint8(15),
	2968:  uint8(15),
	2969:  uint8(15),
	2970:  uint8(15),
	2971:  uint8(15),
	2972:  uint8(15),
	2973:  uint8(15),
	2974:  uint8(15),
	2975:  uint8(15),
	2976:  uint8(15),
	2977:  uint8(15),
	2978:  uint8(15),
	2979:  uint8(15),
	2980:  uint8(15),
	2981:  uint8(15),
	2982:  uint8(15),
	2983:  uint8(15),
	2984:  uint8(15),
	2985:  uint8(15),
	2986:  uint8(15),
	2987:  uint8(15),
	2988:  uint8(15),
	2989:  uint8(15),
	2990:  uint8(15),
	2991:  uint8(15),
	2992:  uint8(15),
	2993:  uint8(15),
	2994:  uint8(15),
	2995:  uint8(15),
	2996:  uint8(15),
	2997:  uint8(15),
	2998:  uint8(15),
	2999:  uint8(15),
	3000:  uint8(15),
	3001:  uint8(15),
	3002:  uint8(15),
	3003:  uint8(95),
	3004:  uint8(95),
	3005:  uint8(15),
	3006:  uint8(127),
	3007:  uint8(127),
	3008:  uint8(127),
	3009:  uint8(95),
	3010:  uint8(95),
	3011:  uint8(95),
	3012:  uint8(95),
	3014:  uint8(127),
	3015:  uint8(127),
	3016:  uint8(127),
	3018:  uint8(127),
	3019:  uint8(127),
	3020:  uint8(127),
	3021:  uint8(95),
	3022:  uint8(15),
	3023:  uint8(14),
	3028:  uint8(15),
	3029:  uint8(15),
	3030:  uint8(15),
	3031:  uint8(127),
	3032:  uint8(18),
	3033:  uint8(18),
	3034:  uint8(18),
	3035:  uint8(18),
	3036:  uint8(18),
	3037:  uint8(18),
	3038:  uint8(18),
	3039:  uint8(15),
	3040:  uint8(15),
	3041:  uint8(15),
	3042:  uint8(95),
	3043:  uint8(95),
	3046:  uint8(9),
	3047:  uint8(9),
	3048:  uint8(9),
	3049:  uint8(9),
	3050:  uint8(9),
	3051:  uint8(9),
	3052:  uint8(9),
	3053:  uint8(9),
	3054:  uint8(9),
	3055:  uint8(9),
	3056:  uint8(18),
	3057:  uint8(18),
	3058:  uint8(18),
	3059:  uint8(18),
	3060:  uint8(18),
	3061:  uint8(18),
	3062:  uint8(18),
	3063:  uint8(18),
	3064:  uint8(18),
	3065:  uint8(14),
	3066:  uint8(15),
	3067:  uint8(15),
	3068:  uint8(15),
	3069:  uint8(15),
	3070:  uint8(15),
	3071:  uint8(15),
	3073:  uint8(95),
	3074:  uint8(127),
	3075:  uint8(127),
	3077:  uint8(15),
	3078:  uint8(15),
	3079:  uint8(15),
	3080:  uint8(15),
	3081:  uint8(15),
	3082:  uint8(15),
	3083:  uint8(15),
	3084:  uint8(15),
	3085:  uint8(15),
	3086:  uint8(15),
	3087:  uint8(15),
	3088:  uint8(15),
	3089:  uint8(15),
	3090:  uint8(15),
	3091:  uint8(15),
	3092:  uint8(15),
	3093:  uint8(15),
	3094:  uint8(15),
	3098:  uint8(15),
	3099:  uint8(15),
	3100:  uint8(15),
	3101:  uint8(15),
	3102:  uint8(15),
	3103:  uint8(15),
	3104:  uint8(15),
	3105:  uint8(15),
	3106:  uint8(15),
	3107:  uint8(15),
	3108:  uint8(15),
	3109:  uint8(15),
	3110:  uint8(15),
	3111:  uint8(15),
	3112:  uint8(15),
	3113:  uint8(15),
	3114:  uint8(15),
	3115:  uint8(15),
	3116:  uint8(15),
	3117:  uint8(15),
	3118:  uint8(15),
	3119:  uint8(15),
	3120:  uint8(15),
	3121:  uint8(15),
	3123:  uint8(15),
	3124:  uint8(15),
	3125:  uint8(15),
	3126:  uint8(15),
	3127:  uint8(15),
	3128:  uint8(15),
	3129:  uint8(15),
	3130:  uint8(15),
	3131:  uint8(15),
	3133:  uint8(15),
	3136:  uint8(15),
	3137:  uint8(15),
	3138:  uint8(15),
	3139:  uint8(15),
	3140:  uint8(15),
	3141:  uint8(15),
	3142:  uint8(15),
	3146:  uint8(95),
	3151:  uint8(127),
	3152:  uint8(127),
	3153:  uint8(127),
	3154:  uint8(95),
	3155:  uint8(95),
	3156:  uint8(95),
	3158:  uint8(95),
	3160:  uint8(127),
	3161:  uint8(127),
	3162:  uint8(127),
	3163:  uint8(127),
	3164:  uint8(127),
	3165:  uint8(127),
	3166:  uint8(127),
	3167:  uint8(127),
	3174:  uint8(9),
	3175:  uint8(9),
	3176:  uint8(9),
	3177:  uint8(9),
	3178:  uint8(9),
	3179:  uint8(9),
	3180:  uint8(9),
	3181:  uint8(9),
	3182:  uint8(9),
	3183:  uint8(9),
	3186:  uint8(127),
	3187:  uint8(127),
	3188:  uint8(3),
	3201:  uint8(15),
	3202:  uint8(15),
	3203:  uint8(15),
	3204:  uint8(15),
	3205:  uint8(15),
	3206:  uint8(15),
	3207:  uint8(15),
	3208:  uint8(15),
	3209:  uint8(15),
	3210:  uint8(15),
	3211:  uint8(15),
	3212:  uint8(15),
	3213:  uint8(15),
	3214:  uint8(15),
	3215:  uint8(15),
	3216:  uint8(15),
	3217:  uint8(15),
	3218:  uint8(15),
	3219:  uint8(15),
	3220:  uint8(15),
	3221:  uint8(15),
	3222:  uint8(15),
	3223:  uint8(15),
	3224:  uint8(15),
	3225:  uint8(15),
	3226:  uint8(15),
	3227:  uint8(15),
	3228:  uint8(15),
	3229:  uint8(15),
	3230:  uint8(15),
	3231:  uint8(15),
	3232:  uint8(15),
	3233:  uint8(15),
	3234:  uint8(15),
	3235:  uint8(15),
	3236:  uint8(15),
	3237:  uint8(15),
	3238:  uint8(15),
	3239:  uint8(15),
	3240:  uint8(15),
	3241:  uint8(15),
	3242:  uint8(15),
	3243:  uint8(15),
	3244:  uint8(15),
	3245:  uint8(15),
	3246:  uint8(15),
	3247:  uint8(15),
	3248:  uint8(15),
	3249:  uint8(95),
	3250:  uint8(15),
	3251:  uint8(15),
	3252:  uint8(95),
	3253:  uint8(95),
	3254:  uint8(95),
	3255:  uint8(95),
	3256:  uint8(95),
	3257:  uint8(95),
	3258:  uint8(95),
	3263:  uint8(4),
	3264:  uint8(15),
	3265:  uint8(15),
	3266:  uint8(15),
	3267:  uint8(15),
	3268:  uint8(15),
	3269:  uint8(15),
	3270:  uint8(94),
	3271:  uint8(95),
	3272:  uint8(95),
	3273:  uint8(95),
	3274:  uint8(95),
	3275:  uint8(95),
	3276:  uint8(95),
	3277:  uint8(95),
	3278:  uint8(95),
	3279:  uint8(3),
	3280:  uint8(9),
	3281:  uint8(9),
	3282:  uint8(9),
	3283:  uint8(9),
	3284:  uint8(9),
	3285:  uint8(9),
	3286:  uint8(9),
	3287:  uint8(9),
	3288:  uint8(9),
	3289:  uint8(9),
	3290:  uint8(3),
	3291:  uint8(3),
	3329:  uint8(15),
	3330:  uint8(15),
	3332:  uint8(15),
	3334:  uint8(15),
	3335:  uint8(15),
	3336:  uint8(15),
	3337:  uint8(15),
	3338:  uint8(15),
	3340:  uint8(15),
	3341:  uint8(15),
	3342:  uint8(15),
	3343:  uint8(15),
	3344:  uint8(15),
	3345:  uint8(15),
	3346:  uint8(15),
	3347:  uint8(15),
	3348:  uint8(15),
	3349:  uint8(15),
	3350:  uint8(15),
	3351:  uint8(15),
	3352:  uint8(15),
	3353:  uint8(15),
	3354:  uint8(15),
	3355:  uint8(15),
	3356:  uint8(15),
	3357:  uint8(15),
	3358:  uint8(15),
	3359:  uint8(15),
	3360:  uint8(15),
	3361:  uint8(15),
	3362:  uint8(15),
	3363:  uint8(15),
	3365:  uint8(15),
	3367:  uint8(15),
	3368:  uint8(15),
	3369:  uint8(15),
	3370:  uint8(15),
	3371:  uint8(15),
	3372:  uint8(15),
	3373:  uint8(15),
	3374:  uint8(15),
	3375:  uint8(15),
	3376:  uint8(15),
	3377:  uint8(95),
	3378:  uint8(15),
	3379:  uint8(15),
	3380:  uint8(95),
	3381:  uint8(95),
	3382:  uint8(95),
	3383:  uint8(95),
	3384:  uint8(95),
	3385:  uint8(95),
	3386:  uint8(95),
	3387:  uint8(95),
	3388:  uint8(95),
	3389:  uint8(15),
	3392:  uint8(15),
	3393:  uint8(15),
	3394:  uint8(15),
	3395:  uint8(15),
	3396:  uint8(15),
	3398:  uint8(94),
	3400:  uint8(95),
	3401:  uint8(95),
	3402:  uint8(95),
	3403:  uint8(95),
	3404:  uint8(95),
	3405:  uint8(95),
	3406:  uint8(95),
	3408:  uint8(9),
	3409:  uint8(9),
	3410:  uint8(9),
	3411:  uint8(9),
	3412:  uint8(9),
	3413:  uint8(9),
	3414:  uint8(9),
	3415:  uint8(9),
	3416:  uint8(9),
	3417:  uint8(9),
	3420:  uint8(15),
	3421:  uint8(15),
	3422:  uint8(15),
	3423:  uint8(15),
	3424:  uint8(15),
	3425:  uint8(14),
	3426:  uint8(14),
	3427:  uint8(14),
	3428:  uint8(3),
	3429:  uint8(3),
	3430:  uint8(3),
	3431:  uint8(3),
	3432:  uint8(3),
	3433:  uint8(3),
	3434:  uint8(3),
	3435:  uint8(3),
	3436:  uint8(3),
	3437:  uint8(3),
	3438:  uint8(3),
	3439:  uint8(3),
	3440:  uint8(3),
	3441:  uint8(3),
	3442:  uint8(3),
	3443:  uint8(14),
	3444:  uint8(3),
	3445:  uint8(14),
	3446:  uint8(14),
	3447:  uint8(14),
	3448:  uint8(95),
	3449:  uint8(95),
	3450:  uint8(14),
	3451:  uint8(14),
	3452:  uint8(14),
	3453:  uint8(14),
	3454:  uint8(14),
	3455:  uint8(14),
	3456:  uint8(9),
	3457:  uint8(9),
	3458:  uint8(9),
	3459:  uint8(9),
	3460:  uint8(9),
	3461:  uint8(9),
	3462:  uint8(9),
	3463:  uint8(9),
	3464:  uint8(9),
	3465:  uint8(9),
	3466:  uint8(18),
	3467:  uint8(18),
	3468:  uint8(18),
	3469:  uint8(18),
	3470:  uint8(18),
	3471:  uint8(18),
	3472:  uint8(18),
	3473:  uint8(18),
	3474:  uint8(18),
	3475:  uint8(18),
	3476:  uint8(14),
	3477:  uint8(95),
	3478:  uint8(14),
	3479:  uint8(95),
	3480:  uint8(14),
	3481:  uint8(95),
	3482:  uint8(5),
	3483:  uint8(6),
	3484:  uint8(5),
	3485:  uint8(6),
	3486:  uint8(127),
	3487:  uint8(127),
	3488:  uint8(15),
	3489:  uint8(15),
	3490:  uint8(15),
	3491:  uint8(15),
	3492:  uint8(15),
	3493:  uint8(15),
	3494:  uint8(15),
	3495:  uint8(15),
	3497:  uint8(15),
	3498:  uint8(15),
	3499:  uint8(15),
	3500:  uint8(15),
	3501:  uint8(15),
	3502:  uint8(15),
	3503:  uint8(15),
	3504:  uint8(15),
	3505:  uint8(15),
	3506:  uint8(15),
	3507:  uint8(15),
	3508:  uint8(15),
	3509:  uint8(15),
	3510:  uint8(15),
	3511:  uint8(15),
	3512:  uint8(15),
	3513:  uint8(15),
	3514:  uint8(15),
	3515:  uint8(15),
	3516:  uint8(15),
	3517:  uint8(15),
	3518:  uint8(15),
	3519:  uint8(15),
	3520:  uint8(15),
	3521:  uint8(15),
	3522:  uint8(15),
	3523:  uint8(15),
	3524:  uint8(15),
	3525:  uint8(15),
	3526:  uint8(15),
	3527:  uint8(15),
	3528:  uint8(15),
	3529:  uint8(15),
	3530:  uint8(15),
	3531:  uint8(15),
	3532:  uint8(15),
	3537:  uint8(95),
	3538:  uint8(95),
	3539:  uint8(95),
	3540:  uint8(95),
	3541:  uint8(95),
	3542:  uint8(95),
	3543:  uint8(95),
	3544:  uint8(95),
	3545:  uint8(95),
	3546:  uint8(95),
	3547:  uint8(95),
	3548:  uint8(95),
	3549:  uint8(95),
	3550:  uint8(95),
	3551:  uint8(127),
	3552:  uint8(95),
	3553:  uint8(95),
	3554:  uint8(95),
	3555:  uint8(95),
	3556:  uint8(95),
	3557:  uint8(3),
	3558:  uint8(95),
	3559:  uint8(95),
	3560:  uint8(15),
	3561:  uint8(15),
	3562:  uint8(15),
	3563:  uint8(15),
	3564:  uint8(15),
	3565:  uint8(95),
	3566:  uint8(95),
	3567:  uint8(95),
	3568:  uint8(95),
	3569:  uint8(95),
	3570:  uint8(95),
	3571:  uint8(95),
	3572:  uint8(95),
	3573:  uint8(95),
	3574:  uint8(95),
	3575:  uint8(95),
	3577:  uint8(95),
	3578:  uint8(95),
	3579:  uint8(95),
	3580:  uint8(95),
	3581:  uint8(95),
	3582:  uint8(95),
	3583:  uint8(95),
	3584:  uint8(95),
	3585:  uint8(95),
	3586:  uint8(95),
	3587:  uint8(95),
	3588:  uint8(95),
	3589:  uint8(95),
	3590:  uint8(95),
	3591:  uint8(95),
	3592:  uint8(95),
	3593:  uint8(95),
	3594:  uint8(95),
	3595:  uint8(95),
	3596:  uint8(95),
	3597:  uint8(95),
	3598:  uint8(95),
	3599:  uint8(95),
	3600:  uint8(95),
	3601:  uint8(95),
	3602:  uint8(95),
	3603:  uint8(95),
	3604:  uint8(95),
	3605:  uint8(95),
	3606:  uint8(95),
	3607:  uint8(95),
	3608:  uint8(95),
	3609:  uint8(95),
	3610:  uint8(95),
	3611:  uint8(95),
	3612:  uint8(95),
	3614:  uint8(14),
	3615:  uint8(14),
	3616:  uint8(14),
	3617:  uint8(14),
	3618:  uint8(14),
	3619:  uint8(14),
	3620:  uint8(14),
	3621:  uint8(14),
	3622:  uint8(95),
	3623:  uint8(14),
	3624:  uint8(14),
	3625:  uint8(14),
	3626:  uint8(14),
	3627:  uint8(14),
	3628:  uint8(14),
	3630:  uint8(14),
	3631:  uint8(14),
	3632:  uint8(3),
	3633:  uint8(3),
	3634:  uint8(3),
	3635:  uint8(3),
	3636:  uint8(3),
	3637:  uint8(14),
	3638:  uint8(14),
	3639:  uint8(14),
	3640:  uint8(14),
	3641:  uint8(3),
	3642:  uint8(3),
	3648:  uint8(15),
	3649:  uint8(15),
	3650:  uint8(15),
	3651:  uint8(15),
	3652:  uint8(15),
	3653:  uint8(15),
	3654:  uint8(15),
	3655:  uint8(15),
	3656:  uint8(15),
	3657:  uint8(15),
	3658:  uint8(15),
	3659:  uint8(127),
	3660:  uint8(127),
	3661:  uint8(95),
	3662:  uint8(95),
	3663:  uint8(95),
	3664:  uint8(95),
	3665:  uint8(127),
	3666:  uint8(95),
	3667:  uint8(95),
	3668:  uint8(95),
	3669:  uint8(95),
	3670:  uint8(95),
	3671:  uint8(95),
	3672:  uint8(127),
	3673:  uint8(95),
	3674:  uint8(95),
	3675:  uint8(127),
	3676:  uint8(127),
	3677:  uint8(95),
	3678:  uint8(95),
	3679:  uint8(15),
	3680:  uint8(9),
	3681:  uint8(9),
	3682:  uint8(9),
	3683:  uint8(9),
	3684:  uint8(9),
	3685:  uint8(9),
	3686:  uint8(9),
	3687:  uint8(9),
	3688:  uint8(9),
	3689:  uint8(9),
	3690:  uint8(3),
	3691:  uint8(3),
	3692:  uint8(3),
	3693:  uint8(3),
	3694:  uint8(3),
	3695:  uint8(3),
	3696:  uint8(15),
	3697:  uint8(15),
	3698:  uint8(15),
	3699:  uint8(15),
	3700:  uint8(15),
	3701:  uint8(15),
	3702:  uint8(127),
	3703:  uint8(127),
	3704:  uint8(95),
	3705:  uint8(95),
	3706:  uint8(15),
	3707:  uint8(15),
	3708:  uint8(15),
	3709:  uint8(15),
	3710:  uint8(95),
	3711:  uint8(95),
	3712:  uint8(95),
	3713:  uint8(15),
	3714:  uint8(127),
	3715:  uint8(127),
	3716:  uint8(127),
	3717:  uint8(15),
	3718:  uint8(15),
	3719:  uint8(127),
	3720:  uint8(127),
	3721:  uint8(127),
	3722:  uint8(127),
	3723:  uint8(127),
	3724:  uint8(127),
	3725:  uint8(127),
	3726:  uint8(15),
	3727:  uint8(15),
	3728:  uint8(15),
	3729:  uint8(95),
	3730:  uint8(95),
	3731:  uint8(95),
	3732:  uint8(95),
	3733:  uint8(15),
	3734:  uint8(15),
	3735:  uint8(15),
	3736:  uint8(15),
	3737:  uint8(15),
	3738:  uint8(15),
	3739:  uint8(15),
	3740:  uint8(15),
	3741:  uint8(15),
	3742:  uint8(15),
	3743:  uint8(15),
	3744:  uint8(15),
	3745:  uint8(15),
	3746:  uint8(95),
	3747:  uint8(127),
	3748:  uint8(127),
	3749:  uint8(95),
	3750:  uint8(95),
	3751:  uint8(127),
	3752:  uint8(127),
	3753:  uint8(127),
	3754:  uint8(127),
	3755:  uint8(127),
	3756:  uint8(127),
	3757:  uint8(95),
	3758:  uint8(15),
	3759:  uint8(127),
	3760:  uint8(9),
	3761:  uint8(9),
	3762:  uint8(9),
	3763:  uint8(9),
	3764:  uint8(9),
	3765:  uint8(9),
	3766:  uint8(9),
	3767:  uint8(9),
	3768:  uint8(9),
	3769:  uint8(9),
	3770:  uint8(127),
	3771:  uint8(127),
	3772:  uint8(127),
	3773:  uint8(95),
	3774:  uint8(14),
	3775:  uint8(14),
	3776:  uint8(128),
	3777:  uint8(128),
	3778:  uint8(128),
	3779:  uint8(128),
	3780:  uint8(128),
	3781:  uint8(128),
	3782:  uint8(128),
	3783:  uint8(128),
	3784:  uint8(128),
	3785:  uint8(128),
	3786:  uint8(128),
	3787:  uint8(128),
	3788:  uint8(128),
	3789:  uint8(128),
	3790:  uint8(128),
	3791:  uint8(128),
	3792:  uint8(128),
	3793:  uint8(128),
	3794:  uint8(128),
	3795:  uint8(128),
	3796:  uint8(128),
	3797:  uint8(128),
	3798:  uint8(128),
	3799:  uint8(128),
	3800:  uint8(128),
	3801:  uint8(128),
	3802:  uint8(128),
	3803:  uint8(128),
	3804:  uint8(128),
	3805:  uint8(128),
	3806:  uint8(128),
	3807:  uint8(128),
	3808:  uint8(128),
	3809:  uint8(128),
	3810:  uint8(128),
	3811:  uint8(128),
	3812:  uint8(128),
	3813:  uint8(128),
	3815:  uint8(128),
	3821:  uint8(128),
	3824:  uint8(129),
	3825:  uint8(129),
	3826:  uint8(129),
	3827:  uint8(129),
	3828:  uint8(129),
	3829:  uint8(129),
	3830:  uint8(129),
	3831:  uint8(129),
	3832:  uint8(129),
	3833:  uint8(129),
	3834:  uint8(129),
	3835:  uint8(129),
	3836:  uint8(129),
	3837:  uint8(129),
	3838:  uint8(129),
	3839:  uint8(129),
	3840:  uint8(129),
	3841:  uint8(129),
	3842:  uint8(129),
	3843:  uint8(129),
	3844:  uint8(129),
	3845:  uint8(129),
	3846:  uint8(129),
	3847:  uint8(129),
	3848:  uint8(129),
	3849:  uint8(129),
	3850:  uint8(129),
	3851:  uint8(129),
	3852:  uint8(129),
	3853:  uint8(129),
	3854:  uint8(129),
	3855:  uint8(129),
	3856:  uint8(129),
	3857:  uint8(129),
	3858:  uint8(129),
	3859:  uint8(129),
	3860:  uint8(129),
	3861:  uint8(129),
	3862:  uint8(129),
	3863:  uint8(129),
	3864:  uint8(129),
	3865:  uint8(129),
	3866:  uint8(129),
	3867:  uint8(3),
	3868:  uint8(94),
	3869:  uint8(129),
	3870:  uint8(129),
	3871:  uint8(129),
	3872:  uint8(15),
	3873:  uint8(15),
	3874:  uint8(15),
	3875:  uint8(15),
	3876:  uint8(15),
	3877:  uint8(15),
	3878:  uint8(15),
	3879:  uint8(15),
	3880:  uint8(15),
	3882:  uint8(15),
	3883:  uint8(15),
	3884:  uint8(15),
	3885:  uint8(15),
	3888:  uint8(15),
	3889:  uint8(15),
	3890:  uint8(15),
	3891:  uint8(15),
	3892:  uint8(15),
	3893:  uint8(15),
	3894:  uint8(15),
	3896:  uint8(15),
	3898:  uint8(15),
	3899:  uint8(15),
	3900:  uint8(15),
	3901:  uint8(15),
	3904:  uint8(15),
	3905:  uint8(15),
	3906:  uint8(15),
	3907:  uint8(15),
	3908:  uint8(15),
	3909:  uint8(15),
	3910:  uint8(15),
	3911:  uint8(15),
	3912:  uint8(15),
	3914:  uint8(15),
	3915:  uint8(15),
	3916:  uint8(15),
	3917:  uint8(15),
	3920:  uint8(15),
	3921:  uint8(15),
	3922:  uint8(15),
	3923:  uint8(15),
	3924:  uint8(15),
	3925:  uint8(15),
	3926:  uint8(15),
	3927:  uint8(15),
	3928:  uint8(15),
	3929:  uint8(15),
	3930:  uint8(15),
	3931:  uint8(15),
	3932:  uint8(15),
	3933:  uint8(15),
	3934:  uint8(15),
	3935:  uint8(15),
	3936:  uint8(15),
	3937:  uint8(15),
	3938:  uint8(15),
	3939:  uint8(15),
	3940:  uint8(15),
	3941:  uint8(15),
	3942:  uint8(15),
	3943:  uint8(15),
	3944:  uint8(15),
	3945:  uint8(15),
	3946:  uint8(15),
	3947:  uint8(15),
	3948:  uint8(15),
	3949:  uint8(15),
	3950:  uint8(15),
	3951:  uint8(15),
	3952:  uint8(15),
	3954:  uint8(15),
	3955:  uint8(15),
	3956:  uint8(15),
	3957:  uint8(15),
	3960:  uint8(15),
	3961:  uint8(15),
	3962:  uint8(15),
	3963:  uint8(15),
	3964:  uint8(15),
	3965:  uint8(15),
	3966:  uint8(15),
	3968:  uint8(15),
	3970:  uint8(15),
	3971:  uint8(15),
	3972:  uint8(15),
	3973:  uint8(15),
	3976:  uint8(15),
	3977:  uint8(15),
	3978:  uint8(15),
	3979:  uint8(15),
	3980:  uint8(15),
	3981:  uint8(15),
	3982:  uint8(15),
	3983:  uint8(15),
	3984:  uint8(15),
	3985:  uint8(15),
	3986:  uint8(15),
	3987:  uint8(15),
	3988:  uint8(15),
	3989:  uint8(15),
	3990:  uint8(15),
	3992:  uint8(15),
	3993:  uint8(15),
	3994:  uint8(15),
	3995:  uint8(15),
	3996:  uint8(15),
	3997:  uint8(15),
	3998:  uint8(15),
	3999:  uint8(15),
	4000:  uint8(15),
	4001:  uint8(15),
	4002:  uint8(15),
	4003:  uint8(15),
	4004:  uint8(15),
	4005:  uint8(15),
	4006:  uint8(15),
	4007:  uint8(15),
	4008:  uint8(15),
	4009:  uint8(15),
	4010:  uint8(15),
	4011:  uint8(15),
	4012:  uint8(15),
	4013:  uint8(15),
	4014:  uint8(15),
	4015:  uint8(15),
	4016:  uint8(15),
	4018:  uint8(15),
	4019:  uint8(15),
	4020:  uint8(15),
	4021:  uint8(15),
	4024:  uint8(15),
	4025:  uint8(15),
	4026:  uint8(15),
	4027:  uint8(15),
	4028:  uint8(15),
	4029:  uint8(15),
	4030:  uint8(15),
	4031:  uint8(15),
	4032:  uint8(15),
	4033:  uint8(15),
	4034:  uint8(15),
	4035:  uint8(15),
	4036:  uint8(15),
	4037:  uint8(15),
	4038:  uint8(15),
	4039:  uint8(15),
	4040:  uint8(15),
	4041:  uint8(15),
	4042:  uint8(15),
	4043:  uint8(15),
	4044:  uint8(15),
	4045:  uint8(15),
	4046:  uint8(15),
	4047:  uint8(15),
	4048:  uint8(15),
	4049:  uint8(15),
	4050:  uint8(15),
	4051:  uint8(15),
	4052:  uint8(15),
	4053:  uint8(15),
	4054:  uint8(15),
	4055:  uint8(15),
	4056:  uint8(15),
	4057:  uint8(15),
	4058:  uint8(15),
	4061:  uint8(95),
	4062:  uint8(95),
	4063:  uint8(95),
	4064:  uint8(3),
	4065:  uint8(3),
	4066:  uint8(3),
	4067:  uint8(3),
	4068:  uint8(3),
	4069:  uint8(3),
	4070:  uint8(3),
	4071:  uint8(3),
	4072:  uint8(3),
	4073:  uint8(18),
	4074:  uint8(18),
	4075:  uint8(18),
	4076:  uint8(18),
	4077:  uint8(18),
	4078:  uint8(18),
	4079:  uint8(18),
	4080:  uint8(18),
	4081:  uint8(18),
	4082:  uint8(18),
	4083:  uint8(18),
	4084:  uint8(18),
	4085:  uint8(18),
	4086:  uint8(18),
	4087:  uint8(18),
	4088:  uint8(18),
	4089:  uint8(18),
	4090:  uint8(18),
	4091:  uint8(18),
	4092:  uint8(18),
	4096:  uint8(15),
	4097:  uint8(15),
	4098:  uint8(15),
	4099:  uint8(15),
	4100:  uint8(15),
	4101:  uint8(15),
	4102:  uint8(15),
	4103:  uint8(15),
	4104:  uint8(15),
	4105:  uint8(15),
	4106:  uint8(15),
	4107:  uint8(15),
	4108:  uint8(15),
	4109:  uint8(15),
	4110:  uint8(15),
	4111:  uint8(15),
	4112:  uint8(14),
	4113:  uint8(14),
	4114:  uint8(14),
	4115:  uint8(14),
	4116:  uint8(14),
	4117:  uint8(14),
	4118:  uint8(14),
	4119:  uint8(14),
	4120:  uint8(14),
	4121:  uint8(14),
	4128:  uint8(130),
	4129:  uint8(130),
	4130:  uint8(130),
	4131:  uint8(130),
	4132:  uint8(130),
	4133:  uint8(130),
	4134:  uint8(130),
	4135:  uint8(130),
	4136:  uint8(130),
	4137:  uint8(130),
	4138:  uint8(130),
	4139:  uint8(130),
	4140:  uint8(130),
	4141:  uint8(130),
	4142:  uint8(130),
	4143:  uint8(130),
	4144:  uint8(130),
	4145:  uint8(130),
	4146:  uint8(130),
	4147:  uint8(130),
	4148:  uint8(130),
	4149:  uint8(130),
	4150:  uint8(130),
	4151:  uint8(130),
	4152:  uint8(130),
	4153:  uint8(130),
	4154:  uint8(130),
	4155:  uint8(130),
	4156:  uint8(130),
	4157:  uint8(130),
	4158:  uint8(130),
	4159:  uint8(130),
	4160:  uint8(130),
	4161:  uint8(130),
	4162:  uint8(130),
	4163:  uint8(130),
	4164:  uint8(130),
	4165:  uint8(130),
	4166:  uint8(130),
	4167:  uint8(130),
	4168:  uint8(130),
	4169:  uint8(130),
	4170:  uint8(130),
	4171:  uint8(130),
	4172:  uint8(130),
	4173:  uint8(130),
	4174:  uint8(130),
	4175:  uint8(130),
	4176:  uint8(107),
	4177:  uint8(107),
	4178:  uint8(107),
	4179:  uint8(107),
	4180:  uint8(107),
	4181:  uint8(107),
	4184:  uint8(113),
	4185:  uint8(113),
	4186:  uint8(113),
	4187:  uint8(113),
	4188:  uint8(113),
	4189:  uint8(113),
	4192:  uint8(8),
	4193:  uint8(15),
	4194:  uint8(15),
	4195:  uint8(15),
	4196:  uint8(15),
	4197:  uint8(15),
	4198:  uint8(15),
	4199:  uint8(15),
	4200:  uint8(15),
	4201:  uint8(15),
	4202:  uint8(15),
	4203:  uint8(15),
	4204:  uint8(15),
	4205:  uint8(15),
	4206:  uint8(15),
	4207:  uint8(15),
	4208:  uint8(15),
	4209:  uint8(15),
	4210:  uint8(15),
	4211:  uint8(15),
	4212:  uint8(15),
	4213:  uint8(15),
	4214:  uint8(15),
	4215:  uint8(15),
	4216:  uint8(15),
	4217:  uint8(15),
	4218:  uint8(15),
	4219:  uint8(15),
	4220:  uint8(15),
	4221:  uint8(15),
	4222:  uint8(15),
	4223:  uint8(15),
	4224:  uint8(15),
	4225:  uint8(15),
	4226:  uint8(15),
	4227:  uint8(15),
	4228:  uint8(15),
	4229:  uint8(15),
	4230:  uint8(15),
	4231:  uint8(15),
	4232:  uint8(15),
	4233:  uint8(15),
	4234:  uint8(15),
	4235:  uint8(15),
	4236:  uint8(15),
	4237:  uint8(14),
	4238:  uint8(3),
	4239:  uint8(15),
	4240:  uint8(15),
	4241:  uint8(15),
	4242:  uint8(15),
	4243:  uint8(15),
	4244:  uint8(15),
	4245:  uint8(15),
	4246:  uint8(15),
	4247:  uint8(15),
	4248:  uint8(15),
	4249:  uint8(15),
	4250:  uint8(15),
	4251:  uint8(15),
	4252:  uint8(15),
	4253:  uint8(15),
	4254:  uint8(15),
	4255:  uint8(15),
	4256:  uint8(2),
	4257:  uint8(15),
	4258:  uint8(15),
	4259:  uint8(15),
	4260:  uint8(15),
	4261:  uint8(15),
	4262:  uint8(15),
	4263:  uint8(15),
	4264:  uint8(15),
	4265:  uint8(15),
	4266:  uint8(15),
	4267:  uint8(15),
	4268:  uint8(15),
	4269:  uint8(15),
	4270:  uint8(15),
	4271:  uint8(15),
	4272:  uint8(15),
	4273:  uint8(15),
	4274:  uint8(15),
	4275:  uint8(15),
	4276:  uint8(15),
	4277:  uint8(15),
	4278:  uint8(15),
	4279:  uint8(15),
	4280:  uint8(15),
	4281:  uint8(15),
	4282:  uint8(15),
	4283:  uint8(5),
	4284:  uint8(6),
	4288:  uint8(15),
	4289:  uint8(15),
	4290:  uint8(15),
	4291:  uint8(15),
	4292:  uint8(15),
	4293:  uint8(15),
	4294:  uint8(15),
	4295:  uint8(15),
	4296:  uint8(15),
	4297:  uint8(15),
	4298:  uint8(15),
	4299:  uint8(3),
	4300:  uint8(3),
	4301:  uint8(3),
	4302:  uint8(131),
	4303:  uint8(131),
	4304:  uint8(131),
	4305:  uint8(15),
	4306:  uint8(15),
	4307:  uint8(15),
	4308:  uint8(15),
	4309:  uint8(15),
	4310:  uint8(15),
	4311:  uint8(15),
	4312:  uint8(15),
	4320:  uint8(15),
	4321:  uint8(15),
	4322:  uint8(15),
	4323:  uint8(15),
	4324:  uint8(15),
	4325:  uint8(15),
	4326:  uint8(15),
	4327:  uint8(15),
	4328:  uint8(15),
	4329:  uint8(15),
	4330:  uint8(15),
	4331:  uint8(15),
	4332:  uint8(15),
	4333:  uint8(15),
	4334:  uint8(15),
	4335:  uint8(15),
	4336:  uint8(15),
	4337:  uint8(15),
	4338:  uint8(95),
	4339:  uint8(95),
	4340:  uint8(95),
	4341:  uint8(127),
	4351:  uint8(15),
	4352:  uint8(15),
	4353:  uint8(15),
	4354:  uint8(15),
	4355:  uint8(15),
	4356:  uint8(15),
	4357:  uint8(15),
	4358:  uint8(15),
	4359:  uint8(15),
	4360:  uint8(15),
	4361:  uint8(15),
	4362:  uint8(15),
	4363:  uint8(15),
	4364:  uint8(15),
	4365:  uint8(15),
	4366:  uint8(15),
	4367:  uint8(15),
	4368:  uint8(15),
	4369:  uint8(15),
	4370:  uint8(95),
	4371:  uint8(95),
	4372:  uint8(127),
	4373:  uint8(3),
	4374:  uint8(3),
	4384:  uint8(15),
	4385:  uint8(15),
	4386:  uint8(15),
	4387:  uint8(15),
	4388:  uint8(15),
	4389:  uint8(15),
	4390:  uint8(15),
	4391:  uint8(15),
	4392:  uint8(15),
	4393:  uint8(15),
	4394:  uint8(15),
	4395:  uint8(15),
	4396:  uint8(15),
	4397:  uint8(15),
	4398:  uint8(15),
	4399:  uint8(15),
	4400:  uint8(15),
	4401:  uint8(15),
	4402:  uint8(95),
	4403:  uint8(95),
	4416:  uint8(15),
	4417:  uint8(15),
	4418:  uint8(15),
	4419:  uint8(15),
	4420:  uint8(15),
	4421:  uint8(15),
	4422:  uint8(15),
	4423:  uint8(15),
	4424:  uint8(15),
	4425:  uint8(15),
	4426:  uint8(15),
	4427:  uint8(15),
	4428:  uint8(15),
	4430:  uint8(15),
	4431:  uint8(15),
	4432:  uint8(15),
	4434:  uint8(95),
	4435:  uint8(95),
	4448:  uint8(15),
	4449:  uint8(15),
	4450:  uint8(15),
	4451:  uint8(15),
	4452:  uint8(15),
	4453:  uint8(15),
	4454:  uint8(15),
	4455:  uint8(15),
	4456:  uint8(15),
	4457:  uint8(15),
	4458:  uint8(15),
	4459:  uint8(15),
	4460:  uint8(15),
	4461:  uint8(15),
	4462:  uint8(15),
	4463:  uint8(15),
	4464:  uint8(15),
	4465:  uint8(15),
	4466:  uint8(15),
	4467:  uint8(15),
	4468:  uint8(95),
	4469:  uint8(95),
	4470:  uint8(127),
	4471:  uint8(95),
	4472:  uint8(95),
	4473:  uint8(95),
	4474:  uint8(95),
	4475:  uint8(95),
	4476:  uint8(95),
	4477:  uint8(95),
	4478:  uint8(127),
	4479:  uint8(127),
	4480:  uint8(127),
	4481:  uint8(127),
	4482:  uint8(127),
	4483:  uint8(127),
	4484:  uint8(127),
	4485:  uint8(127),
	4486:  uint8(95),
	4487:  uint8(127),
	4488:  uint8(127),
	4489:  uint8(95),
	4490:  uint8(95),
	4491:  uint8(95),
	4492:  uint8(95),
	4493:  uint8(95),
	4494:  uint8(95),
	4495:  uint8(95),
	4496:  uint8(95),
	4497:  uint8(95),
	4498:  uint8(95),
	4499:  uint8(95),
	4500:  uint8(3),
	4501:  uint8(3),
	4502:  uint8(3),
	4503:  uint8(94),
	4504:  uint8(3),
	4505:  uint8(3),
	4506:  uint8(3),
	4507:  uint8(4),
	4508:  uint8(15),
	4509:  uint8(95),
	4512:  uint8(9),
	4513:  uint8(9),
	4514:  uint8(9),
	4515:  uint8(9),
	4516:  uint8(9),
	4517:  uint8(9),
	4518:  uint8(9),
	4519:  uint8(9),
	4520:  uint8(9),
	4521:  uint8(9),
	4528:  uint8(18),
	4529:  uint8(18),
	4530:  uint8(18),
	4531:  uint8(18),
	4532:  uint8(18),
	4533:  uint8(18),
	4534:  uint8(18),
	4535:  uint8(18),
	4536:  uint8(18),
	4537:  uint8(18),
	4544:  uint8(3),
	4545:  uint8(3),
	4546:  uint8(3),
	4547:  uint8(3),
	4548:  uint8(3),
	4549:  uint8(3),
	4550:  uint8(8),
	4551:  uint8(3),
	4552:  uint8(3),
	4553:  uint8(3),
	4554:  uint8(3),
	4555:  uint8(95),
	4556:  uint8(95),
	4557:  uint8(95),
	4558:  uint8(17),
	4559:  uint8(95),
	4560:  uint8(9),
	4561:  uint8(9),
	4562:  uint8(9),
	4563:  uint8(9),
	4564:  uint8(9),
	4565:  uint8(9),
	4566:  uint8(9),
	4567:  uint8(9),
	4568:  uint8(9),
	4569:  uint8(9),
	4576:  uint8(15),
	4577:  uint8(15),
	4578:  uint8(15),
	4579:  uint8(94),
	4580:  uint8(15),
	4581:  uint8(15),
	4582:  uint8(15),
	4583:  uint8(15),
	4584:  uint8(15),
	4585:  uint8(15),
	4586:  uint8(15),
	4587:  uint8(15),
	4588:  uint8(15),
	4589:  uint8(15),
	4590:  uint8(15),
	4591:  uint8(15),
	4592:  uint8(15),
	4593:  uint8(15),
	4594:  uint8(15),
	4595:  uint8(15),
	4596:  uint8(15),
	4597:  uint8(15),
	4598:  uint8(15),
	4599:  uint8(15),
	4600:  uint8(15),
	4601:  uint8(15),
	4602:  uint8(15),
	4603:  uint8(15),
	4604:  uint8(15),
	4605:  uint8(15),
	4606:  uint8(15),
	4607:  uint8(15),
	4608:  uint8(15),
	4609:  uint8(15),
	4610:  uint8(15),
	4611:  uint8(15),
	4612:  uint8(15),
	4613:  uint8(15),
	4614:  uint8(15),
	4615:  uint8(15),
	4616:  uint8(15),
	4617:  uint8(15),
	4618:  uint8(15),
	4619:  uint8(15),
	4620:  uint8(15),
	4621:  uint8(15),
	4622:  uint8(15),
	4623:  uint8(15),
	4624:  uint8(15),
	4625:  uint8(15),
	4626:  uint8(15),
	4627:  uint8(15),
	4628:  uint8(15),
	4629:  uint8(15),
	4630:  uint8(15),
	4631:  uint8(15),
	4632:  uint8(15),
	4640:  uint8(15),
	4641:  uint8(15),
	4642:  uint8(15),
	4643:  uint8(15),
	4644:  uint8(15),
	4645:  uint8(95),
	4646:  uint8(95),
	4647:  uint8(15),
	4648:  uint8(15),
	4649:  uint8(15),
	4650:  uint8(15),
	4651:  uint8(15),
	4652:  uint8(15),
	4653:  uint8(15),
	4654:  uint8(15),
	4655:  uint8(15),
	4656:  uint8(15),
	4657:  uint8(15),
	4658:  uint8(15),
	4659:  uint8(15),
	4660:  uint8(15),
	4661:  uint8(15),
	4662:  uint8(15),
	4663:  uint8(15),
	4664:  uint8(15),
	4665:  uint8(15),
	4666:  uint8(15),
	4667:  uint8(15),
	4668:  uint8(15),
	4669:  uint8(15),
	4670:  uint8(15),
	4671:  uint8(15),
	4672:  uint8(15),
	4673:  uint8(15),
	4674:  uint8(15),
	4675:  uint8(15),
	4676:  uint8(15),
	4677:  uint8(15),
	4678:  uint8(15),
	4679:  uint8(15),
	4680:  uint8(15),
	4681:  uint8(95),
	4682:  uint8(15),
	4688:  uint8(15),
	4689:  uint8(15),
	4690:  uint8(15),
	4691:  uint8(15),
	4692:  uint8(15),
	4693:  uint8(15),
	4694:  uint8(15),
	4695:  uint8(15),
	4696:  uint8(15),
	4697:  uint8(15),
	4698:  uint8(15),
	4699:  uint8(15),
	4700:  uint8(15),
	4701:  uint8(15),
	4702:  uint8(15),
	4703:  uint8(15),
	4704:  uint8(15),
	4705:  uint8(15),
	4706:  uint8(15),
	4707:  uint8(15),
	4708:  uint8(15),
	4709:  uint8(15),
	4710:  uint8(15),
	4711:  uint8(15),
	4712:  uint8(15),
	4713:  uint8(15),
	4714:  uint8(15),
	4715:  uint8(15),
	4716:  uint8(15),
	4717:  uint8(15),
	4718:  uint8(15),
	4719:  uint8(15),
	4720:  uint8(15),
	4721:  uint8(15),
	4722:  uint8(15),
	4723:  uint8(15),
	4724:  uint8(15),
	4725:  uint8(15),
	4736:  uint8(15),
	4737:  uint8(15),
	4738:  uint8(15),
	4739:  uint8(15),
	4740:  uint8(15),
	4741:  uint8(15),
	4742:  uint8(15),
	4743:  uint8(15),
	4744:  uint8(15),
	4745:  uint8(15),
	4746:  uint8(15),
	4747:  uint8(15),
	4748:  uint8(15),
	4749:  uint8(15),
	4750:  uint8(15),
	4751:  uint8(15),
	4752:  uint8(15),
	4753:  uint8(15),
	4754:  uint8(15),
	4755:  uint8(15),
	4756:  uint8(15),
	4757:  uint8(15),
	4758:  uint8(15),
	4759:  uint8(15),
	4760:  uint8(15),
	4761:  uint8(15),
	4762:  uint8(15),
	4763:  uint8(15),
	4764:  uint8(15),
	4765:  uint8(15),
	4766:  uint8(15),
	4768:  uint8(95),
	4769:  uint8(95),
	4770:  uint8(95),
	4771:  uint8(127),
	4772:  uint8(127),
	4773:  uint8(127),
	4774:  uint8(127),
	4775:  uint8(95),
	4776:  uint8(95),
	4777:  uint8(127),
	4778:  uint8(127),
	4779:  uint8(127),
	4784:  uint8(127),
	4785:  uint8(127),
	4786:  uint8(95),
	4787:  uint8(127),
	4788:  uint8(127),
	4789:  uint8(127),
	4790:  uint8(127),
	4791:  uint8(127),
	4792:  uint8(127),
	4793:  uint8(95),
	4794:  uint8(95),
	4795:  uint8(95),
	4800:  uint8(14),
	4804:  uint8(3),
	4805:  uint8(3),
	4806:  uint8(9),
	4807:  uint8(9),
	4808:  uint8(9),
	4809:  uint8(9),
	4810:  uint8(9),
	4811:  uint8(9),
	4812:  uint8(9),
	4813:  uint8(9),
	4814:  uint8(9),
	4815:  uint8(9),
	4816:  uint8(15),
	4817:  uint8(15),
	4818:  uint8(15),
	4819:  uint8(15),
	4820:  uint8(15),
	4821:  uint8(15),
	4822:  uint8(15),
	4823:  uint8(15),
	4824:  uint8(15),
	4825:  uint8(15),
	4826:  uint8(15),
	4827:  uint8(15),
	4828:  uint8(15),
	4829:  uint8(15),
	4830:  uint8(15),
	4831:  uint8(15),
	4832:  uint8(15),
	4833:  uint8(15),
	4834:  uint8(15),
	4835:  uint8(15),
	4836:  uint8(15),
	4837:  uint8(15),
	4838:  uint8(15),
	4839:  uint8(15),
	4840:  uint8(15),
	4841:  uint8(15),
	4842:  uint8(15),
	4843:  uint8(15),
	4844:  uint8(15),
	4845:  uint8(15),
	4848:  uint8(15),
	4849:  uint8(15),
	4850:  uint8(15),
	4851:  uint8(15),
	4852:  uint8(15),
	4864:  uint8(15),
	4865:  uint8(15),
	4866:  uint8(15),
	4867:  uint8(15),
	4868:  uint8(15),
	4869:  uint8(15),
	4870:  uint8(15),
	4871:  uint8(15),
	4872:  uint8(15),
	4873:  uint8(15),
	4874:  uint8(15),
	4875:  uint8(15),
	4880:  uint8(15),
	4881:  uint8(15),
	4882:  uint8(15),
	4883:  uint8(15),
	4884:  uint8(15),
	4885:  uint8(15),
	4886:  uint8(15),
	4887:  uint8(15),
	4888:  uint8(15),
	4889:  uint8(15),
	4890:  uint8(15),
	4891:  uint8(15),
	4892:  uint8(15),
	4893:  uint8(15),
	4894:  uint8(15),
	4895:  uint8(15),
	4896:  uint8(15),
	4897:  uint8(15),
	4898:  uint8(15),
	4899:  uint8(15),
	4900:  uint8(15),
	4901:  uint8(15),
	4902:  uint8(15),
	4903:  uint8(15),
	4904:  uint8(15),
	4905:  uint8(15),
	4912:  uint8(9),
	4913:  uint8(9),
	4914:  uint8(9),
	4915:  uint8(9),
	4916:  uint8(9),
	4917:  uint8(9),
	4918:  uint8(9),
	4919:  uint8(9),
	4920:  uint8(9),
	4921:  uint8(9),
	4922:  uint8(18),
	4926:  uint8(14),
	4927:  uint8(14),
	4928:  uint8(14),
	4929:  uint8(14),
	4930:  uint8(14),
	4931:  uint8(14),
	4932:  uint8(14),
	4933:  uint8(14),
	4934:  uint8(14),
	4935:  uint8(14),
	4936:  uint8(14),
	4937:  uint8(14),
	4938:  uint8(14),
	4939:  uint8(14),
	4940:  uint8(14),
	4941:  uint8(14),
	4942:  uint8(14),
	4943:  uint8(14),
	4944:  uint8(14),
	4945:  uint8(14),
	4946:  uint8(14),
	4947:  uint8(14),
	4948:  uint8(14),
	4949:  uint8(14),
	4950:  uint8(14),
	4951:  uint8(14),
	4952:  uint8(14),
	4953:  uint8(14),
	4954:  uint8(14),
	4955:  uint8(14),
	4956:  uint8(14),
	4957:  uint8(14),
	4958:  uint8(14),
	4959:  uint8(14),
	4960:  uint8(15),
	4961:  uint8(15),
	4962:  uint8(15),
	4963:  uint8(15),
	4964:  uint8(15),
	4965:  uint8(15),
	4966:  uint8(15),
	4967:  uint8(15),
	4968:  uint8(15),
	4969:  uint8(15),
	4970:  uint8(15),
	4971:  uint8(15),
	4972:  uint8(15),
	4973:  uint8(15),
	4974:  uint8(15),
	4975:  uint8(15),
	4976:  uint8(15),
	4977:  uint8(15),
	4978:  uint8(15),
	4979:  uint8(15),
	4980:  uint8(15),
	4981:  uint8(15),
	4982:  uint8(15),
	4983:  uint8(95),
	4984:  uint8(95),
	4985:  uint8(127),
	4986:  uint8(127),
	4987:  uint8(95),
	4990:  uint8(3),
	4991:  uint8(3),
	4992:  uint8(15),
	4993:  uint8(15),
	4994:  uint8(15),
	4995:  uint8(15),
	4996:  uint8(15),
	4997:  uint8(15),
	4998:  uint8(15),
	4999:  uint8(15),
	5000:  uint8(15),
	5001:  uint8(15),
	5002:  uint8(15),
	5003:  uint8(15),
	5004:  uint8(15),
	5005:  uint8(15),
	5006:  uint8(15),
	5007:  uint8(15),
	5008:  uint8(15),
	5009:  uint8(15),
	5010:  uint8(15),
	5011:  uint8(15),
	5012:  uint8(15),
	5013:  uint8(127),
	5014:  uint8(95),
	5015:  uint8(127),
	5016:  uint8(95),
	5017:  uint8(95),
	5018:  uint8(95),
	5019:  uint8(95),
	5020:  uint8(95),
	5021:  uint8(95),
	5022:  uint8(95),
	5024:  uint8(95),
	5025:  uint8(127),
	5026:  uint8(95),
	5027:  uint8(127),
	5028:  uint8(127),
	5029:  uint8(95),
	5030:  uint8(95),
	5031:  uint8(95),
	5032:  uint8(95),
	5033:  uint8(95),
	5034:  uint8(95),
	5035:  uint8(95),
	5036:  uint8(95),
	5037:  uint8(127),
	5038:  uint8(127),
	5039:  uint8(127),
	5040:  uint8(127),
	5041:  uint8(127),
	5042:  uint8(127),
	5043:  uint8(95),
	5044:  uint8(95),
	5045:  uint8(95),
	5046:  uint8(95),
	5047:  uint8(95),
	5048:  uint8(95),
	5049:  uint8(95),
	5050:  uint8(95),
	5051:  uint8(95),
	5052:  uint8(95),
	5055:  uint8(95),
	5056:  uint8(9),
	5057:  uint8(9),
	5058:  uint8(9),
	5059:  uint8(9),
	5060:  uint8(9),
	5061:  uint8(9),
	5062:  uint8(9),
	5063:  uint8(9),
	5064:  uint8(9),
	5065:  uint8(9),
	5072:  uint8(9),
	5073:  uint8(9),
	5074:  uint8(9),
	5075:  uint8(9),
	5076:  uint8(9),
	5077:  uint8(9),
	5078:  uint8(9),
	5079:  uint8(9),
	5080:  uint8(9),
	5081:  uint8(9),
	5088:  uint8(3),
	5089:  uint8(3),
	5090:  uint8(3),
	5091:  uint8(3),
	5092:  uint8(3),
	5093:  uint8(3),
	5094:  uint8(3),
	5095:  uint8(94),
	5096:  uint8(3),
	5097:  uint8(3),
	5098:  uint8(3),
	5099:  uint8(3),
	5100:  uint8(3),
	5101:  uint8(3),
	5104:  uint8(95),
	5105:  uint8(95),
	5106:  uint8(95),
	5107:  uint8(95),
	5108:  uint8(95),
	5109:  uint8(95),
	5110:  uint8(95),
	5111:  uint8(95),
	5112:  uint8(95),
	5113:  uint8(95),
	5114:  uint8(95),
	5115:  uint8(95),
	5116:  uint8(95),
	5117:  uint8(95),
	5118:  uint8(122),
	5119:  uint8(95),
	5120:  uint8(95),
	5121:  uint8(95),
	5122:  uint8(95),
	5123:  uint8(95),
	5124:  uint8(95),
	5125:  uint8(95),
	5126:  uint8(95),
	5127:  uint8(95),
	5128:  uint8(95),
	5129:  uint8(95),
	5130:  uint8(95),
	5131:  uint8(95),
	5132:  uint8(95),
	5133:  uint8(95),
	5134:  uint8(95),
	5152:  uint8(95),
	5153:  uint8(95),
	5154:  uint8(95),
	5155:  uint8(95),
	5156:  uint8(127),
	5157:  uint8(15),
	5158:  uint8(15),
	5159:  uint8(15),
	5160:  uint8(15),
	5161:  uint8(15),
	5162:  uint8(15),
	5163:  uint8(15),
	5164:  uint8(15),
	5165:  uint8(15),
	5166:  uint8(15),
	5167:  uint8(15),
	5168:  uint8(15),
	5169:  uint8(15),
	5170:  uint8(15),
	5171:  uint8(15),
	5172:  uint8(15),
	5173:  uint8(15),
	5174:  uint8(15),
	5175:  uint8(15),
	5176:  uint8(15),
	5177:  uint8(15),
	5178:  uint8(15),
	5179:  uint8(15),
	5180:  uint8(15),
	5181:  uint8(15),
	5182:  uint8(15),
	5183:  uint8(15),
	5184:  uint8(15),
	5185:  uint8(15),
	5186:  uint8(15),
	5187:  uint8(15),
	5188:  uint8(15),
	5189:  uint8(15),
	5190:  uint8(15),
	5191:  uint8(15),
	5192:  uint8(15),
	5193:  uint8(15),
	5194:  uint8(15),
	5195:  uint8(15),
	5196:  uint8(15),
	5197:  uint8(15),
	5198:  uint8(15),
	5199:  uint8(15),
	5200:  uint8(15),
	5201:  uint8(15),
	5202:  uint8(15),
	5203:  uint8(15),
	5204:  uint8(95),
	5205:  uint8(127),
	5206:  uint8(95),
	5207:  uint8(95),
	5208:  uint8(95),
	5209:  uint8(95),
	5210:  uint8(95),
	5211:  uint8(127),
	5212:  uint8(95),
	5213:  uint8(127),
	5214:  uint8(127),
	5215:  uint8(127),
	5216:  uint8(127),
	5217:  uint8(127),
	5218:  uint8(95),
	5219:  uint8(127),
	5220:  uint8(127),
	5221:  uint8(15),
	5222:  uint8(15),
	5223:  uint8(15),
	5224:  uint8(15),
	5225:  uint8(15),
	5226:  uint8(15),
	5227:  uint8(15),
	5228:  uint8(15),
	5230:  uint8(3),
	5231:  uint8(3),
	5232:  uint8(9),
	5233:  uint8(9),
	5234:  uint8(9),
	5235:  uint8(9),
	5236:  uint8(9),
	5237:  uint8(9),
	5238:  uint8(9),
	5239:  uint8(9),
	5240:  uint8(9),
	5241:  uint8(9),
	5242:  uint8(3),
	5243:  uint8(3),
	5244:  uint8(3),
	5245:  uint8(3),
	5246:  uint8(3),
	5247:  uint8(3),
	5248:  uint8(3),
	5249:  uint8(14),
	5250:  uint8(14),
	5251:  uint8(14),
	5252:  uint8(14),
	5253:  uint8(14),
	5254:  uint8(14),
	5255:  uint8(14),
	5256:  uint8(14),
	5257:  uint8(14),
	5258:  uint8(14),
	5259:  uint8(95),
	5260:  uint8(95),
	5261:  uint8(95),
	5262:  uint8(95),
	5263:  uint8(95),
	5264:  uint8(95),
	5265:  uint8(95),
	5266:  uint8(95),
	5267:  uint8(95),
	5268:  uint8(14),
	5269:  uint8(14),
	5270:  uint8(14),
	5271:  uint8(14),
	5272:  uint8(14),
	5273:  uint8(14),
	5274:  uint8(14),
	5275:  uint8(14),
	5276:  uint8(14),
	5277:  uint8(3),
	5278:  uint8(3),
	5279:  uint8(3),
	5280:  uint8(95),
	5281:  uint8(95),
	5282:  uint8(127),
	5283:  uint8(15),
	5284:  uint8(15),
	5285:  uint8(15),
	5286:  uint8(15),
	5287:  uint8(15),
	5288:  uint8(15),
	5289:  uint8(15),
	5290:  uint8(15),
	5291:  uint8(15),
	5292:  uint8(15),
	5293:  uint8(15),
	5294:  uint8(15),
	5295:  uint8(15),
	5296:  uint8(15),
	5297:  uint8(15),
	5298:  uint8(15),
	5299:  uint8(15),
	5300:  uint8(15),
	5301:  uint8(15),
	5302:  uint8(15),
	5303:  uint8(15),
	5304:  uint8(15),
	5305:  uint8(15),
	5306:  uint8(15),
	5307:  uint8(15),
	5308:  uint8(15),
	5309:  uint8(15),
	5310:  uint8(15),
	5311:  uint8(15),
	5312:  uint8(15),
	5313:  uint8(127),
	5314:  uint8(95),
	5315:  uint8(95),
	5316:  uint8(95),
	5317:  uint8(95),
	5318:  uint8(127),
	5319:  uint8(127),
	5320:  uint8(95),
	5321:  uint8(95),
	5322:  uint8(127),
	5323:  uint8(95),
	5324:  uint8(95),
	5325:  uint8(95),
	5326:  uint8(15),
	5327:  uint8(15),
	5328:  uint8(9),
	5329:  uint8(9),
	5330:  uint8(9),
	5331:  uint8(9),
	5332:  uint8(9),
	5333:  uint8(9),
	5334:  uint8(9),
	5335:  uint8(9),
	5336:  uint8(9),
	5337:  uint8(9),
	5338:  uint8(15),
	5339:  uint8(15),
	5340:  uint8(15),
	5341:  uint8(15),
	5342:  uint8(15),
	5343:  uint8(15),
	5344:  uint8(15),
	5345:  uint8(15),
	5346:  uint8(15),
	5347:  uint8(15),
	5348:  uint8(15),
	5349:  uint8(15),
	5350:  uint8(95),
	5351:  uint8(127),
	5352:  uint8(95),
	5353:  uint8(95),
	5354:  uint8(127),
	5355:  uint8(127),
	5356:  uint8(127),
	5357:  uint8(95),
	5358:  uint8(127),
	5359:  uint8(95),
	5360:  uint8(95),
	5361:  uint8(95),
	5362:  uint8(127),
	5363:  uint8(127),
	5372:  uint8(3),
	5373:  uint8(3),
	5374:  uint8(3),
	5375:  uint8(3),
	5376:  uint8(15),
	5377:  uint8(15),
	5378:  uint8(15),
	5379:  uint8(15),
	5380:  uint8(127),
	5381:  uint8(127),
	5382:  uint8(127),
	5383:  uint8(127),
	5384:  uint8(127),
	5385:  uint8(127),
	5386:  uint8(127),
	5387:  uint8(127),
	5388:  uint8(95),
	5389:  uint8(95),
	5390:  uint8(95),
	5391:  uint8(95),
	5392:  uint8(95),
	5393:  uint8(95),
	5394:  uint8(95),
	5395:  uint8(95),
	5396:  uint8(127),
	5397:  uint8(127),
	5398:  uint8(95),
	5399:  uint8(95),
	5403:  uint8(3),
	5404:  uint8(3),
	5405:  uint8(3),
	5406:  uint8(3),
	5407:  uint8(3),
	5408:  uint8(9),
	5409:  uint8(9),
	5410:  uint8(9),
	5411:  uint8(9),
	5412:  uint8(9),
	5413:  uint8(9),
	5414:  uint8(9),
	5415:  uint8(9),
	5416:  uint8(9),
	5417:  uint8(9),
	5421:  uint8(15),
	5422:  uint8(15),
	5423:  uint8(15),
	5424:  uint8(9),
	5425:  uint8(9),
	5426:  uint8(9),
	5427:  uint8(9),
	5428:  uint8(9),
	5429:  uint8(9),
	5430:  uint8(9),
	5431:  uint8(9),
	5432:  uint8(9),
	5433:  uint8(9),
	5434:  uint8(15),
	5435:  uint8(15),
	5436:  uint8(15),
	5437:  uint8(15),
	5438:  uint8(15),
	5439:  uint8(15),
	5440:  uint8(15),
	5441:  uint8(15),
	5442:  uint8(15),
	5443:  uint8(15),
	5444:  uint8(15),
	5445:  uint8(15),
	5446:  uint8(15),
	5447:  uint8(15),
	5448:  uint8(15),
	5449:  uint8(15),
	5450:  uint8(15),
	5451:  uint8(15),
	5452:  uint8(15),
	5453:  uint8(15),
	5454:  uint8(15),
	5455:  uint8(15),
	5456:  uint8(15),
	5457:  uint8(15),
	5458:  uint8(15),
	5459:  uint8(15),
	5460:  uint8(15),
	5461:  uint8(15),
	5462:  uint8(15),
	5463:  uint8(15),
	5464:  uint8(94),
	5465:  uint8(94),
	5466:  uint8(94),
	5467:  uint8(94),
	5468:  uint8(94),
	5469:  uint8(94),
	5470:  uint8(3),
	5471:  uint8(3),
	5472:  uint8(132),
	5473:  uint8(133),
	5474:  uint8(134),
	5475:  uint8(135),
	5476:  uint8(135),
	5477:  uint8(136),
	5478:  uint8(137),
	5479:  uint8(138),
	5480:  uint8(139),
	5481:  uint8(23),
	5482:  uint8(24),
	5488:  uint8(140),
	5489:  uint8(140),
	5490:  uint8(140),
	5491:  uint8(140),
	5492:  uint8(140),
	5493:  uint8(140),
	5494:  uint8(140),
	5495:  uint8(140),
	5496:  uint8(140),
	5497:  uint8(140),
	5498:  uint8(140),
	5499:  uint8(140),
	5500:  uint8(140),
	5501:  uint8(140),
	5502:  uint8(140),
	5503:  uint8(140),
	5504:  uint8(140),
	5505:  uint8(140),
	5506:  uint8(140),
	5507:  uint8(140),
	5508:  uint8(140),
	5509:  uint8(140),
	5510:  uint8(140),
	5511:  uint8(140),
	5512:  uint8(140),
	5513:  uint8(140),
	5514:  uint8(140),
	5515:  uint8(140),
	5516:  uint8(140),
	5517:  uint8(140),
	5518:  uint8(140),
	5519:  uint8(140),
	5520:  uint8(140),
	5521:  uint8(140),
	5522:  uint8(140),
	5523:  uint8(140),
	5524:  uint8(140),
	5525:  uint8(140),
	5526:  uint8(140),
	5527:  uint8(140),
	5528:  uint8(140),
	5529:  uint8(140),
	5530:  uint8(140),
	5533:  uint8(140),
	5534:  uint8(140),
	5535:  uint8(140),
	5536:  uint8(3),
	5537:  uint8(3),
	5538:  uint8(3),
	5539:  uint8(3),
	5540:  uint8(3),
	5541:  uint8(3),
	5542:  uint8(3),
	5543:  uint8(3),
	5552:  uint8(95),
	5553:  uint8(95),
	5554:  uint8(95),
	5555:  uint8(3),
	5556:  uint8(95),
	5557:  uint8(95),
	5558:  uint8(95),
	5559:  uint8(95),
	5560:  uint8(95),
	5561:  uint8(95),
	5562:  uint8(95),
	5563:  uint8(95),
	5564:  uint8(95),
	5565:  uint8(95),
	5566:  uint8(95),
	5567:  uint8(95),
	5568:  uint8(95),
	5569:  uint8(127),
	5570:  uint8(95),
	5571:  uint8(95),
	5572:  uint8(95),
	5573:  uint8(95),
	5574:  uint8(95),
	5575:  uint8(95),
	5576:  uint8(95),
	5577:  uint8(15),
	5578:  uint8(15),
	5579:  uint8(15),
	5580:  uint8(15),
	5581:  uint8(95),
	5582:  uint8(15),
	5583:  uint8(15),
	5584:  uint8(15),
	5585:  uint8(15),
	5586:  uint8(15),
	5587:  uint8(15),
	5588:  uint8(95),
	5589:  uint8(15),
	5590:  uint8(15),
	5591:  uint8(127),
	5592:  uint8(95),
	5593:  uint8(95),
	5594:  uint8(15),
	5600:  uint8(21),
	5601:  uint8(21),
	5602:  uint8(21),
	5603:  uint8(21),
	5604:  uint8(21),
	5605:  uint8(21),
	5606:  uint8(21),
	5607:  uint8(21),
	5608:  uint8(21),
	5609:  uint8(21),
	5610:  uint8(21),
	5611:  uint8(21),
	5612:  uint8(21),
	5613:  uint8(21),
	5614:  uint8(21),
	5615:  uint8(21),
	5616:  uint8(21),
	5617:  uint8(21),
	5618:  uint8(21),
	5619:  uint8(21),
	5620:  uint8(21),
	5621:  uint8(21),
	5622:  uint8(21),
	5623:  uint8(21),
	5624:  uint8(21),
	5625:  uint8(21),
	5626:  uint8(21),
	5627:  uint8(21),
	5628:  uint8(21),
	5629:  uint8(21),
	5630:  uint8(21),
	5631:  uint8(21),
	5632:  uint8(21),
	5633:  uint8(21),
	5634:  uint8(21),
	5635:  uint8(21),
	5636:  uint8(21),
	5637:  uint8(21),
	5638:  uint8(21),
	5639:  uint8(21),
	5640:  uint8(21),
	5641:  uint8(21),
	5642:  uint8(21),
	5643:  uint8(21),
	5644:  uint8(94),
	5645:  uint8(94),
	5646:  uint8(94),
	5647:  uint8(94),
	5648:  uint8(94),
	5649:  uint8(94),
	5650:  uint8(94),
	5651:  uint8(94),
	5652:  uint8(94),
	5653:  uint8(94),
	5654:  uint8(94),
	5655:  uint8(94),
	5656:  uint8(94),
	5657:  uint8(94),
	5658:  uint8(94),
	5659:  uint8(94),
	5660:  uint8(94),
	5661:  uint8(94),
	5662:  uint8(94),
	5663:  uint8(94),
	5664:  uint8(94),
	5665:  uint8(94),
	5666:  uint8(94),
	5667:  uint8(94),
	5668:  uint8(94),
	5669:  uint8(94),
	5670:  uint8(94),
	5671:  uint8(94),
	5672:  uint8(94),
	5673:  uint8(94),
	5674:  uint8(94),
	5675:  uint8(94),
	5676:  uint8(94),
	5677:  uint8(94),
	5678:  uint8(94),
	5679:  uint8(94),
	5680:  uint8(94),
	5681:  uint8(94),
	5682:  uint8(94),
	5683:  uint8(94),
	5684:  uint8(94),
	5685:  uint8(94),
	5686:  uint8(94),
	5687:  uint8(94),
	5688:  uint8(94),
	5689:  uint8(94),
	5690:  uint8(94),
	5691:  uint8(94),
	5692:  uint8(94),
	5693:  uint8(94),
	5694:  uint8(94),
	5695:  uint8(94),
	5696:  uint8(94),
	5697:  uint8(94),
	5698:  uint8(94),
	5699:  uint8(94),
	5700:  uint8(94),
	5701:  uint8(94),
	5702:  uint8(94),
	5703:  uint8(94),
	5704:  uint8(94),
	5705:  uint8(94),
	5706:  uint8(94),
	5707:  uint8(21),
	5708:  uint8(21),
	5709:  uint8(21),
	5710:  uint8(21),
	5711:  uint8(21),
	5712:  uint8(21),
	5713:  uint8(21),
	5714:  uint8(21),
	5715:  uint8(21),
	5716:  uint8(21),
	5717:  uint8(21),
	5718:  uint8(21),
	5719:  uint8(21),
	5720:  uint8(94),
	5721:  uint8(141),
	5722:  uint8(21),
	5723:  uint8(21),
	5724:  uint8(21),
	5725:  uint8(142),
	5726:  uint8(21),
	5727:  uint8(21),
	5728:  uint8(21),
	5729:  uint8(21),
	5730:  uint8(21),
	5731:  uint8(21),
	5732:  uint8(21),
	5733:  uint8(21),
	5734:  uint8(21),
	5735:  uint8(21),
	5736:  uint8(21),
	5737:  uint8(21),
	5738:  uint8(21),
	5739:  uint8(21),
	5740:  uint8(21),
	5741:  uint8(21),
	5742:  uint8(143),
	5743:  uint8(21),
	5744:  uint8(21),
	5745:  uint8(21),
	5746:  uint8(21),
	5747:  uint8(21),
	5748:  uint8(21),
	5749:  uint8(21),
	5750:  uint8(21),
	5751:  uint8(21),
	5752:  uint8(21),
	5753:  uint8(21),
	5754:  uint8(21),
	5755:  uint8(94),
	5756:  uint8(94),
	5757:  uint8(94),
	5758:  uint8(94),
	5759:  uint8(94),
	5760:  uint8(23),
	5761:  uint8(24),
	5762:  uint8(23),
	5763:  uint8(24),
	5764:  uint8(23),
	5765:  uint8(24),
	5766:  uint8(23),
	5767:  uint8(24),
	5768:  uint8(23),
	5769:  uint8(24),
	5770:  uint8(23),
	5771:  uint8(24),
	5772:  uint8(23),
	5773:  uint8(24),
	5774:  uint8(23),
	5775:  uint8(24),
	5776:  uint8(23),
	5777:  uint8(24),
	5778:  uint8(23),
	5779:  uint8(24),
	5780:  uint8(23),
	5781:  uint8(24),
	5782:  uint8(21),
	5783:  uint8(21),
	5784:  uint8(21),
	5785:  uint8(21),
	5786:  uint8(21),
	5787:  uint8(144),
	5788:  uint8(21),
	5789:  uint8(21),
	5790:  uint8(145),
	5791:  uint8(21),
	5792:  uint8(146),
	5793:  uint8(146),
	5794:  uint8(146),
	5795:  uint8(146),
	5796:  uint8(146),
	5797:  uint8(146),
	5798:  uint8(146),
	5799:  uint8(146),
	5800:  uint8(147),
	5801:  uint8(147),
	5802:  uint8(147),
	5803:  uint8(147),
	5804:  uint8(147),
	5805:  uint8(147),
	5806:  uint8(147),
	5807:  uint8(147),
	5808:  uint8(146),
	5809:  uint8(146),
	5810:  uint8(146),
	5811:  uint8(146),
	5812:  uint8(146),
	5813:  uint8(146),
	5816:  uint8(147),
	5817:  uint8(147),
	5818:  uint8(147),
	5819:  uint8(147),
	5820:  uint8(147),
	5821:  uint8(147),
	5824:  uint8(146),
	5825:  uint8(146),
	5826:  uint8(146),
	5827:  uint8(146),
	5828:  uint8(146),
	5829:  uint8(146),
	5830:  uint8(146),
	5831:  uint8(146),
	5832:  uint8(147),
	5833:  uint8(147),
	5834:  uint8(147),
	5835:  uint8(147),
	5836:  uint8(147),
	5837:  uint8(147),
	5838:  uint8(147),
	5839:  uint8(147),
	5840:  uint8(146),
	5841:  uint8(146),
	5842:  uint8(146),
	5843:  uint8(146),
	5844:  uint8(146),
	5845:  uint8(146),
	5846:  uint8(146),
	5847:  uint8(146),
	5848:  uint8(147),
	5849:  uint8(147),
	5850:  uint8(147),
	5851:  uint8(147),
	5852:  uint8(147),
	5853:  uint8(147),
	5854:  uint8(147),
	5855:  uint8(147),
	5856:  uint8(146),
	5857:  uint8(146),
	5858:  uint8(146),
	5859:  uint8(146),
	5860:  uint8(146),
	5861:  uint8(146),
	5864:  uint8(147),
	5865:  uint8(147),
	5866:  uint8(147),
	5867:  uint8(147),
	5868:  uint8(147),
	5869:  uint8(147),
	5872:  uint8(21),
	5873:  uint8(146),
	5874:  uint8(21),
	5875:  uint8(146),
	5876:  uint8(21),
	5877:  uint8(146),
	5878:  uint8(21),
	5879:  uint8(146),
	5881:  uint8(147),
	5883:  uint8(147),
	5885:  uint8(147),
	5887:  uint8(147),
	5888:  uint8(146),
	5889:  uint8(146),
	5890:  uint8(146),
	5891:  uint8(146),
	5892:  uint8(146),
	5893:  uint8(146),
	5894:  uint8(146),
	5895:  uint8(146),
	5896:  uint8(147),
	5897:  uint8(147),
	5898:  uint8(147),
	5899:  uint8(147),
	5900:  uint8(147),
	5901:  uint8(147),
	5902:  uint8(147),
	5903:  uint8(147),
	5904:  uint8(148),
	5905:  uint8(148),
	5906:  uint8(149),
	5907:  uint8(149),
	5908:  uint8(149),
	5909:  uint8(149),
	5910:  uint8(150),
	5911:  uint8(150),
	5912:  uint8(151),
	5913:  uint8(151),
	5914:  uint8(152),
	5915:  uint8(152),
	5916:  uint8(153),
	5917:  uint8(153),
	5920:  uint8(146),
	5921:  uint8(146),
	5922:  uint8(146),
	5923:  uint8(146),
	5924:  uint8(146),
	5925:  uint8(146),
	5926:  uint8(146),
	5927:  uint8(146),
	5928:  uint8(154),
	5929:  uint8(154),
	5930:  uint8(154),
	5931:  uint8(154),
	5932:  uint8(154),
	5933:  uint8(154),
	5934:  uint8(154),
	5935:  uint8(154),
	5936:  uint8(146),
	5937:  uint8(146),
	5938:  uint8(146),
	5939:  uint8(146),
	5940:  uint8(146),
	5941:  uint8(146),
	5942:  uint8(146),
	5943:  uint8(146),
	5944:  uint8(154),
	5945:  uint8(154),
	5946:  uint8(154),
	5947:  uint8(154),
	5948:  uint8(154),
	5949:  uint8(154),
	5950:  uint8(154),
	5951:  uint8(154),
	5952:  uint8(146),
	5953:  uint8(146),
	5954:  uint8(146),
	5955:  uint8(146),
	5956:  uint8(146),
	5957:  uint8(146),
	5958:  uint8(146),
	5959:  uint8(146),
	5960:  uint8(154),
	5961:  uint8(154),
	5962:  uint8(154),
	5963:  uint8(154),
	5964:  uint8(154),
	5965:  uint8(154),
	5966:  uint8(154),
	5967:  uint8(154),
	5968:  uint8(146),
	5969:  uint8(146),
	5970:  uint8(21),
	5971:  uint8(155),
	5972:  uint8(21),
	5974:  uint8(21),
	5975:  uint8(21),
	5976:  uint8(147),
	5977:  uint8(147),
	5978:  uint8(156),
	5979:  uint8(156),
	5980:  uint8(157),
	5981:  uint8(11),
	5982:  uint8(158),
	5983:  uint8(11),
	5984:  uint8(11),
	5985:  uint8(11),
	5986:  uint8(21),
	5987:  uint8(155),
	5988:  uint8(21),
	5990:  uint8(21),
	5991:  uint8(21),
	5992:  uint8(159),
	5993:  uint8(159),
	5994:  uint8(159),
	5995:  uint8(159),
	5996:  uint8(157),
	5997:  uint8(11),
	5998:  uint8(11),
	5999:  uint8(11),
	6000:  uint8(146),
	6001:  uint8(146),
	6002:  uint8(21),
	6003:  uint8(21),
	6006:  uint8(21),
	6007:  uint8(21),
	6008:  uint8(147),
	6009:  uint8(147),
	6010:  uint8(160),
	6011:  uint8(160),
	6013:  uint8(11),
	6014:  uint8(11),
	6015:  uint8(11),
	6016:  uint8(146),
	6017:  uint8(146),
	6018:  uint8(21),
	6019:  uint8(21),
	6020:  uint8(21),
	6021:  uint8(116),
	6022:  uint8(21),
	6023:  uint8(21),
	6024:  uint8(147),
	6025:  uint8(147),
	6026:  uint8(161),
	6027:  uint8(161),
	6028:  uint8(120),
	6029:  uint8(11),
	6030:  uint8(11),
	6031:  uint8(11),
	6034:  uint8(21),
	6035:  uint8(155),
	6036:  uint8(21),
	6038:  uint8(21),
	6039:  uint8(21),
	6040:  uint8(162),
	6041:  uint8(162),
	6042:  uint8(163),
	6043:  uint8(163),
	6044:  uint8(157),
	6045:  uint8(11),
	6046:  uint8(11),
	6048:  uint8(2),
	6049:  uint8(2),
	6050:  uint8(2),
	6051:  uint8(2),
	6052:  uint8(2),
	6053:  uint8(2),
	6054:  uint8(2),
	6055:  uint8(2),
	6056:  uint8(2),
	6057:  uint8(2),
	6058:  uint8(2),
	6059:  uint8(17),
	6060:  uint8(17),
	6061:  uint8(17),
	6062:  uint8(17),
	6063:  uint8(17),
	6064:  uint8(8),
	6065:  uint8(8),
	6066:  uint8(8),
	6067:  uint8(8),
	6068:  uint8(8),
	6069:  uint8(8),
	6070:  uint8(3),
	6071:  uint8(3),
	6072:  uint8(16),
	6073:  uint8(20),
	6074:  uint8(5),
	6075:  uint8(16),
	6076:  uint8(16),
	6077:  uint8(20),
	6078:  uint8(5),
	6079:  uint8(16),
	6080:  uint8(3),
	6081:  uint8(3),
	6082:  uint8(3),
	6083:  uint8(3),
	6084:  uint8(3),
	6085:  uint8(3),
	6086:  uint8(3),
	6087:  uint8(3),
	6088:  uint8(164),
	6089:  uint8(165),
	6090:  uint8(17),
	6091:  uint8(17),
	6092:  uint8(17),
	6093:  uint8(17),
	6094:  uint8(17),
	6095:  uint8(2),
	6096:  uint8(3),
	6097:  uint8(3),
	6098:  uint8(3),
	6099:  uint8(3),
	6100:  uint8(3),
	6101:  uint8(3),
	6102:  uint8(3),
	6103:  uint8(3),
	6104:  uint8(3),
	6105:  uint8(16),
	6106:  uint8(20),
	6107:  uint8(3),
	6108:  uint8(3),
	6109:  uint8(3),
	6110:  uint8(3),
	6111:  uint8(12),
	6112:  uint8(12),
	6113:  uint8(3),
	6114:  uint8(3),
	6115:  uint8(3),
	6116:  uint8(7),
	6117:  uint8(5),
	6118:  uint8(6),
	6119:  uint8(3),
	6120:  uint8(3),
	6121:  uint8(3),
	6122:  uint8(3),
	6123:  uint8(3),
	6124:  uint8(3),
	6125:  uint8(3),
	6126:  uint8(3),
	6127:  uint8(3),
	6128:  uint8(3),
	6129:  uint8(3),
	6130:  uint8(7),
	6131:  uint8(3),
	6132:  uint8(12),
	6133:  uint8(3),
	6134:  uint8(3),
	6135:  uint8(3),
	6136:  uint8(3),
	6137:  uint8(3),
	6138:  uint8(3),
	6139:  uint8(3),
	6140:  uint8(3),
	6141:  uint8(3),
	6142:  uint8(3),
	6143:  uint8(2),
	6144:  uint8(17),
	6145:  uint8(17),
	6146:  uint8(17),
	6147:  uint8(17),
	6148:  uint8(17),
	6150:  uint8(17),
	6151:  uint8(17),
	6152:  uint8(17),
	6153:  uint8(17),
	6154:  uint8(17),
	6155:  uint8(17),
	6156:  uint8(17),
	6157:  uint8(17),
	6158:  uint8(17),
	6159:  uint8(17),
	6160:  uint8(18),
	6161:  uint8(94),
	6164:  uint8(18),
	6165:  uint8(18),
	6166:  uint8(18),
	6167:  uint8(18),
	6168:  uint8(18),
	6169:  uint8(18),
	6170:  uint8(7),
	6171:  uint8(7),
	6172:  uint8(7),
	6173:  uint8(5),
	6174:  uint8(6),
	6175:  uint8(94),
	6176:  uint8(18),
	6177:  uint8(18),
	6178:  uint8(18),
	6179:  uint8(18),
	6180:  uint8(18),
	6181:  uint8(18),
	6182:  uint8(18),
	6183:  uint8(18),
	6184:  uint8(18),
	6185:  uint8(18),
	6186:  uint8(7),
	6187:  uint8(7),
	6188:  uint8(7),
	6189:  uint8(5),
	6190:  uint8(6),
	6192:  uint8(94),
	6193:  uint8(94),
	6194:  uint8(94),
	6195:  uint8(94),
	6196:  uint8(94),
	6197:  uint8(94),
	6198:  uint8(94),
	6199:  uint8(94),
	6200:  uint8(94),
	6201:  uint8(94),
	6202:  uint8(94),
	6203:  uint8(94),
	6204:  uint8(94),
	6208:  uint8(4),
	6209:  uint8(4),
	6210:  uint8(4),
	6211:  uint8(4),
	6212:  uint8(4),
	6213:  uint8(4),
	6214:  uint8(4),
	6215:  uint8(4),
	6216:  uint8(4),
	6217:  uint8(4),
	6218:  uint8(4),
	6219:  uint8(4),
	6220:  uint8(4),
	6221:  uint8(4),
	6222:  uint8(4),
	6223:  uint8(4),
	6224:  uint8(4),
	6225:  uint8(4),
	6226:  uint8(4),
	6227:  uint8(4),
	6228:  uint8(4),
	6229:  uint8(4),
	6230:  uint8(4),
	6231:  uint8(4),
	6232:  uint8(4),
	6233:  uint8(4),
	6234:  uint8(4),
	6235:  uint8(4),
	6236:  uint8(4),
	6237:  uint8(4),
	6238:  uint8(4),
	6239:  uint8(4),
	6240:  uint8(4),
	6256:  uint8(95),
	6257:  uint8(95),
	6258:  uint8(95),
	6259:  uint8(95),
	6260:  uint8(95),
	6261:  uint8(95),
	6262:  uint8(95),
	6263:  uint8(95),
	6264:  uint8(95),
	6265:  uint8(95),
	6266:  uint8(95),
	6267:  uint8(95),
	6268:  uint8(95),
	6269:  uint8(122),
	6270:  uint8(122),
	6271:  uint8(122),
	6272:  uint8(122),
	6273:  uint8(95),
	6274:  uint8(122),
	6275:  uint8(122),
	6276:  uint8(122),
	6277:  uint8(95),
	6278:  uint8(95),
	6279:  uint8(95),
	6280:  uint8(95),
	6281:  uint8(95),
	6282:  uint8(95),
	6283:  uint8(95),
	6284:  uint8(95),
	6285:  uint8(95),
	6286:  uint8(95),
	6287:  uint8(95),
	6288:  uint8(95),
	6304:  uint8(14),
	6305:  uint8(14),
	6306:  uint8(110),
	6307:  uint8(14),
	6308:  uint8(14),
	6309:  uint8(14),
	6310:  uint8(14),
	6311:  uint8(110),
	6312:  uint8(14),
	6313:  uint8(14),
	6314:  uint8(21),
	6315:  uint8(110),
	6316:  uint8(110),
	6317:  uint8(110),
	6318:  uint8(21),
	6319:  uint8(21),
	6320:  uint8(110),
	6321:  uint8(110),
	6322:  uint8(110),
	6323:  uint8(21),
	6324:  uint8(14),
	6325:  uint8(110),
	6326:  uint8(14),
	6327:  uint8(14),
	6328:  uint8(7),
	6329:  uint8(110),
	6330:  uint8(110),
	6331:  uint8(110),
	6332:  uint8(110),
	6333:  uint8(110),
	6334:  uint8(14),
	6335:  uint8(14),
	6336:  uint8(14),
	6337:  uint8(14),
	6338:  uint8(14),
	6339:  uint8(14),
	6340:  uint8(110),
	6341:  uint8(14),
	6342:  uint8(166),
	6343:  uint8(14),
	6344:  uint8(110),
	6345:  uint8(14),
	6346:  uint8(167),
	6347:  uint8(168),
	6348:  uint8(110),
	6349:  uint8(110),
	6350:  uint8(14),
	6351:  uint8(21),
	6352:  uint8(110),
	6353:  uint8(110),
	6354:  uint8(169),
	6355:  uint8(110),
	6356:  uint8(21),
	6357:  uint8(15),
	6358:  uint8(15),
	6359:  uint8(15),
	6360:  uint8(15),
	6361:  uint8(21),
	6362:  uint8(14),
	6363:  uint8(14),
	6364:  uint8(21),
	6365:  uint8(21),
	6366:  uint8(110),
	6367:  uint8(110),
	6368:  uint8(7),
	6369:  uint8(7),
	6370:  uint8(7),
	6371:  uint8(7),
	6372:  uint8(7),
	6373:  uint8(110),
	6374:  uint8(21),
	6375:  uint8(21),
	6376:  uint8(21),
	6377:  uint8(21),
	6378:  uint8(14),
	6379:  uint8(7),
	6380:  uint8(14),
	6381:  uint8(14),
	6382:  uint8(170),
	6383:  uint8(14),
	6384:  uint8(18),
	6385:  uint8(18),
	6386:  uint8(18),
	6387:  uint8(18),
	6388:  uint8(18),
	6389:  uint8(18),
	6390:  uint8(18),
	6391:  uint8(18),
	6392:  uint8(18),
	6393:  uint8(18),
	6394:  uint8(18),
	6395:  uint8(18),
	6396:  uint8(18),
	6397:  uint8(18),
	6398:  uint8(18),
	6399:  uint8(18),
	6400:  uint8(171),
	6401:  uint8(171),
	6402:  uint8(171),
	6403:  uint8(171),
	6404:  uint8(171),
	6405:  uint8(171),
	6406:  uint8(171),
	6407:  uint8(171),
	6408:  uint8(171),
	6409:  uint8(171),
	6410:  uint8(171),
	6411:  uint8(171),
	6412:  uint8(171),
	6413:  uint8(171),
	6414:  uint8(171),
	6415:  uint8(171),
	6416:  uint8(172),
	6417:  uint8(172),
	6418:  uint8(172),
	6419:  uint8(172),
	6420:  uint8(172),
	6421:  uint8(172),
	6422:  uint8(172),
	6423:  uint8(172),
	6424:  uint8(172),
	6425:  uint8(172),
	6426:  uint8(172),
	6427:  uint8(172),
	6428:  uint8(172),
	6429:  uint8(172),
	6430:  uint8(172),
	6431:  uint8(172),
	6432:  uint8(131),
	6433:  uint8(131),
	6434:  uint8(131),
	6435:  uint8(23),
	6436:  uint8(24),
	6437:  uint8(131),
	6438:  uint8(131),
	6439:  uint8(131),
	6440:  uint8(131),
	6441:  uint8(18),
	6442:  uint8(14),
	6443:  uint8(14),
	6448:  uint8(7),
	6449:  uint8(7),
	6450:  uint8(7),
	6451:  uint8(7),
	6452:  uint8(7),
	6453:  uint8(14),
	6454:  uint8(14),
	6455:  uint8(14),
	6456:  uint8(14),
	6457:  uint8(14),
	6458:  uint8(7),
	6459:  uint8(7),
	6460:  uint8(14),
	6461:  uint8(14),
	6462:  uint8(14),
	6463:  uint8(14),
	6464:  uint8(7),
	6465:  uint8(14),
	6466:  uint8(14),
	6467:  uint8(7),
	6468:  uint8(14),
	6469:  uint8(14),
	6470:  uint8(7),
	6471:  uint8(14),
	6472:  uint8(14),
	6473:  uint8(14),
	6474:  uint8(14),
	6475:  uint8(14),
	6476:  uint8(14),
	6477:  uint8(14),
	6478:  uint8(7),
	6479:  uint8(14),
	6480:  uint8(14),
	6481:  uint8(14),
	6482:  uint8(14),
	6483:  uint8(14),
	6484:  uint8(14),
	6485:  uint8(14),
	6486:  uint8(14),
	6487:  uint8(14),
	6488:  uint8(14),
	6489:  uint8(14),
	6490:  uint8(14),
	6491:  uint8(14),
	6492:  uint8(14),
	6493:  uint8(14),
	6494:  uint8(14),
	6495:  uint8(14),
	6496:  uint8(14),
	6497:  uint8(14),
	6498:  uint8(14),
	6499:  uint8(14),
	6500:  uint8(14),
	6501:  uint8(14),
	6502:  uint8(14),
	6503:  uint8(14),
	6504:  uint8(14),
	6505:  uint8(14),
	6506:  uint8(14),
	6507:  uint8(14),
	6508:  uint8(14),
	6509:  uint8(14),
	6510:  uint8(7),
	6511:  uint8(7),
	6512:  uint8(14),
	6513:  uint8(14),
	6514:  uint8(7),
	6515:  uint8(14),
	6516:  uint8(7),
	6517:  uint8(14),
	6518:  uint8(14),
	6519:  uint8(14),
	6520:  uint8(14),
	6521:  uint8(14),
	6522:  uint8(14),
	6523:  uint8(14),
	6524:  uint8(14),
	6525:  uint8(14),
	6526:  uint8(14),
	6527:  uint8(14),
	6528:  uint8(14),
	6529:  uint8(14),
	6530:  uint8(14),
	6531:  uint8(14),
	6532:  uint8(14),
	6533:  uint8(14),
	6534:  uint8(14),
	6535:  uint8(14),
	6536:  uint8(14),
	6537:  uint8(14),
	6538:  uint8(14),
	6539:  uint8(14),
	6540:  uint8(14),
	6541:  uint8(14),
	6542:  uint8(14),
	6543:  uint8(14),
	6544:  uint8(14),
	6545:  uint8(14),
	6546:  uint8(14),
	6547:  uint8(14),
	6548:  uint8(7),
	6549:  uint8(7),
	6550:  uint8(7),
	6551:  uint8(7),
	6552:  uint8(7),
	6553:  uint8(7),
	6554:  uint8(7),
	6555:  uint8(7),
	6556:  uint8(7),
	6557:  uint8(7),
	6558:  uint8(7),
	6559:  uint8(7),
	6560:  uint8(7),
	6561:  uint8(7),
	6562:  uint8(7),
	6563:  uint8(7),
	6564:  uint8(7),
	6565:  uint8(7),
	6566:  uint8(7),
	6567:  uint8(7),
	6568:  uint8(7),
	6569:  uint8(7),
	6570:  uint8(7),
	6571:  uint8(7),
	6572:  uint8(7),
	6573:  uint8(7),
	6574:  uint8(7),
	6575:  uint8(7),
	6576:  uint8(7),
	6577:  uint8(7),
	6578:  uint8(7),
	6579:  uint8(7),
	6580:  uint8(7),
	6581:  uint8(7),
	6582:  uint8(7),
	6583:  uint8(7),
	6584:  uint8(7),
	6585:  uint8(7),
	6586:  uint8(7),
	6587:  uint8(7),
	6588:  uint8(7),
	6589:  uint8(7),
	6590:  uint8(7),
	6591:  uint8(7),
	6592:  uint8(14),
	6593:  uint8(14),
	6594:  uint8(14),
	6595:  uint8(14),
	6596:  uint8(14),
	6597:  uint8(14),
	6598:  uint8(14),
	6599:  uint8(14),
	6600:  uint8(5),
	6601:  uint8(6),
	6602:  uint8(5),
	6603:  uint8(6),
	6604:  uint8(14),
	6605:  uint8(14),
	6606:  uint8(14),
	6607:  uint8(14),
	6608:  uint8(14),
	6609:  uint8(14),
	6610:  uint8(14),
	6611:  uint8(14),
	6612:  uint8(14),
	6613:  uint8(14),
	6614:  uint8(14),
	6615:  uint8(14),
	6616:  uint8(14),
	6617:  uint8(14),
	6618:  uint8(14),
	6619:  uint8(14),
	6620:  uint8(14),
	6621:  uint8(14),
	6622:  uint8(14),
	6623:  uint8(14),
	6624:  uint8(7),
	6625:  uint8(7),
	6626:  uint8(14),
	6627:  uint8(14),
	6628:  uint8(14),
	6629:  uint8(14),
	6630:  uint8(14),
	6631:  uint8(14),
	6632:  uint8(14),
	6633:  uint8(5),
	6634:  uint8(6),
	6635:  uint8(14),
	6636:  uint8(14),
	6637:  uint8(14),
	6638:  uint8(14),
	6639:  uint8(14),
	6640:  uint8(14),
	6641:  uint8(14),
	6642:  uint8(14),
	6643:  uint8(14),
	6644:  uint8(14),
	6645:  uint8(14),
	6646:  uint8(14),
	6647:  uint8(14),
	6648:  uint8(14),
	6649:  uint8(14),
	6650:  uint8(14),
	6651:  uint8(14),
	6652:  uint8(14),
	6653:  uint8(14),
	6654:  uint8(14),
	6655:  uint8(14),
	6656:  uint8(14),
	6657:  uint8(14),
	6658:  uint8(14),
	6659:  uint8(14),
	6660:  uint8(14),
	6661:  uint8(14),
	6662:  uint8(14),
	6663:  uint8(14),
	6664:  uint8(14),
	6665:  uint8(14),
	6666:  uint8(14),
	6667:  uint8(14),
	6668:  uint8(14),
	6669:  uint8(14),
	6670:  uint8(14),
	6671:  uint8(14),
	6672:  uint8(14),
	6673:  uint8(14),
	6674:  uint8(14),
	6675:  uint8(14),
	6676:  uint8(14),
	6677:  uint8(14),
	6678:  uint8(14),
	6679:  uint8(14),
	6680:  uint8(14),
	6681:  uint8(14),
	6682:  uint8(14),
	6683:  uint8(14),
	6684:  uint8(7),
	6685:  uint8(14),
	6686:  uint8(14),
	6687:  uint8(14),
	6688:  uint8(14),
	6689:  uint8(14),
	6690:  uint8(14),
	6691:  uint8(14),
	6692:  uint8(14),
	6693:  uint8(14),
	6694:  uint8(14),
	6695:  uint8(14),
	6696:  uint8(14),
	6697:  uint8(14),
	6698:  uint8(14),
	6699:  uint8(14),
	6700:  uint8(14),
	6701:  uint8(14),
	6702:  uint8(14),
	6703:  uint8(14),
	6704:  uint8(14),
	6705:  uint8(14),
	6706:  uint8(14),
	6707:  uint8(14),
	6708:  uint8(14),
	6709:  uint8(14),
	6710:  uint8(14),
	6711:  uint8(14),
	6712:  uint8(14),
	6713:  uint8(14),
	6714:  uint8(14),
	6715:  uint8(7),
	6716:  uint8(7),
	6717:  uint8(7),
	6718:  uint8(7),
	6719:  uint8(7),
	6720:  uint8(7),
	6721:  uint8(7),
	6722:  uint8(7),
	6723:  uint8(7),
	6724:  uint8(7),
	6725:  uint8(7),
	6726:  uint8(7),
	6727:  uint8(7),
	6728:  uint8(7),
	6729:  uint8(7),
	6730:  uint8(7),
	6731:  uint8(7),
	6732:  uint8(7),
	6733:  uint8(7),
	6734:  uint8(7),
	6735:  uint8(7),
	6736:  uint8(7),
	6737:  uint8(7),
	6738:  uint8(7),
	6739:  uint8(7),
	6740:  uint8(14),
	6741:  uint8(14),
	6742:  uint8(14),
	6743:  uint8(14),
	6744:  uint8(14),
	6745:  uint8(14),
	6746:  uint8(14),
	6747:  uint8(14),
	6748:  uint8(14),
	6749:  uint8(14),
	6750:  uint8(14),
	6751:  uint8(14),
	6752:  uint8(14),
	6753:  uint8(14),
	6754:  uint8(14),
	6755:  uint8(14),
	6756:  uint8(14),
	6757:  uint8(14),
	6758:  uint8(14),
	6759:  uint8(14),
	6760:  uint8(14),
	6761:  uint8(14),
	6762:  uint8(14),
	6763:  uint8(14),
	6764:  uint8(14),
	6765:  uint8(14),
	6766:  uint8(14),
	6767:  uint8(14),
	6768:  uint8(14),
	6769:  uint8(14),
	6770:  uint8(14),
	6771:  uint8(14),
	6772:  uint8(14),
	6773:  uint8(14),
	6774:  uint8(14),
	6775:  uint8(14),
	6776:  uint8(14),
	6777:  uint8(14),
	6778:  uint8(14),
	6779:  uint8(14),
	6780:  uint8(7),
	6781:  uint8(7),
	6782:  uint8(7),
	6783:  uint8(7),
	6784:  uint8(7),
	6785:  uint8(7),
	6786:  uint8(14),
	6787:  uint8(14),
	6788:  uint8(14),
	6789:  uint8(14),
	6790:  uint8(14),
	6791:  uint8(14),
	6792:  uint8(14),
	6793:  uint8(14),
	6794:  uint8(14),
	6795:  uint8(14),
	6796:  uint8(14),
	6797:  uint8(14),
	6798:  uint8(14),
	6799:  uint8(14),
	6800:  uint8(14),
	6801:  uint8(14),
	6802:  uint8(14),
	6803:  uint8(14),
	6804:  uint8(14),
	6805:  uint8(14),
	6806:  uint8(14),
	6807:  uint8(14),
	6808:  uint8(14),
	6809:  uint8(14),
	6810:  uint8(14),
	6811:  uint8(14),
	6812:  uint8(14),
	6813:  uint8(14),
	6814:  uint8(14),
	6815:  uint8(14),
	6816:  uint8(14),
	6817:  uint8(14),
	6818:  uint8(14),
	6819:  uint8(14),
	6820:  uint8(14),
	6821:  uint8(14),
	6822:  uint8(14),
	6823:  uint8(14),
	6824:  uint8(14),
	6825:  uint8(14),
	6848:  uint8(14),
	6849:  uint8(14),
	6850:  uint8(14),
	6851:  uint8(14),
	6852:  uint8(14),
	6853:  uint8(14),
	6854:  uint8(14),
	6855:  uint8(14),
	6856:  uint8(14),
	6857:  uint8(14),
	6858:  uint8(14),
	6880:  uint8(18),
	6881:  uint8(18),
	6882:  uint8(18),
	6883:  uint8(18),
	6884:  uint8(18),
	6885:  uint8(18),
	6886:  uint8(18),
	6887:  uint8(18),
	6888:  uint8(18),
	6889:  uint8(18),
	6890:  uint8(18),
	6891:  uint8(18),
	6892:  uint8(18),
	6893:  uint8(18),
	6894:  uint8(18),
	6895:  uint8(18),
	6896:  uint8(18),
	6897:  uint8(18),
	6898:  uint8(18),
	6899:  uint8(18),
	6900:  uint8(18),
	6901:  uint8(18),
	6902:  uint8(18),
	6903:  uint8(18),
	6904:  uint8(18),
	6905:  uint8(18),
	6906:  uint8(18),
	6907:  uint8(18),
	6908:  uint8(18),
	6909:  uint8(18),
	6910:  uint8(18),
	6911:  uint8(18),
	6912:  uint8(18),
	6913:  uint8(18),
	6914:  uint8(18),
	6915:  uint8(18),
	6916:  uint8(18),
	6917:  uint8(18),
	6918:  uint8(18),
	6919:  uint8(18),
	6920:  uint8(18),
	6921:  uint8(18),
	6922:  uint8(18),
	6923:  uint8(18),
	6924:  uint8(18),
	6925:  uint8(18),
	6926:  uint8(18),
	6927:  uint8(18),
	6928:  uint8(18),
	6929:  uint8(18),
	6930:  uint8(18),
	6931:  uint8(18),
	6932:  uint8(18),
	6933:  uint8(18),
	6934:  uint8(18),
	6935:  uint8(18),
	6936:  uint8(18),
	6937:  uint8(18),
	6938:  uint8(18),
	6939:  uint8(18),
	6940:  uint8(14),
	6941:  uint8(14),
	6942:  uint8(14),
	6943:  uint8(14),
	6944:  uint8(14),
	6945:  uint8(14),
	6946:  uint8(14),
	6947:  uint8(14),
	6948:  uint8(14),
	6949:  uint8(14),
	6950:  uint8(14),
	6951:  uint8(14),
	6952:  uint8(14),
	6953:  uint8(14),
	6954:  uint8(14),
	6955:  uint8(14),
	6956:  uint8(14),
	6957:  uint8(14),
	6958:  uint8(14),
	6959:  uint8(14),
	6960:  uint8(14),
	6961:  uint8(14),
	6962:  uint8(14),
	6963:  uint8(14),
	6964:  uint8(14),
	6965:  uint8(14),
	6966:  uint8(173),
	6967:  uint8(173),
	6968:  uint8(173),
	6969:  uint8(173),
	6970:  uint8(173),
	6971:  uint8(173),
	6972:  uint8(173),
	6973:  uint8(173),
	6974:  uint8(173),
	6975:  uint8(173),
	6976:  uint8(173),
	6977:  uint8(173),
	6978:  uint8(173),
	6979:  uint8(173),
	6980:  uint8(173),
	6981:  uint8(173),
	6982:  uint8(173),
	6983:  uint8(173),
	6984:  uint8(173),
	6985:  uint8(173),
	6986:  uint8(173),
	6987:  uint8(173),
	6988:  uint8(173),
	6989:  uint8(173),
	6990:  uint8(173),
	6991:  uint8(173),
	6992:  uint8(174),
	6993:  uint8(174),
	6994:  uint8(174),
	6995:  uint8(174),
	6996:  uint8(174),
	6997:  uint8(174),
	6998:  uint8(174),
	6999:  uint8(174),
	7000:  uint8(174),
	7001:  uint8(174),
	7002:  uint8(174),
	7003:  uint8(174),
	7004:  uint8(174),
	7005:  uint8(174),
	7006:  uint8(174),
	7007:  uint8(174),
	7008:  uint8(174),
	7009:  uint8(174),
	7010:  uint8(174),
	7011:  uint8(174),
	7012:  uint8(174),
	7013:  uint8(174),
	7014:  uint8(174),
	7015:  uint8(174),
	7016:  uint8(174),
	7017:  uint8(174),
	7018:  uint8(18),
	7019:  uint8(18),
	7020:  uint8(18),
	7021:  uint8(18),
	7022:  uint8(18),
	7023:  uint8(18),
	7024:  uint8(18),
	7025:  uint8(18),
	7026:  uint8(18),
	7027:  uint8(18),
	7028:  uint8(18),
	7029:  uint8(18),
	7030:  uint8(18),
	7031:  uint8(18),
	7032:  uint8(18),
	7033:  uint8(18),
	7034:  uint8(18),
	7035:  uint8(18),
	7036:  uint8(18),
	7037:  uint8(18),
	7038:  uint8(18),
	7039:  uint8(18),
	7040:  uint8(14),
	7041:  uint8(14),
	7042:  uint8(14),
	7043:  uint8(14),
	7044:  uint8(14),
	7045:  uint8(14),
	7046:  uint8(14),
	7047:  uint8(14),
	7048:  uint8(14),
	7049:  uint8(14),
	7050:  uint8(14),
	7051:  uint8(14),
	7052:  uint8(14),
	7053:  uint8(14),
	7054:  uint8(14),
	7055:  uint8(14),
	7056:  uint8(14),
	7057:  uint8(14),
	7058:  uint8(14),
	7059:  uint8(14),
	7060:  uint8(14),
	7061:  uint8(14),
	7062:  uint8(14),
	7063:  uint8(7),
	7064:  uint8(14),
	7065:  uint8(14),
	7066:  uint8(14),
	7067:  uint8(14),
	7068:  uint8(14),
	7069:  uint8(14),
	7070:  uint8(14),
	7071:  uint8(14),
	7072:  uint8(14),
	7073:  uint8(7),
	7074:  uint8(14),
	7075:  uint8(14),
	7076:  uint8(14),
	7077:  uint8(14),
	7078:  uint8(14),
	7079:  uint8(14),
	7080:  uint8(14),
	7081:  uint8(14),
	7082:  uint8(14),
	7083:  uint8(14),
	7084:  uint8(14),
	7085:  uint8(14),
	7086:  uint8(14),
	7087:  uint8(14),
	7088:  uint8(14),
	7089:  uint8(14),
	7090:  uint8(14),
	7091:  uint8(14),
	7092:  uint8(14),
	7093:  uint8(14),
	7094:  uint8(14),
	7095:  uint8(14),
	7096:  uint8(14),
	7097:  uint8(14),
	7098:  uint8(14),
	7099:  uint8(14),
	7100:  uint8(14),
	7101:  uint8(14),
	7102:  uint8(14),
	7103:  uint8(14),
	7104:  uint8(14),
	7105:  uint8(14),
	7106:  uint8(14),
	7107:  uint8(14),
	7108:  uint8(14),
	7109:  uint8(14),
	7110:  uint8(14),
	7111:  uint8(14),
	7112:  uint8(14),
	7113:  uint8(14),
	7114:  uint8(14),
	7115:  uint8(14),
	7116:  uint8(14),
	7117:  uint8(14),
	7118:  uint8(14),
	7119:  uint8(14),
	7120:  uint8(14),
	7121:  uint8(14),
	7122:  uint8(14),
	7123:  uint8(14),
	7124:  uint8(14),
	7125:  uint8(14),
	7126:  uint8(14),
	7127:  uint8(14),
	7128:  uint8(7),
	7129:  uint8(7),
	7130:  uint8(7),
	7131:  uint8(7),
	7132:  uint8(7),
	7133:  uint8(7),
	7134:  uint8(7),
	7135:  uint8(7),
	7136:  uint8(14),
	7137:  uint8(14),
	7138:  uint8(14),
	7139:  uint8(14),
	7140:  uint8(14),
	7141:  uint8(14),
	7142:  uint8(14),
	7143:  uint8(14),
	7144:  uint8(14),
	7145:  uint8(14),
	7146:  uint8(14),
	7147:  uint8(14),
	7148:  uint8(14),
	7149:  uint8(14),
	7150:  uint8(14),
	7151:  uint8(7),
	7152:  uint8(14),
	7153:  uint8(14),
	7154:  uint8(14),
	7155:  uint8(14),
	7156:  uint8(14),
	7157:  uint8(14),
	7158:  uint8(14),
	7159:  uint8(14),
	7160:  uint8(14),
	7161:  uint8(14),
	7162:  uint8(14),
	7163:  uint8(14),
	7164:  uint8(14),
	7165:  uint8(14),
	7166:  uint8(14),
	7167:  uint8(14),
	7168:  uint8(14),
	7169:  uint8(14),
	7170:  uint8(14),
	7171:  uint8(14),
	7172:  uint8(14),
	7173:  uint8(14),
	7174:  uint8(14),
	7175:  uint8(14),
	7176:  uint8(5),
	7177:  uint8(6),
	7178:  uint8(5),
	7179:  uint8(6),
	7180:  uint8(5),
	7181:  uint8(6),
	7182:  uint8(5),
	7183:  uint8(6),
	7184:  uint8(5),
	7185:  uint8(6),
	7186:  uint8(5),
	7187:  uint8(6),
	7188:  uint8(5),
	7189:  uint8(6),
	7190:  uint8(18),
	7191:  uint8(18),
	7192:  uint8(18),
	7193:  uint8(18),
	7194:  uint8(18),
	7195:  uint8(18),
	7196:  uint8(18),
	7197:  uint8(18),
	7198:  uint8(18),
	7199:  uint8(18),
	7200:  uint8(18),
	7201:  uint8(18),
	7202:  uint8(18),
	7203:  uint8(18),
	7204:  uint8(18),
	7205:  uint8(18),
	7206:  uint8(18),
	7207:  uint8(18),
	7208:  uint8(18),
	7209:  uint8(18),
	7210:  uint8(18),
	7211:  uint8(18),
	7212:  uint8(18),
	7213:  uint8(18),
	7214:  uint8(18),
	7215:  uint8(18),
	7216:  uint8(18),
	7217:  uint8(18),
	7218:  uint8(18),
	7219:  uint8(18),
	7220:  uint8(14),
	7221:  uint8(14),
	7222:  uint8(14),
	7223:  uint8(14),
	7224:  uint8(14),
	7225:  uint8(14),
	7226:  uint8(14),
	7227:  uint8(14),
	7228:  uint8(14),
	7229:  uint8(14),
	7230:  uint8(14),
	7231:  uint8(14),
	7232:  uint8(7),
	7233:  uint8(7),
	7234:  uint8(7),
	7235:  uint8(7),
	7236:  uint8(7),
	7237:  uint8(5),
	7238:  uint8(6),
	7239:  uint8(7),
	7240:  uint8(7),
	7241:  uint8(7),
	7242:  uint8(7),
	7243:  uint8(7),
	7244:  uint8(7),
	7245:  uint8(7),
	7246:  uint8(7),
	7247:  uint8(7),
	7248:  uint8(7),
	7249:  uint8(7),
	7250:  uint8(7),
	7251:  uint8(7),
	7252:  uint8(7),
	7253:  uint8(7),
	7254:  uint8(7),
	7255:  uint8(7),
	7256:  uint8(7),
	7257:  uint8(7),
	7258:  uint8(7),
	7259:  uint8(7),
	7260:  uint8(7),
	7261:  uint8(7),
	7262:  uint8(7),
	7263:  uint8(7),
	7264:  uint8(7),
	7265:  uint8(7),
	7266:  uint8(7),
	7267:  uint8(7),
	7268:  uint8(7),
	7269:  uint8(7),
	7270:  uint8(5),
	7271:  uint8(6),
	7272:  uint8(5),
	7273:  uint8(6),
	7274:  uint8(5),
	7275:  uint8(6),
	7276:  uint8(5),
	7277:  uint8(6),
	7278:  uint8(5),
	7279:  uint8(6),
	7280:  uint8(7),
	7281:  uint8(7),
	7282:  uint8(7),
	7283:  uint8(7),
	7284:  uint8(7),
	7285:  uint8(7),
	7286:  uint8(7),
	7287:  uint8(7),
	7288:  uint8(7),
	7289:  uint8(7),
	7290:  uint8(7),
	7291:  uint8(7),
	7292:  uint8(7),
	7293:  uint8(7),
	7294:  uint8(7),
	7295:  uint8(7),
	7296:  uint8(7),
	7297:  uint8(7),
	7298:  uint8(7),
	7299:  uint8(5),
	7300:  uint8(6),
	7301:  uint8(5),
	7302:  uint8(6),
	7303:  uint8(5),
	7304:  uint8(6),
	7305:  uint8(5),
	7306:  uint8(6),
	7307:  uint8(5),
	7308:  uint8(6),
	7309:  uint8(5),
	7310:  uint8(6),
	7311:  uint8(5),
	7312:  uint8(6),
	7313:  uint8(5),
	7314:  uint8(6),
	7315:  uint8(5),
	7316:  uint8(6),
	7317:  uint8(5),
	7318:  uint8(6),
	7319:  uint8(5),
	7320:  uint8(6),
	7321:  uint8(7),
	7322:  uint8(7),
	7323:  uint8(7),
	7324:  uint8(7),
	7325:  uint8(7),
	7326:  uint8(7),
	7327:  uint8(7),
	7328:  uint8(7),
	7329:  uint8(7),
	7330:  uint8(7),
	7331:  uint8(7),
	7332:  uint8(7),
	7333:  uint8(7),
	7334:  uint8(7),
	7335:  uint8(7),
	7336:  uint8(7),
	7337:  uint8(7),
	7338:  uint8(7),
	7339:  uint8(7),
	7340:  uint8(7),
	7341:  uint8(7),
	7342:  uint8(7),
	7343:  uint8(7),
	7344:  uint8(7),
	7345:  uint8(7),
	7346:  uint8(7),
	7347:  uint8(7),
	7348:  uint8(7),
	7349:  uint8(7),
	7350:  uint8(7),
	7351:  uint8(7),
	7352:  uint8(5),
	7353:  uint8(6),
	7354:  uint8(5),
	7355:  uint8(6),
	7356:  uint8(7),
	7357:  uint8(7),
	7358:  uint8(7),
	7359:  uint8(7),
	7360:  uint8(7),
	7361:  uint8(7),
	7362:  uint8(7),
	7363:  uint8(7),
	7364:  uint8(7),
	7365:  uint8(7),
	7366:  uint8(7),
	7367:  uint8(7),
	7368:  uint8(7),
	7369:  uint8(7),
	7370:  uint8(7),
	7371:  uint8(7),
	7372:  uint8(7),
	7373:  uint8(7),
	7374:  uint8(7),
	7375:  uint8(7),
	7376:  uint8(7),
	7377:  uint8(7),
	7378:  uint8(7),
	7379:  uint8(7),
	7380:  uint8(7),
	7381:  uint8(7),
	7382:  uint8(7),
	7383:  uint8(7),
	7384:  uint8(7),
	7385:  uint8(7),
	7386:  uint8(7),
	7387:  uint8(7),
	7388:  uint8(5),
	7389:  uint8(6),
	7390:  uint8(7),
	7391:  uint8(7),
	7392:  uint8(14),
	7393:  uint8(14),
	7394:  uint8(14),
	7395:  uint8(14),
	7396:  uint8(14),
	7397:  uint8(14),
	7398:  uint8(14),
	7399:  uint8(14),
	7400:  uint8(14),
	7401:  uint8(14),
	7402:  uint8(14),
	7403:  uint8(14),
	7404:  uint8(14),
	7405:  uint8(14),
	7406:  uint8(14),
	7407:  uint8(14),
	7408:  uint8(7),
	7409:  uint8(7),
	7410:  uint8(7),
	7411:  uint8(7),
	7412:  uint8(7),
	7413:  uint8(7),
	7414:  uint8(7),
	7415:  uint8(7),
	7416:  uint8(7),
	7417:  uint8(7),
	7418:  uint8(7),
	7419:  uint8(7),
	7420:  uint8(7),
	7421:  uint8(7),
	7422:  uint8(7),
	7423:  uint8(7),
	7424:  uint8(7),
	7425:  uint8(7),
	7426:  uint8(7),
	7427:  uint8(7),
	7428:  uint8(7),
	7429:  uint8(14),
	7430:  uint8(14),
	7431:  uint8(7),
	7432:  uint8(7),
	7433:  uint8(7),
	7434:  uint8(7),
	7435:  uint8(7),
	7436:  uint8(7),
	7437:  uint8(14),
	7438:  uint8(14),
	7439:  uint8(14),
	7440:  uint8(14),
	7441:  uint8(14),
	7442:  uint8(14),
	7443:  uint8(14),
	7444:  uint8(14),
	7445:  uint8(14),
	7446:  uint8(14),
	7447:  uint8(14),
	7448:  uint8(14),
	7449:  uint8(14),
	7450:  uint8(14),
	7451:  uint8(14),
	7452:  uint8(14),
	7453:  uint8(14),
	7454:  uint8(14),
	7455:  uint8(14),
	7456:  uint8(14),
	7457:  uint8(14),
	7458:  uint8(14),
	7459:  uint8(14),
	7460:  uint8(14),
	7461:  uint8(14),
	7462:  uint8(14),
	7463:  uint8(14),
	7464:  uint8(14),
	7465:  uint8(14),
	7466:  uint8(14),
	7467:  uint8(14),
	7468:  uint8(14),
	7469:  uint8(14),
	7470:  uint8(14),
	7471:  uint8(14),
	7472:  uint8(14),
	7473:  uint8(14),
	7474:  uint8(14),
	7475:  uint8(14),
	7478:  uint8(14),
	7479:  uint8(14),
	7480:  uint8(14),
	7481:  uint8(14),
	7482:  uint8(14),
	7483:  uint8(14),
	7484:  uint8(14),
	7485:  uint8(14),
	7486:  uint8(14),
	7487:  uint8(14),
	7488:  uint8(14),
	7489:  uint8(14),
	7490:  uint8(14),
	7491:  uint8(14),
	7492:  uint8(14),
	7493:  uint8(14),
	7494:  uint8(14),
	7495:  uint8(14),
	7496:  uint8(14),
	7497:  uint8(14),
	7498:  uint8(14),
	7499:  uint8(14),
	7500:  uint8(14),
	7501:  uint8(14),
	7502:  uint8(14),
	7503:  uint8(14),
	7504:  uint8(14),
	7505:  uint8(14),
	7506:  uint8(14),
	7507:  uint8(14),
	7508:  uint8(14),
	7509:  uint8(14),
	7511:  uint8(14),
	7512:  uint8(14),
	7513:  uint8(14),
	7514:  uint8(14),
	7515:  uint8(14),
	7516:  uint8(14),
	7517:  uint8(14),
	7518:  uint8(14),
	7519:  uint8(14),
	7520:  uint8(125),
	7521:  uint8(125),
	7522:  uint8(125),
	7523:  uint8(125),
	7524:  uint8(125),
	7525:  uint8(125),
	7526:  uint8(125),
	7527:  uint8(125),
	7528:  uint8(125),
	7529:  uint8(125),
	7530:  uint8(125),
	7531:  uint8(125),
	7532:  uint8(125),
	7533:  uint8(125),
	7534:  uint8(125),
	7535:  uint8(125),
	7536:  uint8(125),
	7537:  uint8(125),
	7538:  uint8(125),
	7539:  uint8(125),
	7540:  uint8(125),
	7541:  uint8(125),
	7542:  uint8(125),
	7543:  uint8(125),
	7544:  uint8(125),
	7545:  uint8(125),
	7546:  uint8(125),
	7547:  uint8(125),
	7548:  uint8(125),
	7549:  uint8(125),
	7550:  uint8(125),
	7551:  uint8(125),
	7552:  uint8(125),
	7553:  uint8(125),
	7554:  uint8(125),
	7555:  uint8(125),
	7556:  uint8(125),
	7557:  uint8(125),
	7558:  uint8(125),
	7559:  uint8(125),
	7560:  uint8(125),
	7561:  uint8(125),
	7562:  uint8(125),
	7563:  uint8(125),
	7564:  uint8(125),
	7565:  uint8(125),
	7566:  uint8(125),
	7567:  uint8(125),
	7568:  uint8(126),
	7569:  uint8(126),
	7570:  uint8(126),
	7571:  uint8(126),
	7572:  uint8(126),
	7573:  uint8(126),
	7574:  uint8(126),
	7575:  uint8(126),
	7576:  uint8(126),
	7577:  uint8(126),
	7578:  uint8(126),
	7579:  uint8(126),
	7580:  uint8(126),
	7581:  uint8(126),
	7582:  uint8(126),
	7583:  uint8(126),
	7584:  uint8(126),
	7585:  uint8(126),
	7586:  uint8(126),
	7587:  uint8(126),
	7588:  uint8(126),
	7589:  uint8(126),
	7590:  uint8(126),
	7591:  uint8(126),
	7592:  uint8(126),
	7593:  uint8(126),
	7594:  uint8(126),
	7595:  uint8(126),
	7596:  uint8(126),
	7597:  uint8(126),
	7598:  uint8(126),
	7599:  uint8(126),
	7600:  uint8(126),
	7601:  uint8(126),
	7602:  uint8(126),
	7603:  uint8(126),
	7604:  uint8(126),
	7605:  uint8(126),
	7606:  uint8(126),
	7607:  uint8(126),
	7608:  uint8(126),
	7609:  uint8(126),
	7610:  uint8(126),
	7611:  uint8(126),
	7612:  uint8(126),
	7613:  uint8(126),
	7614:  uint8(126),
	7615:  uint8(126),
	7616:  uint8(23),
	7617:  uint8(24),
	7618:  uint8(175),
	7619:  uint8(176),
	7620:  uint8(177),
	7621:  uint8(178),
	7622:  uint8(179),
	7623:  uint8(23),
	7624:  uint8(24),
	7625:  uint8(23),
	7626:  uint8(24),
	7627:  uint8(23),
	7628:  uint8(24),
	7629:  uint8(180),
	7630:  uint8(181),
	7631:  uint8(182),
	7632:  uint8(183),
	7633:  uint8(21),
	7634:  uint8(23),
	7635:  uint8(24),
	7636:  uint8(21),
	7637:  uint8(23),
	7638:  uint8(24),
	7639:  uint8(21),
	7640:  uint8(21),
	7641:  uint8(21),
	7642:  uint8(21),
	7643:  uint8(21),
	7644:  uint8(94),
	7645:  uint8(94),
	7646:  uint8(184),
	7647:  uint8(184),
	7648:  uint8(23),
	7649:  uint8(24),
	7650:  uint8(23),
	7651:  uint8(24),
	7652:  uint8(21),
	7653:  uint8(14),
	7654:  uint8(14),
	7655:  uint8(14),
	7656:  uint8(14),
	7657:  uint8(14),
	7658:  uint8(14),
	7659:  uint8(23),
	7660:  uint8(24),
	7661:  uint8(23),
	7662:  uint8(24),
	7663:  uint8(95),
	7664:  uint8(95),
	7665:  uint8(95),
	7666:  uint8(23),
	7667:  uint8(24),
	7673:  uint8(3),
	7674:  uint8(3),
	7675:  uint8(3),
	7676:  uint8(3),
	7677:  uint8(18),
	7678:  uint8(3),
	7679:  uint8(3),
	7680:  uint8(185),
	7681:  uint8(185),
	7682:  uint8(185),
	7683:  uint8(185),
	7684:  uint8(185),
	7685:  uint8(185),
	7686:  uint8(185),
	7687:  uint8(185),
	7688:  uint8(185),
	7689:  uint8(185),
	7690:  uint8(185),
	7691:  uint8(185),
	7692:  uint8(185),
	7693:  uint8(185),
	7694:  uint8(185),
	7695:  uint8(185),
	7696:  uint8(185),
	7697:  uint8(185),
	7698:  uint8(185),
	7699:  uint8(185),
	7700:  uint8(185),
	7701:  uint8(185),
	7702:  uint8(185),
	7703:  uint8(185),
	7704:  uint8(185),
	7705:  uint8(185),
	7706:  uint8(185),
	7707:  uint8(185),
	7708:  uint8(185),
	7709:  uint8(185),
	7710:  uint8(185),
	7711:  uint8(185),
	7712:  uint8(185),
	7713:  uint8(185),
	7714:  uint8(185),
	7715:  uint8(185),
	7716:  uint8(185),
	7717:  uint8(185),
	7719:  uint8(185),
	7725:  uint8(185),
	7728:  uint8(15),
	7729:  uint8(15),
	7730:  uint8(15),
	7731:  uint8(15),
	7732:  uint8(15),
	7733:  uint8(15),
	7734:  uint8(15),
	7735:  uint8(15),
	7736:  uint8(15),
	7737:  uint8(15),
	7738:  uint8(15),
	7739:  uint8(15),
	7740:  uint8(15),
	7741:  uint8(15),
	7742:  uint8(15),
	7743:  uint8(15),
	7744:  uint8(15),
	7745:  uint8(15),
	7746:  uint8(15),
	7747:  uint8(15),
	7748:  uint8(15),
	7749:  uint8(15),
	7750:  uint8(15),
	7751:  uint8(15),
	7759:  uint8(94),
	7760:  uint8(3),
	7775:  uint8(95),
	7776:  uint8(15),
	7777:  uint8(15),
	7778:  uint8(15),
	7779:  uint8(15),
	7780:  uint8(15),
	7781:  uint8(15),
	7782:  uint8(15),
	7783:  uint8(15),
	7784:  uint8(15),
	7785:  uint8(15),
	7786:  uint8(15),
	7787:  uint8(15),
	7788:  uint8(15),
	7789:  uint8(15),
	7790:  uint8(15),
	7791:  uint8(15),
	7792:  uint8(15),
	7793:  uint8(15),
	7794:  uint8(15),
	7795:  uint8(15),
	7796:  uint8(15),
	7797:  uint8(15),
	7798:  uint8(15),
	7808:  uint8(15),
	7809:  uint8(15),
	7810:  uint8(15),
	7811:  uint8(15),
	7812:  uint8(15),
	7813:  uint8(15),
	7814:  uint8(15),
	7816:  uint8(15),
	7817:  uint8(15),
	7818:  uint8(15),
	7819:  uint8(15),
	7820:  uint8(15),
	7821:  uint8(15),
	7822:  uint8(15),
	7824:  uint8(15),
	7825:  uint8(15),
	7826:  uint8(15),
	7827:  uint8(15),
	7828:  uint8(15),
	7829:  uint8(15),
	7830:  uint8(15),
	7832:  uint8(15),
	7833:  uint8(15),
	7834:  uint8(15),
	7835:  uint8(15),
	7836:  uint8(15),
	7837:  uint8(15),
	7838:  uint8(15),
	7840:  uint8(3),
	7841:  uint8(3),
	7842:  uint8(16),
	7843:  uint8(20),
	7844:  uint8(16),
	7845:  uint8(20),
	7846:  uint8(3),
	7847:  uint8(3),
	7848:  uint8(3),
	7849:  uint8(16),
	7850:  uint8(20),
	7851:  uint8(3),
	7852:  uint8(16),
	7853:  uint8(20),
	7854:  uint8(3),
	7855:  uint8(3),
	7856:  uint8(3),
	7857:  uint8(3),
	7858:  uint8(3),
	7859:  uint8(3),
	7860:  uint8(3),
	7861:  uint8(3),
	7862:  uint8(3),
	7863:  uint8(8),
	7864:  uint8(3),
	7865:  uint8(3),
	7866:  uint8(8),
	7867:  uint8(3),
	7868:  uint8(16),
	7869:  uint8(20),
	7870:  uint8(3),
	7871:  uint8(3),
	7872:  uint8(16),
	7873:  uint8(20),
	7874:  uint8(5),
	7875:  uint8(6),
	7876:  uint8(5),
	7877:  uint8(6),
	7878:  uint8(5),
	7879:  uint8(6),
	7880:  uint8(5),
	7881:  uint8(6),
	7882:  uint8(3),
	7883:  uint8(3),
	7884:  uint8(3),
	7885:  uint8(3),
	7886:  uint8(3),
	7887:  uint8(94),
	7888:  uint8(3),
	7889:  uint8(3),
	7890:  uint8(3),
	7891:  uint8(3),
	7892:  uint8(3),
	7893:  uint8(3),
	7894:  uint8(3),
	7895:  uint8(3),
	7896:  uint8(3),
	7897:  uint8(3),
	7898:  uint8(8),
	7899:  uint8(8),
	7900:  uint8(3),
	7901:  uint8(3),
	7902:  uint8(3),
	7903:  uint8(3),
	7904:  uint8(8),
	7905:  uint8(3),
	7906:  uint8(5),
	7907:  uint8(3),
	7908:  uint8(3),
	7909:  uint8(3),
	7910:  uint8(3),
	7911:  uint8(3),
	7912:  uint8(3),
	7913:  uint8(3),
	7914:  uint8(3),
	7915:  uint8(3),
	7916:  uint8(3),
	7917:  uint8(3),
	7918:  uint8(3),
	7919:  uint8(3),
	7920:  uint8(14),
	7921:  uint8(14),
	7922:  uint8(3),
	7923:  uint8(3),
	7924:  uint8(3),
	7925:  uint8(5),
	7926:  uint8(6),
	7927:  uint8(5),
	7928:  uint8(6),
	7929:  uint8(5),
	7930:  uint8(6),
	7931:  uint8(5),
	7932:  uint8(6),
	7933:  uint8(8),
	7936:  uint8(14),
	7937:  uint8(14),
	7938:  uint8(14),
	7939:  uint8(14),
	7940:  uint8(14),
	7941:  uint8(14),
	7942:  uint8(14),
	7943:  uint8(14),
	7944:  uint8(14),
	7945:  uint8(14),
	7946:  uint8(14),
	7947:  uint8(14),
	7948:  uint8(14),
	7949:  uint8(14),
	7950:  uint8(14),
	7951:  uint8(14),
	7952:  uint8(14),
	7953:  uint8(14),
	7954:  uint8(14),
	7955:  uint8(14),
	7956:  uint8(14),
	7957:  uint8(14),
	7958:  uint8(14),
	7959:  uint8(14),
	7960:  uint8(14),
	7961:  uint8(14),
	7963:  uint8(14),
	7964:  uint8(14),
	7965:  uint8(14),
	7966:  uint8(14),
	7967:  uint8(14),
	7968:  uint8(14),
	7969:  uint8(14),
	7970:  uint8(14),
	7971:  uint8(14),
	7972:  uint8(14),
	7973:  uint8(14),
	7974:  uint8(14),
	7975:  uint8(14),
	7976:  uint8(14),
	7977:  uint8(14),
	7978:  uint8(14),
	7979:  uint8(14),
	7980:  uint8(14),
	7981:  uint8(14),
	7982:  uint8(14),
	7983:  uint8(14),
	7984:  uint8(14),
	7985:  uint8(14),
	7986:  uint8(14),
	7987:  uint8(14),
	8000:  uint8(14),
	8001:  uint8(14),
	8002:  uint8(14),
	8003:  uint8(14),
	8004:  uint8(14),
	8005:  uint8(14),
	8006:  uint8(14),
	8007:  uint8(14),
	8008:  uint8(14),
	8009:  uint8(14),
	8010:  uint8(14),
	8011:  uint8(14),
	8012:  uint8(14),
	8013:  uint8(14),
	8014:  uint8(14),
	8015:  uint8(14),
	8016:  uint8(14),
	8017:  uint8(14),
	8018:  uint8(14),
	8019:  uint8(14),
	8020:  uint8(14),
	8021:  uint8(14),
	8048:  uint8(14),
	8049:  uint8(14),
	8050:  uint8(14),
	8051:  uint8(14),
	8052:  uint8(14),
	8053:  uint8(14),
	8054:  uint8(14),
	8055:  uint8(14),
	8056:  uint8(14),
	8057:  uint8(14),
	8058:  uint8(14),
	8059:  uint8(14),
	8060:  uint8(14),
	8061:  uint8(14),
	8062:  uint8(14),
	8063:  uint8(14),
	8064:  uint8(2),
	8065:  uint8(3),
	8066:  uint8(3),
	8067:  uint8(3),
	8068:  uint8(14),
	8069:  uint8(94),
	8070:  uint8(15),
	8071:  uint8(131),
	8072:  uint8(5),
	8073:  uint8(6),
	8074:  uint8(5),
	8075:  uint8(6),
	8076:  uint8(5),
	8077:  uint8(6),
	8078:  uint8(5),
	8079:  uint8(6),
	8080:  uint8(5),
	8081:  uint8(6),
	8082:  uint8(14),
	8083:  uint8(14),
	8084:  uint8(5),
	8085:  uint8(6),
	8086:  uint8(5),
	8087:  uint8(6),
	8088:  uint8(5),
	8089:  uint8(6),
	8090:  uint8(5),
	8091:  uint8(6),
	8092:  uint8(8),
	8093:  uint8(5),
	8094:  uint8(6),
	8095:  uint8(6),
	8096:  uint8(14),
	8097:  uint8(131),
	8098:  uint8(131),
	8099:  uint8(131),
	8100:  uint8(131),
	8101:  uint8(131),
	8102:  uint8(131),
	8103:  uint8(131),
	8104:  uint8(131),
	8105:  uint8(131),
	8106:  uint8(95),
	8107:  uint8(95),
	8108:  uint8(95),
	8109:  uint8(95),
	8110:  uint8(127),
	8111:  uint8(127),
	8112:  uint8(8),
	8113:  uint8(94),
	8114:  uint8(94),
	8115:  uint8(94),
	8116:  uint8(94),
	8117:  uint8(94),
	8118:  uint8(14),
	8119:  uint8(14),
	8120:  uint8(131),
	8121:  uint8(131),
	8122:  uint8(131),
	8123:  uint8(94),
	8124:  uint8(15),
	8125:  uint8(3),
	8126:  uint8(14),
	8127:  uint8(14),
	8128:  uint8(15),
	8129:  uint8(15),
	8130:  uint8(15),
	8131:  uint8(15),
	8132:  uint8(15),
	8133:  uint8(15),
	8134:  uint8(15),
	8135:  uint8(15),
	8136:  uint8(15),
	8137:  uint8(15),
	8138:  uint8(15),
	8139:  uint8(15),
	8140:  uint8(15),
	8141:  uint8(15),
	8142:  uint8(15),
	8143:  uint8(15),
	8144:  uint8(15),
	8145:  uint8(15),
	8146:  uint8(15),
	8147:  uint8(15),
	8148:  uint8(15),
	8149:  uint8(15),
	8150:  uint8(15),
	8153:  uint8(95),
	8154:  uint8(95),
	8155:  uint8(11),
	8156:  uint8(11),
	8157:  uint8(94),
	8158:  uint8(94),
	8159:  uint8(15),
	8160:  uint8(15),
	8161:  uint8(15),
	8162:  uint8(15),
	8163:  uint8(15),
	8164:  uint8(15),
	8165:  uint8(15),
	8166:  uint8(15),
	8167:  uint8(15),
	8168:  uint8(15),
	8169:  uint8(15),
	8170:  uint8(15),
	8171:  uint8(15),
	8172:  uint8(15),
	8173:  uint8(15),
	8174:  uint8(15),
	8175:  uint8(15),
	8176:  uint8(15),
	8177:  uint8(15),
	8178:  uint8(15),
	8179:  uint8(15),
	8180:  uint8(15),
	8181:  uint8(15),
	8182:  uint8(15),
	8183:  uint8(15),
	8184:  uint8(15),
	8185:  uint8(15),
	8186:  uint8(15),
	8187:  uint8(3),
	8188:  uint8(94),
	8189:  uint8(94),
	8190:  uint8(94),
	8191:  uint8(15),
	8197:  uint8(15),
	8198:  uint8(15),
	8199:  uint8(15),
	8200:  uint8(15),
	8201:  uint8(15),
	8202:  uint8(15),
	8203:  uint8(15),
	8204:  uint8(15),
	8205:  uint8(15),
	8206:  uint8(15),
	8207:  uint8(15),
	8208:  uint8(15),
	8209:  uint8(15),
	8210:  uint8(15),
	8211:  uint8(15),
	8212:  uint8(15),
	8213:  uint8(15),
	8214:  uint8(15),
	8215:  uint8(15),
	8216:  uint8(15),
	8217:  uint8(15),
	8218:  uint8(15),
	8219:  uint8(15),
	8220:  uint8(15),
	8221:  uint8(15),
	8222:  uint8(15),
	8223:  uint8(15),
	8224:  uint8(15),
	8225:  uint8(15),
	8226:  uint8(15),
	8227:  uint8(15),
	8228:  uint8(15),
	8229:  uint8(15),
	8230:  uint8(15),
	8231:  uint8(15),
	8232:  uint8(15),
	8233:  uint8(15),
	8234:  uint8(15),
	8235:  uint8(15),
	8236:  uint8(15),
	8237:  uint8(15),
	8238:  uint8(15),
	8239:  uint8(15),
	8241:  uint8(15),
	8242:  uint8(15),
	8243:  uint8(15),
	8244:  uint8(15),
	8245:  uint8(15),
	8246:  uint8(15),
	8247:  uint8(15),
	8248:  uint8(15),
	8249:  uint8(15),
	8250:  uint8(15),
	8251:  uint8(15),
	8252:  uint8(15),
	8253:  uint8(15),
	8254:  uint8(15),
	8255:  uint8(15),
	8256:  uint8(15),
	8257:  uint8(15),
	8258:  uint8(15),
	8259:  uint8(15),
	8260:  uint8(15),
	8261:  uint8(15),
	8262:  uint8(15),
	8263:  uint8(15),
	8264:  uint8(15),
	8265:  uint8(15),
	8266:  uint8(15),
	8267:  uint8(15),
	8268:  uint8(15),
	8269:  uint8(15),
	8270:  uint8(15),
	8272:  uint8(14),
	8273:  uint8(14),
	8274:  uint8(18),
	8275:  uint8(18),
	8276:  uint8(18),
	8277:  uint8(18),
	8278:  uint8(14),
	8279:  uint8(14),
	8280:  uint8(14),
	8281:  uint8(14),
	8282:  uint8(14),
	8283:  uint8(14),
	8284:  uint8(14),
	8285:  uint8(14),
	8286:  uint8(14),
	8287:  uint8(14),
	8288:  uint8(14),
	8289:  uint8(14),
	8290:  uint8(14),
	8291:  uint8(14),
	8292:  uint8(14),
	8293:  uint8(14),
	8303:  uint8(14),
	8304:  uint8(15),
	8305:  uint8(15),
	8306:  uint8(15),
	8307:  uint8(15),
	8308:  uint8(15),
	8309:  uint8(15),
	8310:  uint8(15),
	8311:  uint8(15),
	8312:  uint8(15),
	8313:  uint8(15),
	8314:  uint8(15),
	8315:  uint8(15),
	8316:  uint8(15),
	8317:  uint8(15),
	8318:  uint8(15),
	8319:  uint8(15),
	8320:  uint8(14),
	8321:  uint8(14),
	8322:  uint8(14),
	8323:  uint8(14),
	8324:  uint8(14),
	8325:  uint8(14),
	8326:  uint8(14),
	8327:  uint8(14),
	8328:  uint8(14),
	8329:  uint8(14),
	8330:  uint8(14),
	8331:  uint8(14),
	8332:  uint8(14),
	8333:  uint8(14),
	8334:  uint8(14),
	8335:  uint8(14),
	8336:  uint8(14),
	8337:  uint8(14),
	8338:  uint8(14),
	8339:  uint8(14),
	8340:  uint8(14),
	8341:  uint8(14),
	8342:  uint8(14),
	8343:  uint8(14),
	8344:  uint8(14),
	8345:  uint8(14),
	8346:  uint8(14),
	8347:  uint8(14),
	8348:  uint8(14),
	8349:  uint8(14),
	8350:  uint8(14),
	8352:  uint8(18),
	8353:  uint8(18),
	8354:  uint8(18),
	8355:  uint8(18),
	8356:  uint8(18),
	8357:  uint8(18),
	8358:  uint8(18),
	8359:  uint8(18),
	8360:  uint8(18),
	8361:  uint8(18),
	8362:  uint8(14),
	8363:  uint8(14),
	8364:  uint8(14),
	8365:  uint8(14),
	8366:  uint8(14),
	8367:  uint8(14),
	8368:  uint8(14),
	8369:  uint8(14),
	8370:  uint8(14),
	8371:  uint8(14),
	8372:  uint8(14),
	8373:  uint8(14),
	8374:  uint8(14),
	8375:  uint8(14),
	8376:  uint8(14),
	8377:  uint8(14),
	8378:  uint8(14),
	8379:  uint8(14),
	8380:  uint8(14),
	8381:  uint8(14),
	8382:  uint8(14),
	8383:  uint8(14),
	8384:  uint8(14),
	8385:  uint8(14),
	8386:  uint8(14),
	8387:  uint8(14),
	8388:  uint8(14),
	8389:  uint8(14),
	8390:  uint8(14),
	8391:  uint8(14),
	8392:  uint8(18),
	8393:  uint8(18),
	8394:  uint8(18),
	8395:  uint8(18),
	8396:  uint8(18),
	8397:  uint8(18),
	8398:  uint8(18),
	8399:  uint8(18),
	8400:  uint8(14),
	8401:  uint8(18),
	8402:  uint8(18),
	8403:  uint8(18),
	8404:  uint8(18),
	8405:  uint8(18),
	8406:  uint8(18),
	8407:  uint8(18),
	8408:  uint8(18),
	8409:  uint8(18),
	8410:  uint8(18),
	8411:  uint8(18),
	8412:  uint8(18),
	8413:  uint8(18),
	8414:  uint8(18),
	8415:  uint8(18),
	8416:  uint8(14),
	8417:  uint8(14),
	8418:  uint8(14),
	8419:  uint8(14),
	8420:  uint8(14),
	8421:  uint8(14),
	8422:  uint8(14),
	8423:  uint8(14),
	8424:  uint8(14),
	8425:  uint8(14),
	8426:  uint8(14),
	8427:  uint8(14),
	8428:  uint8(14),
	8429:  uint8(14),
	8430:  uint8(14),
	8431:  uint8(14),
	8432:  uint8(14),
	8433:  uint8(18),
	8434:  uint8(18),
	8435:  uint8(18),
	8436:  uint8(18),
	8437:  uint8(18),
	8438:  uint8(18),
	8439:  uint8(18),
	8440:  uint8(18),
	8441:  uint8(18),
	8442:  uint8(18),
	8443:  uint8(18),
	8444:  uint8(18),
	8445:  uint8(18),
	8446:  uint8(18),
	8447:  uint8(18),
	8448:  uint8(15),
	8449:  uint8(15),
	8450:  uint8(15),
	8451:  uint8(15),
	8452:  uint8(15),
	8453:  uint8(15),
	8454:  uint8(15),
	8455:  uint8(15),
	8456:  uint8(15),
	8457:  uint8(15),
	8458:  uint8(15),
	8459:  uint8(15),
	8460:  uint8(15),
	8461:  uint8(15),
	8462:  uint8(15),
	8463:  uint8(15),
	8464:  uint8(15),
	8465:  uint8(15),
	8466:  uint8(15),
	8467:  uint8(15),
	8468:  uint8(15),
	8469:  uint8(94),
	8470:  uint8(15),
	8471:  uint8(15),
	8472:  uint8(15),
	8473:  uint8(15),
	8474:  uint8(15),
	8475:  uint8(15),
	8476:  uint8(15),
	8477:  uint8(15),
	8478:  uint8(15),
	8479:  uint8(15),
	8480:  uint8(15),
	8481:  uint8(15),
	8482:  uint8(15),
	8483:  uint8(15),
	8484:  uint8(15),
	8485:  uint8(15),
	8486:  uint8(15),
	8487:  uint8(15),
	8488:  uint8(15),
	8489:  uint8(15),
	8490:  uint8(15),
	8491:  uint8(15),
	8492:  uint8(15),
	8496:  uint8(14),
	8497:  uint8(14),
	8498:  uint8(14),
	8499:  uint8(14),
	8500:  uint8(14),
	8501:  uint8(14),
	8502:  uint8(14),
	8503:  uint8(14),
	8504:  uint8(14),
	8505:  uint8(14),
	8506:  uint8(14),
	8507:  uint8(14),
	8508:  uint8(14),
	8509:  uint8(14),
	8510:  uint8(14),
	8511:  uint8(14),
	8512:  uint8(14),
	8513:  uint8(14),
	8514:  uint8(14),
	8515:  uint8(14),
	8516:  uint8(14),
	8517:  uint8(14),
	8518:  uint8(14),
	8528:  uint8(15),
	8529:  uint8(15),
	8530:  uint8(15),
	8531:  uint8(15),
	8532:  uint8(15),
	8533:  uint8(15),
	8534:  uint8(15),
	8535:  uint8(15),
	8536:  uint8(15),
	8537:  uint8(15),
	8538:  uint8(15),
	8539:  uint8(15),
	8540:  uint8(15),
	8541:  uint8(15),
	8542:  uint8(15),
	8543:  uint8(15),
	8544:  uint8(15),
	8545:  uint8(15),
	8546:  uint8(15),
	8547:  uint8(15),
	8548:  uint8(15),
	8549:  uint8(15),
	8550:  uint8(15),
	8551:  uint8(15),
	8552:  uint8(15),
	8553:  uint8(15),
	8554:  uint8(15),
	8555:  uint8(15),
	8556:  uint8(94),
	8557:  uint8(3),
	8558:  uint8(3),
	8559:  uint8(3),
	8560:  uint8(15),
	8561:  uint8(15),
	8562:  uint8(15),
	8563:  uint8(15),
	8564:  uint8(15),
	8565:  uint8(15),
	8566:  uint8(15),
	8567:  uint8(15),
	8568:  uint8(15),
	8569:  uint8(15),
	8570:  uint8(15),
	8571:  uint8(15),
	8572:  uint8(15),
	8573:  uint8(15),
	8574:  uint8(15),
	8575:  uint8(15),
	8576:  uint8(9),
	8577:  uint8(9),
	8578:  uint8(9),
	8579:  uint8(9),
	8580:  uint8(9),
	8581:  uint8(9),
	8582:  uint8(9),
	8583:  uint8(9),
	8584:  uint8(9),
	8585:  uint8(9),
	8586:  uint8(15),
	8587:  uint8(15),
	8608:  uint8(23),
	8609:  uint8(24),
	8610:  uint8(23),
	8611:  uint8(24),
	8612:  uint8(23),
	8613:  uint8(24),
	8614:  uint8(23),
	8615:  uint8(24),
	8616:  uint8(23),
	8617:  uint8(24),
	8618:  uint8(23),
	8619:  uint8(24),
	8620:  uint8(23),
	8621:  uint8(24),
	8622:  uint8(15),
	8623:  uint8(95),
	8624:  uint8(122),
	8625:  uint8(122),
	8626:  uint8(122),
	8627:  uint8(3),
	8628:  uint8(95),
	8629:  uint8(95),
	8630:  uint8(95),
	8631:  uint8(95),
	8632:  uint8(95),
	8633:  uint8(95),
	8634:  uint8(95),
	8635:  uint8(95),
	8636:  uint8(95),
	8637:  uint8(95),
	8638:  uint8(3),
	8639:  uint8(94),
	8640:  uint8(23),
	8641:  uint8(24),
	8642:  uint8(23),
	8643:  uint8(24),
	8644:  uint8(23),
	8645:  uint8(24),
	8646:  uint8(23),
	8647:  uint8(24),
	8648:  uint8(23),
	8649:  uint8(24),
	8650:  uint8(23),
	8651:  uint8(24),
	8652:  uint8(23),
	8653:  uint8(24),
	8654:  uint8(23),
	8655:  uint8(24),
	8656:  uint8(23),
	8657:  uint8(24),
	8658:  uint8(23),
	8659:  uint8(24),
	8660:  uint8(23),
	8661:  uint8(24),
	8662:  uint8(23),
	8663:  uint8(24),
	8664:  uint8(23),
	8665:  uint8(24),
	8666:  uint8(23),
	8667:  uint8(24),
	8668:  uint8(94),
	8669:  uint8(94),
	8670:  uint8(95),
	8671:  uint8(95),
	8672:  uint8(15),
	8673:  uint8(15),
	8674:  uint8(15),
	8675:  uint8(15),
	8676:  uint8(15),
	8677:  uint8(15),
	8678:  uint8(131),
	8679:  uint8(131),
	8680:  uint8(131),
	8681:  uint8(131),
	8682:  uint8(131),
	8683:  uint8(131),
	8684:  uint8(131),
	8685:  uint8(131),
	8686:  uint8(131),
	8687:  uint8(131),
	8688:  uint8(95),
	8689:  uint8(95),
	8690:  uint8(3),
	8691:  uint8(3),
	8692:  uint8(3),
	8693:  uint8(3),
	8694:  uint8(3),
	8695:  uint8(3),
	8704:  uint8(11),
	8705:  uint8(11),
	8706:  uint8(11),
	8707:  uint8(11),
	8708:  uint8(11),
	8709:  uint8(11),
	8710:  uint8(11),
	8711:  uint8(11),
	8712:  uint8(11),
	8713:  uint8(11),
	8714:  uint8(11),
	8715:  uint8(11),
	8716:  uint8(11),
	8717:  uint8(11),
	8718:  uint8(11),
	8719:  uint8(11),
	8720:  uint8(11),
	8721:  uint8(11),
	8722:  uint8(11),
	8723:  uint8(11),
	8724:  uint8(11),
	8725:  uint8(11),
	8726:  uint8(11),
	8727:  uint8(94),
	8728:  uint8(94),
	8729:  uint8(94),
	8730:  uint8(94),
	8731:  uint8(94),
	8732:  uint8(94),
	8733:  uint8(94),
	8734:  uint8(94),
	8735:  uint8(94),
	8736:  uint8(11),
	8737:  uint8(11),
	8738:  uint8(23),
	8739:  uint8(24),
	8740:  uint8(23),
	8741:  uint8(24),
	8742:  uint8(23),
	8743:  uint8(24),
	8744:  uint8(23),
	8745:  uint8(24),
	8746:  uint8(23),
	8747:  uint8(24),
	8748:  uint8(23),
	8749:  uint8(24),
	8750:  uint8(23),
	8751:  uint8(24),
	8752:  uint8(21),
	8753:  uint8(21),
	8754:  uint8(23),
	8755:  uint8(24),
	8756:  uint8(23),
	8757:  uint8(24),
	8758:  uint8(23),
	8759:  uint8(24),
	8760:  uint8(23),
	8761:  uint8(24),
	8762:  uint8(23),
	8763:  uint8(24),
	8764:  uint8(23),
	8765:  uint8(24),
	8766:  uint8(23),
	8767:  uint8(24),
	8768:  uint8(23),
	8769:  uint8(24),
	8770:  uint8(23),
	8771:  uint8(24),
	8772:  uint8(23),
	8773:  uint8(24),
	8774:  uint8(23),
	8775:  uint8(24),
	8776:  uint8(23),
	8777:  uint8(24),
	8778:  uint8(23),
	8779:  uint8(24),
	8780:  uint8(23),
	8781:  uint8(24),
	8782:  uint8(23),
	8783:  uint8(24),
	8784:  uint8(94),
	8785:  uint8(21),
	8786:  uint8(21),
	8787:  uint8(21),
	8788:  uint8(21),
	8789:  uint8(21),
	8790:  uint8(21),
	8791:  uint8(21),
	8792:  uint8(21),
	8793:  uint8(23),
	8794:  uint8(24),
	8795:  uint8(23),
	8796:  uint8(24),
	8797:  uint8(186),
	8798:  uint8(23),
	8799:  uint8(24),
	8800:  uint8(23),
	8801:  uint8(24),
	8802:  uint8(23),
	8803:  uint8(24),
	8804:  uint8(23),
	8805:  uint8(24),
	8806:  uint8(23),
	8807:  uint8(24),
	8808:  uint8(94),
	8809:  uint8(11),
	8810:  uint8(11),
	8811:  uint8(23),
	8812:  uint8(24),
	8813:  uint8(187),
	8814:  uint8(21),
	8815:  uint8(15),
	8816:  uint8(23),
	8817:  uint8(24),
	8818:  uint8(23),
	8819:  uint8(24),
	8820:  uint8(188),
	8821:  uint8(21),
	8822:  uint8(23),
	8823:  uint8(24),
	8824:  uint8(23),
	8825:  uint8(24),
	8826:  uint8(23),
	8827:  uint8(24),
	8828:  uint8(23),
	8829:  uint8(24),
	8830:  uint8(23),
	8831:  uint8(24),
	8832:  uint8(23),
	8833:  uint8(24),
	8834:  uint8(23),
	8835:  uint8(24),
	8836:  uint8(23),
	8837:  uint8(24),
	8838:  uint8(23),
	8839:  uint8(24),
	8840:  uint8(23),
	8841:  uint8(24),
	8842:  uint8(189),
	8843:  uint8(190),
	8844:  uint8(191),
	8845:  uint8(192),
	8846:  uint8(189),
	8847:  uint8(21),
	8848:  uint8(193),
	8849:  uint8(194),
	8850:  uint8(195),
	8851:  uint8(196),
	8852:  uint8(23),
	8853:  uint8(24),
	8854:  uint8(23),
	8855:  uint8(24),
	8856:  uint8(23),
	8857:  uint8(24),
	8858:  uint8(23),
	8859:  uint8(24),
	8860:  uint8(23),
	8861:  uint8(24),
	8862:  uint8(23),
	8863:  uint8(24),
	8864:  uint8(23),
	8865:  uint8(24),
	8866:  uint8(23),
	8867:  uint8(24),
	8868:  uint8(197),
	8869:  uint8(198),
	8870:  uint8(199),
	8871:  uint8(23),
	8872:  uint8(24),
	8873:  uint8(23),
	8874:  uint8(24),
	8875:  uint8(200),
	8876:  uint8(23),
	8877:  uint8(24),
	8880:  uint8(23),
	8881:  uint8(24),
	8883:  uint8(21),
	8885:  uint8(21),
	8886:  uint8(23),
	8887:  uint8(24),
	8888:  uint8(23),
	8889:  uint8(24),
	8890:  uint8(23),
	8891:  uint8(24),
	8892:  uint8(201),
	8914:  uint8(94),
	8915:  uint8(94),
	8916:  uint8(94),
	8917:  uint8(23),
	8918:  uint8(24),
	8919:  uint8(15),
	8920:  uint8(94),
	8921:  uint8(94),
	8922:  uint8(21),
	8923:  uint8(15),
	8924:  uint8(15),
	8925:  uint8(15),
	8926:  uint8(15),
	8927:  uint8(15),
	8928:  uint8(15),
	8929:  uint8(15),
	8930:  uint8(95),
	8931:  uint8(15),
	8932:  uint8(15),
	8933:  uint8(15),
	8934:  uint8(95),
	8935:  uint8(15),
	8936:  uint8(15),
	8937:  uint8(15),
	8938:  uint8(15),
	8939:  uint8(95),
	8940:  uint8(15),
	8941:  uint8(15),
	8942:  uint8(15),
	8943:  uint8(15),
	8944:  uint8(15),
	8945:  uint8(15),
	8946:  uint8(15),
	8947:  uint8(15),
	8948:  uint8(15),
	8949:  uint8(15),
	8950:  uint8(15),
	8951:  uint8(15),
	8952:  uint8(15),
	8953:  uint8(15),
	8954:  uint8(15),
	8955:  uint8(15),
	8956:  uint8(15),
	8957:  uint8(15),
	8958:  uint8(15),
	8959:  uint8(15),
	8960:  uint8(15),
	8961:  uint8(15),
	8962:  uint8(15),
	8963:  uint8(127),
	8964:  uint8(127),
	8965:  uint8(95),
	8966:  uint8(95),
	8967:  uint8(127),
	8968:  uint8(14),
	8969:  uint8(14),
	8970:  uint8(14),
	8971:  uint8(14),
	8972:  uint8(95),
	8976:  uint8(18),
	8977:  uint8(18),
	8978:  uint8(18),
	8979:  uint8(18),
	8980:  uint8(18),
	8981:  uint8(18),
	8982:  uint8(14),
	8983:  uint8(14),
	8984:  uint8(4),
	8985:  uint8(14),
	8992:  uint8(15),
	8993:  uint8(15),
	8994:  uint8(15),
	8995:  uint8(15),
	8996:  uint8(15),
	8997:  uint8(15),
	8998:  uint8(15),
	8999:  uint8(15),
	9000:  uint8(15),
	9001:  uint8(15),
	9002:  uint8(15),
	9003:  uint8(15),
	9004:  uint8(15),
	9005:  uint8(15),
	9006:  uint8(15),
	9007:  uint8(15),
	9008:  uint8(15),
	9009:  uint8(15),
	9010:  uint8(15),
	9011:  uint8(15),
	9012:  uint8(3),
	9013:  uint8(3),
	9014:  uint8(3),
	9015:  uint8(3),
	9024:  uint8(127),
	9025:  uint8(127),
	9026:  uint8(15),
	9027:  uint8(15),
	9028:  uint8(15),
	9029:  uint8(15),
	9030:  uint8(15),
	9031:  uint8(15),
	9032:  uint8(15),
	9033:  uint8(15),
	9034:  uint8(15),
	9035:  uint8(15),
	9036:  uint8(15),
	9037:  uint8(15),
	9038:  uint8(15),
	9039:  uint8(15),
	9040:  uint8(15),
	9041:  uint8(15),
	9042:  uint8(15),
	9043:  uint8(15),
	9044:  uint8(15),
	9045:  uint8(15),
	9046:  uint8(15),
	9047:  uint8(15),
	9048:  uint8(15),
	9049:  uint8(15),
	9050:  uint8(15),
	9051:  uint8(15),
	9052:  uint8(15),
	9053:  uint8(15),
	9054:  uint8(15),
	9055:  uint8(15),
	9056:  uint8(15),
	9057:  uint8(15),
	9058:  uint8(15),
	9059:  uint8(15),
	9060:  uint8(15),
	9061:  uint8(15),
	9062:  uint8(15),
	9063:  uint8(15),
	9064:  uint8(15),
	9065:  uint8(15),
	9066:  uint8(15),
	9067:  uint8(15),
	9068:  uint8(15),
	9069:  uint8(15),
	9070:  uint8(15),
	9071:  uint8(15),
	9072:  uint8(15),
	9073:  uint8(15),
	9074:  uint8(15),
	9075:  uint8(15),
	9076:  uint8(127),
	9077:  uint8(127),
	9078:  uint8(127),
	9079:  uint8(127),
	9080:  uint8(127),
	9081:  uint8(127),
	9082:  uint8(127),
	9083:  uint8(127),
	9084:  uint8(127),
	9085:  uint8(127),
	9086:  uint8(127),
	9087:  uint8(127),
	9088:  uint8(127),
	9089:  uint8(127),
	9090:  uint8(127),
	9091:  uint8(127),
	9092:  uint8(95),
	9093:  uint8(95),
	9102:  uint8(3),
	9103:  uint8(3),
	9104:  uint8(9),
	9105:  uint8(9),
	9106:  uint8(9),
	9107:  uint8(9),
	9108:  uint8(9),
	9109:  uint8(9),
	9110:  uint8(9),
	9111:  uint8(9),
	9112:  uint8(9),
	9113:  uint8(9),
	9120:  uint8(95),
	9121:  uint8(95),
	9122:  uint8(95),
	9123:  uint8(95),
	9124:  uint8(95),
	9125:  uint8(95),
	9126:  uint8(95),
	9127:  uint8(95),
	9128:  uint8(95),
	9129:  uint8(95),
	9130:  uint8(95),
	9131:  uint8(95),
	9132:  uint8(95),
	9133:  uint8(95),
	9134:  uint8(95),
	9135:  uint8(95),
	9136:  uint8(95),
	9137:  uint8(95),
	9138:  uint8(15),
	9139:  uint8(15),
	9140:  uint8(15),
	9141:  uint8(15),
	9142:  uint8(15),
	9143:  uint8(15),
	9144:  uint8(3),
	9145:  uint8(3),
	9146:  uint8(3),
	9147:  uint8(15),
	9148:  uint8(3),
	9149:  uint8(15),
	9150:  uint8(15),
	9151:  uint8(95),
	9152:  uint8(15),
	9153:  uint8(15),
	9154:  uint8(15),
	9155:  uint8(15),
	9156:  uint8(15),
	9157:  uint8(15),
	9158:  uint8(95),
	9159:  uint8(95),
	9160:  uint8(95),
	9161:  uint8(95),
	9162:  uint8(95),
	9163:  uint8(95),
	9164:  uint8(95),
	9165:  uint8(95),
	9166:  uint8(3),
	9167:  uint8(3),
	9168:  uint8(15),
	9169:  uint8(15),
	9170:  uint8(15),
	9171:  uint8(15),
	9172:  uint8(15),
	9173:  uint8(15),
	9174:  uint8(15),
	9175:  uint8(15),
	9176:  uint8(15),
	9177:  uint8(15),
	9178:  uint8(15),
	9179:  uint8(15),
	9180:  uint8(15),
	9181:  uint8(15),
	9182:  uint8(15),
	9183:  uint8(15),
	9184:  uint8(15),
	9185:  uint8(15),
	9186:  uint8(15),
	9187:  uint8(15),
	9188:  uint8(15),
	9189:  uint8(15),
	9190:  uint8(15),
	9191:  uint8(95),
	9192:  uint8(95),
	9193:  uint8(95),
	9194:  uint8(95),
	9195:  uint8(95),
	9196:  uint8(95),
	9197:  uint8(95),
	9198:  uint8(95),
	9199:  uint8(95),
	9200:  uint8(95),
	9201:  uint8(95),
	9202:  uint8(127),
	9203:  uint8(127),
	9215:  uint8(3),
	9216:  uint8(15),
	9217:  uint8(15),
	9218:  uint8(15),
	9219:  uint8(15),
	9220:  uint8(15),
	9221:  uint8(15),
	9222:  uint8(15),
	9223:  uint8(15),
	9224:  uint8(15),
	9225:  uint8(15),
	9226:  uint8(15),
	9227:  uint8(15),
	9228:  uint8(15),
	9229:  uint8(15),
	9230:  uint8(15),
	9231:  uint8(15),
	9232:  uint8(15),
	9233:  uint8(15),
	9234:  uint8(15),
	9235:  uint8(15),
	9236:  uint8(15),
	9237:  uint8(15),
	9238:  uint8(15),
	9239:  uint8(15),
	9240:  uint8(15),
	9241:  uint8(15),
	9242:  uint8(15),
	9243:  uint8(15),
	9244:  uint8(15),
	9248:  uint8(15),
	9249:  uint8(15),
	9250:  uint8(15),
	9251:  uint8(15),
	9252:  uint8(15),
	9253:  uint8(15),
	9254:  uint8(15),
	9255:  uint8(15),
	9256:  uint8(15),
	9257:  uint8(15),
	9258:  uint8(15),
	9259:  uint8(15),
	9260:  uint8(15),
	9261:  uint8(15),
	9262:  uint8(15),
	9263:  uint8(15),
	9264:  uint8(15),
	9265:  uint8(15),
	9266:  uint8(15),
	9267:  uint8(95),
	9268:  uint8(127),
	9269:  uint8(127),
	9270:  uint8(95),
	9271:  uint8(95),
	9272:  uint8(95),
	9273:  uint8(95),
	9274:  uint8(127),
	9275:  uint8(127),
	9276:  uint8(95),
	9277:  uint8(95),
	9278:  uint8(127),
	9279:  uint8(127),
	9280:  uint8(127),
	9281:  uint8(3),
	9282:  uint8(3),
	9283:  uint8(3),
	9284:  uint8(3),
	9285:  uint8(3),
	9286:  uint8(3),
	9287:  uint8(3),
	9288:  uint8(3),
	9289:  uint8(3),
	9290:  uint8(3),
	9291:  uint8(3),
	9292:  uint8(3),
	9293:  uint8(3),
	9295:  uint8(94),
	9296:  uint8(9),
	9297:  uint8(9),
	9298:  uint8(9),
	9299:  uint8(9),
	9300:  uint8(9),
	9301:  uint8(9),
	9302:  uint8(9),
	9303:  uint8(9),
	9304:  uint8(9),
	9305:  uint8(9),
	9310:  uint8(3),
	9311:  uint8(3),
	9312:  uint8(15),
	9313:  uint8(15),
	9314:  uint8(15),
	9315:  uint8(15),
	9316:  uint8(15),
	9317:  uint8(95),
	9318:  uint8(94),
	9319:  uint8(15),
	9320:  uint8(15),
	9321:  uint8(15),
	9322:  uint8(15),
	9323:  uint8(15),
	9324:  uint8(15),
	9325:  uint8(15),
	9326:  uint8(15),
	9327:  uint8(15),
	9328:  uint8(9),
	9329:  uint8(9),
	9330:  uint8(9),
	9331:  uint8(9),
	9332:  uint8(9),
	9333:  uint8(9),
	9334:  uint8(9),
	9335:  uint8(9),
	9336:  uint8(9),
	9337:  uint8(9),
	9338:  uint8(15),
	9339:  uint8(15),
	9340:  uint8(15),
	9341:  uint8(15),
	9342:  uint8(15),
	9344:  uint8(15),
	9345:  uint8(15),
	9346:  uint8(15),
	9347:  uint8(15),
	9348:  uint8(15),
	9349:  uint8(15),
	9350:  uint8(15),
	9351:  uint8(15),
	9352:  uint8(15),
	9353:  uint8(95),
	9354:  uint8(95),
	9355:  uint8(95),
	9356:  uint8(95),
	9357:  uint8(95),
	9358:  uint8(95),
	9359:  uint8(127),
	9360:  uint8(127),
	9361:  uint8(95),
	9362:  uint8(95),
	9363:  uint8(127),
	9364:  uint8(127),
	9365:  uint8(95),
	9366:  uint8(95),
	9376:  uint8(15),
	9377:  uint8(15),
	9378:  uint8(15),
	9379:  uint8(95),
	9380:  uint8(15),
	9381:  uint8(15),
	9382:  uint8(15),
	9383:  uint8(15),
	9384:  uint8(15),
	9385:  uint8(15),
	9386:  uint8(15),
	9387:  uint8(15),
	9388:  uint8(95),
	9389:  uint8(127),
	9392:  uint8(9),
	9393:  uint8(9),
	9394:  uint8(9),
	9395:  uint8(9),
	9396:  uint8(9),
	9397:  uint8(9),
	9398:  uint8(9),
	9399:  uint8(9),
	9400:  uint8(9),
	9401:  uint8(9),
	9404:  uint8(3),
	9405:  uint8(3),
	9406:  uint8(3),
	9407:  uint8(3),
	9408:  uint8(15),
	9409:  uint8(15),
	9410:  uint8(15),
	9411:  uint8(15),
	9412:  uint8(15),
	9413:  uint8(15),
	9414:  uint8(15),
	9415:  uint8(15),
	9416:  uint8(15),
	9417:  uint8(15),
	9418:  uint8(15),
	9419:  uint8(15),
	9420:  uint8(15),
	9421:  uint8(15),
	9422:  uint8(15),
	9423:  uint8(15),
	9424:  uint8(94),
	9425:  uint8(15),
	9426:  uint8(15),
	9427:  uint8(15),
	9428:  uint8(15),
	9429:  uint8(15),
	9430:  uint8(15),
	9431:  uint8(14),
	9432:  uint8(14),
	9433:  uint8(14),
	9434:  uint8(15),
	9435:  uint8(127),
	9436:  uint8(95),
	9437:  uint8(127),
	9438:  uint8(15),
	9439:  uint8(15),
	9440:  uint8(15),
	9441:  uint8(15),
	9442:  uint8(15),
	9443:  uint8(15),
	9444:  uint8(15),
	9445:  uint8(15),
	9446:  uint8(15),
	9447:  uint8(15),
	9448:  uint8(15),
	9449:  uint8(15),
	9450:  uint8(15),
	9451:  uint8(15),
	9452:  uint8(15),
	9453:  uint8(15),
	9454:  uint8(15),
	9455:  uint8(15),
	9456:  uint8(95),
	9457:  uint8(15),
	9458:  uint8(95),
	9459:  uint8(95),
	9460:  uint8(95),
	9461:  uint8(15),
	9462:  uint8(15),
	9463:  uint8(95),
	9464:  uint8(95),
	9465:  uint8(15),
	9466:  uint8(15),
	9467:  uint8(15),
	9468:  uint8(15),
	9469:  uint8(15),
	9470:  uint8(95),
	9471:  uint8(95),
	9472:  uint8(15),
	9473:  uint8(95),
	9474:  uint8(15),
	9499:  uint8(15),
	9500:  uint8(15),
	9501:  uint8(94),
	9502:  uint8(3),
	9503:  uint8(3),
	9504:  uint8(15),
	9505:  uint8(15),
	9506:  uint8(15),
	9507:  uint8(15),
	9508:  uint8(15),
	9509:  uint8(15),
	9510:  uint8(15),
	9511:  uint8(15),
	9512:  uint8(15),
	9513:  uint8(15),
	9514:  uint8(15),
	9515:  uint8(127),
	9516:  uint8(95),
	9517:  uint8(95),
	9518:  uint8(127),
	9519:  uint8(127),
	9520:  uint8(3),
	9521:  uint8(3),
	9522:  uint8(15),
	9523:  uint8(94),
	9524:  uint8(94),
	9525:  uint8(127),
	9526:  uint8(95),
	9537:  uint8(15),
	9538:  uint8(15),
	9539:  uint8(15),
	9540:  uint8(15),
	9541:  uint8(15),
	9542:  uint8(15),
	9545:  uint8(15),
	9546:  uint8(15),
	9547:  uint8(15),
	9548:  uint8(15),
	9549:  uint8(15),
	9550:  uint8(15),
	9553:  uint8(15),
	9554:  uint8(15),
	9555:  uint8(15),
	9556:  uint8(15),
	9557:  uint8(15),
	9558:  uint8(15),
	9568:  uint8(15),
	9569:  uint8(15),
	9570:  uint8(15),
	9571:  uint8(15),
	9572:  uint8(15),
	9573:  uint8(15),
	9574:  uint8(15),
	9576:  uint8(15),
	9577:  uint8(15),
	9578:  uint8(15),
	9579:  uint8(15),
	9580:  uint8(15),
	9581:  uint8(15),
	9582:  uint8(15),
	9584:  uint8(21),
	9585:  uint8(21),
	9586:  uint8(21),
	9587:  uint8(21),
	9588:  uint8(21),
	9589:  uint8(21),
	9590:  uint8(21),
	9591:  uint8(21),
	9592:  uint8(21),
	9593:  uint8(21),
	9594:  uint8(21),
	9595:  uint8(21),
	9596:  uint8(21),
	9597:  uint8(21),
	9598:  uint8(21),
	9599:  uint8(21),
	9600:  uint8(21),
	9601:  uint8(21),
	9602:  uint8(21),
	9603:  uint8(21),
	9604:  uint8(21),
	9605:  uint8(21),
	9606:  uint8(21),
	9607:  uint8(21),
	9608:  uint8(21),
	9609:  uint8(21),
	9610:  uint8(21),
	9611:  uint8(21),
	9612:  uint8(21),
	9613:  uint8(21),
	9614:  uint8(21),
	9615:  uint8(21),
	9616:  uint8(21),
	9617:  uint8(21),
	9618:  uint8(21),
	9619:  uint8(202),
	9620:  uint8(21),
	9621:  uint8(21),
	9622:  uint8(21),
	9623:  uint8(21),
	9624:  uint8(21),
	9625:  uint8(21),
	9626:  uint8(21),
	9627:  uint8(11),
	9628:  uint8(94),
	9629:  uint8(94),
	9630:  uint8(94),
	9631:  uint8(94),
	9632:  uint8(21),
	9633:  uint8(21),
	9634:  uint8(21),
	9635:  uint8(21),
	9636:  uint8(21),
	9637:  uint8(21),
	9638:  uint8(21),
	9639:  uint8(21),
	9640:  uint8(21),
	9641:  uint8(94),
	9642:  uint8(11),
	9643:  uint8(11),
	9648:  uint8(203),
	9649:  uint8(203),
	9650:  uint8(203),
	9651:  uint8(203),
	9652:  uint8(203),
	9653:  uint8(203),
	9654:  uint8(203),
	9655:  uint8(203),
	9656:  uint8(203),
	9657:  uint8(203),
	9658:  uint8(203),
	9659:  uint8(203),
	9660:  uint8(203),
	9661:  uint8(203),
	9662:  uint8(203),
	9663:  uint8(203),
	9664:  uint8(203),
	9665:  uint8(203),
	9666:  uint8(203),
	9667:  uint8(203),
	9668:  uint8(203),
	9669:  uint8(203),
	9670:  uint8(203),
	9671:  uint8(203),
	9672:  uint8(203),
	9673:  uint8(203),
	9674:  uint8(203),
	9675:  uint8(203),
	9676:  uint8(203),
	9677:  uint8(203),
	9678:  uint8(203),
	9679:  uint8(203),
	9680:  uint8(203),
	9681:  uint8(203),
	9682:  uint8(203),
	9683:  uint8(203),
	9684:  uint8(203),
	9685:  uint8(203),
	9686:  uint8(203),
	9687:  uint8(203),
	9688:  uint8(203),
	9689:  uint8(203),
	9690:  uint8(203),
	9691:  uint8(203),
	9692:  uint8(203),
	9693:  uint8(203),
	9694:  uint8(203),
	9695:  uint8(203),
	9696:  uint8(15),
	9697:  uint8(15),
	9698:  uint8(15),
	9699:  uint8(127),
	9700:  uint8(127),
	9701:  uint8(95),
	9702:  uint8(127),
	9703:  uint8(127),
	9704:  uint8(95),
	9705:  uint8(127),
	9706:  uint8(127),
	9707:  uint8(3),
	9708:  uint8(127),
	9709:  uint8(95),
	9712:  uint8(9),
	9713:  uint8(9),
	9714:  uint8(9),
	9715:  uint8(9),
	9716:  uint8(9),
	9717:  uint8(9),
	9718:  uint8(9),
	9719:  uint8(9),
	9720:  uint8(9),
	9721:  uint8(9),
	9728:  uint8(15),
	9729:  uint8(15),
	9730:  uint8(15),
	9731:  uint8(15),
	9744:  uint8(15),
	9745:  uint8(15),
	9746:  uint8(15),
	9747:  uint8(15),
	9748:  uint8(15),
	9749:  uint8(15),
	9750:  uint8(15),
	9751:  uint8(15),
	9752:  uint8(15),
	9753:  uint8(15),
	9754:  uint8(15),
	9755:  uint8(15),
	9756:  uint8(15),
	9757:  uint8(15),
	9758:  uint8(15),
	9759:  uint8(15),
	9760:  uint8(15),
	9761:  uint8(15),
	9762:  uint8(15),
	9763:  uint8(15),
	9764:  uint8(15),
	9765:  uint8(15),
	9766:  uint8(15),
	9771:  uint8(15),
	9772:  uint8(15),
	9773:  uint8(15),
	9774:  uint8(15),
	9775:  uint8(15),
	9776:  uint8(15),
	9777:  uint8(15),
	9778:  uint8(15),
	9779:  uint8(15),
	9780:  uint8(15),
	9781:  uint8(15),
	9782:  uint8(15),
	9783:  uint8(15),
	9784:  uint8(15),
	9785:  uint8(15),
	9786:  uint8(15),
	9787:  uint8(15),
	9788:  uint8(15),
	9789:  uint8(15),
	9790:  uint8(15),
	9791:  uint8(15),
	9792:  uint8(15),
	9793:  uint8(15),
	9794:  uint8(15),
	9795:  uint8(15),
	9796:  uint8(15),
	9797:  uint8(15),
	9798:  uint8(15),
	9799:  uint8(15),
	9800:  uint8(15),
	9801:  uint8(15),
	9802:  uint8(15),
	9803:  uint8(15),
	9804:  uint8(15),
	9805:  uint8(15),
	9806:  uint8(15),
	9807:  uint8(15),
	9808:  uint8(15),
	9809:  uint8(15),
	9810:  uint8(15),
	9811:  uint8(15),
	9812:  uint8(15),
	9813:  uint8(15),
	9814:  uint8(15),
	9815:  uint8(15),
	9816:  uint8(15),
	9817:  uint8(15),
	9818:  uint8(15),
	9819:  uint8(15),
	9824:  uint8(204),
	9825:  uint8(204),
	9826:  uint8(204),
	9827:  uint8(204),
	9828:  uint8(204),
	9829:  uint8(204),
	9830:  uint8(204),
	9831:  uint8(204),
	9832:  uint8(204),
	9833:  uint8(204),
	9834:  uint8(204),
	9835:  uint8(204),
	9836:  uint8(204),
	9837:  uint8(204),
	9838:  uint8(204),
	9839:  uint8(204),
	9840:  uint8(204),
	9841:  uint8(204),
	9842:  uint8(204),
	9843:  uint8(204),
	9844:  uint8(204),
	9845:  uint8(204),
	9846:  uint8(204),
	9847:  uint8(204),
	9848:  uint8(204),
	9849:  uint8(204),
	9850:  uint8(204),
	9851:  uint8(204),
	9852:  uint8(204),
	9853:  uint8(204),
	9854:  uint8(204),
	9855:  uint8(204),
	9856:  uint8(205),
	9857:  uint8(205),
	9858:  uint8(205),
	9859:  uint8(205),
	9860:  uint8(205),
	9861:  uint8(205),
	9862:  uint8(205),
	9863:  uint8(205),
	9864:  uint8(205),
	9865:  uint8(205),
	9866:  uint8(205),
	9867:  uint8(205),
	9868:  uint8(205),
	9869:  uint8(205),
	9870:  uint8(205),
	9871:  uint8(205),
	9872:  uint8(205),
	9873:  uint8(205),
	9874:  uint8(205),
	9875:  uint8(205),
	9876:  uint8(205),
	9877:  uint8(205),
	9878:  uint8(205),
	9879:  uint8(205),
	9880:  uint8(205),
	9881:  uint8(205),
	9882:  uint8(205),
	9883:  uint8(205),
	9884:  uint8(205),
	9885:  uint8(205),
	9886:  uint8(205),
	9887:  uint8(205),
	9888:  uint8(15),
	9889:  uint8(15),
	9890:  uint8(15),
	9891:  uint8(15),
	9892:  uint8(15),
	9893:  uint8(15),
	9894:  uint8(15),
	9895:  uint8(15),
	9896:  uint8(15),
	9897:  uint8(15),
	9898:  uint8(15),
	9899:  uint8(15),
	9900:  uint8(15),
	9901:  uint8(15),
	9904:  uint8(15),
	9905:  uint8(15),
	9906:  uint8(15),
	9907:  uint8(15),
	9908:  uint8(15),
	9909:  uint8(15),
	9910:  uint8(15),
	9911:  uint8(15),
	9912:  uint8(15),
	9913:  uint8(15),
	9914:  uint8(15),
	9915:  uint8(15),
	9916:  uint8(15),
	9917:  uint8(15),
	9918:  uint8(15),
	9919:  uint8(15),
	9920:  uint8(15),
	9921:  uint8(15),
	9922:  uint8(15),
	9923:  uint8(15),
	9924:  uint8(15),
	9925:  uint8(15),
	9926:  uint8(15),
	9927:  uint8(15),
	9928:  uint8(15),
	9929:  uint8(15),
	9930:  uint8(15),
	9931:  uint8(15),
	9932:  uint8(15),
	9933:  uint8(15),
	9934:  uint8(15),
	9935:  uint8(15),
	9936:  uint8(15),
	9937:  uint8(15),
	9938:  uint8(15),
	9939:  uint8(15),
	9940:  uint8(15),
	9941:  uint8(15),
	9942:  uint8(15),
	9943:  uint8(15),
	9944:  uint8(15),
	9945:  uint8(15),
	9952:  uint8(21),
	9953:  uint8(21),
	9954:  uint8(21),
	9955:  uint8(21),
	9956:  uint8(21),
	9957:  uint8(21),
	9958:  uint8(21),
	9971:  uint8(21),
	9972:  uint8(21),
	9973:  uint8(21),
	9974:  uint8(21),
	9975:  uint8(21),
	9981:  uint8(15),
	9982:  uint8(95),
	9983:  uint8(15),
	9984:  uint8(15),
	9985:  uint8(15),
	9986:  uint8(15),
	9987:  uint8(15),
	9988:  uint8(15),
	9989:  uint8(15),
	9990:  uint8(15),
	9991:  uint8(15),
	9992:  uint8(15),
	9993:  uint8(7),
	9994:  uint8(15),
	9995:  uint8(15),
	9996:  uint8(15),
	9997:  uint8(15),
	9998:  uint8(15),
	9999:  uint8(15),
	10000: uint8(15),
	10001: uint8(15),
	10002: uint8(15),
	10003: uint8(15),
	10004: uint8(15),
	10005: uint8(15),
	10006: uint8(15),
	10008: uint8(15),
	10009: uint8(15),
	10010: uint8(15),
	10011: uint8(15),
	10012: uint8(15),
	10014: uint8(15),
	10016: uint8(15),
	10017: uint8(15),
	10019: uint8(15),
	10020: uint8(15),
	10022: uint8(15),
	10023: uint8(15),
	10024: uint8(15),
	10025: uint8(15),
	10026: uint8(15),
	10027: uint8(15),
	10028: uint8(15),
	10029: uint8(15),
	10030: uint8(15),
	10031: uint8(15),
	10032: uint8(15),
	10033: uint8(15),
	10034: uint8(15),
	10035: uint8(15),
	10036: uint8(15),
	10037: uint8(15),
	10038: uint8(15),
	10039: uint8(15),
	10040: uint8(15),
	10041: uint8(15),
	10042: uint8(15),
	10043: uint8(15),
	10044: uint8(15),
	10045: uint8(15),
	10046: uint8(15),
	10047: uint8(15),
	10048: uint8(15),
	10049: uint8(15),
	10050: uint8(15),
	10051: uint8(15),
	10052: uint8(15),
	10053: uint8(15),
	10054: uint8(15),
	10055: uint8(15),
	10056: uint8(15),
	10057: uint8(15),
	10058: uint8(15),
	10059: uint8(15),
	10060: uint8(15),
	10061: uint8(15),
	10062: uint8(15),
	10063: uint8(15),
	10064: uint8(15),
	10065: uint8(15),
	10066: uint8(11),
	10067: uint8(11),
	10068: uint8(11),
	10069: uint8(11),
	10070: uint8(11),
	10071: uint8(11),
	10072: uint8(11),
	10073: uint8(11),
	10074: uint8(11),
	10075: uint8(11),
	10076: uint8(11),
	10077: uint8(11),
	10078: uint8(11),
	10079: uint8(11),
	10080: uint8(11),
	10081: uint8(11),
	10082: uint8(11),
	10099: uint8(15),
	10100: uint8(15),
	10101: uint8(15),
	10102: uint8(15),
	10103: uint8(15),
	10104: uint8(15),
	10105: uint8(15),
	10106: uint8(15),
	10107: uint8(15),
	10108: uint8(15),
	10109: uint8(15),
	10110: uint8(15),
	10111: uint8(15),
	10112: uint8(15),
	10113: uint8(15),
	10114: uint8(15),
	10115: uint8(15),
	10116: uint8(15),
	10117: uint8(15),
	10118: uint8(15),
	10119: uint8(15),
	10120: uint8(15),
	10121: uint8(15),
	10122: uint8(15),
	10123: uint8(15),
	10124: uint8(15),
	10125: uint8(15),
	10126: uint8(15),
	10127: uint8(15),
	10128: uint8(15),
	10129: uint8(15),
	10130: uint8(15),
	10131: uint8(15),
	10132: uint8(15),
	10133: uint8(15),
	10134: uint8(15),
	10135: uint8(15),
	10136: uint8(15),
	10137: uint8(15),
	10138: uint8(15),
	10139: uint8(15),
	10140: uint8(15),
	10141: uint8(15),
	10142: uint8(6),
	10143: uint8(5),
	10144: uint8(14),
	10145: uint8(14),
	10146: uint8(14),
	10147: uint8(14),
	10148: uint8(14),
	10149: uint8(14),
	10150: uint8(14),
	10151: uint8(14),
	10152: uint8(14),
	10153: uint8(14),
	10154: uint8(14),
	10155: uint8(14),
	10156: uint8(14),
	10157: uint8(14),
	10158: uint8(14),
	10159: uint8(14),
	10160: uint8(15),
	10161: uint8(15),
	10162: uint8(15),
	10163: uint8(15),
	10164: uint8(15),
	10165: uint8(15),
	10166: uint8(15),
	10167: uint8(15),
	10168: uint8(15),
	10169: uint8(15),
	10170: uint8(15),
	10171: uint8(15),
	10172: uint8(15),
	10173: uint8(15),
	10174: uint8(15),
	10175: uint8(15),
	10176: uint8(15),
	10177: uint8(15),
	10178: uint8(15),
	10179: uint8(15),
	10180: uint8(15),
	10181: uint8(15),
	10182: uint8(15),
	10183: uint8(15),
	10184: uint8(15),
	10185: uint8(15),
	10186: uint8(15),
	10187: uint8(15),
	10188: uint8(15),
	10189: uint8(15),
	10190: uint8(15),
	10191: uint8(15),
	10194: uint8(15),
	10195: uint8(15),
	10196: uint8(15),
	10197: uint8(15),
	10198: uint8(15),
	10199: uint8(15),
	10200: uint8(15),
	10201: uint8(15),
	10202: uint8(15),
	10203: uint8(15),
	10204: uint8(15),
	10205: uint8(15),
	10206: uint8(15),
	10207: uint8(15),
	10208: uint8(15),
	10209: uint8(15),
	10210: uint8(15),
	10211: uint8(15),
	10212: uint8(15),
	10213: uint8(15),
	10214: uint8(15),
	10215: uint8(15),
	10223: uint8(14),
	10256: uint8(15),
	10257: uint8(15),
	10258: uint8(15),
	10259: uint8(15),
	10260: uint8(15),
	10261: uint8(15),
	10262: uint8(15),
	10263: uint8(15),
	10264: uint8(15),
	10265: uint8(15),
	10266: uint8(15),
	10267: uint8(15),
	10268: uint8(4),
	10269: uint8(14),
	10270: uint8(14),
	10271: uint8(14),
	10272: uint8(95),
	10273: uint8(95),
	10274: uint8(95),
	10275: uint8(95),
	10276: uint8(95),
	10277: uint8(95),
	10278: uint8(95),
	10279: uint8(95),
	10280: uint8(95),
	10281: uint8(95),
	10282: uint8(95),
	10283: uint8(95),
	10284: uint8(95),
	10285: uint8(95),
	10286: uint8(95),
	10287: uint8(95),
	10288: uint8(3),
	10289: uint8(3),
	10290: uint8(3),
	10291: uint8(3),
	10292: uint8(3),
	10293: uint8(3),
	10294: uint8(3),
	10295: uint8(5),
	10296: uint8(6),
	10297: uint8(3),
	10304: uint8(95),
	10305: uint8(95),
	10306: uint8(95),
	10307: uint8(95),
	10308: uint8(95),
	10309: uint8(95),
	10310: uint8(95),
	10311: uint8(95),
	10312: uint8(95),
	10313: uint8(95),
	10314: uint8(95),
	10315: uint8(95),
	10316: uint8(95),
	10317: uint8(95),
	10318: uint8(95),
	10319: uint8(95),
	10320: uint8(3),
	10321: uint8(8),
	10322: uint8(8),
	10323: uint8(12),
	10324: uint8(12),
	10325: uint8(5),
	10326: uint8(6),
	10327: uint8(5),
	10328: uint8(6),
	10329: uint8(5),
	10330: uint8(6),
	10331: uint8(5),
	10332: uint8(6),
	10333: uint8(5),
	10334: uint8(6),
	10335: uint8(5),
	10336: uint8(6),
	10337: uint8(5),
	10338: uint8(6),
	10339: uint8(5),
	10340: uint8(6),
	10341: uint8(3),
	10342: uint8(3),
	10343: uint8(5),
	10344: uint8(6),
	10345: uint8(3),
	10346: uint8(3),
	10347: uint8(3),
	10348: uint8(3),
	10349: uint8(12),
	10350: uint8(12),
	10351: uint8(12),
	10352: uint8(3),
	10353: uint8(3),
	10354: uint8(3),
	10356: uint8(3),
	10357: uint8(3),
	10358: uint8(3),
	10359: uint8(3),
	10360: uint8(8),
	10361: uint8(5),
	10362: uint8(6),
	10363: uint8(5),
	10364: uint8(6),
	10365: uint8(5),
	10366: uint8(6),
	10367: uint8(3),
	10368: uint8(3),
	10369: uint8(3),
	10370: uint8(7),
	10371: uint8(8),
	10372: uint8(7),
	10373: uint8(7),
	10374: uint8(7),
	10376: uint8(3),
	10377: uint8(4),
	10378: uint8(3),
	10379: uint8(3),
	10384: uint8(15),
	10385: uint8(15),
	10386: uint8(15),
	10387: uint8(15),
	10388: uint8(15),
	10390: uint8(15),
	10391: uint8(15),
	10392: uint8(15),
	10393: uint8(15),
	10394: uint8(15),
	10395: uint8(15),
	10396: uint8(15),
	10397: uint8(15),
	10398: uint8(15),
	10399: uint8(15),
	10400: uint8(15),
	10401: uint8(15),
	10402: uint8(15),
	10403: uint8(15),
	10404: uint8(15),
	10405: uint8(15),
	10406: uint8(15),
	10407: uint8(15),
	10408: uint8(15),
	10409: uint8(15),
	10410: uint8(15),
	10411: uint8(15),
	10412: uint8(15),
	10413: uint8(15),
	10414: uint8(15),
	10415: uint8(15),
	10416: uint8(15),
	10417: uint8(15),
	10418: uint8(15),
	10419: uint8(15),
	10420: uint8(15),
	10421: uint8(15),
	10422: uint8(15),
	10423: uint8(15),
	10424: uint8(15),
	10425: uint8(15),
	10426: uint8(15),
	10427: uint8(15),
	10428: uint8(15),
	10431: uint8(17),
	10433: uint8(3),
	10434: uint8(3),
	10435: uint8(3),
	10436: uint8(4),
	10437: uint8(3),
	10438: uint8(3),
	10439: uint8(3),
	10440: uint8(5),
	10441: uint8(6),
	10442: uint8(3),
	10443: uint8(7),
	10444: uint8(3),
	10445: uint8(8),
	10446: uint8(3),
	10447: uint8(3),
	10448: uint8(9),
	10449: uint8(9),
	10450: uint8(9),
	10451: uint8(9),
	10452: uint8(9),
	10453: uint8(9),
	10454: uint8(9),
	10455: uint8(9),
	10456: uint8(9),
	10457: uint8(9),
	10458: uint8(3),
	10459: uint8(3),
	10460: uint8(7),
	10461: uint8(7),
	10462: uint8(7),
	10463: uint8(3),
	10464: uint8(11),
	10465: uint8(13),
	10466: uint8(13),
	10467: uint8(13),
	10468: uint8(13),
	10469: uint8(13),
	10470: uint8(13),
	10471: uint8(13),
	10472: uint8(13),
	10473: uint8(13),
	10474: uint8(13),
	10475: uint8(13),
	10476: uint8(13),
	10477: uint8(13),
	10478: uint8(13),
	10479: uint8(13),
	10480: uint8(13),
	10481: uint8(13),
	10482: uint8(13),
	10483: uint8(13),
	10484: uint8(13),
	10485: uint8(13),
	10486: uint8(13),
	10487: uint8(13),
	10488: uint8(13),
	10489: uint8(13),
	10490: uint8(13),
	10491: uint8(5),
	10492: uint8(7),
	10493: uint8(6),
	10494: uint8(7),
	10495: uint8(5),
	10496: uint8(6),
	10497: uint8(3),
	10498: uint8(5),
	10499: uint8(6),
	10500: uint8(3),
	10501: uint8(3),
	10502: uint8(15),
	10503: uint8(15),
	10504: uint8(15),
	10505: uint8(15),
	10506: uint8(15),
	10507: uint8(15),
	10508: uint8(15),
	10509: uint8(15),
	10510: uint8(15),
	10511: uint8(15),
	10512: uint8(94),
	10513: uint8(15),
	10514: uint8(15),
	10515: uint8(15),
	10516: uint8(15),
	10517: uint8(15),
	10518: uint8(15),
	10519: uint8(15),
	10520: uint8(15),
	10521: uint8(15),
	10522: uint8(15),
	10523: uint8(15),
	10524: uint8(15),
	10525: uint8(15),
	10526: uint8(15),
	10527: uint8(15),
	10528: uint8(15),
	10529: uint8(15),
	10530: uint8(15),
	10531: uint8(15),
	10532: uint8(15),
	10533: uint8(15),
	10534: uint8(15),
	10535: uint8(15),
	10536: uint8(15),
	10537: uint8(15),
	10538: uint8(15),
	10539: uint8(15),
	10540: uint8(15),
	10541: uint8(15),
	10542: uint8(15),
	10543: uint8(15),
	10544: uint8(15),
	10545: uint8(15),
	10546: uint8(15),
	10547: uint8(15),
	10548: uint8(15),
	10549: uint8(15),
	10550: uint8(15),
	10551: uint8(15),
	10552: uint8(15),
	10553: uint8(15),
	10554: uint8(15),
	10555: uint8(15),
	10556: uint8(15),
	10557: uint8(15),
	10558: uint8(94),
	10559: uint8(94),
	10562: uint8(15),
	10563: uint8(15),
	10564: uint8(15),
	10565: uint8(15),
	10566: uint8(15),
	10567: uint8(15),
	10570: uint8(15),
	10571: uint8(15),
	10572: uint8(15),
	10573: uint8(15),
	10574: uint8(15),
	10575: uint8(15),
	10578: uint8(15),
	10579: uint8(15),
	10580: uint8(15),
	10581: uint8(15),
	10582: uint8(15),
	10583: uint8(15),
	10586: uint8(15),
	10587: uint8(15),
	10588: uint8(15),
	10592: uint8(4),
	10593: uint8(4),
	10594: uint8(7),
	10595: uint8(11),
	10596: uint8(14),
	10597: uint8(4),
	10598: uint8(4),
	10600: uint8(14),
	10601: uint8(7),
	10602: uint8(7),
	10603: uint8(7),
	10604: uint8(7),
	10605: uint8(14),
	10606: uint8(14),
	10617: uint8(17),
	10618: uint8(17),
	10619: uint8(17),
	10620: uint8(14),
	10621: uint8(14),
	10624: uint8(15),
	10625: uint8(15),
	10626: uint8(15),
	10627: uint8(15),
	10628: uint8(15),
	10629: uint8(15),
	10630: uint8(15),
	10631: uint8(15),
	10632: uint8(15),
	10633: uint8(15),
	10634: uint8(15),
	10635: uint8(15),
	10637: uint8(15),
	10638: uint8(15),
	10639: uint8(15),
	10640: uint8(15),
	10641: uint8(15),
	10642: uint8(15),
	10643: uint8(15),
	10644: uint8(15),
	10645: uint8(15),
	10646: uint8(15),
	10647: uint8(15),
	10648: uint8(15),
	10649: uint8(15),
	10650: uint8(15),
	10651: uint8(15),
	10652: uint8(15),
	10653: uint8(15),
	10654: uint8(15),
	10655: uint8(15),
	10656: uint8(15),
	10657: uint8(15),
	10658: uint8(15),
	10659: uint8(15),
	10660: uint8(15),
	10661: uint8(15),
	10662: uint8(15),
	10664: uint8(15),
	10665: uint8(15),
	10666: uint8(15),
	10667: uint8(15),
	10668: uint8(15),
	10669: uint8(15),
	10670: uint8(15),
	10671: uint8(15),
	10672: uint8(15),
	10673: uint8(15),
	10674: uint8(15),
	10675: uint8(15),
	10676: uint8(15),
	10677: uint8(15),
	10678: uint8(15),
	10679: uint8(15),
	10680: uint8(15),
	10681: uint8(15),
	10682: uint8(15),
	10684: uint8(15),
	10685: uint8(15),
	10687: uint8(15),
	10688: uint8(15),
	10689: uint8(15),
	10690: uint8(15),
	10691: uint8(15),
	10692: uint8(15),
	10693: uint8(15),
	10694: uint8(15),
	10695: uint8(15),
	10696: uint8(15),
	10697: uint8(15),
	10698: uint8(15),
	10699: uint8(15),
	10700: uint8(15),
	10701: uint8(15),
	10704: uint8(15),
	10705: uint8(15),
	10706: uint8(15),
	10707: uint8(15),
	10708: uint8(15),
	10709: uint8(15),
	10710: uint8(15),
	10711: uint8(15),
	10712: uint8(15),
	10713: uint8(15),
	10714: uint8(15),
	10715: uint8(15),
	10716: uint8(15),
	10717: uint8(15),
	10720: uint8(15),
	10721: uint8(15),
	10722: uint8(15),
	10723: uint8(15),
	10724: uint8(15),
	10725: uint8(15),
	10726: uint8(15),
	10727: uint8(15),
	10728: uint8(15),
	10729: uint8(15),
	10730: uint8(15),
	10731: uint8(15),
	10732: uint8(15),
	10733: uint8(15),
	10734: uint8(15),
	10735: uint8(15),
	10736: uint8(15),
	10737: uint8(15),
	10738: uint8(15),
	10739: uint8(15),
	10740: uint8(15),
	10741: uint8(15),
	10742: uint8(15),
	10743: uint8(15),
	10744: uint8(15),
	10745: uint8(15),
	10746: uint8(15),
	10752: uint8(3),
	10753: uint8(3),
	10754: uint8(3),
	10759: uint8(18),
	10760: uint8(18),
	10761: uint8(18),
	10762: uint8(18),
	10763: uint8(18),
	10764: uint8(18),
	10765: uint8(18),
	10766: uint8(18),
	10767: uint8(18),
	10768: uint8(18),
	10769: uint8(18),
	10770: uint8(18),
	10771: uint8(18),
	10772: uint8(18),
	10773: uint8(18),
	10774: uint8(18),
	10775: uint8(18),
	10776: uint8(18),
	10777: uint8(18),
	10778: uint8(18),
	10779: uint8(18),
	10780: uint8(18),
	10781: uint8(18),
	10782: uint8(18),
	10783: uint8(18),
	10784: uint8(18),
	10785: uint8(18),
	10786: uint8(18),
	10787: uint8(18),
	10788: uint8(18),
	10789: uint8(18),
	10790: uint8(18),
	10791: uint8(18),
	10792: uint8(18),
	10793: uint8(18),
	10794: uint8(18),
	10795: uint8(18),
	10796: uint8(18),
	10797: uint8(18),
	10798: uint8(18),
	10799: uint8(18),
	10800: uint8(18),
	10801: uint8(18),
	10802: uint8(18),
	10803: uint8(18),
	10807: uint8(14),
	10808: uint8(14),
	10809: uint8(14),
	10810: uint8(14),
	10811: uint8(14),
	10812: uint8(14),
	10813: uint8(14),
	10814: uint8(14),
	10815: uint8(14),
	10816: uint8(131),
	10817: uint8(131),
	10818: uint8(131),
	10819: uint8(131),
	10820: uint8(131),
	10821: uint8(131),
	10822: uint8(131),
	10823: uint8(131),
	10824: uint8(131),
	10825: uint8(131),
	10826: uint8(131),
	10827: uint8(131),
	10828: uint8(131),
	10829: uint8(131),
	10830: uint8(131),
	10831: uint8(131),
	10832: uint8(131),
	10833: uint8(131),
	10834: uint8(131),
	10835: uint8(131),
	10836: uint8(131),
	10837: uint8(131),
	10838: uint8(131),
	10839: uint8(131),
	10840: uint8(131),
	10841: uint8(131),
	10842: uint8(131),
	10843: uint8(131),
	10844: uint8(131),
	10845: uint8(131),
	10846: uint8(131),
	10847: uint8(131),
	10848: uint8(131),
	10849: uint8(131),
	10850: uint8(131),
	10851: uint8(131),
	10852: uint8(131),
	10853: uint8(131),
	10854: uint8(131),
	10855: uint8(131),
	10856: uint8(131),
	10857: uint8(131),
	10858: uint8(131),
	10859: uint8(131),
	10860: uint8(131),
	10861: uint8(131),
	10862: uint8(131),
	10863: uint8(131),
	10864: uint8(131),
	10865: uint8(131),
	10866: uint8(131),
	10867: uint8(131),
	10868: uint8(131),
	10869: uint8(18),
	10870: uint8(18),
	10871: uint8(18),
	10872: uint8(18),
	10873: uint8(14),
	10874: uint8(14),
	10875: uint8(14),
	10876: uint8(14),
	10877: uint8(14),
	10878: uint8(14),
	10879: uint8(14),
	10880: uint8(14),
	10881: uint8(14),
	10882: uint8(14),
	10883: uint8(14),
	10884: uint8(14),
	10885: uint8(14),
	10886: uint8(14),
	10887: uint8(14),
	10888: uint8(14),
	10889: uint8(14),
	10890: uint8(18),
	10891: uint8(18),
	10892: uint8(14),
	10893: uint8(14),
	10894: uint8(14),
	10896: uint8(14),
	10897: uint8(14),
	10898: uint8(14),
	10899: uint8(14),
	10900: uint8(14),
	10901: uint8(14),
	10902: uint8(14),
	10903: uint8(14),
	10904: uint8(14),
	10905: uint8(14),
	10906: uint8(14),
	10907: uint8(14),
	10908: uint8(14),
	10912: uint8(14),
	10944: uint8(14),
	10945: uint8(14),
	10946: uint8(14),
	10947: uint8(14),
	10948: uint8(14),
	10949: uint8(14),
	10950: uint8(14),
	10951: uint8(14),
	10952: uint8(14),
	10953: uint8(14),
	10954: uint8(14),
	10955: uint8(14),
	10956: uint8(14),
	10957: uint8(14),
	10958: uint8(14),
	10959: uint8(14),
	10960: uint8(14),
	10961: uint8(14),
	10962: uint8(14),
	10963: uint8(14),
	10964: uint8(14),
	10965: uint8(14),
	10966: uint8(14),
	10967: uint8(14),
	10968: uint8(14),
	10969: uint8(14),
	10970: uint8(14),
	10971: uint8(14),
	10972: uint8(14),
	10973: uint8(95),
	10976: uint8(15),
	10977: uint8(15),
	10978: uint8(15),
	10979: uint8(15),
	10980: uint8(15),
	10981: uint8(15),
	10982: uint8(15),
	10983: uint8(15),
	10984: uint8(15),
	10985: uint8(15),
	10986: uint8(15),
	10987: uint8(15),
	10988: uint8(15),
	10989: uint8(15),
	10990: uint8(15),
	10991: uint8(15),
	10992: uint8(15),
	11008: uint8(95),
	11009: uint8(18),
	11010: uint8(18),
	11011: uint8(18),
	11012: uint8(18),
	11013: uint8(18),
	11014: uint8(18),
	11015: uint8(18),
	11016: uint8(18),
	11017: uint8(18),
	11018: uint8(18),
	11019: uint8(18),
	11020: uint8(18),
	11021: uint8(18),
	11022: uint8(18),
	11023: uint8(18),
	11024: uint8(18),
	11025: uint8(18),
	11026: uint8(18),
	11027: uint8(18),
	11028: uint8(18),
	11029: uint8(18),
	11030: uint8(18),
	11031: uint8(18),
	11032: uint8(18),
	11033: uint8(18),
	11034: uint8(18),
	11035: uint8(18),
	11040: uint8(18),
	11041: uint8(18),
	11042: uint8(18),
	11043: uint8(18),
	11053: uint8(15),
	11054: uint8(15),
	11055: uint8(15),
	11056: uint8(15),
	11057: uint8(15),
	11058: uint8(15),
	11059: uint8(15),
	11060: uint8(15),
	11061: uint8(15),
	11062: uint8(15),
	11063: uint8(15),
	11064: uint8(15),
	11065: uint8(15),
	11066: uint8(15),
	11067: uint8(15),
	11068: uint8(15),
	11069: uint8(15),
	11070: uint8(15),
	11071: uint8(15),
	11072: uint8(15),
	11073: uint8(131),
	11074: uint8(15),
	11075: uint8(15),
	11076: uint8(15),
	11077: uint8(15),
	11078: uint8(15),
	11079: uint8(15),
	11080: uint8(15),
	11081: uint8(15),
	11082: uint8(131),
	11088: uint8(15),
	11089: uint8(15),
	11090: uint8(15),
	11091: uint8(15),
	11092: uint8(15),
	11093: uint8(15),
	11094: uint8(15),
	11095: uint8(15),
	11096: uint8(15),
	11097: uint8(15),
	11098: uint8(15),
	11099: uint8(15),
	11100: uint8(15),
	11101: uint8(15),
	11102: uint8(15),
	11103: uint8(15),
	11104: uint8(15),
	11105: uint8(15),
	11106: uint8(15),
	11107: uint8(15),
	11108: uint8(15),
	11109: uint8(15),
	11110: uint8(15),
	11111: uint8(15),
	11112: uint8(15),
	11113: uint8(15),
	11114: uint8(15),
	11115: uint8(15),
	11116: uint8(15),
	11117: uint8(15),
	11118: uint8(15),
	11119: uint8(15),
	11120: uint8(15),
	11121: uint8(15),
	11122: uint8(15),
	11123: uint8(15),
	11124: uint8(15),
	11125: uint8(15),
	11126: uint8(95),
	11127: uint8(95),
	11128: uint8(95),
	11129: uint8(95),
	11130: uint8(95),
	11136: uint8(15),
	11137: uint8(15),
	11138: uint8(15),
	11139: uint8(15),
	11140: uint8(15),
	11141: uint8(15),
	11142: uint8(15),
	11143: uint8(15),
	11144: uint8(15),
	11145: uint8(15),
	11146: uint8(15),
	11147: uint8(15),
	11148: uint8(15),
	11149: uint8(15),
	11150: uint8(15),
	11151: uint8(15),
	11152: uint8(15),
	11153: uint8(15),
	11154: uint8(15),
	11155: uint8(15),
	11156: uint8(15),
	11157: uint8(15),
	11158: uint8(15),
	11159: uint8(15),
	11160: uint8(15),
	11161: uint8(15),
	11162: uint8(15),
	11163: uint8(15),
	11164: uint8(15),
	11165: uint8(15),
	11167: uint8(3),
	11168: uint8(15),
	11169: uint8(15),
	11170: uint8(15),
	11171: uint8(15),
	11176: uint8(15),
	11177: uint8(15),
	11178: uint8(15),
	11179: uint8(15),
	11180: uint8(15),
	11181: uint8(15),
	11182: uint8(15),
	11183: uint8(15),
	11184: uint8(3),
	11185: uint8(131),
	11186: uint8(131),
	11187: uint8(131),
	11188: uint8(131),
	11189: uint8(131),
	11200: uint8(206),
	11201: uint8(206),
	11202: uint8(206),
	11203: uint8(206),
	11204: uint8(206),
	11205: uint8(206),
	11206: uint8(206),
	11207: uint8(206),
	11208: uint8(206),
	11209: uint8(206),
	11210: uint8(206),
	11211: uint8(206),
	11212: uint8(206),
	11213: uint8(206),
	11214: uint8(206),
	11215: uint8(206),
	11216: uint8(206),
	11217: uint8(206),
	11218: uint8(206),
	11219: uint8(206),
	11220: uint8(206),
	11221: uint8(206),
	11222: uint8(206),
	11223: uint8(206),
	11224: uint8(206),
	11225: uint8(206),
	11226: uint8(206),
	11227: uint8(206),
	11228: uint8(206),
	11229: uint8(206),
	11230: uint8(206),
	11231: uint8(206),
	11232: uint8(206),
	11233: uint8(206),
	11234: uint8(206),
	11235: uint8(206),
	11236: uint8(206),
	11237: uint8(206),
	11238: uint8(206),
	11239: uint8(206),
	11240: uint8(207),
	11241: uint8(207),
	11242: uint8(207),
	11243: uint8(207),
	11244: uint8(207),
	11245: uint8(207),
	11246: uint8(207),
	11247: uint8(207),
	11248: uint8(207),
	11249: uint8(207),
	11250: uint8(207),
	11251: uint8(207),
	11252: uint8(207),
	11253: uint8(207),
	11254: uint8(207),
	11255: uint8(207),
	11256: uint8(207),
	11257: uint8(207),
	11258: uint8(207),
	11259: uint8(207),
	11260: uint8(207),
	11261: uint8(207),
	11262: uint8(207),
	11263: uint8(207),
	11264: uint8(207),
	11265: uint8(207),
	11266: uint8(207),
	11267: uint8(207),
	11268: uint8(207),
	11269: uint8(207),
	11270: uint8(207),
	11271: uint8(207),
	11272: uint8(207),
	11273: uint8(207),
	11274: uint8(207),
	11275: uint8(207),
	11276: uint8(207),
	11277: uint8(207),
	11278: uint8(207),
	11279: uint8(207),
	11280: uint8(15),
	11281: uint8(15),
	11282: uint8(15),
	11283: uint8(15),
	11284: uint8(15),
	11285: uint8(15),
	11286: uint8(15),
	11287: uint8(15),
	11288: uint8(15),
	11289: uint8(15),
	11290: uint8(15),
	11291: uint8(15),
	11292: uint8(15),
	11293: uint8(15),
	11294: uint8(15),
	11295: uint8(15),
	11296: uint8(15),
	11297: uint8(15),
	11298: uint8(15),
	11299: uint8(15),
	11300: uint8(15),
	11301: uint8(15),
	11302: uint8(15),
	11303: uint8(15),
	11304: uint8(15),
	11305: uint8(15),
	11306: uint8(15),
	11307: uint8(15),
	11308: uint8(15),
	11309: uint8(15),
	11310: uint8(15),
	11311: uint8(15),
	11312: uint8(15),
	11313: uint8(15),
	11314: uint8(15),
	11315: uint8(15),
	11316: uint8(15),
	11317: uint8(15),
	11318: uint8(15),
	11319: uint8(15),
	11320: uint8(15),
	11321: uint8(15),
	11322: uint8(15),
	11323: uint8(15),
	11324: uint8(15),
	11325: uint8(15),
	11328: uint8(9),
	11329: uint8(9),
	11330: uint8(9),
	11331: uint8(9),
	11332: uint8(9),
	11333: uint8(9),
	11334: uint8(9),
	11335: uint8(9),
	11336: uint8(9),
	11337: uint8(9),
	11344: uint8(206),
	11345: uint8(206),
	11346: uint8(206),
	11347: uint8(206),
	11348: uint8(206),
	11349: uint8(206),
	11350: uint8(206),
	11351: uint8(206),
	11352: uint8(206),
	11353: uint8(206),
	11354: uint8(206),
	11355: uint8(206),
	11356: uint8(206),
	11357: uint8(206),
	11358: uint8(206),
	11359: uint8(206),
	11360: uint8(206),
	11361: uint8(206),
	11362: uint8(206),
	11363: uint8(206),
	11364: uint8(206),
	11365: uint8(206),
	11366: uint8(206),
	11367: uint8(206),
	11368: uint8(206),
	11369: uint8(206),
	11370: uint8(206),
	11371: uint8(206),
	11372: uint8(206),
	11373: uint8(206),
	11374: uint8(206),
	11375: uint8(206),
	11376: uint8(206),
	11377: uint8(206),
	11378: uint8(206),
	11379: uint8(206),
	11384: uint8(207),
	11385: uint8(207),
	11386: uint8(207),
	11387: uint8(207),
	11388: uint8(207),
	11389: uint8(207),
	11390: uint8(207),
	11391: uint8(207),
	11392: uint8(207),
	11393: uint8(207),
	11394: uint8(207),
	11395: uint8(207),
	11396: uint8(207),
	11397: uint8(207),
	11398: uint8(207),
	11399: uint8(207),
	11400: uint8(207),
	11401: uint8(207),
	11402: uint8(207),
	11403: uint8(207),
	11404: uint8(207),
	11405: uint8(207),
	11406: uint8(207),
	11407: uint8(207),
	11408: uint8(207),
	11409: uint8(207),
	11410: uint8(207),
	11411: uint8(207),
	11412: uint8(207),
	11413: uint8(207),
	11414: uint8(207),
	11415: uint8(207),
	11416: uint8(207),
	11417: uint8(207),
	11418: uint8(207),
	11419: uint8(207),
	11424: uint8(15),
	11425: uint8(15),
	11426: uint8(15),
	11427: uint8(15),
	11428: uint8(15),
	11429: uint8(15),
	11430: uint8(15),
	11431: uint8(15),
	11440: uint8(15),
	11441: uint8(15),
	11442: uint8(15),
	11443: uint8(15),
	11444: uint8(15),
	11445: uint8(15),
	11446: uint8(15),
	11447: uint8(15),
	11448: uint8(15),
	11449: uint8(15),
	11450: uint8(15),
	11451: uint8(15),
	11452: uint8(15),
	11453: uint8(15),
	11454: uint8(15),
	11455: uint8(15),
	11456: uint8(15),
	11457: uint8(15),
	11458: uint8(15),
	11459: uint8(15),
	11471: uint8(3),
	11472: uint8(208),
	11473: uint8(208),
	11474: uint8(208),
	11475: uint8(208),
	11476: uint8(208),
	11477: uint8(208),
	11478: uint8(208),
	11479: uint8(208),
	11480: uint8(208),
	11481: uint8(208),
	11482: uint8(208),
	11484: uint8(208),
	11485: uint8(208),
	11486: uint8(208),
	11487: uint8(208),
	11488: uint8(208),
	11489: uint8(208),
	11490: uint8(208),
	11491: uint8(208),
	11492: uint8(208),
	11493: uint8(208),
	11494: uint8(208),
	11495: uint8(208),
	11496: uint8(208),
	11497: uint8(208),
	11498: uint8(208),
	11500: uint8(208),
	11501: uint8(208),
	11502: uint8(208),
	11503: uint8(208),
	11504: uint8(208),
	11505: uint8(208),
	11506: uint8(208),
	11508: uint8(208),
	11509: uint8(208),
	11511: uint8(209),
	11512: uint8(209),
	11513: uint8(209),
	11514: uint8(209),
	11515: uint8(209),
	11516: uint8(209),
	11517: uint8(209),
	11518: uint8(209),
	11519: uint8(209),
	11520: uint8(209),
	11521: uint8(209),
	11523: uint8(209),
	11524: uint8(209),
	11525: uint8(209),
	11526: uint8(209),
	11527: uint8(209),
	11528: uint8(209),
	11529: uint8(209),
	11530: uint8(209),
	11531: uint8(209),
	11532: uint8(209),
	11533: uint8(209),
	11534: uint8(209),
	11535: uint8(209),
	11536: uint8(209),
	11537: uint8(209),
	11539: uint8(209),
	11540: uint8(209),
	11541: uint8(209),
	11542: uint8(209),
	11543: uint8(209),
	11544: uint8(209),
	11545: uint8(209),
	11547: uint8(209),
	11548: uint8(209),
	11552: uint8(15),
	11553: uint8(15),
	11554: uint8(15),
	11555: uint8(15),
	11556: uint8(15),
	11557: uint8(15),
	11558: uint8(15),
	11559: uint8(15),
	11560: uint8(15),
	11561: uint8(15),
	11562: uint8(15),
	11563: uint8(15),
	11564: uint8(15),
	11565: uint8(15),
	11566: uint8(15),
	11567: uint8(15),
	11568: uint8(15),
	11569: uint8(15),
	11570: uint8(15),
	11571: uint8(15),
	11584: uint8(15),
	11585: uint8(15),
	11586: uint8(15),
	11587: uint8(15),
	11588: uint8(15),
	11589: uint8(15),
	11590: uint8(15),
	11591: uint8(15),
	11616: uint8(94),
	11617: uint8(94),
	11618: uint8(94),
	11619: uint8(94),
	11620: uint8(94),
	11621: uint8(94),
	11623: uint8(94),
	11624: uint8(94),
	11625: uint8(94),
	11626: uint8(94),
	11627: uint8(94),
	11628: uint8(94),
	11629: uint8(94),
	11630: uint8(94),
	11631: uint8(94),
	11632: uint8(94),
	11633: uint8(94),
	11634: uint8(94),
	11635: uint8(94),
	11636: uint8(94),
	11637: uint8(94),
	11638: uint8(94),
	11639: uint8(94),
	11640: uint8(94),
	11641: uint8(94),
	11642: uint8(94),
	11643: uint8(94),
	11644: uint8(94),
	11645: uint8(94),
	11646: uint8(94),
	11647: uint8(94),
	11648: uint8(94),
	11649: uint8(94),
	11650: uint8(94),
	11651: uint8(94),
	11652: uint8(94),
	11653: uint8(94),
	11654: uint8(94),
	11655: uint8(94),
	11656: uint8(94),
	11657: uint8(94),
	11658: uint8(94),
	11659: uint8(94),
	11660: uint8(94),
	11661: uint8(94),
	11662: uint8(94),
	11663: uint8(94),
	11664: uint8(94),
	11666: uint8(94),
	11667: uint8(94),
	11668: uint8(94),
	11669: uint8(94),
	11670: uint8(94),
	11671: uint8(94),
	11672: uint8(94),
	11673: uint8(94),
	11674: uint8(94),
	11680: uint8(15),
	11681: uint8(15),
	11682: uint8(15),
	11683: uint8(15),
	11684: uint8(15),
	11685: uint8(15),
	11688: uint8(15),
	11690: uint8(15),
	11691: uint8(15),
	11692: uint8(15),
	11693: uint8(15),
	11694: uint8(15),
	11695: uint8(15),
	11696: uint8(15),
	11697: uint8(15),
	11698: uint8(15),
	11699: uint8(15),
	11700: uint8(15),
	11701: uint8(15),
	11702: uint8(15),
	11703: uint8(15),
	11704: uint8(15),
	11705: uint8(15),
	11706: uint8(15),
	11707: uint8(15),
	11708: uint8(15),
	11709: uint8(15),
	11710: uint8(15),
	11711: uint8(15),
	11712: uint8(15),
	11713: uint8(15),
	11714: uint8(15),
	11715: uint8(15),
	11716: uint8(15),
	11717: uint8(15),
	11718: uint8(15),
	11719: uint8(15),
	11720: uint8(15),
	11721: uint8(15),
	11722: uint8(15),
	11723: uint8(15),
	11724: uint8(15),
	11725: uint8(15),
	11726: uint8(15),
	11727: uint8(15),
	11728: uint8(15),
	11729: uint8(15),
	11730: uint8(15),
	11731: uint8(15),
	11732: uint8(15),
	11733: uint8(15),
	11735: uint8(15),
	11736: uint8(15),
	11740: uint8(15),
	11743: uint8(15),
	11744: uint8(15),
	11745: uint8(15),
	11746: uint8(15),
	11747: uint8(15),
	11748: uint8(15),
	11749: uint8(15),
	11750: uint8(15),
	11751: uint8(15),
	11752: uint8(15),
	11753: uint8(15),
	11754: uint8(15),
	11755: uint8(15),
	11756: uint8(15),
	11757: uint8(15),
	11758: uint8(15),
	11759: uint8(15),
	11760: uint8(15),
	11761: uint8(15),
	11762: uint8(15),
	11763: uint8(15),
	11764: uint8(15),
	11765: uint8(15),
	11767: uint8(3),
	11768: uint8(18),
	11769: uint8(18),
	11770: uint8(18),
	11771: uint8(18),
	11772: uint8(18),
	11773: uint8(18),
	11774: uint8(18),
	11775: uint8(18),
	11776: uint8(15),
	11777: uint8(15),
	11778: uint8(15),
	11779: uint8(15),
	11780: uint8(15),
	11781: uint8(15),
	11782: uint8(15),
	11783: uint8(15),
	11784: uint8(15),
	11785: uint8(15),
	11786: uint8(15),
	11787: uint8(15),
	11788: uint8(15),
	11789: uint8(15),
	11790: uint8(15),
	11791: uint8(15),
	11792: uint8(15),
	11793: uint8(15),
	11794: uint8(15),
	11795: uint8(15),
	11796: uint8(15),
	11797: uint8(15),
	11798: uint8(15),
	11799: uint8(14),
	11800: uint8(14),
	11801: uint8(18),
	11802: uint8(18),
	11803: uint8(18),
	11804: uint8(18),
	11805: uint8(18),
	11806: uint8(18),
	11807: uint8(18),
	11815: uint8(18),
	11816: uint8(18),
	11817: uint8(18),
	11818: uint8(18),
	11819: uint8(18),
	11820: uint8(18),
	11821: uint8(18),
	11822: uint8(18),
	11823: uint8(18),
	11840: uint8(15),
	11841: uint8(15),
	11842: uint8(15),
	11843: uint8(15),
	11844: uint8(15),
	11845: uint8(15),
	11846: uint8(15),
	11847: uint8(15),
	11848: uint8(15),
	11849: uint8(15),
	11850: uint8(15),
	11851: uint8(15),
	11852: uint8(15),
	11853: uint8(15),
	11854: uint8(15),
	11855: uint8(15),
	11856: uint8(15),
	11857: uint8(15),
	11858: uint8(15),
	11860: uint8(15),
	11861: uint8(15),
	11867: uint8(18),
	11868: uint8(18),
	11869: uint8(18),
	11870: uint8(18),
	11871: uint8(18),
	11872: uint8(15),
	11873: uint8(15),
	11874: uint8(15),
	11875: uint8(15),
	11876: uint8(15),
	11877: uint8(15),
	11878: uint8(15),
	11879: uint8(15),
	11880: uint8(15),
	11881: uint8(15),
	11882: uint8(15),
	11883: uint8(15),
	11884: uint8(15),
	11885: uint8(15),
	11886: uint8(15),
	11887: uint8(15),
	11888: uint8(15),
	11889: uint8(15),
	11890: uint8(15),
	11891: uint8(15),
	11892: uint8(15),
	11893: uint8(15),
	11894: uint8(18),
	11895: uint8(18),
	11896: uint8(18),
	11897: uint8(18),
	11898: uint8(18),
	11899: uint8(18),
	11903: uint8(3),
	11904: uint8(15),
	11905: uint8(15),
	11906: uint8(15),
	11907: uint8(15),
	11908: uint8(15),
	11909: uint8(15),
	11910: uint8(15),
	11911: uint8(15),
	11912: uint8(15),
	11913: uint8(15),
	11914: uint8(15),
	11915: uint8(15),
	11916: uint8(15),
	11917: uint8(15),
	11918: uint8(15),
	11919: uint8(15),
	11920: uint8(15),
	11921: uint8(15),
	11922: uint8(15),
	11923: uint8(15),
	11924: uint8(15),
	11925: uint8(15),
	11926: uint8(15),
	11927: uint8(15),
	11928: uint8(15),
	11929: uint8(15),
	11935: uint8(3),
	11936: uint8(15),
	11937: uint8(15),
	11938: uint8(15),
	11939: uint8(15),
	11940: uint8(15),
	11941: uint8(15),
	11942: uint8(15),
	11943: uint8(15),
	11944: uint8(15),
	11945: uint8(15),
	11946: uint8(15),
	11947: uint8(15),
	11948: uint8(15),
	11949: uint8(15),
	11950: uint8(15),
	11951: uint8(15),
	11952: uint8(15),
	11953: uint8(15),
	11954: uint8(15),
	11955: uint8(15),
	11956: uint8(15),
	11957: uint8(15),
	11958: uint8(15),
	11959: uint8(15),
	11964: uint8(18),
	11965: uint8(18),
	11966: uint8(15),
	11967: uint8(15),
	11968: uint8(18),
	11969: uint8(18),
	11970: uint8(18),
	11971: uint8(18),
	11972: uint8(18),
	11973: uint8(18),
	11974: uint8(18),
	11975: uint8(18),
	11976: uint8(18),
	11977: uint8(18),
	11978: uint8(18),
	11979: uint8(18),
	11980: uint8(18),
	11981: uint8(18),
	11982: uint8(18),
	11983: uint8(18),
	11986: uint8(18),
	11987: uint8(18),
	11988: uint8(18),
	11989: uint8(18),
	11990: uint8(18),
	11991: uint8(18),
	11992: uint8(18),
	11993: uint8(18),
	11994: uint8(18),
	11995: uint8(18),
	11996: uint8(18),
	11997: uint8(18),
	11998: uint8(18),
	11999: uint8(18),
	12000: uint8(15),
	12001: uint8(95),
	12002: uint8(95),
	12003: uint8(95),
	12005: uint8(95),
	12006: uint8(95),
	12012: uint8(95),
	12013: uint8(95),
	12014: uint8(95),
	12015: uint8(95),
	12016: uint8(15),
	12017: uint8(15),
	12018: uint8(15),
	12019: uint8(15),
	12021: uint8(15),
	12022: uint8(15),
	12023: uint8(15),
	12025: uint8(15),
	12026: uint8(15),
	12027: uint8(15),
	12028: uint8(15),
	12029: uint8(15),
	12030: uint8(15),
	12031: uint8(15),
	12032: uint8(15),
	12033: uint8(15),
	12034: uint8(15),
	12035: uint8(15),
	12036: uint8(15),
	12037: uint8(15),
	12038: uint8(15),
	12039: uint8(15),
	12040: uint8(15),
	12041: uint8(15),
	12042: uint8(15),
	12043: uint8(15),
	12044: uint8(15),
	12045: uint8(15),
	12046: uint8(15),
	12047: uint8(15),
	12048: uint8(15),
	12049: uint8(15),
	12050: uint8(15),
	12051: uint8(15),
	12052: uint8(15),
	12053: uint8(15),
	12056: uint8(95),
	12057: uint8(95),
	12058: uint8(95),
	12063: uint8(95),
	12064: uint8(18),
	12065: uint8(18),
	12066: uint8(18),
	12067: uint8(18),
	12068: uint8(18),
	12069: uint8(18),
	12070: uint8(18),
	12071: uint8(18),
	12072: uint8(18),
	12080: uint8(3),
	12081: uint8(3),
	12082: uint8(3),
	12083: uint8(3),
	12084: uint8(3),
	12085: uint8(3),
	12086: uint8(3),
	12087: uint8(3),
	12088: uint8(3),
	12096: uint8(15),
	12097: uint8(15),
	12098: uint8(15),
	12099: uint8(15),
	12100: uint8(15),
	12101: uint8(15),
	12102: uint8(15),
	12103: uint8(15),
	12104: uint8(15),
	12105: uint8(15),
	12106: uint8(15),
	12107: uint8(15),
	12108: uint8(15),
	12109: uint8(15),
	12110: uint8(15),
	12111: uint8(15),
	12112: uint8(15),
	12113: uint8(15),
	12114: uint8(15),
	12115: uint8(15),
	12116: uint8(15),
	12117: uint8(15),
	12118: uint8(15),
	12119: uint8(15),
	12120: uint8(15),
	12121: uint8(15),
	12122: uint8(15),
	12123: uint8(15),
	12124: uint8(15),
	12125: uint8(18),
	12126: uint8(18),
	12127: uint8(3),
	12128: uint8(15),
	12129: uint8(15),
	12130: uint8(15),
	12131: uint8(15),
	12132: uint8(15),
	12133: uint8(15),
	12134: uint8(15),
	12135: uint8(15),
	12136: uint8(15),
	12137: uint8(15),
	12138: uint8(15),
	12139: uint8(15),
	12140: uint8(15),
	12141: uint8(15),
	12142: uint8(15),
	12143: uint8(15),
	12144: uint8(15),
	12145: uint8(15),
	12146: uint8(15),
	12147: uint8(15),
	12148: uint8(15),
	12149: uint8(15),
	12150: uint8(15),
	12151: uint8(15),
	12152: uint8(15),
	12153: uint8(15),
	12154: uint8(15),
	12155: uint8(15),
	12156: uint8(15),
	12157: uint8(18),
	12158: uint8(18),
	12159: uint8(18),
	12160: uint8(15),
	12161: uint8(15),
	12162: uint8(15),
	12163: uint8(15),
	12164: uint8(15),
	12165: uint8(15),
	12166: uint8(15),
	12167: uint8(15),
	12168: uint8(14),
	12169: uint8(15),
	12170: uint8(15),
	12171: uint8(15),
	12172: uint8(15),
	12173: uint8(15),
	12174: uint8(15),
	12175: uint8(15),
	12176: uint8(15),
	12177: uint8(15),
	12178: uint8(15),
	12179: uint8(15),
	12180: uint8(15),
	12181: uint8(15),
	12182: uint8(15),
	12183: uint8(15),
	12184: uint8(15),
	12185: uint8(15),
	12186: uint8(15),
	12187: uint8(15),
	12188: uint8(15),
	12189: uint8(15),
	12190: uint8(15),
	12191: uint8(15),
	12192: uint8(15),
	12193: uint8(15),
	12194: uint8(15),
	12195: uint8(15),
	12196: uint8(15),
	12197: uint8(95),
	12198: uint8(95),
	12203: uint8(18),
	12204: uint8(18),
	12205: uint8(18),
	12206: uint8(18),
	12207: uint8(18),
	12208: uint8(3),
	12209: uint8(3),
	12210: uint8(3),
	12211: uint8(3),
	12212: uint8(3),
	12213: uint8(3),
	12214: uint8(3),
	12224: uint8(15),
	12225: uint8(15),
	12226: uint8(15),
	12227: uint8(15),
	12228: uint8(15),
	12229: uint8(15),
	12230: uint8(15),
	12231: uint8(15),
	12232: uint8(15),
	12233: uint8(15),
	12234: uint8(15),
	12235: uint8(15),
	12236: uint8(15),
	12237: uint8(15),
	12238: uint8(15),
	12239: uint8(15),
	12240: uint8(15),
	12241: uint8(15),
	12242: uint8(15),
	12243: uint8(15),
	12244: uint8(15),
	12245: uint8(15),
	12249: uint8(3),
	12250: uint8(3),
	12251: uint8(3),
	12252: uint8(3),
	12253: uint8(3),
	12254: uint8(3),
	12255: uint8(3),
	12256: uint8(15),
	12257: uint8(15),
	12258: uint8(15),
	12259: uint8(15),
	12260: uint8(15),
	12261: uint8(15),
	12262: uint8(15),
	12263: uint8(15),
	12264: uint8(15),
	12265: uint8(15),
	12266: uint8(15),
	12267: uint8(15),
	12268: uint8(15),
	12269: uint8(15),
	12270: uint8(15),
	12271: uint8(15),
	12272: uint8(15),
	12273: uint8(15),
	12274: uint8(15),
	12275: uint8(15),
	12276: uint8(15),
	12277: uint8(15),
	12280: uint8(18),
	12281: uint8(18),
	12282: uint8(18),
	12283: uint8(18),
	12284: uint8(18),
	12285: uint8(18),
	12286: uint8(18),
	12287: uint8(18),
	12288: uint8(15),
	12289: uint8(15),
	12290: uint8(15),
	12291: uint8(15),
	12292: uint8(15),
	12293: uint8(15),
	12294: uint8(15),
	12295: uint8(15),
	12296: uint8(15),
	12297: uint8(15),
	12298: uint8(15),
	12299: uint8(15),
	12300: uint8(15),
	12301: uint8(15),
	12302: uint8(15),
	12303: uint8(15),
	12304: uint8(15),
	12305: uint8(15),
	12306: uint8(15),
	12312: uint8(18),
	12313: uint8(18),
	12314: uint8(18),
	12315: uint8(18),
	12316: uint8(18),
	12317: uint8(18),
	12318: uint8(18),
	12319: uint8(18),
	12320: uint8(15),
	12321: uint8(15),
	12322: uint8(15),
	12323: uint8(15),
	12324: uint8(15),
	12325: uint8(15),
	12326: uint8(15),
	12327: uint8(15),
	12328: uint8(15),
	12329: uint8(15),
	12330: uint8(15),
	12331: uint8(15),
	12332: uint8(15),
	12333: uint8(15),
	12334: uint8(15),
	12335: uint8(15),
	12336: uint8(15),
	12337: uint8(15),
	12345: uint8(3),
	12346: uint8(3),
	12347: uint8(3),
	12348: uint8(3),
	12361: uint8(18),
	12362: uint8(18),
	12363: uint8(18),
	12364: uint8(18),
	12365: uint8(18),
	12366: uint8(18),
	12367: uint8(18),
	12384: uint8(15),
	12385: uint8(15),
	12386: uint8(15),
	12387: uint8(15),
	12388: uint8(15),
	12389: uint8(15),
	12390: uint8(15),
	12391: uint8(15),
	12392: uint8(15),
	12416: uint8(100),
	12417: uint8(100),
	12418: uint8(100),
	12419: uint8(100),
	12420: uint8(100),
	12421: uint8(100),
	12422: uint8(100),
	12423: uint8(100),
	12424: uint8(100),
	12425: uint8(100),
	12426: uint8(100),
	12427: uint8(100),
	12428: uint8(100),
	12429: uint8(100),
	12430: uint8(100),
	12431: uint8(100),
	12432: uint8(100),
	12433: uint8(100),
	12434: uint8(100),
	12435: uint8(100),
	12436: uint8(100),
	12437: uint8(100),
	12438: uint8(100),
	12439: uint8(100),
	12440: uint8(100),
	12441: uint8(100),
	12442: uint8(100),
	12443: uint8(100),
	12444: uint8(100),
	12445: uint8(100),
	12446: uint8(100),
	12447: uint8(100),
	12448: uint8(100),
	12449: uint8(100),
	12450: uint8(100),
	12451: uint8(100),
	12452: uint8(100),
	12453: uint8(100),
	12454: uint8(100),
	12455: uint8(100),
	12456: uint8(100),
	12457: uint8(100),
	12458: uint8(100),
	12459: uint8(100),
	12460: uint8(100),
	12461: uint8(100),
	12462: uint8(100),
	12463: uint8(100),
	12464: uint8(100),
	12465: uint8(100),
	12466: uint8(100),
	12480: uint8(105),
	12481: uint8(105),
	12482: uint8(105),
	12483: uint8(105),
	12484: uint8(105),
	12485: uint8(105),
	12486: uint8(105),
	12487: uint8(105),
	12488: uint8(105),
	12489: uint8(105),
	12490: uint8(105),
	12491: uint8(105),
	12492: uint8(105),
	12493: uint8(105),
	12494: uint8(105),
	12495: uint8(105),
	12496: uint8(105),
	12497: uint8(105),
	12498: uint8(105),
	12499: uint8(105),
	12500: uint8(105),
	12501: uint8(105),
	12502: uint8(105),
	12503: uint8(105),
	12504: uint8(105),
	12505: uint8(105),
	12506: uint8(105),
	12507: uint8(105),
	12508: uint8(105),
	12509: uint8(105),
	12510: uint8(105),
	12511: uint8(105),
	12512: uint8(105),
	12513: uint8(105),
	12514: uint8(105),
	12515: uint8(105),
	12516: uint8(105),
	12517: uint8(105),
	12518: uint8(105),
	12519: uint8(105),
	12520: uint8(105),
	12521: uint8(105),
	12522: uint8(105),
	12523: uint8(105),
	12524: uint8(105),
	12525: uint8(105),
	12526: uint8(105),
	12527: uint8(105),
	12528: uint8(105),
	12529: uint8(105),
	12530: uint8(105),
	12538: uint8(18),
	12539: uint8(18),
	12540: uint8(18),
	12541: uint8(18),
	12542: uint8(18),
	12543: uint8(18),
	12544: uint8(15),
	12545: uint8(15),
	12546: uint8(15),
	12547: uint8(15),
	12548: uint8(95),
	12549: uint8(95),
	12550: uint8(95),
	12551: uint8(95),
	12560: uint8(9),
	12561: uint8(9),
	12562: uint8(9),
	12563: uint8(9),
	12564: uint8(9),
	12565: uint8(9),
	12566: uint8(9),
	12567: uint8(9),
	12568: uint8(9),
	12569: uint8(9),
	12576: uint8(9),
	12577: uint8(9),
	12578: uint8(9),
	12579: uint8(9),
	12580: uint8(9),
	12581: uint8(9),
	12582: uint8(9),
	12583: uint8(9),
	12584: uint8(9),
	12585: uint8(9),
	12586: uint8(15),
	12587: uint8(15),
	12588: uint8(15),
	12589: uint8(15),
	12590: uint8(94),
	12591: uint8(15),
	12592: uint8(10),
	12593: uint8(10),
	12594: uint8(10),
	12595: uint8(10),
	12596: uint8(10),
	12597: uint8(10),
	12598: uint8(10),
	12599: uint8(10),
	12600: uint8(10),
	12601: uint8(10),
	12602: uint8(10),
	12603: uint8(10),
	12604: uint8(10),
	12605: uint8(10),
	12606: uint8(10),
	12607: uint8(10),
	12608: uint8(10),
	12609: uint8(10),
	12610: uint8(10),
	12611: uint8(10),
	12612: uint8(10),
	12613: uint8(10),
	12617: uint8(95),
	12618: uint8(95),
	12619: uint8(95),
	12620: uint8(95),
	12621: uint8(95),
	12622: uint8(8),
	12623: uint8(94),
	12624: uint8(13),
	12625: uint8(13),
	12626: uint8(13),
	12627: uint8(13),
	12628: uint8(13),
	12629: uint8(13),
	12630: uint8(13),
	12631: uint8(13),
	12632: uint8(13),
	12633: uint8(13),
	12634: uint8(13),
	12635: uint8(13),
	12636: uint8(13),
	12637: uint8(13),
	12638: uint8(13),
	12639: uint8(13),
	12640: uint8(13),
	12641: uint8(13),
	12642: uint8(13),
	12643: uint8(13),
	12644: uint8(13),
	12645: uint8(13),
	12654: uint8(7),
	12655: uint8(7),
	12672: uint8(18),
	12673: uint8(18),
	12674: uint8(18),
	12675: uint8(18),
	12676: uint8(18),
	12677: uint8(18),
	12678: uint8(18),
	12679: uint8(18),
	12680: uint8(18),
	12681: uint8(18),
	12682: uint8(18),
	12683: uint8(18),
	12684: uint8(18),
	12685: uint8(18),
	12686: uint8(18),
	12687: uint8(18),
	12688: uint8(18),
	12689: uint8(18),
	12690: uint8(18),
	12691: uint8(18),
	12692: uint8(18),
	12693: uint8(18),
	12694: uint8(18),
	12695: uint8(18),
	12696: uint8(18),
	12697: uint8(18),
	12698: uint8(18),
	12699: uint8(18),
	12700: uint8(18),
	12701: uint8(18),
	12702: uint8(18),
	12704: uint8(15),
	12705: uint8(15),
	12706: uint8(15),
	12707: uint8(15),
	12708: uint8(15),
	12709: uint8(15),
	12710: uint8(15),
	12711: uint8(15),
	12712: uint8(15),
	12713: uint8(15),
	12715: uint8(95),
	12716: uint8(95),
	12717: uint8(8),
	12720: uint8(15),
	12721: uint8(15),
	12738: uint8(15),
	12739: uint8(15),
	12740: uint8(15),
	12796: uint8(95),
	12797: uint8(95),
	12798: uint8(95),
	12799: uint8(95),
	12800: uint8(18),
	12801: uint8(18),
	12802: uint8(18),
	12803: uint8(18),
	12804: uint8(18),
	12805: uint8(18),
	12806: uint8(18),
	12807: uint8(15),
	12816: uint8(15),
	12817: uint8(15),
	12818: uint8(15),
	12819: uint8(15),
	12820: uint8(15),
	12821: uint8(15),
	12822: uint8(15),
	12823: uint8(15),
	12824: uint8(15),
	12825: uint8(15),
	12826: uint8(15),
	12827: uint8(15),
	12828: uint8(15),
	12829: uint8(15),
	12830: uint8(15),
	12831: uint8(15),
	12832: uint8(15),
	12833: uint8(15),
	12834: uint8(15),
	12835: uint8(15),
	12836: uint8(15),
	12837: uint8(15),
	12838: uint8(95),
	12839: uint8(95),
	12840: uint8(95),
	12841: uint8(95),
	12842: uint8(95),
	12843: uint8(95),
	12844: uint8(95),
	12845: uint8(95),
	12846: uint8(95),
	12847: uint8(95),
	12848: uint8(95),
	12849: uint8(18),
	12850: uint8(18),
	12851: uint8(18),
	12852: uint8(18),
	12853: uint8(3),
	12854: uint8(3),
	12855: uint8(3),
	12856: uint8(3),
	12857: uint8(3),
	12880: uint8(15),
	12881: uint8(15),
	12882: uint8(15),
	12883: uint8(15),
	12884: uint8(15),
	12885: uint8(15),
	12886: uint8(15),
	12887: uint8(15),
	12888: uint8(15),
	12889: uint8(15),
	12890: uint8(15),
	12891: uint8(15),
	12892: uint8(15),
	12893: uint8(15),
	12894: uint8(15),
	12895: uint8(15),
	12896: uint8(15),
	12897: uint8(15),
	12898: uint8(95),
	12899: uint8(95),
	12900: uint8(95),
	12901: uint8(95),
	12902: uint8(3),
	12903: uint8(3),
	12904: uint8(3),
	12905: uint8(3),
	12928: uint8(15),
	12929: uint8(15),
	12930: uint8(15),
	12931: uint8(15),
	12932: uint8(15),
	12933: uint8(18),
	12934: uint8(18),
	12935: uint8(18),
	12936: uint8(18),
	12937: uint8(18),
	12938: uint8(18),
	12939: uint8(18),
	12960: uint8(127),
	12961: uint8(95),
	12962: uint8(127),
	12963: uint8(15),
	12964: uint8(15),
	12965: uint8(15),
	12966: uint8(15),
	12967: uint8(15),
	12968: uint8(15),
	12969: uint8(15),
	12970: uint8(15),
	12971: uint8(15),
	12972: uint8(15),
	12973: uint8(15),
	12974: uint8(15),
	12975: uint8(15),
	12976: uint8(15),
	12977: uint8(15),
	12978: uint8(15),
	12979: uint8(15),
	12980: uint8(15),
	12981: uint8(15),
	12982: uint8(15),
	12983: uint8(15),
	12984: uint8(15),
	12985: uint8(15),
	12986: uint8(15),
	12987: uint8(15),
	12988: uint8(15),
	12989: uint8(15),
	12990: uint8(15),
	12991: uint8(15),
	12992: uint8(15),
	12993: uint8(15),
	12994: uint8(15),
	12995: uint8(15),
	12996: uint8(15),
	12997: uint8(15),
	12998: uint8(15),
	12999: uint8(15),
	13000: uint8(15),
	13001: uint8(15),
	13002: uint8(15),
	13003: uint8(15),
	13004: uint8(15),
	13005: uint8(15),
	13006: uint8(15),
	13007: uint8(15),
	13008: uint8(15),
	13009: uint8(15),
	13010: uint8(15),
	13011: uint8(15),
	13012: uint8(15),
	13013: uint8(15),
	13014: uint8(15),
	13015: uint8(15),
	13016: uint8(95),
	13017: uint8(95),
	13018: uint8(95),
	13019: uint8(95),
	13020: uint8(95),
	13021: uint8(95),
	13022: uint8(95),
	13023: uint8(95),
	13024: uint8(95),
	13025: uint8(95),
	13026: uint8(95),
	13027: uint8(95),
	13028: uint8(95),
	13029: uint8(95),
	13030: uint8(95),
	13031: uint8(3),
	13032: uint8(3),
	13033: uint8(3),
	13034: uint8(3),
	13035: uint8(3),
	13036: uint8(3),
	13037: uint8(3),
	13042: uint8(18),
	13043: uint8(18),
	13044: uint8(18),
	13045: uint8(18),
	13046: uint8(18),
	13047: uint8(18),
	13048: uint8(18),
	13049: uint8(18),
	13050: uint8(18),
	13051: uint8(18),
	13052: uint8(18),
	13053: uint8(18),
	13054: uint8(18),
	13055: uint8(18),
	13056: uint8(18),
	13057: uint8(18),
	13058: uint8(18),
	13059: uint8(18),
	13060: uint8(18),
	13061: uint8(18),
	13062: uint8(9),
	13063: uint8(9),
	13064: uint8(9),
	13065: uint8(9),
	13066: uint8(9),
	13067: uint8(9),
	13068: uint8(9),
	13069: uint8(9),
	13070: uint8(9),
	13071: uint8(9),
	13072: uint8(95),
	13073: uint8(15),
	13074: uint8(15),
	13075: uint8(95),
	13076: uint8(95),
	13077: uint8(15),
	13087: uint8(95),
	13088: uint8(15),
	13089: uint8(15),
	13090: uint8(15),
	13091: uint8(15),
	13092: uint8(15),
	13093: uint8(15),
	13094: uint8(15),
	13095: uint8(15),
	13096: uint8(15),
	13097: uint8(15),
	13098: uint8(15),
	13099: uint8(15),
	13100: uint8(15),
	13101: uint8(15),
	13102: uint8(15),
	13103: uint8(15),
	13104: uint8(127),
	13105: uint8(127),
	13106: uint8(127),
	13107: uint8(95),
	13108: uint8(95),
	13109: uint8(95),
	13110: uint8(95),
	13111: uint8(127),
	13112: uint8(127),
	13113: uint8(95),
	13114: uint8(95),
	13115: uint8(3),
	13116: uint8(3),
	13117: uint8(17),
	13118: uint8(3),
	13119: uint8(3),
	13120: uint8(3),
	13121: uint8(3),
	13122: uint8(95),
	13133: uint8(17),
	13136: uint8(15),
	13137: uint8(15),
	13138: uint8(15),
	13139: uint8(15),
	13140: uint8(15),
	13141: uint8(15),
	13142: uint8(15),
	13143: uint8(15),
	13144: uint8(15),
	13145: uint8(15),
	13146: uint8(15),
	13147: uint8(15),
	13148: uint8(15),
	13149: uint8(15),
	13150: uint8(15),
	13151: uint8(15),
	13152: uint8(15),
	13153: uint8(15),
	13154: uint8(15),
	13155: uint8(15),
	13156: uint8(15),
	13157: uint8(15),
	13158: uint8(15),
	13159: uint8(15),
	13160: uint8(15),
	13168: uint8(9),
	13169: uint8(9),
	13170: uint8(9),
	13171: uint8(9),
	13172: uint8(9),
	13173: uint8(9),
	13174: uint8(9),
	13175: uint8(9),
	13176: uint8(9),
	13177: uint8(9),
	13184: uint8(95),
	13185: uint8(95),
	13186: uint8(95),
	13187: uint8(15),
	13188: uint8(15),
	13189: uint8(15),
	13190: uint8(15),
	13191: uint8(15),
	13192: uint8(15),
	13193: uint8(15),
	13194: uint8(15),
	13195: uint8(15),
	13196: uint8(15),
	13197: uint8(15),
	13198: uint8(15),
	13199: uint8(15),
	13200: uint8(15),
	13201: uint8(15),
	13202: uint8(15),
	13203: uint8(15),
	13204: uint8(15),
	13205: uint8(15),
	13206: uint8(15),
	13207: uint8(15),
	13208: uint8(15),
	13209: uint8(15),
	13210: uint8(15),
	13211: uint8(15),
	13212: uint8(15),
	13213: uint8(15),
	13214: uint8(15),
	13215: uint8(15),
	13216: uint8(15),
	13217: uint8(15),
	13218: uint8(15),
	13219: uint8(15),
	13220: uint8(15),
	13221: uint8(15),
	13222: uint8(15),
	13223: uint8(95),
	13224: uint8(95),
	13225: uint8(95),
	13226: uint8(95),
	13227: uint8(95),
	13228: uint8(127),
	13229: uint8(95),
	13230: uint8(95),
	13231: uint8(95),
	13232: uint8(95),
	13233: uint8(95),
	13234: uint8(95),
	13235: uint8(95),
	13236: uint8(95),
	13238: uint8(9),
	13239: uint8(9),
	13240: uint8(9),
	13241: uint8(9),
	13242: uint8(9),
	13243: uint8(9),
	13244: uint8(9),
	13245: uint8(9),
	13246: uint8(9),
	13247: uint8(9),
	13248: uint8(3),
	13249: uint8(3),
	13250: uint8(3),
	13251: uint8(3),
	13252: uint8(15),
	13253: uint8(127),
	13254: uint8(127),
	13255: uint8(15),
	13264: uint8(15),
	13265: uint8(15),
	13266: uint8(15),
	13267: uint8(15),
	13268: uint8(15),
	13269: uint8(15),
	13270: uint8(15),
	13271: uint8(15),
	13272: uint8(15),
	13273: uint8(15),
	13274: uint8(15),
	13275: uint8(15),
	13276: uint8(15),
	13277: uint8(15),
	13278: uint8(15),
	13279: uint8(15),
	13280: uint8(15),
	13281: uint8(15),
	13282: uint8(15),
	13283: uint8(15),
	13284: uint8(15),
	13285: uint8(15),
	13286: uint8(15),
	13287: uint8(15),
	13288: uint8(15),
	13289: uint8(15),
	13290: uint8(15),
	13291: uint8(15),
	13292: uint8(15),
	13293: uint8(15),
	13294: uint8(15),
	13295: uint8(15),
	13296: uint8(15),
	13297: uint8(15),
	13298: uint8(15),
	13299: uint8(95),
	13300: uint8(3),
	13301: uint8(3),
	13302: uint8(15),
	13312: uint8(15),
	13313: uint8(15),
	13314: uint8(15),
	13315: uint8(15),
	13316: uint8(15),
	13317: uint8(15),
	13318: uint8(15),
	13319: uint8(15),
	13320: uint8(15),
	13321: uint8(15),
	13322: uint8(15),
	13323: uint8(15),
	13324: uint8(15),
	13325: uint8(15),
	13326: uint8(15),
	13327: uint8(15),
	13328: uint8(15),
	13329: uint8(15),
	13330: uint8(15),
	13331: uint8(127),
	13332: uint8(127),
	13333: uint8(127),
	13334: uint8(95),
	13335: uint8(95),
	13336: uint8(95),
	13337: uint8(95),
	13338: uint8(95),
	13339: uint8(95),
	13340: uint8(95),
	13341: uint8(95),
	13342: uint8(95),
	13343: uint8(127),
	13344: uint8(127),
	13345: uint8(15),
	13346: uint8(15),
	13347: uint8(15),
	13348: uint8(15),
	13349: uint8(3),
	13350: uint8(3),
	13351: uint8(3),
	13352: uint8(3),
	13353: uint8(95),
	13354: uint8(95),
	13355: uint8(95),
	13356: uint8(95),
	13357: uint8(3),
	13358: uint8(127),
	13359: uint8(95),
	13360: uint8(9),
	13361: uint8(9),
	13362: uint8(9),
	13363: uint8(9),
	13364: uint8(9),
	13365: uint8(9),
	13366: uint8(9),
	13367: uint8(9),
	13368: uint8(9),
	13369: uint8(9),
	13370: uint8(15),
	13371: uint8(3),
	13372: uint8(15),
	13373: uint8(3),
	13374: uint8(3),
	13375: uint8(3),
	13377: uint8(18),
	13378: uint8(18),
	13379: uint8(18),
	13380: uint8(18),
	13381: uint8(18),
	13382: uint8(18),
	13383: uint8(18),
	13384: uint8(18),
	13385: uint8(18),
	13386: uint8(18),
	13387: uint8(18),
	13388: uint8(18),
	13389: uint8(18),
	13390: uint8(18),
	13391: uint8(18),
	13392: uint8(18),
	13393: uint8(18),
	13394: uint8(18),
	13395: uint8(18),
	13396: uint8(18),
	13408: uint8(15),
	13409: uint8(15),
	13410: uint8(15),
	13411: uint8(15),
	13412: uint8(15),
	13413: uint8(15),
	13414: uint8(15),
	13415: uint8(15),
	13416: uint8(15),
	13417: uint8(15),
	13418: uint8(15),
	13419: uint8(15),
	13420: uint8(15),
	13421: uint8(15),
	13422: uint8(15),
	13423: uint8(15),
	13424: uint8(15),
	13425: uint8(15),
	13427: uint8(15),
	13428: uint8(15),
	13429: uint8(15),
	13430: uint8(15),
	13431: uint8(15),
	13432: uint8(15),
	13433: uint8(15),
	13434: uint8(15),
	13435: uint8(15),
	13436: uint8(15),
	13437: uint8(15),
	13438: uint8(15),
	13439: uint8(15),
	13440: uint8(15),
	13441: uint8(15),
	13442: uint8(15),
	13443: uint8(15),
	13444: uint8(15),
	13445: uint8(15),
	13446: uint8(15),
	13447: uint8(15),
	13448: uint8(15),
	13449: uint8(15),
	13450: uint8(15),
	13451: uint8(15),
	13452: uint8(127),
	13453: uint8(127),
	13454: uint8(127),
	13455: uint8(95),
	13456: uint8(95),
	13457: uint8(95),
	13458: uint8(127),
	13459: uint8(127),
	13460: uint8(95),
	13461: uint8(127),
	13462: uint8(95),
	13463: uint8(95),
	13464: uint8(3),
	13465: uint8(3),
	13466: uint8(3),
	13467: uint8(3),
	13468: uint8(3),
	13469: uint8(3),
	13470: uint8(95),
	13471: uint8(15),
	13472: uint8(15),
	13473: uint8(95),
	13504: uint8(15),
	13505: uint8(15),
	13506: uint8(15),
	13507: uint8(15),
	13508: uint8(15),
	13509: uint8(15),
	13510: uint8(15),
	13512: uint8(15),
	13514: uint8(15),
	13515: uint8(15),
	13516: uint8(15),
	13517: uint8(15),
	13519: uint8(15),
	13520: uint8(15),
	13521: uint8(15),
	13522: uint8(15),
	13523: uint8(15),
	13524: uint8(15),
	13525: uint8(15),
	13526: uint8(15),
	13527: uint8(15),
	13528: uint8(15),
	13529: uint8(15),
	13530: uint8(15),
	13531: uint8(15),
	13532: uint8(15),
	13533: uint8(15),
	13535: uint8(15),
	13536: uint8(15),
	13537: uint8(15),
	13538: uint8(15),
	13539: uint8(15),
	13540: uint8(15),
	13541: uint8(15),
	13542: uint8(15),
	13543: uint8(15),
	13544: uint8(15),
	13545: uint8(3),
	13552: uint8(15),
	13553: uint8(15),
	13554: uint8(15),
	13555: uint8(15),
	13556: uint8(15),
	13557: uint8(15),
	13558: uint8(15),
	13559: uint8(15),
	13560: uint8(15),
	13561: uint8(15),
	13562: uint8(15),
	13563: uint8(15),
	13564: uint8(15),
	13565: uint8(15),
	13566: uint8(15),
	13567: uint8(15),
	13568: uint8(15),
	13569: uint8(15),
	13570: uint8(15),
	13571: uint8(15),
	13572: uint8(15),
	13573: uint8(15),
	13574: uint8(15),
	13575: uint8(15),
	13576: uint8(15),
	13577: uint8(15),
	13578: uint8(15),
	13579: uint8(15),
	13580: uint8(15),
	13581: uint8(15),
	13582: uint8(15),
	13583: uint8(15),
	13584: uint8(15),
	13585: uint8(15),
	13586: uint8(15),
	13587: uint8(15),
	13588: uint8(15),
	13589: uint8(15),
	13590: uint8(15),
	13591: uint8(15),
	13592: uint8(15),
	13593: uint8(15),
	13594: uint8(15),
	13595: uint8(15),
	13596: uint8(15),
	13597: uint8(15),
	13598: uint8(15),
	13599: uint8(95),
	13600: uint8(127),
	13601: uint8(127),
	13602: uint8(127),
	13603: uint8(95),
	13604: uint8(95),
	13605: uint8(95),
	13606: uint8(95),
	13607: uint8(95),
	13608: uint8(95),
	13609: uint8(95),
	13610: uint8(95),
	13616: uint8(9),
	13617: uint8(9),
	13618: uint8(9),
	13619: uint8(9),
	13620: uint8(9),
	13621: uint8(9),
	13622: uint8(9),
	13623: uint8(9),
	13624: uint8(9),
	13625: uint8(9),
	13632: uint8(95),
	13633: uint8(95),
	13634: uint8(127),
	13635: uint8(127),
	13637: uint8(15),
	13638: uint8(15),
	13639: uint8(15),
	13640: uint8(15),
	13641: uint8(15),
	13642: uint8(15),
	13643: uint8(15),
	13644: uint8(15),
	13647: uint8(15),
	13648: uint8(15),
	13651: uint8(15),
	13652: uint8(15),
	13653: uint8(15),
	13654: uint8(15),
	13655: uint8(15),
	13656: uint8(15),
	13657: uint8(15),
	13658: uint8(15),
	13659: uint8(15),
	13660: uint8(15),
	13661: uint8(15),
	13662: uint8(15),
	13663: uint8(15),
	13664: uint8(15),
	13665: uint8(15),
	13666: uint8(15),
	13667: uint8(15),
	13668: uint8(15),
	13669: uint8(15),
	13670: uint8(15),
	13671: uint8(15),
	13672: uint8(15),
	13674: uint8(15),
	13675: uint8(15),
	13676: uint8(15),
	13677: uint8(15),
	13678: uint8(15),
	13679: uint8(15),
	13680: uint8(15),
	13682: uint8(15),
	13683: uint8(15),
	13685: uint8(15),
	13686: uint8(15),
	13687: uint8(15),
	13688: uint8(15),
	13689: uint8(15),
	13691: uint8(95),
	13692: uint8(95),
	13693: uint8(15),
	13694: uint8(127),
	13695: uint8(127),
	13696: uint8(95),
	13697: uint8(127),
	13698: uint8(127),
	13699: uint8(127),
	13700: uint8(127),
	13703: uint8(127),
	13704: uint8(127),
	13707: uint8(127),
	13708: uint8(127),
	13709: uint8(127),
	13712: uint8(15),
	13719: uint8(127),
	13725: uint8(15),
	13726: uint8(15),
	13727: uint8(15),
	13728: uint8(15),
	13729: uint8(15),
	13730: uint8(127),
	13731: uint8(127),
	13734: uint8(95),
	13735: uint8(95),
	13736: uint8(95),
	13737: uint8(95),
	13738: uint8(95),
	13739: uint8(95),
	13740: uint8(95),
	13744: uint8(95),
	13745: uint8(95),
	13746: uint8(95),
	13747: uint8(95),
	13748: uint8(95),
	13760: uint8(15),
	13761: uint8(15),
	13762: uint8(15),
	13763: uint8(15),
	13764: uint8(15),
	13765: uint8(15),
	13766: uint8(15),
	13767: uint8(15),
	13768: uint8(15),
	13769: uint8(15),
	13771: uint8(15),
	13774: uint8(15),
	13776: uint8(15),
	13777: uint8(15),
	13778: uint8(15),
	13779: uint8(15),
	13780: uint8(15),
	13781: uint8(15),
	13782: uint8(15),
	13783: uint8(15),
	13784: uint8(15),
	13785: uint8(15),
	13786: uint8(15),
	13787: uint8(15),
	13788: uint8(15),
	13789: uint8(15),
	13790: uint8(15),
	13791: uint8(15),
	13792: uint8(15),
	13793: uint8(15),
	13794: uint8(15),
	13795: uint8(15),
	13796: uint8(15),
	13797: uint8(15),
	13798: uint8(15),
	13799: uint8(15),
	13800: uint8(15),
	13801: uint8(15),
	13802: uint8(15),
	13803: uint8(15),
	13804: uint8(15),
	13805: uint8(15),
	13806: uint8(15),
	13807: uint8(15),
	13808: uint8(15),
	13809: uint8(15),
	13810: uint8(15),
	13811: uint8(15),
	13812: uint8(15),
	13813: uint8(15),
	13815: uint8(15),
	13816: uint8(127),
	13817: uint8(127),
	13818: uint8(127),
	13819: uint8(95),
	13820: uint8(95),
	13821: uint8(95),
	13822: uint8(95),
	13823: uint8(95),
	13824: uint8(95),
	13826: uint8(127),
	13829: uint8(127),
	13831: uint8(127),
	13832: uint8(127),
	13833: uint8(127),
	13834: uint8(127),
	13836: uint8(127),
	13837: uint8(127),
	13838: uint8(95),
	13839: uint8(127),
	13840: uint8(95),
	13841: uint8(15),
	13842: uint8(95),
	13843: uint8(15),
	13844: uint8(3),
	13845: uint8(3),
	13847: uint8(3),
	13848: uint8(3),
	13857: uint8(95),
	13858: uint8(95),
	13888: uint8(15),
	13889: uint8(15),
	13890: uint8(15),
	13891: uint8(15),
	13892: uint8(15),
	13893: uint8(15),
	13894: uint8(15),
	13895: uint8(15),
	13896: uint8(15),
	13897: uint8(15),
	13898: uint8(15),
	13899: uint8(15),
	13900: uint8(15),
	13901: uint8(15),
	13902: uint8(15),
	13903: uint8(15),
	13904: uint8(15),
	13905: uint8(15),
	13906: uint8(15),
	13907: uint8(15),
	13908: uint8(15),
	13909: uint8(127),
	13910: uint8(127),
	13911: uint8(127),
	13912: uint8(95),
	13913: uint8(95),
	13914: uint8(95),
	13915: uint8(95),
	13916: uint8(95),
	13917: uint8(95),
	13918: uint8(95),
	13919: uint8(95),
	13920: uint8(127),
	13921: uint8(127),
	13922: uint8(95),
	13923: uint8(95),
	13924: uint8(95),
	13925: uint8(127),
	13926: uint8(95),
	13927: uint8(15),
	13928: uint8(15),
	13929: uint8(15),
	13930: uint8(15),
	13931: uint8(3),
	13932: uint8(3),
	13933: uint8(3),
	13934: uint8(3),
	13935: uint8(3),
	13936: uint8(9),
	13937: uint8(9),
	13938: uint8(9),
	13939: uint8(9),
	13940: uint8(9),
	13941: uint8(9),
	13942: uint8(9),
	13943: uint8(9),
	13944: uint8(9),
	13945: uint8(9),
	13946: uint8(3),
	13947: uint8(3),
	13949: uint8(3),
	13950: uint8(95),
	13951: uint8(15),
	13952: uint8(15),
	13953: uint8(15),
	13984: uint8(15),
	13985: uint8(15),
	13986: uint8(15),
	13987: uint8(15),
	13988: uint8(15),
	13989: uint8(15),
	13990: uint8(15),
	13991: uint8(15),
	13992: uint8(15),
	13993: uint8(15),
	13994: uint8(15),
	13995: uint8(15),
	13996: uint8(15),
	13997: uint8(15),
	13998: uint8(15),
	13999: uint8(15),
	14000: uint8(127),
	14001: uint8(127),
	14002: uint8(127),
	14003: uint8(95),
	14004: uint8(95),
	14005: uint8(95),
	14006: uint8(95),
	14007: uint8(95),
	14008: uint8(95),
	14009: uint8(127),
	14010: uint8(95),
	14011: uint8(127),
	14012: uint8(127),
	14013: uint8(127),
	14014: uint8(127),
	14015: uint8(95),
	14016: uint8(95),
	14017: uint8(127),
	14018: uint8(95),
	14019: uint8(95),
	14020: uint8(15),
	14021: uint8(15),
	14022: uint8(3),
	14023: uint8(15),
	14032: uint8(9),
	14033: uint8(9),
	14034: uint8(9),
	14035: uint8(9),
	14036: uint8(9),
	14037: uint8(9),
	14038: uint8(9),
	14039: uint8(9),
	14040: uint8(9),
	14041: uint8(9),
	14048: uint8(15),
	14049: uint8(15),
	14050: uint8(15),
	14051: uint8(15),
	14052: uint8(15),
	14053: uint8(15),
	14054: uint8(15),
	14055: uint8(15),
	14056: uint8(15),
	14057: uint8(15),
	14058: uint8(15),
	14059: uint8(15),
	14060: uint8(15),
	14061: uint8(15),
	14062: uint8(15),
	14063: uint8(127),
	14064: uint8(127),
	14065: uint8(127),
	14066: uint8(95),
	14067: uint8(95),
	14068: uint8(95),
	14069: uint8(95),
	14072: uint8(127),
	14073: uint8(127),
	14074: uint8(127),
	14075: uint8(127),
	14076: uint8(95),
	14077: uint8(95),
	14078: uint8(127),
	14079: uint8(95),
	14080: uint8(95),
	14081: uint8(3),
	14082: uint8(3),
	14083: uint8(3),
	14084: uint8(3),
	14085: uint8(3),
	14086: uint8(3),
	14087: uint8(3),
	14088: uint8(3),
	14089: uint8(3),
	14090: uint8(3),
	14091: uint8(3),
	14092: uint8(3),
	14093: uint8(3),
	14094: uint8(3),
	14095: uint8(3),
	14096: uint8(3),
	14097: uint8(3),
	14098: uint8(3),
	14099: uint8(3),
	14100: uint8(3),
	14101: uint8(3),
	14102: uint8(3),
	14103: uint8(3),
	14104: uint8(15),
	14105: uint8(15),
	14106: uint8(15),
	14107: uint8(15),
	14108: uint8(95),
	14109: uint8(95),
	14112: uint8(15),
	14113: uint8(15),
	14114: uint8(15),
	14115: uint8(15),
	14116: uint8(15),
	14117: uint8(15),
	14118: uint8(15),
	14119: uint8(15),
	14120: uint8(15),
	14121: uint8(15),
	14122: uint8(15),
	14123: uint8(15),
	14124: uint8(15),
	14125: uint8(15),
	14126: uint8(15),
	14127: uint8(15),
	14128: uint8(127),
	14129: uint8(127),
	14130: uint8(127),
	14131: uint8(95),
	14132: uint8(95),
	14133: uint8(95),
	14134: uint8(95),
	14135: uint8(95),
	14136: uint8(95),
	14137: uint8(95),
	14138: uint8(95),
	14139: uint8(127),
	14140: uint8(127),
	14141: uint8(95),
	14142: uint8(127),
	14143: uint8(95),
	14144: uint8(95),
	14145: uint8(3),
	14146: uint8(3),
	14147: uint8(3),
	14148: uint8(15),
	14160: uint8(9),
	14161: uint8(9),
	14162: uint8(9),
	14163: uint8(9),
	14164: uint8(9),
	14165: uint8(9),
	14166: uint8(9),
	14167: uint8(9),
	14168: uint8(9),
	14169: uint8(9),
	14176: uint8(3),
	14177: uint8(3),
	14178: uint8(3),
	14179: uint8(3),
	14180: uint8(3),
	14181: uint8(3),
	14182: uint8(3),
	14183: uint8(3),
	14184: uint8(3),
	14185: uint8(3),
	14186: uint8(3),
	14187: uint8(3),
	14188: uint8(3),
	14208: uint8(15),
	14209: uint8(15),
	14210: uint8(15),
	14211: uint8(15),
	14212: uint8(15),
	14213: uint8(15),
	14214: uint8(15),
	14215: uint8(15),
	14216: uint8(15),
	14217: uint8(15),
	14218: uint8(15),
	14219: uint8(95),
	14220: uint8(127),
	14221: uint8(95),
	14222: uint8(127),
	14223: uint8(127),
	14224: uint8(95),
	14225: uint8(95),
	14226: uint8(95),
	14227: uint8(95),
	14228: uint8(95),
	14229: uint8(95),
	14230: uint8(127),
	14231: uint8(95),
	14232: uint8(15),
	14233: uint8(3),
	14240: uint8(9),
	14241: uint8(9),
	14242: uint8(9),
	14243: uint8(9),
	14244: uint8(9),
	14245: uint8(9),
	14246: uint8(9),
	14247: uint8(9),
	14248: uint8(9),
	14249: uint8(9),
	14256: uint8(9),
	14257: uint8(9),
	14258: uint8(9),
	14259: uint8(9),
	14260: uint8(9),
	14261: uint8(9),
	14262: uint8(9),
	14263: uint8(9),
	14264: uint8(9),
	14265: uint8(9),
	14266: uint8(9),
	14267: uint8(9),
	14268: uint8(9),
	14269: uint8(9),
	14270: uint8(9),
	14271: uint8(9),
	14272: uint8(9),
	14273: uint8(9),
	14274: uint8(9),
	14275: uint8(9),
	14304: uint8(15),
	14305: uint8(15),
	14306: uint8(15),
	14307: uint8(15),
	14308: uint8(15),
	14309: uint8(15),
	14310: uint8(15),
	14311: uint8(15),
	14312: uint8(15),
	14313: uint8(15),
	14314: uint8(15),
	14315: uint8(15),
	14316: uint8(15),
	14317: uint8(15),
	14318: uint8(15),
	14319: uint8(15),
	14320: uint8(15),
	14321: uint8(15),
	14322: uint8(15),
	14323: uint8(15),
	14324: uint8(15),
	14325: uint8(15),
	14326: uint8(15),
	14327: uint8(15),
	14328: uint8(15),
	14329: uint8(15),
	14330: uint8(15),
	14333: uint8(95),
	14334: uint8(127),
	14335: uint8(95),
	14336: uint8(127),
	14337: uint8(127),
	14338: uint8(95),
	14339: uint8(95),
	14340: uint8(95),
	14341: uint8(95),
	14342: uint8(127),
	14343: uint8(95),
	14344: uint8(95),
	14345: uint8(95),
	14346: uint8(95),
	14347: uint8(95),
	14352: uint8(9),
	14353: uint8(9),
	14354: uint8(9),
	14355: uint8(9),
	14356: uint8(9),
	14357: uint8(9),
	14358: uint8(9),
	14359: uint8(9),
	14360: uint8(9),
	14361: uint8(9),
	14362: uint8(18),
	14363: uint8(18),
	14364: uint8(3),
	14365: uint8(3),
	14366: uint8(3),
	14367: uint8(14),
	14368: uint8(15),
	14369: uint8(15),
	14370: uint8(15),
	14371: uint8(15),
	14372: uint8(15),
	14373: uint8(15),
	14374: uint8(15),
	14400: uint8(15),
	14401: uint8(15),
	14402: uint8(15),
	14403: uint8(15),
	14404: uint8(15),
	14405: uint8(15),
	14406: uint8(15),
	14407: uint8(15),
	14408: uint8(15),
	14409: uint8(15),
	14410: uint8(15),
	14411: uint8(15),
	14412: uint8(127),
	14413: uint8(127),
	14414: uint8(127),
	14415: uint8(95),
	14416: uint8(95),
	14417: uint8(95),
	14418: uint8(95),
	14419: uint8(95),
	14420: uint8(95),
	14421: uint8(95),
	14422: uint8(95),
	14423: uint8(95),
	14424: uint8(127),
	14425: uint8(95),
	14426: uint8(95),
	14427: uint8(3),
	14432: uint8(10),
	14433: uint8(10),
	14434: uint8(10),
	14435: uint8(10),
	14436: uint8(10),
	14437: uint8(10),
	14438: uint8(10),
	14439: uint8(10),
	14440: uint8(10),
	14441: uint8(10),
	14442: uint8(10),
	14443: uint8(10),
	14444: uint8(10),
	14445: uint8(10),
	14446: uint8(10),
	14447: uint8(10),
	14448: uint8(10),
	14449: uint8(10),
	14450: uint8(10),
	14451: uint8(10),
	14452: uint8(10),
	14453: uint8(10),
	14454: uint8(10),
	14455: uint8(10),
	14456: uint8(10),
	14457: uint8(10),
	14458: uint8(10),
	14459: uint8(10),
	14460: uint8(10),
	14461: uint8(10),
	14462: uint8(10),
	14463: uint8(10),
	14464: uint8(13),
	14465: uint8(13),
	14466: uint8(13),
	14467: uint8(13),
	14468: uint8(13),
	14469: uint8(13),
	14470: uint8(13),
	14471: uint8(13),
	14472: uint8(13),
	14473: uint8(13),
	14474: uint8(13),
	14475: uint8(13),
	14476: uint8(13),
	14477: uint8(13),
	14478: uint8(13),
	14479: uint8(13),
	14480: uint8(13),
	14481: uint8(13),
	14482: uint8(13),
	14483: uint8(13),
	14484: uint8(13),
	14485: uint8(13),
	14486: uint8(13),
	14487: uint8(13),
	14488: uint8(13),
	14489: uint8(13),
	14490: uint8(13),
	14491: uint8(13),
	14492: uint8(13),
	14493: uint8(13),
	14494: uint8(13),
	14495: uint8(13),
	14496: uint8(9),
	14497: uint8(9),
	14498: uint8(9),
	14499: uint8(9),
	14500: uint8(9),
	14501: uint8(9),
	14502: uint8(9),
	14503: uint8(9),
	14504: uint8(9),
	14505: uint8(9),
	14506: uint8(18),
	14507: uint8(18),
	14508: uint8(18),
	14509: uint8(18),
	14510: uint8(18),
	14511: uint8(18),
	14512: uint8(18),
	14513: uint8(18),
	14514: uint8(18),
	14527: uint8(15),
	14528: uint8(15),
	14529: uint8(15),
	14530: uint8(15),
	14531: uint8(15),
	14532: uint8(15),
	14533: uint8(15),
	14534: uint8(15),
	14537: uint8(15),
	14540: uint8(15),
	14541: uint8(15),
	14542: uint8(15),
	14543: uint8(15),
	14544: uint8(15),
	14545: uint8(15),
	14546: uint8(15),
	14547: uint8(15),
	14549: uint8(15),
	14550: uint8(15),
	14552: uint8(15),
	14553: uint8(15),
	14554: uint8(15),
	14555: uint8(15),
	14556: uint8(15),
	14557: uint8(15),
	14558: uint8(15),
	14559: uint8(15),
	14560: uint8(15),
	14561: uint8(15),
	14562: uint8(15),
	14563: uint8(15),
	14564: uint8(15),
	14565: uint8(15),
	14566: uint8(15),
	14567: uint8(15),
	14568: uint8(15),
	14569: uint8(15),
	14570: uint8(15),
	14571: uint8(15),
	14572: uint8(15),
	14573: uint8(15),
	14574: uint8(15),
	14575: uint8(15),
	14576: uint8(127),
	14577: uint8(127),
	14578: uint8(127),
	14579: uint8(127),
	14580: uint8(127),
	14581: uint8(127),
	14583: uint8(127),
	14584: uint8(127),
	14587: uint8(95),
	14588: uint8(95),
	14589: uint8(127),
	14590: uint8(95),
	14591: uint8(15),
	14592: uint8(127),
	14593: uint8(15),
	14594: uint8(127),
	14595: uint8(95),
	14596: uint8(3),
	14597: uint8(3),
	14598: uint8(3),
	14608: uint8(9),
	14609: uint8(9),
	14610: uint8(9),
	14611: uint8(9),
	14612: uint8(9),
	14613: uint8(9),
	14614: uint8(9),
	14615: uint8(9),
	14616: uint8(9),
	14617: uint8(9),
	14624: uint8(15),
	14625: uint8(15),
	14626: uint8(15),
	14627: uint8(15),
	14628: uint8(15),
	14629: uint8(15),
	14630: uint8(15),
	14631: uint8(15),
	14634: uint8(15),
	14635: uint8(15),
	14636: uint8(15),
	14637: uint8(15),
	14638: uint8(15),
	14639: uint8(15),
	14640: uint8(15),
	14641: uint8(15),
	14642: uint8(15),
	14643: uint8(15),
	14644: uint8(15),
	14645: uint8(15),
	14646: uint8(15),
	14647: uint8(15),
	14648: uint8(15),
	14649: uint8(15),
	14650: uint8(15),
	14651: uint8(15),
	14652: uint8(15),
	14653: uint8(15),
	14654: uint8(15),
	14655: uint8(15),
	14656: uint8(15),
	14657: uint8(15),
	14658: uint8(15),
	14659: uint8(15),
	14660: uint8(15),
	14661: uint8(15),
	14662: uint8(15),
	14663: uint8(15),
	14664: uint8(15),
	14665: uint8(15),
	14666: uint8(15),
	14667: uint8(15),
	14668: uint8(15),
	14669: uint8(15),
	14670: uint8(15),
	14671: uint8(15),
	14672: uint8(15),
	14673: uint8(127),
	14674: uint8(127),
	14675: uint8(127),
	14676: uint8(95),
	14677: uint8(95),
	14678: uint8(95),
	14679: uint8(95),
	14682: uint8(95),
	14683: uint8(95),
	14684: uint8(127),
	14685: uint8(127),
	14686: uint8(127),
	14687: uint8(127),
	14688: uint8(95),
	14689: uint8(15),
	14690: uint8(3),
	14691: uint8(15),
	14692: uint8(127),
	14720: uint8(15),
	14721: uint8(95),
	14722: uint8(95),
	14723: uint8(95),
	14724: uint8(95),
	14725: uint8(95),
	14726: uint8(95),
	14727: uint8(95),
	14728: uint8(95),
	14729: uint8(95),
	14730: uint8(95),
	14731: uint8(15),
	14732: uint8(15),
	14733: uint8(15),
	14734: uint8(15),
	14735: uint8(15),
	14736: uint8(15),
	14737: uint8(15),
	14738: uint8(15),
	14739: uint8(15),
	14740: uint8(15),
	14741: uint8(15),
	14742: uint8(15),
	14743: uint8(15),
	14744: uint8(15),
	14745: uint8(15),
	14746: uint8(15),
	14747: uint8(15),
	14748: uint8(15),
	14749: uint8(15),
	14750: uint8(15),
	14751: uint8(15),
	14752: uint8(15),
	14753: uint8(15),
	14754: uint8(15),
	14755: uint8(15),
	14756: uint8(15),
	14757: uint8(15),
	14758: uint8(15),
	14759: uint8(15),
	14760: uint8(15),
	14761: uint8(15),
	14762: uint8(15),
	14763: uint8(15),
	14764: uint8(15),
	14765: uint8(15),
	14766: uint8(15),
	14767: uint8(15),
	14768: uint8(15),
	14769: uint8(15),
	14770: uint8(15),
	14771: uint8(95),
	14772: uint8(95),
	14773: uint8(95),
	14774: uint8(95),
	14775: uint8(95),
	14776: uint8(95),
	14777: uint8(127),
	14778: uint8(15),
	14779: uint8(95),
	14780: uint8(95),
	14781: uint8(95),
	14782: uint8(95),
	14783: uint8(3),
	14784: uint8(3),
	14785: uint8(3),
	14786: uint8(3),
	14787: uint8(3),
	14788: uint8(3),
	14789: uint8(3),
	14790: uint8(3),
	14791: uint8(95),
	14800: uint8(15),
	14801: uint8(95),
	14802: uint8(95),
	14803: uint8(95),
	14804: uint8(95),
	14805: uint8(95),
	14806: uint8(95),
	14807: uint8(127),
	14808: uint8(127),
	14809: uint8(95),
	14810: uint8(95),
	14811: uint8(95),
	14812: uint8(15),
	14813: uint8(15),
	14814: uint8(15),
	14815: uint8(15),
	14816: uint8(15),
	14817: uint8(15),
	14818: uint8(15),
	14819: uint8(15),
	14820: uint8(15),
	14821: uint8(15),
	14822: uint8(15),
	14823: uint8(15),
	14824: uint8(15),
	14825: uint8(15),
	14826: uint8(95),
	14827: uint8(95),
	14828: uint8(95),
	14829: uint8(95),
	14830: uint8(95),
	14831: uint8(95),
	14832: uint8(95),
	14833: uint8(95),
	14834: uint8(95),
	14835: uint8(95),
	14836: uint8(95),
	14837: uint8(95),
	14838: uint8(95),
	14839: uint8(127),
	14840: uint8(95),
	14841: uint8(95),
	14842: uint8(3),
	14843: uint8(3),
	14844: uint8(3),
	14845: uint8(15),
	14846: uint8(3),
	14847: uint8(3),
	14848: uint8(3),
	14849: uint8(3),
	14850: uint8(3),
	14864: uint8(15),
	14865: uint8(15),
	14866: uint8(15),
	14867: uint8(15),
	14868: uint8(15),
	14869: uint8(15),
	14870: uint8(15),
	14871: uint8(15),
	14872: uint8(15),
	14873: uint8(15),
	14874: uint8(15),
	14875: uint8(15),
	14876: uint8(15),
	14877: uint8(15),
	14878: uint8(15),
	14879: uint8(15),
	14880: uint8(3),
	14881: uint8(3),
	14882: uint8(3),
	14883: uint8(3),
	14884: uint8(3),
	14885: uint8(3),
	14886: uint8(3),
	14887: uint8(3),
	14888: uint8(3),
	14889: uint8(3),
	14912: uint8(15),
	14913: uint8(3),
	14928: uint8(9),
	14929: uint8(9),
	14930: uint8(9),
	14931: uint8(9),
	14932: uint8(9),
	14933: uint8(9),
	14934: uint8(9),
	14935: uint8(9),
	14936: uint8(9),
	14937: uint8(9),
	14944: uint8(15),
	14945: uint8(15),
	14946: uint8(15),
	14947: uint8(15),
	14948: uint8(15),
	14949: uint8(15),
	14950: uint8(15),
	14951: uint8(15),
	14952: uint8(15),
	14954: uint8(15),
	14955: uint8(15),
	14956: uint8(15),
	14957: uint8(15),
	14958: uint8(15),
	14959: uint8(15),
	14960: uint8(15),
	14961: uint8(15),
	14962: uint8(15),
	14963: uint8(15),
	14964: uint8(15),
	14965: uint8(15),
	14966: uint8(15),
	14967: uint8(15),
	14968: uint8(15),
	14969: uint8(15),
	14970: uint8(15),
	14971: uint8(15),
	14972: uint8(15),
	14973: uint8(15),
	14974: uint8(15),
	14975: uint8(15),
	14976: uint8(15),
	14977: uint8(15),
	14978: uint8(15),
	14979: uint8(15),
	14980: uint8(15),
	14981: uint8(15),
	14982: uint8(15),
	14983: uint8(15),
	14984: uint8(15),
	14985: uint8(15),
	14986: uint8(15),
	14987: uint8(15),
	14988: uint8(15),
	14989: uint8(15),
	14990: uint8(15),
	14991: uint8(127),
	14992: uint8(95),
	14993: uint8(95),
	14994: uint8(95),
	14995: uint8(95),
	14996: uint8(95),
	14997: uint8(95),
	14998: uint8(95),
	15000: uint8(95),
	15001: uint8(95),
	15002: uint8(95),
	15003: uint8(95),
	15004: uint8(95),
	15005: uint8(95),
	15006: uint8(127),
	15007: uint8(95),
	15008: uint8(15),
	15009: uint8(3),
	15010: uint8(3),
	15011: uint8(3),
	15012: uint8(3),
	15013: uint8(3),
	15024: uint8(9),
	15025: uint8(9),
	15026: uint8(9),
	15027: uint8(9),
	15028: uint8(9),
	15029: uint8(9),
	15030: uint8(9),
	15031: uint8(9),
	15032: uint8(9),
	15033: uint8(9),
	15034: uint8(18),
	15035: uint8(18),
	15036: uint8(18),
	15037: uint8(18),
	15038: uint8(18),
	15039: uint8(18),
	15040: uint8(18),
	15041: uint8(18),
	15042: uint8(18),
	15043: uint8(18),
	15044: uint8(18),
	15045: uint8(18),
	15046: uint8(18),
	15047: uint8(18),
	15048: uint8(18),
	15049: uint8(18),
	15050: uint8(18),
	15051: uint8(18),
	15052: uint8(18),
	15056: uint8(3),
	15057: uint8(3),
	15058: uint8(15),
	15059: uint8(15),
	15060: uint8(15),
	15061: uint8(15),
	15062: uint8(15),
	15063: uint8(15),
	15064: uint8(15),
	15065: uint8(15),
	15066: uint8(15),
	15067: uint8(15),
	15068: uint8(15),
	15069: uint8(15),
	15070: uint8(15),
	15071: uint8(15),
	15072: uint8(15),
	15073: uint8(15),
	15074: uint8(15),
	15075: uint8(15),
	15076: uint8(15),
	15077: uint8(15),
	15078: uint8(15),
	15079: uint8(15),
	15080: uint8(15),
	15081: uint8(15),
	15082: uint8(15),
	15083: uint8(15),
	15084: uint8(15),
	15085: uint8(15),
	15086: uint8(15),
	15087: uint8(15),
	15090: uint8(95),
	15091: uint8(95),
	15092: uint8(95),
	15093: uint8(95),
	15094: uint8(95),
	15095: uint8(95),
	15096: uint8(95),
	15097: uint8(95),
	15098: uint8(95),
	15099: uint8(95),
	15100: uint8(95),
	15101: uint8(95),
	15102: uint8(95),
	15103: uint8(95),
	15104: uint8(95),
	15105: uint8(95),
	15106: uint8(95),
	15107: uint8(95),
	15108: uint8(95),
	15109: uint8(95),
	15110: uint8(95),
	15111: uint8(95),
	15113: uint8(127),
	15114: uint8(95),
	15115: uint8(95),
	15116: uint8(95),
	15117: uint8(95),
	15118: uint8(95),
	15119: uint8(95),
	15120: uint8(95),
	15121: uint8(127),
	15122: uint8(95),
	15123: uint8(95),
	15124: uint8(127),
	15125: uint8(95),
	15126: uint8(95),
	15136: uint8(15),
	15137: uint8(15),
	15138: uint8(15),
	15139: uint8(15),
	15140: uint8(15),
	15141: uint8(15),
	15142: uint8(15),
	15144: uint8(15),
	15145: uint8(15),
	15147: uint8(15),
	15148: uint8(15),
	15149: uint8(15),
	15150: uint8(15),
	15151: uint8(15),
	15152: uint8(15),
	15153: uint8(15),
	15154: uint8(15),
	15155: uint8(15),
	15156: uint8(15),
	15157: uint8(15),
	15158: uint8(15),
	15159: uint8(15),
	15160: uint8(15),
	15161: uint8(15),
	15162: uint8(15),
	15163: uint8(15),
	15164: uint8(15),
	15165: uint8(15),
	15166: uint8(15),
	15167: uint8(15),
	15168: uint8(15),
	15169: uint8(15),
	15170: uint8(15),
	15171: uint8(15),
	15172: uint8(15),
	15173: uint8(15),
	15174: uint8(15),
	15175: uint8(15),
	15176: uint8(15),
	15177: uint8(15),
	15178: uint8(15),
	15179: uint8(15),
	15180: uint8(15),
	15181: uint8(15),
	15182: uint8(15),
	15183: uint8(15),
	15184: uint8(15),
	15185: uint8(95),
	15186: uint8(95),
	15187: uint8(95),
	15188: uint8(95),
	15189: uint8(95),
	15190: uint8(95),
	15194: uint8(95),
	15196: uint8(95),
	15197: uint8(95),
	15199: uint8(95),
	15200: uint8(95),
	15201: uint8(95),
	15202: uint8(95),
	15203: uint8(95),
	15204: uint8(95),
	15205: uint8(95),
	15206: uint8(15),
	15207: uint8(95),
	15216: uint8(9),
	15217: uint8(9),
	15218: uint8(9),
	15219: uint8(9),
	15220: uint8(9),
	15221: uint8(9),
	15222: uint8(9),
	15223: uint8(9),
	15224: uint8(9),
	15225: uint8(9),
	15232: uint8(15),
	15233: uint8(15),
	15234: uint8(15),
	15235: uint8(15),
	15236: uint8(15),
	15237: uint8(15),
	15239: uint8(15),
	15240: uint8(15),
	15242: uint8(15),
	15243: uint8(15),
	15244: uint8(15),
	15245: uint8(15),
	15246: uint8(15),
	15247: uint8(15),
	15248: uint8(15),
	15249: uint8(15),
	15250: uint8(15),
	15251: uint8(15),
	15252: uint8(15),
	15253: uint8(15),
	15254: uint8(15),
	15255: uint8(15),
	15256: uint8(15),
	15257: uint8(15),
	15258: uint8(15),
	15259: uint8(15),
	15260: uint8(15),
	15261: uint8(15),
	15262: uint8(15),
	15263: uint8(15),
	15264: uint8(15),
	15265: uint8(15),
	15266: uint8(15),
	15267: uint8(15),
	15268: uint8(15),
	15269: uint8(15),
	15270: uint8(15),
	15271: uint8(15),
	15272: uint8(15),
	15273: uint8(15),
	15274: uint8(127),
	15275: uint8(127),
	15276: uint8(127),
	15277: uint8(127),
	15278: uint8(127),
	15280: uint8(95),
	15281: uint8(95),
	15283: uint8(127),
	15284: uint8(127),
	15285: uint8(95),
	15286: uint8(127),
	15287: uint8(95),
	15288: uint8(15),
	15296: uint8(9),
	15297: uint8(9),
	15298: uint8(9),
	15299: uint8(9),
	15300: uint8(9),
	15301: uint8(9),
	15302: uint8(9),
	15303: uint8(9),
	15304: uint8(9),
	15305: uint8(9),
	15328: uint8(15),
	15329: uint8(15),
	15330: uint8(15),
	15331: uint8(15),
	15332: uint8(15),
	15333: uint8(15),
	15334: uint8(15),
	15335: uint8(15),
	15336: uint8(15),
	15337: uint8(15),
	15338: uint8(15),
	15339: uint8(15),
	15340: uint8(15),
	15341: uint8(15),
	15342: uint8(15),
	15343: uint8(15),
	15344: uint8(15),
	15345: uint8(15),
	15346: uint8(15),
	15347: uint8(95),
	15348: uint8(95),
	15349: uint8(127),
	15350: uint8(127),
	15351: uint8(3),
	15352: uint8(3),
	15360: uint8(95),
	15361: uint8(95),
	15362: uint8(15),
	15363: uint8(127),
	15364: uint8(15),
	15365: uint8(15),
	15366: uint8(15),
	15367: uint8(15),
	15368: uint8(15),
	15369: uint8(15),
	15370: uint8(15),
	15371: uint8(15),
	15372: uint8(15),
	15373: uint8(15),
	15374: uint8(15),
	15375: uint8(15),
	15376: uint8(15),
	15378: uint8(15),
	15379: uint8(15),
	15380: uint8(15),
	15381: uint8(15),
	15382: uint8(15),
	15383: uint8(15),
	15384: uint8(15),
	15385: uint8(15),
	15386: uint8(15),
	15387: uint8(15),
	15388: uint8(15),
	15389: uint8(15),
	15390: uint8(15),
	15391: uint8(15),
	15392: uint8(15),
	15393: uint8(15),
	15394: uint8(15),
	15395: uint8(15),
	15396: uint8(15),
	15397: uint8(15),
	15398: uint8(15),
	15399: uint8(15),
	15400: uint8(15),
	15401: uint8(15),
	15402: uint8(15),
	15403: uint8(15),
	15404: uint8(15),
	15405: uint8(15),
	15406: uint8(15),
	15407: uint8(15),
	15408: uint8(15),
	15409: uint8(15),
	15410: uint8(15),
	15411: uint8(15),
	15412: uint8(127),
	15413: uint8(127),
	15414: uint8(95),
	15415: uint8(95),
	15416: uint8(95),
	15417: uint8(95),
	15418: uint8(95),
	15422: uint8(127),
	15423: uint8(127),
	15424: uint8(95),
	15425: uint8(127),
	15426: uint8(95),
	15427: uint8(3),
	15428: uint8(3),
	15429: uint8(3),
	15430: uint8(3),
	15431: uint8(3),
	15432: uint8(3),
	15433: uint8(3),
	15434: uint8(3),
	15435: uint8(3),
	15436: uint8(3),
	15437: uint8(3),
	15438: uint8(3),
	15439: uint8(3),
	15440: uint8(9),
	15441: uint8(9),
	15442: uint8(9),
	15443: uint8(9),
	15444: uint8(9),
	15445: uint8(9),
	15446: uint8(9),
	15447: uint8(9),
	15448: uint8(9),
	15449: uint8(9),
	15450: uint8(95),
	15472: uint8(15),
	15488: uint8(18),
	15489: uint8(18),
	15490: uint8(18),
	15491: uint8(18),
	15492: uint8(18),
	15493: uint8(18),
	15494: uint8(18),
	15495: uint8(18),
	15496: uint8(18),
	15497: uint8(18),
	15498: uint8(18),
	15499: uint8(18),
	15500: uint8(18),
	15501: uint8(18),
	15502: uint8(18),
	15503: uint8(18),
	15504: uint8(18),
	15505: uint8(18),
	15506: uint8(18),
	15507: uint8(18),
	15508: uint8(18),
	15509: uint8(14),
	15510: uint8(14),
	15511: uint8(14),
	15512: uint8(14),
	15513: uint8(14),
	15514: uint8(14),
	15515: uint8(14),
	15516: uint8(14),
	15517: uint8(4),
	15518: uint8(4),
	15519: uint8(4),
	15520: uint8(4),
	15521: uint8(14),
	15522: uint8(14),
	15523: uint8(14),
	15524: uint8(14),
	15525: uint8(14),
	15526: uint8(14),
	15527: uint8(14),
	15528: uint8(14),
	15529: uint8(14),
	15530: uint8(14),
	15531: uint8(14),
	15532: uint8(14),
	15533: uint8(14),
	15534: uint8(14),
	15535: uint8(14),
	15536: uint8(14),
	15537: uint8(14),
	15551: uint8(3),
	15552: uint8(131),
	15553: uint8(131),
	15554: uint8(131),
	15555: uint8(131),
	15556: uint8(131),
	15557: uint8(131),
	15558: uint8(131),
	15559: uint8(131),
	15560: uint8(131),
	15561: uint8(131),
	15562: uint8(131),
	15563: uint8(131),
	15564: uint8(131),
	15565: uint8(131),
	15566: uint8(131),
	15568: uint8(3),
	15569: uint8(3),
	15570: uint8(3),
	15571: uint8(3),
	15572: uint8(3),
	15584: uint8(15),
	15585: uint8(15),
	15586: uint8(15),
	15587: uint8(15),
	15616: uint8(15),
	15617: uint8(15),
	15618: uint8(15),
	15619: uint8(15),
	15620: uint8(15),
	15621: uint8(15),
	15622: uint8(15),
	15623: uint8(15),
	15624: uint8(15),
	15625: uint8(15),
	15626: uint8(15),
	15627: uint8(15),
	15628: uint8(15),
	15629: uint8(15),
	15630: uint8(15),
	15631: uint8(15),
	15632: uint8(15),
	15633: uint8(3),
	15634: uint8(3),
	15648: uint8(15),
	15649: uint8(15),
	15650: uint8(15),
	15651: uint8(15),
	15652: uint8(15),
	15653: uint8(15),
	15654: uint8(15),
	15655: uint8(15),
	15656: uint8(15),
	15657: uint8(15),
	15658: uint8(15),
	15659: uint8(15),
	15660: uint8(15),
	15661: uint8(15),
	15662: uint8(15),
	15663: uint8(15),
	15664: uint8(17),
	15665: uint8(17),
	15666: uint8(17),
	15667: uint8(17),
	15668: uint8(17),
	15669: uint8(17),
	15670: uint8(17),
	15671: uint8(17),
	15672: uint8(17),
	15673: uint8(17),
	15674: uint8(17),
	15675: uint8(17),
	15676: uint8(17),
	15677: uint8(17),
	15678: uint8(17),
	15679: uint8(17),
	15680: uint8(95),
	15681: uint8(15),
	15682: uint8(15),
	15683: uint8(15),
	15684: uint8(15),
	15685: uint8(15),
	15686: uint8(15),
	15687: uint8(95),
	15688: uint8(95),
	15689: uint8(95),
	15690: uint8(95),
	15691: uint8(95),
	15692: uint8(95),
	15693: uint8(95),
	15694: uint8(95),
	15695: uint8(95),
	15696: uint8(95),
	15697: uint8(95),
	15698: uint8(95),
	15699: uint8(95),
	15700: uint8(95),
	15701: uint8(95),
	15712: uint8(15),
	15713: uint8(15),
	15714: uint8(15),
	15715: uint8(15),
	15716: uint8(15),
	15717: uint8(15),
	15718: uint8(15),
	15719: uint8(15),
	15720: uint8(15),
	15721: uint8(15),
	15722: uint8(15),
	15723: uint8(15),
	15724: uint8(15),
	15725: uint8(15),
	15726: uint8(15),
	15727: uint8(15),
	15728: uint8(15),
	15729: uint8(15),
	15730: uint8(15),
	15731: uint8(15),
	15732: uint8(15),
	15733: uint8(15),
	15734: uint8(15),
	15735: uint8(15),
	15736: uint8(15),
	15737: uint8(15),
	15738: uint8(15),
	15739: uint8(15),
	15740: uint8(15),
	15741: uint8(15),
	15742: uint8(95),
	15743: uint8(95),
	15744: uint8(95),
	15745: uint8(95),
	15746: uint8(95),
	15747: uint8(95),
	15748: uint8(95),
	15749: uint8(95),
	15750: uint8(95),
	15751: uint8(95),
	15752: uint8(95),
	15753: uint8(95),
	15754: uint8(127),
	15755: uint8(127),
	15756: uint8(127),
	15757: uint8(95),
	15758: uint8(95),
	15759: uint8(95),
	15760: uint8(9),
	15761: uint8(9),
	15762: uint8(9),
	15763: uint8(9),
	15764: uint8(9),
	15765: uint8(9),
	15766: uint8(9),
	15767: uint8(9),
	15768: uint8(9),
	15769: uint8(9),
	15776: uint8(9),
	15777: uint8(9),
	15778: uint8(9),
	15779: uint8(9),
	15780: uint8(9),
	15781: uint8(9),
	15782: uint8(9),
	15783: uint8(9),
	15784: uint8(9),
	15785: uint8(9),
	15790: uint8(3),
	15791: uint8(3),
	15792: uint8(15),
	15793: uint8(15),
	15794: uint8(15),
	15795: uint8(15),
	15796: uint8(15),
	15797: uint8(15),
	15798: uint8(15),
	15799: uint8(15),
	15800: uint8(15),
	15801: uint8(15),
	15802: uint8(15),
	15803: uint8(15),
	15804: uint8(15),
	15805: uint8(15),
	15806: uint8(15),
	15807: uint8(15),
	15808: uint8(9),
	15809: uint8(9),
	15810: uint8(9),
	15811: uint8(9),
	15812: uint8(9),
	15813: uint8(9),
	15814: uint8(9),
	15815: uint8(9),
	15816: uint8(9),
	15817: uint8(9),
	15824: uint8(15),
	15825: uint8(15),
	15826: uint8(15),
	15827: uint8(15),
	15828: uint8(15),
	15829: uint8(15),
	15830: uint8(15),
	15831: uint8(15),
	15832: uint8(15),
	15833: uint8(15),
	15834: uint8(15),
	15835: uint8(15),
	15836: uint8(15),
	15837: uint8(15),
	15838: uint8(15),
	15839: uint8(15),
	15840: uint8(15),
	15841: uint8(15),
	15842: uint8(15),
	15843: uint8(15),
	15844: uint8(15),
	15845: uint8(15),
	15846: uint8(15),
	15847: uint8(15),
	15848: uint8(15),
	15849: uint8(15),
	15850: uint8(15),
	15851: uint8(15),
	15852: uint8(15),
	15853: uint8(15),
	15856: uint8(95),
	15857: uint8(95),
	15858: uint8(95),
	15859: uint8(95),
	15860: uint8(95),
	15861: uint8(3),
	15872: uint8(15),
	15873: uint8(15),
	15874: uint8(15),
	15875: uint8(15),
	15876: uint8(15),
	15877: uint8(15),
	15878: uint8(15),
	15879: uint8(15),
	15880: uint8(15),
	15881: uint8(15),
	15882: uint8(15),
	15883: uint8(15),
	15884: uint8(15),
	15885: uint8(15),
	15886: uint8(15),
	15887: uint8(15),
	15888: uint8(95),
	15889: uint8(95),
	15890: uint8(95),
	15891: uint8(95),
	15892: uint8(95),
	15893: uint8(95),
	15894: uint8(95),
	15895: uint8(3),
	15896: uint8(3),
	15897: uint8(3),
	15898: uint8(3),
	15899: uint8(3),
	15900: uint8(14),
	15901: uint8(14),
	15902: uint8(14),
	15903: uint8(14),
	15904: uint8(94),
	15905: uint8(94),
	15906: uint8(94),
	15907: uint8(94),
	15908: uint8(3),
	15909: uint8(14),
	15920: uint8(9),
	15921: uint8(9),
	15922: uint8(9),
	15923: uint8(9),
	15924: uint8(9),
	15925: uint8(9),
	15926: uint8(9),
	15927: uint8(9),
	15928: uint8(9),
	15929: uint8(9),
	15931: uint8(18),
	15932: uint8(18),
	15933: uint8(18),
	15934: uint8(18),
	15935: uint8(18),
	15936: uint8(18),
	15937: uint8(18),
	15939: uint8(15),
	15940: uint8(15),
	15941: uint8(15),
	15942: uint8(15),
	15943: uint8(15),
	15944: uint8(15),
	15945: uint8(15),
	15946: uint8(15),
	15947: uint8(15),
	15948: uint8(15),
	15949: uint8(15),
	15950: uint8(15),
	15951: uint8(15),
	15952: uint8(15),
	15953: uint8(15),
	15954: uint8(15),
	15955: uint8(15),
	15956: uint8(15),
	15957: uint8(15),
	15958: uint8(15),
	15959: uint8(15),
	15965: uint8(15),
	15966: uint8(15),
	15967: uint8(15),
	15968: uint8(15),
	15969: uint8(15),
	15970: uint8(15),
	15971: uint8(15),
	15972: uint8(15),
	15973: uint8(15),
	15974: uint8(15),
	15975: uint8(15),
	15976: uint8(15),
	15977: uint8(15),
	15978: uint8(15),
	15979: uint8(15),
	15980: uint8(15),
	15981: uint8(15),
	15982: uint8(15),
	15983: uint8(15),
	16000: uint8(94),
	16001: uint8(94),
	16002: uint8(94),
	16003: uint8(15),
	16004: uint8(15),
	16005: uint8(15),
	16006: uint8(15),
	16007: uint8(15),
	16008: uint8(15),
	16009: uint8(15),
	16010: uint8(15),
	16011: uint8(15),
	16012: uint8(15),
	16013: uint8(15),
	16014: uint8(15),
	16015: uint8(15),
	16016: uint8(15),
	16017: uint8(15),
	16018: uint8(15),
	16019: uint8(15),
	16020: uint8(15),
	16021: uint8(15),
	16022: uint8(15),
	16023: uint8(15),
	16024: uint8(15),
	16025: uint8(15),
	16026: uint8(15),
	16027: uint8(15),
	16028: uint8(15),
	16029: uint8(15),
	16030: uint8(15),
	16031: uint8(15),
	16032: uint8(15),
	16033: uint8(15),
	16034: uint8(15),
	16035: uint8(15),
	16036: uint8(15),
	16037: uint8(15),
	16038: uint8(15),
	16039: uint8(15),
	16040: uint8(15),
	16041: uint8(15),
	16042: uint8(15),
	16043: uint8(94),
	16044: uint8(94),
	16045: uint8(3),
	16046: uint8(3),
	16047: uint8(3),
	16048: uint8(9),
	16049: uint8(9),
	16050: uint8(9),
	16051: uint8(9),
	16052: uint8(9),
	16053: uint8(9),
	16054: uint8(9),
	16055: uint8(9),
	16056: uint8(9),
	16057: uint8(9),
	16064: uint8(18),
	16065: uint8(18),
	16066: uint8(18),
	16067: uint8(18),
	16068: uint8(18),
	16069: uint8(18),
	16070: uint8(18),
	16071: uint8(18),
	16072: uint8(18),
	16073: uint8(18),
	16074: uint8(18),
	16075: uint8(18),
	16076: uint8(18),
	16077: uint8(18),
	16078: uint8(18),
	16079: uint8(18),
	16080: uint8(18),
	16081: uint8(18),
	16082: uint8(18),
	16083: uint8(18),
	16084: uint8(18),
	16085: uint8(18),
	16086: uint8(18),
	16087: uint8(3),
	16088: uint8(3),
	16089: uint8(3),
	16090: uint8(3),
	16096: uint8(15),
	16097: uint8(15),
	16098: uint8(15),
	16099: uint8(15),
	16100: uint8(15),
	16101: uint8(15),
	16102: uint8(15),
	16103: uint8(15),
	16104: uint8(15),
	16105: uint8(15),
	16106: uint8(15),
	16111: uint8(95),
	16112: uint8(15),
	16113: uint8(127),
	16114: uint8(127),
	16115: uint8(127),
	16116: uint8(127),
	16117: uint8(127),
	16118: uint8(127),
	16119: uint8(127),
	16120: uint8(127),
	16121: uint8(127),
	16122: uint8(127),
	16123: uint8(127),
	16124: uint8(127),
	16125: uint8(127),
	16126: uint8(127),
	16127: uint8(127),
	16128: uint8(127),
	16129: uint8(127),
	16130: uint8(127),
	16131: uint8(127),
	16132: uint8(127),
	16133: uint8(127),
	16134: uint8(127),
	16135: uint8(127),
	16136: uint8(127),
	16137: uint8(127),
	16138: uint8(127),
	16139: uint8(127),
	16140: uint8(127),
	16141: uint8(127),
	16142: uint8(127),
	16143: uint8(127),
	16144: uint8(127),
	16145: uint8(127),
	16146: uint8(127),
	16147: uint8(127),
	16148: uint8(127),
	16149: uint8(127),
	16150: uint8(127),
	16151: uint8(127),
	16152: uint8(127),
	16153: uint8(127),
	16154: uint8(127),
	16155: uint8(127),
	16156: uint8(127),
	16157: uint8(127),
	16158: uint8(127),
	16159: uint8(127),
	16160: uint8(127),
	16161: uint8(127),
	16162: uint8(127),
	16163: uint8(127),
	16164: uint8(127),
	16165: uint8(127),
	16166: uint8(127),
	16167: uint8(127),
	16175: uint8(95),
	16176: uint8(95),
	16177: uint8(95),
	16178: uint8(95),
	16179: uint8(94),
	16180: uint8(94),
	16181: uint8(94),
	16182: uint8(94),
	16183: uint8(94),
	16184: uint8(94),
	16185: uint8(94),
	16186: uint8(94),
	16187: uint8(94),
	16188: uint8(94),
	16189: uint8(94),
	16190: uint8(94),
	16191: uint8(94),
	16192: uint8(94),
	16193: uint8(94),
	16194: uint8(3),
	16195: uint8(94),
	16196: uint8(95),
	16208: uint8(127),
	16209: uint8(127),
	16224: uint8(15),
	16225: uint8(15),
	16226: uint8(15),
	16227: uint8(15),
	16228: uint8(15),
	16229: uint8(15),
	16230: uint8(15),
	16231: uint8(15),
	16232: uint8(15),
	16233: uint8(15),
	16234: uint8(15),
	16235: uint8(15),
	16236: uint8(15),
	16237: uint8(15),
	16238: uint8(15),
	16239: uint8(15),
	16240: uint8(15),
	16241: uint8(15),
	16242: uint8(15),
	16243: uint8(15),
	16244: uint8(15),
	16245: uint8(15),
	16246: uint8(15),
	16247: uint8(15),
	16287: uint8(15),
	16304: uint8(94),
	16305: uint8(94),
	16306: uint8(94),
	16307: uint8(94),
	16309: uint8(94),
	16310: uint8(94),
	16311: uint8(94),
	16312: uint8(94),
	16313: uint8(94),
	16314: uint8(94),
	16315: uint8(94),
	16317: uint8(94),
	16318: uint8(94),
	16320: uint8(15),
	16321: uint8(15),
	16322: uint8(15),
	16338: uint8(15),
	16368: uint8(15),
	16369: uint8(15),
	16370: uint8(15),
	16373: uint8(15),
	16388: uint8(15),
	16389: uint8(15),
	16390: uint8(15),
	16391: uint8(15),
	16400: uint8(15),
	16401: uint8(15),
	16402: uint8(15),
	16403: uint8(15),
	16404: uint8(15),
	16405: uint8(15),
	16406: uint8(15),
	16407: uint8(15),
	16408: uint8(15),
	16409: uint8(15),
	16410: uint8(15),
	16411: uint8(15),
	16412: uint8(15),
	16413: uint8(15),
	16414: uint8(15),
	16415: uint8(15),
	16416: uint8(15),
	16417: uint8(15),
	16418: uint8(15),
	16419: uint8(15),
	16420: uint8(15),
	16421: uint8(15),
	16422: uint8(15),
	16423: uint8(15),
	16424: uint8(15),
	16425: uint8(15),
	16426: uint8(15),
	16432: uint8(15),
	16433: uint8(15),
	16434: uint8(15),
	16435: uint8(15),
	16436: uint8(15),
	16437: uint8(15),
	16438: uint8(15),
	16439: uint8(15),
	16440: uint8(15),
	16441: uint8(15),
	16442: uint8(15),
	16443: uint8(15),
	16444: uint8(15),
	16448: uint8(15),
	16449: uint8(15),
	16450: uint8(15),
	16451: uint8(15),
	16452: uint8(15),
	16453: uint8(15),
	16454: uint8(15),
	16455: uint8(15),
	16456: uint8(15),
	16464: uint8(15),
	16465: uint8(15),
	16466: uint8(15),
	16467: uint8(15),
	16468: uint8(15),
	16469: uint8(15),
	16470: uint8(15),
	16471: uint8(15),
	16472: uint8(15),
	16473: uint8(15),
	16476: uint8(14),
	16477: uint8(95),
	16478: uint8(95),
	16479: uint8(3),
	16480: uint8(17),
	16481: uint8(17),
	16482: uint8(17),
	16483: uint8(17),
	16512: uint8(14),
	16513: uint8(14),
	16514: uint8(14),
	16515: uint8(14),
	16516: uint8(14),
	16517: uint8(14),
	16518: uint8(14),
	16519: uint8(14),
	16520: uint8(14),
	16521: uint8(14),
	16522: uint8(14),
	16523: uint8(14),
	16524: uint8(14),
	16525: uint8(14),
	16526: uint8(14),
	16527: uint8(14),
	16528: uint8(9),
	16529: uint8(9),
	16530: uint8(9),
	16531: uint8(9),
	16532: uint8(9),
	16533: uint8(9),
	16534: uint8(9),
	16535: uint8(9),
	16536: uint8(9),
	16537: uint8(9),
	16544: uint8(95),
	16545: uint8(95),
	16546: uint8(95),
	16547: uint8(95),
	16548: uint8(95),
	16549: uint8(95),
	16550: uint8(95),
	16551: uint8(95),
	16552: uint8(95),
	16553: uint8(95),
	16554: uint8(95),
	16555: uint8(95),
	16556: uint8(95),
	16557: uint8(95),
	16560: uint8(95),
	16561: uint8(95),
	16562: uint8(95),
	16563: uint8(95),
	16564: uint8(95),
	16565: uint8(95),
	16566: uint8(95),
	16567: uint8(95),
	16568: uint8(95),
	16569: uint8(95),
	16570: uint8(95),
	16571: uint8(95),
	16572: uint8(95),
	16573: uint8(95),
	16574: uint8(95),
	16575: uint8(95),
	16576: uint8(95),
	16577: uint8(95),
	16578: uint8(95),
	16579: uint8(95),
	16580: uint8(95),
	16581: uint8(95),
	16582: uint8(95),
	16592: uint8(14),
	16593: uint8(14),
	16594: uint8(14),
	16595: uint8(14),
	16596: uint8(14),
	16597: uint8(14),
	16598: uint8(14),
	16599: uint8(14),
	16600: uint8(14),
	16601: uint8(14),
	16602: uint8(14),
	16603: uint8(14),
	16604: uint8(14),
	16605: uint8(14),
	16606: uint8(14),
	16607: uint8(14),
	16608: uint8(14),
	16609: uint8(14),
	16610: uint8(14),
	16611: uint8(14),
	16640: uint8(14),
	16641: uint8(14),
	16642: uint8(14),
	16643: uint8(14),
	16644: uint8(14),
	16645: uint8(14),
	16646: uint8(14),
	16649: uint8(14),
	16650: uint8(14),
	16651: uint8(14),
	16652: uint8(14),
	16653: uint8(14),
	16654: uint8(14),
	16655: uint8(14),
	16656: uint8(14),
	16657: uint8(14),
	16658: uint8(14),
	16659: uint8(14),
	16660: uint8(14),
	16661: uint8(14),
	16662: uint8(14),
	16663: uint8(14),
	16664: uint8(14),
	16665: uint8(14),
	16666: uint8(14),
	16667: uint8(14),
	16668: uint8(14),
	16669: uint8(14),
	16670: uint8(14),
	16671: uint8(14),
	16672: uint8(14),
	16673: uint8(14),
	16674: uint8(14),
	16675: uint8(14),
	16676: uint8(14),
	16677: uint8(127),
	16678: uint8(127),
	16679: uint8(95),
	16680: uint8(95),
	16681: uint8(95),
	16682: uint8(14),
	16683: uint8(14),
	16684: uint8(14),
	16685: uint8(127),
	16686: uint8(127),
	16687: uint8(127),
	16688: uint8(127),
	16689: uint8(127),
	16690: uint8(127),
	16691: uint8(17),
	16692: uint8(17),
	16693: uint8(17),
	16694: uint8(17),
	16695: uint8(17),
	16696: uint8(17),
	16697: uint8(17),
	16698: uint8(17),
	16699: uint8(95),
	16700: uint8(95),
	16701: uint8(95),
	16702: uint8(95),
	16703: uint8(95),
	16704: uint8(95),
	16705: uint8(95),
	16706: uint8(95),
	16707: uint8(14),
	16708: uint8(14),
	16709: uint8(95),
	16710: uint8(95),
	16711: uint8(95),
	16712: uint8(95),
	16713: uint8(95),
	16714: uint8(95),
	16715: uint8(95),
	16716: uint8(14),
	16717: uint8(14),
	16718: uint8(14),
	16719: uint8(14),
	16720: uint8(14),
	16721: uint8(14),
	16722: uint8(14),
	16723: uint8(14),
	16724: uint8(14),
	16725: uint8(14),
	16726: uint8(14),
	16727: uint8(14),
	16728: uint8(14),
	16729: uint8(14),
	16730: uint8(14),
	16731: uint8(14),
	16732: uint8(14),
	16733: uint8(14),
	16734: uint8(14),
	16735: uint8(14),
	16736: uint8(14),
	16737: uint8(14),
	16738: uint8(14),
	16739: uint8(14),
	16740: uint8(14),
	16741: uint8(14),
	16742: uint8(14),
	16743: uint8(14),
	16744: uint8(14),
	16745: uint8(14),
	16746: uint8(95),
	16747: uint8(95),
	16748: uint8(95),
	16749: uint8(95),
	16750: uint8(14),
	16751: uint8(14),
	16752: uint8(14),
	16753: uint8(14),
	16754: uint8(14),
	16755: uint8(14),
	16756: uint8(14),
	16757: uint8(14),
	16758: uint8(14),
	16759: uint8(14),
	16760: uint8(14),
	16761: uint8(14),
	16762: uint8(14),
	16763: uint8(14),
	16764: uint8(14),
	16765: uint8(14),
	16766: uint8(14),
	16767: uint8(14),
	16768: uint8(14),
	16769: uint8(14),
	16770: uint8(95),
	16771: uint8(95),
	16772: uint8(95),
	16773: uint8(14),
	16800: uint8(18),
	16801: uint8(18),
	16802: uint8(18),
	16803: uint8(18),
	16804: uint8(18),
	16805: uint8(18),
	16806: uint8(18),
	16807: uint8(18),
	16808: uint8(18),
	16809: uint8(18),
	16810: uint8(18),
	16811: uint8(18),
	16812: uint8(18),
	16813: uint8(18),
	16814: uint8(18),
	16815: uint8(18),
	16816: uint8(18),
	16817: uint8(18),
	16818: uint8(18),
	16819: uint8(18),
	16832: uint8(14),
	16833: uint8(14),
	16834: uint8(14),
	16835: uint8(14),
	16836: uint8(14),
	16837: uint8(14),
	16838: uint8(14),
	16839: uint8(14),
	16840: uint8(14),
	16841: uint8(14),
	16842: uint8(14),
	16843: uint8(14),
	16844: uint8(14),
	16845: uint8(14),
	16846: uint8(14),
	16847: uint8(14),
	16848: uint8(14),
	16849: uint8(14),
	16850: uint8(14),
	16851: uint8(14),
	16852: uint8(14),
	16853: uint8(14),
	16854: uint8(14),
	16864: uint8(18),
	16865: uint8(18),
	16866: uint8(18),
	16867: uint8(18),
	16868: uint8(18),
	16869: uint8(18),
	16870: uint8(18),
	16871: uint8(18),
	16872: uint8(18),
	16873: uint8(18),
	16874: uint8(18),
	16875: uint8(18),
	16876: uint8(18),
	16877: uint8(18),
	16878: uint8(18),
	16879: uint8(18),
	16880: uint8(18),
	16881: uint8(18),
	16882: uint8(18),
	16883: uint8(18),
	16884: uint8(18),
	16885: uint8(18),
	16886: uint8(18),
	16887: uint8(18),
	16888: uint8(18),
	16896: uint8(110),
	16897: uint8(110),
	16898: uint8(110),
	16899: uint8(110),
	16900: uint8(110),
	16901: uint8(110),
	16902: uint8(110),
	16903: uint8(110),
	16904: uint8(110),
	16905: uint8(110),
	16906: uint8(110),
	16907: uint8(110),
	16908: uint8(110),
	16909: uint8(110),
	16910: uint8(110),
	16911: uint8(110),
	16912: uint8(110),
	16913: uint8(110),
	16914: uint8(110),
	16915: uint8(110),
	16916: uint8(110),
	16917: uint8(110),
	16918: uint8(110),
	16919: uint8(110),
	16920: uint8(110),
	16921: uint8(110),
	16922: uint8(21),
	16923: uint8(21),
	16924: uint8(21),
	16925: uint8(21),
	16926: uint8(21),
	16927: uint8(21),
	16928: uint8(21),
	16929: uint8(21),
	16930: uint8(21),
	16931: uint8(21),
	16932: uint8(21),
	16933: uint8(21),
	16934: uint8(21),
	16935: uint8(21),
	16936: uint8(21),
	16937: uint8(21),
	16938: uint8(21),
	16939: uint8(21),
	16940: uint8(21),
	16941: uint8(21),
	16942: uint8(21),
	16943: uint8(21),
	16944: uint8(21),
	16945: uint8(21),
	16946: uint8(21),
	16947: uint8(21),
	16948: uint8(110),
	16949: uint8(110),
	16950: uint8(110),
	16951: uint8(110),
	16952: uint8(110),
	16953: uint8(110),
	16954: uint8(110),
	16955: uint8(110),
	16956: uint8(110),
	16957: uint8(110),
	16958: uint8(110),
	16959: uint8(110),
	16960: uint8(110),
	16961: uint8(110),
	16962: uint8(110),
	16963: uint8(110),
	16964: uint8(110),
	16965: uint8(110),
	16966: uint8(110),
	16967: uint8(110),
	16968: uint8(110),
	16969: uint8(110),
	16970: uint8(110),
	16971: uint8(110),
	16972: uint8(110),
	16973: uint8(110),
	16974: uint8(21),
	16975: uint8(21),
	16976: uint8(21),
	16977: uint8(21),
	16978: uint8(21),
	16979: uint8(21),
	16980: uint8(21),
	16982: uint8(21),
	16983: uint8(21),
	16984: uint8(21),
	16985: uint8(21),
	16986: uint8(21),
	16987: uint8(21),
	16988: uint8(21),
	16989: uint8(21),
	16990: uint8(21),
	16991: uint8(21),
	16992: uint8(21),
	16993: uint8(21),
	16994: uint8(21),
	16995: uint8(21),
	16996: uint8(21),
	16997: uint8(21),
	16998: uint8(21),
	16999: uint8(21),
	17000: uint8(110),
	17001: uint8(110),
	17002: uint8(110),
	17003: uint8(110),
	17004: uint8(110),
	17005: uint8(110),
	17006: uint8(110),
	17007: uint8(110),
	17008: uint8(110),
	17009: uint8(110),
	17010: uint8(110),
	17011: uint8(110),
	17012: uint8(110),
	17013: uint8(110),
	17014: uint8(110),
	17015: uint8(110),
	17016: uint8(110),
	17017: uint8(110),
	17018: uint8(110),
	17019: uint8(110),
	17020: uint8(110),
	17021: uint8(110),
	17022: uint8(110),
	17023: uint8(110),
	17024: uint8(110),
	17025: uint8(110),
	17026: uint8(21),
	17027: uint8(21),
	17028: uint8(21),
	17029: uint8(21),
	17030: uint8(21),
	17031: uint8(21),
	17032: uint8(21),
	17033: uint8(21),
	17034: uint8(21),
	17035: uint8(21),
	17036: uint8(21),
	17037: uint8(21),
	17038: uint8(21),
	17039: uint8(21),
	17040: uint8(21),
	17041: uint8(21),
	17042: uint8(21),
	17043: uint8(21),
	17044: uint8(21),
	17045: uint8(21),
	17046: uint8(21),
	17047: uint8(21),
	17048: uint8(21),
	17049: uint8(21),
	17050: uint8(21),
	17051: uint8(21),
	17052: uint8(110),
	17054: uint8(110),
	17055: uint8(110),
	17058: uint8(110),
	17061: uint8(110),
	17062: uint8(110),
	17065: uint8(110),
	17066: uint8(110),
	17067: uint8(110),
	17068: uint8(110),
	17070: uint8(110),
	17071: uint8(110),
	17072: uint8(110),
	17073: uint8(110),
	17074: uint8(110),
	17075: uint8(110),
	17076: uint8(110),
	17077: uint8(110),
	17078: uint8(21),
	17079: uint8(21),
	17080: uint8(21),
	17081: uint8(21),
	17083: uint8(21),
	17085: uint8(21),
	17086: uint8(21),
	17087: uint8(21),
	17088: uint8(21),
	17089: uint8(21),
	17090: uint8(21),
	17091: uint8(21),
	17093: uint8(21),
	17094: uint8(21),
	17095: uint8(21),
	17096: uint8(21),
	17097: uint8(21),
	17098: uint8(21),
	17099: uint8(21),
	17100: uint8(21),
	17101: uint8(21),
	17102: uint8(21),
	17103: uint8(21),
	17104: uint8(110),
	17105: uint8(110),
	17106: uint8(110),
	17107: uint8(110),
	17108: uint8(110),
	17109: uint8(110),
	17110: uint8(110),
	17111: uint8(110),
	17112: uint8(110),
	17113: uint8(110),
	17114: uint8(110),
	17115: uint8(110),
	17116: uint8(110),
	17117: uint8(110),
	17118: uint8(110),
	17119: uint8(110),
	17120: uint8(110),
	17121: uint8(110),
	17122: uint8(110),
	17123: uint8(110),
	17124: uint8(110),
	17125: uint8(110),
	17126: uint8(110),
	17127: uint8(110),
	17128: uint8(110),
	17129: uint8(110),
	17130: uint8(21),
	17131: uint8(21),
	17132: uint8(21),
	17133: uint8(21),
	17134: uint8(21),
	17135: uint8(21),
	17136: uint8(21),
	17137: uint8(21),
	17138: uint8(21),
	17139: uint8(21),
	17140: uint8(21),
	17141: uint8(21),
	17142: uint8(21),
	17143: uint8(21),
	17144: uint8(21),
	17145: uint8(21),
	17146: uint8(21),
	17147: uint8(21),
	17148: uint8(21),
	17149: uint8(21),
	17150: uint8(21),
	17151: uint8(21),
	17152: uint8(21),
	17153: uint8(21),
	17154: uint8(21),
	17155: uint8(21),
	17156: uint8(110),
	17157: uint8(110),
	17159: uint8(110),
	17160: uint8(110),
	17161: uint8(110),
	17162: uint8(110),
	17165: uint8(110),
	17166: uint8(110),
	17167: uint8(110),
	17168: uint8(110),
	17169: uint8(110),
	17170: uint8(110),
	17171: uint8(110),
	17172: uint8(110),
	17174: uint8(110),
	17175: uint8(110),
	17176: uint8(110),
	17177: uint8(110),
	17178: uint8(110),
	17179: uint8(110),
	17180: uint8(110),
	17182: uint8(21),
	17183: uint8(21),
	17184: uint8(21),
	17185: uint8(21),
	17186: uint8(21),
	17187: uint8(21),
	17188: uint8(21),
	17189: uint8(21),
	17190: uint8(21),
	17191: uint8(21),
	17192: uint8(21),
	17193: uint8(21),
	17194: uint8(21),
	17195: uint8(21),
	17196: uint8(21),
	17197: uint8(21),
	17198: uint8(21),
	17199: uint8(21),
	17200: uint8(21),
	17201: uint8(21),
	17202: uint8(21),
	17203: uint8(21),
	17204: uint8(21),
	17205: uint8(21),
	17206: uint8(21),
	17207: uint8(21),
	17208: uint8(110),
	17209: uint8(110),
	17211: uint8(110),
	17212: uint8(110),
	17213: uint8(110),
	17214: uint8(110),
	17216: uint8(110),
	17217: uint8(110),
	17218: uint8(110),
	17219: uint8(110),
	17220: uint8(110),
	17222: uint8(110),
	17226: uint8(110),
	17227: uint8(110),
	17228: uint8(110),
	17229: uint8(110),
	17230: uint8(110),
	17231: uint8(110),
	17232: uint8(110),
	17234: uint8(21),
	17235: uint8(21),
	17236: uint8(21),
	17237: uint8(21),
	17238: uint8(21),
	17239: uint8(21),
	17240: uint8(21),
	17241: uint8(21),
	17242: uint8(21),
	17243: uint8(21),
	17244: uint8(21),
	17245: uint8(21),
	17246: uint8(21),
	17247: uint8(21),
	17248: uint8(21),
	17249: uint8(21),
	17250: uint8(21),
	17251: uint8(21),
	17252: uint8(21),
	17253: uint8(21),
	17254: uint8(21),
	17255: uint8(21),
	17256: uint8(21),
	17257: uint8(21),
	17258: uint8(21),
	17259: uint8(21),
	17260: uint8(110),
	17261: uint8(110),
	17262: uint8(110),
	17263: uint8(110),
	17264: uint8(110),
	17265: uint8(110),
	17266: uint8(110),
	17267: uint8(110),
	17268: uint8(110),
	17269: uint8(110),
	17270: uint8(110),
	17271: uint8(110),
	17272: uint8(110),
	17273: uint8(110),
	17274: uint8(110),
	17275: uint8(110),
	17276: uint8(110),
	17277: uint8(110),
	17278: uint8(110),
	17279: uint8(110),
	17280: uint8(110),
	17281: uint8(110),
	17282: uint8(110),
	17283: uint8(110),
	17284: uint8(110),
	17285: uint8(110),
	17286: uint8(21),
	17287: uint8(21),
	17288: uint8(21),
	17289: uint8(21),
	17290: uint8(21),
	17291: uint8(21),
	17292: uint8(21),
	17293: uint8(21),
	17294: uint8(21),
	17295: uint8(21),
	17296: uint8(21),
	17297: uint8(21),
	17298: uint8(21),
	17299: uint8(21),
	17300: uint8(21),
	17301: uint8(21),
	17302: uint8(21),
	17303: uint8(21),
	17304: uint8(21),
	17305: uint8(21),
	17306: uint8(21),
	17307: uint8(21),
	17308: uint8(21),
	17309: uint8(21),
	17310: uint8(21),
	17311: uint8(21),
	17312: uint8(110),
	17313: uint8(110),
	17314: uint8(110),
	17315: uint8(110),
	17316: uint8(110),
	17317: uint8(110),
	17318: uint8(110),
	17319: uint8(110),
	17320: uint8(110),
	17321: uint8(110),
	17322: uint8(110),
	17323: uint8(110),
	17324: uint8(110),
	17325: uint8(110),
	17326: uint8(21),
	17327: uint8(21),
	17328: uint8(21),
	17329: uint8(21),
	17330: uint8(21),
	17331: uint8(21),
	17332: uint8(21),
	17333: uint8(21),
	17334: uint8(21),
	17335: uint8(21),
	17336: uint8(21),
	17337: uint8(21),
	17338: uint8(21),
	17339: uint8(21),
	17340: uint8(21),
	17341: uint8(21),
	17342: uint8(21),
	17343: uint8(21),
	17344: uint8(110),
	17345: uint8(110),
	17346: uint8(21),
	17347: uint8(21),
	17348: uint8(21),
	17349: uint8(21),
	17350: uint8(21),
	17351: uint8(21),
	17352: uint8(21),
	17353: uint8(21),
	17354: uint8(21),
	17355: uint8(21),
	17356: uint8(21),
	17357: uint8(21),
	17358: uint8(21),
	17359: uint8(21),
	17360: uint8(21),
	17361: uint8(21),
	17362: uint8(21),
	17363: uint8(21),
	17364: uint8(21),
	17365: uint8(21),
	17366: uint8(21),
	17367: uint8(21),
	17368: uint8(21),
	17369: uint8(21),
	17370: uint8(21),
	17371: uint8(21),
	17372: uint8(110),
	17373: uint8(110),
	17374: uint8(110),
	17375: uint8(110),
	17376: uint8(110),
	17377: uint8(110),
	17378: uint8(110),
	17379: uint8(110),
	17380: uint8(110),
	17381: uint8(110),
	17382: uint8(110),
	17383: uint8(110),
	17384: uint8(110),
	17385: uint8(110),
	17386: uint8(110),
	17387: uint8(110),
	17388: uint8(110),
	17389: uint8(110),
	17390: uint8(110),
	17391: uint8(110),
	17392: uint8(110),
	17393: uint8(110),
	17394: uint8(110),
	17395: uint8(110),
	17396: uint8(110),
	17397: uint8(110),
	17398: uint8(21),
	17399: uint8(21),
	17400: uint8(21),
	17401: uint8(21),
	17402: uint8(21),
	17403: uint8(21),
	17404: uint8(21),
	17405: uint8(21),
	17406: uint8(21),
	17407: uint8(21),
	17408: uint8(21),
	17409: uint8(21),
	17410: uint8(21),
	17411: uint8(21),
	17412: uint8(21),
	17413: uint8(21),
	17414: uint8(21),
	17415: uint8(21),
	17416: uint8(21),
	17417: uint8(21),
	17418: uint8(21),
	17419: uint8(21),
	17420: uint8(21),
	17421: uint8(21),
	17422: uint8(21),
	17423: uint8(21),
	17424: uint8(110),
	17425: uint8(110),
	17426: uint8(110),
	17427: uint8(110),
	17428: uint8(110),
	17429: uint8(110),
	17430: uint8(110),
	17431: uint8(110),
	17432: uint8(110),
	17433: uint8(110),
	17434: uint8(110),
	17435: uint8(110),
	17436: uint8(110),
	17437: uint8(110),
	17438: uint8(110),
	17439: uint8(110),
	17440: uint8(21),
	17441: uint8(21),
	17442: uint8(21),
	17443: uint8(21),
	17444: uint8(21),
	17445: uint8(21),
	17448: uint8(110),
	17449: uint8(110),
	17450: uint8(110),
	17451: uint8(110),
	17452: uint8(110),
	17453: uint8(110),
	17454: uint8(110),
	17455: uint8(110),
	17456: uint8(110),
	17457: uint8(110),
	17458: uint8(110),
	17459: uint8(110),
	17460: uint8(110),
	17461: uint8(110),
	17462: uint8(110),
	17463: uint8(110),
	17464: uint8(110),
	17465: uint8(110),
	17466: uint8(110),
	17467: uint8(110),
	17468: uint8(110),
	17469: uint8(110),
	17470: uint8(110),
	17471: uint8(110),
	17472: uint8(110),
	17473: uint8(7),
	17474: uint8(21),
	17475: uint8(21),
	17476: uint8(21),
	17477: uint8(21),
	17478: uint8(21),
	17479: uint8(21),
	17480: uint8(21),
	17481: uint8(21),
	17482: uint8(21),
	17483: uint8(21),
	17484: uint8(21),
	17485: uint8(21),
	17486: uint8(21),
	17487: uint8(21),
	17488: uint8(21),
	17489: uint8(21),
	17490: uint8(21),
	17491: uint8(21),
	17492: uint8(21),
	17493: uint8(21),
	17494: uint8(21),
	17495: uint8(21),
	17496: uint8(21),
	17497: uint8(21),
	17498: uint8(21),
	17499: uint8(7),
	17500: uint8(21),
	17501: uint8(21),
	17502: uint8(21),
	17503: uint8(21),
	17504: uint8(21),
	17505: uint8(21),
	17506: uint8(110),
	17507: uint8(110),
	17508: uint8(110),
	17509: uint8(110),
	17510: uint8(110),
	17511: uint8(110),
	17512: uint8(110),
	17513: uint8(110),
	17514: uint8(110),
	17515: uint8(110),
	17516: uint8(110),
	17517: uint8(110),
	17518: uint8(110),
	17519: uint8(110),
	17520: uint8(110),
	17521: uint8(110),
	17522: uint8(110),
	17523: uint8(110),
	17524: uint8(110),
	17525: uint8(110),
	17526: uint8(110),
	17527: uint8(110),
	17528: uint8(110),
	17529: uint8(110),
	17530: uint8(110),
	17531: uint8(7),
	17532: uint8(21),
	17533: uint8(21),
	17534: uint8(21),
	17535: uint8(21),
	17536: uint8(21),
	17537: uint8(21),
	17538: uint8(21),
	17539: uint8(21),
	17540: uint8(21),
	17541: uint8(21),
	17542: uint8(21),
	17543: uint8(21),
	17544: uint8(21),
	17545: uint8(21),
	17546: uint8(21),
	17547: uint8(21),
	17548: uint8(21),
	17549: uint8(21),
	17550: uint8(21),
	17551: uint8(21),
	17552: uint8(21),
	17553: uint8(21),
	17554: uint8(21),
	17555: uint8(21),
	17556: uint8(21),
	17557: uint8(7),
	17558: uint8(21),
	17559: uint8(21),
	17560: uint8(21),
	17561: uint8(21),
	17562: uint8(21),
	17563: uint8(21),
	17564: uint8(110),
	17565: uint8(110),
	17566: uint8(110),
	17567: uint8(110),
	17568: uint8(110),
	17569: uint8(110),
	17570: uint8(110),
	17571: uint8(110),
	17572: uint8(110),
	17573: uint8(110),
	17574: uint8(110),
	17575: uint8(110),
	17576: uint8(110),
	17577: uint8(110),
	17578: uint8(110),
	17579: uint8(110),
	17580: uint8(110),
	17581: uint8(110),
	17582: uint8(110),
	17583: uint8(110),
	17584: uint8(110),
	17585: uint8(110),
	17586: uint8(110),
	17587: uint8(110),
	17588: uint8(110),
	17589: uint8(7),
	17590: uint8(21),
	17591: uint8(21),
	17592: uint8(21),
	17593: uint8(21),
	17594: uint8(21),
	17595: uint8(21),
	17596: uint8(21),
	17597: uint8(21),
	17598: uint8(21),
	17599: uint8(21),
	17600: uint8(21),
	17601: uint8(21),
	17602: uint8(21),
	17603: uint8(21),
	17604: uint8(21),
	17605: uint8(21),
	17606: uint8(21),
	17607: uint8(21),
	17608: uint8(21),
	17609: uint8(21),
	17610: uint8(21),
	17611: uint8(21),
	17612: uint8(21),
	17613: uint8(21),
	17614: uint8(21),
	17615: uint8(7),
	17616: uint8(21),
	17617: uint8(21),
	17618: uint8(21),
	17619: uint8(21),
	17620: uint8(21),
	17621: uint8(21),
	17622: uint8(110),
	17623: uint8(110),
	17624: uint8(110),
	17625: uint8(110),
	17626: uint8(110),
	17627: uint8(110),
	17628: uint8(110),
	17629: uint8(110),
	17630: uint8(110),
	17631: uint8(110),
	17632: uint8(110),
	17633: uint8(110),
	17634: uint8(110),
	17635: uint8(110),
	17636: uint8(110),
	17637: uint8(110),
	17638: uint8(110),
	17639: uint8(110),
	17640: uint8(110),
	17641: uint8(110),
	17642: uint8(110),
	17643: uint8(110),
	17644: uint8(110),
	17645: uint8(110),
	17646: uint8(110),
	17647: uint8(7),
	17648: uint8(21),
	17649: uint8(21),
	17650: uint8(21),
	17651: uint8(21),
	17652: uint8(21),
	17653: uint8(21),
	17654: uint8(21),
	17655: uint8(21),
	17656: uint8(21),
	17657: uint8(21),
	17658: uint8(21),
	17659: uint8(21),
	17660: uint8(21),
	17661: uint8(21),
	17662: uint8(21),
	17663: uint8(21),
	17664: uint8(21),
	17665: uint8(21),
	17666: uint8(21),
	17667: uint8(21),
	17668: uint8(21),
	17669: uint8(21),
	17670: uint8(21),
	17671: uint8(21),
	17672: uint8(21),
	17673: uint8(7),
	17674: uint8(21),
	17675: uint8(21),
	17676: uint8(21),
	17677: uint8(21),
	17678: uint8(21),
	17679: uint8(21),
	17680: uint8(110),
	17681: uint8(110),
	17682: uint8(110),
	17683: uint8(110),
	17684: uint8(110),
	17685: uint8(110),
	17686: uint8(110),
	17687: uint8(110),
	17688: uint8(110),
	17689: uint8(110),
	17690: uint8(110),
	17691: uint8(110),
	17692: uint8(110),
	17693: uint8(110),
	17694: uint8(110),
	17695: uint8(110),
	17696: uint8(110),
	17697: uint8(110),
	17698: uint8(110),
	17699: uint8(110),
	17700: uint8(110),
	17701: uint8(110),
	17702: uint8(110),
	17703: uint8(110),
	17704: uint8(110),
	17705: uint8(7),
	17706: uint8(21),
	17707: uint8(21),
	17708: uint8(21),
	17709: uint8(21),
	17710: uint8(21),
	17711: uint8(21),
	17712: uint8(21),
	17713: uint8(21),
	17714: uint8(21),
	17715: uint8(21),
	17716: uint8(21),
	17717: uint8(21),
	17718: uint8(21),
	17719: uint8(21),
	17720: uint8(21),
	17721: uint8(21),
	17722: uint8(21),
	17723: uint8(21),
	17724: uint8(21),
	17725: uint8(21),
	17726: uint8(21),
	17727: uint8(21),
	17728: uint8(21),
	17729: uint8(21),
	17730: uint8(21),
	17731: uint8(7),
	17732: uint8(21),
	17733: uint8(21),
	17734: uint8(21),
	17735: uint8(21),
	17736: uint8(21),
	17737: uint8(21),
	17738: uint8(110),
	17739: uint8(21),
	17742: uint8(9),
	17743: uint8(9),
	17744: uint8(9),
	17745: uint8(9),
	17746: uint8(9),
	17747: uint8(9),
	17748: uint8(9),
	17749: uint8(9),
	17750: uint8(9),
	17751: uint8(9),
	17752: uint8(9),
	17753: uint8(9),
	17754: uint8(9),
	17755: uint8(9),
	17756: uint8(9),
	17757: uint8(9),
	17758: uint8(9),
	17759: uint8(9),
	17760: uint8(9),
	17761: uint8(9),
	17762: uint8(9),
	17763: uint8(9),
	17764: uint8(9),
	17765: uint8(9),
	17766: uint8(9),
	17767: uint8(9),
	17768: uint8(9),
	17769: uint8(9),
	17770: uint8(9),
	17771: uint8(9),
	17772: uint8(9),
	17773: uint8(9),
	17774: uint8(9),
	17775: uint8(9),
	17776: uint8(9),
	17777: uint8(9),
	17778: uint8(9),
	17779: uint8(9),
	17780: uint8(9),
	17781: uint8(9),
	17782: uint8(9),
	17783: uint8(9),
	17784: uint8(9),
	17785: uint8(9),
	17786: uint8(9),
	17787: uint8(9),
	17788: uint8(9),
	17789: uint8(9),
	17790: uint8(9),
	17791: uint8(9),
	17792: uint8(95),
	17793: uint8(95),
	17794: uint8(95),
	17795: uint8(95),
	17796: uint8(95),
	17797: uint8(95),
	17798: uint8(95),
	17799: uint8(95),
	17800: uint8(95),
	17801: uint8(95),
	17802: uint8(95),
	17803: uint8(95),
	17804: uint8(95),
	17805: uint8(95),
	17806: uint8(95),
	17807: uint8(95),
	17808: uint8(95),
	17809: uint8(95),
	17810: uint8(95),
	17811: uint8(95),
	17812: uint8(95),
	17813: uint8(95),
	17814: uint8(95),
	17815: uint8(14),
	17816: uint8(14),
	17817: uint8(14),
	17818: uint8(14),
	17819: uint8(95),
	17820: uint8(95),
	17821: uint8(95),
	17822: uint8(95),
	17823: uint8(95),
	17824: uint8(95),
	17825: uint8(95),
	17826: uint8(95),
	17827: uint8(95),
	17828: uint8(95),
	17829: uint8(95),
	17830: uint8(95),
	17831: uint8(95),
	17832: uint8(95),
	17833: uint8(95),
	17834: uint8(95),
	17835: uint8(95),
	17836: uint8(95),
	17837: uint8(14),
	17838: uint8(14),
	17839: uint8(14),
	17840: uint8(14),
	17841: uint8(14),
	17842: uint8(14),
	17843: uint8(14),
	17844: uint8(14),
	17845: uint8(95),
	17846: uint8(14),
	17847: uint8(14),
	17848: uint8(14),
	17849: uint8(14),
	17850: uint8(14),
	17851: uint8(14),
	17852: uint8(14),
	17853: uint8(14),
	17854: uint8(14),
	17855: uint8(14),
	17856: uint8(14),
	17857: uint8(14),
	17858: uint8(14),
	17859: uint8(14),
	17860: uint8(95),
	17861: uint8(14),
	17862: uint8(14),
	17863: uint8(3),
	17864: uint8(3),
	17865: uint8(3),
	17866: uint8(3),
	17867: uint8(3),
	17883: uint8(95),
	17884: uint8(95),
	17885: uint8(95),
	17886: uint8(95),
	17887: uint8(95),
	17889: uint8(95),
	17890: uint8(95),
	17891: uint8(95),
	17892: uint8(95),
	17893: uint8(95),
	17894: uint8(95),
	17895: uint8(95),
	17896: uint8(95),
	17897: uint8(95),
	17898: uint8(95),
	17899: uint8(95),
	17900: uint8(95),
	17901: uint8(95),
	17902: uint8(95),
	17903: uint8(95),
	17920: uint8(21),
	17921: uint8(21),
	17922: uint8(21),
	17923: uint8(21),
	17924: uint8(21),
	17925: uint8(21),
	17926: uint8(21),
	17927: uint8(21),
	17928: uint8(21),
	17929: uint8(21),
	17930: uint8(15),
	17931: uint8(21),
	17932: uint8(21),
	17933: uint8(21),
	17934: uint8(21),
	17935: uint8(21),
	17936: uint8(21),
	17937: uint8(21),
	17938: uint8(21),
	17939: uint8(21),
	17940: uint8(21),
	17941: uint8(21),
	17942: uint8(21),
	17943: uint8(21),
	17944: uint8(21),
	17945: uint8(21),
	17946: uint8(21),
	17947: uint8(21),
	17948: uint8(21),
	17949: uint8(21),
	17950: uint8(21),
	17957: uint8(21),
	17958: uint8(21),
	17959: uint8(21),
	17960: uint8(21),
	17961: uint8(21),
	17962: uint8(21),
	17984: uint8(95),
	17985: uint8(95),
	17986: uint8(95),
	17987: uint8(95),
	17988: uint8(95),
	17989: uint8(95),
	17990: uint8(95),
	17992: uint8(95),
	17993: uint8(95),
	17994: uint8(95),
	17995: uint8(95),
	17996: uint8(95),
	17997: uint8(95),
	17998: uint8(95),
	17999: uint8(95),
	18000: uint8(95),
	18001: uint8(95),
	18002: uint8(95),
	18003: uint8(95),
	18004: uint8(95),
	18005: uint8(95),
	18006: uint8(95),
	18007: uint8(95),
	18008: uint8(95),
	18011: uint8(95),
	18012: uint8(95),
	18013: uint8(95),
	18014: uint8(95),
	18015: uint8(95),
	18016: uint8(95),
	18017: uint8(95),
	18019: uint8(95),
	18020: uint8(95),
	18022: uint8(95),
	18023: uint8(95),
	18024: uint8(95),
	18025: uint8(95),
	18026: uint8(95),
	18032: uint8(94),
	18033: uint8(94),
	18034: uint8(94),
	18035: uint8(94),
	18036: uint8(94),
	18037: uint8(94),
	18038: uint8(94),
	18039: uint8(94),
	18040: uint8(94),
	18041: uint8(94),
	18042: uint8(94),
	18043: uint8(94),
	18044: uint8(94),
	18045: uint8(94),
	18046: uint8(94),
	18047: uint8(94),
	18048: uint8(94),
	18049: uint8(94),
	18050: uint8(94),
	18051: uint8(94),
	18052: uint8(94),
	18053: uint8(94),
	18054: uint8(94),
	18055: uint8(94),
	18056: uint8(94),
	18057: uint8(94),
	18058: uint8(94),
	18059: uint8(94),
	18060: uint8(94),
	18061: uint8(94),
	18095: uint8(95),
	18112: uint8(15),
	18113: uint8(15),
	18114: uint8(15),
	18115: uint8(15),
	18116: uint8(15),
	18117: uint8(15),
	18118: uint8(15),
	18119: uint8(15),
	18120: uint8(15),
	18121: uint8(15),
	18122: uint8(15),
	18123: uint8(15),
	18124: uint8(15),
	18128: uint8(95),
	18129: uint8(95),
	18130: uint8(95),
	18131: uint8(95),
	18132: uint8(95),
	18133: uint8(95),
	18134: uint8(95),
	18135: uint8(94),
	18136: uint8(94),
	18137: uint8(94),
	18138: uint8(94),
	18139: uint8(94),
	18140: uint8(94),
	18141: uint8(94),
	18144: uint8(9),
	18145: uint8(9),
	18146: uint8(9),
	18147: uint8(9),
	18148: uint8(9),
	18149: uint8(9),
	18150: uint8(9),
	18151: uint8(9),
	18152: uint8(9),
	18153: uint8(9),
	18158: uint8(15),
	18159: uint8(14),
	18176: uint8(15),
	18177: uint8(15),
	18178: uint8(15),
	18179: uint8(15),
	18180: uint8(15),
	18181: uint8(15),
	18182: uint8(15),
	18183: uint8(15),
	18184: uint8(15),
	18185: uint8(15),
	18186: uint8(15),
	18187: uint8(15),
	18188: uint8(15),
	18189: uint8(15),
	18190: uint8(95),
	18208: uint8(15),
	18209: uint8(15),
	18210: uint8(15),
	18211: uint8(15),
	18212: uint8(15),
	18213: uint8(15),
	18214: uint8(15),
	18215: uint8(15),
	18216: uint8(15),
	18217: uint8(15),
	18218: uint8(15),
	18219: uint8(15),
	18220: uint8(95),
	18221: uint8(95),
	18222: uint8(95),
	18223: uint8(95),
	18224: uint8(9),
	18225: uint8(9),
	18226: uint8(9),
	18227: uint8(9),
	18228: uint8(9),
	18229: uint8(9),
	18230: uint8(9),
	18231: uint8(9),
	18232: uint8(9),
	18233: uint8(9),
	18239: uint8(4),
	18240: uint8(15),
	18241: uint8(15),
	18242: uint8(15),
	18243: uint8(15),
	18244: uint8(15),
	18245: uint8(15),
	18246: uint8(15),
	18247: uint8(15),
	18248: uint8(15),
	18249: uint8(15),
	18250: uint8(15),
	18251: uint8(94),
	18252: uint8(95),
	18253: uint8(95),
	18254: uint8(95),
	18255: uint8(95),
	18256: uint8(9),
	18257: uint8(9),
	18258: uint8(9),
	18259: uint8(9),
	18260: uint8(9),
	18261: uint8(9),
	18262: uint8(9),
	18263: uint8(9),
	18264: uint8(9),
	18265: uint8(9),
	18272: uint8(15),
	18273: uint8(15),
	18274: uint8(15),
	18275: uint8(15),
	18276: uint8(15),
	18277: uint8(15),
	18278: uint8(15),
	18279: uint8(15),
	18280: uint8(15),
	18281: uint8(15),
	18282: uint8(15),
	18283: uint8(15),
	18284: uint8(15),
	18285: uint8(15),
	18286: uint8(95),
	18287: uint8(95),
	18288: uint8(15),
	18289: uint8(9),
	18290: uint8(9),
	18291: uint8(9),
	18292: uint8(9),
	18293: uint8(9),
	18294: uint8(9),
	18295: uint8(9),
	18296: uint8(9),
	18297: uint8(9),
	18298: uint8(9),
	18303: uint8(3),
	18304: uint8(15),
	18305: uint8(15),
	18306: uint8(15),
	18307: uint8(15),
	18308: uint8(15),
	18309: uint8(15),
	18310: uint8(15),
	18312: uint8(15),
	18313: uint8(15),
	18314: uint8(15),
	18315: uint8(15),
	18317: uint8(15),
	18318: uint8(15),
	18320: uint8(15),
	18321: uint8(15),
	18322: uint8(15),
	18323: uint8(15),
	18324: uint8(15),
	18325: uint8(15),
	18326: uint8(15),
	18327: uint8(15),
	18328: uint8(15),
	18329: uint8(15),
	18330: uint8(15),
	18331: uint8(15),
	18332: uint8(15),
	18333: uint8(15),
	18334: uint8(15),
	18336: uint8(15),
	18337: uint8(15),
	18338: uint8(15),
	18339: uint8(15),
	18340: uint8(15),
	18343: uint8(18),
	18344: uint8(18),
	18345: uint8(18),
	18346: uint8(18),
	18347: uint8(18),
	18348: uint8(18),
	18349: uint8(18),
	18350: uint8(18),
	18351: uint8(18),
	18352: uint8(95),
	18353: uint8(95),
	18354: uint8(95),
	18355: uint8(95),
	18356: uint8(95),
	18357: uint8(95),
	18358: uint8(95),
	18368: uint8(210),
	18369: uint8(210),
	18370: uint8(210),
	18371: uint8(210),
	18372: uint8(210),
	18373: uint8(210),
	18374: uint8(210),
	18375: uint8(210),
	18376: uint8(210),
	18377: uint8(210),
	18378: uint8(210),
	18379: uint8(210),
	18380: uint8(210),
	18381: uint8(210),
	18382: uint8(210),
	18383: uint8(210),
	18384: uint8(210),
	18385: uint8(210),
	18386: uint8(210),
	18387: uint8(210),
	18388: uint8(210),
	18389: uint8(210),
	18390: uint8(210),
	18391: uint8(210),
	18392: uint8(210),
	18393: uint8(210),
	18394: uint8(210),
	18395: uint8(210),
	18396: uint8(210),
	18397: uint8(210),
	18398: uint8(210),
	18399: uint8(210),
	18400: uint8(210),
	18401: uint8(210),
	18402: uint8(211),
	18403: uint8(211),
	18404: uint8(211),
	18405: uint8(211),
	18406: uint8(211),
	18407: uint8(211),
	18408: uint8(211),
	18409: uint8(211),
	18410: uint8(211),
	18411: uint8(211),
	18412: uint8(211),
	18413: uint8(211),
	18414: uint8(211),
	18415: uint8(211),
	18416: uint8(211),
	18417: uint8(211),
	18418: uint8(211),
	18419: uint8(211),
	18420: uint8(211),
	18421: uint8(211),
	18422: uint8(211),
	18423: uint8(211),
	18424: uint8(211),
	18425: uint8(211),
	18426: uint8(211),
	18427: uint8(211),
	18428: uint8(211),
	18429: uint8(211),
	18430: uint8(211),
	18431: uint8(211),
	18432: uint8(211),
	18433: uint8(211),
	18434: uint8(211),
	18435: uint8(211),
	18436: uint8(95),
	18437: uint8(95),
	18438: uint8(95),
	18439: uint8(95),
	18440: uint8(95),
	18441: uint8(95),
	18442: uint8(95),
	18443: uint8(94),
	18448: uint8(9),
	18449: uint8(9),
	18450: uint8(9),
	18451: uint8(9),
	18452: uint8(9),
	18453: uint8(9),
	18454: uint8(9),
	18455: uint8(9),
	18456: uint8(9),
	18457: uint8(9),
	18462: uint8(3),
	18463: uint8(3),
	18481: uint8(18),
	18482: uint8(18),
	18483: uint8(18),
	18484: uint8(18),
	18485: uint8(18),
	18486: uint8(18),
	18487: uint8(18),
	18488: uint8(18),
	18489: uint8(18),
	18490: uint8(18),
	18491: uint8(18),
	18492: uint8(18),
	18493: uint8(18),
	18494: uint8(18),
	18495: uint8(18),
	18496: uint8(18),
	18497: uint8(18),
	18498: uint8(18),
	18499: uint8(18),
	18500: uint8(18),
	18501: uint8(18),
	18502: uint8(18),
	18503: uint8(18),
	18504: uint8(18),
	18505: uint8(18),
	18506: uint8(18),
	18507: uint8(18),
	18508: uint8(14),
	18509: uint8(18),
	18510: uint8(18),
	18511: uint8(18),
	18512: uint8(4),
	18513: uint8(18),
	18514: uint8(18),
	18515: uint8(18),
	18516: uint8(18),
	18529: uint8(18),
	18530: uint8(18),
	18531: uint8(18),
	18532: uint8(18),
	18533: uint8(18),
	18534: uint8(18),
	18535: uint8(18),
	18536: uint8(18),
	18537: uint8(18),
	18538: uint8(18),
	18539: uint8(18),
	18540: uint8(18),
	18541: uint8(18),
	18542: uint8(18),
	18543: uint8(18),
	18544: uint8(18),
	18545: uint8(18),
	18546: uint8(18),
	18547: uint8(18),
	18548: uint8(18),
	18549: uint8(18),
	18550: uint8(18),
	18551: uint8(18),
	18552: uint8(18),
	18553: uint8(18),
	18554: uint8(18),
	18555: uint8(18),
	18556: uint8(18),
	18557: uint8(18),
	18558: uint8(18),
	18559: uint8(18),
	18560: uint8(18),
	18561: uint8(18),
	18562: uint8(18),
	18563: uint8(18),
	18564: uint8(18),
	18565: uint8(18),
	18566: uint8(18),
	18567: uint8(18),
	18568: uint8(18),
	18569: uint8(18),
	18570: uint8(18),
	18571: uint8(18),
	18572: uint8(18),
	18573: uint8(18),
	18574: uint8(14),
	18575: uint8(18),
	18576: uint8(18),
	18577: uint8(18),
	18578: uint8(18),
	18579: uint8(18),
	18580: uint8(18),
	18581: uint8(18),
	18582: uint8(18),
	18583: uint8(18),
	18584: uint8(18),
	18585: uint8(18),
	18586: uint8(18),
	18587: uint8(18),
	18588: uint8(18),
	18589: uint8(18),
	18592: uint8(15),
	18593: uint8(15),
	18594: uint8(15),
	18595: uint8(15),
	18597: uint8(15),
	18598: uint8(15),
	18599: uint8(15),
	18600: uint8(15),
	18601: uint8(15),
	18602: uint8(15),
	18603: uint8(15),
	18604: uint8(15),
	18605: uint8(15),
	18606: uint8(15),
	18607: uint8(15),
	18608: uint8(15),
	18609: uint8(15),
	18610: uint8(15),
	18611: uint8(15),
	18612: uint8(15),
	18613: uint8(15),
	18614: uint8(15),
	18615: uint8(15),
	18616: uint8(15),
	18617: uint8(15),
	18618: uint8(15),
	18619: uint8(15),
	18620: uint8(15),
	18621: uint8(15),
	18622: uint8(15),
	18623: uint8(15),
	18625: uint8(15),
	18626: uint8(15),
	18628: uint8(15),
	18631: uint8(15),
	18633: uint8(15),
	18634: uint8(15),
	18635: uint8(15),
	18636: uint8(15),
	18637: uint8(15),
	18638: uint8(15),
	18639: uint8(15),
	18640: uint8(15),
	18641: uint8(15),
	18642: uint8(15),
	18644: uint8(15),
	18645: uint8(15),
	18646: uint8(15),
	18647: uint8(15),
	18649: uint8(15),
	18651: uint8(15),
	18658: uint8(15),
	18663: uint8(15),
	18665: uint8(15),
	18667: uint8(15),
	18669: uint8(15),
	18670: uint8(15),
	18671: uint8(15),
	18673: uint8(15),
	18674: uint8(15),
	18676: uint8(15),
	18679: uint8(15),
	18681: uint8(15),
	18683: uint8(15),
	18685: uint8(15),
	18687: uint8(15),
	18689: uint8(15),
	18690: uint8(15),
	18692: uint8(15),
	18695: uint8(15),
	18696: uint8(15),
	18697: uint8(15),
	18698: uint8(15),
	18700: uint8(15),
	18701: uint8(15),
	18702: uint8(15),
	18703: uint8(15),
	18704: uint8(15),
	18705: uint8(15),
	18706: uint8(15),
	18708: uint8(15),
	18709: uint8(15),
	18710: uint8(15),
	18711: uint8(15),
	18713: uint8(15),
	18714: uint8(15),
	18715: uint8(15),
	18716: uint8(15),
	18718: uint8(15),
	18720: uint8(15),
	18721: uint8(15),
	18722: uint8(15),
	18723: uint8(15),
	18724: uint8(15),
	18725: uint8(15),
	18726: uint8(15),
	18727: uint8(15),
	18728: uint8(15),
	18729: uint8(15),
	18731: uint8(15),
	18732: uint8(15),
	18733: uint8(15),
	18734: uint8(15),
	18735: uint8(15),
	18736: uint8(15),
	18737: uint8(15),
	18738: uint8(15),
	18739: uint8(15),
	18740: uint8(15),
	18741: uint8(15),
	18742: uint8(15),
	18743: uint8(15),
	18744: uint8(15),
	18745: uint8(15),
	18746: uint8(15),
	18747: uint8(15),
	18753: uint8(15),
	18754: uint8(15),
	18755: uint8(15),
	18757: uint8(15),
	18758: uint8(15),
	18759: uint8(15),
	18760: uint8(15),
	18761: uint8(15),
	18763: uint8(15),
	18764: uint8(15),
	18765: uint8(15),
	18766: uint8(15),
	18767: uint8(15),
	18768: uint8(15),
	18769: uint8(15),
	18770: uint8(15),
	18771: uint8(15),
	18772: uint8(15),
	18773: uint8(15),
	18774: uint8(15),
	18775: uint8(15),
	18776: uint8(15),
	18777: uint8(15),
	18778: uint8(15),
	18779: uint8(15),
	18800: uint8(7),
	18801: uint8(7),
	18816: uint8(14),
	18817: uint8(14),
	18818: uint8(14),
	18819: uint8(14),
	18820: uint8(14),
	18821: uint8(14),
	18822: uint8(14),
	18823: uint8(14),
	18824: uint8(14),
	18825: uint8(14),
	18826: uint8(14),
	18827: uint8(14),
	18832: uint8(14),
	18833: uint8(14),
	18834: uint8(14),
	18835: uint8(14),
	18836: uint8(14),
	18837: uint8(14),
	18838: uint8(14),
	18839: uint8(14),
	18840: uint8(14),
	18841: uint8(14),
	18842: uint8(14),
	18843: uint8(14),
	18844: uint8(14),
	18845: uint8(14),
	18846: uint8(14),
	18847: uint8(14),
	18848: uint8(14),
	18849: uint8(14),
	18850: uint8(14),
	18851: uint8(14),
	18852: uint8(14),
	18853: uint8(14),
	18854: uint8(14),
	18855: uint8(14),
	18856: uint8(14),
	18857: uint8(14),
	18858: uint8(14),
	18859: uint8(14),
	18860: uint8(14),
	18861: uint8(14),
	18862: uint8(14),
	18865: uint8(14),
	18866: uint8(14),
	18867: uint8(14),
	18868: uint8(14),
	18869: uint8(14),
	18870: uint8(14),
	18871: uint8(14),
	18872: uint8(14),
	18873: uint8(14),
	18874: uint8(14),
	18875: uint8(14),
	18876: uint8(14),
	18877: uint8(14),
	18878: uint8(14),
	18879: uint8(14),
	18881: uint8(14),
	18882: uint8(14),
	18883: uint8(14),
	18884: uint8(14),
	18885: uint8(14),
	18886: uint8(14),
	18887: uint8(14),
	18888: uint8(14),
	18889: uint8(14),
	18890: uint8(14),
	18891: uint8(14),
	18892: uint8(14),
	18893: uint8(14),
	18894: uint8(14),
	18895: uint8(14),
	18897: uint8(14),
	18898: uint8(14),
	18899: uint8(14),
	18900: uint8(14),
	18901: uint8(14),
	18902: uint8(14),
	18903: uint8(14),
	18904: uint8(14),
	18905: uint8(14),
	18906: uint8(14),
	18907: uint8(14),
	18908: uint8(14),
	18909: uint8(14),
	18910: uint8(14),
	18911: uint8(14),
	18912: uint8(18),
	18913: uint8(18),
	18914: uint8(18),
	18915: uint8(18),
	18916: uint8(18),
	18917: uint8(18),
	18918: uint8(18),
	18919: uint8(18),
	18920: uint8(18),
	18921: uint8(18),
	18922: uint8(18),
	18923: uint8(18),
	18924: uint8(18),
	18925: uint8(14),
	18926: uint8(14),
	18927: uint8(14),
	18928: uint8(14),
	18929: uint8(14),
	18930: uint8(14),
	18931: uint8(14),
	18932: uint8(14),
	18933: uint8(14),
	18934: uint8(14),
	18935: uint8(14),
	18936: uint8(14),
	18937: uint8(14),
	18938: uint8(14),
	18939: uint8(14),
	18940: uint8(14),
	18941: uint8(14),
	18942: uint8(14),
	18943: uint8(14),
	18944: uint8(14),
	18945: uint8(14),
	18946: uint8(14),
	18947: uint8(14),
	18948: uint8(14),
	18949: uint8(14),
	18950: uint8(14),
	18951: uint8(14),
	18952: uint8(14),
	18953: uint8(14),
	18954: uint8(14),
	18955: uint8(14),
	18956: uint8(14),
	18957: uint8(14),
	18982: uint8(14),
	18983: uint8(14),
	18984: uint8(14),
	18985: uint8(14),
	18986: uint8(14),
	18987: uint8(14),
	18988: uint8(14),
	18989: uint8(14),
	18990: uint8(14),
	18991: uint8(14),
	18992: uint8(14),
	18993: uint8(14),
	18994: uint8(14),
	18995: uint8(14),
	18996: uint8(14),
	18997: uint8(14),
	18998: uint8(14),
	18999: uint8(14),
	19000: uint8(14),
	19001: uint8(14),
	19002: uint8(14),
	19003: uint8(14),
	19004: uint8(14),
	19005: uint8(14),
	19006: uint8(14),
	19007: uint8(14),
	19008: uint8(14),
	19009: uint8(14),
	19010: uint8(14),
	19024: uint8(14),
	19025: uint8(14),
	19026: uint8(14),
	19027: uint8(14),
	19028: uint8(14),
	19029: uint8(14),
	19030: uint8(14),
	19031: uint8(14),
	19032: uint8(14),
	19033: uint8(14),
	19034: uint8(14),
	19035: uint8(14),
	19036: uint8(14),
	19037: uint8(14),
	19038: uint8(14),
	19039: uint8(14),
	19040: uint8(14),
	19041: uint8(14),
	19042: uint8(14),
	19043: uint8(14),
	19044: uint8(14),
	19045: uint8(14),
	19046: uint8(14),
	19047: uint8(14),
	19048: uint8(14),
	19049: uint8(14),
	19050: uint8(14),
	19051: uint8(14),
	19052: uint8(14),
	19053: uint8(14),
	19054: uint8(14),
	19055: uint8(14),
	19056: uint8(14),
	19057: uint8(14),
	19058: uint8(14),
	19059: uint8(14),
	19060: uint8(14),
	19061: uint8(14),
	19062: uint8(14),
	19063: uint8(14),
	19064: uint8(14),
	19065: uint8(14),
	19066: uint8(14),
	19067: uint8(14),
	19072: uint8(14),
	19073: uint8(14),
	19074: uint8(14),
	19075: uint8(14),
	19076: uint8(14),
	19077: uint8(14),
	19078: uint8(14),
	19079: uint8(14),
	19080: uint8(14),
	19088: uint8(14),
	19089: uint8(14),
	19104: uint8(14),
	19105: uint8(14),
	19106: uint8(14),
	19107: uint8(14),
	19108: uint8(14),
	19109: uint8(14),
	19136: uint8(14),
	19137: uint8(14),
	19138: uint8(14),
	19139: uint8(14),
	19140: uint8(14),
	19141: uint8(14),
	19142: uint8(14),
	19143: uint8(14),
	19144: uint8(14),
	19145: uint8(14),
	19146: uint8(14),
	19147: uint8(14),
	19148: uint8(14),
	19149: uint8(14),
	19150: uint8(14),
	19151: uint8(14),
	19152: uint8(14),
	19153: uint8(14),
	19154: uint8(14),
	19155: uint8(14),
	19156: uint8(14),
	19157: uint8(14),
	19158: uint8(14),
	19159: uint8(14),
	19160: uint8(14),
	19161: uint8(14),
	19162: uint8(14),
	19163: uint8(11),
	19164: uint8(11),
	19165: uint8(11),
	19166: uint8(11),
	19167: uint8(11),
	19168: uint8(14),
	19169: uint8(14),
	19170: uint8(14),
	19171: uint8(14),
	19172: uint8(14),
	19173: uint8(14),
	19174: uint8(14),
	19175: uint8(14),
	19176: uint8(14),
	19177: uint8(14),
	19178: uint8(14),
	19179: uint8(14),
	19180: uint8(14),
	19181: uint8(14),
	19182: uint8(14),
	19183: uint8(14),
	19184: uint8(14),
	19185: uint8(14),
	19186: uint8(14),
	19187: uint8(14),
	19188: uint8(14),
	19189: uint8(14),
	19190: uint8(14),
	19191: uint8(14),
	19196: uint8(14),
	19197: uint8(14),
	19198: uint8(14),
	19199: uint8(14),
	19200: uint8(14),
	19201: uint8(14),
	19202: uint8(14),
	19203: uint8(14),
	19204: uint8(14),
	19205: uint8(14),
	19206: uint8(14),
	19207: uint8(14),
	19208: uint8(14),
	19209: uint8(14),
	19210: uint8(14),
	19211: uint8(14),
	19212: uint8(14),
	19216: uint8(14),
	19217: uint8(14),
	19218: uint8(14),
	19219: uint8(14),
	19220: uint8(14),
	19221: uint8(14),
	19222: uint8(14),
	19223: uint8(14),
	19224: uint8(14),
	19225: uint8(14),
	19226: uint8(14),
	19227: uint8(14),
	19228: uint8(14),
	19232: uint8(14),
	19233: uint8(14),
	19234: uint8(14),
	19235: uint8(14),
	19236: uint8(14),
	19237: uint8(14),
	19238: uint8(14),
	19239: uint8(14),
	19240: uint8(14),
	19241: uint8(14),
	19242: uint8(14),
	19243: uint8(14),
	19244: uint8(14),
	19245: uint8(14),
	19246: uint8(14),
	19247: uint8(14),
	19248: uint8(14),
	19249: uint8(14),
	19250: uint8(14),
	19251: uint8(14),
	19252: uint8(14),
	19253: uint8(14),
	19254: uint8(14),
	19259: uint8(14),
	19260: uint8(14),
	19261: uint8(14),
	19262: uint8(14),
	19263: uint8(14),
	19264: uint8(14),
	19265: uint8(14),
	19266: uint8(14),
	19267: uint8(14),
	19268: uint8(14),
	19269: uint8(14),
	19270: uint8(14),
	19271: uint8(14),
	19272: uint8(14),
	19273: uint8(14),
	19274: uint8(14),
	19275: uint8(14),
	19276: uint8(14),
	19277: uint8(14),
	19278: uint8(14),
	19279: uint8(14),
	19280: uint8(14),
	19281: uint8(14),
	19282: uint8(14),
	19283: uint8(14),
	19284: uint8(14),
	19285: uint8(14),
	19286: uint8(14),
	19287: uint8(14),
	19288: uint8(14),
	19289: uint8(14),
	19296: uint8(14),
	19297: uint8(14),
	19298: uint8(14),
	19299: uint8(14),
	19300: uint8(14),
	19301: uint8(14),
	19302: uint8(14),
	19303: uint8(14),
	19304: uint8(14),
	19305: uint8(14),
	19306: uint8(14),
	19307: uint8(14),
	19312: uint8(14),
	19328: uint8(14),
	19329: uint8(14),
	19330: uint8(14),
	19331: uint8(14),
	19332: uint8(14),
	19333: uint8(14),
	19334: uint8(14),
	19335: uint8(14),
	19344: uint8(14),
	19345: uint8(14),
	19346: uint8(14),
	19347: uint8(14),
	19348: uint8(14),
	19349: uint8(14),
	19350: uint8(14),
	19351: uint8(14),
	19352: uint8(14),
	19353: uint8(14),
	19360: uint8(14),
	19361: uint8(14),
	19362: uint8(14),
	19363: uint8(14),
	19364: uint8(14),
	19365: uint8(14),
	19366: uint8(14),
	19367: uint8(14),
	19376: uint8(14),
	19377: uint8(14),
	19378: uint8(14),
	19379: uint8(14),
	19380: uint8(14),
	19381: uint8(14),
	19382: uint8(14),
	19383: uint8(14),
	19384: uint8(14),
	19385: uint8(14),
	19386: uint8(14),
	19387: uint8(14),
	19388: uint8(14),
	19389: uint8(14),
	19390: uint8(14),
	19391: uint8(14),
	19392: uint8(14),
	19393: uint8(14),
	19394: uint8(14),
	19395: uint8(14),
	19396: uint8(14),
	19397: uint8(14),
	19398: uint8(14),
	19399: uint8(14),
	19400: uint8(14),
	19401: uint8(14),
	19402: uint8(14),
	19403: uint8(14),
	19404: uint8(14),
	19405: uint8(14),
	19408: uint8(14),
	19409: uint8(14),
	19410: uint8(14),
	19411: uint8(14),
	19412: uint8(14),
	19413: uint8(14),
	19414: uint8(14),
	19415: uint8(14),
	19416: uint8(14),
	19417: uint8(14),
	19418: uint8(14),
	19419: uint8(14),
	19424: uint8(14),
	19425: uint8(14),
	19456: uint8(14),
	19457: uint8(14),
	19458: uint8(14),
	19459: uint8(14),
	19460: uint8(14),
	19461: uint8(14),
	19462: uint8(14),
	19463: uint8(14),
	19464: uint8(14),
	19465: uint8(14),
	19466: uint8(14),
	19467: uint8(14),
	19468: uint8(14),
	19469: uint8(14),
	19472: uint8(14),
	19473: uint8(14),
	19474: uint8(14),
	19475: uint8(14),
	19476: uint8(14),
	19477: uint8(14),
	19478: uint8(14),
	19479: uint8(14),
	19480: uint8(14),
	19481: uint8(14),
	19482: uint8(14),
	19483: uint8(14),
	19484: uint8(14),
	19488: uint8(14),
	19489: uint8(14),
	19490: uint8(14),
	19491: uint8(14),
	19492: uint8(14),
	19493: uint8(14),
	19494: uint8(14),
	19495: uint8(14),
	19496: uint8(14),
	19497: uint8(14),
	19503: uint8(14),
	19504: uint8(14),
	19505: uint8(14),
	19506: uint8(14),
	19507: uint8(14),
	19508: uint8(14),
	19509: uint8(14),
	19510: uint8(14),
	19511: uint8(14),
	19512: uint8(14),
	19513: uint8(14),
	19514: uint8(14),
	19515: uint8(14),
	19516: uint8(14),
	19517: uint8(14),
	19518: uint8(14),
	19519: uint8(14),
	19520: uint8(14),
	19521: uint8(14),
	19522: uint8(14),
	19523: uint8(14),
	19524: uint8(14),
	19525: uint8(14),
	19526: uint8(14),
	19534: uint8(14),
	19535: uint8(14),
	19536: uint8(14),
	19537: uint8(14),
	19538: uint8(14),
	19539: uint8(14),
	19540: uint8(14),
	19541: uint8(14),
	19542: uint8(14),
	19543: uint8(14),
	19544: uint8(14),
	19545: uint8(14),
	19546: uint8(14),
	19547: uint8(14),
	19548: uint8(14),
	19551: uint8(14),
	19552: uint8(14),
	19553: uint8(14),
	19554: uint8(14),
	19555: uint8(14),
	19556: uint8(14),
	19557: uint8(14),
	19558: uint8(14),
	19559: uint8(14),
	19560: uint8(14),
	19561: uint8(14),
	19568: uint8(14),
	19569: uint8(14),
	19570: uint8(14),
	19571: uint8(14),
	19572: uint8(14),
	19573: uint8(14),
	19574: uint8(14),
	19575: uint8(14),
	19576: uint8(14),
	19584: uint8(14),
	19585: uint8(14),
	19586: uint8(14),
	19587: uint8(14),
	19588: uint8(14),
	19589: uint8(14),
	19590: uint8(14),
	19591: uint8(14),
	19592: uint8(14),
	19593: uint8(14),
	19594: uint8(14),
	19595: uint8(14),
	19596: uint8(14),
	19597: uint8(14),
	19598: uint8(14),
	19599: uint8(14),
	19600: uint8(14),
	19601: uint8(14),
	19602: uint8(14),
	19604: uint8(14),
	19605: uint8(14),
	19606: uint8(14),
	19607: uint8(14),
	19608: uint8(14),
	19609: uint8(14),
	19610: uint8(14),
	19611: uint8(14),
	19612: uint8(14),
	19613: uint8(14),
	19614: uint8(14),
	19615: uint8(14),
	19616: uint8(15),
	19617: uint8(15),
	19632: uint8(15),
	19633: uint8(15),
	19634: uint8(15),
	19635: uint8(15),
	19636: uint8(15),
	19637: uint8(15),
	19638: uint8(15),
	19639: uint8(15),
	19640: uint8(15),
	19641: uint8(15),
	19642: uint8(15),
	19643: uint8(15),
	19644: uint8(15),
	19645: uint8(15),
	19646: uint8(15),
	19647: uint8(15),
	19648: uint8(15),
	19664: uint8(15),
	19665: uint8(15),
	19666: uint8(15),
	19667: uint8(15),
	19668: uint8(15),
	19669: uint8(15),
	19670: uint8(15),
	19671: uint8(15),
	19672: uint8(15),
	19673: uint8(15),
	19674: uint8(15),
	19675: uint8(15),
	19676: uint8(15),
	19677: uint8(15),
	19678: uint8(15),
	19679: uint8(15),
}

/*
 * Each group represents a unique set of character attributes.  The attributes
 * are encoded into a 32-bit value as follows:
 *
 * Bits 0-4	Character category: see the constants listed below.
 *
 * Bits 5-7	Case delta type: 000 = identity
 *				 010 = add delta for lower
 *				 011 = add delta for lower, add 1 for title
 *				 100 = subtract delta for title/upper
 *				 101 = sub delta for upper, sub 1 for title
 *				 110 = sub delta for upper, add delta for lower
 *				 111 = subtract delta for upper
 *
 * Bits 8-31	Case delta: delta for case conversions.  This should be the
 *			    highest field so we can easily sign extend.
 */

var _groups = [212]int32{
	1:   int32(15),
	2:   int32(12),
	3:   int32(25),
	4:   int32(27),
	5:   int32(21),
	6:   int32(22),
	7:   int32(26),
	8:   int32(20),
	9:   int32(9),
	10:  int32(8257),
	11:  int32(28),
	12:  int32(19),
	13:  int32(8322),
	14:  int32(29),
	15:  int32(5),
	16:  int32(23),
	17:  int32(16),
	18:  int32(11),
	19:  -int32(190078),
	20:  int32(24),
	21:  int32(2),
	22:  -int32(30846),
	23:  int32(321),
	24:  int32(386),
	25:  -int32(50879),
	26:  int32(59522),
	27:  -int32(30911),
	28:  int32(76930),
	29:  -int32(49790),
	30:  int32(53825),
	31:  int32(52801),
	32:  int32(52545),
	33:  int32(20289),
	34:  int32(51777),
	35:  int32(52033),
	36:  int32(53057),
	37:  -int32(24702),
	38:  int32(54081),
	39:  int32(53569),
	40:  -int32(41598),
	41:  -int32(10895486),
	42:  int32(54593),
	43:  -int32(33150),
	44:  int32(54849),
	45:  int32(55873),
	46:  int32(55617),
	47:  int32(56129),
	48:  -int32(14206),
	49:  int32(609),
	50:  int32(451),
	51:  int32(674),
	52:  int32(20354),
	53:  -int32(24767),
	54:  -int32(14271),
	55:  -int32(33215),
	56:  int32(2763585),
	57:  -int32(41663),
	58:  int32(2762817),
	59:  -int32(2768510),
	60:  -int32(49855),
	61:  int32(17729),
	62:  int32(18241),
	63:  -int32(2760318),
	64:  -int32(2759550),
	65:  -int32(2760062),
	66:  int32(53890),
	67:  int32(52866),
	68:  int32(52610),
	69:  int32(51842),
	70:  int32(52098),
	71:  -int32(10833534),
	72:  -int32(10832510),
	73:  int32(53122),
	74:  -int32(10839678),
	75:  -int32(10823550),
	76:  -int32(10830718),
	77:  int32(53634),
	78:  int32(54146),
	79:  -int32(2750078),
	80:  -int32(10829950),
	81:  -int32(2751614),
	82:  int32(54658),
	83:  int32(54914),
	84:  -int32(2745982),
	85:  int32(55938),
	86:  -int32(10830462),
	87:  -int32(10824062),
	88:  int32(17794),
	89:  int32(55682),
	90:  int32(18306),
	91:  int32(56194),
	92:  -int32(10818686),
	93:  -int32(10817918),
	94:  int32(4),
	95:  int32(6),
	96:  -int32(21370),
	97:  int32(29761),
	98:  int32(9793),
	99:  int32(9537),
	100: int32(16449),
	101: int32(16193),
	102: int32(9858),
	103: int32(9602),
	104: int32(8066),
	105: int32(16514),
	106: int32(16258),
	107: int32(2113),
	108: int32(16002),
	109: int32(14722),
	110: int32(1),
	111: int32(12162),
	112: int32(13954),
	113: int32(2178),
	114: int32(22146),
	115: int32(20610),
	116: -int32(1662),
	117: int32(29826),
	118: -int32(15295),
	119: int32(24706),
	120: -int32(1727),
	121: int32(20545),
	122: int32(7),
	123: int32(3905),
	124: int32(3970),
	125: int32(12353),
	126: int32(12418),
	127: int32(8),
	128: int32(1859649),
	129: -int32(769822),
	130: int32(9949249),
	131: int32(10),
	132: int32(1601154),
	133: int32(1600898),
	134: int32(1598594),
	135: int32(1598082),
	136: int32(1598338),
	137: int32(1596546),
	138: int32(1582466),
	139: -int32(9027966),
	140: -int32(769983),
	141: -int32(9044862),
	142: -int32(976254),
	143: -int32(9058174),
	144: int32(15234),
	145: -int32(1949375),
	146: -int32(1918),
	147: -int32(1983),
	148: -int32(18814),
	149: -int32(21886),
	150: -int32(25470),
	151: -int32(32638),
	152: -int32(28542),
	153: -int32(32126),
	154: -int32(1981),
	155: -int32(2174),
	156: -int32(18879),
	157: -int32(2237),
	158: int32(1844610),
	159: -int32(21951),
	160: -int32(25535),
	161: -int32(28607),
	162: -int32(32703),
	163: -int32(32191),
	164: int32(13),
	165: int32(14),
	166: -int32(1924287),
	167: -int32(2145983),
	168: -int32(2115007),
	169: int32(7233),
	170: int32(7298),
	171: int32(4170),
	172: int32(4234),
	173: int32(6749),
	174: int32(6813),
	175: -int32(2750143),
	176: -int32(976319),
	177: -int32(2746047),
	178: int32(2763650),
	179: int32(2762882),
	180: -int32(2759615),
	181: -int32(2751679),
	182: -int32(2760383),
	183: -int32(2760127),
	184: -int32(2768575),
	185: int32(1859714),
	186: -int32(9044927),
	187: -int32(10823615),
	188: -int32(12158),
	189: -int32(10830783),
	190: -int32(10833599),
	191: -int32(10832575),
	192: -int32(10830015),
	193: -int32(10817983),
	194: -int32(10824127),
	195: -int32(10818751),
	196: int32(237633),
	197: -int32(12223),
	198: -int32(10830527),
	199: -int32(9058239),
	200: -int32(10839743),
	201: -int32(10895551),
	202: int32(237698),
	203: int32(9949314),
	204: int32(18),
	205: int32(17),
	206: int32(10305),
	207: int32(10370),
	208: int32(10049),
	209: int32(10114),
	210: int32(8769),
	211: int32(8834),
}

const UNASSIGNED = 0
const UPPERCASE_LETTER = 1
const LOWERCASE_LETTER = 2
const TITLECASE_LETTER = 3
const MODIFIER_LETTER = 4
const OTHER_LETTER = 5
const NON_SPACING_MARK = 6
const ENCLOSING_MARK = 7
const COMBINING_SPACING_MARK = 8
const DECIMAL_DIGIT_NUMBER = 9
const LETTER_NUMBER = 10
const OTHER_NUMBER = 11
const SPACE_SEPARATOR = 12
const LINE_SEPARATOR = 13
const PARAGRAPH_SEPARATOR = 14
const CONTROL = 15
const FORMAT = 16
const PRIVATE_USE = 17
const SURROGATE = 18
const CONNECTOR_PUNCTUATION = 19
const DASH_PUNCTUATION = 20
const OPEN_PUNCTUATION = 21
const CLOSE_PUNCTUATION = 22
const INITIAL_QUOTE_PUNCTUATION = 23
const FINAL_QUOTE_PUNCTUATION = 24
const OTHER_PUNCTUATION = 25
const MATH_SYMBOL = 26
const CURRENCY_SYMBOL = 27
const MODIFIER_SYMBOL = 28
const OTHER_SYMBOL = 29

/*
 * The following macros extract the fields of the character info.  The
 * GetDelta() macro is complicated because we can't rely on the C compiler
 * to do sign extension on right shifts.
 */

/*
 * This macro extracts the information about a character from the
 * Unicode character tables.
 */

/*
 * The following masks are used for fast character category tests. The x_BITS
 * values are shifted right by the category value to determine whether the
 * given category is included in the set.
 */
type UnicodeCharacterCategoryMasks = int32

const ALPHA_BITS = 62
const CONTROL_BITS = 98304
const DIGIT_BITS = 512
const SPACE_BITS = 28672
const WORD_BITS = 524862
const PUNCT_BITS = 66584576
const GRAPH_BITS = 1073221630

/*
 * Unicode characters less than this value are represented by themselves in
 * UTF-8 strings.
 */

/*
 * The following structures are used when mapping between Unicode and
 * UTF-8.
 */

var _totalBytes = [256]uint8{
	0:   uint8(1),
	1:   uint8(1),
	2:   uint8(1),
	3:   uint8(1),
	4:   uint8(1),
	5:   uint8(1),
	6:   uint8(1),
	7:   uint8(1),
	8:   uint8(1),
	9:   uint8(1),
	10:  uint8(1),
	11:  uint8(1),
	12:  uint8(1),
	13:  uint8(1),
	14:  uint8(1),
	15:  uint8(1),
	16:  uint8(1),
	17:  uint8(1),
	18:  uint8(1),
	19:  uint8(1),
	20:  uint8(1),
	21:  uint8(1),
	22:  uint8(1),
	23:  uint8(1),
	24:  uint8(1),
	25:  uint8(1),
	26:  uint8(1),
	27:  uint8(1),
	28:  uint8(1),
	29:  uint8(1),
	30:  uint8(1),
	31:  uint8(1),
	32:  uint8(1),
	33:  uint8(1),
	34:  uint8(1),
	35:  uint8(1),
	36:  uint8(1),
	37:  uint8(1),
	38:  uint8(1),
	39:  uint8(1),
	40:  uint8(1),
	41:  uint8(1),
	42:  uint8(1),
	43:  uint8(1),
	44:  uint8(1),
	45:  uint8(1),
	46:  uint8(1),
	47:  uint8(1),
	48:  uint8(1),
	49:  uint8(1),
	50:  uint8(1),
	51:  uint8(1),
	52:  uint8(1),
	53:  uint8(1),
	54:  uint8(1),
	55:  uint8(1),
	56:  uint8(1),
	57:  uint8(1),
	58:  uint8(1),
	59:  uint8(1),
	60:  uint8(1),
	61:  uint8(1),
	62:  uint8(1),
	63:  uint8(1),
	64:  uint8(1),
	65:  uint8(1),
	66:  uint8(1),
	67:  uint8(1),
	68:  uint8(1),
	69:  uint8(1),
	70:  uint8(1),
	71:  uint8(1),
	72:  uint8(1),
	73:  uint8(1),
	74:  uint8(1),
	75:  uint8(1),
	76:  uint8(1),
	77:  uint8(1),
	78:  uint8(1),
	79:  uint8(1),
	80:  uint8(1),
	81:  uint8(1),
	82:  uint8(1),
	83:  uint8(1),
	84:  uint8(1),
	85:  uint8(1),
	86:  uint8(1),
	87:  uint8(1),
	88:  uint8(1),
	89:  uint8(1),
	90:  uint8(1),
	91:  uint8(1),
	92:  uint8(1),
	93:  uint8(1),
	94:  uint8(1),
	95:  uint8(1),
	96:  uint8(1),
	97:  uint8(1),
	98:  uint8(1),
	99:  uint8(1),
	100: uint8(1),
	101: uint8(1),
	102: uint8(1),
	103: uint8(1),
	104: uint8(1),
	105: uint8(1),
	106: uint8(1),
	107: uint8(1),
	108: uint8(1),
	109: uint8(1),
	110: uint8(1),
	111: uint8(1),
	112: uint8(1),
	113: uint8(1),
	114: uint8(1),
	115: uint8(1),
	116: uint8(1),
	117: uint8(1),
	118: uint8(1),
	119: uint8(1),
	120: uint8(1),
	121: uint8(1),
	122: uint8(1),
	123: uint8(1),
	124: uint8(1),
	125: uint8(1),
	126: uint8(1),
	127: uint8(1),
	128: uint8(1),
	129: uint8(1),
	130: uint8(1),
	131: uint8(1),
	132: uint8(1),
	133: uint8(1),
	134: uint8(1),
	135: uint8(1),
	136: uint8(1),
	137: uint8(1),
	138: uint8(1),
	139: uint8(1),
	140: uint8(1),
	141: uint8(1),
	142: uint8(1),
	143: uint8(1),
	144: uint8(1),
	145: uint8(1),
	146: uint8(1),
	147: uint8(1),
	148: uint8(1),
	149: uint8(1),
	150: uint8(1),
	151: uint8(1),
	152: uint8(1),
	153: uint8(1),
	154: uint8(1),
	155: uint8(1),
	156: uint8(1),
	157: uint8(1),
	158: uint8(1),
	159: uint8(1),
	160: uint8(1),
	161: uint8(1),
	162: uint8(1),
	163: uint8(1),
	164: uint8(1),
	165: uint8(1),
	166: uint8(1),
	167: uint8(1),
	168: uint8(1),
	169: uint8(1),
	170: uint8(1),
	171: uint8(1),
	172: uint8(1),
	173: uint8(1),
	174: uint8(1),
	175: uint8(1),
	176: uint8(1),
	177: uint8(1),
	178: uint8(1),
	179: uint8(1),
	180: uint8(1),
	181: uint8(1),
	182: uint8(1),
	183: uint8(1),
	184: uint8(1),
	185: uint8(1),
	186: uint8(1),
	187: uint8(1),
	188: uint8(1),
	189: uint8(1),
	190: uint8(1),
	191: uint8(1),
	192: uint8(2),
	193: uint8(1),
	194: uint8(2),
	195: uint8(2),
	196: uint8(2),
	197: uint8(2),
	198: uint8(2),
	199: uint8(2),
	200: uint8(2),
	201: uint8(2),
	202: uint8(2),
	203: uint8(2),
	204: uint8(2),
	205: uint8(2),
	206: uint8(2),
	207: uint8(2),
	208: uint8(2),
	209: uint8(2),
	210: uint8(2),
	211: uint8(2),
	212: uint8(2),
	213: uint8(2),
	214: uint8(2),
	215: uint8(2),
	216: uint8(2),
	217: uint8(2),
	218: uint8(2),
	219: uint8(2),
	220: uint8(2),
	221: uint8(2),
	222: uint8(2),
	223: uint8(2),
	224: uint8(3),
	225: uint8(3),
	226: uint8(3),
	227: uint8(3),
	228: uint8(3),
	229: uint8(3),
	230: uint8(3),
	231: uint8(3),
	232: uint8(3),
	233: uint8(3),
	234: uint8(3),
	235: uint8(3),
	236: uint8(3),
	237: uint8(3),
	238: uint8(3),
	239: uint8(3),
	240: uint8(4),
	241: uint8(4),
	242: uint8(4),
	243: uint8(4),
	244: uint8(4),
	245: uint8(1),
	246: uint8(1),
	247: uint8(1),
	248: uint8(1),
	249: uint8(1),
	250: uint8(1),
	251: uint8(1),
	252: uint8(1),
	253: uint8(1),
	254: uint8(1),
	255: uint8(1),
}

var _complete = [256]uint8{
	0:   uint8(1),
	1:   uint8(1),
	2:   uint8(1),
	3:   uint8(1),
	4:   uint8(1),
	5:   uint8(1),
	6:   uint8(1),
	7:   uint8(1),
	8:   uint8(1),
	9:   uint8(1),
	10:  uint8(1),
	11:  uint8(1),
	12:  uint8(1),
	13:  uint8(1),
	14:  uint8(1),
	15:  uint8(1),
	16:  uint8(1),
	17:  uint8(1),
	18:  uint8(1),
	19:  uint8(1),
	20:  uint8(1),
	21:  uint8(1),
	22:  uint8(1),
	23:  uint8(1),
	24:  uint8(1),
	25:  uint8(1),
	26:  uint8(1),
	27:  uint8(1),
	28:  uint8(1),
	29:  uint8(1),
	30:  uint8(1),
	31:  uint8(1),
	32:  uint8(1),
	33:  uint8(1),
	34:  uint8(1),
	35:  uint8(1),
	36:  uint8(1),
	37:  uint8(1),
	38:  uint8(1),
	39:  uint8(1),
	40:  uint8(1),
	41:  uint8(1),
	42:  uint8(1),
	43:  uint8(1),
	44:  uint8(1),
	45:  uint8(1),
	46:  uint8(1),
	47:  uint8(1),
	48:  uint8(1),
	49:  uint8(1),
	50:  uint8(1),
	51:  uint8(1),
	52:  uint8(1),
	53:  uint8(1),
	54:  uint8(1),
	55:  uint8(1),
	56:  uint8(1),
	57:  uint8(1),
	58:  uint8(1),
	59:  uint8(1),
	60:  uint8(1),
	61:  uint8(1),
	62:  uint8(1),
	63:  uint8(1),
	64:  uint8(1),
	65:  uint8(1),
	66:  uint8(1),
	67:  uint8(1),
	68:  uint8(1),
	69:  uint8(1),
	70:  uint8(1),
	71:  uint8(1),
	72:  uint8(1),
	73:  uint8(1),
	74:  uint8(1),
	75:  uint8(1),
	76:  uint8(1),
	77:  uint8(1),
	78:  uint8(1),
	79:  uint8(1),
	80:  uint8(1),
	81:  uint8(1),
	82:  uint8(1),
	83:  uint8(1),
	84:  uint8(1),
	85:  uint8(1),
	86:  uint8(1),
	87:  uint8(1),
	88:  uint8(1),
	89:  uint8(1),
	90:  uint8(1),
	91:  uint8(1),
	92:  uint8(1),
	93:  uint8(1),
	94:  uint8(1),
	95:  uint8(1),
	96:  uint8(1),
	97:  uint8(1),
	98:  uint8(1),
	99:  uint8(1),
	100: uint8(1),
	101: uint8(1),
	102: uint8(1),
	103: uint8(1),
	104: uint8(1),
	105: uint8(1),
	106: uint8(1),
	107: uint8(1),
	108: uint8(1),
	109: uint8(1),
	110: uint8(1),
	111: uint8(1),
	112: uint8(1),
	113: uint8(1),
	114: uint8(1),
	115: uint8(1),
	116: uint8(1),
	117: uint8(1),
	118: uint8(1),
	119: uint8(1),
	120: uint8(1),
	121: uint8(1),
	122: uint8(1),
	123: uint8(1),
	124: uint8(1),
	125: uint8(1),
	126: uint8(1),
	127: uint8(1),
	128: uint8(3),
	129: uint8(3),
	130: uint8(3),
	131: uint8(3),
	132: uint8(3),
	133: uint8(3),
	134: uint8(3),
	135: uint8(3),
	136: uint8(3),
	137: uint8(3),
	138: uint8(3),
	139: uint8(3),
	140: uint8(3),
	141: uint8(3),
	142: uint8(3),
	143: uint8(3),
	144: uint8(3),
	145: uint8(3),
	146: uint8(3),
	147: uint8(3),
	148: uint8(3),
	149: uint8(3),
	150: uint8(3),
	151: uint8(3),
	152: uint8(3),
	153: uint8(3),
	154: uint8(3),
	155: uint8(3),
	156: uint8(3),
	157: uint8(3),
	158: uint8(3),
	159: uint8(3),
	160: uint8(3),
	161: uint8(3),
	162: uint8(3),
	163: uint8(3),
	164: uint8(3),
	165: uint8(3),
	166: uint8(3),
	167: uint8(3),
	168: uint8(3),
	169: uint8(3),
	170: uint8(3),
	171: uint8(3),
	172: uint8(3),
	173: uint8(3),
	174: uint8(3),
	175: uint8(3),
	176: uint8(3),
	177: uint8(3),
	178: uint8(3),
	179: uint8(3),
	180: uint8(3),
	181: uint8(3),
	182: uint8(3),
	183: uint8(3),
	184: uint8(3),
	185: uint8(3),
	186: uint8(3),
	187: uint8(3),
	188: uint8(3),
	189: uint8(3),
	190: uint8(3),
	191: uint8(3),
	192: uint8(2),
	193: uint8(1),
	194: uint8(2),
	195: uint8(2),
	196: uint8(2),
	197: uint8(2),
	198: uint8(2),
	199: uint8(2),
	200: uint8(2),
	201: uint8(2),
	202: uint8(2),
	203: uint8(2),
	204: uint8(2),
	205: uint8(2),
	206: uint8(2),
	207: uint8(2),
	208: uint8(2),
	209: uint8(2),
	210: uint8(2),
	211: uint8(2),
	212: uint8(2),
	213: uint8(2),
	214: uint8(2),
	215: uint8(2),
	216: uint8(2),
	217: uint8(2),
	218: uint8(2),
	219: uint8(2),
	220: uint8(2),
	221: uint8(2),
	222: uint8(2),
	223: uint8(2),
	224: uint8(3),
	225: uint8(3),
	226: uint8(3),
	227: uint8(3),
	228: uint8(3),
	229: uint8(3),
	230: uint8(3),
	231: uint8(3),
	232: uint8(3),
	233: uint8(3),
	234: uint8(3),
	235: uint8(3),
	236: uint8(3),
	237: uint8(3),
	238: uint8(3),
	239: uint8(3),
	240: uint8(4),
	241: uint8(4),
	242: uint8(4),
	243: uint8(4),
	244: uint8(4),
	245: uint8(1),
	246: uint8(1),
	247: uint8(1),
	248: uint8(1),
	249: uint8(1),
	250: uint8(1),
	251: uint8(1),
	252: uint8(1),
	253: uint8(1),
	254: uint8(1),
	255: uint8(1),
}

/*
 *---------------------------------------------------------------------------
 *
 * TclUtfCount --
 *
 *	Find the number of bytes in the Utf character "ch".
 *
 * Results:
 *	The return values is the number of bytes in the Utf character "ch".
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTclUtfCount(tls *libc.TLS, ch int32) (r int32) {
	/* The Unicode character whose size is returned. */
	if libc.Uint32FromInt32(ch-libc.Int32FromInt32(1)) < libc.Uint32FromInt32(libc.Int32FromInt32(UNICODE_SELF)-libc.Int32FromInt32(1)) {
		return int32(1)
	}
	if ch <= int32(0x7FF) {
		return int32(2)
	}
	if libc.Uint32FromInt32(ch-libc.Int32FromInt32(0x10000)) <= uint32(0xFFFFF) {
		return int32(4)
	}
	return int32(3)
}

/*
 *---------------------------------------------------------------------------
 *
 * Invalid --
 *
 *	Given a pointer to a two-byte prefix of a well-formed UTF-8 byte
 *	sequence (a lead byte followed by a trail byte) this routine
 *	examines those two bytes to determine whether the sequence is
 *	invalid in UTF-8.  This might be because it is an overlong
 *	encoding, or because it encodes something out of the proper range.
 *
 *	Given a pointer to the bytes \xF8 or \xFC , this routine will
 *	try to read beyond the end of the "bounds" table.  Callers must
 *	prevent this.
 *
 *	Given a pointer to something else (an ASCII byte, a trail byte,
 *	or another byte	that can never begin a valid byte sequence such
 *	as \xF5) this routine returns false.  That makes the routine poorly
 *	named, as it does not detect and report all invalid sequences.
 *
 *	Callers have to take care that this routine does something useful
 *	for their needs.
 *
 * Results:
 *	A boolean.
 *---------------------------------------------------------------------------
 */

var _bounds = [28]uint8{
	0:  uint8(0x80),
	1:  uint8(0x80),
	2:  uint8(0x80),
	3:  uint8(0xBF),
	4:  uint8(0x80),
	5:  uint8(0xBF),
	6:  uint8(0x80),
	7:  uint8(0xBF),
	8:  uint8(0x80),
	9:  uint8(0xBF),
	10: uint8(0x80),
	11: uint8(0xBF),
	12: uint8(0x80),
	13: uint8(0xBF),
	14: uint8(0x80),
	15: uint8(0xBF),
	16: uint8(0xA0),
	17: uint8(0xBF),
	18: uint8(0x80),
	19: uint8(0xBF),
	20: uint8(0x80),
	21: uint8(0xBF),
	22: uint8(0x80),
	23: uint8(0xBF),
	24: uint8(0x90),
	25: uint8(0xBF),
	26: uint8(0x80),
	27: uint8(0x8F),
}

func _Invalid(tls *libc.TLS, src uintptr) (r int32) {
	/* Points to lead byte of a UTF-8 byte sequence */
	var byte1 uint8
	var index int32
	_, _ = byte1, index
	byte1 = *(*uint8)(unsafe.Pointer(src))
	if libc.Int32FromUint8(byte1)&int32(0xC3) == int32(0xC0) {
		/* Only lead bytes 0xC0, 0xE0, 0xF0, 0xF4 need examination */
		index = (libc.Int32FromUint8(byte1) - int32(0xC0)) >> int32(1)
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1))) < libc.Int32FromUint8(_bounds[index]) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1))) > libc.Int32FromUint8(_bounds[index+int32(1)]) {
			/* Out of bounds - report invalid. */
			return int32(1)
		}
	}
	return 0
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_UniCharToUtf --
 *
 *	Stores the given Tcl_UniChar as a sequence of UTF-8 bytes in the provided
 *	buffer. Equivalent to Plan 9 runetochar().
 *
 *	Surrogate pairs are handled as follows: When ch is a high surrogate,
 *	the first byte of the 4-byte UTF-8 sequence is stored in the buffer and
 *	the function returns 1. If the function is called again with a low
 *	surrogate and the same buffer, the remaining 3 bytes of the 4-byte
 *	UTF-8 sequence are produced.
 *
 *	If no low surrogate follows the high surrogate (which is actually illegal),
 *	calling Tcl_UniCharToUtf again with ch being -1 produces a 3-byte UTF-8
 *	sequence representing the high surrogate.
 *
 * Results:
 *	Returns the number of bytes stored into the buffer.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_UniCharToUtf(tls *libc.TLS, ch int32, buf uintptr) (r TTcl_Size) {
	/* Buffer in which the UTF-8 representation of
	 * ch is stored. Must be large enough to hold
	 * the UTF-8 character (at most 4 bytes). */
	var flags int32
	var p1 uintptr
	_, _ = flags, p1
	flags = ch
	if ch >= int32(TCL_COMBINE) {
		ch &= libc.Int32FromInt32(TCL_COMBINE) - libc.Int32FromInt32(1)
	}
	if libc.Uint32FromInt32(ch-libc.Int32FromInt32(1)) < libc.Uint32FromInt32(libc.Int32FromInt32(UNICODE_SELF)-libc.Int32FromInt32(1)) {
		*(*uint8)(unsafe.Pointer(buf)) = libc.Uint8FromInt32(ch)
		return int64(1)
	}
	if ch >= 0 {
		if ch <= int32(0x7FF) {
			*(*uint8)(unsafe.Pointer(buf + 1)) = libc.Uint8FromInt32(libc.Int32FromInt32(0x80) | libc.Int32FromInt32(0x3F)&ch)
			*(*uint8)(unsafe.Pointer(buf)) = libc.Uint8FromInt32(libc.Int32FromInt32(0xC0) | ch>>libc.Int32FromInt32(6))
			return int64(2)
		}
		if ch <= int32(0xFFFF) {
			if flags&int32(TCL_COMBINE) != 0 && ch&int32(0xF800) == int32(0xD800) {
				if ch&int32(0x0400) != 0 {
					/* Low surrogate */
					if int32(0x80) == int32(0xC0)&libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(buf))) && 0 == int32(0xCF)&libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(buf + 1))) {
						/* Previous Tcl_UniChar was a high surrogate, so combine */
						*(*uint8)(unsafe.Pointer(buf + 2)) = libc.Uint8FromInt32(libc.Int32FromInt32(0x80) | libc.Int32FromInt32(0x3F)&ch)
						p1 = buf + 1
						*(*uint8)(unsafe.Pointer(p1)) = uint8(int32(*(*uint8)(unsafe.Pointer(p1))) | libc.Int32FromUint8(libc.Uint8FromInt32(libc.Int32FromInt32(0x80)|libc.Int32FromInt32(0x0F)&(ch>>libc.Int32FromInt32(6)))))
						return int64(3)
					}
					/* Previous Tcl_UniChar was not a high surrogate, so just output */
				} else {
					/* High surrogate */
					/* Add 0x10000 to the raw number encoded in the surrogate
					 * pair in order to get the code point. */
					ch += int32(0x40)
					/* Fill buffer with specific 3-byte (invalid) byte combination,
					 * so following low surrogate can recognize it and combine */
					*(*uint8)(unsafe.Pointer(buf + 2)) = libc.Uint8FromInt32(ch << libc.Int32FromInt32(4) & libc.Int32FromInt32(0x30))
					*(*uint8)(unsafe.Pointer(buf + 1)) = libc.Uint8FromInt32(libc.Int32FromInt32(0x80) | libc.Int32FromInt32(0x3F)&(ch>>libc.Int32FromInt32(2)))
					*(*uint8)(unsafe.Pointer(buf)) = libc.Uint8FromInt32(libc.Int32FromInt32(0xF0) | libc.Int32FromInt32(0x07)&(ch>>libc.Int32FromInt32(8)))
					return int64(1)
				}
			}
			goto three
		}
		if ch <= int32(0x10FFFF) {
			*(*uint8)(unsafe.Pointer(buf + 3)) = libc.Uint8FromInt32(libc.Int32FromInt32(0x80) | libc.Int32FromInt32(0x3F)&ch)
			*(*uint8)(unsafe.Pointer(buf + 2)) = libc.Uint8FromInt32(libc.Int32FromInt32(0x80) | libc.Int32FromInt32(0x3F)&(ch>>libc.Int32FromInt32(6)))
			*(*uint8)(unsafe.Pointer(buf + 1)) = libc.Uint8FromInt32(libc.Int32FromInt32(0x80) | libc.Int32FromInt32(0x3F)&(ch>>libc.Int32FromInt32(12)))
			*(*uint8)(unsafe.Pointer(buf)) = libc.Uint8FromInt32(libc.Int32FromInt32(0xF0) | ch>>libc.Int32FromInt32(18))
			return int64(4)
		}
	} else {
		if ch == -int32(1) {
			if int32(0x80) == int32(0xC0)&libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(buf))) && 0 == int32(0xCF)&libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(buf + 1))) && int32(0xF0) == int32(0xF8)&libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(buf + uintptr(-libc.Int32FromInt32(1))))) {
				ch = int32(0xD7C0) + int32(0x07)&libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(buf + uintptr(-libc.Int32FromInt32(1)))))<<int32(8) + int32(0x3F)&libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(buf)))<<int32(2) + int32(0x30)&libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(buf + 1)))>>int32(4)
				*(*uint8)(unsafe.Pointer(buf + 1)) = libc.Uint8FromInt32(libc.Int32FromInt32(0x80) | libc.Int32FromInt32(0x3F)&ch)
				*(*uint8)(unsafe.Pointer(buf)) = libc.Uint8FromInt32(libc.Int32FromInt32(0x80) | libc.Int32FromInt32(0x3F)&(ch>>libc.Int32FromInt32(6)))
				*(*uint8)(unsafe.Pointer(buf + uintptr(-libc.Int32FromInt32(1)))) = libc.Uint8FromInt32(libc.Int32FromInt32(0xE0) | ch>>libc.Int32FromInt32(12))
				return int64(2)
			}
		}
	}
	ch = int32(0xFFFD)
	goto three
three:
	;
	*(*uint8)(unsafe.Pointer(buf + 2)) = libc.Uint8FromInt32(libc.Int32FromInt32(0x80) | libc.Int32FromInt32(0x3F)&ch)
	*(*uint8)(unsafe.Pointer(buf + 1)) = libc.Uint8FromInt32(libc.Int32FromInt32(0x80) | libc.Int32FromInt32(0x3F)&(ch>>libc.Int32FromInt32(6)))
	*(*uint8)(unsafe.Pointer(buf)) = libc.Uint8FromInt32(libc.Int32FromInt32(0xE0) | ch>>libc.Int32FromInt32(12))
	return int64(3)
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_UniCharToUtfDString --
 *
 *	Convert the given Unicode string to UTF-8.
 *
 * Results:
 *	The return value is a pointer to the UTF-8 representation of the
 *	Unicode string. Storage for the return value is appended to the end of
 *	dsPtr.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_UniCharToUtfDString(tls *libc.TLS, uniStr uintptr, uniLength TTcl_Size, dsPtr uintptr) (r uintptr) {
	/* UTF-8 representation of string is appended
	 * to this previously initialized DString. */
	var oldLength TTcl_Size
	var p, string1, w, wEnd uintptr
	_, _, _, _, _ = oldLength, p, string1, w, wEnd
	/*
	 * UTF-8 string length in bytes will be <= Unicode string length * 4.
	 */
	if uniStr == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	if uniLength < 0 {
		uniLength = 0
		w = uniStr
		for *(*int32)(unsafe.Pointer(w)) != int32('\000') {
			uniLength++
			w += 4
		}
	}
	oldLength = (*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength
	XTcl_DStringSetLength(tls, dsPtr, oldLength+(uniLength+int64(1))*int64(4))
	string1 = (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1 + uintptr(oldLength)
	p = string1
	wEnd = uniStr + uintptr(uniLength)*4
	w = uniStr
	for {
		if !(w < wEnd) {
			break
		}
		p += uintptr(XTcl_UniCharToUtf(tls, *(*int32)(unsafe.Pointer(w)), p))
		w += 4
		goto _1
	_1:
	}
	XTcl_DStringSetLength(tls, dsPtr, oldLength+(int64(p)-int64(string1)))
	return string1
}

func XTcl_Char16ToUtfDString(tls *libc.TLS, uniStr uintptr, uniLength TTcl_Size, dsPtr uintptr) (r uintptr) {
	/* UTF-8 representation of string is appended
	 * to this previously initialized DString. */
	var len1 int32
	var oldLength TTcl_Size
	var p, string1, w, wEnd uintptr
	_, _, _, _, _, _ = len1, oldLength, p, string1, w, wEnd
	len1 = int32(1)
	/*
	 * UTF-8 string length in bytes will be <= Utf16 string length * 3.
	 */
	if uniStr == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	if uniLength < 0 {
		uniLength = 0
		w = uniStr
		for libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(w))) != int32('\000') {
			uniLength++
			w += 2
		}
	}
	oldLength = (*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength
	XTcl_DStringSetLength(tls, dsPtr, oldLength+(uniLength+int64(1))*int64(3))
	string1 = (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1 + uintptr(oldLength)
	p = string1
	wEnd = uniStr + uintptr(uniLength)*2
	w = uniStr
	for {
		if !(w < wEnd) {
			break
		}
		if !(len1 != 0) && libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(w)))&int32(0xFC00) != int32(0xDC00) {
			/* Special case for handling high surrogates. */
			p += uintptr(XTcl_UniCharToUtf(tls, -int32(1), p))
		}
		len1 = int32(XTcl_UniCharToUtf(tls, libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(w)))|int32(TCL_COMBINE), p))
		p += uintptr(len1)
		if libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(w))) >= int32(0xD800) && len1 < int32(3) {
			len1 = 0 /* Indication that high surrogate was found */
		}
		w += 2
		goto _1
	_1:
	}
	if !(len1 != 0) {
		/* Special case for handling high surrogates. */
		p += uintptr(XTcl_UniCharToUtf(tls, -int32(1), p))
	}
	XTcl_DStringSetLength(tls, dsPtr, oldLength+(int64(p)-int64(string1)))
	return string1
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_UtfToUniChar --
 *
 *	Extract the Tcl_UniChar represented by the UTF-8 string. Bad UTF-8
 *	sequences are converted to valid Tcl_UniChars and processing
 *	continues. Equivalent to Plan 9 chartorune().
 *
 *	The caller must ensure that the source buffer is long enough that this
 *	routine does not run off the end and dereference non-existent memory
 *	looking for trail bytes. If the source buffer is known to be '\0'
 *	terminated, this cannot happen. Otherwise, the caller should call
 *	Tcl_UtfCharComplete() before calling this routine to ensure that
 *	enough bytes remain in the string.
 *
 * Results:
 *	*chPtr is filled with the Tcl_UniChar, and the return value is the
 *	number of bytes from the UTF-8 string that were consumed.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

var _cp1252 = [32]uint16{
	0:  uint16(0x20AC),
	1:  uint16(0x81),
	2:  uint16(0x201A),
	3:  uint16(0x0192),
	4:  uint16(0x201E),
	5:  uint16(0x2026),
	6:  uint16(0x2020),
	7:  uint16(0x2021),
	8:  uint16(0x02C6),
	9:  uint16(0x2030),
	10: uint16(0x0160),
	11: uint16(0x2039),
	12: uint16(0x0152),
	13: uint16(0x8D),
	14: uint16(0x017D),
	15: uint16(0x8F),
	16: uint16(0x90),
	17: uint16(0x2018),
	18: uint16(0x2019),
	19: uint16(0x201C),
	20: uint16(0x201D),
	21: uint16(0x2022),
	22: uint16(0x2013),
	23: uint16(0x2014),
	24: uint16(0x2DC),
	25: uint16(0x2122),
	26: uint16(0x0161),
	27: uint16(0x203A),
	28: uint16(0x0153),
	29: uint16(0x9D),
	30: uint16(0x017E),
	31: uint16(0x0178),
}

func XTcl_UtfToUniChar(tls *libc.TLS, src uintptr, chPtr uintptr) (r TTcl_Size) {
	/* Filled with the Unicode character
	 * represented by the UTF-8 string. */
	var byte1 int32
	_ = byte1
	/*
	 * Unroll 1 to 4 byte UTF-8 sequences.
	 */
	byte1 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))
	if byte1 < int32(0xC0) {
		/*
		 * Handles properly formed UTF-8 characters between 0x01 and 0x7F.
		 * Treats naked trail bytes 0x80 to 0x9F as valid characters from
		 * the cp1252 table. See: <https://en.wikipedia.org/wiki/UTF-8>
		 * Also treats \0 and other naked trail bytes 0xA0 to 0xBF as valid
		 * characters representing themselves.
		 */
		if libc.Uint32FromInt32(byte1-libc.Int32FromInt32(0x80)) < libc.Uint32FromInt32(0x20) {
			*(*int32)(unsafe.Pointer(chPtr)) = libc.Int32FromUint16(_cp1252[byte1-int32(0x80)])
		} else {
			*(*int32)(unsafe.Pointer(chPtr)) = byte1
		}
		return int64(1)
	} else {
		if byte1 < int32(0xE0) {
			if byte1 != int32(0xC1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1)))&int32(0xC0) == int32(0x80) {
				/*
				 * Two-byte-character lead-byte followed by a trail-byte.
				 */
				*(*int32)(unsafe.Pointer(chPtr)) = byte1&int32(0x1F)<<int32(6) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1)))&int32(0x3F)
				if libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(chPtr))-libc.Int32FromInt32(1)) >= libc.Uint32FromInt32(libc.Int32FromInt32(UNICODE_SELF)-libc.Int32FromInt32(1)) {
					return int64(2)
				}
			}
			/*
			 * A two-byte-character lead-byte not followed by trail-byte
			 * represents itself.
			 */
		} else {
			if byte1 < int32(0xF0) {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1)))&int32(0xC0) == int32(0x80) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 2)))&int32(0xC0) == int32(0x80) {
					/*
					 * Three-byte-character lead byte followed by two trail bytes.
					 */
					*(*int32)(unsafe.Pointer(chPtr)) = byte1&int32(0x0F)<<int32(12) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1)))&int32(0x3F)<<int32(6) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 2)))&int32(0x3F)
					if *(*int32)(unsafe.Pointer(chPtr)) > int32(0x7FF) {
						return int64(3)
					}
				}
				/*
				 * A three-byte-character lead-byte not followed by two trail-bytes
				 * represents itself.
				 */
			} else {
				if byte1 < int32(0xF5) {
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1)))&int32(0xC0) == int32(0x80) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 2)))&int32(0xC0) == int32(0x80) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 3)))&int32(0xC0) == int32(0x80) {
						/*
						 * Four-byte-character lead byte followed by three trail bytes.
						 */
						*(*int32)(unsafe.Pointer(chPtr)) = byte1&int32(0x07)<<int32(18) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1)))&int32(0x3F)<<int32(12) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 2)))&int32(0x3F)<<int32(6) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 3)))&int32(0x3F)
						if libc.Uint32FromInt32(*(*int32)(unsafe.Pointer(chPtr))-libc.Int32FromInt32(0x10000)) <= uint32(0xFFFFF) {
							return int64(4)
						}
					}
					/*
					 * A four-byte-character lead-byte not followed by three trail-bytes
					 * represents itself.
					 */
				}
			}
		}
	}
	*(*int32)(unsafe.Pointer(chPtr)) = byte1
	return int64(1)
}

func XTcl_UtfToChar16(tls *libc.TLS, src uintptr, chPtr uintptr) (r TTcl_Size) {
	/* Filled with the Tcl_UniChar represented by
	 * the UTF-8 string. This could be a surrogate too. */
	var byte1 uint16
	var high TTcl_UniChar
	_, _ = byte1, high
	/*
	 * Unroll 1 to 4 byte UTF-8 sequences.
	 */
	byte1 = uint16(*(*uint8)(unsafe.Pointer(src)))
	if libc.Int32FromUint16(byte1) < int32(0xC0) {
		/*
		 * Handles properly formed UTF-8 characters between 0x01 and 0x7F.
		 * Treats naked trail bytes 0x80 to 0x9F as valid characters from
		 * the cp1252 table. See: <https://en.wikipedia.org/wiki/UTF-8>
		 * Also treats \0 and other naked trail bytes 0xA0 to 0xBF as valid
		 * characters representing themselves.
		 */
		/* If *chPtr contains a high surrogate (produced by a previous
		 * Tcl_UtfToUniChar() call) and the next 3 bytes are UTF-8 continuation
		 * bytes, then we must produce a follow-up low surrogate. We only
		 * do that if the high surrogate matches the bits we encounter.
		 */
		if libc.Int32FromUint16(byte1)&int32(0xC0) == int32(0x80) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1)))&int32(0xC0) == int32(0x80) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 2)))&int32(0xC0) == int32(0x80) && (libc.Int32FromUint16(byte1)-int32(0x10))<<int32(2)&int32(0xFC)|int32(0xD800) == libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(chPtr)))&int32(0xFCFC) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1)))&int32(0xF0) == libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(chPtr)))<<int32(4)&int32(0x30)|int32(0x80) {
			*(*uint16)(unsafe.Pointer(chPtr)) = libc.Uint16FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1)))&int32(0x0F)<<int32(6) + libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 2)))&int32(0x3F) + int32(0xDC00))
			return int64(3)
		}
		if libc.Uint32FromInt32(libc.Int32FromUint16(byte1)-libc.Int32FromInt32(0x80)) < libc.Uint32FromInt32(0x20) {
			*(*uint16)(unsafe.Pointer(chPtr)) = _cp1252[libc.Int32FromUint16(byte1)-int32(0x80)]
		} else {
			*(*uint16)(unsafe.Pointer(chPtr)) = byte1
		}
		return int64(1)
	} else {
		if libc.Int32FromUint16(byte1) < int32(0xE0) {
			if libc.Int32FromUint16(byte1) != int32(0xC1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1)))&int32(0xC0) == int32(0x80) {
				/*
				 * Two-byte-character lead-byte followed by a trail-byte.
				 */
				*(*uint16)(unsafe.Pointer(chPtr)) = libc.Uint16FromInt32(libc.Int32FromUint16(byte1)&libc.Int32FromInt32(0x1F)<<libc.Int32FromInt32(6) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1)))&libc.Int32FromInt32(0x3F))
				if libc.Uint32FromInt32(libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(chPtr)))-libc.Int32FromInt32(1)) >= libc.Uint32FromInt32(libc.Int32FromInt32(UNICODE_SELF)-libc.Int32FromInt32(1)) {
					return int64(2)
				}
			}
			/*
			 * A two-byte-character lead-byte not followed by trail-byte
			 * represents itself.
			 */
		} else {
			if libc.Int32FromUint16(byte1) < int32(0xF0) {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1)))&int32(0xC0) == int32(0x80) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 2)))&int32(0xC0) == int32(0x80) {
					/*
					 * Three-byte-character lead byte followed by two trail bytes.
					 */
					*(*uint16)(unsafe.Pointer(chPtr)) = libc.Uint16FromInt32(libc.Int32FromUint16(byte1)&libc.Int32FromInt32(0x0F)<<libc.Int32FromInt32(12) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1)))&libc.Int32FromInt32(0x3F)<<libc.Int32FromInt32(6) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 2)))&libc.Int32FromInt32(0x3F))
					if libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(chPtr))) > int32(0x7FF) {
						return int64(3)
					}
				}
				/*
				 * A three-byte-character lead-byte not followed by two trail-bytes
				 * represents itself.
				 */
			} else {
				if libc.Int32FromUint16(byte1) < int32(0xF5) {
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1)))&int32(0xC0) == int32(0x80) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 2)))&int32(0xC0) == int32(0x80) {
						/*
						 * Four-byte-character lead byte followed by at least two trail bytes.
						 * We don't test the validity of 3th trail byte, see [ed29806ba]
						 */
						high = libc.Int32FromUint16(byte1)&int32(0x07)<<int32(8) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1)))&int32(0x3F)<<int32(2) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 2)))&int32(0x3F)>>int32(4) - int32(0x40)
						if high < int32(0x400) {
							/* produce high surrogate, advance source pointer */
							*(*uint16)(unsafe.Pointer(chPtr)) = libc.Uint16FromInt32(int32(0xD800) + high)
							return int64(1)
						}
						/* out of range, < 0x10000 or > 0x10FFFF */
					}
					/*
					 * A four-byte-character lead-byte not followed by three trail-bytes
					 * represents itself.
					 */
				}
			}
		}
	}
	*(*uint16)(unsafe.Pointer(chPtr)) = byte1
	return int64(1)
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_UtfToUniCharDString --
 *
 *	Convert the UTF-8 string to Unicode.
 *
 * Results:
 *	The return value is a pointer to the Unicode representation of the
 *	UTF-8 string. Storage for the return value is appended to the end of
 *	dsPtr. The Unicode string is terminated with a Unicode NULL character.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_UtfToUniCharDString(tls *libc.TLS, src uintptr, length TTcl_Size, dsPtr uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Unicode representation of string is
	 * appended to this previously initialized
	 * DString. */
	var endPtr, optPtr, p, w, wString, v2, v4, v5, v6 uintptr
	var oldLength TTcl_Size
	var v1, v3 int64
	var _ /* ch at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _ = endPtr, oldLength, optPtr, p, w, wString, v1, v2, v3, v4, v5, v6
	*(*int32)(unsafe.Pointer(bp)) = 0
	/* Pointer to the end of string. Never read endPtr[0] */
	endPtr = src + uintptr(length)
	/* Pointer to last byte where optimization still can be used */
	optPtr = endPtr - uintptr(TCL_UTF_MAX)
	if src == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	if length < 0 {
		length = libc.Int64FromUint64(libc.Xstrlen(tls, src))
	}
	/*
	 * Unicode string length in Tcl_UniChars will be <= UTF-8 string length in
	 * bytes.
	 */
	oldLength = (*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength
	XTcl_DStringSetLength(tls, dsPtr, libc.Int64FromUint64(libc.Uint64FromInt64(oldLength)+libc.Uint64FromInt64(length+libc.Int64FromInt32(1))*uint64(4)))
	wString = (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1 + uintptr(oldLength)
	w = wString
	p = src
	endPtr = src + uintptr(length)
	optPtr = endPtr - uintptr(4)
	for p <= optPtr {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) < int32(0x80) {
			*(*int32)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))
			v1 = int64(libc.Int32FromInt32(1))
		} else {
			v1 = XTcl_UtfToUniChar(tls, p, bp)
		}
		p += uintptr(v1)
		v2 = w
		w += 4
		*(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(bp))
	}
	for p < endPtr && XTcl_UtfCharComplete(tls, p, int64(endPtr)-int64(p)) != 0 {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) < int32(0x80) {
			*(*int32)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))
			v3 = int64(libc.Int32FromInt32(1))
		} else {
			v3 = XTcl_UtfToUniChar(tls, p, bp)
		}
		p += uintptr(v3)
		v4 = w
		w += 4
		*(*int32)(unsafe.Pointer(v4)) = *(*int32)(unsafe.Pointer(bp))
	}
	for p < endPtr {
		v5 = w
		w += 4
		v6 = p
		p++
		*(*int32)(unsafe.Pointer(v5)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v6)))
	}
	*(*int32)(unsafe.Pointer(w)) = int32('\000')
	XTcl_DStringSetLength(tls, dsPtr, oldLength+(int64(w)-int64(wString)))
	return wString
}

func XTcl_UtfToChar16DString(tls *libc.TLS, src uintptr, length TTcl_Size, dsPtr uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Unicode representation of string is
	 * appended to this previously initialized
	 * DString. */
	var endPtr, optPtr, p, w, wString, v1, v2, v3, v4 uintptr
	var oldLength TTcl_Size
	var _ /* ch at bp+0 */ uint16
	_, _, _, _, _, _, _, _, _, _ = endPtr, oldLength, optPtr, p, w, wString, v1, v2, v3, v4
	*(*uint16)(unsafe.Pointer(bp)) = uint16(0)
	/* Pointer to the end of string. Never read endPtr[0] */
	endPtr = src + uintptr(length)
	/* Pointer to last byte where optimization still can be used */
	optPtr = endPtr - uintptr(TCL_UTF_MAX)
	if src == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	if length < 0 {
		length = libc.Int64FromUint64(libc.Xstrlen(tls, src))
	}
	/*
	 * Unicode string length in WCHARs will be <= UTF-8 string length in
	 * bytes.
	 */
	oldLength = (*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength
	XTcl_DStringSetLength(tls, dsPtr, libc.Int64FromUint64(libc.Uint64FromInt64(oldLength)+libc.Uint64FromInt64(length+libc.Int64FromInt32(1))*uint64(2)))
	wString = (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1 + uintptr(oldLength)
	w = wString
	p = src
	endPtr = src + uintptr(length)
	optPtr = endPtr - uintptr(3)
	for p <= optPtr {
		p += uintptr(XTcl_UtfToChar16(tls, p, bp))
		v1 = w
		w += 2
		*(*uint16)(unsafe.Pointer(v1)) = *(*uint16)(unsafe.Pointer(bp))
	}
	for p < endPtr {
		if XTcl_UtfCharComplete(tls, p, int64(endPtr)-int64(p)) != 0 {
			p += uintptr(XTcl_UtfToChar16(tls, p, bp))
			v2 = w
			w += 2
			*(*uint16)(unsafe.Pointer(v2)) = *(*uint16)(unsafe.Pointer(bp))
		} else {
			v3 = w
			w += 2
			v4 = p
			p++
			*(*uint16)(unsafe.Pointer(v3)) = uint16(*(*uint8)(unsafe.Pointer(v4)))
		}
	}
	*(*uint16)(unsafe.Pointer(w)) = uint16('\000')
	XTcl_DStringSetLength(tls, dsPtr, oldLength+(int64(w)-int64(wString)))
	return wString
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_UtfCharComplete --
 *
 *	Determine if the UTF-8 string of the given length is long enough to be
 *	decoded by Tcl_UtfToUniChar(). This does not ensure that the UTF-8
 *	string is properly formed. Equivalent to Plan 9 fullrune().
 *
 * Results:
 *	The return value is 0 if the string is not long enough, non-zero
 *	otherwise.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_UtfCharComplete(tls *libc.TLS, src uintptr, length TTcl_Size) (r int32) {
	/* Length of above string in bytes. */
	return libc.BoolInt32(length >= libc.Int64FromUint8(_complete[*(*uint8)(unsafe.Pointer(src))]))
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_NumUtfChars --
 *
 *	Returns the number of characters (not bytes) in the UTF-8 string, not
 *	including the terminating NULL byte. This is equivalent to Plan 9
 *	utflen() and utfnlen().
 *
 * Results:
 *	As above.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_NumUtfChars(tls *libc.TLS, src uintptr, length TTcl_Size) (r TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The length of the string in bytes, or
	 * negative value for strlen(src). */
	var endPtr, optPtr uintptr
	var i TTcl_Size
	var v1, v2, v3 int64
	var _ /* ch at bp+0 */ TTcl_UniChar
	_, _, _, _, _, _ = endPtr, i, optPtr, v1, v2, v3
	*(*TTcl_UniChar)(unsafe.Pointer(bp)) = 0
	i = 0
	if length < 0 {
		/* string is NUL-terminated, so TclUtfToUniChar calls are safe. */
		for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) != int32('\000') {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) < int32(0x80) {
				*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))
				v1 = int64(libc.Int32FromInt32(1))
			} else {
				v1 = XTcl_UtfToUniChar(tls, src, bp)
			}
			src += uintptr(v1)
			i++
		}
	} else {
		/* Will return value between 0 and length. No overflow checks. */
		/* Pointer to the end of string. Never read endPtr[0] */
		endPtr = src + uintptr(length)
		/* Pointer to last byte where optimization still can be used */
		optPtr = endPtr - uintptr(4)
		/*
		 * Optimize away the call in this loop. Justified because...
		 * when (src <= optPtr), (endPtr - src) >= (endPtr - optPtr)
		 * By initialization above (endPtr - optPtr) = TCL_UTF_MAX
		 * So (endPtr - src) >= TCL_UTF_MAX, and passing that to
		 * Tcl_UtfCharComplete we know will cause return of 1.
		 */
		for src <= optPtr {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) < int32(0x80) {
				*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))
				v2 = int64(libc.Int32FromInt32(1))
			} else {
				v2 = XTcl_UtfToUniChar(tls, src, bp)
			}
			src += uintptr(v2)
			i++
		}
		/* Loop over the remaining string where call must happen */
		for src < endPtr {
			if XTcl_UtfCharComplete(tls, src, int64(endPtr)-int64(src)) != 0 {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) < int32(0x80) {
					*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))
					v3 = int64(libc.Int32FromInt32(1))
				} else {
					v3 = XTcl_UtfToUniChar(tls, src, bp)
				}
				src += uintptr(v3)
			} else {
				/*
				 * src points to incomplete UTF-8 sequence
				 * Treat first byte as character and count it
				 */
				src++
			}
			i++
		}
	}
	return i
}

func XTclNumUtfChars(tls *libc.TLS, src uintptr, length TTcl_Size) (r TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The length of the string in bytes, or
	 * negative for strlen(src). */
	var endPtr, optPtr uintptr
	var i TTcl_Size
	var _ /* ch at bp+0 */ uint16
	_, _, _ = endPtr, i, optPtr
	*(*uint16)(unsafe.Pointer(bp)) = uint16(0)
	i = 0
	if length < 0 {
		/* string is NUL-terminated, so TclUtfToUniChar calls are safe. */
		for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) != int32('\000') {
			src += uintptr(XTcl_UtfToChar16(tls, src, bp))
			i++
		}
	} else {
		/* Will return value between 0 and length. No overflow checks. */
		/* Pointer to the end of string. Never read endPtr[0] */
		endPtr = src + uintptr(length)
		/* Pointer to last byte where optimization still can be used */
		optPtr = endPtr - uintptr(4)
		/*
		 * Optimize away the call in this loop. Justified because...
		 * when (src <= optPtr), (endPtr - src) >= (endPtr - optPtr)
		 * By initialization above (endPtr - optPtr) = TCL_UTF_MAX
		 * So (endPtr - src) >= TCL_UTF_MAX, and passing that to
		 * Tcl_UtfCharComplete we know will cause return of 1.
		 */
		for src <= optPtr {
			src += uintptr(XTcl_UtfToChar16(tls, src, bp))
			i++
		}
		/* Loop over the remaining string where call must happen */
		for src < endPtr {
			if XTcl_UtfCharComplete(tls, src, int64(endPtr)-int64(src)) != 0 {
				src += uintptr(XTcl_UtfToChar16(tls, src, bp))
			} else {
				/*
				 * src points to incomplete UTF-8 sequence
				 * Treat first byte as character and count it
				 */
				src++
			}
			i++
		}
	}
	return i
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_UtfFindFirst --
 *
 *	Returns a pointer to the first occurrence of the given Unicode character
 *	in the NULL-terminated UTF-8 string. The NULL terminator is considered
 *	part of the UTF-8 string. Equivalent to Plan 9 utfrune().
 *
 * Results:
 *	As above. If the Unicode character does not exist in the given string,
 *	the return value is NULL.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_UtfFindFirst(tls *libc.TLS, src uintptr, ch int32) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The Unicode character to search for. */
	var len1 int32
	var v1 int64
	var _ /* find at bp+0 */ int32
	_, _ = len1, v1
	for int32(1) != 0 {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) < int32(0x80) {
			*(*int32)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))
			v1 = int64(libc.Int32FromInt32(1))
		} else {
			v1 = XTcl_UtfToUniChar(tls, src, bp)
		}
		len1 = int32(v1)
		if *(*int32)(unsafe.Pointer(bp)) == ch {
			return src
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) == int32('\000') {
			return libc.UintptrFromInt32(0)
		}
		src += uintptr(len1)
	}
	return r
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_UtfFindLast --
 *
 *	Returns a pointer to the last occurrence of the given Unicode character
 *	in the NULL-terminated UTF-8 string. The NULL terminator is considered
 *	part of the UTF-8 string. Equivalent to Plan 9 utfrrune().
 *
 * Results:
 *	As above. If the Unicode character does not exist in the given string, the
 *	return value is NULL.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_UtfFindLast(tls *libc.TLS, src uintptr, ch int32) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The Unicode character to search for. */
	var last uintptr
	var len1 int32
	var v1 int64
	var _ /* find at bp+0 */ int32
	_, _, _ = last, len1, v1
	last = libc.UintptrFromInt32(0)
	for int32(1) != 0 {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) < int32(0x80) {
			*(*int32)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))
			v1 = int64(libc.Int32FromInt32(1))
		} else {
			v1 = XTcl_UtfToUniChar(tls, src, bp)
		}
		len1 = int32(v1)
		if *(*int32)(unsafe.Pointer(bp)) == ch {
			last = src
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) == int32('\000') {
			break
		}
		src += uintptr(len1)
	}
	return last
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_UtfNext --
 *
 *	Given a pointer to some location in a UTF-8 string, Tcl_UtfNext
 *	returns a pointer to the next UTF-8 character in the string.
 *	The caller must not ask for the next character after the last
 *	character in the string if the string is not terminated by a null
 *	character.
 *
 * Results:
 *	The return value is the pointer to the next character in the UTF-8
 *	string.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_UtfNext(tls *libc.TLS, src uintptr) (r uintptr) {
	/* The current location in the string. */
	var left, v4 int32
	var next, v1, v2 uintptr
	var v3 bool
	_, _, _, _, _, _ = left, next, v1, v2, v3, v4
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))&int32(0xC0) == int32(0x80) {
		/* Continuation byte, so we start 'inside' a (possible valid) UTF-8
		 * sequence. Since we are not allowed to access src[-1], we cannot
		 * check if the sequence is actually valid, the best we can do is
		 * just assume it is valid and locate the end. */
		src++
		v1 = src
		if v3 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v1)))&int32(0xC0) == int32(0x80); v3 {
			src++
			v2 = src
		}
		if v3 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v2)))&int32(0xC0) == int32(0x80) {
			src++
		}
		return src
	}
	left = libc.Int32FromUint8(_totalBytes[*(*uint8)(unsafe.Pointer(src))])
	next = src + uintptr(1)
	for {
		left--
		v4 = left
		if !(v4 != 0) {
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(next)))&int32(0xC0) != int32(0x80) {
			/*
			 * src points to non-trail byte; We ran out of trail bytes
			 * before the needs of the lead byte were satisfied.
			 * Let the (malformed) lead byte alone be a character
			 */
			return src + uintptr(1)
		}
		next++
	}
	/*
	 * Call Invalid() here only if required conditions are met:
	 *    src[0] is known a lead byte.
	 *    src[1] is known a trail byte.
	 * Especially important to prevent calls when src[0] == '\xF8' or '\xFC'
	 * See tests utf-6.37 through utf-6.43 through valgrind or similar tool.
	 */
	if next == src+uintptr(1) || _Invalid(tls, src) != 0 {
		return src + uintptr(1)
	}
	return next
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_UtfPrev --
 *
 *	Given a pointer to some current location in a UTF-8 string, move
 *	backwards one character. This works correctly when the pointer is in
 *	the middle of a UTF-8 character.
 *
 * Results:
 *	The return value is a pointer to the previous character in the UTF-8
 *	string. If the current location was already at the beginning of the
 *	string, the return value will also be a pointer to the beginning of
 *	the string.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_UtfPrev(tls *libc.TLS, src uintptr, start uintptr) (r uintptr) {
	/* Pointer to the beginning of the string */
	var byte1 uint8
	var fallback, look uintptr
	var trailBytesSeen int32
	_, _, _, _ = byte1, fallback, look, trailBytesSeen
	trailBytesSeen = 0 /* How many trail bytes have been verified? */
	fallback = src - uintptr(1)
	/* If we cannot find a lead byte that might
	 * start a prefix of a valid UTF byte sequence,
	 * we will fallback to a one-byte back step */
	look = fallback
	/* Start search at the fallback position */
	/* Quick boundary case exit. */
	if fallback <= start {
		return start
	}
	for cond := true; cond; cond = trailBytesSeen < int32(4) {
		byte1 = *(*uint8)(unsafe.Pointer(look))
		if libc.Int32FromUint8(byte1) < int32(0x80) {
			/*
			 * Single byte character. Either this is a correct previous
			 * character, or it is followed by at least one trail byte
			 * which indicates a malformed sequence. In either case the
			 * correct result is to return the fallback.
			 */
			return fallback
		}
		if libc.Int32FromUint8(byte1) >= int32(0xC0) {
			/* Non-trail byte; May be multibyte lead. */
			if trailBytesSeen == 0 || trailBytesSeen >= libc.Int32FromUint8(_totalBytes[byte1]) {
				/*
				 * That is, (1 + trailBytesSeen > needed).
				 * We've examined more bytes than needed to complete
				 * this lead byte. No matter about well-formedness or
				 * validity, the sequence starting with this lead byte
				 * will never include the fallback location, so we must
				 * return the fallback location. See test utf-7.17
				 */
				return fallback
			}
			/*
			 * trailBytesSeen > 0, so we can examine look[1] safely.
			 * Use that capability to screen out invalid sequences.
			 */
			if _Invalid(tls, look) != 0 {
				/* Reject */
				return fallback
			}
			return look
		}
		/* We saw a trail byte. */
		trailBytesSeen++
		if look == start {
			/*
			 * Do not read before the start of the string
			 *
			 * If we get here, we've examined bytes at every location
			 * >= start and < src and all of them are trail bytes,
			 * including (*start).  We need to return our fallback
			 * and exit this loop before we run past the start of the string.
			 */
			return fallback
		}
		/* Continue the search backwards... */
		look--
	}
	/*
	 * We've seen 4 trail bytes, so we know there will not be a
	 * properly formed byte sequence to find, and we can stop looking,
	 * accepting the fallback.
	 */
	return fallback
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_UniCharAtIndex --
 *
 *	Returns the Unicode character represented at the specified character
 *	(not byte) position in the UTF-8 string.
 *
 * Results:
 *	As above.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_UniCharAtIndex(tls *libc.TLS, src uintptr, index TTcl_Size) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The position of the desired character. */
	var v1 TTcl_Size
	var v2 int64
	var _ /* ch at bp+0 */ TTcl_UniChar
	var _ /* i at bp+4 */ int32
	_, _ = v1, v2
	*(*TTcl_UniChar)(unsafe.Pointer(bp)) = 0
	*(*int32)(unsafe.Pointer(bp + 4)) = 0
	if index < 0 {
		return -int32(1)
	}
	for {
		v1 = index
		index--
		if !(v1 != 0) {
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))
			v2 = int64(libc.Int32FromInt32(1))
		} else {
			v2 = XTcl_UtfToUniChar(tls, src, bp)
		}
		*(*int32)(unsafe.Pointer(bp + 4)) = int32(v2)
		src += uintptr(*(*int32)(unsafe.Pointer(bp + 4)))
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) < int32(0x80) {
		*(*int32)(unsafe.Pointer(bp + 4)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))
		_ = libc.Int32FromInt32(1)
	} else {
		XTcl_UtfToUniChar(tls, src, bp+4)
	}
	return *(*int32)(unsafe.Pointer(bp + 4))
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_UtfAtIndex --
 *
 *	Returns a pointer to the specified character (not byte) position in
 *	the UTF-8 string.
 *
 * Results:
 *	As above.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_UtfAtIndex(tls *libc.TLS, src uintptr, index TTcl_Size) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The position of the desired character. */
	var v1 TTcl_Size
	var v2 int64
	var _ /* ch at bp+0 */ TTcl_UniChar
	_, _ = v1, v2
	*(*TTcl_UniChar)(unsafe.Pointer(bp)) = 0
	for {
		v1 = index
		index--
		if !(v1 > 0) {
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))
			v2 = int64(libc.Int32FromInt32(1))
		} else {
			v2 = XTcl_UtfToUniChar(tls, src, bp)
		}
		src += uintptr(v2)
	}
	return src
}

func XTclUtfAtIndex(tls *libc.TLS, src uintptr, index TTcl_Size) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The position of the desired character. */
	var len1, v1, v2 TTcl_Size
	var _ /* ch at bp+0 */ uint16
	_, _, _ = len1, v1, v2
	*(*uint16)(unsafe.Pointer(bp)) = uint16(0)
	len1 = 0
	if index > 0 {
		for {
			v1 = index
			index--
			if !(v1 != 0) {
				break
			}
			v2 = XTcl_UtfToChar16(tls, src, bp)
			len1 = v2
			src += uintptr(v2)
		}
		if libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(bp))) >= int32(0xD800) && len1 < int64(3) {
			/* Index points at character following high Surrogate */
			src += uintptr(XTcl_UtfToChar16(tls, src, bp))
		}
	}
	return src
}

/*
 *---------------------------------------------------------------------------
 *
 * Tcl_UtfBackslash --
 *
 *	Figure out how to handle a backslash sequence.
 *
 * Results:
 *	Stores the bytes represented by the backslash sequence in dst and
 *	returns the number of bytes written to dst. At most 4 bytes
 *	are written to dst; dst must have been large enough to accept those
 *	bytes. If readPtr isn't NULL then it is filled in with a count of the
 *	number of bytes in the backslash sequence.
 *
 * Side effects:
 *	The maximum number of bytes it takes to represent a Unicode character
 *	in UTF-8 is guaranteed to be less than the number of bytes used to
 *	express the backslash sequence that represents that Unicode character.
 *	If the target buffer into which the caller is going to store the bytes
 *	that represent the Unicode character is at least as large as the
 *	source buffer from which the backslashed sequence was extracted, no
 *	buffer overruns should occur.
 *
 *---------------------------------------------------------------------------
 */

func XTcl_UtfBackslash(tls *libc.TLS, src uintptr, readPtr uintptr, dst uintptr) (r TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Filled with the bytes represented by the
	 * backslash sequence. */
	var result int32
	var _ /* numRead at bp+0 */ TTcl_Size
	_ = result
	result = XTclParseBackslash(tls, src, int64(LINE_LENGTH), bp, dst)
	if *(*TTcl_Size)(unsafe.Pointer(bp)) == int64(LINE_LENGTH) {
		/*
		 * We ate a whole line. Pay the price of a strlen()
		 */
		result = XTclParseBackslash(tls, src, libc.Int64FromUint64(libc.Xstrlen(tls, src)), bp, dst)
	}
	if readPtr != libc.UintptrFromInt32(0) {
		*(*int32)(unsafe.Pointer(readPtr)) = int32(*(*TTcl_Size)(unsafe.Pointer(bp)))
	}
	return int64(result)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UtfToUpper --
 *
 *	Convert lowercase characters to uppercase characters in a UTF string
 *	in place. The conversion may shrink the UTF string.
 *
 * Results:
 *	Returns the number of bytes in the resulting string excluding the
 *	trailing null.
 *
 * Side effects:
 *	Writes a terminating null after the last converted character.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UtfToUpper(tls *libc.TLS, str uintptr) (r TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* String to convert in place. */
	var dst, src, v1 uintptr
	var len1 TTcl_Size
	var upChar int32
	var v2 int64
	var _ /* ch at bp+0 */ int32
	_, _, _, _, _, _ = dst, len1, src, upChar, v1, v2
	/*
	 * Iterate over the string until we hit the terminating null.
	 */
	v1 = str
	dst = v1
	src = v1
	for *(*uint8)(unsafe.Pointer(src)) != 0 {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) < int32(0x80) {
			*(*int32)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))
			v2 = int64(libc.Int32FromInt32(1))
		} else {
			v2 = XTcl_UtfToUniChar(tls, src, bp)
		}
		len1 = v2
		upChar = XTcl_UniCharToUpper(tls, *(*int32)(unsafe.Pointer(bp)))
		/*
		 * To keep badly formed Utf strings from getting inflated by the
		 * conversion (thereby causing a segfault), only copy the upper case
		 * char to dst if its size is <= the original char.
		 */
		if len1 < int64(XTclUtfCount(tls, upChar)) {
			libc.Xmemmove(tls, dst, src, libc.Uint64FromInt64(len1))
			dst += uintptr(len1)
		} else {
			dst += uintptr(XTcl_UniCharToUtf(tls, upChar, dst))
		}
		src += uintptr(len1)
	}
	*(*uint8)(unsafe.Pointer(dst)) = uint8('\000')
	return int64(dst) - int64(str)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UtfToLower --
 *
 *	Convert uppercase characters to lowercase characters in a UTF string
 *	in place. The conversion may shrink the UTF string.
 *
 * Results:
 *	Returns the number of bytes in the resulting string excluding the
 *	trailing null.
 *
 * Side effects:
 *	Writes a terminating null after the last converted character.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UtfToLower(tls *libc.TLS, str uintptr) (r TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* String to convert in place. */
	var dst, src, v1 uintptr
	var len1 TTcl_Size
	var lowChar int32
	var v2 int64
	var _ /* ch at bp+0 */ int32
	_, _, _, _, _, _ = dst, len1, lowChar, src, v1, v2
	/*
	 * Iterate over the string until we hit the terminating null.
	 */
	v1 = str
	dst = v1
	src = v1
	for *(*uint8)(unsafe.Pointer(src)) != 0 {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) < int32(0x80) {
			*(*int32)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))
			v2 = int64(libc.Int32FromInt32(1))
		} else {
			v2 = XTcl_UtfToUniChar(tls, src, bp)
		}
		len1 = v2
		lowChar = XTcl_UniCharToLower(tls, *(*int32)(unsafe.Pointer(bp)))
		/*
		 * To keep badly formed Utf strings from getting inflated by the
		 * conversion (thereby causing a segfault), only copy the lower case
		 * char to dst if its size is <= the original char.
		 */
		if len1 < int64(XTclUtfCount(tls, lowChar)) {
			libc.Xmemmove(tls, dst, src, libc.Uint64FromInt64(len1))
			dst += uintptr(len1)
		} else {
			dst += uintptr(XTcl_UniCharToUtf(tls, lowChar, dst))
		}
		src += uintptr(len1)
	}
	*(*uint8)(unsafe.Pointer(dst)) = uint8('\000')
	return int64(dst) - int64(str)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UtfToTitle --
 *
 *	Changes the first character of a UTF string to title case or uppercase
 *	and the rest of the string to lowercase. The conversion happens in
 *	place and may shrink the UTF string.
 *
 * Results:
 *	Returns the number of bytes in the resulting string excluding the
 *	trailing null.
 *
 * Side effects:
 *	Writes a terminating null after the last converted character.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UtfToTitle(tls *libc.TLS, str uintptr) (r TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* String to convert in place. */
	var dst, src, v1 uintptr
	var len1 TTcl_Size
	var lowChar, titleChar int32
	var v2, v3 int64
	var _ /* ch at bp+0 */ int32
	_, _, _, _, _, _, _, _ = dst, len1, lowChar, src, titleChar, v1, v2, v3
	/*
	 * Capitalize the first character and then lowercase the rest of the
	 * characters until we get to a null.
	 */
	v1 = str
	dst = v1
	src = v1
	if *(*uint8)(unsafe.Pointer(src)) != 0 {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) < int32(0x80) {
			*(*int32)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))
			v2 = int64(libc.Int32FromInt32(1))
		} else {
			v2 = XTcl_UtfToUniChar(tls, src, bp)
		}
		len1 = v2
		titleChar = XTcl_UniCharToTitle(tls, *(*int32)(unsafe.Pointer(bp)))
		if len1 < int64(XTclUtfCount(tls, titleChar)) {
			libc.Xmemmove(tls, dst, src, libc.Uint64FromInt64(len1))
			dst += uintptr(len1)
		} else {
			dst += uintptr(XTcl_UniCharToUtf(tls, titleChar, dst))
		}
		src += uintptr(len1)
	}
	for *(*uint8)(unsafe.Pointer(src)) != 0 {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) < int32(0x80) {
			*(*int32)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src)))
			v3 = int64(libc.Int32FromInt32(1))
		} else {
			v3 = XTcl_UtfToUniChar(tls, src, bp)
		}
		len1 = v3
		lowChar = *(*int32)(unsafe.Pointer(bp))
		/* Special exception for Georgian Asomtavruli chars, no titlecase. */
		if libc.Uint32FromInt32(lowChar-libc.Int32FromInt32(0x1C90)) >= uint32(0x30) {
			lowChar = XTcl_UniCharToLower(tls, lowChar)
		}
		if len1 < int64(XTclUtfCount(tls, lowChar)) {
			libc.Xmemmove(tls, dst, src, libc.Uint64FromInt64(len1))
			dst += uintptr(len1)
		} else {
			dst += uintptr(XTcl_UniCharToUtf(tls, lowChar, dst))
		}
		src += uintptr(len1)
	}
	*(*uint8)(unsafe.Pointer(dst)) = uint8('\000')
	return int64(dst) - int64(str)
}

/*
 *----------------------------------------------------------------------
 *
 * TclpUtfNcmp2 --
 *
 *	Compare at most numBytes bytes of utf-8 strings cs and ct. Both cs and
 *	ct are assumed to be at least numBytes bytes long.
 *
 * Results:
 *	Return <0 if cs < ct, 0 if cs == ct, or >0 if cs > ct.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclpUtfNcmp2(tls *libc.TLS, csPtr uintptr, ctPtr uintptr, numBytes Tsize_t) (r int32) {
	/* Number of *bytes* to compare. */
	var c1, c2 uint8
	var cs, ct uintptr
	var result, v2, v3 int32
	_, _, _, _, _, _, _ = c1, c2, cs, ct, result, v2, v3
	cs = csPtr
	ct = ctPtr
	/*
	 * We can't simply call 'memcmp(cs, ct, numBytes);' because we need to
	 * check for Tcl's \xC0\x80 non-utf-8 null encoding. Otherwise utf-8 lexes
	 * fine in the strcmp manner.
	 */
	result = 0
	for {
		if !(numBytes != uint64(0)) {
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cs))) != libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ct))) {
			result = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cs))) - libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ct)))
			break
		}
		goto _1
	_1:
		;
		numBytes--
		cs++
		ct++
	}
	if numBytes != 0 && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cs))) == int32(0xC0) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ct))) == int32(0xC0)) {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cs))) == int32(0xC0) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cs + 1))) == int32(0x80) {
			v2 = 0
		} else {
			v2 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cs)))
		}
		c1 = libc.Uint8FromInt32(v2)
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ct))) == int32(0xC0) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ct + 1))) == int32(0x80) {
			v3 = 0
		} else {
			v3 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ct)))
		}
		c2 = libc.Uint8FromInt32(v3)
		result = libc.Int32FromUint8(c1) - libc.Int32FromUint8(c2)
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UtfNcmp --
 *
 *	Compare at most numChars chars (not bytes) of string cs to string ct. Both cs
 *	and ct are assumed to be at least numChars chars long.
 *
 * Results:
 *	Return <0 if cs < ct, 0 if cs == ct, or >0 if cs > ct.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclUtfNcmp(tls *libc.TLS, cs uintptr, ct uintptr, numChars Tsize_t) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Number of UTF-16 chars to compare. */
	var v1 Tsize_t
	var _ /* ch1 at bp+0 */ uint16
	var _ /* ch2 at bp+2 */ uint16
	_ = v1
	*(*uint16)(unsafe.Pointer(bp)) = uint16(0)
	*(*uint16)(unsafe.Pointer(bp + 2)) = uint16(0)
	/*
	 * Cannot use 'memcmp(cs, ct, n);' as byte representation of \u0000 (the
	 * pair of bytes 0xC0,0x80) is larger than byte representation of \u0001
	 * (the byte 0x01.)
	 */
	for {
		v1 = numChars
		numChars--
		if !(v1 > uint64(0)) {
			break
		}
		/*
		 * n must be interpreted as chars, not bytes. This should be called
		 * only when both strings are of at least n UTF-16 chars long (no need for \0
		 * check)
		 */
		cs += uintptr(XTcl_UtfToChar16(tls, cs, bp))
		ct += uintptr(XTcl_UtfToChar16(tls, ct, bp+2))
		if libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(bp))) != libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(bp + 2))) {
			/* Surrogates always report higher than non-surrogates */
			if libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(bp)))&int32(0xFC00) == int32(0xD800) {
				if libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(bp + 2)))&int32(0xFC00) != int32(0xD800) {
					return libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(bp)))
				}
			} else {
				if libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(bp + 2)))&int32(0xFC00) == int32(0xD800) {
					return -libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(bp + 2)))
				}
			}
			return libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(bp))) - libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(bp + 2)))
		}
	}
	return 0
}

func XTcl_UtfNcmp(tls *libc.TLS, cs uintptr, ct uintptr, numChars Tsize_t) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Number of chars to compare. */
	var v1 Tsize_t
	var v2, v3 int64
	var _ /* ch1 at bp+0 */ TTcl_UniChar
	var _ /* ch2 at bp+4 */ TTcl_UniChar
	_, _, _ = v1, v2, v3
	*(*TTcl_UniChar)(unsafe.Pointer(bp)) = 0
	*(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) = 0
	/*
	 * Cannot use 'memcmp(cs, ct, n);' as byte representation of \u0000 (the
	 * pair of bytes 0xC0,0x80) is larger than byte representation of \u0001
	 * (the byte 0x01.)
	 */
	for {
		v1 = numChars
		numChars--
		if !(v1 > uint64(0)) {
			break
		}
		/*
		 * n must be interpreted as chars, not bytes. This should be called
		 * only when both strings are of at least n chars long (no need for \0
		 * check)
		 */
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cs))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cs)))
			v2 = int64(libc.Int32FromInt32(1))
		} else {
			v2 = XTcl_UtfToUniChar(tls, cs, bp)
		}
		cs += uintptr(v2)
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ct))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ct)))
			v3 = int64(libc.Int32FromInt32(1))
		} else {
			v3 = XTcl_UtfToUniChar(tls, ct, bp+4)
		}
		ct += uintptr(v3)
		if *(*TTcl_UniChar)(unsafe.Pointer(bp)) != *(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) {
			return *(*TTcl_UniChar)(unsafe.Pointer(bp)) - *(*TTcl_UniChar)(unsafe.Pointer(bp + 4))
		}
	}
	return 0
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UtfNcasecmp --
 *
 *	Compare at most numChars chars (not bytes) of string cs to string ct case
 *	insensitive. Both cs and ct are assumed to be at least numChars UTF
 *	chars long.
 *
 * Results:
 *	Return <0 if cs < ct, 0 if cs == ct, or >0 if cs > ct.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclUtfNcasecmp(tls *libc.TLS, cs uintptr, ct uintptr, numChars Tsize_t) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Number of UTF-16 chars to compare. */
	var v1 Tsize_t
	var _ /* ch1 at bp+0 */ uint16
	var _ /* ch2 at bp+2 */ uint16
	_ = v1
	*(*uint16)(unsafe.Pointer(bp)) = uint16(0)
	*(*uint16)(unsafe.Pointer(bp + 2)) = uint16(0)
	for {
		v1 = numChars
		numChars--
		if !(v1 > uint64(0)) {
			break
		}
		/*
		 * n must be interpreted as UTF-16 chars, not bytes.
		 * This should be called only when both strings are of
		 * at least n UTF-16 chars long (no need for \0 check)
		 */
		cs += uintptr(XTcl_UtfToChar16(tls, cs, bp))
		ct += uintptr(XTcl_UtfToChar16(tls, ct, bp+2))
		if libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(bp))) != libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(bp + 2))) {
			/* Surrogates always report higher than non-surrogates */
			if libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(bp)))&int32(0xFC00) == int32(0xD800) {
				if libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(bp + 2)))&int32(0xFC00) != int32(0xD800) {
					return libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(bp)))
				}
			} else {
				if libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(bp + 2)))&int32(0xFC00) == int32(0xD800) {
					return -libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(bp + 2)))
				}
			}
			*(*uint16)(unsafe.Pointer(bp)) = libc.Uint16FromInt32(XTcl_UniCharToLower(tls, libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(bp)))))
			*(*uint16)(unsafe.Pointer(bp + 2)) = libc.Uint16FromInt32(XTcl_UniCharToLower(tls, libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(bp + 2)))))
			if libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(bp))) != libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(bp + 2))) {
				return libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(bp))) - libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(bp + 2)))
			}
		}
	}
	return 0
}

func XTcl_UtfNcasecmp(tls *libc.TLS, cs uintptr, ct uintptr, numChars Tsize_t) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Number of chars to compare. */
	var v1 Tsize_t
	var v2, v3 int64
	var _ /* ch1 at bp+0 */ TTcl_UniChar
	var _ /* ch2 at bp+4 */ TTcl_UniChar
	_, _, _ = v1, v2, v3
	*(*TTcl_UniChar)(unsafe.Pointer(bp)) = 0
	*(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) = 0
	for {
		v1 = numChars
		numChars--
		if !(v1 > uint64(0)) {
			break
		}
		/*
		 * n must be interpreted as chars, not bytes.
		 * This should be called only when both strings are of
		 * at least n chars long (no need for \0 check)
		 */
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cs))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cs)))
			v2 = int64(libc.Int32FromInt32(1))
		} else {
			v2 = XTcl_UtfToUniChar(tls, cs, bp)
		}
		cs += uintptr(v2)
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ct))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ct)))
			v3 = int64(libc.Int32FromInt32(1))
		} else {
			v3 = XTcl_UtfToUniChar(tls, ct, bp+4)
		}
		ct += uintptr(v3)
		if *(*TTcl_UniChar)(unsafe.Pointer(bp)) != *(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp)) = XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(bp)))
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) = XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(bp + 4)))
			if *(*TTcl_UniChar)(unsafe.Pointer(bp)) != *(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) {
				return *(*TTcl_UniChar)(unsafe.Pointer(bp)) - *(*TTcl_UniChar)(unsafe.Pointer(bp + 4))
			}
		}
	}
	return 0
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UtfCmp --
 *
 *	Compare UTF chars of string cs to string ct case sensitively.
 *	Replacement for strcmp in Tcl core, in places where UTF-8 should
 *	be handled.
 *
 * Results:
 *	Return <0 if cs < ct, 0 if cs == ct, or >0 if cs > ct.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclUtfCmp(tls *libc.TLS, cs uintptr, ct uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* UTF string cs is compared to. */
	var v1, v2 int64
	var _ /* ch1 at bp+0 */ TTcl_UniChar
	var _ /* ch2 at bp+4 */ TTcl_UniChar
	_, _ = v1, v2
	*(*TTcl_UniChar)(unsafe.Pointer(bp)) = 0
	*(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) = 0
	for *(*uint8)(unsafe.Pointer(cs)) != 0 && *(*uint8)(unsafe.Pointer(ct)) != 0 {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cs))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cs)))
			v1 = int64(libc.Int32FromInt32(1))
		} else {
			v1 = XTcl_UtfToUniChar(tls, cs, bp)
		}
		cs += uintptr(v1)
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ct))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ct)))
			v2 = int64(libc.Int32FromInt32(1))
		} else {
			v2 = XTcl_UtfToUniChar(tls, ct, bp+4)
		}
		ct += uintptr(v2)
		if *(*TTcl_UniChar)(unsafe.Pointer(bp)) != *(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) {
			return *(*TTcl_UniChar)(unsafe.Pointer(bp)) - *(*TTcl_UniChar)(unsafe.Pointer(bp + 4))
		}
	}
	return libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cs))) - libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ct)))
}

/*
 *----------------------------------------------------------------------
 *
 * TclUtfCasecmp --
 *
 *	Compare UTF chars of string cs to string ct case insensitively.
 *	Replacement for strcasecmp in Tcl core, in places where UTF-8 should
 *	be handled.
 *
 * Results:
 *	Return <0 if cs < ct, 0 if cs == ct, or >0 if cs > ct.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclUtfCasecmp(tls *libc.TLS, cs uintptr, ct uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* UTF string cs is compared to. */
	var v1, v2 int64
	var _ /* ch1 at bp+0 */ TTcl_UniChar
	var _ /* ch2 at bp+4 */ TTcl_UniChar
	_, _ = v1, v2
	*(*TTcl_UniChar)(unsafe.Pointer(bp)) = 0
	*(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) = 0
	for *(*uint8)(unsafe.Pointer(cs)) != 0 && *(*uint8)(unsafe.Pointer(ct)) != 0 {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cs))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cs)))
			v1 = int64(libc.Int32FromInt32(1))
		} else {
			v1 = XTcl_UtfToUniChar(tls, cs, bp)
		}
		cs += uintptr(v1)
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ct))) < int32(0x80) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ct)))
			v2 = int64(libc.Int32FromInt32(1))
		} else {
			v2 = XTcl_UtfToUniChar(tls, ct, bp+4)
		}
		ct += uintptr(v2)
		if *(*TTcl_UniChar)(unsafe.Pointer(bp)) != *(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) {
			*(*TTcl_UniChar)(unsafe.Pointer(bp)) = XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(bp)))
			*(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) = XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(bp + 4)))
			if *(*TTcl_UniChar)(unsafe.Pointer(bp)) != *(*TTcl_UniChar)(unsafe.Pointer(bp + 4)) {
				return *(*TTcl_UniChar)(unsafe.Pointer(bp)) - *(*TTcl_UniChar)(unsafe.Pointer(bp + 4))
			}
		}
	}
	return libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cs))) - libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ct)))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UniCharToUpper --
 *
 *	Compute the uppercase equivalent of the given Unicode character.
 *
 * Results:
 *	Returns the uppercase Unicode character.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UniCharToUpper(tls *libc.TLS, ch int32) (r int32) {
	/* Unicode character to convert. */
	var info int32
	_ = info
	if !(ch&libc.Int32FromInt32(0x1FFFFF) >= libc.Int32FromInt32(0x323C0)) {
		info = _groups[_groupMap[libc.Int32FromUint16(_pageMap[ch&int32(0x1FFFFF)>>int32(OFFSET_BITS)])|ch&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(OFFSET_BITS)-libc.Int32FromInt32(1))]]
		if info&int32(0xE0)>>int32(5)&int32(0x04) != 0 {
			ch -= info >> int32(8)
		}
	}
	/* Clear away extension bits, if any */
	return ch & int32(0x1FFFFF)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UniCharToLower --
 *
 *	Compute the lowercase equivalent of the given Unicode character.
 *
 * Results:
 *	Returns the lowercase Unicode character.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UniCharToLower(tls *libc.TLS, ch int32) (r int32) {
	/* Unicode character to convert. */
	var info, mode int32
	_, _ = info, mode
	if !(ch&libc.Int32FromInt32(0x1FFFFF) >= libc.Int32FromInt32(0x323C0)) {
		info = _groups[_groupMap[libc.Int32FromUint16(_pageMap[ch&int32(0x1FFFFF)>>int32(OFFSET_BITS)])|ch&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(OFFSET_BITS)-libc.Int32FromInt32(1))]]
		mode = info & int32(0xE0) >> int32(5)
		if mode&int32(0x02) != 0 && mode != int32(0x7) {
			ch += info >> int32(8)
		}
	}
	/* Clear away extension bits, if any */
	return ch & int32(0x1FFFFF)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UniCharToTitle --
 *
 *	Compute the titlecase equivalent of the given Unicode character.
 *
 * Results:
 *	Returns the titlecase Unicode character.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UniCharToTitle(tls *libc.TLS, ch int32) (r int32) {
	/* Unicode character to convert. */
	var info, mode, v1 int32
	_, _, _ = info, mode, v1
	if !(ch&libc.Int32FromInt32(0x1FFFFF) >= libc.Int32FromInt32(0x323C0)) {
		info = _groups[_groupMap[libc.Int32FromUint16(_pageMap[ch&int32(0x1FFFFF)>>int32(OFFSET_BITS)])|ch&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(OFFSET_BITS)-libc.Int32FromInt32(1))]]
		mode = info & int32(0xE0) >> int32(5)
		if mode&int32(0x1) != 0 {
			/*
			 * Subtract or add one depending on the original case.
			 */
			if mode != int32(0x7) {
				if mode&int32(0x4) != 0 {
					v1 = -int32(1)
				} else {
					v1 = int32(1)
				}
				ch += v1
			}
		} else {
			if mode == int32(0x4) {
				ch -= info >> int32(8)
			}
		}
	}
	/* Clear away extension bits, if any */
	return ch & int32(0x1FFFFF)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_Char16Len --
 *
 *	Find the length of a UniChar string. The str input must be null
 *	terminated.
 *
 * Results:
 *	Returns the length of str in UniChars (not bytes).
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_Char16Len(tls *libc.TLS, uniStr uintptr) (r TTcl_Size) {
	/* Unicode string to find length of. */
	var len1 TTcl_Size
	_ = len1
	len1 = 0
	for libc.Int32FromUint16(*(*uint16)(unsafe.Pointer(uniStr))) != int32('\000') {
		len1++
		uniStr += 2
	}
	return len1
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UniCharLen --
 *
 *	Find the length of a UniChar string. The str input must be null
 *	terminated.
 *
 * Results:
 *	Returns the length of str in UniChars (not bytes).
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UniCharLen(tls *libc.TLS, uniStr uintptr) (r TTcl_Size) {
	/* Unicode string to find length of. */
	var len1 TTcl_Size
	_ = len1
	len1 = 0
	for *(*int32)(unsafe.Pointer(uniStr)) != int32('\000') {
		len1++
		uniStr += 4
	}
	return len1
}

/*
 *----------------------------------------------------------------------
 *
 * TclUniCharNcmp --
 *
 *	Compare at most numChars chars (not bytes) of string ucs to string uct.
 *	Both ucs and uct are assumed to be at least numChars chars long.
 *
 * Results:
 *	Return <0 if ucs < uct, 0 if ucs == uct, or >0 if ucs > uct.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclUniCharNcmp(tls *libc.TLS, ucs uintptr, uct uintptr, numChars Tsize_t) (r int32) {
	/* Number of chars to compare. */
	/*
	 * We are definitely on a big-endian machine; memcmp() is safe
	 */
	return libc.Xmemcmp(tls, ucs, uct, numChars*uint64(4))
}

/*
 *----------------------------------------------------------------------
 *
 * TclUniCharNcasecmp --
 *
 *	Compare at most numChars chars (not bytes) of string ucs to string uct case
 *	insensitive. Both ucs and uct are assumed to be at least numChars
 *	chars long.
 *
 * Results:
 *	Return <0 if ucs < uct, 0 if ucs == uct, or >0 if ucs > uct.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclUniCharNcasecmp(tls *libc.TLS, ucs uintptr, uct uintptr, numChars Tsize_t) (r int32) {
	/* Number of chars to compare. */
	var lcs, lct TTcl_UniChar
	_, _ = lcs, lct
	for {
		if !(numChars != uint64(0)) {
			break
		}
		if *(*TTcl_UniChar)(unsafe.Pointer(ucs)) != *(*TTcl_UniChar)(unsafe.Pointer(uct)) {
			lcs = XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(ucs)))
			lct = XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(uct)))
			if lcs != lct {
				return lcs - lct
			}
		}
		goto _1
	_1:
		;
		numChars--
		ucs += 4
		uct += 4
	}
	return 0
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UniCharIsAlnum --
 *
 *	Test if a character is an alphanumeric Unicode character.
 *
 * Results:
 *	Returns 1 if character is alphanumeric.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UniCharIsAlnum(tls *libc.TLS, ch int32) (r int32) {
	/* Unicode character to test. */
	if ch&int32(0x1FFFFF) >= int32(0x323C0) {
		return 0
	}
	return (int32(ALPHA_BITS) | int32(DIGIT_BITS)) >> (_groups[_groupMap[libc.Int32FromUint16(_pageMap[ch&int32(0x1FFFFF)>>int32(OFFSET_BITS)])|ch&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(OFFSET_BITS)-libc.Int32FromInt32(1))]] & int32(0x1F)) & int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UniCharIsAlpha --
 *
 *	Test if a character is an alphabetic Unicode character.
 *
 * Results:
 *	Returns 1 if character is alphabetic.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UniCharIsAlpha(tls *libc.TLS, ch int32) (r int32) {
	/* Unicode character to test. */
	if ch&int32(0x1FFFFF) >= int32(0x323C0) {
		return 0
	}
	return int32(ALPHA_BITS) >> (_groups[_groupMap[libc.Int32FromUint16(_pageMap[ch&int32(0x1FFFFF)>>int32(OFFSET_BITS)])|ch&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(OFFSET_BITS)-libc.Int32FromInt32(1))]] & int32(0x1F)) & int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UniCharIsControl --
 *
 *	Test if a character is a Unicode control character.
 *
 * Results:
 *	Returns non-zero if character is a control.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UniCharIsControl(tls *libc.TLS, ch int32) (r int32) {
	/* Unicode character to test. */
	if ch&int32(0x1FFFFF) >= int32(0x323C0) {
		/* Clear away extension bits, if any */
		ch &= int32(0x1FFFFF)
		return libc.BoolInt32(ch == int32(0xE0001) || libc.Uint32FromInt32(ch-libc.Int32FromInt32(0xE0020)) <= uint32(0x5F))
	}
	return int32(CONTROL_BITS) >> (_groups[_groupMap[libc.Int32FromUint16(_pageMap[ch&int32(0x1FFFFF)>>int32(OFFSET_BITS)])|ch&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(OFFSET_BITS)-libc.Int32FromInt32(1))]] & int32(0x1F)) & int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UniCharIsDigit --
 *
 *	Test if a character is a numeric Unicode character.
 *
 * Results:
 *	Returns non-zero if character is a digit.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UniCharIsDigit(tls *libc.TLS, ch int32) (r int32) {
	/* Unicode character to test. */
	if ch&int32(0x1FFFFF) >= int32(0x323C0) {
		return 0
	}
	return libc.BoolInt32(_groups[_groupMap[libc.Int32FromUint16(_pageMap[ch&int32(0x1FFFFF)>>int32(OFFSET_BITS)])|ch&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(OFFSET_BITS)-libc.Int32FromInt32(1))]]&int32(0x1F) == int32(DECIMAL_DIGIT_NUMBER))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UniCharIsGraph --
 *
 *	Test if a character is any Unicode print character except space.
 *
 * Results:
 *	Returns non-zero if character is printable, but not space.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UniCharIsGraph(tls *libc.TLS, ch int32) (r int32) {
	/* Unicode character to test. */
	if ch&int32(0x1FFFFF) >= int32(0x323C0) {
		return libc.BoolInt32(libc.Uint32FromInt32(ch&libc.Int32FromInt32(0x1FFFFF)-libc.Int32FromInt32(0xE0100)) <= uint32(0xEF))
	}
	return int32(GRAPH_BITS) >> (_groups[_groupMap[libc.Int32FromUint16(_pageMap[ch&int32(0x1FFFFF)>>int32(OFFSET_BITS)])|ch&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(OFFSET_BITS)-libc.Int32FromInt32(1))]] & int32(0x1F)) & int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UniCharIsLower --
 *
 *	Test if a character is a lowercase Unicode character.
 *
 * Results:
 *	Returns non-zero if character is lowercase.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UniCharIsLower(tls *libc.TLS, ch int32) (r int32) {
	/* Unicode character to test. */
	if ch&int32(0x1FFFFF) >= int32(0x323C0) {
		return 0
	}
	return libc.BoolInt32(_groups[_groupMap[libc.Int32FromUint16(_pageMap[ch&int32(0x1FFFFF)>>int32(OFFSET_BITS)])|ch&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(OFFSET_BITS)-libc.Int32FromInt32(1))]]&int32(0x1F) == int32(LOWERCASE_LETTER))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UniCharIsPrint --
 *
 *	Test if a character is a Unicode print character.
 *
 * Results:
 *	Returns non-zero if character is printable.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UniCharIsPrint(tls *libc.TLS, ch int32) (r int32) {
	/* Unicode character to test. */
	if ch&int32(0x1FFFFF) >= int32(0x323C0) {
		return libc.BoolInt32(libc.Uint32FromInt32(ch&libc.Int32FromInt32(0x1FFFFF)-libc.Int32FromInt32(0xE0100)) <= uint32(0xEF))
	}
	return (int32(GRAPH_BITS) | int32(SPACE_BITS)) >> (_groups[_groupMap[libc.Int32FromUint16(_pageMap[ch&int32(0x1FFFFF)>>int32(OFFSET_BITS)])|ch&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(OFFSET_BITS)-libc.Int32FromInt32(1))]] & int32(0x1F)) & int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UniCharIsPunct --
 *
 *	Test if a character is a Unicode punctuation character.
 *
 * Results:
 *	Returns non-zero if character is punct.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UniCharIsPunct(tls *libc.TLS, ch int32) (r int32) {
	/* Unicode character to test. */
	if ch&int32(0x1FFFFF) >= int32(0x323C0) {
		return 0
	}
	return int32(PUNCT_BITS) >> (_groups[_groupMap[libc.Int32FromUint16(_pageMap[ch&int32(0x1FFFFF)>>int32(OFFSET_BITS)])|ch&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(OFFSET_BITS)-libc.Int32FromInt32(1))]] & int32(0x1F)) & int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UniCharIsSpace --
 *
 *	Test if a character is a whitespace Unicode character.
 *
 * Results:
 *	Returns non-zero if character is a space.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UniCharIsSpace(tls *libc.TLS, ch int32) (r int32) {
	/* Unicode character to test. */
	var v1 int32
	_ = v1
	/* Ignore upper 11 bits. */
	ch &= int32(0x1FFFFF)
	/*
	 * If the character is within the first 127 characters, just use the
	 * standard C function, otherwise consult the Unicode table.
	 */
	if ch < int32(0x80) {
		if libc.Int32FromUint8(libc.Uint8FromInt32(ch)) > int32(0x20) {
			v1 = 0
		} else {
			v1 = XTclIsSpaceProc(tls, libc.Int32FromUint8(libc.Uint8FromInt32(ch)))
		}
		return v1
	} else {
		if ch&int32(0x1FFFFF) >= int32(0x323C0) {
			return 0
		} else {
			if ch == int32(0x0085) || ch == int32(0x180E) || ch == int32(0x200B) || ch == int32(0x202F) || ch == int32(0x2060) || ch == int32(0xFEFF) {
				return int32(1)
			} else {
				return int32(SPACE_BITS) >> (_groups[_groupMap[libc.Int32FromUint16(_pageMap[ch&int32(0x1FFFFF)>>int32(OFFSET_BITS)])|ch&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(OFFSET_BITS)-libc.Int32FromInt32(1))]] & int32(0x1F)) & int32(1)
			}
		}
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UniCharIsUpper --
 *
 *	Test if a character is a uppercase Unicode character.
 *
 * Results:
 *	Returns non-zero if character is uppercase.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UniCharIsUpper(tls *libc.TLS, ch int32) (r int32) {
	/* Unicode character to test. */
	if ch&int32(0x1FFFFF) >= int32(0x323C0) {
		return 0
	}
	return libc.BoolInt32(_groups[_groupMap[libc.Int32FromUint16(_pageMap[ch&int32(0x1FFFFF)>>int32(OFFSET_BITS)])|ch&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(OFFSET_BITS)-libc.Int32FromInt32(1))]]&int32(0x1F) == int32(UPPERCASE_LETTER))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UniCharIsWordChar --
 *
 *	Test if a character is alphanumeric or a connector punctuation mark.
 *
 * Results:
 *	Returns 1 if character is a word character.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UniCharIsWordChar(tls *libc.TLS, ch int32) (r int32) {
	/* Unicode character to test. */
	if ch&int32(0x1FFFFF) >= int32(0x323C0) {
		return 0
	}
	return int32(WORD_BITS) >> (_groups[_groupMap[libc.Int32FromUint16(_pageMap[ch&int32(0x1FFFFF)>>int32(OFFSET_BITS)])|ch&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(OFFSET_BITS)-libc.Int32FromInt32(1))]] & int32(0x1F)) & int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * TclUniCharCaseMatch --
 *
 *	See if a particular Unicode string matches a particular pattern.
 *	Allows case insensitivity. This is the Unicode equivalent of the char*
 *	Tcl_StringCaseMatch. The UniChar strings must be NULL-terminated.
 *	This has no provision for counted UniChar strings, thus should not be
 *	used where NULLs are expected in the UniChar string. Use
 *	TclUniCharMatch where possible.
 *
 * Results:
 *	The return value is 1 if string matches pattern, and 0 otherwise. The
 *	matching operation permits the following special characters in the
 *	pattern: *?\[] (see the manual entry for details on what these mean).
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclUniCharCaseMatch(tls *libc.TLS, uniStr uintptr, uniPattern uintptr, nocase int32) (r int32) {
	/* 0 for case sensitive, 1 for insensitive */
	var ch1, endChar, p, startChar TTcl_UniChar
	var v1, v5 uintptr
	var v2, v3, v4 int32
	_, _, _, _, _, _, _, _, _ = ch1, endChar, p, startChar, v1, v2, v3, v4, v5
	ch1 = 0
	for int32(1) != 0 {
		p = *(*TTcl_UniChar)(unsafe.Pointer(uniPattern))
		/*
		 * See if we're at the end of both the pattern and the string. If so,
		 * we succeeded. If we're at the end of the pattern but not at the end
		 * of the string, we failed.
		 */
		if p == 0 {
			return libc.BoolInt32(*(*TTcl_UniChar)(unsafe.Pointer(uniStr)) == 0)
		}
		if *(*TTcl_UniChar)(unsafe.Pointer(uniStr)) == 0 && p != int32('*') {
			return 0
		}
		/*
		 * Check for a "*" as the next pattern character. It matches any
		 * substring. We handle this by skipping all the characters up to the
		 * next matching one in the pattern, and then calling ourselves
		 * recursively for each postfix of string, until either we match or we
		 * reach the end of the string.
		 */
		if p == int32('*') {
			/*
			 * Skip all successive *'s in the pattern
			 */
			for {
				uniPattern += 4
				v1 = uniPattern
				if !(*(*TTcl_UniChar)(unsafe.Pointer(v1)) == int32('*')) {
					break
				}
				/* empty body */
			}
			p = *(*TTcl_UniChar)(unsafe.Pointer(uniPattern))
			if p == 0 {
				return int32(1)
			}
			if nocase != 0 {
				p = XTcl_UniCharToLower(tls, p)
			}
			for int32(1) != 0 {
				/*
				 * Optimization for matching - cruise through the string
				 * quickly if the next char in the pattern isn't a special
				 * character
				 */
				if p != int32('[') && p != int32('?') && p != int32('\\') {
					if nocase != 0 {
						for *(*TTcl_UniChar)(unsafe.Pointer(uniStr)) != 0 && p != *(*TTcl_UniChar)(unsafe.Pointer(uniStr)) && p != XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(uniStr))) {
							uniStr += 4
						}
					} else {
						for *(*TTcl_UniChar)(unsafe.Pointer(uniStr)) != 0 && p != *(*TTcl_UniChar)(unsafe.Pointer(uniStr)) {
							uniStr += 4
						}
					}
				}
				if XTclUniCharCaseMatch(tls, uniStr, uniPattern, nocase) != 0 {
					return int32(1)
				}
				if *(*TTcl_UniChar)(unsafe.Pointer(uniStr)) == 0 {
					return 0
				}
				uniStr += 4
			}
		}
		/*
		 * Check for a "?" as the next pattern character. It matches any
		 * single character.
		 */
		if p == int32('?') {
			uniPattern += 4
			uniStr += 4
			continue
		}
		/*
		 * Check for a "[" as the next pattern character. It is followed by a
		 * list of characters that are acceptable, or by a range (two
		 * characters separated by "-").
		 */
		if p == int32('[') {
			uniPattern += 4
			if nocase != 0 {
				v2 = XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(uniStr)))
			} else {
				v2 = *(*TTcl_UniChar)(unsafe.Pointer(uniStr))
			}
			ch1 = v2
			uniStr += 4
			for int32(1) != 0 {
				if *(*TTcl_UniChar)(unsafe.Pointer(uniPattern)) == int32(']') || *(*TTcl_UniChar)(unsafe.Pointer(uniPattern)) == 0 {
					return 0
				}
				if nocase != 0 {
					v3 = XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(uniPattern)))
				} else {
					v3 = *(*TTcl_UniChar)(unsafe.Pointer(uniPattern))
				}
				startChar = v3
				uniPattern += 4
				if *(*TTcl_UniChar)(unsafe.Pointer(uniPattern)) == int32('-') {
					uniPattern += 4
					if *(*TTcl_UniChar)(unsafe.Pointer(uniPattern)) == 0 {
						return 0
					}
					if nocase != 0 {
						v4 = XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(uniPattern)))
					} else {
						v4 = *(*TTcl_UniChar)(unsafe.Pointer(uniPattern))
					}
					endChar = v4
					uniPattern += 4
					if startChar <= ch1 && ch1 <= endChar || endChar <= ch1 && ch1 <= startChar {
						/*
						 * Matches ranges of form [a-z] or [z-a].
						 */
						break
					}
				} else {
					if startChar == ch1 {
						break
					}
				}
			}
			for *(*TTcl_UniChar)(unsafe.Pointer(uniPattern)) != int32(']') {
				if *(*TTcl_UniChar)(unsafe.Pointer(uniPattern)) == 0 {
					uniPattern -= 4
					break
				}
				uniPattern += 4
			}
			uniPattern += 4
			continue
		}
		/*
		 * If the next pattern character is '\', just strip off the '\' so we
		 * do exact matching on the character that follows.
		 */
		if p == int32('\\') {
			uniPattern += 4
			v5 = uniPattern
			if *(*TTcl_UniChar)(unsafe.Pointer(v5)) == int32('\000') {
				return 0
			}
		}
		/*
		 * There's no special character. Just make sure that the next bytes of
		 * each string match.
		 */
		if nocase != 0 {
			if XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(uniStr))) != XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(uniPattern))) {
				return 0
			}
		} else {
			if *(*TTcl_UniChar)(unsafe.Pointer(uniStr)) != *(*TTcl_UniChar)(unsafe.Pointer(uniPattern)) {
				return 0
			}
		}
		uniStr += 4
		uniPattern += 4
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * TclUniCharMatch --
 *
 *	See if a particular Unicode string matches a particular pattern.
 *	Allows case insensitivity. This is the Unicode equivalent of the char*
 *	Tcl_StringCaseMatch. This variant of TclUniCharCaseMatch uses counted
 *	Strings, so embedded NULLs are allowed.
 *
 * Results:
 *	The return value is 1 if string matches pattern, and 0 otherwise. The
 *	matching operation permits the following special characters in the
 *	pattern: *?\[] (see the manual entry for details on what these mean).
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclUniCharMatch(tls *libc.TLS, string1 uintptr, strLen TTcl_Size, pattern uintptr, ptnLen TTcl_Size, nocase int32) (r int32) {
	/* 0 for case sensitive, 1 for insensitive */
	var ch1, endChar, p, startChar TTcl_UniChar
	var patternEnd, stringEnd, v1, v5 uintptr
	var v2, v3, v4 int32
	_, _, _, _, _, _, _, _, _, _, _ = ch1, endChar, p, patternEnd, startChar, stringEnd, v1, v2, v3, v4, v5
	stringEnd = string1 + uintptr(strLen)*4
	patternEnd = pattern + uintptr(ptnLen)*4
	for int32(1) != 0 {
		/*
		 * See if we're at the end of both the pattern and the string. If so,
		 * we succeeded. If we're at the end of the pattern but not at the end
		 * of the string, we failed.
		 */
		if pattern == patternEnd {
			return libc.BoolInt32(string1 == stringEnd)
		}
		p = *(*TTcl_UniChar)(unsafe.Pointer(pattern))
		if string1 == stringEnd && p != int32('*') {
			return 0
		}
		/*
		 * Check for a "*" as the next pattern character. It matches any
		 * substring. We handle this by skipping all the characters up to the
		 * next matching one in the pattern, and then calling ourselves
		 * recursively for each postfix of string, until either we match or we
		 * reach the end of the string.
		 */
		if p == int32('*') {
			/*
			 * Skip all successive *'s in the pattern.
			 */
			for {
				pattern += 4
				v1 = pattern
				if !(*(*TTcl_UniChar)(unsafe.Pointer(v1)) == int32('*')) {
					break
				}
				/* empty body */
			}
			if pattern == patternEnd {
				return int32(1)
			}
			p = *(*TTcl_UniChar)(unsafe.Pointer(pattern))
			if nocase != 0 {
				p = XTcl_UniCharToLower(tls, p)
			}
			for int32(1) != 0 {
				/*
				 * Optimization for matching - cruise through the string
				 * quickly if the next char in the pattern isn't a special
				 * character.
				 */
				if p != int32('[') && p != int32('?') && p != int32('\\') {
					if nocase != 0 {
						for string1 < stringEnd && p != *(*TTcl_UniChar)(unsafe.Pointer(string1)) && p != XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(string1))) {
							string1 += 4
						}
					} else {
						for string1 < stringEnd && p != *(*TTcl_UniChar)(unsafe.Pointer(string1)) {
							string1 += 4
						}
					}
				}
				if XTclUniCharMatch(tls, string1, (int64(stringEnd)-int64(string1))/4, pattern, (int64(patternEnd)-int64(pattern))/4, nocase) != 0 {
					return int32(1)
				}
				if string1 == stringEnd {
					return 0
				}
				string1 += 4
			}
		}
		/*
		 * Check for a "?" as the next pattern character. It matches any
		 * single character.
		 */
		if p == int32('?') {
			pattern += 4
			string1 += 4
			continue
		}
		/*
		 * Check for a "[" as the next pattern character. It is followed by a
		 * list of characters that are acceptable, or by a range (two
		 * characters separated by "-").
		 */
		if p == int32('[') {
			pattern += 4
			if nocase != 0 {
				v2 = XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(string1)))
			} else {
				v2 = *(*TTcl_UniChar)(unsafe.Pointer(string1))
			}
			ch1 = v2
			string1 += 4
			for int32(1) != 0 {
				if *(*TTcl_UniChar)(unsafe.Pointer(pattern)) == int32(']') || pattern == patternEnd {
					return 0
				}
				if nocase != 0 {
					v3 = XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(pattern)))
				} else {
					v3 = *(*TTcl_UniChar)(unsafe.Pointer(pattern))
				}
				startChar = v3
				pattern += 4
				if *(*TTcl_UniChar)(unsafe.Pointer(pattern)) == int32('-') {
					pattern += 4
					if pattern == patternEnd {
						return 0
					}
					if nocase != 0 {
						v4 = XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(pattern)))
					} else {
						v4 = *(*TTcl_UniChar)(unsafe.Pointer(pattern))
					}
					endChar = v4
					pattern += 4
					if startChar <= ch1 && ch1 <= endChar || endChar <= ch1 && ch1 <= startChar {
						/*
						 * Matches ranges of form [a-z] or [z-a].
						 */
						break
					}
				} else {
					if startChar == ch1 {
						break
					}
				}
			}
			for *(*TTcl_UniChar)(unsafe.Pointer(pattern)) != int32(']') {
				if pattern == patternEnd {
					pattern -= 4
					break
				}
				pattern += 4
			}
			pattern += 4
			continue
		}
		/*
		 * If the next pattern character is '\', just strip off the '\' so we
		 * do exact matching on the character that follows.
		 */
		if p == int32('\\') {
			pattern += 4
			v5 = pattern
			if v5 == patternEnd {
				return 0
			}
		}
		/*
		 * There's no special character. Just make sure that the next bytes of
		 * each string match.
		 */
		if nocase != 0 {
			if XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(string1))) != XTcl_UniCharToLower(tls, *(*TTcl_UniChar)(unsafe.Pointer(pattern))) {
				return 0
			}
		} else {
			if *(*TTcl_UniChar)(unsafe.Pointer(string1)) != *(*TTcl_UniChar)(unsafe.Pointer(pattern)) {
				return 0
			}
		}
		string1 += 4
		pattern += 4
	}
	return r
}

const COMPAT = 1
const CONCAT_TRIM_SET1 = " \f\v\r\t\n"
const CONCAT_WS_SIZE = -1

/*
 * The absolute pathname of the executable in which this Tcl library is
 * running.
 */

var _executableName = TProcessGlobalValue{}

/*
 * The following values are used in the flags arguments of Tcl*Scan*Element
 * and Tcl*Convert*Element.  The values TCL_DONT_USE_BRACES and
 * TCL_DONT_QUOTE_HASH are defined in tcl.h, like so:
 *
#define TCL_DONT_USE_BRACES     1
#define TCL_DONT_QUOTE_HASH     8
 *
 * Those are public flag bits which callers of the public routines
 * Tcl_Convert*Element() can use to indicate:
 *
 * TCL_DONT_USE_BRACES -	1 means the caller is insisting that brace
 *				quoting not be used when converting the list
 *				element.
 * TCL_DONT_QUOTE_HASH -	1 means the caller insists that a leading hash
 *				character ('#') should *not* be quoted. This
 *				is appropriate when the caller can guarantee
 *				the element is not the first element of a
 *				list, so [eval] cannot mis-parse the element
 *				as a comment.
 *
 * The remaining values which can be carried by the flags of these routines
 * are for internal use only.  Make sure they do not overlap with the public
 * values above.
 *
 * The Tcl*Scan*Element() routines make a determination which of 4 modes of
 * conversion is most appropriate for Tcl*Convert*Element() to perform, and
 * sets two bits of the flags value to indicate the mode selected.
 *
 * For more details, see the comments on the Tcl*Scan*Element and
 * Tcl*Convert*Element routines.
*/

type ConvertFlags = int32

const CONVERT_NONE = 0
const /* The element needs no quoting. Its literal
 * string is suitable as is. */
DONT_USE_BRACES = 1
const
/* The caller is insisting that brace quoting
 * not be used when converting the list
 * element. */
CONVERT_BRACE = 2
const /* The conversion should be enclosing the
 * literal string in braces. */
CONVERT_ESCAPE = 4
const /* The conversion should be using backslashes
 * to escape any characters in the string that
 * require it. */
DONT_QUOTE_HASH = 8
const
/* The caller insists that a leading hash
 * character ('#') should *not* be quoted. This
 * is appropriate when the caller can guarantee
 * the element is not the first element of a
 * list, so [eval] cannot mis-parse the element
 * as a comment.*/
CONVERT_MASK = 6
const
/* A mask value used to extract the conversion
 * mode from the flags argument.
 *
 * Also indicates a strange conversion mode
 * where all special characters are escaped
 * with backslashes *except for braces*. This
 * is a strange and unnecessary case, but it's
 * part of the historical way in which lists
 * have been formatted in Tcl. To experiment
 * with removing this case, define the value of
 * COMPAT to be 0. */
CONVERT_ANY = 16

/*
 * The following is the Tcl object type definition for an object that
 * represents a list index in the form, "end-offset". It is used as a
 * performance optimization in Tcl_GetIntForIndex. The internal rep is
 * stored directly in the wideValue, so no memory management is required
 * for it. This is a caching internalrep, keeping the result of a parse
 * around. This type is only created from a pre-existing string, so an
 * updateStringProc will never be called and need not exist. The type
 * is unregistered, so has no need of a setFromAnyProc either.
 */

var _endOffsetType = TTcl_ObjType{
	Fname:    __ccgo_ts + 68160,
	Fversion: uint64(libc.UintptrFromInt32(0) + 56),
}

func init() {
	p := unsafe.Pointer(&_endOffsetType)
	*(*uintptr)(unsafe.Add(p, 48)) = __ccgo_fp(XTclLengthOne)
}

func XTclLengthOne(tls *libc.TLS, dummy152 uintptr) (r TTcl_Size) {
	return int64(1)
}

/*
 *	*	STRING REPRESENTATION OF LISTS	*	*	*
 *
 * The next several routines implement the conversions of strings to and from
 * Tcl lists. To understand their operation, the rules of parsing and
 * generating the string representation of lists must be known.  Here we
 * describe them in one place.
 *
 * A list is made up of zero or more elements. Any string is a list if it is
 * made up of alternating substrings of element-separating ASCII whitespace
 * and properly formatted elements.
 *
 * The ASCII characters which can make up the whitespace between list elements
 * are:
 *
 *	\u0009	\t	TAB
 *	\u000A	\n	NEWLINE
 *	\u000B	\v	VERTICAL TAB
 *	\u000C	\f	FORM FEED
 *	\u000D	\r	CARRIAGE RETURN
 *	\u0020		SPACE
 *
 * NOTE: differences between this and other places where Tcl defines a role
 * for "whitespace".
 *
 *	* Unlike command parsing, here NEWLINE is just another whitespace
 *	  character; its role as a command terminator in a script has no
 *	  importance here.
 *
 *	* Unlike command parsing, the BACKSLASH NEWLINE sequence is not
 *	  considered to be a whitespace character.
 *
 *	* Other Unicode whitespace characters (recognized by [string is space]
 *	  or Tcl_UniCharIsSpace()) do not play any role as element separators
 *	  in Tcl lists.
 *
 *	* The NUL byte ought not appear, as it is not in strings properly
 *	  encoded for Tcl, but if it is present, it is not treated as
 *	  separating whitespace, or a string terminator. It is just another
 *	  character in a list element.
 *
 * The interpretation of a formatted substring as a list element follows rules
 * similar to the parsing of the words of a command in a Tcl script. Backslash
 * substitution plays a key role, and is defined exactly as it is in command
 * parsing. The same routine, TclParseBackslash() is used in both command
 * parsing and list parsing.
 *
 * NOTE: This means that if and when backslash substitution rules ever change
 * for command parsing, the interpretation of strings as lists also changes.
 *
 * Backslash substitution replaces an "escape sequence" of one or more
 * characters starting with
 *		\u005c	\	BACKSLASH
 * with a single character. The one character escape sequence case happens only
 * when BACKSLASH is the last character in the string. In all other cases, the
 * escape sequence is at least two characters long.
 *
 * The formatted substrings are interpreted as element values according to the
 * following cases:
 *
 * * If the first character of a formatted substring is
 *		\u007b	{	OPEN BRACE
 *   then the end of the substring is the matching
 *		\u007d	}	CLOSE BRACE
 *   character, where matching is determined by counting nesting levels, and
 *   not including any brace characters that are contained within a backslash
 *   escape sequence in the nesting count. Having found the matching brace,
 *   all characters between the braces are the string value of the element.
 *   If no matching close brace is found before the end of the string, the
 *   string is not a Tcl list. If the character following the close brace is
 *   not an element separating whitespace character, or the end of the string,
 *   then the string is not a Tcl list.
 *
 *   NOTE: this differs from a brace-quoted word in the parsing of a Tcl
 *   command only in its treatment of the backslash-newline sequence. In a
 *   list element, the literal characters in the backslash-newline sequence
 *   become part of the element value. In a script word, conversion to a
 *   single SPACE character is done.
 *
 *   NOTE: Most list element values can be represented by a formatted
 *   substring using brace quoting. The exceptions are any element value that
 *   includes an unbalanced brace not in a backslash escape sequence, and any
 *   value that ends with a backslash not itself in a backslash escape
 *   sequence.
 *
 * * If the first character of a formatted substring is
 *		\u0022	"	QUOTE
 *   then the end of the substring is the next QUOTE character, not counting
 *   any QUOTE characters that are contained within a backslash escape
 *   sequence. If no next QUOTE is found before the end of the string, the
 *   string is not a Tcl list. If the character following the closing QUOTE is
 *   not an element separating whitespace character, or the end of the string,
 *   then the string is not a Tcl list. Having found the limits of the
 *   substring, the element value is produced by performing backslash
 *   substitution on the character sequence between the open and close QUOTEs.
 *
 *   NOTE: Any element value can be represented by this style of formatting,
 *   given suitable choice of backslash escape sequences.
 *
 * * All other formatted substrings are terminated by the next element
 *   separating whitespace character in the string.  Having found the limits
 *   of the substring, the element value is produced by performing backslash
 *   substitution on it.
 *
 *   NOTE: Any element value can be represented by this style of formatting,
 *   given suitable choice of backslash escape sequences, with one exception.
 *   The empty string cannot be represented as a list element without the use
 *   of either braces or quotes to delimit it.
 *
 * This collection of parsing rules is implemented in the routine
 * FindElement().
 *
 * In order to produce lists that can be parsed by these rules, we need the
 * ability to distinguish between characters that are part of a list element
 * value from characters providing syntax that define the structure of the
 * list. This means that our code that generates lists must at a minimum be
 * able to produce escape sequences for the 10 characters identified above
 * that have significance to a list parser.
 *
 *	*	*	CANONICAL LISTS	*	*	*	*	*
 *
 * In addition to the basic rules for parsing strings into Tcl lists, there
 * are additional properties to be met by the set of list values that are
 * generated by Tcl.  Such list values are often said to be in "canonical
 * form":
 *
 * * When any canonical list is evaluated as a Tcl script, it is a script of
 *   either zero commands (an empty list) or exactly one command. The command
 *   word is exactly the first element of the list, and each argument word is
 *   exactly one of the following elements of the list. This means that any
 *   characters that have special meaning during script evaluation need
 *   special treatment when canonical lists are produced:
 *
 *	* Whitespace between elements may not include NEWLINE.
 *	* The command terminating character,
 *		\u003b	;	SEMICOLON
 *	  must be BRACEd, QUOTEd, or escaped so that it does not terminate the
 *	  command prematurely.
 *	* Any of the characters that begin substitutions in scripts,
 *		\u0024	$	DOLLAR
 *		\u005b	[	OPEN BRACKET
 *		\u005c	\	BACKSLASH
 *	  need to be BRACEd or escaped.
 *	* In any list where the first character of the first element is
 *		\u0023	#	HASH
 *	  that HASH character must be BRACEd, QUOTEd, or escaped so that it
 *	  does not convert the command into a comment.
 *	* Any list element that contains the character sequence BACKSLASH
 *	  NEWLINE cannot be formatted with BRACEs. The BACKSLASH character
 *	  must be represented by an escape sequence, and unless QUOTEs are
 *	  used, the NEWLINE must be as well.
 *
 * * It is also guaranteed that one can use a canonical list as a building
 *   block of a larger script within command substitution, as in this example:
 *	set script "puts \[[list $cmd $arg]]"; eval $script
 *   To support this usage, any appearance of the character
 *		\u005d	]	CLOSE BRACKET
 *   in a list element must be BRACEd, QUOTEd, or escaped.
 *
 * * Finally it is guaranteed that enclosing a canonical list in braces
 *   produces a new value that is also a canonical list.  This new list has
 *   length 1, and its only element is the original canonical list.  This same
 *   guarantee also makes it possible to construct scripts where an argument
 *   word is given a list value by enclosing the canonical form of that list
 *   in braces:
 *	set script "puts {[list $one $two $three]}"; eval $script
 *   This sort of coding was once fairly common, though it's become more
 *   idiomatic to see the following instead:
 *	set script [list puts [list $one $two $three]]; eval $script
 *   In order to support this guarantee, every canonical list must have
 *   balance when counting those braces that are not in escape sequences.
 *
 * Within these constraints, the canonical list generation routines
 * TclScanElement() and TclConvertElement() attempt to generate the string for
 * any list that is easiest to read. When an element value is itself
 * acceptable as the formatted substring, it is usually used (CONVERT_NONE).
 * When some quoting or escaping is required, use of BRACEs (CONVERT_BRACE) is
 * usually preferred over the use of escape sequences (CONVERT_ESCAPE). There
 * are some exceptions to both of these preferences for reasons of code
 * simplicity, efficiency, and continuation of historical habits. Canonical
 * lists never use the QUOTE formatting to delimit their elements because that
 * form of quoting does not nest, which makes construction of nested lists far
 * too much trouble.  Canonical lists always use only a single SPACE character
 * for element-separating whitespace.
 *
 *	*	*	FUTURE CONSIDERATIONS	*	*	*
 *
 * When a list element requires quoting or escaping due to a CLOSE BRACKET
 * character or an internal QUOTE character, a strange formatting mode is
 * recommended. For example, if the value "a{b]c}d" is converted by the usual
 * modes:
 *
 *	CONVERT_BRACE:	a{b]c}d		=> {a{b]c}d}
 *	CONVERT_ESCAPE:	a{b]c}d		=> a\{b\]c\}d
 *
 * we get perfectly usable formatted list elements. However, this is not what
 * Tcl releases have been producing. Instead, we have:
 *
 *	CONVERT_MASK:	a{b]c}d		=> a{b\]c}d
 *
 * where the CLOSE BRACKET is escaped, but the BRACEs are not. The same effect
 * can be seen replacing ] with " in this example. There does not appear to be
 * any functional or aesthetic purpose for this strange additional mode. The
 * sole purpose I can see for preserving it is to keep generating the same
 * formatted lists programmers have become accustomed to, and perhaps written
 * tests to expect. That is, compatibility only. The additional code
 * complexity required to support this mode is significant. The lines of code
 * supporting it are delimited in the routines below with #if COMPAT
 * directives. This makes it easy to experiment with eliminating this
 * formatting mode simply with "#define COMPAT 0" above. I believe this is
 * worth considering.
 *
 * Another consideration is the treatment of QUOTE characters in list
 * elements. TclConvertElement() must have the ability to produce the escape
 * sequence \" so that when a list element begins with a QUOTE we do not
 * confuse that first character with a QUOTE used as list syntax to define
 * list structure. However, that is the only place where QUOTE characters need
 * quoting. In this way, handling QUOTE could really be much more like the way
 * we handle HASH which also needs quoting and escaping only in particular
 * situations. Following up this could increase the set of list elements that
 * can use the CONVERT_NONE formatting mode.
 *
 * More speculative is that the demands of canonical list form require brace
 * balance for the list as a whole, while the current implementation achieves
 * this by establishing brace balance for every element.
 *
 * Finally, a reminder that the rules for parsing and formatting lists are
 * closely tied together with the rules for parsing and evaluating scripts,
 * and will need to evolve in sync.
 */

/*
 *----------------------------------------------------------------------
 *
 * TclMaxListLength --
 *
 *	Given 'bytes' pointing to 'numBytes' bytes, scan through them and
 *	count the number of whitespace runs that could be list element
 *	separators. If 'numBytes' is TCL_INDEX_NONE, scan to the terminating
 *	'\0'. Not a full list parser. Typically used to get a quick and dirty
 *	overestimate of length size in order to allocate space for an actual
 *	list parser to operate with.
 *
 * Results:
 *	Returns the largest number of list elements that could possibly be in
 *	this string, interpreted as a Tcl list. If 'endPtr' is not NULL,
 *	writes a pointer to the end of the string scanned there.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclMaxListLength(tls *libc.TLS, bytes uintptr, numBytes TTcl_Size, endPtr uintptr) (r TTcl_Size) {
	var count TTcl_Size
	var v1, v2, v3, v6 int32
	var v4 bool
	_, _, _, _, _, _ = count, v1, v2, v3, v4, v6
	count = 0
	if numBytes == 0 || numBytes == int64(-libc.Int32FromInt32(1)) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes))) == int32('\000') {
		/* Empty string case - quick exit */
		goto done
	}
	/*
	 * No list element before leading white space.
	 */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes))) > int32(0x20) {
		v1 = 0
	} else {
		v1 = XTclIsSpaceProc(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes))))
	}
	count += int64(int32(1) - v1)
	/*
	 * Count white space runs as potential element separators.
	 */
	for numBytes != 0 {
		if numBytes == int64(-libc.Int32FromInt32(1)) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes))) == int32('\000') {
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes))) > int32(0x20) {
			v2 = 0
		} else {
			v2 = XTclIsSpaceProc(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes))))
		}
		if v2 != 0 {
			/*
			 * Space run started; bump count.
			 */
			count++
			for {
				bytes++
				numBytes -= libc.BoolInt64(numBytes != int64(-libc.Int32FromInt32(1)))
				goto _5
			_5:
				;
				if v4 = numBytes != 0; v4 {
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes))) > int32(0x20) {
						v3 = 0
					} else {
						v3 = XTclIsSpaceProc(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes))))
					}
				}
				if !(v4 && v3 != 0) {
					break
				}
			}
			if numBytes == 0 || numBytes == int64(-libc.Int32FromInt32(1)) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes))) == int32('\000') {
				break
			}
			/*
			 * (*bytes) is non-space; return to counting state.
			 */
		}
		bytes++
		numBytes -= libc.BoolInt64(numBytes != int64(-libc.Int32FromInt32(1)))
	}
	/*
	 * No list element following trailing white space.
	 */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes + uintptr(-libc.Int32FromInt32(1))))) > int32(0x20) {
		v6 = 0
	} else {
		v6 = XTclIsSpaceProc(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes + uintptr(-libc.Int32FromInt32(1))))))
	}
	count -= int64(v6)
	goto done
done:
	;
	if endPtr != 0 {
		*(*uintptr)(unsafe.Pointer(endPtr)) = bytes
	}
	return count
}

/*
 *----------------------------------------------------------------------
 *
 * TclFindElement --
 *
 *	Given a pointer into a Tcl list, locate the first (or next) element in
 *	the list.
 *
 * Results:
 *	The return value is normally TCL_OK, which means that the element was
 *	successfully located. If TCL_ERROR is returned it means that list
 *	didn't have proper list structure; the interp's result contains a more
 *	detailed error message.
 *
 *	If TCL_OK is returned, then *elementPtr will be set to point to the
 *	first element of list, and *nextPtr will be set to point to the
 *	character just after any white space following the last character
 *	that's part of the element. If this is the last argument in the list,
 *	then *nextPtr will point just after the last character in the list
 *	(i.e., at the character at list+listLength). If sizePtr is non-NULL,
 *	*sizePtr is filled in with the number of bytes in the element. If the
 *	element is in braces, then *elementPtr will point to the character
 *	after the opening brace and *sizePtr will not include either of the
 *	braces. If there isn't an element in the list, *sizePtr will be zero,
 *	and both *elementPtr and *nextPtr will point just after the last
 *	character in the list. If literalPtr is non-NULL, *literalPtr is set
 *	to a boolean value indicating whether the substring returned as the
 *	values of **elementPtr and *sizePtr is the literal value of a list
 *	element. If not, a call to TclCopyAndCollapse() is needed to produce
 *	the actual value of the list element. Note: this function does NOT
 *	collapse backslash sequences, but uses *literalPtr to tell callers
 *	when it is required for them to do so.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclFindElement(tls *libc.TLS, interp uintptr, list uintptr, listLength TTcl_Size, elementPtr uintptr, nextPtr uintptr, sizePtr uintptr, literalPtr uintptr) (r int32) {
	/* If non-zero, fill in with non-zero/zero to
	 * indicate that the substring of *sizePtr
	 * bytes starting at **elementPtr is/is not
	 * the literal list element and therefore
	 * does not/does require a call to
	 * TclCopyAndCollapse() by the caller. */
	return _FindElement(tls, interp, list, listLength, __ccgo_ts+2860, __ccgo_ts+68171, elementPtr, nextPtr, sizePtr, literalPtr)
}

func XTclFindDictElement(tls *libc.TLS, interp uintptr, dict uintptr, dictLength TTcl_Size, elementPtr uintptr, nextPtr uintptr, sizePtr uintptr, literalPtr uintptr) (r int32) {
	/* If non-zero, fill in with non-zero/zero to
	 * indicate that the substring of *sizePtr
	 * bytes starting at **elementPtr is/is not
	 * the literal key or value and therefore
	 * does not/does require a call to
	 * TclCopyAndCollapse() by the caller. */
	return _FindElement(tls, interp, dict, dictLength, __ccgo_ts+19222, __ccgo_ts+26289, elementPtr, nextPtr, sizePtr, literalPtr)
}

func _FindElement(tls *libc.TLS, interp uintptr, string1 uintptr, stringLength TTcl_Size, typeStr uintptr, typeCode uintptr, elementPtr uintptr, nextPtr uintptr, sizePtr uintptr, literalPtr uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* If non-zero, fill in with non-zero/zero to
	 * indicate that the substring of *sizePtr
	 * bytes starting at **elementPtr is/is not
	 * the literal list/dict element and therefore
	 * does not/does require a call to
	 * TclCopyAndCollapse() by the caller. */
	var elemStart, limit, p, p2 uintptr
	var inQuotes, literal, v1, v11, v12, v3, v5, v7, v9 int32
	var openBraces, size TTcl_Size
	var v10, v13, v2, v4, v6, v8 bool
	var _ /* numChars at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = elemStart, inQuotes, limit, literal, openBraces, p, p2, size, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9
	p = string1    /* Points just after list/dict's last byte. */
	openBraces = 0 /* Brace nesting level during parse. */
	inQuotes = 0
	size = 0
	literal = int32(1)
	/*
	 * Skim off leading white space and check for an opening brace or quote.
	 * We treat embedded NULLs in the list/dict as bytes belonging to a list
	 * element (or dictionary key or value).
	 */
	limit = string1 + uintptr(stringLength)
	for {
		if v2 = p < limit; v2 {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) > int32(0x20) {
				v1 = 0
			} else {
				v1 = XTclIsSpaceProc(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))))
			}
		}
		if !(v2 && v1 != 0) {
			break
		}
		p++
	}
	if p == limit { /* no element found */
		elemStart = limit
		goto done
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('{') {
		openBraces = int64(1)
		p++
	} else {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('"') {
			inQuotes = int32(1)
			p++
		}
	}
	elemStart = p
	/*
	 * Find element's end (a space, close brace, or the end of the string).
	 */
	for p < limit {
		switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) {
		/*
		 * Open brace: don't treat specially unless the element is in
		 * braces. In this case, keep a nesting count.
		 */
		case int32('{'):
			if openBraces != 0 {
				openBraces++
			}
			break
			/*
			 * Close brace: if element is in braces, keep nesting count and
			 * quit when the last close brace is seen.
			 */
			fallthrough
		case int32('}'):
			if openBraces > int64(1) {
				openBraces--
			} else {
				if openBraces == int64(1) {
					size = int64(p) - int64(elemStart)
					p++
					if v4 = p >= limit; !v4 {
						if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) > int32(0x20) {
							v3 = 0
						} else {
							v3 = XTclIsSpaceProc(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))))
						}
					}
					if v4 || v3 != 0 {
						goto done
					}
					/*
					 * Garbage after the closing brace; return an error.
					 */
					if interp != libc.UintptrFromInt32(0) {
						p2 = p
						for {
							if v6 = p2 < limit; v6 {
								if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p2))) > int32(0x20) {
									v5 = 0
								} else {
									v5 = XTclIsSpaceProc(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p2))))
								}
							}
							if !(v6 && !(v5 != 0) && p2 < p+uintptr(20)) {
								break
							}
							p2++
						}
						XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+68176, libc.VaList(bp+16, typeStr, int32(int64(p2)-int64(p)), p)))
						XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+2089, typeCode, __ccgo_ts+68233, libc.UintptrFromInt32(0)))
					}
					return int32(TCL_ERROR)
				}
			}
			break
			/*
			 * Backslash: skip over everything up to the end of the backslash
			 * sequence.
			 */
			fallthrough
		case int32('\\'):
			if openBraces == 0 {
				/*
				 * A backslash sequence not within a brace quoted element
				 * means the value of the element is different from the
				 * substring we are parsing. A call to TclCopyAndCollapse() is
				 * needed to produce the element value. Inform the caller.
				 */
				literal = 0
			}
			XTclParseBackslash(tls, p, int64(limit)-int64(p), bp, libc.UintptrFromInt32(0))
			p += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)) - libc.Int64FromInt32(1))
			break
			/*
			 * Double-quote: if element is in quotes then terminate it.
			 */
			fallthrough
		case int32('"'):
			if inQuotes != 0 {
				size = int64(p) - int64(elemStart)
				p++
				if v8 = p >= limit; !v8 {
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) > int32(0x20) {
						v7 = 0
					} else {
						v7 = XTclIsSpaceProc(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))))
					}
				}
				if v8 || v7 != 0 {
					goto done
				}
				/*
				 * Garbage after the closing quote; return an error.
				 */
				if interp != libc.UintptrFromInt32(0) {
					p2 = p
					for {
						if v10 = p2 < limit; v10 {
							if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p2))) > int32(0x20) {
								v9 = 0
							} else {
								v9 = XTclIsSpaceProc(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p2))))
							}
						}
						if !(v10 && !(v9 != 0) && p2 < p+uintptr(20)) {
							break
						}
						p2++
					}
					XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+68238, libc.VaList(bp+16, typeStr, int32(int64(p2)-int64(p)), p)))
					XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+2089, typeCode, __ccgo_ts+68233, libc.UintptrFromInt32(0)))
				}
				return int32(TCL_ERROR)
			}
		default:
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) > int32(0x20) {
				v11 = 0
			} else {
				v11 = XTclIsSpaceProc(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))))
			}
			if v11 != 0 {
				/*
				 * Space: ignore if element is in braces or quotes;
				 * otherwise terminate element.
				 */
				if openBraces == 0 && !(inQuotes != 0) {
					size = int64(p) - int64(elemStart)
					goto done
				}
			}
			break
		}
		p++
	}
	/*
	 * End of list/dict: terminate element.
	 */
	if p == limit {
		if openBraces != 0 {
			if interp != libc.UintptrFromInt32(0) {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+68295, libc.VaList(bp+16, typeStr)))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+2089, typeCode, __ccgo_ts+68322, libc.UintptrFromInt32(0)))
			}
			return int32(TCL_ERROR)
		} else {
			if inQuotes != 0 {
				if interp != libc.UintptrFromInt32(0) {
					XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+68328, libc.VaList(bp+16, typeStr)))
					XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+2089, typeCode, __ccgo_ts+68355, libc.UintptrFromInt32(0)))
				}
				return int32(TCL_ERROR)
			}
		}
		size = int64(p) - int64(elemStart)
	}
	goto done
done:
	;
	for {
		if v13 = p < limit; v13 {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) > int32(0x20) {
				v12 = 0
			} else {
				v12 = XTclIsSpaceProc(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))))
			}
		}
		if !(v13 && v12 != 0) {
			break
		}
		p++
	}
	*(*uintptr)(unsafe.Pointer(elementPtr)) = elemStart
	*(*uintptr)(unsafe.Pointer(nextPtr)) = p
	if sizePtr != uintptr(0) {
		*(*TTcl_Size)(unsafe.Pointer(sizePtr)) = size
	}
	if literalPtr != uintptr(0) {
		*(*int32)(unsafe.Pointer(literalPtr)) = literal
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclCopyAndCollapse --
 *
 *	Copy a string and substitute all backslash escape sequences
 *
 * Results:
 *	Count bytes get copied from src to dst. Along the way, backslash
 *	sequences are substituted in the copy. After scanning count bytes from
 *	src, a null character is placed at the end of dst. Returns the number
 *	of bytes that got written to dst.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclCopyAndCollapse(tls *libc.TLS, count TTcl_Size, src uintptr, dst uintptr) (r TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* ... to here. */
	var backslashCount, newCount TTcl_Size
	var c uint8
	var _ /* buf at bp+0 */ [4]uint8
	var _ /* numRead at bp+8 */ TTcl_Size
	_, _, _ = backslashCount, c, newCount
	newCount = 0
	for count > 0 {
		c = *(*uint8)(unsafe.Pointer(src))
		if libc.Int32FromUint8(c) == int32('\\') {
			*(*[4]uint8)(unsafe.Pointer(bp)) = [4]uint8{}
			backslashCount = int64(XTclParseBackslash(tls, src, count, bp+8, bp))
			libc.Xmemcpy(tls, dst, bp, libc.Uint64FromInt64(backslashCount))
			dst += uintptr(backslashCount)
			newCount += backslashCount
			src += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
			count -= *(*TTcl_Size)(unsafe.Pointer(bp + 8))
		} else {
			*(*uint8)(unsafe.Pointer(dst)) = c
			dst++
			newCount++
			src++
			count--
		}
	}
	*(*uint8)(unsafe.Pointer(dst)) = uint8(0)
	return newCount
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SplitList --
 *
 *	Splits a list up into its constituent fields.
 *
 * Results
 *	The return value is normally TCL_OK, which means that the list was
 *	successfully split up. If TCL_ERROR is returned, it means that "list"
 *	didn't have proper list structure; the interp's result will contain a
 *	more detailed error message.
 *
 *	*argvPtr will be filled in with the address of an array whose elements
 *	point to the elements of list, in order. *argcPtr will get filled in
 *	with the number of valid elements in the array. A single block of
 *	memory is dynamically allocated to hold both the argv array and a copy
 *	of the list (with backslashes and braces removed in the standard way).
 *	The caller must eventually free this memory by calling free() on
 *	*argvPtr. Note: *argvPtr and *argcPtr are only modified if the
 *	function returns normally.
 *
 * Side effects:
 *	Memory is allocated.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SplitList(tls *libc.TLS, interp uintptr, _list uintptr, argcPtr uintptr, argvPtr uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	*(*uintptr)(unsafe.Pointer(bp)) = _list /* Pointer to place to store pointer to array
	 * of pointers to list elements. */
	var argv, p, prevList uintptr
	var i, length, size TTcl_Size
	var result int32
	var _ /* elSize at bp+24 */ TTcl_Size
	var _ /* element at bp+16 */ uintptr
	var _ /* end at bp+8 */ uintptr
	var _ /* literal at bp+32 */ int32
	_, _, _, _, _, _, _ = argv, i, length, p, prevList, result, size
	/*
	 * Allocate enough space to work in. A (const char *) for each (possible)
	 * list element plus one more for terminating NULL, plus as many bytes as
	 * in the original string value, plus one more for a terminating '\0'.
	 * Space used to hold element separating white space in the original
	 * string gets re-purposed to hold '\0' characters in the argv array.
	 */
	size = XTclMaxListLength(tls, *(*uintptr)(unsafe.Pointer(bp)), int64(-libc.Int32FromInt32(1)), bp+8) + int64(1)
	length = int64(*(*uintptr)(unsafe.Pointer(bp + 8))) - int64(*(*uintptr)(unsafe.Pointer(bp)))
	argv = XTcl_Alloc(tls, libc.Uint64FromInt64(size)*uint64(8)+libc.Uint64FromInt64(length)+uint64(1))
	i = 0
	p = argv + uintptr(libc.Uint64FromInt64(size)*libc.Uint64FromInt64(8))
	for {
		if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != 0) {
			break
		}
		prevList = *(*uintptr)(unsafe.Pointer(bp))
		result = XTclFindElement(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), length, bp+16, bp, bp+24, bp+32)
		length -= int64(*(*uintptr)(unsafe.Pointer(bp))) - int64(prevList)
		if result != TCL_OK {
			XTclpFree(tls, argv)
			return result
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16))))) == 0 {
			break
		}
		if i >= size {
			XTclpFree(tls, argv)
			if interp != libc.UintptrFromInt32(0) {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+68361, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+48, __ccgo_ts+2004, __ccgo_ts+68393, __ccgo_ts+68402, libc.UintptrFromInt32(0)))
			}
			return int32(TCL_ERROR)
		}
		*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)) = p
		if *(*int32)(unsafe.Pointer(bp + 32)) != 0 {
			libc.Xmemcpy(tls, p, *(*uintptr)(unsafe.Pointer(bp + 16)), libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 24))))
			p += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 24)))
			*(*uint8)(unsafe.Pointer(p)) = uint8(0)
			p++
		} else {
			p += uintptr(int64(1) + XTclCopyAndCollapse(tls, *(*TTcl_Size)(unsafe.Pointer(bp + 24)), *(*uintptr)(unsafe.Pointer(bp + 16)), p))
		}
		goto _1
	_1:
		;
		i++
	}
	*(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(argvPtr)) = argv
	*(*TTcl_Size)(unsafe.Pointer(argcPtr)) = i
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ScanElement --
 *
 *	This function is a companion function to Tcl_ConvertElement. It scans
 *	a string to see what needs to be done to it (e.g. add backslashes or
 *	enclosing braces) to make the string into a valid Tcl list element.
 *
 * Results:
 *	The return value is an overestimate of the number of bytes that will
 *	be needed by Tcl_ConvertElement to produce a valid list element from
 *	src. The word at *flagPtr is filled in with a value needed by
 *	Tcl_ConvertElement when doing the actual conversion.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ScanElement(tls *libc.TLS, src uintptr, flagPtr uintptr) (r TTcl_Size) {
	/* Where to store information to guide
	 * Tcl_ConvertCountedElement. */
	return XTcl_ScanCountedElement(tls, src, int64(-libc.Int32FromInt32(1)), flagPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ScanCountedElement --
 *
 *	This function is a companion function to Tcl_ConvertCountedElement. It
 *	scans a string to see what needs to be done to it (e.g. add
 *	backslashes or enclosing braces) to make the string into a valid Tcl
 *	list element. If length is TCL_INDEX_NONE, then the string is scanned
 *	from src up to the first null byte.
 *
 * Results:
 *	The return value is an overestimate of the number of bytes that will
 *	be needed by Tcl_ConvertCountedElement to produce a valid list element
 *	from src. The word at *flagPtr is filled in with a value needed by
 *	Tcl_ConvertCountedElement when doing the actual conversion.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ScanCountedElement(tls *libc.TLS, src uintptr, length TTcl_Size, flagPtr uintptr) (r TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Where to store information to guide
	 * Tcl_ConvertElement. */
	var numBytes TTcl_Size
	var _ /* flags at bp+0 */ uint8
	_ = numBytes
	*(*uint8)(unsafe.Pointer(bp)) = uint8(CONVERT_ANY)
	numBytes = XTclScanElement(tls, src, length, bp)
	*(*int32)(unsafe.Pointer(flagPtr)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp)))
	return numBytes
}

/*
 *----------------------------------------------------------------------
 *
 * TclScanElement --
 *
 *	This function is a companion function to TclConvertElement. It scans a
 *	string to see what needs to be done to it (e.g. add backslashes or
 *	enclosing braces) to make the string into a valid Tcl list element. If
 *	length is TCL_INDEX_NONE, then the string is scanned from src up to the first null
 *	byte. A NULL value for src is treated as an empty string. The incoming
 *	value of *flagPtr is a report from the caller what additional flags it
 *	will pass to TclConvertElement().
 *
 * Results:
 *	The recommended formatting mode for the element is determined and a
 *	value is written to *flagPtr indicating that recommendation. This
 *	recommendation is combined with the incoming flag values in *flagPtr
 *	set by the caller to determine how many bytes will be needed by
 *	TclConvertElement() in which to write the formatted element following
 *	the recommendation modified by the flag values. This number of bytes
 *	is the return value of the routine.  In some situations it may be an
 *	overestimate, but so long as the caller passes the same flags to
 *	TclConvertElement(), it will be large enough.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclScanElement(tls *libc.TLS, src uintptr, length TTcl_Size, flagPtr uintptr) (r TTcl_Size) {
	/* Where to store information to guide
	 * Tcl_ConvertElement. */
	var braceCount, forbidNone, preferBrace, preferEscape, requireEscape, v2 int32
	var bytesNeeded, extra, nestingLevel, v1 TTcl_Size
	var p, p3, p4 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _ = braceCount, bytesNeeded, extra, forbidNone, nestingLevel, p, preferBrace, preferEscape, requireEscape, v1, v2, p3, p4
	p = src
	nestingLevel = 0 /* Brace nesting count */
	forbidNone = 0   /* Do not permit CONVERT_NONE mode. Something
	 * needs protection or escape. */
	requireEscape = 0 /* Force use of CONVERT_ESCAPE mode.  For some
	 * reason bare or brace-quoted form fails. */
	extra = 0 /* Buffer length computed to complete the
	 * element formatting in the selected mode. */
	preferEscape = 0 /* Use preferences to track whether to use */
	preferBrace = 0  /* CONVERT_MASK mode. */
	braceCount = 0   /* Count of all braces '{' '}' seen. */
	if p == libc.UintptrFromInt32(0) || length == 0 || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('\000') && length == int64(-libc.Int32FromInt32(1)) {
		/*
		 * Empty string element must be brace quoted.
		 */
		*(*uint8)(unsafe.Pointer(flagPtr)) = uint8(CONVERT_BRACE)
		return int64(2)
	}
	/*
	 * We have an established history in TclConvertElement() when quoting
	 * because of a leading hash character to force what would be the
	 * CONVERT_MASK mode into the CONVERT_BRACE mode. That is, we format
	 * the element #{a"b} like this:
	 *			{#{a"b}}
	 * and not like this:
	 *			\#{a\"b}
	 * This is inconsistent with [list x{a"b}], but we will not change that now.
	 * Set that preference here so that we compute a tight size requirement.
	 */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) == int32('#') && !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(flagPtr)))&int32(DONT_QUOTE_HASH) != 0) {
		preferBrace = int32(1)
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('{') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('"') {
		/*
		 * Must escape or protect so leading character of value is not
		 * misinterpreted as list element delimiting syntax.
		 */
		forbidNone = int32(1)
		preferBrace = int32(1)
	}
	for length != 0 {
		if libc.Int32FromUint8(XtclCharTypeTable[*(*uint8)(unsafe.Pointer(p))]) != int32(TYPE_NORMAL) {
			switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) {
			case int32('{'): /* TYPE_BRACE */
				braceCount++
				extra++ /* Escape '{' => '\{' */
				nestingLevel++
			case int32('}'): /* TYPE_BRACE */
				braceCount++
				extra++ /* Escape '}' => '\}' */
				v1 = nestingLevel
				nestingLevel--
				if v1 < int64(1) {
					/*
					 * Unbalanced braces!  Cannot format with brace quoting.
					 */
					requireEscape = int32(1)
				}
			case int32(']'): /* TYPE_CLOSE_BRACK */
				fallthrough
			case int32('"'): /* TYPE_SPACE */
				forbidNone = int32(1)
				extra++ /* Escapes all just prepend a backslash */
				preferEscape = int32(1)
			case int32('['): /* TYPE_SUBS */
				fallthrough
			case int32('$'): /* TYPE_SUBS */
				fallthrough
			case int32(';'): /* TYPE_COMMAND_END */
				forbidNone = int32(1)
				extra++ /* Escape sequences all one byte longer. */
				preferBrace = int32(1)
			case int32('\\'): /* TYPE_SUBS */
				extra++ /* Escape '\' => '\\' */
				if length == int64(1) || length == int64(-libc.Int32FromInt32(1)) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('\000') {
					/*
					 * Final backslash. Cannot format with brace quoting.
					 */
					requireEscape = int32(1)
					break
				}
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('\n') {
					extra++ /* Escape newline => '\n', one byte longer */
					/*
					 * Backslash newline sequence.  Brace quoting not permitted.
					 */
					requireEscape = int32(1)
					length -= libc.BoolInt64(length > libc.Int64FromInt32(0))
					p++
					break
				}
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('{') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('}') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('\\') {
					extra++ /* Escape sequences all one byte longer. */
					length -= libc.BoolInt64(length > libc.Int64FromInt32(0))
					p++
				}
				forbidNone = int32(1)
				preferBrace = int32(1)
			case int32('\000'): /* TYPE_SUBS */
				if length == int64(-libc.Int32FromInt32(1)) {
					goto endOfString
				}
				/* TODO: Panic on improper encoding? */
			default:
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) > int32(0x20) {
					v2 = 0
				} else {
					v2 = XTclIsSpaceProc(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))))
				}
				if v2 != 0 {
					forbidNone = int32(1)
					extra++ /* Escape sequences all one byte longer. */
					preferBrace = int32(1)
				}
				break
			}
		}
		length -= libc.BoolInt64(length > libc.Int64FromInt32(0))
		p++
	}
	goto endOfString
endOfString:
	;
	if nestingLevel > 0 {
		/*
		 * Unbalanced braces!  Cannot format with brace quoting.
		 */
		requireEscape = int32(1)
	}
	/*
	 * We need at least as many bytes as are in the element value...
	 */
	bytesNeeded = int64(p) - int64(src)
	if requireEscape != 0 {
		/*
		 * We must use escape sequences.  Add all the extra bytes needed to
		 * have room to create them.
		 */
		bytesNeeded += extra
		/*
		 * Make room to escape leading #, if needed.
		 */
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) == int32('#') && !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(flagPtr)))&int32(DONT_QUOTE_HASH) != 0) {
			bytesNeeded++
		}
		*(*uint8)(unsafe.Pointer(flagPtr)) = uint8(CONVERT_ESCAPE)
		return bytesNeeded
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(flagPtr)))&int32(CONVERT_ANY) != 0 {
		/*
		 * The caller has not let us know what flags it will pass to
		 * TclConvertElement() so compute the max size we might need for any
		 * possible choice.  Normally the formatting using escape sequences is
		 * the longer one, and a minimum "extra" value of 2 makes sure we
		 * don't request too small a buffer in those edge cases where that's
		 * not true.
		 */
		if extra < int64(2) {
			extra = int64(2)
		}
		p3 = flagPtr
		*(*uint8)(unsafe.Pointer(p3)) = uint8(int32(*(*uint8)(unsafe.Pointer(p3))) & ^int32(CONVERT_ANY))
		p4 = flagPtr
		*(*uint8)(unsafe.Pointer(p4)) = uint8(int32(*(*uint8)(unsafe.Pointer(p4))) | int32(DONT_USE_BRACES))
	}
	if forbidNone != 0 {
		/*
		 * We must request some form of quoting of escaping...
		 */
		if preferEscape != 0 && !(preferBrace != 0) {
			/*
			 * If we are quoting solely due to ] or internal " characters use
			 * the CONVERT_MASK mode where we escape all special characters
			 * except for braces. "extra" counted space needed to escape
			 * braces too, so subtract "braceCount" to get our actual needs.
			 */
			bytesNeeded += extra - int64(braceCount)
			/* Make room to escape leading #, if needed. */
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) == int32('#') && !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(flagPtr)))&int32(DONT_QUOTE_HASH) != 0) {
				bytesNeeded++
			}
			/*
			 * If the caller reports it will direct TclConvertElement() to
			 * use full escapes on the element, add back the bytes needed to
			 * escape the braces.
			 */
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(flagPtr)))&int32(DONT_USE_BRACES) != 0 {
				bytesNeeded += int64(braceCount)
			}
			*(*uint8)(unsafe.Pointer(flagPtr)) = uint8(CONVERT_MASK)
			return bytesNeeded
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(flagPtr)))&int32(DONT_USE_BRACES) != 0 {
			/*
			 * If the caller reports it will direct TclConvertElement() to
			 * use escapes, add the extra bytes needed to have room for them.
			 */
			bytesNeeded += extra
			/*
			 * Make room to escape leading #, if needed.
			 */
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) == int32('#') && !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(flagPtr)))&int32(DONT_QUOTE_HASH) != 0) {
				bytesNeeded++
			}
		} else {
			/*
			 * Add 2 bytes for room for the enclosing braces.
			 */
			bytesNeeded += int64(2)
		}
		*(*uint8)(unsafe.Pointer(flagPtr)) = uint8(CONVERT_BRACE)
		return bytesNeeded
	}
	/*
	 * So far, no need to quote or escape anything.
	 */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) == int32('#') && !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(flagPtr)))&int32(DONT_QUOTE_HASH) != 0) {
		/*
		 * If we need to quote a leading #, make room to enclose in braces.
		 */
		bytesNeeded += int64(2)
	}
	*(*uint8)(unsafe.Pointer(flagPtr)) = uint8(CONVERT_NONE)
	return bytesNeeded
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ConvertElement --
 *
 *	This is a companion function to Tcl_ScanElement. Given the information
 *	produced by Tcl_ScanElement, this function converts a string to a list
 *	element equal to that string.
 *
 * Results:
 *	Information is copied to *dst in the form of a list element identical
 *	to src (i.e. if Tcl_SplitList is applied to dst it will produce a
 *	string identical to src). The return value is a count of the number of
 *	characters copied (not including the terminating NULL character).
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ConvertElement(tls *libc.TLS, src uintptr, dst uintptr, flags int32) (r TTcl_Size) {
	/* Flags produced by Tcl_ScanElement. */
	return XTcl_ConvertCountedElement(tls, src, int64(-libc.Int32FromInt32(1)), dst, flags)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ConvertCountedElement --
 *
 *	This is a companion function to Tcl_ScanCountedElement. Given the
 *	information produced by Tcl_ScanCountedElement, this function converts
 *	a string to a list element equal to that string.
 *
 * Results:
 *	Information is copied to *dst in the form of a list element identical
 *	to src (i.e. if Tcl_SplitList is applied to dst it will produce a
 *	string identical to src). The return value is a count of the number of
 *	characters copied (not including the terminating NULL character).
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ConvertCountedElement(tls *libc.TLS, src uintptr, length TTcl_Size, dst uintptr, flags int32) (r TTcl_Size) {
	/* Flags produced by Tcl_ScanElement. */
	var numBytes TTcl_Size
	_ = numBytes
	numBytes = XTclConvertElement(tls, src, length, dst, flags)
	*(*uint8)(unsafe.Pointer(dst + uintptr(numBytes))) = uint8('\000')
	return numBytes
}

/*
 *----------------------------------------------------------------------
 *
 * TclConvertElement --
 *
 *	This is a companion function to TclScanElement. Given the information
 *	produced by TclScanElement, this function converts a string to a list
 *	element equal to that string.
 *
 * Results:
 *	Information is copied to *dst in the form of a list element identical
 *	to src (i.e. if Tcl_SplitList is applied to dst it will produce a
 *	string identical to src). The return value is a count of the number of
 *	characters copied (not including the terminating NULL character).
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclConvertElement(tls *libc.TLS, src uintptr, length TTcl_Size, dst uintptr, flags int32) (r TTcl_Size) {
	/* Flags produced by Tcl_ScanElement. */
	var conversion int32
	var p, v1, v2, v3, v4 uintptr
	_, _, _, _, _, _ = conversion, p, v1, v2, v3, v4
	conversion = flags & int32(CONVERT_MASK)
	p = dst
	/*
	 * Let the caller demand we use escape sequences rather than braces.
	 */
	if flags&int32(DONT_USE_BRACES) != 0 && conversion&int32(CONVERT_BRACE) != 0 {
		conversion = int32(CONVERT_ESCAPE)
	}
	/*
	 * No matter what the caller demands, empty string must be braced!
	 */
	if src == libc.UintptrFromInt32(0) || length == 0 || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) == int32('\000') && length == int64(-libc.Int32FromInt32(1)) {
		*(*uint8)(unsafe.Pointer(p)) = uint8('{')
		*(*uint8)(unsafe.Pointer(p + 1)) = uint8('}')
		return int64(2)
	}
	/*
	 * Escape leading hash as needed and requested.
	 */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) == int32('#') && !(flags&int32(DONT_QUOTE_HASH) != 0) {
		if conversion == int32(CONVERT_ESCAPE) {
			*(*uint8)(unsafe.Pointer(p)) = uint8('\\')
			*(*uint8)(unsafe.Pointer(p + 1)) = uint8('#')
			p += uintptr(2)
			src++
			length -= libc.BoolInt64(length > libc.Int64FromInt32(0))
		} else {
			conversion = int32(CONVERT_BRACE)
		}
	}
	/*
	 * No escape or quoting needed.  Copy the literal string value.
	 */
	if conversion == int32(CONVERT_NONE) {
		if length == int64(-libc.Int32FromInt32(1)) {
			/* TODO: INT_MAX overflow? */
			for *(*uint8)(unsafe.Pointer(src)) != 0 {
				v1 = p
				p++
				v2 = src
				src++
				*(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2))
			}
			return int64(p) - int64(dst)
		} else {
			libc.Xmemcpy(tls, dst, src, libc.Uint64FromInt64(length))
			return length
		}
	}
	/*
	 * Formatted string is original string enclosed in braces.
	 */
	if conversion == int32(CONVERT_BRACE) {
		*(*uint8)(unsafe.Pointer(p)) = uint8('{')
		p++
		if length == int64(-libc.Int32FromInt32(1)) {
			/* TODO: INT_MAX overflow? */
			for *(*uint8)(unsafe.Pointer(src)) != 0 {
				v3 = p
				p++
				v4 = src
				src++
				*(*uint8)(unsafe.Pointer(v3)) = *(*uint8)(unsafe.Pointer(v4))
			}
		} else {
			libc.Xmemcpy(tls, p, src, libc.Uint64FromInt64(length))
			p += uintptr(length)
		}
		*(*uint8)(unsafe.Pointer(p)) = uint8('}')
		p++
		return int64(p) - int64(dst)
	}
	/* conversion == CONVERT_ESCAPE or CONVERT_MASK */
	/*
	 * Formatted string is original string converted to escape sequences.
	 */
	for {
		if !(length != 0) {
			break
		}
		switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) {
		case int32(']'):
			fallthrough
		case int32('['):
			fallthrough
		case int32('$'):
			fallthrough
		case int32(';'):
			fallthrough
		case int32(' '):
			fallthrough
		case int32('\\'):
			fallthrough
		case int32('"'):
			*(*uint8)(unsafe.Pointer(p)) = uint8('\\')
			p++
		case int32('{'):
			fallthrough
		case int32('}'):
			if conversion == int32(CONVERT_ESCAPE) {
				*(*uint8)(unsafe.Pointer(p)) = uint8('\\')
				p++
			}
		case int32('\f'):
			*(*uint8)(unsafe.Pointer(p)) = uint8('\\')
			p++
			*(*uint8)(unsafe.Pointer(p)) = uint8('f')
			p++
			goto _5
		case int32('\n'):
			*(*uint8)(unsafe.Pointer(p)) = uint8('\\')
			p++
			*(*uint8)(unsafe.Pointer(p)) = uint8('n')
			p++
			goto _5
		case int32('\r'):
			*(*uint8)(unsafe.Pointer(p)) = uint8('\\')
			p++
			*(*uint8)(unsafe.Pointer(p)) = uint8('r')
			p++
			goto _5
		case int32('\t'):
			*(*uint8)(unsafe.Pointer(p)) = uint8('\\')
			p++
			*(*uint8)(unsafe.Pointer(p)) = uint8('t')
			p++
			goto _5
		case int32('\v'):
			*(*uint8)(unsafe.Pointer(p)) = uint8('\\')
			p++
			*(*uint8)(unsafe.Pointer(p)) = uint8('v')
			p++
			goto _5
		case int32('\000'):
			if length == int64(-libc.Int32FromInt32(1)) {
				return int64(p) - int64(dst)
			}
			/*
			 * If we reach this point, there's an embedded NULL in the string
			 * range being processed, which should not happen when the
			 * encoding rules for Tcl strings are properly followed.  If the
			 * day ever comes when we stop tolerating such things, this is
			 * where to put the Tcl_Panic().
			 */
			break
		}
		*(*uint8)(unsafe.Pointer(p)) = *(*uint8)(unsafe.Pointer(src))
		p++
		goto _5
	_5:
		;
		src++
		length -= libc.BoolInt64(length > libc.Int64FromInt32(0))
	}
	return int64(p) - int64(dst)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_Merge --
 *
 *	Given a collection of strings, merge them together into a single
 *	string that has proper Tcl list structured (i.e. Tcl_SplitList may be
 *	used to retrieve strings equal to the original elements, and Tcl_Eval
 *	will parse the string back into its original elements).
 *
 * Results:
 *	The return value is the address of a dynamically-allocated string
 *	containing the merged list.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_Merge(tls *libc.TLS, argc TTcl_Size, argv uintptr) (r uintptr) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* Array of string values. */
	var bytesNeeded Tsize_t
	var dst, flagPtr, result, p4 uintptr
	var i TTcl_Size
	var v2, v5 int32
	var _ /* localFlags at bp+0 */ [64]uint8
	_, _, _, _, _, _, _, _ = bytesNeeded, dst, flagPtr, i, result, v2, v5, p4
	flagPtr = libc.UintptrFromInt32(0)
	bytesNeeded = uint64(0)
	/*
	 * Handle empty list case first, so logic of the general case can be
	 * simpler.
	 */
	if argc <= 0 {
		if argc < 0 {
			XTcl_Panic(tls, __ccgo_ts+68416, libc.VaList(bp+72, argc))
		}
		result = XTcl_Alloc(tls, uint64(1))
		*(*uint8)(unsafe.Pointer(result)) = uint8('\000')
		return result
	}
	/*
	 * Pass 1: estimate space, gather flags.
	 */
	if argc <= int64(LOCAL_SIZE) {
		flagPtr = bp
	} else {
		flagPtr = XTcl_Alloc(tls, libc.Uint64FromInt64(argc))
	}
	i = 0
	for {
		if !(i < argc) {
			break
		}
		if i != 0 {
			v2 = int32(DONT_QUOTE_HASH)
		} else {
			v2 = 0
		}
		*(*uint8)(unsafe.Pointer(flagPtr + uintptr(i))) = libc.Uint8FromInt32(v2)
		bytesNeeded += libc.Uint64FromInt64(XTclScanElement(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)), int64(-libc.Int32FromInt32(1)), flagPtr+uintptr(i)))
		goto _1
	_1:
		;
		i++
	}
	bytesNeeded += libc.Uint64FromInt64(argc)
	/*
	 * Pass two: copy into the result area.
	 */
	result = XTcl_Alloc(tls, bytesNeeded)
	dst = result
	i = 0
	for {
		if !(i < argc) {
			break
		}
		p4 = flagPtr + uintptr(i)
		if i != 0 {
			v5 = int32(DONT_QUOTE_HASH)
		} else {
			v5 = 0
		}
		*(*uint8)(unsafe.Pointer(p4)) = uint8(int32(*(*uint8)(unsafe.Pointer(p4))) | v5)
		dst += uintptr(XTclConvertElement(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)), int64(-libc.Int32FromInt32(1)), dst, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(flagPtr + uintptr(i))))))
		*(*uint8)(unsafe.Pointer(dst)) = uint8(' ')
		dst++
		goto _3
	_3:
		;
		i++
	}
	*(*uint8)(unsafe.Pointer(dst + uintptr(-libc.Int32FromInt32(1)))) = uint8(0)
	if flagPtr != bp {
		XTclpFree(tls, flagPtr)
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * TclTrimRight --
 *	Takes two counted strings in the Tcl encoding.  Conceptually
 *	finds the sub string (offset) to trim from the right side of the
 *	first string all characters found in the second string.
 *
 * Results:
 *	The number of bytes to be removed from the end of the string.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclTrimRight(tls *libc.TLS, bytes uintptr, numBytes TTcl_Size, trim uintptr, numTrim TTcl_Size) (r TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* ...and its length in bytes */
	/* Calls to TclUtfToUniChar() in this routine
	 * rely on (trim[numTrim] == '\0'). */
	var bytesLeft, pInc TTcl_Size
	var p, pp, q uintptr
	var v1, v2 int64
	var _ /* ch1 at bp+0 */ int32
	var _ /* ch2 at bp+4 */ int32
	_, _, _, _, _, _, _ = bytesLeft, p, pInc, pp, q, v1, v2
	p = bytes + uintptr(numBytes)
	/* Empty strings -> nothing to do */
	if numBytes == 0 || numTrim == 0 {
		return 0
	}
	/*
	 * Outer loop: iterate over string to be trimmed.
	 */
	for cond := true; cond; cond = p > bytes {
		q = trim
		pInc = 0
		bytesLeft = numTrim
		pp = XTcl_UtfPrev(tls, p, bytes)
		for cond := true; cond; cond = pp+uintptr(pInc) < p {
			pp += uintptr(pInc)
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pp))) < int32(0x80) {
				*(*int32)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pp)))
				v1 = int64(libc.Int32FromInt32(1))
			} else {
				v1 = XTcl_UtfToUniChar(tls, pp, bp)
			}
			pInc = v1
		}
		/*
		 * Inner loop: scan trim string for match to current character.
		 */
		for cond := true; cond; cond = bytesLeft != 0 {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(q))) < int32(0x80) {
				*(*int32)(unsafe.Pointer(bp + 4)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(q)))
				v2 = int64(libc.Int32FromInt32(1))
			} else {
				v2 = XTcl_UtfToUniChar(tls, q, bp+4)
			}
			pInc = v2
			if *(*int32)(unsafe.Pointer(bp)) == *(*int32)(unsafe.Pointer(bp + 4)) {
				break
			}
			q += uintptr(pInc)
			bytesLeft -= pInc
		}
		if bytesLeft == 0 {
			/*
			 * No match; trim task done; *p is last non-trimmed char.
			 */
			break
		}
		p = pp
	}
	return numBytes - (int64(p) - int64(bytes))
}

/*
 *----------------------------------------------------------------------
 *
 * TclTrimLeft --
 *
 *	Takes two counted strings in the Tcl encoding.  Conceptually
 *	finds the sub string (offset) to trim from the left side of the
 *	first string all characters found in the second string.
 *
 * Results:
 *	The number of bytes to be removed from the start of the string.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclTrimLeft(tls *libc.TLS, bytes uintptr, numBytes TTcl_Size, trim uintptr, numTrim TTcl_Size) (r TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* ...and its length in bytes */
	/* Calls to TclUtfToUniChar() in this routine
	 * rely on (trim[numTrim] == '\0'). */
	var bytesLeft, pInc, qInc TTcl_Size
	var p, q uintptr
	var v1, v2 int64
	var _ /* ch1 at bp+0 */ int32
	var _ /* ch2 at bp+4 */ int32
	_, _, _, _, _, _, _ = bytesLeft, p, pInc, q, qInc, v1, v2
	p = bytes
	/* Empty strings -> nothing to do */
	if numBytes == 0 || numTrim == 0 {
		return 0
	}
	/*
	 * Outer loop: iterate over string to be trimmed.
	 */
	for cond := true; cond; cond = numBytes > 0 {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) < int32(0x80) {
			*(*int32)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))
			v1 = int64(libc.Int32FromInt32(1))
		} else {
			v1 = XTcl_UtfToUniChar(tls, p, bp)
		}
		pInc = v1
		q = trim
		bytesLeft = numTrim
		/*
		 * Inner loop: scan trim string for match to current character.
		 */
		for cond := true; cond; cond = bytesLeft != 0 {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(q))) < int32(0x80) {
				*(*int32)(unsafe.Pointer(bp + 4)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(q)))
				v2 = int64(libc.Int32FromInt32(1))
			} else {
				v2 = XTcl_UtfToUniChar(tls, q, bp+4)
			}
			qInc = v2
			if *(*int32)(unsafe.Pointer(bp)) == *(*int32)(unsafe.Pointer(bp + 4)) {
				break
			}
			q += uintptr(qInc)
			bytesLeft -= qInc
		}
		if bytesLeft == 0 {
			/*
			 * No match; trim task done; *p is first non-trimmed char.
			 */
			break
		}
		p += uintptr(pInc)
		numBytes -= pInc
	}
	return int64(p) - int64(bytes)
}

/*
 *----------------------------------------------------------------------
 *
 * TclTrim --
 *	Finds the sub string (offset) to trim from both sides of the
 *	first string all characters found in the second string.
 *
 * Results:
 *	The number of bytes to be removed from the start of the string
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclTrim(tls *libc.TLS, bytes uintptr, numBytes TTcl_Size, trim uintptr, numTrim TTcl_Size, trimRightPtr uintptr) (r TTcl_Size) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Offset from the end of the string. */
	var first uintptr
	var trimLeft, trimRight TTcl_Size
	var v1 int64
	var _ /* ch at bp+0 */ int32
	_, _, _, _ = first, trimLeft, trimRight, v1
	trimLeft = 0
	trimRight = 0
	/* Empty strings -> nothing to do */
	if numBytes > 0 && numTrim > 0 {
		/* When bytes is NUL-terminated, returns 0 <= trimLeft <= numBytes */
		trimLeft = XTclTrimLeft(tls, bytes, numBytes, trim, numTrim)
		numBytes -= trimLeft
		/* If we did not trim the whole string, it starts with a character
		 * that we will not trim. Skip over it. */
		if numBytes > 0 {
			first = bytes + uintptr(trimLeft)
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(first))) < int32(0x80) {
				*(*int32)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(first)))
				v1 = int64(libc.Int32FromInt32(1))
			} else {
				v1 = XTcl_UtfToUniChar(tls, first, bp)
			}
			bytes += uintptr(v1)
			numBytes -= int64(bytes) - int64(first)
			if numBytes > 0 {
				/* When bytes is NUL-terminated, returns
				 * 0 <= trimRight <= numBytes */
				trimRight = XTclTrimRight(tls, bytes, numBytes, trim, numTrim)
			}
		}
	}
	*(*TTcl_Size)(unsafe.Pointer(trimRightPtr)) = trimRight
	return trimLeft
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_Concat --
 *
 *	Concatenate a set of strings into a single large string.
 *
 * Results:
 *	The return value is dynamically-allocated string containing a
 *	concatenation of all the strings in argv, with spaces between the
 *	original argv elements.
 *
 * Side effects:
 *	Memory is allocated for the result; the caller is responsible for
 *	freeing the memory.
 *
 *----------------------------------------------------------------------
 */

/* The whitespace characters trimmed during [concat] operations */

func XTcl_Concat(tls *libc.TLS, argc TTcl_Size, argv uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Array of strings to concatenate. */
	var bytesNeeded, elemLength, i, needSpace, triml TTcl_Size
	var element, p, result, v3 uintptr
	var _ /* trimr at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _ = bytesNeeded, elemLength, element, i, needSpace, p, result, triml, v3
	needSpace = 0
	bytesNeeded = 0
	/*
	 * Dispose of the empty result corner case first to simplify later code.
	 */
	if argc == 0 {
		result = XTcl_Alloc(tls, uint64(1))
		*(*uint8)(unsafe.Pointer(result)) = uint8('\000')
		return result
	}
	/*
	 * First allocate the result buffer at the size required.
	 */
	i = 0
	for {
		if !(i < argc) {
			break
		}
		bytesNeeded = TTcl_Size(uint64(bytesNeeded) + libc.Xstrlen(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8))))
		if bytesNeeded < 0 {
			XTcl_Panic(tls, __ccgo_ts+68458, 0)
		}
		goto _1
	_1:
		;
		i++
	}
	/*
	 * All element bytes + (argc - 1) spaces + 1 terminating NULL.
	 */
	if bytesNeeded+argc-int64(1) < 0 {
		/*
		 * Panic test could be tighter, but not going to bother for this
		 * legacy routine.
		 */
		XTcl_Panic(tls, __ccgo_ts+68458, 0)
	}
	result = XTcl_Alloc(tls, libc.Uint64FromInt64(bytesNeeded+argc))
	p = result
	i = libc.Int64FromInt32(0)
	for {
		if !(i < argc) {
			break
		}
		element = *(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8))
		elemLength = libc.Int64FromUint64(libc.Xstrlen(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8))))
		/* Trim away the leading/trailing whitespace. */
		triml = XTclTrim(tls, element, elemLength, __ccgo_ts+68501, libc.Int64FromUint64(libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1)), bp)
		element += uintptr(triml)
		elemLength -= triml + *(*TTcl_Size)(unsafe.Pointer(bp))
		/* Do not permit trimming to expose a final backslash character. */
		elemLength += libc.BoolInt64(*(*TTcl_Size)(unsafe.Pointer(bp)) != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(element + uintptr(elemLength-int64(1))))) == int32('\\'))
		/*
		 * If we're left with empty element after trimming, do nothing.
		 */
		if elemLength == 0 {
			goto _2
		}
		/*
		 * Append to the result with space if needed.
		 */
		if needSpace != 0 {
			v3 = p
			p++
			*(*uint8)(unsafe.Pointer(v3)) = uint8(' ')
		}
		libc.Xmemcpy(tls, p, element, libc.Uint64FromInt64(elemLength))
		p += uintptr(elemLength)
		needSpace = int64(1)
		goto _2
	_2:
		;
		i++
	}
	*(*uint8)(unsafe.Pointer(p)) = uint8('\000')
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ConcatObj --
 *
 *	Concatenate the strings from a set of objects into a single string
 *	object with spaces between the original strings.
 *
 * Results:
 *	The return value is a new string object containing a concatenation of
 *	the strings in objv. Its ref count is zero.
 *
 * Side effects:
 *	A new object is created.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ConcatObj(tls *libc.TLS, objc TTcl_Size, objv uintptr) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Array of objects to concatenate. */
	var _objPtr, _objPtr1, cachePtr, cachePtr1, element, objPtr1, resPtr, v10, v12, v13, v15, v16, v18, v21, v24, v3, v8 uintptr
	var bytesNeeded, i, triml, v11, v14, v17 TTcl_Size
	var needSpace, v2, v7 int32
	var v19, v22, v4, v9 bool
	var _ /* elemLength at bp+0 */ TTcl_Size
	var _ /* elemPtr at bp+16 */ uintptr
	var _ /* length at bp+8 */ TTcl_Size
	var _ /* trimr at bp+24 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, bytesNeeded, cachePtr, cachePtr1, element, i, needSpace, objPtr1, resPtr, triml, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v21, v22, v24, v3, v4, v7, v8, v9
	needSpace = 0
	bytesNeeded = 0
	/*
	 * Check first to see if all the items are of list type or empty. If so,
	 * we will concat them together as lists, and return a list object. This
	 * is only valid when the lists are in canonical form.
	 */
	i = 0
	for {
		if !(i < objc) {
			break
		}
		objPtr1 = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
		if (*TTcl_Obj)(unsafe.Pointer(objPtr1)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			v2 = libc.BoolInt32((*TTcl_Obj)(unsafe.Pointer(objPtr1)).Fbytes == libc.UintptrFromInt32(0) || (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr1 + 32))).Fptr1)).Fflags&int32(LISTSTORE_CANONICAL) != 0 || (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr1 + 32))).Fptr2 != libc.UintptrFromInt32(0))
		} else {
			v2 = 0
		}
		if v4 = v2 != 0; !v4 {
			if (*TTcl_Obj)(unsafe.Pointer(objPtr1)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+56) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+56) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr1)).FtypePtr)).Fversion) {
				v3 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr1)).FtypePtr)).FindexProc
			} else {
				v3 = libc.UintptrFromInt32(0)
			}
		}
		if v4 || v3 != 0 {
			goto _1
		}
		if (*TTcl_Obj)(unsafe.Pointer(objPtr1)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(objPtr1)).Flength
			_ = (*TTcl_Obj)(unsafe.Pointer(objPtr1)).Fbytes
		} else {
			XTcl_GetStringFromObj(tls, objPtr1, bp+8)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > 0 {
			break
		}
		goto _1
	_1:
		;
		i++
	}
	if i == objc {
		resPtr = libc.UintptrFromInt32(0)
		i = 0
		for {
			if !(i < objc) {
				break
			}
			objPtr1 = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
			if (*TTcl_Obj)(unsafe.Pointer(objPtr1)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				v7 = libc.BoolInt32((*TTcl_Obj)(unsafe.Pointer(objPtr1)).Fbytes == libc.UintptrFromInt32(0) || (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr1 + 32))).Fptr1)).Fflags&int32(LISTSTORE_CANONICAL) != 0 || (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(objPtr1 + 32))).Fptr2 != libc.UintptrFromInt32(0))
			} else {
				v7 = 0
			}
			if v9 = !(v7 != 0); v9 {
				if (*TTcl_Obj)(unsafe.Pointer(objPtr1)).FtypePtr != 0 && (libc.Bool(uint64(libc.UintptrFromInt32(0)+56) < uint64(libc.UintptrFromInt32(0)+40)) || uint64(libc.UintptrFromInt32(0)+56) < (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr1)).FtypePtr)).Fversion) {
					v8 = (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr1)).FtypePtr)).FindexProc
				} else {
					v8 = libc.UintptrFromInt32(0)
				}
			}
			if v9 && !(v8 != 0) {
				goto _6
			}
			if resPtr != 0 {
				*(*uintptr)(unsafe.Pointer(bp + 16)) = libc.UintptrFromInt32(0)
				XTcl_ListObjIndex(tls, libc.UintptrFromInt32(0), objPtr1, 0, bp+16)
				if *(*uintptr)(unsafe.Pointer(bp + 16)) == libc.UintptrFromInt32(0) {
					goto _6
				}
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes != 0 {
					v10 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fbytes
				} else {
					v10 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)), libc.UintptrFromInt32(0))
				}
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) == int32('#') || TCL_OK != XTcl_ListObjAppendList(tls, libc.UintptrFromInt32(0), resPtr, objPtr1) {
					/* Abandon ship! */
					_objPtr1 = resPtr
					v12 = _objPtr1
					v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
					*(*TTcl_Size)(unsafe.Pointer(v12))--
					if v11 <= int64(1) {
						XTclFreeObj(tls, _objPtr1)
					}
					v13 = *(*uintptr)(unsafe.Pointer(bp + 16))
					if v13 != 0 {
						if (*TTcl_Obj)(unsafe.Pointer(v13)).FrefCount == libc.Int64FromInt32(0) {
							_objPtr = v13
							v15 = _objPtr
							v14 = *(*TTcl_Size)(unsafe.Pointer(v15))
							*(*TTcl_Size)(unsafe.Pointer(v15))--
							if v14 <= libc.Int64FromInt32(1) {
								XTclFreeObj(tls, _objPtr)
							}
						}
					} // could be an abstract list element
					goto slow
				}
				v16 = *(*uintptr)(unsafe.Pointer(bp + 16))
				if v16 != 0 {
					if (*TTcl_Obj)(unsafe.Pointer(v16)).FrefCount == libc.Int64FromInt32(0) {
						_objPtr = v16
						v18 = _objPtr
						v17 = *(*TTcl_Size)(unsafe.Pointer(v18))
						*(*TTcl_Size)(unsafe.Pointer(v18))--
						if v17 <= libc.Int64FromInt32(1) {
							XTclFreeObj(tls, _objPtr)
						}
					}
				} // could be an an abstract list element
			} else {
				resPtr = XTclListObjCopy(tls, libc.UintptrFromInt32(0), objPtr1)
			}
			goto _6
		_6:
			;
			i++
		}
		if !(resPtr != 0) {
			if v19 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v19 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v19 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				resPtr = XTclThreadAllocObj(tls)
			} else {
				resPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(resPtr + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(resPtr)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(resPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(resPtr)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(resPtr)).FtypePtr = libc.UintptrFromInt32(0)
		}
		return resPtr
	}
	goto slow
slow:
	;
	/*
	 * Something cannot be determined to be safe, so build the concatenation
	 * the slow way, using the string representations.
	 *
	 * First try to preallocate the size required.
	 */
	i = 0
	for {
		if !(i < objc) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Flength
			v21 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
		} else {
			v21 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp)
		}
		element = v21
		if bytesNeeded > libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))-*(*TTcl_Size)(unsafe.Pointer(bp)) {
			break /* Overflow. Do not preallocate. See comment below. */
		}
		bytesNeeded += *(*TTcl_Size)(unsafe.Pointer(bp))
		goto _20
	_20:
		;
		i++
	}
	/*
	 * Does not matter if this fails, will simply try later to build up the
	 * string with each Append reallocating as needed with the usual string
	 * append algorithm.  When that fails it will report the error.
	 */
	if v22 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v22 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v22 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		resPtr = XTclThreadAllocObj(tls)
	} else {
		resPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resPtr)).FtypePtr = libc.UintptrFromInt32(0)
	XTcl_AttemptSetObjLength(tls, resPtr, bytesNeeded+objc-int64(1))
	XTcl_SetObjLength(tls, resPtr, 0)
	i = 0
	for {
		if !(i < objc) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Flength
			v24 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
		} else {
			v24 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp)
		}
		element = v24
		/* Trim away the leading/trailing whitespace. */
		triml = XTclTrim(tls, element, *(*TTcl_Size)(unsafe.Pointer(bp)), __ccgo_ts+68501, libc.Int64FromUint64(libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1)), bp+24)
		element += uintptr(triml)
		*(*TTcl_Size)(unsafe.Pointer(bp)) -= triml + *(*TTcl_Size)(unsafe.Pointer(bp + 24))
		/* Do not permit trimming to expose a final backslash character. */
		*(*TTcl_Size)(unsafe.Pointer(bp)) += libc.BoolInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 24)) != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(element + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp))-int64(1))))) == int32('\\'))
		/*
		 * If we're left with empty element after trimming, do nothing.
		 */
		if *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
			goto _23
		}
		/*
		 * Append to the result with space if needed.
		 */
		if needSpace != 0 {
			XTcl_AppendToObj(tls, resPtr, __ccgo_ts+14830, int64(1))
		}
		XTcl_AppendToObj(tls, resPtr, element, *(*TTcl_Size)(unsafe.Pointer(bp)))
		needSpace = int32(1)
		goto _23
	_23:
		;
		i++
	}
	return resPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_StringCaseMatch --
 *
 *	See if a particular string matches a particular pattern. Allows case
 *	insensitivity.
 *
 * Results:
 *	The return value is 1 if string matches pattern, and 0 otherwise. The
 *	matching operation permits the following special characters in the
 *	pattern: *?\[] (see the manual entry for details on what these mean).
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_StringCaseMatch(tls *libc.TLS, str uintptr, pattern uintptr, nocase int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* 0 for case sensitive, 1 for insensitive */
	var charLen, p, v10, v12, v2, v8 int32
	var v1 uintptr
	var v11, v13, v14, v15, v4, v5, v6, v7, v9 int64
	var _ /* ch1 at bp+0 */ int32
	var _ /* ch2 at bp+4 */ int32
	var _ /* endChar at bp+12 */ int32
	var _ /* startChar at bp+8 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = charLen, p, v1, v10, v11, v12, v13, v14, v15, v2, v4, v5, v6, v7, v8, v9
	*(*int32)(unsafe.Pointer(bp)) = 0
	*(*int32)(unsafe.Pointer(bp + 4)) = 0
	for int32(1) != 0 {
		p = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern)))
		/*
		 * See if we're at the end of both the pattern and the string. If so,
		 * we succeeded. If we're at the end of the pattern but not at the end
		 * of the string, we failed.
		 */
		if p == int32('\000') {
			return libc.BoolInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) == int32('\000'))
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) == int32('\000') && p != int32('*') {
			return 0
		}
		/*
		 * Check for a "*" as the next pattern character. It matches any
		 * substring. We handle this by calling ourselves recursively for each
		 * postfix of string, until either we match or we reach the end of the
		 * string.
		 */
		if p == int32('*') {
			/*
			 * Skip all successive *'s in the pattern
			 */
			for {
				pattern++
				v1 = pattern
				if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) == int32('*')) {
					break
				}
			}
			p = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern)))
			if p == int32('\000') {
				return int32(1)
			}
			/*
			 * This is a special case optimization for single-byte utf.
			 */
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) < int32(0x80) {
				if nocase != 0 {
					v2 = libc.Xtolower(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))))
				} else {
					v2 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern)))
				}
				*(*int32)(unsafe.Pointer(bp + 4)) = v2
			} else {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) < int32(0x80) {
					*(*int32)(unsafe.Pointer(bp + 4)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern)))
					_ = libc.Int32FromInt32(1)
				} else {
					XTcl_UtfToUniChar(tls, pattern, bp+4)
				}
				if nocase != 0 {
					*(*int32)(unsafe.Pointer(bp + 4)) = XTcl_UniCharToLower(tls, *(*int32)(unsafe.Pointer(bp + 4)))
				}
			}
			for int32(1) != 0 {
				/*
				 * Optimization for matching - cruise through the string
				 * quickly if the next char in the pattern isn't a special
				 * character
				 */
				if p != int32('[') && p != int32('?') && p != int32('\\') {
					if nocase != 0 {
						for *(*uint8)(unsafe.Pointer(str)) != 0 {
							if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) < int32(0x80) {
								*(*int32)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str)))
								v4 = int64(libc.Int32FromInt32(1))
							} else {
								v4 = XTcl_UtfToUniChar(tls, str, bp)
							}
							charLen = int32(v4)
							if *(*int32)(unsafe.Pointer(bp + 4)) == *(*int32)(unsafe.Pointer(bp)) || *(*int32)(unsafe.Pointer(bp + 4)) == XTcl_UniCharToLower(tls, *(*int32)(unsafe.Pointer(bp))) {
								break
							}
							str += uintptr(charLen)
						}
					} else {
						/*
						 * There's no point in trying to make this code
						 * shorter, as the number of bytes you want to compare
						 * each time is non-constant.
						 */
						for *(*uint8)(unsafe.Pointer(str)) != 0 {
							if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) < int32(0x80) {
								*(*int32)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str)))
								v5 = int64(libc.Int32FromInt32(1))
							} else {
								v5 = XTcl_UtfToUniChar(tls, str, bp)
							}
							charLen = int32(v5)
							if *(*int32)(unsafe.Pointer(bp + 4)) == *(*int32)(unsafe.Pointer(bp)) {
								break
							}
							str += uintptr(charLen)
						}
					}
				}
				if XTcl_StringCaseMatch(tls, str, pattern, nocase) != 0 {
					return int32(1)
				}
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) == int32('\000') {
					return 0
				}
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) < int32(0x80) {
					*(*int32)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str)))
					v6 = int64(libc.Int32FromInt32(1))
				} else {
					v6 = XTcl_UtfToUniChar(tls, str, bp)
				}
				str += uintptr(v6)
			}
		}
		/*
		 * Check for a "?" as the next pattern character. It matches any
		 * single character.
		 */
		if p == int32('?') {
			pattern++
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) < int32(0x80) {
				*(*int32)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str)))
				v7 = int64(libc.Int32FromInt32(1))
			} else {
				v7 = XTcl_UtfToUniChar(tls, str, bp)
			}
			str += uintptr(v7)
			continue
		}
		/*
		 * Check for a "[" as the next pattern character. It is followed by a
		 * list of characters that are acceptable, or by a range (two
		 * characters separated by "-").
		 */
		if p == int32('[') {
			*(*int32)(unsafe.Pointer(bp + 8)) = 0
			*(*int32)(unsafe.Pointer(bp + 12)) = 0
			pattern++
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) < int32(0x80) {
				if nocase != 0 {
					v8 = libc.Xtolower(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))))
				} else {
					v8 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str)))
				}
				*(*int32)(unsafe.Pointer(bp)) = v8
				str++
			} else {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) < int32(0x80) {
					*(*int32)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str)))
					v9 = int64(libc.Int32FromInt32(1))
				} else {
					v9 = XTcl_UtfToUniChar(tls, str, bp)
				}
				str += uintptr(v9)
				if nocase != 0 {
					*(*int32)(unsafe.Pointer(bp)) = XTcl_UniCharToLower(tls, *(*int32)(unsafe.Pointer(bp)))
				}
			}
			for int32(1) != 0 {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) == int32(']') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) == int32('\000') {
					return 0
				}
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) < int32(0x80) {
					if nocase != 0 {
						v10 = libc.Xtolower(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))))
					} else {
						v10 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern)))
					}
					*(*int32)(unsafe.Pointer(bp + 8)) = v10
					pattern++
				} else {
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) < int32(0x80) {
						*(*int32)(unsafe.Pointer(bp + 8)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern)))
						v11 = int64(libc.Int32FromInt32(1))
					} else {
						v11 = XTcl_UtfToUniChar(tls, pattern, bp+8)
					}
					pattern += uintptr(v11)
					if nocase != 0 {
						*(*int32)(unsafe.Pointer(bp + 8)) = XTcl_UniCharToLower(tls, *(*int32)(unsafe.Pointer(bp + 8)))
					}
				}
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) == int32('-') {
					pattern++
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) == int32('\000') {
						return 0
					}
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) < int32(0x80) {
						if nocase != 0 {
							v12 = libc.Xtolower(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))))
						} else {
							v12 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern)))
						}
						*(*int32)(unsafe.Pointer(bp + 12)) = v12
						pattern++
					} else {
						if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) < int32(0x80) {
							*(*int32)(unsafe.Pointer(bp + 12)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern)))
							v13 = int64(libc.Int32FromInt32(1))
						} else {
							v13 = XTcl_UtfToUniChar(tls, pattern, bp+12)
						}
						pattern += uintptr(v13)
						if nocase != 0 {
							*(*int32)(unsafe.Pointer(bp + 12)) = XTcl_UniCharToLower(tls, *(*int32)(unsafe.Pointer(bp + 12)))
						}
					}
					if *(*int32)(unsafe.Pointer(bp + 8)) <= *(*int32)(unsafe.Pointer(bp)) && *(*int32)(unsafe.Pointer(bp)) <= *(*int32)(unsafe.Pointer(bp + 12)) || *(*int32)(unsafe.Pointer(bp + 12)) <= *(*int32)(unsafe.Pointer(bp)) && *(*int32)(unsafe.Pointer(bp)) <= *(*int32)(unsafe.Pointer(bp + 8)) {
						/*
						 * Matches ranges of form [a-z] or [z-a].
						 */
						break
					}
				} else {
					if *(*int32)(unsafe.Pointer(bp + 8)) == *(*int32)(unsafe.Pointer(bp)) {
						break
					}
				}
			}
			/* If we reach here, we matched. Need to move past closing ] */
			for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) != int32(']') {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) == int32('\000') {
					/* We ran out of pattern after matching something in
					 * (unclosed!) brackets. So long as we ran out of string
					 * at the same time, we have a match. Otherwise, not. */
					return libc.BoolInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) == int32('\000'))
				}
				pattern++
			}
			pattern++
			continue
		}
		/*
		 * If the next pattern character is '\', just strip off the '\' so we
		 * do exact matching on the character that follows.
		 */
		if p == int32('\\') {
			pattern++
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) == int32('\000') {
				return 0
			}
		}
		/*
		 * There's no special character. Just make sure that the next bytes of
		 * each string match.
		 */
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) < int32(0x80) {
			*(*int32)(unsafe.Pointer(bp)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str)))
			v14 = int64(libc.Int32FromInt32(1))
		} else {
			v14 = XTcl_UtfToUniChar(tls, str, bp)
		}
		str += uintptr(v14)
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) < int32(0x80) {
			*(*int32)(unsafe.Pointer(bp + 4)) = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern)))
			v15 = int64(libc.Int32FromInt32(1))
		} else {
			v15 = XTcl_UtfToUniChar(tls, pattern, bp+4)
		}
		pattern += uintptr(v15)
		if nocase != 0 {
			if XTcl_UniCharToLower(tls, *(*int32)(unsafe.Pointer(bp))) != XTcl_UniCharToLower(tls, *(*int32)(unsafe.Pointer(bp + 4))) {
				return 0
			}
		} else {
			if *(*int32)(unsafe.Pointer(bp)) != *(*int32)(unsafe.Pointer(bp + 4)) {
				return 0
			}
		}
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * TclByteArrayMatch --
 *
 *	See if a particular string matches a particular pattern.  Does not
 *	allow for case insensitivity.
 *	Parallels tclUtf.c:TclUniCharMatch, adjusted for char* and sans nocase.
 *
 * Results:
 *	The return value is 1 if string matches pattern, and 0 otherwise. The
 *	matching operation permits the following special characters in the
 *	pattern: *?\[] (see the manual entry for details on what these mean).
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclByteArrayMatch(tls *libc.TLS, string1 uintptr, strLen TTcl_Size, pattern uintptr, ptnLen TTcl_Size, dummy2360 int32) (r int32) {
	var ch1, endChar, p, startChar uint8
	var patternEnd, stringEnd, v1, v2 uintptr
	_, _, _, _, _, _, _, _ = ch1, endChar, p, patternEnd, startChar, stringEnd, v1, v2
	stringEnd = string1 + uintptr(strLen)
	patternEnd = pattern + uintptr(ptnLen)
	for int32(1) != 0 {
		/*
		 * See if we're at the end of both the pattern and the string. If so,
		 * we succeeded. If we're at the end of the pattern but not at the end
		 * of the string, we failed.
		 */
		if pattern == patternEnd {
			return libc.BoolInt32(string1 == stringEnd)
		}
		p = *(*uint8)(unsafe.Pointer(pattern))
		if string1 == stringEnd && libc.Int32FromUint8(p) != int32('*') {
			return 0
		}
		/*
		 * Check for a "*" as the next pattern character. It matches any
		 * substring. We handle this by skipping all the characters up to the
		 * next matching one in the pattern, and then calling ourselves
		 * recursively for each postfix of string, until either we match or we
		 * reach the end of the string.
		 */
		if libc.Int32FromUint8(p) == int32('*') {
			/*
			 * Skip all successive *'s in the pattern.
			 */
			for {
				pattern++
				v1 = pattern
				if !(v1 < patternEnd && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) == int32('*')) {
					break
				}
				/* empty body */
			}
			if pattern == patternEnd {
				return int32(1)
			}
			p = *(*uint8)(unsafe.Pointer(pattern))
			for int32(1) != 0 {
				/*
				 * Optimization for matching - cruise through the string
				 * quickly if the next char in the pattern isn't a special
				 * character.
				 */
				if libc.Int32FromUint8(p) != int32('[') && libc.Int32FromUint8(p) != int32('?') && libc.Int32FromUint8(p) != int32('\\') {
					for string1 < stringEnd && libc.Int32FromUint8(p) != libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1))) {
						string1++
					}
				}
				if XTclByteArrayMatch(tls, string1, int64(stringEnd)-int64(string1), pattern, int64(patternEnd)-int64(pattern), 0) != 0 {
					return int32(1)
				}
				if string1 == stringEnd {
					return 0
				}
				string1++
			}
		}
		/*
		 * Check for a "?" as the next pattern character. It matches any
		 * single character.
		 */
		if libc.Int32FromUint8(p) == int32('?') {
			pattern++
			string1++
			continue
		}
		/*
		 * Check for a "[" as the next pattern character. It is followed by a
		 * list of characters that are acceptable, or by a range (two
		 * characters separated by "-").
		 */
		if libc.Int32FromUint8(p) == int32('[') {
			pattern++
			ch1 = *(*uint8)(unsafe.Pointer(string1))
			string1++
			for int32(1) != 0 {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) == int32(']') || pattern == patternEnd {
					return 0
				}
				startChar = *(*uint8)(unsafe.Pointer(pattern))
				pattern++
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) == int32('-') {
					pattern++
					if pattern == patternEnd {
						return 0
					}
					endChar = *(*uint8)(unsafe.Pointer(pattern))
					pattern++
					if libc.Int32FromUint8(startChar) <= libc.Int32FromUint8(ch1) && libc.Int32FromUint8(ch1) <= libc.Int32FromUint8(endChar) || libc.Int32FromUint8(endChar) <= libc.Int32FromUint8(ch1) && libc.Int32FromUint8(ch1) <= libc.Int32FromUint8(startChar) {
						/*
						 * Matches ranges of form [a-z] or [z-a].
						 */
						break
					}
				} else {
					if libc.Int32FromUint8(startChar) == libc.Int32FromUint8(ch1) {
						break
					}
				}
			}
			for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) != int32(']') {
				if pattern == patternEnd {
					pattern--
					break
				}
				pattern++
			}
			pattern++
			continue
		}
		/*
		 * If the next pattern character is '\', just strip off the '\' so we
		 * do exact matching on the character that follows.
		 */
		if libc.Int32FromUint8(p) == int32('\\') {
			pattern++
			v2 = pattern
			if v2 == patternEnd {
				return 0
			}
		}
		/*
		 * There's no special character. Just make sure that the next bytes of
		 * each string match.
		 */
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1))) != libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) {
			return 0
		}
		string1++
		pattern++
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * TclStringMatchObj --
 *
 *	See if a particular string matches a particular pattern. Allows case
 *	insensitivity. This is the generic multi-type handler for the various
 *	matching algorithms.
 *
 * Results:
 *	The return value is 1 if string matches pattern, and 0 otherwise. The
 *	matching operation permits the following special characters in the
 *	pattern: *?\[] (see the manual entry for details on what these mean).
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclStringMatchObj(tls *libc.TLS, strObj uintptr, ptnObj uintptr, flags int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Only TCL_MATCH_NOCASE should be passed, or
	 * 0. */
	var data, ptn, udata, uptn, v1, v2 uintptr
	var match int32
	var _ /* length at bp+0 */ TTcl_Size
	var _ /* plen at bp+8 */ TTcl_Size
	_, _, _, _, _, _, _ = data, match, ptn, udata, uptn, v1, v2
	*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0
	/*
	    * Promote based on the type of incoming object.
	    * XXX: Currently doesn't take advantage of exact-ness that
	    * XXX: TclReToGlob tells us about
	   trivial = nocase ? 0 : TclMatchIsTrivial(TclGetString(ptnObj));
	*/
	if (*TTcl_Obj)(unsafe.Pointer(strObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclStringType)) || (*TTcl_Obj)(unsafe.Pointer(strObj)).FtypePtr == libc.UintptrFromInt32(0) {
		udata = XTcl_GetUnicodeFromObj(tls, strObj, bp)
		uptn = XTcl_GetUnicodeFromObj(tls, ptnObj, bp+8)
		match = XTclUniCharMatch(tls, udata, *(*TTcl_Size)(unsafe.Pointer(bp)), uptn, *(*TTcl_Size)(unsafe.Pointer(bp + 8)), flags)
	} else {
		if XTclIsPureByteArray(tls, strObj) != 0 && XTclIsPureByteArray(tls, ptnObj) != 0 && !(flags != 0) {
			data = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), strObj, bp)
			ptn = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), ptnObj, bp+8)
			match = XTclByteArrayMatch(tls, data, *(*TTcl_Size)(unsafe.Pointer(bp)), ptn, *(*TTcl_Size)(unsafe.Pointer(bp + 8)), 0)
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(strObj)).Fbytes != 0 {
				v1 = (*TTcl_Obj)(unsafe.Pointer(strObj)).Fbytes
			} else {
				v1 = XTcl_GetStringFromObj(tls, strObj, libc.UintptrFromInt32(0))
			}
			if (*TTcl_Obj)(unsafe.Pointer(ptnObj)).Fbytes != 0 {
				v2 = (*TTcl_Obj)(unsafe.Pointer(ptnObj)).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, ptnObj, libc.UintptrFromInt32(0))
			}
			match = XTcl_StringCaseMatch(tls, v1, v2, flags)
		}
	}
	return match
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DStringInit --
 *
 *	Initializes a dynamic string, discarding any previous contents of the
 *	string (Tcl_DStringFree should have been called already if the dynamic
 *	string was previously in use).
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The dynamic string is initialized to be empty.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DStringInit(tls *libc.TLS, dsPtr uintptr) {
	/* Pointer to structure for dynamic string. */
	(*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1 = dsPtr + 24
	(*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength = 0
	(*TTcl_DString)(unsafe.Pointer(dsPtr)).FspaceAvl = int64(TCL_DSTRING_STATIC_SIZE)
	*(*uint8)(unsafe.Pointer(dsPtr + 24)) = uint8('\000')
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DStringAppend --
 *
 *	Append more bytes to the current value of a dynamic string.
 *
 * Results:
 *	The return value is a pointer to the dynamic string's new value.
 *
 * Side effects:
 *	Length bytes from "bytes" (or all of "bytes" if length is less than
 *	zero) are added to the current value of the string. Memory gets
 *	reallocated if needed to accomodate the string's new size.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DStringAppend(tls *libc.TLS, dsPtr uintptr, bytes uintptr, length TTcl_Size) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Number of bytes from "bytes" to append. If
	 * TCL_INDEX_NONE, then append all of bytes, up
	 * to null at end. */
	var newSize, offset TTcl_Size
	var newString, v1, v3 uintptr
	_, _, _, _, _ = newSize, newString, offset, v1, v3
	if length < 0 {
		length = libc.Int64FromUint64(libc.Xstrlen(tls, bytes))
	}
	if length > libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))-(*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength-int64(1) {
		XTcl_Panic(tls, __ccgo_ts+66398, libc.VaList(bp+8, libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))))
		return libc.UintptrFromInt32(0) /* NOTREACHED */
	}
	newSize = length + (*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength + int64(1)
	if newSize > (*TTcl_DString)(unsafe.Pointer(dsPtr)).FspaceAvl {
		if (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1 == dsPtr+24 {
			v1 = XTclAllocElemsEx(tls, newSize, int64(1), 0, dsPtr+16)
			goto _2
		_2:
			newString = v1
			libc.Xmemcpy(tls, newString, (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1, libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength))
			(*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1 = newString
		} else {
			offset = int64(-int32(1))
			/* See [16896d49fd] */
			if bytes >= (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1 && bytes <= (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1+uintptr((*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength) {
				/* Source string is within this DString. Note offset */
				offset = int64(bytes) - int64((*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1)
			}
			v3 = XTclReallocElemsEx(tls, (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1, newSize, int64(1), 0, dsPtr+16)
			goto _4
		_4:
			(*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1 = v3
			if offset >= 0 {
				bytes = (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1 + uintptr(offset)
			}
		}
	}
	/*
	 * Copy the new string into the buffer at the end of the old one.
	 */
	libc.Xmemcpy(tls, (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1+uintptr((*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength), bytes, libc.Uint64FromInt64(length))
	*(*TTcl_Size)(unsafe.Pointer(dsPtr + 8)) += length
	*(*uint8)(unsafe.Pointer((*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1 + uintptr((*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength))) = uint8('\000')
	return (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1
}

/*
 *----------------------------------------------------------------------
 *
 * TclDStringAppendObj, TclDStringAppendDString --
 *
 *	Simple wrappers round Tcl_DStringAppend that make it easier to append
 *	from particular sources of strings.
 *
 *----------------------------------------------------------------------
 */

func XTclDStringAppendObj(tls *libc.TLS, dsPtr uintptr, objPtr uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var bytes, v1 uintptr
	var _ /* length at bp+0 */ TTcl_Size
	_, _ = bytes, v1
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, objPtr, bp)
	}
	bytes = v1
	return XTcl_DStringAppend(tls, dsPtr, bytes, *(*TTcl_Size)(unsafe.Pointer(bp)))
}

func XTclDStringAppendDString(tls *libc.TLS, dsPtr uintptr, toAppendPtr uintptr) (r uintptr) {
	return XTcl_DStringAppend(tls, dsPtr, (*TTcl_DString)(unsafe.Pointer(toAppendPtr)).Fstring1, (*TTcl_DString)(unsafe.Pointer(toAppendPtr)).Flength)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DStringAppendElement --
 *
 *	Append a list element to the current value of a dynamic string.
 *
 * Results:
 *	The return value is a pointer to the dynamic string's new value.
 *
 * Side effects:
 *	String is reformatted as a list element and added to the current value
 *	of the string. Memory gets reallocated if needed to accomodate the
 *	string's new size.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DStringAppendElement(tls *libc.TLS, dsPtr uintptr, element uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* String to append. Must be
	 * null-terminated. */
	var dst, newString, v1, v4, v6 uintptr
	var needSpace, offset, quoteHash, v2 int32
	var newSize TTcl_Size
	var v3 bool
	var _ /* flags at bp+0 */ uint8
	_, _, _, _, _, _, _, _, _, _, _ = dst, needSpace, newSize, newString, offset, quoteHash, v1, v2, v3, v4, v6
	dst = (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1 + uintptr((*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength)
	needSpace = XTclNeedSpace(tls, (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1, dst)
	*(*uint8)(unsafe.Pointer(bp)) = uint8(0)
	quoteHash = int32(1)
	if needSpace != 0 {
		/*
		 * If we need a space to separate the new element from something
		 * already ending the string, we're not appending the first element
		 * of any list, so we need not quote any leading hash character.
		 */
		quoteHash = 0
	} else {
		/*
		 * We don't need a space, maybe because there's some already there.
		 * Checking whether we might be appending a first element is a bit
		 * more involved.
		 *
		 * Backtrack over all whitespace.
		 */
		for {
			dst--
			v1 = dst
			if v3 = v1 >= (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1; v3 {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dst))) > int32(0x20) {
					v2 = 0
				} else {
					v2 = XTclIsSpaceProc(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dst))))
				}
			}
			if !(v3 && v2 != 0) {
				break
			}
		}
		/* Call again without whitespace to confound things. */
		quoteHash = libc.BoolInt32(!(XTclNeedSpace(tls, (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1, dst+uintptr(1)) != 0))
	}
	if !(quoteHash != 0) {
		*(*uint8)(unsafe.Pointer(bp)) = uint8(int32(*(*uint8)(unsafe.Pointer(bp))) | int32(DONT_QUOTE_HASH))
	}
	newSize = (*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength + int64(needSpace) + XTclScanElement(tls, element, int64(-libc.Int32FromInt32(1)), bp)
	if !(quoteHash != 0) {
		*(*uint8)(unsafe.Pointer(bp)) = uint8(int32(*(*uint8)(unsafe.Pointer(bp))) | int32(DONT_QUOTE_HASH))
	}
	/*
	 * Allocate a larger buffer for the string if the current one isn't large
	 * enough. Allocate extra space in the new buffer so that there will be
	 * room to grow before we have to allocate again. SPECIAL NOTE: must use
	 * memcpy, not strcpy, to copy the string to a larger buffer, since there
	 * may be embedded NULLs in the string in some cases.
	 */
	newSize += int64(1) /* For terminating nul */
	if newSize > (*TTcl_DString)(unsafe.Pointer(dsPtr)).FspaceAvl {
		if (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1 == dsPtr+24 {
			v4 = XTclAllocElemsEx(tls, newSize, int64(1), 0, dsPtr+16)
			goto _5
		_5:
			newString = v4
			libc.Xmemcpy(tls, newString, (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1, libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength))
			(*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1 = newString
		} else {
			offset = -int32(1)
			/* See [16896d49fd] */
			if element >= (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1 && element <= (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1+uintptr((*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength) {
				/* Source string is within this DString. Note offset */
				offset = int32(int64(element) - int64((*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1))
			}
			v6 = XTclReallocElemsEx(tls, (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1, newSize, int64(1), 0, dsPtr+16)
			goto _7
		_7:
			(*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1 = v6
			if offset >= 0 {
				element = (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1 + uintptr(offset)
			}
		}
	}
	dst = (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1 + uintptr((*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength)
	/*
	 * Convert the new string to a list element and copy it into the buffer at
	 * the end, with a space, if needed.
	 */
	if needSpace != 0 {
		*(*uint8)(unsafe.Pointer(dst)) = uint8(' ')
		dst++
		(*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength++
	}
	*(*TTcl_Size)(unsafe.Pointer(dsPtr + 8)) += XTclConvertElement(tls, element, int64(-libc.Int32FromInt32(1)), dst, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))))
	*(*uint8)(unsafe.Pointer((*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1 + uintptr((*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength))) = uint8('\000')
	return (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DStringSetLength --
 *
 *	Change the length of a dynamic string. This can cause the string to
 *	either grow or shrink, depending on the value of length.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The length of dsPtr is changed to length and a null byte is stored at
 *	that position in the string.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DStringSetLength(tls *libc.TLS, dsPtr uintptr, length TTcl_Size) {
	/* New length for dynamic string. */
	var newString uintptr
	var newsize, v1, v2, v3 TTcl_Size
	_, _, _, _, _ = newString, newsize, v1, v2, v3
	if length < 0 {
		length = 0
	}
	if length >= (*TTcl_DString)(unsafe.Pointer(dsPtr)).FspaceAvl {
		/*
		 * There are two interesting cases here. In the first case, the user
		 * may be trying to allocate a large buffer of a specific size. It
		 * would be wasteful to overallocate that buffer, so we just allocate
		 * enough for the requested size plus the trailing null byte. In the
		 * second case, we are growing the buffer incrementally, so we need
		 * behavior similar to Tcl_DStringAppend.
		 * TODO - the above makes no sense to me. How does the code below
		 * translate into distinguishing the two cases above? IMO, if caller
		 * specifically sets the length, there is no cause for overallocation.
		 */
		if length >= libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)) {
			XTcl_Panic(tls, __ccgo_ts+68458, 0)
		}
		_ = (*TTcl_DString)(unsafe.Pointer(dsPtr)).FspaceAvl
		v1 = length + int64(1)
		v2 = libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
		if v1 < v2-v1/libc.Int64FromInt32(2) {
			v3 = v1 + v1/int64(2)
			goto _4
		} else {
			v3 = v2
			goto _4
		}
	_4:
		newsize = v3
		if length < newsize {
			(*TTcl_DString)(unsafe.Pointer(dsPtr)).FspaceAvl = newsize
		} else {
			(*TTcl_DString)(unsafe.Pointer(dsPtr)).FspaceAvl = length + int64(1)
		}
		if (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1 == dsPtr+24 {
			newString = XTcl_Alloc(tls, libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(dsPtr)).FspaceAvl))
			libc.Xmemcpy(tls, newString, (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1, libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength))
			(*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1 = newString
		} else {
			(*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1 = XTcl_Realloc(tls, (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1, libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(dsPtr)).FspaceAvl))
		}
	}
	(*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength = length
	*(*uint8)(unsafe.Pointer((*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1 + uintptr(length))) = uint8(0)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DStringFree --
 *
 *	Frees up any memory allocated for the dynamic string and reinitializes
 *	the string to an empty state.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The previous contents of the dynamic string are lost, and the new
 *	value is an empty string.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DStringFree(tls *libc.TLS, dsPtr uintptr) {
	/* Structure describing dynamic string. */
	if (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1 != dsPtr+24 {
		XTclpFree(tls, (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1)
	}
	(*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1 = dsPtr + 24
	(*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength = 0
	(*TTcl_DString)(unsafe.Pointer(dsPtr)).FspaceAvl = int64(TCL_DSTRING_STATIC_SIZE)
	*(*uint8)(unsafe.Pointer(dsPtr + 24)) = uint8('\000')
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DStringResult --
 *
 *	This function moves the value of a dynamic string into an interpreter
 *	as its string result. Afterwards, the dynamic string is reset to an
 *	empty string.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The string is "moved" to interp's result, and any existing string
 *	result for interp is freed. dsPtr is reinitialized to an empty string.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DStringResult(tls *libc.TLS, interp uintptr, dsPtr uintptr) {
	/* Dynamic string that is to become the
	 * result of interp. */
	XTcl_SetObjResult(tls, interp, XTcl_DStringToObj(tls, dsPtr))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DStringGetResult --
 *
 *	This function moves an interpreter's result into a dynamic string.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The interpreter's string result is cleared, and the previous contents
 *	of dsPtr are freed.
 *
 *	If the string result is empty, the object result is moved to the
 *	string result, then the object result is reset.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DStringGetResult(tls *libc.TLS, interp uintptr, dsPtr uintptr) {
	/* Dynamic string that is to become the result
	 * of interp. */
	var bytes, obj, v1 uintptr
	_, _, _ = bytes, obj, v1
	obj = XTcl_GetObjResult(tls, interp)
	if (*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, obj, libc.UintptrFromInt32(0))
	}
	bytes = v1
	XTcl_DStringFree(tls, dsPtr)
	XTcl_DStringAppend(tls, dsPtr, bytes, (*TTcl_Obj)(unsafe.Pointer(obj)).Flength)
	XTcl_ResetResult(tls, interp)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DStringToObj --
 *
 *	This function moves a dynamic string's contents to a new Tcl_Obj. Be
 *	aware that this function does *not* check that the encoding of the
 *	contents of the dynamic string is correct; this is the caller's
 *	responsibility to enforce.
 *
 * Results:
 *	The newly-allocated untyped (i.e., typePtr==NULL) Tcl_Obj with a
 *	reference count of zero.
 *
 * Side effects:
 *	The string is "moved" to the object. dsPtr is reinitialized to an
 *	empty string; it does not need to be Tcl_DStringFree'd after this if
 *	not used further.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DStringToObj(tls *libc.TLS, dsPtr uintptr) (r uintptr) {
	var cachePtr, cachePtr1, cachePtr2, result, v3 uintptr
	var v1, v2, v4 bool
	_, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, result, v1, v2, v3, v4
	if (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1 == dsPtr+24 {
		if (*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength == 0 {
			if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				result = XTclThreadAllocObj(tls)
			} else {
				result = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(result + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(result)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(result)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(result)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(result)).FtypePtr = libc.UintptrFromInt32(0)
		} else {
			/*
			 * Static buffer, so must copy.
			 */
			if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
				result = XTclThreadAllocObj(tls)
			} else {
				result = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(result + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(result)).FrefCount = 0
			if (*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength == 0 {
				(*TTcl_Obj)(unsafe.Pointer(result)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(result)).Flength = int64(libc.Int32FromInt32(0))
			} else {
				(*TTcl_Obj)(unsafe.Pointer(result)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength+libc.Int64FromUint32(1)))
				if (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1 != 0 {
					v3 = (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1
				} else {
					v3 = uintptr(unsafe.Pointer(&XtclEmptyString))
				}
				libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(result)).Fbytes, v3, libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength))
				*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(result)).Fbytes + uintptr((*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength))) = uint8('\000')
				(*TTcl_Obj)(unsafe.Pointer(result)).Flength = (*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength
			}
			(*TTcl_Obj)(unsafe.Pointer(result)).FtypePtr = libc.UintptrFromInt32(0)
		}
	} else {
		/*
		 * Dynamic buffer, so transfer ownership and reset.
		 */
		if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
			cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
			result = XTclThreadAllocObj(tls)
		} else {
			result = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(result + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(result)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(result)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(result)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(result)).FtypePtr = libc.UintptrFromInt32(0)
		(*TTcl_Obj)(unsafe.Pointer(result)).Fbytes = (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1
		(*TTcl_Obj)(unsafe.Pointer(result)).Flength = (*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength
	}
	/*
	 * Re-establish the DString as empty with no buffer allocated.
	 */
	(*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1 = dsPtr + 24
	(*TTcl_DString)(unsafe.Pointer(dsPtr)).FspaceAvl = int64(TCL_DSTRING_STATIC_SIZE)
	(*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength = 0
	*(*uint8)(unsafe.Pointer(dsPtr + 24)) = uint8('\000')
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DStringStartSublist --
 *
 *	This function adds the necessary information to a dynamic string
 *	(e.g. " {") to start a sublist. Future element appends will be in the
 *	sublist rather than the main list.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Characters get added to the dynamic string.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DStringStartSublist(tls *libc.TLS, dsPtr uintptr) {
	/* Dynamic string. */
	if XTclNeedSpace(tls, (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1, (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1+uintptr((*TTcl_DString)(unsafe.Pointer(dsPtr)).Flength)) != 0 {
		XTcl_DStringAppend(tls, dsPtr, __ccgo_ts+68508, libc.Int64FromUint64(libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)))
	} else {
		XTcl_DStringAppend(tls, dsPtr, __ccgo_ts+68511, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_DStringEndSublist --
 *
 *	This function adds the necessary characters to a dynamic string to end
 *	a sublist (e.g. "}"). Future element appends will be in the enclosing
 *	(sub)list rather than the current sublist.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_DStringEndSublist(tls *libc.TLS, dsPtr uintptr) {
	/* Dynamic string. */
	XTcl_DStringAppend(tls, dsPtr, __ccgo_ts+263, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_PrintDouble --
 *
 *	Given a floating-point value, this function converts it to an ASCII
 *	string using.
 *
 * Results:
 *	The ASCII equivalent of "value" is written at "dst". It is guaranteed
 *	to contain a decimal point or exponent, so that it looks like a
 *	floating-point value and not an integer.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_PrintDouble(tls *libc.TLS, dummy3097 uintptr, value float64, dst uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Where to store converted value; must have
	 * at least TCL_DOUBLE_SPACE characters. */
	var c uint8
	var digits, p, v10, v11, v13, v14, v15, v16, v17, v19, v20, v21, v22, v5, v6, v7, v8, v9 uintptr
	var v1, v3 uint64
	var v12, v18 int32
	var _ /* __u at bp+0 */ struct {
		F__i [0]uint64
		F__f float64
	}
	var _ /* end at bp+16 */ uintptr
	var _ /* exponent at bp+8 */ int32
	var _ /* signum at bp+12 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, digits, p, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v3, v5, v6, v7, v8, v9
	/*
	 * Handle NaN.
	 */
	*(*float64)(unsafe.Pointer(bp)) = value
	v1 = *(*uint64)(unsafe.Pointer(bp))
	goto _2
_2:
	if libc.BoolInt32(v1&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) > libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
		XTclFormatNaN(tls, value, dst)
		return
	}
	/*
	 * Handle infinities.
	 */
	*(*float64)(unsafe.Pointer(bp)) = value
	v3 = *(*uint64)(unsafe.Pointer(bp))
	goto _4
_4:
	if libc.BoolInt32(v3&(-libc.Uint64FromUint64(1)>>libc.Int32FromInt32(1)) == libc.Uint64FromUint64(0x7ff)<<libc.Int32FromInt32(52)) != 0 {
		/*
		 * Remember to copy the terminating NUL too.
		 */
		if value < libc.Float64FromInt32(0) {
			libc.Xmemcpy(tls, dst, __ccgo_ts+68513, uint64(5))
		} else {
			libc.Xmemcpy(tls, dst, __ccgo_ts+68518, uint64(4))
		}
		return
	}
	/*
	 * Ordinary (normal and denormal) values.
	 */
	digits = XTclDoubleDigits(tls, value, -int32(1), int32(TCL_DD_SHORTEST), bp+8, bp+12, bp+16)
	if *(*int32)(unsafe.Pointer(bp + 12)) != 0 {
		v5 = dst
		dst++
		*(*uint8)(unsafe.Pointer(v5)) = uint8('-')
	}
	p = digits
	if *(*int32)(unsafe.Pointer(bp + 8)) < -int32(4) || *(*int32)(unsafe.Pointer(bp + 8)) > int32(16) {
		/*
		 * E format for numbers < 1e-3 or >= 1e17.
		 */
		v6 = dst
		dst++
		v7 = p
		p++
		*(*uint8)(unsafe.Pointer(v6)) = *(*uint8)(unsafe.Pointer(v7))
		c = *(*uint8)(unsafe.Pointer(p))
		if libc.Int32FromUint8(c) != int32('\000') {
			v8 = dst
			dst++
			*(*uint8)(unsafe.Pointer(v8)) = uint8('.')
			for libc.Int32FromUint8(c) != int32('\000') {
				v9 = dst
				dst++
				*(*uint8)(unsafe.Pointer(v9)) = c
				p++
				v10 = p
				c = *(*uint8)(unsafe.Pointer(v10))
			}
		}
		libc.X__builtin_snprintf(tls, dst, libc.Uint64FromInt32(libc.Int32FromInt32(TCL_MAX_PREC)+libc.Int32FromInt32(10)), __ccgo_ts+68522, libc.VaList(bp+32, *(*int32)(unsafe.Pointer(bp + 8))))
	} else {
		/*
		 * F format for others.
		 */
		if *(*int32)(unsafe.Pointer(bp + 8)) < 0 {
			v11 = dst
			dst++
			*(*uint8)(unsafe.Pointer(v11)) = uint8('0')
		}
		c = *(*uint8)(unsafe.Pointer(p))
		for {
			v12 = *(*int32)(unsafe.Pointer(bp + 8))
			*(*int32)(unsafe.Pointer(bp + 8))--
			if !(v12 >= 0) {
				break
			}
			if libc.Int32FromUint8(c) != int32('\000') {
				v13 = dst
				dst++
				*(*uint8)(unsafe.Pointer(v13)) = c
				p++
				v14 = p
				c = *(*uint8)(unsafe.Pointer(v14))
			} else {
				v15 = dst
				dst++
				*(*uint8)(unsafe.Pointer(v15)) = uint8('0')
			}
		}
		v16 = dst
		dst++
		*(*uint8)(unsafe.Pointer(v16)) = uint8('.')
		if libc.Int32FromUint8(c) == int32('\000') {
			v17 = dst
			dst++
			*(*uint8)(unsafe.Pointer(v17)) = uint8('0')
		} else {
			for {
				*(*int32)(unsafe.Pointer(bp + 8))++
				v18 = *(*int32)(unsafe.Pointer(bp + 8))
				if !(v18 < -int32(1)) {
					break
				}
				v19 = dst
				dst++
				*(*uint8)(unsafe.Pointer(v19)) = uint8('0')
			}
			for libc.Int32FromUint8(c) != int32('\000') {
				v20 = dst
				dst++
				*(*uint8)(unsafe.Pointer(v20)) = c
				p++
				v21 = p
				c = *(*uint8)(unsafe.Pointer(v21))
			}
		}
		v22 = dst
		dst++
		*(*uint8)(unsafe.Pointer(v22)) = uint8('\000')
	}
	XTclpFree(tls, digits)
}

/*
 *----------------------------------------------------------------------
 *
 * TclNeedSpace --
 *
 *	This function checks to see whether it is appropriate to add a space
 *	before appending a new list element to an existing string.
 *
 * Results:
 *	The return value is 1 if a space is appropriate, 0 otherwise.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclNeedSpace(tls *libc.TLS, start uintptr, end uintptr) (r int32) {
	/* End of string (place where space will be
	 * added, if appropriate). */
	var result, v2 int32
	var v1, v3 uintptr
	_, _, _, _ = result, v1, v2, v3
	/*
		     * A space is needed unless either:
		     * (a) we're at the start of the string, or
		     *
		     * (NOTE: This check is now absorbed into the loop below.)
		     *
		    if (end == start) {
			return 0;
		    }
		     *
	*/
	/*
		     * (b) we're at the start of a nested list-element, quoted with an open
		     *	   curly brace; we can be nested arbitrarily deep, so long as the
		     *	   first curly brace starts an element, so backtrack over open curly
		     *	   braces that are trailing characters of the string; and
		     *
		     *  (NOTE: Every character our parser is looking for is a proper
		     *  single-byte encoding of an ASCII value. It does not accept
		     *  overlong encodings.  Given that, there's no benefit using
		     *  Tcl_UtfPrev. If it would find what we seek, so would byte-by-byte
		     *  backward scan. Save routine call overhead and risk of wrong
		     *  results should the behavior of Tcl_UtfPrev change in unexpected ways.
		     *	Reconsider this if we ever start treating non-ASCII Unicode
		     *	characters as meaningful list syntax, expanded Unicode spaces as
		     *	element separators, for example.)
		     *
		    end = Tcl_UtfPrev(end, start);
		    while (*end == '{') {
			if (end == start) {
			    return 0;
			}
			end = Tcl_UtfPrev(end, start);
		    }
		     *
	*/
	for {
		end--
		v1 = end
		if !(v1 >= start && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(end))) == int32('{')) {
			break
		}
	}
	if end < start {
		return 0
	}
	/*
	 * (c) the trailing character of the string is already a list-element
	 *	   separator, Use the same testing routine as TclFindElement to
	 *	   enforce consistency.
	 */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(end))) > int32(0x20) {
		v2 = 0
	} else {
		v2 = XTclIsSpaceProc(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(end))))
	}
	if v2 != 0 {
		result = 0
		/*
		 * Trailing whitespace might be part of a backslash escape
		 * sequence. Handle that possibility.
		 */
		for {
			end--
			v3 = end
			if !(v3 >= start && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(end))) == int32('\\')) {
				break
			}
			result = libc.BoolInt32(!(result != 0))
		}
		return result
	}
	return int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * TclFormatInt --
 *
 *	This procedure formats an integer into a sequence of decimal digit
 *	characters in a buffer. If the integer is negative, a minus sign is
 *	inserted at the start of the buffer. A null character is inserted at
 *	the end of the formatted characters. It is the caller's responsibility
 *	to ensure that enough storage is available. This procedure has the
 *	effect of sprintf(buffer, "%ld", n) but is faster as proven in
 *	benchmarks.  This is key to UpdateStringOfInt, which is a common path
 *	for a lot of code (e.g. int-indexed arrays).
 *
 * Results:
 *	An integer representing the number of characters formatted, not
 *	including the terminating \0.
 *
 * Side effects:
 *	The formatted characters are written into the storage pointer to by
 *	the "buffer" argument.
 *
 *----------------------------------------------------------------------
 */

func XTclFormatInt(tls *libc.TLS, buffer uintptr, n TTcl_WideInt) (r TTcl_Size) {
	/* The integer to format. */
	var i, j, numFormatted, v2, v3, v4 int32
	var intVal TTcl_WideUInt
	var tmp uint8
	var v1 uint64
	_, _, _, _, _, _, _, _, _ = i, intVal, j, numFormatted, tmp, v1, v2, v3, v4
	i = 0
	/*
	 * Generate the characters of the result backwards in the buffer.
	 */
	if n < 0 {
		v1 = -libc.Uint64FromInt64(n)
	} else {
		v1 = libc.Uint64FromInt64(n)
	}
	intVal = v1
	for cond := true; cond; cond = intVal > uint64(0) {
		v2 = i
		i++
		*(*uint8)(unsafe.Pointer(buffer + uintptr(v2))) = _digits[intVal%uint64(10)]
		intVal = intVal / uint64(10)
	}
	if n < 0 {
		v3 = i
		i++
		*(*uint8)(unsafe.Pointer(buffer + uintptr(v3))) = uint8('-')
	}
	*(*uint8)(unsafe.Pointer(buffer + uintptr(i))) = uint8('\000')
	v4 = i
	i--
	numFormatted = v4
	/*
	 * Now reverse the characters.
	 */
	j = 0
	for {
		if !(j < i) {
			break
		}
		tmp = *(*uint8)(unsafe.Pointer(buffer + uintptr(i)))
		*(*uint8)(unsafe.Pointer(buffer + uintptr(i))) = *(*uint8)(unsafe.Pointer(buffer + uintptr(j)))
		*(*uint8)(unsafe.Pointer(buffer + uintptr(j))) = tmp
		goto _5
	_5:
		;
		j++
		i--
	}
	return int64(numFormatted)
}

var _digits = [11]uint8{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'}

/*
 *----------------------------------------------------------------------
 *
 * GetWideForIndex --
 *
 *	This function produces a wide integer value corresponding to the
 *	index value held in *objPtr. The parsing supports all values
 *	recognized as any size of integer, and the syntaxes end[-+]$integer
 *	and $integer[-+]$integer. The argument endValue is used to give
 *	the meaning of the literal index value "end". Index arithmetic
 *	on arguments outside the wide integer range are only accepted
 *	when interp is a working interpreter, not NULL.
 *
 * Results:
 *	When parsing of *objPtr successfully recognizes an index value,
 *	TCL_OK is returned, and the wide integer value corresponding to
 *	the recognized index value is written to *widePtr. When parsing
 *	fails, TCL_ERROR is returned and error information is written to
 *	interp, if non-NULL.
 *
 * Side effects:
 *	The type of *objPtr may change.
 *
 *----------------------------------------------------------------------
 */

func _GetWideForIndex(tls *libc.TLS, interp uintptr, objPtr uintptr, endValue TTcl_WideInt, widePtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Location filled in with a wide integer
	 * representing an index. */
	var code, v3 int32
	var v1, v2 int64
	var _ /* cd at bp+8 */ uintptr
	var _ /* numType at bp+0 */ int32
	_, _, _, _ = code, v1, v2, v3
	code = XTcl_GetNumberFromObj(tls, libc.UintptrFromInt32(0), objPtr, bp+8, bp)
	if code == TCL_OK {
		if *(*int32)(unsafe.Pointer(bp)) == int32(TCL_NUMBER_INT) {
			/* objPtr holds an integer in the signed wide range */
			*(*TTcl_WideInt)(unsafe.Pointer(widePtr)) = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))
			if *(*TTcl_WideInt)(unsafe.Pointer(widePtr)) < 0 {
				if endValue == int64(-int32(1)) {
					v1 = libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) + libc.Uint64FromInt32(1))
				} else {
					v1 = int64(-int32(1))
				}
				*(*TTcl_WideInt)(unsafe.Pointer(widePtr)) = v1
			}
			return TCL_OK
		}
		if *(*int32)(unsafe.Pointer(bp)) == int32(TCL_NUMBER_BIG) {
			/* objPtr holds an integer outside the signed wide range */
			/* Truncate to the signed wide range. */
			if (*Tmp_int)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fsign != MP_ZPOS {
				v3 = int32(MP_YES)
			} else {
				v3 = MP_NO
			}
			if v3 != 0 {
				v2 = libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) + libc.Uint64FromInt32(1))
			} else {
				v2 = libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
			}
			*(*TTcl_WideInt)(unsafe.Pointer(widePtr)) = v2
			return TCL_OK
		}
	}
	/* objPtr does not hold a number, check the end+/- format... */
	return _GetEndOffsetFromObj(tls, interp, objPtr, endValue, widePtr)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetIntForIndex --
 *
 *	Provides an integer corresponding to the list index held in a Tcl
 *	object. The string value 'objPtr' is expected have the format
 *	integer([+-]integer)? or end([+-]integer)?.
 *
 *	If the computed index lies within the valid range of Tcl indices
 *	(0..TCL_SIZE_MAX) it is returned. Higher values are returned as
 *	TCL_SIZE_MAX. Negative values are returned as TCL_INDEX_NONE (-1).
 *
 *	Callers should pass reasonable values for endValue - one in the
 *      valid index range or TCL_INDEX_NONE (-1), for example for an empty
 *	list.
 *
 * Results:
 *	TCL_OK
 *
 *	    The index is stored at the address given by 'indexPtr'.
 *
 *	TCL_ERROR
 *
 *	    The value of 'objPtr' does not have one of the expected formats. If
 *	    'interp' is non-NULL, an error message is left in the interpreter's
 *	    result object.
 *
 * Side effects:
 *
 *	The internal representation contained within objPtr may shimmer.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetIntForIndex(tls *libc.TLS, interp uintptr, objPtr uintptr, endValue TTcl_Size, indexPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Location filled in with an integer
	 * representing an index. May be NULL.*/
	var _ /* wide at bp+0 */ TTcl_WideInt
	if _GetWideForIndex(tls, interp, objPtr, endValue, bp) == int32(TCL_ERROR) {
		return int32(TCL_ERROR)
	}
	if indexPtr != libc.UintptrFromInt32(0) {
		/* Note: check against TCL_SIZE_MAX needed for 32-bit builds */
		if *(*TTcl_WideInt)(unsafe.Pointer(bp)) >= 0 && *(*TTcl_WideInt)(unsafe.Pointer(bp)) <= int64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) {
			*(*TTcl_Size)(unsafe.Pointer(indexPtr)) = *(*TTcl_WideInt)(unsafe.Pointer(bp)) /* A valid index */
		} else {
			if *(*TTcl_WideInt)(unsafe.Pointer(bp)) > int64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) {
				*(*TTcl_Size)(unsafe.Pointer(indexPtr)) = libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1)) /* Beyond max possible index */
			} else {
				if *(*TTcl_WideInt)(unsafe.Pointer(bp)) < int64(int64(-libc.Int32FromInt32(1))-libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) {
					*(*TTcl_Size)(unsafe.Pointer(indexPtr)) = int64(-libc.Int32FromInt32(1)) - libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)) /* Below most negative index */
				} else {
					if *(*TTcl_WideInt)(unsafe.Pointer(bp)) < 0 && endValue >= 0 {
						*(*TTcl_Size)(unsafe.Pointer(indexPtr)) = int64(-libc.Int32FromInt32(1)) /* No clue why this special case */
					} else {
						*(*TTcl_Size)(unsafe.Pointer(indexPtr)) = *(*TTcl_WideInt)(unsafe.Pointer(bp))
					}
				}
			}
		}
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * GetEndOffsetFromObj --
 *
 *	Look for a string of the form "end[+-]offset" or "offset[+-]offset" and
 *	convert it to an internal representation.
 *
 *	The internal representation (wideValue) uses the following encoding:
 *
 *	WIDE_MIN:   Index value TCL_INDEX_NONE (or -1)
 *	WIDE_MIN+1: Index value n, for any n < -1  (usually same effect as -1)
 *	-$n:        Index "end-[expr {$n-1}]"
 *	-2:         Index "end-1"
 *	-1:         Index "end"
 *	0:          Index "0"
 *	WIDE_MAX-1: Index "end+n", for any n > 1. Distinguish from end+1 for
 *                  commands like lset.
 *	WIDE_MAX:   Index "end+1"
 *
 * Results:
 *	Tcl return code.
 *
 * Side effects:
 *	May store a Tcl_ObjType.
 *
 *----------------------------------------------------------------------
 */

func _GetEndOffsetFromObj(tls *libc.TLS, interp uintptr, objPtr uintptr, endValue TTcl_WideInt, widePtr uintptr) (r int32) {
	bp := tls.Alloc(112)
	defer tls.Free(112) /* Location filled in with an integer
	 * representing an index. */
	var _objPtr, bytes, bytes1, compute, irPtr, v1, v11, v19, v2, v3 uintptr
	var offset, w1, w2 TTcl_WideInt
	var v10 TTcl_Size
	var v12, v14, v15, v16, v17, v18, v5 int64
	var v13, v4, v9 int32
	var v6 bool
	var _ /* cd at bp+0 */ uintptr
	var _ /* ir at bp+8 */ TTcl_ObjInternalRep
	var _ /* length at bp+24 */ TTcl_Size
	var _ /* numType at bp+32 */ int32
	var _ /* opPtr at bp+40 */ uintptr
	var _ /* sum at bp+56 */ uintptr
	var _ /* t at bp+64 */ int32
	var _ /* t1 at bp+48 */ int32
	var _ /* t2 at bp+52 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, bytes, bytes1, compute, irPtr, offset, w1, w2, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v3, v4, v5, v6, v9
	offset = int64(-int32(1))
	for {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_endOffsetType)) {
			v2 = objPtr + 32
		} else {
			v2 = libc.UintptrFromInt32(0)
		}
		v1 = v2
		irPtr = v1
		if !(v1 == libc.UintptrFromInt32(0)) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
			v3 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, objPtr, bp+24)
		}
		bytes = v3
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes))) != int32('e') {
			*(*int32)(unsafe.Pointer(bp + 48)) = 0
			*(*int32)(unsafe.Pointer(bp + 52)) = 0
			/* Value doesn't start with "e" */
			/* If we reach here, the string rep of objPtr exists. */
			/*
			 * The valid index syntax does not include any value that is
			 * a list of more than one element. This is necessary so that
			 * lists of index values can be reliably distinguished from any
			 * single index value.
			 */
			/*
			 * Quick scan to see if multi-value list is even possible.
			 * This relies on TclGetString() returning a NUL-terminated string.
			 */
			if v6 = XTclMaxListLength(tls, bytes, int64(-libc.Int32FromInt32(1)), libc.UintptrFromInt32(0)) > int64(1); v6 {
				if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
					if (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(objPtr + 32))).Fptr2 != 0 {
						v5 = (*TListSpan)(unsafe.Pointer((*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(objPtr + 32))).Fptr2)).FspanLength
					} else {
						v5 = (*TListStore)(unsafe.Pointer((*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(objPtr + 32))).Fptr1)).FnumUsed
					}
					*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = v5
					v4 = libc.Int32FromInt32(TCL_OK)
				} else {
					v4 = XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), objPtr, bp+24)
				}
			}
			if v6 && TCL_OK == v4 && *(*TTcl_Size)(unsafe.Pointer(bp + 24)) > int64(1) {
				goto parseError
			}
			/* Passed the list screen, so parse for index arithmetic expression */
			if TCL_OK == XTclParseNumber(tls, libc.UintptrFromInt32(0), objPtr, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), int64(-libc.Int32FromInt32(1)), bp+40, int32(TCL_PARSE_INTEGER_ONLY)) {
				w1 = 0
				w2 = 0
				/* value starts with valid integer... */
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40))))) == int32('-') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40))))) == int32('+') {
					/* ... value continues with [-+] ... */
					/* Save first integer as wide if possible */
					XTcl_GetNumberFromObj(tls, libc.UintptrFromInt32(0), objPtr, bp, bp+48)
					if *(*int32)(unsafe.Pointer(bp + 48)) == int32(TCL_NUMBER_INT) {
						w1 = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))
					}
					if TCL_OK == XTclParseNumber(tls, libc.UintptrFromInt32(0), objPtr, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 40))+uintptr(1), int64(-libc.Int32FromInt32(1)), libc.UintptrFromInt32(0), int32(TCL_PARSE_INTEGER_ONLY)) {
						/* ... value concludes with second valid integer */
						/* Save second integer as wide if possible */
						XTcl_GetNumberFromObj(tls, libc.UintptrFromInt32(0), objPtr, bp, bp+52)
						if *(*int32)(unsafe.Pointer(bp + 52)) == int32(TCL_NUMBER_INT) {
							w2 = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))
						}
					}
				}
				/* Clear invalid internalreps left by TclParseNumber */
				if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != libc.UintptrFromInt32(0) {
					if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
						(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc})))(tls, objPtr)
					}
					(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
				}
				if *(*int32)(unsafe.Pointer(bp + 48)) != 0 && *(*int32)(unsafe.Pointer(bp + 52)) != 0 {
					/* We have both integer values */
					if !(*(*int32)(unsafe.Pointer(bp + 48)) == int32(TCL_NUMBER_INT) && *(*int32)(unsafe.Pointer(bp + 52)) == int32(TCL_NUMBER_INT)) {
						goto _7
					}
					/* Both are wide, do wide-integer math */
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40))))) == int32('-') {
						if w2 == libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))+libc.Uint64FromInt32(1)) {
							goto extreme
						}
						w2 = -w2
					}
					if w1^w2 < 0 {
						/* Different signs, sum cannot overflow */
						offset = w1 + w2
					} else {
						if w1 >= 0 {
							if w1 < libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))-w2 {
								offset = w1 + w2
							} else {
								offset = libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
							}
						} else {
							if w1 > libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))+libc.Uint64FromInt32(1))-w2 {
								offset = w1 + w2
							} else {
								offset = libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) + libc.Uint64FromInt32(1))
							}
						}
					}
					goto _8
				_7:
					;
					goto extreme
				extreme:
					;
					if interp != 0 {
						XTcl_ExprObj(tls, interp, objPtr, bp+56)
					} else {
						compute = XTcl_CreateInterp(tls)
						XTcl_ExprObj(tls, compute, objPtr, bp+56)
						XTcl_DeleteInterp(tls, compute)
					}
					XTcl_GetNumberFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 56)), bp, bp+32)
					if *(*int32)(unsafe.Pointer(bp + 32)) == int32(TCL_NUMBER_INT) {
						/* sum holds an integer in the signed wide range */
						offset = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))
					} else {
						/* sum holds an integer outside the signed wide range */
						/* Truncate to the signed wide range. */
						if (*Tmp_int)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fsign != MP_ZPOS {
							v9 = int32(MP_YES)
						} else {
							v9 = MP_NO
						}
						if v9 != 0 {
							offset = libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) + libc.Uint64FromInt32(1))
						} else {
							offset = libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
						}
					}
					_objPtr = *(*uintptr)(unsafe.Pointer(bp + 56))
					v11 = _objPtr
					v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
					*(*TTcl_Size)(unsafe.Pointer(v11))--
					if v10 <= int64(1) {
						XTclFreeObj(tls, _objPtr)
					}
				_8:
					;
					if offset < 0 {
						if offset == int64(-int32(1)) {
							v12 = libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) + libc.Uint64FromInt32(1))
						} else {
							v12 = libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))+libc.Uint64FromInt32(1)) + libc.Int64FromInt32(1)
						}
						offset = v12
					}
					goto parseOK
				}
			}
			goto parseError
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 24)) < int64(3) || *(*TTcl_Size)(unsafe.Pointer(bp + 24)) == int64(4) || libc.Xstrncmp(tls, bytes, __ccgo_ts+21833, uint64(3)) != 0 {
			/* Doesn't start with "end" */
			goto parseError
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 24)) > int64(4) {
			/* Parse for the "end-..." or "end+..." formats */
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes + 3))) != int32('-') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes + 3))) != int32('+') {
				/* No operator where we need one */
				goto parseError
			}
			if XTclIsSpaceProc(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes + 4)))) != 0 {
				/* Space after + or - not permitted. */
				goto parseError
			}
			/* Parse the integer offset */
			if TCL_OK != XTclParseNumber(tls, libc.UintptrFromInt32(0), objPtr, libc.UintptrFromInt32(0), bytes+uintptr(4), *(*TTcl_Size)(unsafe.Pointer(bp + 24))-int64(4), libc.UintptrFromInt32(0), int32(TCL_PARSE_INTEGER_ONLY)) {
				/* Not a recognized integer format */
				goto parseError
			}
			/* Got an integer offset; pull it from where parser left it. */
			XTcl_GetNumberFromObj(tls, libc.UintptrFromInt32(0), objPtr, bp, bp+64)
			if *(*int32)(unsafe.Pointer(bp + 64)) == int32(TCL_NUMBER_BIG) {
				/* Truncate to the signed wide range. */
				if (*Tmp_int)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fsign != MP_ZPOS {
					v13 = int32(MP_YES)
				} else {
					v13 = MP_NO
				}
				if v13 != 0 {
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes + 3))) == int32('-') {
						v14 = libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
					} else {
						v14 = libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) + libc.Uint64FromInt32(1))
					}
					offset = v14
				} else {
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes + 3))) == int32('-') {
						v15 = libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) + libc.Uint64FromInt32(1))
					} else {
						v15 = libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
					}
					offset = v15
				}
			} else {
				/* assert (t == TCL_NUMBER_INT); */
				offset = *(*TTcl_WideInt)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bytes + 3))) == int32('-') {
					if offset == libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))+libc.Uint64FromInt32(1)) {
						v16 = libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
					} else {
						v16 = -offset
					}
					offset = v16
				}
				if offset == int64(1) {
					offset = libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1)) /* "end+1" */
				} else {
					if offset > int64(1) {
						offset = libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)) - libc.Int64FromInt32(1) /* "end+n", out of range */
					} else {
						if offset != libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))+libc.Uint64FromInt32(1)) {
							offset--
						}
					}
				}
			}
		}
		goto parseOK
	parseOK:
		;
		/* Success. Store the new internal rep. */
		*(*TTcl_WideInt)(unsafe.Pointer(&*(*TTcl_ObjInternalRep)(unsafe.Pointer(bp + 8)))) = offset
		XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&_endOffsetType)), bp+8)
	}
	offset = *(*TTcl_WideInt)(unsafe.Pointer(irPtr))
	if offset == libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)) {
		/*
		 * Encodes end+1. This is distinguished from end+n as noted
		 * in function header.
		 * NOTE: this may wrap around if the caller passes (as lset does)
		 * listLen-1 as endValue and listLen is 0. The -1 will be
		 * interpreted as FF...FF and adding 1 will result in 0 which
		 * is what we want. Callers like lset which pass in listLen-1 == -1
		 * as endValue will have to adjust accordingly.
		 */
		if endValue == int64(-int32(1)) {
			v17 = libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
		} else {
			v17 = endValue + int64(1)
		}
		*(*TTcl_WideInt)(unsafe.Pointer(widePtr)) = v17
	} else {
		if offset == libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))+libc.Uint64FromInt32(1)) {
			if endValue == int64(-int32(1)) {
				v18 = libc.Int64FromUint64(libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) + libc.Uint64FromInt32(1))
			} else {
				v18 = int64(-int32(1))
			}
			*(*TTcl_WideInt)(unsafe.Pointer(widePtr)) = v18
		} else {
			if offset < 0 {
				/* end-(n-1) - Different signs, sum cannot overflow */
				*(*TTcl_WideInt)(unsafe.Pointer(widePtr)) = endValue + offset + int64(1)
			} else {
				/* 0:WIDE_MAX - plain old index. */
				*(*TTcl_WideInt)(unsafe.Pointer(widePtr)) = offset
			}
		}
	}
	return TCL_OK
	/* Report a parse error. */
	goto parseError
parseError:
	;
	if interp != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
			v19 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		} else {
			v19 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
		}
		bytes1 = v19
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+68527, libc.VaList(bp+80, bytes1)))
		if !(libc.Xstrncmp(tls, bytes1, __ccgo_ts+68592, uint64(4)) != 0) {
			bytes1 += uintptr(4)
		}
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+80, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+17278, libc.UintptrFromInt32(0)))
	}
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * TclIndexEncode --
 *      IMPORTANT: function only encodes indices in the range that fits within
 *      an "int" type. Do NOT change this as the byte code compiler and engine
 *      which call this function cannot handle wider index types. Indices
 *      outside the range will result in the function returning an error.
 *
 *      Parse objPtr to determine if it is an index value. Two cases
 *	are possible.  The value objPtr might be parsed as an absolute
 *	index value in the Tcl_Size range.  Note that this includes
 *	index values that are integers as presented and it includes index
 *      arithmetic expressions.
 *
 *      The largest string supported in Tcl 8 has byte length TCL_SIZE_MAX.
 *      This means the largest supported character length is also TCL_SIZE_MAX,
 *      and the index of the last character in a string of length TCL_SIZE_MAX
 *      is TCL_SIZE_MAX-1. Thus the absolute index values that can be
 *	directly meaningful as an index into either a list or a string are
 *	integer values in the range 0 to TCL_SIZE_MAX - 1.
 *
 *      This function however can only handle integer indices in the range
 *      0 : INT_MAX-1.
 *
 *      Any absolute index value parsed outside that range is encoded
 *      using the before and after values passed in by the
 *      caller as the encoding to use for indices that are either
 *      less than or greater than the usable index range. TCL_INDEX_NONE
 *      is available as a good choice for most callers to use for
 *      after. Likewise, the value TCL_INDEX_NONE is good for
 *      most callers to use for before.  Other values are possible
 *      when the caller knows it is helpful in producing its own behavior
 *      for indices before and after the indexed item.
 *
 *      A token can also be parsed as an end-relative index expression.
 *      All end-relative expressions that indicate an index larger
 *      than end (end+2, end--5) point beyond the end of the indexed
 *      collection, and can be encoded as after.  The end-relative
 *      expressions that indicate an index less than or equal to end
 *      are encoded relative to the value TCL_INDEX_END (-2).  The
 *      index "end" is encoded as -2, down to the index "end-0x7FFFFFFE"
 *      which is encoded as INT_MIN. Since the largest index into a
 *      string possible in Tcl 8 is 0x7FFFFFFE, the interpretation of
 *      "end-0x7FFFFFFE" for that largest string would be 0.  Thus,
 *      if the tokens "end-0x7FFFFFFF" or "end+-0x80000000" are parsed,
 *      they can be encoded with the before value.
 *
 * Returns:
 *      TCL_OK if parsing succeeded, and TCL_ERROR if it failed or the
 *      index does not fit in an int type.
 *
 * Side effects:
 *      When TCL_OK is returned, the encoded index value is written
 *      to *indexPtr.
 *
 *----------------------------------------------------------------------
 */

func XTclIndexEncode(tls *libc.TLS, interp uintptr, objPtr uintptr, before int32, after int32, indexPtr uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Where to write the encoded answer, not NULL */
	var ENDVALUE TTcl_WideInt
	var idx int32
	var irPtr, v1, v2 uintptr
	var _ /* wide at bp+0 */ TTcl_WideInt
	_, _, _, _, _ = ENDVALUE, idx, irPtr, v1, v2
	ENDVALUE = libc.Int64FromInt32(2) * libc.Int64FromInt32(INT_MAX)
	if TCL_OK != _GetWideForIndex(tls, interp, objPtr, ENDVALUE, bp) {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_endOffsetType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	/*
	 * We passed 2*INT_MAX as the "end value" to GetWideForIndex. The computed
	 * index will be in one of the following ranges that need to be
	 * distinguished for encoding purposes in the following code.
	 * (1) 0:INT_MAX when
	 *     (a) objPtr was a pure non-negative numeric value in that range
	 *     (b) objPtr was a numeric computation M+/-N with a result in that range
	 *     (c) objPtr was of the form end-N where N was in range INT_MAX:2*INT_MAX
	 * (2) INT_MAX+1:2*INT_MAX when
	 *     (a,b) as above
	 *     (c) objPtr was of the form end-N where N was in range 0:INT_MAX-1
	 * (3) 2*INT_MAX:WIDE_MAX when
	 *     (a,b) as above
	 *     (c) objPtr was of the form end+N
	 * (4) (2*INT_MAX)-TCL_SIZE_MAX : -1 when
	 *     (a,b) as above
	 *     (c) objPtr was of the form end-N where N was in the range 0:TCL_SIZE_MAX
	 * (5) WIDE_MIN:(2*INT_MAX)-TCL_SIZE_MAX
	 *     (a,b) as above
	 *     (c) objPtr was of the form end-N where N was > TCL_SIZE_MAX
	 *
	 * For all cases (b) and (c), the internal representation of objPtr
	 * will be shimmered to endOffsetType. That allows us to distinguish between
	 * (for example) 1a (encodable) and 1c (not encodable) though the computed
	 * index value is the same.
	 *
	 * Further note, the values TCL_SIZE_MAX < N < WIDE_MAX come into play
	 * only in the 32-bit builds as TCL_SIZE_MAX == WIDE_MAX for 64-bits.
	 */
	irPtr = v1
	if irPtr != 0 && *(*TTcl_WideInt)(unsafe.Pointer(irPtr)) >= 0 {
		/*
		 * "int[+-]int" syntax, works the same here as "int".
		 * Note same does not hold for negative integers.
		 * Distinguishes 1b and 1c where wide will be in 0:INT_MAX for
		 * both but irPtr->wideValue will be negative for 1c.
		 */
		irPtr = libc.UintptrFromInt32(0)
	}
	if irPtr == libc.UintptrFromInt32(0) {
		/* objPtr can be treated as a purely numeric value. */
		/*
		 * On 64-bit systems, indices in the range INT_MAX:TCL_SIZE_MAX are
		 * valid indices but are not in the encodable range. Thus an
		 * error is raised. On 32-bit systems, indices in that range indicate
		 * the position after the end and so do not raise an error.
		 */
		if libc.Bool(uint64(4) != uint64(8)) && *(*TTcl_WideInt)(unsafe.Pointer(bp)) > int64(INT_MAX) && *(*TTcl_WideInt)(unsafe.Pointer(bp)) < libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))-libc.Int64FromInt32(1) {
			/* 2(a,b) on 64-bit systems*/
			goto rangeerror
		}
		if *(*TTcl_WideInt)(unsafe.Pointer(bp)) > int64(INT_MAX) {
			/*
			 * 3(a,b) on 64-bit systems and 2(a,b), 3(a,b) on 32-bit systems
			 * Because of the check above, this case holds for indices
			 * greater than INT_MAX on 32-bit systems and > TCL_SIZE_MAX
			 * on 64-bit systems. Always maps to the element after the end.
			 */
			idx = after
		} else {
			if *(*TTcl_WideInt)(unsafe.Pointer(bp)) < 0 {
				/* 4(a,b) (32-bit systems), 5(a,b) - before the beginning */
				idx = before
			} else {
				/* 1(a,b) Encodable range */
				idx = int32(*(*TTcl_WideInt)(unsafe.Pointer(bp)))
			}
		}
	} else {
		/* objPtr is not purely numeric (end etc.)  */
		/*
		 * On 64-bit systems, indices in the range end-LIST_MAX:end-INT_MAX
		 * are valid indices (with max size strings/lists) but are not in
		 * the encodable range. Thus an error is raised. On 32-bit systems,
		 * indices in that range indicate the position before the beginning
		 * and so do not raise an error.
		 */
		if libc.Bool(uint64(4) != uint64(8)) && *(*TTcl_WideInt)(unsafe.Pointer(bp)) > ENDVALUE-int64(libc.Int64FromUint64((libc.Uint64FromInt64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1)))-uint64(libc.UintptrFromInt32(0)+40))/libc.Uint64FromInt64(8))) && *(*TTcl_WideInt)(unsafe.Pointer(bp)) <= int64(INT_MAX) {
			/* 1(c), 4(a,b) on 64-bit systems */
			goto rangeerror
		}
		if *(*TTcl_WideInt)(unsafe.Pointer(bp)) > ENDVALUE {
			/*
			 * 2(c) (32-bit systems), 3(c)
			 * All end+positive or end-negative expressions
			 * always indicate "after the end".
			 * Note we will not reach here for a pure numeric value in this
			 * range because irPtr will be NULL in that case.
			 */
			idx = after
		} else {
			if *(*TTcl_WideInt)(unsafe.Pointer(bp)) <= int64(INT_MAX) {
				/* 1(c) (32-bit systems), 4(c) (32-bit systems), 5(c) */
				idx = before
			} else {
				/* 2(c) Encodable end-positive (or end+negative) */
				idx = int32(*(*TTcl_WideInt)(unsafe.Pointer(bp)))
			}
		}
	}
	*(*int32)(unsafe.Pointer(indexPtr)) = idx
	return TCL_OK
	goto rangeerror
rangeerror:
	;
	if interp != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+17830, libc.VaList(bp+16, v2)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+17278, __ccgo_ts+17284, libc.UintptrFromInt32(0)))
	}
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * TclIndexDecode --
 *
 *	Decodes a value previously encoded by TclIndexEncode.  The argument
 *	endValue indicates what value of "end" should be used in the
 *	decoding.
 *
 * Results:
 *	The decoded index value.
 *
 *----------------------------------------------------------------------
 */

func XTclIndexDecode(tls *libc.TLS, encoded int32, endValue TTcl_Size) (r TTcl_Size) {
	/* Meaning of "end" to use, > TCL_INDEX_END */
	if int64(encoded) > int64(-libc.Int32FromInt32(2)) {
		return int64(encoded)
	}
	endValue += int64(encoded) - int64(-libc.Int32FromInt32(2))
	if endValue >= 0 {
		return endValue
	}
	return int64(-libc.Int32FromInt32(1))
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * TclCommandWordLimitErrpr --
//	 *
//	 *    Generates an error message limit on number of command words exceeded.
//	 *
//	 * Results:
//	 *    Always return TCL_ERROR.
//	 *
//	 * Side effects:
//	 *    If interp is not-NULL, an error message is stored in it.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func XTclCommandWordLimitError(tls *libc.TLS, interp uintptr, count TTcl_Size) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* If <= 0, "unknown" */
	if interp != 0 {
		if count > 0 {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+68597, libc.VaList(bp+8, count, libc.Int64FromInt32(INT_MAX))))
		} else {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+68649, libc.VaList(bp+8, libc.Int64FromInt32(INT_MAX))))
		}
	}
	return int32(TCL_ERROR) /* Always */
}

/*
 *----------------------------------------------------------------------
 *
 * ClearHash --
 *
 *	Remove all the entries in the hash table *tablePtr.
 *
 *----------------------------------------------------------------------
 */

func _ClearHash(tls *libc.TLS, tablePtr uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _objPtr, hPtr, objPtr, v3 uintptr
	var v2 TTcl_Size
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _, _ = _objPtr, hPtr, objPtr, v2, v3
	hPtr = XTcl_FirstHashEntry(tls, tablePtr, bp)
	for {
		if !(hPtr != libc.UintptrFromInt32(0)) {
			break
		}
		objPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		_objPtr = objPtr
		v3 = _objPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		XTcl_DeleteHashEntry(tls, hPtr)
		goto _1
	_1:
		;
		hPtr = XTcl_NextHashEntry(tls, bp)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * GetThreadHash --
 *
 *	Get a thread-specific (Tcl_HashTable *) associated with a thread data
 *	key.
 *
 * Results:
 *	The Tcl_HashTable * corresponding to *keyPtr.
 *
 * Side effects:
 *	The first call on a keyPtr in each thread creates a new Tcl_HashTable,
 *	and registers a thread exit handler to dispose of it.
 *
 *----------------------------------------------------------------------
 */

func _GetThreadHash(tls *libc.TLS, keyPtr uintptr) (r uintptr) {
	var tablePtrPtr uintptr
	_ = tablePtrPtr
	tablePtrPtr = XTcl_GetThreadData(tls, keyPtr, int64(8))
	if libc.UintptrFromInt32(0) == *(*uintptr)(unsafe.Pointer(tablePtrPtr)) {
		*(*uintptr)(unsafe.Pointer(tablePtrPtr)) = XTcl_Alloc(tls, uint64(104))
		XTcl_CreateThreadExitHandler(tls, __ccgo_fp(_FreeThreadHash), *(*uintptr)(unsafe.Pointer(tablePtrPtr)))
		XTcl_InitHashTable(tls, *(*uintptr)(unsafe.Pointer(tablePtrPtr)), int32(TCL_ONE_WORD_KEYS))
	}
	return *(*uintptr)(unsafe.Pointer(tablePtrPtr))
}

/*
 *----------------------------------------------------------------------
 *
 * FreeThreadHash --
 *
 *	Thread exit handler used by GetThreadHash to dispose of a thread hash
 *	table.
 *
 * Side effects:
 *	Frees a Tcl_HashTable.
 *
 *----------------------------------------------------------------------
 */

func _FreeThreadHash(tls *libc.TLS, clientData uintptr) {
	var tablePtr uintptr
	_ = tablePtr
	tablePtr = clientData
	_ClearHash(tls, tablePtr)
	XTcl_DeleteHashTable(tls, tablePtr)
	XTclpFree(tls, tablePtr)
}

/*
 *----------------------------------------------------------------------
 *
 * FreeProcessGlobalValue --
 *
 *	Exit handler used by Tcl(Set|Get)ProcessGlobalValue to cleanup a
 *	ProcessGlobalValue at exit.
 *
 *----------------------------------------------------------------------
 */

func _FreeProcessGlobalValue(tls *libc.TLS, clientData uintptr) {
	var pgvPtr uintptr
	_ = pgvPtr
	pgvPtr = clientData
	(*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fepoch++
	(*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).FnumBytes = uint64(0)
	XTclpFree(tls, (*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fvalue)
	(*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fvalue = libc.UintptrFromInt32(0)
	if (*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fencoding != 0 {
		XTcl_FreeEncoding(tls, (*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fencoding)
		(*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fencoding = libc.UintptrFromInt32(0)
	}
	XTcl_MutexFinalize(tls, pgvPtr+40)
}

/*
 *----------------------------------------------------------------------
 *
 * TclSetProcessGlobalValue --
 *
 *	Utility routine to set a global value shared by all threads in the
 *	process while keeping a thread-local copy as well.
 *
 *----------------------------------------------------------------------
 */

func XTclSetProcessGlobalValue(tls *libc.TLS, pgvPtr uintptr, newValue uintptr) {
	bp := tls.Alloc(240)
	defer tls.Free(240)
	var bytes, cacheMap, hPtr, v1 uintptr
	var _ /* ds at bp+8 */ TTcl_DString
	var _ /* dummy at bp+0 */ int32
	_, _, _, _ = bytes, cacheMap, hPtr, v1
	XTcl_MutexLock(tls, pgvPtr+40)
	/*
	 * Fill the global string value.
	 */
	(*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fepoch++
	if libc.UintptrFromInt32(0) != (*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fvalue {
		XTclpFree(tls, (*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fvalue)
	} else {
		XTcl_CreateExitHandler(tls, __ccgo_fp(_FreeProcessGlobalValue), pgvPtr)
	}
	if (*TTcl_Obj)(unsafe.Pointer(newValue)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(newValue)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, newValue, libc.UintptrFromInt32(0))
	}
	bytes = v1
	(*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).FnumBytes = libc.Uint64FromInt64((*TTcl_Obj)(unsafe.Pointer(newValue)).Flength)
	XTcl_UtfToExternalDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), bytes, libc.Int64FromUint64((*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).FnumBytes), int32(TCL_ENCODING_PROFILE_TCL8), bp+8, libc.UintptrFromInt32(0))
	(*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).FnumBytes = libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(bp + 8)).Flength)
	(*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fvalue = XTcl_Alloc(tls, (*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).FnumBytes+uint64(1))
	libc.Xmemcpy(tls, (*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fvalue, (*TTcl_DString)(unsafe.Pointer(bp+8)).Fstring1, (*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).FnumBytes+uint64(1))
	XTcl_DStringFree(tls, bp+8)
	if (*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fencoding != 0 {
		XTcl_FreeEncoding(tls, (*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fencoding)
	}
	(*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fencoding = libc.UintptrFromInt32(0)
	/*
	 * Fill the local thread copy directly with the Tcl_Obj value to avoid
	 * loss of the internalrep. Increment newValue refCount early to handle case
	 * where we set a PGV to itself.
	 */
	(*TTcl_Obj)(unsafe.Pointer(newValue)).FrefCount++
	cacheMap = _GetThreadHash(tls, pgvPtr+48)
	_ClearHash(tls, cacheMap)
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(cacheMap)).FcreateProc})))(tls, cacheMap, uintptr((*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fepoch), bp)
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = newValue
	XTcl_MutexUnlock(tls, pgvPtr+40)
}

/*
 *----------------------------------------------------------------------
 *
 * TclGetProcessGlobalValue --
 *
 *	Retrieve a global value shared among all threads of the process,
 *	preferring a thread-local copy as long as it remains valid.
 *
 * Results:
 *	Returns a (Tcl_Obj *) that holds a copy of the global value.
 *
 *----------------------------------------------------------------------
 */

func XTclGetProcessGlobalValue(tls *libc.TLS, pgvPtr uintptr) (r uintptr) {
	bp := tls.Alloc(464)
	defer tls.Free(464)
	var cacheMap, hPtr, value, v2 uintptr
	var current TTcl_Encoding
	var epoch, v1 TTcl_Size
	var _ /* dummy at bp+448 */ int32
	var _ /* native at bp+224 */ TTcl_DString
	var _ /* newValue at bp+0 */ TTcl_DString
	_, _, _, _, _, _, _ = cacheMap, current, epoch, hPtr, value, v1, v2
	value = libc.UintptrFromInt32(0)
	epoch = (*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fepoch
	if (*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fencoding != 0 {
		current = XTcl_GetEncoding(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
		if (*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fencoding != current {
			XTcl_MutexLock(tls, pgvPtr+40)
			v2 = pgvPtr
			*(*TTcl_Size)(unsafe.Pointer(v2))++
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			epoch = v1
			XTcl_UtfToExternalDStringEx(tls, libc.UintptrFromInt32(0), (*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fencoding, (*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fvalue, libc.Int64FromUint64((*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).FnumBytes), int32(TCL_ENCODING_PROFILE_TCL8), bp+224, libc.UintptrFromInt32(0))
			XTcl_ExternalToUtfDStringEx(tls, libc.UintptrFromInt32(0), current, (*TTcl_DString)(unsafe.Pointer(bp+224)).Fstring1, (*TTcl_DString)(unsafe.Pointer(bp+224)).Flength, int32(TCL_ENCODING_PROFILE_TCL8), bp, libc.UintptrFromInt32(0))
			XTcl_DStringFree(tls, bp+224)
			XTclpFree(tls, (*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fvalue)
			(*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fvalue = XTcl_Alloc(tls, libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(bp)).Flength+int64(1)))
			libc.Xmemcpy(tls, (*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fvalue, (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1, libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(bp)).Flength+int64(1)))
			XTcl_DStringFree(tls, bp)
			XTcl_FreeEncoding(tls, (*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fencoding)
			(*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fencoding = current
			XTcl_MutexUnlock(tls, pgvPtr+40)
		} else {
			XTcl_FreeEncoding(tls, current)
		}
	}
	cacheMap = _GetThreadHash(tls, pgvPtr+48)
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(cacheMap)).FfindProc})))(tls, cacheMap, uintptr(epoch))
	if libc.UintptrFromInt32(0) == hPtr {
		/*
		 * No cache for the current epoch - must be a new one.
		 *
		 * First, clear the cacheMap, as anything in it must refer to some
		 * expired epoch.
		 */
		_ClearHash(tls, cacheMap)
		/*
		 * If no thread has set the shared value, call the initializer.
		 */
		XTcl_MutexLock(tls, pgvPtr+40)
		if libc.UintptrFromInt32(0) == (*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fvalue && (*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fproc != 0 {
			(*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fepoch++
			(*(*func(*libc.TLS, uintptr, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fproc})))(tls, pgvPtr+16, pgvPtr+8, pgvPtr+24)
			if (*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fvalue == libc.UintptrFromInt32(0) {
				XTcl_Panic(tls, __ccgo_ts+68695, 0)
			}
			XTcl_CreateExitHandler(tls, __ccgo_fp(_FreeProcessGlobalValue), pgvPtr)
		}
		/*
		 * Store a copy of the shared value (but then in utf-8)
		 * in our epoch-indexed cache.
		 */
		XTcl_ExternalToUtfDString(tls, libc.UintptrFromInt32(0), (*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fvalue, libc.Int64FromUint64((*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).FnumBytes), bp)
		value = XTcl_DStringToObj(tls, bp)
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(cacheMap)).FcreateProc})))(tls, cacheMap, uintptr((*TProcessGlobalValue)(unsafe.Pointer(pgvPtr)).Fepoch), bp+448)
		XTcl_MutexUnlock(tls, pgvPtr+40)
		(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = value
		(*TTcl_Obj)(unsafe.Pointer(value)).FrefCount++
	}
	return (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
}

/*
 *----------------------------------------------------------------------
 *
 * TclSetObjNameOfExecutable --
 *
 *	This function stores the absolute pathname of the executable file
 *	(normally as computed by TclpFindExecutable).
 *
 *	Starting with Tcl 9.0, encoding parameter is not used any more.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Stores the executable name.
 *
 *----------------------------------------------------------------------
 */

func XTclSetObjNameOfExecutable(tls *libc.TLS, name uintptr, dummy4302 TTcl_Encoding) {
	XTclSetProcessGlobalValue(tls, uintptr(unsafe.Pointer(&_executableName)), name)
}

/*
 *----------------------------------------------------------------------
 *
 * TclGetObjNameOfExecutable --
 *
 *	This function retrieves the absolute pathname of the application in
 *	which the Tcl library is running, usually as previously stored by
 *	TclpFindExecutable(). This function call is the C API equivalent to
 *	the "info nameofexecutable" command.
 *
 * Results:
 *	A pointer to an "fsPath" Tcl_Obj, or to an empty Tcl_Obj if the
 *	pathname of the application is unknown.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclGetObjNameOfExecutable(tls *libc.TLS) (r uintptr) {
	return XTclGetProcessGlobalValue(tls, uintptr(unsafe.Pointer(&_executableName)))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetNameOfExecutable --
 *
 *	This function retrieves the absolute pathname of the application in
 *	which the Tcl library is running, and returns it in string form.
 *
 *	The returned string belongs to Tcl and should be copied if the caller
 *	plans to keep it, to guard against it becoming invalid.
 *
 * Results:
 *	A pointer to the internal string or NULL if the internal full path
 *	name has not been computed or unknown.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetNameOfExecutable(tls *libc.TLS) (r uintptr) {
	var bytes, obj, v1 uintptr
	_, _, _ = bytes, obj, v1
	obj = XTclGetObjNameOfExecutable(tls)
	if (*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, obj, libc.UintptrFromInt32(0))
	}
	bytes = v1
	if (*TTcl_Obj)(unsafe.Pointer(obj)).Flength == 0 {
		return libc.UintptrFromInt32(0)
	}
	return bytes
}

/*
 *----------------------------------------------------------------------
 *
 * TclGetPlatform --
 *
 *	This is a kludge that allows the test library to get access the
 *	internal tclPlatform variable.
 *
 * Results:
 *	Returns a pointer to the tclPlatform variable.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclGetPlatform(tls *libc.TLS) (r uintptr) {
	return uintptr(unsafe.Pointer(&XtclPlatform))
}

/*
 *----------------------------------------------------------------------
 *
 * TclReToGlob --
 *
 *	Attempt to convert a regular expression to an equivalent glob pattern.
 *
 * Results:
 *	Returns TCL_OK on success, TCL_ERROR on failure. If interp is not
 *	NULL, an error message is placed in the result. On success, the
 *	DString will contain an exact equivalent glob pattern. The caller is
 *	responsible for calling Tcl_DStringFree on success. If exactPtr is not
 *	NULL, it will be 1 if an exact match qualifies.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclReToGlob(tls *libc.TLS, interp uintptr, reStr uintptr, reStrLen TTcl_Size, dsPtr uintptr, exactPtr uintptr, quantifiersFoundPtr uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var anchorLeft, anchorRight, lastIsStar, numStars int32
	var code, dsStr, dsStrStart, msg, p, strEnd, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v4, v5, v6, v7, v8 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = anchorLeft, anchorRight, code, dsStr, dsStrStart, lastIsStar, msg, numStars, p, strEnd, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v4, v5, v6, v7, v8
	strEnd = reStr + uintptr(reStrLen)
	XTcl_DStringInit(tls, dsPtr)
	if quantifiersFoundPtr != libc.UintptrFromInt32(0) {
		*(*int32)(unsafe.Pointer(quantifiersFoundPtr)) = 0
	}
	/*
	 * "***=xxx" == "*xxx*", watch for glob-sensitive chars.
	 */
	if reStrLen >= int64(4) && libc.Xmemcmp(tls, __ccgo_ts+68730, reStr, uint64(4)) == 0 {
		/*
		 * At most, the glob pattern has length 2*reStrLen + 2 to backslash
		 * escape every character and have * at each end.
		 */
		XTcl_DStringSetLength(tls, dsPtr, reStrLen+int64(2))
		v1 = (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1
		dsStrStart = v1
		dsStr = v1
		v2 = dsStr
		dsStr++
		*(*uint8)(unsafe.Pointer(v2)) = uint8('*')
		p = reStr + uintptr(4)
		for {
			if !(p < strEnd) {
				break
			}
			switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) {
			case int32('\\'):
				fallthrough
			case int32('*'):
				fallthrough
			case int32('['):
				fallthrough
			case int32(']'):
				fallthrough
			case int32('?'):
				/* Only add \ where necessary for glob */
				v4 = dsStr
				dsStr++
				*(*uint8)(unsafe.Pointer(v4)) = uint8('\\')
				/* fall through */
				fallthrough
			default:
				v5 = dsStr
				dsStr++
				*(*uint8)(unsafe.Pointer(v5)) = *(*uint8)(unsafe.Pointer(p))
				break
			}
			goto _3
		_3:
			;
			p++
		}
		v6 = dsStr
		dsStr++
		*(*uint8)(unsafe.Pointer(v6)) = uint8('*')
		XTcl_DStringSetLength(tls, dsPtr, int64(dsStr)-int64(dsStrStart))
		if exactPtr != 0 {
			*(*int32)(unsafe.Pointer(exactPtr)) = 0
		}
		return TCL_OK
	}
	/*
	 * At most, the glob pattern has length reStrLen + 2 to account for
	 * possible * at each end.
	 */
	XTcl_DStringSetLength(tls, dsPtr, reStrLen+int64(2))
	v7 = (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1
	dsStrStart = v7
	dsStr = v7
	/*
	 * Check for anchored REs (ie ^foo$), so we can use string equal if
	 * possible. Do not alter the start of str so we can free it correctly.
	 *
	 * Keep track of the last char being an unescaped star to prevent multiple
	 * instances.  Simpler than checking that the last star may be escaped.
	 */
	msg = libc.UintptrFromInt32(0)
	code = libc.UintptrFromInt32(0)
	p = reStr
	anchorRight = 0
	lastIsStar = 0
	numStars = 0
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('^') {
		anchorLeft = int32(1)
		p++
	} else {
		anchorLeft = 0
		v8 = dsStr
		dsStr++
		*(*uint8)(unsafe.Pointer(v8)) = uint8('*')
		lastIsStar = int32(1)
	}
	for {
		if !(p < strEnd) {
			break
		}
		switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) {
		case int32('\\'):
			p++
			switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) {
			case int32('a'):
				v10 = dsStr
				dsStr++
				*(*uint8)(unsafe.Pointer(v10)) = uint8('\a')
			case int32('b'):
				v11 = dsStr
				dsStr++
				*(*uint8)(unsafe.Pointer(v11)) = uint8('\b')
			case int32('f'):
				v12 = dsStr
				dsStr++
				*(*uint8)(unsafe.Pointer(v12)) = uint8('\f')
			case int32('n'):
				v13 = dsStr
				dsStr++
				*(*uint8)(unsafe.Pointer(v13)) = uint8('\n')
			case int32('r'):
				v14 = dsStr
				dsStr++
				*(*uint8)(unsafe.Pointer(v14)) = uint8('\r')
			case int32('t'):
				v15 = dsStr
				dsStr++
				*(*uint8)(unsafe.Pointer(v15)) = uint8('\t')
			case int32('v'):
				v16 = dsStr
				dsStr++
				*(*uint8)(unsafe.Pointer(v16)) = uint8('\v')
			case int32('B'):
				fallthrough
			case int32('\\'):
				v17 = dsStr
				dsStr++
				*(*uint8)(unsafe.Pointer(v17)) = uint8('\\')
				v18 = dsStr
				dsStr++
				*(*uint8)(unsafe.Pointer(v18)) = uint8('\\')
				anchorLeft = 0 /* prevent exact match */
			case int32('*'):
				fallthrough
			case int32('['):
				fallthrough
			case int32(']'):
				fallthrough
			case int32('?'):
				/* Only add \ where necessary for glob */
				v19 = dsStr
				dsStr++
				*(*uint8)(unsafe.Pointer(v19)) = uint8('\\')
				anchorLeft = 0 /* prevent exact match */
				/* fall through */
				fallthrough
			case int32('{'):
				fallthrough
			case int32('}'):
				fallthrough
			case int32('('):
				fallthrough
			case int32(')'):
				fallthrough
			case int32('+'):
				fallthrough
			case int32('.'):
				fallthrough
			case int32('|'):
				fallthrough
			case int32('^'):
				fallthrough
			case int32('$'):
				v20 = dsStr
				dsStr++
				*(*uint8)(unsafe.Pointer(v20)) = *(*uint8)(unsafe.Pointer(p))
			default:
				msg = __ccgo_ts + 68735
				code = __ccgo_ts + 68759
				goto invalidGlob
			}
		case int32('.'):
			if quantifiersFoundPtr != libc.UintptrFromInt32(0) {
				*(*int32)(unsafe.Pointer(quantifiersFoundPtr)) = int32(1)
			}
			anchorLeft = 0 /* prevent exact match */
			if p+uintptr(1) < strEnd {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('*') {
					p++
					if !(lastIsStar != 0) {
						v21 = dsStr
						dsStr++
						*(*uint8)(unsafe.Pointer(v21)) = uint8('*')
						lastIsStar = int32(1)
						numStars++
					}
					goto _9
				} else {
					if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('+') {
						p++
						v22 = dsStr
						dsStr++
						*(*uint8)(unsafe.Pointer(v22)) = uint8('?')
						v23 = dsStr
						dsStr++
						*(*uint8)(unsafe.Pointer(v23)) = uint8('*')
						lastIsStar = int32(1)
						numStars++
						goto _9
					}
				}
			}
			v24 = dsStr
			dsStr++
			*(*uint8)(unsafe.Pointer(v24)) = uint8('?')
		case int32('$'):
			if p+uintptr(1) != strEnd {
				msg = __ccgo_ts + 68769
				code = __ccgo_ts + 68782
				goto invalidGlob
			}
			anchorRight = int32(1)
		case int32('*'):
			fallthrough
		case int32('+'):
			fallthrough
		case int32('?'):
			fallthrough
		case int32('|'):
			fallthrough
		case int32('^'):
			fallthrough
		case int32('{'):
			fallthrough
		case int32('}'):
			fallthrough
		case int32('('):
			fallthrough
		case int32(')'):
			fallthrough
		case int32('['):
			fallthrough
		case int32(']'):
			msg = __ccgo_ts + 68792
			code = __ccgo_ts + 68818
			goto invalidGlob
		default:
			v25 = dsStr
			dsStr++
			*(*uint8)(unsafe.Pointer(v25)) = *(*uint8)(unsafe.Pointer(p))
			break
		}
		lastIsStar = 0
		goto _9
	_9:
		;
		p++
	}
	if numStars > int32(1) {
		/*
		 * Heuristic: if >1 non-anchoring *, the risk is large that glob
		 * matching is slower than the RE engine, so report invalid.
		 */
		msg = __ccgo_ts + 68828
		code = __ccgo_ts + 68873
		goto invalidGlob
	}
	if !(anchorRight != 0) && !(lastIsStar != 0) {
		v26 = dsStr
		dsStr++
		*(*uint8)(unsafe.Pointer(v26)) = uint8('*')
	}
	XTcl_DStringSetLength(tls, dsPtr, int64(dsStr)-int64(dsStrStart))
	if exactPtr != 0 {
		*(*int32)(unsafe.Pointer(exactPtr)) = libc.BoolInt32(anchorLeft != 0 && anchorRight != 0)
	}
	return TCL_OK
	goto invalidGlob
invalidGlob:
	;
	if interp != libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, msg, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+68885, code, libc.UintptrFromInt32(0)))
	}
	XTcl_DStringFree(tls, dsPtr)
	return int32(TCL_ERROR)
}

var _tclVarHashKeyType = TTcl_HashKeyType{
	Fversion: int32(TCL_HASH_KEY_TYPE_VERSION),
	Fflags:   int32(TCL_HASH_KEY_DIRECT_COMPARE),
}

func init() {
	p := unsafe.Pointer(&_tclVarHashKeyType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(XTclHashObjKey)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_CompareVarKeys)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_AllocVarEntry)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_FreeVarEntry)
}

/*
 * NOTE: VarHashCreateVar increments the recount of its key argument.
 * All callers that will call Tcl_DecrRefCount on that argument must
 * call Tcl_IncrRefCount on it before passing it in.  This requirement
 * can bubble up to callers of callers .... etc.
 */

func _VarHashCreateVar1(tls *libc.TLS, tablePtr uintptr, key uintptr, newPtr uintptr) (r uintptr) {
	var hPtr uintptr
	_ = hPtr
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FcreateProc})))(tls, tablePtr, key, newPtr)
	if !(hPtr != 0) {
		return libc.UintptrFromInt32(0)
	}
	return hPtr - uintptr(uint64(libc.UintptrFromInt32(0)+24))
}

func _VarHashFirstVar(tls *libc.TLS, tablePtr uintptr, searchPtr uintptr) (r uintptr) {
	var hPtr uintptr
	_ = hPtr
	hPtr = XTcl_FirstHashEntry(tls, tablePtr, searchPtr)
	if !(hPtr != 0) {
		return libc.UintptrFromInt32(0)
	}
	return hPtr - uintptr(uint64(libc.UintptrFromInt32(0)+24))
}

func _VarHashNextVar(tls *libc.TLS, searchPtr uintptr) (r uintptr) {
	var hPtr uintptr
	_ = hPtr
	hPtr = XTcl_NextHashEntry(tls, searchPtr)
	if !(hPtr != 0) {
		return libc.UintptrFromInt32(0)
	}
	return hPtr - uintptr(uint64(libc.UintptrFromInt32(0)+24))
}

/*
 * The strings below are used to indicate what went wrong when a variable
 * access is denied.
 */

var _NOSUCHVAR = [17]uint8{'n', 'o', ' ', 's', 'u', 'c', 'h', ' ', 'v', 'a', 'r', 'i', 'a', 'b', 'l', 'e'}
var _ISARRAY = [18]uint8{'v', 'a', 'r', 'i', 'a', 'b', 'l', 'e', ' ', 'i', 's', ' ', 'a', 'r', 'r', 'a', 'y'}
var _NEEDARRAY = [21]uint8{'v', 'a', 'r', 'i', 'a', 'b', 'l', 'e', ' ', 'i', 's', 'n', '\'', 't', ' ', 'a', 'r', 'r', 'a', 'y'}
var _NOSUCHELEMENT = [25]uint8{'n', 'o', ' ', 's', 'u', 'c', 'h', ' ', 'e', 'l', 'e', 'm', 'e', 'n', 't', ' ', 'i', 'n', ' ', 'a', 'r', 'r', 'a', 'y'}
var _DANGLINGELEMENT = [41]uint8{'u', 'p', 'v', 'a', 'r', ' ', 'r', 'e', 'f', 'e', 'r', 's', ' ', 't', 'o', ' ', 'e', 'l', 'e', 'm', 'e', 'n', 't', ' ', 'i', 'n', ' ', 'd', 'e', 'l', 'e', 't', 'e', 'd', ' ', 'a', 'r', 'r', 'a', 'y'}
var _DANGLINGVAR = [46]uint8{'u', 'p', 'v', 'a', 'r', ' ', 'r', 'e', 'f', 'e', 'r', 's', ' ', 't', 'o', ' ', 'v', 'a', 'r', 'i', 'a', 'b', 'l', 'e', ' ', 'i', 'n', ' ', 'd', 'e', 'l', 'e', 't', 'e', 'd', ' ', 'n', 'a', 'm', 'e', 's', 'p', 'a', 'c', 'e'}
var _BADNAMESPACE = [31]uint8{'p', 'a', 'r', 'e', 'n', 't', ' ', 'n', 'a', 'm', 'e', 's', 'p', 'a', 'c', 'e', ' ', 'd', 'o', 'e', 's', 'n', '\'', 't', ' ', 'e', 'x', 'i', 's', 't'}
var _MISSINGNAME = [22]uint8{'m', 'i', 's', 's', 'i', 'n', 'g', ' ', 'v', 'a', 'r', 'i', 'a', 'b', 'l', 'e', ' ', 'n', 'a', 'm', 'e'}
var _ISARRAYELEMENT = [38]uint8{'n', 'a', 'm', 'e', ' ', 'r', 'e', 'f', 'e', 'r', 's', ' ', 't', 'o', ' ', 'a', 'n', ' ', 'e', 'l', 'e', 'm', 'e', 'n', 't', ' ', 'i', 'n', ' ', 'a', 'n', ' ', 'a', 'r', 'r', 'a', 'y'}
var _ISCONST = [23]uint8{'v', 'a', 'r', 'i', 'a', 'b', 'l', 'e', ' ', 'i', 's', ' ', 'a', ' ', 'c', 'o', 'n', 's', 't', 'a', 'n', 't'}
var _EXISTS = [24]uint8{'v', 'a', 'r', 'i', 'a', 'b', 'l', 'e', ' ', 'a', 'l', 'r', 'e', 'a', 'd', 'y', ' ', 'e', 'x', 'i', 's', 't', 's'}

/*
 * A test to see if we are in a call frame that has local variables. This is
 * true if we are inside a procedure body.
 */

/*
 * The following structure describes an enumerative search in progress on an
 * array variable; this are invoked with options to the "array" command.
 */

type TArraySearch = struct {
	Fname      uintptr
	Fid        int32
	FvarPtr    uintptr
	Fsearch    TTcl_HashSearch
	FnextEntry uintptr
	FnextPtr   uintptr
}

/*
 * TIP #508: [array default]
 *
 * The following structure extends the regular TclVarHashTable used by array
 * variables to store their optional default value.
 */

type TArrayVarHashTable = struct {
	Ftable      TTclVarHashTable
	FdefaultObj uintptr
}

/*
 * Types of Tcl_Objs used to cache variable lookups.
 *
 * localVarName - INTERNALREP DEFINITION:
 *   twoPtrValue.ptr1:   pointer to name obj in varFramePtr->localCache
 *			  or NULL if it is this same obj
 *   twoPtrValue.ptr2: index into locals table
 *
 * parsedVarName - INTERNALREP DEFINITION:
 *   twoPtrValue.ptr1:	pointer to the array name Tcl_Obj, or NULL if it is a
 *			scalar variable
 *   twoPtrValue.ptr2:	pointer to the element name string (owned by this
 *			Tcl_Obj), or NULL if it is a scalar variable
 */

var _localVarNameType = TTcl_ObjType{
	Fname: __ccgo_ts + 68893,
}

func init() {
	p := unsafe.Pointer(&_localVarNameType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_FreeLocalVarName)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_DupLocalVarName)
}

var _parsedVarNameType = TTcl_ObjType{
	Fname: __ccgo_ts + 68906,
}

func init() {
	p := unsafe.Pointer(&_parsedVarNameType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_FreeParsedVarName)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_DupParsedVarName)
}

func XTclVarHashCreateVar(tls *libc.TLS, tablePtr uintptr, key uintptr, newPtr uintptr) (r uintptr) {
	var _objPtr, keyPtr, varPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _, _ = _objPtr, keyPtr, varPtr, v1, v2
	keyPtr = XTcl_NewStringObj(tls, key, int64(-int32(1)))
	(*TTcl_Obj)(unsafe.Pointer(keyPtr)).FrefCount++
	varPtr = _VarHashCreateVar1(tls, tablePtr, keyPtr, newPtr)
	_objPtr = keyPtr
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return varPtr
}

func _LocateArray(tls *libc.TLS, interp uintptr, name uintptr, varPtrPtr uintptr, isArrayPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var varPtr uintptr
	var _ /* arrayPtr at bp+0 */ uintptr
	_ = varPtr
	varPtr = XTclObjLookupVarEx(tls, interp, name, libc.UintptrFromInt32(0), 0, uintptr(0), 0, 0, bp)
	if XTclCheckArrayTraces(tls, interp, varPtr, *(*uintptr)(unsafe.Pointer(bp)), name, -int32(1)) == int32(TCL_ERROR) {
		return int32(TCL_ERROR)
	}
	if varPtrPtr != 0 {
		*(*uintptr)(unsafe.Pointer(varPtrPtr)) = varPtr
	}
	if isArrayPtr != 0 {
		*(*int32)(unsafe.Pointer(isArrayPtr)) = libc.BoolInt32(varPtr != 0 && !(*(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0)) && (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_ARRAY) != 0)
	}
	return TCL_OK
}

func _NotArrayError(tls *libc.TLS, interp uintptr, name uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var nameStr, v1 uintptr
	_, _ = nameStr, v1
	if (*TTcl_Obj)(unsafe.Pointer(name)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(name)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, name, libc.UintptrFromInt32(0))
	}
	nameStr = v1
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+68920, libc.VaList(bp+8, nameStr)))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+32306, nameStr, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * TclCleanupVar --
 *
 *	This function is called when it looks like it may be OK to free up a
 *	variable's storage. If the variable is in a hashtable, its Var
 *	structure and hash table entry will be freed along with those of its
 *	containing array, if any. This function is called, for example, when
 *	a trace on a variable deletes a variable.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	If the variable (or its containing array) really is dead and in a
 *	hashtable, then its Var structure, and possibly its hash table entry,
 *	is freed up.
 *
 *----------------------------------------------------------------------
 */

func _CleanupVar(tls *libc.TLS, varPtr uintptr, arrayPtr uintptr) {
	/* Array that contains the variable, or NULL
	 * if this variable isn't an array element. */
	if *(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0) && (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 && !((*TVar)(unsafe.Pointer(varPtr)).Fflags&(libc.Int32FromInt32(VAR_TRACED_READ)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_TRACED_ARRAY)|libc.Int32FromInt32(VAR_TRACED_UNSET)) != 0) && (*TVarInHash)(unsafe.Pointer(varPtr)).FrefCount == libc.BoolInt64(!((*TVar)(unsafe.Pointer(varPtr)).Fflags&libc.Int32FromInt32(VAR_DEAD_HASH) != 0)) {
		if (*TVarInHash)(unsafe.Pointer(varPtr)).FrefCount == 0 {
			XTclpFree(tls, varPtr)
		} else {
			XTcl_DeleteHashEntry(tls, varPtr+24)
		}
	}
	if arrayPtr != libc.UintptrFromInt32(0) && *(*uintptr)(unsafe.Pointer(arrayPtr + 8)) == libc.UintptrFromInt32(0) && (*TVar)(unsafe.Pointer(arrayPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 && !((*TVar)(unsafe.Pointer(arrayPtr)).Fflags&(libc.Int32FromInt32(VAR_TRACED_READ)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_TRACED_ARRAY)|libc.Int32FromInt32(VAR_TRACED_UNSET)) != 0) && (*TVarInHash)(unsafe.Pointer(arrayPtr)).FrefCount == libc.BoolInt64(!((*TVar)(unsafe.Pointer(arrayPtr)).Fflags&libc.Int32FromInt32(VAR_DEAD_HASH) != 0)) {
		if (*TVarInHash)(unsafe.Pointer(arrayPtr)).FrefCount == 0 {
			XTclpFree(tls, arrayPtr)
		} else {
			XTcl_DeleteHashEntry(tls, arrayPtr+24)
		}
	}
}

func XTclCleanupVar(tls *libc.TLS, varPtr uintptr, arrayPtr uintptr) {
	/* Array that contains the variable, or NULL
	 * if this variable isn't an array element. */
	_CleanupVar(tls, varPtr, arrayPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * TclLookupVar --
 *
 *	This function is used to locate a variable given its name(s). It has
 *	been mostly superseded by TclObjLookupVar, it is now only used by the
 *	trace code. It is kept in tcl9.0 mainly because it is in the internal
 *	stubs table, so that some extension may be calling it.
 *
 * Results:
 *	The return value is a pointer to the variable structure indicated by
 *	part1 and part2, or NULL if the variable couldn't be found. If the
 *	variable is found, *arrayPtrPtr is filled in with the address of the
 *	variable structure for the array that contains the variable (or NULL
 *	if the variable is a scalar). If the variable can't be found and
 *	either createPart1 or createPart2 are 1, a new as-yet-undefined
 *	(VAR_UNDEFINED) variable structure is created, entered into a hash
 *	table, and returned.
 *
 *	If the variable isn't found and creation wasn't specified, or some
 *	other error occurs, NULL is returned and an error message is left in
 *	the interp's result if TCL_LEAVE_ERR_MSG is set in flags.
 *
 *	Note: it's possible for the variable returned to be VAR_UNDEFINED even
 *	if createPart1 or createPart2 are 1 (these only cause the hash table
 *	entry or array to be created). For example, the variable might be a
 *	global that has been unset but is still referenced by a procedure, or
 *	a variable that has been unset but it only being kept in existence (if
 *	VAR_UNDEFINED) by a trace.
 *
 * Side effects:
 *	New hashtable entries may be created if createPart1 or createPart2
 *	are 1.
 *
 *----------------------------------------------------------------------
 */

func XTclLookupVar(tls *libc.TLS, interp uintptr, part1 uintptr, part2 uintptr, flags int32, msg uintptr, createPart1 int32, createPart2 int32, arrayPtrPtr uintptr) (r uintptr) {
	/* If the name refers to an element of an
	 * array, *arrayPtrPtr gets filled in with
	 * address of array variable. Otherwise this
	 * is set to NULL. */
	var cachePtr, part1Ptr, varPtr, v2 uintptr
	var v1 TTcl_Size
	var v3 bool
	_, _, _, _, _, _ = cachePtr, part1Ptr, varPtr, v1, v2, v3
	part1Ptr = XTcl_NewStringObj(tls, part1, int64(-int32(1)))
	if createPart1 != 0 {
		(*TTcl_Obj)(unsafe.Pointer(part1Ptr)).FrefCount++
	}
	varPtr = XTclObjLookupVar(tls, interp, part1Ptr, part2, flags, msg, createPart1, createPart2, arrayPtrPtr)
	v2 = part1Ptr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if !(v1 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(part1Ptr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(part1Ptr)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(part1Ptr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(part1Ptr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(part1Ptr)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(part1Ptr)).Flength = int64(-libc.Int32FromInt32(1))
			if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, part1Ptr)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(part1Ptr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = part1Ptr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, part1Ptr)
		}
	}
	return varPtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclObjLookupVar, TclObjLookupVarEx --
 *
 *	This function is used by virtually all of the variable code to locate
 *	a variable given its name(s). The parsing into array/element
 *	components and (if possible) the lookup results are cached in
 *	part1Ptr, which is converted to one of the varNameTypes.
 *
 * Results:
 *	The return value is a pointer to the variable structure indicated by
 *	part1Ptr and part2, or NULL if the variable couldn't be found. If *
 *	the variable is found, *arrayPtrPtr is filled with the address of the
 *	variable structure for the array that contains the variable (or NULL
 *	if the variable is a scalar). If the variable can't be found and
 *	either createPart1 or createPart2 are 1, a new as-yet-undefined
 *	(VAR_UNDEFINED) variable structure is created, entered into a hash
 *	table, and returned.
 *
 *	If the variable isn't found and creation wasn't specified, or some
 *	other error occurs, NULL is returned and an error message is left in
 *	the interp's result if TCL_LEAVE_ERR_MSG is set in flags.
 *
 *	Note: it's possible for the variable returned to be VAR_UNDEFINED even
 *	if createPart1 or createPart2 are 1 (these only cause the hash table
 *	entry or array to be created). For example, the variable might be a
 *	global that has been unset but is still referenced by a procedure, or
 *	a variable that has been unset but it only being kept in existence (if
 *	VAR_UNDEFINED) by a trace.
 *
 * Side effects:
 *	New hashtable entries may be created if createPart1 or createPart2
 *	are 1. The object part1Ptr is converted to one of localVarNameType
 *	or parsedVarNameType and caches as much of the lookup as it can.
 *	When createPart1 is 1, callers must IncrRefCount part1Ptr if they
 *	plan to DecrRefCount it.
 *
 *----------------------------------------------------------------------
 */

func XTclObjLookupVar(tls *libc.TLS, interp uintptr, part1Ptr uintptr, part2 uintptr, flags int32, msg uintptr, createPart1 int32, createPart2 int32, arrayPtrPtr uintptr) (r uintptr) {
	/* If the name refers to an element of an
	 * array, *arrayPtrPtr gets filled in with
	 * address of array variable. Otherwise this
	 * is set to NULL. */
	var _objPtr, part2Ptr, resPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _, _ = _objPtr, part2Ptr, resPtr, v1, v2
	part2Ptr = libc.UintptrFromInt32(0)
	if part2 != 0 {
		part2Ptr = XTcl_NewStringObj(tls, part2, int64(-int32(1)))
		if createPart2 != 0 {
			(*TTcl_Obj)(unsafe.Pointer(part2Ptr)).FrefCount++
		}
	}
	resPtr = XTclObjLookupVarEx(tls, interp, part1Ptr, part2Ptr, flags, msg, createPart1, createPart2, arrayPtrPtr)
	if part2Ptr != 0 {
		_objPtr = part2Ptr
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	return resPtr
}

// C documentation
//
//	/*
//	 *	When createPart1 is 1, callers must IncrRefCount part1Ptr if they
//	 *	plan to DecrRefCount it.
//	 *	When createPart2 is 1, callers must IncrRefCount part2Ptr if they
//	 *	plan to DecrRefCount it.
//	 */
func XTclObjLookupVarEx(tls *libc.TLS, interp uintptr, part1Ptr uintptr, part2Ptr uintptr, flags int32, msg uintptr, createPart1 int32, createPart2 int32, arrayPtrPtr uintptr) (r uintptr) {
	bp := tls.Alloc(160)
	defer tls.Free(160) /* If the name refers to an element of an
	 * array, *arrayPtrPtr gets filled in with
	 * address of array variable. Otherwise this
	 * is set to NULL. */
	var arrayPtr, cachedNamePtr, checkNamePtr, elem, iPtr, irPtr, irPtr1, namePtr, part1, part2, ptr, ptr1, ptr11, ptr12, ptr2, ptr21, ptr22, varFramePtr, varPtr, v1, v2, v4, v5, v6, v7, v8 uintptr
	var localIndex TTcl_Size
	var parsed int32
	var v3 int64
	var _ /* errMsg at bp+0 */ uintptr
	var _ /* index at bp+8 */ int32
	var _ /* ir at bp+24 */ TTcl_ObjInternalRep
	var _ /* ir at bp+40 */ TTcl_ObjInternalRep
	var _ /* ir at bp+56 */ TTcl_ObjInternalRep
	var _ /* ir at bp+72 */ TTcl_ObjInternalRep
	var _ /* ir at bp+88 */ TTcl_ObjInternalRep
	var _ /* len at bp+16 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = arrayPtr, cachedNamePtr, checkNamePtr, elem, iPtr, irPtr, irPtr1, localIndex, namePtr, parsed, part1, part2, ptr, ptr1, ptr11, ptr12, ptr2, ptr21, ptr22, varFramePtr, varPtr, v1, v2, v3, v4, v5, v6, v7, v8
	iPtr = interp
	varFramePtr = (*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr /* Points to the variable's in-frame Var
	 * structure. */
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	parsed = 0
	*(*uintptr)(unsafe.Pointer(arrayPtrPtr)) = libc.UintptrFromInt32(0)
	goto restart
restart:
	;
	if (*TTcl_Obj)(unsafe.Pointer(part1Ptr)).FtypePtr == uintptr(unsafe.Pointer(&_localVarNameType)) {
		v1 = part1Ptr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	namePtr = v2
	if irPtr != 0 {
		v3 = int64((*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr2)
	} else {
		v3 = int64(-libc.Int32FromInt32(1))
	}
	localIndex = v3
	if localIndex >= 0 {
		if (*TCallFrame)(unsafe.Pointer(varFramePtr)).FisProcCallFrame&int32(FRAME_IS_PROC) != 0 && !(flags&(libc.Int32FromInt32(TCL_GLOBAL_ONLY)|libc.Int32FromInt32(TCL_NAMESPACE_ONLY)) != 0) && localIndex < (*TCallFrame)(unsafe.Pointer(varFramePtr)).FnumCompiledLocals {
			/*
			 * Use the cached index if the names coincide.
			 */
			checkNamePtr = *(*uintptr)(unsafe.Pointer((*TCallFrame)(unsafe.Pointer(varFramePtr)).FlocalCachePtr + 16 + uintptr(localIndex)*8))
			if !(namePtr != 0) && checkNamePtr == part1Ptr || namePtr != 0 && checkNamePtr == namePtr {
				varPtr = (*TCallFrame)(unsafe.Pointer(varFramePtr)).FcompiledLocals + uintptr(localIndex)*16
				goto donePart1
			}
		}
		goto doneParsing
	}
	/*
	 * If part1Ptr is a parsedVarNameType, retrieve the preparsed parts.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(part1Ptr)).FtypePtr == uintptr(unsafe.Pointer(&_parsedVarNameType)) {
		v4 = part1Ptr + 32
	} else {
		v4 = libc.UintptrFromInt32(0)
	}
	irPtr1 = v4
	parsed = libc.BoolInt32(irPtr1 != libc.UintptrFromInt32(0))
	if irPtr1 != 0 {
		v5 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr1))).Fptr1
	} else {
		v5 = libc.UintptrFromInt32(0)
	}
	arrayPtr = v5
	if irPtr1 != 0 {
		v6 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr1))).Fptr2
	} else {
		v6 = libc.UintptrFromInt32(0)
	}
	elem = v6
	if parsed != 0 && arrayPtr != 0 {
		if part2Ptr != libc.UintptrFromInt32(0) {
			/*
			 * ERROR: part1Ptr is already an array element, cannot specify
			 * a part2.
			 */
			if flags&int32(TCL_LEAVE_ERR_MSG) != 0 {
				XTclObjVarErrMsg(tls, interp, part1Ptr, part2Ptr, msg, uintptr(unsafe.Pointer(&_NOSUCHVAR)), -int32(1))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+112, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+68940, libc.UintptrFromInt32(0)))
			}
			return libc.UintptrFromInt32(0)
		}
		part2Ptr = elem
		part1Ptr = arrayPtr
		goto restart
	}
	if !(parsed != 0) {
		if (*TTcl_Obj)(unsafe.Pointer(part1Ptr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = (*TTcl_Obj)(unsafe.Pointer(part1Ptr)).Flength
			v7 = (*TTcl_Obj)(unsafe.Pointer(part1Ptr)).Fbytes
		} else {
			v7 = XTcl_GetStringFromObj(tls, part1Ptr, bp+16)
		}
		part1 = v7
		if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) > int64(1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(part1 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 16))-int64(1))))) == int32(')') {
			part2 = libc.Xstrchr(tls, part1, int32('('))
			if part2 != 0 {
				if part2Ptr != libc.UintptrFromInt32(0) {
					if flags&int32(TCL_LEAVE_ERR_MSG) != 0 {
						XTclObjVarErrMsg(tls, interp, part1Ptr, part2Ptr, msg, uintptr(unsafe.Pointer(&_NEEDARRAY)), -int32(1))
						XTcl_SetErrorCode(tls, interp, libc.VaList(bp+112, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+68940, libc.UintptrFromInt32(0)))
					}
					return libc.UintptrFromInt32(0)
				}
				arrayPtr = XTcl_NewStringObj(tls, part1, int64(part2)-int64(part1))
				part2Ptr = XTcl_NewStringObj(tls, part2+uintptr(1), *(*TTcl_Size)(unsafe.Pointer(bp + 16))-(int64(part2)-int64(part1))-int64(2))
				ptr11 = arrayPtr
				ptr21 = part2Ptr
				if ptr11 != 0 {
					(*TTcl_Obj)(unsafe.Pointer(ptr11)).FrefCount++
				}
				if ptr21 != 0 {
					(*TTcl_Obj)(unsafe.Pointer(ptr21)).FrefCount++
				}
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(bp + 24))).Fptr1 = ptr11
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(bp + 24))).Fptr2 = ptr21
				XTcl_StoreInternalRep(tls, part1Ptr, uintptr(unsafe.Pointer(&_parsedVarNameType)), bp+24)
				part1Ptr = arrayPtr
			}
		}
	}
	goto doneParsing
doneParsing:
	;
	/*
	 * part1Ptr is not an array element; look it up, and convert it to one of
	 * the cached types if possible.
	 */
	varPtr = XTclLookupSimpleVar(tls, interp, part1Ptr, flags, createPart1, bp, bp+8)
	if varPtr == libc.UintptrFromInt32(0) {
		if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) && flags&int32(TCL_LEAVE_ERR_MSG) != 0 {
			XTclObjVarErrMsg(tls, interp, part1Ptr, part2Ptr, msg, *(*uintptr)(unsafe.Pointer(bp)), -int32(1))
			if (*TTcl_Obj)(unsafe.Pointer(part1Ptr)).Fbytes != 0 {
				v8 = (*TTcl_Obj)(unsafe.Pointer(part1Ptr)).Fbytes
			} else {
				v8 = XTcl_GetStringFromObj(tls, part1Ptr, libc.UintptrFromInt32(0))
			}
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+112, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+68940, v8, libc.UintptrFromInt32(0)))
		}
		return libc.UintptrFromInt32(0)
	}
	/*
	 * Cache the newly found variable if possible.
	 */
	if *(*int32)(unsafe.Pointer(bp + 8)) >= 0 {
		/*
		 * An indexed local variable.
		 */
		cachedNamePtr = *(*uintptr)(unsafe.Pointer((*TCallFrame)(unsafe.Pointer(varFramePtr)).FlocalCachePtr + 16 + uintptr(*(*int32)(unsafe.Pointer(bp + 8)))*8))
		if part1Ptr == cachedNamePtr {
			ptr = libc.UintptrFromInt32(0)
			if ptr != 0 {
				(*TTcl_Obj)(unsafe.Pointer(ptr)).FrefCount++
			}
			(*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(bp + 40))).Fptr1 = ptr
			(*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(bp + 40))).Fptr2 = uintptr(int64(*(*int32)(unsafe.Pointer(bp + 8))))
			XTcl_StoreInternalRep(tls, part1Ptr, uintptr(unsafe.Pointer(&_localVarNameType)), bp+40)
		} else {
			/*
			 * [80304238ac] Trickiness here.  We will store and incr the
			 * refcount on cachedNamePtr.  Trouble is that it's possible
			 * (see test var-22.1) for cachedNamePtr to have an internalrep
			 * that contains a stored and refcounted part1Ptr.  This
			 * would be a reference cycle which leads to a memory leak.
			 *
			 * The solution here is to wipe away all internalrep(s) in
			 * cachedNamePtr and leave it as string only.  This is
			 * radical and destructive, so a better idea would be welcome.
			 */
			/*
			 * Firstly set cached local var reference (avoid free before set,
			 * see [45b9faf103f2])
			 */
			ptr1 = cachedNamePtr
			if ptr1 != 0 {
				(*TTcl_Obj)(unsafe.Pointer(ptr1)).FrefCount++
			}
			(*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(bp + 56))).Fptr1 = ptr1
			(*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(bp + 56))).Fptr2 = uintptr(int64(*(*int32)(unsafe.Pointer(bp + 8))))
			XTcl_StoreInternalRep(tls, part1Ptr, uintptr(unsafe.Pointer(&_localVarNameType)), bp+56)
			/* Then wipe it */
			if (*TTcl_Obj)(unsafe.Pointer(cachedNamePtr)).FtypePtr != libc.UintptrFromInt32(0) {
				if (*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(cachedNamePtr)).FtypePtr)).FfreeIntRepProc != libc.UintptrFromInt32(0) {
					(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(cachedNamePtr)).FtypePtr)).FfreeIntRepProc})))(tls, cachedNamePtr)
				}
				(*TTcl_Obj)(unsafe.Pointer(cachedNamePtr)).FtypePtr = libc.UintptrFromInt32(0)
			}
			/*
			 * Now go ahead and convert it to the "localVarName" type,
			 * since we suspect at least some use of the value as a
			 * varname and we want to resolve it quickly.
			 */
			ptr2 = libc.UintptrFromInt32(0)
			if ptr2 != 0 {
				(*TTcl_Obj)(unsafe.Pointer(ptr2)).FrefCount++
			}
			(*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(bp + 72))).Fptr1 = ptr2
			(*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(bp + 72))).Fptr2 = uintptr(int64(*(*int32)(unsafe.Pointer(bp + 8))))
			XTcl_StoreInternalRep(tls, cachedNamePtr, uintptr(unsafe.Pointer(&_localVarNameType)), bp+72)
		}
	} else {
		/*
		 * At least mark part1Ptr as already parsed.
		 */
		ptr12 = libc.UintptrFromInt32(0)
		ptr22 = libc.UintptrFromInt32(0)
		if ptr12 != 0 {
			(*TTcl_Obj)(unsafe.Pointer(ptr12)).FrefCount++
		}
		if ptr22 != 0 {
			(*TTcl_Obj)(unsafe.Pointer(ptr22)).FrefCount++
		}
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(bp + 88))).Fptr1 = ptr12
		(*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(bp + 88))).Fptr2 = ptr22
		XTcl_StoreInternalRep(tls, part1Ptr, uintptr(unsafe.Pointer(&_parsedVarNameType)), bp+88)
	}
	goto donePart1
donePart1:
	;
	for (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_LINK) != 0 {
		varPtr = *(*uintptr)(unsafe.Pointer(varPtr + 8))
	}
	if part2Ptr != libc.UintptrFromInt32(0) {
		/*
		 * Array element sought: look it up.
		 */
		*(*uintptr)(unsafe.Pointer(arrayPtrPtr)) = varPtr
		varPtr = XTclLookupArrayElement(tls, interp, part1Ptr, part2Ptr, flags, msg, createPart1, createPart2, varPtr, -int32(1))
	}
	return varPtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclLookupSimpleVar --
 *
 *	This function is used by to locate a simple variable (i.e., not an
 *	array element) given its name.
 *
 * Results:
 *	The return value is a pointer to the variable structure indicated by
 *	varName, or NULL if the variable couldn't be found. If the variable
 *	can't be found and create is 1, a new as-yet-undefined (VAR_UNDEFINED)
 *	variable structure is created, entered into a hash table, and
 *	returned.
 *
 *	If the current CallFrame corresponds to a proc and the variable found
 *	is one of the compiledLocals, its index is placed in *indexPtr.
 *	Otherwise, *indexPtr will be set to (according to the needs of
 *	TclObjLookupVar):
 *	    -1 a global reference
 *	    -2 a reference to a namespace variable
 *	    -3 a non-cacheable reference, i.e., one of:
 *		. non-indexed local var
 *		. a reference of unknown origin;
 *		. resolution by a namespace or interp resolver
 *
 *	If the variable isn't found and creation wasn't specified, or some
 *	other error occurs, NULL is returned and the corresponding error
 *	message is left in *errMsgPtr.
 *
 *	Note: it's possible for the variable returned to be VAR_UNDEFINED even
 *	if create is 1 (this only causes the hash table entry to be created).
 *	For example, the variable might be a global that has been unset but is
 *	still referenced by a procedure, or a variable that has been unset but
 *	it only being kept in existence (if VAR_UNDEFINED) by a trace.
 *
 * Side effects:
 *	A new hashtable entry may be created if create is 1.
 *	Callers must Incr varNamePtr if they plan to Decr it if create is 1.
 *
 *----------------------------------------------------------------------
 */

func XTclLookupSimpleVar(tls *libc.TLS, interp uintptr, varNamePtr uintptr, flags int32, create int32, errMsgPtr uintptr, indexPtr uintptr) (r uintptr) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var cxtNsPtr, iPtr, localNameStr, objPtr, objPtrPtr, resPtr, tablePtr, tailPtr, varFramePtr, varName, varPtr, v1, v3 uintptr
	var i, localCt TTcl_Size
	var lookGlobal, result int32
	var _ /* dummy1Ptr at bp+16 */ uintptr
	var _ /* dummy2Ptr at bp+24 */ uintptr
	var _ /* isNew at bp+32 */ int32
	var _ /* localLen at bp+56 */ TTcl_Size
	var _ /* tail at bp+48 */ uintptr
	var _ /* var at bp+0 */ TTcl_Var
	var _ /* varLen at bp+40 */ TTcl_Size
	var _ /* varNsPtr at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cxtNsPtr, i, iPtr, localCt, localNameStr, lookGlobal, objPtr, objPtrPtr, resPtr, result, tablePtr, tailPtr, varFramePtr, varName, varPtr, v1, v3
	iPtr = interp
	varFramePtr = (*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr
	if (*TTcl_Obj)(unsafe.Pointer(varNamePtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = (*TTcl_Obj)(unsafe.Pointer(varNamePtr)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(varNamePtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, varNamePtr, bp+40)
	}
	varName = v1
	varPtr = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(bp + 8)) = libc.UintptrFromInt32(0) /* Set non-NULL if a nonlocal variable. */
	*(*int32)(unsafe.Pointer(indexPtr)) = -int32(3)
	if flags&int32(TCL_GLOBAL_ONLY) != 0 {
		cxtNsPtr = (*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr
	} else {
		cxtNsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FnsPtr
	}
	/*
	 * If this namespace has a variable resolver, then give it first crack at
	 * the variable resolution. It may return a Tcl_Var value, it may signal
	 * to continue onward, or it may signal an error.
	 */
	if ((*TNamespace)(unsafe.Pointer(cxtNsPtr)).FvarResProc != libc.UintptrFromInt32(0) || (*TInterp)(unsafe.Pointer(iPtr)).FresolverPtr != libc.UintptrFromInt32(0)) && !(flags&libc.Int32FromInt32(TCL_AVOID_RESOLVERS) != 0) {
		resPtr = (*TInterp)(unsafe.Pointer(iPtr)).FresolverPtr
		if (*TNamespace)(unsafe.Pointer(cxtNsPtr)).FvarResProc != 0 {
			result = (*(*func(*libc.TLS, uintptr, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TNamespace)(unsafe.Pointer(cxtNsPtr)).FvarResProc})))(tls, interp, varName, cxtNsPtr, flags, bp)
		} else {
			result = int32(TCL_CONTINUE)
		}
		for result == int32(TCL_CONTINUE) && resPtr != 0 {
			if (*TResolverScheme)(unsafe.Pointer(resPtr)).FvarResProc != 0 {
				result = (*(*func(*libc.TLS, uintptr, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TResolverScheme)(unsafe.Pointer(resPtr)).FvarResProc})))(tls, interp, varName, cxtNsPtr, flags, bp)
			}
			resPtr = (*TResolverScheme)(unsafe.Pointer(resPtr)).FnextPtr
		}
		if result == TCL_OK {
			return *(*TTcl_Var)(unsafe.Pointer(bp))
		} else {
			if result != int32(TCL_CONTINUE) {
				return libc.UintptrFromInt32(0)
			}
		}
	}
	/*
	 * Look up varName. Look it up as either a namespace variable or as a
	 * local variable in a procedure call frame (varFramePtr). Interpret
	 * varName as a namespace variable if:
	 *    1) so requested by a TCL_GLOBAL_ONLY or TCL_NAMESPACE_ONLY flag,
	 *    2) there is no active frame (we're at the global :: scope),
	 *    3) the active frame was pushed to define the namespace context for a
	 *	     "namespace eval" or "namespace inscope" command,
	 *    4) the name has namespace qualifiers ("::"s).
	 * Otherwise, if varName is a local variable, search first in the frame's
	 * array of compiler-allocated local variables, then in its hashtable for
	 * runtime-created local variables.
	 *
	 * If create and the variable isn't found, create the variable and, if
	 * necessary, create varFramePtr's local var hashtable.
	 */
	if flags&(libc.Int32FromInt32(TCL_GLOBAL_ONLY)|libc.Int32FromInt32(TCL_NAMESPACE_ONLY)) != 0 || !((*TCallFrame)(unsafe.Pointer(varFramePtr)).FisProcCallFrame&libc.Int32FromInt32(FRAME_IS_PROC) != 0) || libc.Xstrstr(tls, varName, __ccgo_ts+7650) != libc.UintptrFromInt32(0) {
		lookGlobal = libc.BoolInt32(flags&int32(TCL_GLOBAL_ONLY) != 0 || cxtNsPtr == (*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(varName))) == int32(':') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(varName + 1))) == int32(':'))
		if lookGlobal != 0 {
			*(*int32)(unsafe.Pointer(indexPtr)) = -int32(1)
			flags = (flags | int32(TCL_GLOBAL_ONLY)) & ^libc.Int32FromInt32(TCL_NAMESPACE_ONLY)
		} else {
			flags = flags | int32(TCL_NAMESPACE_ONLY)
			*(*int32)(unsafe.Pointer(indexPtr)) = -int32(2)
		}
		/*
		 * Don't pass TCL_LEAVE_ERR_MSG, we may yet create the variable, or
		 * otherwise generate our own error!
		 */
		varPtr = _ObjFindNamespaceVar(tls, interp, varNamePtr, cxtNsPtr, (flags|int32(TCL_AVOID_RESOLVERS)) & ^libc.Int32FromInt32(TCL_LEAVE_ERR_MSG))
		if varPtr == libc.UintptrFromInt32(0) {
			if !(create != 0) { /* Var wasn't found and not to create it. */
				*(*uintptr)(unsafe.Pointer(errMsgPtr)) = uintptr(unsafe.Pointer(&_NOSUCHVAR))
				return libc.UintptrFromInt32(0)
			}
			/*
			 * Var wasn't found so create it.
			 */
			XTclGetNamespaceForQualName(tls, interp, varName, cxtNsPtr, flags, bp+8, bp+16, bp+24, bp+48)
			if *(*uintptr)(unsafe.Pointer(bp + 8)) == libc.UintptrFromInt32(0) {
				*(*uintptr)(unsafe.Pointer(errMsgPtr)) = uintptr(unsafe.Pointer(&_BADNAMESPACE))
				return libc.UintptrFromInt32(0)
			} else {
				if *(*uintptr)(unsafe.Pointer(bp + 48)) == libc.UintptrFromInt32(0) {
					*(*uintptr)(unsafe.Pointer(errMsgPtr)) = uintptr(unsafe.Pointer(&_MISSINGNAME))
					return libc.UintptrFromInt32(0)
				}
			}
			if *(*uintptr)(unsafe.Pointer(bp + 48)) != varName {
				tailPtr = XTcl_NewStringObj(tls, *(*uintptr)(unsafe.Pointer(bp + 48)), int64(-int32(1)))
			} else {
				tailPtr = varNamePtr
			}
			varPtr = _VarHashCreateVar1(tls, *(*uintptr)(unsafe.Pointer(bp + 8))+288, tailPtr, bp+32)
			if lookGlobal != 0 {
				/*
				 * The variable was created starting from the global
				 * namespace: a global reference is returned even if it wasn't
				 * explicitly requested.
				 */
				*(*int32)(unsafe.Pointer(indexPtr)) = -int32(1)
			} else {
				*(*int32)(unsafe.Pointer(indexPtr)) = -int32(2)
			}
		}
	} else { /* Local var: look in frame varFramePtr. */
		localCt = (*TCallFrame)(unsafe.Pointer(varFramePtr)).FnumCompiledLocals
		if localCt > 0 {
			objPtrPtr = (*TCallFrame)(unsafe.Pointer(varFramePtr)).FlocalCachePtr + 16
			i = 0
			for {
				if !(i < localCt) {
					break
				}
				objPtr = *(*uintptr)(unsafe.Pointer(objPtrPtr))
				if objPtr != 0 {
					if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
						*(*TTcl_Size)(unsafe.Pointer(bp + 56)) = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength
						v3 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
					} else {
						v3 = XTcl_GetStringFromObj(tls, objPtr, bp+56)
					}
					localNameStr = v3
					if *(*TTcl_Size)(unsafe.Pointer(bp + 40)) == *(*TTcl_Size)(unsafe.Pointer(bp + 56)) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(varName))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(localNameStr))) && !(libc.Xmemcmp(tls, varName, localNameStr, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 40)))) != 0) {
						*(*int32)(unsafe.Pointer(indexPtr)) = int32(i)
						return (*TCallFrame)(unsafe.Pointer(varFramePtr)).FcompiledLocals + uintptr(i)*16
					}
				}
				goto _2
			_2:
				;
				i++
				objPtrPtr += 8
			}
		}
		tablePtr = (*TCallFrame)(unsafe.Pointer(varFramePtr)).FvarTablePtr
		if create != 0 {
			if tablePtr == libc.UintptrFromInt32(0) {
				tablePtr = XTcl_Alloc(tls, uint64(120))
				XTclInitVarHashTable(tls, tablePtr, libc.UintptrFromInt32(0))
				(*TTclVarHashTable)(unsafe.Pointer(tablePtr)).FarrayPtr = varPtr
				(*TCallFrame)(unsafe.Pointer(varFramePtr)).FvarTablePtr = tablePtr
			}
			varPtr = _VarHashCreateVar1(tls, tablePtr, varNamePtr, bp+32)
		} else {
			varPtr = libc.UintptrFromInt32(0)
			if tablePtr != libc.UintptrFromInt32(0) {
				varPtr = _VarHashCreateVar1(tls, tablePtr, varNamePtr, libc.UintptrFromInt32(0))
			}
			if varPtr == libc.UintptrFromInt32(0) {
				*(*uintptr)(unsafe.Pointer(errMsgPtr)) = uintptr(unsafe.Pointer(&_NOSUCHVAR))
			}
		}
	}
	return varPtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclLookupArrayElement --
 *
 *	This function is used to locate a variable which is in an array's
 *	hashtable given a pointer to the array's Var structure and the
 *	element's name.
 *
 * Results:
 *	The return value is a pointer to the variable structure , or NULL if
 *	the variable couldn't be found.
 *
 *	If arrayPtr points to a variable that isn't an array and createPart1
 *	is 1, the corresponding variable will be converted to an array.
 *	Otherwise, NULL is returned and an error message is left in the
 *	interp's result if TCL_LEAVE_ERR_MSG is set in flags.
 *
 *	If the variable is not found and createPart2 is 1, the variable is
 *	created. Otherwise, NULL is returned and an error message is left in
 *	the interp's result if TCL_LEAVE_ERR_MSG is set in flags.
 *
 *	Note: it's possible for the variable returned to be VAR_UNDEFINED even
 *	if createPart1 or createPart2 are 1 (these only cause the hash table
 *	entry or array to be created). For example, the variable might be a
 *	global that has been unset but is still referenced by a procedure, or
 *	a variable that has been unset but it only being kept in existence (if
 *	VAR_UNDEFINED) by a trace.
 *
 * Side effects:
 *	The variable at arrayPtr may be converted to be an array if
 *	createPart1 is 1. A new hashtable entry may be created if createPart2
 *	is 1.
 *	When createElem is 1, callers must incr elNamePtr if they plan
 *	to decr it.
 *
 *----------------------------------------------------------------------
 */

func XTclLookupArrayElement(tls *libc.TLS, interp uintptr, arrayNamePtr uintptr, elNamePtr uintptr, flags int32, msg uintptr, createArray int32, createElem int32, arrayPtr uintptr, index int32) (r uintptr) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* If >=0, the index of the local array. */
	var varPtr, v1, v2, v3, v4, v5, v6, v7 uintptr
	var _ /* isNew at bp+0 */ int32
	_, _, _, _, _, _, _, _ = varPtr, v1, v2, v3, v4, v5, v6, v7
	/*
	 * We're dealing with an array element. Make sure the variable is an array
	 * and look up the element (create the element if desired).
	 */
	if *(*uintptr)(unsafe.Pointer(arrayPtr + 8)) == libc.UintptrFromInt32(0) && !((*TVar)(unsafe.Pointer(arrayPtr)).Fflags&libc.Int32FromInt32(VAR_ARRAY_ELEMENT) != 0) {
		if !(createArray != 0) {
			if flags&int32(TCL_LEAVE_ERR_MSG) != 0 {
				XTclObjVarErrMsg(tls, interp, arrayNamePtr, elNamePtr, msg, uintptr(unsafe.Pointer(&_NOSUCHVAR)), index)
				if arrayNamePtr != 0 {
					if (*TTcl_Obj)(unsafe.Pointer(arrayNamePtr)).Fbytes != 0 {
						v2 = (*TTcl_Obj)(unsafe.Pointer(arrayNamePtr)).Fbytes
					} else {
						v2 = XTcl_GetStringFromObj(tls, arrayNamePtr, libc.UintptrFromInt32(0))
					}
					v1 = v2
				} else {
					v1 = libc.UintptrFromInt32(0)
				}
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+68940, v1, libc.UintptrFromInt32(0)))
			}
			return libc.UintptrFromInt32(0)
		}
		/*
		 * Make sure we are not resurrecting a namespace variable from a
		 * deleted namespace!
		 */
		if (*TVar)(unsafe.Pointer(arrayPtr)).Fflags&int32(VAR_DEAD_HASH) != 0 {
			if flags&int32(TCL_LEAVE_ERR_MSG) != 0 {
				XTclObjVarErrMsg(tls, interp, arrayNamePtr, elNamePtr, msg, uintptr(unsafe.Pointer(&_DANGLINGVAR)), index)
				if arrayNamePtr != 0 {
					if (*TTcl_Obj)(unsafe.Pointer(arrayNamePtr)).Fbytes != 0 {
						v4 = (*TTcl_Obj)(unsafe.Pointer(arrayNamePtr)).Fbytes
					} else {
						v4 = XTcl_GetStringFromObj(tls, arrayNamePtr, libc.UintptrFromInt32(0))
					}
					v3 = v4
				} else {
					v3 = libc.UintptrFromInt32(0)
				}
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+68940, v3, libc.UintptrFromInt32(0)))
			}
			return libc.UintptrFromInt32(0)
		}
		XTclInitArrayVar(tls, arrayPtr)
	} else {
		if !((*TVar)(unsafe.Pointer(arrayPtr)).Fflags&libc.Int32FromInt32(VAR_ARRAY) != 0) {
			if flags&int32(TCL_LEAVE_ERR_MSG) != 0 {
				XTclObjVarErrMsg(tls, interp, arrayNamePtr, elNamePtr, msg, uintptr(unsafe.Pointer(&_NEEDARRAY)), index)
				if arrayNamePtr != 0 {
					if (*TTcl_Obj)(unsafe.Pointer(arrayNamePtr)).Fbytes != 0 {
						v6 = (*TTcl_Obj)(unsafe.Pointer(arrayNamePtr)).Fbytes
					} else {
						v6 = XTcl_GetStringFromObj(tls, arrayNamePtr, libc.UintptrFromInt32(0))
					}
					v5 = v6
				} else {
					v5 = libc.UintptrFromInt32(0)
				}
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+68940, v5, libc.UintptrFromInt32(0)))
			}
			return libc.UintptrFromInt32(0)
		}
	}
	if createElem != 0 {
		varPtr = _VarHashCreateVar1(tls, *(*uintptr)(unsafe.Pointer(arrayPtr + 8)), elNamePtr, bp)
		if *(*int32)(unsafe.Pointer(bp)) != 0 {
			if (*TVar)(unsafe.Pointer(arrayPtr)).Fflags&int32(VAR_SEARCH_ACTIVE) != 0 {
				_DeleteSearches(tls, interp, arrayPtr)
			}
			(*TVar)(unsafe.Pointer(varPtr)).Fflags = (*TVar)(unsafe.Pointer(varPtr)).Fflags & ^libc.Int32FromInt32(VAR_ARRAY) | int32(VAR_ARRAY_ELEMENT)
		}
	} else {
		varPtr = _VarHashCreateVar1(tls, *(*uintptr)(unsafe.Pointer(arrayPtr + 8)), elNamePtr, libc.UintptrFromInt32(0))
		if varPtr == libc.UintptrFromInt32(0) {
			if flags&int32(TCL_LEAVE_ERR_MSG) != 0 {
				XTclObjVarErrMsg(tls, interp, arrayNamePtr, elNamePtr, msg, uintptr(unsafe.Pointer(&_NOSUCHELEMENT)), index)
				if (*TTcl_Obj)(unsafe.Pointer(elNamePtr)).Fbytes != 0 {
					v7 = (*TTcl_Obj)(unsafe.Pointer(elNamePtr)).Fbytes
				} else {
					v7 = XTcl_GetStringFromObj(tls, elNamePtr, libc.UintptrFromInt32(0))
				}
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+68948, v7, libc.UintptrFromInt32(0)))
			}
		}
	}
	return varPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetVar2 --
 *
 *	Return the value of a Tcl variable as a string, given a two-part name
 *	consisting of array name and element within array.
 *
 * Results:
 *	The return value points to the current value of the variable given by
 *	part1 and part2 as a string. If the specified variable doesn't exist,
 *	or if there is a clash in array usage, then NULL is returned and a
 *	message will be left in the interp's result if the TCL_LEAVE_ERR_MSG
 *	flag is set. Note: the return value is only valid up until the next
 *	change to the variable; if you depend on the value lasting longer than
 *	that, then make yourself a private copy.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetVar2(tls *libc.TLS, interp uintptr, part1 uintptr, part2 uintptr, flags int32) (r uintptr) {
	/* OR-ed combination of TCL_GLOBAL_ONLY,
	 * TCL_NAMESPACE_ONLY and TCL_LEAVE_ERR_MSG *
	 * bits. */
	var _objPtr, _objPtr1, part1Ptr, part2Ptr, resultPtr, v2, v4, v5 uintptr
	var v1, v3 TTcl_Size
	_, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, part1Ptr, part2Ptr, resultPtr, v1, v2, v3, v4, v5
	part2Ptr = libc.UintptrFromInt32(0)
	part1Ptr = XTcl_NewStringObj(tls, part1, int64(-int32(1)))
	if part2 != 0 {
		part2Ptr = XTcl_NewStringObj(tls, part2, int64(-int32(1)))
		(*TTcl_Obj)(unsafe.Pointer(part2Ptr)).FrefCount++
	}
	resultPtr = XTcl_ObjGetVar2(tls, interp, part1Ptr, part2Ptr, flags)
	_objPtr = part1Ptr
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	if part2Ptr != 0 {
		_objPtr1 = part2Ptr
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
	if resultPtr == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	if (*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes != 0 {
		v5 = (*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes
	} else {
		v5 = XTcl_GetStringFromObj(tls, resultPtr, libc.UintptrFromInt32(0))
	}
	return v5
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetVar2Ex --
 *
 *	Return the value of a Tcl variable as a Tcl object, given a two-part
 *	name consisting of array name and element within array.
 *
 * Results:
 *	The return value points to the current object value of the variable
 *	given by part1Ptr and part2Ptr. If the specified variable doesn't
 *	exist, or if there is a clash in array usage, then NULL is returned
 *	and a message will be left in the interpreter's result if the
 *	TCL_LEAVE_ERR_MSG flag is set.
 *
 * Side effects:
 *	The ref count for the returned object is _not_ incremented to reflect
 *	the returned reference; if you want to keep a reference to the object
 *	you must increment its ref count yourself.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetVar2Ex(tls *libc.TLS, interp uintptr, part1 uintptr, part2 uintptr, flags int32) (r uintptr) {
	/* OR-ed combination of TCL_GLOBAL_ONLY, and
	 * TCL_LEAVE_ERR_MSG bits. */
	var _objPtr, _objPtr1, part1Ptr, part2Ptr, resPtr, v2, v4 uintptr
	var v1, v3 TTcl_Size
	_, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, part1Ptr, part2Ptr, resPtr, v1, v2, v3, v4
	part2Ptr = libc.UintptrFromInt32(0)
	part1Ptr = XTcl_NewStringObj(tls, part1, int64(-int32(1)))
	if part2 != 0 {
		part2Ptr = XTcl_NewStringObj(tls, part2, int64(-int32(1)))
		(*TTcl_Obj)(unsafe.Pointer(part2Ptr)).FrefCount++
	}
	resPtr = XTcl_ObjGetVar2(tls, interp, part1Ptr, part2Ptr, flags)
	_objPtr = part1Ptr
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	if part2Ptr != 0 {
		_objPtr1 = part2Ptr
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
	return resPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ObjGetVar2 --
 *
 *	Return the value of a Tcl variable as a Tcl object, given a two-part
 *	name consisting of array name and element within array.
 *
 * Results:
 *	The return value points to the current object value of the variable
 *	given by part1Ptr and part2Ptr. If the specified variable doesn't
 *	exist, or if there is a clash in array usage, then NULL is returned
 *	and a message will be left in the interpreter's result if the
 *	TCL_LEAVE_ERR_MSG flag is set.
 *
 * Side effects:
 *	The ref count for the returned object is _not_ incremented to reflect
 *	the returned reference; if you want to keep a reference to the object
 *	you must increment its ref count yourself.
 *
 *	Callers must incr part2Ptr if they plan to decr it.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ObjGetVar2(tls *libc.TLS, interp uintptr, part1Ptr uintptr, part2Ptr uintptr, flags int32) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* OR-ed combination of TCL_GLOBAL_ONLY and
	 * TCL_LEAVE_ERR_MSG bits. */
	var varPtr uintptr
	var _ /* arrayPtr at bp+0 */ uintptr
	_ = varPtr
	/*
	 * Filter to pass through only the flags this interface supports.
	 */
	flags &= libc.Int32FromInt32(TCL_GLOBAL_ONLY) | libc.Int32FromInt32(TCL_NAMESPACE_ONLY) | libc.Int32FromInt32(TCL_LEAVE_ERR_MSG)
	varPtr = XTclObjLookupVarEx(tls, interp, part1Ptr, part2Ptr, flags, __ccgo_ts+5552, 0, int32(1), bp)
	if varPtr == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	return XTclPtrGetVarIdx(tls, interp, varPtr, *(*uintptr)(unsafe.Pointer(bp)), part1Ptr, part2Ptr, flags, -int32(1))
}

/*
 *----------------------------------------------------------------------
 *
 * TclPtrGetVar --
 *
 *	Return the value of a Tcl variable as a Tcl object, given the pointers
 *	to the variable's (and possibly containing array's) VAR structure.
 *
 * Results:
 *	The return value points to the current object value of the variable
 *	given by varPtr. If the specified variable doesn't exist, or if there
 *	is a clash in array usage, then NULL is returned and a message will be
 *	left in the interpreter's result if the TCL_LEAVE_ERR_MSG flag is set.
 *
 * Side effects:
 *	The ref count for the returned object is _not_ incremented to reflect
 *	the returned reference; if you want to keep a reference to the object
 *	you must increment its ref count yourself.
 *
 *----------------------------------------------------------------------
 */

func XTclPtrGetVar(tls *libc.TLS, interp uintptr, varPtr TTcl_Var, arrayPtr TTcl_Var, part1Ptr uintptr, part2Ptr uintptr, flags int32) (r uintptr) {
	/* OR-ed combination of TCL_GLOBAL_ONLY, and
	 * TCL_LEAVE_ERR_MSG bits. */
	if varPtr == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+68956, 0)
	}
	if part1Ptr == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+68980, 0)
	}
	return XTclPtrGetVarIdx(tls, interp, varPtr, arrayPtr, part1Ptr, part2Ptr, flags, -int32(1))
}

/*
 *----------------------------------------------------------------------
 *
 * TclPtrGetVarIdx --
 *
 *	Return the value of a Tcl variable as a Tcl object, given the pointers
 *	to the variable's (and possibly containing array's) VAR structure.
 *
 * Results:
 *	The return value points to the current object value of the variable
 *	given by varPtr. If the specified variable doesn't exist, or if there
 *	is a clash in array usage, then NULL is returned and a message will be
 *	left in the interpreter's result if the TCL_LEAVE_ERR_MSG flag is set.
 *
 * Side effects:
 *	The ref count for the returned object is _not_ incremented to reflect
 *	the returned reference; if you want to keep a reference to the object
 *	you must increment its ref count yourself.
 *
 *----------------------------------------------------------------------
 */

func XTclPtrGetVarIdx(tls *libc.TLS, interp uintptr, varPtr uintptr, arrayPtr uintptr, part1Ptr uintptr, part2Ptr uintptr, flags int32, index int32) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Index into the local variable table of the
	 * variable, or -1. Only used when part1Ptr is
	 * NULL. */
	var avhtPtr, iPtr, initialArrayPtr, msg uintptr
	_, _, _, _ = avhtPtr, iPtr, initialArrayPtr, msg
	iPtr = interp
	initialArrayPtr = arrayPtr
	if arrayPtr == libc.UintptrFromInt32(0) && (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 && (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(varPtr)).Fentry.FtablePtr)).FarrayPtr != libc.UintptrFromInt32(0) {
		arrayPtr = (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(varPtr)).Fentry.FtablePtr)).FarrayPtr
	}
	/*
	 * Invoke any read traces that have been set for the variable.
	 */
	if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_TRACED_READ) != 0 || arrayPtr != 0 && (*TVar)(unsafe.Pointer(arrayPtr)).Fflags&int32(VAR_TRACED_READ) != 0 {
		if int32(TCL_ERROR) == XTclObjCallVarTraces(tls, iPtr, arrayPtr, varPtr, part1Ptr, part2Ptr, flags&(libc.Int32FromInt32(TCL_NAMESPACE_ONLY)|libc.Int32FromInt32(TCL_GLOBAL_ONLY))|int32(TCL_TRACE_READS), flags&int32(TCL_LEAVE_ERR_MSG), index) {
			goto errorReturn
		}
	}
	/*
	 * Return the element if it's an existing scalar variable.
	 */
	if !((*TVar)(unsafe.Pointer(varPtr)).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)) != 0) && !(*(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0)) {
		return *(*uintptr)(unsafe.Pointer(varPtr + 8))
	}
	/*
	 * Return the array default value if any.
	 */
	if arrayPtr != 0 && (*TVar)(unsafe.Pointer(arrayPtr)).Fflags&int32(VAR_ARRAY) != 0 && XTclGetArrayDefault(tls, arrayPtr) != 0 {
		return XTclGetArrayDefault(tls, arrayPtr)
	}
	if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_ARRAY_ELEMENT) != 0 && !(arrayPtr != 0) {
		/*
		 * UGLY! Peek inside the implementation of things. This lets us get
		 * the default of an array even when we've been [upvar]ed to just an
		 * element of the array.
		 */
		avhtPtr = (*TVarInHash)(unsafe.Pointer(varPtr)).Fentry.FtablePtr
		if (*TArrayVarHashTable)(unsafe.Pointer(avhtPtr)).FdefaultObj != 0 {
			return (*TArrayVarHashTable)(unsafe.Pointer(avhtPtr)).FdefaultObj
		}
	}
	if flags&int32(TCL_LEAVE_ERR_MSG) != 0 {
		if *(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0) && initialArrayPtr != 0 && !(*(*uintptr)(unsafe.Pointer(initialArrayPtr + 8)) == libc.UintptrFromInt32(0)) {
			msg = uintptr(unsafe.Pointer(&_NOSUCHELEMENT))
		} else {
			if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_ARRAY) != 0 {
				msg = uintptr(unsafe.Pointer(&_ISARRAY))
			} else {
				msg = uintptr(unsafe.Pointer(&_NOSUCHVAR))
			}
		}
		XTclObjVarErrMsg(tls, interp, part1Ptr, part2Ptr, __ccgo_ts+5552, msg, index)
	}
	/*
	 * An error. If the variable doesn't exist anymore and no-one's using it,
	 * then free up the relevant structures and hash table entries.
	 */
	goto errorReturn
errorReturn:
	;
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+69006, __ccgo_ts+68940, libc.UintptrFromInt32(0)))
	if *(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0) {
		XTclCleanupVar(tls, varPtr, arrayPtr)
	}
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetObjCmd --
 *
 *	This function is invoked to process the "set" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result value.
 *
 * Side effects:
 *	A variable's value may be changed.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetObjCmd(tls *libc.TLS, dummy1485 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var varValueObj uintptr
	_ = varValueObj
	if objc == int32(2) {
		varValueObj = XTcl_ObjGetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), int32(TCL_LEAVE_ERR_MSG))
		if varValueObj == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
		XTcl_SetObjResult(tls, interp, varValueObj)
		return TCL_OK
	} else {
		if objc == int32(3) {
			varValueObj = XTcl_ObjSetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + 2*8)), int32(TCL_LEAVE_ERR_MSG))
			if varValueObj == libc.UintptrFromInt32(0) {
				return int32(TCL_ERROR)
			}
			XTcl_SetObjResult(tls, interp, varValueObj)
			return TCL_OK
		} else {
			XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+69011)
			return int32(TCL_ERROR)
		}
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetVar2 --
 *
 *	Given a two-part variable name, which may refer either to a scalar
 *	variable or an element of an array, change the value of the variable.
 *	If the named scalar or array or element doesn't exist then create one.
 *
 * Results:
 *	Returns a pointer to the malloc'ed string which is the character
 *	representation of the variable's new value. The caller must not modify
 *	this string. If the write operation was disallowed because an array
 *	was expected but not found (or vice versa), then NULL is returned; if
 *	the TCL_LEAVE_ERR_MSG flag is set, then an explanatory message will be
 *	left in the interp's result. Note that the returned string may not be
 *	the same as newValue; this is because variable traces may modify the
 *	variable's value.
 *
 * Side effects:
 *	The value of the given variable is set. If either the array or the
 *	entry didn't exist then a new one is created.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetVar2(tls *libc.TLS, interp uintptr, part1 uintptr, part2 uintptr, newValue uintptr, flags int32) (r uintptr) {
	/* Various flags that tell how to set value:
	 * any of TCL_GLOBAL_ONLY, TCL_NAMESPACE_ONLY,
	 * TCL_APPEND_VALUE, TCL_LIST_ELEMENT, or
	 * TCL_LEAVE_ERR_MSG. */
	var varValuePtr, v1 uintptr
	_, _ = varValuePtr, v1
	varValuePtr = XTcl_SetVar2Ex(tls, interp, part1, part2, XTcl_NewStringObj(tls, newValue, int64(-int32(1))), flags)
	if varValuePtr == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	if (*TTcl_Obj)(unsafe.Pointer(varValuePtr)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(varValuePtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, varValuePtr, libc.UintptrFromInt32(0))
	}
	return v1
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetVar2Ex --
 *
 *	Given a two-part variable name, which may refer either to a scalar
 *	variable or an element of an array, change the value of the variable
 *	to a new Tcl object value. If the named scalar or array or element
 *	doesn't exist then create one.
 *
 * Results:
 *	Returns a pointer to the Tcl_Obj holding the new value of the
 *	variable. If the write operation was disallowed because an array was
 *	expected but not found (or vice versa), then NULL is returned; if the
 *	TCL_LEAVE_ERR_MSG flag is set, then an explanatory message will be
 *	left in the interpreter's result. Note that the returned object may
 *	not be the same one referenced by newValuePtr; this is because
 *	variable traces may modify the variable's value.
 *
 * Side effects:
 *	The value of the given variable is set. If either the array or the
 *	entry didn't exist then a new variable is created.
 *
 *	The reference count is decremented for any old value of the variable
 *	and incremented for its new value. If the new value for the variable
 *	is not the same one referenced by newValuePtr (perhaps as a result of
 *	a variable trace), then newValuePtr's ref count is left unchanged by
 *	Tcl_SetVar2Ex. newValuePtr's ref count is also left unchanged if we
 *	are appending it as a string value: that is, if "flags" includes
 *	TCL_APPEND_VALUE but not TCL_LIST_ELEMENT.
 *
 *	The reference count for the returned object is _not_ incremented: if
 *	you want to keep a reference to the object you must increment its ref
 *	count yourself.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetVar2Ex(tls *libc.TLS, interp uintptr, part1 uintptr, part2 uintptr, newValuePtr uintptr, flags int32) (r uintptr) {
	/* Various flags that tell how to set value:
	 * any of TCL_GLOBAL_ONLY, TCL_NAMESPACE_ONLY,
	 * TCL_APPEND_VALUE, TCL_LIST_ELEMENT or
	 * TCL_LEAVE_ERR_MSG. */
	var _objPtr, _objPtr1, part1Ptr, part2Ptr, resPtr, v2, v4 uintptr
	var v1, v3 TTcl_Size
	_, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, part1Ptr, part2Ptr, resPtr, v1, v2, v3, v4
	part2Ptr = libc.UintptrFromInt32(0)
	part1Ptr = XTcl_NewStringObj(tls, part1, int64(-int32(1)))
	(*TTcl_Obj)(unsafe.Pointer(part1Ptr)).FrefCount++
	if part2 != 0 {
		part2Ptr = XTcl_NewStringObj(tls, part2, int64(-int32(1)))
		(*TTcl_Obj)(unsafe.Pointer(part2Ptr)).FrefCount++
	}
	resPtr = XTcl_ObjSetVar2(tls, interp, part1Ptr, part2Ptr, newValuePtr, flags)
	_objPtr = part1Ptr
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	if part2Ptr != 0 {
		_objPtr1 = part2Ptr
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
	return resPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ObjSetVar2 --
 *
 *	This function is the same as Tcl_SetVar2Ex above, except the variable
 *	names are passed in Tcl object instead of strings.
 *
 * Results:
 *	Returns a pointer to the Tcl_Obj holding the new value of the
 *	variable. If the write operation was disallowed because an array was
 *	expected but not found (or vice versa), then NULL is returned; if the
 *	TCL_LEAVE_ERR_MSG flag is set, then an explanatory message will be
 *	left in the interpreter's result. Note that the returned object may
 *	not be the same one referenced by newValuePtr; this is because
 *	variable traces may modify the variable's value.
 *
 * Side effects:
 *	The value of the given variable is set. If either the array or the
 *	entry didn't exist then a new variable is created.
 *	Callers must Incr part1Ptr if they plan to Decr it.
 *	Callers must Incr part2Ptr if they plan to Decr it.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ObjSetVar2(tls *libc.TLS, interp uintptr, part1Ptr uintptr, part2Ptr uintptr, newValuePtr uintptr, flags int32) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Various flags that tell how to set value:
	 * any of TCL_GLOBAL_ONLY, TCL_NAMESPACE_ONLY,
	 * TCL_APPEND_VALUE, TCL_LIST_ELEMENT, or
	 * TCL_LEAVE_ERR_MSG. */
	var _objPtr, varPtr, v2 uintptr
	var v1 TTcl_Size
	var _ /* arrayPtr at bp+0 */ uintptr
	_, _, _, _ = _objPtr, varPtr, v1, v2
	/*
	 * Filter to pass through only the flags this interface supports.
	 */
	flags &= libc.Int32FromInt32(TCL_GLOBAL_ONLY) | libc.Int32FromInt32(TCL_NAMESPACE_ONLY) | libc.Int32FromInt32(TCL_LEAVE_ERR_MSG) | libc.Int32FromInt32(TCL_APPEND_VALUE) | libc.Int32FromInt32(TCL_LIST_ELEMENT)
	varPtr = XTclObjLookupVarEx(tls, interp, part1Ptr, part2Ptr, flags, __ccgo_ts+5383, int32(1), int32(1), bp)
	if varPtr == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(newValuePtr)).FrefCount == 0 {
			_objPtr = newValuePtr
			v2 = _objPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if v1 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
		return libc.UintptrFromInt32(0)
	}
	return XTclPtrSetVarIdx(tls, interp, varPtr, *(*uintptr)(unsafe.Pointer(bp)), part1Ptr, part2Ptr, newValuePtr, flags, -int32(1))
}

/*
 *----------------------------------------------------------------------
 *
 * TclPtrSetVar --
 *
 *	This function is the same as Tcl_SetVar2Ex above, except that it
 *	requires pointers to the variable's Var structs in addition to the
 *	variable names.
 *
 * Results:
 *	Returns a pointer to the Tcl_Obj holding the new value of the
 *	variable. If the write operation was disallowed because an array was
 *	expected but not found (or vice versa), then NULL is returned; if the
 *	TCL_LEAVE_ERR_MSG flag is set, then an explanatory message will be
 *	left in the interpreter's result. Note that the returned object may
 *	not be the same one referenced by newValuePtr; this is because
 *	variable traces may modify the variable's value.
 *
 * Side effects:
 *	The value of the given variable is set. If either the array or the
 *	entry didn't exist then a new variable is created.
 *
 *----------------------------------------------------------------------
 */

func XTclPtrSetVar(tls *libc.TLS, interp uintptr, varPtr TTcl_Var, arrayPtr TTcl_Var, part1Ptr uintptr, part2Ptr uintptr, newValuePtr uintptr, flags int32) (r uintptr) {
	/* OR-ed combination of TCL_GLOBAL_ONLY, and
	 * TCL_LEAVE_ERR_MSG bits. */
	if varPtr == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+68956, 0)
	}
	if part1Ptr == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+68980, 0)
	}
	if newValuePtr == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+69030, 0)
	}
	return XTclPtrSetVarIdx(tls, interp, varPtr, arrayPtr, part1Ptr, part2Ptr, newValuePtr, flags, -int32(1))
}

/*
 *----------------------------------------------------------------------
 *
 * ListAppendInVar, StringAppendInVar --
 *
 *	Support functions for TclPtrSetVarIdx that implement various types of
 *	appending operations.
 *
 * Results:
 *	ListAppendInVar returns a Tcl result code (from the core list append
 *	operation). StringAppendInVar has no return value.
 *
 * Side effects:
 *	The variable or element of the array is updated. This may make the
 *	variable/element exist. Reference counts of values may be updated.
 *
 *----------------------------------------------------------------------
 */

func _ListAppendInVar(tls *libc.TLS, interp uintptr, varPtr uintptr, arrayPtr uintptr, oldValuePtr uintptr, newValuePtr uintptr) (r int32) {
	var cachePtr, cachePtr1, defValuePtr, v3 uintptr
	var v1, v4 bool
	var v2 TTcl_Size
	_, _, _, _, _, _, _ = cachePtr, cachePtr1, defValuePtr, v1, v2, v3, v4
	if oldValuePtr == libc.UintptrFromInt32(0) {
		/*
		 * No previous value. Check for defaults if there's an array we can
		 * ask this of.
		 */
		if arrayPtr != 0 {
			defValuePtr = XTclGetArrayDefault(tls, arrayPtr)
			if defValuePtr != 0 {
				oldValuePtr = XTcl_DuplicateObj(tls, defValuePtr)
			}
		}
		if oldValuePtr == libc.UintptrFromInt32(0) {
			/*
			 * No default. [lappend] semantics say this is like being an empty
			 * string.
			 */
			if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				oldValuePtr = XTclThreadAllocObj(tls)
			} else {
				oldValuePtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(oldValuePtr + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).FtypePtr = libc.UintptrFromInt32(0)
		}
		*(*uintptr)(unsafe.Pointer(varPtr + 8)) = oldValuePtr
		(*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).FrefCount++ /* Since var is referenced. */
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).FrefCount > int64(1) {
			*(*uintptr)(unsafe.Pointer(varPtr + 8)) = XTcl_DuplicateObj(tls, oldValuePtr)
			v3 = oldValuePtr
			v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
			*(*TTcl_Size)(unsafe.Pointer(v3))--
			if !(v2 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).Flength = int64(-libc.Int32FromInt32(1))
					if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
						cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v4 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, oldValuePtr)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(oldValuePtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = oldValuePtr
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, oldValuePtr)
				}
			}
			oldValuePtr = *(*uintptr)(unsafe.Pointer(varPtr + 8))
			(*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).FrefCount++ /* Since var is referenced. */
		}
	}
	return XTcl_ListObjAppendElement(tls, interp, oldValuePtr, newValuePtr)
}

func _StringAppendInVar(tls *libc.TLS, varPtr uintptr, arrayPtr uintptr, oldValuePtr uintptr, newValuePtr uintptr) {
	var _objPtr, _objPtr1, cachePtr, defValuePtr, valuePtr, v2, v4, v7 uintptr
	var v1, v3, v6 TTcl_Size
	var v5 bool
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, defValuePtr, valuePtr, v1, v2, v3, v4, v5, v6, v7
	/*
	 * If there was no previous value, either we use the array's default (if
	 * this is an array with a default at all) or we treat this as a simple
	 * set.
	 */
	if oldValuePtr == libc.UintptrFromInt32(0) {
		if arrayPtr != 0 {
			defValuePtr = XTclGetArrayDefault(tls, arrayPtr)
			if defValuePtr != 0 {
				/*
				 * This is *almost* the same as the shared path below, except
				 * that the original value reference in defValuePtr is not
				 * decremented.
				 */
				valuePtr = XTcl_DuplicateObj(tls, defValuePtr)
				*(*uintptr)(unsafe.Pointer(varPtr + 8)) = valuePtr
				XTclContinuationsCopy(tls, valuePtr, defValuePtr)
				(*TTcl_Obj)(unsafe.Pointer(valuePtr)).FrefCount++
				XTcl_AppendObjToObj(tls, valuePtr, newValuePtr)
				if (*TTcl_Obj)(unsafe.Pointer(newValuePtr)).FrefCount == 0 {
					_objPtr = newValuePtr
					v2 = _objPtr
					v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
					*(*TTcl_Size)(unsafe.Pointer(v2))--
					if v1 <= int64(1) {
						XTclFreeObj(tls, _objPtr)
					}
				}
				return
			}
		}
		*(*uintptr)(unsafe.Pointer(varPtr + 8)) = newValuePtr
		(*TTcl_Obj)(unsafe.Pointer(newValuePtr)).FrefCount++
		return
	}
	/*
	 * We append newValuePtr's bytes but don't change its ref count. Unless
	 * the reference is shared, when we have to duplicate in order to be safe
	 * to modify at all.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).FrefCount > int64(1) { /* Append to copy. */
		*(*uintptr)(unsafe.Pointer(varPtr + 8)) = XTcl_DuplicateObj(tls, oldValuePtr)
		XTclContinuationsCopy(tls, *(*uintptr)(unsafe.Pointer(varPtr + 8)), oldValuePtr)
		v4 = oldValuePtr
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if !(v3 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).Flength = int64(-libc.Int32FromInt32(1))
				if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v5 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, oldValuePtr)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(oldValuePtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = oldValuePtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, oldValuePtr)
			}
		}
		oldValuePtr = *(*uintptr)(unsafe.Pointer(varPtr + 8))
		(*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).FrefCount++ /* Since var is ref */
	}
	XTcl_AppendObjToObj(tls, oldValuePtr, newValuePtr)
	if (*TTcl_Obj)(unsafe.Pointer(newValuePtr)).FrefCount == 0 {
		_objPtr1 = newValuePtr
		v7 = _objPtr1
		v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
		*(*TTcl_Size)(unsafe.Pointer(v7))--
		if v6 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclPtrSetVarIdx --
 *
 *	This function is the same as Tcl_SetVar2Ex above, except that it
 *	requires pointers to the variable's Var structs in addition to the
 *	variable names.
 *
 * Results:
 *	Returns a pointer to the Tcl_Obj holding the new value of the
 *	variable. If the write operation was disallowed because an array was
 *	expected but not found (or vice versa), then NULL is returned; if the
 *	TCL_LEAVE_ERR_MSG flag is set, then an explanatory message will be
 *	left in the interpreter's result. Note that the returned object may
 *	not be the same one referenced by newValuePtr; this is because
 *	variable traces may modify the variable's value.
 *
 * Side effects:
 *	The value of the given variable is set. If either the array or the
 *	entry didn't exist then a new variable is created.
 *
 *----------------------------------------------------------------------
 */

func XTclPtrSetVarIdx(tls *libc.TLS, interp uintptr, varPtr uintptr, arrayPtr uintptr, part1Ptr uintptr, part2Ptr uintptr, newValuePtr uintptr, flags int32, index int32) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Index of local var where part1 is to be
	 * found. */
	var _objPtr, cachePtr, iPtr, oldValuePtr, resultPtr, v2, v5 uintptr
	var cleanupOnEarlyError, result int32
	var v1, v4 TTcl_Size
	var v3 bool
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, cleanupOnEarlyError, iPtr, oldValuePtr, result, resultPtr, v1, v2, v3, v4, v5
	iPtr = interp
	resultPtr = libc.UintptrFromInt32(0)
	cleanupOnEarlyError = libc.BoolInt32((*TTcl_Obj)(unsafe.Pointer(newValuePtr)).FrefCount == 0)
	/*
	 * If the variable is in a hashtable and its hPtr field is NULL, then we
	 * may have an upvar to an array element where the array was deleted or an
	 * upvar to a namespace variable whose namespace was deleted. Generate an
	 * error (allowing the variable to be reset would screw up our storage
	 * allocation and is meaningless anyway).
	 */
	if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_DEAD_HASH) != 0 {
		if flags&int32(TCL_LEAVE_ERR_MSG) != 0 {
			if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_ARRAY_ELEMENT) != 0 {
				XTclObjVarErrMsg(tls, interp, part1Ptr, part2Ptr, __ccgo_ts+5383, uintptr(unsafe.Pointer(&_DANGLINGELEMENT)), index)
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+68948, libc.UintptrFromInt32(0)))
			} else {
				XTclObjVarErrMsg(tls, interp, part1Ptr, part2Ptr, __ccgo_ts+5383, uintptr(unsafe.Pointer(&_DANGLINGVAR)), index)
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+68940, libc.UintptrFromInt32(0)))
			}
		}
		goto earlyError
	}
	/*
	 * It's an error to try to set a constant.
	 */
	if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_CONSTANT) != 0 {
		if flags&int32(TCL_LEAVE_ERR_MSG) != 0 {
			XTclObjVarErrMsg(tls, interp, part1Ptr, part2Ptr, __ccgo_ts+5383, uintptr(unsafe.Pointer(&_ISCONST)), index)
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+32300, __ccgo_ts+32263, libc.UintptrFromInt32(0)))
		}
		goto earlyError
	}
	/*
	 * It's an error to try to set an array variable itself.
	 */
	if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_ARRAY) != 0 {
		if flags&int32(TCL_LEAVE_ERR_MSG) != 0 {
			XTclObjVarErrMsg(tls, interp, part1Ptr, part2Ptr, __ccgo_ts+5383, uintptr(unsafe.Pointer(&_ISARRAY)), index)
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+32300, __ccgo_ts+32306, libc.UintptrFromInt32(0)))
		}
		goto earlyError
	}
	if arrayPtr == libc.UintptrFromInt32(0) && (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 && (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(varPtr)).Fentry.FtablePtr)).FarrayPtr != libc.UintptrFromInt32(0) {
		arrayPtr = (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(varPtr)).Fentry.FtablePtr)).FarrayPtr
	}
	/*
	 * Invoke any read traces that have been set for the variable if it is
	 * requested. This was done for INST_LAPPEND_* but that was inconsistent
	 * with the non-bc instruction, and would cause failures trying to
	 * lappend to any non-existing ::env var, which is inconsistent with
	 * documented behavior. [Bug #3057639].
	 */
	if flags&int32(TCL_TRACE_READS) != 0 && ((*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_TRACED_READ) != 0 || arrayPtr != 0 && (*TVar)(unsafe.Pointer(arrayPtr)).Fflags&int32(VAR_TRACED_READ) != 0) {
		if int32(TCL_ERROR) == XTclObjCallVarTraces(tls, iPtr, arrayPtr, varPtr, part1Ptr, part2Ptr, int32(TCL_TRACE_READS), flags&int32(TCL_LEAVE_ERR_MSG), index) {
			goto earlyError
		}
	}
	/*
	 * Set the variable's new value. If appending, append the new value to the
	 * variable, either as a list element or as a string. Also, if appending,
	 * then if the variable's old value is unshared we can modify it directly,
	 * otherwise we must create a new copy to modify: this is "copy on write".
	 */
	oldValuePtr = *(*uintptr)(unsafe.Pointer(varPtr + 8))
	if flags&int32(TCL_LIST_ELEMENT) != 0 && !(flags&libc.Int32FromInt32(TCL_APPEND_VALUE) != 0) {
		*(*uintptr)(unsafe.Pointer(varPtr + 8)) = libc.UintptrFromInt32(0)
	}
	if flags&(libc.Int32FromInt32(TCL_APPEND_VALUE)|libc.Int32FromInt32(TCL_LIST_ELEMENT)) != 0 {
		if flags&int32(TCL_LIST_ELEMENT) != 0 { /* Append list element. */
			result = _ListAppendInVar(tls, interp, varPtr, arrayPtr, oldValuePtr, newValuePtr)
			if result != TCL_OK {
				goto earlyError
			}
		} else { /* Append string. */
			_StringAppendInVar(tls, varPtr, arrayPtr, oldValuePtr, newValuePtr)
		}
	} else {
		if newValuePtr != oldValuePtr {
			/*
			 * In this case we are replacing the value, so we don't need to do
			 * more than swap the objects.
			 */
			*(*uintptr)(unsafe.Pointer(varPtr + 8)) = newValuePtr
			(*TTcl_Obj)(unsafe.Pointer(newValuePtr)).FrefCount++ /* Var is another ref. */
			if oldValuePtr != libc.UintptrFromInt32(0) {
				v2 = oldValuePtr
				v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
				*(*TTcl_Size)(unsafe.Pointer(v2))--
				if !(v1 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(oldValuePtr)).Flength = int64(-libc.Int32FromInt32(1))
						if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
							cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, oldValuePtr)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(oldValuePtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = oldValuePtr
							(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, oldValuePtr)
					}
				} /* Discard old value. */
			}
		}
	}
	/*
	 * Invoke any write traces for the variable.
	 */
	if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_TRACED_WRITE) != 0 || arrayPtr != 0 && (*TVar)(unsafe.Pointer(arrayPtr)).Fflags&int32(VAR_TRACED_WRITE) != 0 {
		if int32(TCL_ERROR) == XTclObjCallVarTraces(tls, iPtr, arrayPtr, varPtr, part1Ptr, part2Ptr, flags&(libc.Int32FromInt32(TCL_GLOBAL_ONLY)|libc.Int32FromInt32(TCL_NAMESPACE_ONLY))|int32(TCL_TRACE_WRITES), flags&int32(TCL_LEAVE_ERR_MSG), index) {
			goto cleanup
		}
	}
	/*
	 * Return the variable's value unless the variable was changed in some
	 * gross way by a trace (e.g. it was unset and then recreated as an
	 * array).
	 */
	if !((*TVar)(unsafe.Pointer(varPtr)).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)) != 0) && !(*(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0)) {
		return *(*uintptr)(unsafe.Pointer(varPtr + 8))
	}
	/*
	 * A trace changed the value in some gross way. Return an empty string
	 * object.
	 */
	resultPtr = (*TInterp)(unsafe.Pointer(iPtr)).FemptyObjPtr
	/*
	 * If the variable doesn't exist anymore and no-one's using it, then free
	 * up the relevant structures and hash table entries.
	 */
	goto cleanup
cleanup:
	;
	if resultPtr == libc.UintptrFromInt32(0) {
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+32300, __ccgo_ts+68940, libc.UintptrFromInt32(0)))
	}
	if *(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0) {
		XTclCleanupVar(tls, varPtr, arrayPtr)
	}
	return resultPtr
	goto earlyError
earlyError:
	;
	if cleanupOnEarlyError != 0 {
		_objPtr = newValuePtr
		v5 = _objPtr
		v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
		*(*TTcl_Size)(unsafe.Pointer(v5))--
		if v4 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	goto cleanup
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * TclIncrObjVar2 --
 *
 *	Given a two-part variable name, which may refer either to a scalar
 *	variable or an element of an array, increment the Tcl object value of
 *	the variable by a specified Tcl_Obj increment value.
 *
 * Results:
 *	Returns a pointer to the Tcl_Obj holding the new value of the
 *	variable. If the specified variable doesn't exist, or there is a clash
 *	in array usage, or an error occurs while executing variable traces,
 *	then NULL is returned and a message will be left in the interpreter's
 *	result.
 *
 * Side effects:
 *	The value of the given variable is incremented by the specified
 *	amount. If either the array or the entry didn't exist then a new
 *	variable is created. The ref count for the returned object is _not_
 *	incremented to reflect the returned reference; if you want to keep a
 *	reference to the object you must increment its ref count yourself.
 *	Callers must Incr part1Ptr if they plan to Decr it.
 *	Callers must Incr part2Ptr if they plan to Decr it.
 *
 *----------------------------------------------------------------------
 */

func XTclIncrObjVar2(tls *libc.TLS, interp uintptr, part1Ptr uintptr, part2Ptr uintptr, incrPtr uintptr, flags int32) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Various flags that tell how to incr value:
	 * any of TCL_GLOBAL_ONLY, TCL_NAMESPACE_ONLY,
	 * TCL_APPEND_VALUE, TCL_LIST_ELEMENT,
	 * TCL_LEAVE_ERR_MSG. */
	var varPtr uintptr
	var _ /* arrayPtr at bp+0 */ uintptr
	_ = varPtr
	varPtr = XTclObjLookupVarEx(tls, interp, part1Ptr, part2Ptr, flags, __ccgo_ts+5552, int32(1), int32(1), bp)
	if varPtr == libc.UintptrFromInt32(0) {
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+32116, int64(-int32(1))))
		return libc.UintptrFromInt32(0)
	}
	return XTclPtrIncrObjVarIdx(tls, interp, varPtr, *(*uintptr)(unsafe.Pointer(bp)), part1Ptr, part2Ptr, incrPtr, flags, -int32(1))
}

/*
 *----------------------------------------------------------------------
 *
 * TclPtrIncrObjVar --
 *
 *	Given the pointers to a variable and possible containing array,
 *	increment the Tcl object value of the variable by a Tcl_Obj increment.
 *
 * Results:
 *	Returns a pointer to the Tcl_Obj holding the new value of the
 *	variable. If the specified variable doesn't exist, or there is a clash
 *	in array usage, or an error occurs while executing variable traces,
 *	then NULL is returned and a message will be left in the interpreter's
 *	result.
 *
 * Side effects:
 *	The value of the given variable is incremented by the specified
 *	amount. If either the array or the entry didn't exist then a new
 *	variable is created. The ref count for the returned object is _not_
 *	incremented to reflect the returned reference; if you want to keep a
 *	reference to the object you must increment its ref count yourself.
 *
 *----------------------------------------------------------------------
 */

func XTclPtrIncrObjVar(tls *libc.TLS, interp uintptr, varPtr TTcl_Var, arrayPtr TTcl_Var, part1Ptr uintptr, part2Ptr uintptr, incrPtr uintptr, flags int32) (r uintptr) {
	/* Various flags that tell how to incr value:
	 * any of TCL_GLOBAL_ONLY, TCL_NAMESPACE_ONLY,
	 * TCL_APPEND_VALUE, TCL_LIST_ELEMENT,
	 * TCL_LEAVE_ERR_MSG. */
	if varPtr == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+68956, 0)
	}
	if part1Ptr == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+68980, 0)
	}
	return XTclPtrIncrObjVarIdx(tls, interp, varPtr, arrayPtr, part1Ptr, part2Ptr, incrPtr, flags, -int32(1))
}

/*
 *----------------------------------------------------------------------
 *
 * TclPtrIncrObjVarIdx --
 *
 *	Given the pointers to a variable and possible containing array,
 *	increment the Tcl object value of the variable by a Tcl_Obj increment.
 *
 * Results:
 *	Returns a pointer to the Tcl_Obj holding the new value of the
 *	variable. If the specified variable doesn't exist, or there is a clash
 *	in array usage, or an error occurs while executing variable traces,
 *	then NULL is returned and a message will be left in the interpreter's
 *	result.
 *
 * Side effects:
 *	The value of the given variable is incremented by the specified
 *	amount. If either the array or the entry didn't exist then a new
 *	variable is created. The ref count for the returned object is _not_
 *	incremented to reflect the returned reference; if you want to keep a
 *	reference to the object you must increment its ref count yourself.
 *
 *----------------------------------------------------------------------
 */

func XTclPtrIncrObjVarIdx(tls *libc.TLS, interp uintptr, varPtr uintptr, arrayPtr uintptr, part1Ptr uintptr, part2Ptr uintptr, incrPtr uintptr, flags int32, index int32) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Index into the local variable table of the
	 * variable, or -1. Only used when part1Ptr is
	 * NULL. */
	var _objPtr, cachePtr, varValuePtr, v3 uintptr
	var v1 bool
	var v2 TTcl_Size
	_, _, _, _, _, _ = _objPtr, cachePtr, varValuePtr, v1, v2, v3
	/*
	 * It's an error to try to increment a constant.
	 */
	if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_CONSTANT) != 0 {
		if flags&int32(TCL_LEAVE_ERR_MSG) != 0 {
			XTclObjVarErrMsg(tls, interp, part1Ptr, part2Ptr, __ccgo_ts+2542, uintptr(unsafe.Pointer(&_ISCONST)), index)
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+32300, __ccgo_ts+32263, libc.UintptrFromInt32(0)))
		}
		return libc.UintptrFromInt32(0)
	}
	if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
		(*TVarInHash)(unsafe.Pointer(varPtr)).FrefCount++
	}
	varValuePtr = XTclPtrGetVarIdx(tls, interp, varPtr, arrayPtr, part1Ptr, part2Ptr, flags, index)
	if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
		(*TVarInHash)(unsafe.Pointer(varPtr)).FrefCount--
	}
	if varValuePtr == libc.UintptrFromInt32(0) {
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			varValuePtr = XTclThreadAllocObj(tls)
		} else {
			varValuePtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(varValuePtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(varValuePtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(varValuePtr)).Fbytes = libc.UintptrFromInt32(0)
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(varValuePtr)).FinternalRep)) = int64(libc.Int32FromInt32(0))
		(*TTcl_Obj)(unsafe.Pointer(varValuePtr)).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	}
	if (*TTcl_Obj)(unsafe.Pointer(varValuePtr)).FrefCount > int64(1) {
		/* Copy on write */
		varValuePtr = XTcl_DuplicateObj(tls, varValuePtr)
		if TCL_OK == XTclIncrObj(tls, interp, varValuePtr, incrPtr) {
			return XTclPtrSetVarIdx(tls, interp, varPtr, arrayPtr, part1Ptr, part2Ptr, varValuePtr, flags, index)
		} else {
			_objPtr = varValuePtr
			v3 = _objPtr
			v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
			*(*TTcl_Size)(unsafe.Pointer(v3))--
			if v2 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			return libc.UintptrFromInt32(0)
		}
	} else {
		/* Unshared - can Incr in place */
		if TCL_OK == XTclIncrObj(tls, interp, varValuePtr, incrPtr) {
			/*
			 * This seems dumb to write the incremeted value into the var
			 * after we just adjusted the value in place, but the spec for
			 * [incr] requires that write traces fire, and making this call
			 * is the way to make that happen.
			 */
			return XTclPtrSetVarIdx(tls, interp, varPtr, arrayPtr, part1Ptr, part2Ptr, varValuePtr, flags, index)
		} else {
			return libc.UintptrFromInt32(0)
		}
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UnsetVar2 --
 *
 *	Delete a variable, given a 2-part name.
 *
 * Results:
 *	Returns TCL_OK if the variable was successfully deleted, TCL_ERROR if
 *	the variable can't be unset. In the event of an error, if the
 *	TCL_LEAVE_ERR_MSG flag is set then an error message is left in the
 *	interp's result.
 *
 * Side effects:
 *	If part1 and part2 indicate a local or global variable in interp, it
 *	is deleted. If part1 is an array name and part2 is NULL, then the
 *	whole array is deleted.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UnsetVar2(tls *libc.TLS, interp uintptr, part1 uintptr, part2 uintptr, flags int32) (r int32) {
	/* OR-ed combination of any of
	 * TCL_GLOBAL_ONLY, TCL_NAMESPACE_ONLY,
	 * TCL_LEAVE_ERR_MSG. */
	var _objPtr, _objPtr1, part1Ptr, part2Ptr, v2, v4 uintptr
	var result int32
	var v1, v3 TTcl_Size
	_, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, part1Ptr, part2Ptr, result, v1, v2, v3, v4
	part2Ptr = libc.UintptrFromInt32(0)
	part1Ptr = XTcl_NewStringObj(tls, part1, int64(-int32(1)))
	if part2 != 0 {
		part2Ptr = XTcl_NewStringObj(tls, part2, int64(-int32(1)))
	}
	/*
	 * Filter to pass through only the flags this interface supports.
	 */
	flags &= libc.Int32FromInt32(TCL_GLOBAL_ONLY) | libc.Int32FromInt32(TCL_NAMESPACE_ONLY) | libc.Int32FromInt32(TCL_LEAVE_ERR_MSG)
	result = XTclObjUnsetVar2(tls, interp, part1Ptr, part2Ptr, flags)
	_objPtr = part1Ptr
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	if part2Ptr != 0 {
		_objPtr1 = part2Ptr
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * TclObjUnsetVar2 --
 *
 *	Delete a variable, given a 2-object name.
 *
 * Results:
 *	Returns TCL_OK if the variable was successfully deleted, TCL_ERROR if
 *	the variable can't be unset. In the event of an error, if the
 *	TCL_LEAVE_ERR_MSG flag is set then an error message is left in the
 *	interp's result.
 *
 * Side effects:
 *	If part1ptr and part2Ptr indicate a local or global variable in
 *	interp, it is deleted. If part1Ptr is an array name and part2Ptr is
 *	NULL, then the whole array is deleted.
 *
 *----------------------------------------------------------------------
 */

func XTclObjUnsetVar2(tls *libc.TLS, interp uintptr, part1Ptr uintptr, part2Ptr uintptr, flags int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* OR-ed combination of any of
	 * TCL_GLOBAL_ONLY, TCL_NAMESPACE_ONLY,
	 * TCL_LEAVE_ERR_MSG. */
	var varPtr uintptr
	var _ /* arrayPtr at bp+0 */ uintptr
	_ = varPtr
	varPtr = XTclObjLookupVarEx(tls, interp, part1Ptr, part2Ptr, flags, __ccgo_ts+3450, 0, 0, bp)
	if varPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	return XTclPtrUnsetVarIdx(tls, interp, varPtr, *(*uintptr)(unsafe.Pointer(bp)), part1Ptr, part2Ptr, flags, -int32(1))
}

/*
 *----------------------------------------------------------------------
 *
 * TclPtrUnsetVar --
 *
 *	Delete a variable, given the pointers to the variable's (and possibly
 *	containing array's) VAR structure.
 *
 * Results:
 *	Returns TCL_OK if the variable was successfully deleted, TCL_ERROR if
 *	the variable can't be unset. In the event of an error, if the
 *	TCL_LEAVE_ERR_MSG flag is set then an error message is left in the
 *	interp's result.
 *
 * Side effects:
 *	If varPtr and arrayPtr indicate a local or global variable in interp,
 *	it is deleted. If varPtr is an array reference and part2Ptr is NULL,
 *	then the whole array is deleted.
 *
 *----------------------------------------------------------------------
 */

func XTclPtrUnsetVar(tls *libc.TLS, interp uintptr, varPtr TTcl_Var, arrayPtr TTcl_Var, part1Ptr uintptr, part2Ptr uintptr, flags int32) (r int32) {
	/* OR-ed combination of any of
	 * TCL_GLOBAL_ONLY, TCL_NAMESPACE_ONLY,
	 * TCL_LEAVE_ERR_MSG. */
	if varPtr == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+68956, 0)
	}
	if part1Ptr == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+68980, 0)
	}
	return XTclPtrUnsetVarIdx(tls, interp, varPtr, arrayPtr, part1Ptr, part2Ptr, flags, -int32(1))
}

/*
 *----------------------------------------------------------------------
 *
 * TclPtrUnsetVarIdx --
 *
 *	Delete a variable, given the pointers to the variable's (and possibly
 *	containing array's) VAR structure.
 *
 * Results:
 *	Returns TCL_OK if the variable was successfully deleted, TCL_ERROR if
 *	the variable can't be unset. In the event of an error, if the
 *	TCL_LEAVE_ERR_MSG flag is set then an error message is left in the
 *	interp's result.
 *
 * Side effects:
 *	If varPtr and arrayPtr indicate a local or global variable in interp,
 *	it is deleted. If varPtr is an array reference and part2Ptr is NULL,
 *	then the whole array is deleted.
 *
 *----------------------------------------------------------------------
 */

func XTclPtrUnsetVarIdx(tls *libc.TLS, interp uintptr, varPtr uintptr, arrayPtr uintptr, part1Ptr uintptr, part2Ptr uintptr, flags int32, index int32) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Index into the local variable table of the
	 * variable, or -1. Only used when part1Ptr is
	 * NULL. */
	var iPtr, initialArrayPtr, v2 uintptr
	var result, v1 int32
	_, _, _, _, _ = iPtr, initialArrayPtr, result, v1, v2
	iPtr = interp
	if *(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0) {
		v1 = int32(TCL_ERROR)
	} else {
		v1 = TCL_OK
	}
	result = v1
	initialArrayPtr = arrayPtr
	/*
	 * It's an error to try to unset a constant.
	 */
	if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_CONSTANT) != 0 {
		if flags&int32(TCL_LEAVE_ERR_MSG) != 0 {
			XTclObjVarErrMsg(tls, interp, part1Ptr, part2Ptr, __ccgo_ts+3450, uintptr(unsafe.Pointer(&_ISCONST)), index)
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+69059, __ccgo_ts+32263, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	/*
	 * Keep the variable alive until we're done with it. We used to
	 * increase/decrease the refCount for each operation, making it hard to
	 * find [Bug 735335] - caused by unsetting the variable whose value was
	 * the variable's name.
	 */
	if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
		(*TVarInHash)(unsafe.Pointer(varPtr)).FrefCount++
	}
	if arrayPtr == libc.UintptrFromInt32(0) && (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 && (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(varPtr)).Fentry.FtablePtr)).FarrayPtr != libc.UintptrFromInt32(0) {
		arrayPtr = (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(varPtr)).Fentry.FtablePtr)).FarrayPtr
	}
	_UnsetVarStruct(tls, varPtr, arrayPtr, iPtr, part1Ptr, part2Ptr, flags, index)
	/*
	 * It's an error to unset an undefined variable.
	 */
	if result != TCL_OK {
		if flags&int32(TCL_LEAVE_ERR_MSG) != 0 {
			if initialArrayPtr == libc.UintptrFromInt32(0) {
				v2 = uintptr(unsafe.Pointer(&_NOSUCHVAR))
			} else {
				v2 = uintptr(unsafe.Pointer(&_NOSUCHELEMENT))
			}
			XTclObjVarErrMsg(tls, interp, part1Ptr, part2Ptr, __ccgo_ts+3450, v2, index)
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+69059, __ccgo_ts+68940, libc.UintptrFromInt32(0)))
		}
	}
	/*
	 * Finally, if the variable is truly not in use then free up its Var
	 * structure and remove it from its hash table, if any. The ref count of
	 * its value object, if any, was decremented above.
	 */
	if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
		(*TVarInHash)(unsafe.Pointer(varPtr)).FrefCount--
		_CleanupVar(tls, varPtr, arrayPtr)
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * UnsetVarStruct --
 *
 *	Unset and delete a variable. This does the internal work for
 *	TclObjUnsetVar2 and TclDeleteNamespaceVars, which call here for each
 *	variable to be unset and deleted.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	If the arguments indicate a local or global variable in iPtr, it is
 *	unset and deleted.
 *
 *----------------------------------------------------------------------
 */

func _UnsetVarStruct(tls *libc.TLS, varPtr uintptr, arrayPtr uintptr, iPtr uintptr, part1Ptr uintptr, part2Ptr uintptr, flags int32, index int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var activePtr, cachePtr, linkPtr, objPtr, prevPtr, tPtr, tracePtr, v3 uintptr
	var traced int32
	var v2 TTcl_Size
	var v4 bool
	var _ /* dummyVar at bp+0 */ TVar
	var _ /* isNew at bp+16 */ int32
	_, _, _, _, _, _, _, _, _, _, _ = activePtr, cachePtr, linkPtr, objPtr, prevPtr, tPtr, tracePtr, traced, v2, v3, v4
	traced = libc.BoolInt32((*TVar)(unsafe.Pointer(varPtr)).Fflags&(libc.Int32FromInt32(VAR_TRACED_READ)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_TRACED_ARRAY)|libc.Int32FromInt32(VAR_TRACED_UNSET)) != 0 || arrayPtr != 0 && (*TVar)(unsafe.Pointer(arrayPtr)).Fflags&int32(VAR_TRACED_UNSET) != 0)
	if arrayPtr != 0 && (*TVar)(unsafe.Pointer(arrayPtr)).Fflags&int32(VAR_SEARCH_ACTIVE) != 0 {
		_DeleteSearches(tls, iPtr, arrayPtr)
	} else {
		if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_SEARCH_ACTIVE) != 0 {
			_DeleteSearches(tls, iPtr, varPtr)
		}
	}
	/*
	 * The code below is tricky, because of the possibility that a trace
	 * function might try to access a variable being deleted. To handle this
	 * situation gracefully, do things in three steps:
	 * 1. Copy the contents of the variable to a dummy variable structure, and
	 *    mark the original Var structure as undefined.
	 * 2. Invoke traces and clean up the variable, using the dummy copy.
	 * 3. If at the end of this the original variable is still undefined and
	 *    has no outstanding references, then delete it (but it could have
	 *    gotten recreated by a trace).
	 */
	*(*TVar)(unsafe.Pointer(bp)) = *(*TVar)(unsafe.Pointer(varPtr))
	(*(*TVar)(unsafe.Pointer(bp))).Fflags &= ^(libc.Int32FromInt32(VAR_IN_HASHTABLE) | libc.Int32FromInt32(VAR_DEAD_HASH) | libc.Int32FromInt32(VAR_NAMESPACE_VAR) | libc.Int32FromInt32(VAR_ARRAY_ELEMENT))
	*(*int32)(unsafe.Pointer(varPtr)) &= ^(libc.Int32FromInt32(VAR_ARRAY) | libc.Int32FromInt32(VAR_LINK) | libc.Int32FromInt32(VAR_CONSTANT))
	*(*uintptr)(unsafe.Pointer(varPtr + 8)) = libc.UintptrFromInt32(0)
	/*
	 * Call trace functions for the variable being deleted. Then delete its
	 * traces. Be sure to abort any other traces for the variable that are
	 * still pending. Special tricks:
	 * 1. We need to increment varPtr's refCount around this: TclCallVarTraces
	 *    will use dummyVar so it won't increment varPtr's refCount itself.
	 * 2. Turn off the VAR_TRACE_ACTIVE flag in dummyVar: we want to call
	 *    unset traces even if other traces are pending.
	 */
	if traced != 0 {
		tracePtr = libc.UintptrFromInt32(0)
		if (*TVar)(unsafe.Pointer(bp)).Fflags&(libc.Int32FromInt32(VAR_TRACED_READ)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_TRACED_ARRAY)|libc.Int32FromInt32(VAR_TRACED_UNSET)) != 0 {
			tPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iPtr + 792)).FfindProc})))(tls, iPtr+792, varPtr)
			tracePtr = (*TTcl_HashEntry)(unsafe.Pointer(tPtr)).FclientData
			*(*int32)(unsafe.Pointer(varPtr)) &= ^(libc.Int32FromInt32(VAR_TRACED_READ) | libc.Int32FromInt32(VAR_TRACED_WRITE) | libc.Int32FromInt32(VAR_TRACED_ARRAY) | libc.Int32FromInt32(VAR_TRACED_UNSET))
			XTcl_DeleteHashEntry(tls, tPtr)
			if (*(*TVar)(unsafe.Pointer(bp))).Fflags&int32(VAR_TRACED_UNSET) != 0 {
				tPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iPtr + 792)).FcreateProc})))(tls, iPtr+792, bp, bp+16)
				(*TTcl_HashEntry)(unsafe.Pointer(tPtr)).FclientData = tracePtr
			}
		}
		if (*(*TVar)(unsafe.Pointer(bp))).Fflags&int32(VAR_TRACED_UNSET) != 0 || arrayPtr != 0 && (*TVar)(unsafe.Pointer(arrayPtr)).Fflags&int32(VAR_TRACED_UNSET) != 0 {
			/*
			 * Pass the array element name to TclObjCallVarTraces(), because
			 * it cannot be determined from dummyVar. Alternatively, indicate
			 * via flags whether the variable involved in the code that caused
			 * the trace to be triggered was an array element, for the correct
			 * formatting of error messages.
			 */
			if part2Ptr != 0 {
				flags |= int32(VAR_ARRAY_ELEMENT)
			} else {
				if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_ARRAY_ELEMENT) != 0 {
					part2Ptr = *(*uintptr)(unsafe.Pointer(varPtr + 24 + 32))
				}
			}
			(*(*TVar)(unsafe.Pointer(bp))).Fflags &= ^libc.Int32FromInt32(VAR_TRACE_ACTIVE)
			XTclObjCallVarTraces(tls, iPtr, arrayPtr, bp, part1Ptr, part2Ptr, flags&(libc.Int32FromInt32(TCL_GLOBAL_ONLY)|libc.Int32FromInt32(TCL_NAMESPACE_ONLY)|libc.Int32FromInt32(VAR_ARRAY_ELEMENT))|int32(TCL_TRACE_UNSETS), 0, index)
			/*
			 * The traces that we just called may have triggered a change in
			 * the set of traces. If so, reload the traces to manipulate.
			 */
			tracePtr = libc.UintptrFromInt32(0)
			if (*TVar)(unsafe.Pointer(bp)).Fflags&(libc.Int32FromInt32(VAR_TRACED_READ)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_TRACED_ARRAY)|libc.Int32FromInt32(VAR_TRACED_UNSET)) != 0 {
				tPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iPtr + 792)).FfindProc})))(tls, iPtr+792, bp)
				if tPtr != 0 {
					tracePtr = (*TTcl_HashEntry)(unsafe.Pointer(tPtr)).FclientData
					XTcl_DeleteHashEntry(tls, tPtr)
				}
			}
		}
		if tracePtr != 0 {
			for tracePtr != 0 {
				prevPtr = tracePtr
				tracePtr = (*TVarTrace)(unsafe.Pointer(tracePtr)).FnextPtr
				(*TVarTrace)(unsafe.Pointer(prevPtr)).FnextPtr = libc.UintptrFromInt32(0)
				XTcl_EventuallyFree(tls, prevPtr, libc.UintptrFromInt32(3))
			}
			activePtr = (*TInterp)(unsafe.Pointer(iPtr)).FactiveVarTracePtr
			for {
				if !(activePtr != libc.UintptrFromInt32(0)) {
					break
				}
				if (*TActiveVarTrace)(unsafe.Pointer(activePtr)).FvarPtr == varPtr {
					(*TActiveVarTrace)(unsafe.Pointer(activePtr)).FnextTracePtr = libc.UintptrFromInt32(0)
				}
				goto _1
			_1:
				;
				activePtr = (*TActiveVarTrace)(unsafe.Pointer(activePtr)).FnextPtr
			}
			(*(*TVar)(unsafe.Pointer(bp))).Fflags &= ^(libc.Int32FromInt32(VAR_TRACED_READ) | libc.Int32FromInt32(VAR_TRACED_WRITE) | libc.Int32FromInt32(VAR_TRACED_ARRAY) | libc.Int32FromInt32(VAR_TRACED_UNSET))
		}
	}
	if !((*TVar)(unsafe.Pointer(bp)).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)) != 0) && *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) {
		/*
		 * Decrement the ref count of the var's value.
		 */
		objPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
		v3 = objPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if !(v2 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(-libc.Int32FromInt32(1))
				if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v4 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, objPtr)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(objPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = objPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, objPtr)
			}
		}
	} else {
		if (*TVar)(unsafe.Pointer(bp)).Fflags&int32(VAR_ARRAY) != 0 {
			/*
			 * If the variable is an array, delete all of its elements. This must
			 * be done after calling and deleting the traces on the array, above
			 * (that's the way traces are defined). If the array name is not
			 * present and is required for a trace on some element, it will be
			 * computed at DeleteArray.
			 */
			_DeleteArray(tls, iPtr, part1Ptr, bp, flags&(libc.Int32FromInt32(TCL_GLOBAL_ONLY)|libc.Int32FromInt32(TCL_NAMESPACE_ONLY))|int32(TCL_TRACE_UNSETS), index)
		} else {
			if (*TVar)(unsafe.Pointer(bp)).Fflags&int32(VAR_LINK) != 0 {
				/*
				 * For global/upvar variables referenced in procedures, decrement the
				 * reference count on the variable referred to, and free the
				 * referenced variable if it's no longer needed.
				 */
				linkPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
				if (*TVar)(unsafe.Pointer(linkPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
					(*TVarInHash)(unsafe.Pointer(linkPtr)).FrefCount--
					_CleanupVar(tls, linkPtr, libc.UintptrFromInt32(0))
				}
			}
		}
	}
	/*
	 * If the variable was a namespace variable, decrement its reference
	 * count.
	 */
	if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_NAMESPACE_VAR) != 0 {
		*(*int32)(unsafe.Pointer(varPtr)) &= ^libc.Int32FromInt32(VAR_NAMESPACE_VAR)
		if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
			(*TVarInHash)(unsafe.Pointer(varPtr)).FrefCount--
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UnsetObjCmd --
 *
 *	This object-based function is invoked to process the "unset" Tcl
 *	command. See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl object result value.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UnsetObjCmd(tls *libc.TLS, dummy2733 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var flags, i int32
	var name, v1, v2 uintptr
	_, _, _, _, _ = flags, i, name, v1, v2
	flags = int32(TCL_LEAVE_ERR_MSG)
	if objc == int32(1) {
		/*
		 * Do nothing if no arguments supplied, so as to match command
		 * documentation.
		 */
		return TCL_OK
	}
	/*
	 * Simple, restrictive argument parsing. The only options are -- and
	 * -nocomplain (which must come first and be given exactly to be an
	 * option).
	 */
	i = int32(1)
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
	}
	name = v1
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32('-') {
		if libc.Xstrcmp(tls, __ccgo_ts+22371, name) == 0 {
			i++
			if i == objc {
				return TCL_OK
			}
			flags = 0
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
				v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
			}
			name = v2
		}
		if libc.Xstrcmp(tls, __ccgo_ts+18684, name) == 0 {
			i++
		}
	}
	for {
		if !(i < objc) {
			break
		}
		if XTclObjUnsetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0), flags) != TCL_OK && flags == int32(TCL_LEAVE_ERR_MSG) {
			return int32(TCL_ERROR)
		}
		goto _3
	_3:
		;
		i++
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_AppendObjCmd --
 *
 *	This object-based function is invoked to process the "append" Tcl
 *	command. See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl object result value.
 *
 * Side effects:
 *	A variable's value may be changed.
 *
 *----------------------------------------------------------------------
 */

func XTcl_AppendObjCmd(tls *libc.TLS, dummy2800 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var i int32
	var varPtr, varValuePtr uintptr
	var _ /* arrayPtr at bp+0 */ uintptr
	_, _, _ = i, varPtr, varValuePtr
	varValuePtr = libc.UintptrFromInt32(0)
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+69065)
		return int32(TCL_ERROR)
	}
	if objc == int32(2) {
		varValuePtr = XTcl_ObjGetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), int32(TCL_LEAVE_ERR_MSG))
		if varValuePtr == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
	} else {
		varPtr = XTclObjLookupVarEx(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), int32(TCL_LEAVE_ERR_MSG), __ccgo_ts+5383, int32(1), int32(1), bp)
		if varPtr == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
		i = int32(2)
		for {
			if !(i < objc) {
				break
			}
			/*
			 * Note that we do not need to increase the refCount of the Var
			 * pointers: should a trace delete the variable, the return value
			 * of TclPtrSetVarIdx will be NULL or emptyObjPtr, and we will not
			 * access the variable again.
			 */
			varValuePtr = XTclPtrSetVarIdx(tls, interp, varPtr, *(*uintptr)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.Int32FromInt32(TCL_APPEND_VALUE)|libc.Int32FromInt32(TCL_LEAVE_ERR_MSG), -int32(1))
			if varValuePtr == libc.UintptrFromInt32(0) || varValuePtr == (*TInterp)(unsafe.Pointer(interp)).FemptyObjPtr {
				return int32(TCL_ERROR)
			}
			goto _1
		_1:
			;
			i++
		}
	}
	XTcl_SetObjResult(tls, interp, varValuePtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_LappendObjCmd --
 *
 *	This object-based function is invoked to process the "lappend" Tcl
 *	command. See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl object result value.
 *
 * Side effects:
 *	A variable's value may be changed.
 *
 *----------------------------------------------------------------------
 */

func XTcl_LappendObjCmd(tls *libc.TLS, dummy2865 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var cachePtr, cachePtr1, cachePtr2, newValuePtr, varPtr, varValuePtr, v8 uintptr
	var createdNewObj, result, v2, v5 int32
	var v1, v4, v9 bool
	var v3, v6 int64
	var v7 TTcl_Size
	var _ /* arrayPtr at bp+8 */ uintptr
	var _ /* numElems at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, createdNewObj, newValuePtr, result, varPtr, varValuePtr, v1, v2, v3, v4, v5, v6, v7, v8, v9
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+69065)
		return int32(TCL_ERROR)
	}
	if objc == int32(2) {
		newValuePtr = XTcl_ObjGetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), 0)
		if newValuePtr == libc.UintptrFromInt32(0) {
			/*
			 * The variable doesn't exist yet. Just create it with an empty
			 * initial value.
			 */
			if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				varValuePtr = XTclThreadAllocObj(tls)
			} else {
				varValuePtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(varValuePtr + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(varValuePtr)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(varValuePtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(varValuePtr)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(varValuePtr)).FtypePtr = libc.UintptrFromInt32(0)
			newValuePtr = XTcl_ObjSetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), varValuePtr, int32(TCL_LEAVE_ERR_MSG))
			if newValuePtr == libc.UintptrFromInt32(0) {
				return int32(TCL_ERROR)
			}
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(newValuePtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(newValuePtr + 32))).Fptr2 != 0 {
					v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(newValuePtr + 32))).Fptr2)).FspanLength
				} else {
					v3 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(newValuePtr + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp)) = v3
				v2 = libc.Int32FromInt32(TCL_OK)
			} else {
				v2 = XTcl_ListObjLength(tls, interp, newValuePtr, bp)
			}
			result = v2
			if result != TCL_OK {
				return result
			}
		}
	} else {
		/*
		 * We have arguments to append. We used to call Tcl_SetVar2 to append
		 * each argument one at a time to ensure that traces were run for each
		 * append step. We now append the arguments all at once because it's
		 * faster. Note that a read trace and a write trace for the variable
		 * will now each only be called once. Also, if the variable's old
		 * value is unshared we modify it directly, otherwise we create a new
		 * copy to modify: this is "copy on write".
		 */
		createdNewObj = 0
		/*
		 * Protect the variable pointers around the TclPtrGetVarIdx call
		 * to insure that they remain valid even if the variable was undefined
		 * and unused.
		 */
		varPtr = XTclObjLookupVarEx(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), int32(TCL_LEAVE_ERR_MSG), __ccgo_ts+5383, int32(1), int32(1), bp+8)
		if varPtr == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
		if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
			(*TVarInHash)(unsafe.Pointer(varPtr)).FrefCount++
		}
		if *(*uintptr)(unsafe.Pointer(bp + 8)) != 0 && (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
			(*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount++
		}
		varValuePtr = XTclPtrGetVarIdx(tls, interp, varPtr, *(*uintptr)(unsafe.Pointer(bp + 8)), *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), int32(TCL_LEAVE_ERR_MSG), -int32(1))
		if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
			(*TVarInHash)(unsafe.Pointer(varPtr)).FrefCount--
		}
		if *(*uintptr)(unsafe.Pointer(bp + 8)) != 0 && (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
			(*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FrefCount--
		}
		if varValuePtr == libc.UintptrFromInt32(0) {
			/*
			 * We couldn't read the old value: either the var doesn't yet
			 * exist or it's an array element. If it's new, we will try to
			 * create it with Tcl_ObjSetVar2 below.
			 */
			if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
				varValuePtr = XTclThreadAllocObj(tls)
			} else {
				varValuePtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(varValuePtr + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(varValuePtr)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(varValuePtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(varValuePtr)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(varValuePtr)).FtypePtr = libc.UintptrFromInt32(0)
			createdNewObj = int32(1)
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(varValuePtr)).FrefCount > int64(1) {
				varValuePtr = XTcl_DuplicateObj(tls, varValuePtr)
				createdNewObj = int32(1)
			}
		}
		if (*TTcl_Obj)(unsafe.Pointer(varValuePtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(varValuePtr + 32))).Fptr2 != 0 {
				v6 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(varValuePtr + 32))).Fptr2)).FspanLength
			} else {
				v6 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(varValuePtr + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp)) = v6
			v5 = libc.Int32FromInt32(TCL_OK)
		} else {
			v5 = XTcl_ListObjLength(tls, interp, varValuePtr, bp)
		}
		result = v5
		if result == TCL_OK {
			result = XTcl_ListObjReplace(tls, interp, varValuePtr, *(*TTcl_Size)(unsafe.Pointer(bp)), 0, int64(objc-libc.Int32FromInt32(2)), objv+libc.UintptrFromInt32(2)*8)
		}
		if result != TCL_OK {
			if createdNewObj != 0 {
				v8 = varValuePtr
				v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
				*(*TTcl_Size)(unsafe.Pointer(v8))--
				if !(v7 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(varValuePtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(varValuePtr)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(varValuePtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(varValuePtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(varValuePtr)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(varValuePtr)).Flength = int64(-libc.Int32FromInt32(1))
						if v9 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v9 {
							cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v9 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, varValuePtr)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(varValuePtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = varValuePtr
							(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, varValuePtr)
					}
				} /* Free unneeded obj. */
			}
			return result
		}
		/*
		 * Now store the list object back into the variable. If there is an
		 * error setting the new value, decrement its ref count if it was new
		 * and we didn't create the variable.
		 */
		newValuePtr = XTclPtrSetVarIdx(tls, interp, varPtr, *(*uintptr)(unsafe.Pointer(bp + 8)), *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), varValuePtr, int32(TCL_LEAVE_ERR_MSG), -int32(1))
		if newValuePtr == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
	}
	/*
	 * Set the interpreter's object result to refer to the variable's value
	 * object.
	 */
	XTcl_SetObjResult(tls, interp, newValuePtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * ArrayForObjCmd, ArrayForNRCmd, ArrayForLoopCallback, ArrayObjNext --
 *
 *	These functions implement the "array for" Tcl command.
 *	    array for {k v} a {}
 *	The array for command iterates over the array, setting the
 *	specified loop variables, and executing the body each iteration.
 *
 *	ArrayForObjCmd() is the standard wrapper around ArrayForNRCmd().
 *
 *	ArrayForNRCmd() sets up the ArraySearch structure, sets arrayNamePtr
 *	inside the structure and calls VarHashFirstEntry to start the hash
 *	iteration.
 *
 *	ArrayForNRCmd() does not execute the body or set the loop variables,
 *	it only initializes the iterator.
 *
 *	ArrayForLoopCallback() iterates over the entire array, executing the
 *	body each time.
 *
 *----------------------------------------------------------------------
 */

func _ArrayObjNext(tls *libc.TLS, interp uintptr, arrayNameObj uintptr, varPtr uintptr, searchPtr uintptr, keyPtrPtr uintptr, valuePtrPtr uintptr) (r int32) {
	/* Pointer to a variable to have the
	 * value written into, or NULL.*/
	var donerc, gotValue int32
	var hPtr, keyObj, valueObj uintptr
	_, _, _, _, _ = donerc, gotValue, hPtr, keyObj, valueObj
	valueObj = libc.UintptrFromInt32(0)
	donerc = int32(TCL_BREAK)
	if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_SEARCH_ACTIVE) != int32(VAR_SEARCH_ACTIVE) {
		donerc = int32(TCL_ERROR)
		return donerc
	}
	gotValue = 0
	for int32(1) != 0 {
		hPtr = (*TArraySearch)(unsafe.Pointer(searchPtr)).FnextEntry
		if hPtr != libc.UintptrFromInt32(0) {
			(*TArraySearch)(unsafe.Pointer(searchPtr)).FnextEntry = libc.UintptrFromInt32(0)
		} else {
			hPtr = XTcl_NextHashEntry(tls, searchPtr+24)
			if hPtr == libc.UintptrFromInt32(0) {
				gotValue = 0
				break
			}
		}
		varPtr = hPtr - uintptr(uint64(libc.UintptrFromInt32(0)+24))
		if !(*(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0)) {
			gotValue = int32(1)
			break
		}
	}
	if !(gotValue != 0) {
		return donerc
	}
	donerc = int32(TCL_CONTINUE)
	keyObj = *(*uintptr)(unsafe.Pointer(varPtr + 24 + 32))
	*(*uintptr)(unsafe.Pointer(keyPtrPtr)) = keyObj
	valueObj = XTcl_ObjGetVar2(tls, interp, arrayNameObj, keyObj, int32(TCL_LEAVE_ERR_MSG))
	*(*uintptr)(unsafe.Pointer(valuePtrPtr)) = valueObj
	return donerc
}

func _ArrayForObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	return XTcl_NRCallObjProc(tls, interp, __ccgo_fp(_ArrayForNRCmd), clientData, int64(objc), objv)
}

func _ArrayForNRCmd(tls *libc.TLS, dummy3081 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var _objPtr, arrayNameObj, cachePtr, scriptObj, searchPtr, varListObj uintptr
	var v1 int32
	var v2 int64
	var v3 bool
	var _ /* _callbackPtr at bp+24 */ uintptr
	var _ /* isArray at bp+8 */ int32
	var _ /* numVars at bp+16 */ TTcl_Size
	var _ /* varPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _ = _objPtr, arrayNameObj, cachePtr, scriptObj, searchPtr, varListObj, v1, v2, v3
	searchPtr = libc.UintptrFromInt32(0)
	/*
	 * array for {k v} a body
	 */
	if objc != int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+69085)
		return int32(TCL_ERROR)
	}
	/*
	 * Parse arguments.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr2)).FspanLength
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = v2
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjLength(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+16)
	}
	if v1 != TCL_OK {
		return int32(TCL_ERROR)
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) != int64(2) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+69114, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+26810, __ccgo_ts+28190, __ccgo_ts+5187, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	arrayNameObj = *(*uintptr)(unsafe.Pointer(objv + 2*8))
	if int32(TCL_ERROR) == _LocateArray(tls, interp, arrayNameObj, bp, bp+8) {
		return int32(TCL_ERROR)
	}
	if !(*(*int32)(unsafe.Pointer(bp + 8)) != 0) {
		return _NotArrayError(tls, interp, arrayNameObj)
	}
	/*
	 * Make a new array search, put it on the stack.
	 */
	searchPtr = XTcl_Alloc(tls, uint64(64))
	_ArrayPopulateSearch(tls, interp, arrayNameObj, *(*uintptr)(unsafe.Pointer(bp)), searchPtr)
	/*
	 * Make sure that these objects (which we need throughout the body of the
	 * loop) don't vanish.
	 */
	varListObj = XTclListObjCopy(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if !(varListObj != 0) {
		return int32(TCL_ERROR)
	}
	scriptObj = *(*uintptr)(unsafe.Pointer(objv + 3*8))
	(*TTcl_Obj)(unsafe.Pointer(scriptObj)).FrefCount++
	/*
	 * Run the script.
	 */
	if v3 = interp == libc.UintptrFromInt32(0); !v3 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 24)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).FprocPtr = __ccgo_fp(_ArrayForLoopCallback)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 8)) = searchPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 8 + 1*8)) = varListObj
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 8 + 2*8)) = arrayNameObj
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 8 + 3*8)) = scriptObj
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 24))
	return TCL_OK
}

func _ArrayForLoopCallback(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(96)
	defer tls.Free(96)
	var _objPtr, _objPtr1, arrayNameObj, cachePtr, cachePtr1, cachePtr2, iPtr, scriptObj, searchPtr, varListObj, varPtr, v11, v6, v8 uintptr
	var done, v1 int32
	var v10, v5, v7 TTcl_Size
	var v12, v4, v9 bool
	var v2, v3 int64
	var _ /* _callbackPtr at bp+40 */ uintptr
	var _ /* arrayPtr at bp+24 */ uintptr
	var _ /* keyObj at bp+8 */ uintptr
	var _ /* valueObj at bp+16 */ uintptr
	var _ /* varc at bp+32 */ TTcl_Size
	var _ /* varv at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, arrayNameObj, cachePtr, cachePtr1, cachePtr2, done, iPtr, scriptObj, searchPtr, varListObj, varPtr, v1, v10, v11, v12, v2, v3, v4, v5, v6, v7, v8, v9
	iPtr = interp
	searchPtr = *(*uintptr)(unsafe.Pointer(data))
	varListObj = *(*uintptr)(unsafe.Pointer(data + 1*8))
	arrayNameObj = *(*uintptr)(unsafe.Pointer(data + 2*8))
	scriptObj = *(*uintptr)(unsafe.Pointer(data + 3*8))
	/*
	 * Process the result from the previous execution of the script body.
	 */
	done = int32(TCL_ERROR)
	if result == int32(TCL_CONTINUE) {
		result = TCL_OK
	} else {
		if result != TCL_OK {
			if result == int32(TCL_BREAK) {
				XTcl_ResetResult(tls, interp)
				result = TCL_OK
			} else {
				if result == int32(TCL_ERROR) {
					XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+69143, libc.VaList(bp+56, XTcl_GetErrorLine(tls, interp))))
				}
			}
			goto arrayfordone
		}
	}
	/*
	 * Get the next mapping from the array.
	 */
	*(*uintptr)(unsafe.Pointer(bp + 8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(bp + 16)) = libc.UintptrFromInt32(0)
	varPtr = XTclObjLookupVarEx(tls, interp, arrayNameObj, libc.UintptrFromInt32(0), 0, uintptr(0), 0, 0, bp+24)
	if varPtr == libc.UintptrFromInt32(0) {
		done = int32(TCL_ERROR)
	} else {
		done = _ArrayObjNext(tls, interp, arrayNameObj, varPtr, searchPtr, bp+8, bp+16)
	}
	result = TCL_OK
	if done != int32(TCL_CONTINUE) {
		XTcl_ResetResult(tls, interp)
		if done == int32(TCL_ERROR) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+69175, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+56, __ccgo_ts+2004, __ccgo_ts+69006, __ccgo_ts+28190, __ccgo_ts+5187, libc.UintptrFromInt32(0)))
			*(*int32)(unsafe.Pointer(varPtr)) |= int32(TCL_LEAVE_ERR_MSG)
			result = done
		}
		goto arrayfordone
	}
	if (*TTcl_Obj)(unsafe.Pointer(varListObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(varListObj + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(varListObj + 32))).Fptr2)).FspanStart
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(varListObj + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(varListObj + 32))).Fptr1 + 40 + uintptr(v2)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(varListObj + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(varListObj + 32))).Fptr2)).FspanLength
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(varListObj + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 32)) = v3
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), varListObj, bp+32, bp)
	}
	result = v1
	if result != TCL_OK {
		goto arrayfordone
	}
	if XTcl_ObjSetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))), libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 8)), int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
		result = int32(TCL_ERROR)
		goto arrayfordone
	}
	if *(*uintptr)(unsafe.Pointer(bp + 16)) != libc.UintptrFromInt32(0) {
		if XTcl_ObjSetVar2(tls, interp, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1*8)), libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 16)), int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
			result = int32(TCL_ERROR)
			goto arrayfordone
		}
	}
	/*
	 * Run the script.
	 */
	if v4 = interp == libc.UintptrFromInt32(0); !v4 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 40)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).FprocPtr = __ccgo_fp(_ArrayForLoopCallback)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 8)) = searchPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 8 + 1*8)) = varListObj
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 8 + 2*8)) = arrayNameObj
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)) + 8 + 3*8)) = scriptObj
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 40))
	return XTclNREvalObjEx(tls, interp, scriptObj, 0, (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr, int32(3))
	/*
	 * For unwinding everything once the iterating is done.
	 */
	goto arrayfordone
arrayfordone:
	;
	if done != int32(TCL_ERROR) {
		/*
		 * If the search was terminated by an array change, the
		 * VAR_SEARCH_ACTIVE flag will no longer be set.
		 */
		_ArrayDoneSearch(tls, iPtr, varPtr, searchPtr)
		_objPtr1 = (*TArraySearch)(unsafe.Pointer(searchPtr)).Fname
		v6 = _objPtr1
		v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
		*(*TTcl_Size)(unsafe.Pointer(v6))--
		if v5 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		XTclpFree(tls, searchPtr)
	}
	v8 = varListObj
	v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
	*(*TTcl_Size)(unsafe.Pointer(v8))--
	if !(v7 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(varListObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(varListObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(varListObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(varListObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(varListObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(varListObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v9 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v9 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v9 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, varListObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(varListObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = varListObj
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, varListObj)
		}
	}
	v11 = scriptObj
	v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
	*(*TTcl_Size)(unsafe.Pointer(v11))--
	if !(v10 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(scriptObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(scriptObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(scriptObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(scriptObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(scriptObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(scriptObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v12 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v12 {
				cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v12 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, scriptObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(scriptObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = scriptObj
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, scriptObj)
		}
	}
	return result
}

/*
 * ArrayPopulateSearch
 */

func _ArrayPopulateSearch(tls *libc.TLS, interp uintptr, arrayNameObj uintptr, varPtr uintptr, searchPtr uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var hPtr, iPtr, v1 uintptr
	var _ /* isNew at bp+0 */ int32
	_, _, _ = hPtr, iPtr, v1
	iPtr = interp
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iPtr + 896)).FcreateProc})))(tls, iPtr+896, varPtr, bp)
	if *(*int32)(unsafe.Pointer(bp)) != 0 {
		(*TArraySearch)(unsafe.Pointer(searchPtr)).Fid = int32(1)
		*(*int32)(unsafe.Pointer(varPtr)) |= int32(VAR_SEARCH_ACTIVE)
		(*TArraySearch)(unsafe.Pointer(searchPtr)).FnextPtr = libc.UintptrFromInt32(0)
	} else {
		(*TArraySearch)(unsafe.Pointer(searchPtr)).Fid = (*TArraySearch)(unsafe.Pointer((*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData)).Fid + int32(1)
		(*TArraySearch)(unsafe.Pointer(searchPtr)).FnextPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
	}
	(*TArraySearch)(unsafe.Pointer(searchPtr)).FvarPtr = varPtr
	(*TArraySearch)(unsafe.Pointer(searchPtr)).FnextEntry = XTcl_FirstHashEntry(tls, *(*uintptr)(unsafe.Pointer(varPtr + 8)), searchPtr+24)
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = searchPtr
	if (*TTcl_Obj)(unsafe.Pointer(arrayNameObj)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(arrayNameObj)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, arrayNameObj, libc.UintptrFromInt32(0))
	}
	(*TArraySearch)(unsafe.Pointer(searchPtr)).Fname = XTcl_ObjPrintf(tls, __ccgo_ts+69206, libc.VaList(bp+16, (*TArraySearch)(unsafe.Pointer(searchPtr)).Fid, v1))
	(*TTcl_Obj)(unsafe.Pointer((*TArraySearch)(unsafe.Pointer(searchPtr)).Fname)).FrefCount++
}

/*
 *----------------------------------------------------------------------
 *
 * ArrayStartSearchCmd --
 *
 *	This object-based function is invoked to process the "array
 *	startsearch" Tcl command. See the user documentation for details on
 *	what it does.
 *
 * Results:
 *	A standard Tcl result object.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _ArrayStartSearchCmd(tls *libc.TLS, dummy3318 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var searchPtr uintptr
	var _ /* isArray at bp+8 */ int32
	var _ /* varPtr at bp+0 */ uintptr
	_ = searchPtr
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+69214)
		return int32(TCL_ERROR)
	}
	if int32(TCL_ERROR) == _LocateArray(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp, bp+8) {
		return int32(TCL_ERROR)
	}
	if !(*(*int32)(unsafe.Pointer(bp + 8)) != 0) {
		return _NotArrayError(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	}
	/*
	 * Make a new array search with a free name.
	 */
	searchPtr = XTcl_Alloc(tls, uint64(64))
	_ArrayPopulateSearch(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), *(*uintptr)(unsafe.Pointer(bp)), searchPtr)
	XTcl_SetObjResult(tls, interp, (*TArraySearch)(unsafe.Pointer(searchPtr)).Fname)
	return TCL_OK
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * ArrayDoneSearch --
//	 *
//	 *	Removes the search from the hash of active searches.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _ArrayDoneSearch(tls *libc.TLS, iPtr uintptr, varPtr uintptr, searchPtr uintptr) {
	var hPtr, prevPtr uintptr
	_, _ = hPtr, prevPtr
	/*
	 * Unhook the search from the list of searches associated with the
	 * variable.
	 */
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iPtr + 896)).FfindProc})))(tls, iPtr+896, varPtr)
	if hPtr == libc.UintptrFromInt32(0) {
		return
	}
	if searchPtr == (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData {
		if (*TArraySearch)(unsafe.Pointer(searchPtr)).FnextPtr != 0 {
			(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = (*TArraySearch)(unsafe.Pointer(searchPtr)).FnextPtr
		} else {
			*(*int32)(unsafe.Pointer(varPtr)) &= ^libc.Int32FromInt32(VAR_SEARCH_ACTIVE)
			XTcl_DeleteHashEntry(tls, hPtr)
		}
	} else {
		prevPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		for {
			if (*TArraySearch)(unsafe.Pointer(prevPtr)).FnextPtr == searchPtr {
				(*TArraySearch)(unsafe.Pointer(prevPtr)).FnextPtr = (*TArraySearch)(unsafe.Pointer(searchPtr)).FnextPtr
				break
			}
			goto _1
		_1:
			;
			prevPtr = (*TArraySearch)(unsafe.Pointer(prevPtr)).FnextPtr
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * ArrayAnyMoreCmd --
 *
 *	This object-based function is invoked to process the "array anymore"
 *	Tcl command. See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result object.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _ArrayAnyMoreCmd(tls *libc.TLS, dummy3413 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var gotValue int32
	var iPtr, searchObj, searchPtr, varNameObj uintptr
	var _ /* isArray at bp+8 */ int32
	var _ /* varPtr at bp+0 */ uintptr
	_, _, _, _, _ = gotValue, iPtr, searchObj, searchPtr, varNameObj
	iPtr = interp
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+69224)
		return int32(TCL_ERROR)
	}
	varNameObj = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	searchObj = *(*uintptr)(unsafe.Pointer(objv + 2*8))
	if int32(TCL_ERROR) == _LocateArray(tls, interp, varNameObj, bp, bp+8) {
		return int32(TCL_ERROR)
	}
	if !(*(*int32)(unsafe.Pointer(bp + 8)) != 0) {
		return _NotArrayError(tls, interp, varNameObj)
	}
	/*
	 * Get the search.
	 */
	searchPtr = _ParseSearchId(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), varNameObj, searchObj)
	if searchPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Scan forward to find if there are any further elements in the array
	 * that are defined.
	 */
	for int32(1) != 0 {
		if (*TArraySearch)(unsafe.Pointer(searchPtr)).FnextEntry != libc.UintptrFromInt32(0) {
			*(*uintptr)(unsafe.Pointer(bp)) = (*TArraySearch)(unsafe.Pointer(searchPtr)).FnextEntry - uintptr(uint64(libc.UintptrFromInt32(0)+24))
			if !(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) == libc.UintptrFromInt32(0)) {
				gotValue = int32(1)
				break
			}
		}
		(*TArraySearch)(unsafe.Pointer(searchPtr)).FnextEntry = XTcl_NextHashEntry(tls, searchPtr+24)
		if (*TArraySearch)(unsafe.Pointer(searchPtr)).FnextEntry == libc.UintptrFromInt32(0) {
			gotValue = 0
			break
		}
	}
	XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FexecEnvPtr + 8 + uintptr(gotValue)*8)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * ArrayNextElementCmd --
 *
 *	This object-based function is invoked to process the "array
 *	nextelement" Tcl command. See the user documentation for details on
 *	what it does.
 *
 * Results:
 *	A standard Tcl result object.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _ArrayNextElementCmd(tls *libc.TLS, dummy3491 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var hPtr, searchObj, searchPtr, varNameObj uintptr
	var _ /* isArray at bp+8 */ int32
	var _ /* varPtr at bp+0 */ uintptr
	_, _, _, _ = hPtr, searchObj, searchPtr, varNameObj
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+69224)
		return int32(TCL_ERROR)
	}
	varNameObj = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	searchObj = *(*uintptr)(unsafe.Pointer(objv + 2*8))
	if int32(TCL_ERROR) == _LocateArray(tls, interp, varNameObj, bp, bp+8) {
		return int32(TCL_ERROR)
	}
	if !(*(*int32)(unsafe.Pointer(bp + 8)) != 0) {
		return _NotArrayError(tls, interp, varNameObj)
	}
	/*
	 * Get the search.
	 */
	searchPtr = _ParseSearchId(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), varNameObj, searchObj)
	if searchPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Get the next element from the search, or the empty string on
	 * exhaustion. Note that the [array anymore] command may well have already
	 * pulled a value from the hash enumeration, so we have to check the cache
	 * there first.
	 */
	for int32(1) != 0 {
		hPtr = (*TArraySearch)(unsafe.Pointer(searchPtr)).FnextEntry
		if hPtr == libc.UintptrFromInt32(0) {
			hPtr = XTcl_NextHashEntry(tls, searchPtr+24)
			if hPtr == libc.UintptrFromInt32(0) {
				return TCL_OK
			}
		} else {
			(*TArraySearch)(unsafe.Pointer(searchPtr)).FnextEntry = libc.UintptrFromInt32(0)
		}
		*(*uintptr)(unsafe.Pointer(bp)) = hPtr - uintptr(uint64(libc.UintptrFromInt32(0)+24))
		if !(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) == libc.UintptrFromInt32(0)) {
			XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 24 + 32)))
			return TCL_OK
		}
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * ArrayDoneSearchCmd --
 *
 *	This object-based function is invoked to process the "array
 *	donesearch" Tcl command. See the user documentation for details on
 *	what it does.
 *
 * Results:
 *	A standard Tcl result object.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _ArrayDoneSearchCmd(tls *libc.TLS, dummy3571 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, iPtr, searchObj, searchPtr, varNameObj, v2 uintptr
	var v1 TTcl_Size
	var _ /* isArray at bp+8 */ int32
	var _ /* varPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _ = _objPtr, iPtr, searchObj, searchPtr, varNameObj, v1, v2
	iPtr = interp
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+69224)
		return int32(TCL_ERROR)
	}
	varNameObj = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	searchObj = *(*uintptr)(unsafe.Pointer(objv + 2*8))
	if int32(TCL_ERROR) == _LocateArray(tls, interp, varNameObj, bp, bp+8) {
		return int32(TCL_ERROR)
	}
	if !(*(*int32)(unsafe.Pointer(bp + 8)) != 0) {
		return _NotArrayError(tls, interp, varNameObj)
	}
	/*
	 * Get the search.
	 */
	searchPtr = _ParseSearchId(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), varNameObj, searchObj)
	if searchPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	_ArrayDoneSearch(tls, iPtr, *(*uintptr)(unsafe.Pointer(bp)), searchPtr)
	_objPtr = (*TArraySearch)(unsafe.Pointer(searchPtr)).Fname
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	XTclpFree(tls, searchPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * ArrayExistsCmd --
 *
 *	This object-based function is invoked to process the "array exists"
 *	Tcl command. See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result object.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _ArrayExistsCmd(tls *libc.TLS, dummy3631 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var iPtr uintptr
	var _ /* isArray at bp+0 */ int32
	_ = iPtr
	iPtr = interp
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+69214)
		return int32(TCL_ERROR)
	}
	if int32(TCL_ERROR) == _LocateArray(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), bp) {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FexecEnvPtr + 8 + uintptr(*(*int32)(unsafe.Pointer(bp)))*8)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * ArrayGetCmd --
 *
 *	This object-based function is invoked to process the "array get" Tcl
 *	command. See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result object.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _ArrayGetCmd(tls *libc.TLS, dummy3671 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, nameLstObj, nameObj, pattern, patternObj, tmpResObj, valueObj, varNameObj, varPtr2, v1, v11, v18, v2, v20, v23, v26, v5, v8 uintptr
	var i, v10, v19, v22, v25, v4 TTcl_Size
	var result, v14 int32
	var v12, v13, v21, v24, v27, v3, v6, v9 bool
	var v15, v16 int64
	var _ /* count at bp+40 */ TTcl_Size
	var _ /* isArray at bp+48 */ int32
	var _ /* nameObjPtr at bp+8 */ uintptr
	var _ /* search at bp+16 */ TTcl_HashSearch
	var _ /* varPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, i, nameLstObj, nameObj, pattern, patternObj, result, tmpResObj, valueObj, varNameObj, varPtr2, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v3, v4, v5, v6, v8, v9
	switch objc {
	case int32(2):
		varNameObj = *(*uintptr)(unsafe.Pointer(objv + 1*8))
		patternObj = libc.UintptrFromInt32(0)
	case int32(3):
		varNameObj = *(*uintptr)(unsafe.Pointer(objv + 1*8))
		patternObj = *(*uintptr)(unsafe.Pointer(objv + 2*8))
	default:
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+69243)
		return int32(TCL_ERROR)
	}
	if int32(TCL_ERROR) == _LocateArray(tls, interp, varNameObj, bp, bp+48) {
		return int32(TCL_ERROR)
	}
	/* If not an array, it's an empty result. */
	if !(*(*int32)(unsafe.Pointer(bp + 48)) != 0) {
		return TCL_OK
	}
	if patternObj != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(patternObj)).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(patternObj)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, patternObj, libc.UintptrFromInt32(0))
		}
		v1 = v2
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	pattern = v1
	/*
	 * Store the array names in a new object.
	 */
	if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		nameLstObj = XTclThreadAllocObj(tls)
	} else {
		nameLstObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(nameLstObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(nameLstObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(nameLstObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(nameLstObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(nameLstObj)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(nameLstObj)).FrefCount++
	if patternObj != libc.UintptrFromInt32(0) && libc.Xstrpbrk(tls, pattern, __ccgo_ts+16411) == libc.UintptrFromInt32(0) {
		varPtr2 = _VarHashCreateVar1(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)), patternObj, libc.UintptrFromInt32(0))
		if varPtr2 == libc.UintptrFromInt32(0) {
			goto searchDone
		}
		if *(*uintptr)(unsafe.Pointer(varPtr2 + 8)) == libc.UintptrFromInt32(0) {
			goto searchDone
		}
		result = XTcl_ListObjAppendElement(tls, interp, nameLstObj, *(*uintptr)(unsafe.Pointer(varPtr2 + 24 + 32)))
		if result != TCL_OK {
			v5 = nameLstObj
			v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
			*(*TTcl_Size)(unsafe.Pointer(v5))--
			if !(v4 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(nameLstObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(nameLstObj)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(nameLstObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(nameLstObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(nameLstObj)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(nameLstObj)).Flength = int64(-libc.Int32FromInt32(1))
					if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
						cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v6 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, nameLstObj)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(nameLstObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = nameLstObj
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, nameLstObj)
				}
			}
			return result
		}
		goto searchDone
	}
	varPtr2 = _VarHashFirstVar(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)), bp+16)
	for {
		if !(varPtr2 != 0) {
			break
		}
		if *(*uintptr)(unsafe.Pointer(varPtr2 + 8)) == libc.UintptrFromInt32(0) {
			goto _7
		}
		nameObj = *(*uintptr)(unsafe.Pointer(varPtr2 + 24 + 32))
		if v9 = patternObj != 0; v9 {
			if (*TTcl_Obj)(unsafe.Pointer(nameObj)).Fbytes != 0 {
				v8 = (*TTcl_Obj)(unsafe.Pointer(nameObj)).Fbytes
			} else {
				v8 = XTcl_GetStringFromObj(tls, nameObj, libc.UintptrFromInt32(0))
			}
		}
		if v9 && !(XTcl_StringCaseMatch(tls, v8, pattern, 0) != 0) {
			goto _7 /* Element name doesn't match pattern. */
		}
		result = XTcl_ListObjAppendElement(tls, interp, nameLstObj, nameObj)
		if result != TCL_OK {
			v11 = nameLstObj
			v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
			*(*TTcl_Size)(unsafe.Pointer(v11))--
			if !(v10 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(nameLstObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(nameLstObj)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(nameLstObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(nameLstObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(nameLstObj)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(nameLstObj)).Flength = int64(-libc.Int32FromInt32(1))
					if v12 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v12 {
						cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v12 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, nameLstObj)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(nameLstObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = nameLstObj
						(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, nameLstObj)
				}
			}
			return result
		}
		goto _7
	_7:
		;
		varPtr2 = _VarHashNextVar(tls, bp+16)
	}
	/*
	 * Make sure the Var structure of the array is not removed by a trace
	 * while we're working.
	 */
	goto searchDone
searchDone:
	;
	if (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
		(*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FrefCount++
	}
	/*
	 * Get the array values corresponding to each element name.
	 */
	if v13 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v13 {
		cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v13 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
		tmpResObj = XTclThreadAllocObj(tls)
	} else {
		tmpResObj = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(tmpResObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(tmpResObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(tmpResObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(tmpResObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(tmpResObj)).FtypePtr = libc.UintptrFromInt32(0)
	if (*TTcl_Obj)(unsafe.Pointer(nameLstObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(nameLstObj + 32))).Fptr2 != 0 {
			v15 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(nameLstObj + 32))).Fptr2)).FspanStart
		} else {
			v15 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(nameLstObj + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(nameLstObj + 32))).Fptr1 + 40 + uintptr(v15)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(nameLstObj + 32))).Fptr2 != 0 {
			v16 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(nameLstObj + 32))).Fptr2)).FspanLength
		} else {
			v16 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(nameLstObj + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 40)) = v16
		v14 = libc.Int32FromInt32(TCL_OK)
	} else {
		v14 = XTcl_ListObjGetElements(tls, interp, nameLstObj, bp+40, bp+8)
	}
	result = v14
	if result != TCL_OK {
		goto errorInArrayGet
	}
	i = 0
	for {
		if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 40))) {
			break
		}
		v18 = *(*uintptr)(unsafe.Pointer(bp + 8))
		*(*uintptr)(unsafe.Pointer(bp + 8)) += 8
		nameObj = *(*uintptr)(unsafe.Pointer(v18))
		valueObj = XTcl_ObjGetVar2(tls, interp, varNameObj, nameObj, int32(TCL_LEAVE_ERR_MSG))
		if valueObj == libc.UintptrFromInt32(0) {
			/*
			 * Some trace played a trick on us; we need to diagnose to adapt
			 * our behaviour: was the array element unset, or did the
			 * modification modify the complete array?
			 */
			if (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fflags&int32(VAR_ARRAY) != 0 {
				/*
				 * The array itself looks OK, the variable was undefined:
				 * forget it.
				 */
				goto _17
			}
			result = int32(TCL_ERROR)
			goto errorInArrayGet
		}
		result = XTcl_DictObjPut(tls, interp, tmpResObj, nameObj, valueObj)
		if result != TCL_OK {
			goto errorInArrayGet
		}
		goto _17
	_17:
		;
		i++
	}
	if (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
		(*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FrefCount--
	}
	XTcl_SetObjResult(tls, interp, tmpResObj)
	v20 = nameLstObj
	v19 = *(*TTcl_Size)(unsafe.Pointer(v20))
	*(*TTcl_Size)(unsafe.Pointer(v20))--
	if !(v19 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(nameLstObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(nameLstObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(nameLstObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(nameLstObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(nameLstObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(nameLstObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v21 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v21 {
				cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v21 || ((*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, nameLstObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(nameLstObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = nameLstObj
				(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, nameLstObj)
		}
	}
	return TCL_OK
	goto errorInArrayGet
errorInArrayGet:
	;
	if (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
		(*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FrefCount--
	}
	v23 = nameLstObj
	v22 = *(*TTcl_Size)(unsafe.Pointer(v23))
	*(*TTcl_Size)(unsafe.Pointer(v23))--
	if !(v22 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(nameLstObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(nameLstObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(nameLstObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(nameLstObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(nameLstObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(nameLstObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v24 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v24 {
				cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v24 || ((*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, nameLstObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(nameLstObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = nameLstObj
				(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, nameLstObj)
		}
	}
	v26 = tmpResObj
	v25 = *(*TTcl_Size)(unsafe.Pointer(v26))
	*(*TTcl_Size)(unsafe.Pointer(v26))--
	if !(v25 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(tmpResObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(tmpResObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(tmpResObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(tmpResObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(tmpResObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(tmpResObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v27 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v27 {
				cachePtr6 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v27 || ((*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, tmpResObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(tmpResObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr = tmpResObj
				(*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, tmpResObj)
		}
	} /* Free unneeded temp result. */
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * ArrayNamesCmd --
 *
 *	This object-based function is invoked to process the "array names" Tcl
 *	command. See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result object.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _ArrayNamesCmd(tls *libc.TLS, dummy3831 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var cachePtr, cachePtr1, name, nameObj, pattern, patternObj, resultObj, varPtr2, v1, v3, v5, v7 uintptr
	var matched int32
	var v2, v8 bool
	var v6 TTcl_Size
	var _ /* isArray at bp+40 */ int32
	var _ /* mode at bp+0 */ int32
	var _ /* search at bp+16 */ TTcl_HashSearch
	var _ /* varPtr at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, matched, name, nameObj, pattern, patternObj, resultObj, varPtr2, v1, v2, v3, v5, v6, v7, v8
	*(*int32)(unsafe.Pointer(bp)) = 1
	pattern = libc.UintptrFromInt32(0)
	if objc < int32(2) || objc > int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+69263)
		return int32(TCL_ERROR)
	}
	if objc > int32(2) {
		v1 = *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8))
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	patternObj = v1
	if int32(TCL_ERROR) == _LocateArray(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+8, bp+40) {
		return int32(TCL_ERROR)
	}
	/*
	 * Finish parsing the arguments.
	 */
	if objc == int32(4) && XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), uintptr(unsafe.Pointer(&_options19)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	/* If not an array, the result is empty. */
	if !(*(*int32)(unsafe.Pointer(bp + 40)) != 0) {
		return TCL_OK
	}
	/*
	 * Check for the trivial cases where we can use a direct lookup.
	 */
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	if patternObj != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(patternObj)).Fbytes != 0 {
			v3 = (*TTcl_Obj)(unsafe.Pointer(patternObj)).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, patternObj, libc.UintptrFromInt32(0))
		}
		pattern = v3
	}
	if *(*int32)(unsafe.Pointer(bp)) == 1 && patternObj != 0 && libc.Xstrpbrk(tls, pattern, __ccgo_ts+16411) == libc.UintptrFromInt32(0) || *(*int32)(unsafe.Pointer(bp)) == 0 {
		varPtr2 = _VarHashCreateVar1(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8)), patternObj, libc.UintptrFromInt32(0))
		if varPtr2 != libc.UintptrFromInt32(0) && !(*(*uintptr)(unsafe.Pointer(varPtr2 + 8)) == libc.UintptrFromInt32(0)) {
			/*
			 * This can't fail; lappending to an empty object always works.
			 */
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, *(*uintptr)(unsafe.Pointer(varPtr2 + 24 + 32)))
		}
		XTcl_SetObjResult(tls, interp, resultObj)
		return TCL_OK
	}
	/*
	 * Must scan the array to select the elements.
	 */
	varPtr2 = _VarHashFirstVar(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8)), bp+16)
	for {
		if !(varPtr2 != libc.UintptrFromInt32(0)) {
			break
		}
		if *(*uintptr)(unsafe.Pointer(varPtr2 + 8)) == libc.UintptrFromInt32(0) {
			goto _4
		}
		nameObj = *(*uintptr)(unsafe.Pointer(varPtr2 + 24 + 32))
		if patternObj != 0 {
			if (*TTcl_Obj)(unsafe.Pointer(nameObj)).Fbytes != 0 {
				v5 = (*TTcl_Obj)(unsafe.Pointer(nameObj)).Fbytes
			} else {
				v5 = XTcl_GetStringFromObj(tls, nameObj, libc.UintptrFromInt32(0))
			}
			name = v5
			matched = 0
			switch *(*int32)(unsafe.Pointer(bp)) {
			case 0:
				XTcl_Panic(tls, __ccgo_ts+69290, 0)
				fallthrough
			case 1:
				matched = XTcl_StringCaseMatch(tls, name, pattern, 0)
			case 2:
				matched = XTcl_RegExpMatchObj(tls, interp, nameObj, patternObj)
				if matched < 0 {
					v7 = resultObj
					v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
					*(*TTcl_Size)(unsafe.Pointer(v7))--
					if !(v6 > int64(1)) {
						if !((*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr)).FfreeIntRepProc != 0) {
							if (*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
								XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes)
							}
							(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = int64(-libc.Int32FromInt32(1))
							if v8 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v8 {
								cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
							}
							if v8 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
								XTclThreadFreeObj(tls, resultObj)
							} else {
								(*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer(resultObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
								(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = resultObj
								(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
							}
						} else {
							XTclFreeObj(tls, resultObj)
						}
					}
					return int32(TCL_ERROR)
				}
				break
			}
			if matched == 0 {
				goto _4
			}
		}
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, nameObj)
		goto _4
	_4:
		;
		varPtr2 = _VarHashNextVar(tls, bp+16)
	}
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
}

var _options19 = [4]uintptr{
	0: __ccgo_ts + 17506,
	1: __ccgo_ts + 17513,
	2: __ccgo_ts + 17574,
	3: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * TclFindArrayPtrElements --
 *
 *	Fill out a hash table (which *must* use Tcl_Obj* keys) with an entry
 *	for each existing element of the given array. The provided hash table
 *	is assumed to be initially empty.
 *
 * Result:
 *	none
 *
 * Side effects:
 *	The keys of the array gain an extra reference. The supplied hash table
 *	has elements added to it.
 *
 *----------------------------------------------------------------------
 */

func XTclFindArrayPtrElements(tls *libc.TLS, arrayPtr uintptr, tablePtr uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var hPtr, nameObj, varPtr uintptr
	var _ /* dummy at bp+24 */ int32
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _ = hPtr, nameObj, varPtr
	if arrayPtr == libc.UintptrFromInt32(0) || !((*TVar)(unsafe.Pointer(arrayPtr)).Fflags&libc.Int32FromInt32(VAR_ARRAY) != 0) || *(*uintptr)(unsafe.Pointer(arrayPtr + 8)) == libc.UintptrFromInt32(0) {
		return
	}
	varPtr = _VarHashFirstVar(tls, *(*uintptr)(unsafe.Pointer(arrayPtr + 8)), bp)
	for {
		if !(varPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if *(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0) {
			goto _1
		}
		nameObj = *(*uintptr)(unsafe.Pointer(varPtr + 24 + 32))
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(tablePtr)).FcreateProc})))(tls, tablePtr, nameObj, bp+24)
		(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = nameObj
		goto _1
	_1:
		;
		varPtr = _VarHashNextVar(tls, bp)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * ArraySetCmd --
 *
 *	This object-based function is invoked to process the "array set" Tcl
 *	command. See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result object.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _ArraySetCmd(tls *libc.TLS, dummy3998 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(128)
	defer tls.Free(128)
	var _objPtr, arrayElemObj, arrayNameObj, copyListObj, elemVarPtr, elemVarPtr1, varPtr, v1, v10 uintptr
	var i, v9 TTcl_Size
	var result, v3, v5 int32
	var v4, v6, v7 int64
	var _ /* arrayPtr at bp+0 */ uintptr
	var _ /* done at bp+48 */ int32
	var _ /* elemLen at bp+64 */ TTcl_Size
	var _ /* elemPtrs at bp+72 */ uintptr
	var _ /* keyPtr at bp+8 */ uintptr
	var _ /* search at bp+24 */ TTcl_DictSearch
	var _ /* size at bp+56 */ TTcl_Size
	var _ /* valuePtr at bp+16 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, arrayElemObj, arrayNameObj, copyListObj, elemVarPtr, elemVarPtr1, i, result, varPtr, v1, v10, v3, v4, v5, v6, v7, v9
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+69324)
		return int32(TCL_ERROR)
	}
	if int32(TCL_ERROR) == _LocateArray(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0)) {
		return int32(TCL_ERROR)
	}
	arrayNameObj = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	varPtr = XTclObjLookupVarEx(tls, interp, arrayNameObj, libc.UintptrFromInt32(0), int32(TCL_LEAVE_ERR_MSG), __ccgo_ts+5383, int32(1), int32(1), bp)
	if varPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if *(*uintptr)(unsafe.Pointer(bp)) != 0 {
		_CleanupVar(tls, varPtr, *(*uintptr)(unsafe.Pointer(bp)))
		XTclObjVarErrMsg(tls, interp, arrayNameObj, libc.UintptrFromInt32(0), __ccgo_ts+5383, uintptr(unsafe.Pointer(&_NEEDARRAY)), -int32(1))
		if (*TTcl_Obj)(unsafe.Pointer(arrayNameObj)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(arrayNameObj)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, arrayNameObj, libc.UintptrFromInt32(0))
		}
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+88, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+68940, v1, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Install the contents of the dictionary or list into the array.
	 */
	arrayElemObj = *(*uintptr)(unsafe.Pointer(objv + 2*8))
	if (*TTcl_Obj)(unsafe.Pointer(arrayElemObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclDictType)) && (*TTcl_Obj)(unsafe.Pointer(arrayElemObj)).Fbytes == libc.UintptrFromInt32(0) {
		if XTcl_DictObjSize(tls, interp, arrayElemObj, bp+56) != TCL_OK {
			return int32(TCL_ERROR)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 56)) == 0 {
			/*
			 * Empty, so we'll just force the array to be properly existing
			 * instead.
			 */
			goto ensureArray
		}
		/*
		 * Don't need to look at result of Tcl_DictObjFirst as we've just
		 * successfully used a dictionary operation on the same object.
		 */
		XTcl_DictObjFirst(tls, interp, arrayElemObj, bp+24, bp+8, bp+16, bp+48)
		for {
			if !!(*(*int32)(unsafe.Pointer(bp + 48)) != 0) {
				break
			}
			/*
			 * At this point, it would be nice if the key was directly usable
			 * by the array. This isn't the case though.
			 */
			elemVarPtr = XTclLookupArrayElement(tls, interp, arrayNameObj, *(*uintptr)(unsafe.Pointer(bp + 8)), int32(TCL_LEAVE_ERR_MSG), __ccgo_ts+5383, int32(1), int32(1), varPtr, -int32(1))
			if elemVarPtr == libc.UintptrFromInt32(0) || XTclPtrSetVarIdx(tls, interp, elemVarPtr, varPtr, arrayNameObj, *(*uintptr)(unsafe.Pointer(bp + 8)), *(*uintptr)(unsafe.Pointer(bp + 16)), int32(TCL_LEAVE_ERR_MSG), -int32(1)) == libc.UintptrFromInt32(0) {
				XTcl_DictObjDone(tls, bp+24)
				return int32(TCL_ERROR)
			}
			goto _2
		_2:
			;
			XTcl_DictObjNext(tls, bp+24, bp+8, bp+16, bp+48)
		}
		return TCL_OK
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(arrayElemObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(arrayElemObj + 32))).Fptr2 != 0 {
				v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(arrayElemObj + 32))).Fptr2)).FspanLength
			} else {
				v4 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(arrayElemObj + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 64)) = v4
			v3 = libc.Int32FromInt32(TCL_OK)
		} else {
			v3 = XTcl_ListObjLength(tls, interp, arrayElemObj, bp+64)
		}
		result = v3
		if result != TCL_OK {
			return result
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 64))&int64(1) != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+21399, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+88, __ccgo_ts+2004, __ccgo_ts+16490, __ccgo_ts+65404, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 64)) == 0 {
			goto ensureArray
		}
		if (*TTcl_Obj)(unsafe.Pointer(arrayElemObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(arrayElemObj + 32))).Fptr2 != 0 {
				v6 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(arrayElemObj + 32))).Fptr2)).FspanStart
			} else {
				v6 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(arrayElemObj + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 72)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(arrayElemObj + 32))).Fptr1 + 40 + uintptr(v6)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(arrayElemObj + 32))).Fptr2 != 0 {
				v7 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(arrayElemObj + 32))).Fptr2)).FspanLength
			} else {
				v7 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(arrayElemObj + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 64)) = v7
			v5 = libc.Int32FromInt32(TCL_OK)
		} else {
			v5 = XTcl_ListObjGetElements(tls, interp, arrayElemObj, bp+64, bp+72)
		}
		result = v5
		if result != TCL_OK {
			return result
		}
		/*
		 * We needn't worry about traces invalidating arrayPtr: should that be
		 * the case, TclPtrSetVarIdx will return NULL so that we break out of
		 * the loop and return an error.
		 */
		copyListObj = XTclListObjCopy(tls, libc.UintptrFromInt32(0), arrayElemObj)
		if !(copyListObj != 0) {
			return int32(TCL_ERROR)
		}
		i = 0
		for {
			if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 64))) {
				break
			}
			elemVarPtr1 = XTclLookupArrayElement(tls, interp, arrayNameObj, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)) + uintptr(i)*8)), int32(TCL_LEAVE_ERR_MSG), __ccgo_ts+5383, int32(1), int32(1), varPtr, -int32(1))
			if elemVarPtr1 == libc.UintptrFromInt32(0) || XTclPtrSetVarIdx(tls, interp, elemVarPtr1, varPtr, arrayNameObj, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)) + uintptr(i)*8)), *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 72)) + uintptr(i+int64(1))*8)), int32(TCL_LEAVE_ERR_MSG), -int32(1)) == libc.UintptrFromInt32(0) {
				result = int32(TCL_ERROR)
				break
			}
			goto _8
		_8:
			;
			i += int64(2)
		}
		_objPtr = copyListObj
		v10 = _objPtr
		v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
		*(*TTcl_Size)(unsafe.Pointer(v10))--
		if v9 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		return result
	}
	/*
	 * The list is empty make sure we have an array, or create one if
	 * necessary.
	 */
	goto ensureArray
ensureArray:
	;
	if varPtr != libc.UintptrFromInt32(0) {
		if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_ARRAY) != 0 {
			/*
			 * Already an array, done.
			 */
			return TCL_OK
		}
		if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_ARRAY_ELEMENT) != 0 || !(*(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0)) {
			/*
			 * Either an array element, or a scalar: lose!
			 */
			XTclObjVarErrMsg(tls, interp, arrayNameObj, libc.UintptrFromInt32(0), __ccgo_ts+32269, uintptr(unsafe.Pointer(&_NEEDARRAY)), -int32(1))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+88, __ccgo_ts+2004, __ccgo_ts+32300, __ccgo_ts+32306, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
	}
	XTclInitArrayVar(tls, varPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * ArraySizeCmd --
 *
 *	This object-based function is invoked to process the "array size" Tcl
 *	command. See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result object.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _ArraySizeCmd(tls *libc.TLS, dummy4182 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var size int32
	var varPtr2 uintptr
	var _ /* isArray at bp+32 */ int32
	var _ /* search at bp+8 */ TTcl_HashSearch
	var _ /* varPtr at bp+0 */ uintptr
	_, _ = size, varPtr2
	size = 0
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+69214)
		return int32(TCL_ERROR)
	}
	if int32(TCL_ERROR) == _LocateArray(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp, bp+32) {
		return int32(TCL_ERROR)
	}
	/* We can only iterate over the array if it exists... */
	if *(*int32)(unsafe.Pointer(bp + 32)) != 0 {
		/*
		 * Must iterate in order to get chance to check for present but
		 * "undefined" entries.
		 */
		varPtr2 = _VarHashFirstVar(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)), bp+8)
		for {
			if !(varPtr2 != libc.UintptrFromInt32(0)) {
				break
			}
			if !(*(*uintptr)(unsafe.Pointer(varPtr2 + 8)) == libc.UintptrFromInt32(0)) {
				size++
			}
			goto _1
		_1:
			;
			varPtr2 = _VarHashNextVar(tls, bp+8)
		}
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, int64(size)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * ArrayStatsCmd --
 *
 *	This object-based function is invoked to process the "array
 *	statistics" Tcl command. See the user documentation for details on
 *	what it does.
 *
 * Results:
 *	A standard Tcl result object.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _ArrayStatsCmd(tls *libc.TLS, dummy4241 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var stats, varNameObj uintptr
	var _ /* isArray at bp+8 */ int32
	var _ /* varPtr at bp+0 */ uintptr
	_, _ = stats, varNameObj
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+69214)
		return int32(TCL_ERROR)
	}
	varNameObj = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	if int32(TCL_ERROR) == _LocateArray(tls, interp, varNameObj, bp, bp+8) {
		return int32(TCL_ERROR)
	}
	if !(*(*int32)(unsafe.Pointer(bp + 8)) != 0) {
		return _NotArrayError(tls, interp, varNameObj)
	}
	stats = XTcl_HashStats(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)))
	if stats == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+69339, int64(-int32(1))))
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, stats, int64(-int32(1))))
	XTclpFree(tls, stats)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * ArrayUnsetCmd --
 *
 *	This object-based function is invoked to process the "array unset" Tcl
 *	command. See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result object.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _ArrayUnsetCmd(tls *libc.TLS, dummy4295 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var nameObj, pattern, patternObj, protectedVarPtr, varNameObj, varPtr2, v1, v3 uintptr
	var unsetFlags int32
	var _ /* isArray at bp+32 */ int32
	var _ /* search at bp+8 */ TTcl_HashSearch
	var _ /* varPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _ = nameObj, pattern, patternObj, protectedVarPtr, unsetFlags, varNameObj, varPtr2, v1, v3
	unsetFlags = 0
	switch objc {
	case int32(2):
		varNameObj = *(*uintptr)(unsafe.Pointer(objv + 1*8))
		patternObj = libc.UintptrFromInt32(0)
	case int32(3):
		varNameObj = *(*uintptr)(unsafe.Pointer(objv + 1*8))
		patternObj = *(*uintptr)(unsafe.Pointer(objv + 2*8))
	default:
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+69243)
		return int32(TCL_ERROR)
	}
	if int32(TCL_ERROR) == _LocateArray(tls, interp, varNameObj, bp, bp+32) {
		return int32(TCL_ERROR)
	}
	if !(*(*int32)(unsafe.Pointer(bp + 32)) != 0) {
		return TCL_OK
	}
	if !(patternObj != 0) {
		/*
		 * When no pattern is given, just unset the whole array.
		 */
		return XTclObjUnsetVar2(tls, interp, varNameObj, libc.UintptrFromInt32(0), 0)
	}
	/*
	 * With a trivial pattern, we can just unset.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(patternObj)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(patternObj)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, patternObj, libc.UintptrFromInt32(0))
	}
	pattern = v1
	if libc.Xstrpbrk(tls, pattern, __ccgo_ts+16411) == libc.UintptrFromInt32(0) {
		varPtr2 = _VarHashCreateVar1(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)), patternObj, libc.UintptrFromInt32(0))
		if !(varPtr2 != 0) || *(*uintptr)(unsafe.Pointer(varPtr2 + 8)) == libc.UintptrFromInt32(0) {
			return TCL_OK
		}
		return XTclPtrUnsetVarIdx(tls, interp, varPtr2, *(*uintptr)(unsafe.Pointer(bp)), varNameObj, patternObj, unsetFlags, -int32(1))
	}
	/*
	 * Non-trivial case (well, deeply tricky really). We peek inside the hash
	 * iterator in order to allow us to guarantee that the following element
	 * in the array will not be scrubbed until we have dealt with it. This
	 * stops the overall iterator from ending up pointing into deallocated
	 * memory. [Bug 2939073]
	 */
	protectedVarPtr = libc.UintptrFromInt32(0)
	varPtr2 = _VarHashFirstVar(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)), bp+8)
	for {
		if !(varPtr2 != libc.UintptrFromInt32(0)) {
			break
		}
		/*
		 * Drop the extra ref immediately. We don't need to free it at this
		 * point though; we'll be unsetting it if necessary soon.
		 */
		if varPtr2 == protectedVarPtr {
			(*TVarInHash)(unsafe.Pointer(varPtr2)).FrefCount--
		}
		/*
		 * Guard the next (peeked) item in the search chain by incrementing
		 * its refcount. This guarantees that the hash table iterator won't be
		 * dangling on the next time through the loop.
		 */
		if (*(*TTcl_HashSearch)(unsafe.Pointer(bp + 8))).FnextEntryPtr != libc.UintptrFromInt32(0) {
			protectedVarPtr = (*(*TTcl_HashSearch)(unsafe.Pointer(bp + 8))).FnextEntryPtr - uintptr(uint64(libc.UintptrFromInt32(0)+24))
			(*TVarInHash)(unsafe.Pointer(protectedVarPtr)).FrefCount++
		} else {
			protectedVarPtr = libc.UintptrFromInt32(0)
		}
		/*
		 * If the variable is undefined, clean it out as it has been hit by
		 * something else (i.e., an unset trace).
		 */
		if *(*uintptr)(unsafe.Pointer(varPtr2 + 8)) == libc.UintptrFromInt32(0) {
			_CleanupVar(tls, varPtr2, *(*uintptr)(unsafe.Pointer(bp)))
			goto _2
		}
		nameObj = *(*uintptr)(unsafe.Pointer(varPtr2 + 24 + 32))
		if (*TTcl_Obj)(unsafe.Pointer(nameObj)).Fbytes != 0 {
			v3 = (*TTcl_Obj)(unsafe.Pointer(nameObj)).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, nameObj, libc.UintptrFromInt32(0))
		}
		if XTcl_StringCaseMatch(tls, v3, pattern, 0) != 0 && XTclPtrUnsetVarIdx(tls, interp, varPtr2, *(*uintptr)(unsafe.Pointer(bp)), varNameObj, nameObj, unsetFlags, -int32(1)) != TCL_OK {
			/*
			 * If we incremented a refcount, we must decrement it here as we
			 * will not be coming back properly due to the error.
			 */
			if protectedVarPtr != 0 {
				(*TVarInHash)(unsafe.Pointer(protectedVarPtr)).FrefCount--
				_CleanupVar(tls, protectedVarPtr, *(*uintptr)(unsafe.Pointer(bp)))
			}
			return int32(TCL_ERROR)
		}
		goto _2
	_2:
		;
		varPtr2 = _VarHashNextVar(tls, bp+8)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclInitArrayCmd --
 *
 *	This creates the ensemble for the "array" command.
 *
 * Results:
 *	The handle for the created ensemble.
 *
 * Side effects:
 *	Creates a command in the global namespace.
 *
 *----------------------------------------------------------------------
 */

func XTclInitArrayCmd(tls *libc.TLS, interp uintptr) (r TTcl_Command) {
	return XTclMakeEnsemble(tls, interp, __ccgo_ts+28190, uintptr(unsafe.Pointer(&_arrayImplMap)))
}

/* Current interpreter. */
var _arrayImplMap = [14]TEnsembleImplMap{
	0: {
		Fname: __ccgo_ts + 69370,
	},
	1: {
		Fname: __ccgo_ts + 16043,
	},
	2: {
		Fname: __ccgo_ts + 69378,
	},
	3: {
		Fname: __ccgo_ts + 5689,
	},
	4: {
		Fname: __ccgo_ts + 5187,
	},
	5: {
		Fname: __ccgo_ts + 24987,
	},
	6: {
		Fname: __ccgo_ts + 15007,
	},
	7: {
		Fname: __ccgo_ts + 69389,
	},
	8: {
		Fname: __ccgo_ts + 5383,
	},
	9: {
		Fname: __ccgo_ts + 5807,
	},
	10: {
		Fname: __ccgo_ts + 69401,
	},
	11: {
		Fname: __ccgo_ts + 69413,
	},
	12: {
		Fname: __ccgo_ts + 3450,
	},
	13: {},
}

func init() {
	p := unsafe.Pointer(&_arrayImplMap)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_ArrayAnyMoreCmd)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(XTclCompileBasic2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(_ArrayDefaultCmd)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(XTclCompileBasic2Or3ArgCmd)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(_ArrayDoneSearchCmd)
	*(*uintptr)(unsafe.Add(p, 112)) = __ccgo_fp(XTclCompileBasic2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 152)) = __ccgo_fp(_ArrayExistsCmd)
	*(*uintptr)(unsafe.Add(p, 160)) = __ccgo_fp(XTclCompileArrayExistsCmd)
	*(*uintptr)(unsafe.Add(p, 200)) = __ccgo_fp(_ArrayForObjCmd)
	*(*uintptr)(unsafe.Add(p, 208)) = __ccgo_fp(XTclCompileBasic3ArgCmd)
	*(*uintptr)(unsafe.Add(p, 216)) = __ccgo_fp(_ArrayForNRCmd)
	*(*uintptr)(unsafe.Add(p, 248)) = __ccgo_fp(_ArrayGetCmd)
	*(*uintptr)(unsafe.Add(p, 256)) = __ccgo_fp(XTclCompileBasic1Or2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 296)) = __ccgo_fp(_ArrayNamesCmd)
	*(*uintptr)(unsafe.Add(p, 304)) = __ccgo_fp(XTclCompileBasic1To3ArgCmd)
	*(*uintptr)(unsafe.Add(p, 344)) = __ccgo_fp(_ArrayNextElementCmd)
	*(*uintptr)(unsafe.Add(p, 352)) = __ccgo_fp(XTclCompileBasic2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 392)) = __ccgo_fp(_ArraySetCmd)
	*(*uintptr)(unsafe.Add(p, 400)) = __ccgo_fp(XTclCompileArraySetCmd)
	*(*uintptr)(unsafe.Add(p, 440)) = __ccgo_fp(_ArraySizeCmd)
	*(*uintptr)(unsafe.Add(p, 448)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 488)) = __ccgo_fp(_ArrayStartSearchCmd)
	*(*uintptr)(unsafe.Add(p, 496)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 536)) = __ccgo_fp(_ArrayStatsCmd)
	*(*uintptr)(unsafe.Add(p, 544)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 584)) = __ccgo_fp(_ArrayUnsetCmd)
	*(*uintptr)(unsafe.Add(p, 592)) = __ccgo_fp(XTclCompileArrayUnsetCmd)
}

/*
 *----------------------------------------------------------------------
 *
 * ObjMakeUpvar --
 *
 *	This function does all of the work of the "global" and "upvar"
 *	commands.
 *
 * Results:
 *	A standard Tcl completion code. If an error occurs then an error
 *	message is left in interp.
 *
 * Side effects:
 *	The variable given by myName is linked to the variable in framePtr
 *	given by otherP1 and otherP2, so that references to myName are
 *	redirected to the other variable like a symbolic link.
 *	Callers must Incr myNamePtr if they plan to Decr it.
 *	Callers must Incr otherP1Ptr if they plan to Decr it.
 *
 *----------------------------------------------------------------------
 */

func _ObjMakeUpvar(tls *libc.TLS, interp uintptr, framePtr uintptr, otherP1Ptr uintptr, otherP2 uintptr, otherFlags int32, myNamePtr uintptr, myFlags int32, index int32) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* If the variable to be linked is an indexed
	 * scalar, this is its index. Otherwise, -1 */
	var iPtr, otherPtr, varFramePtr, v2, v4, v6, v9 uintptr
	var v1 int32
	var v3, v5, v7, v8 bool
	var _ /* arrayPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _ = iPtr, otherPtr, varFramePtr, v1, v2, v3, v4, v5, v6, v7, v8, v9
	iPtr = interp
	/*
	 * Find "other" in "framePtr". If not looking up other in just the current
	 * namespace, temporarily replace the current var frame pointer in the
	 * interpreter in order to use TclObjLookupVar.
	 */
	if framePtr == libc.UintptrFromInt32(0) {
		framePtr = (*TInterp)(unsafe.Pointer(iPtr)).FrootFramePtr
	}
	varFramePtr = (*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr
	if !(otherFlags&libc.Int32FromInt32(TCL_NAMESPACE_ONLY) != 0) {
		(*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr = framePtr
	}
	otherPtr = XTclObjLookupVar(tls, interp, otherP1Ptr, otherP2, otherFlags|int32(TCL_LEAVE_ERR_MSG), __ccgo_ts+32162, int32(1), int32(1), bp)
	if !(otherFlags&libc.Int32FromInt32(TCL_NAMESPACE_ONLY) != 0) {
		(*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr = varFramePtr
	}
	if otherPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Check that we are not trying to create a namespace var linked to a
	 * local variable in a procedure. If we allowed this, the local
	 * variable in the shorter-lived procedure frame could go away leaving
	 * the namespace var's reference invalid.
	 */
	if index < 0 {
		if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
			if v3 = (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fflags&int32(VAR_IN_HASHTABLE) != 0; v3 {
				if (*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
					v2 = (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fentry.FtablePtr)).FnsPtr
				} else {
					v2 = libc.UintptrFromInt32(0)
				}
			}
			v1 = libc.BoolInt32(v3 && v2 != 0)
		} else {
			if v5 = (*TVar)(unsafe.Pointer(otherPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0; v5 {
				if (*TVar)(unsafe.Pointer(otherPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
					v4 = (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(otherPtr)).Fentry.FtablePtr)).FnsPtr
				} else {
					v4 = libc.UintptrFromInt32(0)
				}
			}
			v1 = libc.BoolInt32(v5 && v4 != 0)
		}
		if v8 = !(v1 != 0); v8 {
			if v7 = myFlags&(libc.Int32FromInt32(TCL_GLOBAL_ONLY)|libc.Int32FromInt32(TCL_NAMESPACE_ONLY)) != 0 || varFramePtr == libc.UintptrFromInt32(0) || !((*TCallFrame)(unsafe.Pointer(varFramePtr)).FisProcCallFrame&libc.Int32FromInt32(FRAME_IS_PROC) != 0); !v7 {
				if (*TTcl_Obj)(unsafe.Pointer(myNamePtr)).Fbytes != 0 {
					v6 = (*TTcl_Obj)(unsafe.Pointer(myNamePtr)).Fbytes
				} else {
					v6 = XTcl_GetStringFromObj(tls, myNamePtr, libc.UintptrFromInt32(0))
				}
			}
		}
		if v8 && (v7 || libc.Xstrstr(tls, v6, __ccgo_ts+7650) != libc.UintptrFromInt32(0)) {
			if (*TTcl_Obj)(unsafe.Pointer(myNamePtr)).Fbytes != 0 {
				v9 = (*TTcl_Obj)(unsafe.Pointer(myNamePtr)).Fbytes
			} else {
				v9 = XTcl_GetStringFromObj(tls, myNamePtr, libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, iPtr, XTcl_ObjPrintf(tls, __ccgo_ts+69424, libc.VaList(bp+16, v9)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+69514, __ccgo_ts+69520, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
	}
	return XTclPtrObjMakeUpvarIdx(tls, interp, otherPtr, myNamePtr, myFlags, index)
}

/*
 *----------------------------------------------------------------------
 *
 * TclPtrMakeUpvar --
 *
 *	This procedure does all of the work of the "global" and "upvar"
 *	commands.
 *
 * Results:
 *	A standard Tcl completion code. If an error occurs then an error
 *	message is left in interp.
 *
 * Side effects:
 *	The variable given by myName is linked to the variable in framePtr
 *	given by otherP1 and otherP2, so that references to myName are
 *	redirected to the other variable like a symbolic link.
 *
 *----------------------------------------------------------------------
 */

func XTclPtrMakeUpvar(tls *libc.TLS, interp uintptr, otherPtr uintptr, myName uintptr, myFlags int32, index int32) (r int32) {
	/* If the variable to be linked is an indexed
	 * scalar, this is its index. Otherwise, -1 */
	var _objPtr, myNamePtr, v2 uintptr
	var result int32
	var v1 TTcl_Size
	_, _, _, _, _ = _objPtr, myNamePtr, result, v1, v2
	myNamePtr = libc.UintptrFromInt32(0)
	if myName != 0 {
		myNamePtr = XTcl_NewStringObj(tls, myName, int64(-int32(1)))
		(*TTcl_Obj)(unsafe.Pointer(myNamePtr)).FrefCount++
	}
	result = XTclPtrObjMakeUpvarIdx(tls, interp, otherPtr, myNamePtr, myFlags, index)
	if myNamePtr != 0 {
		_objPtr = myNamePtr
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	return result
}

func XTclPtrObjMakeUpvar(tls *libc.TLS, interp uintptr, otherPtr TTcl_Var, myNamePtr uintptr, myFlags int32) (r int32) {
	/* 0, TCL_GLOBAL_ONLY or TCL_NAMESPACE_ONLY:
	 * indicates scope of myName. */
	return XTclPtrObjMakeUpvarIdx(tls, interp, otherPtr, myNamePtr, myFlags, -int32(1))
}

/* Callers must Incr myNamePtr if they plan to Decr it. */

func XTclPtrObjMakeUpvarIdx(tls *libc.TLS, interp uintptr, otherPtr uintptr, myNamePtr uintptr, myFlags int32, _index int32) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	*(*int32)(unsafe.Pointer(bp)) = _index /* If the variable to be linked is an indexed
	 * scalar, this is its index. Otherwise, -1 */
	var iPtr, linkPtr, myName, p, varFramePtr, varPtr, v1, v2, v3, v4 uintptr
	var _ /* errMsg at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _ = iPtr, linkPtr, myName, p, varFramePtr, varPtr, v1, v2, v3, v4
	iPtr = interp
	varFramePtr = (*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr
	if *(*int32)(unsafe.Pointer(bp)) >= 0 {
		if !((*TCallFrame)(unsafe.Pointer(varFramePtr)).FisProcCallFrame&libc.Int32FromInt32(FRAME_IS_PROC) != 0) {
			XTcl_Panic(tls, __ccgo_ts+69529, 0)
		}
		varPtr = (*TCallFrame)(unsafe.Pointer(varFramePtr)).FcompiledLocals + uintptr(*(*int32)(unsafe.Pointer(bp)))*16
		myNamePtr = *(*uintptr)(unsafe.Pointer((*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FlocalCachePtr + 16 + uintptr(*(*int32)(unsafe.Pointer(bp)))*8))
		if myNamePtr != 0 {
			if (*TTcl_Obj)(unsafe.Pointer(myNamePtr)).Fbytes != 0 {
				v2 = (*TTcl_Obj)(unsafe.Pointer(myNamePtr)).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, myNamePtr, libc.UintptrFromInt32(0))
			}
			v1 = v2
		} else {
			v1 = libc.UintptrFromInt32(0)
		}
		myName = v1
	} else {
		/*
		 * Do not permit the new variable to look like an array reference, as
		 * it will not be reachable in that case [Bug 600812, TIP 184]. The
		 * "definition" of what "looks like an array reference" is consistent
		 * (and must remain consistent) with the code in TclObjLookupVar().
		 */
		if (*TTcl_Obj)(unsafe.Pointer(myNamePtr)).Fbytes != 0 {
			v3 = (*TTcl_Obj)(unsafe.Pointer(myNamePtr)).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, myNamePtr, libc.UintptrFromInt32(0))
		}
		myName = v3
		p = libc.Xstrstr(tls, myName, __ccgo_ts+68100)
		if p != libc.UintptrFromInt32(0) {
			p += uintptr(libc.Xstrlen(tls, p) - uint64(1))
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(')') {
				/*
				 * myName looks like an array reference.
				 */
				XTcl_SetObjResult(tls, iPtr, XTcl_ObjPrintf(tls, __ccgo_ts+69583, libc.VaList(bp+24, myName)))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+69514, __ccgo_ts+69671, libc.UintptrFromInt32(0)))
				return int32(TCL_ERROR)
			}
		}
		/*
		 * Lookup and eventually create the new variable. Set the flag bit
		 * TCL_AVOID_RESOLVERS to indicate the special resolution rules for
		 * upvar purposes:
		 *   - Bug #696893 - variable is either proc-local or in the current
		 *     namespace; never follow the second (global) resolution path.
		 *   - Bug #631741 - do not use special namespace or interp resolvers.
		 */
		varPtr = XTclLookupSimpleVar(tls, interp, myNamePtr, myFlags|int32(TCL_AVOID_RESOLVERS), int32(1), bp+8, bp)
		if varPtr == libc.UintptrFromInt32(0) {
			XTclObjVarErrMsg(tls, interp, myNamePtr, libc.UintptrFromInt32(0), __ccgo_ts+26194, *(*uintptr)(unsafe.Pointer(bp + 8)), -int32(1))
			if (*TTcl_Obj)(unsafe.Pointer(myNamePtr)).Fbytes != 0 {
				v4 = (*TTcl_Obj)(unsafe.Pointer(myNamePtr)).Fbytes
			} else {
				v4 = XTcl_GetStringFromObj(tls, myNamePtr, libc.UintptrFromInt32(0))
			}
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+68940, v4, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
	}
	if varPtr == otherPtr {
		XTcl_SetObjResult(tls, iPtr, XTcl_NewStringObj(tls, __ccgo_ts+69685, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+69514, __ccgo_ts+42580, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if (*TVar)(unsafe.Pointer(varPtr)).Fflags&(libc.Int32FromInt32(VAR_TRACED_READ)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_TRACED_ARRAY)|libc.Int32FromInt32(VAR_TRACED_UNSET)) != 0 {
		XTcl_SetObjResult(tls, iPtr, XTcl_ObjPrintf(tls, __ccgo_ts+69721, libc.VaList(bp+24, myName)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+69514, __ccgo_ts+69767, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	} else {
		if !(*(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0)) {
			/*
			 * The variable already existed. Make sure this variable "varPtr"
			 * isn't the same as "otherPtr" (avoid circular links). Also, if it's
			 * not an upvar then it's an error. If it is an upvar, then just
			 * disconnect it from the thing it currently refers to.
			 */
			if !((*TVar)(unsafe.Pointer(varPtr)).Fflags&libc.Int32FromInt32(VAR_LINK) != 0) {
				XTcl_SetObjResult(tls, iPtr, XTcl_ObjPrintf(tls, __ccgo_ts+69774, libc.VaList(bp+24, myName)))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+69514, __ccgo_ts+69803, libc.UintptrFromInt32(0)))
				return int32(TCL_ERROR)
			}
			linkPtr = *(*uintptr)(unsafe.Pointer(varPtr + 8))
			if linkPtr == otherPtr {
				return TCL_OK
			}
			if (*TVar)(unsafe.Pointer(linkPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
				(*TVarInHash)(unsafe.Pointer(linkPtr)).FrefCount--
				if *(*uintptr)(unsafe.Pointer(linkPtr + 8)) == libc.UintptrFromInt32(0) {
					_CleanupVar(tls, linkPtr, libc.UintptrFromInt32(0))
				}
			}
		}
	}
	(*TVar)(unsafe.Pointer(varPtr)).Fflags = (*TVar)(unsafe.Pointer(varPtr)).Fflags & ^libc.Int32FromInt32(VAR_ARRAY) | int32(VAR_LINK)
	*(*uintptr)(unsafe.Pointer(varPtr + 8)) = otherPtr
	if (*TVar)(unsafe.Pointer(otherPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
		(*TVarInHash)(unsafe.Pointer(otherPtr)).FrefCount++
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UpVar2 --
 *
 *	This function links one variable to another, just like the "upvar"
 *	command.
 *
 * Results:
 *	A standard Tcl completion code. If an error occurs then an error
 *	message is left in the interp's result.
 *
 * Side effects:
 *	The variable in frameName whose name is given by part1 and part2
 *	becomes accessible under the name localNameStr, so that references to
 *	localNameStr are redirected to the other variable like a symbolic
 *	link.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UpVar2(tls *libc.TLS, interp uintptr, frameName uintptr, part1 uintptr, part2 uintptr, localNameStr uintptr, flags int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* 0, TCL_GLOBAL_ONLY or TCL_NAMESPACE_ONLY:
	 * indicates scope of localNameStr. */
	var _objPtr, _objPtr1, localNamePtr, part1Ptr, v2, v4 uintptr
	var result int32
	var v1, v3 TTcl_Size
	var _ /* framePtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, localNamePtr, part1Ptr, result, v1, v2, v3, v4
	if XTclGetFrame(tls, interp, frameName, bp) == -int32(1) {
		return int32(TCL_ERROR)
	}
	part1Ptr = XTcl_NewStringObj(tls, part1, int64(-int32(1)))
	(*TTcl_Obj)(unsafe.Pointer(part1Ptr)).FrefCount++
	localNamePtr = XTcl_NewStringObj(tls, localNameStr, int64(-int32(1)))
	(*TTcl_Obj)(unsafe.Pointer(localNamePtr)).FrefCount++
	result = _ObjMakeUpvar(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), part1Ptr, part2, 0, localNamePtr, flags, -int32(1))
	_objPtr = part1Ptr
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	_objPtr1 = localNamePtr
	v4 = _objPtr1
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	if v3 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetVariableFullName --
 *
 *	Given a Tcl_Var token returned by Tcl_FindNamespaceVar, this function
 *	appends to an object the namespace variable's full name, qualified by
 *	a sequence of parent namespace names.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The variable's fully-qualified name is appended to the string
 *	representation of objPtr.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetVariableFullName(tls *libc.TLS, interp uintptr, variable TTcl_Var, objPtr uintptr) {
	/* Points to the object onto which the
	 * variable's full name is appended. */
	var iPtr, namePtr, nsPtr, varPtr, v1 uintptr
	var index TTcl_Size
	_, _, _, _, _, _ = iPtr, index, namePtr, nsPtr, varPtr, v1
	iPtr = interp
	varPtr = variable
	if !(varPtr != 0) || (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_ARRAY_ELEMENT) != 0 {
		return
	}
	/*
	 * Add the full name of the containing namespace (if any), followed by the
	 * "::" separator, then the variable name.
	 */
	if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
		v1 = (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(varPtr)).Fentry.FtablePtr)).FnsPtr
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	nsPtr = v1
	if nsPtr != 0 {
		XTcl_AppendToObj(tls, objPtr, (*TNamespace)(unsafe.Pointer(nsPtr)).FfullName, int64(-int32(1)))
		if nsPtr != (*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr {
			XTcl_AppendToObj(tls, objPtr, __ccgo_ts+7650, int64(2))
		}
	}
	if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
		if !((*TVar)(unsafe.Pointer(varPtr)).Fflags&libc.Int32FromInt32(VAR_DEAD_HASH) != 0) {
			namePtr = *(*uintptr)(unsafe.Pointer(varPtr + 24 + 32))
			XTcl_AppendObjToObj(tls, objPtr, namePtr)
		}
	} else {
		if (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FprocPtr != 0 {
			index = (int64(varPtr) - int64((*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FcompiledLocals)) / 16
			if index < (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FnumCompiledLocals {
				namePtr = *(*uintptr)(unsafe.Pointer((*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FlocalCachePtr + 16 + uintptr(index)*8))
				XTcl_AppendObjToObj(tls, objPtr, namePtr)
			}
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ConstObjCmd --
 *
 *	This function is invoked to process the "const" Tcl command.
 *	See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl object result value.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ConstObjCmd(tls *libc.TLS, dummy4863 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument objects. */
	var part1Ptr, varPtr uintptr
	var _ /* arrayPtr at bp+0 */ uintptr
	_, _ = part1Ptr, varPtr
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+69810)
		return int32(TCL_ERROR)
	}
	part1Ptr = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	varPtr = XTclObjLookupVarEx(tls, interp, part1Ptr, libc.UintptrFromInt32(0), int32(TCL_LEAVE_ERR_MSG), __ccgo_ts+5135, int32(1), int32(1), bp)
	if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_ARRAY) != 0 {
		XTclObjVarErrMsg(tls, interp, part1Ptr, libc.UintptrFromInt32(0), __ccgo_ts+32249, uintptr(unsafe.Pointer(&_ISARRAY)), -int32(1))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+32263, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_ARRAY_ELEMENT) != 0 {
		if *(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0) {
			_CleanupVar(tls, varPtr, *(*uintptr)(unsafe.Pointer(bp)))
		}
		XTclObjVarErrMsg(tls, interp, part1Ptr, libc.UintptrFromInt32(0), __ccgo_ts+32249, uintptr(unsafe.Pointer(&_ISARRAYELEMENT)), -int32(1))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+32263, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * If already exists, either a constant (no problem) or an error.
	 */
	if !(*(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0)) {
		if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_CONSTANT) != 0 {
			return TCL_OK
		}
		XTclObjVarErrMsg(tls, interp, part1Ptr, libc.UintptrFromInt32(0), __ccgo_ts+32249, uintptr(unsafe.Pointer(&_EXISTS)), -int32(1))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+32263, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Make the variable and flag it as a constant.
	 */
	if XTclPtrSetVar(tls, interp, varPtr, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + 2*8)), int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
		if *(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0) {
			_CleanupVar(tls, varPtr, *(*uintptr)(unsafe.Pointer(bp)))
		}
		return int32(TCL_ERROR)
	}
	(*TVar)(unsafe.Pointer(varPtr)).Fflags = (*TVar)(unsafe.Pointer(varPtr)).Fflags & ^(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)) | int32(VAR_CONSTANT)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GlobalObjCmd --
 *
 *	This object-based function is invoked to process the "global" Tcl
 *	command. See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl object result value.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GlobalObjCmd(tls *libc.TLS, dummy4938 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var _objPtr, iPtr, objPtr, tail, tailPtr, varName, v2, v5 uintptr
	var i, result int32
	var v4 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _ = _objPtr, i, iPtr, objPtr, result, tail, tailPtr, varName, v2, v4, v5
	iPtr = interp
	/*
	 * If we are not executing inside a Tcl procedure, just return.
	 */
	if !((*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FisProcCallFrame&libc.Int32FromInt32(FRAME_IS_PROC) != 0) {
		return TCL_OK
	}
	i = int32(1)
	for {
		if !(i < objc) {
			break
		}
		/*
		 * Make a local variable linked to its counterpart in the global ::
		 * namespace.
		 */
		objPtr = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
		}
		varName = v2
		/*
		 * The variable name might have a scope qualifier, but the name for
		 * the local "link" variable must be the simple name at the tail.
		 */
		tail = varName
		for {
			if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(tail))) != int32('\000')) {
				break
			}
			/* empty body */
			goto _3
		_3:
			;
			tail++
		}
		for tail > varName && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(tail))) != int32(':') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(tail + uintptr(-libc.Int32FromInt32(1))))) != int32(':')) {
			tail--
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(tail))) == int32(':') && tail > varName {
			tail++
		}
		if tail == varName {
			tailPtr = objPtr
		} else {
			tailPtr = XTcl_NewStringObj(tls, tail, int64(-int32(1)))
			(*TTcl_Obj)(unsafe.Pointer(tailPtr)).FrefCount++
		}
		/*
		 * Link to the variable "varName" in the global :: namespace.
		 */
		result = _ObjMakeUpvar(tls, interp, libc.UintptrFromInt32(0), objPtr, libc.UintptrFromInt32(0), int32(TCL_GLOBAL_ONLY), tailPtr, 0, -int32(1))
		if tail != varName {
			_objPtr = tailPtr
			v5 = _objPtr
			v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
			*(*TTcl_Size)(unsafe.Pointer(v5))--
			if v4 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
		if result != TCL_OK {
			return result
		}
		goto _1
	_1:
		;
		i++
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_VariableObjCmd --
 *
 *	Invoked to implement the "variable" command that creates one or more
 *	global variables. Handles the following syntax:
 *
 *	    variable ?name value...? name ?value?
 *
 *	One or more variables can be created. The variables are initialized
 *	with the specified values. The value for the last variable is
 *	optional.
 *
 *	If the variable does not exist, it is created and given the optional
 *	value. If it already exists, it is simply set to the optional value.
 *	Normally, "name" is an unqualified name, so it is created in the
 *	current namespace. If it includes namespace qualifiers, it can be
 *	created in another namespace.
 *
 *	If the variable command is executed inside a Tcl procedure, it creates
 *	a local variable linked to the newly-created namespace variable.
 *
 * Results:
 *	Returns TCL_OK if the variable is found or created. Returns TCL_ERROR
 *	if anything goes wrong.
 *
 * Side effects:
 *	If anything goes wrong, this function returns an error message as the
 *	result in the interpreter's result object.
 *
 *----------------------------------------------------------------------
 */

func XTcl_VariableObjCmd(tls *libc.TLS, dummy5042 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument objects. */
	var _objPtr, cp, iPtr, tail, tailPtr, varName, varNamePtr, varPtr, varValuePtr, v2, v4, v5, v6, v8 uintptr
	var i, result int32
	var v7 TTcl_Size
	var _ /* arrayPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cp, i, iPtr, result, tail, tailPtr, varName, varNamePtr, varPtr, varValuePtr, v2, v4, v5, v6, v7, v8
	iPtr = interp
	i = int32(1)
	for {
		if !(i < objc) {
			break
		}
		/*
		 * Look up each variable in the current namespace context, creating it
		 * if necessary.
		 */
		varNamePtr = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
		if (*TTcl_Obj)(unsafe.Pointer(varNamePtr)).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(varNamePtr)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, varNamePtr, libc.UintptrFromInt32(0))
		}
		varName = v2
		varPtr = XTclObjLookupVarEx(tls, interp, varNamePtr, libc.UintptrFromInt32(0), libc.Int32FromInt32(TCL_NAMESPACE_ONLY)|libc.Int32FromInt32(TCL_LEAVE_ERR_MSG), __ccgo_ts+69824, int32(1), 0, bp)
		if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
			/*
			 * Variable cannot be an element in an array. If arrayPtr is
			 * non-NULL, it is, so throw up an error and return.
			 */
			XTclObjVarErrMsg(tls, interp, varNamePtr, libc.UintptrFromInt32(0), __ccgo_ts+69824, uintptr(unsafe.Pointer(&_ISARRAYELEMENT)), -int32(1))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+69514, __ccgo_ts+69671, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		if varPtr == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
		/*
		 * Mark the variable as a namespace variable and increment its
		 * reference count so that it will persist until its namespace is
		 * destroyed or until the variable is unset.
		 */
		if !((*TVar)(unsafe.Pointer(varPtr)).Fflags&libc.Int32FromInt32(VAR_NAMESPACE_VAR) != 0) {
			*(*int32)(unsafe.Pointer(varPtr)) |= int32(VAR_NAMESPACE_VAR)
			if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
				(*TVarInHash)(unsafe.Pointer(varPtr)).FrefCount++
			}
		}
		/*
		 * If a value was specified, set the variable to that value.
		 * Otherwise, if the variable is new, leave it undefined. (If the
		 * variable already exists and no value was specified, leave its value
		 * unchanged; just create the local link if we're in a Tcl procedure).
		 */
		if i+int32(1) < objc { /* A value was specified. */
			varValuePtr = XTclPtrSetVarIdx(tls, interp, varPtr, *(*uintptr)(unsafe.Pointer(bp)), varNamePtr, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)), libc.Int32FromInt32(TCL_NAMESPACE_ONLY)|libc.Int32FromInt32(TCL_LEAVE_ERR_MSG), -int32(1))
			if varValuePtr == libc.UintptrFromInt32(0) {
				return int32(TCL_ERROR)
			}
		}
		/*
		 * If we are executing inside a Tcl procedure, create a local variable
		 * linked to the new namespace variable "varName".
		 */
		if (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FisProcCallFrame&int32(FRAME_IS_PROC) != 0 {
			/*
			 * varName might have a scope qualifier, but the name for the
			 * local "link" variable must be the simple name at the tail.
			 *
			 * Locate tail in one pass: drop any prefix after two *or more*
			 * consecutive ":" characters).
			 */
			v4 = varName
			cp = v4
			tail = v4
			for {
				if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cp))) != int32('\000')) {
					break
				}
				v5 = cp
				cp++
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) == int32(':') {
					for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cp))) == int32(':') {
						cp++
						v6 = cp
						tail = v6
					}
				}
				goto _3
			_3:
			}
			/*
			 * Create a local link "tail" to the variable "varName" in the
			 * current namespace.
			 */
			if tail == varName {
				tailPtr = varNamePtr
			} else {
				tailPtr = XTcl_NewStringObj(tls, tail, int64(-int32(1)))
				(*TTcl_Obj)(unsafe.Pointer(tailPtr)).FrefCount++
			}
			result = _ObjMakeUpvar(tls, interp, libc.UintptrFromInt32(0), varNamePtr, libc.UintptrFromInt32(0), int32(TCL_NAMESPACE_ONLY), tailPtr, 0, -int32(1))
			if tail != varName {
				_objPtr = tailPtr
				v8 = _objPtr
				v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
				*(*TTcl_Size)(unsafe.Pointer(v8))--
				if v7 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
			if result != TCL_OK {
				return result
			}
		}
		goto _1
	_1:
		;
		i += int32(2)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_UpvarObjCmd --
 *
 *	This object-based function is invoked to process the "upvar" Tcl
 *	command. See the user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl object result value.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_UpvarObjCmd(tls *libc.TLS, dummy5175 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Argument objects. */
	var hasLevel, result int32
	var levelObj, v1, v2 uintptr
	var _ /* framePtr at bp+0 */ uintptr
	_, _, _, _, _ = hasLevel, levelObj, result, v1, v2
	if objc < int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+69831)
		return int32(TCL_ERROR)
	}
	if objc&int32(1) != 0 {
		/*
		 * Even number of arguments, so use the default level of "1" by
		 * passing NULL to TclObjGetFrame.
		 */
		levelObj = libc.UintptrFromInt32(0)
		hasLevel = 0
	} else {
		/*
		 * Odd number of arguments, so objv[1] must contain the level.
		 */
		levelObj = *(*uintptr)(unsafe.Pointer(objv + 1*8))
		hasLevel = int32(1)
	}
	/*
	 * Find the call frame containing each of the "other variables" to be
	 * linked to.
	 */
	result = XTclObjGetFrame(tls, interp, levelObj, bp)
	if result == -int32(1) {
		return int32(TCL_ERROR)
	}
	if result == 0 && hasLevel != 0 {
		/*
		 * Synthesize an error message since TclObjGetFrame doesn't do this
		 * for this particular case.
		 */
		if (*TTcl_Obj)(unsafe.Pointer(levelObj)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(levelObj)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, levelObj, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+16556, libc.VaList(bp+16, v1)))
		if (*TTcl_Obj)(unsafe.Pointer(levelObj)).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(levelObj)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, levelObj, libc.UintptrFromInt32(0))
		}
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+16571, v2, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * We've now finished with parsing levels; skip to the variable names.
	 */
	objc -= hasLevel + int32(1)
	objv += uintptr(hasLevel+int32(1)) * 8
	/*
	 * Iterate over each (other variable, local variable) pair. Divide the
	 * other variable name into two parts, then call MakeUpvar to do all the
	 * work of linking it to the local variable.
	 */
	for {
		if !(objc > 0) {
			break
		}
		result = _ObjMakeUpvar(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(objv)), libc.UintptrFromInt32(0), 0, *(*uintptr)(unsafe.Pointer(objv + 1*8)), 0, -int32(1))
		if result != TCL_OK {
			return int32(TCL_ERROR)
		}
		goto _3
	_3:
		;
		objc -= int32(2)
		objv += uintptr(2) * 8
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * ParseSearchId --
 *
 *	This function translates from a tcl object to a pointer to an active
 *	array search (if there is one that matches the string).
 *
 * Results:
 *	The return value is a pointer to the array search indicated by string,
 *	or NULL if there isn't one. If NULL is returned, the interp's result
 *	contains an error message.
 *
 *----------------------------------------------------------------------
 */

func _ParseSearchId(tls *libc.TLS, interp uintptr, varPtr uintptr, varNamePtr uintptr, handleObj uintptr) (r uintptr) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Object containing id of search. Must have
	 * form "search-num-var" where "num" is a
	 * decimal number and "var" is a variable
	 * name. */
	var hPtr, handle, iPtr, searchPtr, v1, v4, v6, v7 uintptr
	var v5 bool
	var _ /* end at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _ = hPtr, handle, iPtr, searchPtr, v1, v4, v5, v6, v7
	iPtr = interp
	if (*TTcl_Obj)(unsafe.Pointer(handleObj)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(handleObj)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, handleObj, libc.UintptrFromInt32(0))
	}
	handle = v1
	if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_SEARCH_ACTIVE) != 0 {
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iPtr + 896)).FfindProc})))(tls, iPtr+896, varPtr)
		/* First look for same (Tcl_Obj *) */
		searchPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		for {
			if !(searchPtr != libc.UintptrFromInt32(0)) {
				break
			}
			if (*TArraySearch)(unsafe.Pointer(searchPtr)).Fname == handleObj {
				return searchPtr
			}
			goto _2
		_2:
			;
			searchPtr = (*TArraySearch)(unsafe.Pointer(searchPtr)).FnextPtr
		}
		/* Fallback: do string compares. */
		searchPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		for {
			if !(searchPtr != libc.UintptrFromInt32(0)) {
				break
			}
			if (*TTcl_Obj)(unsafe.Pointer((*TArraySearch)(unsafe.Pointer(searchPtr)).Fname)).Fbytes != 0 {
				v4 = (*TTcl_Obj)(unsafe.Pointer((*TArraySearch)(unsafe.Pointer(searchPtr)).Fname)).Fbytes
			} else {
				v4 = XTcl_GetStringFromObj(tls, (*TArraySearch)(unsafe.Pointer(searchPtr)).Fname, libc.UintptrFromInt32(0))
			}
			if libc.Xstrcmp(tls, v4, handle) == 0 {
				return searchPtr
			}
			goto _3
		_3:
			;
			searchPtr = (*TArraySearch)(unsafe.Pointer(searchPtr)).FnextPtr
		}
	}
	if v5 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(handle))) != int32('s') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(handle + 1))) != int32('-'); !v5 {
		libc.Xstrtoul(tls, handle+uintptr(2), bp, int32(10))
	}
	if v5 || *(*uintptr)(unsafe.Pointer(bp)) == handle+libc.UintptrFromInt32(2) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32('-') {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+69881, libc.VaList(bp+16, handle)))
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(varNamePtr)).Fbytes != 0 {
			v6 = (*TTcl_Obj)(unsafe.Pointer(varNamePtr)).Fbytes
		} else {
			v6 = XTcl_GetStringFromObj(tls, varNamePtr, libc.UintptrFromInt32(0))
		}
		if libc.Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(bp))+uintptr(1), v6) != 0 {
			if (*TTcl_Obj)(unsafe.Pointer(varNamePtr)).Fbytes != 0 {
				v7 = (*TTcl_Obj)(unsafe.Pointer(varNamePtr)).Fbytes
			} else {
				v7 = XTcl_GetStringFromObj(tls, varNamePtr, libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+69912, libc.VaList(bp+16, handle, v7)))
		} else {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+69959, libc.VaList(bp+16, handle)))
		}
	}
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+69985, handle, libc.UintptrFromInt32(0)))
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * DeleteSearches --
 *
 *	This function is called to free up all of the searches associated
 *	with an array variable.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Memory is released to the storage allocator.
 *
 *----------------------------------------------------------------------
 */

func _DeleteSearches(tls *libc.TLS, iPtr uintptr, arrayVarPtr uintptr) {
	/* Variable whose searches are to be
	 * deleted. */
	var _objPtr, nextPtr, sPtr, searchPtr, v3 uintptr
	var v2 TTcl_Size
	_, _, _, _, _, _ = _objPtr, nextPtr, sPtr, searchPtr, v2, v3
	if (*TVar)(unsafe.Pointer(arrayVarPtr)).Fflags&int32(VAR_SEARCH_ACTIVE) != 0 {
		sPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iPtr + 896)).FfindProc})))(tls, iPtr+896, arrayVarPtr)
		searchPtr = (*TTcl_HashEntry)(unsafe.Pointer(sPtr)).FclientData
		for {
			if !(searchPtr != libc.UintptrFromInt32(0)) {
				break
			}
			nextPtr = (*TArraySearch)(unsafe.Pointer(searchPtr)).FnextPtr
			_objPtr = (*TArraySearch)(unsafe.Pointer(searchPtr)).Fname
			v3 = _objPtr
			v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
			*(*TTcl_Size)(unsafe.Pointer(v3))--
			if v2 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			XTclpFree(tls, searchPtr)
			goto _1
		_1:
			;
			searchPtr = nextPtr
		}
		*(*int32)(unsafe.Pointer(arrayVarPtr)) &= ^libc.Int32FromInt32(VAR_SEARCH_ACTIVE)
		XTcl_DeleteHashEntry(tls, sPtr)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclDeleteNamespaceVars --
 *
 *	This function is called to recycle all the storage space associated
 *	with a namespace's table of variables.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Variables are deleted and trace functions are invoked, if any are
 *	declared.
 *
 *----------------------------------------------------------------------
 */

func XTclDeleteNamespaceVars(tls *libc.TLS, nsPtr uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _objPtr, activePtr, cachePtr, iPtr, interp, objPtr, prevPtr, tPtr, tablePtr, tracePtr, varPtr, v5 uintptr
	var flags int32
	var v2 bool
	var v4 TTcl_Size
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, activePtr, cachePtr, flags, iPtr, interp, objPtr, prevPtr, tPtr, tablePtr, tracePtr, varPtr, v2, v4, v5
	tablePtr = nsPtr + 288
	interp = (*TNamespace)(unsafe.Pointer(nsPtr)).Finterp
	iPtr = interp
	flags = 0
	/*
	 * Determine what flags to pass to the trace callback functions.
	 */
	if nsPtr == (*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr {
		flags = int32(TCL_GLOBAL_ONLY)
	} else {
		if nsPtr == (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FnsPtr {
			flags = int32(TCL_NAMESPACE_ONLY)
		}
	}
	varPtr = _VarHashFirstVar(tls, tablePtr, bp)
	for {
		if !(varPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			objPtr = XTclThreadAllocObj(tls)
		} else {
			objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
		(*TVarInHash)(unsafe.Pointer(varPtr)).FrefCount++ /* Make sure we get to remove from
		 * hash. */
		XTcl_GetVariableFullName(tls, interp, varPtr, objPtr)
		_UnsetVarStruct(tls, varPtr, libc.UintptrFromInt32(0), iPtr, objPtr, libc.UintptrFromInt32(0), flags, -int32(1))
		/*
		 * We just unset the variable. However, an unset trace might
		 * have re-set it, or might have re-established traces on it.
		 * This namespace and its vartable are going away unconditionally,
		 * so we cannot let such things linger. That would be a leak.
		 *
		 * First we destroy all traces. ...
		 */
		if (*TVar)(unsafe.Pointer(varPtr)).Fflags&(libc.Int32FromInt32(VAR_TRACED_READ)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_TRACED_ARRAY)|libc.Int32FromInt32(VAR_TRACED_UNSET)) != 0 {
			tPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iPtr + 792)).FfindProc})))(tls, iPtr+792, varPtr)
			tracePtr = (*TTcl_HashEntry)(unsafe.Pointer(tPtr)).FclientData
			for tracePtr != 0 {
				prevPtr = tracePtr
				tracePtr = (*TVarTrace)(unsafe.Pointer(tracePtr)).FnextPtr
				(*TVarTrace)(unsafe.Pointer(prevPtr)).FnextPtr = libc.UintptrFromInt32(0)
				XTcl_EventuallyFree(tls, prevPtr, libc.UintptrFromInt32(3))
			}
			XTcl_DeleteHashEntry(tls, tPtr)
			*(*int32)(unsafe.Pointer(varPtr)) &= ^(libc.Int32FromInt32(VAR_TRACED_READ) | libc.Int32FromInt32(VAR_TRACED_WRITE) | libc.Int32FromInt32(VAR_TRACED_ARRAY) | libc.Int32FromInt32(VAR_TRACED_UNSET))
			activePtr = (*TInterp)(unsafe.Pointer(iPtr)).FactiveVarTracePtr
			for {
				if !(activePtr != libc.UintptrFromInt32(0)) {
					break
				}
				if (*TActiveVarTrace)(unsafe.Pointer(activePtr)).FvarPtr == varPtr {
					(*TActiveVarTrace)(unsafe.Pointer(activePtr)).FnextTracePtr = libc.UintptrFromInt32(0)
				}
				goto _3
			_3:
				;
				activePtr = (*TActiveVarTrace)(unsafe.Pointer(activePtr)).FnextPtr
			}
		}
		/*
		 * ...and then, if the variable still holds a value, we unset it
		 * again. This time with no traces left, we're sure it goes away.
		 */
		if !(*(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0)) {
			_UnsetVarStruct(tls, varPtr, libc.UintptrFromInt32(0), iPtr, objPtr, libc.UintptrFromInt32(0), flags, -int32(1))
		}
		_objPtr = objPtr
		v5 = _objPtr
		v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
		*(*TTcl_Size)(unsafe.Pointer(v5))--
		if v4 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		} /* free no longer needed obj */
		(*TVarInHash)(unsafe.Pointer(varPtr)).FrefCount--
		XTcl_DeleteHashEntry(tls, varPtr+24)
		goto _1
	_1:
		;
		varPtr = _VarHashFirstVar(tls, tablePtr, bp)
	}
	XTcl_DeleteHashTable(tls, tablePtr)
}

/*
 *----------------------------------------------------------------------
 *
 * TclDeleteVars --
 *
 *	This function is called to recycle all the storage space associated
 *	with a table of variables. For this function to work correctly, it
 *	must not be possible for any of the variables in the table to be
 *	accessed from Tcl commands (e.g. from trace functions).
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Variables are deleted and trace functions are invoked, if any are
 *	declared.
 *
 *----------------------------------------------------------------------
 */

func XTclDeleteVars(tls *libc.TLS, iPtr uintptr, tablePtr uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Hash table containing variables to
	 * delete. */
	var currNsPtr, interp, varPtr uintptr
	var flags int32
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _ = currNsPtr, flags, interp, varPtr
	interp = iPtr
	currNsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FnsPtr
	/*
	 * Determine what flags to pass to the trace callback functions.
	 */
	flags = int32(TCL_TRACE_UNSETS)
	if tablePtr == (*TInterp)(unsafe.Pointer(iPtr)).FglobalNsPtr+288 {
		flags |= int32(TCL_GLOBAL_ONLY)
	} else {
		if tablePtr == currNsPtr+288 {
			flags |= int32(TCL_NAMESPACE_ONLY)
		}
	}
	varPtr = _VarHashFirstVar(tls, tablePtr, bp)
	for {
		if !(varPtr != libc.UintptrFromInt32(0)) {
			break
		}
		_UnsetVarStruct(tls, varPtr, libc.UintptrFromInt32(0), iPtr, *(*uintptr)(unsafe.Pointer(varPtr + 24 + 32)), libc.UintptrFromInt32(0), flags, -int32(1))
		XTcl_DeleteHashEntry(tls, varPtr+24)
		goto _1
	_1:
		;
		varPtr = _VarHashFirstVar(tls, tablePtr, bp)
	}
	XTcl_DeleteHashTable(tls, tablePtr)
}

/*
 *----------------------------------------------------------------------
 *
 * TclDeleteCompiledLocalVars --
 *
 *	This function is called to recycle storage space associated with the
 *	compiler-allocated array of local variables in a procedure call frame.
 *	This function resembles TclDeleteVars above except that each variable
 *	is stored in a call frame and not a hash table. For this function to
 *	work correctly, it must not be possible for any of the variable in the
 *	table to be accessed from Tcl commands (e.g. from trace functions).
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Variables are deleted and trace functions are invoked, if any are
 *	declared.
 *
 *----------------------------------------------------------------------
 */

func XTclDeleteCompiledLocalVars(tls *libc.TLS, iPtr uintptr, framePtr uintptr) {
	/* Procedure call frame containing compiler-
	 * assigned local variables to delete. */
	var i, numLocals TTcl_Size
	var namePtrPtr, varPtr uintptr
	_, _, _, _ = i, namePtrPtr, numLocals, varPtr
	numLocals = (*TCallFrame)(unsafe.Pointer(framePtr)).FnumCompiledLocals
	varPtr = (*TCallFrame)(unsafe.Pointer(framePtr)).FcompiledLocals
	namePtrPtr = (*TCallFrame)(unsafe.Pointer(framePtr)).FlocalCachePtr + 16
	i = 0
	for {
		if !(i < numLocals) {
			break
		}
		_UnsetVarStruct(tls, varPtr, libc.UintptrFromInt32(0), iPtr, *(*uintptr)(unsafe.Pointer(namePtrPtr)), libc.UintptrFromInt32(0), int32(TCL_TRACE_UNSETS), int32(i))
		goto _1
	_1:
		;
		i++
		namePtrPtr += 8
		varPtr += 16
	}
	(*TCallFrame)(unsafe.Pointer(framePtr)).FnumCompiledLocals = 0
}

/*
 *----------------------------------------------------------------------
 *
 * DeleteArray --
 *
 *	This function is called to free up everything in an array variable.
 *	It's the caller's responsibility to make sure that the array is no
 *	longer accessible before this function is called.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	All storage associated with varPtr's array elements is deleted
 *	(including the array's hash table). Deletion trace functions for
 *	array elements are invoked, then deleted. Any pending traces for array
 *	elements are also deleted.
 *
 *----------------------------------------------------------------------
 */

func _DeleteArray(tls *libc.TLS, iPtr uintptr, arrayNamePtr uintptr, varPtr uintptr, flags int32, index int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var activePtr, cachePtr, elNamePtr, elPtr, objPtr, prevPtr, tPtr, tracePtr, v3 uintptr
	var v2 TTcl_Size
	var v4 bool
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _, _, _, _, _, _ = activePtr, cachePtr, elNamePtr, elPtr, objPtr, prevPtr, tPtr, tracePtr, v2, v3, v4
	elPtr = _VarHashFirstVar(tls, *(*uintptr)(unsafe.Pointer(varPtr + 8)), bp)
	for {
		if !(elPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if !((*TVar)(unsafe.Pointer(elPtr)).Fflags&(libc.Int32FromInt32(VAR_ARRAY)|libc.Int32FromInt32(VAR_LINK)) != 0) && *(*uintptr)(unsafe.Pointer(elPtr + 8)) != libc.UintptrFromInt32(0) {
			objPtr = *(*uintptr)(unsafe.Pointer(elPtr + 8))
			v3 = objPtr
			v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
			*(*TTcl_Size)(unsafe.Pointer(v3))--
			if !(v2 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = int64(-libc.Int32FromInt32(1))
					if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
						cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v4 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, objPtr)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(objPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = objPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, objPtr)
				}
			}
			*(*uintptr)(unsafe.Pointer(elPtr + 8)) = libc.UintptrFromInt32(0)
		}
		/*
		 * Lie about the validity of the hashtable entry. In this way the
		 * variables will be deleted by VarHashDeleteTable.
		 */
		*(*int32)(unsafe.Pointer(elPtr)) |= int32(VAR_DEAD_HASH)
		if (*TVar)(unsafe.Pointer(elPtr)).Fflags&(libc.Int32FromInt32(VAR_TRACED_READ)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_TRACED_ARRAY)|libc.Int32FromInt32(VAR_TRACED_UNSET)) != 0 {
			/*
			 * Compute the array name if it was not supplied.
			 */
			if (*TVar)(unsafe.Pointer(elPtr)).Fflags&int32(VAR_TRACED_UNSET) != 0 {
				elNamePtr = *(*uintptr)(unsafe.Pointer(elPtr + 24 + 32))
				*(*int32)(unsafe.Pointer(elPtr)) &= ^libc.Int32FromInt32(VAR_TRACE_ACTIVE)
				XTclObjCallVarTraces(tls, iPtr, libc.UintptrFromInt32(0), elPtr, arrayNamePtr, elNamePtr, flags, 0, index)
			}
			tPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(iPtr + 792)).FfindProc})))(tls, iPtr+792, elPtr)
			tracePtr = (*TTcl_HashEntry)(unsafe.Pointer(tPtr)).FclientData
			for tracePtr != 0 {
				prevPtr = tracePtr
				tracePtr = (*TVarTrace)(unsafe.Pointer(tracePtr)).FnextPtr
				(*TVarTrace)(unsafe.Pointer(prevPtr)).FnextPtr = libc.UintptrFromInt32(0)
				XTcl_EventuallyFree(tls, prevPtr, libc.UintptrFromInt32(3))
			}
			XTcl_DeleteHashEntry(tls, tPtr)
			*(*int32)(unsafe.Pointer(elPtr)) &= ^(libc.Int32FromInt32(VAR_TRACED_READ) | libc.Int32FromInt32(VAR_TRACED_WRITE) | libc.Int32FromInt32(VAR_TRACED_ARRAY) | libc.Int32FromInt32(VAR_TRACED_UNSET))
			activePtr = (*TInterp)(unsafe.Pointer(iPtr)).FactiveVarTracePtr
			for {
				if !(activePtr != libc.UintptrFromInt32(0)) {
					break
				}
				if (*TActiveVarTrace)(unsafe.Pointer(activePtr)).FvarPtr == elPtr {
					(*TActiveVarTrace)(unsafe.Pointer(activePtr)).FnextTracePtr = libc.UintptrFromInt32(0)
				}
				goto _5
			_5:
				;
				activePtr = (*TActiveVarTrace)(unsafe.Pointer(activePtr)).FnextPtr
			}
		}
		*(*int32)(unsafe.Pointer(elPtr)) &= ^(libc.Int32FromInt32(VAR_ARRAY) | libc.Int32FromInt32(VAR_LINK) | libc.Int32FromInt32(VAR_CONSTANT))
		*(*uintptr)(unsafe.Pointer(elPtr + 8)) = libc.UintptrFromInt32(0)
		/*
		 * Even though array elements are not supposed to be namespace
		 * variables, some combinations of [upvar] and [variable] may create
		 * such beasts - see [Bug 604239]. This is necessary to avoid leaking
		 * the corresponding Var struct, and is otherwise harmless.
		 */
		if (*TVar)(unsafe.Pointer(elPtr)).Fflags&int32(VAR_NAMESPACE_VAR) != 0 {
			*(*int32)(unsafe.Pointer(elPtr)) &= ^libc.Int32FromInt32(VAR_NAMESPACE_VAR)
			if (*TVar)(unsafe.Pointer(elPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
				(*TVarInHash)(unsafe.Pointer(elPtr)).FrefCount--
			}
		}
		goto _1
	_1:
		;
		elPtr = _VarHashNextVar(tls, bp)
	}
	_DeleteArrayVar(tls, varPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * TclObjVarErrMsg --
 *
 *	Generate a reasonable error message describing why a variable
 *	operation failed.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The interp's result is set to hold a message identifying the variable
 *	given by part1 and part2 and describing why the variable operation
 *	failed.
 *
 *----------------------------------------------------------------------
 */

func XTclVarErrMsg(tls *libc.TLS, interp uintptr, part1 uintptr, part2 uintptr, operation uintptr, reason uintptr) {
	/* String describing why operation failed. */
	var _objPtr, _objPtr1, part1Ptr, part2Ptr, v2, v4 uintptr
	var v1, v3 TTcl_Size
	_, _, _, _, _, _, _, _ = _objPtr, _objPtr1, part1Ptr, part2Ptr, v1, v2, v3, v4
	part2Ptr = libc.UintptrFromInt32(0)
	part1Ptr = XTcl_NewStringObj(tls, part1, int64(-int32(1)))
	if part2 != 0 {
		part2Ptr = XTcl_NewStringObj(tls, part2, int64(-int32(1)))
	}
	XTclObjVarErrMsg(tls, interp, part1Ptr, part2Ptr, operation, reason, -int32(1))
	_objPtr = part1Ptr
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	if part2Ptr != 0 {
		_objPtr1 = part2Ptr
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
}

func XTclObjVarErrMsg(tls *libc.TLS, interp uintptr, part1Ptr uintptr, part2Ptr uintptr, operation uintptr, reason uintptr, index int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Index into the local variable table of the
	 * variable, or -1. Only used when part1Ptr is
	 * NULL. */
	var v1, v2, v3, v4, v5 uintptr
	_, _, _, _, _ = v1, v2, v3, v4, v5
	if !(part1Ptr != 0) {
		if index == -int32(1) {
			XTcl_Panic(tls, __ccgo_ts+69997, 0)
		}
		part1Ptr = *(*uintptr)(unsafe.Pointer((*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FlocalCachePtr + 16 + uintptr(index)*8))
	}
	if (*TTcl_Obj)(unsafe.Pointer(part1Ptr)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(part1Ptr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, part1Ptr, libc.UintptrFromInt32(0))
	}
	if part2Ptr != 0 {
		v2 = __ccgo_ts + 68100
	} else {
		v2 = __ccgo_ts + 1945
	}
	if part2Ptr != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(part2Ptr)).Fbytes != 0 {
			v4 = (*TTcl_Obj)(unsafe.Pointer(part2Ptr)).Fbytes
		} else {
			v4 = XTcl_GetStringFromObj(tls, part2Ptr, libc.UintptrFromInt32(0))
		}
		v3 = v4
	} else {
		v3 = __ccgo_ts + 1945
	}
	if part2Ptr != 0 {
		v5 = __ccgo_ts + 3563
	} else {
		v5 = __ccgo_ts + 1945
	}
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+70041, libc.VaList(bp+8, operation, v1, v2, v3, v5, reason)))
}

/*
 *----------------------------------------------------------------------
 *
 * Internal functions for variable name object types --
 *
 *----------------------------------------------------------------------
 */

/*
 * localVarName -
 *
 * INTERNALREP DEFINITION:
 *   twoPtrValue.ptr1:   pointer to name obj in varFramePtr->localCache
 *			  or NULL if it is this same obj
 *   twoPtrValue.ptr2: index into locals table
 */

func _FreeLocalVarName(tls *libc.TLS, objPtr uintptr) {
	var _objPtr, irPtr, namePtr, v1, v2, v5 uintptr
	var index, v4 TTcl_Size
	var v3 int64
	_, _, _, _, _, _, _, _, _ = _objPtr, index, irPtr, namePtr, v1, v2, v3, v4, v5
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_localVarNameType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	namePtr = v2
	if irPtr != 0 {
		v3 = int64((*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr2)
	} else {
		v3 = int64(-libc.Int32FromInt32(1))
	}
	index = v3
	index++ /* Compiler warning bait. */
	if namePtr != 0 {
		_objPtr = namePtr
		v5 = _objPtr
		v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
		*(*TTcl_Size)(unsafe.Pointer(v5))--
		if v4 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
}

func _DupLocalVarName(tls *libc.TLS, srcPtr uintptr, dupPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var index TTcl_Size
	var irPtr, namePtr, ptr, v1, v2 uintptr
	var v3 int64
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_, _, _, _, _, _, _ = index, irPtr, namePtr, ptr, v1, v2, v3
	if (*TTcl_Obj)(unsafe.Pointer(srcPtr)).FtypePtr == uintptr(unsafe.Pointer(&_localVarNameType)) {
		v1 = srcPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	namePtr = v2
	if irPtr != 0 {
		v3 = int64((*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr2)
	} else {
		v3 = int64(-libc.Int32FromInt32(1))
	}
	index = v3
	if !(namePtr != 0) {
		namePtr = srcPtr
	}
	ptr = namePtr
	if ptr != 0 {
		(*TTcl_Obj)(unsafe.Pointer(ptr)).FrefCount++
	}
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr1 = ptr
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr2 = uintptr(index)
	XTcl_StoreInternalRep(tls, dupPtr, uintptr(unsafe.Pointer(&_localVarNameType)), bp)
}

/*
 * parsedVarName -
 *
 * INTERNALREP DEFINITION:
 *   twoPtrValue.ptr1 = pointer to the array name Tcl_Obj (NULL if scalar)
 *   twoPtrValue.ptr2 = pointer to the element name string (owned by this
 *			Tcl_Obj), or NULL if it is a scalar variable
 */

func _FreeParsedVarName(tls *libc.TLS, objPtr uintptr) {
	var arrayPtr, cachePtr, cachePtr1, elem, irPtr, v1, v2, v3, v5, v8 uintptr
	var parsed int32
	var v4, v7 TTcl_Size
	var v6, v9 bool
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = arrayPtr, cachePtr, cachePtr1, elem, irPtr, parsed, v1, v2, v3, v4, v5, v6, v7, v8, v9
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_parsedVarNameType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	parsed = libc.BoolInt32(irPtr != libc.UintptrFromInt32(0))
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	arrayPtr = v2
	if irPtr != 0 {
		v3 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr2
	} else {
		v3 = libc.UintptrFromInt32(0)
	}
	elem = v3
	parsed++ /* Silence compiler. */
	if arrayPtr != libc.UintptrFromInt32(0) {
		v5 = arrayPtr
		v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
		*(*TTcl_Size)(unsafe.Pointer(v5))--
		if !(v4 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(arrayPtr)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(arrayPtr)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(arrayPtr)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(arrayPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(arrayPtr)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(arrayPtr)).Flength = int64(-libc.Int32FromInt32(1))
				if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v6 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, arrayPtr)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(arrayPtr + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = arrayPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, arrayPtr)
			}
		}
		v8 = elem
		v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
		*(*TTcl_Size)(unsafe.Pointer(v8))--
		if !(v7 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(elem)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(elem)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(elem)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(elem)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(elem)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(elem)).Flength = int64(-libc.Int32FromInt32(1))
				if v9 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v9 {
					cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v9 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, elem)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(elem + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = elem
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, elem)
			}
		}
	}
}

func _DupParsedVarName(tls *libc.TLS, srcPtr uintptr, dupPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var arrayPtr, elem, irPtr, ptr1, ptr2, v1, v2, v3 uintptr
	var parsed int32
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	_, _, _, _, _, _, _, _, _ = arrayPtr, elem, irPtr, parsed, ptr1, ptr2, v1, v2, v3
	if (*TTcl_Obj)(unsafe.Pointer(srcPtr)).FtypePtr == uintptr(unsafe.Pointer(&_parsedVarNameType)) {
		v1 = srcPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	parsed = libc.BoolInt32(irPtr != libc.UintptrFromInt32(0))
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	arrayPtr = v2
	if irPtr != 0 {
		v3 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr2
	} else {
		v3 = libc.UintptrFromInt32(0)
	}
	elem = v3
	parsed++ /* Silence compiler. */
	ptr1 = arrayPtr
	ptr2 = elem
	if ptr1 != 0 {
		(*TTcl_Obj)(unsafe.Pointer(ptr1)).FrefCount++
	}
	if ptr2 != 0 {
		(*TTcl_Obj)(unsafe.Pointer(ptr2)).FrefCount++
	}
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr1 = ptr1
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr2 = ptr2
	XTcl_StoreInternalRep(tls, dupPtr, uintptr(unsafe.Pointer(&_parsedVarNameType)), bp)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_FindNamespaceVar -- MOVED OVER from tclNamesp.c
 *
 *	Searches for a namespace variable, a variable not local to a
 *	procedure. The variable can be either a scalar or an array, but may
 *	not be an element of an array.
 *
 * Results:
 *	Returns a token for the variable if it is found. Otherwise, if it
 *	can't be found or there is an error, returns NULL and leaves an error
 *	message in the interpreter's result object if "flags" contains
 *	TCL_LEAVE_ERR_MSG.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_FindNamespaceVar(tls *libc.TLS, interp uintptr, name uintptr, contextNsPtr uintptr, flags int32) (r TTcl_Var) {
	/* An OR'd combination of:
	 * TCL_AVOID_RESOLVERS, TCL_GLOBAL_ONLY (look
	 * up name only in global namespace),
	 * TCL_NAMESPACE_ONLY (look up only in
	 * contextNsPtr, or the current namespace if
	 * contextNsPtr is NULL), and
	 * TCL_LEAVE_ERR_MSG. If both TCL_GLOBAL_ONLY
	 * and TCL_NAMESPACE_ONLY are given,
	 * TCL_GLOBAL_ONLY is ignored. */
	var _objPtr, namePtr, v2 uintptr
	var var1 TTcl_Var
	var v1 TTcl_Size
	_, _, _, _, _ = _objPtr, namePtr, var1, v1, v2
	namePtr = XTcl_NewStringObj(tls, name, int64(-int32(1)))
	var1 = _ObjFindNamespaceVar(tls, interp, namePtr, contextNsPtr, flags)
	_objPtr = namePtr
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return var1
}

func _ObjFindNamespaceVar(tls *libc.TLS, interp uintptr, namePtr uintptr, contextNsPtr uintptr, flags int32) (r TTcl_Var) {
	bp := tls.Alloc(96)
	defer tls.Free(96) /* An OR'd combination of:
	 * TCL_AVOID_RESOLVERS, TCL_GLOBAL_ONLY (look
	 * up name only in global namespace),
	 * TCL_NAMESPACE_ONLY (look up only in
	 * contextNsPtr, or the current namespace if
	 * contextNsPtr is NULL), and
	 * TCL_LEAVE_ERR_MSG. If both TCL_GLOBAL_ONLY
	 * and TCL_NAMESPACE_ONLY are given,
	 * TCL_GLOBAL_ONLY is ignored. */
	var _objPtr, iPtr, name, resPtr, simpleNamePtr, varPtr, v1, v4 uintptr
	var result, search int32
	var v3 TTcl_Size
	var _ /* cxtNsPtr at bp+16 */ uintptr
	var _ /* nsPtr at bp+0 */ [2]uintptr
	var _ /* simpleName at bp+24 */ uintptr
	var _ /* var at bp+32 */ TTcl_Var
	_, _, _, _, _, _, _, _, _, _, _ = _objPtr, iPtr, name, resPtr, result, search, simpleNamePtr, varPtr, v1, v3, v4
	iPtr = interp
	if (*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, namePtr, libc.UintptrFromInt32(0))
	}
	name = v1
	/*
	 * If this namespace has a variable resolver, then give it first crack at
	 * the variable resolution. It may return a Tcl_Var value, it may signal
	 * to continue onward, or it may signal an error.
	 */
	if flags&int32(TCL_GLOBAL_ONLY) != 0 {
		*(*uintptr)(unsafe.Pointer(bp + 16)) = (*TInterp)(unsafe.Pointer(interp)).FglobalNsPtr
	} else {
		if contextNsPtr != libc.UintptrFromInt32(0) {
			*(*uintptr)(unsafe.Pointer(bp + 16)) = contextNsPtr
		} else {
			*(*uintptr)(unsafe.Pointer(bp + 16)) = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FnsPtr
		}
	}
	if !(flags&libc.Int32FromInt32(TCL_AVOID_RESOLVERS) != 0) && ((*TNamespace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FvarResProc != libc.UintptrFromInt32(0) || (*TInterp)(unsafe.Pointer(iPtr)).FresolverPtr != libc.UintptrFromInt32(0)) {
		resPtr = (*TInterp)(unsafe.Pointer(iPtr)).FresolverPtr
		if (*TNamespace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FvarResProc != 0 {
			result = (*(*func(*libc.TLS, uintptr, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TNamespace)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FvarResProc})))(tls, interp, name, *(*uintptr)(unsafe.Pointer(bp + 16)), flags, bp+32)
		} else {
			result = int32(TCL_CONTINUE)
		}
		for result == int32(TCL_CONTINUE) && resPtr != 0 {
			if (*TResolverScheme)(unsafe.Pointer(resPtr)).FvarResProc != 0 {
				result = (*(*func(*libc.TLS, uintptr, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TResolverScheme)(unsafe.Pointer(resPtr)).FvarResProc})))(tls, interp, name, *(*uintptr)(unsafe.Pointer(bp + 16)), flags, bp+32)
			}
			resPtr = (*TResolverScheme)(unsafe.Pointer(resPtr)).FnextPtr
		}
		if result == TCL_OK {
			return *(*TTcl_Var)(unsafe.Pointer(bp + 32))
		} else {
			if result != int32(TCL_CONTINUE) {
				return libc.UintptrFromInt32(0)
			}
		}
	}
	/*
	 * Find the namespace(s) that contain the variable.
	 */
	if !(flags&libc.Int32FromInt32(TCL_GLOBAL_ONLY) != 0) {
		flags |= int32(TCL_NAMESPACE_ONLY)
	}
	XTclGetNamespaceForQualName(tls, interp, name, contextNsPtr, flags, bp, bp+1*8, bp+16, bp+24)
	/*
	 * Look for the variable in the variable table of its namespace. Be sure
	 * to check both possible search paths: from the specified namespace
	 * context and from the global namespace.
	 */
	varPtr = libc.UintptrFromInt32(0)
	if *(*uintptr)(unsafe.Pointer(bp + 24)) != name {
		simpleNamePtr = XTcl_NewStringObj(tls, *(*uintptr)(unsafe.Pointer(bp + 24)), int64(-int32(1)))
	} else {
		simpleNamePtr = namePtr
	}
	search = 0
	for {
		if !(search < int32(2) && varPtr == libc.UintptrFromInt32(0)) {
			break
		}
		if (*(*[2]uintptr)(unsafe.Pointer(bp)))[search] != libc.UintptrFromInt32(0) && *(*uintptr)(unsafe.Pointer(bp + 24)) != libc.UintptrFromInt32(0) {
			varPtr = _VarHashCreateVar1(tls, (*(*[2]uintptr)(unsafe.Pointer(bp)))[search]+288, simpleNamePtr, libc.UintptrFromInt32(0))
		}
		goto _2
	_2:
		;
		search++
	}
	if *(*uintptr)(unsafe.Pointer(bp + 24)) != name {
		_objPtr = simpleNamePtr
		v4 = _objPtr
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	if varPtr == libc.UintptrFromInt32(0) && flags&int32(TCL_LEAVE_ERR_MSG) != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+70065, libc.VaList(bp+48, name)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+48, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+17108, name, libc.UintptrFromInt32(0)))
	}
	return varPtr
}

/*
 *----------------------------------------------------------------------
 *
 * InfoVarsCmd -- (moved over from tclCmdIL.c)
 *
 *	Called to implement the "info vars" command that returns the list of
 *	variables in the interpreter that match an optional pattern. The
 *	pattern, if any, consists of an optional sequence of namespace names
 *	separated by "::" qualifiers, which is followed by a glob-style
 *	pattern that restricts which variables are returned. Handles the
 *	following syntax:
 *
 *	    info vars ?pattern?
 *
 * Results:
 *	Returns TCL_OK if successful and TCL_ERROR if there is an error.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If there is an
 *	error, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func XTclInfoVarsCmd(tls *libc.TLS, dummy5991 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Argument objects. */
	var _objPtr, cachePtr, cachePtr1, currNsPtr, elemObjPtr, iPtr, listPtr, pattern, simplePatternPtr, varName, varNamePtr, varPtr, v1, v3, v6 uintptr
	var specificNsInPattern int32
	var v2, v4 bool
	var v5 TTcl_Size
	var _ /* dummy1NsPtr at bp+40 */ uintptr
	var _ /* dummy2NsPtr at bp+48 */ uintptr
	var _ /* nsPtr at bp+32 */ uintptr
	var _ /* search at bp+8 */ TTcl_HashSearch
	var _ /* simplePattern at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, cachePtr1, currNsPtr, elemObjPtr, iPtr, listPtr, pattern, simplePatternPtr, specificNsInPattern, varName, varNamePtr, varPtr, v1, v2, v3, v4, v5, v6
	iPtr = interp
	currNsPtr = XTcl_GetCurrentNamespace(tls, interp)
	specificNsInPattern = 0 /* Init. to avoid compiler warning. */
	simplePatternPtr = libc.UintptrFromInt32(0)
	/*
	 * Get the pattern and find the "effective namespace" in which to list
	 * variables. We only use this effective namespace if there's no active
	 * Tcl procedure frame.
	 */
	if objc == int32(1) {
		*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(bp + 32)) = currNsPtr
		specificNsInPattern = 0
	} else {
		if objc == int32(2) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
				v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
			} else {
				v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
			}
			pattern = v1
			XTclGetNamespaceForQualName(tls, interp, pattern, libc.UintptrFromInt32(0), 0, bp+32, bp+40, bp+48, bp)
			if *(*uintptr)(unsafe.Pointer(bp + 32)) != libc.UintptrFromInt32(0) { /* We successfully found the pattern's ns. */
				specificNsInPattern = libc.BoolInt32(libc.Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(bp)), pattern) != 0)
				if *(*uintptr)(unsafe.Pointer(bp)) == pattern {
					simplePatternPtr = *(*uintptr)(unsafe.Pointer(objv + 1*8))
				} else {
					simplePatternPtr = XTcl_NewStringObj(tls, *(*uintptr)(unsafe.Pointer(bp)), int64(-int32(1)))
				}
				(*TTcl_Obj)(unsafe.Pointer(simplePatternPtr)).FrefCount++
			}
		} else {
			XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+16401)
			return int32(TCL_ERROR)
		}
	}
	/*
	 * If the namespace specified in the pattern wasn't found, just return.
	 */
	if *(*uintptr)(unsafe.Pointer(bp + 32)) == libc.UintptrFromInt32(0) {
		return TCL_OK
	}
	listPtr = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
	if !((*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FisProcCallFrame&libc.Int32FromInt32(FRAME_IS_PROC) != 0) || specificNsInPattern != 0 {
		/*
		 * There is no frame pointer, the frame pointer was pushed only to
		 * activate a namespace, or we are in a procedure call frame but a
		 * specific namespace was specified. Create a list containing only the
		 * variables in the effective namespace's variable table.
		 */
		if *(*uintptr)(unsafe.Pointer(bp)) != 0 && libc.Xstrpbrk(tls, *(*uintptr)(unsafe.Pointer(bp)), __ccgo_ts+16411) == libc.UintptrFromInt32(0) {
			/*
			 * If we can just do hash lookups, that simplifies things a lot.
			 */
			varPtr = _VarHashCreateVar1(tls, *(*uintptr)(unsafe.Pointer(bp + 32))+288, simplePatternPtr, libc.UintptrFromInt32(0))
			if varPtr != 0 {
				if !(*(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0)) || (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_NAMESPACE_VAR) != 0 {
					if specificNsInPattern != 0 {
						if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
							cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
							elemObjPtr = XTclThreadAllocObj(tls)
						} else {
							elemObjPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(elemObjPtr + 32))).Fptr1
							(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
						}
						(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).FrefCount = 0
						(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
						(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).Flength = 0
						(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).FtypePtr = libc.UintptrFromInt32(0)
						XTcl_GetVariableFullName(tls, interp, varPtr, elemObjPtr)
					} else {
						elemObjPtr = *(*uintptr)(unsafe.Pointer(varPtr + 24 + 32))
					}
					XTcl_ListObjAppendElement(tls, interp, listPtr, elemObjPtr)
				}
			}
		} else {
			/*
			 * Have to scan the tables of variables.
			 */
			varPtr = _VarHashFirstVar(tls, *(*uintptr)(unsafe.Pointer(bp + 32))+288, bp+8)
			for varPtr != 0 {
				if !(*(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0)) || (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_NAMESPACE_VAR) != 0 {
					varNamePtr = *(*uintptr)(unsafe.Pointer(varPtr + 24 + 32))
					if (*TTcl_Obj)(unsafe.Pointer(varNamePtr)).Fbytes != 0 {
						v3 = (*TTcl_Obj)(unsafe.Pointer(varNamePtr)).Fbytes
					} else {
						v3 = XTcl_GetStringFromObj(tls, varNamePtr, libc.UintptrFromInt32(0))
					}
					varName = v3
					if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) || XTcl_StringCaseMatch(tls, varName, *(*uintptr)(unsafe.Pointer(bp)), 0) != 0 {
						if specificNsInPattern != 0 {
							if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
								cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
							}
							if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
								elemObjPtr = XTclThreadAllocObj(tls)
							} else {
								elemObjPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
								(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer(elemObjPtr + 32))).Fptr1
								(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
							}
							(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).FrefCount = 0
							(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
							(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).Flength = 0
							(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).FtypePtr = libc.UintptrFromInt32(0)
							XTcl_GetVariableFullName(tls, interp, varPtr, elemObjPtr)
						} else {
							elemObjPtr = varNamePtr
						}
						XTcl_ListObjAppendElement(tls, interp, listPtr, elemObjPtr)
					}
				}
				varPtr = _VarHashNextVar(tls, bp+8)
			}
		}
	} else {
		if (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FprocPtr != libc.UintptrFromInt32(0) {
			_AppendLocals(tls, interp, listPtr, simplePatternPtr, int32(1), 0)
		}
	}
	if simplePatternPtr != 0 {
		_objPtr = simplePatternPtr
		v6 = _objPtr
		v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
		*(*TTcl_Size)(unsafe.Pointer(v6))--
		if v5 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	XTcl_SetObjResult(tls, interp, listPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * InfoGlobalsCmd -- (moved over from tclCmdIL.c)
 *
 *	Called to implement the "info globals" command that returns the list
 *	of global variables matching an optional pattern. Handles the
 *	following syntax:
 *
 *	    info globals ?pattern?
 *
 * Results:
 *	Returns TCL_OK if successful and TCL_ERROR if there is an error.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If there is an
 *	error, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func XTclInfoGlobalsCmd(tls *libc.TLS, dummy6142 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Argument objects. */
	var _objPtr, globalNsPtr, listPtr, pattern, patternPtr, varName, varNamePtr, varPtr, v1, v2, v4, v6 uintptr
	var v3 TTcl_Size
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, globalNsPtr, listPtr, pattern, patternPtr, varName, varNamePtr, varPtr, v1, v2, v3, v4, v6
	globalNsPtr = XTcl_GetGlobalNamespace(tls, interp)
	if objc == int32(1) {
		pattern = libc.UintptrFromInt32(0)
	} else {
		if objc == int32(2) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
				v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
			} else {
				v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
			}
			pattern = v1
			/*
			 * Strip leading global-namespace qualifiers. [Bug 1057461]
			 */
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) == int32(':') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern + 1))) == int32(':') {
				for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) == int32(':') {
					pattern++
				}
			}
		} else {
			XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+16401)
			return int32(TCL_ERROR)
		}
	}
	/*
	 * Scan through the global :: namespace's variable table and create a list
	 * of all global variables that match the pattern.
	 */
	listPtr = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
	if pattern != libc.UintptrFromInt32(0) && libc.Xstrpbrk(tls, pattern, __ccgo_ts+16411) == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
		}
		if pattern == v2 {
			patternPtr = *(*uintptr)(unsafe.Pointer(objv + 1*8))
		} else {
			patternPtr = XTcl_NewStringObj(tls, pattern, int64(-int32(1)))
		}
		(*TTcl_Obj)(unsafe.Pointer(patternPtr)).FrefCount++
		varPtr = _VarHashCreateVar1(tls, globalNsPtr+288, patternPtr, libc.UintptrFromInt32(0))
		if varPtr != 0 {
			if !(*(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0)) {
				XTcl_ListObjAppendElement(tls, interp, listPtr, *(*uintptr)(unsafe.Pointer(varPtr + 24 + 32)))
			}
		}
		_objPtr = patternPtr
		v4 = _objPtr
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	} else {
		varPtr = _VarHashFirstVar(tls, globalNsPtr+288, bp)
		for {
			if !(varPtr != libc.UintptrFromInt32(0)) {
				break
			}
			if *(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0) {
				goto _5
			}
			varNamePtr = *(*uintptr)(unsafe.Pointer(varPtr + 24 + 32))
			if (*TTcl_Obj)(unsafe.Pointer(varNamePtr)).Fbytes != 0 {
				v6 = (*TTcl_Obj)(unsafe.Pointer(varNamePtr)).Fbytes
			} else {
				v6 = XTcl_GetStringFromObj(tls, varNamePtr, libc.UintptrFromInt32(0))
			}
			varName = v6
			if pattern == libc.UintptrFromInt32(0) || XTcl_StringCaseMatch(tls, varName, pattern, 0) != 0 {
				XTcl_ListObjAppendElement(tls, interp, listPtr, varNamePtr)
			}
			goto _5
		_5:
			;
			varPtr = _VarHashNextVar(tls, bp)
		}
	}
	XTcl_SetObjResult(tls, interp, listPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclInfoLocalsCmd -- (moved over from tclCmdIl.c)
 *
 *	Called to implement the "info locals" command to return a list of
 *	local variables that match an optional pattern. Handles the following
 *	syntax:
 *
 *	    info locals ?pattern?
 *
 * Results:
 *	Returns TCL_OK if successful and TCL_ERROR if there is an error.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If there is an
 *	error, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func XTclInfoLocalsCmd(tls *libc.TLS, dummy6235 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var iPtr, listPtr, patternPtr uintptr
	_, _, _ = iPtr, listPtr, patternPtr
	iPtr = interp
	if objc == int32(1) {
		patternPtr = libc.UintptrFromInt32(0)
	} else {
		if objc == int32(2) {
			patternPtr = *(*uintptr)(unsafe.Pointer(objv + 1*8))
		} else {
			XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+16401)
			return int32(TCL_ERROR)
		}
	}
	if !((*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FisProcCallFrame&libc.Int32FromInt32(FRAME_IS_PROC) != 0) {
		return TCL_OK
	}
	/*
	 * Return a list containing names of first the compiled locals (i.e. the
	 * ones stored in the call frame), then the variables in the local hash
	 * table (if one exists).
	 */
	listPtr = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
	_AppendLocals(tls, interp, listPtr, patternPtr, 0, 0)
	XTcl_SetObjResult(tls, interp, listPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclInfoConstsCmd --
 *
 *	Called to implement the "info consts" command that returns the list of
 *	constants in the interpreter that match an optional pattern. The
 *	pattern, if any, consists of an optional sequence of namespace names
 *	separated by "::" qualifiers, which is followed by a glob-style
 *	pattern that restricts which variables are returned. Handles the
 *	following syntax:
 *
 *	    info consts ?pattern?
 *
 * Results:
 *	Returns TCL_OK if successful and TCL_ERROR if there is an error.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If there is an
 *	error, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func XTclInfoConstsCmd(tls *libc.TLS, dummy6294 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Argument objects. */
	var _objPtr, cachePtr, cachePtr1, currNsPtr, elemObjPtr, globalNsPtr, iPtr, listPtr, pattern, simplePatternPtr, varName, varNamePtr, varPtr, v1, v3, v5, v7 uintptr
	var specificNsInPattern int32
	var v2, v4 bool
	var v6 TTcl_Size
	var _ /* dummy1NsPtr at bp+40 */ uintptr
	var _ /* dummy2NsPtr at bp+48 */ uintptr
	var _ /* nsPtr at bp+32 */ uintptr
	var _ /* search at bp+8 */ TTcl_HashSearch
	var _ /* simplePattern at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, cachePtr1, currNsPtr, elemObjPtr, globalNsPtr, iPtr, listPtr, pattern, simplePatternPtr, specificNsInPattern, varName, varNamePtr, varPtr, v1, v2, v3, v4, v5, v6, v7
	iPtr = interp
	globalNsPtr = XTcl_GetGlobalNamespace(tls, interp)
	currNsPtr = XTcl_GetCurrentNamespace(tls, interp)
	specificNsInPattern = 0 /* Init. to avoid compiler warning. */
	simplePatternPtr = libc.UintptrFromInt32(0)
	/*
	 * Get the pattern and find the "effective namespace" in which to list
	 * variables. We only use this effective namespace if there's no active
	 * Tcl procedure frame.
	 */
	if objc == int32(1) {
		*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(bp + 32)) = currNsPtr
		specificNsInPattern = 0
	} else {
		if objc == int32(2) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
				v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
			} else {
				v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
			}
			pattern = v1
			XTclGetNamespaceForQualName(tls, interp, pattern, libc.UintptrFromInt32(0), 0, bp+32, bp+40, bp+48, bp)
			if *(*uintptr)(unsafe.Pointer(bp + 32)) != libc.UintptrFromInt32(0) { /* We successfully found the pattern's ns. */
				specificNsInPattern = libc.BoolInt32(libc.Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(bp)), pattern) != 0)
				if *(*uintptr)(unsafe.Pointer(bp)) == pattern {
					simplePatternPtr = *(*uintptr)(unsafe.Pointer(objv + 1*8))
				} else {
					simplePatternPtr = XTcl_NewStringObj(tls, *(*uintptr)(unsafe.Pointer(bp)), int64(-int32(1)))
				}
				(*TTcl_Obj)(unsafe.Pointer(simplePatternPtr)).FrefCount++
			}
		} else {
			XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+16401)
			return int32(TCL_ERROR)
		}
	}
	/*
	 * If the namespace specified in the pattern wasn't found, just return.
	 */
	if *(*uintptr)(unsafe.Pointer(bp + 32)) == libc.UintptrFromInt32(0) {
		return TCL_OK
	}
	listPtr = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
	if !((*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FisProcCallFrame&libc.Int32FromInt32(FRAME_IS_PROC) != 0) || specificNsInPattern != 0 {
		/*
		 * There is no frame pointer, the frame pointer was pushed only to
		 * activate a namespace, or we are in a procedure call frame but a
		 * specific namespace was specified. Create a list containing only the
		 * variables in the effective namespace's variable table.
		 */
		if *(*uintptr)(unsafe.Pointer(bp)) != 0 && libc.Xstrpbrk(tls, *(*uintptr)(unsafe.Pointer(bp)), __ccgo_ts+16411) == libc.UintptrFromInt32(0) {
			/*
			 * If we can just do hash lookups, that simplifies things a lot.
			 */
			varPtr = _VarHashCreateVar1(tls, *(*uintptr)(unsafe.Pointer(bp + 32))+288, simplePatternPtr, libc.UintptrFromInt32(0))
			if varPtr != 0 && (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_CONSTANT) != 0 {
				if !(*(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0)) || (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_NAMESPACE_VAR) != 0 {
					if specificNsInPattern != 0 {
						if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
							cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
							elemObjPtr = XTclThreadAllocObj(tls)
						} else {
							elemObjPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(elemObjPtr + 32))).Fptr1
							(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
						}
						(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).FrefCount = 0
						(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
						(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).Flength = 0
						(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).FtypePtr = libc.UintptrFromInt32(0)
						XTcl_GetVariableFullName(tls, interp, varPtr, elemObjPtr)
					} else {
						elemObjPtr = *(*uintptr)(unsafe.Pointer(varPtr + 24 + 32))
					}
					XTcl_ListObjAppendElement(tls, interp, listPtr, elemObjPtr)
				}
			} else {
				if *(*uintptr)(unsafe.Pointer(bp + 32)) != globalNsPtr && !(specificNsInPattern != 0) {
					varPtr = _VarHashCreateVar1(tls, globalNsPtr+288, simplePatternPtr, libc.UintptrFromInt32(0))
					if varPtr != 0 && (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_CONSTANT) != 0 {
						if !(*(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0)) || (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_NAMESPACE_VAR) != 0 {
							XTcl_ListObjAppendElement(tls, interp, listPtr, *(*uintptr)(unsafe.Pointer(varPtr + 24 + 32)))
						}
					}
				}
			}
		} else {
			/*
			 * Have to scan the tables of variables.
			 */
			varPtr = _VarHashFirstVar(tls, *(*uintptr)(unsafe.Pointer(bp + 32))+288, bp+8)
			for varPtr != 0 {
				if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_CONSTANT) != 0 && (!(*(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0)) || (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_NAMESPACE_VAR) != 0) {
					varNamePtr = *(*uintptr)(unsafe.Pointer(varPtr + 24 + 32))
					if (*TTcl_Obj)(unsafe.Pointer(varNamePtr)).Fbytes != 0 {
						v3 = (*TTcl_Obj)(unsafe.Pointer(varNamePtr)).Fbytes
					} else {
						v3 = XTcl_GetStringFromObj(tls, varNamePtr, libc.UintptrFromInt32(0))
					}
					varName = v3
					if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) || XTcl_StringCaseMatch(tls, varName, *(*uintptr)(unsafe.Pointer(bp)), 0) != 0 {
						if specificNsInPattern != 0 {
							if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
								cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
							}
							if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
								elemObjPtr = XTclThreadAllocObj(tls)
							} else {
								elemObjPtr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
								(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer(elemObjPtr + 32))).Fptr1
								(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
							}
							(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).FrefCount = 0
							(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
							(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).Flength = 0
							(*TTcl_Obj)(unsafe.Pointer(elemObjPtr)).FtypePtr = libc.UintptrFromInt32(0)
							XTcl_GetVariableFullName(tls, interp, varPtr, elemObjPtr)
						} else {
							elemObjPtr = varNamePtr
						}
						XTcl_ListObjAppendElement(tls, interp, listPtr, elemObjPtr)
					}
				}
				varPtr = _VarHashNextVar(tls, bp+8)
			}
			/*
			 * If the effective namespace isn't the global :: namespace, and a
			 * specific namespace wasn't requested in the pattern (i.e., the
			 * pattern only specifies variable names), then add in all global
			 * :: variables that match the simple pattern. Of course, add in
			 * only those variables that aren't hidden by a variable in the
			 * effective namespace.
			 */
			if *(*uintptr)(unsafe.Pointer(bp + 32)) != globalNsPtr && !(specificNsInPattern != 0) {
				varPtr = _VarHashFirstVar(tls, globalNsPtr+288, bp+8)
				for varPtr != 0 {
					if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_CONSTANT) != 0 && (!(*(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0)) || (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_NAMESPACE_VAR) != 0) {
						varNamePtr = *(*uintptr)(unsafe.Pointer(varPtr + 24 + 32))
						if (*TTcl_Obj)(unsafe.Pointer(varNamePtr)).Fbytes != 0 {
							v5 = (*TTcl_Obj)(unsafe.Pointer(varNamePtr)).Fbytes
						} else {
							v5 = XTcl_GetStringFromObj(tls, varNamePtr, libc.UintptrFromInt32(0))
						}
						varName = v5
						if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) || XTcl_StringCaseMatch(tls, varName, *(*uintptr)(unsafe.Pointer(bp)), 0) != 0 {
							if _VarHashCreateVar1(tls, *(*uintptr)(unsafe.Pointer(bp + 32))+288, varNamePtr, libc.UintptrFromInt32(0)) == libc.UintptrFromInt32(0) {
								XTcl_ListObjAppendElement(tls, interp, listPtr, varNamePtr)
							}
						}
					}
					varPtr = _VarHashNextVar(tls, bp+8)
				}
			}
		}
	} else {
		if (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FprocPtr != libc.UintptrFromInt32(0) {
			_AppendLocals(tls, interp, listPtr, simplePatternPtr, int32(1), int32(1))
		}
	}
	if simplePatternPtr != 0 {
		_objPtr = simplePatternPtr
		v7 = _objPtr
		v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
		*(*TTcl_Size)(unsafe.Pointer(v7))--
		if v6 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	XTcl_SetObjResult(tls, interp, listPtr)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * AppendLocals --
 *
 *	Append the local variables for the current frame to the specified list
 *	object.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _ContextObjectContainsConstant(tls *libc.TLS, context TTcl_ObjectContext, varNamePtr uintptr) (r int32) {
	var nsPtr, oPtr, varPtr uintptr
	_, _, _ = nsPtr, oPtr, varPtr
	/*
	 * Helper for AppendLocals to check if an object contains a variable
	 * that is a constant. It's too complicated without factoring this
	 * check out!
	 */
	oPtr = XTcl_ObjectContextObject(tls, context)
	nsPtr = (*TObject)(unsafe.Pointer(oPtr)).FnamespacePtr
	varPtr = _VarHashCreateVar1(tls, nsPtr+288, varNamePtr, libc.UintptrFromInt32(0))
	return libc.BoolInt32(!(*(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0)) && (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_CONSTANT) != 0)
}

func _AppendLocals(tls *libc.TLS, interp uintptr, listPtr uintptr, patternPtr uintptr, includeLinks int32, justConstants int32) {
	bp := tls.Alloc(144)
	defer tls.Free(144) /* 1 if just constants should be included. */
	var clsPtr, iPtr, localVarTablePtr, mPtr, oPtr, objNamePtr, pattern, privatePtr, varName, varNamePtr, varPtr, v1, v12, v16, v2, v20, v4, v6, v8 uintptr
	var context TTcl_ObjectContext
	var i, localVarCt TTcl_Size
	var v10, v13, v14, v17, v18, v21, v22, v9 bool
	var _ /* added at bp+0 */ int32
	var _ /* addedTable at bp+32 */ TTcl_HashTable
	var _ /* search at bp+8 */ TTcl_HashSearch
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = clsPtr, context, i, iPtr, localVarCt, localVarTablePtr, mPtr, oPtr, objNamePtr, pattern, privatePtr, varName, varNamePtr, varPtr, v1, v10, v12, v13, v14, v16, v17, v18, v2, v20, v21, v22, v4, v6, v8, v9
	iPtr = interp
	if patternPtr != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(patternPtr)).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(patternPtr)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, patternPtr, libc.UintptrFromInt32(0))
		}
		v1 = v2
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	pattern = v1
	localVarCt = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FnumCompiledLocals
	varPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FcompiledLocals
	localVarTablePtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FvarTablePtr
	if includeLinks != 0 {
		XTcl_InitObjHashTable(tls, bp+32)
	}
	if localVarCt > 0 {
		varNamePtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FlocalCachePtr + 16
		i = 0
		for {
			if !(i < localVarCt) {
				break
			}
			/*
			 * Skip nameless (temporary) variables and undefined variables.
			 */
			if *(*uintptr)(unsafe.Pointer(varNamePtr)) != 0 && !(*(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0)) && (includeLinks != 0 || !((*TVar)(unsafe.Pointer(varPtr)).Fflags&libc.Int32FromInt32(VAR_LINK) != 0)) {
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(varNamePtr)))).Fbytes != 0 {
					v4 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(varNamePtr)))).Fbytes
				} else {
					v4 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(varNamePtr)), libc.UintptrFromInt32(0))
				}
				varName = v4
				if pattern == libc.UintptrFromInt32(0) || XTcl_StringCaseMatch(tls, varName, pattern, 0) != 0 {
					if !(justConstants != 0) || (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_CONSTANT) != 0 {
						XTcl_ListObjAppendElement(tls, interp, listPtr, *(*uintptr)(unsafe.Pointer(varNamePtr)))
					}
					if includeLinks != 0 {
						(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(bp + 32)).FcreateProc})))(tls, bp+32, *(*uintptr)(unsafe.Pointer(varNamePtr)), bp)
					}
				}
			}
			varPtr += 16
			goto _3
		_3:
			;
			i++
			varNamePtr += 8
		}
	}
	/*
	 * Do nothing if no local variables.
	 */
	if localVarTablePtr == libc.UintptrFromInt32(0) {
		goto objectVars
	}
	/*
	 * Check for the simple and fast case.
	 */
	if pattern != libc.UintptrFromInt32(0) && libc.Xstrpbrk(tls, pattern, __ccgo_ts+16411) == libc.UintptrFromInt32(0) {
		varPtr = _VarHashCreateVar1(tls, localVarTablePtr, patternPtr, libc.UintptrFromInt32(0))
		if varPtr != libc.UintptrFromInt32(0) {
			if !(*(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0)) && (includeLinks != 0 || !((*TVar)(unsafe.Pointer(varPtr)).Fflags&libc.Int32FromInt32(VAR_LINK) != 0)) {
				if !(justConstants != 0) || (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_CONSTANT) != 0 {
					XTcl_ListObjAppendElement(tls, interp, listPtr, *(*uintptr)(unsafe.Pointer(varPtr + 24 + 32)))
				}
				if includeLinks != 0 {
					(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(bp + 32)).FcreateProc})))(tls, bp+32, *(*uintptr)(unsafe.Pointer(varPtr + 24 + 32)), bp)
				}
			}
		}
		goto objectVars
	}
	/*
	 * Scan over and process all local variables.
	 */
	varPtr = _VarHashFirstVar(tls, localVarTablePtr, bp+8)
	for {
		if !(varPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if !(*(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0)) && (includeLinks != 0 || !((*TVar)(unsafe.Pointer(varPtr)).Fflags&libc.Int32FromInt32(VAR_LINK) != 0)) {
			objNamePtr = *(*uintptr)(unsafe.Pointer(varPtr + 24 + 32))
			if (*TTcl_Obj)(unsafe.Pointer(objNamePtr)).Fbytes != 0 {
				v6 = (*TTcl_Obj)(unsafe.Pointer(objNamePtr)).Fbytes
			} else {
				v6 = XTcl_GetStringFromObj(tls, objNamePtr, libc.UintptrFromInt32(0))
			}
			varName = v6
			if pattern == libc.UintptrFromInt32(0) || XTcl_StringCaseMatch(tls, varName, pattern, 0) != 0 {
				if !(justConstants != 0) || (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_CONSTANT) != 0 {
					XTcl_ListObjAppendElement(tls, interp, listPtr, objNamePtr)
				}
				if includeLinks != 0 {
					(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(bp + 32)).FcreateProc})))(tls, bp+32, objNamePtr, bp)
				}
			}
		}
		goto _5
	_5:
		;
		varPtr = _VarHashNextVar(tls, bp+8)
	}
	goto objectVars
objectVars:
	;
	if !(includeLinks != 0) {
		return
	}
	if (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FisProcCallFrame&int32(FRAME_IS_METHOD) != 0 {
		context = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FclientData
		mPtr = XTcl_ObjectContextMethod(tls, context)
		if (*TMethod)(unsafe.Pointer(mPtr)).FdeclaringObjectPtr != 0 {
			oPtr = (*TMethod)(unsafe.Pointer(mPtr)).FdeclaringObjectPtr
			i = 0
			for {
				if !(i < (*TObject)(unsafe.Pointer(oPtr)).Fvariables.Fnum) {
					break
				}
				if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fvariables.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
					goto _7
				} else {
					objNamePtr = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fvariables.Flist + uintptr(i)*8))
					if libc.Int32FromInt32(1) != 0 {
						(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(bp + 32)).FcreateProc})))(tls, bp+32, objNamePtr, bp)
						if justConstants != 0 && !(_ContextObjectContainsConstant(tls, context, objNamePtr) != 0) {
							goto _7
						}
						if v10 = *(*int32)(unsafe.Pointer(bp)) != 0; v10 {
							if v9 = !(pattern != 0); !v9 {
								if (*TTcl_Obj)(unsafe.Pointer(objNamePtr)).Fbytes != 0 {
									v8 = (*TTcl_Obj)(unsafe.Pointer(objNamePtr)).Fbytes
								} else {
									v8 = XTcl_GetStringFromObj(tls, objNamePtr, libc.UintptrFromInt32(0))
								}
							}
						}
						if v10 && (v9 || XTcl_StringCaseMatch(tls, v8, pattern, 0) != 0) {
							XTcl_ListObjAppendElement(tls, interp, listPtr, objNamePtr)
						}
					}
				}
				goto _7
			_7:
				;
				i++
			}
			i = 0
			if (*TObject)(unsafe.Pointer(oPtr)).FprivateVariables.Fnum > libc.Int64FromInt32(0) {
				for {
					privatePtr = (*TObject)(unsafe.Pointer(oPtr)).FprivateVariables.Flist + uintptr(i)*16
					if !(i < (*TObject)(unsafe.Pointer(oPtr)).FprivateVariables.Fnum) {
						break
					}
					(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(bp + 32)).FcreateProc})))(tls, bp+32, (*TPrivateVariableMapping)(unsafe.Pointer(privatePtr)).FvariableObj, bp)
					if justConstants != 0 && !(_ContextObjectContainsConstant(tls, context, (*TPrivateVariableMapping)(unsafe.Pointer(privatePtr)).FfullNameObj) != 0) {
						goto _11
					}
					if v14 = *(*int32)(unsafe.Pointer(bp)) != 0; v14 {
						if v13 = !(pattern != 0); !v13 {
							if (*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privatePtr)).FvariableObj)).Fbytes != 0 {
								v12 = (*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privatePtr)).FvariableObj)).Fbytes
							} else {
								v12 = XTcl_GetStringFromObj(tls, (*TPrivateVariableMapping)(unsafe.Pointer(privatePtr)).FvariableObj, libc.UintptrFromInt32(0))
							}
						}
					}
					if v14 && (v13 || XTcl_StringCaseMatch(tls, v12, pattern, 0) != 0) {
						XTcl_ListObjAppendElement(tls, interp, listPtr, (*TPrivateVariableMapping)(unsafe.Pointer(privatePtr)).FvariableObj)
					}
					goto _11
				_11:
					;
					i++
				}
			}
		} else {
			clsPtr = (*TMethod)(unsafe.Pointer(mPtr)).FdeclaringClassPtr
			i = 0
			for {
				if !(i < (*TClass)(unsafe.Pointer(clsPtr)).Fvariables.Fnum) {
					break
				}
				if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fvariables.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
					goto _15
				} else {
					objNamePtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fvariables.Flist + uintptr(i)*8))
					if libc.Int32FromInt32(1) != 0 {
						(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(bp + 32)).FcreateProc})))(tls, bp+32, objNamePtr, bp)
						if justConstants != 0 && !(_ContextObjectContainsConstant(tls, context, objNamePtr) != 0) {
							goto _15
						}
						if v18 = *(*int32)(unsafe.Pointer(bp)) != 0; v18 {
							if v17 = !(pattern != 0); !v17 {
								if (*TTcl_Obj)(unsafe.Pointer(objNamePtr)).Fbytes != 0 {
									v16 = (*TTcl_Obj)(unsafe.Pointer(objNamePtr)).Fbytes
								} else {
									v16 = XTcl_GetStringFromObj(tls, objNamePtr, libc.UintptrFromInt32(0))
								}
							}
						}
						if v18 && (v17 || XTcl_StringCaseMatch(tls, v16, pattern, 0) != 0) {
							XTcl_ListObjAppendElement(tls, interp, listPtr, objNamePtr)
						}
					}
				}
				goto _15
			_15:
				;
				i++
			}
			i = 0
			if (*TClass)(unsafe.Pointer(clsPtr)).FprivateVariables.Fnum > libc.Int64FromInt32(0) {
				for {
					privatePtr = (*TClass)(unsafe.Pointer(clsPtr)).FprivateVariables.Flist + uintptr(i)*16
					if !(i < (*TClass)(unsafe.Pointer(clsPtr)).FprivateVariables.Fnum) {
						break
					}
					(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(bp + 32)).FcreateProc})))(tls, bp+32, (*TPrivateVariableMapping)(unsafe.Pointer(privatePtr)).FvariableObj, bp)
					if justConstants != 0 && !(_ContextObjectContainsConstant(tls, context, (*TPrivateVariableMapping)(unsafe.Pointer(privatePtr)).FfullNameObj) != 0) {
						goto _19
					}
					if v22 = *(*int32)(unsafe.Pointer(bp)) != 0; v22 {
						if v21 = !(pattern != 0); !v21 {
							if (*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privatePtr)).FvariableObj)).Fbytes != 0 {
								v20 = (*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privatePtr)).FvariableObj)).Fbytes
							} else {
								v20 = XTcl_GetStringFromObj(tls, (*TPrivateVariableMapping)(unsafe.Pointer(privatePtr)).FvariableObj, libc.UintptrFromInt32(0))
							}
						}
					}
					if v22 && (v21 || XTcl_StringCaseMatch(tls, v20, pattern, 0) != 0) {
						XTcl_ListObjAppendElement(tls, interp, listPtr, (*TPrivateVariableMapping)(unsafe.Pointer(privatePtr)).FvariableObj)
					}
					goto _19
				_19:
					;
					i++
				}
			}
		}
	}
	XTcl_DeleteHashTable(tls, bp+32)
}

/*
 *----------------------------------------------------------------------
 *
 * TclInfoConstantCmd --
 *
 *	Called to implement the "info constant" command that tests whether a
 *	specific variable is a constant. Handles the following syntax:
 *
 *	    info constant varName
 *
 * Results:
 *	Returns TCL_OK if successful and TCL_ERROR if there is an error.
 *
 * Side effects:
 *	Returns a result in the interpreter's result object. If there is an
 *	error, the result is an error message.
 *
 *----------------------------------------------------------------------
 */

func XTclInfoConstantCmd(tls *libc.TLS, dummy6693 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var result int32
	var varPtr uintptr
	var _ /* arrayPtr at bp+0 */ uintptr
	_, _ = result, varPtr
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+16508)
		return int32(TCL_ERROR)
	}
	varPtr = XTclObjLookupVar(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), 0, __ccgo_ts+70087, 0, 0, bp)
	result = libc.BoolInt32(varPtr != 0 && (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_CONSTANT) != 0)
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(result != 0)))
	return TCL_OK
}

/*
 * Hash table implementation - first, just copy and adapt the obj key stuff
 */

func XTclInitVarHashTable(tls *libc.TLS, tablePtr uintptr, nsPtr uintptr) {
	XTcl_InitCustomHashTable(tls, tablePtr, -int32(2), uintptr(unsafe.Pointer(&_tclVarHashKeyType)))
	(*TTclVarHashTable)(unsafe.Pointer(tablePtr)).FnsPtr = nsPtr
	(*TTclVarHashTable)(unsafe.Pointer(tablePtr)).FarrayPtr = libc.UintptrFromInt32(0)
}

func _AllocVarEntry(tls *libc.TLS, dummy6729 uintptr, keyPtr uintptr) (r uintptr) {
	/* Key to store in the hash table entry. */
	var hPtr, objPtr, varPtr uintptr
	_, _, _ = hPtr, objPtr, varPtr
	objPtr = keyPtr
	varPtr = XTcl_Alloc(tls, uint64(64))
	(*TVar)(unsafe.Pointer(varPtr)).Fflags = int32(VAR_IN_HASHTABLE)
	*(*uintptr)(unsafe.Pointer(varPtr + 8)) = libc.UintptrFromInt32(0)
	(*TVarInHash)(unsafe.Pointer(varPtr)).FrefCount = int64(1)
	hPtr = varPtr + 24
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = varPtr
	*(*uintptr)(unsafe.Pointer(hPtr + 32)) = objPtr
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount++
	return hPtr
}

func _FreeVarEntry(tls *libc.TLS, hPtr uintptr) {
	var _objPtr, objPtr, varPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _, _ = _objPtr, objPtr, varPtr, v1, v2
	varPtr = hPtr - uintptr(uint64(libc.UintptrFromInt32(0)+24))
	objPtr = *(*uintptr)(unsafe.Pointer(hPtr + 32))
	if *(*uintptr)(unsafe.Pointer(varPtr + 8)) == libc.UintptrFromInt32(0) && !((*TVar)(unsafe.Pointer(varPtr)).Fflags&(libc.Int32FromInt32(VAR_TRACED_READ)|libc.Int32FromInt32(VAR_TRACED_WRITE)|libc.Int32FromInt32(VAR_TRACED_ARRAY)|libc.Int32FromInt32(VAR_TRACED_UNSET)) != 0) && (*TVarInHash)(unsafe.Pointer(varPtr)).FrefCount == int64(1) {
		XTclpFree(tls, varPtr)
	} else {
		*(*int32)(unsafe.Pointer(varPtr)) |= int32(VAR_DEAD_HASH)
		*(*int32)(unsafe.Pointer(varPtr)) &= ^(libc.Int32FromInt32(VAR_ARRAY) | libc.Int32FromInt32(VAR_LINK) | libc.Int32FromInt32(VAR_CONSTANT))
		*(*uintptr)(unsafe.Pointer(varPtr + 8)) = libc.UintptrFromInt32(0)
		(*TVarInHash)(unsafe.Pointer(varPtr)).FrefCount--
	}
	_objPtr = objPtr
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
}

func _CompareVarKeys(tls *libc.TLS, keyPtr uintptr, hPtr uintptr) (r int32) {
	/* Existing key to compare. */
	var l1, l2 Tsize_t
	var objPtr1, objPtr2, p1, p2, v1, v2 uintptr
	_, _, _, _, _, _, _, _ = l1, l2, objPtr1, objPtr2, p1, p2, v1, v2
	objPtr1 = keyPtr
	objPtr2 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
	/*
	 * If the object pointers are the same then they match.
	 * OPT: this comparison was moved to the caller
	 *
	 * if (objPtr1 == objPtr2) return 1;
	 */
	/*
	 * Don't use Tcl_GetStringFromObj as it would prevent l1 and l2 being in a
	 * register.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(objPtr1)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(objPtr1)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, objPtr1, libc.UintptrFromInt32(0))
	}
	p1 = v1
	l1 = libc.Uint64FromInt64((*TTcl_Obj)(unsafe.Pointer(objPtr1)).Flength)
	if (*TTcl_Obj)(unsafe.Pointer(objPtr2)).Fbytes != 0 {
		v2 = (*TTcl_Obj)(unsafe.Pointer(objPtr2)).Fbytes
	} else {
		v2 = XTcl_GetStringFromObj(tls, objPtr2, libc.UintptrFromInt32(0))
	}
	p2 = v2
	l2 = libc.Uint64FromInt64((*TTcl_Obj)(unsafe.Pointer(objPtr2)).Flength)
	/*
	 * Only compare string representations of the same length.
	 */
	return libc.BoolInt32(l1 == l2 && !(libc.Xmemcmp(tls, p1, p2, l1) != 0))
}

/*----------------------------------------------------------------------
 *
 * ArrayDefaultCmd --
 *
 *	This function implements the 'array default' Tcl command.
 *	Refer to the user documentation for details on what it does.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _ArrayDefaultCmd(tls *libc.TLS, dummy6819 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* Argument objects. */
	var arrayNameObj, defaultValueObj, v1 uintptr
	var _ /* arrayPtr at bp+16 */ uintptr
	var _ /* isArray at bp+24 */ int32
	var _ /* option at bp+0 */ int32
	var _ /* varPtr at bp+8 */ uintptr
	_, _, _ = arrayNameObj, defaultValueObj, v1
	/*
	 * Parse arguments.
	 */
	if objc != int32(3) && objc != int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+70094)
		return int32(TCL_ERROR)
	}
	if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), uintptr(unsafe.Pointer(&_options20)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	arrayNameObj = *(*uintptr)(unsafe.Pointer(objv + 2*8))
	if int32(TCL_ERROR) == _LocateArray(tls, interp, arrayNameObj, bp+8, bp+24) {
		return int32(TCL_ERROR)
	}
	switch *(*int32)(unsafe.Pointer(bp)) {
	case 0:
		if objc != int32(3) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+69214)
			return int32(TCL_ERROR)
		}
		if !(*(*uintptr)(unsafe.Pointer(bp + 8)) != 0) || *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8)) == libc.UintptrFromInt32(0) || !(*(*int32)(unsafe.Pointer(bp + 24)) != 0) {
			return _NotArrayError(tls, interp, arrayNameObj)
		}
		defaultValueObj = XTclGetArrayDefault(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
		if !(defaultValueObj != 0) {
			/* Array default must exist. */
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+70119, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+69006, __ccgo_ts+32306, __ccgo_ts+70146, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		XTcl_SetObjResult(tls, interp, defaultValueObj)
		return TCL_OK
	case 1:
		if objc != int32(4) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+70154)
			return int32(TCL_ERROR)
		}
		/*
		 * Attempt to create array if needed.
		 */
		*(*uintptr)(unsafe.Pointer(bp + 8)) = XTclObjLookupVarEx(tls, interp, arrayNameObj, libc.UintptrFromInt32(0), int32(TCL_LEAVE_ERR_MSG), __ccgo_ts+70170, int32(1), int32(1), bp+16)
		if *(*uintptr)(unsafe.Pointer(bp + 8)) == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
		if *(*uintptr)(unsafe.Pointer(bp + 16)) != 0 {
			/*
			 * Not a valid array name.
			 */
			_CleanupVar(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), *(*uintptr)(unsafe.Pointer(bp + 16)))
			XTclObjVarErrMsg(tls, interp, arrayNameObj, libc.UintptrFromInt32(0), __ccgo_ts+70170, uintptr(unsafe.Pointer(&_NEEDARRAY)), -int32(1))
			if (*TTcl_Obj)(unsafe.Pointer(arrayNameObj)).Fbytes != 0 {
				v1 = (*TTcl_Obj)(unsafe.Pointer(arrayNameObj)).Fbytes
			} else {
				v1 = XTcl_GetStringFromObj(tls, arrayNameObj, libc.UintptrFromInt32(0))
			}
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+68940, v1, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		if !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fflags&libc.Int32FromInt32(VAR_ARRAY) != 0) && !(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8)) == libc.UintptrFromInt32(0)) {
			/*
			 * Not an array.
			 */
			XTclObjVarErrMsg(tls, interp, arrayNameObj, libc.UintptrFromInt32(0), __ccgo_ts+70170, uintptr(unsafe.Pointer(&_NEEDARRAY)), -int32(1))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+32300, __ccgo_ts+32306, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		if !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fflags&libc.Int32FromInt32(VAR_ARRAY) != 0) {
			XTclInitArrayVar(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
		}
		defaultValueObj = *(*uintptr)(unsafe.Pointer(objv + 3*8))
		_SetArrayDefault(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), defaultValueObj)
		return TCL_OK
	case 2:
		if objc != int32(3) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+69214)
			return int32(TCL_ERROR)
		}
		/*
		 * Undefined variables (whether or not they have storage allocated) do
		 * not have defaults, and this is not an error case.
		 */
		if !(*(*uintptr)(unsafe.Pointer(bp + 8)) != 0) || *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8)) == libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(0 != 0)))
		} else {
			if !(*(*int32)(unsafe.Pointer(bp + 24)) != 0) {
				return _NotArrayError(tls, interp, arrayNameObj)
			} else {
				defaultValueObj = XTclGetArrayDefault(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
				XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(libc.BoolInt32(!!(defaultValueObj != 0)) != 0)))
			}
		}
		return TCL_OK
	case 3:
		if objc != int32(3) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+69214)
			return int32(TCL_ERROR)
		}
		if *(*uintptr)(unsafe.Pointer(bp + 8)) != 0 && !(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8)) == libc.UintptrFromInt32(0)) {
			if !(*(*int32)(unsafe.Pointer(bp + 24)) != 0) {
				return _NotArrayError(tls, interp, arrayNameObj)
			}
			_SetArrayDefault(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), libc.UintptrFromInt32(0))
		}
		return TCL_OK
	}
	/* Unreached */
	return int32(TCL_ERROR)
}

var _options20 = [5]uintptr{
	0: __ccgo_ts + 24987,
	1: __ccgo_ts + 5383,
	2: __ccgo_ts + 5689,
	3: __ccgo_ts + 3450,
	4: libc.UintptrFromInt32(0),
}

/*
 * Initialize array variable.
 */

func XTclInitArrayVar(tls *libc.TLS, arrayPtr uintptr) {
	var tablePtr, v1 uintptr
	_, _ = tablePtr, v1
	tablePtr = XTcl_Alloc(tls, uint64(128))
	/*
	 * Mark the variable as an array.
	 */
	(*TVar)(unsafe.Pointer(arrayPtr)).Fflags = (*TVar)(unsafe.Pointer(arrayPtr)).Fflags & ^libc.Int32FromInt32(VAR_LINK) | int32(VAR_ARRAY)
	/*
	 * Regular TclVarHashTable initialization.
	 */
	*(*uintptr)(unsafe.Pointer(arrayPtr + 8)) = tablePtr
	if (*TVar)(unsafe.Pointer(arrayPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
		v1 = (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(arrayPtr)).Fentry.FtablePtr)).FnsPtr
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	XTclInitVarHashTable(tls, *(*uintptr)(unsafe.Pointer(arrayPtr + 8)), v1)
	(*TTclVarHashTable)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(arrayPtr + 8)))).FarrayPtr = arrayPtr
	/*
	 * Default value initialization.
	 */
	(*TArrayVarHashTable)(unsafe.Pointer(tablePtr)).FdefaultObj = libc.UintptrFromInt32(0)
}

/*
 * Cleanup array variable.
 */

func _DeleteArrayVar(tls *libc.TLS, arrayPtr uintptr) {
	var tablePtr uintptr
	_ = tablePtr
	tablePtr = *(*uintptr)(unsafe.Pointer(arrayPtr + 8))
	/*
	 * Default value cleanup.
	 */
	_SetArrayDefault(tls, arrayPtr, libc.UintptrFromInt32(0))
	/*
	 * Regular TclVarHashTable cleanup.
	 */
	XTcl_DeleteHashTable(tls, *(*uintptr)(unsafe.Pointer(arrayPtr + 8)))
	XTclpFree(tls, tablePtr)
}

/*
 * Get array default value if any.
 */

func XTclGetArrayDefault(tls *libc.TLS, arrayPtr uintptr) (r uintptr) {
	var tablePtr uintptr
	_ = tablePtr
	tablePtr = *(*uintptr)(unsafe.Pointer(arrayPtr + 8))
	return (*TArrayVarHashTable)(unsafe.Pointer(tablePtr)).FdefaultObj
}

/*
 * Set/replace/unset array default value.
 */

func _SetArrayDefault(tls *libc.TLS, arrayPtr uintptr, defaultObj uintptr) {
	var _objPtr, _objPtr1, tablePtr, v2, v4 uintptr
	var v1, v3 TTcl_Size
	_, _, _, _, _, _, _ = _objPtr, _objPtr1, tablePtr, v1, v2, v3, v4
	tablePtr = *(*uintptr)(unsafe.Pointer(arrayPtr + 8))
	/*
	 * Increment/decrement refcount twice to ensure that the object is shared,
	 * so that it doesn't get modified accidentally by the folling code:
	 *
	 *      array default set v 1
	 *      lappend v(a) 2; # returns a new object {1 2}
	 *      set v(b); # returns the original default object "1"
	 */
	if (*TArrayVarHashTable)(unsafe.Pointer(tablePtr)).FdefaultObj != 0 {
		_objPtr = (*TArrayVarHashTable)(unsafe.Pointer(tablePtr)).FdefaultObj
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		_objPtr1 = (*TArrayVarHashTable)(unsafe.Pointer(tablePtr)).FdefaultObj
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
	(*TArrayVarHashTable)(unsafe.Pointer(tablePtr)).FdefaultObj = defaultObj
	if (*TArrayVarHashTable)(unsafe.Pointer(tablePtr)).FdefaultObj != 0 {
		(*TTcl_Obj)(unsafe.Pointer((*TArrayVarHashTable)(unsafe.Pointer(tablePtr)).FdefaultObj)).FrefCount++
		(*TTcl_Obj)(unsafe.Pointer((*TArrayVarHashTable)(unsafe.Pointer(tablePtr)).FdefaultObj)).FrefCount++
	}
}

const BUFFER_SIZE_LIMIT = 65535
const DEFAULT_BUFFER_SIZE = 4096
const MAX_BUFFER_SIZE = 65536
const MAX_COMMENT_LEN = 256
const MAX_MEM_LEVEL = 9
const MAX_WBITS = 15
const MIN_NONSTREAM_BUFFER_SIZE = 16
const TCL_ZLIB_VERSION = "2.0.1"
const ZEXTERN = 0
const ZLIB_VERNUM = 4880
const ZLIB_VERSION = "1.3.1"
const ZLIB_VER_MAJOR = 1
const ZLIB_VER_MINOR = 3
const ZLIB_VER_REVISION = 1
const ZLIB_VER_SUBREVISION = 0
const Z_ASCII = 1
const Z_BEST_COMPRESSION = 9
const Z_BEST_SPEED = 1
const Z_BINARY = 0
const Z_BLOCK = 5
const Z_BUF_ERROR = -5
const Z_DATA_ERROR = -3
const Z_DEFAULT_COMPRESSION = -1
const Z_DEFAULT_STRATEGY = 0
const Z_DEFLATED = 8
const Z_ERRNO = -1
const Z_FILTERED = 1
const Z_FINISH = 4
const Z_FIXED = 4
const Z_FULL_FLUSH = 3
const Z_HUFFMAN_ONLY = 2
const Z_MEM_ERROR = -4
const Z_NEED_DICT = 2
const Z_NO_COMPRESSION = 0
const Z_NO_FLUSH = 0
const Z_NULL = 0
const Z_OK = 0
const Z_PARTIAL_FLUSH = 1
const Z_RLE = 3
const Z_STREAM_END = 1
const Z_STREAM_ERROR = -2
const Z_SYNC_FLUSH = 2
const Z_TEXT = 1
const Z_TREES = 6
const Z_U4 = 0
const Z_UNKNOWN = 2
const Z_VERSION_ERROR = -6
const z_off64_t = 0
const z_off_t = 0
const zlib_version = 0

type Tz_size_t = uint64

type TByte = uint8

type TuInt = uint32

type TuLong = uint64

type TBytef = uint8

type Tcharf = uint8

type Tintf = int32

type TuIntf = uint32

type TuLongf = uint64

type Tvoidpc = uintptr

type Tvoidpf = uintptr

type Tvoidp = uintptr

type Tz_crc_t = uint32

type Talloc_func = uintptr

type Tfree_func = uintptr

type Tz_stream = struct {
	Fnext_in   uintptr
	Favail_in  TuInt
	Ftotal_in  TuLong
	Fnext_out  uintptr
	Favail_out TuInt
	Ftotal_out TuLong
	Fmsg       uintptr
	Fstate     uintptr
	Fzalloc    Talloc_func
	Fzfree     Tfree_func
	Fopaque    Tvoidpf
	Fdata_type int32
	Fadler     TuLong
	Freserved  TuLong
}

type Tz_stream_s = Tz_stream

type Tz_streamp = uintptr

type Tgz_header = struct {
	Ftext      int32
	Ftime      TuLong
	Fxflags    int32
	Fos        int32
	Fextra     uintptr
	Fextra_len TuInt
	Fextra_max TuInt
	Fname      uintptr
	Fname_max  TuInt
	Fcomment   uintptr
	Fcomm_max  TuInt
	Fhcrc      int32
	Fdone      int32
}

type Tgz_header_s = Tgz_header

type Tgz_headerp = uintptr

type Tin_func = uintptr

type Tout_func = uintptr

type TgzFile = uintptr

type TgzFile_s = struct {
	Fhave uint32
	Fnext uintptr
	Fpos  Toff_t
}

/*
 * Values for the flags field in Channel. Any OR'ed combination of the
 * following flags can be stored in the field. These flags record various
 * options and state bits about the channel. In addition to the flags below,
 * the channel can also have TCL_READABLE (1<<1) and TCL_WRITABLE (1<<2) set.
 */

/*
 * The length of time to wait between synthetic timer events. Must be zero or
 * bad things tend to happen.
 */

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * The version of the zlib "package" that this implements. Note that this
 * thoroughly supersedes the versions included with tclkit, which are "1.1",
 * so this is at least "2.0" (there's no general *commitment* to have the same
 * interface, even if that is mostly true).
 */

/*
 * Magic flags used with wbits fields to indicate that we're handling the gzip
 * format or automatic detection of format. Putting it here is slightly less
 * gross!
 */
type WBitsFlags = int32

const WBITS_RAW = -15
const /* RAW compressed data */
WBITS_ZLIB = 15
const /* Zlib-format compressed data */
WBITS_GZIP = 31
const /* Gzip-format compressed data */
WBITS_AUTODETECT = 47

/*
 * Structure used for handling gzip headers that are generated from a
 * dictionary. It comprises the header structure itself plus some working
 * space that it is very convenient to have attached.
 */

type TGzipHeader = struct {
	Fheader            Tgz_header
	FnativeFilenameBuf [4096]uint8
	FnativeCommentBuf  [256]uint8
}

/*
 * Structure used for the Tcl_ZlibStream* commands and [zlib stream ...]
 */

type TZlibStreamHandle = struct {
	Finterp       uintptr
	Fstream       Tz_stream
	FstreamEnd    int32
	FinData       uintptr
	FoutData      uintptr
	FcurrentInput uintptr
	FoutPos       TTcl_Size
	Fmode         int32
	Fformat       int32
	Flevel        int32
	Fflush        int32
	Fwbits        int32
	Fcmd          TTcl_Command
	FcompDictObj  uintptr
	Fflags        int32
	FgzHeaderPtr  uintptr
}

type ZlibStreamHandleFlags = int32

const DICT_TO_SET = 1

/*
 * Macros to make it clearer in some of the twiddlier accesses what is
 * happening.
 */

/*
 * Structure used for stacked channel compression and decompression.
 */

type TZlibChannelData = struct {
	Fchan1          TTcl_Channel
	Fparent         TTcl_Channel
	Fflags          int32
	Fmode           int32
	Fformat         int32
	FreadAheadLimit uint32
	FinStream       Tz_stream
	FoutStream      Tz_stream
	FinBuffer       uintptr
	FoutBuffer      uintptr
	FinAllocated    Tsize_t
	FoutAllocated   Tsize_t
	FinHeader       TGzipHeader
	FoutHeader      TGzipHeader
	Ftimer          TTcl_TimerToken
	FcompDictObj    uintptr
}

/*
 * Value bits for the ZlibChannelData::flags field.
 */
type ZlibChannelDataFlags = int32

const ASYNC = 1
const /* Set if this is an asynchronous channel. */
IN_HEADER = 2
const /* Set if the inHeader field has been
 * registered with the input compressor. */
OUT_HEADER = 4
const /* Set if the outputHeader field has been
 * registered with the output decompressor. */
STREAM_DECOMPRESS = 8
const /* Set to signal decompress pending data. */
STREAM_DONE = 16

/*
 * Type of zlib-based compressing and decompressing channels.
 */

var _zlibChannelType = TTcl_ChannelType{
	FtypeName: __ccgo_ts + 70188,
	Fversion:  libc.UintptrFromInt32(0x5),
}

func init() {
	p := unsafe.Pointer(&_zlibChannelType)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_ZlibTransformInput)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_ZlibTransformOutput)
	*(*uintptr)(unsafe.Add(p, 48)) = __ccgo_fp(_ZlibTransformSetOption)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(_ZlibTransformGetOption)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(_ZlibTransformWatch)
	*(*uintptr)(unsafe.Add(p, 72)) = __ccgo_fp(_ZlibTransformGetHandle)
	*(*uintptr)(unsafe.Add(p, 80)) = __ccgo_fp(_ZlibTransformClose)
	*(*uintptr)(unsafe.Add(p, 88)) = __ccgo_fp(_ZlibTransformBlockMode)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(_ZlibTransformEventHandler)
}

// C documentation
//
//	/*
//	 *----------------------------------------------------------------------
//	 *
//	 * Latin1 --
//	 *	Helper to definitely get the ISO 8859-1 encoding. It's internally
//	 *	defined by Tcl so this operation should always succeed.
//	 *
//	 *----------------------------------------------------------------------
//	 */
func _Latin1(tls *libc.TLS) (r TTcl_Encoding) {
	var latin1enc TTcl_Encoding
	_ = latin1enc
	latin1enc = XTcl_GetEncoding(tls, libc.UintptrFromInt32(0), __ccgo_ts+29173)
	if latin1enc == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+70193, 0)
	}
	return latin1enc
}

/*
 *----------------------------------------------------------------------
 *
 * ConvertError --
 *
 *	Utility function for converting a zlib error into a Tcl error.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Updates the interpreter result and errorcode.
 *
 *----------------------------------------------------------------------
 */

func _ConvertError(tls *libc.TLS, interp uintptr, code int32, adler TuLong) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* The checksum expected (for Z_NEED_DICT) */
	var codeStr, codeStr2 uintptr
	var _ /* codeStrBuf at bp+0 */ [24]uint8
	_, _ = codeStr, codeStr2
	codeStr2 = libc.UintptrFromInt32(0)
	if interp == libc.UintptrFromInt32(0) {
		return
	}
	switch code {
	/*
	 * Firstly, the case that is *different* because it's really coming
	 * from the OS and is just being reported via zlib. It should be
	 * really uncommon because Tcl handles all I/O rather than delegating
	 * it to zlib, but proving it can't happen is hard.
	 */
	case -int32(1):
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, XTcl_PosixError(tls, interp), int64(-libc.Int32FromInt32(1))))
		return
		/*
		 * Normal errors/conditions, some of which have additional detail and
		 * some which don't. (This is not defined by array lookup because zlib
		 * error codes are sometimes negative.)
		 */
		fallthrough
	case -int32(2):
		codeStr = __ccgo_ts + 70213
	case -int32(3):
		codeStr = __ccgo_ts + 70220
	case -int32(4):
		codeStr = __ccgo_ts + 70225
	case -int32(5):
		codeStr = __ccgo_ts + 70229
	case -int32(6):
		codeStr = __ccgo_ts + 58248
	case int32(Z_NEED_DICT):
		codeStr = __ccgo_ts + 70233
		codeStr2 = bp
		libc.X__builtin_snprintf(tls, bp, uint64(24), __ccgo_ts+70243, libc.VaList(bp+32, adler))
		break
		/*
		 * These should _not_ happen! This function is for dealing with error
		 * cases, not non-errors!
		 */
		fallthrough
	case Z_OK:
		XTcl_Panic(tls, __ccgo_ts+70247, 0)
		fallthrough
	case int32(Z_STREAM_END):
		XTcl_Panic(tls, __ccgo_ts+70293, 0)
		/*
		 * Anything else is bad news; it's unexpected. Convert to generic
		 * error.
		 */
		fallthrough
	default:
		codeStr = __ccgo_ts + 2095
		codeStr2 = bp
		libc.X__builtin_snprintf(tls, bp, uint64(24), __ccgo_ts+260, libc.VaList(bp+32, code))
		break
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, libz.XzError(tls, code), int64(-libc.Int32FromInt32(1))))
	/*
	 * Tricky point! We might pass NULL twice here (and will when the error
	 * type is known).
	 */
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+32, __ccgo_ts+2004, __ccgo_ts+70347, codeStr, codeStr2, libc.UintptrFromInt32(0)))
}

func _ConvertErrorToList(tls *libc.TLS, code int32, adler TuLong) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* The checksum expected (for Z_NEED_DICT) */
	var cachePtr, cachePtr1, cachePtr10, cachePtr11, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cachePtr8, cachePtr9 uintptr
	var v1, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26 bool
	var _ /* objv at bp+0 */ [4]uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr10, cachePtr11, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cachePtr8, cachePtr9, v1, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[0] = XTclThreadAllocObj(tls)
	} else {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[0] = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[0] + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[0])).FrefCount = 0
	if libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[0])).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[0])).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[0])).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[0])).Fbytes, __ccgo_ts+2004, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[0])).Fbytes + uintptr(libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[0])).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(4) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[0])).FtypePtr = libc.UintptrFromInt32(0)
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(1)] = XTclThreadAllocObj(tls)
	} else {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(1)] = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(1)] + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(1)])).FrefCount = 0
	if libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(1)])).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(1)])).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(1)])).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(1)])).Fbytes, __ccgo_ts+70347, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(1)])).Fbytes + uintptr(libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(1)])).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(5) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(1)])).FtypePtr = libc.UintptrFromInt32(0)
	switch code {
	case -int32(2):
		goto _3
	case -int32(3):
		goto _4
	case -int32(4):
		goto _5
	case -int32(5):
		goto _6
	case -int32(6):
		goto _7
	case -int32(1):
		goto _8
	case int32(Z_NEED_DICT):
		goto _9
	case Z_OK:
		goto _10
	case int32(Z_STREAM_END):
		goto _11
	default:
		goto _12
	}
	goto _13
_3:
	;
_16:
	;
	if v17 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v17 {
		cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v17 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)] = XTclThreadAllocObj(tls)
	} else {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)] = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)] + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).FrefCount = 0
	if libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes, __ccgo_ts+70213, libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes + uintptr(libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(7) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).FtypePtr = libc.UintptrFromInt32(0)
	goto _15
_15:
	;
	if 0 != 0 {
		goto _16
	}
	goto _14
_14:
	;
	return XTcl_NewListObj(tls, int64(3), bp)
_4:
	;
	if v18 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v18 {
		cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v18 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)] = XTclThreadAllocObj(tls)
	} else {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)] = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)] + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).FrefCount = 0
	if libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes, __ccgo_ts+70220, libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes + uintptr(libc.Uint64FromInt64(5)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(5) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).FtypePtr = libc.UintptrFromInt32(0)
	return XTcl_NewListObj(tls, int64(3), bp)
_5:
	;
	if v19 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v19 {
		cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v19 || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == libc.Uint64FromInt32(0) {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)] = XTclThreadAllocObj(tls)
	} else {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)] = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)] + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).FrefCount = 0
	if libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes, __ccgo_ts+70225, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes + uintptr(libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(4) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).FtypePtr = libc.UintptrFromInt32(0)
	return XTcl_NewListObj(tls, int64(3), bp)
_6:
	;
	if v20 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v20 {
		cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v20 || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == libc.Uint64FromInt32(0) {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)] = XTclThreadAllocObj(tls)
	} else {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)] = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)] + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).FrefCount = 0
	if libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes, __ccgo_ts+70229, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes + uintptr(libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(4) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).FtypePtr = libc.UintptrFromInt32(0)
	return XTcl_NewListObj(tls, int64(3), bp)
_7:
	;
	if v21 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v21 {
		cachePtr6 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v21 || (*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects == libc.Uint64FromInt32(0) {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)] = XTclThreadAllocObj(tls)
	} else {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)] = (*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)] + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).FrefCount = 0
	if libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes, __ccgo_ts+58248, libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes + uintptr(libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(8) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).FtypePtr = libc.UintptrFromInt32(0)
	return XTcl_NewListObj(tls, int64(3), bp)
_8:
	;
	if v22 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v22 {
		cachePtr7 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v22 || (*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects == libc.Uint64FromInt32(0) {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)] = XTclThreadAllocObj(tls)
	} else {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)] = (*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)] + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).FrefCount = 0
	if libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes, __ccgo_ts+49678, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes + uintptr(libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(6) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).FtypePtr = libc.UintptrFromInt32(0)
	(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(3)] = XTcl_NewStringObj(tls, XTcl_ErrnoId(tls), int64(-libc.Int32FromInt32(1)))
	return XTcl_NewListObj(tls, int64(4), bp)
_9:
	;
	if v23 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v23 {
		cachePtr8 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v23 || (*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects == libc.Uint64FromInt32(0) {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)] = XTclThreadAllocObj(tls)
	} else {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)] = (*TAllocCache)(unsafe.Pointer(cachePtr8)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr8)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)] + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).FrefCount = 0
	if libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes, __ccgo_ts+70233, libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes + uintptr(libc.Uint64FromInt64(10)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(10) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).FtypePtr = libc.UintptrFromInt32(0)
	if v24 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v24 {
		cachePtr9 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v24 || (*TAllocCache)(unsafe.Pointer(cachePtr9)).FnumObjects == libc.Uint64FromInt32(0) {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(3)] = XTclThreadAllocObj(tls)
	} else {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(3)] = (*TAllocCache)(unsafe.Pointer(cachePtr9)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr9)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(3)] + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr9)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(3)])).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(3)])).Fbytes = libc.UintptrFromInt32(0)
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(3)])).FinternalRep)) = libc.Int64FromUint64(adler)
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(3)])).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	return XTcl_NewListObj(tls, int64(4), bp)
	/*
	 * These should _not_ happen! This function is for dealing with error
	 * cases, not non-errors!
	 */
_10:
	;
	XTcl_Panic(tls, __ccgo_ts+70247, 0)
_11:
	;
	XTcl_Panic(tls, __ccgo_ts+70293, 0)
	/*
	 * Catch-all. Should be unreachable because all cases are already
	 * listed above.
	 */
_12:
	;
	if v25 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v25 {
		cachePtr10 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v25 || (*TAllocCache)(unsafe.Pointer(cachePtr10)).FnumObjects == libc.Uint64FromInt32(0) {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)] = XTclThreadAllocObj(tls)
	} else {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)] = (*TAllocCache)(unsafe.Pointer(cachePtr10)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr10)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)] + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr10)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).FrefCount = 0
	if libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes, __ccgo_ts+2095, libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Fbytes + uintptr(libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(8) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)])).FtypePtr = libc.UintptrFromInt32(0)
	if v26 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v26 {
		cachePtr11 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v26 || (*TAllocCache)(unsafe.Pointer(cachePtr11)).FnumObjects == libc.Uint64FromInt32(0) {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(3)] = XTclThreadAllocObj(tls)
	} else {
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(3)] = (*TAllocCache)(unsafe.Pointer(cachePtr11)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr11)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(3)] + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr11)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(3)])).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(3)])).Fbytes = libc.UintptrFromInt32(0)
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(3)])).FinternalRep)) = int64(code)
	(*TTcl_Obj)(unsafe.Pointer((*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(3)])).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	return XTcl_NewListObj(tls, int64(4), bp)
_13:
	;
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * GenerateHeader --
 *
 *	Function for creating a gzip header from the contents of a dictionary
 *	(as described in the documentation).
 *
 * Results:
 *	A Tcl result code.
 *
 * Side effects:
 *	Updates the fields of the given gz_header structure. Adds amount of
 *	extra space required for the header to the variable referenced by the
 *	extraSizePtr argument.
 *
 *----------------------------------------------------------------------
 */

func _GenerateHeader(tls *libc.TLS, interp uintptr, dictObj uintptr, headerPtr uintptr, extraSizePtr uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* Variable to add the length of header
	 * strings (filename, comment) to. */
	var latin1enc TTcl_Encoding
	var result, v3 int32
	var valueStr, v1, v2 uintptr
	var v4 bool
	var _ /* len at bp+8 */ int32
	var _ /* length at bp+16 */ TTcl_Size
	var _ /* state at bp+32 */ TTcl_EncodingState
	var _ /* state at bp+40 */ TTcl_EncodingState
	var _ /* value at bp+0 */ uintptr
	var _ /* wideValue at bp+24 */ TTcl_WideInt
	_, _, _, _, _, _, _ = latin1enc, result, valueStr, v1, v2, v3, v4
	result = int32(TCL_ERROR)
	*(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) = 0
	latin1enc = _Latin1(tls)
	if XTclDictGet(tls, interp, dictObj, __ccgo_ts+70357, bp) != TCL_OK {
		goto error
	} else {
		if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Flength
				v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes
			} else {
				v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+16)
			}
			valueStr = v1
			result = XTcl_UtfToExternal(tls, libc.UintptrFromInt32(0), latin1enc, valueStr, *(*TTcl_Size)(unsafe.Pointer(bp + 16)), libc.Int32FromInt32(TCL_ENCODING_START)|libc.Int32FromInt32(TCL_ENCODING_END)|libc.Int32FromInt32(TCL_ENCODING_STOPONERROR), bp+32, headerPtr+4176, int64(libc.Int32FromInt32(MAX_COMMENT_LEN)-libc.Int32FromInt32(1)), libc.UintptrFromInt32(0), bp+8, libc.UintptrFromInt32(0))
			if result != TCL_OK {
				if interp != 0 {
					if result == -int32(3) {
						XTcl_AppendResult(tls, interp, libc.VaList(bp+56, __ccgo_ts+70365, libc.UintptrFromInt32(0)))
					} else {
						XTcl_AppendResult(tls, interp, libc.VaList(bp+56, __ccgo_ts+70400, libc.UintptrFromInt32(0)))
					}
				}
				result = int32(TCL_ERROR) /* TCL_CONVERT_* -> TCL_ERROR */
				goto error
			}
			*(*uint8)(unsafe.Pointer(headerPtr + 4176 + uintptr(*(*int32)(unsafe.Pointer(bp + 8))))) = uint8('\000')
			(*TGzipHeader)(unsafe.Pointer(headerPtr)).Fheader.Fcomment = headerPtr + 4176
			if extraSizePtr != libc.UintptrFromInt32(0) {
				*(*int32)(unsafe.Pointer(extraSizePtr)) += *(*int32)(unsafe.Pointer(bp + 8))
			}
		}
	}
	if XTclDictGet(tls, interp, dictObj, __ccgo_ts+70426, bp) != TCL_OK {
		goto error
	} else {
		if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) && XTcl_GetBoolFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), (libc.Int32FromInt32(TCL_NULL_OK)-libc.Int32FromInt32(2))&libc.Int32FromInt64(4), headerPtr+68) != 0 {
			goto error
		}
	}
	if XTclDictGet(tls, interp, dictObj, __ccgo_ts+70430, bp) != TCL_OK {
		goto error
	} else {
		if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Flength
				v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp)), bp+16)
			}
			valueStr = v2
			result = XTcl_UtfToExternal(tls, libc.UintptrFromInt32(0), latin1enc, valueStr, *(*TTcl_Size)(unsafe.Pointer(bp + 16)), libc.Int32FromInt32(TCL_ENCODING_START)|libc.Int32FromInt32(TCL_ENCODING_END)|libc.Int32FromInt32(TCL_ENCODING_STOPONERROR), bp+40, headerPtr+80, int64(libc.Int32FromInt32(MAXPATHLEN)-libc.Int32FromInt32(1)), libc.UintptrFromInt32(0), bp+8, libc.UintptrFromInt32(0))
			if result != TCL_OK {
				if interp != 0 {
					if result == -int32(3) {
						XTcl_AppendResult(tls, interp, libc.VaList(bp+56, __ccgo_ts+70439, libc.UintptrFromInt32(0)))
					} else {
						XTcl_AppendResult(tls, interp, libc.VaList(bp+56, __ccgo_ts+70475, libc.UintptrFromInt32(0)))
					}
				}
				result = int32(TCL_ERROR) /* TCL_CONVERT_* -> TCL_ERROR */
				goto error
			}
			*(*uint8)(unsafe.Pointer(headerPtr + 80 + uintptr(*(*int32)(unsafe.Pointer(bp + 8))))) = uint8('\000')
			(*TGzipHeader)(unsafe.Pointer(headerPtr)).Fheader.Fname = headerPtr + 80
			if extraSizePtr != libc.UintptrFromInt32(0) {
				*(*int32)(unsafe.Pointer(extraSizePtr)) += *(*int32)(unsafe.Pointer(bp + 8))
			}
		}
	}
	if XTclDictGet(tls, interp, dictObj, __ccgo_ts+42248, bp) != TCL_OK {
		goto error
	} else {
		if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) && XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), headerPtr+20) != TCL_OK {
			goto error
		}
	}
	/*
	 * Ignore the 'size' field, since that is controlled by the size of the
	 * input data.
	 */
	if XTclDictGet(tls, interp, dictObj, __ccgo_ts+5581, bp) != TCL_OK {
		goto error
	} else {
		if v4 = *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0); v4 {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
				*(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FinternalRep))
				v3 = libc.Int32FromInt32(TCL_OK)
			} else {
				v3 = XTcl_GetWideIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), bp+24)
			}
		}
		if v4 && v3 != TCL_OK {
			goto error
		}
	}
	(*TGzipHeader)(unsafe.Pointer(headerPtr)).Fheader.Ftime = libc.Uint64FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 24)))
	if XTclDictGet(tls, interp, dictObj, __ccgo_ts+5851, bp) != TCL_OK {
		goto error
	} else {
		if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) && XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), uintptr(unsafe.Pointer(&_types1)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+5851, libc.Int32FromInt32(TCL_EXACT)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), headerPtr) != TCL_OK {
			goto error
		}
	}
	result = TCL_OK
	goto error
error:
	;
	XTcl_FreeEncoding(tls, latin1enc)
	return result
}

var _types1 = [2]uintptr{
	0: __ccgo_ts + 10664,
	1: __ccgo_ts + 70352,
}

/*
 *----------------------------------------------------------------------
 *
 * ExtractHeader --
 *
 *	Take the values out of a gzip header and store them in a dictionary.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Updates the dictionary, which must be writable (i.e. refCount < 2).
 *
 *----------------------------------------------------------------------
 */

func _ExtractHeader(tls *libc.TLS, headerPtr uintptr, dictObj uintptr) {
	bp := tls.Alloc(224)
	defer tls.Free(224) /* The dictionary to store in. */
	var latin1enc TTcl_Encoding
	var v1 uintptr
	var _ /* tmp at bp+0 */ TTcl_DString
	_, _ = latin1enc, v1
	latin1enc = libc.UintptrFromInt32(0)
	if (*Tgz_header)(unsafe.Pointer(headerPtr)).Fcomment != uintptr(Z_NULL) {
		latin1enc = _Latin1(tls)
		XTcl_ExternalToUtfDString(tls, latin1enc, (*Tgz_header)(unsafe.Pointer(headerPtr)).Fcomment, int64(-libc.Int32FromInt32(1)), bp)
		XTclDictPut(tls, libc.UintptrFromInt32(0), dictObj, __ccgo_ts+70357, XTcl_DStringToObj(tls, bp))
	}
	XTclDictPut(tls, libc.UintptrFromInt32(0), dictObj, __ccgo_ts+70426, XTcl_NewWideIntObj(tls, libc.BoolInt64((*Tgz_header)(unsafe.Pointer(headerPtr)).Fhcrc != 0)))
	if (*Tgz_header)(unsafe.Pointer(headerPtr)).Fname != uintptr(Z_NULL) {
		if latin1enc == libc.UintptrFromInt32(0) {
			latin1enc = _Latin1(tls)
		}
		XTcl_ExternalToUtfDString(tls, latin1enc, (*Tgz_header)(unsafe.Pointer(headerPtr)).Fname, int64(-libc.Int32FromInt32(1)), bp)
		XTclDictPut(tls, libc.UintptrFromInt32(0), dictObj, __ccgo_ts+70430, XTcl_DStringToObj(tls, bp))
	}
	if (*Tgz_header)(unsafe.Pointer(headerPtr)).Fos != int32(255) {
		XTclDictPut(tls, libc.UintptrFromInt32(0), dictObj, __ccgo_ts+42248, XTcl_NewWideIntObj(tls, int64((*Tgz_header)(unsafe.Pointer(headerPtr)).Fos)))
	}
	if (*Tgz_header)(unsafe.Pointer(headerPtr)).Ftime != uint64(0) {
		XTclDictPut(tls, libc.UintptrFromInt32(0), dictObj, __ccgo_ts+5581, XTcl_NewWideIntObj(tls, libc.Int64FromUint64((*Tgz_header)(unsafe.Pointer(headerPtr)).Ftime)))
	}
	if (*Tgz_header)(unsafe.Pointer(headerPtr)).Ftext != int32(Z_UNKNOWN) {
		if (*Tgz_header)(unsafe.Pointer(headerPtr)).Ftext != 0 {
			v1 = __ccgo_ts + 70352
		} else {
			v1 = __ccgo_ts + 10664
		}
		XTclDictPutString(tls, libc.UintptrFromInt32(0), dictObj, __ccgo_ts+5851, v1)
	}
	if latin1enc != libc.UintptrFromInt32(0) {
		XTcl_FreeEncoding(tls, latin1enc)
	}
}

/*
 * Disentangle the worst of how the zlib API is used.
 */

func _SetInflateDictionary(tls *libc.TLS, strm Tz_streamp, compDictObj uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var bytes uintptr
	var _ /* length at bp+0 */ TTcl_Size
	_ = bytes
	if compDictObj != libc.UintptrFromInt32(0) {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
		bytes = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), compDictObj, bp)
		if bytes == libc.UintptrFromInt32(0) {
			return -int32(3)
		}
		return libz.XinflateSetDictionary(tls, strm, bytes, libc.Uint32FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))))
	}
	return Z_OK
}

func _SetDeflateDictionary(tls *libc.TLS, strm Tz_streamp, compDictObj uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var bytes uintptr
	var _ /* length at bp+0 */ TTcl_Size
	_ = bytes
	if compDictObj != libc.UintptrFromInt32(0) {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
		bytes = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), compDictObj, bp)
		if bytes == libc.UintptrFromInt32(0) {
			return -int32(3)
		}
		return libz.XdeflateSetDictionary(tls, strm, bytes, libc.Uint32FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))))
	}
	return Z_OK
}

func _Deflate(tls *libc.TLS, strm Tz_streamp, bufferPtr uintptr, bufferSize Tsize_t, flush int32, writtenPtr uintptr) (r int32) {
	var e int32
	_ = e
	(*Tz_stream)(unsafe.Pointer(strm)).Fnext_out = bufferPtr
	(*Tz_stream)(unsafe.Pointer(strm)).Favail_out = uint32(bufferSize)
	e = libz.Xdeflate(tls, strm, flush)
	if writtenPtr != libc.UintptrFromInt32(0) {
		*(*Tsize_t)(unsafe.Pointer(writtenPtr)) = bufferSize - uint64((*Tz_stream)(unsafe.Pointer(strm)).Favail_out)
	}
	return e
}

func _AppendByteArray(tls *libc.TLS, listObj uintptr, buffer uintptr, size Tsize_t) {
	var baObj uintptr
	_ = baObj
	if size > uint64(0) {
		baObj = XTcl_NewByteArrayObj(tls, buffer, libc.Int64FromUint64(size))
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listObj, baObj)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ZlibStreamInit --
 *
 *	This command initializes a (de)compression context/handle for
 *	(de)compressing data in chunks.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	The variable pointed to by zshandlePtr is initialised and memory
 *	allocated for internal state. Additionally, if interp is not null, a
 *	Tcl command is created and its name placed in the interp result obj.
 *
 * Note:
 *	At least one of interp and zshandlePtr should be non-NULL or the
 *	reference to the stream will be completely lost.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ZlibStreamInit(tls *libc.TLS, interp uintptr, mode int32, format int32, level int32, dictObj uintptr, zshandlePtr uintptr) (r int32) {
	bp := tls.Alloc(272)
	defer tls.Free(272)
	var _objPtr, gzHeaderPtr, zshPtr, v2 uintptr
	var e, wbits int32
	var v1 TTcl_Size
	var _ /* cmdname at bp+0 */ TTcl_DString
	_, _, _, _, _, _, _ = _objPtr, e, gzHeaderPtr, wbits, zshPtr, v1, v2
	wbits = 0
	zshPtr = libc.UintptrFromInt32(0)
	gzHeaderPtr = libc.UintptrFromInt32(0)
	switch mode {
	case int32(TCL_ZLIB_STREAM_DEFLATE):
		/*
		 * Compressed format is specified by the wbits parameter. See zlib.h
		 * for details.
		 */
		switch format {
		case int32(TCL_ZLIB_FORMAT_RAW):
			wbits = int32(WBITS_RAW)
		case int32(TCL_ZLIB_FORMAT_GZIP):
			wbits = int32(WBITS_GZIP)
			if dictObj != 0 {
				gzHeaderPtr = XTcl_Alloc(tls, uint64(4432))
				libc.Xmemset(tls, gzHeaderPtr, 0, uint64(4432))
				if _GenerateHeader(tls, interp, dictObj, gzHeaderPtr, libc.UintptrFromInt32(0)) != TCL_OK {
					XTclpFree(tls, gzHeaderPtr)
					return int32(TCL_ERROR)
				}
			}
		case int32(TCL_ZLIB_FORMAT_ZLIB):
			wbits = int32(WBITS_ZLIB)
		default:
			XTcl_Panic(tls, __ccgo_ts+70502, 0)
		}
		if level < -int32(1) || level > int32(9) {
			XTcl_Panic(tls, __ccgo_ts+70604, 0)
		}
	case int32(TCL_ZLIB_STREAM_INFLATE):
		/*
		 * wbits are the same as DEFLATE, but FORMAT_AUTO is valid too.
		 */
		switch format {
		case int32(TCL_ZLIB_FORMAT_RAW):
			wbits = int32(WBITS_RAW)
		case int32(TCL_ZLIB_FORMAT_GZIP):
			wbits = int32(WBITS_GZIP)
			gzHeaderPtr = XTcl_Alloc(tls, uint64(4432))
			libc.Xmemset(tls, gzHeaderPtr, 0, uint64(4432))
			(*TGzipHeader)(unsafe.Pointer(gzHeaderPtr)).Fheader.Fname = gzHeaderPtr + 80
			(*TGzipHeader)(unsafe.Pointer(gzHeaderPtr)).Fheader.Fname_max = libc.Uint32FromInt32(libc.Int32FromInt32(MAXPATHLEN) - libc.Int32FromInt32(1))
			(*TGzipHeader)(unsafe.Pointer(gzHeaderPtr)).Fheader.Fcomment = gzHeaderPtr + 4176
			(*TGzipHeader)(unsafe.Pointer(gzHeaderPtr)).Fheader.Fname_max = libc.Uint32FromInt32(libc.Int32FromInt32(MAX_COMMENT_LEN) - libc.Int32FromInt32(1))
		case int32(TCL_ZLIB_FORMAT_ZLIB):
			wbits = int32(WBITS_ZLIB)
		case int32(TCL_ZLIB_FORMAT_AUTO):
			wbits = int32(WBITS_AUTODETECT)
		default:
			XTcl_Panic(tls, __ccgo_ts+70720, 0)
		}
	default:
		XTcl_Panic(tls, __ccgo_ts+70844, 0)
	}
	zshPtr = XTcl_Alloc(tls, uint64(216))
	(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Finterp = interp
	(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fmode = mode
	(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fformat = format
	(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Flevel = level
	(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fwbits = wbits
	(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcurrentInput = libc.UintptrFromInt32(0)
	(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FstreamEnd = 0
	(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcompDictObj = libc.UintptrFromInt32(0)
	(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fflags = 0
	(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FgzHeaderPtr = gzHeaderPtr
	libc.Xmemset(tls, zshPtr+8, 0, uint64(112))
	(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fstream.Fadler = uint64(1)
	/*
	 * No output buffer available yet
	 */
	if mode == int32(TCL_ZLIB_STREAM_DEFLATE) {
		e = libz.XdeflateInit2_(tls, zshPtr+8, level, int32(Z_DEFLATED), wbits, int32(MAX_MEM_LEVEL), Z_DEFAULT_STRATEGY, __ccgo_ts+70913, libc.Int32FromInt64(112))
		if e == Z_OK && (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FgzHeaderPtr != 0 {
			e = libz.XdeflateSetHeader(tls, zshPtr+8, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FgzHeaderPtr)
		}
	} else {
		e = libz.XinflateInit2_(tls, zshPtr+8, wbits, __ccgo_ts+70913, libc.Int32FromInt64(112))
		if e == Z_OK && (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FgzHeaderPtr != 0 {
			e = libz.XinflateGetHeader(tls, zshPtr+8, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FgzHeaderPtr)
		}
	}
	if e != Z_OK {
		_ConvertError(tls, interp, e, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fstream.Fadler)
		goto error
	}
	/*
	 * I could do all this in C, but this is easier.
	 */
	if interp != libc.UintptrFromInt32(0) {
		if XTcl_EvalEx(tls, interp, __ccgo_ts+70919, int64(-libc.Int32FromInt32(1)), 0) != TCL_OK {
			goto error
		}
		XTcl_DStringInit(tls, bp)
		XTcl_DStringAppend(tls, bp, __ccgo_ts+70950, libc.Int64FromUint64(libc.Uint64FromInt64(24)-libc.Uint64FromInt32(1)))
		XTclDStringAppendObj(tls, bp, XTcl_GetObjResult(tls, interp))
		if XTcl_FindCommand(tls, interp, (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1, libc.UintptrFromInt32(0), 0) != libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+70974, int64(-libc.Int32FromInt32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+232, __ccgo_ts+2004, __ccgo_ts+26190, __ccgo_ts+71014, libc.UintptrFromInt32(0)))
			XTcl_DStringFree(tls, bp)
			goto error
		}
		XTcl_ResetResult(tls, interp)
		/*
		 * Create the command.
		 */
		(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fcmd = XTcl_CreateObjCommand(tls, interp, (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1, __ccgo_fp(_ZlibStreamCmd), zshPtr, __ccgo_fp(_ZlibStreamCmdDelete))
		XTcl_DStringFree(tls, bp)
		if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fcmd == libc.UintptrFromInt32(0) {
			goto error
		}
	} else {
		(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fcmd = libc.UintptrFromInt32(0)
	}
	/*
	 * Prepare the buffers for use.
	 */
	(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FinData = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
	(*TTcl_Obj)(unsafe.Pointer((*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FinData)).FrefCount++
	(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutData = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
	(*TTcl_Obj)(unsafe.Pointer((*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutData)).FrefCount++
	(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutPos = 0
	/*
	 * Now set the variable pointed to by *zshandlePtr to the pointer to the
	 * zsh struct.
	 */
	if zshandlePtr != 0 {
		*(*TTcl_ZlibStream)(unsafe.Pointer(zshandlePtr)) = zshPtr
	}
	return TCL_OK
	goto error
error:
	;
	if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcompDictObj != 0 {
		_objPtr = (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcompDictObj
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FgzHeaderPtr != 0 {
		XTclpFree(tls, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FgzHeaderPtr)
	}
	XTclpFree(tls, zshPtr)
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * ZlibStreamCmdDelete --
 *
 *	This is the delete command which Tcl invokes when a zlibstream command
 *	is deleted from the interpreter (on stream close, usually).
 *
 * Results:
 *	None
 *
 * Side effects:
 *	Invalidates the zlib stream handle as obtained from Tcl_ZlibStreamInit
 *
 *----------------------------------------------------------------------
 */

func _ZlibStreamCmdDelete(tls *libc.TLS, clientData uintptr) {
	var zshPtr uintptr
	_ = zshPtr
	zshPtr = clientData
	(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fcmd = libc.UintptrFromInt32(0)
	_ZlibStreamCleanup(tls, zshPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ZlibStreamClose --
 *
 *	This procedure must be called after (de)compression is done to ensure
 *	memory is freed and the command is deleted from the interpreter (if
 *	any).
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Invalidates the zlib stream handle as obtained from Tcl_ZlibStreamInit
 *
 *----------------------------------------------------------------------
 */

func XTcl_ZlibStreamClose(tls *libc.TLS, zshandle TTcl_ZlibStream) (r int32) {
	/* As obtained from Tcl_ZlibStreamInit. */
	var zshPtr uintptr
	_ = zshPtr
	zshPtr = zshandle
	/*
	 * If the interp is set, deleting the command will trigger
	 * ZlibStreamCleanup in ZlibStreamCmdDelete. If no interp is set, call
	 * ZlibStreamCleanup directly.
	 */
	if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Finterp != 0 && (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fcmd != 0 {
		XTcl_DeleteCommandFromToken(tls, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Finterp, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fcmd)
	} else {
		_ZlibStreamCleanup(tls, zshPtr)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * ZlibStreamCleanup --
 *
 *	This procedure is called by either Tcl_ZlibStreamClose or
 *	ZlibStreamCmdDelete to cleanup the stream context.
 *
 * Results:
 *	None
 *
 * Side effects:
 *	Invalidates the zlib stream handle.
 *
 *----------------------------------------------------------------------
 */

func _ZlibStreamCleanup(tls *libc.TLS, zshPtr uintptr) {
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, v2, v4, v6, v8 uintptr
	var v1, v3, v5, v7 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, v1, v2, v3, v4, v5, v6, v7, v8
	if !((*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FstreamEnd != 0) {
		if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fmode == int32(TCL_ZLIB_STREAM_DEFLATE) {
			libz.XdeflateEnd(tls, zshPtr+8)
		} else {
			libz.XinflateEnd(tls, zshPtr+8)
		}
	}
	if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FinData != 0 {
		_objPtr = (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FinData
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutData != 0 {
		_objPtr1 = (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutData
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
	if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcurrentInput != 0 {
		_objPtr2 = (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcurrentInput
		v6 = _objPtr2
		v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
		*(*TTcl_Size)(unsafe.Pointer(v6))--
		if v5 <= int64(1) {
			XTclFreeObj(tls, _objPtr2)
		}
	}
	if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcompDictObj != 0 {
		_objPtr3 = (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcompDictObj
		v8 = _objPtr3
		v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
		*(*TTcl_Size)(unsafe.Pointer(v8))--
		if v7 <= int64(1) {
			XTclFreeObj(tls, _objPtr3)
		}
	}
	if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FgzHeaderPtr != 0 {
		XTclpFree(tls, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FgzHeaderPtr)
	}
	XTclpFree(tls, zshPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ZlibStreamReset --
 *
 *	This procedure will reinitialize an existing stream handle.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Any data left in the (de)compression buffer is lost.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ZlibStreamReset(tls *libc.TLS, zshandle TTcl_ZlibStream) (r int32) {
	/* As obtained from Tcl_ZlibStreamInit */
	var _objPtr, zshPtr, v2 uintptr
	var e int32
	var v1 TTcl_Size
	_, _, _, _, _ = _objPtr, e, zshPtr, v1, v2
	zshPtr = zshandle
	if !((*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FstreamEnd != 0) {
		if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fmode == int32(TCL_ZLIB_STREAM_DEFLATE) {
			libz.XdeflateEnd(tls, zshPtr+8)
		} else {
			libz.XinflateEnd(tls, zshPtr+8)
		}
	}
	XTcl_SetByteArrayLength(tls, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FinData, 0)
	XTcl_SetByteArrayLength(tls, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutData, 0)
	if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcurrentInput != 0 {
		_objPtr = (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcurrentInput
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcurrentInput = libc.UintptrFromInt32(0)
	}
	(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutPos = 0
	(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FstreamEnd = 0
	libc.Xmemset(tls, zshPtr+8, 0, uint64(112))
	/*
	 * No output buffer available yet.
	 */
	if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fmode == int32(TCL_ZLIB_STREAM_DEFLATE) {
		e = libz.XdeflateInit2_(tls, zshPtr+8, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Flevel, int32(Z_DEFLATED), (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fwbits, int32(MAX_MEM_LEVEL), Z_DEFAULT_STRATEGY, __ccgo_ts+70913, libc.Int32FromInt64(112))
		if e == Z_OK && (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fflags&int32(DICT_TO_SET) != 0 {
			e = _SetDeflateDictionary(tls, zshPtr+8, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcompDictObj)
			if e == Z_OK {
				*(*int32)(unsafe.Pointer(zshPtr + 200)) |= ^int32(DICT_TO_SET)
			}
		}
	} else {
		e = libz.XinflateInit2_(tls, zshPtr+8, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fwbits, __ccgo_ts+70913, libc.Int32FromInt64(112))
		if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fformat == int32(TCL_ZLIB_FORMAT_RAW) && (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fflags&int32(DICT_TO_SET) != 0 && e == Z_OK {
			e = _SetInflateDictionary(tls, zshPtr+8, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcompDictObj)
			if e == Z_OK {
				*(*int32)(unsafe.Pointer(zshPtr + 200)) |= ^int32(DICT_TO_SET)
			}
		}
	}
	if e != Z_OK {
		_ConvertError(tls, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Finterp, e, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fstream.Fadler)
		/* TODO:cleanup */
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ZlibStreamGetCommandName --
 *
 *	This procedure will return the command name associated with the
 *	stream.
 *
 * Results:
 *	A Tcl_Obj with the name of the Tcl command or NULL if no command is
 *	associated with the stream.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ZlibStreamGetCommandName(tls *libc.TLS, zshandle TTcl_ZlibStream) (r uintptr) {
	/* As obtained from Tcl_ZlibStreamInit */
	var cachePtr, objPtr, zshPtr uintptr
	var v1 bool
	_, _, _, _ = cachePtr, objPtr, zshPtr, v1
	zshPtr = zshandle
	if !((*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Finterp != 0) {
		return libc.UintptrFromInt32(0)
	}
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	XTcl_GetCommandFullName(tls, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Finterp, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fcmd, objPtr)
	return objPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ZlibStreamEof --
 *
 *	This procedure This function returns 0 or 1 depending on the state of
 *	the (de)compressor. For decompression, eof is reached when the entire
 *	compressed stream has been decompressed. For compression, eof is
 *	reached when the stream has been flushed with TCL_ZLIB_FINALIZE.
 *
 * Results:
 *	Integer.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ZlibStreamEof(tls *libc.TLS, zshandle TTcl_ZlibStream) (r int32) {
	/* As obtained from Tcl_ZlibStreamInit */
	var zshPtr uintptr
	_ = zshPtr
	zshPtr = zshandle
	return (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FstreamEnd
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ZlibStreamChecksum --
 *
 *	Return the checksum of the uncompressed data seen so far by the
 *	stream.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ZlibStreamChecksum(tls *libc.TLS, zshandle TTcl_ZlibStream) (r int32) {
	/* As obtained from Tcl_ZlibStreamInit */
	var zshPtr uintptr
	_ = zshPtr
	zshPtr = zshandle
	return libc.Int32FromUint64((*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fstream.Fadler)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ZlibStreamSetCompressionDictionary --
 *
 *	Sets the compression dictionary for a stream. This will be used as
 *	appropriate for the next compression or decompression action performed
 *	on the stream.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ZlibStreamSetCompressionDictionary(tls *libc.TLS, zshandle TTcl_ZlibStream, compressionDictionaryObj uintptr) {
	var _objPtr, zshPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _ = _objPtr, zshPtr, v1, v2
	zshPtr = zshandle
	if compressionDictionaryObj != 0 && libc.UintptrFromInt32(0) == XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), compressionDictionaryObj, libc.UintptrFromInt32(0)) {
		/* Missing or invalid compression dictionary */
		compressionDictionaryObj = libc.UintptrFromInt32(0)
	}
	if compressionDictionaryObj != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(compressionDictionaryObj)).FrefCount > int64(1) {
			compressionDictionaryObj = XTcl_DuplicateObj(tls, compressionDictionaryObj)
		}
		(*TTcl_Obj)(unsafe.Pointer(compressionDictionaryObj)).FrefCount++
		*(*int32)(unsafe.Pointer(zshPtr + 200)) |= int32(DICT_TO_SET)
	} else {
		*(*int32)(unsafe.Pointer(zshPtr + 200)) &= ^int32(DICT_TO_SET)
	}
	if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcompDictObj != libc.UintptrFromInt32(0) {
		_objPtr = (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcompDictObj
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcompDictObj = compressionDictionaryObj
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ZlibStreamPut --
 *
 *	Add data to the stream for compression or decompression from a
 *	bytearray Tcl_Obj.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ZlibStreamPut(tls *libc.TLS, zshandle TTcl_ZlibStream, data uintptr, flush int32) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* TCL_ZLIB_NO_FLUSH, TCL_ZLIB_FLUSH,
	 * TCL_ZLIB_FULLFLUSH, or TCL_ZLIB_FINALIZE */
	var bytes, dataTmp, zshPtr uintptr
	var e int32
	var outSize Tsize_t
	var _ /* size at bp+0 */ TTcl_Size
	var _ /* toStore at bp+8 */ Tsize_t
	_, _, _, _, _ = bytes, dataTmp, e, outSize, zshPtr
	zshPtr = zshandle
	dataTmp = libc.UintptrFromInt32(0)
	*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FstreamEnd != 0 {
		if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Finterp != 0 {
			XTcl_SetObjResult(tls, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Finterp, XTcl_NewStringObj(tls, __ccgo_ts+71027, int64(-libc.Int32FromInt32(1))))
			XTcl_SetErrorCode(tls, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Finterp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+71062, __ccgo_ts+71066, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	bytes = XTcl_GetBytesFromObj(tls, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Finterp, data, bp)
	if bytes == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fmode == int32(TCL_ZLIB_STREAM_DEFLATE) {
		(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fstream.Fnext_in = bytes
		(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fstream.Favail_in = libc.Uint32FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))
		/*
		 * Must not do a zero-length compress unless finalizing. [Bug 25842c161]
		 */
		if *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 && flush != int32(Z_FINISH) {
			return TCL_OK
		}
		if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fflags&int32(DICT_TO_SET) != 0 {
			e = _SetDeflateDictionary(tls, zshPtr+8, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcompDictObj)
			if e != Z_OK {
				_ConvertError(tls, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Finterp, e, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fstream.Fadler)
				return int32(TCL_ERROR)
			}
			*(*int32)(unsafe.Pointer(zshPtr + 200)) |= ^int32(DICT_TO_SET)
		}
		/*
		 * deflateBound() doesn't seem to take various header sizes into
		 * account, so we add 100 extra bytes. However, we can also loop
		 * around again so we also set an upper bound on the output buffer
		 * size.
		 */
		outSize = libz.XdeflateBound(tls, zshPtr+8, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))) + uint64(100)
		if outSize > uint64(BUFFER_SIZE_LIMIT) {
			outSize = uint64(BUFFER_SIZE_LIMIT)
		}
		dataTmp = XTcl_Alloc(tls, outSize)
		for int32(1) != 0 {
			e = _Deflate(tls, zshPtr+8, dataTmp, outSize, flush, bp+8)
			/*
			 * Test if we've filled the buffer up and have to ask deflate() to
			 * give us some more. Note that the condition for needing to
			 * repeat a buffer transfer when the result is Z_OK is whether
			 * there is no more space in the buffer we provided; the zlib
			 * library does not necessarily return a different code in that
			 * case. [Bug b26e38a3e4] [Tk Bug 10f2e7872b]
			 */
			if e != -int32(5) && (e != Z_OK || *(*Tsize_t)(unsafe.Pointer(bp + 8)) < outSize) {
				if e == Z_OK || flush == int32(Z_FINISH) && e == int32(Z_STREAM_END) {
					break
				}
				_ConvertError(tls, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Finterp, e, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fstream.Fadler)
				return int32(TCL_ERROR)
			}
			/*
			 * Output buffer too small to hold the data being generated or we
			 * are doing the end-of-stream flush (which can spit out masses of
			 * data). This means we need to put a new buffer into place after
			 * saving the old generated data to the outData list.
			 */
			_AppendByteArray(tls, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutData, dataTmp, outSize)
			if outSize < uint64(BUFFER_SIZE_LIMIT) {
				outSize = uint64(BUFFER_SIZE_LIMIT)
				/* There may be *lots* of data left to output... */
				dataTmp = XTcl_Realloc(tls, dataTmp, outSize)
			}
		}
		/*
		 * And append the final data block to the outData list.
		 */
		_AppendByteArray(tls, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutData, dataTmp, *(*Tsize_t)(unsafe.Pointer(bp + 8)))
		XTclpFree(tls, dataTmp)
	} else {
		/*
		 * This is easy. Just append to the inData list.
		 */
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FinData, data)
		/*
		 * and we'll need the flush parameter for the Inflate call.
		 */
		(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fflush = flush
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ZlibStreamGet --
 *
 *	Retrieve data (now compressed or decompressed) from the stream into a
 *	bytearray Tcl_Obj.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ZlibStreamGet(tls *libc.TLS, zshandle TTcl_ZlibStream, data uintptr, count TTcl_Size) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* Number of bytes to grab as a maximum, you
	 * may get less! */
	var _objPtr, _objPtr1, _objPtr2, dataPtr, itemPtr, zshPtr, v10, v2, v8 uintptr
	var dataPos, i, len1, len11, v1, v7, v9 TTcl_Size
	var e, v14 int32
	var v12, v15, v4, v6 int64
	var v16 bool
	var _ /* existing at bp+24 */ TTcl_Size
	var _ /* itemLen at bp+8 */ TTcl_Size
	var _ /* itemObj at bp+16 */ uintptr
	var _ /* listLen at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, dataPos, dataPtr, e, i, itemPtr, len1, len11, zshPtr, v1, v10, v12, v14, v15, v16, v2, v4, v6, v7, v8, v9
	zshPtr = zshandle
	*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0
	dataPos = 0
	*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = 0
	/*
	 * Getting beyond the of stream, just return empty string.
	 */
	if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FstreamEnd != 0 {
		return TCL_OK
	}
	if libc.UintptrFromInt32(0) == XTcl_GetBytesFromObj(tls, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Finterp, data, bp+24) {
		return int32(TCL_ERROR)
	}
	if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fmode == int32(TCL_ZLIB_STREAM_INFLATE) {
		if count < 0 {
			/*
			 * The only safe thing to do is restict to 65k. We might cause a
			 * panic for out of memory if we just kept growing the buffer.
			 */
			count = int64(MAX_BUFFER_SIZE)
		}
		/*
		 * Prepare the place to store the data.
		 */
		dataPtr = XTcl_SetByteArrayLength(tls, data, *(*TTcl_Size)(unsafe.Pointer(bp + 24))+count)
		dataPtr += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 24)))
		(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fstream.Fnext_out = dataPtr
		(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fstream.Favail_out = libc.Uint32FromInt64(count)
		if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fstream.Favail_in == uint32(0) {
			/*
			 * zlib will probably need more data to decompress.
			 */
			if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcurrentInput != 0 {
				_objPtr = (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcurrentInput
				v2 = _objPtr
				v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
				*(*TTcl_Size)(unsafe.Pointer(v2))--
				if v1 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
				(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcurrentInput = libc.UintptrFromInt32(0)
			}
			if (*TTcl_Obj)(unsafe.Pointer((*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FinData)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
				if (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FinData + 32))).Fptr2 != 0 {
					v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer((*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FinData + 32))).Fptr2)).FspanLength
				} else {
					v4 = (*TListStore)(unsafe.Pointer((*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer((*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FinData + 32))).Fptr1)).FnumUsed
				}
				*(*TTcl_Size)(unsafe.Pointer(bp)) = v4
				_ = libc.Int32FromInt32(TCL_OK)
			} else {
				XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FinData, bp)
			}
			if *(*TTcl_Size)(unsafe.Pointer(bp)) > 0 {
				/*
				 * There is more input available, get it from the list and
				 * give it to zlib. At this point, the data must not be shared
				 * since we require the bytearray representation to not vanish
				 * under our feet. [Bug 3081008]
				 */
				XTcl_ListObjIndex(tls, libc.UintptrFromInt32(0), (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FinData, 0, bp+16)
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount > int64(1) {
					*(*uintptr)(unsafe.Pointer(bp + 16)) = XTcl_DuplicateObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
				}
				itemPtr = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 16)), bp+8)
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount++
				(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcurrentInput = *(*uintptr)(unsafe.Pointer(bp + 16))
				(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fstream.Fnext_in = itemPtr
				(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fstream.Favail_in = libc.Uint32FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
				/*
				 * And remove it from the list
				 */
				XTcl_ListObjReplace(tls, libc.UintptrFromInt32(0), (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FinData, 0, int64(1), 0, libc.UintptrFromInt32(0))
			}
		}
		/*
		 * When dealing with a raw stream, we set the dictionary here, once.
		 * (You can't do it in response to getting Z_NEED_DATA as raw streams
		 * don't ever issue that.)
		 */
		if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fformat == int32(TCL_ZLIB_FORMAT_RAW) && (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fflags&int32(DICT_TO_SET) != 0 {
			e = _SetInflateDictionary(tls, zshPtr+8, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcompDictObj)
			if e != Z_OK {
				_ConvertError(tls, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Finterp, e, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fstream.Fadler)
				return int32(TCL_ERROR)
			}
			*(*int32)(unsafe.Pointer(zshPtr + 200)) |= ^int32(DICT_TO_SET)
		}
		e = libz.Xinflate(tls, zshPtr+8, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fflush)
		if e == int32(Z_NEED_DICT) && (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fflags&int32(DICT_TO_SET) != 0 {
			e = _SetInflateDictionary(tls, zshPtr+8, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcompDictObj)
			if e == Z_OK {
				*(*int32)(unsafe.Pointer(zshPtr + 200)) |= ^int32(DICT_TO_SET)
				e = libz.Xinflate(tls, zshPtr+8, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fflush)
			}
		}
		if (*TTcl_Obj)(unsafe.Pointer((*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FinData)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer((*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FinData + 32))).Fptr2 != 0 {
				v6 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FinData + 32))).Fptr2)).FspanLength
			} else {
				v6 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FinData + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp)) = v6
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FinData, bp)
		}
		for (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fstream.Favail_out > uint32(0) && (e == Z_OK || e == -int32(5)) && *(*TTcl_Size)(unsafe.Pointer(bp)) > 0 {
			/*
			 * State: We have not satisfied the request yet and there may be
			 * more to inflate.
			 */
			if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fstream.Favail_in > uint32(0) {
				if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Finterp != 0 {
					XTcl_SetObjResult(tls, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Finterp, XTcl_NewStringObj(tls, __ccgo_ts+71073, int64(-libc.Int32FromInt32(1))))
					XTcl_SetErrorCode(tls, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Finterp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+71062, __ccgo_ts+71125, libc.UintptrFromInt32(0)))
				}
				XTcl_SetByteArrayLength(tls, data, *(*TTcl_Size)(unsafe.Pointer(bp + 24)))
				return int32(TCL_ERROR)
			}
			if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcurrentInput != 0 {
				_objPtr1 = (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcurrentInput
				v8 = _objPtr1
				v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
				*(*TTcl_Size)(unsafe.Pointer(v8))--
				if v7 <= int64(1) {
					XTclFreeObj(tls, _objPtr1)
				}
				(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcurrentInput = uintptr(0)
			}
			/*
			 * Get the next block of data to go to inflate. At this point, the
			 * data must not be shared since we require the bytearray
			 * representation to not vanish under our feet. [Bug 3081008]
			 */
			XTcl_ListObjIndex(tls, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Finterp, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FinData, 0, bp+16)
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount > int64(1) {
				*(*uintptr)(unsafe.Pointer(bp + 16)) = XTcl_DuplicateObj(tls, *(*uintptr)(unsafe.Pointer(bp + 16)))
			}
			itemPtr = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 16)), bp+8)
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FrefCount++
			(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcurrentInput = *(*uintptr)(unsafe.Pointer(bp + 16))
			(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fstream.Fnext_in = itemPtr
			(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fstream.Favail_in = libc.Uint32FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
			/*
			 * Remove it from the list.
			 */
			XTcl_ListObjReplace(tls, libc.UintptrFromInt32(0), (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FinData, 0, int64(1), 0, libc.UintptrFromInt32(0))
			*(*TTcl_Size)(unsafe.Pointer(bp))--
			/*
			 * And call inflate again.
			 */
			for cond := true; cond; cond = e == Z_OK {
				e = libz.Xinflate(tls, zshPtr+8, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fflush)
				if e != int32(Z_NEED_DICT) || !((*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fflags&int32(DICT_TO_SET) != 0) {
					break
				}
				e = _SetInflateDictionary(tls, zshPtr+8, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcompDictObj)
				*(*int32)(unsafe.Pointer(zshPtr + 200)) |= ^int32(DICT_TO_SET)
			}
		}
		if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fstream.Favail_out > uint32(0) {
			XTcl_SetByteArrayLength(tls, data, *(*TTcl_Size)(unsafe.Pointer(bp + 24))+count-libc.Int64FromUint32((*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fstream.Favail_out))
		}
		if !(e == Z_OK || e == int32(Z_STREAM_END) || e == -int32(5)) {
			XTcl_SetByteArrayLength(tls, data, *(*TTcl_Size)(unsafe.Pointer(bp + 24)))
			_ConvertError(tls, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Finterp, e, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fstream.Fadler)
			return int32(TCL_ERROR)
		}
		if e == int32(Z_STREAM_END) {
			(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FstreamEnd = int32(1)
			if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcurrentInput != 0 {
				_objPtr2 = (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcurrentInput
				v10 = _objPtr2
				v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
				*(*TTcl_Size)(unsafe.Pointer(v10))--
				if v9 <= int64(1) {
					XTclFreeObj(tls, _objPtr2)
				}
				(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FcurrentInput = uintptr(0)
			}
			libz.XinflateEnd(tls, zshPtr+8)
		}
	} else {
		if (*TTcl_Obj)(unsafe.Pointer((*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutData)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer((*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutData + 32))).Fptr2 != 0 {
				v12 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutData + 32))).Fptr2)).FspanLength
			} else {
				v12 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutData + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp)) = v12
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutData, bp)
		}
		if count < 0 {
			count = 0
			i = 0
			for {
				if !(i < *(*TTcl_Size)(unsafe.Pointer(bp))) {
					break
				}
				XTcl_ListObjIndex(tls, libc.UintptrFromInt32(0), (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutData, i, bp+16)
				XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 16)), bp+8)
				if i == 0 {
					count += *(*TTcl_Size)(unsafe.Pointer(bp + 8)) - (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutPos
				} else {
					count += *(*TTcl_Size)(unsafe.Pointer(bp + 8))
				}
				goto _13
			_13:
				;
				i++
			}
		}
		/*
		 * Prepare the place to store the data.
		 */
		dataPtr = XTcl_SetByteArrayLength(tls, data, *(*TTcl_Size)(unsafe.Pointer(bp + 24))+count)
		dataPtr += uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 24)))
		for {
			if v16 = count > dataPos; v16 {
				if (*TTcl_Obj)(unsafe.Pointer((*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutData)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
					if (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer((*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutData + 32))).Fptr2 != 0 {
						v15 = (*TListSpan)(unsafe.Pointer((*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer((*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutData + 32))).Fptr2)).FspanLength
					} else {
						v15 = (*TListStore)(unsafe.Pointer((*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer((*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutData + 32))).Fptr1)).FnumUsed
					}
					*(*TTcl_Size)(unsafe.Pointer(bp)) = v15
					v14 = libc.Int32FromInt32(TCL_OK)
				} else {
					v14 = XTcl_ListObjLength(tls, libc.UintptrFromInt32(0), (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutData, bp)
				}
			}
			if !(v16 && v14 == TCL_OK && *(*TTcl_Size)(unsafe.Pointer(bp)) > 0) {
				break
			}
			/*
			 * Get the next chunk off our list of chunks and grab the data out
			 * of it.
			 */
			XTcl_ListObjIndex(tls, libc.UintptrFromInt32(0), (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutData, 0, bp+16)
			itemPtr = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp + 16)), bp+8)
			if *(*TTcl_Size)(unsafe.Pointer(bp + 8))-(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutPos >= count-dataPos {
				len1 = count - dataPos
				libc.Xmemcpy(tls, dataPtr+uintptr(dataPos), itemPtr+uintptr((*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutPos), libc.Uint64FromInt64(len1))
				*(*TTcl_Size)(unsafe.Pointer(zshPtr + 152)) += len1
				dataPos += len1
				if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutPos == *(*TTcl_Size)(unsafe.Pointer(bp + 8)) {
					(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutPos = 0
				}
			} else {
				len11 = *(*TTcl_Size)(unsafe.Pointer(bp + 8)) - (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutPos
				libc.Xmemcpy(tls, dataPtr+uintptr(dataPos), itemPtr+uintptr((*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutPos), libc.Uint64FromInt64(len11))
				dataPos += len11
				(*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutPos = 0
			}
			if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutPos == 0 {
				XTcl_ListObjReplace(tls, libc.UintptrFromInt32(0), (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FoutData, 0, int64(1), 0, libc.UintptrFromInt32(0))
				*(*TTcl_Size)(unsafe.Pointer(bp))--
			}
		}
		XTcl_SetByteArrayLength(tls, data, *(*TTcl_Size)(unsafe.Pointer(bp + 24))+dataPos)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ZlibDeflate --
 *
 *	Compress the contents of Tcl_Obj *data with compression level in
 *	output format, producing the compressed data in the interpreter
 *	result.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ZlibDeflate(tls *libc.TLS, interp uintptr, format int32, data uintptr, level int32, gzipHeaderDictObj uintptr) (r int32) {
	bp := tls.Alloc(4560)
	defer tls.Free(4560)
	var cachePtr, cachePtr1, headerPtr, inData, obj, v3 uintptr
	var e, wbits int32
	var v1, v4 bool
	var v2 TTcl_Size
	var _ /* extraSize at bp+0 */ int32
	var _ /* header at bp+128 */ TGzipHeader
	var _ /* inLen at bp+8 */ TTcl_Size
	var _ /* stream at bp+16 */ Tz_stream
	_, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, e, headerPtr, inData, obj, wbits, v1, v2, v3, v4
	wbits = 0
	e = 0
	*(*int32)(unsafe.Pointer(bp)) = 0
	*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0
	inData = libc.UintptrFromInt32(0)
	headerPtr = libc.UintptrFromInt32(0)
	if !(interp != 0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Obtain the pointer to the byte array, we'll pass this pointer straight
	 * to the deflate command.
	 */
	inData = XTcl_GetBytesFromObj(tls, interp, data, bp+8)
	if inData == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Compressed format is specified by the wbits parameter. See zlib.h for
	 * details.
	 */
	if format == int32(TCL_ZLIB_FORMAT_RAW) {
		wbits = int32(WBITS_RAW)
	} else {
		if format == int32(TCL_ZLIB_FORMAT_GZIP) {
			wbits = int32(WBITS_GZIP)
			/*
			 * Need to allocate extra space for the gzip header and footer. The
			 * amount of space is (a bit less than) 32 bytes, plus a byte for each
			 * byte of string that we add. Note that over-allocation is not a
			 * problem. [Bug 2419061]
			 */
			*(*int32)(unsafe.Pointer(bp)) = int32(32)
			if gzipHeaderDictObj != 0 {
				headerPtr = bp + 128
				libc.Xmemset(tls, headerPtr, 0, uint64(80))
				if _GenerateHeader(tls, interp, gzipHeaderDictObj, bp+128, bp) != TCL_OK {
					return int32(TCL_ERROR)
				}
			}
		} else {
			if format == int32(TCL_ZLIB_FORMAT_ZLIB) {
				wbits = int32(WBITS_ZLIB)
			} else {
				XTcl_Panic(tls, __ccgo_ts+71131, 0)
			}
		}
	}
	if level < -int32(1) || level > int32(9) {
		XTcl_Panic(tls, __ccgo_ts+71234, 0)
	}
	/*
	 * Allocate some space to store the output.
	 */
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		obj = XTclThreadAllocObj(tls)
	} else {
		obj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(obj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(obj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(obj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr = libc.UintptrFromInt32(0)
	libc.Xmemset(tls, bp+16, 0, uint64(112))
	(*(*Tz_stream)(unsafe.Pointer(bp + 16))).Favail_in = libc.Uint32FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
	(*(*Tz_stream)(unsafe.Pointer(bp + 16))).Fnext_in = inData
	/*
	 * No output buffer available yet, will alloc after deflateInit2.
	 */
	e = libz.XdeflateInit2_(tls, bp+16, level, int32(Z_DEFLATED), wbits, int32(MAX_MEM_LEVEL), Z_DEFAULT_STRATEGY, __ccgo_ts+70913, libc.Int32FromInt64(112))
	if e != Z_OK {
		goto error
	}
	if headerPtr != libc.UintptrFromInt32(0) {
		e = libz.XdeflateSetHeader(tls, bp+16, headerPtr)
		if e != Z_OK {
			goto error
		}
	}
	/*
	 * Allocate the output buffer from the value of deflateBound(). This is
	 * probably too much space. Before returning to the caller, we will reduce
	 * it back to the actual compressed size.
	 */
	(*(*Tz_stream)(unsafe.Pointer(bp + 16))).Favail_out = uint32(libz.XdeflateBound(tls, bp+16, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))) + libc.Uint64FromInt32(*(*int32)(unsafe.Pointer(bp))))
	(*(*Tz_stream)(unsafe.Pointer(bp + 16))).Fnext_out = XTcl_SetByteArrayLength(tls, obj, libc.Int64FromUint32((*(*Tz_stream)(unsafe.Pointer(bp + 16))).Favail_out))
	/*
	 * Perform the compression, Z_FINISH means do it in one go.
	 */
	e = libz.Xdeflate(tls, bp+16, int32(Z_FINISH))
	if e != int32(Z_STREAM_END) {
		e = libz.XdeflateEnd(tls, bp+16)
		/*
		 * deflateEnd() returns Z_OK when there are bytes left to compress, at
		 * this point we consider that an error, although we could continue by
		 * allocating more memory and calling deflate() again.
		 */
		if e == Z_OK {
			e = -int32(5)
		}
	} else {
		e = libz.XdeflateEnd(tls, bp+16)
	}
	if e != Z_OK {
		goto error
	}
	/*
	 * Reduce the ByteArray length to the actual data length produced by
	 * deflate.
	 */
	XTcl_SetByteArrayLength(tls, obj, libc.Int64FromUint64((*(*Tz_stream)(unsafe.Pointer(bp + 16))).Ftotal_out))
	XTcl_SetObjResult(tls, interp, obj)
	return TCL_OK
	goto error
error:
	;
	_ConvertError(tls, interp, e, (*(*Tz_stream)(unsafe.Pointer(bp + 16))).Fadler)
	v3 = obj
	v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
	*(*TTcl_Size)(unsafe.Pointer(v3))--
	if !(v2 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(obj)).Flength = int64(-libc.Int32FromInt32(1))
			if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v4 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, obj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(obj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = obj
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, obj)
		}
	}
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ZlibInflate --
 *
 *	Decompress data in an object into the interpreter result.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ZlibInflate(tls *libc.TLS, interp uintptr, format int32, data uintptr, bufferSize TTcl_Size, gzipHeaderDictObj uintptr) (r int32) {
	bp := tls.Alloc(208)
	defer tls.Free(208)
	var cachePtr, cachePtr1, commentBuf, headerPtr, inData, nameBuf, newOutData, obj, outData, v4, p2 uintptr
	var e, wbits int32
	var newBufferSize, v3 TTcl_Size
	var v1, v5 bool
	var _ /* header at bp+120 */ Tgz_header
	var _ /* inLen at bp+0 */ TTcl_Size
	var _ /* stream at bp+8 */ Tz_stream
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, commentBuf, e, headerPtr, inData, nameBuf, newBufferSize, newOutData, obj, outData, wbits, v1, v3, v4, v5, p2
	wbits = 0
	e = 0
	*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	inData = libc.UintptrFromInt32(0)
	outData = libc.UintptrFromInt32(0)
	newOutData = libc.UintptrFromInt32(0)
	headerPtr = libc.UintptrFromInt32(0)
	nameBuf = libc.UintptrFromInt32(0)
	commentBuf = libc.UintptrFromInt32(0)
	if !(interp != 0) {
		return int32(TCL_ERROR)
	}
	inData = XTcl_GetBytesFromObj(tls, interp, data, bp)
	if inData == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Compressed format is specified by the wbits parameter. See zlib.h for
	 * details.
	 */
	switch format {
	case int32(TCL_ZLIB_FORMAT_RAW):
		wbits = int32(WBITS_RAW)
		gzipHeaderDictObj = libc.UintptrFromInt32(0)
	case int32(TCL_ZLIB_FORMAT_ZLIB):
		wbits = int32(WBITS_ZLIB)
		gzipHeaderDictObj = libc.UintptrFromInt32(0)
	case int32(TCL_ZLIB_FORMAT_GZIP):
		wbits = int32(WBITS_GZIP)
	case int32(TCL_ZLIB_FORMAT_AUTO):
		wbits = int32(WBITS_AUTODETECT)
	default:
		XTcl_Panic(tls, __ccgo_ts+70720, 0)
	}
	if gzipHeaderDictObj != 0 {
		headerPtr = bp + 120
		libc.Xmemset(tls, headerPtr, 0, uint64(80))
		nameBuf = XTcl_Alloc(tls, uint64(MAXPATHLEN))
		(*(*Tgz_header)(unsafe.Pointer(bp + 120))).Fname = nameBuf
		(*(*Tgz_header)(unsafe.Pointer(bp + 120))).Fname_max = libc.Uint32FromInt32(libc.Int32FromInt32(MAXPATHLEN) - libc.Int32FromInt32(1))
		commentBuf = XTcl_Alloc(tls, uint64(MAX_COMMENT_LEN))
		(*(*Tgz_header)(unsafe.Pointer(bp + 120))).Fcomment = commentBuf
		(*(*Tgz_header)(unsafe.Pointer(bp + 120))).Fcomm_max = libc.Uint32FromInt32(libc.Int32FromInt32(MAX_COMMENT_LEN) - libc.Int32FromInt32(1))
	}
	if bufferSize < int64(1) {
		/*
		 * Start with a buffer (up to) 3 times the size of the input data.
		 */
		if *(*TTcl_Size)(unsafe.Pointer(bp)) < int64(libc.Int32FromInt32(32)*libc.Int32FromInt32(1024)*libc.Int32FromInt32(1024)) {
			bufferSize = int64(3) * *(*TTcl_Size)(unsafe.Pointer(bp))
		} else {
			if *(*TTcl_Size)(unsafe.Pointer(bp)) < int64(libc.Int32FromInt32(256)*libc.Int32FromInt32(1024)*libc.Int32FromInt32(1024)) {
				bufferSize = int64(2) * *(*TTcl_Size)(unsafe.Pointer(bp))
			} else {
				bufferSize = *(*TTcl_Size)(unsafe.Pointer(bp))
			}
		}
	}
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		obj = XTclThreadAllocObj(tls)
	} else {
		obj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(obj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(obj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(obj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr = libc.UintptrFromInt32(0)
	outData = XTcl_SetByteArrayLength(tls, obj, bufferSize)
	libc.Xmemset(tls, bp+8, 0, uint64(112))
	(*(*Tz_stream)(unsafe.Pointer(bp + 8))).Favail_in = libc.Uint32FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)) + int64(1)) /* +1 because zlib can "over-request"
	 * input (but ignore it!) */
	(*(*Tz_stream)(unsafe.Pointer(bp + 8))).Fnext_in = inData
	(*(*Tz_stream)(unsafe.Pointer(bp + 8))).Favail_out = libc.Uint32FromInt64(bufferSize)
	(*(*Tz_stream)(unsafe.Pointer(bp + 8))).Fnext_out = outData
	/*
	 * Initialize zlib for decompression.
	 */
	e = libz.XinflateInit2_(tls, bp+8, wbits, __ccgo_ts+70913, libc.Int32FromInt64(112))
	if e != Z_OK {
		goto error
	}
	if headerPtr != 0 {
		e = libz.XinflateGetHeader(tls, bp+8, headerPtr)
		if e != Z_OK {
			libz.XinflateEnd(tls, bp+8)
			goto error
		}
	}
	/*
	 * Start the decompression cycle.
	 */
	for int32(1) != 0 {
		e = libz.Xinflate(tls, bp+8, int32(Z_FINISH))
		if e != -int32(5) {
			break
		}
		/*
		 * Not enough room in the output buffer. Increase it by five times the
		 * bytes still in the input buffer. (Because 3 times didn't do the
		 * trick before, 5 times is what we do next.) Further optimization
		 * should be done by the user, specify the decompressed size!
		 */
		if (*(*Tz_stream)(unsafe.Pointer(bp + 8))).Favail_in == uint32(0) && (*(*Tz_stream)(unsafe.Pointer(bp + 8))).Favail_out > uint32(0) {
			e = -int32(2)
			break
		}
		newBufferSize = bufferSize + libc.Int64FromUint32(uint32(5)*(*(*Tz_stream)(unsafe.Pointer(bp + 8))).Favail_in)
		if newBufferSize == bufferSize {
			newBufferSize = bufferSize + int64(1000)
		}
		newOutData = XTcl_SetByteArrayLength(tls, obj, newBufferSize)
		/*
		 * Set next out to the same offset in the new location.
		 */
		(*(*Tz_stream)(unsafe.Pointer(bp + 8))).Fnext_out = newOutData + uintptr((*(*Tz_stream)(unsafe.Pointer(bp + 8))).Ftotal_out)
		/*
		 * And increase avail_out with the number of new bytes allocated.
		 */
		p2 = bp + 8 + 32
		*(*TuInt)(unsafe.Pointer(p2)) = TuInt(int64(*(*TuInt)(unsafe.Pointer(p2))) + (newBufferSize - bufferSize))
		outData = newOutData
		bufferSize = newBufferSize
	}
	if e != int32(Z_STREAM_END) {
		libz.XinflateEnd(tls, bp+8)
		goto error
	}
	e = libz.XinflateEnd(tls, bp+8)
	if e != Z_OK {
		goto error
	}
	/*
	 * Reduce the BA length to the actual data length produced by deflate.
	 */
	XTcl_SetByteArrayLength(tls, obj, libc.Int64FromUint64((*(*Tz_stream)(unsafe.Pointer(bp + 8))).Ftotal_out))
	if headerPtr != libc.UintptrFromInt32(0) {
		_ExtractHeader(tls, bp+120, gzipHeaderDictObj)
		XTclDictPut(tls, libc.UintptrFromInt32(0), gzipHeaderDictObj, __ccgo_ts+5807, XTcl_NewWideIntObj(tls, libc.Int64FromUint64((*(*Tz_stream)(unsafe.Pointer(bp + 8))).Ftotal_out)))
		XTclpFree(tls, nameBuf)
		XTclpFree(tls, commentBuf)
	}
	XTcl_SetObjResult(tls, interp, obj)
	return TCL_OK
	goto error
error:
	;
	v4 = obj
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	if !(v3 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(obj)).Flength = int64(-libc.Int32FromInt32(1))
			if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v5 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, obj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(obj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = obj
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, obj)
		}
	}
	_ConvertError(tls, interp, e, (*(*Tz_stream)(unsafe.Pointer(bp + 8))).Fadler)
	if nameBuf != 0 {
		XTclpFree(tls, nameBuf)
	}
	if commentBuf != 0 {
		XTclpFree(tls, commentBuf)
	}
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ZlibCRC32, Tcl_ZlibAdler32 --
 *
 *	Access to the checksumming engines.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ZlibCRC32(tls *libc.TLS, crc uint32, buf uintptr, len1 TTcl_Size) (r uint32) {
	/* Nothing much to do, just wrap the crc32(). */
	return uint32(libz.Xcrc32(tls, uint64(crc), buf, libc.Uint32FromInt64(len1)))
}

func XTcl_ZlibAdler32(tls *libc.TLS, adler uint32, buf uintptr, len1 TTcl_Size) (r uint32) {
	return uint32(libz.Xadler32(tls, uint64(adler), buf, libc.Uint32FromInt64(len1)))
}

/*
 *----------------------------------------------------------------------
 *
 * ZlibCmd --
 *
 *	Implementation of the [zlib] command.
 *
 *	TODO: Convert this to an ensemble.
 *
 *----------------------------------------------------------------------
 */

func _ZlibCmd(tls *libc.TLS, dummy1970 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var buffersize Tsize_t
	var cachePtr, cachePtr1, data, extraInfoStr, headerDictObj, headerVarObj, v4, v9 uintptr
	var i, v2, v3, v6 int32
	var v10, v7 bool
	var v8 TTcl_Size
	var _ /* command at bp+32 */ int32
	var _ /* dlen at bp+8 */ TTcl_Size
	var _ /* level at bp+4 */ int32
	var _ /* option at bp+0 */ int32
	var _ /* start at bp+16 */ uint32
	var _ /* wideLen at bp+24 */ TTcl_WideInt
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = buffersize, cachePtr, cachePtr1, data, extraInfoStr, headerDictObj, headerVarObj, i, v10, v2, v3, v4, v6, v7, v8, v9
	*(*int32)(unsafe.Pointer(bp + 4)) = -int32(1)
	buffersize = uint64(0)
	*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0
	extraInfoStr = libc.UintptrFromInt32(0)
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+71417)
		return int32(TCL_ERROR)
	}
	if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), uintptr(unsafe.Pointer(&_commands)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+16416, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+32) != TCL_OK {
		return int32(TCL_ERROR)
	}
	switch *(*int32)(unsafe.Pointer(bp + 32)) {
	case 0: /* adler32 str ?startvalue?
		 *	-> checksum */
		if objc < int32(3) || objc > int32(4) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+71435)
			return int32(TCL_ERROR)
		}
		data = XTcl_GetBytesFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp+8)
		if data == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
		if objc > int32(3) && XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)), bp+16) != TCL_OK {
			return int32(TCL_ERROR)
		}
		if objc < int32(4) {
			*(*uint32)(unsafe.Pointer(bp + 16)) = XTcl_ZlibAdler32(tls, uint32(0), libc.UintptrFromInt32(0), 0)
		}
		XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.Int64FromUint32(XTcl_ZlibAdler32(tls, *(*uint32)(unsafe.Pointer(bp + 16)), data, *(*TTcl_Size)(unsafe.Pointer(bp + 8))))))
		return TCL_OK
	case 2: /* crc32 str ?startvalue?
		 *	-> checksum */
		if objc < int32(3) || objc > int32(4) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+71435)
			return int32(TCL_ERROR)
		}
		data = XTcl_GetBytesFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp+8)
		if data == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
		if objc > int32(3) && XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)), bp+16) != TCL_OK {
			return int32(TCL_ERROR)
		}
		if objc < int32(4) {
			*(*uint32)(unsafe.Pointer(bp + 16)) = XTcl_ZlibCRC32(tls, uint32(0), libc.UintptrFromInt32(0), 0)
		}
		XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.Int64FromUint32(XTcl_ZlibCRC32(tls, *(*uint32)(unsafe.Pointer(bp + 16)), data, *(*TTcl_Size)(unsafe.Pointer(bp + 8))))))
		return TCL_OK
	case 4: /* deflate data ?level?
		 *	-> rawCompressedData */
		if objc < int32(3) || objc > int32(4) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+71453)
			return int32(TCL_ERROR)
		}
		if objc > int32(3) {
			if XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)), bp+4) != TCL_OK {
				return int32(TCL_ERROR)
			}
			if *(*int32)(unsafe.Pointer(bp + 4)) < 0 || *(*int32)(unsafe.Pointer(bp + 4)) > int32(9) {
				goto badLevel
			}
		}
		return XTcl_ZlibDeflate(tls, interp, int32(TCL_ZLIB_FORMAT_RAW), *(*uintptr)(unsafe.Pointer(objv + 2*8)), *(*int32)(unsafe.Pointer(bp + 4)), libc.UintptrFromInt32(0))
	case 1: /* compress data ?level?
		 *	-> zlibCompressedData */
		if objc < int32(3) || objc > int32(4) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+71453)
			return int32(TCL_ERROR)
		}
		if objc > int32(3) {
			if XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)), bp+4) != TCL_OK {
				return int32(TCL_ERROR)
			}
			if *(*int32)(unsafe.Pointer(bp + 4)) < 0 || *(*int32)(unsafe.Pointer(bp + 4)) > int32(9) {
				goto badLevel
			}
		}
		return XTcl_ZlibDeflate(tls, interp, int32(TCL_ZLIB_FORMAT_ZLIB), *(*uintptr)(unsafe.Pointer(objv + 2*8)), *(*int32)(unsafe.Pointer(bp + 4)), libc.UintptrFromInt32(0))
	case 6: /* gzip data ?level?
		 *	-> gzippedCompressedData */
		headerDictObj = libc.UintptrFromInt32(0)
		/*
		 * Legacy argument format support.
		 */
		if objc == int32(4) && XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)), bp+4) == TCL_OK {
			if *(*int32)(unsafe.Pointer(bp + 4)) < 0 || *(*int32)(unsafe.Pointer(bp + 4)) > int32(9) {
				extraInfoStr = __ccgo_ts + 71466
				goto badLevel
			}
			return XTcl_ZlibDeflate(tls, interp, int32(TCL_ZLIB_FORMAT_GZIP), *(*uintptr)(unsafe.Pointer(objv + 2*8)), *(*int32)(unsafe.Pointer(bp + 4)), libc.UintptrFromInt32(0))
		}
		if objc < int32(3) || objc > int32(7) || objc&int32(1) == 0 {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+71490)
			return int32(TCL_ERROR)
		}
		i = int32(3)
		for {
			if !(i < objc) {
				break
			}
			if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_gzipopts)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
				return int32(TCL_ERROR)
			}
			switch *(*int32)(unsafe.Pointer(bp)) {
			case 0:
				headerDictObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8))
			case int32(1):
				if XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)), bp+4) != TCL_OK {
					return int32(TCL_ERROR)
				}
				if *(*int32)(unsafe.Pointer(bp + 4)) < 0 || *(*int32)(unsafe.Pointer(bp + 4)) > int32(9) {
					extraInfoStr = __ccgo_ts + 71466
					goto badLevel
				}
				break
			}
			goto _1
		_1:
			;
			i += int32(2)
		}
		return XTcl_ZlibDeflate(tls, interp, int32(TCL_ZLIB_FORMAT_GZIP), *(*uintptr)(unsafe.Pointer(objv + 2*8)), *(*int32)(unsafe.Pointer(bp + 4)), headerDictObj)
	case 7: /* inflate rawcomprdata ?bufferSize?
		 *	-> decompressedData */
		if objc < int32(3) || objc > int32(4) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+71535)
			return int32(TCL_ERROR)
		}
		if objc > int32(3) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
				*(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep))
				v2 = libc.Int32FromInt32(TCL_OK)
			} else {
				v2 = XTcl_GetWideIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)), bp+24)
			}
			if v2 != TCL_OK {
				return int32(TCL_ERROR)
			}
			if *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) < int64(MIN_NONSTREAM_BUFFER_SIZE) || *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) > int64(MAX_BUFFER_SIZE) {
				goto badBuffer
			}
			buffersize = libc.Uint64FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 24)))
		}
		return XTcl_ZlibInflate(tls, interp, int32(TCL_ZLIB_FORMAT_RAW), *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.Int64FromUint64(buffersize), libc.UintptrFromInt32(0))
	case 3: /* decompress zlibcomprdata ?bufferSize?
		 *	-> decompressedData */
		if objc < int32(3) || objc > int32(4) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+71535)
			return int32(TCL_ERROR)
		}
		if objc > int32(3) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
				*(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).FinternalRep))
				v3 = libc.Int32FromInt32(TCL_OK)
			} else {
				v3 = XTcl_GetWideIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)), bp+24)
			}
			if v3 != TCL_OK {
				return int32(TCL_ERROR)
			}
			if *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) < int64(MIN_NONSTREAM_BUFFER_SIZE) || *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) > int64(MAX_BUFFER_SIZE) {
				goto badBuffer
			}
			buffersize = libc.Uint64FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 24)))
		}
		return XTcl_ZlibInflate(tls, interp, int32(TCL_ZLIB_FORMAT_ZLIB), *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.Int64FromUint64(buffersize), libc.UintptrFromInt32(0))
	case 5:
		if objc < int32(3) || objc > int32(5) || objc&int32(1) == 0 {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+71553)
			return int32(TCL_ERROR)
		}
		v4 = libc.UintptrFromInt32(0)
		headerVarObj = v4
		headerDictObj = v4
		i = int32(3)
		for {
			if !(i < objc) {
				break
			}
			if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_gunzipopts)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
				return int32(TCL_ERROR)
			}
			switch *(*int32)(unsafe.Pointer(bp)) {
			case 0:
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)))).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
					*(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)))).FinternalRep))
					v6 = libc.Int32FromInt32(TCL_OK)
				} else {
					v6 = XTcl_GetWideIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8)), bp+24)
				}
				if v6 != TCL_OK {
					return int32(TCL_ERROR)
				}
				if *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) < int64(MIN_NONSTREAM_BUFFER_SIZE) || *(*TTcl_WideInt)(unsafe.Pointer(bp + 24)) > int64(MAX_BUFFER_SIZE) {
					goto badBuffer
				}
				buffersize = libc.Uint64FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp + 24)))
			case int32(1):
				headerVarObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8))
				if v7 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v7 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v7 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
					headerDictObj = XTclThreadAllocObj(tls)
				} else {
					headerDictObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(headerDictObj + 32))).Fptr1
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
				}
				(*TTcl_Obj)(unsafe.Pointer(headerDictObj)).FrefCount = 0
				(*TTcl_Obj)(unsafe.Pointer(headerDictObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(headerDictObj)).Flength = 0
				(*TTcl_Obj)(unsafe.Pointer(headerDictObj)).FtypePtr = libc.UintptrFromInt32(0)
				break
			}
			goto _5
		_5:
			;
			i += int32(2)
		}
		if XTcl_ZlibInflate(tls, interp, int32(TCL_ZLIB_FORMAT_GZIP), *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.Int64FromUint64(buffersize), headerDictObj) != TCL_OK {
			if headerDictObj != 0 {
				v9 = headerDictObj
				v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
				*(*TTcl_Size)(unsafe.Pointer(v9))--
				if !(v8 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(headerDictObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(headerDictObj)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(headerDictObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(headerDictObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(headerDictObj)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(headerDictObj)).Flength = int64(-libc.Int32FromInt32(1))
						if v10 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v10 {
							cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v10 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, headerDictObj)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(headerDictObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = headerDictObj
							(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, headerDictObj)
					}
				}
			}
			return int32(TCL_ERROR)
		}
		if headerVarObj != libc.UintptrFromInt32(0) && XTcl_ObjSetVar2(tls, interp, headerVarObj, libc.UintptrFromInt32(0), headerDictObj, int32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
		return TCL_OK
	case 9: /* stream deflate/inflate/...gunzip options...
		 *	-> handleCmd */
		return _ZlibStreamSubcmd(tls, interp, objc, objv)
	case 8: /* push mode channel options...
		 *	-> channel */
		return _ZlibPushSubcmd(tls, interp, objc, objv)
	}
	return int32(TCL_ERROR)
	goto badLevel
badLevel:
	;
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+71590, int64(-libc.Int32FromInt32(1))))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+48, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+71611, libc.UintptrFromInt32(0)))
	if extraInfoStr != 0 {
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, extraInfoStr, int64(-int32(1))))
	}
	return int32(TCL_ERROR)
	goto badBuffer
badBuffer:
	;
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+71628, libc.VaList(bp+48, int32(MIN_NONSTREAM_BUFFER_SIZE), int32(MAX_BUFFER_SIZE))))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+48, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+71657, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
}

var _commands = [11]uintptr{
	0:  __ccgo_ts + 71348,
	1:  __ccgo_ts + 71356,
	2:  __ccgo_ts + 71365,
	3:  __ccgo_ts + 71371,
	4:  __ccgo_ts + 71382,
	5:  __ccgo_ts + 71390,
	6:  __ccgo_ts + 71397,
	7:  __ccgo_ts + 71402,
	8:  __ccgo_ts + 2116,
	9:  __ccgo_ts + 71410,
	10: libc.UintptrFromInt32(0),
}

var _gzipopts = [3]uintptr{
	0: __ccgo_ts + 71527,
	1: __ccgo_ts + 30715,
	2: libc.UintptrFromInt32(0),
}

var _gunzipopts = [3]uintptr{
	0: __ccgo_ts + 44715,
	1: __ccgo_ts + 71579,
	2: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * ZlibStreamSubcmd --
 *
 *	Implementation of the [zlib stream] subcommand.
 *
 *----------------------------------------------------------------------
 */

func _ZlibStreamSubcmd(tls *libc.TLS, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var desc uintptr
	var format, i, mode int32
	var obj [3]uintptr
	var _ /* fmt at bp+0 */ int32
	var _ /* level at bp+8 */ int32
	var _ /* option at bp+4 */ int32
	var _ /* zh at bp+16 */ TTcl_ZlibStream
	_, _, _, _, _ = desc, format, i, mode, obj
	mode = 0
	obj = [3]uintptr{}
	desc = libc.UintptrFromInt32(0)
	if objc < int32(3) || !(objc&libc.Int32FromInt32(1) != 0) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+71668)
		return int32(TCL_ERROR)
	}
	if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), uintptr(unsafe.Pointer(&_stream_formats)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+15665, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * The format determines the compression mode and the options that may be
	 * specified.
	 */
	switch *(*int32)(unsafe.Pointer(bp)) {
	case 2:
		desc = uintptr(unsafe.Pointer(&_compressionOpts))
		mode = int32(TCL_ZLIB_STREAM_DEFLATE)
		format = int32(TCL_ZLIB_FORMAT_RAW)
	case 5:
		desc = uintptr(unsafe.Pointer(&_expansionOpts))
		mode = int32(TCL_ZLIB_STREAM_INFLATE)
		format = int32(TCL_ZLIB_FORMAT_RAW)
	case 0:
		desc = uintptr(unsafe.Pointer(&_compressionOpts))
		mode = int32(TCL_ZLIB_STREAM_DEFLATE)
		format = int32(TCL_ZLIB_FORMAT_ZLIB)
	case 1:
		desc = uintptr(unsafe.Pointer(&_expansionOpts))
		mode = int32(TCL_ZLIB_STREAM_INFLATE)
		format = int32(TCL_ZLIB_FORMAT_ZLIB)
	case 4:
		desc = uintptr(unsafe.Pointer(&_gzipOpts))
		mode = int32(TCL_ZLIB_STREAM_DEFLATE)
		format = int32(TCL_ZLIB_FORMAT_GZIP)
	case 3:
		desc = uintptr(unsafe.Pointer(&_gunzipOpts))
		mode = int32(TCL_ZLIB_STREAM_INFLATE)
		format = int32(TCL_ZLIB_FORMAT_GZIP)
	default:
		XTcl_Panic(tls, __ccgo_ts+71692, 0)
	}
	/*
	 * Parse the options.
	 */
	i = int32(3)
	for {
		if !(i < objc) {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), desc, libc.Int64FromUint64(libc.Uint64FromInt64(16)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+4) != TCL_OK {
			return int32(TCL_ERROR)
		}
		obj[(*(*struct {
			Fname   uintptr
			Foffset int32
		})(unsafe.Pointer(desc + uintptr(*(*int32)(unsafe.Pointer(bp + 4)))*16))).Foffset] = *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8))
		goto _1
	_1:
		;
		i += int32(2)
	}
	/*
	 * If a compression level was given, parse it (integral: 0..9). Otherwise
	 * use the default.
	 */
	if obj[2] == libc.UintptrFromInt32(0) {
		*(*int32)(unsafe.Pointer(bp + 8)) = -int32(1)
	} else {
		if XTcl_GetIntFromObj(tls, interp, obj[2], bp+8) != TCL_OK {
			return int32(TCL_ERROR)
		} else {
			if *(*int32)(unsafe.Pointer(bp + 8)) < 0 || *(*int32)(unsafe.Pointer(bp + 8)) > int32(9) {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+71590, int64(-libc.Int32FromInt32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+32, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+71611, libc.UintptrFromInt32(0)))
				XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+71466, int64(-int32(1))))
				return int32(TCL_ERROR)
			}
		}
	}
	if obj[0] != 0 {
		if libc.UintptrFromInt32(0) == XTcl_GetBytesFromObj(tls, interp, obj[0], libc.UintptrFromInt32(0)) {
			return int32(TCL_ERROR)
		}
	}
	/*
	 * Construct the stream now we know its configuration.
	 */
	if XTcl_ZlibStreamInit(tls, interp, mode, format, *(*int32)(unsafe.Pointer(bp + 8)), obj[1], bp+16) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if obj[0] != libc.UintptrFromInt32(0) {
		XTcl_ZlibStreamSetCompressionDictionary(tls, *(*TTcl_ZlibStream)(unsafe.Pointer(bp + 16)), obj[0])
	}
	XTcl_SetObjResult(tls, interp, XTcl_ZlibStreamGetCommandName(tls, *(*TTcl_ZlibStream)(unsafe.Pointer(bp + 16))))
	return TCL_OK
}

var _stream_formats = [7]uintptr{
	0: __ccgo_ts + 71356,
	1: __ccgo_ts + 71371,
	2: __ccgo_ts + 71382,
	3: __ccgo_ts + 71390,
	4: __ccgo_ts + 71397,
	5: __ccgo_ts + 71402,
	6: libc.UintptrFromInt32(0),
}

var _compressionOpts = [3]struct {
	Fname   uintptr
	Foffset int32
}{
	0: {
		Fname: __ccgo_ts + 17494,
	},
	1: {
		Fname:   __ccgo_ts + 30715,
		Foffset: 2,
	},
	2: {
		Foffset: -1,
	},
}

var _gzipOpts = [3]struct {
	Fname   uintptr
	Foffset int32
}{
	0: {
		Fname:   __ccgo_ts + 71527,
		Foffset: 1,
	},
	1: {
		Fname:   __ccgo_ts + 30715,
		Foffset: 2,
	},
	2: {
		Foffset: -1,
	},
}

var _expansionOpts = [2]struct {
	Fname   uintptr
	Foffset int32
}{
	0: {
		Fname: __ccgo_ts + 17494,
	},
	1: {
		Foffset: -1,
	},
}

var _gunzipOpts = [1]struct {
	Fname   uintptr
	Foffset int32
}{
	0: {
		Foffset: -1,
	},
}

/*
 *----------------------------------------------------------------------
 *
 * ZlibPushSubcmd --
 *
 *	Implementation of the [zlib push] subcommand.
 *
 *----------------------------------------------------------------------
 */

func _ZlibPushSubcmd(tls *libc.TLS, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var compDictObj, headerObj, pushOptions uintptr
	var format, i, mode, v2 int32
	var _ /* chan at bp+8 */ TTcl_Channel
	var _ /* chanMode at bp+16 */ int32
	var _ /* dummy at bp+32 */ TTcl_Size
	var _ /* fmt at bp+0 */ int32
	var _ /* level at bp+20 */ int32
	var _ /* limit at bp+28 */ int32
	var _ /* option at bp+24 */ int32
	_, _, _, _, _, _, _ = compDictObj, format, headerObj, i, mode, pushOptions, v2
	mode = 0
	pushOptions = uintptr(unsafe.Pointer(&_pushDecompressOptions))
	headerObj = libc.UintptrFromInt32(0)
	compDictObj = libc.UintptrFromInt32(0)
	*(*int32)(unsafe.Pointer(bp + 28)) = int32(DEFAULT_BUFFER_SIZE)
	if objc < int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+71721)
		return int32(TCL_ERROR)
	}
	if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), uintptr(unsafe.Pointer(&_stream_formats1)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+15665, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	switch *(*int32)(unsafe.Pointer(bp)) {
	case 2:
		mode = int32(TCL_ZLIB_STREAM_DEFLATE)
		format = int32(TCL_ZLIB_FORMAT_RAW)
		pushOptions = uintptr(unsafe.Pointer(&_pushCompressOptions))
	case 5:
		mode = int32(TCL_ZLIB_STREAM_INFLATE)
		format = int32(TCL_ZLIB_FORMAT_RAW)
	case 0:
		mode = int32(TCL_ZLIB_STREAM_DEFLATE)
		format = int32(TCL_ZLIB_FORMAT_ZLIB)
		pushOptions = uintptr(unsafe.Pointer(&_pushCompressOptions))
	case 1:
		mode = int32(TCL_ZLIB_STREAM_INFLATE)
		format = int32(TCL_ZLIB_FORMAT_ZLIB)
	case 4:
		mode = int32(TCL_ZLIB_STREAM_DEFLATE)
		format = int32(TCL_ZLIB_FORMAT_GZIP)
		pushOptions = uintptr(unsafe.Pointer(&_pushCompressOptions))
	case 3:
		mode = int32(TCL_ZLIB_STREAM_INFLATE)
		format = int32(TCL_ZLIB_FORMAT_GZIP)
	default:
		XTcl_Panic(tls, __ccgo_ts+71692, 0)
	}
	if XTclGetChannelFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)), bp+8, bp+16, 0) != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Sanity checks.
	 */
	if mode == int32(TCL_ZLIB_STREAM_DEFLATE) && !(*(*int32)(unsafe.Pointer(bp + 16))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+71747, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+48, __ccgo_ts+2004, __ccgo_ts+71062, __ccgo_ts+71800, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if mode == int32(TCL_ZLIB_STREAM_INFLATE) && !(*(*int32)(unsafe.Pointer(bp + 16))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+71811, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+48, __ccgo_ts+2004, __ccgo_ts+71062, __ccgo_ts+71866, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Parse options.
	 */
	*(*int32)(unsafe.Pointer(bp + 20)) = -int32(1)
	i = int32(4)
	for {
		if !(i < objc) {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), pushOptions, libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+24) != TCL_OK {
			return int32(TCL_ERROR)
		}
		i++
		v2 = i
		if v2 > objc-int32(1) {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+71877, libc.VaList(bp+48, *(*uintptr)(unsafe.Pointer(pushOptions + uintptr(*(*int32)(unsafe.Pointer(bp + 24)))*8)))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+48, __ccgo_ts+2004, __ccgo_ts+71062, __ccgo_ts+71905, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		switch *(*int32)(unsafe.Pointer(bp + 24)) {
		case 1: /* -header headerDict */
			headerObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
			if XTcl_DictObjSize(tls, interp, headerObj, bp+32) != TCL_OK {
				goto genericOptionError
			}
		case 2: /* -level compLevel */
			if XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp+20) != TCL_OK {
				goto genericOptionError
			}
			if *(*int32)(unsafe.Pointer(bp + 20)) < 0 || *(*int32)(unsafe.Pointer(bp + 20)) > int32(9) {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+71590, int64(-libc.Int32FromInt32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+48, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+71611, libc.UintptrFromInt32(0)))
				goto genericOptionError
			}
		case 3: /* -limit numBytes */
			if XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp+28) != TCL_OK {
				goto genericOptionError
			}
			if *(*int32)(unsafe.Pointer(bp + 28)) < int32(1) || *(*int32)(unsafe.Pointer(bp + 28)) > int32(MAX_BUFFER_SIZE) {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+71911, libc.VaList(bp+48, int32(MAX_BUFFER_SIZE))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+48, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+71657, libc.UintptrFromInt32(0)))
				goto genericOptionError
			}
		case 0: /* -dictionary compDict */
			if format == int32(TCL_ZLIB_FORMAT_GZIP) {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+71944, int64(-libc.Int32FromInt32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+48, __ccgo_ts+2004, __ccgo_ts+71062, __ccgo_ts+72003, libc.UintptrFromInt32(0)))
				goto genericOptionError
			}
			compDictObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
			break
		}
		goto _1
	_1:
		;
		i++
	}
	if compDictObj != 0 && libc.UintptrFromInt32(0) == XTcl_GetBytesFromObj(tls, interp, compDictObj, libc.UintptrFromInt32(0)) {
		return int32(TCL_ERROR)
	}
	if _ZlibStackChannelTransform(tls, interp, mode, format, *(*int32)(unsafe.Pointer(bp + 20)), *(*int32)(unsafe.Pointer(bp + 28)), *(*TTcl_Channel)(unsafe.Pointer(bp + 8)), headerObj, compDictObj) == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)))
	return TCL_OK
	goto genericOptionError
genericOptionError:
	;
	XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+72010, int64(-int32(1))))
	XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, *(*uintptr)(unsafe.Pointer(pushOptions + uintptr(*(*int32)(unsafe.Pointer(bp + 24)))*8)), int64(-int32(1))))
	XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+72020, int64(-int32(1))))
	return int32(TCL_ERROR)
}

var _stream_formats1 = [7]uintptr{
	0: __ccgo_ts + 71356,
	1: __ccgo_ts + 71371,
	2: __ccgo_ts + 71382,
	3: __ccgo_ts + 71390,
	4: __ccgo_ts + 71397,
	5: __ccgo_ts + 71402,
	6: libc.UintptrFromInt32(0),
}

var _pushCompressOptions = [4]uintptr{
	0: __ccgo_ts + 17494,
	1: __ccgo_ts + 71527,
	2: __ccgo_ts + 30715,
	3: libc.UintptrFromInt32(0),
}

var _pushDecompressOptions = [5]uintptr{
	0: __ccgo_ts + 17494,
	1: __ccgo_ts + 71527,
	2: __ccgo_ts + 30715,
	3: __ccgo_ts + 71714,
	4: libc.UintptrFromInt32(0),
}

/*
 *----------------------------------------------------------------------
 *
 * ZlibStreamCmd --
 *
 *	Implementation of the commands returned by [zlib stream].
 *
 *----------------------------------------------------------------------
 */

func _ZlibStreamCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, obj, v11, v15, v3, v7 uintptr
	var code int32
	var zstream TTcl_ZlibStream
	var v1, v12, v13, v16, v4, v5, v8, v9 bool
	var v10, v14, v2, v6 TTcl_Size
	var _ /* command at bp+4 */ int32
	var _ /* count at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, code, obj, zstream, v1, v10, v11, v12, v13, v14, v15, v16, v2, v3, v4, v5, v6, v7, v8, v9
	zstream = clientData
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+72065)
		return int32(TCL_ERROR)
	}
	if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), uintptr(unsafe.Pointer(&_cmds)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+4) != TCL_OK {
		return int32(TCL_ERROR)
	}
	switch *(*int32)(unsafe.Pointer(bp + 4)) {
	case 0: /* $strm add ?$flushopt? $data */
		return _ZlibStreamAddCmd(tls, zstream, interp, objc, objv)
	case 8: /* $strm header */
		return _ZlibStreamHeaderCmd(tls, zstream, interp, objc, objv)
	case 9: /* $strm put ?$flushopt? $data */
		return _ZlibStreamPutCmd(tls, zstream, interp, objc, objv)
	case 7: /* $strm get ?count? */
		if objc > int32(3) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+72083)
			return int32(TCL_ERROR)
		}
		*(*int32)(unsafe.Pointer(bp)) = -int32(1)
		if objc >= int32(3) {
			if XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp) != TCL_OK {
				return int32(TCL_ERROR)
			}
		}
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			obj = XTclThreadAllocObj(tls)
		} else {
			obj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(obj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(obj)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(obj)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr = libc.UintptrFromInt32(0)
		code = XTcl_ZlibStreamGet(tls, zstream, obj, int64(*(*int32)(unsafe.Pointer(bp))))
		if code == TCL_OK {
			XTcl_SetObjResult(tls, interp, obj)
		} else {
			v3 = obj
			v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
			*(*TTcl_Size)(unsafe.Pointer(v3))--
			if !(v2 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer(obj)).Flength = int64(-libc.Int32FromInt32(1))
					if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
						cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v4 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, obj)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer(obj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = obj
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, obj)
				}
			}
		}
		return code
	case 5: /* $strm flush */
		if objc != int32(2) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, libc.UintptrFromInt32(0))
			return int32(TCL_ERROR)
		}
		if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
			cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v5 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
			obj = XTclThreadAllocObj(tls)
		} else {
			obj = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(obj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(obj)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(obj)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr = libc.UintptrFromInt32(0)
		(*TTcl_Obj)(unsafe.Pointer(obj)).FrefCount++
		code = XTcl_ZlibStreamPut(tls, zstream, obj, int32(Z_SYNC_FLUSH))
		v7 = obj
		v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
		*(*TTcl_Size)(unsafe.Pointer(v7))--
		if !(v6 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(obj)).Flength = int64(-libc.Int32FromInt32(1))
				if v8 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v8 {
					cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v8 || ((*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, obj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(obj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = obj
					(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, obj)
			}
		}
		return code
	case 6: /* $strm fullflush */
		if objc != int32(2) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, libc.UintptrFromInt32(0))
			return int32(TCL_ERROR)
		}
		if v9 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v9 {
			cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v9 || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == libc.Uint64FromInt32(0) {
			obj = XTclThreadAllocObj(tls)
		} else {
			obj = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(obj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(obj)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(obj)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr = libc.UintptrFromInt32(0)
		(*TTcl_Obj)(unsafe.Pointer(obj)).FrefCount++
		code = XTcl_ZlibStreamPut(tls, zstream, obj, int32(Z_FULL_FLUSH))
		v11 = obj
		v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
		*(*TTcl_Size)(unsafe.Pointer(v11))--
		if !(v10 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(obj)).Flength = int64(-libc.Int32FromInt32(1))
				if v12 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v12 {
					cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v12 || ((*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, obj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(obj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = obj
					(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, obj)
			}
		}
		return code
	case 4: /* $strm finalize */
		if objc != int32(2) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, libc.UintptrFromInt32(0))
			return int32(TCL_ERROR)
		}
		/*
		 * The flush commands slightly abuse the empty result obj as input
		 * data.
		 */
		if v13 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v13 {
			cachePtr6 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v13 || (*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects == libc.Uint64FromInt32(0) {
			obj = XTclThreadAllocObj(tls)
		} else {
			obj = (*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(obj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(obj)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(obj)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr = libc.UintptrFromInt32(0)
		(*TTcl_Obj)(unsafe.Pointer(obj)).FrefCount++
		code = XTcl_ZlibStreamPut(tls, zstream, obj, int32(Z_FINISH))
		v15 = obj
		v14 = *(*TTcl_Size)(unsafe.Pointer(v15))
		*(*TTcl_Size)(unsafe.Pointer(v15))--
		if !(v14 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(obj)).Flength = int64(-libc.Int32FromInt32(1))
				if v16 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v16 {
					cachePtr7 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v16 || ((*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, obj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(obj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr = obj
					(*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, obj)
			}
		}
		return code
	case 2: /* $strm close */
		if objc != int32(2) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, libc.UintptrFromInt32(0))
			return int32(TCL_ERROR)
		}
		return XTcl_ZlibStreamClose(tls, zstream)
	case 3: /* $strm eof */
		if objc != int32(2) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, libc.UintptrFromInt32(0))
			return int32(TCL_ERROR)
		}
		XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(XTcl_ZlibStreamEof(tls, zstream) != 0)))
		return TCL_OK
	case 1: /* $strm checksum */
		if objc != int32(2) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, libc.UintptrFromInt32(0))
			return int32(TCL_ERROR)
		}
		XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.Int64FromUint32(libc.Uint32FromInt32(XTcl_ZlibStreamChecksum(tls, zstream)))))
		return TCL_OK
	case 10: /* $strm reset */
		if objc != int32(2) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, libc.UintptrFromInt32(0))
			return int32(TCL_ERROR)
		}
		return XTcl_ZlibStreamReset(tls, zstream)
	}
	return TCL_OK
}

var _cmds = [12]uintptr{
	0:  __ccgo_ts + 2121,
	1:  __ccgo_ts + 72029,
	2:  __ccgo_ts + 5462,
	3:  __ccgo_ts + 5468,
	4:  __ccgo_ts + 47133,
	5:  __ccgo_ts + 5518,
	6:  __ccgo_ts + 72038,
	7:  __ccgo_ts + 24987,
	8:  __ccgo_ts + 72048,
	9:  __ccgo_ts + 72055,
	10: __ccgo_ts + 72059,
	11: libc.UintptrFromInt32(0),
}

func _ZlibStreamAddCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var cachePtr, cachePtr1, compDictObj, obj, v6 uintptr
	var code, flush, i, v2, v3 int32
	var zstream TTcl_ZlibStream
	var v4, v7 bool
	var v5 TTcl_Size
	var _ /* buffersize at bp+0 */ int32
	var _ /* index at bp+4 */ int32
	var _ /* len at bp+8 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, code, compDictObj, flush, i, obj, zstream, v2, v3, v4, v5, v6, v7
	zstream = clientData
	*(*int32)(unsafe.Pointer(bp)) = -int32(1)
	flush = -int32(1)
	compDictObj = libc.UintptrFromInt32(0)
	i = int32(2)
	for {
		if !(i < objc-int32(1)) {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_add_options)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+4) != TCL_OK {
			return int32(TCL_ERROR)
		}
		switch *(*int32)(unsafe.Pointer(bp + 4)) {
		case 3: /* -flush */
			if flush >= 0 {
				flush = -int32(2)
			} else {
				flush = int32(Z_SYNC_FLUSH)
			}
		case 4: /* -fullflush */
			if flush >= 0 {
				flush = -int32(2)
			} else {
				flush = int32(Z_FULL_FLUSH)
			}
		case 2: /* -finalize */
			if flush >= 0 {
				flush = -int32(2)
			} else {
				flush = int32(Z_FINISH)
			}
		case 0: /* -buffer bufferSize */
			if i == objc-int32(2) {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+72127, int64(-libc.Int32FromInt32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+71062, __ccgo_ts+71905, libc.UintptrFromInt32(0)))
				return int32(TCL_ERROR)
			}
			i++
			v2 = i
			if XTcl_GetIntFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(v2)*8)), bp) != TCL_OK {
				return int32(TCL_ERROR)
			}
			if *(*int32)(unsafe.Pointer(bp)) < int32(1) || *(*int32)(unsafe.Pointer(bp)) > int32(MAX_BUFFER_SIZE) {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+72197, libc.VaList(bp+24, int32(MAX_BUFFER_SIZE))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+71657, libc.UintptrFromInt32(0)))
				return int32(TCL_ERROR)
			}
		case 1: /* -dictionary compDict */
			if i == objc-int32(2) {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+72225, int64(-libc.Int32FromInt32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+71062, __ccgo_ts+71905, libc.UintptrFromInt32(0)))
				return int32(TCL_ERROR)
			}
			i++
			v3 = i
			compDictObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(v3)*8))
			break
		}
		if flush == -int32(2) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+72295, int64(-libc.Int32FromInt32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+71062, __ccgo_ts+72365, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		goto _1
	_1:
		;
		i++
	}
	if flush == -int32(1) {
		flush = 0
	}
	/*
	 * Set the compression dictionary if requested.
	 */
	if compDictObj != libc.UintptrFromInt32(0) {
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0
		if libc.UintptrFromInt32(0) == XTcl_GetBytesFromObj(tls, interp, compDictObj, bp+8) {
			return int32(TCL_ERROR)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == 0 {
			compDictObj = libc.UintptrFromInt32(0)
		}
		XTcl_ZlibStreamSetCompressionDictionary(tls, zstream, compDictObj)
	}
	/*
	 * Send the data to the stream core, along with any flushing directive.
	 */
	if XTcl_ZlibStreamPut(tls, zstream, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), flush) != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Get such data out as we can (up to the requested length).
	 */
	if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		obj = XTclThreadAllocObj(tls)
	} else {
		obj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(obj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(obj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(obj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr = libc.UintptrFromInt32(0)
	code = XTcl_ZlibStreamGet(tls, zstream, obj, int64(*(*int32)(unsafe.Pointer(bp))))
	if code == TCL_OK {
		XTcl_SetObjResult(tls, interp, obj)
	} else {
		v6 = obj
		v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
		*(*TTcl_Size)(unsafe.Pointer(v6))--
		if !(v5 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(obj)).Flength = int64(-libc.Int32FromInt32(1))
				if v7 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v7 {
					cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v7 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, obj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(obj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = obj
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, obj)
			}
		}
	}
	return code
}

var _add_options = [6]uintptr{
	0: __ccgo_ts + 72091,
	1: __ccgo_ts + 17494,
	2: __ccgo_ts + 72099,
	3: __ccgo_ts + 72109,
	4: __ccgo_ts + 72116,
	5: libc.UintptrFromInt32(0),
}

func _ZlibStreamPutCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var compDictObj uintptr
	var flush, i, v2 int32
	var zstream TTcl_ZlibStream
	var _ /* index at bp+0 */ int32
	var _ /* len at bp+8 */ TTcl_Size
	_, _, _, _, _ = compDictObj, flush, i, zstream, v2
	zstream = clientData
	flush = -int32(1)
	compDictObj = libc.UintptrFromInt32(0)
	i = int32(2)
	for {
		if !(i < objc-int32(1)) {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_put_options)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
			return int32(TCL_ERROR)
		}
		switch *(*int32)(unsafe.Pointer(bp)) {
		case 2: /* -flush */
			if flush >= 0 {
				flush = -int32(2)
			} else {
				flush = int32(Z_SYNC_FLUSH)
			}
		case 3: /* -fullflush */
			if flush >= 0 {
				flush = -int32(2)
			} else {
				flush = int32(Z_FULL_FLUSH)
			}
		case 1: /* -finalize */
			if flush >= 0 {
				flush = -int32(2)
			} else {
				flush = int32(Z_FINISH)
			}
		case 0: /* -dictionary compDict */
			if i == objc-int32(2) {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+72225, int64(-libc.Int32FromInt32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+71062, __ccgo_ts+71905, libc.UintptrFromInt32(0)))
				return int32(TCL_ERROR)
			}
			i++
			v2 = i
			compDictObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(v2)*8))
			break
		}
		if flush == -int32(2) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+72295, int64(-libc.Int32FromInt32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+71062, __ccgo_ts+72365, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		goto _1
	_1:
		;
		i++
	}
	if flush == -int32(1) {
		flush = 0
	}
	/*
	 * Set the compression dictionary if requested.
	 */
	if compDictObj != libc.UintptrFromInt32(0) {
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0
		if libc.UintptrFromInt32(0) == XTcl_GetBytesFromObj(tls, interp, compDictObj, bp+8) {
			return int32(TCL_ERROR)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) == 0 {
			compDictObj = libc.UintptrFromInt32(0)
		}
		XTcl_ZlibStreamSetCompressionDictionary(tls, zstream, compDictObj)
	}
	/*
	 * Send the data to the stream core, along with any flushing directive.
	 */
	return XTcl_ZlibStreamPut(tls, zstream, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), flush)
}

var _put_options = [5]uintptr{
	0: __ccgo_ts + 17494,
	1: __ccgo_ts + 72099,
	2: __ccgo_ts + 72109,
	3: __ccgo_ts + 72116,
	4: libc.UintptrFromInt32(0),
}

func _ZlibStreamHeaderCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var cachePtr, resultObj, zshPtr uintptr
	var v1 bool
	_, _, _, _ = cachePtr, resultObj, zshPtr, v1
	zshPtr = clientData
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(2), objv, libc.UintptrFromInt32(0))
		return int32(TCL_ERROR)
	} else {
		if (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fmode != int32(TCL_ZLIB_STREAM_INFLATE) || (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).Fformat != int32(TCL_ZLIB_FORMAT_GZIP) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+72375, int64(-libc.Int32FromInt32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+71062, __ccgo_ts+72426, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
	}
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	_ExtractHeader(tls, (*TZlibStreamHandle)(unsafe.Pointer(zshPtr)).FgzHeaderPtr, resultObj)
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *	Set of functions to support channel stacking.
 *----------------------------------------------------------------------
 */

func _HaveFlag(tls *libc.TLS, chanDataPtr uintptr, flag int32) (r int32) {
	return libc.BoolInt32((*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fflags&flag != 0)
}

/*
 *
 * ZlibTransformClose --
 *
 *	How to shut down a stacked compressing/decompressing transform.
 *
 *----------------------------------------------------------------------
 */

func _ZlibTransformClose(tls *libc.TLS, instanceData uintptr, interp uintptr, flags int32) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _objPtr, chanDataPtr, v2 uintptr
	var e, result int32
	var v1 TTcl_Size
	var _ /* written at bp+0 */ Tsize_t
	_, _, _, _, _, _ = _objPtr, chanDataPtr, e, result, v1, v2
	chanDataPtr = instanceData
	result = TCL_OK
	if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
		return int32(EINVAL)
	}
	/*
	 * Delete the support timer.
	 */
	_ZlibTransformEventTimerKill(tls, chanDataPtr)
	/*
	 * Flush any data waiting to be compressed.
	 */
	if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fmode == int32(TCL_ZLIB_STREAM_DEFLATE) {
		(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutStream.Favail_in = uint32(0)
		for cond := true; cond; cond = e != int32(Z_STREAM_END) {
			e = _Deflate(tls, chanDataPtr+144, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutBuffer, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutAllocated, int32(Z_FINISH), bp)
			/*
			 * Can't be sure that deflate() won't declare the buffer to be
			 * full (with Z_BUF_ERROR) so handle that case.
			 */
			if e == -int32(5) {
				e = Z_OK
				*(*Tsize_t)(unsafe.Pointer(bp)) = (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutAllocated
			}
			if e != Z_OK && e != int32(Z_STREAM_END) {
				/* TODO: is this the right way to do errors on close? */
				if !(XTclInThreadExit(tls) != 0) {
					_ConvertError(tls, interp, e, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutStream.Fadler)
				}
				result = int32(TCL_ERROR)
				break
			}
			if *(*Tsize_t)(unsafe.Pointer(bp)) != 0 && XTcl_WriteRaw(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fparent, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutBuffer, libc.Int64FromUint64(*(*Tsize_t)(unsafe.Pointer(bp)))) == int64(-libc.Int32FromInt32(1)) {
				/* TODO: is this the right way to do errors on close?
				 * Note: when close is called from FinalizeIOSubsystem then
				 * interp may be NULL */
				if !(XTclInThreadExit(tls) != 0) && interp != 0 {
					XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+72432, libc.VaList(bp+16, XTcl_PosixError(tls, interp))))
				}
				result = int32(TCL_ERROR)
				break
			}
		}
		libz.XdeflateEnd(tls, chanDataPtr+144)
	} else {
		/*
		 * If we have unused bytes from the read input (overshot by
		 * Z_STREAM_END or on possible error), unget them back to the parent
		 * channel, so that they appear as not being read yet.
		 */
		if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinStream.Favail_in != 0 {
			XTcl_Ungets(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fparent, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinStream.Fnext_in, libc.Int64FromUint32((*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinStream.Favail_in), 0)
		}
		libz.XinflateEnd(tls, chanDataPtr+32)
	}
	/*
	 * Release all memory.
	 */
	if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj != 0 {
		_objPtr = (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj = libc.UintptrFromInt32(0)
	}
	if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinBuffer != 0 {
		XTclpFree(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinBuffer)
		(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinBuffer = libc.UintptrFromInt32(0)
	}
	if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutBuffer != 0 {
		XTclpFree(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutBuffer)
		(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutBuffer = libc.UintptrFromInt32(0)
	}
	XTclpFree(tls, chanDataPtr)
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * ZlibTransformInput --
 *
 *	Reader filter that does decompression.
 *
 *----------------------------------------------------------------------
 */

func _ZlibTransformInput(tls *libc.TLS, instanceData uintptr, buf uintptr, toRead int32, errorCodePtr uintptr) (r int32) {
	var chanDataPtr, inProc uintptr
	var decBytes, gotBytes, readBytes, v1 int32
	var n uint32
	_, _, _, _, _, _, _ = chanDataPtr, decBytes, gotBytes, inProc, n, readBytes, v1
	chanDataPtr = instanceData
	inProc = XTcl_ChannelInputProc(tls, XTcl_GetChannelType(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fparent))
	if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fmode == int32(TCL_ZLIB_STREAM_DEFLATE) {
		return (*(*func(*libc.TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{inProc})))(tls, XTcl_GetChannelInstanceData(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fparent), buf, toRead, errorCodePtr)
	}
	gotBytes = 0
	readBytes = libc.Int32FromUint32((*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinStream.Favail_in) /* how many bytes in buffer now */
	for !(_HaveFlag(tls, chanDataPtr, int32(STREAM_DONE)) != 0) && toRead > 0 {
		/* if starting from scratch or continuation after full decompression */
		if !((*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinStream.Favail_in != 0) {
			/* buffer to start, we can read to whole available buffer */
			(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinStream.Fnext_in = (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinBuffer
		}
		/*
		 * If done - no read needed anymore, check we have to copy rest of
		 * decompressed data, otherwise return with size (or 0 for Eof)
		 */
		if _HaveFlag(tls, chanDataPtr, int32(STREAM_DECOMPRESS)) != 0 {
			goto copyDecompressed
		}
		/*
		 * The buffer is exhausted, but the caller wants even more. We now
		 * have to go to the underlying channel, get more bytes and then
		 * transform them for delivery. We may not get what we want (full EOF
		 * or temporarily out of data).
		 */
		/* Check free buffer size and adjust size of next chunk to read. */
		n = uint32((*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinAllocated - libc.Uint64FromInt64(int64((*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinStream.Fnext_in)-int64((*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinBuffer)))
		if n <= uint32(0) {
			/* Normally unreachable: not enough input buffer to uncompress.
			 * Todo: firstly try to realloc inBuffer upto MAX_BUFFER_SIZE.
			 */
			*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(ENOBUFS)
			return -int32(1)
		}
		if n > (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FreadAheadLimit {
			n = (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FreadAheadLimit
		}
		readBytes = int32(XTcl_ReadRaw(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fparent, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinStream.Fnext_in, libc.Int64FromUint32(n)))
		/*
		 * Three cases here:
		 *  1.	Got some data from the underlying channel (readBytes > 0) so
		 *	it should be fed through the decompression engine.
		 *  2.	Got an error (readBytes == -1) which we should report up except
		 *	for the case where we can convert it to a short read.
		 *  3.	Got an end-of-data from EOF or blocking (readBytes == 0). If
		 *	it is EOF, try flushing the data out of the decompressor.
		 */
		if readBytes == -int32(1) {
			/* See ReflectInput() in tclIORTrans.c */
			if XTcl_InputBlocked(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fparent) != 0 && gotBytes > 0 {
				break
			}
			*(*int32)(unsafe.Pointer(errorCodePtr)) = XTcl_GetErrno(tls)
			return -int32(1)
		}
		/* more bytes (or Eof if readBytes == 0) */
		(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinStream.Favail_in += libc.Uint32FromInt32(readBytes)
		goto copyDecompressed
	copyDecompressed:
		;
		/*
		 * Transform the read chunk, if not empty. Anything we get
		 * back is a transformation result to be put into our buffers, and
		 * the next iteration will put it into the result.
		 * For the case readBytes is 0 which signaling Eof in parent, the
		 * partial data waiting is converted and returned.
		 */
		if readBytes != 0 {
			v1 = Z_NO_FLUSH
		} else {
			v1 = int32(Z_SYNC_FLUSH)
		}
		decBytes = _ResultDecompress(tls, chanDataPtr, buf, toRead, v1, errorCodePtr)
		if decBytes == -int32(1) {
			return -int32(1)
		}
		gotBytes += decBytes
		buf += uintptr(decBytes)
		toRead -= decBytes
		if decBytes == 0 || _HaveFlag(tls, chanDataPtr, int32(STREAM_DECOMPRESS)) != 0 {
			/*
			 * The drain delivered nothing (or buffer too small to decompress).
			 * Time to deliver what we've got.
			 */
			if !(gotBytes != 0) && !(_HaveFlag(tls, chanDataPtr, int32(STREAM_DONE)) != 0) {
				/* if no-data, but not ready - avoid signaling Eof,
				 * continue in blocking mode, otherwise EAGAIN */
				if XTcl_InputBlocked(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fparent) != 0 {
					continue
				}
				*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(EAGAIN)
				return -int32(1)
			}
			break
		}
		/*
		 * Loop until the request is satisfied (or no data available from
		 * above, possibly EOF).
		 */
	}
	return gotBytes
}

/*
 *----------------------------------------------------------------------
 *
 * ZlibTransformOutput --
 *
 *	Writer filter that does compression.
 *
 *----------------------------------------------------------------------
 */

func _ZlibTransformOutput(tls *libc.TLS, instanceData uintptr, buf uintptr, toWrite int32, errorCodePtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var chanDataPtr, errObj, outProc uintptr
	var e int32
	var _ /* produced at bp+0 */ Tsize_t
	_, _, _, _ = chanDataPtr, e, errObj, outProc
	chanDataPtr = instanceData
	outProc = XTcl_ChannelOutputProc(tls, XTcl_GetChannelType(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fparent))
	if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fmode == int32(TCL_ZLIB_STREAM_INFLATE) {
		return (*(*func(*libc.TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{outProc})))(tls, XTcl_GetChannelInstanceData(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fparent), buf, toWrite, errorCodePtr)
	}
	/*
	 * No zero-length writes. Flushes must be explicit.
	 */
	if toWrite == 0 {
		return 0
	}
	(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutStream.Fnext_in = buf
	(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutStream.Favail_in = libc.Uint32FromInt32(toWrite)
	for (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutStream.Favail_in > uint32(0) {
		e = _Deflate(tls, chanDataPtr+144, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutBuffer, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutAllocated, Z_NO_FLUSH, bp)
		if e != Z_OK || *(*Tsize_t)(unsafe.Pointer(bp)) == uint64(0) {
			break
		}
		if XTcl_WriteRaw(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fparent, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutBuffer, libc.Int64FromUint64(*(*Tsize_t)(unsafe.Pointer(bp)))) == int64(-libc.Int32FromInt32(1)) {
			*(*int32)(unsafe.Pointer(errorCodePtr)) = XTcl_GetErrno(tls)
			return -int32(1)
		}
	}
	if e == Z_OK {
		return libc.Int32FromUint32(libc.Uint32FromInt32(toWrite) - (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutStream.Favail_in)
	}
	errObj = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), errObj, XTcl_NewStringObj(tls, __ccgo_ts+15231, int64(-libc.Int32FromInt32(1))))
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), errObj, _ConvertErrorToList(tls, e, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutStream.Fadler))
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), errObj, XTcl_NewStringObj(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutStream.Fmsg, int64(-libc.Int32FromInt32(1))))
	XTcl_SetChannelError(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fparent, errObj)
	*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(EINVAL)
	return -int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * ZlibTransformFlush --
 *
 *	How to perform a flush of a compressing transform.
 *
 *----------------------------------------------------------------------
 */

func _ZlibTransformFlush(tls *libc.TLS, interp uintptr, chanDataPtr uintptr, flushType int32) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var e int32
	var _ /* len at bp+0 */ Tsize_t
	_ = e
	(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutStream.Favail_in = uint32(0)
	for cond := true; cond; cond = *(*Tsize_t)(unsafe.Pointer(bp)) > uint64(0) && e == -int32(5) {
		/*
		 * Get the bytes to go out of the compression engine.
		 */
		e = _Deflate(tls, chanDataPtr+144, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutBuffer, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutAllocated, flushType, bp)
		if e != Z_OK && e != -int32(5) {
			_ConvertError(tls, interp, e, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutStream.Fadler)
			return int32(TCL_ERROR)
		}
		/*
		 * Write the bytes we've received to the next layer.
		 */
		if *(*Tsize_t)(unsafe.Pointer(bp)) > uint64(0) && XTcl_WriteRaw(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fparent, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutBuffer, libc.Int64FromUint64(*(*Tsize_t)(unsafe.Pointer(bp)))) == int64(-libc.Int32FromInt32(1)) {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+72464, libc.VaList(bp+16, XTcl_PosixError(tls, interp))))
			return int32(TCL_ERROR)
		}
		/*
		 * If we get to this point, either we're in the Z_OK or the
		 * Z_BUF_ERROR state. In the former case, we're done. In the latter
		 * case, it's because there's more bytes to go than would fit in the
		 * buffer we provided, and we need to go round again to get some more.
		 *
		 * We also stop the loop if we would have done a zero-length write.
		 * Those can cause problems at the OS level.
		 */
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * ZlibTransformSetOption --
 *
 *	Writing side of [fconfigure] on our channel.
 *
 *----------------------------------------------------------------------
 */

func _ZlibTransformSetOption(tls *libc.TLS, instanceData uintptr, interp uintptr, optionName uintptr, value uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var _objPtr, cachePtr, cachePtr1, chanDataPtr, compDictObj, setOptionProc, v2, v4, v6, v8, v9 uintptr
	var code, flushType, haveFlushOpt int32
	var v1, v7 bool
	var v3, v5 TTcl_Size
	var _ /* newLimit at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, cachePtr1, chanDataPtr, code, compDictObj, flushType, haveFlushOpt, setOptionProc, v1, v2, v3, v4, v5, v6, v7, v8, v9
	chanDataPtr = instanceData
	setOptionProc = XTcl_ChannelSetOptionProc(tls, XTcl_GetChannelType(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fparent))
	haveFlushOpt = libc.BoolInt32((*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fmode == int32(TCL_ZLIB_STREAM_DEFLATE))
	if optionName != 0 && libc.Xstrcmp(tls, optionName, __ccgo_ts+17494) == 0 && (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fformat != int32(TCL_ZLIB_FORMAT_GZIP) {
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			compDictObj = XTclThreadAllocObj(tls)
		} else {
			compDictObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(compDictObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(compDictObj)).FrefCount = 0
		if libc.Xstrlen(tls, value) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer(compDictObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(compDictObj)).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(compDictObj)).Fbytes = XTcl_Alloc(tls, libc.Xstrlen(tls, value)+uint64(1))
			if value != 0 {
				v2 = value
			} else {
				v2 = uintptr(unsafe.Pointer(&XtclEmptyString))
			}
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(compDictObj)).Fbytes, v2, libc.Xstrlen(tls, value))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(compDictObj)).Fbytes + uintptr(libc.Xstrlen(tls, value)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(compDictObj)).Flength = libc.Int64FromUint64(libc.Xstrlen(tls, value))
		}
		(*TTcl_Obj)(unsafe.Pointer(compDictObj)).FtypePtr = libc.UintptrFromInt32(0)
		(*TTcl_Obj)(unsafe.Pointer(compDictObj)).FrefCount++
		if libc.UintptrFromInt32(0) == XTcl_GetBytesFromObj(tls, interp, compDictObj, libc.UintptrFromInt32(0)) {
			_objPtr = compDictObj
			v4 = _objPtr
			v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
			*(*TTcl_Size)(unsafe.Pointer(v4))--
			if v3 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			return int32(TCL_ERROR)
		}
		if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj != 0 {
			v6 = (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj
			v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
			*(*TTcl_Size)(unsafe.Pointer(v6))--
			if !(v5 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer((*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer((*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer((*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj)).Flength = int64(-libc.Int32FromInt32(1))
					if v7 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v7 {
						cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v7 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer((*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj
						(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj)
				}
			}
		}
		(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj = compDictObj
		code = Z_OK
		if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fmode == int32(TCL_ZLIB_STREAM_DEFLATE) {
			code = _SetDeflateDictionary(tls, chanDataPtr+144, compDictObj)
			if code != Z_OK {
				_ConvertError(tls, interp, code, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutStream.Fadler)
				return int32(TCL_ERROR)
			}
		} else {
			if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fformat == int32(TCL_ZLIB_FORMAT_RAW) {
				code = _SetInflateDictionary(tls, chanDataPtr+32, compDictObj)
				if code != Z_OK {
					_ConvertError(tls, interp, code, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinStream.Fadler)
					return int32(TCL_ERROR)
				}
			}
		}
		return TCL_OK
	}
	if haveFlushOpt != 0 {
		if optionName != 0 && libc.Xstrcmp(tls, optionName, __ccgo_ts+72109) == 0 {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(value))) == int32('f') && libc.Xstrcmp(tls, value, __ccgo_ts+44710) == 0 {
				flushType = int32(Z_FULL_FLUSH)
			} else {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(value))) == int32('s') && libc.Xstrcmp(tls, value, __ccgo_ts+72539) == 0 {
					flushType = int32(Z_SYNC_FLUSH)
				} else {
					XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+72544, libc.VaList(bp+16, value)))
					XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+72591, libc.UintptrFromInt32(0)))
					return int32(TCL_ERROR)
				}
			}
			/*
			 * Try to actually do the flush now.
			 */
			return _ZlibTransformFlush(tls, interp, chanDataPtr, flushType)
		}
	} else {
		if optionName != 0 && libc.Xstrcmp(tls, optionName, __ccgo_ts+71714) == 0 {
			if XTcl_GetInt(tls, interp, value, bp) != TCL_OK {
				return int32(TCL_ERROR)
			} else {
				if *(*int32)(unsafe.Pointer(bp)) < int32(1) || *(*int32)(unsafe.Pointer(bp)) > int32(MAX_BUFFER_SIZE) {
					XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+72597, int64(-libc.Int32FromInt32(1))))
					XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+72632, libc.UintptrFromInt32(0)))
					return int32(TCL_ERROR)
				}
			}
		}
	}
	if setOptionProc == libc.UintptrFromInt32(0) {
		if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fformat == int32(TCL_ZLIB_FORMAT_GZIP) {
			if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fmode == int32(TCL_ZLIB_STREAM_DEFLATE) {
				v8 = _gzipChanOptions
			} else {
				v8 = _gunzipChanOptions
			}
			return XTcl_BadChannelOption(tls, interp, optionName, v8)
		} else {
			if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fmode == int32(TCL_ZLIB_STREAM_DEFLATE) {
				v9 = _compressChanOptions
			} else {
				v9 = _decompressChanOptions
			}
			return XTcl_BadChannelOption(tls, interp, optionName, v9)
		}
	}
	/*
	 * Pass all unknown options down, to deeper transforms and/or the base
	 * channel.
	 */
	return (*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{setOptionProc})))(tls, XTcl_GetChannelInstanceData(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fparent), interp, optionName, value)
}

var _compressChanOptions = __ccgo_ts + 72493

var _gzipChanOptions = __ccgo_ts + 5518

var _decompressChanOptions = __ccgo_ts + 72510

var _gunzipChanOptions = __ccgo_ts + 72527

/*
 *----------------------------------------------------------------------
 *
 * ZlibTransformGetOption --
 *
 *	Reading side of [fconfigure] on our channel.
 *
 *----------------------------------------------------------------------
 */

func _ZlibTransformGetOption(tls *libc.TLS, instanceData uintptr, interp uintptr, optionName uintptr, dsPtr uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var _objPtr, _objPtr1, cachePtr, chanDataPtr, getOptionProc, str, tmpObj, v1, v10, v2, v4, v6, v8, v9 uintptr
	var crc TuLong
	var v3 bool
	var v5, v7 TTcl_Size
	var _ /* buf at bp+0 */ [12]uint8
	var _ /* length at bp+16 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, chanDataPtr, crc, getOptionProc, str, tmpObj, v1, v10, v2, v3, v4, v5, v6, v7, v8, v9
	chanDataPtr = instanceData
	getOptionProc = XTcl_ChannelGetOptionProc(tls, XTcl_GetChannelType(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fparent))
	/*
	 * The "crc" option reports the current CRC (calculated with the Adler32
	 * or CRC32 algorithm according to the format) given the data that has
	 * been processed so far.
	 */
	if optionName == libc.UintptrFromInt32(0) || libc.Xstrcmp(tls, optionName, __ccgo_ts+72710) == 0 {
		if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fmode == int32(TCL_ZLIB_STREAM_DEFLATE) {
			crc = (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutStream.Fadler
		} else {
			crc = (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinStream.Fadler
		}
		libc.X__builtin_snprintf(tls, bp, uint64(12), __ccgo_ts+70243, libc.VaList(bp+32, crc))
		if optionName == libc.UintptrFromInt32(0) {
			XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+72710)
			XTcl_DStringAppendElement(tls, dsPtr, bp)
		} else {
			XTcl_DStringAppend(tls, dsPtr, bp, int64(-libc.Int32FromInt32(1)))
			return TCL_OK
		}
	}
	if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fformat != int32(TCL_ZLIB_FORMAT_GZIP) && (optionName == libc.UintptrFromInt32(0) || libc.Xstrcmp(tls, optionName, __ccgo_ts+17494) == 0) {
		/*
		 * Embedded NUL bytes are ok; they'll be C080-encoded.
		 */
		if optionName == libc.UintptrFromInt32(0) {
			XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+17494)
			if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj != 0 {
				if (*TTcl_Obj)(unsafe.Pointer((*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj)).Fbytes != 0 {
					v1 = (*TTcl_Obj)(unsafe.Pointer((*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj)).Fbytes
				} else {
					v1 = XTcl_GetStringFromObj(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj, libc.UintptrFromInt32(0))
				}
				XTcl_DStringAppendElement(tls, dsPtr, v1)
			} else {
				XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+1945)
			}
		} else {
			if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj != 0 {
				if (*TTcl_Obj)(unsafe.Pointer((*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj)).Fbytes != 0 {
					*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = (*TTcl_Obj)(unsafe.Pointer((*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj)).Flength
					v2 = (*TTcl_Obj)(unsafe.Pointer((*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj)).Fbytes
				} else {
					v2 = XTcl_GetStringFromObj(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj, bp+16)
				}
				str = v2
				XTcl_DStringAppend(tls, dsPtr, str, *(*TTcl_Size)(unsafe.Pointer(bp + 16)))
			}
			return TCL_OK
		}
	}
	/*
	 * The "header" option, which is only valid on inflating gzip channels,
	 * reports the header that has been read from the start of the stream.
	 */
	if _HaveFlag(tls, chanDataPtr, int32(IN_HEADER)) != 0 && (optionName == libc.UintptrFromInt32(0) || libc.Xstrcmp(tls, optionName, __ccgo_ts+71527) == 0) {
		if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			tmpObj = XTclThreadAllocObj(tls)
		} else {
			tmpObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(tmpObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(tmpObj)).FtypePtr = libc.UintptrFromInt32(0)
		_ExtractHeader(tls, chanDataPtr+288, tmpObj)
		if optionName == libc.UintptrFromInt32(0) {
			XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+71527)
			if (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes != 0 {
				v4 = (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes
			} else {
				v4 = XTcl_GetStringFromObj(tls, tmpObj, libc.UintptrFromInt32(0))
			}
			XTcl_DStringAppendElement(tls, dsPtr, v4)
			_objPtr = tmpObj
			v6 = _objPtr
			v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
			*(*TTcl_Size)(unsafe.Pointer(v6))--
			if v5 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		} else {
			XTclDStringAppendObj(tls, dsPtr, tmpObj)
			_objPtr1 = tmpObj
			v8 = _objPtr1
			v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
			*(*TTcl_Size)(unsafe.Pointer(v8))--
			if v7 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
			return TCL_OK
		}
	}
	/*
	 * Now we do the standard processing of the stream we wrapped.
	 */
	if getOptionProc != 0 {
		return (*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{getOptionProc})))(tls, XTcl_GetChannelInstanceData(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fparent), interp, optionName, dsPtr)
	}
	if optionName == libc.UintptrFromInt32(0) {
		return TCL_OK
	}
	if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fformat == int32(TCL_ZLIB_FORMAT_GZIP) {
		if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fmode == int32(TCL_ZLIB_STREAM_DEFLATE) {
			v9 = _gzipChanOptions1
		} else {
			v9 = _gunzipChanOptions1
		}
		return XTcl_BadChannelOption(tls, interp, optionName, v9)
	} else {
		if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fmode == int32(TCL_ZLIB_STREAM_DEFLATE) {
			v10 = _compressChanOptions1
		} else {
			v10 = _decompressChanOptions1
		}
		return XTcl_BadChannelOption(tls, interp, optionName, v10)
	}
	return r
}

var _compressChanOptions1 = __ccgo_ts + 72642

var _gzipChanOptions1 = __ccgo_ts + 72029

var _decompressChanOptions1 = __ccgo_ts + 72662

var _gunzipChanOptions1 = __ccgo_ts + 72688

/*
 *----------------------------------------------------------------------
 *
 * ZlibTransformWatch, ZlibTransformEventHandler --
 *
 *	If we have data pending, trigger a readable event after a short time
 *	(in order to allow a real event to catch up).
 *
 *----------------------------------------------------------------------
 */

func _ZlibTransformWatch(tls *libc.TLS, instanceData uintptr, mask int32) {
	var chanDataPtr, watchProc uintptr
	_, _ = chanDataPtr, watchProc
	chanDataPtr = instanceData
	/*
	 * This code is based on the code in tclIORTrans.c
	 */
	watchProc = XTcl_ChannelWatchProc(tls, XTcl_GetChannelType(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fparent))
	(*(*func(*libc.TLS, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{watchProc})))(tls, XTcl_GetChannelInstanceData(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fparent), mask)
	if !(mask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0) || !(_HaveFlag(tls, chanDataPtr, int32(STREAM_DECOMPRESS)) != 0) {
		_ZlibTransformEventTimerKill(tls, chanDataPtr)
	} else {
		if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Ftimer == libc.UintptrFromInt32(0) {
			(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Ftimer = XTcl_CreateTimerHandler(tls, SYNTHETIC_EVENT_TIME, __ccgo_fp(_ZlibTransformTimerRun), chanDataPtr)
		}
	}
}

func _ZlibTransformEventHandler(tls *libc.TLS, instanceData uintptr, interestMask int32) (r int32) {
	var chanDataPtr uintptr
	_ = chanDataPtr
	chanDataPtr = instanceData
	_ZlibTransformEventTimerKill(tls, chanDataPtr)
	return interestMask
}

func _ZlibTransformEventTimerKill(tls *libc.TLS, chanDataPtr uintptr) {
	if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Ftimer != libc.UintptrFromInt32(0) {
		XTcl_DeleteTimerHandler(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Ftimer)
		(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Ftimer = libc.UintptrFromInt32(0)
	}
}

func _ZlibTransformTimerRun(tls *libc.TLS, clientData uintptr) {
	var chanDataPtr uintptr
	_ = chanDataPtr
	chanDataPtr = clientData
	(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Ftimer = libc.UintptrFromInt32(0)
	XTcl_NotifyChannel(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fchan1, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1))
}

/*
 *----------------------------------------------------------------------
 *
 * ZlibTransformGetHandle --
 *
 *	Anything that needs the OS handle is told to get it from what we are
 *	stacked on top of.
 *
 *----------------------------------------------------------------------
 */

func _ZlibTransformGetHandle(tls *libc.TLS, instanceData uintptr, direction int32, handlePtr uintptr) (r int32) {
	var chanDataPtr uintptr
	_ = chanDataPtr
	chanDataPtr = instanceData
	return XTcl_GetChannelHandle(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fparent, direction, handlePtr)
}

/*
 *----------------------------------------------------------------------
 *
 * ZlibTransformBlockMode --
 *
 *	We need to keep track of the blocking mode; it changes our behavior.
 *
 *----------------------------------------------------------------------
 */

func _ZlibTransformBlockMode(tls *libc.TLS, instanceData uintptr, mode int32) (r int32) {
	var chanDataPtr uintptr
	_ = chanDataPtr
	chanDataPtr = instanceData
	if mode == int32(TCL_MODE_NONBLOCKING) {
		*(*int32)(unsafe.Pointer(chanDataPtr + 16)) |= int32(ASYNC)
	} else {
		*(*int32)(unsafe.Pointer(chanDataPtr + 16)) &= ^int32(ASYNC)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * ZlibStackChannelTransform --
 *
 *	Stacks either compression or decompression onto a channel.
 *
 * Results:
 *	The stacked channel, or NULL if there was an error.
 *
 *----------------------------------------------------------------------
 */

func _ZlibStackChannelTransform(tls *libc.TLS, interp uintptr, mode int32, format int32, level int32, limit int32, channel TTcl_Channel, gzipHeaderDictPtr uintptr, compDictObj uintptr) (r TTcl_Channel) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Byte-array object containing compression
	 * dictionary (not dictObj!) to use if
	 * necessary. */
	var _objPtr, chanDataPtr, v2 uintptr
	var chan1 TTcl_Channel
	var wbits int32
	var v1 TTcl_Size
	_, _, _, _, _, _ = _objPtr, chan1, chanDataPtr, wbits, v1, v2
	chanDataPtr = XTcl_Alloc(tls, uint64(9168))
	wbits = 0
	if mode != int32(TCL_ZLIB_STREAM_DEFLATE) && mode != int32(TCL_ZLIB_STREAM_INFLATE) {
		XTcl_Panic(tls, __ccgo_ts+72720, libc.VaList(bp+8, mode))
	}
	libc.Xmemset(tls, chanDataPtr, 0, uint64(9168))
	(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fmode = mode
	(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fformat = format
	(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FreadAheadLimit = libc.Uint32FromInt32(limit)
	if format == int32(TCL_ZLIB_FORMAT_GZIP) || format == int32(TCL_ZLIB_FORMAT_AUTO) {
		if mode == int32(TCL_ZLIB_STREAM_DEFLATE) {
			if gzipHeaderDictPtr != 0 {
				*(*int32)(unsafe.Pointer(chanDataPtr + 16)) |= int32(OUT_HEADER)
				if _GenerateHeader(tls, interp, gzipHeaderDictPtr, chanDataPtr+4720, libc.UintptrFromInt32(0)) != TCL_OK {
					goto error
				}
			}
		} else {
			*(*int32)(unsafe.Pointer(chanDataPtr + 16)) |= int32(IN_HEADER)
			(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinHeader.Fheader.Fname = chanDataPtr + 288 + 80
			(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinHeader.Fheader.Fname_max = libc.Uint32FromInt32(libc.Int32FromInt32(MAXPATHLEN) - libc.Int32FromInt32(1))
			(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinHeader.Fheader.Fcomment = chanDataPtr + 288 + 4176
			(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinHeader.Fheader.Fcomm_max = libc.Uint32FromInt32(libc.Int32FromInt32(MAX_COMMENT_LEN) - libc.Int32FromInt32(1))
		}
	}
	if compDictObj != libc.UintptrFromInt32(0) {
		(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj = XTcl_DuplicateObj(tls, compDictObj)
		(*TTcl_Obj)(unsafe.Pointer((*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj)).FrefCount++
		XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj, libc.UintptrFromInt32(0))
	}
	switch format {
	case int32(TCL_ZLIB_FORMAT_RAW):
		wbits = int32(WBITS_RAW)
	case int32(TCL_ZLIB_FORMAT_ZLIB):
		wbits = int32(WBITS_ZLIB)
	case int32(TCL_ZLIB_FORMAT_GZIP):
		wbits = int32(WBITS_GZIP)
	case int32(TCL_ZLIB_FORMAT_AUTO):
		wbits = int32(WBITS_AUTODETECT)
	default:
		XTcl_Panic(tls, __ccgo_ts+72737, libc.VaList(bp+8, format))
	}
	/*
	 * Initialize input inflater or the output deflater.
	 */
	if mode == int32(TCL_ZLIB_STREAM_INFLATE) {
		if libz.XinflateInit2_(tls, chanDataPtr+32, wbits, __ccgo_ts+70913, libc.Int32FromInt64(112)) != Z_OK {
			goto error
		}
		(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinAllocated = uint64(DEFAULT_BUFFER_SIZE)
		if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinAllocated < uint64((*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FreadAheadLimit) {
			(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinAllocated = uint64((*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FreadAheadLimit)
		}
		(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinBuffer = XTcl_Alloc(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinAllocated)
		if _HaveFlag(tls, chanDataPtr, int32(IN_HEADER)) != 0 {
			if libz.XinflateGetHeader(tls, chanDataPtr+32, chanDataPtr+288) != Z_OK {
				goto error
			}
		}
		if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fformat == int32(TCL_ZLIB_FORMAT_RAW) && (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj != 0 {
			if _SetInflateDictionary(tls, chanDataPtr+32, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj) != Z_OK {
				goto error
			}
		}
	} else {
		if libz.XdeflateInit2_(tls, chanDataPtr+144, level, int32(Z_DEFLATED), wbits, int32(MAX_MEM_LEVEL), Z_DEFAULT_STRATEGY, __ccgo_ts+70913, libc.Int32FromInt64(112)) != Z_OK {
			goto error
		}
		(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutAllocated = uint64(DEFAULT_BUFFER_SIZE)
		(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutBuffer = XTcl_Alloc(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutAllocated)
		if _HaveFlag(tls, chanDataPtr, int32(OUT_HEADER)) != 0 {
			if libz.XdeflateSetHeader(tls, chanDataPtr+144, chanDataPtr+4720) != Z_OK {
				goto error
			}
		}
		if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj != 0 {
			if _SetDeflateDictionary(tls, chanDataPtr+144, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj) != Z_OK {
				goto error
			}
		}
	}
	chan1 = XTcl_StackChannel(tls, interp, uintptr(unsafe.Pointer(&_zlibChannelType)), chanDataPtr, XTcl_GetChannelMode(tls, channel), channel)
	if chan1 == libc.UintptrFromInt32(0) {
		goto error
	}
	(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fchan1 = chan1
	(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fparent = XTcl_GetStackedChannel(tls, chan1)
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, XTcl_GetChannelName(tls, chan1), int64(-libc.Int32FromInt32(1))))
	return chan1
	goto error
error:
	;
	if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinBuffer != 0 {
		XTclpFree(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinBuffer)
		libz.XinflateEnd(tls, chanDataPtr+32)
	}
	if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutBuffer != 0 {
		XTclpFree(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FoutBuffer)
		libz.XdeflateEnd(tls, chanDataPtr+144)
	}
	if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj != 0 {
		_objPtr = (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	XTclpFree(tls, chanDataPtr)
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * ResultDecompress --
 *
 *	Extract uncompressed bytes from the compression engine and store them
 *	in our buffer (buf) up to toRead bytes.
 *
 * Result:
 *	Number of bytes decompressed or -1 if error (with *errorCodePtr updated
 *	with reason).
 *
 * Side effects:
 *	After execution it updates chanDataPtr->inStream (next_in, avail_in) to
 *	reflect the data that has been decompressed.
 *
 *----------------------------------------------------------------------
 */

func _ResultDecompress(tls *libc.TLS, chanDataPtr uintptr, buf uintptr, toRead int32, flush int32, errorCodePtr uintptr) (r int32) {
	var e, resBytes, written int32
	var errObj uintptr
	_, _, _, _ = e, errObj, resBytes, written
	resBytes = 0
	*(*int32)(unsafe.Pointer(chanDataPtr + 16)) &= ^int32(STREAM_DECOMPRESS)
	(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinStream.Fnext_out = buf
	(*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinStream.Favail_out = libc.Uint32FromInt32(toRead)
	for (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinStream.Favail_out > uint32(0) {
		e = libz.Xinflate(tls, chanDataPtr+32, flush)
		/*
		 * Apply a compression dictionary if one is needed and we have one.
		 */
		if e == int32(Z_NEED_DICT) && (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj != 0 {
			e = _SetInflateDictionary(tls, chanDataPtr+32, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FcompDictObj)
			if e == Z_OK {
				/*
				 * A repetition of Z_NEED_DICT now is just an error.
				 */
				e = libz.Xinflate(tls, chanDataPtr+32, flush)
			}
		}
		/*
		 * avail_out is now the left over space in the output.  Therefore
		 * "toRead - avail_out" is the amount of bytes generated.
		 */
		written = libc.Int32FromUint32(libc.Uint32FromInt32(toRead) - (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinStream.Favail_out)
		/*
		 * The cases where we're definitely done.
		 */
		if e == int32(Z_STREAM_END) {
			*(*int32)(unsafe.Pointer(chanDataPtr + 16)) |= int32(STREAM_DONE)
			resBytes += written
			break
		}
		if e == Z_OK {
			if written == 0 {
				break
			}
			resBytes += written
		}
		if flush == int32(Z_SYNC_FLUSH) && e == -int32(5) {
			break
		}
		/*
		 * Z_BUF_ERROR can be ignored as per http://www.zlib.net/zlib_how.html
		 *
		 * Just indicates that the zlib couldn't consume input/produce output,
		 * and is fixed by supplying more input.
		 *
		 * Otherwise, we've got errors and need to report to higher-up.
		 */
		if e != Z_OK && e != -int32(5) {
			goto handleError
		}
		/*
		 * Check if the inflate stopped early.
		 */
		if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinStream.Favail_in <= uint32(0) && flush != int32(Z_SYNC_FLUSH) {
			break
		}
	}
	if !(_HaveFlag(tls, chanDataPtr, int32(STREAM_DONE)) != 0) {
		/* if we have pending input data, but no available output buffer */
		if (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinStream.Favail_in != 0 && !((*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinStream.Favail_out != 0) {
			/* next time try to decompress it got readable (new output buffer) */
			*(*int32)(unsafe.Pointer(chanDataPtr + 16)) |= int32(STREAM_DECOMPRESS)
		}
	}
	return resBytes
	goto handleError
handleError:
	;
	errObj = XTcl_NewListObj(tls, 0, libc.UintptrFromInt32(0))
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), errObj, XTcl_NewStringObj(tls, __ccgo_ts+15231, int64(-libc.Int32FromInt32(1))))
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), errObj, _ConvertErrorToList(tls, e, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinStream.Fadler))
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), errObj, XTcl_NewStringObj(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).FinStream.Fmsg, int64(-libc.Int32FromInt32(1))))
	XTcl_SetChannelError(tls, (*TZlibChannelData)(unsafe.Pointer(chanDataPtr)).Fparent, errObj)
	*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(EINVAL)
	return -int32(1)
}

/*
 *----------------------------------------------------------------------
 *	Finally, the TclZlibInit function. Used to install the zlib API.
 *----------------------------------------------------------------------
 */

func XTclZlibInit(tls *libc.TLS, interp uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _ /* cfg at bp+0 */ [2]TTcl_Config
	/*
	 * This does two things. It creates a counter used in the creation of
	 * stream commands, and it creates the namespace that will contain those
	 * commands.
	 */
	XTcl_EvalEx(tls, interp, __ccgo_ts+72752, int64(-libc.Int32FromInt32(1)), 0)
	/*
	 * Create the public scripted interface to this file's functionality.
	 */
	XTcl_CreateObjCommand(tls, interp, __ccgo_ts+70188, __ccgo_fp(_ZlibCmd), uintptr(0), uintptr(0))
	/*
	 * Store the underlying configuration information.
	 *
	 * TODO: Describe whether we're using the system version of the library or
	 * a compatibility version built into Tcl?
	 */
	(*(*[2]TTcl_Config)(unsafe.Pointer(bp)))[0].Fkey = __ccgo_ts + 72803
	(*(*[2]TTcl_Config)(unsafe.Pointer(bp)))[0].Fvalue = libz.XzlibVersion(tls)
	(*(*[2]TTcl_Config)(unsafe.Pointer(bp)))[int32(1)].Fkey = libc.UintptrFromInt32(0)
	XTcl_RegisterConfig(tls, interp, __ccgo_ts+70188, bp, __ccgo_ts+29080)
	/*
	 * Allow command type introspection to do something sensible with streams.
	 */
	XTclRegisterCommandTypeName(tls, __ccgo_fp(_ZlibStreamCmd), __ccgo_ts+72815)
	/*
	 * Formally provide the package as a Tcl built-in.
	 */
	return XTcl_PkgProvideEx(tls, interp, __ccgo_ts+72826, __ccgo_ts+72836, libc.UintptrFromInt32(0))
}

/*
 *----------------------------------------------------------------------
 *
 * TclTommath_Init --
 *
 *	Initializes the TclTomMath 'package', which exists as a
 *	placeholder so that the package data can be used to hold
 *	a stub table pointer.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	Installs the stub table for tommath.
 *
 *----------------------------------------------------------------------
 */

func XTclTommath_Init(tls *libc.TLS, interp uintptr) (r int32) {
	/* Tcl interpreter */
	/* TIP #268: Full patchlevel instead of just major.minor */
	if XTcl_PkgProvideEx(tls, interp, __ccgo_ts+72842, __ccgo_ts+7219, uintptr(unsafe.Pointer(&XtclTomMathStubs))) != TCL_OK {
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclBN_epoch --
 *
 *	Return the epoch number of the TclTomMath stubs table
 *
 * Results:
 *	Returns an arbitrary integer that does not decrease with
 *	release.  Stubs tables with different epochs are incompatible.
 *
 *----------------------------------------------------------------------
 */

func XTclBN_epoch(tls *libc.TLS) (r int32) {
	return TCLTOMMATH_EPOCH
}

/*
 *----------------------------------------------------------------------
 *
 * TclBN_revision --
 *
 *	Returns the revision level of the TclTomMath stubs table
 *
 * Results:
 *	Returns an arbitrary integer that increases with revisions.
 *	If a client requires a given epoch and revision, any Stubs table
 *	with the same epoch and an equal or higher revision satisfies
 *	the request.
 *
 *----------------------------------------------------------------------
 */

func XTclBN_revision(tls *libc.TLS) (r int32) {
	return TCLTOMMATH_REVISION
}

const DEFAULT_WRITE_MAX_SIZE = 2147483647
const DEF_MEM_LEVEL = 8
const DEF_WBITS = 15
const DYN_TREES = 2
const MADV_COLD = 20
const MADV_DODUMP = 17
const MADV_DOFORK = 11
const MADV_DONTDUMP = 16
const MADV_DONTFORK = 10
const MADV_DONTNEED = 4
const MADV_FREE = 8
const MADV_HUGEPAGE = 14
const MADV_HWPOISON = 100
const MADV_KEEPONFORK = 19
const MADV_MERGEABLE = 12
const MADV_NOHUGEPAGE = 15
const MADV_NORMAL = 0
const MADV_PAGEOUT = 21
const MADV_RANDOM = 1
const MADV_REMOVE = 9
const MADV_SEQUENTIAL = 2
const MADV_SOFT_OFFLINE = 101
const MADV_UNMERGEABLE = 13
const MADV_WILLNEED = 3
const MADV_WIPEONFORK = 18
const MAP_ANON = 32
const MAP_ANONYMOUS = 32
const MAP_DENYWRITE = 2048
const MAP_EXECUTABLE = 4096
const MAP_FAILED = -1
const MAP_FILE = 0
const MAP_FIXED = 16
const MAP_FIXED_NOREPLACE = 1048576
const MAP_GROWSDOWN = 256
const MAP_HUGETLB = 262144
const MAP_HUGE_16GB = 2281701376
const MAP_HUGE_16KB = 939524096
const MAP_HUGE_16MB = 1610612736
const MAP_HUGE_1GB = 2013265920
const MAP_HUGE_1MB = 1342177280
const MAP_HUGE_256MB = 1879048192
const MAP_HUGE_2GB = 2080374784
const MAP_HUGE_2MB = 1409286144
const MAP_HUGE_32MB = 1677721600
const MAP_HUGE_512KB = 1275068416
const MAP_HUGE_512MB = 1946157056
const MAP_HUGE_64KB = 1073741824
const MAP_HUGE_8MB = 1543503872
const MAP_HUGE_MASK = 63
const MAP_HUGE_SHIFT = 26
const MAP_LOCKED = 8192
const MAP_NONBLOCK = 65536
const MAP_NORESERVE = 16384
const MAP_POPULATE = 32768
const MAP_PRIVATE = 2
const MAP_SHARED = 1
const MAP_SHARED_VALIDATE = 3
const MAP_STACK = 131072
const MAP_SYNC = 524288
const MAP_TYPE = 15
const MAX_MATCH = 258
const MCL_CURRENT = 1
const MCL_FUTURE = 2
const MCL_ONFAULT = 4
const MFD_ALLOW_SEALING = 2
const MFD_CLOEXEC = 1
const MFD_HUGETLB = 4
const MIN_MATCH = 3
const MLOCK_ONFAULT = 1
const MREMAP_DONTUNMAP = 4
const MREMAP_FIXED = 2
const MREMAP_MAYMOVE = 1
const MS_ASYNC = 1
const MS_INVALIDATE = 2
const MS_SYNC = 4
const OS_CODE = 3
const POSIX_MADV_DONTNEED = 4
const POSIX_MADV_NORMAL = 0
const POSIX_MADV_RANDOM = 1
const POSIX_MADV_SEQUENTIAL = 2
const POSIX_MADV_WILLNEED = 3
const PRESET_DICT = 32
const PROT_EXEC = 4
const PROT_GROWSDOWN = 16777216
const PROT_GROWSUP = 33554432
const PROT_NONE = 0
const PROT_READ = 1
const PROT_WRITE = 2
const RTLD_DI_LINKMAP = 2
const RTLD_GLOBAL = 256
const RTLD_LAZY = 1
const RTLD_LOCAL = 0
const RTLD_NEXT = -1
const RTLD_NODELETE = 4096
const RTLD_NOLOAD = 4
const RTLD_NOW = 2
const STATIC_TREES = 1
const STORED_BLOCK = 0
const TBLS = 1
const ZIPFS_FALLBACK_ENCODING = "cp437"
const ZIPFS_ROOTDIR_DEPTH = 3
const ZIPFS_VOLUME = "//zipfs:/"
const ZIPFS_VOLUME_LEN = 9
const ZIP_CENTRAL_END_SIG = 101010256
const ZIP_CENTRAL_HEADER_SIG = 33639248
const ZIP_CRYPT_HDR_LEN = 12
const ZIP_LOCAL_HEADER_SIG = 67324752
const ZIP_MAX_FILE_SIZE = 2147483647
const ZIP_MIN_VERSION = 20
const ZIP_PASSWORD_END_SIG = 1515866960
const ZIP_SIG_LEN = 4
const local = 0
const mmap64 = 0
const zmemcmp = 0
const zmemcpy = 0

type TDl_info = struct {
	Fdli_fname uintptr
	Fdli_fbase uintptr
	Fdli_sname uintptr
	Fdli_saddr uintptr
}

func _decrypt_byte(tls *libc.TLS, pkeys uintptr, pcrc_32_tab uintptr) (r int32) {
	var temp uint32
	_ = temp
	_ = pcrc_32_tab
	temp = uint32(*(*uint64)(unsafe.Pointer(pkeys + libc.UintptrFromInt32(2)*8)))&uint32(0xffff) | uint32(2)
	return libc.Int32FromUint32(temp * (temp ^ libc.Uint32FromInt32(1)) >> libc.Int32FromInt32(8) & libc.Uint32FromInt32(0xff))
}

func _update_keys(tls *libc.TLS, pkeys uintptr, pcrc_32_tab uintptr, c int32) (r int32) {
	var keyshift int32
	_ = keyshift
	*(*uint64)(unsafe.Pointer(pkeys + libc.UintptrFromInt32(0)*8)) = uint64(*(*Tz_crc_t)(unsafe.Pointer(pcrc_32_tab + uintptr((libc.Int32FromUint64(*(*uint64)(unsafe.Pointer(pkeys + libc.UintptrFromInt32(0)*8)))^c)&libc.Int32FromInt32(0xff))*4))) ^ *(*uint64)(unsafe.Pointer(pkeys + libc.UintptrFromInt32(0)*8))>>int32(8)
	*(*uint64)(unsafe.Pointer(pkeys + libc.UintptrFromInt32(1)*8)) += *(*uint64)(unsafe.Pointer(pkeys + libc.UintptrFromInt32(0)*8)) & uint64(0xff)
	*(*uint64)(unsafe.Pointer(pkeys + libc.UintptrFromInt32(1)*8)) = *(*uint64)(unsafe.Pointer(pkeys + libc.UintptrFromInt32(1)*8))*uint64(134775813) + uint64(1)
	keyshift = libc.Int32FromUint64(*(*uint64)(unsafe.Pointer(pkeys + libc.UintptrFromInt32(1)*8)) >> libc.Int32FromInt32(24))
	*(*uint64)(unsafe.Pointer(pkeys + libc.UintptrFromInt32(2)*8)) = uint64(*(*Tz_crc_t)(unsafe.Pointer(pcrc_32_tab + uintptr((libc.Int32FromUint64(*(*uint64)(unsafe.Pointer(pkeys + libc.UintptrFromInt32(2)*8)))^keyshift)&libc.Int32FromInt32(0xff))*4))) ^ *(*uint64)(unsafe.Pointer(pkeys + libc.UintptrFromInt32(2)*8))>>int32(8)
	return c
}

func _init_keys(tls *libc.TLS, passwd uintptr, pkeys uintptr, pcrc_32_tab uintptr) {
	*(*uint64)(unsafe.Pointer(pkeys + libc.UintptrFromInt32(0)*8)) = uint64(305419896)
	*(*uint64)(unsafe.Pointer(pkeys + libc.UintptrFromInt32(1)*8)) = uint64(591751049)
	*(*uint64)(unsafe.Pointer(pkeys + libc.UintptrFromInt32(2)*8)) = uint64(878082192)
	for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(passwd))) != int32('\000') {
		_update_keys(tls, pkeys, pcrc_32_tab, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(passwd))))
		passwd++
	}
}

type Tuch = uint8

type Tuchf = uint8

type Tush = uint16

type Tushf = uint16

type Tulg = uint64

var _crc_table = [256]Tz_crc_t{
	1:   uint32(0x77073096),
	2:   uint32(0xee0e612c),
	3:   uint32(0x990951ba),
	4:   uint32(0x076dc419),
	5:   uint32(0x706af48f),
	6:   uint32(0xe963a535),
	7:   uint32(0x9e6495a3),
	8:   uint32(0x0edb8832),
	9:   uint32(0x79dcb8a4),
	10:  uint32(0xe0d5e91e),
	11:  uint32(0x97d2d988),
	12:  uint32(0x09b64c2b),
	13:  uint32(0x7eb17cbd),
	14:  uint32(0xe7b82d07),
	15:  uint32(0x90bf1d91),
	16:  uint32(0x1db71064),
	17:  uint32(0x6ab020f2),
	18:  uint32(0xf3b97148),
	19:  uint32(0x84be41de),
	20:  uint32(0x1adad47d),
	21:  uint32(0x6ddde4eb),
	22:  uint32(0xf4d4b551),
	23:  uint32(0x83d385c7),
	24:  uint32(0x136c9856),
	25:  uint32(0x646ba8c0),
	26:  uint32(0xfd62f97a),
	27:  uint32(0x8a65c9ec),
	28:  uint32(0x14015c4f),
	29:  uint32(0x63066cd9),
	30:  uint32(0xfa0f3d63),
	31:  uint32(0x8d080df5),
	32:  uint32(0x3b6e20c8),
	33:  uint32(0x4c69105e),
	34:  uint32(0xd56041e4),
	35:  uint32(0xa2677172),
	36:  uint32(0x3c03e4d1),
	37:  uint32(0x4b04d447),
	38:  uint32(0xd20d85fd),
	39:  uint32(0xa50ab56b),
	40:  uint32(0x35b5a8fa),
	41:  uint32(0x42b2986c),
	42:  uint32(0xdbbbc9d6),
	43:  uint32(0xacbcf940),
	44:  uint32(0x32d86ce3),
	45:  uint32(0x45df5c75),
	46:  uint32(0xdcd60dcf),
	47:  uint32(0xabd13d59),
	48:  uint32(0x26d930ac),
	49:  uint32(0x51de003a),
	50:  uint32(0xc8d75180),
	51:  uint32(0xbfd06116),
	52:  uint32(0x21b4f4b5),
	53:  uint32(0x56b3c423),
	54:  uint32(0xcfba9599),
	55:  uint32(0xb8bda50f),
	56:  uint32(0x2802b89e),
	57:  uint32(0x5f058808),
	58:  uint32(0xc60cd9b2),
	59:  uint32(0xb10be924),
	60:  uint32(0x2f6f7c87),
	61:  uint32(0x58684c11),
	62:  uint32(0xc1611dab),
	63:  uint32(0xb6662d3d),
	64:  uint32(0x76dc4190),
	65:  uint32(0x01db7106),
	66:  uint32(0x98d220bc),
	67:  uint32(0xefd5102a),
	68:  uint32(0x71b18589),
	69:  uint32(0x06b6b51f),
	70:  uint32(0x9fbfe4a5),
	71:  uint32(0xe8b8d433),
	72:  uint32(0x7807c9a2),
	73:  uint32(0x0f00f934),
	74:  uint32(0x9609a88e),
	75:  uint32(0xe10e9818),
	76:  uint32(0x7f6a0dbb),
	77:  uint32(0x086d3d2d),
	78:  uint32(0x91646c97),
	79:  uint32(0xe6635c01),
	80:  uint32(0x6b6b51f4),
	81:  uint32(0x1c6c6162),
	82:  uint32(0x856530d8),
	83:  uint32(0xf262004e),
	84:  uint32(0x6c0695ed),
	85:  uint32(0x1b01a57b),
	86:  uint32(0x8208f4c1),
	87:  uint32(0xf50fc457),
	88:  uint32(0x65b0d9c6),
	89:  uint32(0x12b7e950),
	90:  uint32(0x8bbeb8ea),
	91:  uint32(0xfcb9887c),
	92:  uint32(0x62dd1ddf),
	93:  uint32(0x15da2d49),
	94:  uint32(0x8cd37cf3),
	95:  uint32(0xfbd44c65),
	96:  uint32(0x4db26158),
	97:  uint32(0x3ab551ce),
	98:  uint32(0xa3bc0074),
	99:  uint32(0xd4bb30e2),
	100: uint32(0x4adfa541),
	101: uint32(0x3dd895d7),
	102: uint32(0xa4d1c46d),
	103: uint32(0xd3d6f4fb),
	104: uint32(0x4369e96a),
	105: uint32(0x346ed9fc),
	106: uint32(0xad678846),
	107: uint32(0xda60b8d0),
	108: uint32(0x44042d73),
	109: uint32(0x33031de5),
	110: uint32(0xaa0a4c5f),
	111: uint32(0xdd0d7cc9),
	112: uint32(0x5005713c),
	113: uint32(0x270241aa),
	114: uint32(0xbe0b1010),
	115: uint32(0xc90c2086),
	116: uint32(0x5768b525),
	117: uint32(0x206f85b3),
	118: uint32(0xb966d409),
	119: uint32(0xce61e49f),
	120: uint32(0x5edef90e),
	121: uint32(0x29d9c998),
	122: uint32(0xb0d09822),
	123: uint32(0xc7d7a8b4),
	124: uint32(0x59b33d17),
	125: uint32(0x2eb40d81),
	126: uint32(0xb7bd5c3b),
	127: uint32(0xc0ba6cad),
	128: uint32(0xedb88320),
	129: uint32(0x9abfb3b6),
	130: uint32(0x03b6e20c),
	131: uint32(0x74b1d29a),
	132: uint32(0xead54739),
	133: uint32(0x9dd277af),
	134: uint32(0x04db2615),
	135: uint32(0x73dc1683),
	136: uint32(0xe3630b12),
	137: uint32(0x94643b84),
	138: uint32(0x0d6d6a3e),
	139: uint32(0x7a6a5aa8),
	140: uint32(0xe40ecf0b),
	141: uint32(0x9309ff9d),
	142: uint32(0x0a00ae27),
	143: uint32(0x7d079eb1),
	144: uint32(0xf00f9344),
	145: uint32(0x8708a3d2),
	146: uint32(0x1e01f268),
	147: uint32(0x6906c2fe),
	148: uint32(0xf762575d),
	149: uint32(0x806567cb),
	150: uint32(0x196c3671),
	151: uint32(0x6e6b06e7),
	152: uint32(0xfed41b76),
	153: uint32(0x89d32be0),
	154: uint32(0x10da7a5a),
	155: uint32(0x67dd4acc),
	156: uint32(0xf9b9df6f),
	157: uint32(0x8ebeeff9),
	158: uint32(0x17b7be43),
	159: uint32(0x60b08ed5),
	160: uint32(0xd6d6a3e8),
	161: uint32(0xa1d1937e),
	162: uint32(0x38d8c2c4),
	163: uint32(0x4fdff252),
	164: uint32(0xd1bb67f1),
	165: uint32(0xa6bc5767),
	166: uint32(0x3fb506dd),
	167: uint32(0x48b2364b),
	168: uint32(0xd80d2bda),
	169: uint32(0xaf0a1b4c),
	170: uint32(0x36034af6),
	171: uint32(0x41047a60),
	172: uint32(0xdf60efc3),
	173: uint32(0xa867df55),
	174: uint32(0x316e8eef),
	175: uint32(0x4669be79),
	176: uint32(0xcb61b38c),
	177: uint32(0xbc66831a),
	178: uint32(0x256fd2a0),
	179: uint32(0x5268e236),
	180: uint32(0xcc0c7795),
	181: uint32(0xbb0b4703),
	182: uint32(0x220216b9),
	183: uint32(0x5505262f),
	184: uint32(0xc5ba3bbe),
	185: uint32(0xb2bd0b28),
	186: uint32(0x2bb45a92),
	187: uint32(0x5cb36a04),
	188: uint32(0xc2d7ffa7),
	189: uint32(0xb5d0cf31),
	190: uint32(0x2cd99e8b),
	191: uint32(0x5bdeae1d),
	192: uint32(0x9b64c2b0),
	193: uint32(0xec63f226),
	194: uint32(0x756aa39c),
	195: uint32(0x026d930a),
	196: uint32(0x9c0906a9),
	197: uint32(0xeb0e363f),
	198: uint32(0x72076785),
	199: uint32(0x05005713),
	200: uint32(0x95bf4a82),
	201: uint32(0xe2b87a14),
	202: uint32(0x7bb12bae),
	203: uint32(0x0cb61b38),
	204: uint32(0x92d28e9b),
	205: uint32(0xe5d5be0d),
	206: uint32(0x7cdcefb7),
	207: uint32(0x0bdbdf21),
	208: uint32(0x86d3d2d4),
	209: uint32(0xf1d4e242),
	210: uint32(0x68ddb3f8),
	211: uint32(0x1fda836e),
	212: uint32(0x81be16cd),
	213: uint32(0xf6b9265b),
	214: uint32(0x6fb077e1),
	215: uint32(0x18b74777),
	216: uint32(0x88085ae6),
	217: uint32(0xff0f6a70),
	218: uint32(0x66063bca),
	219: uint32(0x11010b5c),
	220: uint32(0x8f659eff),
	221: uint32(0xf862ae69),
	222: uint32(0x616bffd3),
	223: uint32(0x166ccf45),
	224: uint32(0xa00ae278),
	225: uint32(0xd70dd2ee),
	226: uint32(0x4e048354),
	227: uint32(0x3903b3c2),
	228: uint32(0xa7672661),
	229: uint32(0xd06016f7),
	230: uint32(0x4969474d),
	231: uint32(0x3e6e77db),
	232: uint32(0xaed16a4a),
	233: uint32(0xd9d65adc),
	234: uint32(0x40df0b66),
	235: uint32(0x37d83bf0),
	236: uint32(0xa9bcae53),
	237: uint32(0xdebb9ec5),
	238: uint32(0x47b2cf7f),
	239: uint32(0x30b5ffe9),
	240: uint32(0xbdbdf21c),
	241: uint32(0xcabac28a),
	242: uint32(0x53b39330),
	243: uint32(0x24b4a3a6),
	244: uint32(0xbad03605),
	245: uint32(0xcdd70693),
	246: uint32(0x54de5729),
	247: uint32(0x23d967bf),
	248: uint32(0xb3667a2e),
	249: uint32(0xc4614ab8),
	250: uint32(0x5d681b02),
	251: uint32(0x2a6f2b94),
	252: uint32(0xb40bbe37),
	253: uint32(0xc30c8ea1),
	254: uint32(0x5a05df1b),
	255: uint32(0x2d02ef8d),
}
var _x2n_table = [32]Tz_crc_t{
	0:  uint32(0x40000000),
	1:  uint32(0x20000000),
	2:  uint32(0x08000000),
	3:  uint32(0x00800000),
	4:  uint32(0x00008000),
	5:  uint32(0xedb88320),
	6:  uint32(0xb1e6b092),
	7:  uint32(0xa06a2517),
	8:  uint32(0xed627dae),
	9:  uint32(0x88d14467),
	10: uint32(0xd7bbfe6a),
	11: uint32(0xec447f11),
	12: uint32(0x8e7ea170),
	13: uint32(0x6427800e),
	14: uint32(0x4d47bae0),
	15: uint32(0x09fe548f),
	16: uint32(0x83852d0f),
	17: uint32(0x30362f1a),
	18: uint32(0x7b5a9cc3),
	19: uint32(0x31fec169),
	20: uint32(0x9fec022a),
	21: uint32(0x6c8dedc4),
	22: uint32(0x15d6874d),
	23: uint32(0x5fde7a4e),
	24: uint32(0xbad90e37),
	25: uint32(0x2e4e5eef),
	26: uint32(0x4eaba214),
	27: uint32(0xa8a472c0),
	28: uint32(0x429a969e),
	29: uint32(0x148d302a),
	30: uint32(0xc40ba6d0),
	31: uint32(0xc4e22c3c),
}

var _crc32tab uintptr

/*
** We are compiling as part of the core.
** TIP430 style zipfs prefix
 */

/*
 * Various constants and offsets found in ZIP archive files
 */

/*
 * Local header of ZIP archive member (at very beginning of each member).
 * C can't express this structure type even close to portably (thanks for
 * nothing, Clang and MSVC).
 */
type ZipLocalEntryOffsets = int32

const ZIP_LOCAL_SIG_OFFS = 0
const /* sig field offset */
ZIP_LOCAL_VERSION_OFFS = 4
const /* version field offset */
ZIP_LOCAL_FLAGS_OFFS = 6
const /* flags field offset */
ZIP_LOCAL_COMPMETH_OFFS = 8
const /* compMethod field offset */
ZIP_LOCAL_MTIME_OFFS = 10
const /* modTime field offset */
ZIP_LOCAL_MDATE_OFFS = 12
const /* modDate field offset */
ZIP_LOCAL_CRC32_OFFS = 14
const /* crc32 field offset */
ZIP_LOCAL_COMPLEN_OFFS = 18
const /* compLen field offset */
ZIP_LOCAL_UNCOMPLEN_OFFS = 22
const /* uncompLen field offset */
ZIP_LOCAL_PATHLEN_OFFS = 26
const /* pathLen field offset */
ZIP_LOCAL_EXTRALEN_OFFS = 28
const /* extraLen field offset */
ZIP_LOCAL_HEADER_LEN = 30

type ZipLocalFlags = int32

const ZIP_LOCAL_FLAGS_UTF8 = 2048

/*
 * Central header of ZIP archive member at end of ZIP file.
 * C can't express this structure type even close to portably (thanks for
 * nothing, Clang and MSVC).
 */
type ZipCentralEntryOffsets = int32

const ZIP_CENTRAL_SIG_OFFS = 0
const /* sig field offset */
ZIP_CENTRAL_VERSIONMADE_OFFS = 4
const /* versionMade field offset */
ZIP_CENTRAL_VERSION_OFFS = 6
const /* version field offset */
ZIP_CENTRAL_FLAGS_OFFS = 8
const /* flags field offset */
ZIP_CENTRAL_COMPMETH_OFFS = 10
const /* compMethod field offset */
ZIP_CENTRAL_MTIME_OFFS = 12
const /* modTime field offset */
ZIP_CENTRAL_MDATE_OFFS = 14
const /* modDate field offset */
ZIP_CENTRAL_CRC32_OFFS = 16
const /* crc32 field offset */
ZIP_CENTRAL_COMPLEN_OFFS = 20
const /* compLen field offset */
ZIP_CENTRAL_UNCOMPLEN_OFFS = 24
const /* uncompLen field offset */
ZIP_CENTRAL_PATHLEN_OFFS = 28
const /* pathLen field offset */
ZIP_CENTRAL_EXTRALEN_OFFS = 30
const /* extraLen field offset */
ZIP_CENTRAL_FCOMMENTLEN_OFFS = 32
const /* commentLen field offset */
ZIP_CENTRAL_DISKFILE_OFFS = 34
const /* diskFile field offset */
ZIP_CENTRAL_IATTR_OFFS = 36
const /* intAttr field offset */
ZIP_CENTRAL_EATTR_OFFS = 38
const /* extAttr field offset */
ZIP_CENTRAL_LOCALHDR_OFFS = 42
const /* localHeaderOffset field offset */
ZIP_CENTRAL_HEADER_LEN = 46

/*
 * Central end signature at very end of ZIP file.
 * C can't express this structure type even close to portably (thanks for
 * nothing, Clang and MSVC).
 */
type ZipCentralMainOffsets = int32

const ZIP_CENTRAL_END_SIG_OFFS = 0
const /* sig field offset */
ZIP_CENTRAL_DISKNO_OFFS = 4
const /* diskNum field offset */
ZIP_CENTRAL_DISKDIR_OFFS = 6
const /* diskDir field offset */
ZIP_CENTRAL_ENTS_OFFS = 8
const /* entriesOffset field offset */
ZIP_CENTRAL_TOTALENTS_OFFS = 10
const /* totalEntries field offset */
ZIP_CENTRAL_DIRSIZE_OFFS = 12
const /* dirSize field offset */
ZIP_CENTRAL_DIRSTART_OFFS = 16
const /* dirStart field offset */
ZIP_CENTRAL_COMMENTLEN_OFFS = 20
const /* commentLen field offset */
ZIP_CENTRAL_END_LEN = 22

type ZipCompressionMethods = int32

const ZIP_COMPMETH_STORED = 0
const ZIP_COMPMETH_DEFLATED = 8

/*
 * Mutex to protect localtime(3) when no reentrant version available.
 */

/*
 * Forward declaration.
 */

type TZipEntry1 = struct {
	Fname               uintptr
	FzipFilePtr         uintptr
	Foffset             Tsize_t
	FnumBytes           int32
	FnumCompressedBytes int32
	FcompressMethod     int32
	FisDirectory        int32
	Fdepth              int32
	Fcrc32              int32
	Ftimestamp          int32
	FisEncrypted        int32
	Fflags              int32
	Fdata               uintptr
	Fnext               uintptr
	Ftnext              uintptr
}

/*
 * In-core description of mounted ZIP archive file.
 */

type TZipFile = struct {
	Fname            uintptr
	FnameLength      Tsize_t
	FisMemBuffer     uint8
	Fchan1           TTcl_Channel
	Fdata            uintptr
	Flength          Tsize_t
	FptrToFree       uintptr
	FnumFiles        Tsize_t
	FbaseOffset      Tsize_t
	FpassOffset      Tsize_t
	FdirectoryOffset Tsize_t
	FdirectorySize   Tsize_t
	FpassBuf         [264]uint8
	FnumOpen         Tsize_t
	Fentries         uintptr
	FtopEnts         uintptr
	FmountPoint      uintptr
	FmountPointLen   TTcl_Size
}

/*
 * In-core description of file contained in mounted ZIP archive.
 */

type TZipEntry = struct {
	Fname               uintptr
	FzipFilePtr         uintptr
	Foffset             Tsize_t
	FnumBytes           int32
	FnumCompressedBytes int32
	FcompressMethod     int32
	FisDirectory        int32
	Fdepth              int32
	Fcrc32              int32
	Ftimestamp          int32
	FisEncrypted        int32
	Fflags              int32
	Fdata               uintptr
	Fnext               uintptr
	Ftnext              uintptr
}

type ZipEntryFlags = int32

const ZE_F_CRC_COMPARED = 1
const /* If 1, the CRC has been compared. */
ZE_F_CRC_CORRECT = 2
const /* Only meaningful if ZE_F_CRC_COMPARED is 1 */
ZE_F_VOLUME = 4

/*
 * File channel for file contained in mounted ZIP archive.
 *
 * Regarding data buffers:
 * For READ-ONLY files that are not encrypted and not compressed (zip STORE
 * method), ubuf points directly to the mapped zip file data in memory. No
 * additional storage is allocated and so ubufToFree is NULL.
 *
 * In all other combinations of compression and encryption or if channel is
 * writable, storage is allocated for the decrypted and/or uncompressed data
 * and a pointer to it is stored in ubufToFree and ubuf. When channel is
 * closed, ubufToFree is freed if not NULL. ubuf is irrelevant since it may
 * or may not point to allocated storage as above.
 */

type TZipChannel = struct {
	FzipFilePtr  uintptr
	FzipEntryPtr uintptr
	FmaxWrite    TTcl_Size
	FnumBytes    TTcl_Size
	Fcursor      TTcl_Size
	Fubuf        uintptr
	FubufToFree  uintptr
	FubufSize    TTcl_Size
	Fiscompr     int32
	FisDirectory int32
	FisEncrypted int32
	Fmode        int32
	Fkeys        [3]uint64
}

func _ZipChannelWritable(tls *libc.TLS, info uintptr) (r int32) {
	return libc.BoolInt32((*TZipChannel)(unsafe.Pointer(info)).Fmode&(libc.Int32FromInt32(O_WRONLY)|libc.Int32FromInt32(O_RDWR)) != 0)
}

/*
 * Global variables.
 *
 * Most are kept in single ZipFS struct. When build with threading support
 * this struct is protected by the ZipFSMutex (see below).
 *
 * The "fileHash" component is the process-wide global table of all known ZIP
 * archive members in all mounted ZIP archives.
 *
 * The "zipHash" components is the process wide global table of all mounted
 * ZIP archive files.
 */

var _ZipFS = struct {
	Finitialized           int32
	Flock                  int32
	Fwaiters               int32
	Fwrmax                 int32
	FfallbackEntryEncoding uintptr
	FidCount               int32
	FfileHash              TTcl_HashTable
	FzipHash               TTcl_HashTable
}{
	Fwrmax: int32(INT_MAX),
}

/*
 * For password rotation.
 */

var _pwrot = [17]uint8{0, 128, '@', 192, ' ', 160, '`', 224, 16, 144, 'P', 208, '0', 176, 'p', 240}

var _zipfs_literal_tcl_library = libc.UintptrFromInt32(0)

/*
 * Define the ZIP filesystem dispatch table.
 */

var _zipfsFilesystem = TTcl_Filesystem{
	FtypeName:        __ccgo_ts + 5934,
	FstructureLength: int64(248),
	Fversion:         libc.UintptrFromInt32(0x2),
}

func init() {
	p := unsafe.Pointer(&_zipfsFilesystem)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_ZipFSPathInFilesystemProc)
	*(*uintptr)(unsafe.Add(p, 72)) = __ccgo_fp(_ZipFSFilesystemPathTypeProc)
	*(*uintptr)(unsafe.Add(p, 80)) = __ccgo_fp(_ZipFSFilesystemSeparatorProc)
	*(*uintptr)(unsafe.Add(p, 88)) = __ccgo_fp(_ZipFSStatProc)
	*(*uintptr)(unsafe.Add(p, 96)) = __ccgo_fp(_ZipFSAccessProc)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(_ZipFSOpenFileChannelProc)
	*(*uintptr)(unsafe.Add(p, 112)) = __ccgo_fp(_ZipFSMatchInDirectoryProc)
	*(*uintptr)(unsafe.Add(p, 136)) = __ccgo_fp(_ZipFSListVolumesProc)
	*(*uintptr)(unsafe.Add(p, 144)) = __ccgo_fp(_ZipFSFileAttrStringsProc)
	*(*uintptr)(unsafe.Add(p, 152)) = __ccgo_fp(_ZipFSFileAttrsGetProc)
	*(*uintptr)(unsafe.Add(p, 160)) = __ccgo_fp(_ZipFSFileAttrsSetProc)
	*(*uintptr)(unsafe.Add(p, 224)) = __ccgo_fp(_ZipFSLoadFile)
}

// C documentation
//
//	/*
//	 * The channel type/driver definition used for ZIP archive members.
//	 */
var _zipChannelType = TTcl_ChannelType{
	FtypeName: __ccgo_ts + 72855,
	Fversion:  libc.UintptrFromInt32(0x5),
}

func init() {
	p := unsafe.Pointer(&_zipChannelType)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_ZipChannelRead)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_ZipChannelWrite)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(_ZipChannelWatchChannel)
	*(*uintptr)(unsafe.Add(p, 72)) = __ccgo_fp(_ZipChannelGetFile)
	*(*uintptr)(unsafe.Add(p, 80)) = __ccgo_fp(_ZipChannelClose)
	*(*uintptr)(unsafe.Add(p, 112)) = __ccgo_fp(_ZipChannelWideSeek)
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * TclIsZipfsPath --
//	 *
//	 *    Checks if the passed path has a zipfs volume prefix.
//	 *
//	 * Results:
//	 *    0 if not a zipfs path
//	 *    else the length of the zipfs volume prefix
//	 *
//	 * Side effects:
//	 *    None.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func XTclIsZipfsPath(tls *libc.TLS, path uintptr) (r int32) {
	var i int32
	_ = i
	i = 0
	for {
		if !(i < int32(ZIPFS_VOLUME_LEN)) {
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(i)))) != libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 72859 + uintptr(i)))) && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(i)))) != int32('\\') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(__ccgo_ts + 72859 + uintptr(i)))) != int32('/')) {
			return 0
		}
		goto _1
	_1:
		;
		i++
	}
	return int32(ZIPFS_VOLUME_LEN)
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipReadInt, ZipReadShort, ZipWriteInt, ZipWriteShort --
 *
 *	Inline functions to read and write little-endian 16 and 32 bit
 *	integers from/to buffers representing parts of ZIP archives.
 *
 *	These take bufferStart and bufferEnd pointers, which are used to
 *	maintain a guarantee that out-of-bounds accesses don't happen when
 *	reading or writing critical directory structures.
 *
 *-------------------------------------------------------------------------
 */

func _ZipReadInt(tls *libc.TLS, bufferStart uintptr, bufferEnd uintptr, ptr uintptr) (r uint32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	if ptr < bufferStart || ptr+uintptr(4) > bufferEnd {
		XTcl_Panic(tls, __ccgo_ts+72869, libc.VaList(bp+8, bufferStart, bufferEnd, ptr))
	}
	return libc.Uint32FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ptr)))|libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ptr + 1)))<<int32(8)|libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ptr + 2)))<<int32(16)) | uint32(*(*uint8)(unsafe.Pointer(ptr + 3)))<<int32(24)
}

func _ZipReadShort(tls *libc.TLS, bufferStart uintptr, bufferEnd uintptr, ptr uintptr) (r uint16) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	if ptr < bufferStart || ptr+uintptr(2) > bufferEnd {
		XTcl_Panic(tls, __ccgo_ts+72917, libc.VaList(bp+8, bufferStart, bufferEnd, ptr))
	}
	return libc.Uint16FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ptr))) | libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(ptr + 1)))<<int32(8))
}

func _ZipWriteInt(tls *libc.TLS, bufferStart uintptr, bufferEnd uintptr, ptr uintptr, value uint32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	if ptr < bufferStart || ptr+uintptr(4) > bufferEnd {
		XTcl_Panic(tls, __ccgo_ts+72965, libc.VaList(bp+8, bufferStart, bufferEnd, ptr))
	}
	*(*uint8)(unsafe.Pointer(ptr)) = uint8(value & uint32(0xff))
	*(*uint8)(unsafe.Pointer(ptr + 1)) = uint8(value >> int32(8) & uint32(0xff))
	*(*uint8)(unsafe.Pointer(ptr + 2)) = uint8(value >> int32(16) & uint32(0xff))
	*(*uint8)(unsafe.Pointer(ptr + 3)) = uint8(value >> int32(24) & uint32(0xff))
}

func _ZipWriteShort(tls *libc.TLS, bufferStart uintptr, bufferEnd uintptr, ptr uintptr, value uint16) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	if ptr < bufferStart || ptr+uintptr(2) > bufferEnd {
		XTcl_Panic(tls, __ccgo_ts+73014, libc.VaList(bp+8, bufferStart, bufferEnd, ptr))
	}
	*(*uint8)(unsafe.Pointer(ptr)) = libc.Uint8FromInt32(libc.Int32FromUint16(value) & int32(0xff))
	*(*uint8)(unsafe.Pointer(ptr + 1)) = libc.Uint8FromInt32(libc.Int32FromUint16(value) >> int32(8) & int32(0xff))
}

/*
 *-------------------------------------------------------------------------
 *
 * ReadLock, WriteLock, Unlock --
 *
 *	POSIX like rwlock functions to support multiple readers and single
 *	writer on internal structs.
 *
 *	Limitations:
 *	 - a read lock cannot be promoted to a write lock
 *	 - a write lock may not be nested
 *
 *-------------------------------------------------------------------------
 */
var _ZipFSMutex TTcl_Mutex

var _ZipFSCond TTcl_Condition

func _ReadLock(tls *libc.TLS) {
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_ZipFSMutex)))
	for _ZipFS.Flock < 0 {
		_ZipFS.Fwaiters++
		XTcl_ConditionWait(tls, uintptr(unsafe.Pointer(&_ZipFSCond)), uintptr(unsafe.Pointer(&_ZipFSMutex)), libc.UintptrFromInt32(0))
		_ZipFS.Fwaiters--
	}
	_ZipFS.Flock++
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_ZipFSMutex)))
}

func _WriteLock(tls *libc.TLS) {
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_ZipFSMutex)))
	for _ZipFS.Flock != 0 {
		_ZipFS.Fwaiters++
		XTcl_ConditionWait(tls, uintptr(unsafe.Pointer(&_ZipFSCond)), uintptr(unsafe.Pointer(&_ZipFSMutex)), libc.UintptrFromInt32(0))
		_ZipFS.Fwaiters--
	}
	_ZipFS.Flock = -int32(1)
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_ZipFSMutex)))
}

func _Unlock(tls *libc.TLS) {
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_ZipFSMutex)))
	if _ZipFS.Flock > 0 {
		_ZipFS.Flock--
	} else {
		if _ZipFS.Flock < 0 {
			_ZipFS.Flock = 0
		}
	}
	if _ZipFS.Flock == 0 && _ZipFS.Fwaiters > 0 {
		XTcl_ConditionNotify(tls, uintptr(unsafe.Pointer(&_ZipFSCond)))
	}
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_ZipFSMutex)))
}

/*
 *-------------------------------------------------------------------------
 *
 * DosTimeDate, ToDosTime, ToDosDate --
 *
 *	Functions to perform conversions between DOS time stamps and POSIX
 *	time_t.
 *
 *-------------------------------------------------------------------------
 */

func _DosTimeDate(tls *libc.TLS, dosDate int32, dosTime int32) (r Ttime_t) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var ret Ttime_t
	var _ /* tm at bp+0 */ Ttm
	_ = ret
	libc.Xmemset(tls, bp, 0, uint64(56))
	(*(*Ttm)(unsafe.Pointer(bp))).Ftm_isdst = -int32(1) /* let mktime() deal with DST */
	(*(*Ttm)(unsafe.Pointer(bp))).Ftm_year = dosDate&int32(0xfe00)>>int32(9) + int32(80)
	(*(*Ttm)(unsafe.Pointer(bp))).Ftm_mon = dosDate&int32(0x1e0)>>int32(5) - int32(1)
	(*(*Ttm)(unsafe.Pointer(bp))).Ftm_mday = dosDate & int32(0x1f)
	(*(*Ttm)(unsafe.Pointer(bp))).Ftm_hour = dosTime & int32(0xf800) >> int32(11)
	(*(*Ttm)(unsafe.Pointer(bp))).Ftm_min = dosTime & int32(0x7e0) >> int32(5)
	(*(*Ttm)(unsafe.Pointer(bp))).Ftm_sec = dosTime & int32(0x1f) << int32(1)
	ret = libc.Xmktime(tls, bp)
	if ret == int64(-libc.Int32FromInt32(1)) {
		/* fallback to 1980-01-01T00:00:00+00:00 (DOS epoch) */
		ret = libc.Int64FromInt32(315532800)
	}
	return ret
}

func _ToDosTime(tls *libc.TLS, _when Ttime_t) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	*(*Ttime_t)(unsafe.Pointer(bp)) = _when
	var tmp uintptr
	var _ /* tm at bp+8 */ Ttm
	_ = tmp
	/* Threaded, have reentrant API */
	tmp = bp + 8
	libc.Xlocaltime_r(tls, bp, tmp)
	return (*(*Ttm)(unsafe.Pointer(bp + 8))).Ftm_hour<<int32(11) | (*(*Ttm)(unsafe.Pointer(bp + 8))).Ftm_min<<int32(5) | (*(*Ttm)(unsafe.Pointer(bp + 8))).Ftm_sec>>int32(1)
}

func _ToDosDate(tls *libc.TLS, _when Ttime_t) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	*(*Ttime_t)(unsafe.Pointer(bp)) = _when
	var tmp uintptr
	var _ /* tm at bp+8 */ Ttm
	_ = tmp
	/* Threaded, have reentrant API */
	tmp = bp + 8
	libc.Xlocaltime_r(tls, bp, tmp)
	return ((*(*Ttm)(unsafe.Pointer(bp + 8))).Ftm_year-int32(80))<<int32(9) | ((*(*Ttm)(unsafe.Pointer(bp + 8))).Ftm_mon+int32(1))<<int32(5) | (*(*Ttm)(unsafe.Pointer(bp + 8))).Ftm_mday
}

/*
 *-------------------------------------------------------------------------
 *
 * CountSlashes --
 *
 *	This function counts the number of slashes in a pathname string.
 *
 * Results:
 *	Number of slashes found in string.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func _CountSlashes(tls *libc.TLS, string1 uintptr) (r Tsize_t) {
	var count Tsize_t
	var p uintptr
	_, _ = count, p
	count = uint64(0)
	p = string1
	for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('\000') {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('/') {
			count++
		}
		p++
	}
	return count
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * IsCryptHeaderValid --
//	 *
//	 *    Computes the validity of the encryption header CRC for a ZipEntry.
//	 *
//	 * Results:
//	 *    Returns 1 if the header is valid else 0.
//	 *
//	 * Side effects:
//	 *    None.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _IsCryptHeaderValid(tls *libc.TLS, z uintptr, cryptHeader uintptr) (r int32) {
	var dosTime int32
	_ = dosTime
	/*
	 * There are multiple possibilities. The last one or two bytes of the
	 * encryption header should match the last one or two bytes of the
	 * CRC of the file. Or the last byte of the encryption header should
	 * be the high order byte of the file time. Depending on the archiver
	 * and version, any of the might be in used. We follow libzip in checking
	 * only one byte against both the crc and the time. Note that by design
	 * the check generates high number of false positives in any case.
	 * Also, in case a check is passed when it should not, the final CRC
	 * calculation will (should) catch it. Only difference is it will be
	 * reported as a corruption error instead of incorrect password.
	 */
	dosTime = _ToDosTime(tls, int64((*TZipEntry)(unsafe.Pointer(z)).Ftimestamp))
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cryptHeader + 11))) == libc.Int32FromUint8(libc.Uint8FromInt32(dosTime>>libc.Int32FromInt32(8))) {
		/* Infozip style - Tested with test-password.zip */
		return int32(1)
	}
	/* DOS time did not match, may be CRC does */
	if (*TZipEntry)(unsafe.Pointer(z)).Fcrc32 != 0 {
		/* Pkware style - Tested with test-password2.zip */
		return libc.BoolInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cryptHeader + 11))) == libc.Int32FromUint8(libc.Uint8FromInt32((*TZipEntry)(unsafe.Pointer(z)).Fcrc32>>libc.Int32FromInt32(24))))
	}
	/* No CRC, no way to verify. Assume valid */
	return int32(1)
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * DecodeCryptHeader --
//	 *
//	 *    Decodes the crypt header and validates it.
//	 *
//	 * Results:
//	 *    TCL_OK on success, TCL_ERROR on failure.
//	 *
//	 * Side effects:
//	 *    On success, keys[] are updated. On failure, an error message is
//	 *    left in interp if not NULL.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _DecodeCryptHeader(tls *libc.TLS, interp uintptr, z uintptr, keys uintptr, cryptHeader uintptr) (r int32) {
	bp := tls.Alloc(320)
	defer tls.Free(320)
	/* From zip file content */
	var ch, i, len1 int32
	var _ /* encheader at bp+260 */ [12]uint8
	var _ /* passBuf at bp+0 */ [260]uint8
	_, _, _ = ch, i, len1
	len1 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TZipEntry)(unsafe.Pointer(z)).FzipFilePtr + 96))) & int32(0xFF)
	i = 0
	for {
		if !(i < len1) {
			break
		}
		ch = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TZipEntry)(unsafe.Pointer(z)).FzipFilePtr + 96 + uintptr(len1-i))))
		(*(*[260]uint8)(unsafe.Pointer(bp)))[i] = libc.Uint8FromInt32(ch&int32(0x0f) | libc.Int32FromUint8(_pwrot[ch>>int32(4)&int32(0x0f)]))
		goto _1
	_1:
		;
		i++
	}
	(*(*[260]uint8)(unsafe.Pointer(bp)))[i] = uint8('\000')
	_init_keys(tls, bp, keys, _crc32tab)
	libc.Xmemset(tls, bp, 0, uint64(260))
	libc.Xmemcpy(tls, bp+260, cryptHeader, uint64(ZIP_CRYPT_HDR_LEN))
	i = 0
	for {
		if !(i < int32(ZIP_CRYPT_HDR_LEN)) {
			break
		}
		ch = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(cryptHeader + uintptr(i))))
		ch ^= _decrypt_byte(tls, keys, _crc32tab)
		(*(*[12]uint8)(unsafe.Pointer(bp + 260)))[i] = libc.Uint8FromInt32(ch)
		_update_keys(tls, keys, _crc32tab, ch)
		goto _2
	_2:
		;
		i++
	}
	if !(_IsCryptHeaderValid(tls, z, bp+260) != 0) {
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+73063, int64(-int32(1))))
		}
		if interp != 0 {
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+280, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+73086, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *-------------------------------------------------------------------------
 *
 * DecodeZipEntryText --
 *
 *	Given a sequence of bytes from an entry in a ZIP central directory,
 *	convert that into a Tcl string. This is complicated because we don't
 *	actually know what encoding is in use! So we try to use UTF-8, and if
 *	that goes wrong, we fall back to a user-specified encoding, or to an
 *	encoding we specify (Windows code page 437), or to ISO 8859-1 if
 *	absolutely nothing else works.
 *
 *	During Tcl startup, we skip the user-specified encoding and cp437, as
 *	we may well not have any loadable encodings yet. Tcl's own library
 *	files ought to be using ASCII filenames.
 *
 * Results:
 *	The decoded filename; the filename is owned by the argument DString.
 *
 * Side effects:
 *	Updates dstPtr.
 *
 *-------------------------------------------------------------------------
 */

func _DecodeZipEntryText(tls *libc.TLS, inputBytes uintptr, inputLength uint32, dstPtr uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Must have been initialized by caller! */
	var converted, dst, src uintptr
	var dstLen, flags, result, soFar, srcLen int32
	var encoding TTcl_Encoding
	var _ /* dstWrote at bp+12 */ int32
	var _ /* srcRead at bp+8 */ int32
	var _ /* state at bp+0 */ TTcl_EncodingState
	_, _, _, _, _, _, _, _, _ = converted, dst, dstLen, encoding, flags, result, soFar, src, srcLen
	srcLen = libc.Int32FromUint32(inputLength)
	if inputLength < uint32(1) {
		return (*TTcl_DString)(unsafe.Pointer(dstPtr)).Fstring1
	}
	/*
	 * We can't use Tcl_ExternalToUtfDString at this point; it has no way to
	 * fail. So we use this modified version of it that can report encoding
	 * errors to us (so we can fall back to something else).
	 *
	 * The utf-8 encoding is implemented internally, and so is guaranteed to
	 * be present.
	 */
	src = inputBytes
	dst = (*TTcl_DString)(unsafe.Pointer(dstPtr)).Fstring1
	dstLen = int32((*TTcl_DString)(unsafe.Pointer(dstPtr)).FspaceAvl - int64(1))
	flags = libc.Int32FromInt32(TCL_ENCODING_START) | libc.Int32FromInt32(TCL_ENCODING_END) /* Special flag! */
	for int32(1) != 0 {
		result = XTcl_ExternalToUtf(tls, libc.UintptrFromInt32(0), XtclUtf8Encoding, src, int64(srcLen), flags, bp, dst, int64(dstLen), bp+8, bp+12, libc.UintptrFromInt32(0))
		soFar = int32(int64(dst+uintptr(*(*int32)(unsafe.Pointer(bp + 12)))) - int64((*TTcl_DString)(unsafe.Pointer(dstPtr)).Fstring1))
		if result == TCL_OK {
			XTcl_DStringSetLength(tls, dstPtr, int64(soFar))
			return (*TTcl_DString)(unsafe.Pointer(dstPtr)).Fstring1
		} else {
			if result != -int32(4) {
				break
			}
		}
		flags &= ^libc.Int32FromInt32(TCL_ENCODING_START)
		src += uintptr(*(*int32)(unsafe.Pointer(bp + 8)))
		srcLen -= *(*int32)(unsafe.Pointer(bp + 8))
		if (*TTcl_DString)(unsafe.Pointer(dstPtr)).Flength == 0 {
			XTcl_DStringSetLength(tls, dstPtr, int64(dstLen))
		}
		XTcl_DStringSetLength(tls, dstPtr, int64(2)*(*TTcl_DString)(unsafe.Pointer(dstPtr)).Flength+int64(1))
		dst = (*TTcl_DString)(unsafe.Pointer(dstPtr)).Fstring1 + uintptr(soFar)
		dstLen = int32((*TTcl_DString)(unsafe.Pointer(dstPtr)).Flength - int64(soFar) - int64(1))
	}
	/*
	 * Something went wrong. Fall back to another encoding. Those *can* use
	 * Tcl_ExternalToUtfDString().
	 */
	encoding = libc.UintptrFromInt32(0)
	if _ZipFS.FfallbackEntryEncoding != 0 {
		encoding = XTcl_GetEncoding(tls, libc.UintptrFromInt32(0), _ZipFS.FfallbackEntryEncoding)
	}
	if !(encoding != 0) {
		encoding = XTcl_GetEncoding(tls, libc.UintptrFromInt32(0), __ccgo_ts+73095)
	}
	if !(encoding != 0) {
		/*
		 * Fallback to internal encoding that always converts all bytes.
		 * Should only happen when a filename isn't UTF-8 and we've not got
		 * our encodings initialised for some reason.
		 */
		encoding = XTcl_GetEncoding(tls, libc.UintptrFromInt32(0), __ccgo_ts+29173)
	}
	converted = XTcl_ExternalToUtfDString(tls, encoding, inputBytes, libc.Int64FromUint32(inputLength), dstPtr)
	XTcl_FreeEncoding(tls, encoding)
	return converted
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * NormalizeMountPoint --
//	 *
//	 *    Converts the passed path into a normalized zipfs mount point
//	 *    of the form //zipfs:/some/path. On Windows any \ path separators
//	 *    are converted to /.
//	 *
//	 *    Mount points with a volume will raise an error unless the volume is
//	 *    zipfs root. Thus D:/foo is not a valid mount point.
//	 *
//	 *    Relative paths and absolute paths without a volume are mapped under
//	 *    the zipfs root.
//	 *
//	 *    The empty string is mapped to the zipfs root.
//	 *
//	 *    dsPtr is initialized by the function and must be cleared by caller
//	 *    on a successful return.
//	 *
//	 * Results:
//	 *    TCL_OK on success with normalized mount path in dsPtr
//	 *    TCL_ERROR on fail with error message in interp if not NULL
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _NormalizeMountPoint(tls *libc.TLS, interp uintptr, mountPath uintptr, dsPtr uintptr) (r int32) {
	bp := tls.Alloc(288)
	defer tls.Free(288) /* Must be initialized by caller! */
	var _objPtr, _objPtr1, _objPtr2, joinedPath, normalizedObj, normalizedPath, unnormalizedObj, v2, v4, v5, v7 uintptr
	var v1, v3, v6 TTcl_Size
	var _ /* dsJoin at bp+24 */ TTcl_DString
	var _ /* joiner at bp+0 */ [2]uintptr
	var _ /* normalizedLen at bp+16 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, joinedPath, normalizedObj, normalizedPath, unnormalizedObj, v1, v2, v3, v4, v5, v6, v7
	/*
	 * Several things need to happen here
	 * - Absolute paths containing volumes (drive letter or UNC) raise error
	 *   except of course if the volume is zipfs root
	 * - \ -> / and // -> / conversions (except if UNC which is error)
	 * - . and .. have to be dealt with
	 * The first is explicitly checked, the others are dealt with a
	 * combination file join and normalize. Easier than doing it ourselves
	 * and not performance sensitive anyways.
	 */
	(*(*[2]uintptr)(unsafe.Pointer(bp)))[0] = __ccgo_ts + 72859
	(*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)] = mountPath
	XTcl_DStringInit(tls, bp+24)
	joinedPath = XTcl_JoinPath(tls, int64(2), bp, bp+24)
	/* Now joinedPath has all \ -> / and // -> / (except UNC) converted. */
	if !(libc.Xstrncmp(tls, __ccgo_ts+72859, joinedPath, uint64(ZIPFS_VOLUME_LEN)) != 0) {
		unnormalizedObj = XTcl_DStringToObj(tls, bp+24)
	} else {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(joinedPath))) != int32('/') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(joinedPath + 1))) == int32('/') {
			/* mount path was D:/x, D:x or //unc */
			goto invalidMountPath
		}
		unnormalizedObj = XTcl_ObjPrintf(tls, __ccgo_ts+73101, libc.VaList(bp+256, joinedPath+uintptr(1)))
	}
	(*TTcl_Obj)(unsafe.Pointer(unnormalizedObj)).FrefCount++
	normalizedObj = XTcl_FSGetNormalizedPath(tls, interp, unnormalizedObj)
	if normalizedObj == libc.UintptrFromInt32(0) {
		_objPtr = unnormalizedObj
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		goto errorReturn
	}
	(*TTcl_Obj)(unsafe.Pointer(normalizedObj)).FrefCount++ /* BEFORE DecrRefCount on unnormalizedObj */
	_objPtr1 = unnormalizedObj
	v4 = _objPtr1
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	if v3 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	/* normalizedObj owned by Tcl!! Do NOT DecrRef without an IncrRef */
	if (*TTcl_Obj)(unsafe.Pointer(normalizedObj)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = (*TTcl_Obj)(unsafe.Pointer(normalizedObj)).Flength
		v5 = (*TTcl_Obj)(unsafe.Pointer(normalizedObj)).Fbytes
	} else {
		v5 = XTcl_GetStringFromObj(tls, normalizedObj, bp+16)
	}
	normalizedPath = v5
	XTcl_DStringFree(tls, bp+24)
	XTcl_DStringAppend(tls, dsPtr, normalizedPath, *(*TTcl_Size)(unsafe.Pointer(bp + 16)))
	_objPtr2 = normalizedObj
	v7 = _objPtr2
	v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
	*(*TTcl_Size)(unsafe.Pointer(v7))--
	if v6 <= int64(1) {
		XTclFreeObj(tls, _objPtr2)
	}
	return TCL_OK
	goto invalidMountPath
invalidMountPath:
	;
	if interp != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+73113, libc.VaList(bp+256, mountPath)))
		if interp != 0 {
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+256, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+73137, libc.UintptrFromInt32(0)))
		}
	}
	goto errorReturn
errorReturn:
	;
	XTcl_DStringFree(tls, bp+24)
	return int32(TCL_ERROR)
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * MapPathToZipfs --
//	 *
//	 *    Maps a path as stored in a zip archive to its normalized location
//	 *    under a given zipfs mount point. Relative paths and Unix style
//	 *    absolute paths go directly under the mount point. Volume relative
//	 *    paths and absolute paths that have a volume (drive or UNC) are
//	 *    stripped of the volume before joining the mount point.
//	 *
//	 * Results:
//	 *    Pointer to normalized path.
//	 *
//	 * Side effects:
//	 *    Stores mapped path in dsPtr.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _MapPathToZipfs(tls *libc.TLS, interp uintptr, mountPath uintptr, path uintptr, dsPtr uintptr) (r uintptr) {
	bp := tls.Alloc(272)
	defer tls.Free(272) /* Must be initialized and cleared
	 * by caller */
	var _objPtr, _objPtr1, joinedPath, normalizedObj, normalizedPath, unnormalizedObj, v2, v3, v5 uintptr
	var v1, v4 TTcl_Size
	var _ /* dsJoin at bp+24 */ TTcl_DString
	var _ /* joiner at bp+0 */ [2]uintptr
	var _ /* normalizedLen at bp+16 */ TTcl_Size
	var _ /* numParts at bp+248 */ TTcl_Size
	var _ /* partsPtr at bp+256 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, joinedPath, normalizedObj, normalizedPath, unnormalizedObj, v1, v2, v3, v4, v5
	(*(*[2]uintptr)(unsafe.Pointer(bp)))[0] = mountPath
	(*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)] = path
	/* On Unix C:/foo/bat is not treated as absolute by JoinPath so check ourself */
	if *(*uint8)(unsafe.Pointer(path)) != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + 1))) == int32(':') {
		*(*uintptr)(unsafe.Pointer(bp + 1*8)) += uintptr(2)
	}
	XTcl_DStringInit(tls, bp+24)
	joinedPath = XTcl_JoinPath(tls, int64(2), bp, bp+24)
	if libc.Xstrncmp(tls, __ccgo_ts+72859, joinedPath, uint64(ZIPFS_VOLUME_LEN)) != 0 {
		XTcl_SplitPath(tls, path, bp+248, bp+256)
		XTcl_DStringFree(tls, bp+24)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 256)))) = mountPath
		XTcl_JoinPath(tls, *(*TTcl_Size)(unsafe.Pointer(bp + 248)), *(*uintptr)(unsafe.Pointer(bp + 256)), bp+24)
		XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 256)))
	}
	unnormalizedObj = XTcl_DStringToObj(tls, bp+24) /* Also resets dsJoin */
	(*TTcl_Obj)(unsafe.Pointer(unnormalizedObj)).FrefCount++
	normalizedObj = XTcl_FSGetNormalizedPath(tls, interp, unnormalizedObj)
	if normalizedObj == libc.UintptrFromInt32(0) {
		/* Should not happen but continue... */
		normalizedObj = unnormalizedObj
	}
	(*TTcl_Obj)(unsafe.Pointer(normalizedObj)).FrefCount++ /* BEFORE DecrRefCount on unnormalizedObj */
	_objPtr = unnormalizedObj
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	/* normalizedObj owned by Tcl!! Do NOT DecrRef without an IncrRef */
	if (*TTcl_Obj)(unsafe.Pointer(normalizedObj)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = (*TTcl_Obj)(unsafe.Pointer(normalizedObj)).Flength
		v3 = (*TTcl_Obj)(unsafe.Pointer(normalizedObj)).Fbytes
	} else {
		v3 = XTcl_GetStringFromObj(tls, normalizedObj, bp+16)
	}
	normalizedPath = v3
	XTcl_DStringAppend(tls, dsPtr, normalizedPath, *(*TTcl_Size)(unsafe.Pointer(bp + 16)))
	_objPtr1 = normalizedObj
	v5 = _objPtr1
	v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
	*(*TTcl_Size)(unsafe.Pointer(v5))--
	if v4 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	return (*TTcl_DString)(unsafe.Pointer(dsPtr)).Fstring1
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSLookup --
 *
 *	This function returns the ZIP entry struct corresponding to the ZIP
 *	archive member of the given file name. Caller must hold the right
 *	lock.
 *
 * Results:
 *	Returns the pointer to ZIP entry struct or NULL if the the given file
 *	name could not be found in the global list of ZIP archive members.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSLookup(tls *libc.TLS, filename uintptr) (r uintptr) {
	var hPtr, z uintptr
	_, _ = hPtr, z
	z = libc.UintptrFromInt32(0)
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ZipFS)) + 32)).FfindProc})))(tls, uintptr(unsafe.Pointer(&_ZipFS))+32, filename)
	if hPtr != 0 {
		z = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
	}
	return z
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSLookupZip --
 *
 *	This function gets the structure for a mounted ZIP archive.
 *
 * Results:
 *	Returns a pointer to the structure, or NULL if the file is ZIP file is
 *	unknown/not mounted.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSLookupZip(tls *libc.TLS, mountPoint uintptr) (r uintptr) {
	var hPtr, zf uintptr
	_, _ = hPtr, zf
	zf = libc.UintptrFromInt32(0)
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ZipFS)) + 136)).FfindProc})))(tls, uintptr(unsafe.Pointer(&_ZipFS))+136, mountPoint)
	if hPtr != 0 {
		zf = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
	}
	return zf
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * ContainsMountPoint --
//	 *
//	 *    Check if there is a mount point anywhere under the specified path.
//	 *    Although the function will work for any path, for efficiency reasons
//	 *    it should be called only after checking ZipFSLookup does not find
//	 *    the path.
//	 *
//	 *    Caller must hold read lock before calling.
//	 *
//	 * Results:
//	 *    1 - there is at least one mount point under the path
//	 *    0 - otherwise
//	 *
//	 * Side effects:
//	 *    None.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func _ContainsMountPoint(tls *libc.TLS, path uintptr, pathLen int32) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var hPtr, z, zf uintptr
	var lenz int32
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _ = hPtr, lenz, z, zf
	if _ZipFS.FzipHash.FnumEntries == 0 {
		return 0
	}
	if pathLen < 0 {
		pathLen = libc.Int32FromUint64(libc.Xstrlen(tls, path))
	}
	/*
	 * We are looking for the case where the path is //zipfs:/a/b
	 * and there is a mount point //zipfs:/a/b/c/.. below it
	 */
	hPtr = XTcl_FirstHashEntry(tls, uintptr(unsafe.Pointer(&_ZipFS))+136, bp)
	for {
		if !(hPtr != 0) {
			break
		}
		zf = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		if (*TZipFile)(unsafe.Pointer(zf)).FmountPointLen == 0 {
			z = (*TZipFile)(unsafe.Pointer(zf)).FtopEnts
			for {
				if !(z != 0) {
					break
				}
				lenz = libc.Int32FromUint64(libc.Xstrlen(tls, (*TZipEntry)(unsafe.Pointer(z)).Fname))
				if lenz >= pathLen && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TZipEntry)(unsafe.Pointer(z)).Fname + uintptr(pathLen)))) == int32('/') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TZipEntry)(unsafe.Pointer(z)).Fname + uintptr(pathLen)))) == int32('\000')) && libc.Xstrncmp(tls, (*TZipEntry)(unsafe.Pointer(z)).Fname, path, libc.Uint64FromInt32(pathLen)) == 0 {
					return int32(1)
				}
				goto _2
			_2:
				;
				z = (*TZipEntry)(unsafe.Pointer(z)).Ftnext
			}
		} else {
			if (*TZipFile)(unsafe.Pointer(zf)).FmountPointLen >= int64(pathLen) && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TZipFile)(unsafe.Pointer(zf)).FmountPoint + uintptr(pathLen)))) == int32('/') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TZipFile)(unsafe.Pointer(zf)).FmountPoint + uintptr(pathLen)))) == int32('\000') || pathLen == int32(ZIPFS_VOLUME_LEN)) && libc.Xstrncmp(tls, (*TZipFile)(unsafe.Pointer(zf)).FmountPoint, path, libc.Uint64FromInt32(pathLen)) == 0 {
				/* Matched standard mount */
				return int32(1)
			}
		}
		goto _1
	_1:
		;
		hPtr = XTcl_NextHashEntry(tls, bp)
	}
	return 0
}

/*
 *-------------------------------------------------------------------------
 *
 * AllocateZipFile, AllocateZipEntry, AllocateZipChannel --
 *
 *	Allocates the memory for a datastructure. Always ensures that it is
 *	zeroed out for safety.
 *
 * Returns:
 *	The allocated structure, or NULL if allocate fails.
 *
 * Side effects:
 *	The interpreter result may be written to on error. Which might fail
 *	(for ZipFile) in a low-memory situation. Always panics if ZipEntry
 *	allocation fails.
 *
 *-------------------------------------------------------------------------
 */

func _AllocateZipFile(tls *libc.TLS, interp uintptr, mountPointNameLength Tsize_t) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var size Tsize_t
	var zf uintptr
	_, _ = size, zf
	size = uint64(400) + mountPointNameLength + uint64(1)
	zf = XTclpAlloc(tls, size)
	if !(zf != 0) {
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+1638, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+73148, libc.UintptrFromInt32(0)))
		}
	} else {
		libc.Xmemset(tls, zf, 0, size)
	}
	return zf
}

func _AllocateZipEntry(tls *libc.TLS) (r uintptr) {
	var z uintptr
	_ = z
	z = XTcl_Alloc(tls, uint64(88))
	libc.Xmemset(tls, z, 0, uint64(88))
	return z
}

func _AllocateZipChannel(tls *libc.TLS, interp uintptr) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var zc uintptr
	_ = zc
	zc = XTclpAlloc(tls, uint64(104))
	if !(zc != 0) {
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+1638, int64(-int32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+73148, libc.UintptrFromInt32(0)))
		}
	} else {
		libc.Xmemset(tls, zc, 0, uint64(104))
	}
	return zc
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSCloseArchive --
 *
 *	This function closes a mounted ZIP archive file.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	A memory mapped ZIP archive is unmapped, allocated memory is released.
 *	The ZipFile pointer is *NOT* deallocated by this function.
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSCloseArchive(tls *libc.TLS, interp uintptr, zf uintptr) {
	if (*TZipFile)(unsafe.Pointer(zf)).FnameLength != 0 {
		XTclpFree(tls, (*TZipFile)(unsafe.Pointer(zf)).Fname)
	}
	if (*TZipFile)(unsafe.Pointer(zf)).FisMemBuffer != 0 {
		/* Pointer to memory */
		if (*TZipFile)(unsafe.Pointer(zf)).FptrToFree != 0 {
			XTclpFree(tls, (*TZipFile)(unsafe.Pointer(zf)).FptrToFree)
			(*TZipFile)(unsafe.Pointer(zf)).FptrToFree = libc.UintptrFromInt32(0)
		}
		(*TZipFile)(unsafe.Pointer(zf)).Fdata = libc.UintptrFromInt32(0)
		return
	}
	/*
	 * Remove the memory mapping, if we have one.
	 */
	if (*TZipFile)(unsafe.Pointer(zf)).Fdata != uintptr(-libc.Int32FromInt32(1)) && !((*TZipFile)(unsafe.Pointer(zf)).FptrToFree != 0) {
		libc.Xmunmap(tls, (*TZipFile)(unsafe.Pointer(zf)).Fdata, (*TZipFile)(unsafe.Pointer(zf)).Flength)
		(*TZipFile)(unsafe.Pointer(zf)).Fdata = uintptr(-libc.Int32FromInt32(1))
	}
	if (*TZipFile)(unsafe.Pointer(zf)).FptrToFree != 0 {
		XTclpFree(tls, (*TZipFile)(unsafe.Pointer(zf)).FptrToFree)
		(*TZipFile)(unsafe.Pointer(zf)).FptrToFree = libc.UintptrFromInt32(0)
	}
	if (*TZipFile)(unsafe.Pointer(zf)).Fchan1 != 0 {
		XTcl_CloseEx(tls, interp, (*TZipFile)(unsafe.Pointer(zf)).Fchan1, 0)
		(*TZipFile)(unsafe.Pointer(zf)).Fchan1 = libc.UintptrFromInt32(0)
	}
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSFindTOC --
 *
 *	This function takes a memory mapped zip file and indexes the contents.
 *	When "needZip" is zero an embedded ZIP archive in an executable file
 *	is accepted. Note that we do not support ZIP64.
 *
 * Results:
 *	TCL_OK on success, TCL_ERROR otherwise with an error message placed
 *	into the given "interp" if it is not NULL.
 *
 * Side effects:
 *      The given ZipFile struct is filled with information about the ZIP
 *      archive file.  On error, ZipFSCloseArchive is called on zf but
 *      it is not freed.
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSFindTOC(tls *libc.TLS, interp uintptr, needZip int32, zf uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var cdirSize, cdirZipOffset uint32
	var cdirStart, dirEntry, end, eocdPtr, localP, passPtr, q, start uintptr
	var comlen, extra, pathlen int32
	var eocdDataOffset Tptrdiff_t
	var i, localhdr_off, minoff, v2, v3, v4, v5 Tsize_t
	var v7 uint64
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cdirSize, cdirStart, cdirZipOffset, comlen, dirEntry, end, eocdDataOffset, eocdPtr, extra, i, localP, localhdr_off, minoff, passPtr, pathlen, q, start, v2, v3, v4, v5, v7 /* End of Central Directory Record */
	start = (*TZipFile)(unsafe.Pointer(zf)).Fdata
	end = (*TZipFile)(unsafe.Pointer(zf)).Fdata + uintptr((*TZipFile)(unsafe.Pointer(zf)).Flength)
	/*
	 * Scan backwards from the end of the file for the signature. This is
	 * necessary because ZIP archives aren't the only things that get tagged
	 * on the end of executables; digital signatures can also go there.
	 */
	eocdPtr = (*TZipFile)(unsafe.Pointer(zf)).Fdata + uintptr((*TZipFile)(unsafe.Pointer(zf)).Flength) - uintptr(ZIP_CENTRAL_END_LEN)
	for eocdPtr >= start {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(eocdPtr))) == libc.Int32FromInt32(ZIP_CENTRAL_END_SIG)&libc.Int32FromInt32(0xFF) {
			if _ZipReadInt(tls, start, end, eocdPtr) == uint32(ZIP_CENTRAL_END_SIG) {
				break
			}
			eocdPtr -= uintptr(ZIP_SIG_LEN)
		} else {
			eocdPtr--
		}
	}
	if !(eocdPtr < (*TZipFile)(unsafe.Pointer(zf)).Fdata) {
		goto _1
	}
	/*
	 * Didn't find it (or not enough space for a central directory!); not
	 * a ZIP archive. This might be OK or a problem.
	 */
	if !(needZip != 0) {
		v2 = (*TZipFile)(unsafe.Pointer(zf)).Flength
		(*TZipFile)(unsafe.Pointer(zf)).FpassOffset = v2
		(*TZipFile)(unsafe.Pointer(zf)).FbaseOffset = v2
		return TCL_OK
	}
	if interp != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+73155, int64(-int32(1))))
	}
	if interp != 0 {
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+73197, libc.UintptrFromInt32(0)))
	}
	goto error
error:
	;
	_ZipFSCloseArchive(tls, interp, zf)
	return int32(TCL_ERROR)
_1:
	;
	/*
	 * eocdPtr -> End of Central Directory (EOCD) record at this point.
	 * Note this is not same as "end of Central Directory" :-) as EOCD
	 * is a record/structure in the ZIP spec terminology
	 */
	/*
	 * How many files in the archive? If that's bogus, we're done here.
	 */
	(*TZipFile)(unsafe.Pointer(zf)).FnumFiles = uint64(_ZipReadShort(tls, start, end, eocdPtr+uintptr(ZIP_CENTRAL_ENTS_OFFS)))
	if (*TZipFile)(unsafe.Pointer(zf)).FnumFiles == uint64(0) {
		if !(needZip != 0) {
			v3 = (*TZipFile)(unsafe.Pointer(zf)).Flength
			(*TZipFile)(unsafe.Pointer(zf)).FpassOffset = v3
			(*TZipFile)(unsafe.Pointer(zf)).FbaseOffset = v3
			return TCL_OK
		}
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+73205, int64(-int32(1))))
		}
		if interp != 0 {
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+22759, libc.UintptrFromInt32(0)))
		}
		goto error
	}
	/*
	 * The Central Directory (CD) is a series of Central Directory File
	 * Header (CDFH) records preceding the EOCD (but not necessarily
	 * immediately preceding). cdirZipOffset is the offset into the
	 * *archive* to the CD (first CDFH). The size of the CD is given by
	 * cdirSize. NOTE: offset into archive does NOT mean offset into
	 * (zf->data) as other data may precede the archive in the file.
	 */
	eocdDataOffset = int64(eocdPtr) - int64((*TZipFile)(unsafe.Pointer(zf)).Fdata)
	cdirZipOffset = _ZipReadInt(tls, start, end, eocdPtr+uintptr(ZIP_CENTRAL_DIRSTART_OFFS))
	cdirSize = _ZipReadInt(tls, start, end, eocdPtr+uintptr(ZIP_CENTRAL_DIRSIZE_OFFS))
	/*
	 * As computed above,
	 *    eocdDataOffset < zf->length.
	 * In addition, the following consistency checks must be met
	 * (1) cdirZipOffset <= eocdDataOffset (to prevent under flow in computation of (2))
	 * (2) cdirZipOffset + cdirSize <= eocdDataOffset. Else the CD will be overlapping
	 * the EOCD. Note this automatically means cdirZipOffset+cdirSize < zf->length.
	 */
	if !(uint64(cdirZipOffset) <= libc.Uint64FromInt64(eocdDataOffset) && libc.Int64FromUint32(cdirSize) <= eocdDataOffset-libc.Int64FromUint32(cdirZipOffset)) {
		if !(needZip != 0) {
			/* Simply point to end od data */
			v5 = (*TZipFile)(unsafe.Pointer(zf)).Flength
			(*TZipFile)(unsafe.Pointer(zf)).FpassOffset = v5
			v4 = v5
			(*TZipFile)(unsafe.Pointer(zf)).FbaseOffset = v4
			(*TZipFile)(unsafe.Pointer(zf)).FdirectoryOffset = v4
			return TCL_OK
		}
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+73219, int64(-int32(1))))
		}
		if interp != 0 {
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+73247, libc.UintptrFromInt32(0)))
		}
		goto error
	}
	/*
	 * Calculate the offset of the CD in the *data*. If there was no extra
	 * "junk" preceding the archive, this would just be cdirZipOffset but
	 * otherwise we have to account for it.
	 */
	if eocdDataOffset-libc.Int64FromUint32(cdirSize) > libc.Int64FromUint32(cdirZipOffset) {
		(*TZipFile)(unsafe.Pointer(zf)).FbaseOffset = libc.Uint64FromInt64(eocdDataOffset - libc.Int64FromUint32(cdirSize) - libc.Int64FromUint32(cdirZipOffset))
	} else {
		(*TZipFile)(unsafe.Pointer(zf)).FbaseOffset = uint64(0)
	}
	(*TZipFile)(unsafe.Pointer(zf)).FpassOffset = (*TZipFile)(unsafe.Pointer(zf)).FbaseOffset
	(*TZipFile)(unsafe.Pointer(zf)).FdirectoryOffset = uint64(cdirZipOffset) + (*TZipFile)(unsafe.Pointer(zf)).FbaseOffset
	(*TZipFile)(unsafe.Pointer(zf)).FdirectorySize = uint64(cdirSize)
	/*
	 * Read the central directory.
	 */
	cdirStart = eocdPtr - uintptr(cdirSize)
	minoff = (*TZipFile)(unsafe.Pointer(zf)).Flength
	dirEntry = cdirStart
	i = libc.Uint64FromInt32(0)
	for {
		if !(i < (*TZipFile)(unsafe.Pointer(zf)).FnumFiles) {
			break
		}
		if int64(dirEntry)-int64(cdirStart)+int64(ZIP_CENTRAL_HEADER_LEN) > libc.Int64FromUint64((*TZipFile)(unsafe.Pointer(zf)).FdirectorySize) {
			if interp != 0 {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+73254, int64(-int32(1))))
			}
			if interp != 0 {
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+73274, libc.UintptrFromInt32(0)))
			}
			goto error
		}
		if _ZipReadInt(tls, start, end, dirEntry) != uint32(ZIP_CENTRAL_HEADER_SIG) {
			if interp != 0 {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+73284, int64(-int32(1))))
			}
			if interp != 0 {
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+73307, libc.UintptrFromInt32(0)))
			}
			goto error
		}
		pathlen = libc.Int32FromUint16(_ZipReadShort(tls, start, end, dirEntry+uintptr(ZIP_CENTRAL_PATHLEN_OFFS)))
		comlen = libc.Int32FromUint16(_ZipReadShort(tls, start, end, dirEntry+uintptr(ZIP_CENTRAL_FCOMMENTLEN_OFFS)))
		extra = libc.Int32FromUint16(_ZipReadShort(tls, start, end, dirEntry+uintptr(ZIP_CENTRAL_EXTRALEN_OFFS)))
		localhdr_off = uint64(_ZipReadInt(tls, start, end, dirEntry+uintptr(ZIP_CENTRAL_LOCALHDR_OFFS)))
		localP = (*TZipFile)(unsafe.Pointer(zf)).Fdata + uintptr((*TZipFile)(unsafe.Pointer(zf)).FbaseOffset) + uintptr(localhdr_off)
		if localP > cdirStart-uintptr(ZIP_LOCAL_HEADER_LEN) || _ZipReadInt(tls, start, end, localP) != uint32(ZIP_LOCAL_HEADER_SIG) {
			if interp != 0 {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+73315, int64(-int32(1))))
			}
			if interp != 0 {
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+73343, libc.UintptrFromInt32(0)))
			}
			goto error
		}
		if localhdr_off < minoff {
			minoff = localhdr_off
		}
		dirEntry += uintptr(pathlen + comlen + extra + int32(ZIP_CENTRAL_HEADER_LEN))
		goto _6
	_6:
		;
		i++
	}
	if int64(dirEntry)-int64(cdirStart) < libc.Int64FromUint64((*TZipFile)(unsafe.Pointer(zf)).FdirectorySize) {
		/* file count and dir size do not match */
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+73351, int64(-int32(1))))
		}
		if interp != 0 {
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+73368, libc.UintptrFromInt32(0)))
		}
		goto error
	}
	(*TZipFile)(unsafe.Pointer(zf)).FpassOffset = minoff + (*TZipFile)(unsafe.Pointer(zf)).FbaseOffset
	/*
	 * If there's also an encoded password, extract that too (but don't decode
	 * yet).
	 * TODO - is this even part of the ZIP "standard". The idea of storing
	 * a password with the archive seems absurd, encoded or not.
	 */
	q = (*TZipFile)(unsafe.Pointer(zf)).Fdata + uintptr((*TZipFile)(unsafe.Pointer(zf)).FpassOffset)
	if (*TZipFile)(unsafe.Pointer(zf)).FpassOffset >= uint64(6) && start < q-uintptr(4) && _ZipReadInt(tls, start, end, q-uintptr(4)) == uint32(ZIP_PASSWORD_END_SIG) {
		i = uint64(*(*uint8)(unsafe.Pointer(q + uintptr(-libc.Int32FromInt32(5)))))
		passPtr = q - uintptr(5) - uintptr(i)
		if passPtr >= start && passPtr+uintptr(i) < end {
			*(*uint8)(unsafe.Pointer(zf + 96)) = uint8(i)
			libc.Xmemcpy(tls, zf+96+uintptr(1), passPtr, i)
			if i != 0 {
				v7 = uint64(5) + i
			} else {
				v7 = uint64(0)
			}
			*(*Tsize_t)(unsafe.Pointer(zf + 72)) -= v7
		}
	}
	return TCL_OK
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSOpenArchive --
 *
 *	This function opens a ZIP archive file for reading. An attempt is made
 *	to memory map that file. Otherwise it is read into an allocated memory
 *	buffer. The ZIP archive header is verified and must be valid for the
 *	function to succeed. When "needZip" is zero an embedded ZIP archive in
 *	an executable file is accepted.
 *
 * Results:
 *	TCL_OK on success, TCL_ERROR otherwise with an error message placed
 *	into the given "interp" if it is not NULL. On error, ZipFSCloseArchive
 *      is called on zf but it is not freed.
 *
 * Side effects:
 *	ZIP archive is memory mapped or read into allocated memory, the given
 *	ZipFile struct is filled with information about the ZIP archive file.
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSOpenArchive(tls *libc.TLS, interp uintptr, zipname uintptr, needZip int32, zf uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var i, v1 Tsize_t
	var v2 uintptr
	var _ /* handle at bp+0 */ uintptr
	_, _, _ = i, v1, v2
	(*TZipFile)(unsafe.Pointer(zf)).FnameLength = uint64(0)
	(*TZipFile)(unsafe.Pointer(zf)).FisMemBuffer = uint8(0)
	(*TZipFile)(unsafe.Pointer(zf)).Fdata = uintptr(-libc.Int32FromInt32(1))
	(*TZipFile)(unsafe.Pointer(zf)).Flength = uint64(0)
	(*TZipFile)(unsafe.Pointer(zf)).FnumFiles = uint64(0)
	v1 = libc.Uint64FromInt32(0)
	(*TZipFile)(unsafe.Pointer(zf)).FpassOffset = v1
	(*TZipFile)(unsafe.Pointer(zf)).FbaseOffset = v1
	(*TZipFile)(unsafe.Pointer(zf)).FptrToFree = libc.UintptrFromInt32(0)
	*(*uint8)(unsafe.Pointer(zf + 96)) = uint8(0)
	/*
	 * Actually open the file.
	 */
	(*TZipFile)(unsafe.Pointer(zf)).Fchan1 = XTcl_OpenFileChannel(tls, interp, zipname, __ccgo_ts+49954, 0)
	if !((*TZipFile)(unsafe.Pointer(zf)).Fchan1 != 0) {
		return int32(TCL_ERROR)
	}
	/*
	 * See if we can get the OS handle. If we can, we can use that to memory
	 * map the file, which is nice and efficient. However, it totally depends
	 * on the filename pointing to a real regular OS file.
	 *
	 * Opening real filesystem entities that are not files will lead to an
	 * error.
	 */
	if XTcl_GetChannelHandle(tls, (*TZipFile)(unsafe.Pointer(zf)).Fchan1, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1), bp) == TCL_OK {
		if _ZipMapArchive(tls, interp, zf, *(*uintptr)(unsafe.Pointer(bp))) != TCL_OK {
			goto error
		}
	} else {
		/*
		 * Not an OS file, but rather something in a Tcl VFS. Must copy into
		 * memory.
		 */
		(*TZipFile)(unsafe.Pointer(zf)).Flength = libc.Uint64FromInt64(XTcl_Seek(tls, (*TZipFile)(unsafe.Pointer(zf)).Fchan1, 0, int32(2)))
		if (*TZipFile)(unsafe.Pointer(zf)).Flength == libc.Uint64FromInt64(int64(-libc.Int32FromInt32(1))) {
			if interp != 0 {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+24923, libc.VaList(bp+16, __ccgo_ts+73379, XTcl_PosixError(tls, interp))))
			}
			goto error
		}
		/* What's the magic about 64 * 1024 * 1024 ? */
		if (*TZipFile)(unsafe.Pointer(zf)).Flength <= uint64(ZIP_CENTRAL_END_LEN) || (*TZipFile)(unsafe.Pointer(zf)).Flength-uint64(ZIP_CENTRAL_END_LEN) > libc.Uint64FromInt32(libc.Int32FromInt32(64)*libc.Int32FromInt32(1024)*libc.Int32FromInt32(1024)-int32(ZIP_CENTRAL_END_LEN)) {
			if interp != 0 {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+73390, int64(-int32(1))))
			}
			if interp != 0 {
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+73408, libc.UintptrFromInt32(0)))
			}
			goto error
		}
		if XTcl_Seek(tls, (*TZipFile)(unsafe.Pointer(zf)).Fchan1, 0, 0) == int64(-int32(1)) {
			if interp != 0 {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+24923, libc.VaList(bp+16, __ccgo_ts+73379, XTcl_PosixError(tls, interp))))
			}
			goto error
		}
		v2 = XTclpAlloc(tls, (*TZipFile)(unsafe.Pointer(zf)).Flength)
		(*TZipFile)(unsafe.Pointer(zf)).Fdata = v2
		(*TZipFile)(unsafe.Pointer(zf)).FptrToFree = v2
		if !((*TZipFile)(unsafe.Pointer(zf)).FptrToFree != 0) {
			if interp != 0 {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+1638, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+73148, libc.UintptrFromInt32(0)))
			}
			goto error
		}
		i = libc.Uint64FromInt64(XTcl_Read(tls, (*TZipFile)(unsafe.Pointer(zf)).Fchan1, (*TZipFile)(unsafe.Pointer(zf)).Fdata, libc.Int64FromUint64((*TZipFile)(unsafe.Pointer(zf)).Flength)))
		if i != (*TZipFile)(unsafe.Pointer(zf)).Flength {
			if interp != 0 {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+24923, libc.VaList(bp+16, __ccgo_ts+73418, XTcl_PosixError(tls, interp))))
			}
			goto error
		}
	}
	/*
	 * Close the Tcl channel. If the file was mapped, the mapping is
	 * unaffected. It is important to close the channel otherwise there is a
	 * potential chicken and egg issue at finalization time as the channels
	 * are closed before the file systems are dismounted.
	 */
	XTcl_CloseEx(tls, interp, (*TZipFile)(unsafe.Pointer(zf)).Fchan1, 0)
	(*TZipFile)(unsafe.Pointer(zf)).Fchan1 = libc.UintptrFromInt32(0)
	return _ZipFSFindTOC(tls, interp, needZip, zf)
	/*
	 * Handle errors by closing the archive. This includes closing the channel
	 * handle for the archive file.
	 */
	goto error
error:
	;
	_ZipFSCloseArchive(tls, interp, zf)
	return int32(TCL_ERROR)
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipMapArchive --
 *
 *	Wrapper around the platform-specific parts of mmap() (and Windows's
 *	equivalent) because it's not part of the standard channel API.
 *
 *-------------------------------------------------------------------------
 */

func _ZipMapArchive(tls *libc.TLS, interp uintptr, zf uintptr, handle uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* The OS handle to the open archive. */
	var fd int32
	_ = fd
	fd = int32(int64(handle))
	/*
	 * Determine the file size.
	 */
	(*TZipFile)(unsafe.Pointer(zf)).Flength = libc.Uint64FromInt64(libc.Xlseek(tls, fd, 0, int32(2)))
	if (*TZipFile)(unsafe.Pointer(zf)).Flength == libc.Uint64FromInt32(-libc.Int32FromInt32(1)) {
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+24923, libc.VaList(bp+8, __ccgo_ts+73434, XTcl_PosixError(tls, interp))))
		}
		return int32(TCL_ERROR)
	}
	if (*TZipFile)(unsafe.Pointer(zf)).Flength < uint64(ZIP_CENTRAL_END_LEN) {
		XTcl_SetErrno(tls, int32(EINVAL))
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+24923, libc.VaList(bp+8, __ccgo_ts+73463, XTcl_PosixError(tls, interp))))
		}
		return int32(TCL_ERROR)
	}
	libc.Xlseek(tls, fd, 0, 0)
	(*TZipFile)(unsafe.Pointer(zf)).Fdata = libc.Xmmap(tls, uintptr(0), (*TZipFile)(unsafe.Pointer(zf)).Flength, int32(PROT_READ), libc.Int32FromInt32(MAP_FILE)|libc.Int32FromInt32(MAP_PRIVATE), fd, 0)
	if (*TZipFile)(unsafe.Pointer(zf)).Fdata == uintptr(-libc.Int32FromInt32(1)) {
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+24923, libc.VaList(bp+8, __ccgo_ts+73478, XTcl_PosixError(tls, interp))))
		}
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *-------------------------------------------------------------------------
 *
 * IsPasswordValid --
 *
 *	Basic test for whether a passowrd is valid. If the test fails, sets an
 *	error message in the interpreter.
 *
 * Returns:
 *	TCL_OK if the test passes, TCL_ERROR if it fails.
 *
 *-------------------------------------------------------------------------
 */

func _IsPasswordValid(tls *libc.TLS, interp uintptr, passwd uintptr, pwlen Tsize_t) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	if pwlen > uint64(255) || libc.Xstrchr(tls, passwd, int32(0xff)) != 0 {
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+73498, int64(-int32(1))))
		}
		if interp != 0 {
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+73515, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSCatalogFilesystem --
 *
 *	This function generates the root node for a ZIPFS filesystem by
 *	reading the ZIP's central directory.
 *
 * Results:
 *	TCL_OK on success, TCL_ERROR otherwise with an error message placed
 *	into the given "interp" if it is not NULL. On error, frees zf!!
 *
 * Side effects:
 *	Will acquire and release the write lock.
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSCatalogFilesystem(tls *libc.TLS, interp uintptr, zf uintptr, mountPoint uintptr, passwd uintptr, zipname uintptr) (r int32) {
	bp := tls.Alloc(512)
	defer tls.Free(512) /* Path to ZIP file to build a catalog of. */
	var comlen, i, offs, pathlen, pwlen, v4 Tsize_t
	var dir, end, endPtr, fullpath, gq, hPtr, lq, path, q, start, z, zd, zf0, v1, v11, v7, v9 uintptr
	var dosDate, dosTime, extra, isdir, k, nbcompr, v2, v5, v6 int32
	var _ /* ds at bp+8 */ TTcl_DString
	var _ /* fpBuf at bp+232 */ TTcl_DString
	var _ /* isNew at bp+0 */ int32
	var _ /* t at bp+456 */ TTcl_Time
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = comlen, dir, dosDate, dosTime, end, endPtr, extra, fullpath, gq, hPtr, i, isdir, k, lq, nbcompr, offs, path, pathlen, pwlen, q, start, z, zd, zf0, v1, v11, v2, v4, v5, v6, v7, v9
	/* Caller should have normalized */
	XTcl_DStringInit(tls, bp+8)
	/*
	 * Basic verification of the password for sanity.
	 */
	pwlen = uint64(0)
	if passwd != 0 {
		pwlen = libc.Xstrlen(tls, passwd)
		if _IsPasswordValid(tls, interp, passwd, pwlen) != TCL_OK {
			_ZipFSCloseArchive(tls, interp, zf)
			XTclpFree(tls, zf)
			return int32(TCL_ERROR)
		}
	}
	/*
	 * Validate the TOC data. If that's bad, things fall apart.
	 */
	if (*TZipFile)(unsafe.Pointer(zf)).FbaseOffset >= (*TZipFile)(unsafe.Pointer(zf)).Flength || (*TZipFile)(unsafe.Pointer(zf)).FpassOffset >= (*TZipFile)(unsafe.Pointer(zf)).Flength || (*TZipFile)(unsafe.Pointer(zf)).FdirectoryOffset >= (*TZipFile)(unsafe.Pointer(zf)).Flength {
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+73524, int64(-int32(1))))
		}
		if interp != 0 {
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+480, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+73537, libc.UintptrFromInt32(0)))
		}
		_ZipFSCloseArchive(tls, interp, zf)
		XTclpFree(tls, zf)
		return int32(TCL_ERROR)
	}
	_WriteLock(tls)
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ZipFS)) + 136)).FcreateProc})))(tls, uintptr(unsafe.Pointer(&_ZipFS))+136, mountPoint, bp)
	if !(*(*int32)(unsafe.Pointer(bp)) != 0) {
		if interp != 0 {
			zf0 = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+73545, libc.VaList(bp+480, (*TZipFile)(unsafe.Pointer(zf0)).Fname, mountPoint)))
			if interp != 0 {
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+480, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+73573, libc.UintptrFromInt32(0)))
			}
		}
		_Unlock(tls)
		_ZipFSCloseArchive(tls, interp, zf)
		XTcl_DStringFree(tls, bp+8)
		XTclpFree(tls, zf)
		return int32(TCL_ERROR)
	}
	/*
	 * Convert to a real archive descriptor.
	 */
	if (*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ZipFS))+136)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ZipFS))+136)).FkeyType == -int32(1) {
		v1 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
	} else {
		v1 = hPtr + 32
	}
	(*TZipFile)(unsafe.Pointer(zf)).FmountPoint = v1
	(*TZipFile)(unsafe.Pointer(zf)).FmountPointLen = libc.Int64FromUint64(libc.Xstrlen(tls, (*TZipFile)(unsafe.Pointer(zf)).FmountPoint))
	(*TZipFile)(unsafe.Pointer(zf)).FnameLength = libc.Xstrlen(tls, zipname)
	(*TZipFile)(unsafe.Pointer(zf)).Fname = XTcl_Alloc(tls, (*TZipFile)(unsafe.Pointer(zf)).FnameLength+uint64(1))
	libc.Xmemcpy(tls, (*TZipFile)(unsafe.Pointer(zf)).Fname, zipname, (*TZipFile)(unsafe.Pointer(zf)).FnameLength+uint64(1))
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = zf
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(zf + 96))) == 0 && pwlen != 0 {
		k = 0
		v2 = k
		k++
		*(*uint8)(unsafe.Pointer(zf + 96 + uintptr(v2))) = uint8(pwlen)
		i = pwlen
		for {
			v4 = i
			i--
			if !(v4 > uint64(0)) {
				break
			}
			v5 = k
			k++
			*(*uint8)(unsafe.Pointer(zf + 96 + uintptr(v5))) = libc.Uint8FromInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(passwd + uintptr(i))))&int32(0x0f) | libc.Int32FromUint8(_pwrot[libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(passwd + uintptr(i))))>>int32(4)&int32(0x0f)]))
			goto _3
		_3:
		}
		*(*uint8)(unsafe.Pointer(zf + 96 + uintptr(k))) = uint8('\000')
	}
	/* TODO - is this test necessary? When will mountPoint[0] be \0 ? */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(mountPoint))) != int32('\000') {
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ZipFS)) + 32)).FcreateProc})))(tls, uintptr(unsafe.Pointer(&_ZipFS))+32, mountPoint, bp)
		if *(*int32)(unsafe.Pointer(bp)) != 0 {
			z = _AllocateZipEntry(tls)
			(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = z
			(*TZipEntry)(unsafe.Pointer(z)).Fdepth = libc.Int32FromUint64(_CountSlashes(tls, mountPoint))
			(*TZipEntry)(unsafe.Pointer(z)).FzipFilePtr = zf
			if (*TZipFile)(unsafe.Pointer(zf)).FbaseOffset == uint64(0) {
				v6 = int32(1)
			} else {
				v6 = -int32(1)
			}
			(*TZipEntry)(unsafe.Pointer(z)).FisDirectory = v6 /* root marker */
			(*TZipEntry)(unsafe.Pointer(z)).Foffset = (*TZipFile)(unsafe.Pointer(zf)).FbaseOffset
			(*TZipEntry)(unsafe.Pointer(z)).FcompressMethod = int32(ZIP_COMPMETH_STORED)
			if (*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ZipFS))+32)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ZipFS))+32)).FkeyType == -int32(1) {
				v7 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
			} else {
				v7 = hPtr + 32
			}
			(*TZipEntry)(unsafe.Pointer(z)).Fname = v7
			if !(libc.Xstrcmp(tls, (*TZipEntry)(unsafe.Pointer(z)).Fname, __ccgo_ts+72859) != 0) {
				*(*int32)(unsafe.Pointer(z + 56)) |= int32(ZE_F_VOLUME) /* Mark as root volume */
			}
			XTcl_GetTime(tls, bp+456)
			(*TZipEntry)(unsafe.Pointer(z)).Ftimestamp = int32((*(*TTcl_Time)(unsafe.Pointer(bp + 456))).Fsec)
			(*TZipEntry)(unsafe.Pointer(z)).Fnext = (*TZipFile)(unsafe.Pointer(zf)).Fentries
			(*TZipFile)(unsafe.Pointer(zf)).Fentries = z
		}
	}
	q = (*TZipFile)(unsafe.Pointer(zf)).Fdata + uintptr((*TZipFile)(unsafe.Pointer(zf)).FdirectoryOffset)
	XTcl_DStringInit(tls, bp+232)
	i = uint64(0)
	for {
		if !(i < (*TZipFile)(unsafe.Pointer(zf)).FnumFiles) {
			break
		}
		start = (*TZipFile)(unsafe.Pointer(zf)).Fdata
		end = (*TZipFile)(unsafe.Pointer(zf)).Fdata + uintptr((*TZipFile)(unsafe.Pointer(zf)).Flength)
		isdir = 0
		gq = libc.UintptrFromInt32(0)
		pathlen = uint64(_ZipReadShort(tls, start, end, q+uintptr(ZIP_CENTRAL_PATHLEN_OFFS)))
		comlen = uint64(_ZipReadShort(tls, start, end, q+uintptr(ZIP_CENTRAL_FCOMMENTLEN_OFFS)))
		extra = libc.Int32FromUint16(_ZipReadShort(tls, start, end, q+uintptr(ZIP_CENTRAL_EXTRALEN_OFFS)))
		XTcl_DStringSetLength(tls, bp+8, 0)
		path = _DecodeZipEntryText(tls, q+uintptr(ZIP_CENTRAL_HEADER_LEN), uint32(pathlen), bp+8)
		if pathlen > uint64(0) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(pathlen-uint64(1))))) == int32('/') {
			XTcl_DStringSetLength(tls, bp+8, libc.Int64FromUint64(pathlen-uint64(1)))
			path = (*TTcl_DString)(unsafe.Pointer(bp + 8)).Fstring1
			isdir = int32(1)
		}
		if libc.Xstrcmp(tls, path, __ccgo_ts+35293) == 0 || libc.Xstrcmp(tls, path, __ccgo_ts+15981) == 0 {
			goto nextent
		}
		lq = (*TZipFile)(unsafe.Pointer(zf)).Fdata + uintptr((*TZipFile)(unsafe.Pointer(zf)).FbaseOffset) + uintptr(_ZipReadInt(tls, start, end, q+uintptr(ZIP_CENTRAL_LOCALHDR_OFFS)))
		if lq < start || lq+uintptr(ZIP_LOCAL_HEADER_LEN) > end {
			goto nextent
		}
		nbcompr = libc.Int32FromUint32(_ZipReadInt(tls, start, end, lq+uintptr(ZIP_LOCAL_COMPLEN_OFFS)))
		if !(isdir != 0) && nbcompr == 0 && _ZipReadInt(tls, start, end, lq+uintptr(ZIP_LOCAL_UNCOMPLEN_OFFS)) == uint32(0) && _ZipReadInt(tls, start, end, lq+uintptr(ZIP_LOCAL_CRC32_OFFS)) == uint32(0) {
			gq = q
			nbcompr = libc.Int32FromUint32(_ZipReadInt(tls, start, end, gq+uintptr(ZIP_CENTRAL_COMPLEN_OFFS)))
		}
		offs = libc.Uint64FromInt64(int64(lq) - int64((*TZipFile)(unsafe.Pointer(zf)).Fdata) + int64(ZIP_LOCAL_HEADER_LEN) + libc.Int64FromUint16(_ZipReadShort(tls, start, end, lq+uintptr(ZIP_LOCAL_PATHLEN_OFFS))) + libc.Int64FromUint16(_ZipReadShort(tls, start, end, lq+uintptr(ZIP_LOCAL_EXTRALEN_OFFS))))
		if offs+libc.Uint64FromInt32(nbcompr) > (*TZipFile)(unsafe.Pointer(zf)).Flength {
			goto nextent
		}
		if !(isdir != 0) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(mountPoint))) == int32('\000') && !(_CountSlashes(tls, path) != 0) {
			/*
			 * Regular files skipped when mounting on root.
			 */
			goto nextent
		}
		XTcl_DStringSetLength(tls, bp+232, 0)
		fullpath = _MapPathToZipfs(tls, interp, mountPoint, path, bp+232)
		z = _AllocateZipEntry(tls)
		(*TZipEntry)(unsafe.Pointer(z)).Fdepth = libc.Int32FromUint64(_CountSlashes(tls, fullpath))
		(*TZipEntry)(unsafe.Pointer(z)).FzipFilePtr = zf
		(*TZipEntry)(unsafe.Pointer(z)).FisDirectory = isdir
		(*TZipEntry)(unsafe.Pointer(z)).FisEncrypted = libc.BoolInt32(libc.Int32FromUint16(_ZipReadShort(tls, start, end, lq+uintptr(ZIP_LOCAL_FLAGS_OFFS)))&int32(1) != 0 && nbcompr > int32(ZIP_CRYPT_HDR_LEN))
		(*TZipEntry)(unsafe.Pointer(z)).Foffset = offs
		if gq != 0 {
			(*TZipEntry)(unsafe.Pointer(z)).Fcrc32 = libc.Int32FromUint32(_ZipReadInt(tls, start, end, gq+uintptr(ZIP_CENTRAL_CRC32_OFFS)))
			dosDate = libc.Int32FromUint16(_ZipReadShort(tls, start, end, gq+uintptr(ZIP_CENTRAL_MDATE_OFFS)))
			dosTime = libc.Int32FromUint16(_ZipReadShort(tls, start, end, gq+uintptr(ZIP_CENTRAL_MTIME_OFFS)))
			(*TZipEntry)(unsafe.Pointer(z)).Ftimestamp = int32(_DosTimeDate(tls, dosDate, dosTime))
			(*TZipEntry)(unsafe.Pointer(z)).FnumBytes = libc.Int32FromUint32(_ZipReadInt(tls, start, end, gq+uintptr(ZIP_CENTRAL_UNCOMPLEN_OFFS)))
			(*TZipEntry)(unsafe.Pointer(z)).FcompressMethod = libc.Int32FromUint16(_ZipReadShort(tls, start, end, gq+uintptr(ZIP_CENTRAL_COMPMETH_OFFS)))
		} else {
			(*TZipEntry)(unsafe.Pointer(z)).Fcrc32 = libc.Int32FromUint32(_ZipReadInt(tls, start, end, lq+uintptr(ZIP_LOCAL_CRC32_OFFS)))
			dosDate = libc.Int32FromUint16(_ZipReadShort(tls, start, end, lq+uintptr(ZIP_LOCAL_MDATE_OFFS)))
			dosTime = libc.Int32FromUint16(_ZipReadShort(tls, start, end, lq+uintptr(ZIP_LOCAL_MTIME_OFFS)))
			(*TZipEntry)(unsafe.Pointer(z)).Ftimestamp = int32(_DosTimeDate(tls, dosDate, dosTime))
			(*TZipEntry)(unsafe.Pointer(z)).FnumBytes = libc.Int32FromUint32(_ZipReadInt(tls, start, end, lq+uintptr(ZIP_LOCAL_UNCOMPLEN_OFFS)))
			(*TZipEntry)(unsafe.Pointer(z)).FcompressMethod = libc.Int32FromUint16(_ZipReadShort(tls, start, end, lq+uintptr(ZIP_LOCAL_COMPMETH_OFFS)))
		}
		(*TZipEntry)(unsafe.Pointer(z)).FnumCompressedBytes = nbcompr
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ZipFS)) + 32)).FcreateProc})))(tls, uintptr(unsafe.Pointer(&_ZipFS))+32, fullpath, bp)
		if !(*(*int32)(unsafe.Pointer(bp)) != 0) {
			/* should not happen but skip it anyway */
			XTclpFree(tls, z)
			goto nextent
		}
		(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = z
		if (*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ZipFS))+32)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ZipFS))+32)).FkeyType == -int32(1) {
			v9 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
		} else {
			v9 = hPtr + 32
		}
		(*TZipEntry)(unsafe.Pointer(z)).Fname = v9
		(*TZipEntry)(unsafe.Pointer(z)).Fnext = (*TZipFile)(unsafe.Pointer(zf)).Fentries
		(*TZipFile)(unsafe.Pointer(zf)).Fentries = z
		if isdir != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(mountPoint))) == int32('\000') && (*TZipEntry)(unsafe.Pointer(z)).Fdepth == int32(ZIPFS_ROOTDIR_DEPTH) {
			(*TZipEntry)(unsafe.Pointer(z)).Ftnext = (*TZipFile)(unsafe.Pointer(zf)).FtopEnts
			(*TZipFile)(unsafe.Pointer(zf)).FtopEnts = z
		}
		/*
		 * Make any directory nodes we need. ZIPs are not consistent about
		 * containing directory nodes.
		 */
		if !((*TZipEntry)(unsafe.Pointer(z)).FisDirectory != 0) && (*TZipEntry)(unsafe.Pointer(z)).Fdepth > int32(ZIPFS_ROOTDIR_DEPTH) {
			XTcl_DStringSetLength(tls, bp+8, libc.Int64FromUint64(libc.Xstrlen(tls, (*TZipEntry)(unsafe.Pointer(z)).Fname)+uint64(8)))
			XTcl_DStringSetLength(tls, bp+8, 0)
			XTcl_DStringAppend(tls, bp+8, (*TZipEntry)(unsafe.Pointer(z)).Fname, int64(-int32(1)))
			dir = (*TTcl_DString)(unsafe.Pointer(bp + 8)).Fstring1
			endPtr = libc.Xstrrchr(tls, dir, int32('/'))
			for {
				if !(endPtr != 0 && endPtr != dir) {
					break
				}
				XTcl_DStringSetLength(tls, bp+8, int64(endPtr)-int64(dir))
				hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ZipFS)) + 32)).FcreateProc})))(tls, uintptr(unsafe.Pointer(&_ZipFS))+32, dir, bp)
				if !(*(*int32)(unsafe.Pointer(bp)) != 0) {
					/*
					 * Already made. That's fine.
					 */
					break
				}
				zd = _AllocateZipEntry(tls)
				(*TZipEntry)(unsafe.Pointer(zd)).Fdepth = libc.Int32FromUint64(_CountSlashes(tls, dir))
				(*TZipEntry)(unsafe.Pointer(zd)).FzipFilePtr = zf
				(*TZipEntry)(unsafe.Pointer(zd)).FisDirectory = int32(1)
				(*TZipEntry)(unsafe.Pointer(zd)).Foffset = (*TZipEntry)(unsafe.Pointer(z)).Foffset
				(*TZipEntry)(unsafe.Pointer(zd)).Ftimestamp = (*TZipEntry)(unsafe.Pointer(z)).Ftimestamp
				(*TZipEntry)(unsafe.Pointer(zd)).FcompressMethod = int32(ZIP_COMPMETH_STORED)
				(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = zd
				if (*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ZipFS))+32)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ZipFS))+32)).FkeyType == -int32(1) {
					v11 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
				} else {
					v11 = hPtr + 32
				}
				(*TZipEntry)(unsafe.Pointer(zd)).Fname = v11
				(*TZipEntry)(unsafe.Pointer(zd)).Fnext = (*TZipFile)(unsafe.Pointer(zf)).Fentries
				(*TZipFile)(unsafe.Pointer(zf)).Fentries = zd
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(mountPoint))) == int32('\000') && (*TZipEntry)(unsafe.Pointer(zd)).Fdepth == int32(ZIPFS_ROOTDIR_DEPTH) {
					(*TZipEntry)(unsafe.Pointer(zd)).Ftnext = (*TZipFile)(unsafe.Pointer(zf)).FtopEnts
					(*TZipFile)(unsafe.Pointer(zf)).FtopEnts = zd
				}
				goto _10
			_10:
				;
				endPtr = libc.Xstrrchr(tls, dir, int32('/'))
			}
		}
		goto nextent
	nextent:
		;
		q += uintptr(pathlen + comlen + libc.Uint64FromInt32(extra) + uint64(ZIP_CENTRAL_HEADER_LEN))
		goto _8
	_8:
		;
		i++
	}
	_Unlock(tls)
	XTcl_DStringFree(tls, bp+232)
	XTcl_DStringFree(tls, bp+8)
	XTcl_FSMountsChanged(tls, libc.UintptrFromInt32(0))
	return TCL_OK
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipfsSetup --
 *
 *	Common initialisation code. ZipFS.initialized must *not* be set prior
 *	to the call.
 *
 *-------------------------------------------------------------------------
 */

func _ZipfsSetup(tls *libc.TLS) {
	/*
	 * Inflate condition variable.
	 */
	XTcl_MutexLock(tls, uintptr(unsafe.Pointer(&_ZipFSMutex)))
	XTcl_ConditionWait(tls, uintptr(unsafe.Pointer(&_ZipFSCond)), uintptr(unsafe.Pointer(&_ZipFSMutex)), uintptr(unsafe.Pointer(&_t)))
	XTcl_MutexUnlock(tls, uintptr(unsafe.Pointer(&_ZipFSMutex)))
	_crc32tab = libz.Xget_crc_table(tls)
	XTcl_FSRegister(tls, libc.UintptrFromInt32(0), uintptr(unsafe.Pointer(&_zipfsFilesystem)))
	XTcl_InitHashTable(tls, uintptr(unsafe.Pointer(&_ZipFS))+32, TCL_STRING_KEYS)
	XTcl_InitHashTable(tls, uintptr(unsafe.Pointer(&_ZipFS))+136, TCL_STRING_KEYS)
	_ZipFS.FidCount = int32(1)
	_ZipFS.Fwrmax = int32(INT_MAX)
	_ZipFS.FfallbackEntryEncoding = XTcl_Alloc(tls, libc.Xstrlen(tls, __ccgo_ts+73095)+uint64(1))
	libc.Xstrcpy(tls, _ZipFS.FfallbackEntryEncoding, __ccgo_ts+73095)
	_ZipFS.Finitialized = int32(1)
}

var _t = TTcl_Time{}

/*
 *-------------------------------------------------------------------------
 *
 * ListMountPoints --
 *
 *	This procedure lists the mount points and what's mounted there, or
 *	reports whether there are any mounts (if there's no interpreter). The
 *	read lock must be held by the caller.
 *
 * Results:
 *	A standard Tcl result. TCL_OK (or TCL_BREAK if no mounts and no
 *	interpreter).
 *
 * Side effects:
 *	Interpreter result may be updated.
 *
 *-------------------------------------------------------------------------
 */

func _ListMountPoints(tls *libc.TLS, interp uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var cachePtr, hPtr, resultList, zf uintptr
	var v1 int32
	var v2 bool
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _ = cachePtr, hPtr, resultList, zf, v1, v2
	if !(interp != 0) {
		/*
		 * Are there any entries in the zipHash? Don't need to enumerate them
		 * all to know.
		 */
		if _ZipFS.FzipHash.FnumEntries != 0 {
			v1 = TCL_OK
		} else {
			v1 = int32(TCL_BREAK)
		}
		return v1
	}
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultList = XTclThreadAllocObj(tls)
	} else {
		resultList = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultList + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultList)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultList)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultList)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultList)).FtypePtr = libc.UintptrFromInt32(0)
	hPtr = XTcl_FirstHashEntry(tls, uintptr(unsafe.Pointer(&_ZipFS))+136, bp)
	for {
		if !(hPtr != 0) {
			break
		}
		zf = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultList, XTcl_NewStringObj(tls, (*TZipFile)(unsafe.Pointer(zf)).FmountPoint, int64(-int32(1))))
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultList, XTcl_NewStringObj(tls, (*TZipFile)(unsafe.Pointer(zf)).Fname, int64(-int32(1))))
		goto _3
	_3:
		;
		hPtr = XTcl_NextHashEntry(tls, bp)
	}
	XTcl_SetObjResult(tls, interp, resultList)
	return TCL_OK
}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * CleanupMount --
//	 *
//	 *    Releases all resources associated with a mounted archive. There
//	 *    must not be any open files in the archive.
//	 *
//	 *    Caller MUST be holding WriteLock() before calling this function.
//	 *
//	 * Results:
//	 *    None.
//	 *
//	 * Side effects:
//	 *    Memory associated with the mounted archive is deallocated.
//	 *------------------------------------------------------------------------
//	 */
func _CleanupMount(tls *libc.TLS, zf uintptr) {
	/* Mount point */
	var hPtr, z, znext uintptr
	_, _, _ = hPtr, z, znext
	z = (*TZipFile)(unsafe.Pointer(zf)).Fentries
	for {
		if !(z != 0) {
			break
		}
		znext = (*TZipEntry)(unsafe.Pointer(z)).Fnext
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ZipFS)) + 32)).FfindProc})))(tls, uintptr(unsafe.Pointer(&_ZipFS))+32, (*TZipEntry)(unsafe.Pointer(z)).Fname)
		if hPtr != 0 {
			XTcl_DeleteHashEntry(tls, hPtr)
		}
		if (*TZipEntry)(unsafe.Pointer(z)).Fdata != 0 {
			XTclpFree(tls, (*TZipEntry)(unsafe.Pointer(z)).Fdata)
		}
		XTclpFree(tls, z)
		goto _1
	_1:
		;
		z = znext
	}
	(*TZipFile)(unsafe.Pointer(zf)).Fentries = libc.UintptrFromInt32(0)
}

/*
 *-------------------------------------------------------------------------
 *
 * DescribeMounted --
 *
 *	This procedure describes what is mounted at the given the mount point.
 *	The interpreter result is not updated if there is nothing mounted at
 *	the given point. The read lock must be held by the caller.
 *
 * Results:
 *	A standard Tcl result. TCL_OK (or TCL_BREAK if nothing mounted there
 *	and no interpreter).
 *
 * Side effects:
 *	Interpreter result may be updated.
 *
 *-------------------------------------------------------------------------
 */

func _DescribeMounted(tls *libc.TLS, interp uintptr, mountPoint uintptr) (r int32) {
	var zf uintptr
	var v1 int32
	_, _ = zf, v1
	if interp != 0 {
		zf = _ZipFSLookupZip(tls, mountPoint)
		if zf != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, (*TZipFile)(unsafe.Pointer(zf)).Fname, int64(-int32(1))))
			return TCL_OK
		}
	}
	if interp != 0 {
		v1 = TCL_OK
	} else {
		v1 = int32(TCL_BREAK)
	}
	return v1
}

/*
 *-------------------------------------------------------------------------
 *
 * TclZipfs_Mount --
 *
 *	This procedure is invoked to mount a given ZIP archive file on a given
 *	mountpoint with optional ZIP password.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	A ZIP archive file is read, analyzed and mounted, resources are
 *	allocated.
 *
 *-------------------------------------------------------------------------
 */

func XTclZipfs_Mount(tls *libc.TLS, interp uintptr, zipname uintptr, mountPoint uintptr, passwd uintptr) (r int32) {
	bp := tls.Alloc(272)
	defer tls.Free(272) /* Password for opening the ZIP, or NULL if
	 * the ZIP is unprotected. */
	var _objPtr, _objPtr1, normPath, normZipPathObj, zf, zipPathObj, v4, v6 uintptr
	var ret, v1 int32
	var v2 bool
	var v3, v5 TTcl_Size
	var _ /* ds at bp+0 */ TTcl_DString
	_, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, normPath, normZipPathObj, ret, zf, zipPathObj, v1, v2, v3, v4, v5, v6
	_ReadLock(tls)
	if !(_ZipFS.Finitialized != 0) {
		_ZipfsSetup(tls)
	}
	/*
	 * No mount point, so list all mount points and what is mounted there.
	 */
	if mountPoint == libc.UintptrFromInt32(0) {
		ret = _ListMountPoints(tls, interp)
		_Unlock(tls)
		return ret
	}
	XTcl_DStringInit(tls, bp)
	ret = _NormalizeMountPoint(tls, interp, mountPoint, bp)
	if ret != TCL_OK {
		_Unlock(tls)
		return ret
	}
	mountPoint = (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1
	if !(zipname != 0) {
		/*
		 * Mount point but no file, so describe what is mounted at that mount
		 * point.
		 */
		ret = _DescribeMounted(tls, interp, mountPoint)
		_Unlock(tls)
	} else {
		_Unlock(tls)
		zipPathObj = XTcl_NewStringObj(tls, zipname, int64(-int32(1)))
		(*TTcl_Obj)(unsafe.Pointer(zipPathObj)).FrefCount++
		normZipPathObj = XTcl_FSGetNormalizedPath(tls, interp, zipPathObj)
		if normZipPathObj == libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+73581, libc.VaList(bp+232, zipname)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+232, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+73619, libc.UintptrFromInt32(0)))
			ret = int32(TCL_ERROR)
		} else {
			(*TTcl_Obj)(unsafe.Pointer(normZipPathObj)).FrefCount++
			normPath = XTcl_GetStringFromObj(tls, normZipPathObj, libc.UintptrFromInt32(0))
			if v2 = passwd == libc.UintptrFromInt32(0); !v2 {
				v1 = _IsPasswordValid(tls, interp, passwd, libc.Xstrlen(tls, passwd))
				ret = v1
			}
			if v2 || v1 == TCL_OK {
				zf = _AllocateZipFile(tls, interp, libc.Xstrlen(tls, mountPoint))
				if zf == libc.UintptrFromInt32(0) {
					ret = int32(TCL_ERROR)
				} else {
					ret = _ZipFSOpenArchive(tls, interp, normPath, int32(1), zf)
					if ret != TCL_OK {
						XTclpFree(tls, zf)
					} else {
						ret = _ZipFSCatalogFilesystem(tls, interp, zf, mountPoint, passwd, normPath)
						/* Note zf is already freed on error! */
					}
				}
			}
			_objPtr = normZipPathObj
			v4 = _objPtr
			v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
			*(*TTcl_Size)(unsafe.Pointer(v4))--
			if v3 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			if ret == TCL_OK && interp != 0 {
				XTcl_DStringResult(tls, interp, bp)
			}
		}
		_objPtr1 = zipPathObj
		v6 = _objPtr1
		v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
		*(*TTcl_Size)(unsafe.Pointer(v6))--
		if v5 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
	XTcl_DStringFree(tls, bp)
	return ret
}

/*
 *-------------------------------------------------------------------------
 *
 * TclZipfs_MountBuffer --
 *
 *	This procedure is invoked to mount a given ZIP archive file on a given
 *	mountpoint.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	A ZIP archive file is read, analyzed and mounted, resources are
 *	allocated.
 *
 *-------------------------------------------------------------------------
 */

func XTclZipfs_MountBuffer(tls *libc.TLS, interp uintptr, data uintptr, datalen Tsize_t, mountPoint uintptr, copy1 int32) (r int32) {
	bp := tls.Alloc(272)
	defer tls.Free(272)
	var ret int32
	var zf uintptr
	var _ /* ds at bp+0 */ TTcl_DString
	_, _ = ret, zf
	if mountPoint == libc.UintptrFromInt32(0) || data == libc.UintptrFromInt32(0) {
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+73629, int64(-int32(1))))
		}
		return int32(TCL_ERROR)
	}
	/* TODO - how come a *read* lock suffices for initialzing ? */
	_ReadLock(tls)
	if !(_ZipFS.Finitialized != 0) {
		_ZipfsSetup(tls)
	}
	XTcl_DStringInit(tls, bp)
	ret = _NormalizeMountPoint(tls, interp, mountPoint, bp)
	if ret != TCL_OK {
		_Unlock(tls)
		return ret
	}
	mountPoint = (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1
	_Unlock(tls)
	/*
	 * Have both a mount point and data to mount there.
	 * What's the magic about 64 * 1024 * 1024 ?
	 */
	ret = int32(TCL_ERROR)
	if datalen <= uint64(ZIP_CENTRAL_END_LEN) || datalen-uint64(ZIP_CENTRAL_END_LEN) > libc.Uint64FromInt32(libc.Int32FromInt32(64)*libc.Int32FromInt32(1024)*libc.Int32FromInt32(1024)-int32(ZIP_CENTRAL_END_LEN)) {
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+73390, int64(-int32(1))))
		}
		if interp != 0 {
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+232, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+73408, libc.UintptrFromInt32(0)))
		}
		goto done
	}
	zf = _AllocateZipFile(tls, interp, libc.Xstrlen(tls, mountPoint))
	if zf == libc.UintptrFromInt32(0) {
		goto done
	}
	(*TZipFile)(unsafe.Pointer(zf)).FisMemBuffer = uint8(1)
	(*TZipFile)(unsafe.Pointer(zf)).Flength = datalen
	if copy1 != 0 {
		(*TZipFile)(unsafe.Pointer(zf)).Fdata = XTclpAlloc(tls, datalen)
		if (*TZipFile)(unsafe.Pointer(zf)).Fdata == libc.UintptrFromInt32(0) {
			_ZipFSCloseArchive(tls, interp, zf)
			XTclpFree(tls, zf)
			if interp != 0 {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+1638, int64(-int32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+232, __ccgo_ts+2004, __ccgo_ts+73148, libc.UintptrFromInt32(0)))
			}
			goto done
		}
		libc.Xmemcpy(tls, (*TZipFile)(unsafe.Pointer(zf)).Fdata, data, datalen)
		(*TZipFile)(unsafe.Pointer(zf)).FptrToFree = (*TZipFile)(unsafe.Pointer(zf)).Fdata
	} else {
		(*TZipFile)(unsafe.Pointer(zf)).Fdata = data
		(*TZipFile)(unsafe.Pointer(zf)).FptrToFree = libc.UintptrFromInt32(0)
	}
	ret = _ZipFSFindTOC(tls, interp, int32(1), zf)
	if ret != TCL_OK {
		XTclpFree(tls, zf)
	} else {
		/* Note ZipFSCatalogFilesystem will free zf on error */
		ret = _ZipFSCatalogFilesystem(tls, interp, zf, mountPoint, libc.UintptrFromInt32(0), __ccgo_ts+73662)
	}
	if ret == TCL_OK && interp != 0 {
		XTcl_DStringResult(tls, interp, bp)
	}
	goto done
done:
	;
	XTcl_DStringFree(tls, bp)
	return ret
}

/*
 *-------------------------------------------------------------------------
 *
 * TclZipfs_Unmount --
 *
 *	This procedure is invoked to unmount a given ZIP archive.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	A mounted ZIP archive file is unmounted, resources are free'd.
 *
 *-------------------------------------------------------------------------
 */

func XTclZipfs_Unmount(tls *libc.TLS, interp uintptr, mountPoint uintptr) (r int32) {
	bp := tls.Alloc(272)
	defer tls.Free(272) /* Mount point path. */
	var hPtr, zf uintptr
	var ret, unmounted int32
	var _ /* dsm at bp+0 */ TTcl_DString
	_, _, _, _ = hPtr, ret, unmounted, zf
	ret = TCL_OK
	unmounted = 0
	XTcl_DStringInit(tls, bp)
	_WriteLock(tls)
	if !(_ZipFS.Finitialized != 0) {
		goto done
	}
	/*
	 * Mount point sometimes is a relative or otherwise denormalized path.
	 * But an absolute name is needed as mount point here.
	 */
	if _NormalizeMountPoint(tls, interp, mountPoint, bp) != TCL_OK {
		goto done
	}
	mountPoint = (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ZipFS)) + 136)).FfindProc})))(tls, uintptr(unsafe.Pointer(&_ZipFS))+136, mountPoint)
	/* don't report no-such-mount as an error */
	if !(hPtr != 0) {
		goto done
	}
	zf = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
	if (*TZipFile)(unsafe.Pointer(zf)).FnumOpen > uint64(0) {
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+73676, int64(-int32(1))))
		}
		if interp != 0 {
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+232, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+9994, libc.UintptrFromInt32(0)))
		}
		ret = int32(TCL_ERROR)
		goto done
	}
	XTcl_DeleteHashEntry(tls, hPtr)
	/*
	 * Now no longer mounted - the rest of the code won't find it - but we're
	 * still cleaning things up.
	 */
	_CleanupMount(tls, zf)
	_ZipFSCloseArchive(tls, interp, zf)
	XTclpFree(tls, zf)
	unmounted = int32(1)
	goto done
done:
	;
	_Unlock(tls)
	XTcl_DStringFree(tls, bp)
	if unmounted != 0 {
		XTcl_FSMountsChanged(tls, libc.UintptrFromInt32(0))
	}
	return ret
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSMountObjCmd --
 *
 *	This procedure is invoked to process the [zipfs mount] command.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	A ZIP archive file is mounted, resources are allocated.
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSMountObjCmd(tls *libc.TLS, dummy2676 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var mountPoint, password, zipFile uintptr
	var result int32
	_, _, _, _ = mountPoint, password, result, zipFile
	mountPoint = libc.UintptrFromInt32(0)
	zipFile = libc.UintptrFromInt32(0)
	password = libc.UintptrFromInt32(0)
	if objc > int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+73695)
		return int32(TCL_ERROR)
	}
	/*
	 * A single argument is treated as the mountpoint. Two arguments
	 * are treated as zipfile and mountpoint.
	 */
	if objc > int32(1) {
		if objc == int32(2) {
			mountPoint = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
		} else {
			/* 2 < objc < 4 */
			zipFile = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
			mountPoint = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
			if objc > int32(3) {
				password = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0))
			}
		}
	}
	result = XTclZipfs_Mount(tls, interp, zipFile, mountPoint, password)
	return result
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSMountBufferObjCmd --
 *
 *	This procedure is invoked to process the [zipfs mountdata] command.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	A ZIP archive file is mounted, resources are allocated.
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSMountBufferObjCmd(tls *libc.TLS, dummy2727 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var data, mountPoint uintptr
	var _ /* length at bp+0 */ TTcl_Size
	_, _ = data, mountPoint
	mountPoint = libc.UintptrFromInt32(0) /* Mount point path. */
	data = libc.UintptrFromInt32(0)
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+73729)
		return int32(TCL_ERROR)
	}
	data = XTcl_GetBytesFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
	mountPoint = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
	if data == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	return XTclZipfs_MountBuffer(tls, interp, data, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))), mountPoint, int32(1))
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSRootObjCmd --
 *
 *	This procedure is invoked to process the [zipfs root] command. It
 *	returns the root that all zipfs file systems are mounted under.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSRootObjCmd(tls *libc.TLS, dummy2766 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	if objc != int32(1) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+1945)
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+72859, int64(-int32(1))))
	return TCL_OK
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSUnmountObjCmd --
 *
 *	This procedure is invoked to process the [zipfs unmount] command.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	A mounted ZIP archive file is unmounted, resources are free'd.
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSUnmountObjCmd(tls *libc.TLS, dummy2797 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var v1 uintptr
	_ = v1
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+73745)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	return XTclZipfs_Unmount(tls, interp, v1)
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSMkKeyObjCmd --
 *
 *	This procedure is invoked to process the [zipfs mkkey] command.  It
 *	produces a rotated password to be embedded into an image file.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSMkKeyObjCmd(tls *libc.TLS, dummy2828 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var ch int32
	var i, v2 TTcl_Size
	var passBuf, passObj, pw, v1 uintptr
	var _ /* len at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _ = ch, i, passBuf, passObj, pw, v1, v2
	i = 0
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+73756)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
	}
	pw = v1
	if *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
		return TCL_OK
	}
	if _IsPasswordValid(tls, interp, pw, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))) != TCL_OK {
		return int32(TCL_ERROR)
	}
	passObj = XTcl_NewByteArrayObj(tls, libc.UintptrFromInt32(0), int64(264))
	passBuf = XTcl_GetBytesFromObj(tls, libc.UintptrFromInt32(0), passObj, libc.UintptrFromInt32(0))
	for *(*TTcl_Size)(unsafe.Pointer(bp)) > 0 {
		ch = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pw + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp))-int64(1)))))
		v2 = i
		i++
		*(*uint8)(unsafe.Pointer(passBuf + uintptr(v2))) = libc.Uint8FromInt32(ch&int32(0x0f) | libc.Int32FromUint8(_pwrot[ch>>int32(4)&int32(0x0f)]))
		*(*TTcl_Size)(unsafe.Pointer(bp))--
	}
	*(*uint8)(unsafe.Pointer(passBuf + uintptr(i))) = libc.Uint8FromInt64(i)
	i++
	_ZipWriteInt(tls, passBuf, passBuf+uintptr(264), passBuf+uintptr(i), uint32(ZIP_PASSWORD_END_SIG))
	XTcl_SetByteArrayLength(tls, passObj, i+int64(4))
	XTcl_SetObjResult(tls, interp, passObj)
	return TCL_OK
}

/*
 *-------------------------------------------------------------------------
 *
 * RandomChar --
 *
 *	Worker for ZipAddFile().  Picks a random character (range: 0..255)
 *	using Tcl's standard PRNG.
 *
 * Returns:
 *	Tcl result code. Updates chPtr with random character on success.
 *
 * Side effects:
 *	Advances the PRNG state. May reenter the Tcl interpreter if the user
 *	has replaced the PRNG.
 *
 *-------------------------------------------------------------------------
 */

func _RandomChar(tls *libc.TLS, interp uintptr, step int32, chPtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var ret uintptr
	var _ /* r at bp+0 */ float64
	_ = ret
	if XTcl_EvalEx(tls, interp, __ccgo_ts+73765, int64(-libc.Int32FromInt32(1)), 0) != TCL_OK {
		goto failed
	}
	ret = XTcl_GetObjResult(tls, interp)
	if XTcl_GetDoubleFromObj(tls, interp, ret, bp) != TCL_OK {
		goto failed
	}
	*(*int32)(unsafe.Pointer(chPtr)) = int32(float64(*(*float64)(unsafe.Pointer(bp)) * libc.Float64FromInt32(256)))
	return TCL_OK
	goto failed
failed:
	;
	XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+73787, libc.VaList(bp+16, step)))
	return int32(TCL_ERROR)
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipAddFile --
 *
 *	This procedure is used by ZipFSMkZipOrImg() to add a single file to
 *	the output ZIP archive file being written. A ZipEntry struct about the
 *	input file is added to the given fileHash table for later creation of
 *	the central ZIP directory.
 *
 *	Tcl *always* encodes filenames in the ZIP as UTF-8. Similarly, it
 *	would always encode comments as UTF-8, if it supported comments.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	Input file is read and (compressed and) written to the output ZIP
 *	archive file.
 *
 *-------------------------------------------------------------------------
 */

func _ZipAddFile(tls *libc.TLS, interp uintptr, pathObj uintptr, name uintptr, out TTcl_Channel, passwd uintptr, buf uintptr, bufsize int32, fileHash uintptr) (r int32) {
	bp := tls.Alloc(4720)
	defer tls.Free(4720) /* Where to record ZIP entry metdata so we can
	 * built the central directory. */
	var aend, astart, end, hPtr, start, z, zpathExt, zpathTcl, v1, v14, v16, v22, v24, v6, v7, v9 uintptr
	var align, i1, i2, len1, olen TTcl_Size
	var compMeth, crc, flush, i, mtime, tmp, tmp1, tmp2, zpathlen, v12, v13, v15, v20, v23 int32
	var dataEndOffset, dataStartOffset, headerStartOffset int64
	var in TTcl_Channel
	var nbyte, nbytecompr, v2 Tsize_t
	var _ /* abuf at bp+4632 */ [8]uint8
	var _ /* ch at bp+4640 */ int32
	var _ /* isNew at bp+336 */ int32
	var _ /* keys at bp+344 */ [3]uint64
	var _ /* keys0 at bp+368 */ [3]uint64
	var _ /* kvbuf at bp+4644 */ [24]uint8
	var _ /* obuf at bp+392 */ [4096]uint8
	var _ /* statBuf at bp+4488 */ TTcl_StatBuf
	var _ /* stream at bp+0 */ Tz_stream
	var _ /* zpathDs at bp+112 */ TTcl_DString
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = aend, align, astart, compMeth, crc, dataEndOffset, dataStartOffset, end, flush, hPtr, headerStartOffset, i, i1, i2, in, len1, mtime, nbyte, nbytecompr, olen, start, tmp, tmp1, tmp2, z, zpathExt, zpathTcl, zpathlen, v1, v12, v13, v14, v15, v16, v2, v20, v22, v23, v24, v6, v7, v9
	start = buf
	end = buf + uintptr(bufsize)
	align = 0
	mtime = 0
	/*
	 * Trim leading '/' characters. If this results in an empty string, we've
	 * nothing to do.
	 */
	zpathTcl = name
	for zpathTcl != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(zpathTcl))) == int32('/') {
		zpathTcl++
	}
	if !(zpathTcl != 0) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(zpathTcl))) == int32('\000') {
		return TCL_OK
	}
	/*
	 * Convert to encoded form. Note that we use strlen() here; if someone's
	 * crazy enough to embed NULs in filenames, they deserve what they get!
	 */
	if XTcl_UtfToExternalDStringEx(tls, interp, XtclUtf8Encoding, zpathTcl, int64(-libc.Int32FromInt32(1)), 0, bp+112, libc.UintptrFromInt32(0)) != TCL_OK {
		XTcl_DStringFree(tls, bp+112)
		return int32(TCL_ERROR)
	}
	zpathExt = (*TTcl_DString)(unsafe.Pointer(bp + 112)).Fstring1
	zpathlen = libc.Int32FromUint64(libc.Xstrlen(tls, zpathExt))
	if zpathlen+int32(ZIP_CENTRAL_HEADER_LEN) > bufsize {
		if (*TTcl_Obj)(unsafe.Pointer(pathObj)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(pathObj)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, pathObj, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+73840, libc.VaList(bp+4680, v1)))
		if interp != 0 {
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+4680, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+73863, libc.UintptrFromInt32(0)))
		}
		XTcl_DStringFree(tls, bp+112)
		return int32(TCL_ERROR)
	}
	in = XTcl_FSOpenFileChannel(tls, interp, pathObj, __ccgo_ts+49954, 0)
	if !(in != 0) {
		XTcl_DStringFree(tls, bp+112)
		XTcl_CloseEx(tls, interp, in, 0)
		return int32(TCL_ERROR)
	} else {
		if XTcl_FSStat(tls, pathObj, bp+4488) != -int32(1) {
			mtime = int32((*(*TTcl_StatBuf)(unsafe.Pointer(bp + 4488))).Fst_mtim.Ftv_sec)
		}
	}
	XTcl_ResetResult(tls, interp)
	/*
	 * Compute the CRC.
	 */
	crc = 0
	v2 = libc.Uint64FromInt32(0)
	nbytecompr = v2
	nbyte = v2
_4:
	;
	if !(int32(1) != 0) {
		goto _3
	}
	len1 = XTcl_Read(tls, in, buf, int64(bufsize))
	if !(len1 < 0) {
		goto _5
	}
	XTcl_DStringFree(tls, bp+112)
	if nbyte == uint64(0) && *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(EISDIR) {
		XTcl_CloseEx(tls, interp, in, 0)
		return TCL_OK
	}
	goto readErrorWithChannelOpen
readErrorWithChannelOpen:
	;
	if (*TTcl_Obj)(unsafe.Pointer(pathObj)).Fbytes != 0 {
		v6 = (*TTcl_Obj)(unsafe.Pointer(pathObj)).Fbytes
	} else {
		v6 = XTcl_GetStringFromObj(tls, pathObj, libc.UintptrFromInt32(0))
	}
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+73872, libc.VaList(bp+4680, v6, XTcl_PosixError(tls, interp))))
	XTcl_CloseEx(tls, interp, in, 0)
	return int32(TCL_ERROR)
_5:
	;
	if len1 == 0 {
		goto _3
	}
	crc = libc.Int32FromUint64(libz.Xcrc32(tls, libc.Uint64FromInt32(crc), buf, libc.Uint32FromInt64(len1)))
	nbyte += libc.Uint64FromInt64(len1)
	goto _4
_3:
	;
	if XTcl_Seek(tls, in, 0, 0) == int64(-int32(1)) {
		if (*TTcl_Obj)(unsafe.Pointer(pathObj)).Fbytes != 0 {
			v7 = (*TTcl_Obj)(unsafe.Pointer(pathObj)).Fbytes
		} else {
			v7 = XTcl_GetStringFromObj(tls, pathObj, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+73895, libc.VaList(bp+4680, v7, XTcl_PosixError(tls, interp))))
		XTcl_CloseEx(tls, interp, in, 0)
		XTcl_DStringFree(tls, bp+112)
		return int32(TCL_ERROR)
	}
	/*
	 * Remember where we've got to so far so we can write the header (after
	 * writing the file).
	 */
	headerStartOffset = XTcl_Tell(tls, out)
	/*
	 * Reserve space for the per-file header. Includes writing the file name
	 * as we already know that.
	 */
	libc.Xmemset(tls, buf, int32('\000'), uint64(ZIP_LOCAL_HEADER_LEN))
	libc.Xmemcpy(tls, buf+uintptr(ZIP_LOCAL_HEADER_LEN), zpathExt, libc.Uint64FromInt32(zpathlen))
	len1 = int64(zpathlen + int32(ZIP_LOCAL_HEADER_LEN))
	if !(XTcl_Write(tls, out, buf, len1) != len1) {
		goto _8
	}
	goto writeErrorWithChannelOpen
writeErrorWithChannelOpen:
	;
	if (*TTcl_Obj)(unsafe.Pointer(pathObj)).Fbytes != 0 {
		v9 = (*TTcl_Obj)(unsafe.Pointer(pathObj)).Fbytes
	} else {
		v9 = XTcl_GetStringFromObj(tls, pathObj, libc.UintptrFromInt32(0))
	}
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+73918, libc.VaList(bp+4680, v9, XTcl_PosixError(tls, interp))))
	XTcl_CloseEx(tls, interp, in, 0)
	XTcl_DStringFree(tls, bp+112)
	return int32(TCL_ERROR)
_8:
	;
	/*
	 * Align payload to next 4-byte boundary (if necessary) using a dummy
	 * extra entry similar to the zipalign tool from Android's SDK.
	 */
	if (len1+headerStartOffset)&int64(3) != 0 {
		astart = bp + 4632
		aend = bp + 4632 + uintptr(8)
		align = int64(4) + (len1+headerStartOffset)&int64(3)
		_ZipWriteShort(tls, astart, aend, bp+4632, uint16(0xffff))
		_ZipWriteShort(tls, astart, aend, bp+4632+uintptr(2), libc.Uint16FromInt64(align-int64(4)))
		_ZipWriteInt(tls, astart, aend, bp+4632+uintptr(4), uint32(0x03020100))
		if XTcl_Write(tls, out, bp+4632, align) != align {
			goto writeErrorWithChannelOpen
		}
	}
	/*
	 * Set up encryption if we were asked to.
	 */
	if passwd != 0 {
		_init_keys(tls, passwd, bp+344, _crc32tab)
		i = 0
		for {
			if !(i < libc.Int32FromInt32(ZIP_CRYPT_HDR_LEN)-libc.Int32FromInt32(2)) {
				break
			}
			if _RandomChar(tls, interp, i, bp+4640) != TCL_OK {
				XTcl_CloseEx(tls, interp, in, 0)
				return int32(TCL_ERROR)
			}
			tmp = _decrypt_byte(tls, bp+344, _crc32tab)
			_update_keys(tls, bp+344, _crc32tab, *(*int32)(unsafe.Pointer(bp + 4640)))
			(*(*[24]uint8)(unsafe.Pointer(bp + 4644)))[i+int32(ZIP_CRYPT_HDR_LEN)] = libc.Uint8FromInt32(libc.Int32FromUint8(libc.Uint8FromInt32(tmp)) ^ *(*int32)(unsafe.Pointer(bp + 4640)))
			goto _10
		_10:
			;
			i++
		}
		XTcl_ResetResult(tls, interp)
		_init_keys(tls, passwd, bp+344, _crc32tab)
		i = 0
		for {
			if !(i < libc.Int32FromInt32(ZIP_CRYPT_HDR_LEN)-libc.Int32FromInt32(2)) {
				break
			}
			tmp = _decrypt_byte(tls, bp+344, _crc32tab)
			_update_keys(tls, bp+344, _crc32tab, libc.Int32FromUint8((*(*[24]uint8)(unsafe.Pointer(bp + 4644)))[i+int32(ZIP_CRYPT_HDR_LEN)]))
			(*(*[24]uint8)(unsafe.Pointer(bp + 4644)))[i] = libc.Uint8FromInt32(libc.Int32FromUint8(libc.Uint8FromInt32(tmp)) ^ libc.Int32FromUint8((*(*[24]uint8)(unsafe.Pointer(bp + 4644)))[i+int32(ZIP_CRYPT_HDR_LEN)]))
			goto _11
		_11:
			;
			i++
		}
		v12 = i
		i++
		tmp = _decrypt_byte(tls, bp+344, _crc32tab)
		_update_keys(tls, bp+344, _crc32tab, crc>>int32(16))
		(*(*[24]uint8)(unsafe.Pointer(bp + 4644)))[v12] = libc.Uint8FromInt32(libc.Int32FromUint8(libc.Uint8FromInt32(tmp)) ^ crc>>libc.Int32FromInt32(16))
		v13 = i
		i++
		tmp = _decrypt_byte(tls, bp+344, _crc32tab)
		_update_keys(tls, bp+344, _crc32tab, crc>>int32(24))
		(*(*[24]uint8)(unsafe.Pointer(bp + 4644)))[v13] = libc.Uint8FromInt32(libc.Int32FromUint8(libc.Uint8FromInt32(tmp)) ^ crc>>libc.Int32FromInt32(24))
		len1 = XTcl_Write(tls, out, bp+4644, int64(ZIP_CRYPT_HDR_LEN))
		libc.Xmemset(tls, bp+4644, 0, uint64(24))
		if len1 != int64(ZIP_CRYPT_HDR_LEN) {
			goto writeErrorWithChannelOpen
		}
		libc.Xmemcpy(tls, bp+368, bp+344, uint64(24))
		nbytecompr += uint64(ZIP_CRYPT_HDR_LEN)
	}
	/*
	 * Save where we've got to in case we need to just store this file.
	 */
	XTcl_Flush(tls, out)
	dataStartOffset = XTcl_Tell(tls, out)
	/*
	 * Compress the stream.
	 */
	compMeth = int32(ZIP_COMPMETH_DEFLATED)
	libc.Xmemset(tls, bp, 0, uint64(112))
	(*(*Tz_stream)(unsafe.Pointer(bp))).Fzalloc = uintptr(Z_NULL)
	(*(*Tz_stream)(unsafe.Pointer(bp))).Fzfree = uintptr(Z_NULL)
	(*(*Tz_stream)(unsafe.Pointer(bp))).Fopaque = uintptr(Z_NULL)
	if libz.XdeflateInit2_(tls, bp, int32(9), int32(Z_DEFLATED), -int32(15), int32(8), Z_DEFAULT_STRATEGY, __ccgo_ts+70913, libc.Int32FromInt64(112)) != Z_OK {
		if (*TTcl_Obj)(unsafe.Pointer(pathObj)).Fbytes != 0 {
			v14 = (*TTcl_Obj)(unsafe.Pointer(pathObj)).Fbytes
		} else {
			v14 = XTcl_GetStringFromObj(tls, pathObj, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+73942, libc.VaList(bp+4680, v14)))
		if interp != 0 {
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+4680, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+73973, libc.UintptrFromInt32(0)))
		}
		XTcl_CloseEx(tls, interp, in, 0)
		XTcl_DStringFree(tls, bp+112)
		return int32(TCL_ERROR)
	}
	for cond := true; cond; cond = flush != int32(Z_FINISH) {
		len1 = XTcl_Read(tls, in, buf, int64(bufsize))
		if len1 < 0 {
			libz.XdeflateEnd(tls, bp)
			goto readErrorWithChannelOpen
		}
		(*(*Tz_stream)(unsafe.Pointer(bp))).Favail_in = libc.Uint32FromInt64(len1)
		(*(*Tz_stream)(unsafe.Pointer(bp))).Fnext_in = buf
		if XTcl_Eof(tls, in) != 0 {
			v15 = int32(Z_FINISH)
		} else {
			v15 = Z_NO_FLUSH
		}
		flush = v15
		for cond := true; cond; cond = (*(*Tz_stream)(unsafe.Pointer(bp))).Favail_out == uint32(0) {
			(*(*Tz_stream)(unsafe.Pointer(bp))).Favail_out = uint32(4096)
			(*(*Tz_stream)(unsafe.Pointer(bp))).Fnext_out = bp + 392
			len1 = int64(libz.Xdeflate(tls, bp, flush))
			if len1 == int64(-libc.Int32FromInt32(2)) {
				if (*TTcl_Obj)(unsafe.Pointer(pathObj)).Fbytes != 0 {
					v16 = (*TTcl_Obj)(unsafe.Pointer(pathObj)).Fbytes
				} else {
					v16 = XTcl_GetStringFromObj(tls, pathObj, libc.UintptrFromInt32(0))
				}
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+73986, libc.VaList(bp+4680, v16)))
				if interp != 0 {
					XTcl_SetErrorCode(tls, interp, libc.VaList(bp+4680, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+74008, libc.UintptrFromInt32(0)))
				}
				libz.XdeflateEnd(tls, bp)
				XTcl_CloseEx(tls, interp, in, 0)
				XTcl_DStringFree(tls, bp+112)
				return int32(TCL_ERROR)
			}
			olen = libc.Int64FromUint64(uint64(4096) - uint64((*(*Tz_stream)(unsafe.Pointer(bp))).Favail_out))
			if passwd != 0 {
				i1 = 0
				for {
					if !(i1 < olen) {
						break
					}
					tmp1 = _decrypt_byte(tls, bp+344, _crc32tab)
					_update_keys(tls, bp+344, _crc32tab, libc.Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 392)))[i1]))
					(*(*[4096]uint8)(unsafe.Pointer(bp + 392)))[i1] = libc.Uint8FromInt32(libc.Int32FromUint8(libc.Uint8FromInt32(tmp1)) ^ libc.Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 392)))[i1]))
					goto _17
				_17:
					;
					i1++
				}
			}
			if olen != 0 && XTcl_Write(tls, out, bp+392, olen) != olen {
				libz.XdeflateEnd(tls, bp)
				goto writeErrorWithChannelOpen
			}
			nbytecompr += libc.Uint64FromInt64(olen)
		}
	}
	libz.XdeflateEnd(tls, bp)
	/*
	 * Work out where we've got to.
	 */
	XTcl_Flush(tls, out)
	dataEndOffset = XTcl_Tell(tls, out)
	if !(nbyte-nbytecompr <= uint64(0)) {
		goto _18
	}
	/*
	 * Compressed file larger than input, write it again uncompressed.
	 */
	if XTcl_Seek(tls, in, 0, 0) != 0 {
		goto seekErr
	}
	if !(XTcl_Seek(tls, out, dataStartOffset, 0) != dataStartOffset) {
		goto _19
	}
	goto seekErr
seekErr:
	;
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+74016, libc.VaList(bp+4680, XTcl_PosixError(tls, interp))))
	XTcl_CloseEx(tls, interp, in, 0)
	XTcl_DStringFree(tls, bp+112)
	return int32(TCL_ERROR)
_19:
	;
	if passwd != 0 {
		v20 = int32(ZIP_CRYPT_HDR_LEN)
	} else {
		v20 = 0
	}
	nbytecompr = libc.Uint64FromInt32(v20)
	for int32(1) != 0 {
		len1 = XTcl_Read(tls, in, buf, int64(bufsize))
		if len1 < 0 {
			goto readErrorWithChannelOpen
		} else {
			if len1 == 0 {
				break
			}
		}
		if passwd != 0 {
			i2 = 0
			for {
				if !(i2 < len1) {
					break
				}
				tmp2 = _decrypt_byte(tls, bp+368, _crc32tab)
				_update_keys(tls, bp+368, _crc32tab, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(buf + uintptr(i2)))))
				*(*uint8)(unsafe.Pointer(buf + uintptr(i2))) = libc.Uint8FromInt32(libc.Int32FromUint8(libc.Uint8FromInt32(tmp2)) ^ libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(buf + uintptr(i2)))))
				goto _21
			_21:
				;
				i2++
			}
		}
		if XTcl_Write(tls, out, buf, len1) != len1 {
			goto writeErrorWithChannelOpen
		}
		nbytecompr += libc.Uint64FromInt64(len1)
	}
	compMeth = int32(ZIP_COMPMETH_STORED)
	/*
	 * Chop off everything after this; it's the over-large compressed data
	 * and we don't know if it is going to get overwritten otherwise.
	 */
	XTcl_Flush(tls, out)
	dataEndOffset = XTcl_Tell(tls, out)
	XTcl_TruncateChannel(tls, out, dataEndOffset)
_18:
	;
	XTcl_CloseEx(tls, interp, in, 0)
	XTcl_DStringFree(tls, bp+112)
	zpathExt = libc.UintptrFromInt32(0)
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(fileHash)).FcreateProc})))(tls, fileHash, zpathTcl, bp+336)
	if !(*(*int32)(unsafe.Pointer(bp + 336)) != 0) {
		if (*TTcl_Obj)(unsafe.Pointer(pathObj)).Fbytes != 0 {
			v22 = (*TTcl_Obj)(unsafe.Pointer(pathObj)).Fbytes
		} else {
			v22 = XTcl_GetStringFromObj(tls, pathObj, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+74031, libc.VaList(bp+4680, v22)))
		if interp != 0 {
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+4680, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+74057, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	/*
	 * Remember that we've written the file (for central directory generation)
	 * and generate the local (per-file) header in the space that we reserved
	 * earlier.
	 */
	z = _AllocateZipEntry(tls)
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = z
	if passwd != 0 {
		v23 = int32(1)
	} else {
		v23 = 0
	}
	(*TZipEntry)(unsafe.Pointer(z)).FisEncrypted = v23
	(*TZipEntry)(unsafe.Pointer(z)).Foffset = libc.Uint64FromInt64(headerStartOffset)
	(*TZipEntry)(unsafe.Pointer(z)).Fcrc32 = crc
	(*TZipEntry)(unsafe.Pointer(z)).Ftimestamp = mtime
	(*TZipEntry)(unsafe.Pointer(z)).FnumBytes = libc.Int32FromUint64(nbyte)
	(*TZipEntry)(unsafe.Pointer(z)).FnumCompressedBytes = libc.Int32FromUint64(nbytecompr)
	(*TZipEntry)(unsafe.Pointer(z)).FcompressMethod = compMeth
	if (*TTcl_HashTable)(unsafe.Pointer(fileHash)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(fileHash)).FkeyType == -int32(1) {
		v24 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
	} else {
		v24 = hPtr + 32
	}
	(*TZipEntry)(unsafe.Pointer(z)).Fname = v24
	/*
	 * Write final local header information.
	 */
	_SerializeLocalEntryHeader(tls, start, end, buf, z, zpathlen, int32(align))
	if XTcl_Seek(tls, out, headerStartOffset, 0) != headerStartOffset {
		XTcl_DeleteHashEntry(tls, hPtr)
		XTclpFree(tls, z)
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+74016, libc.VaList(bp+4680, XTcl_PosixError(tls, interp))))
		return int32(TCL_ERROR)
	}
	if XTcl_Write(tls, out, buf, int64(ZIP_LOCAL_HEADER_LEN)) != int64(ZIP_LOCAL_HEADER_LEN) {
		XTcl_DeleteHashEntry(tls, hPtr)
		XTclpFree(tls, z)
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+74072, libc.VaList(bp+4680, XTcl_PosixError(tls, interp))))
		return int32(TCL_ERROR)
	}
	XTcl_Flush(tls, out)
	if XTcl_Seek(tls, out, dataEndOffset, 0) != dataEndOffset {
		XTcl_DeleteHashEntry(tls, hPtr)
		XTclpFree(tls, z)
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+74016, libc.VaList(bp+4680, XTcl_PosixError(tls, interp))))
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSFind --
 *
 *	Worker for ZipFSMkZipOrImg() that discovers the list of files to add.
 *	Simple wrapper around [zipfs find].
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSFind(tls *libc.TLS, interp uintptr, dirRoot uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, v2 uintptr
	var result int32
	var v1 TTcl_Size
	var _ /* cmd at bp+0 */ [2]uintptr
	_, _, _, _ = _objPtr, result, v1, v2
	(*(*[2]uintptr)(unsafe.Pointer(bp)))[0] = XTcl_NewStringObj(tls, __ccgo_ts+74088, int64(-int32(1)))
	(*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)] = dirRoot
	(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp)))[0])).FrefCount++
	result = XTcl_EvalObjv(tls, interp, int64(2), bp, 0)
	_objPtr = (*(*[2]uintptr)(unsafe.Pointer(bp)))[0]
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	if result != TCL_OK {
		return libc.UintptrFromInt32(0)
	}
	return XTcl_GetObjResult(tls, interp)
}

/*
 *-------------------------------------------------------------------------
 *
 * ComputeNameInArchive --
 *
 *	Helper for ZipFSMkZipOrImg() that computes what the actual name of a
 *	file in the ZIP archive should be, stripping a prefix (if appropriate)
 *	and any leading slashes. If the result is an empty string, the entry
 *	should be skipped.
 *
 * Returns:
 *	Pointer to the name (in Tcl's internal encoding), which will be in
 *	memory owned by one of the argument objects.
 *
 * Side effects:
 *	None (if Tcl_Objs have string representations)
 *
 *-------------------------------------------------------------------------
 */

func _ComputeNameInArchive(tls *libc.TLS, pathObj uintptr, directNameObj uintptr, strip uintptr, slen TTcl_Size) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The length of the prefix; must be 0 if no
	 * stripping need be done. */
	var name, v1, v2 uintptr
	var _ /* len at bp+0 */ TTcl_Size
	_, _, _ = name, v1, v2
	if directNameObj != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(directNameObj)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(directNameObj)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, directNameObj, libc.UintptrFromInt32(0))
		}
		name = v1
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(pathObj)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(pathObj)).Flength
			v2 = (*TTcl_Obj)(unsafe.Pointer(pathObj)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, pathObj, bp)
		}
		name = v2
		if slen > 0 {
			if *(*TTcl_Size)(unsafe.Pointer(bp)) <= slen || libc.Xstrncmp(tls, strip, name, libc.Uint64FromInt64(slen)) != 0 {
				/*
				 * Guaranteed to be a NUL at the end, which will make this
				 * entry be skipped.
				 */
				return name + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))
			}
			name += uintptr(slen)
		}
	}
	for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32('/') {
		name++
	}
	return name
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSMkZipOrImg --
 *
 *	This procedure is creates a new ZIP archive file or image file given
 *	output filename, input directory of files to be archived, optional
 *	password, and optional image to be prepended to the output ZIP archive
 *	file. It's the core of the implementation of [zipfs mkzip], [zipfs
 *	mkimg], [zipfs lmkzip] and [zipfs lmkimg].
 *
 *	Tcl *always* encodes filenames in the ZIP as UTF-8. Similarly, it
 *	would always encode comments as UTF-8, if it supported comments.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	A new ZIP archive file or image file is written.
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSMkZipOrImg(tls *libc.TLS, interp uintptr, isImg int32, targetFile uintptr, dirRoot uintptr, mappingList uintptr, originFile uintptr, stripPrefix uintptr, passwordObj uintptr) (r int32) {
	bp := tls.Alloc(5184)
	defer tls.Free(5184) /* The password for encoding things. NULL if
	 * there's no password protection. */
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, _objPtr6, _objPtr7, _objPtr8, end, hPtr, imgName, list, name, name1, pathObj, pw, start, strip, z, zf, v1, v14, v16, v17, v18, v27, v29, v31, v32, v34, v37, v40, v5, v7, v9 uintptr
	var ch, count, isMounted, ret, v10, v2, v35, v38 int32
	var dataStartOffset, directoryStartOffset, suffixStartOffset, v11, v12, v3 int64
	var i, len1, v13, v15, v20, v21, v22, v23, v24, v26, v28, v30, v39, v4, v6, v8 TTcl_Size
	var out TTcl_Channel
	var _ /* buf at bp+424 */ [4096]uint8
	var _ /* ds at bp+4920 */ TTcl_DString
	var _ /* fileHash at bp+56 */ TTcl_HashTable
	var _ /* lobjc at bp+16 */ TTcl_Size
	var _ /* lobjv at bp+24 */ uintptr
	var _ /* passBuf at bp+160 */ [264]uint8
	var _ /* pwlen at bp+0 */ TTcl_Size
	var _ /* search at bp+32 */ TTcl_HashSearch
	var _ /* slen at bp+8 */ TTcl_Size
	var _ /* zf0 at bp+4520 */ TZipFile
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, _objPtr6, _objPtr7, _objPtr8, ch, count, dataStartOffset, directoryStartOffset, end, hPtr, i, imgName, isMounted, len1, list, name, name1, out, pathObj, pw, ret, start, strip, suffixStartOffset, z, zf, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v2, v20, v21, v22, v23, v24, v26, v27, v28, v29, v3, v30, v31, v32, v34, v35, v37, v38, v39, v4, v40, v5, v6, v7, v8, v9
	ret = int32(TCL_ERROR)
	*(*TTcl_Size)(unsafe.Pointer(bp)) = 0
	*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = 0
	i = 0
	list = mappingList
	strip = libc.UintptrFromInt32(0)
	pw = libc.UintptrFromInt32(0)
	start = bp + 424
	end = start + uintptr(4096)
	/*
	 * Caller has verified that the number of arguments is correct.
	 */
	(*(*[264]uint8)(unsafe.Pointer(bp + 160)))[0] = uint8(0)
	if passwordObj != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(passwordObj)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(passwordObj)).Flength
			v1 = (*TTcl_Obj)(unsafe.Pointer(passwordObj)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, passwordObj, bp)
		}
		pw = v1
		if _IsPasswordValid(tls, interp, pw, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))) != TCL_OK {
			return int32(TCL_ERROR)
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
			pw = libc.UintptrFromInt32(0)
		}
	}
	if dirRoot != libc.UintptrFromInt32(0) {
		list = _ZipFSFind(tls, interp, dirRoot)
		if !(list != 0) {
			return int32(TCL_ERROR)
		}
	}
	(*TTcl_Obj)(unsafe.Pointer(list)).FrefCount++
	if (*TTcl_Obj)(unsafe.Pointer(list)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(list + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(list + 32))).Fptr2)).FspanLength
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(list + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = v3
		v2 = libc.Int32FromInt32(TCL_OK)
	} else {
		v2 = XTcl_ListObjLength(tls, interp, list, bp+16)
	}
	if v2 != TCL_OK {
		_objPtr = list
		v5 = _objPtr
		v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
		*(*TTcl_Size)(unsafe.Pointer(v5))--
		if v4 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		return int32(TCL_ERROR)
	}
	if mappingList != 0 && *(*TTcl_Size)(unsafe.Pointer(bp + 16))%int64(2) != 0 {
		_objPtr1 = list
		v7 = _objPtr1
		v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
		*(*TTcl_Size)(unsafe.Pointer(v7))--
		if v6 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+74107, int64(-int32(1))))
		}
		if interp != 0 {
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+5152, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+74136, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) == 0 {
		_objPtr2 = list
		v9 = _objPtr2
		v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
		*(*TTcl_Size)(unsafe.Pointer(v9))--
		if v8 <= int64(1) {
			XTclFreeObj(tls, _objPtr2)
		}
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+73205, int64(-int32(1))))
		}
		if interp != 0 {
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+5152, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+22759, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(list)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(list + 32))).Fptr2 != 0 {
			v11 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(list + 32))).Fptr2)).FspanStart
		} else {
			v11 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(list + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 24)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(list + 32))).Fptr1 + 40 + uintptr(v11)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(list + 32))).Fptr2 != 0 {
			v12 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(list + 32))).Fptr2)).FspanLength
		} else {
			v12 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(list + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 16)) = v12
		v10 = libc.Int32FromInt32(TCL_OK)
	} else {
		v10 = XTcl_ListObjGetElements(tls, interp, list, bp+16, bp+24)
	}
	if v10 != TCL_OK {
		_objPtr3 = list
		v14 = _objPtr3
		v13 = *(*TTcl_Size)(unsafe.Pointer(v14))
		*(*TTcl_Size)(unsafe.Pointer(v14))--
		if v13 <= int64(1) {
			XTclFreeObj(tls, _objPtr3)
		}
		return int32(TCL_ERROR)
	}
	out = XTcl_FSOpenFileChannel(tls, interp, targetFile, __ccgo_ts+49951, int32(0755))
	if out == libc.UintptrFromInt32(0) {
		_objPtr4 = list
		v16 = _objPtr4
		v15 = *(*TTcl_Size)(unsafe.Pointer(v16))
		*(*TTcl_Size)(unsafe.Pointer(v16))--
		if v15 <= int64(1) {
			XTclFreeObj(tls, _objPtr4)
		}
		return int32(TCL_ERROR)
	}
	/*
	 * Copy the existing contents from the image if it is an executable image.
	 * Care must be taken because this might include an existing ZIP, which
	 * needs to be stripped.
	 */
	if isImg != 0 {
		isMounted = 0
		// TODO: normalize the origin file name
		if originFile != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(originFile)).Fbytes != 0 {
				v18 = (*TTcl_Obj)(unsafe.Pointer(originFile)).Fbytes
			} else {
				v18 = XTcl_GetStringFromObj(tls, originFile, libc.UintptrFromInt32(0))
			}
			v17 = v18
		} else {
			v17 = XTcl_GetNameOfExecutable(tls)
		}
		imgName = v17
		if *(*TTcl_Size)(unsafe.Pointer(bp)) != 0 {
			i = 0
			len1 = *(*TTcl_Size)(unsafe.Pointer(bp))
			for {
				v20 = len1
				len1--
				if !(v20 > 0) {
					break
				}
				ch = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pw + uintptr(len1))))
				(*(*[264]uint8)(unsafe.Pointer(bp + 160)))[i] = libc.Uint8FromInt32(ch&int32(0x0f) | libc.Int32FromUint8(_pwrot[ch>>int32(4)&int32(0x0f)]))
				i++
				goto _19
			_19:
			}
			(*(*[264]uint8)(unsafe.Pointer(bp + 160)))[i] = libc.Uint8FromInt64(i)
			i++
			v21 = i
			i++
			(*(*[264]uint8)(unsafe.Pointer(bp + 160)))[v21] = libc.Uint8FromInt32(ZIP_PASSWORD_END_SIG)
			v22 = i
			i++
			(*(*[264]uint8)(unsafe.Pointer(bp + 160)))[v22] = libc.Uint8FromInt32(libc.Int32FromInt32(ZIP_PASSWORD_END_SIG) >> libc.Int32FromInt32(8))
			v23 = i
			i++
			(*(*[264]uint8)(unsafe.Pointer(bp + 160)))[v23] = libc.Uint8FromInt32(libc.Int32FromInt32(ZIP_PASSWORD_END_SIG) >> libc.Int32FromInt32(16))
			v24 = i
			i++
			(*(*[264]uint8)(unsafe.Pointer(bp + 160)))[v24] = libc.Uint8FromInt32(libc.Int32FromInt32(ZIP_PASSWORD_END_SIG) >> libc.Int32FromInt32(24))
			(*(*[264]uint8)(unsafe.Pointer(bp + 160)))[i] = uint8('\000')
		}
		/*
		 * Check for mounted image.
		 */
		_WriteLock(tls)
		hPtr = XTcl_FirstHashEntry(tls, uintptr(unsafe.Pointer(&_ZipFS))+136, bp+32)
		for {
			if !(hPtr != 0) {
				break
			}
			zf = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
			if libc.Xstrcmp(tls, (*TZipFile)(unsafe.Pointer(zf)).Fname, imgName) == 0 {
				isMounted = int32(1)
				(*TZipFile)(unsafe.Pointer(zf)).FnumOpen++
				break
			}
			goto _25
		_25:
			;
			hPtr = XTcl_NextHashEntry(tls, bp+32)
		}
		_Unlock(tls)
		if !(isMounted != 0) {
			zf = bp + 4520
			libc.Xmemset(tls, bp+4520, 0, uint64(400))
		}
		if isMounted != 0 || _ZipFSOpenArchive(tls, interp, imgName, 0, zf) == TCL_OK {
			/*
			 * Copy everything up to the ZIP-related suffix.
			 */
			if libc.Uint64FromInt64(XTcl_Write(tls, out, (*TZipFile)(unsafe.Pointer(zf)).Fdata, libc.Int64FromUint64((*TZipFile)(unsafe.Pointer(zf)).FpassOffset))) != (*TZipFile)(unsafe.Pointer(zf)).FpassOffset {
				libc.Xmemset(tls, bp+160, 0, uint64(264))
				_objPtr5 = list
				v27 = _objPtr5
				v26 = *(*TTcl_Size)(unsafe.Pointer(v27))
				*(*TTcl_Size)(unsafe.Pointer(v27))--
				if v26 <= int64(1) {
					XTclFreeObj(tls, _objPtr5)
				}
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+74072, libc.VaList(bp+5152, XTcl_PosixError(tls, interp))))
				XTcl_CloseEx(tls, interp, out, 0)
				if zf == bp+4520 {
					_ZipFSCloseArchive(tls, interp, zf)
				} else {
					_WriteLock(tls)
					(*TZipFile)(unsafe.Pointer(zf)).FnumOpen--
					_Unlock(tls)
				}
				return int32(TCL_ERROR)
			}
			if zf == bp+4520 {
				_ZipFSCloseArchive(tls, interp, zf)
			} else {
				_WriteLock(tls)
				(*TZipFile)(unsafe.Pointer(zf)).FnumOpen--
				_Unlock(tls)
			}
		} else {
			/*
			 * Fall back to read it as plain file which hopefully is a static
			 * tclsh or wish binary with proper zipfs infrastructure built in.
			 */
			if _CopyImageFile(tls, interp, imgName, out) != TCL_OK {
				libc.Xmemset(tls, bp+160, 0, uint64(264))
				_objPtr6 = list
				v29 = _objPtr6
				v28 = *(*TTcl_Size)(unsafe.Pointer(v29))
				*(*TTcl_Size)(unsafe.Pointer(v29))--
				if v28 <= int64(1) {
					XTclFreeObj(tls, _objPtr6)
				}
				XTcl_CloseEx(tls, interp, out, 0)
				return int32(TCL_ERROR)
			}
		}
		/*
		 * Store the password so that the automounter can find it.
		 */
		len1 = libc.Int64FromUint64(libc.Xstrlen(tls, bp+160))
		if len1 > 0 {
			i = XTcl_Write(tls, out, bp+160, len1)
			if i != len1 {
				_objPtr7 = list
				v31 = _objPtr7
				v30 = *(*TTcl_Size)(unsafe.Pointer(v31))
				*(*TTcl_Size)(unsafe.Pointer(v31))--
				if v30 <= int64(1) {
					XTclFreeObj(tls, _objPtr7)
				}
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+74072, libc.VaList(bp+5152, XTcl_PosixError(tls, interp))))
				XTcl_CloseEx(tls, interp, out, 0)
				return int32(TCL_ERROR)
			}
		}
		libc.Xmemset(tls, bp+160, 0, uint64(264))
		XTcl_Flush(tls, out)
		dataStartOffset = XTcl_Tell(tls, out)
	} else {
		dataStartOffset = 0
	}
	/*
	 * Prepare the contents of the ZIP archive.
	 */
	XTcl_InitHashTable(tls, bp+56, TCL_STRING_KEYS)
	if mappingList == libc.UintptrFromInt32(0) && stripPrefix != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(stripPrefix)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(stripPrefix)).Flength
			v32 = (*TTcl_Obj)(unsafe.Pointer(stripPrefix)).Fbytes
		} else {
			v32 = XTcl_GetStringFromObj(tls, stripPrefix, bp+8)
		}
		strip = v32
		if !(*(*TTcl_Size)(unsafe.Pointer(bp + 8)) != 0) {
			strip = libc.UintptrFromInt32(0)
		}
	}
	i = 0
	for {
		if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 16))) {
			break
		}
		pathObj = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + uintptr(i)*8))
		if mappingList != 0 {
			v34 = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + uintptr(i+int64(1))*8))
		} else {
			v34 = libc.UintptrFromInt32(0)
		}
		name = _ComputeNameInArchive(tls, pathObj, v34, strip, *(*TTcl_Size)(unsafe.Pointer(bp + 8)))
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32('\000') {
			goto _33
		}
		if _ZipAddFile(tls, interp, pathObj, name, out, pw, bp+424, int32(4096), bp+56) != TCL_OK {
			goto done
		}
		goto _33
	_33:
		;
		if mappingList != 0 {
			v35 = int32(2)
		} else {
			v35 = int32(1)
		}
		i += int64(v35)
	}
	/*
	 * Construct the contents of the ZIP central directory.
	 */
	directoryStartOffset = XTcl_Tell(tls, out)
	count = 0
	i = 0
	for {
		if !(i < *(*TTcl_Size)(unsafe.Pointer(bp + 16))) {
			break
		}
		if mappingList != 0 {
			v37 = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + uintptr(i+int64(1))*8))
		} else {
			v37 = libc.UintptrFromInt32(0)
		}
		name1 = _ComputeNameInArchive(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + uintptr(i)*8)), v37, strip, *(*TTcl_Size)(unsafe.Pointer(bp + 8)))
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(bp + 56)).FfindProc})))(tls, bp+56, name1)
		if !(hPtr != 0) {
			goto _36
		}
		z = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		if XTcl_UtfToExternalDStringEx(tls, interp, XtclUtf8Encoding, (*TZipEntry)(unsafe.Pointer(z)).Fname, int64(-libc.Int32FromInt32(1)), 0, bp+4920, libc.UintptrFromInt32(0)) != TCL_OK {
			ret = int32(TCL_ERROR)
			goto done
		}
		name1 = (*TTcl_DString)(unsafe.Pointer(bp + 4920)).Fstring1
		len1 = (*TTcl_DString)(unsafe.Pointer(bp + 4920)).Flength
		_SerializeCentralDirectoryEntry(tls, start, end, bp+424, z, libc.Uint64FromInt64(len1), dataStartOffset)
		if XTcl_Write(tls, out, bp+424, int64(ZIP_CENTRAL_HEADER_LEN)) != int64(ZIP_CENTRAL_HEADER_LEN) || XTcl_Write(tls, out, name1, len1) != len1 {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+74072, libc.VaList(bp+5152, XTcl_PosixError(tls, interp))))
			XTcl_DStringFree(tls, bp+4920)
			goto done
		}
		XTcl_DStringFree(tls, bp+4920)
		count++
		goto _36
	_36:
		;
		if mappingList != 0 {
			v38 = int32(2)
		} else {
			v38 = int32(1)
		}
		i += int64(v38)
	}
	/*
	 * Finalize the central directory.
	 */
	XTcl_Flush(tls, out)
	suffixStartOffset = XTcl_Tell(tls, out)
	_SerializeCentralDirectorySuffix(tls, start, end, bp+424, count, dataStartOffset, directoryStartOffset, suffixStartOffset)
	if XTcl_Write(tls, out, bp+424, int64(ZIP_CENTRAL_END_LEN)) != int64(ZIP_CENTRAL_END_LEN) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+74072, libc.VaList(bp+5152, XTcl_PosixError(tls, interp))))
		goto done
	}
	XTcl_Flush(tls, out)
	ret = TCL_OK
	goto done
done:
	;
	if ret == TCL_OK {
		ret = XTcl_CloseEx(tls, interp, out, 0)
	} else {
		XTcl_CloseEx(tls, interp, out, 0)
	}
	_objPtr8 = list
	v40 = _objPtr8
	v39 = *(*TTcl_Size)(unsafe.Pointer(v40))
	*(*TTcl_Size)(unsafe.Pointer(v40))--
	if v39 <= int64(1) {
		XTclFreeObj(tls, _objPtr8)
	}
	hPtr = XTcl_FirstHashEntry(tls, bp+56, bp+32)
	for {
		if !(hPtr != 0) {
			break
		}
		z = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		XTclpFree(tls, z)
		XTcl_DeleteHashEntry(tls, hPtr)
		goto _41
	_41:
		;
		hPtr = XTcl_NextHashEntry(tls, bp+32)
	}
	XTcl_DeleteHashTable(tls, bp+56)
	return ret
}

/*
 * ---------------------------------------------------------------------
 *
 * CopyImageFile --
 *
 *	A simple file copy function that is used (by ZipFSMkZipOrImg) for
 *	anything that is not an image with a ZIP appended.
 *
 * Returns:
 *	A Tcl result code.
 *
 * Side effects:
 *	Writes to an output channel.
 *
 * ---------------------------------------------------------------------
 */

func _CopyImageFile(tls *libc.TLS, interp uintptr, imgName uintptr, out TTcl_Channel) (r int32) {
	bp := tls.Alloc(4128)
	defer tls.Free(4128) /* Where to copy to; already open for writing
	 * binary data. */
	var errMsg uintptr
	var i, k TTcl_WideInt
	var in TTcl_Channel
	var m, n TTcl_Size
	var _ /* buf at bp+0 */ [4096]uint8
	_, _, _, _, _, _ = errMsg, i, in, k, m, n
	XTcl_ResetResult(tls, interp)
	in = XTcl_OpenFileChannel(tls, interp, imgName, __ccgo_ts+49954, int32(0644))
	if !(in != 0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Get the length of the file (and exclude non-files).
	 */
	i = XTcl_Seek(tls, in, 0, int32(2))
	if i == int64(-int32(1)) {
		errMsg = __ccgo_ts + 73379
		goto copyError
	}
	XTcl_Seek(tls, in, 0, 0)
	/*
	 * Copy the whole file, 8 blocks at a time (reasonably efficient). Note
	 * that this totally ignores things like Windows's Alternate File Streams.
	 */
	k = 0
	for {
		if !(k < i) {
			break
		}
		m = i - k
		if m > libc.Int64FromInt64(4096) {
			m = int64(4096)
		}
		n = XTcl_Read(tls, in, bp, m)
		if n == int64(-int32(1)) {
			errMsg = __ccgo_ts + 74148
			goto copyError
		} else {
			if n == 0 {
				break
			}
		}
		m = XTcl_Write(tls, out, bp, n)
		if m != n {
			errMsg = __ccgo_ts + 74159
			goto copyError
		}
		goto _1
	_1:
		;
		k += m
	}
	XTcl_CloseEx(tls, interp, in, 0)
	return TCL_OK
	goto copyError
copyError:
	;
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+24923, libc.VaList(bp+4104, errMsg, XTcl_PosixError(tls, interp))))
	XTcl_CloseEx(tls, interp, in, 0)
	return int32(TCL_ERROR)
}

/*
 * ---------------------------------------------------------------------
 *
 * SerializeLocalEntryHeader, SerializeCentralDirectoryEntry,
 * SerializeCentralDirectorySuffix --
 *
 *	Create serialized forms of the structures that make up the ZIP
 *	metadata. Note that the both the local entry and the central directory
 *	entry need to have the name of the entry written directly afterwards.
 *
 *	We could write these as structs except we need to guarantee that we
 *	are writing these out as little-endian values.
 *
 * Side effects:
 *	Both update their buffer arguments, but otherwise change nothing.
 *
 * ---------------------------------------------------------------------
 */

func _SerializeLocalEntryHeader(tls *libc.TLS, start uintptr, end uintptr, buf uintptr, z uintptr, nameLength int32, align int32) {
	/* The number of alignment bytes. */
	_ZipWriteInt(tls, start, end, buf+uintptr(ZIP_LOCAL_SIG_OFFS), uint32(ZIP_LOCAL_HEADER_SIG))
	_ZipWriteShort(tls, start, end, buf+uintptr(ZIP_LOCAL_VERSION_OFFS), uint16(ZIP_MIN_VERSION))
	_ZipWriteShort(tls, start, end, buf+uintptr(ZIP_LOCAL_FLAGS_OFFS), libc.Uint16FromInt32((*TZipEntry)(unsafe.Pointer(z)).FisEncrypted+int32(ZIP_LOCAL_FLAGS_UTF8)))
	_ZipWriteShort(tls, start, end, buf+uintptr(ZIP_LOCAL_COMPMETH_OFFS), libc.Uint16FromInt32((*TZipEntry)(unsafe.Pointer(z)).FcompressMethod))
	_ZipWriteShort(tls, start, end, buf+uintptr(ZIP_LOCAL_MTIME_OFFS), libc.Uint16FromInt32(_ToDosTime(tls, int64((*TZipEntry)(unsafe.Pointer(z)).Ftimestamp))))
	_ZipWriteShort(tls, start, end, buf+uintptr(ZIP_LOCAL_MDATE_OFFS), libc.Uint16FromInt32(_ToDosDate(tls, int64((*TZipEntry)(unsafe.Pointer(z)).Ftimestamp))))
	_ZipWriteInt(tls, start, end, buf+uintptr(ZIP_LOCAL_CRC32_OFFS), libc.Uint32FromInt32((*TZipEntry)(unsafe.Pointer(z)).Fcrc32))
	_ZipWriteInt(tls, start, end, buf+uintptr(ZIP_LOCAL_COMPLEN_OFFS), libc.Uint32FromInt32((*TZipEntry)(unsafe.Pointer(z)).FnumCompressedBytes))
	_ZipWriteInt(tls, start, end, buf+uintptr(ZIP_LOCAL_UNCOMPLEN_OFFS), libc.Uint32FromInt32((*TZipEntry)(unsafe.Pointer(z)).FnumBytes))
	_ZipWriteShort(tls, start, end, buf+uintptr(ZIP_LOCAL_PATHLEN_OFFS), libc.Uint16FromInt32(nameLength))
	_ZipWriteShort(tls, start, end, buf+uintptr(ZIP_LOCAL_EXTRALEN_OFFS), libc.Uint16FromInt32(align))
}

func _SerializeCentralDirectoryEntry(tls *libc.TLS, start uintptr, end uintptr, buf uintptr, z uintptr, nameLength Tsize_t, dataStartOffset int64) {
	/* The overall file offset of the start of the
	 * data section of the file. */
	_ZipWriteInt(tls, start, end, buf+uintptr(ZIP_CENTRAL_SIG_OFFS), uint32(ZIP_CENTRAL_HEADER_SIG))
	_ZipWriteShort(tls, start, end, buf+uintptr(ZIP_CENTRAL_VERSIONMADE_OFFS), uint16(ZIP_MIN_VERSION))
	_ZipWriteShort(tls, start, end, buf+uintptr(ZIP_CENTRAL_VERSION_OFFS), uint16(ZIP_MIN_VERSION))
	_ZipWriteShort(tls, start, end, buf+uintptr(ZIP_CENTRAL_FLAGS_OFFS), libc.Uint16FromInt32((*TZipEntry)(unsafe.Pointer(z)).FisEncrypted+int32(ZIP_LOCAL_FLAGS_UTF8)))
	_ZipWriteShort(tls, start, end, buf+uintptr(ZIP_CENTRAL_COMPMETH_OFFS), libc.Uint16FromInt32((*TZipEntry)(unsafe.Pointer(z)).FcompressMethod))
	_ZipWriteShort(tls, start, end, buf+uintptr(ZIP_CENTRAL_MTIME_OFFS), libc.Uint16FromInt32(_ToDosTime(tls, int64((*TZipEntry)(unsafe.Pointer(z)).Ftimestamp))))
	_ZipWriteShort(tls, start, end, buf+uintptr(ZIP_CENTRAL_MDATE_OFFS), libc.Uint16FromInt32(_ToDosDate(tls, int64((*TZipEntry)(unsafe.Pointer(z)).Ftimestamp))))
	_ZipWriteInt(tls, start, end, buf+uintptr(ZIP_CENTRAL_CRC32_OFFS), libc.Uint32FromInt32((*TZipEntry)(unsafe.Pointer(z)).Fcrc32))
	_ZipWriteInt(tls, start, end, buf+uintptr(ZIP_CENTRAL_COMPLEN_OFFS), libc.Uint32FromInt32((*TZipEntry)(unsafe.Pointer(z)).FnumCompressedBytes))
	_ZipWriteInt(tls, start, end, buf+uintptr(ZIP_CENTRAL_UNCOMPLEN_OFFS), libc.Uint32FromInt32((*TZipEntry)(unsafe.Pointer(z)).FnumBytes))
	_ZipWriteShort(tls, start, end, buf+uintptr(ZIP_CENTRAL_PATHLEN_OFFS), uint16(nameLength))
	_ZipWriteShort(tls, start, end, buf+uintptr(ZIP_CENTRAL_EXTRALEN_OFFS), uint16(0))
	_ZipWriteShort(tls, start, end, buf+uintptr(ZIP_CENTRAL_FCOMMENTLEN_OFFS), uint16(0))
	_ZipWriteShort(tls, start, end, buf+uintptr(ZIP_CENTRAL_DISKFILE_OFFS), uint16(0))
	_ZipWriteShort(tls, start, end, buf+uintptr(ZIP_CENTRAL_IATTR_OFFS), uint16(0))
	_ZipWriteInt(tls, start, end, buf+uintptr(ZIP_CENTRAL_EATTR_OFFS), uint32(0))
	_ZipWriteInt(tls, start, end, buf+uintptr(ZIP_CENTRAL_LOCALHDR_OFFS), uint32((*TZipEntry)(unsafe.Pointer(z)).Foffset-libc.Uint64FromInt64(dataStartOffset)))
}

func _SerializeCentralDirectorySuffix(tls *libc.TLS, start uintptr, end uintptr, buf uintptr, entryCount int32, dataStartOffset int64, directoryStartOffset int64, suffixStartOffset int64) {
	/* The overall file offset of the start of the
	 * suffix of the central directory (i.e.,
	 * where this data will be written). */
	_ZipWriteInt(tls, start, end, buf+uintptr(ZIP_CENTRAL_END_SIG_OFFS), uint32(ZIP_CENTRAL_END_SIG))
	_ZipWriteShort(tls, start, end, buf+uintptr(ZIP_CENTRAL_DISKNO_OFFS), uint16(0))
	_ZipWriteShort(tls, start, end, buf+uintptr(ZIP_CENTRAL_DISKDIR_OFFS), uint16(0))
	_ZipWriteShort(tls, start, end, buf+uintptr(ZIP_CENTRAL_ENTS_OFFS), libc.Uint16FromInt32(entryCount))
	_ZipWriteShort(tls, start, end, buf+uintptr(ZIP_CENTRAL_TOTALENTS_OFFS), libc.Uint16FromInt32(entryCount))
	_ZipWriteInt(tls, start, end, buf+uintptr(ZIP_CENTRAL_DIRSIZE_OFFS), libc.Uint32FromInt64(suffixStartOffset-directoryStartOffset))
	_ZipWriteInt(tls, start, end, buf+uintptr(ZIP_CENTRAL_DIRSTART_OFFS), libc.Uint32FromInt64(directoryStartOffset-dataStartOffset))
	_ZipWriteShort(tls, start, end, buf+uintptr(ZIP_CENTRAL_COMMENTLEN_OFFS), uint16(0))
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSMkZipObjCmd, ZipFSLMkZipObjCmd --
 *
 *	These procedures are invoked to process the [zipfs mkzip] and [zipfs
 *	lmkzip] commands.  See description of ZipFSMkZipOrImg().
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See description of ZipFSMkZipOrImg().
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSMkZipObjCmd(tls *libc.TLS, dummy3928 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument objects. */
	var password, stripPrefix, v1, v2 uintptr
	_, _, _, _ = password, stripPrefix, v1, v2
	if objc < int32(3) || objc > int32(5) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+74171)
		return int32(TCL_ERROR)
	}
	if XTcl_IsSafe(tls, interp) != 0 {
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+74204, int64(-int32(1))))
		}
		if interp != 0 {
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+74250, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	if objc > int32(3) {
		v1 = *(*uintptr)(unsafe.Pointer(objv + 3*8))
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	stripPrefix = v1
	if objc > int32(4) {
		v2 = *(*uintptr)(unsafe.Pointer(objv + 4*8))
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	password = v2
	return _ZipFSMkZipOrImg(tls, interp, 0, *(*uintptr)(unsafe.Pointer(objv + 1*8)), *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), stripPrefix, password)
}

func _ZipFSLMkZipObjCmd(tls *libc.TLS, dummy3953 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument objects. */
	var password, v1 uintptr
	_, _ = password, v1
	if objc < int32(3) || objc > int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+74262)
		return int32(TCL_ERROR)
	}
	if XTcl_IsSafe(tls, interp) != 0 {
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+74204, int64(-int32(1))))
		}
		if interp != 0 {
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+74250, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	if objc > int32(3) {
		v1 = *(*uintptr)(unsafe.Pointer(objv + 3*8))
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	password = v1
	return _ZipFSMkZipOrImg(tls, interp, 0, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), password)
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSMkImgObjCmd, ZipFSLMkImgObjCmd --
 *
 *	These procedures are invoked to process the [zipfs mkimg] and [zipfs
 *	lmkimg] commands.  See description of ZipFSMkZipOrImg().
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See description of ZipFSMkZipOrImg().
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSMkImgObjCmd(tls *libc.TLS, dummy3994 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument objects. */
	var originFile, password, stripPrefix, v1, v2, v3 uintptr
	_, _, _, _, _, _ = originFile, password, stripPrefix, v1, v2, v3
	if objc < int32(3) || objc > int32(6) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+74288)
		return int32(TCL_ERROR)
	}
	if XTcl_IsSafe(tls, interp) != 0 {
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+74204, int64(-int32(1))))
		}
		if interp != 0 {
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+74250, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	if objc > int32(5) {
		v1 = *(*uintptr)(unsafe.Pointer(objv + 5*8))
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	originFile = v1
	if objc > int32(3) {
		v2 = *(*uintptr)(unsafe.Pointer(objv + 3*8))
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	stripPrefix = v2
	if objc > int32(4) {
		v3 = *(*uintptr)(unsafe.Pointer(objv + 4*8))
	} else {
		v3 = libc.UintptrFromInt32(0)
	}
	password = v3
	return _ZipFSMkZipOrImg(tls, interp, int32(1), *(*uintptr)(unsafe.Pointer(objv + 1*8)), *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0), originFile, stripPrefix, password)
}

func _ZipFSLMkImgObjCmd(tls *libc.TLS, dummy4021 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Argument objects. */
	var originFile, password, v1, v2 uintptr
	_, _, _, _ = originFile, password, v1, v2
	if objc < int32(3) || objc > int32(5) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+74330)
		return int32(TCL_ERROR)
	}
	if XTcl_IsSafe(tls, interp) != 0 {
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+74204, int64(-int32(1))))
		}
		if interp != 0 {
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+74250, libc.UintptrFromInt32(0)))
		}
		return int32(TCL_ERROR)
	}
	if objc > int32(4) {
		v1 = *(*uintptr)(unsafe.Pointer(objv + 4*8))
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	originFile = v1
	if objc > int32(3) {
		v2 = *(*uintptr)(unsafe.Pointer(objv + 3*8))
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	password = v2
	return _ZipFSMkZipOrImg(tls, interp, int32(1), *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + 2*8)), originFile, libc.UintptrFromInt32(0), password)
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSCanonicalObjCmd --
 *
 *	This procedure is invoked to process the [zipfs canonical] command.
 *	It returns the canonical name for a file within zipfs
 *
 * Results:
 *	Always TCL_OK provided the right number of arguments are supplied.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSCanonicalObjCmd(tls *libc.TLS, dummy4063 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(448)
	defer tls.Free(448) /* Argument objects. */
	var mntPoint uintptr
	var _ /* dsMount at bp+224 */ TTcl_DString
	var _ /* dsPath at bp+0 */ TTcl_DString
	_ = mntPoint
	mntPoint = libc.UintptrFromInt32(0)
	if objc < int32(2) || objc > int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+74365)
		return int32(TCL_ERROR)
	}
	XTcl_DStringInit(tls, bp)
	XTcl_DStringInit(tls, bp+224)
	if objc == int32(2) {
		mntPoint = __ccgo_ts + 72859
	} else {
		if _NormalizeMountPoint(tls, interp, XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0)), bp+224) != TCL_OK {
			return int32(TCL_ERROR)
		}
		mntPoint = (*TTcl_DString)(unsafe.Pointer(bp + 224)).Fstring1
	}
	_MapPathToZipfs(tls, interp, mntPoint, XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), libc.UintptrFromInt32(0)), bp)
	XTcl_SetObjResult(tls, interp, XTcl_DStringToObj(tls, bp))
	return TCL_OK
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSExistsObjCmd --
 *
 *	This procedure is invoked to process the [zipfs exists] command.  It
 *	tests for the existence of a file in the ZIP filesystem and places a
 *	boolean into the interp's result.
 *
 * Results:
 *	Always TCL_OK provided the right number of arguments are supplied.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSExistsObjCmd(tls *libc.TLS, dummy4113 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument objects. */
	var exists int32
	var filename, v1 uintptr
	_, _, _ = exists, filename, v1
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+70430)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	filename = v1
	_ReadLock(tls)
	exists = libc.BoolInt32(_ZipFSLookup(tls, filename) != libc.UintptrFromInt32(0))
	if !(exists != 0) {
		/* An ancestor directory of a file ? */
		exists = _ContainsMountPoint(tls, filename, -int32(1))
	}
	_Unlock(tls)
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(exists != 0)))
	return TCL_OK
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSInfoObjCmd --
 *
 *	This procedure is invoked to process the [zipfs info] command.  On
 *	success, it returns a Tcl list made up of name of ZIP archive file,
 *	size uncompressed, size compressed, and archive offset of a file in
 *	the ZIP filesystem.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSInfoObjCmd(tls *libc.TLS, dummy4162 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Argument objects. */
	var filename, result, z, v1 uintptr
	var ret int32
	_, _, _, _, _ = filename, result, ret, z, v1
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+70430)
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	filename = v1
	_ReadLock(tls)
	z = _ZipFSLookup(tls, filename)
	if z != 0 {
		result = XTcl_GetObjResult(tls, interp)
		XTcl_ListObjAppendElement(tls, interp, result, XTcl_NewStringObj(tls, (*TZipFile)(unsafe.Pointer((*TZipEntry)(unsafe.Pointer(z)).FzipFilePtr)).Fname, int64(-int32(1))))
		XTcl_ListObjAppendElement(tls, interp, result, XTcl_NewWideIntObj(tls, int64((*TZipEntry)(unsafe.Pointer(z)).FnumBytes)))
		XTcl_ListObjAppendElement(tls, interp, result, XTcl_NewWideIntObj(tls, int64((*TZipEntry)(unsafe.Pointer(z)).FnumCompressedBytes)))
		XTcl_ListObjAppendElement(tls, interp, result, XTcl_NewWideIntObj(tls, libc.Int64FromUint64((*TZipEntry)(unsafe.Pointer(z)).Foffset)))
		ret = TCL_OK
	} else {
		XTcl_SetErrno(tls, int32(ENOENT))
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+74387, libc.VaList(bp+8, filename)))
		}
		ret = int32(TCL_ERROR)
	}
	_Unlock(tls)
	return ret
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSListObjCmd --
 *
 *	This procedure is invoked to process the [zipfs list] command.	 On
 *	success, it returns a Tcl list of files of the ZIP filesystem which
 *	match a search pattern (glob or regexp).
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSListObjCmd(tls *libc.TLS, dummy4222 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Argument objects. */
	var hPtr, pattern, result, z, z1, z2, v1, v2, v3 uintptr
	var regexp TTcl_RegExp
	var _ /* idx at bp+48 */ int32
	var _ /* options at bp+24 */ [3]uintptr
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _, _, _, _, _ = hPtr, pattern, regexp, result, z, z1, z2, v1, v2, v3
	pattern = libc.UintptrFromInt32(0)
	regexp = libc.UintptrFromInt32(0)
	result = XTcl_GetObjResult(tls, interp)
	*(*[3]uintptr)(unsafe.Pointer(bp + 24)) = [3]uintptr{
		0: __ccgo_ts + 17513,
		1: __ccgo_ts + 17574,
		2: libc.UintptrFromInt32(0),
	}
	/*
	 * Parse arguments.
	 */
	if objc > int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+74427)
		return int32(TCL_ERROR)
	}
	if objc == int32(3) {
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+24, libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+48) != TCL_OK {
			return int32(TCL_ERROR)
		}
		switch *(*int32)(unsafe.Pointer(bp + 48)) {
		case 0:
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
				v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
			} else {
				v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
			}
			pattern = v1
		case 1:
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
				v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
			}
			regexp = XTcl_RegExpCompile(tls, interp, v2)
			if !(regexp != 0) {
				return int32(TCL_ERROR)
			}
			break
		}
	} else {
		if objc == int32(2) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
				v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
			} else {
				v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
			}
			pattern = v3
		}
	}
	/*
	 * Scan for matching entries.
	 */
	_ReadLock(tls)
	if pattern != 0 {
		hPtr = XTcl_FirstHashEntry(tls, uintptr(unsafe.Pointer(&_ZipFS))+32, bp)
		for {
			if !(hPtr != libc.UintptrFromInt32(0)) {
				break
			}
			z = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
			if XTcl_StringCaseMatch(tls, (*TZipEntry)(unsafe.Pointer(z)).Fname, pattern, 0) != 0 {
				XTcl_ListObjAppendElement(tls, interp, result, XTcl_NewStringObj(tls, (*TZipEntry)(unsafe.Pointer(z)).Fname, int64(-int32(1))))
			}
			goto _4
		_4:
			;
			hPtr = XTcl_NextHashEntry(tls, bp)
		}
	} else {
		if regexp != 0 {
			hPtr = XTcl_FirstHashEntry(tls, uintptr(unsafe.Pointer(&_ZipFS))+32, bp)
			for {
				if !(hPtr != 0) {
					break
				}
				z1 = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
				if XTcl_RegExpExec(tls, interp, regexp, (*TZipEntry)(unsafe.Pointer(z1)).Fname, (*TZipEntry)(unsafe.Pointer(z1)).Fname) != 0 {
					XTcl_ListObjAppendElement(tls, interp, result, XTcl_NewStringObj(tls, (*TZipEntry)(unsafe.Pointer(z1)).Fname, int64(-int32(1))))
				}
				goto _5
			_5:
				;
				hPtr = XTcl_NextHashEntry(tls, bp)
			}
		} else {
			hPtr = XTcl_FirstHashEntry(tls, uintptr(unsafe.Pointer(&_ZipFS))+32, bp)
			for {
				if !(hPtr != 0) {
					break
				}
				z2 = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
				XTcl_ListObjAppendElement(tls, interp, result, XTcl_NewStringObj(tls, (*TZipEntry)(unsafe.Pointer(z2)).Fname, int64(-int32(1))))
				goto _6
			_6:
				;
				hPtr = XTcl_NextHashEntry(tls, bp)
			}
		}
	}
	_Unlock(tls)
	return TCL_OK
}

/*
 *-------------------------------------------------------------------------
 *
 * TclZipfs_TclLibrary --
 *
 *	This procedure gets (and possibly finds) the root that Tcl's library
 *	files are mounted under.
 *
 * Results:
 *	A Tcl object holding the location (with zero refcount), or NULL if no
 *	Tcl library can be found.
 *
 * Side effects:
 *	May initialise the cache of where such library files are to be found.
 *	This cache is never cleared.
 *
 *-------------------------------------------------------------------------
 */

// C documentation
//
//	/* Utility routine to centralize housekeeping */
func _ScriptLibrarySetup(tls *libc.TLS, dirName uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, _objPtr1, cachePtr, cachePtr1, libDirObj, searchPathObj, v4, v6 uintptr
	var v1, v2 bool
	var v3, v5 TTcl_Size
	var _ /* subDirObj at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, cachePtr1, libDirObj, searchPathObj, v1, v2, v3, v4, v5, v6
	libDirObj = XTcl_NewStringObj(tls, dirName, int64(-int32(1)))
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		*(*uintptr)(unsafe.Pointer(bp)) = XTclThreadAllocObj(tls)
	} else {
		*(*uintptr)(unsafe.Pointer(bp)) = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FrefCount = 0
	if libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes, __ccgo_ts+5615, libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fbytes + uintptr(libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(9) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FrefCount++
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		searchPathObj = XTclThreadAllocObj(tls)
	} else {
		searchPathObj = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(searchPathObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(searchPathObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(searchPathObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(searchPathObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(searchPathObj)).FtypePtr = libc.UintptrFromInt32(0)
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), searchPathObj, XTcl_FSJoinToPath(tls, libDirObj, int64(1), bp))
	_objPtr = *(*uintptr)(unsafe.Pointer(bp))
	v4 = _objPtr
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	if v3 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	(*TTcl_Obj)(unsafe.Pointer(searchPathObj)).FrefCount++
	XTcl_SetEncodingSearchPath(tls, searchPathObj)
	_objPtr1 = searchPathObj
	v6 = _objPtr1
	v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
	*(*TTcl_Size)(unsafe.Pointer(v6))--
	if v5 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	/* Bug [fccb9f322f]. Reinit system encoding after setting search path */
	XTclpSetInitialEncodings(tls)
	return libDirObj
}

func XTclZipfs_TclLibrary(tls *libc.TLS) (r uintptr) {
	var _objPtr, vfsInitScript, v2 uintptr
	var found int32
	var v1 TTcl_Size
	_, _, _, _, _ = _objPtr, found, vfsInitScript, v1, v2
	/*
	 * Use the cached value if that has been set; we don't want to repeat the
	 * searching and mounting.
	 */
	if _zipfs_literal_tcl_library != 0 {
		return _ScriptLibrarySetup(tls, _zipfs_literal_tcl_library)
	}
	/*
	 * Look for the library file system within the executable.
	 */
	vfsInitScript = XTcl_NewStringObj(tls, __ccgo_ts+74455, int64(-int32(1)))
	(*TTcl_Obj)(unsafe.Pointer(vfsInitScript)).FrefCount++
	found = XTcl_FSAccess(tls, vfsInitScript, F_OK)
	_objPtr = vfsInitScript
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	if found == TCL_OK {
		_zipfs_literal_tcl_library = __ccgo_ts + 74489
		return _ScriptLibrarySetup(tls, _zipfs_literal_tcl_library)
	}
	/*
	 * Look for the library file system within the DLL/shared library.  Note
	 * that we must mount the zip file and dll before releasing to search.
	 */
	/*
	 * If anything set the cache (but subsequently failed) go with that
	 * anyway.
	 */
	if _zipfs_literal_tcl_library != 0 {
		return _ScriptLibrarySetup(tls, _zipfs_literal_tcl_library)
	}
	return libc.UintptrFromInt32(0)
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSTclLibraryObjCmd --
 *
 *	This procedure is invoked to process the
 *	[::tcl::zipfs::tcl_library_init] command, usually called during the
 *	execution of Tcl's interpreter startup. It returns the root that Tcl's
 *	library files are mounted under.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	May initialise the cache of where such library files are to be found.
 *	This cache is never cleared.
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSTclLibraryObjCmd(tls *libc.TLS, dummy4443 uintptr, interp uintptr, dummy4445 int32, dummy4446 uintptr) (r int32) {
	/*objv*/
	var cachePtr, pResult uintptr
	var v1 bool
	_, _, _ = cachePtr, pResult, v1
	if !(XTcl_IsSafe(tls, interp) != 0) {
		pResult = XTclZipfs_TclLibrary(tls)
		if !(pResult != 0) {
			if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				pResult = XTclThreadAllocObj(tls)
			} else {
				pResult = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(pResult + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(pResult)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(pResult)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(pResult)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(pResult)).FtypePtr = libc.UintptrFromInt32(0)
		}
		XTcl_SetObjResult(tls, interp, pResult)
	}
	return TCL_OK
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipChannelClose --
 *
 *	This function is called to close a channel.
 *
 * Results:
 *	Always TCL_OK.
 *
 * Side effects:
 *	Resources are free'd.
 *
 *-------------------------------------------------------------------------
 */

func _ZipChannelClose(tls *libc.TLS, instanceData uintptr, dummy4478 uintptr, flags int32) (r int32) {
	var info, newdata, z uintptr
	var v1 int64
	var v2 int32
	_, _, _, _, _ = info, newdata, z, v1, v2
	info = instanceData
	if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
		return int32(EINVAL)
	}
	if (*TZipChannel)(unsafe.Pointer(info)).FisEncrypted != 0 {
		(*TZipChannel)(unsafe.Pointer(info)).FisEncrypted = 0
		libc.Xmemset(tls, info+80, 0, uint64(24))
	}
	_WriteLock(tls)
	if _ZipChannelWritable(tls, info) != 0 {
		/*
		 * Copy channel data back into original file in archive.
		 */
		z = (*TZipChannel)(unsafe.Pointer(info)).FzipEntryPtr
		if (*TZipChannel)(unsafe.Pointer(info)).FnumBytes != 0 {
			v1 = (*TZipChannel)(unsafe.Pointer(info)).FnumBytes
		} else {
			v1 = int64(1)
		}
		newdata = XTclpRealloc(tls, (*TZipChannel)(unsafe.Pointer(info)).FubufToFree, libc.Uint64FromInt64(v1)) /* Bug [23dd83ce7c] */
		if newdata == libc.UintptrFromInt32(0) {
			/* Could not reallocate, keep existing buffer */
			newdata = (*TZipChannel)(unsafe.Pointer(info)).FubufToFree
		}
		(*TZipChannel)(unsafe.Pointer(info)).FubufToFree = libc.UintptrFromInt32(0) /* Now newdata! */
		(*TZipChannel)(unsafe.Pointer(info)).Fubuf = libc.UintptrFromInt32(0)
		(*TZipChannel)(unsafe.Pointer(info)).FubufSize = 0
		/* Replace old content */
		if (*TZipEntry)(unsafe.Pointer(z)).Fdata != 0 {
			XTclpFree(tls, (*TZipEntry)(unsafe.Pointer(z)).Fdata)
		}
		(*TZipEntry)(unsafe.Pointer(z)).Fdata = newdata /* May be NULL when ubufToFree was NULL */
		v2 = int32((*TZipChannel)(unsafe.Pointer(info)).FnumBytes)
		(*TZipEntry)(unsafe.Pointer(z)).FnumCompressedBytes = v2
		(*TZipEntry)(unsafe.Pointer(z)).FnumBytes = v2
		(*TZipEntry)(unsafe.Pointer(z)).FcompressMethod = int32(ZIP_COMPMETH_STORED)
		(*TZipEntry)(unsafe.Pointer(z)).Ftimestamp = int32(libc.Xtime(tls, libc.UintptrFromInt32(0)))
		(*TZipEntry)(unsafe.Pointer(z)).FisDirectory = 0
		(*TZipEntry)(unsafe.Pointer(z)).FisEncrypted = 0
		(*TZipEntry)(unsafe.Pointer(z)).Foffset = uint64(0)
		(*TZipEntry)(unsafe.Pointer(z)).Fcrc32 = 0
	}
	(*TZipFile)(unsafe.Pointer((*TZipChannel)(unsafe.Pointer(info)).FzipFilePtr)).FnumOpen--
	_Unlock(tls)
	if (*TZipChannel)(unsafe.Pointer(info)).FubufToFree != 0 {
		XTclpFree(tls, (*TZipChannel)(unsafe.Pointer(info)).FubufToFree)
		(*TZipChannel)(unsafe.Pointer(info)).Fubuf = libc.UintptrFromInt32(0)
		(*TZipChannel)(unsafe.Pointer(info)).FubufToFree = libc.UintptrFromInt32(0)
		(*TZipChannel)(unsafe.Pointer(info)).FubufSize = 0
	}
	XTclpFree(tls, info)
	return TCL_OK
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipChannelRead --
 *
 *	This function is called to read data from channel.
 *
 * Results:
 *	Number of bytes read or -1 on error with error number set.
 *
 * Side effects:
 *	Data is read and file pointer is advanced.
 *
 *-------------------------------------------------------------------------
 */

func _ZipChannelRead(tls *libc.TLS, instanceData uintptr, buf uintptr, toRead int32, errloc uintptr) (r int32) {
	var ch, i int32
	var info uintptr
	var nextpos TTcl_Size
	_, _, _, _ = ch, i, info, nextpos
	info = instanceData
	if (*TZipChannel)(unsafe.Pointer(info)).FisDirectory < 0 {
		/*
		 * Special case: when executable combined with ZIP archive file read
		 * data in front of ZIP, i.e. the executable itself.
		 */
		nextpos = (*TZipChannel)(unsafe.Pointer(info)).Fcursor + int64(toRead)
		if libc.Uint64FromInt64(nextpos) > (*TZipFile)(unsafe.Pointer((*TZipChannel)(unsafe.Pointer(info)).FzipFilePtr)).FbaseOffset {
			toRead = libc.Int32FromUint64((*TZipFile)(unsafe.Pointer((*TZipChannel)(unsafe.Pointer(info)).FzipFilePtr)).FbaseOffset - libc.Uint64FromInt64((*TZipChannel)(unsafe.Pointer(info)).Fcursor))
			nextpos = libc.Int64FromUint64((*TZipFile)(unsafe.Pointer((*TZipChannel)(unsafe.Pointer(info)).FzipFilePtr)).FbaseOffset)
		}
		if toRead == 0 {
			return 0
		}
		libc.Xmemcpy(tls, buf, (*TZipFile)(unsafe.Pointer((*TZipChannel)(unsafe.Pointer(info)).FzipFilePtr)).Fdata, libc.Uint64FromInt32(toRead))
		(*TZipChannel)(unsafe.Pointer(info)).Fcursor = nextpos
		*(*int32)(unsafe.Pointer(errloc)) = 0
		return toRead
	}
	if (*TZipChannel)(unsafe.Pointer(info)).FisDirectory != 0 {
		*(*int32)(unsafe.Pointer(errloc)) = int32(EISDIR)
		return -int32(1)
	}
	nextpos = (*TZipChannel)(unsafe.Pointer(info)).Fcursor + int64(toRead)
	if nextpos > (*TZipChannel)(unsafe.Pointer(info)).FnumBytes {
		toRead = int32((*TZipChannel)(unsafe.Pointer(info)).FnumBytes - (*TZipChannel)(unsafe.Pointer(info)).Fcursor)
		nextpos = (*TZipChannel)(unsafe.Pointer(info)).FnumBytes
	}
	if toRead == 0 {
		return 0
	}
	if (*TZipChannel)(unsafe.Pointer(info)).FisEncrypted != 0 {
		/*
		 * TODO - when is this code ever exercised? Cannot reach it from
		 * tests. In particular, decryption is always done at channel open
		 * to allow for seeks and random reads.
		 */
		i = 0
		for {
			if !(i < toRead) {
				break
			}
			ch = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TZipChannel)(unsafe.Pointer(info)).Fubuf + uintptr(int64(i)+(*TZipChannel)(unsafe.Pointer(info)).Fcursor))))
			ch ^= _decrypt_byte(tls, info+80, _crc32tab)
			*(*uint8)(unsafe.Pointer(buf + uintptr(i))) = libc.Uint8FromInt32(_update_keys(tls, info+80, _crc32tab, ch))
			goto _1
		_1:
			;
			i++
		}
	} else {
		libc.Xmemcpy(tls, buf, (*TZipChannel)(unsafe.Pointer(info)).Fubuf+uintptr((*TZipChannel)(unsafe.Pointer(info)).Fcursor), libc.Uint64FromInt32(toRead))
	}
	(*TZipChannel)(unsafe.Pointer(info)).Fcursor = nextpos
	*(*int32)(unsafe.Pointer(errloc)) = 0
	return toRead
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipChannelWrite --
 *
 *	This function is called to write data into channel.
 *
 * Results:
 *	Number of bytes written or -1 on error with error number set.
 *
 * Side effects:
 *	Data is written and file pointer is advanced.
 *
 *-------------------------------------------------------------------------
 */

func _ZipChannelWrite(tls *libc.TLS, instanceData uintptr, buf uintptr, toWrite int32, errloc uintptr) (r int32) {
	var info, newBuf uintptr
	var needed TTcl_Size
	var nextpos uint64
	_, _, _, _ = info, needed, newBuf, nextpos
	info = instanceData
	if !(_ZipChannelWritable(tls, info) != 0) {
		*(*int32)(unsafe.Pointer(errloc)) = int32(EINVAL)
		return -int32(1)
	}
	if toWrite == 0 {
		*(*int32)(unsafe.Pointer(errloc)) = 0
		return 0
	}
	if (*TZipChannel)(unsafe.Pointer(info)).Fmode&int32(O_APPEND) != 0 {
		(*TZipChannel)(unsafe.Pointer(info)).Fcursor = (*TZipChannel)(unsafe.Pointer(info)).FnumBytes
	}
	if int64(toWrite) > (*TZipChannel)(unsafe.Pointer(info)).FmaxWrite-(*TZipChannel)(unsafe.Pointer(info)).Fcursor {
		/* File would grow beyond max size permitted */
		/* Don't do partial writes in error case. Or should we? */
		*(*int32)(unsafe.Pointer(errloc)) = int32(EFBIG)
		return -int32(1)
	}
	if int64(toWrite) > (*TZipChannel)(unsafe.Pointer(info)).FubufSize-(*TZipChannel)(unsafe.Pointer(info)).Fcursor {
		/* grow the buffer. We have already checked will not exceed maxWrite */
		needed = (*TZipChannel)(unsafe.Pointer(info)).Fcursor + int64(toWrite)
		/* Tack on a bit for future growth. */
		if needed < (*TZipChannel)(unsafe.Pointer(info)).FmaxWrite-needed/int64(2) {
			needed += needed / int64(2)
		} else {
			needed = (*TZipChannel)(unsafe.Pointer(info)).FmaxWrite
		}
		newBuf = XTclpRealloc(tls, (*TZipChannel)(unsafe.Pointer(info)).FubufToFree, libc.Uint64FromInt64(needed))
		if newBuf == libc.UintptrFromInt32(0) {
			*(*int32)(unsafe.Pointer(errloc)) = int32(ENOMEM)
			return -int32(1)
		}
		(*TZipChannel)(unsafe.Pointer(info)).FubufToFree = newBuf
		(*TZipChannel)(unsafe.Pointer(info)).Fubuf = (*TZipChannel)(unsafe.Pointer(info)).FubufToFree
		(*TZipChannel)(unsafe.Pointer(info)).FubufSize = needed
	}
	nextpos = libc.Uint64FromInt64((*TZipChannel)(unsafe.Pointer(info)).Fcursor + int64(toWrite))
	libc.Xmemcpy(tls, (*TZipChannel)(unsafe.Pointer(info)).Fubuf+uintptr((*TZipChannel)(unsafe.Pointer(info)).Fcursor), buf, libc.Uint64FromInt32(toWrite))
	(*TZipChannel)(unsafe.Pointer(info)).Fcursor = libc.Int64FromUint64(nextpos)
	if (*TZipChannel)(unsafe.Pointer(info)).Fcursor > (*TZipChannel)(unsafe.Pointer(info)).FnumBytes {
		(*TZipChannel)(unsafe.Pointer(info)).FnumBytes = (*TZipChannel)(unsafe.Pointer(info)).Fcursor
	}
	*(*int32)(unsafe.Pointer(errloc)) = 0
	return toWrite
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipChannelSeek/ZipChannelWideSeek --
 *
 *	This function is called to position file pointer of channel.
 *
 * Results:
 *	New file position or -1 on error with error number set.
 *
 * Side effects:
 *	File pointer is repositioned according to offset and mode.
 *
 *-------------------------------------------------------------------------
 */

func _ZipChannelWideSeek(tls *libc.TLS, instanceData uintptr, offset int64, mode int32, errloc uintptr) (r int64) {
	var end TTcl_Size
	var info uintptr
	_, _ = end, info
	info = instanceData
	if !(_ZipChannelWritable(tls, info) != 0) && (*TZipChannel)(unsafe.Pointer(info)).FisDirectory < 0 {
		/*
		 * Special case: when executable combined with ZIP archive file, seek
		 * within front of ZIP, i.e. the executable itself.
		 */
		end = libc.Int64FromUint64((*TZipFile)(unsafe.Pointer((*TZipChannel)(unsafe.Pointer(info)).FzipFilePtr)).FbaseOffset)
	} else {
		if (*TZipChannel)(unsafe.Pointer(info)).FisDirectory != 0 {
			*(*int32)(unsafe.Pointer(errloc)) = int32(EINVAL)
			return int64(-int32(1))
		} else {
			end = (*TZipChannel)(unsafe.Pointer(info)).FnumBytes
		}
	}
	switch mode {
	case int32(1):
		offset += (*TZipChannel)(unsafe.Pointer(info)).Fcursor
	case int32(2):
		offset += end
	case 0:
	default:
		*(*int32)(unsafe.Pointer(errloc)) = int32(EINVAL)
		return int64(-int32(1))
	}
	if offset < 0 || offset > int64(libc.Int64FromUint64(libc.Uint64FromInt32(-libc.Int32FromInt32(1))>>libc.Int32FromInt32(1))) {
		*(*int32)(unsafe.Pointer(errloc)) = int32(EINVAL)
		return int64(-int32(1))
	}
	if _ZipChannelWritable(tls, info) != 0 {
		if offset > (*TZipChannel)(unsafe.Pointer(info)).FmaxWrite {
			*(*int32)(unsafe.Pointer(errloc)) = int32(EINVAL)
			return int64(-int32(1))
		}
		if offset > (*TZipChannel)(unsafe.Pointer(info)).FnumBytes {
			(*TZipChannel)(unsafe.Pointer(info)).FnumBytes = offset
		}
	} else {
		if offset > end {
			*(*int32)(unsafe.Pointer(errloc)) = int32(EINVAL)
			return int64(-int32(1))
		}
	}
	(*TZipChannel)(unsafe.Pointer(info)).Fcursor = offset
	return (*TZipChannel)(unsafe.Pointer(info)).Fcursor
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipChannelWatchChannel --
 *
 *	This function is called for event notifications on channel. Does
 *	nothing.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func _ZipChannelWatchChannel(tls *libc.TLS, dummy4786 uintptr, dummy4787 int32) {
	return
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipChannelGetFile --
 *
 *	This function is called to retrieve OS handle for channel.
 *
 * Results:
 *	Always TCL_ERROR since there's never an OS handle for a file within a
 *	ZIP archive.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func _ZipChannelGetFile(tls *libc.TLS, dummy4811 uintptr, dummy4812 int32, dummy4813 uintptr) (r int32) {
	return int32(TCL_ERROR)
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipChannelOpen --
 *
 *	This function opens a Tcl_Channel on a file from a mounted ZIP archive
 *	according to given open mode (already parsed by caller).
 *
 * Results:
 *	Tcl_Channel on success, or NULL on error.
 *
 * Side effects:
 *	Memory is allocated, the file from the ZIP archive is uncompressed.
 *
 *-------------------------------------------------------------------------
 */

func _ZipChannelOpen(tls *libc.TLS, interp uintptr, filename uintptr, mode int32) (r TTcl_Channel) {
	bp := tls.Alloc(176)
	defer tls.Free(176) /* O_WRONLY O_RDWR O_TRUNC flags */
	var crc, flags, wr, v1, v3 int32
	var info, z, v2, v4 uintptr
	var _ /* cname at bp+0 */ [128]uint8
	_, _, _, _, _, _, _, _, _ = crc, flags, info, wr, z, v1, v2, v3, v4
	flags = 0
	wr = libc.BoolInt32(mode&(libc.Int32FromInt32(O_WRONLY)|libc.Int32FromInt32(O_RDWR)) != 0)
	/* Check for unsupported modes. */
	if _ZipFS.Fwrmax <= 0 && wr != 0 {
		XTcl_SetErrno(tls, int32(EACCES))
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+74514, libc.VaList(bp+136, XTcl_PosixError(tls, interp))))
		}
		return libc.UintptrFromInt32(0)
	}
	if mode&(libc.Int32FromInt32(O_APPEND)|libc.Int32FromInt32(O_TRUNC)) != 0 && !(wr != 0) {
		XTcl_SetErrno(tls, int32(EINVAL))
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+74539, libc.VaList(bp+136, mode, XTcl_PosixError(tls, interp))))
		}
		return libc.UintptrFromInt32(0)
	}
	/*
	 * Is the file there?
	 */
	_WriteLock(tls)
	z = _ZipFSLookup(tls, filename)
	if !(z != 0) {
		if wr != 0 {
			v1 = int32(EOPNOTSUPP)
		} else {
			v1 = int32(ENOENT)
		}
		XTcl_SetErrno(tls, v1)
		if interp != 0 {
			if wr != 0 {
				v2 = __ccgo_ts + 74605
			} else {
				v2 = __ccgo_ts + 74613
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+74619, libc.VaList(bp+136, filename, v2, XTcl_PosixError(tls, interp))))
		}
		goto error
	}
	if (*TZipEntry)(unsafe.Pointer(z)).FnumBytes < 0 || (*TZipEntry)(unsafe.Pointer(z)).FnumCompressedBytes < 0 || (*TZipEntry)(unsafe.Pointer(z)).Foffset >= (*TZipFile)(unsafe.Pointer((*TZipEntry)(unsafe.Pointer(z)).FzipFilePtr)).Flength {
		/* Normally this should only happen for zip64. */
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+74640, int64(-int32(1))))
		}
		if interp != 0 {
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+136, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+73408, libc.UintptrFromInt32(0)))
		}
		goto error
	}
	/* Do we support opening the file that way? */
	if wr != 0 && (*TZipEntry)(unsafe.Pointer(z)).FisDirectory != 0 {
		XTcl_SetErrno(tls, int32(EISDIR))
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+74671, libc.VaList(bp+136, XTcl_PosixError(tls, interp))))
		}
		goto error
	}
	if (*TZipEntry)(unsafe.Pointer(z)).FcompressMethod != int32(ZIP_COMPMETH_STORED) && (*TZipEntry)(unsafe.Pointer(z)).FcompressMethod != int32(ZIP_COMPMETH_DEFLATED) {
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+74697, int64(-int32(1))))
		}
		if interp != 0 {
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+136, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+74728, libc.UintptrFromInt32(0)))
		}
		goto error
	}
	if wr != 0 {
		if mode&int32(O_TRUNC) == 0 && !((*TZipEntry)(unsafe.Pointer(z)).Fdata != 0) && (*TZipEntry)(unsafe.Pointer(z)).FnumBytes > _ZipFS.Fwrmax {
			XTcl_SetErrno(tls, int32(EFBIG))
			if interp != 0 {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+24923, libc.VaList(bp+136, __ccgo_ts+74740, XTcl_PosixError(tls, interp))))
			}
			goto error
		}
		flags = libc.Int32FromInt32(1) << libc.Int32FromInt32(2)
		if mode&int32(O_RDWR) != 0 {
			flags |= libc.Int32FromInt32(1) << libc.Int32FromInt32(1)
		}
	} else {
		/* Read-only */
		flags |= libc.Int32FromInt32(1) << libc.Int32FromInt32(1)
	}
	if (*TZipEntry)(unsafe.Pointer(z)).FisEncrypted != 0 {
		if (*TZipEntry)(unsafe.Pointer(z)).FnumCompressedBytes < int32(ZIP_CRYPT_HDR_LEN) {
			if interp != 0 {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+74771, int64(-int32(1))))
			}
			if interp != 0 {
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+136, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+74818, libc.UintptrFromInt32(0)))
			}
			goto error
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TZipEntry)(unsafe.Pointer(z)).FzipFilePtr + 96))) == 0 {
			if interp != 0 {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+74826, int64(-int32(1))))
			}
			if interp != 0 {
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+136, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+74818, libc.UintptrFromInt32(0)))
			}
			goto error
		}
	}
	info = _AllocateZipChannel(tls, interp)
	if !(info != 0) {
		goto error
	}
	(*TZipChannel)(unsafe.Pointer(info)).FzipFilePtr = (*TZipEntry)(unsafe.Pointer(z)).FzipFilePtr
	(*TZipChannel)(unsafe.Pointer(info)).FzipEntryPtr = z
	if wr != 0 {
		/* Set up a writable channel. */
		if _InitWritableChannel(tls, interp, info, z, mode) == int32(TCL_ERROR) {
			XTclpFree(tls, info)
			goto error
		}
	} else {
		if (*TZipEntry)(unsafe.Pointer(z)).Fdata != 0 {
			/* Set up a readable channel for direct data. */
			(*TZipChannel)(unsafe.Pointer(info)).FnumBytes = int64((*TZipEntry)(unsafe.Pointer(z)).FnumBytes)
			(*TZipChannel)(unsafe.Pointer(info)).Fubuf = (*TZipEntry)(unsafe.Pointer(z)).Fdata
			(*TZipChannel)(unsafe.Pointer(info)).FubufToFree = libc.UintptrFromInt32(0) /* Not dynamically allocated */
			(*TZipChannel)(unsafe.Pointer(info)).FubufSize = 0
		} else {
			/*
			 * Set up a readable channel.
			 */
			if _InitReadableChannel(tls, interp, info, z) == int32(TCL_ERROR) {
				XTclpFree(tls, info)
				goto error
			}
		}
	}
	if (*TZipEntry)(unsafe.Pointer(z)).Fcrc32 != 0 {
		if !((*TZipEntry)(unsafe.Pointer(z)).Fflags&int32(ZE_F_CRC_COMPARED) != 0) {
			crc = libc.Int32FromUint64(libz.Xcrc32(tls, uint64(0), libc.UintptrFromInt32(0), libc.Uint32FromInt64((*TZipChannel)(unsafe.Pointer(info)).FnumBytes)))
			crc = libc.Int32FromUint64(libz.Xcrc32(tls, libc.Uint64FromInt32(crc), (*TZipChannel)(unsafe.Pointer(info)).Fubuf, libc.Uint32FromInt64((*TZipChannel)(unsafe.Pointer(info)).FnumBytes)))
			*(*int32)(unsafe.Pointer(z + 56)) |= int32(ZE_F_CRC_COMPARED)
			if crc == (*TZipEntry)(unsafe.Pointer(z)).Fcrc32 {
				*(*int32)(unsafe.Pointer(z + 56)) |= int32(ZE_F_CRC_CORRECT)
			}
		}
		if !((*TZipEntry)(unsafe.Pointer(z)).Fflags&int32(ZE_F_CRC_CORRECT) != 0) {
			if interp != 0 {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+74867, int64(-int32(1))))
			}
			if interp != 0 {
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+136, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+74879, libc.UintptrFromInt32(0)))
			}
			if (*TZipChannel)(unsafe.Pointer(info)).FubufToFree != 0 {
				XTclpFree(tls, (*TZipChannel)(unsafe.Pointer(info)).FubufToFree)
				(*TZipChannel)(unsafe.Pointer(info)).FubufSize = 0
			}
			XTclpFree(tls, info)
			goto error
		}
	}
	/*
	 * Wrap the ZipChannel into a Tcl_Channel.
	 */
	v4 = uintptr(unsafe.Pointer(&_ZipFS)) + 24
	v3 = *(*int32)(unsafe.Pointer(v4))
	*(*int32)(unsafe.Pointer(v4))++
	libc.X__builtin_snprintf(tls, bp, uint64(128), __ccgo_ts+74890, libc.VaList(bp+136, (*TZipEntry)(unsafe.Pointer(z)).Foffset, v3))
	(*TZipFile)(unsafe.Pointer((*TZipEntry)(unsafe.Pointer(z)).FzipFilePtr)).FnumOpen++
	_Unlock(tls)
	return XTcl_CreateChannel(tls, uintptr(unsafe.Pointer(&_zipChannelType)), bp, info, flags)
	goto error
error:
	;
	_Unlock(tls)
	return libc.UintptrFromInt32(0)
}

/*
 *-------------------------------------------------------------------------
 *
 * InitWritableChannel --
 *
 *	Assistant for ZipChannelOpen() that sets up a writable channel. It's
 *	up to the caller to actually register the channel.
 *
 * Returns:
 *	Tcl result code.
 *
 * Side effects:
 *	Allocates memory for the implementation of the channel. Writes to the
 *	interpreter's result on error.
 *
 *-------------------------------------------------------------------------
 */

func _InitWritableChannel(tls *libc.TLS, interp uintptr, info uintptr, z uintptr, mode int32) (r int32) {
	bp := tls.Alloc(160)
	defer tls.Free(160) /* O_APPEND, O_TRUNC */
	var cbuf, zbuf uintptr
	var ch, err, i, len1, v1 int32
	var j, v2 uint32
	var _ /* stream at bp+0 */ Tz_stream
	_, _, _, _, _, _, _, _, _ = cbuf, ch, err, i, j, len1, zbuf, v1, v2
	cbuf = libc.UintptrFromInt32(0)
	/*
	 * Set up a writable channel.
	 */
	(*TZipChannel)(unsafe.Pointer(info)).Fmode = mode
	(*TZipChannel)(unsafe.Pointer(info)).FmaxWrite = int64(_ZipFS.Fwrmax)
	if (*TZipEntry)(unsafe.Pointer(z)).FnumBytes != 0 {
		v1 = (*TZipEntry)(unsafe.Pointer(z)).FnumBytes
	} else {
		v1 = int32(1)
	}
	(*TZipChannel)(unsafe.Pointer(info)).FubufSize = int64(v1)
	(*TZipChannel)(unsafe.Pointer(info)).FubufToFree = XTclpAlloc(tls, libc.Uint64FromInt64((*TZipChannel)(unsafe.Pointer(info)).FubufSize))
	(*TZipChannel)(unsafe.Pointer(info)).Fubuf = (*TZipChannel)(unsafe.Pointer(info)).FubufToFree
	if (*TZipChannel)(unsafe.Pointer(info)).FubufToFree == libc.UintptrFromInt32(0) {
		goto memoryError
	}
	if (*TZipEntry)(unsafe.Pointer(z)).FisEncrypted != 0 {
		/* caller should have checked*/
		if _DecodeCryptHeader(tls, interp, z, info+80, (*TZipFile)(unsafe.Pointer((*TZipEntry)(unsafe.Pointer(z)).FzipFilePtr)).Fdata+uintptr((*TZipEntry)(unsafe.Pointer(z)).Foffset)) != TCL_OK {
			goto error_cleanup
		}
	}
	if mode&int32(O_TRUNC) != 0 {
		/*
		 * Truncate; nothing there.
		 */
		(*TZipChannel)(unsafe.Pointer(info)).FnumBytes = 0
		(*TZipEntry)(unsafe.Pointer(z)).Fcrc32 = 0 /* Truncated, CRC no longer applicable */
	} else {
		if (*TZipEntry)(unsafe.Pointer(z)).Fdata != 0 {
			/*
			 * Already got uncompressed data.
			 */
			libc.Xmemcpy(tls, (*TZipChannel)(unsafe.Pointer(info)).Fubuf, (*TZipEntry)(unsafe.Pointer(z)).Fdata, libc.Uint64FromInt32((*TZipEntry)(unsafe.Pointer(z)).FnumBytes))
			(*TZipChannel)(unsafe.Pointer(info)).FnumBytes = int64((*TZipEntry)(unsafe.Pointer(z)).FnumBytes)
		} else {
			/*
			 * Need to uncompress the existing data.
			 */
			zbuf = (*TZipFile)(unsafe.Pointer((*TZipEntry)(unsafe.Pointer(z)).FzipFilePtr)).Fdata + uintptr((*TZipEntry)(unsafe.Pointer(z)).Foffset)
			if (*TZipEntry)(unsafe.Pointer(z)).FisEncrypted != 0 {
				zbuf += uintptr(ZIP_CRYPT_HDR_LEN)
			}
			if (*TZipEntry)(unsafe.Pointer(z)).FcompressMethod == int32(ZIP_COMPMETH_DEFLATED) {
				libc.Xmemset(tls, bp, 0, uint64(112))
				(*(*Tz_stream)(unsafe.Pointer(bp))).Fzalloc = uintptr(Z_NULL)
				(*(*Tz_stream)(unsafe.Pointer(bp))).Fzfree = uintptr(Z_NULL)
				(*(*Tz_stream)(unsafe.Pointer(bp))).Fopaque = uintptr(Z_NULL)
				(*(*Tz_stream)(unsafe.Pointer(bp))).Favail_in = libc.Uint32FromInt32((*TZipEntry)(unsafe.Pointer(z)).FnumCompressedBytes)
				if (*TZipEntry)(unsafe.Pointer(z)).FisEncrypted != 0 {
					/* Min length ZIP_CRYPT_HDR_LEN for keys should already been checked. */
					(*(*Tz_stream)(unsafe.Pointer(bp))).Favail_in -= uint32(ZIP_CRYPT_HDR_LEN)
					if (*(*Tz_stream)(unsafe.Pointer(bp))).Favail_in != 0 {
						v2 = (*(*Tz_stream)(unsafe.Pointer(bp))).Favail_in
					} else {
						v2 = uint32(1)
					}
					cbuf = XTclpAlloc(tls, uint64(v2))
					if !(cbuf != 0) {
						goto memoryError
					}
					j = uint32(0)
					for {
						if !(j < (*(*Tz_stream)(unsafe.Pointer(bp))).Favail_in) {
							break
						}
						ch = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(zbuf + uintptr(j))))
						ch ^= _decrypt_byte(tls, info+80, _crc32tab)
						*(*uint8)(unsafe.Pointer(cbuf + uintptr(j))) = libc.Uint8FromInt32(_update_keys(tls, info+80, _crc32tab, ch))
						goto _3
					_3:
						;
						j++
					}
					(*(*Tz_stream)(unsafe.Pointer(bp))).Fnext_in = cbuf
				} else {
					(*(*Tz_stream)(unsafe.Pointer(bp))).Fnext_in = zbuf
				}
				(*(*Tz_stream)(unsafe.Pointer(bp))).Fnext_out = (*TZipChannel)(unsafe.Pointer(info)).Fubuf
				(*(*Tz_stream)(unsafe.Pointer(bp))).Favail_out = libc.Uint32FromInt64((*TZipChannel)(unsafe.Pointer(info)).FubufSize)
				if libz.XinflateInit2_(tls, bp, -int32(15), __ccgo_ts+70913, libc.Int32FromInt64(112)) != Z_OK {
					goto corruptionError
				}
				err = libz.Xinflate(tls, bp, int32(Z_SYNC_FLUSH))
				libz.XinflateEnd(tls, bp)
				if err != int32(Z_STREAM_END) && (err != Z_OK || (*(*Tz_stream)(unsafe.Pointer(bp))).Favail_in != uint32(0)) {
					goto corruptionError
				}
				/* Even if decompression succeeded, counts should be as expected */
				if libc.Int32FromUint64((*(*Tz_stream)(unsafe.Pointer(bp))).Ftotal_out) != (*TZipEntry)(unsafe.Pointer(z)).FnumBytes {
					goto corruptionError
				}
				(*TZipChannel)(unsafe.Pointer(info)).FnumBytes = int64((*TZipEntry)(unsafe.Pointer(z)).FnumBytes)
				if cbuf != 0 {
					XTclpFree(tls, cbuf)
				}
			} else {
				if (*TZipEntry)(unsafe.Pointer(z)).FisEncrypted != 0 {
					/*
					 * Need to decrypt some otherwise-simple stored data.
					 */
					if (*TZipEntry)(unsafe.Pointer(z)).FnumCompressedBytes <= int32(ZIP_CRYPT_HDR_LEN) || (*TZipEntry)(unsafe.Pointer(z)).FnumCompressedBytes-int32(ZIP_CRYPT_HDR_LEN) != (*TZipEntry)(unsafe.Pointer(z)).FnumBytes {
						goto corruptionError
					}
					len1 = (*TZipEntry)(unsafe.Pointer(z)).FnumCompressedBytes - int32(ZIP_CRYPT_HDR_LEN)
					i = 0
					for {
						if !(i < len1) {
							break
						}
						ch = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(zbuf + uintptr(i))))
						ch ^= _decrypt_byte(tls, info+80, _crc32tab)
						*(*uint8)(unsafe.Pointer((*TZipChannel)(unsafe.Pointer(info)).Fubuf + uintptr(i))) = libc.Uint8FromInt32(_update_keys(tls, info+80, _crc32tab, ch))
						goto _4
					_4:
						;
						i++
					}
					(*TZipChannel)(unsafe.Pointer(info)).FnumBytes = int64(len1)
				} else {
					/*
					 * Simple stored data. Copy into our working buffer.
					 */
					libc.Xmemcpy(tls, (*TZipChannel)(unsafe.Pointer(info)).Fubuf, zbuf, libc.Uint64FromInt32((*TZipEntry)(unsafe.Pointer(z)).FnumBytes))
					(*TZipChannel)(unsafe.Pointer(info)).FnumBytes = int64((*TZipEntry)(unsafe.Pointer(z)).FnumBytes)
				}
			}
			libc.Xmemset(tls, info+80, 0, uint64(24))
		}
	}
	if mode&int32(O_APPEND) != 0 {
		(*TZipChannel)(unsafe.Pointer(info)).Fcursor = (*TZipChannel)(unsafe.Pointer(info)).FnumBytes
	}
	return TCL_OK
	goto memoryError
memoryError:
	;
	if interp != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+1638, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+120, __ccgo_ts+2004, __ccgo_ts+73148, libc.UintptrFromInt32(0)))
	}
	goto error_cleanup
	goto corruptionError
corruptionError:
	;
	if cbuf != 0 {
		libc.Xmemset(tls, info+80, 0, uint64(24))
		XTclpFree(tls, cbuf)
	}
	if interp != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+74903, int64(-int32(1))))
	}
	if interp != 0 {
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+120, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+74923, libc.UintptrFromInt32(0)))
	}
	goto error_cleanup
error_cleanup:
	;
	if (*TZipChannel)(unsafe.Pointer(info)).FubufToFree != 0 {
		XTclpFree(tls, (*TZipChannel)(unsafe.Pointer(info)).FubufToFree)
		(*TZipChannel)(unsafe.Pointer(info)).FubufToFree = libc.UintptrFromInt32(0)
		(*TZipChannel)(unsafe.Pointer(info)).Fubuf = libc.UintptrFromInt32(0)
		(*TZipChannel)(unsafe.Pointer(info)).FubufSize = 0
	}
	return int32(TCL_ERROR)
}

/*
 *-------------------------------------------------------------------------
 *
 * InitReadableChannel --
 *
 *	Assistant for ZipChannelOpen() that sets up a readable channel. It's
 *	up to the caller to actually register the channel. Caller should have
 *	validated the passed ZipEntry (byte counts in particular)
 *
 * Returns:
 *	Tcl result code.
 *
 * Side effects:
 *	Allocates memory for the implementation of the channel. Writes to the
 *	interpreter's result on error.
 *
 *-------------------------------------------------------------------------
 */

func _InitReadableChannel(tls *libc.TLS, interp uintptr, info uintptr, z uintptr) (r int32) {
	bp := tls.Alloc(160)
	defer tls.Free(160) /* The zipped file that the channel will read
	 * from. */
	var ch, err int32
	var j, j1, len1, v1 uint32
	var ubuf uintptr
	var v3 int64
	var _ /* stream at bp+0 */ Tz_stream
	_, _, _, _, _, _, _, _ = ch, err, j, j1, len1, ubuf, v1, v3
	ubuf = libc.UintptrFromInt32(0)
	(*TZipChannel)(unsafe.Pointer(info)).Fiscompr = libc.BoolInt32((*TZipEntry)(unsafe.Pointer(z)).FcompressMethod == int32(ZIP_COMPMETH_DEFLATED))
	(*TZipChannel)(unsafe.Pointer(info)).Fubuf = (*TZipFile)(unsafe.Pointer((*TZipEntry)(unsafe.Pointer(z)).FzipFilePtr)).Fdata + uintptr((*TZipEntry)(unsafe.Pointer(z)).Foffset)
	(*TZipChannel)(unsafe.Pointer(info)).FubufToFree = libc.UintptrFromInt32(0) /* ubuf memory not allocated */
	(*TZipChannel)(unsafe.Pointer(info)).FubufSize = 0
	(*TZipChannel)(unsafe.Pointer(info)).FisDirectory = (*TZipEntry)(unsafe.Pointer(z)).FisDirectory
	(*TZipChannel)(unsafe.Pointer(info)).FisEncrypted = (*TZipEntry)(unsafe.Pointer(z)).FisEncrypted
	(*TZipChannel)(unsafe.Pointer(info)).Fmode = O_RDONLY
	/* Caller must validate - bug [6ed3447a7e] */
	(*TZipChannel)(unsafe.Pointer(info)).FnumBytes = int64((*TZipEntry)(unsafe.Pointer(z)).FnumBytes)
	if (*TZipChannel)(unsafe.Pointer(info)).FisEncrypted != 0 {
		/* caller should have checked*/
		if _DecodeCryptHeader(tls, interp, z, info+80, (*TZipChannel)(unsafe.Pointer(info)).Fubuf) != TCL_OK {
			goto error_cleanup
		}
		*(*uintptr)(unsafe.Pointer(info + 40)) += uintptr(ZIP_CRYPT_HDR_LEN)
	}
	if (*TZipChannel)(unsafe.Pointer(info)).Fiscompr != 0 {
		/*
		 * Data to decode is compressed, and possibly encrpyted too. If
		 * encrypted, local variable ubuf is used to hold the decrypted but
		 * still compressed data.
		 */
		libc.Xmemset(tls, bp, 0, uint64(112))
		(*(*Tz_stream)(unsafe.Pointer(bp))).Fzalloc = uintptr(Z_NULL)
		(*(*Tz_stream)(unsafe.Pointer(bp))).Fzfree = uintptr(Z_NULL)
		(*(*Tz_stream)(unsafe.Pointer(bp))).Fopaque = uintptr(Z_NULL)
		(*(*Tz_stream)(unsafe.Pointer(bp))).Favail_in = libc.Uint32FromInt32((*TZipEntry)(unsafe.Pointer(z)).FnumCompressedBytes)
		if (*TZipChannel)(unsafe.Pointer(info)).FisEncrypted != 0 {
			(*(*Tz_stream)(unsafe.Pointer(bp))).Favail_in -= uint32(ZIP_CRYPT_HDR_LEN)
			if (*(*Tz_stream)(unsafe.Pointer(bp))).Favail_in != 0 {
				v1 = (*(*Tz_stream)(unsafe.Pointer(bp))).Favail_in
			} else {
				v1 = uint32(1)
			}
			ubuf = XTclpAlloc(tls, uint64(v1))
			if !(ubuf != 0) {
				goto memoryError
			}
			j = uint32(0)
			for {
				if !(j < (*(*Tz_stream)(unsafe.Pointer(bp))).Favail_in) {
					break
				}
				ch = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TZipChannel)(unsafe.Pointer(info)).Fubuf + uintptr(j))))
				ch ^= _decrypt_byte(tls, info+80, _crc32tab)
				*(*uint8)(unsafe.Pointer(ubuf + uintptr(j))) = libc.Uint8FromInt32(_update_keys(tls, info+80, _crc32tab, ch))
				goto _2
			_2:
				;
				j++
			}
			(*(*Tz_stream)(unsafe.Pointer(bp))).Fnext_in = ubuf
		} else {
			(*(*Tz_stream)(unsafe.Pointer(bp))).Fnext_in = (*TZipChannel)(unsafe.Pointer(info)).Fubuf
		}
		if (*TZipChannel)(unsafe.Pointer(info)).FnumBytes != 0 {
			v3 = (*TZipChannel)(unsafe.Pointer(info)).FnumBytes
		} else {
			v3 = int64(1)
		}
		(*TZipChannel)(unsafe.Pointer(info)).FubufSize = v3
		(*TZipChannel)(unsafe.Pointer(info)).FubufToFree = XTclpAlloc(tls, libc.Uint64FromInt64((*TZipChannel)(unsafe.Pointer(info)).FubufSize))
		(*TZipChannel)(unsafe.Pointer(info)).Fubuf = (*TZipChannel)(unsafe.Pointer(info)).FubufToFree
		(*(*Tz_stream)(unsafe.Pointer(bp))).Fnext_out = (*TZipChannel)(unsafe.Pointer(info)).Fubuf
		if !((*TZipChannel)(unsafe.Pointer(info)).Fubuf != 0) {
			goto memoryError
		}
		(*(*Tz_stream)(unsafe.Pointer(bp))).Favail_out = libc.Uint32FromInt64((*TZipChannel)(unsafe.Pointer(info)).FnumBytes)
		if libz.XinflateInit2_(tls, bp, -int32(15), __ccgo_ts+70913, libc.Int32FromInt64(112)) != Z_OK {
			goto corruptionError
		}
		err = libz.Xinflate(tls, bp, int32(Z_SYNC_FLUSH))
		libz.XinflateEnd(tls, bp)
		/*
		 * Decompression was successful if we're either in the END state, or
		 * in the OK state with no buffered bytes.
		 */
		if err != int32(Z_STREAM_END) && (err != Z_OK || (*(*Tz_stream)(unsafe.Pointer(bp))).Favail_in != uint32(0)) {
			goto corruptionError
		}
		/* Even if decompression succeeded, counts should be as expected */
		if libc.Int32FromUint64((*(*Tz_stream)(unsafe.Pointer(bp))).Ftotal_out) != (*TZipEntry)(unsafe.Pointer(z)).FnumBytes {
			goto corruptionError
		}
		if ubuf != 0 {
			(*TZipChannel)(unsafe.Pointer(info)).FisEncrypted = 0
			libc.Xmemset(tls, info+80, 0, uint64(24))
			XTclpFree(tls, ubuf)
		}
	} else {
		if (*TZipChannel)(unsafe.Pointer(info)).FisEncrypted != 0 {
			/*
			 * Decode encrypted but uncompressed file, since we support Tcl_Seek()
			 * on it, and it can be randomly accessed later.
			 */
			if (*TZipEntry)(unsafe.Pointer(z)).FnumCompressedBytes <= int32(ZIP_CRYPT_HDR_LEN) || (*TZipEntry)(unsafe.Pointer(z)).FnumCompressedBytes-int32(ZIP_CRYPT_HDR_LEN) != (*TZipEntry)(unsafe.Pointer(z)).FnumBytes {
				goto corruptionError
			}
			len1 = libc.Uint32FromInt32((*TZipEntry)(unsafe.Pointer(z)).FnumCompressedBytes - int32(ZIP_CRYPT_HDR_LEN))
			ubuf = XTclpAlloc(tls, uint64(len1))
			if ubuf == libc.UintptrFromInt32(0) {
				goto memoryError
			}
			j1 = uint32(0)
			for {
				if !(j1 < len1) {
					break
				}
				ch = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TZipChannel)(unsafe.Pointer(info)).Fubuf + uintptr(j1))))
				ch ^= _decrypt_byte(tls, info+80, _crc32tab)
				*(*uint8)(unsafe.Pointer(ubuf + uintptr(j1))) = libc.Uint8FromInt32(_update_keys(tls, info+80, _crc32tab, ch))
				goto _4
			_4:
				;
				j1++
			}
			(*TZipChannel)(unsafe.Pointer(info)).FubufSize = libc.Int64FromUint32(len1)
			(*TZipChannel)(unsafe.Pointer(info)).FubufToFree = ubuf
			(*TZipChannel)(unsafe.Pointer(info)).Fubuf = (*TZipChannel)(unsafe.Pointer(info)).FubufToFree
			ubuf = libc.UintptrFromInt32(0) /* So it does not inadvertently get free on future changes */
			(*TZipChannel)(unsafe.Pointer(info)).FisEncrypted = 0
		}
	}
	return TCL_OK
	goto corruptionError
corruptionError:
	;
	if interp != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+74903, int64(-int32(1))))
	}
	if interp != 0 {
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+120, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+74923, libc.UintptrFromInt32(0)))
	}
	goto error_cleanup
	goto memoryError
memoryError:
	;
	if interp != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+1638, int64(-int32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+120, __ccgo_ts+2004, __ccgo_ts+73148, libc.UintptrFromInt32(0)))
	}
	goto error_cleanup
error_cleanup:
	;
	if ubuf != 0 {
		libc.Xmemset(tls, info+80, 0, uint64(24))
		XTclpFree(tls, ubuf)
	}
	if (*TZipChannel)(unsafe.Pointer(info)).FubufToFree != 0 {
		XTclpFree(tls, (*TZipChannel)(unsafe.Pointer(info)).FubufToFree)
		(*TZipChannel)(unsafe.Pointer(info)).FubufToFree = libc.UintptrFromInt32(0)
		(*TZipChannel)(unsafe.Pointer(info)).Fubuf = libc.UintptrFromInt32(0)
		(*TZipChannel)(unsafe.Pointer(info)).FubufSize = 0
	}
	return int32(TCL_ERROR)
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipEntryStat --
 *
 *	This function implements the ZIP filesystem specific version of the
 *	library version of stat.
 *
 * Results:
 *	See stat documentation.
 *
 * Side effects:
 *	See stat documentation.
 *
 *-------------------------------------------------------------------------
 */

func _ZipEntryStat(tls *libc.TLS, path uintptr, buf uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var ret int32
	var z uintptr
	var v1, v2 Ttime_t
	var _ /* t at bp+0 */ TTcl_Time
	_, _, _, _ = ret, z, v1, v2
	_ReadLock(tls)
	z = _ZipFSLookup(tls, path)
	if z != 0 {
		libc.Xmemset(tls, buf, 0, uint64(144))
		if (*TZipEntry)(unsafe.Pointer(z)).FisDirectory != 0 {
			(*TTcl_StatBuf)(unsafe.Pointer(buf)).Fst_mode = libc.Uint32FromInt32(libc.Int32FromInt32(S_IFDIR) | libc.Int32FromInt32(0555))
		} else {
			(*TTcl_StatBuf)(unsafe.Pointer(buf)).Fst_mode = libc.Uint32FromInt32(libc.Int32FromInt32(S_IFREG) | libc.Int32FromInt32(0555))
		}
		(*TTcl_StatBuf)(unsafe.Pointer(buf)).Fst_size = int64((*TZipEntry)(unsafe.Pointer(z)).FnumBytes)
		(*TTcl_StatBuf)(unsafe.Pointer(buf)).Fst_mtim.Ftv_sec = int64((*TZipEntry)(unsafe.Pointer(z)).Ftimestamp)
		(*TTcl_StatBuf)(unsafe.Pointer(buf)).Fst_ctim.Ftv_sec = int64((*TZipEntry)(unsafe.Pointer(z)).Ftimestamp)
		(*TTcl_StatBuf)(unsafe.Pointer(buf)).Fst_atim.Ftv_sec = int64((*TZipEntry)(unsafe.Pointer(z)).Ftimestamp)
		ret = 0
	} else {
		if _ContainsMountPoint(tls, path, -int32(1)) != 0 {
			/* An intermediate dir under which a mount exists */
			libc.Xmemset(tls, buf, 0, uint64(144))
			XTcl_GetTime(tls, bp)
			v2 = (*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec
			(*TTcl_StatBuf)(unsafe.Pointer(buf)).Fst_ctim.Ftv_sec = v2
			v1 = v2
			(*TTcl_StatBuf)(unsafe.Pointer(buf)).Fst_mtim.Ftv_sec = v1
			(*TTcl_StatBuf)(unsafe.Pointer(buf)).Fst_atim.Ftv_sec = v1
			(*TTcl_StatBuf)(unsafe.Pointer(buf)).Fst_mode = libc.Uint32FromInt32(libc.Int32FromInt32(S_IFDIR) | libc.Int32FromInt32(0555))
			ret = 0
		} else {
			XTcl_SetErrno(tls, int32(ENOENT))
			ret = -int32(1)
		}
	}
	_Unlock(tls)
	return ret
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipEntryAccess --
 *
 *	This function implements the ZIP filesystem specific version of the
 *	library version of access.
 *
 * Results:
 *	See access documentation.
 *
 * Side effects:
 *	See access documentation.
 *
 *-------------------------------------------------------------------------
 */

func _ZipEntryAccess(tls *libc.TLS, path uintptr, mode int32) (r int32) {
	var access, v1, v2 int32
	var z uintptr
	_, _, _, _ = access, z, v1, v2
	if mode&int32(X_OK) != 0 {
		return -int32(1)
	}
	_ReadLock(tls)
	z = _ZipFSLookup(tls, path)
	if z != 0 {
		/* Currently existing files read/write but dirs are read-only */
		if (*TZipEntry)(unsafe.Pointer(z)).FisDirectory != 0 && mode&int32(W_OK) != 0 {
			v1 = -int32(1)
		} else {
			v1 = 0
		}
		access = v1
	} else {
		if mode&int32(W_OK) != 0 {
			access = -int32(1)
		} else {
			/*
			 * Even if entry does not exist, could be intermediate dir
			 * containing a mount point
			 */
			if _ContainsMountPoint(tls, path, -int32(1)) != 0 {
				v2 = 0
			} else {
				v2 = -int32(1)
			}
			access = v2
		}
	}
	_Unlock(tls)
	return access
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSOpenFileChannelProc --
 *
 *	Open a channel to a file in a mounted ZIP archive. Delegates to
 *	ZipChannelOpen().
 *
 * Results:
 *	Tcl_Channel on success, or NULL on error.
 *
 * Side effects:
 *	Allocates memory.
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSOpenFileChannelProc(tls *libc.TLS, interp uintptr, pathPtr uintptr, mode int32, dummy5477 int32) (r TTcl_Channel) {
	pathPtr = XTcl_FSGetNormalizedPath(tls, libc.UintptrFromInt32(0), pathPtr)
	if !(pathPtr != 0) {
		return libc.UintptrFromInt32(0)
	}
	return _ZipChannelOpen(tls, interp, XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0)), mode)
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSStatProc --
 *
 *	This function implements the ZIP filesystem specific version of the
 *	library version of stat.
 *
 * Results:
 *	See stat documentation.
 *
 * Side effects:
 *	See stat documentation.
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSStatProc(tls *libc.TLS, pathPtr uintptr, buf uintptr) (r int32) {
	var v1 uintptr
	_ = v1
	pathPtr = XTcl_FSGetNormalizedPath(tls, libc.UintptrFromInt32(0), pathPtr)
	if !(pathPtr != 0) {
		return -int32(1)
	}
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
	}
	return _ZipEntryStat(tls, v1, buf)
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSAccessProc --
 *
 *	This function implements the ZIP filesystem specific version of the
 *	library version of access.
 *
 * Results:
 *	See access documentation.
 *
 * Side effects:
 *	See access documentation.
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSAccessProc(tls *libc.TLS, pathPtr uintptr, mode int32) (r int32) {
	var v1 uintptr
	_ = v1
	pathPtr = XTcl_FSGetNormalizedPath(tls, libc.UintptrFromInt32(0), pathPtr)
	if !(pathPtr != 0) {
		return -int32(1)
	}
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
	}
	return _ZipEntryAccess(tls, v1, mode)
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSFilesystemSeparatorProc --
 *
 *	This function returns the separator to be used for a given path. The
 *	object returned should have a refCount of zero
 *
 * Results:
 *	A Tcl object, with a refCount of zero. If the caller needs to retain a
 *	reference to the object, it should call Tcl_IncrRefCount, and should
 *	otherwise free the object.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSFilesystemSeparatorProc(tls *libc.TLS, dummy5566 uintptr) (r uintptr) {
	return XTcl_NewStringObj(tls, __ccgo_ts+6339, int64(-int32(1)))
}

/*
 *-------------------------------------------------------------------------
 *
 * AppendWithPrefix --
 *
 *	Worker for ZipFSMatchInDirectoryProc() that is a wrapper around
 *	Tcl_ListObjAppendElement() which knows about handling prefixes.
 *
 *-------------------------------------------------------------------------
 */

func _AppendWithPrefix(tls *libc.TLS, result uintptr, prefix uintptr, name uintptr, nameLen Tsize_t) {
	/* The length of the name. May be TCL_INDEX_NONE for
	 * append-up-to-NUL-byte. */
	var prefixLength Tsize_t
	_ = prefixLength
	if prefix != 0 {
		prefixLength = libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(prefix)).Flength)
		XTcl_DStringAppend(tls, prefix, name, libc.Int64FromUint64(nameLen))
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), result, XTcl_NewStringObj(tls, (*TTcl_DString)(unsafe.Pointer(prefix)).Fstring1, (*TTcl_DString)(unsafe.Pointer(prefix)).Flength))
		XTcl_DStringSetLength(tls, prefix, libc.Int64FromUint64(prefixLength))
	} else {
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), result, XTcl_NewStringObj(tls, name, libc.Int64FromUint64(nameLen)))
	}
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSMatchInDirectoryProc --
 *
 *	This routine is used by the globbing code to search a directory for
 *	all files which match a given pattern.
 *
 * Results:
 *	The return value is a standard Tcl result indicating whether an error
 *	occurred in globbing. Errors are left in interp, good results are
 *	lappend'ed to result (which must be a valid object).
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSMatchInDirectoryProc(tls *libc.TLS, interp uintptr, result uintptr, pathPtr uintptr, pattern uintptr, types uintptr) (r int32) {
	bp := tls.Alloc(608)
	defer tls.Free(608) /* What types we are looking for. */
	var end, hPtr, matchedPath, normPathPtr, pat, path, prefix, prefixBuf, tail, z, zf, v1, v2 uintptr
	var foundInHash, l, scnt, wanted int32
	var strip TTcl_Size
	var v5 int64
	var _ /* ds at bp+376 */ TTcl_DString
	var _ /* dsPref at bp+16 */ TTcl_DString
	var _ /* duplicates at bp+248 */ TTcl_HashTable
	var _ /* len at bp+8 */ TTcl_Size
	var _ /* notDuplicate at bp+240 */ int32
	var _ /* prefixLen at bp+0 */ TTcl_Size
	var _ /* search at bp+352 */ TTcl_HashSearch
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = end, foundInHash, hPtr, l, matchedPath, normPathPtr, pat, path, prefix, prefixBuf, scnt, strip, tail, wanted, z, zf, v1, v2, v5
	normPathPtr = XTcl_FSGetNormalizedPath(tls, libc.UintptrFromInt32(0), pathPtr)
	strip = 0
	prefixBuf = libc.UintptrFromInt32(0) /* TCL_GLOB_TYPE* */
	if !(normPathPtr != 0) {
		return -int32(1)
	}
	if types != 0 {
		wanted = (*TTcl_GlobTypeData)(unsafe.Pointer(types)).Ftype1
		if wanted&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(7)) != 0 && wanted != libc.Int32FromInt32(1)<<libc.Int32FromInt32(7) {
			if interp != 0 {
				if interp != 0 {
					XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+74931, int64(-int32(1))))
				}
			}
			return int32(TCL_ERROR)
		}
		if wanted&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(4)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(7)) == 0 {
			/* Not looking for files,dirs,mounts. zipfs cannot have others */
			return TCL_OK
		}
		wanted &= libc.Int32FromInt32(1)<<libc.Int32FromInt32(2) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(4) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(7)
	} else {
		wanted = libc.Int32FromInt32(1)<<libc.Int32FromInt32(2) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(4)
	}
	/*
	 * The prefix that gets prepended to results.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, pathPtr, bp)
	}
	prefix = v1
	/*
	 * The (normalized) path we're searching.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(normPathPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer(normPathPtr)).Flength
		v2 = (*TTcl_Obj)(unsafe.Pointer(normPathPtr)).Fbytes
	} else {
		v2 = XTcl_GetStringFromObj(tls, normPathPtr, bp+8)
	}
	path = v2
	XTcl_DStringInit(tls, bp+16)
	if libc.Xstrcmp(tls, prefix, path) == 0 {
		prefixBuf = libc.UintptrFromInt32(0)
	} else {
		/*
		 * We need to strip the normalized prefix of the filenames and replace
		 * it with the official prefix that we were expecting to get.
		 */
		strip = *(*TTcl_Size)(unsafe.Pointer(bp + 8)) + int64(1)
		XTcl_DStringAppend(tls, bp+16, prefix, *(*TTcl_Size)(unsafe.Pointer(bp)))
		XTcl_DStringAppend(tls, bp+16, __ccgo_ts+6339, int64(1))
		prefix = (*TTcl_DString)(unsafe.Pointer(bp + 16)).Fstring1
		prefixBuf = bp + 16
	}
	_ReadLock(tls)
	/*
	 * Are we globbing the mount points?
	 */
	if wanted&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(7)) != 0 {
		_ZipFSMatchMountPoints(tls, result, normPathPtr, pattern, prefixBuf)
		goto end
	}
	/* Should not reach here unless at least one of DIR or FILE is set */
	/* Does the path exist in the hash table? */
	z = _ZipFSLookup(tls, path)
	if z != 0 {
		/*
		 * Can we skip the complexity of actual globbing? Without a pattern,
		 * yes; it's a directory existence test.
		 */
		if !(pattern != 0) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) == int32('\000') {
			/* TODO - can't seem to get to this code from script for tests. */
			/* Follow logic of what tclUnixFile.c does */
			if wanted == libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(4) || wanted == libc.Int32FromInt32(1)<<libc.Int32FromInt32(2) && (*TZipEntry)(unsafe.Pointer(z)).FisDirectory != 0 || wanted == libc.Int32FromInt32(1)<<libc.Int32FromInt32(4) && !((*TZipEntry)(unsafe.Pointer(z)).FisDirectory != 0) {
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), result, pathPtr)
			}
			goto end
		}
	} else {
		/* Not in the hash table but could be an intermediate dir in a mount */
		if !(pattern != 0) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) == int32('\000') {
			/* TODO - can't seem to get to this code from script for tests. */
			if wanted&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 && _ContainsMountPoint(tls, path, int32(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))) != 0 {
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), result, pathPtr)
			}
			goto end
		}
	}
	foundInHash = libc.BoolInt32(z != libc.UintptrFromInt32(0))
	/*
	 * We've got to work for our supper and do the actual globbing. And all
	 * we've got really is an undifferentiated pile of all the filenames we've
	 * got from all our ZIP mounts.
	 */
	l = libc.Int32FromUint64(libc.Xstrlen(tls, pattern))
	pat = XTcl_Alloc(tls, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8))+int64(l)+int64(2)))
	libc.Xmemcpy(tls, pat, path, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 8))))
	for *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > int64(1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8))-int64(1))))) == int32('/') {
		*(*TTcl_Size)(unsafe.Pointer(bp + 8))--
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > int64(1) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) != int32('/') {
		*(*uint8)(unsafe.Pointer(pat + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8))))) = uint8('/')
		*(*TTcl_Size)(unsafe.Pointer(bp + 8))++
	}
	libc.Xmemcpy(tls, pat+uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8))), pattern, libc.Uint64FromInt32(l+int32(1)))
	scnt = libc.Int32FromUint64(_CountSlashes(tls, pat))
	*(*int32)(unsafe.Pointer(bp + 240)) = 0
	XTcl_InitHashTable(tls, bp+248, TCL_STRING_KEYS)
	if foundInHash != 0 {
		hPtr = XTcl_FirstHashEntry(tls, uintptr(unsafe.Pointer(&_ZipFS))+32, bp+352)
		for {
			if !(hPtr != 0) {
				break
			}
			z = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
			if wanted == libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(4) || wanted == libc.Int32FromInt32(1)<<libc.Int32FromInt32(2) && (*TZipEntry)(unsafe.Pointer(z)).FisDirectory != 0 || wanted == libc.Int32FromInt32(1)<<libc.Int32FromInt32(4) && !((*TZipEntry)(unsafe.Pointer(z)).FisDirectory != 0) {
				if (*TZipEntry)(unsafe.Pointer(z)).Fdepth == scnt && (*TZipEntry)(unsafe.Pointer(z)).Fflags&int32(ZE_F_VOLUME) == 0 && XTcl_StringCaseMatch(tls, (*TZipEntry)(unsafe.Pointer(z)).Fname, pat, 0) != 0 {
					(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(bp + 248)).FcreateProc})))(tls, bp+248, (*TZipEntry)(unsafe.Pointer(z)).Fname+uintptr(strip), bp+240)
					_AppendWithPrefix(tls, result, prefixBuf, (*TZipEntry)(unsafe.Pointer(z)).Fname+uintptr(strip), libc.Uint64FromInt32(-libc.Int32FromInt32(1)))
				}
			}
			goto _3
		_3:
			;
			hPtr = XTcl_NextHashEntry(tls, bp+352)
		}
	}
	if wanted&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
		XTcl_DStringInit(tls, bp+376)
		hPtr = XTcl_FirstHashEntry(tls, uintptr(unsafe.Pointer(&_ZipFS))+136, bp+352)
		for {
			if !(hPtr != 0) {
				break
			}
			zf = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
			if XTcl_StringCaseMatch(tls, (*TZipFile)(unsafe.Pointer(zf)).FmountPoint, pat, 0) != 0 {
				tail = (*TZipFile)(unsafe.Pointer(zf)).FmountPoint + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(tail))) == int32('\000') {
					goto _4
				}
				end = libc.Xstrchr(tls, tail, int32('/'))
				if end != 0 {
					v5 = int64(end) - int64((*TZipFile)(unsafe.Pointer(zf)).FmountPoint)
				} else {
					v5 = int64(-int32(1))
				}
				XTcl_DStringAppend(tls, bp+376, (*TZipFile)(unsafe.Pointer(zf)).FmountPoint+uintptr(strip), v5)
				matchedPath = (*TTcl_DString)(unsafe.Pointer(bp + 376)).Fstring1
				(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(bp + 248)).FcreateProc})))(tls, bp+248, matchedPath, bp+240)
				if *(*int32)(unsafe.Pointer(bp + 240)) != 0 {
					_AppendWithPrefix(tls, result, prefixBuf, matchedPath, libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(bp+376)).Flength))
				}
				XTcl_DStringFree(tls, bp+376)
			}
			goto _4
		_4:
			;
			hPtr = XTcl_NextHashEntry(tls, bp+352)
		}
	}
	XTcl_DeleteHashTable(tls, bp+248)
	XTclpFree(tls, pat)
	goto end
end:
	;
	_Unlock(tls)
	XTcl_DStringFree(tls, bp+16)
	return TCL_OK
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSMatchMountPoints --
 *
 *	This routine is a worker for ZipFSMatchInDirectoryProc, used by the
 *	globbing code to search for all mount points files which match a given
 *	pattern.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Adds the matching mounts to the list in result, uses prefix as working
 *	space if it is non-NULL.
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSMatchMountPoints(tls *libc.TLS, result uintptr, normPathPtr uintptr, pattern uintptr, prefix uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Workspace filled with a prefix for all the
	 * filenames, or NULL if no prefix is to be
	 * used. */
	var hPtr, path, z, zf, v1 uintptr
	var l int32
	var len1, lenz TTcl_Size
	var _ /* normLength at bp+24 */ TTcl_Size
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _, _, _ = hPtr, l, len1, lenz, path, z, zf, v1
	if (*TTcl_Obj)(unsafe.Pointer(normPathPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = (*TTcl_Obj)(unsafe.Pointer(normPathPtr)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(normPathPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, normPathPtr, bp+24)
	}
	path = v1
	len1 = *(*TTcl_Size)(unsafe.Pointer(bp + 24))
	if len1 < int64(1) {
		/*
		 * Shouldn't happen. But "shouldn't"...
		 */
		return
	}
	l = libc.Int32FromUint64(_CountSlashes(tls, path))
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(len1-int64(1))))) == int32('/') {
		len1--
	} else {
		l++
	}
	if !(pattern != 0) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) == int32('\000') {
		pattern = __ccgo_ts + 6235
	}
	hPtr = XTcl_FirstHashEntry(tls, uintptr(unsafe.Pointer(&_ZipFS))+136, bp)
	for {
		if !(hPtr != 0) {
			break
		}
		zf = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		if (*TZipFile)(unsafe.Pointer(zf)).FmountPointLen == 0 {
			/*
			 * Enumerate the contents of the ZIP; it's mounted on the root.
			 * TODO - a holdover from androwish? Tcl does not allow mounting
			 * outside of the //zipfs:/ area.
			 */
			z = (*TZipFile)(unsafe.Pointer(zf)).FtopEnts
			for {
				if !(z != 0) {
					break
				}
				lenz = libc.Int64FromUint64(libc.Xstrlen(tls, (*TZipEntry)(unsafe.Pointer(z)).Fname))
				if lenz > len1+int64(1) && libc.Xstrncmp(tls, (*TZipEntry)(unsafe.Pointer(z)).Fname, path, libc.Uint64FromInt64(len1)) == 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TZipEntry)(unsafe.Pointer(z)).Fname + uintptr(len1)))) == int32('/') && libc.Int32FromUint64(_CountSlashes(tls, (*TZipEntry)(unsafe.Pointer(z)).Fname)) == l && XTcl_StringCaseMatch(tls, (*TZipEntry)(unsafe.Pointer(z)).Fname+uintptr(len1)+uintptr(1), pattern, 0) != 0 {
					_AppendWithPrefix(tls, result, prefix, (*TZipEntry)(unsafe.Pointer(z)).Fname, libc.Uint64FromInt64(lenz))
				}
				goto _3
			_3:
				;
				z = (*TZipEntry)(unsafe.Pointer(z)).Ftnext
			}
		} else {
			if (*TZipFile)(unsafe.Pointer(zf)).FmountPointLen > len1+int64(1) && libc.Xstrncmp(tls, (*TZipFile)(unsafe.Pointer(zf)).FmountPoint, path, libc.Uint64FromInt64(len1)) == 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TZipFile)(unsafe.Pointer(zf)).FmountPoint + uintptr(len1)))) == int32('/') && libc.Int32FromUint64(_CountSlashes(tls, (*TZipFile)(unsafe.Pointer(zf)).FmountPoint)) == l && XTcl_StringCaseMatch(tls, (*TZipFile)(unsafe.Pointer(zf)).FmountPoint+uintptr(len1)+uintptr(1), pattern, 0) != 0 {
				/*
				 * Standard mount; append if it matches.
				 */
				_AppendWithPrefix(tls, result, prefix, (*TZipFile)(unsafe.Pointer(zf)).FmountPoint, libc.Uint64FromInt64((*TZipFile)(unsafe.Pointer(zf)).FmountPointLen))
			}
		}
		goto _2
	_2:
		;
		hPtr = XTcl_NextHashEntry(tls, bp)
	}
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSPathInFilesystemProc --
 *
 *	This function determines if the given path object is in the ZIP
 *	filesystem.
 *
 * Results:
 *	TCL_OK when the path object is in the ZIP filesystem, -1 otherwise.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSPathInFilesystemProc(tls *libc.TLS, pathPtr uintptr, dummy5930 uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, path, v1, v4 uintptr
	var decrRef, ret, v2 int32
	var v3 TTcl_Size
	var _ /* len at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _ = _objPtr, decrRef, path, ret, v1, v2, v3, v4
	decrRef = 0
	if XTclFSCwdIsNative(tls) != 0 || XTcl_FSGetPathType(tls, pathPtr) == int32(TCL_PATH_ABSOLUTE) {
		/*
		 * The cwd is native (or path is absolute), use the translated path
		 * without worrying about normalization (this will also usually be
		 * shorter so the utf-to-external conversion will be somewhat faster).
		 */
		pathPtr = XTcl_FSGetTranslatedPath(tls, libc.UintptrFromInt32(0), pathPtr)
		if pathPtr == libc.UintptrFromInt32(0) {
			return -int32(1)
		}
		decrRef = int32(1) /* Tcl_FSGetTranslatedPath increases refCount */
	} else {
		/*
		 * Make sure the normalized path is set.
		 */
		pathPtr = XTcl_FSGetNormalizedPath(tls, libc.UintptrFromInt32(0), pathPtr)
		if !(pathPtr != 0) {
			return -int32(1)
		}
		/* Tcl_FSGetNormalizedPath doesn't increase refCount */
	}
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, pathPtr, bp)
	}
	path = v1
	/*
	 * Claim any path under ZIPFS_VOLUME as ours. This is both a necessary
	 * and sufficient condition as zipfs mounts at arbitrary paths are
	 * not permitted (unlike Androwish).
	 */
	if *(*TTcl_Size)(unsafe.Pointer(bp)) < int64(ZIPFS_VOLUME_LEN) || libc.Xstrncmp(tls, path, __ccgo_ts+72859, uint64(ZIPFS_VOLUME_LEN)) != 0 {
		v2 = -int32(1)
	} else {
		v2 = TCL_OK
	}
	ret = v2
	if decrRef != 0 {
		_objPtr = pathPtr
		v4 = _objPtr
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	return ret
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSListVolumesProc --
 *
 *	Lists the currently mounted ZIP filesystem volumes.
 *
 * Results:
 *	The list of volumes.
 *
 * Side effects:
 *	None
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSListVolumesProc(tls *libc.TLS) (r uintptr) {
	return XTcl_NewStringObj(tls, __ccgo_ts+72859, int64(-int32(1)))
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSFileAttrStringsProc --
 *
 *	This function implements the ZIP filesystem dependent 'file
 *	attributes' subcommand, for listing the set of possible attribute
 *	strings.
 *
 * Results:
 *	An array of strings
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

type ZipFileAttrs = int32

const ZIP_ATTR_UNCOMPSIZE = 0
const ZIP_ATTR_COMPSIZE = 1
const ZIP_ATTR_OFFSET = 2
const ZIP_ATTR_MOUNT = 3
const ZIP_ATTR_ARCHIVE = 4
const ZIP_ATTR_PERMISSIONS = 5
const ZIP_ATTR_CRC = 6

func _ZipFSFileAttrStringsProc(tls *libc.TLS, dummy6029 uintptr, dummy6030 uintptr) (r uintptr) {
	return uintptr(unsafe.Pointer(&_attrs))
}

/*
 * Must match up with ZipFileAttrs enum above.
 */

var _attrs = [8]uintptr{
	0: __ccgo_ts + 75023,
	1: __ccgo_ts + 75035,
	2: __ccgo_ts + 75045,
	3: __ccgo_ts + 75053,
	4: __ccgo_ts + 75060,
	5: __ccgo_ts + 33918,
	6: __ccgo_ts + 75069,
	7: libc.UintptrFromInt32(0),
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSFileAttrsGetProc --
 *
 *	This function implements the ZIP filesystem specific 'file attributes'
 *	subcommand, for 'get' operations.
 *
 * Results:
 *	Standard Tcl return code. The object placed in objPtrRef (if TCL_OK
 *	was returned) is likely to have a refCount of zero. Either way we must
 *	either store it somewhere (e.g. the Tcl result), or Incr/Decr its
 *	refCount to ensure it is properly freed.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSFileAttrsGetProc(tls *libc.TLS, interp uintptr, index int32, pathPtr uintptr, objPtrRef uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var cachePtr, cachePtr1, cachePtr2, cachePtr3, path, z, v1, v20 uintptr
	var ret, v15, v17, v22 int32
	var v14, v16, v18, v21 bool
	var v19 uint64
	var _ /* len at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, cachePtr3, path, ret, z, v1, v14, v15, v16, v17, v18, v19, v20, v21, v22
	ret = TCL_OK
	pathPtr = XTcl_FSGetNormalizedPath(tls, libc.UintptrFromInt32(0), pathPtr)
	if !(pathPtr != 0) {
		return -int32(1)
	}
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, pathPtr, bp)
	}
	path = v1
	_ReadLock(tls)
	z = _ZipFSLookup(tls, path)
	if !(z != 0) && !(_ContainsMountPoint(tls, path, -int32(1)) != 0) {
		XTcl_SetErrno(tls, int32(ENOENT))
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+24923, libc.VaList(bp+16, __ccgo_ts+75074, XTcl_PosixError(tls, interp))))
		}
		ret = int32(TCL_ERROR)
		goto done
	}
	/* z == NULL for intermediate directories that are ancestors of mounts */
	switch index {
	case int32(ZIP_ATTR_UNCOMPSIZE):
		goto _2
	case int32(ZIP_ATTR_COMPSIZE):
		goto _3
	case int32(ZIP_ATTR_OFFSET):
		goto _4
	case int32(ZIP_ATTR_MOUNT):
		goto _5
	case int32(ZIP_ATTR_ARCHIVE):
		goto _6
	case int32(ZIP_ATTR_PERMISSIONS):
		goto _7
	case int32(ZIP_ATTR_CRC):
		goto _8
	default:
		goto _9
	}
	goto _10
_2:
	;
_13:
	;
	if v14 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v14 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v14 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		*(*uintptr)(unsafe.Pointer(objPtrRef)) = XTclThreadAllocObj(tls)
	} else {
		*(*uintptr)(unsafe.Pointer(objPtrRef)) = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objPtrRef)) + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objPtrRef)))).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objPtrRef)))).Fbytes = libc.UintptrFromInt32(0)
	if z != 0 {
		v15 = (*TZipEntry)(unsafe.Pointer(z)).FnumBytes
	} else {
		v15 = 0
	}
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objPtrRef)))).FinternalRep)) = int64(v15)
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objPtrRef)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	goto _12
_12:
	;
	if 0 != 0 {
		goto _13
	}
	goto _11
_11:
	;
	goto _10
_3:
	;
	if v16 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v16 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v16 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		*(*uintptr)(unsafe.Pointer(objPtrRef)) = XTclThreadAllocObj(tls)
	} else {
		*(*uintptr)(unsafe.Pointer(objPtrRef)) = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objPtrRef)) + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objPtrRef)))).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objPtrRef)))).Fbytes = libc.UintptrFromInt32(0)
	if z != 0 {
		v17 = (*TZipEntry)(unsafe.Pointer(z)).FnumCompressedBytes
	} else {
		v17 = 0
	}
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objPtrRef)))).FinternalRep)) = int64(v17)
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objPtrRef)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	goto _10
_4:
	;
	if v18 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v18 {
		cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v18 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
		*(*uintptr)(unsafe.Pointer(objPtrRef)) = XTclThreadAllocObj(tls)
	} else {
		*(*uintptr)(unsafe.Pointer(objPtrRef)) = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objPtrRef)) + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objPtrRef)))).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objPtrRef)))).Fbytes = libc.UintptrFromInt32(0)
	if z != 0 {
		v19 = (*TZipEntry)(unsafe.Pointer(z)).Foffset
	} else {
		v19 = uint64(0)
	}
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objPtrRef)))).FinternalRep)) = libc.Int64FromUint64(v19)
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objPtrRef)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	goto _10
_5:
	;
	if z != 0 {
		*(*uintptr)(unsafe.Pointer(objPtrRef)) = XTcl_NewStringObj(tls, (*TZipFile)(unsafe.Pointer((*TZipEntry)(unsafe.Pointer(z)).FzipFilePtr)).FmountPoint, (*TZipFile)(unsafe.Pointer((*TZipEntry)(unsafe.Pointer(z)).FzipFilePtr)).FmountPointLen)
	} else {
		*(*uintptr)(unsafe.Pointer(objPtrRef)) = XTcl_NewStringObj(tls, __ccgo_ts+1945, 0)
	}
	goto _10
_6:
	;
	if z != 0 {
		v20 = (*TZipFile)(unsafe.Pointer((*TZipEntry)(unsafe.Pointer(z)).FzipFilePtr)).Fname
	} else {
		v20 = __ccgo_ts + 1945
	}
	*(*uintptr)(unsafe.Pointer(objPtrRef)) = XTcl_NewStringObj(tls, v20, int64(-int32(1)))
	goto _10
_7:
	;
	*(*uintptr)(unsafe.Pointer(objPtrRef)) = XTcl_NewStringObj(tls, __ccgo_ts+75089, int64(-int32(1)))
	goto _10
_8:
	;
	if v21 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v21 {
		cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v21 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
		*(*uintptr)(unsafe.Pointer(objPtrRef)) = XTclThreadAllocObj(tls)
	} else {
		*(*uintptr)(unsafe.Pointer(objPtrRef)) = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objPtrRef)) + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objPtrRef)))).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objPtrRef)))).Fbytes = libc.UintptrFromInt32(0)
	if z != 0 {
		v22 = (*TZipEntry)(unsafe.Pointer(z)).Fcrc32
	} else {
		v22 = 0
	}
	*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objPtrRef)))).FinternalRep)) = int64(v22)
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objPtrRef)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	goto _10
_9:
	;
	if interp != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+75095, int64(-int32(1))))
	}
	if interp != 0 {
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+75113, libc.UintptrFromInt32(0)))
	}
	ret = int32(TCL_ERROR)
_10:
	;
	goto done
done:
	;
	_Unlock(tls)
	return ret
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSFileAttrsSetProc --
 *
 *	This function implements the ZIP filesystem specific 'file attributes'
 *	subcommand, for 'set' operations.
 *
 * Results:
 *	Standard Tcl return code.
 *
 * Side effects:
 *	None.
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSFileAttrsSetProc(tls *libc.TLS, interp uintptr, dummy6154 int32, dummy6155 uintptr, dummy6156 uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	if interp != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+75123, int64(-int32(1))))
	}
	if interp != 0 {
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+73080, __ccgo_ts+35769, libc.UintptrFromInt32(0)))
	}
	return int32(TCL_ERROR)
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSFilesystemPathTypeProc --
 *
 * Results:
 *
 * Side effects:
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSFilesystemPathTypeProc(tls *libc.TLS, dummy6177 uintptr) (r uintptr) {
	return XTcl_NewStringObj(tls, __ccgo_ts+72855, int64(-int32(1)))
}

/*
 *-------------------------------------------------------------------------
 *
 * ZipFSLoadFile --
 *
 *	This functions deals with loading native object code. If the given
 *	path object refers to a file within the ZIP filesystem, an approriate
 *	error code is returned to delegate loading to the caller (by copying
 *	the file to temp store and loading from there). As fallback when the
 *	file refers to the ZIP file system but is not present, it is looked up
 *	relative to the executable and loaded from there when available.
 *
 * Results:
 *	TCL_OK on success, TCL_ERROR otherwise with error message left.
 *
 * Side effects:
 *	Loads native code into the process address space.
 *
 *-------------------------------------------------------------------------
 */

func _ZipFSLoadFile(tls *libc.TLS, interp uintptr, path uintptr, loadHandle uintptr, unloadProcPtr uintptr, flags int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, _objPtr1, _objPtr2, altPath, cachePtr, execName, loadFileProc, p, v2, v5, v7, v9 uintptr
	var ret int32
	var v1, v4, v6, v8 TTcl_Size
	var v3 bool
	var _ /* objs at bp+0 */ [2]uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, altPath, cachePtr, execName, loadFileProc, p, ret, v1, v2, v3, v4, v5, v6, v7, v8, v9
	altPath = libc.UintptrFromInt32(0)
	ret = int32(TCL_ERROR)
	*(*[2]uintptr)(unsafe.Pointer(bp)) = [2]uintptr{}
	if XTcl_FSAccess(tls, path, int32(R_OK)) == 0 {
		/*
		 * EXDEV should trigger loading by copying to temp store.
		 */
		XTcl_SetErrno(tls, int32(EXDEV))
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, XTcl_PosixError(tls, interp), int64(-int32(1))))
		}
		return ret
	}
	(*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)] = XTclPathPart(tls, interp, path, int32(TCL_PATH_DIRNAME))
	if (*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)] != 0 && _ZipFSAccessProc(tls, (*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)], int32(R_OK)) == 0 {
		execName = XTcl_GetNameOfExecutable(tls)
		/*
		 * Shared object is not in ZIP but its path prefix is, thus try to
		 * load from directory where the executable came from.
		 */
		v2 = (*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)]
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if !(v1 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)])).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)])).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)])).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)])).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)])).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)])).Flength = int64(-libc.Int32FromInt32(1))
				if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, (*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)])
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)] + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)]
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, (*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)])
			}
		}
		(*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)] = XTclPathPart(tls, interp, path, int32(TCL_PATH_TAIL))
		/*
		 * Get directory name of executable manually to deal with cases where
		 * [file dirname [info nameofexecutable]] is equal to [info
		 * nameofexecutable] due to VFS effects.
		 */
		if execName != 0 {
			p = libc.Xstrrchr(tls, execName, int32('/'))
			if p != 0 && p > execName+uintptr(1) {
				p--
				(*(*[2]uintptr)(unsafe.Pointer(bp)))[0] = XTcl_NewStringObj(tls, execName, int64(p)-int64(execName))
			}
		}
		if !((*(*[2]uintptr)(unsafe.Pointer(bp)))[0] != 0) {
			(*(*[2]uintptr)(unsafe.Pointer(bp)))[0] = XTclPathPart(tls, interp, XTclGetObjNameOfExecutable(tls), int32(TCL_PATH_DIRNAME))
		}
		if (*(*[2]uintptr)(unsafe.Pointer(bp)))[0] != 0 {
			altPath = XTclJoinPath(tls, int64(2), bp, 0)
			if altPath != 0 {
				(*TTcl_Obj)(unsafe.Pointer(altPath)).FrefCount++
				if XTcl_FSAccess(tls, altPath, int32(R_OK)) == 0 {
					path = altPath
				}
			}
		}
	}
	if (*(*[2]uintptr)(unsafe.Pointer(bp)))[0] != 0 {
		_objPtr = (*(*[2]uintptr)(unsafe.Pointer(bp)))[0]
		v5 = _objPtr
		v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
		*(*TTcl_Size)(unsafe.Pointer(v5))--
		if v4 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	if (*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)] != 0 {
		_objPtr1 = (*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)]
		v7 = _objPtr1
		v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
		*(*TTcl_Size)(unsafe.Pointer(v7))--
		if v6 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
	loadFileProc = XtclNativeFilesystem.FloadFileProc
	if loadFileProc != 0 {
		ret = (*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{loadFileProc})))(tls, interp, path, loadHandle, unloadProcPtr, flags)
	} else {
		XTcl_SetErrno(tls, int32(ENOENT))
		if interp != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, XTcl_PosixError(tls, interp), int64(-int32(1))))
		}
	}
	if altPath != 0 {
		_objPtr2 = altPath
		v9 = _objPtr2
		v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
		*(*TTcl_Size)(unsafe.Pointer(v9))--
		if v8 <= int64(1) {
			XTclFreeObj(tls, _objPtr2)
		}
	}
	return ret
}

/*
 *-------------------------------------------------------------------------
 *
 * TclZipfs_Init --
 *
 *	Perform per interpreter initialization of this module.
 *
 * Results:
 *	The return value is a standard Tcl result.
 *
 * Side effects:
 *	Initializes this module if not already initialized, and adds module
 *	related commands to the given interpreter.
 *
 *-------------------------------------------------------------------------
 */

func XTclZipfs_Init(tls *libc.TLS, interp uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Current interpreter. */
	var ensemble TTcl_Command
	var v1 uintptr
	var _ /* mapObj at bp+0 */ uintptr
	_, _ = ensemble, v1
	/*
	 * One-time initialization.
	 */
	_WriteLock(tls)
	if !(_ZipFS.Finitialized != 0) {
		_ZipfsSetup(tls)
	}
	_Unlock(tls)
	if interp != 0 {
		XTcl_EvalEx(tls, interp, uintptr(unsafe.Pointer(&_findproc)), int64(-libc.Int32FromInt32(1)), int32(TCL_EVAL_GLOBAL))
		if !(XTcl_IsSafe(tls, interp) != 0) {
			XTcl_LinkVar(tls, interp, __ccgo_ts+75145, uintptr(unsafe.Pointer(&_ZipFS))+12, int32(TCL_LINK_INT))
			XTcl_LinkVar(tls, interp, __ccgo_ts+75165, uintptr(unsafe.Pointer(&_ZipFS))+16, int32(TCL_LINK_STRING))
		}
		if XTcl_IsSafe(tls, interp) != 0 {
			v1 = uintptr(unsafe.Pointer(&_initMap2)) + libc.UintptrFromInt32(4)*48
		} else {
			v1 = uintptr(unsafe.Pointer(&_initMap2))
		}
		ensemble = XTclMakeEnsemble(tls, interp, __ccgo_ts+5934, v1)
		/*
		 * Add the [zipfs find] subcommand.
		 */
		XTcl_GetEnsembleMappingDict(tls, libc.UintptrFromInt32(0), ensemble, bp)
		XTclDictPutString(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), __ccgo_ts+75201, __ccgo_ts+74088)
		XTcl_CreateObjCommand(tls, interp, __ccgo_ts+75206, __ccgo_fp(_ZipFSTclLibraryObjCmd), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	}
	return TCL_OK
}

var _initMap2 = [14]TEnsembleImplMap{
	0: {
		Fname:   __ccgo_ts + 5964,
		Funsafe: int32(1),
	},
	1: {
		Fname:   __ccgo_ts + 5976,
		Funsafe: int32(1),
	},
	2: {
		Fname:   __ccgo_ts + 5950,
		Funsafe: int32(1),
	},
	3: {
		Fname:   __ccgo_ts + 5957,
		Funsafe: int32(1),
	},
	4: {
		Fname:   __ccgo_ts + 5982,
		Funsafe: int32(1),
	},
	5: {
		Fname:   __ccgo_ts + 5988,
		Funsafe: int32(1),
	},
	6: {
		Fname:   __ccgo_ts + 6003,
		Funsafe: int32(1),
	},
	7: {
		Fname:   __ccgo_ts + 5970,
		Funsafe: int32(1),
	},
	8: {
		Fname:   __ccgo_ts + 5689,
		Funsafe: int32(1),
	},
	9: {
		Fname:   __ccgo_ts + 5873,
		Funsafe: int32(1),
	},
	10: {
		Fname:   __ccgo_ts + 2860,
		Funsafe: int32(1),
	},
	11: {
		Fname:   __ccgo_ts + 5940,
		Funsafe: int32(1),
	},
	12: {
		Fname:   __ccgo_ts + 5998,
		Funsafe: int32(1),
	},
	13: {},
}

func init() {
	p := unsafe.Pointer(&_initMap2)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_ZipFSMkImgObjCmd)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(_ZipFSMkZipObjCmd)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(_ZipFSLMkImgObjCmd)
	*(*uintptr)(unsafe.Add(p, 152)) = __ccgo_fp(_ZipFSLMkZipObjCmd)
	*(*uintptr)(unsafe.Add(p, 200)) = __ccgo_fp(_ZipFSMountObjCmd)
	*(*uintptr)(unsafe.Add(p, 248)) = __ccgo_fp(_ZipFSMountBufferObjCmd)
	*(*uintptr)(unsafe.Add(p, 296)) = __ccgo_fp(_ZipFSUnmountObjCmd)
	*(*uintptr)(unsafe.Add(p, 344)) = __ccgo_fp(_ZipFSMkKeyObjCmd)
	*(*uintptr)(unsafe.Add(p, 392)) = __ccgo_fp(_ZipFSExistsObjCmd)
	*(*uintptr)(unsafe.Add(p, 440)) = __ccgo_fp(_ZipFSInfoObjCmd)
	*(*uintptr)(unsafe.Add(p, 488)) = __ccgo_fp(_ZipFSListObjCmd)
	*(*uintptr)(unsafe.Add(p, 536)) = __ccgo_fp(_ZipFSCanonicalObjCmd)
	*(*uintptr)(unsafe.Add(p, 584)) = __ccgo_fp(_ZipFSRootObjCmd)
}

var _findproc = [500]uint8{'n', 'a', 'm', 'e', 's', 'p', 'a', 'c', 'e', ' ', 'e', 'v', 'a', 'l', ' ', ':', ':', 't', 'c', 'l', ':', ':', 'z', 'i', 'p', 'f', 's', ' ', '{', '}', 10, 'p', 'r', 'o', 'c', ' ', ':', ':', 't', 'c', 'l', ':', ':', 'z', 'i', 'p', 'f', 's', ':', ':', 'F', 'i', 'n', 'd', ' ', 'd', 'i', 'r', ' ', '{', 10, ' ', ' ', ' ', ' ', 's', 'e', 't', ' ', 'r', 'e', 's', 'u', 'l', 't', ' ', '{', '}', 10, ' ', ' ', ' ', ' ', 'i', 'f', ' ', '{', '[', 'c', 'a', 't', 'c', 'h', ' ', '{', 10, ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'c', 'o', 'n', 'c', 'a', 't', ' ', '[', 'g', 'l', 'o', 'b', ' ', '-', 'd', 'i', 'r', 'e', 'c', 't', 'o', 'r', 'y', ' ', '$', 'd', 'i', 'r', ' ', '-', 'n', 'o', 'c', 'o', 'm', 'p', 'l', 'a', 'i', 'n', ' ', '*', ']', ' ', '[', 'g', 'l', 'o', 'b', ' ', '-', 'd', 'i', 'r', 'e', 'c', 't', 'o', 'r', 'y', ' ', '$', 'd', 'i', 'r', ' ', '-', 't', 'y', 'p', 'e', 's', ' ', 'h', 'i', 'd', 'd', 'e', 'n', ' ', '-', 'n', 'o', 'c', 'o', 'm', 'p', 'l', 'a', 'i', 'n', ' ', '*', ']', 10, ' ', ' ', ' ', ' ', '}', ' ', 'l', 'i', 's', 't', ']', '}', ' ', '{', 10, ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'r', 'e', 't', 'u', 'r', 'n', ' ', '$', 'r', 'e', 's', 'u', 'l', 't', 10, ' ', ' ', ' ', ' ', '}', 10, ' ', ' ', ' ', ' ', 'f', 'o', 'r', 'e', 'a', 'c', 'h', ' ', 'f', 'i', 'l', 'e', ' ', '$', 'l', 'i', 's', 't', ' ', '{', 10, ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'i', 'f', ' ', '{', '[', 'f', 'i', 'l', 'e', ' ', 't', 'a', 'i', 'l', ' ', '$', 'f', 'i', 'l', 'e', ']', ' ', 'i', 'n', ' ', '{', '.', ' ', '.', '.', '}', '}', ' ', '{', 10, ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'c', 'o', 'n', 't', 'i', 'n', 'u', 'e', 10, ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '}', 10, ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'l', 'a', 'p', 'p', 'e', 'n', 'd', ' ', 'r', 'e', 's', 'u', 'l', 't', ' ', '$', 'f', 'i', 'l', 'e', ' ', '{', '*', '}', '[', 'F', 'i', 'n', 'd', ' ', '$', 'f', 'i', 'l', 'e', ']', 10, ' ', ' ', ' ', ' ', '}', 10, ' ', ' ', ' ', ' ', 'r', 'e', 't', 'u', 'r', 'n', ' ', '$', 'r', 'e', 's', 'u', 'l', 't', 10, '}', 10, 'p', 'r', 'o', 'c', ' ', ':', ':', 't', 'c', 'l', ':', ':', 'z', 'i', 'p', 'f', 's', ':', ':', 'f', 'i', 'n', 'd', ' ', '{', 'd', 'i', 'r', 'e', 'c', 't', 'o', 'r', 'y', 'N', 'a', 'm', 'e', '}', ' ', '{', 10, ' ', ' ', ' ', ' ', 'r', 'e', 't', 'u', 'r', 'n', ' ', '[', 'l', 's', 'o', 'r', 't', ' ', '[', 'F', 'i', 'n', 'd', ' ', '$', 'd', 'i', 'r', 'e', 'c', 't', 'o', 'r', 'y', 'N', 'a', 'm', 'e', ']', ']', 10, '}', 10}

// C documentation
//
//	/*
//	 *------------------------------------------------------------------------
//	 *
//	 * TclZipfsFinalize --
//	 *
//	 *    Frees all zipfs resources IRRESPECTIVE of open channels (there should
//	 *    not be any!) etc. To be called at process exit time (from
//	 *    Tcl_Finalize->TclFinalizeFilesystem)
//	 *
//	 * Results:
//	 *    None.
//	 *
//	 * Side effects:
//	 *    Frees up archives loaded into memory.
//	 *
//	 *------------------------------------------------------------------------
//	 */
func XTclZipfsFinalize(tls *libc.TLS) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var hPtr, zf uintptr
	var _ /* zipSearch at bp+0 */ TTcl_HashSearch
	_, _ = hPtr, zf
	_WriteLock(tls)
	if !(_ZipFS.Finitialized != 0) {
		_Unlock(tls)
		return
	}
	hPtr = XTcl_FirstHashEntry(tls, uintptr(unsafe.Pointer(&_ZipFS))+136, bp)
	for {
		if !(hPtr != 0) {
			break
		}
		zf = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		XTcl_DeleteHashEntry(tls, hPtr)
		_CleanupMount(tls, zf) /* Frees file entries belonging to the archive */
		_ZipFSCloseArchive(tls, libc.UintptrFromInt32(0), zf)
		XTclpFree(tls, zf)
		goto _1
	_1:
		;
		hPtr = XTcl_NextHashEntry(tls, bp)
	}
	XTcl_FSUnregister(tls, uintptr(unsafe.Pointer(&_zipfsFilesystem)))
	XTcl_DeleteHashTable(tls, uintptr(unsafe.Pointer(&_ZipFS))+32)
	XTcl_DeleteHashTable(tls, uintptr(unsafe.Pointer(&_ZipFS))+136)
	if _ZipFS.FfallbackEntryEncoding != 0 {
		XTclpFree(tls, _ZipFS.FfallbackEntryEncoding)
		_ZipFS.FfallbackEntryEncoding = libc.UintptrFromInt32(0)
	}
	_ZipFS.Finitialized = 0
	_Unlock(tls)
}

/*
 *-------------------------------------------------------------------------
 *
 * TclZipfs_AppHook --
 *
 *	Performs the argument munging for the shell
 *
 *-------------------------------------------------------------------------
 */

func XTclZipfs_AppHook(tls *libc.TLS, dummy6499 uintptr, argvPtr uintptr) (r uintptr) {
	/* Pointer to argv */
	var _objPtr, _objPtr1, archive, cachePtr, cachePtr1, result, vfsInitScript, v3, v6 uintptr
	var found int32
	var v1, v4 bool
	var v2, v5 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, archive, cachePtr, cachePtr1, found, result, vfsInitScript, v1, v2, v3, v4, v5, v6
	result = XTcl_FindExecutable(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argvPtr)))))
	archive = XTcl_GetNameOfExecutable(tls)
	XTclZipfs_Init(tls, libc.UintptrFromInt32(0))
	/*
	 * Look for init.tcl in one of the locations mounted later in this
	 * function.
	 */
	if !(XTclZipfs_Mount(tls, libc.UintptrFromInt32(0), archive, __ccgo_ts+75237, libc.UintptrFromInt32(0)) != 0) {
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			vfsInitScript = XTclThreadAllocObj(tls)
		} else {
			vfsInitScript = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(vfsInitScript + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(vfsInitScript)).FrefCount = 0
		if libc.Uint64FromInt64(22)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer(vfsInitScript)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(vfsInitScript)).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(vfsInitScript)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(22)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(vfsInitScript)).Fbytes, __ccgo_ts+75250, libc.Uint64FromInt64(22)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(vfsInitScript)).Fbytes + uintptr(libc.Uint64FromInt64(22)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(vfsInitScript)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(22) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer(vfsInitScript)).FtypePtr = libc.UintptrFromInt32(0)
		(*TTcl_Obj)(unsafe.Pointer(vfsInitScript)).FrefCount++
		if XTcl_FSAccess(tls, vfsInitScript, F_OK) == 0 {
			/*
			 * Startup script should be set before calling Tcl_AppInit
			 */
			XTcl_SetStartupScript(tls, vfsInitScript, libc.UintptrFromInt32(0))
		} else {
			_objPtr = vfsInitScript
			v3 = _objPtr
			v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
			*(*TTcl_Size)(unsafe.Pointer(v3))--
			if v2 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
		/*
		 * Set Tcl Encodings
		 */
		if !(_zipfs_literal_tcl_library != 0) {
			if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
				vfsInitScript = XTclThreadAllocObj(tls)
			} else {
				vfsInitScript = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(vfsInitScript + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(vfsInitScript)).FrefCount = 0
			if libc.Uint64FromInt64(34)-libc.Uint64FromInt32(1) == uint64(0) {
				(*TTcl_Obj)(unsafe.Pointer(vfsInitScript)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(vfsInitScript)).Flength = int64(libc.Int32FromInt32(0))
			} else {
				(*TTcl_Obj)(unsafe.Pointer(vfsInitScript)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(34)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
				libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(vfsInitScript)).Fbytes, __ccgo_ts+74455, libc.Uint64FromInt64(34)-libc.Uint64FromInt32(1))
				*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(vfsInitScript)).Fbytes + uintptr(libc.Uint64FromInt64(34)-libc.Uint64FromInt32(1)))) = uint8('\000')
				(*TTcl_Obj)(unsafe.Pointer(vfsInitScript)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(34) - libc.Uint64FromInt32(1))
			}
			(*TTcl_Obj)(unsafe.Pointer(vfsInitScript)).FtypePtr = libc.UintptrFromInt32(0)
			(*TTcl_Obj)(unsafe.Pointer(vfsInitScript)).FrefCount++
			found = XTcl_FSAccess(tls, vfsInitScript, F_OK)
			_objPtr1 = vfsInitScript
			v6 = _objPtr1
			v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
			*(*TTcl_Size)(unsafe.Pointer(v6))--
			if v5 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
			if found == TCL_OK {
				_zipfs_literal_tcl_library = __ccgo_ts + 74489
				return result
			}
		}
	}
	return result
}

/*
 * Values for the flags field in Channel. Any OR'ed combination of the
 * following flags can be stored in the field. These flags record various
 * options and state bits about the channel. In addition to the flags below,
 * the channel can also have TCL_READABLE (1<<1) and TCL_WRITABLE (1<<2) set.
 */

/*
 * The length of time to wait between synthetic timer events. Must be zero or
 * bad things tend to happen.
 */

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * The bits supported for describing the closeMode field of TtyState.
 */

type CloseModeBits = int32

const CLOSE_DEFAULT = 0
const CLOSE_DRAIN = 1
const CLOSE_DISCARD = 2

/*
 * Helper macros to make parts of this file clearer. The macros do exactly
 * what they say on the tin. :-) They also only ever refer to their arguments
 * once, and so can be used without regard to side effects.
 */

/*
 * These structures describe per-instance state of file-based and serial-based
 * channels.
 */

type TFileState = struct {
	Fchannel   TTcl_Channel
	Ffd        int32
	FvalidMask int32
}

type TTtyState = struct {
	FfileState TFileState
}

/*
 * This structure describes the channel type structure for file based IO:
 */

var _fileChannelType = TTcl_ChannelType{
	FtypeName: __ccgo_ts + 5636,
	Fversion:  libc.UintptrFromInt32(0x5),
}

func init() {
	p := unsafe.Pointer(&_fileChannelType)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_FileInputProc)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_FileOutputProc)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(_FileGetOptionProc)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(_FileWatchProc)
	*(*uintptr)(unsafe.Add(p, 72)) = __ccgo_fp(_FileGetHandleProc)
	*(*uintptr)(unsafe.Add(p, 80)) = __ccgo_fp(_FileCloseProc)
	*(*uintptr)(unsafe.Add(p, 88)) = __ccgo_fp(_FileBlockModeProc)
	*(*uintptr)(unsafe.Add(p, 112)) = __ccgo_fp(_FileWideSeekProc)
	*(*uintptr)(unsafe.Add(p, 128)) = __ccgo_fp(_FileTruncateProc)
}

/*
 *----------------------------------------------------------------------
 *
 * FileBlockModeProc --
 *
 *	Helper function to set blocking and nonblocking modes on a file based
 *	channel. Invoked by generic IO level code.
 *
 * Results:
 *	0 if successful, errno when failed.
 *
 * Side effects:
 *	Sets the device into blocking or non-blocking mode.
 *
 *----------------------------------------------------------------------
 */

func _FileBlockModeProc(tls *libc.TLS, instanceData uintptr, mode int32) (r int32) {
	/* The mode to set. Can be TCL_MODE_BLOCKING
	 * or TCL_MODE_NONBLOCKING. */
	var fsPtr uintptr
	_ = fsPtr
	fsPtr = instanceData
	if XTclUnixSetBlockingMode(tls, (*TFileState)(unsafe.Pointer(fsPtr)).Ffd, mode) < 0 {
		return *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))
	}
	return 0
}

/*
 *----------------------------------------------------------------------
 *
 * FileInputProc --
 *
 *	This function is invoked from the generic IO level to read input from
 *	a file based channel.
 *
 * Results:
 *	The number of bytes read is returned or -1 on error. An output
 *	argument contains a POSIX error code if an error occurs, or zero.
 *
 * Side effects:
 *	Reads input from the input device of the channel.
 *
 *----------------------------------------------------------------------
 */

func _FileInputProc(tls *libc.TLS, instanceData uintptr, buf uintptr, toRead int32, errorCodePtr uintptr) (r int32) {
	/* Where to store error code. */
	var bytesRead int32
	var fsPtr uintptr
	_, _ = bytesRead, fsPtr
	fsPtr = instanceData /* How many bytes were actually read from the
	 * input device? */
	*(*int32)(unsafe.Pointer(errorCodePtr)) = 0
	/*
	 * Assume there is always enough input available. This will block
	 * appropriately, and read will unblock as soon as a short read is
	 * possible, if the channel is in blocking mode. If the channel is
	 * nonblocking, the read will never block.
	 */
	for cond := true; cond; cond = bytesRead < 0 && *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(EINTR) {
		bytesRead = int32(libc.Xread(tls, (*TFileState)(unsafe.Pointer(fsPtr)).Ffd, buf, libc.Uint64FromInt32(toRead)))
	}
	if bytesRead < 0 {
		*(*int32)(unsafe.Pointer(errorCodePtr)) = *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))
		return -int32(1)
	}
	return bytesRead
}

/*
 *----------------------------------------------------------------------
 *
 * FileOutputProc--
 *
 *	This function is invoked from the generic IO level to write output to
 *	a file channel.
 *
 * Results:
 *	The number of bytes written is returned or -1 on error. An output
 *	argument contains a POSIX error code if an error occurred, or zero.
 *
 * Side effects:
 *	Writes output on the output device of the channel.
 *
 *----------------------------------------------------------------------
 */

func _FileOutputProc(tls *libc.TLS, instanceData uintptr, buf uintptr, toWrite int32, errorCodePtr uintptr) (r int32) {
	/* Where to store error code. */
	var fsPtr uintptr
	var written int32
	_, _ = fsPtr, written
	fsPtr = instanceData
	*(*int32)(unsafe.Pointer(errorCodePtr)) = 0
	if toWrite == 0 {
		/*
		 * SF Tcl Bug 465765. Do not try to write nothing into a file. STREAM
		 * based implementations will considers this as EOF (if there is a
		 * pipe behind the file).
		 */
		return 0
	}
	written = int32(libc.Xwrite(tls, (*TFileState)(unsafe.Pointer(fsPtr)).Ffd, buf, libc.Uint64FromInt32(toWrite)))
	if written >= 0 {
		return written
	}
	*(*int32)(unsafe.Pointer(errorCodePtr)) = *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))
	return -int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * FileCloseProc, TtyCloseProc --
 *
 *	These functions are called from the generic IO level to perform
 *	channel-type-specific cleanup when a file- or tty-based channel is
 *	closed.
 *
 * Results:
 *	0 if successful, errno if failed.
 *
 * Side effects:
 *	Closes the device of the channel.
 *
 *----------------------------------------------------------------------
 */

func _FileCloseProc(tls *libc.TLS, instanceData uintptr, dummy360 uintptr, flags int32) (r int32) {
	var errorCode int32
	var fsPtr uintptr
	_, _ = errorCode, fsPtr
	fsPtr = instanceData
	errorCode = 0
	if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
		return int32(EINVAL)
	}
	XTcl_DeleteFileHandler(tls, (*TFileState)(unsafe.Pointer(fsPtr)).Ffd)
	/*
	 * Do not close standard channels while in thread-exit.
	 */
	if !(XTclInThreadExit(tls) != 0) || (*TFileState)(unsafe.Pointer(fsPtr)).Ffd != 0 && (*TFileState)(unsafe.Pointer(fsPtr)).Ffd != int32(1) && (*TFileState)(unsafe.Pointer(fsPtr)).Ffd != int32(2) {
		if libc.Xclose(tls, (*TFileState)(unsafe.Pointer(fsPtr)).Ffd) < 0 {
			errorCode = *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))
		}
	}
	XTclpFree(tls, fsPtr)
	return errorCode
}

/*
 *----------------------------------------------------------------------
 *
 * FileWideSeekProc --
 *
 *	This function is called by the generic IO level to move the access
 *	point in a file based channel, with offsets expressed as wide
 *	integers.
 *
 * Results:
 *	-1 if failed, the new position if successful. An output argument
 *	contains the POSIX error code if an error occurred, or zero.
 *
 * Side effects:
 *	Moves the location at which the channel will be accessed in future
 *	operations.
 *
 *----------------------------------------------------------------------
 */

func _FileWideSeekProc(tls *libc.TLS, instanceData uintptr, offset int64, mode int32, errorCodePtr uintptr) (r int64) {
	/* To store error code. */
	var fsPtr uintptr
	var newLoc int64
	var v1 int32
	_, _, _ = fsPtr, newLoc, v1
	fsPtr = instanceData
	newLoc = int64(libc.Xlseek(tls, (*TFileState)(unsafe.Pointer(fsPtr)).Ffd, offset, mode))
	if newLoc == int64(-int32(1)) {
		v1 = *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))
	} else {
		v1 = 0
	}
	*(*int32)(unsafe.Pointer(errorCodePtr)) = v1
	return newLoc
}

/*
 *----------------------------------------------------------------------
 *
 * FileWatchProc --
 *
 *	Initialize the notifier to watch the fd from this channel.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Sets up the notifier so that a future event on the channel will
 *	be seen by Tcl.
 *
 *----------------------------------------------------------------------
 */

// C documentation
//
//	/*
//	 * Bug ad5a57f2f271: Tcl_NotifyChannel is not a Tcl_FileProc,
//	 * so do not pass it to directly to Tcl_CreateFileHandler.
//	 * Instead, pass a wrapper which is a Tcl_FileProc.
//	 */
func _FileWatchNotifyChannelWrapper(tls *libc.TLS, clientData uintptr, mask int32) {
	var channel TTcl_Channel
	_ = channel
	channel = clientData
	XTcl_NotifyChannel(tls, channel, mask)
}

func _FileWatchProc(tls *libc.TLS, instanceData uintptr, mask int32) {
	/* Events of interest; an OR-ed combination of
	 * TCL_READABLE, TCL_WRITABLE and
	 * TCL_EXCEPTION. */
	var fsPtr uintptr
	_ = fsPtr
	fsPtr = instanceData
	/*
	 * Make sure we only register for events that are valid on this file.
	 */
	mask &= (*TFileState)(unsafe.Pointer(fsPtr)).FvalidMask
	if mask != 0 {
		XTcl_CreateFileHandler(tls, (*TFileState)(unsafe.Pointer(fsPtr)).Ffd, mask, __ccgo_fp(_FileWatchNotifyChannelWrapper), (*TFileState)(unsafe.Pointer(fsPtr)).Fchannel)
	} else {
		XTcl_DeleteFileHandler(tls, (*TFileState)(unsafe.Pointer(fsPtr)).Ffd)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * FileGetHandleProc --
 *
 *	Called from Tcl_GetChannelHandle to retrieve OS handles from a file
 *	based channel.
 *
 * Results:
 *	Returns TCL_OK with the fd in handlePtr, or TCL_ERROR if there is no
 *	handle for the specified direction.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _FileGetHandleProc(tls *libc.TLS, instanceData uintptr, direction int32, handlePtr uintptr) (r int32) {
	/* Where to store the handle. */
	var fsPtr uintptr
	_ = fsPtr
	fsPtr = instanceData
	if direction&(*TFileState)(unsafe.Pointer(fsPtr)).FvalidMask != 0 {
		*(*uintptr)(unsafe.Pointer(handlePtr)) = uintptr(int64((*TFileState)(unsafe.Pointer(fsPtr)).Ffd))
		return TCL_OK
	}
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * FileGetOptionProc --
 *
 *	Gets an option associated with an open file. If the optionName arg is
 *	non-NULL, retrieves the value of that option. If the optionName arg is
 *	NULL, retrieves a list of alternating option names and values for the
 *	given channel.
 *
 * Results:
 *	A standard Tcl result. Also sets the supplied DString to the string
 *	value of the option(s) returned.  Sets error message if needed
 *	(by calling Tcl_BadChannelOption).
 *
 *----------------------------------------------------------------------
 */

func _GetTypeFromMode1(tls *libc.TLS, mode int32) (r uintptr) {
	/*
	 * TODO: deduplicate with tclCmdAH.c
	 */
	if mode&int32(S_IFMT) == int32(S_IFREG) {
		return __ccgo_ts + 5636
	} else {
		if mode&int32(S_IFMT) == int32(S_IFDIR) {
			return __ccgo_ts + 15675
		} else {
			if mode&int32(S_IFMT) == int32(S_IFCHR) {
				return __ccgo_ts + 15685
			} else {
				if mode&int32(S_IFMT) == int32(S_IFBLK) {
					return __ccgo_ts + 15702
				} else {
					if mode&int32(S_IFMT) == int32(S_IFIFO) {
						return __ccgo_ts + 15715
					} else {
						if mode&int32(S_IFMT) == int32(S_IFLNK) {
							return __ccgo_ts + 5730
						} else {
							if mode&int32(S_IFMT) == int32(S_IFSOCK) {
								return __ccgo_ts + 5562
							}
						}
					}
				}
			}
		}
	}
	return __ccgo_ts + 15720
}

func _StatOpenFile(tls *libc.TLS, fsPtr uintptr) (r uintptr) {
	bp := tls.Alloc(144)
	defer tls.Free(144)
	var cachePtr, dictObj uintptr
	var mode uint16
	var v1 bool
	var _ /* statBuf at bp+0 */ TTcl_StatBuf
	_, _, _, _ = cachePtr, dictObj, mode, v1
	if libc.Xfstat(tls, (*TFileState)(unsafe.Pointer(fsPtr)).Ffd, bp) < 0 {
		return libc.UintptrFromInt32(0)
	}
	/*
	 * TODO: merge with TIP 594 implementation (it's silly to have a
	 * duplicate!)
	 */
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		dictObj = XTclThreadAllocObj(tls)
	} else {
		dictObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(dictObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(dictObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(dictObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(dictObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(dictObj)).FtypePtr = libc.UintptrFromInt32(0)
	XTclDictPut(tls, libc.UintptrFromInt32(0), dictObj, __ccgo_ts+15622, XTcl_NewWideIntObj(tls, int64(libc.Int64FromUint64((*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_dev))))
	XTclDictPut(tls, libc.UintptrFromInt32(0), dictObj, __ccgo_ts+15626, XTcl_NewWideIntObj(tls, libc.Int64FromUint64((*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_ino)))
	XTclDictPut(tls, libc.UintptrFromInt32(0), dictObj, __ccgo_ts+15630, XTcl_NewWideIntObj(tls, int64(libc.Int64FromUint64((*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_nlink))))
	XTclDictPut(tls, libc.UintptrFromInt32(0), dictObj, __ccgo_ts+15636, XTcl_NewWideIntObj(tls, int64(libc.Int64FromUint32((*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_uid))))
	XTclDictPut(tls, libc.UintptrFromInt32(0), dictObj, __ccgo_ts+15640, XTcl_NewWideIntObj(tls, int64(libc.Int64FromUint32((*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_gid))))
	XTclDictPut(tls, libc.UintptrFromInt32(0), dictObj, __ccgo_ts+5807, XTcl_NewWideIntObj(tls, (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_size))
	XTclDictPut(tls, libc.UintptrFromInt32(0), dictObj, __ccgo_ts+15644, XTcl_NewWideIntObj(tls, (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_blocks))
	XTclDictPut(tls, libc.UintptrFromInt32(0), dictObj, __ccgo_ts+15651, XTcl_NewWideIntObj(tls, (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_blksize))
	if (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFCHR) || (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFBLK) {
		XTclDictPut(tls, libc.UintptrFromInt32(0), dictObj, __ccgo_ts+15670, XTcl_NewWideIntObj(tls, int64(libc.Int64FromUint64((*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_rdev))))
	}
	XTclDictPut(tls, libc.UintptrFromInt32(0), dictObj, __ccgo_ts+5641, XTcl_NewWideIntObj(tls, XTcl_GetAccessTimeFromStat(tls, bp)))
	XTclDictPut(tls, libc.UintptrFromInt32(0), dictObj, __ccgo_ts+5741, XTcl_NewWideIntObj(tls, XTcl_GetModificationTimeFromStat(tls, bp)))
	XTclDictPut(tls, libc.UintptrFromInt32(0), dictObj, __ccgo_ts+15659, XTcl_NewWideIntObj(tls, XTcl_GetChangeTimeFromStat(tls, bp)))
	mode = uint16((*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_mode)
	XTclDictPut(tls, libc.UintptrFromInt32(0), dictObj, __ccgo_ts+15665, XTcl_NewWideIntObj(tls, libc.Int64FromUint16(mode)))
	XTclDictPut(tls, libc.UintptrFromInt32(0), dictObj, __ccgo_ts+5851, XTcl_NewStringObj(tls, _GetTypeFromMode1(tls, libc.Int32FromUint16(mode)), int64(-int32(1))))
	return dictObj
}

func _FileGetOptionProc(tls *libc.TLS, instanceData uintptr, interp uintptr, optionName uintptr, dsPtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _objPtr, dictContents, dictObj, fsPtr, v1, v3 uintptr
	var len1, valid int32
	var v2 TTcl_Size
	var _ /* dictLength at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _ = _objPtr, dictContents, dictObj, fsPtr, len1, valid, v1, v2, v3
	fsPtr = instanceData
	valid = 0
	if optionName == libc.UintptrFromInt32(0) {
		len1 = 0
		valid = int32(1)
	} else {
		len1 = libc.Int32FromUint64(libc.Xstrlen(tls, optionName))
	}
	/*
	 * Get option -stat
	 * Option is readonly and returned by [fconfigure chan -stat] but not
	 * returned by [fconfigure chan] without explicit option name.
	 */
	if len1 > int32(1) && libc.Xstrncmp(tls, optionName, __ccgo_ts+75272, libc.Uint64FromInt32(len1)) == 0 {
		dictObj = _StatOpenFile(tls, fsPtr)
		if dictObj == libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+75278, libc.VaList(bp+16, XTcl_PosixError(tls, interp))))
			return int32(TCL_ERROR)
		}
		/*
		 * Transfer dictionary to the DString. Note that we don't do this as
		 * an element as this is an option that can't be retrieved with a
		 * general probe.
		 */
		if (*TTcl_Obj)(unsafe.Pointer(dictObj)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(dictObj)).Flength
			v1 = (*TTcl_Obj)(unsafe.Pointer(dictObj)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, dictObj, bp)
		}
		dictContents = v1
		XTcl_DStringAppend(tls, dsPtr, dictContents, *(*TTcl_Size)(unsafe.Pointer(bp)))
		_objPtr = dictObj
		v3 = _objPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		return TCL_OK
	}
	if valid != 0 {
		return TCL_OK
	}
	return XTcl_BadChannelOption(tls, interp, optionName, __ccgo_ts+5812)
}

/*
 *----------------------------------------------------------------------
 *
 * TclpOpenFileChannel --
 *
 *	Open an file based channel on Unix systems.
 *
 * Results:
 *	The new channel or NULL. If NULL, the output argument errorCodePtr is
 *	set to a POSIX error and an error message is left in the interp's
 *	result if interp is not NULL.
 *
 * Side effects:
 *	May open the channel and may cause creation of a file on the file
 *	system.
 *
 *----------------------------------------------------------------------
 */

func XTclpOpenFileChannel(tls *libc.TLS, interp uintptr, pathPtr uintptr, mode int32, permissions int32) (r TTcl_Channel) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* If the open involves creating a file, with
	 * what modes to create it? */
	var channelPermissions, fd int32
	var channelTypePtr, fsPtr, native, translation, v1, v3, v4 uintptr
	var v2 bool
	var _ /* channelName at bp+0 */ [40]uint8
	_, _, _, _, _, _, _, _, _, _ = channelPermissions, channelTypePtr, fd, fsPtr, native, translation, v1, v2, v3, v4
	switch mode & (libc.Int32FromInt32(03) | libc.Int32FromInt32(O_PATH)) {
	case O_RDONLY:
		channelPermissions = libc.Int32FromInt32(1) << libc.Int32FromInt32(1)
	case int32(O_WRONLY):
		channelPermissions = libc.Int32FromInt32(1) << libc.Int32FromInt32(2)
	case int32(O_RDWR):
		channelPermissions = libc.Int32FromInt32(1)<<libc.Int32FromInt32(1) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)
	default:
		/*
		 * This may occurr if modeString was "", for example.
		 */
		XTcl_Panic(tls, __ccgo_ts+75316, 0)
		return libc.UintptrFromInt32(0)
	}
	native = XTcl_FSGetNativePath(tls, pathPtr)
	if native == libc.UintptrFromInt32(0) {
		if interp != libc.UintptrFromInt32(0) {
			/*
			 * We need this just to ensure we return the correct error messages under
			 * some circumstances (relative paths only), so because the normalization
			 * is very expensive, don't invoke it for native or absolute paths.
			 * Note: since paths starting with ~ are absolute, it also considers tilde expansion,
			 * (proper error message of tests *io-40.17 "tilde substitution in open")
			 */
			if v2 = !(XTclFSCwdIsNative(tls) != 0) && XTcl_FSGetPathType(tls, pathPtr) != int32(TCL_PATH_ABSOLUTE); !v2 {
				if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
					v1 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
				} else {
					v1 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
				}
			}
			if (v2 || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) == int32('~')) && XTcl_FSGetNormalizedPath(tls, interp, pathPtr) == libc.UintptrFromInt32(0) {
				return libc.UintptrFromInt32(0)
			}
			if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
				v3 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
			} else {
				v3 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
			}
			XTcl_AppendResult(tls, interp, libc.VaList(bp+48, __ccgo_ts+75356, v3, __ccgo_ts+75372, libc.UintptrFromInt32(0)))
		}
		return libc.UintptrFromInt32(0)
	}
	fd = libc.Xopen(tls, native, mode, libc.VaList(bp+48, permissions))
	if fd < 0 {
		if interp != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
				v4 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
			} else {
				v4 = XTcl_GetStringFromObj(tls, pathPtr, libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+49737, libc.VaList(bp+48, v4, XTcl_PosixError(tls, interp))))
		}
		return libc.UintptrFromInt32(0)
	}
	/*
	 * Set close-on-exec flag on the fd so that child processes will not
	 * inherit this fd.
	 */
	libc.Xfcntl(tls, fd, int32(F_SETFD), libc.VaList(bp+48, int32(FD_CLOEXEC)))
	translation = libc.UintptrFromInt32(0)
	channelTypePtr = uintptr(unsafe.Pointer(&_fileChannelType))
	libc.X__builtin_snprintf(tls, bp, uint64(40), __ccgo_ts+75412, libc.VaList(bp+48, fd))
	fsPtr = XTcl_Alloc(tls, uint64(16))
	(*TTtyState)(unsafe.Pointer(fsPtr)).FfileState.FvalidMask = channelPermissions | libc.Int32FromInt32(1)<<libc.Int32FromInt32(3)
	(*TTtyState)(unsafe.Pointer(fsPtr)).FfileState.Ffd = fd
	(*TTtyState)(unsafe.Pointer(fsPtr)).FfileState.Fchannel = XTcl_CreateChannel(tls, channelTypePtr, bp, fsPtr, channelPermissions)
	if translation != libc.UintptrFromInt32(0) {
		/*
		 * Gotcha. Most modems need a "\r" at the end of the command sequence.
		 * If you just send "at\n", the modem will not respond with "OK"
		 * because it never got a "\r" to actually invoke the command. So, by
		 * default, newlines are translated to "\r\n" on output to avoid "bug"
		 * reports that the serial port isn't working.
		 */
		if XTcl_SetChannelOption(tls, interp, (*TTtyState)(unsafe.Pointer(fsPtr)).FfileState.Fchannel, __ccgo_ts+44736, translation) != TCL_OK {
			XTcl_CloseEx(tls, libc.UintptrFromInt32(0), (*TTtyState)(unsafe.Pointer(fsPtr)).FfileState.Fchannel, 0)
			return libc.UintptrFromInt32(0)
		}
	}
	return (*TTtyState)(unsafe.Pointer(fsPtr)).FfileState.Fchannel
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_MakeFileChannel --
 *
 *	Makes a Tcl_Channel from an existing OS level file handle.
 *
 * Results:
 *	The Tcl_Channel created around the preexisting OS level file handle.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_MakeFileChannel(tls *libc.TLS, handle uintptr, mode int32) (r TTcl_Channel) {
	bp := tls.Alloc(224)
	defer tls.Free(224) /* OR'ed combination of TCL_READABLE and
	 * TCL_WRITABLE to indicate file mode. */
	var channelTypePtr, fsPtr uintptr
	var fd int32
	var _ /* buf at bp+40 */ TTcl_StatBuf
	var _ /* channelName at bp+0 */ [40]uint8
	var _ /* sockaddr at bp+184 */ Tsockaddr
	var _ /* sockaddrLen at bp+200 */ Tsocklen_t
	_, _, _ = channelTypePtr, fd, fsPtr
	fd = int32(int64(handle))
	if mode == 0 {
		return libc.UintptrFromInt32(0)
	}
	if !(libc.Xfstat(tls, fd, bp+40) == 0 && (*(*TTcl_StatBuf)(unsafe.Pointer(bp + 40))).Fst_mode&uint32(S_IFMT) == uint32(S_IFSOCK)) {
		goto _1
	}
	*(*Tsocklen_t)(unsafe.Pointer(bp + 200)) = uint32(16)
	(*(*Tsockaddr)(unsafe.Pointer(bp + 184))).Fsa_family = uint16(PF_UNSPEC)
	if libc.Xgetsockname(tls, fd, bp+184, bp+200) == 0 && *(*Tsocklen_t)(unsafe.Pointer(bp + 200)) > uint32(0) && (libc.Int32FromUint16((*(*Tsockaddr)(unsafe.Pointer(bp + 184))).Fsa_family) == int32(PF_INET) || libc.Int32FromUint16((*(*Tsockaddr)(unsafe.Pointer(bp + 184))).Fsa_family) == int32(PF_INET6)) {
		return XTclpMakeTcpClientChannelMode(tls, uintptr(int64(fd)), mode)
	}
	goto normalChannelAfterAll
	goto _2
_1:
	;
	goto normalChannelAfterAll
normalChannelAfterAll:
	;
	channelTypePtr = uintptr(unsafe.Pointer(&_fileChannelType))
	libc.X__builtin_snprintf(tls, bp, uint64(40), __ccgo_ts+75412, libc.VaList(bp+216, fd))
_2:
	;
	fsPtr = XTcl_Alloc(tls, uint64(16))
	(*TTtyState)(unsafe.Pointer(fsPtr)).FfileState.Ffd = fd
	(*TTtyState)(unsafe.Pointer(fsPtr)).FfileState.FvalidMask = mode | libc.Int32FromInt32(1)<<libc.Int32FromInt32(3)
	(*TTtyState)(unsafe.Pointer(fsPtr)).FfileState.Fchannel = XTcl_CreateChannel(tls, channelTypePtr, bp, fsPtr, mode)
	return (*TTtyState)(unsafe.Pointer(fsPtr)).FfileState.Fchannel
}

/*
 *----------------------------------------------------------------------
 *
 * TclpGetDefaultStdChannel --
 *
 *	Creates channels for standard input, standard output or standard error
 *	output if they do not already exist.
 *
 * Results:
 *	Returns the specified default standard channel, or NULL.
 *
 * Side effects:
 *	May cause the creation of a standard channel and the underlying file.
 *
 *----------------------------------------------------------------------
 */

func XTclpGetDefaultStdChannel(tls *libc.TLS, type1 int32) (r TTcl_Channel) {
	/* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR. */
	var bufMode uintptr
	var channel TTcl_Channel
	var fd, mode int32
	_, _, _, _ = bufMode, channel, fd, mode
	channel = libc.UintptrFromInt32(0)
	fd = 0   /* Initializations needed to prevent */
	mode = 0 /* compiler warning (used before set). */
	bufMode = libc.UintptrFromInt32(0)
	/*
	 * Some #def's to make the code a little clearer!
	 */
	switch type1 {
	case libc.Int32FromInt32(1) << libc.Int32FromInt32(1):
		if libc.Xlseek(tls, 0, 0, int32(1)) == int64(-libc.Int32FromInt32(1)) && *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(EBADF) {
			return libc.UintptrFromInt32(0)
		}
		fd = 0
		mode = libc.Int32FromInt32(1) << libc.Int32FromInt32(1)
		bufMode = __ccgo_ts + 16589
	case libc.Int32FromInt32(1) << libc.Int32FromInt32(2):
		if libc.Xlseek(tls, int32(1), 0, int32(1)) == int64(-libc.Int32FromInt32(1)) && *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(EBADF) {
			return libc.UintptrFromInt32(0)
		}
		fd = int32(1)
		mode = libc.Int32FromInt32(1) << libc.Int32FromInt32(2)
		bufMode = __ccgo_ts + 16589
	case libc.Int32FromInt32(1) << libc.Int32FromInt32(3):
		if libc.Xlseek(tls, int32(2), 0, int32(1)) == int64(-libc.Int32FromInt32(1)) && *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(EBADF) {
			return libc.UintptrFromInt32(0)
		}
		fd = int32(2)
		mode = libc.Int32FromInt32(1) << libc.Int32FromInt32(2)
		bufMode = __ccgo_ts + 44705
	default:
		XTcl_Panic(tls, __ccgo_ts+75419, 0)
		break
	}
	channel = XTcl_MakeFileChannel(tls, uintptr(int64(fd)), mode)
	if channel == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	/*
	 * Set up the normal channel options for stdio handles.
	 */
	if XTcl_GetChannelType(tls, channel) == uintptr(unsafe.Pointer(&_fileChannelType)) {
		XTcl_SetChannelOption(tls, libc.UintptrFromInt32(0), channel, __ccgo_ts+44736, __ccgo_ts+44749)
	} else {
		XTcl_SetChannelOption(tls, libc.UintptrFromInt32(0), channel, __ccgo_ts+44736, __ccgo_ts+75468)
	}
	XTcl_SetChannelOption(tls, libc.UintptrFromInt32(0), channel, __ccgo_ts+44694, bufMode)
	return channel
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetOpenFile --
 *
 *	Given a name of a channel registered in the given interpreter, returns
 *	a FILE * for it.
 *
 * Results:
 *	A standard Tcl result. If the channel is registered in the given
 *	interpreter and it is managed by the "file" channel driver, and it is
 *	open for the requested mode, then the output parameter filePtr is set
 *	to a FILE * for the underlying file. On error, the filePtr is not set,
 *	TCL_ERROR is returned and an error message is left in the interp's
 *	result.
 *
 * Side effects:
 *	May invoke fdopen to create the FILE * for the requested file.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetOpenFile(tls *libc.TLS, interp uintptr, chanID uintptr, forWriting int32, dummy2070 int32, filePtr uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Store pointer to FILE structure here. */
	var chan1 TTcl_Channel
	var chanTypePtr, f, v2 uintptr
	var fd, v1 int32
	var _ /* chanMode at bp+0 */ int32
	var _ /* data at bp+8 */ uintptr
	_, _, _, _, _, _ = chan1, chanTypePtr, f, fd, v1, v2
	chan1 = XTcl_GetChannel(tls, interp, chanID, bp)
	if chan1 == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if forWriting != 0 && !(*(*int32)(unsafe.Pointer(bp))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+75478, libc.VaList(bp+24, chanID)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+43147, __ccgo_ts+75509, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	} else {
		if !(forWriting != 0) && !(*(*int32)(unsafe.Pointer(bp))&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0) {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+75522, libc.VaList(bp+24, chanID)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+43147, __ccgo_ts+75553, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
	}
	/*
	 * We allow creating a FILE * out of file based, pipe based and socket
	 * based channels. We currently do not allow any other channel types,
	 * because it is likely that stdio will not know what to do with them.
	 */
	chanTypePtr = XTcl_GetChannelType(tls, chan1)
	if chanTypePtr == uintptr(unsafe.Pointer(&_fileChannelType)) || libc.Xstrcmp(tls, (*TTcl_ChannelType)(unsafe.Pointer(chanTypePtr)).FtypeName, __ccgo_ts+45209) == 0 || libc.Xstrcmp(tls, (*TTcl_ChannelType)(unsafe.Pointer(chanTypePtr)).FtypeName, __ccgo_ts+47057) == 0 {
		if forWriting != 0 {
			v1 = libc.Int32FromInt32(1) << libc.Int32FromInt32(2)
		} else {
			v1 = libc.Int32FromInt32(1) << libc.Int32FromInt32(1)
		}
		if XTcl_GetChannelHandle(tls, chan1, v1, bp+8) == TCL_OK {
			fd = int32(int64(*(*uintptr)(unsafe.Pointer(bp + 8))))
			/*
			 * The call to fdopen below is probably dangerous, since it will
			 * truncate an existing file if the file is being opened for
			 * writing....
			 */
			if forWriting != 0 {
				v2 = __ccgo_ts + 25887
			} else {
				v2 = __ccgo_ts + 25877
			}
			f = libc.Xfdopen(tls, fd, v2)
			if f == libc.UintptrFromInt32(0) {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+75566, libc.VaList(bp+24, chanID)))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+43147, __ccgo_ts+75595, libc.UintptrFromInt32(0)))
				return int32(TCL_ERROR)
			}
			*(*uintptr)(unsafe.Pointer(filePtr)) = f
			return TCL_OK
		}
	}
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+75608, libc.VaList(bp+24, chanID)))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+43147, __ccgo_ts+75644, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * FileTruncateProc --
 *
 *	Truncates a file to a given length.
 *
 * Results:
 *	0 if the operation succeeded, and -1 if it failed (in which case
 *	*errorCodePtr will be set to errno).
 *
 * Side effects:
 *	The underlying file is potentially truncated. This can have a wide
 *	variety of side effects, including moving file pointers that point at
 *	places later in the file than the truncate point.
 *
 *----------------------------------------------------------------------
 */

func _FileTruncateProc(tls *libc.TLS, instanceData uintptr, length int64) (r int32) {
	var fsPtr uintptr
	var result int32
	_, _ = fsPtr, result
	fsPtr = instanceData
	result = libc.Xftruncate(tls, (*TFileState)(unsafe.Pointer(fsPtr)).Ffd, length)
	if result != 0 {
		return *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))
	}
	return 0
}

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 *----------------------------------------------------------------------
 *
 * Tcl_Sleep --
 *
 *	Delay execution for the specified number of milliseconds.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Time passes.
 *
 *----------------------------------------------------------------------
 */

func XTcl_Sleep(tls *libc.TLS, ms int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Number of milliseconds to sleep. */
	var after TTcl_Time
	var v1 uintptr
	var _ /* before at bp+16 */ TTcl_Time
	var _ /* delay at bp+0 */ Ttimeval
	var _ /* vdelay at bp+32 */ TTcl_Time
	_, _ = after, v1
	/*
	 * The only trick here is that select appears to return early under some
	 * conditions, so we have to check to make sure that the right amount of
	 * time really has elapsed.  If it's too early, go back to sleep again.
	 */
	XTcl_GetTime(tls, bp+16)
	after = *(*TTcl_Time)(unsafe.Pointer(bp + 16))
	after.Fsec += int64(ms / int32(1000))
	after.Fusec += int64(ms % int32(1000) * int32(1000))
	if after.Fusec > int64(1000000) {
		after.Fusec -= int64(1000000)
		after.Fsec += int64(1)
	}
	for int32(1) != 0 {
		/*
		 * TIP #233: Scale from virtual time to real-time for select.
		 */
		(*(*TTcl_Time)(unsafe.Pointer(bp + 32))).Fsec = after.Fsec - (*(*TTcl_Time)(unsafe.Pointer(bp + 16))).Fsec
		(*(*TTcl_Time)(unsafe.Pointer(bp + 32))).Fusec = after.Fusec - (*(*TTcl_Time)(unsafe.Pointer(bp + 16))).Fusec
		if (*(*TTcl_Time)(unsafe.Pointer(bp + 32))).Fusec < 0 {
			(*(*TTcl_Time)(unsafe.Pointer(bp + 32))).Fusec += int64(1000000)
			(*(*TTcl_Time)(unsafe.Pointer(bp + 32))).Fsec -= int64(1)
		}
		if (*(*TTcl_Time)(unsafe.Pointer(bp + 32))).Fsec != 0 || (*(*TTcl_Time)(unsafe.Pointer(bp + 32))).Fusec != 0 {
			v1 = bp + 32
			if v1 != libc.UintptrFromInt32(0) {
				(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{XtclScaleTimeProcPtr})))(tls, v1, XtclTimeClientData)
			}
		}
		(*(*Ttimeval)(unsafe.Pointer(bp))).Ftv_sec = (*(*TTcl_Time)(unsafe.Pointer(bp + 32))).Fsec
		(*(*Ttimeval)(unsafe.Pointer(bp))).Ftv_usec = (*(*TTcl_Time)(unsafe.Pointer(bp + 32))).Fusec
		/*
		 * Special note: must convert delay.tv_sec to int before comparing to
		 * zero, since delay.tv_usec is unsigned on some platforms.
		 */
		if int32((*(*Ttimeval)(unsafe.Pointer(bp))).Ftv_sec) < 0 || (*(*Ttimeval)(unsafe.Pointer(bp))).Ftv_usec == 0 && (*(*Ttimeval)(unsafe.Pointer(bp))).Ftv_sec == 0 {
			break
		}
		libc.Xselect(tls, 0, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), bp)
		XTcl_GetTime(tls, bp+16)
	}
}

const DEFAULT_COPY_BLOCK_SIZE = 4096
const DEFAULT_TEMP_DIR_PREFIX = "tcl"
const DOTREE_F = 3
const DOTREE_POSTD = 2
const DOTREE_PRED = 1
const MAX_READDIR_UNLINK_THRESHOLD = 130
const Realpath = 0
const TCL_TEMPORARY_FILE_DIRECTORY = "/tmp"
const haveRealpath = 1

const UNIX_GROUP_ATTRIBUTE = 0
const UNIX_OWNER_ATTRIBUTE = 1
const UNIX_PERMISSIONS_ATTRIBUTE = 2
const UNIX_INVALID_ATTRIBUTE = 3

func init() {
	p := unsafe.Pointer(&XtclpFileAttrProcs)
	*(*uintptr)(unsafe.Add(p, 0)) = __ccgo_fp(_GetGroupAttribute)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_SetGroupAttribute)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_GetOwnerAttribute)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_SetOwnerAttribute)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_GetPermissionsAttribute)
	*(*uintptr)(unsafe.Add(p, 40)) = __ccgo_fp(_SetPermissionsAttribute)
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpObjRenameFile, DoRenameFile --
 *
 *	Changes the name of an existing file or directory, from src to dst. If
 *	src and dst refer to the same file or directory, does nothing and
 *	returns success. Otherwise if dst already exists, it will be deleted
 *	and replaced by src subject to the following conditions:
 *	    If src is a directory, dst may be an empty directory.
 *	    If src is a file, dst may be a file.
 *	In any other situation where dst already exists, the rename will fail.
 *
 * Results:
 *	If the directory was successfully created, returns TCL_OK. Otherwise
 *	the return value is TCL_ERROR and errno is set to indicate the error.
 *	Some possible values for errno are:
 *
 *	EACCES:	    src or dst parent directory can't be read and/or written.
 *	EEXIST:	    dst is a non-empty directory.
 *	EINVAL:	    src is a root directory or dst is a subdirectory of src.
 *	EISDIR:	    dst is a directory, but src is not.
 *	ENOENT:	    src doesn't exist, or src or dst is "".
 *	ENOTDIR:    src is a directory, but dst is not.
 *	EXDEV:	    src and dst are on different filesystems.
 *
 * Side effects:
 *	The implementation of rename may allow cross-filesystem renames, but
 *	the caller should be prepared to emulate it with copy and delete if
 *	errno is EXDEV.
 *
 *---------------------------------------------------------------------------
 */

func XTclpObjRenameFile(tls *libc.TLS, srcPathPtr uintptr, destPathPtr uintptr) (r int32) {
	return _DoRenameFile(tls, XTcl_FSGetNativePath(tls, srcPathPtr), XTcl_FSGetNativePath(tls, destPathPtr))
}

func _DoRenameFile(tls *libc.TLS, src uintptr, dst uintptr) (r int32) {
	bp := tls.Alloc(8192)
	defer tls.Free(8192) /* New pathname of file or directory
	 * (native). */
	var dirEntPtr, dirPtr uintptr
	var _ /* dstPath at bp+4096 */ [4096]uint8
	var _ /* srcPath at bp+0 */ [4096]uint8
	_, _ = dirEntPtr, dirPtr
	if libc.Xrename(tls, src, dst) == 0 { /* INTL: Native. */
		return TCL_OK
	}
	if *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(ENOTEMPTY) {
		*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = int32(EEXIST)
	}
	/*
	 * IRIX returns EIO when you attempt to move a directory into itself. We
	 * just map EIO to EINVAL get the right message on SGI. Most platforms
	 * don't return EIO except in really strange cases.
	 */
	if *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(EIO) {
		*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = int32(EINVAL)
	}
	/*
	 * SunOS 4.1.4 reports overwriting a non-empty directory with a directory
	 * as EINVAL instead of EEXIST (first rule out the correct EINVAL result
	 * code for moving a directory into itself). Must be conditionally
	 * compiled because realpath() not defined on all systems.
	 */
	if *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(EINVAL) && libc.Bool(int32(haveRealpath) != 0) {
		if libc.Xrealpath(tls, src, bp) != libc.UintptrFromInt32(0) && libc.Xrealpath(tls, dst, bp+4096) != libc.UintptrFromInt32(0) && libc.Xstrncmp(tls, bp, bp+4096, libc.Xstrlen(tls, bp)) != 0 {
			dirPtr = libc.Xopendir(tls, dst) /* INTL: Native. */
			if dirPtr != libc.UintptrFromInt32(0) {
				for int32(1) != 0 {
					dirEntPtr = libc.Xreaddir(tls, dirPtr) /* INTL: Native. */
					if dirEntPtr == libc.UintptrFromInt32(0) {
						break
					}
					if libc.Xstrcmp(tls, dirEntPtr+19, __ccgo_ts+35293) != 0 && libc.Xstrcmp(tls, dirEntPtr+19, __ccgo_ts+15981) != 0 {
						*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = int32(EEXIST)
						libc.Xclosedir(tls, dirPtr)
						return int32(TCL_ERROR)
					}
				}
				libc.Xclosedir(tls, dirPtr)
			}
		}
		*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = int32(EINVAL)
	}
	if libc.Xstrcmp(tls, src, __ccgo_ts+6339) == 0 {
		/*
		 * Alpha reports renaming / as EBUSY and Linux reports it as EACCES,
		 * instead of EINVAL.
		 */
		*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = int32(EINVAL)
	}
	/*
	 * DEC Alpha OSF1 V3.0 returns EACCES when attempting to move a file
	 * across filesystems and the parent directory of that file is not
	 * writable. Most other systems return EXDEV. Does nothing to correct this
	 * behavior.
	 */
	return int32(TCL_ERROR)
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpObjCopyFile, DoCopyFile --
 *
 *	Copy a single file (not a directory). If dst already exists and is not
 *	a directory, it is removed.
 *
 * Results:
 *	If the file was successfully copied, returns TCL_OK. Otherwise the
 *	return value is TCL_ERROR and errno is set to indicate the error. Some
 *	possible values for errno are:
 *
 *	EACCES:	    src or dst parent directory can't be read and/or written.
 *	EISDIR:	    src or dst is a directory.
 *	ENOENT:	    src doesn't exist. src or dst is "".
 *
 * Side effects:
 *	This procedure will also copy symbolic links, block, and character
 *	devices, and fifos. For symbolic links, the links themselves will be
 *	copied and not what they point to. For the other special file types,
 *	the directory entry will be copied and not the contents of the device
 *	that it refers to.
 *
 *---------------------------------------------------------------------------
 */

func XTclpObjCopyFile(tls *libc.TLS, srcPathPtr uintptr, destPathPtr uintptr) (r int32) {
	bp := tls.Alloc(144)
	defer tls.Free(144)
	var src uintptr
	var _ /* srcStatBuf at bp+0 */ TTcl_StatBuf
	_ = src
	src = XTcl_FSGetNativePath(tls, srcPathPtr)
	if libc.Xlstat(tls, src, bp) != 0 { /* INTL: Native. */
		return int32(TCL_ERROR)
	}
	return _DoCopyFile(tls, src, XTcl_FSGetNativePath(tls, destPathPtr), bp)
}

func _DoCopyFile(tls *libc.TLS, src uintptr, dst uintptr, statBufPtr uintptr) (r int32) {
	bp := tls.Alloc(4256)
	defer tls.Free(4256)
	/* Used to determine filetype. */
	var length int32
	var _ /* dstStatBuf at bp+0 */ TTcl_StatBuf
	var _ /* linkBuf at bp+144 */ [4097]uint8
	_ = length
	if (*TTcl_StatBuf)(unsafe.Pointer(statBufPtr)).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) {
		*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = int32(EISDIR)
		return int32(TCL_ERROR)
	}
	/*
	 * Symlink, and some of the other calls will fail if the target exists, so
	 * we remove it first.
	 */
	if libc.Xlstat(tls, dst, bp) == 0 { /* INTL: Native. */
		if (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) {
			*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = int32(EISDIR)
			return int32(TCL_ERROR)
		}
	}
	if libc.Xunlink(tls, dst) != 0 { /* INTL: Native. */
		if *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) != int32(ENOENT) {
			return int32(TCL_ERROR)
		}
	}
	switch libc.Int32FromUint32((*TTcl_StatBuf)(unsafe.Pointer(statBufPtr)).Fst_mode & libc.Uint32FromInt32(S_IFMT)) {
	case int32(S_IFLNK):
		length = int32(libc.Xreadlink(tls, src, bp+144, uint64(MAXPATHLEN))) /* INTL: Native. */
		if length == -int32(1) {
			return int32(TCL_ERROR)
		}
		(*(*[4097]uint8)(unsafe.Pointer(bp + 144)))[length] = uint8('\000')
		if libc.Xsymlink(tls, bp+144, dst) < 0 { /* INTL: Native. */
			return int32(TCL_ERROR)
		}
	case int32(S_IFBLK):
		fallthrough
	case int32(S_IFCHR):
		if libc.Xmknod(tls, dst, (*TTcl_StatBuf)(unsafe.Pointer(statBufPtr)).Fst_mode, (*TTcl_StatBuf)(unsafe.Pointer(statBufPtr)).Fst_rdev) < 0 {
			return int32(TCL_ERROR)
		}
		return _CopyFileAtts(tls, src, dst, statBufPtr)
	case int32(S_IFIFO):
		if libc.Xmkfifo(tls, dst, (*TTcl_StatBuf)(unsafe.Pointer(statBufPtr)).Fst_mode) < 0 { /* INTL: Native. */
			return int32(TCL_ERROR)
		}
		return _CopyFileAtts(tls, src, dst, statBufPtr)
	default:
		return XTclUnixCopyFile(tls, src, dst, statBufPtr, 0)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclUnixCopyFile -
 *
 *	Helper function for TclpCopyFile. Copies one regular file, using
 *	read() and write().
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	A file is copied. Dst will be overwritten if it exists.
 *
 *----------------------------------------------------------------------
 */

func XTclUnixCopyFile(tls *libc.TLS, src uintptr, dst uintptr, statBufPtr uintptr, dontCopyAtts int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* If flag set, don't copy attributes. */
	var blockSize Tsize_t
	var buffer uintptr
	var dstFd, srcFd, v1 int32
	var nread Tssize_t
	_, _, _, _, _, _ = blockSize, buffer, dstFd, nread, srcFd, v1
	v1 = libc.Xopen(tls, src, O_RDONLY, libc.VaList(bp+8, 0))
	srcFd = v1
	if v1 < 0 { /* INTL: Native */
		return int32(TCL_ERROR)
	}
	dstFd = libc.Xopen(tls, dst, libc.Int32FromInt32(O_CREAT)|libc.Int32FromInt32(O_TRUNC)|libc.Int32FromInt32(O_WRONLY), libc.VaList(bp+8, (*TTcl_StatBuf)(unsafe.Pointer(statBufPtr)).Fst_mode))
	if dstFd < 0 {
		libc.Xclose(tls, srcFd)
		return int32(TCL_ERROR)
	}
	/*
	 * Try to work out the best size of buffer to use for copying. If we
	 * can't, it's no big deal as we can just use a (32-bit) page, since
	 * that's likely to be fairly efficient anyway.
	 */
	blockSize = libc.Uint64FromInt64((*TTcl_StatBuf)(unsafe.Pointer(statBufPtr)).Fst_blksize)
	/*
	 * [SF Tcl Bug 1586470] Even if we HAVE_STRUCT_STAT_ST_BLKSIZE, there are
	 * filesystems which report a bogus value for the blocksize. An example
	 * is the Andrew Filesystem (afs), reporting a blocksize of 0. When
	 * detecting such a situation we now simply fall back to a hardwired
	 * default size.
	 */
	if blockSize <= uint64(0) {
		blockSize = uint64(DEFAULT_COPY_BLOCK_SIZE)
	}
	buffer = XTcl_Alloc(tls, blockSize)
	for int32(1) != 0 {
		nread = libc.Xread(tls, srcFd, buffer, blockSize)
		if nread == int64(-int32(1)) || nread == 0 {
			break
		}
		if libc.Xwrite(tls, dstFd, buffer, libc.Uint64FromInt64(nread)) != nread {
			nread = int64(-int32(1))
			break
		}
	}
	XTclpFree(tls, buffer)
	libc.Xclose(tls, srcFd)
	if libc.Xclose(tls, dstFd) != 0 || nread == int64(-int32(1)) {
		libc.Xunlink(tls, dst) /* INTL: Native. */
		return int32(TCL_ERROR)
	}
	if !(dontCopyAtts != 0) && _CopyFileAtts(tls, src, dst, statBufPtr) == int32(TCL_ERROR) {
		/*
		 * The copy succeeded, but setting the permissions failed, so be in a
		 * consistent state, we remove the file that was created by the copy.
		 */
		libc.Xunlink(tls, dst) /* INTL: Native. */
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpObjDeleteFile, TclpDeleteFile --
 *
 *	Removes a single file (not a directory).
 *
 * Results:
 *	If the file was successfully deleted, returns TCL_OK. Otherwise the
 *	return value is TCL_ERROR and errno is set to indicate the error. Some
 *	possible values for errno are:
 *
 *	EACCES:	    a parent directory can't be read and/or written.
 *	EISDIR:	    path is a directory.
 *	ENOENT:	    path doesn't exist or is "".
 *
 * Side effects:
 *	The file is deleted, even if it is read-only.
 *
 *---------------------------------------------------------------------------
 */

func XTclpObjDeleteFile(tls *libc.TLS, pathPtr uintptr) (r int32) {
	return XTclpDeleteFile(tls, XTcl_FSGetNativePath(tls, pathPtr))
}

func XTclpDeleteFile(tls *libc.TLS, path uintptr) (r int32) {
	/* Pathname of file to be removed (native). */
	if libc.Xunlink(tls, path) != 0 {
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpCreateDirectory, DoCreateDirectory --
 *
 *	Creates the specified directory. All parent directories of the
 *	specified directory must already exist. The directory is automatically
 *	created with permissions so that user can access the new directory and
 *	create new files or subdirectories in it.
 *
 * Results:
 *	If the directory was successfully created, returns TCL_OK. Otherwise
 *	the return value is TCL_ERROR and errno is set to indicate the error.
 *	Some possible values for errno are:
 *
 *	EACCES:	    a parent directory can't be read and/or written.
 *	EEXIST:	    path already exists.
 *	ENOENT:	    a parent directory doesn't exist.
 *
 * Side effects:
 *	A directory is created with the current umask, except that permission
 *	for u+rwx will always be added.
 *
 *---------------------------------------------------------------------------
 */

func XTclpObjCreateDirectory(tls *libc.TLS, pathPtr uintptr) (r int32) {
	return _DoCreateDirectory(tls, XTcl_FSGetNativePath(tls, pathPtr))
}

func _DoCreateDirectory(tls *libc.TLS, path uintptr) (r int32) {
	/* Pathname of directory to create (native). */
	var mode Tmode_t
	_ = mode
	mode = libc.Xumask(tls, uint32(0))
	libc.Xumask(tls, mode)
	/*
	 * umask return value is actually the inverse of the permissions.
	 */
	mode = uint32(0777) & ^mode | uint32(S_IRUSR) | uint32(S_IWUSR) | uint32(S_IXUSR)
	if libc.Xmkdir(tls, path, mode) != 0 { /* INTL: Native. */
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpObjCopyDirectory --
 *
 *	Recursively copies a directory. The target directory dst must not
 *	already exist. Note that this function does not merge two directory
 *	hierarchies, even if the target directory is an empty directory.
 *
 * Results:
 *	If the directory was successfully copied, returns TCL_OK. Otherwise
 *	the return value is TCL_ERROR, errno is set to indicate the error, and
 *	the pathname of the file that caused the error is stored in errorPtr.
 *	See TclpObjCreateDirectory and TclpObjCopyFile for a description of
 *	possible values for errno.
 *
 * Side effects:
 *	An exact copy of the directory hierarchy src will be created with the
 *	name dst. If an error occurs, the error will be returned immediately,
 *	and remaining files will not be processed.
 *
 *---------------------------------------------------------------------------
 */

func XTclpObjCopyDirectory(tls *libc.TLS, srcPathPtr uintptr, destPathPtr uintptr, errorPtr uintptr) (r int32) {
	bp := tls.Alloc(672)
	defer tls.Free(672)
	var _objPtr, _objPtr1, transPtr, v1, v2, v4, v5, v6, v8 uintptr
	var ret int32
	var v3, v7 TTcl_Size
	var _ /* ds at bp+0 */ TTcl_DString
	var _ /* dstString at bp+448 */ TTcl_DString
	var _ /* srcString at bp+224 */ TTcl_DString
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, ret, transPtr, v1, v2, v3, v4, v5, v6, v7, v8
	transPtr = XTcl_FSGetTranslatedPath(tls, libc.UintptrFromInt32(0), srcPathPtr)
	if transPtr != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(transPtr)).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(transPtr)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, transPtr, libc.UintptrFromInt32(0))
		}
		v1 = v2
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	ret = XTcl_UtfToExternalDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), v1, int64(-int32(1)), 0, bp+224, libc.UintptrFromInt32(0))
	if transPtr != libc.UintptrFromInt32(0) {
		_objPtr = transPtr
		v4 = _objPtr
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	if ret != TCL_OK {
		*(*uintptr)(unsafe.Pointer(errorPtr)) = srcPathPtr
	} else {
		transPtr = XTcl_FSGetTranslatedPath(tls, libc.UintptrFromInt32(0), destPathPtr)
		if transPtr != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(transPtr)).Fbytes != 0 {
				v6 = (*TTcl_Obj)(unsafe.Pointer(transPtr)).Fbytes
			} else {
				v6 = XTcl_GetStringFromObj(tls, transPtr, libc.UintptrFromInt32(0))
			}
			v5 = v6
		} else {
			v5 = libc.UintptrFromInt32(0)
		}
		ret = XTcl_UtfToExternalDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), v5, int64(-int32(1)), int32(TCL_ENCODING_PROFILE_TCL8), bp+448, libc.UintptrFromInt32(0))
		if transPtr != libc.UintptrFromInt32(0) {
			_objPtr1 = transPtr
			v8 = _objPtr1
			v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
			*(*TTcl_Size)(unsafe.Pointer(v8))--
			if v7 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
		}
		if ret != TCL_OK {
			*(*uintptr)(unsafe.Pointer(errorPtr)) = destPathPtr
		} else {
			ret = _TraverseUnixTree(tls, __ccgo_fp(_TraversalCopy), bp+224, bp+448, bp, 0)
			/* Note above call only sets ds on error */
			if ret != TCL_OK {
				*(*uintptr)(unsafe.Pointer(errorPtr)) = XTcl_DStringToObj(tls, bp)
			}
			XTcl_DStringFree(tls, bp+448)
		}
		XTcl_DStringFree(tls, bp+224)
	}
	if ret != TCL_OK {
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(errorPtr)))).FrefCount++
	}
	return ret
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpRemoveDirectory, DoRemoveDirectory --
 *
 *	Removes directory (and its contents, if the recursive flag is set).
 *
 * Results:
 *	If the directory was successfully removed, returns TCL_OK. Otherwise
 *	the return value is TCL_ERROR, errno is set to indicate the error, and
 *	the pathname of the file that caused the error is stored in errorPtr.
 *	Some possible values for errno are:
 *
 *	EACCES:	    path directory can't be read and/or written.
 *	EEXIST:	    path is a non-empty directory.
 *	EINVAL:	    path is a root directory.
 *	ENOENT:	    path doesn't exist or is "".
 *	ENOTDIR:    path is not a directory.
 *
 * Side effects:
 *	Directory removed. If an error occurs, the error will be returned
 *	immediately, and remaining files will not be deleted.
 *
 *---------------------------------------------------------------------------
 */

func XTclpObjRemoveDirectory(tls *libc.TLS, pathPtr uintptr, recursive int32, errorPtr uintptr) (r int32) {
	bp := tls.Alloc(448)
	defer tls.Free(448)
	var _objPtr, transPtr, v1, v2, v4 uintptr
	var ret int32
	var v3 TTcl_Size
	var _ /* ds at bp+0 */ TTcl_DString
	var _ /* pathString at bp+224 */ TTcl_DString
	_, _, _, _, _, _, _ = _objPtr, ret, transPtr, v1, v2, v3, v4
	transPtr = XTcl_FSGetTranslatedPath(tls, libc.UintptrFromInt32(0), pathPtr)
	if transPtr != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(transPtr)).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(transPtr)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, transPtr, libc.UintptrFromInt32(0))
		}
		v1 = v2
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	ret = XTcl_UtfToExternalDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), v1, int64(-int32(1)), int32(TCL_ENCODING_PROFILE_TCL8), bp+224, libc.UintptrFromInt32(0))
	if transPtr != libc.UintptrFromInt32(0) {
		_objPtr = transPtr
		v4 = _objPtr
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	if ret != TCL_OK {
		*(*uintptr)(unsafe.Pointer(errorPtr)) = pathPtr
	} else {
		ret = _DoRemoveDirectory(tls, bp+224, recursive, bp)
		XTcl_DStringFree(tls, bp+224)
		/* Note above call only sets ds on error */
		if ret != TCL_OK {
			*(*uintptr)(unsafe.Pointer(errorPtr)) = XTcl_DStringToObj(tls, bp)
		}
	}
	if ret != TCL_OK {
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(errorPtr)))).FrefCount++
	}
	return ret
}

func _DoRemoveDirectory(tls *libc.TLS, pathPtr uintptr, recursive int32, errorPtr uintptr) (r int32) {
	bp := tls.Alloc(144)
	defer tls.Free(144) /* If non-NULL, uninitialized or free DString
	 * filled with UTF-8 name of file causing
	 * error. */
	var newPerm, result int32
	var oldPerm Tmode_t
	var path uintptr
	var _ /* statBuf at bp+0 */ TTcl_StatBuf
	_, _, _, _ = newPerm, oldPerm, path, result
	oldPerm = uint32(0)
	path = (*TTcl_DString)(unsafe.Pointer(pathPtr)).Fstring1
	if recursive != 0 {
		if libc.Xstat(tls, path, bp) == 0 {
			oldPerm = (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_mode & libc.Uint32FromInt32(0x00007FFF)
		}
		newPerm = libc.Int32FromUint32(oldPerm | libc.Uint32FromInt32(libc.Int32FromInt32(64)+libc.Int32FromInt32(128)+libc.Int32FromInt32(256)))
		libc.Xchmod(tls, path, libc.Uint32FromInt32(newPerm))
	}
	if libc.Xrmdir(tls, path) == 0 { /* INTL: Native. */
		return TCL_OK
	}
	if *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(ENOTEMPTY) {
		*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = int32(EEXIST)
	}
	result = TCL_OK
	if *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) != int32(EEXIST) || recursive == 0 {
		if errorPtr != libc.UintptrFromInt32(0) {
			XTcl_ExternalToUtfDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), path, int64(-libc.Int32FromInt32(1)), 0, errorPtr, libc.UintptrFromInt32(0))
		}
		result = int32(TCL_ERROR)
	}
	/*
	 * The directory is nonempty, but the recursive flag has been specified,
	 * so we recursively remove all the files in the directory.
	 */
	if result == TCL_OK {
		result = _TraverseUnixTree(tls, __ccgo_fp(_TraversalDelete), pathPtr, libc.UintptrFromInt32(0), errorPtr, int32(1))
	}
	if result != TCL_OK && recursive != 0 {
		/*
		 * Try to restore permissions.
		 */
		libc.Xchmod(tls, path, oldPerm)
	}
	return result
}

/*
 *---------------------------------------------------------------------------
 *
 * TraverseUnixTree --
 *
 *	Traverse directory tree specified by sourcePtr, calling the function
 *	traverseProc for each file and directory encountered. If destPtr is
 *	non-null, each of name in the sourcePtr directory is appended to the
 *	directory specified by destPtr and passed as the second argument to
 *	traverseProc().
 *
 * Results:
 *	Standard Tcl result.
 *
 * Side effects:
 *	None caused by TraverseUnixTree, however the user specified
 *	traverseProc() may change state. If an error occurs, the error will be
 *	returned immediately, and remaining files will not be processed.
 *
 *---------------------------------------------------------------------------
 */

func _TraverseUnixTree(tls *libc.TLS, traverseProc uintptr, sourcePtr uintptr, targetPtr uintptr, errorPtr uintptr, doRewind int32) (r int32) {
	bp := tls.Alloc(144)
	defer tls.Free(144) /* Flag indicating that to ensure complete
	 * traversal of source hierarchy, the readdir
	 * loop should be rewound whenever
	 * traverseProc has returned TCL_OK; this is
	 * required when traverseProc modifies the
	 * source hierarchy, e.g. by deleting
	 * files. */
	var dirEntPtr, dirPtr, errfile, source, v1 uintptr
	var numProcessed, result int32
	var sourceLen, targetLen Tsize_t
	var _ /* statBuf at bp+0 */ TTcl_StatBuf
	_, _, _, _, _, _, _, _, _ = dirEntPtr, dirPtr, errfile, numProcessed, result, source, sourceLen, targetLen, v1
	numProcessed = 0
	errfile = libc.UintptrFromInt32(0)
	result = TCL_OK
	targetLen = uint64(0)
	source = (*TTcl_DString)(unsafe.Pointer(sourcePtr)).Fstring1
	if libc.Xlstat(tls, source, bp) != 0 { /* INTL: Native. */
		errfile = source
		goto end
	}
	if !((*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_mode&libc.Uint32FromInt32(S_IFMT) == libc.Uint32FromInt32(S_IFDIR)) {
		/*
		 * Process the regular file
		 */
		return (*(*func(*libc.TLS, uintptr, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{traverseProc})))(tls, sourcePtr, targetPtr, bp, int32(DOTREE_F), errorPtr)
	}
	dirPtr = libc.Xopendir(tls, source) /* INTL: Native. */
	if dirPtr == libc.UintptrFromInt32(0) {
		/*
		 * Can't read directory
		 */
		errfile = source
		goto end
	}
	result = (*(*func(*libc.TLS, uintptr, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{traverseProc})))(tls, sourcePtr, targetPtr, bp, int32(DOTREE_PRED), errorPtr)
	if result != TCL_OK {
		libc.Xclosedir(tls, dirPtr)
		return result
	}
	XTcl_DStringAppend(tls, sourcePtr, __ccgo_ts+6339, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))
	sourceLen = libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(sourcePtr)).Flength)
	if targetPtr != libc.UintptrFromInt32(0) {
		XTcl_DStringAppend(tls, targetPtr, __ccgo_ts+6339, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))
		targetLen = libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(targetPtr)).Flength)
	}
	for {
		v1 = libc.Xreaddir(tls, dirPtr)
		dirEntPtr = v1
		if !(v1 != libc.UintptrFromInt32(0)) {
			break
		} /* INTL: Native. */
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirEntPtr + 19))) == int32('.') && (libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirEntPtr + 19 + 1))) == int32('\000') || libc.Xstrcmp(tls, dirEntPtr+19, __ccgo_ts+15981) == 0) {
			continue
		}
		/*
		 * Append name after slash, and recurse on the file.
		 */
		XTcl_DStringAppend(tls, sourcePtr, dirEntPtr+19, int64(-libc.Int32FromInt32(1)))
		if targetPtr != libc.UintptrFromInt32(0) {
			XTcl_DStringAppend(tls, targetPtr, dirEntPtr+19, int64(-libc.Int32FromInt32(1)))
		}
		result = _TraverseUnixTree(tls, traverseProc, sourcePtr, targetPtr, errorPtr, doRewind)
		if result != TCL_OK {
			break
		} else {
			numProcessed++
		}
		/*
		 * Remove name after slash.
		 */
		XTcl_DStringSetLength(tls, sourcePtr, libc.Int64FromUint64(sourceLen))
		if targetPtr != libc.UintptrFromInt32(0) {
			XTcl_DStringSetLength(tls, targetPtr, libc.Int64FromUint64(targetLen))
		}
		if doRewind != 0 && numProcessed > int32(MAX_READDIR_UNLINK_THRESHOLD) {
			/*
			 * Call rewinddir if we've called unlink or rmdir so many times
			 * (since the opendir or the previous rewinddir), to avoid a
			 * NULL-return that may a symptom of a buggy readdir.
			 */
			libc.Xrewinddir(tls, dirPtr)
			numProcessed = 0
		}
	}
	libc.Xclosedir(tls, dirPtr)
	/*
	 * Strip off the trailing slash we added
	 */
	XTcl_DStringSetLength(tls, sourcePtr, libc.Int64FromUint64(sourceLen-uint64(1)))
	if targetPtr != libc.UintptrFromInt32(0) {
		XTcl_DStringSetLength(tls, targetPtr, libc.Int64FromUint64(targetLen-uint64(1)))
	}
	if result == TCL_OK {
		/*
		 * Call traverseProc() on a directory after visiting all the files in
		 * that directory.
		 */
		result = (*(*func(*libc.TLS, uintptr, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{traverseProc})))(tls, sourcePtr, targetPtr, bp, int32(DOTREE_POSTD), errorPtr)
	}
	goto end
end:
	;
	if errfile != libc.UintptrFromInt32(0) {
		if errorPtr != libc.UintptrFromInt32(0) {
			XTcl_ExternalToUtfDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), errfile, int64(-libc.Int32FromInt32(1)), 0, errorPtr, libc.UintptrFromInt32(0))
		}
		result = int32(TCL_ERROR)
	}
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * TraversalCopy
 *
 *	Called from TraverseUnixTree in order to execute a recursive copy of a
 *	directory.
 *
 * Results:
 *	Standard Tcl result.
 *
 * Side effects:
 *	The file or directory src may be copied to dst, depending on the value
 *	of type.
 *
 *----------------------------------------------------------------------
 */

func _TraversalCopy(tls *libc.TLS, srcPtr uintptr, dstPtr uintptr, statBufPtr uintptr, type1 int32, errorPtr uintptr) (r int32) {
	/* If non-NULL, uninitialized or free DString
	 * filled with UTF-8 name of file causing
	 * error. */
	switch type1 {
	case int32(DOTREE_F):
		if _DoCopyFile(tls, (*TTcl_DString)(unsafe.Pointer(srcPtr)).Fstring1, (*TTcl_DString)(unsafe.Pointer(dstPtr)).Fstring1, statBufPtr) == TCL_OK {
			return TCL_OK
		}
	case int32(DOTREE_PRED):
		if _DoCreateDirectory(tls, (*TTcl_DString)(unsafe.Pointer(dstPtr)).Fstring1) == TCL_OK {
			return TCL_OK
		}
	case int32(DOTREE_POSTD):
		if _CopyFileAtts(tls, (*TTcl_DString)(unsafe.Pointer(srcPtr)).Fstring1, (*TTcl_DString)(unsafe.Pointer(dstPtr)).Fstring1, statBufPtr) == TCL_OK {
			return TCL_OK
		}
		break
	}
	/*
	 * There shouldn't be a problem with src, because we already checked it to
	 * get here.
	 */
	if errorPtr != libc.UintptrFromInt32(0) {
		XTcl_ExternalToUtfDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), (*TTcl_DString)(unsafe.Pointer(dstPtr)).Fstring1, (*TTcl_DString)(unsafe.Pointer(dstPtr)).Flength, 0, errorPtr, libc.UintptrFromInt32(0))
	}
	return int32(TCL_ERROR)
}

/*
 *---------------------------------------------------------------------------
 *
 * TraversalDelete --
 *
 *	Called by procedure TraverseUnixTree for every file and directory that
 *	it encounters in a directory hierarchy. This procedure unlinks files,
 *	and removes directories after all the containing files have been
 *	processed.
 *
 * Results:
 *	Standard Tcl result.
 *
 * Side effects:
 *	Files or directory specified by src will be deleted.
 *
 *----------------------------------------------------------------------
 */

func _TraversalDelete(tls *libc.TLS, srcPtr uintptr, dummy1219 uintptr, dummy1220 uintptr, type1 int32, errorPtr uintptr) (r int32) {
	/* If non-NULL, uninitialized or free DString
	 * filled with UTF-8 name of file causing
	 * error. */
	switch type1 {
	case int32(DOTREE_F):
		if XTclpDeleteFile(tls, (*TTcl_DString)(unsafe.Pointer(srcPtr)).Fstring1) == 0 {
			return TCL_OK
		}
	case int32(DOTREE_PRED):
		return TCL_OK
	case int32(DOTREE_POSTD):
		if _DoRemoveDirectory(tls, srcPtr, 0, libc.UintptrFromInt32(0)) == 0 {
			return TCL_OK
		}
		break
	}
	if errorPtr != libc.UintptrFromInt32(0) {
		XTcl_ExternalToUtfDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), (*TTcl_DString)(unsafe.Pointer(srcPtr)).Fstring1, (*TTcl_DString)(unsafe.Pointer(srcPtr)).Flength, 0, errorPtr, libc.UintptrFromInt32(0))
	}
	return int32(TCL_ERROR)
}

/*
 *---------------------------------------------------------------------------
 *
 * CopyFileAtts --
 *
 *	Copy the file attributes such as owner, group, permissions, and
 *	modification date from one file to another.
 *
 * Results:
 *	Standard Tcl result.
 *
 * Side effects:
 *	User id, group id, permission bits, last modification time, and last
 *	access time are updated in the new file to reflect the old file.
 *
 *---------------------------------------------------------------------------
 */

func _CopyFileAtts(tls *libc.TLS, dummy1271 uintptr, dst uintptr, statBufPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	/* Stat info for source file */
	var newMode Tmode_t
	var _ /* tval at bp+0 */ Tutimbuf
	_ = newMode
	newMode = (*TTcl_StatBuf)(unsafe.Pointer(statBufPtr)).Fst_mode & libc.Uint32FromInt32(libc.Int32FromInt32(S_ISUID)|libc.Int32FromInt32(S_ISGID)|libc.Int32FromInt32(S_IRWXU)|libc.Int32FromInt32(S_IRWXG)|libc.Int32FromInt32(S_IRWXO))
	/*
	 * Note that if you copy a setuid file that is owned by someone else, and
	 * you are not root, then the copy will be setuid to you. The most correct
	 * implementation would probably be to have the copy not setuid to anyone
	 * if the original file was owned by someone else, but this corner case
	 * isn't currently handled. It would require another lstat(), or getuid().
	 */
	if libc.Xchmod(tls, dst, newMode) != 0 { /* INTL: Native. */
		newMode &= libc.Uint32FromInt32(^(libc.Int32FromInt32(S_ISUID) | libc.Int32FromInt32(S_ISGID)))
		if libc.Xchmod(tls, dst, newMode) != 0 { /* INTL: Native. */
			return int32(TCL_ERROR)
		}
	}
	(*(*Tutimbuf)(unsafe.Pointer(bp))).Factime = XTcl_GetAccessTimeFromStat(tls, statBufPtr)
	(*(*Tutimbuf)(unsafe.Pointer(bp))).Fmodtime = XTcl_GetModificationTimeFromStat(tls, statBufPtr)
	if libc.Xutime(tls, dst, bp) != 0 { /* INTL: Native. */
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * GetGroupAttribute
 *
 *	Gets the group attribute of a file.
 *
 * Results:
 *	Standard TCL result. Returns a new Tcl_Obj in attributePtrPtr if there
 *	is no error.
 *
 * Side effects:
 *	A new object is allocated.
 *
 *----------------------------------------------------------------------
 */

func _GetGroupAttribute(tls *libc.TLS, interp uintptr, dummy1330 int32, fileName uintptr, attributePtrPtr uintptr) (r int32) {
	bp := tls.Alloc(400)
	defer tls.Free(400) /* A pointer to return the object with. */
	var cachePtr, groupPtr, utf, v1 uintptr
	var result int32
	var v2 bool
	var _ /* ds at bp+144 */ TTcl_DString
	var _ /* statBuf at bp+0 */ TTcl_StatBuf
	_, _, _, _, _, _ = cachePtr, groupPtr, result, utf, v1, v2
	result = XTclpObjStat(tls, fileName, bp)
	if result != 0 {
		if interp != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(fileName)).Fbytes != 0 {
				v1 = (*TTcl_Obj)(unsafe.Pointer(fileName)).Fbytes
			} else {
				v1 = XTcl_GetStringFromObj(tls, fileName, libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+15598, libc.VaList(bp+376, v1, XTcl_PosixError(tls, interp))))
		}
		return int32(TCL_ERROR)
	}
	groupPtr = XTclpGetGrGid(tls, (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_gid)
	if groupPtr == libc.UintptrFromInt32(0) {
		if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(attributePtrPtr)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(attributePtrPtr)) = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(attributePtrPtr)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(attributePtrPtr)))).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(attributePtrPtr)))).Fbytes = libc.UintptrFromInt32(0)
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(attributePtrPtr)))).FinternalRep)) = libc.Int64FromUint32((*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_gid)
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(attributePtrPtr)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	} else {
		utf = XTcl_ExternalToUtfDString(tls, libc.UintptrFromInt32(0), (*Tgroup)(unsafe.Pointer(groupPtr)).Fgr_name, int64(-libc.Int32FromInt32(1)), bp+144)
		*(*uintptr)(unsafe.Pointer(attributePtrPtr)) = XTcl_NewStringObj(tls, utf, int64(-libc.Int32FromInt32(1)))
		XTcl_DStringFree(tls, bp+144)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * GetOwnerAttribute
 *
 *	Gets the owner attribute of a file.
 *
 * Results:
 *	Standard TCL result. Returns a new Tcl_Obj in attributePtrPtr if there
 *	is no error.
 *
 * Side effects:
 *	A new object is allocated.
 *
 *----------------------------------------------------------------------
 */

func _GetOwnerAttribute(tls *libc.TLS, interp uintptr, dummy1384 int32, fileName uintptr, attributePtrPtr uintptr) (r int32) {
	bp := tls.Alloc(400)
	defer tls.Free(400) /* A pointer to return the object with. */
	var cachePtr, pwPtr, v1 uintptr
	var result int32
	var v2 bool
	var _ /* ds at bp+144 */ TTcl_DString
	var _ /* statBuf at bp+0 */ TTcl_StatBuf
	_, _, _, _, _ = cachePtr, pwPtr, result, v1, v2
	result = XTclpObjStat(tls, fileName, bp)
	if result != 0 {
		if interp != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(fileName)).Fbytes != 0 {
				v1 = (*TTcl_Obj)(unsafe.Pointer(fileName)).Fbytes
			} else {
				v1 = XTcl_GetStringFromObj(tls, fileName, libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+15598, libc.VaList(bp+376, v1, XTcl_PosixError(tls, interp))))
		}
		return int32(TCL_ERROR)
	}
	pwPtr = XTclpGetPwUid(tls, (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_uid)
	if pwPtr == libc.UintptrFromInt32(0) {
		if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			*(*uintptr)(unsafe.Pointer(attributePtrPtr)) = XTclThreadAllocObj(tls)
		} else {
			*(*uintptr)(unsafe.Pointer(attributePtrPtr)) = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(attributePtrPtr)) + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(attributePtrPtr)))).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(attributePtrPtr)))).Fbytes = libc.UintptrFromInt32(0)
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(attributePtrPtr)))).FinternalRep)) = libc.Int64FromUint32((*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_uid)
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(attributePtrPtr)))).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
	} else {
		XTcl_ExternalToUtfDString(tls, libc.UintptrFromInt32(0), (*Tpasswd)(unsafe.Pointer(pwPtr)).Fpw_name, int64(-libc.Int32FromInt32(1)), bp+144)
		*(*uintptr)(unsafe.Pointer(attributePtrPtr)) = XTcl_DStringToObj(tls, bp+144)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * GetPermissionsAttribute
 *
 *	Gets the group attribute of a file.
 *
 * Results:
 *	Standard TCL result. Returns a new Tcl_Obj in attributePtrPtr if there
 *	is no error. The object will have ref count 0.
 *
 * Side effects:
 *	A new object is allocated.
 *
 *----------------------------------------------------------------------
 */

func _GetPermissionsAttribute(tls *libc.TLS, interp uintptr, dummy1436 int32, fileName uintptr, attributePtrPtr uintptr) (r int32) {
	bp := tls.Alloc(176)
	defer tls.Free(176) /* A pointer to return the object with. */
	var result int32
	var v1 uintptr
	var _ /* statBuf at bp+0 */ TTcl_StatBuf
	_, _ = result, v1
	result = XTclpObjStat(tls, fileName, bp)
	if result != 0 {
		if interp != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(fileName)).Fbytes != 0 {
				v1 = (*TTcl_Obj)(unsafe.Pointer(fileName)).Fbytes
			} else {
				v1 = XTcl_GetStringFromObj(tls, fileName, libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+15598, libc.VaList(bp+152, v1, XTcl_PosixError(tls, interp))))
		}
		return int32(TCL_ERROR)
	}
	*(*uintptr)(unsafe.Pointer(attributePtrPtr)) = XTcl_ObjPrintf(tls, __ccgo_ts+75672, libc.VaList(bp+152, libc.Int32FromUint32((*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_mode)&int32(0x7FFF)))
	return TCL_OK
}

/*
 *---------------------------------------------------------------------------
 *
 * SetGroupAttribute --
 *
 *	Sets the group of the file to the specified group.
 *
 * Results:
 *	Standard TCL result.
 *
 * Side effects:
 *	As above.
 *
 *---------------------------------------------------------------------------
 */

func _SetGroupAttribute(tls *libc.TLS, interp uintptr, dummy1478 int32, fileName uintptr, attributePtr uintptr) (r int32) {
	bp := tls.Alloc(288)
	defer tls.Free(288) /* New group for file. */
	var groupPtr, native, string1, v2, v3, v4 uintptr
	var result, v1 int32
	var _ /* ds at bp+8 */ TTcl_DString
	var _ /* gid at bp+0 */ TTcl_WideInt
	var _ /* length at bp+232 */ TTcl_Size
	_, _, _, _, _, _, _, _ = groupPtr, native, result, string1, v1, v2, v3, v4
	if (*TTcl_Obj)(unsafe.Pointer(attributePtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*TTcl_WideInt)(unsafe.Pointer(bp)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(attributePtr)).FinternalRep))
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_GetWideIntFromObj(tls, libc.UintptrFromInt32(0), attributePtr, bp)
	}
	if v1 != TCL_OK {
		groupPtr = libc.UintptrFromInt32(0)
		if (*TTcl_Obj)(unsafe.Pointer(attributePtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 232)) = (*TTcl_Obj)(unsafe.Pointer(attributePtr)).Flength
			v2 = (*TTcl_Obj)(unsafe.Pointer(attributePtr)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, attributePtr, bp+232)
		}
		string1 = v2
		if XTcl_UtfToExternalDStringEx(tls, interp, libc.UintptrFromInt32(0), string1, *(*TTcl_Size)(unsafe.Pointer(bp + 232)), 0, bp+8, libc.UintptrFromInt32(0)) != TCL_OK {
			XTcl_DStringFree(tls, bp+8)
			return int32(TCL_ERROR)
		}
		native = (*TTcl_DString)(unsafe.Pointer(bp + 8)).Fstring1
		groupPtr = XTclpGetGrNam(tls, native) /* INTL: Native. */
		XTcl_DStringFree(tls, bp+8)
		if groupPtr == libc.UintptrFromInt32(0) {
			if interp != libc.UintptrFromInt32(0) {
				if (*TTcl_Obj)(unsafe.Pointer(fileName)).Fbytes != 0 {
					v3 = (*TTcl_Obj)(unsafe.Pointer(fileName)).Fbytes
				} else {
					v3 = XTcl_GetStringFromObj(tls, fileName, libc.UintptrFromInt32(0))
				}
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+75678, libc.VaList(bp+248, v3, string1)))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+248, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+75739, __ccgo_ts+75746, libc.UintptrFromInt32(0)))
			}
			return int32(TCL_ERROR)
		}
		*(*TTcl_WideInt)(unsafe.Pointer(bp)) = libc.Int64FromUint32((*Tgroup)(unsafe.Pointer(groupPtr)).Fgr_gid)
	}
	native = XTcl_FSGetNativePath(tls, fileName)
	result = libc.Xchown(tls, native, libc.Uint32FromInt32(-libc.Int32FromInt32(1)), libc.Uint32FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp)))) /* INTL: Native. */
	if result != 0 {
		if interp != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(fileName)).Fbytes != 0 {
				v4 = (*TTcl_Obj)(unsafe.Pointer(fileName)).Fbytes
			} else {
				v4 = XTcl_GetStringFromObj(tls, fileName, libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+75755, libc.VaList(bp+248, v4, XTcl_PosixError(tls, interp))))
		}
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *---------------------------------------------------------------------------
 *
 * SetOwnerAttribute --
 *
 *	Sets the owner of the file to the specified owner.
 *
 * Results:
 *	Standard TCL result.
 *
 * Side effects:
 *	As above.
 *
 *---------------------------------------------------------------------------
 */

func _SetOwnerAttribute(tls *libc.TLS, interp uintptr, dummy1549 int32, fileName uintptr, attributePtr uintptr) (r int32) {
	bp := tls.Alloc(288)
	defer tls.Free(288) /* New owner for file. */
	var native, pwPtr, string1, v2, v3, v4 uintptr
	var result, v1 int32
	var _ /* ds at bp+8 */ TTcl_DString
	var _ /* length at bp+232 */ TTcl_Size
	var _ /* uid at bp+0 */ TTcl_WideInt
	_, _, _, _, _, _, _, _ = native, pwPtr, result, string1, v1, v2, v3, v4
	if (*TTcl_Obj)(unsafe.Pointer(attributePtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
		*(*TTcl_WideInt)(unsafe.Pointer(bp)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(attributePtr)).FinternalRep))
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_GetWideIntFromObj(tls, libc.UintptrFromInt32(0), attributePtr, bp)
	}
	if v1 != TCL_OK {
		pwPtr = libc.UintptrFromInt32(0)
		if (*TTcl_Obj)(unsafe.Pointer(attributePtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 232)) = (*TTcl_Obj)(unsafe.Pointer(attributePtr)).Flength
			v2 = (*TTcl_Obj)(unsafe.Pointer(attributePtr)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, attributePtr, bp+232)
		}
		string1 = v2
		if XTcl_UtfToExternalDStringEx(tls, interp, libc.UintptrFromInt32(0), string1, *(*TTcl_Size)(unsafe.Pointer(bp + 232)), 0, bp+8, libc.UintptrFromInt32(0)) != TCL_OK {
			XTcl_DStringFree(tls, bp+8)
			return int32(TCL_ERROR)
		}
		native = (*TTcl_DString)(unsafe.Pointer(bp + 8)).Fstring1
		pwPtr = XTclpGetPwNam(tls, native) /* INTL: Native. */
		XTcl_DStringFree(tls, bp+8)
		if pwPtr == libc.UintptrFromInt32(0) {
			if interp != libc.UintptrFromInt32(0) {
				if (*TTcl_Obj)(unsafe.Pointer(fileName)).Fbytes != 0 {
					v3 = (*TTcl_Obj)(unsafe.Pointer(fileName)).Fbytes
				} else {
					v3 = XTcl_GetStringFromObj(tls, fileName, libc.UintptrFromInt32(0))
				}
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+75793, libc.VaList(bp+248, v3, string1)))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+248, __ccgo_ts+2004, __ccgo_ts+8210, __ccgo_ts+75853, __ccgo_ts+75860, libc.UintptrFromInt32(0)))
			}
			return int32(TCL_ERROR)
		}
		*(*TTcl_WideInt)(unsafe.Pointer(bp)) = libc.Int64FromUint32((*Tpasswd)(unsafe.Pointer(pwPtr)).Fpw_uid)
	}
	native = XTcl_FSGetNativePath(tls, fileName)
	result = libc.Xchown(tls, native, libc.Uint32FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp))), libc.Uint32FromInt32(-libc.Int32FromInt32(1))) /* INTL: Native. */
	if result != 0 {
		if interp != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(fileName)).Fbytes != 0 {
				v4 = (*TTcl_Obj)(unsafe.Pointer(fileName)).Fbytes
			} else {
				v4 = XTcl_GetStringFromObj(tls, fileName, libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+75868, libc.VaList(bp+248, v4, XTcl_PosixError(tls, interp))))
		}
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *---------------------------------------------------------------------------
 *
 * SetPermissionsAttribute
 *
 *	Sets the file to the given permission.
 *
 * Results:
 *	Standard TCL result.
 *
 * Side effects:
 *	The permission of the file is changed.
 *
 *---------------------------------------------------------------------------
 */

func _SetPermissionsAttribute(tls *libc.TLS, interp uintptr, dummy1620 int32, fileName uintptr, attributePtr uintptr) (r int32) {
	bp := tls.Alloc(208)
	defer tls.Free(208) /* The attribute to set. */
	var _objPtr, cachePtr, modeObj, modeStringPtr, native, v1, v5, v8, v9 uintptr
	var result, scanned, v3, v6 int32
	var v2, v7 bool
	var v4 TTcl_Size
	var _ /* buf at bp+16 */ TTcl_StatBuf
	var _ /* mode at bp+0 */ TTcl_WideInt
	var _ /* newMode at bp+8 */ Tmode_t
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, modeObj, modeStringPtr, native, result, scanned, v1, v2, v3, v4, v5, v6, v7, v8, v9
	result = int32(TCL_ERROR)
	if (*TTcl_Obj)(unsafe.Pointer(attributePtr)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(attributePtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, attributePtr, libc.UintptrFromInt32(0))
	}
	modeStringPtr = v1
	scanned = int32(XTclParseAllWhiteSpace(tls, modeStringPtr, int64(-int32(1))))
	/*
	 * First supply support for octal number format
	 */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(modeStringPtr + uintptr(scanned)))) == int32('0') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(modeStringPtr + uintptr(scanned+int32(1))))) >= int32('0') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(modeStringPtr + uintptr(scanned+int32(1))))) <= int32('7') {
		if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			modeObj = XTclThreadAllocObj(tls)
		} else {
			modeObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(modeObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(modeObj)).FrefCount = 0
		if libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1) == uint64(0) {
			(*TTcl_Obj)(unsafe.Pointer(modeObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(modeObj)).Flength = int64(libc.Int32FromInt32(0))
		} else {
			(*TTcl_Obj)(unsafe.Pointer(modeObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
			libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(modeObj)).Fbytes, __ccgo_ts+46049, libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1))
			*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(modeObj)).Fbytes + uintptr(libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)))) = uint8('\000')
			(*TTcl_Obj)(unsafe.Pointer(modeObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(3) - libc.Uint64FromInt32(1))
		}
		(*TTcl_Obj)(unsafe.Pointer(modeObj)).FtypePtr = libc.UintptrFromInt32(0)
		XTcl_AppendToObj(tls, modeObj, modeStringPtr+uintptr(scanned)+uintptr(1), int64(-libc.Int32FromInt32(1)))
		if (*TTcl_Obj)(unsafe.Pointer(modeObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
			*(*TTcl_WideInt)(unsafe.Pointer(bp)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(modeObj)).FinternalRep))
			v3 = libc.Int32FromInt32(TCL_OK)
		} else {
			v3 = XTcl_GetWideIntFromObj(tls, libc.UintptrFromInt32(0), modeObj, bp)
		}
		result = v3
		_objPtr = modeObj
		v5 = _objPtr
		v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
		*(*TTcl_Size)(unsafe.Pointer(v5))--
		if v4 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	if v7 = result == TCL_OK; !v7 {
		if (*TTcl_Obj)(unsafe.Pointer(attributePtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclIntType)) {
			*(*TTcl_WideInt)(unsafe.Pointer(bp)) = *(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer(attributePtr)).FinternalRep))
			v6 = libc.Int32FromInt32(TCL_OK)
		} else {
			v6 = XTcl_GetWideIntFromObj(tls, libc.UintptrFromInt32(0), attributePtr, bp)
		}
	}
	if v7 || v6 == TCL_OK {
		*(*Tmode_t)(unsafe.Pointer(bp + 8)) = libc.Uint32FromInt64(*(*TTcl_WideInt)(unsafe.Pointer(bp)) & libc.Int64FromInt32(0x00007FFF))
	} else {
		/*
		 * Try the forms "rwxrwxrwx" and "ugo=rwx"
		 *
		 * We get the current mode of the file, in order to allow for ug+-=rwx
		 * style chmod strings.
		 */
		result = XTclpObjStat(tls, fileName, bp+16)
		if result != 0 {
			if interp != libc.UintptrFromInt32(0) {
				if (*TTcl_Obj)(unsafe.Pointer(fileName)).Fbytes != 0 {
					v8 = (*TTcl_Obj)(unsafe.Pointer(fileName)).Fbytes
				} else {
					v8 = XTcl_GetStringFromObj(tls, fileName, libc.UintptrFromInt32(0))
				}
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+15598, libc.VaList(bp+168, v8, XTcl_PosixError(tls, interp))))
			}
			return int32(TCL_ERROR)
		}
		*(*Tmode_t)(unsafe.Pointer(bp + 8)) = (*(*TTcl_StatBuf)(unsafe.Pointer(bp + 16))).Fst_mode & libc.Uint32FromInt32(0x00007FFF)
		if _GetModeFromPermString(tls, libc.UintptrFromInt32(0), modeStringPtr, bp+8) != TCL_OK {
			if interp != libc.UintptrFromInt32(0) {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+75906, libc.VaList(bp+168, modeStringPtr)))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+168, __ccgo_ts+2004, __ccgo_ts+2089, __ccgo_ts+75944, libc.UintptrFromInt32(0)))
			}
			return int32(TCL_ERROR)
		}
	}
	native = XTcl_FSGetNativePath(tls, fileName)
	result = libc.Xchmod(tls, native, *(*Tmode_t)(unsafe.Pointer(bp + 8))) /* INTL: Native. */
	if result != 0 {
		if interp != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(fileName)).Fbytes != 0 {
				v9 = (*TTcl_Obj)(unsafe.Pointer(fileName)).Fbytes
			} else {
				v9 = XTcl_GetStringFromObj(tls, fileName, libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+75955, libc.VaList(bp+168, v9, XTcl_PosixError(tls, interp))))
		}
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpObjListVolumes --
 *
 *	Lists the currently mounted volumes, which on UNIX is just /.
 *
 * Results:
 *	The list of volumes.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTclpObjListVolumes(tls *libc.TLS) (r uintptr) {
	var cachePtr, resultPtr uintptr
	var v1 bool
	_, _, _ = cachePtr, resultPtr, v1
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultPtr = XTclThreadAllocObj(tls)
	} else {
		resultPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount = 0
	if libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes, __ccgo_ts+6339, libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes + uintptr(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(2) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount++
	return resultPtr
}

/*
 *----------------------------------------------------------------------
 *
 * GetModeFromPermString --
 *
 *	This procedure is invoked to process the "file permissions" Tcl
 *	command, to check for a "rwxrwxrwx" or "ugoa+-=rwxst" string. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func _GetModeFromPermString(tls *libc.TLS, dummy1742 uintptr, modeStringPtr uintptr, modePtr uintptr) (r int32) {
	/* pointer to the mode value */
	var i, n, op, op_found, what, who, who_found, v3, v4, v5, v6 int32
	var newMode, oldMode Tmode_t
	_, _, _, _, _, _, _, _, _, _, _, _, _ = i, n, newMode, oldMode, op, op_found, what, who, who_found, v3, v4, v5, v6
	/*
	 * We start off checking for an "rwxrwxrwx" style permissions string
	 */
	if libc.Xstrlen(tls, modeStringPtr) != uint64(9) {
		goto chmodStyleCheck
	}
	newMode = uint32(0)
	i = 0
	for {
		if !(i < int32(9)) {
			break
		}
		switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(modeStringPtr + uintptr(i)))) {
		case int32('r'):
			if i%int32(3) != 0 {
				goto chmodStyleCheck
			}
			newMode |= libc.Uint32FromInt32(libc.Int32FromInt32(1) << (libc.Int32FromInt32(8) - i))
		case int32('w'):
			if i%int32(3) != int32(1) {
				goto chmodStyleCheck
			}
			newMode |= libc.Uint32FromInt32(libc.Int32FromInt32(1) << (libc.Int32FromInt32(8) - i))
		case int32('x'):
			if i%int32(3) != int32(2) {
				goto chmodStyleCheck
			}
			newMode |= libc.Uint32FromInt32(libc.Int32FromInt32(1) << (libc.Int32FromInt32(8) - i))
		case int32('s'):
			if i%int32(3) != int32(2) || i > int32(5) {
				goto chmodStyleCheck
			}
			newMode |= libc.Uint32FromInt32(libc.Int32FromInt32(1) << (libc.Int32FromInt32(8) - i))
			newMode |= libc.Uint32FromInt32(libc.Int32FromInt32(1) << (libc.Int32FromInt32(11) - i/libc.Int32FromInt32(3)))
		case int32('S'):
			if i%int32(3) != int32(2) || i > int32(5) {
				goto chmodStyleCheck
			}
			newMode |= libc.Uint32FromInt32(libc.Int32FromInt32(1) << (libc.Int32FromInt32(11) - i/libc.Int32FromInt32(3)))
		case int32('t'):
			if i != int32(8) {
				goto chmodStyleCheck
			}
			newMode |= libc.Uint32FromInt32(libc.Int32FromInt32(1) << (libc.Int32FromInt32(8) - i))
			newMode |= libc.Uint32FromInt32(libc.Int32FromInt32(1) << libc.Int32FromInt32(9))
		case int32('T'):
			if i != int32(8) {
				goto chmodStyleCheck
			}
			newMode |= libc.Uint32FromInt32(libc.Int32FromInt32(1) << libc.Int32FromInt32(9))
		case int32('-'):
		default:
			/*
			 * Oops, not what we thought it was, so go on
			 */
			goto chmodStyleCheck
		}
		goto _1
	_1:
		;
		i++
	}
	*(*Tmode_t)(unsafe.Pointer(modePtr)) = newMode
	return TCL_OK
	goto chmodStyleCheck
chmodStyleCheck:
	;
	/*
	 * We now check for an "ugoa+-=rwxst" style permissions string
	 */
	n = 0
	for {
		if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(modeStringPtr + uintptr(n)))) != int32('\000')) {
			break
		}
		oldMode = *(*Tmode_t)(unsafe.Pointer(modePtr))
		v6 = libc.Int32FromInt32(0)
		who_found = v6
		v5 = v6
		op_found = v5
		v4 = v5
		what = v4
		v3 = v4
		op = v3
		who = v3
		i = 0
		for {
			if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(modeStringPtr + uintptr(n+i)))) != int32('\000')) {
				break
			}
			if !(who_found != 0) {
				/* who */
				switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(modeStringPtr + uintptr(n+i)))) {
				case int32('u'):
					who |= int32(0x9C0)
					goto _7
				case int32('g'):
					who |= int32(0x438)
					goto _7
				case int32('o'):
					who |= int32(0x207)
					goto _7
				case int32('a'):
					who |= int32(0xFFF)
					goto _7
				}
			}
			who_found = int32(1)
			if who == 0 {
				who = int32(0xFFF)
			}
			if !(op_found != 0) {
				/* op */
				switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(modeStringPtr + uintptr(n+i)))) {
				case int32('+'):
					op = int32(1)
					op_found = int32(1)
					goto _7
				case int32('-'):
					op = int32(2)
					op_found = int32(1)
					goto _7
				case int32('='):
					op = int32(3)
					op_found = int32(1)
					goto _7
				default:
					return int32(TCL_ERROR)
				}
			}
			/* what */
			switch libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(modeStringPtr + uintptr(n+i)))) {
			case int32('r'):
				what |= int32(0x124)
				goto _7
			case int32('w'):
				what |= int32(0x92)
				goto _7
			case int32('x'):
				what |= int32(0x49)
				goto _7
			case int32('s'):
				what |= int32(0xC00)
				goto _7
			case int32('t'):
				what |= int32(0x200)
				goto _7
			case int32(','):
			default:
				return int32(TCL_ERROR)
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(modeStringPtr + uintptr(n+i)))) == int32(',') {
				i++
				break
			}
			goto _7
		_7:
			;
			i++
		}
		switch op {
		case int32(1):
			*(*Tmode_t)(unsafe.Pointer(modePtr)) = oldMode | libc.Uint32FromInt32(who&what)
			goto _2
		case int32(2):
			*(*Tmode_t)(unsafe.Pointer(modePtr)) = oldMode & libc.Uint32FromInt32(^(who & what))
			goto _2
		case int32(3):
			*(*Tmode_t)(unsafe.Pointer(modePtr)) = oldMode&libc.Uint32FromInt32(^who) | libc.Uint32FromInt32(who&what)
			goto _2
		}
		goto _2
	_2:
		;
		n += i
	}
	return TCL_OK
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpObjNormalizePath --
 *
 *	Replaces each component except that last one in a pathname that is a
 *	symbolic link with the fully resolved target of that link.
 *
 * Results:
 *	Stores the resulting path in pathPtr and returns the offset of the last
 *	byte processed to obtain the resulting path.
 *
 * Side effects:
 *
 *---------------------------------------------------------------------------
 */

func XTclpObjNormalizePath(tls *libc.TLS, interp uintptr, pathPtr uintptr, nextCheckpoint int32) (r int32) {
	bp := tls.Alloc(4336)
	defer tls.Free(4336) /* offset to start at in pathPtr.  Must either
	 * be 0 or the offset of a directory separator
	 * at the end of a path part that is already
	 * normalized.  I.e. this is not the index of
	 * the byte just after the separator.  */
	var accessOk, normLen int32
	var cur uint8
	var currentPathEndPosition, lastDir, nativePath, path, v1 uintptr
	var newNormLen TTcl_Size
	var _ /* ds at bp+8 */ TTcl_DString
	var _ /* normPath at bp+232 */ [4096]uint8
	var _ /* pathLen at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _ = accessOk, cur, currentPathEndPosition, lastDir, nativePath, newNormLen, normLen, path, v1
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, pathPtr, bp)
	}
	path = v1
	currentPathEndPosition = path + uintptr(nextCheckpoint)
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(currentPathEndPosition))) == int32('/') {
		currentPathEndPosition++
	}
	if nextCheckpoint == 0 && libc.Bool(int32(haveRealpath) != 0) {
		/*
		 * Try to get the entire path in one go
		 */
		lastDir = libc.Xstrrchr(tls, currentPathEndPosition, int32('/'))
		if lastDir != libc.UintptrFromInt32(0) {
			if XTcl_UtfToExternalDStringEx(tls, interp, libc.UintptrFromInt32(0), path, int64(lastDir)-int64(path), 0, bp+8, libc.UintptrFromInt32(0)) != TCL_OK {
				XTcl_DStringFree(tls, bp+8)
				return -int32(1)
			}
			nativePath = (*TTcl_DString)(unsafe.Pointer(bp + 8)).Fstring1
			if libc.Xrealpath(tls, nativePath, bp+232) != libc.UintptrFromInt32(0) {
				if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(nativePath))) != int32('/') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + 232))) == int32('/') {
					/*
					 * realpath transformed a relative path into an
					 * absolute path.  Fall back to the long way.
					 */
					/*
					 * To do: This logic seems to be out of date.  This whole
					 * routine should be reviewed and cleaed up.
					 */
				} else {
					nextCheckpoint = int32(int64(lastDir) - int64(path))
					goto wholeStringOk
				}
			}
			XTcl_DStringFree(tls, bp+8)
		}
	}
	/*
	 * Else do it the slow way.
	 */
	for int32(1) != 0 {
		cur = *(*uint8)(unsafe.Pointer(currentPathEndPosition))
		if libc.Int32FromUint8(cur) == int32('/') && path != currentPathEndPosition {
			if XTcl_UtfToExternalDStringEx(tls, interp, libc.UintptrFromInt32(0), path, int64(currentPathEndPosition)-int64(path), 0, bp+8, libc.UintptrFromInt32(0)) != TCL_OK {
				XTcl_DStringFree(tls, bp+8)
				return -int32(1)
			}
			nativePath = (*TTcl_DString)(unsafe.Pointer(bp + 8)).Fstring1
			accessOk = libc.Xaccess(tls, nativePath, F_OK)
			XTcl_DStringFree(tls, bp+8)
			if accessOk != 0 {
				/*
				 * File doesn't exist.
				 */
				break
			}
			/*
			 * Assign the end of the current component to nextCheckpoint
			 */
			nextCheckpoint = int32(int64(currentPathEndPosition) - int64(path))
		} else {
			if libc.Int32FromUint8(cur) == 0 {
				/*
				 * The end of the string.
				 */
				break
			}
		}
		currentPathEndPosition++
	}
	/*
	 * Call 'realpath' to obtain a canonical path.
	 */
	if !(int32(haveRealpath) != 0) {
		goto _2
	}
	if nextCheckpoint == 0 {
		/*
		 * The path contains at most one component, e.g. '/foo' or '/',
		 * so there is nothing to resolve. Also, on some platforms
		 * 'Realpath' transforms an empty string into the normalized pwd,
		 * which is the wrong answer.
		 */
		return 0
	}
	if XTcl_UtfToExternalDStringEx(tls, interp, libc.UintptrFromInt32(0), path, int64(nextCheckpoint), 0, bp+8, libc.UintptrFromInt32(0)) != 0 {
		XTcl_DStringFree(tls, bp+8)
		return -int32(1)
	}
	nativePath = (*TTcl_DString)(unsafe.Pointer(bp + 8)).Fstring1
	if !(libc.Xrealpath(tls, nativePath, bp+232) != libc.UintptrFromInt32(0)) {
		goto _3
	}
	goto wholeStringOk
wholeStringOk:
	;
	newNormLen = libc.Int64FromUint64(libc.Xstrlen(tls, bp+232))
	if newNormLen == (*TTcl_DString)(unsafe.Pointer(bp+8)).Flength && libc.Xstrcmp(tls, bp+232, nativePath) == 0 {
		/*
		 * The original path is unchanged.
		 */
		XTcl_DStringFree(tls, bp+8)
		/*
			 * Uncommenting this would mean that this native filesystem
			 * routine claims the path is normalized if the file exists,
			 * which would permit the caller to avoid iterating through
			 * other filesystems. Saving lots of calls is
			 * probably worth the extra access() time, but in the common
			 * case that no other filesystems are registered this is an
			 * unnecessary expense.
			 *
			if (0 == access(normPath, F_OK)) {
			    return pathLen;
			}
		*/
		return nextCheckpoint
	}
	/*
	 * Free the original path and replace it with the normalized path.
	 */
	XTcl_DStringFree(tls, bp+8)
	XTcl_ExternalToUtfDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), bp+232, newNormLen, 0, bp+8, libc.UintptrFromInt32(0))
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(nextCheckpoint)))) != int32('\000') {
		/*
		 * Append the remaining path components.
		 */
		normLen = int32((*TTcl_DString)(unsafe.Pointer(bp + 8)).Flength)
		XTcl_DStringAppend(tls, bp+8, path+uintptr(nextCheckpoint), *(*TTcl_Size)(unsafe.Pointer(bp))-int64(nextCheckpoint))
		/*
		 * characters up to and including the directory separator have
		 * been processed
		 */
		nextCheckpoint = normLen + int32(1)
	} else {
		/*
		 * We recognise the whole string.
		 */
		nextCheckpoint = int32((*TTcl_DString)(unsafe.Pointer(bp + 8)).Flength)
	}
	XTcl_SetStringObj(tls, pathPtr, (*TTcl_DString)(unsafe.Pointer(bp+8)).Fstring1, (*TTcl_DString)(unsafe.Pointer(bp+8)).Flength)
_3:
	;
	XTcl_DStringFree(tls, bp+8)
_2:
	;
	return nextCheckpoint
}

/*
 *----------------------------------------------------------------------
 *
 * TclpOpenTemporaryFile, TclUnixOpenTemporaryFile --
 *
 *	Creates a temporary file, possibly based on the supplied bits and
 *	pieces of template supplied in the first three arguments. If the
 *	fourth argument is non-NULL, it contains a Tcl_Obj to store the name
 *	of the temporary file in (and it is caller's responsibility to clean
 *	up). If the fourth argument is NULL, try to arrange for the temporary
 *	file to go away once it is no longer needed.
 *
 * Results:
 *	A read-write Tcl Channel open on the file for TclpOpenTemporaryFile,
 *	or a file descriptor (or -1 on failure) for TclUnixOpenTemporaryFile.
 *
 * Side effects:
 *	Accesses the filesystem. Will set the contents of the Tcl_Obj fourth
 *	argument (if that is non-NULL).
 *
 *----------------------------------------------------------------------
 */

func XTclpOpenTemporaryFile(tls *libc.TLS, dirObj uintptr, basenameObj uintptr, extensionObj uintptr, resultingNameObj uintptr) (r TTcl_Channel) {
	var fd int32
	_ = fd
	fd = XTclUnixOpenTemporaryFile(tls, dirObj, basenameObj, extensionObj, resultingNameObj)
	if fd == -int32(1) {
		return libc.UintptrFromInt32(0)
	}
	return XTcl_MakeFileChannel(tls, uintptr(int64(fd)), libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(2))
}

func XTclUnixOpenTemporaryFile(tls *libc.TLS, dirObj uintptr, basenameObj uintptr, extensionObj uintptr, resultingNameObj uintptr) (r int32) {
	bp := tls.Alloc(464)
	defer tls.Free(464)
	var fd int32
	var string1, v1, v2, v3 uintptr
	var _ /* length at bp+448 */ TTcl_Size
	var _ /* templ at bp+0 */ TTcl_DString
	var _ /* tmp at bp+224 */ TTcl_DString
	_, _, _, _, _ = fd, string1, v1, v2, v3
	/*
	 * We should also check against making more than TMP_MAX of these.
	 */
	if dirObj != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(dirObj)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 448)) = (*TTcl_Obj)(unsafe.Pointer(dirObj)).Flength
			v1 = (*TTcl_Obj)(unsafe.Pointer(dirObj)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, dirObj, bp+448)
		}
		string1 = v1
		if XTcl_UtfToExternalDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), string1, *(*TTcl_Size)(unsafe.Pointer(bp + 448)), 0, bp, libc.UintptrFromInt32(0)) != TCL_OK {
			return -int32(1)
		}
	} else {
		XTcl_DStringInit(tls, bp)
		XTcl_DStringAppend(tls, bp, _DefaultTempDir(tls), int64(-libc.Int32FromInt32(1))) /* INTL: native */
	}
	XTcl_DStringAppend(tls, bp, __ccgo_ts+6339, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))
	if basenameObj != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(basenameObj)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 448)) = (*TTcl_Obj)(unsafe.Pointer(basenameObj)).Flength
			v2 = (*TTcl_Obj)(unsafe.Pointer(basenameObj)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, basenameObj, bp+448)
		}
		string1 = v2
		if XTcl_UtfToExternalDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), string1, *(*TTcl_Size)(unsafe.Pointer(bp + 448)), 0, bp+224, libc.UintptrFromInt32(0)) != TCL_OK {
			XTcl_DStringFree(tls, bp+224)
			return -int32(1)
		}
		XTclDStringAppendDString(tls, bp, bp+224)
		XTcl_DStringFree(tls, bp+224)
	} else {
		XTcl_DStringAppend(tls, bp, __ccgo_ts+7241, libc.Int64FromUint64(libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)))
	}
	XTcl_DStringAppend(tls, bp, __ccgo_ts+75999, libc.Int64FromUint64(libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)))
	if extensionObj != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(extensionObj)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 448)) = (*TTcl_Obj)(unsafe.Pointer(extensionObj)).Flength
			v3 = (*TTcl_Obj)(unsafe.Pointer(extensionObj)).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, extensionObj, bp+448)
		}
		string1 = v3
		if XTcl_UtfToExternalDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), string1, *(*TTcl_Size)(unsafe.Pointer(bp + 448)), 0, bp+224, libc.UintptrFromInt32(0)) != TCL_OK {
			XTcl_DStringFree(tls, bp)
			return -int32(1)
		}
		XTclDStringAppendDString(tls, bp, bp+224)
		fd = libc.Xmkstemps(tls, (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1, int32((*TTcl_DString)(unsafe.Pointer(bp+224)).Flength))
		XTcl_DStringFree(tls, bp+224)
	} else {
		fd = libc.Xmkstemp(tls, (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1)
	}
	if fd == -int32(1) {
		XTcl_DStringFree(tls, bp)
		return -int32(1)
	}
	if resultingNameObj != 0 {
		if XTcl_ExternalToUtfDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1, (*TTcl_DString)(unsafe.Pointer(bp)).Flength, 0, bp+224, libc.UintptrFromInt32(0)) != TCL_OK {
			XTcl_DStringFree(tls, bp)
			return -int32(1)
		}
		XTcl_SetStringObj(tls, resultingNameObj, (*TTcl_DString)(unsafe.Pointer(bp+224)).Fstring1, (*TTcl_DString)(unsafe.Pointer(bp+224)).Flength)
		XTcl_DStringFree(tls, bp+224)
	} else {
		/*
		 * Try to delete the file immediately since we're not reporting the
		 * name to anyone. Note that we're *not* handling any errors from
		 * this!
		 */
		libc.Xunlink(tls, (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1)
		*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = 0
	}
	XTcl_DStringFree(tls, bp)
	return fd
}

/*
 * Helper that does *part* of what tempnam() does.
 */

func _DefaultTempDir(tls *libc.TLS) (r uintptr) {
	bp := tls.Alloc(144)
	defer tls.Free(144)
	var dir uintptr
	var _ /* buf at bp+0 */ TTcl_StatBuf
	_ = dir
	dir = libc.Xgetenv(tls, __ccgo_ts+76007)
	if dir != 0 && *(*uint8)(unsafe.Pointer(dir)) != 0 && libc.Xstat(tls, dir, bp) == 0 && (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) && libc.Xaccess(tls, dir, int32(W_OK)) == 0 {
		return dir
	}
	dir = __ccgo_ts + 76014
	if libc.Xstat(tls, dir, bp) == 0 && (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) && libc.Xaccess(tls, dir, int32(W_OK)) == 0 {
		return dir
	}
	/*
	 * Assume that the default location ("/tmp" if not overridden) is always
	 * an existing writable directory; we've no recovery mechanism if it
	 * isn't.
	 */
	return __ccgo_ts + 76014
}

/*
 *----------------------------------------------------------------------
 *
 * TclpCreateTemporaryDirectory --
 *
 *	Creates a temporary directory, possibly based on the supplied bits and
 *	pieces of template supplied in the arguments.
 *
 * Results:
 *	An object (refcount 0) containing the name of the newly-created
 *	directory, or NULL on failure.
 *
 * Side effects:
 *	Accesses the native filesystem. Makes a directory.
 *
 *----------------------------------------------------------------------
 */

func XTclpCreateTemporaryDirectory(tls *libc.TLS, dirObj uintptr, basenameObj uintptr) (r uintptr) {
	bp := tls.Alloc(448)
	defer tls.Free(448)
	var string1, v1, v2 uintptr
	var _ /* templ at bp+0 */ TTcl_DString
	var _ /* tmp at bp+224 */ TTcl_DString
	_, _, _ = string1, v1, v2
	/*
	 * Build the template in writable memory from the user-supplied pieces and
	 * some defaults.
	 */
	if dirObj != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(dirObj)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(dirObj)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, dirObj, libc.UintptrFromInt32(0))
		}
		string1 = v1
		if XTcl_UtfToExternalDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), string1, (*TTcl_Obj)(unsafe.Pointer(dirObj)).Flength, 0, bp, libc.UintptrFromInt32(0)) != TCL_OK {
			return libc.UintptrFromInt32(0)
		}
	} else {
		XTcl_DStringInit(tls, bp)
		XTcl_DStringAppend(tls, bp, _DefaultTempDir(tls), int64(-libc.Int32FromInt32(1))) /* INTL: native */
	}
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_DString)(unsafe.Pointer(bp)).Fstring1 + uintptr((*TTcl_DString)(unsafe.Pointer(bp)).Flength-int64(1))))) != int32('/') {
		XTcl_DStringAppend(tls, bp, __ccgo_ts+6339, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))
	}
	if basenameObj != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(basenameObj)).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(basenameObj)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, basenameObj, libc.UintptrFromInt32(0))
		}
		string1 = v2
		if (*TTcl_Obj)(unsafe.Pointer(basenameObj)).Flength != 0 {
			if XTcl_UtfToExternalDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), string1, (*TTcl_Obj)(unsafe.Pointer(basenameObj)).Flength, 0, bp+224, libc.UintptrFromInt32(0)) != TCL_OK {
				XTcl_DStringFree(tls, bp)
				return libc.UintptrFromInt32(0)
			}
			XTclDStringAppendDString(tls, bp, bp+224)
			XTcl_DStringFree(tls, bp+224)
		} else {
			XTcl_DStringAppend(tls, bp, __ccgo_ts+7241, libc.Int64FromUint64(libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)))
		}
	} else {
		XTcl_DStringAppend(tls, bp, __ccgo_ts+7241, libc.Int64FromUint64(libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)))
	}
	XTcl_DStringAppend(tls, bp, __ccgo_ts+75999, libc.Int64FromUint64(libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)))
	/*
	 * Make the temporary directory.
	 */
	if libc.Xmkdtemp(tls, (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1) == libc.UintptrFromInt32(0) {
		XTcl_DStringFree(tls, bp)
		return libc.UintptrFromInt32(0)
	}
	/*
	 * The template has been updated. Tell the caller what it was.
	 */
	if XTcl_ExternalToUtfDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1, (*TTcl_DString)(unsafe.Pointer(bp)).Flength, 0, bp+224, libc.UintptrFromInt32(0)) != TCL_OK {
		XTcl_DStringFree(tls, bp)
		return libc.UintptrFromInt32(0)
	}
	XTcl_DStringFree(tls, bp)
	return XTcl_DStringToObj(tls, bp+224)
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpFindExecutable --
 *
 *	This function computes the absolute path name of the current
 *	application, given its argv[0] value. For Cygwin, argv[0] is
 *	ignored and the path is determined the same as under win32.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The computed path name is stored as a ProcessGlobalValue.
 *
 *---------------------------------------------------------------------------
 */

func XTclpFindExecutable(tls *libc.TLS, argv0 uintptr) {
	bp := tls.Alloc(1040)
	defer tls.Free(1040) /* The value of the application's argv[0]
	 * (native). */
	var cachePtr, cachePtr1, name, obj, p uintptr
	var v2 int32
	var v3, v4 bool
	var _ /* buffer at bp+144 */ TTcl_DString
	var _ /* cwd at bp+592 */ TTcl_DString
	var _ /* nameString at bp+368 */ TTcl_DString
	var _ /* statBuf at bp+0 */ TTcl_StatBuf
	var _ /* utfName at bp+816 */ TTcl_DString
	_, _, _, _, _, _, _, _ = cachePtr, cachePtr1, name, obj, p, v2, v3, v4
	if argv0 == libc.UintptrFromInt32(0) {
		return
	}
	XTcl_DStringInit(tls, bp+144)
	name = argv0
	p = name
	for {
		if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('\000')) {
			break
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('/') {
			/*
			 * The name contains a slash, so use the name directly without
			 * doing a path search.
			 */
			goto gotName
		}
		goto _1
	_1:
		;
		p++
	}
	p = libc.Xgetenv(tls, __ccgo_ts+56448) /* INTL: Native. */
	if p == libc.UintptrFromInt32(0) {
		/*
		 * There's no PATH environment variable; use the default that is used
		 * by sh.
		 */
		p = __ccgo_ts + 76019
	} else {
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('\000') {
			/*
			 * An empty path is equivalent to ".".
			 */
			p = __ccgo_ts + 34717
		}
	}
	/*
	 * Search through all the directories named in the PATH variable to see if
	 * argv[0] is in one of them. If so, use that file name.
	 */
	for int32(1) != 0 {
		for {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) > int32(0x20) {
				v2 = 0
			} else {
				v2 = XTclIsSpaceProc(tls, libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))))
			}
			if !(v2 != 0) {
				break
			}
			p++
		}
		name = p
		for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32(':') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != 0 {
			p++
		}
		XTcl_DStringSetLength(tls, bp+144, 0)
		if p != name {
			XTcl_DStringAppend(tls, bp+144, name, int64(p)-int64(name))
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-libc.Int32FromInt32(1))))) != int32('/') {
				XTcl_DStringAppend(tls, bp+144, __ccgo_ts+6339, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))
			}
		}
		name = XTcl_DStringAppend(tls, bp+144, argv0, int64(-libc.Int32FromInt32(1)))
		/*
		 * INTL: The following calls to access() and stat() should not be
		 * converted to Tclp routines because they need to operate on native
		 * strings directly.
		 */
		if libc.Xaccess(tls, name, int32(X_OK)) == 0 && libc.Xstat(tls, name, bp) == 0 && (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFREG) {
			goto gotName
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('\000') {
			break
		} else {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == 0 {
				p = __ccgo_ts + 34717
			} else {
				p++
			}
		}
	}
	if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		obj = XTclThreadAllocObj(tls)
	} else {
		obj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(obj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(obj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(obj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr = libc.UintptrFromInt32(0)
	XTclSetObjNameOfExecutable(tls, obj, libc.UintptrFromInt32(0))
	goto done
	/*
	 * If the name starts with "/" then just store it
	 */
	goto gotName
gotName:
	;
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32('/') {
		XTcl_ExternalToUtfDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), name, int64(-libc.Int32FromInt32(1)), int32(TCL_ENCODING_PROFILE_TCL8), bp+816, libc.UintptrFromInt32(0))
		XTclSetObjNameOfExecutable(tls, XTcl_DStringToObj(tls, bp+816), libc.UintptrFromInt32(0))
		goto done
	}
	if XTclpGetCwd(tls, libc.UintptrFromInt32(0), bp+592) == libc.UintptrFromInt32(0) {
		if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			obj = XTclThreadAllocObj(tls)
		} else {
			obj = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(obj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(obj)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(obj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(obj)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(obj)).FtypePtr = libc.UintptrFromInt32(0)
		XTclSetObjNameOfExecutable(tls, obj, libc.UintptrFromInt32(0))
		goto done
	}
	/*
	 * The name is relative to the current working directory. First strip off
	 * a leading "./", if any, then add the full path name of the current
	 * working directory.
	 */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32('.') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name + 1))) == int32('/') {
		name += uintptr(2)
	}
	XTcl_DStringInit(tls, bp+368)
	XTcl_DStringAppend(tls, bp+368, name, int64(-libc.Int32FromInt32(1)))
	XTcl_DStringFree(tls, bp+144)
	XTcl_UtfToExternalDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), (*TTcl_DString)(unsafe.Pointer(bp+592)).Fstring1, (*TTcl_DString)(unsafe.Pointer(bp+592)).Flength, int32(TCL_ENCODING_PROFILE_TCL8), bp+144, libc.UintptrFromInt32(0))
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer((*TTcl_DString)(unsafe.Pointer(bp+592)).Fstring1 + uintptr((*TTcl_DString)(unsafe.Pointer(bp+592)).Flength-int64(1))))) != int32('/') {
		XTcl_DStringAppend(tls, bp+144, __ccgo_ts+6339, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))
	}
	XTcl_DStringFree(tls, bp+592)
	XTclDStringAppendDString(tls, bp+144, bp+368)
	XTcl_DStringFree(tls, bp+368)
	XTcl_ExternalToUtfDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), (*TTcl_DString)(unsafe.Pointer(bp+144)).Fstring1, int64(-libc.Int32FromInt32(1)), int32(TCL_ENCODING_PROFILE_TCL8), bp+816, libc.UintptrFromInt32(0))
	XTclSetObjNameOfExecutable(tls, XTcl_DStringToObj(tls, bp+816), libc.UintptrFromInt32(0))
	goto done
done:
	;
	XTcl_DStringFree(tls, bp+144)
}

/*
 *----------------------------------------------------------------------
 *
 * TclpMatchInDirectory --
 *
 *	This routine is used by the globbing code to search a directory for
 *	all files which match a given pattern.
 *
 * Results:
 *	The return value is a standard Tcl result indicating whether an error
 *	occurred in globbing. Errors are left in interp, good results are
 *	[lappend]ed to resultPtr (which must be a valid object).
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclpMatchInDirectory(tls *libc.TLS, interp uintptr, resultPtr uintptr, pathPtr uintptr, pattern uintptr, types uintptr) (r int32) {
	bp := tls.Alloc(848)
	defer tls.Free(848) /* Object containing list of acceptable types.
	 * May be NULL. In particular the directory
	 * flag is very important. */
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, d, dirName, entryPtr, fileNamePtr, native, nativeTail, tailPtr, utfname, v11, v12, v14, v2, v4, v5, v7, v9 uintptr
	var matchHidden, matchHiddenPat, matchResult, typeOk int32
	var nativeDirLen, v1, v10, v13, v3, v6, v8 TTcl_Size
	var _ /* dirLength at bp+0 */ TTcl_Size
	var _ /* ds at bp+152 */ TTcl_DString
	var _ /* dsOrig at bp+376 */ TTcl_DString
	var _ /* statBuf at bp+8 */ TTcl_StatBuf
	var _ /* utfDs at bp+600 */ TTcl_DString
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, d, dirName, entryPtr, fileNamePtr, matchHidden, matchHiddenPat, matchResult, native, nativeDirLen, nativeTail, tailPtr, typeOk, utfname, v1, v10, v11, v12, v13, v14, v2, v3, v4, v5, v6, v7, v8, v9
	matchResult = 0
	if types != libc.UintptrFromInt32(0) && (*TTcl_GlobTypeData)(unsafe.Pointer(types)).Ftype1 == libc.Int32FromInt32(1)<<libc.Int32FromInt32(7) {
		/*
		 * The native filesystem never adds mounts.
		 */
		return TCL_OK
	}
	fileNamePtr = XTcl_FSGetTranslatedPath(tls, interp, pathPtr)
	if fileNamePtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if pattern == libc.UintptrFromInt32(0) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) == int32('\000') {
		native = XTcl_FSGetNativePath(tls, pathPtr)
		tailPtr = XTclPathPart(tls, interp, pathPtr, int32(TCL_PATH_TAIL))
		nativeTail = XTcl_FSGetNativePath(tls, tailPtr)
		matchResult = _NativeMatchType(tls, interp, native, nativeTail, types)
		if matchResult == int32(1) {
			XTcl_ListObjAppendElement(tls, interp, resultPtr, pathPtr)
		}
		_objPtr = tailPtr
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		_objPtr1 = fileNamePtr
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	} else { /* utf-8 encoding of dir */
		XTcl_DStringInit(tls, bp+376)
		if (*TTcl_Obj)(unsafe.Pointer(fileNamePtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(fileNamePtr)).Flength
			v5 = (*TTcl_Obj)(unsafe.Pointer(fileNamePtr)).Fbytes
		} else {
			v5 = XTcl_GetStringFromObj(tls, fileNamePtr, bp)
		}
		dirName = v5
		XTcl_DStringAppend(tls, bp+376, dirName, *(*TTcl_Size)(unsafe.Pointer(bp)))
		/*
		 * Make sure that the directory part of the name really is a
		 * directory. If the directory name is "", use the name "." instead,
		 * because some UNIX systems don't treat "" like "." automatically.
		 * Keep the "" for use in generating file names, otherwise "glob
		 * foo.c" would return "./foo.c".
		 */
		if *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
			dirName = __ccgo_ts + 35293
		} else {
			dirName = (*TTcl_DString)(unsafe.Pointer(bp + 376)).Fstring1
			/*
			 * Make sure we have a trailing directory delimiter.
			 */
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(dirName + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp))-int64(1))))) != int32('/') {
				dirName = XTcl_DStringAppend(tls, bp+376, __ccgo_ts+6339, libc.Int64FromUint64(libc.Uint64FromInt64(2)-libc.Uint64FromInt32(1)))
				*(*TTcl_Size)(unsafe.Pointer(bp))++
			}
		}
		/*
		 * Now open the directory for reading and iterate over the contents.
		 */
		if XTcl_UtfToExternalDStringEx(tls, interp, libc.UintptrFromInt32(0), dirName, int64(-libc.Int32FromInt32(1)), 0, bp+152, libc.UintptrFromInt32(0)) != TCL_OK {
			XTcl_DStringFree(tls, bp+376)
			XTcl_DStringFree(tls, bp+152)
			_objPtr2 = fileNamePtr
			v7 = _objPtr2
			v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
			*(*TTcl_Size)(unsafe.Pointer(v7))--
			if v6 <= int64(1) {
				XTclFreeObj(tls, _objPtr2)
			}
			return int32(TCL_ERROR)
		}
		native = (*TTcl_DString)(unsafe.Pointer(bp + 152)).Fstring1
		if libc.Xstat(tls, native, bp+8) != 0 || !((*(*TTcl_StatBuf)(unsafe.Pointer(bp + 8))).Fst_mode&libc.Uint32FromInt32(S_IFMT) == libc.Uint32FromInt32(S_IFDIR)) {
			XTcl_DStringFree(tls, bp+376)
			XTcl_DStringFree(tls, bp+152)
			_objPtr3 = fileNamePtr
			v9 = _objPtr3
			v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
			*(*TTcl_Size)(unsafe.Pointer(v9))--
			if v8 <= int64(1) {
				XTclFreeObj(tls, _objPtr3)
			}
			return TCL_OK
		}
		d = libc.Xopendir(tls, native) /* INTL: Native. */
		if d == libc.UintptrFromInt32(0) {
			XTcl_DStringFree(tls, bp+152)
			if interp != libc.UintptrFromInt32(0) {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+76034, libc.VaList(bp+832, (*TTcl_DString)(unsafe.Pointer(bp+376)).Fstring1, XTcl_PosixError(tls, interp))))
			}
			XTcl_DStringFree(tls, bp+376)
			_objPtr4 = fileNamePtr
			v11 = _objPtr4
			v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
			*(*TTcl_Size)(unsafe.Pointer(v11))--
			if v10 <= int64(1) {
				XTclFreeObj(tls, _objPtr4)
			}
			return int32(TCL_ERROR)
		}
		nativeDirLen = (*TTcl_DString)(unsafe.Pointer(bp + 152)).Flength
		/*
		 * Check to see if -type or the pattern requests hidden files.
		 */
		matchHiddenPat = libc.BoolInt32(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) == int32('.') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern))) == int32('\\') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(pattern + 1))) == int32('.'))
		matchHidden = libc.BoolInt32(matchHiddenPat != 0 || types != 0 && (*TTcl_GlobTypeData)(unsafe.Pointer(types)).Fperm&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0)
		for {
			v12 = libc.Xreaddir(tls, d)
			entryPtr = v12
			if !(v12 != libc.UintptrFromInt32(0)) {
				break
			}
			/*
			 * Skip this file if it doesn't agree with the hidden parameters
			 * requested by the user (via -type or pattern).
			 */
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(entryPtr + 19))) == int32('.') {
				if !(matchHidden != 0) {
					continue
				}
			} else {
				if matchHidden != 0 {
					continue
				}
			}
			/*
			 * Now check to see if the file matches, according to both type
			 * and pattern. If so, add the file to the result.
			 */
			if XTcl_ExternalToUtfDStringEx(tls, interp, libc.UintptrFromInt32(0), entryPtr+19, int64(-libc.Int32FromInt32(1)), 0, bp+600, libc.UintptrFromInt32(0)) != TCL_OK {
				matchResult = -int32(1)
				break
			}
			utfname = (*TTcl_DString)(unsafe.Pointer(bp + 600)).Fstring1
			if XTcl_StringCaseMatch(tls, utfname, pattern, 0) != 0 {
				typeOk = int32(1)
				if types != libc.UintptrFromInt32(0) {
					XTcl_DStringSetLength(tls, bp+152, nativeDirLen)
					native = XTcl_DStringAppend(tls, bp+152, entryPtr+19, int64(-libc.Int32FromInt32(1)))
					matchResult = _NativeMatchType(tls, interp, native, entryPtr+19, types)
					typeOk = libc.BoolInt32(matchResult == int32(1))
				}
				if typeOk != 0 {
					XTcl_ListObjAppendElement(tls, interp, resultPtr, XTclNewFSPathObj(tls, pathPtr, utfname, (*TTcl_DString)(unsafe.Pointer(bp+600)).Flength))
				}
			}
			XTcl_DStringFree(tls, bp+600)
			if matchResult < 0 {
				break
			}
		}
		libc.Xclosedir(tls, d)
		XTcl_DStringFree(tls, bp+152)
		XTcl_DStringFree(tls, bp+376)
		_objPtr5 = fileNamePtr
		v14 = _objPtr5
		v13 = *(*TTcl_Size)(unsafe.Pointer(v14))
		*(*TTcl_Size)(unsafe.Pointer(v14))--
		if v13 <= int64(1) {
			XTclFreeObj(tls, _objPtr5)
		}
	}
	if matchResult < 0 {
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * NativeMatchType --
 *
 *	This routine is used by the globbing code to check if a file matches a
 *	given type description.
 *
 * Results:
 *	The return value is 1, 0 or -1 indicating whether the file matches the
 *	given criteria, does not match them, or an error occurred (in which
 *	case an error is left in interp).
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _NativeMatchType(tls *libc.TLS, interp uintptr, nativeEntry uintptr, nativeName uintptr, types uintptr) (r int32) {
	bp := tls.Alloc(144)
	defer tls.Free(144) /* Type description to match against. */
	var _ /* buf at bp+0 */ TTcl_StatBuf
	if types == libc.UintptrFromInt32(0) {
		/*
		 * Simply check for the file's existence, but do it with lstat, in
		 * case it is a link to a file which doesn't exist (since that case
		 * would not show up if we used 'access' or 'stat')
		 */
		if libc.Xlstat(tls, nativeEntry, bp) != 0 {
			return 0
		}
		return int32(1)
	}
	if (*TTcl_GlobTypeData)(unsafe.Pointer(types)).Fperm != 0 {
		if libc.Xstat(tls, nativeEntry, bp) != 0 {
			/*
			 * Either the file has disappeared between the 'readdir' call and
			 * the 'stat' call, or the file is a link to a file which doesn't
			 * exist (which we could ascertain with lstat), or there is some
			 * other strange problem. In all these cases, we define this to
			 * mean the file does not match any defined permission, and
			 * therefore it is not added to the list of files to return.
			 */
			return 0
		}
		/*
		 * readonly means that there are NO write permissions (even for user),
		 * but execute is OK for anybody OR that the user immutable flag is
		 * set (where supported).
		 */
		if (*TTcl_GlobTypeData)(unsafe.Pointer(types)).Fperm&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(0)) != 0 && (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_mode&libc.Uint32FromInt32(libc.Int32FromInt32(S_IWOTH)|libc.Int32FromInt32(S_IWGRP)|libc.Int32FromInt32(S_IWUSR)) != 0 || (*TTcl_GlobTypeData)(unsafe.Pointer(types)).Fperm&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 && libc.Xaccess(tls, nativeEntry, int32(R_OK)) != 0 || (*TTcl_GlobTypeData)(unsafe.Pointer(types)).Fperm&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(3)) != 0 && libc.Xaccess(tls, nativeEntry, int32(W_OK)) != 0 || (*TTcl_GlobTypeData)(unsafe.Pointer(types)).Fperm&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(4)) != 0 && libc.Xaccess(tls, nativeEntry, int32(X_OK)) != 0 || (*TTcl_GlobTypeData)(unsafe.Pointer(types)).Fperm&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(nativeName))) != int32('.') {
			return 0
		}
	}
	if (*TTcl_GlobTypeData)(unsafe.Pointer(types)).Ftype1 != 0 {
		if (*TTcl_GlobTypeData)(unsafe.Pointer(types)).Fperm == 0 {
			/*
			 * We haven't yet done a stat on the file.
			 */
			if libc.Xstat(tls, nativeEntry, bp) != 0 {
				/*
				 * Posix error occurred. The only ok case is if this is a link
				 * to a nonexistent file, and the user did 'glob -l'. So we
				 * check that here:
				 */
				if (*TTcl_GlobTypeData)(unsafe.Pointer(types)).Ftype1&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(5)) != 0 && libc.Xlstat(tls, nativeEntry, bp) == 0 && (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) {
					return int32(1)
				}
				return 0
			}
		}
		/*
		 * In order bcdpsfl as in 'find -t'
		 */
		if (*TTcl_GlobTypeData)(unsafe.Pointer(types)).Ftype1&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(0)) != 0 && (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFBLK) || (*TTcl_GlobTypeData)(unsafe.Pointer(types)).Ftype1&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 && (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFCHR) || (*TTcl_GlobTypeData)(unsafe.Pointer(types)).Ftype1&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 && (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFDIR) || (*TTcl_GlobTypeData)(unsafe.Pointer(types)).Ftype1&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(3)) != 0 && (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFIFO) || (*TTcl_GlobTypeData)(unsafe.Pointer(types)).Ftype1&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(6)) != 0 && (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFSOCK) || (*TTcl_GlobTypeData)(unsafe.Pointer(types)).Ftype1&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(4)) != 0 && (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFREG) {
			/*
			 * Do nothing - this file is ok.
			 */
		} else {
			if (*TTcl_GlobTypeData)(unsafe.Pointer(types)).Ftype1&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(5)) != 0 && libc.Xlstat(tls, nativeEntry, bp) == 0 && (*(*TTcl_StatBuf)(unsafe.Pointer(bp))).Fst_mode&uint32(S_IFMT) == uint32(S_IFLNK) {
				goto filetypeOK
			}
			return 0
		}
	}
	goto filetypeOK
filetypeOK:
	;
	/*
	 * If we're on OSX, we also have to worry about matching the file creator
	 * code (if specified). Do that now.
	 */
	_ = interp
	return int32(1)
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpGetUserHome --
 *
 *	This function takes the specified user name and finds their home
 *	directory.
 *
 * Results:
 *	The result is a pointer to a string specifying the user's home
 *	directory, or NULL if the user's home directory could not be
 *	determined. Storage for the result string is allocated in bufferPtr;
 *	the caller must call Tcl_DStringFree() when the result is no longer
 *	needed.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclpGetUserHome(tls *libc.TLS, name uintptr, bufferPtr uintptr) (r uintptr) {
	bp := tls.Alloc(224)
	defer tls.Free(224) /* Uninitialized or free DString filled with
	 * name of user's home directory. */
	var native, pwPtr uintptr
	var _ /* ds at bp+0 */ TTcl_DString
	_, _ = native, pwPtr
	if XTcl_UtfToExternalDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), name, int64(-libc.Int32FromInt32(1)), 0, bp, libc.UintptrFromInt32(0)) != TCL_OK {
		XTcl_DStringFree(tls, bp)
		return libc.UintptrFromInt32(0)
	}
	native = (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1
	pwPtr = XTclpGetPwNam(tls, native) /* INTL: Native. */
	XTcl_DStringFree(tls, bp)
	if pwPtr == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	if XTcl_ExternalToUtfDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), (*Tpasswd)(unsafe.Pointer(pwPtr)).Fpw_dir, int64(-libc.Int32FromInt32(1)), 0, bufferPtr, libc.UintptrFromInt32(0)) != TCL_OK {
		return libc.UintptrFromInt32(0)
	} else {
		return (*TTcl_DString)(unsafe.Pointer(bufferPtr)).Fstring1
	}
	return r
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpObjAccess --
 *
 *	This function replaces the library version of access().
 *
 * Results:
 *	See access() documentation.
 *
 * Side effects:
 *	See access() documentation.
 *
 *---------------------------------------------------------------------------
 */

func XTclpObjAccess(tls *libc.TLS, pathPtr uintptr, mode int32) (r int32) {
	/* Permission setting. */
	var path uintptr
	_ = path
	path = XTcl_FSGetNativePath(tls, pathPtr)
	if path == libc.UintptrFromInt32(0) {
		return -int32(1)
	}
	return libc.Xaccess(tls, path, mode)
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpObjChdir --
 *
 *	This function replaces the library version of chdir().
 *
 * Results:
 *	See chdir() documentation.
 *
 * Side effects:
 *	See chdir() documentation.
 *
 *---------------------------------------------------------------------------
 */

func XTclpObjChdir(tls *libc.TLS, pathPtr uintptr) (r int32) {
	/* Path to new working directory */
	var path uintptr
	_ = path
	path = XTcl_FSGetNativePath(tls, pathPtr)
	if path == libc.UintptrFromInt32(0) {
		return -int32(1)
	}
	return libc.Xchdir(tls, path)
}

/*
 *----------------------------------------------------------------------
 *
 * TclpObjLstat --
 *
 *	This function replaces the library version of lstat().
 *
 * Results:
 *	See lstat() documentation.
 *
 * Side effects:
 *	See lstat() documentation.
 *
 *----------------------------------------------------------------------
 */

func XTclpObjLstat(tls *libc.TLS, pathPtr uintptr, bufPtr uintptr) (r int32) {
	/* Filled with results of stat call. */
	return libc.Xlstat(tls, XTcl_FSGetNativePath(tls, pathPtr), bufPtr)
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpGetNativeCwd --
 *
 *	This function replaces the library version of getcwd().
 *
 * Results:
 *	The input and output are filesystem paths in native form. The result
 *	is either the given clientData, if the working directory hasn't
 *	changed, or a new clientData (owned by our caller), giving the new
 *	native path, or NULL if the current directory could not be determined.
 *	If NULL is returned, the caller can examine the standard Posix error
 *	codes to determine the cause of the problem.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclpGetNativeCwd(tls *libc.TLS, clientData uintptr) (r uintptr) {
	bp := tls.Alloc(4112)
	defer tls.Free(4112)
	var newCd uintptr
	var _ /* buffer at bp+0 */ [4097]uint8
	_ = newCd
	if libc.Xgetcwd(tls, bp, libc.Uint64FromInt32(libc.Int32FromInt32(MAXPATHLEN)+libc.Int32FromInt32(1))) == libc.UintptrFromInt32(0) { /* INTL: Native. */
		return libc.UintptrFromInt32(0)
	}
	if clientData == libc.UintptrFromInt32(0) || libc.Xstrcmp(tls, bp, clientData) != 0 {
		newCd = XTcl_Alloc(tls, libc.Xstrlen(tls, bp)+uint64(1))
		libc.Xstrcpy(tls, newCd, bp)
		return newCd
	}
	/*
	 * No change to pwd.
	 */
	return clientData
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpGetCwd --
 *
 *	This function replaces the library version of getcwd(). (Obsolete
 *	function, only retained for old extensions which may call it
 *	directly).
 *
 * Results:
 *	The result is a pointer to a string specifying the current directory,
 *	or NULL if the current directory could not be determined. If NULL is
 *	returned, an error message is left in the interp's result. Storage for
 *	the result string is allocated in bufferPtr; the caller must call
 *	Tcl_DStringFree() when the result is no longer needed.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclpGetCwd(tls *libc.TLS, interp uintptr, bufferPtr uintptr) (r uintptr) {
	bp := tls.Alloc(4128)
	defer tls.Free(4128) /* Uninitialized or free DString filled with
	 * name of current directory. */
	var _ /* buffer at bp+0 */ [4097]uint8
	if libc.Xgetcwd(tls, bp, libc.Uint64FromInt32(libc.Int32FromInt32(MAXPATHLEN)+libc.Int32FromInt32(1))) == libc.UintptrFromInt32(0) { /* INTL: Native. */
		if interp != libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+49760, libc.VaList(bp+4112, XTcl_PosixError(tls, interp))))
		}
		return libc.UintptrFromInt32(0)
	}
	if XTcl_ExternalToUtfDStringEx(tls, interp, libc.UintptrFromInt32(0), bp, int64(-libc.Int32FromInt32(1)), 0, bufferPtr, libc.UintptrFromInt32(0)) != TCL_OK {
		return libc.UintptrFromInt32(0)
	}
	return (*TTcl_DString)(unsafe.Pointer(bufferPtr)).Fstring1
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpReadlink --
 *
 *	This function replaces the library version of readlink().
 *
 * Results:
 *	The result is a pointer to a string specifying the contents of the
 *	symbolic link given by 'path', or NULL if the symbolic link could not
 *	be read. Storage for the result string is allocated in bufferPtr; the
 *	caller must call Tcl_DStringFree() when the result is no longer
 *	needed.
 *
 * Side effects:
 *	See readlink() documentation.
 *
 *---------------------------------------------------------------------------
 */

func XTclpReadlink(tls *libc.TLS, path uintptr, linkPtr uintptr) (r uintptr) {
	bp := tls.Alloc(4320)
	defer tls.Free(4320) /* Uninitialized or free DString filled with
	 * contents of link (UTF-8). */
	var length TTcl_Size
	var native uintptr
	var _ /* ds at bp+4096 */ TTcl_DString
	var _ /* link at bp+0 */ [4096]uint8
	_, _ = length, native
	if XTcl_UtfToExternalDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), path, int64(-libc.Int32FromInt32(1)), 0, bp+4096, libc.UintptrFromInt32(0)) != TCL_OK {
		XTcl_DStringFree(tls, bp+4096)
		return libc.UintptrFromInt32(0)
	}
	native = (*TTcl_DString)(unsafe.Pointer(bp + 4096)).Fstring1
	length = libc.Xreadlink(tls, native, bp, uint64(4096)) /* INTL: Native. */
	XTcl_DStringFree(tls, bp+4096)
	if length < 0 {
		return libc.UintptrFromInt32(0)
	}
	if XTcl_ExternalToUtfDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), bp, length, 0, linkPtr, libc.UintptrFromInt32(0)) == TCL_OK {
		return (*TTcl_DString)(unsafe.Pointer(linkPtr)).Fstring1
	}
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * TclpObjStat --
 *
 *	This function replaces the library version of stat().
 *
 * Results:
 *	See stat() documentation.
 *
 * Side effects:
 *	See stat() documentation.
 *
 *----------------------------------------------------------------------
 */

func XTclpObjStat(tls *libc.TLS, pathPtr uintptr, bufPtr uintptr) (r int32) {
	/* Filled with results of stat call. */
	var path uintptr
	_ = path
	path = XTcl_FSGetNativePath(tls, pathPtr)
	if path == libc.UintptrFromInt32(0) {
		return -int32(1)
	}
	return libc.Xstat(tls, path, bufPtr)
}

func XTclpObjLink(tls *libc.TLS, pathPtr uintptr, _toPtr uintptr, linkAction int32) (r uintptr) {
	bp := tls.Alloc(4560)
	defer tls.Free(4560)
	*(*uintptr)(unsafe.Pointer(bp)) = _toPtr
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, absPtr, dirPtr, linkPtr, src, target, transPtr, transPtr1, v11, v13, v2, v4, v6, v8, v9 uintptr
	var length1 Tssize_t
	var v1, v10, v12, v3, v5, v7 TTcl_Size
	var _ /* ds at bp+4336 */ TTcl_DString
	var _ /* ds at bp+8 */ TTcl_DString
	var _ /* length at bp+232 */ TTcl_Size
	var _ /* link at bp+240 */ [4096]uint8
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, _objPtr4, _objPtr5, absPtr, dirPtr, length1, linkPtr, src, target, transPtr, transPtr1, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9
	if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
		src = XTcl_FSGetNativePath(tls, pathPtr)
		target = libc.UintptrFromInt32(0)
		if src == libc.UintptrFromInt32(0) {
			return libc.UintptrFromInt32(0)
		}
		/*
		 * If we're making a symbolic link and the path is relative, then we
		 * must check whether it exists _relative_ to the directory in which
		 * the src is found (not relative to the current cwd which is just not
		 * relevant in this case).
		 *
		 * If we're making a hard link, then a relative path is just converted
		 * to absolute relative to the cwd.
		 */
		if linkAction&int32(TCL_CREATE_SYMBOLIC_LINK) != 0 && XTcl_FSGetPathType(tls, *(*uintptr)(unsafe.Pointer(bp))) == int32(TCL_PATH_RELATIVE) {
			dirPtr = XTclPathPart(tls, libc.UintptrFromInt32(0), pathPtr, int32(TCL_PATH_DIRNAME))
			if dirPtr == libc.UintptrFromInt32(0) {
				return libc.UintptrFromInt32(0)
			}
			absPtr = XTcl_FSJoinToPath(tls, dirPtr, int64(1), bp)
			(*TTcl_Obj)(unsafe.Pointer(absPtr)).FrefCount++
			if XTcl_FSAccess(tls, absPtr, F_OK) == -int32(1) {
				_objPtr = absPtr
				v2 = _objPtr
				v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
				*(*TTcl_Size)(unsafe.Pointer(v2))--
				if v1 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
				_objPtr1 = dirPtr
				v4 = _objPtr1
				v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
				*(*TTcl_Size)(unsafe.Pointer(v4))--
				if v3 <= int64(1) {
					XTclFreeObj(tls, _objPtr1)
				}
				/*
				 * Target doesn't exist.
				 */
				*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = int32(ENOENT)
				return libc.UintptrFromInt32(0)
			}
			/*
			 * Target exists; we'll construct the relative path we want below.
			 */
			_objPtr2 = absPtr
			v6 = _objPtr2
			v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
			*(*TTcl_Size)(unsafe.Pointer(v6))--
			if v5 <= int64(1) {
				XTclFreeObj(tls, _objPtr2)
			}
			_objPtr3 = dirPtr
			v8 = _objPtr3
			v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
			*(*TTcl_Size)(unsafe.Pointer(v8))--
			if v7 <= int64(1) {
				XTclFreeObj(tls, _objPtr3)
			}
		} else {
			target = XTcl_FSGetNativePath(tls, *(*uintptr)(unsafe.Pointer(bp)))
			if target == libc.UintptrFromInt32(0) {
				return libc.UintptrFromInt32(0)
			}
			if libc.Xaccess(tls, target, F_OK) == -int32(1) {
				/*
				 * Target doesn't exist.
				 */
				*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = int32(ENOENT)
				return libc.UintptrFromInt32(0)
			}
		}
		if libc.Xaccess(tls, src, F_OK) != -int32(1) {
			/*
			 * Src exists.
			 */
			*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = int32(EEXIST)
			return libc.UintptrFromInt32(0)
		}
		/*
		 * Check symbolic link flag first, since we prefer to create these.
		 */
		if linkAction&int32(TCL_CREATE_SYMBOLIC_LINK) != 0 {
			/*
			 * Now we don't want to link to the absolute, normalized path.
			 * Relative links are quite acceptable (but links to ~user are not
			 * -- these must be expanded first).
			 */
			transPtr = XTcl_FSGetTranslatedPath(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)))
			if transPtr == libc.UintptrFromInt32(0) {
				return libc.UintptrFromInt32(0)
			}
			if (*TTcl_Obj)(unsafe.Pointer(transPtr)).Fbytes != 0 {
				*(*TTcl_Size)(unsafe.Pointer(bp + 232)) = (*TTcl_Obj)(unsafe.Pointer(transPtr)).Flength
				v9 = (*TTcl_Obj)(unsafe.Pointer(transPtr)).Fbytes
			} else {
				v9 = XTcl_GetStringFromObj(tls, transPtr, bp+232)
			}
			target = v9
			if XTcl_UtfToExternalDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), target, *(*TTcl_Size)(unsafe.Pointer(bp + 232)), 0, bp+8, libc.UintptrFromInt32(0)) != TCL_OK {
				XTcl_DStringFree(tls, bp+8)
				return libc.UintptrFromInt32(0)
			}
			target = (*TTcl_DString)(unsafe.Pointer(bp + 8)).Fstring1
			_objPtr4 = transPtr
			v11 = _objPtr4
			v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
			*(*TTcl_Size)(unsafe.Pointer(v11))--
			if v10 <= int64(1) {
				XTclFreeObj(tls, _objPtr4)
			}
			if libc.Xsymlink(tls, target, src) != 0 {
				*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
			}
			XTcl_DStringFree(tls, bp+8)
		} else {
			if linkAction&int32(TCL_CREATE_HARD_LINK) != 0 {
				if libc.Xlink(tls, target, src) != 0 {
					return libc.UintptrFromInt32(0)
				}
			} else {
				*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = int32(ENODEV)
				return libc.UintptrFromInt32(0)
			}
		}
		return *(*uintptr)(unsafe.Pointer(bp))
	} else {
		linkPtr = libc.UintptrFromInt32(0)
		transPtr1 = XTcl_FSGetTranslatedPath(tls, libc.UintptrFromInt32(0), pathPtr)
		if transPtr1 == libc.UintptrFromInt32(0) {
			return libc.UintptrFromInt32(0)
		}
		_objPtr5 = transPtr1
		v13 = _objPtr5
		v12 = *(*TTcl_Size)(unsafe.Pointer(v13))
		*(*TTcl_Size)(unsafe.Pointer(v13))--
		if v12 <= int64(1) {
			XTclFreeObj(tls, _objPtr5)
		}
		length1 = libc.Xreadlink(tls, XTcl_FSGetNativePath(tls, pathPtr), bp+240, uint64(4096))
		if length1 < 0 {
			return libc.UintptrFromInt32(0)
		}
		if XTcl_ExternalToUtfDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), bp+240, libc.Int64FromUint64(libc.Uint64FromInt64(length1)), 0, bp+4336, libc.UintptrFromInt32(0)) != TCL_OK {
			return libc.UintptrFromInt32(0)
		}
		linkPtr = XTcl_DStringToObj(tls, bp+4336)
		(*TTcl_Obj)(unsafe.Pointer(linkPtr)).FrefCount++
		return linkPtr
	}
	return r
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpFilesystemPathType --
 *
 *	This function is part of the native filesystem support, and returns
 *	the path type of the given path. Right now it simply returns NULL. In
 *	the future it could return specific path types, like 'nfs', 'samba',
 *	'FAT32', etc.
 *
 * Results:
 *	NULL at present.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTclpFilesystemPathType(tls *libc.TLS, dummy1056 uintptr) (r uintptr) {
	/*
	 * All native paths are of the same type.
	 */
	return libc.UintptrFromInt32(0)
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpNativeToNormalized --
 *
 *	Convert native format to a normalized path object, with refCount of
 *	zero.
 *
 *	Currently assumes all native paths are actually normalized already, so
 *	if the path given is not normalized this will actually just convert to
 *	a valid string path, but not necessarily a normalized one.
 *
 * Results:
 *	A valid normalized path.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTclpNativeToNormalized(tls *libc.TLS, clientData uintptr) (r uintptr) {
	bp := tls.Alloc(224)
	defer tls.Free(224)
	var _ /* ds at bp+0 */ TTcl_DString
	XTcl_ExternalToUtfDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), clientData, int64(-libc.Int32FromInt32(1)), int32(TCL_ENCODING_PROFILE_TCL8), bp, libc.UintptrFromInt32(0))
	return XTcl_DStringToObj(tls, bp)
}

/*
 *---------------------------------------------------------------------------
 *
 * TclNativeCreateNativeRep --
 *
 *	Create a native representation for the given path.
 *
 * Results:
 *	The nativePath representation.
 *
 * Side effects:
 *	Memory will be allocated. The path may need to be normalized.
 *
 *---------------------------------------------------------------------------
 */

func XTclNativeCreateNativeRep(tls *libc.TLS, pathPtr uintptr) (r uintptr) {
	bp := tls.Alloc(240)
	defer tls.Free(240)
	var _objPtr, _objPtr1, _objPtr2, nativePathPtr, str, validPathPtr, v1, v3, v5, v7 uintptr
	var v2, v4, v6 TTcl_Size
	var _ /* ds at bp+0 */ TTcl_DString
	var _ /* len at bp+224 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, nativePathPtr, str, validPathPtr, v1, v2, v3, v4, v5, v6, v7
	if XTclFSCwdIsNative(tls) != 0 || XTcl_FSGetPathType(tls, pathPtr) == int32(TCL_PATH_ABSOLUTE) {
		/*
		 * The cwd is native (or path is absolute), use the translated path
		 * without worrying about normalization (this will also usually be
		 * shorter so the utf-to-external conversion will be somewhat faster).
		 */
		validPathPtr = XTcl_FSGetTranslatedPath(tls, libc.UintptrFromInt32(0), pathPtr)
		if validPathPtr == libc.UintptrFromInt32(0) {
			return libc.UintptrFromInt32(0)
		}
	} else {
		/*
		 * Make sure the normalized path is set.
		 */
		validPathPtr = XTcl_FSGetNormalizedPath(tls, libc.UintptrFromInt32(0), pathPtr)
		if validPathPtr == libc.UintptrFromInt32(0) {
			return libc.UintptrFromInt32(0)
		}
		(*TTcl_Obj)(unsafe.Pointer(validPathPtr)).FrefCount++
	}
	if (*TTcl_Obj)(unsafe.Pointer(validPathPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 224)) = (*TTcl_Obj)(unsafe.Pointer(validPathPtr)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(validPathPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, validPathPtr, bp+224)
	}
	str = v1
	if XTcl_UtfToExternalDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), str, *(*TTcl_Size)(unsafe.Pointer(bp + 224)), 0, bp, libc.UintptrFromInt32(0)) != TCL_OK {
		_objPtr = validPathPtr
		v3 = _objPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		XTcl_DStringFree(tls, bp)
		return libc.UintptrFromInt32(0)
	}
	*(*TTcl_Size)(unsafe.Pointer(bp + 224)) = libc.Int64FromUint64(libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(bp)).Flength) + uint64(1))
	if libc.Xstrlen(tls, (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1) < libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 224)))-uint64(1) {
		/* See bug [3118489]: NUL in filenames */
		_objPtr1 = validPathPtr
		v5 = _objPtr1
		v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
		*(*TTcl_Size)(unsafe.Pointer(v5))--
		if v4 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		XTcl_DStringFree(tls, bp)
		return libc.UintptrFromInt32(0)
	}
	_objPtr2 = validPathPtr
	v7 = _objPtr2
	v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
	*(*TTcl_Size)(unsafe.Pointer(v7))--
	if v6 <= int64(1) {
		XTclFreeObj(tls, _objPtr2)
	}
	nativePathPtr = XTcl_Alloc(tls, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 224))))
	libc.Xmemcpy(tls, nativePathPtr, (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 224))))
	XTcl_DStringFree(tls, bp)
	return nativePathPtr
}

/*
 *---------------------------------------------------------------------------
 *
 * TclNativeDupInternalRep --
 *
 *	Duplicate the native representation.
 *
 * Results:
 *	The copied native representation, or NULL if it is not possible to
 *	copy the representation.
 *
 * Side effects:
 *	Memory will be allocated for the copy.
 *
 *---------------------------------------------------------------------------
 */

func XTclNativeDupInternalRep(tls *libc.TLS, clientData uintptr) (r uintptr) {
	var copy1 uintptr
	var len1 Tsize_t
	_, _ = copy1, len1
	if clientData == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	/*
	 * ASCII representation when running on Unix.
	 */
	len1 = (libc.Xstrlen(tls, clientData) + uint64(1)) * uint64(1)
	copy1 = XTcl_Alloc(tls, len1)
	libc.Xmemcpy(tls, copy1, clientData, len1)
	return copy1
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpUtime --
 *
 *	Set the modification date for a file.
 *
 * Results:
 *	0 on success, -1 on error.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTclpUtime(tls *libc.TLS, pathPtr uintptr, tval uintptr) (r int32) {
	/* New modification date structure */
	return libc.Xutime(tls, XTcl_FSGetNativePath(tls, pathPtr), tval)
}

const fork = 0

/* Epoch of the tcl environment
 * (if changed with tcl-env). */

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * The following macros convert between TclFile's and fd's. The conversion
 * simple involves shifting fd's up by one to ensure that no valid fd is ever
 * the same as NULL.
 */

/*
 * This structure describes per-instance state of a pipe based channel.
 */

type TPipeState = struct {
	Fchannel       TTcl_Channel
	FinFile        TTclFile
	FoutFile       TTclFile
	FerrorFile     TTclFile
	FnumPids       Tsize_t
	FpidPtr        uintptr
	FisNonBlocking int32
}

/*
 * This structure describes the channel type structure for command pipe based
 * I/O:
 */

var _pipeChannelType = TTcl_ChannelType{
	FtypeName: __ccgo_ts + 47057,
	Fversion:  libc.UintptrFromInt32(0x5),
}

func init() {
	p := unsafe.Pointer(&_pipeChannelType)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_PipeInputProc)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_PipeOutputProc)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(_PipeWatchProc)
	*(*uintptr)(unsafe.Add(p, 72)) = __ccgo_fp(_PipeGetHandleProc)
	*(*uintptr)(unsafe.Add(p, 80)) = __ccgo_fp(_PipeClose2Proc)
	*(*uintptr)(unsafe.Add(p, 88)) = __ccgo_fp(_PipeBlockModeProc)
}

/*
 *----------------------------------------------------------------------
 *
 * TclpMakeFile --
 *
 *	Make a TclFile from a channel.
 *
 * Results:
 *	Returns a new TclFile or NULL on failure.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclpMakeFile(tls *libc.TLS, channel TTcl_Channel, direction int32) (r TTclFile) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Either TCL_READABLE or TCL_WRITABLE. */
	var _ /* data at bp+0 */ uintptr
	if XTcl_GetChannelHandle(tls, channel, direction, bp) != TCL_OK {
		return libc.UintptrFromInt32(0)
	}
	return uintptr(int64(int32(int64(*(*uintptr)(unsafe.Pointer(bp)))) + libc.Int32FromInt32(1)))
}

/*
 *----------------------------------------------------------------------
 *
 * TclpOpenFile --
 *
 *	Open a file for use in a pipeline.
 *
 * Results:
 *	Returns a new TclFile handle or NULL on failure.
 *
 * Side effects:
 *	May cause a file to be created on the file system.
 *
 *----------------------------------------------------------------------
 */

func XTclpOpenFile(tls *libc.TLS, fname uintptr, mode int32) (r TTclFile) {
	bp := tls.Alloc(240)
	defer tls.Free(240) /* In what mode to open the file? */
	var fd int32
	var native uintptr
	var _ /* ds at bp+0 */ TTcl_DString
	_, _ = fd, native
	if XTcl_UtfToExternalDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), fname, int64(-libc.Int32FromInt32(1)), 0, bp, libc.UintptrFromInt32(0)) != TCL_OK {
		XTcl_DStringFree(tls, bp)
		return libc.UintptrFromInt32(0)
	}
	native = (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1
	fd = libc.Xopen(tls, native, mode, libc.VaList(bp+232, int32(0666))) /* INTL: Native. */
	XTcl_DStringFree(tls, bp)
	if fd != -int32(1) {
		libc.Xfcntl(tls, fd, int32(F_SETFD), libc.VaList(bp+232, int32(FD_CLOEXEC)))
		/*
		 * If the file is being opened for writing, seek to the end so we can
		 * append to any data already in the file.
		 */
		if mode&int32(O_WRONLY) != 0 && !(mode&libc.Int32FromInt32(O_APPEND) != 0) {
			libc.Xlseek(tls, fd, 0, int32(2))
		}
		/*
		 * Increment the fd so it can't be 0, which would conflict with the
		 * NULL return for errors.
		 */
		return uintptr(int64(fd + libc.Int32FromInt32(1)))
	}
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * TclpCreateTempFile --
 *
 *	This function creates a temporary file initialized with an optional
 *	string, and returns a file handle with the file pointer at the
 *	beginning of the file.
 *
 * Results:
 *	A handle to a file.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclpCreateTempFile(tls *libc.TLS, contents uintptr) (r TTclFile) {
	bp := tls.Alloc(240)
	defer tls.Free(240) /* String to write into temp file, or NULL. */
	var fd int32
	var native uintptr
	var _ /* dstring at bp+0 */ TTcl_DString
	_, _ = fd, native
	fd = XTclUnixOpenTemporaryFile(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	if fd == -int32(1) {
		return libc.UintptrFromInt32(0)
	}
	libc.Xfcntl(tls, fd, int32(F_SETFD), libc.VaList(bp+232, int32(FD_CLOEXEC)))
	if contents != libc.UintptrFromInt32(0) {
		if XTcl_UtfToExternalDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), contents, int64(-libc.Int32FromInt32(1)), 0, bp, libc.UintptrFromInt32(0)) != TCL_OK {
			libc.Xclose(tls, fd)
			XTcl_DStringFree(tls, bp)
			return libc.UintptrFromInt32(0)
		}
		native = (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1
		if libc.Xwrite(tls, fd, native, libc.Uint64FromInt64((*TTcl_DString)(unsafe.Pointer(bp)).Flength)) == int64(-int32(1)) {
			libc.Xclose(tls, fd)
			XTcl_DStringFree(tls, bp)
			return libc.UintptrFromInt32(0)
		}
		XTcl_DStringFree(tls, bp)
		libc.Xlseek(tls, fd, 0, 0)
	}
	return uintptr(int64(fd + libc.Int32FromInt32(1)))
}

/*
 *----------------------------------------------------------------------
 *
 * TclpTempFileName --
 *
 *	This function returns unique filename.
 *
 * Results:
 *	Returns a valid Tcl_Obj* with refCount 0, or NULL on failure.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclpTempFileName(tls *libc.TLS) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, _objPtr1, cachePtr, nameObj, retVal, v3, v5 uintptr
	var fd int32
	var v1 bool
	var v2, v4 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, fd, nameObj, retVal, v1, v2, v3, v4, v5
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		nameObj = XTclThreadAllocObj(tls)
	} else {
		nameObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(nameObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(nameObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(nameObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(nameObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(nameObj)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer(nameObj)).FrefCount++
	fd = XTclUnixOpenTemporaryFile(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), nameObj)
	if fd == -int32(1) {
		_objPtr = nameObj
		v3 = _objPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		return libc.UintptrFromInt32(0)
	}
	libc.Xfcntl(tls, fd, int32(F_SETFD), libc.VaList(bp+8, int32(FD_CLOEXEC)))
	XTclpObjDeleteFile(tls, nameObj)
	libc.Xclose(tls, fd)
	retVal = XTcl_DuplicateObj(tls, nameObj)
	_objPtr1 = nameObj
	v5 = _objPtr1
	v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
	*(*TTcl_Size)(unsafe.Pointer(v5))--
	if v4 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	return retVal
}

/*
 *----------------------------------------------------------------------------
 *
 * TclpTempFileNameForLibrary --
 *
 *	Constructs a file name in the native file system where a dynamically
 *	loaded library may be placed.
 *
 * Results:
 *	Returns the constructed file name. If an error occurs, returns NULL
 *	and leaves an error message in the interpreter result.
 *
 * On Unix, it works to load a shared object from a file of any name, so this
 * function is merely a thin wrapper around TclpTempFileName().
 *
 *----------------------------------------------------------------------------
 */

func XTclpTempFileNameForLibrary(tls *libc.TLS, interp uintptr, dummy292 uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var retval uintptr
	_ = retval
	retval = XTclpTempFileName(tls)
	if retval == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+76067, libc.VaList(bp+8, XTcl_PosixError(tls, interp))))
	}
	return retval
}

/*
 *----------------------------------------------------------------------
 *
 * TclpCreatePipe --
 *
 *	Creates a pipe - simply calls the pipe() function.
 *
 * Results:
 *	Returns 1 on success, 0 on failure.
 *
 * Side effects:
 *	Creates a pipe.
 *
 *----------------------------------------------------------------------
 */

func XTclpCreatePipe(tls *libc.TLS, readPipe uintptr, writePipe uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Location to store file handle for write
	 * side of pipe. */
	var _ /* pipeIds at bp+0 */ [2]int32
	if libc.Xpipe(tls, bp) != 0 {
		return 0
	}
	libc.Xfcntl(tls, (*(*[2]int32)(unsafe.Pointer(bp)))[0], int32(F_SETFD), libc.VaList(bp+16, int32(FD_CLOEXEC)))
	libc.Xfcntl(tls, (*(*[2]int32)(unsafe.Pointer(bp)))[int32(1)], int32(F_SETFD), libc.VaList(bp+16, int32(FD_CLOEXEC)))
	*(*TTclFile)(unsafe.Pointer(readPipe)) = uintptr(int64((*(*[2]int32)(unsafe.Pointer(bp)))[0] + libc.Int32FromInt32(1)))
	*(*TTclFile)(unsafe.Pointer(writePipe)) = uintptr(int64((*(*[2]int32)(unsafe.Pointer(bp)))[int32(1)] + libc.Int32FromInt32(1)))
	return int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * TclpCloseFile --
 *
 *	Implements a mechanism to close a UNIX file.
 *
 * Results:
 *	Returns 0 on success, or -1 on error, setting errno.
 *
 * Side effects:
 *	The file is closed.
 *
 *----------------------------------------------------------------------
 */

func XTclpCloseFile(tls *libc.TLS, file TTclFile) (r int32) {
	/* The file to close. */
	var fd int32
	_ = fd
	fd = int32(int64(file) - libc.Int64FromInt32(1))
	/*
	 * Refuse to close the fds for stdin, stdout and stderr.
	 */
	if fd == 0 || fd == int32(1) || fd == int32(2) {
		return 0
	}
	XTcl_DeleteFileHandler(tls, fd)
	return libc.Xclose(tls, fd)
}

/*
 *----------------------------------------------------------------------
 *
 * RestoreSignals --
 *
 *	This function is invoked in a forked child process just before
 *	exec-ing a new program to restore all signals to their default
 *	settings.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Signal settings get changed.
 *
 *----------------------------------------------------------------------
 */

func _RestoreSignals(tls *libc.TLS) {
	libc.Xsignal(tls, int32(SIGABRT), libc.UintptrFromInt32(0))
	libc.Xsignal(tls, int32(SIGALRM), libc.UintptrFromInt32(0))
	libc.Xsignal(tls, int32(SIGFPE), libc.UintptrFromInt32(0))
	libc.Xsignal(tls, int32(SIGHUP), libc.UintptrFromInt32(0))
	libc.Xsignal(tls, int32(SIGILL), libc.UintptrFromInt32(0))
	libc.Xsignal(tls, int32(SIGINT), libc.UintptrFromInt32(0))
	libc.Xsignal(tls, int32(SIGPIPE), libc.UintptrFromInt32(0))
	libc.Xsignal(tls, int32(SIGQUIT), libc.UintptrFromInt32(0))
	libc.Xsignal(tls, int32(SIGSEGV), libc.UintptrFromInt32(0))
	libc.Xsignal(tls, int32(SIGTERM), libc.UintptrFromInt32(0))
	libc.Xsignal(tls, int32(SIGUSR1), libc.UintptrFromInt32(0))
	libc.Xsignal(tls, int32(SIGUSR2), libc.UintptrFromInt32(0))
	libc.Xsignal(tls, int32(SIGCHLD), libc.UintptrFromInt32(0))
	libc.Xsignal(tls, int32(SIGCONT), libc.UintptrFromInt32(0))
	libc.Xsignal(tls, int32(SIGTSTP), libc.UintptrFromInt32(0))
	libc.Xsignal(tls, int32(SIGTTIN), libc.UintptrFromInt32(0))
	libc.Xsignal(tls, int32(SIGTTOU), libc.UintptrFromInt32(0))
}

/*
 *----------------------------------------------------------------------
 *
 * SetupStdFile --
 *
 *	Set up stdio file handles for the child process, using the current
 *	standard channels if no other files are specified. If no standard
 *	channel is defined, or if no file is associated with the channel, then
 *	the corresponding standard fd is closed.
 *
 * Results:
 *	Returns 1 on success, or 0 on failure.
 *
 * Side effects:
 *	Replaces stdio fds.
 *
 *----------------------------------------------------------------------
 */

func _SetupStdFile(tls *libc.TLS, file TTclFile, type1 int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR */
	var channel TTcl_Channel
	var direction, fd, targetFd int32
	_, _, _, _ = channel, direction, fd, targetFd
	targetFd = 0  /* Initializations here needed only to */
	direction = 0 /* prevent warnings about using uninitialized
	 * variables. */
	switch type1 {
	case libc.Int32FromInt32(1) << libc.Int32FromInt32(1):
		targetFd = 0
		direction = libc.Int32FromInt32(1) << libc.Int32FromInt32(1)
	case libc.Int32FromInt32(1) << libc.Int32FromInt32(2):
		targetFd = int32(1)
		direction = libc.Int32FromInt32(1) << libc.Int32FromInt32(2)
	case libc.Int32FromInt32(1) << libc.Int32FromInt32(3):
		targetFd = int32(2)
		direction = libc.Int32FromInt32(1) << libc.Int32FromInt32(2)
		break
	}
	if !(file != 0) {
		channel = XTcl_GetStdChannel(tls, type1)
		if channel != 0 {
			file = XTclpMakeFile(tls, channel, direction)
		}
	}
	if file != 0 {
		fd = int32(int64(file) - libc.Int64FromInt32(1))
		if fd != targetFd {
			if libc.Xdup2(tls, fd, targetFd) == -int32(1) {
				return 0
			}
			/*
			 * Must clear the close-on-exec flag for the target FD, since some
			 * systems (e.g. Ultrix) do not clear the CLOEXEC flag on the
			 * target FD.
			 */
			libc.Xfcntl(tls, targetFd, int32(F_SETFD), libc.VaList(bp+8, 0))
		} else {
			/*
			 * Since we aren't dup'ing the file, we need to explicitly clear
			 * the close-on-exec flag.
			 */
			libc.Xfcntl(tls, fd, int32(F_SETFD), libc.VaList(bp+8, 0))
		}
	} else {
		libc.Xclose(tls, targetFd)
	}
	return int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * TclpCreateCommandChannel --
 *
 *	This function is called by the generic IO level to perform the
 *	platform specific channel initialization for a command channel.
 *
 * Results:
 *	Returns a new channel or NULL on failure.
 *
 * Side effects:
 *	Allocates a new channel.
 *
 *----------------------------------------------------------------------
 */

func XTclpCreateCommandChannel(tls *libc.TLS, readFile TTclFile, writeFile TTclFile, errorFile TTclFile, numPids Tsize_t, pidPtr uintptr) (r TTcl_Channel) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* An array of process identifiers. Allocated
	 * by the caller, freed when the channel is
	 * closed or the processes are detached (in a
	 * background exec). */
	var fd, mode int32
	var statePtr uintptr
	var _ /* channelName at bp+0 */ [40]uint8
	_, _, _ = fd, mode, statePtr
	statePtr = XTcl_Alloc(tls, uint64(56))
	(*TPipeState)(unsafe.Pointer(statePtr)).FinFile = readFile
	(*TPipeState)(unsafe.Pointer(statePtr)).FoutFile = writeFile
	(*TPipeState)(unsafe.Pointer(statePtr)).FerrorFile = errorFile
	(*TPipeState)(unsafe.Pointer(statePtr)).FnumPids = numPids
	(*TPipeState)(unsafe.Pointer(statePtr)).FpidPtr = pidPtr
	(*TPipeState)(unsafe.Pointer(statePtr)).FisNonBlocking = 0
	mode = 0
	if readFile != 0 {
		mode |= libc.Int32FromInt32(1) << libc.Int32FromInt32(1)
	}
	if writeFile != 0 {
		mode |= libc.Int32FromInt32(1) << libc.Int32FromInt32(2)
	}
	/*
	 * Use one of the fds associated with the channel as the channel id.
	 */
	if readFile != 0 {
		fd = int32(int64(readFile) - libc.Int64FromInt32(1))
	} else {
		if writeFile != 0 {
			fd = int32(int64(writeFile) - libc.Int64FromInt32(1))
		} else {
			if errorFile != 0 {
				fd = int32(int64(errorFile) - libc.Int64FromInt32(1))
			} else {
				fd = 0
			}
		}
	}
	/*
	 * For backward compatibility with previous versions of Tcl, we use
	 * "file%d" as the base name for pipes even though it would be more
	 * natural to use "pipe%d".
	 */
	libc.X__builtin_snprintf(tls, bp, uint64(40), __ccgo_ts+75412, libc.VaList(bp+48, fd))
	(*TPipeState)(unsafe.Pointer(statePtr)).Fchannel = XTcl_CreateChannel(tls, uintptr(unsafe.Pointer(&_pipeChannelType)), bp, statePtr, mode)
	return (*TPipeState)(unsafe.Pointer(statePtr)).Fchannel
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_CreatePipe --
 *
 *	System dependent interface to create a pipe for the [chan pipe]
 *	command. Stolen from TclX.
 *
 * Results:
 *	TCL_OK or TCL_ERROR.
 *
 * Side effects:
 *	Registers two channels.
 *
 *----------------------------------------------------------------------
 */

func XTcl_CreatePipe(tls *libc.TLS, interp uintptr, rchan uintptr, wchan uintptr, dummy914 int32) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Reserved for future use. */
	var _ /* fileNums at bp+0 */ [2]int32
	if libc.Xpipe(tls, bp) < 0 {
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+76102, libc.VaList(bp+16, XTcl_PosixError(tls, interp))))
		return int32(TCL_ERROR)
	}
	libc.Xfcntl(tls, (*(*[2]int32)(unsafe.Pointer(bp)))[0], int32(F_SETFD), libc.VaList(bp+16, int32(FD_CLOEXEC)))
	libc.Xfcntl(tls, (*(*[2]int32)(unsafe.Pointer(bp)))[int32(1)], int32(F_SETFD), libc.VaList(bp+16, int32(FD_CLOEXEC)))
	*(*TTcl_Channel)(unsafe.Pointer(rchan)) = XTcl_MakeFileChannel(tls, uintptr(int64((*(*[2]int32)(unsafe.Pointer(bp)))[0])), libc.Int32FromInt32(1)<<libc.Int32FromInt32(1))
	XTcl_RegisterChannel(tls, interp, *(*TTcl_Channel)(unsafe.Pointer(rchan)))
	*(*TTcl_Channel)(unsafe.Pointer(wchan)) = XTcl_MakeFileChannel(tls, uintptr(int64((*(*[2]int32)(unsafe.Pointer(bp)))[int32(1)])), libc.Int32FromInt32(1)<<libc.Int32FromInt32(2))
	XTcl_RegisterChannel(tls, interp, *(*TTcl_Channel)(unsafe.Pointer(wchan)))
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclGetAndDetachPids --
 *
 *	This function is invoked in the generic implementation of a
 *	background "exec" (an exec when invoked with a terminating "&") to
 *	store a list of the PIDs for processes in a command pipeline in the
 *	interp's result and to detach the processes.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Modifies the interp's result. Detaches processes.
 *
 *----------------------------------------------------------------------
 */

func XTclGetAndDetachPids(tls *libc.TLS, interp uintptr, chan1 TTcl_Channel) {
	/* Handle for the pipeline. */
	var cachePtr, chanTypePtr, pidsObj, pipePtr uintptr
	var i Tsize_t
	var v1 bool
	_, _, _, _, _, _ = cachePtr, chanTypePtr, i, pidsObj, pipePtr, v1
	/*
	 * Punt if the channel is not a command channel.
	 */
	chanTypePtr = XTcl_GetChannelType(tls, chan1)
	if chanTypePtr != uintptr(unsafe.Pointer(&_pipeChannelType)) {
		return
	}
	pipePtr = XTcl_GetChannelInstanceData(tls, chan1)
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		pidsObj = XTclThreadAllocObj(tls)
	} else {
		pidsObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(pidsObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(pidsObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(pidsObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(pidsObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(pidsObj)).FtypePtr = libc.UintptrFromInt32(0)
	i = uint64(0)
	for {
		if !(i < (*TPipeState)(unsafe.Pointer(pipePtr)).FnumPids) {
			break
		}
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), pidsObj, XTcl_NewWideIntObj(tls, int64(*(*TTcl_Pid)(unsafe.Pointer((*TPipeState)(unsafe.Pointer(pipePtr)).FpidPtr + uintptr(i)*8)))))
		XTcl_DetachPids(tls, int64(1), (*TPipeState)(unsafe.Pointer(pipePtr)).FpidPtr+uintptr(i)*8)
		goto _2
	_2:
		;
		i++
	}
	XTcl_SetObjResult(tls, interp, pidsObj)
	if (*TPipeState)(unsafe.Pointer(pipePtr)).FnumPids > uint64(0) {
		XTclpFree(tls, (*TPipeState)(unsafe.Pointer(pipePtr)).FpidPtr)
		(*TPipeState)(unsafe.Pointer(pipePtr)).FnumPids = uint64(0)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * PipeBlockModeProc --
 *
 *	Helper function to set blocking and nonblocking modes on a pipe based
 *	channel. Invoked by generic IO level code.
 *
 * Results:
 *	0 if successful, errno when failed.
 *
 * Side effects:
 *	Sets the device into blocking or non-blocking mode.
 *
 *----------------------------------------------------------------------
 */

func _PipeBlockModeProc(tls *libc.TLS, instanceData uintptr, mode int32) (r int32) {
	/* The mode to set. Can be one of
	 * TCL_MODE_BLOCKING or
	 * TCL_MODE_NONBLOCKING. */
	var psPtr uintptr
	_ = psPtr
	psPtr = instanceData
	if (*TPipeState)(unsafe.Pointer(psPtr)).FinFile != 0 && XTclUnixSetBlockingMode(tls, int32(int64((*TPipeState)(unsafe.Pointer(psPtr)).FinFile)-libc.Int64FromInt32(1)), mode) < 0 {
		return *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))
	}
	if (*TPipeState)(unsafe.Pointer(psPtr)).FoutFile != 0 && XTclUnixSetBlockingMode(tls, int32(int64((*TPipeState)(unsafe.Pointer(psPtr)).FoutFile)-libc.Int64FromInt32(1)), mode) < 0 {
		return *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))
	}
	(*TPipeState)(unsafe.Pointer(psPtr)).FisNonBlocking = libc.BoolInt32(mode == int32(TCL_MODE_NONBLOCKING))
	return 0
}

/*
 *----------------------------------------------------------------------
 *
 * PipeClose2Proc
 *
 *	This function is invoked by the generic IO level to perform
 *	pipeline-type-specific half or full-close.
 *
 * Results:
 *	0 on success, errno otherwise.
 *
 * Side effects:
 *	Closes the command pipeline channel.
 *
 *----------------------------------------------------------------------
 */

func _PipeClose2Proc(tls *libc.TLS, instanceData uintptr, interp uintptr, flags int32) (r int32) {
	/* Flags that indicate which side to close. */
	var errChan TTcl_Channel
	var errorCode, result int32
	var pipePtr uintptr
	_, _, _, _ = errChan, errorCode, pipePtr, result
	pipePtr = instanceData
	errorCode = 0
	result = 0
	if (!(flags != 0) || flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0) && (*TPipeState)(unsafe.Pointer(pipePtr)).FinFile != libc.UintptrFromInt32(0) {
		if XTclpCloseFile(tls, (*TPipeState)(unsafe.Pointer(pipePtr)).FinFile) < 0 {
			errorCode = *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))
		} else {
			(*TPipeState)(unsafe.Pointer(pipePtr)).FinFile = libc.UintptrFromInt32(0)
		}
	}
	if (!(flags != 0) || flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0) && (*TPipeState)(unsafe.Pointer(pipePtr)).FoutFile != libc.UintptrFromInt32(0) && errorCode == 0 {
		if XTclpCloseFile(tls, (*TPipeState)(unsafe.Pointer(pipePtr)).FoutFile) < 0 {
			errorCode = *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))
		} else {
			(*TPipeState)(unsafe.Pointer(pipePtr)).FoutFile = libc.UintptrFromInt32(0)
		}
	}
	/*
	 * If half-closing, stop here.
	 */
	if flags != 0 {
		return errorCode
	}
	if (*TPipeState)(unsafe.Pointer(pipePtr)).FisNonBlocking != 0 || XTclInExit(tls) != 0 {
		/*
		 * If the channel is non-blocking or Tcl is being cleaned up, just
		 * detach the children PIDs, reap them (important if we are in a
		 * dynamic load module), and discard the errorFile.
		 */
		XTcl_DetachPids(tls, libc.Int64FromUint64((*TPipeState)(unsafe.Pointer(pipePtr)).FnumPids), (*TPipeState)(unsafe.Pointer(pipePtr)).FpidPtr)
		XTcl_ReapDetachedProcs(tls)
		if (*TPipeState)(unsafe.Pointer(pipePtr)).FerrorFile != 0 {
			XTclpCloseFile(tls, (*TPipeState)(unsafe.Pointer(pipePtr)).FerrorFile)
		}
	} else {
		/*
		 * Wrap the error file into a channel and give it to the cleanup
		 * routine.
		 */
		if (*TPipeState)(unsafe.Pointer(pipePtr)).FerrorFile != 0 {
			errChan = XTcl_MakeFileChannel(tls, uintptr(int64((*TPipeState)(unsafe.Pointer(pipePtr)).FerrorFile)-libc.Int64FromInt32(1)), libc.Int32FromInt32(1)<<libc.Int32FromInt32(1))
			/* Error channels should not raise encoding errors */
			XTcl_SetChannelOption(tls, libc.UintptrFromInt32(0), errChan, __ccgo_ts+15022, __ccgo_ts+19738)
		} else {
			errChan = libc.UintptrFromInt32(0)
		}
		result = XTclCleanupChildren(tls, interp, libc.Int64FromUint64((*TPipeState)(unsafe.Pointer(pipePtr)).FnumPids), (*TPipeState)(unsafe.Pointer(pipePtr)).FpidPtr, errChan)
	}
	if (*TPipeState)(unsafe.Pointer(pipePtr)).FnumPids != uint64(0) {
		XTclpFree(tls, (*TPipeState)(unsafe.Pointer(pipePtr)).FpidPtr)
	}
	XTclpFree(tls, pipePtr)
	if errorCode == 0 {
		return result
	}
	return errorCode
}

/*
 *----------------------------------------------------------------------
 *
 * PipeInputProc --
 *
 *	This function is invoked from the generic IO level to read input from
 *	a command pipeline based channel.
 *
 * Results:
 *	The number of bytes read is returned or -1 on error. An output
 *	argument contains a POSIX error code if an error occurs, or zero.
 *
 * Side effects:
 *	Reads input from the input device of the channel.
 *
 *----------------------------------------------------------------------
 */

func _PipeInputProc(tls *libc.TLS, instanceData uintptr, buf uintptr, toRead int32, errorCodePtr uintptr) (r int32) {
	/* Where to store error code. */
	var bytesRead int32
	var psPtr uintptr
	_, _ = bytesRead, psPtr
	psPtr = instanceData /* How many bytes were actually read from the
	 * input device? */
	*(*int32)(unsafe.Pointer(errorCodePtr)) = 0
	/*
	 * Assume there is always enough input available. This will block
	 * appropriately, and read will unblock as soon as a short read is
	 * possible, if the channel is in blocking mode. If the channel is
	 * nonblocking, the read will never block. Some OSes can throw an
	 * interrupt error, for which we should immediately retry. [Bug #415131]
	 */
	for cond := true; cond; cond = bytesRead < 0 && *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(EINTR) {
		bytesRead = int32(libc.Xread(tls, int32(int64((*TPipeState)(unsafe.Pointer(psPtr)).FinFile)-libc.Int64FromInt32(1)), buf, libc.Uint64FromInt32(toRead)))
	}
	if bytesRead < 0 {
		*(*int32)(unsafe.Pointer(errorCodePtr)) = *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))
		return -int32(1)
	}
	return bytesRead
}

/*
 *----------------------------------------------------------------------
 *
 * PipeOutputProc--
 *
 *	This function is invoked from the generic IO level to write output to
 *	a command pipeline based channel.
 *
 * Results:
 *	The number of bytes written is returned or -1 on error. An output
 *	argument contains a POSIX error code if an error occurred, or zero.
 *
 * Side effects:
 *	Writes output on the output device of the channel.
 *
 *----------------------------------------------------------------------
 */

func _PipeOutputProc(tls *libc.TLS, instanceData uintptr, buf uintptr, toWrite int32, errorCodePtr uintptr) (r int32) {
	/* Where to store error code. */
	var psPtr uintptr
	var written int32
	_, _ = psPtr, written
	psPtr = instanceData
	*(*int32)(unsafe.Pointer(errorCodePtr)) = 0
	/*
	 * Some OSes can throw an interrupt error, for which we should immediately
	 * retry. [Bug #415131]
	 */
	for cond := true; cond; cond = written < 0 && *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(EINTR) {
		written = int32(libc.Xwrite(tls, int32(int64((*TPipeState)(unsafe.Pointer(psPtr)).FoutFile)-libc.Int64FromInt32(1)), buf, libc.Uint64FromInt32(toWrite)))
	}
	if written < 0 {
		*(*int32)(unsafe.Pointer(errorCodePtr)) = *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))
		return -int32(1)
	}
	return written
}

/*
 *----------------------------------------------------------------------
 *
 * PipeWatchProc --
 *
 *	Initialize the notifier to watch the fds from this channel.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Sets up the notifier so that a future event on the channel will be
 *	seen by Tcl.
 *
 *----------------------------------------------------------------------
 */

/*
 * Bug ad5a57f2f271: Tcl_NotifyChannel is not a Tcl_FileProc,
 * so do not pass it to directly to Tcl_CreateFileHandler.
 * Instead, pass a wrapper which is a Tcl_FileProc.
 */

func _PipeWatchNotifyChannelWrapper(tls *libc.TLS, clientData uintptr, mask int32) {
	var channel TTcl_Channel
	_ = channel
	channel = clientData
	XTcl_NotifyChannel(tls, channel, mask)
}

func _PipeWatchProc(tls *libc.TLS, instanceData uintptr, mask int32) {
	/* Events of interest; an OR-ed combination of
	 * TCL_READABLE, TCL_WRITABLE and
	 * TCL_EXCEPTION. */
	var newmask int32
	var psPtr uintptr
	_, _ = newmask, psPtr
	psPtr = instanceData
	if (*TPipeState)(unsafe.Pointer(psPtr)).FinFile != 0 {
		newmask = mask & (libc.Int32FromInt32(1)<<libc.Int32FromInt32(1) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(3))
		if newmask != 0 {
			XTcl_CreateFileHandler(tls, int32(int64((*TPipeState)(unsafe.Pointer(psPtr)).FinFile)-libc.Int64FromInt32(1)), newmask, __ccgo_fp(_PipeWatchNotifyChannelWrapper), (*TPipeState)(unsafe.Pointer(psPtr)).Fchannel)
		} else {
			XTcl_DeleteFileHandler(tls, int32(int64((*TPipeState)(unsafe.Pointer(psPtr)).FinFile)-libc.Int64FromInt32(1)))
		}
	}
	if (*TPipeState)(unsafe.Pointer(psPtr)).FoutFile != 0 {
		newmask = mask & (libc.Int32FromInt32(1)<<libc.Int32FromInt32(2) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(3))
		if newmask != 0 {
			XTcl_CreateFileHandler(tls, int32(int64((*TPipeState)(unsafe.Pointer(psPtr)).FoutFile)-libc.Int64FromInt32(1)), newmask, __ccgo_fp(_PipeWatchNotifyChannelWrapper), (*TPipeState)(unsafe.Pointer(psPtr)).Fchannel)
		} else {
			XTcl_DeleteFileHandler(tls, int32(int64((*TPipeState)(unsafe.Pointer(psPtr)).FoutFile)-libc.Int64FromInt32(1)))
		}
	}
}

/*
 *----------------------------------------------------------------------
 *
 * PipeGetHandleProc --
 *
 *	Called from Tcl_GetChannelHandle to retrieve OS handles from inside a
 *	command pipeline based channel.
 *
 * Results:
 *	Returns TCL_OK with the fd in handlePtr, or TCL_ERROR if there is no
 *	handle for the specified direction.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _PipeGetHandleProc(tls *libc.TLS, instanceData uintptr, direction int32, handlePtr uintptr) (r int32) {
	/* Where to store the handle. */
	var psPtr uintptr
	_ = psPtr
	psPtr = instanceData
	if direction == libc.Int32FromInt32(1)<<libc.Int32FromInt32(1) && (*TPipeState)(unsafe.Pointer(psPtr)).FinFile != 0 {
		*(*uintptr)(unsafe.Pointer(handlePtr)) = uintptr(int64((*TPipeState)(unsafe.Pointer(psPtr)).FinFile) - libc.Int64FromInt32(1))
		return TCL_OK
	}
	if direction == libc.Int32FromInt32(1)<<libc.Int32FromInt32(2) && (*TPipeState)(unsafe.Pointer(psPtr)).FoutFile != 0 {
		*(*uintptr)(unsafe.Pointer(handlePtr)) = uintptr(int64((*TPipeState)(unsafe.Pointer(psPtr)).FoutFile) - libc.Int64FromInt32(1))
		return TCL_OK
	}
	return int32(TCL_ERROR)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_WaitPid --
 *
 *	Implements the waitpid system call on Unix systems.
 *
 * Results:
 *	Result of calling waitpid.
 *
 * Side effects:
 *	Waits for a process to terminate.
 *
 *----------------------------------------------------------------------
 */

func XTcl_WaitPid(tls *libc.TLS, pid TTcl_Pid, statPtr uintptr, options int32) (r TTcl_Pid) {
	var real_pid Tpid_t
	var result int32
	_, _ = real_pid, result
	real_pid = int32(int64(pid))
	for int32(1) != 0 {
		result = libc.Xwaitpid(tls, real_pid, statPtr, options)
		if result != -int32(1) || *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) != int32(EINTR) {
			return uintptr(int64(result))
		}
	}
	return r
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_PidObjCmd --
 *
 *	This function is invoked to process the "pid" Tcl command. See the
 *	user documentation for details on what it does.
 *
 * Results:
 *	A standard Tcl result.
 *
 * Side effects:
 *	See the user documentation.
 *
 *----------------------------------------------------------------------
 */

func XTcl_PidObjCmd(tls *libc.TLS, dummy1372 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	/* Argument strings. */
	var cachePtr, pipePtr, resultPtr, v1 uintptr
	var chan1 TTcl_Channel
	var i Tsize_t
	var v2 bool
	_, _, _, _, _, _, _ = cachePtr, chan1, i, pipePtr, resultPtr, v1, v2
	if objc > int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+76127)
		return int32(TCL_ERROR)
	}
	if objc == int32(1) {
		XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, int64(libc.Xgetpid(tls))))
	} else {
		/*
		 * Get the channel and make sure that it refers to a pipe.
		 */
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
		}
		chan1 = XTcl_GetChannel(tls, interp, v1, libc.UintptrFromInt32(0))
		if chan1 == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
		if XTcl_GetChannelType(tls, chan1) != uintptr(unsafe.Pointer(&_pipeChannelType)) {
			return TCL_OK
		}
		/*
		 * Extract the process IDs from the pipe structure.
		 */
		pipePtr = XTcl_GetChannelInstanceData(tls, chan1)
		if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			resultPtr = XTclThreadAllocObj(tls)
		} else {
			resultPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(resultPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(resultPtr)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(resultPtr)).FtypePtr = libc.UintptrFromInt32(0)
		i = uint64(0)
		for {
			if !(i < (*TPipeState)(unsafe.Pointer(pipePtr)).FnumPids) {
				break
			}
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultPtr, XTcl_NewWideIntObj(tls, int64(*(*TTcl_Pid)(unsafe.Pointer((*TPipeState)(unsafe.Pointer(pipePtr)).FpidPtr + uintptr(i)*8)))))
			goto _3
		_3:
			;
			i++
		}
		XTcl_SetObjResult(tls, interp, resultPtr)
	}
	return TCL_OK
}

/*
 *----------------------------------------------------------------------
 *
 * TclpFinalizePipes --
 *
 *	Cleans up the pipe subsystem from Tcl_FinalizeThread
 *
 * Results:
 *	None.
 *
 * Notes:
 *	This function carries out no operation on Unix.
 *
 *----------------------------------------------------------------------
 */

func XTclpFinalizePipes(tls *libc.TLS) {
}

const MAXRETRY = 10
const SOCKET_BUFSIZE = 4096
const SOCK_CHAN_LENGTH = 5
const SOL_TCP = 6
const SUPPRESS_RDNS_VAR = "::tcl::unsupported::noReverseDNS"
const TCPI_OPT_ECN = 8
const TCPI_OPT_SACK = 2
const TCPI_OPT_TIMESTAMPS = 1
const TCPI_OPT_WSCALE = 4
const TCPOLEN_MAXSEG = 4
const TCPOLEN_SACK_PERMITTED = 2
const TCPOLEN_TIMESTAMP = 10
const TCPOLEN_WINDOW = 3
const TCPOPT_EOL = 0
const TCPOPT_MAXSEG = 2
const TCPOPT_NOP = 1
const TCPOPT_SACK = 5
const TCPOPT_SACK_PERMITTED = 4
const TCPOPT_TIMESTAMP = 8
const TCPOPT_WINDOW = 3
const TCP_ASYNC_CONNECT = 2
const TCP_ASYNC_FAILED = 32
const TCP_ASYNC_PENDING = 16
const TCP_ASYNC_TEST_MODE = 256
const TCP_CA_CWR = 2
const TCP_CA_Disorder = 1
const TCP_CA_Loss = 4
const TCP_CA_Open = 0
const TCP_CA_Recovery = 3
const TCP_CC_INFO = 26
const TCP_CLOSE = 7
const TCP_CLOSE_WAIT = 8
const TCP_CLOSING = 11
const TCP_CM_INQ = 36
const TCP_CONGESTION = 13
const TCP_CORK = 3
const TCP_DEFER_ACCEPT = 9
const TCP_ESTABLISHED = 1
const TCP_FASTOPEN = 23
const TCP_FASTOPEN_CONNECT = 30
const TCP_FASTOPEN_KEY = 33
const TCP_FASTOPEN_NO_COOKIE = 34
const TCP_FIN_WAIT1 = 4
const TCP_FIN_WAIT2 = 5
const TCP_INFO = 11
const TCP_INQ = 36
const TCP_KEEPCNT = 6
const TCP_KEEPIDLE = 4
const TCP_KEEPINTVL = 5
const TCP_LAST_ACK = 9
const TCP_LINGER2 = 8
const TCP_LISTEN = 10
const TCP_MAXSEG = 2
const TCP_MD5SIG = 14
const TCP_MD5SIG_EXT = 32
const TCP_MD5SIG_FLAG_IFINDEX = 2
const TCP_MD5SIG_FLAG_PREFIX = 1
const TCP_MD5SIG_MAXKEYLEN = 80
const TCP_NODELAY = 1
const TCP_NONBLOCKING = 1
const TCP_NOTSENT_LOWAT = 25
const TCP_QUEUE_SEQ = 21
const TCP_QUICKACK = 12
const TCP_RECEIVE_ZEROCOPY_FLAG_TLB_CLEAN_HINT = 1
const TCP_REPAIR = 19
const TCP_REPAIR_OFF = 0
const TCP_REPAIR_OFF_NO_WP = -1
const TCP_REPAIR_ON = 1
const TCP_REPAIR_OPTIONS = 22
const TCP_REPAIR_QUEUE = 20
const TCP_REPAIR_WINDOW = 29
const TCP_SAVED_SYN = 28
const TCP_SAVE_SYN = 27
const TCP_SYNCNT = 7
const TCP_SYN_RECV = 3
const TCP_SYN_SENT = 2
const TCP_THIN_DUPACK = 17
const TCP_THIN_LINEAR_TIMEOUTS = 16
const TCP_TIMESTAMP = 24
const TCP_TIME_WAIT = 6
const TCP_TX_DELAY = 37
const TCP_ULP = 31
const TCP_USER_TIMEOUT = 18
const TCP_WINDOW_CLAMP = 10
const TCP_ZEROCOPY_RECEIVE = 35
const TH_ACK = 16
const TH_FIN = 1
const TH_PUSH = 8
const TH_RST = 4
const TH_SYN = 2
const TH_URG = 32

const TCP_NLA_PAD = 0
const TCP_NLA_BUSY = 1
const TCP_NLA_RWND_LIMITED = 2
const TCP_NLA_SNDBUF_LIMITED = 3
const TCP_NLA_DATA_SEGS_OUT = 4
const TCP_NLA_TOTAL_RETRANS = 5
const TCP_NLA_PACING_RATE = 6
const TCP_NLA_DELIVERY_RATE = 7
const TCP_NLA_SND_CWND = 8
const TCP_NLA_REORDERING = 9
const TCP_NLA_MIN_RTT = 10
const TCP_NLA_RECUR_RETRANS = 11
const TCP_NLA_DELIVERY_RATE_APP_LMT = 12
const TCP_NLA_SNDQ_SIZE = 13
const TCP_NLA_CA_STATE = 14
const TCP_NLA_SND_SSTHRESH = 15
const TCP_NLA_DELIVERED = 16
const TCP_NLA_DELIVERED_CE = 17
const TCP_NLA_BYTES_SENT = 18
const TCP_NLA_BYTES_RETRANS = 19
const TCP_NLA_DSACK_DUPS = 20
const TCP_NLA_REORD_SEEN = 21
const TCP_NLA_SRTT = 22
const TCP_NLA_TIMEOUT_REHASH = 23
const TCP_NLA_BYTES_NOTSENT = 24
const TCP_NLA_EDT = 25
const TCP_NLA_TTL = 26

type Ttcp_seq = uint32

type Ttcphdr = struct {
	F__ccgo0_0 struct {
		F__ccgo1_0 [0]struct {
			Fth_sport Tuint16_t
			Fth_dport Tuint16_t
			Fth_seq   Tuint32_t
			Fth_ack   Tuint32_t
			F__ccgo12 uint8
			Fth_flags Tuint8_t
			Fth_win   Tuint16_t
			Fth_sum   Tuint16_t
			Fth_urp   Tuint16_t
		}
		F__ccgo0_0 struct {
			Fsource   Tuint16_t
			Fdest     Tuint16_t
			Fseq      Tuint32_t
			Fack_seq  Tuint32_t
			F__ccgo12 uint16
			Fwindow   Tuint16_t
			Fcheck    Tuint16_t
			Furg_ptr  Tuint16_t
		}
	}
}

type tcp_fastopen_client_fail = int32

const TFO_STATUS_UNSPEC = 0
const TFO_COOKIE_UNAVAILABLE = 1
const TFO_DATA_NOT_ACKED = 2
const TFO_SYN_RETRANSMITTED = 3

type Ttcp_info = struct {
	Ftcpi_state           Tuint8_t
	Ftcpi_ca_state        Tuint8_t
	Ftcpi_retransmits     Tuint8_t
	Ftcpi_probes          Tuint8_t
	Ftcpi_backoff         Tuint8_t
	Ftcpi_options         Tuint8_t
	F__ccgo6              uint8
	F__ccgo7              uint8
	Ftcpi_rto             Tuint32_t
	Ftcpi_ato             Tuint32_t
	Ftcpi_snd_mss         Tuint32_t
	Ftcpi_rcv_mss         Tuint32_t
	Ftcpi_unacked         Tuint32_t
	Ftcpi_sacked          Tuint32_t
	Ftcpi_lost            Tuint32_t
	Ftcpi_retrans         Tuint32_t
	Ftcpi_fackets         Tuint32_t
	Ftcpi_last_data_sent  Tuint32_t
	Ftcpi_last_ack_sent   Tuint32_t
	Ftcpi_last_data_recv  Tuint32_t
	Ftcpi_last_ack_recv   Tuint32_t
	Ftcpi_pmtu            Tuint32_t
	Ftcpi_rcv_ssthresh    Tuint32_t
	Ftcpi_rtt             Tuint32_t
	Ftcpi_rttvar          Tuint32_t
	Ftcpi_snd_ssthresh    Tuint32_t
	Ftcpi_snd_cwnd        Tuint32_t
	Ftcpi_advmss          Tuint32_t
	Ftcpi_reordering      Tuint32_t
	Ftcpi_rcv_rtt         Tuint32_t
	Ftcpi_rcv_space       Tuint32_t
	Ftcpi_total_retrans   Tuint32_t
	Ftcpi_pacing_rate     Tuint64_t
	Ftcpi_max_pacing_rate Tuint64_t
	Ftcpi_bytes_acked     Tuint64_t
	Ftcpi_bytes_received  Tuint64_t
	Ftcpi_segs_out        Tuint32_t
	Ftcpi_segs_in         Tuint32_t
	Ftcpi_notsent_bytes   Tuint32_t
	Ftcpi_min_rtt         Tuint32_t
	Ftcpi_data_segs_in    Tuint32_t
	Ftcpi_data_segs_out   Tuint32_t
	Ftcpi_delivery_rate   Tuint64_t
	Ftcpi_busy_time       Tuint64_t
	Ftcpi_rwnd_limited    Tuint64_t
	Ftcpi_sndbuf_limited  Tuint64_t
	Ftcpi_delivered       Tuint32_t
	Ftcpi_delivered_ce    Tuint32_t
	Ftcpi_bytes_sent      Tuint64_t
	Ftcpi_bytes_retrans   Tuint64_t
	Ftcpi_dsack_dups      Tuint32_t
	Ftcpi_reord_seen      Tuint32_t
	Ftcpi_rcv_ooopack     Tuint32_t
	Ftcpi_snd_wnd         Tuint32_t
}

type Ttcp_md5sig = struct {
	Ftcpm_addr      Tsockaddr_storage
	Ftcpm_flags     Tuint8_t
	Ftcpm_prefixlen Tuint8_t
	Ftcpm_keylen    Tuint16_t
	Ftcpm_ifindex   int32
	Ftcpm_key       [80]Tuint8_t
}

type Ttcp_diag_md5sig = struct {
	Ftcpm_family    Tuint8_t
	Ftcpm_prefixlen Tuint8_t
	Ftcpm_keylen    Tuint16_t
	Ftcpm_addr      [4]Tuint32_t
	Ftcpm_key       [80]Tuint8_t
}

type Ttcp_repair_window = struct {
	Fsnd_wl1    Tuint32_t
	Fsnd_wnd    Tuint32_t
	Fmax_window Tuint32_t
	Frcv_wnd    Tuint32_t
	Frcv_wup    Tuint32_t
}

type Ttcp_zerocopy_receive = struct {
	Faddress         Tuint64_t
	Flength          Tuint32_t
	Frecv_skip_hint  Tuint32_t
	Finq             Tuint32_t
	Ferr             Tint32_t
	Fcopybuf_address Tuint64_t
	Fcopybuf_len     Tint32_t
	Fflags           Tuint32_t
	Fmsg_control     Tuint64_t
	Fmsg_controllen  Tuint64_t
	Fmsg_flags       Tuint32_t
	Freserved        Tuint32_t
}

/*
 * Helper macros to make parts of this file clearer. The macros do exactly
 * what they say on the tin. :-) They also only ever refer to their arguments
 * once, and so can be used without regard to side effects.
 */

/* "sock" + a pointer in hex + \0 */

/*
 * This is needed to comply with the strict aliasing rules of GCC, but it also
 * simplifies casting between the different sockaddr types.
 */

type Taddress = struct {
	Fsa4         [0]Tsockaddr_in
	Fsa6         [0]Tsockaddr_in6
	Fsas         [0]Tsockaddr_storage
	Fsa          Tsockaddr
	F__ccgo_pad4 [112]byte
}

/*
 * This structure describes per-instance state of a tcp-based channel.
 */

type TTcpState = struct {
	Fchannel        TTcl_Channel
	Fflags          int32
	Ffds            TTcpFdList
	Finterest       int32
	FacceptProc     uintptr
	FacceptProcData uintptr
	Faddrlist       uintptr
	Faddr           uintptr
	Fmyaddrlist     uintptr
	Fmyaddr         uintptr
	Ffilehandlers   int32
	FconnectError   int32
	FcachedBlocking int32
}

type TTcpFdList = struct {
	FstatePtr uintptr
	Ffd       int32
	Fnext     uintptr
}

type TTcpState1 = struct {
	Fchannel        TTcl_Channel
	Fflags          int32
	Ffds            TTcpFdList
	Finterest       int32
	FacceptProc     uintptr
	FacceptProcData uintptr
	Faddrlist       uintptr
	Faddr           uintptr
	Fmyaddrlist     uintptr
	Fmyaddr         uintptr
	Ffilehandlers   int32
	FconnectError   int32
	FcachedBlocking int32
}

/*
 * This structure describes the channel type structure for TCP socket
 * based IO:
 */

var _tcpChannelType = TTcl_ChannelType{
	FtypeName: __ccgo_ts + 45209,
	Fversion:  libc.UintptrFromInt32(0x5),
}

func init() {
	p := unsafe.Pointer(&_tcpChannelType)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_TcpInputProc)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_TcpOutputProc)
	*(*uintptr)(unsafe.Add(p, 48)) = __ccgo_fp(_TcpSetOptionProc)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(_TcpGetOptionProc)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(_TcpWatchProc)
	*(*uintptr)(unsafe.Add(p, 72)) = __ccgo_fp(_TcpGetHandleProc)
	*(*uintptr)(unsafe.Add(p, 80)) = __ccgo_fp(_TcpClose2Proc)
	*(*uintptr)(unsafe.Add(p, 88)) = __ccgo_fp(_TcpBlockModeProc)
	*(*uintptr)(unsafe.Add(p, 120)) = __ccgo_fp(_TcpThreadActionProc)
}

var _hostName = TProcessGlobalValue{}

func init() {
	p := unsafe.Pointer(&_hostName)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_InitializeHostName)
}

/*
 * ----------------------------------------------------------------------
 *
 * InitializeHostName --
 *
 *	This routine sets the process global value of the name of the local
 *	host on which the process is running.
 *
 * Results:
 *	None.
 *
 * ----------------------------------------------------------------------
 */

func _InitializeHostName(tls *libc.TLS, valuePtr uintptr, lengthPtr uintptr, encodingPtr uintptr) {
	bp := tls.Alloc(400)
	defer tls.Free(400)
	var dot, hp, native, node uintptr
	var _ /* u at bp+0 */ Tutsname
	_, _, _, _ = dot, hp, native, node
	native = libc.UintptrFromInt32(0)
	libc.Xmemset(tls, bp, libc.Int32FromInt32(0), uint64(390))
	if libc.Xuname(tls, bp) >= 0 { /* INTL: Native. */
		hp = XTclpGetHostByName(tls, bp+65) /* INTL: Native. */
		if hp == libc.UintptrFromInt32(0) {
			/*
			 * Sometimes the nodename is fully qualified, but gets truncated
			 * as it exceeds SYS_NMLN. See if we can just get the immediate
			 * nodename and get a proper answer that way.
			 */
			dot = libc.Xstrchr(tls, bp+65, int32('.'))
			if dot != libc.UintptrFromInt32(0) {
				node = XTcl_Alloc(tls, libc.Uint64FromInt64(int64(dot)-T__predefined_ptrdiff_t(bp+65)+int64(1)))
				libc.Xmemcpy(tls, node, bp+65, libc.Uint64FromInt64(int64(dot)-T__predefined_ptrdiff_t(bp+65)))
				*(*uint8)(unsafe.Pointer(node + uintptr(int64(dot)-T__predefined_ptrdiff_t(bp+65)))) = uint8('\000')
				hp = XTclpGetHostByName(tls, node)
				XTclpFree(tls, node)
			}
		}
		if hp != libc.UintptrFromInt32(0) {
			native = (*Thostent)(unsafe.Pointer(hp)).Fh_name
		} else {
			native = bp + 65
		}
	}
	*(*TTcl_Encoding)(unsafe.Pointer(encodingPtr)) = XTcl_GetEncoding(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	if native != 0 {
		*(*Tsize_t)(unsafe.Pointer(lengthPtr)) = libc.Xstrlen(tls, native)
		*(*uintptr)(unsafe.Pointer(valuePtr)) = XTcl_Alloc(tls, *(*Tsize_t)(unsafe.Pointer(lengthPtr))+uint64(1))
		libc.Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(valuePtr)), native, *(*Tsize_t)(unsafe.Pointer(lengthPtr))+uint64(1))
	} else {
		*(*Tsize_t)(unsafe.Pointer(lengthPtr)) = uint64(0)
		*(*uintptr)(unsafe.Pointer(valuePtr)) = XTcl_Alloc(tls, uint64(1))
		*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(valuePtr)))) = uint8('\000')
	}
}

/*
 * ----------------------------------------------------------------------
 *
 * Tcl_GetHostName --
 *
 *	Returns the name of the local host.
 *
 * Results:
 *	A string containing the network name for this machine, or an empty
 *	string if we can't figure out the name. The caller must not modify or
 *	free this string.
 *
 * Side effects:
 *	Caches the name to return for future calls.
 *
 * ----------------------------------------------------------------------
 */

func XTcl_GetHostName(tls *libc.TLS) (r uintptr) {
	var tclObj, v1 uintptr
	_, _ = tclObj, v1
	tclObj = XTclGetProcessGlobalValue(tls, uintptr(unsafe.Pointer(&_hostName)))
	if (*TTcl_Obj)(unsafe.Pointer(tclObj)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(tclObj)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, tclObj, libc.UintptrFromInt32(0))
	}
	return v1
}

/*
 * ----------------------------------------------------------------------
 *
 * TclpFinalizeSockets --
 *
 *	Performs per-thread socket subsystem finalization.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 * ----------------------------------------------------------------------
 */

func XTclpFinalizeSockets(tls *libc.TLS) {
	return
}

/*
 * ----------------------------------------------------------------------
 *
 * TcpBlockModeProc --
 *
 *	This function is invoked by the generic IO level to set blocking and
 *	nonblocking mode on a TCP socket based channel.
 *
 * Results:
 *	0 if successful, errno when failed.
 *
 * Side effects:
 *	Sets the device into blocking or nonblocking mode.
 *
 * ----------------------------------------------------------------------
 */

func _TcpBlockModeProc(tls *libc.TLS, instanceData uintptr, mode int32) (r int32) {
	/* The mode to set. Can be one of
	 * TCL_MODE_BLOCKING or
	 * TCL_MODE_NONBLOCKING. */
	var statePtr uintptr
	_ = statePtr
	statePtr = instanceData
	if mode == TCL_MODE_BLOCKING {
		*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(0))
	} else {
		*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(0)
	}
	if (*TTcpState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
		(*TTcpState)(unsafe.Pointer(statePtr)).FcachedBlocking = mode
		return 0
	}
	if XTclUnixSetBlockingMode(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd, mode) < 0 {
		return *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))
	}
	return 0
}

/*
 * ----------------------------------------------------------------------
 *
 * WaitForConnect --
 *
 *	Check the state of an async connect process. If a connection attempt
 *	terminated, process it, which may finalize it or may start the next
 *	attempt. If a connect error occurs, it is saved in
 *	statePtr->connectError to be reported by 'fconfigure -error'.
 *
 *	There are two modes of operation, defined by errorCodePtr:
 *	 *  non-NULL: Called by explicit read/write command. Blocks if the
 *	    socket is blocking.
 *	    May return two error codes:
 *	     *	EWOULDBLOCK: if connect is still in progress
 *	     *	ENOTCONN: if connect failed. This would be the error message
 *		of a recv or sendto syscall so this is emulated here.
 *	 *  NULL: Called by a background operation. Do not block and do not
 *	    return any error code.
 *
 * Results:
 *	0 if the connection has completed, -1 if still in progress or there is
 *	an error.
 *
 * Side effects:
 *	Processes socket events off the system queue. May process
 *	asynchronous connects.
 *
 *----------------------------------------------------------------------
 */

func _WaitForConnect(tls *libc.TLS, statePtr uintptr, errorCodePtr uintptr) (r int32) {
	var timeout int32
	_ = timeout
	/*
	 * Check if an async connect failed already and error reporting is
	 * demanded, return the error ENOTCONN
	 */
	if errorCodePtr != libc.UintptrFromInt32(0) && (*TTcpState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(5)) != 0 {
		*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(ENOTCONN)
		return -int32(1)
	}
	/*
	 * Check if an async connect is running. If not return ok.
	 */
	if !((*TTcpState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(4)) != libc.Int32FromInt32(0)) {
		return 0
	}
	/*
	 * In socket test mode do not continue with the connect.
	 * Exceptions are:
	 * - Call by recv/send and blocking socket
	 *   (errorCodePtr != NULL && !GOT_BITS(flags, TCP_NONBLOCKING))
	 */
	if (*TTcpState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(8)) != 0 && !(errorCodePtr != libc.UintptrFromInt32(0) && !((*TTcpState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(0)) != libc.Int32FromInt32(0))) {
		*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(EAGAIN)
		return -int32(1)
	}
	if errorCodePtr == libc.UintptrFromInt32(0) || (*TTcpState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(0)) != 0 {
		timeout = 0
	} else {
		timeout = -int32(1)
	}
	for cond := true; cond; cond = timeout == -int32(1) && (*TTcpState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
		if XTclUnixWaitForFile(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(3), timeout) != 0 {
			_TcpConnect(tls, libc.UintptrFromInt32(0), statePtr)
		}
		/*
		 * Do this only once in the nonblocking case and repeat it until the
		 * socket is final when blocking.
		 */
	}
	if errorCodePtr != libc.UintptrFromInt32(0) {
		if (*TTcpState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(4)) != 0 {
			*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(EAGAIN)
			return -int32(1)
		} else {
			if (*TTcpState)(unsafe.Pointer(statePtr)).FconnectError != 0 {
				*(*int32)(unsafe.Pointer(errorCodePtr)) = int32(ENOTCONN)
				return -int32(1)
			}
		}
	}
	return 0
}

/*
 *----------------------------------------------------------------------
 *
 * TcpInputProc --
 *
 *	This function is invoked by the generic IO level to read input from a
 *	TCP socket based channel.
 *
 *	NOTE: We cannot share code with FilePipeInputProc because here we must
 *	use recv to obtain the input from the channel, not read.
 *
 * Results:
 *	The number of bytes read is returned or -1 on error. An output
 *	argument contains the POSIX error code on error, or zero if no error
 *	occurred.
 *
 * Side effects:
 *	Reads input from the input device of the channel.
 *
 *----------------------------------------------------------------------
 */

func _TcpInputProc(tls *libc.TLS, instanceData uintptr, buf uintptr, bufSize int32, errorCodePtr uintptr) (r int32) {
	/* Where to store error code. */
	var bytesRead int32
	var statePtr uintptr
	_, _ = bytesRead, statePtr
	statePtr = instanceData
	*(*int32)(unsafe.Pointer(errorCodePtr)) = 0
	if _WaitForConnect(tls, statePtr, errorCodePtr) != 0 {
		return -int32(1)
	}
	bytesRead = int32(libc.Xrecv(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd, buf, libc.Uint64FromInt32(bufSize), 0))
	if bytesRead >= 0 {
		return bytesRead
	}
	if *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(ECONNRESET) {
		/*
		 * Turn ECONNRESET into a soft EOF condition.
		 */
		return 0
	}
	*(*int32)(unsafe.Pointer(errorCodePtr)) = *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))
	return -int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * TcpOutputProc --
 *
 *	This function is invoked by the generic IO level to write output to a
 *	TCP socket based channel.
 *
 *	NOTE: We cannot share code with FilePipeOutputProc because here we
 *	must use send, not write, to get reliable error reporting.
 *
 * Results:
 *	The number of bytes written is returned. An output argument is set to
 *	a POSIX error code if an error occurred, or zero.
 *
 * Side effects:
 *	Writes output on the output device of the channel.
 *
 *----------------------------------------------------------------------
 */

func _TcpOutputProc(tls *libc.TLS, instanceData uintptr, buf uintptr, toWrite int32, errorCodePtr uintptr) (r int32) {
	/* Where to store error code. */
	var statePtr uintptr
	var written int32
	_, _ = statePtr, written
	statePtr = instanceData
	*(*int32)(unsafe.Pointer(errorCodePtr)) = 0
	if _WaitForConnect(tls, statePtr, errorCodePtr) != 0 {
		return -int32(1)
	}
	written = int32(libc.Xsend(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd, buf, libc.Uint64FromInt32(toWrite), 0))
	if written >= 0 {
		return written
	}
	*(*int32)(unsafe.Pointer(errorCodePtr)) = *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))
	return -int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * TcpCloseProc --
 *
 *	This function is invoked by the generic IO level to perform
 *	channel-type-specific cleanup when a TCP socket based channel is
 *	closed.
 *
 * Results:
 *	0 if successful, the value of errno if failed.
 *
 * Side effects:
 *	Closes the socket of the channel.
 *
 *----------------------------------------------------------------------
 */

func _TcpCloseProc(tls *libc.TLS, instanceData uintptr, dummy597 uintptr) (r int32) {
	var errorCode int32
	var fds, next, statePtr uintptr
	_, _, _, _ = errorCode, fds, next, statePtr
	statePtr = instanceData
	errorCode = 0
	/*
	 * Delete a file handler that may be active for this socket if this is a
	 * server socket - the file handler was created automatically by Tcl as
	 * part of the mechanism to accept new client connections. Channel
	 * handlers are already deleted in the generic IO channel closing code
	 * that called this function, so we do not have to delete them here.
	 */
	fds = statePtr + 16
	for {
		if !(fds != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TTcpFdList)(unsafe.Pointer(fds)).Ffd < 0 {
			goto _1
		}
		XTcl_DeleteFileHandler(tls, (*TTcpFdList)(unsafe.Pointer(fds)).Ffd)
		if libc.Xclose(tls, (*TTcpFdList)(unsafe.Pointer(fds)).Ffd) < 0 {
			errorCode = *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))
		}
		goto _1
	_1:
		;
		fds = (*TTcpFdList)(unsafe.Pointer(fds)).Fnext
	}
	fds = (*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Fnext
	for fds != libc.UintptrFromInt32(0) {
		next = (*TTcpFdList)(unsafe.Pointer(fds)).Fnext
		XTclpFree(tls, fds)
		fds = next
	}
	if (*TTcpState)(unsafe.Pointer(statePtr)).Faddrlist != libc.UintptrFromInt32(0) {
		libc.Xfreeaddrinfo(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Faddrlist)
	}
	if (*TTcpState)(unsafe.Pointer(statePtr)).Fmyaddrlist != libc.UintptrFromInt32(0) {
		libc.Xfreeaddrinfo(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Fmyaddrlist)
	}
	XTclpFree(tls, statePtr)
	return errorCode
}

/*
 *----------------------------------------------------------------------
 *
 * TcpClose2Proc --
 *
 *	This function is called by the generic IO level to perform the channel
 *	type specific part of a half-close: namely, a shutdown() on a socket.
 *
 * Results:
 *	0 if successful, the value of errno if failed.
 *
 * Side effects:
 *	Shuts down one side of the socket.
 *
 *----------------------------------------------------------------------
 */

func _TcpClose2Proc(tls *libc.TLS, instanceData uintptr, dummy658 uintptr, flags int32) (r int32) {
	/* Flags that indicate which side to close. */
	var readError, writeError, v1 int32
	var statePtr uintptr
	_, _, _, _ = readError, statePtr, writeError, v1
	statePtr = instanceData
	readError = 0
	writeError = 0
	/*
	 * Shutdown the OS socket handle.
	 */
	if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) == 0 {
		return _TcpCloseProc(tls, instanceData, libc.UintptrFromInt32(0))
	}
	if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 && libc.Xshutdown(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd, SHUT_RD) < 0 {
		readError = *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))
	}
	if flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 && libc.Xshutdown(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd, int32(SHUT_WR)) < 0 {
		writeError = *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))
	}
	if readError != 0 {
		v1 = readError
	} else {
		v1 = writeError
	}
	return v1
}

/*
 *----------------------------------------------------------------------
 *
 * TcpHostPortList --
 *
 *	This function is called by the -gethostname and -getpeername switches
 *	of TcpGetOptionProc() to add three list elements with the textual
 *	representation of the given address to the given DString.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Adds three elements do dsPtr
 *
 *----------------------------------------------------------------------
 */

func _IPv6AddressNeedsNumericRendering(tls *libc.TLS, _addr Tin6_addr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	*(*Tin6_addr)(unsafe.Pointer(bp)) = _addr
	if !(*(*Tuint32_t)(unsafe.Pointer(bp))-*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&libc.Xin6addr_any))))|(*(*Tuint32_t)(unsafe.Pointer(bp + 1*4))-*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&libc.Xin6addr_any)) + 1*4)))|(*(*Tuint32_t)(unsafe.Pointer(bp + 2*4))-*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&libc.Xin6addr_any)) + 2*4)))|(*(*Tuint32_t)(unsafe.Pointer(bp + 3*4))-*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&libc.Xin6addr_any)) + 3*4))) != 0) {
		return int32(1)
	}
	/*
	 * The IN6_IS_ADDR_V4MAPPED macro has a problem with aliasing warnings on
	 * at least some versions of OSX.
	 */
	if !(*(*Tuint32_t)(unsafe.Pointer(bp)) == uint32(0) && *(*Tuint32_t)(unsafe.Pointer(bp + 1*4)) == uint32(0) && libc.Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 8))) == 0 && libc.Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 9))) == 0 && libc.Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 10))) == int32(0xff) && libc.Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 11))) == int32(0xff)) {
		return 0
	}
	return libc.BoolInt32(libc.Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 12))) == 0 && libc.Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 13))) == 0 && libc.Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 14))) == 0 && libc.Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(bp + 15))) == 0)
}

func _TcpHostPortList(tls *libc.TLS, interp uintptr, dsPtr uintptr, _addr Taddress, salen Tsocklen_t) {
	bp := tls.Alloc(672)
	defer tls.Free(672)
	*(*Taddress)(unsafe.Pointer(bp)) = _addr
	var flags int32
	var _ /* host at bp+128 */ [255]uint8
	var _ /* nhost at bp+383 */ [255]uint8
	var _ /* nport at bp+638 */ [32]uint8
	_ = flags
	flags = 0
	libc.Xgetnameinfo(tls, bp, salen, bp+383, uint32(255), bp+638, uint32(32), libc.Int32FromInt32(NI_NUMERICHOST)|libc.Int32FromInt32(NI_NUMERICSERV))
	XTcl_DStringAppendElement(tls, dsPtr, bp+383)
	/*
	 * We don't want to resolve INADDR_ANY and sin6addr_any; they can
	 * sometimes cause problems (and never have a name).
	 */
	if libc.Int32FromUint16((*(*Taddress)(unsafe.Pointer(bp))).Fsa.Fsa_family) == int32(PF_INET) {
		if (*(*Tsockaddr_in)(unsafe.Pointer(&*(*Taddress)(unsafe.Pointer(bp))))).Fsin_addr.Fs_addr == libc.Uint32FromInt32(0x00000000) {
			flags |= int32(NI_NUMERICHOST)
		}
	} else {
		if libc.Int32FromUint16((*(*Taddress)(unsafe.Pointer(bp))).Fsa.Fsa_family) == int32(PF_INET6) {
			if _IPv6AddressNeedsNumericRendering(tls, (*(*Tsockaddr_in6)(unsafe.Pointer(&*(*Taddress)(unsafe.Pointer(bp))))).Fsin6_addr) != 0 {
				flags |= int32(NI_NUMERICHOST)
			}
		}
	}
	/*
	 * Check if reverse DNS has been switched off globally.
	 */
	if interp != libc.UintptrFromInt32(0) && XTcl_GetVar2(tls, interp, __ccgo_ts+76137, libc.UintptrFromInt32(0), 0) != libc.UintptrFromInt32(0) {
		flags |= int32(NI_NUMERICHOST)
	}
	if libc.Xgetnameinfo(tls, bp, salen, bp+128, uint32(255), libc.UintptrFromInt32(0), uint32(0), flags) == 0 {
		/*
		 * Reverse mapping worked.
		 */
		XTcl_DStringAppendElement(tls, dsPtr, bp+128)
	} else {
		/*
		 * Reverse mapping failed - use the numeric rep once more.
		 */
		XTcl_DStringAppendElement(tls, dsPtr, bp+383)
	}
	XTcl_DStringAppendElement(tls, dsPtr, bp+638)
}

/*
 *----------------------------------------------------------------------
 *
 * TcpSetOptionProc --
 *
 *	Sets TCP channel specific options.
 *
 * Results:
 *	None, unless an error happens.
 *
 * Side effects:
 *	Changes attributes of the socket at the system level.
 *
 *----------------------------------------------------------------------
 */

func _TcpSetOptionProc(tls *libc.TLS, instanceData uintptr, interp uintptr, optionName uintptr, value uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* New value for option. */
	var len1 Tsize_t
	var ret, ret1 int32
	var statePtr uintptr
	var _ /* val at bp+0 */ int32
	var _ /* val at bp+4 */ int32
	_, _, _, _ = len1, ret, ret1, statePtr
	statePtr = instanceData
	len1 = uint64(0)
	if optionName != libc.UintptrFromInt32(0) {
		len1 = libc.Xstrlen(tls, optionName)
	}
	if len1 > uint64(1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(optionName + 1))) == int32('k') && libc.Xstrncmp(tls, optionName, __ccgo_ts+76170, len1) == 0 {
		*(*int32)(unsafe.Pointer(bp)) = 0
		if XTcl_GetBool(tls, interp, value, (libc.Int32FromInt32(TCL_NULL_OK)-libc.Int32FromInt32(2))&libc.Int32FromInt64(4), bp) != TCL_OK {
			return int32(TCL_ERROR)
		}
		ret = libc.Xsetsockopt(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd, int32(SOL_SOCKET), int32(SO_KEEPALIVE), bp, uint32(4))
		if ret < 0 {
			if interp != 0 {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+76181, libc.VaList(bp+16, XTcl_PosixError(tls, interp))))
			}
			return int32(TCL_ERROR)
		}
		return TCL_OK
	}
	if len1 > uint64(1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(optionName + 1))) == int32('n') && libc.Xstrncmp(tls, optionName, __ccgo_ts+76212, len1) == 0 {
		*(*int32)(unsafe.Pointer(bp + 4)) = 0
		if XTcl_GetBool(tls, interp, value, (libc.Int32FromInt32(TCL_NULL_OK)-libc.Int32FromInt32(2))&libc.Int32FromInt64(4), bp+4) != TCL_OK {
			return int32(TCL_ERROR)
		}
		ret1 = libc.Xsetsockopt(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd, int32(SOL_TCP), int32(TCP_NODELAY), bp+4, uint32(4))
		if ret1 < 0 {
			if interp != 0 {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+76181, libc.VaList(bp+16, XTcl_PosixError(tls, interp))))
			}
			return int32(TCL_ERROR)
		}
		return TCL_OK
	}
	return XTcl_BadChannelOption(tls, interp, optionName, __ccgo_ts+76221)
}

/*
 *----------------------------------------------------------------------
 *
 * TcpGetOptionProc --
 *
 *	Computes an option value for a TCP socket based channel, or a list of
 *	all options and their values.
 *
 *	Note: This code is based on code contributed by John Haxby.
 *
 * Results:
 *	A standard Tcl result. The value of the specified option or a list of
 *	all options and their values is returned in the supplied DString. Sets
 *	Error message if needed.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _TcpGetOptionProc(tls *libc.TLS, instanceData uintptr, interp uintptr, optionName uintptr, dsPtr uintptr) (r int32) {
	bp := tls.Alloc(320)
	defer tls.Free(320) /* Where to store the computed value;
	 * initialized by caller. */
	var fds, statePtr, v1, v3, v4 uintptr
	var found int32
	var len1 Tsize_t
	var _ /* err at bp+4 */ int32
	var _ /* opt at bp+276 */ int32
	var _ /* opt at bp+284 */ int32
	var _ /* optlen at bp+0 */ Tsocklen_t
	var _ /* peername at bp+8 */ Taddress
	var _ /* size at bp+136 */ Tsocklen_t
	var _ /* size at bp+272 */ Tsocklen_t
	var _ /* size at bp+280 */ Tsocklen_t
	var _ /* size at bp+288 */ Tsocklen_t
	var _ /* sockname at bp+144 */ Taddress
	_, _, _, _, _, _, _ = fds, found, len1, statePtr, v1, v3, v4
	statePtr = instanceData
	len1 = uint64(0)
	if optionName != libc.UintptrFromInt32(0) {
		len1 = libc.Xstrlen(tls, optionName)
	}
	if len1 > uint64(1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(optionName + 1))) == int32('e') && libc.Xstrncmp(tls, optionName, __ccgo_ts+37556, len1) == 0 {
		*(*Tsocklen_t)(unsafe.Pointer(bp)) = uint32(4)
		_WaitForConnect(tls, statePtr, libc.UintptrFromInt32(0))
		if (*TTcpState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
			/*
			 * Suppress errors as long as we are not done.
			 */
			*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = 0
		} else {
			if (*TTcpState)(unsafe.Pointer(statePtr)).FconnectError != 0 {
				*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = (*TTcpState)(unsafe.Pointer(statePtr)).FconnectError
				(*TTcpState)(unsafe.Pointer(statePtr)).FconnectError = 0
			} else {
				libc.Xgetsockopt(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd, int32(SOL_SOCKET), int32(SO_ERROR), bp+4, bp)
				*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = *(*int32)(unsafe.Pointer(bp + 4))
			}
		}
		if *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) != 0 {
			XTcl_DStringAppend(tls, dsPtr, XTcl_ErrnoMsg(tls, *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))), int64(-libc.Int32FromInt32(1)))
		}
		return TCL_OK
	}
	if len1 > uint64(1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(optionName + 1))) == int32('c') && libc.Xstrncmp(tls, optionName, __ccgo_ts+76239, len1) == 0 {
		_WaitForConnect(tls, statePtr, libc.UintptrFromInt32(0))
		if (*TTcpState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
			v1 = __ccgo_ts + 21397
		} else {
			v1 = __ccgo_ts + 14828
		}
		XTcl_DStringAppend(tls, dsPtr, v1, int64(-libc.Int32FromInt32(1)))
		return TCL_OK
	}
	if len1 == uint64(0) || len1 > uint64(1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(optionName + 1))) == int32('p') && libc.Xstrncmp(tls, optionName, __ccgo_ts+76251, len1) == 0 {
		*(*Tsocklen_t)(unsafe.Pointer(bp + 136)) = uint32(128)
		_WaitForConnect(tls, statePtr, libc.UintptrFromInt32(0))
		if (*TTcpState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
			/*
			 * In async connect output an empty string
			 */
			if len1 == uint64(0) {
				XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+76251)
				XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+1945)
			} else {
				return TCL_OK
			}
		} else {
			if libc.Xgetpeername(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd, bp+8, bp+136) >= 0 {
				/*
				 * Peername fetch succeeded - output list
				 */
				if len1 == uint64(0) {
					XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+76251)
					XTcl_DStringStartSublist(tls, dsPtr)
				}
				_TcpHostPortList(tls, interp, dsPtr, *(*Taddress)(unsafe.Pointer(bp + 8)), *(*Tsocklen_t)(unsafe.Pointer(bp + 136)))
				if len1 != 0 {
					return TCL_OK
				}
				XTcl_DStringEndSublist(tls, dsPtr)
			} else {
				/*
				 * getpeername failed - but if we were asked for all the options
				 * (len==0), don't flag an error at that point because it could be
				 * an fconfigure request on a server socket (which have no peer).
				 * Same must be done on win&mac.
				 */
				if len1 != 0 {
					if interp != 0 {
						XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+76261, libc.VaList(bp+304, XTcl_PosixError(tls, interp))))
					}
					return int32(TCL_ERROR)
				}
			}
		}
	}
	if len1 == uint64(0) || len1 > uint64(1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(optionName + 1))) == int32('s') && libc.Xstrncmp(tls, optionName, __ccgo_ts+76284, len1) == 0 {
		found = 0
		_WaitForConnect(tls, statePtr, libc.UintptrFromInt32(0))
		if len1 == uint64(0) {
			XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+76284)
			XTcl_DStringStartSublist(tls, dsPtr)
		}
		if (*TTcpState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
			/*
			 * In async connect output an empty string
			 */
			found = int32(1)
		} else {
			fds = statePtr + 16
			for {
				if !(fds != libc.UintptrFromInt32(0)) {
					break
				}
				*(*Tsocklen_t)(unsafe.Pointer(bp + 272)) = uint32(128)
				if libc.Xgetsockname(tls, (*TTcpFdList)(unsafe.Pointer(fds)).Ffd, bp+144, bp+272) >= 0 {
					found = int32(1)
					_TcpHostPortList(tls, interp, dsPtr, *(*Taddress)(unsafe.Pointer(bp + 144)), *(*Tsocklen_t)(unsafe.Pointer(bp + 272)))
				}
				goto _2
			_2:
				;
				fds = (*TTcpFdList)(unsafe.Pointer(fds)).Fnext
			}
		}
		if found != 0 {
			if len1 != 0 {
				return TCL_OK
			}
			XTcl_DStringEndSublist(tls, dsPtr)
		} else {
			if interp != 0 {
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+76294, libc.VaList(bp+304, XTcl_PosixError(tls, interp))))
			}
			return int32(TCL_ERROR)
		}
	}
	if len1 == uint64(0) || len1 > uint64(1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(optionName + 1))) == int32('k') && libc.Xstrncmp(tls, optionName, __ccgo_ts+76170, len1) == 0 {
		*(*int32)(unsafe.Pointer(bp + 276)) = 0
		*(*Tsocklen_t)(unsafe.Pointer(bp + 280)) = uint32(4)
		if len1 == uint64(0) {
			XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+76170)
		}
		libc.Xgetsockopt(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd, int32(SOL_SOCKET), int32(SO_KEEPALIVE), bp+276, bp+280)
		if *(*int32)(unsafe.Pointer(bp + 276)) != 0 {
			v3 = __ccgo_ts + 21397
		} else {
			v3 = __ccgo_ts + 14828
		}
		XTcl_DStringAppendElement(tls, dsPtr, v3)
		if len1 > uint64(0) {
			return TCL_OK
		}
	}
	if len1 == uint64(0) || len1 > uint64(1) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(optionName + 1))) == int32('n') && libc.Xstrncmp(tls, optionName, __ccgo_ts+76212, len1) == 0 {
		*(*int32)(unsafe.Pointer(bp + 284)) = 0
		*(*Tsocklen_t)(unsafe.Pointer(bp + 288)) = uint32(4)
		if len1 == uint64(0) {
			XTcl_DStringAppendElement(tls, dsPtr, __ccgo_ts+76212)
		}
		libc.Xgetsockopt(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd, int32(SOL_TCP), int32(TCP_NODELAY), bp+284, bp+288)
		if *(*int32)(unsafe.Pointer(bp + 284)) != 0 {
			v4 = __ccgo_ts + 21397
		} else {
			v4 = __ccgo_ts + 14828
		}
		XTcl_DStringAppendElement(tls, dsPtr, v4)
		if len1 > uint64(0) {
			return TCL_OK
		}
	}
	if len1 > uint64(0) {
		return XTcl_BadChannelOption(tls, interp, optionName, __ccgo_ts+76317)
	}
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * TcpThreadActionProc --
 *
 *	Handles detach/attach for asynchronously connecting socket.
 *
 *	Reassigning the file handler associated with thread-related channel
 *	notification, responsible for callbacks (signaling that asynchronous
 *	connection attempt has succeeded or failed).
 *
 * Results:
 *	None.
 *
 * ----------------------------------------------------------------------
 */

func _TcpThreadActionProc(tls *libc.TLS, instanceData uintptr, action int32) {
	var statePtr uintptr
	_ = statePtr
	statePtr = instanceData
	if (*TTcpState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
		/*
		 * Async-connecting socket must get reassigned handler if it have been
		 * transferred to another thread. Remove the handler if the socket is
		 * not managed by this thread anymore and create new handler (TSD related)
		 * so the callback will run in the correct thread, bug [f583715154].
		 */
		switch action {
		case int32(TCL_CHANNEL_THREAD_REMOVE):
			*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(4))
			XTcl_DeleteFileHandler(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd)
		case TCL_CHANNEL_THREAD_INSERT:
			XTcl_CreateFileHandler(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(3), __ccgo_fp(_TcpAsyncCallback), statePtr)
			*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(4)
			break
		}
	}
}

/*
 * ----------------------------------------------------------------------
 *
 * TcpWatchProc --
 *
 *	Initialize the notifier to watch the fd from this channel.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Sets up the notifier so that a future event on the channel will be
 *	seen by Tcl.
 *
 * ----------------------------------------------------------------------
 */

func _WrapNotify(tls *libc.TLS, clientData uintptr, mask int32) {
	var newmask int32
	var statePtr uintptr
	_, _ = newmask, statePtr
	statePtr = clientData
	newmask = mask & (*TTcpState)(unsafe.Pointer(statePtr)).Finterest
	if newmask == 0 {
		/*
		 * There was no overlap between the states the channel is interested
		 * in notifications for, and the states that are reported present on
		 * the file descriptor by select().  The only way that can happen is
		 * when the channel is interested in a writable condition, and only a
		 * readable state is reported present (see TcpWatchProc() below).  In
		 * that case, signal back to the caller the writable state, which is
		 * really an error condition.  As an extra check on that assumption,
		 * check for a non-zero value of errno before reporting an artificial
		 * writable state.
		 */
		if *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == 0 {
			return
		}
		newmask = libc.Int32FromInt32(1) << libc.Int32FromInt32(2)
	}
	XTcl_NotifyChannel(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Fchannel, newmask)
}

func _TcpWatchProc(tls *libc.TLS, instanceData uintptr, mask int32) {
	/* Events of interest; an OR-ed combination of
	 * TCL_READABLE, TCL_WRITABLE and
	 * TCL_EXCEPTION. */
	var statePtr uintptr
	_ = statePtr
	statePtr = instanceData
	if (*TTcpState)(unsafe.Pointer(statePtr)).FacceptProc != libc.UintptrFromInt32(0) {
		/*
		 * Make sure we don't mess with server sockets since they will never
		 * be readable or writable at the Tcl level. This keeps Tcl scripts
		 * from interfering with the -accept behavior (bug #3394732).
		 */
		return
	}
	if (*TTcpState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(4)) != 0 {
		/*
		 * Async sockets use a FileHandler internally while connecting, so we
		 * need to cache this request until the connection has succeeded.
		 */
		(*TTcpState)(unsafe.Pointer(statePtr)).Ffilehandlers = mask
	} else {
		if mask != 0 {
			/*
			 * Whether it is a bug or feature or otherwise, it is a fact of life
			 * that on at least some Linux kernels select() fails to report that a
			 * socket file descriptor is writable when the other end of the socket
			 * is closed.  This is in contrast to the guarantees Tcl makes that
			 * its channels become writable and fire writable events on an error
			 * condition.  This has caused a leak of file descriptors in a state of
			 * background flushing.  See Tcl ticket 1758a0b603.
			 *
			 * As a workaround, when our caller indicates an interest in writable
			 * notifications, we must tell the notifier built around select() that
			 * we are interested in the readable state of the file descriptor as
			 * well, as that is the only reliable means to get notified of error
			 * conditions.  Then it is the task of WrapNotify() above to untangle
			 * the meaning of these channel states and report the chan events as
			 * best it can.  We save a copy of the mask passed in to assist with
			 * that.
			 */
			(*TTcpState)(unsafe.Pointer(statePtr)).Finterest = mask
			XTcl_CreateFileHandler(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd, mask|libc.Int32FromInt32(1)<<libc.Int32FromInt32(1), __ccgo_fp(_WrapNotify), statePtr)
		} else {
			XTcl_DeleteFileHandler(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd)
		}
	}
}

/*
 * ----------------------------------------------------------------------
 *
 * TcpGetHandleProc --
 *
 *	Called from Tcl_GetChannelHandle to retrieve OS handles from inside a
 *	TCP socket based channel.
 *
 * Results:
 *	Returns TCL_OK with the fd in handlePtr, or TCL_ERROR if there is no
 *	handle for the specified direction.
 *
 * Side effects:
 *	None.
 *
 * ----------------------------------------------------------------------
 */

func _TcpGetHandleProc(tls *libc.TLS, instanceData uintptr, dummy1245 int32, handlePtr uintptr) (r int32) {
	/* Where to store the handle. */
	var statePtr uintptr
	_ = statePtr
	statePtr = instanceData
	*(*uintptr)(unsafe.Pointer(handlePtr)) = uintptr(int64((*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd))
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * TcpAsyncCallback --
 *
 *	Called by the event handler that TcpConnect sets up internally for
 *	[socket -async] to get notified when the asynchronous connection
 *	attempt has succeeded or failed.
 *
 * ----------------------------------------------------------------------
 */

func _TcpAsyncCallback(tls *libc.TLS, clientData uintptr, dummy1269 int32) {
	_TcpConnect(tls, libc.UintptrFromInt32(0), clientData)
}

/*
 * ----------------------------------------------------------------------
 *
 * TcpConnect --
 *
 *	This function opens a new socket in client mode.
 *
 * Results:
 *      TCL_OK, if the socket was successfully connected or an asynchronous
 *      connection is in progress. If an error occurs, TCL_ERROR is returned
 *      and an error message is left in interp.
 *
 * Side effects:
 *	Opens a socket.
 *
 * Remarks:
 *	A single host name may resolve to more than one IP address, e.g. for
 *	an IPv4/IPv6 dual stack host. For handling asynchronously connecting
 *	sockets in the background for such hosts, this function can act as a
 *	coroutine. On the first call, it sets up the control variables for the
 *	two nested loops over the local and remote addresses. Once the first
 *	connection attempt is in progress, it sets up itself as a writable
 *	event handler for that socket, and returns. When the callback occurs,
 *	control is transferred to the "reenter" label, right after the initial
 *	return and the loops resume as if they had never been interrupted.
 *	For synchronously connecting sockets, the loops work the usual way.
 *
 * ----------------------------------------------------------------------
 */

func _TcpConnect(tls *libc.TLS, interp uintptr, statePtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var async, async_callback, ret int32
	var _ /* error at bp+4 */ int32
	var _ /* optlen at bp+0 */ Tsocklen_t
	_, _, _ = async, async_callback, ret
	async_callback = libc.BoolInt32((*TTcpState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(4)) != 0)
	ret = -int32(1)
	*(*int32)(unsafe.Pointer(bp + 4)) = int32(EHOSTUNREACH)
	async = libc.BoolInt32((*TTcpState)(unsafe.Pointer(statePtr)).Fflags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0)
	if async_callback != 0 {
		goto reenter
	}
	(*TTcpState)(unsafe.Pointer(statePtr)).Faddr = (*TTcpState)(unsafe.Pointer(statePtr)).Faddrlist
_3:
	;
	if !((*TTcpState)(unsafe.Pointer(statePtr)).Faddr != libc.UintptrFromInt32(0)) {
		goto _1
	}
	(*TTcpState)(unsafe.Pointer(statePtr)).Fmyaddr = (*TTcpState)(unsafe.Pointer(statePtr)).Fmyaddrlist
_6:
	;
	if !((*TTcpState)(unsafe.Pointer(statePtr)).Fmyaddr != libc.UintptrFromInt32(0)) {
		goto _4
	}
	/*
	 * No need to try combinations of local and remote addresses of
	 * different families.
	 */
	if (*Taddrinfo)(unsafe.Pointer((*TTcpState)(unsafe.Pointer(statePtr)).Fmyaddr)).Fai_family != (*Taddrinfo)(unsafe.Pointer((*TTcpState)(unsafe.Pointer(statePtr)).Faddr)).Fai_family {
		goto _5
	}
	/*
	 * Close the socket if it is still open from the last unsuccessful
	 * iteration.
	 */
	if (*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd >= 0 {
		libc.Xclose(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd)
		(*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd = -int32(1)
		*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = 0
	}
	(*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd = libc.Xsocket(tls, (*Taddrinfo)(unsafe.Pointer((*TTcpState)(unsafe.Pointer(statePtr)).Faddr)).Fai_family, int32(SOCK_STREAM), 0)
	if (*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd < 0 {
		goto _5
	}
	/*
	 * Set the close-on-exec flag so that the socket will not get
	 * inherited by child processes.
	 */
	libc.Xfcntl(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd, int32(F_SETFD), libc.VaList(bp+16, int32(FD_CLOEXEC)))
	/*
	 * Set kernel space buffering
	 */
	XTclSockMinimumBuffers(tls, uintptr(int64((*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd)), int64(SOCKET_BUFSIZE))
	if async != 0 {
		ret = XTclUnixSetBlockingMode(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd, int32(TCL_MODE_NONBLOCKING))
		if ret < 0 {
			goto _5
		}
	}
	/*
	 * Must reset the error variable here, before we use it for the
	 * first time in this iteration.
	 */
	*(*int32)(unsafe.Pointer(bp + 4)) = 0
	libc.Xsetsockopt(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd, int32(SOL_SOCKET), int32(SO_REUSEADDR), uintptr(unsafe.Pointer(&_reuseaddr)), uint32(4))
	ret = libc.Xbind(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd, (*Taddrinfo)(unsafe.Pointer((*TTcpState)(unsafe.Pointer(statePtr)).Fmyaddr)).Fai_addr, (*Taddrinfo)(unsafe.Pointer((*TTcpState)(unsafe.Pointer(statePtr)).Fmyaddr)).Fai_addrlen)
	if ret < 0 {
		*(*int32)(unsafe.Pointer(bp + 4)) = *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))
		goto _5
	}
	/*
	 * Attempt to connect. The connect may fail at present with an
	 * EINPROGRESS but at a later time it will complete. The caller
	 * will set up a file handler on the socket if she is interested
	 * in being informed when the connect completes.
	 */
	ret = libc.Xconnect(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd, (*Taddrinfo)(unsafe.Pointer((*TTcpState)(unsafe.Pointer(statePtr)).Faddr)).Fai_addr, (*Taddrinfo)(unsafe.Pointer((*TTcpState)(unsafe.Pointer(statePtr)).Faddr)).Fai_addrlen)
	if ret < 0 {
		*(*int32)(unsafe.Pointer(bp + 4)) = *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))
	}
	if !(ret < 0 && *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(EINPROGRESS)) {
		goto _7
	}
	XTcl_CreateFileHandler(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(3), __ccgo_fp(_TcpAsyncCallback), statePtr)
	*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = int32(EAGAIN)
	*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(4)
	return TCL_OK
	goto reenter
reenter:
	;
	*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(4))
	XTcl_DeleteFileHandler(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd)
	/*
	 * Read the error state from the socket to see if the async
	 * connection has succeeded or failed. As this clears the
	 * error condition, we cache the status in the socket state
	 * struct for later retrieval by [fconfigure -error].
	 */
	*(*Tsocklen_t)(unsafe.Pointer(bp)) = uint32(4)
	libc.Xgetsockopt(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd, int32(SOL_SOCKET), int32(SO_ERROR), bp+4, bp)
	*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = *(*int32)(unsafe.Pointer(bp + 4))
_7:
	;
	if *(*int32)(unsafe.Pointer(bp + 4)) == 0 {
		goto out
	}
	goto _5
_5:
	;
	(*TTcpState)(unsafe.Pointer(statePtr)).Fmyaddr = (*Taddrinfo)(unsafe.Pointer((*TTcpState)(unsafe.Pointer(statePtr)).Fmyaddr)).Fai_next
	goto _6
	goto _4
_4:
	;
	goto _2
_2:
	;
	(*TTcpState)(unsafe.Pointer(statePtr)).Faddr = (*Taddrinfo)(unsafe.Pointer((*TTcpState)(unsafe.Pointer(statePtr)).Faddr)).Fai_next
	goto _3
	goto _1
_1:
	;
	goto out
out:
	;
	(*TTcpState)(unsafe.Pointer(statePtr)).FconnectError = *(*int32)(unsafe.Pointer(bp + 4))
	*(*int32)(unsafe.Pointer(statePtr + 8)) &= ^(libc.Int32FromInt32(1) << libc.Int32FromInt32(1))
	if async_callback != 0 {
		/*
		 * An asynchonous connection has finally succeeded or failed.
		 */
		_TcpWatchProc(tls, statePtr, (*TTcpState)(unsafe.Pointer(statePtr)).Ffilehandlers)
		XTclUnixSetBlockingMode(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd, (*TTcpState)(unsafe.Pointer(statePtr)).FcachedBlocking)
		if *(*int32)(unsafe.Pointer(bp + 4)) != 0 {
			*(*int32)(unsafe.Pointer(statePtr + 8)) |= libc.Int32FromInt32(1) << libc.Int32FromInt32(5)
		}
		/*
		 * We need to forward the writable event that brought us here, because
		 * upon reading of getsockopt(SO_ERROR), at least some OSes clear the
		 * writable state from the socket, and so a subsequent select() on
		 * behalf of a script level [fileevent] would not fire. It doesn't
		 * hurt that this is also called in the successful case and will save
		 * the event mechanism one roundtrip through select().
		 */
		if (*TTcpState)(unsafe.Pointer(statePtr)).FcachedBlocking == int32(TCL_MODE_NONBLOCKING) {
			XTcl_NotifyChannel(tls, (*TTcpState)(unsafe.Pointer(statePtr)).Fchannel, libc.Int32FromInt32(1)<<libc.Int32FromInt32(2))
		}
	}
	if *(*int32)(unsafe.Pointer(bp + 4)) != 0 {
		/*
		 * Failure for either a synchronous connection, or an async one that
		 * failed before it could enter background mode, e.g. because an
		 * invalid -myaddr was given.
		 */
		if interp != libc.UintptrFromInt32(0) {
			*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = *(*int32)(unsafe.Pointer(bp + 4))
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+76364, libc.VaList(bp+16, XTcl_PosixError(tls, interp))))
		}
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

var _reuseaddr = int32(1)

/*
 *----------------------------------------------------------------------
 *
 * Tcl_OpenTcpClient --
 *
 *	Opens a TCP client socket and creates a channel around it.
 *
 * Results:
 *	The channel or NULL if failed. An error message is returned in the
 *	interpreter on failure.
 *
 * Side effects:
 *	Opens a client socket and creates a new channel.
 *
 *----------------------------------------------------------------------
 */

func XTcl_OpenTcpClient(tls *libc.TLS, interp uintptr, port int32, host uintptr, myaddr uintptr, myport int32, async int32) (r TTcl_Channel) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* If nonzero, attempt to do an asynchronous
	 * connect. Otherwise we do a blocking
	 * connect. */
	var statePtr uintptr
	var v1 int32
	var _ /* addrlist at bp+8 */ uintptr
	var _ /* channelName at bp+24 */ [21]uint8
	var _ /* errorMsg at bp+0 */ uintptr
	var _ /* myaddrlist at bp+16 */ uintptr
	_, _ = statePtr, v1
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(bp + 8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(bp + 16)) = libc.UintptrFromInt32(0)
	/*
	 * Do the name lookups for the local and remote addresses.
	 */
	if !(XTclCreateSocketAddress(tls, interp, bp+8, host, port, 0, bp) != 0) || !(XTclCreateSocketAddress(tls, interp, bp+16, myaddr, myport, int32(1), bp) != 0) {
		if *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) {
			libc.Xfreeaddrinfo(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
		}
		if interp != libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+76364, libc.VaList(bp+56, *(*uintptr)(unsafe.Pointer(bp)))))
		}
		return libc.UintptrFromInt32(0)
	}
	/*
	 * Allocate a new TcpState for this socket.
	 */
	statePtr = XTcl_Alloc(tls, uint64(112))
	libc.Xmemset(tls, statePtr, 0, uint64(112))
	if async != 0 {
		v1 = libc.Int32FromInt32(1) << libc.Int32FromInt32(1)
	} else {
		v1 = 0
	}
	(*TTcpState)(unsafe.Pointer(statePtr)).Fflags = v1
	(*TTcpState)(unsafe.Pointer(statePtr)).FcachedBlocking = TCL_MODE_BLOCKING
	(*TTcpState)(unsafe.Pointer(statePtr)).Faddrlist = *(*uintptr)(unsafe.Pointer(bp + 8))
	(*TTcpState)(unsafe.Pointer(statePtr)).Fmyaddrlist = *(*uintptr)(unsafe.Pointer(bp + 16))
	(*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd = -int32(1)
	/*
	 * Create a new client socket and wrap it in a channel.
	 */
	if _TcpConnect(tls, interp, statePtr) != TCL_OK {
		_TcpCloseProc(tls, statePtr, libc.UintptrFromInt32(0))
		return libc.UintptrFromInt32(0)
	}
	libc.X__builtin_snprintf(tls, bp+24, uint64(21), __ccgo_ts+76389, libc.VaList(bp+56, int64(statePtr)))
	(*TTcpState)(unsafe.Pointer(statePtr)).Fchannel = XTcl_CreateChannel(tls, uintptr(unsafe.Pointer(&_tcpChannelType)), bp+24, statePtr, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(2))
	if XTcl_SetChannelOption(tls, interp, (*TTcpState)(unsafe.Pointer(statePtr)).Fchannel, __ccgo_ts+44736, __ccgo_ts+75468) == int32(TCL_ERROR) {
		XTcl_CloseEx(tls, libc.UintptrFromInt32(0), (*TTcpState)(unsafe.Pointer(statePtr)).Fchannel, 0)
		return libc.UintptrFromInt32(0)
	}
	return (*TTcpState)(unsafe.Pointer(statePtr)).Fchannel
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_MakeTcpClientChannel --
 *
 *	Creates a Tcl_Channel from an existing client TCP socket.
 *
 * Results:
 *	The Tcl_Channel wrapped around the preexisting TCP socket.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_MakeTcpClientChannel(tls *libc.TLS, sock uintptr) (r TTcl_Channel) {
	/* The socket to wrap up into a channel. */
	return XTclpMakeTcpClientChannelMode(tls, sock, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(2))
}

/*
 *----------------------------------------------------------------------
 *
 * TclpMakeTcpClientChannelMode --
 *
 *	Creates a Tcl_Channel from an existing client TCP socket
 *	with given mode.
 *
 * Results:
 *	The Tcl_Channel wrapped around the preexisting TCP socket.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclpMakeTcpClientChannelMode(tls *libc.TLS, sock uintptr, mode int32) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* OR'ed combination of TCL_READABLE and
	 * TCL_WRITABLE to indicate file mode. */
	var statePtr uintptr
	var _ /* channelName at bp+0 */ [21]uint8
	_ = statePtr
	statePtr = XTcl_Alloc(tls, uint64(112))
	libc.Xmemset(tls, statePtr, 0, uint64(112))
	(*TTcpState)(unsafe.Pointer(statePtr)).Ffds.Ffd = int32(int64(sock))
	(*TTcpState)(unsafe.Pointer(statePtr)).Fflags = 0
	libc.X__builtin_snprintf(tls, bp, uint64(21), __ccgo_ts+76389, libc.VaList(bp+32, int64(statePtr)))
	(*TTcpState)(unsafe.Pointer(statePtr)).Fchannel = XTcl_CreateChannel(tls, uintptr(unsafe.Pointer(&_tcpChannelType)), bp, statePtr, mode)
	if XTcl_SetChannelOption(tls, libc.UintptrFromInt32(0), (*TTcpState)(unsafe.Pointer(statePtr)).Fchannel, __ccgo_ts+44736, __ccgo_ts+75468) == int32(TCL_ERROR) {
		XTcl_CloseEx(tls, libc.UintptrFromInt32(0), (*TTcpState)(unsafe.Pointer(statePtr)).Fchannel, 0)
		return libc.UintptrFromInt32(0)
	}
	return (*TTcpState)(unsafe.Pointer(statePtr)).Fchannel
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_OpenTcpServerEx --
 *
 *	Opens a TCP server socket and creates a channel around it.
 *
 * Results:
 *	The channel or NULL if failed. If an error occurred, an error message
 *	is left in the interp's result if interp is not NULL.
 *
 * Side effects:
 *	Opens a server socket and creates a new channel.
 *
 *----------------------------------------------------------------------
 */

func XTcl_OpenTcpServerEx(tls *libc.TLS, interp uintptr, service uintptr, myHost uintptr, flags uint32, backlog int32, acceptProc uintptr, acceptProcData uintptr) (r TTcl_Channel) {
	bp := tls.Alloc(208)
	defer tls.Free(208) /* Data for the callback. */
	var addrPtr, errorObj, fds, newfds, statePtr uintptr
	var chosenport, howfar, my_errno, retry, sock, status int32
	var _ /* addrlist at bp+8 */ uintptr
	var _ /* channelName at bp+16 */ [21]uint8
	var _ /* errorMsg at bp+40 */ uintptr
	var _ /* namelen at bp+184 */ Tsocklen_t
	var _ /* optvalue at bp+0 */ int32
	var _ /* port at bp+4 */ int32
	var _ /* sockname at bp+56 */ Taddress
	var _ /* v6only at bp+48 */ int32
	_, _, _, _, _, _, _, _, _, _, _ = addrPtr, chosenport, errorObj, fds, howfar, my_errno, newfds, retry, sock, statePtr, status
	status = 0
	sock = -int32(1)
	*(*uintptr)(unsafe.Pointer(bp + 8)) = libc.UintptrFromInt32(0) /* socket address */
	statePtr = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(bp + 40)) = libc.UintptrFromInt32(0)
	fds = libc.UintptrFromInt32(0)
	/*
	 * Try to record and return the most meaningful error message, i.e. the
	 * one from the first socket that went the farthest before it failed.
	 */
	howfar = 0
	my_errno = 0
	/*
	 * If we were called with port 0 to listen on a random port number, we
	 * copy the port number from the first member of the addrinfo list to all
	 * subsequent members, so that IPv4 and IPv6 listen on the same port. This
	 * might fail to bind() with EADDRINUSE if a port is free on the first
	 * address family in the list but already used on the other. In this case
	 * we revert everything we've done so far and start from scratch hoping
	 * that next time we'll find a port number that is usable on all address
	 * families. We try this at most MAXRETRY times to avoid an endless loop
	 * if all ports are taken.
	 */
	retry = 0
	goto repeat
repeat:
	;
	if retry > 0 {
		if statePtr != libc.UintptrFromInt32(0) {
			_TcpCloseProc(tls, statePtr, libc.UintptrFromInt32(0))
			statePtr = libc.UintptrFromInt32(0)
		}
		if *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) {
			libc.Xfreeaddrinfo(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
			*(*uintptr)(unsafe.Pointer(bp + 8)) = libc.UintptrFromInt32(0)
		}
		if retry >= int32(MAXRETRY) {
			goto error
		}
	}
	retry++
	chosenport = 0
	if XTclSockGetPort(tls, interp, service, __ccgo_ts+45209, bp+4) != TCL_OK {
		*(*uintptr)(unsafe.Pointer(bp + 40)) = __ccgo_ts + 76397
		goto error
	}
	if !(XTclCreateSocketAddress(tls, interp, bp+8, myHost, *(*int32)(unsafe.Pointer(bp + 4)), int32(1), bp+40) != 0) {
		my_errno = *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))
		goto error
	}
	addrPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
	for {
		if !(addrPtr != libc.UintptrFromInt32(0)) {
			break
		}
		sock = libc.Xsocket(tls, (*Taddrinfo)(unsafe.Pointer(addrPtr)).Fai_family, (*Taddrinfo)(unsafe.Pointer(addrPtr)).Fai_socktype, (*Taddrinfo)(unsafe.Pointer(addrPtr)).Fai_protocol)
		if sock == -int32(1) {
			if howfar < 1 {
				howfar = 1
				my_errno = *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))
			}
			goto _1
		}
		/*
		 * Set the close-on-exec flag so that the socket will not get
		 * inherited by child processes.
		 */
		libc.Xfcntl(tls, sock, int32(F_SETFD), libc.VaList(bp+200, int32(FD_CLOEXEC)))
		/*
		 * Set kernel space buffering
		 */
		XTclSockMinimumBuffers(tls, uintptr(int64(sock)), int64(SOCKET_BUFSIZE))
		/*
		 * Set up to reuse server addresses and/or ports if requested.
		 */
		if flags&libc.Uint32FromInt32(libc.Int32FromInt32(1)<<libc.Int32FromInt32(0)) != uint32(0) {
			*(*int32)(unsafe.Pointer(bp)) = int32(1)
			libc.Xsetsockopt(tls, sock, int32(SOL_SOCKET), int32(SO_REUSEADDR), bp, uint32(4))
		}
		if flags&libc.Uint32FromInt32(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != uint32(0) {
			*(*int32)(unsafe.Pointer(bp)) = int32(1)
			libc.Xsetsockopt(tls, sock, int32(SOL_SOCKET), int32(SO_REUSEPORT), bp, uint32(4))
		}
		/*
		 * Make sure we use the same port number when opening two server
		 * sockets for IPv4 and IPv6 on a random port.
		 *
		 * As sockaddr_in6 uses the same offset and size for the port member
		 * as sockaddr_in, we can handle both through the IPv4 API.
		 */
		if *(*int32)(unsafe.Pointer(bp + 4)) == 0 && chosenport != 0 {
			(*Tsockaddr_in)(unsafe.Pointer((*Taddrinfo)(unsafe.Pointer(addrPtr)).Fai_addr)).Fsin_port = libc.Xhtons(tls, libc.Uint16FromInt32(chosenport))
		}
		/*
		 * Missing on: Solaris 2.8
		 */
		if (*Taddrinfo)(unsafe.Pointer(addrPtr)).Fai_family == int32(PF_INET6) {
			*(*int32)(unsafe.Pointer(bp + 48)) = int32(1)
			libc.Xsetsockopt(tls, sock, int32(IPPROTO_IPV6), int32(IPV6_V6ONLY), bp+48, uint32(4))
		}
		status = libc.Xbind(tls, sock, (*Taddrinfo)(unsafe.Pointer(addrPtr)).Fai_addr, (*Taddrinfo)(unsafe.Pointer(addrPtr)).Fai_addrlen)
		if status == -int32(1) {
			if howfar < 2 {
				howfar = 2
				my_errno = *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))
			}
			libc.Xclose(tls, sock)
			sock = -int32(1)
			if *(*int32)(unsafe.Pointer(bp + 4)) == 0 && *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(EADDRINUSE) {
				goto repeat
			}
			goto _1
		}
		if *(*int32)(unsafe.Pointer(bp + 4)) == 0 && chosenport == 0 {
			*(*Tsocklen_t)(unsafe.Pointer(bp + 184)) = uint32(128)
			/*
			 * Synchronize port numbers when binding to port 0 of multiple
			 * addresses.
			 */
			if libc.Xgetsockname(tls, sock, bp+56, bp+184) >= 0 {
				chosenport = libc.Int32FromUint16(libc.Xntohs(tls, (*(*Tsockaddr_in)(unsafe.Pointer(&*(*Taddress)(unsafe.Pointer(bp + 56))))).Fsin_port))
			}
		}
		if backlog < 0 {
			backlog = int32(SOMAXCONN)
		}
		status = libc.Xlisten(tls, sock, backlog)
		if status < 0 {
			if howfar < 3 {
				howfar = 3
				my_errno = *(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))
			}
			libc.Xclose(tls, sock)
			sock = -int32(1)
			if *(*int32)(unsafe.Pointer(bp + 4)) == 0 && *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(EADDRINUSE) {
				goto repeat
			}
			goto _1
		}
		if statePtr == libc.UintptrFromInt32(0) {
			/*
			 * Allocate a new TcpState for this socket.
			 */
			statePtr = XTcl_Alloc(tls, uint64(112))
			libc.Xmemset(tls, statePtr, 0, uint64(112))
			(*TTcpState)(unsafe.Pointer(statePtr)).FacceptProc = acceptProc
			(*TTcpState)(unsafe.Pointer(statePtr)).FacceptProcData = acceptProcData
			libc.X__builtin_snprintf(tls, bp+16, uint64(21), __ccgo_ts+76389, libc.VaList(bp+200, int64(statePtr)))
			newfds = statePtr + 16
		} else {
			newfds = XTcl_Alloc(tls, uint64(24))
			libc.Xmemset(tls, newfds, libc.Int32FromInt32(0), uint64(24))
			(*TTcpFdList)(unsafe.Pointer(fds)).Fnext = newfds
		}
		(*TTcpFdList)(unsafe.Pointer(newfds)).Ffd = sock
		(*TTcpFdList)(unsafe.Pointer(newfds)).FstatePtr = statePtr
		fds = newfds
		/*
		 * Set up the callback mechanism for accepting connections from new
		 * clients.
		 */
		XTcl_CreateFileHandler(tls, sock, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1), __ccgo_fp(_TcpAccept), fds)
		goto _1
	_1:
		;
		addrPtr = (*Taddrinfo)(unsafe.Pointer(addrPtr)).Fai_next
	}
	goto error
error:
	;
	if *(*uintptr)(unsafe.Pointer(bp + 8)) != libc.UintptrFromInt32(0) {
		libc.Xfreeaddrinfo(tls, *(*uintptr)(unsafe.Pointer(bp + 8)))
	}
	if statePtr != libc.UintptrFromInt32(0) {
		(*TTcpState)(unsafe.Pointer(statePtr)).Fchannel = XTcl_CreateChannel(tls, uintptr(unsafe.Pointer(&_tcpChannelType)), bp+16, statePtr, 0)
		return (*TTcpState)(unsafe.Pointer(statePtr)).Fchannel
	}
	if interp != libc.UintptrFromInt32(0) {
		errorObj = XTcl_NewStringObj(tls, __ccgo_ts+76417, int64(-libc.Int32FromInt32(1)))
		if *(*uintptr)(unsafe.Pointer(bp + 40)) == libc.UintptrFromInt32(0) {
			*(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) = my_errno
			XTcl_AppendToObj(tls, errorObj, XTcl_PosixError(tls, interp), int64(-libc.Int32FromInt32(1)))
		} else {
			XTcl_AppendToObj(tls, errorObj, *(*uintptr)(unsafe.Pointer(bp + 40)), int64(-libc.Int32FromInt32(1)))
		}
		XTcl_SetObjResult(tls, interp, errorObj)
	}
	if sock != -int32(1) {
		libc.Xclose(tls, sock)
	}
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * TcpAccept --
 *	Accept a TCP socket connection.	 This is called by the event loop.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Creates a new connection socket. Calls the registered callback for the
 *	connection acceptance mechanism.
 *
 *----------------------------------------------------------------------
 */

func _TcpAccept(tls *libc.TLS, data uintptr, dummy1903 int32) {
	bp := tls.Alloc(464)
	defer tls.Free(464)
	var fds, newSockState uintptr
	var newsock int32
	var _ /* addr at bp+0 */ Taddress
	var _ /* channelName at bp+132 */ [21]uint8
	var _ /* host at bp+153 */ [255]uint8
	var _ /* len at bp+128 */ Tsocklen_t
	var _ /* port at bp+408 */ [32]uint8
	_, _, _ = fds, newSockState, newsock
	fds = data
	*(*Tsocklen_t)(unsafe.Pointer(bp + 128)) = uint32(128)
	newsock = libc.Xaccept(tls, (*TTcpFdList)(unsafe.Pointer(fds)).Ffd, bp, bp+128)
	if newsock < 0 {
		return
	}
	/*
	 * Set close-on-exec flag to prevent the newly accepted socket from being
	 * inherited by child processes.
	 */
	libc.Xfcntl(tls, newsock, int32(F_SETFD), libc.VaList(bp+448, int32(FD_CLOEXEC)))
	newSockState = XTcl_Alloc(tls, uint64(112))
	libc.Xmemset(tls, newSockState, 0, uint64(112))
	(*TTcpState)(unsafe.Pointer(newSockState)).Fflags = 0
	(*TTcpState)(unsafe.Pointer(newSockState)).Ffds.Ffd = newsock
	libc.X__builtin_snprintf(tls, bp+132, uint64(21), __ccgo_ts+76389, libc.VaList(bp+448, int64(newSockState)))
	(*TTcpState)(unsafe.Pointer(newSockState)).Fchannel = XTcl_CreateChannel(tls, uintptr(unsafe.Pointer(&_tcpChannelType)), bp+132, newSockState, libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(2))
	XTcl_SetChannelOption(tls, libc.UintptrFromInt32(0), (*TTcpState)(unsafe.Pointer(newSockState)).Fchannel, __ccgo_ts+44736, __ccgo_ts+75468)
	if (*TTcpState)(unsafe.Pointer((*TTcpFdList)(unsafe.Pointer(fds)).FstatePtr)).FacceptProc != libc.UintptrFromInt32(0) {
		libc.Xgetnameinfo(tls, bp, *(*Tsocklen_t)(unsafe.Pointer(bp + 128)), bp+153, uint32(255), bp+408, uint32(32), libc.Int32FromInt32(NI_NUMERICHOST)|libc.Int32FromInt32(NI_NUMERICSERV))
		(*(*func(*libc.TLS, uintptr, TTcl_Channel, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{(*TTcpState)(unsafe.Pointer((*TTcpFdList)(unsafe.Pointer(fds)).FstatePtr)).FacceptProc})))(tls, (*TTcpState)(unsafe.Pointer((*TTcpFdList)(unsafe.Pointer(fds)).FstatePtr)).FacceptProcData, (*TTcpState)(unsafe.Pointer(newSockState)).Fchannel, bp+153, libc.Xatoi(tls, bp+408))
	}
}

func init() {
	p := unsafe.Pointer(&XtclGetTimeProcPtr)
	*(*uintptr)(unsafe.Add(p, 0)) = __ccgo_fp(_NativeGetTime)
}

func init() {
	p := unsafe.Pointer(&XtclScaleTimeProcPtr)
	*(*uintptr)(unsafe.Add(p, 0)) = __ccgo_fp(_NativeScaleTime)
}

/*
 * Inlined version of Tcl_GetTime.
 */

func _GetTime(tls *libc.TLS, timePtr uintptr) {
	(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{XtclGetTimeProcPtr})))(tls, timePtr, XtclTimeClientData)
}

func _IsTimeNative(tls *libc.TLS) (r int32) {
	return libc.BoolInt32(XtclGetTimeProcPtr == __ccgo_fp(_NativeGetTime))
}

/*
 *----------------------------------------------------------------------
 *
 * TclpGetSeconds --
 *
 *	This procedure returns the number of seconds from the epoch. On most
 *	Unix systems the epoch is Midnight Jan 1, 1970 GMT.
 *
 * Results:
 *	Number of seconds from the epoch.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclpGetSeconds(tls *libc.TLS) (r uint64) {
	return libc.Uint64FromInt64(libc.Xtime(tls, libc.UintptrFromInt32(0)))
}

/*
 *----------------------------------------------------------------------
 *
 * TclpGetMicroseconds --
 *
 *	This procedure returns the number of microseconds from the epoch.
 *	On most Unix systems the epoch is Midnight Jan 1, 1970 GMT.
 *
 * Results:
 *	Number of microseconds from the epoch.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclpGetMicroseconds(tls *libc.TLS) (r int64) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _ /* time at bp+0 */ TTcl_Time
	_GetTime(tls, bp)
	return (*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec*int64(1000000) + (*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec
}

/*
 *----------------------------------------------------------------------
 *
 * TclpGetClicks --
 *
 *	This procedure returns a value that represents the highest resolution
 *	clock available on the system. There are no guarantees on what the
 *	resolution will be. In Tcl we will call this value a "click". The
 *	start time is also system dependent.
 *
 * Results:
 *	Number of clicks from some start time.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclpGetClicks(tls *libc.TLS) (r uint64) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var now uint64
	var _ /* time at bp+0 */ TTcl_Time
	_ = now
	_GetTime(tls, bp)
	now = libc.Uint64FromInt64((*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec)*uint64(1000000) + libc.Uint64FromInt64((*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec)
	return now
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetTime --
 *
 *	Gets the current system time in seconds and microseconds since the
 *	beginning of the epoch: 00:00 UCT, January 1, 1970.
 *
 *	This function is hooked, allowing users to specify their own virtual
 *	system time.
 *
 * Results:
 *	Returns the current time in timePtr.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetTime(tls *libc.TLS, timePtr uintptr) {
	/* Location to store time information. */
	_GetTime(tls, timePtr)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_SetTimeProc --
 *
 *	TIP #233 (Virtualized Time): Registers two handlers for the
 *	virtualization of Tcl's access to time information.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Remembers the handlers, alters core behaviour.
 *
 *----------------------------------------------------------------------
 */

func XTcl_SetTimeProc(tls *libc.TLS, getProc uintptr, scaleProc uintptr, clientData uintptr) {
	XtclGetTimeProcPtr = getProc
	XtclScaleTimeProcPtr = scaleProc
	XtclTimeClientData = clientData
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_QueryTimeProc --
 *
 *	TIP #233 (Virtualized Time): Query which time handlers are registered.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_QueryTimeProc(tls *libc.TLS, getProc uintptr, scaleProc uintptr, clientData uintptr) {
	if getProc != 0 {
		*(*uintptr)(unsafe.Pointer(getProc)) = XtclGetTimeProcPtr
	}
	if scaleProc != 0 {
		*(*uintptr)(unsafe.Pointer(scaleProc)) = XtclScaleTimeProcPtr
	}
	if clientData != 0 {
		*(*uintptr)(unsafe.Pointer(clientData)) = XtclTimeClientData
	}
}

/*
 *----------------------------------------------------------------------
 *
 * NativeScaleTime --
 *
 *	TIP #233: Scale from virtual time to the real-time. For native scaling
 *	the relationship is 1:1 and nothing has to be done.
 *
 * Results:
 *	Scales the time in timePtr.
 *
 * Side effects:
 *	See above.
 *
 *----------------------------------------------------------------------
 */

func _NativeScaleTime(tls *libc.TLS, dummy390 uintptr, dummy391 uintptr) {
	/* Native scale is 1:1. Nothing is done */
}

/*
 *----------------------------------------------------------------------
 *
 * NativeGetTime --
 *
 *	TIP #233: Gets the current system time in seconds and microseconds
 *	since the beginning of the epoch: 00:00 UCT, January 1, 1970.
 *
 * Results:
 *	Returns the current time in timePtr.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _NativeGetTime(tls *libc.TLS, timePtr uintptr, dummy416 uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _ /* tv at bp+0 */ Ttimeval
	libc.Xgettimeofday(tls, bp, libc.UintptrFromInt32(0))
	(*TTcl_Time)(unsafe.Pointer(timePtr)).Fsec = (*(*Ttimeval)(unsafe.Pointer(bp))).Ftv_sec
	(*TTcl_Time)(unsafe.Pointer(timePtr)).Fusec = (*(*Ttimeval)(unsafe.Pointer(bp))).Ftv_usec
}

const ABDAY_1 = 131072
const ABDAY_2 = 131073
const ABDAY_3 = 131074
const ABDAY_4 = 131075
const ABDAY_5 = 131076
const ABDAY_6 = 131077
const ABDAY_7 = 131078
const ABMON_1 = 131086
const ABMON_10 = 131095
const ABMON_11 = 131096
const ABMON_12 = 131097
const ABMON_2 = 131087
const ABMON_3 = 131088
const ABMON_4 = 131089
const ABMON_5 = 131090
const ABMON_6 = 131091
const ABMON_7 = 131092
const ABMON_8 = 131093
const ABMON_9 = 131094
const ALT_DIGITS = 131119
const AM_STR = 131110
const CODESET = 14
const CRNCYSTR = 262159
const DAY_1 = 131079
const DAY_2 = 131080
const DAY_3 = 131081
const DAY_4 = 131082
const DAY_5 = 131083
const DAY_6 = 131084
const DAY_7 = 131085
const D_FMT = 131113
const D_T_FMT = 131112
const ERA = 131116
const ERA_D_FMT = 131118
const ERA_D_T_FMT = 131120
const ERA_T_FMT = 131121
const LIBRARY_SIZE = 32
const MON_1 = 131098
const MON_10 = 131107
const MON_11 = 131108
const MON_12 = 131109
const MON_2 = 131099
const MON_3 = 131100
const MON_4 = 131101
const MON_5 = 131102
const MON_6 = 131103
const MON_7 = 131104
const MON_8 = 131105
const MON_9 = 131106
const NL_CAT_LOCALE = 1
const NL_SETD = 1
const NOEXPR = 327681
const NOSTR = 327683
const PM_STR = 131111
const RADIXCHAR = 65536
const TCL_DEFAULT_ENCODING = "utf-8"
const TCL_LIBRARY = "/usr/local/lib/tcl9.0"
const TCL_PACKAGE_PATH = "/usr/local/lib"
const THOUSEP = 65537
const T_FMT = 131114
const T_FMT_AMPM = 131115
const YESEXPR = 327680
const YESSTR = 327682

type Tnl_item = int32

type Tnl_catd = uintptr

/*
 * Tcl tries to use standard and homebrew methods to guess the right encoding
 * on the platform. However, there is always a final fallback, and this value
 * is it. Make sure it is a real Tcl encoding.
 */

/*
 * Default directory in which to look for Tcl library scripts. The symbol is
 * defined by Makefile.
 */

var _defaultLibraryDir = [22]uint8{'/', 'u', 's', 'r', '/', 'l', 'o', 'c', 'a', 'l', '/', 'l', 'i', 'b', '/', 't', 'c', 'l', '9', '.', '0'}

/*
 * Directory in which to look for packages (each package is typically
 * installed as a subdirectory of this directory). The symbol is defined by
 * Makefile.
 */

var _pkgPath = [15]uint8{'/', 'u', 's', 'r', '/', 'l', 'o', 'c', 'a', 'l', '/', 'l', 'i', 'b'}

/*
 * The following table is used to map from Unix locale strings to encoding
 * files. If HAVE_LANGINFO is defined, then this is a fallback table when the
 * result from nl_langinfo isn't a recognized encoding. Otherwise this is the
 * first list checked for a mapping from env encoding to Tcl encoding name.
 */

type TLocaleTable = struct {
	Flang     uintptr
	Fencoding uintptr
}

/*
 * The table below is sorted for the sake of doing binary searches on it. The
 * indenting reflects different categories of data. The leftmost data
 * represent the encoding names directly implemented by data files in Tcl's
 * default encoding directory. Indented by one TAB are the encoding names that
 * are common alternative spellings. Indented by two TABs are the accumulated
 * "bug fixes" that have been added to deal with the wide variability seen
 * among existing platforms.
 */

var _localeTable = [174]TLocaleTable{
	0: {
		Flang:     __ccgo_ts + 1945,
		Fencoding: __ccgo_ts + 29173,
	},
	1: {
		Flang:     __ccgo_ts + 76440,
		Fencoding: __ccgo_ts + 76450,
	},
	2: {
		Flang:     __ccgo_ts + 76457,
		Fencoding: __ccgo_ts + 29173,
	},
	3: {
		Flang:     __ccgo_ts + 1131,
		Fencoding: __ccgo_ts + 1131,
	},
	4: {
		Flang:     __ccgo_ts + 76472,
		Fencoding: __ccgo_ts + 76472,
	},
	5: {
		Flang:     __ccgo_ts + 76477,
		Fencoding: __ccgo_ts + 76477,
	},
	6: {
		Flang:     __ccgo_ts + 76450,
		Fencoding: __ccgo_ts + 76450,
	},
	7: {
		Flang:     __ccgo_ts + 76484,
		Fencoding: __ccgo_ts + 76484,
	},
	8: {
		Flang:     __ccgo_ts + 76491,
		Fencoding: __ccgo_ts + 76491,
	},
	9: {
		Flang:     __ccgo_ts + 76498,
		Fencoding: __ccgo_ts + 76498,
	},
	10: {
		Flang:     __ccgo_ts + 76505,
		Fencoding: __ccgo_ts + 76505,
	},
	11: {
		Flang:     __ccgo_ts + 76512,
		Fencoding: __ccgo_ts + 76512,
	},
	12: {
		Flang:     __ccgo_ts + 76519,
		Fencoding: __ccgo_ts + 76519,
	},
	13: {
		Flang:     __ccgo_ts + 76526,
		Fencoding: __ccgo_ts + 76526,
	},
	14: {
		Flang:     __ccgo_ts + 73095,
		Fencoding: __ccgo_ts + 73095,
	},
	15: {
		Flang:     __ccgo_ts + 76533,
		Fencoding: __ccgo_ts + 76533,
	},
	16: {
		Flang:     __ccgo_ts + 76539,
		Fencoding: __ccgo_ts + 76539,
	},
	17: {
		Flang:     __ccgo_ts + 76545,
		Fencoding: __ccgo_ts + 76545,
	},
	18: {
		Flang:     __ccgo_ts + 76551,
		Fencoding: __ccgo_ts + 76551,
	},
	19: {
		Flang:     __ccgo_ts + 76557,
		Fencoding: __ccgo_ts + 76557,
	},
	20: {
		Flang:     __ccgo_ts + 76563,
		Fencoding: __ccgo_ts + 76563,
	},
	21: {
		Flang:     __ccgo_ts + 76569,
		Fencoding: __ccgo_ts + 76569,
	},
	22: {
		Flang:     __ccgo_ts + 76575,
		Fencoding: __ccgo_ts + 76575,
	},
	23: {
		Flang:     __ccgo_ts + 76581,
		Fencoding: __ccgo_ts + 76581,
	},
	24: {
		Flang:     __ccgo_ts + 76587,
		Fencoding: __ccgo_ts + 76587,
	},
	25: {
		Flang:     __ccgo_ts + 76593,
		Fencoding: __ccgo_ts + 76593,
	},
	26: {
		Flang:     __ccgo_ts + 76599,
		Fencoding: __ccgo_ts + 76599,
	},
	27: {
		Flang:     __ccgo_ts + 76605,
		Fencoding: __ccgo_ts + 76605,
	},
	28: {
		Flang:     __ccgo_ts + 76611,
		Fencoding: __ccgo_ts + 76611,
	},
	29: {
		Flang:     __ccgo_ts + 76617,
		Fencoding: __ccgo_ts + 76617,
	},
	30: {
		Flang:     __ccgo_ts + 76623,
		Fencoding: __ccgo_ts + 76623,
	},
	31: {
		Flang:     __ccgo_ts + 76629,
		Fencoding: __ccgo_ts + 76629,
	},
	32: {
		Flang:     __ccgo_ts + 76635,
		Fencoding: __ccgo_ts + 76635,
	},
	33: {
		Flang:     __ccgo_ts + 76641,
		Fencoding: __ccgo_ts + 76641,
	},
	34: {
		Flang:     __ccgo_ts + 76647,
		Fencoding: __ccgo_ts + 76647,
	},
	35: {
		Flang:     __ccgo_ts + 76656,
		Fencoding: __ccgo_ts + 76656,
	},
	36: {
		Flang:     __ccgo_ts + 76663,
		Fencoding: __ccgo_ts + 76663,
	},
	37: {
		Flang:     __ccgo_ts + 76670,
		Fencoding: __ccgo_ts + 76670,
	},
	38: {
		Flang:     __ccgo_ts + 76677,
		Fencoding: __ccgo_ts + 76677,
	},
	39: {
		Flang:     __ccgo_ts + 76684,
		Fencoding: __ccgo_ts + 76670,
	},
	40: {
		Flang:     __ccgo_ts + 76690,
		Fencoding: __ccgo_ts + 76677,
	},
	41: {
		Flang:     __ccgo_ts + 76696,
		Fencoding: __ccgo_ts + 76663,
	},
	42: {
		Flang:     __ccgo_ts + 76702,
		Fencoding: __ccgo_ts + 76702,
	},
	43: {
		Flang:     __ccgo_ts + 76710,
		Fencoding: __ccgo_ts + 76710,
	},
	44: {
		Flang:     __ccgo_ts + 76717,
		Fencoding: __ccgo_ts + 76717,
	},
	45: {
		Flang:     __ccgo_ts + 76724,
		Fencoding: __ccgo_ts + 76717,
	},
	46: {
		Flang:     __ccgo_ts + 76736,
		Fencoding: __ccgo_ts + 76736,
	},
	47: {
		Flang:     __ccgo_ts + 76747,
		Fencoding: __ccgo_ts + 76611,
	},
	48: {
		Flang:     __ccgo_ts + 76754,
		Fencoding: __ccgo_ts + 76477,
	},
	49: {
		Flang:     __ccgo_ts + 76762,
		Fencoding: __ccgo_ts + 76450,
	},
	50: {
		Flang:     __ccgo_ts + 76770,
		Fencoding: __ccgo_ts + 76484,
	},
	51: {
		Flang:     __ccgo_ts + 76778,
		Fencoding: __ccgo_ts + 76491,
	},
	52: {
		Flang:     __ccgo_ts + 76786,
		Fencoding: __ccgo_ts + 76498,
	},
	53: {
		Flang:     __ccgo_ts + 76794,
		Fencoding: __ccgo_ts + 76505,
	},
	54: {
		Flang:     __ccgo_ts + 76802,
		Fencoding: __ccgo_ts + 76512,
	},
	55: {
		Flang:     __ccgo_ts + 76810,
		Fencoding: __ccgo_ts + 76519,
	},
	56: {
		Flang:     __ccgo_ts + 76818,
		Fencoding: __ccgo_ts + 76526,
	},
	57: {
		Flang:     __ccgo_ts + 76826,
		Fencoding: __ccgo_ts + 73095,
	},
	58: {
		Flang:     __ccgo_ts + 76833,
		Fencoding: __ccgo_ts + 76533,
	},
	59: {
		Flang:     __ccgo_ts + 76840,
		Fencoding: __ccgo_ts + 76539,
	},
	60: {
		Flang:     __ccgo_ts + 76847,
		Fencoding: __ccgo_ts + 76545,
	},
	61: {
		Flang:     __ccgo_ts + 76854,
		Fencoding: __ccgo_ts + 76551,
	},
	62: {
		Flang:     __ccgo_ts + 76861,
		Fencoding: __ccgo_ts + 76557,
	},
	63: {
		Flang:     __ccgo_ts + 76868,
		Fencoding: __ccgo_ts + 76563,
	},
	64: {
		Flang:     __ccgo_ts + 76875,
		Fencoding: __ccgo_ts + 76569,
	},
	65: {
		Flang:     __ccgo_ts + 76882,
		Fencoding: __ccgo_ts + 76575,
	},
	66: {
		Flang:     __ccgo_ts + 76889,
		Fencoding: __ccgo_ts + 76581,
	},
	67: {
		Flang:     __ccgo_ts + 76896,
		Fencoding: __ccgo_ts + 76587,
	},
	68: {
		Flang:     __ccgo_ts + 76903,
		Fencoding: __ccgo_ts + 76593,
	},
	69: {
		Flang:     __ccgo_ts + 76910,
		Fencoding: __ccgo_ts + 76599,
	},
	70: {
		Flang:     __ccgo_ts + 76917,
		Fencoding: __ccgo_ts + 76605,
	},
	71: {
		Flang:     __ccgo_ts + 76924,
		Fencoding: __ccgo_ts + 76611,
	},
	72: {
		Flang:     __ccgo_ts + 76931,
		Fencoding: __ccgo_ts + 76617,
	},
	73: {
		Flang:     __ccgo_ts + 76938,
		Fencoding: __ccgo_ts + 76623,
	},
	74: {
		Flang:     __ccgo_ts + 76945,
		Fencoding: __ccgo_ts + 76629,
	},
	75: {
		Flang:     __ccgo_ts + 76952,
		Fencoding: __ccgo_ts + 76635,
	},
	76: {
		Flang:     __ccgo_ts + 76959,
		Fencoding: __ccgo_ts + 76641,
	},
	77: {
		Flang:     __ccgo_ts + 76966,
		Fencoding: __ccgo_ts + 76975,
	},
	78: {
		Flang:     __ccgo_ts + 76983,
		Fencoding: __ccgo_ts + 76995,
	},
	79: {
		Flang:     __ccgo_ts + 77006,
		Fencoding: __ccgo_ts + 77018,
	},
	80: {
		Flang:     __ccgo_ts + 77029,
		Fencoding: __ccgo_ts + 29173,
	},
	81: {
		Flang:     __ccgo_ts + 77040,
		Fencoding: __ccgo_ts + 77052,
	},
	82: {
		Flang:     __ccgo_ts + 77063,
		Fencoding: __ccgo_ts + 77075,
	},
	83: {
		Flang:     __ccgo_ts + 77086,
		Fencoding: __ccgo_ts + 77098,
	},
	84: {
		Flang:     __ccgo_ts + 77109,
		Fencoding: __ccgo_ts + 77121,
	},
	85: {
		Flang:     __ccgo_ts + 77132,
		Fencoding: __ccgo_ts + 77144,
	},
	86: {
		Flang:     __ccgo_ts + 77155,
		Fencoding: __ccgo_ts + 77166,
	},
	87: {
		Flang:     __ccgo_ts + 77176,
		Fencoding: __ccgo_ts + 77187,
	},
	88: {
		Flang:     __ccgo_ts + 77197,
		Fencoding: __ccgo_ts + 77208,
	},
	89: {
		Flang:     __ccgo_ts + 77218,
		Fencoding: __ccgo_ts + 77229,
	},
	90: {
		Flang:     __ccgo_ts + 77239,
		Fencoding: __ccgo_ts + 77250,
	},
	91: {
		Flang:     __ccgo_ts + 77260,
		Fencoding: __ccgo_ts + 77271,
	},
	92: {
		Flang:     __ccgo_ts + 77281,
		Fencoding: __ccgo_ts + 77292,
	},
	93: {
		Flang:     __ccgo_ts + 77302,
		Fencoding: __ccgo_ts + 77313,
	},
	94: {
		Flang:     __ccgo_ts + 76975,
		Fencoding: __ccgo_ts + 76975,
	},
	95: {
		Flang:     __ccgo_ts + 76995,
		Fencoding: __ccgo_ts + 76995,
	},
	96: {
		Flang:     __ccgo_ts + 77018,
		Fencoding: __ccgo_ts + 77018,
	},
	97: {
		Flang:     __ccgo_ts + 29173,
		Fencoding: __ccgo_ts + 29173,
	},
	98: {
		Flang:     __ccgo_ts + 77052,
		Fencoding: __ccgo_ts + 77052,
	},
	99: {
		Flang:     __ccgo_ts + 77075,
		Fencoding: __ccgo_ts + 77075,
	},
	100: {
		Flang:     __ccgo_ts + 77098,
		Fencoding: __ccgo_ts + 77098,
	},
	101: {
		Flang:     __ccgo_ts + 77121,
		Fencoding: __ccgo_ts + 77121,
	},
	102: {
		Flang:     __ccgo_ts + 77144,
		Fencoding: __ccgo_ts + 77144,
	},
	103: {
		Flang:     __ccgo_ts + 77166,
		Fencoding: __ccgo_ts + 77166,
	},
	104: {
		Flang:     __ccgo_ts + 77187,
		Fencoding: __ccgo_ts + 77187,
	},
	105: {
		Flang:     __ccgo_ts + 77208,
		Fencoding: __ccgo_ts + 77208,
	},
	106: {
		Flang:     __ccgo_ts + 77229,
		Fencoding: __ccgo_ts + 77229,
	},
	107: {
		Flang:     __ccgo_ts + 77250,
		Fencoding: __ccgo_ts + 77250,
	},
	108: {
		Flang:     __ccgo_ts + 77271,
		Fencoding: __ccgo_ts + 77271,
	},
	109: {
		Flang:     __ccgo_ts + 77292,
		Fencoding: __ccgo_ts + 77292,
	},
	110: {
		Flang:     __ccgo_ts + 77313,
		Fencoding: __ccgo_ts + 77313,
	},
	111: {
		Flang:     __ccgo_ts + 77323,
		Fencoding: __ccgo_ts + 29173,
	},
	112: {
		Flang:     __ccgo_ts + 77332,
		Fencoding: __ccgo_ts + 77121,
	},
	113: {
		Flang:     __ccgo_ts + 77342,
		Fencoding: __ccgo_ts + 77166,
	},
	114: {
		Flang:     __ccgo_ts + 77351,
		Fencoding: __ccgo_ts + 77229,
	},
	115: {
		Flang:     __ccgo_ts + 77360,
		Fencoding: __ccgo_ts + 77250,
	},
	116: {
		Flang:     __ccgo_ts + 77369,
		Fencoding: __ccgo_ts + 77271,
	},
	117: {
		Flang:     __ccgo_ts + 77378,
		Fencoding: __ccgo_ts + 77292,
	},
	118: {
		Flang:     __ccgo_ts + 77387,
		Fencoding: __ccgo_ts + 77313,
	},
	119: {
		Flang:     __ccgo_ts + 77396,
		Fencoding: __ccgo_ts + 76670,
	},
	120: {
		Flang:     __ccgo_ts + 77399,
		Fencoding: __ccgo_ts + 76670,
	},
	121: {
		Flang:     __ccgo_ts + 77405,
		Fencoding: __ccgo_ts + 76670,
	},
	122: {
		Flang:     __ccgo_ts + 77415,
		Fencoding: __ccgo_ts + 76670,
	},
	123: {
		Flang:     __ccgo_ts + 77427,
		Fencoding: __ccgo_ts + 76995,
	},
	124: {
		Flang:     __ccgo_ts + 77437,
		Fencoding: __ccgo_ts + 77450,
	},
	125: {
		Flang:     __ccgo_ts + 77459,
		Fencoding: __ccgo_ts + 77450,
	},
	126: {
		Flang:     __ccgo_ts + 77470,
		Fencoding: __ccgo_ts + 76670,
	},
	127: {
		Flang:     __ccgo_ts + 77481,
		Fencoding: __ccgo_ts + 76670,
	},
	128: {
		Flang:     __ccgo_ts + 77487,
		Fencoding: __ccgo_ts + 76670,
	},
	129: {
		Flang:     __ccgo_ts + 77496,
		Fencoding: __ccgo_ts + 77450,
	},
	130: {
		Flang:     __ccgo_ts + 77510,
		Fencoding: __ccgo_ts + 76670,
	},
	131: {
		Flang:     __ccgo_ts + 77524,
		Fencoding: __ccgo_ts + 76670,
	},
	132: {
		Flang:     __ccgo_ts + 77537,
		Fencoding: __ccgo_ts + 77450,
	},
	133: {
		Flang:     __ccgo_ts + 77551,
		Fencoding: __ccgo_ts + 77551,
	},
	134: {
		Flang:     __ccgo_ts + 77559,
		Fencoding: __ccgo_ts + 77559,
	},
	135: {
		Flang:     __ccgo_ts + 77567,
		Fencoding: __ccgo_ts + 77567,
	},
	136: {
		Flang:     __ccgo_ts + 77575,
		Fencoding: __ccgo_ts + 77450,
	},
	137: {
		Flang:     __ccgo_ts + 77581,
		Fencoding: __ccgo_ts + 76677,
	},
	138: {
		Flang:     __ccgo_ts + 77584,
		Fencoding: __ccgo_ts + 76677,
	},
	139: {
		Flang:     __ccgo_ts + 77590,
		Fencoding: __ccgo_ts + 76677,
	},
	140: {
		Flang:     __ccgo_ts + 77600,
		Fencoding: __ccgo_ts + 76677,
	},
	141: {
		Flang:     __ccgo_ts + 77612,
		Fencoding: __ccgo_ts + 77612,
	},
	142: {
		Flang:     __ccgo_ts + 77619,
		Fencoding: __ccgo_ts + 77619,
	},
	143: {
		Flang:     __ccgo_ts + 77626,
		Fencoding: __ccgo_ts + 76677,
	},
	144: {
		Flang:     __ccgo_ts + 77633,
		Fencoding: __ccgo_ts + 77633,
	},
	145: {
		Flang:     __ccgo_ts + 77641,
		Fencoding: __ccgo_ts + 77653,
	},
	146: {
		Flang:     __ccgo_ts + 77665,
		Fencoding: __ccgo_ts + 77677,
	},
	147: {
		Flang:     __ccgo_ts + 77689,
		Fencoding: __ccgo_ts + 77701,
	},
	148: {
		Flang:     __ccgo_ts + 77713,
		Fencoding: __ccgo_ts + 77725,
	},
	149: {
		Flang:     __ccgo_ts + 77737,
		Fencoding: __ccgo_ts + 77746,
	},
	150: {
		Flang:     __ccgo_ts + 77755,
		Fencoding: __ccgo_ts + 77766,
	},
	151: {
		Flang:     __ccgo_ts + 77777,
		Fencoding: __ccgo_ts + 77786,
	},
	152: {
		Flang:     __ccgo_ts + 77795,
		Fencoding: __ccgo_ts + 77804,
	},
	153: {
		Flang:     __ccgo_ts + 77813,
		Fencoding: __ccgo_ts + 77824,
	},
	154: {
		Flang:     __ccgo_ts + 77835,
		Fencoding: __ccgo_ts + 77843,
	},
	155: {
		Flang:     __ccgo_ts + 77851,
		Fencoding: __ccgo_ts + 77862,
	},
	156: {
		Flang:     __ccgo_ts + 77873,
		Fencoding: __ccgo_ts + 77884,
	},
	157: {
		Flang:     __ccgo_ts + 77895,
		Fencoding: __ccgo_ts + 29173,
	},
	158: {
		Flang:     __ccgo_ts + 77902,
		Fencoding: __ccgo_ts + 77229,
	},
	159: {
		Flang:     __ccgo_ts + 77905,
		Fencoding: __ccgo_ts + 77229,
	},
	160: {
		Flang:     __ccgo_ts + 77911,
		Fencoding: __ccgo_ts + 77229,
	},
	161: {
		Flang:     __ccgo_ts + 77450,
		Fencoding: __ccgo_ts + 77450,
	},
	162: {
		Flang:     __ccgo_ts + 77917,
		Fencoding: __ccgo_ts + 77450,
	},
	163: {
		Flang:     __ccgo_ts + 77922,
		Fencoding: __ccgo_ts + 77922,
	},
	164: {
		Flang:     __ccgo_ts + 77929,
		Fencoding: __ccgo_ts + 77929,
	},
	165: {
		Flang:     __ccgo_ts + 77937,
		Fencoding: __ccgo_ts + 77929,
	},
	166: {
		Flang:     __ccgo_ts + 77944,
		Fencoding: __ccgo_ts + 76563,
	},
	167: {
		Flang:     __ccgo_ts + 77953,
		Fencoding: __ccgo_ts + 29080,
	},
	168: {
		Flang:     __ccgo_ts + 77958,
		Fencoding: __ccgo_ts + 76629,
	},
	169: {
		Flang:     __ccgo_ts + 77961,
		Fencoding: __ccgo_ts + 76663,
	},
	170: {
		Flang:     __ccgo_ts + 77974,
		Fencoding: __ccgo_ts + 76663,
	},
	171: {
		Flang:     __ccgo_ts + 77984,
		Fencoding: __ccgo_ts + 76663,
	},
	172: {
		Flang:     __ccgo_ts + 77997,
		Fencoding: __ccgo_ts + 78003,
	},
	173: {
		Flang:     __ccgo_ts + 78010,
		Fencoding: __ccgo_ts + 76472,
	},
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpInitPlatform --
 *
 *	Initialize all the platform-dependent things like signals and
 *	floating-point error handling.
 *
 *	Called at process initialization time.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *---------------------------------------------------------------------------
 */

func XTclpInitPlatform(tls *libc.TLS) {
	XtclPlatform = int32(TCL_PLATFORM_UNIX)
	/*
	 * Make sure, that the standard FDs exist. [Bug 772288]
	 */
	if libc.Xlseek(tls, 0, 0, int32(1)) == int64(-int32(1)) && *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(EBADF) {
		libc.Xopen(tls, __ccgo_ts+78021, O_RDONLY, 0)
	}
	if libc.Xlseek(tls, int32(1), 0, int32(1)) == int64(-int32(1)) && *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(EBADF) {
		libc.Xopen(tls, __ccgo_ts+78021, int32(O_WRONLY), 0)
	}
	if libc.Xlseek(tls, int32(2), 0, int32(1)) == int64(-int32(1)) && *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(EBADF) {
		libc.Xopen(tls, __ccgo_ts+78021, int32(O_WRONLY), 0)
	}
	/*
	 * The code below causes SIGPIPE (broken pipe) errors to be ignored. This
	 * is needed so that Tcl processes don't die if they create child
	 * processes (e.g. using "exec" or "open") that terminate prematurely.
	 * The signal handler is only set up when the first interpreter is
	 * created; after this the application can override the handler with a
	 * different one of its own, if it wants.
	 */
	libc.Xsignal(tls, int32(SIGPIPE), libc.UintptrFromInt32(1))
	/*
	 * Initialize the C library's locale subsystem. This is required for input
	 * methods to work properly on X11. We only do this for LC_CTYPE because
	 * that's the necessary one, and we don't want to affect LC_TIME here.
	 * The side effect of setting the default locale should be to load any
	 * locale specific modules that are needed by X. [BUG: 5422 3345 4236 2522
	 * 2521].
	 */
	libc.Xsetlocale(tls, LC_CTYPE, __ccgo_ts+1945)
	/*
	 * In case the initial locale is not "C", ensure that the numeric
	 * processing is done in "C" locale regardless. This is needed because Tcl
	 * relies on routines like strtol/strtoul, but should not have locale dependent
	 * behavior.
	 */
	libc.Xsetlocale(tls, int32(LC_NUMERIC), __ccgo_ts+11678)
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpInitLibraryPath --
 *
 *	This is the fallback routine that sets the library path if the
 *	application has not set one by the first time it is needed.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Sets the library path to an initial value.
 *
 *-------------------------------------------------------------------------
 */

func XTclpInitLibraryPath(tls *libc.TLS, valuePtr uintptr, lengthPtr uintptr, encodingPtr uintptr) {
	bp := tls.Alloc(528)
	defer tls.Free(528)
	var _objPtr, cachePtr, objPtr, pathPtr, str, v2, v4 uintptr
	var v1 bool
	var v3 TTcl_Size
	var _ /* buffer at bp+0 */ TTcl_DString
	var _ /* ds at bp+224 */ TTcl_DString
	var _ /* installLib at bp+464 */ [32]uint8
	var _ /* length at bp+496 */ TTcl_Size
	var _ /* pathc at bp+448 */ TTcl_Size
	var _ /* pathv at bp+456 */ uintptr
	_, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, objPtr, pathPtr, str, v1, v2, v3, v4
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		pathPtr = XTclThreadAllocObj(tls)
	} else {
		pathPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(pathPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(pathPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(pathPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(pathPtr)).FtypePtr = libc.UintptrFromInt32(0)
	/*
	 * Look for the library relative to the TCL_LIBRARY env variable. If the
	 * last dirname in the TCL_LIBRARY path does not match the last dirname in
	 * the installLib variable, use the last dir name of installLib in
	 * addition to the original TCL_LIBRARY path.
	 */
	str = libc.Xgetenv(tls, __ccgo_ts+78031) /* INTL: Native. */
	XTcl_ExternalToUtfDStringEx(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), str, int64(-libc.Int32FromInt32(1)), int32(TCL_ENCODING_PROFILE_TCL8), bp, libc.UintptrFromInt32(0))
	str = (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1
	if str != libc.UintptrFromInt32(0) && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) != int32('\000') {
		XTcl_DStringInit(tls, bp+224)
		/*
		 * Initialize the substrings used when locating an executable. The
		 * installLib variable computes the path as though the executable is
		 * installed.
		 */
		libc.X__builtin_snprintf(tls, bp+464, uint64(32), __ccgo_ts+78043, libc.VaList(bp+512, __ccgo_ts+7237))
		/*
		 * If TCL_LIBRARY is set, search there.
		 */
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), pathPtr, XTcl_NewStringObj(tls, str, int64(-libc.Int32FromInt32(1))))
		XTcl_SplitPath(tls, str, bp+448, bp+456)
		if *(*TTcl_Size)(unsafe.Pointer(bp + 448)) > 0 && libc.Xstrcasecmp(tls, bp+464+uintptr(4), *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 456)) + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 448))-int64(1))*8))) != 0 {
			/*
			 * If TCL_LIBRARY is set but refers to a different tcl
			 * installation than the current version, try fiddling with the
			 * specified directory to make it refer to this installation by
			 * removing the old "tclX.Y" and substituting the current version
			 * string.
			 */
			*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 456)) + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 448))-int64(1))*8)) = bp + 464 + uintptr(4)
			str = XTcl_JoinPath(tls, *(*TTcl_Size)(unsafe.Pointer(bp + 448)), *(*uintptr)(unsafe.Pointer(bp + 456)), bp+224)
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), pathPtr, XTcl_DStringToObj(tls, bp+224))
		}
		XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 456)))
	}
	/*
	 * Finally, look for the library relative to the compiled-in path. This is
	 * needed when users install Tcl with an exec-prefix that is different
	 * from the prefix.
	 */
	/*
	 * TODO: Pull this value from the TIP 59 table.
	 */
	str = uintptr(unsafe.Pointer(&_defaultLibraryDir))
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) != int32('\000') {
		objPtr = XTcl_NewStringObj(tls, str, int64(-libc.Int32FromInt32(1)))
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), pathPtr, objPtr)
	}
	XTcl_DStringFree(tls, bp)
	*(*TTcl_Encoding)(unsafe.Pointer(encodingPtr)) = XTcl_GetEncoding(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	if (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 496)) = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Flength
		v2 = (*TTcl_Obj)(unsafe.Pointer(pathPtr)).Fbytes
	} else {
		v2 = XTcl_GetStringFromObj(tls, pathPtr, bp+496)
	}
	str = v2
	*(*Tsize_t)(unsafe.Pointer(lengthPtr)) = libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 496)))
	*(*uintptr)(unsafe.Pointer(valuePtr)) = XTcl_Alloc(tls, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 496))+int64(1)))
	libc.Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(valuePtr)), str, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 496))+int64(1)))
	_objPtr = pathPtr
	v4 = _objPtr
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	if v3 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpSetInitialEncodings --
 *
 *	Based on the locale, determine the encoding of the operating system
 *	and the default encoding for newly opened files.
 *
 *	Called at process initialization time, and part way through startup,
 *	we verify that the initial encodings were correctly setup. Depending
 *	on Tcl's environment, there may not have been enough information first
 *	time through (above).
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The Tcl library path is converted from native encoding to UTF-8, on
 *	the first call, and the encodings may be changed on first or second
 *	call.
 *
 *---------------------------------------------------------------------------
 */

func XTclpSetInitialEncodings(tls *libc.TLS) {
	bp := tls.Alloc(224)
	defer tls.Free(224)
	var _ /* encodingName at bp+0 */ TTcl_DString
	XTcl_SetSystemEncoding(tls, libc.UintptrFromInt32(0), XTcl_GetEncodingNameFromEnvironment(tls, bp))
	XTcl_DStringFree(tls, bp)
}

func _SearchKnownEncodings(tls *libc.TLS, encoding uintptr) (r uintptr) {
	var code, left, right, test int32
	_, _, _, _ = code, left, right, test
	left = 0
	right = libc.Int32FromUint64(libc.Uint64FromInt64(2784) / libc.Uint64FromInt64(16))
	/* Here, search for i in the interval left <= i < right. */
	for left < right {
		test = (left + right) / int32(2)
		code = libc.Xstrcmp(tls, _localeTable[test].Flang, encoding)
		if code == 0 {
			/* Found it at i == test.  */
			return _localeTable[test].Fencoding
		}
		if code < 0 {
			/* Restrict the search to the interval test < i < right. */
			left = test + int32(1)
		} else {
			/* Restrict the search to the interval left <= i < test. */
			right = test
		}
	}
	return libc.UintptrFromInt32(0)
}

func XTcl_GetEncodingNameFromEnvironment(tls *libc.TLS, bufPtr uintptr) (r uintptr) {
	bp := tls.Alloc(448)
	defer tls.Free(448)
	var encoding, knownEncoding, p uintptr
	var _ /* ds at bp+0 */ TTcl_DString
	var _ /* ds at bp+224 */ TTcl_DString
	_, _, _ = encoding, knownEncoding, p
	XTcl_DStringInit(tls, bufPtr)
	/*
	 * Determine the current encoding from the LC_* or LANG environment
	 * variables. We previously used setlocale() to determine the locale, but
	 * this does not work on some systems (e.g. Linux/i386 RH 5.0).
	 */
	if libc.Xsetlocale(tls, LC_CTYPE, __ccgo_ts+1945) != libc.UintptrFromInt32(0) {
		/*
		 * Use a DString so we can modify case.
		 */
		XTcl_DStringInit(tls, bp)
		encoding = XTcl_DStringAppend(tls, bp, libc.Xnl_langinfo(tls, int32(CODESET)), int64(-libc.Int32FromInt32(1)))
		XTcl_UtfToLower(tls, (*TTcl_DString)(unsafe.Pointer(bp)).Fstring1)
		knownEncoding = _SearchKnownEncodings(tls, encoding)
		if knownEncoding != libc.UintptrFromInt32(0) {
			XTcl_DStringAppend(tls, bufPtr, knownEncoding, int64(-libc.Int32FromInt32(1)))
		} else {
			if libc.UintptrFromInt32(0) != XTcl_GetEncoding(tls, libc.UintptrFromInt32(0), encoding) {
				XTcl_DStringAppend(tls, bufPtr, encoding, int64(-libc.Int32FromInt32(1)))
			}
		}
		XTcl_DStringFree(tls, bp)
		if (*TTcl_DString)(unsafe.Pointer(bufPtr)).Flength != 0 {
			return (*TTcl_DString)(unsafe.Pointer(bufPtr)).Fstring1
		}
	}
	/*
	 * Classic fallback check. This tries a homebrew algorithm to determine
	 * what encoding should be used based on env vars.
	 */
	encoding = libc.Xgetenv(tls, __ccgo_ts+78053)
	if encoding == libc.UintptrFromInt32(0) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(encoding))) == int32('\000') {
		encoding = libc.Xgetenv(tls, __ccgo_ts+78060)
	}
	if encoding == libc.UintptrFromInt32(0) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(encoding))) == int32('\000') {
		encoding = libc.Xgetenv(tls, __ccgo_ts+78069)
	}
	if encoding == libc.UintptrFromInt32(0) || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(encoding))) == int32('\000') {
		encoding = libc.UintptrFromInt32(0)
	}
	if encoding != libc.UintptrFromInt32(0) {
		XTcl_DStringInit(tls, bp+224)
		p = encoding
		encoding = XTcl_DStringAppend(tls, bp+224, p, int64(-libc.Int32FromInt32(1)))
		XTcl_UtfToLower(tls, (*TTcl_DString)(unsafe.Pointer(bp+224)).Fstring1)
		knownEncoding = _SearchKnownEncodings(tls, encoding)
		if knownEncoding != libc.UintptrFromInt32(0) {
			XTcl_DStringAppend(tls, bufPtr, knownEncoding, int64(-libc.Int32FromInt32(1)))
		} else {
			if libc.UintptrFromInt32(0) != XTcl_GetEncoding(tls, libc.UintptrFromInt32(0), encoding) {
				XTcl_DStringAppend(tls, bufPtr, encoding, int64(-libc.Int32FromInt32(1)))
			}
		}
		if (*TTcl_DString)(unsafe.Pointer(bufPtr)).Flength != 0 {
			XTcl_DStringFree(tls, bp+224)
			return (*TTcl_DString)(unsafe.Pointer(bufPtr)).Fstring1
		}
		/*
		 * We didn't recognize the full value as an encoding name. If there is
		 * an encoding subfield, we can try to guess from that.
		 */
		p = encoding
		for {
			if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('\000')) {
				break
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('.') {
				p++
				break
			}
			goto _1
		_1:
			;
			p++
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('\000') {
			knownEncoding = _SearchKnownEncodings(tls, p)
			if knownEncoding != libc.UintptrFromInt32(0) {
				XTcl_DStringAppend(tls, bufPtr, knownEncoding, int64(-libc.Int32FromInt32(1)))
			} else {
				if libc.UintptrFromInt32(0) != XTcl_GetEncoding(tls, libc.UintptrFromInt32(0), p) {
					XTcl_DStringAppend(tls, bufPtr, p, int64(-libc.Int32FromInt32(1)))
				}
			}
		}
		XTcl_DStringFree(tls, bp+224)
		if (*TTcl_DString)(unsafe.Pointer(bufPtr)).Flength != 0 {
			return (*TTcl_DString)(unsafe.Pointer(bufPtr)).Fstring1
		}
	}
	return XTcl_DStringAppend(tls, bufPtr, __ccgo_ts+29080, int64(-libc.Int32FromInt32(1)))
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpSetVariables --
 *
 *	Performs platform-specific interpreter initialization related to the
 *	tcl_library and tcl_platform variables, and other platform-specific
 *	things.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Sets "tclDefaultLibrary", "tcl_pkgPath", and "tcl_platform" Tcl
 *	variables.
 *
 *----------------------------------------------------------------------
 */

func XTclpSetVariables(tls *libc.TLS, interp uintptr) {
	bp := tls.Alloc(848)
	defer tls.Free(848)
	var native, origPaths, p, pkgListObj, pwEnt, q, resolvedPaths, user, v1 uintptr
	var unameOK int32
	var _ /* ds at bp+392 */ TTcl_DString
	var _ /* ds at bp+616 */ TTcl_DString
	var _ /* name at bp+0 */ Tutsname
	_, _, _, _, _, _, _, _, _, _ = native, origPaths, p, pkgListObj, pwEnt, q, resolvedPaths, unameOK, user, v1
	pkgListObj = XTcl_NewObj(tls)
	p = uintptr(unsafe.Pointer(&_pkgPath))
	for {
		v1 = libc.Xstrchr(tls, p, int32(':'))
		q = v1
		if !(v1 != libc.UintptrFromInt32(0)) {
			break
		}
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), pkgListObj, XTcl_NewStringObj(tls, p, int64(q)-int64(p)))
		p = q + uintptr(1)
	}
	if *(*uint8)(unsafe.Pointer(p)) != 0 {
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), pkgListObj, XTcl_NewStringObj(tls, p, int64(-int32(1))))
	}
	XTcl_ObjSetVar2(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+42292, int64(-int32(1))), libc.UintptrFromInt32(0), pkgListObj, int32(TCL_GLOBAL_ONLY))
	origPaths = XTcl_GetVar2Ex(tls, interp, __ccgo_ts+42292, libc.UintptrFromInt32(0), int32(TCL_GLOBAL_ONLY))
	resolvedPaths = XTclResolveTildePathList(tls, origPaths)
	if resolvedPaths != origPaths && resolvedPaths != libc.UintptrFromInt32(0) {
		XTcl_SetVar2Ex(tls, interp, __ccgo_ts+42292, libc.UintptrFromInt32(0), resolvedPaths, int32(TCL_GLOBAL_ONLY))
	}
	XTcl_SetVar2(tls, interp, __ccgo_ts+7126, __ccgo_ts+45117, __ccgo_ts+78074, int32(TCL_GLOBAL_ONLY))
	unameOK = 0
	if libc.Xuname(tls, bp) >= 0 {
		unameOK = int32(1)
		native = XTcl_ExternalToUtfDString(tls, libc.UintptrFromInt32(0), bp, int64(-libc.Int32FromInt32(1)), bp+392)
		XTcl_SetVar2(tls, interp, __ccgo_ts+7126, __ccgo_ts+42248, native, int32(TCL_GLOBAL_ONLY))
		XTcl_DStringFree(tls, bp+392)
		/*
		 * The following code is a special hack to handle differences in the
		 * way version information is returned by uname. On most systems the
		 * full version number is available in name.release. However, under
		 * AIX the major version number is in name.version and the minor
		 * version number is in name.release.
		 */
		if libc.Xstrchr(tls, bp+130, int32('.')) != libc.UintptrFromInt32(0) || !(libc.BoolInt32(uint32(*(*uint8)(unsafe.Pointer(bp + 195)))-libc.Uint32FromUint8('0') < libc.Uint32FromInt32(10)) != 0) { /* INTL: digit */
			XTcl_SetVar2(tls, interp, __ccgo_ts+7126, __ccgo_ts+42251, bp+130, int32(TCL_GLOBAL_ONLY))
		} else {
			XTcl_SetVar2(tls, interp, __ccgo_ts+7126, __ccgo_ts+42251, bp+195, int32(TCL_GLOBAL_ONLY))
			XTcl_SetVar2(tls, interp, __ccgo_ts+7126, __ccgo_ts+42251, __ccgo_ts+35293, libc.Int32FromInt32(TCL_GLOBAL_ONLY)|libc.Int32FromInt32(TCL_APPEND_VALUE))
			XTcl_SetVar2(tls, interp, __ccgo_ts+7126, __ccgo_ts+42251, bp+130, libc.Int32FromInt32(TCL_GLOBAL_ONLY)|libc.Int32FromInt32(TCL_APPEND_VALUE))
		}
		XTcl_SetVar2(tls, interp, __ccgo_ts+7126, __ccgo_ts+42261, bp+260, int32(TCL_GLOBAL_ONLY))
	}
	if !(unameOK != 0) {
		XTcl_SetVar2(tls, interp, __ccgo_ts+7126, __ccgo_ts+42248, __ccgo_ts+1945, int32(TCL_GLOBAL_ONLY))
		XTcl_SetVar2(tls, interp, __ccgo_ts+7126, __ccgo_ts+42251, __ccgo_ts+1945, int32(TCL_GLOBAL_ONLY))
		XTcl_SetVar2(tls, interp, __ccgo_ts+7126, __ccgo_ts+42261, __ccgo_ts+1945, int32(TCL_GLOBAL_ONLY))
	}
	/*
	 * Copy the username of the real user (according to getuid()) into
	 * tcl_platform(user).
	 */
	pwEnt = XTclpGetPwUid(tls, libc.Xgetuid(tls))
	if pwEnt == libc.UintptrFromInt32(0) {
		user = __ccgo_ts + 1945
		XTcl_DStringInit(tls, bp+616) /* ensure cleanliness */
	} else {
		user = XTcl_ExternalToUtfDString(tls, libc.UintptrFromInt32(0), (*Tpasswd)(unsafe.Pointer(pwEnt)).Fpw_name, int64(-libc.Int32FromInt32(1)), bp+616)
	}
	XTcl_SetVar2(tls, interp, __ccgo_ts+7126, __ccgo_ts+42269, user, int32(TCL_GLOBAL_ONLY))
	XTcl_DStringFree(tls, bp+616)
	/*
	 * Define what the platform PATH separator is. [TIP #315]
	 */
	XTcl_SetVar2(tls, interp, __ccgo_ts+7126, __ccgo_ts+78079, __ccgo_ts+21829, int32(TCL_GLOBAL_ONLY))
}

/*
 *----------------------------------------------------------------------
 *
 * TclpFindVariable --
 *
 *	Locate the entry in environ for a given name. On Unix this routine is
 *	case sensitive, on Windows this matches mixed case.
 *
 * Results:
 *	The return value is the index in environ of an entry with the name
 *	"name", or -1 if there is no such entry. The integer at *lengthPtr is
 *	filled in with the length of name (if a matching entry is found) or
 *	the length of the environ array (if no matching entry is found).
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclpFindVariable(tls *libc.TLS, name uintptr, lengthPtr uintptr) (r TTcl_Size) {
	bp := tls.Alloc(224)
	defer tls.Free(224) /* Used to return length of name (for
	 * successful searches) or number of non-NULL
	 * entries in environ (for unsuccessful
	 * searches). */
	var env, p1, p2 uintptr
	var i, result TTcl_Size
	var _ /* envString at bp+0 */ TTcl_DString
	_, _, _, _, _ = env, i, p1, p2, result
	result = int64(-int32(1))
	XTcl_DStringInit(tls, bp)
	i = 0
	env = *(*uintptr)(unsafe.Pointer(libc.Xenviron + uintptr(i)*8))
	for {
		if !(env != libc.UintptrFromInt32(0)) {
			break
		}
		p1 = XTcl_ExternalToUtfDString(tls, libc.UintptrFromInt32(0), env, int64(-libc.Int32FromInt32(1)), bp)
		p2 = name
		for {
			if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p2))) == libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p1)))) {
				break
			}
			/* NULL loop body. */
			goto _2
		_2:
			;
			p1++
			p2++
		}
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p1))) == int32('=') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p2))) == int32('\000') {
			*(*TTcl_Size)(unsafe.Pointer(lengthPtr)) = int64(p2) - int64(name)
			result = i
			goto done
		}
		XTcl_DStringFree(tls, bp)
		goto _1
	_1:
		;
		i++
		env = *(*uintptr)(unsafe.Pointer(libc.Xenviron + uintptr(i)*8))
	}
	*(*TTcl_Size)(unsafe.Pointer(lengthPtr)) = i
	goto done
done:
	;
	XTcl_DStringFree(tls, bp)
	return result
}

const PCondTimedWait = 0
const PCondWait = 0
const PMutexDestroy = 0
const PMutexLock = 0
const PMutexUnlock = 0

/* Epoch of the tcl environment
 * (if changed with tcl-env). */

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * TIP #509. Ensures that Tcl's mutexes are reentrant.
 *
 *----------------------------------------------------------------------
 *
 * PMutexInit --
 *
 *	Sets up the memory pointed to by its argument so that it contains the
 *	implementation of a recursive lock. Caller supplies the space.
 *
 *----------------------------------------------------------------------
 *
 * PMutexDestroy --
 *
 *	Tears down the implementation of a recursive lock (but does not
 *	deallocate the space holding the lock).
 *
 *----------------------------------------------------------------------
 *
 * PMutexLock --
 *
 *	Locks a recursive lock. (Similar to pthread_mutex_lock)
 *
 *----------------------------------------------------------------------
 *
 * PMutexUnlock --
 *
 *	Unlocks a recursive lock. (Similar to pthread_mutex_unlock)
 *
 *----------------------------------------------------------------------
 *
 * PCondWait --
 *
 *	Waits on a condition variable linked a recursive lock. (Similar to
 *	pthread_cond_wait)
 *
 *----------------------------------------------------------------------
 *
 * PCondTimedWait --
 *
 *	Waits for a limited amount of time on a condition variable linked to a
 *	recursive lock. (Similar to pthread_cond_timedwait)
 *
 *----------------------------------------------------------------------
 */

/*
 * Pthread has native reentrant (AKA recursive) mutexes. Use them for
 * Tcl_Mutex.
 */

type TPMutex = struct {
	F__u struct {
		F__vi [0][10]int32
		F__p  [0][5]uintptr
		F__i  [10]int32
	}
}

func _PMutexInit(tls *libc.TLS, pmutexPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _ /* attr at bp+0 */ Tpthread_mutexattr_t
	libc.Xpthread_mutexattr_init(tls, bp)
	libc.Xpthread_mutexattr_settype(tls, bp, int32(PTHREAD_MUTEX_RECURSIVE))
	libc.Xpthread_mutex_init(tls, pmutexPtr, bp)
}

/*
 * globalLock is used to serialize creation of mutexes, condition variables,
 * and thread local storage. This is the only place that can count on the
 * ability to statically initialize the mutex.
 */

var _globalLock = Tpthread_mutex_t{}

/*
 * initLock is used to serialize initialization and finalization of Tcl. It
 * cannot use any dynamically allocated storage.
 */

var _initLock = Tpthread_mutex_t{}

/*
 * allocLock is used by Tcl's version of malloc for synchronization. For
 * obvious reasons, cannot use any dynamically allocated storage.
 */

var _allocLock TPMutex
var _allocLockInitOnce = int32(PTHREAD_ONCE_INIT)

func _allocLockInit(tls *libc.TLS) {
	_PMutexInit(tls, uintptr(unsafe.Pointer(&_allocLock)))
}

var _allocLockPtr = uintptr(unsafe.Pointer(&_allocLock))

/*
 *----------------------------------------------------------------------
 *
 * TclpThreadCreate --
 *
 *	This procedure creates a new thread.
 *
 * Results:
 *	TCL_OK if the thread could be created. The thread ID is returned in a
 *	parameter.
 *
 * Side effects:
 *	A new thread is created.
 *
 *----------------------------------------------------------------------
 */

func XTclpThreadCreate(tls *libc.TLS, idPtr uintptr, proc uintptr, clientData uintptr, stackSize Tsize_t, flags int32) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Flags controlling behaviour of the new
	 * thread. */
	var result int32
	var _ /* attr at bp+0 */ Tpthread_attr_t
	var _ /* theThread at bp+56 */ Tpthread_t
	_ = result
	libc.Xpthread_attr_init(tls, bp)
	libc.Xpthread_attr_setscope(tls, bp, PTHREAD_SCOPE_SYSTEM)
	if stackSize != libc.Uint64FromInt32(libc.Int32FromInt32(TCL_THREAD_STACK_DEFAULT)) {
		libc.Xpthread_attr_setstacksize(tls, bp, stackSize)
	}
	if !(flags&libc.Int32FromInt32(TCL_THREAD_JOINABLE) != 0) {
		libc.Xpthread_attr_setdetachstate(tls, bp, int32(PTHREAD_CREATE_DETACHED))
	}
	if libc.Xpthread_create(tls, bp+56, bp, proc, clientData) != 0 && libc.Xpthread_create(tls, bp+56, libc.UintptrFromInt32(0), proc, clientData) != 0 {
		result = int32(TCL_ERROR)
	} else {
		*(*TTcl_ThreadId)(unsafe.Pointer(idPtr)) = *(*Tpthread_t)(unsafe.Pointer(bp + 56))
		result = TCL_OK
	}
	libc.Xpthread_attr_destroy(tls, bp)
	return result
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_JoinThread --
 *
 *	This procedure waits upon the exit of the specified thread.
 *
 * Results:
 *	TCL_OK if the wait was successful, TCL_ERROR else.
 *
 * Side effects:
 *	The result area is set to the exit code of the thread we waited upon.
 *
 *----------------------------------------------------------------------
 */

func XTcl_JoinThread(tls *libc.TLS, threadId TTcl_ThreadId, state uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Reference to the storage the result of the
	 * thread we wait upon will be written into.
	 * May be NULL. */
	var result, v1 int32
	var retcodePtr uintptr
	var _ /* retcode at bp+0 */ uint64
	_, _, _ = result, retcodePtr, v1
	retcodePtr = bp
	result = libc.Xpthread_join(tls, threadId, retcodePtr)
	if state != 0 {
		*(*int32)(unsafe.Pointer(state)) = libc.Int32FromUint64(*(*uint64)(unsafe.Pointer(bp)))
	}
	if result == 0 {
		v1 = TCL_OK
	} else {
		v1 = int32(TCL_ERROR)
	}
	return v1
}

/*
 *----------------------------------------------------------------------
 *
 * TclpThreadExit --
 *
 *	This procedure terminates the current thread.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	This procedure terminates the current thread.
 *
 *----------------------------------------------------------------------
 */
func XTclpThreadExit(tls *libc.TLS, status int32) {
	libc.Xpthread_exit(tls, uintptr(int64(status)))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetCurrentThread --
 *
 *	This procedure returns the ID of the currently running thread.
 *
 * Results:
 *	A thread ID.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetCurrentThread(tls *libc.TLS) (r TTcl_ThreadId) {
	return libc.Xpthread_self(tls)
}

/*
 *----------------------------------------------------------------------
 *
 * TclpInitLock
 *
 *	This procedure is used to grab a lock that serializes initialization
 *	and finalization of Tcl. On some platforms this may also initialize
 *	the mutex used to serialize creation of more mutexes and thread local
 *	storage keys.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Acquire the initialization mutex.
 *
 *----------------------------------------------------------------------
 */

func XTclpInitLock(tls *libc.TLS) {
	libc.Xpthread_mutex_lock(tls, uintptr(unsafe.Pointer(&_initLock)))
}

/*
 *----------------------------------------------------------------------
 *
 * TclFinalizeLock
 *
 *	This procedure is used to destroy all private resources used in this
 *	file.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Destroys everything private. TclpInitLock must be held entering this
 *	function.
 *
 *----------------------------------------------------------------------
 */

func XTclFinalizeLock(tls *libc.TLS) {
	/*
	 * You do not need to destroy mutexes that were created with the
	 * PTHREAD_MUTEX_INITIALIZER macro. These mutexes do not need any
	 * destruction: globalLock, allocLock, and initLock.
	 */
	libc.Xpthread_mutex_unlock(tls, uintptr(unsafe.Pointer(&_initLock)))
}

/*
 *----------------------------------------------------------------------
 *
 * TclpInitUnlock
 *
 *	This procedure is used to release a lock that serializes
 *	initialization and finalization of Tcl.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Release the initialization mutex.
 *
 *----------------------------------------------------------------------
 */

func XTclpInitUnlock(tls *libc.TLS) {
	libc.Xpthread_mutex_unlock(tls, uintptr(unsafe.Pointer(&_initLock)))
}

/*
 *----------------------------------------------------------------------
 *
 * TclpGlobalLock
 *
 *	This procedure is used to grab a lock that serializes creation and
 *	finalization of serialization objects. This interface is only needed
 *	in finalization; it is hidden during creation of the objects.
 *
 *	This lock must be different than the initLock because the initLock is
 *	held during creation of synchronization objects.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Acquire the global mutex.
 *
 *----------------------------------------------------------------------
 */

func XTclpGlobalLock(tls *libc.TLS) {
	libc.Xpthread_mutex_lock(tls, uintptr(unsafe.Pointer(&_globalLock)))
}

/*
 *----------------------------------------------------------------------
 *
 * TclpGlobalUnlock
 *
 *	This procedure is used to release a lock that serializes creation and
 *	finalization of synchronization objects.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Release the global mutex.
 *
 *----------------------------------------------------------------------
 */

func XTclpGlobalUnlock(tls *libc.TLS) {
	libc.Xpthread_mutex_unlock(tls, uintptr(unsafe.Pointer(&_globalLock)))
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetAllocMutex
 *
 *	This procedure returns a pointer to a statically initialized mutex for
 *	use by the memory allocator. The allocator must use this lock, because
 *	all other locks are allocated...
 *
 * Results:
 *	A pointer to a mutex that is suitable for passing to Tcl_MutexLock and
 *	Tcl_MutexUnlock.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTcl_GetAllocMutex(tls *libc.TLS) (r uintptr) {
	var allocLockPtrPtr uintptr
	_ = allocLockPtrPtr
	allocLockPtrPtr = uintptr(unsafe.Pointer(&_allocLockPtr))
	_pthread_once(tls, uintptr(unsafe.Pointer(&_allocLockInitOnce)), __ccgo_fp(_allocLockInit))
	return allocLockPtrPtr
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_MutexLock --
 *
 *	This procedure is invoked to lock a mutex. This procedure handles
 *	initializing the mutex, if necessary. The caller can rely on the fact
 *	that Tcl_Mutex is an opaque pointer. This routine will change that
 *	pointer from NULL after first use.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	May block the current thread. The mutex is acquired when this returns.
 *	Will allocate memory for a pthread_mutex_t and initialize this the
 *	first time this Tcl_Mutex is used.
 *
 *----------------------------------------------------------------------
 */

func XTcl_MutexLock(tls *libc.TLS, mutexPtr uintptr) {
	/* Really (PMutex **) */
	var pmutexPtr uintptr
	_ = pmutexPtr
	if *(*TTcl_Mutex)(unsafe.Pointer(mutexPtr)) == libc.UintptrFromInt32(0) {
		libc.Xpthread_mutex_lock(tls, uintptr(unsafe.Pointer(&_globalLock)))
		if *(*TTcl_Mutex)(unsafe.Pointer(mutexPtr)) == libc.UintptrFromInt32(0) {
			/*
			 * Double inside global lock check to avoid a race condition.
			 */
			pmutexPtr = XTcl_Alloc(tls, uint64(40))
			_PMutexInit(tls, pmutexPtr)
			*(*TTcl_Mutex)(unsafe.Pointer(mutexPtr)) = pmutexPtr
			XTclRememberMutex(tls, mutexPtr)
		}
		libc.Xpthread_mutex_unlock(tls, uintptr(unsafe.Pointer(&_globalLock)))
	}
	pmutexPtr = *(*uintptr)(unsafe.Pointer(mutexPtr))
	libc.Xpthread_mutex_lock(tls, pmutexPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_MutexUnlock --
 *
 *	This procedure is invoked to unlock a mutex. The mutex must have been
 *	locked by Tcl_MutexLock.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The mutex is released when this returns.
 *
 *----------------------------------------------------------------------
 */

func XTcl_MutexUnlock(tls *libc.TLS, mutexPtr uintptr) {
	/* Really (PMutex **) */
	var pmutexPtr uintptr
	_ = pmutexPtr
	pmutexPtr = *(*uintptr)(unsafe.Pointer(mutexPtr))
	libc.Xpthread_mutex_unlock(tls, pmutexPtr)
}

/*
 *----------------------------------------------------------------------
 *
 * TclpFinalizeMutex --
 *
 *	This procedure is invoked to clean up one mutex. This is only safe to
 *	call at the end of time.
 *
 *	This assumes the Global Lock is held.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The mutex list is deallocated.
 *
 *----------------------------------------------------------------------
 */

func XTclpFinalizeMutex(tls *libc.TLS, mutexPtr uintptr) {
	var pmutexPtr uintptr
	_ = pmutexPtr
	pmutexPtr = *(*uintptr)(unsafe.Pointer(mutexPtr))
	if pmutexPtr != libc.UintptrFromInt32(0) {
		libc.Xpthread_mutex_destroy(tls, pmutexPtr)
		XTclpFree(tls, pmutexPtr)
		*(*TTcl_Mutex)(unsafe.Pointer(mutexPtr)) = libc.UintptrFromInt32(0)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ConditionWait --
 *
 *	This procedure is invoked to wait on a condition variable. The mutex
 *	is automically released as part of the wait, and automatically grabbed
 *	when the condition is signaled.
 *
 *	The mutex must be held when this procedure is called.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	May block the current thread. The mutex is acquired when this returns.
 *	Will allocate memory for a pthread_mutex_t and initialize this the
 *	first time this Tcl_Mutex is used.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ConditionWait(tls *libc.TLS, condPtr uintptr, mutexPtr uintptr, timePtr uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Timeout on waiting period */
	var pcondPtr, pmutexPtr uintptr
	var _ /* now at bp+16 */ TTcl_Time
	var _ /* ptime at bp+0 */ Ttimespec
	_, _ = pcondPtr, pmutexPtr
	if *(*TTcl_Condition)(unsafe.Pointer(condPtr)) == libc.UintptrFromInt32(0) {
		libc.Xpthread_mutex_lock(tls, uintptr(unsafe.Pointer(&_globalLock)))
		/*
		 * Double check inside mutex to avoid race, then initialize condition
		 * variable if necessary.
		 */
		if *(*TTcl_Condition)(unsafe.Pointer(condPtr)) == libc.UintptrFromInt32(0) {
			pcondPtr = XTcl_Alloc(tls, uint64(48))
			libc.Xpthread_cond_init(tls, pcondPtr, libc.UintptrFromInt32(0))
			*(*TTcl_Condition)(unsafe.Pointer(condPtr)) = pcondPtr
			XTclRememberCondition(tls, condPtr)
		}
		libc.Xpthread_mutex_unlock(tls, uintptr(unsafe.Pointer(&_globalLock)))
	}
	pmutexPtr = *(*uintptr)(unsafe.Pointer(mutexPtr))
	pcondPtr = *(*uintptr)(unsafe.Pointer(condPtr))
	if timePtr == libc.UintptrFromInt32(0) {
		libc.Xpthread_cond_wait(tls, pcondPtr, pmutexPtr)
	} else {
		/*
		 * Make sure to take into account the microsecond component of the
		 * current time, including possible overflow situations. [Bug #411603]
		 */
		XTcl_GetTime(tls, bp+16)
		(*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_sec = (*TTcl_Time)(unsafe.Pointer(timePtr)).Fsec + (*(*TTcl_Time)(unsafe.Pointer(bp + 16))).Fsec + ((*TTcl_Time)(unsafe.Pointer(timePtr)).Fusec+(*(*TTcl_Time)(unsafe.Pointer(bp + 16))).Fusec)/int64(1000000)
		(*(*Ttimespec)(unsafe.Pointer(bp))).Ftv_nsec = int64(1000) * (((*TTcl_Time)(unsafe.Pointer(timePtr)).Fusec + (*(*TTcl_Time)(unsafe.Pointer(bp + 16))).Fusec) % int64(1000000))
		libc.Xpthread_cond_timedwait(tls, pcondPtr, pmutexPtr, bp)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ConditionNotify --
 *
 *	This procedure is invoked to signal a condition variable.
 *
 *	The mutex must be held during this call to avoid races, but this
 *	interface does not enforce that.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	May unblock another thread.
 *
 *----------------------------------------------------------------------
 */

func XTcl_ConditionNotify(tls *libc.TLS, condPtr uintptr) {
	var pcondPtr uintptr
	_ = pcondPtr
	pcondPtr = *(*uintptr)(unsafe.Pointer(condPtr))
	if pcondPtr != libc.UintptrFromInt32(0) {
		libc.Xpthread_cond_broadcast(tls, pcondPtr)
	} else {
		/*
		 * No-one has used the condition variable, so there are no waiters.
		 */
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclpFinalizeCondition --
 *
 *	This procedure is invoked to clean up a condition variable. This is
 *	only safe to call at the end of time.
 *
 *	This assumes the Global Lock is held.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	The condition variable is deallocated.
 *
 *----------------------------------------------------------------------
 */

func XTclpFinalizeCondition(tls *libc.TLS, condPtr uintptr) {
	var pcondPtr uintptr
	_ = pcondPtr
	pcondPtr = *(*uintptr)(unsafe.Pointer(condPtr))
	if pcondPtr != libc.UintptrFromInt32(0) {
		libc.Xpthread_cond_destroy(tls, pcondPtr)
		XTclpFree(tls, pcondPtr)
		*(*TTcl_Condition)(unsafe.Pointer(condPtr)) = libc.UintptrFromInt32(0)
	}
}

/*
 * Additions by AOL for specialized thread memory allocator.
 */

var _key Tpthread_key_t

type TAllocMutex = struct {
	Ftlock TTcl_Mutex
	Fplock TPMutex
}

func XTclpNewAllocMutex(tls *libc.TLS) (r uintptr) {
	var lockPtr, plockPtr uintptr
	_, _ = lockPtr, plockPtr
	lockPtr = libc.Xmalloc(tls, uint64(48))
	if lockPtr == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+78093, 0)
	}
	plockPtr = lockPtr + 8
	(*TAllocMutex)(unsafe.Pointer(lockPtr)).Ftlock = plockPtr
	_PMutexInit(tls, lockPtr+8)
	return lockPtr
}

func XTclpFreeAllocMutex(tls *libc.TLS, mutex uintptr) {
	/* The alloc mutex to free. */
	var lockPtr uintptr
	_ = lockPtr
	lockPtr = mutex
	if !(lockPtr != 0) {
		return
	}
	libc.Xpthread_mutex_destroy(tls, lockPtr+8)
	libc.Xfree(tls, lockPtr)
}

func XTclpInitAllocCache(tls *libc.TLS) {
	libc.Xpthread_key_create(tls, uintptr(unsafe.Pointer(&_key)), libc.UintptrFromInt32(0))
}

func XTclpFreeAllocCache(tls *libc.TLS, ptr uintptr) {
	if ptr != libc.UintptrFromInt32(0) {
		/*
		 * Called by TclFinalizeThreadAllocThread() during the thread
		 * finalization initiated from Tcl_FinalizeThread()
		 */
		XTclFreeAllocCache(tls, ptr)
		libc.Xpthread_setspecific(tls, _key, libc.UintptrFromInt32(0))
	} else {
		/*
		 * Called by TclFinalizeThreadAlloc() during the process
		 * finalization initiated from Tcl_Finalize()
		 */
		libc.Xpthread_key_delete(tls, _key)
	}
}

func XTclpGetAllocCache(tls *libc.TLS) (r uintptr) {
	return libc.Xpthread_getspecific(tls, _key)
}

func XTclpSetAllocCache(tls *libc.TLS, arg uintptr) {
	libc.Xpthread_setspecific(tls, _key, arg)
}

func XTclpThreadCreateKey(tls *libc.TLS) (r uintptr) {
	var ptkeyPtr uintptr
	_ = ptkeyPtr
	ptkeyPtr = libc.Xmalloc(tls, uint64(4))
	if libc.UintptrFromInt32(0) == ptkeyPtr {
		XTcl_Panic(tls, __ccgo_ts+78117, 0)
	}
	if libc.Xpthread_key_create(tls, ptkeyPtr, libc.UintptrFromInt32(0)) != 0 {
		XTcl_Panic(tls, __ccgo_ts+78148, 0)
	}
	return ptkeyPtr
}

func XTclpThreadDeleteKey(tls *libc.TLS, keyPtr uintptr) {
	var ptkeyPtr uintptr
	_ = ptkeyPtr
	ptkeyPtr = keyPtr
	if libc.Xpthread_key_delete(tls, *(*Tpthread_key_t)(unsafe.Pointer(ptkeyPtr))) != 0 {
		XTcl_Panic(tls, __ccgo_ts+78178, 0)
	}
	libc.Xfree(tls, keyPtr)
}

func XTclpThreadSetGlobalTSD(tls *libc.TLS, tsdKeyPtr uintptr, ptr uintptr) {
	var ptkeyPtr uintptr
	_ = ptkeyPtr
	ptkeyPtr = tsdKeyPtr
	if libc.Xpthread_setspecific(tls, *(*Tpthread_key_t)(unsafe.Pointer(ptkeyPtr)), ptr) != 0 {
		XTcl_Panic(tls, __ccgo_ts+78200, 0)
	}
}

func XTclpThreadGetGlobalTSD(tls *libc.TLS, tsdKeyPtr uintptr) (r uintptr) {
	var ptkeyPtr uintptr
	_ = ptkeyPtr
	ptkeyPtr = tsdKeyPtr
	return libc.Xpthread_getspecific(tls, *(*Tpthread_key_t)(unsafe.Pointer(ptkeyPtr)))
}

const NEED_GR_CLEANER = 1
const NEED_PW_CLEANER = 1

/* Epoch of the tcl environment
 * (if changed with tcl-env). */

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * See also: SC_BLOCKING_STYLE in unix/tcl.m4
 */

/*
 * Used to pad structures at size'd boundaries
 *
 * This macro assumes that the pointer 'buffer' was created from an aligned
 * pointer by adding the 'length'. If this 'length' was not a multiple of the
 * 'size' the result is unaligned and PadBuffer corrects both the pointer,
 * _and_ the 'length'. The latter means that future increments of 'buffer' by
 * 'length' stay aligned.
 */

/*
 * Per-thread private storage used to store values returned from MT-unsafe
 * library calls.
 */

type TThreadSpecificData14 = struct {
	Fpwd     Tpasswd
	Fpbuf    uintptr
	Fpbuflen int32
	Fgrp     Tgroup
	Fgbuf    uintptr
	Fgbuflen int32
	Fhent    Thostent
	Fhbuf    [2048]uint8
}

var _dataKey12 TTcl_ThreadDataKey

/*
 *---------------------------------------------------------------------------
 *
 * TclUnixSetBlockingMode --
 *
 *	Set the blocking mode of a file descriptor.
 *
 * Results:
 *
 *	0 on success, -1 (with errno set) on error.
 *
 *---------------------------------------------------------------------------
 */

func XTclUnixSetBlockingMode(tls *libc.TLS, fd int32, mode int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Either TCL_MODE_BLOCKING or
	 * TCL_MODE_NONBLOCKING. */
	var flags int32
	_ = flags
	flags = libc.Xfcntl(tls, fd, int32(F_GETFL), 0)
	if mode == TCL_MODE_BLOCKING {
		flags &= ^libc.Int32FromInt32(O_NONBLOCK)
	} else {
		flags |= int32(O_NONBLOCK)
	}
	return libc.Xfcntl(tls, fd, int32(F_SETFL), libc.VaList(bp+8, flags))
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpGetPwNam --
 *
 *      Thread-safe wrappers for getpwnam(). See "man getpwnam" for more
 *      details.
 *
 * Results:
 *      Pointer to struct passwd on success or NULL on error.
 *
 * Side effects:
 *      None.
 *
 *---------------------------------------------------------------------------
 */

func XTclpGetPwNam(tls *libc.TLS, name uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var e int32
	var tsdPtr, v1 uintptr
	var _ /* pwPtr at bp+0 */ uintptr
	_, _, _ = e, tsdPtr, v1
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey12)), int64(2192))
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	/*
	 * How to allocate a buffer of the right initial size. If you want the
	 * gory detail, see http://www.opengroup.org/austin/docs/austin_328.txt
	 * and weep.
	 */
	if (*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fpbuf == libc.UintptrFromInt32(0) {
		(*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fpbuflen = int32(libc.Xsysconf(tls, int32(_SC_GETPW_R_SIZE_MAX)))
		if (*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fpbuflen < int32(1) {
			(*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fpbuflen = int32(1024)
		}
		(*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fpbuf = XTcl_Alloc(tls, libc.Uint64FromInt32((*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fpbuflen))
		XTcl_CreateThreadExitHandler(tls, __ccgo_fp(_FreePwBuf), libc.UintptrFromInt32(0))
	}
	for int32(1) != 0 {
		e = libc.Xgetpwnam_r(tls, name, tsdPtr, (*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fpbuf, libc.Uint64FromInt32((*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fpbuflen), bp)
		if e == 0 {
			break
		} else {
			if e != int32(ERANGE) {
				return libc.UintptrFromInt32(0)
			}
		}
		*(*int32)(unsafe.Pointer(tsdPtr + 56)) *= int32(2)
		(*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fpbuf = XTcl_Realloc(tls, (*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fpbuf, libc.Uint64FromInt32((*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fpbuflen))
	}
	if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
		v1 = tsdPtr
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	return v1
	return libc.UintptrFromInt32(0) /* Not reached. */
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpGetPwUid --
 *
 *      Thread-safe wrappers for getpwuid(). See "man getpwuid" for more
 *      details.
 *
 * Results:
 *      Pointer to struct passwd on success or NULL on error.
 *
 * Side effects:
 *      None.
 *
 *---------------------------------------------------------------------------
 */

func XTclpGetPwUid(tls *libc.TLS, uid Tuid_t) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var e int32
	var tsdPtr, v1 uintptr
	var _ /* pwPtr at bp+0 */ uintptr
	_, _, _ = e, tsdPtr, v1
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey12)), int64(2192))
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	/*
	 * How to allocate a buffer of the right initial size. If you want the
	 * gory detail, see http://www.opengroup.org/austin/docs/austin_328.txt
	 * and weep.
	 */
	if (*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fpbuf == libc.UintptrFromInt32(0) {
		(*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fpbuflen = int32(libc.Xsysconf(tls, int32(_SC_GETPW_R_SIZE_MAX)))
		if (*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fpbuflen < int32(1) {
			(*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fpbuflen = int32(1024)
		}
		(*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fpbuf = XTcl_Alloc(tls, libc.Uint64FromInt32((*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fpbuflen))
		XTcl_CreateThreadExitHandler(tls, __ccgo_fp(_FreePwBuf), libc.UintptrFromInt32(0))
	}
	for int32(1) != 0 {
		e = libc.Xgetpwuid_r(tls, uid, tsdPtr, (*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fpbuf, libc.Uint64FromInt32((*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fpbuflen), bp)
		if e == 0 {
			break
		} else {
			if e != int32(ERANGE) {
				return libc.UintptrFromInt32(0)
			}
		}
		*(*int32)(unsafe.Pointer(tsdPtr + 56)) *= int32(2)
		(*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fpbuf = XTcl_Realloc(tls, (*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fpbuf, libc.Uint64FromInt32((*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fpbuflen))
	}
	if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
		v1 = tsdPtr
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	return v1
	return libc.UintptrFromInt32(0) /* Not reached. */
}

/*
 *---------------------------------------------------------------------------
 *
 * FreePwBuf --
 *
 *	Helper that is used to dispose of space allocated and referenced from
 *	the ThreadSpecificData for user entries. (Darn that baroque POSIX
 *	reentrant interface.)
 *
 *---------------------------------------------------------------------------
 */

func _FreePwBuf(tls *libc.TLS, dummy337 uintptr) {
	var tsdPtr uintptr
	_ = tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey12)), int64(2192))
	XTclpFree(tls, (*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fpbuf)
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpGetGrNam --
 *
 *      Thread-safe wrappers for getgrnam(). See "man getgrnam" for more
 *      details.
 *
 * Results:
 *      Pointer to struct group on success or NULL on error.
 *
 * Side effects:
 *      None.
 *
 *---------------------------------------------------------------------------
 */

func XTclpGetGrNam(tls *libc.TLS, name uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var e int32
	var tsdPtr, v1 uintptr
	var _ /* grPtr at bp+0 */ uintptr
	_, _, _ = e, tsdPtr, v1
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey12)), int64(2192))
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	/*
	 * How to allocate a buffer of the right initial size. If you want the
	 * gory detail, see http://www.opengroup.org/austin/docs/austin_328.txt
	 * and weep.
	 */
	if (*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fgbuf == libc.UintptrFromInt32(0) {
		(*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fgbuflen = int32(libc.Xsysconf(tls, int32(_SC_GETGR_R_SIZE_MAX)))
		if (*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fgbuflen < int32(1) {
			(*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fgbuflen = int32(1024)
		}
		(*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fgbuf = XTcl_Alloc(tls, libc.Uint64FromInt32((*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fgbuflen))
		XTcl_CreateThreadExitHandler(tls, __ccgo_fp(_FreeGrBuf), libc.UintptrFromInt32(0))
	}
	for int32(1) != 0 {
		e = libc.Xgetgrnam_r(tls, name, tsdPtr+64, (*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fgbuf, libc.Uint64FromInt32((*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fgbuflen), bp)
		if e == 0 {
			break
		} else {
			if e != int32(ERANGE) {
				return libc.UintptrFromInt32(0)
			}
		}
		*(*int32)(unsafe.Pointer(tsdPtr + 104)) *= int32(2)
		(*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fgbuf = XTcl_Realloc(tls, (*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fgbuf, libc.Uint64FromInt32((*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fgbuflen))
	}
	if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
		v1 = tsdPtr + 64
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	return v1
	return libc.UintptrFromInt32(0) /* Not reached. */
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpGetGrGid --
 *
 *      Thread-safe wrappers for getgrgid(). See "man getgrgid" for more
 *      details.
 *
 * Results:
 *      Pointer to struct group on success or NULL on error.
 *
 * Side effects:
 *      None.
 *
 *---------------------------------------------------------------------------
 */

func XTclpGetGrGid(tls *libc.TLS, gid Tgid_t) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var e int32
	var tsdPtr, v1 uintptr
	var _ /* grPtr at bp+0 */ uintptr
	_, _, _ = e, tsdPtr, v1
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey12)), int64(2192))
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	/*
	 * How to allocate a buffer of the right initial size. If you want the
	 * gory detail, see http://www.opengroup.org/austin/docs/austin_328.txt
	 * and weep.
	 */
	if (*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fgbuf == libc.UintptrFromInt32(0) {
		(*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fgbuflen = int32(libc.Xsysconf(tls, int32(_SC_GETGR_R_SIZE_MAX)))
		if (*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fgbuflen < int32(1) {
			(*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fgbuflen = int32(1024)
		}
		(*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fgbuf = XTcl_Alloc(tls, libc.Uint64FromInt32((*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fgbuflen))
		XTcl_CreateThreadExitHandler(tls, __ccgo_fp(_FreeGrBuf), libc.UintptrFromInt32(0))
	}
	for int32(1) != 0 {
		e = libc.Xgetgrgid_r(tls, gid, tsdPtr+64, (*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fgbuf, libc.Uint64FromInt32((*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fgbuflen), bp)
		if e == 0 {
			break
		} else {
			if e != int32(ERANGE) {
				return libc.UintptrFromInt32(0)
			}
		}
		*(*int32)(unsafe.Pointer(tsdPtr + 104)) *= int32(2)
		(*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fgbuf = XTcl_Realloc(tls, (*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fgbuf, libc.Uint64FromInt32((*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fgbuflen))
	}
	if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
		v1 = tsdPtr + 64
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	return v1
	return libc.UintptrFromInt32(0) /* Not reached. */
}

/*
 *---------------------------------------------------------------------------
 *
 * FreeGrBuf --
 *
 *	Helper that is used to dispose of space allocated and referenced from
 *	the ThreadSpecificData for group entries. (Darn that baroque POSIX
 *	reentrant interface.)
 *
 *---------------------------------------------------------------------------
 */

func _FreeGrBuf(tls *libc.TLS, dummy520 uintptr) {
	var tsdPtr uintptr
	_ = tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey12)), int64(2192))
	XTclpFree(tls, (*TThreadSpecificData14)(unsafe.Pointer(tsdPtr)).Fgbuf)
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpGetHostByName --
 *
 *      Thread-safe wrappers for gethostbyname(). See "man gethostbyname" for
 *      more details.
 *
 * Results:
 *      Pointer to struct hostent on success or NULL on error.
 *
 * Side effects:
 *      None.
 *
 *---------------------------------------------------------------------------
 */

func XTclpGetHostByName(tls *libc.TLS, name uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var result int32
	var tsdPtr, v1 uintptr
	var _ /* hePtr at bp+0 */ uintptr
	var _ /* local_errno at bp+8 */ int32
	_, _, _ = result, tsdPtr, v1
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey12)), int64(2192))
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	result = libc.Xgethostbyname_r(tls, name, tsdPtr+112, tsdPtr+144, uint64(2048), bp, bp+8)
	if result == 0 {
		v1 = *(*uintptr)(unsafe.Pointer(bp))
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	return v1
	return libc.UintptrFromInt32(0) /* Not reached. */
}

/*
 *---------------------------------------------------------------------------
 *
 * TclpGetHostByAddr --
 *
 *      Thread-safe wrappers for gethostbyaddr(). See "man gethostbyaddr" for
 *      more details.
 *
 * Results:
 *      Pointer to struct hostent on success or NULL on error.
 *
 * Side effects:
 *      None.
 *
 *---------------------------------------------------------------------------
 */

func XTclpGetHostByAddr(tls *libc.TLS, addr uintptr, length int32, type1 int32) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var tsdPtr, v1 uintptr
	var _ /* hePtr at bp+0 */ uintptr
	var _ /* local_errno at bp+8 */ int32
	_, _ = tsdPtr, v1
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey12)), int64(2192))
	if libc.Xgethostbyaddr_r(tls, addr, libc.Uint32FromInt32(length), type1, tsdPtr+112, tsdPtr+144, uint64(2048), bp, bp+8) == 0 {
		v1 = tsdPtr + 112
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	return v1
	return libc.UintptrFromInt32(0) /* Not reached. */
}

const POLLERR = 8
const POLLHUP = 16
const POLLIN = 1
const POLLMSG = 1024
const POLLNVAL = 32
const POLLOUT = 4
const POLLPRI = 2
const POLLRDBAND = 128
const POLLRDHUP = 8192
const POLLRDNORM = 64
const POLLWRBAND = 512
const POLLWRNORM = 256
const POLL_DONE = 2
const POLL_WANT = 1

/* Epoch of the tcl environment
 * (if changed with tcl-env). */

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * This structure is used to keep track of the notifier info for a registered
 * file.
 */

type TFileHandler = struct {
	Ffd         int32
	Fmask       int32
	FreadyMask  int32
	Fproc       uintptr
	FclientData uintptr
	FnextPtr    uintptr
}

/*
 * The following structure contains a set of select() masks to track readable,
 * writable, and exception conditions.
 */

type TSelectMasks = struct {
	Freadable  Tfd_set
	Fwritable  Tfd_set
	Fexception Tfd_set
}

/*
 * The following structure is what is added to the Tcl event queue when file
 * handlers are ready to fire.
 */

type TFileHandlerEvent = struct {
	Fheader TTcl_Event
	Ffd     int32
}

/*
 * The following static structure contains the state information for the
 * select based implementation of the Tcl notifier. One of these structures is
 * created for each thread that is using the notifier.
 */

type TThreadSpecificData15 = struct {
	FfirstFileHandlerPtr uintptr
	FcheckMasks          TSelectMasks
	FreadyMasks          TSelectMasks
	FnumFdBits           int32
	FonList              int32
	FpollState           uint32
	FnextPtr             uintptr
	FprevPtr             uintptr
	FwaitCV              Tpthread_cond_t
	FwaitCVinitialized   int32
	FeventReady          int32
}

var _dataKey13 TTcl_ThreadDataKey

/*
 * The following static indicates the number of threads that have initialized
 * notifiers.
 *
 * You must hold the notifierMutex lock before accessing this variable.
 */

var _notifierCount = int32(0)

/*
 * The following variable points to the head of a doubly-linked list of
 * ThreadSpecificData structures for all threads that are currently waiting on
 * an event.
 *
 * You must hold the notifierMutex lock before accessing this list.
 */

var _waitingListPtr = libc.UintptrFromInt32(0)

/*
 * The notifier thread spends all its time in select() waiting for a file
 * descriptor associated with one of the threads on the waitingListPtr list to
 * do something interesting. But if the contents of the waitingListPtr list
 * ever changes, we need to wake up and restart the select() system call. You
 * can wake up the notifier thread by writing a single byte to the file
 * descriptor defined below. This file descriptor is the input-end of a pipe
 * and the notifier thread is listening for data on the output-end of the same
 * pipe. Hence writing to this file descriptor will cause the select() system
 * call to return and wake up the notifier thread.
 *
 * You must hold the notifierMutex lock before writing to the pipe.
 */

var _triggerPipe = -int32(1)
var _otherPipe = -int32(1)

/*
 * The notifierMutex locks access to all of the global notifier state.
 */

var _notifierInitMutex = Tpthread_mutex_t{}
var _notifierMutex = Tpthread_mutex_t{}

/*
 * The following static indicates if the notifier thread is running.
 *
 * You must hold the notifierInitMutex before accessing this variable.
 */

var _notifierThreadRunning = int32(0)

/*
 * The following static flag indicates that async handlers are pending.
 */

var _asyncPending = int32(0)

/*
 * The notifier thread signals the notifierCV when it has finished
 * initializing the triggerPipe and right before the notifier thread
 * terminates. This condition is used to deal with the signal mask, too.
 */

var _notifierCV = Tpthread_cond_t{}

/*
 * The pollState bits:
 *
 * POLL_WANT is set by each thread before it waits on its condition variable.
 *	It is checked by the notifier before it does select.
 *
 * POLL_DONE is set by the notifier if it goes into select after seeing
 *	POLL_WANT. The idea is to ensure it tries a select with the same bits
 *	the initial thread had set.
 */

/*
 * This is the thread ID of the notifier thread that does select.
 */

var _notifierThread TTcl_ThreadId

/*
 * Signal mask information for notifier thread.
 */

var _notifierSigMask Tsigset_t
var _atForkInit = int32(0)

type Tnfds_t = uint64

type Tpollfd = struct {
	Ffd      int32
	Fevents  int16
	Frevents int16
}

/*
 *----------------------------------------------------------------------
 *
 * StartNotifierThread --
 *
 *	Start a notifier thread and wait for the notifier pipe to be created.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Running Thread.
 *
 *----------------------------------------------------------------------
 */

func _StartNotifierThread(tls *libc.TLS, proc uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	if !(_notifierThreadRunning != 0) {
		libc.Xpthread_mutex_lock(tls, uintptr(unsafe.Pointer(&_notifierInitMutex)))
		if !(_notifierThreadRunning != 0) {
			if XTclpThreadCreate(tls, uintptr(unsafe.Pointer(&_notifierThread)), __ccgo_fp(_NotifierThreadProc), libc.UintptrFromInt32(0), libc.Uint64FromInt32(libc.Int32FromInt32(TCL_THREAD_STACK_DEFAULT)), int32(TCL_THREAD_JOINABLE)) != TCL_OK {
				XTcl_Panic(tls, __ccgo_ts+78231, libc.VaList(bp+8, proc))
			}
			libc.Xpthread_mutex_lock(tls, uintptr(unsafe.Pointer(&_notifierMutex)))
			/*
			 * Wait for the notifier pipe to be created.
			 */
			for _triggerPipe < 0 {
				libc.Xpthread_cond_wait(tls, uintptr(unsafe.Pointer(&_notifierCV)), uintptr(unsafe.Pointer(&_notifierMutex)))
			}
			libc.Xpthread_mutex_unlock(tls, uintptr(unsafe.Pointer(&_notifierMutex)))
			_notifierThreadRunning = int32(1)
		}
		libc.Xpthread_mutex_unlock(tls, uintptr(unsafe.Pointer(&_notifierInitMutex)))
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclpAlertNotifier --
 *
 *	Wake up the specified notifier from any thread. This routine is called
 *	by the platform independent notifier code whenever the Tcl_ThreadAlert
 *	routine is called. This routine is guaranteed not to be called on a
 *	given notifier after Tcl_FinalizeNotifier is called for that notifier.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	select(2) notifier:
 *		signals the notifier condition variable for the specified
 *		notifier.
 *	epoll(7) notifier:
 *		write(2)s to the eventfd(2) of the specified thread.
 *	kqueue(2) notifier:
 *		write(2)s to the trigger pipe(2) of the specified thread.
 *
 *----------------------------------------------------------------------
 */

func XTclpAlertNotifier(tls *libc.TLS, clientData uintptr) {
	var tsdPtr uintptr
	_ = tsdPtr
	tsdPtr = clientData
	libc.Xpthread_mutex_lock(tls, uintptr(unsafe.Pointer(&_notifierMutex)))
	(*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FeventReady = int32(1)
	libc.Xpthread_cond_broadcast(tls, tsdPtr+808)
	libc.Xpthread_mutex_unlock(tls, uintptr(unsafe.Pointer(&_notifierMutex)))
}

/*
 *----------------------------------------------------------------------
 *
 * LookUpFileHandler --
 *
 *	Look up the file handler structure (and optionally the previous one in
 *	the chain) associated with a file descriptor.
 *
 * Returns:
 *	A pointer to the file handler, or NULL if it can't be found.
 *
 * Side effects:
 *	If prevPtrPtr is non-NULL, it will be written to if the file handler
 *	is found.
 *
 *----------------------------------------------------------------------
 */

func _LookUpFileHandler(tls *libc.TLS, tsdPtr uintptr, fd int32, prevPtrPtr uintptr) (r uintptr) {
	/* If non-NULL, where to report the previous
	 * pointer. */
	var filePtr, prevPtr uintptr
	_, _ = filePtr, prevPtr
	/*
	 * Find the entry for the given file (and return if there isn't one).
	 */
	prevPtr = libc.UintptrFromInt32(0)
	filePtr = (*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FfirstFileHandlerPtr
	for {
		if filePtr == libc.UintptrFromInt32(0) {
			return libc.UintptrFromInt32(0)
		}
		if (*TFileHandler)(unsafe.Pointer(filePtr)).Ffd == fd {
			break
		}
		goto _1
	_1:
		;
		prevPtr = filePtr
		filePtr = (*TFileHandler)(unsafe.Pointer(filePtr)).FnextPtr
	}
	/*
	 * Report what we've found to our caller.
	 */
	if prevPtrPtr != 0 {
		*(*uintptr)(unsafe.Pointer(prevPtrPtr)) = prevPtr
	}
	return filePtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclpSetTimer --
 *
 *	This function sets the current notifier timer value. This interface is
 *	not implemented in this notifier because we are always running inside
 *	of Tcl_DoOneEvent.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclpSetTimer(tls *libc.TLS, dummy216 uintptr) {
	/* Timeout value, may be NULL. */
	/*
	 * The interval timer doesn't do anything in this implementation, because
	 * the only event loop is via Tcl_DoOneEvent, which passes timeout values
	 * to Tcl_WaitForEvent.
	 */
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ServiceModeHook --
 *
 *	This function is invoked whenever the service mode changes.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclpServiceModeHook(tls *libc.TLS, mode int32) {
	/* Either TCL_SERVICE_ALL, or
	 * TCL_SERVICE_NONE. */
	if mode == int32(TCL_SERVICE_ALL) {
		_StartNotifierThread(tls, __ccgo_ts+78267)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * FileHandlerEventProc --
 *
 *	This function is called by Tcl_ServiceEvent when a file event reaches
 *	the front of the event queue. This function is responsible for
 *	actually handling the event by invoking the callback for the file
 *	handler.
 *
 * Results:
 *	Returns 1 if the event was handled, meaning it should be removed from
 *	the queue. Returns 0 if the event was not handled, meaning it should
 *	stay on the queue. The only time the event isn't handled is if the
 *	TCL_FILE_EVENTS flag bit isn't set.
 *
 * Side effects:
 *	Whatever the file handler's callback function does.
 *
 *----------------------------------------------------------------------
 */

func _FileHandlerEventProc(tls *libc.TLS, evPtr uintptr, flags int32) (r int32) {
	/* Flags that indicate what events to handle,
	 * such as TCL_FILE_EVENTS. */
	var fileEvPtr, filePtr, tsdPtr uintptr
	var mask int32
	_, _, _, _ = fileEvPtr, filePtr, mask, tsdPtr
	fileEvPtr = evPtr
	if !(flags&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(3)) != 0) {
		return 0
	}
	/*
	 * Search through the file handlers to find the one whose handle matches
	 * the event. We do this rather than keeping a pointer to the file handler
	 * directly in the event, so that the handler can be deleted while the
	 * event is queued without leaving a dangling pointer.
	 */
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey13)), int64(864))
	filePtr = (*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FfirstFileHandlerPtr
	for {
		if !(filePtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TFileHandler)(unsafe.Pointer(filePtr)).Ffd != (*TFileHandlerEvent)(unsafe.Pointer(fileEvPtr)).Ffd {
			goto _1
		}
		/*
		 * The code is tricky for two reasons:
		 * 1. The file handler's desired events could have changed since the
		 *    time when the event was queued, so AND the ready mask with the
		 *    desired mask.
		 * 2. The file could have been closed and re-opened since the time
		 *    when the event was queued. This is why the ready mask is stored
		 *    in the file handler rather than the queued event: it will be
		 *    zeroed when a new file handler is created for the newly opened
		 *    file.
		 */
		mask = (*TFileHandler)(unsafe.Pointer(filePtr)).FreadyMask & (*TFileHandler)(unsafe.Pointer(filePtr)).Fmask
		(*TFileHandler)(unsafe.Pointer(filePtr)).FreadyMask = 0
		if mask != 0 {
			(*(*func(*libc.TLS, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{(*TFileHandler)(unsafe.Pointer(filePtr)).Fproc})))(tls, (*TFileHandler)(unsafe.Pointer(filePtr)).FclientData, mask)
		}
		break
		goto _1
	_1:
		;
		filePtr = (*TFileHandler)(unsafe.Pointer(filePtr)).FnextPtr
	}
	return int32(1)
}

/*
 *----------------------------------------------------------------------
 *
 * AlertSingleThread --
 *
 *	Notify a single thread that is waiting on a file descriptor to become
 *	readable or writable or to have an exception condition.
 *	notifierMutex must be held.
 *
 * Result:
 *	None.
 *
 * Side effects:
 *	The condition variable associated with the thread is broadcasted.
 *
 *----------------------------------------------------------------------
 */

func _AlertSingleThread(tls *libc.TLS, tsdPtr uintptr) {
	var v1 uintptr
	_ = v1
	(*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FeventReady = int32(1)
	if (*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FonList != 0 {
		/*
		 * Remove the ThreadSpecificData structure of this thread from the
		 * waiting list. This prevents us from continuously spinning on
		 * epoll_wait until the other threads runs and services the file
		 * event.
		 */
		if (*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FprevPtr != 0 {
			(*TThreadSpecificData16)(unsafe.Pointer((*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FprevPtr)).FnextPtr = (*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FnextPtr
		} else {
			_waitingListPtr = (*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FnextPtr
		}
		if (*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FnextPtr != 0 {
			(*TThreadSpecificData16)(unsafe.Pointer((*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FnextPtr)).FprevPtr = (*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FprevPtr
		}
		v1 = libc.UintptrFromInt32(0)
		(*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FprevPtr = v1
		(*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FnextPtr = v1
		(*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FonList = 0
		(*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FpollState = uint32(0)
	}
	libc.Xpthread_cond_broadcast(tls, tsdPtr+808)
}

/*
 *----------------------------------------------------------------------
 *
 * AtForkChild --
 *
 *	Unlock and reinstall the notifier in the child after a fork.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func _AtForkChild(tls *libc.TLS) {
	var tsdPtr, v1 uintptr
	_, _ = tsdPtr, v1
	if _notifierThreadRunning == int32(1) {
		libc.Xpthread_cond_destroy(tls, uintptr(unsafe.Pointer(&_notifierCV)))
	}
	libc.Xpthread_mutex_init(tls, uintptr(unsafe.Pointer(&_notifierInitMutex)), libc.UintptrFromInt32(0))
	libc.Xpthread_mutex_init(tls, uintptr(unsafe.Pointer(&_notifierMutex)), libc.UintptrFromInt32(0))
	libc.Xpthread_cond_init(tls, uintptr(unsafe.Pointer(&_notifierCV)), libc.UintptrFromInt32(0))
	_asyncPending = 0
	/*
	 * notifierThreadRunning == 1: thread is running, (there might be data in
	 *		notifier lists)
	 * atForkInit == 0: InitNotifier was never called
	 * notifierCount != 0: unbalanced InitNotifier() / FinalizeNotifier calls
	 * waitingListPtr != 0: there are threads currently waiting for events.
	 */
	if _atForkInit == int32(1) {
		_notifierCount = 0
		if _notifierThreadRunning == int32(1) {
			tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey13)), int64(864))
			_notifierThreadRunning = 0
			libc.Xclose(tls, _triggerPipe)
			_triggerPipe = -int32(1)
			libc.Xclose(tls, _otherPipe)
			_otherPipe = -int32(1)
			/*
			 * The waitingListPtr might contain event info from multiple
			 * threads, which are invalid here, so setting it to NULL is not
			 * unreasonable.
			 */
			_waitingListPtr = libc.UintptrFromInt32(0)
			/*
			 * The tsdPtr from before the fork is copied as well. But since we
			 * are paranoiac, we don't trust its condvar and reset it.
			 */
			libc.Xpthread_cond_destroy(tls, tsdPtr+808)
			libc.Xpthread_cond_init(tls, tsdPtr+808, libc.UintptrFromInt32(0))
			/*
			 * In case, we had multiple threads running before the fork,
			 * make sure, we don't try to reach out to their thread local data.
			 */
			v1 = libc.UintptrFromInt32(0)
			(*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FprevPtr = v1
			(*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FnextPtr = v1
			/*
			 * The list of registered event handlers at fork time is in
			 * tsdPtr->firstFileHandlerPtr;
			 */
		}
	}
	XTcl_InitNotifier(tls)
	/*
	 * Restart the notifier thread for signal handling.
	 */
	_StartNotifierThread(tls, __ccgo_ts+78287)
}

/*
 *----------------------------------------------------------------------
 *
 * TclpNotifierData --
 *
 *	This function returns a void pointer to be associated
 *	with a Tcl_AsyncHandler.
 *
 * Results:
 *	For the epoll and kqueue notifiers, this function returns the
 *	thread specific data. Otherwise NULL.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclpNotifierData(tls *libc.TLS) (r uintptr) {
	return libc.UintptrFromInt32(0)
}

/*
 *----------------------------------------------------------------------
 *
 * TclUnixWaitForFile --
 *
 *	This function waits synchronously for a file to become readable or
 *	writable, with an optional timeout.
 *
 * Results:
 *	The return value is an OR'ed combination of TCL_READABLE,
 *	TCL_WRITABLE, and TCL_EXCEPTION, indicating the conditions that are
 *	present on file at the time of the return. This function will not
 *	return until either "timeout" milliseconds have elapsed or at least
 *	one of the conditions given by mask has occurred for file (a return
 *	value of 0 means that a timeout occurred). No normal events will be
 *	serviced during the execution of this function.
 *
 * Side effects:
 *	Time passes.
 *
 *----------------------------------------------------------------------
 */

func XTclUnixWaitForFile(tls *libc.TLS, fd int32, mask int32, timeout int32) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Maximum amount of time to wait for one of
	 * the conditions in mask to occur, in
	 * milliseconds. A value of 0 means don't wait
	 * at all, and a value of -1 means wait
	 * forever. */
	var abortTime TTcl_Time
	var numFound, pollTimeout, result int32
	var timeoutPtr, p2, p3, p4 uintptr
	var v1 int16
	var _ /* blockTime at bp+16 */ Ttimeval
	var _ /* now at bp+0 */ TTcl_Time
	var _ /* pollFds at bp+32 */ [1]Tpollfd
	_, _, _, _, _, _, _, _, _ = abortTime, numFound, pollTimeout, result, timeoutPtr, v1, p2, p3, p4
	abortTime = TTcl_Time{}
	result = 0
	/*
	 * If there is a non-zero finite timeout, compute the time when we give
	 * up.
	 */
	if timeout > 0 {
		XTcl_GetTime(tls, bp)
		abortTime.Fsec = (*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec + int64(timeout/int32(1000))
		abortTime.Fusec = (*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec + int64(timeout%int32(1000)*int32(1000))
		if abortTime.Fusec >= int64(1000000) {
			abortTime.Fusec -= int64(1000000)
			abortTime.Fsec += int64(1)
		}
		timeoutPtr = bp + 16
	} else {
		if timeout == 0 {
			timeoutPtr = bp + 16
			(*(*Ttimeval)(unsafe.Pointer(bp + 16))).Ftv_sec = 0
			(*(*Ttimeval)(unsafe.Pointer(bp + 16))).Ftv_usec = 0
		} else {
			timeoutPtr = libc.UintptrFromInt32(0)
		}
	}
	/*
	 * Setup the pollfd structure for the fd.
	 */
	(*(*[1]Tpollfd)(unsafe.Pointer(bp + 32)))[0].Ffd = fd
	v1 = libc.Int16FromInt32(0)
	(*(*[1]Tpollfd)(unsafe.Pointer(bp + 32)))[0].Frevents = v1
	(*(*[1]Tpollfd)(unsafe.Pointer(bp + 32)))[0].Fevents = v1
	if mask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
		p2 = bp + 32 + 4
		*(*int16)(unsafe.Pointer(p2)) = int16(int32(*(*int16)(unsafe.Pointer(p2))) | (libc.Int32FromInt32(POLLIN) | libc.Int32FromInt32(POLLHUP)))
	}
	if mask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
		p3 = bp + 32 + 4
		*(*int16)(unsafe.Pointer(p3)) = int16(int32(*(*int16)(unsafe.Pointer(p3))) | libc.Int32FromInt32(POLLOUT))
	}
	if mask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(3)) != 0 {
		p4 = bp + 32 + 4
		*(*int16)(unsafe.Pointer(p4)) = int16(int32(*(*int16)(unsafe.Pointer(p4))) | libc.Int32FromInt32(POLLERR))
	}
	/*
	 * Loop in a mini-event loop of our own, waiting for either the file to
	 * become ready or a timeout to occur.
	 */
	for cond := true; cond; cond = abortTime.Fsec > (*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec || abortTime.Fsec == (*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec && abortTime.Fusec > (*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec {
		if timeout > 0 {
			(*(*Ttimeval)(unsafe.Pointer(bp + 16))).Ftv_sec = abortTime.Fsec - (*(*TTcl_Time)(unsafe.Pointer(bp))).Fsec
			(*(*Ttimeval)(unsafe.Pointer(bp + 16))).Ftv_usec = abortTime.Fusec - (*(*TTcl_Time)(unsafe.Pointer(bp))).Fusec
			if (*(*Ttimeval)(unsafe.Pointer(bp + 16))).Ftv_usec < 0 {
				(*(*Ttimeval)(unsafe.Pointer(bp + 16))).Ftv_sec -= int64(1)
				(*(*Ttimeval)(unsafe.Pointer(bp + 16))).Ftv_usec += int64(1000000)
			}
			if (*(*Ttimeval)(unsafe.Pointer(bp + 16))).Ftv_sec < 0 {
				(*(*Ttimeval)(unsafe.Pointer(bp + 16))).Ftv_sec = 0
				(*(*Ttimeval)(unsafe.Pointer(bp + 16))).Ftv_usec = 0
			}
		}
		/*
		 * Wait for the event or a timeout.
		 */
		if !(timeoutPtr != 0) {
			pollTimeout = -int32(1)
		} else {
			if !((*Ttimeval)(unsafe.Pointer(timeoutPtr)).Ftv_sec != 0) && !((*Ttimeval)(unsafe.Pointer(timeoutPtr)).Ftv_usec != 0) {
				pollTimeout = 0
			} else {
				pollTimeout = int32((*Ttimeval)(unsafe.Pointer(timeoutPtr)).Ftv_sec) * int32(1000)
				if (*Ttimeval)(unsafe.Pointer(timeoutPtr)).Ftv_usec != 0 {
					pollTimeout += int32((*Ttimeval)(unsafe.Pointer(timeoutPtr)).Ftv_usec) / int32(1000)
				}
			}
		}
		numFound = libc.Xpoll(tls, bp+32, uint64(1), pollTimeout)
		if numFound == int32(1) {
			result = 0
			if int32((*(*[1]Tpollfd)(unsafe.Pointer(bp + 32)))[0].Frevents)&(libc.Int32FromInt32(POLLIN)|libc.Int32FromInt32(POLLHUP)) != 0 {
				result |= libc.Int32FromInt32(1) << libc.Int32FromInt32(1)
			}
			if int32((*(*[1]Tpollfd)(unsafe.Pointer(bp + 32)))[0].Frevents)&int32(POLLOUT) != 0 {
				result |= libc.Int32FromInt32(1) << libc.Int32FromInt32(2)
			}
			if int32((*(*[1]Tpollfd)(unsafe.Pointer(bp + 32)))[0].Frevents)&int32(POLLERR) != 0 {
				result |= libc.Int32FromInt32(1) << libc.Int32FromInt32(3)
			}
			if result != 0 {
				break
			}
		}
		if timeout == 0 {
			break
		}
		if timeout < 0 {
			continue
		}
		/*
		 * The select returned early, so we need to recompute the timeout.
		 */
		XTcl_GetTime(tls, bp)
	}
	return result
}

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 *----------------------------------------------------------------------
 *
 * TclpInitNotifier --
 *
 *	Initializes the platform specific notifier state.
 *
 * Results:
 *	Returns a handle to the notifier state for this thread.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclpInitNotifier(tls *libc.TLS) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var result int32
	var tsdPtr uintptr
	_, _ = result, tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey13)), int64(864))
	(*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FeventReady = 0
	/*
	 * Initialize thread specific condition variable for this thread.
	 */
	if (*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FwaitCVinitialized == 0 {
		libc.Xpthread_cond_init(tls, tsdPtr+808, libc.UintptrFromInt32(0))
		(*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FwaitCVinitialized = int32(1)
	}
	libc.Xpthread_mutex_lock(tls, uintptr(unsafe.Pointer(&_notifierInitMutex)))
	/*
	 * Install pthread_atfork handlers to clean up the notifier in the child
	 * of a fork.
	 */
	if !(_atForkInit != 0) {
		result = libc.Xpthread_atfork(tls, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), __ccgo_fp(_AtForkChild))
		if result != 0 {
			XTcl_Panic(tls, __ccgo_ts+78299, libc.VaList(bp+8, __ccgo_ts+78320))
		}
		_atForkInit = int32(1)
	}
	_notifierCount++
	libc.Xpthread_mutex_unlock(tls, uintptr(unsafe.Pointer(&_notifierInitMutex)))
	return tsdPtr
}

/*
 *----------------------------------------------------------------------
 *
 * TclpFinalizeNotifier --
 *
 *	This function is called to cleanup the notifier state before a thread
 *	is terminated.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	May terminate the background notifier thread if this is the last
 *	notifier instance.
 *
 *----------------------------------------------------------------------
 */

func XTclpFinalizeNotifier(tls *libc.TLS, dummy399 uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var result int32
	var tsdPtr uintptr
	_, _ = result, tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey13)), int64(864))
	libc.Xpthread_mutex_lock(tls, uintptr(unsafe.Pointer(&_notifierInitMutex)))
	_notifierCount--
	/*
	 * If this is the last thread to use the notifier, close the notifier pipe
	 * and wait for the background thread to terminate.
	 */
	if _notifierCount == 0 && _triggerPipe != -int32(1) {
		if libc.Xwrite(tls, _triggerPipe, __ccgo_ts+25875, uint64(1)) != int64(1) {
			XTcl_Panic(tls, __ccgo_ts+78342, libc.VaList(bp+8, __ccgo_ts+78367))
		}
		libc.Xclose(tls, _triggerPipe)
		libc.Xpthread_mutex_lock(tls, uintptr(unsafe.Pointer(&_notifierMutex)))
		for _triggerPipe != -int32(1) {
			libc.Xpthread_cond_wait(tls, uintptr(unsafe.Pointer(&_notifierCV)), uintptr(unsafe.Pointer(&_notifierMutex)))
		}
		libc.Xpthread_mutex_unlock(tls, uintptr(unsafe.Pointer(&_notifierMutex)))
		if _notifierThreadRunning != 0 {
			result = libc.Xpthread_join(tls, _notifierThread, libc.UintptrFromInt32(0))
			if result != 0 {
				XTcl_Panic(tls, __ccgo_ts+78342, libc.VaList(bp+8, __ccgo_ts+78402))
			}
			_notifierThreadRunning = 0
			/*
			 * If async marks are outstanding, perform actions now.
			 */
			if _asyncPending != 0 {
				_asyncPending = 0
				XTclAsyncMarkFromNotifier(tls)
			}
		}
	}
	/*
	 * Clean up any synchronization objects in the thread local storage.
	 */
	libc.Xpthread_cond_destroy(tls, tsdPtr+808)
	(*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FwaitCVinitialized = 0
	libc.Xpthread_mutex_unlock(tls, uintptr(unsafe.Pointer(&_notifierInitMutex)))
}

/*
 *----------------------------------------------------------------------
 *
 * TclpCreateFileHandler --
 *
 *	This function registers a file handler with the select notifier.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Creates a new file handler structure.
 *
 *----------------------------------------------------------------------
 */

func XTclpCreateFileHandler(tls *libc.TLS, fd int32, mask int32, proc uintptr, clientData uintptr) {
	/* Arbitrary data to pass to proc. */
	var filePtr, tsdPtr uintptr
	_, _ = filePtr, tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey13)), int64(864))
	filePtr = _LookUpFileHandler(tls, tsdPtr, fd, libc.UintptrFromInt32(0))
	if filePtr == libc.UintptrFromInt32(0) {
		filePtr = XTcl_Alloc(tls, uint64(40))
		(*TFileHandler)(unsafe.Pointer(filePtr)).Ffd = fd
		(*TFileHandler)(unsafe.Pointer(filePtr)).FreadyMask = 0
		(*TFileHandler)(unsafe.Pointer(filePtr)).FnextPtr = (*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FfirstFileHandlerPtr
		(*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FfirstFileHandlerPtr = filePtr
	}
	(*TFileHandler)(unsafe.Pointer(filePtr)).Fproc = proc
	(*TFileHandler)(unsafe.Pointer(filePtr)).FclientData = clientData
	(*TFileHandler)(unsafe.Pointer(filePtr)).Fmask = mask
	/*
	 * Update the check masks for this file.
	 */
	if mask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
		*(*uint64)(unsafe.Pointer(tsdPtr + 8 + uintptr(libc.Uint64FromInt32(fd)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8)) |= uint64(1) << (libc.Uint64FromInt32(fd) % (libc.Uint64FromInt32(8) * libc.Uint64FromInt64(8)))
	} else {
		*(*uint64)(unsafe.Pointer(tsdPtr + 8 + uintptr(libc.Uint64FromInt32(fd)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8)) &= ^(libc.Uint64FromUint64(1) << (libc.Uint64FromInt32(fd) % (libc.Uint64FromInt32(8) * libc.Uint64FromInt64(8))))
	}
	if mask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
		*(*uint64)(unsafe.Pointer(tsdPtr + 8 + 128 + uintptr(libc.Uint64FromInt32(fd)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8)) |= uint64(1) << (libc.Uint64FromInt32(fd) % (libc.Uint64FromInt32(8) * libc.Uint64FromInt64(8)))
	} else {
		*(*uint64)(unsafe.Pointer(tsdPtr + 8 + 128 + uintptr(libc.Uint64FromInt32(fd)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8)) &= ^(libc.Uint64FromUint64(1) << (libc.Uint64FromInt32(fd) % (libc.Uint64FromInt32(8) * libc.Uint64FromInt64(8))))
	}
	if mask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(3)) != 0 {
		*(*uint64)(unsafe.Pointer(tsdPtr + 8 + 256 + uintptr(libc.Uint64FromInt32(fd)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8)) |= uint64(1) << (libc.Uint64FromInt32(fd) % (libc.Uint64FromInt32(8) * libc.Uint64FromInt64(8)))
	} else {
		*(*uint64)(unsafe.Pointer(tsdPtr + 8 + 256 + uintptr(libc.Uint64FromInt32(fd)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8)) &= ^(libc.Uint64FromUint64(1) << (libc.Uint64FromInt32(fd) % (libc.Uint64FromInt32(8) * libc.Uint64FromInt64(8))))
	}
	if (*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FnumFdBits <= fd {
		(*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FnumFdBits = fd + int32(1)
	}
}

/*
 *----------------------------------------------------------------------
 *
 * TclpDeleteFileHandler --
 *
 *	Cancel a previously-arranged callback arrangement for a file.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	If a callback was previously registered on file, remove it.
 *
 *----------------------------------------------------------------------
 */

func XTclpDeleteFileHandler(tls *libc.TLS, fd int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Stream id for which to remove callback
	 * function. */
	var filePtr, tsdPtr uintptr
	var i, numFdBits int32
	var _ /* prevPtr at bp+0 */ uintptr
	_, _, _, _ = filePtr, i, numFdBits, tsdPtr
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey13)), int64(864))
	/*
	 * Find the entry for the given file (and return if there isn't one).
	 */
	filePtr = _LookUpFileHandler(tls, tsdPtr, fd, bp)
	if filePtr == libc.UintptrFromInt32(0) {
		return
	}
	/*
	 * Update the check masks for this file.
	 */
	if (*TFileHandler)(unsafe.Pointer(filePtr)).Fmask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(1)) != 0 {
		*(*uint64)(unsafe.Pointer(tsdPtr + 8 + uintptr(libc.Uint64FromInt32(fd)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8)) &= ^(libc.Uint64FromUint64(1) << (libc.Uint64FromInt32(fd) % (libc.Uint64FromInt32(8) * libc.Uint64FromInt64(8))))
	}
	if (*TFileHandler)(unsafe.Pointer(filePtr)).Fmask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(2)) != 0 {
		*(*uint64)(unsafe.Pointer(tsdPtr + 8 + 128 + uintptr(libc.Uint64FromInt32(fd)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8)) &= ^(libc.Uint64FromUint64(1) << (libc.Uint64FromInt32(fd) % (libc.Uint64FromInt32(8) * libc.Uint64FromInt64(8))))
	}
	if (*TFileHandler)(unsafe.Pointer(filePtr)).Fmask&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(3)) != 0 {
		*(*uint64)(unsafe.Pointer(tsdPtr + 8 + 256 + uintptr(libc.Uint64FromInt32(fd)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8)) &= ^(libc.Uint64FromUint64(1) << (libc.Uint64FromInt32(fd) % (libc.Uint64FromInt32(8) * libc.Uint64FromInt64(8))))
	}
	/*
	 * Find current max fd.
	 */
	if fd+int32(1) == (*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FnumFdBits {
		numFdBits = 0
		i = fd - int32(1)
		for {
			if !(i >= 0) {
				break
			}
			if !!(*(*uint64)(unsafe.Pointer(tsdPtr + 8 + uintptr(libc.Uint64FromInt32(i)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8))&(libc.Uint64FromUint64(1)<<(libc.Uint64FromInt32(i)%(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))) != 0) || !!(*(*uint64)(unsafe.Pointer(tsdPtr + 8 + 128 + uintptr(libc.Uint64FromInt32(i)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8))&(libc.Uint64FromUint64(1)<<(libc.Uint64FromInt32(i)%(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))) != 0) || !!(*(*uint64)(unsafe.Pointer(tsdPtr + 8 + 256 + uintptr(libc.Uint64FromInt32(i)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8))&(libc.Uint64FromUint64(1)<<(libc.Uint64FromInt32(i)%(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))) != 0) {
				numFdBits = i + int32(1)
				break
			}
			goto _1
		_1:
			;
			i--
		}
		(*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FnumFdBits = numFdBits
	}
	/*
	 * Clean up information in the callback record.
	 */
	if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
		(*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FfirstFileHandlerPtr = (*TFileHandler)(unsafe.Pointer(filePtr)).FnextPtr
	} else {
		(*TFileHandler)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TFileHandler)(unsafe.Pointer(filePtr)).FnextPtr
	}
	XTclpFree(tls, filePtr)
}

/*
 *----------------------------------------------------------------------
 *
 * TclpWaitForEvent --
 *
 *	This function is called by Tcl_DoOneEvent to wait for new events on
 *	the message queue. If the block time is 0, then Tcl_WaitForEvent just
 *	polls without blocking.
 *
 * Results:
 *	Returns -1 if the select would block forever, otherwise returns 0.
 *
 * Side effects:
 *	Queues file events that are detected by the select.
 *
 *----------------------------------------------------------------------
 */

func XTclpWaitForEvent(tls *libc.TLS, timePtr1 uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Maximum block time, or NULL. */
	var __b, __b1, __b2, fileEvPtr, filePtr, tsdPtr, v1, v3, v5, v7, v8 uintptr
	var __i, __i1, __i2, mask, waitForFiles int32
	var _ /* now at bp+16 */ TTcl_Time
	var _ /* ptime at bp+32 */ Ttimespec
	var _ /* vTime at bp+0 */ TTcl_Time
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __b, __b1, __b2, __i, __i1, __i2, fileEvPtr, filePtr, mask, tsdPtr, waitForFiles, v1, v3, v5, v7, v8
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_dataKey13)), int64(864))
	/*
	 * Set up the timeout structure. Note that if there are no events to check
	 * for, we return with a negative result rather than blocking forever.
	 */
	if timePtr1 != libc.UintptrFromInt32(0) {
		/*
		 * TIP #233 (Virtualized Time). Is virtual time in effect? And do we
		 * actually have something to scale? If yes to both then we call the
		 * handler to do this scaling.
		 */
		if (*TTcl_Time)(unsafe.Pointer(timePtr1)).Fsec != 0 || (*TTcl_Time)(unsafe.Pointer(timePtr1)).Fusec != 0 {
			*(*TTcl_Time)(unsafe.Pointer(bp)) = *(*TTcl_Time)(unsafe.Pointer(timePtr1))
			v1 = bp
			if v1 != libc.UintptrFromInt32(0) {
				(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{XtclScaleTimeProcPtr})))(tls, v1, XtclTimeClientData)
			}
			timePtr1 = bp
		}
	}
	/*
	 * Start notifier thread and place this thread on the list of interested
	 * threads, signal the notifier thread, and wait for a response or a
	 * timeout.
	 */
	_StartNotifierThread(tls, __ccgo_ts+78433)
	libc.Xpthread_mutex_lock(tls, uintptr(unsafe.Pointer(&_notifierMutex)))
	if timePtr1 != libc.UintptrFromInt32(0) && (*TTcl_Time)(unsafe.Pointer(timePtr1)).Fsec == 0 && (*TTcl_Time)(unsafe.Pointer(timePtr1)).Fusec == 0 {
		/*
		 * Cannot emulate a polling select with a polling condition variable.
		 * Instead, pretend to wait for files and tell the notifier thread
		 * what we are doing. The notifier thread makes sure it goes through
		 * select with its select mask in the same state as ours currently is.
		 * We block until that happens.
		 */
		waitForFiles = int32(1)
		(*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FpollState = uint32(POLL_WANT)
		timePtr1 = libc.UintptrFromInt32(0)
	} else {
		waitForFiles = libc.BoolInt32((*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FnumFdBits > 0)
		(*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FpollState = uint32(0)
	}
	if waitForFiles != 0 {
		/*
		 * Add the ThreadSpecificData structure of this thread to the list of
		 * ThreadSpecificData structures of all threads that are waiting on
		 * file events.
		 */
		(*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FnextPtr = _waitingListPtr
		if _waitingListPtr != 0 {
			(*TThreadSpecificData15)(unsafe.Pointer(_waitingListPtr)).FprevPtr = tsdPtr
		}
		(*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FprevPtr = uintptr(0)
		_waitingListPtr = tsdPtr
		(*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FonList = int32(1)
		if libc.Xwrite(tls, _triggerPipe, __ccgo_ts+1945, uint64(1)) == int64(-int32(1)) && *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) != int32(EAGAIN) {
			XTcl_Panic(tls, __ccgo_ts+78450, libc.VaList(bp+56, __ccgo_ts+78471))
		}
	}
	__b = tsdPtr + 392
	__i = libc.Int32FromUint64(libc.Uint64FromInt64(128) / libc.Uint64FromInt64(8))
	for {
		if !(__i != 0) {
			break
		}
		v3 = __b
		__b += 8
		*(*uint64)(unsafe.Pointer(v3)) = uint64(0)
		goto _2
	_2:
		;
		__i--
	}
	__b1 = tsdPtr + 392 + 128
	__i1 = libc.Int32FromUint64(libc.Uint64FromInt64(128) / libc.Uint64FromInt64(8))
	for {
		if !(__i1 != 0) {
			break
		}
		v5 = __b1
		__b1 += 8
		*(*uint64)(unsafe.Pointer(v5)) = uint64(0)
		goto _4
	_4:
		;
		__i1--
	}
	__b2 = tsdPtr + 392 + 256
	__i2 = libc.Int32FromUint64(libc.Uint64FromInt64(128) / libc.Uint64FromInt64(8))
	for {
		if !(__i2 != 0) {
			break
		}
		v7 = __b2
		__b2 += 8
		*(*uint64)(unsafe.Pointer(v7)) = uint64(0)
		goto _6
	_6:
		;
		__i2--
	}
	if !((*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FeventReady != 0) {
		if timePtr1 != libc.UintptrFromInt32(0) {
			XTcl_GetTime(tls, bp+16)
			(*(*Ttimespec)(unsafe.Pointer(bp + 32))).Ftv_sec = (*TTcl_Time)(unsafe.Pointer(timePtr1)).Fsec + (*(*TTcl_Time)(unsafe.Pointer(bp + 16))).Fsec + ((*TTcl_Time)(unsafe.Pointer(timePtr1)).Fusec+(*(*TTcl_Time)(unsafe.Pointer(bp + 16))).Fusec)/int64(1000000)
			(*(*Ttimespec)(unsafe.Pointer(bp + 32))).Ftv_nsec = int64(1000) * (((*TTcl_Time)(unsafe.Pointer(timePtr1)).Fusec + (*(*TTcl_Time)(unsafe.Pointer(bp + 16))).Fusec) % int64(1000000))
			libc.Xpthread_cond_timedwait(tls, tsdPtr+808, uintptr(unsafe.Pointer(&_notifierMutex)), bp+32)
		} else {
			libc.Xpthread_cond_wait(tls, tsdPtr+808, uintptr(unsafe.Pointer(&_notifierMutex)))
		}
	}
	(*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FeventReady = 0
	if waitForFiles != 0 && (*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FonList != 0 {
		/*
		 * Remove the ThreadSpecificData structure of this thread from the
		 * waiting list. Alert the notifier thread to recompute its select
		 * masks - skipping this caused a hang when trying to close a pipe
		 * which the notifier thread was still doing a select on.
		 */
		if (*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FprevPtr != 0 {
			(*TThreadSpecificData16)(unsafe.Pointer((*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FprevPtr)).FnextPtr = (*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FnextPtr
		} else {
			_waitingListPtr = (*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FnextPtr
		}
		if (*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FnextPtr != 0 {
			(*TThreadSpecificData16)(unsafe.Pointer((*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FnextPtr)).FprevPtr = (*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FprevPtr
		}
		v8 = libc.UintptrFromInt32(0)
		(*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FprevPtr = v8
		(*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FnextPtr = v8
		(*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FonList = 0
		if libc.Xwrite(tls, _triggerPipe, __ccgo_ts+1945, uint64(1)) == int64(-int32(1)) && *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) != int32(EAGAIN) {
			XTcl_Panic(tls, __ccgo_ts+78450, libc.VaList(bp+56, __ccgo_ts+78471))
		}
	}
	/*
	 * Queue all detected file events before returning.
	 */
	filePtr = (*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FfirstFileHandlerPtr
	for {
		if !(filePtr != libc.UintptrFromInt32(0)) {
			break
		}
		mask = 0
		if !!(*(*uint64)(unsafe.Pointer(tsdPtr + 392 + uintptr(libc.Uint64FromInt32((*TFileHandler)(unsafe.Pointer(filePtr)).Ffd)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8))&(libc.Uint64FromUint64(1)<<(libc.Uint64FromInt32((*TFileHandler)(unsafe.Pointer(filePtr)).Ffd)%(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))) != 0) {
			mask |= libc.Int32FromInt32(1) << libc.Int32FromInt32(1)
		}
		if !!(*(*uint64)(unsafe.Pointer(tsdPtr + 392 + 128 + uintptr(libc.Uint64FromInt32((*TFileHandler)(unsafe.Pointer(filePtr)).Ffd)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8))&(libc.Uint64FromUint64(1)<<(libc.Uint64FromInt32((*TFileHandler)(unsafe.Pointer(filePtr)).Ffd)%(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))) != 0) {
			mask |= libc.Int32FromInt32(1) << libc.Int32FromInt32(2)
		}
		if !!(*(*uint64)(unsafe.Pointer(tsdPtr + 392 + 256 + uintptr(libc.Uint64FromInt32((*TFileHandler)(unsafe.Pointer(filePtr)).Ffd)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8))&(libc.Uint64FromUint64(1)<<(libc.Uint64FromInt32((*TFileHandler)(unsafe.Pointer(filePtr)).Ffd)%(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))) != 0) {
			mask |= libc.Int32FromInt32(1) << libc.Int32FromInt32(3)
		}
		if !(mask != 0) {
			goto _9
		}
		/*
		 * Don't bother to queue an event if the mask was previously non-zero
		 * since an event must still be on the queue.
		 */
		if (*TFileHandler)(unsafe.Pointer(filePtr)).FreadyMask == 0 {
			fileEvPtr = XTcl_Alloc(tls, uint64(24))
			(*TFileHandlerEvent)(unsafe.Pointer(fileEvPtr)).Fheader.Fproc = __ccgo_fp(_FileHandlerEventProc)
			(*TFileHandlerEvent)(unsafe.Pointer(fileEvPtr)).Ffd = (*TFileHandler)(unsafe.Pointer(filePtr)).Ffd
			XTcl_QueueEvent(tls, fileEvPtr, int32(TCL_QUEUE_TAIL))
		}
		(*TFileHandler)(unsafe.Pointer(filePtr)).FreadyMask = mask
		goto _9
	_9:
		;
		filePtr = (*TFileHandler)(unsafe.Pointer(filePtr)).FnextPtr
	}
	libc.Xpthread_mutex_unlock(tls, uintptr(unsafe.Pointer(&_notifierMutex)))
	return 0
}

/*
 *----------------------------------------------------------------------
 *
 * TclAsyncNotifier --
 *
 *	This procedure sets the async mark of an async handler to a
 *	given value, if it is called from the notifier thread.
 *
 * Result:
 *	True, when the handler will be marked, false otherwise.
 *
 * Side effetcs:
 *	The trigger pipe is written when called from the notifier
 *	thread.
 *
 *----------------------------------------------------------------------
 */

func XTclAsyncNotifier(tls *libc.TLS, sigNumber int32, dummy923 TTcl_ThreadId, dummy924 uintptr, flagPtr uintptr, value int32) (r int32) {
	/* Value of mark. */
	/*
	 * WARNING:
	 * This code most likely runs in a signal handler. Thus,
	 * only few async-signal-safe system calls are allowed,
	 * e.g. pthread_self(), sem_post(), write().
	 */
	if libc.Xpthread_self(tls) == _notifierThread {
		if _notifierThreadRunning != 0 {
			*(*int32)(unsafe.Pointer(flagPtr)) = value
			if !(_asyncPending != 0) {
				_asyncPending = int32(1)
				if libc.Xwrite(tls, _triggerPipe, __ccgo_ts+78502, uint64(1)) != int64(1) {
					_asyncPending = 0
					return 0
				}
			}
			return int32(1)
		}
		return 0
	}
	/*
	 * Re-send the signal to the notifier thread.
	 */
	_pthread_kill(tls, _notifierThread, sigNumber)
	return 0
}

/*
 *----------------------------------------------------------------------
 *
 * NotifierThreadProc --
 *
 *	This routine is the initial (and only) function executed by the
 *	special notifier thread. Its job is to wait for file descriptors to
 *	become readable or writable or to have an exception condition and then
 *	to notify other threads who are interested in this information by
 *	signalling a condition variable. Other threads can signal this
 *	notifier thread of a change in their interests by writing a single
 *	byte to a special pipe that the notifier thread is monitoring.
 *
 * Result:
 *	None. Once started, this routine normally never exits and usually dies
 *	with the overall process, but it can be shut down if the Tcl library
 *	is finalized.
 *
 * Side effects:
 *	The trigger pipe used to signal the notifier thread is created when
 *	the notifier thread first starts.
 *
 *----------------------------------------------------------------------
 */

func _NotifierThreadProc(tls *libc.TLS, dummy992 uintptr) {
	bp := tls.Alloc(448)
	defer tls.Free(448)
	var __b, __b1, __b2, timePtr, tsdPtr, tspecPtr, v2, v4, v6 uintptr
	var __i, __i1, __i2, i, numFdBits, receivePipe, ret int32
	var found int64
	var _ /* buf at bp+408 */ [2]uint8
	var _ /* exceptionMask at bp+256 */ Tfd_set
	var _ /* fds at bp+384 */ [2]int32
	var _ /* poll at bp+392 */ Ttimeval
	var _ /* readableMask at bp+0 */ Tfd_set
	var _ /* tspec at bp+416 */ Ttimespec
	var _ /* writableMask at bp+128 */ Tfd_set
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __b, __b1, __b2, __i, __i1, __i2, found, i, numFdBits, receivePipe, ret, timePtr, tsdPtr, tspecPtr, v2, v4, v6
	*(*Ttimeval)(unsafe.Pointer(bp + 392)) = Ttimeval{}
	numFdBits = 0
	if libc.Xpipe(tls, bp+384) != 0 {
		XTcl_Panic(tls, __ccgo_ts+78504, libc.VaList(bp+440, __ccgo_ts+78527))
	}
	/*
	 * Ticket [c6897e6e6a].
	 */
	if (*(*[2]int32)(unsafe.Pointer(bp + 384)))[0] >= int32(FD_SETSIZE) || (*(*[2]int32)(unsafe.Pointer(bp + 384)))[int32(1)] >= int32(FD_SETSIZE) {
		XTcl_Panic(tls, __ccgo_ts+78504, libc.VaList(bp+440, __ccgo_ts+61035))
	}
	receivePipe = (*(*[2]int32)(unsafe.Pointer(bp + 384)))[0]
	if XTclUnixSetBlockingMode(tls, receivePipe, int32(TCL_MODE_NONBLOCKING)) < 0 {
		XTcl_Panic(tls, __ccgo_ts+78504, libc.VaList(bp+440, __ccgo_ts+78557))
	}
	if XTclUnixSetBlockingMode(tls, (*(*[2]int32)(unsafe.Pointer(bp + 384)))[int32(1)], int32(TCL_MODE_NONBLOCKING)) < 0 {
		XTcl_Panic(tls, __ccgo_ts+78504, libc.VaList(bp+440, __ccgo_ts+78598))
	}
	if libc.Xfcntl(tls, receivePipe, int32(F_SETFD), libc.VaList(bp+440, int32(FD_CLOEXEC))) < 0 {
		XTcl_Panic(tls, __ccgo_ts+78504, libc.VaList(bp+440, __ccgo_ts+78639))
	}
	if libc.Xfcntl(tls, (*(*[2]int32)(unsafe.Pointer(bp + 384)))[int32(1)], int32(F_SETFD), libc.VaList(bp+440, int32(FD_CLOEXEC))) < 0 {
		XTcl_Panic(tls, __ccgo_ts+78504, libc.VaList(bp+440, __ccgo_ts+78681))
	}
	/*
	 * Install the write end of the pipe into the global variable.
	 */
	libc.Xpthread_mutex_lock(tls, uintptr(unsafe.Pointer(&_notifierMutex)))
	_triggerPipe = (*(*[2]int32)(unsafe.Pointer(bp + 384)))[int32(1)]
	_otherPipe = (*(*[2]int32)(unsafe.Pointer(bp + 384)))[0]
	/*
	 * Signal any threads that are waiting.
	 */
	libc.Xpthread_cond_broadcast(tls, uintptr(unsafe.Pointer(&_notifierCV)))
	libc.Xpthread_mutex_unlock(tls, uintptr(unsafe.Pointer(&_notifierMutex)))
	/*
	 * Look for file events and report them to interested threads.
	 */
	for int32(1) != 0 {
		__b = bp
		__i = libc.Int32FromUint64(libc.Uint64FromInt64(128) / libc.Uint64FromInt64(8))
		for {
			if !(__i != 0) {
				break
			}
			v2 = __b
			__b += 8
			*(*uint64)(unsafe.Pointer(v2)) = uint64(0)
			goto _1
		_1:
			;
			__i--
		}
		__b1 = bp + 128
		__i1 = libc.Int32FromUint64(libc.Uint64FromInt64(128) / libc.Uint64FromInt64(8))
		for {
			if !(__i1 != 0) {
				break
			}
			v4 = __b1
			__b1 += 8
			*(*uint64)(unsafe.Pointer(v4)) = uint64(0)
			goto _3
		_3:
			;
			__i1--
		}
		__b2 = bp + 256
		__i2 = libc.Int32FromUint64(libc.Uint64FromInt64(128) / libc.Uint64FromInt64(8))
		for {
			if !(__i2 != 0) {
				break
			}
			v6 = __b2
			__b2 += 8
			*(*uint64)(unsafe.Pointer(v6)) = uint64(0)
			goto _5
		_5:
			;
			__i2--
		}
		/*
		 * Compute the logical OR of the masks from all the waiting
		 * notifiers.
		 */
		libc.Xpthread_mutex_lock(tls, uintptr(unsafe.Pointer(&_notifierMutex)))
		timePtr = libc.UintptrFromInt32(0)
		tsdPtr = _waitingListPtr
		for {
			if !(tsdPtr != 0) {
				break
			}
			i = (*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FnumFdBits - int32(1)
			for {
				if !(i >= 0) {
					break
				}
				if !!(*(*uint64)(unsafe.Pointer(tsdPtr + 8 + uintptr(libc.Uint64FromInt32(i)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8))&(libc.Uint64FromUint64(1)<<(libc.Uint64FromInt32(i)%(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))) != 0) {
					*(*uint64)(unsafe.Pointer(bp + uintptr(libc.Uint64FromInt32(i)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8)) |= uint64(1) << (libc.Uint64FromInt32(i) % (libc.Uint64FromInt32(8) * libc.Uint64FromInt64(8)))
				}
				if !!(*(*uint64)(unsafe.Pointer(tsdPtr + 8 + 128 + uintptr(libc.Uint64FromInt32(i)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8))&(libc.Uint64FromUint64(1)<<(libc.Uint64FromInt32(i)%(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))) != 0) {
					*(*uint64)(unsafe.Pointer(bp + 128 + uintptr(libc.Uint64FromInt32(i)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8)) |= uint64(1) << (libc.Uint64FromInt32(i) % (libc.Uint64FromInt32(8) * libc.Uint64FromInt64(8)))
				}
				if !!(*(*uint64)(unsafe.Pointer(tsdPtr + 8 + 256 + uintptr(libc.Uint64FromInt32(i)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8))&(libc.Uint64FromUint64(1)<<(libc.Uint64FromInt32(i)%(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))) != 0) {
					*(*uint64)(unsafe.Pointer(bp + 256 + uintptr(libc.Uint64FromInt32(i)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8)) |= uint64(1) << (libc.Uint64FromInt32(i) % (libc.Uint64FromInt32(8) * libc.Uint64FromInt64(8)))
				}
				goto _8
			_8:
				;
				i--
			}
			if (*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FnumFdBits > numFdBits {
				numFdBits = (*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FnumFdBits
			}
			if (*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FpollState&uint32(POLL_WANT) != 0 {
				/*
				 * Here we make sure we go through select() with the same mask
				 * bits that were present when the thread tried to poll.
				 */
				*(*uint32)(unsafe.Pointer(tsdPtr + 784)) |= uint32(POLL_DONE)
				timePtr = bp + 392
			}
			goto _7
		_7:
			;
			tsdPtr = (*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FnextPtr
		}
		libc.Xpthread_mutex_unlock(tls, uintptr(unsafe.Pointer(&_notifierMutex)))
		/*
		 * Set up the mask to include the receive pipe.
		 */
		if receivePipe >= numFdBits {
			numFdBits = receivePipe + int32(1)
		}
		*(*uint64)(unsafe.Pointer(bp + uintptr(libc.Uint64FromInt32(receivePipe)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8)) |= uint64(1) << (libc.Uint64FromInt32(receivePipe) % (libc.Uint64FromInt32(8) * libc.Uint64FromInt64(8)))
		/*
		 * Signals are unblocked only during select().
		 */
		if timePtr == libc.UintptrFromInt32(0) {
			tspecPtr = libc.UintptrFromInt32(0)
		} else {
			tspecPtr = bp + 416
			(*Ttimespec)(unsafe.Pointer(tspecPtr)).Ftv_sec = (*Ttimeval)(unsafe.Pointer(timePtr)).Ftv_sec
			(*Ttimespec)(unsafe.Pointer(tspecPtr)).Ftv_nsec = (*Ttimeval)(unsafe.Pointer(timePtr)).Ftv_usec * int64(1000)
		}
		ret = libc.Xpselect(tls, numFdBits, bp, bp+128, bp+256, tspecPtr, uintptr(unsafe.Pointer(&_notifierSigMask)))
		if ret == -int32(1) {
			/*
			 * In case a signal was caught during select(),
			 * perform work on async handlers now.
			 */
			if *(*int32)(unsafe.Pointer(libc.X__errno_location(tls))) == int32(EINTR) && _asyncPending != 0 {
				_asyncPending = 0
				XTclAsyncMarkFromNotifier(tls)
			}
			/*
			 * Try again immediately on select() error.
			 */
			continue
		}
		/*
		 * Alert any threads that are waiting on a ready file descriptor.
		 */
		libc.Xpthread_mutex_lock(tls, uintptr(unsafe.Pointer(&_notifierMutex)))
		tsdPtr = _waitingListPtr
		for {
			if !(tsdPtr != 0) {
				break
			}
			found = 0
			i = (*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FnumFdBits - int32(1)
			for {
				if !(i >= 0) {
					break
				}
				if !!(*(*uint64)(unsafe.Pointer(tsdPtr + 8 + uintptr(libc.Uint64FromInt32(i)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8))&(libc.Uint64FromUint64(1)<<(libc.Uint64FromInt32(i)%(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))) != 0) && !!(*(*uint64)(unsafe.Pointer(bp + uintptr(libc.Uint64FromInt32(i)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8))&(libc.Uint64FromUint64(1)<<(libc.Uint64FromInt32(i)%(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))) != 0) {
					*(*uint64)(unsafe.Pointer(tsdPtr + 392 + uintptr(libc.Uint64FromInt32(i)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8)) |= uint64(1) << (libc.Uint64FromInt32(i) % (libc.Uint64FromInt32(8) * libc.Uint64FromInt64(8)))
					found = int64(1)
				}
				if !!(*(*uint64)(unsafe.Pointer(tsdPtr + 8 + 128 + uintptr(libc.Uint64FromInt32(i)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8))&(libc.Uint64FromUint64(1)<<(libc.Uint64FromInt32(i)%(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))) != 0) && !!(*(*uint64)(unsafe.Pointer(bp + 128 + uintptr(libc.Uint64FromInt32(i)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8))&(libc.Uint64FromUint64(1)<<(libc.Uint64FromInt32(i)%(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))) != 0) {
					*(*uint64)(unsafe.Pointer(tsdPtr + 392 + 128 + uintptr(libc.Uint64FromInt32(i)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8)) |= uint64(1) << (libc.Uint64FromInt32(i) % (libc.Uint64FromInt32(8) * libc.Uint64FromInt64(8)))
					found = int64(1)
				}
				if !!(*(*uint64)(unsafe.Pointer(tsdPtr + 8 + 256 + uintptr(libc.Uint64FromInt32(i)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8))&(libc.Uint64FromUint64(1)<<(libc.Uint64FromInt32(i)%(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))) != 0) && !!(*(*uint64)(unsafe.Pointer(bp + 256 + uintptr(libc.Uint64FromInt32(i)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8))&(libc.Uint64FromUint64(1)<<(libc.Uint64FromInt32(i)%(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))) != 0) {
					*(*uint64)(unsafe.Pointer(tsdPtr + 392 + 256 + uintptr(libc.Uint64FromInt32(i)/(libc.Uint64FromInt32(8)*libc.Uint64FromInt64(8)))*8)) |= uint64(1) << (libc.Uint64FromInt32(i) % (libc.Uint64FromInt32(8) * libc.Uint64FromInt64(8)))
					found = int64(1)
				}
				goto _10
			_10:
				;
				i--
			}
			if found != 0 || (*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FpollState&uint32(POLL_DONE) != 0 {
				_AlertSingleThread(tls, tsdPtr)
			}
			goto _9
		_9:
			;
			tsdPtr = (*TThreadSpecificData15)(unsafe.Pointer(tsdPtr)).FnextPtr
		}
		libc.Xpthread_mutex_unlock(tls, uintptr(unsafe.Pointer(&_notifierMutex)))
		/*
		 * Consume the next byte from the notifier pipe if the pipe was
		 * readable. Note that there may be multiple bytes pending, but to
		 * avoid a race condition we only read one at a time.
		 */
		for cond := true; cond; cond = int32(1) != 0 {
			i = int32(libc.Xread(tls, receivePipe, bp+408, uint64(1)))
			if i <= 0 {
				break
			} else {
				if i == 0 || i == int32(1) && libc.Int32FromUint8((*(*[2]uint8)(unsafe.Pointer(bp + 408)))[0]) == int32('q') {
					/*
					 * Someone closed the write end of the pipe or sent us a Quit
					 * message [Bug: 4139] and then closed the write end of the
					 * pipe so we need to shut down the notifier thread.
					 */
					break
				}
			}
		}
		if _asyncPending != 0 {
			_asyncPending = 0
			XTclAsyncMarkFromNotifier(tls)
		}
		if i == 0 || libc.Int32FromUint8((*(*[2]uint8)(unsafe.Pointer(bp + 408)))[0]) == int32('q') {
			break
		}
	}
	/*
	 * Clean up the read end of the pipe and signal any threads waiting on
	 * termination of the notifier thread.
	 */
	libc.Xclose(tls, receivePipe)
	libc.Xpthread_mutex_lock(tls, uintptr(unsafe.Pointer(&_notifierMutex)))
	_triggerPipe = -int32(1)
	_otherPipe = -int32(1)
	libc.Xpthread_cond_broadcast(tls, uintptr(unsafe.Pointer(&_notifierCV)))
	libc.Xpthread_mutex_unlock(tls, uintptr(unsafe.Pointer(&_notifierMutex)))
	XTclpThreadExit(tls, 0)
}

type TThreadSpecificData16 = struct {
	FfirstFileHandlerPtr uintptr
	FcheckMasks          TSelectMasks
	FreadyMasks          TSelectMasks
	FnumFdBits           int32
	FonList              int32
	FpollState           uint32
	FnextPtr             uintptr
	FprevPtr             uintptr
	FwaitCV              Tpthread_cond_t
	FwaitCVinitialized   int32
	FeventReady          int32
}

const ALLOC_CHUNK = 8
const TCLOO_VERSION1 = "1.3.0"
const TCL_OO_METHOD_VERSION_CURRENT1 = 1

/* !END!: Do not edit above this line. */

/*
 * Alternatives to Tcl_Preserve/Tcl_EventuallyFree/Tcl_Release.
 */

/*
 * A convenience macro for iterating through the lists used in the internal
 * memory management of objects.
 * REQUIRES DECLARATION: Tcl_Size i;
 */

/*
 * A variation where the array is an array of structs. There's no issue with
 * possible NULLs; every element of the array will be iterated over and the
 * variable set to a pointer to each of those elements in turn.
 * REQUIRES DECLARATION: Tcl_Size i; See [96551aca55] for more FOREACH_STRUCT details.
 */

/*
 * Convenience macros for iterating through hash tables. FOREACH_HASH_DECLS
 * sets up the declarations needed for the main macro, FOREACH_HASH, which
 * does the actual iteration. FOREACH_HASH_KEY and FOREACH_HASH_VALUE are
 * restricted versions that only iterate over keys or values respectively.
 * REQUIRES DECLARATION: FOREACH_HASH_DECLS;
 */

/*
 * Convenience macro for duplicating a list. Needs no external declaration,
 * but all arguments are used multiple times and so must have no side effects.
 */

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * Commands in oo::define and oo::objdefine.
 */

var _defineCmds = [12]struct {
	Fname    uintptr
	FobjProc uintptr
	Fflag    int32
}{
	0: {
		Fname: __ccgo_ts + 28529,
	},
	1: {
		Fname: __ccgo_ts + 78723,
	},
	2: {
		Fname: __ccgo_ts + 78743,
	},
	3: {
		Fname: __ccgo_ts + 28541,
	},
	4: {
		Fname: __ccgo_ts + 53396,
	},
	5: {
		Fname: __ccgo_ts + 78756,
	},
	6: {
		Fname: __ccgo_ts + 28559,
	},
	7: {
		Fname: __ccgo_ts + 78764,
	},
	8: {
		Fname: __ccgo_ts + 78772,
	},
	9: {
		Fname: __ccgo_ts + 78785,
	},
	10: {
		Fname: __ccgo_ts + 78790,
	},
	11: {},
}

func init() {
	p := unsafe.Pointer(&_defineCmds)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(XTclOODefineConstructorObjCmd)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(XTclOODefineDefnNsObjCmd)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(XTclOODefineDeleteMethodObjCmd)
	*(*uintptr)(unsafe.Add(p, 80)) = __ccgo_fp(XTclOODefineDestructorObjCmd)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(XTclOODefineExportObjCmd)
	*(*uintptr)(unsafe.Add(p, 128)) = __ccgo_fp(XTclOODefineForwardObjCmd)
	*(*uintptr)(unsafe.Add(p, 152)) = __ccgo_fp(XTclOODefineMethodObjCmd)
	*(*uintptr)(unsafe.Add(p, 176)) = __ccgo_fp(XTclOODefinePrivateObjCmd)
	*(*uintptr)(unsafe.Add(p, 200)) = __ccgo_fp(XTclOODefineRenameMethodObjCmd)
	*(*uintptr)(unsafe.Add(p, 224)) = __ccgo_fp(XTclOODefineSelfObjCmd)
	*(*uintptr)(unsafe.Add(p, 248)) = __ccgo_fp(XTclOODefineUnexportObjCmd)
}

var _objdefCmds = [10]struct {
	Fname    uintptr
	FobjProc uintptr
	Fflag    int32
}{
	0: {
		Fname: __ccgo_ts + 19296,
		Fflag: int32(1),
	},
	1: {
		Fname: __ccgo_ts + 78743,
		Fflag: int32(1),
	},
	2: {
		Fname: __ccgo_ts + 53396,
		Fflag: int32(1),
	},
	3: {
		Fname: __ccgo_ts + 78756,
		Fflag: int32(1),
	},
	4: {
		Fname: __ccgo_ts + 28559,
		Fflag: int32(1),
	},
	5: {
		Fname: __ccgo_ts + 78764,
		Fflag: int32(1),
	},
	6: {
		Fname: __ccgo_ts + 78772,
		Fflag: int32(1),
	},
	7: {
		Fname: __ccgo_ts + 78785,
	},
	8: {
		Fname: __ccgo_ts + 78790,
		Fflag: int32(1),
	},
	9: {},
}

func init() {
	p := unsafe.Pointer(&_objdefCmds)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(XTclOODefineClassObjCmd)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(XTclOODefineDeleteMethodObjCmd)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(XTclOODefineExportObjCmd)
	*(*uintptr)(unsafe.Add(p, 80)) = __ccgo_fp(XTclOODefineForwardObjCmd)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(XTclOODefineMethodObjCmd)
	*(*uintptr)(unsafe.Add(p, 128)) = __ccgo_fp(XTclOODefinePrivateObjCmd)
	*(*uintptr)(unsafe.Add(p, 152)) = __ccgo_fp(XTclOODefineRenameMethodObjCmd)
	*(*uintptr)(unsafe.Add(p, 176)) = __ccgo_fp(XTclOODefineObjSelfObjCmd)
	*(*uintptr)(unsafe.Add(p, 200)) = __ccgo_fp(XTclOODefineUnexportObjCmd)
}

/*
 * Methods in the oo::object and oo::class classes. First, we define a helper
 * macro that makes building the method type declaration structure a lot
 * easier. No point in making life harder than it has to be!
 *
 * Note that the core methods don't need clone or free proc callbacks.
 */

var _objMethods = [6]TDeclaredClassMethod{
	0: {
		Fname:     __ccgo_ts + 78799,
		FisPublic: int32(1),
		Fdefinition: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 78807,
		},
	},
	1: {
		Fname: __ccgo_ts + 2464,
		Fdefinition: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 78830,
		},
	},
	2: {
		Fname: __ccgo_ts + 15720,
		Fdefinition: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 78850,
		},
	},
	3: {
		Fname: __ccgo_ts + 3502,
		Fdefinition: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 78873,
		},
	},
	4: {
		Fname: __ccgo_ts + 3762,
		Fdefinition: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 78897,
		},
	},
	5: {},
}

func init() {
	p := unsafe.Pointer(&_objMethods)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(XTclOO_Object_Destroy)
	*(*uintptr)(unsafe.Add(p, 88)) = __ccgo_fp(XTclOO_Object_Eval)
	*(*uintptr)(unsafe.Add(p, 144)) = __ccgo_fp(XTclOO_Object_Unknown)
	*(*uintptr)(unsafe.Add(p, 200)) = __ccgo_fp(XTclOO_Object_LinkVar)
	*(*uintptr)(unsafe.Add(p, 256)) = __ccgo_fp(XTclOO_Object_VarName)
}

var _clsMethods = [4]TDeclaredClassMethod{
	0: {
		Fname:     __ccgo_ts + 26194,
		FisPublic: int32(1),
		Fdefinition: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 78920,
		},
	},
	1: {
		Fname:     __ccgo_ts + 78942,
		FisPublic: int32(1),
		Fdefinition: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 78946,
		},
	},
	2: {
		Fname: __ccgo_ts + 78965,
		Fdefinition: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 78985,
		},
	},
	3: {},
}

func init() {
	p := unsafe.Pointer(&_clsMethods)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(XTclOO_Class_Create)
	*(*uintptr)(unsafe.Add(p, 88)) = __ccgo_fp(XTclOO_Class_New)
	*(*uintptr)(unsafe.Add(p, 144)) = __ccgo_fp(XTclOO_Class_CreateNs)
}

var _cfgMethods = [2]TDeclaredClassMethod{
	0: {
		Fname:     __ccgo_ts + 29497,
		FisPublic: int32(1),
		Fdefinition: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 79020,
		},
	},
	1: {},
}

func init() {
	p := unsafe.Pointer(&_cfgMethods)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(XTclOO_Configurable_Configure)
}

/*
 * And for the oo::class constructor...
 */

var _classConstructor = TTcl_MethodType{
	Fversion: int32(TCL_OO_METHOD_VERSION_1),
	Fname:    __ccgo_ts + 79045,
}

func init() {
	p := unsafe.Pointer(&_classConstructor)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(XTclOO_Class_Constructor)
}

/*
 * Scripted parts of TclOO. First, the main script (cannot be outside this
 * file).
 */

var _initScript = [206]uint8{'p', 'a', 'c', 'k', 'a', 'g', 'e', ' ', 'i', 'f', 'n', 'e', 'e', 'd', 'e', 'd', ' ', 'T', 'c', 'l', 'O', 'O', ' ', '1', '.', '3', '.', '0', ' ', '{', '#', ' ', 'A', 'l', 'r', 'e', 'a', 'd', 'y', ' ', 'p', 'r', 'e', 's', 'e', 'n', 't', ',', ' ', 'O', 'K', '?', '}', ';', 'p', 'a', 'c', 'k', 'a', 'g', 'e', ' ', 'i', 'f', 'n', 'e', 'e', 'd', 'e', 'd', ' ', 't', 'c', 'l', ':', ':', 'o', 'o', ' ', '1', '.', '3', '.', '0', ' ', '{', '#', ' ', 'A', 'l', 'r', 'e', 'a', 'd', 'y', ' ', 'p', 'r', 'e', 's', 'e', 'n', 't', ',', ' ', 'O', 'K', '?', '}', ';', 'n', 'a', 'm', 'e', 's', 'p', 'a', 'c', 'e', ' ', 'e', 'v', 'a', 'l', ' ', ':', ':', 'o', 'o', ' ', '{', ' ', 'v', 'a', 'r', 'i', 'a', 'b', 'l', 'e', ' ', 'v', 'e', 'r', 's', 'i', 'o', 'n', ' ', '1', '.', '3', ' ', '}', ';', 'n', 'a', 'm', 'e', 's', 'p', 'a', 'c', 'e', ' ', 'e', 'v', 'a', 'l', ' ', ':', ':', 'o', 'o', ' ', '{', ' ', 'v', 'a', 'r', 'i', 'a', 'b', 'l', 'e', ' ', 'p', 'a', 't', 'c', 'h', 'l', 'e', 'v', 'e', 'l', ' ', '1', '.', '3', '.', '0', ' ', '}', ';'}
var _tclOOSetupScript = __ccgo_ts + 79067

/*
 * Convenience macro for getting the foundation from an interpreter.
 */

/*
 * Macros to make inspecting into the guts of an object cleaner.
 *
 * The ocPtr parameter (only in these macros) is assumed to work fine with
 * either an oPtr or a classPtr. Note that the roots oo::object and oo::class
 * have _both_ their object and class flags tagged with ROOT_OBJECT and
 * ROOT_CLASS respectively.
 */

/*
 * ----------------------------------------------------------------------
 *
 * RemoveClass, RemoveObject --
 *
 *	Helpers for the RemoveItem macro for deleting a class or object from a
 *	list. Setting the "empty" location to NULL makes debugging a little
 *	easier.
 *
 * ----------------------------------------------------------------------
 */

func _RemoveClass(tls *libc.TLS, list uintptr, num Tsize_t, idx Tsize_t) {
	for {
		if !(idx+uint64(1) < num) {
			break
		}
		*(*uintptr)(unsafe.Pointer(list + uintptr(idx)*8)) = *(*uintptr)(unsafe.Pointer(list + uintptr(idx+uint64(1))*8))
		goto _1
	_1:
		;
		idx++
	}
	*(*uintptr)(unsafe.Pointer(list + uintptr(idx)*8)) = libc.UintptrFromInt32(0)
}

func _RemoveObject(tls *libc.TLS, list uintptr, num Tsize_t, idx Tsize_t) {
	for {
		if !(idx+uint64(1) < num) {
			break
		}
		*(*uintptr)(unsafe.Pointer(list + uintptr(idx)*8)) = *(*uintptr)(unsafe.Pointer(list + uintptr(idx+uint64(1))*8))
		goto _1
	_1:
		;
		idx++
	}
	*(*uintptr)(unsafe.Pointer(list + uintptr(idx)*8)) = libc.UintptrFromInt32(0)
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOInit --
 *
 *	Called to initialise the OO system within an interpreter.
 *
 * Result:
 *	TCL_OK if the setup succeeded. Currently assumed to always work.
 *
 * Side effects:
 *	Creates namespaces, commands, several classes and a number of
 *	callbacks. Upon return, the OO system is ready for use.
 *
 * ----------------------------------------------------------------------
 */

func XTclOOInit(tls *libc.TLS, interp uintptr) (r int32) {
	/* The interpreter to install into. */
	/*
	 * Build the core of the OO system.
	 */
	if _InitFoundation(tls, interp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Run our initialization script and, if that works, declare the package
	 * to be fully provided.
	 */
	if XTcl_EvalEx(tls, interp, uintptr(unsafe.Pointer(&_initScript)), int64(-libc.Int32FromInt32(1)), 0) != TCL_OK {
		return int32(TCL_ERROR)
	}
	XTcl_PkgProvideEx(tls, interp, __ccgo_ts+86818, __ccgo_ts+86824, uintptr(unsafe.Pointer(&XtclOOStubs)))
	return XTcl_PkgProvideEx(tls, interp, __ccgo_ts+86830, __ccgo_ts+86824, uintptr(unsafe.Pointer(&XtclOOStubs)))
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOGetFoundation --
 *
 *	Get a reference to the OO core class system.
 *
 * ----------------------------------------------------------------------
 */

func XTclOOGetFoundation(tls *libc.TLS, interp uintptr) (r uintptr) {
	return (*TInterp)(unsafe.Pointer(interp)).FobjectFoundation
}

// C documentation
//
//	/*
//	 * ----------------------------------------------------------------------
//	 *
//	 * CreateCmdInNS --
//	 *
//	 *	Create a command in a namespace. Supports setting various
//	 *	implementation functions, but not a deletion callback or a clientData;
//	 *	it's suitable for use-cases in this file, no more.
//	 *
//	 * ----------------------------------------------------------------------
//	 */
func _CreateCmdInNS(tls *libc.TLS, interp uintptr, namespacePtr uintptr, name uintptr, cmdProc uintptr, nreProc uintptr, compileProc uintptr) {
	var cmdPtr uintptr
	_ = cmdPtr
	if cmdProc == libc.UintptrFromInt32(0) && nreProc == libc.UintptrFromInt32(0) {
		XTcl_Panic(tls, __ccgo_ts+86838, 0)
	}
	cmdPtr = XTclCreateObjCommandInNs(tls, interp, name, namespacePtr, cmdProc, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	(*TCommand)(unsafe.Pointer(cmdPtr)).FnreProc = nreProc
	(*TCommand)(unsafe.Pointer(cmdPtr)).FcompileProc = compileProc
}

/*
 * ----------------------------------------------------------------------
 *
 * InitFoundation --
 *
 *	Set up the core of the OO core class system. This is a structure
 *	holding references to the magical bits that need to be known about in
 *	other places, plus the oo::object and oo::class classes.
 *
 * ----------------------------------------------------------------------
 */

func _InitFoundation(tls *libc.TLS, interp uintptr) (r int32) {
	var _objPtr, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cachePtr8, define, fPtr, namePtr, objdef, tsdPtr, v11, v15, v17, v9 uintptr
	var cfgCls TTcl_Object
	var i Tsize_t
	var v1, v14, v2, v3, v4, v5, v6, v7, v8 bool
	var v10, v16 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, cachePtr7, cachePtr8, cfgCls, define, fPtr, i, namePtr, objdef, tsdPtr, v1, v10, v11, v14, v15, v16, v17, v2, v3, v4, v5, v6, v7, v8, v9
	tsdPtr = XTcl_GetThreadData(tls, uintptr(unsafe.Pointer(&_tsdKey)), int64(8))
	fPtr = XTcl_Alloc(tls, uint64(112))
	/*
	 * Initialize the structure that holds the OO system core. This is
	 * attached to the interpreter via an assocData entry; not very efficient,
	 * but the best we can do without hacking the core more.
	 */
	libc.Xmemset(tls, fPtr, 0, uint64(112))
	(*TInterp)(unsafe.Pointer(interp)).FobjectFoundation = fPtr
	(*TFoundation)(unsafe.Pointer(fPtr)).Finterp = interp
	(*TFoundation)(unsafe.Pointer(fPtr)).FooNs = XTcl_CreateNamespace(tls, interp, __ccgo_ts+86887, fPtr, libc.UintptrFromInt32(0))
	XTcl_Export(tls, interp, (*TFoundation)(unsafe.Pointer(fPtr)).FooNs, __ccgo_ts+86892, int32(1))
	define = XTcl_CreateNamespace(tls, interp, __ccgo_ts+86899, fPtr, libc.UintptrFromInt32(0))
	objdef = XTcl_CreateNamespace(tls, interp, __ccgo_ts+86912, fPtr, libc.UintptrFromInt32(0))
	(*TFoundation)(unsafe.Pointer(fPtr)).FhelpersNs = XTcl_CreateNamespace(tls, interp, __ccgo_ts+86928, fPtr, __ccgo_fp(_DeletedHelpersNamespace))
	XTcl_CreateNamespace(tls, interp, __ccgo_ts+86942, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	(*TFoundation)(unsafe.Pointer(fPtr)).Fepoch = int64(1)
	(*TFoundation)(unsafe.Pointer(fPtr)).FtsdPtr = tsdPtr
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		(*TFoundation)(unsafe.Pointer(fPtr)).FunknownMethodNameObj = XTclThreadAllocObj(tls)
	} else {
		(*TFoundation)(unsafe.Pointer(fPtr)).FunknownMethodNameObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FunknownMethodNameObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FunknownMethodNameObj)).FrefCount = 0
	if libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FunknownMethodNameObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FunknownMethodNameObj)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FunknownMethodNameObj)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FunknownMethodNameObj)).Fbytes, __ccgo_ts+15720, libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FunknownMethodNameObj)).Fbytes + uintptr(libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FunknownMethodNameObj)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(8) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FunknownMethodNameObj)).FtypePtr = libc.UintptrFromInt32(0)
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		(*TFoundation)(unsafe.Pointer(fPtr)).FconstructorName = XTclThreadAllocObj(tls)
	} else {
		(*TFoundation)(unsafe.Pointer(fPtr)).FconstructorName = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FconstructorName + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FconstructorName)).FrefCount = 0
	if libc.Uint64FromInt64(14)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FconstructorName)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FconstructorName)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FconstructorName)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(14)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FconstructorName)).Fbytes, __ccgo_ts+86965, libc.Uint64FromInt64(14)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FconstructorName)).Fbytes + uintptr(libc.Uint64FromInt64(14)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FconstructorName)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(14) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FconstructorName)).FtypePtr = libc.UintptrFromInt32(0)
	if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
		cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
		(*TFoundation)(unsafe.Pointer(fPtr)).FdestructorName = XTclThreadAllocObj(tls)
	} else {
		(*TFoundation)(unsafe.Pointer(fPtr)).FdestructorName = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdestructorName + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdestructorName)).FrefCount = 0
	if libc.Uint64FromInt64(13)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdestructorName)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdestructorName)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdestructorName)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(13)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdestructorName)).Fbytes, __ccgo_ts+86979, libc.Uint64FromInt64(13)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdestructorName)).Fbytes + uintptr(libc.Uint64FromInt64(13)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdestructorName)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(13) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdestructorName)).FtypePtr = libc.UintptrFromInt32(0)
	if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
		cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
		(*TFoundation)(unsafe.Pointer(fPtr)).FclonedName = XTclThreadAllocObj(tls)
	} else {
		(*TFoundation)(unsafe.Pointer(fPtr)).FclonedName = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclonedName + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclonedName)).FrefCount = 0
	if libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclonedName)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclonedName)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclonedName)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclonedName)).Fbytes, __ccgo_ts+86992, libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclonedName)).Fbytes + uintptr(libc.Uint64FromInt64(9)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclonedName)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(9) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclonedName)).FtypePtr = libc.UintptrFromInt32(0)
	if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
		cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v5 || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == libc.Uint64FromInt32(0) {
		(*TFoundation)(unsafe.Pointer(fPtr)).FdefineName = XTclThreadAllocObj(tls)
	} else {
		(*TFoundation)(unsafe.Pointer(fPtr)).FdefineName = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdefineName + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdefineName)).FrefCount = 0
	if libc.Uint64FromInt64(13)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdefineName)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdefineName)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdefineName)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(13)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdefineName)).Fbytes, __ccgo_ts+86899, libc.Uint64FromInt64(13)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdefineName)).Fbytes + uintptr(libc.Uint64FromInt64(13)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdefineName)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(13) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdefineName)).FtypePtr = libc.UintptrFromInt32(0)
	if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
		cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v6 || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == libc.Uint64FromInt32(0) {
		(*TFoundation)(unsafe.Pointer(fPtr)).FmyName = XTclThreadAllocObj(tls)
	} else {
		(*TFoundation)(unsafe.Pointer(fPtr)).FmyName = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmyName + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmyName)).FrefCount = 0
	if libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmyName)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmyName)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmyName)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmyName)).Fbytes, __ccgo_ts+87001, libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmyName)).Fbytes + uintptr(libc.Uint64FromInt64(3)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmyName)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(3) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmyName)).FtypePtr = libc.UintptrFromInt32(0)
	if v7 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v7 {
		cachePtr6 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v7 || (*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects == libc.Uint64FromInt32(0) {
		(*TFoundation)(unsafe.Pointer(fPtr)).FmcdName = XTclThreadAllocObj(tls)
	} else {
		(*TFoundation)(unsafe.Pointer(fPtr)).FmcdName = (*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmcdName + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmcdName)).FrefCount = 0
	if libc.Uint64FromInt64(26)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmcdName)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmcdName)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmcdName)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(26)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmcdName)).Fbytes, __ccgo_ts+87004, libc.Uint64FromInt64(26)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmcdName)).Fbytes + uintptr(libc.Uint64FromInt64(26)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmcdName)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(26) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmcdName)).FtypePtr = libc.UintptrFromInt32(0)
	(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FunknownMethodNameObj)).FrefCount++
	(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FconstructorName)).FrefCount++
	(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdestructorName)).FrefCount++
	(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclonedName)).FrefCount++
	(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdefineName)).FrefCount++
	(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmyName)).FrefCount++
	(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmcdName)).FrefCount++
	XTclCreateObjCommandInNs(tls, interp, __ccgo_ts+87030, (*TFoundation)(unsafe.Pointer(fPtr)).FooNs, __ccgo_fp(XTclOOUnknownDefinition), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	if v8 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v8 {
		cachePtr7 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v8 || (*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects == libc.Uint64FromInt32(0) {
		namePtr = XTclThreadAllocObj(tls)
	} else {
		namePtr = (*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr7)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(namePtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr7)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(namePtr)).FrefCount = 0
	if libc.Uint64FromInt64(24)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(namePtr)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(24)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes, __ccgo_ts+87048, libc.Uint64FromInt64(24)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes + uintptr(libc.Uint64FromInt64(24)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(namePtr)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(24) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(namePtr)).FtypePtr = libc.UintptrFromInt32(0)
	XTcl_SetNamespaceUnknownHandler(tls, interp, define, namePtr)
	XTcl_SetNamespaceUnknownHandler(tls, interp, objdef, namePtr)
	v9 = namePtr
	if v9 != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(v9)).FrefCount == libc.Int64FromInt32(0) {
			_objPtr = v9
			v11 = _objPtr
			v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
			*(*TTcl_Size)(unsafe.Pointer(v11))--
			if v10 <= libc.Int64FromInt32(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
	}
	/*
	 * Create the subcommands in the oo::define and oo::objdefine spaces.
	 */
	i = uint64(0)
	for {
		if !(_defineCmds[i].Fname != 0) {
			break
		}
		XTclCreateObjCommandInNs(tls, interp, _defineCmds[i].Fname, define, _defineCmds[i].FobjProc, uintptr(int64(_defineCmds[i].Fflag)), libc.UintptrFromInt32(0))
		goto _12
	_12:
		;
		i++
	}
	i = uint64(0)
	for {
		if !(_objdefCmds[i].Fname != 0) {
			break
		}
		XTclCreateObjCommandInNs(tls, interp, _objdefCmds[i].Fname, objdef, _objdefCmds[i].FobjProc, uintptr(int64(_objdefCmds[i].Fflag)), libc.UintptrFromInt32(0))
		goto _13
	_13:
		;
		i++
	}
	XTcl_CallWhenDeleted(tls, interp, __ccgo_fp(_KillFoundation), libc.UintptrFromInt32(0))
	/*
	 * Create the special objects at the core of the object system.
	 */
	_InitClassSystemRoots(tls, interp, fPtr)
	/*
	 * Basic method declarations for the core classes.
	 */
	XTclOODefineBasicMethods(tls, (*TFoundation)(unsafe.Pointer(fPtr)).FobjectCls, uintptr(unsafe.Pointer(&_objMethods)))
	XTclOODefineBasicMethods(tls, (*TFoundation)(unsafe.Pointer(fPtr)).FclassCls, uintptr(unsafe.Pointer(&_clsMethods)))
	/*
	 * Finish setting up the class of classes by marking the 'new' method as
	 * private; classes, unlike general objects, must have explicit names. We
	 * also need to create the constructor for classes.
	 */
	if v14 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v14 {
		cachePtr8 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v14 || (*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects == libc.Uint64FromInt32(0) {
		namePtr = XTclThreadAllocObj(tls)
	} else {
		namePtr = (*TAllocCache)(unsafe.Pointer(cachePtr8)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr8)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(namePtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr8)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(namePtr)).FrefCount = 0
	if libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(namePtr)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes, __ccgo_ts+78942, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes + uintptr(libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(namePtr)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(4) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(namePtr)).FtypePtr = libc.UintptrFromInt32(0)
	XTclNewInstanceMethod(tls, interp, (*TClass)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclassCls)).FthisPtr, namePtr, 0, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	v15 = namePtr
	if v15 != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(v15)).FrefCount == libc.Int64FromInt32(0) {
			_objPtr = v15
			v17 = _objPtr
			v16 = *(*TTcl_Size)(unsafe.Pointer(v17))
			*(*TTcl_Size)(unsafe.Pointer(v17))--
			if v16 <= libc.Int64FromInt32(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
	}
	(*TClass)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclassCls)).FconstructorPtr = XTclNewMethod(tls, (*TFoundation)(unsafe.Pointer(fPtr)).FclassCls, libc.UintptrFromInt32(0), 0, uintptr(unsafe.Pointer(&_classConstructor)), libc.UintptrFromInt32(0))
	/*
	 * Create non-object commands and plug ourselves into the Tcl [info]
	 * ensemble.
	 */
	_CreateCmdInNS(tls, interp, (*TFoundation)(unsafe.Pointer(fPtr)).FhelpersNs, __ccgo_ts+25555, libc.UintptrFromInt32(0), __ccgo_fp(XTclOONextObjCmd), __ccgo_fp(XTclCompileObjectNextCmd))
	_CreateCmdInNS(tls, interp, (*TFoundation)(unsafe.Pointer(fPtr)).FhelpersNs, __ccgo_ts+87072, libc.UintptrFromInt32(0), __ccgo_fp(XTclOONextToObjCmd), __ccgo_fp(XTclCompileObjectNextToCmd))
	_CreateCmdInNS(tls, interp, (*TFoundation)(unsafe.Pointer(fPtr)).FhelpersNs, __ccgo_ts+78785, __ccgo_fp(XTclOOSelfObjCmd), libc.UintptrFromInt32(0), __ccgo_fp(XTclCompileObjectSelfCmd))
	_CreateCmdInNS(tls, interp, (*TFoundation)(unsafe.Pointer(fPtr)).FooNs, __ccgo_ts+69824, __ccgo_fp(XTclOODefineObjCmd), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	_CreateCmdInNS(tls, interp, (*TFoundation)(unsafe.Pointer(fPtr)).FooNs, __ccgo_ts+87079, __ccgo_fp(XTclOOObjDefObjCmd), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	_CreateCmdInNS(tls, interp, (*TFoundation)(unsafe.Pointer(fPtr)).FooNs, __ccgo_ts+5658, __ccgo_fp(XTclOOCopyObjectCmd), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	XTclOOInitInfo(tls, interp)
	/*
	 * Now make the class of slots.
	 */
	if XTclOODefineSlots(tls, fPtr) != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Make the configurable class and install its standard defined method.
	 */
	cfgCls = XTcl_NewObjectInstance(tls, interp, (*TFoundation)(unsafe.Pointer(fPtr)).FclassCls, __ccgo_ts+87089, libc.UintptrFromInt32(0), int64(-libc.Int32FromInt32(1)), libc.UintptrFromInt32(0), 0)
	XTclOODefineBasicMethods(tls, (*TObject)(unsafe.Pointer(cfgCls)).FclassPtr, uintptr(unsafe.Pointer(&_cfgMethods)))
	/*
	 * Don't have handles to these namespaces, so use Tcl_CreateObjCommand.
	 */
	XTcl_CreateObjCommand(tls, interp, __ccgo_ts+87126, __ccgo_fp(XTclOODefinePropertyCmd), libc.UintptrFromInt32(1), libc.UintptrFromInt32(0))
	XTcl_CreateObjCommand(tls, interp, __ccgo_ts+87179, __ccgo_fp(XTclOODefinePropertyCmd), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	/*
	 * Evaluate the remaining definitions, which are a compiled-in Tcl script.
	 */
	return XTcl_EvalEx(tls, interp, _tclOOSetupScript, int64(-libc.Int32FromInt32(1)), 0)
}

var _tsdKey TTcl_ThreadDataKey

/*
 * ----------------------------------------------------------------------
 *
 * InitClassSystemRoots --
 *
 *	Creates the objects at the core of the object system. These need to be
 *	spliced manually.
 *
 * ----------------------------------------------------------------------
 */

func _InitClassSystemRoots(tls *libc.TLS, interp uintptr, fPtr uintptr) {
	bp := tls.Alloc(640)
	defer tls.Free(640)
	var cachePtr, cachePtr1, defNsName uintptr
	var v1, v2 bool
	var _ /* fakeCls at bp+0 */ TClass
	var _ /* fakeObject at bp+392 */ TObject
	_, _, _, _, _ = cachePtr, cachePtr1, defNsName, v1, v2
	/* Stand up a phony class for bootstrapping. */
	(*TFoundation)(unsafe.Pointer(fPtr)).FobjectCls = bp
	/* referenced in TclOOAllocClass to increment the refCount. */
	(*(*TClass)(unsafe.Pointer(bp))).FthisPtr = bp + 392
	(*(*TObject)(unsafe.Pointer(bp + 392))).FrefCount = 0 // Do not increment an uninitialized value.
	(*TFoundation)(unsafe.Pointer(fPtr)).FobjectCls = XTclOOAllocClass(tls, interp, _AllocObject(tls, interp, __ccgo_ts+6499, (*TFoundation)(unsafe.Pointer(fPtr)).FooNs, libc.UintptrFromInt32(0)))
	// Corresponding TclOODecrRefCount in KillFoundation
	(*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FobjectCls)).FthisPtr)).FrefCount++
	/*
	 * This is why it is unnecessary in this routine to replace the
	 * incremented reference count of fPtr->objectCls that was swallowed by
	 * fakeObject.
	 */
	(*TClass)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FobjectCls)).Fsuperclasses.Fnum = 0
	XTclpFree(tls, (*TClass)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FobjectCls)).Fsuperclasses.Flist)
	(*TClass)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FobjectCls)).Fsuperclasses.Flist = libc.UintptrFromInt32(0)
	/*
	 * Special initialization for the primordial objects.
	 */
	*(*int32)(unsafe.Pointer((*TClass)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FobjectCls)).FthisPtr + 96)) |= int32(ROOT_OBJECT)
	*(*int32)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FobjectCls + 8)) |= int32(ROOT_OBJECT)
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		defNsName = XTclThreadAllocObj(tls)
	} else {
		defNsName = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(defNsName + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(defNsName)).FrefCount = 0
	if libc.Uint64FromInt64(16)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(defNsName)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(defNsName)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(defNsName)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(16)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(defNsName)).Fbytes, __ccgo_ts+86912, libc.Uint64FromInt64(16)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(defNsName)).Fbytes + uintptr(libc.Uint64FromInt64(16)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(defNsName)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(16) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(defNsName)).FtypePtr = libc.UintptrFromInt32(0)
	(*TClass)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FobjectCls)).FobjDefinitionNs = defNsName
	(*TTcl_Obj)(unsafe.Pointer(defNsName)).FrefCount++
	(*TFoundation)(unsafe.Pointer(fPtr)).FclassCls = XTclOOAllocClass(tls, interp, _AllocObject(tls, interp, __ccgo_ts+19296, (*TFoundation)(unsafe.Pointer(fPtr)).FooNs, libc.UintptrFromInt32(0)))
	// Corresponding TclOODecrRefCount in KillFoundation
	(*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclassCls)).FthisPtr)).FrefCount++
	/*
	 * Increment reference counts for each reference because these
	 * relationships can be dynamically changed.
	 *
	 * Corresponding TclOODecrRefCount for all incremented refcounts is in
	 * KillFoundation.
	 */
	/*
	 * Rewire bootstrapped objects.
	 */
	(*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FobjectCls)).FthisPtr)).FselfCls = (*TFoundation)(unsafe.Pointer(fPtr)).FclassCls
	(*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclassCls)).FthisPtr)).FrefCount++
	XTclOOAddToInstances(tls, (*TClass)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FobjectCls)).FthisPtr, (*TFoundation)(unsafe.Pointer(fPtr)).FclassCls)
	(*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclassCls)).FthisPtr)).FselfCls = (*TFoundation)(unsafe.Pointer(fPtr)).FclassCls
	(*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclassCls)).FthisPtr)).FrefCount++
	XTclOOAddToInstances(tls, (*TClass)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclassCls)).FthisPtr, (*TFoundation)(unsafe.Pointer(fPtr)).FclassCls)
	*(*int32)(unsafe.Pointer((*TClass)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclassCls)).FthisPtr + 96)) |= int32(ROOT_CLASS)
	*(*int32)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclassCls + 8)) |= int32(ROOT_CLASS)
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		defNsName = XTclThreadAllocObj(tls)
	} else {
		defNsName = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(defNsName + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(defNsName)).FrefCount = 0
	if libc.Uint64FromInt64(13)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(defNsName)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(defNsName)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(defNsName)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(13)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(defNsName)).Fbytes, __ccgo_ts+86899, libc.Uint64FromInt64(13)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(defNsName)).Fbytes + uintptr(libc.Uint64FromInt64(13)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(defNsName)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(13) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(defNsName)).FtypePtr = libc.UintptrFromInt32(0)
	(*TClass)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclassCls)).FclsDefinitionNs = defNsName
	(*TTcl_Obj)(unsafe.Pointer(defNsName)).FrefCount++
	/* Standard initialization for new Objects */
	XTclOOAddToSubclasses(tls, (*TFoundation)(unsafe.Pointer(fPtr)).FclassCls, (*TFoundation)(unsafe.Pointer(fPtr)).FobjectCls)
	/*
	 * THIS IS THE ONLY FUNCTION THAT DOES NON-STANDARD CLASS SPLICING.
	 * Everything else is careful to prohibit looping.
	 */
}

/*
 * ----------------------------------------------------------------------
 *
 * DeletedHelpersNamespace --
 *
 *	Simple helper used to clear fields of the foundation when they no
 *	longer hold useful information.
 *
 * ----------------------------------------------------------------------
 */

func _DeletedHelpersNamespace(tls *libc.TLS, clientData uintptr) {
	var fPtr uintptr
	_ = fPtr
	fPtr = clientData
	(*TFoundation)(unsafe.Pointer(fPtr)).FhelpersNs = libc.UintptrFromInt32(0)
}

/*
 * ----------------------------------------------------------------------
 *
 * KillFoundation --
 *
 *	Delete those parts of the OO core that are not deleted automatically
 *	when the objects and classes themselves are destroyed.
 *
 * ----------------------------------------------------------------------
 */

func _KillFoundation(tls *libc.TLS, dummy603 uintptr, interp uintptr) {
	/* The interpreter containing the OO system
	 * foundation. */
	var cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, fPtr, v11, v14, v17, v2, v20, v5, v8 uintptr
	var v1, v10, v13, v16, v19, v4, v7 TTcl_Size
	var v12, v15, v18, v21, v3, v6, v9 bool
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, cachePtr5, cachePtr6, fPtr, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v3, v4, v5, v6, v7, v8, v9
	fPtr = (*TInterp)(unsafe.Pointer(interp)).FobjectFoundation
	v2 = (*TFoundation)(unsafe.Pointer(fPtr)).FunknownMethodNameObj
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if !(v1 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FunknownMethodNameObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FunknownMethodNameObj)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FunknownMethodNameObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FunknownMethodNameObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FunknownMethodNameObj)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FunknownMethodNameObj)).Flength = int64(-libc.Int32FromInt32(1))
			if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, (*TFoundation)(unsafe.Pointer(fPtr)).FunknownMethodNameObj)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FunknownMethodNameObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*TFoundation)(unsafe.Pointer(fPtr)).FunknownMethodNameObj
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, (*TFoundation)(unsafe.Pointer(fPtr)).FunknownMethodNameObj)
		}
	}
	v5 = (*TFoundation)(unsafe.Pointer(fPtr)).FconstructorName
	v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
	*(*TTcl_Size)(unsafe.Pointer(v5))--
	if !(v4 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FconstructorName)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FconstructorName)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FconstructorName)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FconstructorName)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FconstructorName)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FconstructorName)).Flength = int64(-libc.Int32FromInt32(1))
			if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v6 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, (*TFoundation)(unsafe.Pointer(fPtr)).FconstructorName)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FconstructorName + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*TFoundation)(unsafe.Pointer(fPtr)).FconstructorName
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, (*TFoundation)(unsafe.Pointer(fPtr)).FconstructorName)
		}
	}
	v8 = (*TFoundation)(unsafe.Pointer(fPtr)).FdestructorName
	v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
	*(*TTcl_Size)(unsafe.Pointer(v8))--
	if !(v7 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdestructorName)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdestructorName)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdestructorName)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdestructorName)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdestructorName)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdestructorName)).Flength = int64(-libc.Int32FromInt32(1))
			if v9 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v9 {
				cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v9 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, (*TFoundation)(unsafe.Pointer(fPtr)).FdestructorName)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdestructorName + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*TFoundation)(unsafe.Pointer(fPtr)).FdestructorName
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, (*TFoundation)(unsafe.Pointer(fPtr)).FdestructorName)
		}
	}
	v11 = (*TFoundation)(unsafe.Pointer(fPtr)).FclonedName
	v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
	*(*TTcl_Size)(unsafe.Pointer(v11))--
	if !(v10 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclonedName)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclonedName)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclonedName)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclonedName)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclonedName)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclonedName)).Flength = int64(-libc.Int32FromInt32(1))
			if v12 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v12 {
				cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v12 || ((*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, (*TFoundation)(unsafe.Pointer(fPtr)).FclonedName)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclonedName + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*TFoundation)(unsafe.Pointer(fPtr)).FclonedName
				(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, (*TFoundation)(unsafe.Pointer(fPtr)).FclonedName)
		}
	}
	v14 = (*TFoundation)(unsafe.Pointer(fPtr)).FdefineName
	v13 = *(*TTcl_Size)(unsafe.Pointer(v14))
	*(*TTcl_Size)(unsafe.Pointer(v14))--
	if !(v13 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdefineName)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdefineName)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdefineName)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdefineName)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdefineName)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdefineName)).Flength = int64(-libc.Int32FromInt32(1))
			if v15 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v15 {
				cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v15 || ((*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, (*TFoundation)(unsafe.Pointer(fPtr)).FdefineName)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FdefineName + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = (*TFoundation)(unsafe.Pointer(fPtr)).FdefineName
				(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, (*TFoundation)(unsafe.Pointer(fPtr)).FdefineName)
		}
	}
	v17 = (*TFoundation)(unsafe.Pointer(fPtr)).FmyName
	v16 = *(*TTcl_Size)(unsafe.Pointer(v17))
	*(*TTcl_Size)(unsafe.Pointer(v17))--
	if !(v16 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmyName)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmyName)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmyName)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmyName)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmyName)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmyName)).Flength = int64(-libc.Int32FromInt32(1))
			if v18 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v18 {
				cachePtr5 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v18 || ((*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, (*TFoundation)(unsafe.Pointer(fPtr)).FmyName)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmyName + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr5)).FfirstObjPtr = (*TFoundation)(unsafe.Pointer(fPtr)).FmyName
				(*TAllocCache)(unsafe.Pointer(cachePtr5)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, (*TFoundation)(unsafe.Pointer(fPtr)).FmyName)
		}
	}
	v20 = (*TFoundation)(unsafe.Pointer(fPtr)).FmcdName
	v19 = *(*TTcl_Size)(unsafe.Pointer(v20))
	*(*TTcl_Size)(unsafe.Pointer(v20))--
	if !(v19 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmcdName)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmcdName)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmcdName)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmcdName)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmcdName)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmcdName)).Flength = int64(-libc.Int32FromInt32(1))
			if v21 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v21 {
				cachePtr6 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v21 || ((*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, (*TFoundation)(unsafe.Pointer(fPtr)).FmcdName)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FmcdName + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr6)).FfirstObjPtr = (*TFoundation)(unsafe.Pointer(fPtr)).FmcdName
				(*TAllocCache)(unsafe.Pointer(cachePtr6)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, (*TFoundation)(unsafe.Pointer(fPtr)).FmcdName)
		}
	}
	XTclOODecrRefCount(tls, (*TClass)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FobjectCls)).FthisPtr)
	XTclOODecrRefCount(tls, (*TClass)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclassCls)).FthisPtr)
	XTclpFree(tls, fPtr)
	/*
	 * Don't leave the interpreter field pointing to freed data.
	 */
	(*TInterp)(unsafe.Pointer(interp)).FobjectFoundation = libc.UintptrFromInt32(0)
}

/*
 * ----------------------------------------------------------------------
 *
 * AllocObject --
 *
 *	Allocate an object of basic type. Does not splice the object into its
 *	class's instance list.  The caller must set the classPtr on the object
 *	to either a class or NULL, call TclOOAddToInstances to add the object
 *	to the class's instance list, and if the object itself is a class, use
 *	call TclOOAddToSubclasses() to add it to the right class's list of
 *	subclasses.
 *
 * Returns:
 *	Pointer to the object structure created, or NULL if a specific
 *	namespace was asked for but couldn't be created.
 *
 * ----------------------------------------------------------------------
 */

func _AllocObject(tls *libc.TLS, interp uintptr, nameStr uintptr, nsPtr uintptr, nsNameStr uintptr) (r uintptr) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* The name of the namespace to create, or
	 * NULL if the OO system should pick a unique
	 * name itself. If this is non-NULL but names
	 * a namespace that already exists, the effect
	 * will be the same as if this was NULL. */
	var cmdPtr, fPtr, oPtr, tracePtr, v2, v4, v5 uintptr
	var creationEpoch Tsize_t
	var v1, v3 TTcl_Size
	var _ /* objName at bp+0 */ [34]uint8
	_, _, _, _, _, _, _, _, _, _ = cmdPtr, creationEpoch, fPtr, oPtr, tracePtr, v1, v2, v3, v4, v5
	fPtr = (*TInterp)(unsafe.Pointer(interp)).FobjectFoundation
	oPtr = XTcl_Alloc(tls, uint64(248))
	libc.Xmemset(tls, oPtr, 0, uint64(248))
	/*
	 * Every object has a namespace; make one. Note that this also normally
	 * computes the creation epoch value for the object, a sequence number
	 * that is unique to the object (and which allows us to manage method
	 * caching without comparing pointers).
	 *
	 * When creating a namespace, we first check to see if the caller
	 * specified the name for the namespace. If not, we generate namespace
	 * names using the epoch until such time as a new namespace is actually
	 * created.
	 */
	if nsNameStr != libc.UintptrFromInt32(0) {
		(*TObject)(unsafe.Pointer(oPtr)).FnamespacePtr = XTcl_CreateNamespace(tls, interp, nsNameStr, oPtr, libc.UintptrFromInt32(0))
		if (*TObject)(unsafe.Pointer(oPtr)).FnamespacePtr == libc.UintptrFromInt32(0) {
			/*
			 * Couldn't make the specific namespace. Report as an error.
			 * [Bug 154f0982f2]
			 */
			XTclpFree(tls, oPtr)
			return libc.UintptrFromInt32(0)
		}
		v2 = (*TFoundation)(unsafe.Pointer(fPtr)).FtsdPtr
		*(*TTcl_Size)(unsafe.Pointer(v2))++
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		creationEpoch = libc.Uint64FromInt64(v1)
		goto configNamespace
	}
	for int32(1) != 0 {
		v4 = (*TFoundation)(unsafe.Pointer(fPtr)).FtsdPtr
		*(*TTcl_Size)(unsafe.Pointer(v4))++
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		libc.X__builtin_snprintf(tls, bp, uint64(34), __ccgo_ts+87231, libc.VaList(bp+48, v3))
		(*TObject)(unsafe.Pointer(oPtr)).FnamespacePtr = XTcl_CreateNamespace(tls, interp, bp, oPtr, libc.UintptrFromInt32(0))
		if (*TObject)(unsafe.Pointer(oPtr)).FnamespacePtr != libc.UintptrFromInt32(0) {
			creationEpoch = libc.Uint64FromInt64((*TThreadLocalData)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FtsdPtr)).FnsCount)
			break
		}
		/*
		 * Could not make that namespace, so we make another. But first we
		 * have to get rid of the error message from Tcl_CreateNamespace,
		 * since that's something that should not be exposed to the user.
		 */
		XTcl_ResetResult(tls, interp)
	}
	goto configNamespace
configNamespace:
	;
	(*TNamespace)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FnamespacePtr)).FrefCount++
	/*
	 * Make the namespace know about the helper commands. This grants access
	 * to the [self] and [next] commands.
	 */
	if (*TFoundation)(unsafe.Pointer(fPtr)).FhelpersNs != libc.UintptrFromInt32(0) {
		XTclSetNsPath(tls, (*TObject)(unsafe.Pointer(oPtr)).FnamespacePtr, int64(1), fPtr+32)
	}
	XTclOOSetupVariableResolver(tls, (*TObject)(unsafe.Pointer(oPtr)).FnamespacePtr)
	/*
	 * Suppress use of compiled versions of the commands in this object's
	 * namespace and its children; causes wrong behaviour without expensive
	 * recompilation. [Bug 2037727]
	 */
	*(*int32)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FnamespacePtr + 160)) |= int32(NS_SUPPRESS_COMPILATION)
	/*
	 * Set up a callback to get notification of the deletion of a namespace
	 * when enough of the namespace still remains to execute commands and
	 * access variables in it. [Bug 2950259]
	 */
	(*TNamespace)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FnamespacePtr)).FearlyDeleteProc = __ccgo_fp(_ObjectNamespaceDeleted)
	/*
	 * Fill in the rest of the non-zero/NULL parts of the structure.
	 */
	(*TObject)(unsafe.Pointer(oPtr)).FfPtr = fPtr
	(*TObject)(unsafe.Pointer(oPtr)).FcreationEpoch = libc.Int64FromUint64(creationEpoch)
	/*
	 * An object starts life with a refCount of 2 to mark the two stages of
	 * destruction it occur:  A call to ObjectRenamedTrace(), and a call to
	 * ObjectNamespaceDeleted().
	 */
	(*TObject)(unsafe.Pointer(oPtr)).FrefCount = int64(2)
	(*TObject)(unsafe.Pointer(oPtr)).Fflags = int32(USE_CLASS_CACHE)
	/*
	 * Finally, create the object commands and initialize the trace on the
	 * public command (so that the object structures are deleted when the
	 * command is deleted).
	 */
	if !(nameStr != 0) {
		nameStr = (*TTcl_Namespace)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FnamespacePtr)).Fname
		nsPtr = (*TObject)(unsafe.Pointer(oPtr)).FnamespacePtr
		if (*TNamespace)(unsafe.Pointer(nsPtr)).FparentPtr != libc.UintptrFromInt32(0) {
			nsPtr = (*TNamespace)(unsafe.Pointer(nsPtr)).FparentPtr
		}
	}
	(*TObject)(unsafe.Pointer(oPtr)).Fcommand = XTclCreateObjCommandInNs(tls, interp, nameStr, nsPtr, __ccgo_fp(XTclOOPublicObjectCmd), oPtr, libc.UintptrFromInt32(0))
	/*
	 * Add the NRE command and trace directly. While this breaks a number of
	 * abstractions, it is faster and we're inside Tcl here so we're allowed.
	 */
	cmdPtr = (*TObject)(unsafe.Pointer(oPtr)).Fcommand
	(*TCommand)(unsafe.Pointer(cmdPtr)).FnreProc = __ccgo_fp(_PublicNRObjectCmd)
	v5 = XTcl_Alloc(tls, uint64(40))
	tracePtr = v5
	(*TCommand)(unsafe.Pointer(cmdPtr)).FtracePtr = v5
	(*TCommandTrace)(unsafe.Pointer(tracePtr)).FtraceProc = __ccgo_fp(_ObjectRenamedTrace)
	(*TCommandTrace)(unsafe.Pointer(tracePtr)).FclientData = oPtr
	(*TCommandTrace)(unsafe.Pointer(tracePtr)).Fflags = libc.Int32FromInt32(TCL_TRACE_RENAME) | libc.Int32FromInt32(TCL_TRACE_DELETE)
	(*TCommandTrace)(unsafe.Pointer(tracePtr)).FnextPtr = libc.UintptrFromInt32(0)
	(*TCommandTrace)(unsafe.Pointer(tracePtr)).FrefCount = int64(1)
	(*TObject)(unsafe.Pointer(oPtr)).FmyCommand = XTclNRCreateCommandInNs(tls, interp, __ccgo_ts+87001, (*TObject)(unsafe.Pointer(oPtr)).FnamespacePtr, __ccgo_fp(XTclOOPrivateObjectCmd), __ccgo_fp(_PrivateNRObjectCmd), oPtr, __ccgo_fp(_MyDeleted))
	(*TObject)(unsafe.Pointer(oPtr)).FmyclassCommand = XTclNRCreateCommandInNs(tls, interp, __ccgo_ts+87244, (*TObject)(unsafe.Pointer(oPtr)).FnamespacePtr, __ccgo_fp(XTclOOMyClassObjCmd), __ccgo_fp(_MyClassNRObjCmd), oPtr, __ccgo_fp(_MyClassDeleted))
	return oPtr
}

/*
 * ----------------------------------------------------------------------
 *
 * SquelchCachedName --
 *
 *	Encapsulates how to throw away a cached object name. Called from
 *	object rename traces and at object destruction.
 *
 * ----------------------------------------------------------------------
 */

func _SquelchCachedName(tls *libc.TLS, oPtr uintptr) {
	var _objPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _ = _objPtr, v1, v2
	if (*TObject)(unsafe.Pointer(oPtr)).FcachedNameObj != 0 {
		_objPtr = (*TObject)(unsafe.Pointer(oPtr)).FcachedNameObj
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		(*TObject)(unsafe.Pointer(oPtr)).FcachedNameObj = libc.UintptrFromInt32(0)
	}
}

/*
 * ----------------------------------------------------------------------
 *
 * MyDeleted, MyClassDeleted --
 *
 *	These callbacks are triggered when the object's [my] or [myclass]
 *	commands are deleted by any mechanism. They just mark the object as
 *	not having a [my] command or [myclass] command, and so prevent cleanup
 *	of those commands when the object itself is deleted.
 *
 * ----------------------------------------------------------------------
 */

func _MyDeleted(tls *libc.TLS, clientData uintptr) {
	/* Reference to the object whose [my] has been
	 * squelched. */
	var oPtr uintptr
	_ = oPtr
	oPtr = clientData
	(*TObject)(unsafe.Pointer(oPtr)).FmyCommand = libc.UintptrFromInt32(0)
}

func _MyClassDeleted(tls *libc.TLS, clientData uintptr) {
	var oPtr uintptr
	_ = oPtr
	oPtr = clientData
	(*TObject)(unsafe.Pointer(oPtr)).FmyclassCommand = libc.UintptrFromInt32(0)
}

/*
 * ----------------------------------------------------------------------
 *
 * ObjectRenamedTrace --
 *
 *	This callback is triggered when the object is deleted by any
 *	mechanism. It runs the destructors and arranges for the actual cleanup
 *	of the object's namespace, which in turn triggers cleansing of the
 *	object data structures.
 *
 * ----------------------------------------------------------------------
 */

func _ObjectRenamedTrace(tls *libc.TLS, clientData uintptr, dummy870 uintptr, dummy871 uintptr, dummy872 uintptr, flags int32) {
	/* Why was the object deleted? */
	var oPtr uintptr
	_ = oPtr
	oPtr = clientData
	/*
	 * If this is a rename and not a delete of the object, we just flush the
	 * cache of the object name.
	 */
	if flags&int32(TCL_TRACE_RENAME) != 0 {
		_SquelchCachedName(tls, oPtr)
		return
	}
	/*
	 * The namespace is only deleted if it hasn't already been deleted. [Bug
	 * 2950259].
	 */
	if !((*TObject)(unsafe.Pointer(oPtr)).Fflags&int32(OBJECT_DESTRUCTING) != 0) {
		XTcl_DeleteNamespace(tls, (*TObject)(unsafe.Pointer(oPtr)).FnamespacePtr)
	}
	(*TObject)(unsafe.Pointer(oPtr)).Fcommand = libc.UintptrFromInt32(0)
	XTclOODecrRefCount(tls, oPtr)
	return
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOODeleteDescendants --
 *
 *	Delete all descendants of a particular class.
 *
 * ----------------------------------------------------------------------
 */

func XTclOODeleteDescendants(tls *libc.TLS, interp uintptr, oPtr uintptr) {
	/* The object representing the class. */
	var clsPtr, instancePtr, mixinSubclassPtr, subclassPtr uintptr
	_, _, _, _ = clsPtr, instancePtr, mixinSubclassPtr, subclassPtr
	clsPtr = (*TObject)(unsafe.Pointer(oPtr)).FclassPtr
	/*
	 * Squelch classes that this class has been mixed into.
	 */
	if (*TClass)(unsafe.Pointer(clsPtr)).FmixinSubs.Fnum > 0 {
		for (*TClass)(unsafe.Pointer(clsPtr)).FmixinSubs.Fnum > 0 {
			mixinSubclassPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).FmixinSubs.Flist + uintptr((*TClass)(unsafe.Pointer(clsPtr)).FmixinSubs.Fnum-int64(1))*8))
			/*
			 * This condition also covers the case where mixinSubclassPtr ==
			 * clsPtr
			 */
			if !((*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(mixinSubclassPtr)).FthisPtr)).Fflags&int32(OBJECT_DESTRUCTING) != 0) && !((*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(mixinSubclassPtr)).FthisPtr)).Fflags&int32(DONT_DELETE) != 0) {
				XTcl_DeleteCommandFromToken(tls, interp, (*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(mixinSubclassPtr)).FthisPtr)).Fcommand)
			}
			XTclOORemoveFromMixinSubs(tls, mixinSubclassPtr, clsPtr)
		}
	}
	if (*TClass)(unsafe.Pointer(clsPtr)).FmixinSubs.Fsize > 0 {
		XTclpFree(tls, (*TClass)(unsafe.Pointer(clsPtr)).FmixinSubs.Flist)
		(*TClass)(unsafe.Pointer(clsPtr)).FmixinSubs.Fsize = 0
	}
	/*
	 * Squelch subclasses of this class.
	 */
	if (*TClass)(unsafe.Pointer(clsPtr)).Fsubclasses.Fnum > 0 {
		for (*TClass)(unsafe.Pointer(clsPtr)).Fsubclasses.Fnum > 0 {
			subclassPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fsubclasses.Flist + uintptr((*TClass)(unsafe.Pointer(clsPtr)).Fsubclasses.Fnum-int64(1))*8))
			if !((*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(subclassPtr)).FthisPtr)).Fflags&int32(OBJECT_DESTRUCTING) != 0) && !((*TClass)(unsafe.Pointer(subclassPtr)).Fflags&(int32(ROOT_OBJECT)|int32(ROOT_CLASS)) != 0) && !((*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(subclassPtr)).FthisPtr)).Fflags&int32(DONT_DELETE) != 0) {
				XTcl_DeleteCommandFromToken(tls, interp, (*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(subclassPtr)).FthisPtr)).Fcommand)
			}
			XTclOORemoveFromSubclasses(tls, subclassPtr, clsPtr)
		}
	}
	if (*TClass)(unsafe.Pointer(clsPtr)).Fsubclasses.Fsize > 0 {
		XTclpFree(tls, (*TClass)(unsafe.Pointer(clsPtr)).Fsubclasses.Flist)
		(*TClass)(unsafe.Pointer(clsPtr)).Fsubclasses.Flist = libc.UintptrFromInt32(0)
		(*TClass)(unsafe.Pointer(clsPtr)).Fsubclasses.Fsize = 0
	}
	/*
	 * Squelch instances of this class (includes objects we're mixed into).
	 */
	if (*TClass)(unsafe.Pointer(clsPtr)).Finstances.Fnum > 0 {
		for (*TClass)(unsafe.Pointer(clsPtr)).Finstances.Fnum > 0 {
			instancePtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Finstances.Flist + uintptr((*TClass)(unsafe.Pointer(clsPtr)).Finstances.Fnum-int64(1))*8))
			/*
			 * This condition also covers the case where instancePtr == oPtr
			 */
			if !((*TObject)(unsafe.Pointer(instancePtr)).Fflags&int32(OBJECT_DESTRUCTING) != 0) && !((*TObject)(unsafe.Pointer(instancePtr)).Fflags&(int32(ROOT_OBJECT)|int32(ROOT_CLASS)) != 0) && !((*TObject)(unsafe.Pointer(instancePtr)).Fflags&int32(DONT_DELETE) != 0) {
				XTcl_DeleteCommandFromToken(tls, interp, (*TObject)(unsafe.Pointer(instancePtr)).Fcommand)
			}
			XTclOORemoveFromInstances(tls, instancePtr, clsPtr)
		}
	}
	if (*TClass)(unsafe.Pointer(clsPtr)).Finstances.Fsize > 0 {
		XTclpFree(tls, (*TClass)(unsafe.Pointer(clsPtr)).Finstances.Flist)
		(*TClass)(unsafe.Pointer(clsPtr)).Finstances.Flist = libc.UintptrFromInt32(0)
		(*TClass)(unsafe.Pointer(clsPtr)).Finstances.Fsize = 0
	}
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOReleaseClassContents --
 *
 *	Tear down the special class data structure, including deleting all
 *	dependent classes and objects.
 *
 * ----------------------------------------------------------------------
 */

func XTclOOReleaseClassContents(tls *libc.TLS, interp uintptr, oPtr uintptr) {
	bp := tls.Alloc(80)
	defer tls.Free(80) /* The object representing the class. */
	var _objPtr, _objPtr1, cachePtr, cachePtr1, cachePtr2, cachePtr3, clsPtr, fPtr, filterObj, hPtr, privateVariable, tmpClsPtr, variableObj, v13, v2, v20, v24, v27, v4, v9 uintptr
	var i, v1, v19, v23, v26, v3, v8 TTcl_Size
	var v10, v21, v25, v28 bool
	var v12, v17, v6 int32
	var _ /* callPtr at bp+32 */ uintptr
	var _ /* mPtr at bp+24 */ uintptr
	var _ /* metadataTypePtr at bp+40 */ uintptr
	var _ /* search at bp+0 */ TTcl_HashSearch
	var _ /* value at bp+48 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, cachePtr1, cachePtr2, cachePtr3, clsPtr, fPtr, filterObj, hPtr, i, privateVariable, tmpClsPtr, variableObj, v1, v10, v12, v13, v17, v19, v2, v20, v21, v23, v24, v25, v26, v27, v28, v3, v4, v6, v8, v9
	clsPtr = (*TObject)(unsafe.Pointer(oPtr)).FclassPtr
	fPtr = (*TObject)(unsafe.Pointer(oPtr)).FfPtr
	/*
	 * Sanity check!
	 */
	if !((*TObject)(unsafe.Pointer(oPtr)).Fflags&int32(OBJECT_DESTRUCTING) != 0) {
		if (*TObject)(unsafe.Pointer(oPtr)).Fflags&int32(ROOT_CLASS) != 0 {
			XTcl_Panic(tls, __ccgo_ts+87252, libc.VaList(bp+64, __ccgo_ts+87296))
		} else {
			if (*TObject)(unsafe.Pointer(oPtr)).Fflags&int32(ROOT_OBJECT) != 0 {
				XTcl_Panic(tls, __ccgo_ts+87252, libc.VaList(bp+64, __ccgo_ts+87308))
			}
		}
	}
	/*
	 * Stop using the class for definition information.
	 */
	if (*TClass)(unsafe.Pointer(clsPtr)).FclsDefinitionNs != 0 {
		_objPtr = (*TClass)(unsafe.Pointer(clsPtr)).FclsDefinitionNs
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		(*TClass)(unsafe.Pointer(clsPtr)).FclsDefinitionNs = libc.UintptrFromInt32(0)
	}
	if (*TClass)(unsafe.Pointer(clsPtr)).FobjDefinitionNs != 0 {
		_objPtr1 = (*TClass)(unsafe.Pointer(clsPtr)).FobjDefinitionNs
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		(*TClass)(unsafe.Pointer(clsPtr)).FobjDefinitionNs = libc.UintptrFromInt32(0)
	}
	/*
	 * Squelch method implementation chain caches.
	 */
	if (*TClass)(unsafe.Pointer(clsPtr)).FconstructorChainPtr != 0 {
		XTclOODeleteChain(tls, (*TClass)(unsafe.Pointer(clsPtr)).FconstructorChainPtr)
		(*TClass)(unsafe.Pointer(clsPtr)).FconstructorChainPtr = libc.UintptrFromInt32(0)
	}
	if (*TClass)(unsafe.Pointer(clsPtr)).FdestructorChainPtr != 0 {
		XTclOODeleteChain(tls, (*TClass)(unsafe.Pointer(clsPtr)).FdestructorChainPtr)
		(*TClass)(unsafe.Pointer(clsPtr)).FdestructorChainPtr = libc.UintptrFromInt32(0)
	}
	if (*TClass)(unsafe.Pointer(clsPtr)).FclassChainCache != 0 {
		hPtr = XTcl_FirstHashEntry(tls, (*TClass)(unsafe.Pointer(clsPtr)).FclassChainCache, bp)
		for {
			if hPtr != libc.UintptrFromInt32(0) {
				*(*uintptr)(unsafe.Pointer(bp + 32)) = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
				v6 = libc.Int32FromInt32(1)
			} else {
				v6 = 0
			}
			if !(v6 != 0) {
				break
			}
			XTclOODeleteChain(tls, *(*uintptr)(unsafe.Pointer(bp + 32)))
			goto _5
		_5:
			;
			hPtr = XTcl_NextHashEntry(tls, bp)
		}
		XTcl_DeleteHashTable(tls, (*TClass)(unsafe.Pointer(clsPtr)).FclassChainCache)
		XTclpFree(tls, (*TClass)(unsafe.Pointer(clsPtr)).FclassChainCache)
		(*TClass)(unsafe.Pointer(clsPtr)).FclassChainCache = libc.UintptrFromInt32(0)
	}
	/*
	 * Squelch the property lists.
	 */
	XTclOOReleasePropertyStorage(tls, clsPtr+336)
	/*
	 * Squelch our filter list.
	 */
	if (*TClass)(unsafe.Pointer(clsPtr)).Ffilters.Fnum != 0 {
		i = 0
		for {
			if !(i < (*TClass)(unsafe.Pointer(clsPtr)).Ffilters.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Ffilters.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _7
			} else {
				filterObj = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Ffilters.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					v9 = filterObj
					v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
					*(*TTcl_Size)(unsafe.Pointer(v9))--
					if !(v8 > int64(1)) {
						if !((*TTcl_Obj)(unsafe.Pointer(filterObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(filterObj)).FtypePtr)).FfreeIntRepProc != 0) {
							if (*TTcl_Obj)(unsafe.Pointer(filterObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(filterObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
								XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(filterObj)).Fbytes)
							}
							(*TTcl_Obj)(unsafe.Pointer(filterObj)).Flength = int64(-libc.Int32FromInt32(1))
							if v10 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v10 {
								cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
							}
							if v10 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
								XTclThreadFreeObj(tls, filterObj)
							} else {
								(*(*struct {
									Fptr1 uintptr
									Fptr2 uintptr
								})(unsafe.Pointer(filterObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
								(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = filterObj
								(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
							}
						} else {
							XTclFreeObj(tls, filterObj)
						}
					}
				}
			}
			goto _7
		_7:
			;
			i++
		}
		XTclpFree(tls, (*TClass)(unsafe.Pointer(clsPtr)).Ffilters.Flist)
		(*TClass)(unsafe.Pointer(clsPtr)).Ffilters.Flist = libc.UintptrFromInt32(0)
		(*TClass)(unsafe.Pointer(clsPtr)).Ffilters.Fnum = 0
	}
	/*
	 * Squelch our metadata.
	 */
	if (*TClass)(unsafe.Pointer(clsPtr)).FmetadataPtr != libc.UintptrFromInt32(0) {
		hPtr = XTcl_FirstHashEntry(tls, (*TClass)(unsafe.Pointer(clsPtr)).FmetadataPtr, bp)
		for {
			if hPtr != libc.UintptrFromInt32(0) {
				if (*TTcl_HashTable)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).FmetadataPtr)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).FmetadataPtr)).FkeyType == -int32(1) {
					v13 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
				} else {
					v13 = hPtr + 32
				}
				*(*uintptr)(unsafe.Pointer(bp + 40)) = v13
				*(*uintptr)(unsafe.Pointer(bp + 48)) = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
				v12 = libc.Int32FromInt32(1)
			} else {
				v12 = 0
			}
			if !(v12 != 0) {
				break
			}
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjectMetadataType)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).FdeleteProc})))(tls, *(*uintptr)(unsafe.Pointer(bp + 48)))
			goto _11
		_11:
			;
			hPtr = XTcl_NextHashEntry(tls, bp)
		}
		XTcl_DeleteHashTable(tls, (*TClass)(unsafe.Pointer(clsPtr)).FmetadataPtr)
		XTclpFree(tls, (*TClass)(unsafe.Pointer(clsPtr)).FmetadataPtr)
		(*TClass)(unsafe.Pointer(clsPtr)).FmetadataPtr = libc.UintptrFromInt32(0)
	}
	if (*TClass)(unsafe.Pointer(clsPtr)).Fmixins.Fnum != 0 {
		i = 0
		for {
			if !(i < (*TClass)(unsafe.Pointer(clsPtr)).Fmixins.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _14
			} else {
				tmpClsPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fmixins.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					XTclOORemoveFromMixinSubs(tls, clsPtr, tmpClsPtr)
					XTclOODecrRefCount(tls, (*TClass)(unsafe.Pointer(tmpClsPtr)).FthisPtr)
				}
			}
			goto _14
		_14:
			;
			i++
		}
		XTclpFree(tls, (*TClass)(unsafe.Pointer(clsPtr)).Fmixins.Flist)
		(*TClass)(unsafe.Pointer(clsPtr)).Fmixins.Flist = libc.UintptrFromInt32(0)
		(*TClass)(unsafe.Pointer(clsPtr)).Fmixins.Fnum = 0
	}
	if (*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Fnum > 0 {
		i = 0
		for {
			if !(i < (*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _15
			} else {
				tmpClsPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					XTclOORemoveFromSubclasses(tls, clsPtr, tmpClsPtr)
					XTclOODecrRefCount(tls, (*TClass)(unsafe.Pointer(tmpClsPtr)).FthisPtr)
				}
			}
			goto _15
		_15:
			;
			i++
		}
		XTclpFree(tls, (*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Flist)
		(*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Fnum = 0
		(*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Flist = libc.UintptrFromInt32(0)
	}
	hPtr = XTcl_FirstHashEntry(tls, clsPtr+136, bp)
	for {
		if hPtr != libc.UintptrFromInt32(0) {
			*(*uintptr)(unsafe.Pointer(bp + 24)) = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
			v17 = libc.Int32FromInt32(1)
		} else {
			v17 = 0
		}
		if !(v17 != 0) {
			break
		}
		/* instance gets deleted, so if method remains, reset it there */
		if (*TMethod)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).FrefCount > int64(1) && (*TMethod)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).FdeclaringClassPtr == clsPtr {
			(*TMethod)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).FdeclaringClassPtr = libc.UintptrFromInt32(0)
		}
		XTclOODelMethodRef(tls, *(*uintptr)(unsafe.Pointer(bp + 24)))
		goto _16
	_16:
		;
		hPtr = XTcl_NextHashEntry(tls, bp)
	}
	XTcl_DeleteHashTable(tls, clsPtr+136)
	XTclOODelMethodRef(tls, (*TClass)(unsafe.Pointer(clsPtr)).FconstructorPtr)
	XTclOODelMethodRef(tls, (*TClass)(unsafe.Pointer(clsPtr)).FdestructorPtr)
	i = 0
	for {
		if !(i < (*TClass)(unsafe.Pointer(clsPtr)).Fvariables.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fvariables.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _18
		} else {
			variableObj = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fvariables.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				v20 = variableObj
				v19 = *(*TTcl_Size)(unsafe.Pointer(v20))
				*(*TTcl_Size)(unsafe.Pointer(v20))--
				if !(v19 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(variableObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(variableObj)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(variableObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(variableObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(variableObj)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(variableObj)).Flength = int64(-libc.Int32FromInt32(1))
						if v21 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v21 {
							cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v21 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, variableObj)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(variableObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = variableObj
							(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, variableObj)
					}
				}
			}
		}
		goto _18
	_18:
		;
		i++
	}
	if i != 0 {
		XTclpFree(tls, (*TClass)(unsafe.Pointer(clsPtr)).Fvariables.Flist)
	}
	i = 0
	if (*TClass)(unsafe.Pointer(clsPtr)).FprivateVariables.Fnum > libc.Int64FromInt32(0) {
		for {
			privateVariable = (*TClass)(unsafe.Pointer(clsPtr)).FprivateVariables.Flist + uintptr(i)*16
			if !(i < (*TClass)(unsafe.Pointer(clsPtr)).FprivateVariables.Fnum) {
				break
			}
			v24 = (*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FvariableObj
			v23 = *(*TTcl_Size)(unsafe.Pointer(v24))
			*(*TTcl_Size)(unsafe.Pointer(v24))--
			if !(v23 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FvariableObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FvariableObj)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FvariableObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FvariableObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FvariableObj)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FvariableObj)).Flength = int64(-libc.Int32FromInt32(1))
					if v25 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v25 {
						cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v25 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, (*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FvariableObj)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FvariableObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FvariableObj
						(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, (*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FvariableObj)
				}
			}
			v27 = (*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FfullNameObj
			v26 = *(*TTcl_Size)(unsafe.Pointer(v27))
			*(*TTcl_Size)(unsafe.Pointer(v27))--
			if !(v26 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FfullNameObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FfullNameObj)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FfullNameObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FfullNameObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FfullNameObj)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FfullNameObj)).Flength = int64(-libc.Int32FromInt32(1))
					if v28 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v28 {
						cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v28 || ((*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, (*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FfullNameObj)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FfullNameObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FfullNameObj
						(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, (*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FfullNameObj)
				}
			}
			goto _22
		_22:
			;
			i++
		}
	}
	if i != 0 {
		XTclpFree(tls, (*TClass)(unsafe.Pointer(clsPtr)).FprivateVariables.Flist)
	}
	if (*TObject)(unsafe.Pointer(oPtr)).Fflags&int32(ROOT_CLASS) != 0 && !((*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FobjectCls)).FthisPtr)).Fflags&int32(OBJECT_DESTRUCTING) != 0) {
		XTcl_DeleteCommandFromToken(tls, interp, (*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FobjectCls)).FthisPtr)).Fcommand)
	}
}

/*
 * ----------------------------------------------------------------------
 *
 * ObjectNamespaceDeleted --
 *
 *	Callback when the object's namespace is deleted. Used to clean up the
 *	data structures associated with the object. The complicated bit is
 *	that this can sometimes happen before the object's command is deleted
 *	(interpreter teardown is complex!)
 *
 * ----------------------------------------------------------------------
 */

func _ObjectNamespaceDeleted(tls *libc.TLS, clientData uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Pointer to the class whose namespace is
	 * being deleted. */
	var cachePtr, cachePtr1, cachePtr2, cachePtr3, contextPtr, fPtr, filterObj, hPtr, interp, mixinPtr, oPtr, privateVariable, variableObj, v10, v14, v17, v21, v4 uintptr
	var i, v13, v16, v3, v9 TTcl_Size
	var result, v20, v7 int32
	var state TTcl_InterpState
	var v11, v15, v18, v5 bool
	var _ /* mPtr at bp+24 */ uintptr
	var _ /* metadataTypePtr at bp+32 */ uintptr
	var _ /* search at bp+0 */ TTcl_HashSearch
	var _ /* value at bp+40 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, cachePtr3, contextPtr, fPtr, filterObj, hPtr, i, interp, mixinPtr, oPtr, privateVariable, result, state, variableObj, v10, v11, v13, v14, v15, v16, v17, v18, v20, v21, v3, v4, v5, v7, v9
	oPtr = clientData
	fPtr = (*TObject)(unsafe.Pointer(oPtr)).FfPtr
	interp = (*TFoundation)(unsafe.Pointer(fPtr)).Finterp
	if (*TObject)(unsafe.Pointer(oPtr)).Fflags&int32(OBJECT_DESTRUCTING) != 0 {
		/*
		 * TODO:  Can ObjectNamespaceDeleted ever be called twice?  If not,
		 * this guard could be removed.
		 */
		return
	}
	/*
	 * One rule for the teardown routines is that if an object is in the
	 * process of being deleted, nothing else may modify its bookkeeping
	 * records.  This is the flag that
	 */
	*(*int32)(unsafe.Pointer(oPtr + 96)) |= int32(OBJECT_DESTRUCTING)
	/*
	 * Let the dominoes fall!
	 */
	if (*TObject)(unsafe.Pointer(oPtr)).FclassPtr != 0 {
		XTclOODeleteDescendants(tls, interp, oPtr)
	}
	/*
	 * We do not run destructors on the core class objects when the
	 * interpreter is being deleted; their incestuous nature causes problems
	 * in that case when the destructor is partially deleted before the uses
	 * of it have gone. [Bug 2949397]
	 */
	if !(XTcl_InterpDeleted(tls, interp) != 0) && !((*TObject)(unsafe.Pointer(oPtr)).Fflags&int32(DESTRUCTOR_CALLED) != 0) {
		contextPtr = XTclOOGetCallContext(tls, oPtr, libc.UintptrFromInt32(0), int32(DESTRUCTOR), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
		*(*int32)(unsafe.Pointer(oPtr + 96)) |= int32(DESTRUCTOR_CALLED)
		if contextPtr != libc.UintptrFromInt32(0) {
			*(*int32)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr + 24)) |= int32(DESTRUCTOR)
			(*TCallContext)(unsafe.Pointer(contextPtr)).Fskip = 0
			state = XTcl_SaveInterpState(tls, interp, TCL_OK)
			result = XTcl_NRCallObjProc(tls, interp, __ccgo_fp(XTclOOInvokeContext), contextPtr, 0, libc.UintptrFromInt32(0))
			if result != TCL_OK {
				XTcl_BackgroundException(tls, interp, result)
			}
			XTcl_RestoreInterpState(tls, interp, state)
			XTclOODeleteContext(tls, contextPtr)
		}
	}
	/*
	 * Instruct everyone to no longer use any allocated fields of the object.
	 * Also delete the command that refers to the object at this point (if it
	 * still exists) because otherwise its pointer to the object points into
	 * freed memory.
	 */
	if (*TCommand)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fcommand)).Fflags != 0 && libc.Bool(int32(CMD_DYING) != 0) {
		/*
		 * Something has already started the command deletion process. We can
		 * go ahead and clean up the namespace,
		 */
	} else {
		/*
		 * The namespace must have been deleted directly.  Delete the command
		 * as well.
		 */
		XTcl_DeleteCommandFromToken(tls, interp, (*TObject)(unsafe.Pointer(oPtr)).Fcommand)
	}
	if (*TObject)(unsafe.Pointer(oPtr)).FmyclassCommand != 0 {
		XTcl_DeleteCommandFromToken(tls, interp, (*TObject)(unsafe.Pointer(oPtr)).FmyclassCommand)
	}
	if (*TObject)(unsafe.Pointer(oPtr)).FmyCommand != 0 {
		XTcl_DeleteCommandFromToken(tls, interp, (*TObject)(unsafe.Pointer(oPtr)).FmyCommand)
	}
	/*
	 * Splice the object out of its context. After this, we must *not* call
	 * methods on the object.
	 */
	// TODO: Should this be protected with a !IsRoot() condition?
	XTclOORemoveFromInstances(tls, oPtr, (*TObject)(unsafe.Pointer(oPtr)).FselfCls)
	if (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Fnum > 0 {
		i = 0
		for {
			if !(i < (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _1
			} else {
				mixinPtr = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					XTclOORemoveFromInstances(tls, oPtr, mixinPtr)
					XTclOODecrRefCount(tls, (*TClass)(unsafe.Pointer(mixinPtr)).FthisPtr)
				}
			}
			goto _1
		_1:
			;
			i++
		}
		if (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist != libc.UintptrFromInt32(0) {
			XTclpFree(tls, (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist)
		}
	}
	i = 0
	for {
		if !(i < (*TObject)(unsafe.Pointer(oPtr)).Ffilters.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Ffilters.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _2
		} else {
			filterObj = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Ffilters.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				v4 = filterObj
				v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
				*(*TTcl_Size)(unsafe.Pointer(v4))--
				if !(v3 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(filterObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(filterObj)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(filterObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(filterObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(filterObj)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(filterObj)).Flength = int64(-libc.Int32FromInt32(1))
						if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
							cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v5 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, filterObj)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(filterObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = filterObj
							(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, filterObj)
					}
				}
			}
		}
		goto _2
	_2:
		;
		i++
	}
	if i != 0 {
		XTclpFree(tls, (*TObject)(unsafe.Pointer(oPtr)).Ffilters.Flist)
	}
	if (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr != 0 {
		hPtr = XTcl_FirstHashEntry(tls, (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr, bp)
		for {
			if hPtr != libc.UintptrFromInt32(0) {
				*(*uintptr)(unsafe.Pointer(bp + 24)) = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
				v7 = libc.Int32FromInt32(1)
			} else {
				v7 = 0
			}
			if !(v7 != 0) {
				break
			}
			/* instance gets deleted, so if method remains, reset it there */
			if (*TMethod)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).FrefCount > int64(1) && (*TMethod)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).FdeclaringObjectPtr == oPtr {
				(*TMethod)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).FdeclaringObjectPtr = libc.UintptrFromInt32(0)
			}
			XTclOODelMethodRef(tls, *(*uintptr)(unsafe.Pointer(bp + 24)))
			goto _6
		_6:
			;
			hPtr = XTcl_NextHashEntry(tls, bp)
		}
		XTcl_DeleteHashTable(tls, (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr)
		XTclpFree(tls, (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr)
	}
	i = 0
	for {
		if !(i < (*TObject)(unsafe.Pointer(oPtr)).Fvariables.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fvariables.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _8
		} else {
			variableObj = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fvariables.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				v10 = variableObj
				v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
				*(*TTcl_Size)(unsafe.Pointer(v10))--
				if !(v9 > int64(1)) {
					if !((*TTcl_Obj)(unsafe.Pointer(variableObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(variableObj)).FtypePtr)).FfreeIntRepProc != 0) {
						if (*TTcl_Obj)(unsafe.Pointer(variableObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(variableObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
							XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(variableObj)).Fbytes)
						}
						(*TTcl_Obj)(unsafe.Pointer(variableObj)).Flength = int64(-libc.Int32FromInt32(1))
						if v11 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v11 {
							cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
						}
						if v11 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
							XTclThreadFreeObj(tls, variableObj)
						} else {
							(*(*struct {
								Fptr1 uintptr
								Fptr2 uintptr
							})(unsafe.Pointer(variableObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
							(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = variableObj
							(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
						}
					} else {
						XTclFreeObj(tls, variableObj)
					}
				}
			}
		}
		goto _8
	_8:
		;
		i++
	}
	if i != 0 {
		XTclpFree(tls, (*TObject)(unsafe.Pointer(oPtr)).Fvariables.Flist)
	}
	i = 0
	if (*TObject)(unsafe.Pointer(oPtr)).FprivateVariables.Fnum > libc.Int64FromInt32(0) {
		for {
			privateVariable = (*TObject)(unsafe.Pointer(oPtr)).FprivateVariables.Flist + uintptr(i)*16
			if !(i < (*TObject)(unsafe.Pointer(oPtr)).FprivateVariables.Fnum) {
				break
			}
			v14 = (*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FvariableObj
			v13 = *(*TTcl_Size)(unsafe.Pointer(v14))
			*(*TTcl_Size)(unsafe.Pointer(v14))--
			if !(v13 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FvariableObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FvariableObj)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FvariableObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FvariableObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FvariableObj)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FvariableObj)).Flength = int64(-libc.Int32FromInt32(1))
					if v15 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v15 {
						cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v15 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, (*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FvariableObj)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FvariableObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FvariableObj
						(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, (*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FvariableObj)
				}
			}
			v17 = (*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FfullNameObj
			v16 = *(*TTcl_Size)(unsafe.Pointer(v17))
			*(*TTcl_Size)(unsafe.Pointer(v17))--
			if !(v16 > int64(1)) {
				if !((*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FfullNameObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FfullNameObj)).FtypePtr)).FfreeIntRepProc != 0) {
					if (*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FfullNameObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FfullNameObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
						XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FfullNameObj)).Fbytes)
					}
					(*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FfullNameObj)).Flength = int64(-libc.Int32FromInt32(1))
					if v18 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v18 {
						cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
					}
					if v18 || ((*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
						XTclThreadFreeObj(tls, (*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FfullNameObj)
					} else {
						(*(*struct {
							Fptr1 uintptr
							Fptr2 uintptr
						})(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FfullNameObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
						(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FfullNameObj
						(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects++
					}
				} else {
					XTclFreeObj(tls, (*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FfullNameObj)
				}
			}
			goto _12
		_12:
			;
			i++
		}
	}
	if i != 0 {
		XTclpFree(tls, (*TObject)(unsafe.Pointer(oPtr)).FprivateVariables.Flist)
	}
	if (*TObject)(unsafe.Pointer(oPtr)).FchainCache != 0 {
		XTclOODeleteChainCache(tls, (*TObject)(unsafe.Pointer(oPtr)).FchainCache)
	}
	_SquelchCachedName(tls, oPtr)
	if (*TObject)(unsafe.Pointer(oPtr)).FmetadataPtr != libc.UintptrFromInt32(0) {
		hPtr = XTcl_FirstHashEntry(tls, (*TObject)(unsafe.Pointer(oPtr)).FmetadataPtr, bp)
		for {
			if hPtr != libc.UintptrFromInt32(0) {
				if (*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FmetadataPtr)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FmetadataPtr)).FkeyType == -int32(1) {
					v21 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
				} else {
					v21 = hPtr + 32
				}
				*(*uintptr)(unsafe.Pointer(bp + 32)) = v21
				*(*uintptr)(unsafe.Pointer(bp + 40)) = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
				v20 = libc.Int32FromInt32(1)
			} else {
				v20 = 0
			}
			if !(v20 != 0) {
				break
			}
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjectMetadataType)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))).FdeleteProc})))(tls, *(*uintptr)(unsafe.Pointer(bp + 40)))
			goto _19
		_19:
			;
			hPtr = XTcl_NextHashEntry(tls, bp)
		}
		XTcl_DeleteHashTable(tls, (*TObject)(unsafe.Pointer(oPtr)).FmetadataPtr)
		XTclpFree(tls, (*TObject)(unsafe.Pointer(oPtr)).FmetadataPtr)
		(*TObject)(unsafe.Pointer(oPtr)).FmetadataPtr = libc.UintptrFromInt32(0)
	}
	/*
	 * Squelch the property lists.
	 */
	XTclOOReleasePropertyStorage(tls, oPtr+192)
	/*
	 * Because an object can be a class that is an instance of itself, the
	 * class object's class structure should only be cleaned after most of
	 * the cleanup on the object is done.
	 *
	 * The class of objects needs some special care; if it is deleted (and
	 * we're not killing the whole interpreter) we force the delete of the
	 * class of classes now as well. Due to the incestuous nature of those two
	 * classes, if one goes the other must too and yet the tangle can
	 * sometimes not go away automatically; we force it here. [Bug 2962664]
	 */
	if (*TObject)(unsafe.Pointer(oPtr)).Fflags&int32(ROOT_OBJECT) != 0 && !((*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclassCls)).FthisPtr)).Fflags&int32(OBJECT_DESTRUCTING) != 0) && !(XTcl_InterpDeleted(tls, interp) != 0) {
		XTcl_DeleteCommandFromToken(tls, interp, (*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FclassCls)).FthisPtr)).Fcommand)
	}
	if (*TObject)(unsafe.Pointer(oPtr)).FclassPtr != libc.UintptrFromInt32(0) {
		XTclOOReleaseClassContents(tls, interp, oPtr)
	}
	/*
	 * Delete the object structure itself.
	 */
	XTclNsDecrRefCount(tls, (*TObject)(unsafe.Pointer(oPtr)).FnamespacePtr)
	(*TObject)(unsafe.Pointer(oPtr)).FnamespacePtr = libc.UintptrFromInt32(0)
	XTclOODecrRefCount(tls, (*TClass)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FselfCls)).FthisPtr)
	(*TObject)(unsafe.Pointer(oPtr)).FselfCls = libc.UintptrFromInt32(0)
	XTclOODecrRefCount(tls, oPtr)
	return
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOODecrRefCount --
 *
 *	Decrement the refcount of an object and deallocate storage then object
 *	is no longer referenced.  Returns 1 if storage was deallocated, and 0
 *	otherwise.
 *
 * ----------------------------------------------------------------------
 */

func XTclOODecrRefCount(tls *libc.TLS, oPtr uintptr) (r int32) {
	var v1 TTcl_Size
	var v2 uintptr
	_, _ = v1, v2
	v2 = oPtr + 88
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		if (*TObject)(unsafe.Pointer(oPtr)).FclassPtr != libc.UintptrFromInt32(0) {
			XTclpFree(tls, (*TObject)(unsafe.Pointer(oPtr)).FclassPtr)
		}
		XTclpFree(tls, oPtr)
		return int32(1)
	}
	return 0
}

// C documentation
//
//	/*
//	 * ----------------------------------------------------------------------
//	 *
//	 * TclOOObjectDestroyed --
//	 *
//	 *	Returns TCL_OK if an object is entirely deleted, i.e. the destruction
//	 *	sequence has completed.
//	 *
//	 * ----------------------------------------------------------------------
//	 */
func XTclOOObjectDestroyed(tls *libc.TLS, oPtr uintptr) (r int32) {
	return libc.BoolInt32((*TObject)(unsafe.Pointer(oPtr)).FnamespacePtr == libc.UintptrFromInt32(0))
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOORemoveFromInstances --
 *
 *	Utility function to remove an object from the list of instances within
 *	a class.
 *
 * ----------------------------------------------------------------------
 */

func XTclOORemoveFromInstances(tls *libc.TLS, oPtr uintptr, clsPtr uintptr) (r int32) {
	/* The class (possibly) containing the
	 * reference to the instance. */
	var i TTcl_Size
	var instPtr uintptr
	var res int32
	_, _, _ = i, instPtr, res
	res = 0
	i = 0
	for {
		if !(i < (*TClass)(unsafe.Pointer(clsPtr)).Finstances.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Finstances.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _1
		} else {
			instPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Finstances.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				if oPtr == instPtr {
					_RemoveObject(tls, (*TClass)(unsafe.Pointer(clsPtr)).Finstances.Flist, libc.Uint64FromInt64((*TClass)(unsafe.Pointer(clsPtr)).Finstances.Fnum), libc.Uint64FromInt64(i))
					(*TClass)(unsafe.Pointer(clsPtr)).Finstances.Fnum--
					XTclOODecrRefCount(tls, oPtr)
					res++
					break
				}
			}
		}
		goto _1
	_1:
		;
		i++
	}
	return res
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOAddToInstances --
 *
 *	Utility function to add an object to the list of instances within a
 *	class.
 *
 * ----------------------------------------------------------------------
 */

func XTclOOAddToInstances(tls *libc.TLS, oPtr uintptr, clsPtr uintptr) {
	/* The class to add the instance to. It is
	 * assumed that the class is not already
	 * present as an instance in the class. */
	var v1 TTcl_Size
	var v2 uintptr
	_, _ = v1, v2
	if (*TClass)(unsafe.Pointer(clsPtr)).Finstances.Fnum >= (*TClass)(unsafe.Pointer(clsPtr)).Finstances.Fsize {
		(*TClass)(unsafe.Pointer(clsPtr)).Finstances.Fsize += int64(ALLOC_CHUNK)
		if (*TClass)(unsafe.Pointer(clsPtr)).Finstances.Fsize == int64(ALLOC_CHUNK) {
			(*TClass)(unsafe.Pointer(clsPtr)).Finstances.Flist = XTcl_Alloc(tls, libc.Uint64FromInt64(8)*libc.Uint64FromInt32(ALLOC_CHUNK))
		} else {
			(*TClass)(unsafe.Pointer(clsPtr)).Finstances.Flist = XTcl_Realloc(tls, (*TClass)(unsafe.Pointer(clsPtr)).Finstances.Flist, uint64(8)*libc.Uint64FromInt64((*TClass)(unsafe.Pointer(clsPtr)).Finstances.Fsize))
		}
	}
	v2 = clsPtr + 56
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))++
	*(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Finstances.Flist + uintptr(v1)*8)) = oPtr
	(*TObject)(unsafe.Pointer(oPtr)).FrefCount++
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOORemoveFromMixins --
 *
 *	Utility function to remove a class from the list of mixins within an
 *	object.
 *
 * ----------------------------------------------------------------------
 */

func XTclOORemoveFromMixins(tls *libc.TLS, mixinPtr uintptr, oPtr uintptr) (r int32) {
	/* The object (possibly) containing the
	 * reference to the mixin. */
	var i TTcl_Size
	var mixPtr uintptr
	var res int32
	_, _, _ = i, mixPtr, res
	res = 0
	i = 0
	for {
		if !(i < (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _1
		} else {
			mixPtr = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				if mixinPtr == mixPtr {
					_RemoveClass(tls, (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist, libc.Uint64FromInt64((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Fnum), libc.Uint64FromInt64(i))
					(*TObject)(unsafe.Pointer(oPtr)).Fmixins.Fnum--
					XTclOODecrRefCount(tls, (*TClass)(unsafe.Pointer(mixPtr)).FthisPtr)
					res++
					break
				}
			}
		}
		goto _1
	_1:
		;
		i++
	}
	if (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Fnum == 0 {
		XTclpFree(tls, (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist)
		(*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist = libc.UintptrFromInt32(0)
	}
	return res
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOORemoveFromSubclasses --
 *
 *	Utility function to remove a class from the list of subclasses within
 *	another class. Returns the number of removals performed.
 *
 * ----------------------------------------------------------------------
 */

func XTclOORemoveFromSubclasses(tls *libc.TLS, subPtr uintptr, superPtr uintptr) (r int32) {
	/* The superclass to possibly remove the
	 * subclass reference from. */
	var i TTcl_Size
	var res int32
	var subclsPtr uintptr
	_, _, _ = i, res, subclsPtr
	res = 0
	i = 0
	for {
		if !(i < (*TClass)(unsafe.Pointer(superPtr)).Fsubclasses.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(superPtr)).Fsubclasses.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _1
		} else {
			subclsPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(superPtr)).Fsubclasses.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				if subPtr == subclsPtr {
					_RemoveClass(tls, (*TClass)(unsafe.Pointer(superPtr)).Fsubclasses.Flist, libc.Uint64FromInt64((*TClass)(unsafe.Pointer(superPtr)).Fsubclasses.Fnum), libc.Uint64FromInt64(i))
					(*TClass)(unsafe.Pointer(superPtr)).Fsubclasses.Fnum--
					XTclOODecrRefCount(tls, (*TClass)(unsafe.Pointer(subPtr)).FthisPtr)
					res++
				}
			}
		}
		goto _1
	_1:
		;
		i++
	}
	return res
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOAddToSubclasses --
 *
 *	Utility function to add a class to the list of subclasses within
 *	another class.
 *
 * ----------------------------------------------------------------------
 */

func XTclOOAddToSubclasses(tls *libc.TLS, subPtr uintptr, superPtr uintptr) {
	/* The superclass to add the subclass to. It
	 * is assumed that the class is not already
	 * present as a subclass in the superclass. */
	var v1 TTcl_Size
	var v2 uintptr
	_, _ = v1, v2
	if (*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(superPtr)).FthisPtr)).Fflags&int32(OBJECT_DESTRUCTING) != 0 {
		return
	}
	if (*TClass)(unsafe.Pointer(superPtr)).Fsubclasses.Fnum >= (*TClass)(unsafe.Pointer(superPtr)).Fsubclasses.Fsize {
		(*TClass)(unsafe.Pointer(superPtr)).Fsubclasses.Fsize += int64(ALLOC_CHUNK)
		if (*TClass)(unsafe.Pointer(superPtr)).Fsubclasses.Fsize == int64(ALLOC_CHUNK) {
			(*TClass)(unsafe.Pointer(superPtr)).Fsubclasses.Flist = XTcl_Alloc(tls, libc.Uint64FromInt64(8)*libc.Uint64FromInt32(ALLOC_CHUNK))
		} else {
			(*TClass)(unsafe.Pointer(superPtr)).Fsubclasses.Flist = XTcl_Realloc(tls, (*TClass)(unsafe.Pointer(superPtr)).Fsubclasses.Flist, uint64(8)*libc.Uint64FromInt64((*TClass)(unsafe.Pointer(superPtr)).Fsubclasses.Fsize))
		}
	}
	v2 = superPtr + 32
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))++
	*(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(superPtr)).Fsubclasses.Flist + uintptr(v1)*8)) = subPtr
	(*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(subPtr)).FthisPtr)).FrefCount++
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOORemoveFromMixinSubs --
 *
 *	Utility function to remove a class from the list of mixinSubs within
 *	another class.
 *
 * ----------------------------------------------------------------------
 */

func XTclOORemoveFromMixinSubs(tls *libc.TLS, subPtr uintptr, superPtr uintptr) (r int32) {
	/* The superclass to possibly remove the
	 * subclass reference from. */
	var i TTcl_Size
	var res int32
	var subclsPtr uintptr
	_, _, _ = i, res, subclsPtr
	res = 0
	i = 0
	for {
		if !(i < (*TClass)(unsafe.Pointer(superPtr)).FmixinSubs.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(superPtr)).FmixinSubs.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _1
		} else {
			subclsPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(superPtr)).FmixinSubs.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				if subPtr == subclsPtr {
					_RemoveClass(tls, (*TClass)(unsafe.Pointer(superPtr)).FmixinSubs.Flist, libc.Uint64FromInt64((*TClass)(unsafe.Pointer(superPtr)).FmixinSubs.Fnum), libc.Uint64FromInt64(i))
					(*TClass)(unsafe.Pointer(superPtr)).FmixinSubs.Fnum--
					XTclOODecrRefCount(tls, (*TClass)(unsafe.Pointer(subPtr)).FthisPtr)
					res++
					break
				}
			}
		}
		goto _1
	_1:
		;
		i++
	}
	return res
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOAddToMixinSubs --
 *
 *	Utility function to add a class to the list of mixinSubs within
 *	another class.
 *
 * ----------------------------------------------------------------------
 */

func XTclOOAddToMixinSubs(tls *libc.TLS, subPtr uintptr, superPtr uintptr) {
	/* The superclass to add the subclass to. It
	 * is assumed that the class is not already
	 * present as a subclass in the superclass. */
	var v1 TTcl_Size
	var v2 uintptr
	_, _ = v1, v2
	if (*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(superPtr)).FthisPtr)).Fflags&int32(OBJECT_DESTRUCTING) != 0 {
		return
	}
	if (*TClass)(unsafe.Pointer(superPtr)).FmixinSubs.Fnum >= (*TClass)(unsafe.Pointer(superPtr)).FmixinSubs.Fsize {
		(*TClass)(unsafe.Pointer(superPtr)).FmixinSubs.Fsize += int64(ALLOC_CHUNK)
		if (*TClass)(unsafe.Pointer(superPtr)).FmixinSubs.Fsize == int64(ALLOC_CHUNK) {
			(*TClass)(unsafe.Pointer(superPtr)).FmixinSubs.Flist = XTcl_Alloc(tls, libc.Uint64FromInt64(8)*libc.Uint64FromInt32(ALLOC_CHUNK))
		} else {
			(*TClass)(unsafe.Pointer(superPtr)).FmixinSubs.Flist = XTcl_Realloc(tls, (*TClass)(unsafe.Pointer(superPtr)).FmixinSubs.Flist, uint64(8)*libc.Uint64FromInt64((*TClass)(unsafe.Pointer(superPtr)).FmixinSubs.Fsize))
		}
	}
	v2 = superPtr + 112
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))++
	*(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(superPtr)).FmixinSubs.Flist + uintptr(v1)*8)) = subPtr
	(*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(subPtr)).FthisPtr)).FrefCount++
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOAllocClass --
 *
 *	Allocate a basic class. Does not add class to its class's instance
 *	list.
 *
 * ----------------------------------------------------------------------
 */

func _InitClassPath(tls *libc.TLS, interp uintptr, clsPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var fPtr uintptr
	var _ /* path at bp+0 */ [2]uintptr
	_ = fPtr
	fPtr = (*TInterp)(unsafe.Pointer(interp)).FobjectFoundation
	if (*TFoundation)(unsafe.Pointer(fPtr)).FhelpersNs != libc.UintptrFromInt32(0) {
		(*(*[2]uintptr)(unsafe.Pointer(bp)))[0] = (*TFoundation)(unsafe.Pointer(fPtr)).FhelpersNs
		(*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)] = (*TFoundation)(unsafe.Pointer(fPtr)).FooNs
		XTclSetNsPath(tls, (*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).FthisPtr)).FnamespacePtr, int64(2), bp)
	} else {
		XTclSetNsPath(tls, (*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).FthisPtr)).FnamespacePtr, int64(1), fPtr+24)
	}
}

func XTclOOAllocClass(tls *libc.TLS, interp uintptr, useThisObj uintptr) (r uintptr) {
	/* Object that is to act as the class
	 * representation. */
	var clsPtr, fPtr uintptr
	_, _ = clsPtr, fPtr
	fPtr = (*TInterp)(unsafe.Pointer(interp)).FobjectFoundation
	clsPtr = XTcl_Alloc(tls, uint64(392))
	libc.Xmemset(tls, clsPtr, 0, uint64(392))
	(*TClass)(unsafe.Pointer(clsPtr)).FthisPtr = useThisObj
	/*
	 * Configure the namespace path for the class's object.
	 */
	_InitClassPath(tls, interp, clsPtr)
	/*
	 * Classes are subclasses of oo::object, i.e. the objects they create are
	 * objects.
	 */
	(*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Fnum = int64(1)
	(*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Flist = XTcl_Alloc(tls, uint64(8))
	*(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Flist)) = (*TFoundation)(unsafe.Pointer(fPtr)).FobjectCls
	(*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FobjectCls)).FthisPtr)).FrefCount++
	/*
	 * Finish connecting the class structure to the object structure.
	 */
	(*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).FthisPtr)).FclassPtr = clsPtr
	/*
	 * That's the complicated bit. Now fill in the rest of the non-zero/NULL
	 * fields.
	 */
	XTcl_InitObjHashTable(tls, clsPtr+136)
	return clsPtr
}

// C documentation
//
//	/*
//	 * ----------------------------------------------------------------------
//	 *
//	 * Tcl_NewObjectInstance --
//	 *
//	 *	Allocate a new instance of an object.
//	 *
//	 * ----------------------------------------------------------------------
//	 */
func XTcl_NewObjectInstance(tls *libc.TLS, interp uintptr, cls TTcl_Class, nameStr uintptr, nsNameStr uintptr, objc TTcl_Size, objv uintptr, skip TTcl_Size) (r TTcl_Object) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Number of arguments to _not_ pass to the
	 * constructor. */
	var classPtr, contextPtr uintptr
	var isRoot, result int32
	var state TTcl_InterpState
	var _ /* clientData at bp+8 */ [4]uintptr
	var _ /* oPtr at bp+0 */ uintptr
	_, _, _, _, _ = classPtr, contextPtr, isRoot, result, state
	classPtr = cls
	*(*uintptr)(unsafe.Pointer(bp)) = XTclNewObjectInstanceCommon(tls, interp, classPtr, nameStr, nsNameStr)
	if *(*uintptr)(unsafe.Pointer(bp)) == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	/*
	 * Run constructors, except when objc < 0, which is a special flag case
	 * used for object cloning only.
	 */
	if objc != int64(-libc.Int32FromInt32(1)) {
		contextPtr = XTclOOGetCallContext(tls, *(*uintptr)(unsafe.Pointer(bp)), libc.UintptrFromInt32(0), int32(CONSTRUCTOR), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
		if contextPtr != libc.UintptrFromInt32(0) {
			state = XTcl_SaveInterpState(tls, interp, TCL_OK)
			*(*int32)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr + 24)) |= int32(CONSTRUCTOR)
			(*TCallContext)(unsafe.Pointer(contextPtr)).Fskip = skip
			/*
			 * Adjust the ensemble tracking record if necessary. [Bug 3514761]
			 */
			isRoot = XTclInitRewriteEnsemble(tls, interp, skip, skip, objv)
			result = XTcl_NRCallObjProc(tls, interp, __ccgo_fp(XTclOOInvokeContext), contextPtr, objc, objv)
			if isRoot != 0 {
				XTclResetRewriteEnsemble(tls, interp, int32(1))
			}
			(*(*[4]uintptr)(unsafe.Pointer(bp + 8)))[0] = contextPtr
			(*(*[4]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] = *(*uintptr)(unsafe.Pointer(bp))
			(*(*[4]uintptr)(unsafe.Pointer(bp + 8)))[int32(2)] = state
			(*(*[4]uintptr)(unsafe.Pointer(bp + 8)))[int32(3)] = bp
			result = _FinalizeAlloc(tls, bp+8, interp, result)
			if result != TCL_OK {
				return libc.UintptrFromInt32(0)
			}
		}
	}
	return *(*uintptr)(unsafe.Pointer(bp))
}

func XTclNRNewObjectInstance(tls *libc.TLS, interp uintptr, cls TTcl_Class, nameStr uintptr, nsNameStr uintptr, objc TTcl_Size, objv uintptr, skip TTcl_Size, objectPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Place to write the object reference upon
	 * successful allocation. */
	var _objPtr, _objPtr1, cachePtr, cachePtr1, classPtr, contextPtr, oPtr uintptr
	var state TTcl_InterpState
	var v1, v2 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	var _ /* _callbackPtr at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, cachePtr1, classPtr, contextPtr, oPtr, state, v1, v2
	classPtr = cls
	oPtr = XTclNewObjectInstanceCommon(tls, interp, classPtr, nameStr, nsNameStr)
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Run constructors, except when objc == TCL_INDEX_NONE (a special flag case used for
	 * object cloning only). If there aren't any constructors, we do nothing.
	 */
	if objc < 0 {
		*(*TTcl_Object)(unsafe.Pointer(objectPtr)) = oPtr
		return TCL_OK
	}
	contextPtr = XTclOOGetCallContext(tls, oPtr, libc.UintptrFromInt32(0), int32(CONSTRUCTOR), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	if contextPtr == libc.UintptrFromInt32(0) {
		*(*TTcl_Object)(unsafe.Pointer(objectPtr)) = oPtr
		return TCL_OK
	}
	state = XTcl_SaveInterpState(tls, interp, TCL_OK)
	*(*int32)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr + 24)) |= int32(CONSTRUCTOR)
	(*TCallContext)(unsafe.Pointer(contextPtr)).Fskip = skip
	/*
	 * Adjust the ensemble tracking record if necessary. [Bug 3514761]
	 */
	if XTclInitRewriteEnsemble(tls, interp, skip, skip, objv) != 0 {
		if v1 = interp == libc.UintptrFromInt32(0); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			_objPtr = XTclThreadAllocObj(tls)
		} else {
			_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(_objPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(XTclClearRootEnsemble)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
		(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
	}
	/*
	 * Fire off the constructors non-recursively.
	 */
	if v2 = interp == libc.UintptrFromInt32(0); !v2 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr1 = XTclThreadAllocObj(tls)
	} else {
		_objPtr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr1 + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 8)) = _objPtr1
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FprocPtr = __ccgo_fp(_FinalizeAlloc)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8)) = contextPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 1*8)) = oPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 2*8)) = state
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 3*8)) = objectPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
	XTclPushTailcallPoint(tls, interp)
	return XTclOOInvokeContext(tls, contextPtr, interp, int32(objc), objv)
}

func XTclNewObjectInstanceCommon(tls *libc.TLS, interp uintptr, classPtr uintptr, nameStr uintptr, nsNameStr uintptr) (r uintptr) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var fPtr, hPtr, inNsPtr, oPtr uintptr
	var _ /* dummy at bp+16 */ uintptr
	var _ /* nsPtr at bp+8 */ uintptr
	var _ /* simpleName at bp+0 */ uintptr
	_, _, _, _ = fPtr, hPtr, inNsPtr, oPtr
	fPtr = (*TInterp)(unsafe.Pointer(interp)).FobjectFoundation
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(bp + 8)) = libc.UintptrFromInt32(0)
	inNsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FnsPtr
	if nameStr != 0 {
		XTclGetNamespaceForQualName(tls, interp, nameStr, inNsPtr, int32(TCL_CREATE_NS_IF_UNKNOWN), bp+8, bp+16, bp+16, bp)
		/*
		 * Disallow creation of an object over an existing command.
		 */
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 184)).FfindProc})))(tls, *(*uintptr)(unsafe.Pointer(bp + 8))+184, *(*uintptr)(unsafe.Pointer(bp)))
		if hPtr != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+87321, libc.VaList(bp+32, nameStr)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+32, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+87385, libc.UintptrFromInt32(0)))
			return libc.UintptrFromInt32(0)
		}
	}
	/*
	 * Create the object.
	 */
	oPtr = _AllocObject(tls, interp, *(*uintptr)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 8)), nsNameStr)
	if oPtr == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	(*TObject)(unsafe.Pointer(oPtr)).FselfCls = classPtr
	(*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(classPtr)).FthisPtr)).FrefCount++
	XTclOOAddToInstances(tls, oPtr, classPtr)
	/*
	 * Check to see if we're really creating a class. If so, allocate the
	 * class structure as well.
	 */
	if XTclOOIsReachable(tls, (*TFoundation)(unsafe.Pointer(fPtr)).FclassCls, classPtr) != 0 {
		/*
		 * Is a class, so attach a class structure. Note that the
		 * TclOOAllocClass function splices the structure into the object, so
		 * we don't have to. Once that's done, we need to repatch the object
		 * to have the right class since TclOOAllocClass interferes with that.
		 */
		XTclOOAllocClass(tls, interp, oPtr)
		XTclOOAddToSubclasses(tls, (*TObject)(unsafe.Pointer(oPtr)).FclassPtr, (*TFoundation)(unsafe.Pointer(fPtr)).FobjectCls)
	} else {
		(*TObject)(unsafe.Pointer(oPtr)).FclassPtr = libc.UintptrFromInt32(0)
	}
	return oPtr
}

func _FinalizeAlloc(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var contextPtr, oPtr, objectPtr uintptr
	var state TTcl_InterpState
	_, _, _, _ = contextPtr, oPtr, objectPtr, state
	contextPtr = *(*uintptr)(unsafe.Pointer(data))
	oPtr = *(*uintptr)(unsafe.Pointer(data + 1*8))
	state = *(*uintptr)(unsafe.Pointer(data + 2*8))
	objectPtr = *(*uintptr)(unsafe.Pointer(data + 3*8))
	/*
	 * Ensure an error if the object was deleted in the constructor. Don't
	 * want to lose errors by accident. [Bug 2903011]
	 */
	if result != int32(TCL_ERROR) && (*TObject)(unsafe.Pointer(oPtr)).Fflags&int32(OBJECT_DESTRUCTING) != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+87402, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+87432, libc.UintptrFromInt32(0)))
		result = int32(TCL_ERROR)
	}
	if result != TCL_OK {
		XTcl_DiscardInterpState(tls, state)
		/*
		 * Take care to not delete a deleted object; that would be bad. [Bug
		 * 2903011] Also take care to make sure that we have the name of the
		 * command before we delete it. [Bug 9dd1bd7a74]
		 */
		if !((*TObject)(unsafe.Pointer(oPtr)).Fflags&int32(OBJECT_DESTRUCTING) != 0) {
			XTclOOObjectName(tls, interp, oPtr)
			XTcl_DeleteCommandFromToken(tls, interp, (*TObject)(unsafe.Pointer(oPtr)).Fcommand)
		}
		/*
		 * This decrements the refcount of oPtr.
		 */
		XTclOODeleteContext(tls, contextPtr)
		return int32(TCL_ERROR)
	}
	XTcl_RestoreInterpState(tls, interp, state)
	*(*TTcl_Object)(unsafe.Pointer(objectPtr)) = oPtr
	/*
	 * This decrements the refcount of oPtr.
	 */
	XTclOODeleteContext(tls, contextPtr)
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * Tcl_CopyObjectInstance --
 *
 *	Creates a copy of an object. Does not copy the backing namespace,
 *	since the correct way to do that (e.g., shallow/deep) depends on the
 *	object/class's own policies.
 *
 * ----------------------------------------------------------------------
 */

func XTcl_CopyObjectInstance(tls *libc.TLS, interp uintptr, sourceObject TTcl_Object, targetName uintptr, targetNamespaceName uintptr) (r TTcl_Object) {
	bp := tls.Alloc(160)
	defer tls.Free(160)
	var cachePtr, cachePtr1, cachePtr2, cls2Ptr, clsPtr, contextPtr, filterObj, hPtr, mixinPtr, o2Ptr, oPtr, privateVariable, superPtr, variableObj, v12, v15, v19, v23, v26, v29, v3, v33, v37, v40, v42, v45, v48, v6, v9 uintptr
	var i, v11, v14, v22, v25, v28, v32, v41, v44, v47, v5, v8 TTcl_Size
	var len1, len11, len2, len3, len4, len5, len6, len7 Tsize_t
	var result, v18, v2, v36, v39 int32
	var v43, v46, v49 bool
	var _ /* args at bp+40 */ [3]uintptr
	var _ /* duplicate at bp+104 */ uintptr
	var _ /* duplicate at bp+80 */ uintptr
	var _ /* keyPtr at bp+32 */ uintptr
	var _ /* mPtr at bp+24 */ uintptr
	var _ /* metadataTypePtr at bp+64 */ uintptr
	var _ /* metadataTypePtr at bp+88 */ uintptr
	var _ /* search at bp+0 */ TTcl_HashSearch
	var _ /* value at bp+72 */ uintptr
	var _ /* value at bp+96 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, cls2Ptr, clsPtr, contextPtr, filterObj, hPtr, i, len1, len11, len2, len3, len4, len5, len6, len7, mixinPtr, o2Ptr, oPtr, privateVariable, result, superPtr, variableObj, v11, v12, v14, v15, v18, v19, v2, v22, v23, v25, v26, v28, v29, v3, v32, v33, v36, v37, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v6, v8, v9
	oPtr = sourceObject
	/*
	 * Sanity check.
	 */
	if (*TObject)(unsafe.Pointer(oPtr)).Fflags&int32(ROOT_CLASS) != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+87442, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+120, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+87477, libc.UintptrFromInt32(0)))
		return libc.UintptrFromInt32(0)
	}
	/*
	 * Build the instance. Note that this does not run any constructors.
	 */
	o2Ptr = XTcl_NewObjectInstance(tls, interp, (*TObject)(unsafe.Pointer(oPtr)).FselfCls, targetName, targetNamespaceName, int64(-libc.Int32FromInt32(1)), libc.UintptrFromInt32(0), 0)
	if o2Ptr == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	/*
	 * Copy the object-local methods to the new object.
	 */
	if (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr != 0 {
		hPtr = XTcl_FirstHashEntry(tls, (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr, bp)
		for {
			if hPtr != libc.UintptrFromInt32(0) {
				if (*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr)).FkeyType == -int32(1) {
					v3 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
				} else {
					v3 = hPtr + 32
				}
				*(*uintptr)(unsafe.Pointer(bp + 32)) = v3
				*(*uintptr)(unsafe.Pointer(bp + 24)) = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
				v2 = libc.Int32FromInt32(1)
			} else {
				v2 = 0
			}
			if !(v2 != 0) {
				break
			}
			if _CloneObjectMethod(tls, interp, o2Ptr, *(*uintptr)(unsafe.Pointer(bp + 24)), *(*uintptr)(unsafe.Pointer(bp + 32))) != TCL_OK {
				XTcl_DeleteCommandFromToken(tls, interp, (*TObject)(unsafe.Pointer(o2Ptr)).Fcommand)
				return libc.UintptrFromInt32(0)
			}
			goto _1
		_1:
			;
			hPtr = XTcl_NextHashEntry(tls, bp)
		}
	}
	/*
	 * Copy the object's mixin references to the new object.
	 */
	if (*TObject)(unsafe.Pointer(o2Ptr)).Fmixins.Fnum != 0 {
		i = 0
		for {
			if !(i < (*TObject)(unsafe.Pointer(o2Ptr)).Fmixins.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(o2Ptr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _4
			} else {
				mixinPtr = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(o2Ptr)).Fmixins.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					if mixinPtr != 0 && mixinPtr != (*TObject)(unsafe.Pointer(o2Ptr)).FselfCls {
						XTclOORemoveFromInstances(tls, o2Ptr, mixinPtr)
					}
					XTclOODecrRefCount(tls, (*TClass)(unsafe.Pointer(mixinPtr)).FthisPtr)
				}
			}
			goto _4
		_4:
			;
			i++
		}
		XTclpFree(tls, (*TObject)(unsafe.Pointer(o2Ptr)).Fmixins.Flist)
	}
	v5 = (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Fnum
	(*TObject)(unsafe.Pointer(o2Ptr)).Fmixins.Fnum = v5
	len1 = uint64(8) * libc.Uint64FromInt64(v5)
	if len1 != uint64(0) {
		v6 = XTcl_Alloc(tls, len1)
		(*TObject)(unsafe.Pointer(o2Ptr)).Fmixins.Flist = v6
		libc.Xmemcpy(tls, v6, (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist, len1)
	} else {
		(*TObject)(unsafe.Pointer(o2Ptr)).Fmixins.Flist = libc.UintptrFromInt32(0)
	}
	i = 0
	for {
		if !(i < (*TObject)(unsafe.Pointer(o2Ptr)).Fmixins.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(o2Ptr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _7
		} else {
			mixinPtr = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(o2Ptr)).Fmixins.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				if mixinPtr != 0 && mixinPtr != (*TObject)(unsafe.Pointer(o2Ptr)).FselfCls {
					XTclOOAddToInstances(tls, o2Ptr, mixinPtr)
				}
				/*
				 * For the reference just created in DUPLICATE.
				 */
				(*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(mixinPtr)).FthisPtr)).FrefCount++
			}
		}
		goto _7
	_7:
		;
		i++
	}
	/*
	 * Copy the object's filter list to the new object.
	 */
	v8 = (*TObject)(unsafe.Pointer(oPtr)).Ffilters.Fnum
	(*TObject)(unsafe.Pointer(o2Ptr)).Ffilters.Fnum = v8
	len11 = uint64(8) * libc.Uint64FromInt64(v8)
	if len11 != uint64(0) {
		v9 = XTcl_Alloc(tls, len11)
		(*TObject)(unsafe.Pointer(o2Ptr)).Ffilters.Flist = v9
		libc.Xmemcpy(tls, v9, (*TObject)(unsafe.Pointer(oPtr)).Ffilters.Flist, len11)
	} else {
		(*TObject)(unsafe.Pointer(o2Ptr)).Ffilters.Flist = libc.UintptrFromInt32(0)
	}
	i = 0
	for {
		if !(i < (*TObject)(unsafe.Pointer(o2Ptr)).Ffilters.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(o2Ptr)).Ffilters.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _10
		} else {
			filterObj = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(o2Ptr)).Ffilters.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				(*TTcl_Obj)(unsafe.Pointer(filterObj)).FrefCount++
			}
		}
		goto _10
	_10:
		;
		i++
	}
	/*
	 * Copy the object's variable resolution lists to the new object.
	 */
	v11 = (*TObject)(unsafe.Pointer(oPtr)).Fvariables.Fnum
	(*TObject)(unsafe.Pointer(o2Ptr)).Fvariables.Fnum = v11
	len2 = uint64(8) * libc.Uint64FromInt64(v11)
	if len2 != uint64(0) {
		v12 = XTcl_Alloc(tls, len2)
		(*TObject)(unsafe.Pointer(o2Ptr)).Fvariables.Flist = v12
		libc.Xmemcpy(tls, v12, (*TObject)(unsafe.Pointer(oPtr)).Fvariables.Flist, len2)
	} else {
		(*TObject)(unsafe.Pointer(o2Ptr)).Fvariables.Flist = libc.UintptrFromInt32(0)
	}
	i = 0
	for {
		if !(i < (*TObject)(unsafe.Pointer(o2Ptr)).Fvariables.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(o2Ptr)).Fvariables.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _13
		} else {
			variableObj = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(o2Ptr)).Fvariables.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				(*TTcl_Obj)(unsafe.Pointer(variableObj)).FrefCount++
			}
		}
		goto _13
	_13:
		;
		i++
	}
	v14 = (*TObject)(unsafe.Pointer(oPtr)).FprivateVariables.Fnum
	(*TObject)(unsafe.Pointer(o2Ptr)).FprivateVariables.Fnum = v14
	len3 = uint64(16) * libc.Uint64FromInt64(v14)
	if len3 != uint64(0) {
		v15 = XTcl_Alloc(tls, len3)
		(*TObject)(unsafe.Pointer(o2Ptr)).FprivateVariables.Flist = v15
		libc.Xmemcpy(tls, v15, (*TObject)(unsafe.Pointer(oPtr)).FprivateVariables.Flist, len3)
	} else {
		(*TObject)(unsafe.Pointer(o2Ptr)).FprivateVariables.Flist = libc.UintptrFromInt32(0)
	}
	i = 0
	if (*TObject)(unsafe.Pointer(o2Ptr)).FprivateVariables.Fnum > libc.Int64FromInt32(0) {
		for {
			privateVariable = (*TObject)(unsafe.Pointer(o2Ptr)).FprivateVariables.Flist + uintptr(i)*16
			if !(i < (*TObject)(unsafe.Pointer(o2Ptr)).FprivateVariables.Fnum) {
				break
			}
			(*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FvariableObj)).FrefCount++
			(*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FfullNameObj)).FrefCount++
			goto _16
		_16:
			;
			i++
		}
	}
	/*
	 * Copy the object's flags to the new object, clearing those that must be
	 * kept object-local. The duplicate is never deleted at this point, nor is
	 * it the root of the object system or in the midst of processing a filter
	 * call.
	 */
	(*TObject)(unsafe.Pointer(o2Ptr)).Fflags = (*TObject)(unsafe.Pointer(oPtr)).Fflags & ^(int32(OBJECT_DESTRUCTING) | int32(ROOT_OBJECT) | int32(ROOT_CLASS) | int32(FILTER_HANDLING))
	/*
	 * Copy the object's metadata.
	 */
	if (*TObject)(unsafe.Pointer(oPtr)).FmetadataPtr != libc.UintptrFromInt32(0) {
		hPtr = XTcl_FirstHashEntry(tls, (*TObject)(unsafe.Pointer(oPtr)).FmetadataPtr, bp)
		for {
			if hPtr != libc.UintptrFromInt32(0) {
				if (*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FmetadataPtr)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FmetadataPtr)).FkeyType == -int32(1) {
					v19 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
				} else {
					v19 = hPtr + 32
				}
				*(*uintptr)(unsafe.Pointer(bp + 64)) = v19
				*(*uintptr)(unsafe.Pointer(bp + 72)) = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
				v18 = libc.Int32FromInt32(1)
			} else {
				v18 = 0
			}
			if !(v18 != 0) {
				break
			}
			if (*TTcl_ObjectMetadataType)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 64)))).FcloneProc == libc.UintptrFromInt32(0) {
				*(*uintptr)(unsafe.Pointer(bp + 80)) = *(*uintptr)(unsafe.Pointer(bp + 72))
			} else {
				if (*(*func(*libc.TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjectMetadataType)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 64)))).FcloneProc})))(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 72)), bp+80) != TCL_OK {
					XTcl_DeleteCommandFromToken(tls, interp, (*TObject)(unsafe.Pointer(o2Ptr)).Fcommand)
					return libc.UintptrFromInt32(0)
				}
			}
			if *(*uintptr)(unsafe.Pointer(bp + 80)) != libc.UintptrFromInt32(0) {
				XTcl_ObjectSetMetadata(tls, o2Ptr, *(*uintptr)(unsafe.Pointer(bp + 64)), *(*uintptr)(unsafe.Pointer(bp + 80)))
			}
			goto _17
		_17:
			;
			hPtr = XTcl_NextHashEntry(tls, bp)
		}
	}
	/*
	 * Copy the class, if present. Note that if there is a class present in
	 * the source object, there must also be one in the copy.
	 */
	if (*TObject)(unsafe.Pointer(oPtr)).FclassPtr != libc.UintptrFromInt32(0) {
		clsPtr = (*TObject)(unsafe.Pointer(oPtr)).FclassPtr
		cls2Ptr = (*TObject)(unsafe.Pointer(o2Ptr)).FclassPtr
		/*
		 * Copy the class flags across.
		 */
		(*TClass)(unsafe.Pointer(cls2Ptr)).Fflags = (*TClass)(unsafe.Pointer(clsPtr)).Fflags
		/*
		 * Ensure that the new class's superclass structure is the same as the
		 * old class's.
		 */
		i = 0
		for {
			if !(i < (*TClass)(unsafe.Pointer(cls2Ptr)).Fsuperclasses.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(cls2Ptr)).Fsuperclasses.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _20
			} else {
				superPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(cls2Ptr)).Fsuperclasses.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					XTclOORemoveFromSubclasses(tls, cls2Ptr, superPtr)
					XTclOODecrRefCount(tls, (*TClass)(unsafe.Pointer(superPtr)).FthisPtr)
				}
			}
			goto _20
		_20:
			;
			i++
		}
		if (*TClass)(unsafe.Pointer(cls2Ptr)).Fsuperclasses.Fnum != 0 {
			(*TClass)(unsafe.Pointer(cls2Ptr)).Fsuperclasses.Flist = XTcl_Realloc(tls, (*TClass)(unsafe.Pointer(cls2Ptr)).Fsuperclasses.Flist, uint64(8)*libc.Uint64FromInt64((*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Fnum))
		} else {
			(*TClass)(unsafe.Pointer(cls2Ptr)).Fsuperclasses.Flist = XTcl_Alloc(tls, uint64(8)*libc.Uint64FromInt64((*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Fnum))
		}
		libc.Xmemcpy(tls, (*TClass)(unsafe.Pointer(cls2Ptr)).Fsuperclasses.Flist, (*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Flist, uint64(8)*libc.Uint64FromInt64((*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Fnum))
		(*TClass)(unsafe.Pointer(cls2Ptr)).Fsuperclasses.Fnum = (*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Fnum
		i = 0
		for {
			if !(i < (*TClass)(unsafe.Pointer(cls2Ptr)).Fsuperclasses.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(cls2Ptr)).Fsuperclasses.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _21
			} else {
				superPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(cls2Ptr)).Fsuperclasses.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					XTclOOAddToSubclasses(tls, cls2Ptr, superPtr)
					/*
					 * For the new item in cls2Ptr->superclasses that memcpy just
					 * created.
					 */
					(*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(superPtr)).FthisPtr)).FrefCount++
				}
			}
			goto _21
		_21:
			;
			i++
		}
		/*
		 * Duplicate the source class's filters.
		 */
		v22 = (*TClass)(unsafe.Pointer(clsPtr)).Ffilters.Fnum
		(*TClass)(unsafe.Pointer(cls2Ptr)).Ffilters.Fnum = v22
		len4 = uint64(8) * libc.Uint64FromInt64(v22)
		if len4 != uint64(0) {
			v23 = XTcl_Alloc(tls, len4)
			(*TClass)(unsafe.Pointer(cls2Ptr)).Ffilters.Flist = v23
			libc.Xmemcpy(tls, v23, (*TClass)(unsafe.Pointer(clsPtr)).Ffilters.Flist, len4)
		} else {
			(*TClass)(unsafe.Pointer(cls2Ptr)).Ffilters.Flist = libc.UintptrFromInt32(0)
		}
		i = 0
		for {
			if !(i < (*TClass)(unsafe.Pointer(cls2Ptr)).Ffilters.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(cls2Ptr)).Ffilters.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _24
			} else {
				filterObj = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(cls2Ptr)).Ffilters.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					(*TTcl_Obj)(unsafe.Pointer(filterObj)).FrefCount++
				}
			}
			goto _24
		_24:
			;
			i++
		}
		/*
		 * Copy the source class's variable resolution lists.
		 */
		v25 = (*TClass)(unsafe.Pointer(clsPtr)).Fvariables.Fnum
		(*TClass)(unsafe.Pointer(cls2Ptr)).Fvariables.Fnum = v25
		len5 = uint64(8) * libc.Uint64FromInt64(v25)
		if len5 != uint64(0) {
			v26 = XTcl_Alloc(tls, len5)
			(*TClass)(unsafe.Pointer(cls2Ptr)).Fvariables.Flist = v26
			libc.Xmemcpy(tls, v26, (*TClass)(unsafe.Pointer(clsPtr)).Fvariables.Flist, len5)
		} else {
			(*TClass)(unsafe.Pointer(cls2Ptr)).Fvariables.Flist = libc.UintptrFromInt32(0)
		}
		i = 0
		for {
			if !(i < (*TClass)(unsafe.Pointer(cls2Ptr)).Fvariables.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(cls2Ptr)).Fvariables.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _27
			} else {
				variableObj = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(cls2Ptr)).Fvariables.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					(*TTcl_Obj)(unsafe.Pointer(variableObj)).FrefCount++
				}
			}
			goto _27
		_27:
			;
			i++
		}
		v28 = (*TClass)(unsafe.Pointer(clsPtr)).FprivateVariables.Fnum
		(*TClass)(unsafe.Pointer(cls2Ptr)).FprivateVariables.Fnum = v28
		len6 = uint64(16) * libc.Uint64FromInt64(v28)
		if len6 != uint64(0) {
			v29 = XTcl_Alloc(tls, len6)
			(*TClass)(unsafe.Pointer(cls2Ptr)).FprivateVariables.Flist = v29
			libc.Xmemcpy(tls, v29, (*TClass)(unsafe.Pointer(clsPtr)).FprivateVariables.Flist, len6)
		} else {
			(*TClass)(unsafe.Pointer(cls2Ptr)).FprivateVariables.Flist = libc.UintptrFromInt32(0)
		}
		i = 0
		if (*TClass)(unsafe.Pointer(cls2Ptr)).FprivateVariables.Fnum > libc.Int64FromInt32(0) {
			for {
				privateVariable = (*TClass)(unsafe.Pointer(cls2Ptr)).FprivateVariables.Flist + uintptr(i)*16
				if !(i < (*TClass)(unsafe.Pointer(cls2Ptr)).FprivateVariables.Fnum) {
					break
				}
				(*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FvariableObj)).FrefCount++
				(*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privateVariable)).FfullNameObj)).FrefCount++
				goto _30
			_30:
				;
				i++
			}
		}
		/*
		 * Duplicate the source class's mixins (which cannot be circular
		 * references to the duplicate).
		 */
		if (*TClass)(unsafe.Pointer(cls2Ptr)).Fmixins.Fnum != 0 {
			i = 0
			for {
				if !(i < (*TClass)(unsafe.Pointer(cls2Ptr)).Fmixins.Fnum) {
					break
				}
				if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(cls2Ptr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
					goto _31
				} else {
					mixinPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(cls2Ptr)).Fmixins.Flist + uintptr(i)*8))
					if libc.Int32FromInt32(1) != 0 {
						XTclOORemoveFromMixinSubs(tls, cls2Ptr, mixinPtr)
						XTclOODecrRefCount(tls, (*TClass)(unsafe.Pointer(mixinPtr)).FthisPtr)
					}
				}
				goto _31
			_31:
				;
				i++
			}
			XTclpFree(tls, (*TClass)(unsafe.Pointer(clsPtr)).Fmixins.Flist)
		}
		v32 = (*TClass)(unsafe.Pointer(clsPtr)).Fmixins.Fnum
		(*TClass)(unsafe.Pointer(cls2Ptr)).Fmixins.Fnum = v32
		len7 = uint64(8) * libc.Uint64FromInt64(v32)
		if len7 != uint64(0) {
			v33 = XTcl_Alloc(tls, len7)
			(*TClass)(unsafe.Pointer(cls2Ptr)).Fmixins.Flist = v33
			libc.Xmemcpy(tls, v33, (*TClass)(unsafe.Pointer(clsPtr)).Fmixins.Flist, len7)
		} else {
			(*TClass)(unsafe.Pointer(cls2Ptr)).Fmixins.Flist = libc.UintptrFromInt32(0)
		}
		i = 0
		for {
			if !(i < (*TClass)(unsafe.Pointer(cls2Ptr)).Fmixins.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(cls2Ptr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _34
			} else {
				mixinPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(cls2Ptr)).Fmixins.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					XTclOOAddToMixinSubs(tls, cls2Ptr, mixinPtr)
					/*
					 * For the copy just created in DUPLICATE.
					 */
					(*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(mixinPtr)).FthisPtr)).FrefCount++
				}
			}
			goto _34
		_34:
			;
			i++
		}
		/*
		 * Duplicate the source class's methods, constructor and destructor.
		 */
		hPtr = XTcl_FirstHashEntry(tls, clsPtr+136, bp)
		for {
			if hPtr != libc.UintptrFromInt32(0) {
				if (*TTcl_HashTable)(unsafe.Pointer(clsPtr+136)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(clsPtr+136)).FkeyType == -int32(1) {
					v37 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
				} else {
					v37 = hPtr + 32
				}
				*(*uintptr)(unsafe.Pointer(bp + 32)) = v37
				*(*uintptr)(unsafe.Pointer(bp + 24)) = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
				v36 = libc.Int32FromInt32(1)
			} else {
				v36 = 0
			}
			if !(v36 != 0) {
				break
			}
			if _CloneClassMethod(tls, interp, cls2Ptr, *(*uintptr)(unsafe.Pointer(bp + 24)), *(*uintptr)(unsafe.Pointer(bp + 32)), libc.UintptrFromInt32(0)) != TCL_OK {
				XTcl_DeleteCommandFromToken(tls, interp, (*TObject)(unsafe.Pointer(o2Ptr)).Fcommand)
				return libc.UintptrFromInt32(0)
			}
			goto _35
		_35:
			;
			hPtr = XTcl_NextHashEntry(tls, bp)
		}
		if (*TClass)(unsafe.Pointer(clsPtr)).FconstructorPtr != 0 {
			if _CloneClassMethod(tls, interp, cls2Ptr, (*TClass)(unsafe.Pointer(clsPtr)).FconstructorPtr, libc.UintptrFromInt32(0), cls2Ptr+240) != TCL_OK {
				XTcl_DeleteCommandFromToken(tls, interp, (*TObject)(unsafe.Pointer(o2Ptr)).Fcommand)
				return libc.UintptrFromInt32(0)
			}
		}
		if (*TClass)(unsafe.Pointer(clsPtr)).FdestructorPtr != 0 {
			if _CloneClassMethod(tls, interp, cls2Ptr, (*TClass)(unsafe.Pointer(clsPtr)).FdestructorPtr, libc.UintptrFromInt32(0), cls2Ptr+248) != TCL_OK {
				XTcl_DeleteCommandFromToken(tls, interp, (*TObject)(unsafe.Pointer(o2Ptr)).Fcommand)
				return libc.UintptrFromInt32(0)
			}
		}
		/*
		 * Duplicate the class's metadata.
		 */
		if (*TClass)(unsafe.Pointer(clsPtr)).FmetadataPtr != libc.UintptrFromInt32(0) {
			hPtr = XTcl_FirstHashEntry(tls, (*TClass)(unsafe.Pointer(clsPtr)).FmetadataPtr, bp)
			for {
				if hPtr != libc.UintptrFromInt32(0) {
					if (*TTcl_HashTable)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).FmetadataPtr)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).FmetadataPtr)).FkeyType == -int32(1) {
						v40 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
					} else {
						v40 = hPtr + 32
					}
					*(*uintptr)(unsafe.Pointer(bp + 88)) = v40
					*(*uintptr)(unsafe.Pointer(bp + 96)) = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
					v39 = libc.Int32FromInt32(1)
				} else {
					v39 = 0
				}
				if !(v39 != 0) {
					break
				}
				if (*TTcl_ObjectMetadataType)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 88)))).FcloneProc == libc.UintptrFromInt32(0) {
					*(*uintptr)(unsafe.Pointer(bp + 104)) = *(*uintptr)(unsafe.Pointer(bp + 96))
				} else {
					if (*(*func(*libc.TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjectMetadataType)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 88)))).FcloneProc})))(tls, interp, *(*uintptr)(unsafe.Pointer(bp + 96)), bp+104) != TCL_OK {
						XTcl_DeleteCommandFromToken(tls, interp, (*TObject)(unsafe.Pointer(o2Ptr)).Fcommand)
						return libc.UintptrFromInt32(0)
					}
				}
				if *(*uintptr)(unsafe.Pointer(bp + 104)) != libc.UintptrFromInt32(0) {
					XTcl_ClassSetMetadata(tls, cls2Ptr, *(*uintptr)(unsafe.Pointer(bp + 88)), *(*uintptr)(unsafe.Pointer(bp + 104)))
				}
				goto _38
			_38:
				;
				hPtr = XTcl_NextHashEntry(tls, bp)
			}
		}
	}
	XTclResetRewriteEnsemble(tls, interp, int32(1))
	contextPtr = XTclOOGetCallContext(tls, o2Ptr, (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FfPtr)).FclonedName, 0, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	if contextPtr != 0 {
		(*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[0] = XTclOOObjectName(tls, interp, o2Ptr)
		(*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[int32(1)] = (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FfPtr)).FclonedName
		(*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[int32(2)] = XTclOOObjectName(tls, interp, oPtr)
		(*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[0])).FrefCount++
		(*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[int32(1)])).FrefCount++
		(*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[int32(2)])).FrefCount++
		result = XTcl_NRCallObjProc(tls, interp, __ccgo_fp(XTclOOInvokeContext), contextPtr, int64(3), bp+40)
		v42 = (*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[0]
		v41 = *(*TTcl_Size)(unsafe.Pointer(v42))
		*(*TTcl_Size)(unsafe.Pointer(v42))--
		if !(v41 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[0])).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[0])).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[0])).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[0])).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[0])).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[0])).Flength = int64(-libc.Int32FromInt32(1))
				if v43 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v43 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v43 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, (*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[0])
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[0] + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[0]
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, (*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[0])
			}
		}
		v45 = (*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[int32(1)]
		v44 = *(*TTcl_Size)(unsafe.Pointer(v45))
		*(*TTcl_Size)(unsafe.Pointer(v45))--
		if !(v44 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[int32(1)])).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[int32(1)])).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[int32(1)])).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[int32(1)])).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[int32(1)])).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[int32(1)])).Flength = int64(-libc.Int32FromInt32(1))
				if v46 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v46 {
					cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v46 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, (*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[int32(1)])
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[int32(1)] + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[int32(1)]
					(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, (*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[int32(1)])
			}
		}
		v48 = (*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[int32(2)]
		v47 = *(*TTcl_Size)(unsafe.Pointer(v48))
		*(*TTcl_Size)(unsafe.Pointer(v48))--
		if !(v47 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[int32(2)])).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[int32(2)])).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[int32(2)])).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[int32(2)])).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[int32(2)])).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[int32(2)])).Flength = int64(-libc.Int32FromInt32(1))
				if v49 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v49 {
					cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v49 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, (*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[int32(2)])
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[int32(2)] + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[int32(2)]
					(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, (*(*[3]uintptr)(unsafe.Pointer(bp + 40)))[int32(2)])
			}
		}
		XTclOODeleteContext(tls, contextPtr)
		if result == int32(TCL_ERROR) {
			XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+87491, int64(-int32(1))))
		}
		if result != TCL_OK {
			XTcl_DeleteCommandFromToken(tls, interp, (*TObject)(unsafe.Pointer(o2Ptr)).Fcommand)
			return libc.UintptrFromInt32(0)
		}
	}
	return o2Ptr
}

/*
 * ----------------------------------------------------------------------
 *
 * CloneObjectMethod, CloneClassMethod --
 *
 *	Helper functions used for cloning methods. They work identically to
 *	each other, except for the difference between them in how they
 *	register the cloned method on a successful clone.
 *
 * ----------------------------------------------------------------------
 */

func _CloneObjectMethod(tls *libc.TLS, interp uintptr, oPtr uintptr, mPtr uintptr, namePtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _ /* newClientData at bp+0 */ uintptr
	if (*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr == libc.UintptrFromInt32(0) {
		XTclNewInstanceMethod(tls, interp, oPtr, namePtr, (*TMethod)(unsafe.Pointer(mPtr)).Fflags&int32(PUBLIC_METHOD), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	} else {
		if (*TTcl_MethodType)(unsafe.Pointer((*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr)).FcloneProc != 0 {
			if (*(*func(*libc.TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_MethodType)(unsafe.Pointer((*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr)).FcloneProc})))(tls, interp, (*TMethod)(unsafe.Pointer(mPtr)).FclientData, bp) != TCL_OK {
				return int32(TCL_ERROR)
			}
			XTclNewInstanceMethod(tls, interp, oPtr, namePtr, (*TMethod)(unsafe.Pointer(mPtr)).Fflags&int32(PUBLIC_METHOD), (*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr, *(*uintptr)(unsafe.Pointer(bp)))
		} else {
			XTclNewInstanceMethod(tls, interp, oPtr, namePtr, (*TMethod)(unsafe.Pointer(mPtr)).Fflags&int32(PUBLIC_METHOD), (*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr, (*TMethod)(unsafe.Pointer(mPtr)).FclientData)
		}
	}
	return TCL_OK
}

func _CloneClassMethod(tls *libc.TLS, interp uintptr, clsPtr uintptr, mPtr uintptr, namePtr uintptr, m2PtrPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var m2Ptr uintptr
	var _ /* newClientData at bp+0 */ uintptr
	_ = m2Ptr
	if (*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr == libc.UintptrFromInt32(0) {
		m2Ptr = XTclNewMethod(tls, clsPtr, namePtr, (*TMethod)(unsafe.Pointer(mPtr)).Fflags&int32(PUBLIC_METHOD), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	} else {
		if (*TTcl_MethodType)(unsafe.Pointer((*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr)).FcloneProc != 0 {
			if (*(*func(*libc.TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_MethodType)(unsafe.Pointer((*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr)).FcloneProc})))(tls, interp, (*TMethod)(unsafe.Pointer(mPtr)).FclientData, bp) != TCL_OK {
				return int32(TCL_ERROR)
			}
			m2Ptr = XTclNewMethod(tls, clsPtr, namePtr, (*TMethod)(unsafe.Pointer(mPtr)).Fflags&int32(PUBLIC_METHOD), (*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr, *(*uintptr)(unsafe.Pointer(bp)))
		} else {
			m2Ptr = XTclNewMethod(tls, clsPtr, namePtr, (*TMethod)(unsafe.Pointer(mPtr)).Fflags&int32(PUBLIC_METHOD), (*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr, (*TMethod)(unsafe.Pointer(mPtr)).FclientData)
		}
	}
	if m2PtrPtr != libc.UintptrFromInt32(0) {
		*(*uintptr)(unsafe.Pointer(m2PtrPtr)) = m2Ptr
	}
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * Tcl_ClassGetMetadata, Tcl_ClassSetMetadata, Tcl_ObjectGetMetadata,
 * Tcl_ObjectSetMetadata --
 *
 *	Metadata management API. The metadata system allows code in extensions
 *	to attach arbitrary non-NULL pointers to objects and classes without
 *	the different things that might be interested being able to interfere
 *	with each other. Apart from non-NULL-ness, these routines attach no
 *	interpretation to the meaning of the metadata pointers.
 *
 *	The Tcl_*GetMetadata routines get the metadata pointer attached that
 *	has been related with a particular type, or NULL if no metadata
 *	associated with the given type has been attached.
 *
 *	The Tcl_*SetMetadata routines set or delete the metadata pointer that
 *	is related to a particular type. The value associated with the type is
 *	deleted (if present; no-op otherwise) if the value is NULL, and
 *	attached (replacing the previous value, which is deleted if present)
 *	otherwise. This means it is impossible to attach a NULL value for any
 *	metadata type.
 *
 * ----------------------------------------------------------------------
 */

func XTcl_ClassGetMetadata(tls *libc.TLS, clazz TTcl_Class, typePtr uintptr) (r uintptr) {
	var clsPtr, hPtr uintptr
	_, _ = clsPtr, hPtr
	clsPtr = clazz
	/*
	 * If there's no metadata store attached, the type in question has
	 * definitely not been attached either!
	 */
	if (*TClass)(unsafe.Pointer(clsPtr)).FmetadataPtr == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	/*
	 * There is a metadata store, so look in it for the given type.
	 */
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).FmetadataPtr)).FfindProc})))(tls, (*TClass)(unsafe.Pointer(clsPtr)).FmetadataPtr, typePtr)
	/*
	 * Return the metadata value if we found it, otherwise NULL.
	 */
	if hPtr == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	return (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
}

func XTcl_ClassSetMetadata(tls *libc.TLS, clazz TTcl_Class, typePtr uintptr, metadata uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var clsPtr, hPtr uintptr
	var _ /* isNew at bp+0 */ int32
	_, _ = clsPtr, hPtr
	clsPtr = clazz
	/*
	 * Attach the metadata store if not done already.
	 */
	if (*TClass)(unsafe.Pointer(clsPtr)).FmetadataPtr == libc.UintptrFromInt32(0) {
		if metadata == libc.UintptrFromInt32(0) {
			return
		}
		(*TClass)(unsafe.Pointer(clsPtr)).FmetadataPtr = XTcl_Alloc(tls, uint64(104))
		XTcl_InitHashTable(tls, (*TClass)(unsafe.Pointer(clsPtr)).FmetadataPtr, int32(TCL_ONE_WORD_KEYS))
	}
	/*
	 * If the metadata is NULL, we're deleting the metadata for the type.
	 */
	if metadata == libc.UintptrFromInt32(0) {
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).FmetadataPtr)).FfindProc})))(tls, (*TClass)(unsafe.Pointer(clsPtr)).FmetadataPtr, typePtr)
		if hPtr != libc.UintptrFromInt32(0) {
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjectMetadataType)(unsafe.Pointer(typePtr)).FdeleteProc})))(tls, (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData)
			XTcl_DeleteHashEntry(tls, hPtr)
		}
		return
	}
	/*
	 * Otherwise we're attaching the metadata. Note that if there was already
	 * some metadata attached of this type, we delete that first.
	 */
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).FmetadataPtr)).FcreateProc})))(tls, (*TClass)(unsafe.Pointer(clsPtr)).FmetadataPtr, typePtr, bp)
	if !(*(*int32)(unsafe.Pointer(bp)) != 0) {
		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjectMetadataType)(unsafe.Pointer(typePtr)).FdeleteProc})))(tls, (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData)
	}
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = metadata
}

func XTcl_ObjectGetMetadata(tls *libc.TLS, object TTcl_Object, typePtr uintptr) (r uintptr) {
	var hPtr, oPtr uintptr
	_, _ = hPtr, oPtr
	oPtr = object
	/*
	 * If there's no metadata store attached, the type in question has
	 * definitely not been attached either!
	 */
	if (*TObject)(unsafe.Pointer(oPtr)).FmetadataPtr == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	/*
	 * There is a metadata store, so look in it for the given type.
	 */
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FmetadataPtr)).FfindProc})))(tls, (*TObject)(unsafe.Pointer(oPtr)).FmetadataPtr, typePtr)
	/*
	 * Return the metadata value if we found it, otherwise NULL.
	 */
	if hPtr == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	return (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
}

func XTcl_ObjectSetMetadata(tls *libc.TLS, object TTcl_Object, typePtr uintptr, metadata uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var hPtr, oPtr uintptr
	var _ /* isNew at bp+0 */ int32
	_, _ = hPtr, oPtr
	oPtr = object
	/*
	 * Attach the metadata store if not done already.
	 */
	if (*TObject)(unsafe.Pointer(oPtr)).FmetadataPtr == libc.UintptrFromInt32(0) {
		if metadata == libc.UintptrFromInt32(0) {
			return
		}
		(*TObject)(unsafe.Pointer(oPtr)).FmetadataPtr = XTcl_Alloc(tls, uint64(104))
		XTcl_InitHashTable(tls, (*TObject)(unsafe.Pointer(oPtr)).FmetadataPtr, int32(TCL_ONE_WORD_KEYS))
	}
	/*
	 * If the metadata is NULL, we're deleting the metadata for the type.
	 */
	if metadata == libc.UintptrFromInt32(0) {
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FmetadataPtr)).FfindProc})))(tls, (*TObject)(unsafe.Pointer(oPtr)).FmetadataPtr, typePtr)
		if hPtr != libc.UintptrFromInt32(0) {
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjectMetadataType)(unsafe.Pointer(typePtr)).FdeleteProc})))(tls, (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData)
			XTcl_DeleteHashEntry(tls, hPtr)
		}
		return
	}
	/*
	 * Otherwise we're attaching the metadata. Note that if there was already
	 * some metadata attached of this type, we delete that first.
	 */
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FmetadataPtr)).FcreateProc})))(tls, (*TObject)(unsafe.Pointer(oPtr)).FmetadataPtr, typePtr, bp)
	if !(*(*int32)(unsafe.Pointer(bp)) != 0) {
		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ObjectMetadataType)(unsafe.Pointer(typePtr)).FdeleteProc})))(tls, (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData)
	}
	(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = metadata
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOPublicObjectCmd, TclOOPrivateObjectCmd, TclOOInvokeObject --
 *
 *	Main entry point for object invocations. The Public* and Private*
 *	wrapper functions (implementations of both object instance commands
 *	and [my]) are just thin wrappers round the main TclOOObjectCmdCore
 *	function. Note that the core is function is NRE-aware.
 *
 * ----------------------------------------------------------------------
 */

func XTclOOPublicObjectCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	return XTcl_NRCallObjProc(tls, interp, __ccgo_fp(_PublicNRObjectCmd), clientData, int64(objc), objv)
}

func _PublicNRObjectCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	return XTclOOObjectCmdCore(tls, clientData, interp, int64(objc), objv, int32(PUBLIC_METHOD), libc.UintptrFromInt32(0))
}

func XTclOOPrivateObjectCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	return XTcl_NRCallObjProc(tls, interp, __ccgo_fp(_PrivateNRObjectCmd), clientData, int64(objc), objv)
}

func _PrivateNRObjectCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	return XTclOOObjectCmdCore(tls, clientData, interp, int64(objc), objv, 0, libc.UintptrFromInt32(0))
}

func XTclOOInvokeObject(tls *libc.TLS, interp uintptr, object TTcl_Object, startCls TTcl_Class, publicPrivate int32, objc TTcl_Size, objv uintptr) (r int32) {
	/* Array of argument objects. It is assumed
	 * that the name of the method to invoke will
	 * be at index 1. */
	switch publicPrivate {
	case int32(PUBLIC_METHOD):
		return XTclOOObjectCmdCore(tls, object, interp, objc, objv, int32(PUBLIC_METHOD), startCls)
	case int32(PRIVATE_METHOD):
		return XTclOOObjectCmdCore(tls, object, interp, objc, objv, int32(PRIVATE_METHOD), startCls)
	default:
		return XTclOOObjectCmdCore(tls, object, interp, objc, objv, 0, startCls)
	}
	return r
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOMyClassObjCmd, MyClassNRObjCmd --
 *
 *	Special trap door to allow an object to delegate simply to its class.
 *
 * ----------------------------------------------------------------------
 */

func XTclOOMyClassObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	return XTcl_NRCallObjProc(tls, interp, __ccgo_fp(_MyClassNRObjCmd), clientData, int64(objc), objv)
}

func _MyClassNRObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var oPtr uintptr
	_ = oPtr
	oPtr = clientData
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+87534)
		return int32(TCL_ERROR)
	}
	return XTclOOObjectCmdCore(tls, (*TClass)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FselfCls)).FthisPtr, interp, int64(objc), objv, 0, libc.UintptrFromInt32(0))
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOObjectCmdCore, FinalizeObjectCall --
 *
 *	Main function for object invocations. Does call chain creation,
 *	management and invocation. The function FinalizeObjectCall exists to
 *	clean up after the non-recursive processing of TclOOObjectCmdCore.
 *
 * ----------------------------------------------------------------------
 */

func XTclOOObjectCmdCore(tls *libc.TLS, oPtr uintptr, interp uintptr, objc TTcl_Size, objv uintptr, flags int32, _startCls uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	*(*uintptr)(unsafe.Pointer(bp)) = _startCls /* Where to start in the call chain, or NULL
	 * if we are to start at the front with
	 * filters and the object's methods (which is
	 * the normal case). */
	var _objPtr, cachePtr, cachePtr1, cachePtr2, callerClsPtr, callerContextPtr, callerMethodPtr, callerObjPtr, contextPtr, framePtr, mappedMethodName, methodNamePtr, miPtr, startClsPtr, v10, v11, v12, v14, v4, v7, v9 uintptr
	var result int32
	var v15, v5, v8 bool
	var v3, v6 TTcl_Size
	var _ /* _callbackPtr at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, cachePtr1, cachePtr2, callerClsPtr, callerContextPtr, callerMethodPtr, callerObjPtr, contextPtr, framePtr, mappedMethodName, methodNamePtr, miPtr, result, startClsPtr, v10, v11, v12, v14, v15, v3, v4, v5, v6, v7, v8, v9
	framePtr = (*TInterp)(unsafe.Pointer(interp)).FvarFramePtr
	callerObjPtr = libc.UintptrFromInt32(0)
	callerClsPtr = libc.UintptrFromInt32(0)
	/*
	 * If we've no method name, throw this directly into the unknown
	 * processing.
	 */
	if objc < int64(2) {
		flags |= int32(FORCE_UNKNOWN)
		methodNamePtr = libc.UintptrFromInt32(0)
		goto noMapping
	}
	/*
	 * Determine if we're in a context that can see the extra, private methods
	 * in this class.
	 */
	if (*TCallFrame)(unsafe.Pointer(framePtr)).FisProcCallFrame&int32(FRAME_IS_METHOD) != 0 {
		callerContextPtr = (*TCallFrame)(unsafe.Pointer(framePtr)).FclientData
		callerMethodPtr = (*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(callerContextPtr)).FcallPtr)).Fchain + uintptr((*TCallContext)(unsafe.Pointer(callerContextPtr)).Findex)*24))).FmPtr
		if (*TMethod)(unsafe.Pointer(callerMethodPtr)).FdeclaringObjectPtr != 0 {
			callerObjPtr = (*TMethod)(unsafe.Pointer(callerMethodPtr)).FdeclaringObjectPtr
		}
		if (*TMethod)(unsafe.Pointer(callerMethodPtr)).FdeclaringClassPtr != 0 {
			callerClsPtr = (*TMethod)(unsafe.Pointer(callerMethodPtr)).FdeclaringClassPtr
		}
	}
	/*
	 * Give plugged in code a chance to remap the method name.
	 */
	methodNamePtr = *(*uintptr)(unsafe.Pointer(objv + 1*8))
	if !((*TObject)(unsafe.Pointer(oPtr)).FmapMethodNameProc != libc.UintptrFromInt32(0)) {
		goto _1
	}
	startClsPtr = bp
	mappedMethodName = XTcl_DuplicateObj(tls, methodNamePtr)
	result = (*(*func(*libc.TLS, uintptr, TTcl_Object, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TObject)(unsafe.Pointer(oPtr)).FmapMethodNameProc})))(tls, interp, oPtr, startClsPtr, mappedMethodName)
	if result != TCL_OK {
		v4 = mappedMethodName
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if !(v3 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(mappedMethodName)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(mappedMethodName)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(mappedMethodName)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(mappedMethodName)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(mappedMethodName)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(mappedMethodName)).Flength = int64(-libc.Int32FromInt32(1))
				if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v5 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, mappedMethodName)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(mappedMethodName + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = mappedMethodName
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, mappedMethodName)
			}
		}
		if result == int32(TCL_BREAK) {
			goto noMapping
		} else {
			if result == int32(TCL_ERROR) {
				XTcl_AppendObjToErrorInfo(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+87555, int64(-int32(1))))
			}
		}
		return result
	}
	/*
	 * Get the call chain for the remapped name.
	 */
	(*TTcl_Obj)(unsafe.Pointer(mappedMethodName)).FrefCount++
	contextPtr = XTclOOGetCallContext(tls, oPtr, mappedMethodName, flags|(*TObject)(unsafe.Pointer(oPtr)).Fflags&int32(FILTER_HANDLING), callerObjPtr, callerClsPtr, methodNamePtr)
	v7 = mappedMethodName
	v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
	*(*TTcl_Size)(unsafe.Pointer(v7))--
	if !(v6 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(mappedMethodName)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(mappedMethodName)).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(mappedMethodName)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(mappedMethodName)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(mappedMethodName)).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(mappedMethodName)).Flength = int64(-libc.Int32FromInt32(1))
			if v8 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v8 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v8 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, mappedMethodName)
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(mappedMethodName + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = mappedMethodName
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, mappedMethodName)
		}
	}
	if contextPtr == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(methodNamePtr)).Fbytes != 0 {
			v9 = (*TTcl_Obj)(unsafe.Pointer(methodNamePtr)).Fbytes
		} else {
			v9 = XTcl_GetStringFromObj(tls, methodNamePtr, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+87588, libc.VaList(bp+24, v9)))
		if (*TTcl_Obj)(unsafe.Pointer(methodNamePtr)).Fbytes != 0 {
			v10 = (*TTcl_Obj)(unsafe.Pointer(methodNamePtr)).Fbytes
		} else {
			v10 = XTcl_GetStringFromObj(tls, methodNamePtr, libc.UintptrFromInt32(0))
		}
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+87658, v10, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	goto _2
_1:
	;
	/*
	 * Get the call chain.
	 */
	goto noMapping
noMapping:
	;
	contextPtr = XTclOOGetCallContext(tls, oPtr, methodNamePtr, flags|(*TObject)(unsafe.Pointer(oPtr)).Fflags&int32(FILTER_HANDLING), callerObjPtr, callerClsPtr, libc.UintptrFromInt32(0))
	if contextPtr == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(methodNamePtr)).Fbytes != 0 {
			v11 = (*TTcl_Obj)(unsafe.Pointer(methodNamePtr)).Fbytes
		} else {
			v11 = XTcl_GetStringFromObj(tls, methodNamePtr, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+87588, libc.VaList(bp+24, v11)))
		if (*TTcl_Obj)(unsafe.Pointer(methodNamePtr)).Fbytes != 0 {
			v12 = (*TTcl_Obj)(unsafe.Pointer(methodNamePtr)).Fbytes
		} else {
			v12 = XTcl_GetStringFromObj(tls, methodNamePtr, libc.UintptrFromInt32(0))
		}
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+28950, v12, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
_2:
	;
	/*
	 * Check to see if we need to apply magical tricks to start part way
	 * through the call chain.
	 */
	if *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
		for {
			if !((*TCallContext)(unsafe.Pointer(contextPtr)).Findex < (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).FnumChain) {
				break
			}
			miPtr = (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr((*TCallContext)(unsafe.Pointer(contextPtr)).Findex)*24
			if (*TMInvoke)(unsafe.Pointer(miPtr)).FisFilter != 0 {
				goto _13
			}
			if (*TMethod)(unsafe.Pointer((*TMInvoke)(unsafe.Pointer(miPtr)).FmPtr)).FdeclaringClassPtr == *(*uintptr)(unsafe.Pointer(bp)) {
				break
			}
			goto _13
		_13:
			;
			(*TCallContext)(unsafe.Pointer(contextPtr)).Findex++
		}
		if (*TCallContext)(unsafe.Pointer(contextPtr)).Findex >= (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).FnumChain {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+87672, int64(-libc.Int32FromInt32(1))))
			if (*TTcl_Obj)(unsafe.Pointer(methodNamePtr)).Fbytes != 0 {
				v14 = (*TTcl_Obj)(unsafe.Pointer(methodNamePtr)).Fbytes
			} else {
				v14 = XTcl_GetStringFromObj(tls, methodNamePtr, libc.UintptrFromInt32(0))
			}
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+28950, v14, libc.UintptrFromInt32(0)))
			XTclOODeleteContext(tls, contextPtr)
			return int32(TCL_ERROR)
		}
	}
	/*
	 * Invoke the call chain, locking the object structure against deletion
	 * for the duration.
	 */
	if v15 = interp == libc.UintptrFromInt32(0); !v15 {
		cachePtr2 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v15 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 8)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FprocPtr = __ccgo_fp(_FinalizeObjectCall)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8)) = contextPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
	return XTclOOInvokeContext(tls, contextPtr, interp, int32(objc), objv)
}

func _FinalizeObjectCall(tls *libc.TLS, data uintptr, dummy2851 uintptr, result int32) (r int32) {
	/*
	 * Dispose of the call chain, which drops the lock on the object's
	 * structure.
	 */
	XTclOODeleteContext(tls, *(*uintptr)(unsafe.Pointer(data)))
	return result
}

/*
 * ----------------------------------------------------------------------
 *
 * Tcl_ObjectContextInvokeNext, TclNRObjectContextInvokeNext, FinalizeNext --
 *
 *	Invokes the next stage of the call chain described in an object
 *	context. This is the core of the implementation of the [next] command.
 *	Does not do management of the call-frame stack. Available in public
 *	(standard API) and private (NRE-aware) forms. FinalizeNext is a
 *	private function used to clean up in the NRE case.
 *
 * ----------------------------------------------------------------------
 */

func XTcl_ObjectContextInvokeNext(tls *libc.TLS, interp uintptr, context TTcl_ObjectContext, objc TTcl_Size, objv uintptr, skip TTcl_Size) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var contextPtr, methodType uintptr
	var result int32
	var savedIndex, savedSkip Tsize_t
	_, _, _, _, _ = contextPtr, methodType, result, savedIndex, savedSkip
	contextPtr = context
	savedIndex = libc.Uint64FromInt64((*TCallContext)(unsafe.Pointer(contextPtr)).Findex)
	savedSkip = libc.Uint64FromInt64((*TCallContext)(unsafe.Pointer(contextPtr)).Fskip)
	if (*TCallContext)(unsafe.Pointer(contextPtr)).Findex+int64(1) >= (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).FnumChain {
		if XTcl_InterpDeleted(tls, interp) != 0 {
			return TCL_OK
		}
		if (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fflags&int32(CONSTRUCTOR) != 0 {
			methodType = __ccgo_ts + 28529
		} else {
			if (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fflags&int32(DESTRUCTOR) != 0 {
				methodType = __ccgo_ts + 28541
			} else {
				methodType = __ccgo_ts + 28559
			}
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+32626, libc.VaList(bp+8, methodType)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+32652, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Advance to the next method implementation in the chain in the method
	 * call context while we process the body. However, need to adjust the
	 * argument-skip control because we're guaranteed to have a single prefix
	 * arg (i.e., 'next') and not the variable amount that can happen because
	 * method invocations (i.e., '$obj meth' and 'my meth'), constructors
	 * (i.e., '$cls new' and '$cls create obj') and destructors (no args at
	 * all) come through the same code.
	 */
	(*TCallContext)(unsafe.Pointer(contextPtr)).Findex++
	(*TCallContext)(unsafe.Pointer(contextPtr)).Fskip = skip
	/*
	 * Invoke the (advanced) method call context in the caller context.
	 */
	result = XTcl_NRCallObjProc(tls, interp, __ccgo_fp(XTclOOInvokeContext), contextPtr, objc, objv)
	/*
	 * Restore the call chain context index as we've finished the inner invoke
	 * and want to operate in the outer context again.
	 */
	(*TCallContext)(unsafe.Pointer(contextPtr)).Findex = libc.Int64FromUint64(savedIndex)
	(*TCallContext)(unsafe.Pointer(contextPtr)).Fskip = libc.Int64FromUint64(savedSkip)
	return result
}

func XTclNRObjectContextInvokeNext(tls *libc.TLS, interp uintptr, context TTcl_ObjectContext, objc TTcl_Size, objv uintptr, skip TTcl_Size) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var _objPtr, cachePtr, contextPtr, methodType uintptr
	var v1 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _, _, _ = _objPtr, cachePtr, contextPtr, methodType, v1
	contextPtr = context
	if (*TCallContext)(unsafe.Pointer(contextPtr)).Findex+int64(1) >= (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).FnumChain {
		if XTcl_InterpDeleted(tls, interp) != 0 {
			return TCL_OK
		}
		if (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fflags&int32(CONSTRUCTOR) != 0 {
			methodType = __ccgo_ts + 28529
		} else {
			if (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fflags&int32(DESTRUCTOR) != 0 {
				methodType = __ccgo_ts + 28541
			} else {
				methodType = __ccgo_ts + 28559
			}
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+32626, libc.VaList(bp+16, methodType)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+32652, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Advance to the next method implementation in the chain in the method
	 * call context while we process the body. However, need to adjust the
	 * argument-skip control because we're guaranteed to have a single prefix
	 * arg (i.e., 'next') and not the variable amount that can happen because
	 * method invocations (i.e., '$obj meth' and 'my meth'), constructors
	 * (i.e., '$cls new' and '$cls create obj') and destructors (no args at
	 * all) come through the same code.
	 */
	if v1 = interp == libc.UintptrFromInt32(0); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(_FinalizeNext)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = contextPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = uintptr((*TCallContext)(unsafe.Pointer(contextPtr)).Findex)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = uintptr((*TCallContext)(unsafe.Pointer(contextPtr)).Fskip)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
	(*TCallContext)(unsafe.Pointer(contextPtr)).Findex++
	(*TCallContext)(unsafe.Pointer(contextPtr)).Fskip = skip
	/*
	 * Invoke the (advanced) method call context in the caller context.
	 */
	return XTclOOInvokeContext(tls, contextPtr, interp, int32(objc), objv)
}

func _FinalizeNext(tls *libc.TLS, data uintptr, dummy3012 uintptr, result int32) (r int32) {
	var contextPtr uintptr
	_ = contextPtr
	contextPtr = *(*uintptr)(unsafe.Pointer(data))
	/*
	 * Restore the call chain context index as we've finished the inner invoke
	 * and want to operate in the outer context again.
	 */
	(*TCallContext)(unsafe.Pointer(contextPtr)).Findex = int64(*(*uintptr)(unsafe.Pointer(data + 1*8)))
	(*TCallContext)(unsafe.Pointer(contextPtr)).Fskip = int64(*(*uintptr)(unsafe.Pointer(data + 2*8)))
	return result
}

/*
 * ----------------------------------------------------------------------
 *
 * Tcl_GetObjectFromObj --
 *
 *	Utility function to get an object from a Tcl_Obj containing its name.
 *
 * ----------------------------------------------------------------------
 */

func XTcl_GetObjectFromObj(tls *libc.TLS, interp uintptr, objPtr uintptr) (r TTcl_Object) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* The name of the object to look up, which is
	 * exactly the name of its public command. */
	var cmdPtr, v1, v2 uintptr
	_, _, _ = cmdPtr, v1, v2
	cmdPtr = XTcl_GetCommandFromObj(tls, interp, objPtr)
	if cmdPtr == libc.UintptrFromInt32(0) {
		goto notAnObject
	}
	if (*TCommand)(unsafe.Pointer(cmdPtr)).FobjProc != __ccgo_fp(XTclOOPublicObjectCmd) {
		cmdPtr = XTclGetOriginalCommand(tls, cmdPtr)
		if cmdPtr == libc.UintptrFromInt32(0) || (*TCommand)(unsafe.Pointer(cmdPtr)).FobjProc != __ccgo_fp(XTclOOPublicObjectCmd) {
			goto notAnObject
		}
	}
	return (*TCommand)(unsafe.Pointer(cmdPtr)).FobjClientData
	goto notAnObject
notAnObject:
	;
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
	}
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+87703, libc.VaList(bp+8, v1)))
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		v2 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		v2 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
	}
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+87734, v2, libc.UintptrFromInt32(0)))
	return libc.UintptrFromInt32(0)
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOIsReachable --
 *
 *	Utility function that tests whether a class is a subclass (whether
 *	directly or indirectly) of another class.
 *
 * ----------------------------------------------------------------------
 */

func XTclOOIsReachable(tls *libc.TLS, targetPtr uintptr, startPtr uintptr) (r int32) {
	var i TTcl_Size
	var superPtr uintptr
	_, _ = i, superPtr
	goto tailRecurse
tailRecurse:
	;
	if startPtr == targetPtr {
		return int32(1)
	}
	if (*TClass)(unsafe.Pointer(startPtr)).Fsuperclasses.Fnum == int64(1) && (*TClass)(unsafe.Pointer(startPtr)).Fmixins.Fnum == 0 {
		startPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(startPtr)).Fsuperclasses.Flist))
		goto tailRecurse
	}
	i = 0
	for {
		if !(i < (*TClass)(unsafe.Pointer(startPtr)).Fsuperclasses.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(startPtr)).Fsuperclasses.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _1
		} else {
			superPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(startPtr)).Fsuperclasses.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				if XTclOOIsReachable(tls, targetPtr, superPtr) != 0 {
					return int32(1)
				}
			}
		}
		goto _1
	_1:
		;
		i++
	}
	i = 0
	for {
		if !(i < (*TClass)(unsafe.Pointer(startPtr)).Fmixins.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(startPtr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _2
		} else {
			superPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(startPtr)).Fmixins.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				if XTclOOIsReachable(tls, targetPtr, superPtr) != 0 {
					return int32(1)
				}
			}
		}
		goto _2
	_2:
		;
		i++
	}
	return 0
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOObjectName, Tcl_GetObjectName --
 *
 *	Utility function that returns the name of the object. Note that this
 *	simplifies cache management by keeping the code to do it in one place
 *	and not sprayed all over. The value returned always has a reference
 *	count of at least one.
 *
 * ----------------------------------------------------------------------
 */

func XTclOOObjectName(tls *libc.TLS, interp uintptr, oPtr uintptr) (r uintptr) {
	var cachePtr, namePtr uintptr
	var v1 bool
	_, _, _ = cachePtr, namePtr, v1
	if (*TObject)(unsafe.Pointer(oPtr)).FcachedNameObj != 0 {
		return (*TObject)(unsafe.Pointer(oPtr)).FcachedNameObj
	}
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		namePtr = XTclThreadAllocObj(tls)
	} else {
		namePtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(namePtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(namePtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(namePtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(namePtr)).FtypePtr = libc.UintptrFromInt32(0)
	XTcl_GetCommandFullName(tls, interp, (*TObject)(unsafe.Pointer(oPtr)).Fcommand, namePtr)
	(*TTcl_Obj)(unsafe.Pointer(namePtr)).FrefCount++
	(*TObject)(unsafe.Pointer(oPtr)).FcachedNameObj = namePtr
	return namePtr
}

func XTcl_GetObjectName(tls *libc.TLS, interp uintptr, object TTcl_Object) (r uintptr) {
	return XTclOOObjectName(tls, interp, object)
}

/*
 * ----------------------------------------------------------------------
 *
 * assorted trivial 'getter' functions
 *
 * ----------------------------------------------------------------------
 */

func XTcl_ObjectContextMethod(tls *libc.TLS, context TTcl_ObjectContext) (r TTcl_Method) {
	var contextPtr uintptr
	_ = contextPtr
	contextPtr = context
	return (*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr((*TCallContext)(unsafe.Pointer(contextPtr)).Findex)*24))).FmPtr
}

func XTcl_ObjectContextIsFiltering(tls *libc.TLS, context TTcl_ObjectContext) (r int32) {
	var contextPtr uintptr
	_ = contextPtr
	contextPtr = context
	return (*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr((*TCallContext)(unsafe.Pointer(contextPtr)).Findex)*24))).FisFilter
}

func XTcl_ObjectContextObject(tls *libc.TLS, context TTcl_ObjectContext) (r TTcl_Object) {
	return (*TCallContext)(unsafe.Pointer(context)).FoPtr
}

func XTcl_ObjectContextSkippedArgs(tls *libc.TLS, context TTcl_ObjectContext) (r TTcl_Size) {
	return (*TCallContext)(unsafe.Pointer(context)).Fskip
}

func XTcl_GetObjectNamespace(tls *libc.TLS, object TTcl_Object) (r uintptr) {
	return (*TObject)(unsafe.Pointer(object)).FnamespacePtr
}

func XTcl_GetObjectCommand(tls *libc.TLS, object TTcl_Object) (r TTcl_Command) {
	return (*TObject)(unsafe.Pointer(object)).Fcommand
}

func XTcl_GetObjectAsClass(tls *libc.TLS, object TTcl_Object) (r TTcl_Class) {
	return (*TObject)(unsafe.Pointer(object)).FclassPtr
}

func XTcl_ObjectDeleted(tls *libc.TLS, object TTcl_Object) (r int32) {
	return libc.BoolInt32((*TObject)(unsafe.Pointer(object)).Fcommand == libc.UintptrFromInt32(0))
}

func XTcl_GetClassAsObject(tls *libc.TLS, clazz TTcl_Class) (r TTcl_Object) {
	return (*TClass)(unsafe.Pointer(clazz)).FthisPtr
}

func XTcl_ObjectGetMethodNameMapper(tls *libc.TLS, object TTcl_Object) (r uintptr) {
	return (*TObject)(unsafe.Pointer(object)).FmapMethodNameProc
}

func XTcl_ObjectSetMethodNameMapper(tls *libc.TLS, object TTcl_Object, mapMethodNameProc uintptr) {
	(*TObject)(unsafe.Pointer(object)).FmapMethodNameProc = mapMethodNameProc
}

func XTcl_GetClassOfObject(tls *libc.TLS, object TTcl_Object) (r TTcl_Class) {
	return (*TObject)(unsafe.Pointer(object)).FselfCls
}

func XTcl_GetObjectClassName(tls *libc.TLS, interp uintptr, object TTcl_Object) (r uintptr) {
	var classObj TTcl_Object
	_ = classObj
	classObj = (*TClass)(unsafe.Pointer((*TObject)(unsafe.Pointer(object)).FselfCls)).FthisPtr
	if classObj == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	return XTcl_GetObjectName(tls, interp, classObj)
}

const TCLOO_VERSION2 = "1.3"
const TCL_OO_METHOD_VERSION_CURRENT2 = 0

/*
 * ----------------------------------------------------------------------
 *
 * AddCreateCallback, FinalizeConstruction --
 *
 *	Special version of TclNRAddCallback that allows the caller to splice
 *	the object created later on. Always calls FinalizeConstruction, which
 *	converts the object into its name and stores that in the interpreter
 *	result. This is shared by all the construction methods (create,
 *	createWithNamespace, new).
 *
 *	Note that this is the only code in this file (or, indeed, the whole of
 *	TclOO) that uses NRE internals; it is the only code that does
 *	non-standard poking in the NRE guts.
 *
 * ----------------------------------------------------------------------
 */

func _AddConstructionFinalizer(tls *libc.TLS, interp uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, cachePtr uintptr
	var v1 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _ = _objPtr, cachePtr, v1
	if v1 = interp == libc.UintptrFromInt32(0); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(_FinalizeConstruction)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
	return (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr + 8
}

func _FinalizeConstruction(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	var oPtr uintptr
	_ = oPtr
	oPtr = *(*uintptr)(unsafe.Pointer(data))
	if result != TCL_OK {
		return result
	}
	XTcl_SetObjResult(tls, interp, XTclOOObjectName(tls, interp, oPtr))
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOO_Class_Constructor --
 *
 *	Implementation for oo::class constructor.
 *
 * ----------------------------------------------------------------------
 */

func XTclOO_Class_Constructor(tls *libc.TLS, dummy80 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _objPtr, _objPtr1, cachePtr, invoke, nameObj, oPtr, v1, v2, v4 uintptr
	var skip Tsize_t
	var v3 TTcl_Size
	var v5 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, invoke, nameObj, oPtr, skip, v1, v2, v3, v4, v5
	oPtr = XTcl_ObjectContextObject(tls, context)
	skip = libc.Uint64FromInt64(XTcl_ObjectContextSkippedArgs(tls, context))
	if libc.Uint64FromInt32(objc) > skip+uint64(1) {
		XTcl_WrongNumArgs(tls, interp, libc.Int64FromUint64(skip), objv, __ccgo_ts+87741)
		return int32(TCL_ERROR)
	}
	/*
	 * Make the class definition delegate. This is special; it doesn't reenter
	 * here (and the class definition delegate doesn't run any constructors).
	 *
	 * This needs to be done before consideration of whether to pass the script
	 * argument to [oo::define]. [Bug 680503]
	 */
	nameObj = XTcl_ObjPrintf(tls, __ccgo_ts+87760, libc.VaList(bp+16, (*TTcl_Namespace)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FnamespacePtr)).FfullName))
	if (*TTcl_Obj)(unsafe.Pointer(nameObj)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(nameObj)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, nameObj, libc.UintptrFromInt32(0))
	}
	XTcl_NewObjectInstance(tls, interp, (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FfPtr)).FclassCls, v1, libc.UintptrFromInt32(0), int64(-libc.Int32FromInt32(1)), libc.UintptrFromInt32(0), 0)
	v2 = nameObj
	if v2 != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(v2)).FrefCount == libc.Int64FromInt32(0) {
			_objPtr = v2
			v4 = _objPtr
			v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
			*(*TTcl_Size)(unsafe.Pointer(v4))--
			if v3 <= libc.Int64FromInt32(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
	}
	/*
	 * If there's nothing else to do, we're done.
	 */
	if libc.Uint64FromInt32(objc) == skip {
		return TCL_OK
	}
	/*
	 * Delegate to [oo::define] to do the work.
	 */
	invoke = XTclStackAlloc(tls, interp, libc.Uint64FromInt32(3)*libc.Uint64FromInt64(8))
	*(*uintptr)(unsafe.Pointer(invoke)) = (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FfPtr)).FdefineName
	*(*uintptr)(unsafe.Pointer(invoke + 1*8)) = XTclOOObjectName(tls, interp, oPtr)
	*(*uintptr)(unsafe.Pointer(invoke + 2*8)) = *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8))
	/*
	 * Must add references or errors in configuration script will cause
	 * trouble.
	 */
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke)))).FrefCount++
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke + 1*8)))).FrefCount++
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke + 2*8)))).FrefCount++
	if v5 = interp == libc.UintptrFromInt32(0); !v5 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v5 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr1 = XTclThreadAllocObj(tls)
	} else {
		_objPtr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr1 + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp)) = _objPtr1
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(_DecrRefsPostClassConstructor)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = invoke
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = oPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
	/*
	 * Tricky point: do not want the extra reported level in the Tcl stack
	 * trace, so use TCL_EVAL_NOERR.
	 */
	return XTclNREvalObjv(tls, interp, int64(3), invoke, int32(TCL_EVAL_NOERR), libc.UintptrFromInt32(0))
}

func _DecrRefsPostClassConstructor(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	var cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, invoke, oPtr, v11, v14, v2, v5, v8 uintptr
	var code int32
	var saved TTcl_InterpState
	var v1, v10, v13, v4, v7 TTcl_Size
	var v12, v15, v3, v6, v9 bool
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, cachePtr1, cachePtr2, cachePtr3, cachePtr4, code, invoke, oPtr, saved, v1, v10, v11, v12, v13, v14, v15, v2, v3, v4, v5, v6, v7, v8, v9
	invoke = *(*uintptr)(unsafe.Pointer(data))
	oPtr = *(*uintptr)(unsafe.Pointer(data + 1*8))
	v2 = *(*uintptr)(unsafe.Pointer(invoke))
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if !(v1 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke)))).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke)))).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke)))).Flength = int64(-libc.Int32FromInt32(1))
			if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(invoke)))
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(invoke))
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(invoke)))
		}
	}
	v5 = *(*uintptr)(unsafe.Pointer(invoke + 1*8))
	v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
	*(*TTcl_Size)(unsafe.Pointer(v5))--
	if !(v4 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke + 1*8)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke + 1*8)))).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke + 1*8)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke + 1*8)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke + 1*8)))).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke + 1*8)))).Flength = int64(-libc.Int32FromInt32(1))
			if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v6 || ((*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(invoke + 1*8)))
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke + 1*8)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(invoke + 1*8))
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(invoke + 1*8)))
		}
	}
	v8 = *(*uintptr)(unsafe.Pointer(invoke + 2*8))
	v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
	*(*TTcl_Size)(unsafe.Pointer(v8))--
	if !(v7 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke + 2*8)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke + 2*8)))).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke + 2*8)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke + 2*8)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke + 2*8)))).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke + 2*8)))).Flength = int64(-libc.Int32FromInt32(1))
			if v9 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v9 {
				cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v9 || ((*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(invoke + 2*8)))
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke + 2*8)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(invoke + 2*8))
				(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(invoke + 2*8)))
		}
	}
	*(*uintptr)(unsafe.Pointer(invoke)) = (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FfPtr)).FmcdName
	*(*uintptr)(unsafe.Pointer(invoke + 1*8)) = XTclOOObjectName(tls, interp, oPtr)
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke)))).FrefCount++
	(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke + 1*8)))).FrefCount++
	saved = XTcl_SaveInterpState(tls, interp, result)
	code = XTcl_EvalObjv(tls, interp, int64(2), invoke, 0)
	v11 = *(*uintptr)(unsafe.Pointer(invoke))
	v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
	*(*TTcl_Size)(unsafe.Pointer(v11))--
	if !(v10 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke)))).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke)))).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke)))).Flength = int64(-libc.Int32FromInt32(1))
			if v12 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v12 {
				cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v12 || ((*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(invoke)))
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(invoke))
				(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(invoke)))
		}
	}
	v14 = *(*uintptr)(unsafe.Pointer(invoke + 1*8))
	v13 = *(*TTcl_Size)(unsafe.Pointer(v14))
	*(*TTcl_Size)(unsafe.Pointer(v14))--
	if !(v13 > int64(1)) {
		if !((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke + 1*8)))).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke + 1*8)))).FtypePtr)).FfreeIntRepProc != 0) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke + 1*8)))).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke + 1*8)))).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
				XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke + 1*8)))).Fbytes)
			}
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke + 1*8)))).Flength = int64(-libc.Int32FromInt32(1))
			if v15 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v15 {
				cachePtr4 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v15 || ((*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
				XTclThreadFreeObj(tls, *(*uintptr)(unsafe.Pointer(invoke + 1*8)))
			} else {
				(*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(invoke + 1*8)) + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr4)).FfirstObjPtr = *(*uintptr)(unsafe.Pointer(invoke + 1*8))
				(*TAllocCache)(unsafe.Pointer(cachePtr4)).FnumObjects++
			}
		} else {
			XTclFreeObj(tls, *(*uintptr)(unsafe.Pointer(invoke + 1*8)))
		}
	}
	XTclStackFree(tls, interp, invoke)
	if code != TCL_OK {
		XTcl_DiscardInterpState(tls, saved)
		return code
	}
	return XTcl_RestoreInterpState(tls, interp, saved)
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOO_Class_Create --
 *
 *	Implementation for oo::class->create method.
 *
 * ----------------------------------------------------------------------
 */

func XTclOO_Class_Create(tls *libc.TLS, dummy188 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* The actual arguments. */
	var cmdnameObj, oPtr, objName, v1 uintptr
	var _ /* len at bp+0 */ TTcl_Size
	_, _, _, _ = cmdnameObj, oPtr, objName, v1
	oPtr = XTcl_ObjectContextObject(tls, context)
	/*
	 * Sanity check; should not be possible to invoke this method on a
	 * non-class.
	 */
	if (*TObject)(unsafe.Pointer(oPtr)).FclassPtr == libc.UintptrFromInt32(0) {
		cmdnameObj = XTclOOObjectName(tls, interp, oPtr)
		if (*TTcl_Obj)(unsafe.Pointer(cmdnameObj)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(cmdnameObj)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, cmdnameObj, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+87779, libc.VaList(bp+16, v1)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+87806, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Check we have the right number of (sensible) arguments.
	 */
	if int64(objc) < int64(1)+XTcl_ObjectContextSkippedArgs(tls, context) {
		XTcl_WrongNumArgs(tls, interp, XTcl_ObjectContextSkippedArgs(tls, context), objv, __ccgo_ts+87827)
		return int32(TCL_ERROR)
	}
	objName = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(XTcl_ObjectContextSkippedArgs(tls, context))*8)), bp)
	if *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+87848, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+87878, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Make the object and return its name.
	 */
	return XTclNRNewObjectInstance(tls, interp, (*TObject)(unsafe.Pointer(oPtr)).FclassPtr, objName, libc.UintptrFromInt32(0), int64(objc), objv, XTcl_ObjectContextSkippedArgs(tls, context)+int64(1), _AddConstructionFinalizer(tls, interp))
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOO_Class_CreateNs --
 *
 *	Implementation for oo::class->createWithNamespace method.
 *
 * ----------------------------------------------------------------------
 */

func XTclOO_Class_CreateNs(tls *libc.TLS, dummy253 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* The actual arguments. */
	var cmdnameObj, nsName, oPtr, objName, v1 uintptr
	var _ /* len at bp+0 */ TTcl_Size
	_, _, _, _, _ = cmdnameObj, nsName, oPtr, objName, v1
	oPtr = XTcl_ObjectContextObject(tls, context)
	/*
	 * Sanity check; should not be possible to invoke this method on a
	 * non-class.
	 */
	if (*TObject)(unsafe.Pointer(oPtr)).FclassPtr == libc.UintptrFromInt32(0) {
		cmdnameObj = XTclOOObjectName(tls, interp, oPtr)
		if (*TTcl_Obj)(unsafe.Pointer(cmdnameObj)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(cmdnameObj)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, cmdnameObj, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+87779, libc.VaList(bp+16, v1)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+87806, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Check we have the right number of (sensible) arguments.
	 */
	if int64(objc+int32(1)) < XTcl_ObjectContextSkippedArgs(tls, context)+int64(3) {
		XTcl_WrongNumArgs(tls, interp, XTcl_ObjectContextSkippedArgs(tls, context), objv, __ccgo_ts+87889)
		return int32(TCL_ERROR)
	}
	objName = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(XTcl_ObjectContextSkippedArgs(tls, context))*8)), bp)
	if *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+87848, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+87878, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	nsName = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(XTcl_ObjectContextSkippedArgs(tls, context)+int64(1))*8)), bp)
	if *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+87924, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+87878, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Make the object and return its name.
	 */
	return XTclNRNewObjectInstance(tls, interp, (*TObject)(unsafe.Pointer(oPtr)).FclassPtr, objName, nsName, int64(objc), objv, XTcl_ObjectContextSkippedArgs(tls, context)+int64(2), _AddConstructionFinalizer(tls, interp))
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOO_Class_New --
 *
 *	Implementation for oo::class->new method.
 *
 * ----------------------------------------------------------------------
 */

func XTclOO_Class_New(tls *libc.TLS, dummy326 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* The actual arguments. */
	var cmdnameObj, oPtr, v1 uintptr
	_, _, _ = cmdnameObj, oPtr, v1
	oPtr = XTcl_ObjectContextObject(tls, context)
	/*
	 * Sanity check; should not be possible to invoke this method on a
	 * non-class.
	 */
	if (*TObject)(unsafe.Pointer(oPtr)).FclassPtr == libc.UintptrFromInt32(0) {
		cmdnameObj = XTclOOObjectName(tls, interp, oPtr)
		if (*TTcl_Obj)(unsafe.Pointer(cmdnameObj)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(cmdnameObj)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, cmdnameObj, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+87779, libc.VaList(bp+8, v1)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+87806, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Make the object and return its name.
	 */
	return XTclNRNewObjectInstance(tls, interp, (*TObject)(unsafe.Pointer(oPtr)).FclassPtr, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), int64(objc), objv, XTcl_ObjectContextSkippedArgs(tls, context), _AddConstructionFinalizer(tls, interp))
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOO_Object_Destroy --
 *
 *	Implementation for oo::object->destroy method.
 *
 * ----------------------------------------------------------------------
 */

func XTclOO_Object_Destroy(tls *libc.TLS, dummy370 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The actual arguments. */
	var _objPtr, cachePtr, contextPtr, oPtr uintptr
	var v1 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _, _, _ = _objPtr, cachePtr, contextPtr, oPtr, v1
	oPtr = XTcl_ObjectContextObject(tls, context)
	if objc != int32(XTcl_ObjectContextSkippedArgs(tls, context)) {
		XTcl_WrongNumArgs(tls, interp, XTcl_ObjectContextSkippedArgs(tls, context), objv, libc.UintptrFromInt32(0))
		return int32(TCL_ERROR)
	}
	if !((*TObject)(unsafe.Pointer(oPtr)).Fflags&int32(DESTRUCTOR_CALLED) != 0) {
		*(*int32)(unsafe.Pointer(oPtr + 96)) |= int32(DESTRUCTOR_CALLED)
		contextPtr = XTclOOGetCallContext(tls, oPtr, libc.UintptrFromInt32(0), int32(DESTRUCTOR), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
		if contextPtr != libc.UintptrFromInt32(0) {
			*(*int32)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr + 24)) |= int32(DESTRUCTOR)
			(*TCallContext)(unsafe.Pointer(contextPtr)).Fskip = 0
			if v1 = interp == libc.UintptrFromInt32(0); !v1 {
				cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
			}
			if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				_objPtr = XTclThreadAllocObj(tls)
			} else {
				_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(_objPtr + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
			(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(_AfterNRDestructor)
			*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = contextPtr
			*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
			*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
			*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
			(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
			(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
			XTclPushTailcallPoint(tls, interp)
			return XTclOOInvokeContext(tls, contextPtr, interp, 0, libc.UintptrFromInt32(0))
		}
	}
	if (*TObject)(unsafe.Pointer(oPtr)).Fcommand != 0 {
		XTcl_DeleteCommandFromToken(tls, interp, (*TObject)(unsafe.Pointer(oPtr)).Fcommand)
	}
	return TCL_OK
}

func _AfterNRDestructor(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	var contextPtr uintptr
	_ = contextPtr
	contextPtr = *(*uintptr)(unsafe.Pointer(data))
	if (*TObject)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr)).Fcommand != 0 {
		XTcl_DeleteCommandFromToken(tls, interp, (*TObject)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr)).Fcommand)
	}
	XTclOODeleteContext(tls, contextPtr)
	return result
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOO_Object_Eval --
 *
 *	Implementation for oo::object->eval method.
 *
 * ----------------------------------------------------------------------
 */

func XTclOO_Object_Eval(tls *libc.TLS, dummy431 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The actual arguments. */
	var _objPtr, cachePtr, contextPtr, framePtrPtr, invoker, scriptPtr uintptr
	var object TTcl_Object
	var skip Tsize_t
	var v1 bool
	var _ /* _callbackPtr at bp+8 */ uintptr
	var _ /* framePtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, contextPtr, framePtrPtr, invoker, object, scriptPtr, skip, v1
	contextPtr = context
	object = XTcl_ObjectContextObject(tls, context)
	skip = libc.Uint64FromInt64(XTcl_ObjectContextSkippedArgs(tls, context))
	framePtrPtr = bp
	if libc.Uint64FromInt32(objc) < skip+uint64(1) {
		XTcl_WrongNumArgs(tls, interp, libc.Int64FromUint64(skip), objv, __ccgo_ts+15269)
		return int32(TCL_ERROR)
	}
	/*
	 * Make the object's namespace the current namespace and evaluate the
	 * command(s).
	 */
	XTclPushStackFrame(tls, interp, framePtrPtr, XTcl_GetObjectNamespace(tls, object), int32(FRAME_IS_METHOD))
	(*TCallFrame)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FclientData = context
	(*TCallFrame)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fobjc = int64(objc)
	(*TCallFrame)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fobjv = objv /* Reference counts do not need to be
	 * incremented here. */
	if !((*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fflags&int32(PUBLIC_METHOD) != 0) {
		object = libc.UintptrFromInt32(0) /* Now just for error mesage printing. */
	}
	/*
	 * Work out what script we are actually going to evaluate.
	 *
	 * When there's more than one argument, we concatenate them together with
	 * spaces between, then evaluate the result. Tcl_EvalObjEx will delete the
	 * object when it decrements its refcount after eval'ing it.
	 */
	if libc.Uint64FromInt32(objc) != skip+uint64(1) {
		scriptPtr = XTcl_ConcatObj(tls, libc.Int64FromUint64(libc.Uint64FromInt32(objc)-skip), objv+uintptr(skip)*8)
		invoker = libc.UintptrFromInt32(0)
	} else {
		scriptPtr = *(*uintptr)(unsafe.Pointer(objv + uintptr(skip)*8))
		invoker = (*TInterp)(unsafe.Pointer(interp)).FcmdFramePtr
	}
	/*
	 * Evaluate the script now, with FinalizeEval to do the processing after
	 * the script completes.
	 */
	if v1 = interp == libc.UintptrFromInt32(0); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 8)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FprocPtr = __ccgo_fp(_FinalizeEval)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8)) = object
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
	return XTclNREvalObjEx(tls, interp, scriptPtr, 0, invoker, libc.Int32FromUint64(skip))
}

func _FinalizeEval(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var namePtr, oPtr, v1 uintptr
	_, _, _ = namePtr, oPtr, v1
	if result == int32(TCL_ERROR) {
		oPtr = *(*uintptr)(unsafe.Pointer(data))
		if oPtr != 0 {
			if (*TTcl_Obj)(unsafe.Pointer(XTclOOObjectName(tls, interp, oPtr))).Fbytes != 0 {
				v1 = (*TTcl_Obj)(unsafe.Pointer(XTclOOObjectName(tls, interp, oPtr))).Fbytes
			} else {
				v1 = XTcl_GetStringFromObj(tls, XTclOOObjectName(tls, interp, oPtr), libc.UintptrFromInt32(0))
			}
			namePtr = v1
		} else {
			namePtr = __ccgo_ts + 87001
		}
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+87957, libc.VaList(bp+8, namePtr, XTcl_GetErrorLine(tls, interp))))
	}
	/*
	 * Restore the previous "current" namespace.
	 */
	XTclPopStackFrame(tls, interp)
	return result
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOO_Object_Unknown --
 *
 *	Default unknown method handler method (defined in oo::object). This
 *	just creates a suitable error message.
 *
 * ----------------------------------------------------------------------
 */

func XTclOO_Object_Unknown(tls *libc.TLS, dummy533 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* The actual arguments. */
	var callerCls, callerContext, callerObj, contextPtr, errorMsg, framePtr, mPtr, oPtr, piece, tmpBuf, v1, v2, v3, v5 uintptr
	var i, numMethodNames int32
	var skip Tsize_t
	var _ /* methodNames at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = callerCls, callerContext, callerObj, contextPtr, errorMsg, framePtr, i, mPtr, numMethodNames, oPtr, piece, skip, tmpBuf, v1, v2, v3, v5
	contextPtr = context
	callerObj = libc.UintptrFromInt32(0)
	callerCls = libc.UintptrFromInt32(0)
	oPtr = (*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr
	skip = libc.Uint64FromInt64(XTcl_ObjectContextSkippedArgs(tls, context))
	framePtr = (*TInterp)(unsafe.Pointer(interp)).FvarFramePtr
	/*
	 * If no method name, generate an error asking for a method name. (Only by
	 * overriding *this* method can an object handle the absence of a method
	 * name without an error).
	 */
	if libc.Uint64FromInt32(objc) < skip+uint64(1) {
		XTcl_WrongNumArgs(tls, interp, libc.Int64FromUint64(skip), objv, __ccgo_ts+87992)
		return int32(TCL_ERROR)
	}
	/*
	 * Determine if the calling context should know about extra private
	 * methods, and if so, which.
	 */
	if (*TCallFrame)(unsafe.Pointer(framePtr)).FisProcCallFrame&int32(FRAME_IS_METHOD) != 0 {
		callerContext = (*TCallFrame)(unsafe.Pointer(framePtr)).FclientData
		mPtr = (*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(callerContext)).FcallPtr)).Fchain + uintptr((*TCallContext)(unsafe.Pointer(callerContext)).Findex)*24))).FmPtr
		if (*TMethod)(unsafe.Pointer(mPtr)).FdeclaringObjectPtr != 0 {
			if oPtr == (*TMethod)(unsafe.Pointer(mPtr)).FdeclaringObjectPtr {
				callerObj = (*TMethod)(unsafe.Pointer(mPtr)).FdeclaringObjectPtr
			}
		} else {
			if XTclOOIsReachable(tls, (*TMethod)(unsafe.Pointer(mPtr)).FdeclaringClassPtr, (*TObject)(unsafe.Pointer(oPtr)).FselfCls) != 0 {
				callerCls = (*TMethod)(unsafe.Pointer(mPtr)).FdeclaringClassPtr
			}
		}
	}
	/*
	 * Get the list of methods that we want to know about.
	 */
	numMethodNames = XTclOOGetSortedMethodList(tls, oPtr, callerObj, callerCls, (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fflags&int32(PUBLIC_METHOD), bp)
	/*
	 * Special message when there are no visible methods at all.
	 */
	if numMethodNames == 0 {
		tmpBuf = XTclOOObjectName(tls, interp, oPtr)
		if (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fflags&int32(PUBLIC_METHOD) != 0 {
			piece = __ccgo_ts + 88009
		} else {
			piece = __ccgo_ts + 88025
		}
		if (*TTcl_Obj)(unsafe.Pointer(tmpBuf)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(tmpBuf)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, tmpBuf, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+88033, libc.VaList(bp+16, v1, piece)))
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(skip)*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(skip)*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(skip)*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+28950, v2, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(skip)*8)))).Fbytes != 0 {
		v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(skip)*8)))).Fbytes
	} else {
		v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(skip)*8)), libc.UintptrFromInt32(0))
	}
	errorMsg = XTcl_ObjPrintf(tls, __ccgo_ts+88055, libc.VaList(bp+16, v3))
	i = 0
	for {
		if !(i < numMethodNames-int32(1)) {
			break
		}
		if i != 0 {
			XTcl_AppendToObj(tls, errorMsg, __ccgo_ts+21617, int64(-libc.Int32FromInt32(1)))
		}
		XTcl_AppendToObj(tls, errorMsg, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(i)*8)), int64(-libc.Int32FromInt32(1)))
		goto _4
	_4:
		;
		i++
	}
	if i != 0 {
		XTcl_AppendToObj(tls, errorMsg, __ccgo_ts+29437, int64(-libc.Int32FromInt32(1)))
	}
	XTcl_AppendToObj(tls, errorMsg, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(i)*8)), int64(-libc.Int32FromInt32(1)))
	XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp)))
	XTcl_SetObjResult(tls, interp, errorMsg)
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(skip)*8)))).Fbytes != 0 {
		v5 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(skip)*8)))).Fbytes
	} else {
		v5 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(skip)*8)), libc.UintptrFromInt32(0))
	}
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+28950, v5, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOO_Object_LinkVar --
 *
 *	Implementation of oo::object->variable method.
 *
 * ----------------------------------------------------------------------
 */

func XTclOO_Object_LinkVar(tls *libc.TLS, dummy640 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* The actual arguments. */
	var i TTcl_Size
	var iPtr, savedNsPtr, varName, varPtr, v2 uintptr
	var object TTcl_Object
	var _ /* aryPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _ = i, iPtr, object, savedNsPtr, varName, varPtr, v2
	iPtr = interp
	object = XTcl_ObjectContextObject(tls, context)
	if int64(objc) < XTcl_ObjectContextSkippedArgs(tls, context) {
		XTcl_WrongNumArgs(tls, interp, XTcl_ObjectContextSkippedArgs(tls, context), objv, __ccgo_ts+88085)
		return int32(TCL_ERROR)
	}
	/*
	 * A sanity check. Shouldn't ever happen. (This is all that remains of a
	 * more complex check inherited from [global] after we have applied the
	 * fix for [Bug 2903811]; note that the fix involved *removing* code.)
	 */
	if (*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr == libc.UintptrFromInt32(0) {
		return TCL_OK
	}
	i = XTcl_ObjectContextSkippedArgs(tls, context)
	for {
		if !(i < int64(objc)) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		varName = v2
		/*
		 * The variable name must not contain a '::' since that's illegal in
		 * local names.
		 */
		if libc.Xstrstr(tls, varName, __ccgo_ts+7650) != libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+88099, libc.VaList(bp+16, varName)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+69514, __ccgo_ts+69520, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		/*
		 * Switch to the object's namespace for the duration of this call.
		 * Like this, the variable is looked up in the namespace of the
		 * object, and not in the namespace of the caller. Otherwise this
		 * would only work if the caller was a method of the object itself,
		 * which might not be true if the method was exported. This is a bit
		 * of a hack, but the simplest way to do this (pushing a stack frame
		 * would be horribly expensive by comparison).
		 */
		savedNsPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FnsPtr
		(*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FnsPtr = XTcl_GetObjectNamespace(tls, object)
		varPtr = XTclObjLookupVar(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0), int32(TCL_NAMESPACE_ONLY), __ccgo_ts+69824, int32(1), 0, bp)
		(*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FnsPtr = savedNsPtr
		if varPtr == libc.UintptrFromInt32(0) || *(*uintptr)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
			/*
			 * Variable cannot be an element in an array. If aryPtr is not
			 * NULL, it is an element, so throw up an error and return.
			 */
			XTclVarErrMsg(tls, interp, varName, libc.UintptrFromInt32(0), __ccgo_ts+69824, __ccgo_ts+32187)
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+69514, __ccgo_ts+69671, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		/*
		 * Arrange for the lifetime of the variable to be correctly managed.
		 * This is copied out of Tcl_VariableObjCmd...
		 */
		if !((*TVar)(unsafe.Pointer(varPtr)).Fflags&libc.Int32FromInt32(VAR_NAMESPACE_VAR) != 0) {
			if !((*TVar)(unsafe.Pointer(varPtr)).Fflags&libc.Int32FromInt32(VAR_NAMESPACE_VAR) != 0) {
				*(*int32)(unsafe.Pointer(varPtr)) |= int32(VAR_NAMESPACE_VAR)
				if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
					(*TVarInHash)(unsafe.Pointer(varPtr)).FrefCount++
				}
			}
		}
		if XTclPtrMakeUpvar(tls, interp, varPtr, varName, 0, -int32(1)) != TCL_OK {
			return int32(TCL_ERROR)
		}
		goto _1
	_1:
		;
		i++
	}
	return TCL_OK
}

// C documentation
//
//	/*
//	 * ----------------------------------------------------------------------
//	 *
//	 * TclOOLookupObjectVar --
//	 *
//	 *	Look up a variable in an object. Tricky because of private variables.
//	 *
//	 * Returns:
//	 *	Handle to the variable if it can be found, or NULL if there's an error.
//	 *
//	 * ----------------------------------------------------------------------
//	 */
func XTclOOLookupObjectVar(tls *libc.TLS, interp uintptr, object TTcl_Object, varName uintptr, aryPtr uintptr) (r TTcl_Var) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Where to write the handle to the array
	 * containing the element; if not an element,
	 * then the variable this points to is set to
	 * NULL. */
	var _objPtr, arg, callerContext, clsPtr, framePtr, mPtr, mixinCls, namespacePtr, oPtr, pvPtr, varNamePtr, v1, v5, v7 uintptr
	var i, v6 TTcl_Size
	var isInstance int32
	var var1 TTcl_Var
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, arg, callerContext, clsPtr, framePtr, i, isInstance, mPtr, mixinCls, namespacePtr, oPtr, pvPtr, var1, varNamePtr, v1, v5, v6, v7
	if (*TTcl_Obj)(unsafe.Pointer(varName)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(varName)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, varName, libc.UintptrFromInt32(0))
	}
	arg = v1
	/*
	 * Convert the variable name to fully-qualified form if it wasn't already.
	 * This has to be done prior to lookup because we can run into problems
	 * with resolvers otherwise. [Bug 3603695]
	 *
	 * We still need to do the lookup; the variable could be linked to another
	 * variable and we want the target's name.
	 */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(arg))) == int32(':') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(arg + 1))) == int32(':') {
		varNamePtr = varName
	} else {
		namespacePtr = XTcl_GetObjectNamespace(tls, object)
		framePtr = (*TInterp)(unsafe.Pointer(interp)).FvarFramePtr
		/*
		 * Private method handling. [TIP 500]
		 *
		 * If we're in a context that can see some private methods of an
		 * object, we may need to precede a variable name with its prefix.
		 * This is a little tricky as we need to check through the inheritance
		 * hierarchy when the method was declared by a class to see if the
		 * current object is an instance of that class.
		 */
		if (*TCallFrame)(unsafe.Pointer(framePtr)).FisProcCallFrame&int32(FRAME_IS_METHOD) != 0 {
			oPtr = object
			callerContext = (*TCallFrame)(unsafe.Pointer(framePtr)).FclientData
			mPtr = (*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(callerContext)).FcallPtr)).Fchain + uintptr((*TCallContext)(unsafe.Pointer(callerContext)).Findex)*24))).FmPtr
			if (*TMethod)(unsafe.Pointer(mPtr)).FdeclaringObjectPtr == oPtr {
				i = 0
				if (*TObject)(unsafe.Pointer(oPtr)).FprivateVariables.Fnum > libc.Int64FromInt32(0) {
					for {
						pvPtr = (*TObject)(unsafe.Pointer(oPtr)).FprivateVariables.Flist + uintptr(i)*16
						if !(i < (*TObject)(unsafe.Pointer(oPtr)).FprivateVariables.Fnum) {
							break
						}
						if !(XTclStringCmp(tls, (*TPrivateVariableMapping)(unsafe.Pointer(pvPtr)).FvariableObj, varName, int32(1), 0, int64(-libc.Int32FromInt32(1))) != 0) {
							varName = (*TPrivateVariableMapping)(unsafe.Pointer(pvPtr)).FfullNameObj
							break
						}
						goto _2
					_2:
						;
						i++
					}
				}
			} else {
				if (*TMethod)(unsafe.Pointer(mPtr)).FdeclaringClassPtr != 0 && (*TClass)(unsafe.Pointer((*TMethod)(unsafe.Pointer(mPtr)).FdeclaringClassPtr)).FprivateVariables.Fnum != 0 {
					clsPtr = (*TMethod)(unsafe.Pointer(mPtr)).FdeclaringClassPtr
					isInstance = XTclOOIsReachable(tls, clsPtr, (*TObject)(unsafe.Pointer(oPtr)).FselfCls)
					if !(isInstance != 0) {
						i = 0
						for {
							if !(i < (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Fnum) {
								break
							}
							if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
								goto _3
							} else {
								mixinCls = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8))
								if libc.Int32FromInt32(1) != 0 {
									if XTclOOIsReachable(tls, clsPtr, mixinCls) != 0 {
										isInstance = int32(1)
										break
									}
								}
							}
							goto _3
						_3:
							;
							i++
						}
					}
					if isInstance != 0 {
						i = 0
						if (*TClass)(unsafe.Pointer(clsPtr)).FprivateVariables.Fnum > libc.Int64FromInt32(0) {
							for {
								pvPtr = (*TClass)(unsafe.Pointer(clsPtr)).FprivateVariables.Flist + uintptr(i)*16
								if !(i < (*TClass)(unsafe.Pointer(clsPtr)).FprivateVariables.Fnum) {
									break
								}
								if !(XTclStringCmp(tls, (*TPrivateVariableMapping)(unsafe.Pointer(pvPtr)).FvariableObj, varName, int32(1), 0, int64(-libc.Int32FromInt32(1))) != 0) {
									varName = (*TPrivateVariableMapping)(unsafe.Pointer(pvPtr)).FfullNameObj
									break
								}
								goto _4
							_4:
								;
								i++
							}
						}
					}
				}
			}
		}
		// The namespace isn't the global one; necessarily true for any object!
		if (*TTcl_Obj)(unsafe.Pointer(varName)).Fbytes != 0 {
			v5 = (*TTcl_Obj)(unsafe.Pointer(varName)).Fbytes
		} else {
			v5 = XTcl_GetStringFromObj(tls, varName, libc.UintptrFromInt32(0))
		}
		varNamePtr = XTcl_ObjPrintf(tls, __ccgo_ts+88164, libc.VaList(bp+8, (*TTcl_Namespace)(unsafe.Pointer(namespacePtr)).FfullName, v5))
	}
	(*TTcl_Obj)(unsafe.Pointer(varNamePtr)).FrefCount++
	var1 = XTclObjLookupVar(tls, interp, varNamePtr, libc.UintptrFromInt32(0), libc.Int32FromInt32(TCL_NAMESPACE_ONLY)|libc.Int32FromInt32(TCL_LEAVE_ERR_MSG), __ccgo_ts+88171, int32(1), int32(1), aryPtr)
	_objPtr = varNamePtr
	v7 = _objPtr
	v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
	*(*TTcl_Size)(unsafe.Pointer(v7))--
	if v6 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	if var1 == libc.UintptrFromInt32(0) {
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+17108, arg, libc.UintptrFromInt32(0)))
	} else {
		if *(*TTcl_Var)(unsafe.Pointer(aryPtr)) == libc.UintptrFromInt32(0) && (*TVar)(unsafe.Pointer(var1)).Fflags&int32(VAR_ARRAY_ELEMENT) != 0 {
			/*
			 * If the varPtr points to an element of an array but we don't already
			 * have the array, find it now. Note that this can't be easily
			 * backported; the arrayPtr field is new in Tcl 9.0. [Bug 2da1cb0c80]
			 */
			*(*TTcl_Var)(unsafe.Pointer(aryPtr)) = (*TTclVarHashTable)(unsafe.Pointer((*TVarInHash)(unsafe.Pointer(var1)).Fentry.FtablePtr)).FarrayPtr
		}
	}
	return var1
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOO_Object_VarName --
 *
 *	Implementation of the oo::object->varname method.
 *
 * ----------------------------------------------------------------------
 */

func XTclOO_Object_VarName(tls *libc.TLS, dummy857 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* The actual arguments. */
	var cachePtr, varNamePtr uintptr
	var varPtr TTcl_Var
	var v1 bool
	var _ /* aryVar at bp+0 */ TTcl_Var
	_, _, _, _ = cachePtr, varNamePtr, varPtr, v1
	if int32(XTcl_ObjectContextSkippedArgs(tls, context))+int32(1) != objc {
		XTcl_WrongNumArgs(tls, interp, XTcl_ObjectContextSkippedArgs(tls, context), objv, __ccgo_ts+16508)
		return int32(TCL_ERROR)
	}
	varPtr = XTclOOLookupObjectVar(tls, interp, XTcl_ObjectContextObject(tls, context), *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), bp)
	if varPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * The variable reference must not disappear too soon. [Bug 74b6110204]
	 */
	if !((*TVar)(unsafe.Pointer(varPtr)).Fflags&libc.Int32FromInt32(VAR_ARRAY_ELEMENT) != 0) {
		if !((*TVar)(unsafe.Pointer(varPtr)).Fflags&libc.Int32FromInt32(VAR_NAMESPACE_VAR) != 0) {
			*(*int32)(unsafe.Pointer(varPtr)) |= int32(VAR_NAMESPACE_VAR)
			if (*TVar)(unsafe.Pointer(varPtr)).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
				(*TVarInHash)(unsafe.Pointer(varPtr)).FrefCount++
			}
		}
	}
	/*
	 * Now that we've pinned down what variable we're really talking about
	 * (including traversing variable links), convert back to a name.
	 */
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		varNamePtr = XTclThreadAllocObj(tls)
	} else {
		varNamePtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(varNamePtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(varNamePtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(varNamePtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(varNamePtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(varNamePtr)).FtypePtr = libc.UintptrFromInt32(0)
	if *(*TTcl_Var)(unsafe.Pointer(bp)) != libc.UintptrFromInt32(0) {
		XTcl_GetVariableFullName(tls, interp, *(*TTcl_Var)(unsafe.Pointer(bp)), varNamePtr)
		XTcl_AppendPrintfToObj(tls, varNamePtr, __ccgo_ts+88180, libc.VaList(bp+16, XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(varPtr + 24 + 32)), libc.UintptrFromInt32(0))))
	} else {
		XTcl_GetVariableFullName(tls, interp, varPtr, varNamePtr)
	}
	XTcl_SetObjResult(tls, interp, varNamePtr)
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOONextObjCmd, TclOONextToObjCmd --
 *
 *	Implementation of the [next] and [nextto] commands. Note that these
 *	commands are only ever to be used inside the body of a procedure-like
 *	method.
 *
 * ----------------------------------------------------------------------
 */

func XTclOONextObjCmd(tls *libc.TLS, dummy918 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var _objPtr, cachePtr, framePtr, iPtr, v1 uintptr
	var context TTcl_ObjectContext
	var v2 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _ = _objPtr, cachePtr, context, framePtr, iPtr, v1, v2
	iPtr = interp
	framePtr = (*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr
	/*
	 * Start with sanity checks on the calling context to make sure that we
	 * are invoked from a suitable method context. If so, we can safely
	 * retrieve the handle to the object call context.
	 */
	if framePtr == libc.UintptrFromInt32(0) || !((*TCallFrame)(unsafe.Pointer(framePtr)).FisProcCallFrame&libc.Int32FromInt32(FRAME_IS_METHOD) != 0) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+88185, libc.VaList(bp+16, v1)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+32372, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	context = (*TCallFrame)(unsafe.Pointer(framePtr)).FclientData
	/*
	 * Invoke the (advanced) method call context in the caller context. Note
	 * that this is like [uplevel 1] and not [eval].
	 */
	if v2 = interp == libc.UintptrFromInt32(0); !v2 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(_NextRestoreFrame)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = framePtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
	(*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr = (*TCallFrame)(unsafe.Pointer(framePtr)).FcallerVarPtr
	return XTclNRObjectContextInvokeNext(tls, interp, context, int64(objc), objv, int64(1))
}

func XTclOONextToObjCmd(tls *libc.TLS, dummy954 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var _objPtr, cachePtr, classPtr, contextPtr, framePtr, iPtr, methodType, miPtr, miPtr1, v1, v2, v6, v7 uintptr
	var i TTcl_Size
	var object TTcl_Object
	var v4 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, classPtr, contextPtr, framePtr, i, iPtr, methodType, miPtr, miPtr1, object, v1, v2, v4, v6, v7
	iPtr = interp
	framePtr = (*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr
	/*
	 * Start with sanity checks on the calling context to make sure that we
	 * are invoked from a suitable method context. If so, we can safely
	 * retrieve the handle to the object call context.
	 */
	if framePtr == libc.UintptrFromInt32(0) || !((*TCallFrame)(unsafe.Pointer(framePtr)).FisProcCallFrame&libc.Int32FromInt32(FRAME_IS_METHOD) != 0) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+88185, libc.VaList(bp+16, v1)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+32372, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	contextPtr = (*TCallFrame)(unsafe.Pointer(framePtr)).FclientData
	/*
	 * Sanity check the arguments; we need the first one to refer to a class.
	 */
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+88228)
		return int32(TCL_ERROR)
	}
	object = XTcl_GetObjectFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if object == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	classPtr = (*TObject)(unsafe.Pointer(object)).FclassPtr
	if classPtr == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+28620, libc.VaList(bp+16, v2)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+32436, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Search for an implementation of a method associated with the current
	 * call on the call chain past the point where we currently are. Do not
	 * allow jumping backwards!
	 */
	i = (*TCallContext)(unsafe.Pointer(contextPtr)).Findex + int64(1)
	for {
		if !(i < (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).FnumChain) {
			break
		}
		miPtr = (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr(i)*24
		if !((*TMInvoke)(unsafe.Pointer(miPtr)).FisFilter != 0) && (*TMethod)(unsafe.Pointer((*TMInvoke)(unsafe.Pointer(miPtr)).FmPtr)).FdeclaringClassPtr == classPtr {
			/*
			 * Invoke the (advanced) method call context in the caller
			 * context. Note that this is like [uplevel 1] and not [eval].
			 */
			if v4 = interp == libc.UintptrFromInt32(0); !v4 {
				cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
			}
			if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				_objPtr = XTclThreadAllocObj(tls)
			} else {
				_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(_objPtr + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
			(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(_NextRestoreFrame)
			*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = framePtr
			*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = contextPtr
			*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = uintptr((*TCallContext)(unsafe.Pointer(contextPtr)).Findex)
			*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
			(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
			(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
			(*TCallContext)(unsafe.Pointer(contextPtr)).Findex = i - int64(1)
			(*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr = (*TCallFrame)(unsafe.Pointer(framePtr)).FcallerVarPtr
			return XTclNRObjectContextInvokeNext(tls, interp, contextPtr, int64(objc), objv, int64(2))
		}
		goto _3
	_3:
		;
		i++
	}
	/*
	 * Generate an appropriate error message, depending on whether the value
	 * is on the chain but unreachable, or not on the chain at all.
	 */
	if (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fflags&int32(CONSTRUCTOR) != 0 {
		methodType = __ccgo_ts + 28529
	} else {
		if (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fflags&int32(DESTRUCTOR) != 0 {
			methodType = __ccgo_ts + 28541
		} else {
			methodType = __ccgo_ts + 28559
		}
	}
	i = (*TCallContext)(unsafe.Pointer(contextPtr)).Findex
	for {
		if !(i != int64(-libc.Int32FromInt32(1))) {
			break
		}
		miPtr1 = (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr(i)*24
		if !((*TMInvoke)(unsafe.Pointer(miPtr1)).FisFilter != 0) && (*TMethod)(unsafe.Pointer((*TMInvoke)(unsafe.Pointer(miPtr1)).FmPtr)).FdeclaringClassPtr == classPtr {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
				v6 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
			} else {
				v6 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+32451, libc.VaList(bp+16, methodType, v6)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+32501, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		goto _5
	_5:
		;
		i--
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v7 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v7 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+32521, libc.VaList(bp+16, methodType, v7)))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+32565, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
}

func _NextRestoreFrame(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	var contextPtr, iPtr uintptr
	_, _ = contextPtr, iPtr
	iPtr = interp
	contextPtr = *(*uintptr)(unsafe.Pointer(data + 1*8))
	(*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr = *(*uintptr)(unsafe.Pointer(data))
	if contextPtr != libc.UintptrFromInt32(0) {
		(*TCallContext)(unsafe.Pointer(contextPtr)).Findex = libc.Int64FromUint64(uint64(*(*uintptr)(unsafe.Pointer(data + 2*8))))
	}
	return result
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOSelfObjCmd --
 *
 *	Implementation of the [self] command, which provides introspection of
 *	the call context.
 *
 * ----------------------------------------------------------------------
 */

func XTclOOSelfObjCmd(tls *libc.TLS, dummy1087 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var cachePtr, callerPtr, clsPtr, contextPtr, declarerPtr, declarerPtr1, declarerPtr2, framePtr, iPtr, mPtr, mPtr1, mPtr2, miPtr, oPtr, type1, v1 uintptr
	var i TTcl_Size
	var v3 bool
	var _ /* index at bp+0 */ int32
	var _ /* result at bp+8 */ [3]uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, callerPtr, clsPtr, contextPtr, declarerPtr, declarerPtr1, declarerPtr2, framePtr, i, iPtr, mPtr, mPtr1, mPtr2, miPtr, oPtr, type1, v1, v3
	iPtr = interp
	framePtr = (*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr
	/*
	 * Start with sanity checks on the calling context and the method context.
	 */
	if framePtr == libc.UintptrFromInt32(0) || !((*TCallFrame)(unsafe.Pointer(framePtr)).FisProcCallFrame&libc.Int32FromInt32(FRAME_IS_METHOD) != 0) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+88185, libc.VaList(bp+40, v1)))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+32372, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	contextPtr = (*TCallFrame)(unsafe.Pointer(framePtr)).FclientData
	/*
	 * Now we do "conventional" argument parsing for a while. Note that no
	 * subcommand takes arguments.
	 */
	if objc > int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+25008)
		return int32(TCL_ERROR)
	} else {
		if objc == int32(1) {
			*(*int32)(unsafe.Pointer(bp)) = 7
		} else {
			if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), uintptr(unsafe.Pointer(&_subcmds)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+25008, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
				return int32(TCL_ERROR)
			}
		}
	}
	switch *(*int32)(unsafe.Pointer(bp)) {
	case 7:
		XTcl_SetObjResult(tls, interp, XTclOOObjectName(tls, interp, (*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr))
		return TCL_OK
	case 5:
		XTcl_SetObjResult(tls, interp, XTclNewNamespaceObj(tls, (*TObject)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr)).FnamespacePtr))
		return TCL_OK
	case 2:
		clsPtr = (*TMethod)(unsafe.Pointer((*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr((*TCallContext)(unsafe.Pointer(contextPtr)).Findex)*24))).FmPtr)).FdeclaringClassPtr
		if clsPtr == libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+88255, int64(-libc.Int32FromInt32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+88285, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		XTcl_SetObjResult(tls, interp, XTclOOObjectName(tls, interp, (*TClass)(unsafe.Pointer(clsPtr)).FthisPtr))
		return TCL_OK
	case 4:
		if (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fflags&int32(CONSTRUCTOR) != 0 {
			XTcl_SetObjResult(tls, interp, (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr)).FfPtr)).FconstructorName)
		} else {
			if (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fflags&int32(DESTRUCTOR) != 0 {
				XTcl_SetObjResult(tls, interp, (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr)).FfPtr)).FdestructorName)
			} else {
				XTcl_SetObjResult(tls, interp, (*TMethod)(unsafe.Pointer((*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr((*TCallContext)(unsafe.Pointer(contextPtr)).Findex)*24))).FmPtr)).FnamePtr)
			}
		}
		return TCL_OK
	case 3:
		if !((*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr((*TCallContext)(unsafe.Pointer(contextPtr)).Findex)*24))).FisFilter != 0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+88303, int64(-libc.Int32FromInt32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+88285, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		} else {
			miPtr = (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr((*TCallContext)(unsafe.Pointer(contextPtr)).Findex)*24
			if (*TMInvoke)(unsafe.Pointer(miPtr)).FfilterDeclarer != libc.UintptrFromInt32(0) {
				oPtr = (*TClass)(unsafe.Pointer((*TMInvoke)(unsafe.Pointer(miPtr)).FfilterDeclarer)).FthisPtr
				type1 = __ccgo_ts + 19296
			} else {
				oPtr = (*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr
				type1 = __ccgo_ts + 6499
			}
			(*(*[3]uintptr)(unsafe.Pointer(bp + 8)))[0] = XTclOOObjectName(tls, interp, oPtr)
			(*(*[3]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] = XTcl_NewStringObj(tls, type1, int64(-libc.Int32FromInt32(1)))
			(*(*[3]uintptr)(unsafe.Pointer(bp + 8)))[int32(2)] = (*TMethod)(unsafe.Pointer((*TMInvoke)(unsafe.Pointer(miPtr)).FmPtr)).FnamePtr
			XTcl_SetObjResult(tls, interp, XTcl_NewListObj(tls, int64(3), bp+8))
			return TCL_OK
		}
		fallthrough
	case 1:
		if (*TCallFrame)(unsafe.Pointer(framePtr)).FcallerVarPtr == libc.UintptrFromInt32(0) || !((*TCallFrame1)(unsafe.Pointer((*TCallFrame)(unsafe.Pointer(framePtr)).FcallerVarPtr)).FisProcCallFrame&libc.Int32FromInt32(FRAME_IS_METHOD) != 0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+88334, int64(-libc.Int32FromInt32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+32372, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		} else {
			callerPtr = (*TCallFrame1)(unsafe.Pointer((*TCallFrame)(unsafe.Pointer(framePtr)).FcallerVarPtr)).FclientData
			mPtr = (*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(callerPtr)).FcallPtr)).Fchain + uintptr((*TCallContext)(unsafe.Pointer(callerPtr)).Findex)*24))).FmPtr
			if (*TMethod)(unsafe.Pointer(mPtr)).FdeclaringClassPtr != libc.UintptrFromInt32(0) {
				declarerPtr = (*TClass)(unsafe.Pointer((*TMethod)(unsafe.Pointer(mPtr)).FdeclaringClassPtr)).FthisPtr
			} else {
				if (*TMethod)(unsafe.Pointer(mPtr)).FdeclaringObjectPtr != libc.UintptrFromInt32(0) {
					declarerPtr = (*TMethod)(unsafe.Pointer(mPtr)).FdeclaringObjectPtr
				} else {
					/*
					 * This should be unreachable code.
					 */
					XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+88358, int64(-libc.Int32FromInt32(1))))
					return int32(TCL_ERROR)
				}
			}
			(*(*[3]uintptr)(unsafe.Pointer(bp + 8)))[0] = XTclOOObjectName(tls, interp, declarerPtr)
			(*(*[3]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] = XTclOOObjectName(tls, interp, (*TCallContext)(unsafe.Pointer(callerPtr)).FoPtr)
			if (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(callerPtr)).FcallPtr)).Fflags&int32(CONSTRUCTOR) != 0 {
				(*(*[3]uintptr)(unsafe.Pointer(bp + 8)))[int32(2)] = (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer(declarerPtr)).FfPtr)).FconstructorName
			} else {
				if (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(callerPtr)).FcallPtr)).Fflags&int32(DESTRUCTOR) != 0 {
					(*(*[3]uintptr)(unsafe.Pointer(bp + 8)))[int32(2)] = (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer(declarerPtr)).FfPtr)).FdestructorName
				} else {
					(*(*[3]uintptr)(unsafe.Pointer(bp + 8)))[int32(2)] = (*TMethod)(unsafe.Pointer(mPtr)).FnamePtr
				}
			}
			XTcl_SetObjResult(tls, interp, XTcl_NewListObj(tls, int64(3), bp+8))
			return TCL_OK
		}
		fallthrough
	case 6:
		if (*TCallContext)(unsafe.Pointer(contextPtr)).Findex < (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).FnumChain-int64(1) {
			mPtr1 = (*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr((*TCallContext)(unsafe.Pointer(contextPtr)).Findex+int64(1))*24))).FmPtr
			if (*TMethod)(unsafe.Pointer(mPtr1)).FdeclaringClassPtr != libc.UintptrFromInt32(0) {
				declarerPtr1 = (*TClass)(unsafe.Pointer((*TMethod)(unsafe.Pointer(mPtr1)).FdeclaringClassPtr)).FthisPtr
			} else {
				if (*TMethod)(unsafe.Pointer(mPtr1)).FdeclaringObjectPtr != libc.UintptrFromInt32(0) {
					declarerPtr1 = (*TMethod)(unsafe.Pointer(mPtr1)).FdeclaringObjectPtr
				} else {
					/*
					 * This should be unreachable code.
					 */
					XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+88358, int64(-libc.Int32FromInt32(1))))
					return int32(TCL_ERROR)
				}
			}
			(*(*[3]uintptr)(unsafe.Pointer(bp + 8)))[0] = XTclOOObjectName(tls, interp, declarerPtr1)
			if (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fflags&int32(CONSTRUCTOR) != 0 {
				(*(*[3]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] = (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer(declarerPtr1)).FfPtr)).FconstructorName
			} else {
				if (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fflags&int32(DESTRUCTOR) != 0 {
					(*(*[3]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] = (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer(declarerPtr1)).FfPtr)).FdestructorName
				} else {
					(*(*[3]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] = (*TMethod)(unsafe.Pointer(mPtr1)).FnamePtr
				}
			}
			XTcl_SetObjResult(tls, interp, XTcl_NewListObj(tls, int64(2), bp+8))
		}
		return TCL_OK
	case 8:
		if !((*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr((*TCallContext)(unsafe.Pointer(contextPtr)).Findex)*24))).FisFilter != 0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+88303, int64(-libc.Int32FromInt32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+40, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+88285, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		} else {
			i = (*TCallContext)(unsafe.Pointer(contextPtr)).Findex
			for {
				if !(i < (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).FnumChain) {
					break
				}
				if !((*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr(i)*24))).FisFilter != 0) {
					break
				}
				goto _2
			_2:
				;
				i++
			}
			if i == (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).FnumChain {
				XTcl_Panic(tls, __ccgo_ts+88383, 0)
			}
			mPtr2 = (*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr(i)*24))).FmPtr
			if (*TMethod)(unsafe.Pointer(mPtr2)).FdeclaringClassPtr != libc.UintptrFromInt32(0) {
				declarerPtr2 = (*TClass)(unsafe.Pointer((*TMethod)(unsafe.Pointer(mPtr2)).FdeclaringClassPtr)).FthisPtr
			} else {
				if (*TMethod)(unsafe.Pointer(mPtr2)).FdeclaringObjectPtr != libc.UintptrFromInt32(0) {
					declarerPtr2 = (*TMethod)(unsafe.Pointer(mPtr2)).FdeclaringObjectPtr
				} else {
					/*
					 * This should be unreachable code.
					 */
					XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+88358, int64(-libc.Int32FromInt32(1))))
					return int32(TCL_ERROR)
				}
			}
			(*(*[3]uintptr)(unsafe.Pointer(bp + 8)))[0] = XTclOOObjectName(tls, interp, declarerPtr2)
			(*(*[3]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] = (*TMethod)(unsafe.Pointer(mPtr2)).FnamePtr
			XTcl_SetObjResult(tls, interp, XTcl_NewListObj(tls, int64(2), bp+8))
			return TCL_OK
		}
		fallthrough
	case 0:
		(*(*[3]uintptr)(unsafe.Pointer(bp + 8)))[0] = XTclOORenderCallChain(tls, interp, (*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)
		if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			(*(*[3]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] = XTclThreadAllocObj(tls)
		} else {
			(*(*[3]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)] + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).Fbytes = libc.UintptrFromInt32(0)
		*(*TTcl_WideInt)(unsafe.Pointer(&(*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).FinternalRep)) = (*TCallContext)(unsafe.Pointer(contextPtr)).Findex
		(*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp + 8)))[int32(1)])).FtypePtr = uintptr(unsafe.Pointer(&XtclIntType))
		XTcl_SetObjResult(tls, interp, XTcl_NewListObj(tls, int64(2), bp+8))
		return TCL_OK
	}
	return int32(TCL_ERROR)
}

var _subcmds = [10]uintptr{
	0: __ccgo_ts + 88243,
	1: __ccgo_ts + 88248,
	2: __ccgo_ts + 19296,
	3: __ccgo_ts + 26201,
	4: __ccgo_ts + 28559,
	5: __ccgo_ts + 21846,
	6: __ccgo_ts + 25555,
	7: __ccgo_ts + 6499,
	8: __ccgo_ts + 40619,
	9: libc.UintptrFromInt32(0),
}

/*
 * ----------------------------------------------------------------------
 *
 * CopyObjectCmd --
 *
 *	Implementation of the [oo::copy] command, which clones an object (but
 *	not its namespace). Note that no constructors are called during this
 *	process.
 *
 * ----------------------------------------------------------------------
 */

func XTclOOCopyObjectCmd(tls *libc.TLS, dummy1324 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var name, namespaceName, v1, v2 uintptr
	var o2Ptr, oPtr TTcl_Object
	_, _, _, _, _, _ = name, namespaceName, o2Ptr, oPtr, v1, v2
	if objc < int32(2) || objc > int32(4) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+88432)
		return int32(TCL_ERROR)
	}
	oPtr = XTcl_GetObjectFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Create a cloned object of the correct class. Note that constructors are
	 * not called. Also note that we must resolve the object name ourselves
	 * because we do not want to create the object in the current namespace,
	 * but rather in the context of the namespace of the caller of the overall
	 * [oo::define] command.
	 */
	if objc == int32(2) {
		o2Ptr = XTcl_CopyObjectInstance(tls, interp, oPtr, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		name = v1
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32('\000') {
			name = libc.UintptrFromInt32(0)
		}
		/*
		 * Choose a unique namespace name if the user didn't supply one.
		 */
		namespaceName = libc.UintptrFromInt32(0)
		if objc == int32(4) {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes != 0 {
				v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 3*8)))).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 3*8)), libc.UintptrFromInt32(0))
			}
			namespaceName = v2
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(namespaceName))) == int32('\000') {
				namespaceName = libc.UintptrFromInt32(0)
			} else {
				if XTcl_FindNamespace(tls, interp, namespaceName, libc.UintptrFromInt32(0), 0) != libc.UintptrFromInt32(0) {
					XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+88474, libc.VaList(bp+8, namespaceName)))
					return int32(TCL_ERROR)
				}
			}
		}
		o2Ptr = XTcl_CopyObjectInstance(tls, interp, oPtr, name, namespaceName)
	}
	if o2Ptr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Return the name of the cloned object.
	 */
	XTcl_SetObjResult(tls, interp, XTclOOObjectName(tls, interp, o2Ptr))
	return TCL_OK
}

type TCallFrame1 = struct {
	FnsPtr             uintptr
	FisProcCallFrame   int32
	Fobjc              TTcl_Size
	Fobjv              uintptr
	FcallerPtr         uintptr
	FcallerVarPtr      uintptr
	Flevel             TTcl_Size
	FprocPtr           uintptr
	FvarTablePtr       uintptr
	FnumCompiledLocals TTcl_Size
	FcompiledLocals    uintptr
	FclientData        uintptr
	FlocalCachePtr     uintptr
	FtailcallPtr       uintptr
}

const DEFINE_CHAIN_STATIC_SIZE = 4

// C documentation
//
//	/*
//	 * Structure containing a CallChain and any other values needed only during
//	 * the construction of the CallChain.
//	 */
type TChainBuilder = struct {
	FcallChainPtr uintptr
	FfilterLength Tsize_t
	FoPtr         uintptr
}

/*
 * Structures used for traversing the class hierarchy to find out where
 * definitions are supposed to be done.
 */

type TDefineEntry = struct {
	FdefinerCls    uintptr
	FnamespaceName uintptr
}

type TDefineChain = struct {
	Flist uintptr
	Fnum  int32
	Fsize int32
}

/*
 * Extra flags used for call chain management.
 */
type CallChainFlags = int32

const DEFINITE_PROTECTED = 1048576
const DEFINITE_PUBLIC = 2097152
const KNOWN_STATE = 3145728
const SPECIAL = 65560
const BUILDING_MIXINS = 4194304
const TRAVERSED_MIXIN = 8388608
const OBJECT_MIXIN = 16777216
const DEFINE_FOR_CLASS = 33554432

/*
 * Note that the flag bit PRIVATE_METHOD has a confusing name; it's just for
 * Itcl's special type of private.
 */

/*
 * Name the bits used in the names table values.
 */
type NameTableValues = int32

const IN_LIST1 = 1
const /* Seen an implementation. */
NO_IMPLEMENTATION = 2

/*
 * Object type used to manage type caches attached to method names.
 */

var _methodNameType = TTcl_ObjType{
	Fname: __ccgo_ts + 88509,
}

func init() {
	p := unsafe.Pointer(&_methodNameType)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_FreeMethodNameRep)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_DupMethodNameRep)
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOODeleteContext --
 *
 *	Destroys a method call-chain context, which should not be in use.
 *
 * ----------------------------------------------------------------------
 */

func XTclOODeleteContext(tls *libc.TLS, contextPtr uintptr) {
	var oPtr uintptr
	_ = oPtr
	oPtr = (*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr
	XTclOODeleteChain(tls, (*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)
	if oPtr != libc.UintptrFromInt32(0) {
		XTclStackFree(tls, (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FfPtr)).Finterp, contextPtr)
		/*
		 * Corresponding AddRef() in TclOO.c/TclOOObjectCmdCore
		 */
		XTclOODecrRefCount(tls, oPtr)
	}
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOODeleteChainCache --
 *
 *	Destroy the cache of method call-chains.
 *
 * ----------------------------------------------------------------------
 */

func XTclOODeleteChainCache(tls *libc.TLS, tablePtr uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var hPtr uintptr
	var v2 int32
	var _ /* callPtr at bp+24 */ uintptr
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _ = hPtr, v2
	hPtr = XTcl_FirstHashEntry(tls, tablePtr, bp)
	for {
		if hPtr != libc.UintptrFromInt32(0) {
			*(*uintptr)(unsafe.Pointer(bp + 24)) = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
			v2 = libc.Int32FromInt32(1)
		} else {
			v2 = 0
		}
		if !(v2 != 0) {
			break
		}
		if *(*uintptr)(unsafe.Pointer(bp + 24)) != 0 {
			XTclOODeleteChain(tls, *(*uintptr)(unsafe.Pointer(bp + 24)))
		}
		goto _1
	_1:
		;
		hPtr = XTcl_NextHashEntry(tls, bp)
	}
	XTcl_DeleteHashTable(tls, tablePtr)
	XTclpFree(tls, tablePtr)
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOODeleteChain --
 *
 *	Destroys a method call-chain.
 *
 * ----------------------------------------------------------------------
 */

func XTclOODeleteChain(tls *libc.TLS, callPtr uintptr) {
	var v1 TTcl_Size
	var v2 uintptr
	var v3 bool
	_, _, _ = v1, v2, v3
	if v3 = callPtr == libc.UintptrFromInt32(0); !v3 {
		v2 = callPtr + 32
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
	}
	if v3 || v1 > int64(1) {
		return
	}
	if (*TCallChain)(unsafe.Pointer(callPtr)).Fchain != callPtr+56 {
		XTclpFree(tls, (*TCallChain)(unsafe.Pointer(callPtr)).Fchain)
	}
	XTclpFree(tls, callPtr)
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOStashContext --
 *
 *	Saves a reference to a method call context in a Tcl_Obj's internal
 *	representation.
 *
 * ----------------------------------------------------------------------
 */

func _StashCallChain(tls *libc.TLS, objPtr uintptr, callPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _ /* ir at bp+0 */ TTcl_ObjInternalRep
	(*TCallChain)(unsafe.Pointer(callPtr)).FrefCount++
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
		_ = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
	} else {
		XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
	}
	(*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(bp))).Fptr1 = callPtr
	XTcl_StoreInternalRep(tls, objPtr, uintptr(unsafe.Pointer(&_methodNameType)), bp)
}

func XTclOOStashContext(tls *libc.TLS, objPtr uintptr, contextPtr uintptr) {
	_StashCallChain(tls, objPtr, (*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)
}

/*
 * ----------------------------------------------------------------------
 *
 * DupMethodNameRep, FreeMethodNameRep --
 *
 *	Functions to implement the required parts of the Tcl_Obj guts needed
 *	for caching of method contexts in Tcl_Objs.
 *
 * ----------------------------------------------------------------------
 */

func _DupMethodNameRep(tls *libc.TLS, srcPtr uintptr, dstPtr uintptr) {
	var v1 uintptr
	_ = v1
	if (*TTcl_Obj)(unsafe.Pointer(srcPtr)).FtypePtr == uintptr(unsafe.Pointer(&_methodNameType)) {
		v1 = srcPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	_StashCallChain(tls, dstPtr, (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(v1))).Fptr1)
}

func _FreeMethodNameRep(tls *libc.TLS, objPtr uintptr) {
	var v1 uintptr
	_ = v1
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&_methodNameType)) {
		v1 = objPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	XTclOODeleteChain(tls, (*(*struct {
		Fptr1 uintptr
		Fptr2 uintptr
	})(unsafe.Pointer(v1))).Fptr1)
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOInvokeContext --
 *
 *	Invokes a single step along a method call-chain context. Note that the
 *	invocation of a step along the chain can cause further steps along the
 *	chain to be invoked. Note that this function is written to be as light
 *	in stack usage as possible.
 *
 * ----------------------------------------------------------------------
 */

func XTclOOInvokeContext(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* The arguments as actually seen. */
	var _objPtr, _objPtr1, _objPtr2, cachePtr, cachePtr1, cachePtr2, contextPtr, mPtr uintptr
	var i TTcl_Size
	var isFilter int32
	var v2, v3, v4 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	var _ /* _callbackPtr at bp+16 */ uintptr
	var _ /* _callbackPtr at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, cachePtr, cachePtr1, cachePtr2, contextPtr, i, isFilter, mPtr, v2, v3, v4
	contextPtr = clientData
	mPtr = (*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr((*TCallContext)(unsafe.Pointer(contextPtr)).Findex)*24))).FmPtr
	isFilter = (*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr((*TCallContext)(unsafe.Pointer(contextPtr)).Findex)*24))).FisFilter
	/*
	 * If this is the first step along the chain, we preserve the method
	 * entries in the chain so that they do not get deleted out from under our
	 * feet.
	 */
	if (*TCallContext)(unsafe.Pointer(contextPtr)).Findex == 0 {
		i = 0
		for {
			if !(i < (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).FnumChain) {
				break
			}
			(*TMethod)(unsafe.Pointer((*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr(i)*24))).FmPtr)).FrefCount++
			goto _1
		_1:
			;
			i++
		}
		/*
		 * Ensure that the method name itself is part of the arguments when
		 * we're doing unknown processing.
		 */
		if (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fflags&int32(OO_UNKNOWN_METHOD) != 0 {
			(*TCallContext)(unsafe.Pointer(contextPtr)).Fskip--
		}
		/*
		 * Add a callback to ensure that method references are dropped once
		 * this call is finished.
		 */
		if v2 = interp == libc.UintptrFromInt32(0); !v2 {
			cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
		}
		if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			_objPtr = XTclThreadAllocObj(tls)
		} else {
			_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(_objPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(_FinalizeMethodRefs)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = contextPtr
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
		(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
	}
	/*
	 * Save whether we were in a filter and set up whether we are now.
	 */
	if (*TObject)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr)).Fflags&int32(FILTER_HANDLING) != 0 {
		if v3 = interp == libc.UintptrFromInt32(0); !v3 {
			cachePtr1 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
		}
		if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
			_objPtr1 = XTclThreadAllocObj(tls)
		} else {
			_objPtr1 = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(_objPtr1 + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = _objPtr1
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FprocPtr = __ccgo_fp(_SetFilterFlags)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8)) = contextPtr
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
		(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
	} else {
		if v4 = interp == libc.UintptrFromInt32(0); !v4 {
			cachePtr2 = (*TInterp)(unsafe.Pointer(interp)).FallocCache
		}
		if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
			_objPtr2 = XTclThreadAllocObj(tls)
		} else {
			_objPtr2 = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(_objPtr2 + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
		}
		*(*uintptr)(unsafe.Pointer(bp + 16)) = _objPtr2
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FprocPtr = __ccgo_fp(_ResetFilterFlags)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8)) = contextPtr
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
		(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 16))
	}
	if isFilter != 0 || (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fflags&int32(FILTER_HANDLING) != 0 {
		*(*int32)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr + 96)) |= int32(FILTER_HANDLING)
	} else {
		*(*int32)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr + 96)) &= ^int32(FILTER_HANDLING)
	}
	/*
	 * Run the method implementation.
	 */
	if (*TTcl_MethodType)(unsafe.Pointer((*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr)).Fversion < int32(TCL_OO_METHOD_VERSION_2) {
		return (*(*func(*libc.TLS, uintptr, uintptr, TTcl_ObjectContext, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_MethodType)(unsafe.Pointer((*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr)).FcallProc})))(tls, (*TMethod)(unsafe.Pointer(mPtr)).FclientData, interp, contextPtr, objc, objv)
	}
	return (*(*func(*libc.TLS, uintptr, uintptr, TTcl_ObjectContext, TTcl_Size, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_MethodType2)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mPtr)))).FcallProc})))(tls, (*TMethod)(unsafe.Pointer(mPtr)).FclientData, interp, contextPtr, int64(objc), objv)
}

func _SetFilterFlags(tls *libc.TLS, data uintptr, dummy394 uintptr, result int32) (r int32) {
	var contextPtr uintptr
	_ = contextPtr
	contextPtr = *(*uintptr)(unsafe.Pointer(data))
	*(*int32)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr + 96)) |= int32(FILTER_HANDLING)
	return result
}

func _ResetFilterFlags(tls *libc.TLS, data uintptr, dummy406 uintptr, result int32) (r int32) {
	var contextPtr uintptr
	_ = contextPtr
	contextPtr = *(*uintptr)(unsafe.Pointer(data))
	*(*int32)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr + 96)) &= ^int32(FILTER_HANDLING)
	return result
}

func _FinalizeMethodRefs(tls *libc.TLS, data uintptr, dummy418 uintptr, result int32) (r int32) {
	var contextPtr uintptr
	var i TTcl_Size
	_, _ = contextPtr, i
	contextPtr = *(*uintptr)(unsafe.Pointer(data))
	i = 0
	for {
		if !(i < (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).FnumChain) {
			break
		}
		XTclOODelMethodRef(tls, (*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr(i)*24))).FmPtr)
		goto _1
	_1:
		;
		i++
	}
	return result
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOGetSortedMethodList, TclOOGetSortedClassMethodList --
 *
 *	Discovers the list of method names supported by an object or class.
 *
 * ----------------------------------------------------------------------
 */

func XTclOOGetSortedMethodList(tls *libc.TLS, oPtr uintptr, contextObj uintptr, contextCls uintptr, flags int32, stringsPtr uintptr) (r int32) {
	bp := tls.Alloc(256)
	defer tls.Free(256) /* Where to write a pointer to the array of
	 * strings to. */
	var hPtr, mixinPtr, v3, v6 uintptr
	var i, numStrings TTcl_Size
	var v2, v5 int32
	var _ /* examinedClasses at bp+104 */ TTcl_HashTable
	var _ /* mPtr at bp+240 */ uintptr
	var _ /* namePtr at bp+232 */ uintptr
	var _ /* names at bp+0 */ TTcl_HashTable
	var _ /* search at bp+208 */ TTcl_HashSearch
	_, _, _, _, _, _, _, _ = hPtr, i, mixinPtr, numStrings, v2, v3, v5, v6
	XTcl_InitObjHashTable(tls, bp)
	XTcl_InitHashTable(tls, bp+104, int32(TCL_ONE_WORD_KEYS))
	/*
	 * Process method names due to the object.
	 */
	if (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr != 0 {
		hPtr = XTcl_FirstHashEntry(tls, (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr, bp+208)
		for {
			if hPtr != libc.UintptrFromInt32(0) {
				if (*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr)).FkeyType == -int32(1) {
					v3 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
				} else {
					v3 = hPtr + 32
				}
				*(*uintptr)(unsafe.Pointer(bp + 232)) = v3
				*(*uintptr)(unsafe.Pointer(bp + 240)) = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
				v2 = libc.Int32FromInt32(1)
			} else {
				v2 = 0
			}
			if !(v2 != 0) {
				break
			}
			if (*TMethod)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 240)))).Fflags&int32(TRUE_PRIVATE_METHOD) != 0 {
				goto _1
			}
			if (*TMethod)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 240)))).Fflags&(int32(PUBLIC_METHOD)|int32(PRIVATE_METHOD)|int32(TRUE_PRIVATE_METHOD)) == 0 && !(flags&(int32(PRIVATE_METHOD)|int32(TRUE_PRIVATE_METHOD)) == libc.Int32FromInt32(0)) {
				goto _1
			}
			_AddStandardMethodName(tls, flags, *(*uintptr)(unsafe.Pointer(bp + 232)), *(*uintptr)(unsafe.Pointer(bp + 240)), bp)
			goto _1
		_1:
			;
			hPtr = XTcl_NextHashEntry(tls, bp+208)
		}
	}
	/*
	 * Process method names due to private methods on the object's class.
	 */
	if flags&(int32(PRIVATE_METHOD)|int32(TRUE_PRIVATE_METHOD)) == 0 {
		hPtr = XTcl_FirstHashEntry(tls, (*TObject)(unsafe.Pointer(oPtr)).FselfCls+136, bp+208)
		for {
			if hPtr != libc.UintptrFromInt32(0) {
				if (*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FselfCls+136)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FselfCls+136)).FkeyType == -int32(1) {
					v6 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
				} else {
					v6 = hPtr + 32
				}
				*(*uintptr)(unsafe.Pointer(bp + 232)) = v6
				*(*uintptr)(unsafe.Pointer(bp + 240)) = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
				v5 = libc.Int32FromInt32(1)
			} else {
				v5 = 0
			}
			if !(v5 != 0) {
				break
			}
			if (*TMethod)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 240)))).Fflags&(int32(PUBLIC_METHOD)|int32(PRIVATE_METHOD)|int32(TRUE_PRIVATE_METHOD)) == 0 {
				_AddStandardMethodName(tls, flags, *(*uintptr)(unsafe.Pointer(bp + 232)), *(*uintptr)(unsafe.Pointer(bp + 240)), bp)
			}
			goto _4
		_4:
			;
			hPtr = XTcl_NextHashEntry(tls, bp+208)
		}
	}
	/*
	 * Process method names due to private methods on the context's object or
	 * class. Which must be correct if either are not NULL.
	 */
	if contextObj != 0 && (*TObject)(unsafe.Pointer(contextObj)).FmethodsPtr != 0 {
		_AddPrivateMethodNames(tls, (*TObject)(unsafe.Pointer(contextObj)).FmethodsPtr, bp)
	}
	if contextCls != 0 {
		_AddPrivateMethodNames(tls, contextCls+136, bp)
	}
	/*
	 * Process (normal) method names from the class hierarchy and the mixin
	 * hierarchy.
	 */
	_AddClassMethodNames(tls, (*TObject)(unsafe.Pointer(oPtr)).FselfCls, flags, bp, bp+104)
	i = 0
	for {
		if !(i < (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _7
		} else {
			mixinPtr = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				_AddClassMethodNames(tls, mixinPtr, flags|int32(TRAVERSED_MIXIN), bp, bp+104)
			}
		}
		goto _7
	_7:
		;
		i++
	}
	/*
	 * Tidy up, sort the names and resolve finally whether we really want
	 * them (processing export layering).
	 */
	XTcl_DeleteHashTable(tls, bp+104)
	numStrings = libc.Int64FromUint64(_SortMethodNames(tls, bp, flags, stringsPtr))
	XTcl_DeleteHashTable(tls, bp)
	return int32(numStrings)
}

func XTclOOGetSortedClassMethodList(tls *libc.TLS, clsPtr uintptr, flags int32, stringsPtr uintptr) (r Tsize_t) {
	bp := tls.Alloc(208)
	defer tls.Free(208) /* Where to write a pointer to the array of
	 * strings to. */
	var numStrings Tsize_t
	var _ /* examinedClasses at bp+104 */ TTcl_HashTable
	var _ /* names at bp+0 */ TTcl_HashTable
	_ = numStrings
	XTcl_InitObjHashTable(tls, bp)
	XTcl_InitHashTable(tls, bp+104, int32(TCL_ONE_WORD_KEYS))
	/*
	 * Process method names from the class hierarchy and the mixin hierarchy.
	 */
	_AddClassMethodNames(tls, clsPtr, flags, bp, bp+104)
	XTcl_DeleteHashTable(tls, bp+104)
	/*
	 * Process private method names if we should. [TIP 500]
	 */
	if flags&int32(TRUE_PRIVATE_METHOD) != 0 {
		_AddPrivateMethodNames(tls, clsPtr+136, bp)
		flags &= ^int32(TRUE_PRIVATE_METHOD)
	}
	/*
	 * Tidy up, sort the names and resolve finally whether we really want
	 * them (processing export layering).
	 */
	numStrings = _SortMethodNames(tls, bp, flags, stringsPtr)
	XTcl_DeleteHashTable(tls, bp)
	return numStrings
}

/*
 * ----------------------------------------------------------------------
 *
 * SortMethodNames --
 *
 *	Shared helper for TclOOGetSortedMethodList etc. that knows the method
 *	sorting rules.
 *
 * Returns:
 *	The length of the sorted list.
 *
 * ----------------------------------------------------------------------
 */

func _SortMethodNames(tls *libc.TLS, namesPtr uintptr, flags int32, stringsPtr uintptr) (r Tsize_t) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Where to store the sorted list of strings
	 * that we produce. Tcl_Alloced() */
	var hPtr, strings, v3, v5 uintptr
	var i, v4 Tsize_t
	var v2 int32
	var _ /* isWanted at bp+32 */ uintptr
	var _ /* namePtr at bp+24 */ uintptr
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _, _ = hPtr, i, strings, v2, v3, v4, v5
	i = uint64(0)
	/*
	 * See how many (visible) method names there are. If none, we do not (and
	 * should not) try to sort the list of them.
	 */
	if (*TTcl_HashTable)(unsafe.Pointer(namesPtr)).FnumEntries == 0 {
		*(*uintptr)(unsafe.Pointer(stringsPtr)) = libc.UintptrFromInt32(0)
		return uint64(0)
	}
	/*
	 * We need to build the list of methods to sort. We will be using qsort()
	 * for this, because it is very unlikely that the list will be heavily
	 * sorted when it is long enough to matter.
	 */
	strings = XTcl_Alloc(tls, uint64(8)*libc.Uint64FromInt64((*TTcl_HashTable)(unsafe.Pointer(namesPtr)).FnumEntries))
	hPtr = XTcl_FirstHashEntry(tls, namesPtr, bp)
	for {
		if hPtr != libc.UintptrFromInt32(0) {
			if (*TTcl_HashTable)(unsafe.Pointer(namesPtr)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(namesPtr)).FkeyType == -int32(1) {
				v3 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
			} else {
				v3 = hPtr + 32
			}
			*(*uintptr)(unsafe.Pointer(bp + 24)) = v3
			*(*uintptr)(unsafe.Pointer(bp + 32)) = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
			v2 = libc.Int32FromInt32(1)
		} else {
			v2 = 0
		}
		if !(v2 != 0) {
			break
		}
		if !(flags&int32(PUBLIC_METHOD) != libc.Int32FromInt32(0)) || int64(*(*uintptr)(unsafe.Pointer(bp + 32)))&int64(IN_LIST1) != 0 {
			if int64(*(*uintptr)(unsafe.Pointer(bp + 32)))&int64(NO_IMPLEMENTATION) != 0 {
				goto _1
			}
			v4 = i
			i++
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Fbytes != 0 {
				v5 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Fbytes
			} else {
				v5 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(bp + 24)), libc.UintptrFromInt32(0))
			}
			*(*uintptr)(unsafe.Pointer(strings + uintptr(v4)*8)) = v5
		}
		goto _1
	_1:
		;
		hPtr = XTcl_NextHashEntry(tls, bp)
	}
	/*
	 * Note that 'i' may well be less than names.numEntries when we are
	 * dealing with public method names. We don't sort unless there's at least
	 * two method names.
	 */
	if i > uint64(0) {
		if i > uint64(1) {
			libc.Xqsort(tls, strings, i, uint64(8), __ccgo_fp(_CmpStr))
		}
		*(*uintptr)(unsafe.Pointer(stringsPtr)) = strings
	} else {
		XTclpFree(tls, strings)
		*(*uintptr)(unsafe.Pointer(stringsPtr)) = libc.UintptrFromInt32(0)
	}
	return i
}

/*
 * Comparator for SortMethodNames
 */

func _CmpStr(tls *libc.TLS, ptr1 uintptr, ptr2 uintptr) (r int32) {
	var strPtr1, strPtr2 uintptr
	_, _ = strPtr1, strPtr2
	strPtr1 = ptr1
	strPtr2 = ptr2
	return XTclpUtfNcmp2(tls, *(*uintptr)(unsafe.Pointer(strPtr1)), *(*uintptr)(unsafe.Pointer(strPtr2)), libc.Xstrlen(tls, *(*uintptr)(unsafe.Pointer(strPtr1)))+uint64(1))
}

/*
 * ----------------------------------------------------------------------
 *
 * AddClassMethodNames --
 *
 *	Adds the method names defined by a class (or its superclasses) to the
 *	collection being built. The collection is built in a hash table to
 *	ensure that duplicates are excluded. Helper for GetSortedMethodList().
 *
 * ----------------------------------------------------------------------
 */

func _AddClassMethodNames(tls *libc.TLS, clsPtr uintptr, flags int32, namesPtr uintptr, examinedClassesPtr uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	/* Hash table that tracks what classes have
	 * already been looked at. The keys are the
	 * pointers to the classes, and the values are
	 * immaterial. */
	var hPtr, mixinPtr, superPtr, v4 uintptr
	var i TTcl_Size
	var v3 int32
	var _ /* isNew at bp+40 */ int32
	var _ /* mPtr at bp+32 */ uintptr
	var _ /* namePtr at bp+24 */ uintptr
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _, _, _, _ = hPtr, i, mixinPtr, superPtr, v3, v4
	/*
	 * If we've already started looking at this class, stop working on it now
	 * to prevent repeated work.
	 */
	if (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(examinedClassesPtr)).FfindProc})))(tls, examinedClassesPtr, clsPtr) != 0 {
		return
	}
	/*
	 * Scope all declarations so that the compiler can stand a good chance of
	 * making the recursive step highly efficient. We also hand-implement the
	 * tail-recursive case using a while loop; C compilers typically cannot do
	 * tail-recursion optimization usefully.
	 */
	for int32(1) != 0 {
		(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(examinedClassesPtr)).FcreateProc})))(tls, examinedClassesPtr, clsPtr, bp+40)
		if !(*(*int32)(unsafe.Pointer(bp + 40)) != 0) {
			break
		}
		if (*TClass)(unsafe.Pointer(clsPtr)).Fmixins.Fnum != 0 {
			i = 0
			for {
				if !(i < (*TClass)(unsafe.Pointer(clsPtr)).Fmixins.Fnum) {
					break
				}
				if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
					goto _1
				} else {
					mixinPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fmixins.Flist + uintptr(i)*8))
					if libc.Int32FromInt32(1) != 0 {
						if mixinPtr != clsPtr {
							_AddClassMethodNames(tls, mixinPtr, flags|int32(TRAVERSED_MIXIN), namesPtr, examinedClassesPtr)
						}
					}
				}
				goto _1
			_1:
				;
				i++
			}
		}
		hPtr = XTcl_FirstHashEntry(tls, clsPtr+136, bp)
		for {
			if hPtr != libc.UintptrFromInt32(0) {
				if (*TTcl_HashTable)(unsafe.Pointer(clsPtr+136)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(clsPtr+136)).FkeyType == -int32(1) {
					v4 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
				} else {
					v4 = hPtr + 32
				}
				*(*uintptr)(unsafe.Pointer(bp + 24)) = v4
				*(*uintptr)(unsafe.Pointer(bp + 32)) = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
				v3 = libc.Int32FromInt32(1)
			} else {
				v3 = 0
			}
			if !(v3 != 0) {
				break
			}
			_AddStandardMethodName(tls, flags, *(*uintptr)(unsafe.Pointer(bp + 24)), *(*uintptr)(unsafe.Pointer(bp + 32)), namesPtr)
			goto _2
		_2:
			;
			hPtr = XTcl_NextHashEntry(tls, bp)
		}
		if (*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Fnum != int64(1) {
			break
		}
		clsPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Flist))
	}
	if (*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Fnum != 0 {
		i = 0
		for {
			if !(i < (*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _5
			} else {
				superPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					_AddClassMethodNames(tls, superPtr, flags, namesPtr, examinedClassesPtr)
				}
			}
			goto _5
		_5:
			;
			i++
		}
	}
}

/*
 * ----------------------------------------------------------------------
 *
 * AddPrivateMethodNames, AddStandardMethodName --
 *
 *	Factored-out helpers for the sorted name list production functions.
 *
 * ----------------------------------------------------------------------
 */

func _AddPrivateMethodNames(tls *libc.TLS, methodsTablePtr uintptr, namesPtr uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var hPtr, v3 uintptr
	var v2 int32
	var _ /* isNew at bp+40 */ int32
	var _ /* mPtr at bp+24 */ uintptr
	var _ /* namePtr at bp+32 */ uintptr
	var _ /* search at bp+0 */ TTcl_HashSearch
	_, _, _ = hPtr, v2, v3
	hPtr = XTcl_FirstHashEntry(tls, methodsTablePtr, bp)
	for {
		if hPtr != libc.UintptrFromInt32(0) {
			if (*TTcl_HashTable)(unsafe.Pointer(methodsTablePtr)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(methodsTablePtr)).FkeyType == -int32(1) {
				v3 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
			} else {
				v3 = hPtr + 32
			}
			*(*uintptr)(unsafe.Pointer(bp + 32)) = v3
			*(*uintptr)(unsafe.Pointer(bp + 24)) = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
			v2 = libc.Int32FromInt32(1)
		} else {
			v2 = 0
		}
		if !(v2 != 0) {
			break
		}
		if (*TMethod)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Fflags&int32(TRUE_PRIVATE_METHOD) != 0 {
			hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(namesPtr)).FcreateProc})))(tls, namesPtr, *(*uintptr)(unsafe.Pointer(bp + 32)), bp+40)
			(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = uintptr(int64(int32(IN_LIST1)))
		}
		goto _1
	_1:
		;
		hPtr = XTcl_NextHashEntry(tls, bp)
	}
}

func _AddStandardMethodName(tls *libc.TLS, flags int32, namePtr uintptr, mPtr uintptr, namesPtr uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var hPtr uintptr
	var isWanted, isWanted1, v1, v2 int32
	var _ /* isNew at bp+0 */ int32
	_, _, _, _, _ = hPtr, isWanted, isWanted1, v1, v2
	if !((*TMethod)(unsafe.Pointer(mPtr)).Fflags&int32(TRUE_PRIVATE_METHOD) != libc.Int32FromInt32(0)) {
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(namesPtr)).FcreateProc})))(tls, namesPtr, namePtr, bp)
		if *(*int32)(unsafe.Pointer(bp)) != 0 {
			if !(flags&int32(PUBLIC_METHOD) != libc.Int32FromInt32(0)) || (*TMethod)(unsafe.Pointer(mPtr)).Fflags&int32(PUBLIC_METHOD) != 0 {
				v1 = int32(IN_LIST1)
			} else {
				v1 = 0
			}
			isWanted = v1
			if (*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr == libc.UintptrFromInt32(0) {
				v2 = int32(NO_IMPLEMENTATION)
			} else {
				v2 = 0
			}
			isWanted |= v2
			(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = uintptr(int64(isWanted))
		} else {
			if int64((*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData)&int64(NO_IMPLEMENTATION) != 0 && (*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr != libc.UintptrFromInt32(0) {
				isWanted1 = int32(int64((*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData))
				isWanted1 &= ^int32(NO_IMPLEMENTATION)
				(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = uintptr(int64(isWanted1))
			}
		}
	}
}

/*
 * ----------------------------------------------------------------------
 *
 * AddInstancePrivateToCallContext --
 *
 *	Add private methods from the instance. Called when the calling Tcl
 *	context is a TclOO method declared by an object that is the same as
 *	the current object. Returns true iff a private method was actually
 *	found and added to the call chain (as this suppresses caching).
 *
 * ----------------------------------------------------------------------
 */

func _AddInstancePrivateToCallContext(tls *libc.TLS, oPtr uintptr, methodName uintptr, cbPtr uintptr, flags int32) (r int32) {
	/* What sort of call chain are we building. */
	var donePrivate int32
	var hPtr, mPtr uintptr
	_, _, _ = donePrivate, hPtr, mPtr
	donePrivate = 0
	if (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr != 0 {
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr)).FfindProc})))(tls, (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr, methodName)
		if hPtr != libc.UintptrFromInt32(0) {
			mPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
			if (*TMethod)(unsafe.Pointer(mPtr)).Fflags&int32(TRUE_PRIVATE_METHOD) != 0 {
				_AddMethodToCallChain(tls, mPtr, cbPtr, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), flags)
				donePrivate = int32(1)
			}
		}
	}
	return donePrivate
}

/*
 * ----------------------------------------------------------------------
 *
 * AddSimpleChainToCallContext --
 *
 *	The core of the call-chain construction engine, this handles calling a
 *	particular method on a particular object. Note that filters and
 *	unknown handling are already handled by the logic that uses this
 *	function. Returns true if a private method was one of those found.
 *
 * ----------------------------------------------------------------------
 */

func _AddSimpleChainToCallContext(tls *libc.TLS, oPtr uintptr, contextCls uintptr, methodNameObj uintptr, cbPtr uintptr, doneFilters uintptr, flags int32, filterDecl uintptr) (r int32) {
	/* The class that declared the filter. If
	 * NULL, either the filter was declared by the
	 * object or this isn't a filter. */
	var blockedUnexported, foundPrivate int32
	var hPtr, mPtr, mixinPtr uintptr
	var i TTcl_Size
	_, _, _, _, _, _ = blockedUnexported, foundPrivate, hPtr, i, mPtr, mixinPtr
	foundPrivate = 0
	blockedUnexported = 0
	if !(flags&(int32(KNOWN_STATE)|int32(SPECIAL)) != 0) && (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr != 0 {
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr)).FfindProc})))(tls, (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr, methodNameObj)
		if hPtr != libc.UintptrFromInt32(0) {
			mPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
			if !((*TMethod)(unsafe.Pointer(mPtr)).Fflags&int32(TRUE_PRIVATE_METHOD) != libc.Int32FromInt32(0)) {
				if flags&int32(PUBLIC_METHOD) != 0 {
					if !((*TMethod)(unsafe.Pointer(mPtr)).Fflags&int32(PUBLIC_METHOD) != libc.Int32FromInt32(0)) {
						blockedUnexported = int32(1)
					} else {
						flags |= int32(DEFINITE_PUBLIC)
					}
				} else {
					flags |= int32(DEFINITE_PROTECTED)
				}
			}
		}
	}
	if !(flags&int32(SPECIAL) != 0) {
		i = 0
		for {
			if !(i < (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _1
			} else {
				mixinPtr = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					if contextCls != 0 {
						foundPrivate |= _AddPrivatesFromClassChainToCallContext(tls, mixinPtr, contextCls, methodNameObj, cbPtr, doneFilters, flags|int32(TRAVERSED_MIXIN), filterDecl)
					}
					foundPrivate |= _AddSimpleClassChainToCallContext(tls, mixinPtr, methodNameObj, cbPtr, doneFilters, flags|int32(TRAVERSED_MIXIN), filterDecl)
				}
			}
			goto _1
		_1:
			;
			i++
		}
		if (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr != 0 && !(blockedUnexported != 0) {
			hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr)).FfindProc})))(tls, (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr, methodNameObj)
			if hPtr != libc.UintptrFromInt32(0) {
				mPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
				if !((*TMethod)(unsafe.Pointer(mPtr)).Fflags&int32(TRUE_PRIVATE_METHOD) != libc.Int32FromInt32(0)) {
					_AddMethodToCallChain(tls, mPtr, cbPtr, doneFilters, filterDecl, flags)
				}
			}
		}
	}
	if !((*TObject)(unsafe.Pointer(oPtr)).FselfCls != 0) {
		return foundPrivate
	}
	if contextCls != 0 {
		foundPrivate |= _AddPrivatesFromClassChainToCallContext(tls, (*TObject)(unsafe.Pointer(oPtr)).FselfCls, contextCls, methodNameObj, cbPtr, doneFilters, flags, filterDecl)
	}
	if !(blockedUnexported != 0) {
		foundPrivate |= _AddSimpleClassChainToCallContext(tls, (*TObject)(unsafe.Pointer(oPtr)).FselfCls, methodNameObj, cbPtr, doneFilters, flags, filterDecl)
	}
	return foundPrivate
}

/*
 * ----------------------------------------------------------------------
 *
 * AddMethodToCallChain --
 *
 *	Utility method that manages the adding of a particular method
 *	implementation to a call-chain.
 *
 * ----------------------------------------------------------------------
 */

func _AddMethodToCallChain(tls *libc.TLS, mPtr uintptr, cbPtr uintptr, doneFilters uintptr, filterDecl uintptr, flags int32) {
	/* Used to check if we're mixin-consistent
	 * only. Mixin-consistent means that either
	 * we're looking to add things from a mixin
	 * and we have passed a mixin, or we're not
	 * looking to add things from a mixin and have
	 * not passed a mixin. */
	var callPtr, declCls uintptr
	var i TTcl_Size
	_, _, _ = callPtr, declCls, i
	callPtr = (*TChainBuilder)(unsafe.Pointer(cbPtr)).FcallChainPtr
	/*
	 * Return if this is just an entry used to record whether this is a public
	 * method. If so, there's nothing real to call and so nothing to add to
	 * the call chain.
	 *
	 * This is also where we enforce mixin-consistency.
	 */
	if mPtr == libc.UintptrFromInt32(0) || (*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr == libc.UintptrFromInt32(0) || !(flags&int32(OBJECT_MIXIN) != 0 || libc.BoolInt32(!(flags&int32(BUILDING_MIXINS) != 0)) == libc.BoolInt32(!(flags&int32(TRAVERSED_MIXIN) != 0))) {
		return
	}
	/*
	 * Enforce real private method handling here. We will skip adding this
	 * method IF
	 *  1) we are not allowing private methods, AND
	 *  2) this is a private method, AND
	 *  3) this is a class method, AND
	 *  4) this method was not declared by the class of the current object.
	 *
	 * This does mean that only classes really handle private methods. This
	 * should be sufficient for [incr Tcl] support though.
	 */
	if !((*TCallChain)(unsafe.Pointer(callPtr)).Fflags&(int32(PRIVATE_METHOD)|int32(TRUE_PRIVATE_METHOD)) == libc.Int32FromInt32(0)) && (*TMethod)(unsafe.Pointer(mPtr)).Fflags&(int32(PUBLIC_METHOD)|int32(PRIVATE_METHOD)|int32(TRUE_PRIVATE_METHOD)) == 0 && (*TMethod)(unsafe.Pointer(mPtr)).FdeclaringClassPtr != libc.UintptrFromInt32(0) && (*TMethod)(unsafe.Pointer(mPtr)).FdeclaringClassPtr != (*TObject)(unsafe.Pointer((*TChainBuilder)(unsafe.Pointer(cbPtr)).FoPtr)).FselfCls {
		return
	}
	/*
	 * First test whether the method is already in the call chain. Skip over
	 * any leading filters.
	 */
	i = libc.Int64FromUint64((*TChainBuilder)(unsafe.Pointer(cbPtr)).FfilterLength)
	for {
		if !(i < (*TCallChain)(unsafe.Pointer(callPtr)).FnumChain) {
			break
		}
		if (*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer(callPtr)).Fchain + uintptr(i)*24))).FmPtr == mPtr && (*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer(callPtr)).Fchain + uintptr(i)*24))).FisFilter == libc.BoolInt32(doneFilters != libc.UintptrFromInt32(0)) {
			/*
			 * Call chain semantics states that methods come as *late* in the
			 * call chain as possible. This is done by copying down the
			 * following methods. Note that this does not change the number of
			 * method invocations in the call chain; it just rearranges them.
			 */
			declCls = (*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer(callPtr)).Fchain + uintptr(i)*24))).FfilterDeclarer
			for {
				if !(i+int64(1) < (*TCallChain)(unsafe.Pointer(callPtr)).FnumChain) {
					break
				}
				*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer(callPtr)).Fchain + uintptr(i)*24)) = *(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer(callPtr)).Fchain + uintptr(i+int64(1))*24))
				goto _2
			_2:
				;
				i++
			}
			(*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer(callPtr)).Fchain + uintptr(i)*24))).FmPtr = mPtr
			(*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer(callPtr)).Fchain + uintptr(i)*24))).FisFilter = libc.BoolInt32(doneFilters != libc.UintptrFromInt32(0))
			(*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer(callPtr)).Fchain + uintptr(i)*24))).FfilterDeclarer = declCls
			return
		}
		goto _1
	_1:
		;
		i++
	}
	/*
	 * Need to really add the method. This is made a bit more complex by the
	 * fact that we are using some "static" space initially, and only start
	 * realloc-ing if the chain gets long.
	 */
	if (*TCallChain)(unsafe.Pointer(callPtr)).FnumChain == int64(CALL_CHAIN_STATIC_SIZE) {
		(*TCallChain)(unsafe.Pointer(callPtr)).Fchain = XTcl_Alloc(tls, uint64(24)*libc.Uint64FromInt64((*TCallChain)(unsafe.Pointer(callPtr)).FnumChain+libc.Int64FromInt32(1)))
		libc.Xmemcpy(tls, (*TCallChain)(unsafe.Pointer(callPtr)).Fchain, callPtr+56, uint64(24)*libc.Uint64FromInt64((*TCallChain)(unsafe.Pointer(callPtr)).FnumChain))
	} else {
		if (*TCallChain)(unsafe.Pointer(callPtr)).FnumChain > int64(CALL_CHAIN_STATIC_SIZE) {
			(*TCallChain)(unsafe.Pointer(callPtr)).Fchain = XTcl_Realloc(tls, (*TCallChain)(unsafe.Pointer(callPtr)).Fchain, uint64(24)*libc.Uint64FromInt64((*TCallChain)(unsafe.Pointer(callPtr)).FnumChain+libc.Int64FromInt32(1)))
		}
	}
	(*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer(callPtr)).Fchain + uintptr(i)*24))).FmPtr = mPtr
	(*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer(callPtr)).Fchain + uintptr(i)*24))).FisFilter = libc.BoolInt32(doneFilters != libc.UintptrFromInt32(0))
	(*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer(callPtr)).Fchain + uintptr(i)*24))).FfilterDeclarer = filterDecl
	(*TCallChain)(unsafe.Pointer(callPtr)).FnumChain++
}

/*
 * ----------------------------------------------------------------------
 *
 * InitCallChain --
 *	Encoding of the policy of how to set up a call chain. Doesn't populate
 *	the chain with the method implementation data.
 *
 * ----------------------------------------------------------------------
 */

func _InitCallChain(tls *libc.TLS, callPtr uintptr, oPtr uintptr, flags int32) {
	var v1 uintptr
	_ = v1
	/*
	 * Note that it's possible to end up with a NULL oPtr->selfCls here if
	 * there is a call into stereotypical object after it has finished running
	 * its destructor phase. Such things can't be cached for a long time so the
	 * epoch can be bogus. [Bug 7842f33a5c]
	 */
	(*TCallChain)(unsafe.Pointer(callPtr)).Fflags = flags & (int32(PUBLIC_METHOD) | int32(PRIVATE_METHOD) | int32(SPECIAL) | int32(FILTER_HANDLING))
	if (*TObject)(unsafe.Pointer(oPtr)).Fflags&int32(USE_CLASS_CACHE) != 0 {
		if (*TObject)(unsafe.Pointer(oPtr)).FselfCls != 0 {
			v1 = (*TClass)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FselfCls)).FthisPtr
		} else {
			v1 = libc.UintptrFromInt32(0)
		}
		oPtr = v1
		*(*int32)(unsafe.Pointer(callPtr + 24)) |= int32(USE_CLASS_CACHE)
	}
	if oPtr != 0 {
		(*TCallChain)(unsafe.Pointer(callPtr)).Fepoch = (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FfPtr)).Fepoch
		(*TCallChain)(unsafe.Pointer(callPtr)).FobjectCreationEpoch = (*TObject)(unsafe.Pointer(oPtr)).FcreationEpoch
		(*TCallChain)(unsafe.Pointer(callPtr)).FobjectEpoch = (*TObject)(unsafe.Pointer(oPtr)).Fepoch
	} else {
		(*TCallChain)(unsafe.Pointer(callPtr)).Fepoch = 0
		(*TCallChain)(unsafe.Pointer(callPtr)).FobjectCreationEpoch = 0
		(*TCallChain)(unsafe.Pointer(callPtr)).FobjectEpoch = 0
	}
	(*TCallChain)(unsafe.Pointer(callPtr)).FrefCount = int64(1)
	(*TCallChain)(unsafe.Pointer(callPtr)).FnumChain = 0
	(*TCallChain)(unsafe.Pointer(callPtr)).Fchain = callPtr + 56
}

/*
 * ----------------------------------------------------------------------
 *
 * IsStillValid --
 *
 *	Calculates whether the given call chain can be used for executing a
 *	method for the given object. The condition on a chain from a cached
 *	location being reusable is:
 *	- Refers to the same object (same creation epoch), and
 *	- Still across the same class structure (same global epoch), and
 *	- Still across the same object structure (same local epoch), and
 *	- No public/private/filter magic leakage (same flags, modulo the fact
 *	  that a public chain will satisfy a non-public call).
 *
 * ----------------------------------------------------------------------
 */

func _IsStillValid(tls *libc.TLS, callPtr uintptr, oPtr uintptr, flags int32, mask int32) (r int32) {
	if (*TObject)(unsafe.Pointer(oPtr)).Fflags&int32(USE_CLASS_CACHE) != 0 {
		/*
		 * If the object is in a weird state (due to stereotype tricks) then
		 * just declare the cache invalid. [Bug 7842f33a5c]
		 */
		if !((*TObject)(unsafe.Pointer(oPtr)).FselfCls != 0) {
			return 0
		}
		oPtr = (*TClass)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FselfCls)).FthisPtr
		flags |= int32(USE_CLASS_CACHE)
	}
	return libc.BoolInt32((*TCallChain)(unsafe.Pointer(callPtr)).FobjectCreationEpoch == (*TObject)(unsafe.Pointer(oPtr)).FcreationEpoch && (*TCallChain)(unsafe.Pointer(callPtr)).Fepoch == (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FfPtr)).Fepoch && (*TCallChain)(unsafe.Pointer(callPtr)).FobjectEpoch == (*TObject)(unsafe.Pointer(oPtr)).Fepoch && (*TCallChain)(unsafe.Pointer(callPtr)).Fflags&mask == flags&mask)
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOGetCallContext --
 *
 *	Responsible for constructing the call context, an ordered list of all
 *	method implementations to be called as part of a method invocation.
 *	This method is central to the whole operation of the OO system.
 *
 * ----------------------------------------------------------------------
 */

func XTclOOGetCallContext(tls *libc.TLS, oPtr uintptr, methodNameObj uintptr, flags int32, contextObj uintptr, contextCls uintptr, cacheInThisObj uintptr) (r uintptr) {
	bp := tls.Alloc(144)
	defer tls.Free(144) /* What object to cache in, or NULL if it is
	 * to be in the same object as the
	 * methodNameObj. */
	var callPtr, contextPtr, filterObj, hPtr, irPtr, mixinPtr, v2, v3 uintptr
	var count, i TTcl_Size
	var doFilters, donePrivate, reuseMask, v1 int32
	var v6 Tsize_t
	var _ /* cb at bp+0 */ TChainBuilder
	var _ /* doneFilters at bp+24 */ TTcl_HashTable
	var _ /* isNew at bp+128 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = callPtr, contextPtr, count, doFilters, donePrivate, filterObj, hPtr, i, irPtr, mixinPtr, reuseMask, v1, v2, v3, v6
	donePrivate = 0
	if cacheInThisObj == libc.UintptrFromInt32(0) {
		cacheInThisObj = methodNameObj
	}
	if flags&(int32(SPECIAL)|int32(FILTER_HANDLING)) != 0 || (*TObject)(unsafe.Pointer(oPtr)).Fflags&int32(FILTER_HANDLING) != 0 {
		hPtr = libc.UintptrFromInt32(0)
		doFilters = 0
		/*
		 * Check if we have a cached valid constructor or destructor.
		 */
		if flags&int32(CONSTRUCTOR) != 0 {
			callPtr = (*TClass)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FselfCls)).FconstructorChainPtr
			if callPtr != libc.UintptrFromInt32(0) && (*TCallChain)(unsafe.Pointer(callPtr)).FobjectEpoch == (*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FselfCls)).FthisPtr)).Fepoch && (*TCallChain)(unsafe.Pointer(callPtr)).Fepoch == (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FfPtr)).Fepoch {
				(*TCallChain)(unsafe.Pointer(callPtr)).FrefCount++
				goto returnContext
			}
		} else {
			if flags&int32(DESTRUCTOR) != 0 {
				callPtr = (*TClass)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FselfCls)).FdestructorChainPtr
				if (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Fnum == 0 && callPtr != libc.UintptrFromInt32(0) && (*TCallChain)(unsafe.Pointer(callPtr)).FobjectEpoch == (*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FselfCls)).FthisPtr)).Fepoch && (*TCallChain)(unsafe.Pointer(callPtr)).Fepoch == (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FfPtr)).Fepoch {
					(*TCallChain)(unsafe.Pointer(callPtr)).FrefCount++
					goto returnContext
				}
			}
		}
	} else {
		if flags&int32(PUBLIC_METHOD) != 0 {
			v1 = ^libc.Int32FromInt32(0)
		} else {
			v1 = ^int32(PUBLIC_METHOD)
		}
		reuseMask = v1
		if (*TTcl_Obj)(unsafe.Pointer(cacheInThisObj)).FtypePtr == uintptr(unsafe.Pointer(&_methodNameType)) {
			v3 = cacheInThisObj + 32
		} else {
			v3 = libc.UintptrFromInt32(0)
		}
		v2 = v3
		irPtr = v2
		if v2 != 0 {
			callPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(irPtr))).Fptr1
			if _IsStillValid(tls, callPtr, oPtr, flags, reuseMask) != 0 {
				(*TCallChain)(unsafe.Pointer(callPtr)).FrefCount++
				goto returnContext
			}
			XTcl_StoreInternalRep(tls, cacheInThisObj, uintptr(unsafe.Pointer(&_methodNameType)), libc.UintptrFromInt32(0))
		}
		/*
		 * Note that it's possible to end up with a NULL oPtr->selfCls here if
		 * there is a call into stereotypical object after it has finished
		 * running its destructor phase. It's quite a tangle, but at that
		 * point, we simply can't get stereotypes from the cache.
		 * [Bug 7842f33a5c]
		 */
		if (*TObject)(unsafe.Pointer(oPtr)).Fflags&int32(USE_CLASS_CACHE) != 0 && (*TObject)(unsafe.Pointer(oPtr)).FselfCls != 0 {
			if (*TClass)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FselfCls)).FclassChainCache != 0 {
				hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TClass)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FselfCls)).FclassChainCache)).FfindProc})))(tls, (*TClass)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FselfCls)).FclassChainCache, methodNameObj)
			} else {
				hPtr = libc.UintptrFromInt32(0)
			}
		} else {
			if (*TObject)(unsafe.Pointer(oPtr)).FchainCache != libc.UintptrFromInt32(0) {
				hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FchainCache)).FfindProc})))(tls, (*TObject)(unsafe.Pointer(oPtr)).FchainCache, methodNameObj)
			} else {
				hPtr = libc.UintptrFromInt32(0)
			}
		}
		if hPtr != libc.UintptrFromInt32(0) && (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData != libc.UintptrFromInt32(0) {
			callPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
			if _IsStillValid(tls, callPtr, oPtr, flags, reuseMask) != 0 {
				(*TCallChain)(unsafe.Pointer(callPtr)).FrefCount++
				goto returnContext
			}
			(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = libc.UintptrFromInt32(0)
			XTclOODeleteChain(tls, callPtr)
		}
		doFilters = int32(1)
	}
	callPtr = XTcl_Alloc(tls, uint64(152))
	_InitCallChain(tls, callPtr, oPtr, flags)
	(*(*TChainBuilder)(unsafe.Pointer(bp))).FcallChainPtr = callPtr
	(*(*TChainBuilder)(unsafe.Pointer(bp))).FfilterLength = uint64(0)
	(*(*TChainBuilder)(unsafe.Pointer(bp))).FoPtr = oPtr
	/*
	 * If we're working with a forced use of unknown, do that now.
	 */
	if flags&int32(FORCE_UNKNOWN) != 0 {
		_AddSimpleChainToCallContext(tls, oPtr, libc.UintptrFromInt32(0), (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FfPtr)).FunknownMethodNameObj, bp, libc.UintptrFromInt32(0), int32(BUILDING_MIXINS), libc.UintptrFromInt32(0))
		_AddSimpleChainToCallContext(tls, oPtr, libc.UintptrFromInt32(0), (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FfPtr)).FunknownMethodNameObj, bp, libc.UintptrFromInt32(0), 0, libc.UintptrFromInt32(0))
		*(*int32)(unsafe.Pointer(callPtr + 24)) |= int32(OO_UNKNOWN_METHOD)
		(*TCallChain)(unsafe.Pointer(callPtr)).Fepoch = 0
		if (*TCallChain)(unsafe.Pointer(callPtr)).FnumChain == 0 {
			XTclOODeleteChain(tls, callPtr)
			return libc.UintptrFromInt32(0)
		}
		goto returnContext
	}
	/*
	 * Add all defined filters (if any, and if we're going to be processing
	 * them; they're not processed for constructors, destructors or when we're
	 * in the middle of processing a filter).
	 */
	if doFilters != 0 {
		doFilters = int32(1)
		XTcl_InitObjHashTable(tls, bp+24)
		i = 0
		for {
			if !(i < (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _4
			} else {
				mixinPtr = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					_AddClassFiltersToCallContext(tls, oPtr, mixinPtr, bp, bp+24, int32(TRAVERSED_MIXIN)|int32(BUILDING_MIXINS)|int32(OBJECT_MIXIN))
					_AddClassFiltersToCallContext(tls, oPtr, mixinPtr, bp, bp+24, int32(OBJECT_MIXIN))
				}
			}
			goto _4
		_4:
			;
			i++
		}
		i = 0
		for {
			if !(i < (*TObject)(unsafe.Pointer(oPtr)).Ffilters.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Ffilters.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _5
			} else {
				filterObj = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Ffilters.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					donePrivate |= _AddSimpleChainToCallContext(tls, oPtr, contextCls, filterObj, bp, bp+24, int32(BUILDING_MIXINS), libc.UintptrFromInt32(0))
					donePrivate |= _AddSimpleChainToCallContext(tls, oPtr, contextCls, filterObj, bp, bp+24, 0, libc.UintptrFromInt32(0))
				}
			}
			goto _5
		_5:
			;
			i++
		}
		_AddClassFiltersToCallContext(tls, oPtr, (*TObject)(unsafe.Pointer(oPtr)).FselfCls, bp, bp+24, int32(BUILDING_MIXINS))
		_AddClassFiltersToCallContext(tls, oPtr, (*TObject)(unsafe.Pointer(oPtr)).FselfCls, bp, bp+24, 0)
		XTcl_DeleteHashTable(tls, bp+24)
	}
	v6 = libc.Uint64FromInt64((*TCallChain)(unsafe.Pointer(callPtr)).FnumChain)
	(*(*TChainBuilder)(unsafe.Pointer(bp))).FfilterLength = v6
	count = libc.Int64FromUint64(v6)
	/*
	 * Add the actual method implementations. We have to do this twice to
	 * handle class mixins right.
	 */
	if oPtr == contextObj {
		donePrivate |= _AddInstancePrivateToCallContext(tls, oPtr, methodNameObj, bp, flags)
		donePrivate |= (*TObject)(unsafe.Pointer(contextObj)).Fflags & int32(HAS_PRIVATE_METHODS)
	}
	donePrivate |= _AddSimpleChainToCallContext(tls, oPtr, contextCls, methodNameObj, bp, libc.UintptrFromInt32(0), flags|int32(BUILDING_MIXINS), libc.UintptrFromInt32(0))
	donePrivate |= _AddSimpleChainToCallContext(tls, oPtr, contextCls, methodNameObj, bp, libc.UintptrFromInt32(0), flags, libc.UintptrFromInt32(0))
	/*
	 * Check to see if the method has no implementation. If so, we probably
	 * need to add in a call to the unknown method. Otherwise, set up the
	 * cacheing of the method implementation (if relevant).
	 */
	if count == (*TCallChain)(unsafe.Pointer(callPtr)).FnumChain {
		/*
		 * Method does not actually exist. If we're dealing with constructors
		 * or destructors, this isn't a problem.
		 */
		if flags&int32(SPECIAL) != 0 {
			XTclOODeleteChain(tls, callPtr)
			return libc.UintptrFromInt32(0)
		}
		_AddSimpleChainToCallContext(tls, oPtr, libc.UintptrFromInt32(0), (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FfPtr)).FunknownMethodNameObj, bp, libc.UintptrFromInt32(0), int32(BUILDING_MIXINS), libc.UintptrFromInt32(0))
		_AddSimpleChainToCallContext(tls, oPtr, libc.UintptrFromInt32(0), (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FfPtr)).FunknownMethodNameObj, bp, libc.UintptrFromInt32(0), 0, libc.UintptrFromInt32(0))
		*(*int32)(unsafe.Pointer(callPtr + 24)) |= int32(OO_UNKNOWN_METHOD)
		(*TCallChain)(unsafe.Pointer(callPtr)).Fepoch = 0
		if count == (*TCallChain)(unsafe.Pointer(callPtr)).FnumChain {
			XTclOODeleteChain(tls, callPtr)
			return libc.UintptrFromInt32(0)
		}
	} else {
		if doFilters != 0 && !(donePrivate != 0) {
			if hPtr == libc.UintptrFromInt32(0) {
				if (*TObject)(unsafe.Pointer(oPtr)).Fflags&int32(USE_CLASS_CACHE) != 0 {
					if (*TClass)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FselfCls)).FclassChainCache == libc.UintptrFromInt32(0) {
						(*TClass)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FselfCls)).FclassChainCache = XTcl_Alloc(tls, uint64(104))
						XTcl_InitObjHashTable(tls, (*TClass)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FselfCls)).FclassChainCache)
					}
					hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TClass)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FselfCls)).FclassChainCache)).FcreateProc})))(tls, (*TClass)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FselfCls)).FclassChainCache, methodNameObj, bp+128)
				} else {
					if (*TObject)(unsafe.Pointer(oPtr)).FchainCache == libc.UintptrFromInt32(0) {
						(*TObject)(unsafe.Pointer(oPtr)).FchainCache = XTcl_Alloc(tls, uint64(104))
						XTcl_InitObjHashTable(tls, (*TObject)(unsafe.Pointer(oPtr)).FchainCache)
					}
					hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FchainCache)).FcreateProc})))(tls, (*TObject)(unsafe.Pointer(oPtr)).FchainCache, methodNameObj, bp+128)
				}
			}
			(*TCallChain)(unsafe.Pointer(callPtr)).FrefCount++
			(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = callPtr
			_StashCallChain(tls, cacheInThisObj, callPtr)
		} else {
			if flags&int32(CONSTRUCTOR) != 0 {
				if (*TClass)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FselfCls)).FconstructorChainPtr != 0 {
					XTclOODeleteChain(tls, (*TClass)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FselfCls)).FconstructorChainPtr)
				}
				(*TClass)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FselfCls)).FconstructorChainPtr = callPtr
				(*TCallChain)(unsafe.Pointer(callPtr)).FrefCount++
			} else {
				if flags&int32(DESTRUCTOR) != 0 && (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Fnum == 0 {
					if (*TClass)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FselfCls)).FdestructorChainPtr != 0 {
						XTclOODeleteChain(tls, (*TClass)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FselfCls)).FdestructorChainPtr)
					}
					(*TClass)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FselfCls)).FdestructorChainPtr = callPtr
					(*TCallChain)(unsafe.Pointer(callPtr)).FrefCount++
				}
			}
		}
	}
	goto returnContext
returnContext:
	;
	contextPtr = XTclStackAlloc(tls, (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FfPtr)).Finterp, uint64(32))
	(*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr = oPtr
	/*
	 * Corresponding TclOODecrRefCount() in TclOODeleteContext
	 */
	(*TObject)(unsafe.Pointer(oPtr)).FrefCount++
	(*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr = callPtr
	(*TCallContext)(unsafe.Pointer(contextPtr)).Fskip = int64(2)
	(*TCallContext)(unsafe.Pointer(contextPtr)).Findex = 0
	return contextPtr
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOGetStereotypeCallChain --
 *
 *	Construct a call-chain for a method that would be used by a
 *	stereotypical instance of the given class (i.e., where the object has
 *	no definitions special to itself).
 *
 * ----------------------------------------------------------------------
 */

func XTclOOGetStereotypeCallChain(tls *libc.TLS, clsPtr uintptr, methodNameObj uintptr, flags int32) (r uintptr) {
	bp := tls.Alloc(384)
	defer tls.Free(384) /* What sort of context are we looking for.
	 * Only the bits PUBLIC_METHOD, CONSTRUCTOR,
	 * PRIVATE_METHOD, DESTRUCTOR and
	 * FILTER_HANDLING are useful. */
	var callPtr, fPtr, hPtr uintptr
	var count TTcl_Size
	var reuseMask, v1 int32
	var v2 Tsize_t
	var _ /* cb at bp+0 */ TChainBuilder
	var _ /* doneFilters at bp+24 */ TTcl_HashTable
	var _ /* isNew at bp+376 */ int32
	var _ /* obj at bp+128 */ TObject
	_, _, _, _, _, _, _ = callPtr, count, fPtr, hPtr, reuseMask, v1, v2
	fPtr = (*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).FthisPtr)).FfPtr
	/*
	 * Note that it's possible to end up with a NULL clsPtr here if there is
	 * a call into stereotypical object after it has finished running its
	 * destructor phase. It's quite a tangle, but at that point, we simply
	 * can't get stereotypes. [Bug 7842f33a5c]
	 */
	if clsPtr == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	/*
	 * Synthesize a temporary stereotypical object so that we can use existing
	 * machinery to produce the stereotypical call chain.
	 */
	libc.Xmemset(tls, bp+128, 0, uint64(248))
	(*(*TObject)(unsafe.Pointer(bp + 128))).FfPtr = fPtr
	(*(*TObject)(unsafe.Pointer(bp + 128))).FselfCls = clsPtr
	(*(*TObject)(unsafe.Pointer(bp + 128))).FrefCount = int64(1)
	(*(*TObject)(unsafe.Pointer(bp + 128))).Fflags = int32(USE_CLASS_CACHE)
	/*
	 * Check if we can get the chain out of the Tcl_Obj method name or out of
	 * the cache. This is made a bit more complex by the fact that there are
	 * multiple different layers of cache (in the Tcl_Obj, in the object, and
	 * in the class).
	 */
	if (*TClass)(unsafe.Pointer(clsPtr)).FclassChainCache != libc.UintptrFromInt32(0) {
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).FclassChainCache)).FfindProc})))(tls, (*TClass)(unsafe.Pointer(clsPtr)).FclassChainCache, methodNameObj)
		if hPtr != libc.UintptrFromInt32(0) && (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData != libc.UintptrFromInt32(0) {
			if flags&int32(PUBLIC_METHOD) != 0 {
				v1 = ^libc.Int32FromInt32(0)
			} else {
				v1 = ^int32(PUBLIC_METHOD)
			}
			reuseMask = v1
			callPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
			if _IsStillValid(tls, callPtr, bp+128, flags, reuseMask) != 0 {
				(*TCallChain)(unsafe.Pointer(callPtr)).FrefCount++
				return callPtr
			}
			(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = libc.UintptrFromInt32(0)
			XTclOODeleteChain(tls, callPtr)
		}
	} else {
		hPtr = libc.UintptrFromInt32(0)
	}
	callPtr = XTcl_Alloc(tls, uint64(152))
	libc.Xmemset(tls, callPtr, 0, uint64(152))
	(*TCallChain)(unsafe.Pointer(callPtr)).Fflags = flags & (int32(PUBLIC_METHOD) | int32(PRIVATE_METHOD) | int32(FILTER_HANDLING))
	(*TCallChain)(unsafe.Pointer(callPtr)).Fepoch = (*TFoundation)(unsafe.Pointer(fPtr)).Fepoch
	(*TCallChain)(unsafe.Pointer(callPtr)).FobjectCreationEpoch = (*TThreadLocalData)(unsafe.Pointer((*TFoundation)(unsafe.Pointer(fPtr)).FtsdPtr)).FnsCount
	(*TCallChain)(unsafe.Pointer(callPtr)).FobjectEpoch = (*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).FthisPtr)).Fepoch
	(*TCallChain)(unsafe.Pointer(callPtr)).FrefCount = int64(1)
	(*TCallChain)(unsafe.Pointer(callPtr)).Fchain = callPtr + 56
	(*(*TChainBuilder)(unsafe.Pointer(bp))).FcallChainPtr = callPtr
	(*(*TChainBuilder)(unsafe.Pointer(bp))).FfilterLength = uint64(0)
	(*(*TChainBuilder)(unsafe.Pointer(bp))).FoPtr = bp + 128
	/*
	 * Add all defined filters (if any, and if we're going to be processing
	 * them; they're not processed for constructors, destructors or when we're
	 * in the middle of processing a filter).
	 */
	XTcl_InitObjHashTable(tls, bp+24)
	_AddClassFiltersToCallContext(tls, bp+128, clsPtr, bp, bp+24, int32(BUILDING_MIXINS))
	_AddClassFiltersToCallContext(tls, bp+128, clsPtr, bp, bp+24, 0)
	XTcl_DeleteHashTable(tls, bp+24)
	v2 = libc.Uint64FromInt64((*TCallChain)(unsafe.Pointer(callPtr)).FnumChain)
	(*(*TChainBuilder)(unsafe.Pointer(bp))).FfilterLength = v2
	count = libc.Int64FromUint64(v2)
	/*
	 * Add the actual method implementations.
	 */
	_AddSimpleChainToCallContext(tls, bp+128, libc.UintptrFromInt32(0), methodNameObj, bp, libc.UintptrFromInt32(0), flags|int32(BUILDING_MIXINS), libc.UintptrFromInt32(0))
	_AddSimpleChainToCallContext(tls, bp+128, libc.UintptrFromInt32(0), methodNameObj, bp, libc.UintptrFromInt32(0), flags, libc.UintptrFromInt32(0))
	/*
	 * Check to see if the method has no implementation. If so, we probably
	 * need to add in a call to the unknown method. Otherwise, set up the
	 * caching of the method implementation (if relevant).
	 */
	if count == (*TCallChain)(unsafe.Pointer(callPtr)).FnumChain {
		_AddSimpleChainToCallContext(tls, bp+128, libc.UintptrFromInt32(0), (*TFoundation)(unsafe.Pointer(fPtr)).FunknownMethodNameObj, bp, libc.UintptrFromInt32(0), int32(BUILDING_MIXINS), libc.UintptrFromInt32(0))
		_AddSimpleChainToCallContext(tls, bp+128, libc.UintptrFromInt32(0), (*TFoundation)(unsafe.Pointer(fPtr)).FunknownMethodNameObj, bp, libc.UintptrFromInt32(0), 0, libc.UintptrFromInt32(0))
		*(*int32)(unsafe.Pointer(callPtr + 24)) |= int32(OO_UNKNOWN_METHOD)
		(*TCallChain)(unsafe.Pointer(callPtr)).Fepoch = 0
		if count == (*TCallChain)(unsafe.Pointer(callPtr)).FnumChain {
			XTclOODeleteChain(tls, callPtr)
			return libc.UintptrFromInt32(0)
		}
	} else {
		if hPtr == libc.UintptrFromInt32(0) {
			if (*TClass)(unsafe.Pointer(clsPtr)).FclassChainCache == libc.UintptrFromInt32(0) {
				(*TClass)(unsafe.Pointer(clsPtr)).FclassChainCache = XTcl_Alloc(tls, uint64(104))
				XTcl_InitObjHashTable(tls, (*TClass)(unsafe.Pointer(clsPtr)).FclassChainCache)
			}
			hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).FclassChainCache)).FcreateProc})))(tls, (*TClass)(unsafe.Pointer(clsPtr)).FclassChainCache, methodNameObj, bp+376)
		}
		(*TCallChain)(unsafe.Pointer(callPtr)).FrefCount++
		(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = callPtr
		_StashCallChain(tls, methodNameObj, callPtr)
	}
	return callPtr
}

/*
 * ----------------------------------------------------------------------
 *
 * AddClassFiltersToCallContext --
 *
 *	Logic to make extracting all the filters from the class context much
 *	easier.
 *
 * ----------------------------------------------------------------------
 */

func _AddClassFiltersToCallContext(tls *libc.TLS, oPtr uintptr, clsPtr uintptr, cbPtr uintptr, doneFilters uintptr, flags int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Whether we've gone along a mixin link
	 * yet. */
	var clearedFlags int32
	var filterObj, mixinPtr, superPtr uintptr
	var i TTcl_Size
	var _ /* isNew at bp+0 */ int32
	_, _, _, _, _ = clearedFlags, filterObj, i, mixinPtr, superPtr
	clearedFlags = flags & ^(int32(TRAVERSED_MIXIN) | int32(OBJECT_MIXIN) | int32(BUILDING_MIXINS))
	goto tailRecurse
tailRecurse:
	;
	if clsPtr == libc.UintptrFromInt32(0) {
		return
	}
	/*
	 * Add all the filters defined by classes mixed into the main class
	 * hierarchy.
	 */
	i = 0
	for {
		if !(i < (*TClass)(unsafe.Pointer(clsPtr)).Fmixins.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _1
		} else {
			mixinPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fmixins.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				_AddClassFiltersToCallContext(tls, oPtr, mixinPtr, cbPtr, doneFilters, flags|int32(TRAVERSED_MIXIN))
			}
		}
		goto _1
	_1:
		;
		i++
	}
	/*
	 * Add all the class filters from the current class. Note that the filters
	 * are added starting at the object root, as this allows the object to
	 * override how filters work to extend their behaviour.
	 */
	if flags&int32(OBJECT_MIXIN) != 0 || libc.BoolInt32(!(flags&int32(BUILDING_MIXINS) != 0)) == libc.BoolInt32(!(flags&int32(TRAVERSED_MIXIN) != 0)) {
		i = 0
		for {
			if !(i < (*TClass)(unsafe.Pointer(clsPtr)).Ffilters.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Ffilters.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _2
			} else {
				filterObj = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Ffilters.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(doneFilters)).FcreateProc})))(tls, doneFilters, filterObj, bp)
					if *(*int32)(unsafe.Pointer(bp)) != 0 {
						_AddSimpleChainToCallContext(tls, oPtr, libc.UintptrFromInt32(0), filterObj, cbPtr, doneFilters, clearedFlags|int32(BUILDING_MIXINS), clsPtr)
						_AddSimpleChainToCallContext(tls, oPtr, libc.UintptrFromInt32(0), filterObj, cbPtr, doneFilters, clearedFlags, clsPtr)
					}
				}
			}
			goto _2
		_2:
			;
			i++
		}
	}
	/*
	 * Now process the recursive case. Notice the tail-call optimization.
	 */
	switch (*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Fnum {
	case int64(1):
		goto _3
	default:
		goto _4
	case 0:
		goto _5
	}
	goto _6
_3:
	;
	clsPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Flist))
	goto tailRecurse
_4:
	;
	i = 0
_9:
	;
	if !(i < (*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Fnum) {
		goto _7
	}
	if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
		goto _8
	} else {
		superPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Flist + uintptr(i)*8))
		if libc.Int32FromInt32(1) != 0 {
			_AddClassFiltersToCallContext(tls, oPtr, superPtr, cbPtr, doneFilters, flags)
		}
	}
	goto _8
_8:
	;
	i++
	goto _9
	goto _7
_7:
	;
_5:
	;
	return
_6:
}

/*
 * ----------------------------------------------------------------------
 *
 * AddPrivatesFromClassChainToCallContext --
 *
 *	Helper for AddSimpleChainToCallContext that is used to find private
 *	methds and add them to the call chain. Returns true when a private
 *	method is found and added. [TIP 500]
 *
 * ----------------------------------------------------------------------
 */

func _AddPrivatesFromClassChainToCallContext(tls *libc.TLS, classPtr uintptr, contextCls uintptr, methodName uintptr, cbPtr uintptr, doneFilters uintptr, flags int32, filterDecl uintptr) (r int32) {
	/* The class that declared the filter. If
	 * NULL, either the filter was declared by the
	 * object or this isn't a filter. */
	var hPtr, mPtr, superPtr uintptr
	var i TTcl_Size
	_, _, _, _ = hPtr, i, mPtr, superPtr
	/*
	 * We hard-code the tail-recursive form. It's by far the most common case
	 * *and* it is much more gentle on the stack.
	 *
	 * Note that mixins must be processed before the main class hierarchy.
	 * [Bug 1998221]
	 *
	 * Note also that it's possible to end up with a null classPtr here if
	 * there is a call into stereotypical object after it has finished running
	 * its destructor phase. [Bug 7842f33a5c]
	 */
	goto tailRecurse
tailRecurse:
	;
	if classPtr == libc.UintptrFromInt32(0) {
		return 0
	}
	i = 0
	for {
		if !(i < (*TClass)(unsafe.Pointer(classPtr)).Fmixins.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(classPtr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _1
		} else {
			superPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(classPtr)).Fmixins.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				if _AddPrivatesFromClassChainToCallContext(tls, superPtr, contextCls, methodName, cbPtr, doneFilters, flags|int32(TRAVERSED_MIXIN), filterDecl) != 0 {
					return int32(1)
				}
			}
		}
		goto _1
	_1:
		;
		i++
	}
	if classPtr == contextCls {
		hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(classPtr + 136)).FfindProc})))(tls, classPtr+136, methodName)
		if hPtr != libc.UintptrFromInt32(0) {
			mPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
			if (*TMethod)(unsafe.Pointer(mPtr)).Fflags&int32(TRUE_PRIVATE_METHOD) != 0 {
				_AddMethodToCallChain(tls, mPtr, cbPtr, doneFilters, filterDecl, flags)
				return int32(1)
			}
		}
	}
	switch (*TClass)(unsafe.Pointer(classPtr)).Fsuperclasses.Fnum {
	case int64(1):
		goto _2
	default:
		goto _3
	case 0:
		goto _4
	}
	goto _5
_2:
	;
	classPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(classPtr)).Fsuperclasses.Flist))
	goto tailRecurse
_3:
	;
	i = 0
_8:
	;
	if !(i < (*TClass)(unsafe.Pointer(classPtr)).Fsuperclasses.Fnum) {
		goto _6
	}
	if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(classPtr)).Fsuperclasses.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
		goto _7
	} else {
		superPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(classPtr)).Fsuperclasses.Flist + uintptr(i)*8))
		if libc.Int32FromInt32(1) != 0 {
			if _AddPrivatesFromClassChainToCallContext(tls, superPtr, contextCls, methodName, cbPtr, doneFilters, flags, filterDecl) != 0 {
				return int32(1)
			}
		}
	}
	goto _7
_7:
	;
	i++
	goto _8
	goto _6
_6:
	;
	/* FALLTHRU */
_4:
	;
	return 0
_5:
	;
	return r
}

/*
 * ----------------------------------------------------------------------
 *
 * AddSimpleClassChainToCallContext --
 *
 *	Construct a call-chain from a class hierarchy.
 *
 * ----------------------------------------------------------------------
 */

func _AddSimpleClassChainToCallContext(tls *libc.TLS, classPtr uintptr, methodNameObj uintptr, cbPtr uintptr, doneFilters uintptr, flags int32, filterDecl uintptr) (r int32) {
	/* The class that declared the filter. If
	 * NULL, either the filter was declared by the
	 * object or this isn't a filter. */
	var hPtr, mPtr, superPtr uintptr
	var i TTcl_Size
	var privateDanger int32
	_, _, _, _, _ = hPtr, i, mPtr, privateDanger, superPtr
	privateDanger = 0
	/*
	 * We hard-code the tail-recursive form. It's by far the most common case
	 * *and* it is much more gentle on the stack.
	 *
	 * Note that mixins must be processed before the main class hierarchy.
	 * [Bug 1998221]
	 */
	goto tailRecurse
tailRecurse:
	;
	if classPtr == libc.UintptrFromInt32(0) {
		return privateDanger
	}
	i = 0
	for {
		if !(i < (*TClass)(unsafe.Pointer(classPtr)).Fmixins.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(classPtr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _1
		} else {
			superPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(classPtr)).Fmixins.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				privateDanger |= _AddSimpleClassChainToCallContext(tls, superPtr, methodNameObj, cbPtr, doneFilters, flags|int32(TRAVERSED_MIXIN), filterDecl)
			}
		}
		goto _1
	_1:
		;
		i++
	}
	if flags&int32(CONSTRUCTOR) != 0 {
		_AddMethodToCallChain(tls, (*TClass)(unsafe.Pointer(classPtr)).FconstructorPtr, cbPtr, doneFilters, filterDecl, flags)
	} else {
		if flags&int32(DESTRUCTOR) != 0 {
			_AddMethodToCallChain(tls, (*TClass)(unsafe.Pointer(classPtr)).FdestructorPtr, cbPtr, doneFilters, filterDecl, flags)
		} else {
			hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(classPtr + 136)).FfindProc})))(tls, classPtr+136, methodNameObj)
			if (*TClass)(unsafe.Pointer(classPtr)).Fflags&int32(HAS_PRIVATE_METHODS) != 0 {
				privateDanger |= int32(1)
			}
			if hPtr != libc.UintptrFromInt32(0) {
				mPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
				if !((*TMethod)(unsafe.Pointer(mPtr)).Fflags&int32(TRUE_PRIVATE_METHOD) != libc.Int32FromInt32(0)) {
					if !(flags&int32(KNOWN_STATE) != 0) {
						if flags&int32(PUBLIC_METHOD) != 0 {
							if !((*TMethod)(unsafe.Pointer(mPtr)).Fflags&int32(PUBLIC_METHOD) != libc.Int32FromInt32(0)) {
								return privateDanger
							}
							flags |= int32(DEFINITE_PUBLIC)
						} else {
							flags |= int32(DEFINITE_PROTECTED)
						}
					}
					_AddMethodToCallChain(tls, mPtr, cbPtr, doneFilters, filterDecl, flags)
				}
			}
		}
	}
	switch (*TClass)(unsafe.Pointer(classPtr)).Fsuperclasses.Fnum {
	case int64(1):
		goto _2
	default:
		goto _3
	case 0:
		goto _4
	}
	goto _5
_2:
	;
	classPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(classPtr)).Fsuperclasses.Flist))
	goto tailRecurse
_3:
	;
	i = 0
_8:
	;
	if !(i < (*TClass)(unsafe.Pointer(classPtr)).Fsuperclasses.Fnum) {
		goto _6
	}
	if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(classPtr)).Fsuperclasses.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
		goto _7
	} else {
		superPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(classPtr)).Fsuperclasses.Flist + uintptr(i)*8))
		if libc.Int32FromInt32(1) != 0 {
			privateDanger |= _AddSimpleClassChainToCallContext(tls, superPtr, methodNameObj, cbPtr, doneFilters, flags, filterDecl)
		}
	}
	goto _7
_7:
	;
	i++
	goto _8
	goto _6
_6:
	;
	/* FALLTHRU */
_4:
	;
	return privateDanger
_5:
	;
	return r
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOORenderCallChain --
 *
 *	Create a description of a call chain. Used in [info object call],
 *	[info class call], and [self call].
 *
 * ----------------------------------------------------------------------
 */

func XTclOORenderCallChain(tls *libc.TLS, interp uintptr, callPtr uintptr) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _objPtr, cachePtr, cachePtr1, cachePtr2, cachePtr3, fPtr, filterLiteral, methodLiteral, miPtr, objectLiteral, objv, privateLiteral, resultObj, v10, v11, v12, v14, v15, v17, v18, v20, v21, v23, v6, v7, v8, v9 uintptr
	var i, v13, v16, v19, v22 TTcl_Size
	var v1, v2, v3, v4 bool
	var _ /* descObjs at bp+0 */ [4]uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, cachePtr1, cachePtr2, cachePtr3, fPtr, filterLiteral, i, methodLiteral, miPtr, objectLiteral, objv, privateLiteral, resultObj, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v3, v4, v6, v7, v8, v9
	fPtr = XTclOOGetFoundation(tls, interp)
	/*
	 * Allocate the literals (potentially) used in our description.
	 */
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		filterLiteral = XTclThreadAllocObj(tls)
	} else {
		filterLiteral = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(filterLiteral + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(filterLiteral)).FrefCount = 0
	if libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(filterLiteral)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(filterLiteral)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(filterLiteral)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(filterLiteral)).Fbytes, __ccgo_ts+26201, libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(filterLiteral)).Fbytes + uintptr(libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(filterLiteral)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(7) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(filterLiteral)).FtypePtr = libc.UintptrFromInt32(0)
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		methodLiteral = XTclThreadAllocObj(tls)
	} else {
		methodLiteral = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(methodLiteral + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(methodLiteral)).FrefCount = 0
	if libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(methodLiteral)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(methodLiteral)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(methodLiteral)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(methodLiteral)).Fbytes, __ccgo_ts+28559, libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(methodLiteral)).Fbytes + uintptr(libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(methodLiteral)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(7) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(methodLiteral)).FtypePtr = libc.UintptrFromInt32(0)
	if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
		cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
		objectLiteral = XTclThreadAllocObj(tls)
	} else {
		objectLiteral = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objectLiteral + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objectLiteral)).FrefCount = 0
	if libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(objectLiteral)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(objectLiteral)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(objectLiteral)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(objectLiteral)).Fbytes, __ccgo_ts+6499, libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objectLiteral)).Fbytes + uintptr(libc.Uint64FromInt64(7)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(objectLiteral)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(7) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(objectLiteral)).FtypePtr = libc.UintptrFromInt32(0)
	if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
		cachePtr3 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects == libc.Uint64FromInt32(0) {
		privateLiteral = XTclThreadAllocObj(tls)
	} else {
		privateLiteral = (*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr3)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(privateLiteral + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr3)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(privateLiteral)).FrefCount = 0
	if libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(privateLiteral)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(privateLiteral)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(privateLiteral)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(privateLiteral)).Fbytes, __ccgo_ts+78764, libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(privateLiteral)).Fbytes + uintptr(libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(privateLiteral)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(8) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(privateLiteral)).FtypePtr = libc.UintptrFromInt32(0)
	/*
	 * Do the actual construction of the descriptions. They consist of a list
	 * of triples that describe the details of how a method is understood. For
	 * each triple, the first word is the type of invocation ("method" is
	 * normal, "unknown" is special because it adds the method name as an
	 * extra argument when handled by some method types, and "filter" is
	 * special because it's a filter method). The second word is the name of
	 * the method in question (which differs for "unknown" and "filter" types)
	 * and the third word is the full name of the class that declares the
	 * method (or "object" if it is declared on the instance).
	 */
	objv = XTclStackAlloc(tls, interp, libc.Uint64FromInt64((*TCallChain)(unsafe.Pointer(callPtr)).FnumChain)*uint64(8))
	i = 0
	for {
		if !(i < (*TCallChain)(unsafe.Pointer(callPtr)).FnumChain) {
			break
		}
		miPtr = (*TCallChain)(unsafe.Pointer(callPtr)).Fchain + uintptr(i)*24
		if (*TMInvoke)(unsafe.Pointer(miPtr)).FisFilter != 0 {
			v6 = filterLiteral
		} else {
			if (*TCallChain)(unsafe.Pointer(callPtr)).Fflags&int32(OO_UNKNOWN_METHOD) != 0 {
				v7 = (*TFoundation)(unsafe.Pointer(fPtr)).FunknownMethodNameObj
			} else {
				if (*TMethod)(unsafe.Pointer((*TMInvoke)(unsafe.Pointer(miPtr)).FmPtr)).Fflags&int32(TRUE_PRIVATE_METHOD) != 0 {
					v8 = privateLiteral
				} else {
					v8 = methodLiteral
				}
				v7 = v8
			}
			v6 = v7
		}
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[0] = v6
		if (*TCallChain)(unsafe.Pointer(callPtr)).Fflags&int32(CONSTRUCTOR) != 0 {
			v9 = (*TFoundation)(unsafe.Pointer(fPtr)).FconstructorName
		} else {
			if (*TCallChain)(unsafe.Pointer(callPtr)).Fflags&int32(DESTRUCTOR) != 0 {
				v10 = (*TFoundation)(unsafe.Pointer(fPtr)).FdestructorName
			} else {
				v10 = (*TMethod)(unsafe.Pointer((*TMInvoke)(unsafe.Pointer(miPtr)).FmPtr)).FnamePtr
			}
			v9 = v10
		}
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(1)] = v9
		if (*TMethod)(unsafe.Pointer((*TMInvoke)(unsafe.Pointer(miPtr)).FmPtr)).FdeclaringClassPtr != 0 {
			v11 = XTcl_GetObjectName(tls, interp, (*TClass)(unsafe.Pointer((*TMethod)(unsafe.Pointer((*TMInvoke)(unsafe.Pointer(miPtr)).FmPtr)).FdeclaringClassPtr)).FthisPtr)
		} else {
			v11 = objectLiteral
		}
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(2)] = v11
		(*(*[4]uintptr)(unsafe.Pointer(bp)))[int32(3)] = XTcl_NewStringObj(tls, (*TTcl_MethodType)(unsafe.Pointer((*TMethod)(unsafe.Pointer((*TMInvoke)(unsafe.Pointer(miPtr)).FmPtr)).F__ccgo0_0.FtypePtr)).Fname, int64(-libc.Int32FromInt32(1)))
		*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)) = XTcl_NewListObj(tls, int64(4), bp)
		goto _5
	_5:
		;
		i++
	}
	/*
	 * Drop the local references to the literals; if they're actually used,
	 * they'll live on the description itself.
	 */
	v12 = filterLiteral
	if v12 != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(v12)).FrefCount == libc.Int64FromInt32(0) {
			_objPtr = v12
			v14 = _objPtr
			v13 = *(*TTcl_Size)(unsafe.Pointer(v14))
			*(*TTcl_Size)(unsafe.Pointer(v14))--
			if v13 <= libc.Int64FromInt32(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
	}
	v15 = methodLiteral
	if v15 != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(v15)).FrefCount == libc.Int64FromInt32(0) {
			_objPtr = v15
			v17 = _objPtr
			v16 = *(*TTcl_Size)(unsafe.Pointer(v17))
			*(*TTcl_Size)(unsafe.Pointer(v17))--
			if v16 <= libc.Int64FromInt32(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
	}
	v18 = objectLiteral
	if v18 != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(v18)).FrefCount == libc.Int64FromInt32(0) {
			_objPtr = v18
			v20 = _objPtr
			v19 = *(*TTcl_Size)(unsafe.Pointer(v20))
			*(*TTcl_Size)(unsafe.Pointer(v20))--
			if v19 <= libc.Int64FromInt32(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
	}
	v21 = privateLiteral
	if v21 != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(v21)).FrefCount == libc.Int64FromInt32(0) {
			_objPtr = v21
			v23 = _objPtr
			v22 = *(*TTcl_Size)(unsafe.Pointer(v23))
			*(*TTcl_Size)(unsafe.Pointer(v23))--
			if v22 <= libc.Int64FromInt32(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
	}
	/*
	 * Finish building the description and return it.
	 */
	resultObj = XTcl_NewListObj(tls, (*TCallChain)(unsafe.Pointer(callPtr)).FnumChain, objv)
	XTclStackFree(tls, interp, objv)
	return resultObj
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOGetDefineContextNamespace --
 *
 *	Responsible for determining which namespace to use for definitions.
 *	This is done by building a define chain, which models (strongly!) the
 *	way that a call chain works but with a different internal model.
 *
 *	Then it walks the chain to find the first namespace name that actually
 *	resolves to an existing namespace.
 *
 * Returns:
 *	Name of namespace, or NULL if none can be found. Note that this
 *	function does *not* set an error message in the interpreter on failure.
 *
 * ----------------------------------------------------------------------
 */

func XTclOOGetDefineContextNamespace(tls *libc.TLS, interp uintptr, oPtr uintptr, forClass int32) (r uintptr) {
	bp := tls.Alloc(96)
	defer tls.Free(96) /* What sort of context are we looking for.
	 * If true, we are going to use this for
	 * [oo::define], otherwise, we are going to
	 * use this for [oo::objdefine]. */
	var entryPtr uintptr
	var flags, i, v1 int32
	var _ /* define at bp+0 */ TDefineChain
	var _ /* nsPtr at bp+80 */ uintptr
	var _ /* staticSpace at bp+16 */ [4]TDefineEntry
	_, _, _, _ = entryPtr, flags, i, v1
	*(*uintptr)(unsafe.Pointer(bp + 80)) = libc.UintptrFromInt32(0)
	if forClass != 0 {
		v1 = int32(DEFINE_FOR_CLASS)
	} else {
		v1 = 0
	}
	flags = v1
	(*(*TDefineChain)(unsafe.Pointer(bp))).Flist = bp + 16
	(*(*TDefineChain)(unsafe.Pointer(bp))).Fnum = 0
	(*(*TDefineChain)(unsafe.Pointer(bp))).Fsize = int32(DEFINE_CHAIN_STATIC_SIZE)
	/*
	 * Add the actual define locations. We have to do this twice to handle
	 * class mixins right.
	 */
	_AddSimpleDefineNamespaces(tls, oPtr, bp, flags|int32(BUILDING_MIXINS))
	_AddSimpleDefineNamespaces(tls, oPtr, bp, flags)
	/*
	 * Go through the list until we find a namespace whose name we can
	 * resolve.
	 */
	i = 0
	if (*(*TDefineChain)(unsafe.Pointer(bp))).Fnum > libc.Int32FromInt32(0) {
		for {
			entryPtr = (*(*TDefineChain)(unsafe.Pointer(bp))).Flist + uintptr(i)*16
			if !(i < (*(*TDefineChain)(unsafe.Pointer(bp))).Fnum) {
				break
			}
			if XTclGetNamespaceFromObj(tls, interp, (*TDefineEntry)(unsafe.Pointer(entryPtr)).FnamespaceName, bp+80) == TCL_OK {
				break
			}
			XTcl_ResetResult(tls, interp)
			goto _2
		_2:
			;
			i++
		}
	}
	if (*(*TDefineChain)(unsafe.Pointer(bp))).Flist != bp+16 {
		XTclpFree(tls, (*(*TDefineChain)(unsafe.Pointer(bp))).Flist)
	}
	return *(*uintptr)(unsafe.Pointer(bp + 80))
}

/*
 * ----------------------------------------------------------------------
 *
 * AddSimpleDefineNamespaces --
 *
 *	Adds to the definition chain all the definitions provided by an
 *	object's class and its mixins, taking into account everything they
 *	inherit from.
 *
 * ----------------------------------------------------------------------
 */

func _AddSimpleDefineNamespaces(tls *libc.TLS, oPtr uintptr, definePtr uintptr, flags int32) {
	/* What sort of define chain are we
	 * building. */
	var i TTcl_Size
	var mixinPtr uintptr
	_, _ = i, mixinPtr
	i = 0
	for {
		if !(i < (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _1
		} else {
			mixinPtr = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				_AddSimpleClassDefineNamespaces(tls, mixinPtr, definePtr, flags|int32(TRAVERSED_MIXIN))
			}
		}
		goto _1
	_1:
		;
		i++
	}
	_AddSimpleClassDefineNamespaces(tls, (*TObject)(unsafe.Pointer(oPtr)).FselfCls, definePtr, flags)
}

/*
 * ----------------------------------------------------------------------
 *
 * AddSimpleClassDefineNamespaces --
 *
 *	Adds to the definition chain all the definitions provided by a class
 *	and its superclasses and its class mixins.
 *
 * ----------------------------------------------------------------------
 */

func _AddSimpleClassDefineNamespaces(tls *libc.TLS, classPtr uintptr, definePtr uintptr, flags int32) {
	/* What sort of define chain are we
	 * building. */
	var i TTcl_Size
	var superPtr uintptr
	_, _ = i, superPtr
	/*
	 * We hard-code the tail-recursive form. It's by far the most common case
	 * *and* it is much more gentle on the stack.
	 */
	goto tailRecurse
tailRecurse:
	;
	i = 0
	for {
		if !(i < (*TClass)(unsafe.Pointer(classPtr)).Fmixins.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(classPtr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _1
		} else {
			superPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(classPtr)).Fmixins.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				_AddSimpleClassDefineNamespaces(tls, superPtr, definePtr, flags|int32(TRAVERSED_MIXIN))
			}
		}
		goto _1
	_1:
		;
		i++
	}
	if flags&int32(DEFINE_FOR_CLASS) != 0 {
		_AddDefinitionNamespaceToChain(tls, classPtr, (*TClass)(unsafe.Pointer(classPtr)).FclsDefinitionNs, definePtr, flags)
	} else {
		_AddDefinitionNamespaceToChain(tls, classPtr, (*TClass)(unsafe.Pointer(classPtr)).FobjDefinitionNs, definePtr, flags)
	}
	switch (*TClass)(unsafe.Pointer(classPtr)).Fsuperclasses.Fnum {
	case int64(1):
		goto _2
	default:
		goto _3
	case 0:
		goto _4
	}
	goto _5
_2:
	;
	classPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(classPtr)).Fsuperclasses.Flist))
	goto tailRecurse
_3:
	;
	i = 0
_8:
	;
	if !(i < (*TClass)(unsafe.Pointer(classPtr)).Fsuperclasses.Fnum) {
		goto _6
	}
	if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(classPtr)).Fsuperclasses.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
		goto _7
	} else {
		superPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(classPtr)).Fsuperclasses.Flist + uintptr(i)*8))
		if libc.Int32FromInt32(1) != 0 {
			_AddSimpleClassDefineNamespaces(tls, superPtr, definePtr, flags)
		}
	}
	goto _7
_7:
	;
	i++
	goto _8
	goto _6
_6:
	;
_4:
	;
	return
_5:
}

/*
 * ----------------------------------------------------------------------
 *
 * AddDefinitionNamespaceToChain --
 *
 *	Adds a single item to the definition chain (if it is meaningful),
 *	reallocating the space for the chain if necessary.
 *
 * ----------------------------------------------------------------------
 */

func _AddDefinitionNamespaceToChain(tls *libc.TLS, definerCls uintptr, namespaceName uintptr, definePtr uintptr, flags int32) {
	/* Used to check if we're mixin-consistent
	 * only. Mixin-consistent means that either
	 * we're looking to add things from a mixin
	 * and we have passed a mixin, or we're not
	 * looking to add things from a mixin and have
	 * not passed a mixin. */
	var i int32
	var staticList uintptr
	_, _ = i, staticList
	/*
	 * Return if this entry is blank. This is also where we enforce
	 * mixin-consistency.
	 */
	if namespaceName == libc.UintptrFromInt32(0) || !(flags&int32(OBJECT_MIXIN) != 0 || libc.BoolInt32(!(flags&int32(BUILDING_MIXINS) != 0)) == libc.BoolInt32(!(flags&int32(TRAVERSED_MIXIN) != 0))) {
		return
	}
	/*
	 * First test whether the method is already in the call chain.
	 */
	i = 0
	for {
		if !(i < (*TDefineChain)(unsafe.Pointer(definePtr)).Fnum) {
			break
		}
		if (*(*TDefineEntry)(unsafe.Pointer((*TDefineChain)(unsafe.Pointer(definePtr)).Flist + uintptr(i)*16))).FdefinerCls == definerCls {
			/*
			 * Call chain semantics states that methods come as *late* in the
			 * call chain as possible. This is done by copying down the
			 * following methods. Note that this does not change the number of
			 * method invocations in the call chain; it just rearranges them.
			 *
			 * We skip changing anything if the place we found was already at
			 * the end of the list.
			 */
			if i < (*TDefineChain)(unsafe.Pointer(definePtr)).Fnum-int32(1) {
				libc.Xmemmove(tls, (*TDefineChain)(unsafe.Pointer(definePtr)).Flist+uintptr(i)*16, (*TDefineChain)(unsafe.Pointer(definePtr)).Flist+uintptr(i+int32(1))*16, uint64(16)*libc.Uint64FromInt32((*TDefineChain)(unsafe.Pointer(definePtr)).Fnum-i-libc.Int32FromInt32(1)))
				(*(*TDefineEntry)(unsafe.Pointer((*TDefineChain)(unsafe.Pointer(definePtr)).Flist + uintptr(i)*16))).FdefinerCls = definerCls
				(*(*TDefineEntry)(unsafe.Pointer((*TDefineChain)(unsafe.Pointer(definePtr)).Flist + uintptr(i)*16))).FnamespaceName = namespaceName
			}
			return
		}
		goto _1
	_1:
		;
		i++
	}
	/*
	 * Need to really add the define. This is made a bit more complex by the
	 * fact that we are using some "static" space initially, and only start
	 * realloc-ing if the chain gets long.
	 */
	if (*TDefineChain)(unsafe.Pointer(definePtr)).Fnum == (*TDefineChain)(unsafe.Pointer(definePtr)).Fsize {
		*(*int32)(unsafe.Pointer(definePtr + 12)) *= int32(2)
		if (*TDefineChain)(unsafe.Pointer(definePtr)).Fnum == int32(DEFINE_CHAIN_STATIC_SIZE) {
			staticList = (*TDefineChain)(unsafe.Pointer(definePtr)).Flist
			(*TDefineChain)(unsafe.Pointer(definePtr)).Flist = XTcl_Alloc(tls, uint64(16)*libc.Uint64FromInt32((*TDefineChain)(unsafe.Pointer(definePtr)).Fsize))
			libc.Xmemcpy(tls, (*TDefineChain)(unsafe.Pointer(definePtr)).Flist, staticList, uint64(16)*libc.Uint64FromInt32((*TDefineChain)(unsafe.Pointer(definePtr)).Fnum))
		} else {
			(*TDefineChain)(unsafe.Pointer(definePtr)).Flist = XTcl_Realloc(tls, (*TDefineChain)(unsafe.Pointer(definePtr)).Flist, uint64(16)*libc.Uint64FromInt32((*TDefineChain)(unsafe.Pointer(definePtr)).Fsize))
		}
	}
	(*(*TDefineEntry)(unsafe.Pointer((*TDefineChain)(unsafe.Pointer(definePtr)).Flist + uintptr(i)*16))).FdefinerCls = definerCls
	(*(*TDefineEntry)(unsafe.Pointer((*TDefineChain)(unsafe.Pointer(definePtr)).Flist + uintptr(i)*16))).FnamespaceName = namespaceName
	(*TDefineChain)(unsafe.Pointer(definePtr)).Fnum++
}

const OBJNAME_LENGTH_IN_ERRORINFO_LIMIT = 30
const PRIVATE_FRAME = 24
const PRIVATE_VARIABLE_PATTERN = "%d : %s"
const PUBLIC_PATTERN = "[a-z]*"
const TCL_OO_METHOD_VERSION_CURRENT3 = 1

/* !END!: Do not edit above this line. */

/*
 * Alternatives to Tcl_Preserve/Tcl_EventuallyFree/Tcl_Release.
 */

/*
 * A convenience macro for iterating through the lists used in the internal
 * memory management of objects.
 * REQUIRES DECLARATION: Tcl_Size i;
 */

/*
 * A variation where the array is an array of structs. There's no issue with
 * possible NULLs; every element of the array will be iterated over and the
 * variable set to a pointer to each of those elements in turn.
 * REQUIRES DECLARATION: Tcl_Size i; See [96551aca55] for more FOREACH_STRUCT details.
 */

/*
 * Convenience macros for iterating through hash tables. FOREACH_HASH_DECLS
 * sets up the declarations needed for the main macro, FOREACH_HASH, which
 * does the actual iteration. FOREACH_HASH_KEY and FOREACH_HASH_VALUE are
 * restricted versions that only iterate over keys or values respectively.
 * REQUIRES DECLARATION: FOREACH_HASH_DECLS;
 */

/*
 * Convenience macro for duplicating a list. Needs no external declaration,
 * but all arguments are used multiple times and so must have no side effects.
 */

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * The actual value used to mark private declaration frames.
 */

/*
 * The maximum length of fully-qualified object name to use in an errorinfo
 * message. Longer than this will be curtailed.
 */

// C documentation
//
//	/*
//	 * Some things that make it easier to declare a slot.
//	 */
type TDeclaredSlot = struct {
	Fname         uintptr
	FgetterType   TTcl_MethodType
	FsetterType   TTcl_MethodType
	FresolverType TTcl_MethodType
}

/*
 * Now define the slots used in declarations.
 */

var _slots = [12]TDeclaredSlot{
	0: {
		Fname: __ccgo_ts + 88527,
		FgetterType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 88548,
		},
		FsetterType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 88583,
		},
		FresolverType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 88618,
		},
	},
	1: {
		Fname: __ccgo_ts + 88655,
		FgetterType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 88675,
		},
		FsetterType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 88709,
		},
		FresolverType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 88743,
		},
	},
	2: {
		Fname: __ccgo_ts + 88779,
		FgetterType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 88804,
		},
		FsetterType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 88843,
		},
		FresolverType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 88882,
		},
	},
	3: {
		Fname: __ccgo_ts + 88923,
		FgetterType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 88946,
		},
		FsetterType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 88983,
		},
		FresolverType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 89020,
		},
	},
	4: {
		Fname: __ccgo_ts + 89059,
		FgetterType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 89083,
		},
		FsetterType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 89121,
		},
		FresolverType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 89159,
		},
	},
	5: {
		Fname: __ccgo_ts + 89199,
		FgetterType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 89222,
		},
		FsetterType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 89259,
		},
		FresolverType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 89296,
		},
	},
	6: {
		Fname: __ccgo_ts + 89335,
		FgetterType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 89361,
		},
		FsetterType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 89401,
		},
		FresolverType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 89441,
		},
	},
	7: {
		Fname: __ccgo_ts + 89483,
		FgetterType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 89526,
		},
		FsetterType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 89583,
		},
		FresolverType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 89640,
		},
	},
	8: {
		Fname: __ccgo_ts + 89699,
		FgetterType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 89742,
		},
		FsetterType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 89799,
		},
		FresolverType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 89856,
		},
	},
	9: {
		Fname: __ccgo_ts + 89915,
		FgetterType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 89961,
		},
		FsetterType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 90021,
		},
		FresolverType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 90081,
		},
	},
	10: {
		Fname: __ccgo_ts + 90143,
		FgetterType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 90189,
		},
		FsetterType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 90249,
		},
		FresolverType: TTcl_MethodType{
			Fversion: int32(TCL_OO_METHOD_VERSION_1),
			Fname:    __ccgo_ts + 90309,
		},
	},
	11: {},
}

func init() {
	p := unsafe.Pointer(&_slots)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_ClassFilter_Get)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(_ClassFilter_Set)
	*(*uintptr)(unsafe.Add(p, 152)) = __ccgo_fp(_ClassMixin_Get)
	*(*uintptr)(unsafe.Add(p, 192)) = __ccgo_fp(_ClassMixin_Set)
	*(*uintptr)(unsafe.Add(p, 232)) = __ccgo_fp(_ResolveClass)
	*(*uintptr)(unsafe.Add(p, 280)) = __ccgo_fp(_ClassSuper_Get)
	*(*uintptr)(unsafe.Add(p, 320)) = __ccgo_fp(_ClassSuper_Set)
	*(*uintptr)(unsafe.Add(p, 360)) = __ccgo_fp(_ResolveClass)
	*(*uintptr)(unsafe.Add(p, 408)) = __ccgo_fp(_ClassVars_Get)
	*(*uintptr)(unsafe.Add(p, 448)) = __ccgo_fp(_ClassVars_Set)
	*(*uintptr)(unsafe.Add(p, 536)) = __ccgo_fp(_ObjFilter_Get)
	*(*uintptr)(unsafe.Add(p, 576)) = __ccgo_fp(_ObjFilter_Set)
	*(*uintptr)(unsafe.Add(p, 664)) = __ccgo_fp(_ObjMixin_Get)
	*(*uintptr)(unsafe.Add(p, 704)) = __ccgo_fp(_ObjMixin_Set)
	*(*uintptr)(unsafe.Add(p, 744)) = __ccgo_fp(_ResolveClass)
	*(*uintptr)(unsafe.Add(p, 792)) = __ccgo_fp(_ObjVars_Get)
	*(*uintptr)(unsafe.Add(p, 832)) = __ccgo_fp(_ObjVars_Set)
	*(*uintptr)(unsafe.Add(p, 920)) = __ccgo_fp(_Configurable_ClassReadableProps_Get)
	*(*uintptr)(unsafe.Add(p, 960)) = __ccgo_fp(_Configurable_ClassReadableProps_Set)
	*(*uintptr)(unsafe.Add(p, 1048)) = __ccgo_fp(_Configurable_ClassWritableProps_Get)
	*(*uintptr)(unsafe.Add(p, 1088)) = __ccgo_fp(_Configurable_ClassWritableProps_Set)
	*(*uintptr)(unsafe.Add(p, 1176)) = __ccgo_fp(_Configurable_ObjectReadableProps_Get)
	*(*uintptr)(unsafe.Add(p, 1216)) = __ccgo_fp(_Configurable_ObjectReadableProps_Set)
	*(*uintptr)(unsafe.Add(p, 1304)) = __ccgo_fp(_Configurable_ObjectWritableProps_Get)
	*(*uintptr)(unsafe.Add(p, 1344)) = __ccgo_fp(_Configurable_ObjectWritableProps_Set)
}

/*
 * How to build the in-namespace name of a private variable. This is a pattern
 * used with Tcl_ObjPrintf().
 */

/*
 * ----------------------------------------------------------------------
 *
 * IsPrivateDefine --
 *
 *	Extracts whether the current context is handling private definitions.
 *
 * ----------------------------------------------------------------------
 */

func _IsPrivateDefine(tls *libc.TLS, interp uintptr) (r int32) {
	var iPtr uintptr
	_ = iPtr
	iPtr = interp
	if !((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr != 0) {
		return 0
	}
	return libc.BoolInt32((*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FisProcCallFrame == libc.Int32FromInt32(FRAME_IS_OO_DEFINE)|libc.Int32FromInt32(FRAME_IS_PRIVATE_DEFINE))
}

/*
 * ----------------------------------------------------------------------
 *
 * BumpGlobalEpoch --
 *
 *	Utility that ensures that call chains that are invalid will get thrown
 *	away at an appropriate time. Note that exactly which epoch gets
 *	advanced will depend on exactly what the class is tangled up in; in
 *	the worst case, the simplest option is to advance the global epoch,
 *	causing *everything* to be thrown away on next usage.
 *
 * ----------------------------------------------------------------------
 */

func _BumpGlobalEpoch(tls *libc.TLS, interp uintptr, classPtr uintptr) {
	var _objPtr, _objPtr1, v2, v4 uintptr
	var v1, v3 TTcl_Size
	_, _, _, _, _, _ = _objPtr, _objPtr1, v1, v2, v3, v4
	if classPtr != libc.UintptrFromInt32(0) && (*TClass)(unsafe.Pointer(classPtr)).Fsubclasses.Fnum == 0 && (*TClass)(unsafe.Pointer(classPtr)).Finstances.Fnum == 0 && (*TClass)(unsafe.Pointer(classPtr)).FmixinSubs.Fnum == 0 {
		/*
		 * If a class has no subclasses or instances, and is not mixed into
		 * anything, a change to its structure does not require us to
		 * invalidate any call chains. Note that we still bump our object's
		 * epoch if it has any mixins; the relation between a class and its
		 * representative object is special. But it won't hurt.
		 */
		if (*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(classPtr)).FthisPtr)).Fmixins.Fnum > 0 {
			(*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(classPtr)).FthisPtr)).Fepoch++
			/*
			 * Invalidate the property caches directly.
			 */
			if (*TClass)(unsafe.Pointer(classPtr)).Fproperties.FallReadableCache != 0 {
				_objPtr = (*TClass)(unsafe.Pointer(classPtr)).Fproperties.FallReadableCache
				v2 = _objPtr
				v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
				*(*TTcl_Size)(unsafe.Pointer(v2))--
				if v1 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
				(*TClass)(unsafe.Pointer(classPtr)).Fproperties.FallReadableCache = libc.UintptrFromInt32(0)
			}
			if (*TClass)(unsafe.Pointer(classPtr)).Fproperties.FallWritableCache != 0 {
				_objPtr1 = (*TClass)(unsafe.Pointer(classPtr)).Fproperties.FallWritableCache
				v4 = _objPtr1
				v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
				*(*TTcl_Size)(unsafe.Pointer(v4))--
				if v3 <= int64(1) {
					XTclFreeObj(tls, _objPtr1)
				}
				(*TClass)(unsafe.Pointer(classPtr)).Fproperties.FallWritableCache = libc.UintptrFromInt32(0)
			}
		}
		return
	}
	/*
	 * Either there's no class (?!) or we're reconfiguring something that is
	 * in use. Force regeneration of call chains and properties.
	 */
	(*TFoundation)(unsafe.Pointer(XTclOOGetFoundation(tls, interp))).Fepoch++
}

/*
 * ----------------------------------------------------------------------
 *
 * BumpInstanceEpoch --
 *
 *	Advances the epoch and clears the property cache of an object. The
 *	equivalent for classes is BumpGlobalEpoch(), as classes have a more
 *	complex set of relationships to other entities.
 *
 * ----------------------------------------------------------------------
 */

func _BumpInstanceEpoch(tls *libc.TLS, oPtr uintptr) {
	var _objPtr, _objPtr1, v2, v4 uintptr
	var v1, v3 TTcl_Size
	_, _, _, _, _, _ = _objPtr, _objPtr1, v1, v2, v3, v4
	(*TObject)(unsafe.Pointer(oPtr)).Fepoch++
	if (*TObject)(unsafe.Pointer(oPtr)).Fproperties.FallReadableCache != 0 {
		_objPtr = (*TObject)(unsafe.Pointer(oPtr)).Fproperties.FallReadableCache
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		(*TObject)(unsafe.Pointer(oPtr)).Fproperties.FallReadableCache = libc.UintptrFromInt32(0)
	}
	if (*TObject)(unsafe.Pointer(oPtr)).Fproperties.FallWritableCache != 0 {
		_objPtr1 = (*TObject)(unsafe.Pointer(oPtr)).Fproperties.FallWritableCache
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		(*TObject)(unsafe.Pointer(oPtr)).Fproperties.FallWritableCache = libc.UintptrFromInt32(0)
	}
}

/*
 * ----------------------------------------------------------------------
 *
 * RecomputeClassCacheFlag --
 *
 *	Determine whether the object is prototypical of its class, and hence
 *	able to use the class's method chain cache.
 *
 * ----------------------------------------------------------------------
 */

func _RecomputeClassCacheFlag(tls *libc.TLS, oPtr uintptr) {
	if ((*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr == libc.UintptrFromInt32(0) || (*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr)).FnumEntries == 0) && (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Fnum == 0 && (*TObject)(unsafe.Pointer(oPtr)).Ffilters.Fnum == 0 {
		*(*int32)(unsafe.Pointer(oPtr + 96)) |= int32(USE_CLASS_CACHE)
	} else {
		*(*int32)(unsafe.Pointer(oPtr + 96)) &= ^int32(USE_CLASS_CACHE)
	}
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOObjectSetFilters --
 *
 *	Install a list of filter method names into an object.
 *
 * ----------------------------------------------------------------------
 */

func XTclOOObjectSetFilters(tls *libc.TLS, oPtr uintptr, numFilters TTcl_Size, filters uintptr) {
	var _objPtr, filterObj, filtersList, v3 uintptr
	var i, v2 TTcl_Size
	var size Tsize_t
	_, _, _, _, _, _, _ = _objPtr, filterObj, filtersList, i, size, v2, v3
	if (*TObject)(unsafe.Pointer(oPtr)).Ffilters.Fnum != 0 {
		i = 0
		for {
			if !(i < (*TObject)(unsafe.Pointer(oPtr)).Ffilters.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Ffilters.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _1
			} else {
				filterObj = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Ffilters.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					_objPtr = filterObj
					v3 = _objPtr
					v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
					*(*TTcl_Size)(unsafe.Pointer(v3))--
					if v2 <= int64(1) {
						XTclFreeObj(tls, _objPtr)
					}
				}
			}
			goto _1
		_1:
			;
			i++
		}
	}
	if numFilters == 0 {
		/*
		 * No list of filters was supplied, so we're deleting filters.
		 */
		XTclpFree(tls, (*TObject)(unsafe.Pointer(oPtr)).Ffilters.Flist)
		(*TObject)(unsafe.Pointer(oPtr)).Ffilters.Flist = libc.UintptrFromInt32(0)
		(*TObject)(unsafe.Pointer(oPtr)).Ffilters.Fnum = 0
		_RecomputeClassCacheFlag(tls, oPtr)
	} else {
		size = uint64(8) * libc.Uint64FromInt64(numFilters)
		if (*TObject)(unsafe.Pointer(oPtr)).Ffilters.Fnum == 0 {
			filtersList = XTcl_Alloc(tls, size)
		} else {
			filtersList = XTcl_Realloc(tls, (*TObject)(unsafe.Pointer(oPtr)).Ffilters.Flist, size)
		}
		i = 0
		for {
			if !(i < numFilters) {
				break
			}
			*(*uintptr)(unsafe.Pointer(filtersList + uintptr(i)*8)) = *(*uintptr)(unsafe.Pointer(filters + uintptr(i)*8))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(filters + uintptr(i)*8)))).FrefCount++
			goto _4
		_4:
			;
			i++
		}
		(*TObject)(unsafe.Pointer(oPtr)).Ffilters.Flist = filtersList
		(*TObject)(unsafe.Pointer(oPtr)).Ffilters.Fnum = numFilters
		*(*int32)(unsafe.Pointer(oPtr + 96)) &= ^int32(USE_CLASS_CACHE)
	}
	_BumpInstanceEpoch(tls, oPtr) // Only this object can be affected.
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOClassSetFilters --
 *
 *	Install a list of filter method names into a class.
 *
 * ----------------------------------------------------------------------
 */

func XTclOOClassSetFilters(tls *libc.TLS, interp uintptr, classPtr uintptr, numFilters TTcl_Size, filters uintptr) {
	var _objPtr, filterObj, filtersList, v3 uintptr
	var i, v2 TTcl_Size
	var size Tsize_t
	_, _, _, _, _, _, _ = _objPtr, filterObj, filtersList, i, size, v2, v3
	if (*TClass)(unsafe.Pointer(classPtr)).Ffilters.Fnum != 0 {
		i = 0
		for {
			if !(i < (*TClass)(unsafe.Pointer(classPtr)).Ffilters.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(classPtr)).Ffilters.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _1
			} else {
				filterObj = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(classPtr)).Ffilters.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					_objPtr = filterObj
					v3 = _objPtr
					v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
					*(*TTcl_Size)(unsafe.Pointer(v3))--
					if v2 <= int64(1) {
						XTclFreeObj(tls, _objPtr)
					}
				}
			}
			goto _1
		_1:
			;
			i++
		}
	}
	if numFilters == 0 {
		/*
		 * No list of filters was supplied, so we're deleting filters.
		 */
		XTclpFree(tls, (*TClass)(unsafe.Pointer(classPtr)).Ffilters.Flist)
		(*TClass)(unsafe.Pointer(classPtr)).Ffilters.Flist = libc.UintptrFromInt32(0)
		(*TClass)(unsafe.Pointer(classPtr)).Ffilters.Fnum = 0
	} else {
		size = uint64(8) * libc.Uint64FromInt64(numFilters)
		if (*TClass)(unsafe.Pointer(classPtr)).Ffilters.Fnum == 0 {
			filtersList = XTcl_Alloc(tls, size)
		} else {
			filtersList = XTcl_Realloc(tls, (*TClass)(unsafe.Pointer(classPtr)).Ffilters.Flist, size)
		}
		i = 0
		for {
			if !(i < numFilters) {
				break
			}
			*(*uintptr)(unsafe.Pointer(filtersList + uintptr(i)*8)) = *(*uintptr)(unsafe.Pointer(filters + uintptr(i)*8))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(filters + uintptr(i)*8)))).FrefCount++
			goto _4
		_4:
			;
			i++
		}
		(*TClass)(unsafe.Pointer(classPtr)).Ffilters.Flist = filtersList
		(*TClass)(unsafe.Pointer(classPtr)).Ffilters.Fnum = numFilters
	}
	/*
	 * There may be many objects affected, so bump the global epoch.
	 */
	_BumpGlobalEpoch(tls, interp, classPtr)
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOObjectSetMixins --
 *
 *	Install a list of mixin classes into an object.
 *
 * ----------------------------------------------------------------------
 */

func XTclOOObjectSetMixins(tls *libc.TLS, oPtr uintptr, numMixins TTcl_Size, mixins uintptr) {
	var i TTcl_Size
	var mixinPtr uintptr
	_, _ = i, mixinPtr
	if numMixins == 0 {
		if (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Fnum != 0 {
			i = 0
			for {
				if !(i < (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Fnum) {
					break
				}
				if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
					goto _1
				} else {
					mixinPtr = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8))
					if libc.Int32FromInt32(1) != 0 {
						XTclOORemoveFromInstances(tls, oPtr, mixinPtr)
						XTclOODecrRefCount(tls, (*TClass)(unsafe.Pointer(mixinPtr)).FthisPtr)
					}
				}
				goto _1
			_1:
				;
				i++
			}
			XTclpFree(tls, (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist)
			(*TObject)(unsafe.Pointer(oPtr)).Fmixins.Fnum = 0
		}
		_RecomputeClassCacheFlag(tls, oPtr)
	} else {
		if (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Fnum != 0 {
			i = 0
			for {
				if !(i < (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Fnum) {
					break
				}
				if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
					goto _2
				} else {
					mixinPtr = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8))
					if libc.Int32FromInt32(1) != 0 {
						if mixinPtr != 0 && mixinPtr != (*TObject)(unsafe.Pointer(oPtr)).FselfCls {
							XTclOORemoveFromInstances(tls, oPtr, mixinPtr)
						}
						XTclOODecrRefCount(tls, (*TClass)(unsafe.Pointer(mixinPtr)).FthisPtr)
					}
				}
				goto _2
			_2:
				;
				i++
			}
			(*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist = XTcl_Realloc(tls, (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist, uint64(8)*libc.Uint64FromInt64(numMixins))
		} else {
			(*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist = XTcl_Alloc(tls, uint64(8)*libc.Uint64FromInt64(numMixins))
			*(*int32)(unsafe.Pointer(oPtr + 96)) &= ^int32(USE_CLASS_CACHE)
		}
		(*TObject)(unsafe.Pointer(oPtr)).Fmixins.Fnum = numMixins
		libc.Xmemcpy(tls, (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist, mixins, uint64(8)*libc.Uint64FromInt64(numMixins))
		i = 0
		for {
			if !(i < (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _3
			} else {
				mixinPtr = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					if mixinPtr != (*TObject)(unsafe.Pointer(oPtr)).FselfCls {
						XTclOOAddToInstances(tls, oPtr, mixinPtr)
						/*
						 * For the new copy created by memcpy().
						 */
						(*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(mixinPtr)).FthisPtr)).FrefCount++
					}
				}
			}
			goto _3
		_3:
			;
			i++
		}
	}
	_BumpInstanceEpoch(tls, oPtr)
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOClassSetMixins --
 *
 *	Install a list of mixin classes into a class.
 *
 * ----------------------------------------------------------------------
 */

func XTclOOClassSetMixins(tls *libc.TLS, interp uintptr, classPtr uintptr, numMixins TTcl_Size, mixins uintptr) {
	var i TTcl_Size
	var mixinPtr uintptr
	_, _ = i, mixinPtr
	if numMixins == 0 {
		if (*TClass)(unsafe.Pointer(classPtr)).Fmixins.Fnum != 0 {
			i = 0
			for {
				if !(i < (*TClass)(unsafe.Pointer(classPtr)).Fmixins.Fnum) {
					break
				}
				if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(classPtr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
					goto _1
				} else {
					mixinPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(classPtr)).Fmixins.Flist + uintptr(i)*8))
					if libc.Int32FromInt32(1) != 0 {
						XTclOORemoveFromMixinSubs(tls, classPtr, mixinPtr)
						XTclOODecrRefCount(tls, (*TClass)(unsafe.Pointer(mixinPtr)).FthisPtr)
					}
				}
				goto _1
			_1:
				;
				i++
			}
			XTclpFree(tls, (*TClass)(unsafe.Pointer(classPtr)).Fmixins.Flist)
			(*TClass)(unsafe.Pointer(classPtr)).Fmixins.Fnum = 0
		}
	} else {
		if (*TClass)(unsafe.Pointer(classPtr)).Fmixins.Fnum != 0 {
			i = 0
			for {
				if !(i < (*TClass)(unsafe.Pointer(classPtr)).Fmixins.Fnum) {
					break
				}
				if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(classPtr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
					goto _2
				} else {
					mixinPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(classPtr)).Fmixins.Flist + uintptr(i)*8))
					if libc.Int32FromInt32(1) != 0 {
						XTclOORemoveFromMixinSubs(tls, classPtr, mixinPtr)
						XTclOODecrRefCount(tls, (*TClass)(unsafe.Pointer(mixinPtr)).FthisPtr)
					}
				}
				goto _2
			_2:
				;
				i++
			}
			(*TClass)(unsafe.Pointer(classPtr)).Fmixins.Flist = XTcl_Realloc(tls, (*TClass)(unsafe.Pointer(classPtr)).Fmixins.Flist, uint64(8)*libc.Uint64FromInt64(numMixins))
		} else {
			(*TClass)(unsafe.Pointer(classPtr)).Fmixins.Flist = XTcl_Alloc(tls, uint64(8)*libc.Uint64FromInt64(numMixins))
		}
		(*TClass)(unsafe.Pointer(classPtr)).Fmixins.Fnum = numMixins
		libc.Xmemcpy(tls, (*TClass)(unsafe.Pointer(classPtr)).Fmixins.Flist, mixins, uint64(8)*libc.Uint64FromInt64(numMixins))
		i = 0
		for {
			if !(i < (*TClass)(unsafe.Pointer(classPtr)).Fmixins.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(classPtr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _3
			} else {
				mixinPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(classPtr)).Fmixins.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					XTclOOAddToMixinSubs(tls, classPtr, mixinPtr)
					/*
					 * For the new copy created by memcpy.
					 */
					(*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(mixinPtr)).FthisPtr)).FrefCount++
				}
			}
			goto _3
		_3:
			;
			i++
		}
	}
	_BumpGlobalEpoch(tls, interp, classPtr)
}

/*
 * ----------------------------------------------------------------------
 *
 * InstallStandardVariableMapping, InstallPrivateVariableMapping --
 *
 *	Helpers for installing standard and private variable maps.
 *
 * ----------------------------------------------------------------------
 */

func _InstallStandardVariableMapping(tls *libc.TLS, vnlPtr uintptr, varc TTcl_Size, varv uintptr) {
	bp := tls.Alloc(112)
	defer tls.Free(112)
	var _objPtr, _objPtr1, variableObj, v4, v9 uintptr
	var i, n, v3, v6, v7, v8 TTcl_Size
	var _ /* created at bp+0 */ int32
	var _ /* uniqueTable at bp+8 */ TTcl_HashTable
	_, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, i, n, variableObj, v3, v4, v6, v7, v8, v9
	i = 0
	for {
		if !(i < varc) {
			break
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(varv + uintptr(i)*8)))).FrefCount++
		goto _1
	_1:
		;
		i++
	}
	i = 0
	for {
		if !(i < (*TVariableNameList)(unsafe.Pointer(vnlPtr)).Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TVariableNameList)(unsafe.Pointer(vnlPtr)).Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _2
		} else {
			variableObj = *(*uintptr)(unsafe.Pointer((*TVariableNameList)(unsafe.Pointer(vnlPtr)).Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				_objPtr = variableObj
				v4 = _objPtr
				v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
				*(*TTcl_Size)(unsafe.Pointer(v4))--
				if v3 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
		}
		goto _2
	_2:
		;
		i++
	}
	if i != varc {
		if varc == 0 {
			XTclpFree(tls, (*TVariableNameList)(unsafe.Pointer(vnlPtr)).Flist)
		} else {
			if i != 0 {
				(*TVariableNameList)(unsafe.Pointer(vnlPtr)).Flist = XTcl_Realloc(tls, (*TVariableNameList)(unsafe.Pointer(vnlPtr)).Flist, uint64(8)*libc.Uint64FromInt64(varc))
			} else {
				(*TVariableNameList)(unsafe.Pointer(vnlPtr)).Flist = XTcl_Alloc(tls, uint64(8)*libc.Uint64FromInt64(varc))
			}
		}
	}
	(*TVariableNameList)(unsafe.Pointer(vnlPtr)).Fnum = 0
	if varc > 0 {
		XTcl_InitObjHashTable(tls, bp+8)
		v6 = libc.Int64FromInt32(0)
		n = v6
		i = v6
		for {
			if !(i < varc) {
				break
			}
			(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(bp + 8)).FcreateProc})))(tls, bp+8, *(*uintptr)(unsafe.Pointer(varv + uintptr(i)*8)), bp)
			if *(*int32)(unsafe.Pointer(bp)) != 0 {
				v7 = n
				n++
				*(*uintptr)(unsafe.Pointer((*TVariableNameList)(unsafe.Pointer(vnlPtr)).Flist + uintptr(v7)*8)) = *(*uintptr)(unsafe.Pointer(varv + uintptr(i)*8))
			} else {
				_objPtr1 = *(*uintptr)(unsafe.Pointer(varv + uintptr(i)*8))
				v9 = _objPtr1
				v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
				*(*TTcl_Size)(unsafe.Pointer(v9))--
				if v8 <= int64(1) {
					XTclFreeObj(tls, _objPtr1)
				}
			}
			goto _5
		_5:
			;
			i++
		}
		(*TVariableNameList)(unsafe.Pointer(vnlPtr)).Fnum = n
		/*
		 * Shouldn't be necessary, but maintain num/list invariant.
		 */
		if n != varc {
			(*TVariableNameList)(unsafe.Pointer(vnlPtr)).Flist = XTcl_Realloc(tls, (*TVariableNameList)(unsafe.Pointer(vnlPtr)).Flist, uint64(8)*libc.Uint64FromInt64(n))
		}
		XTcl_DeleteHashTable(tls, bp+8)
	}
}

func _InstallPrivateVariableMapping(tls *libc.TLS, pvlPtr uintptr, varc TTcl_Size, varv uintptr, creationEpoch int32) {
	bp := tls.Alloc(144)
	defer tls.Free(144)
	var _objPtr, _objPtr1, _objPtr2, privatePtr, v10, v12, v4, v6 uintptr
	var i, n, v11, v3, v5, v8, v9 TTcl_Size
	var _ /* created at bp+0 */ int32
	var _ /* uniqueTable at bp+8 */ TTcl_HashTable
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, i, n, privatePtr, v10, v11, v12, v3, v4, v5, v6, v8, v9
	i = 0
	for {
		if !(i < varc) {
			break
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(varv + uintptr(i)*8)))).FrefCount++
		goto _1
	_1:
		;
		i++
	}
	i = 0
	if (*TPrivateVariableList)(unsafe.Pointer(pvlPtr)).Fnum > libc.Int64FromInt32(0) {
		for {
			privatePtr = (*TPrivateVariableList)(unsafe.Pointer(pvlPtr)).Flist + uintptr(i)*16
			if !(i < (*TPrivateVariableList)(unsafe.Pointer(pvlPtr)).Fnum) {
				break
			}
			_objPtr = (*TPrivateVariableMapping)(unsafe.Pointer(privatePtr)).FvariableObj
			v4 = _objPtr
			v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
			*(*TTcl_Size)(unsafe.Pointer(v4))--
			if v3 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			_objPtr1 = (*TPrivateVariableMapping)(unsafe.Pointer(privatePtr)).FfullNameObj
			v6 = _objPtr1
			v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
			*(*TTcl_Size)(unsafe.Pointer(v6))--
			if v5 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
			goto _2
		_2:
			;
			i++
		}
	}
	if i != varc {
		if varc == 0 {
			XTclpFree(tls, (*TPrivateVariableList)(unsafe.Pointer(pvlPtr)).Flist)
		} else {
			if i != 0 {
				(*TPrivateVariableList)(unsafe.Pointer(pvlPtr)).Flist = XTcl_Realloc(tls, (*TPrivateVariableList)(unsafe.Pointer(pvlPtr)).Flist, uint64(16)*libc.Uint64FromInt64(varc))
			} else {
				(*TPrivateVariableList)(unsafe.Pointer(pvlPtr)).Flist = XTcl_Alloc(tls, uint64(16)*libc.Uint64FromInt64(varc))
			}
		}
	}
	(*TPrivateVariableList)(unsafe.Pointer(pvlPtr)).Fnum = 0
	if varc > 0 {
		XTcl_InitObjHashTable(tls, bp+8)
		v8 = libc.Int64FromInt32(0)
		n = v8
		i = v8
		for {
			if !(i < varc) {
				break
			}
			(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(bp + 8)).FcreateProc})))(tls, bp+8, *(*uintptr)(unsafe.Pointer(varv + uintptr(i)*8)), bp)
			if *(*int32)(unsafe.Pointer(bp)) != 0 {
				v9 = n
				n++
				privatePtr = (*TPrivateVariableList)(unsafe.Pointer(pvlPtr)).Flist + uintptr(v9)*16
				(*TPrivateVariableMapping)(unsafe.Pointer(privatePtr)).FvariableObj = *(*uintptr)(unsafe.Pointer(varv + uintptr(i)*8))
				if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(varv + uintptr(i)*8)))).Fbytes != 0 {
					v10 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(varv + uintptr(i)*8)))).Fbytes
				} else {
					v10 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(varv + uintptr(i)*8)), libc.UintptrFromInt32(0))
				}
				(*TPrivateVariableMapping)(unsafe.Pointer(privatePtr)).FfullNameObj = XTcl_ObjPrintf(tls, __ccgo_ts+90371, libc.VaList(bp+120, creationEpoch, v10))
				(*TTcl_Obj)(unsafe.Pointer((*TPrivateVariableMapping)(unsafe.Pointer(privatePtr)).FfullNameObj)).FrefCount++
			} else {
				_objPtr2 = *(*uintptr)(unsafe.Pointer(varv + uintptr(i)*8))
				v12 = _objPtr2
				v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
				*(*TTcl_Size)(unsafe.Pointer(v12))--
				if v11 <= int64(1) {
					XTclFreeObj(tls, _objPtr2)
				}
			}
			goto _7
		_7:
			;
			i++
		}
		(*TPrivateVariableList)(unsafe.Pointer(pvlPtr)).Fnum = n
		/*
		 * Shouldn't be necessary, but maintain num/list invariant.
		 */
		if n != varc {
			(*TPrivateVariableList)(unsafe.Pointer(pvlPtr)).Flist = XTcl_Realloc(tls, (*TPrivateVariableList)(unsafe.Pointer(pvlPtr)).Flist, uint64(16)*libc.Uint64FromInt64(n))
		}
		XTcl_DeleteHashTable(tls, bp+8)
	}
}

/*
 * ----------------------------------------------------------------------
 *
 * RenameDeleteMethod --
 *
 *	Core of the code to rename and delete methods.
 *
 * ----------------------------------------------------------------------
 */

func _RenameDeleteMethod(tls *libc.TLS, interp uintptr, oPtr uintptr, useClass int32, fromPtr uintptr, toPtr uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var _objPtr, hPtr, mPtr, newHPtr, v10, v12, v4, v5 uintptr
	var v11 TTcl_Size
	var _ /* isNew at bp+0 */ int32
	_, _, _, _, _, _, _, _, _ = _objPtr, hPtr, mPtr, newHPtr, v10, v11, v12, v4, v5
	newHPtr = libc.UintptrFromInt32(0)
	if !!(useClass != 0) {
		goto _1
	}
	if !!((*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr != 0) {
		goto _3
	}
	goto noSuchMethod
noSuchMethod:
	;
	if (*TTcl_Obj)(unsafe.Pointer(fromPtr)).Fbytes != 0 {
		v4 = (*TTcl_Obj)(unsafe.Pointer(fromPtr)).Fbytes
	} else {
		v4 = XTcl_GetStringFromObj(tls, fromPtr, libc.UintptrFromInt32(0))
	}
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+90379, libc.VaList(bp+16, v4)))
	if (*TTcl_Obj)(unsafe.Pointer(fromPtr)).Fbytes != 0 {
		v5 = (*TTcl_Obj)(unsafe.Pointer(fromPtr)).Fbytes
	} else {
		v5 = XTcl_GetStringFromObj(tls, fromPtr, libc.UintptrFromInt32(0))
	}
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+28950, v5, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
_3:
	;
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr)).FfindProc})))(tls, (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr, fromPtr)
	if hPtr == libc.UintptrFromInt32(0) {
		goto noSuchMethod
	}
	if !(toPtr != 0) {
		goto _6
	}
	newHPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr)).FcreateProc})))(tls, (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr, toPtr, bp)
	if !(hPtr == newHPtr) {
		goto _7
	}
	goto renameToSelf
renameToSelf:
	;
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+90404, int64(-libc.Int32FromInt32(1))))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+90435, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
	goto _8
_7:
	;
	if !!(*(*int32)(unsafe.Pointer(bp)) != 0) {
		goto _9
	}
	goto renameToExisting
renameToExisting:
	;
	if (*TTcl_Obj)(unsafe.Pointer(toPtr)).Fbytes != 0 {
		v10 = (*TTcl_Obj)(unsafe.Pointer(toPtr)).Fbytes
	} else {
		v10 = XTcl_GetStringFromObj(tls, toPtr, libc.UintptrFromInt32(0))
	}
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+90450, libc.VaList(bp+16, v10)))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+90482, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
_9:
	;
_8:
	;
_6:
	;
	goto _2
_1:
	;
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FclassPtr + 136)).FfindProc})))(tls, (*TObject)(unsafe.Pointer(oPtr)).FclassPtr+136, fromPtr)
	if hPtr == libc.UintptrFromInt32(0) {
		goto noSuchMethod
	}
	if toPtr != 0 {
		newHPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FclassPtr + 136)).FcreateProc})))(tls, (*TObject)(unsafe.Pointer(oPtr)).FclassPtr+136, toPtr, bp)
		if hPtr == newHPtr {
			goto renameToSelf
		} else {
			if !(*(*int32)(unsafe.Pointer(bp)) != 0) {
				goto renameToExisting
			}
		}
	}
_2:
	;
	/*
	 * Complete the splicing by changing the method's name.
	 */
	mPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
	if toPtr != 0 {
		(*TTcl_Obj)(unsafe.Pointer(toPtr)).FrefCount++
		_objPtr = (*TMethod)(unsafe.Pointer(mPtr)).FnamePtr
		v12 = _objPtr
		v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
		*(*TTcl_Size)(unsafe.Pointer(v12))--
		if v11 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		(*TMethod)(unsafe.Pointer(mPtr)).FnamePtr = toPtr
		(*TTcl_HashEntry)(unsafe.Pointer(newHPtr)).FclientData = mPtr
	} else {
		if !(useClass != 0) {
			_RecomputeClassCacheFlag(tls, oPtr)
		}
		XTclOODelMethodRef(tls, mPtr)
	}
	XTcl_DeleteHashEntry(tls, hPtr)
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOUnknownDefinition --
 *
 *	Handles what happens when an unknown command is encountered during the
 *	processing of a definition script. Works by finding a command in the
 *	operating definition namespace that the requested command is a unique
 *	prefix of.
 *
 * ----------------------------------------------------------------------
 */

func XTclOOUnknownDefinition(tls *libc.TLS, dummy784 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(96)
	defer tls.Free(96)
	var _objPtr, hPtr, matchedStr, newObjv, nsPtr, soughtStr, v1, v4, v6 uintptr
	var result, v3 int32
	var v5 TTcl_Size
	var _ /* nameStr at bp+32 */ uintptr
	var _ /* search at bp+0 */ TTcl_HashSearch
	var _ /* soughtLen at bp+24 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, hPtr, matchedStr, newObjv, nsPtr, result, soughtStr, v1, v3, v4, v5, v6
	nsPtr = XTcl_GetCurrentNamespace(tls, interp)
	matchedStr = libc.UintptrFromInt32(0)
	if objc < int32(2) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+90494, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+48, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+90522, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if XTclOOGetDefineCmdContext(tls, interp) == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp + 24)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp+24)
	}
	soughtStr = v1
	if *(*TTcl_Size)(unsafe.Pointer(bp + 24)) == 0 {
		goto noMatch
	}
	hPtr = XTcl_FirstHashEntry(tls, nsPtr+184, bp)
	for {
		if hPtr != libc.UintptrFromInt32(0) {
			if (*TTcl_HashTable)(unsafe.Pointer(nsPtr+184)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(nsPtr+184)).FkeyType == -int32(1) {
				v4 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
			} else {
				v4 = hPtr + 32
			}
			*(*uintptr)(unsafe.Pointer(bp + 32)) = v4
			v3 = libc.Int32FromInt32(1)
		} else {
			v3 = 0
		}
		if !(v3 != 0) {
			break
		}
		if libc.Xstrncmp(tls, soughtStr, *(*uintptr)(unsafe.Pointer(bp + 32)), libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 24)))) == 0 {
			if matchedStr != libc.UintptrFromInt32(0) {
				goto noMatch
			}
			matchedStr = *(*uintptr)(unsafe.Pointer(bp + 32))
		}
		goto _2
	_2:
		;
		hPtr = XTcl_NextHashEntry(tls, bp)
	}
	if matchedStr != libc.UintptrFromInt32(0) {
		/*
		 * Got one match, and only one match!
		 */
		newObjv = XTclStackAlloc(tls, interp, uint64(8)*libc.Uint64FromInt32(objc-libc.Int32FromInt32(1)))
		*(*uintptr)(unsafe.Pointer(newObjv)) = XTcl_NewStringObj(tls, matchedStr, int64(-libc.Int32FromInt32(1)))
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(newObjv)))).FrefCount++
		if objc > int32(2) {
			libc.Xmemcpy(tls, newObjv+uintptr(1)*8, objv+uintptr(2)*8, uint64(8)*libc.Uint64FromInt32(objc-libc.Int32FromInt32(2)))
		}
		result = XTcl_EvalObjv(tls, interp, int64(objc-int32(1)), newObjv, 0)
		_objPtr = *(*uintptr)(unsafe.Pointer(newObjv))
		v6 = _objPtr
		v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
		*(*TTcl_Size)(unsafe.Pointer(v6))--
		if v5 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		XTclStackFree(tls, interp, newObjv)
		return result
	}
	goto noMatch
noMatch:
	;
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+8511, libc.VaList(bp+48, soughtStr)))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+48, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+8118, soughtStr, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
}

/*
 * ----------------------------------------------------------------------
 *
 * FindCommand --
 *
 *	Specialized version of Tcl_FindCommand that handles command prefixes
 *	and disallows namespace magic.
 *
 * ----------------------------------------------------------------------
 */

func _FindCommand(tls *libc.TLS, interp uintptr, stringObj uintptr, namespacePtr uintptr) (r TTcl_Command) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var cmd TTcl_Command
	var hPtr, nsPtr, string1, v1, v4 uintptr
	var v3 int32
	var _ /* cmd2 at bp+40 */ TTcl_Command
	var _ /* length at bp+0 */ TTcl_Size
	var _ /* nameStr at bp+8 */ uintptr
	var _ /* search at bp+16 */ TTcl_HashSearch
	_, _, _, _, _, _, _ = cmd, hPtr, nsPtr, string1, v1, v3, v4
	if (*TTcl_Obj)(unsafe.Pointer(stringObj)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(stringObj)).Flength
		v1 = (*TTcl_Obj)(unsafe.Pointer(stringObj)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, stringObj, bp)
	}
	string1 = v1
	nsPtr = namespacePtr
	/*
	 * If someone is playing games, we stop playing right now.
	 */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(string1))) == int32('\000') || libc.Xstrstr(tls, string1, __ccgo_ts+7650) != libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	/*
	 * Do the exact lookup first.
	 */
	cmd = XTcl_FindCommand(tls, interp, string1, namespacePtr, int32(TCL_NAMESPACE_ONLY))
	if cmd != libc.UintptrFromInt32(0) {
		return cmd
	}
	/*
	 * Bother, need to perform an approximate match. Iterate across the hash
	 * table of commands in the namespace.
	 */
	hPtr = XTcl_FirstHashEntry(tls, nsPtr+184, bp+16)
	for {
		if hPtr != libc.UintptrFromInt32(0) {
			if (*TTcl_HashTable)(unsafe.Pointer(nsPtr+184)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(nsPtr+184)).FkeyType == -int32(1) {
				v4 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
			} else {
				v4 = hPtr + 32
			}
			*(*uintptr)(unsafe.Pointer(bp + 8)) = v4
			*(*uintptr)(unsafe.Pointer(bp + 40)) = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
			v3 = libc.Int32FromInt32(1)
		} else {
			v3 = 0
		}
		if !(v3 != 0) {
			break
		}
		if libc.Xstrncmp(tls, string1, *(*uintptr)(unsafe.Pointer(bp + 8)), libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp)))) == 0 {
			if cmd != libc.UintptrFromInt32(0) {
				return libc.UintptrFromInt32(0)
			}
			cmd = *(*TTcl_Command)(unsafe.Pointer(bp + 40))
		}
		goto _2
	_2:
		;
		hPtr = XTcl_NextHashEntry(tls, bp+16)
	}
	/*
	 * Either we found one thing or we found nothing. Either way, return it.
	 */
	return cmd
}

/*
 * ----------------------------------------------------------------------
 *
 * InitDefineContext --
 *
 *	Does the magic incantations necessary to push the special stack frame
 *	used when processing object definitions. It is up to the caller to
 *	dispose of the frame (with TclPopStackFrame) when finished.
 *
 * ----------------------------------------------------------------------
 */

func _InitDefineContext(tls *libc.TLS, interp uintptr, namespacePtr uintptr, oPtr uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var framePtrPtr uintptr
	var _ /* framePtr at bp+0 */ uintptr
	_ = framePtrPtr
	framePtrPtr = bp
	if namespacePtr == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+90534, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+90568, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * framePtrPtr is needed to satisfy GCC 3.3's strict aliasing rules.
	 */
	XTclPushStackFrame(tls, interp, framePtrPtr, namespacePtr, int32(FRAME_IS_OO_DEFINE))
	(*TCallFrame)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FclientData = oPtr
	(*TCallFrame)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fobjc = int64(objc)
	(*TCallFrame)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fobjv = objv /* Reference counts do not need to be
	 * incremented here. */
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOGetDefineCmdContext, TclOOGetClassDefineCmdContext --
 *
 *	Extracts the magic token from the current stack frame, or returns NULL
 *	(and leaves an error message) otherwise.
 *
 * ----------------------------------------------------------------------
 */

func XTclOOGetDefineCmdContext(tls *libc.TLS, interp uintptr) (r TTcl_Object) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var iPtr uintptr
	var object TTcl_Object
	_, _ = iPtr, object
	iPtr = interp
	if (*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr == libc.UintptrFromInt32(0) || (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FisProcCallFrame != int32(FRAME_IS_OO_DEFINE) && (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FisProcCallFrame != libc.Int32FromInt32(FRAME_IS_OO_DEFINE)|libc.Int32FromInt32(FRAME_IS_PRIVATE_DEFINE) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+90584, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+90568, libc.UintptrFromInt32(0)))
		return libc.UintptrFromInt32(0)
	}
	object = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FclientData
	if XTcl_ObjectDeleted(tls, object) != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+90686, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+90568, libc.UintptrFromInt32(0)))
		return libc.UintptrFromInt32(0)
	}
	return object
}

func XTclOOGetClassDefineCmdContext(tls *libc.TLS, interp uintptr) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var oPtr uintptr
	_ = oPtr
	oPtr = XTclOOGetDefineCmdContext(tls, interp)
	if oPtr == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	if !((*TObject)(unsafe.Pointer(oPtr)).FclassPtr != 0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+90749, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+90568, libc.UintptrFromInt32(0)))
		return libc.UintptrFromInt32(0)
	}
	return (*TObject)(unsafe.Pointer(oPtr)).FclassPtr
}

/*
 * ----------------------------------------------------------------------
 *
 * GetClassInOuterContext, GetNamespaceInOuterContext --
 *
 *	Wrappers round Tcl_GetObjectFromObj and TclGetNamespaceFromObj to
 *	perform the lookup in the context that called oo::define (or
 *	equivalent). Note that this may have to go up multiple levels to get
 *	the level that we started doing definitions at.
 *
 * ----------------------------------------------------------------------
 */

func _GetClassInOuterContext(tls *libc.TLS, interp uintptr, className uintptr, errMsg uintptr) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var iPtr, oPtr, savedFramePtr, v1 uintptr
	_, _, _, _ = iPtr, oPtr, savedFramePtr, v1
	iPtr = interp
	savedFramePtr = (*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr
	for (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FisProcCallFrame == int32(FRAME_IS_OO_DEFINE) || (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FisProcCallFrame == libc.Int32FromInt32(FRAME_IS_OO_DEFINE)|libc.Int32FromInt32(FRAME_IS_PRIVATE_DEFINE) {
		if (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FcallerVarPtr == libc.UintptrFromInt32(0) {
			XTcl_Panic(tls, __ccgo_ts+90771, 0)
		}
		(*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FcallerVarPtr
	}
	oPtr = XTcl_GetObjectFromObj(tls, interp, className)
	(*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr = savedFramePtr
	if oPtr == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	if (*TObject)(unsafe.Pointer(oPtr)).FclassPtr == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, errMsg, int64(-libc.Int32FromInt32(1))))
		if (*TTcl_Obj)(unsafe.Pointer(className)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(className)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, className, libc.UintptrFromInt32(0))
		}
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+28640, v1, libc.UintptrFromInt32(0)))
		return libc.UintptrFromInt32(0)
	}
	return (*TObject)(unsafe.Pointer(oPtr)).FclassPtr
}

func _GetNamespaceInOuterContext(tls *libc.TLS, interp uintptr, namespaceName uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var iPtr, savedFramePtr uintptr
	var result int32
	var _ /* nsPtr at bp+0 */ uintptr
	_, _, _ = iPtr, result, savedFramePtr
	iPtr = interp
	savedFramePtr = (*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr
	for (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FisProcCallFrame == int32(FRAME_IS_OO_DEFINE) || (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FisProcCallFrame == libc.Int32FromInt32(FRAME_IS_OO_DEFINE)|libc.Int32FromInt32(FRAME_IS_PRIVATE_DEFINE) {
		if (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FcallerVarPtr == libc.UintptrFromInt32(0) {
			XTcl_Panic(tls, __ccgo_ts+90771, 0)
		}
		(*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FcallerVarPtr
	}
	result = XTclGetNamespaceFromObj(tls, interp, namespaceName, bp)
	(*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr = savedFramePtr
	if result != TCL_OK {
		return libc.UintptrFromInt32(0)
	}
	return *(*uintptr)(unsafe.Pointer(bp))
}

/*
 * ----------------------------------------------------------------------
 *
 * GenerateErrorInfo --
 *
 *	Factored out code to generate part of the error trace messages.
 *
 * ----------------------------------------------------------------------
 */

func _GenerateErrorInfo(tls *libc.TLS, interp uintptr, oPtr uintptr, savedNameObj uintptr, typeOfSubject uintptr) {
	bp := tls.Alloc(64)
	defer tls.Free(64) /* Part of the message, saying whether it was
	 * an object, class or class-as-object that
	 * was being configured. */
	var limit, overflow, v3 int32
	var objName, realNameObj, v1, v2, v4 uintptr
	var _ /* length at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _ = limit, objName, overflow, realNameObj, v1, v2, v3, v4
	if XTcl_ObjectDeleted(tls, oPtr) != 0 {
		v1 = savedNameObj
	} else {
		v1 = XTclOOObjectName(tls, interp, oPtr)
	}
	realNameObj = v1
	if (*TTcl_Obj)(unsafe.Pointer(realNameObj)).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(realNameObj)).Flength
		v2 = (*TTcl_Obj)(unsafe.Pointer(realNameObj)).Fbytes
	} else {
		v2 = XTcl_GetStringFromObj(tls, realNameObj, bp)
	}
	objName = v2
	limit = int32(OBJNAME_LENGTH_IN_ERRORINFO_LIMIT)
	overflow = libc.BoolInt32(*(*TTcl_Size)(unsafe.Pointer(bp)) > int64(limit))
	if overflow != 0 {
		v3 = limit
	} else {
		v3 = int32(*(*TTcl_Size)(unsafe.Pointer(bp)))
	}
	if overflow != 0 {
		v4 = __ccgo_ts + 8560
	} else {
		v4 = __ccgo_ts + 1945
	}
	XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+90824, libc.VaList(bp+16, typeOfSubject, v3, objName, v4, XTcl_GetErrorLine(tls, interp))))
}

/*
 * ----------------------------------------------------------------------
 *
 * MagicDefinitionInvoke --
 *
 *	Part of the implementation of the "oo::define" and "oo::objdefine"
 *	commands that is used to implement the more-than-one-argument case,
 *	applying ensemble-like tricks with dispatch so that error messages are
 *	clearer. Doesn't handle the management of the stack frame.
 *
 * ----------------------------------------------------------------------
 */

func _MagicDefinitionInvoke(tls *libc.TLS, interp uintptr, nsPtr uintptr, cmdIndex int32, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _objPtr, cachePtr, cachePtr1, obj2Ptr, objPtr, v7 uintptr
	var cmd TTcl_Command
	var isRoot, offset, result int32
	var v1, v2 bool
	var v4, v5 int64
	var v6 TTcl_Size
	var _ /* dummy at bp+8 */ TTcl_Size
	var _ /* objs at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, cachePtr1, cmd, isRoot, obj2Ptr, objPtr, offset, result, v1, v2, v4, v5, v6, v7
	offset = cmdIndex + int32(1)
	/*
	 * More than one argument: fire them through the ensemble processing
	 * engine so that everything appears to be good and proper in error
	 * messages. Note that we cannot just concatenate and send through
	 * Tcl_EvalObjEx, as that doesn't do ensemble processing, and we cannot go
	 * through Tcl_EvalObjv without the extra work to pre-find the command, as
	 * that finds command names in the wrong namespace at the moment. Ugly!
	 */
	isRoot = XTclInitRewriteEnsemble(tls, interp, int64(offset), int64(1), objv)
	/*
	 * Build the list of arguments using a Tcl_Obj as a workspace. See
	 * comments above for why these contortions are necessary.
	 */
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		objPtr = XTclThreadAllocObj(tls)
	} else {
		objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr = libc.UintptrFromInt32(0)
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		obj2Ptr = XTclThreadAllocObj(tls)
	} else {
		obj2Ptr = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(obj2Ptr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(obj2Ptr)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(obj2Ptr)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(obj2Ptr)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(obj2Ptr)).FtypePtr = libc.UintptrFromInt32(0)
	cmd = _FindCommand(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(cmdIndex)*8)), nsPtr)
	if cmd == libc.UintptrFromInt32(0) {
		/*
		 * Punt this case!
		 */
		XTcl_AppendObjToObj(tls, obj2Ptr, *(*uintptr)(unsafe.Pointer(objv + uintptr(cmdIndex)*8)))
	} else {
		XTcl_GetCommandFullName(tls, interp, cmd, obj2Ptr)
	}
	XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), objPtr, obj2Ptr)
	// TODO: overflow?
	XTcl_ListObjReplace(tls, libc.UintptrFromInt32(0), objPtr, int64(1), 0, int64(objc-offset), objv+uintptr(offset)*8)
	if (*TTcl_Obj)(unsafe.Pointer(objPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr2 != 0 {
			v4 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr2)).FspanStart
		} else {
			v4 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr1 + 40 + uintptr(v4)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(objPtr + 32))).Fptr2 != 0 {
			v5 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr2)).FspanLength
		} else {
			v5 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(objPtr + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v5
		_ = libc.Int32FromInt32(TCL_OK)
	} else {
		XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), objPtr, bp+8, bp)
	}
	result = XTcl_EvalObjv(tls, interp, int64(objc-cmdIndex), *(*uintptr)(unsafe.Pointer(bp)), int32(TCL_EVAL_INVOKE))
	if isRoot != 0 {
		XTclResetRewriteEnsemble(tls, interp, int32(1))
	}
	_objPtr = objPtr
	v7 = _objPtr
	v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
	*(*TTcl_Size)(unsafe.Pointer(v7))--
	if v6 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	return result
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOODefineObjCmd --
 *
 *	Implementation of the "oo::define" command. Works by effectively doing
 *	the same as 'namespace eval', but with extra magic applied so that the
 *	object to be modified is known to the commands in the target
 *	namespace. Also does ensemble-like tricks with dispatch so that error
 *	messages are clearer.
 *
 * ----------------------------------------------------------------------
 */

func XTclOODefineObjCmd(tls *libc.TLS, dummy1195 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var cachePtr, nsPtr, oPtr, objNameObj, v1, v2, v4 uintptr
	var result int32
	var v3 TTcl_Size
	var v5 bool
	_, _, _, _, _, _, _, _, _, _ = cachePtr, nsPtr, oPtr, objNameObj, result, v1, v2, v3, v4, v5
	if objc < int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+90876)
		return int32(TCL_ERROR)
	}
	oPtr = XTcl_GetObjectFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if (*TObject)(unsafe.Pointer(oPtr)).FclassPtr == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+90900, libc.VaList(bp+8, v1)))
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+28640, v2, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Make the oo::define namespace the current namespace and evaluate the
	 * command(s).
	 */
	nsPtr = XTclOOGetDefineContextNamespace(tls, interp, oPtr, int32(1))
	if _InitDefineContext(tls, interp, nsPtr, oPtr, objc, objv) != TCL_OK {
		return int32(TCL_ERROR)
	}
	(*TObject)(unsafe.Pointer(oPtr)).FrefCount++
	if objc == int32(3) {
		objNameObj = XTclOOObjectName(tls, interp, oPtr)
		(*TTcl_Obj)(unsafe.Pointer(objNameObj)).FrefCount++
		result = XTclEvalObjEx(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), 0, (*TInterp)(unsafe.Pointer(interp)).FcmdFramePtr, int32(2))
		if result == int32(TCL_ERROR) {
			_GenerateErrorInfo(tls, interp, oPtr, objNameObj, __ccgo_ts+19296)
		}
		v4 = objNameObj
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if !(v3 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(objNameObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objNameObj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(objNameObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objNameObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(objNameObj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(objNameObj)).Flength = int64(-libc.Int32FromInt32(1))
				if v5 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v5 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v5 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, objNameObj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(objNameObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = objNameObj
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, objNameObj)
			}
		}
	} else {
		result = _MagicDefinitionInvoke(tls, interp, nsPtr, int32(2), objc, objv)
	}
	XTclOODecrRefCount(tls, oPtr)
	/*
	 * Restore the previous "current" namespace.
	 */
	XTclPopStackFrame(tls, interp)
	return result
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOObjDefObjCmd --
 *
 *	Implementation of the "oo::objdefine" command. Works by effectively
 *	doing the same as 'namespace eval', but with extra magic applied so
 *	that the object to be modified is known to the commands in the target
 *	namespace. Also does ensemble-like tricks with dispatch so that error
 *	messages are clearer.
 *
 * ----------------------------------------------------------------------
 */

func XTclOOObjDefObjCmd(tls *libc.TLS, dummy1271 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var cachePtr, nsPtr, oPtr, objNameObj, v2 uintptr
	var result int32
	var v1 TTcl_Size
	var v3 bool
	_, _, _, _, _, _, _, _ = cachePtr, nsPtr, oPtr, objNameObj, result, v1, v2, v3
	if objc < int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+90929)
		return int32(TCL_ERROR)
	}
	oPtr = XTcl_GetObjectFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Make the oo::objdefine namespace the current namespace and evaluate the
	 * command(s).
	 */
	nsPtr = XTclOOGetDefineContextNamespace(tls, interp, oPtr, 0)
	if _InitDefineContext(tls, interp, nsPtr, oPtr, objc, objv) != TCL_OK {
		return int32(TCL_ERROR)
	}
	(*TObject)(unsafe.Pointer(oPtr)).FrefCount++
	if objc == int32(3) {
		objNameObj = XTclOOObjectName(tls, interp, oPtr)
		(*TTcl_Obj)(unsafe.Pointer(objNameObj)).FrefCount++
		result = XTclEvalObjEx(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), 0, (*TInterp)(unsafe.Pointer(interp)).FcmdFramePtr, int32(2))
		if result == int32(TCL_ERROR) {
			_GenerateErrorInfo(tls, interp, oPtr, objNameObj, __ccgo_ts+6499)
		}
		v2 = objNameObj
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if !(v1 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(objNameObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objNameObj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(objNameObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objNameObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(objNameObj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(objNameObj)).Flength = int64(-libc.Int32FromInt32(1))
				if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, objNameObj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(objNameObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = objNameObj
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, objNameObj)
			}
		}
	} else {
		result = _MagicDefinitionInvoke(tls, interp, nsPtr, int32(2), objc, objv)
	}
	XTclOODecrRefCount(tls, oPtr)
	/*
	 * Restore the previous "current" namespace.
	 */
	XTclPopStackFrame(tls, interp)
	return result
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOODefineSelfObjCmd --
 *
 *	Implementation of the "self" subcommand of the "oo::define" command.
 *	Works by effectively doing the same as 'namespace eval', but with
 *	extra magic applied so that the object to be modified is known to the
 *	commands in the target namespace. Also does ensemble-like tricks with
 *	dispatch so that error messages are clearer.
 *
 * ----------------------------------------------------------------------
 */

func XTclOODefineSelfObjCmd(tls *libc.TLS, dummy1340 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var cachePtr, nsPtr, oPtr, objNameObj, v2 uintptr
	var isPrivate, result int32
	var v1 TTcl_Size
	var v3 bool
	_, _, _, _, _, _, _, _, _ = cachePtr, isPrivate, nsPtr, oPtr, objNameObj, result, v1, v2, v3
	oPtr = XTclOOGetDefineCmdContext(tls, interp)
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if objc < int32(2) {
		XTcl_SetObjResult(tls, interp, XTclOOObjectName(tls, interp, oPtr))
		return TCL_OK
	}
	isPrivate = _IsPrivateDefine(tls, interp)
	/*
	 * Make the oo::objdefine namespace the current namespace and evaluate the
	 * command(s).
	 */
	nsPtr = XTclOOGetDefineContextNamespace(tls, interp, oPtr, 0)
	if _InitDefineContext(tls, interp, nsPtr, oPtr, objc, objv) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if isPrivate != 0 {
		(*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FisProcCallFrame = libc.Int32FromInt32(FRAME_IS_OO_DEFINE) | libc.Int32FromInt32(FRAME_IS_PRIVATE_DEFINE)
	}
	(*TObject)(unsafe.Pointer(oPtr)).FrefCount++
	if objc == int32(2) {
		objNameObj = XTclOOObjectName(tls, interp, oPtr)
		(*TTcl_Obj)(unsafe.Pointer(objNameObj)).FrefCount++
		result = XTclEvalObjEx(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), 0, (*TInterp)(unsafe.Pointer(interp)).FcmdFramePtr, int32(1))
		if result == int32(TCL_ERROR) {
			_GenerateErrorInfo(tls, interp, oPtr, objNameObj, __ccgo_ts+90954)
		}
		v2 = objNameObj
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if !(v1 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(objNameObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objNameObj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(objNameObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objNameObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(objNameObj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(objNameObj)).Flength = int64(-libc.Int32FromInt32(1))
				if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v3 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, objNameObj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(objNameObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = objNameObj
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, objNameObj)
			}
		}
	} else {
		result = _MagicDefinitionInvoke(tls, interp, nsPtr, int32(1), objc, objv)
	}
	XTclOODecrRefCount(tls, oPtr)
	/*
	 * Restore the previous "current" namespace.
	 */
	XTclPopStackFrame(tls, interp)
	return result
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOODefineObjSelfObjCmd --
 *
 *	Implementation of the "self" subcommand of the "oo::objdefine"
 *	command.
 *
 * ----------------------------------------------------------------------
 */

func XTclOODefineObjSelfObjCmd(tls *libc.TLS, dummy1411 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var oPtr uintptr
	_ = oPtr
	if objc != int32(1) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, libc.UintptrFromInt32(0))
		return int32(TCL_ERROR)
	}
	oPtr = XTclOOGetDefineCmdContext(tls, interp)
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTclOOObjectName(tls, interp, oPtr))
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOODefinePrivateObjCmd --
 *
 *	Implementation of the "private" subcommand of the "oo::define"
 *	and "oo::objdefine" commands.
 *
 * ----------------------------------------------------------------------
 */

func XTclOODefinePrivateObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var cachePtr, iPtr, oPtr, objNameObj, v1, v3 uintptr
	var isInstancePrivate, result, saved int32
	var v2 TTcl_Size
	var v4 bool
	_, _, _, _, _, _, _, _, _, _, _ = cachePtr, iPtr, isInstancePrivate, oPtr, objNameObj, result, saved, v1, v2, v3, v4
	isInstancePrivate = libc.BoolInt32(clientData != libc.UintptrFromInt32(0))
	/* Just so that we can generate the correct
	 * error message depending on the context of
	 * usage of this function. */
	iPtr = interp
	oPtr = XTclOOGetDefineCmdContext(tls, interp)
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if objc == int32(1) {
		XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(_IsPrivateDefine(tls, interp) != 0)))
		return TCL_OK
	}
	/*
	 * Change the frame type flag while evaluating the body.
	 */
	saved = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FisProcCallFrame
	(*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FisProcCallFrame = libc.Int32FromInt32(FRAME_IS_OO_DEFINE) | libc.Int32FromInt32(FRAME_IS_PRIVATE_DEFINE)
	/*
	 * Evaluate the body; standard pattern.
	 */
	(*TObject)(unsafe.Pointer(oPtr)).FrefCount++
	if objc == int32(2) {
		objNameObj = XTclOOObjectName(tls, interp, oPtr)
		(*TTcl_Obj)(unsafe.Pointer(objNameObj)).FrefCount++
		result = XTclEvalObjEx(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), 0, (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr, int32(1))
		if result == int32(TCL_ERROR) {
			if isInstancePrivate != 0 {
				v1 = __ccgo_ts + 6499
			} else {
				v1 = __ccgo_ts + 19296
			}
			_GenerateErrorInfo(tls, interp, oPtr, objNameObj, v1)
		}
		v3 = objNameObj
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if !(v2 > int64(1)) {
			if !((*TTcl_Obj)(unsafe.Pointer(objNameObj)).FtypePtr != 0) || !((*TTcl_ObjType)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(objNameObj)).FtypePtr)).FfreeIntRepProc != 0) {
				if (*TTcl_Obj)(unsafe.Pointer(objNameObj)).Fbytes != 0 && (*TTcl_Obj)(unsafe.Pointer(objNameObj)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
					XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(objNameObj)).Fbytes)
				}
				(*TTcl_Obj)(unsafe.Pointer(objNameObj)).Flength = int64(-libc.Int32FromInt32(1))
				if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
					cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
				}
				if v4 || ((*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == uint64(0) || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects >= uint64(ALLOC_NOBJHIGH)) {
					XTclThreadFreeObj(tls, objNameObj)
				} else {
					(*(*struct {
						Fptr1 uintptr
						Fptr2 uintptr
					})(unsafe.Pointer(objNameObj + 32))).Fptr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = objNameObj
					(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects++
				}
			} else {
				XTclFreeObj(tls, objNameObj)
			}
		}
	} else {
		result = _MagicDefinitionInvoke(tls, interp, (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FnsPtr, int32(1), objc, objv)
	}
	XTclOODecrRefCount(tls, oPtr)
	/*
	 * Restore the frame type flag to what it was previously.
	 */
	(*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr)).FisProcCallFrame = saved
	return result
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOODefineClassObjCmd --
 *
 *	Implementation of the "class" subcommand of the "oo::objdefine"
 *	command.
 *
 * ----------------------------------------------------------------------
 */

func XTclOODefineClassObjCmd(tls *libc.TLS, dummy1518 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var clsPtr, fPtr, oPtr uintptr
	var wasClass, willBeClass int32
	_, _, _, _, _ = clsPtr, fPtr, oPtr, wasClass, willBeClass
	fPtr = XTclOOGetFoundation(tls, interp)
	/*
	 * Parse the context to get the object to operate on.
	 */
	oPtr = XTclOOGetDefineCmdContext(tls, interp)
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if (*TObject)(unsafe.Pointer(oPtr)).Fflags&int32(ROOT_OBJECT) != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+90967, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+90568, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if (*TObject)(unsafe.Pointer(oPtr)).Fflags&int32(ROOT_CLASS) != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+91017, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+90568, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Parse the argument to get the class to set the object's class to.
	 */
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+28610)
		return int32(TCL_ERROR)
	}
	clsPtr = _GetClassInOuterContext(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), __ccgo_ts+91066)
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if oPtr == (*TClass)(unsafe.Pointer(clsPtr)).FthisPtr {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+91105, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+90568, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Set the object's class.
	 */
	wasClass = libc.BoolInt32((*TObject)(unsafe.Pointer(oPtr)).FclassPtr != libc.UintptrFromInt32(0))
	willBeClass = XTclOOIsReachable(tls, (*TFoundation)(unsafe.Pointer(fPtr)).FclassCls, clsPtr)
	if (*TObject)(unsafe.Pointer(oPtr)).FselfCls != clsPtr {
		XTclOORemoveFromInstances(tls, oPtr, (*TObject)(unsafe.Pointer(oPtr)).FselfCls)
		XTclOODecrRefCount(tls, (*TClass)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FselfCls)).FthisPtr)
		(*TObject)(unsafe.Pointer(oPtr)).FselfCls = clsPtr
		(*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FselfCls)).FthisPtr)).FrefCount++
		XTclOOAddToInstances(tls, oPtr, (*TObject)(unsafe.Pointer(oPtr)).FselfCls)
		/*
		 * Create or delete the class guts if necessary.
		 */
		if wasClass != 0 && !(willBeClass != 0) {
			/*
			 * This is the most global of all epochs. Bump it! No cache can be
			 * trusted!
			 */
			XTclOORemoveFromMixins(tls, (*TObject)(unsafe.Pointer(oPtr)).FclassPtr, oPtr)
			(*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FfPtr)).Fepoch++
			*(*int32)(unsafe.Pointer(oPtr + 96)) |= int32(DONT_DELETE)
			XTclOODeleteDescendants(tls, interp, oPtr)
			*(*int32)(unsafe.Pointer(oPtr + 96)) &= ^int32(DONT_DELETE)
			XTclOOReleaseClassContents(tls, interp, oPtr)
			XTclpFree(tls, (*TObject)(unsafe.Pointer(oPtr)).FclassPtr)
			(*TObject)(unsafe.Pointer(oPtr)).FclassPtr = libc.UintptrFromInt32(0)
		} else {
			if !(wasClass != 0) && willBeClass != 0 {
				XTclOOAllocClass(tls, interp, oPtr)
			}
		}
		if (*TObject)(unsafe.Pointer(oPtr)).FclassPtr != libc.UintptrFromInt32(0) {
			_BumpGlobalEpoch(tls, interp, (*TObject)(unsafe.Pointer(oPtr)).FclassPtr)
		} else {
			_BumpInstanceEpoch(tls, oPtr)
		}
	}
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOODefineConstructorObjCmd --
 *
 *	Implementation of the "constructor" subcommand of the "oo::define"
 *	command.
 *
 * ----------------------------------------------------------------------
 */

func XTclOODefineConstructorObjCmd(tls *libc.TLS, dummy1630 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var clsPtr uintptr
	var method TTcl_Method
	var _ /* bodyLength at bp+0 */ TTcl_Size
	_, _ = clsPtr, method
	clsPtr = XTclOOGetClassDefineCmdContext(tls, interp)
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	} else {
		if objc != int32(3) {
			XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+91159)
			return int32(TCL_ERROR)
		}
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Flength
		_ = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
	} else {
		XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), bp)
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp)) > 0 {
		/*
		 * Create the method structure.
		 */
		method = XTclOONewProcMethod(tls, interp, clsPtr, int32(PUBLIC_METHOD), libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + 1*8)), *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		if method == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
	} else {
		/*
		 * Delete the constructor method record and set the field in the
		 * class record to NULL.
		 */
		method = libc.UintptrFromInt32(0)
	}
	/*
	 * Place the method structure in the class record. Note that we might not
	 * immediately delete the constructor as this might be being done during
	 * execution of the constructor itself.
	 */
	XTcl_ClassSetConstructor(tls, interp, clsPtr, method)
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOODefineDefnNsObjCmd --
 *
 *	Implementation of the "definitionnamespace" subcommand of the
 *	"oo::define" command.
 *
 * ----------------------------------------------------------------------
 */

func XTclOODefineDefnNsObjCmd(tls *libc.TLS, dummy1689 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var _objPtr, clsPtr, nsNamePtr, nsPtr, storagePtr, v1, v3 uintptr
	var v2 TTcl_Size
	var _ /* kind at bp+0 */ int32
	_, _, _, _, _, _, _, _ = _objPtr, clsPtr, nsNamePtr, nsPtr, storagePtr, v1, v2, v3
	*(*int32)(unsafe.Pointer(bp)) = 0
	clsPtr = XTclOOGetClassDefineCmdContext(tls, interp)
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	} else {
		if (*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).FthisPtr)).Fflags&(int32(ROOT_OBJECT)|int32(ROOT_CLASS)) != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+91191, int64(-libc.Int32FromInt32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+90568, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
	}
	/*
	 * Parse the arguments and work out what the user wants to do.
	 */
	if objc != int32(2) && objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+91251)
		return int32(TCL_ERROR)
	}
	if objc == int32(3) && XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), uintptr(unsafe.Pointer(&_kindList)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+91268, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), libc.UintptrFromInt32(0))
	}
	if !(*(*uint8)(unsafe.Pointer(v1)) != 0) {
		nsNamePtr = libc.UintptrFromInt32(0)
	} else {
		nsPtr = _GetNamespaceInOuterContext(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)))
		if nsPtr == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
		nsNamePtr = XTclNewNamespaceObj(tls, nsPtr)
		(*TTcl_Obj)(unsafe.Pointer(nsNamePtr)).FrefCount++
	}
	/*
	 * Update the correct field of the class definition.
	 */
	if *(*int32)(unsafe.Pointer(bp)) != 0 {
		storagePtr = clsPtr + 328
	} else {
		storagePtr = clsPtr + 320
	}
	if *(*uintptr)(unsafe.Pointer(storagePtr)) != libc.UintptrFromInt32(0) {
		_objPtr = *(*uintptr)(unsafe.Pointer(storagePtr))
		v3 = _objPtr
		v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
		*(*TTcl_Size)(unsafe.Pointer(v3))--
		if v2 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	*(*uintptr)(unsafe.Pointer(storagePtr)) = nsNamePtr
	return TCL_OK
}

var _kindList = [3]uintptr{
	0: __ccgo_ts + 91174,
	1: __ccgo_ts + 91181,
	2: libc.UintptrFromInt32(0),
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOODefineDeleteMethodObjCmd --
 *
 *	Implementation of the "deletemethod" subcommand of the "oo::define"
 *	and "oo::objdefine" commands.
 *
 * ----------------------------------------------------------------------
 */

func XTclOODefineDeleteMethodObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var i, isInstanceDeleteMethod int32
	var oPtr uintptr
	_, _, _ = i, isInstanceDeleteMethod, oPtr
	isInstanceDeleteMethod = libc.BoolInt32(clientData != libc.UintptrFromInt32(0))
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+15474)
		return int32(TCL_ERROR)
	}
	oPtr = XTclOOGetDefineCmdContext(tls, interp)
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if !(isInstanceDeleteMethod != 0) && !((*TObject)(unsafe.Pointer(oPtr)).FclassPtr != 0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+90749, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+90568, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	i = int32(1)
	for {
		if !(i < objc) {
			break
		}
		/*
		 * Delete the method structure from the appropriate hash table.
		 */
		if _RenameDeleteMethod(tls, interp, oPtr, libc.BoolInt32(!(isInstanceDeleteMethod != 0)), *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), libc.UintptrFromInt32(0)) != TCL_OK {
			return int32(TCL_ERROR)
		}
		goto _1
	_1:
		;
		i++
	}
	if isInstanceDeleteMethod != 0 {
		_BumpInstanceEpoch(tls, oPtr)
	} else {
		_BumpGlobalEpoch(tls, interp, (*TObject)(unsafe.Pointer(oPtr)).FclassPtr)
	}
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOODefineDestructorObjCmd --
 *
 *	Implementation of the "destructor" subcommand of the "oo::define"
 *	command.
 *
 * ----------------------------------------------------------------------
 */

func XTclOODefineDestructorObjCmd(tls *libc.TLS, dummy1823 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var clsPtr uintptr
	var method TTcl_Method
	var _ /* bodyLength at bp+0 */ TTcl_Size
	_, _ = clsPtr, method
	clsPtr = XTclOOGetClassDefineCmdContext(tls, interp)
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	} else {
		if objc != int32(2) {
			XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+15995)
			return int32(TCL_ERROR)
		}
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Flength
		_ = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), bp)
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp)) > 0 {
		/*
		 * Create the method structure.
		 */
		method = XTclOONewProcMethod(tls, interp, clsPtr, int32(PUBLIC_METHOD), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
		if method == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
	} else {
		/*
		 * Delete the destructor method record and set the field in the class
		 * record to NULL.
		 */
		method = libc.UintptrFromInt32(0)
	}
	/*
	 * Place the method structure in the class record. Note that we might not
	 * immediately delete the destructor as this might be being done during
	 * execution of the destructor itself. Also note that setting a
	 * destructor during a destructor is fairly dumb anyway.
	 */
	XTcl_ClassSetDestructor(tls, interp, clsPtr, method)
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOODefineExportObjCmd --
 *
 *	Implementation of the "export" subcommand of the "oo::define" and
 *	"oo::objdefine" commands.
 *
 * ----------------------------------------------------------------------
 */

func XTclOODefineExportObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var changed, i, isInstanceExport int32
	var clsPtr, hPtr, mPtr, oPtr uintptr
	var _ /* isNew at bp+0 */ int32
	_, _, _, _, _, _, _ = changed, clsPtr, hPtr, i, isInstanceExport, mPtr, oPtr
	isInstanceExport = libc.BoolInt32(clientData != libc.UintptrFromInt32(0))
	changed = 0
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+15474)
		return int32(TCL_ERROR)
	}
	oPtr = XTclOOGetDefineCmdContext(tls, interp)
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	clsPtr = (*TObject)(unsafe.Pointer(oPtr)).FclassPtr
	if !(isInstanceExport != 0) && !(clsPtr != 0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+90749, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+90568, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	i = int32(1)
	for {
		if !(i < objc) {
			break
		}
		/*
		 * Exporting is done by adding the PUBLIC_METHOD flag to the method
		 * record. If there is no such method in this object or class (i.e.
		 * the method comes from something inherited from or that we're an
		 * instance of) then we put in a blank record with that flag; such
		 * records are skipped over by the call chain engine *except* for
		 * their flags member.
		 */
		if isInstanceExport != 0 {
			if !((*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr != 0) {
				(*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr = XTcl_Alloc(tls, uint64(104))
				XTcl_InitObjHashTable(tls, (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr)
				*(*int32)(unsafe.Pointer(oPtr + 96)) &= ^int32(USE_CLASS_CACHE)
			}
			hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr)).FcreateProc})))(tls, (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp)
		} else {
			hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(clsPtr + 136)).FcreateProc})))(tls, clsPtr+136, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp)
		}
		if *(*int32)(unsafe.Pointer(bp)) != 0 {
			mPtr = XTcl_Alloc(tls, uint64(56))
			libc.Xmemset(tls, mPtr, 0, uint64(56))
			(*TMethod)(unsafe.Pointer(mPtr)).FrefCount = int64(1)
			(*TMethod)(unsafe.Pointer(mPtr)).FnamePtr = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FrefCount++
			(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = mPtr
		} else {
			mPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		}
		if *(*int32)(unsafe.Pointer(bp)) != 0 || !((*TMethod)(unsafe.Pointer(mPtr)).Fflags&(int32(PUBLIC_METHOD)|int32(PRIVATE_METHOD)) != 0) {
			*(*int32)(unsafe.Pointer(mPtr + 48)) |= int32(PUBLIC_METHOD)
			*(*int32)(unsafe.Pointer(mPtr + 48)) &= ^int32(TRUE_PRIVATE_METHOD)
			changed = int32(1)
		}
		goto _1
	_1:
		;
		i++
	}
	/*
	 * Bump the right epoch if we actually changed anything.
	 */
	if changed != 0 {
		if isInstanceExport != 0 {
			_BumpInstanceEpoch(tls, oPtr)
		} else {
			_BumpGlobalEpoch(tls, interp, clsPtr)
		}
	}
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOODefineForwardObjCmd --
 *
 *	Implementation of the "forward" subcommand of the "oo::define" and
 *	"oo::objdefine" commands.
 *
 * ----------------------------------------------------------------------
 */

func XTclOODefineForwardObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var _objPtr, mPtr, oPtr, prefixObj, v2, v4 uintptr
	var isInstanceForward, isPublic, v1 int32
	var v3 TTcl_Size
	_, _, _, _, _, _, _, _, _, _ = _objPtr, isInstanceForward, isPublic, mPtr, oPtr, prefixObj, v1, v2, v3, v4
	isInstanceForward = libc.BoolInt32(clientData != libc.UintptrFromInt32(0))
	if objc < int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+91273)
		return int32(TCL_ERROR)
	}
	oPtr = XTclOOGetDefineCmdContext(tls, interp)
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if !(isInstanceForward != 0) && !((*TObject)(unsafe.Pointer(oPtr)).FclassPtr != 0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+90749, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+90568, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
		v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
	} else {
		v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
	}
	if XTcl_StringCaseMatch(tls, v2, __ccgo_ts+86892, 0) != 0 {
		v1 = int32(PUBLIC_METHOD)
	} else {
		v1 = 0
	}
	isPublic = v1
	if _IsPrivateDefine(tls, interp) != 0 {
		isPublic = int32(TRUE_PRIVATE_METHOD)
	}
	/*
	 * Create the method structure.
	 */
	prefixObj = XTcl_NewListObj(tls, int64(objc-int32(2)), objv+uintptr(2)*8)
	if isInstanceForward != 0 {
		mPtr = XTclOONewForwardInstanceMethod(tls, interp, oPtr, isPublic, *(*uintptr)(unsafe.Pointer(objv + 1*8)), prefixObj)
	} else {
		mPtr = XTclOONewForwardMethod(tls, interp, (*TObject)(unsafe.Pointer(oPtr)).FclassPtr, isPublic, *(*uintptr)(unsafe.Pointer(objv + 1*8)), prefixObj)
	}
	if mPtr == libc.UintptrFromInt32(0) {
		_objPtr = prefixObj
		v4 = _objPtr
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOODefineMethodObjCmd --
 *
 *	Implementation of the "method" subcommand of the "oo::define" and
 *	"oo::objdefine" commands.
 *
 * ----------------------------------------------------------------------
 */

func XTclOODefineMethodObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var isInstanceMethod, isPublic, v1 int32
	var oPtr, v2 uintptr
	var _ /* exportMode at bp+0 */ int32
	_, _, _, _, _ = isInstanceMethod, isPublic, oPtr, v1, v2
	isInstanceMethod = libc.BoolInt32(clientData != libc.UintptrFromInt32(0))
	isPublic = 0
	if objc < int32(4) || objc > int32(5) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+91323)
		return int32(TCL_ERROR)
	}
	oPtr = XTclOOGetDefineCmdContext(tls, interp)
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if !(isInstanceMethod != 0) && !((*TObject)(unsafe.Pointer(oPtr)).FclassPtr != 0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+90749, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+90568, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if objc == int32(5) {
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), uintptr(unsafe.Pointer(&_exportModes)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+91347, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
			return int32(TCL_ERROR)
		}
		switch *(*int32)(unsafe.Pointer(bp)) {
		case 0:
			isPublic = int32(PUBLIC_METHOD)
		case 1:
			isPublic = int32(TRUE_PRIVATE_METHOD)
		case 2:
			isPublic = 0
			break
		}
	} else {
		if _IsPrivateDefine(tls, interp) != 0 {
			isPublic = int32(TRUE_PRIVATE_METHOD)
		} else {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes != 0 {
				v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 1*8)))).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 1*8)), libc.UintptrFromInt32(0))
			}
			if XTcl_StringCaseMatch(tls, v2, __ccgo_ts+86892, 0) != 0 {
				v1 = int32(PUBLIC_METHOD)
			} else {
				v1 = 0
			}
			isPublic = v1
		}
	}
	/*
	 * Create the method by using the right back-end API.
	 */
	if isInstanceMethod != 0 {
		if XTclOONewProcInstanceMethod(tls, interp, oPtr, isPublic, *(*uintptr)(unsafe.Pointer(objv + 1*8)), *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)), *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), libc.UintptrFromInt32(0)) == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
	} else {
		if XTclOONewProcMethod(tls, interp, (*TObject)(unsafe.Pointer(oPtr)).FclassPtr, isPublic, *(*uintptr)(unsafe.Pointer(objv + 1*8)), *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(2))*8)), *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), libc.UintptrFromInt32(0)) == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
	}
	return TCL_OK
}

/*
 * Table of export modes for methods and their corresponding enum.
 */

var _exportModes = [4]uintptr{
	0: __ccgo_ts + 91296,
	1: __ccgo_ts + 91304,
	2: __ccgo_ts + 91313,
	3: libc.UintptrFromInt32(0),
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOODefineRenameMethodObjCmd --
 *
 *	Implementation of the "renamemethod" subcommand of the "oo::define"
 *	and "oo::objdefine" commands.
 *
 * ----------------------------------------------------------------------
 */

func XTclOODefineRenameMethodObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var isInstanceRenameMethod int32
	var oPtr uintptr
	_, _ = isInstanceRenameMethod, oPtr
	isInstanceRenameMethod = libc.BoolInt32(clientData != libc.UintptrFromInt32(0))
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+18990)
		return int32(TCL_ERROR)
	}
	oPtr = XTclOOGetDefineCmdContext(tls, interp)
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if !(isInstanceRenameMethod != 0) && !((*TObject)(unsafe.Pointer(oPtr)).FclassPtr != 0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+90749, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+90568, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	/*
	 * Delete the method entry from the appropriate hash table, and transfer
	 * the thing it points to to its new entry. To do this, we first need to
	 * get the entries from the appropriate hash tables (this can generate a
	 * range of errors...)
	 */
	if _RenameDeleteMethod(tls, interp, oPtr, libc.BoolInt32(!(isInstanceRenameMethod != 0)), *(*uintptr)(unsafe.Pointer(objv + 1*8)), *(*uintptr)(unsafe.Pointer(objv + 2*8))) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if isInstanceRenameMethod != 0 {
		_BumpInstanceEpoch(tls, oPtr)
	} else {
		_BumpGlobalEpoch(tls, interp, (*TObject)(unsafe.Pointer(oPtr)).FclassPtr)
	}
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOODefineUnexportObjCmd --
 *
 *	Implementation of the "unexport" subcommand of the "oo::define" and
 *	"oo::objdefine" commands.
 *
 * ----------------------------------------------------------------------
 */

func XTclOODefineUnexportObjCmd(tls *libc.TLS, clientData uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var changed, i, isInstanceUnexport int32
	var clsPtr, hPtr, mPtr, oPtr uintptr
	var _ /* isNew at bp+0 */ int32
	_, _, _, _, _, _, _ = changed, clsPtr, hPtr, i, isInstanceUnexport, mPtr, oPtr
	isInstanceUnexport = libc.BoolInt32(clientData != libc.UintptrFromInt32(0))
	changed = 0
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+15474)
		return int32(TCL_ERROR)
	}
	oPtr = XTclOOGetDefineCmdContext(tls, interp)
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	clsPtr = (*TObject)(unsafe.Pointer(oPtr)).FclassPtr
	if !(isInstanceUnexport != 0) && !(clsPtr != 0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+90749, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+90568, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	i = int32(1)
	for {
		if !(i < objc) {
			break
		}
		/*
		 * Unexporting is done by removing the PUBLIC_METHOD flag from the
		 * method record. If there is no such method in this object or class
		 * (i.e. the method comes from something inherited from or that we're
		 * an instance of) then we put in a blank record without that flag;
		 * such records are skipped over by the call chain engine *except* for
		 * their flags member.
		 */
		if isInstanceUnexport != 0 {
			if !((*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr != 0) {
				(*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr = XTcl_Alloc(tls, uint64(104))
				XTcl_InitObjHashTable(tls, (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr)
				*(*int32)(unsafe.Pointer(oPtr + 96)) &= ^int32(USE_CLASS_CACHE)
			}
			hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr)).FcreateProc})))(tls, (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp)
		} else {
			hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(clsPtr + 136)).FcreateProc})))(tls, clsPtr+136, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp)
		}
		if *(*int32)(unsafe.Pointer(bp)) != 0 {
			mPtr = XTcl_Alloc(tls, uint64(56))
			libc.Xmemset(tls, mPtr, 0, uint64(56))
			(*TMethod)(unsafe.Pointer(mPtr)).FrefCount = int64(1)
			(*TMethod)(unsafe.Pointer(mPtr)).FnamePtr = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
			(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FrefCount++
			(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = mPtr
		} else {
			mPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		}
		if *(*int32)(unsafe.Pointer(bp)) != 0 || (*TMethod)(unsafe.Pointer(mPtr)).Fflags&(int32(PUBLIC_METHOD)|int32(TRUE_PRIVATE_METHOD)) != 0 {
			*(*int32)(unsafe.Pointer(mPtr + 48)) &= ^(int32(PUBLIC_METHOD) | int32(TRUE_PRIVATE_METHOD))
			changed = int32(1)
		}
		goto _1
	_1:
		;
		i++
	}
	/*
	 * Bump the right epoch if we actually changed anything.
	 */
	if changed != 0 {
		if isInstanceUnexport != 0 {
			_BumpInstanceEpoch(tls, oPtr)
		} else {
			_BumpGlobalEpoch(tls, interp, clsPtr)
		}
	}
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * Tcl_ClassSetConstructor, Tcl_ClassSetDestructor --
 *
 *	How to install a constructor or destructor into a class; API to call
 *	from C.
 *
 * ----------------------------------------------------------------------
 */

func XTcl_ClassSetConstructor(tls *libc.TLS, interp uintptr, clazz TTcl_Class, method TTcl_Method) {
	var clsPtr uintptr
	_ = clsPtr
	clsPtr = clazz
	if method != (*TClass)(unsafe.Pointer(clsPtr)).FconstructorPtr {
		XTclOODelMethodRef(tls, (*TClass)(unsafe.Pointer(clsPtr)).FconstructorPtr)
		(*TClass)(unsafe.Pointer(clsPtr)).FconstructorPtr = method
		/*
		 * Remember to invalidate the cached constructor chain for this class.
		 * [Bug 2531577]
		 */
		if (*TClass)(unsafe.Pointer(clsPtr)).FconstructorChainPtr != 0 {
			XTclOODeleteChain(tls, (*TClass)(unsafe.Pointer(clsPtr)).FconstructorChainPtr)
			(*TClass)(unsafe.Pointer(clsPtr)).FconstructorChainPtr = libc.UintptrFromInt32(0)
		}
		_BumpGlobalEpoch(tls, interp, clsPtr)
	}
}

func XTcl_ClassSetDestructor(tls *libc.TLS, interp uintptr, clazz TTcl_Class, method TTcl_Method) {
	var clsPtr uintptr
	_ = clsPtr
	clsPtr = clazz
	if method != (*TClass)(unsafe.Pointer(clsPtr)).FdestructorPtr {
		XTclOODelMethodRef(tls, (*TClass)(unsafe.Pointer(clsPtr)).FdestructorPtr)
		(*TClass)(unsafe.Pointer(clsPtr)).FdestructorPtr = method
		if (*TClass)(unsafe.Pointer(clsPtr)).FdestructorChainPtr != 0 {
			XTclOODeleteChain(tls, (*TClass)(unsafe.Pointer(clsPtr)).FdestructorChainPtr)
			(*TClass)(unsafe.Pointer(clsPtr)).FdestructorChainPtr = libc.UintptrFromInt32(0)
		}
		_BumpGlobalEpoch(tls, interp, clsPtr)
	}
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOODefineSlots --
 *
 *	Create the "::oo::Slot" class and its standard instances. Class
 *	definition is empty at the stage (added by scripting).
 *
 * ----------------------------------------------------------------------
 */

func XTclOODefineSlots(tls *libc.TLS, fPtr uintptr) (r int32) {
	var _objPtr, cachePtr, cachePtr1, cachePtr2, getName, interp, resolveName, setName, slotCls, slotInfoPtr, v10, v11, v13, v5, v7, v8 uintptr
	var object, slotObject TTcl_Object
	var v1, v2, v3 bool
	var v12, v6, v9 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, cachePtr1, cachePtr2, getName, interp, object, resolveName, setName, slotCls, slotInfoPtr, slotObject, v1, v10, v11, v12, v13, v2, v3, v5, v6, v7, v8, v9
	interp = (*TFoundation)(unsafe.Pointer(fPtr)).Finterp
	object = XTcl_NewObjectInstance(tls, interp, (*TFoundation)(unsafe.Pointer(fPtr)).FclassCls, __ccgo_ts+91359, libc.UintptrFromInt32(0), int64(-libc.Int32FromInt32(1)), libc.UintptrFromInt32(0), 0)
	if object == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	slotCls = (*TObject)(unsafe.Pointer(object)).FclassPtr
	if slotCls == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		getName = XTclThreadAllocObj(tls)
	} else {
		getName = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(getName + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(getName)).FrefCount = 0
	if libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(getName)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(getName)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(getName)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(getName)).Fbytes, __ccgo_ts+91370, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(getName)).Fbytes + uintptr(libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(getName)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(4) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(getName)).FtypePtr = libc.UintptrFromInt32(0)
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
		setName = XTclThreadAllocObj(tls)
	} else {
		setName = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(setName + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(setName)).FrefCount = 0
	if libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(setName)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(setName)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(setName)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(setName)).Fbytes, __ccgo_ts+91374, libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(setName)).Fbytes + uintptr(libc.Uint64FromInt64(4)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(setName)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(4) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(setName)).FtypePtr = libc.UintptrFromInt32(0)
	if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
		cachePtr2 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects == libc.Uint64FromInt32(0) {
		resolveName = XTclThreadAllocObj(tls)
	} else {
		resolveName = (*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resolveName + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr2)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resolveName)).FrefCount = 0
	if libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1) == uint64(0) {
		(*TTcl_Obj)(unsafe.Pointer(resolveName)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(resolveName)).Flength = int64(libc.Int32FromInt32(0))
	} else {
		(*TTcl_Obj)(unsafe.Pointer(resolveName)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
		libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(resolveName)).Fbytes, __ccgo_ts+91378, libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1))
		*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(resolveName)).Fbytes + uintptr(libc.Uint64FromInt64(8)-libc.Uint64FromInt32(1)))) = uint8('\000')
		(*TTcl_Obj)(unsafe.Pointer(resolveName)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(8) - libc.Uint64FromInt32(1))
	}
	(*TTcl_Obj)(unsafe.Pointer(resolveName)).FtypePtr = libc.UintptrFromInt32(0)
	slotInfoPtr = uintptr(unsafe.Pointer(&_slots))
	for {
		if !((*TDeclaredSlot)(unsafe.Pointer(slotInfoPtr)).Fname != 0) {
			break
		}
		slotObject = XTcl_NewObjectInstance(tls, interp, slotCls, (*TDeclaredSlot)(unsafe.Pointer(slotInfoPtr)).Fname, libc.UintptrFromInt32(0), int64(-libc.Int32FromInt32(1)), libc.UintptrFromInt32(0), 0)
		if slotObject == libc.UintptrFromInt32(0) {
			goto _4
		}
		XTclNewInstanceMethod(tls, interp, slotObject, getName, 0, slotInfoPtr+8, libc.UintptrFromInt32(0))
		XTclNewInstanceMethod(tls, interp, slotObject, setName, 0, slotInfoPtr+48, libc.UintptrFromInt32(0))
		if (*TDeclaredSlot)(unsafe.Pointer(slotInfoPtr)).FresolverType.FcallProc != 0 {
			XTclNewInstanceMethod(tls, interp, slotObject, resolveName, 0, slotInfoPtr+88, libc.UintptrFromInt32(0))
		}
		goto _4
	_4:
		;
		slotInfoPtr += 128
	}
	v5 = getName
	if v5 != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(v5)).FrefCount == libc.Int64FromInt32(0) {
			_objPtr = v5
			v7 = _objPtr
			v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
			*(*TTcl_Size)(unsafe.Pointer(v7))--
			if v6 <= libc.Int64FromInt32(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
	}
	v8 = setName
	if v8 != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(v8)).FrefCount == libc.Int64FromInt32(0) {
			_objPtr = v8
			v10 = _objPtr
			v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
			*(*TTcl_Size)(unsafe.Pointer(v10))--
			if v9 <= libc.Int64FromInt32(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
	}
	v11 = resolveName
	if v11 != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(v11)).FrefCount == libc.Int64FromInt32(0) {
			_objPtr = v11
			v13 = _objPtr
			v12 = *(*TTcl_Size)(unsafe.Pointer(v13))
			*(*TTcl_Size)(unsafe.Pointer(v13))--
			if v12 <= libc.Int64FromInt32(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
	}
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * ClassFilter_Get, ClassFilter_Set --
 *
 *	Implementation of the "filter" slot accessors of the "oo::define"
 *	command.
 *
 * ----------------------------------------------------------------------
 */

func _ClassFilter_Get(tls *libc.TLS, dummy2405 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	var cachePtr, clsPtr, filterObj, resultObj uintptr
	var i TTcl_Size
	var v1 bool
	_, _, _, _, _, _ = cachePtr, clsPtr, filterObj, i, resultObj, v1
	clsPtr = XTclOOGetClassDefineCmdContext(tls, interp)
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	} else {
		if XTcl_ObjectContextSkippedArgs(tls, context) != int64(objc) {
			XTcl_WrongNumArgs(tls, interp, XTcl_ObjectContextSkippedArgs(tls, context), objv, libc.UintptrFromInt32(0))
			return int32(TCL_ERROR)
		}
	}
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	i = 0
	for {
		if !(i < (*TClass)(unsafe.Pointer(clsPtr)).Ffilters.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Ffilters.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _2
		} else {
			filterObj = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Ffilters.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, filterObj)
			}
		}
		goto _2
	_2:
		;
		i++
	}
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
}

func _ClassFilter_Set(tls *libc.TLS, dummy2433 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var clsPtr uintptr
	var v1 int32
	var v2, v3 int64
	var _ /* filterc at bp+0 */ TTcl_Size
	var _ /* filterv at bp+8 */ uintptr
	_, _, _, _ = clsPtr, v1, v2, v3
	clsPtr = XTclOOGetClassDefineCmdContext(tls, interp)
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	} else {
		if XTcl_ObjectContextSkippedArgs(tls, context)+int64(1) != int64(objc) {
			XTcl_WrongNumArgs(tls, interp, XTcl_ObjectContextSkippedArgs(tls, context), objv, __ccgo_ts+91386)
			return int32(TCL_ERROR)
		}
	}
	objv += uintptr(XTcl_ObjectContextSkippedArgs(tls, context)) * 8
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2)).FspanStart
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1 + 40 + uintptr(v2)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2)).FspanLength
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v3
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(objv)), bp, bp+8)
	}
	if v1 != TCL_OK {
		return int32(TCL_ERROR)
	}
	XTclOOClassSetFilters(tls, interp, clsPtr, *(*TTcl_Size)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 8)))
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * ClassMixin_Get, ClassMixin_Set --
 *
 *	Implementation of the "mixin" slot accessors of the "oo::define"
 *	command.
 *
 * ----------------------------------------------------------------------
 */

func _ClassMixin_Get(tls *libc.TLS, dummy2474 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	var cachePtr, clsPtr, mixinPtr, resultObj uintptr
	var i TTcl_Size
	var v1 bool
	_, _, _, _, _, _ = cachePtr, clsPtr, i, mixinPtr, resultObj, v1
	clsPtr = XTclOOGetClassDefineCmdContext(tls, interp)
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	} else {
		if XTcl_ObjectContextSkippedArgs(tls, context) != int64(objc) {
			XTcl_WrongNumArgs(tls, interp, XTcl_ObjectContextSkippedArgs(tls, context), objv, libc.UintptrFromInt32(0))
			return int32(TCL_ERROR)
		}
	}
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	i = 0
	for {
		if !(i < (*TClass)(unsafe.Pointer(clsPtr)).Fmixins.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _2
		} else {
			mixinPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fmixins.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, XTclOOObjectName(tls, interp, (*TClass)(unsafe.Pointer(mixinPtr)).FthisPtr))
			}
		}
		goto _2
	_2:
		;
		i++
	}
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
}

func _ClassMixin_Set(tls *libc.TLS, dummy2505 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(176)
	defer tls.Free(176)
	var clsPtr, mixins uintptr
	var i TTcl_Size
	var v1 int32
	var v2, v3 int64
	var _ /* isNew at bp+120 */ int32
	var _ /* mixinc at bp+0 */ TTcl_Size
	var _ /* mixinv at bp+8 */ uintptr
	var _ /* uniqueCheck at bp+16 */ TTcl_HashTable
	_, _, _, _, _, _ = clsPtr, i, mixins, v1, v2, v3
	clsPtr = XTclOOGetClassDefineCmdContext(tls, interp)
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	} else {
		if XTcl_ObjectContextSkippedArgs(tls, context)+int64(1) != int64(objc) {
			XTcl_WrongNumArgs(tls, interp, XTcl_ObjectContextSkippedArgs(tls, context), objv, __ccgo_ts+91397)
			return int32(TCL_ERROR)
		}
	}
	objv += uintptr(XTcl_ObjectContextSkippedArgs(tls, context)) * 8
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2)).FspanStart
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1 + 40 + uintptr(v2)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2)).FspanLength
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v3
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(objv)), bp, bp+8)
	}
	if v1 != TCL_OK {
		return int32(TCL_ERROR)
	}
	mixins = XTclStackAlloc(tls, interp, uint64(8)*libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))))
	XTcl_InitHashTable(tls, bp+16, int32(TCL_ONE_WORD_KEYS))
	i = 0
	for {
		if !(i < *(*TTcl_Size)(unsafe.Pointer(bp))) {
			break
		}
		*(*uintptr)(unsafe.Pointer(mixins + uintptr(i)*8)) = _GetClassInOuterContext(tls, interp, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)), __ccgo_ts+91407)
		if *(*uintptr)(unsafe.Pointer(mixins + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			i--
			goto freeAndError
		}
		(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(bp + 16)).FcreateProc})))(tls, bp+16, *(*uintptr)(unsafe.Pointer(mixins + uintptr(i)*8)), bp+120)
		if !(*(*int32)(unsafe.Pointer(bp + 120)) != 0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+91431, int64(-libc.Int32FromInt32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+136, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+91472, libc.UintptrFromInt32(0)))
			goto freeAndError
		}
		if XTclOOIsReachable(tls, clsPtr, *(*uintptr)(unsafe.Pointer(mixins + uintptr(i)*8))) != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+91484, int64(-libc.Int32FromInt32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+136, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+91516, libc.UintptrFromInt32(0)))
			goto freeAndError
		}
		goto _4
	_4:
		;
		i++
	}
	XTclOOClassSetMixins(tls, interp, clsPtr, *(*TTcl_Size)(unsafe.Pointer(bp)), mixins)
	XTcl_DeleteHashTable(tls, bp+16)
	XTclStackFree(tls, interp, mixins)
	return TCL_OK
	goto freeAndError
freeAndError:
	;
	XTcl_DeleteHashTable(tls, bp+16)
	XTclStackFree(tls, interp, mixins)
	return int32(TCL_ERROR)
}

/*
 * ----------------------------------------------------------------------
 *
 * ClassSuper_Get, ClassSuper_Set --
 *
 *	Implementation of the "superclass" slot accessors of the "oo::define"
 *	command.
 *
 * ----------------------------------------------------------------------
 */

func _ClassSuper_Get(tls *libc.TLS, dummy2584 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	var cachePtr, clsPtr, resultObj, superPtr uintptr
	var i TTcl_Size
	var v1 bool
	_, _, _, _, _, _ = cachePtr, clsPtr, i, resultObj, superPtr, v1
	clsPtr = XTclOOGetClassDefineCmdContext(tls, interp)
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	} else {
		if XTcl_ObjectContextSkippedArgs(tls, context) != int64(objc) {
			XTcl_WrongNumArgs(tls, interp, XTcl_ObjectContextSkippedArgs(tls, context), objv, libc.UintptrFromInt32(0))
			return int32(TCL_ERROR)
		}
	}
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	i = 0
	for {
		if !(i < (*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _2
		} else {
			superPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, XTclOOObjectName(tls, interp, (*TClass)(unsafe.Pointer(superPtr)).FthisPtr))
			}
		}
		goto _2
	_2:
		;
		i++
	}
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
}

func _ClassSuper_Set(tls *libc.TLS, dummy2614 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var clsPtr, fPtr, superPtr, superclasses uintptr
	var i, j, v10 TTcl_Size
	var v1 int32
	var v2, v3 int64
	var _ /* superc at bp+0 */ TTcl_Size
	var _ /* superv at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _ = clsPtr, fPtr, i, j, superPtr, superclasses, v1, v10, v2, v3
	clsPtr = XTclOOGetClassDefineCmdContext(tls, interp)
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	} else {
		if XTcl_ObjectContextSkippedArgs(tls, context)+int64(1) != int64(objc) {
			XTcl_WrongNumArgs(tls, interp, XTcl_ObjectContextSkippedArgs(tls, context), objv, __ccgo_ts+91527)
			return int32(TCL_ERROR)
		}
	}
	objv += uintptr(XTcl_ObjectContextSkippedArgs(tls, context)) * 8
	fPtr = (*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).FthisPtr)).FfPtr
	if clsPtr == (*TFoundation)(unsafe.Pointer(fPtr)).FobjectCls {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+91542, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+90568, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2 != 0 {
				v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2)).FspanStart
			} else {
				v2 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1 + 40 + uintptr(v2)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2 != 0 {
				v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2)).FspanLength
			} else {
				v3 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp)) = v3
			v1 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(objv)), bp, bp+8)
		}
		if v1 != TCL_OK {
			return int32(TCL_ERROR)
		}
	}
	/*
	 * Allocate some working space.
	 */
	superclasses = XTcl_Alloc(tls, uint64(8)*libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))))
	/*
	 * Parse the arguments to get the class to use as superclasses.
	 *
	 * Note that zero classes is special, as it is equivalent to just the
	 * class of objects. [Bug 9d61624b3d]
	 */
	if *(*TTcl_Size)(unsafe.Pointer(bp)) == 0 {
		superclasses = XTcl_Realloc(tls, superclasses, uint64(8))
		if XTclOOIsReachable(tls, (*TFoundation)(unsafe.Pointer(fPtr)).FclassCls, clsPtr) != 0 {
			*(*uintptr)(unsafe.Pointer(superclasses)) = (*TFoundation)(unsafe.Pointer(fPtr)).FclassCls
		} else {
			*(*uintptr)(unsafe.Pointer(superclasses)) = (*TFoundation)(unsafe.Pointer(fPtr)).FobjectCls
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = int64(1)
		(*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(superclasses)))).FthisPtr)).FrefCount++
	} else {
		i = 0
	_6:
		;
		if !(i < *(*TTcl_Size)(unsafe.Pointer(bp))) {
			goto _4
		}
		*(*uintptr)(unsafe.Pointer(superclasses + uintptr(i)*8)) = _GetClassInOuterContext(tls, interp, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)), __ccgo_ts+91591)
		if *(*uintptr)(unsafe.Pointer(superclasses + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto failedAfterAlloc
		}
		j = 0
		for {
			if !(j < i) {
				break
			}
			if *(*uintptr)(unsafe.Pointer(superclasses + uintptr(j)*8)) == *(*uintptr)(unsafe.Pointer(superclasses + uintptr(i)*8)) {
				XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+91624, int64(-libc.Int32FromInt32(1))))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+91472, libc.UintptrFromInt32(0)))
				goto failedAfterAlloc
			}
			goto _7
		_7:
			;
			j++
		}
		if !(XTclOOIsReachable(tls, clsPtr, *(*uintptr)(unsafe.Pointer(superclasses + uintptr(i)*8))) != 0) {
			goto _8
		}
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+91670, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+57558, libc.UintptrFromInt32(0)))
		goto failedAfterAlloc
	failedAfterAlloc:
		;
		for {
			v10 = i
			i--
			if !(v10 > 0) {
				break
			}
			XTclOODecrRefCount(tls, (*TClass)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(superclasses + uintptr(i)*8)))).FthisPtr)
			goto _9
		_9:
		}
		XTclpFree(tls, superclasses)
		return int32(TCL_ERROR)
	_8:
		;
		/*
		 * Corresponding TclOODecrRefCount() is near the end of this
		 * function.
		 */
		(*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(superclasses + uintptr(i)*8)))).FthisPtr)).FrefCount++
		goto _5
	_5:
		;
		i++
		goto _6
		goto _4
	_4:
	}
	/*
	 * Install the list of superclasses into the class. Note that this also
	 * involves splicing the class out of the superclasses' subclass list that
	 * it used to be a member of and splicing it into the new superclasses'
	 * subclass list.
	 */
	if (*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Fnum != 0 {
		i = 0
		for {
			if !(i < (*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _11
			} else {
				superPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					XTclOORemoveFromSubclasses(tls, clsPtr, superPtr)
					XTclOODecrRefCount(tls, (*TClass)(unsafe.Pointer(superPtr)).FthisPtr)
				}
			}
			goto _11
		_11:
			;
			i++
		}
		XTclpFree(tls, (*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Flist)
	}
	(*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Flist = superclasses
	(*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Fnum = *(*TTcl_Size)(unsafe.Pointer(bp))
	i = 0
	for {
		if !(i < (*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _12
		} else {
			superPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				XTclOOAddToSubclasses(tls, clsPtr, superPtr)
			}
		}
		goto _12
	_12:
		;
		i++
	}
	_BumpGlobalEpoch(tls, interp, clsPtr)
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * ClassVars_Get, ClassVars_Set --
 *
 *	Implementation of the "variable" slot accessors of the "oo::define"
 *	command.
 *
 * ----------------------------------------------------------------------
 */

func _ClassVars_Get(tls *libc.TLS, dummy2744 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	var cachePtr, clsPtr, privatePtr, resultObj, variableObj uintptr
	var i TTcl_Size
	var v1 bool
	_, _, _, _, _, _, _ = cachePtr, clsPtr, i, privatePtr, resultObj, variableObj, v1
	clsPtr = XTclOOGetClassDefineCmdContext(tls, interp)
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	} else {
		if XTcl_ObjectContextSkippedArgs(tls, context) != int64(objc) {
			XTcl_WrongNumArgs(tls, interp, XTcl_ObjectContextSkippedArgs(tls, context), objv, libc.UintptrFromInt32(0))
			return int32(TCL_ERROR)
		}
	}
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	if _IsPrivateDefine(tls, interp) != 0 {
		i = 0
		if (*TClass)(unsafe.Pointer(clsPtr)).FprivateVariables.Fnum > libc.Int64FromInt32(0) {
			for {
				privatePtr = (*TClass)(unsafe.Pointer(clsPtr)).FprivateVariables.Flist + uintptr(i)*16
				if !(i < (*TClass)(unsafe.Pointer(clsPtr)).FprivateVariables.Fnum) {
					break
				}
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, (*TPrivateVariableMapping)(unsafe.Pointer(privatePtr)).FvariableObj)
				goto _2
			_2:
				;
				i++
			}
		}
	} else {
		i = 0
		for {
			if !(i < (*TClass)(unsafe.Pointer(clsPtr)).Fvariables.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fvariables.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _3
			} else {
				variableObj = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fvariables.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, variableObj)
				}
			}
			goto _3
		_3:
			;
			i++
		}
	}
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
}

func _ClassVars_Set(tls *libc.TLS, dummy2782 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var clsPtr, varName, v5 uintptr
	var i TTcl_Size
	var v1 int32
	var v2, v3 int64
	var _ /* varc at bp+0 */ TTcl_Size
	var _ /* varv at bp+8 */ uintptr
	_, _, _, _, _, _, _ = clsPtr, i, varName, v1, v2, v3, v5
	clsPtr = XTclOOGetClassDefineCmdContext(tls, interp)
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	} else {
		if XTcl_ObjectContextSkippedArgs(tls, context)+int64(1) != int64(objc) {
			XTcl_WrongNumArgs(tls, interp, XTcl_ObjectContextSkippedArgs(tls, context), objv, __ccgo_ts+91386)
			return int32(TCL_ERROR)
		}
	}
	objv += uintptr(XTcl_ObjectContextSkippedArgs(tls, context)) * 8
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2)).FspanStart
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1 + 40 + uintptr(v2)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2)).FspanLength
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v3
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(objv)), bp, bp+8)
	}
	if v1 != TCL_OK {
		return int32(TCL_ERROR)
	}
	i = 0
	for {
		if !(i < *(*TTcl_Size)(unsafe.Pointer(bp))) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)))).Fbytes != 0 {
			v5 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)))).Fbytes
		} else {
			v5 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		varName = v5
		if libc.Xstrstr(tls, varName, __ccgo_ts+7650) != libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+91712, libc.VaList(bp+24, varName, __ccgo_ts+91761)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+91790, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		if XTcl_StringCaseMatch(tls, varName, __ccgo_ts+91802, 0) != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+91712, libc.VaList(bp+24, varName, __ccgo_ts+91807)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+91790, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		goto _4
	_4:
		;
		i++
	}
	if _IsPrivateDefine(tls, interp) != 0 {
		_InstallPrivateVariableMapping(tls, clsPtr+304, *(*TTcl_Size)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 8)), int32((*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).FthisPtr)).FcreationEpoch))
	} else {
		_InstallStandardVariableMapping(tls, clsPtr+288, *(*TTcl_Size)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 8)))
	}
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * ObjFilter_Get, ObjFilter_Set --
 *
 *	Implementation of the "filter" slot accessors of the "oo::objdefine"
 *	command.
 *
 * ----------------------------------------------------------------------
 */

func _ObjFilter_Get(tls *libc.TLS, dummy2847 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	var cachePtr, filterObj, oPtr, resultObj uintptr
	var i TTcl_Size
	var v1 bool
	_, _, _, _, _, _ = cachePtr, filterObj, i, oPtr, resultObj, v1
	oPtr = XTclOOGetDefineCmdContext(tls, interp)
	if XTcl_ObjectContextSkippedArgs(tls, context) != int64(objc) {
		XTcl_WrongNumArgs(tls, interp, XTcl_ObjectContextSkippedArgs(tls, context), objv, libc.UintptrFromInt32(0))
		return int32(TCL_ERROR)
	} else {
		if oPtr == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
	}
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	i = 0
	for {
		if !(i < (*TObject)(unsafe.Pointer(oPtr)).Ffilters.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Ffilters.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _2
		} else {
			filterObj = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Ffilters.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, filterObj)
			}
		}
		goto _2
	_2:
		;
		i++
	}
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
}

func _ObjFilter_Set(tls *libc.TLS, dummy2875 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var oPtr uintptr
	var v1 int32
	var v2, v3 int64
	var _ /* filterc at bp+0 */ TTcl_Size
	var _ /* filterv at bp+8 */ uintptr
	_, _, _, _ = oPtr, v1, v2, v3
	oPtr = XTclOOGetDefineCmdContext(tls, interp)
	if XTcl_ObjectContextSkippedArgs(tls, context)+int64(1) != int64(objc) {
		XTcl_WrongNumArgs(tls, interp, XTcl_ObjectContextSkippedArgs(tls, context), objv, __ccgo_ts+91386)
		return int32(TCL_ERROR)
	} else {
		if oPtr == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
	}
	objv += uintptr(XTcl_ObjectContextSkippedArgs(tls, context)) * 8
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2)).FspanStart
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1 + 40 + uintptr(v2)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2)).FspanLength
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v3
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(objv)), bp, bp+8)
	}
	if v1 != TCL_OK {
		return int32(TCL_ERROR)
	}
	XTclOOObjectSetFilters(tls, oPtr, *(*TTcl_Size)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 8)))
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * ObjMixin_Get, ObjMixin_Set --
 *
 *	Implementation of the "mixin" slot accessors of the "oo::objdefine"
 *	command.
 *
 * ----------------------------------------------------------------------
 */

func _ObjMixin_Get(tls *libc.TLS, dummy2914 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	var cachePtr, mixinPtr, oPtr, resultObj uintptr
	var i TTcl_Size
	var v1 bool
	_, _, _, _, _, _ = cachePtr, i, mixinPtr, oPtr, resultObj, v1
	oPtr = XTclOOGetDefineCmdContext(tls, interp)
	if XTcl_ObjectContextSkippedArgs(tls, context) != int64(objc) {
		XTcl_WrongNumArgs(tls, interp, XTcl_ObjectContextSkippedArgs(tls, context), objv, libc.UintptrFromInt32(0))
		return int32(TCL_ERROR)
	} else {
		if oPtr == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
	}
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	i = 0
	for {
		if !(i < (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _2
		} else {
			mixinPtr = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				if mixinPtr != 0 {
					XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, XTclOOObjectName(tls, interp, (*TClass)(unsafe.Pointer(mixinPtr)).FthisPtr))
				}
			}
		}
		goto _2
	_2:
		;
		i++
	}
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
}

func _ObjMixin_Set(tls *libc.TLS, dummy2946 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(176)
	defer tls.Free(176)
	var i TTcl_Size
	var mixins, oPtr uintptr
	var v1 int32
	var v2, v3 int64
	var _ /* isNew at bp+120 */ int32
	var _ /* mixinc at bp+0 */ TTcl_Size
	var _ /* mixinv at bp+8 */ uintptr
	var _ /* uniqueCheck at bp+16 */ TTcl_HashTable
	_, _, _, _, _, _ = i, mixins, oPtr, v1, v2, v3
	oPtr = XTclOOGetDefineCmdContext(tls, interp)
	if XTcl_ObjectContextSkippedArgs(tls, context)+int64(1) != int64(objc) {
		XTcl_WrongNumArgs(tls, interp, XTcl_ObjectContextSkippedArgs(tls, context), objv, __ccgo_ts+91397)
		return int32(TCL_ERROR)
	} else {
		if oPtr == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
	}
	objv += uintptr(XTcl_ObjectContextSkippedArgs(tls, context)) * 8
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2)).FspanStart
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1 + 40 + uintptr(v2)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2)).FspanLength
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v3
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(objv)), bp, bp+8)
	}
	if v1 != TCL_OK {
		return int32(TCL_ERROR)
	}
	mixins = XTclStackAlloc(tls, interp, uint64(8)*libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))))
	XTcl_InitHashTable(tls, bp+16, int32(TCL_ONE_WORD_KEYS))
	i = 0
	for {
		if !(i < *(*TTcl_Size)(unsafe.Pointer(bp))) {
			break
		}
		*(*uintptr)(unsafe.Pointer(mixins + uintptr(i)*8)) = _GetClassInOuterContext(tls, interp, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)), __ccgo_ts+91407)
		if *(*uintptr)(unsafe.Pointer(mixins + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto freeAndError
		}
		(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(bp + 16)).FcreateProc})))(tls, bp+16, *(*uintptr)(unsafe.Pointer(mixins + uintptr(i)*8)), bp+120)
		if !(*(*int32)(unsafe.Pointer(bp + 120)) != 0) {
			XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+91431, int64(-libc.Int32FromInt32(1))))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+136, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+91472, libc.UintptrFromInt32(0)))
			goto freeAndError
		}
		goto _4
	_4:
		;
		i++
	}
	XTclOOObjectSetMixins(tls, oPtr, *(*TTcl_Size)(unsafe.Pointer(bp)), mixins)
	XTclStackFree(tls, interp, mixins)
	XTcl_DeleteHashTable(tls, bp+16)
	return TCL_OK
	goto freeAndError
freeAndError:
	;
	XTclStackFree(tls, interp, mixins)
	XTcl_DeleteHashTable(tls, bp+16)
	return int32(TCL_ERROR)
}

/*
 * ----------------------------------------------------------------------
 *
 * ObjVars_Get, ObjVars_Set --
 *
 *	Implementation of the "variable" slot accessors of the "oo::objdefine"
 *	command.
 *
 * ----------------------------------------------------------------------
 */

func _ObjVars_Get(tls *libc.TLS, dummy3017 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	var cachePtr, oPtr, privatePtr, resultObj, variableObj uintptr
	var i TTcl_Size
	var v1 bool
	_, _, _, _, _, _, _ = cachePtr, i, oPtr, privatePtr, resultObj, variableObj, v1
	oPtr = XTclOOGetDefineCmdContext(tls, interp)
	if XTcl_ObjectContextSkippedArgs(tls, context) != int64(objc) {
		XTcl_WrongNumArgs(tls, interp, XTcl_ObjectContextSkippedArgs(tls, context), objv, libc.UintptrFromInt32(0))
		return int32(TCL_ERROR)
	} else {
		if oPtr == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
	}
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	if _IsPrivateDefine(tls, interp) != 0 {
		i = 0
		if (*TObject)(unsafe.Pointer(oPtr)).FprivateVariables.Fnum > libc.Int64FromInt32(0) {
			for {
				privatePtr = (*TObject)(unsafe.Pointer(oPtr)).FprivateVariables.Flist + uintptr(i)*16
				if !(i < (*TObject)(unsafe.Pointer(oPtr)).FprivateVariables.Fnum) {
					break
				}
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, (*TPrivateVariableMapping)(unsafe.Pointer(privatePtr)).FvariableObj)
				goto _2
			_2:
				;
				i++
			}
		}
	} else {
		i = 0
		for {
			if !(i < (*TObject)(unsafe.Pointer(oPtr)).Fvariables.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fvariables.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _3
			} else {
				variableObj = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fvariables.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, variableObj)
				}
			}
			goto _3
		_3:
			;
			i++
		}
	}
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
}

func _ObjVars_Set(tls *libc.TLS, dummy3055 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var i TTcl_Size
	var oPtr, varName, v5 uintptr
	var v1 int32
	var v2, v3 int64
	var _ /* varc at bp+0 */ TTcl_Size
	var _ /* varv at bp+8 */ uintptr
	_, _, _, _, _, _, _ = i, oPtr, varName, v1, v2, v3, v5
	oPtr = XTclOOGetDefineCmdContext(tls, interp)
	if XTcl_ObjectContextSkippedArgs(tls, context)+int64(1) != int64(objc) {
		XTcl_WrongNumArgs(tls, interp, XTcl_ObjectContextSkippedArgs(tls, context), objv, __ccgo_ts+91833)
		return int32(TCL_ERROR)
	} else {
		if oPtr == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
	}
	objv += uintptr(XTcl_ObjectContextSkippedArgs(tls, context)) * 8
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2)).FspanStart
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1 + 40 + uintptr(v2)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2)).FspanLength
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v3
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(objv)), bp, bp+8)
	}
	if v1 != TCL_OK {
		return int32(TCL_ERROR)
	}
	i = 0
	for {
		if !(i < *(*TTcl_Size)(unsafe.Pointer(bp))) {
			break
		}
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)))).Fbytes != 0 {
			v5 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)))).Fbytes
		} else {
			v5 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(i)*8)), libc.UintptrFromInt32(0))
		}
		varName = v5
		if libc.Xstrstr(tls, varName, __ccgo_ts+7650) != libc.UintptrFromInt32(0) {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+91712, libc.VaList(bp+24, varName, __ccgo_ts+91761)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+91790, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		if XTcl_StringCaseMatch(tls, varName, __ccgo_ts+91802, 0) != 0 {
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+91712, libc.VaList(bp+24, varName, __ccgo_ts+91807)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+91790, libc.UintptrFromInt32(0)))
			return int32(TCL_ERROR)
		}
		goto _4
	_4:
		;
		i++
	}
	if _IsPrivateDefine(tls, interp) != 0 {
		_InstallPrivateVariableMapping(tls, oPtr+168, *(*TTcl_Size)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 8)), int32((*TObject)(unsafe.Pointer(oPtr)).FcreationEpoch))
	} else {
		_InstallStandardVariableMapping(tls, oPtr+152, *(*TTcl_Size)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 8)))
	}
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * ResolveClass --
 *
 *	Implementation of the "Resolve" support method for some slots (those
 *	that are slots around a list of classes). This resolves possible class
 *	names to their fully-qualified names if possible.
 *
 * ----------------------------------------------------------------------
 */

func _ResolveClass(tls *libc.TLS, dummy3119 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	var clsPtr, oPtr uintptr
	var idx int32
	_, _, _ = clsPtr, idx, oPtr
	idx = int32(XTcl_ObjectContextSkippedArgs(tls, context))
	oPtr = XTclOOGetDefineCmdContext(tls, interp)
	/*
	 * Check if were called wrongly. The definition context isn't used...
	 * except that GetClassInOuterContext() assumes that it is there.
	 */
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	} else {
		if objc != idx+int32(1) {
			XTcl_WrongNumArgs(tls, interp, int64(idx), objv, __ccgo_ts+91846)
			return int32(TCL_ERROR)
		}
	}
	/*
	 * Resolve the class if possible. If not, remove any resolution error and
	 * return what we've got anyway as the failure might not be fatal overall.
	 */
	clsPtr = _GetClassInOuterContext(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(idx)*8)), __ccgo_ts+91858)
	if clsPtr == libc.UintptrFromInt32(0) {
		XTcl_ResetResult(tls, interp)
		XTcl_SetObjResult(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(idx)*8)))
	} else {
		XTcl_SetObjResult(tls, interp, XTclOOObjectName(tls, interp, (*TClass)(unsafe.Pointer(clsPtr)).FthisPtr))
	}
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * Configurable_ClassReadableProps_Get, Configurable_ClassReadableProps_Set,
 * Configurable_ObjectReadableProps_Get, Configurable_ObjectReadableProps_Set --
 *
 *	Implementations of the "readableproperties" slot accessors for classes
 *	and instances.
 *
 * ----------------------------------------------------------------------
 */

func _Configurable_ClassReadableProps_Get(tls *libc.TLS, dummy3172 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	var clsPtr uintptr
	_ = clsPtr
	clsPtr = XTclOOGetClassDefineCmdContext(tls, interp)
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	} else {
		if XTcl_ObjectContextSkippedArgs(tls, context) != int64(objc) {
			XTcl_WrongNumArgs(tls, interp, XTcl_ObjectContextSkippedArgs(tls, context), objv, libc.UintptrFromInt32(0))
			return int32(TCL_ERROR)
		}
	}
	XTcl_SetObjResult(tls, interp, XTclOOGetPropertyList(tls, clsPtr+336))
	return TCL_OK
}

func _Configurable_ClassReadableProps_Set(tls *libc.TLS, dummy3194 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var clsPtr uintptr
	var v1 int32
	var v2, v3 int64
	var _ /* varc at bp+0 */ TTcl_Size
	var _ /* varv at bp+8 */ uintptr
	_, _, _, _ = clsPtr, v1, v2, v3
	clsPtr = XTclOOGetClassDefineCmdContext(tls, interp)
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	} else {
		if XTcl_ObjectContextSkippedArgs(tls, context)+int64(1) != int64(objc) {
			XTcl_WrongNumArgs(tls, interp, XTcl_ObjectContextSkippedArgs(tls, context), objv, __ccgo_ts+91386)
			return int32(TCL_ERROR)
		}
	}
	objv += uintptr(XTcl_ObjectContextSkippedArgs(tls, context)) * 8
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2)).FspanStart
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1 + 40 + uintptr(v2)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2)).FspanLength
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v3
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(objv)), bp, bp+8)
	}
	if v1 != TCL_OK {
		return int32(TCL_ERROR)
	}
	XTclOOInstallReadableProperties(tls, clsPtr+336, *(*TTcl_Size)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 8)))
	_BumpGlobalEpoch(tls, interp, clsPtr)
	return TCL_OK
}

func _Configurable_ObjectReadableProps_Get(tls *libc.TLS, dummy3224 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	var oPtr uintptr
	_ = oPtr
	oPtr = XTclOOGetDefineCmdContext(tls, interp)
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	} else {
		if XTcl_ObjectContextSkippedArgs(tls, context) != int64(objc) {
			XTcl_WrongNumArgs(tls, interp, XTcl_ObjectContextSkippedArgs(tls, context), objv, libc.UintptrFromInt32(0))
			return int32(TCL_ERROR)
		}
	}
	XTcl_SetObjResult(tls, interp, XTclOOGetPropertyList(tls, oPtr+192))
	return TCL_OK
}

func _Configurable_ObjectReadableProps_Set(tls *libc.TLS, dummy3246 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var oPtr uintptr
	var v1 int32
	var v2, v3 int64
	var _ /* varc at bp+0 */ TTcl_Size
	var _ /* varv at bp+8 */ uintptr
	_, _, _, _ = oPtr, v1, v2, v3
	oPtr = XTclOOGetDefineCmdContext(tls, interp)
	if XTcl_ObjectContextSkippedArgs(tls, context)+int64(1) != int64(objc) {
		XTcl_WrongNumArgs(tls, interp, XTcl_ObjectContextSkippedArgs(tls, context), objv, __ccgo_ts+91386)
		return int32(TCL_ERROR)
	}
	objv += uintptr(XTcl_ObjectContextSkippedArgs(tls, context)) * 8
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2 != 0 {
				v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2)).FspanStart
			} else {
				v2 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1 + 40 + uintptr(v2)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2 != 0 {
				v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2)).FspanLength
			} else {
				v3 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp)) = v3
			v1 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(objv)), bp, bp+8)
		}
		if v1 != TCL_OK {
			return int32(TCL_ERROR)
		}
	}
	XTclOOInstallReadableProperties(tls, oPtr+192, *(*TTcl_Size)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 8)))
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * Configurable_ClassWritableProps_Get, Configurable_ClassWritableProps_Set,
 * Configurable_ObjectWritableProps_Get, Configurable_ObjectWritableProps_Set --
 *
 *	Implementations of the "writableproperties" slot accessors for classes
 *	and instances.
 *
 * ----------------------------------------------------------------------
 */

func _Configurable_ClassWritableProps_Get(tls *libc.TLS, dummy3288 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	var clsPtr uintptr
	_ = clsPtr
	clsPtr = XTclOOGetClassDefineCmdContext(tls, interp)
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	} else {
		if XTcl_ObjectContextSkippedArgs(tls, context) != int64(objc) {
			XTcl_WrongNumArgs(tls, interp, XTcl_ObjectContextSkippedArgs(tls, context), objv, libc.UintptrFromInt32(0))
			return int32(TCL_ERROR)
		}
	}
	XTcl_SetObjResult(tls, interp, XTclOOGetPropertyList(tls, clsPtr+336+16))
	return TCL_OK
}

func _Configurable_ClassWritableProps_Set(tls *libc.TLS, dummy3310 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var clsPtr uintptr
	var v1 int32
	var v2, v3 int64
	var _ /* varc at bp+0 */ TTcl_Size
	var _ /* varv at bp+8 */ uintptr
	_, _, _, _ = clsPtr, v1, v2, v3
	clsPtr = XTclOOGetClassDefineCmdContext(tls, interp)
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	} else {
		if XTcl_ObjectContextSkippedArgs(tls, context)+int64(1) != int64(objc) {
			XTcl_WrongNumArgs(tls, interp, XTcl_ObjectContextSkippedArgs(tls, context), objv, __ccgo_ts+91891)
			return int32(TCL_ERROR)
		}
	}
	objv += uintptr(XTcl_ObjectContextSkippedArgs(tls, context)) * 8
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2)).FspanStart
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1 + 40 + uintptr(v2)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2)).FspanLength
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v3
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(objv)), bp, bp+8)
	}
	if v1 != TCL_OK {
		return int32(TCL_ERROR)
	}
	XTclOOInstallWritableProperties(tls, clsPtr+336, *(*TTcl_Size)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 8)))
	_BumpGlobalEpoch(tls, interp, clsPtr)
	return TCL_OK
}

func _Configurable_ObjectWritableProps_Get(tls *libc.TLS, dummy3340 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	var oPtr uintptr
	_ = oPtr
	oPtr = XTclOOGetDefineCmdContext(tls, interp)
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	} else {
		if XTcl_ObjectContextSkippedArgs(tls, context) != int64(objc) {
			XTcl_WrongNumArgs(tls, interp, XTcl_ObjectContextSkippedArgs(tls, context), objv, libc.UintptrFromInt32(0))
			return int32(TCL_ERROR)
		}
	}
	XTcl_SetObjResult(tls, interp, XTclOOGetPropertyList(tls, oPtr+192+16))
	return TCL_OK
}

func _Configurable_ObjectWritableProps_Set(tls *libc.TLS, dummy3362 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var oPtr uintptr
	var v1 int32
	var v2, v3 int64
	var _ /* varc at bp+0 */ TTcl_Size
	var _ /* varv at bp+8 */ uintptr
	_, _, _, _ = oPtr, v1, v2, v3
	oPtr = XTclOOGetDefineCmdContext(tls, interp)
	if XTcl_ObjectContextSkippedArgs(tls, context)+int64(1) != int64(objc) {
		XTcl_WrongNumArgs(tls, interp, XTcl_ObjectContextSkippedArgs(tls, context), objv, __ccgo_ts+91891)
		return int32(TCL_ERROR)
	}
	objv += uintptr(XTcl_ObjectContextSkippedArgs(tls, context)) * 8
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)))).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2 != 0 {
				v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2)).FspanStart
			} else {
				v2 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp + 8)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1 + 40 + uintptr(v2)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2 != 0 {
				v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr2)).FspanLength
			} else {
				v3 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv)) + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp)) = v3
			v1 = libc.Int32FromInt32(TCL_OK)
		} else {
			v1 = XTcl_ListObjGetElements(tls, interp, *(*uintptr)(unsafe.Pointer(objv)), bp, bp+8)
		}
		if v1 != TCL_OK {
			return int32(TCL_ERROR)
		}
	}
	XTclOOInstallWritableProperties(tls, oPtr+192, *(*TTcl_Size)(unsafe.Pointer(bp)), *(*uintptr)(unsafe.Pointer(bp + 8)))
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOORegisterProperty, TclOORegisterInstanceProperty --
 *
 *	Helpers to add or remove a name from the property slots of a class or
 *	instance.
 *
 * BuildPropertyList --
 *
 *	Helper for the helpers. Scans a property list and does the filtering
 *	or adding of the property to add or remove
 *
 * ----------------------------------------------------------------------
 */

func _BuildPropertyList(tls *libc.TLS, propsList uintptr, propName uintptr, addingProp int32, listObj uintptr) (r int32) {
	/* The list of property names we're building */
	var changed, i, present int32
	var other uintptr
	_, _, _, _ = changed, i, other, present
	present = 0
	changed = 0
	XTcl_SetListObj(tls, listObj, 0, libc.UintptrFromInt32(0))
	i = 0
	for {
		if !(int64(i) < (*TPropertyList)(unsafe.Pointer(propsList)).Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TPropertyList)(unsafe.Pointer(propsList)).Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _1
		} else {
			other = *(*uintptr)(unsafe.Pointer((*TPropertyList)(unsafe.Pointer(propsList)).Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				if !(XTclStringCmp(tls, propName, other, int32(1), 0, int64(-libc.Int32FromInt32(1))) != 0) {
					present = int32(1)
					if !(addingProp != 0) {
						changed = int32(1)
						goto _1
					}
				}
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listObj, other)
			}
		}
		goto _1
	_1:
		;
		i++
	}
	if !(present != 0) && addingProp != 0 {
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), listObj, propName)
		changed = int32(1)
	}
	return changed
}

func XTclOORegisterInstanceProperty(tls *libc.TLS, oPtr uintptr, propName uintptr, registerReader int32, registerWriter int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* True if we're adding the property name to
	 * the writable property slot. False if we're
	 * removing the property name from the slot. */
	var _objPtr, listObj, v7, v9 uintptr
	var v2, v3, v5, v6 int64
	var v8 TTcl_Size
	var _ /* count at bp+8 */ TTcl_Size
	var _ /* objv at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _ = _objPtr, listObj, v2, v3, v5, v6, v7, v8, v9
	listObj = XTcl_NewObj(tls)
	if _BuildPropertyList(tls, oPtr+192, propName, registerReader, listObj) != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr2 != 0 {
				v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr2)).FspanStart
			} else {
				v2 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr1 + 40 + uintptr(v2)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr2 != 0 {
				v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr2)).FspanLength
			} else {
				v3 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v3
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), listObj, bp+8, bp)
		}
		XTclOOInstallReadableProperties(tls, oPtr+192, *(*TTcl_Size)(unsafe.Pointer(bp + 8)), *(*uintptr)(unsafe.Pointer(bp)))
	}
	if _BuildPropertyList(tls, oPtr+192+16, propName, registerWriter, listObj) != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr2 != 0 {
				v5 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr2)).FspanStart
			} else {
				v5 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr1 + 40 + uintptr(v5)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr2 != 0 {
				v6 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr2)).FspanLength
			} else {
				v6 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v6
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), listObj, bp+8, bp)
		}
		XTclOOInstallWritableProperties(tls, oPtr+192, *(*TTcl_Size)(unsafe.Pointer(bp + 8)), *(*uintptr)(unsafe.Pointer(bp)))
	}
	v7 = listObj
	if v7 != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(v7)).FrefCount == libc.Int64FromInt32(0) {
			_objPtr = v7
			v9 = _objPtr
			v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
			*(*TTcl_Size)(unsafe.Pointer(v9))--
			if v8 <= libc.Int64FromInt32(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
	}
}

func XTclOORegisterProperty(tls *libc.TLS, clsPtr uintptr, propName uintptr, registerReader int32, registerWriter int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* True if we're adding the property name to
	 * the writable property slot. False if we're
	 * removing the property name from the slot. */
	var _objPtr, listObj, v7, v9 uintptr
	var changed int32
	var v2, v3, v5, v6 int64
	var v8 TTcl_Size
	var _ /* count at bp+8 */ TTcl_Size
	var _ /* objv at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _ = _objPtr, changed, listObj, v2, v3, v5, v6, v7, v8, v9
	listObj = XTcl_NewObj(tls)
	changed = 0
	if _BuildPropertyList(tls, clsPtr+336, propName, registerReader, listObj) != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr2 != 0 {
				v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr2)).FspanStart
			} else {
				v2 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr1 + 40 + uintptr(v2)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr2 != 0 {
				v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr2)).FspanLength
			} else {
				v3 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v3
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), listObj, bp+8, bp)
		}
		XTclOOInstallReadableProperties(tls, clsPtr+336, *(*TTcl_Size)(unsafe.Pointer(bp + 8)), *(*uintptr)(unsafe.Pointer(bp)))
		changed = int32(1)
	}
	if _BuildPropertyList(tls, clsPtr+336+16, propName, registerWriter, listObj) != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(listObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr2 != 0 {
				v5 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr2)).FspanStart
			} else {
				v5 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr1)).FfirstUsed
			}
			*(*uintptr)(unsafe.Pointer(bp)) = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr1 + 40 + uintptr(v5)*8
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listObj + 32))).Fptr2 != 0 {
				v6 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr2)).FspanLength
			} else {
				v6 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(listObj + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v6
			_ = libc.Int32FromInt32(TCL_OK)
		} else {
			XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), listObj, bp+8, bp)
		}
		XTclOOInstallWritableProperties(tls, clsPtr+336, *(*TTcl_Size)(unsafe.Pointer(bp + 8)), *(*uintptr)(unsafe.Pointer(bp)))
		changed = int32(1)
	}
	v7 = listObj
	if v7 != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(v7)).FrefCount == libc.Int64FromInt32(0) {
			_objPtr = v7
			v9 = _objPtr
			v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
			*(*TTcl_Size)(unsafe.Pointer(v9))--
			if v8 <= libc.Int64FromInt32(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
	}
	if changed != 0 {
		_BumpGlobalEpoch(tls, (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).FthisPtr)).FfPtr)).Finterp, clsPtr)
	}
}

const TCL_OO_METHOD_VERSION_CURRENT4 = 0

/*
 * List of commands that are used to implement the [info object] subcommands.
 */

var _infoObjectCmds = [15]TEnsembleImplMap{
	0: {
		Fname: __ccgo_ts + 88243,
	},
	1: {
		Fname: __ccgo_ts + 19296,
	},
	2: {
		Fname: __ccgo_ts + 91904,
	},
	3: {
		Fname: __ccgo_ts + 91915,
	},
	4: {
		Fname: __ccgo_ts + 91926,
	},
	5: {
		Fname: __ccgo_ts + 78756,
	},
	6: {
		Fname: __ccgo_ts + 91934,
	},
	7: {
		Fname: __ccgo_ts + 88025,
	},
	8: {
		Fname: __ccgo_ts + 91938,
	},
	9: {
		Fname: __ccgo_ts + 91949,
	},
	10: {
		Fname: __ccgo_ts + 21846,
	},
	11: {
		Fname: __ccgo_ts + 91956,
	},
	12: {
		Fname: __ccgo_ts + 21627,
	},
	13: {
		Fname: __ccgo_ts + 16159,
	},
	14: {},
}

func init() {
	p := unsafe.Pointer(&_infoObjectCmds)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_InfoObjectCallCmd)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(XTclCompileBasic2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(_InfoObjectClassCmd)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(XTclCompileInfoObjectClassCmd)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(_InfoObjectIdCmd)
	*(*uintptr)(unsafe.Add(p, 112)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 152)) = __ccgo_fp(_InfoObjectDefnCmd)
	*(*uintptr)(unsafe.Add(p, 160)) = __ccgo_fp(XTclCompileBasic2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 200)) = __ccgo_fp(_InfoObjectFiltersCmd)
	*(*uintptr)(unsafe.Add(p, 208)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 248)) = __ccgo_fp(_InfoObjectForwardCmd)
	*(*uintptr)(unsafe.Add(p, 256)) = __ccgo_fp(XTclCompileBasic2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 296)) = __ccgo_fp(_InfoObjectIsACmd)
	*(*uintptr)(unsafe.Add(p, 304)) = __ccgo_fp(XTclCompileInfoObjectIsACmd)
	*(*uintptr)(unsafe.Add(p, 344)) = __ccgo_fp(_InfoObjectMethodsCmd)
	*(*uintptr)(unsafe.Add(p, 352)) = __ccgo_fp(XTclCompileBasicMin1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 392)) = __ccgo_fp(_InfoObjectMethodTypeCmd)
	*(*uintptr)(unsafe.Add(p, 400)) = __ccgo_fp(XTclCompileBasic2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 440)) = __ccgo_fp(_InfoObjectMixinsCmd)
	*(*uintptr)(unsafe.Add(p, 448)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 488)) = __ccgo_fp(_InfoObjectNsCmd)
	*(*uintptr)(unsafe.Add(p, 496)) = __ccgo_fp(XTclCompileInfoObjectNamespaceCmd)
	*(*uintptr)(unsafe.Add(p, 536)) = __ccgo_fp(XTclOOInfoObjectPropCmd)
	*(*uintptr)(unsafe.Add(p, 544)) = __ccgo_fp(XTclCompileBasicMin1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 584)) = __ccgo_fp(_InfoObjectVariablesCmd)
	*(*uintptr)(unsafe.Add(p, 592)) = __ccgo_fp(XTclCompileBasic1Or2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 632)) = __ccgo_fp(_InfoObjectVarsCmd)
	*(*uintptr)(unsafe.Add(p, 640)) = __ccgo_fp(XTclCompileBasic1Or2ArgCmd)
}

/*
 * List of commands that are used to implement the [info class] subcommands.
 */

var _infoClassCmds = [16]TEnsembleImplMap{
	0: {
		Fname: __ccgo_ts + 88243,
	},
	1: {
		Fname: __ccgo_ts + 28529,
	},
	2: {
		Fname: __ccgo_ts + 91915,
	},
	3: {
		Fname: __ccgo_ts + 78723,
	},
	4: {
		Fname: __ccgo_ts + 28541,
	},
	5: {
		Fname: __ccgo_ts + 91926,
	},
	6: {
		Fname: __ccgo_ts + 78756,
	},
	7: {
		Fname: __ccgo_ts + 91967,
	},
	8: {
		Fname: __ccgo_ts + 88025,
	},
	9: {
		Fname: __ccgo_ts + 91938,
	},
	10: {
		Fname: __ccgo_ts + 91949,
	},
	11: {
		Fname: __ccgo_ts + 91956,
	},
	12: {
		Fname: __ccgo_ts + 91977,
	},
	13: {
		Fname: __ccgo_ts + 91988,
	},
	14: {
		Fname: __ccgo_ts + 21627,
	},
	15: {},
}

func init() {
	p := unsafe.Pointer(&_infoClassCmds)
	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(_InfoClassCallCmd)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(XTclCompileBasic2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(_InfoClassConstrCmd)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(_InfoClassDefnCmd)
	*(*uintptr)(unsafe.Add(p, 112)) = __ccgo_fp(XTclCompileBasic2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 152)) = __ccgo_fp(_InfoClassDefnNsCmd)
	*(*uintptr)(unsafe.Add(p, 160)) = __ccgo_fp(XTclCompileBasic1Or2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 200)) = __ccgo_fp(_InfoClassDestrCmd)
	*(*uintptr)(unsafe.Add(p, 208)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 248)) = __ccgo_fp(_InfoClassFiltersCmd)
	*(*uintptr)(unsafe.Add(p, 256)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 296)) = __ccgo_fp(_InfoClassForwardCmd)
	*(*uintptr)(unsafe.Add(p, 304)) = __ccgo_fp(XTclCompileBasic2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 344)) = __ccgo_fp(_InfoClassInstancesCmd)
	*(*uintptr)(unsafe.Add(p, 352)) = __ccgo_fp(XTclCompileBasic1Or2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 392)) = __ccgo_fp(_InfoClassMethodsCmd)
	*(*uintptr)(unsafe.Add(p, 400)) = __ccgo_fp(XTclCompileBasicMin1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 440)) = __ccgo_fp(_InfoClassMethodTypeCmd)
	*(*uintptr)(unsafe.Add(p, 448)) = __ccgo_fp(XTclCompileBasic2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 488)) = __ccgo_fp(_InfoClassMixinsCmd)
	*(*uintptr)(unsafe.Add(p, 496)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 536)) = __ccgo_fp(XTclOOInfoClassPropCmd)
	*(*uintptr)(unsafe.Add(p, 544)) = __ccgo_fp(XTclCompileBasicMin1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 584)) = __ccgo_fp(_InfoClassSubsCmd)
	*(*uintptr)(unsafe.Add(p, 592)) = __ccgo_fp(XTclCompileBasic1Or2ArgCmd)
	*(*uintptr)(unsafe.Add(p, 632)) = __ccgo_fp(_InfoClassSupersCmd)
	*(*uintptr)(unsafe.Add(p, 640)) = __ccgo_fp(XTclCompileBasic1ArgCmd)
	*(*uintptr)(unsafe.Add(p, 680)) = __ccgo_fp(_InfoClassVariablesCmd)
	*(*uintptr)(unsafe.Add(p, 688)) = __ccgo_fp(XTclCompileBasic1Or2ArgCmd)
}

// C documentation
//
//	/*
//	 * ----------------------------------------------------------------------
//	 *
//	 * LocalVarName --
//	 *
//	 *	Get the name of a local variable (especially a method argument) as a
//	 *	Tcl value.
//	 *
//	 * ----------------------------------------------------------------------
//	 */
func _LocalVarName(tls *libc.TLS, localPtr uintptr) (r uintptr) {
	return XTcl_NewStringObj(tls, localPtr+44, int64(-libc.Int32FromInt32(1)))
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOInitInfo --
 *
 *	Adjusts the Tcl core [info] command to contain subcommands ("object"
 *	and "class") for introspection of objects and classes.
 *
 * ----------------------------------------------------------------------
 */

func XTclOOInitInfo(tls *libc.TLS, interp uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var infoCmd TTcl_Command
	var _ /* mapDict at bp+0 */ uintptr
	_ = infoCmd
	/*
	 * Build the ensembles used to implement [info object] and [info class].
	 */
	XTclMakeEnsemble(tls, interp, __ccgo_ts+92001, uintptr(unsafe.Pointer(&_infoObjectCmds)))
	XTclMakeEnsemble(tls, interp, __ccgo_ts+92018, uintptr(unsafe.Pointer(&_infoClassCmds)))
	/*
	 * Install into the [info] ensemble.
	 */
	infoCmd = XTcl_FindCommand(tls, interp, __ccgo_ts+5873, libc.UintptrFromInt32(0), int32(TCL_GLOBAL_ONLY))
	if infoCmd != 0 {
		XTcl_GetEnsembleMappingDict(tls, libc.UintptrFromInt32(0), infoCmd, bp)
		XTclDictPutString(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), __ccgo_ts+6499, __ccgo_ts+92001)
		XTclDictPutString(tls, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(bp)), __ccgo_ts+19296, __ccgo_ts+92018)
		XTcl_SetEnsembleMappingDict(tls, interp, infoCmd, *(*uintptr)(unsafe.Pointer(bp)))
	}
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOGetClassFromObj --
 *
 *	How to correctly get a class from a Tcl_Obj. Just a wrapper round
 *	Tcl_GetObjectFromObj, but this is an idiom that was used heavily.
 *
 * ----------------------------------------------------------------------
 */

func XTclOOGetClassFromObj(tls *libc.TLS, interp uintptr, objPtr uintptr) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var oPtr, v1, v2 uintptr
	_, _, _ = oPtr, v1, v2
	oPtr = XTcl_GetObjectFromObj(tls, interp, objPtr)
	if oPtr == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	if (*TObject)(unsafe.Pointer(oPtr)).FclassPtr == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+28620, libc.VaList(bp+8, v1)))
		if (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(objPtr)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, objPtr, libc.UintptrFromInt32(0))
		}
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+28640, v2, libc.UintptrFromInt32(0)))
		return libc.UintptrFromInt32(0)
	}
	return (*TObject)(unsafe.Pointer(oPtr)).FclassPtr
}

/*
 * ----------------------------------------------------------------------
 *
 * InfoObjectClassCmd --
 *
 *	Implements [info object class $objName ?$className?]
 *
 * ----------------------------------------------------------------------
 */

func _InfoObjectClassCmd(tls *libc.TLS, dummy190 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var i TTcl_Size
	var mixinPtr, o2clsPtr, oPtr uintptr
	_, _, _, _ = i, mixinPtr, o2clsPtr, oPtr
	if objc != int32(2) && objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+92034)
		return int32(TCL_ERROR)
	}
	oPtr = XTcl_GetObjectFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if objc == int32(2) {
		XTcl_SetObjResult(tls, interp, XTclOOObjectName(tls, interp, (*TClass)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FselfCls)).FthisPtr))
		return TCL_OK
	} else {
		o2clsPtr = XTclOOGetClassFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
		if o2clsPtr == libc.UintptrFromInt32(0) {
			return int32(TCL_ERROR)
		}
		i = 0
		for {
			if !(i < (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _1
			} else {
				mixinPtr = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					if !(mixinPtr != 0) {
						goto _1
					}
					if XTclOOIsReachable(tls, o2clsPtr, mixinPtr) != 0 {
						XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(int32(1) != 0)))
						return TCL_OK
					}
				}
			}
			goto _1
		_1:
			;
			i++
		}
		XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(XTclOOIsReachable(tls, o2clsPtr, (*TObject)(unsafe.Pointer(oPtr)).FselfCls) != 0)))
		return TCL_OK
	}
	return r
}

/*
 * ----------------------------------------------------------------------
 *
 * InfoObjectDefnCmd --
 *
 *	Implements [info object definition $objName $methodName]
 *
 * ----------------------------------------------------------------------
 */

func _InfoObjectDefnCmd(tls *libc.TLS, dummy247 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var argObj, cachePtr, cachePtr1, hPtr, localPtr, oPtr, procPtr, v4, v5, v6 uintptr
	var v1, v3 bool
	var _ /* resultObjs at bp+0 */ [2]uintptr
	_, _, _, _, _, _, _, _, _, _, _, _ = argObj, cachePtr, cachePtr1, hPtr, localPtr, oPtr, procPtr, v1, v3, v4, v5, v6
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+92054)
		return int32(TCL_ERROR)
	}
	oPtr = XTcl_GetObjectFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if !((*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr != 0) {
		goto unknownMethod
	}
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr)).FfindProc})))(tls, (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
	if hPtr == libc.UintptrFromInt32(0) {
		goto unknownMethod
	}
	procPtr = XTclOOGetProcFromMethod(tls, (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData)
	if procPtr == libc.UintptrFromInt32(0) {
		goto wrongType
	}
	/*
	 * We now have the method to describe the definition of.
	 */
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		(*(*[2]uintptr)(unsafe.Pointer(bp)))[0] = XTclThreadAllocObj(tls)
	} else {
		(*(*[2]uintptr)(unsafe.Pointer(bp)))[0] = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp)))[0] + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp)))[0])).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp)))[0])).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp)))[0])).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp)))[0])).FtypePtr = libc.UintptrFromInt32(0)
	localPtr = (*TProc)(unsafe.Pointer(procPtr)).FfirstLocalPtr
	for {
		if !(localPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TCompiledLocal)(unsafe.Pointer(localPtr)).Fflags&int32(VAR_ARGUMENT) != 0 {
			if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
				argObj = XTclThreadAllocObj(tls)
			} else {
				argObj = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(argObj + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(argObj)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(argObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(argObj)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(argObj)).FtypePtr = libc.UintptrFromInt32(0)
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), argObj, _LocalVarName(tls, localPtr))
			if (*TCompiledLocal)(unsafe.Pointer(localPtr)).FdefValuePtr != libc.UintptrFromInt32(0) {
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), argObj, (*TCompiledLocal)(unsafe.Pointer(localPtr)).FdefValuePtr)
			}
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), (*(*[2]uintptr)(unsafe.Pointer(bp)))[0], argObj)
		}
		goto _2
	_2:
		;
		localPtr = (*TCompiledLocal)(unsafe.Pointer(localPtr)).FnextPtr
	}
	(*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)] = XTclOOGetMethodBody(tls, (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData)
	XTcl_SetObjResult(tls, interp, XTcl_NewListObj(tls, int64(2), bp))
	return TCL_OK
	/*
	 * Errors...
	 */
	goto unknownMethod
unknownMethod:
	;
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
		v4 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
	} else {
		v4 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
	}
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+28930, libc.VaList(bp+24, v4)))
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
		v5 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
	} else {
		v5 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
	}
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+28950, v5, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
	goto wrongType
wrongType:
	;
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+92073, int64(-libc.Int32FromInt32(1))))
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
		v6 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
	} else {
		v6 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
	}
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+28950, v6, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
}

/*
 * ----------------------------------------------------------------------
 *
 * InfoObjectFiltersCmd --
 *
 *	Implements [info object filters $objName]
 *
 * ----------------------------------------------------------------------
 */

func _InfoObjectFiltersCmd(tls *libc.TLS, dummy334 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var cachePtr, filterObj, oPtr, resultObj uintptr
	var i TTcl_Size
	var v1 bool
	_, _, _, _, _, _ = cachePtr, filterObj, i, oPtr, resultObj, v1
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+92122)
		return int32(TCL_ERROR)
	}
	oPtr = XTcl_GetObjectFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	i = 0
	for {
		if !(i < (*TObject)(unsafe.Pointer(oPtr)).Ffilters.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Ffilters.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _2
		} else {
			filterObj = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Ffilters.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, filterObj)
			}
		}
		goto _2
	_2:
		;
		i++
	}
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * InfoObjectForwardCmd --
 *
 *	Implements [info object forward $objName $methodName]
 *
 * ----------------------------------------------------------------------
 */

func _InfoObjectForwardCmd(tls *libc.TLS, dummy373 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var hPtr, oPtr, prefixObj, v1, v2, v3 uintptr
	_, _, _, _, _, _ = hPtr, oPtr, prefixObj, v1, v2, v3
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+92054)
		return int32(TCL_ERROR)
	}
	oPtr = XTcl_GetObjectFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if !((*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr != 0) {
		goto unknownMethod
	}
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr)).FfindProc})))(tls, (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
	if hPtr == libc.UintptrFromInt32(0) {
		goto unknownMethod
	}
	prefixObj = XTclOOGetFwdFromMethod(tls, (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData)
	if prefixObj == libc.UintptrFromInt32(0) {
		goto wrongType
	}
	/*
	 * Describe the valid forward method.
	 */
	XTcl_SetObjResult(tls, interp, prefixObj)
	return TCL_OK
	/*
	 * Errors...
	 */
	goto unknownMethod
unknownMethod:
	;
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
	}
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+28930, libc.VaList(bp+8, v1)))
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
		v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
	} else {
		v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
	}
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+28950, v2, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
	goto wrongType
wrongType:
	;
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+92130, int64(-libc.Int32FromInt32(1))))
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
		v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
	} else {
		v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
	}
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+28950, v3, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
}

/*
 * ----------------------------------------------------------------------
 *
 * InfoObjectIsACmd --
 *
 *	Implements [info object isa $category $objName ...]
 *
 * ----------------------------------------------------------------------
 */

func _InfoObjectIsACmd(tls *libc.TLS, dummy443 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var i TTcl_Size
	var mixinPtr, o2Ptr, oPtr uintptr
	var result int32
	var _ /* idx at bp+0 */ int32
	_, _, _, _, _ = i, mixinPtr, o2Ptr, oPtr, result
	result = 0
	if objc < int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+92212)
		return int32(TCL_ERROR)
	}
	if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)), uintptr(unsafe.Pointer(&_categories)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+92239, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	/*
	 * Now we know what test we are doing, we can check we've got the right
	 * number of arguments.
	 */
	switch *(*int32)(unsafe.Pointer(bp)) {
	case 3:
		fallthrough
	case 0:
		fallthrough
	case 1:
		if objc != int32(3) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+92122)
			return int32(TCL_ERROR)
		}
	case 2:
		fallthrough
	case 4:
		if objc != int32(4) {
			XTcl_WrongNumArgs(tls, interp, int64(2), objv, __ccgo_ts+92248)
			return int32(TCL_ERROR)
		}
		break
	}
	/*
	 * Perform the check. Note that we can guarantee that we will not fail
	 * from here on; "failures" result in a false-TCL_OK result.
	 */
	oPtr = XTcl_GetObjectFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
	if oPtr == libc.UintptrFromInt32(0) {
		goto failPrecondition
	}
	switch *(*int32)(unsafe.Pointer(bp)) {
	case 3:
		result = int32(1)
	case 0:
		result = libc.BoolInt32((*TObject)(unsafe.Pointer(oPtr)).FclassPtr != libc.UintptrFromInt32(0))
	case 1:
		if (*TObject)(unsafe.Pointer(oPtr)).FclassPtr != libc.UintptrFromInt32(0) {
			result = XTclOOIsReachable(tls, (*TFoundation)(unsafe.Pointer(XTclOOGetFoundation(tls, interp))).FclassCls, (*TObject)(unsafe.Pointer(oPtr)).FclassPtr)
		}
	case 2:
		o2Ptr = XTcl_GetObjectFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)))
		if o2Ptr == libc.UintptrFromInt32(0) {
			goto failPrecondition
		}
		if (*TObject)(unsafe.Pointer(o2Ptr)).FclassPtr != libc.UintptrFromInt32(0) {
			i = 0
			for {
				if !(i < (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Fnum) {
					break
				}
				if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
					goto _1
				} else {
					mixinPtr = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8))
					if libc.Int32FromInt32(1) != 0 {
						if !(mixinPtr != 0) {
							goto _1
						}
						if XTclOOIsReachable(tls, (*TObject)(unsafe.Pointer(o2Ptr)).FclassPtr, mixinPtr) != 0 {
							result = int32(1)
							break
						}
					}
				}
				goto _1
			_1:
				;
				i++
			}
		}
	case 4:
		o2Ptr = XTcl_GetObjectFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 3*8)))
		if o2Ptr == libc.UintptrFromInt32(0) {
			goto failPrecondition
		}
		if (*TObject)(unsafe.Pointer(o2Ptr)).FclassPtr != libc.UintptrFromInt32(0) {
			result = XTclOOIsReachable(tls, (*TObject)(unsafe.Pointer(o2Ptr)).FclassPtr, (*TObject)(unsafe.Pointer(oPtr)).FselfCls)
		}
		break
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(result != 0)))
	return TCL_OK
	goto failPrecondition
failPrecondition:
	;
	XTcl_ResetResult(tls, interp)
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, libc.BoolInt64(0 != 0)))
	return TCL_OK
}

var _categories = [6]uintptr{
	0: __ccgo_ts + 19296,
	1: __ccgo_ts + 92189,
	2: __ccgo_ts + 92199,
	3: __ccgo_ts + 6499,
	4: __ccgo_ts + 92205,
	5: libc.UintptrFromInt32(0),
}

/*
 * ----------------------------------------------------------------------
 *
 * InfoObjectMethodsCmd --
 *
 *	Implements [info object methods $objName ?$option ...?]
 *
 * ----------------------------------------------------------------------
 */

func _InfoObjectMethodsCmd(tls *libc.TLS, dummy563 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(96)
	defer tls.Free(96)
	var cachePtr, hPtr, oPtr, resultObj, v10, v7 uintptr
	var flag, i, i1, numNames, recurse, scopeFilter, v2, v6, v9 int32
	var v3 bool
	var _ /* idx at bp+0 */ int32
	var _ /* mPtr at bp+40 */ uintptr
	var _ /* namePtr at bp+32 */ uintptr
	var _ /* names at bp+48 */ uintptr
	var _ /* scope at bp+4 */ int32
	var _ /* search at bp+8 */ TTcl_HashSearch
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, flag, hPtr, i, i1, numNames, oPtr, recurse, resultObj, scopeFilter, v10, v2, v3, v6, v7, v9
	flag = int32(PUBLIC_METHOD)
	recurse = 0
	*(*int32)(unsafe.Pointer(bp + 4)) = -1
	/*
	 * Parse arguments.
	 */
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+92305)
		return int32(TCL_ERROR)
	}
	oPtr = XTcl_GetObjectFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if objc != int32(2) {
		i = int32(2)
		for {
			if !(i < objc) {
				break
			}
			if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_options21)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
				return int32(TCL_ERROR)
			}
			switch *(*int32)(unsafe.Pointer(bp)) {
			case 0:
				recurse = int32(1)
			case 1:
				flag = int32(PRIVATE_METHOD)
			case 2:
				flag = 0
			case 3:
				i++
				v2 = i
				if v2 >= objc {
					XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+92333, 0))
					XTcl_SetErrorCode(tls, interp, libc.VaList(bp+64, __ccgo_ts+2004, __ccgo_ts+16490, __ccgo_ts+17673, libc.UintptrFromInt32(0)))
					return int32(TCL_ERROR)
				}
				if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_scopes)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+92359, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+4) != TCL_OK {
					return int32(TCL_ERROR)
				}
				break
			}
			goto _1
		_1:
			;
			i++
		}
	}
	if *(*int32)(unsafe.Pointer(bp + 4)) != -1 {
		recurse = 0
		switch *(*int32)(unsafe.Pointer(bp + 4)) {
		case 0:
			flag = int32(TRUE_PRIVATE_METHOD)
		case 1:
			flag = int32(PUBLIC_METHOD)
		case 3:
			flag = int32(PRIVATE_METHOD)
		case 2:
			flag = 0
			break
		}
	}
	/*
	 * List matching methods.
	 */
	if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	if recurse != 0 {
		numNames = XTclOOGetSortedMethodList(tls, oPtr, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), flag, bp+48)
		i1 = 0
		for {
			if !(i1 < numNames) {
				break
			}
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, XTcl_NewStringObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 48)) + uintptr(i1)*8)), int64(-libc.Int32FromInt32(1))))
			goto _4
		_4:
			;
			i1++
		}
		if numNames > 0 {
			XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 48)))
		}
	} else {
		if (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr != 0 {
			if *(*int32)(unsafe.Pointer(bp + 4)) == -1 {
				/*
				 * Handle legacy-mode matching. [Bug 36e5517a6850]
				 */
				scopeFilter = flag | int32(TRUE_PRIVATE_METHOD)
				hPtr = XTcl_FirstHashEntry(tls, (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr, bp+8)
				for {
					if hPtr != libc.UintptrFromInt32(0) {
						if (*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr)).FkeyType == -int32(1) {
							v7 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
						} else {
							v7 = hPtr + 32
						}
						*(*uintptr)(unsafe.Pointer(bp + 32)) = v7
						*(*uintptr)(unsafe.Pointer(bp + 40)) = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
						v6 = libc.Int32FromInt32(1)
					} else {
						v6 = 0
					}
					if !(v6 != 0) {
						break
					}
					if (*TMethod)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).F__ccgo0_0.FtypePtr != 0 && (*TMethod)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).Fflags&scopeFilter == flag {
						XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, *(*uintptr)(unsafe.Pointer(bp + 32)))
					}
					goto _5
				_5:
					;
					hPtr = XTcl_NextHashEntry(tls, bp+8)
				}
			} else {
				hPtr = XTcl_FirstHashEntry(tls, (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr, bp+8)
				for {
					if hPtr != libc.UintptrFromInt32(0) {
						if (*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr)).FkeyType == -int32(1) {
							v10 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
						} else {
							v10 = hPtr + 32
						}
						*(*uintptr)(unsafe.Pointer(bp + 32)) = v10
						*(*uintptr)(unsafe.Pointer(bp + 40)) = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
						v9 = libc.Int32FromInt32(1)
					} else {
						v9 = 0
					}
					if !(v9 != 0) {
						break
					}
					if (*TMethod)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).F__ccgo0_0.FtypePtr != 0 && (*TMethod)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).Fflags&(int32(PUBLIC_METHOD)|int32(PRIVATE_METHOD)|int32(TRUE_PRIVATE_METHOD)) == flag {
						XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, *(*uintptr)(unsafe.Pointer(bp + 32)))
					}
					goto _8
				_8:
					;
					hPtr = XTcl_NextHashEntry(tls, bp+8)
				}
			}
		}
	}
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
}

var _options21 = [5]uintptr{
	0: __ccgo_ts + 17462,
	1: __ccgo_ts + 92266,
	2: __ccgo_ts + 91304,
	3: __ccgo_ts + 92280,
	4: libc.UintptrFromInt32(0),
}

var _scopes = [3]uintptr{
	0: __ccgo_ts + 78764,
	1: __ccgo_ts + 92287,
	2: __ccgo_ts + 92294,
}

/*
 * ----------------------------------------------------------------------
 *
 * InfoObjectMethodTypeCmd --
 *
 *	Implements [info object methodtype $objName $methodName]
 *
 * ----------------------------------------------------------------------
 */

func _InfoObjectMethodTypeCmd(tls *libc.TLS, dummy705 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var hPtr, mPtr, oPtr, v1, v2 uintptr
	_, _, _, _, _ = hPtr, mPtr, oPtr, v1, v2
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+92054)
		return int32(TCL_ERROR)
	}
	oPtr = XTcl_GetObjectFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if !((*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr != 0) {
		goto unknownMethod
	}
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr)).FfindProc})))(tls, (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
	if hPtr == libc.UintptrFromInt32(0) {
		goto unknownMethod
	}
	mPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
	if (*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr == libc.UintptrFromInt32(0) {
		/*
		 * Special entry for visibility control: pretend the method doesnt
		 * exist.
		 */
		goto unknownMethod
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, (*TTcl_MethodType)(unsafe.Pointer((*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr)).Fname, int64(-libc.Int32FromInt32(1))))
	return TCL_OK
	goto unknownMethod
unknownMethod:
	;
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
	}
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+28930, libc.VaList(bp+8, v1)))
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
		v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
	} else {
		v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
	}
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+28950, v2, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
}

/*
 * ----------------------------------------------------------------------
 *
 * InfoObjectMixinsCmd --
 *
 *	Implements [info object mixins $objName]
 *
 * ----------------------------------------------------------------------
 */

func _InfoObjectMixinsCmd(tls *libc.TLS, dummy765 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var cachePtr, mixinPtr, oPtr, resultObj uintptr
	var i TTcl_Size
	var v1 bool
	_, _, _, _, _, _ = cachePtr, i, mixinPtr, oPtr, resultObj, v1
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+92122)
		return int32(TCL_ERROR)
	}
	oPtr = XTcl_GetObjectFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	i = 0
	for {
		if !(i < (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _2
		} else {
			mixinPtr = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				if !(mixinPtr != 0) {
					goto _2
				}
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, XTclOOObjectName(tls, interp, (*TClass)(unsafe.Pointer(mixinPtr)).FthisPtr))
			}
		}
		goto _2
	_2:
		;
		i++
	}
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * InfoObjectIdCmd --
 *
 *	Implements [info object creationid $objName]
 *
 * ----------------------------------------------------------------------
 */

func _InfoObjectIdCmd(tls *libc.TLS, dummy808 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var oPtr uintptr
	_ = oPtr
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+92122)
		return int32(TCL_ERROR)
	}
	oPtr = XTcl_GetObjectFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewWideIntObj(tls, (*TObject)(unsafe.Pointer(oPtr)).FcreationEpoch))
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * InfoObjectNsCmd --
 *
 *	Implements [info object namespace $objName]
 *
 * ----------------------------------------------------------------------
 */

func _InfoObjectNsCmd(tls *libc.TLS, dummy840 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var oPtr uintptr
	_ = oPtr
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+92122)
		return int32(TCL_ERROR)
	}
	oPtr = XTcl_GetObjectFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTclNewNamespaceObj(tls, (*TObject)(unsafe.Pointer(oPtr)).FnamespacePtr))
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * InfoObjectVariablesCmd --
 *
 *	Implements [info object variables $objName ?-private?]
 *
 * ----------------------------------------------------------------------
 */

func _InfoObjectVariablesCmd(tls *libc.TLS, dummy872 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var cachePtr, oPtr, privatePtr, resultObj, variableObj, v1, v2 uintptr
	var i TTcl_Size
	var isPrivate int32
	var v3 bool
	_, _, _, _, _, _, _, _, _, _ = cachePtr, i, isPrivate, oPtr, privatePtr, resultObj, variableObj, v1, v2, v3
	isPrivate = 0
	if objc != int32(2) && objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+92365)
		return int32(TCL_ERROR)
	}
	if objc == int32(3) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		if libc.Xstrcmp(tls, __ccgo_ts+91304, v1) != 0 {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
				v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+92384, libc.VaList(bp+8, v2)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+92422))
			return int32(TCL_ERROR)
		}
		isPrivate = int32(1)
	}
	oPtr = XTcl_GetObjectFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	if isPrivate != 0 {
		i = 0
		if (*TObject)(unsafe.Pointer(oPtr)).FprivateVariables.Fnum > libc.Int64FromInt32(0) {
			for {
				privatePtr = (*TObject)(unsafe.Pointer(oPtr)).FprivateVariables.Flist + uintptr(i)*16
				if !(i < (*TObject)(unsafe.Pointer(oPtr)).FprivateVariables.Fnum) {
					break
				}
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, (*TPrivateVariableMapping)(unsafe.Pointer(privatePtr)).FvariableObj)
				goto _4
			_4:
				;
				i++
			}
		}
	} else {
		i = 0
		for {
			if !(i < (*TObject)(unsafe.Pointer(oPtr)).Fvariables.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fvariables.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _5
			} else {
				variableObj = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fvariables.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, variableObj)
				}
			}
			goto _5
		_5:
			;
			i++
		}
	}
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * InfoObjectVarsCmd --
 *
 *	Implements [info object vars $objName ?$pattern?]
 *
 * ----------------------------------------------------------------------
 */

func _InfoObjectVarsCmd(tls *libc.TLS, dummy931 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var cachePtr, hPtr, nameObj, oPtr, pattern, resultObj, v1, v5 uintptr
	var v2, v6 bool
	var v4 int32
	var _ /* search at bp+0 */ TTcl_HashSearch
	var _ /* vihPtr at bp+24 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _ = cachePtr, hPtr, nameObj, oPtr, pattern, resultObj, v1, v2, v4, v5, v6
	pattern = libc.UintptrFromInt32(0)
	if objc != int32(2) && objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+92430)
		return int32(TCL_ERROR)
	}
	oPtr = XTcl_GetObjectFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if objc == int32(3) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		pattern = v1
	}
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	/*
	 * Extract the information we need from the object's namespace's table of
	 * variables. Note that this involves horrific knowledge of the guts of
	 * tclVar.c, so we can't leverage our hash-iteration macros properly.
	 */
	hPtr = XTcl_FirstHashEntry(tls, (*TObject)(unsafe.Pointer(oPtr)).FnamespacePtr+288, bp)
	for {
		if hPtr != libc.UintptrFromInt32(0) {
			*(*uintptr)(unsafe.Pointer(bp + 24)) = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
			v4 = libc.Int32FromInt32(1)
		} else {
			v4 = 0
		}
		if !(v4 != 0) {
			break
		}
		nameObj = *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 24 + 32))
		if *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + 8)) == libc.UintptrFromInt32(0) || !((*TVar)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)))).Fflags&libc.Int32FromInt32(VAR_NAMESPACE_VAR) != 0) {
			goto _3
		}
		if v6 = pattern != libc.UintptrFromInt32(0); v6 {
			if (*TTcl_Obj)(unsafe.Pointer(nameObj)).Fbytes != 0 {
				v5 = (*TTcl_Obj)(unsafe.Pointer(nameObj)).Fbytes
			} else {
				v5 = XTcl_GetStringFromObj(tls, nameObj, libc.UintptrFromInt32(0))
			}
		}
		if v6 && !(XTcl_StringCaseMatch(tls, v5, pattern, 0) != 0) {
			goto _3
		}
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, nameObj)
		goto _3
	_3:
		;
		hPtr = XTcl_NextHashEntry(tls, bp)
	}
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * InfoClassConstrCmd --
 *
 *	Implements [info class constructor $clsName]
 *
 * ----------------------------------------------------------------------
 */

func _InfoClassConstrCmd(tls *libc.TLS, dummy992 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var argObj, cachePtr, cachePtr1, clsPtr, localPtr, procPtr uintptr
	var v1, v3 bool
	var _ /* resultObjs at bp+0 */ [2]uintptr
	_, _, _, _, _, _, _, _ = argObj, cachePtr, cachePtr1, clsPtr, localPtr, procPtr, v1, v3
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+28610)
		return int32(TCL_ERROR)
	}
	clsPtr = XTclOOGetClassFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if (*TClass)(unsafe.Pointer(clsPtr)).FconstructorPtr == libc.UintptrFromInt32(0) {
		return TCL_OK
	}
	procPtr = XTclOOGetProcFromMethod(tls, (*TClass)(unsafe.Pointer(clsPtr)).FconstructorPtr)
	if procPtr == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+92073, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+92448, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		(*(*[2]uintptr)(unsafe.Pointer(bp)))[0] = XTclThreadAllocObj(tls)
	} else {
		(*(*[2]uintptr)(unsafe.Pointer(bp)))[0] = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp)))[0] + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp)))[0])).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp)))[0])).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp)))[0])).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp)))[0])).FtypePtr = libc.UintptrFromInt32(0)
	localPtr = (*TProc)(unsafe.Pointer(procPtr)).FfirstLocalPtr
	for {
		if !(localPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TCompiledLocal)(unsafe.Pointer(localPtr)).Fflags&int32(VAR_ARGUMENT) != 0 {
			if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
				argObj = XTclThreadAllocObj(tls)
			} else {
				argObj = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(argObj + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(argObj)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(argObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(argObj)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(argObj)).FtypePtr = libc.UintptrFromInt32(0)
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), argObj, _LocalVarName(tls, localPtr))
			if (*TCompiledLocal)(unsafe.Pointer(localPtr)).FdefValuePtr != libc.UintptrFromInt32(0) {
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), argObj, (*TCompiledLocal)(unsafe.Pointer(localPtr)).FdefValuePtr)
			}
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), (*(*[2]uintptr)(unsafe.Pointer(bp)))[0], argObj)
		}
		goto _2
	_2:
		;
		localPtr = (*TCompiledLocal)(unsafe.Pointer(localPtr)).FnextPtr
	}
	(*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)] = XTclOOGetMethodBody(tls, (*TClass)(unsafe.Pointer(clsPtr)).FconstructorPtr)
	XTcl_SetObjResult(tls, interp, XTcl_NewListObj(tls, int64(2), bp))
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * InfoClassDefnCmd --
 *
 *	Implements [info class definition $clsName $methodName]
 *
 * ----------------------------------------------------------------------
 */

func _InfoClassDefnCmd(tls *libc.TLS, dummy1053 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var argObj, cachePtr, cachePtr1, clsPtr, hPtr, localPtr, procPtr, v1, v2, v3 uintptr
	var v4, v6 bool
	var _ /* resultObjs at bp+0 */ [2]uintptr
	_, _, _, _, _, _, _, _, _, _, _, _ = argObj, cachePtr, cachePtr1, clsPtr, hPtr, localPtr, procPtr, v1, v2, v3, v4, v6
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+28887)
		return int32(TCL_ERROR)
	}
	clsPtr = XTclOOGetClassFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(clsPtr + 136)).FfindProc})))(tls, clsPtr+136, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
	if hPtr == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+28930, libc.VaList(bp+24, v1)))
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+28950, v2, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	procPtr = XTclOOGetProcFromMethod(tls, (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData)
	if procPtr == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+92073, int64(-libc.Int32FromInt32(1))))
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+28950, v3, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	if v4 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v4 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v4 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		(*(*[2]uintptr)(unsafe.Pointer(bp)))[0] = XTclThreadAllocObj(tls)
	} else {
		(*(*[2]uintptr)(unsafe.Pointer(bp)))[0] = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp)))[0] + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp)))[0])).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp)))[0])).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp)))[0])).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp)))[0])).FtypePtr = libc.UintptrFromInt32(0)
	localPtr = (*TProc)(unsafe.Pointer(procPtr)).FfirstLocalPtr
	for {
		if !(localPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TCompiledLocal)(unsafe.Pointer(localPtr)).Fflags&int32(VAR_ARGUMENT) != 0 {
			if v6 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v6 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v6 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
				argObj = XTclThreadAllocObj(tls)
			} else {
				argObj = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(argObj + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(argObj)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(argObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(argObj)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(argObj)).FtypePtr = libc.UintptrFromInt32(0)
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), argObj, _LocalVarName(tls, localPtr))
			if (*TCompiledLocal)(unsafe.Pointer(localPtr)).FdefValuePtr != libc.UintptrFromInt32(0) {
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), argObj, (*TCompiledLocal)(unsafe.Pointer(localPtr)).FdefValuePtr)
			}
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), (*(*[2]uintptr)(unsafe.Pointer(bp)))[0], argObj)
		}
		goto _5
	_5:
		;
		localPtr = (*TCompiledLocal)(unsafe.Pointer(localPtr)).FnextPtr
	}
	(*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)] = XTclOOGetMethodBody(tls, (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData)
	XTcl_SetObjResult(tls, interp, XTcl_NewListObj(tls, int64(2), bp))
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * InfoClassDefnNsCmd --
 *
 *	Implements [info class definitionnamespace $clsName ?$kind?]
 *
 * ----------------------------------------------------------------------
 */

func _InfoClassDefnNsCmd(tls *libc.TLS, dummy1121 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var clsPtr, nsNamePtr uintptr
	var _ /* kind at bp+0 */ int32
	_, _ = clsPtr, nsNamePtr
	*(*int32)(unsafe.Pointer(bp)) = 0
	if objc != int32(2) && objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+92460)
		return int32(TCL_ERROR)
	}
	clsPtr = XTclOOGetClassFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if objc == int32(3) && XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 2*8)), uintptr(unsafe.Pointer(&_kindList1)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+91268, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
		return int32(TCL_ERROR)
	}
	if *(*int32)(unsafe.Pointer(bp)) != 0 {
		nsNamePtr = (*TClass)(unsafe.Pointer(clsPtr)).FobjDefinitionNs
	} else {
		nsNamePtr = (*TClass)(unsafe.Pointer(clsPtr)).FclsDefinitionNs
	}
	if nsNamePtr != 0 {
		XTcl_SetObjResult(tls, interp, nsNamePtr)
	}
	return TCL_OK
}

var _kindList1 = [3]uintptr{
	0: __ccgo_ts + 91174,
	1: __ccgo_ts + 91181,
	2: libc.UintptrFromInt32(0),
}

/*
 * ----------------------------------------------------------------------
 *
 * InfoClassDestrCmd --
 *
 *	Implements [info class destructor $clsName]
 *
 * ----------------------------------------------------------------------
 */

func _InfoClassDestrCmd(tls *libc.TLS, dummy1171 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var clsPtr, procPtr uintptr
	_, _ = clsPtr, procPtr
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+28610)
		return int32(TCL_ERROR)
	}
	clsPtr = XTclOOGetClassFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if (*TClass)(unsafe.Pointer(clsPtr)).FdestructorPtr == libc.UintptrFromInt32(0) {
		return TCL_OK
	}
	procPtr = XTclOOGetProcFromMethod(tls, (*TClass)(unsafe.Pointer(clsPtr)).FdestructorPtr)
	if procPtr == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+92073, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+92448, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTclOOGetMethodBody(tls, (*TClass)(unsafe.Pointer(clsPtr)).FdestructorPtr))
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * InfoClassFiltersCmd --
 *
 *	Implements [info class filters $clsName]
 *
 * ----------------------------------------------------------------------
 */

func _InfoClassFiltersCmd(tls *libc.TLS, dummy1216 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var cachePtr, clsPtr, filterObj, resultObj uintptr
	var i TTcl_Size
	var v1 bool
	_, _, _, _, _, _ = cachePtr, clsPtr, filterObj, i, resultObj, v1
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+28610)
		return int32(TCL_ERROR)
	}
	clsPtr = XTclOOGetClassFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	i = 0
	for {
		if !(i < (*TClass)(unsafe.Pointer(clsPtr)).Ffilters.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Ffilters.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _2
		} else {
			filterObj = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Ffilters.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, filterObj)
			}
		}
		goto _2
	_2:
		;
		i++
	}
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * InfoClassForwardCmd --
 *
 *	Implements [info class forward $clsName $methodName]
 *
 * ----------------------------------------------------------------------
 */

func _InfoClassForwardCmd(tls *libc.TLS, dummy1254 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var clsPtr, hPtr, prefixObj, v1, v2, v3 uintptr
	_, _, _, _, _, _ = clsPtr, hPtr, prefixObj, v1, v2, v3
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+28887)
		return int32(TCL_ERROR)
	}
	clsPtr = XTclOOGetClassFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(clsPtr + 136)).FfindProc})))(tls, clsPtr+136, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
	if hPtr == libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+28930, libc.VaList(bp+8, v1)))
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+28950, v2, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	prefixObj = XTclOOGetFwdFromMethod(tls, (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData)
	if prefixObj == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+92130, int64(-libc.Int32FromInt32(1))))
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v3 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v3 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+28950, v3, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, prefixObj)
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * InfoClassInstancesCmd --
 *
 *	Implements [info class instances $clsName ?$pattern?]
 *
 * ----------------------------------------------------------------------
 */

func _InfoClassInstancesCmd(tls *libc.TLS, dummy1305 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var cachePtr, clsPtr, oPtr, pattern, resultObj, tmpObj, v1, v4 uintptr
	var i TTcl_Size
	var v2, v5 bool
	_, _, _, _, _, _, _, _, _, _, _ = cachePtr, clsPtr, i, oPtr, pattern, resultObj, tmpObj, v1, v2, v4, v5
	pattern = libc.UintptrFromInt32(0)
	if objc != int32(2) && objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+92477)
		return int32(TCL_ERROR)
	}
	clsPtr = XTclOOGetClassFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if objc == int32(3) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		pattern = v1
	}
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	i = 0
	for {
		if !(i < (*TClass)(unsafe.Pointer(clsPtr)).Finstances.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Finstances.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _3
		} else {
			oPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Finstances.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				tmpObj = XTclOOObjectName(tls, interp, oPtr)
				if v5 = pattern != 0; v5 {
					if (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes != 0 {
						v4 = (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes
					} else {
						v4 = XTcl_GetStringFromObj(tls, tmpObj, libc.UintptrFromInt32(0))
					}
				}
				if v5 && !(XTcl_StringCaseMatch(tls, v4, pattern, 0) != 0) {
					goto _3
				}
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, tmpObj)
			}
		}
		goto _3
	_3:
		;
		i++
	}
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * InfoClassMethodsCmd --
 *
 *	Implements [info class methods $clsName ?options...?]
 *
 * ----------------------------------------------------------------------
 */

func _InfoClassMethodsCmd(tls *libc.TLS, dummy1353 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(96)
	defer tls.Free(96)
	var cachePtr, clsPtr, hPtr, resultObj, v10, v7 uintptr
	var flag, i, recurse, scopeFilter, v2, v6, v9 int32
	var i1, numNames TTcl_Size
	var v3 bool
	var _ /* idx at bp+0 */ int32
	var _ /* mPtr at bp+16 */ uintptr
	var _ /* namePtr at bp+8 */ uintptr
	var _ /* names at bp+24 */ uintptr
	var _ /* scope at bp+4 */ int32
	var _ /* search at bp+32 */ TTcl_HashSearch
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, clsPtr, flag, hPtr, i, i1, numNames, recurse, resultObj, scopeFilter, v10, v2, v3, v6, v7, v9
	flag = int32(PUBLIC_METHOD)
	recurse = 0
	*(*int32)(unsafe.Pointer(bp + 4)) = -1
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+92497)
		return int32(TCL_ERROR)
	}
	clsPtr = XTclOOGetClassFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if objc != int32(2) {
		i = int32(2)
		for {
			if !(i < objc) {
				break
			}
			if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_options22)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
				return int32(TCL_ERROR)
			}
			switch *(*int32)(unsafe.Pointer(bp)) {
			case 0:
				recurse = int32(1)
			case 1:
				flag = int32(PRIVATE_METHOD)
			case 2:
				flag = 0
			case 3:
				i++
				v2 = i
				if v2 >= objc {
					XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+92333, 0))
					XTcl_SetErrorCode(tls, interp, libc.VaList(bp+64, __ccgo_ts+2004, __ccgo_ts+16490, __ccgo_ts+17673, libc.UintptrFromInt32(0)))
					return int32(TCL_ERROR)
				}
				if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_scopes1)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+92359, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+4) != TCL_OK {
					return int32(TCL_ERROR)
				}
				break
			}
			goto _1
		_1:
			;
			i++
		}
	}
	if *(*int32)(unsafe.Pointer(bp + 4)) != -1 {
		recurse = 0
		switch *(*int32)(unsafe.Pointer(bp + 4)) {
		case 0:
			flag = int32(TRUE_PRIVATE_METHOD)
		case 1:
			flag = int32(PUBLIC_METHOD)
		case 2:
			flag = 0
			break
		}
	}
	if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	if recurse != 0 {
		numNames = libc.Int64FromUint64(XTclOOGetSortedClassMethodList(tls, clsPtr, flag, bp+24))
		i1 = 0
		for {
			if !(i1 < numNames) {
				break
			}
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, XTcl_NewStringObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 24)) + uintptr(i1)*8)), int64(-libc.Int32FromInt32(1))))
			goto _4
		_4:
			;
			i1++
		}
		if numNames > 0 {
			XTclpFree(tls, *(*uintptr)(unsafe.Pointer(bp + 24)))
		}
	} else {
		if *(*int32)(unsafe.Pointer(bp + 4)) == -1 {
			/*
			 * Handle legacy-mode matching. [Bug 36e5517a6850]
			 */
			scopeFilter = flag | int32(TRUE_PRIVATE_METHOD)
			hPtr = XTcl_FirstHashEntry(tls, clsPtr+136, bp+32)
			for {
				if hPtr != libc.UintptrFromInt32(0) {
					if (*TTcl_HashTable)(unsafe.Pointer(clsPtr+136)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(clsPtr+136)).FkeyType == -int32(1) {
						v7 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
					} else {
						v7 = hPtr + 32
					}
					*(*uintptr)(unsafe.Pointer(bp + 8)) = v7
					*(*uintptr)(unsafe.Pointer(bp + 16)) = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
					v6 = libc.Int32FromInt32(1)
				} else {
					v6 = 0
				}
				if !(v6 != 0) {
					break
				}
				if (*TMethod)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).F__ccgo0_0.FtypePtr != 0 && (*TMethod)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fflags&scopeFilter == flag {
					XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, *(*uintptr)(unsafe.Pointer(bp + 8)))
				}
				goto _5
			_5:
				;
				hPtr = XTcl_NextHashEntry(tls, bp+32)
			}
		} else {
			hPtr = XTcl_FirstHashEntry(tls, clsPtr+136, bp+32)
			for {
				if hPtr != libc.UintptrFromInt32(0) {
					if (*TTcl_HashTable)(unsafe.Pointer(clsPtr+136)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(clsPtr+136)).FkeyType == -int32(1) {
						v10 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
					} else {
						v10 = hPtr + 32
					}
					*(*uintptr)(unsafe.Pointer(bp + 8)) = v10
					*(*uintptr)(unsafe.Pointer(bp + 16)) = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
					v9 = libc.Int32FromInt32(1)
				} else {
					v9 = 0
				}
				if !(v9 != 0) {
					break
				}
				if (*TMethod)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).F__ccgo0_0.FtypePtr != 0 && (*TMethod)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)))).Fflags&(int32(PUBLIC_METHOD)|int32(PRIVATE_METHOD)|int32(TRUE_PRIVATE_METHOD)) == flag {
					XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, *(*uintptr)(unsafe.Pointer(bp + 8)))
				}
				goto _8
			_8:
				;
				hPtr = XTcl_NextHashEntry(tls, bp+32)
			}
		}
	}
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
}

var _options22 = [5]uintptr{
	0: __ccgo_ts + 17462,
	1: __ccgo_ts + 92266,
	2: __ccgo_ts + 91304,
	3: __ccgo_ts + 92280,
	4: libc.UintptrFromInt32(0),
}

var _scopes1 = [3]uintptr{
	0: __ccgo_ts + 78764,
	1: __ccgo_ts + 92287,
	2: __ccgo_ts + 92294,
}

/*
 * ----------------------------------------------------------------------
 *
 * InfoClassMethodTypeCmd --
 *
 *	Implements [info class methodtype $clsName $methodName]
 *
 * ----------------------------------------------------------------------
 */

func _InfoClassMethodTypeCmd(tls *libc.TLS, dummy1483 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var clsPtr, hPtr, mPtr, v1, v2 uintptr
	_, _, _, _, _ = clsPtr, hPtr, mPtr, v1, v2
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+28887)
		return int32(TCL_ERROR)
	}
	clsPtr = XTclOOGetClassFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(clsPtr + 136)).FfindProc})))(tls, clsPtr+136, *(*uintptr)(unsafe.Pointer(objv + 2*8)))
	if hPtr == libc.UintptrFromInt32(0) {
		goto unknownMethod
	}
	mPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
	if (*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr == libc.UintptrFromInt32(0) {
		/*
		 * Special entry for visibility control: pretend the method doesnt
		 * exist.
		 */
		goto unknownMethod
	}
	XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, (*TTcl_MethodType)(unsafe.Pointer((*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr)).Fname, int64(-libc.Int32FromInt32(1))))
	return TCL_OK
	goto unknownMethod
unknownMethod:
	;
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
	}
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+28930, libc.VaList(bp+8, v1)))
	if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
		v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
	} else {
		v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
	}
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+7967, __ccgo_ts+28950, v2, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
}

/*
 * ----------------------------------------------------------------------
 *
 * InfoClassMixinsCmd --
 *
 *	Implements [info class mixins $clsName]
 *
 * ----------------------------------------------------------------------
 */

func _InfoClassMixinsCmd(tls *libc.TLS, dummy1538 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var cachePtr, clsPtr, mixinPtr, resultObj uintptr
	var i TTcl_Size
	var v1 bool
	_, _, _, _, _, _ = cachePtr, clsPtr, i, mixinPtr, resultObj, v1
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+28610)
		return int32(TCL_ERROR)
	}
	clsPtr = XTclOOGetClassFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	i = 0
	for {
		if !(i < (*TClass)(unsafe.Pointer(clsPtr)).Fmixins.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _2
		} else {
			mixinPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fmixins.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				if !(mixinPtr != 0) {
					goto _2
				}
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, XTclOOObjectName(tls, interp, (*TClass)(unsafe.Pointer(mixinPtr)).FthisPtr))
			}
		}
		goto _2
	_2:
		;
		i++
	}
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * InfoClassSubsCmd --
 *
 *	Implements [info class subclasses $clsName ?$pattern?]
 *
 * ----------------------------------------------------------------------
 */

func _InfoClassSubsCmd(tls *libc.TLS, dummy1580 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var cachePtr, clsPtr, pattern, resultObj, subclassPtr, tmpObj, tmpObj1, v1, v4, v7 uintptr
	var i TTcl_Size
	var v2, v5, v8 bool
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = cachePtr, clsPtr, i, pattern, resultObj, subclassPtr, tmpObj, tmpObj1, v1, v2, v4, v5, v7, v8
	pattern = libc.UintptrFromInt32(0)
	if objc != int32(2) && objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+92477)
		return int32(TCL_ERROR)
	}
	clsPtr = XTclOOGetClassFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if objc == int32(3) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		pattern = v1
	}
	if v2 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v2 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v2 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	i = 0
	for {
		if !(i < (*TClass)(unsafe.Pointer(clsPtr)).Fsubclasses.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fsubclasses.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _3
		} else {
			subclassPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fsubclasses.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				tmpObj = XTclOOObjectName(tls, interp, (*TClass)(unsafe.Pointer(subclassPtr)).FthisPtr)
				if v5 = pattern != 0; v5 {
					if (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes != 0 {
						v4 = (*TTcl_Obj)(unsafe.Pointer(tmpObj)).Fbytes
					} else {
						v4 = XTcl_GetStringFromObj(tls, tmpObj, libc.UintptrFromInt32(0))
					}
				}
				if v5 && !(XTcl_StringCaseMatch(tls, v4, pattern, 0) != 0) {
					goto _3
				}
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, tmpObj)
			}
		}
		goto _3
	_3:
		;
		i++
	}
	i = 0
	for {
		if !(i < (*TClass)(unsafe.Pointer(clsPtr)).FmixinSubs.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).FmixinSubs.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _6
		} else {
			subclassPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).FmixinSubs.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				tmpObj1 = XTclOOObjectName(tls, interp, (*TClass)(unsafe.Pointer(subclassPtr)).FthisPtr)
				if v8 = pattern != 0; v8 {
					if (*TTcl_Obj)(unsafe.Pointer(tmpObj1)).Fbytes != 0 {
						v7 = (*TTcl_Obj)(unsafe.Pointer(tmpObj1)).Fbytes
					} else {
						v7 = XTcl_GetStringFromObj(tls, tmpObj1, libc.UintptrFromInt32(0))
					}
				}
				if v8 && !(XTcl_StringCaseMatch(tls, v7, pattern, 0) != 0) {
					goto _6
				}
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, tmpObj1)
			}
		}
		goto _6
	_6:
		;
		i++
	}
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * InfoClassSupersCmd --
 *
 *	Implements [info class superclasses $clsName]
 *
 * ----------------------------------------------------------------------
 */

func _InfoClassSupersCmd(tls *libc.TLS, dummy1635 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	var cachePtr, clsPtr, resultObj, superPtr uintptr
	var i TTcl_Size
	var v1 bool
	_, _, _, _, _, _ = cachePtr, clsPtr, i, resultObj, superPtr, v1
	if objc != int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+28610)
		return int32(TCL_ERROR)
	}
	clsPtr = XTclOOGetClassFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	i = 0
	for {
		if !(i < (*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _2
		} else {
			superPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, XTclOOObjectName(tls, interp, (*TClass)(unsafe.Pointer(superPtr)).FthisPtr))
			}
		}
		goto _2
	_2:
		;
		i++
	}
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * InfoClassVariablesCmd --
 *
 *	Implements [info class variables $clsName ?-private?]
 *
 * ----------------------------------------------------------------------
 */

func _InfoClassVariablesCmd(tls *libc.TLS, dummy1674 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var cachePtr, clsPtr, privatePtr, resultObj, variableObj, v1, v2 uintptr
	var i TTcl_Size
	var isPrivate int32
	var v3 bool
	_, _, _, _, _, _, _, _, _, _ = cachePtr, clsPtr, i, isPrivate, privatePtr, resultObj, variableObj, v1, v2, v3
	isPrivate = 0
	if objc != int32(2) && objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+92527)
		return int32(TCL_ERROR)
	}
	if objc == int32(3) {
		if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
			v1 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
		}
		if libc.Xstrcmp(tls, __ccgo_ts+91304, v1) != 0 {
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes != 0 {
				v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + 2*8)))).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(objv + 2*8)), libc.UintptrFromInt32(0))
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+92384, libc.VaList(bp+8, v2)))
			XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+92422))
			return int32(TCL_ERROR)
		}
		isPrivate = int32(1)
	}
	clsPtr = XTclOOGetClassFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	if isPrivate != 0 {
		i = 0
		if (*TClass)(unsafe.Pointer(clsPtr)).FprivateVariables.Fnum > libc.Int64FromInt32(0) {
			for {
				privatePtr = (*TClass)(unsafe.Pointer(clsPtr)).FprivateVariables.Flist + uintptr(i)*16
				if !(i < (*TClass)(unsafe.Pointer(clsPtr)).FprivateVariables.Fnum) {
					break
				}
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, (*TPrivateVariableMapping)(unsafe.Pointer(privatePtr)).FvariableObj)
				goto _4
			_4:
				;
				i++
			}
		}
	} else {
		i = 0
		for {
			if !(i < (*TClass)(unsafe.Pointer(clsPtr)).Fvariables.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fvariables.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _5
			} else {
				variableObj = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fvariables.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, variableObj)
				}
			}
			goto _5
		_5:
			;
			i++
		}
	}
	XTcl_SetObjResult(tls, interp, resultObj)
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * InfoObjectCallCmd --
 *
 *	Implements [info object call $objName $methodName]
 *
 * ----------------------------------------------------------------------
 */

func _InfoObjectCallCmd(tls *libc.TLS, dummy1733 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var contextPtr, oPtr uintptr
	_, _ = contextPtr, oPtr
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+92054)
		return int32(TCL_ERROR)
	}
	oPtr = XTcl_GetObjectFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Get the call context and render its call chain.
	 */
	contextPtr = XTclOOGetCallContext(tls, oPtr, *(*uintptr)(unsafe.Pointer(objv + 2*8)), int32(PUBLIC_METHOD), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	if contextPtr == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+92548, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+92580))
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTclOORenderCallChain(tls, interp, (*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr))
	XTclOODeleteContext(tls, contextPtr)
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * InfoClassCallCmd --
 *
 *	Implements [info class call $clsName $methodName]
 *
 * ----------------------------------------------------------------------
 */

func _InfoClassCallCmd(tls *libc.TLS, dummy1780 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var callPtr, clsPtr uintptr
	_, _ = callPtr, clsPtr
	if objc != int32(3) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+28887)
		return int32(TCL_ERROR)
	}
	clsPtr = XTclOOGetClassFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	/*
	 * Get an render the stereotypical call chain.
	 */
	callPtr = XTclOOGetStereotypeCallChain(tls, clsPtr, *(*uintptr)(unsafe.Pointer(objv + 2*8)), int32(PUBLIC_METHOD))
	if callPtr == libc.UintptrFromInt32(0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+92548, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+8, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+92580))
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, XTclOORenderCallChain(tls, interp, callPtr))
	XTclOODeleteChain(tls, callPtr)
	return TCL_OK
}

const LIMIT = 60
const TCL_OO_METHOD_VERSION_CURRENT5 = 1

/*
 * Macros used to update the flag that indicates if we are at the start of a
 * command, based on whether the opcode is INST_START_COMMAND.
 *
 * void TclUpdateAtCmdStart(unsigned char op, CompileEnv *envPtr);
 */

/*
 * Macro to emit an opcode byte into a CompileEnv's code array. The ANSI C
 * "prototype" for this macro is:
 *
 * void TclEmitOpcode(unsigned char op, CompileEnv *envPtr);
 */

/*
 * Macros to emit an integer operand. The ANSI C "prototype" for these macros
 * are:
 *
 * void TclEmitInt1(int i, CompileEnv *envPtr);
 * void TclEmitInt4(int i, CompileEnv *envPtr);
 */

/*
 * Macros to emit an instruction with signed or unsigned integer operands.
 * Four byte integers are stored in "big-endian" order with the high order
 * byte stored at the lowest address. The ANSI C "prototypes" for these macros
 * are:
 *
 * void TclEmitInstInt1(unsigned char op, int i, CompileEnv *envPtr);
 * void TclEmitInstInt4(unsigned char op, int i, CompileEnv *envPtr);
 */

/*
 * Macro to push a Tcl object onto the Tcl evaluation stack. It emits the
 * object's one or four byte array index into the CompileEnv's code array.
 * These support, respectively, a maximum of 256 (2**8) and 2**32 objects in a
 * CompileEnv. The ANSI C "prototype" for this macro is:
 *
 * void	TclEmitPush(int objIndex, CompileEnv *envPtr);
 */

/*
 * Macros to update a (signed or unsigned) integer starting at a pointer. The
 * two variants depend on the number of bytes. The ANSI C "prototypes" for
 * these macros are:
 *
 * void TclStoreInt1AtPtr(int i, unsigned char *p);
 * void TclStoreInt4AtPtr(int i, unsigned char *p);
 */

/*
 * Macros to update instructions at a particular pc with a new op code and a
 * (signed or unsigned) int operand. The ANSI C "prototypes" for these macros
 * are:
 *
 * void TclUpdateInstInt1AtPc(unsigned char op, int i, unsigned char *pc);
 * void TclUpdateInstInt4AtPc(unsigned char op, int i, unsigned char *pc);
 */

/*
 * Macro to fix up a forward jump to point to the current code-generation
 * position in the bytecode being created (the most common case). The ANSI C
 * "prototypes" for this macro is:
 *
 * int TclFixupForwardJumpToHere(CompileEnv *envPtr, JumpFixup *fixupPtr,
 *				 int threshold);
 */

/*
 * Macros to get a signed integer (GET_INT{1,2}) or an unsigned int
 * (GET_UINT{1,2}) from a pointer. There are two variants for each return type
 * that depend on the number of bytes fetched. The ANSI C "prototypes" for
 * these macros are:
 *
 * int TclGetInt1AtPtr(unsigned char *p);
 * int TclGetInt4AtPtr(unsigned char *p);
 * unsigned int TclGetUInt1AtPtr(unsigned char *p);
 * unsigned int TclGetUInt4AtPtr(unsigned char *p);
 */

/*
 * The TclGetInt1AtPtr macro is tricky because we want to do sign extension on
 * the 1-byte value. Unfortunately the "char" type isn't signed on all
 * platforms so sign-extension doesn't always happen automatically. Sometimes
 * we can explicitly declare the pointer to be signed, but other times we have
 * to explicitly sign-extend the value in software.
 */

/*
 * Macros used to compute the minimum and maximum of two values. The ANSI C
 * "prototypes" for these macros are:
 *
 * size_t TclMin(size_t i, size_t j);
 * size_t TclMax(size_t i, size_t j);
 */

/*
 * Convenience macros for use when compiling bodies of commands. The ANSI C
 * "prototype" for these macros are:
 *
 * static void		BODY(Tcl_Token *tokenPtr, int word);
 */

/*
 * Convenience macro for use when compiling tokens to be pushed. The ANSI C
 * "prototype" for this macro is:
 *
 * static void		CompileTokens(CompileEnv *envPtr, Tcl_Token *tokenPtr,
 *			    Tcl_Interp *interp);
 */

/*
 * Convenience macros for use when pushing literals. The ANSI C "prototype" for
 * these macros are:
 *
 * static void		PushLiteral(CompileEnv *envPtr,
 *			    const char *string, Tcl_Size length);
 * static void		PushStringLiteral(CompileEnv *envPtr,
 *			    const char *string);
 */

/*
 * Macro to advance to the next token; it is more mnemonic than the address
 * arithmetic that it replaces. The ANSI C "prototype" for this macro is:
 *
 * static Tcl_Token *	TokenAfter(Tcl_Token *tokenPtr);
 */

/*
 * Macro to get the offset to the next instruction to be issued. The ANSI C
 * "prototype" for this macro is:
 *
 * static ptrdiff_t	CurrentOffset(CompileEnv *envPtr);
 */

/*
 * Note: the exceptDepth is a bit of a misnomer: TEBC only needs the
 * maximal depth of nested CATCH ranges in order to alloc runtime
 * memory. These macros should compute precisely that? OTOH, the nesting depth
 * of LOOP ranges is an interesting datum for debugging purposes, and that is
 * what we compute now.
 *
 * static int	ExceptionRangeStarts(CompileEnv *envPtr, Tcl_Size index);
 * static void	ExceptionRangeEnds(CompileEnv *envPtr, Tcl_Size index);
 * static void	ExceptionRangeTarget(CompileEnv *envPtr, Tcl_Size index, LABEL);
 */

/*
 * Check if there is an LVT for compiled locals
 */

/*
 * Macros for making it easier to deal with tokens and DStrings.
 */

/*
 * Macro that encapsulates an efficiency trick that avoids a function call for
 * the simplest of compiles. The ANSI C "prototype" for this macro is:
 *
 * static void		CompileWord(CompileEnv *envPtr, Tcl_Token *tokenPtr,
 *			    Tcl_Interp *interp, int word);
 */

/*
 * TIP #280: Remember the per-word line information of the current command. An
 * index is used instead of a pointer as recursive compilation may reallocate,
 * i.e. move, the array. This is also the reason to save the nuloc now, it may
 * change during the course of the function.
 *
 * Macro to encapsulate the variable definition and setup.
 */

/*
 * Often want to issue one of two versions of an instruction based on whether
 * the argument will fit in a single byte or not. This makes it much clearer.
 */

/*
 * How to get an anonymous local variable (used for holding temporary values
 * off the stack) or a local simple scalar.
 */

/*
 * Flags bits used by TclPushVarName.
 */

/*
 * Flags bits used by lreplace4 instruction
 */

/*
 * DTrace probe macros (NOPs if DTrace support is not enabled).
 */

/*
 * Define the following macros to enable debug logging of the DTrace proc,
 * cmd, and inst probes. Note that this does _not_ require a platform with
 * DTrace, it simply logs all probe output to /tmp/tclDTraceDebug-[pid].log.
 *
 * If the second macro is defined, logging to file starts immediately,
 * otherwise only after the first call to [tcl::dtrace]. Note that the debug
 * probe data is always computed, even when it is not logged to file.
 *
 * Defining the third macro enables debug logging of inst probes (disabled
 * by default due to the significant performance impact).
 */

/*
#define TCL_DTRACE_DEBUG 1
#define TCL_DTRACE_DEBUG_LOG_ENABLED 1
#define TCL_DTRACE_DEBUG_INST_PROBES 1
*/

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * Structure used to contain all the information needed about a call frame
 * used in a procedure-like method.
 */

type TPMFrameData = struct {
	FframePtr uintptr
	FerrProc  uintptr
	FnameObj  uintptr
}

/*
 * Structure used to pass information about variable resolution to the
 * on-the-ground resolvers used when working with resolved compiled variables.
 */

type TOOResVarInfo = struct {
	Finfo            TTcl_ResolvedVarInfo
	FvariableObj     uintptr
	FcachedObjectVar TTcl_Var
}

/*
 * The types of methods defined by the core OO system.
 */

var _procMethodType = TTcl_MethodType{
	Fversion: int32(TCL_OO_METHOD_VERSION_1),
	Fname:    __ccgo_ts + 28559,
}

func init() {
	p := unsafe.Pointer(&_procMethodType)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_InvokeProcedureMethod)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_DeleteProcedureMethod)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_CloneProcedureMethod)
}

var _fwdMethodType = TTcl_MethodType{
	Fversion: int32(TCL_OO_METHOD_VERSION_1),
	Fname:    __ccgo_ts + 78756,
}

func init() {
	p := unsafe.Pointer(&_fwdMethodType)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_InvokeForwardMethod)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_DeleteForwardMethod)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_CloneForwardMethod)
}

/*
 * Helper macros (derived from things private to tclVar.c)
 */

func _AllocProcedureMethodRecord(tls *libc.TLS, flags int32) (r uintptr) {
	var pmPtr uintptr
	_ = pmPtr
	pmPtr = XTcl_Alloc(tls, uint64(288))
	libc.Xmemset(tls, pmPtr, 0, uint64(288))
	(*TProcedureMethod)(unsafe.Pointer(pmPtr)).Fversion = int32(TCLOO_PROCEDURE_METHOD_VERSION_1)
	(*TProcedureMethod)(unsafe.Pointer(pmPtr)).Fflags = flags & int32(USE_DECLARER_NS)
	(*TProcedureMethod)(unsafe.Pointer(pmPtr)).FrefCount = int64(1)
	(*TProcedureMethod)(unsafe.Pointer(pmPtr)).Fcmd.FclientData = pmPtr + 208
	return pmPtr
}

/*
 * ----------------------------------------------------------------------
 *
 * Tcl_NewInstanceMethod --
 *
 *	Attach a method to an object instance.
 *
 * ----------------------------------------------------------------------
 */

func XTclNewInstanceMethod(tls *libc.TLS, dummy129 uintptr, object TTcl_Object, nameObj uintptr, flags int32, typePtr uintptr, clientData uintptr) (r TTcl_Method) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Some data associated with the particular
	 * method to be created. */
	var hPtr, mPtr, oPtr uintptr
	var _ /* isNew at bp+0 */ int32
	_, _, _ = hPtr, mPtr, oPtr
	oPtr = object
	if nameObj == libc.UintptrFromInt32(0) {
		mPtr = XTcl_Alloc(tls, uint64(56))
		(*TMethod)(unsafe.Pointer(mPtr)).FnamePtr = libc.UintptrFromInt32(0)
		(*TMethod)(unsafe.Pointer(mPtr)).FrefCount = int64(1)
		goto populate
	}
	if !((*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr != 0) {
		(*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr = XTcl_Alloc(tls, uint64(104))
		XTcl_InitObjHashTable(tls, (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr)
		*(*int32)(unsafe.Pointer(oPtr + 96)) &= ^int32(USE_CLASS_CACHE)
	}
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr)).FcreateProc})))(tls, (*TObject)(unsafe.Pointer(oPtr)).FmethodsPtr, nameObj, bp)
	if *(*int32)(unsafe.Pointer(bp)) != 0 {
		mPtr = XTcl_Alloc(tls, uint64(56))
		(*TMethod)(unsafe.Pointer(mPtr)).FnamePtr = nameObj
		(*TMethod)(unsafe.Pointer(mPtr)).FrefCount = int64(1)
		(*TTcl_Obj)(unsafe.Pointer(nameObj)).FrefCount++
		(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = mPtr
	} else {
		mPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		if (*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr != libc.UintptrFromInt32(0) && (*TTcl_MethodType)(unsafe.Pointer((*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr)).FdeleteProc != libc.UintptrFromInt32(0) {
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_MethodType)(unsafe.Pointer((*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr)).FdeleteProc})))(tls, (*TMethod)(unsafe.Pointer(mPtr)).FclientData)
		}
	}
	goto populate
populate:
	;
	(*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr = typePtr
	(*TMethod)(unsafe.Pointer(mPtr)).FclientData = clientData
	(*TMethod)(unsafe.Pointer(mPtr)).Fflags = 0
	(*TMethod)(unsafe.Pointer(mPtr)).FdeclaringObjectPtr = oPtr
	(*TMethod)(unsafe.Pointer(mPtr)).FdeclaringClassPtr = libc.UintptrFromInt32(0)
	if flags != 0 {
		*(*int32)(unsafe.Pointer(mPtr + 48)) |= flags & (int32(PUBLIC_METHOD) | int32(PRIVATE_METHOD) | int32(TRUE_PRIVATE_METHOD))
		if flags&int32(TRUE_PRIVATE_METHOD) != 0 {
			*(*int32)(unsafe.Pointer(oPtr + 96)) |= int32(HAS_PRIVATE_METHODS)
		}
	}
	(*TObject)(unsafe.Pointer(oPtr)).Fepoch++
	return mPtr
}

func XTcl_NewInstanceMethod(tls *libc.TLS, dummy191 uintptr, object TTcl_Object, nameObj uintptr, flags int32, typePtr uintptr, clientData uintptr) (r TTcl_Method) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Some data associated with the particular
	 * method to be created. */
	if (*TTcl_MethodType)(unsafe.Pointer(typePtr)).Fversion > int32(TCL_OO_METHOD_VERSION_1) {
		XTcl_Panic(tls, __ccgo_ts+92595, libc.VaList(bp+8, __ccgo_ts+92647, __ccgo_ts+92669))
	}
	return XTclNewInstanceMethod(tls, libc.UintptrFromInt32(0), object, nameObj, flags, typePtr, clientData)
}

func XTcl_NewInstanceMethod2(tls *libc.TLS, dummy214 uintptr, object TTcl_Object, nameObj uintptr, flags int32, typePtr uintptr, clientData uintptr) (r TTcl_Method) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Some data associated with the particular
	 * method to be created. */
	if (*TTcl_MethodType2)(unsafe.Pointer(typePtr)).Fversion < int32(TCL_OO_METHOD_VERSION_2) {
		XTcl_Panic(tls, __ccgo_ts+92595, libc.VaList(bp+8, __ccgo_ts+92693, __ccgo_ts+92716))
	}
	return XTclNewInstanceMethod(tls, libc.UintptrFromInt32(0), object, nameObj, flags, typePtr, clientData)
}

/*
 * ----------------------------------------------------------------------
 *
 * Tcl_NewMethod --
 *
 *	Attach a method to a class.
 *
 * ----------------------------------------------------------------------
 */

func XTclNewMethod(tls *libc.TLS, cls TTcl_Class, nameObj uintptr, flags int32, typePtr uintptr, clientData uintptr) (r TTcl_Method) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Some data associated with the particular
	 * method to be created. */
	var clsPtr, hPtr, mPtr uintptr
	var _ /* isNew at bp+0 */ int32
	_, _, _ = clsPtr, hPtr, mPtr
	clsPtr = cls
	if nameObj == libc.UintptrFromInt32(0) {
		mPtr = XTcl_Alloc(tls, uint64(56))
		(*TMethod)(unsafe.Pointer(mPtr)).FnamePtr = libc.UintptrFromInt32(0)
		(*TMethod)(unsafe.Pointer(mPtr)).FrefCount = int64(1)
		goto populate
	}
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(clsPtr + 136)).FcreateProc})))(tls, clsPtr+136, nameObj, bp)
	if *(*int32)(unsafe.Pointer(bp)) != 0 {
		mPtr = XTcl_Alloc(tls, uint64(56))
		(*TMethod)(unsafe.Pointer(mPtr)).FrefCount = int64(1)
		(*TMethod)(unsafe.Pointer(mPtr)).FnamePtr = nameObj
		(*TTcl_Obj)(unsafe.Pointer(nameObj)).FrefCount++
		(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = mPtr
	} else {
		mPtr = (*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData
		if (*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr != libc.UintptrFromInt32(0) && (*TTcl_MethodType)(unsafe.Pointer((*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr)).FdeleteProc != libc.UintptrFromInt32(0) {
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_MethodType)(unsafe.Pointer((*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr)).FdeleteProc})))(tls, (*TMethod)(unsafe.Pointer(mPtr)).FclientData)
		}
	}
	goto populate
populate:
	;
	(*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).FthisPtr)).FfPtr)).Fepoch++
	(*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr = typePtr
	(*TMethod)(unsafe.Pointer(mPtr)).FclientData = clientData
	(*TMethod)(unsafe.Pointer(mPtr)).Fflags = 0
	(*TMethod)(unsafe.Pointer(mPtr)).FdeclaringObjectPtr = libc.UintptrFromInt32(0)
	(*TMethod)(unsafe.Pointer(mPtr)).FdeclaringClassPtr = clsPtr
	if flags != 0 {
		*(*int32)(unsafe.Pointer(mPtr + 48)) |= flags & (int32(PUBLIC_METHOD) | int32(PRIVATE_METHOD) | int32(TRUE_PRIVATE_METHOD))
		if flags&int32(TRUE_PRIVATE_METHOD) != 0 {
			*(*int32)(unsafe.Pointer(clsPtr + 8)) |= int32(HAS_PRIVATE_METHODS)
		}
	}
	return mPtr
}

func XTcl_NewMethod(tls *libc.TLS, dummy305 uintptr, cls TTcl_Class, nameObj uintptr, flags int32, typePtr uintptr, clientData uintptr) (r TTcl_Method) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Some data associated with the particular
	 * method to be created. */
	if (*TTcl_MethodType)(unsafe.Pointer(typePtr)).Fversion > int32(TCL_OO_METHOD_VERSION_1) {
		XTcl_Panic(tls, __ccgo_ts+92595, libc.VaList(bp+8, __ccgo_ts+92740, __ccgo_ts+92669))
	}
	return XTclNewMethod(tls, cls, nameObj, flags, typePtr, clientData)
}

func XTcl_NewMethod2(tls *libc.TLS, dummy327 uintptr, cls TTcl_Class, nameObj uintptr, flags int32, typePtr uintptr, clientData uintptr) (r TTcl_Method) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Some data associated with the particular
	 * method to be created. */
	if (*TTcl_MethodType2)(unsafe.Pointer(typePtr)).Fversion < int32(TCL_OO_METHOD_VERSION_2) {
		XTcl_Panic(tls, __ccgo_ts+92595, libc.VaList(bp+8, __ccgo_ts+92754, __ccgo_ts+92716))
	}
	return XTclNewMethod(tls, cls, nameObj, flags, typePtr, clientData)
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOODelMethodRef --
 *
 *	How to delete a method.
 *
 * ----------------------------------------------------------------------
 */

func XTclOODelMethodRef(tls *libc.TLS, mPtr uintptr) {
	var _objPtr, v2, v5 uintptr
	var v1, v4 TTcl_Size
	var v3 bool
	_, _, _, _, _, _ = _objPtr, v1, v2, v3, v4, v5
	if v3 = mPtr != libc.UintptrFromInt32(0); v3 {
		v2 = mPtr + 8
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
	}
	if v3 && v1 <= int64(1) {
		if (*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr != libc.UintptrFromInt32(0) && (*TTcl_MethodType)(unsafe.Pointer((*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr)).FdeleteProc != libc.UintptrFromInt32(0) {
			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_MethodType)(unsafe.Pointer((*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr)).FdeleteProc})))(tls, (*TMethod)(unsafe.Pointer(mPtr)).FclientData)
		}
		if (*TMethod)(unsafe.Pointer(mPtr)).FnamePtr != libc.UintptrFromInt32(0) {
			_objPtr = (*TMethod)(unsafe.Pointer(mPtr)).FnamePtr
			v5 = _objPtr
			v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
			*(*TTcl_Size)(unsafe.Pointer(v5))--
			if v4 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
		XTclpFree(tls, mPtr)
	}
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOODefineBasicMethods --
 *
 *	Helper that makes it cleaner to create very simple methods during
 *	basic system initialization. Not suitable for general use.
 *
 * ----------------------------------------------------------------------
 */

func XTclOODefineBasicMethods(tls *libc.TLS, clsPtr uintptr, dcmAry uintptr) {
	/* Static table of method definitions. */
	var _objPtr, namePtr, v3, v5 uintptr
	var i, v2 int32
	var v4 TTcl_Size
	_, _, _, _, _, _, _ = _objPtr, i, namePtr, v2, v3, v4, v5
	i = 0
	for {
		if !((*(*TDeclaredClassMethod)(unsafe.Pointer(dcmAry + uintptr(i)*56))).Fname != 0) {
			break
		}
		namePtr = XTcl_NewStringObj(tls, (*(*TDeclaredClassMethod)(unsafe.Pointer(dcmAry + uintptr(i)*56))).Fname, int64(-libc.Int32FromInt32(1)))
		if (*(*TDeclaredClassMethod)(unsafe.Pointer(dcmAry + uintptr(i)*56))).FisPublic != 0 {
			v2 = int32(PUBLIC_METHOD)
		} else {
			v2 = 0
		}
		XTclNewMethod(tls, clsPtr, namePtr, v2, dcmAry+uintptr(i)*56+16, libc.UintptrFromInt32(0))
		v3 = namePtr
		if v3 != 0 {
			if (*TTcl_Obj)(unsafe.Pointer(v3)).FrefCount == libc.Int64FromInt32(0) {
				_objPtr = v3
				v5 = _objPtr
				v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
				*(*TTcl_Size)(unsafe.Pointer(v5))--
				if v4 <= libc.Int64FromInt32(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
		}
		goto _1
	_1:
		;
		i++
	}
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOONewProcInstanceMethod --
 *
 *	Create a new procedure-like method for an object.
 *
 * ----------------------------------------------------------------------
 */

func XTclOONewProcInstanceMethod(tls *libc.TLS, interp uintptr, oPtr uintptr, flags int32, nameObj uintptr, argsObj uintptr, bodyObj uintptr, pmPtrPtr uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Place to write pointer to procedure method
	 * structure to allow for deeper tuning of the
	 * structure's contents. NULL if caller is not
	 * interested. */
	var method TTcl_Method
	var pmPtr uintptr
	var v1 int32
	var v2 int64
	var _ /* argsLen at bp+0 */ TTcl_Size
	_, _, _, _ = method, pmPtr, v1, v2
	if (*TTcl_Obj)(unsafe.Pointer(argsObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(argsObj + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(argsObj + 32))).Fptr2)).FspanLength
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(argsObj + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v2
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjLength(tls, interp, argsObj, bp)
	}
	if v1 != TCL_OK {
		return libc.UintptrFromInt32(0)
	}
	pmPtr = _AllocProcedureMethodRecord(tls, flags)
	method = XTclOOMakeProcInstanceMethod(tls, interp, oPtr, flags, nameObj, argsObj, bodyObj, uintptr(unsafe.Pointer(&_procMethodType)), pmPtr, pmPtr+8)
	if method == libc.UintptrFromInt32(0) {
		XTclpFree(tls, pmPtr)
	} else {
		if pmPtrPtr != libc.UintptrFromInt32(0) {
			*(*uintptr)(unsafe.Pointer(pmPtrPtr)) = pmPtr
		}
	}
	return method
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOONewProcMethod --
 *
 *	Create a new procedure-like method for a class.
 *
 * ----------------------------------------------------------------------
 */

func XTclOONewProcMethod(tls *libc.TLS, interp uintptr, clsPtr uintptr, flags int32, nameObj uintptr, argsObj uintptr, bodyObj uintptr, pmPtrPtr uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Place to write pointer to procedure method
	 * structure to allow for deeper tuning of the
	 * structure's contents. NULL if caller is not
	 * interested. */
	var _objPtr, cachePtr, pmPtr, procName, v4, v5, v7 uintptr
	var method TTcl_Method
	var v1 bool
	var v2 int32
	var v3 int64
	var v6 TTcl_Size
	var _ /* argsLen at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, method, pmPtr, procName, v1, v2, v3, v4, v5, v6, v7
	if argsObj == libc.UintptrFromInt32(0) {
		*(*TTcl_Size)(unsafe.Pointer(bp)) = int64(-libc.Int32FromInt32(1))
		if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			argsObj = XTclThreadAllocObj(tls)
		} else {
			argsObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(argsObj + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		(*TTcl_Obj)(unsafe.Pointer(argsObj)).FrefCount = 0
		(*TTcl_Obj)(unsafe.Pointer(argsObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
		(*TTcl_Obj)(unsafe.Pointer(argsObj)).Flength = 0
		(*TTcl_Obj)(unsafe.Pointer(argsObj)).FtypePtr = libc.UintptrFromInt32(0)
		(*TTcl_Obj)(unsafe.Pointer(argsObj)).FrefCount++
		procName = __ccgo_ts + 86979
	} else {
		if (*TTcl_Obj)(unsafe.Pointer(argsObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
			if (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(argsObj + 32))).Fptr2 != 0 {
				v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(argsObj + 32))).Fptr2)).FspanLength
			} else {
				v3 = (*TListStore)(unsafe.Pointer((*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(argsObj + 32))).Fptr1)).FnumUsed
			}
			*(*TTcl_Size)(unsafe.Pointer(bp)) = v3
			v2 = libc.Int32FromInt32(TCL_OK)
		} else {
			v2 = XTcl_ListObjLength(tls, interp, argsObj, bp)
		}
		if v2 != TCL_OK {
			return libc.UintptrFromInt32(0)
		} else {
			if nameObj == libc.UintptrFromInt32(0) {
				v4 = __ccgo_ts + 86965
			} else {
				if (*TTcl_Obj)(unsafe.Pointer(nameObj)).Fbytes != 0 {
					v5 = (*TTcl_Obj)(unsafe.Pointer(nameObj)).Fbytes
				} else {
					v5 = XTcl_GetStringFromObj(tls, nameObj, libc.UintptrFromInt32(0))
				}
				v4 = v5
			}
			procName = v4
		}
	}
	pmPtr = _AllocProcedureMethodRecord(tls, flags)
	method = XTclOOMakeProcMethod(tls, interp, clsPtr, flags, nameObj, procName, argsObj, bodyObj, uintptr(unsafe.Pointer(&_procMethodType)), pmPtr, pmPtr+8)
	if *(*TTcl_Size)(unsafe.Pointer(bp)) == int64(-libc.Int32FromInt32(1)) {
		_objPtr = argsObj
		v7 = _objPtr
		v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
		*(*TTcl_Size)(unsafe.Pointer(v7))--
		if v6 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	if method == libc.UintptrFromInt32(0) {
		XTclpFree(tls, pmPtr)
	} else {
		if pmPtrPtr != libc.UintptrFromInt32(0) {
			*(*uintptr)(unsafe.Pointer(pmPtrPtr)) = pmPtr
		}
	}
	return method
}

// C documentation
//
//	/*
//	 * ----------------------------------------------------------------------
//	 *
//	 * InitCmdFrame --
//	 *
//	 *	Set up a CmdFrame to record the source location for a procedure
//	 *	method. Assumes that the body is the last argument to the command
//	 *	creating the method, a good assumption because putting the body
//	 *	elsewhere is ugly.
//	 *
//	 * ----------------------------------------------------------------------
//	 */
func _InitCmdFrame(tls *libc.TLS, iPtr uintptr, procPtr uintptr) {
	bp := tls.Alloc(96)
	defer tls.Free(96) /* Guts of the method being made. */
	var _objPtr, cfPtr, hPtr, v2 uintptr
	var v1 TTcl_Size
	var _ /* context at bp+0 */ TCmdFrame
	var _ /* isNew at bp+88 */ int32
	_, _, _, _, _ = _objPtr, cfPtr, hPtr, v1, v2
	if (*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr != 0 {
		*(*TCmdFrame)(unsafe.Pointer(bp)) = TCmdFrame{}
		*(*TCmdFrame1)(unsafe.Pointer(bp)) = *(*TCmdFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FcmdFramePtr))
		if (*(*TCmdFrame)(unsafe.Pointer(bp))).Ftype1 == int32(TCL_LOCATION_BC) {
			/*
			 * Retrieve source information from the bytecode, if possible. If
			 * the information is retrieved successfully, context.type will be
			 * TCL_LOCATION_SOURCE and the reference held by
			 * context.data.eval.path will be counted.
			 */
			XTclGetSrcInfoForPc(tls, bp)
		} else {
			if (*(*TCmdFrame)(unsafe.Pointer(bp))).Ftype1 == int32(TCL_LOCATION_SOURCE) {
				/*
				 * The copy into 'context' up above has created another reference
				 * to 'context.data.eval.path'; account for it.
				 */
				(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 40)))).FrefCount++
			}
		}
		if (*(*TCmdFrame)(unsafe.Pointer(bp))).Ftype1 == int32(TCL_LOCATION_SOURCE) {
			/*
			 * We can account for source location within a proc only if the
			 * proc body was not created by substitution. This is where we
			 * assume that the body is the last argument; the index of the body
			 * is NOT a fixed count of arguments in because of the alternate
			 * form of [oo::define]/[oo::objdefine].
			 * (FIXME: check that this is sane and correct!)
			 */
			if (*(*TCmdFrame)(unsafe.Pointer(bp))).Fline != 0 && (*(*TCmdFrame)(unsafe.Pointer(bp))).Fnline > int64(1) && *(*TTcl_Size)(unsafe.Pointer((*(*TCmdFrame)(unsafe.Pointer(bp))).Fline + uintptr((*(*TCmdFrame)(unsafe.Pointer(bp))).Fnline-int64(1))*8)) >= 0 {
				cfPtr = XTcl_Alloc(tls, uint64(88))
				(*TCmdFrame)(unsafe.Pointer(cfPtr)).Flevel = -int32(1)
				(*TCmdFrame)(unsafe.Pointer(cfPtr)).Ftype1 = (*(*TCmdFrame)(unsafe.Pointer(bp))).Ftype1
				(*TCmdFrame)(unsafe.Pointer(cfPtr)).Fline = XTcl_Alloc(tls, uint64(8))
				*(*TTcl_Size)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(cfPtr)).Fline)) = *(*TTcl_Size)(unsafe.Pointer((*(*TCmdFrame)(unsafe.Pointer(bp))).Fline + uintptr((*(*TCmdFrame)(unsafe.Pointer(bp))).Fnline-int64(1))*8))
				(*TCmdFrame)(unsafe.Pointer(cfPtr)).Fnline = int64(1)
				(*TCmdFrame)(unsafe.Pointer(cfPtr)).FframePtr = libc.UintptrFromInt32(0)
				(*TCmdFrame)(unsafe.Pointer(cfPtr)).FnextPtr = libc.UintptrFromInt32(0)
				(*TCmdFrame)(unsafe.Pointer(cfPtr)).Fdata.Feval.Fpath = *(*uintptr)(unsafe.Pointer(bp + 40))
				(*TTcl_Obj)(unsafe.Pointer((*TCmdFrame)(unsafe.Pointer(cfPtr)).Fdata.Feval.Fpath)).FrefCount++
				(*TCmdFrame)(unsafe.Pointer(cfPtr)).Fcmd = libc.UintptrFromInt32(0)
				(*TCmdFrame)(unsafe.Pointer(cfPtr)).Flen1 = 0
				hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TInterp)(unsafe.Pointer(iPtr)).FlinePBodyPtr)).FcreateProc})))(tls, (*TInterp)(unsafe.Pointer(iPtr)).FlinePBodyPtr, procPtr, bp+88)
				(*TTcl_HashEntry)(unsafe.Pointer(hPtr)).FclientData = cfPtr
			}
			/*
			 * 'context' is going out of scope; account for the reference that
			 * it's holding to the path name.
			 */
			_objPtr = *(*uintptr)(unsafe.Pointer(bp + 40))
			v2 = _objPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if v1 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			*(*uintptr)(unsafe.Pointer(bp + 40)) = libc.UintptrFromInt32(0)
		}
	}
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOMakeProcInstanceMethod --
 *
 *	The guts of the code to make a procedure-like method for an object.
 *	Split apart so that it is easier for other extensions to reuse (in
 *	particular, it frees them from having to pry so deeply into Tcl's
 *	guts).
 *
 * ----------------------------------------------------------------------
 */

func XTclOOMakeProcInstanceMethod(tls *libc.TLS, interp uintptr, oPtr uintptr, flags int32, nameObj uintptr, argsObj uintptr, bodyObj uintptr, typePtr uintptr, clientData uintptr, procPtrPtr uintptr) (r TTcl_Method) {
	/* A pointer to the variable in which to write
	 * the procedure record reference. Presumably
	 * inside the structure indicated by the
	 * pointer in clientData. */
	var iPtr, procPtr, v1 uintptr
	_, _, _ = iPtr, procPtr, v1
	iPtr = interp
	if (*TTcl_Obj)(unsafe.Pointer(nameObj)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(nameObj)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, nameObj, libc.UintptrFromInt32(0))
	}
	if XTclCreateProc(tls, interp, libc.UintptrFromInt32(0), v1, argsObj, bodyObj, procPtrPtr) != TCL_OK {
		return libc.UintptrFromInt32(0)
	}
	procPtr = *(*uintptr)(unsafe.Pointer(procPtrPtr))
	(*TProc)(unsafe.Pointer(procPtr)).FcmdPtr = libc.UintptrFromInt32(0)
	_InitCmdFrame(tls, iPtr, procPtr)
	return XTclNewInstanceMethod(tls, interp, oPtr, nameObj, flags, typePtr, clientData)
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOMakeProcMethod --
 *
 *	The guts of the code to make a procedure-like method for a class.
 *	Split apart so that it is easier for other extensions to reuse (in
 *	particular, it frees them from having to pry so deeply into Tcl's
 *	guts).
 *
 * ----------------------------------------------------------------------
 */

func XTclOOMakeProcMethod(tls *libc.TLS, interp uintptr, clsPtr uintptr, flags int32, nameObj uintptr, namePtr uintptr, argsObj uintptr, bodyObj uintptr, typePtr uintptr, clientData uintptr, procPtrPtr uintptr) (r TTcl_Method) {
	/* A pointer to the variable in which to write
	 * the procedure record reference. Presumably
	 * inside the structure indicated by the
	 * pointer in clientData. */
	var iPtr, procPtr uintptr
	_, _ = iPtr, procPtr
	iPtr = interp
	if XTclCreateProc(tls, interp, libc.UintptrFromInt32(0), namePtr, argsObj, bodyObj, procPtrPtr) != TCL_OK {
		return libc.UintptrFromInt32(0)
	}
	procPtr = *(*uintptr)(unsafe.Pointer(procPtrPtr))
	(*TProc)(unsafe.Pointer(procPtr)).FcmdPtr = libc.UintptrFromInt32(0)
	_InitCmdFrame(tls, iPtr, procPtr)
	return XTclNewMethod(tls, clsPtr, nameObj, flags, typePtr, clientData)
}

/*
 * ----------------------------------------------------------------------
 *
 * InvokeProcedureMethod, PushMethodCallFrame --
 *
 *	How to invoke a procedure-like method.
 *
 * ----------------------------------------------------------------------
 */

func _InvokeProcedureMethod(tls *libc.TLS, clientData uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Arguments as actually seen. */
	var _objPtr, cachePtr, fdPtr, pmPtr, v2 uintptr
	var method TTcl_Method
	var result int32
	var v1 TTcl_Size
	var v3 bool
	var _ /* _callbackPtr at bp+8 */ uintptr
	var _ /* isFinished at bp+0 */ int32
	_, _, _, _, _, _, _, _, _ = _objPtr, cachePtr, fdPtr, method, pmPtr, result, v1, v2, v3
	pmPtr = clientData /* Important data that has to have a lifetime
	 * matched by this function (or rather, by the
	 * call frame's lifetime). */
	/*
	 * If the object namespace (or interpreter) were deleted, we just skip to
	 * the next thing in the chain.
	 */
	if XTclOOObjectDestroyed(tls, (*TCallContext)(unsafe.Pointer(context)).FoPtr) != 0 || XTcl_InterpDeleted(tls, interp) != 0 {
		return XTclNRObjectContextInvokeNext(tls, interp, context, int64(objc), objv, XTcl_ObjectContextSkippedArgs(tls, context))
	}
	/*
	 * Finishes filling out the extra frame info so that [info frame] works if
	 * that is not already set up.
	 */
	if (*TProcedureMethod)(unsafe.Pointer(pmPtr)).Fefi.Flength == 0 {
		method = XTcl_ObjectContextMethod(tls, context)
		(*TProcedureMethod)(unsafe.Pointer(pmPtr)).Fefi.Flength = int64(2)
		(*(*TExtraFrameInfoField)(unsafe.Pointer(pmPtr + 208 + 8))).Fname = __ccgo_ts + 28559
		(*(*TExtraFrameInfoField)(unsafe.Pointer(pmPtr + 208 + 8))).Fproc = __ccgo_fp(_RenderMethodName)
		(*(*TExtraFrameInfoField)(unsafe.Pointer(pmPtr + 208 + 8))).FclientData = pmPtr
		(*TProcedureMethod)(unsafe.Pointer(pmPtr)).FcallSiteFlags = (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(context)).FcallPtr)).Fflags & (int32(CONSTRUCTOR) | int32(DESTRUCTOR))
		(*TProcedureMethod)(unsafe.Pointer(pmPtr)).Finterp = interp
		(*TProcedureMethod)(unsafe.Pointer(pmPtr)).Fmethod = method
		if (*TProcedureMethod)(unsafe.Pointer(pmPtr)).FgfivProc != libc.UintptrFromInt32(0) {
			(*(*TExtraFrameInfoField)(unsafe.Pointer(pmPtr + 208 + 8 + 1*24))).Fname = __ccgo_ts + 1945
			(*(*TExtraFrameInfoField)(unsafe.Pointer(pmPtr + 208 + 8 + 1*24))).Fproc = (*TProcedureMethod)(unsafe.Pointer(pmPtr)).FgfivProc
			(*(*TExtraFrameInfoField)(unsafe.Pointer(pmPtr + 208 + 8 + 1*24))).FclientData = pmPtr
		} else {
			if XTcl_MethodDeclarerObject(tls, method) != libc.UintptrFromInt32(0) {
				(*(*TExtraFrameInfoField)(unsafe.Pointer(pmPtr + 208 + 8 + 1*24))).Fname = __ccgo_ts + 6499
			} else {
				(*(*TExtraFrameInfoField)(unsafe.Pointer(pmPtr + 208 + 8 + 1*24))).Fname = __ccgo_ts + 19296
			}
			(*(*TExtraFrameInfoField)(unsafe.Pointer(pmPtr + 208 + 8 + 1*24))).Fproc = __ccgo_fp(_RenderDeclarerName)
			(*(*TExtraFrameInfoField)(unsafe.Pointer(pmPtr + 208 + 8 + 1*24))).FclientData = pmPtr
		}
	}
	/*
	 * Allocate the special frame data.
	 */
	fdPtr = XTclStackAlloc(tls, interp, uint64(24))
	/*
	 * Create a call frame for this method.
	 */
	result = _PushMethodCallFrame(tls, interp, context, pmPtr, objc, objv, fdPtr)
	if result != TCL_OK {
		XTclStackFree(tls, interp, fdPtr)
		return result
	}
	(*TProcedureMethod)(unsafe.Pointer(pmPtr)).FrefCount++
	/*
	 * Give the pre-call callback a chance to do some setup and, possibly,
	 * veto the call.
	 */
	if (*TProcedureMethod)(unsafe.Pointer(pmPtr)).FpreCallProc != libc.UintptrFromInt32(0) {
		result = (*(*func(*libc.TLS, uintptr, uintptr, TTcl_ObjectContext, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TProcedureMethod)(unsafe.Pointer(pmPtr)).FpreCallProc})))(tls, (*TProcedureMethod)(unsafe.Pointer(pmPtr)).FclientData, interp, context, (*TPMFrameData)(unsafe.Pointer(fdPtr)).FframePtr, bp)
		if *(*int32)(unsafe.Pointer(bp)) != 0 || result != TCL_OK {
			XTcl_PopCallFrame(tls, interp)
			XTclStackFree(tls, interp, (*TPMFrameData)(unsafe.Pointer(fdPtr)).FframePtr)
			v2 = pmPtr + 24
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if v1 <= int64(1) {
				_DeleteProcedureMethodRecord(tls, pmPtr)
			}
			XTclStackFree(tls, interp, fdPtr)
			return result
		}
	}
	/*
	 * Now invoke the body of the method.
	 */
	if v3 = interp == libc.UintptrFromInt32(0); !v3 {
		cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
	}
	if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		_objPtr = XTclThreadAllocObj(tls)
	} else {
		_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(_objPtr + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	*(*uintptr)(unsafe.Pointer(bp + 8)) = _objPtr
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FprocPtr = __ccgo_fp(_FinalizePMCall)
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8)) = pmPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 1*8)) = context
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 2*8)) = fdPtr
	*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
	(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
	(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp + 8))
	return XTclNRInterpProcCore(tls, interp, (*TPMFrameData)(unsafe.Pointer(fdPtr)).FnameObj, XTcl_ObjectContextSkippedArgs(tls, context), (*TPMFrameData)(unsafe.Pointer(fdPtr)).FerrProc)
}

func _FinalizePMCall(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	var context TTcl_ObjectContext
	var fdPtr, pmPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _, _ = context, fdPtr, pmPtr, v1, v2
	pmPtr = *(*uintptr)(unsafe.Pointer(data))
	context = *(*uintptr)(unsafe.Pointer(data + 1*8))
	fdPtr = *(*uintptr)(unsafe.Pointer(data + 2*8))
	/*
	 * Give the post-call callback a chance to do some cleanup. Note that at
	 * this point the call frame itself is invalid; it's already been popped.
	 */
	if (*TProcedureMethod)(unsafe.Pointer(pmPtr)).FpostCallProc != 0 {
		result = (*(*func(*libc.TLS, uintptr, uintptr, TTcl_ObjectContext, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{(*TProcedureMethod)(unsafe.Pointer(pmPtr)).FpostCallProc})))(tls, (*TProcedureMethod)(unsafe.Pointer(pmPtr)).FclientData, interp, context, XTcl_GetObjectNamespace(tls, XTcl_ObjectContextObject(tls, context)), result)
	}
	/*
	 * Scrap the special frame data now that we're done with it. Note that we
	 * are inlining DeleteProcedureMethod() here; this location is highly
	 * sensitive when it comes to performance!
	 */
	v2 = pmPtr + 24
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		_DeleteProcedureMethodRecord(tls, pmPtr)
	}
	XTclStackFree(tls, interp, fdPtr)
	return result
}

func _PushMethodCallFrame(tls *libc.TLS, interp uintptr, contextPtr uintptr, pmPtr uintptr, objc int32, objv uintptr, fdPtr uintptr) (r int32) {
	/* Place to store information about the call
	 * frame. */
	var codePtr, framePtrPtr, irPtr, mPtr, nsPtr, v1, v2, v3 uintptr
	var result int32
	_, _, _, _, _, _, _, _, _ = codePtr, framePtrPtr, irPtr, mPtr, nsPtr, result, v1, v2, v3
	nsPtr = (*TObject)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr)).FnamespacePtr
	framePtrPtr = fdPtr
	/*
	 * Compute basic information on the basis of the type of method it is.
	 */
	if (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fflags&int32(CONSTRUCTOR) != 0 {
		(*TPMFrameData)(unsafe.Pointer(fdPtr)).FnameObj = (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr)).FfPtr)).FconstructorName
		(*TPMFrameData)(unsafe.Pointer(fdPtr)).FerrProc = __ccgo_fp(_ConstructorErrorHandler)
	} else {
		if (*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fflags&int32(DESTRUCTOR) != 0 {
			(*TPMFrameData)(unsafe.Pointer(fdPtr)).FnameObj = (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr)).FfPtr)).FdestructorName
			(*TPMFrameData)(unsafe.Pointer(fdPtr)).FerrProc = __ccgo_fp(_DestructorErrorHandler)
		} else {
			(*TPMFrameData)(unsafe.Pointer(fdPtr)).FnameObj = XTcl_MethodName(tls, XTcl_ObjectContextMethod(tls, contextPtr))
			(*TPMFrameData)(unsafe.Pointer(fdPtr)).FerrProc = __ccgo_fp(_MethodErrorHandler)
		}
	}
	if (*TProcedureMethod)(unsafe.Pointer(pmPtr)).FerrProc != libc.UintptrFromInt32(0) {
		(*TPMFrameData)(unsafe.Pointer(fdPtr)).FerrProc = (*TProcedureMethod)(unsafe.Pointer(pmPtr)).FerrProc
	}
	/*
	 * Magic to enable things like [incr Tcl], which wants methods to run in
	 * their class's namespace.
	 */
	if (*TProcedureMethod)(unsafe.Pointer(pmPtr)).Fflags&int32(USE_DECLARER_NS) != 0 {
		mPtr = (*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr((*TCallContext)(unsafe.Pointer(contextPtr)).Findex)*24))).FmPtr
		if (*TMethod)(unsafe.Pointer(mPtr)).FdeclaringClassPtr != libc.UintptrFromInt32(0) {
			nsPtr = (*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer((*TMethod)(unsafe.Pointer(mPtr)).FdeclaringClassPtr)).FthisPtr)).FnamespacePtr
		} else {
			nsPtr = (*TObject)(unsafe.Pointer((*TMethod)(unsafe.Pointer(mPtr)).FdeclaringObjectPtr)).FnamespacePtr
		}
	}
	/*
	 * Compile the body.
	 *
	 * [Bug 2037727] Always call TclProcCompileProc so that we check not only
	 * that we have bytecode, but also that it remains valid. Note that we set
	 * the namespace of the code here directly; this is a hack, but the
	 * alternative is *so* slow...
	 */
	(*TProc)(unsafe.Pointer((*TProcedureMethod)(unsafe.Pointer(pmPtr)).FprocPtr)).FcmdPtr = pmPtr + 88
	if (*TTcl_Obj)(unsafe.Pointer((*TProc)(unsafe.Pointer((*TProcedureMethod)(unsafe.Pointer(pmPtr)).FprocPtr)).FbodyPtr)).FtypePtr == uintptr(unsafe.Pointer(&XtclByteCodeType)) {
		v1 = (*TProc)(unsafe.Pointer((*TProcedureMethod)(unsafe.Pointer(pmPtr)).FprocPtr)).FbodyPtr + 32
	} else {
		v1 = libc.UintptrFromInt32(0)
	}
	irPtr = v1
	if irPtr != 0 {
		v2 = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(irPtr))).Fptr1
	} else {
		v2 = libc.UintptrFromInt32(0)
	}
	codePtr = v2
	if codePtr != 0 {
		(*TByteCode)(unsafe.Pointer(codePtr)).FnsPtr = nsPtr
	}
	if (*TTcl_Obj)(unsafe.Pointer((*TPMFrameData)(unsafe.Pointer(fdPtr)).FnameObj)).Fbytes != 0 {
		v3 = (*TTcl_Obj)(unsafe.Pointer((*TPMFrameData)(unsafe.Pointer(fdPtr)).FnameObj)).Fbytes
	} else {
		v3 = XTcl_GetStringFromObj(tls, (*TPMFrameData)(unsafe.Pointer(fdPtr)).FnameObj, libc.UintptrFromInt32(0))
	}
	result = XTclProcCompileProc(tls, interp, (*TProcedureMethod)(unsafe.Pointer(pmPtr)).FprocPtr, (*TProc)(unsafe.Pointer((*TProcedureMethod)(unsafe.Pointer(pmPtr)).FprocPtr)).FbodyPtr, nsPtr, __ccgo_ts+29000, v3)
	if result != TCL_OK {
		return result
	}
	/*
	 * Make the stack frame and fill it out with information about this call.
	 * This operation doesn't ever actually fail.
	 */
	XTclPushStackFrame(tls, interp, framePtrPtr, nsPtr, libc.Int32FromInt32(FRAME_IS_PROC)|libc.Int32FromInt32(FRAME_IS_METHOD))
	(*TCallFrame)(unsafe.Pointer((*TPMFrameData)(unsafe.Pointer(fdPtr)).FframePtr)).FclientData = contextPtr
	(*TCallFrame)(unsafe.Pointer((*TPMFrameData)(unsafe.Pointer(fdPtr)).FframePtr)).Fobjc = int64(objc)
	(*TCallFrame)(unsafe.Pointer((*TPMFrameData)(unsafe.Pointer(fdPtr)).FframePtr)).Fobjv = objv
	(*TCallFrame)(unsafe.Pointer((*TPMFrameData)(unsafe.Pointer(fdPtr)).FframePtr)).FprocPtr = (*TProcedureMethod)(unsafe.Pointer(pmPtr)).FprocPtr
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOSetupVariableResolver, etc. --
 *
 *	Variable resolution engine used to connect declared variables to local
 *	variables used in methods. The compiled variable resolver is more
 *	important, but both are needed as it is possible to have a variable
 *	that is only referred to in ways that aren't compilable and we can't
 *	force LVT presence. [TIP #320, #500]
 *
 * ----------------------------------------------------------------------
 */

func XTclOOSetupVariableResolver(tls *libc.TLS, nsPtr uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _ /* info at bp+0 */ TTcl_ResolverInfo
	XTcl_GetNamespaceResolvers(tls, nsPtr, bp)
	if (*(*TTcl_ResolverInfo)(unsafe.Pointer(bp))).FcompiledVarResProc == libc.UintptrFromInt32(0) {
		XTcl_SetNamespaceResolvers(tls, nsPtr, libc.UintptrFromInt32(0), __ccgo_fp(_ProcedureMethodVarResolver), __ccgo_fp(_ProcedureMethodCompiledVarResolver))
	}
}

func _ProcedureMethodVarResolver(tls *libc.TLS, interp uintptr, varName uintptr, contextNs uintptr, dummy959 int32, varPtr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var result, v1 int32
	var _ /* rPtr at bp+0 */ uintptr
	_, _ = result, v1
	*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
	result = _ProcedureMethodCompiledVarResolver(tls, interp, varName, libc.Int64FromUint64(libc.Xstrlen(tls, varName)), contextNs, bp)
	if result != TCL_OK {
		return result
	}
	*(*TTcl_Var)(unsafe.Pointer(varPtr)) = (*(*func(*libc.TLS, uintptr, uintptr) TTcl_Var)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ResolvedVarInfo)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FfetchProc})))(tls, interp, *(*uintptr)(unsafe.Pointer(bp)))
	/*
	 * Must not retain reference to resolved information. [Bug 3105999]
	 */
	(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TTcl_ResolvedVarInfo)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FdeleteProc})))(tls, *(*uintptr)(unsafe.Pointer(bp)))
	if *(*TTcl_Var)(unsafe.Pointer(varPtr)) != 0 {
		v1 = TCL_OK
	} else {
		v1 = int32(TCL_CONTINUE)
	}
	return v1
}

func _ProcedureMethodCompiledVarConnect(tls *libc.TLS, interp uintptr, rPtr uintptr) (r TTcl_Var) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var cacheIt int32
	var contextPtr, framePtr, hPtr, iPtr, infoPtr, match, privateVar, varName, variableObj uintptr
	var i TTcl_Size
	var _ /* isNew at bp+0 */ int32
	var _ /* len at bp+16 */ TTcl_Size
	var _ /* varLen at bp+8 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _ = cacheIt, contextPtr, framePtr, hPtr, i, iPtr, infoPtr, match, privateVar, varName, variableObj
	infoPtr = rPtr
	iPtr = interp
	framePtr = (*TInterp)(unsafe.Pointer(iPtr)).FvarFramePtr
	/*
	 * Check that the variable is being requested in a context that is also a
	 * method call; if not (i.e. we're evaluating in the object's namespace or
	 * in a procedure of that namespace) then we do nothing.
	 */
	if framePtr == libc.UintptrFromInt32(0) || !((*TCallFrame)(unsafe.Pointer(framePtr)).FisProcCallFrame&libc.Int32FromInt32(FRAME_IS_METHOD) != 0) {
		return libc.UintptrFromInt32(0)
	}
	contextPtr = (*TCallFrame)(unsafe.Pointer(framePtr)).FclientData
	/*
	 * If we've done the work before (in a comparable context) then reuse that
	 * rather than performing resolution ourselves.
	 */
	if (*TOOResVarInfo)(unsafe.Pointer(infoPtr)).FcachedObjectVar != 0 {
		return (*TOOResVarInfo)(unsafe.Pointer(infoPtr)).FcachedObjectVar
	}
	/*
	 * Check if the variable is one we want to resolve at all (i.e. whether it
	 * is in the list provided by the user). If not, we mustn't do anything
	 * either.
	 */
	varName = XTcl_GetStringFromObj(tls, (*TOOResVarInfo)(unsafe.Pointer(infoPtr)).FvariableObj, bp+8)
	if (*TMethod)(unsafe.Pointer((*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr((*TCallContext)(unsafe.Pointer(contextPtr)).Findex)*24))).FmPtr)).FdeclaringClassPtr != libc.UintptrFromInt32(0) {
		i = 0
		if (*TClass)(unsafe.Pointer((*TMethod)(unsafe.Pointer((*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr((*TCallContext)(unsafe.Pointer(contextPtr)).Findex)*24))).FmPtr)).FdeclaringClassPtr)).FprivateVariables.Fnum > libc.Int64FromInt32(0) {
			for {
				privateVar = (*TClass)(unsafe.Pointer((*TMethod)(unsafe.Pointer((*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr((*TCallContext)(unsafe.Pointer(contextPtr)).Findex)*24))).FmPtr)).FdeclaringClassPtr)).FprivateVariables.Flist + uintptr(i)*16
				if !(i < (*TClass)(unsafe.Pointer((*TMethod)(unsafe.Pointer((*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr((*TCallContext)(unsafe.Pointer(contextPtr)).Findex)*24))).FmPtr)).FdeclaringClassPtr)).FprivateVariables.Fnum) {
					break
				}
				match = XTcl_GetStringFromObj(tls, (*TPrivateVariableMapping)(unsafe.Pointer(privateVar)).FvariableObj, bp+16)
				if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) == *(*TTcl_Size)(unsafe.Pointer(bp + 8)) && !(libc.Xmemcmp(tls, match, varName, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 16)))) != 0) {
					variableObj = (*TPrivateVariableMapping)(unsafe.Pointer(privateVar)).FfullNameObj
					cacheIt = 0
					goto gotMatch
				}
				goto _1
			_1:
				;
				i++
			}
		}
		i = 0
		for {
			if !(i < (*TClass)(unsafe.Pointer((*TMethod)(unsafe.Pointer((*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr((*TCallContext)(unsafe.Pointer(contextPtr)).Findex)*24))).FmPtr)).FdeclaringClassPtr)).Fvariables.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer((*TMethod)(unsafe.Pointer((*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr((*TCallContext)(unsafe.Pointer(contextPtr)).Findex)*24))).FmPtr)).FdeclaringClassPtr)).Fvariables.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _2
			} else {
				variableObj = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer((*TMethod)(unsafe.Pointer((*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr((*TCallContext)(unsafe.Pointer(contextPtr)).Findex)*24))).FmPtr)).FdeclaringClassPtr)).Fvariables.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					match = XTcl_GetStringFromObj(tls, variableObj, bp+16)
					if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) == *(*TTcl_Size)(unsafe.Pointer(bp + 8)) && !(libc.Xmemcmp(tls, match, varName, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 16)))) != 0) {
						cacheIt = 0
						goto gotMatch
					}
				}
			}
			goto _2
		_2:
			;
			i++
		}
	} else {
		i = 0
		if (*TObject)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr)).FprivateVariables.Fnum > libc.Int64FromInt32(0) {
			for {
				privateVar = (*TObject)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr)).FprivateVariables.Flist + uintptr(i)*16
				if !(i < (*TObject)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr)).FprivateVariables.Fnum) {
					break
				}
				match = XTcl_GetStringFromObj(tls, (*TPrivateVariableMapping)(unsafe.Pointer(privateVar)).FvariableObj, bp+16)
				if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) == *(*TTcl_Size)(unsafe.Pointer(bp + 8)) && !(libc.Xmemcmp(tls, match, varName, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 16)))) != 0) {
					variableObj = (*TPrivateVariableMapping)(unsafe.Pointer(privateVar)).FfullNameObj
					cacheIt = int32(1)
					goto gotMatch
				}
				goto _3
			_3:
				;
				i++
			}
		}
		i = 0
		for {
			if !(i < (*TObject)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr)).Fvariables.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr)).Fvariables.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _4
			} else {
				variableObj = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr)).Fvariables.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					match = XTcl_GetStringFromObj(tls, variableObj, bp+16)
					if *(*TTcl_Size)(unsafe.Pointer(bp + 16)) == *(*TTcl_Size)(unsafe.Pointer(bp + 8)) && !(libc.Xmemcmp(tls, match, varName, libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp + 16)))) != 0) {
						cacheIt = int32(1)
						goto gotMatch
					}
				}
			}
			goto _4
		_4:
			;
			i++
		}
	}
	return libc.UintptrFromInt32(0)
	/*
	 * It is a variable we want to resolve, so resolve it.
	 */
	goto gotMatch
gotMatch:
	;
	hPtr = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer((*TObject)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr)).FnamespacePtr + 288)).FcreateProc})))(tls, (*TObject)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr)).FnamespacePtr+288, variableObj, bp)
	if *(*int32)(unsafe.Pointer(bp)) != 0 {
		if !((*TVar)(unsafe.Pointer(hPtr-uintptr(uint64(libc.UintptrFromInt32(0)+24)))).Fflags&libc.Int32FromInt32(VAR_NAMESPACE_VAR) != 0) {
			*(*int32)(unsafe.Pointer(hPtr - uintptr(uint64(libc.UintptrFromInt32(0)+24)))) |= int32(VAR_NAMESPACE_VAR)
			if (*TVar)(unsafe.Pointer(hPtr-uintptr(uint64(libc.UintptrFromInt32(0)+24)))).Fflags&int32(VAR_IN_HASHTABLE) != 0 {
				(*TVarInHash)(unsafe.Pointer(hPtr-uintptr(uint64(libc.UintptrFromInt32(0)+24)))).FrefCount++
			}
		}
	}
	if cacheIt != 0 {
		(*TOOResVarInfo)(unsafe.Pointer(infoPtr)).FcachedObjectVar = hPtr - uintptr(uint64(libc.UintptrFromInt32(0)+24))
		/*
		 * We must keep a reference to the variable so everything will
		 * continue to work correctly even if it is unset; being unset does
		 * not end the life of the variable at this level. [Bug 3185009]
		 */
		(*TVarInHash)(unsafe.Pointer((*TOOResVarInfo)(unsafe.Pointer(infoPtr)).FcachedObjectVar)).FrefCount++
	}
	return hPtr - uintptr(uint64(libc.UintptrFromInt32(0)+24))
}

func _ProcedureMethodCompiledVarDelete(tls *libc.TLS, rPtr uintptr) {
	var _objPtr, infoPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _ = _objPtr, infoPtr, v1, v2
	infoPtr = rPtr
	/*
	 * Release the reference to the variable if we were holding it.
	 */
	if (*TOOResVarInfo)(unsafe.Pointer(infoPtr)).FcachedObjectVar != 0 {
		(*TVarInHash)(unsafe.Pointer((*TOOResVarInfo)(unsafe.Pointer(infoPtr)).FcachedObjectVar)).FrefCount--
		XTclCleanupVar(tls, (*TOOResVarInfo)(unsafe.Pointer(infoPtr)).FcachedObjectVar, libc.UintptrFromInt32(0))
	}
	_objPtr = (*TOOResVarInfo)(unsafe.Pointer(infoPtr)).FvariableObj
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	XTclpFree(tls, infoPtr)
}

func _ProcedureMethodCompiledVarResolver(tls *libc.TLS, dummy1107 uintptr, varName uintptr, length TTcl_Size, dummy1110 uintptr, rPtrPtr uintptr) (r int32) {
	var _objPtr, infoPtr, variableObj, v1, v2, v5 uintptr
	var v3 bool
	var v4 TTcl_Size
	_, _, _, _, _, _, _, _ = _objPtr, infoPtr, variableObj, v1, v2, v3, v4, v5
	variableObj = XTcl_NewStringObj(tls, varName, length)
	/*
	 * Do not create resolvers for cases that contain namespace separators or
	 * which look like array accesses. Both will lead us astray.
	 */
	if (*TTcl_Obj)(unsafe.Pointer(variableObj)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(variableObj)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, variableObj, libc.UintptrFromInt32(0))
	}
	if v3 = libc.Xstrstr(tls, v1, __ccgo_ts+7650) != libc.UintptrFromInt32(0); !v3 {
		if (*TTcl_Obj)(unsafe.Pointer(variableObj)).Fbytes != 0 {
			v2 = (*TTcl_Obj)(unsafe.Pointer(variableObj)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, variableObj, libc.UintptrFromInt32(0))
		}
	}
	if v3 || XTcl_StringCaseMatch(tls, v2, __ccgo_ts+91802, 0) != 0 {
		_objPtr = variableObj
		v5 = _objPtr
		v4 = *(*TTcl_Size)(unsafe.Pointer(v5))
		*(*TTcl_Size)(unsafe.Pointer(v5))--
		if v4 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		return int32(TCL_CONTINUE)
	}
	infoPtr = XTcl_Alloc(tls, uint64(32))
	(*TOOResVarInfo)(unsafe.Pointer(infoPtr)).Finfo.FfetchProc = __ccgo_fp(_ProcedureMethodCompiledVarConnect)
	(*TOOResVarInfo)(unsafe.Pointer(infoPtr)).Finfo.FdeleteProc = __ccgo_fp(_ProcedureMethodCompiledVarDelete)
	(*TOOResVarInfo)(unsafe.Pointer(infoPtr)).FcachedObjectVar = libc.UintptrFromInt32(0)
	(*TOOResVarInfo)(unsafe.Pointer(infoPtr)).FvariableObj = variableObj
	(*TTcl_Obj)(unsafe.Pointer(variableObj)).FrefCount++
	*(*uintptr)(unsafe.Pointer(rPtrPtr)) = infoPtr
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * RenderMethodName --
 *
 *	Returns the name of the declared method. Used for producing information
 *	for [info frame].
 *
 * ----------------------------------------------------------------------
 */

func _RenderMethodName(tls *libc.TLS, clientData uintptr) (r uintptr) {
	var pmPtr uintptr
	_ = pmPtr
	pmPtr = clientData
	if (*TProcedureMethod)(unsafe.Pointer(pmPtr)).FcallSiteFlags&int32(CONSTRUCTOR) != 0 {
		return (*TFoundation)(unsafe.Pointer(XTclOOGetFoundation(tls, (*TProcedureMethod)(unsafe.Pointer(pmPtr)).Finterp))).FconstructorName
	} else {
		if (*TProcedureMethod)(unsafe.Pointer(pmPtr)).FcallSiteFlags&int32(DESTRUCTOR) != 0 {
			return (*TFoundation)(unsafe.Pointer(XTclOOGetFoundation(tls, (*TProcedureMethod)(unsafe.Pointer(pmPtr)).Finterp))).FdestructorName
		} else {
			return XTcl_MethodName(tls, (*TProcedureMethod)(unsafe.Pointer(pmPtr)).Fmethod)
		}
	}
	return r
}

/*
 * ----------------------------------------------------------------------
 *
 * RenderDeclarerName --
 *
 *	Returns the name of the entity (object or class) which declared a
 *	method. Used for producing information for [info frame] in such a way
 *	that the expensive part of this (generating the object or class name
 *	itself) isn't done until it is needed.
 *
 * ----------------------------------------------------------------------
 */

func _RenderDeclarerName(tls *libc.TLS, clientData uintptr) (r uintptr) {
	var object TTcl_Object
	var pmPtr uintptr
	_, _ = object, pmPtr
	pmPtr = clientData
	object = XTcl_MethodDeclarerObject(tls, (*TProcedureMethod)(unsafe.Pointer(pmPtr)).Fmethod)
	if object == libc.UintptrFromInt32(0) {
		object = XTcl_GetClassAsObject(tls, XTcl_MethodDeclarerClass(tls, (*TProcedureMethod)(unsafe.Pointer(pmPtr)).Fmethod))
	}
	return XTclOOObjectName(tls, (*TProcedureMethod)(unsafe.Pointer(pmPtr)).Finterp, object)
}

/*
 * ----------------------------------------------------------------------
 *
 * MethodErrorHandler, ConstructorErrorHandler, DestructorErrorHandler --
 *
 *	How to fill in the stack trace correctly upon error in various forms
 *	of procedure-like methods. LIMIT is how long the inserted strings in
 *	the error traces should get before being converted to have ellipses,
 *	and ELLIPSIFY is a macro to do the conversion (with the help of a
 *	%.*s%s format field). Note that ELLIPSIFY is only safe for use in
 *	suitable formatting contexts.
 *
 * ----------------------------------------------------------------------
 */

// TODO: Check whether Tcl_AppendLimitedToObj() can work here.

func _CommonMethErrorHandler(tls *libc.TLS, interp uintptr, special uintptr) {
	bp := tls.Alloc(96)
	defer tls.Free(96)
	var contextPtr, declarerPtr, kindName, mPtr, methodName, objectName, v1, v2, v4, v6, v8 uintptr
	var v3, v5, v7 int32
	var _ /* nameLen at bp+8 */ TTcl_Size
	var _ /* objectNameLen at bp+0 */ TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = contextPtr, declarerPtr, kindName, mPtr, methodName, objectName, v1, v2, v3, v4, v5, v6, v7, v8
	contextPtr = (*TCallFrame)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FvarFramePtr)).FclientData
	mPtr = (*(*TMInvoke)(unsafe.Pointer((*TCallChain)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FcallPtr)).Fchain + uintptr((*TCallContext)(unsafe.Pointer(contextPtr)).Findex)*24))).FmPtr
	kindName = __ccgo_ts + 92769
	declarerPtr = libc.UintptrFromInt32(0)
	if (*TMethod)(unsafe.Pointer(mPtr)).FdeclaringObjectPtr != libc.UintptrFromInt32(0) {
		declarerPtr = (*TMethod)(unsafe.Pointer(mPtr)).FdeclaringObjectPtr
		kindName = __ccgo_ts + 6499
	} else {
		if (*TMethod)(unsafe.Pointer(mPtr)).FdeclaringClassPtr != libc.UintptrFromInt32(0) {
			declarerPtr = (*TClass)(unsafe.Pointer((*TMethod)(unsafe.Pointer(mPtr)).FdeclaringClassPtr)).FthisPtr
			kindName = __ccgo_ts + 19296
		}
	}
	if declarerPtr != 0 {
		if (*TTcl_Obj)(unsafe.Pointer(XTclOOObjectName(tls, interp, declarerPtr))).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp)) = (*TTcl_Obj)(unsafe.Pointer(XTclOOObjectName(tls, interp, declarerPtr))).Flength
			v1 = (*TTcl_Obj)(unsafe.Pointer(XTclOOObjectName(tls, interp, declarerPtr))).Fbytes
		} else {
			v1 = XTcl_GetStringFromObj(tls, XTclOOObjectName(tls, interp, declarerPtr), bp)
		}
		objectName = v1
	} else {
		objectName = __ccgo_ts + 92778
		*(*TTcl_Size)(unsafe.Pointer(bp)) = int64(18)
	}
	if !(special != 0) {
		if (*TTcl_Obj)(unsafe.Pointer((*TMethod)(unsafe.Pointer(mPtr)).FnamePtr)).Fbytes != 0 {
			*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = (*TTcl_Obj)(unsafe.Pointer((*TMethod)(unsafe.Pointer(mPtr)).FnamePtr)).Flength
			v2 = (*TTcl_Obj)(unsafe.Pointer((*TMethod)(unsafe.Pointer(mPtr)).FnamePtr)).Fbytes
		} else {
			v2 = XTcl_GetStringFromObj(tls, (*TMethod)(unsafe.Pointer(mPtr)).FnamePtr, bp+8)
		}
		methodName = v2
		if *(*TTcl_Size)(unsafe.Pointer(bp)) > int64(LIMIT) {
			v3 = int32(LIMIT)
		} else {
			v3 = int32(*(*TTcl_Size)(unsafe.Pointer(bp)))
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp)) > int64(LIMIT) {
			v4 = __ccgo_ts + 8560
		} else {
			v4 = __ccgo_ts + 1945
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > int64(LIMIT) {
			v5 = int32(LIMIT)
		} else {
			v5 = int32(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp + 8)) > int64(LIMIT) {
			v6 = __ccgo_ts + 8560
		} else {
			v6 = __ccgo_ts + 1945
		}
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+92797, libc.VaList(bp+24, kindName, v3, objectName, v4, v5, methodName, v6, XTcl_GetErrorLine(tls, interp))))
	} else {
		if *(*TTcl_Size)(unsafe.Pointer(bp)) > int64(LIMIT) {
			v7 = int32(LIMIT)
		} else {
			v7 = int32(*(*TTcl_Size)(unsafe.Pointer(bp)))
		}
		if *(*TTcl_Size)(unsafe.Pointer(bp)) > int64(LIMIT) {
			v8 = __ccgo_ts + 8560
		} else {
			v8 = __ccgo_ts + 1945
		}
		XTcl_AppendObjToErrorInfo(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+92840, libc.VaList(bp+24, kindName, v7, objectName, v8, special, XTcl_GetErrorLine(tls, interp))))
	}
}

func _MethodErrorHandler(tls *libc.TLS, interp uintptr, dummy1257 uintptr) {
	/* We pull the method name out of context instead of from argument */
	_CommonMethErrorHandler(tls, interp, libc.UintptrFromInt32(0))
}

func _ConstructorErrorHandler(tls *libc.TLS, interp uintptr, dummy1266 uintptr) {
	/* Ignore. We know it is the constructor. */
	_CommonMethErrorHandler(tls, interp, __ccgo_ts+28529)
}

func _DestructorErrorHandler(tls *libc.TLS, interp uintptr, dummy1296 uintptr) {
	/* Ignore. We know it is the destructor. */
	_CommonMethErrorHandler(tls, interp, __ccgo_ts+28541)
}

/*
 * ----------------------------------------------------------------------
 *
 * DeleteProcedureMethod, CloneProcedureMethod --
 *
 *	How to delete and clone procedure-like methods.
 *
 * ----------------------------------------------------------------------
 */

func _DeleteProcedureMethodRecord(tls *libc.TLS, pmPtr uintptr) {
	XTclProcDeleteProc(tls, (*TProcedureMethod)(unsafe.Pointer(pmPtr)).FprocPtr)
	if (*TProcedureMethod)(unsafe.Pointer(pmPtr)).FdeleteClientdataProc != 0 {
		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TProcedureMethod)(unsafe.Pointer(pmPtr)).FdeleteClientdataProc})))(tls, (*TProcedureMethod)(unsafe.Pointer(pmPtr)).FclientData)
	}
	XTclpFree(tls, pmPtr)
}

func _DeleteProcedureMethod(tls *libc.TLS, clientData uintptr) {
	var pmPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _ = pmPtr, v1, v2
	pmPtr = clientData
	v2 = pmPtr + 24
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		_DeleteProcedureMethodRecord(tls, pmPtr)
	}
}

func _CloneProcedureMethod(tls *libc.TLS, interp uintptr, clientData uintptr, newClientData uintptr) (r int32) {
	var _objPtr, _objPtr1, _objPtr2, _objPtr3, argObj, argsObj, bodyObj, cachePtr, cachePtr1, localPtr, pm2Ptr, pmPtr, v10, v12, v6, v8 uintptr
	var v1, v3 bool
	var v11, v5, v7, v9 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, _objPtr3, argObj, argsObj, bodyObj, cachePtr, cachePtr1, localPtr, pm2Ptr, pmPtr, v1, v10, v11, v12, v3, v5, v6, v7, v8, v9
	pmPtr = clientData
	/*
	 * Copy the argument list.
	 */
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		argsObj = XTclThreadAllocObj(tls)
	} else {
		argsObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(argsObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(argsObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(argsObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(argsObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(argsObj)).FtypePtr = libc.UintptrFromInt32(0)
	localPtr = (*TProc)(unsafe.Pointer((*TProcedureMethod)(unsafe.Pointer(pmPtr)).FprocPtr)).FfirstLocalPtr
	for {
		if !(localPtr != libc.UintptrFromInt32(0)) {
			break
		}
		if (*TCompiledLocal)(unsafe.Pointer(localPtr)).Fflags&int32(VAR_ARGUMENT) != 0 {
			if v3 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v3 {
				cachePtr1 = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v3 || (*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects == libc.Uint64FromInt32(0) {
				argObj = XTclThreadAllocObj(tls)
			} else {
				argObj = (*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(argObj + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr1)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(argObj)).FrefCount = 0
			(*TTcl_Obj)(unsafe.Pointer(argObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
			(*TTcl_Obj)(unsafe.Pointer(argObj)).Flength = 0
			(*TTcl_Obj)(unsafe.Pointer(argObj)).FtypePtr = libc.UintptrFromInt32(0)
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), argObj, XTcl_NewStringObj(tls, localPtr+44, int64(-libc.Int32FromInt32(1))))
			if (*TCompiledLocal)(unsafe.Pointer(localPtr)).FdefValuePtr != libc.UintptrFromInt32(0) {
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), argObj, (*TCompiledLocal)(unsafe.Pointer(localPtr)).FdefValuePtr)
			}
			XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), argsObj, argObj)
		}
		goto _2
	_2:
		;
		localPtr = (*TCompiledLocal)(unsafe.Pointer(localPtr)).FnextPtr
	}
	/*
	 * Must strip the internal representation in order to ensure that any
	 * bound references to instance variables are removed. [Bug 3609693]
	 */
	bodyObj = XTcl_DuplicateObj(tls, (*TProc)(unsafe.Pointer((*TProcedureMethod)(unsafe.Pointer(pmPtr)).FprocPtr)).FbodyPtr)
	if (*TTcl_Obj)(unsafe.Pointer(bodyObj)).Fbytes != 0 {
		_ = (*TTcl_Obj)(unsafe.Pointer(bodyObj)).Fbytes
	} else {
		XTcl_GetStringFromObj(tls, bodyObj, libc.UintptrFromInt32(0))
	}
	XTcl_StoreInternalRep(tls, (*TProc)(unsafe.Pointer((*TProcedureMethod)(unsafe.Pointer(pmPtr)).FprocPtr)).FbodyPtr, uintptr(unsafe.Pointer(&XtclByteCodeType)), libc.UintptrFromInt32(0))
	/*
	 * Create the actual copy of the method record, manufacturing a new proc
	 * record.
	 */
	pm2Ptr = XTcl_Alloc(tls, uint64(288))
	libc.Xmemcpy(tls, pm2Ptr, pmPtr, uint64(288))
	(*TProcedureMethod)(unsafe.Pointer(pm2Ptr)).FrefCount = int64(1)
	(*TProcedureMethod)(unsafe.Pointer(pm2Ptr)).Fcmd.FclientData = pm2Ptr + 208
	(*TProcedureMethod)(unsafe.Pointer(pm2Ptr)).Fefi.Flength = 0 /* Trigger a reinit of this. */
	(*TTcl_Obj)(unsafe.Pointer(argsObj)).FrefCount++
	(*TTcl_Obj)(unsafe.Pointer(bodyObj)).FrefCount++
	if XTclCreateProc(tls, interp, libc.UintptrFromInt32(0), __ccgo_ts+1945, argsObj, bodyObj, pm2Ptr+8) != TCL_OK {
		_objPtr = argsObj
		v6 = _objPtr
		v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
		*(*TTcl_Size)(unsafe.Pointer(v6))--
		if v5 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		_objPtr1 = bodyObj
		v8 = _objPtr1
		v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
		*(*TTcl_Size)(unsafe.Pointer(v8))--
		if v7 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		XTclpFree(tls, pm2Ptr)
		return int32(TCL_ERROR)
	}
	_objPtr2 = argsObj
	v10 = _objPtr2
	v9 = *(*TTcl_Size)(unsafe.Pointer(v10))
	*(*TTcl_Size)(unsafe.Pointer(v10))--
	if v9 <= int64(1) {
		XTclFreeObj(tls, _objPtr2)
	}
	_objPtr3 = bodyObj
	v12 = _objPtr3
	v11 = *(*TTcl_Size)(unsafe.Pointer(v12))
	*(*TTcl_Size)(unsafe.Pointer(v12))--
	if v11 <= int64(1) {
		XTclFreeObj(tls, _objPtr3)
	}
	if (*TProcedureMethod)(unsafe.Pointer(pmPtr)).FcloneClientdataProc != 0 {
		(*TProcedureMethod)(unsafe.Pointer(pm2Ptr)).FclientData = (*(*func(*libc.TLS, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TProcedureMethod)(unsafe.Pointer(pmPtr)).FcloneClientdataProc})))(tls, (*TProcedureMethod)(unsafe.Pointer(pmPtr)).FclientData)
	}
	*(*uintptr)(unsafe.Pointer(newClientData)) = pm2Ptr
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOONewForwardInstanceMethod --
 *
 *	Create a forwarded method for an object.
 *
 * ----------------------------------------------------------------------
 */

func XTclOONewForwardInstanceMethod(tls *libc.TLS, interp uintptr, oPtr uintptr, flags int32, nameObj uintptr, prefixObj uintptr) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* List of arguments that form the command
	 * prefix to forward to. */
	var fmPtr uintptr
	var v1 int32
	var v2 int64
	var _ /* prefixLen at bp+0 */ TTcl_Size
	_, _, _ = fmPtr, v1, v2
	if (*TTcl_Obj)(unsafe.Pointer(prefixObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(prefixObj + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(prefixObj + 32))).Fptr2)).FspanLength
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(prefixObj + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v2
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjLength(tls, interp, prefixObj, bp)
	}
	if v1 != TCL_OK {
		return libc.UintptrFromInt32(0)
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp)) < int64(1) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+92870, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+92910, libc.UintptrFromInt32(0)))
		return libc.UintptrFromInt32(0)
	}
	fmPtr = XTcl_Alloc(tls, uint64(8))
	(*TForwardMethod)(unsafe.Pointer(fmPtr)).FprefixObj = prefixObj
	(*TTcl_Obj)(unsafe.Pointer(prefixObj)).FrefCount++
	return XTclNewInstanceMethod(tls, interp, oPtr, nameObj, flags, uintptr(unsafe.Pointer(&_fwdMethodType)), fmPtr)
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOONewForwardMethod --
 *
 *	Create a new forwarded method for a class.
 *
 * ----------------------------------------------------------------------
 */

func XTclOONewForwardMethod(tls *libc.TLS, interp uintptr, clsPtr uintptr, flags int32, nameObj uintptr, prefixObj uintptr) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* List of arguments that form the command
	 * prefix to forward to. */
	var fmPtr uintptr
	var v1 int32
	var v2 int64
	var _ /* prefixLen at bp+0 */ TTcl_Size
	_, _, _ = fmPtr, v1, v2
	if (*TTcl_Obj)(unsafe.Pointer(prefixObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(prefixObj + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(prefixObj + 32))).Fptr2)).FspanLength
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(prefixObj + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp)) = v2
		v1 = libc.Int32FromInt32(TCL_OK)
	} else {
		v1 = XTcl_ListObjLength(tls, interp, prefixObj, bp)
	}
	if v1 != TCL_OK {
		return libc.UintptrFromInt32(0)
	}
	if *(*TTcl_Size)(unsafe.Pointer(bp)) < int64(1) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+92870, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+16, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+92910, libc.UintptrFromInt32(0)))
		return libc.UintptrFromInt32(0)
	}
	fmPtr = XTcl_Alloc(tls, uint64(8))
	(*TForwardMethod)(unsafe.Pointer(fmPtr)).FprefixObj = prefixObj
	(*TTcl_Obj)(unsafe.Pointer(prefixObj)).FrefCount++
	return XTclNewMethod(tls, clsPtr, nameObj, flags, uintptr(unsafe.Pointer(&_fwdMethodType)), fmPtr)
}

/*
 * ----------------------------------------------------------------------
 *
 * InvokeForwardMethod --
 *
 *	How to invoke a forwarded method. Works by doing some ensemble-like
 *	command rearranging and then invokes some other Tcl command.
 *
 * ----------------------------------------------------------------------
 */

func _InvokeForwardMethod(tls *libc.TLS, clientData uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32) /* Arguments as actually seen. */
	var argObjs, contextPtr, fmPtr uintptr
	var skip TTcl_Size
	var v2, v3 int64
	var _ /* len at bp+16 */ int32
	var _ /* numPrefixes at bp+8 */ TTcl_Size
	var _ /* prefixObjs at bp+0 */ uintptr
	_, _, _, _, _, _ = argObjs, contextPtr, fmPtr, skip, v2, v3
	contextPtr = context
	fmPtr = clientData
	skip = (*TCallContext)(unsafe.Pointer(contextPtr)).Fskip
	/*
	 * Build the real list of arguments to use. Note that we know that the
	 * prefixObj field of the ForwardMethod structure holds a reference to a
	 * non-empty list, so there's a whole class of failures ("not a list") we
	 * can ignore here.
	 */
	if (*TTcl_Obj)(unsafe.Pointer((*TForwardMethod)(unsafe.Pointer(fmPtr)).FprefixObj)).FtypePtr == uintptr(unsafe.Pointer(&XtclListType)) {
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*TForwardMethod)(unsafe.Pointer(fmPtr)).FprefixObj + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer((*TForwardMethod)(unsafe.Pointer(fmPtr)).FprefixObj + 32))).Fptr2)).FspanStart
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer((*TForwardMethod)(unsafe.Pointer(fmPtr)).FprefixObj + 32))).Fptr1)).FfirstUsed
		}
		*(*uintptr)(unsafe.Pointer(bp)) = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*TForwardMethod)(unsafe.Pointer(fmPtr)).FprefixObj + 32))).Fptr1 + 40 + uintptr(v2)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer((*TForwardMethod)(unsafe.Pointer(fmPtr)).FprefixObj + 32))).Fptr2 != 0 {
			v3 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer((*TForwardMethod)(unsafe.Pointer(fmPtr)).FprefixObj + 32))).Fptr2)).FspanLength
		} else {
			v3 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer((*TForwardMethod)(unsafe.Pointer(fmPtr)).FprefixObj + 32))).Fptr1)).FnumUsed
		}
		*(*TTcl_Size)(unsafe.Pointer(bp + 8)) = v3
		_ = libc.Int32FromInt32(TCL_OK)
	} else {
		XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), (*TForwardMethod)(unsafe.Pointer(fmPtr)).FprefixObj, bp+8, bp)
	}
	argObjs = _InitEnsembleRewrite(tls, interp, objc, objv, int32(skip), int32(*(*TTcl_Size)(unsafe.Pointer(bp + 8))), *(*uintptr)(unsafe.Pointer(bp)), bp+16)
	XTcl_NRAddCallback(tls, interp, __ccgo_fp(_FinalizeForwardCall), argObjs, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
	/*
	 * NOTE: The combination of direct set of iPtr->lookupNsPtr and the use
	 * of the TCL_EVAL_NOERR flag results in an evaluation configuration
	 * very much like TCL_EVAL_INVOKE.
	 */
	(*TInterp)(unsafe.Pointer(interp)).FlookupNsPtr = (*TObject)(unsafe.Pointer((*TCallContext)(unsafe.Pointer(contextPtr)).FoPtr)).FnamespacePtr
	return XTclNREvalObjv(tls, interp, int64(*(*int32)(unsafe.Pointer(bp + 16))), argObjs, int32(TCL_EVAL_NOERR), libc.UintptrFromInt32(0))
}

func _FinalizeForwardCall(tls *libc.TLS, data uintptr, interp uintptr, result int32) (r int32) {
	var argObjs uintptr
	_ = argObjs
	argObjs = *(*uintptr)(unsafe.Pointer(data))
	XTclStackFree(tls, interp, argObjs)
	return result
}

/*
 * ----------------------------------------------------------------------
 *
 * DeleteForwardMethod, CloneForwardMethod --
 *
 *	How to delete and clone forwarded methods.
 *
 * ----------------------------------------------------------------------
 */

func _DeleteForwardMethod(tls *libc.TLS, clientData uintptr) {
	var _objPtr, fmPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _ = _objPtr, fmPtr, v1, v2
	fmPtr = clientData
	_objPtr = (*TForwardMethod)(unsafe.Pointer(fmPtr)).FprefixObj
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	XTclpFree(tls, fmPtr)
}

func _CloneForwardMethod(tls *libc.TLS, dummy1582 uintptr, clientData uintptr, newClientData uintptr) (r int32) {
	var fm2Ptr, fmPtr uintptr
	_, _ = fm2Ptr, fmPtr
	fmPtr = clientData
	fm2Ptr = XTcl_Alloc(tls, uint64(8))
	(*TForwardMethod)(unsafe.Pointer(fm2Ptr)).FprefixObj = (*TForwardMethod)(unsafe.Pointer(fmPtr)).FprefixObj
	(*TTcl_Obj)(unsafe.Pointer((*TForwardMethod)(unsafe.Pointer(fm2Ptr)).FprefixObj)).FrefCount++
	*(*uintptr)(unsafe.Pointer(newClientData)) = fm2Ptr
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOGetProcFromMethod, TclOOGetFwdFromMethod --
 *
 *	Utility functions used for procedure-like and forwarding method
 *	introspection.
 *
 * ----------------------------------------------------------------------
 */

func XTclOOGetProcFromMethod(tls *libc.TLS, mPtr uintptr) (r uintptr) {
	var pmPtr uintptr
	_ = pmPtr
	if (*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr == uintptr(unsafe.Pointer(&_procMethodType)) {
		pmPtr = (*TMethod)(unsafe.Pointer(mPtr)).FclientData
		return (*TProcedureMethod)(unsafe.Pointer(pmPtr)).FprocPtr
	}
	return libc.UintptrFromInt32(0)
}

func XTclOOGetMethodBody(tls *libc.TLS, mPtr uintptr) (r uintptr) {
	var pmPtr uintptr
	_ = pmPtr
	if (*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr == uintptr(unsafe.Pointer(&_procMethodType)) {
		pmPtr = (*TMethod)(unsafe.Pointer(mPtr)).FclientData
		if (*TTcl_Obj)(unsafe.Pointer((*TProc)(unsafe.Pointer((*TProcedureMethod)(unsafe.Pointer(pmPtr)).FprocPtr)).FbodyPtr)).Fbytes != 0 {
			_ = (*TTcl_Obj)(unsafe.Pointer((*TProc)(unsafe.Pointer((*TProcedureMethod)(unsafe.Pointer(pmPtr)).FprocPtr)).FbodyPtr)).Fbytes
		} else {
			XTcl_GetStringFromObj(tls, (*TProc)(unsafe.Pointer((*TProcedureMethod)(unsafe.Pointer(pmPtr)).FprocPtr)).FbodyPtr, libc.UintptrFromInt32(0))
		}
		return (*TProc)(unsafe.Pointer((*TProcedureMethod)(unsafe.Pointer(pmPtr)).FprocPtr)).FbodyPtr
	}
	return libc.UintptrFromInt32(0)
}

func XTclOOGetFwdFromMethod(tls *libc.TLS, mPtr uintptr) (r uintptr) {
	var fwPtr uintptr
	_ = fwPtr
	if (*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr == uintptr(unsafe.Pointer(&_fwdMethodType)) {
		fwPtr = (*TMethod)(unsafe.Pointer(mPtr)).FclientData
		return (*TForwardMethod)(unsafe.Pointer(fwPtr)).FprefixObj
	}
	return libc.UintptrFromInt32(0)
}

/*
 * ----------------------------------------------------------------------
 *
 * InitEnsembleRewrite --
 *
 *	Utility function that wraps up a lot of the complexity involved in
 *	doing ensemble-like command forwarding. Here is a picture of memory
 *	management plan:
 *
 *                    <-----------------objc---------------------->
 *      objv:        |=============|===============================|
 *                    <-toRewrite->           |
 *                                              *                    <-rewriteLength->          *      rewriteObjs: |=================|          *                           |                    |
 *                           V                    V
 *      argObjs:     |=================|===============================|
 *                    <------------------*lengthPtr------------------->
 *
 * ----------------------------------------------------------------------
 */

func _InitEnsembleRewrite(tls *libc.TLS, interp uintptr, objc int32, objv uintptr, toRewrite int32, rewriteLength int32, rewriteObjs uintptr, lengthPtr uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Where to write the resulting length of the
	 * array of rewritten arguments. */
	var _objPtr, argObjs, cachePtr uintptr
	var len1 Tsize_t
	var v1 bool
	var _ /* _callbackPtr at bp+0 */ uintptr
	_, _, _, _, _ = _objPtr, argObjs, cachePtr, len1, v1
	len1 = libc.Uint64FromInt32(rewriteLength + objc - toRewrite)
	argObjs = XTclStackAlloc(tls, interp, uint64(8)*len1)
	libc.Xmemcpy(tls, argObjs, rewriteObjs, libc.Uint64FromInt32(rewriteLength)*uint64(8))
	libc.Xmemcpy(tls, argObjs+uintptr(rewriteLength)*8, objv+uintptr(toRewrite)*8, uint64(8)*libc.Uint64FromInt32(objc-toRewrite))
	/*
	 * Now plumb this into the core ensemble rewrite logging system so that
	 * Tcl_WrongNumArgs() can rewrite its result appropriately. The rules for
	 * how to store the rewrite rules get complex solely because of the case
	 * where an ensemble rewrites itself out of the picture; when that
	 * happens, the quality of the error message rewrite falls drastically
	 * (and unavoidably).
	 */
	if XTclInitRewriteEnsemble(tls, interp, int64(toRewrite), int64(rewriteLength), objv) != 0 {
		if v1 = interp == libc.UintptrFromInt32(0); !v1 {
			cachePtr = (*TInterp)(unsafe.Pointer(interp)).FallocCache
		}
		if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
			_objPtr = XTclThreadAllocObj(tls)
		} else {
			_objPtr = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(_objPtr + 32))).Fptr1
			(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
		}
		*(*uintptr)(unsafe.Pointer(bp)) = _objPtr
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FprocPtr = __ccgo_fp(XTclClearRootEnsemble)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 1*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 2*8)) = libc.UintptrFromInt32(0)
		*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 8 + 3*8)) = libc.UintptrFromInt32(0)
		(*TNRE_callback)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FnextPtr = (*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr
		(*TExecEnv1)(unsafe.Pointer((*TInterp)(unsafe.Pointer(interp)).FexecEnvPtr)).FcallbackPtr = *(*uintptr)(unsafe.Pointer(bp))
	}
	*(*int32)(unsafe.Pointer(lengthPtr)) = libc.Int32FromUint64(len1)
	return argObjs
}

/*
 * ----------------------------------------------------------------------
 *
 * assorted trivial 'getter' functions
 *
 * ----------------------------------------------------------------------
 */

func XTcl_MethodDeclarerObject(tls *libc.TLS, method TTcl_Method) (r TTcl_Object) {
	return (*TMethod)(unsafe.Pointer(method)).FdeclaringObjectPtr
}

func XTcl_MethodDeclarerClass(tls *libc.TLS, method TTcl_Method) (r TTcl_Class) {
	return (*TMethod)(unsafe.Pointer(method)).FdeclaringClassPtr
}

func XTcl_MethodName(tls *libc.TLS, method TTcl_Method) (r uintptr) {
	return (*TMethod)(unsafe.Pointer(method)).FnamePtr
}

func XTclMethodIsType(tls *libc.TLS, method TTcl_Method, typePtr uintptr, clientDataPtr uintptr) (r int32) {
	var mPtr uintptr
	_ = mPtr
	mPtr = method
	if (*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr == typePtr {
		if clientDataPtr != libc.UintptrFromInt32(0) {
			*(*uintptr)(unsafe.Pointer(clientDataPtr)) = (*TMethod)(unsafe.Pointer(mPtr)).FclientData
		}
		return int32(1)
	}
	return 0
}

func XTcl_MethodIsType(tls *libc.TLS, method TTcl_Method, typePtr uintptr, clientDataPtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var mPtr uintptr
	_ = mPtr
	mPtr = method
	if (*TTcl_MethodType)(unsafe.Pointer(typePtr)).Fversion > int32(TCL_OO_METHOD_VERSION_1) {
		XTcl_Panic(tls, __ccgo_ts+92595, libc.VaList(bp+8, __ccgo_ts+92922, __ccgo_ts+92669))
	}
	if (*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr == typePtr {
		if clientDataPtr != libc.UintptrFromInt32(0) {
			*(*uintptr)(unsafe.Pointer(clientDataPtr)) = (*TMethod)(unsafe.Pointer(mPtr)).FclientData
		}
		return int32(1)
	}
	return 0
}

func XTcl_MethodIsType2(tls *libc.TLS, method TTcl_Method, typePtr uintptr, clientDataPtr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var mPtr uintptr
	_ = mPtr
	mPtr = method
	if (*TTcl_MethodType2)(unsafe.Pointer(typePtr)).Fversion < int32(TCL_OO_METHOD_VERSION_2) {
		XTcl_Panic(tls, __ccgo_ts+92595, libc.VaList(bp+8, __ccgo_ts+92939, __ccgo_ts+92716))
	}
	if (*TMethod)(unsafe.Pointer(mPtr)).F__ccgo0_0.FtypePtr == typePtr {
		if clientDataPtr != libc.UintptrFromInt32(0) {
			*(*uintptr)(unsafe.Pointer(clientDataPtr)) = (*TMethod)(unsafe.Pointer(mPtr)).FclientData
		}
		return int32(1)
	}
	return 0
}

func XTcl_MethodIsPublic(tls *libc.TLS, method TTcl_Method) (r int32) {
	var v1 int32
	_ = v1
	if (*TMethod)(unsafe.Pointer(method)).Fflags&int32(PUBLIC_METHOD) != 0 {
		v1 = int32(1)
	} else {
		v1 = 0
	}
	return v1
}

func XTcl_MethodIsPrivate(tls *libc.TLS, method TTcl_Method) (r int32) {
	var v1 int32
	_ = v1
	if (*TMethod)(unsafe.Pointer(method)).Fflags&int32(TRUE_PRIVATE_METHOD) != 0 {
		v1 = int32(1)
	} else {
		v1 = 0
	}
	return v1
}

/*
 * Extended method construction for itcl-ng.
 */

func XTclOONewProcInstanceMethodEx(tls *libc.TLS, interp uintptr, oPtr TTcl_Object, preCallPtr uintptr, postCallPtr uintptr, errProc uintptr, clientData uintptr, nameObj uintptr, argsObj uintptr, bodyObj uintptr, flags int32, internalTokenPtr uintptr) (r TTcl_Method) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* If non-NULL, points to a variable that gets
	 * the reference to the ProcedureMethod
	 * structure. */
	var method TTcl_Method
	var _ /* pmPtr at bp+0 */ uintptr
	_ = method
	method = XTclOONewProcInstanceMethod(tls, interp, oPtr, flags, nameObj, argsObj, bodyObj, bp)
	if method == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	(*TProcedureMethod)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fflags = flags & int32(USE_DECLARER_NS)
	(*TProcedureMethod)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FpreCallProc = preCallPtr
	(*TProcedureMethod)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FpostCallProc = postCallPtr
	(*TProcedureMethod)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FerrProc = errProc
	(*TProcedureMethod)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FclientData = clientData
	if internalTokenPtr != libc.UintptrFromInt32(0) {
		*(*uintptr)(unsafe.Pointer(internalTokenPtr)) = *(*uintptr)(unsafe.Pointer(bp))
	}
	return method
}

func XTclOONewProcMethodEx(tls *libc.TLS, interp uintptr, clsPtr TTcl_Class, preCallPtr uintptr, postCallPtr uintptr, errProc uintptr, clientData uintptr, nameObj uintptr, argsObj uintptr, bodyObj uintptr, flags int32, internalTokenPtr uintptr) (r TTcl_Method) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* If non-NULL, points to a variable that gets
	 * the reference to the ProcedureMethod
	 * structure. */
	var method TTcl_Method
	var _ /* pmPtr at bp+0 */ uintptr
	_ = method
	method = XTclOONewProcMethod(tls, interp, clsPtr, flags, nameObj, argsObj, bodyObj, bp)
	if method == libc.UintptrFromInt32(0) {
		return libc.UintptrFromInt32(0)
	}
	(*TProcedureMethod)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).Fflags = flags & int32(USE_DECLARER_NS)
	(*TProcedureMethod)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FpreCallProc = preCallPtr
	(*TProcedureMethod)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FpostCallProc = postCallPtr
	(*TProcedureMethod)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FerrProc = errProc
	(*TProcedureMethod)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))).FclientData = clientData
	if internalTokenPtr != libc.UintptrFromInt32(0) {
		*(*uintptr)(unsafe.Pointer(internalTokenPtr)) = *(*uintptr)(unsafe.Pointer(bp))
	}
	return method
}

type TCmdFrame1 = struct {
	Ftype1    int32
	Flevel    int32
	Fline     uintptr
	Fnline    int64
	FframePtr uintptr
	FnextPtr  uintptr
	Fdata     struct {
		Ftebc [0]struct {
			FcodePtr uintptr
			Fpc      uintptr
		}
		Feval struct {
			Fpath uintptr
		}
		F__ccgo_pad2 [8]byte
	}
	FcmdObj uintptr
	Fcmd    uintptr
	Flen1   int64
	Flitarg uintptr
}

const TCL_OO_METHOD_VERSION_CURRENT6 = 0

/* !END!: Do not edit above this line. */

/*
 * Alternatives to Tcl_Preserve/Tcl_EventuallyFree/Tcl_Release.
 */

/*
 * A convenience macro for iterating through the lists used in the internal
 * memory management of objects.
 * REQUIRES DECLARATION: Tcl_Size i;
 */

/*
 * A variation where the array is an array of structs. There's no issue with
 * possible NULLs; every element of the array will be iterated over and the
 * variable set to a pointer to each of those elements in turn.
 * REQUIRES DECLARATION: Tcl_Size i; See [96551aca55] for more FOREACH_STRUCT details.
 */

/*
 * Convenience macros for iterating through hash tables. FOREACH_HASH_DECLS
 * sets up the declarations needed for the main macro, FOREACH_HASH, which
 * does the actual iteration. FOREACH_HASH_KEY and FOREACH_HASH_VALUE are
 * restricted versions that only iterate over keys or values respectively.
 * REQUIRES DECLARATION: FOREACH_HASH_DECLS;
 */

/*
 * Convenience macro for duplicating a list. Needs no external declaration,
 * but all arguments are used multiple times and so must have no side effects.
 */

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

// C documentation
//
//	/* Short-term cache for GetPropertyName(). */
type TGPNCache = struct {
	FlistPtr uintptr
}

type GPNFlags = int32

const GPN_WRITABLE = 1
const /* Are we looking for a writable property? */
GPN_FALLING_BACK = 2

/*
 * Shared bits for [property] declarations.
 */
type PropOpt = int32

const PROP_ALL = 0
const PROP_READABLE = 1
const PROP_WRITABLE = 2

var _propOptNames = [4]uintptr{
	0: __ccgo_ts + 17462,
	1: __ccgo_ts + 31097,
	2: __ccgo_ts + 31126,
	3: libc.UintptrFromInt32(0),
}

/*
 * Method descriptors
 */

var _GetterType = TTcl_MethodType{
	Fversion: int32(TCL_OO_METHOD_VERSION_1),
	Fname:    __ccgo_ts + 92957,
}

func init() {
	p := unsafe.Pointer(&_GetterType)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_Configurable_Getter)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_DetailsDeleter)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_DetailsCloner)
}

var _SetterType = TTcl_MethodType{
	Fversion: int32(TCL_OO_METHOD_VERSION_1),
	Fname:    __ccgo_ts + 92972,
}

func init() {
	p := unsafe.Pointer(&_SetterType)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(_Configurable_Setter)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(_DetailsDeleter)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(_DetailsCloner)
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOO_Configurable_Configure --
 *
 *	Implementation of the oo::configurable->configure method.
 *
 * ----------------------------------------------------------------------
 */

// C documentation
//
//	/*
//	 * Ugly thunks to read and write a property by calling the right method in
//	 * the right way. Note that we MUST be correct in holding references to Tcl_Obj
//	 * values, as this is potentially a call into user code.
//	 */
func _ReadProperty(tls *libc.TLS, interp uintptr, oPtr uintptr, propName uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _objPtr, _objPtr1, v2, v4 uintptr
	var code int32
	var v1, v3 TTcl_Size
	var _ /* args at bp+0 */ [2]uintptr
	_, _, _, _, _, _, _ = _objPtr, _objPtr1, code, v1, v2, v3, v4
	*(*[2]uintptr)(unsafe.Pointer(bp)) = [2]uintptr{
		0: (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FfPtr)).FmyName,
		1: XTcl_ObjPrintf(tls, __ccgo_ts+92987, libc.VaList(bp+24, propName)),
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp)))[0])).FrefCount++
	(*TTcl_Obj)(unsafe.Pointer((*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)])).FrefCount++
	code = XTclOOPrivateObjectCmd(tls, oPtr, interp, int32(2), bp)
	_objPtr = (*(*[2]uintptr)(unsafe.Pointer(bp)))[0]
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	_objPtr1 = (*(*[2]uintptr)(unsafe.Pointer(bp)))[int32(1)]
	v4 = _objPtr1
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	if v3 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	switch code {
	case int32(TCL_BREAK):
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+93000, libc.VaList(bp+24, propName)))
		return int32(TCL_ERROR)
	case int32(TCL_CONTINUE):
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+93035, libc.VaList(bp+24, propName)))
		return int32(TCL_ERROR)
	default:
		return code
	}
	return r
}

func _WriteProperty(tls *libc.TLS, interp uintptr, oPtr uintptr, propName uintptr, valueObj uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var _objPtr, _objPtr1, _objPtr2, v2, v4, v6 uintptr
	var code int32
	var v1, v3, v5 TTcl_Size
	var _ /* args at bp+0 */ [3]uintptr
	_, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, code, v1, v2, v3, v4, v5, v6
	*(*[3]uintptr)(unsafe.Pointer(bp)) = [3]uintptr{
		0: (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FfPtr)).FmyName,
		1: XTcl_ObjPrintf(tls, __ccgo_ts+93073, libc.VaList(bp+32, propName)),
		2: valueObj,
	}
	(*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp)))[0])).FrefCount++
	(*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp)))[int32(1)])).FrefCount++
	(*TTcl_Obj)(unsafe.Pointer((*(*[3]uintptr)(unsafe.Pointer(bp)))[int32(2)])).FrefCount++
	code = XTclOOPrivateObjectCmd(tls, oPtr, interp, int32(3), bp)
	_objPtr = (*(*[3]uintptr)(unsafe.Pointer(bp)))[0]
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
	_objPtr1 = (*(*[3]uintptr)(unsafe.Pointer(bp)))[int32(1)]
	v4 = _objPtr1
	v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
	*(*TTcl_Size)(unsafe.Pointer(v4))--
	if v3 <= int64(1) {
		XTclFreeObj(tls, _objPtr1)
	}
	_objPtr2 = (*(*[3]uintptr)(unsafe.Pointer(bp)))[int32(2)]
	v6 = _objPtr2
	v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
	*(*TTcl_Size)(unsafe.Pointer(v6))--
	if v5 <= int64(1) {
		XTclFreeObj(tls, _objPtr2)
	}
	switch code {
	case int32(TCL_BREAK):
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+93087, libc.VaList(bp+32, propName)))
		return int32(TCL_ERROR)
	case int32(TCL_CONTINUE):
		XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+93122, libc.VaList(bp+32, propName)))
		return int32(TCL_ERROR)
	default:
		return code
	}
	return r
}

// C documentation
//
//	/* Look up a property full name. */
func _GetPropertyName(tls *libc.TLS, interp uintptr, oPtr uintptr, flags int32, namePtr uintptr, cachePtr uintptr) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48) /* Where to cache the table, if the caller
	 * wants that. The contents are to be freed
	 * with Tcl_Free if the cache is used. */
	var foo TTcl_InterpState
	var i TTcl_Size
	var listPtr, otherName, tablePtr, v2, v3, v4 uintptr
	var result int32
	var _ /* index at bp+8 */ TTcl_Size
	var _ /* objc at bp+0 */ TTcl_Size
	var _ /* objv at bp+16 */ uintptr
	_, _, _, _, _, _, _, _, _ = foo, i, listPtr, otherName, result, tablePtr, v2, v3, v4
	listPtr = XTclOOGetAllObjectProperties(tls, oPtr, flags&int32(GPN_WRITABLE))
	XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), listPtr, bp, bp+16)
	if cachePtr != 0 && *(*uintptr)(unsafe.Pointer(cachePtr)) != 0 {
		tablePtr = *(*uintptr)(unsafe.Pointer(cachePtr))
	} else {
		tablePtr = XTclStackAlloc(tls, interp, uint64(libc.UintptrFromInt32(0)+8)+uint64(8)*libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))+libc.Int64FromInt32(1)))
		i = 0
		for {
			if !(i < *(*TTcl_Size)(unsafe.Pointer(bp))) {
				break
			}
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i)*8)))).Fbytes != 0 {
				v2 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i)*8)))).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(i)*8)), libc.UintptrFromInt32(0))
			}
			*(*uintptr)(unsafe.Pointer(tablePtr + 8 + uintptr(i)*8)) = v2
			goto _1
		_1:
			;
			i++
		}
		*(*uintptr)(unsafe.Pointer(tablePtr + 8 + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp)))*8)) = libc.UintptrFromInt32(0)
		if cachePtr != 0 {
			/*
			 * Have a cache, but nothing in it so far.
			 *
			 * We cache the list here so it doesn't vanish from under our
			 * feet if a property implementation does something crazy like
			 * changing the set of properties. The type of copy this does
			 * means that the copy holds the references to the names in the
			 * table.
			 */
			(*TGPNCache)(unsafe.Pointer(tablePtr)).FlistPtr = XTclListObjCopy(tls, libc.UintptrFromInt32(0), listPtr)
			(*TTcl_Obj)(unsafe.Pointer((*TGPNCache)(unsafe.Pointer(tablePtr)).FlistPtr)).FrefCount++
			*(*uintptr)(unsafe.Pointer(cachePtr)) = tablePtr
		} else {
			(*TGPNCache)(unsafe.Pointer(tablePtr)).FlistPtr = libc.UintptrFromInt32(0)
		}
	}
	result = XTcl_GetIndexFromObjStruct(tls, interp, namePtr, tablePtr+8, libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+93160, libc.Int32FromInt32(TCL_INDEX_TEMP_TABLE)|libc.Int32FromUint64(libc.Uint64FromInt64(8)<<libc.Int32FromInt32(1)), bp+8)
	if result == int32(TCL_ERROR) && !(flags&int32(GPN_FALLING_BACK) != 0) {
		/*
		 * If property can be accessed the other way, use a special message.
		 * We use a recursive call to look this up.
		 */
		foo = XTcl_SaveInterpState(tls, interp, result)
		otherName = _GetPropertyName(tls, interp, oPtr, flags^(int32(GPN_WRITABLE)|int32(GPN_FALLING_BACK)), namePtr, libc.UintptrFromInt32(0))
		result = XTcl_RestoreInterpState(tls, interp, foo)
		if otherName != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(otherName)).Fbytes != 0 {
				v3 = (*TTcl_Obj)(unsafe.Pointer(otherName)).Fbytes
			} else {
				v3 = XTcl_GetStringFromObj(tls, otherName, libc.UintptrFromInt32(0))
			}
			if flags&int32(GPN_WRITABLE) != 0 {
				v4 = __ccgo_ts + 5552
			} else {
				v4 = __ccgo_ts + 44159
			}
			XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+93169, libc.VaList(bp+32, v3, v4)))
		}
	}
	if !(cachePtr != 0) {
		XTclStackFree(tls, interp, tablePtr)
	}
	if result != TCL_OK {
		return libc.UintptrFromInt32(0)
	}
	return *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 16)) + uintptr(*(*TTcl_Size)(unsafe.Pointer(bp + 8)))*8))
}

// C documentation
//
//	/* Release the cache made by GetPropertyName(). */
func _ReleasePropertyNameCache(tls *libc.TLS, interp uintptr, cachePtr uintptr) {
	var _objPtr, tablePtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _ = _objPtr, tablePtr, v1, v2
	if *(*uintptr)(unsafe.Pointer(cachePtr)) != 0 {
		tablePtr = *(*uintptr)(unsafe.Pointer(cachePtr))
		if (*TGPNCache)(unsafe.Pointer(tablePtr)).FlistPtr != 0 {
			_objPtr = (*TGPNCache)(unsafe.Pointer(tablePtr)).FlistPtr
			v2 = _objPtr
			v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
			*(*TTcl_Size)(unsafe.Pointer(v2))--
			if v1 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
		}
		XTclStackFree(tls, interp, tablePtr)
		*(*uintptr)(unsafe.Pointer(cachePtr)) = libc.UintptrFromInt32(0)
	}
}

func XTclOO_Configurable_Configure(tls *libc.TLS, dummy252 uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The actual arguments. */
	var _objPtr, _objPtr1, listPtr, namePtr, namev, oPtr, resultPtr, v10, v11, v13, v4, v6, v9 uintptr
	var code int32
	var i, namec, skip, v5, v7, v8 TTcl_Size
	var v1, v2 int64
	var _ /* cache at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, code, i, listPtr, namePtr, namec, namev, oPtr, resultPtr, skip, v1, v10, v11, v13, v2, v4, v5, v6, v7, v8, v9
	oPtr = XTcl_ObjectContextObject(tls, context)
	skip = XTcl_ObjectContextSkippedArgs(tls, context)
	code = TCL_OK
	objc = int32(int64(objc) - skip)
	if objc&int32(1) != 0 && objc != int32(1) {
		/*
		 * Bad (odd > 1) number of arguments.
		 */
		XTcl_WrongNumArgs(tls, interp, skip, objv, __ccgo_ts+42585)
		return int32(TCL_ERROR)
	}
	objv += uintptr(skip) * 8
	if objc == 0 {
		/*
		 * Read all properties.
		 */
		listPtr = XTclOOGetAllObjectProperties(tls, oPtr, 0)
		resultPtr = XTcl_NewObj(tls)
		(*TTcl_Obj)(unsafe.Pointer(listPtr)).FrefCount++
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listPtr + 32))).Fptr2 != 0 {
			v1 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr + 32))).Fptr2)).FspanStart
		} else {
			v1 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr + 32))).Fptr1)).FfirstUsed
		}
		namev = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listPtr + 32))).Fptr1 + 40 + uintptr(v1)*8
		if (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(listPtr + 32))).Fptr2 != 0 {
			v2 = (*TListSpan)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr + 32))).Fptr2)).FspanLength
		} else {
			v2 = (*TListStore)(unsafe.Pointer((*(*struct {
				Fptr1 uintptr
				Fptr2 uintptr
			})(unsafe.Pointer(listPtr + 32))).Fptr1)).FnumUsed
		}
		namec = v2
		i = 0
		for {
			if !(i < namec) {
				break
			}
			if (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(namev + uintptr(i)*8)))).Fbytes != 0 {
				v4 = (*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(namev + uintptr(i)*8)))).Fbytes
			} else {
				v4 = XTcl_GetStringFromObj(tls, *(*uintptr)(unsafe.Pointer(namev + uintptr(i)*8)), libc.UintptrFromInt32(0))
			}
			code = _ReadProperty(tls, interp, oPtr, v4)
			if code != TCL_OK {
				_objPtr = resultPtr
				v6 = _objPtr
				v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
				*(*TTcl_Size)(unsafe.Pointer(v6))--
				if v5 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
				break
			}
			XTcl_DictObjPut(tls, libc.UintptrFromInt32(0), resultPtr, *(*uintptr)(unsafe.Pointer(namev + uintptr(i)*8)), XTcl_GetObjResult(tls, interp))
			i++
			v7 = i
			if v7 >= namec {
				XTcl_SetObjResult(tls, interp, resultPtr)
				break
			}
			XTcl_SetObjResult(tls, interp, XTcl_NewObj(tls))
			goto _3
		_3:
		}
		_objPtr1 = listPtr
		v9 = _objPtr1
		v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
		*(*TTcl_Size)(unsafe.Pointer(v9))--
		if v8 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
		return code
	} else {
		if objc == int32(1) {
			/*
			 * Read a single named property.
			 */
			namePtr = _GetPropertyName(tls, interp, oPtr, 0, *(*uintptr)(unsafe.Pointer(objv)), libc.UintptrFromInt32(0))
			if namePtr == libc.UintptrFromInt32(0) {
				return int32(TCL_ERROR)
			}
			if (*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes != 0 {
				v10 = (*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes
			} else {
				v10 = XTcl_GetStringFromObj(tls, namePtr, libc.UintptrFromInt32(0))
			}
			return _ReadProperty(tls, interp, oPtr, v10)
		} else {
			if objc == int32(2) {
				/*
				 * Special case for writing to one property. Saves fiddling with the
				 * cache in this common case.
				 */
				namePtr = _GetPropertyName(tls, interp, oPtr, int32(GPN_WRITABLE), *(*uintptr)(unsafe.Pointer(objv)), libc.UintptrFromInt32(0))
				if namePtr == libc.UintptrFromInt32(0) {
					return int32(TCL_ERROR)
				}
				if (*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes != 0 {
					v11 = (*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes
				} else {
					v11 = XTcl_GetStringFromObj(tls, namePtr, libc.UintptrFromInt32(0))
				}
				code = _WriteProperty(tls, interp, oPtr, v11, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
				if code == TCL_OK {
					XTcl_ResetResult(tls, interp)
				}
				return code
			} else {
				/*
				 * Write properties. Slightly tricky because we want to cache the
				 * table of property names.
				 */
				*(*uintptr)(unsafe.Pointer(bp)) = libc.UintptrFromInt32(0)
				code = TCL_OK
				i = 0
				for {
					if !(i < int64(objc)) {
						break
					}
					namePtr = _GetPropertyName(tls, interp, oPtr, int32(GPN_WRITABLE), *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp)
					if namePtr == libc.UintptrFromInt32(0) {
						code = int32(TCL_ERROR)
						break
					}
					if (*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes != 0 {
						v13 = (*TTcl_Obj)(unsafe.Pointer(namePtr)).Fbytes
					} else {
						v13 = XTcl_GetStringFromObj(tls, namePtr, libc.UintptrFromInt32(0))
					}
					code = _WriteProperty(tls, interp, oPtr, v13, *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int64(1))*8)))
					if code != TCL_OK {
						break
					}
					goto _12
				_12:
					;
					i += int64(2)
				}
				if code == TCL_OK {
					XTcl_ResetResult(tls, interp)
				}
				_ReleasePropertyNameCache(tls, interp, bp)
				return code
			}
		}
	}
	return r
}

/*
 * ----------------------------------------------------------------------
 *
 * Configurable_Getter, Configurable_Setter --
 *
 *	Standard property implementation. The clientData is a simple Tcl_Obj*
 *	that contains the name of the property.
 *
 * ----------------------------------------------------------------------
 */

func _Configurable_Getter(tls *libc.TLS, clientData uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The actual arguments. */
	var propNamePtr, valuePtr uintptr
	var varPtr TTcl_Var
	var _ /* aryVar at bp+0 */ TTcl_Var
	_, _, _ = propNamePtr, valuePtr, varPtr
	propNamePtr = clientData
	if int32(XTcl_ObjectContextSkippedArgs(tls, context)) != objc {
		XTcl_WrongNumArgs(tls, interp, XTcl_ObjectContextSkippedArgs(tls, context), objv, libc.UintptrFromInt32(0))
		return int32(TCL_ERROR)
	}
	varPtr = XTclOOLookupObjectVar(tls, interp, XTcl_ObjectContextObject(tls, context), propNamePtr, bp)
	if varPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	valuePtr = XTclPtrGetVar(tls, interp, varPtr, *(*TTcl_Var)(unsafe.Pointer(bp)), propNamePtr, libc.UintptrFromInt32(0), libc.Int32FromInt32(TCL_NAMESPACE_ONLY)|libc.Int32FromInt32(TCL_LEAVE_ERR_MSG))
	if valuePtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	XTcl_SetObjResult(tls, interp, valuePtr)
	return TCL_OK
}

func _Configurable_Setter(tls *libc.TLS, clientData uintptr, interp uintptr, context TTcl_ObjectContext, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* The actual arguments. */
	var propNamePtr uintptr
	var varPtr TTcl_Var
	var _ /* aryVar at bp+0 */ TTcl_Var
	_, _ = propNamePtr, varPtr
	propNamePtr = clientData
	if int32(XTcl_ObjectContextSkippedArgs(tls, context))+int32(1) != objc {
		XTcl_WrongNumArgs(tls, interp, XTcl_ObjectContextSkippedArgs(tls, context), objv, __ccgo_ts+3605)
		return int32(TCL_ERROR)
	}
	varPtr = XTclOOLookupObjectVar(tls, interp, XTcl_ObjectContextObject(tls, context), propNamePtr, bp)
	if varPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if XTclPtrSetVar(tls, interp, varPtr, *(*TTcl_Var)(unsafe.Pointer(bp)), propNamePtr, libc.UintptrFromInt32(0), *(*uintptr)(unsafe.Pointer(objv + uintptr(objc-int32(1))*8)), libc.Int32FromInt32(TCL_NAMESPACE_ONLY)|libc.Int32FromInt32(TCL_LEAVE_ERR_MSG)) == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	return TCL_OK
}

// C documentation
//
//	// Simple support functions
func _DetailsDeleter(tls *libc.TLS, clientData uintptr) {
	var _objPtr, propNamePtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _, _ = _objPtr, propNamePtr, v1, v2
	// Just drop the reference count
	propNamePtr = clientData
	_objPtr = propNamePtr
	v2 = _objPtr
	v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
	*(*TTcl_Size)(unsafe.Pointer(v2))--
	if v1 <= int64(1) {
		XTclFreeObj(tls, _objPtr)
	}
}

func _DetailsCloner(tls *libc.TLS, dummy449 uintptr, oldClientData uintptr, newClientData uintptr) (r int32) {
	var propNamePtr uintptr
	_ = propNamePtr
	// Just add another reference to this name; easy!
	propNamePtr = oldClientData
	(*TTcl_Obj)(unsafe.Pointer(propNamePtr)).FrefCount++
	*(*uintptr)(unsafe.Pointer(newClientData)) = propNamePtr
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * ImplementObjectProperty, ImplementClassProperty --
 *
 *	Installs a basic property implementation for a property, either on
 *	an instance or on a class. It's up to the code that calls these
 *	to ensure that the property name is syntactically valid.
 *
 * ----------------------------------------------------------------------
 */

func _ImplementObjectProperty(tls *libc.TLS, targetObject TTcl_Object, propNamePtr uintptr, installGetter int32, installSetter int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Whether to install a standard setter. */
	var _objPtr, methodName, methodName1, propName, v1, v2, v4, v5, v7 uintptr
	var v3, v6 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _ = _objPtr, methodName, methodName1, propName, v1, v2, v3, v4, v5, v6, v7
	if (*TTcl_Obj)(unsafe.Pointer(propNamePtr)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(propNamePtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, propNamePtr, libc.UintptrFromInt32(0))
	}
	propName = v1
	for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(propName))) == int32('-') {
		propName++
	}
	if installGetter != 0 {
		methodName = XTcl_ObjPrintf(tls, __ccgo_ts+93194, libc.VaList(bp+8, propName))
		(*TTcl_Obj)(unsafe.Pointer(propNamePtr)).FrefCount++ // Paired with DetailsDeleter
		XTclNewInstanceMethod(tls, libc.UintptrFromInt32(0), targetObject, methodName, 0, uintptr(unsafe.Pointer(&_GetterType)), propNamePtr)
		v2 = methodName
		if v2 != 0 {
			if (*TTcl_Obj)(unsafe.Pointer(v2)).FrefCount == libc.Int64FromInt32(0) {
				_objPtr = v2
				v4 = _objPtr
				v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
				*(*TTcl_Size)(unsafe.Pointer(v4))--
				if v3 <= libc.Int64FromInt32(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
		}
	}
	if installSetter != 0 {
		methodName1 = XTcl_ObjPrintf(tls, __ccgo_ts+93208, libc.VaList(bp+8, propName))
		(*TTcl_Obj)(unsafe.Pointer(propNamePtr)).FrefCount++ // Paired with DetailsDeleter
		XTclNewInstanceMethod(tls, libc.UintptrFromInt32(0), targetObject, methodName1, 0, uintptr(unsafe.Pointer(&_SetterType)), propNamePtr)
		v5 = methodName1
		if v5 != 0 {
			if (*TTcl_Obj)(unsafe.Pointer(v5)).FrefCount == libc.Int64FromInt32(0) {
				_objPtr = v5
				v7 = _objPtr
				v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
				*(*TTcl_Size)(unsafe.Pointer(v7))--
				if v6 <= libc.Int64FromInt32(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
		}
	}
}

func _ImplementClassProperty(tls *libc.TLS, targetClass TTcl_Class, propNamePtr uintptr, installGetter int32, installSetter int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Whether to install a standard setter. */
	var _objPtr, methodName, methodName1, propName, v1, v2, v4, v5, v7 uintptr
	var v3, v6 TTcl_Size
	_, _, _, _, _, _, _, _, _, _, _ = _objPtr, methodName, methodName1, propName, v1, v2, v3, v4, v5, v6, v7
	if (*TTcl_Obj)(unsafe.Pointer(propNamePtr)).Fbytes != 0 {
		v1 = (*TTcl_Obj)(unsafe.Pointer(propNamePtr)).Fbytes
	} else {
		v1 = XTcl_GetStringFromObj(tls, propNamePtr, libc.UintptrFromInt32(0))
	}
	propName = v1
	for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(propName))) == int32('-') {
		propName++
	}
	if installGetter != 0 {
		methodName = XTcl_ObjPrintf(tls, __ccgo_ts+93194, libc.VaList(bp+8, propName))
		(*TTcl_Obj)(unsafe.Pointer(propNamePtr)).FrefCount++ // Paired with DetailsDeleter
		XTclNewMethod(tls, targetClass, methodName, 0, uintptr(unsafe.Pointer(&_GetterType)), propNamePtr)
		v2 = methodName
		if v2 != 0 {
			if (*TTcl_Obj)(unsafe.Pointer(v2)).FrefCount == libc.Int64FromInt32(0) {
				_objPtr = v2
				v4 = _objPtr
				v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
				*(*TTcl_Size)(unsafe.Pointer(v4))--
				if v3 <= libc.Int64FromInt32(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
		}
	}
	if installSetter != 0 {
		methodName1 = XTcl_ObjPrintf(tls, __ccgo_ts+93208, libc.VaList(bp+8, propName))
		(*TTcl_Obj)(unsafe.Pointer(propNamePtr)).FrefCount++ // Paired with DetailsDeleter
		XTclNewMethod(tls, targetClass, methodName1, 0, uintptr(unsafe.Pointer(&_SetterType)), propNamePtr)
		v5 = methodName1
		if v5 != 0 {
			if (*TTcl_Obj)(unsafe.Pointer(v5)).FrefCount == libc.Int64FromInt32(0) {
				_objPtr = v5
				v7 = _objPtr
				v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
				*(*TTcl_Size)(unsafe.Pointer(v7))--
				if v6 <= libc.Int64FromInt32(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
		}
	}
}

/*
 * ----------------------------------------------------------------------
 *
 * FindClassProps --
 *
 *	Discover the properties known to a class and its superclasses.
 *	The property names become the keys in the accumulator hash table
 *	(which is used as a set).
 *
 * ----------------------------------------------------------------------
 */

func _FindClassProps(tls *libc.TLS, clsPtr uintptr, writable int32, accumulator uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Where to gather the names. */
	var i int32
	var mixin, propName, sup uintptr
	var _ /* dummy at bp+0 */ int32
	_, _, _, _ = i, mixin, propName, sup
	goto tailRecurse
tailRecurse:
	;
	if writable != 0 {
		i = 0
		for {
			if !(int64(i) < (*TClass)(unsafe.Pointer(clsPtr)).Fproperties.Fwritable.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fproperties.Fwritable.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _1
			} else {
				propName = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fproperties.Fwritable.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(accumulator)).FcreateProc})))(tls, accumulator, propName, bp)
				}
			}
			goto _1
		_1:
			;
			i++
		}
	} else {
		i = 0
		for {
			if !(int64(i) < (*TClass)(unsafe.Pointer(clsPtr)).Fproperties.Freadable.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fproperties.Freadable.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _2
			} else {
				propName = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fproperties.Freadable.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(accumulator)).FcreateProc})))(tls, accumulator, propName, bp)
				}
			}
			goto _2
		_2:
			;
			i++
		}
	}
	if (*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).FthisPtr)).Fflags&int32(ROOT_OBJECT) != 0 {
		/*
		 * We do *not* traverse upwards from the root!
		 */
		return
	}
	i = 0
	for {
		if !(int64(i) < (*TClass)(unsafe.Pointer(clsPtr)).Fmixins.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _3
		} else {
			mixin = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fmixins.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				_FindClassProps(tls, mixin, writable, accumulator)
			}
		}
		goto _3
	_3:
		;
		i++
	}
	if (*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Fnum == int64(1) {
		clsPtr = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Flist))
		goto tailRecurse
	}
	i = 0
	for {
		if !(int64(i) < (*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _4
		} else {
			sup = *(*uintptr)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).Fsuperclasses.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				_FindClassProps(tls, sup, writable, accumulator)
			}
		}
		goto _4
	_4:
		;
		i++
	}
}

/*
 * ----------------------------------------------------------------------
 *
 * FindObjectProps --
 *
 *	Discover the properties known to an object and all its classes.
 *	The property names become the keys in the accumulator hash table
 *	(which is used as a set).
 *
 * ----------------------------------------------------------------------
 */

func _FindObjectProps(tls *libc.TLS, oPtr uintptr, writable int32, accumulator uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16) /* Where to gather the names. */
	var i int32
	var mixin, propName uintptr
	var _ /* dummy at bp+0 */ int32
	_, _, _ = i, mixin, propName
	if writable != 0 {
		i = 0
		for {
			if !(int64(i) < (*TObject)(unsafe.Pointer(oPtr)).Fproperties.Fwritable.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fproperties.Fwritable.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _1
			} else {
				propName = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fproperties.Fwritable.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(accumulator)).FcreateProc})))(tls, accumulator, propName, bp)
				}
			}
			goto _1
		_1:
			;
			i++
		}
	} else {
		i = 0
		for {
			if !(int64(i) < (*TObject)(unsafe.Pointer(oPtr)).Fproperties.Freadable.Fnum) {
				break
			}
			if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fproperties.Freadable.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
				goto _2
			} else {
				propName = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fproperties.Freadable.Flist + uintptr(i)*8))
				if libc.Int32FromInt32(1) != 0 {
					(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(accumulator)).FcreateProc})))(tls, accumulator, propName, bp)
				}
			}
			goto _2
		_2:
			;
			i++
		}
	}
	i = 0
	for {
		if !(int64(i) < (*TObject)(unsafe.Pointer(oPtr)).Fmixins.Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _3
		} else {
			mixin = *(*uintptr)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).Fmixins.Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				_FindClassProps(tls, mixin, writable, accumulator)
			}
		}
		goto _3
	_3:
		;
		i++
	}
	_FindClassProps(tls, (*TObject)(unsafe.Pointer(oPtr)).FselfCls, writable, accumulator)
}

/*
 * ----------------------------------------------------------------------
 *
 * GetAllClassProperties --
 *
 *	Get the list of all properties known to a class, including to its
 *	superclasses. Manages a cache so this operation is usually cheap.
 *	The order of properties in the resulting list is undefined.
 *
 * ----------------------------------------------------------------------
 */

func _GetAllClassProperties(tls *libc.TLS, clsPtr uintptr, writable int32, allocated uintptr) (r uintptr) {
	bp := tls.Alloc(144)
	defer tls.Free(144) /* Address of variable to set to true if a
	 * Tcl_Obj was allocated and may be safely
	 * modified by the caller. */
	var _objPtr, _objPtr1, cachePtr, hPtr, result, v4, v6, v8 uintptr
	var v1 bool
	var v3 int32
	var v5, v7 TTcl_Size
	var _ /* hashTable at bp+0 */ TTcl_HashTable
	var _ /* propName at bp+128 */ uintptr
	var _ /* search at bp+104 */ TTcl_HashSearch
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, hPtr, result, v1, v3, v4, v5, v6, v7, v8
	/*
	 * Look in the cache.
	 */
	if int64((*TClass)(unsafe.Pointer(clsPtr)).Fproperties.Fepoch) == (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).FthisPtr)).FfPtr)).Fepoch {
		if writable != 0 {
			if (*TClass)(unsafe.Pointer(clsPtr)).Fproperties.FallWritableCache != 0 {
				*(*int32)(unsafe.Pointer(allocated)) = 0
				return (*TClass)(unsafe.Pointer(clsPtr)).Fproperties.FallWritableCache
			}
		} else {
			if (*TClass)(unsafe.Pointer(clsPtr)).Fproperties.FallReadableCache != 0 {
				*(*int32)(unsafe.Pointer(allocated)) = 0
				return (*TClass)(unsafe.Pointer(clsPtr)).Fproperties.FallReadableCache
			}
		}
	}
	/*
	 * Gather the information. Unsorted! (Caller will sort.)
	 */
	*(*int32)(unsafe.Pointer(allocated)) = int32(1)
	XTcl_InitObjHashTable(tls, bp)
	_FindClassProps(tls, clsPtr, writable, bp)
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		result = XTclThreadAllocObj(tls)
	} else {
		result = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(result + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(result)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(result)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(result)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(result)).FtypePtr = libc.UintptrFromInt32(0)
	hPtr = XTcl_FirstHashEntry(tls, bp, bp+104)
	for {
		if hPtr != libc.UintptrFromInt32(0) {
			if (*TTcl_HashTable)(unsafe.Pointer(bp)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(bp)).FkeyType == -int32(1) {
				v4 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
			} else {
				v4 = hPtr + 32
			}
			*(*uintptr)(unsafe.Pointer(bp + 128)) = v4
			v3 = libc.Int32FromInt32(1)
		} else {
			v3 = 0
		}
		if !(v3 != 0) {
			break
		}
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), result, *(*uintptr)(unsafe.Pointer(bp + 128)))
		goto _2
	_2:
		;
		hPtr = XTcl_NextHashEntry(tls, bp+104)
	}
	XTcl_DeleteHashTable(tls, bp)
	/*
	 * Cache the information. Also purges the cache.
	 */
	if int64((*TClass)(unsafe.Pointer(clsPtr)).Fproperties.Fepoch) != (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).FthisPtr)).FfPtr)).Fepoch {
		if (*TClass)(unsafe.Pointer(clsPtr)).Fproperties.FallWritableCache != 0 {
			_objPtr = (*TClass)(unsafe.Pointer(clsPtr)).Fproperties.FallWritableCache
			v6 = _objPtr
			v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
			*(*TTcl_Size)(unsafe.Pointer(v6))--
			if v5 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			(*TClass)(unsafe.Pointer(clsPtr)).Fproperties.FallWritableCache = libc.UintptrFromInt32(0)
		}
		if (*TClass)(unsafe.Pointer(clsPtr)).Fproperties.FallReadableCache != 0 {
			_objPtr1 = (*TClass)(unsafe.Pointer(clsPtr)).Fproperties.FallReadableCache
			v8 = _objPtr1
			v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
			*(*TTcl_Size)(unsafe.Pointer(v8))--
			if v7 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
			(*TClass)(unsafe.Pointer(clsPtr)).Fproperties.FallReadableCache = libc.UintptrFromInt32(0)
		}
	}
	(*TClass)(unsafe.Pointer(clsPtr)).Fproperties.Fepoch = int32((*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer((*TClass)(unsafe.Pointer(clsPtr)).FthisPtr)).FfPtr)).Fepoch)
	if writable != 0 {
		(*TClass)(unsafe.Pointer(clsPtr)).Fproperties.FallWritableCache = result
	} else {
		(*TClass)(unsafe.Pointer(clsPtr)).Fproperties.FallReadableCache = result
	}
	(*TTcl_Obj)(unsafe.Pointer(result)).FrefCount++
	return result
}

/*
 * ----------------------------------------------------------------------
 *
 * SortPropList --
 *	Sort a list of names of properties. Simple support function. Assumes
 *	that the list Tcl_Obj is unshared and doesn't have a string
 *	representation.
 *
 * ----------------------------------------------------------------------
 */

func _PropNameCompare(tls *libc.TLS, a uintptr, b uintptr) (r int32) {
	var first, second uintptr
	_, _ = first, second
	first = *(*uintptr)(unsafe.Pointer(a))
	second = *(*uintptr)(unsafe.Pointer(b))
	return XTclStringCmp(tls, first, second, 0, 0, int64(-libc.Int32FromInt32(1)))
}

func _SortPropList(tls *libc.TLS, list uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var _isobjPtr uintptr
	var _ /* ec at bp+0 */ TTcl_Size
	var _ /* ev at bp+8 */ uintptr
	_ = _isobjPtr
	if (*TTcl_Obj)(unsafe.Pointer(list)).FrefCount > int64(1) {
		XTcl_Panic(tls, __ccgo_ts+93223, 0)
	}
	XTcl_ListObjGetElements(tls, libc.UintptrFromInt32(0), list, bp, bp+8)
	_isobjPtr = list
	if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != libc.UintptrFromInt32(0) {
		if (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes != uintptr(unsafe.Pointer(&XtclEmptyString)) {
			XTclpFree(tls, (*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes)
		}
		(*TTcl_Obj)(unsafe.Pointer(_isobjPtr)).Fbytes = libc.UintptrFromInt32(0)
	}
	libc.Xqsort(tls, *(*uintptr)(unsafe.Pointer(bp + 8)), libc.Uint64FromInt64(*(*TTcl_Size)(unsafe.Pointer(bp))), uint64(8), __ccgo_fp(_PropNameCompare))
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOGetAllObjectProperties --
 *
 *	Get the sorted list of all properties known to an object, including to
 *	its classes. Manages a cache so this operation is usually cheap.
 *
 * ----------------------------------------------------------------------
 */

func XTclOOGetAllObjectProperties(tls *libc.TLS, oPtr uintptr, writable int32) (r uintptr) {
	bp := tls.Alloc(144)
	defer tls.Free(144) /* Whether to get writable properties. If
	 * false, readable properties will be returned
	 * instead. */
	var _objPtr, _objPtr1, cachePtr, hPtr, result, v4, v6, v8 uintptr
	var v1 bool
	var v3 int32
	var v5, v7 TTcl_Size
	var _ /* hashTable at bp+0 */ TTcl_HashTable
	var _ /* propName at bp+128 */ uintptr
	var _ /* search at bp+104 */ TTcl_HashSearch
	_, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, cachePtr, hPtr, result, v1, v3, v4, v5, v6, v7, v8
	/*
	 * Look in the cache.
	 */
	if int64((*TObject)(unsafe.Pointer(oPtr)).Fproperties.Fepoch) == (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FfPtr)).Fepoch {
		if writable != 0 {
			if (*TObject)(unsafe.Pointer(oPtr)).Fproperties.FallWritableCache != 0 {
				return (*TObject)(unsafe.Pointer(oPtr)).Fproperties.FallWritableCache
			}
		} else {
			if (*TObject)(unsafe.Pointer(oPtr)).Fproperties.FallReadableCache != 0 {
				return (*TObject)(unsafe.Pointer(oPtr)).Fproperties.FallReadableCache
			}
		}
	}
	/*
	 * Gather the information. Unsorted! (Caller will sort.)
	 */
	XTcl_InitObjHashTable(tls, bp)
	_FindObjectProps(tls, oPtr, writable, bp)
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		result = XTclThreadAllocObj(tls)
	} else {
		result = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(result + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(result)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(result)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(result)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(result)).FtypePtr = libc.UintptrFromInt32(0)
	hPtr = XTcl_FirstHashEntry(tls, bp, bp+104)
	for {
		if hPtr != libc.UintptrFromInt32(0) {
			if (*TTcl_HashTable)(unsafe.Pointer(bp)).FkeyType == int32(TCL_ONE_WORD_KEYS) || (*TTcl_HashTable)(unsafe.Pointer(bp)).FkeyType == -int32(1) {
				v4 = *(*uintptr)(unsafe.Pointer(hPtr + 32))
			} else {
				v4 = hPtr + 32
			}
			*(*uintptr)(unsafe.Pointer(bp + 128)) = v4
			v3 = libc.Int32FromInt32(1)
		} else {
			v3 = 0
		}
		if !(v3 != 0) {
			break
		}
		XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), result, *(*uintptr)(unsafe.Pointer(bp + 128)))
		goto _2
	_2:
		;
		hPtr = XTcl_NextHashEntry(tls, bp+104)
	}
	XTcl_DeleteHashTable(tls, bp)
	_SortPropList(tls, result)
	/*
	 * Cache the information.
	 */
	if int64((*TObject)(unsafe.Pointer(oPtr)).Fproperties.Fepoch) != (*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FfPtr)).Fepoch {
		if (*TObject)(unsafe.Pointer(oPtr)).Fproperties.FallWritableCache != 0 {
			_objPtr = (*TObject)(unsafe.Pointer(oPtr)).Fproperties.FallWritableCache
			v6 = _objPtr
			v5 = *(*TTcl_Size)(unsafe.Pointer(v6))
			*(*TTcl_Size)(unsafe.Pointer(v6))--
			if v5 <= int64(1) {
				XTclFreeObj(tls, _objPtr)
			}
			(*TObject)(unsafe.Pointer(oPtr)).Fproperties.FallWritableCache = libc.UintptrFromInt32(0)
		}
		if (*TObject)(unsafe.Pointer(oPtr)).Fproperties.FallReadableCache != 0 {
			_objPtr1 = (*TObject)(unsafe.Pointer(oPtr)).Fproperties.FallReadableCache
			v8 = _objPtr1
			v7 = *(*TTcl_Size)(unsafe.Pointer(v8))
			*(*TTcl_Size)(unsafe.Pointer(v8))--
			if v7 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
			(*TObject)(unsafe.Pointer(oPtr)).Fproperties.FallReadableCache = libc.UintptrFromInt32(0)
		}
	}
	(*TObject)(unsafe.Pointer(oPtr)).Fproperties.Fepoch = int32((*TFoundation)(unsafe.Pointer((*TObject)(unsafe.Pointer(oPtr)).FfPtr)).Fepoch)
	if writable != 0 {
		(*TObject)(unsafe.Pointer(oPtr)).Fproperties.FallWritableCache = result
	} else {
		(*TObject)(unsafe.Pointer(oPtr)).Fproperties.FallReadableCache = result
	}
	(*TTcl_Obj)(unsafe.Pointer(result)).FrefCount++
	return result
}

// C documentation
//
//	/*
//	 * ----------------------------------------------------------------------
//	 *
//	 * SetPropertyList --
//	 *
//	 *	Helper for writing a property list (which is actually a set).
//	 *
//	 * ----------------------------------------------------------------------
//	 */
func _SetPropertyList(tls *libc.TLS, propList uintptr, objc TTcl_Size, objv uintptr) {
	bp := tls.Alloc(112)
	defer tls.Free(112) /* Property names. */
	var _objPtr, _objPtr1, propObj, v4, v9 uintptr
	var i, n, v3, v6, v7, v8 TTcl_Size
	var _ /* created at bp+0 */ int32
	var _ /* uniqueTable at bp+8 */ TTcl_HashTable
	_, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, i, n, propObj, v3, v4, v6, v7, v8, v9
	i = 0
	for {
		if !(i < objc) {
			break
		}
		(*TTcl_Obj)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)))).FrefCount++
		goto _1
	_1:
		;
		i++
	}
	i = 0
	for {
		if !(i < (*TPropertyList)(unsafe.Pointer(propList)).Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TPropertyList)(unsafe.Pointer(propList)).Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _2
		} else {
			propObj = *(*uintptr)(unsafe.Pointer((*TPropertyList)(unsafe.Pointer(propList)).Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				_objPtr = propObj
				v4 = _objPtr
				v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
				*(*TTcl_Size)(unsafe.Pointer(v4))--
				if v3 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
		}
		goto _2
	_2:
		;
		i++
	}
	if i != objc {
		if objc == 0 {
			XTclpFree(tls, (*TPropertyList)(unsafe.Pointer(propList)).Flist)
		} else {
			if i != 0 {
				(*TPropertyList)(unsafe.Pointer(propList)).Flist = XTcl_Realloc(tls, (*TPropertyList)(unsafe.Pointer(propList)).Flist, uint64(8)*libc.Uint64FromInt64(objc))
			} else {
				(*TPropertyList)(unsafe.Pointer(propList)).Flist = XTcl_Alloc(tls, uint64(8)*libc.Uint64FromInt64(objc))
			}
		}
	}
	(*TPropertyList)(unsafe.Pointer(propList)).Fnum = 0
	if objc > 0 {
		XTcl_InitObjHashTable(tls, bp+8)
		v6 = libc.Int64FromInt32(0)
		n = v6
		i = v6
		for {
			if !(i < objc) {
				break
			}
			(*(*func(*libc.TLS, uintptr, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{(*TTcl_HashTable)(unsafe.Pointer(bp + 8)).FcreateProc})))(tls, bp+8, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), bp)
			if *(*int32)(unsafe.Pointer(bp)) != 0 {
				v7 = n
				n++
				*(*uintptr)(unsafe.Pointer((*TPropertyList)(unsafe.Pointer(propList)).Flist + uintptr(v7)*8)) = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
			} else {
				_objPtr1 = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
				v9 = _objPtr1
				v8 = *(*TTcl_Size)(unsafe.Pointer(v9))
				*(*TTcl_Size)(unsafe.Pointer(v9))--
				if v8 <= int64(1) {
					XTclFreeObj(tls, _objPtr1)
				}
			}
			goto _5
		_5:
			;
			i++
		}
		(*TPropertyList)(unsafe.Pointer(propList)).Fnum = n
		/*
		 * Shouldn't be necessary, but maintain num/list invariant.
		 */
		if n != objc {
			(*TPropertyList)(unsafe.Pointer(propList)).Flist = XTcl_Realloc(tls, (*TPropertyList)(unsafe.Pointer(propList)).Flist, uint64(8)*libc.Uint64FromInt64(n))
		}
		XTcl_DeleteHashTable(tls, bp+8)
	}
}

// C documentation
//
//	/*
//	 * ----------------------------------------------------------------------
//	 *
//	 * TclOOInstallReadableProperties --
//	 *
//	 *	Helper for writing the readable property list (which is actually a set)
//	 *	that includes flushing the name cache.
//	 *
//	 * ----------------------------------------------------------------------
//	 */
func XTclOOInstallReadableProperties(tls *libc.TLS, props uintptr, objc TTcl_Size, objv uintptr) {
	/* Property names. */
	var _objPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _ = _objPtr, v1, v2
	if (*TPropertyStorage)(unsafe.Pointer(props)).FallReadableCache != 0 {
		_objPtr = (*TPropertyStorage)(unsafe.Pointer(props)).FallReadableCache
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		(*TPropertyStorage)(unsafe.Pointer(props)).FallReadableCache = libc.UintptrFromInt32(0)
	}
	_SetPropertyList(tls, props, objc, objv)
}

// C documentation
//
//	/*
//	 * ----------------------------------------------------------------------
//	 *
//	 * TclOOInstallWritableProperties --
//	 *
//	 *	Helper for writing the writable property list (which is actually a set)
//	 *	that includes flushing the name cache.
//	 *
//	 * ----------------------------------------------------------------------
//	 */
func XTclOOInstallWritableProperties(tls *libc.TLS, props uintptr, objc TTcl_Size, objv uintptr) {
	/* Property names. */
	var _objPtr, v2 uintptr
	var v1 TTcl_Size
	_, _, _ = _objPtr, v1, v2
	if (*TPropertyStorage)(unsafe.Pointer(props)).FallWritableCache != 0 {
		_objPtr = (*TPropertyStorage)(unsafe.Pointer(props)).FallWritableCache
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
		(*TPropertyStorage)(unsafe.Pointer(props)).FallWritableCache = libc.UintptrFromInt32(0)
	}
	_SetPropertyList(tls, props+16, objc, objv)
}

// C documentation
//
//	/*
//	 * ----------------------------------------------------------------------
//	 *
//	 * TclOOGetPropertyList --
//	 *
//	 *	Helper for reading a property list.
//	 *
//	 * ----------------------------------------------------------------------
//	 */
func XTclOOGetPropertyList(tls *libc.TLS, propList uintptr) (r uintptr) {
	/* The property list to read. */
	var cachePtr, propNameObj, resultObj uintptr
	var i TTcl_Size
	var v1 bool
	_, _, _, _, _ = cachePtr, i, propNameObj, resultObj, v1
	if v1 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v1 {
		cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
	}
	if v1 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
		resultObj = XTclThreadAllocObj(tls)
	} else {
		resultObj = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
			Fptr1 uintptr
			Fptr2 uintptr
		})(unsafe.Pointer(resultObj + 32))).Fptr1
		(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
	}
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FrefCount = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).Flength = 0
	(*TTcl_Obj)(unsafe.Pointer(resultObj)).FtypePtr = libc.UintptrFromInt32(0)
	i = 0
	for {
		if !(i < (*TPropertyList)(unsafe.Pointer(propList)).Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TPropertyList)(unsafe.Pointer(propList)).Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _2
		} else {
			propNameObj = *(*uintptr)(unsafe.Pointer((*TPropertyList)(unsafe.Pointer(propList)).Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				XTcl_ListObjAppendElement(tls, libc.UintptrFromInt32(0), resultObj, propNameObj)
			}
		}
		goto _2
	_2:
		;
		i++
	}
	return resultObj
}

// C documentation
//
//	/*
//	 * ----------------------------------------------------------------------
//	 *
//	 * TclOOInstallStdPropertyImpls --
//	 *
//	 *	Validates a (dashless) property name, and installs implementation
//	 *	methods if asked to do so (readable and writable flags).
//	 *
//	 * ----------------------------------------------------------------------
//	 */
func XTclOOInstallStdPropertyImpls(tls *libc.TLS, useInstance uintptr, interp uintptr, propName uintptr, readable int32, writable int32) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var cls TTcl_Class
	var name, reason uintptr
	var object TTcl_Object
	var _ /* flag at bp+8 */ uint8
	var _ /* len at bp+0 */ TTcl_Size
	_, _, _, _ = cls, name, object, reason
	*(*uint8)(unsafe.Pointer(bp + 8)) = uint8(TCL_DONT_QUOTE_HASH)
	/*
	 * Validate the property name. Note that just calling TclScanElement() is
	 * cheaper than actually formatting a list and comparing the string
	 * version of that with the original, as TclScanElement() is one of the
	 * core parts of doing that; this skips a whole load of irrelevant memory
	 * allocations!
	 */
	name = XTcl_GetStringFromObj(tls, propName, bp)
	if XTcl_StringCaseMatch(tls, name, __ccgo_ts+93261, 0) != 0 {
		reason = __ccgo_ts + 93264
		goto badProp
	}
	if XTclScanElement(tls, name, *(*TTcl_Size)(unsafe.Pointer(bp)), bp+8) != *(*TTcl_Size)(unsafe.Pointer(bp)) {
		reason = __ccgo_ts + 93286
		goto badProp
	}
	if XTcl_StringCaseMatch(tls, name, __ccgo_ts+93308, 0) != 0 {
		reason = __ccgo_ts + 93313
		goto badProp
	}
	if XTcl_StringCaseMatch(tls, name, __ccgo_ts+93351, 0) != 0 {
		reason = __ccgo_ts + 93358
		goto badProp
	}
	/*
	 * Install the implementations... if asked to do so.
	 */
	if useInstance != 0 {
		object = XTclOOGetDefineCmdContext(tls, interp)
		if !(object != 0) {
			return int32(TCL_ERROR)
		}
		_ImplementObjectProperty(tls, object, propName, readable, writable)
	} else {
		cls = XTclOOGetClassDefineCmdContext(tls, interp)
		if !(cls != 0) {
			return int32(TCL_ERROR)
		}
		_ImplementClassProperty(tls, cls, propName, readable, writable)
	}
	return TCL_OK
	goto badProp
badProp:
	;
	XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+93387, libc.VaList(bp+24, name, reason)))
	XTcl_SetErrorCode(tls, interp, libc.VaList(bp+24, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+93414, libc.UintptrFromInt32(0)))
	return int32(TCL_ERROR)
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOODefinePropertyCmd --
 *
 *	Implementation of the "property" definition for classes and instances
 *	governed by the [oo::configurable] metaclass.
 *
 * ----------------------------------------------------------------------
 */

func XTclOODefinePropertyCmd(tls *libc.TLS, useInstance uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(112)
	defer tls.Free(112) /* Arguments. */
	var _objPtr, _objPtr1, _objPtr2, argObj, argsPtr, argsPtr1, cachePtr, getterName, getterScript, hyphenated, mPtr, mPtr1, nextObj, oPtr, propObj, setterName, setterScript, v11, v12, v14, v16, v17, v19, v2, v21, v22, v24, v26, v3, v4, v5, v7, v8, v9 uintptr
	var i int32
	var v10, v13, v15, v20, v23, v25, v6 TTcl_Size
	var v18 bool
	var _ /* kind at bp+64 */ int32
	var _ /* kinds at bp+32 */ [4]uintptr
	var _ /* option at bp+68 */ int32
	var _ /* options at bp+0 */ [4]uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = _objPtr, _objPtr1, _objPtr2, argObj, argsPtr, argsPtr1, cachePtr, getterName, getterScript, hyphenated, i, mPtr, mPtr1, nextObj, oPtr, propObj, setterName, setterScript, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v3, v4, v5, v6, v7, v8, v9
	*(*[4]uintptr)(unsafe.Pointer(bp)) = [4]uintptr{
		0: __ccgo_ts + 93430,
		1: __ccgo_ts + 93435,
		2: __ccgo_ts + 93441,
		3: libc.UintptrFromInt32(0),
	}
	*(*[4]uintptr)(unsafe.Pointer(bp + 32)) = [4]uintptr{
		0: __ccgo_ts + 5780,
		1: __ccgo_ts + 93446,
		2: __ccgo_ts + 5864,
		3: libc.UintptrFromInt32(0),
	}
	oPtr = XTclOOGetDefineCmdContext(tls, interp)
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	if !(useInstance != 0) && !((*TObject)(unsafe.Pointer(oPtr)).FclassPtr != 0) {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+90749, int64(-libc.Int32FromInt32(1))))
		XTcl_SetErrorCode(tls, interp, libc.VaList(bp+80, __ccgo_ts+2004, __ccgo_ts+32369, __ccgo_ts+90568, libc.UintptrFromInt32(0)))
		return int32(TCL_ERROR)
	}
	i = int32(1)
	for {
		if !(i < objc) {
			break
		}
		propObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8))
		getterScript = libc.UintptrFromInt32(0)
		setterScript = libc.UintptrFromInt32(0)
		/*
		 * Parse the extra options for the property.
		 */
		*(*int32)(unsafe.Pointer(bp + 64)) = 1
		for i+int32(1) < objc {
			nextObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(1))*8))
			if (*TTcl_Obj)(unsafe.Pointer(nextObj)).Fbytes != 0 {
				v2 = (*TTcl_Obj)(unsafe.Pointer(nextObj)).Fbytes
			} else {
				v2 = XTcl_GetStringFromObj(tls, nextObj, libc.UintptrFromInt32(0))
			}
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) != int32('-') {
				break
			}
			if XTcl_GetIndexFromObjStruct(tls, interp, nextObj, bp, libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+68) != TCL_OK {
				return int32(TCL_ERROR)
			}
			if i+int32(2) >= objc {
				if *(*int32)(unsafe.Pointer(bp + 68)) == 1 {
					v3 = __ccgo_ts + 93456
				} else {
					v3 = __ccgo_ts + 15995
				}
				XTcl_SetObjResult(tls, interp, XTcl_ObjPrintf(tls, __ccgo_ts+93467, libc.VaList(bp+80, v3, (*(*[4]uintptr)(unsafe.Pointer(bp)))[*(*int32)(unsafe.Pointer(bp + 68))])))
				XTcl_SetErrorCode(tls, interp, libc.VaList(bp+80, __ccgo_ts+2004, __ccgo_ts+9101, libc.UintptrFromInt32(0)))
				return int32(TCL_ERROR)
			}
			argObj = *(*uintptr)(unsafe.Pointer(objv + uintptr(i+int32(2))*8))
			i += int32(2)
			switch *(*int32)(unsafe.Pointer(bp + 68)) {
			case 0:
				getterScript = argObj
			case 2:
				setterScript = argObj
			case 1:
				if XTcl_GetIndexFromObjStruct(tls, interp, argObj, bp+32, libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+91268, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp+64) != TCL_OK {
					return int32(TCL_ERROR)
				}
				break
			}
		}
		/*
		 * Install the property. Note that TclOOInstallStdPropertyImpls
		 * validates the property name as well.
		 */
		if XTclOOInstallStdPropertyImpls(tls, useInstance, interp, propObj, libc.BoolInt32(*(*int32)(unsafe.Pointer(bp + 64)) != 2 && getterScript == libc.UintptrFromInt32(0)), libc.BoolInt32(*(*int32)(unsafe.Pointer(bp + 64)) != 0 && setterScript == libc.UintptrFromInt32(0))) != TCL_OK {
			return int32(TCL_ERROR)
		}
		if (*TTcl_Obj)(unsafe.Pointer(propObj)).Fbytes != 0 {
			v4 = (*TTcl_Obj)(unsafe.Pointer(propObj)).Fbytes
		} else {
			v4 = XTcl_GetStringFromObj(tls, propObj, libc.UintptrFromInt32(0))
		}
		hyphenated = XTcl_ObjPrintf(tls, __ccgo_ts+93499, libc.VaList(bp+80, v4))
		if useInstance != 0 {
			XTclOORegisterInstanceProperty(tls, oPtr, hyphenated, libc.BoolInt32(*(*int32)(unsafe.Pointer(bp + 64)) != 2), libc.BoolInt32(*(*int32)(unsafe.Pointer(bp + 64)) != 0))
		} else {
			XTclOORegisterProperty(tls, (*TObject)(unsafe.Pointer(oPtr)).FclassPtr, hyphenated, libc.BoolInt32(*(*int32)(unsafe.Pointer(bp + 64)) != 2), libc.BoolInt32(*(*int32)(unsafe.Pointer(bp + 64)) != 0))
		}
		v5 = hyphenated
		if v5 != 0 {
			if (*TTcl_Obj)(unsafe.Pointer(v5)).FrefCount == libc.Int64FromInt32(0) {
				_objPtr = v5
				v7 = _objPtr
				v6 = *(*TTcl_Size)(unsafe.Pointer(v7))
				*(*TTcl_Size)(unsafe.Pointer(v7))--
				if v6 <= libc.Int64FromInt32(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
		}
		/*
		 * Create property implementation methods by using the right
		 * back-end API, but only if the user has given us the bodies of the
		 * methods we'll make.
		 */
		if getterScript != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(propObj)).Fbytes != 0 {
				v8 = (*TTcl_Obj)(unsafe.Pointer(propObj)).Fbytes
			} else {
				v8 = XTcl_GetStringFromObj(tls, propObj, libc.UintptrFromInt32(0))
			}
			getterName = XTcl_ObjPrintf(tls, __ccgo_ts+93194, libc.VaList(bp+80, v8))
			argsPtr = XTcl_NewObj(tls)
			(*TTcl_Obj)(unsafe.Pointer(getterScript)).FrefCount++
			if useInstance != 0 {
				mPtr = XTclOONewProcInstanceMethod(tls, interp, oPtr, 0, getterName, argsPtr, getterScript, libc.UintptrFromInt32(0))
			} else {
				mPtr = XTclOONewProcMethod(tls, interp, (*TObject)(unsafe.Pointer(oPtr)).FclassPtr, 0, getterName, argsPtr, getterScript, libc.UintptrFromInt32(0))
			}
			v9 = getterName
			if v9 != 0 {
				if (*TTcl_Obj)(unsafe.Pointer(v9)).FrefCount == libc.Int64FromInt32(0) {
					_objPtr = v9
					v11 = _objPtr
					v10 = *(*TTcl_Size)(unsafe.Pointer(v11))
					*(*TTcl_Size)(unsafe.Pointer(v11))--
					if v10 <= libc.Int64FromInt32(1) {
						XTclFreeObj(tls, _objPtr)
					}
				}
			}
			v12 = argsPtr
			if v12 != 0 {
				if (*TTcl_Obj)(unsafe.Pointer(v12)).FrefCount == libc.Int64FromInt32(0) {
					_objPtr = v12
					v14 = _objPtr
					v13 = *(*TTcl_Size)(unsafe.Pointer(v14))
					*(*TTcl_Size)(unsafe.Pointer(v14))--
					if v13 <= libc.Int64FromInt32(1) {
						XTclFreeObj(tls, _objPtr)
					}
				}
			}
			_objPtr1 = getterScript
			v16 = _objPtr1
			v15 = *(*TTcl_Size)(unsafe.Pointer(v16))
			*(*TTcl_Size)(unsafe.Pointer(v16))--
			if v15 <= int64(1) {
				XTclFreeObj(tls, _objPtr1)
			}
			if mPtr == libc.UintptrFromInt32(0) {
				return int32(TCL_ERROR)
			}
		}
		if setterScript != libc.UintptrFromInt32(0) {
			if (*TTcl_Obj)(unsafe.Pointer(propObj)).Fbytes != 0 {
				v17 = (*TTcl_Obj)(unsafe.Pointer(propObj)).Fbytes
			} else {
				v17 = XTcl_GetStringFromObj(tls, propObj, libc.UintptrFromInt32(0))
			}
			setterName = XTcl_ObjPrintf(tls, __ccgo_ts+93208, libc.VaList(bp+80, v17))
			if v18 = libc.Bool(libc.UintptrFromInt32(0) == libc.UintptrFromInt32(0)); !v18 {
				cachePtr = (*TInterp)(unsafe.Pointer(libc.UintptrFromInt32(0))).FallocCache
			}
			if v18 || (*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects == libc.Uint64FromInt32(0) {
				argsPtr1 = XTclThreadAllocObj(tls)
			} else {
				argsPtr1 = (*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FfirstObjPtr = (*(*struct {
					Fptr1 uintptr
					Fptr2 uintptr
				})(unsafe.Pointer(argsPtr1 + 32))).Fptr1
				(*TAllocCache)(unsafe.Pointer(cachePtr)).FnumObjects--
			}
			(*TTcl_Obj)(unsafe.Pointer(argsPtr1)).FrefCount = 0
			if libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1) == uint64(0) {
				(*TTcl_Obj)(unsafe.Pointer(argsPtr1)).Fbytes = uintptr(unsafe.Pointer(&XtclEmptyString))
				(*TTcl_Obj)(unsafe.Pointer(argsPtr1)).Flength = int64(libc.Int32FromInt32(0))
			} else {
				(*TTcl_Obj)(unsafe.Pointer(argsPtr1)).Fbytes = XTcl_Alloc(tls, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)+libc.Uint64FromUint32(1))
				libc.Xmemcpy(tls, (*TTcl_Obj)(unsafe.Pointer(argsPtr1)).Fbytes, __ccgo_ts+3605, libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1))
				*(*uint8)(unsafe.Pointer((*TTcl_Obj)(unsafe.Pointer(argsPtr1)).Fbytes + uintptr(libc.Uint64FromInt64(6)-libc.Uint64FromInt32(1)))) = uint8('\000')
				(*TTcl_Obj)(unsafe.Pointer(argsPtr1)).Flength = libc.Int64FromUint64(libc.Uint64FromInt64(6) - libc.Uint64FromInt32(1))
			}
			(*TTcl_Obj)(unsafe.Pointer(argsPtr1)).FtypePtr = libc.UintptrFromInt32(0)
			(*TTcl_Obj)(unsafe.Pointer(setterScript)).FrefCount++
			if useInstance != 0 {
				mPtr1 = XTclOONewProcInstanceMethod(tls, interp, oPtr, 0, setterName, argsPtr1, setterScript, libc.UintptrFromInt32(0))
			} else {
				mPtr1 = XTclOONewProcMethod(tls, interp, (*TObject)(unsafe.Pointer(oPtr)).FclassPtr, 0, setterName, argsPtr1, setterScript, libc.UintptrFromInt32(0))
			}
			v19 = setterName
			if v19 != 0 {
				if (*TTcl_Obj)(unsafe.Pointer(v19)).FrefCount == libc.Int64FromInt32(0) {
					_objPtr = v19
					v21 = _objPtr
					v20 = *(*TTcl_Size)(unsafe.Pointer(v21))
					*(*TTcl_Size)(unsafe.Pointer(v21))--
					if v20 <= libc.Int64FromInt32(1) {
						XTclFreeObj(tls, _objPtr)
					}
				}
			}
			v22 = argsPtr1
			if v22 != 0 {
				if (*TTcl_Obj)(unsafe.Pointer(v22)).FrefCount == libc.Int64FromInt32(0) {
					_objPtr = v22
					v24 = _objPtr
					v23 = *(*TTcl_Size)(unsafe.Pointer(v24))
					*(*TTcl_Size)(unsafe.Pointer(v24))--
					if v23 <= libc.Int64FromInt32(1) {
						XTclFreeObj(tls, _objPtr)
					}
				}
			}
			_objPtr2 = setterScript
			v26 = _objPtr2
			v25 = *(*TTcl_Size)(unsafe.Pointer(v26))
			*(*TTcl_Size)(unsafe.Pointer(v26))--
			if v25 <= int64(1) {
				XTclFreeObj(tls, _objPtr2)
			}
			if mPtr1 == libc.UintptrFromInt32(0) {
				return int32(TCL_ERROR)
			}
		}
		goto _1
	_1:
		;
		i++
	}
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOInfoClassPropCmd, TclOOInfoObjectPropCmd --
 *
 *	Implements [info class properties $clsName ?$option...?] and
 *	[info object properties $objName ?$option...?]
 *
 * ----------------------------------------------------------------------
 */

func XTclOOInfoClassPropCmd(tls *libc.TLS, dummy1192 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var all, i, writable int32
	var clsPtr, result uintptr
	var _ /* allocated at bp+4 */ int32
	var _ /* idx at bp+0 */ int32
	_, _, _, _, _ = all, clsPtr, i, result, writable
	all = 0
	writable = 0
	*(*int32)(unsafe.Pointer(bp + 4)) = 0
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+93503)
		return int32(TCL_ERROR)
	}
	clsPtr = XTclOOGetClassFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if clsPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	i = int32(2)
	for {
		if !(i < objc) {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_propOptNames)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
			return int32(TCL_ERROR)
		}
		switch *(*int32)(unsafe.Pointer(bp)) {
		case int32(PROP_ALL):
			all = int32(1)
		case int32(PROP_READABLE):
			writable = 0
		case int32(PROP_WRITABLE):
			writable = int32(1)
			break
		}
		goto _1
	_1:
		;
		i++
	}
	/*
	 * Get the properties.
	 */
	if all != 0 {
		result = _GetAllClassProperties(tls, clsPtr, writable, bp+4)
		if *(*int32)(unsafe.Pointer(bp + 4)) != 0 {
			_SortPropList(tls, result)
		}
	} else {
		if writable != 0 {
			result = XTclOOGetPropertyList(tls, clsPtr+336+16)
		} else {
			result = XTclOOGetPropertyList(tls, clsPtr+336)
		}
		_SortPropList(tls, result)
	}
	XTcl_SetObjResult(tls, interp, result)
	return TCL_OK
}

func XTclOOInfoObjectPropCmd(tls *libc.TLS, dummy1250 uintptr, interp uintptr, objc int32, objv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var all, i, writable int32
	var oPtr, result uintptr
	var _ /* idx at bp+0 */ int32
	_, _, _, _, _ = all, i, oPtr, result, writable
	all = 0
	writable = 0
	if objc < int32(2) {
		XTcl_WrongNumArgs(tls, interp, int64(1), objv, __ccgo_ts+93526)
		return int32(TCL_ERROR)
	}
	oPtr = XTcl_GetObjectFromObj(tls, interp, *(*uintptr)(unsafe.Pointer(objv + 1*8)))
	if oPtr == libc.UintptrFromInt32(0) {
		return int32(TCL_ERROR)
	}
	i = int32(2)
	for {
		if !(i < objc) {
			break
		}
		if XTcl_GetIndexFromObjStruct(tls, interp, *(*uintptr)(unsafe.Pointer(objv + uintptr(i)*8)), uintptr(unsafe.Pointer(&_propOptNames)), libc.Int64FromUint64(libc.Uint64FromInt64(8)), __ccgo_ts+11057, libc.Int32FromInt32(0)|libc.Int32FromUint64(libc.Uint64FromInt64(4)<<libc.Int32FromInt32(1)), bp) != TCL_OK {
			return int32(TCL_ERROR)
		}
		switch *(*int32)(unsafe.Pointer(bp)) {
		case int32(PROP_ALL):
			all = int32(1)
		case int32(PROP_READABLE):
			writable = 0
		case int32(PROP_WRITABLE):
			writable = int32(1)
			break
		}
		goto _1
	_1:
		;
		i++
	}
	/*
	 * Get the properties.
	 */
	if all != 0 {
		result = XTclOOGetAllObjectProperties(tls, oPtr, writable)
	} else {
		if writable != 0 {
			result = XTclOOGetPropertyList(tls, oPtr+192+16)
		} else {
			result = XTclOOGetPropertyList(tls, oPtr+192)
		}
		_SortPropList(tls, result)
	}
	XTcl_SetObjResult(tls, interp, result)
	return TCL_OK
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOOReleasePropertyStorage --
 *
 *	Delete the memory associated with a class or object's properties.
 *
 * ----------------------------------------------------------------------
 */

func _ReleasePropertyList(tls *libc.TLS, propList uintptr) {
	var _objPtr, propertyObj, v3 uintptr
	var i, v2 TTcl_Size
	_, _, _, _, _ = _objPtr, i, propertyObj, v2, v3
	i = 0
	for {
		if !(i < (*TPropertyList)(unsafe.Pointer(propList)).Fnum) {
			break
		}
		if *(*uintptr)(unsafe.Pointer((*TPropertyList)(unsafe.Pointer(propList)).Flist + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
			goto _1
		} else {
			propertyObj = *(*uintptr)(unsafe.Pointer((*TPropertyList)(unsafe.Pointer(propList)).Flist + uintptr(i)*8))
			if libc.Int32FromInt32(1) != 0 {
				_objPtr = propertyObj
				v3 = _objPtr
				v2 = *(*TTcl_Size)(unsafe.Pointer(v3))
				*(*TTcl_Size)(unsafe.Pointer(v3))--
				if v2 <= int64(1) {
					XTclFreeObj(tls, _objPtr)
				}
			}
		}
		goto _1
	_1:
		;
		i++
	}
	XTclpFree(tls, (*TPropertyList)(unsafe.Pointer(propList)).Flist)
	(*TPropertyList)(unsafe.Pointer(propList)).Flist = libc.UintptrFromInt32(0)
	(*TPropertyList)(unsafe.Pointer(propList)).Fnum = 0
}

func XTclOOReleasePropertyStorage(tls *libc.TLS, propsPtr uintptr) {
	var _objPtr, _objPtr1, v2, v4 uintptr
	var v1, v3 TTcl_Size
	_, _, _, _, _, _ = _objPtr, _objPtr1, v1, v2, v3, v4
	if (*TPropertyStorage)(unsafe.Pointer(propsPtr)).FallReadableCache != 0 {
		_objPtr = (*TPropertyStorage)(unsafe.Pointer(propsPtr)).FallReadableCache
		v2 = _objPtr
		v1 = *(*TTcl_Size)(unsafe.Pointer(v2))
		*(*TTcl_Size)(unsafe.Pointer(v2))--
		if v1 <= int64(1) {
			XTclFreeObj(tls, _objPtr)
		}
	}
	if (*TPropertyStorage)(unsafe.Pointer(propsPtr)).FallWritableCache != 0 {
		_objPtr1 = (*TPropertyStorage)(unsafe.Pointer(propsPtr)).FallWritableCache
		v4 = _objPtr1
		v3 = *(*TTcl_Size)(unsafe.Pointer(v4))
		*(*TTcl_Size)(unsafe.Pointer(v4))--
		if v3 <= int64(1) {
			XTclFreeObj(tls, _objPtr1)
		}
	}
	if (*TPropertyStorage)(unsafe.Pointer(propsPtr)).Freadable.Fnum != 0 {
		_ReleasePropertyList(tls, propsPtr)
	}
	if (*TPropertyStorage)(unsafe.Pointer(propsPtr)).Fwritable.Fnum != 0 {
		_ReleasePropertyList(tls, propsPtr+16)
	}
}

/* !BEGIN!: Do not edit below this line. */

var _tclOOIntStubs = TTclOOIntStubs{
	Fmagic: libc.Int32FromUint32(0xFCA3BACB) + libc.Int32FromInt64(8),
}

func init() {
	p := unsafe.Pointer(&_tclOOIntStubs)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(XTclOOGetDefineCmdContext)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(XTclOOMakeProcInstanceMethod)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(XTclOOMakeProcMethod)
	*(*uintptr)(unsafe.Add(p, 40)) = __ccgo_fp(XTclOONewProcInstanceMethod)
	*(*uintptr)(unsafe.Add(p, 48)) = __ccgo_fp(XTclOONewProcMethod)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(XTclOOObjectCmdCore)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(XTclOOIsReachable)
	*(*uintptr)(unsafe.Add(p, 72)) = __ccgo_fp(XTclOONewForwardMethod)
	*(*uintptr)(unsafe.Add(p, 80)) = __ccgo_fp(XTclOONewForwardInstanceMethod)
	*(*uintptr)(unsafe.Add(p, 88)) = __ccgo_fp(XTclOONewProcInstanceMethodEx)
	*(*uintptr)(unsafe.Add(p, 96)) = __ccgo_fp(XTclOONewProcMethodEx)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(XTclOOInvokeObject)
	*(*uintptr)(unsafe.Add(p, 112)) = __ccgo_fp(XTclOOObjectSetFilters)
	*(*uintptr)(unsafe.Add(p, 120)) = __ccgo_fp(XTclOOClassSetFilters)
	*(*uintptr)(unsafe.Add(p, 128)) = __ccgo_fp(XTclOOObjectSetMixins)
	*(*uintptr)(unsafe.Add(p, 136)) = __ccgo_fp(XTclOOClassSetMixins)
}

var _tclOOStubHooks = TTclOOStubHooks{
	FtclOOIntStubs: uintptr(unsafe.Pointer(&_tclOOIntStubs)),
}

func init() {
	p := unsafe.Pointer(&XtclOOStubs)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(XTcl_CopyObjectInstance)
	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(XTcl_GetClassAsObject)
	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(XTcl_GetObjectAsClass)
	*(*uintptr)(unsafe.Add(p, 40)) = __ccgo_fp(XTcl_GetObjectCommand)
	*(*uintptr)(unsafe.Add(p, 48)) = __ccgo_fp(XTcl_GetObjectFromObj)
	*(*uintptr)(unsafe.Add(p, 56)) = __ccgo_fp(XTcl_GetObjectNamespace)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(XTcl_MethodDeclarerClass)
	*(*uintptr)(unsafe.Add(p, 72)) = __ccgo_fp(XTcl_MethodDeclarerObject)
	*(*uintptr)(unsafe.Add(p, 80)) = __ccgo_fp(XTcl_MethodIsPublic)
	*(*uintptr)(unsafe.Add(p, 88)) = __ccgo_fp(XTcl_MethodIsType)
	*(*uintptr)(unsafe.Add(p, 96)) = __ccgo_fp(XTcl_MethodName)
	*(*uintptr)(unsafe.Add(p, 104)) = __ccgo_fp(XTcl_NewInstanceMethod)
	*(*uintptr)(unsafe.Add(p, 112)) = __ccgo_fp(XTcl_NewMethod)
	*(*uintptr)(unsafe.Add(p, 120)) = __ccgo_fp(XTcl_NewObjectInstance)
	*(*uintptr)(unsafe.Add(p, 128)) = __ccgo_fp(XTcl_ObjectDeleted)
	*(*uintptr)(unsafe.Add(p, 136)) = __ccgo_fp(XTcl_ObjectContextIsFiltering)
	*(*uintptr)(unsafe.Add(p, 144)) = __ccgo_fp(XTcl_ObjectContextMethod)
	*(*uintptr)(unsafe.Add(p, 152)) = __ccgo_fp(XTcl_ObjectContextObject)
	*(*uintptr)(unsafe.Add(p, 160)) = __ccgo_fp(XTcl_ObjectContextSkippedArgs)
	*(*uintptr)(unsafe.Add(p, 168)) = __ccgo_fp(XTcl_ClassGetMetadata)
	*(*uintptr)(unsafe.Add(p, 176)) = __ccgo_fp(XTcl_ClassSetMetadata)
	*(*uintptr)(unsafe.Add(p, 184)) = __ccgo_fp(XTcl_ObjectGetMetadata)
	*(*uintptr)(unsafe.Add(p, 192)) = __ccgo_fp(XTcl_ObjectSetMetadata)
	*(*uintptr)(unsafe.Add(p, 200)) = __ccgo_fp(XTcl_ObjectContextInvokeNext)
	*(*uintptr)(unsafe.Add(p, 208)) = __ccgo_fp(XTcl_ObjectGetMethodNameMapper)
	*(*uintptr)(unsafe.Add(p, 216)) = __ccgo_fp(XTcl_ObjectSetMethodNameMapper)
	*(*uintptr)(unsafe.Add(p, 224)) = __ccgo_fp(XTcl_ClassSetConstructor)
	*(*uintptr)(unsafe.Add(p, 232)) = __ccgo_fp(XTcl_ClassSetDestructor)
	*(*uintptr)(unsafe.Add(p, 240)) = __ccgo_fp(XTcl_GetObjectName)
	*(*uintptr)(unsafe.Add(p, 248)) = __ccgo_fp(XTcl_MethodIsPrivate)
	*(*uintptr)(unsafe.Add(p, 256)) = __ccgo_fp(XTcl_GetClassOfObject)
	*(*uintptr)(unsafe.Add(p, 264)) = __ccgo_fp(XTcl_GetObjectClassName)
	*(*uintptr)(unsafe.Add(p, 272)) = __ccgo_fp(XTcl_MethodIsType2)
	*(*uintptr)(unsafe.Add(p, 280)) = __ccgo_fp(XTcl_NewInstanceMethod2)
	*(*uintptr)(unsafe.Add(p, 288)) = __ccgo_fp(XTcl_NewMethod2)
}

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 *----------------------------------------------------------------------
 *
 * TclpDlopen --
 *
 *	This procedure is called to carry out dynamic loading of binary code;
 *	it is intended for use only on systems that don't support dynamic
 *	loading (it returns an error).
 *
 * Results:
 *	The result is TCL_ERROR, and an error message is left in the interp's
 *	result.
 *
 * Side effects:
 *	None.
 *
 *----------------------------------------------------------------------
 */

func XTclpDlopen(tls *libc.TLS, interp uintptr, pathPtr uintptr, loadHandle uintptr, unloadProcPtr uintptr, flags int32) (r int32) {
	if interp != 0 {
		XTcl_SetObjResult(tls, interp, XTcl_NewStringObj(tls, __ccgo_ts+93547, int64(-int32(1))))
	}
	return int32(TCL_ERROR)
}

const WORDS_BIGENDIAN = 1

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* reverse an array, used for radix code */
func XTclBN_mp_reverse(tls *libc.TLS, s uintptr, len1 Tsize_t) {
	var ix, iy Tsize_t
	var t uint8
	_, _, _ = ix, iy, t
	ix = 0
	iy = len1 - uint64(1)
	for ix < iy {
		t = *(*uint8)(unsafe.Pointer(s + uintptr(ix)))
		*(*uint8)(unsafe.Pointer(s + uintptr(ix))) = *(*uint8)(unsafe.Pointer(s + uintptr(iy)))
		*(*uint8)(unsafe.Pointer(s + uintptr(iy))) = t
		ix++
		iy--
	}
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* Fast (comba) multiplier
//	 *
//	 * This is the fast column-array [comba] multiplier.  It is
//	 * designed to compute the columns of the product first
//	 * then handle the carries afterwards.  This has the effect
//	 * of making the nested loops that compute the columns very
//	 * simple and schedulable on super-scalar processors.
//	 *
//	 * This has been modified to produce a variable number of
//	 * digits of output so if say only a half-product is required
//	 * you don't have to compute the upper half (a feature
//	 * required for fast Barrett reduction).
//	 *
//	 * Based on Algorithm 14.12 on pp.595 of HAC.
//	 *
//	 */
func XTclBN_mp_mul_digs_fast(tls *libc.TLS, a uintptr, b uintptr, c uintptr, digs int32) (r Tmp_err) {
	var W [512]Tmp_digit
	var _W Tmp_word
	var err, v1 Tmp_err
	var ix, iy, iz, olduse, pa, tx, ty, zd_, v11, v2, v4, v5 int32
	var tmpc, tmpx, tmpy, zm_, v10, v12, v7, v8 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = W, _W, err, ix, iy, iz, olduse, pa, tmpc, tmpx, tmpy, tx, ty, zd_, zm_, v1, v10, v11, v12, v2, v4, v5, v7, v8
	if digs < 0 {
		return -int32(3)
	}
	/* grow the destination as required */
	if (*Tmp_int)(unsafe.Pointer(c)).Falloc < digs {
		v1 = XTclBN_mp_grow(tls, c, digs)
		err = v1
		if v1 != MP_OKAY {
			return err
		}
	}
	/* number of output digits to produce */
	if digs < (*Tmp_int)(unsafe.Pointer(a)).Fused+(*Tmp_int)(unsafe.Pointer(b)).Fused {
		v2 = digs
	} else {
		v2 = (*Tmp_int)(unsafe.Pointer(a)).Fused + (*Tmp_int)(unsafe.Pointer(b)).Fused
	}
	pa = v2
	/* clear the carry */
	_W = uint64(0)
	ix = 0
	for {
		if !(ix < pa) {
			break
		}
		/* get offsets into the two bignums */
		if (*Tmp_int)(unsafe.Pointer(b)).Fused-int32(1) < ix {
			v4 = (*Tmp_int)(unsafe.Pointer(b)).Fused - int32(1)
		} else {
			v4 = ix
		}
		ty = v4
		tx = ix - ty
		/* setup temp aliases */
		tmpx = (*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr(tx)*4
		tmpy = (*Tmp_int)(unsafe.Pointer(b)).Fdp + uintptr(ty)*4
		/* this is the number of times the loop will iterrate, essentially
		   while (tx++ < a->used && ty-- >= 0) { ... }
		*/
		if (*Tmp_int)(unsafe.Pointer(a)).Fused-tx < ty+int32(1) {
			v5 = (*Tmp_int)(unsafe.Pointer(a)).Fused - tx
		} else {
			v5 = ty + int32(1)
		}
		iy = v5
		/* execute loop */
		iz = 0
		for {
			if !(iz < iy) {
				break
			}
			v7 = tmpx
			tmpx += 4
			v8 = tmpy
			tmpy -= 4
			_W += uint64(*(*Tmp_digit)(unsafe.Pointer(v7))) * uint64(*(*Tmp_digit)(unsafe.Pointer(v8)))
			goto _6
		_6:
			;
			iz++
		}
		/* store term */
		W[ix] = uint32(_W) & (libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1))
		/* make next carry */
		_W = _W >> libc.Uint64FromInt32(MP_DIGIT_BIT)
		goto _3
	_3:
		;
		ix++
	}
	/* setup dest */
	olduse = (*Tmp_int)(unsafe.Pointer(c)).Fused
	(*Tmp_int)(unsafe.Pointer(c)).Fused = pa
	tmpc = (*Tmp_int)(unsafe.Pointer(c)).Fdp
	ix = 0
	for {
		if !(ix < pa) {
			break
		}
		/* now extract the previous digit [below the carry] */
		v10 = tmpc
		tmpc += 4
		*(*Tmp_digit)(unsafe.Pointer(v10)) = W[ix]
		goto _9
	_9:
		;
		ix++
	}
	/* clear unused digits [that existed in the old copy of c] */
	zd_ = olduse - ix
	zm_ = tmpc
	for {
		v11 = zd_
		zd_--
		if !(v11 > 0) {
			break
		}
		v12 = zm_
		zm_ += 4
		*(*Tmp_digit)(unsafe.Pointer(v12)) = uint32(0)
	}
	XTclBN_mp_clamp(tls, c)
	return MP_OKAY
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

/* the jist of squaring...
 * you do like mult except the offset of the tmpx [one that
 * starts closer to zero] can't equal the offset of tmpy.
 * So basically you set up iy like before then you min it with
 * (ty-tx) so that it never happens.  You double all those
 * you add in the inner loop

After that loop you do the squares and add them in.
*/

func XTclBN_mp_sqr_fast(tls *libc.TLS, a uintptr, b uintptr) (r Tmp_err) {
	var W [512]Tmp_digit
	var W1, _W Tmp_word
	var err, v1 Tmp_err
	var ix, iy, iz, olduse, pa, tx, ty, zd_, v11, v3, v4, v5 int32
	var tmpb, tmpx, tmpy, zm_, v10, v12, v7, v8 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = W, W1, _W, err, ix, iy, iz, olduse, pa, tmpb, tmpx, tmpy, tx, ty, zd_, zm_, v1, v10, v11, v12, v3, v4, v5, v7, v8
	/* grow the destination as required */
	pa = (*Tmp_int)(unsafe.Pointer(a)).Fused + (*Tmp_int)(unsafe.Pointer(a)).Fused
	if (*Tmp_int)(unsafe.Pointer(b)).Falloc < pa {
		v1 = XTclBN_mp_grow(tls, b, pa)
		err = v1
		if v1 != MP_OKAY {
			return err
		}
	}
	/* number of output digits to produce */
	W1 = uint64(0)
	ix = 0
	for {
		if !(ix < pa) {
			break
		}
		/* clear counter */
		_W = uint64(0)
		/* get offsets into the two bignums */
		if (*Tmp_int)(unsafe.Pointer(a)).Fused-int32(1) < ix {
			v3 = (*Tmp_int)(unsafe.Pointer(a)).Fused - int32(1)
		} else {
			v3 = ix
		}
		ty = v3
		tx = ix - ty
		/* setup temp aliases */
		tmpx = (*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr(tx)*4
		tmpy = (*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr(ty)*4
		/* this is the number of times the loop will iterrate, essentially
		   while (tx++ < a->used && ty-- >= 0) { ... }
		*/
		if (*Tmp_int)(unsafe.Pointer(a)).Fused-tx < ty+int32(1) {
			v4 = (*Tmp_int)(unsafe.Pointer(a)).Fused - tx
		} else {
			v4 = ty + int32(1)
		}
		iy = v4
		/* now for squaring tx can never equal ty
		 * we halve the distance since they approach at a rate of 2x
		 * and we have to round because odd cases need to be executed
		 */
		if iy < (ty-tx+int32(1))>>int32(1) {
			v5 = iy
		} else {
			v5 = (ty - tx + int32(1)) >> int32(1)
		}
		iy = v5
		/* execute loop */
		iz = 0
		for {
			if !(iz < iy) {
				break
			}
			v7 = tmpx
			tmpx += 4
			v8 = tmpy
			tmpy -= 4
			_W += uint64(*(*Tmp_digit)(unsafe.Pointer(v7))) * uint64(*(*Tmp_digit)(unsafe.Pointer(v8)))
			goto _6
		_6:
			;
			iz++
		}
		/* double the inner product and add carry */
		_W = _W + _W + W1
		/* even columns have the square term in them */
		if libc.Uint32FromInt32(ix)&uint32(1) == 0 {
			_W += uint64(*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr(ix>>int32(1))*4))) * uint64(*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr(ix>>int32(1))*4)))
		}
		/* store it */
		W[ix] = uint32(_W) & (libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1))
		/* make next carry */
		W1 = _W >> libc.Uint64FromInt32(MP_DIGIT_BIT)
		goto _2
	_2:
		;
		ix++
	}
	/* setup dest */
	olduse = (*Tmp_int)(unsafe.Pointer(b)).Fused
	(*Tmp_int)(unsafe.Pointer(b)).Fused = (*Tmp_int)(unsafe.Pointer(a)).Fused + (*Tmp_int)(unsafe.Pointer(a)).Fused
	tmpb = (*Tmp_int)(unsafe.Pointer(b)).Fdp
	ix = 0
	for {
		if !(ix < pa) {
			break
		}
		v10 = tmpb
		tmpb += 4
		*(*Tmp_digit)(unsafe.Pointer(v10)) = W[ix] & (libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1))
		goto _9
	_9:
		;
		ix++
	}
	/* clear unused digits [that existed in the old copy of c] */
	zd_ = olduse - ix
	zm_ = tmpb
	for {
		v11 = zd_
		zd_--
		if !(v11 > 0) {
			break
		}
		v12 = zm_
		zm_ += 4
		*(*Tmp_digit)(unsafe.Pointer(v12)) = uint32(0)
	}
	XTclBN_mp_clamp(tls, b)
	return MP_OKAY
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* high level addition (handles signs) */
func XTclBN_mp_add(tls *libc.TLS, a uintptr, b uintptr, c uintptr) (r Tmp_err) {
	var err Tmp_err
	var sa, sb Tmp_sign
	_, _, _ = err, sa, sb
	/* get sign of both inputs */
	sa = (*Tmp_int)(unsafe.Pointer(a)).Fsign
	sb = (*Tmp_int)(unsafe.Pointer(b)).Fsign
	/* handle two cases, not four */
	if sa == sb {
		/* both positive or both negative */
		/* add their magnitudes, copy the sign */
		(*Tmp_int)(unsafe.Pointer(c)).Fsign = sa
		err = XTclBN_s_mp_add(tls, a, b, c)
	} else {
		/* one positive, the other negative */
		/* subtract the one with the greater magnitude from */
		/* the one of the lesser magnitude.  The result gets */
		/* the sign of the one with the greater magnitude. */
		if XTclBN_mp_cmp_mag(tls, a, b) == -int32(1) {
			(*Tmp_int)(unsafe.Pointer(c)).Fsign = sb
			err = XTclBN_s_mp_sub(tls, b, a, c)
		} else {
			(*Tmp_int)(unsafe.Pointer(c)).Fsign = sa
			err = XTclBN_s_mp_sub(tls, a, b, c)
		}
	}
	return err
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* two complement and */
func XTclBN_mp_and(tls *libc.TLS, a uintptr, b uintptr, c uintptr) (r Tmp_err) {
	var ac, bc, cc, x, y Tmp_digit
	var csign Tmp_sign
	var err, v3 Tmp_err
	var i, used, v1, v2 int32
	var v5, v7 uint32
	var v6, v8 uint64
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = ac, bc, cc, csign, err, i, used, x, y, v1, v2, v3, v5, v6, v7, v8
	if (*Tmp_int)(unsafe.Pointer(a)).Fused > (*Tmp_int)(unsafe.Pointer(b)).Fused {
		v1 = (*Tmp_int)(unsafe.Pointer(a)).Fused
	} else {
		v1 = (*Tmp_int)(unsafe.Pointer(b)).Fused
	}
	used = v1 + int32(1)
	ac = uint32(1)
	bc = uint32(1)
	cc = uint32(1)
	if (*Tmp_int)(unsafe.Pointer(a)).Fsign == int32(MP_NEG) && (*Tmp_int)(unsafe.Pointer(b)).Fsign == int32(MP_NEG) {
		v2 = int32(MP_NEG)
	} else {
		v2 = MP_ZPOS
	}
	csign = v2
	if (*Tmp_int)(unsafe.Pointer(c)).Falloc < used {
		v3 = XTclBN_mp_grow(tls, c, used)
		err = v3
		if v3 != MP_OKAY {
			return err
		}
	}
	i = 0
	for {
		if !(i < used) {
			break
		}
		/* convert to two complement if negative */
		if (*Tmp_int)(unsafe.Pointer(a)).Fsign == int32(MP_NEG) {
			if i >= (*Tmp_int)(unsafe.Pointer(a)).Fused {
				v5 = libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1)
			} else {
				v5 = ^*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr(i)*4)) & (libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1))
			}
			ac += v5
			x = ac & (libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1))
			ac >>= uint32(MP_DIGIT_BIT)
		} else {
			if i >= (*Tmp_int)(unsafe.Pointer(a)).Fused {
				v6 = 0
			} else {
				v6 = uint64(*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr(i)*4)))
			}
			x = uint32(v6)
		}
		/* convert to two complement if negative */
		if (*Tmp_int)(unsafe.Pointer(b)).Fsign == int32(MP_NEG) {
			if i >= (*Tmp_int)(unsafe.Pointer(b)).Fused {
				v7 = libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1)
			} else {
				v7 = ^*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(b)).Fdp + uintptr(i)*4)) & (libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1))
			}
			bc += v7
			y = bc & (libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1))
			bc >>= uint32(MP_DIGIT_BIT)
		} else {
			if i >= (*Tmp_int)(unsafe.Pointer(b)).Fused {
				v8 = 0
			} else {
				v8 = uint64(*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(b)).Fdp + uintptr(i)*4)))
			}
			y = uint32(v8)
		}
		*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(c)).Fdp + uintptr(i)*4)) = x & y
		/* convert to to sign-magnitude if negative */
		if csign == int32(MP_NEG) {
			cc += ^*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(c)).Fdp + uintptr(i)*4)) & (libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1))
			*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(c)).Fdp + uintptr(i)*4)) = cc & (libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1))
			cc >>= uint32(MP_DIGIT_BIT)
		}
		goto _4
	_4:
		;
		i++
	}
	(*Tmp_int)(unsafe.Pointer(c)).Fused = used
	(*Tmp_int)(unsafe.Pointer(c)).Fsign = csign
	XTclBN_mp_clamp(tls, c)
	return MP_OKAY
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* single digit addition */
func XTclBN_mp_add_d(tls *libc.TLS, a uintptr, b Tmp_digit, c uintptr) (r Tmp_err) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var err, v1 Tmp_err
	var ix, oldused, zd_, v8 int32
	var mu Tmp_digit
	var tmpa, tmpc, zm_, v3, v4, v5, v6, v7, v9 uintptr
	var _ /* a_ at bp+0 */ Tmp_int
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = err, ix, mu, oldused, tmpa, tmpc, zd_, zm_, v1, v3, v4, v5, v6, v7, v8, v9
	/* grow c as required */
	if (*Tmp_int)(unsafe.Pointer(c)).Falloc < (*Tmp_int)(unsafe.Pointer(a)).Fused+int32(1) {
		v1 = XTclBN_mp_grow(tls, c, (*Tmp_int)(unsafe.Pointer(a)).Fused+int32(1))
		err = v1
		if v1 != MP_OKAY {
			return err
		}
	}
	/* if a is negative and |a| >= b, call c = |a| - b */
	if (*Tmp_int)(unsafe.Pointer(a)).Fsign == int32(MP_NEG) && ((*Tmp_int)(unsafe.Pointer(a)).Fused > int32(1) || *(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp)) >= b) {
		*(*Tmp_int)(unsafe.Pointer(bp)) = *(*Tmp_int)(unsafe.Pointer(a))
		/* temporarily fix sign of a */
		(*(*Tmp_int)(unsafe.Pointer(bp))).Fsign = MP_ZPOS
		/* c = |a| - b */
		err = XTclBN_mp_sub_d(tls, bp, b, c)
		/* fix sign  */
		(*Tmp_int)(unsafe.Pointer(c)).Fsign = int32(MP_NEG)
		/* clamp */
		XTclBN_mp_clamp(tls, c)
		return err
	}
	/* old number of used digits in c */
	oldused = (*Tmp_int)(unsafe.Pointer(c)).Fused
	/* source alias */
	tmpa = (*Tmp_int)(unsafe.Pointer(a)).Fdp
	/* destination alias */
	tmpc = (*Tmp_int)(unsafe.Pointer(c)).Fdp
	/* if a is positive */
	if (*Tmp_int)(unsafe.Pointer(a)).Fsign == MP_ZPOS {
		/* add digits, mu is carry */
		mu = b
		ix = 0
		for {
			if !(ix < (*Tmp_int)(unsafe.Pointer(a)).Fused) {
				break
			}
			v3 = tmpa
			tmpa += 4
			*(*Tmp_digit)(unsafe.Pointer(tmpc)) = *(*Tmp_digit)(unsafe.Pointer(v3)) + mu
			mu = *(*Tmp_digit)(unsafe.Pointer(tmpc)) >> int32(MP_DIGIT_BIT)
			v4 = tmpc
			tmpc += 4
			*(*Tmp_digit)(unsafe.Pointer(v4)) &= libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1)
			goto _2
		_2:
			;
			ix++
		}
		/* set final carry */
		ix++
		v5 = tmpc
		tmpc += 4
		*(*Tmp_digit)(unsafe.Pointer(v5)) = mu
		/* setup size */
		(*Tmp_int)(unsafe.Pointer(c)).Fused = (*Tmp_int)(unsafe.Pointer(a)).Fused + int32(1)
	} else {
		/* a was negative and |a| < b */
		(*Tmp_int)(unsafe.Pointer(c)).Fused = int32(1)
		/* the result is a single digit */
		if (*Tmp_int)(unsafe.Pointer(a)).Fused == int32(1) {
			v6 = tmpc
			tmpc += 4
			*(*Tmp_digit)(unsafe.Pointer(v6)) = b - *(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp))
		} else {
			v7 = tmpc
			tmpc += 4
			*(*Tmp_digit)(unsafe.Pointer(v7)) = b
		}
		/* setup count so the clearing of oldused
		 * can fall through correctly
		 */
		ix = int32(1)
	}
	/* sign always positive */
	(*Tmp_int)(unsafe.Pointer(c)).Fsign = MP_ZPOS
	/* now zero to oldused */
	zd_ = oldused - ix
	zm_ = tmpc
	for {
		v8 = zd_
		zd_--
		if !(v8 > 0) {
			break
		}
		v9 = zm_
		zm_ += 4
		*(*Tmp_digit)(unsafe.Pointer(v9)) = uint32(0)
	}
	XTclBN_mp_clamp(tls, c)
	return MP_OKAY
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* trim unused digits
//	 *
//	 * This is used to ensure that leading zero digits are
//	 * trimed and the leading "used" digit will be non-zero
//	 * Typically very fast.  Also fixes the sign if there
//	 * are no more leading digits
//	 */
func XTclBN_mp_clamp(tls *libc.TLS, a uintptr) {
	/* decrease used while the most significant digit is
	 * zero.
	 */
	for (*Tmp_int)(unsafe.Pointer(a)).Fused > 0 && *(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr((*Tmp_int)(unsafe.Pointer(a)).Fused-int32(1))*4)) == 0 {
		(*Tmp_int)(unsafe.Pointer(a)).Fused--
	}
	/* reset the sign flag if used == 0 */
	if (*Tmp_int)(unsafe.Pointer(a)).Fused == 0 {
		(*Tmp_int)(unsafe.Pointer(a)).Fsign = MP_ZPOS
	}
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* clear one (frees)  */
func XTclBN_mp_clear(tls *libc.TLS, a uintptr) {
	var fd_, v3 int32
	var fm_, zm_, v2 uintptr
	var fs_, zs_, v1 Tsize_t
	_, _, _, _, _, _, _, _ = fd_, fm_, fs_, zm_, zs_, v1, v2, v3
	/* only do anything if a hasn't been freed previously */
	if (*Tmp_int)(unsafe.Pointer(a)).Fdp != libc.UintptrFromInt32(0) {
		/* free ram */
		fd_ = (*Tmp_int)(unsafe.Pointer(a)).Falloc
		fm_ = (*Tmp_int)(unsafe.Pointer(a)).Fdp
		if fm_ != libc.UintptrFromInt32(0) {
			fs_ = uint64(4) * libc.Uint64FromInt32(fd_)
			zs_ = fs_
			zm_ = fm_
			for {
				v1 = zs_
				zs_--
				if !(v1 > 0) {
					break
				}
				v2 = zm_
				zm_++
				*(*uint8)(unsafe.Pointer(v2)) = uint8('\000')
			}
			_ = fs_
			XTcl_Free(tls, fm_)
		}
		/* reset members to make debugging easier */
		(*Tmp_int)(unsafe.Pointer(a)).Fdp = libc.UintptrFromInt32(0)
		v3 = libc.Int32FromInt32(0)
		(*Tmp_int)(unsafe.Pointer(a)).Fused = v3
		(*Tmp_int)(unsafe.Pointer(a)).Falloc = v3
		(*Tmp_int)(unsafe.Pointer(a)).Fsign = MP_ZPOS
	}
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

func XTclBN_mp_clear_multi(tls *libc.TLS, mp uintptr, va uintptr) {
	var args Tva_list
	var next_mp uintptr
	_, _ = args, next_mp
	next_mp = mp
	args = va
	for next_mp != libc.UintptrFromInt32(0) {
		XTclBN_mp_clear(tls, next_mp)
		next_mp = libc.VaUintptr(&args)
	}
	_ = args
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* compare two ints (signed)*/
func XTclBN_mp_cmp(tls *libc.TLS, a uintptr, b uintptr) (r Tmp_ord) {
	/* compare based on sign */
	if (*Tmp_int)(unsafe.Pointer(a)).Fsign != (*Tmp_int)(unsafe.Pointer(b)).Fsign {
		if (*Tmp_int)(unsafe.Pointer(a)).Fsign == int32(MP_NEG) {
			return -int32(1)
		} else {
			return int32(MP_GT)
		}
	}
	/* compare digits */
	if (*Tmp_int)(unsafe.Pointer(a)).Fsign == int32(MP_NEG) {
		/* if negative compare opposite direction */
		return XTclBN_mp_cmp_mag(tls, b, a)
	} else {
		return XTclBN_mp_cmp_mag(tls, a, b)
	}
	return r
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* compare a digit */
func XTclBN_mp_cmp_d(tls *libc.TLS, a uintptr, b Tmp_digit) (r Tmp_ord) {
	/* compare based on sign */
	if (*Tmp_int)(unsafe.Pointer(a)).Fsign == int32(MP_NEG) {
		return -int32(1)
	}
	/* compare based on magnitude */
	if (*Tmp_int)(unsafe.Pointer(a)).Fused > int32(1) {
		return int32(MP_GT)
	}
	/* compare the only digit of a to b */
	if *(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp)) > b {
		return int32(MP_GT)
	} else {
		if *(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp)) < b {
			return -int32(1)
		} else {
			return MP_EQ
		}
	}
	return r
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* compare maginitude of two ints (unsigned) */
func XTclBN_mp_cmp_mag(tls *libc.TLS, a uintptr, b uintptr) (r Tmp_ord) {
	var n int32
	var tmpa, tmpb uintptr
	_, _, _ = n, tmpa, tmpb
	/* compare based on # of non-zero digits */
	if (*Tmp_int)(unsafe.Pointer(a)).Fused > (*Tmp_int)(unsafe.Pointer(b)).Fused {
		return int32(MP_GT)
	}
	if (*Tmp_int)(unsafe.Pointer(a)).Fused < (*Tmp_int)(unsafe.Pointer(b)).Fused {
		return -int32(1)
	}
	/* alias for a */
	tmpa = (*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr((*Tmp_int)(unsafe.Pointer(a)).Fused-libc.Int32FromInt32(1))*4
	/* alias for b */
	tmpb = (*Tmp_int)(unsafe.Pointer(b)).Fdp + uintptr((*Tmp_int)(unsafe.Pointer(a)).Fused-libc.Int32FromInt32(1))*4
	/* compare based on digits  */
	n = 0
	for {
		if !(n < (*Tmp_int)(unsafe.Pointer(a)).Fused) {
			break
		}
		if *(*Tmp_digit)(unsafe.Pointer(tmpa)) > *(*Tmp_digit)(unsafe.Pointer(tmpb)) {
			return int32(MP_GT)
		}
		if *(*Tmp_digit)(unsafe.Pointer(tmpa)) < *(*Tmp_digit)(unsafe.Pointer(tmpb)) {
			return -int32(1)
		}
		goto _1
	_1:
		;
		n++
		tmpa -= 4
		tmpb -= 4
	}
	return MP_EQ
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

var _lnz = [16]int32{
	0:  int32(4),
	2:  int32(1),
	4:  int32(2),
	6:  int32(1),
	8:  int32(3),
	10: int32(1),
	12: int32(2),
	14: int32(1),
}

// C documentation
//
//	/* Counts the number of lsbs which are zero before the first zero bit */
func XTclBN_mp_cnt_lsb(tls *libc.TLS, a uintptr) (r int32) {
	var q, qq Tmp_digit
	var x int32
	_, _, _ = q, qq, x
	/* easy out */
	if (*Tmp_int)(unsafe.Pointer(a)).Fused == 0 {
		return 0
	}
	/* scan lower digits until non-zero */
	x = 0
	for {
		if !(x < (*Tmp_int)(unsafe.Pointer(a)).Fused && *(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr(x)*4)) == 0) {
			break
		}
		goto _1
	_1:
		;
		x++
	}
	q = *(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr(x)*4))
	x *= int32(MP_DIGIT_BIT)
	/* now scan this digit until a 1 is found */
	if q&uint32(1) == 0 {
		for cond := true; cond; cond = qq == 0 {
			qq = q & uint32(15)
			x += _lnz[qq]
			q >>= uint32(4)
		}
	}
	return x
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* copy, b = a */
func XTclBN_mp_copy(tls *libc.TLS, a uintptr, b uintptr) (r Tmp_err) {
	var err, v1 Tmp_err
	var n, zd_, v5 int32
	var tmpa, tmpb, zm_, v3, v4, v6 uintptr
	_, _, _, _, _, _, _, _, _, _, _ = err, n, tmpa, tmpb, zd_, zm_, v1, v3, v4, v5, v6
	/* if dst == src do nothing */
	if a == b {
		return MP_OKAY
	}
	/* grow dest */
	if (*Tmp_int)(unsafe.Pointer(b)).Falloc < (*Tmp_int)(unsafe.Pointer(a)).Fused {
		v1 = XTclBN_mp_grow(tls, b, (*Tmp_int)(unsafe.Pointer(a)).Fused)
		err = v1
		if v1 != MP_OKAY {
			return err
		}
	}
	/* zero b and copy the parameters over */
	/* pointer aliases */
	/* source */
	tmpa = (*Tmp_int)(unsafe.Pointer(a)).Fdp
	/* destination */
	tmpb = (*Tmp_int)(unsafe.Pointer(b)).Fdp
	/* copy all the digits */
	n = 0
	for {
		if !(n < (*Tmp_int)(unsafe.Pointer(a)).Fused) {
			break
		}
		v3 = tmpb
		tmpb += 4
		v4 = tmpa
		tmpa += 4
		*(*Tmp_digit)(unsafe.Pointer(v3)) = *(*Tmp_digit)(unsafe.Pointer(v4))
		goto _2
	_2:
		;
		n++
	}
	/* clear high digits */
	zd_ = (*Tmp_int)(unsafe.Pointer(b)).Fused - n
	zm_ = tmpb
	for {
		v5 = zd_
		zd_--
		if !(v5 > 0) {
			break
		}
		v6 = zm_
		zm_ += 4
		*(*Tmp_digit)(unsafe.Pointer(v6)) = uint32(0)
	}
	/* copy used count and sign */
	(*Tmp_int)(unsafe.Pointer(b)).Fused = (*Tmp_int)(unsafe.Pointer(a)).Fused
	(*Tmp_int)(unsafe.Pointer(b)).Fsign = (*Tmp_int)(unsafe.Pointer(a)).Fsign
	return MP_OKAY
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* returns the number of bits in an int */
func XTclBN_mp_count_bits(tls *libc.TLS, a uintptr) (r1 int32) {
	var q Tmp_digit
	var r int32
	_, _ = q, r
	/* shortcut */
	if (*Tmp_int)(unsafe.Pointer(a)).Fused == 0 {
		return 0
	}
	/* get number of digits and add that */
	r = ((*Tmp_int)(unsafe.Pointer(a)).Fused - int32(1)) * int32(MP_DIGIT_BIT)
	/* take the last digit and count the bits in it */
	q = *(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr((*Tmp_int)(unsafe.Pointer(a)).Fused-int32(1))*4))
	for q > 0 {
		r++
		q >>= uint32(1)
	}
	return r
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* integer signed division.
//	 * c*b + d == a [e.g. a/b, c=quotient, d=remainder]
//	 * HAC pp.598 Algorithm 14.20
//	 *
//	 * Note that the description in HAC is horribly
//	 * incomplete.  For example, it doesn't consider
//	 * the case where digits are removed from 'x' in
//	 * the inner loop.  It also doesn't consider the
//	 * case that y has fewer than three digits, etc..
//	 *
//	 * The overall algorithm is as described as
//	 * 14.20 from HAC but fixed to treat these cases.
//	*/
func XTclBN_mp_div(tls *libc.TLS, a uintptr, b uintptr, c uintptr, d uintptr) (r Tmp_err) {
	bp := tls.Alloc(128)
	defer tls.Free(128)
	var err, v1, v10, v11, v14, v16, v17, v18, v19, v2, v20, v21, v23, v3, v4, v5, v8, v9 Tmp_err
	var i, n, norm, t, v22, v6 int32
	var neg, v7 Tmp_sign
	var tmp Tmp_word
	var v13, v15 uint32
	var _ /* q at bp+0 */ Tmp_int
	var _ /* t1 at bp+72 */ Tmp_int
	var _ /* t2 at bp+96 */ Tmp_int
	var _ /* x at bp+24 */ Tmp_int
	var _ /* y at bp+48 */ Tmp_int
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = err, i, n, neg, norm, t, tmp, v1, v10, v11, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v3, v4, v5, v6, v7, v8, v9
	/* is divisor zero ? */
	if (*Tmp_int)(unsafe.Pointer(b)).Fused == 0 {
		return -int32(3)
	}
	/* if a < b then q=0, r = a */
	if XTclBN_mp_cmp_mag(tls, a, b) == -int32(1) {
		if d != libc.UintptrFromInt32(0) {
			err = XTclBN_mp_copy(tls, a, d)
		} else {
			err = MP_OKAY
		}
		if c != libc.UintptrFromInt32(0) {
			XTclBN_mp_zero(tls, c)
		}
		return err
	}
	v1 = XTclBN_mp_init_size(tls, bp, (*Tmp_int)(unsafe.Pointer(a)).Fused+int32(2))
	err = v1
	if v1 != MP_OKAY {
		return err
	}
	(*(*Tmp_int)(unsafe.Pointer(bp))).Fused = (*Tmp_int)(unsafe.Pointer(a)).Fused + int32(2)
	v2 = XTclBN_mp_init(tls, bp+72)
	err = v2
	if v2 != MP_OKAY {
		goto LBL_Q
	}
	v3 = XTclBN_mp_init(tls, bp+96)
	err = v3
	if v3 != MP_OKAY {
		goto LBL_T1
	}
	v4 = XTclBN_mp_init_copy(tls, bp+24, a)
	err = v4
	if v4 != MP_OKAY {
		goto LBL_T2
	}
	v5 = XTclBN_mp_init_copy(tls, bp+48, b)
	err = v5
	if v5 != MP_OKAY {
		goto LBL_X
	}
	/* fix the sign */
	if (*Tmp_int)(unsafe.Pointer(a)).Fsign == (*Tmp_int)(unsafe.Pointer(b)).Fsign {
		v6 = MP_ZPOS
	} else {
		v6 = int32(MP_NEG)
	}
	neg = v6
	v7 = libc.Int32FromInt32(MP_ZPOS)
	(*(*Tmp_int)(unsafe.Pointer(bp + 48))).Fsign = v7
	(*(*Tmp_int)(unsafe.Pointer(bp + 24))).Fsign = v7
	/* normalize both x and y, ensure that y >= b/2, [b == 2**MP_DIGIT_BIT] */
	norm = XTclBN_mp_count_bits(tls, bp+48) % int32(MP_DIGIT_BIT)
	if norm < libc.Int32FromInt32(MP_DIGIT_BIT)-libc.Int32FromInt32(1) {
		norm = libc.Int32FromInt32(MP_DIGIT_BIT) - libc.Int32FromInt32(1) - norm
		v8 = XTclBN_mp_mul_2d(tls, bp+24, norm, bp+24)
		err = v8
		if v8 != MP_OKAY {
			goto LBL_Y
		}
		v9 = XTclBN_mp_mul_2d(tls, bp+48, norm, bp+48)
		err = v9
		if v9 != MP_OKAY {
			goto LBL_Y
		}
	} else {
		norm = 0
	}
	/* note hac does 0 based, so if used==5 then its 0,1,2,3,4, e.g. use 4 */
	n = (*(*Tmp_int)(unsafe.Pointer(bp + 24))).Fused - int32(1)
	t = (*(*Tmp_int)(unsafe.Pointer(bp + 48))).Fused - int32(1)
	/* while (x >= y*b**n-t) do { q[n-t] += 1; x -= y*b**{n-t} } */
	/* y = y*b**{n-t} */
	v10 = XTclBN_mp_lshd(tls, bp+48, n-t)
	err = v10
	if v10 != MP_OKAY {
		goto LBL_Y
	}
	for XTclBN_mp_cmp(tls, bp+24, bp+48) != -int32(1) {
		*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp + uintptr(n-t)*4))++
		v11 = XTclBN_mp_sub(tls, bp+24, bp+48, bp+24)
		err = v11
		if v11 != MP_OKAY {
			goto LBL_Y
		}
	}
	/* reset y by shifting it back down */
	XTclBN_mp_rshd(tls, bp+48, n-t)
	/* step 3. for i from n down to (t + 1) */
	i = n
	for {
		if !(i >= t+int32(1)) {
			break
		}
		if i > (*(*Tmp_int)(unsafe.Pointer(bp + 24))).Fused {
			goto _12
		}
		/* step 3.1 if xi == yt then set q{i-t-1} to b-1,
		 * otherwise set q{i-t-1} to (xi*b + x{i-1})/yt */
		if *(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 24))).Fdp + uintptr(i)*4)) == *(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 48))).Fdp + uintptr(t)*4)) {
			*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp + uintptr(i-t-int32(1))*4)) = libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1)
		} else {
			tmp = uint64(*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 24))).Fdp + uintptr(i)*4))) << libc.Uint64FromInt32(MP_DIGIT_BIT)
			tmp |= uint64(*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 24))).Fdp + uintptr(i-int32(1))*4)))
			tmp /= uint64(*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 48))).Fdp + uintptr(t)*4)))
			if tmp > uint64(libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT)-libc.Uint32FromInt32(1)) {
				tmp = uint64(libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1))
			}
			*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp + uintptr(i-t-int32(1))*4)) = uint32(tmp & uint64(libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT)-libc.Uint32FromInt32(1)))
		}
		/* while (q{i-t-1} * (yt * b + y{t-1})) >
		         xi * b**2 + xi-1 * b + xi-2
		   do q{i-t-1} -= 1;
		*/
		*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp + uintptr(i-t-int32(1))*4)) = uint32((uint64(*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp + uintptr(i-t-int32(1))*4))) + uint64(1)) & uint64(libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT)-libc.Uint32FromInt32(1)))
		for cond := true; cond; cond = XTclBN_mp_cmp_mag(tls, bp+72, bp+96) == int32(MP_GT) {
			*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp + uintptr(i-t-int32(1))*4)) = uint32((uint64(*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp + uintptr(i-t-int32(1))*4))) - uint64(1)) & uint64(libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT)-libc.Uint32FromInt32(1)))
			/* find left hand */
			XTclBN_mp_zero(tls, bp+72)
			if t-int32(1) < 0 {
				v13 = 0
			} else {
				v13 = *(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 48))).Fdp + uintptr(t-int32(1))*4))
			}
			*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 72))).Fdp)) = v13
			*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 72))).Fdp + 1*4)) = *(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 48))).Fdp + uintptr(t)*4))
			(*(*Tmp_int)(unsafe.Pointer(bp + 72))).Fused = int32(2)
			v14 = XTclBN_mp_mul_d(tls, bp+72, *(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp + uintptr(i-t-int32(1))*4)), bp+72)
			err = v14
			if v14 != MP_OKAY {
				goto LBL_Y
			}
			/* find right hand */
			if i-int32(2) < 0 {
				v15 = 0
			} else {
				v15 = *(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 24))).Fdp + uintptr(i-int32(2))*4))
			}
			*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 96))).Fdp)) = v15
			*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 96))).Fdp + 1*4)) = *(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 24))).Fdp + uintptr(i-int32(1))*4)) /* i >= 1 always holds */
			*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 96))).Fdp + 2*4)) = *(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 24))).Fdp + uintptr(i)*4))
			(*(*Tmp_int)(unsafe.Pointer(bp + 96))).Fused = int32(3)
		}
		/* step 3.3 x = x - q{i-t-1} * y * b**{i-t-1} */
		v16 = XTclBN_mp_mul_d(tls, bp+48, *(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp + uintptr(i-t-int32(1))*4)), bp+72)
		err = v16
		if v16 != MP_OKAY {
			goto LBL_Y
		}
		v17 = XTclBN_mp_lshd(tls, bp+72, i-t-int32(1))
		err = v17
		if v17 != MP_OKAY {
			goto LBL_Y
		}
		v18 = XTclBN_mp_sub(tls, bp+24, bp+72, bp+24)
		err = v18
		if v18 != MP_OKAY {
			goto LBL_Y
		}
		/* if x < 0 then { x = x + y*b**{i-t-1}; q{i-t-1} -= 1; } */
		if (*(*Tmp_int)(unsafe.Pointer(bp + 24))).Fsign == int32(MP_NEG) {
			v19 = XTclBN_mp_copy(tls, bp+48, bp+72)
			err = v19
			if v19 != MP_OKAY {
				goto LBL_Y
			}
			v20 = XTclBN_mp_lshd(tls, bp+72, i-t-int32(1))
			err = v20
			if v20 != MP_OKAY {
				goto LBL_Y
			}
			v21 = XTclBN_mp_add(tls, bp+24, bp+72, bp+24)
			err = v21
			if v21 != MP_OKAY {
				goto LBL_Y
			}
			*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp + uintptr(i-t-int32(1))*4)) = uint32((uint64(*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp + uintptr(i-t-int32(1))*4))) - uint64(1)) & uint64(libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT)-libc.Uint32FromInt32(1)))
		}
		goto _12
	_12:
		;
		i--
	}
	/* now q is the quotient and x is the remainder
	 * [which we have to normalize]
	 */
	/* get sign before writing to c */
	if (*(*Tmp_int)(unsafe.Pointer(bp + 24))).Fused == 0 {
		v22 = MP_ZPOS
	} else {
		v22 = (*Tmp_int)(unsafe.Pointer(a)).Fsign
	}
	(*(*Tmp_int)(unsafe.Pointer(bp + 24))).Fsign = v22
	if c != libc.UintptrFromInt32(0) {
		XTclBN_mp_clamp(tls, bp)
		XTclBN_mp_exch(tls, bp, c)
		(*Tmp_int)(unsafe.Pointer(c)).Fsign = neg
	}
	if d != libc.UintptrFromInt32(0) {
		v23 = XTclBN_mp_div_2d(tls, bp+24, norm, bp+24, libc.UintptrFromInt32(0))
		err = v23
		if v23 != MP_OKAY {
			goto LBL_Y
		}
		XTclBN_mp_exch(tls, bp+24, d)
	}
	err = MP_OKAY
	goto LBL_Y
LBL_Y:
	;
	XTclBN_mp_clear(tls, bp+48)
	goto LBL_X
LBL_X:
	;
	XTclBN_mp_clear(tls, bp+24)
	goto LBL_T2
LBL_T2:
	;
	XTclBN_mp_clear(tls, bp+96)
	goto LBL_T1
LBL_T1:
	;
	XTclBN_mp_clear(tls, bp+72)
	goto LBL_Q
LBL_Q:
	;
	XTclBN_mp_clear(tls, bp)
	return err
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* single digit division (based on routine from MPI) */
func XTclBN_mp_div_d(tls *libc.TLS, a uintptr, b Tmp_digit, c uintptr, d uintptr) (r Tmp_err) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var err, v1 Tmp_err
	var ix int32
	var t Tmp_digit
	var w Tmp_word
	var _ /* q at bp+0 */ Tmp_int
	_, _, _, _, _ = err, ix, t, w, v1
	/* cannot divide by zero */
	if b == 0 {
		return -int32(3)
	}
	/* quick outs */
	if b == uint32(1) || (*Tmp_int)(unsafe.Pointer(a)).Fused == 0 {
		if d != libc.UintptrFromInt32(0) {
			*(*Tmp_digit)(unsafe.Pointer(d)) = uint32(0)
		}
		if c != libc.UintptrFromInt32(0) {
			return XTclBN_mp_copy(tls, a, c)
		}
		return MP_OKAY
	}
	/* power of two ? */
	if b&(b-uint32(1)) == 0 {
		ix = int32(1)
		for ix < int32(MP_DIGIT_BIT) && b != libc.Uint32FromInt32(1)<<ix {
			ix++
		}
		if d != libc.UintptrFromInt32(0) {
			*(*Tmp_digit)(unsafe.Pointer(d)) = uint32(uint64(*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp))) & (uint64(libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(ix)) - uint64(1)))
		}
		if c != libc.UintptrFromInt32(0) {
			return XTclBN_mp_div_2d(tls, a, ix, c, libc.UintptrFromInt32(0))
		}
		return MP_OKAY
	}
	/* three? */
	if libc.Bool(uint64(1) == uint64(1)) && b == uint32(3) {
		return XTclBN_mp_div_3(tls, a, c, d)
	}
	/* no easy answer [c'est la vie].  Just division */
	v1 = XTclBN_mp_init_size(tls, bp, (*Tmp_int)(unsafe.Pointer(a)).Fused)
	err = v1
	if v1 != MP_OKAY {
		return err
	}
	(*(*Tmp_int)(unsafe.Pointer(bp))).Fused = (*Tmp_int)(unsafe.Pointer(a)).Fused
	(*(*Tmp_int)(unsafe.Pointer(bp))).Fsign = (*Tmp_int)(unsafe.Pointer(a)).Fsign
	w = uint64(0)
	ix = (*Tmp_int)(unsafe.Pointer(a)).Fused - int32(1)
	for {
		if !(ix >= 0) {
			break
		}
		w = w<<libc.Uint64FromInt32(MP_DIGIT_BIT) | uint64(*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr(ix)*4)))
		if w >= uint64(b) {
			t = uint32(w / uint64(b))
			w -= uint64(t) * uint64(b)
		} else {
			t = uint32(0)
		}
		*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp + uintptr(ix)*4)) = t
		goto _2
	_2:
		;
		ix--
	}
	if d != libc.UintptrFromInt32(0) {
		*(*Tmp_digit)(unsafe.Pointer(d)) = uint32(w)
	}
	if c != libc.UintptrFromInt32(0) {
		XTclBN_mp_clamp(tls, bp)
		XTclBN_mp_exch(tls, bp, c)
	}
	XTclBN_mp_clear(tls, bp)
	return err
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* b = a/2 */
func XTclBN_mp_div_2(tls *libc.TLS, a uintptr, b uintptr) (r1 Tmp_err) {
	var err, v1 Tmp_err
	var oldused, x, zd_, v5 int32
	var r, rr Tmp_digit
	var tmpa, tmpb, zm_, v3, v4, v6 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = err, oldused, r, rr, tmpa, tmpb, x, zd_, zm_, v1, v3, v4, v5, v6
	/* copy */
	if (*Tmp_int)(unsafe.Pointer(b)).Falloc < (*Tmp_int)(unsafe.Pointer(a)).Fused {
		v1 = XTclBN_mp_grow(tls, b, (*Tmp_int)(unsafe.Pointer(a)).Fused)
		err = v1
		if v1 != MP_OKAY {
			return err
		}
	}
	oldused = (*Tmp_int)(unsafe.Pointer(b)).Fused
	(*Tmp_int)(unsafe.Pointer(b)).Fused = (*Tmp_int)(unsafe.Pointer(a)).Fused
	/* source alias */
	tmpa = (*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr((*Tmp_int)(unsafe.Pointer(b)).Fused)*4 - uintptr(1)*4
	/* dest alias */
	tmpb = (*Tmp_int)(unsafe.Pointer(b)).Fdp + uintptr((*Tmp_int)(unsafe.Pointer(b)).Fused)*4 - uintptr(1)*4
	/* carry */
	r = uint32(0)
	x = (*Tmp_int)(unsafe.Pointer(b)).Fused - int32(1)
	for {
		if !(x >= 0) {
			break
		}
		/* get the carry for the next iteration */
		rr = *(*Tmp_digit)(unsafe.Pointer(tmpa)) & uint32(1)
		/* shift the current digit, add in carry and store */
		v3 = tmpb
		tmpb -= 4
		v4 = tmpa
		tmpa -= 4
		*(*Tmp_digit)(unsafe.Pointer(v3)) = *(*Tmp_digit)(unsafe.Pointer(v4))>>libc.Int32FromInt32(1) | r<<(libc.Int32FromInt32(MP_DIGIT_BIT)-libc.Int32FromInt32(1))
		/* forward carry to next iteration */
		r = rr
		goto _2
	_2:
		;
		x--
	}
	/* zero excess digits */
	zd_ = oldused - (*Tmp_int)(unsafe.Pointer(b)).Fused
	zm_ = (*Tmp_int)(unsafe.Pointer(b)).Fdp + uintptr((*Tmp_int)(unsafe.Pointer(b)).Fused)*4
	for {
		v5 = zd_
		zd_--
		if !(v5 > 0) {
			break
		}
		v6 = zm_
		zm_ += 4
		*(*Tmp_digit)(unsafe.Pointer(v6)) = uint32(0)
	}
	(*Tmp_int)(unsafe.Pointer(b)).Fsign = (*Tmp_int)(unsafe.Pointer(a)).Fsign
	XTclBN_mp_clamp(tls, b)
	return MP_OKAY
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* shift right by a certain bit count (store quotient in c, optional remainder in d) */
func XTclBN_mp_div_2d(tls *libc.TLS, a uintptr, b int32, c uintptr, d uintptr) (r1 Tmp_err) {
	var D, mask, r, rr, shift Tmp_digit
	var err, v1, v2 Tmp_err
	var tmpc uintptr
	var x int32
	_, _, _, _, _, _, _, _, _, _ = D, err, mask, r, rr, shift, tmpc, x, v1, v2
	/* if the shift count is <= 0 then we do no work */
	if b <= 0 {
		err = XTclBN_mp_copy(tls, a, c)
		if d != libc.UintptrFromInt32(0) {
			XTclBN_mp_zero(tls, d)
		}
		return err
	}
	/* copy */
	v1 = XTclBN_mp_copy(tls, a, c)
	err = v1
	if v1 != MP_OKAY {
		return err
	}
	/* 'a' should not be used after here - it might be the same as d */
	/* get the remainder */
	if d != libc.UintptrFromInt32(0) {
		v2 = XTclBN_mp_mod_2d(tls, a, b, d)
		err = v2
		if v2 != MP_OKAY {
			return err
		}
	}
	/* shift by as many digits in the bit count */
	if b >= int32(MP_DIGIT_BIT) {
		XTclBN_mp_rshd(tls, c, b/int32(MP_DIGIT_BIT))
	}
	/* shift any bit count < MP_DIGIT_BIT */
	D = libc.Uint32FromInt32(b % libc.Int32FromInt32(MP_DIGIT_BIT))
	if D != 0 {
		/* mask */
		mask = uint32(uint64(libc.Uint32FromInt32(1)<<D) - uint64(1))
		/* shift for lsb */
		shift = libc.Uint32FromInt32(MP_DIGIT_BIT) - D
		/* alias */
		tmpc = (*Tmp_int)(unsafe.Pointer(c)).Fdp + uintptr((*Tmp_int)(unsafe.Pointer(c)).Fused-libc.Int32FromInt32(1))*4
		/* carry */
		r = uint32(0)
		x = (*Tmp_int)(unsafe.Pointer(c)).Fused - int32(1)
		for {
			if !(x >= 0) {
				break
			}
			/* get the lower  bits of this word in a temp */
			rr = *(*Tmp_digit)(unsafe.Pointer(tmpc)) & mask
			/* shift the current word and mix in the carry bits from the previous word */
			*(*Tmp_digit)(unsafe.Pointer(tmpc)) = *(*Tmp_digit)(unsafe.Pointer(tmpc))>>D | r<<shift
			tmpc -= 4
			/* set the carry to the carry bits of the current word found above */
			r = rr
			goto _3
		_3:
			;
			x--
		}
	}
	XTclBN_mp_clamp(tls, c)
	return MP_OKAY
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* divide by three (based on routine from MPI and the GMP manual) */
func XTclBN_mp_div_3(tls *libc.TLS, a uintptr, c uintptr, d uintptr) (r Tmp_err) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var b Tmp_digit
	var err, v1 Tmp_err
	var ix int32
	var t, w Tmp_word
	var _ /* q at bp+0 */ Tmp_int
	_, _, _, _, _, _ = b, err, ix, t, w, v1
	/* b = 2**MP_DIGIT_BIT / 3 */
	b = uint32(libc.Uint64FromInt32(1) << libc.Uint64FromInt32(MP_DIGIT_BIT) / libc.Uint64FromInt32(3))
	v1 = XTclBN_mp_init_size(tls, bp, (*Tmp_int)(unsafe.Pointer(a)).Fused)
	err = v1
	if v1 != MP_OKAY {
		return err
	}
	(*(*Tmp_int)(unsafe.Pointer(bp))).Fused = (*Tmp_int)(unsafe.Pointer(a)).Fused
	(*(*Tmp_int)(unsafe.Pointer(bp))).Fsign = (*Tmp_int)(unsafe.Pointer(a)).Fsign
	w = uint64(0)
	ix = (*Tmp_int)(unsafe.Pointer(a)).Fused - int32(1)
	for {
		if !(ix >= 0) {
			break
		}
		w = w<<libc.Uint64FromInt32(MP_DIGIT_BIT) | uint64(*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr(ix)*4)))
		if w >= uint64(3) {
			/* multiply w by [1/3] */
			t = w * uint64(b) >> libc.Uint64FromInt32(MP_DIGIT_BIT)
			/* now subtract 3 * [w/3] from w, to get the remainder */
			w -= t + t + t
			/* fixup the remainder as required since
			 * the optimization is not exact.
			 */
			for w >= uint64(3) {
				t += uint64(1)
				w -= uint64(3)
			}
		} else {
			t = uint64(0)
		}
		*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp + uintptr(ix)*4)) = uint32(t)
		goto _2
	_2:
		;
		ix--
	}
	/* [optional] store the remainder */
	if d != libc.UintptrFromInt32(0) {
		*(*Tmp_digit)(unsafe.Pointer(d)) = uint32(w)
	}
	/* [optional] store the quotient */
	if c != libc.UintptrFromInt32(0) {
		XTclBN_mp_clamp(tls, bp)
		XTclBN_mp_exch(tls, bp, c)
	}
	XTclBN_mp_clear(tls, bp)
	return err
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* swap the elements of two integers, for cases where you can't simply swap the
//	 * mp_int pointers around
//	 */
func XTclBN_mp_exch(tls *libc.TLS, a uintptr, b uintptr) {
	var t Tmp_int
	_ = t
	t = *(*Tmp_int)(unsafe.Pointer(a))
	*(*Tmp_int)(unsafe.Pointer(a)) = *(*Tmp_int)(unsafe.Pointer(b))
	*(*Tmp_int)(unsafe.Pointer(b)) = t
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* calculate c = a**b  using a square-multiply algorithm */
func XTclBN_mp_expt_n(tls *libc.TLS, a uintptr, b int32, c uintptr) (r Tmp_err) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var err, v1, v2, v3 Tmp_err
	var _ /* g at bp+0 */ Tmp_int
	_, _, _, _ = err, v1, v2, v3
	v1 = XTclBN_mp_init_copy(tls, bp, a)
	err = v1
	if v1 != MP_OKAY {
		return err
	}
	/* set initial result */
	XTclBN_mp_set_i64(tls, c, int64(libc.Int32FromUint64(libc.Uint64FromUint64(1))))
	for b > 0 {
		/* if the bit is set multiply */
		if b&int32(1) != 0 {
			v2 = XTclBN_mp_mul(tls, c, bp, c)
			err = v2
			if v2 != MP_OKAY {
				goto LBL_ERR
			}
		}
		/* square */
		if b > int32(1) {
			v3 = XTclBN_mp_sqr(tls, bp, bp)
			err = v3
			if v3 != MP_OKAY {
				goto LBL_ERR
			}
		}
		/* shift to next bit */
		b >>= int32(1)
	}
	goto LBL_ERR
LBL_ERR:
	;
	XTclBN_mp_clear(tls, bp)
	return err
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */
func XTclBN_mp_get_mag_u64(tls *libc.TLS, a uintptr) (r Tuint64_t) {
	var i, v1, v2 uint32
	var res Tuint64_t
	_, _, _, _ = i, res, v1, v2
	if libc.Uint32FromInt32((*Tmp_int)(unsafe.Pointer(a)).Fused) < uint32((libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8)+libc.Uint64FromInt32(MP_DIGIT_BIT)-libc.Uint64FromInt32(1))/libc.Uint64FromInt32(MP_DIGIT_BIT)) {
		v1 = libc.Uint32FromInt32((*Tmp_int)(unsafe.Pointer(a)).Fused)
	} else {
		v1 = uint32((libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8) + libc.Uint64FromInt32(MP_DIGIT_BIT) - libc.Uint64FromInt32(1)) / libc.Uint64FromInt32(MP_DIGIT_BIT))
	}
	i = v1
	res = 0
	for {
		v2 = i
		i--
		if !(v2 > 0) {
			break
		}
		res <<= libc.Uint64FromInt32(libc.Int32FromInt32(MP_DIGIT_BIT))
		res |= uint64(*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr(i)*4)))
		if libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8) <= uint64(MP_DIGIT_BIT) {
			break
		}
	}
	return res
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* grow as required */
func XTclBN_mp_grow(tls *libc.TLS, a uintptr, size int32) (r Tmp_err) {
	var i, zd_, v1 int32
	var tmp, zm_, v2 uintptr
	_, _, _, _, _, _ = i, tmp, zd_, zm_, v1, v2
	if size < 0 {
		return -int32(3)
	}
	/* if the alloc size is smaller alloc more ram */
	if (*Tmp_int)(unsafe.Pointer(a)).Falloc < size {
		/* reallocate the array a->dp
		 *
		 * We store the return in a temporary variable
		 * in case the operation failed we don't want
		 * to overwrite the dp member of a.
		 */
		_ = libc.Uint64FromInt32((*Tmp_int)(unsafe.Pointer(a)).Falloc) * libc.Uint64FromInt64(4)
		tmp = XTcl_AttemptRealloc(tls, (*Tmp_int)(unsafe.Pointer(a)).Fdp, libc.Uint64FromInt32(size)*libc.Uint64FromInt64(4))
		if tmp == libc.UintptrFromInt32(0) {
			/* reallocation failed but "a" is still valid [can be freed] */
			return -int32(2)
		}
		/* reallocation succeeded so set a->dp */
		(*Tmp_int)(unsafe.Pointer(a)).Fdp = tmp
		/* zero excess digits */
		i = (*Tmp_int)(unsafe.Pointer(a)).Falloc
		(*Tmp_int)(unsafe.Pointer(a)).Falloc = size
		zd_ = (*Tmp_int)(unsafe.Pointer(a)).Falloc - i
		zm_ = (*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr(i)*4
		for {
			v1 = zd_
			zd_--
			if !(v1 > 0) {
				break
			}
			v2 = zm_
			zm_ += 4
			*(*Tmp_digit)(unsafe.Pointer(v2)) = uint32(0)
		}
	}
	return MP_OKAY
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* init a new mp_int */
func XTclBN_mp_init(tls *libc.TLS, a uintptr) (r Tmp_err) {
	/* allocate memory required and clear it */
	(*Tmp_int)(unsafe.Pointer(a)).Fdp = libc.Xmemset(tls, XTcl_AttemptAlloc(tls, libc.Uint64FromInt32(MP_PREC)*libc.Uint64FromInt64(4)), 0, libc.Uint64FromInt32(MP_PREC)*libc.Uint64FromInt64(4))
	if (*Tmp_int)(unsafe.Pointer(a)).Fdp == libc.UintptrFromInt32(0) {
		return -int32(2)
	}
	/* set the used to zero, allocated digits to the default precision
	 * and sign to positive */
	(*Tmp_int)(unsafe.Pointer(a)).Fused = 0
	(*Tmp_int)(unsafe.Pointer(a)).Falloc = int32(MP_PREC)
	(*Tmp_int)(unsafe.Pointer(a)).Fsign = MP_ZPOS
	return MP_OKAY
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* creates "a" then copies b into it */
func XTclBN_mp_init_copy(tls *libc.TLS, a uintptr, b uintptr) (r Tmp_err) {
	var err, v1, v2 Tmp_err
	_, _, _ = err, v1, v2
	v1 = XTclBN_mp_init_size(tls, a, (*Tmp_int)(unsafe.Pointer(b)).Fused)
	err = v1
	if v1 != MP_OKAY {
		return err
	}
	v2 = XTclBN_mp_copy(tls, b, a)
	err = v2
	if v2 != MP_OKAY {
		XTclBN_mp_clear(tls, a)
	}
	return err
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

func XTclBN_mp_init_multi(tls *libc.TLS, mp uintptr, va uintptr) (r Tmp_err) {
	var args, clean_args Tva_list
	var cur_arg uintptr
	var err Tmp_err
	var n, v1 int32
	_, _, _, _, _, _ = args, clean_args, cur_arg, err, n, v1
	err = MP_OKAY /* Assume ok until proven otherwise */
	n = 0         /* Number of ok inits */
	cur_arg = mp
	args = va /* init args to next argument from caller */
	for cur_arg != libc.UintptrFromInt32(0) {
		if XTclBN_mp_init(tls, cur_arg) != MP_OKAY {
			/* now start cleaning up */
			cur_arg = mp
			clean_args = va
			for {
				v1 = n
				n--
				if !(v1 != 0) {
					break
				}
				XTclBN_mp_clear(tls, cur_arg)
				cur_arg = libc.VaUintptr(&clean_args)
			}
			_ = clean_args
			err = -int32(2)
			break
		}
		n++
		cur_arg = libc.VaUintptr(&args)
	}
	_ = args
	return err /* Assumed ok, if error flagged above. */
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* initialize and set a digit */
func XTclBN_mp_init_set(tls *libc.TLS, a uintptr, b Tmp_digit) (r Tmp_err) {
	var err, v1 Tmp_err
	_, _ = err, v1
	v1 = XTclBN_mp_init(tls, a)
	err = v1
	if v1 != MP_OKAY {
		return err
	}
	XTclBN_mp_set_i64(tls, a, int64(libc.Int32FromUint32(b)))
	return err
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* init an mp_init for a given size */
func XTclBN_mp_init_size(tls *libc.TLS, a uintptr, size int32) (r Tmp_err) {
	var v1 int32
	_ = v1
	if size < 0 {
		return -int32(3)
	}
	if (libc.Int32FromUint64(libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8))+libc.Int32FromInt32(MP_DIGIT_BIT)-libc.Int32FromInt32(1))/libc.Int32FromInt32(MP_DIGIT_BIT) > size {
		v1 = (libc.Int32FromUint64(libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8)) + libc.Int32FromInt32(MP_DIGIT_BIT) - libc.Int32FromInt32(1)) / libc.Int32FromInt32(MP_DIGIT_BIT)
	} else {
		v1 = size
	}
	size = v1
	/* alloc mem */
	(*Tmp_int)(unsafe.Pointer(a)).Fdp = libc.Xmemset(tls, XTcl_AttemptAlloc(tls, libc.Uint64FromInt32(size)*libc.Uint64FromInt64(4)), 0, libc.Uint64FromInt32(size)*libc.Uint64FromInt64(4))
	if (*Tmp_int)(unsafe.Pointer(a)).Fdp == libc.UintptrFromInt32(0) {
		return -int32(2)
	}
	/* set the members */
	(*Tmp_int)(unsafe.Pointer(a)).Fused = 0
	(*Tmp_int)(unsafe.Pointer(a)).Falloc = size
	(*Tmp_int)(unsafe.Pointer(a)).Fsign = MP_ZPOS
	return MP_OKAY
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* c = |a| * |b| using Karatsuba Multiplication using
//	 * three half size multiplications
//	 *
//	 * Let B represent the radix [e.g. 2**MP_DIGIT_BIT] and
//	 * let n represent half of the number of digits in
//	 * the min(a,b)
//	 *
//	 * a = a1 * B**n + a0
//	 * b = b1 * B**n + b0
//	 *
//	 * Then, a * b =>
//	   a1b1 * B**2n + ((a1 + a0)(b1 + b0) - (a0b0 + a1b1)) * B + a0b0
//	 *
//	 * Note that a1b1 and a0b0 are used twice and only need to be
//	 * computed once.  So in total three half size (half # of
//	 * digit) multiplications are performed, a0b0, a1b1 and
//	 * (a1+b1)(a0+b0)
//	 *
//	 * Note that a multiplication of half the digits requires
//	 * 1/4th the number of single precision multiplications so in
//	 * total after one call 25% of the single precision multiplications
//	 * are saved.  Note also that the call to mp_mul can end up back
//	 * in this function if the a0, a1, b0, or b1 are above the threshold.
//	 * This is known as divide-and-conquer and leads to the famous
//	 * O(N**lg(3)) or O(N**1.584) work which is asymptopically lower than
//	 * the standard O(N**2) that the baseline/comba methods use.
//	 * Generally though the overhead of this method doesn't pay off
//	 * until a certain size (N ~ 80) is reached.
//	 */
func XTclBN_mp_karatsuba_mul(tls *libc.TLS, a uintptr, b uintptr, c uintptr) (r Tmp_err) {
	bp := tls.Alloc(176)
	defer tls.Free(176)
	var B, x, v1, v2 int32
	var err Tmp_err
	var tmpa, tmpb, tmpx, tmpy, v10, v12, v13, v4, v5, v6, v7, v9 uintptr
	var _ /* t1 at bp+96 */ Tmp_int
	var _ /* x0 at bp+0 */ Tmp_int
	var _ /* x0y0 at bp+120 */ Tmp_int
	var _ /* x1 at bp+24 */ Tmp_int
	var _ /* x1y1 at bp+144 */ Tmp_int
	var _ /* y0 at bp+48 */ Tmp_int
	var _ /* y1 at bp+72 */ Tmp_int
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = B, err, tmpa, tmpb, tmpx, tmpy, x, v1, v10, v12, v13, v2, v4, v5, v6, v7, v9
	err = -int32(2) /* default the return code to an error */
	/* min # of digits */
	if (*Tmp_int)(unsafe.Pointer(a)).Fused < (*Tmp_int)(unsafe.Pointer(b)).Fused {
		v1 = (*Tmp_int)(unsafe.Pointer(a)).Fused
	} else {
		v1 = (*Tmp_int)(unsafe.Pointer(b)).Fused
	}
	B = v1
	/* now divide in two */
	B = B >> int32(1)
	/* init copy all the temps */
	if XTclBN_mp_init_size(tls, bp, B) != MP_OKAY {
		goto LBL_ERR
	}
	if XTclBN_mp_init_size(tls, bp+24, (*Tmp_int)(unsafe.Pointer(a)).Fused-B) != MP_OKAY {
		goto X0
	}
	if XTclBN_mp_init_size(tls, bp+48, B) != MP_OKAY {
		goto X1
	}
	if XTclBN_mp_init_size(tls, bp+72, (*Tmp_int)(unsafe.Pointer(b)).Fused-B) != MP_OKAY {
		goto Y0
	}
	/* init temps */
	if XTclBN_mp_init_size(tls, bp+96, B*int32(2)) != MP_OKAY {
		goto Y1
	}
	if XTclBN_mp_init_size(tls, bp+120, B*int32(2)) != MP_OKAY {
		goto T1
	}
	if XTclBN_mp_init_size(tls, bp+144, B*int32(2)) != MP_OKAY {
		goto X0Y0
	}
	/* now shift the digits */
	v2 = B
	(*(*Tmp_int)(unsafe.Pointer(bp + 48))).Fused = v2
	(*(*Tmp_int)(unsafe.Pointer(bp))).Fused = v2
	(*(*Tmp_int)(unsafe.Pointer(bp + 24))).Fused = (*Tmp_int)(unsafe.Pointer(a)).Fused - B
	(*(*Tmp_int)(unsafe.Pointer(bp + 72))).Fused = (*Tmp_int)(unsafe.Pointer(b)).Fused - B
	/* we copy the digits directly instead of using higher level functions
	 * since we also need to shift the digits
	 */
	tmpa = (*Tmp_int)(unsafe.Pointer(a)).Fdp
	tmpb = (*Tmp_int)(unsafe.Pointer(b)).Fdp
	tmpx = (*(*Tmp_int)(unsafe.Pointer(bp))).Fdp
	tmpy = (*(*Tmp_int)(unsafe.Pointer(bp + 48))).Fdp
	x = 0
	for {
		if !(x < B) {
			break
		}
		v4 = tmpx
		tmpx += 4
		v5 = tmpa
		tmpa += 4
		*(*Tmp_digit)(unsafe.Pointer(v4)) = *(*Tmp_digit)(unsafe.Pointer(v5))
		v6 = tmpy
		tmpy += 4
		v7 = tmpb
		tmpb += 4
		*(*Tmp_digit)(unsafe.Pointer(v6)) = *(*Tmp_digit)(unsafe.Pointer(v7))
		goto _3
	_3:
		;
		x++
	}
	tmpx = (*(*Tmp_int)(unsafe.Pointer(bp + 24))).Fdp
	x = B
	for {
		if !(x < (*Tmp_int)(unsafe.Pointer(a)).Fused) {
			break
		}
		v9 = tmpx
		tmpx += 4
		v10 = tmpa
		tmpa += 4
		*(*Tmp_digit)(unsafe.Pointer(v9)) = *(*Tmp_digit)(unsafe.Pointer(v10))
		goto _8
	_8:
		;
		x++
	}
	tmpy = (*(*Tmp_int)(unsafe.Pointer(bp + 72))).Fdp
	x = B
	for {
		if !(x < (*Tmp_int)(unsafe.Pointer(b)).Fused) {
			break
		}
		v12 = tmpy
		tmpy += 4
		v13 = tmpb
		tmpb += 4
		*(*Tmp_digit)(unsafe.Pointer(v12)) = *(*Tmp_digit)(unsafe.Pointer(v13))
		goto _11
	_11:
		;
		x++
	}
	/* only need to clamp the lower words since by definition the
	 * upper words x1/y1 must have a known number of digits
	 */
	XTclBN_mp_clamp(tls, bp)
	XTclBN_mp_clamp(tls, bp+48)
	/* now calc the products x0y0 and x1y1 */
	/* after this x0 is no longer required, free temp [x0==t2]! */
	if XTclBN_mp_mul(tls, bp, bp+48, bp+120) != MP_OKAY {
		goto X1Y1 /* x0y0 = x0*y0 */
	}
	if XTclBN_mp_mul(tls, bp+24, bp+72, bp+144) != MP_OKAY {
		goto X1Y1 /* x1y1 = x1*y1 */
	}
	/* now calc x1+x0 and y1+y0 */
	if XTclBN_s_mp_add(tls, bp+24, bp, bp+96) != MP_OKAY {
		goto X1Y1 /* t1 = x1 - x0 */
	}
	if XTclBN_s_mp_add(tls, bp+72, bp+48, bp) != MP_OKAY {
		goto X1Y1 /* t2 = y1 - y0 */
	}
	if XTclBN_mp_mul(tls, bp+96, bp, bp+96) != MP_OKAY {
		goto X1Y1 /* t1 = (x1 + x0) * (y1 + y0) */
	}
	/* add x0y0 */
	if XTclBN_mp_add(tls, bp+120, bp+144, bp) != MP_OKAY {
		goto X1Y1 /* t2 = x0y0 + x1y1 */
	}
	if XTclBN_s_mp_sub(tls, bp+96, bp, bp+96) != MP_OKAY {
		goto X1Y1 /* t1 = (x1+x0)*(y1+y0) - (x1y1 + x0y0) */
	}
	/* shift by B */
	if XTclBN_mp_lshd(tls, bp+96, B) != MP_OKAY {
		goto X1Y1 /* t1 = (x0y0 + x1y1 - (x1-x0)*(y1-y0))<<B */
	}
	if XTclBN_mp_lshd(tls, bp+144, B*int32(2)) != MP_OKAY {
		goto X1Y1 /* x1y1 = x1y1 << 2*B */
	}
	if XTclBN_mp_add(tls, bp+120, bp+96, bp+96) != MP_OKAY {
		goto X1Y1 /* t1 = x0y0 + t1 */
	}
	if XTclBN_mp_add(tls, bp+96, bp+144, c) != MP_OKAY {
		goto X1Y1 /* t1 = x0y0 + t1 + x1y1 */
	}
	/* Algorithm succeeded set the return code to MP_OKAY */
	err = MP_OKAY
	goto X1Y1
X1Y1:
	;
	XTclBN_mp_clear(tls, bp+144)
	goto X0Y0
X0Y0:
	;
	XTclBN_mp_clear(tls, bp+120)
	goto T1
T1:
	;
	XTclBN_mp_clear(tls, bp+96)
	goto Y1
Y1:
	;
	XTclBN_mp_clear(tls, bp+72)
	goto Y0
Y0:
	;
	XTclBN_mp_clear(tls, bp+48)
	goto X1
X1:
	;
	XTclBN_mp_clear(tls, bp+24)
	goto X0
X0:
	;
	XTclBN_mp_clear(tls, bp)
	goto LBL_ERR
LBL_ERR:
	;
	return err
	return r
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */
func XTclBN_mp_init_i64(tls *libc.TLS, a uintptr, b Tint64_t) (r Tmp_err) {
	var err, v1 Tmp_err
	_, _ = err, v1
	v1 = XTclBN_mp_init(tls, a)
	err = v1
	if v1 != MP_OKAY {
		return err
	}
	XTclBN_mp_set_i64(tls, a, b)
	return MP_OKAY
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */
func XTclBN_mp_init_u64(tls *libc.TLS, a uintptr, b Tuint64_t) (r Tmp_err) {
	var err, v1 Tmp_err
	_, _ = err, v1
	v1 = XTclBN_mp_init(tls, a)
	err = v1
	if v1 != MP_OKAY {
		return err
	}
	XTclBN_mp_set_u64(tls, a, b)
	return MP_OKAY
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* Karatsuba squaring, computes b = a*a using three
//	 * half size squarings
//	 *
//	 * See comments of karatsuba_mul for details.  It
//	 * is essentially the same algorithm but merely
//	 * tuned to perform recursive squarings.
//	 */
func XTclBN_mp_karatsuba_sqr(tls *libc.TLS, a uintptr, b uintptr) (r Tmp_err) {
	bp := tls.Alloc(144)
	defer tls.Free(144)
	var B, x int32
	var dst, src, v2, v3, v5, v6 uintptr
	var err Tmp_err
	var _ /* t1 at bp+48 */ Tmp_int
	var _ /* t2 at bp+72 */ Tmp_int
	var _ /* x0 at bp+0 */ Tmp_int
	var _ /* x0x0 at bp+96 */ Tmp_int
	var _ /* x1 at bp+24 */ Tmp_int
	var _ /* x1x1 at bp+120 */ Tmp_int
	_, _, _, _, _, _, _, _, _ = B, dst, err, src, x, v2, v3, v5, v6
	err = -int32(2)
	/* min # of digits */
	B = (*Tmp_int)(unsafe.Pointer(a)).Fused
	/* now divide in two */
	B = B >> int32(1)
	/* init copy all the temps */
	if XTclBN_mp_init_size(tls, bp, B) != MP_OKAY {
		goto LBL_ERR
	}
	if XTclBN_mp_init_size(tls, bp+24, (*Tmp_int)(unsafe.Pointer(a)).Fused-B) != MP_OKAY {
		goto X0
	}
	/* init temps */
	if XTclBN_mp_init_size(tls, bp+48, (*Tmp_int)(unsafe.Pointer(a)).Fused*int32(2)) != MP_OKAY {
		goto X1
	}
	if XTclBN_mp_init_size(tls, bp+72, (*Tmp_int)(unsafe.Pointer(a)).Fused*int32(2)) != MP_OKAY {
		goto T1
	}
	if XTclBN_mp_init_size(tls, bp+96, B*int32(2)) != MP_OKAY {
		goto T2
	}
	if XTclBN_mp_init_size(tls, bp+120, ((*Tmp_int)(unsafe.Pointer(a)).Fused-B)*int32(2)) != MP_OKAY {
		goto X0X0
	}
	src = (*Tmp_int)(unsafe.Pointer(a)).Fdp
	/* now shift the digits */
	dst = (*(*Tmp_int)(unsafe.Pointer(bp))).Fdp
	x = 0
	for {
		if !(x < B) {
			break
		}
		v2 = dst
		dst += 4
		v3 = src
		src += 4
		*(*Tmp_digit)(unsafe.Pointer(v2)) = *(*Tmp_digit)(unsafe.Pointer(v3))
		goto _1
	_1:
		;
		x++
	}
	dst = (*(*Tmp_int)(unsafe.Pointer(bp + 24))).Fdp
	x = B
	for {
		if !(x < (*Tmp_int)(unsafe.Pointer(a)).Fused) {
			break
		}
		v5 = dst
		dst += 4
		v6 = src
		src += 4
		*(*Tmp_digit)(unsafe.Pointer(v5)) = *(*Tmp_digit)(unsafe.Pointer(v6))
		goto _4
	_4:
		;
		x++
	}
	(*(*Tmp_int)(unsafe.Pointer(bp))).Fused = B
	(*(*Tmp_int)(unsafe.Pointer(bp + 24))).Fused = (*Tmp_int)(unsafe.Pointer(a)).Fused - B
	XTclBN_mp_clamp(tls, bp)
	/* now calc the products x0*x0 and x1*x1 */
	if XTclBN_mp_sqr(tls, bp, bp+96) != MP_OKAY {
		goto X1X1
	} /* x0x0 = x0*x0 */
	if XTclBN_mp_sqr(tls, bp+24, bp+120) != MP_OKAY {
		goto X1X1
	} /* x1x1 = x1*x1 */
	/* now calc (x1+x0)**2 */
	if XTclBN_s_mp_add(tls, bp+24, bp, bp+48) != MP_OKAY {
		goto X1X1
	} /* t1 = x1 - x0 */
	if XTclBN_mp_sqr(tls, bp+48, bp+48) != MP_OKAY {
		goto X1X1
	} /* t1 = (x1 - x0) * (x1 - x0) */
	/* add x0y0 */
	if XTclBN_s_mp_add(tls, bp+96, bp+120, bp+72) != MP_OKAY {
		goto X1X1
	} /* t2 = x0x0 + x1x1 */
	if XTclBN_s_mp_sub(tls, bp+48, bp+72, bp+48) != MP_OKAY {
		goto X1X1
	} /* t1 = (x1+x0)**2 - (x0x0 + x1x1) */
	/* shift by B */
	if XTclBN_mp_lshd(tls, bp+48, B) != MP_OKAY {
		goto X1X1
	} /* t1 = (x0x0 + x1x1 - (x1-x0)*(x1-x0))<<B */
	if XTclBN_mp_lshd(tls, bp+120, B*int32(2)) != MP_OKAY {
		goto X1X1
	} /* x1x1 = x1x1 << 2*B */
	if XTclBN_mp_add(tls, bp+96, bp+48, bp+48) != MP_OKAY {
		goto X1X1
	} /* t1 = x0x0 + t1 */
	if XTclBN_mp_add(tls, bp+48, bp+120, b) != MP_OKAY {
		goto X1X1
	} /* t1 = x0x0 + t1 + x1x1 */
	err = MP_OKAY
	goto X1X1
X1X1:
	;
	XTclBN_mp_clear(tls, bp+120)
	goto X0X0
X0X0:
	;
	XTclBN_mp_clear(tls, bp+96)
	goto T2
T2:
	;
	XTclBN_mp_clear(tls, bp+72)
	goto T1
T1:
	;
	XTclBN_mp_clear(tls, bp+48)
	goto X1
X1:
	;
	XTclBN_mp_clear(tls, bp+24)
	goto X0
X0:
	;
	XTclBN_mp_clear(tls, bp)
	goto LBL_ERR
LBL_ERR:
	;
	return err
	return r
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* single-digit multiplication with the smaller number as the single-digit */
func XTclBN_mp_balance_mul(tls *libc.TLS, a uintptr, b uintptr, c uintptr) (r Tmp_err) {
	bp := tls.Alloc(128)
	defer tls.Free(128)
	var A Tmp_int
	var bsize, count, i, j, len_a, len_b, nblocks, v1, v13, v2, v3, v8 int32
	var err, v10, v11, v14, v15, v16, v4, v5, v9 Tmp_err
	var _ /* B at bp+48 */ Tmp_int
	var _ /* a0 at bp+0 */ Tmp_int
	var _ /* r at bp+72 */ Tmp_int
	var _ /* tmp at bp+24 */ Tmp_int
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = A, bsize, count, err, i, j, len_a, len_b, nblocks, v1, v10, v11, v13, v14, v15, v16, v2, v3, v4, v5, v8, v9
	len_a = (*Tmp_int)(unsafe.Pointer(a)).Fused
	len_b = (*Tmp_int)(unsafe.Pointer(b)).Fused
	if (*Tmp_int)(unsafe.Pointer(a)).Fused > (*Tmp_int)(unsafe.Pointer(b)).Fused {
		v1 = (*Tmp_int)(unsafe.Pointer(a)).Fused
	} else {
		v1 = (*Tmp_int)(unsafe.Pointer(b)).Fused
	}
	if (*Tmp_int)(unsafe.Pointer(a)).Fused < (*Tmp_int)(unsafe.Pointer(b)).Fused {
		v2 = (*Tmp_int)(unsafe.Pointer(a)).Fused
	} else {
		v2 = (*Tmp_int)(unsafe.Pointer(b)).Fused
	}
	nblocks = v1 / v2
	if (*Tmp_int)(unsafe.Pointer(a)).Fused < (*Tmp_int)(unsafe.Pointer(b)).Fused {
		v3 = (*Tmp_int)(unsafe.Pointer(a)).Fused
	} else {
		v3 = (*Tmp_int)(unsafe.Pointer(b)).Fused
	}
	bsize = v3
	v4 = XTclBN_mp_init_size(tls, bp, bsize+int32(2))
	err = v4
	if v4 != MP_OKAY {
		return err
	}
	v5 = XTclBN_mp_init_multi(tls, bp+24, libc.VaList(bp+104, bp+72, libc.UintptrFromInt32(0)))
	err = v5
	if v5 != MP_OKAY {
		XTclBN_mp_clear(tls, bp)
		return err
	}
	/* Make sure that A is the larger one*/
	if len_a < len_b {
		*(*Tmp_int)(unsafe.Pointer(bp + 48)) = *(*Tmp_int)(unsafe.Pointer(a))
		A = *(*Tmp_int)(unsafe.Pointer(b))
	} else {
		A = *(*Tmp_int)(unsafe.Pointer(a))
		*(*Tmp_int)(unsafe.Pointer(bp + 48)) = *(*Tmp_int)(unsafe.Pointer(b))
	}
	i = 0
	j = libc.Int32FromInt32(0)
	for {
		if !(i < nblocks) {
			break
		}
		/* Cut a slice off of a */
		(*(*Tmp_int)(unsafe.Pointer(bp))).Fused = 0
		count = 0
		for {
			if !(count < bsize) {
				break
			}
			v8 = j
			j++
			*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp + uintptr(count)*4)) = *(*Tmp_digit)(unsafe.Pointer(A.Fdp + uintptr(v8)*4))
			(*(*Tmp_int)(unsafe.Pointer(bp))).Fused++
			goto _7
		_7:
			;
			count++
		}
		XTclBN_mp_clamp(tls, bp)
		/* Multiply with b */
		v9 = XTclBN_mp_mul(tls, bp, bp+48, bp+24)
		err = v9
		if v9 != MP_OKAY {
			goto LBL_ERR
		}
		/* Shift tmp to the correct position */
		v10 = XTclBN_mp_lshd(tls, bp+24, bsize*i)
		err = v10
		if v10 != MP_OKAY {
			goto LBL_ERR
		}
		/* Add to output. No carry needed */
		v11 = XTclBN_mp_add(tls, bp+72, bp+24, bp+72)
		err = v11
		if v11 != MP_OKAY {
			goto LBL_ERR
		}
		goto _6
	_6:
		;
		i++
	}
	/* The left-overs; there are always left-overs */
	if j < A.Fused {
		(*(*Tmp_int)(unsafe.Pointer(bp))).Fused = 0
		count = 0
		for {
			if !(j < A.Fused) {
				break
			}
			v13 = j
			j++
			*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp + uintptr(count)*4)) = *(*Tmp_digit)(unsafe.Pointer(A.Fdp + uintptr(v13)*4))
			(*(*Tmp_int)(unsafe.Pointer(bp))).Fused++
			goto _12
		_12:
			;
			count++
		}
		XTclBN_mp_clamp(tls, bp)
		v14 = XTclBN_mp_mul(tls, bp, bp+48, bp+24)
		err = v14
		if v14 != MP_OKAY {
			goto LBL_ERR
		}
		v15 = XTclBN_mp_lshd(tls, bp+24, bsize*i)
		err = v15
		if v15 != MP_OKAY {
			goto LBL_ERR
		}
		v16 = XTclBN_mp_add(tls, bp+72, bp+24, bp+72)
		err = v16
		if v16 != MP_OKAY {
			goto LBL_ERR
		}
	}
	XTclBN_mp_exch(tls, bp+72, c)
	goto LBL_ERR
LBL_ERR:
	;
	XTclBN_mp_clear_multi(tls, bp, libc.VaList(bp+104, bp+24, bp+72, libc.UintptrFromInt32(0)))
	return err
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* shift left a certain amount of digits */
func XTclBN_mp_lshd(tls *libc.TLS, a uintptr, b int32) (r Tmp_err) {
	var bottom, top, zm_, v3, v4, v6 uintptr
	var err, v1 Tmp_err
	var x, zd_, v5 int32
	_, _, _, _, _, _, _, _, _, _, _ = bottom, err, top, x, zd_, zm_, v1, v3, v4, v5, v6
	/* if its less than zero return */
	if b <= 0 {
		return MP_OKAY
	}
	/* no need to shift 0 around */
	if (*Tmp_int)(unsafe.Pointer(a)).Fused == 0 {
		return MP_OKAY
	}
	/* grow to fit the new digits */
	if (*Tmp_int)(unsafe.Pointer(a)).Falloc < (*Tmp_int)(unsafe.Pointer(a)).Fused+b {
		v1 = XTclBN_mp_grow(tls, a, (*Tmp_int)(unsafe.Pointer(a)).Fused+b)
		err = v1
		if v1 != MP_OKAY {
			return err
		}
	}
	/* increment the used by the shift amount then copy upwards */
	*(*int32)(unsafe.Pointer(a)) += b
	/* top */
	top = (*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr((*Tmp_int)(unsafe.Pointer(a)).Fused)*4 - uintptr(1)*4
	/* base */
	bottom = (*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr((*Tmp_int)(unsafe.Pointer(a)).Fused)*4 - uintptr(1)*4 - uintptr(b)*4
	/* much like mp_rshd this is implemented using a sliding window
	 * except the window goes the otherway around.  Copying from
	 * the bottom to the top.  see bn_mp_rshd.c for more info.
	 */
	x = (*Tmp_int)(unsafe.Pointer(a)).Fused - int32(1)
	for {
		if !(x >= b) {
			break
		}
		v3 = top
		top -= 4
		v4 = bottom
		bottom -= 4
		*(*Tmp_digit)(unsafe.Pointer(v3)) = *(*Tmp_digit)(unsafe.Pointer(v4))
		goto _2
	_2:
		;
		x--
	}
	/* zero the lower digits */
	zd_ = b
	zm_ = (*Tmp_int)(unsafe.Pointer(a)).Fdp
	for {
		v5 = zd_
		zd_--
		if !(v5 > 0) {
			break
		}
		v6 = zm_
		zm_ += 4
		*(*Tmp_digit)(unsafe.Pointer(v6)) = uint32(0)
	}
	return MP_OKAY
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* c = a mod b, 0 <= c < b if b > 0, b < c <= 0 if b < 0 */
func XTclBN_mp_mod(tls *libc.TLS, a uintptr, b uintptr, c uintptr) (r Tmp_err) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var err, v1, v2 Tmp_err
	var _ /* t at bp+0 */ Tmp_int
	_, _, _ = err, v1, v2
	v1 = XTclBN_mp_init_size(tls, bp, (*Tmp_int)(unsafe.Pointer(b)).Fused)
	err = v1
	if v1 != MP_OKAY {
		return err
	}
	v2 = XTclBN_mp_div(tls, a, b, libc.UintptrFromInt32(0), bp)
	err = v2
	if v2 != MP_OKAY {
		goto LBL_ERR
	}
	if (*Tmp_int)(unsafe.Pointer(bp)).Fused == 0 || (*(*Tmp_int)(unsafe.Pointer(bp))).Fsign == (*Tmp_int)(unsafe.Pointer(b)).Fsign {
		err = MP_OKAY
		XTclBN_mp_exch(tls, bp, c)
	} else {
		err = XTclBN_mp_add(tls, b, bp, c)
	}
	goto LBL_ERR
LBL_ERR:
	;
	XTclBN_mp_clear(tls, bp)
	return err
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* calc a value mod 2**b */
func XTclBN_mp_mod_2d(tls *libc.TLS, a uintptr, b int32, c uintptr) (r Tmp_err) {
	var err, v1 Tmp_err
	var x, zd_, v2, v3 int32
	var zm_, v4 uintptr
	_, _, _, _, _, _, _, _ = err, x, zd_, zm_, v1, v2, v3, v4
	/* if b is <= 0 then zero the int */
	if b <= 0 {
		XTclBN_mp_zero(tls, c)
		return MP_OKAY
	}
	/* if the modulus is larger than the value than return */
	if b >= (*Tmp_int)(unsafe.Pointer(a)).Fused*int32(MP_DIGIT_BIT) {
		return XTclBN_mp_copy(tls, a, c)
	}
	/* copy */
	v1 = XTclBN_mp_copy(tls, a, c)
	err = v1
	if v1 != MP_OKAY {
		return err
	}
	/* zero digits above the last digit of the modulus */
	if b%int32(MP_DIGIT_BIT) == 0 {
		v2 = 0
	} else {
		v2 = int32(1)
	}
	x = b/int32(MP_DIGIT_BIT) + v2
	zd_ = (*Tmp_int)(unsafe.Pointer(c)).Fused - x
	zm_ = (*Tmp_int)(unsafe.Pointer(c)).Fdp + uintptr(x)*4
	for {
		v3 = zd_
		zd_--
		if !(v3 > 0) {
			break
		}
		v4 = zm_
		zm_ += 4
		*(*Tmp_digit)(unsafe.Pointer(v4)) = uint32(0)
	}
	/* clear the digit that is not completely outside/inside the modulus */
	*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(c)).Fdp + uintptr(b/int32(MP_DIGIT_BIT))*4)) &= libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(b%libc.Int32FromInt32(MP_DIGIT_BIT)) - libc.Uint32FromInt32(1)
	XTclBN_mp_clamp(tls, c)
	return MP_OKAY
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* high level multiplication (handles sign) */
func XTclBN_mp_mul(tls *libc.TLS, a uintptr, b uintptr, c uintptr) (r Tmp_err) {
	var digs, max_len, min_len, v1, v2, v3, v4 int32
	var err Tmp_err
	var neg Tmp_sign
	_, _, _, _, _, _, _, _, _ = digs, err, max_len, min_len, neg, v1, v2, v3, v4
	if (*Tmp_int)(unsafe.Pointer(a)).Fused < (*Tmp_int)(unsafe.Pointer(b)).Fused {
		v1 = (*Tmp_int)(unsafe.Pointer(a)).Fused
	} else {
		v1 = (*Tmp_int)(unsafe.Pointer(b)).Fused
	}
	min_len = v1
	if (*Tmp_int)(unsafe.Pointer(a)).Fused > (*Tmp_int)(unsafe.Pointer(b)).Fused {
		v2 = (*Tmp_int)(unsafe.Pointer(a)).Fused
	} else {
		v2 = (*Tmp_int)(unsafe.Pointer(b)).Fused
	}
	max_len = v2
	digs = (*Tmp_int)(unsafe.Pointer(a)).Fused + (*Tmp_int)(unsafe.Pointer(b)).Fused + int32(1)
	if (*Tmp_int)(unsafe.Pointer(a)).Fsign == (*Tmp_int)(unsafe.Pointer(b)).Fsign {
		v3 = MP_ZPOS
	} else {
		v3 = int32(MP_NEG)
	}
	neg = v3
	if a == b {
		return XTclBN_mp_sqr(tls, a, c)
	} else {
		if libc.Bool(uint64(1) == uint64(1)) && min_len >= int32(MP_DEFAULT_KARATSUBA_MUL_CUTOFF) && max_len/int32(2) >= int32(MP_DEFAULT_KARATSUBA_MUL_CUTOFF) && max_len >= int32(2)*min_len {
			err = XTclBN_mp_balance_mul(tls, a, b, c)
		} else {
			if libc.Bool(uint64(1) == uint64(1)) && min_len >= int32(MP_DEFAULT_TOOM_MUL_CUTOFF) {
				err = XTclBN_mp_toom_mul(tls, a, b, c)
			} else {
				if libc.Bool(uint64(1) == uint64(1)) && min_len >= int32(MP_DEFAULT_KARATSUBA_MUL_CUTOFF) {
					err = XTclBN_mp_karatsuba_mul(tls, a, b, c)
				} else {
					if libc.Bool(uint64(1) == uint64(1)) && digs < libc.Int32FromInt32(1)<<(libc.Int32FromInt32(CHAR_BIT)*libc.Int32FromInt64(8)-libc.Int32FromInt32(2)*libc.Int32FromInt32(MP_DIGIT_BIT)+libc.Int32FromInt32(1)) && min_len <= libc.Int32FromUint64(libc.Uint64FromUint64(1)<<(libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8)-libc.Uint64FromUint32(2)*libc.Uint64FromInt32(MP_DIGIT_BIT))) {
						err = XTclBN_mp_mul_digs_fast(tls, a, b, c, digs)
					} else {
						if uint64(1) == uint64(1) {
							err = XTclBN_mp_mul_digs(tls, a, b, c, digs)
						} else {
							err = -int32(3)
						}
					}
				}
			}
		}
	}
	if (*Tmp_int)(unsafe.Pointer(c)).Fused > 0 {
		v4 = neg
	} else {
		v4 = MP_ZPOS
	}
	(*Tmp_int)(unsafe.Pointer(c)).Fsign = v4
	return err
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* b = a*2 */
func XTclBN_mp_mul_2(tls *libc.TLS, a uintptr, b uintptr) (r1 Tmp_err) {
	var err, v1 Tmp_err
	var oldused, x, zd_, v5 int32
	var r, rr Tmp_digit
	var tmpa, tmpb, zm_, v3, v4, v6 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = err, oldused, r, rr, tmpa, tmpb, x, zd_, zm_, v1, v3, v4, v5, v6
	/* grow to accomodate result */
	if (*Tmp_int)(unsafe.Pointer(b)).Falloc < (*Tmp_int)(unsafe.Pointer(a)).Fused+int32(1) {
		v1 = XTclBN_mp_grow(tls, b, (*Tmp_int)(unsafe.Pointer(a)).Fused+int32(1))
		err = v1
		if v1 != MP_OKAY {
			return err
		}
	}
	oldused = (*Tmp_int)(unsafe.Pointer(b)).Fused
	(*Tmp_int)(unsafe.Pointer(b)).Fused = (*Tmp_int)(unsafe.Pointer(a)).Fused
	/* alias for source */
	tmpa = (*Tmp_int)(unsafe.Pointer(a)).Fdp
	/* alias for dest */
	tmpb = (*Tmp_int)(unsafe.Pointer(b)).Fdp
	/* carry */
	r = uint32(0)
	x = 0
	for {
		if !(x < (*Tmp_int)(unsafe.Pointer(a)).Fused) {
			break
		}
		/* get what will be the *next* carry bit from the
		 * MSB of the current digit
		 */
		rr = *(*Tmp_digit)(unsafe.Pointer(tmpa)) >> libc.Uint32FromInt32(libc.Int32FromInt32(MP_DIGIT_BIT)-libc.Int32FromInt32(1))
		/* now shift up this digit, add in the carry [from the previous] */
		v3 = tmpb
		tmpb += 4
		v4 = tmpa
		tmpa += 4
		*(*Tmp_digit)(unsafe.Pointer(v3)) = (*(*Tmp_digit)(unsafe.Pointer(v4))<<libc.Uint64FromUint64(1) | r) & (libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1))
		/* copy the carry that would be from the source
		 * digit into the next iteration
		 */
		r = rr
		goto _2
	_2:
		;
		x++
	}
	/* new leading digit? */
	if r != 0 {
		/* add a MSB which is always 1 at this point */
		*(*Tmp_digit)(unsafe.Pointer(tmpb)) = uint32(1)
		(*Tmp_int)(unsafe.Pointer(b)).Fused++
	}
	/* now zero any excess digits on the destination
	 * that we didn't write to
	 */
	zd_ = oldused - (*Tmp_int)(unsafe.Pointer(b)).Fused
	zm_ = (*Tmp_int)(unsafe.Pointer(b)).Fdp + uintptr((*Tmp_int)(unsafe.Pointer(b)).Fused)*4
	for {
		v5 = zd_
		zd_--
		if !(v5 > 0) {
			break
		}
		v6 = zm_
		zm_ += 4
		*(*Tmp_digit)(unsafe.Pointer(v6)) = uint32(0)
	}
	(*Tmp_int)(unsafe.Pointer(b)).Fsign = (*Tmp_int)(unsafe.Pointer(a)).Fsign
	return MP_OKAY
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* shift left by a certain bit count */
func XTclBN_mp_mul_2d(tls *libc.TLS, a uintptr, b int32, c uintptr) (r1 Tmp_err) {
	var d, mask, r, rr, shift Tmp_digit
	var err, v1, v2, v3 Tmp_err
	var tmpc, v6 uintptr
	var x, v5 int32
	_, _, _, _, _, _, _, _, _, _, _, _, _ = d, err, mask, r, rr, shift, tmpc, x, v1, v2, v3, v5, v6
	if b < 0 {
		return -int32(3)
	}
	/* copy */
	if a != c {
		v1 = XTclBN_mp_copy(tls, a, c)
		err = v1
		if v1 != MP_OKAY {
			return err
		}
	}
	if (*Tmp_int)(unsafe.Pointer(c)).Falloc < (*Tmp_int)(unsafe.Pointer(c)).Fused+b/int32(MP_DIGIT_BIT)+int32(1) {
		v2 = XTclBN_mp_grow(tls, c, (*Tmp_int)(unsafe.Pointer(c)).Fused+b/int32(MP_DIGIT_BIT)+int32(1))
		err = v2
		if v2 != MP_OKAY {
			return err
		}
	}
	/* shift by as many digits in the bit count */
	if b >= int32(MP_DIGIT_BIT) {
		v3 = XTclBN_mp_lshd(tls, c, b/int32(MP_DIGIT_BIT))
		err = v3
		if v3 != MP_OKAY {
			return err
		}
	}
	/* shift any bit count < MP_DIGIT_BIT */
	d = libc.Uint32FromInt32(b % libc.Int32FromInt32(MP_DIGIT_BIT))
	if d != 0 {
		/* bitmask for carries */
		mask = libc.Uint32FromInt32(1)<<d - libc.Uint32FromInt32(1)
		/* shift for msbs */
		shift = libc.Uint32FromInt32(MP_DIGIT_BIT) - d
		/* alias */
		tmpc = (*Tmp_int)(unsafe.Pointer(c)).Fdp
		/* carry */
		r = uint32(0)
		x = 0
		for {
			if !(x < (*Tmp_int)(unsafe.Pointer(c)).Fused) {
				break
			}
			/* get the higher bits of the current word */
			rr = *(*Tmp_digit)(unsafe.Pointer(tmpc)) >> shift & mask
			/* shift the current word and OR in the carry */
			*(*Tmp_digit)(unsafe.Pointer(tmpc)) = (*(*Tmp_digit)(unsafe.Pointer(tmpc))<<d | r) & (libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1))
			tmpc += 4
			/* set the carry to the carry bits of the current word */
			r = rr
			goto _4
		_4:
			;
			x++
		}
		/* set final carry */
		if r != 0 {
			v6 = c
			v5 = *(*int32)(unsafe.Pointer(v6))
			*(*int32)(unsafe.Pointer(v6))++
			*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(c)).Fdp + uintptr(v5)*4)) = r
		}
	}
	XTclBN_mp_clamp(tls, c)
	return MP_OKAY
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* multiply by a digit */
func XTclBN_mp_mul_d(tls *libc.TLS, a uintptr, b Tmp_digit, c uintptr) (r1 Tmp_err) {
	var err, v1 Tmp_err
	var ix, olduse, zd_, v6 int32
	var r Tmp_word
	var tmpa, tmpc, zm_, v3, v4, v5, v7 uintptr
	var u Tmp_digit
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = err, ix, olduse, r, tmpa, tmpc, u, zd_, zm_, v1, v3, v4, v5, v6, v7
	/* make sure c is big enough to hold a*b */
	if (*Tmp_int)(unsafe.Pointer(c)).Falloc < (*Tmp_int)(unsafe.Pointer(a)).Fused+int32(1) {
		v1 = XTclBN_mp_grow(tls, c, (*Tmp_int)(unsafe.Pointer(a)).Fused+int32(1))
		err = v1
		if v1 != MP_OKAY {
			return err
		}
	}
	/* get the original destinations used count */
	olduse = (*Tmp_int)(unsafe.Pointer(c)).Fused
	/* set the sign */
	(*Tmp_int)(unsafe.Pointer(c)).Fsign = (*Tmp_int)(unsafe.Pointer(a)).Fsign
	/* alias for a->dp [source] */
	tmpa = (*Tmp_int)(unsafe.Pointer(a)).Fdp
	/* alias for c->dp [dest] */
	tmpc = (*Tmp_int)(unsafe.Pointer(c)).Fdp
	/* zero carry */
	u = uint32(0)
	/* compute columns */
	ix = 0
	for {
		if !(ix < (*Tmp_int)(unsafe.Pointer(a)).Fused) {
			break
		}
		/* compute product and carry sum for this term */
		v3 = tmpa
		tmpa += 4
		r = uint64(u) + uint64(*(*Tmp_digit)(unsafe.Pointer(v3)))*uint64(b)
		/* mask off higher bits to get a single digit */
		v4 = tmpc
		tmpc += 4
		*(*Tmp_digit)(unsafe.Pointer(v4)) = uint32(r & uint64(libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT)-libc.Uint32FromInt32(1)))
		/* send carry into next iteration */
		u = uint32(r >> libc.Uint64FromInt32(MP_DIGIT_BIT))
		goto _2
	_2:
		;
		ix++
	}
	/* store final carry [if any] and increment ix offset  */
	v5 = tmpc
	tmpc += 4
	*(*Tmp_digit)(unsafe.Pointer(v5)) = u
	ix++
	/* now zero digits above the top */
	zd_ = olduse - ix
	zm_ = tmpc
	for {
		v6 = zd_
		zd_--
		if !(v6 > 0) {
			break
		}
		v7 = zm_
		zm_ += 4
		*(*Tmp_digit)(unsafe.Pointer(v7)) = uint32(0)
	}
	/* set used count */
	(*Tmp_int)(unsafe.Pointer(c)).Fused = (*Tmp_int)(unsafe.Pointer(a)).Fused + int32(1)
	XTclBN_mp_clamp(tls, c)
	return MP_OKAY
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* b = -a */
func XTclBN_mp_neg(tls *libc.TLS, a uintptr, b uintptr) (r Tmp_err) {
	var err, v1 Tmp_err
	var v2 int32
	_, _, _ = err, v1, v2
	if a != b {
		v1 = XTclBN_mp_copy(tls, a, b)
		err = v1
		if v1 != MP_OKAY {
			return err
		}
	}
	if !((*Tmp_int)(unsafe.Pointer(b)).Fused == libc.Int32FromInt32(0)) {
		if (*Tmp_int)(unsafe.Pointer(a)).Fsign == MP_ZPOS {
			v2 = int32(MP_NEG)
		} else {
			v2 = MP_ZPOS
		}
		(*Tmp_int)(unsafe.Pointer(b)).Fsign = v2
	} else {
		(*Tmp_int)(unsafe.Pointer(b)).Fsign = MP_ZPOS
	}
	return MP_OKAY
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* two complement or */
func XTclBN_mp_or(tls *libc.TLS, a uintptr, b uintptr, c uintptr) (r Tmp_err) {
	var ac, bc, cc, x, y Tmp_digit
	var csign Tmp_sign
	var err, v3 Tmp_err
	var i, used, v1, v2 int32
	var v5, v7 uint32
	var v6, v8 uint64
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = ac, bc, cc, csign, err, i, used, x, y, v1, v2, v3, v5, v6, v7, v8
	if (*Tmp_int)(unsafe.Pointer(a)).Fused > (*Tmp_int)(unsafe.Pointer(b)).Fused {
		v1 = (*Tmp_int)(unsafe.Pointer(a)).Fused
	} else {
		v1 = (*Tmp_int)(unsafe.Pointer(b)).Fused
	}
	used = v1 + int32(1)
	ac = uint32(1)
	bc = uint32(1)
	cc = uint32(1)
	if (*Tmp_int)(unsafe.Pointer(a)).Fsign == int32(MP_NEG) || (*Tmp_int)(unsafe.Pointer(b)).Fsign == int32(MP_NEG) {
		v2 = int32(MP_NEG)
	} else {
		v2 = MP_ZPOS
	}
	csign = v2
	if (*Tmp_int)(unsafe.Pointer(c)).Falloc < used {
		v3 = XTclBN_mp_grow(tls, c, used)
		err = v3
		if v3 != MP_OKAY {
			return err
		}
	}
	i = 0
	for {
		if !(i < used) {
			break
		}
		/* convert to two complement if negative */
		if (*Tmp_int)(unsafe.Pointer(a)).Fsign == int32(MP_NEG) {
			if i >= (*Tmp_int)(unsafe.Pointer(a)).Fused {
				v5 = libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1)
			} else {
				v5 = ^*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr(i)*4)) & (libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1))
			}
			ac += v5
			x = ac & (libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1))
			ac >>= uint32(MP_DIGIT_BIT)
		} else {
			if i >= (*Tmp_int)(unsafe.Pointer(a)).Fused {
				v6 = 0
			} else {
				v6 = uint64(*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr(i)*4)))
			}
			x = uint32(v6)
		}
		/* convert to two complement if negative */
		if (*Tmp_int)(unsafe.Pointer(b)).Fsign == int32(MP_NEG) {
			if i >= (*Tmp_int)(unsafe.Pointer(b)).Fused {
				v7 = libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1)
			} else {
				v7 = ^*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(b)).Fdp + uintptr(i)*4)) & (libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1))
			}
			bc += v7
			y = bc & (libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1))
			bc >>= uint32(MP_DIGIT_BIT)
		} else {
			if i >= (*Tmp_int)(unsafe.Pointer(b)).Fused {
				v8 = 0
			} else {
				v8 = uint64(*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(b)).Fdp + uintptr(i)*4)))
			}
			y = uint32(v8)
		}
		*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(c)).Fdp + uintptr(i)*4)) = x | y
		/* convert to to sign-magnitude if negative */
		if csign == int32(MP_NEG) {
			cc += ^*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(c)).Fdp + uintptr(i)*4)) & (libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1))
			*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(c)).Fdp + uintptr(i)*4)) = cc & (libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1))
			cc >>= uint32(MP_DIGIT_BIT)
		}
		goto _4
	_4:
		;
		i++
	}
	(*Tmp_int)(unsafe.Pointer(c)).Fused = used
	(*Tmp_int)(unsafe.Pointer(c)).Fsign = csign
	XTclBN_mp_clamp(tls, c)
	return MP_OKAY
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* based on gmp's mpz_export.
//	 * see http://gmplib.org/manual/Integer-Import-and-Export.html
//	 */
func XTclBN_mp_pack(tls *libc.TLS, rop uintptr, maxcount Tsize_t, written uintptr, order Tmp_order, size Tsize_t, endian Tmp_endian, nails Tsize_t, op uintptr) (r Tmp_err) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var byte1, p uintptr
	var count, i, j, nail_bytes, odd_nails Tsize_t
	var err, v1, v9 Tmp_err
	var odd_nail_mask uint8
	var v10, v2 int32
	var v6, v7, v8 uint64
	var _ /* n at bp+24 */ Tint16_t
	var _ /* t at bp+0 */ Tmp_int
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = byte1, count, err, i, j, nail_bytes, odd_nail_mask, odd_nails, p, v1, v10, v2, v6, v7, v8, v9
	count = XTclBN_mp_pack_count(tls, op, nails, size)
	if count > maxcount {
		return -int32(5)
	}
	v1 = XTclBN_mp_init_copy(tls, bp, op)
	err = v1
	if v1 != MP_OKAY {
		return err
	}
	if endian == MP_NATIVE_ENDIAN {
		*(*Tint16_t)(unsafe.Pointer(bp + 24)) = int16(0x1)
		p = bp + 24
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('\x01') {
			v2 = -int32(1)
		} else {
			v2 = int32(MP_BIG_ENDIAN)
		}
		endian = v2
	}
	odd_nails = nails % libc.Uint64FromUint32(8)
	odd_nail_mask = uint8(0xff)
	i = 0
	for {
		if !(i < odd_nails) {
			break
		}
		odd_nail_mask = uint8(int32(odd_nail_mask) ^ libc.Int32FromUint8(uint8(libc.Uint32FromUint32(1)<<(libc.Uint64FromUint32(7)-i))))
		goto _3
	_3:
		;
		i++
	}
	nail_bytes = nails / uint64(8)
	i = 0
	for {
		if !(i < count) {
			break
		}
		j = 0
		for {
			if !(j < size) {
				break
			}
			if order == -int32(1) {
				v6 = i
			} else {
				v6 = count - uint64(1) - i
			}
			if endian == -int32(1) {
				v7 = j
			} else {
				v7 = size - uint64(1) - j
			}
			byte1 = rop + uintptr(v6*size) + uintptr(v7)
			if j >= size-nail_bytes {
				*(*uint8)(unsafe.Pointer(byte1)) = uint8(0)
				goto _5
			}
			if j == size-nail_bytes-uint64(1) {
				v8 = uint64(*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp)) & uint32(odd_nail_mask))
			} else {
				v8 = uint64(*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp))) & uint64(0xFF)
			}
			*(*uint8)(unsafe.Pointer(byte1)) = uint8(v8)
			if j == size-nail_bytes-uint64(1) {
				v10 = libc.Int32FromUint64(libc.Uint64FromUint32(8) - odd_nails)
			} else {
				v10 = int32(8)
			}
			v9 = XTclBN_mp_div_2d(tls, bp, v10, bp, libc.UintptrFromInt32(0))
			err = v9
			if v9 != MP_OKAY {
				goto LBL_ERR
			}
			goto _5
		_5:
			;
			j++
		}
		goto _4
	_4:
		;
		i++
	}
	if written != libc.UintptrFromInt32(0) {
		*(*Tsize_t)(unsafe.Pointer(written)) = count
	}
	err = MP_OKAY
	goto LBL_ERR
LBL_ERR:
	;
	XTclBN_mp_clear(tls, bp)
	return err
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

func XTclBN_mp_pack_count(tls *libc.TLS, a uintptr, nails Tsize_t, size Tsize_t) (r Tsize_t) {
	var bits Tsize_t
	var v1 uint32
	_, _ = bits, v1
	bits = libc.Uint64FromInt32(XTclBN_mp_count_bits(tls, a))
	if bits%(size*uint64(8)-nails) != 0 {
		v1 = uint32(1)
	} else {
		v1 = 0
	}
	return bits/(size*libc.Uint64FromUint32(8)-nails) + uint64(v1)
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* returns size of ASCII representation */
func XTclBN_mp_radix_size(tls *libc.TLS, a uintptr, radix int32, size uintptr) (r Tmp_err) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var digs, v1 int32
	var err, v2, v3 Tmp_err
	var _ /* d at bp+24 */ Tmp_digit
	var _ /* t at bp+0 */ Tmp_int
	_, _, _, _, _ = digs, err, v1, v2, v3
	*(*int32)(unsafe.Pointer(size)) = 0
	/* make sure the radix is in range */
	if radix < int32(2) || radix > int32(64) {
		return -int32(3)
	}
	if (*Tmp_int)(unsafe.Pointer(a)).Fused == 0 {
		*(*int32)(unsafe.Pointer(size)) = int32(2)
		return MP_OKAY
	}
	/* special case for binary */
	if radix == int32(2) {
		if (*Tmp_int)(unsafe.Pointer(a)).Fsign == int32(MP_NEG) {
			v1 = int32(1)
		} else {
			v1 = 0
		}
		*(*int32)(unsafe.Pointer(size)) = XTclBN_mp_count_bits(tls, a) + v1 + int32(1)
		return MP_OKAY
	}
	/* digs is the digit count */
	digs = 0
	/* if it's negative add one for the sign */
	if (*Tmp_int)(unsafe.Pointer(a)).Fsign == int32(MP_NEG) {
		digs++
	}
	/* init a copy of the input */
	v2 = XTclBN_mp_init_copy(tls, bp, a)
	err = v2
	if v2 != MP_OKAY {
		return err
	}
	/* force temp to positive */
	(*(*Tmp_int)(unsafe.Pointer(bp))).Fsign = MP_ZPOS
	/* fetch out all of the digits */
	for !((*Tmp_int)(unsafe.Pointer(bp)).Fused == libc.Int32FromInt32(0)) {
		v3 = XTclBN_mp_div_d(tls, bp, libc.Uint32FromInt32(radix), bp, bp+24)
		err = v3
		if v3 != MP_OKAY {
			goto LBL_ERR
		}
		digs++
	}
	/* return digs + 1, the 1 is for the NULL byte that would be required. */
	*(*int32)(unsafe.Pointer(size)) = digs + int32(1)
	err = MP_OKAY
	goto LBL_ERR
LBL_ERR:
	;
	XTclBN_mp_clear(tls, bp)
	return err
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */
func XTclBN_mp_set_i64(tls *libc.TLS, a uintptr, b Tint64_t) {
	var v1 uint64
	_ = v1
	if b < 0 {
		v1 = -libc.Uint64FromInt64(b)
	} else {
		v1 = libc.Uint64FromInt64(b)
	}
	XTclBN_mp_set_u64(tls, a, v1)
	if b < 0 {
		(*Tmp_int)(unsafe.Pointer(a)).Fsign = int32(MP_NEG)
	}
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* read a string [ASCII] in a given radix */
func XTclBN_mp_read_radix(tls *libc.TLS, a uintptr, str uintptr, radix int32) (r Tmp_err) {
	var ch uint8
	var err, v3, v4 Tmp_err
	var neg Tmp_sign
	var pos uint32
	var y, v1, v2 int32
	_, _, _, _, _, _, _, _, _ = ch, err, neg, pos, y, v1, v2, v3, v4
	/* zero the digit bignum */
	XTclBN_mp_zero(tls, a)
	/* make sure the radix is ok */
	if radix < int32(2) || radix > int32(64) {
		return -int32(3)
	}
	/* if the leading digit is a
	 * minus set the sign to negative.
	 */
	if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) == int32('-') {
		str++
		neg = int32(MP_NEG)
	} else {
		neg = MP_ZPOS
	}
	/* set the integer to the default of zero */
	XTclBN_mp_zero(tls, a)
	/* process each digit of the string */
	for libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) != int32('\000') {
		/* if the radix <= 36 the conversion is case insensitive
		 * this allows numbers like 1AB and 1ab to represent the same  value
		 * [e.g. in hex]
		 */
		if radix <= int32(36) {
			if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) >= int32('a') && libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) <= int32('z') {
				v2 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) + int32('A') - int32('a')
			} else {
				v2 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str)))
			}
			v1 = libc.Int32FromUint8(libc.Uint8FromInt32(v2))
		} else {
			v1 = libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str)))
		}
		ch = libc.Uint8FromInt32(v1)
		pos = libc.Uint32FromInt32(libc.Int32FromUint8(ch) - libc.Int32FromUint8('('))
		if XTclBN_mp_s_rmap_reverse_sz < uint64(pos) {
			break
		}
		y = libc.Int32FromUint8(XTclBN_mp_s_rmap_reverse[pos])
		/* if the char was found in the map
		 * and is less than the given radix add it
		 * to the number, otherwise exit the loop.
		 */
		if y == int32(0xff) || y >= radix {
			break
		}
		v3 = XTclBN_mp_mul_d(tls, a, libc.Uint32FromInt32(radix), a)
		err = v3
		if v3 != MP_OKAY {
			return err
		}
		v4 = XTclBN_mp_add_d(tls, a, libc.Uint32FromInt32(y), a)
		err = v4
		if v4 != MP_OKAY {
			return err
		}
		str++
	}
	/* if an illegal character was found, fail. */
	if !(libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) == int32('\000') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) == int32('\r') || libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) == int32('\n')) {
		XTclBN_mp_zero(tls, a)
		return -int32(3)
	}
	/* set the sign only if a != 0 */
	if !((*Tmp_int)(unsafe.Pointer(a)).Fused == libc.Int32FromInt32(0)) {
		(*Tmp_int)(unsafe.Pointer(a)).Fsign = neg
	}
	return MP_OKAY
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* shift right a certain amount of digits */
func XTclBN_mp_rshd(tls *libc.TLS, a uintptr, b int32) {
	var bottom, top, zm_, v2, v3, v5 uintptr
	var x, zd_, v4 int32
	_, _, _, _, _, _, _, _, _ = bottom, top, x, zd_, zm_, v2, v3, v4, v5
	/* if b <= 0 then ignore it */
	if b <= 0 {
		return
	}
	/* if b > used then simply zero it and return */
	if (*Tmp_int)(unsafe.Pointer(a)).Fused <= b {
		XTclBN_mp_zero(tls, a)
		return
	}
	/* shift the digits down */
	/* bottom */
	bottom = (*Tmp_int)(unsafe.Pointer(a)).Fdp
	/* top [offset into digits] */
	top = (*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr(b)*4
	/* this is implemented as a sliding window where
	   * the window is b-digits long and digits from
	   * the top of the window are copied to the bottom
	   *
	   * e.g.
	   b-2 | b-1 | b0 | b1 | b2 | ... | bb |   ---->
	               /\                   |      ---->
	                \-------------------/      ---->
	*/
	x = 0
	for {
		if !(x < (*Tmp_int)(unsafe.Pointer(a)).Fused-b) {
			break
		}
		v2 = bottom
		bottom += 4
		v3 = top
		top += 4
		*(*Tmp_digit)(unsafe.Pointer(v2)) = *(*Tmp_digit)(unsafe.Pointer(v3))
		goto _1
	_1:
		;
		x++
	}
	/* zero the top digits */
	zd_ = (*Tmp_int)(unsafe.Pointer(a)).Fused - x
	zm_ = bottom
	for {
		v4 = zd_
		zd_--
		if !(v4 > 0) {
			break
		}
		v5 = zm_
		zm_ += 4
		*(*Tmp_digit)(unsafe.Pointer(v5)) = uint32(0)
	}
	/* remove excess digits */
	*(*int32)(unsafe.Pointer(a)) -= b
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */
func XTclBN_mp_set_u64(tls *libc.TLS, a uintptr, b Tuint64_t) {
	var i, zd_, v1, v2 int32
	var zm_, v3 uintptr
	_, _, _, _, _, _ = i, zd_, zm_, v1, v2, v3
	i = 0
	for b != 0 {
		v1 = i
		i++
		*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr(v1)*4)) = uint32(b) & (libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1))
		if libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8) <= uint64(MP_DIGIT_BIT) {
			break
		}
		b >>= libc.Uint64FromInt32(libc.Int32FromInt32(MP_DIGIT_BIT))
	}
	(*Tmp_int)(unsafe.Pointer(a)).Fused = i
	(*Tmp_int)(unsafe.Pointer(a)).Fsign = MP_ZPOS
	zd_ = (*Tmp_int)(unsafe.Pointer(a)).Falloc - (*Tmp_int)(unsafe.Pointer(a)).Fused
	zm_ = (*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr((*Tmp_int)(unsafe.Pointer(a)).Fused)*4
	for {
		v2 = zd_
		zd_--
		if !(v2 > 0) {
			break
		}
		v3 = zm_
		zm_ += 4
		*(*Tmp_digit)(unsafe.Pointer(v3)) = uint32(0)
	}
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* shrink a bignum */
func XTclBN_mp_shrink(tls *libc.TLS, a uintptr) (r Tmp_err) {
	var alloc, v1 int32
	var tmp, v2 uintptr
	_, _, _, _ = alloc, tmp, v1, v2
	if (libc.Int32FromUint64(libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8))+libc.Int32FromInt32(MP_DIGIT_BIT)-libc.Int32FromInt32(1))/libc.Int32FromInt32(MP_DIGIT_BIT) > (*Tmp_int)(unsafe.Pointer(a)).Fused {
		v1 = (libc.Int32FromUint64(libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8)) + libc.Int32FromInt32(MP_DIGIT_BIT) - libc.Int32FromInt32(1)) / libc.Int32FromInt32(MP_DIGIT_BIT)
	} else {
		v1 = (*Tmp_int)(unsafe.Pointer(a)).Fused
	}
	alloc = v1
	if (*Tmp_int)(unsafe.Pointer(a)).Falloc != alloc {
		_ = libc.Uint64FromInt32((*Tmp_int)(unsafe.Pointer(a)).Falloc) * libc.Uint64FromInt64(4)
		v2 = XTcl_AttemptRealloc(tls, (*Tmp_int)(unsafe.Pointer(a)).Fdp, libc.Uint64FromInt32(alloc)*libc.Uint64FromInt64(4))
		tmp = v2
		if v2 == libc.UintptrFromInt32(0) {
			return -int32(2)
		}
		(*Tmp_int)(unsafe.Pointer(a)).Fdp = tmp
		(*Tmp_int)(unsafe.Pointer(a)).Falloc = alloc
	}
	return MP_OKAY
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* computes b = a*a */
func XTclBN_mp_sqr(tls *libc.TLS, a uintptr, b uintptr) (r Tmp_err) {
	var err Tmp_err
	_ = err
	if libc.Bool(uint64(1) == uint64(1)) && (*Tmp_int)(unsafe.Pointer(a)).Fused >= int32(MP_DEFAULT_TOOM_SQR_CUTOFF) {
		err = XTclBN_mp_toom_sqr(tls, a, b)
	} else {
		if libc.Bool(uint64(1) == uint64(1)) && (*Tmp_int)(unsafe.Pointer(a)).Fused >= int32(MP_DEFAULT_KARATSUBA_SQR_CUTOFF) {
			err = XTclBN_mp_karatsuba_sqr(tls, a, b)
		} else {
			if libc.Bool(uint64(1) == uint64(1)) && (*Tmp_int)(unsafe.Pointer(a)).Fused*int32(2)+int32(1) < libc.Int32FromInt32(1)<<(libc.Int32FromInt32(CHAR_BIT)*libc.Int32FromInt64(8)-libc.Int32FromInt32(2)*libc.Int32FromInt32(MP_DIGIT_BIT)+libc.Int32FromInt32(1)) && (*Tmp_int)(unsafe.Pointer(a)).Fused < libc.Int32FromUint64(libc.Uint64FromUint64(1)<<(libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8)-libc.Uint64FromUint32(2)*libc.Uint64FromInt32(MP_DIGIT_BIT)))/libc.Int32FromInt32(2) {
				err = XTclBN_mp_sqr_fast(tls, a, b)
			} else {
				if uint64(1) == uint64(1) {
					err = XTclBN_s_mp_sqr(tls, a, b)
				} else {
					err = -int32(3)
				}
			}
		}
	}
	(*Tmp_int)(unsafe.Pointer(b)).Fsign = MP_ZPOS
	return err
}

// C documentation
//
//	/* this function is less generic than mp_n_root, simpler and faster */
func XTclBN_mp_sqrt(tls *libc.TLS, arg uintptr, ret uintptr) (r Tmp_err) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var d float64
	var dig Tmp_digit
	var err, v1, v10, v2, v5, v6, v7, v8, v9 Tmp_err
	var i, j, k int32
	var _ /* t1 at bp+0 */ Tmp_int
	var _ /* t2 at bp+24 */ Tmp_int
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, dig, err, i, j, k, v1, v10, v2, v5, v6, v7, v8, v9
	/* must be positive */
	if (*Tmp_int)(unsafe.Pointer(arg)).Fsign == int32(MP_NEG) {
		return -int32(3)
	}
	/* easy out */
	if (*Tmp_int)(unsafe.Pointer(arg)).Fused == 0 {
		XTclBN_mp_zero(tls, ret)
		return MP_OKAY
	}
	i = (*Tmp_int)(unsafe.Pointer(arg)).Fused/int32(2) - int32(1)
	j = int32(2) * i
	v1 = XTclBN_mp_init_size(tls, bp, i+int32(2))
	err = v1
	if v1 != MP_OKAY {
		return err
	}
	v2 = XTclBN_mp_init(tls, bp+24)
	err = v2
	if v2 != MP_OKAY {
		goto E2
	}
	k = 0
	for {
		if !(k < i) {
			break
		}
		*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp + uintptr(k)*4)) = libc.Uint32FromInt32(0)
		goto _3
	_3:
		;
		k++
	}
	/* Estimate the square root using the hardware floating point unit. */
	d = float64(0)
	k = (*Tmp_int)(unsafe.Pointer(arg)).Fused - int32(1)
	for {
		if !(k >= j) {
			break
		}
		d = libc.Xldexp(tls, d, int32(MP_DIGIT_BIT)) + float64(*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(arg)).Fdp + uintptr(k)*4)))
		goto _4
	_4:
		;
		k--
	}
	/*
	 * At this point, d is the nearest floating point number to the most
	 * significant 1 or 2 mp_digits of arg. Extract its square root.
	 */
	d = libc.Xsqrt(tls, d)
	/* dig is the most significant mp_digit of the square root */
	dig = uint32(libc.Xldexp(tls, d, -int32(MP_DIGIT_BIT)))
	/*
	 * If the most significant digit is nonzero, find the next digit down
	 * by subtracting MP_DIGIT_BIT times thie most significant digit.
	 * Subtract one from the result so that our initial estimate is always
	 * low.
	 */
	if dig != 0 {
		(*(*Tmp_int)(unsafe.Pointer(bp))).Fused = i + int32(2)
		d -= libc.Xldexp(tls, float64(dig), int32(MP_DIGIT_BIT))
		if d >= float64(1) {
			*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp + uintptr(i+int32(1))*4)) = dig
			*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp + uintptr(i)*4)) = uint32(d) - uint32(1)
		} else {
			*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp + uintptr(i+int32(1))*4)) = dig - uint32(1)
			*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp + uintptr(i)*4)) = libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1)
		}
	} else {
		(*(*Tmp_int)(unsafe.Pointer(bp))).Fused = i + int32(1)
		*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp + uintptr(i)*4)) = uint32(d) - uint32(1)
	}
	/* t1 > 0  */
	v5 = XTclBN_mp_div(tls, arg, bp, bp+24, libc.UintptrFromInt32(0))
	err = v5
	if v5 != MP_OKAY {
		goto E1
	}
	v6 = XTclBN_mp_add(tls, bp, bp+24, bp)
	err = v6
	if v6 != MP_OKAY {
		goto E1
	}
	v7 = XTclBN_mp_div_2(tls, bp, bp)
	err = v7
	if v7 != MP_OKAY {
		goto E1
	}
	/* And now t1 > sqrt(arg) */
	for cond := true; cond; cond = XTclBN_mp_cmp_mag(tls, bp, bp+24) == int32(MP_GT) {
		v8 = XTclBN_mp_div(tls, arg, bp, bp+24, libc.UintptrFromInt32(0))
		err = v8
		if v8 != MP_OKAY {
			goto E1
		}
		v9 = XTclBN_mp_add(tls, bp, bp+24, bp)
		err = v9
		if v9 != MP_OKAY {
			goto E1
		}
		v10 = XTclBN_mp_div_2(tls, bp, bp)
		err = v10
		if v10 != MP_OKAY {
			goto E1
		}
		/* t1 >= sqrt(arg) >= t2 at this point */
	}
	XTclBN_mp_exch(tls, bp, ret)
	goto E1
E1:
	;
	XTclBN_mp_clear(tls, bp+24)
	goto E2
E2:
	;
	XTclBN_mp_clear(tls, bp)
	return err
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* high level subtraction (handles signs) */
func XTclBN_mp_sub(tls *libc.TLS, a uintptr, b uintptr, c uintptr) (r Tmp_err) {
	var err Tmp_err
	var sa, sb Tmp_sign
	var v1 int32
	_, _, _, _ = err, sa, sb, v1
	sa = (*Tmp_int)(unsafe.Pointer(a)).Fsign
	sb = (*Tmp_int)(unsafe.Pointer(b)).Fsign
	if sa != sb {
		/* subtract a negative from a positive, OR */
		/* subtract a positive from a negative. */
		/* In either case, ADD their magnitudes, */
		/* and use the sign of the first number. */
		(*Tmp_int)(unsafe.Pointer(c)).Fsign = sa
		err = XTclBN_s_mp_add(tls, a, b, c)
	} else {
		/* subtract a positive from a positive, OR */
		/* subtract a negative from a negative. */
		/* First, take the difference between their */
		/* magnitudes, then... */
		if XTclBN_mp_cmp_mag(tls, a, b) != -int32(1) {
			/* Copy the sign from the first */
			(*Tmp_int)(unsafe.Pointer(c)).Fsign = sa
			/* The first has a larger or equal magnitude */
			err = XTclBN_s_mp_sub(tls, a, b, c)
		} else {
			/* The result has the *opposite* sign from */
			/* the first number. */
			if sa == MP_ZPOS {
				v1 = int32(MP_NEG)
			} else {
				v1 = MP_ZPOS
			}
			(*Tmp_int)(unsafe.Pointer(c)).Fsign = v1
			/* The second has a larger magnitude */
			err = XTclBN_s_mp_sub(tls, b, a, c)
		}
	}
	return err
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* single digit subtraction */
func XTclBN_mp_sub_d(tls *libc.TLS, a uintptr, b Tmp_digit, c uintptr) (r Tmp_err) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var err, v1 Tmp_err
	var ix, oldused, zd_, v7 int32
	var mu Tmp_digit
	var tmpa, tmpc, zm_, v2, v3, v5, v6, v8 uintptr
	var _ /* a_ at bp+0 */ Tmp_int
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = err, ix, mu, oldused, tmpa, tmpc, zd_, zm_, v1, v2, v3, v5, v6, v7, v8
	/* grow c as required */
	if (*Tmp_int)(unsafe.Pointer(c)).Falloc < (*Tmp_int)(unsafe.Pointer(a)).Fused+int32(1) {
		v1 = XTclBN_mp_grow(tls, c, (*Tmp_int)(unsafe.Pointer(a)).Fused+int32(1))
		err = v1
		if v1 != MP_OKAY {
			return err
		}
	}
	/* if a is negative just do an unsigned
	 * addition [with fudged signs]
	 */
	if (*Tmp_int)(unsafe.Pointer(a)).Fsign == int32(MP_NEG) {
		*(*Tmp_int)(unsafe.Pointer(bp)) = *(*Tmp_int)(unsafe.Pointer(a))
		(*(*Tmp_int)(unsafe.Pointer(bp))).Fsign = MP_ZPOS
		err = XTclBN_mp_add_d(tls, bp, b, c)
		(*Tmp_int)(unsafe.Pointer(c)).Fsign = int32(MP_NEG)
		/* clamp */
		XTclBN_mp_clamp(tls, c)
		return err
	}
	/* setup regs */
	oldused = (*Tmp_int)(unsafe.Pointer(c)).Fused
	tmpa = (*Tmp_int)(unsafe.Pointer(a)).Fdp
	tmpc = (*Tmp_int)(unsafe.Pointer(c)).Fdp
	/* if a <= b simply fix the single digit */
	if (*Tmp_int)(unsafe.Pointer(a)).Fused == int32(1) && *(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp)) <= b || (*Tmp_int)(unsafe.Pointer(a)).Fused == 0 {
		if (*Tmp_int)(unsafe.Pointer(a)).Fused == int32(1) {
			v2 = tmpc
			tmpc += 4
			*(*Tmp_digit)(unsafe.Pointer(v2)) = b - *(*Tmp_digit)(unsafe.Pointer(tmpa))
		} else {
			v3 = tmpc
			tmpc += 4
			*(*Tmp_digit)(unsafe.Pointer(v3)) = b
		}
		ix = int32(1)
		/* negative/1digit */
		(*Tmp_int)(unsafe.Pointer(c)).Fsign = int32(MP_NEG)
		(*Tmp_int)(unsafe.Pointer(c)).Fused = int32(1)
	} else {
		mu = b
		/* positive/size */
		(*Tmp_int)(unsafe.Pointer(c)).Fsign = MP_ZPOS
		(*Tmp_int)(unsafe.Pointer(c)).Fused = (*Tmp_int)(unsafe.Pointer(a)).Fused
		/* subtract digits, mu is carry */
		ix = 0
		for {
			if !(ix < (*Tmp_int)(unsafe.Pointer(a)).Fused) {
				break
			}
			v5 = tmpa
			tmpa += 4
			*(*Tmp_digit)(unsafe.Pointer(tmpc)) = *(*Tmp_digit)(unsafe.Pointer(v5)) - mu
			mu = *(*Tmp_digit)(unsafe.Pointer(tmpc)) >> (libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(4) - libc.Uint64FromUint32(1))
			v6 = tmpc
			tmpc += 4
			*(*Tmp_digit)(unsafe.Pointer(v6)) &= libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1)
			goto _4
		_4:
			;
			ix++
		}
	}
	/* zero excess digits */
	zd_ = oldused - ix
	zm_ = tmpc
	for {
		v7 = zd_
		zd_--
		if !(v7 > 0) {
			break
		}
		v8 = zm_
		zm_ += 4
		*(*Tmp_digit)(unsafe.Pointer(v8)) = uint32(0)
	}
	XTclBN_mp_clamp(tls, c)
	return MP_OKAY
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* shift right by a certain bit count with sign extension */
func XTclBN_mp_signed_rsh(tls *libc.TLS, a uintptr, b int32, c uintptr) (r Tmp_err) {
	var res Tmp_err
	var v1 int32
	_, _ = res, v1
	if (*Tmp_int)(unsafe.Pointer(a)).Fsign == MP_ZPOS {
		return XTclBN_mp_div_2d(tls, a, b, c, libc.UintptrFromInt32(0))
	}
	res = XTclBN_mp_add_d(tls, a, uint32(1), c)
	if res != MP_OKAY {
		return res
	}
	res = XTclBN_mp_div_2d(tls, c, b, c, libc.UintptrFromInt32(0))
	if res == MP_OKAY {
		v1 = XTclBN_mp_sub_d(tls, c, uint32(1), c)
	} else {
		v1 = res
	}
	return v1
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* store in unsigned [big endian] format */
func XTclBN_mp_to_ubin(tls *libc.TLS, a uintptr, buf uintptr, maxlen Tsize_t, written uintptr) (r Tmp_err) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var count, x, v3 Tsize_t
	var err, v1, v4 Tmp_err
	var _ /* t at bp+0 */ Tmp_int
	_, _, _, _, _, _ = count, err, x, v1, v3, v4
	count = XTclBN_mp_ubin_size(tls, a)
	if count > maxlen {
		return -int32(5)
	}
	v1 = XTclBN_mp_init_copy(tls, bp, a)
	err = v1
	if v1 != MP_OKAY {
		return err
	}
	x = count
	for {
		v3 = x
		x--
		if !(v3 > 0) {
			break
		}
		*(*uint8)(unsafe.Pointer(buf + uintptr(x))) = uint8(*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp)) & libc.Uint32FromUint32(255))
		v4 = XTclBN_mp_div_2d(tls, bp, int32(8), bp, libc.UintptrFromInt32(0))
		err = v4
		if v4 != MP_OKAY {
			goto LBL_ERR
		}
		goto _2
	_2:
	}
	if written != libc.UintptrFromInt32(0) {
		*(*Tsize_t)(unsafe.Pointer(written)) = count
	}
	goto LBL_ERR
LBL_ERR:
	;
	XTclBN_mp_clear(tls, bp)
	return err
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* based on gmp's mpz_import.
//	 * see http://gmplib.org/manual/Integer-Import-and-Export.html
//	 */
func XTclBN_mp_unpack(tls *libc.TLS, rop uintptr, count Tsize_t, order Tmp_order, size Tsize_t, endian Tmp_endian, nails Tsize_t, op uintptr) (r Tmp_err) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var byte1, odd_nail_mask uint8
	var err, v7 Tmp_err
	var i, j, nail_bytes, odd_nails Tsize_t
	var p uintptr
	var v1, v8 int32
	var v5, v6 uint64
	var v9 uint32
	var _ /* n at bp+0 */ Tint16_t
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = byte1, err, i, j, nail_bytes, odd_nail_mask, odd_nails, p, v1, v5, v6, v7, v8, v9
	XTclBN_mp_zero(tls, rop)
	if endian == MP_NATIVE_ENDIAN {
		*(*Tint16_t)(unsafe.Pointer(bp)) = int16(0x1)
		p = bp
		if libc.Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('\x01') {
			v1 = -int32(1)
		} else {
			v1 = int32(MP_BIG_ENDIAN)
		}
		endian = v1
	}
	odd_nails = nails % libc.Uint64FromUint32(8)
	odd_nail_mask = uint8(0xff)
	i = uint64(0)
	for {
		if !(i < odd_nails) {
			break
		}
		odd_nail_mask = uint8(int32(odd_nail_mask) ^ libc.Int32FromUint8(uint8(libc.Uint32FromUint32(1)<<(libc.Uint64FromUint32(7)-i))))
		goto _2
	_2:
		;
		i++
	}
	nail_bytes = nails / uint64(8)
	i = uint64(0)
	for {
		if !(i < count) {
			break
		}
		j = uint64(0)
		for {
			if !(j < size-nail_bytes) {
				break
			}
			if order == int32(MP_MSB_FIRST) {
				v5 = i
			} else {
				v5 = count - uint64(1) - i
			}
			if endian == int32(MP_BIG_ENDIAN) {
				v6 = j + nail_bytes
			} else {
				v6 = size - uint64(1) - j - nail_bytes
			}
			byte1 = *(*uint8)(unsafe.Pointer(op + uintptr(v5*size) + uintptr(v6)))
			if j == 0 {
				v8 = libc.Int32FromUint64(libc.Uint64FromUint32(8) - odd_nails)
			} else {
				v8 = int32(8)
			}
			v7 = XTclBN_mp_mul_2d(tls, rop, v8, rop)
			err = v7
			if v7 != MP_OKAY {
				return err
			}
			if j == 0 {
				v9 = libc.Uint32FromInt32(libc.Int32FromUint8(byte1) & libc.Int32FromUint8(odd_nail_mask))
			} else {
				v9 = uint32(byte1)
			}
			*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(rop)).Fdp)) |= v9
			*(*int32)(unsafe.Pointer(rop)) += int32(1)
			goto _4
		_4:
			;
			j++
		}
		goto _3
	_3:
		;
		i++
	}
	XTclBN_mp_clamp(tls, rop)
	return MP_OKAY
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

/* multiplication using the Toom-Cook 3-way algorithm
 *
 * Much more complicated than Karatsuba but has a lower
 * asymptotic running time of O(N**1.464).  This algorithm is
 * only particularly useful on VERY large inputs
 * (we're talking 1000s of digits here...).
 */

/*
   This file contains code from J. Arndt's book  "Matters Computational"
   and the accompanying FXT-library with permission of the author.
*/

/*
   Setup from

     Chung, Jaewook, and M. Anwar Hasan. "Asymmetric squaring formulae."
     18th IEEE Symposium on Computer Arithmetic (ARITH'07). IEEE, 2007.

   The interpolation from above needed one temporary variable more
   than the interpolation here:

     Bodrato, Marco, and Alberto Zanoni. "What about Toom-Cook matrices optimality."
     Centro Vito Volterra Universita di Roma Tor Vergata (2006)
*/

func XTclBN_mp_toom_mul(tls *libc.TLS, a uintptr, b uintptr, c uintptr) (r Tmp_err) {
	bp := tls.Alloc(256)
	defer tls.Free(256)
	var B, count, v2 int32
	var err, v1, v11, v13, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v7, v9 Tmp_err
	var _ /* S1 at bp+0 */ Tmp_int
	var _ /* S2 at bp+24 */ Tmp_int
	var _ /* T1 at bp+48 */ Tmp_int
	var _ /* a0 at bp+72 */ Tmp_int
	var _ /* a1 at bp+96 */ Tmp_int
	var _ /* a2 at bp+120 */ Tmp_int
	var _ /* b0 at bp+144 */ Tmp_int
	var _ /* b1 at bp+168 */ Tmp_int
	var _ /* b2 at bp+192 */ Tmp_int
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = B, count, err, v1, v11, v13, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v7, v9
	/* init temps */
	v1 = XTclBN_mp_init_multi(tls, bp, libc.VaList(bp+224, bp+24, bp+48, libc.UintptrFromInt32(0)))
	err = v1
	if v1 != MP_OKAY {
		return err
	}
	/* B */
	if (*Tmp_int)(unsafe.Pointer(a)).Fused < (*Tmp_int)(unsafe.Pointer(b)).Fused {
		v2 = (*Tmp_int)(unsafe.Pointer(a)).Fused
	} else {
		v2 = (*Tmp_int)(unsafe.Pointer(b)).Fused
	}
	B = v2 / int32(3)
	/** a = a2 * x^2 + a1 * x + a0; */
	v3 = XTclBN_mp_init_size(tls, bp+72, B)
	err = v3
	if v3 != MP_OKAY {
		goto LBL_ERRa0
	}
	count = 0
	for {
		if !(count < B) {
			break
		}
		*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 72))).Fdp + uintptr(count)*4)) = *(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr(count)*4))
		(*(*Tmp_int)(unsafe.Pointer(bp + 72))).Fused++
		goto _4
	_4:
		;
		count++
	}
	XTclBN_mp_clamp(tls, bp+72)
	v5 = XTclBN_mp_init_size(tls, bp+96, B)
	err = v5
	if v5 != MP_OKAY {
		goto LBL_ERRa1
	}
	for {
		if !(count < int32(2)*B) {
			break
		}
		*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 96))).Fdp + uintptr(count-B)*4)) = *(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr(count)*4))
		(*(*Tmp_int)(unsafe.Pointer(bp + 96))).Fused++
		goto _6
	_6:
		;
		count++
	}
	XTclBN_mp_clamp(tls, bp+96)
	v7 = XTclBN_mp_init_size(tls, bp+120, B+((*Tmp_int)(unsafe.Pointer(a)).Fused-int32(3)*B))
	err = v7
	if v7 != MP_OKAY {
		goto LBL_ERRa2
	}
	for {
		if !(count < (*Tmp_int)(unsafe.Pointer(a)).Fused) {
			break
		}
		*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 120))).Fdp + uintptr(count-int32(2)*B)*4)) = *(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr(count)*4))
		(*(*Tmp_int)(unsafe.Pointer(bp + 120))).Fused++
		goto _8
	_8:
		;
		count++
	}
	XTclBN_mp_clamp(tls, bp+120)
	/** b = b2 * x^2 + b1 * x + b0; */
	v9 = XTclBN_mp_init_size(tls, bp+144, B)
	err = v9
	if v9 != MP_OKAY {
		goto LBL_ERRb0
	}
	count = 0
	for {
		if !(count < B) {
			break
		}
		*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 144))).Fdp + uintptr(count)*4)) = *(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(b)).Fdp + uintptr(count)*4))
		(*(*Tmp_int)(unsafe.Pointer(bp + 144))).Fused++
		goto _10
	_10:
		;
		count++
	}
	XTclBN_mp_clamp(tls, bp+144)
	v11 = XTclBN_mp_init_size(tls, bp+168, B)
	err = v11
	if v11 != MP_OKAY {
		goto LBL_ERRb1
	}
	for {
		if !(count < int32(2)*B) {
			break
		}
		*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 168))).Fdp + uintptr(count-B)*4)) = *(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(b)).Fdp + uintptr(count)*4))
		(*(*Tmp_int)(unsafe.Pointer(bp + 168))).Fused++
		goto _12
	_12:
		;
		count++
	}
	XTclBN_mp_clamp(tls, bp+168)
	v13 = XTclBN_mp_init_size(tls, bp+192, B+((*Tmp_int)(unsafe.Pointer(b)).Fused-int32(3)*B))
	err = v13
	if v13 != MP_OKAY {
		goto LBL_ERRb2
	}
	for {
		if !(count < (*Tmp_int)(unsafe.Pointer(b)).Fused) {
			break
		}
		*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp + 192))).Fdp + uintptr(count-int32(2)*B)*4)) = *(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(b)).Fdp + uintptr(count)*4))
		(*(*Tmp_int)(unsafe.Pointer(bp + 192))).Fused++
		goto _14
	_14:
		;
		count++
	}
	XTclBN_mp_clamp(tls, bp+192)
	/** \\ S1 = (a2+a1+a0) * (b2+b1+b0); */
	/** T1 = a2 + a1; */
	v15 = XTclBN_mp_add(tls, bp+120, bp+96, bp+48)
	err = v15
	if v15 != MP_OKAY {
		goto LBL_ERR
	}
	/** S2 = T1 + a0; */
	v16 = XTclBN_mp_add(tls, bp+48, bp+72, bp+24)
	err = v16
	if v16 != MP_OKAY {
		goto LBL_ERR
	}
	/** c = b2 + b1; */
	v17 = XTclBN_mp_add(tls, bp+192, bp+168, c)
	err = v17
	if v17 != MP_OKAY {
		goto LBL_ERR
	}
	/** S1 = c + b0; */
	v18 = XTclBN_mp_add(tls, c, bp+144, bp)
	err = v18
	if v18 != MP_OKAY {
		goto LBL_ERR
	}
	/** S1 = S1 * S2; */
	v19 = XTclBN_mp_mul(tls, bp, bp+24, bp)
	err = v19
	if v19 != MP_OKAY {
		goto LBL_ERR
	}
	/** \\S2 = (4*a2+2*a1+a0) * (4*b2+2*b1+b0); */
	/** T1 = T1 + a2; */
	v20 = XTclBN_mp_add(tls, bp+48, bp+120, bp+48)
	err = v20
	if v20 != MP_OKAY {
		goto LBL_ERR
	}
	/** T1 = T1 << 1; */
	v21 = XTclBN_mp_mul_2(tls, bp+48, bp+48)
	err = v21
	if v21 != MP_OKAY {
		goto LBL_ERR
	}
	/** T1 = T1 + a0; */
	v22 = XTclBN_mp_add(tls, bp+48, bp+72, bp+48)
	err = v22
	if v22 != MP_OKAY {
		goto LBL_ERR
	}
	/** c = c + b2; */
	v23 = XTclBN_mp_add(tls, c, bp+192, c)
	err = v23
	if v23 != MP_OKAY {
		goto LBL_ERR
	}
	/** c = c << 1; */
	v24 = XTclBN_mp_mul_2(tls, c, c)
	err = v24
	if v24 != MP_OKAY {
		goto LBL_ERR
	}
	/** c = c + b0; */
	v25 = XTclBN_mp_add(tls, c, bp+144, c)
	err = v25
	if v25 != MP_OKAY {
		goto LBL_ERR
	}
	/** S2 = T1 * c; */
	v26 = XTclBN_mp_mul(tls, bp+48, c, bp+24)
	err = v26
	if v26 != MP_OKAY {
		goto LBL_ERR
	}
	/** \\S3 = (a2-a1+a0) * (b2-b1+b0); */
	/** a1 = a2 - a1; */
	v27 = XTclBN_mp_sub(tls, bp+120, bp+96, bp+96)
	err = v27
	if v27 != MP_OKAY {
		goto LBL_ERR
	}
	/** a1 = a1 + a0; */
	v28 = XTclBN_mp_add(tls, bp+96, bp+72, bp+96)
	err = v28
	if v28 != MP_OKAY {
		goto LBL_ERR
	}
	/** b1 = b2 - b1; */
	v29 = XTclBN_mp_sub(tls, bp+192, bp+168, bp+168)
	err = v29
	if v29 != MP_OKAY {
		goto LBL_ERR
	}
	/** b1 = b1 + b0; */
	v30 = XTclBN_mp_add(tls, bp+168, bp+144, bp+168)
	err = v30
	if v30 != MP_OKAY {
		goto LBL_ERR
	}
	/** a1 = a1 * b1; */
	v31 = XTclBN_mp_mul(tls, bp+96, bp+168, bp+96)
	err = v31
	if v31 != MP_OKAY {
		goto LBL_ERR
	}
	/** b1 = a2 * b2; */
	v32 = XTclBN_mp_mul(tls, bp+120, bp+192, bp+168)
	err = v32
	if v32 != MP_OKAY {
		goto LBL_ERR
	}
	/** \\S2 = (S2 - S3)/3; */
	/** S2 = S2 - a1; */
	v33 = XTclBN_mp_sub(tls, bp+24, bp+96, bp+24)
	err = v33
	if v33 != MP_OKAY {
		goto LBL_ERR
	}
	/** S2 = S2 / 3; \\ this is an exact division  */
	v34 = XTclBN_mp_div_3(tls, bp+24, bp+24, libc.UintptrFromInt32(0))
	err = v34
	if v34 != MP_OKAY {
		goto LBL_ERR
	}
	/** a1 = S1 - a1; */
	v35 = XTclBN_mp_sub(tls, bp, bp+96, bp+96)
	err = v35
	if v35 != MP_OKAY {
		goto LBL_ERR
	}
	/** a1 = a1 >> 1; */
	v36 = XTclBN_mp_div_2(tls, bp+96, bp+96)
	err = v36
	if v36 != MP_OKAY {
		goto LBL_ERR
	}
	/** a0 = a0 * b0; */
	v37 = XTclBN_mp_mul(tls, bp+72, bp+144, bp+72)
	err = v37
	if v37 != MP_OKAY {
		goto LBL_ERR
	}
	/** S1 = S1 - a0; */
	v38 = XTclBN_mp_sub(tls, bp, bp+72, bp)
	err = v38
	if v38 != MP_OKAY {
		goto LBL_ERR
	}
	/** S2 = S2 - S1; */
	v39 = XTclBN_mp_sub(tls, bp+24, bp, bp+24)
	err = v39
	if v39 != MP_OKAY {
		goto LBL_ERR
	}
	/** S2 = S2 >> 1; */
	v40 = XTclBN_mp_div_2(tls, bp+24, bp+24)
	err = v40
	if v40 != MP_OKAY {
		goto LBL_ERR
	}
	/** S1 = S1 - a1; */
	v41 = XTclBN_mp_sub(tls, bp, bp+96, bp)
	err = v41
	if v41 != MP_OKAY {
		goto LBL_ERR
	}
	/** S1 = S1 - b1; */
	v42 = XTclBN_mp_sub(tls, bp, bp+168, bp)
	err = v42
	if v42 != MP_OKAY {
		goto LBL_ERR
	}
	/** T1 = b1 << 1; */
	v43 = XTclBN_mp_mul_2(tls, bp+168, bp+48)
	err = v43
	if v43 != MP_OKAY {
		goto LBL_ERR
	}
	/** S2 = S2 - T1; */
	v44 = XTclBN_mp_sub(tls, bp+24, bp+48, bp+24)
	err = v44
	if v44 != MP_OKAY {
		goto LBL_ERR
	}
	/** a1 = a1 - S2; */
	v45 = XTclBN_mp_sub(tls, bp+96, bp+24, bp+96)
	err = v45
	if v45 != MP_OKAY {
		goto LBL_ERR
	}
	/** P = b1*x^4+ S2*x^3+ S1*x^2+ a1*x + a0; */
	v46 = XTclBN_mp_lshd(tls, bp+168, int32(4)*B)
	err = v46
	if v46 != MP_OKAY {
		goto LBL_ERR
	}
	v47 = XTclBN_mp_lshd(tls, bp+24, int32(3)*B)
	err = v47
	if v47 != MP_OKAY {
		goto LBL_ERR
	}
	v48 = XTclBN_mp_add(tls, bp+168, bp+24, bp+168)
	err = v48
	if v48 != MP_OKAY {
		goto LBL_ERR
	}
	v49 = XTclBN_mp_lshd(tls, bp, int32(2)*B)
	err = v49
	if v49 != MP_OKAY {
		goto LBL_ERR
	}
	v50 = XTclBN_mp_add(tls, bp+168, bp, bp+168)
	err = v50
	if v50 != MP_OKAY {
		goto LBL_ERR
	}
	v51 = XTclBN_mp_lshd(tls, bp+96, int32(1)*B)
	err = v51
	if v51 != MP_OKAY {
		goto LBL_ERR
	}
	v52 = XTclBN_mp_add(tls, bp+168, bp+96, bp+168)
	err = v52
	if v52 != MP_OKAY {
		goto LBL_ERR
	}
	v53 = XTclBN_mp_add(tls, bp+168, bp+72, c)
	err = v53
	if v53 != MP_OKAY {
		goto LBL_ERR
	}
	/** a * b - P */
	goto LBL_ERR
LBL_ERR:
	;
	XTclBN_mp_clear(tls, bp+192)
	goto LBL_ERRb2
LBL_ERRb2:
	;
	XTclBN_mp_clear(tls, bp+168)
	goto LBL_ERRb1
LBL_ERRb1:
	;
	XTclBN_mp_clear(tls, bp+144)
	goto LBL_ERRb0
LBL_ERRb0:
	;
	XTclBN_mp_clear(tls, bp+120)
	goto LBL_ERRa2
LBL_ERRa2:
	;
	XTclBN_mp_clear(tls, bp+96)
	goto LBL_ERRa1
LBL_ERRa1:
	;
	XTclBN_mp_clear(tls, bp+72)
	goto LBL_ERRa0
LBL_ERRa0:
	;
	XTclBN_mp_clear_multi(tls, bp, libc.VaList(bp+224, bp+24, bp+48, libc.UintptrFromInt32(0)))
	return err
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

/* squaring using Toom-Cook 3-way algorithm */

/*
   This file contains code from J. Arndt's book  "Matters Computational"
   and the accompanying FXT-library with permission of the author.
*/

// C documentation
//
//	/* squaring using Toom-Cook 3-way algorithm */
//	/*
//	   Setup and interpolation from algorithm SQR_3 in
//
//	     Chung, Jaewook, and M. Anwar Hasan. "Asymmetric squaring formulae."
//	     18th IEEE Symposium on Computer Arithmetic (ARITH'07). IEEE, 2007.
//
//	*/
func XTclBN_mp_toom_sqr(tls *libc.TLS, a uintptr, b uintptr) (r Tmp_err) {
	bp := tls.Alloc(96)
	defer tls.Free(96)
	var B, count int32
	var err, v1, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v4 Tmp_err
	var tmpa, tmpc, v10, v12, v13, v6, v7, v9 uintptr
	var _ /* S0 at bp+0 */ Tmp_int
	var _ /* a0 at bp+24 */ Tmp_int
	var _ /* a1 at bp+48 */ Tmp_int
	var _ /* a2 at bp+72 */ Tmp_int
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = B, count, err, tmpa, tmpc, v1, v10, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v4, v6, v7, v9
	/* init temps */
	v1 = XTclBN_mp_init(tls, bp)
	err = v1
	if v1 != MP_OKAY {
		return err
	}
	/* B */
	B = (*Tmp_int)(unsafe.Pointer(a)).Fused / int32(3)
	/** a = a2 * x^2 + a1 * x + a0; */
	v2 = XTclBN_mp_init_size(tls, bp+24, B)
	err = v2
	if v2 != MP_OKAY {
		goto LBL_ERRa0
	}
	(*(*Tmp_int)(unsafe.Pointer(bp + 24))).Fused = B
	v3 = XTclBN_mp_init_size(tls, bp+48, B)
	err = v3
	if v3 != MP_OKAY {
		goto LBL_ERRa1
	}
	(*(*Tmp_int)(unsafe.Pointer(bp + 48))).Fused = B
	v4 = XTclBN_mp_init_size(tls, bp+72, B+((*Tmp_int)(unsafe.Pointer(a)).Fused-int32(3)*B))
	err = v4
	if v4 != MP_OKAY {
		goto LBL_ERRa2
	}
	tmpa = (*Tmp_int)(unsafe.Pointer(a)).Fdp
	tmpc = (*(*Tmp_int)(unsafe.Pointer(bp + 24))).Fdp
	count = 0
	for {
		if !(count < B) {
			break
		}
		v6 = tmpc
		tmpc += 4
		v7 = tmpa
		tmpa += 4
		*(*Tmp_digit)(unsafe.Pointer(v6)) = *(*Tmp_digit)(unsafe.Pointer(v7))
		goto _5
	_5:
		;
		count++
	}
	tmpc = (*(*Tmp_int)(unsafe.Pointer(bp + 48))).Fdp
	for {
		if !(count < int32(2)*B) {
			break
		}
		v9 = tmpc
		tmpc += 4
		v10 = tmpa
		tmpa += 4
		*(*Tmp_digit)(unsafe.Pointer(v9)) = *(*Tmp_digit)(unsafe.Pointer(v10))
		goto _8
	_8:
		;
		count++
	}
	tmpc = (*(*Tmp_int)(unsafe.Pointer(bp + 72))).Fdp
	for {
		if !(count < (*Tmp_int)(unsafe.Pointer(a)).Fused) {
			break
		}
		v12 = tmpc
		tmpc += 4
		v13 = tmpa
		tmpa += 4
		*(*Tmp_digit)(unsafe.Pointer(v12)) = *(*Tmp_digit)(unsafe.Pointer(v13))
		(*(*Tmp_int)(unsafe.Pointer(bp + 72))).Fused++
		goto _11
	_11:
		;
		count++
	}
	XTclBN_mp_clamp(tls, bp+24)
	XTclBN_mp_clamp(tls, bp+48)
	XTclBN_mp_clamp(tls, bp+72)
	/** S0 = a0^2;  */
	v14 = XTclBN_mp_sqr(tls, bp+24, bp)
	err = v14
	if v14 != MP_OKAY {
		goto LBL_ERR
	}
	/** \\S1 = (a2 + a1 + a0)^2 */
	/** \\S2 = (a2 - a1 + a0)^2  */
	/** \\S1 = a0 + a2; */
	/** a0 = a0 + a2; */
	v15 = XTclBN_mp_add(tls, bp+24, bp+72, bp+24)
	err = v15
	if v15 != MP_OKAY {
		goto LBL_ERR
	}
	/** \\S2 = S1 - a1; */
	/** b = a0 - a1; */
	v16 = XTclBN_mp_sub(tls, bp+24, bp+48, b)
	err = v16
	if v16 != MP_OKAY {
		goto LBL_ERR
	}
	/** \\S1 = S1 + a1; */
	/** a0 = a0 + a1; */
	v17 = XTclBN_mp_add(tls, bp+24, bp+48, bp+24)
	err = v17
	if v17 != MP_OKAY {
		goto LBL_ERR
	}
	/** \\S1 = S1^2;  */
	/** a0 = a0^2; */
	v18 = XTclBN_mp_sqr(tls, bp+24, bp+24)
	err = v18
	if v18 != MP_OKAY {
		goto LBL_ERR
	}
	/** \\S2 = S2^2;  */
	/** b = b^2; */
	v19 = XTclBN_mp_sqr(tls, b, b)
	err = v19
	if v19 != MP_OKAY {
		goto LBL_ERR
	}
	/** \\ S3 = 2 * a1 * a2  */
	/** \\S3 = a1 * a2;  */
	/** a1 = a1 * a2; */
	v20 = XTclBN_mp_mul(tls, bp+48, bp+72, bp+48)
	err = v20
	if v20 != MP_OKAY {
		goto LBL_ERR
	}
	/** \\S3 = S3 << 1;  */
	/** a1 = a1 << 1; */
	v21 = XTclBN_mp_mul_2(tls, bp+48, bp+48)
	err = v21
	if v21 != MP_OKAY {
		goto LBL_ERR
	}
	/** \\S4 = a2^2;  */
	/** a2 = a2^2; */
	v22 = XTclBN_mp_sqr(tls, bp+72, bp+72)
	err = v22
	if v22 != MP_OKAY {
		goto LBL_ERR
	}
	/** \\ tmp = (S1 + S2)/2  */
	/** \\tmp = S1 + S2; */
	/** b = a0 + b; */
	v23 = XTclBN_mp_add(tls, bp+24, b, b)
	err = v23
	if v23 != MP_OKAY {
		goto LBL_ERR
	}
	/** \\tmp = tmp >> 1; */
	/** b = b >> 1; */
	v24 = XTclBN_mp_div_2(tls, b, b)
	err = v24
	if v24 != MP_OKAY {
		goto LBL_ERR
	}
	/** \\ S1 = S1 - tmp - S3  */
	/** \\S1 = S1 - tmp; */
	/** a0 = a0 - b; */
	v25 = XTclBN_mp_sub(tls, bp+24, b, bp+24)
	err = v25
	if v25 != MP_OKAY {
		goto LBL_ERR
	}
	/** \\S1 = S1 - S3;  */
	/** a0 = a0 - a1; */
	v26 = XTclBN_mp_sub(tls, bp+24, bp+48, bp+24)
	err = v26
	if v26 != MP_OKAY {
		goto LBL_ERR
	}
	/** \\S2 = tmp - S4 -S0  */
	/** \\S2 = tmp - S4;  */
	/** b = b - a2; */
	v27 = XTclBN_mp_sub(tls, b, bp+72, b)
	err = v27
	if v27 != MP_OKAY {
		goto LBL_ERR
	}
	/** \\S2 = S2 - S0;  */
	/** b = b - S0; */
	v28 = XTclBN_mp_sub(tls, b, bp, b)
	err = v28
	if v28 != MP_OKAY {
		goto LBL_ERR
	}
	/** \\P = S4*x^4 + S3*x^3 + S2*x^2 + S1*x + S0; */
	/** P = a2*x^4 + a1*x^3 + b*x^2 + a0*x + S0; */
	v29 = XTclBN_mp_lshd(tls, bp+72, int32(4)*B)
	err = v29
	if v29 != MP_OKAY {
		goto LBL_ERR
	}
	v30 = XTclBN_mp_lshd(tls, bp+48, int32(3)*B)
	err = v30
	if v30 != MP_OKAY {
		goto LBL_ERR
	}
	v31 = XTclBN_mp_lshd(tls, b, int32(2)*B)
	err = v31
	if v31 != MP_OKAY {
		goto LBL_ERR
	}
	v32 = XTclBN_mp_lshd(tls, bp+24, int32(1)*B)
	err = v32
	if v32 != MP_OKAY {
		goto LBL_ERR
	}
	v33 = XTclBN_mp_add(tls, bp+72, bp+48, bp+72)
	err = v33
	if v33 != MP_OKAY {
		goto LBL_ERR
	}
	v34 = XTclBN_mp_add(tls, bp+72, b, b)
	err = v34
	if v34 != MP_OKAY {
		goto LBL_ERR
	}
	v35 = XTclBN_mp_add(tls, b, bp+24, b)
	err = v35
	if v35 != MP_OKAY {
		goto LBL_ERR
	}
	v36 = XTclBN_mp_add(tls, b, bp, b)
	err = v36
	if v36 != MP_OKAY {
		goto LBL_ERR
	}
	/** a^2 - P  */
	goto LBL_ERR
LBL_ERR:
	;
	XTclBN_mp_clear(tls, bp+72)
	goto LBL_ERRa2
LBL_ERRa2:
	;
	XTclBN_mp_clear(tls, bp+48)
	goto LBL_ERRa1
LBL_ERRa1:
	;
	XTclBN_mp_clear(tls, bp+24)
	goto LBL_ERRa0
LBL_ERRa0:
	;
	XTclBN_mp_clear(tls, bp)
	return err
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* stores a bignum as a ASCII string in a given radix (2..64)
//	 *
//	 * Stores upto "size - 1" chars and always a NULL byte, puts the number of characters
//	 * written, including the '\0', in "written".
//	 */
func XTclBN_mp_to_radix(tls *libc.TLS, a uintptr, str uintptr, maxlen Tsize_t, written uintptr, radix int32) (r Tmp_err) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _s, v1, v3, v6 uintptr
	var digs, v4 Tsize_t
	var err, v2, v5 Tmp_err
	var v7 uint64
	var _ /* d at bp+24 */ Tmp_digit
	var _ /* t at bp+0 */ Tmp_int
	_, _, _, _, _, _, _, _, _, _ = _s, digs, err, v1, v2, v3, v4, v5, v6, v7
	_s = str
	/* check range of radix and size*/
	if maxlen < uint64(2) {
		return -int32(5)
	}
	if radix < int32(2) || radix > int32(64) {
		return -int32(3)
	}
	/* quick out if its zero */
	if (*Tmp_int)(unsafe.Pointer(a)).Fused == 0 {
		v1 = str
		str++
		*(*uint8)(unsafe.Pointer(v1)) = uint8('0')
		*(*uint8)(unsafe.Pointer(str)) = uint8('\000')
		if written != libc.UintptrFromInt32(0) {
			*(*Tsize_t)(unsafe.Pointer(written)) = uint64(2)
		}
		return MP_OKAY
	}
	v2 = XTclBN_mp_init_copy(tls, bp, a)
	err = v2
	if v2 != MP_OKAY {
		return err
	}
	/* if it is negative output a - */
	if (*(*Tmp_int)(unsafe.Pointer(bp))).Fsign == int32(MP_NEG) {
		/* we have to reverse our digits later... but not the - sign!! */
		_s++
		/* store the flag and mark the number as positive */
		v3 = str
		str++
		*(*uint8)(unsafe.Pointer(v3)) = uint8('-')
		(*(*Tmp_int)(unsafe.Pointer(bp))).Fsign = MP_ZPOS
		/* subtract a char */
		maxlen--
	}
	digs = 0
	for !((*Tmp_int)(unsafe.Pointer(bp)).Fused == libc.Int32FromInt32(0)) {
		maxlen--
		v4 = maxlen
		if v4 < uint64(1) {
			/* no more room */
			err = -int32(5)
			goto LBL_ERR
		}
		v5 = XTclBN_mp_div_d(tls, bp, libc.Uint32FromInt32(radix), bp, bp+24)
		err = v5
		if v5 != MP_OKAY {
			goto LBL_ERR
		}
		v6 = str
		str++
		*(*uint8)(unsafe.Pointer(v6)) = *(*uint8)(unsafe.Pointer(XTclBN_mp_s_rmap + uintptr(*(*Tmp_digit)(unsafe.Pointer(bp + 24)))))
		digs++
	}
	/* reverse the digits of the string.  In this case _s points
	 * to the first digit [exluding the sign] of the number
	 */
	XTclBN_mp_reverse(tls, _s, digs)
	/* append a NULL so the string is properly terminated */
	*(*uint8)(unsafe.Pointer(str)) = uint8('\000')
	digs++
	if written != libc.UintptrFromInt32(0) {
		if (*Tmp_int)(unsafe.Pointer(a)).Fsign == int32(MP_NEG) {
			v7 = digs + uint64(1)
		} else {
			v7 = digs
		}
		*(*Tsize_t)(unsafe.Pointer(written)) = v7
	}
	goto LBL_ERR
LBL_ERR:
	;
	XTclBN_mp_clear(tls, bp)
	return err
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* get the size for an unsigned equivalent */
func XTclBN_mp_ubin_size(tls *libc.TLS, a uintptr) (r Tsize_t) {
	var size Tsize_t
	var v1 uint32
	_, _ = size, v1
	size = libc.Uint64FromInt32(XTclBN_mp_count_bits(tls, a))
	if size&uint64(7) != 0 {
		v1 = uint32(1)
	} else {
		v1 = 0
	}
	return size/uint64(8) + uint64(v1)
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* two complement xor */
func XTclBN_mp_xor(tls *libc.TLS, a uintptr, b uintptr, c uintptr) (r Tmp_err) {
	var ac, bc, cc, x, y Tmp_digit
	var csign Tmp_sign
	var err, v3 Tmp_err
	var i, used, v1, v2 int32
	var v5, v7 uint32
	var v6, v8 uint64
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = ac, bc, cc, csign, err, i, used, x, y, v1, v2, v3, v5, v6, v7, v8
	if (*Tmp_int)(unsafe.Pointer(a)).Fused > (*Tmp_int)(unsafe.Pointer(b)).Fused {
		v1 = (*Tmp_int)(unsafe.Pointer(a)).Fused
	} else {
		v1 = (*Tmp_int)(unsafe.Pointer(b)).Fused
	}
	used = v1 + int32(1)
	ac = uint32(1)
	bc = uint32(1)
	cc = uint32(1)
	if (*Tmp_int)(unsafe.Pointer(a)).Fsign != (*Tmp_int)(unsafe.Pointer(b)).Fsign {
		v2 = int32(MP_NEG)
	} else {
		v2 = MP_ZPOS
	}
	csign = v2
	if (*Tmp_int)(unsafe.Pointer(c)).Falloc < used {
		v3 = XTclBN_mp_grow(tls, c, used)
		err = v3
		if v3 != MP_OKAY {
			return err
		}
	}
	i = 0
	for {
		if !(i < used) {
			break
		}
		/* convert to two complement if negative */
		if (*Tmp_int)(unsafe.Pointer(a)).Fsign == int32(MP_NEG) {
			if i >= (*Tmp_int)(unsafe.Pointer(a)).Fused {
				v5 = libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1)
			} else {
				v5 = ^*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr(i)*4)) & (libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1))
			}
			ac += v5
			x = ac & (libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1))
			ac >>= uint32(MP_DIGIT_BIT)
		} else {
			if i >= (*Tmp_int)(unsafe.Pointer(a)).Fused {
				v6 = 0
			} else {
				v6 = uint64(*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr(i)*4)))
			}
			x = uint32(v6)
		}
		/* convert to two complement if negative */
		if (*Tmp_int)(unsafe.Pointer(b)).Fsign == int32(MP_NEG) {
			if i >= (*Tmp_int)(unsafe.Pointer(b)).Fused {
				v7 = libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1)
			} else {
				v7 = ^*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(b)).Fdp + uintptr(i)*4)) & (libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1))
			}
			bc += v7
			y = bc & (libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1))
			bc >>= uint32(MP_DIGIT_BIT)
		} else {
			if i >= (*Tmp_int)(unsafe.Pointer(b)).Fused {
				v8 = 0
			} else {
				v8 = uint64(*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(b)).Fdp + uintptr(i)*4)))
			}
			y = uint32(v8)
		}
		*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(c)).Fdp + uintptr(i)*4)) = x ^ y
		/* convert to to sign-magnitude if negative */
		if csign == int32(MP_NEG) {
			cc += ^*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(c)).Fdp + uintptr(i)*4)) & (libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1))
			*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(c)).Fdp + uintptr(i)*4)) = cc & (libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1))
			cc >>= uint32(MP_DIGIT_BIT)
		}
		goto _4
	_4:
		;
		i++
	}
	(*Tmp_int)(unsafe.Pointer(c)).Fused = used
	(*Tmp_int)(unsafe.Pointer(c)).Fsign = csign
	XTclBN_mp_clamp(tls, c)
	return MP_OKAY
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* set to zero */
func XTclBN_mp_zero(tls *libc.TLS, a uintptr) {
	var zd_, v1 int32
	var zm_, v2 uintptr
	_, _, _, _ = zd_, zm_, v1, v2
	(*Tmp_int)(unsafe.Pointer(a)).Fsign = MP_ZPOS
	(*Tmp_int)(unsafe.Pointer(a)).Fused = 0
	zd_ = (*Tmp_int)(unsafe.Pointer(a)).Falloc
	zm_ = (*Tmp_int)(unsafe.Pointer(a)).Fdp
	for {
		v1 = zd_
		zd_--
		if !(v1 > 0) {
			break
		}
		v2 = zm_
		zm_ += 4
		*(*Tmp_digit)(unsafe.Pointer(v2)) = uint32(0)
	}
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* low level addition, based on HAC pp.594, Algorithm 14.7 */
func XTclBN_s_mp_add(tls *libc.TLS, a uintptr, b uintptr, c uintptr) (r Tmp_err) {
	var err, v1 Tmp_err
	var i, max, min, olduse, zd_, v9 int32
	var tmpa, tmpb, tmpc, x, zm_, v10, v3, v4, v5, v7, v8 uintptr
	var u Tmp_digit
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = err, i, max, min, olduse, tmpa, tmpb, tmpc, u, x, zd_, zm_, v1, v10, v3, v4, v5, v7, v8, v9
	/* find sizes, we let |a| <= |b| which means we have to sort
	 * them.  "x" will point to the input with the most digits
	 */
	if (*Tmp_int)(unsafe.Pointer(a)).Fused > (*Tmp_int)(unsafe.Pointer(b)).Fused {
		min = (*Tmp_int)(unsafe.Pointer(b)).Fused
		max = (*Tmp_int)(unsafe.Pointer(a)).Fused
		x = a
	} else {
		min = (*Tmp_int)(unsafe.Pointer(a)).Fused
		max = (*Tmp_int)(unsafe.Pointer(b)).Fused
		x = b
	}
	/* init result */
	if (*Tmp_int)(unsafe.Pointer(c)).Falloc < max+int32(1) {
		v1 = XTclBN_mp_grow(tls, c, max+int32(1))
		err = v1
		if v1 != MP_OKAY {
			return err
		}
	}
	/* get old used digit count and set new one */
	olduse = (*Tmp_int)(unsafe.Pointer(c)).Fused
	(*Tmp_int)(unsafe.Pointer(c)).Fused = max + int32(1)
	/* alias for digit pointers */
	/* first input */
	tmpa = (*Tmp_int)(unsafe.Pointer(a)).Fdp
	/* second input */
	tmpb = (*Tmp_int)(unsafe.Pointer(b)).Fdp
	/* destination */
	tmpc = (*Tmp_int)(unsafe.Pointer(c)).Fdp
	/* zero the carry */
	u = uint32(0)
	i = 0
	for {
		if !(i < min) {
			break
		}
		/* Compute the sum at one digit, T[i] = A[i] + B[i] + U */
		v3 = tmpa
		tmpa += 4
		v4 = tmpb
		tmpb += 4
		*(*Tmp_digit)(unsafe.Pointer(tmpc)) = *(*Tmp_digit)(unsafe.Pointer(v3)) + *(*Tmp_digit)(unsafe.Pointer(v4)) + u
		/* U = carry bit of T[i] */
		u = *(*Tmp_digit)(unsafe.Pointer(tmpc)) >> libc.Uint32FromInt32(MP_DIGIT_BIT)
		/* take away carry bit from T[i] */
		v5 = tmpc
		tmpc += 4
		*(*Tmp_digit)(unsafe.Pointer(v5)) &= libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1)
		goto _2
	_2:
		;
		i++
	}
	/* now copy higher words if any, that is in A+B
	 * if A or B has more digits add those in
	 */
	if min != max {
		for {
			if !(i < max) {
				break
			}
			/* T[i] = X[i] + U */
			*(*Tmp_digit)(unsafe.Pointer(tmpc)) = *(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(x)).Fdp + uintptr(i)*4)) + u
			/* U = carry bit of T[i] */
			u = *(*Tmp_digit)(unsafe.Pointer(tmpc)) >> libc.Uint32FromInt32(MP_DIGIT_BIT)
			/* take away carry bit from T[i] */
			v7 = tmpc
			tmpc += 4
			*(*Tmp_digit)(unsafe.Pointer(v7)) &= libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1)
			goto _6
		_6:
			;
			i++
		}
	}
	/* add carry */
	v8 = tmpc
	tmpc += 4
	*(*Tmp_digit)(unsafe.Pointer(v8)) = u
	/* clear digits above oldused */
	zd_ = olduse - (*Tmp_int)(unsafe.Pointer(c)).Fused
	zm_ = tmpc
	for {
		v9 = zd_
		zd_--
		if !(v9 > 0) {
			break
		}
		v10 = zm_
		zm_ += 4
		*(*Tmp_digit)(unsafe.Pointer(v10)) = uint32(0)
	}
	XTclBN_mp_clamp(tls, c)
	return MP_OKAY
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* multiplies |a| * |b| and only computes upto digs digits of result
//	 * HAC pp. 595, Algorithm 14.12  Modified so you can control how
//	 * many digits of output are created.
//	 */
func XTclBN_mp_mul_digs(tls *libc.TLS, a uintptr, b uintptr, c uintptr, digs int32) (r1 Tmp_err) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var err, v3 Tmp_err
	var ix, iy, pa, pb, v1, v5 int32
	var r Tmp_word
	var tmpt, tmpy, v7, v8 uintptr
	var tmpx, u Tmp_digit
	var v2 bool
	var _ /* t at bp+0 */ Tmp_int
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = err, ix, iy, pa, pb, r, tmpt, tmpx, tmpy, u, v1, v2, v3, v5, v7, v8
	if digs < 0 {
		return -int32(3)
	}
	/* can we use the fast multiplier? */
	if v2 = digs < libc.Int32FromInt32(1)<<(libc.Int32FromInt32(CHAR_BIT)*libc.Int32FromInt64(8)-libc.Int32FromInt32(2)*libc.Int32FromInt32(MP_DIGIT_BIT)+libc.Int32FromInt32(1)); v2 {
		if (*Tmp_int)(unsafe.Pointer(a)).Fused < (*Tmp_int)(unsafe.Pointer(b)).Fused {
			v1 = (*Tmp_int)(unsafe.Pointer(a)).Fused
		} else {
			v1 = (*Tmp_int)(unsafe.Pointer(b)).Fused
		}
	}
	if v2 && v1 < libc.Int32FromUint64(libc.Uint64FromUint64(1)<<(libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(8)-libc.Uint64FromUint32(2)*libc.Uint64FromInt32(MP_DIGIT_BIT))) {
		return XTclBN_mp_mul_digs_fast(tls, a, b, c, digs)
	}
	v3 = XTclBN_mp_init_size(tls, bp, digs)
	err = v3
	if v3 != MP_OKAY {
		return err
	}
	(*(*Tmp_int)(unsafe.Pointer(bp))).Fused = digs
	/* compute the digits of the product directly */
	pa = (*Tmp_int)(unsafe.Pointer(a)).Fused
	ix = 0
	for {
		if !(ix < pa) {
			break
		}
		/* set the carry to zero */
		u = uint32(0)
		/* limit ourselves to making digs digits of output */
		if (*Tmp_int)(unsafe.Pointer(b)).Fused < digs-ix {
			v5 = (*Tmp_int)(unsafe.Pointer(b)).Fused
		} else {
			v5 = digs - ix
		}
		pb = v5
		/* setup some aliases */
		/* copy of the digit from a used within the nested loop */
		tmpx = *(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr(ix)*4))
		/* an alias for the destination shifted ix places */
		tmpt = (*(*Tmp_int)(unsafe.Pointer(bp))).Fdp + uintptr(ix)*4
		/* an alias for the digits of b */
		tmpy = (*Tmp_int)(unsafe.Pointer(b)).Fdp
		/* compute the columns of the output and propagate the carry */
		iy = 0
		for {
			if !(iy < pb) {
				break
			}
			/* compute the column as a mp_word */
			v7 = tmpy
			tmpy += 4
			r = uint64(*(*Tmp_digit)(unsafe.Pointer(tmpt))) + uint64(tmpx)*uint64(*(*Tmp_digit)(unsafe.Pointer(v7))) + uint64(u)
			/* the new column is the lower part of the result */
			v8 = tmpt
			tmpt += 4
			*(*Tmp_digit)(unsafe.Pointer(v8)) = uint32(r & uint64(libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT)-libc.Uint32FromInt32(1)))
			/* get the carry word from the result */
			u = uint32(r >> libc.Uint64FromInt32(MP_DIGIT_BIT))
			goto _6
		_6:
			;
			iy++
		}
		/* set carry if it is placed below digs */
		if ix+iy < digs {
			*(*Tmp_digit)(unsafe.Pointer(tmpt)) = u
		}
		goto _4
	_4:
		;
		ix++
	}
	XTclBN_mp_clamp(tls, bp)
	XTclBN_mp_exch(tls, bp, c)
	XTclBN_mp_clear(tls, bp)
	return MP_OKAY
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* low level squaring, b = a*a, HAC pp.596-597, Algorithm 14.16 */
func XTclBN_s_mp_sqr(tls *libc.TLS, a uintptr, b uintptr) (r1 Tmp_err) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var err, v1 Tmp_err
	var ix, iy, pa int32
	var r Tmp_word
	var tmpt, v4, v5 uintptr
	var tmpx, u Tmp_digit
	var _ /* t at bp+0 */ Tmp_int
	_, _, _, _, _, _, _, _, _, _, _ = err, ix, iy, pa, r, tmpt, tmpx, u, v1, v4, v5
	pa = (*Tmp_int)(unsafe.Pointer(a)).Fused
	v1 = XTclBN_mp_init_size(tls, bp, int32(2)*pa+int32(1))
	err = v1
	if v1 != MP_OKAY {
		return err
	}
	/* default used is maximum possible size */
	(*(*Tmp_int)(unsafe.Pointer(bp))).Fused = int32(2)*pa + int32(1)
	ix = 0
	for {
		if !(ix < pa) {
			break
		}
		/* first calculate the digit at 2*ix */
		/* calculate double precision result */
		r = uint64(*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp + uintptr(int32(2)*ix)*4))) + uint64(*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr(ix)*4)))*uint64(*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr(ix)*4)))
		/* store lower part in result */
		*(*Tmp_digit)(unsafe.Pointer((*(*Tmp_int)(unsafe.Pointer(bp))).Fdp + uintptr(ix+ix)*4)) = uint32(r & uint64(libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT)-libc.Uint32FromInt32(1)))
		/* get the carry */
		u = uint32(r >> libc.Uint64FromInt32(MP_DIGIT_BIT))
		/* left hand side of A[ix] * A[iy] */
		tmpx = *(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr(ix)*4))
		/* alias for where to store the results */
		tmpt = (*(*Tmp_int)(unsafe.Pointer(bp))).Fdp + uintptr(libc.Int32FromInt32(2)*ix+libc.Int32FromInt32(1))*4
		iy = ix + int32(1)
		for {
			if !(iy < pa) {
				break
			}
			/* first calculate the product */
			r = uint64(tmpx) * uint64(*(*Tmp_digit)(unsafe.Pointer((*Tmp_int)(unsafe.Pointer(a)).Fdp + uintptr(iy)*4)))
			/* now calculate the double precision result, note we use
			 * addition instead of *2 since it's easier to optimize
			 */
			r = uint64(*(*Tmp_digit)(unsafe.Pointer(tmpt))) + r + r + uint64(u)
			/* store lower part */
			v4 = tmpt
			tmpt += 4
			*(*Tmp_digit)(unsafe.Pointer(v4)) = uint32(r & uint64(libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT)-libc.Uint32FromInt32(1)))
			/* get carry */
			u = uint32(r >> libc.Uint64FromInt32(MP_DIGIT_BIT))
			goto _3
		_3:
			;
			iy++
		}
		/* propagate upwards */
		for uint64(u) != 0 {
			r = uint64(*(*Tmp_digit)(unsafe.Pointer(tmpt))) + uint64(u)
			v5 = tmpt
			tmpt += 4
			*(*Tmp_digit)(unsafe.Pointer(v5)) = uint32(r & uint64(libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT)-libc.Uint32FromInt32(1)))
			u = uint32(r >> libc.Uint64FromInt32(MP_DIGIT_BIT))
		}
		goto _2
	_2:
		;
		ix++
	}
	XTclBN_mp_clamp(tls, bp)
	XTclBN_mp_exch(tls, bp, b)
	XTclBN_mp_clear(tls, bp)
	return MP_OKAY
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* low level subtraction (assumes |a| > |b|), HAC pp.595 Algorithm 14.9 */
func XTclBN_s_mp_sub(tls *libc.TLS, a uintptr, b uintptr, c uintptr) (r Tmp_err) {
	var err, v1 Tmp_err
	var i, max, min, olduse, zd_, v9 int32
	var tmpa, tmpb, tmpc, zm_, v10, v3, v4, v5, v7, v8 uintptr
	var u Tmp_digit
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = err, i, max, min, olduse, tmpa, tmpb, tmpc, u, zd_, zm_, v1, v10, v3, v4, v5, v7, v8, v9
	/* find sizes */
	min = (*Tmp_int)(unsafe.Pointer(b)).Fused
	max = (*Tmp_int)(unsafe.Pointer(a)).Fused
	/* init result */
	if (*Tmp_int)(unsafe.Pointer(c)).Falloc < max {
		v1 = XTclBN_mp_grow(tls, c, max)
		err = v1
		if v1 != MP_OKAY {
			return err
		}
	}
	olduse = (*Tmp_int)(unsafe.Pointer(c)).Fused
	(*Tmp_int)(unsafe.Pointer(c)).Fused = max
	/* alias for digit pointers */
	tmpa = (*Tmp_int)(unsafe.Pointer(a)).Fdp
	tmpb = (*Tmp_int)(unsafe.Pointer(b)).Fdp
	tmpc = (*Tmp_int)(unsafe.Pointer(c)).Fdp
	/* set carry to zero */
	u = uint32(0)
	i = 0
	for {
		if !(i < min) {
			break
		}
		/* T[i] = A[i] - B[i] - U */
		v3 = tmpa
		tmpa += 4
		v4 = tmpb
		tmpb += 4
		*(*Tmp_digit)(unsafe.Pointer(tmpc)) = *(*Tmp_digit)(unsafe.Pointer(v3)) - *(*Tmp_digit)(unsafe.Pointer(v4)) - u
		/* U = carry bit of T[i]
		 * Note this saves performing an AND operation since
		 * if a carry does occur it will propagate all the way to the
		 * MSB.  As a result a single shift is enough to get the carry
		 */
		u = *(*Tmp_digit)(unsafe.Pointer(tmpc)) >> (libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(4) - libc.Uint64FromUint32(1))
		/* Clear carry from T[i] */
		v5 = tmpc
		tmpc += 4
		*(*Tmp_digit)(unsafe.Pointer(v5)) &= libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1)
		goto _2
	_2:
		;
		i++
	}
	/* now copy higher words if any, e.g. if A has more digits than B  */
	for {
		if !(i < max) {
			break
		}
		/* T[i] = A[i] - U */
		v7 = tmpa
		tmpa += 4
		*(*Tmp_digit)(unsafe.Pointer(tmpc)) = *(*Tmp_digit)(unsafe.Pointer(v7)) - u
		/* U = carry bit of T[i] */
		u = *(*Tmp_digit)(unsafe.Pointer(tmpc)) >> (libc.Uint64FromInt32(CHAR_BIT)*libc.Uint64FromInt64(4) - libc.Uint64FromUint32(1))
		/* Clear carry from T[i] */
		v8 = tmpc
		tmpc += 4
		*(*Tmp_digit)(unsafe.Pointer(v8)) &= libc.Uint32FromInt32(1)<<libc.Uint32FromInt32(MP_DIGIT_BIT) - libc.Uint32FromInt32(1)
		goto _6
	_6:
		;
		i++
	}
	/* clear digits above used (since we may not have grown result above) */
	zd_ = olduse - (*Tmp_int)(unsafe.Pointer(c)).Fused
	zm_ = tmpc
	for {
		v9 = zd_
		zd_--
		if !(v9 > 0) {
			break
		}
		v10 = zm_
		zm_ += 4
		*(*Tmp_digit)(unsafe.Pointer(v10)) = uint32(0)
	}
	XTclBN_mp_clamp(tls, c)
	return MP_OKAY
}

func __ccgo_fp(f interface{}) uintptr {
	type iface [2]uintptr
	return (*iface)(unsafe.Pointer(&f))[1]
}

/* code-generating macros */

/* LibTomMath, multiple-precision integer library -- Tom St Denis */
/* SPDX-License-Identifier: Unlicense */

// C documentation
//
//	/* chars used in radix conversions */
var XTclBN_mp_s_rmap = __ccgo_ts + 93605

var XTclBN_mp_s_rmap_reverse = [88]Tuint8_t{
	0:  uint8(0xff),
	1:  uint8(0xff),
	2:  uint8(0xff),
	3:  uint8(0x3e),
	4:  uint8(0xff),
	5:  uint8(0xff),
	6:  uint8(0xff),
	7:  uint8(0x3f),
	9:  uint8(0x01),
	10: uint8(0x02),
	11: uint8(0x03),
	12: uint8(0x04),
	13: uint8(0x05),
	14: uint8(0x06),
	15: uint8(0x07),
	16: uint8(0x08),
	17: uint8(0x09),
	18: uint8(0xff),
	19: uint8(0xff),
	20: uint8(0xff),
	21: uint8(0xff),
	22: uint8(0xff),
	23: uint8(0xff),
	24: uint8(0xff),
	25: uint8(0x0a),
	26: uint8(0x0b),
	27: uint8(0x0c),
	28: uint8(0x0d),
	29: uint8(0x0e),
	30: uint8(0x0f),
	31: uint8(0x10),
	32: uint8(0x11),
	33: uint8(0x12),
	34: uint8(0x13),
	35: uint8(0x14),
	36: uint8(0x15),
	37: uint8(0x16),
	38: uint8(0x17),
	39: uint8(0x18),
	40: uint8(0x19),
	41: uint8(0x1a),
	42: uint8(0x1b),
	43: uint8(0x1c),
	44: uint8(0x1d),
	45: uint8(0x1e),
	46: uint8(0x1f),
	47: uint8(0x20),
	48: uint8(0x21),
	49: uint8(0x22),
	50: uint8(0x23),
	51: uint8(0xff),
	52: uint8(0xff),
	53: uint8(0xff),
	54: uint8(0xff),
	55: uint8(0xff),
	56: uint8(0xff),
	57: uint8(0x24),
	58: uint8(0x25),
	59: uint8(0x26),
	60: uint8(0x27),
	61: uint8(0x28),
	62: uint8(0x29),
	63: uint8(0x2a),
	64: uint8(0x2b),
	65: uint8(0x2c),
	66: uint8(0x2d),
	67: uint8(0x2e),
	68: uint8(0x2f),
	69: uint8(0x30),
	70: uint8(0x31),
	71: uint8(0x32),
	72: uint8(0x33),
	73: uint8(0x34),
	74: uint8(0x35),
	75: uint8(0x36),
	76: uint8(0x37),
	77: uint8(0x38),
	78: uint8(0x39),
	79: uint8(0x3a),
	80: uint8(0x3b),
	81: uint8(0x3c),
	82: uint8(0x3d),
	83: uint8(0xff),
	84: uint8(0xff),
	85: uint8(0xff),
	86: uint8(0xff),
	87: uint8(0xff),
}

var XTclBN_mp_s_rmap_reverse_sz = uint64(88)

// C documentation
//
//	/* MODULE_SCOPE */
var XTclEnvEpoch Tsize_t

var XtclArrayHashKeyType = TTcl_HashKeyType{
	Fversion: int32(TCL_HASH_KEY_TYPE_VERSION),
	Fflags:   int32(TCL_HASH_KEY_RANDOMIZE_HASH),
}

var XtclBignumType = TTcl_ObjType{
	Fname:    __ccgo_ts + 54638,
	Fversion: uint64(libc.UintptrFromInt32(0) + 56),
}

/*
 * The structures below defines the Tcl object types defined in this file by
 * means of functions that can be invoked by generic object code. See also
 * tclStringObj.c, tclListObj.c, tclByteCode.c for other type manager
 * implementations.
 */

var XtclBooleanType = TTcl_ObjType{
	Fname:    __ccgo_ts + 3611,
	Fversion: uint64(libc.UintptrFromInt32(0) + 56),
}

/*
 * tclByteCodeType provides the standard type management procedures for the
 * bytecode type.
 */

var XtclByteCodeType = TTcl_ObjType{
	Fname: __ccgo_ts + 23858,
}

/*
 * The following table provides parsing information about each possible 8-bit
 * character. The table is designed to be referenced with unsigned characters.
 *
 * The macro CHAR_TYPE is used to index into the table and return information
 * about its character argument. The following return values are defined.
 *
 * TYPE_NORMAL -	All characters that don't have special significance to
 *			the Tcl parser.
 * TYPE_SPACE -		The character is a whitespace character other than
 *			newline.
 * TYPE_COMMAND_END -	Character is newline or semicolon.
 * TYPE_SUBS -		Character begins a substitution or has other special
 *			meaning in ParseTokens: backslash, dollar sign, or
 *			open bracket.
 * TYPE_QUOTE -		Character is a double quote.
 * TYPE_OPEN_PAREN -	Character is a left parenthesis.
 * TYPE_CLOSE_PAREN -	Character is a right parenthesis.
 * TYPE_CLOSE_BRACK -	Character is a right square bracket.
 * TYPE_BRACE -		Character is a curly brace (either left or right).
 */

var XtclCharTypeTable = [256]uint8{
	0:   uint8(TYPE_SUBS),
	9:   uint8(TYPE_SPACE),
	10:  uint8(TYPE_COMMAND_END),
	11:  uint8(TYPE_SPACE),
	12:  uint8(TYPE_SPACE),
	13:  uint8(TYPE_SPACE),
	32:  uint8(TYPE_SPACE),
	34:  uint8(TYPE_QUOTE),
	36:  uint8(TYPE_SUBS),
	40:  uint8(TYPE_OPEN_PAREN),
	41:  uint8(TYPE_CLOSE_PAREN),
	59:  uint8(TYPE_COMMAND_END),
	91:  uint8(TYPE_SUBS),
	92:  uint8(TYPE_SUBS),
	93:  uint8(TYPE_CLOSE_BRACK),
	123: uint8(TYPE_BRACE),
	125: uint8(TYPE_BRACE),
}

/*
 * The structure below defines the command name Tcl object type by means of
 * functions that can be invoked by generic object code. Objects of this type
 * cache the Command pointer that results from looking up command names in the
 * command hashtable. Such objects appear as the zeroth ("command name")
 * argument in a Tcl command.
 *
 * NOTE: the ResolvedCmdName that gets cached is stored in the
 * twoPtrValue.ptr1 field, and the twoPtrValue.ptr2 field is unused. You might
 * think you could use the simpler otherValuePtr field to store the single
 * ResolvedCmdName pointer, but DO NOT DO THIS. It seems that some extensions
 * use the second internal pointer field of the twoPtrValue field for their
 * own purposes.
 *
 * TRICKY POINT! Some extensions update this structure! (Notably, these
 * include TclBlend and TCom). This is highly ill-advised on their part, but
 * does allow them to delete a command when references to it are gone, which
 * is fragile but useful given their somewhat-OO style. Because of this, this
 * structure MUST NOT be const so that the C compiler puts the data in
 * writable memory. [Bug 2558422] [Bug 07d13d99b0a9]
 * TODO: Provide a better API for those extensions so that they can coexist...
 */

var XtclCmdNameType = TTcl_ObjType{
	Fname: __ccgo_ts + 54645,
}

/*
 * Default set of characters to trim in [string trim] and friends. This is a
 * UTF-8 literal string containing all Unicode space characters [TIP #413]
 */

var XtclDefaultTrimSet = [76]uint8{9, 10, 11, 12, 13, ' ', 192, 128, 194, 133, 194, 160, 225, 154, 128, 225, 160, 142, 226, 128, 128, 226, 128, 129, 226, 128, 130, 226, 128, 131, 226, 128, 132, 226, 128, 133, 226, 128, 134, 226, 128, 135, 226, 128, 136, 226, 128, 137, 226, 128, 138, 226, 128, 139, 226, 128, 168, 226, 128, 169, 226, 128, 175, 226, 129, 159, 226, 129, 160, 227, 128, 128, 239, 187, 191}

/*
 * The structure below defines the dictionary object type by means of
 * functions that can be invoked by generic object code.
 */

var XtclDictType = TTcl_ObjType{
	Fname: __ccgo_ts + 19222,
}

var XtclDoubleType = TTcl_ObjType{
	Fname:    __ccgo_ts + 6055,
	Fversion: uint64(libc.UintptrFromInt32(0) + 56),
}

/*
 * Pointer to a heap-allocated string of length zero that the Tcl core uses as
 * the value of an empty string representation for an object. This value is
 * shared by all new objects allocated by Tcl_NewObj.
 */

var XtclEmptyString uint8

var XtclEmptyStringRep = uintptr(unsafe.Pointer(&XtclEmptyString))

/*
 * The structure below defines a bytecode Tcl object type to hold the
 * compiled bytecode for Tcl expressions.
 */

var XtclExprCodeType = TTcl_ObjType{
	Fname: __ccgo_ts + 31620,
}

/*
 * Head of the list of free Tcl_Obj structs we maintain.
 */

var XtclFreeObjList uintptr

/*
 * TIP #233 (Virtualized Time): Data for the time hooks, if any.
 */

var XtclGetTimeProcPtr = uintptr(0)

var XtclIdentityEncoding TTcl_Encoding

/*
 * The structure below defines the index Tcl object type by means of functions
 * that can be invoked by generic object code.
 */

var XtclIndexType = TTcl_ObjType{
	Fname: __ccgo_ts + 19687,
}

/*
 * Variable that controls whether compilation tracing is enabled and, if so,
 * what level of tracing is desired:
 *    0: no compilation tracing
 *    1: summarize compilation of top level cmds and proc bodies
 *    2: display all instructions of each ByteCode compiled
 * This variable is linked to the Tcl variable "tcl_traceCompile".
 */

/*
 * A table describing the Tcl bytecode instructions. Entries in this table
 * must correspond to the instruction opcode definitions in tclCompile.h. The
 * names "op1" and "op4" refer to an instruction's one or four byte first
 * operand. Similarly, "stktop" and "stknext" refer to the topmost and next to
 * topmost stack elements.
 *
 * Note that the load, store, and incr instructions do not distinguish local
 * from global variables; the bytecode interpreter at runtime uses the
 * existence of a procedure call frame to distinguish these.
 */

var XtclInstructionTable = [192]TInstructionDesc{
	0: {
		Fname:        __ccgo_ts + 23112,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	1: {
		Fname:        __ccgo_ts + 23117,
		FnumBytes:    int64(2),
		FstackEffect: +libc.Int32FromInt32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LIT1),
		},
	},
	2: {
		Fname:        __ccgo_ts + 23123,
		FnumBytes:    int64(5),
		FstackEffect: +libc.Int32FromInt32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LIT4),
		},
	},
	3: {
		Fname:        __ccgo_ts + 3047,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	4: {
		Fname:        __ccgo_ts + 2448,
		FnumBytes:    int64(1),
		FstackEffect: +libc.Int32FromInt32(1),
	},
	5: {
		Fname:        __ccgo_ts + 3211,
		FnumBytes:    int64(2),
		FstackEffect: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_UINT1),
		},
	},
	6: {
		Fname:        __ccgo_ts + 23129,
		FnumBytes:    int64(2),
		FstackEffect: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_UINT1),
		},
	},
	7: {
		Fname:        __ccgo_ts + 23140,
		FnumBytes:    int64(5),
		FstackEffect: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_UINT4),
		},
	},
	8: {
		Fname:     __ccgo_ts + 2469,
		FnumBytes: int64(1),
	},
	9: {
		Fname:     __ccgo_ts + 2528,
		FnumBytes: int64(1),
	},
	10: {
		Fname:        __ccgo_ts + 23151,
		FnumBytes:    int64(2),
		FstackEffect: int32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT1),
		},
	},
	11: {
		Fname:        __ccgo_ts + 23163,
		FnumBytes:    int64(5),
		FstackEffect: int32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT4),
		},
	},
	12: {
		Fname:     __ccgo_ts + 23175,
		FnumBytes: int64(1),
	},
	13: {
		Fname:        __ccgo_ts + 23189,
		FnumBytes:    int64(2),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT1),
		},
	},
	14: {
		Fname:        __ccgo_ts + 23200,
		FnumBytes:    int64(5),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT4),
		},
	},
	15: {
		Fname:        __ccgo_ts + 2942,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	16: {
		Fname:     __ccgo_ts + 2955,
		FnumBytes: int64(1),
	},
	17: {
		Fname:        __ccgo_ts + 23211,
		FnumBytes:    int64(2),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT1),
		},
	},
	18: {
		Fname:        __ccgo_ts + 23224,
		FnumBytes:    int64(5),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT4),
		},
	},
	19: {
		Fname:        __ccgo_ts + 23237,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	20: {
		Fname:        __ccgo_ts + 23252,
		FnumBytes:    int64(2),
		FstackEffect: -int32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT1),
		},
	},
	21: {
		Fname:        __ccgo_ts + 23264,
		FnumBytes:    int64(5),
		FstackEffect: -int32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT4),
		},
	},
	22: {
		Fname:        __ccgo_ts + 3142,
		FnumBytes:    int64(1),
		FstackEffect: -int32(2),
	},
	23: {
		Fname:        __ccgo_ts + 3156,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	24: {
		Fname:        __ccgo_ts + 23276,
		FnumBytes:    int64(2),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT1),
		},
	},
	25: {
		Fname:        __ccgo_ts + 23288,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	26: {
		Fname:        __ccgo_ts + 23302,
		FnumBytes:    int64(2),
		FstackEffect: -int32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT1),
		},
	},
	27: {
		Fname:        __ccgo_ts + 2570,
		FnumBytes:    int64(1),
		FstackEffect: -int32(2),
	},
	28: {
		Fname:        __ccgo_ts + 2607,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	29: {
		Fname:        __ccgo_ts + 23313,
		FnumBytes:    int64(3),
		FstackEffect: +libc.Int32FromInt32(1),
		FnumOperands: int32(2),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT1),
			1: int32(OPERAND_INT1),
		},
	},
	30: {
		Fname:        __ccgo_ts + 23328,
		FnumBytes:    int64(2),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_INT1),
		},
	},
	31: {
		Fname:        __ccgo_ts + 23345,
		FnumBytes:    int64(3),
		FnumOperands: int32(2),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT1),
			1: int32(OPERAND_INT1),
		},
	},
	32: {
		Fname:        __ccgo_ts + 2583,
		FnumBytes:    int64(2),
		FstackEffect: -int32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_INT1),
		},
	},
	33: {
		Fname:        __ccgo_ts + 2615,
		FnumBytes:    int64(2),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_INT1),
		},
	},
	34: {
		Fname:        __ccgo_ts + 23359,
		FnumBytes:    int64(2),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_OFFSET1),
		},
	},
	35: {
		Fname:        __ccgo_ts + 2671,
		FnumBytes:    int64(5),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_OFFSET4),
		},
	},
	36: {
		Fname:        __ccgo_ts + 23365,
		FnumBytes:    int64(2),
		FstackEffect: -int32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_OFFSET1),
		},
	},
	37: {
		Fname:        __ccgo_ts + 2717,
		FnumBytes:    int64(5),
		FstackEffect: -int32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_OFFSET4),
		},
	},
	38: {
		Fname:        __ccgo_ts + 23375,
		FnumBytes:    int64(2),
		FstackEffect: -int32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_OFFSET1),
		},
	},
	39: {
		Fname:        __ccgo_ts + 2687,
		FnumBytes:    int64(5),
		FstackEffect: -int32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_OFFSET4),
		},
	},
	40: {
		Fname:        __ccgo_ts + 2250,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	41: {
		Fname:        __ccgo_ts + 2256,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	42: {
		Fname:        __ccgo_ts + 2236,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	43: {
		Fname:        __ccgo_ts + 2461,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	44: {
		Fname:        __ccgo_ts + 3000,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	45: {
		Fname:        __ccgo_ts + 2988,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	46: {
		Fname:        __ccgo_ts + 2539,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	47: {
		Fname:        __ccgo_ts + 2845,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	48: {
		Fname:        __ccgo_ts + 2536,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	49: {
		Fname:        __ccgo_ts + 2981,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	50: {
		Fname:        __ccgo_ts + 3118,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	51: {
		Fname:        __ccgo_ts + 2121,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	52: {
		Fname:        __ccgo_ts + 3357,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	53: {
		Fname:        __ccgo_ts + 2995,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	54: {
		Fname:        __ccgo_ts + 2444,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	55: {
		Fname:        __ccgo_ts + 2991,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	56: {
		Fname:     __ccgo_ts + 3490,
		FnumBytes: int64(1),
	},
	57: {
		Fname:     __ccgo_ts + 3443,
		FnumBytes: int64(1),
	},
	58: {
		Fname:     __ccgo_ts + 2243,
		FnumBytes: int64(1),
	},
	59: {
		Fname:     __ccgo_ts + 3008,
		FnumBytes: int64(1),
	},
	60: {
		Fname:     __ccgo_ts + 3427,
		FnumBytes: int64(1),
	},
	61: {
		Fname:     __ccgo_ts + 5123,
		FnumBytes: int64(1),
	},
	62: {
		Fname:     __ccgo_ts + 5141,
		FnumBytes: int64(1),
	},
	63: {
		Fname:        __ccgo_ts + 23386,
		FnumBytes:    int64(5),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_UINT4),
		},
	},
	64: {
		Fname:     __ccgo_ts + 2452,
		FnumBytes: int64(1),
	},
	65: {
		Fname:        __ccgo_ts + 3081,
		FnumBytes:    int64(1),
		FstackEffect: +libc.Int32FromInt32(1),
	},
	66: {
		Fname:        __ccgo_ts + 3051,
		FnumBytes:    int64(1),
		FstackEffect: +libc.Int32FromInt32(1),
	},
	67: {
		Fname:        __ccgo_ts + 3218,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	68: {
		Fname:        __ccgo_ts + 3288,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	69: {
		Fname:        __ccgo_ts + 3204,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	70: {
		Fname:     __ccgo_ts + 3259,
		FnumBytes: int64(1),
	},
	71: {
		Fname:        __ccgo_ts + 3244,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	72: {
		Fname:        __ccgo_ts + 3279,
		FnumBytes:    int64(2),
		FstackEffect: -int32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_INT1),
		},
	},
	73: {
		Fname:        __ccgo_ts + 2860,
		FnumBytes:    int64(5),
		FstackEffect: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_UINT4),
		},
	},
	74: {
		Fname:        __ccgo_ts + 2883,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	75: {
		Fname:     __ccgo_ts + 2906,
		FnumBytes: int64(1),
	},
	76: {
		Fname:        __ccgo_ts + 23398,
		FnumBytes:    int64(2),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT1),
		},
	},
	77: {
		Fname:        __ccgo_ts + 23412,
		FnumBytes:    int64(5),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT4),
		},
	},
	78: {
		Fname:        __ccgo_ts + 23426,
		FnumBytes:    int64(2),
		FstackEffect: -int32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT1),
		},
	},
	79: {
		Fname:        __ccgo_ts + 23439,
		FnumBytes:    int64(5),
		FstackEffect: -int32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT4),
		},
	},
	80: {
		Fname:        __ccgo_ts + 2144,
		FnumBytes:    int64(1),
		FstackEffect: -int32(2),
	},
	81: {
		Fname:        __ccgo_ts + 2159,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	82: {
		Fname:        __ccgo_ts + 23452,
		FnumBytes:    int64(2),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT1),
		},
	},
	83: {
		Fname:        __ccgo_ts + 23467,
		FnumBytes:    int64(5),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT4),
		},
	},
	84: {
		Fname:        __ccgo_ts + 23482,
		FnumBytes:    int64(2),
		FstackEffect: -int32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT1),
		},
	},
	85: {
		Fname:        __ccgo_ts + 23496,
		FnumBytes:    int64(5),
		FstackEffect: -int32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT4),
		},
	},
	86: {
		Fname:        __ccgo_ts + 2754,
		FnumBytes:    int64(1),
		FstackEffect: -int32(2),
	},
	87: {
		Fname:        __ccgo_ts + 2834,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	88: {
		Fname:        __ccgo_ts + 2848,
		FnumBytes:    int64(5),
		FstackEffect: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_UINT4),
		},
	},
	89: {
		Fname:        __ccgo_ts + 3042,
		FnumBytes:    int64(5),
		FstackEffect: +libc.Int32FromInt32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_UINT4),
		},
	},
	90: {
		Fname:        __ccgo_ts + 2972,
		FnumBytes:    int64(1),
		FstackEffect: -int32(2),
	},
	91: {
		Fname:        __ccgo_ts + 2963,
		FnumBytes:    int64(5),
		FstackEffect: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_UINT4),
		},
	},
	92: {
		Fname:        __ccgo_ts + 23510,
		FnumBytes:    int64(9),
		FstackEffect: -int32(1),
		FnumOperands: int32(2),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_INT4),
			1: int32(OPERAND_UINT4),
		},
	},
	93: {
		Fname:        __ccgo_ts + 2517,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	94: {
		Fname:     __ccgo_ts + 23520,
		FnumBytes: int64(1),
	},
	95: {
		Fname:        __ccgo_ts + 23532,
		FnumBytes:    int64(5),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_UINT4),
		},
	},
	96: {
		Fname:     __ccgo_ts + 23545,
		FnumBytes: int64(1),
	},
	97: {
		Fname:        __ccgo_ts + 2893,
		FnumBytes:    int64(5),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_IDX4),
		},
	},
	98: {
		Fname:        __ccgo_ts + 23560,
		FnumBytes:    int64(9),
		FnumOperands: int32(2),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_IDX4),
			1: int32(OPERAND_IDX4),
		},
	},
	99: {
		Fname:        __ccgo_ts + 23573,
		FnumBytes:    int64(9),
		FnumOperands: int32(2),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_OFFSET4),
			1: int32(OPERAND_UINT4),
		},
	},
	100: {
		Fname:        __ccgo_ts + 2876,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	101: {
		Fname:        __ccgo_ts + 2917,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	102: {
		Fname:        __ccgo_ts + 3066,
		FnumBytes:    int64(1),
		FstackEffect: +libc.Int32FromInt32(1),
	},
	103: {
		Fname:        __ccgo_ts + 23586,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	104: {
		Fname:        __ccgo_ts + 2349,
		FnumBytes:    int64(5),
		FstackEffect: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_UINT4),
		},
	},
	105: {
		Fname:        __ccgo_ts + 2426,
		FnumBytes:    int64(9),
		FstackEffect: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FnumOperands: int32(2),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_UINT4),
			1: int32(OPERAND_LVT4),
		},
	},
	106: {
		Fname:        __ccgo_ts + 2434,
		FnumBytes:    int64(9),
		FstackEffect: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FnumOperands: int32(2),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_UINT4),
			1: int32(OPERAND_LVT4),
		},
	},
	107: {
		Fname:        __ccgo_ts + 2368,
		FnumBytes:    int64(9),
		FnumOperands: int32(2),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_INT4),
			1: int32(OPERAND_LVT4),
		},
	},
	108: {
		Fname:        __ccgo_ts + 2316,
		FnumBytes:    int64(5),
		FstackEffect: -int32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT4),
		},
	},
	109: {
		Fname:        __ccgo_ts + 2380,
		FnumBytes:    int64(5),
		FstackEffect: -int32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT4),
		},
	},
	110: {
		Fname:        __ccgo_ts + 23596,
		FnumBytes:    int64(5),
		FstackEffect: +libc.Int32FromInt32(2),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT4),
		},
	},
	111: {
		Fname:        __ccgo_ts + 23606,
		FnumBytes:    int64(5),
		FstackEffect: +libc.Int32FromInt32(3),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT4),
		},
	},
	112: {
		Fname:        __ccgo_ts + 23615,
		FnumBytes:    int64(9),
		FnumOperands: int32(2),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT4),
			1: int32(OPERAND_AUX4),
		},
	},
	113: {
		Fname:        __ccgo_ts + 23631,
		FnumBytes:    int64(9),
		FstackEffect: -int32(1),
		FnumOperands: int32(2),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT4),
			1: int32(OPERAND_AUX4),
		},
	},
	114: {
		Fname:        __ccgo_ts + 2698,
		FnumBytes:    int64(5),
		FstackEffect: -int32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_AUX4),
		},
	},
	115: {
		Fname:        __ccgo_ts + 3496,
		FnumBytes:    int64(5),
		FstackEffect: -int32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT4),
		},
	},
	116: {
		Fname:        __ccgo_ts + 3012,
		FnumBytes:    int64(5),
		FstackEffect: -int32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT4),
		},
	},
	117: {
		Fname:        __ccgo_ts + 3502,
		FnumBytes:    int64(5),
		FstackEffect: -int32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT4),
		},
	},
	118: {
		Fname:        __ccgo_ts + 23645,
		FnumBytes:    int64(9),
		FstackEffect: -int32(1),
		FnumOperands: int32(2),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_INT4),
			1: int32(OPERAND_UINT4),
		},
	},
	119: {
		Fname:        __ccgo_ts + 3110,
		FnumBytes:    int64(5),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_UINT4),
		},
	},
	120: {
		Fname:        __ccgo_ts + 3092,
		FnumBytes:    int64(2),
		FstackEffect: -int32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_INT1),
		},
	},
	121: {
		Fname:        __ccgo_ts + 23652,
		FnumBytes:    int64(5),
		FstackEffect: int32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT4),
		},
	},
	122: {
		Fname:        __ccgo_ts + 2483,
		FnumBytes:    int64(5),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT4),
		},
	},
	123: {
		Fname:        __ccgo_ts + 2494,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	124: {
		Fname:     __ccgo_ts + 2508,
		FnumBytes: int64(1),
	},
	125: {
		Fname:     __ccgo_ts + 3004,
		FnumBytes: int64(1),
	},
	126: {
		Fname:        __ccgo_ts + 23664,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	127: {
		Fname:        __ccgo_ts + 23681,
		FnumBytes:    int64(6),
		FnumOperands: int32(2),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_UINT1),
			1: int32(OPERAND_LVT4),
		},
	},
	128: {
		Fname:        __ccgo_ts + 3456,
		FnumBytes:    int64(6),
		FstackEffect: -int32(1),
		FnumOperands: int32(2),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_UINT1),
			1: int32(OPERAND_LVT4),
		},
	},
	129: {
		Fname:        __ccgo_ts + 3467,
		FnumBytes:    int64(2),
		FstackEffect: -int32(2),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_UINT1),
		},
	},
	130: {
		Fname:        __ccgo_ts + 3481,
		FnumBytes:    int64(2),
		FstackEffect: -int32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_UINT1),
		},
	},
	131: {
		Fname:        __ccgo_ts + 2338,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	132: {
		Fname:        __ccgo_ts + 2392,
		FnumBytes:    int64(1),
		FstackEffect: -int32(3),
	},
	133: {
		Fname:        __ccgo_ts + 2409,
		FnumBytes:    int64(5),
		FstackEffect: -int32(2),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT4),
		},
	},
	134: {
		Fname:        __ccgo_ts + 2327,
		FnumBytes:    int64(5),
		FstackEffect: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_UINT4),
		},
	},
	135: {
		Fname:        __ccgo_ts + 3511,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	136: {
		Fname:        __ccgo_ts + 3272,
		FnumBytes:    int64(1),
		FstackEffect: -int32(2),
	},
	137: {
		Fname:        __ccgo_ts + 3224,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	138: {
		Fname:        __ccgo_ts + 3315,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	139: {
		Fname:        __ccgo_ts + 23693,
		FnumBytes:    int64(9),
		FnumOperands: int32(2),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_IDX4),
			1: int32(OPERAND_IDX4),
		},
	},
	140: {
		Fname:        __ccgo_ts + 3295,
		FnumBytes:    int64(1),
		FstackEffect: -int32(2),
	},
	141: {
		Fname:     __ccgo_ts + 3522,
		FnumBytes: int64(1),
	},
	142: {
		Fname:        __ccgo_ts + 2290,
		FnumBytes:    int64(1),
		FstackEffect: +libc.Int32FromInt32(1),
	},
	143: {
		Fname:        __ccgo_ts + 5406,
		FnumBytes:    int64(2),
		FstackEffect: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_UINT1),
		},
	},
	144: {
		Fname:        __ccgo_ts + 2299,
		FnumBytes:    int64(1),
		FstackEffect: +libc.Int32FromInt32(1),
	},
	145: {
		Fname:        __ccgo_ts + 2640,
		FnumBytes:    int64(1),
		FstackEffect: +libc.Int32FromInt32(1),
	},
	146: {
		Fname:     __ccgo_ts + 2626,
		FnumBytes: int64(1),
	},
	147: {
		Fname:     __ccgo_ts + 3099,
		FnumBytes: int64(1),
	},
	148: {
		Fname:        __ccgo_ts + 3401,
		FnumBytes:    int64(1),
		FstackEffect: +libc.Int32FromInt32(1),
	},
	149: {
		Fname:     __ccgo_ts + 3361,
		FnumBytes: int64(1),
	},
	150: {
		Fname:     __ccgo_ts + 3386,
		FnumBytes: int64(1),
	},
	151: {
		Fname:     __ccgo_ts + 3372,
		FnumBytes: int64(1),
	},
	152: {
		Fname:     __ccgo_ts + 2184,
		FnumBytes: int64(1),
	},
	153: {
		Fname:        __ccgo_ts + 2169,
		FnumBytes:    int64(5),
		FstackEffect: +libc.Int32FromInt32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT4),
		},
	},
	154: {
		Fname:        __ccgo_ts + 2212,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	155: {
		Fname:        __ccgo_ts + 2199,
		FnumBytes:    int64(5),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT4),
		},
	},
	156: {
		Fname:        __ccgo_ts + 23705,
		FnumBytes:    int64(6),
		FstackEffect: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FnumOperands: int32(2),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_UINT4),
			1: int32(OPERAND_UINT1),
		},
	},
	157: {
		Fname:        __ccgo_ts + 2865,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	158: {
		Fname:     __ccgo_ts + 23719,
		FnumBytes: int64(1),
	},
	159: {
		Fname:        __ccgo_ts + 23730,
		FnumBytes:    int64(5),
		FstackEffect: +libc.Int32FromInt32(2),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_AUX4),
		},
	},
	160: {
		Fname:     __ccgo_ts + 23744,
		FnumBytes: int64(1),
	},
	161: {
		Fname:     __ccgo_ts + 23757,
		FnumBytes: int64(1),
	},
	162: {
		Fname:        __ccgo_ts + 23769,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	163: {
		Fname:        __ccgo_ts + 3324,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	164: {
		Fname:        __ccgo_ts + 3332,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	165: {
		Fname:        __ccgo_ts + 3344,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	166: {
		Fname:        __ccgo_ts + 2280,
		FnumBytes:    int64(5),
		FstackEffect: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_UINT4),
		},
	},
	167: {
		Fname:     __ccgo_ts + 3191,
		FnumBytes: int64(1),
	},
	168: {
		Fname:     __ccgo_ts + 3165,
		FnumBytes: int64(1),
	},
	169: {
		Fname:     __ccgo_ts + 3178,
		FnumBytes: int64(1),
	},
	170: {
		Fname:        __ccgo_ts + 3304,
		FnumBytes:    int64(1),
		FstackEffect: -int32(3),
	},
	171: {
		Fname:     __ccgo_ts + 3032,
		FnumBytes: int64(1),
	},
	172: {
		Fname:        __ccgo_ts + 23782,
		FnumBytes:    int64(2),
		FstackEffect: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_UINT1),
		},
	},
	173: {
		Fname:        __ccgo_ts + 23792,
		FnumBytes:    int64(2),
		FstackEffect: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_UINT1),
		},
	},
	174: {
		Fname:     __ccgo_ts + 23807,
		FnumBytes: int64(1),
	},
	175: {
		Fname:     __ccgo_ts + 3020,
		FnumBytes: int64(1),
	},
	176: {
		Fname:        __ccgo_ts + 3411,
		FnumBytes:    int64(1),
		FstackEffect: +libc.Int32FromInt32(1),
	},
	177: {
		Fname:        __ccgo_ts + 23821,
		FnumBytes:    int64(2),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_SCLS1),
		},
	},
	178: {
		Fname:        __ccgo_ts + 2770,
		FnumBytes:    int64(5),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT4),
		},
	},
	179: {
		Fname:        __ccgo_ts + 2782,
		FnumBytes:    int64(5),
		FstackEffect: -int32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT4),
		},
	},
	180: {
		Fname:        __ccgo_ts + 2799,
		FnumBytes:    int64(1),
		FstackEffect: -int32(2),
	},
	181: {
		Fname:        __ccgo_ts + 2819,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	182: {
		Fname:        __ccgo_ts + 2263,
		FnumBytes:    int64(2),
		FstackEffect: +libc.Int32FromInt32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_UINT1),
		},
	},
	183: {
		Fname:        __ccgo_ts + 2357,
		FnumBytes:    int64(5),
		FstackEffect: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_UINT4),
		},
	},
	184: {
		Fname:        __ccgo_ts + 3266,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	185: {
		Fname:        __ccgo_ts + 3238,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	186: {
		Fname:        __ccgo_ts + 3253,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	187: {
		Fname:        __ccgo_ts + 3232,
		FnumBytes:    int64(1),
		FstackEffect: -int32(1),
	},
	188: {
		Fname:        __ccgo_ts + 23830,
		FnumBytes:    int64(6),
		FstackEffect: -libc.Int32FromInt32(1) - libc.Int32FromInt32(0x7fffffff),
		FnumOperands: int32(2),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_UINT4),
			1: int32(OPERAND_UINT1),
		},
	},
	189: {
		Fname:        __ccgo_ts + 23840,
		FnumBytes:    int64(5),
		FstackEffect: -int32(1),
		FnumOperands: int32(1),
		FopTypes: [2]TInstOperandType{
			0: int32(OPERAND_LVT4),
		},
	},
	190: {
		Fname:        __ccgo_ts + 23849,
		FnumBytes:    int64(1),
		FstackEffect: -int32(2),
	},
	191: {},
}

var XtclIntType = TTcl_ObjType{
	Fname:    __ccgo_ts + 6090,
	Fversion: uint64(libc.UintptrFromInt32(0) + 56),
}

/*
 * The structures below define the AuxData types defined in this file.
 */

var XtclJumptableInfoType = TAuxDataType{
	Fname: __ccgo_ts + 21856,
}

/*
 * The structure below defines the list Tcl object type by means of functions
 * that can be invoked by generic object code.
 *
 * The internal representation of a list object is ListRep defined in tcl.h.
 */

var XtclListType = TTcl_ObjType{
	Fname:    __ccgo_ts + 2860,
	Fversion: uint64(libc.UintptrFromInt32(0) + 56),
}

/*
 * The native filesystem dispatch table.  This could me made public but it
 * should only be accessed by the functions it points to, or perhaps
 * subordinate helper functions.
 */

var XtclNativeFilesystem = TTcl_Filesystem{
	FtypeName:        __ccgo_ts + 7266,
	FstructureLength: int64(248),
	Fversion:         libc.UintptrFromInt32(0x2),
}

var XtclOOStubs = TTclOOStubs{
	Fmagic: libc.Int32FromUint32(0xFCA3BACB) + libc.Int32FromInt64(8),
	Fhooks: uintptr(unsafe.Pointer(&_tclOOStubHooks)),
}

/*
 * The structure below defines the Tcl obj hash key type.
 */

var XtclObjHashKeyType = TTcl_HashKeyType{
	Fversion: int32(TCL_HASH_KEY_TYPE_VERSION),
	Fflags:   int32(TCL_HASH_KEY_DIRECT_COMPARE),
}

var XtclObjMutex TTcl_Mutex

var XtclOneWordHashKeyType = TTcl_HashKeyType{
	Fversion: int32(TCL_HASH_KEY_TYPE_VERSION),
}

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:
 */

/*
 * The following variable is set in the TclPlatformInit call to one of:
 * TCL_PLATFORM_UNIX or TCL_PLATFORM_WINDOWS.
 */

var XtclPlatform TTclPlatformType

/*
 * The ProcBodyObjType type
 */

var XtclProcBodyType = TTcl_ObjType{
	Fname: __ccgo_ts + 63492,
}

/*
 * The regular expression Tcl object type. This serves as a cache of the
 * compiled form of the regular expression.
 */

var XtclRegexpType = TTcl_ObjType{
	Fname: __ccgo_ts + 3092,
}

var XtclScaleTimeProcPtr = uintptr(0)

var XtclStringClassTable = [14]TStringClassDesc{
	0: {
		Fname: [8]uint8{'a', 'l', 'n', 'u', 'm'},
	},
	1: {
		Fname: [8]uint8{'a', 'l', 'p', 'h', 'a'},
	},
	2: {
		Fname: [8]uint8{'a', 's', 'c', 'i', 'i'},
	},
	3: {
		Fname: [8]uint8{'c', 'o', 'n', 't', 'r', 'o', 'l'},
	},
	4: {
		Fname: [8]uint8{'d', 'i', 'g', 'i', 't'},
	},
	5: {
		Fname: [8]uint8{'g', 'r', 'a', 'p', 'h'},
	},
	6: {
		Fname: [8]uint8{'l', 'o', 'w', 'e', 'r'},
	},
	7: {
		Fname: [8]uint8{'p', 'r', 'i', 'n', 't'},
	},
	8: {
		Fname: [8]uint8{'p', 'u', 'n', 'c', 't'},
	},
	9: {
		Fname: [8]uint8{'s', 'p', 'a', 'c', 'e'},
	},
	10: {
		Fname: [8]uint8{'u', 'p', 'p', 'e', 'r'},
	},
	11: {
		Fname: [8]uint8{'w', 'o', 'r', 'd'},
	},
	12: {
		Fname: [8]uint8{'x', 'd', 'i', 'g', 'i', 't'},
	},
	13: {
		Fname: [8]uint8{},
	},
}

var XtclStringHashKeyType = TTcl_HashKeyType{
	Fversion: int32(TCL_HASH_KEY_TYPE_VERSION),
}

/*
 * The structure below defines the string Tcl object type by means of
 * functions that can be invoked by generic object code.
 */

var XtclStringType = TTcl_ObjType{
	Fname: __ccgo_ts + 19514,
}

var XtclStubs = TTclStubs{
	Fmagic: libc.Int32FromUint32(0xFCA3BACB) + libc.Int32FromInt64(8),
	Fhooks: uintptr(unsafe.Pointer(&_tclStubHooks)),
}

var XtclTimeClientData uintptr

var XtclTomMathStubs = TTclTomMathStubs{
	Fmagic: libc.Int32FromUint32(0xFCA3BACB) + libc.Int32FromInt64(8),
}

var XtclUtf8Encoding TTcl_Encoding

var XtclpFileAttrProcs = [3]TTclFileAttrProcs{
	0: {},
	1: {},
	2: {},
}

var XtclpFileAttrStrings = [4]uintptr{
	0: __ccgo_ts + 75658,
	1: __ccgo_ts + 75665,
	2: __ccgo_ts + 33918,
	3: libc.UintptrFromInt32(0),
}

var __ccgo_ts = (*reflect.StringHeader)(unsafe.Pointer(&__ccgo_ts1)).Data

var __ccgo_ts1 = "\n\n\n========= RAW ==========\n\x00\n\n\n========= TREE FIXED ==========\n\x00\n\n\n========= LA%zu ==========\n\x00\n\n\n========= SEARCH ==========\n\x00\n\n\n========= TREE NODE %s ==========\n\x00null tree\n\x00%s. `%c'\x00 longest\x00 shortest\x00 hasmixed\x00 hascapture\x00 hasbackref\x00 UNUSED\x00 (#%d)\x00 {%d,\x00%d\x00}\x00 %zu-%zu\x00 L:%s\x00 R:%s\x00\n\x00unable\x00%p\x00\ninitial cleanup:\n\x00\nempties:\n\x00\nconstraints:\n\x00\nfinal cleanup:\n\x00NUL\x00SOH\x00STX\x00ETX\x00EOT\x00ENQ\x00ACK\x00BEL\x00alert\x00BS\x00backspace\x00HT\x00tab\x00LF\x00newline\x00VT\x00vertical-tab\x00FF\x00form-feed\x00CR\x00carriage-return\x00SO\x00SI\x00DLE\x00DC1\x00DC2\x00DC3\x00DC4\x00NAK\x00SYN\x00ETB\x00CAN\x00EM\x00SUB\x00ESC\x00IS4\x00FS\x00IS3\x00GS\x00IS2\x00RS\x00IS1\x00US\x00space\x00exclamation-mark\x00quotation-mark\x00number-sign\x00dollar-sign\x00percent-sign\x00ampersand\x00apostrophe\x00left-parenthesis\x00right-parenthesis\x00asterisk\x00plus-sign\x00comma\x00hyphen\x00hyphen-minus\x00period\x00full-stop\x00slash\x00solidus\x00zero\x00one\x00two\x00three\x00four\x00five\x00six\x00seven\x00eight\x00nine\x00colon\x00semicolon\x00less-than-sign\x00equals-sign\x00greater-than-sign\x00question-mark\x00commercial-at\x00left-square-bracket\x00backslash\x00reverse-solidus\x00right-square-bracket\x00circumflex\x00circumflex-accent\x00underscore\x00low-line\x00grave-accent\x00left-brace\x00left-curly-bracket\x00vertical-line\x00right-brace\x00right-curly-bracket\x00tilde\x00DEL\x00alnum\x00alpha\x00ascii\x00blank\x00cntrl\x00digit\x00graph\x00lower\x00print\x00punct\x00upper\x00xdigit\x00REG_OKAY\x00no errors detected\x00REG_NOMATCH\x00failed to match\x00REG_BADPAT\x00invalid regexp (reg version 0.8)\x00REG_ECOLLATE\x00invalid collating element\x00REG_ECTYPE\x00invalid character class\x00REG_EESCAPE\x00invalid escape \\ sequence\x00REG_ESUBREG\x00invalid backreference number\x00REG_EBRACK\x00brackets [] not balanced\x00REG_EPAREN\x00parentheses () not balanced\x00REG_EBRACE\x00braces {} not balanced\x00REG_BADBR\x00invalid repetition count(s)\x00REG_ERANGE\x00invalid character range\x00REG_ESPACE\x00out of memory\x00REG_BADRPT\x00invalid quantifier operand\x00REG_ASSERT\x00\"cannot happen\" -- you found a bug\x00REG_INVARG\x00invalid argument to regex function\x00REG_MIXED\x00character widths of regex and string differ\x00REG_BADOPT\x00invalid embedded option\x00REG_ETOOBIG\x00regular expression is too complex\x00REG_ECOLORS\x00too many colors\x00\x00oops\x00REG_%u\x00arithseries\x00max length of a Tcl list exceeded\x00TCL\x00MEMORY\x00SetArithSeriesFromAny: should never be called\x00value is not an arithseries\x00VALUE\x00UNKNOWN\x00assemblecode\x00push\x00add\x00append\x00appendArray\x00appendArrayStk\x00appendStk\x00arrayExistsImm\x00arrayExistsStk\x00arrayMakeImm\x00arrayMakeStk\x00beginCatch\x00bitand\x00bitnot\x00bitor\x00bitxor\x00clockRead\x00concat\x00concatStk\x00coroName\x00currentNamespace\x00dictAppend\x00dictExists\x00dictExpand\x00dictGet\x00dictGetDef\x00dictIncrImm\x00dictLappend\x00dictRecombineStk\x00dictRecombineImm\x00dictSet\x00dictUnset\x00div\x00dup\x00endCatch\x00eq\x00eval\x00evalStk\x00exist\x00existArray\x00existArrayStk\x00existStk\x00expon\x00expr\x00exprStk\x00ge\x00gt\x00incr\x00incrArray\x00incrArrayImm\x00incrArrayStk\x00incrArrayStkImm\x00incrImm\x00incrStk\x00incrStkImm\x00infoLevelArgs\x00infoLevelNumber\x00invokeStk\x00jump\x00jump4\x00jumpFalse\x00jumpFalse4\x00jumpTable\x00jumpTrue\x00jumpTrue4\x00label\x00lappend\x00lappendArray\x00lappendArrayStk\x00lappendList\x00lappendListArray\x00lappendListArrayStk\x00lappendListStk\x00lappendStk\x00le\x00lindexMulti\x00list\x00listConcat\x00listIn\x00listIndex\x00listIndexImm\x00listLength\x00listNotIn\x00load\x00loadArray\x00loadArrayStk\x00loadStk\x00lsetFlat\x00lsetList\x00lshift\x00lt\x00mod\x00mult\x00neq\x00nop\x00not\x00nsupvar\x00numericType\x00originCmd\x00over\x00pop\x00pushReturnCode\x00pushReturnOpts\x00pushResult\x00regexp\x00resolveCmd\x00reverse\x00rshift\x00store\x00storeArray\x00storeArrayStk\x00storeStk\x00strcaseLower\x00strcaseTitle\x00strcaseUpper\x00strcmp\x00strcat\x00streq\x00strfind\x00strge\x00strgt\x00strindex\x00strle\x00strlen\x00strlt\x00strmap\x00strmatch\x00strneq\x00strrange\x00strreplace\x00strrfind\x00strtrim\x00strtrimLeft\x00strtrimRight\x00sub\x00tclooClass\x00tclooIsObject\x00tclooNamespace\x00tclooSelf\x00tryCvtToBoolean\x00tryCvtToNumeric\x00uminus\x00unset\x00unsetArray\x00unsetArrayStk\x00unsetStk\x00uplus\x00upvar\x00variable\x00verifyDict\x00yield\x00bytecodeList\x00\n    (\"\x00\" body, line \x00)\x00\n    (\"%.*s\" body, line %d)\x00instruction\x00value\x00boolean\x00boolean varName\x00imm8\x00operand must be [0..3]\x00ASSEM\x00OPERAND<0,>3\x00count\x00count varName\x00script\x00expression\x00table\x00name\x00operand must be >=2\x00OPERAND>=2\x00varname\x00varName imm8\x00Instruction \"%s\" could not be found, can't happen\n\x00no ASSEM_EVAL case for %s (%d), can't happen\x00jump table must have an even number of list elements\x00BADJUMPTABLE\x00duplicate entry in jump table for \"%s\"\x00DUPJUMPTABLEENTRY\x00assembly code may not contain substitutions\x00NOSUBST\x00cannot use this instruction to create a variable in a non-proc context\x00LVT\x00variable \"%s\" is not local\x00NONLOCAL\x00operand does not fit in one byte\x001BYTE\x00operand must be nonnegative\x00NONNEGATIVE\x00operand must be positive\x00POSITIVE\x00duplicate definition of label \"%s\"\x00DUPLABEL\x00undefined label \"%s\"\x00NOLABEL\x00\"%s\" instruction may not appear in a context where an exception has been caught and not disposed of.\x00BADTHROW\x00inconsistent stack depths on two execution paths\x00BADSTACK\x00stack underflow\x00code pops stack below level of enclosing catch\x00BADSTACKINCATCH\x00stack is unbalanced on exit from the code (depth=%d)\x00execution reaches an instruction in inconsistent exception contexts\x00BADCATCH\x00endCatch without a corresponding beginCatch\x00BADENDCATCH\x00catch still active on exit from assembly code\x00UNCLOSEDCATCH\x00unclosed catch at end of code in tclAssembly.c:BuildExceptionRanges, can't happen\x00undefined label in tclAssembly.c:BuildExceptionRanges, can't happen\x00\n    in assembly code between lines \x00 and \x00end of assembly code\x00Tcl_AsyncDelete: async handler deleted by the wrong thread\x00apply\x00break\x00catch\x00const\x00continue\x00coroinject\x00coroprobe\x00coroutine\x00error\x00for\x00foreach\x00format\x00fpclassify\x00global\x00if\x00join\x00lassign\x00ledit\x00lindex\x00linsert\x00llength\x00lmap\x00lpop\x00lrange\x00lremove\x00lrepeat\x00lreplace\x00lreverse\x00lsearch\x00lseq\x00lset\x00lsort\x00package\x00proc\x00regsub\x00rename\x00return\x00scan\x00set\x00split\x00subst\x00switch\x00tailcall\x00throw\x00trace\x00try\x00uplevel\x00while\x00yieldto\x00after\x00cd\x00close\x00eof\x00exec\x00exit\x00fblocked\x00fconfigure\x00fcopy\x00fileevent\x00flush\x00gets\x00glob\x00open\x00pid\x00puts\x00pwd\x00read\x00seek\x00socket\x00source\x00tell\x00time\x00timerate\x00unload\x00update\x00vwait\x00encoding\x00dirs\x00system\x00file\x00atime\x00attributes\x00copy\x00delete\x00dirname\x00executable\x00exists\x00extension\x00home\x00isdirectory\x00isfile\x00link\x00lstat\x00mtime\x00mkdir\x00nativename\x00normalize\x00owned\x00readable\x00readlink\x00rootname\x00size\x00stat\x00tail\x00tempdir\x00tempfile\x00tildeexpand\x00type\x00volumes\x00writable\x00info\x00cmdtype\x00nameofexecutable\x00process\x00status\x00purge\x00autopurge\x00zipfs\x00canonical\x00lmkimg\x00lmkzip\x00mkimg\x00mkkey\x00mkzip\x00mount\x00mountdata\x00root\x00unmount\x00abs\x00acos\x00asin\x00atan\x00atan2\x00bool\x00ceil\x00cos\x00cosh\x00double\x00entier\x00exp\x00floor\x00fmod\x00hypot\x00int\x00isfinite\x00isinf\x00isnan\x00isnormal\x00isqrt\x00issubnormal\x00isunordered\x00log\x00log10\x00max\x00min\x00pow\x00rand\x00round\x00sin\x00sinh\x00sqrt\x00srand\x00tan\x00tanh\x00wide\x00~\x00integer\x00!\x00+\x00*\x00&\x00|\x00^\x00**\x00<<\x00integer shift\x00>>\x00%\x00integer integer\x00!=\x00value value\x00ne\x00in\x00value list\x00ni\x00-\x00value ?value ...?\x00/\x00<\x00<=\x00>\x00>=\x00==\x00commit\x00compiler\x00patchlevel\x00version\x00?option?\x00clang-\x00gcc-\x00icc-\x00msvc-\x00Tcl_CallFrame must not be smaller than CallFrame\x00ensemble\x00alias\x00interp\x00import\x00object\x00privateObject\x00privateClass\x00::errorInfo\x00UP\x00CALL\x00INNER\x00::errorCode\x00TCL_PKG_PREFER_LATEST\x00TCL_INTERP_DEBUG_FRAME\x00Tcl_CreateInterp: can't create global namespace\x00builtin command with NULL object command proc and a NULL compile proc\x00::tcl::Bgerror\x00::tcl::unsupported::disassemble\x00::tcl::unsupported::getbytecode\x00::tcl::unsupported::representation\x00::tcl::unsupported::assemble\x00::tcl::unsupported::corotype\x00::tcl::unsupported::loadIcu\x00::tcl::unsupported\x00::tcl::mathfunc\x00Can't create math function namespace\x00::tcl::mathfunc::\x00::tcl::mathop\x00cannot create math operator namespace\x00::tcl::mathop::\x00failed to create math operator %s\x00tcl_platform\x00engine\x00Tcl\x00littleEndian\x00bigEndian\x00byteOrder\x00wordSize\x00pointerSize\x00tcl_patchLevel\x009.0.1\x00tcl_version\x009.0\x00tcl\x00::tcl::build-info\x00%s\x00native\x00::tcl::%s::%s\x00tcl:%s:%s\x00___tmp\x00problem making '%s %s' safe: %s\x00problem making '%s' safe: %s\x00not allowed to invoke subcommand %s of %s\x00SAFE\x00SUBCOMMAND\x00Assoc Data Key #%d\x00DeleteInterpProc called with active evals\x00DeleteInterpProc called on interpreter not marked deleted\x00DeleteInterpProc: popping rootCallFrame with other frames on top\x00Argument location tracking table not empty\x00::\x00cannot use namespace qualifiers in hidden command token (rename)\x00HIDDENTOKEN\x00can only hide global namespace commands (use rename then hide)\x00HIDE\x00NON_GLOBAL\x00hidden command named \"%s\" already exists\x00ALREADY_HIDDEN\x00cannot expose to a namespace (use expose to toplevel, then rename)\x00EXPOSE\x00unknown hidden command \"%s\"\x00LOOKUP\x00trying to expose a non-global command namespace command\x00exposed command \"%s\" already exists\x00COMMAND_EXISTS\x00can't %s \"%s\": command doesn't exist\x00COMMAND\x00can't rename to \"%s\": bad command name\x00can't rename to \"%s\": command already exists\x00OPERATION\x00RENAME\x00TARGET_EXISTS\x00attempt to call eval in deleted interpreter\x00IDELETE\x00too many nested evaluations (infinite loop?)\x00LIMIT\x00STACK\x00IUNWIND\x00eval unwound\x00ICANCEL\x00eval canceled\x00CANCEL\x00attempt to invoke a deleted command\x00EVAL\x00DELETEDCOMMAND\x00TEOV_NotFound: NULL global namespace pointer\x00::unknown\x00invalid command name \"%s\"\x00\n    (enter trace on \"\x00...\x00\")\x00\n    (leave trace on \"\x00\n    (expanding word %td)\x00TclArgumentBC Enter/Release Mismatch\x00invoked \"break\" outside of a loop\x00invoked \"continue\" outside of a loop\x00command returned bad code: %d\x00UNEXPECTED_RESULT_CODE\x00illegal argument vector\x00TclObjInvoke: called without TCL_INVOKE_HIDDEN\x00invalid hidden command name \"%s\"\x00NONE\x00square root of negative argument\x00ARITH\x00DOMAIN\x00domain error: argument not in valid range\x00floatValue\x00infinite\x00nan\x00normal\x00subnormal\x00unable to classify number: %f\x00not enough\x00too many\x00%s arguments for math function \"%s\"\x00WRONGARGS\x00?args?\x00tailcall cannot find the right splicing spot: should not happen!\x00?command? ?arg ...?\x00tailcall can only be called from a proc, lambda or method\x00TAILCALL\x00ILLEGAL\x00Adding a callback without an objProc?!\x00?returnValue?\x00yield can only be called in a coroutine\x00COROUTINE\x00ILLEGAL_YIELD\x00command ?arg ...?\x00yieldto can only be called in a coroutine\x00yieldto called in deleted namespace\x00YIELDTO_IN_DELETED\x00cannot yield: C stack busy\x00CANT_YIELD\x00Yield received an option which is not implemented\x00can only get coroutine type of a coroutine\x00active\x00unknown coroutine type\x00BAD_TYPE\x00coroName cmd ?arg1 arg2 ...?\x00can only inject a command into a coroutine\x00can only inject a command into a suspended coroutine\x00ACTIVE\x00can only inject a probe command into a coroutine\x00can only inject a probe command into a suspended coroutine\x00\n    (injected coroutine probe command)\x00coroutine \"%s\" is already running\x00BUSY\x00?arg?\x00wrong coro nargs; how did we get here? not implemented!\x00name cmd ?arg ...?\x00can't create procedure \"%s\": unknown namespace\x00NAMESPACE\x00can't create procedure \"%s\": bad procedure name\x00encode\x00decode\x00hex\x00uuencode\x00base64\x00bytearray\x00%s called with shared object\x00Tcl_SetByteArrayObj\x00negative length specified or max size of a Tcl value exceeded\x00byte sequence length exceeds INT_MAX\x00API\x00OUTDATED\x00Tcl_SetByteArrayLength\x00expected byte sequence but character %zu was '%1s' (U+%06X)\x00BYTES\x00unable to alloc %zu bytes\x00TclAppendBytesToByteArray\x00%s must be called with definite number of bytes to append\x00attempt to append bytes to non-bytearray\x00max size of a byte array exceeded\x00binary\x00binary encode\x00binary decode\x00formatString ?arg ...?\x00number of elements in list does not match count\x00cannot use \"*\" in format string with \"x\"\x00hexadecimal\x00expected %s string but got \"%s\" instead\x00missing count for \"@\" field specifier\x00not enough arguments for all format specifiers\x00bad field specifier \"%s\"\x00value formatString ?varName ...?\x00unexpected fallthrough\x00data\x00-strict\x00?options? data\x00option\x00invalid hexadecimal digit \"%c\" (U+%06X) at position %zu\x00BINARY\x00DECODE\x00INVALID\x00-maxlen\x00-wrapchar\x00?-maxlen len? ?-wrapchar char? data\x00line length out of range\x00ENCODE\x00LINE_LENGTH\x00limit hit\x00invalid wrapchar; will defeat decoding\x00WRAPCHAR\x00short uuencode data\x00SHORT\x00invalid uuencode character \"%c\" (U+%06X) at position %zu\x00invalid base64 character \"%c\" (U+%06X) at position %zu\x00unable to alloc %zu bytes, %s line %d\x00unable to realloc %zu bytes\x00unable to realloc %zu bytes, %s line %d\x00Failed to allocate %td elements of size %td bytes.\x00Failed to reallocate %td elements of size %td bytes.\x00%a %b %d %H:%M:%S %Z %Y\x00current\x00C\x00BCE\x00CE\x00dayOfMonth\x00dayOfWeek\x00dayOfYear\x00era\x00:GMT\x00gregorian\x00integer value too large to represent\x00iso8601Week\x00iso8601Year\x00julianDay\x00localSeconds\x00month\x00seconds\x00tzName\x00tzOffset\x00year\x00::tcl::clock::TZData\x00::tcl::clock::GetSystemTimeZone\x00::tcl::clock::SetupTimeZone\x00::tcl::clock::mcget\x00::tcl::clock::GetSystemLocale\x00::tcl::clock::mclocale\x00::tcl::clock::LocalizeFormat\x00MONTHS_FULL\x00MONTHS_ABBREV\x00MONTHS_COMB\x00DAYS_OF_WEEK_FULL\x00DAYS_OF_WEEK_ABBREV\x00DAYS_OF_WEEK_COMB\x00AM\x00PM\x00LOCALE_ERAS\x00b.c.e.\x00c.e.\x00b.c.\x00a.d.\x00LOCALE_NUMERALS\x00_IDX_\x00_IDX_MONTHS_FULL\x00_IDX_MONTHS_ABBREV\x00_IDX_MONTHS_COMB\x00_IDX_DAYS_OF_WEEK_FULL\x00_IDX_DAYS_OF_WEEK_ABBREV\x00_IDX_DAYS_OF_WEEK_COMB\x00_IDX_AM\x00_IDX_PM\x00_IDX_LOCALE_ERAS\x00_IDX_BCE\x00_IDX_CE\x00_IDX_b.c.e.\x00_IDX_c.e.\x00_IDX_b.c.\x00_IDX_a.d.\x00_IDX_LOCALE_NUMERALS\x00clicks\x00getenv\x00microseconds\x00milliseconds\x00ConvertLocalToUTC\x00GetDateFields\x00GetJulianDayFromEraYearMonthDay\x00GetJulianDayFromEraYearWeekDay\x00::tcl::clock::\x00::tcl::unsupported::clock::configure\x00locale not specified and no default locale set\x00CLOCK\x00badOption\x00-default-locale\x00-clear\x00-current-locale\x00-year-century\x00-century-switch\x00-min-year\x00-max-year\x00-max-jdn\x00-validate\x00-init-complete\x00-setup-tz\x00-system-tz\x00::clock\x00dict timezone changeover\x00key \"localseconds\" not found in dictionary\x00seconds timezone changeover\x00expected key(s) not found in dictionary\x00dict changeover\x00loop in ConvertLocalToUTCUsingTable\x00time value too large/small to represent\x00number too large to represent as a Posix time\x00argTooLarge\x00localtime failed (clock value may be too large/small to represent)\x00localtimeFailed\x00-milliseconds\x00-microseconds\x00clock clicks ?-switch?\x00clock milliseconds\x00%s: memory overflow\x00TclNewUIntObj\x00clock microseconds\x00-base\x00-format\x00-gmt\x00-locale\x00-timezone\x00bad option \"%s\": doubly present\x00cannot use -gmt and -timezone in same call\x00gmtWithTimezone\x00now\x00-now\x00bad seconds \"%s\": must be now or integer\x00bad option \"%s\": must be %s\x00clock format clockval|now ?-format string? ?-gmt boolean? ?-locale LOCALE? ?-timezone ZONE?\x00wrongNumArgs\x00-format, -gmt, -locale, or -timezone\x00clock scan string ?-base seconds? ?-format string? ?-gmt boolean? ?-locale LOCALE? ?-timezone ZONE? ?-validate boolean?\x00-base, -format, -gmt, -locale, -timezone or -validate\x00legacy [clock scan] does not support -locale\x00flagWithLegacyFormat\x00requested date too large to represent\x00dateTooLarge\x00invalid iso year\x00iso year\x00invalid year\x00ambiguous year\x00invalid month\x00invalid day\x00day\x00invalid day of year\x00day of year\x00ambiguous day\x00invalid time\x00invalid time (hour)\x00hour\x00invalid time (minutes)\x00minutes\x00invalid time (does not exist in this time-zone)\x00out-of-time\x00invalid day of week\x00day of week\x00unable to convert input string: %s\x00invInpStr\x00unable to convert date-time string \"%s\": %s\x00clock add clockval|now ?number units?...?-gmt boolean? ?-locale LOCALE? ?-timezone ZONE?\x00years\x00months\x00week\x00weeks\x00days\x00weekdays\x00hours\x00-gmt, -locale, or -timezone\x00unit\x00clock seconds\x00TCL_TZ\x00TZ\x00clock-format\x00FMT_%s\x00retrieve clock format failed \"\x00\"\x00EINVAL\x00day of week is greater than 7\x00badDayOfWeek\x00stardate \x00dmbyYHMSpJjCgGVazUsntQ\x00\t\x00eNBhkIlPAuwZW\x00dmbbHHHpaaazU\x00EJjys\x00dmyHMSu\x00ekIlw\x00dHHHu\x00input string does not match supplied format\x00badInputString\x00Stardate \x00demNbByYCHMSIklpaAuwUVzgGjJsntQ\x000\x00 \x00hPWZ\x00bpUz\x00y\x00dmyHIMSuw\x00ekl\x00dHI\x00script ?resultVarName? ?optionVarName?\x00\n    (\"catch\" body line %d)\x00?dirName?\x00couldn't change working directory to \"%s\": %s\x00convertfrom\x00convertto\x00names\x00profiles\x00-profile\x00-failindex\x00?-profile profile? ?-failindex var? encoding data\x00?dirList?\x00expected directory list but got \"%s\"\x00ENCODING\x00BADPATH\x00?encoding?\x00message ?errorInfo? ?errorCode?\x00-code error -level 0\x00-errorinfo\x00-errorcode\x00\n    (\"eval\" body line %d)\x00arg ?arg ...?\x00?returnCode?\x00channels\x00pathtype\x00separator\x00name ?time?\x00could not set access time for file \"%s\": %s\x00could not set modification time for file \"%s\": %s\x00name ?varName?\x00unrecognised path\x00FILESYSTEM\x00name ?name ...?\x00could not read \"%s\": no such file or directory\x00PATHSPLIT\x00NONESUCH\x00absolute\x00relative\x00volumerelative\x00?name?\x00\\\x00could not read \"%s\": %s\x00dev\x00ino\x00nlink\x00uid\x00gid\x00blocks\x00blksize\x00ctime\x00mode\x00rdev\x00directory\x00characterSpecial\x00blockSpecial\x00fifo\x00unknown\x00start test next command\x00\n    (\"for\" body line %d)\x00\n    (\"for\" initial command)\x00\n    (\"for\" loop-end command)\x00varList list ?varList list ...? command\x00%s varlist is empty\x00LMAP\x00FOREACH\x00NEEDVARS\x00\n    (\"%s\" body line %d)\x00\n    (setting %s loop variable \"%s\")\x00..\x00to\x00by\x00args\x00body\x00cmdcount\x00commands\x00complete\x00constant\x00consts\x00default\x00errorstack\x00frame\x00functions\x00globals\x00hostname\x00level\x00library\x00loaded\x00locals\x00procs\x00sharedlibextension\x00tclversion\x00vars\x00wrong # args: no expression after \"%s\" argument\x00then\x00elseif\x00else\x00wrong # args: extra words after \"else\" clause in \"if\" command\x00wrong # args: no script following \"%s\" argument\x00varName ?increment?\x00procname\x00\"%s\" isn't a procedure\x00PROCEDURE\x00?pattern?\x00*[?\\\x00command\x00procname arg varname\x00procedure \"%s\" doesn't have an argument \"%s\"\x00ARGUMENT\x00?interp?\x00varName\x00?number?\x00Broken frame level calculation\x00bad level \"%s\"\x00LEVEL\x00precompiled\x00line\x00cmd\x00TCL_LOCATION_PROC found in standard frame\x00\t    ::apply [::list {{pattern *}} {\n\t\t::set cmds {}\n\t\t::foreach cmd [::info commands ::tcl::mathfunc::$pattern] {\n\t\t    ::lappend cmds [::namespace tail $cmd]\n\t\t}\n\t\t::foreach cmd [::info commands tcl::mathfunc::$pattern] {\n\t\t    ::set cmd [::namespace tail $cmd]\n\t\t    ::if {$cmd ni $cmds} {\n\t\t\t::lappend cmds $cmd\n\t\t    }\n\t\t}\n\t\t::return $cmds\n\t    } [::namespace current]] \x00unable to determine name of host\x00HOSTNAME\x00tcl_library\x00no library has been specified for Tcl\x00VARIABLE\x00?interp? ?prefix?\x00?filename?\x00commandName\x00list ?joinString?\x00list ?varName ...?\x00list ?index ...?\x00list index ?element ...?\x00listvar ?index?\x00index \"end\" out of range\x00INDEX\x00OUTOFRANGE\x00list first last\x00count ?value ...?\x00bad count \"%lld\": must be integer >= 0\x00LREPEAT\x00NEGARG\x00max length of a Tcl list (%td elements) exceeded\x00list first last ?element ...?\x00-all\x00-ascii\x00-bisect\x00-decreasing\x00-dictionary\x00-exact\x00-glob\x00-increasing\x00-index\x00-inline\x00-integer\x00-nocase\x00-not\x00-real\x00-regexp\x00-sorted\x00-start\x00-stride\x00-subindices\x00?-option value ...? list pattern\x00missing starting index\x00MISSING\x00\"-stride\" option must be followed by stride length\x00stride length must be at least 1\x00LSEARCH\x00BADSTRIDE\x00\"-index\" option must be followed by list index\x00index \"%s\" out of range\x00\n    (-index option item number %zu)\x00-subindices cannot be used without -index option\x00BAD_OPTION_MIX\x00-bisect is not compatible with -all or -not\x00list size must be a multiple of the stride length\x00when used with \"-stride\", the leading \"-index\" value must be within the group\x00BADINDEX\x00range operation\x00missing \"%s\" value.\x00operation\x00n ??op? n ??by? n??\x00listVar ?index? ?index ...? value\x00-command\x00-indices\x00-unique\x00?-option value ...? list\x00\"-command\" option must be followed by comparison command\x00stride length must be at least 2\x00LSORT\x00no enough memory to proccess sort of %zu items\x00listVar first last ?element ...?\x00\n    (-compare command)\x00-compare command returned non-integer result\x00COMPARISONFAILED\x00element end-%d missing from sublist \"%s\"\x00element %d missing from sublist \"%s\"\x00INDEXFAILED\x00-about\x00-expanded\x00-line\x00-linestop\x00-lineanchor\x00--\x00?-option ...? exp string ?matchVar? ?subMatchVar ...?\x00regexp match variables not allowed when using -inline\x00REGEXP\x00MIX_VAR_INLINE\x00?-option ...? exp string subSpec ?varName?\x00&\\\x00*+?{}()[].\\|^$\x00command prefix must be a list of at least one element\x00REGSUB\x00CMDEMPTY\x00\n    (%s substitution computation script)\x00oldName newName\x00?-encoding encoding? fileName\x00-encoding\x00-nopkg\x00tclPkgFiles\x00 \n\t\r\x00string ?splitChars?\x00needleString haystackString ?startIndex?\x00needleString haystackString ?lastIndex?\x00string charIndex\x00string index insertString\x00control\x00dict\x00false\x00true\x00wideinteger\x00wordchar\x00class ?-strict? ?-failindex var? str\x00class\x00?-strict? ?-failindex var? str\x00?-nocase? charMap string\x00bad option \"%s\": must be -nocase\x00char map list unbalanced\x00MAP\x00UNBALANCED\x00?-nocase? pattern string\x00string first last\x00string count\x00string first last ?string?\x00string\x00string index\x00?-nocase? ?-length int? string1 string2\x00-length\x00bad option \"%s\": must be -nocase or -length\x00string ?first? ?last?\x00string ?chars?\x00cat\x00compare\x00equal\x00first\x00index\x00insert\x00is\x00last\x00length\x00map\x00match\x00range\x00repeat\x00replace\x00tolower\x00toupper\x00totitle\x00trim\x00trimleft\x00trimright\x00wordend\x00wordstart\x00-nobackslashes\x00-nocommands\x00-novariables\x00Tcl_SubstObjCmd: bad option index to SubstOptions\x00?-nobackslashes? ?-nocommands? ?-novariables? string\x00-indexvar\x00-matchvar\x00bad option \"%s\": %s option already found\x00SWITCH\x00DOUBLEOPT\x00missing variable name argument to %s option\x00NOVAR\x00?-option ...? string ?pattern body ...? ?default body?\x00%s option requires -regexp option\x00MODERESTRICTION\x00?-option ...? string {?pattern body ...? ?default body?}\x00extra switch pattern with no body\x00BADARM\x00, this may be due to a comment incorrectly placed outside of a switch body - see the \"switch\" documentation\x00COMMENT?\x00no body specified for pattern \"%s\"\x00FALLTHROUGH\x00fall-out when searching for body to match pattern\x00\n    (\"%.*s%s\" arm line %d)\x00type message\x00type must be non-empty list\x00THROW\x00BADEXCEPTION\x00-code error -level 0 -errorcode\x00command ?count?\x00per\x00iteration\x00-direct\x00-overhead\x00-calibrate\x00?-direct? ?-calibrate? ?-overhead double? command ?time ?max-count??\x00µs/#-overhead\x00%.*f\x00%.3f\x00net-ms\x00µs/#\x00#\x00#/sec\x00finally\x00on\x00trap\x00body ?handler ...? ?finally script?\x00handler type\x00finally clause must be last\x00TRY\x00FINALLY\x00NONTERMINAL\x00wrong # args to finally clause: must be \"... finally script\"\x00wrong # args to on clause: must be \"... on code variableList script\"\x00ON\x00wrong # args to trap clause: must be \"... trap pattern variableList script\"\x00TRAP\x00bad prefix '%s': must be a list\x00EXNFORMAT\x00last non-finally clause must not have a body of \"-\"\x00BADFALLTHROUGH\x00-during\x00\n    (\"%s ... %s\" handler line %d)\x00\n    (\"%s ... finally\" body line %d)\x00test command\x00\n    (\"while\" body line %d)\x00ForeachInfo\x00NewForeachInfo\x00DictUpdateInfo\x001\x00list must have an even number of elements\x00-errorcode {TCL ARGUMENT FORMAT}\x00bad stack depth computations: is %zu, should be %zu\x00TclCompileCatchCmd: bad jump distance %zd\x00TclCompileDictCmd(update): bad jump distance %zd\x00, \x00%%v%zu\x00variables\x00data=[\x00], loop=%%v%zu\x00,\x00\n\t\t it%%v%zu\t[\x00]\x00jumpOffset=%+zd, vars=\x00[\x00loop\x00assign\x00jumpOffset\x00TclCompileIfCmd: unexpected opcode \"%d\" updating ifFalse jump\x00::namespace inscope \x00::namespace\x00inscope\x00:\x002\x00end\x00-options\x00namespace\x00JumptableInfo\x003\x00%zu\x00TclCompileSubstCmd: bad start jump distance %zd\x00unexpected token type in TclCompileSubstCmd: %d\x00TclCompileSubstCmd: bad break jump distance %zd\x00TclCompileSubstCmd: bad continue jump distance %zd\x00TclCompileSubstCmd: bad return jump distance %zd\x00TclCompileSubstCmd: bad other jump distance %zd\x00TclCompileSubstCmd: bad ok jump distance %zd\x00TclCompileSubstCmd: bad end jump distance %zd\x00unknown switch mode: %d\x00\n\t\t\x00\"%s\"->pc %zu\x00mapping\x00-errorcode {TCL OPERATION THROW BADEXCEPTION}\x00-level 0 -code 0\x00-nocomplain\x00-1\x001.0\x00_@_\x00not enough memory to parse expression\x00NOMEM\x00invalid character \"%.*s\"\x00BADCHAR\x00incomplete operator \"%.*s\"\x00PARTOP\x00invalid bareword \"%.*s%s\"\x00should be \"$%.*s%s\" or \"{%.*s%s}\"\x00 or \"%.*s%s(...)\" or ...\x00BAREWORD\x00 (invalid binary number?)\x00BADNUMBER\x00 (invalid octal number?)\x00OCTAL\x00missing operator at %s\x00invalid character \"$\"\x00missing close-bracket\x00empty subexpression at %s\x00EMPTY\x00unbalanced open paren\x00missing function argument at %s\x00empty expression\x00unbalanced close paren\x00missing operand at %s\x00missing operator \":\" at %s\x00unexpected operator \":\" without preceding \"?\"\x00SURPRISE\x00unexpected \",\" outside function argument list\x00\nin expression \"%s%.*s%.*s%s%s%.*s%s\"\x00;\n\x00\n    (parsing expression \"%.*s%s\")\x00PARSE\x00EXPR\x00tcl::mathfunc::\x00done\x00push1\x00push4\x00invokeStk1\x00invokeStk4\x00loadScalar1\x00loadScalar4\x00loadScalarStk\x00loadArray1\x00loadArray4\x00storeScalar1\x00storeScalar4\x00storeScalarStk\x00storeArray1\x00storeArray4\x00incrScalar1\x00incrScalarStk\x00incrArray1\x00incrScalar1Imm\x00incrScalarStkImm\x00incrArray1Imm\x00jump1\x00jumpTrue1\x00jumpFalse1\x00beginCatch4\x00appendScalar1\x00appendScalar4\x00appendArray1\x00appendArray4\x00lappendScalar1\x00lappendScalar4\x00lappendArray1\x00lappendArray4\x00returnImm\x00expandStart\x00expandStkTop\x00invokeExpanded\x00listRangeImm\x00startCommand\x00returnStk\x00dictFirst\x00dictNext\x00dictUpdateStart\x00dictUpdateEnd\x00syntax\x00existScalar\x00returnCodeBranch\x00unsetScalar\x00strrangeImm\x00invokeReplace\x00expandDrop\x00foreach_start\x00foreach_step\x00foreach_end\x00lmap_collect\x00tclooNext\x00tclooNextClass\x00yieldToInvoke\x00strclass\x00lreplace4\x00constImm\x00constStk\x00bytecode\x00substcode\x00Maximum byte code length %d exceeded.\x00::tcl\x00::tcl::\x00TclCompileScript() called on uninitialized CompileEnv\x00too many nested compilations (infinite loop?)\x00Script length %td exceeds max permitted length %d.\x00SCRIPTLENGTH\x00Unexpected token type in TclCompileTokens: %d; %.*s\x00TclInitByteCodeObj() called on uninitialized CompileEnv\x00EnterCmdStartData: bad command index %zu\x00EnterCmdStartData: cmd map not sorted by code offset\x00EnterCmdExtentData: bad command index %zu\x00EnterCmdExtentData: missing start data for command %zu\x00trying to add 'break' fixup to full exception range\x00trying to add 'continue' fixup to full exception range\x00trying to finalize a loop exception range\x00TclFixupForwardJump: bad ExceptionRange type %d\x00unexpected opcode\x00GetCmdLocEncodingSize: bad code offset\x00GetCmdLocEncodingSize: bad code length\x00GetCmdLocEncodingSize: bad source length\x00EncodeCmdLocMap: bad code offset\x00EncodeCmdLocMap: bad code length\x00EncodeCmdLocMap: bad source length\x00%s.\n%s: %s\x00Tcl_RegisterConfig\x00Unable to create namespace for package configuration.\x00::pkgconfig\x00%s: %s\x00Unable to create query command for package configuration\x00get\x00subcommand ?arg?\x00subcommand\x00package not known\x00FATAL\x00PKGCFG_BASE\x00key\x00key not known\x00CONFIG\x00insufficient memory to create list\x00QueryConfigObjCmd: Unknown subcommand to 'pkgconfig'. This can't happen\x00tclPackageAboutDict\x00Deleting\x00syntax error\x00Error: discarding\x00Error: popping\x00memory exhausted\x00Cleanup: discarding lookahead\x00Cleanup: popping\x00january\x00february\x00march\x00april\x00may\x00june\x00july\x00august\x00september\x00sept\x00october\x00november\x00december\x00sunday\x00monday\x00tuesday\x00tues\x00wednesday\x00wednes\x00thursday\x00thur\x00thurs\x00friday\x00saturday\x00fortnight\x00minute\x00second\x00sec\x00tomorrow\x00yesterday\x00today\x00this\x00next\x00ago\x00epoch\x00stardate\x00gmt\x00ut\x00utc\x00uct\x00wet\x00bst\x00wat\x00at\x00nft\x00nst\x00ndt\x00ast\x00adt\x00est\x00edt\x00cst\x00cdt\x00mst\x00mdt\x00pst\x00pdt\x00yst\x00ydt\x00akst\x00akdt\x00hst\x00hdt\x00ahst\x00nt\x00idlw\x00cet\x00cest\x00met\x00mewt\x00mest\x00swt\x00sst\x00fwt\x00fst\x00eet\x00bt\x00it\x00zp4\x00zp5\x00ist\x00zp6\x00wast\x00wadt\x00jt\x00cct\x00jst\x00jdt\x00kst\x00kdt\x00cast\x00cadt\x00east\x00eadt\x00gst\x00nzt\x00nzst\x00nzdt\x00idle\x00dst\x00a\x00b\x00c\x00d\x00e\x00f\x00g\x00h\x00i\x00k\x00l\x00m\x00n\x00o\x00p\x00q\x00r\x00s\x00t\x00u\x00v\x00w\x00x\x00z\x00 (characters \x00am\x00a.m.\x00pm\x00p.m.\x00more than one date in string\x00more than one time of day in string\x00more than one time zone in string\x00more than one weekday in string\x00more than one ordinal month in string\x00DATE\x00MULTIPLE\x00Unknown status returned from date parser. Please report this error as a bug in Tcl.\x00BUG\x00create\x00filter\x00getdef\x00getwithdefault\x00keys\x00merge\x00remove\x00values\x00with\x00missing value to go with key\x00DICTIONARY\x00key \"%s\" not known in dictionary\x00DICT\x00Tcl_DictObjPut\x00Tcl_DictObjRemove\x00concurrent dictionary modification and search\x00Tcl_DictObjPutKeyList\x00%s called with empty key list\x00Tcl_DictObjRemoveKeyList\x00?key value ...?\x00dictionary ?key ...?\x00dictionary ?key ...? key default\x00dictionary ?key value ...?\x00dictionary ?pattern?\x00dictionary\x00dictionary key ?key ...?\x00dictVarName key ?increment?\x00\n    (reading increment)\x00dictVarName key ?value ...?\x00{keyVarName valueVarName} dictionary script\x00must have exactly two variable names\x00SYNTAX\x00\n    (\"dict for\" body line %d)\x00\n    (\"dict map\" body line %d)\x00dictVarName key ?key ...? value\x00dictVarName key ?key ...?\x00dictionary filterType ?arg ...?\x00filterType\x00dictionary script {keyVarName valueVarName} filterScript\x00\n    (\"dict filter\" filter script key variable)\x00\n    (\"dict filter\" filter script value variable)\x00\n    (\"dict filter\" script line %d)\x00dictVarName key varName ?key varName ...? script\x00\n    (body of \"dict update\")\x00dictVarName ?key ...? script\x00\n    (body of \"dict with\")\x00instname\x00ByteCode %p, refCt %td, epoch %td, interp %p (epoch %td)\n\x00  Source \x00\n  File \"%s\" Line %d\x00\n  Cmds %d, src %td, inst %td, litObjs %td, aux %td, stkDepth %td, code/src %.2f\n\x00  Proc %p, refCt %td, args %td, compiled locals %td\n\x00, scalar\x00, array\x00, link\x00, arg\x00, temp\x00, resolved\x00      slot %td%s%s%s%s%s%s\x00, \"%s\"\n\x00  Exception ranges %td, depth %td:\n\x00      %td: level %td, %s, pc %td-%td, \x00continue %td, break %td\n\x00catch %td\n\x00DisassembleByteCodeObj: bad ExceptionRange type %d\x00    \x00  Commands %d:\x00     \x00\n   \x00%s%4td: pc %d-%d, src %d-%d\x00  Command %td: \x00(%u) %s \x00%+d \x00%u \x00, %u cmds start here\x00pc %u\x00next cmd at pc %u\x00%d \x00end \x00end-%d \x00FormatInstruction: bad local var index %u (%td locals)\x00temp var %u\x00var \x00%%v%u \x00%s \x00\t# \x00\t# %s\x00\t\t[\x00]\n\x00InnerContext: bad tos -- appending null object\x00InnerContext: bad tos -- appending freed object %p\x00inst_%zu\x00\"\"\x00\\\"\x00\\f\x00\\n\x00\\r\x00\\t\x00\\v\x00\\U%08x\x00\\u%04x\x00%c\x00scalar\x00array\x00arg\x00temp\x00resolved\x00pc %d\x00@%d\x00%%%d\x00.%d\x00.end\x00.end-%d\x00?%d\x00=%s\x00opcode %d with more than zero 'no' operands\x00type %s level %td from %td to %td break %td continue %td\x00type %s level %td from %td to %td catch %td\x00codefrom\x00codeto\x00scriptfrom\x00scriptto\x00literals\x00exception\x00instructions\x00auxiliary\x00stackdepth\x00exceptdepth\x00initiallinenumber\x00sourcefile\x00constructor\x00destructor\x00lambda\x00method\x00objmethod\x00type ...\x00lambdaTerm\x00procName\x00PROC\x00className\x00\"%s\" is not a class\x00CLASS\x00\"%s\" has no defined constructor\x00DISASSEMBLE\x00CONSRUCTOR\x00body not available for this kind of constructor\x00METHODTYPE\x00body of constructor\x00\"%s\" has no defined destructor\x00DESRUCTOR\x00body not available for this kind of destructor\x00body of destructor\x00className methodName\x00objectName methodName\x00unknown method \"%s\"\x00METHOD\x00body not available for this kind of method\x00body of method\x00may not disassemble prebuilt bytecode\x00BYTECODE\x00strict\x00tcl8\x00*.enc\x00utf-8\x00cesu-8\x00ucs-2le\x00ucs-2be\x00ucs-2\x00utf-32le\x00utf-32be\x00utf-32\x00utf-16le\x00utf-16be\x00utf-16\x00unicode\x00iso8859-1\x00%td\x00unexpected byte sequence starting at index %td: '\\x%02X'\x00ILLEGALSEQUENCE\x00unexpected character at index %tu: 'U+%06X'\x00%s.enc\x00unknown encoding \"%s\"\x00invalid encoding file \"%s\"\x00init\x00final\x00EscapeToUtfProc: invalid sub table\x00bad profile name \"%s\": must be\x00 or \x00PROFILE\x00Internal error. Bad profile id \"%d\".\x00PROFILEID\x00configure\x00-map\x00-parameters\x00-prefixes\x00-subcommands\x00-unknown\x00-namespace\x00ensembleCommand\x00tried to manipulate ensemble of deleted namespace\x00ENSEMBLE\x00DEAD\x00subcommand ?arg ...?\x00?option value ...?\x00cmdname\x00cmdname ?-option value ...? ?arg ...?\x00unexpected ensemble command\x00ensemble subcommand implementations must be non-empty lists\x00EMPTY_TARGET\x00option -namespace is read-only\x00READ_ONLY\x00command is not an ensemble\x00NOT_ENSEMBLE\x00ensemble target is not a fully-qualified command\x00UNQUALIFIED_TARGET\x00\"%s\" is not an ensemble command\x00tcl:\x00invalid ensemble name '%s'\x00unable to find or create %s namespace!\x00ensemble activated for deleted namespace\x00full name %s not found in supposedly synchronized hash\x00unknown subcommand \"%s\": namespace %s does not export any commands\x00 or ambiguous\x00unknown%s subcommand \"%s\": must be \x00or %s\x00SpellFix: programming error\x00unknown subcommand handler deleted its ensemble\x00UNKNOWN_DELETED\x00\n    while parsing result of ensemble unknown subcommand handler\x00unknown subcommand handler returned bad code: \x00\n    result of ensemble unknown subcommand handler: \x00UNKNOWN_RESULT\x00\n    (ensemble unknown subcommand handler)\x00env\x00encoding error\x00no such variable\x00tclBgError\x00error in background error handler:\n\x00msg options\x00-level\x00missing return option \"-level\"\x00-code\x00missing return option \"-code\"\x00bgerror\x00errorInfo\x00bgerror failed to handle background error.\n    Original error: \x00\n    Error in bgerror: \x00TclSetBgErrorHandler: NULL cmdPrefix argument\x00Tcl_InitSubsystems called while exiting\x00exit handlers were created during Tcl_Finalize\x00-extended\x00-nofileevents\x00-noidleevents\x00-notimerevents\x00-nowindowevents\x00-readable\x00-timeout\x00-variable\x00-writable\x00argument required for \"%s\"\x00EVENT\x00timeout must be positive\x00NEGTIME\x00channel \"%s\" wasn't open for reading\x00channel \"%s\" wasn't open for writing\x00can't wait: would block forever\x00NO_SOURCES\x00timer events disabled with timeout specified\x00NO_TIME\x00file events disabled with channel(s) specified\x00NO_FILE_EVENT\x00limit exceeded\x00can't wait: would wait forever\x00can't wait for variable(s)/channel(s): would wait forever\x00timeleft\x00idletasks\x00Tcl_UpdateObjCmd: bad option index to UpdateOptions\x00?idletasks?\x00exprcode\x00dictIterator\x00freeing an execStack which is still in use\x00Deleting execEnv with pending TEOV callbacks!\x00Deleting execEnv with existing coroutine\x00STACK: Reallocating with no previous alloc\x00STACK: Stack after current is in use\x00STACK: Stack after current is not last\x00TclStackFree: incorrect freePtr (%p != %p). Call out of sequence?\x00TclStackRealloc: incorrect ptr. Call out of sequence?\x00Tcl_EvalObj: compiled script jumped interps\x00TclIncrObj\x00tailcall can only be called from a proc or lambda\x00\n    (reading value of variable to increment)\x00access\x00variable is array\x00name refers to an element in an array\x00variable already exists\x00make constant\x00CONST\x00array set\x00variable isn't array\x00WRITE\x00ARRAY\x00STACK_LEVEL\x00self may only be called from inside a method\x00OO\x00CONTEXT_REQUIRED\x00nextto may only be called from inside a method\x00CLASS_REQUIRED\x00%s implementation by \"%s\" not reachable from here\x00CLASS_NOT_REACHABLE\x00%s has no non-filter implementation by \"%s\"\x00CLASS_NOT_THERE\x00next may only be called from inside a method\x00no next %s implementation\x00NOTHING_NEXT\x00left \x00right \x00negative shift argument\x00INST_RETURN_CODE_BRANCH: TOS not a return code!\x00INST_RETURN_CODE_BRANCH: TOS is TCL_OK!\x00Should not happen!\x00mis-issued dictFirst!\x00mis-issued dictNext!\x00dictUpdateStart argument length mismatch\x00clockRead instruction with unknown clock#\x00TclNRExecuteByteCode: unrecognized opCode %u\x00divide by zero\x00DIVZERO\x00OUTOFMEMORY\x00exponentiation of zero by negative power\x00\nTclNRExecuteByteCode: abnormal return at pc %td: stack top %td < entry stack top %d\n\x00TclNRExecuteByteCode execution failure: end stack top < start stack top\x00exponent too large\x00unexpected number type\x00cannot use a list as %soperand of \"%s\"\x00non-numeric string\x00non-numeric floating-point value\x00floating-point value\x00(big) integer\x00cannot use %s \"%s\" as %soperand of \"%s\"\x00LocSearch failure\x00floating-point value too small to represent\x00UNDERFLOW\x00floating-point value too large to represent\x00OVERFLOW\x00unknown floating-point error, errno = %d\x00?-option value ...? source ?source ...? target\x00copying\x00renaming\x00error %s: target \"%s\" is not a directory\x00can't create directory \"%s\": %s\x00error deleting \"%s\": directory not empty\x00error deleting unknown file: %s\x00error deleting \"%s\": %s\x00can't overwrite file \"%s\" with directory \"%s\"\x00can't overwrite directory \"%s\" with file \"%s\"\x00u+w\x00-permissions\x00error renaming \"%s\" to \"%s\": trying to rename a volume or move a directory into itself\x00::tcl::CopyDirectory\x00can't unlink \"%s\": %s\x00error %s \"%s\"\x00 to \"%s\"\x00: \"%s\"\x00: %s\x00-force\x00name ?-option value ...?\x00must not update objPtrRef's variable and return non-NULL\x00bad option \"%s\", there are no file attributes in this filesystem\x00FATTR\x00value for \"%s\" missing\x00NOVALUE\x00?-linktype? linkname ?target?\x00-symbolic\x00-hard\x00could not create new link \"%s\": that path already exists\x00could not create new link \"%s\": no such file or directory\x00could not create new link \"%s\": target \"%s\" doesn't exist\x00could not create new link \"%s\" pointing to \"%s\": %s\x00could not read link \"%s\": %s\x00?nameVar? ?template?\x00can't create temporary file: %s\x00?template?\x00can't create temporary directory: %s\x00?user?\x00path\x00//?/UNC/\x00//?/\x00//\x00./\x00/\\:\x00-directory\x00-join\x00-path\x00-tails\x00-types\x00missing argument to \"-directory\"\x00\"-directory\" may only be used once\x00\"-directory\" cannot be used with \"-path\"\x00GLOB\x00BADOPTIONCOMBINATION\x00missing argument to \"-path\"\x00\"-path\" may only be used once\x00\"-path\" cannot be used with \"-dictionary\"\x00missing argument to \"-types\"\x00\"-tails\" must be used with either \"-directory\" or \"-path\"\x00\\/\x00//zipfs:\x00\\[]*?{}\x00readonly\x00hidden\x00macintosh\x00creator\x00bad argument to \"-types\": %s\x00BAD\x00only one MacOS type or creator argument to \"-types\" allowed\x00/\\\x00Called TclGlob with TCL_GLOBMODE_TAILS and pathPrefix==NULL\x00.\x00unmatched open-brace in file name\x00BALANCE\x00unmatched close-brace in file name\x00*[]?\\\x00invalid sharing of Tcl_Obj on C stack\x00malformed bucket chain in Tcl_DeleteHashEntry\x00%tu entries in table, %tu buckets\n\x00number of buckets with %tu entries: %tu\n\x00number of buckets with %d or more entries: %tu\n\x00average search distance for entry: %.1f\x00called %s on deleted table\x00Tcl_FindHashEntry\x00Tcl_CreateHashEntry\x00::tcl::HistoryObjs\x00::history\x00nfc\x00nfd\x00nfkc\x00nfkd\x00ICU function not available\x00ICU\x00UNSUPPORTED_OP\x00. \x00%s%sICU error (%d): %s\x00Could not open charset detector\x00Could not set detection text\x00Could not detect character set\x00Could not get list of detectable encodings\x00Could not get charset enumerator count\x00?bytes ?-all??\x00Invalid option %s, must be \"-all\"\x00convertername\x00Could not get aliases\x00Could not get encoding converter\x00Could not set conversion callback\x00Max length supported by ICU exceeded.\x00ICU error while encoding\x00ICU error while decoding\x00Could not get ICU normalizer\x00String normalization failed\x00?-profile PROFILE? ICUENCNAME STRING\x00Missing value for option %s.\x00Invalid value \"%s\" supplied for option \"-profile\". Must be \"strict\" or \"replace\".\x00Option -failindex not implemented.\x00-mode\x00?-profile PROFILE? ?-mode MODE? STRING\x00normalization mode\x00libicuuc.so.??\x00libicu%s.so.%s\x00i18n\x00u_cleanup\x00u_errorName\x00u_strFromUTF32\x00u_strFromUTF32WithSub\x00u_strToUTF32\x00u_strToUTF32WithSub\x00ucnv_close\x00ucnv_countAliases\x00ucnv_countAvailable\x00ucnv_fromUChars\x00ucnv_getAlias\x00ucnv_getAvailableName\x00ucnv_open\x00ucnv_setFromUCallBack\x00ucnv_setToUCallBack\x00ucnv_toUChars\x00UCNV_FROM_U_CALLBACK_STOP\x00UCNV_TO_U_CALLBACK_STOP\x00ubrk_open\x00ubrk_close\x00ubrk_preceding\x00ubrk_following\x00ubrk_previous\x00ubrk_next\x00ubrk_setText\x00uenum_close\x00uenum_count\x00uenum_next\x00unorm2_getNFCInstance\x00unorm2_getNFDInstance\x00unorm2_getNFKCInstance\x00unorm2_getNFKDInstance\x00unorm2_normalize\x00ucsdet_close\x00ucsdet_detect\x00ucsdet_detectAll\x00ucsdet_getName\x00ucsdet_getAllDetectableCharsets\x00ucsdet_open\x00ucsdet_setText\x00::tcl::unsupported::icu::convertto\x00::tcl::unsupported::icu::convertfrom\x00::tcl::unsupported::icu::detect\x00::tcl::unsupported::icu::converters\x00::tcl::unsupported::icu::aliases\x00::tcl::unsupported::icu::normalize\x00Invalid %s value %td.\x00struct offset\x00ambiguous \x00bad \x00 \"\x00\": no valid options\x00\": must be \x00, or \"\"\x00all\x00longest\x00::tcl::prefix\x00prefix\x00-error\x00-message\x00?options? table string\x00missing value for -message\x00NOARG\x00missing value for -error\x00error options must have an even number of elements\x00table string\x00 or \"\x00wrong # args: should be \"\x00ambiguous option \"%s\"\x00unrecognized argument \"%s\"\x00expected integer argument for \"%s\" but got \"%s\"\x00expected floating-point argument for \"%s\" but got \"%s\"\x00too many (%td) arguments for TCL_ARGV_GENFUNC\x00bad argument type %d in Tcl_ArgvInfo\x00\"%s\" option requires an additional argument\x00Command-specific options:\x00\n%s\x00\n %s:\x00\n\t\tDefault value: %d\x00\n\t\tDefault value: %g\x00\n\t\tDefault value: \"%s\"\x00ok\x00bad completion code \"%s\": must be ok, error, return, break, continue, or an integer\x00RESULT\x00ILLEGAL_CODE\x00if {[namespace which -command tclInit] eq \"\"} {\n  proc tclInit {} {\n    global tcl_libPath tcl_library env tclDefaultLibrary\n    rename tclInit {}\n    if {[info exists tcl_library]} {\n\tset scripts {{set tcl_library}}\n    } else {\n\tset scripts {}\n\tif {[info exists env(TCL_LIBRARY)] && ($env(TCL_LIBRARY) ne {})} {\n\t    lappend scripts {set env(TCL_LIBRARY)}\n\t    lappend scripts {\nif {[regexp ^tcl(.*)$ [file tail $env(TCL_LIBRARY)] -> tail] == 0} continue\nif {$tail eq [info tclversion]} continue\nfile join [file dirname $env(TCL_LIBRARY)] tcl[info tclversion]}\n\t}\n\tlappend scripts {::tcl::zipfs::tcl_library_init}\n\tif {[info exists tclDefaultLibrary]} {\n\t    lappend scripts {set tclDefaultLibrary}\n\t} else {\n\t    lappend scripts {::tcl::pkgconfig get scriptdir,runtime}\n\t}\n\tlappend scripts {\nset parentDir [file dirname [file dirname [info nameofexecutable]]]\nset grandParentDir [file dirname $parentDir]\nfile join $parentDir lib tcl[info tclversion]} \\\n\t{file join $grandParentDir lib tcl[info tclversion]} \\\n\t{file join $parentDir library} \\\n\t{file join $grandParentDir library} \\\n\t{file join $grandParentDir tcl[info tclversion] library} \\\n\t{file join $grandParentDir tcl[info patchlevel] library} \\\n\t{\nfile join [file dirname $grandParentDir] tcl[info patchlevel] library}\n\tif {[info exists tcl_libPath]\n\t\t&& [catch {llength $tcl_libPath} len] == 0} {\n\t    for {set i 0} {$i < $len} {incr i} {\n\t\tlappend scripts [list lindex \\$tcl_libPath $i]\n\t    }\n\t}\n    }\n    set dirs {}\n    set errors {}\n    foreach script $scripts {\n\tif {[set tcl_library [eval $script]] eq \"\"} continue\n\tset tclfile [file join $tcl_library init.tcl]\n\tif {[file exists $tclfile]} {\n\t    if {[catch {uplevel #0 [list source $tclfile]} msg opts]} {\n\t\tappend errors \"$tclfile: $msg\n\"\n\t\tappend errors \"[dict get $opts -errorinfo]\n\"\n\t\tcontinue\n\t    }\n\t    unset -nocomplain tclDefaultLibrary\n\t    return\n\t}\n\tlappend dirs $tcl_library\n    }\n    unset -nocomplain tclDefaultLibrary\n    set msg \"Cannot find a usable init.tcl in the following directories: \n\"\n    append msg \"    $dirs\n\n\"\n    append msg \"$errors\n\n\"\n    append msg \"This probably means that Tcl wasn't installed properly.\n\"\n    error $msg\n  }\n}\ntclInit\x00InterpInfoDeleteProc: still exist commands\x00InterpInfoDeleteProc: still exist aliases\x00aliases\x00cancel\x00children\x00debug\x00expose\x00hide\x00issafe\x00invokehidden\x00limit\x00marktrusted\x00recursionlimit\x00share\x00slaves\x00target\x00transfer\x00cmd ?arg ...?\x00childPath childCmd ?parentPath parentCmd? ?arg ...?\x00path ?cmdPrefix?\x00-unwind\x00?-unwind? ?--? ?path? ?result?\x00-safe\x00?-safe? ?--? ?path?\x00interp%td\x00path ?-frame ?bool??\x00cannot delete the current interpreter\x00INTERP\x00DELETESELF\x00path arg ?arg ...?\x00path hiddenCmdName ?cmdName?\x00path cmdName ?hiddenCmdName?\x00-global\x00path ?-namespace ns? ?-global? ?--? cmd ?arg ..?\x00path limitType ?-option value ...?\x00limit type\x00unreachable\x00path ?newlimit?\x00srcPath channel destPath\x00path alias\x00alias \"%s\" in path \"%s\" not found\x00ALIAS\x00target interpreter for alias \"%s\" in path \"%s\" is not my descendant\x00TARGETSHROUDED\x00?path?\x00alias \"%s\" not found\x00cannot define or rename alias \"%s\": interpreter deleted\x00cannot define or rename alias \"%s\": would create a loop\x00ALIASLOOP\x00could not find interpreter \"%s\"\x00cmdPrefix must be list of length >= 1\x00BGERRORFORMAT\x00interpreter named \"%s\" already exists, cannot create\x00tcl_interactive\x00clock\x00TclChildObjCmd: interpreter has been deleted\x00aliasName ?targetName? ?arg ...?\x00?cmdPrefix?\x00?-frame ?bool??\x00hiddenCmdName ?cmdName?\x00cmdName ?hiddenCmdName?\x00?-namespace ns? ?-global? ?--? cmd ?arg ..?\x00limitType ?-option value ...?\x00?newlimit?\x00-frame\x00debug option\x00permission denied: safe interpreter cannot expose commands\x00UNSAFE\x00permission denied: safe interpreters cannot change recursion limit\x00recursion limit must be > 0\x00BADLIMIT\x00falling back due to new recursion limit\x00RECURSION\x00permission denied: safe interpreter cannot hide commands\x00not allowed to invoke hidden commands from safe interpreter\x00permission denied: safe interpreter cannot mark trusted\x00namespace eval ::tcl {namespace eval mathfunc {}}\x00os\x00osVersion\x00machine\x00user\x00tclDefaultLibrary\x00tcl_pkgPath\x00command count limit exceeded\x00COMMANDS\x00time limit exceeded\x00TIME\x00unknown type of resource limit\x00\n    (while waiting for event)\x00limit granularity must be positive\x00installing limit callback to the limited interpreter\x00-granularity\x00-value\x00limits on current interpreter inaccessible\x00SELF\x00?-option value ...?\x00granularity must be at least 1\x00BADVALUE\x00command limit value must be at least 0\x00-seconds\x00milliseconds must be non-negative\x00seconds must be non-negative\x00may only set -milliseconds if -seconds is not also being reset\x00BADUSAGE\x00may only reset -milliseconds if -seconds is also being reset\x00channel\x00TCL_FLUSH_NONBLOCKING_ON_EXIT\x00-blocking\x00tclIO\x00Tcl_RegisterChannel: channel without name\x00Tcl_RegisterChannel: duplicate channel names\x00illegal recursive call to close through close-handler of channel\x00stdin\x00stdout\x00stderr\x00can not find channel named \"%s\"\x00CHANNEL\x00channel does not have a type name\x00channel type %s must be version TCL_CHANNEL_VERSION_5\x00channel type %s must define close2Proc\x00channel type %s must define inputProc when used for reader channel\x00channel type %s must define outputProc when used for writer channel\x00channel type %s must define watchProc\x00couldn't find state for channel \"%s\"\x00reading and writing both disallowed for channel \"%s\"\x00could not flush channel \"%s\"\x00Channel released more than preserved\x00channel \"%s\" does not support OS handles\x00Illegal mode value.\x00Bad mode, would make channel inacessible\x00Tcl_RemoveChannelMode error: %s. Channel: \"%s\"\x00Reuse of ChannelBuffer! %p\x00unable to access channel: invalid channel\x00TclFlush, closed channel: queued output left\x00FlushChannel: damaged channel list\x00SpliceChannel: trying to add channel used in different list\x00called Tcl_Close on channel with refCount > 0\x00double-close of channels not supported by %ss\x00half-close of channels not supported by %ss\x00half-close not applicable to stack of transformations\x00write\x00Half-close of %s-side not possible, side not opened or already closed\x00ClosechanHalf, closed write-side of channel: queued output left\x00unknown output translation requested\x00Tcl_GetsObj: gotEOL reached with bufPtr==NULL\x00TclGetsObjBinary: gotEOL reached with bufPtr==NULL\x00binary encoding is not available\x00Buffer Underflow, BUFFER_PADDING not enough\x00unknown input translation %d\x00blocking buffering buffersize encoding eofchar profile translation\x00malformed option list in channel driver\x00bad option \"%s\": should be one of \x00-%s, \x00or -%s\x00-buffering\x00none\x00full\x00-buffersize\x00-eofchar\x00-translation\x00auto\x00cr\x00crlf\x00lf\x00unable to set channel options: background copy in progress\x00bad value for -buffering: must be one of full, line, or none\x00unknown encoding \"%s\": No longer supported.\n\tplease use either \"-translation binary\" or \"-encoding iso8859-1\"\x00 {}\x00bad value for -eofchar: must be non-NUL ASCII character\x00bad value for -translation: must be a one or two element list\x00platform\x00bad value for -translation: must be one of auto, binary, cr, lf, crlf, or platform\x00tcp\x00channel event ?script?\x00event name\x00channel is not %s\x00channel \"%s\" is busy\x00writ\x00error %sing \"%s\": %s\x00error reading \"\x00\": \x00error writing \"\x00error setting blocking mode: %s\x00Tcl_SetChannelError: bad syntax of message\x00Defined newlevel not used in rewrite\x00Defined newcode not used in rewrite\x00-nonewline\x00?-nonewline? ?channel? string\x00channel \"%s\" wasn't opened for writing\x00error writing \"%s\": %s\x00error flushing \"%s\": %s\x00channel ?varName?\x00channel \"%s\" wasn't opened for reading\x00error reading \"%s\": %s\x00channel ?numChars?\x00?-nonewline? channel\x00expected non-negative integer but got \"%s\"\x00NUMBER\x00-data\x00start\x00channel offset ?origin?\x00origin\x00error during seek on \"%s\": %s\x00channel ?direction?\x00direction\x00channel ?-option value ...?\x00-ignorestderr\x00-keepnewline\x00?-option ...? arg ?arg ...?\x00error reading output from command: %s\x00fileName ?access? ?permissions?\x000o\x00Tcl_OpenCmd: invalid mode value\x00tclTCPAcceptCallbacks\x00RegisterTcpServerCleanup: damaged accept record table\x00-async\x00-backlog\x00-myaddr\x00-myport\x00-reuseaddr\x00-reuseport\x00-server\x00cannot set -async option for server sockets\x00no argument given for -myaddr option\x00no argument given for -myport option\x00no argument given for -server option\x00no argument given for -reuseaddr option\x00no argument given for -reuseport option\x00no argument given for -backlog option\x00Tcl_SocketObjCmd: bad option index to SocketOptions\x00option -myport is not valid for servers\x00?-async? ?-myaddr addr? ?-myport myport? host port\x00-server command ?-backlog count? ?-myaddr addr? ?-reuseaddr boolean? ?-reuseport boolean? port\x00options -backlog, -reuseaddr, and -reuseport are only valid for servers\x00-size\x00input output ?-size size? ?-command callback?\x00input\x00output\x00mode channel\x00channel ?length?\x00cannot truncate to negative length of file\x00could not determine current location in \"%s\": %s\x00error during truncate on \"%s\": %s\x00blocked\x00event\x00isbinary\x00pending\x00pipe\x00postevent\x00truncate\x00::fconfigure\x00chan\x00tclrchannel\x00blocking\x00cget\x00cgetall\x00finalize\x00initialize\x00watch\x00{read delivered more than requested}\x00{read delivered nonbyte result}\x00{write wrote more than requested}\x00{write wrote nothing}\x00{Tried to seek before origin}\x00{Channel thread lost}\x00{Owner lost}\x00-code 1 -level 0 -errorcode NONE -errorinfo {} -errorline 1 {Owner lost}\x00mode cmdprefix\x00chan handler \"%s initialize\" returned non-list: %s\x00chan handler \"\x00 initialize\" returned \x00chan handler \"%s\" does not support all required methods\x00chan handler \"%s\" lacks a \"read\" method\x00chan handler \"%s\" lacks a \"write\" method\x00chan handler \"%s\" supports \"cget\" but not \"cgetall\"\x00chan handler \"%s\" supports \"cgetall\" but not \"cget\"\x00TclChanCreateObjCmd: duplicate channel names\x00channel eventspec\x00can not find reflected channel named \"%s\"\x00TclChanPostEventObjCmd: channel is not a reflected channel\x00TclChanPostEventObjCmd: postevent accepted for call from outside interpreter\x00bad event list: is empty\x00tried to post events channel \"%s\" is not interested in\x00TclChanCaughtErrorBypass: Bad syntax of caught result\x00Unknown thread action code.\x00Expected list with even number of elements, got %td element%s instead\x00read write\x00rc%lu\x00chan handler returned bad code: %d\x00\n    (chan handler subcommand \"%s\")\x00EAGAIN\x00ReflectedChannelMap\x00element\x00elements\x00{Expected list with even number of elements, got %td %s instead}\x00Bad operation code in ForwardProc\x00tclrtransform\x00clear\x00drain\x00limit?\x00{read not supported by Tcl driver}\x00{write not supported by Tcl driver}\x00channel cmdprefix\x00chan handler \"%s initialize\" returned %s\x00chan handler \"%s\" makes the channel inaccessible\x00chan handler \"%s\" supports \"drain\" but not \"read\"\x00chan handler \"%s\" supports \"flush\" but not \"write\"\x00TclChanPushObjCmd: duplicate transformation handle\x00rt%lu\x00ReflectedTransformMap\x00transform\x00-command value is not a list\x00\nfailed to stack channel \"%s\"\x00create/write\x00create/read\x00delete/write\x00chan transform callback received non-bytes\x00flush/write\x00flush/read\x00delete/read\x00query/maxRead\x00clear/read\x00couldn't open socket: port number too high\x00::tcl::unsupported::socketAF\x00inet\x00inet6\x00glob couldn't determine the current working directory\x00illegal access mode \"%s\"\x00OPENMODE\x00\n    while processing open access modes \"\x00RDONLY\x00invalid access mode \"%s\": modes RDONLY, RDWR, and WRONLY cannot be combined\x00WRONLY\x00RDWR\x00APPEND\x00access mode \"%s\" repeated\x00CREAT\x00EXCL\x00NOCTTY\x00NONBLOCK\x00TRUNC\x00invalid access mode \"%s\": must be APPEND, BINARY, CREAT, EXCL, NOCTTY, NONBLOCK, RDONLY, RDWR, TRUNC, or WRONLY\x00access mode must include either RDONLY, RDWR, or WRONLY\x00couldn't read file \"%s\": %s\x00\x1a\x00\ufeff\x00\n    (file \"%.*s%s\" line %d)\x00POSIX\x00could not seek to end of file while opening \"%s\": %s\x00couldn't open \"%s\": %s\x00error getting working directory name: %s\x00TCL_TEMPLOAD_NO_UNLINK\x00couldn't load library \"%s\": %s\x00couldn't load from current filesystem\x000700\x00cannot unload: filesystem does not support unloading\x00wb\x00rb\x00Tcl_FSGetFileSystemForPath called with NULL object\x00Tcl_FSGetFileSystemForPath called with object with refCount == 0\x00invalidReal\x00variable '%s' is already linked\x00wrong array size given\x00bad linked array variable type\x00xXbBoOdD\x00+-\x00linked variable is read-only\x00internal error: linked variable couldn't be read\x00wrong size of char* value\x00invalid binary value\x00wrong size of binary value\x00wrong dimension\x00variable array must have integer values\x00variable must have integer value\x00variable array must have wide integer value\x00variable must have wide integer value\x00variable array must have real value\x00variable must have real value\x00variable array must have boolean value\x00variable must have boolean value\x00variable array must have char value\x00variable must have char value\x00variable array must have unsigned char value\x00variable must have unsigned char value\x00variable array must have short value\x00variable must have short value\x00variable array must have unsigned short value\x00variable must have unsigned short value\x00variable array must have unsigned int value\x00variable must have unsigned int value\x00variable array must have unsigned wide int value\x00variable must have unsigned wide int value\x00variable array must have float value\x00variable must have float value\x00internal error: bad linked variable type\x00NULL\x00??\x00list construction failed: unable to alloc %zu bytes\x00storePtr != NULL\x00storePtr->numAllocated >= 0\x00storePtr->numAllocated <= LIST_MAX\x00storePtr->firstUsed >= 0\x00storePtr->firstUsed < storePtr->numAllocated\x00storePtr->numUsed >= 0\x00storePtr->numUsed <= storePtr->numAllocated\x00storePtr->firstUsed <= (storePtr->numAllocated - storePtr->numUsed)\x00repPtr->spanPtr || repPtr->storePtr->firstUsed == 0\x00ListRepStart(repPtr) >= storePtr->firstUsed\x00ListRepLength(repPtr) <= storePtr->numUsed\x00ListRepStart(repPtr) <= (storePtr->firstUsed + storePtr->numUsed - ListRepLength(repPtr))\x00List internal failure in %s line %d. Condition: %s\x00Object passed to TclListObjValidate cannot be converted to a list object.\x00/home/jnml/.config/ccgo/v4/libtcl9.0/linux/s390x/tcl9.0.1/generic/tclListObj.c\x00list creation failed: unable to alloc %td bytes\x00Tcl_SetListObj\x00Tcl_ListObjAppendList\x00TclListObjAppendElements\x00Tcl_ListObjReplace\x00TclListObjSetElement\x00index \"%td\" out of range\x00max size for a Tcl value (%zu bytes) exceeded\x00Literal table index too large. Cannot be handled by TclEmitPush\x00max size of Tcl literal array (%zu literals) exceeded\x00-lazy\x00?-global? ?-lazy? ?--? fileName ?prefix? ?interp?\x00must specify either file name or prefix\x00LOAD\x00NOLIBRARY\x00file \"%s\" is already loaded for prefix \"%s\"\x00SPLITPERSONALITY\x00tclLoad\x00no library with prefix \"%s\" is loaded statically\x00NOTSTATIC\x00cannot figure out prefix for %s\x00WHATLIBRARY\x00_Init\x00_SafeInit\x00_Unload\x00_SafeUnload\x00cannot use library in a safe interpreter: no %s_SafeInit procedure\x00cannot attach library to interpreter: no %s_Init procedure\x00ENTRYPOINT\x00-keeplibrary\x00?-switch ...? fileName ?prefix? ?interp?\x00UNLOAD\x00library with prefix \"%s\" is loaded statically and cannot be unloaded\x00STATIC\x00file \"%s\" has never been loaded\x00NEVERLOADED\x00file \"%s\" has never been loaded in this interpreter\x00file \"%s\" cannot be unloaded under a safe interpreter\x00CANNOT\x00file \"%s\" cannot be unloaded under a trusted interpreter\x00file \"%s\" cannot be unloaded: unloading disabled\x00DISABLED\x00tcl_rcFileName\x00tclsh\x00argv0\x00argc\x00argv\x00application-specific initialization failed: \x00exit %d\x00TCL_FINALIZE_ON_EXIT\x00tcl_prompt2\x00tcl_prompt1\x00\n    (script that generates prompt)\x00nsName\x00code\x00export\x00forget\x00parent\x00qualifiers\x00which\x00Trying to push call frame for dead namespace\x00errorCode\x00can't create namespace \"\": only global namespace can have empty name\x00CREATEGLOBAL\x00can't create namespace \"%s\": already exists\x00CREATEEXISTING\x00invalid export pattern \"%s\": pattern can't specify a namespace\x00EXPORT\x00auto_import\x00empty import pattern\x00IMPORT\x00unknown namespace in import pattern \"%s\"\x00no namespace specified in import pattern \"%s\"\x00ORIGIN\x00import pattern \"%s\" tries to import from namespace \"%s\" into itself\x00import pattern \"%s\" would create a loop containing command \"%s\"\x00LOOP\x00can't import command \"%s\": already exists\x00OVERWRITE\x00unknown namespace in namespace forget pattern \"%s\"\x00DeleteImportedCmd: did not find cmd in real cmd's list of import references\x00Could not create namespace '%s'\x00unknown namespace \"%s\"\x00unknown command \"%s\"\x00namespace \"%s\" not found\x00namespace \"%s\" not found in \"%s\"\x00?name? ?pattern?\x00?name name...?\x00unknown namespace \"%s\" in namespace delete command\x00name arg ?arg...?\x00\n    (in namespace %s \"%.*s%s\" script line %d)\x00?-clear? ?pattern pattern...?\x00?pattern pattern...?\x00?-force? ?pattern pattern...?\x00?pathList?\x00?script?\x00ns ?otherVar myVar ...?\x00?-command? ?-variable? name\x00while executing\x00invoked from within\x00\n    %s\n\"%.*s%s\"\x00bignum\x00cmdName\x00Derived ICL data for object using offsets from before the script\x00can't convert value to type %s\x00API_ABUSE\x00TclSetDuplicateObj\x00UpdateStringProc should not be invoked for type %s\x00UpdateStringProc for type '%s' failed to create a valid string rep\x00Tcl_GetStringFromObj with 'int' lengthPtr cannot handle such long strings. Please use 'Tcl_Size'\x00boolean value or \"\"\x00boolean value\x00Wrong bool var for %s\x00Tcl_GetBoolFromObj\x00 or \"\"\x00expected boolean value%s but got a list\x00expected boolean value but got \"\x00BOOLEAN\x00yes\x00no\x00off\x00Tcl_SetDoubleObj\x00floating point value is Not a Number\x00DOUBLE\x00NAN\x00expected floating-point number but got a list\x00floating-point number\x00IOVERFLOW\x00expected integer but got \"%s\"\x00INTEGER\x00expected integer but got a list\x00Tcl_SetWideIntObj\x00Tcl_SetWideUIntObj\x00expected unsigned integer but got \"%s\"\x00initialization failure in DupBignum\x00radix size failure in UpdateStringOfBignum\x00UpdateStringOfBignum: string length limit exceeded\x00conversion failure in UpdateStringOfBignum\x00Tcl_SetBignumObj\x00expected number but got a list\x00number\x00max size for a Tcl value (%d bytes) exceeded\x00pure string\x00value is a %s with a refcount of %td, object pointer at %p\x00, internal representation %g\x00, internal representation %p:%p\x00, string representation \"\x00, no string representation\x00can't parse a NULL pointer\x00extra characters after close-quote\x00extra characters after close-brace\x00ParseTokens encountered unknown character\x00missing close-brace for variable name\x00missing )\x00invalid character in array index\x00$\x00missing close-brace\x00: possible unbalanced brace in comment\x00missing \"\x00TclSubstParse: programming error\x00bad parse in TclSubstParse: %c\x00unexpected token type in TclSubstTokens: %d\x00Bad portion to TclPathPart\x00Called UpdateStringOfFsPath with invalid object\x00HOME\x00couldn't find HOME environment variable to expand path\x00PATH\x00HOMELESS\x00user \"%s\" doesn't exist\x00NOUSER\x00writing\x00reading\x00channel \"%s\" wasn't opened for %s\x00EXEC\x00BADCHAN\x00couldn't %s file \"%s\": %s\x00can't specify \"%s\" as last word in command\x00error reading stderr output file: %s\x00child process exited abnormally\x00illegal use of | or |& in command\x00PIPESYNTAX\x00must specify \"%s\" as last word in command\x00couldn't create input file for command: %s\x00couldn't create input pipe for command: %s\x00couldn't create output pipe for command: %s\x00couldn't create error file for command: %s\x00couldn't create pipe: %s\x00can't read output from command: standard output was redirected\x00BADREDIRECT\x00can't write input to command: standard input was redirected\x00pipe for command could not be created\x00NOPIPE\x00conflicting versions provided for package \"%s\": %s, then %s\x00PACKAGE\x00VERSIONCONFLICT\x00Cannot load package \"%s\" in standalone executable: This package is not compiled with stub support\x00UNSTUBBED\x00bad return code: %d\x00BADRESULT\x00\n    (\"package unknown\" script)\x00can't find package %s\x00UNFOUND\x00version conflict for package \"%s\": have %s, need\x00circular package dependency: attempt to provide %s %s requires %s\x00CIRCULARITY\x00attempt to provide package %s %s failed: no version of package %s provided\x00UNPROVIDED\x00attempt to provide package %s %s failed: package %s %s provided instead\x00WRONGPROVIDE\x00attempt to provide package %s %s failed: bad return code: %s\x00\n    (\"package ifneeded %s %s\" script)\x00package %s %s is not present\x00package %s is not present\x00files\x00ifneeded\x00prefer\x00present\x00provide\x00require\x00vcompare\x00versions\x00vsatisfies\x00option ?arg ...?\x00package version ?script?\x00package ?version?\x00?-exact? package ?requirement ...?\x00?command?\x00latest\x00stable\x00?latest|stable?\x00preference\x00version1 version2\x00version ?requirement ...?\x00Tcl_PackageObjCmd: bad option index to pkgOptions\x00expected version number but got \"%s\"\x00VERSION\x00expected versionMin-versionMax but got \"%s\"\x00VERSIONRANGE\x00 exactly %s\x00 %s\x00 0-\x00 -2\x00threaded\x00profiled\x0064bit\x00optimized\x00mem_debug\x00compile_debug\x00compile_stats\x00libdir,runtime\x00/usr/local/lib\x00bindir,runtime\x00/usr/local/bin\x00scriptdir,runtime\x00/usr/local/lib/tcl9.0\x00includedir,runtime\x00/usr/local/include\x00docdir,runtime\x00/usr/local/share/man\x00libdir,install\x00bindir,install\x00scriptdir,install\x00includedir,install\x00docdir,install\x00E2BIG\x00EACCES\x00EADDRINUSE\x00EADDRNOTAVAIL\x00EADV\x00EAFNOSUPPORT\x00EALREADY\x00EBADE\x00EBADF\x00EBADFD\x00EBADMSG\x00EBADR\x00EBADRQC\x00EBADSLT\x00EBFONT\x00EBUSY\x00ECANCELED\x00ECHILD\x00ECHRNG\x00ECOMM\x00ECONNABORTED\x00ECONNREFUSED\x00ECONNRESET\x00EDEADLK\x00EDESTADDRREQ\x00EDOM\x00EDOTDOT\x00EDQUOT\x00EEXIST\x00EFAULT\x00EFBIG\x00EHOSTDOWN\x00EHOSTUNREACH\x00EIDRM\x00EILSEQ\x00EINPROGRESS\x00EINTR\x00EIO\x00EISCONN\x00EISDIR\x00EISNAM\x00EL2HLT\x00EL2NSYNC\x00EL3HLT\x00EL3RST\x00ELIBACC\x00ELIBBAD\x00ELIBEXEC\x00ELIBMAX\x00ELIBSCN\x00ELNRNG\x00ELOOP\x00EMEDIUMTYPE\x00EMFILE\x00EMLINK\x00EMSGSIZE\x00EMULTIHOP\x00ENAMETOOLONG\x00ENAVAIL\x00ENETDOWN\x00ENETRESET\x00ENETUNREACH\x00ENFILE\x00ENOANO\x00ENOBUFS\x00ENOCSI\x00ENODATA\x00ENODEV\x00ENOENT\x00ENOEXEC\x00ENOLCK\x00ENOLINK\x00ENOMEM\x00ENOMEDIUM\x00ENOMSG\x00ENONET\x00ENOPKG\x00ENOPROTOOPT\x00ENOSPC\x00ENOSR\x00ENOSTR\x00ENOSYS\x00ENOTBLK\x00ENOTCONN\x00ENOTRECOVERABLE\x00ENOTDIR\x00ENOTEMPTY\x00ENOTNAM\x00ENOTSOCK\x00ENOTSUP\x00ENOTTY\x00ENOTUNIQ\x00ENXIO\x00EOVERFLOW\x00EOWNERDEAD\x00EPERM\x00EPFNOSUPPORT\x00EPIPE\x00EPROTO\x00EPROTONOSUPPORT\x00EPROTOTYPE\x00ERANGE\x00EREMCHG\x00EREMOTE\x00EREMOTEIO\x00ERESTART\x00EROFS\x00ESHUTDOWN\x00ESOCKTNOSUPPORT\x00ESPIPE\x00ESRCH\x00ESRMNT\x00ESTALE\x00ETIME\x00ETIMEDOUT\x00ETOOMANYREFS\x00ETXTBSY\x00EUCLEAN\x00EUNATCH\x00EUSERS\x00EXDEV\x00EXFULL\x00unknown error\x00argument list too long\x00permission denied\x00address already in use\x00cannot assign requested address\x00advertise error\x00address family not supported by protocol\x00resource temporarily unavailable\x00operation already in progress\x00invalid exchange\x00bad file descriptor\x00file descriptor in bad state\x00bad message\x00invalid request descriptor\x00invalid request code\x00invalid slot\x00bad font file format\x00device or resource busy\x00operation canceled\x00no child processes\x00channel number out of range\x00communication error on send\x00software caused connection abort\x00connection refused\x00connection reset by peer\x00resource deadlock avoided\x00destination address required\x00numerical argument out of domain\x00cross mount point\x00disk quota exceeded\x00file exists\x00bad address\x00file too large\x00host is down\x00no route to host\x00identifier removed\x00invalid or incomplete multibyte or wide character\x00operation now in progress\x00interrupted system call\x00invalid argument\x00input/output error\x00transport endpoint is already connected\x00is a directory\x00is a named type file\x00level 2 halted\x00level 2 not synchronized\x00level 3 halted\x00level 3 reset\x00can not access a needed shared library\x00accessing a corrupted shared library\x00cannot exec a shared library directly\x00attempting to link in too many shared libraries\x00.lib section in a.out corrupted\x00link number out of range\x00too many levels of symbolic links\x00wrong medium type\x00too many open files\x00too many links\x00message too long\x00multihop attempted\x00file name too long\x00not available\x00network is down\x00network dropped connection on reset\x00network is unreachable\x00too many open files in system\x00no anode\x00no buffer space available\x00no CSI structure available\x00no data available\x00no such device\x00no such file or directory\x00exec format error\x00no locks available\x00link has been severed\x00cannot allocate memory\x00no medium found\x00no message of desired type\x00machine is not on the network\x00package not installed\x00protocol not available\x00no space left on device\x00out of streams resources\x00device not a stream\x00function not implemented\x00block device required\x00transport endpoint is not connected\x00not a directory\x00directory not empty\x00not a name file\x00state not recoverable\x00socket operation on non-socket\x00operation not supported\x00inappropriate ioctl for device\x00name not unique on network\x00no such device or address\x00value too large for defined data type\x00owner died\x00operation not permitted\x00protocol family not supported\x00broken pipe\x00protocol error\x00protocol not supported\x00protocol wrong type for socket\x00numerical result out of range\x00remote address changed\x00object is remote\x00remote I/O error\x00interrupted system call should be restarted\x00read-only file system\x00cannot send after transport endpoint shutdown\x00socket type not supported\x00illegal seek\x00no such process\x00srmount error\x00stale file handle\x00streams pipe error\x00timer expired\x00connection timed out\x00too many references: cannot splice\x00text file busy\x00structure needs cleaning\x00protocol driver not attached\x00too many users\x00invalid cross-device link\x00exchange full\x00SIGABRT\x00SIGALRM\x00SIGBUS\x00SIGCHLD\x00SIGCONT\x00SIGFPE\x00SIGHUP\x00SIGILL\x00SIGINT\x00SIGIO\x00SIGKILL\x00SIGPIPE\x00SIGPROF\x00SIGPWR\x00SIGQUIT\x00SIGSEGV\x00SIGSTOP\x00SIGSYS\x00SIGTERM\x00SIGTRAP\x00SIGTSTP\x00SIGTTIN\x00SIGTTOU\x00SIGURG\x00SIGUSR1\x00SIGUSR2\x00SIGVTALRM\x00SIGWINCH\x00SIGXCPU\x00SIGXFSZ\x00unknown signal\x00alarm clock\x00bus error\x00child status changed\x00continue after stop\x00floating-point exception\x00hangup\x00illegal instruction\x00interrupt\x00input/output possible on file\x00kill signal\x00write on pipe with no readers\x00profiling alarm\x00power-fail restart\x00quit signal\x00segmentation violation\x00stop\x00bad argument to system call\x00software termination signal\x00trace trap\x00stop signal from tty\x00background tty read\x00background tty write\x00urgent I/O condition\x00user-defined signal 1\x00user-defined signal 2\x00virtual time alarm\x00window changed\x00exceeded CPU time limit\x00exceeded file size limit\x00Tcl_Release couldn't find reference for %p\x00Tcl_EventuallyFree called twice for %p\x00procbody\x00levelReference\x00lambdaExpr\x00name args body\x00\n    (creating proc \"\x00procedure \"%s\": arg list contains %td entries, precompiled header expects %td\x00BYTECODELIES\x00too many fields in argument specifier \"\x00FORMALARGUMENTFORMAT\x00argument with no name\x00formal parameter \"%s\" is an array element\x00formal parameter \"\x00\" is not a simple name\x00procedure \"%s\": formal parameter %td is inconsistent with precompiled body\x00procedure \"%s\": formal parameter \"\x00\" has default value inconsistent with precompiled body\x00\n    (\"uplevel\" body line %d)\x00?level? command ?arg ...?\x00?\x00?arg ...?\x00body of lambda term\x00body of proc\x00invoked \"%s\" outside of a loop\x00UNEXPECTED\x00a precompiled script jumped interps\x00CROSSINTERPBYTECODE\x00\n    (procedure \"%.*s%s\" line %d)\x00TclUpdateReturnInfo: negative return level\x00can't interpret \"%s\" as a lambda expression\x00LAMBDA\x00\n    (parsing lambda expression \"%s\")\x00lambdaExpr ?arg ...?\x00\n    (lambda term \"%.*s%s\" line %d)\x00child process lost (is SIGCHLD ignored or trapped?)\x00error waiting for process to exit: %s\x00CHILDSTATUS\x00child killed: %s\x00CHILDKILLED\x00child suspended: %s\x00CHILDSUSP\x00child wait status didn't make sense\n\x00ODDWAITRESULT\x00-wait\x00switches\x00?switches? ?pids?\x00?pids?\x00?flag?\x00::tcl::process\x00error while matching regular expression: \x00REG_UBACKREF\x00REG_ULOOKAHEAD\x00REG_UBOUNDS\x00REG_UBRACES\x00REG_UBSALNUM\x00REG_UPBOTCH\x00REG_UBBS\x00REG_UNONPOSIX\x00REG_UUNSPEC\x00REG_UUNPORT\x00REG_ULOCALE\x00REG_UEMPTYMATCH\x00REG_UIMPOSSIBLE\x00REG_USHORTEST\x00%s%s%s\x00cannot compile regular expression pattern: \x00-errorline\x00-errorstack\x00bad %s value: expected dictionary but got \"%s\"\x00ILLEGAL_OPTIONS\x00bad -level value: expected non-negative integer but got \"%s\"\x00ILLEGAL_LEVEL\x00bad -errorcode value: expected a list but got \"%s\"\x00ILLEGAL_ERRORCODE\x00bad -errorstack value: expected a list but got \"%s\"\x00NONLIST_ERRORSTACK\x00forbidden odd-sized list for -errorstack: \"%s\"\x00ODDSIZEDLIST_ERRORSTACK\x00expected dict but got \"%s\"\x00cannot mix \"%\" and \"%n$\" conversion specifiers\x00FORMAT\x00MIXEDSPECTYPES\x00specified field width %llu exceeds limit %td.\x00WIDTHLIMIT\x00field width may not be specified in %c conversion\x00BADWIDTH\x00field size modifier may not be specified in %\x00 conversion\x00BADSIZE\x00unmatched [ in format string\x00BRACKET\x00bad scan conversion character \"\x00BADTYPE\x00variable is assigned by multiple \"%n$\" conversion specifiers\x00POLYASSIGNED\x00variable is not assigned by any conversion specifiers\x00UNASSIGNED\x00\"%n$\" argument index out of range\x00INDEXRANGE\x00different numbers of variable names and field specifiers\x00FIELDVARMISMATCH\x00string format ?varName ...?\x00insufficient memory to create bignum\x00unsigned bignum scans are invalid\x00BADUNSIGNED\x00max size for a Tcl unicode rep (%zd bytes) exceeded\x00Tcl_GetUnicodeFromObj with 'int' lengthPtr cannot handle such long strings. Please use 'Tcl_Size'\x00Tcl_SetStringObj\x00Tcl_SetObjLength: length requested is negative: %td (integer overflow?)\x00Tcl_SetObjLength\x00Tcl_AttemptSetObjLength\x00Tcl_SetUnicodeObj\x00Tcl_AppendLimitedToObj\x00Tcl_AppendUnicodeToObj\x00max size for a Tcl value (%td bytes) exceeded\x00TclAppendUtfToUtf\x00Tcl_AppendStringsToObj\x00max size for a Tcl value exceeded\x00Tcl_AppendFormatToObj\x00format string ended in middle of field specifier\x00INCOMPLETE\x00unsigned bignum format is invalid\x000x\x000b\x000d\x00%lld\x00bad field specifier \"%c\"\x00puoxX\x00Unable to format \"%s\" with supplied arguments: %s\x00string size overflow: unable to alloc %td bytes\x00concatenation failed: unable to alloc %zu bytes\x00concatenation failed: unable to alloc %td bytes\x00str-idx-tree\x00TclParseNumber: bad acceptState %d parsing '%s'\x00TclParseNumber: state INITIAL can't happen here\x00expected %s but got \x00a list\x00Infinity\x00NaN\x00wrong digit!\x00This code doesn't work on a decimal machine!\x00unknown floating point word order on this machine\x00(%lx)\x00alloc: could not allocate new cache\x00alloc: could not allocate %zu new objects\x00shared\x00thread%p\x00%zu %zu %zu %zu %zu %zu\x00alloc: invalid block: %p: %x %x\x00unable to allocate TSDTable\x00unable to reallocate TSDTable\x00List too large to be processed\x00Dict too large to be processed\x00tclAfter\x00bad argument \"%s\": must be cancel, idle, info, or an integer\x00argument\x00after#%d\x00id|command\x00script ?script ...?\x00?id?\x00event \"%s\" doesn't exist\x00timer\x00Tcl_AfterObjCmd: bad subcommand index to afterSubCmds\x00after#\x00\n    (\"after\" script)\x00execution\x00type ?arg ...?\x00type name\x00enter\x00leave\x00enterstep\x00leavestep\x00name opList command\x00bad operation list \"\": must be one or more of enter, leave, enterstep, or leavestep\x00TRACE\x00NOOPS\x00bad operation list \"\": must be one or more of delete or rename\x00bad operation list \"\": must be one or more of array, read, unset, or write\x00 rename\x00 delete\x00TraceExecutionProc: bad flag combination\x00 array\x00 read\x00 write\x00 unset\x00Cannot trace a variable with no name\x00trace array\x00(\x00\n    (%s trace on \"%s%s%s%s\")\x00bad result flag combination\x00end-offset\x00LIST\x00%s element in braces followed by \"%.*s\" instead of space\x00JUNK\x00%s element in quotes followed by \"%.*s\" instead of space\x00unmatched open brace in %s\x00BRACE\x00unmatched open quote in %s\x00QUOTE\x00internal error in Tcl_SplitList\x00INTERNAL\x00Tcl_SplitList\x00Tcl_Merge called with negative argc (%td)\x00Tcl_Concat: max size of Tcl value exceeded\x00 \f\v\r\t\n\x00 {\x00{\x00-Inf\x00Inf\x00e%+d\x00bad index \"%s\": must be integer?[+-]integer? or end?[+-]integer?\x00end-\x00Number of words (%td) in command exceeds limit %td.\x00Number of words in command exceeds limit %td.\x00PGV Initializer did not initialize\x00***=\x00invalid escape sequence\x00BADESCAPE\x00$ not anchor\x00NONANCHOR\x00unhandled RE special char\x00UNHANDLED\x00excessive recursive glob backtrack potential\x00OVERCOMPLEX\x00RE2GLOB\x00localVarName\x00parsedVarName\x00\"%s\" isn't an array\x00VARNAME\x00ELEMENT\x00varPtr must not be NULL\x00part1Ptr must not be NULL\x00READ\x00varName ?newValue?\x00newValuePtr must not be NULL\x00UNSET\x00varName ?value ...?\x00{key value} arrayName script\x00must have two variable names\x00\n    (\"array for\" body line %d)\x00array changed during iteration\x00s-%d-%s\x00arrayName\x00arrayName searchId\x00arrayName ?pattern?\x00arrayName ?mode? ?pattern?\x00exact matching shouldn't get here\x00arrayName list\x00error reading array statistics\x00anymore\x00donesearch\x00nextelement\x00startsearch\x00statistics\x00bad variable name \"%s\": can't create namespace variable that refers to procedure variable\x00UPVAR\x00INVERTED\x00ObjMakeUpvar called with an index outside from a proc\x00bad variable name \"%s\": can't create a scalar variable that looks like an array element\x00LOCAL_ELEMENT\x00can't upvar from variable to itself\x00variable \"%s\" has traces: can't use for upvar\x00TRACED\x00variable \"%s\" already exists\x00EXISTS\x00varName value\x00define\x00?level? otherVar localVar ?otherVar localVar ...?\x00illegal search identifier \"%s\"\x00search identifier \"%s\" isn't for variable \"%s\"\x00couldn't find search \"%s\"\x00ARRAYSEARCH\x00invalid part1Ptr and invalid index together\x00can't %s \"%s%s%s%s\": %s\x00unknown variable \"%s\"\x00lookup\x00option arrayName ?value?\x00array has no default value\x00DEFAULT\x00arrayName value\x00array default set\x00zlib\x00no latin-1 encoding\x00STREAM\x00DATA\x00MEM\x00BUF\x00NEED_DICT\x00%lu\x00unexpected zlib result in error handler: Z_OK\x00unexpected zlib result in error handler: Z_STREAM_END\x00ZLIB\x00text\x00comment\x00Comment contains characters > 0xFF\x00Comment too large for zip\x00crc\x00filename\x00Filename contains characters > 0xFF\x00Filename too large for zip\x00incorrect zlib data format, must be TCL_ZLIB_FORMAT_ZLIB, TCL_ZLIB_FORMAT_GZIP or TCL_ZLIB_FORMAT_RAW\x00compression level should be between 0 (no compression) and 9 (best compression) or -1 for default compression level\x00incorrect zlib data format, must be TCL_ZLIB_FORMAT_ZLIB, TCL_ZLIB_FORMAT_GZIP, TCL_ZLIB_FORMAT_RAW or TCL_ZLIB_FORMAT_AUTO\x00bad mode, must be TCL_ZLIB_STREAM_DEFLATE or TCL_ZLIB_STREAM_INFLATE\x001.3.1\x00::incr ::tcl::zlib::cmdcounter\x00::tcl::zlib::streamcmd_\x00BUG: Stream command name already exists\x00EXISTING_CMD\x00already past compressed stream end\x00ZIP\x00CLOSED\x00unexpected zlib internal state during decompression\x00STATE\x00incorrect zlib data format, must be TCL_ZLIB_FORMAT_ZLIB, TCL_ZLIB_FORMAT_GZIP or TCL_ZLIB_FORMAT_ZLIB\x00compression level should be between 0 (uncompressed) and 9 (best compression) or -1 for default compression level\x00adler32\x00compress\x00crc32\x00decompress\x00deflate\x00gunzip\x00gzip\x00inflate\x00stream\x00command arg ?...?\x00data ?startValue?\x00data ?level?\x00\n    (in -level option)\x00data ?-level level? ?-header header?\x00-header\x00data ?bufferSize?\x00data ?-headerVar varName?\x00-headerVar\x00level must be 0 to 9\x00COMPRESSIONLEVEL\x00buffer size must be %d to %d\x00BUFFERSIZE\x00mode ?-option value...?\x00should be unreachable\x00-limit\x00mode channel ?options...?\x00compression may only be applied to writable channels\x00UNWRITABLE\x00decompression may only be applied to readable channels\x00UNREADABLE\x00value missing for %s option\x00NOVAL\x00read ahead limit must be 1 to %d\x00a compression dictionary may not be set in the gzip format\x00BADOPT\x00\n    (in \x00 option)\x00checksum\x00fullflush\x00header\x00put\x00reset\x00option data ?...?\x00?count?\x00-buffer\x00-finalize\x00-flush\x00-fullflush\x00\"-buffer\" option must be followed by integer decompression buffersize\x00buffer size must be 1 to %d\x00\"-dictionary\" option must be followed by compression dictionary bytes\x00\"-flush\", \"-fullflush\" and \"-finalize\" options are mutually exclusive\x00EXCLUSIVE\x00only gunzip streams can produce header information\x00BADOP\x00error while finalizing file: %s\x00problem flushing channel: %s\x00dictionary flush\x00dictionary limit\x00flush limit\x00sync\x00unknown -flush type \"%s\": must be full or sync\x00FLUSH\x00-limit must be between 1 and 65536\x00READLIMIT\x00checksum dictionary\x00checksum dictionary limit\x00checksum header limit\x00-checksum\x00unknown mode: %d\x00bad format: %d\x00namespace eval ::tcl::zlib {variable cmdcounter 0}\x00zlibVersion\x00zlibStream\x00tcl::zlib\x002.0.1\x00tcl::tommath\x00zip\x00//zipfs:/\x00out of bounds read(4): start=%p, end=%p, ptr=%p\x00out of bounds read(2): start=%p, end=%p, ptr=%p\x00out of bounds write(4): start=%p, end=%p, ptr=%p\x00out of bounds write(2): start=%p, end=%p, ptr=%p\x00invalid password\x00ZIPFS\x00PASSWORD\x00cp437\x00//zipfs:/%s\x00Invalid mount path \"%s\"\x00MOUNT_PATH\x00MALLOC\x00archive directory end signature not found\x00END_SIG\x00empty archive\x00archive directory truncated\x00NO_DIR\x00truncated directory\x00TRUNC_DIR\x00wrong header signature\x00HDR_SIG\x00Failed to find local header\x00LCL_HDR\x00short file count\x00FILE_COUNT\x00seek error\x00illegal file size\x00FILE_SIZE\x00file read error\x00failed to retrieve file size\x00truncated file\x00file mapping failed\x00illegal password\x00BAD_PASS\x00bad zip data\x00BAD_ZIP\x00%s is already mounted on %s\x00MOUNTED\x00could not normalize zip filename \"%s\"\x00NORMALIZE\x00mount point and/or data are null\x00Memory Buffer\x00filesystem is busy\x00?zipfile? ?mountpoint? ?password?\x00data mountpoint\x00mountpoint\x00password\x00::tcl::mathfunc::rand\x00\n    (evaluating PRNG step %d for password encoding)\x00path too long for \"%s\"\x00PATH_LEN\x00read error on \"%s\": %s\x00seek error on \"%s\": %s\x00write error on \"%s\": %s\x00compression init error on \"%s\"\x00DEFLATE_INIT\x00deflate error on \"%s\"\x00DEFLATE\x00seek error: %s\x00non-unique path name \"%s\"\x00DUPLICATE_PATH\x00write error: %s\x00::tcl::zipfs::find\x00need even number of elements\x00LIST_LENGTH\x00read error\x00write error\x00outfile indir ?strip? ?password?\x00operation not permitted in a safe interpreter\x00SAFE_INTERP\x00outfile inlist ?password?\x00outfile indir ?strip? ?password? ?infile?\x00outfile inlist ?password? ?infile?\x00?mountpoint? filename\x00path \"%s\" not found in any zipfs volume\x00?(-glob|-regexp)? ?pattern?\x00//zipfs:/app/tcl_library/init.tcl\x00//zipfs:/app/tcl_library\x00writes not permitted: %s\x00Invalid flags 0x%x. O_APPEND and O_TRUNC require write access: %s\x00created\x00found\x00file \"%s\" not %s: %s\x00file size error (may be zip64)\x00unsupported file type: %s\x00unsupported compression method\x00COMP_METHOD\x00file size exceeds max writable\x00decryption failed: truncated decryption header\x00DECRYPT\x00decryption failed - no password provided\x00invalid CRC\x00CRC_FAILED\x00zipfs_%zx_%d\x00decompression error\x00CORRUPT\x00Internal error: TCL_GLOB_TYPE_MOUNT should not be set in conjunction with other glob types.\x00-uncompsize\x00-compsize\x00-offset\x00-mount\x00-archive\x00-crc\x00file not found\x000o555\x00unknown attribute\x00FILE_ATTR\x00unsupported operation\x00::tcl::zipfs::wrmax\x00::tcl::zipfs::fallbackEntryEncoding\x00find\x00::tcl::zipfs::tcl_library_init\x00//zipfs:/app\x00//zipfs:/app/main.tcl\x00-stat\x00couldn't read file channel status: %s\x00TclpOpenFileChannel: invalid mode value\x00couldn't open \"\x00\": filename is invalid on this platform\x00file%d\x00TclGetDefaultStdChannel: Unexpected channel type\x00auto crlf\x00\"%s\" wasn't opened for writing\x00NOT_WRITABLE\x00\"%s\" wasn't opened for reading\x00NOT_READABLE\x00cannot get a FILE * for \"%s\"\x00FILE_FAILURE\x00\"%s\" cannot be used to get a FILE *\x00NO_DESCRIPTOR\x00-group\x00-owner\x00%0#5o\x00could not set group for file \"%s\": group \"%s\" does not exist\x00SETGRP\x00NO_GROUP\x00could not set group for file \"%s\": %s\x00could not set owner for file \"%s\": user \"%s\" does not exist\x00SETOWN\x00NO_USER\x00could not set owner for file \"%s\": %s\x00unknown permission string format \"%s\"\x00PERMISSION\x00could not set permissions for file \"%s\": %s\x00_XXXXXX\x00TMPDIR\x00/tmp\x00:/bin:/usr/bin\x00couldn't read directory \"%s\": %s\x00couldn't create temporary file: %s\x00pipe creation failed: %s\x00?channel?\x00::tcl::unsupported::noReverseDNS\x00-keepalive\x00couldn't set socket option: %s\x00-nodelay\x00keepalive nodelay\x00-connecting\x00-peername\x00can't get peername: %s\x00-sockname\x00can't get sockname: %s\x00connecting keepalive nodelay peername sockname\x00couldn't open socket: %s\x00sock%zx\x00invalid port number\x00couldn't open socket: \x00ansi-1251\x00cp1251\x00ansi_x3.4-1968\x00big5\x00cp1250\x00cp1252\x00cp1253\x00cp1254\x00cp1255\x00cp1256\x00cp1257\x00cp1258\x00cp737\x00cp775\x00cp850\x00cp852\x00cp855\x00cp857\x00cp860\x00cp861\x00cp862\x00cp863\x00cp864\x00cp865\x00cp866\x00cp869\x00cp874\x00cp932\x00cp936\x00cp949\x00cp950\x00dingbats\x00ebcdic\x00euc-cn\x00euc-jp\x00euc-kr\x00eucjp\x00euckr\x00euctw\x00gb12345\x00gb1988\x00gb2312\x00gb2312-1980\x00gb2312-raw\x00greek8\x00ibm1250\x00ibm1251\x00ibm1252\x00ibm1253\x00ibm1254\x00ibm1255\x00ibm1256\x00ibm1257\x00ibm1258\x00ibm437\x00ibm737\x00ibm775\x00ibm850\x00ibm852\x00ibm855\x00ibm857\x00ibm860\x00ibm861\x00ibm862\x00ibm863\x00ibm864\x00ibm865\x00ibm866\x00ibm869\x00ibm874\x00ibm932\x00ibm936\x00ibm949\x00ibm950\x00iso-2022\x00iso2022\x00iso-2022-jp\x00iso2022-jp\x00iso-2022-kr\x00iso2022-kr\x00iso-8859-1\x00iso-8859-10\x00iso8859-10\x00iso-8859-13\x00iso8859-13\x00iso-8859-14\x00iso8859-14\x00iso-8859-15\x00iso8859-15\x00iso-8859-16\x00iso8859-16\x00iso-8859-2\x00iso8859-2\x00iso-8859-3\x00iso8859-3\x00iso-8859-4\x00iso8859-4\x00iso-8859-5\x00iso8859-5\x00iso-8859-6\x00iso8859-6\x00iso-8859-7\x00iso8859-7\x00iso-8859-8\x00iso8859-8\x00iso-8859-9\x00iso8859-9\x00iso88591\x00iso885915\x00iso88592\x00iso88595\x00iso88596\x00iso88597\x00iso88598\x00iso88599\x00ja\x00ja_jp\x00ja_jp.euc\x00ja_jp.eucjp\x00ja_jp.jis\x00ja_jp.mscode\x00shiftjis\x00ja_jp.sjis\x00ja_jp.ujis\x00japan\x00japanese\x00japanese-sjis\x00japanese-ujis\x00japanese.euc\x00japanese.sjis\x00jis0201\x00jis0208\x00jis0212\x00jp_jp\x00ko\x00ko_kr\x00ko_kr.euc\x00ko_kw.euckw\x00koi8-r\x00koi8-u\x00korean\x00ksc5601\x00maccenteuro\x00macCentEuro\x00maccroatian\x00macCroatian\x00maccyrillic\x00macCyrillic\x00macdingbats\x00macDingbats\x00macgreek\x00macGreek\x00maciceland\x00macIceland\x00macjapan\x00macJapan\x00macroman\x00macRoman\x00macromania\x00macRomania\x00macthai\x00macThai\x00macturkish\x00macTurkish\x00macukraine\x00macUkraine\x00roman8\x00ru\x00ru_ru\x00ru_su\x00sjis\x00symbol\x00tis-620\x00tis620\x00turkish8\x00utf8\x00zh\x00zh_cn.gb2312\x00zh_cn.gbk\x00zh_cz.gb2312\x00zh_tw\x00euc-tw\x00zh_tw.big5\x00/dev/null\x00TCL_LIBRARY\x00lib/tcl%s\x00LC_ALL\x00LC_CTYPE\x00LANG\x00unix\x00pathSeparator\x00could not allocate lock\x00unable to allocate thread key!\x00unable to create pthread key!\x00unable to delete key!\x00unable to set global TSD value\x00%s: unable to start notifier thread\x00Tcl_ServiceModeHook\x00AtForkChild\x00Tcl_InitNotifier: %s\x00pthread_atfork failed\x00Tcl_FinalizeNotifier: %s\x00unable to write 'q' to triggerPipe\x00unable to join notifier thread\x00Tcl_WaitForEvent\x00Tcl_WaitForEvent: %s\x00unable to write to triggerPipe\x00S\x00NotifierThreadProc: %s\x00could not create trigger pipe\x00could not make receive pipe non blocking\x00could not make trigger pipe non blocking\x00could not make receive pipe close-on-exec\x00could not make trigger pipe close-on-exec\x00definitionnamespace\x00deletemethod\x00forward\x00private\x00renamemethod\x00self\x00unexport\x00destroy\x00core method: \"destroy\"\x00core method: \"eval\"\x00core method: \"unknown\"\x00core method: \"variable\"\x00core method: \"varname\"\x00core method: \"create\"\x00new\x00core method: \"new\"\x00createWithNamespace\x00core method: \"createWithNamespace\"\x00core method: \"configure\"\x00oo::class constructor\x00::namespace eval ::oo {\n\t::namespace path {}\n\tnamespace eval Helpers {\n\t\tnamespace path {}\n\t\tproc callback {method args} {\n\t\t\tlist [uplevel 1 {::namespace which my}] $method {*}$args\n\t\t}\n\t\tnamespace export callback\n\t\tnamespace eval tmp {namespace import ::oo::Helpers::callback}\n\t\tnamespace export -clear\n\t\trename tmp::callback mymethod\n\t\tnamespace delete tmp\n\t\tproc classvariable {name args} {\n\t\t\tset ns [info object namespace [uplevel 1 {self class}]]\n\t\t\tforeach v [list $name {*}$args] {\n\t\t\t\tif {[string match *(*) $v]} {\n\t\t\t\t\tset reason \"can't create a scalar variable that looks like an array element\"\n\t\t\t\t\treturn -code error -errorcode {TCL UPVAR LOCAL_ELEMENT} \\\n\t\t\t\t\t\t[format {bad variable name \"%s\": %s} $v $reason]\n\t\t\t\t}\n\t\t\t\tif {[string match *::* $v]} {\n\t\t\t\t\tset reason \"can't create a local variable with a namespace separator in it\"\n\t\t\t\t\treturn -code error -errorcode {TCL UPVAR INVERTED} \\\n\t\t\t\t\t\t[format {bad variable name \"%s\": %s} $v $reason]\n\t\t\t\t}\n\t\t\t\tlappend vs $v $v\n\t\t\t}\n\t\t\ttailcall namespace upvar $ns {*}$vs\n\t\t}\n\t\tproc link {args} {\n\t\t\tset ns [uplevel 1 {::namespace current}]\n\t\t\tforeach link $args {\n\t\t\t\tif {[llength $link] == 2} {\n\t\t\t\t\tlassign $link src dst\n\t\t\t\t} elseif {[llength $link] == 1} {\n\t\t\t\t\tlassign $link src\n\t\t\t\t\tset dst $src\n\t\t\t\t} else {\n\t\t\t\t\treturn -code error -errorcode {TCL OO CMDLINK_FORMAT} \\\n\t\t\t\t\t\t\"bad link description; must only have one or two elements\"\n\t\t\t\t}\n\t\t\t\tif {![string match ::* $src]} {\n\t\t\t\t\tset src [string cat $ns :: $src]\n\t\t\t\t}\n\t\t\t\tinterp alias {} $src {} ${ns}::my $dst\n\t\t\t\ttrace add command ${ns}::my delete [list \\\n\t\t\t\t\t::oo::UnlinkLinkedCommand $src]\n\t\t\t}\n\t\t\treturn\n\t\t}\n\t}\n\tproc UnlinkLinkedCommand {cmd args} {\n\t\tif {[namespace which $cmd] ne {}} {\n\t\t\trename $cmd {}\n\t\t}\n\t}\n\tproc DelegateName {class} {\n\t\tstring cat [info object namespace $class] {:: oo ::delegate}\n\t}\n\tproc MixinClassDelegates {class} {\n\t\tif {![info object isa class $class]} {\n\t\t\treturn\n\t\t}\n\t\tset delegate [DelegateName $class]\n\t\tif {![info object isa class $delegate]} {\n\t\t\treturn\n\t\t}\n\t\tforeach c [info class superclass $class] {\n\t\t\tset d [DelegateName $c]\n\t\t\tif {![info object isa class $d]} {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tdefine $delegate ::oo::define::superclass -appendifnew $d\n\t\t}\n\t\tobjdefine $class ::oo::objdefine::mixin -appendifnew $delegate\n\t}\n\tproc UpdateClassDelegatesAfterClone {originObject targetObject} {\n\t\tset originDelegate [DelegateName $originObject]\n\t\tset targetDelegate [DelegateName $targetObject]\n\t\tif {\n\t\t\t[info object isa class $originDelegate]\n\t\t\t&& ![info object isa class $targetDelegate]\n\t\t} then {\n\t\t\tcopy $originDelegate $targetDelegate\n\t\t\tobjdefine $targetObject ::oo::objdefine::mixin -set \\\n\t\t\t\t{*}[lmap c [info object mixin $targetObject] {\n\t\t\t\t\tif {$c eq $originDelegate} {set targetDelegate} {set c}\n\t\t\t\t}]\n\t\t}\n\t}\n\tproc define::classmethod {name args} {\n\t\t::set argc [::llength [::info level 0]]\n\t\t::if {$argc == 3} {\n\t\t\t::return -code error -errorcode {TCL WRONGARGS} [::format \\\n\t\t\t\t{wrong # args: should be \"%s name ?args body?\"} \\\n\t\t\t\t[::lindex [::info level 0] 0]]\n\t\t}\n\t\t::set cls [::uplevel 1 self]\n\t\t::if {$argc == 4} {\n\t\t\t::oo::define [::oo::DelegateName $cls] method $name {*}$args\n\t\t}\n\t\t::tailcall forward $name myclass $name\n\t}\n\tproc define::initialise {body} {\n\t\t::set clsns [::info object namespace [::uplevel 1 self]]\n\t\t::tailcall apply [::list {} $body $clsns]\n\t}\n\tnamespace eval define {\n\t\t::namespace export initialise\n\t\t::namespace eval tmp {::namespace import ::oo::define::initialise}\n\t\t::namespace export -clear\n\t\t::rename tmp::initialise initialize\n\t\t::namespace delete tmp\n\t}\n\tdefine Slot {\n\t\tmethod Get -unexport {} {\n\t\t\treturn -code error -errorcode {TCL OO ABSTRACT_SLOT} \"unimplemented\"\n\t\t}\n\t\tmethod Set -unexport list {\n\t\t\treturn -code error -errorcode {TCL OO ABSTRACT_SLOT} \"unimplemented\"\n\t\t}\n\t\tmethod Resolve -unexport list {\n\t\t\treturn $list\n\t\t}\n\t\tmethod -set -export args {\n\t\t\tset my [namespace which my]\n\t\t\tset args [lmap a $args {uplevel 1 [list $my Resolve $a]}]\n\t\t\ttailcall my Set $args\n\t\t}\n\t\tmethod -append -export args {\n\t\t\tset my [namespace which my]\n\t\t\tset args [lmap a $args {uplevel 1 [list $my Resolve $a]}]\n\t\t\tset current [uplevel 1 [list $my Get]]\n\t\t\ttailcall my Set [list {*}$current {*}$args]\n\t\t}\n\t\tmethod -appendifnew -export args {\n\t\t\tset my [namespace which my]\n\t\t\tset current [uplevel 1 [list $my Get]]\n\t\t\tforeach a $args {\n\t\t\t\tset a [uplevel 1 [list $my Resolve $a]]\n\t\t\t\tif {$a ni $current} {\n\t\t\t\t\tlappend current $a\n\t\t\t\t}\n\t\t\t}\n\t\t\ttailcall my Set $current\n\t\t}\n\t\tmethod -clear -export {} {tailcall my Set {}}\n\t\tmethod -prepend -export args {\n\t\t\tset my [namespace which my]\n\t\t\tset args [lmap a $args {uplevel 1 [list $my Resolve $a]}]\n\t\t\tset current [uplevel 1 [list $my Get]]\n\t\t\ttailcall my Set [list {*}$args {*}$current]\n\t\t}\n\t\tmethod -remove -export args {\n\t\t\tset my [namespace which my]\n\t\t\tset args [lmap a $args {uplevel 1 [list $my Resolve $a]}]\n\t\t\tset current [uplevel 1 [list $my Get]]\n\t\t\ttailcall my Set [lmap val $current {\n\t\t\t\tif {$val in $args} continue else {set val}\n\t\t\t}]\n\t\t}\n\t\tforward --default-operation my -append\n\t\tmethod unknown -unexport {args} {\n\t\t\tset def --default-operation\n\t\t\tif {[llength $args] == 0} {\n\t\t\t\ttailcall my $def\n\t\t\t} elseif {![string match -* [lindex $args 0]]} {\n\t\t\t\ttailcall my $def {*}$args\n\t\t\t}\n\t\t\tnext {*}$args\n\t\t}\n\t\tunexport destroy\n\t}\n\tobjdefine define::superclass forward --default-operation my -set\n\tobjdefine define::mixin forward --default-operation my -set\n\tobjdefine objdefine::mixin forward --default-operation my -set\n\tdefine object method <cloned> -unexport {originObject} {\n\t\tforeach p [info procs [info object namespace $originObject]::*] {\n\t\t\tset args [info args $p]\n\t\t\tset idx -1\n\t\t\tforeach a $args {\n\t\t\t\tif {[info default $p $a d]} {\n\t\t\t\t\tlset args [incr idx] [list $a $d]\n\t\t\t\t} else {\n\t\t\t\t\tlset args [incr idx] [list $a]\n\t\t\t\t}\n\t\t\t}\n\t\t\tset b [info body $p]\n\t\t\tset p [namespace tail $p]\n\t\t\tproc $p $args $b\n\t\t}\n\t\tforeach v [info vars [info object namespace $originObject]::*] {\n\t\t\tupvar 0 $v vOrigin\n\t\t\tnamespace upvar [namespace current] [namespace tail $v] vNew\n\t\t\tif {[info exists vOrigin]} {\n\t\t\t\tif {[array exists vOrigin]} {\n\t\t\t\t\tarray set vNew [array get vOrigin]\n\t\t\t\t} else {\n\t\t\t\t\tset vNew $vOrigin\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tdefine class method <cloned> -unexport {originObject} {\n\t\tnext $originObject\n\t\t::oo::UpdateClassDelegatesAfterClone $originObject [self]\n\t}\n\tclass create singleton {\n\t\tsuperclass class\n\t\tvariable object\n\t\tunexport create createWithNamespace\n\t\tmethod new args {\n\t\t\tif {![info exists object] || ![info object isa object $object]} {\n\t\t\t\tset object [next {*}$args]\n\t\t\t\t::oo::objdefine $object {\n\t\t\t\t\tmethod destroy {} {\n\t\t\t\t\t\t::return -code error -errorcode {TCL OO SINGLETON} \\\n\t\t\t\t\t\t\t\"may not destroy a singleton object\"\n\t\t\t\t\t}\n\t\t\t\t\tmethod <cloned> -unexport {originObject} {\n\t\t\t\t\t\t::return -code error -errorcode {TCL OO SINGLETON} \\\n\t\t\t\t\t\t\t\"may not clone a singleton object\"\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn $object\n\t\t}\n\t}\n\tclass create abstract {\n\t\tsuperclass class\n\t\tunexport create createWithNamespace new\n\t}\n\tnamespace eval configuresupport {\n\t\t::namespace eval configurableclass {\n\t\t\t::proc properties args {::tailcall property {*}$args}\n\t\t\t::namespace path ::oo::define\n\t\t\t::namespace export property\n\t\t}\n\t\t::namespace eval configurableobject {\n\t\t\t::proc properties args {::tailcall property {*}$args}\n\t\t\t::namespace path ::oo::objdefine\n\t\t\t::namespace export property\n\t\t}\n\t\t::oo::define configurable {\n\t\t\tdefinitionnamespace -instance configurableobject\n\t\t\tdefinitionnamespace -class configurableclass\n\t\t}\n\t}\n\tclass create configurable {\n\t\tsuperclass class\n\t\tconstructor {{definitionScript \"\"}} {\n\t\t\tnext {mixin ::oo::configuresupport::configurable}\n\t\t\tnext $definitionScript\n\t\t}\n\t\tdefinitionnamespace -class configuresupport::configurableclass\n\t}\n}\n\x00TclOO\x001.3.0\x00tcl::oo\x00must supply at least one implementation function\x00::oo\x00[a-z]*\x00::oo::define\x00::oo::objdefine\x00::oo::Helpers\x00::oo::configuresupport\x00<constructor>\x00<destructor>\x00<cloned>\x00my\x00::oo::MixinClassDelegates\x00UnknownDefinition\x00::oo::UnknownDefinition\x00nextto\x00objdefine\x00::oo::configuresupport::configurable\x00::oo::configuresupport::configurableobject::property\x00::oo::configuresupport::configurableclass::property\x00::oo::Obj%zu\x00myclass\x00deleting class structure for non-deleted %s\x00::oo::class\x00::oo::object\x00can't create object \"%s\": command already exists with that name\x00OVERWRITE_OBJECT\x00object deleted in constructor\x00STILLBORN\x00may not clone the class of classes\x00CLONING_CLASS\x00\n    (while performing post-copy callback)\x00methodName ?arg ...?\x00\n    (while mapping method name)\x00impossible to invoke method \"%s\": no defined method or unknown method\x00METHOD_MAPPED\x00no valid method implementation\x00%s does not refer to an object\x00OBJECT\x00?definitionScript?\x00%s:: oo ::delegate\x00object \"%s\" is not a class\x00INSTANTIATE_NONCLASS\x00objectName ?arg ...?\x00object name must not be empty\x00EMPTY_NAME\x00objectName namespaceName ?arg ...?\x00namespace name must not be empty\x00\n    (in \"%s eval\" script line %d)\x00method ?arg ...?\x00visible methods\x00methods\x00object \"%s\" has no %s\x00unknown method \"%s\": must be \x00?varName ...?\x00variable name \"%s\" illegal: must not contain namespace separator\x00%s::%s\x00refer to\x00(%s)\x00%s may only be called from inside a method\x00class ?arg...?\x00call\x00caller\x00method not defined by a class\x00UNMATCHED_CONTEXT\x00not inside a filtering context\x00caller is not an object\x00method without declarer!\x00filtering call chain without terminal non-filter\x00sourceName ?targetName? ?targetNamespace?\x00%s refers to an existing namespace\x00TclOO method name\x00::oo::define::filter\x00core method: define::filter Getter\x00core method: define::filter Setter\x00core method: define::filter Resolver\x00::oo::define::mixin\x00core method: define::mixin Getter\x00core method: define::mixin Setter\x00core method: define::mixin Resolver\x00::oo::define::superclass\x00core method: define::superclass Getter\x00core method: define::superclass Setter\x00core method: define::superclass Resolver\x00::oo::define::variable\x00core method: define::variable Getter\x00core method: define::variable Setter\x00core method: define::variable Resolver\x00::oo::objdefine::filter\x00core method: objdefine::filter Getter\x00core method: objdefine::filter Setter\x00core method: objdefine::filter Resolver\x00::oo::objdefine::mixin\x00core method: objdefine::mixin Getter\x00core method: objdefine::mixin Setter\x00core method: objdefine::mixin Resolver\x00::oo::objdefine::variable\x00core method: objdefine::variable Getter\x00core method: objdefine::variable Setter\x00core method: objdefine::variable Resolver\x00::oo::configuresupport::readableproperties\x00core method: configuresupport::readableproperties Getter\x00core method: configuresupport::readableproperties Setter\x00core method: configuresupport::readableproperties Resolver\x00::oo::configuresupport::writableproperties\x00core method: configuresupport::writableproperties Getter\x00core method: configuresupport::writableproperties Setter\x00core method: configuresupport::writableproperties Resolver\x00::oo::configuresupport::objreadableproperties\x00core method: configuresupport::objreadableproperties Getter\x00core method: configuresupport::objreadableproperties Setter\x00core method: configuresupport::objreadableproperties Resolver\x00::oo::configuresupport::objwritableproperties\x00core method: configuresupport::objwritableproperties Getter\x00core method: configuresupport::objwritableproperties Setter\x00core method: configuresupport::objwritableproperties Resolver\x00%d : %s\x00method %s does not exist\x00cannot rename method to itself\x00RENAME_TO_SELF\x00method called %s already exists\x00RENAME_OVER\x00bad call of unknown handler\x00BAD_UNKNOWN\x00no definition namespace available\x00MONKEY_BUSINESS\x00this command may only be called from within the context of an ::oo::define or ::oo::objdefine command\x00this command cannot be called when the object has been deleted\x00attempt to misuse API\x00getting outer context when already in global context\x00\n    (in definition script for %s \"%.*s%s\" line %d)\x00className arg ?arg ...?\x00%s does not refer to a class\x00objectName arg ?arg ...?\x00class object\x00may not modify the class of the root object class\x00may not modify the class of the class of classes\x00the class of an object must be a class\x00may not change classes into an instance of themselves\x00arguments body\x00-class\x00-instance\x00may not modify the definition namespace of the root classes\x00?kind? namespace\x00kind\x00name cmdName ?arg ...?\x00-export\x00-private\x00-unexport\x00name ?option? args body\x00export flag\x00::oo::Slot\x00Get\x00Set\x00Resolve\x00filterList\x00mixinList\x00may only mix in classes\x00class should only be a direct mixin once\x00REPETITIOUS\x00may not mix a class into itself\x00SELF_MIXIN\x00superclassList\x00may not modify the superclass of the root object\x00only a class can be a superclass\x00class should only be a direct superclass once\x00attempt to form circular dependency graph\x00invalid declared variable name \"%s\": must not %s\x00contain namespace separators\x00BAD_DECLVAR\x00*(*)\x00refer to an array element\x00variableList\x00slotElement\x00USER SHOULD NOT SEE THIS MESSAGE\x00propertyList\x00creationid\x00definition\x00filters\x00isa\x00methodtype\x00mixins\x00properties\x00instances\x00subclasses\x00superclasses\x00::oo::InfoObject\x00::oo::InfoClass\x00objName ?className?\x00objName methodName\x00definition not available for this kind of method\x00objName\x00prefix argument list not available for this kind of method\x00metaclass\x00mixin\x00typeof\x00category objName ?arg ...?\x00category\x00objName className\x00-localprivate\x00-scope\x00public\x00unexported\x00objName ?-option value ...?\x00missing option for -scope\x00scope\x00objName ?-private?\x00option \"%s\" is not exactly \"-private\"\x00BAD_ARG\x00objName ?pattern?\x00METHOD_TYPE\x00className ?kind?\x00className ?pattern?\x00className ?-option value ...?\x00className ?-private?\x00cannot construct any call chain\x00BAD_CALL_CHAIN\x00%s: Wrong version in typePtr->version, should be %s\x00Tcl_NewInstanceMethod\x00TCL_OO_METHOD_VERSION_1\x00Tcl_NewInstanceMethod2\x00TCL_OO_METHOD_VERSION_2\x00Tcl_NewMethod\x00Tcl_NewMethod2\x00instance\x00unknown or deleted\x00\n    (%s \"%.*s%s\" method \"%.*s%s\" line %d)\x00\n    (%s \"%.*s%s\" %s line %d)\x00method forward prefix must be non-empty\x00BAD_FORWARD\x00Tcl_MethodIsType\x00Tcl_MethodIsType2\x00PropertyGetter\x00PropertySetter\x00<ReadProp%s>\x00property getter for %s did a break\x00property getter for %s did a continue\x00<WriteProp%s>\x00property setter for %s did a break\x00property setter for %s did a continue\x00property\x00property \"%s\" is %s only\x00<ReadProp-%s>\x00<WriteProp-%s>\x00shared property list cannot be sorted\x00-*\x00must not begin with -\x00must be a simple word\x00*::*\x00must not contain namespace separators\x00*[()]*\x00must not contain parentheses\x00bad property name \"%s\": %s\x00PROPERTY_FORMAT\x00-get\x00-kind\x00-set\x00readwrite\x00kind value\x00missing %s to go with %s option\x00-%s\x00className ?options...?\x00objName ?options...?\x00dynamic loading is not currently available on this system\x000123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+/\x00"